Pseudocode (program ပုံစံ ရိုးရိုးစာနဲ့ ရေးတဲ့ algorithm)

Pairs with B1.1.4 (tracing flowcharts): pseudocode is the text version of a flowchart. It also supports B1.1.2 (algorithmic design, planning the steps that solve a problem). The current syllabus does not list pseudocode as a topic of its own. It is a planning skill, and finished code in the course is written in Java or Python.
မြန်မာလို: B1.1.4 (flowchart (လုပ်ငန်းစဉ်ကို သင်္ကေတတွေနဲ့ ဆွဲပြတဲ့ ပုံ) တွေကို trace (တစ်ဆင့်ချင်း လိုက်ပြီး မှတ်) လုပ်ခြင်း) နဲ့ တွဲလျက် ဖြစ်ပါတယ်: pseudocode (program ပုံစံ ရိုးရိုးစာနဲ့ ရေးတဲ့ algorithm) ဆိုတာ flowchart ရဲ့ စာသား ပုံစံပါ။ B1.1.2 (algorithmic design: ပြဿနာကို ဖြေရှင်းမယ့် အဆင့်တွေကို စီစဉ်ခြင်း) ကိုလည်း ထောက်ကူပါတယ်။ လက်ရှိ သင်ရိုးမှာ pseudocode ကို သီးခြား ခေါင်းစဉ် တစ်ခုအဖြစ် မထည့်ထားပါဘူး။ Pseudocode က စီစဉ်တဲ့ ကျွမ်းကျင်မှု တစ်ခုဖြစ်ပြီး ဒီသင်တန်းမှာ ပြီးပြည့်စုံတဲ့ code ကို Java ဒါမှမဟုတ် Python နဲ့ ရေးပါတယ်။ B1.1.4 နဲ့ B1.1.2 က IB Computer Science (နိုင်ငံတကာ ကျောင်းတွေမှာ သင်တဲ့ ကွန်ပျူတာသိပ္ပံ သင်ရိုး) ရဲ့ သင်ရိုးထဲက အပိုင်း နံပါတ်တွေပါ။

IB Computer Science သင်တန်းမှာ algorithm (အယ်လ်ဂိုရီသမ်၊ ပြဿနာကို အဆင့်ဆင့် ဖြေရှင်းတဲ့ နည်းလမ်း) တွေကို ကြိုတင် စီစဉ်ပြီး ရေးပြဖို့ pseudocode ကို သုံးပါတယ်။ Programming language တစ်ခုနဲ့ မရေးခင် algorithm တစ်ခုကို ရှင်းရှင်းလင်းလင်း ကြိုတင် စီစဉ်ဖို့ ဘယ်သူမဆို သုံးနိုင်တဲ့ နည်းလမ်း တစ်ခုလည်း ဖြစ်ပါတယ်။

မာတိကာ

ခြုံငုံ မိတ်ဆက်
Pseudocode ဆိုတာ ဘာလဲ (ဘာ မဟုတ်လဲ)
အသုံးများတဲ့ Keyword အစု
အခြေခံ အစိတ်အပိုင်း သုံးခု
Pseudocode ကနေ တကယ့် code အဖြစ်
Pseudocode ကို ဖတ်ခြင်းနဲ့ Trace လုပ်ခြင်း
Pseudocode၊ Flowchart ဒါမှမဟုတ် Code: ဘယ်ဟာကို ဘယ်အချိန် သုံးမလဲ
Quick Check (အမြန် စစ်ဆေးမေးခွန်း)
Trace Exercise (code ကို တစ်ဆင့်ချင်း လိုက်ကြည့်ခြင်း)
Code Completion (code ကွက်လပ် ဖြည့်ခြင်း)
Practice Exercises (လေ့ကျင့်ခန်းများ)
ဆက်စပ် ခေါင်းစဉ်များ

ခြုံငုံ မိတ်ဆက်

တကယ့် code ကို မရေးခင် code က ဘာလုပ်သင့်လဲ ဆိုတာကို အရင် စဉ်းစား ဆုံးဖြတ်ဖို့ လိုပါတယ်။ Pseudocode ဆိုတာ IF နဲ့ WHILE လို ပုံသေ keyword (အထူး အဓိပ္ပာယ်ရှိတဲ့ စကားလုံး) အနည်းငယ်နဲ့အတူ အဆင့်တွေကို ရိုးရိုး English စာကြောင်း တိုတိုလေးတွေနဲ့ ချရေးတဲ့ နည်းလမ်းပါ။ Programming language တစ်ခုရဲ့ တိကျတဲ့ စည်းမျဉ်းတွေကို စိတ်ပူစရာ မလိုဘဲ စီစဉ်နိုင်ပါတယ်။

Flowchart တစ်ခုက algorithm တစ်ခုကို ပုံအဖြစ် ပြပါတယ်။ Pseudocode က အဲဒီ algorithm တစ်ခုတည်းကိုပဲ စာသားအဖြစ် ပြပါတယ်။ နှစ်ခုလုံးက စီစဉ်ဖို့ ကိရိယာတွေပါ: Java ဒါမှမဟုတ် Python ဘာမှ မရေးခင် အဆင့်တွေကို သေချာ စဉ်းစားဖို့၊ အမှားတွေကို ရှာဖို့နဲ့ ကိုယ့် စိတ်ကူးကို တခြားသူကို ရှင်းပြဖို့ ကူညီပါတယ်။ Pseudocode မှာ နောက်ထပ် အားသာချက် တစ်ခု ရှိပါတယ်: သူ့ စာကြောင်းတွေက တကယ့် code နဲ့ နီးစပ်လို့ ဘာသာပြန်တာ (အဆင့် တစ်ခုချင်းစီကို Java ဒါမှမဟုတ် Python နဲ့ ပြန်ရေးတာ) က များသောအားဖြင့် လွယ်ကူပါတယ်။

IB Computer Science ရဲ့ Internal Assessment (IA၊ IB သင်တန်းမှာ ကျောင်းသားတစ်ယောက်ချင်း ကိုယ်တိုင် တည်ဆောက်ရပြီး ကျောင်းက ဆရာက အမှတ်ပေးတဲ့ အပိုင်း) မှာ Criterion C: System overview (အမှတ်ပေး စံနှုန်း C: စနစ်ရဲ့ ခြုံငုံ ဖော်ပြချက်) က ကိုယ့် ဒီဇိုင်းထဲက algorithm တွေကို တင်ပြနိုင်တဲ့ နည်းလမ်း တစ်ခုအဖြစ် pseudocode ကို ဖော်ပြထားပါတယ်။ Natural language (သာမန် စာကြောင်းတွေ) နဲ့ flowchart တွေက နောက်ထပ် နည်းလမ်း နှစ်ခုပါ။

Pseudocode အတွက် တရားဝင် စံ တစ်ခုတည်း မရှိလို့ လူတွေ ရေးပုံ ကွဲပြားပါတယ်။ အဓိပ္ပာယ် တစ်မျိုးတည်းပဲ ဖတ်လို့ရတဲ့ အဆင့်တွေကို ရေးပြီး keyword နဲ့ သင်္ကေတတွေကို အစအဆုံး တစ်ပုံစံတည်း သုံးပါ။ ဒီစာမျက်နှာက အောက်မှာ ဖော်ပြထားတဲ့ convention (အများ လိုက်နာတဲ့ ရေးထုံး) တွေကို သုံးပါတယ်။ တခြား စာမျက်နှာတွေနဲ့ စာအုပ်တွေမှာ နည်းနည်း ကွာပါတယ်: INPUT နဲ့ OUTPUT အစား READ နဲ့ PRINT၊ WHILE condition (မှန်လား မှားလား စစ်တဲ့ အခြေအနေ) ရဲ့ နောက်မှာ colon (အစက် နှစ်စက်)၊ ဒါမှမဟုတ် loop while ... end loop ကို တွေ့ရနိုင်ပါတယ်။ အဓိပ္ပာယ် အတူတူပါပဲ။

Pseudocode ဆိုတာ ဘာလဲ (ဘာ မဟုတ်လဲ)

Pseudocode ဆိုတာ algorithm တစ်ခုရဲ့ အဆင့်တွေကို ရိုးရိုး English နဲ့ ရေးတဲ့ နည်းလမ်း တစ်ခုပါ။ အသုံးများတဲ့ လုပ်ဆောင်ချက်တွေအတွက် keyword တွေ ပါပါတယ်: input (program ထဲ ထည့်ပေးတဲ့ ဒေတာ) ဖတ်ခြင်း၊ output (program က ထုတ်ပြတဲ့ ရလဒ်) ပြခြင်း၊ ဆုံးဖြတ်ချက် ချခြင်းနဲ့ အဆင့်တွေကို ထပ်ခါထပ်ခါ လုပ်ခြင်း။

Pseudocode ကို ကွန်ပျူတာ run ဖို့ ရေးတာ မဟုတ်ပါဘူး။ Compiler (code တစ်ခုလုံးကို ကြိုတင် ဘာသာပြန်တဲ့ program) က မစစ်လို့ တင်းကျပ်တဲ့ သဒ္ဒါ မရှိသလို မှန်ကန်တဲ့ စာလုံးပေါင်း တစ်မျိုးတည်းလည်း မရှိပါဘူး။ လူ နှစ်ယောက်က algorithm တစ်ခုတည်းကို နည်းနည်း မတူအောင် ရေးရင် နှစ်ယောက်လုံး မှန်နိုင်ပါတယ်။ ဒါပေမယ့် လူ တစ်ယောက်က တစ်ဆင့်ချင်း လိုက်ပြီး တန်ဖိုးတွေ ပြောင်းသွားတာကို မှတ်သွားနိုင်ပါတယ်။ ဒါကို tracing (တစ်ဆင့်ချင်း လိုက်ပြီး မှတ်ခြင်း) လို့ ခေါ်ပါတယ် (Pseudocode ကို ဖတ်ခြင်းနဲ့ Trace လုပ်ခြင်း ကို ကြည့်ပါ)။

Pseudocode ကောင်းမကောင်း စစ်နည်းက ရိုးရှင်းပါတယ်: တခြား ကျောင်းသား တစ်ယောက်က အဲဒါကို တစ်ဆင့်ချင်း လိုက်လုပ်ပြီး ကိုယ် ရည်ရွယ်ထားတဲ့ ရလဒ်ကို ရနိုင်မလား။ ရနိုင်ရင် လုံလောက်အောင် ရှင်းပါတယ်။ ကိုယ် ဘာကို ဆိုလိုလဲ သူတို့ ခန့်မှန်းရမယ်ဆိုရင် အသေးစိတ် ထပ်ထည့်ဖို့ လိုပါတယ်။

အသုံးများတဲ့ Keyword အစု

ဒါတွေက ဒီစာမျက်နှာမှာ သုံးတဲ့ keyword တွေပါ။ Variable (တန်ဖိုး သိမ်းထားတဲ့ နာမည်ပေးထားတဲ့ နေရာ၊ ဥပမာ count ဒါမှမဟုတ် total) တွေရဲ့ နာမည်တွေကနေ ကွဲပြားပြီး ထင်ရှားအောင် စာလုံးကြီးတွေနဲ့ ရေးထားပါတယ်။ ဇယားက keyword တစ်ခုစီကို Java နဲ့ Python မှာ ဘယ်လို ရေးလဲ ပြပါတယ်။

Pseudocode	အဓိပ္ပာယ်	Java	Python
`INPUT name`	User ဆီကနေ တန်ဖိုး တစ်ခု ဖတ်ပါ	`name = input.nextLine();`	`name = input()`
`OUTPUT total`	တန်ဖိုး တစ်ခုကို ပြပါ	`System.out.println(total);`	`print(total)`
`count = 0`	Assignment (variable ထဲ တန်ဖိုး ထည့်ခြင်း): variable တစ်ခုထဲမှာ တန်ဖိုး တစ်ခု သိမ်းပါ	`int count = 0;`	`count = 0`
`IF count = 0 THEN`	Condition တစ်ခု (true ဒါမှမဟုတ် false ဖြစ်တဲ့ စစ်ဆေးချက်) ထဲမှာ `=` က “ညီတယ်” လို့ ဆိုလိုပြီး `!=` က “မညီဘူး” လို့ ဆိုလိုပါတယ်	`if (count == 0)`; string (စာသား) တွေအတွက် `.equals()`	`if count == 0:`
`IF ... THEN ... ELSE ... END IF`	Selection (condition ပေါ်မူတည်ပြီး လမ်းကြောင်း ရွေးခြင်း): ဘယ်အဆင့်တွေကို run မလဲ ရွေးပါ	`if (...) { } else { }`	`if ...: else:`
`WHILE ... END WHILE`	Condition မှန်နေသရွေ့ ထပ်ခါထပ်ခါ လုပ်ပါ	`while (...) { }`	`while ...:`
`FOR i FROM 0 TO n - 1 ... END FOR`	သတ်မှတ်ထားတဲ့ အကြိမ်ရေ ထပ်လုပ်ပါ၊ `i` က 0 ကနေ n - 1 အထိ ရေတွက်သွားပါတယ်	`for (int i = 0; i < n; i++)`	`for i in range(n):`
`REPEAT ... UNTIL ...`	အဆင့်တွေကို run ပြီးမှ condition ကို စစ်ပါ၊ condition မှန်လာတဲ့အထိ ထပ်လုပ်ပါ၊ ဒါကြောင့် အဆင့်တွေက အနည်းဆုံး တစ်ကြိမ် run ပါတယ်	`do { } while (!...);`	(တိုက်ရိုက် ကိုက်တာ မရှိပါ: အဆင့်တွေကို တစ်ကြိမ် ရေးပြီး နောက်မှာ အဲဒါတွေကို ထပ်လုပ်တဲ့ `while` loop တစ်ခု ရေးပါ)
`scores[i]`	List ဒါမှမဟုတ် array (တန်ဖိုး အများကြီးကို နာမည် တစ်ခုတည်းအောက်မှာ သိမ်းထားတာ) ထဲက `i` နေရာမှာ ရှိတဲ့ item (အချက်) ပါ။ အဲဒီ နေရာကို index (နေရာအမှတ်) လို့ ခေါ်ပြီး ဒီစာမျက်နှာမှာ 0 ကနေ စပါတယ်	`scores[i]`	`scores[i]`
`length of scores`	List ထဲမှာ item ဘယ်နှစ်ခု ရှိလဲ	`scores.length`	`len(scores)`
`total / count`	ဒသမ အပိုင်းကို ထိန်းထားတဲ့ စားခြင်း	`(double) total / count`	`total / count`
`MOD` / `DIV`	စားပြီး ကျန်တဲ့ အကြွင်း / ကိန်းပြည့် အပိုင်းကိုပဲ ထားတဲ့ စားခြင်း (integer division: ကိန်းပြည့် အချင်းချင်း စားရင် ဒသမ ပျောက်သွားတာ)	`%` / `/` (integer တွေအတွက်)	`%` / `//`

ဒီစာမျက်နှာက ဥပမာတွေလို 0 နဲ့ အထက် ကိန်းပြည့် တစ်ခုကို အပေါင်း ကိန်းပြည့် တစ်ခုနဲ့ စားတဲ့အခါ MOD နဲ့ DIV ရဲ့ ဘာသာပြန်ချက်တွေ ကိုက်ညီပါတယ်။ အနုတ်ကိန်းတွေနဲ့ဆိုရင် အဖြေတွေ ကွာနိုင်ပါတယ်: Java မှာ -5 / 2 က -2 ဖြစ်ပေမယ့် Python မှာ -5 // 2 က -3 ဖြစ်ပါတယ်။

Indentation (စာကြောင်းရှေ့က ကွက်လပ်) က ဖွဲ့စည်းပုံကို ပြပါတယ်။ IF၊ WHILE ဒါမှမဟုတ် FOR ထဲက စာကြောင်းတွေကို indent လုပ် (ညာဘက်ကို ရွှေ့) ပါ၊ ဒါမှ ဘယ်စာကြောင်းတွေက အဲဒါထဲမှာ ပါလဲ ဖတ်သူ မြင်နိုင်ပါတယ်။ အဲဒီ စာကြောင်းတွေ အားလုံး ပေါင်းပြီး block (code အပိုင်း) တစ်ခု ဖြစ်ပါတယ်။ Python မှာတော့ ဒီထက် ပိုပါတယ်: တကယ့် Python code မှာ ဘယ်စာကြောင်းတွေက block တစ်ခုထဲ ပါလဲ ဆိုတာကို indentation က ဆုံးဖြတ်ပါတယ်။

အခြေခံ အစိတ်အပိုင်း သုံးခု

Algorithm မှန်သမျှကို အဆင့် အမျိုးအစား သုံးမျိုးနဲ့ ရေးလို့ရပါတယ်: sequence (ရေးထားတဲ့ အစဉ်အတိုင်း တစ်ကြောင်းပြီး တစ်ကြောင်း run ခြင်း)၊ selection နဲ့ iteration (ထပ်ခါထပ်ခါ လုပ်ခြင်း)။ Pseudocode မှာ တစ်ခုချင်းစီကို ရေးတဲ့ ကိုယ်ပိုင် ပုံစံ ရှိပါတယ်။

1. Sequence (ဒါကို လုပ်၊ ပြီးရင် ဟိုဟာကို လုပ်)

အဆင့်တွေက အပေါ်ကနေ အောက်ကို တစ်ခုပြီးမှ တစ်ခု run ပါတယ်။

START
  price = 20
  tax = price * 0.1
  total = price + tax
  OUTPUT total
END

2. Selection (လမ်းကြောင်း တစ်ခုကို ရွေးခြင်း)

IF က condition တစ်ခု true လား false လား ဆိုတာပေါ် မူတည်ပြီး ဘယ်အဆင့်တွေကို run မလဲ ရွေးပါတယ်။ ဒါက မဲပေးခွင့် flowchart ထဲက algorithm ကို pseudocode နဲ့ ရေးထားတာပါ။

START
  INPUT age
  IF age >= 18 THEN
    OUTPUT "Can vote"
  ELSE
    OUTPUT "Cannot vote"
  END IF
END

3. Iteration (ထပ်ခါထပ်ခါ လုပ်ခြင်း)

Loop (ထပ်ခါထပ်ခါ run တဲ့ code အပိုင်း) က အဆင့်တွေကို ထပ်လုပ်ပါတယ်။ အဆင့်တွေ ဘယ်နှစ်ကြိမ် ထပ်မလဲ ကြိုသိရင် (ဥပမာ list ထဲက item တစ်ခုစီအတွက် တစ်ကြိမ်) FOR ကို သုံးပါ။ ဘယ်အချိန် ရပ်မလဲကို condition က ဆုံးဖြတ်တဲ့အခါ၊ အထူးသဖြင့် pass (loop ရဲ့ အဆင့်တွေကို တစ်ခေါက် run တာ) ဘယ်နှစ်ကြိမ် လိုမလဲ ကြိုမသိနိုင်တဲ့အခါ WHILE ကို သုံးပါ။

ဒီဥပမာမှာ video တစ်ခုကို ကြည့်ထားတဲ့ အကြိမ်ရေ (views) က 50 ရှိပြီး ကြည့်ရှုမှု အရေအတွက်က နေ့တိုင်း နှစ်ဆ ဖြစ်ပါတယ်။ Video ကို အနည်းဆုံး 1000 ကြိမ် ကြည့်ပြီးတဲ့အထိ ရက် ဘယ်နှစ်ရက် ကြာလဲ loop က ရေတွက်ပါတယ်။

START
  views = 50
  days = 0
  WHILE views < 1000
    views = views * 2
    days = days + 1
  END WHILE
  OUTPUT "Days:", days
END

Code ထဲက views က ကြည့်ရှုမှု အရေအတွက်၊ days က ရက် အရေအတွက်ပါ။

Pseudocode ကနေ တကယ့် code အဖြစ်

Pseudocode ကို လေ့လာထိုက်တဲ့ အကြောင်းရင်း တစ်ခုက သိပ် ပြန်ရေးစရာ မလိုဘဲ တကယ့် code အဖြစ် ပြောင်းလို့ ရတာပါ။ ဒီမှာ ပြီးပြည့်စုံတဲ့ algorithm သုံးခု ရှိပါတယ်။ တစ်ခုစီကို pseudocode နဲ့ အရင် ပြပြီး Java နဲ့ Python ကို ဘာသာပြန်ထားပါတယ်။ Language နှစ်ခုကို နှိုင်းယှဉ်ဖို့ tab တွေကို နှိပ်ပါ။

ဥပမာ 1: List တစ်ခုရဲ့ ပျမ်းမျှ

အမှတ် အားလုံးကို ပေါင်းပြီး အမှတ် ဘယ်နှစ်ခု ရှိလဲ ဆိုတဲ့ အရေအတွက်နဲ့ စားပါ။

START
  scores = [72, 85, 90, 64]
  total = 0
  FOR i FROM 0 TO length of scores - 1
    total = total + scores[i]
  END FOR
  average = total / length of scores
  OUTPUT "Average:", average
END

အဲဒီ algorithm တစ်ခုတည်းကို run လို့ရတဲ့ code အဖြစ်:

public class Average {
    public static void main(String[] args) {
        int[] scores = {72, 85, 90, 64};
        int total = 0;
        for (int i = 0; i < scores.length; i++) {
            total = total + scores[i];
        }
        double average = (double) total / scores.length;
        System.out.println("Average: " + average);
    }
}

scores = [72, 85, 90, 64]
total = 0
for i in range(len(scores)):
    total = total + scores[i]
average = total / len(scores)
print("Average:", average)

Output:

Average: 77.75

Pseudocode မှာ ထည့်မရေးထားတဲ့ အသေးစိတ် တစ်ခုကို သတိထားပါ။ Java မှာ integer (ကိန်းပြည့်) တစ်ခုကို နောက် integer တစ်ခုနဲ့ စားရင် ဒသမ အပိုင်း ပျောက်သွားပါတယ်။ ဒါကြောင့် စုစုပေါင်းကို double (ဒသမ ကိန်း သိမ်းနိုင်တဲ့ ဂဏန်း type) အဖြစ် အရင် ပြောင်းပါတယ်။ ဒီစာမျက်နှာရဲ့ pseudocode မှာ / က ဒသမ အပိုင်းကို ထိန်းထားပြီး DIV က ဖယ်ပစ်ပါတယ် (0 နဲ့ အထက် ဂဏန်းတွေအတွက်ပါ၊ keyword ဇယား အောက်က မှတ်ချက်ကို ကြည့်ပါ)။ Pseudocode မှာ ဒီလို အသေးစိတ်တွေကို ဘာသာပြန်တဲ့ အချိန်ကျမှ စဉ်းစားလို့ ရပါတယ်။

ဥပမာ 2: အကြီးဆုံး တန်ဖိုးကို ရှာခြင်း

ပထမ item ကို အခုထိ အကြီးဆုံးလို့ ယူပါ။ ပြီးရင် ကျန်တဲ့ item တစ်ခုချင်းစီကို အခုထိ အကြီးဆုံးနဲ့ နှိုင်းယှဉ်ပြီး ပိုကြီးတာ တွေ့တိုင်း အစားထိုးပါ။

START
  heights = [150, 172, 168, 181, 159]
  tallest = heights[0]
  FOR i FROM 1 TO length of heights - 1
    IF heights[i] > tallest THEN
      tallest = heights[i]
    END IF
  END FOR
  OUTPUT "Tallest:", tallest
END

public class Tallest {
    public static void main(String[] args) {
        int[] heights = {150, 172, 168, 181, 159};
        int tallest = heights[0];
        for (int i = 1; i < heights.length; i++) {
            if (heights[i] > tallest) {
                tallest = heights[i];
            }
        }
        System.out.println("Tallest: " + tallest);
    }
}

heights = [150, 172, 168, 181, 159]
tallest = heights[0]
for i in range(1, len(heights)):
    if heights[i] > tallest:
        tallest = heights[i]
print("Tallest:", tallest)

Output:

Tallest: 181

tallest ကို 0 မဟုတ်ဘဲ ပထမ item (heights[0]) နဲ့ သတ်မှတ်ပါ။ စတင် တန်ဖိုး 0 ဆိုရင် ဂဏန်း အားလုံး အနုတ်ကိန်း ဖြစ်နေတဲ့ list (ဥပမာ ရေခဲမှတ်အောက် အပူချိန်တွေ) မှာ 0 ကို အကြီးဆုံးလို့ မှားပြီး ပြပါလိမ့်မယ်။ နေရာ 0 က item က စတင် တန်ဖိုး ဖြစ်နေပြီးသားမို့ loop ကို နေရာ 1 ကနေ စပါတယ်။

ဥပမာ 3: Condition နဲ့ ရေတွက်ခြင်း

5 ကနေ နောက်ပြန် ရေတွက်ပြီး အဲဒီ ဂဏန်းတွေထဲက စုံကိန်း ဘယ်နှစ်ခု ရှိလဲ မှတ်ထားတဲ့ WHILE loop တစ်ခုပါ။ ဒီ loop က ကြိုသိထားတဲ့ အကြိမ်ရေ run တာမို့ FOR loop နဲ့လည်း ရပါတယ်။ WHILE အဖြစ် ရေးထားတော့ counter (pass တိုင်းမှာ တူညီတဲ့ ပမာဏနဲ့ တိုး ဒါမှမဟုတ် လျော့သွားတဲ့ variable) တစ်ခုနဲ့ ထိန်းတဲ့ loop ရဲ့ အပိုင်း သုံးပိုင်းကို ပြပါတယ်: စတင် တန်ဖိုး (count = 5)၊ condition (count > 0) နဲ့ တန်ဖိုး ပြောင်းတဲ့ အဆင့် (count = count - 1)။

START
  count = 5
  evens = 0
  WHILE count > 0
    IF count MOD 2 = 0 THEN
      evens = evens + 1
    END IF
    count = count - 1
  END WHILE
  OUTPUT "Even numbers seen:", evens
END

public class CountEvens {
    public static void main(String[] args) {
        int count = 5;
        int evens = 0;
        while (count > 0) {
            if (count % 2 == 0) {
                evens = evens + 1;
            }
            count = count - 1;
        }
        System.out.println("Even numbers seen: " + evens);
    }
}

count = 5
evens = 0
while count > 0:
    if count % 2 == 0:
        evens = evens + 1
    count = count - 1
print("Even numbers seen:", evens)

Output:

Even numbers seen: 2

5 ကနေ နောက်ပြန် ရေတွက်တဲ့အခါ loop က စုံကိန်း နှစ်ခု (4 နဲ့ 2) ကို ဖြတ်သွားလို့ evens က 2 နဲ့ ဆုံးပါတယ်။ MOD (Java နဲ့ Python နှစ်ခုလုံးမှာ % လို့ ရေးတယ်) က စားပြီး ကျန်တဲ့ အကြွင်းကို ပေးပါတယ်။ 2 နဲ့ စားရင် အကြွင်း 0 ကျန်တဲ့ ဂဏန်းက စုံကိန်းပါ။

Pseudocode ကို ဖတ်ခြင်းနဲ့ Trace လုပ်ခြင်း

Pseudocode ကို trace လုပ်တာက flowchart ကို trace လုပ်တာ နဲ့ ကျွမ်းကျင်မှု အတူတူပါပဲ: တစ်ကြောင်းချင်း လိုက်ပြီး တန်ဖိုးတွေကို trace table (variable တစ်ခုစီအတွက် ဒေါင်လိုက် ကော်လံ တစ်ခုစီ ပါပြီး တန်ဖိုးတွေ ပြောင်းသွားတာနဲ့အမျှ ချရေးရတဲ့ ဇယား) ထဲမှာ မှတ်ပါ။

Loop ကို ဖြတ်တဲ့ pass တစ်ခုစီအတွက် row (အလျားလိုက် အတန်း) တစ်တန်းစီ ရေးပါ။ ဒီစာမျက်နှာက variable တိုင်းရဲ့ တန်ဖိုးကို မပြောင်းရင်တောင် row တိုင်းမှာ ဖြည့်ပါတယ်။ Row အပြည့် ရှိရင် algorithm က ဘာလုပ်လဲ လိုက်ကြည့်ရ၊ အဆင့်တိုင်းကို စစ်ရ ပိုလွယ်ပါတယ်။ ကွက်လပ် ထားခဲ့ရင် လက်ရှိ တန်ဖိုးကို သိဖို့ အရင် row တွေကို ပြန်ရှာရပြီး trace လုပ်တဲ့ အမှားတွေ ဖြစ်တတ်တာ အဲဒီနေရာမှာပါ။ Flowcharts စာမျက်နှာက ဇယားတွေလို တချို့ ဇယားတွေက ဘာမှ မပြောင်းတဲ့ အကွက်မှာ -- လို့ ရေးပါတယ်။ Pass တိုင်းမှာ ကိုယ်ပိုင် row ရှိနေသရွေ့ စာရွက်ပေါ်မှာ ဒီနည်းလည်း ရပါတယ်။ အောက်က Trace Exercise (code ကို တစ်ဆင့်ချင်း လိုက်ကြည့်ခြင်း) က အကွက်တိုင်းမှာ တန်ဖိုး ဖြည့်ခိုင်းပါတယ်။

ဥပမာ 3 အတွက် trace table က ဒီလို ဖြစ်ပါတယ်။ နောက်ဆုံး row က loop ကို ရပ်စေတဲ့ စစ်ဆေးချက်ကို ပြပါတယ်။

count	count > 0?	count MOD 2 = 0?	evens
5	Yes	No	0
4	Yes	Yes	1
3	Yes	No	1
2	Yes	Yes	2
1	Yes	No	2
0	No	(exit)	2

Output: Even numbers seen: 2.

ဇယားထဲက Yes က ဟုတ်၊ No က မဟုတ်၊ (exit) က loop ကနေ ထွက်တယ် လို့ ဆိုလိုပါတယ်။

Pseudocode၊ Flowchart ဒါမှမဟုတ် Code: ဘယ်ဟာကို ဘယ်အချိန် သုံးမလဲ

သုံးခုလုံးက algorithm တွေကို ဖော်ပြပါတယ်။ တစ်ခုစီက အလုပ်ရဲ့ မတူတဲ့ အဆင့်မှာ အသုံးအဝင်ဆုံးပါ။

ကိရိယာ	အကောင်းဆုံး သုံးတဲ့ နေရာ	အားနည်းတဲ့ နေရာ
Flowchart	Algorithm က ဘယ်မှာ branch ခွဲ (လမ်းကြောင်း အမျိုးမျိုး ခွဲထွက်) လဲ၊ ဘယ်မှာ loop ပတ်လဲ ဆိုတာကို တစ်ချက်ကြည့်ရုံနဲ့ ပြခြင်း	ရှည်ပြီး အသေးစိတ် များတဲ့ algorithm တွေ (ပုံက အရမ်း ကြီးလာတယ်)
Pseudocode	အဆင့်တွေကို တိတိကျကျ မြန်မြန် စီစဉ်ခြင်း၊ code နဲ့ နီးစပ်ပြီး ပြင်ရ လွယ်တယ်	ဖွဲ့စည်းပုံ တစ်ခုလုံးကို ပုံနဲ့ ပြခြင်း
တကယ့် code	ကွန်ပျူတာ run နိုင်တဲ့ ပြီးပြည့်စုံတဲ့ ဖြေရှင်းချက်	စိတ်ကူး တစ်ခုကို စီစဉ်ခြင်းနဲ့ တခြားသူတွေကို ရှင်းပြခြင်း (language ရဲ့ တိကျတဲ့ စည်းမျဉ်းတွေက အနှောင့်အယှက် ဖြစ်တယ်)

အသုံးများတဲ့ အလုပ် အစဉ် တစ်ခုက ဖွဲ့စည်းပုံ တစ်ခုလုံးကို စီစဉ်ဖို့ flowchart၊ အဆင့်တွေကို တိတိကျကျ ချပြဖို့ pseudocode၊ ပြီးမှ ဖြေရှင်းချက်ကို တည်ဆောက်ဖို့ တကယ့် code ပါ။ သုံးခုလုံးကို အမြဲ သုံးမှာ မဟုတ်ပေမယ့် တစ်ခုစီ ဘာအတွက်လဲ သိထားရင် ရွေးရ လွယ်ပါတယ်။ Design Representations (ဒီဇိုင်းကို ဖော်ပြတဲ့ နည်းလမ်းများ) က ဒါတွေကို ဒီဇိုင်း ပြတဲ့ တခြား နည်းလမ်းတွေနဲ့ နှိုင်းယှဉ်ပြထားပါတယ်။

Quick Check (အမြန် စစ်ဆေးမေးခွန်း)

Q1. Pseudocode ရဲ့ အဓိက ရည်ရွယ်ချက်က ဘာလဲ။

Q2. အဆင့် block တစ်ခုကို ထပ်ခါထပ်ခါ လုပ်ဖို့ ဘယ် pseudocode keyword ကို သုံးသလဲ။

Q3. temperature = 30 ဆိုရင် ဒါက ဘာကို print ထုတ်မလဲ။
IF temperature >= 25 THEN OUTPUT "Warm" ELSE OUTPUT "Cool" END IF

Q4. ဒီ algorithm ကို trace လုပ်ပါ။ နောက်ဆုံး output က ဘာလဲ။
total = 0 · n = 3 · WHILE n > 0 · total = total + n · n = n - 1 · END WHILE · OUTPUT total

Q5. 0 ကနေ length - 1 အထိ နေရာ တစ်ခုစီအတွက် တစ်ကြိမ်စီ တစ်ခုခု လုပ်ချင်ပါတယ်။ ဒါတွေထဲက ဘယ်ဟာက အသင့်တော်ဆုံးလဲ။

Q6. Pseudocode မှာ indentation က ဘာကြောင့် အရေးကြီးသလဲ။

Trace Exercise (code ကို တစ်ဆင့်ချင်း လိုက်ကြည့်ခြင်း)

ဒီ algorithm ကို trace လုပ်ပြီး ဇယားကို ဖြည့်ပါ။ List တစ်ခုထဲက အငယ်ဆုံး တန်ဖိုးကို ရှာပါတယ်။

Trace: list က prices = [8, 3, 11, 5] ပါ။ အစမှာနဲ့ comparison (တန်ဖိုး နှစ်ခုကို နှိုင်းယှဉ်ခြင်း) တစ်ခုစီ ပြီးတဲ့နောက် smallest ကို ဖြည့်ပါ။ ဇယားထဲက Start က အစ၊ Yes က ဟုတ်၊ No က မဟုတ် လို့ ဆိုလိုပါတယ်။

smallest = prices[0]
FOR i FROM 1 TO length of prices - 1
    IF prices[i] < smallest THEN
        smallest = prices[i]
    END IF
END FOR
OUTPUT smallest

i	prices[i]	prices[i] < smallest?
Start	--	--
1	3	Yes
2	11	No
3	5	No

Code Completion (code ကွက်လပ် ဖြည့်ခြင်း)

ဒီ pseudocode ကို Java အဖြစ် ဘာသာပြန်ပါ။ List တစ်ခုထဲက ဂဏန်း တိုင်းကို နှစ်ဆ လုပ်ပြီး ရလဒ် တစ်ခုချင်းစီကို print ထုတ်ပါတယ်။

Pseudocode: FOR i FROM 0 TO length of nums - 1 · OUTPUT nums[i] * 2 · END FOR

int[] nums = {4, 7, 2};
for (int i = ; i < nums.; i++) {
    System.out.println(nums[i]  2);
}

Practice Exercises (လေ့ကျင့်ခန်းများ)

Construct နဲ့ Describe လို English စကားလုံးတွေက IB command term (မေးခွန်းမှာ ဘာလုပ်ရမလဲ ပြတဲ့ ညွှန်ကြားချက် စကားလုံး) တွေပါ။ (3 marks) လို mark allocation (မေးခွန်း တစ်ခုစီအတွက် ပေးတဲ့ အမှတ်) တွေက IB Computer Science စာမေးပွဲ ပုံစံအတိုင်း ပေးထားတာပါ၊ ဥပမာ (3 marks) ဆိုတာ 3 မှတ်ပါ။ IB သင်တန်း မတက်တဲ့သူတွေကတော့ အဖြေ ဘယ်လောက် အသေးစိတ် ရေးရမလဲ ချိန်ကြည့်ဖို့ လမ်းညွှန်အဖြစ် သုံးနိုင်ပါတယ်။

Core (အခြေခံ အဆင့်)

Construct (ကိုယ်တိုင် တည်ဆောက်ပါ) (3 marks): ဂဏန်း တစ်ခုကို ဖတ်ပြီး “Positive” (အပေါင်း)၊ “Negative” (အနုတ်) ဒါမှမဟုတ် “Zero” (သုည) ကို output ထုတ်တဲ့ algorithm တစ်ခုအတွက် pseudocode ကို construct လုပ်ပါ။
Construct (3 marks): 1 ကနေ 10 အထိ ဂဏန်းတွေကို ပေါင်းပြီး စုစုပေါင်းကို output ထုတ်ဖို့ FOR loop ကို သုံးတဲ့ pseudocode ကို construct လုပ်ပါ။
Construct (4 marks): 3. Iteration (ထပ်ခါထပ်ခါ လုပ်ခြင်း) ထဲက pseudocode ကနေ Java ဒါမှမဟုတ် Python program တစ်ခုကို construct လုပ်ပြီး အဲဒီ program က print ထုတ်မယ့် output ကို State (ဖော်ပြပါ) လုပ်ပါ။

Extension (တိုးချဲ့ အဆင့်)

Construct (5 marks): user က 0 ထည့်တဲ့အထိ ဂဏန်းတွေကို ဖတ်ပြီး 0 ကို မရေတွက်ဘဲ ဂဏန်း ဘယ်နှစ်ခု ထည့်ခဲ့လဲ output ထုတ်တဲ့ pseudocode ကို construct လုပ်ပါ။ ကိုယ့် pseudocode ကို input 4, 9, 2, 0 နဲ့ Trace (တစ်ဆင့်ချင်း လိုက်ပြီး မှတ်ပါ) လုပ်ပါ။
Construct (5 marks): List တစ်ခုထဲမှာ ပေးထားတဲ့ threshold (ကန့်သတ် တန်ဖိုး) ထက် ကြီးတဲ့ တန်ဖိုး ဘယ်နှစ်ခု ရှိလဲ ရေတွက်ပြီး အဲဒီ အရေအတွက်ကို output ထုတ်တဲ့ pseudocode ကို construct လုပ်ပါ။ List [12, 5, 20, 8] နဲ့ threshold 10 ကို သုံးပြီး trace လုပ်ပါ။
Describe (ဖော်ပြရှင်းပြပါ) (4 marks): အပြေးသမား တစ်ယောက်က ရက် 14 ရက်အတွက် နေ့စဉ် ပြေးတဲ့ အကွာအဝေးကို list တစ်ခုထဲမှာ မှတ်ထားပါတယ်။ အရင်နေ့ထက် ပိုတိုတဲ့ အကွာအဝေး ပြေးခဲ့တဲ့ ပထမဆုံး နေ့ကို ရှာပြီး အဲဒီနေ့ရဲ့ နံပါတ်ကို output ထုတ်တဲ့ algorithm တစ်ခုကို describe လုပ်ပါ။ အဲဒီလို နေ့ မရှိရင် algorithm က မရှိကြောင်း ပြောတဲ့ message တစ်ခုကို output ထုတ်ပါတယ်။ Code ဒါမှမဟုတ် pseudocode ရေးဖို့ မလိုပါဘူး။

Challenge (စိန်ခေါ်မှု အဆင့်)

Construct (8 marks): List တစ်ခုထဲမှာ ကျောင်းသား တစ်ယောက် ရက် ခုနစ်ရက်အတွက် နေ့စဉ် စာဖတ်ခဲ့တဲ့ မိနစ် အရေအတွက်တွေ ရှိပါတယ်။ ကျောင်းသားက အနည်းဆုံး 20 မိနစ် စာဖတ်ခဲ့တဲ့ ဆက်တိုက် ရက်တွေရဲ့ အရှည်ဆုံး အစဉ်ကို ရှာပြီး အဲဒီ အစဉ်ထဲက ရက် အရေအတွက်ကို output ထုတ်တဲ့ pseudocode ကို construct လုပ်ပါ။ ကိုယ့် pseudocode ကို Java ဒါမှမဟုတ် Python ကို ဘာသာပြန်ပြီး list [25, 30, 5, 20, 45, 35, 50] နဲ့ trace လုပ်ပါ။

ဆက်စပ် ခေါင်းစဉ်များ

အရင် လေ့လာထားရမယ့် ခေါင်းစဉ်: CT Concepts (computational thinking ရဲ့ အခြေခံ သဘောတရားများ): pseudocode က ကိုယ် ဒီဇိုင်းဆွဲထားတဲ့ algorithm ကို ချရေးတဲ့ နည်းလမ်း တစ်ခုပါ
ဆက်စပ် ခေါင်းစဉ်: Flowcharts (လုပ်ငန်းစဉ်ကို သင်္ကေတတွေနဲ့ ဆွဲပြတဲ့ ပုံများ): pseudocode နဲ့ တွဲသုံးတဲ့ ပုံ ပုံစံပါ၊ logic တစ်ခုတည်းကို ပုံအဖြစ် ဆွဲထားတာပါ
ဆက်စပ် ခေါင်းစဉ်: Design Representations (ဒီဇိုင်းကို ဖော်ပြတဲ့ နည်းလမ်းများ): pseudocode၊ flowchart နဲ့ ဒီဇိုင်း ပြတဲ့ တခြား နည်းလမ်းတွေထဲက ရွေးခြင်း
နောက်ထပ် လေ့လာမယ့် ခေါင်းစဉ်: Selection (condition ပေါ်မူတည်ပြီး လမ်းကြောင်း ရွေးခြင်း): IF/THEN/ELSE pseudocode က တကယ့် code ထဲမှာ if/else ဖြစ်လာပါတယ်
နောက်ထပ် လေ့လာမယ့် ခေါင်းစဉ်: Iteration (ထပ်ခါထပ်ခါ လုပ်ခြင်း): WHILE နဲ့ FOR pseudocode က တကယ့် loop တွေ ဖြစ်လာပါတယ်
နောက်ထပ် လေ့လာမယ့် ခေါင်းစဉ်: 1D Arrays (တန်းတစ်တန်းတည်းမှာ စီထားတဲ့ ဒေတာအစု): list နဲ့ array တွေကို အပြည့်အစုံ လေ့လာခြင်း (အပေါ်က ဥပမာတွေမှာ သုံးထားပါတယ်)
Internal Assessment: Criterion C: System overview (အမှတ်ပေး စံနှုန်း C: စနစ်ရဲ့ ခြုံငုံ ဖော်ပြချက်): ကိုယ့် ဒီဇိုင်းထဲက algorithm တွေကို တင်ပြခြင်း