අන්තර්ගතයට යන්න
mcqdinethlive

Python loops trace tables වලින් trace කරන හැටි range ඉඳන් nested loops වෙනකම්

A/L ICT papers වල Python loops අහන විදිය සහ ඒ හැම එකකටම පාවිච්චි කරන්න පුළුවන් එකම trace table ක්‍රමය. range, sentinel while loops, digit loops, break, continue, nested loops, flags එක්ක loop else එක past paper ප්‍රශ්න එක්කම බලමු.

ඉංග්‍රීසියෙන් කියවන්න

මේ post එකෙන් පැහැදිලි කරන්නේ කොළේක ලියලා Python loop එකක් trace කරන හැටි. Unit 9 එකේ Python marks ගොඩක් ගන්න ඕනේ වෙන ප්‍රධානම skill එක මේකයි. අලුත් syllabus එකේ 2019 ඉඳන් 2026 වෙනකම් papers අටේම Control structures (9.8) අහලා තියෙනවා, ඒ MCQs 17කුත් Paper II marks 59කුත් එක්ක.

මේ post එකේ කොටස් හතරක් තියෙනවා:

  • පදනම: syllabus එකෙන් අහන්නේ මොනවාද, papers වල ප්‍රශ්න එන්නේ කොහොමද, සහ trace table ක්‍රමය (sections 1 සහ 2).
  • Loops දෙක: range() එක්ක එන for, සහ අගයකින් නතර වෙන while loops (sections 3 සහ 4).
  • Flow එක වෙනස් කරන හැටි: break සහ continue, nested loops, flags සහ loop else එක (sections 5 ඉඳන් 7 වෙනකම්).
  • පුහුණුව: තනියම කරලා බලන්න පුළුවන් past paper ප්‍රශ්න, වර්ග කරලා (section 8).

1. Syllabus එකේ සහ papers වල එන loops

Loop එකක් කියන්නේ ප්‍රධාන control structures තුනෙන් එකක්. Syllabus එකේ sequence, selection සහ repetition කියලා දීලා තියෙනවා, ඊටපස්සේ repetition කියන එක iteration සහ looping කියලා දෙකකට කඩනවා (Syllabus 9.8, page 39) (විෂය නිර්දේශය 9.8, පිටුව 36).

Teachers' Guide එකේ මේ බෙදීම පැහැදිලි කරනවා. සමහර sequences "pre-determined or post-determined number of times" repeat වෙනවා, ඒ iteration සහ looping (Teachers' Guide 9.8, page 77) (ගුරු අත්පොත 9.8, පිටුව 76). සිංහල පොත් වල මේවට "පුනර්කරණය" (iteration) සහ "ලූපනය" (looping) කියලා කියනවා, ඒ වගේම repetition වලට "පුනරුක්තිය" කියනවා. හැබැයි සිංහල Resource Book එක මේ දෙකටම පාවිච්චි කරන්නේ එකම වචනය. ඒකේ "පයිතන්හි පුනර්කරණ (Python Loops)" කියන heading එක යටතේ while සහ for දෙකම "පුනර්කරණ" යටතට දාලා තියෙනවා (Resource Book 9.8, පිටුව 56). ළමයි මේ වචන දෙකම මතක තියාගන්න, මොකද සිංහල මාධ්‍ය papers වල මේ දෙකම පාවිච්චි වෙනවා.

Python වල, මේ ජාති දෙක loops දෙකට ගැලපෙන්නේ මෙහෙමයි:

  • for loop (iteration): loop එක පටන් ගන්න කලින් වාර ගාණ දන්නවා. Resource Book එක කියනවා for loop එකක් block එකක් "for a known number of times" repeat කරනවා කියලා (Resource Book 9.8, page 51) (Resource Book 9.8, පිටුව 56).
  • while loop (looping): වාර ගාණ දන්නේ නෑ. Condition එක True වෙලා තියෙනකම් loop එක run වෙනවා (Resource Book 9.8, page 50) (Resource Book 9.8, පිටුව 56).

Papers වල loops ගැන අහන හැටි

Papers වල loops ප්‍රධාන විදි හතරකට අහනවා. Learning outcomes වල ළමයින්ට කියනවා control structures "appropriately" පාවිච්චි කරන්න සහ "nested control structures" අදාළ කරන්න කියලා (Teachers' Guide 9.8, page 77) (ගුරු අත්පොත 9.8, පිටුව 76).

  1. Find the output (Paper I): ගොඩක් loop MCQs වල code එකක් දීලා output එක අහනවා, 2024 Paper I, Q39 සහ 2026 Paper I, Q36 වගේ.
  2. Trace and state the purpose (Paper II): 2019 (New Syllabus) Paper II, A, Q2(b) සහ 2026 Paper II, A, Q3(a) වල inputs දීලා output එක අහනවා, ඊටපස්සේ purpose එක අහනවා.
  3. Fill the blanks (Paper II): 2024 Paper II, A, Q3(c) සහ 2026 Paper II, A, Q3(b) වල හිස්තැන් තියෙන program එකක් දෙනවා.
  4. Write the loop (Paper II): 2025 Paper II, A, Q3(b) සහ 2026 Paper II, A, Q3(c) වල description එකකින් හෝ flowchart එකකින් program එක ලියන්න කියනවා.

2021 (held 2022) ඉඳන් හැම අවුරුද්දකම Paper II, Part A, Q3 වල Python loop එකක් ඇවිත් තියෙනවා. මේ විදි හතරටම ඕනේ වෙන්නේ එකම skill එකයි: එක පේළිය ගානේ code එක කොළේක run කරන එක.

2. Trace table ක්‍රමය

Trace table එකකින් කරන්නේ code එක කොළේක run කරලා වෙනස් වෙන හැමදේම ලියාගන්න එක. Teachers' Guide එක ළමයින්ට කියනවා program එකක output එක ඒකේ source code එකත් එක්ක compare කරන්න කියලා (Teachers' Guide 9.8, page 78) (ගුරු අත්පොත 9.8, පිටුව 77). Exam එකේදී ඒක කරන්න තියෙන ක්‍රමය තමයි trace table එක.

ළමයි මේ පියවර ටික පාවිච්චි කරන්න:

  1. වෙනස් වෙන හැම variable එකකටම එක column එක ගානේ හදන්න, තව එකක් loop condition එකට සහ අන්තිම එක output එකට හදන්න.
  2. Loop එකට කලින් තියෙන values ටික පළවෙනි පේළියේ ලියන්න.
  3. Condition එක test කරන්න. True හරි False හරි ලියන්න. False ආවොත් loop එක නතර වෙනවා.
  4. Body එකේ පේළි ලියලා තියෙන පිළිවෙලටම run කරන්න. අලුත් වෙන හැම value එකක්ම අලුත් පේළියක ලියන්න.
  5. Loop එක ඉවර වුණාම, ඊටපස්සේ තියෙන පේළි ටික එක පාරක් run කරන්න.

Loop MCQ එකක options විදියට ගොඩක් වෙලාවට තියෙන්නේ පියවරක් මඟ හැරුණාම එන උත්තර. හිතෙන් loop එක run කරන්න එපා. Table එක අඳින්න.

2026න් ගත්ත උදාහරණයක්

2026 Paper II, A, Q3(a) වල මේ program එකයි 10, 5, 0, 15, 25, -1 කියන inputs ටිකයි දීලා තියෙනවා.

x = 0
found = False
n = int(input())
while n >= 0:
  found = True
  if n > x:
      x = n
  n = int(input())
if found:
  print(x)
else:
  print("No positive numbers were entered")

මේ trace table එකේ n, n >= 0, found, n > x සහ x කියන columns තියෙනවා:

  • Start: x = 0, found = False, n = 10.
  • n = 10: True. found = True. 10 > 0, ඒ නිසා x = 10.
  • n = 5: True. 5 > 10 කියන්නේ False, ඒ නිසා x 10 විදියටම තියෙනවා.
  • n = 0: True. x 10 විදියටම තියෙනවා.
  • n = 15: True. x = 15.
  • n = 25: True. x = 25.
  • n = -1: False. Loop එක නතර වෙනවා. found එක True, ඒ නිසා program එක 25 print කරනවා.

ඒ නිසා (i) output එක 25. (ii) සෘණ අංකයකට කලින් දුන්න අංක වලින් ලොකුම අංකය තමයි program එකෙන් print කරන්නේ. (iii) loop body එක එක පාරක් හරි run වුණාද කියලා found එකෙන් record කරනවා (section 7). මේවා අපේම worked answers, code එක run කරලා check කරපුවා, මොකද 2026ට තාම official scheme එකක් නෑ.

3. for loops සහ range()

for loop එකක් structure එකකින් එකින් එක values ගන්නවා. මේ structure එක list එකක්, string එකක් එහෙමත් නැත්නම් range() එකක් වෙන්න පුළුවන්. Resource Book එක සත්තු ඉන්න list එකක් උඩින් යන for loop එකක් පෙන්නනවා (Resource Book 9.8, page 51) (Resource Book 9.8, පිටුව 57).

range(a, b) පටන් ගන්නේ a වලින්, නතර වෙන්නේ b ට කලින්. ඒ නිසා ඒකෙන් අගයන් b අඩුකිරීම a ගාණක් දෙනවා. range(b) පටන් ගන්නේ 0න්. තුන්වෙනි අංකයක් දුන්නොත් ඒක තමයි step එක, negative step එකකින් පල්ලෙහාට ගණන් කරනවා.

  • range(5) වලින් 0, 1, 2, 3, 4 දෙනවා.
  • range(1, 5) වලින් 1, 2, 3, 4 දෙනවා.
  • range(2, 3, 1) වලින් 2 විතරක් දෙනවා.
  • range(10, 0, -2) වලින් 10, 8, 6, 4, 2 දෙනවා.
  • range(5, 1) වලින් මුකුත් දෙන්නේ නෑ, ඒ නිසා body එක කවදාවත් run වෙන්නේ නෑ.

Stop value එක අතඇරලා තියෙන්නේ හේතුවක් ඇතුව. දිග 5ක් වෙන list එකක indexes තියෙන්නේ 0 ඉඳන් 4 වෙනකම්, range(len(L)) දුන්නාම හරියටම ඒ ටික හම්බවෙනවා.

Resource Book දෙකේම control structures පිටු වල range() ගැන පෙන්නන්නේ නෑ. ඒකේ for loop උදාහරණය පාවිච්චි කරන්නේ list එකක් විතරයි (Resource Book 9.8, page 51) (Resource Book 9.8, පිටුව 57). හැබැයි papers වල එන ගොඩක්ම for loops පාවිච්චි කරන්නේ range() එක. ඒ නිසා papers වලින් ඒක ඉගෙනගන්න.

range සහ for අහන MCQs දෙකක්

2024 Paper I, Q39 වල for x in range(1, 3) සහ ඇතුළේ තියෙන for y in qns වලින් x, y print කරනවා, මෙතන qns = ["a", "b"]. x ට එන්නේ 1 සහ 2 විතරයි. ඒ නිසා output එක 1 a 1 b 2 a 2 b එනවා, උත්තරය option (3). Option (4) වල range(1, 3) කියන එක 1 සහ 3 කියලා හිතනවා. මේ key එක third-party marking scheme එකකින් ගත්ත එකක්.

2025 Paper I, Q37 එක "01101" කියන string එක උඩින් වම් පැත්තේ ඉඳන් loop වෙනවා. හැම "1" එකකදීම 2හි p බලය එකතු වෙනවා, ඒ වගේම අකුරක් ගානේ p එක 1කින් වැඩි වෙනවා:

  • p = 1: t = 2.
  • p = 2: t = 2 + 4 = 6.
  • p = 4: t = 6 + 16 = 22.

ඒ නිසා output එක 22, option (4), ඒකයි official key එක. "01101" කියන්නේ binary 13 කියලා හිතන ළමයෙකුට එහෙම option එකක් හොයාගන්න බැරිවෙනවා. String එක පේන විදිය නෙමෙයි, code එකෙන් කරන දේ හරියටම trace කරන්න.

4. අගයකින් නතර වෙන while loops

while loop එකක් condition එක True වෙලා තියෙනකම් run වෙලා, False වුණ ගමන් නතර වෙනවා. Resource Book එකේ මේ කොටස් initialisation, condition, body සහ increment විදියට පෙන්නනවා (Resource Book 9.8, page 50) (Resource Book 9.8, පිටුව 56). Condition එකෙන් test කරන මොනවාහරි දෙයක් body එක ඇතුළේ වෙනස් වෙන්නම ඕනේ. එහෙම වුණේ නැත්නම්, loop එක කවදාවත් නතර වෙන්නේ නෑ.

Sentinel input

Sentinel එකක් කියන්නේ "තව data නෑ" කියලා අදහස් වෙන input value එකක්. ඒක ඇත්ත data එකක් වෙන්න බෑ. Marks සහ prices කවදාවත් සෘණ වෙන්නේ නෑ, ඒ නිසා -1 කියන්නේ ගොඩක් වෙලාවට පාවිච්චි වෙන sentinel එකක්. Sentinel loop එකේ කොටස් හතරක් තියෙනවා:

  1. Loop එකට කලින් පළවෙනි value එක read කරන්න.
  2. Value එක sentinel එක නෙමෙයි කියලා test කරන්න.
  3. Body එක ඇතුළේ වැඩේ කරන්න.
  4. Body එකේ අන්තිම පේළිය විදියට ඊළඟ value එක read කරන්න.

මේ හැඩය තියෙන average හොයන program එකක හිස්තැන් හයක් 2026 Paper II, A, Q3(b) එකෙන් අහනවා. මේක code එක run කරලා check කරපු අපේම worked answer එකක්:

  • ❶ 0, ❷ total + n, ❸ count + 1.
  • ❹ n = int(input()), ❺ count, ❻ total / count.

❺ හිස්තැනට එන්න ඕනේ total නෙමෙයි, count. 0, 0, -1 කියන inputs දුන්නාම total එක 0 වෙනවා, හැබැයි අංක දෙකක් ඇතුළත් කරලා තියෙන නිසා ඒකේ average එක 0 එනවා. ඒ වගේම count = 0 වෙලා තියෙද්දී total / count දුන්නොත් program එක error එකක් ඇවිත් නතර වෙනවා. ❹ නැතුව n කවදාවත් වෙනස් වෙන්නේ නෑ, ඒ නිසා loop එක කවදාවත් නතර වෙන්නෙත් නෑ.

2025 Paper II, A, Q3(b) වලින් අහන්නේ සෘණ අංකයකට කලින් එන ඉරට්ටේ inputs වල එකතුව. 1, 2, 3, 5, -1 දුන්නාම, 2 විතරයි ඉරට්ටේ වෙන්නේ, ඒ නිසා output එක 2යි. Program එකේ read line එක තියෙන්නේ if එකෙන් එළියේ, while body එකේ අන්තිම පේළිය විදියට. ඒක if එක ඇතුළට ගියොත්, ඔත්තේ input එකක් කවදාවත් අලුත් වෙන්නේ නෑ, ඒ නිසා loop එක නතර වෙන්නෙත් නෑ. මේක අපේම worked answer එකක්.

% 10 සහ // 10 පාවිච්චි කරලා ඉලක්කම් වෙන් කරන digit loops

Digit loop එකකින් අංකයක් දකුණු පැත්තේ ඉඳන් කඩනවා. n % 10 වලින් අන්තිම ඉලක්කම දෙනවා. n // 10 වලින් ඒක අයින් කරනවා. n එක 0 වුණාම loop එක නතර වෙනවා.

2022 (held 2023) Paper II, B, Q8(a) වල 1002 ඉලක්කම් ටික එකතු කරනවා. Trace table එකක් ඇන්දොත් C = 2, 0, 0, 1 සහ B = 2, 2, 2, 3 එනවා. ඒ නිසා (i) output එක 3යි. (ii) අග ඉඳන් මුලට (reverse) print කරන්න නම්, B = B + C කියන එක B = B * 10 + C කියලා වෙනස් කරන්න ඕනේ. * 10 වලින් දැනට B එකේ තියෙන ඉලක්කම් එක තැනක් වම් පැත්තට තල්ලු කරනවා, ඊටපස්සේ C එකෙන් එකස්ථානය පුරවනවා. මේවා අපේම worked answers.

2026 Paper II, A, Q3(c) එකේ 1234 ඉඳන් 4321 ට යන flowchart එකක දීලා තියෙන්නෙත් මේ අදහසමයි. ඒකේ හිස්තැන් වලට එන්නේ reverse, n > 0, n % 10, reverse * 10 + digit සහ n = n // 10. n >= 0 දුන්නොත් loop එක කවදාවත් නතර වෙන්නේ නෑ, මොකද 0 // 10 දුන්නත් උත්තරේ 0මයි. Python code එකටත් මේ කොටස් පහම තියෙන while loop එකක් ඕනේ. මේක අපේම worked answer එකක්.

5. break සහ continue

break එකකින් එකපාරටම loop එක නතර කරනවා. continue එකකින් දැනට යන pass එක විතරක් නතර කරනවා, ඊටපස්සේ loop එක ඊළඟ pass එකෙන් දිගටම යනවා. මේ දෙකම වැඩ කරන්නේ ඒක අඩංගු වෙන ළඟම තියෙන loop එකටයි.

Resource Book දෙකේම මේ දෙකට පොඩි උදාහරණ දීලා තියෙනවා (Resource Book 9.8, pages 51 and 52) (Resource Book 9.8, පිටු 57 සහ 58). English Resource Book එකේ එක උදාහරණයක heading එක තියෙන්නේ "Continue to the next iteration if i is 3" කියලා. හැබැයි ඒකේ code එකේ තියෙන්නේ i නෙමෙයි, a කියන variable එක (Resource Book 9.8, page 52). සිංහල පොතේ ඒ heading එක හරියටම ලියලා තියෙනවා, "a == 3 නම් ඊළඟ පුනර්කරණය ක්‍රියාත්මක වේ" කියලා (Resource Book 9.8, පිටුව 58).

MCQs තුනක් හදන හැටි

  1. 2023 (held 2024) Paper I, Q43 එකේ stars ගාණ ගණන් කරනවා. i පටන් ගන්නේ 7න්. Pass 1: i = 4, එක star එකයි, 4 <= 2 කියන්නේ False, ඒ නිසා else එකෙන් දෙවෙනි star එක print කරනවා. Pass 2: i = 1, තුන්වෙනි star එක, 1 <= 2 කියන්නේ True, ඒ නිසා break වෙනවා. උත්තරය stars 3යි, option (2). break එකට කලින් print කරපු star එකත් ගණන් ගැනෙනවා.
  2. 2022 (held 2023) Paper I, Q41 එකේ val එක 9න් පටන් ගන්නවා, ඒක ඇතුළේ තියෙන range(2, 3, 1) එක හැම pass එකකදීම එක පාරක් run වෙනවා. val එක 10 (ඉරට්ටේ, ඒ නිසා continue), 13, 14, 17, 18 විදියට යනවා. උත්තරය 18, option (1). continue එකට යටින් තියෙන val += 2 කවදාවත් run වෙන්නේ නෑ. Option (2) වෙන 24 වලදී ඒකත් එකතු කරලා තියෙනවා.
  3. 2024 Paper I, Q41 එකේ tuples තියෙන list එකක් උඩින් loop වෙලා 50ට අඩු හැම mark එකක්ම continue කරලා skip කරනවා. Rajah (34) සහ rani (49) skip වෙනවා, ඒ නිසා output එක amara fahim එනවා, option (3). Option (5) වලින් කරලා තියෙන්නේ අර skip වුණ නම් දෙක print කරන එකයි. මේ key එක third-party marking scheme එකකින් ගත්ත එකක්.

2022 (held 2023) සහ 2023 (held 2024) උත්තර දෙකම අපේම worked answers, code එක run කරලා check කරපුවා.

6. Nested loops

Nested loop එකකදී, outer loop එකේ හැම pass එකකදීම inner loop එක මුලේ ඉඳන් අගටම run වෙනවා. ඒ නිසා inner body එක (outer passes) x (inner passes) ගාණක් run වෙනවා. Teachers' Guide එක මේවට "sub repetitions inside a repetition (Nested Loops)" කියනවා (Teachers' Guide 9.8, page 77). සිංහල Guide එකේ මේවට කියන්නේ "නිඩිත ලූපනයන්" කියලා (ගුරු අත්පොත 9.8, පිටුව 76).

Learning outcome එකේ nested control structures ගැන අහලා තිබුණත්, Resource Book දෙකේම control structures පිටු වල nested loop උදාහරණයක් නෑ. හැබැයි ගොඩක් අවුරුදු වල papers වල මේවා අහනවා.

  • 2026 Paper I, Q36: for එකක් ඇතුළේ while එකක්. i = 1 වෙද්දී, j = 1 වෙනවා, ඒ නිසා y = 0 + 2 = 2 වෙනවා, ඊටපස්සේ j = -1 වෙනවා. අන්තිමට x = 3 එනවා. i = 2 වෙද්දී, j = 2 වෙනවා, ඒ නිසා y = 2 + 3 = 5 වෙනවා, ඊටපස්සේ j = 0 වෙනවා. අන්තිමට x = 4 එනවා. Output එක 4 5, option (3). මේක අපේම worked answer එකක්. දෙවෙනි pass එකේදී y වලට එකතු වෙන්නේ දැනට තියෙන x, ඒ කියන්නේ 3, 2 නෙමෙයි.
  • 2024 Paper II, B, Q8(a): calculate(4) වලදී i x j එකතු කරනවා, මෙතන j run වෙන්නේ range(i) එකක් උඩින්. Sums ටික 0, ඊටපස්සේ 2, ඊටපස්සේ 0 + 3 + 6 = 9, ඊටපස්සේ 0 + 4 + 8 + 12 = 24 එනවා. ඒ නිසා උත්තරය 0 + 2 + 9 + 24 = 35 එනවා. j එක 1න් පටන් ගත්තොත් 50ක් කියලා වැරදි එකතුවක් එනවා. මේක අපේම worked answer එකක්.
  • 2023 (held 2024) Paper I, Q45: ඇතුළේ තියෙන print(..., end=' ') එකෙන් values ටික එකම පේළියේ තියාගන්නවා, ඒ වගේම එළියේ තියෙන print() එකෙන් අලුත් පේළියක් පටන් ගන්නවා. ඒ නිසා පේළි ගාණ සමාන වෙන්නේ outer passes ගාණටයි. Output එක එන්නේ 1, 2 4, 3 6 9, option (3), මේකත් අපේම worked answer එකක්.

7. Flags සහ loop else එක

Flag එකක් කියන්නේ loop එක ඇතුළේ මොකක්හරි දෙයක් වුණාද කියලා record කරන True හෝ False variable එකක්. Program එකෙන් ඒක loop එකට කලින් set කරලා, loop එක ඇතුළේදී වෙනස් කරලා, loop එකෙන් පස්සේ test කරනවා. 2026 Paper II, A, Q3(a) වල found variable එකත් flag එකක් (section 2 බලන්න).

Papers දෙකක ආපු prime numbers

අංකයක් prime වෙන්නේ 2 ඉඳන් ඊට කලින් අංකය වෙනකම් කිසිම අංකයකින් ඒක බෙදෙන්නේ නැත්නම්. මේකට loop එකෙන් හැම divisor එකක්ම බලලා, බෙදෙන පළවෙනි එක ආපු ගමන් break කරලා එළියට යනවා.

2021 (held 2022) Paper II, A, Q3(c) වල flag එකක් පාවිච්චි කරනවා. num එක 2 ඉඳන් 5 වෙනකම් යද්දී, flag එක 1න් පටන් අරන්, divisor එකක් හම්බුණ ගමන් 0 වෙනවා. ඒ නිසා output එක 2, 3 සහ 5 විදියට වෙන වෙනම පේළි වල එනවා. num = 2 වෙද්දී, range(2, 2) කියන්නේ හිස් එකක්, ඒ නිසා flag එක 1 විදියටම ඉඳලා 2 print වෙනවා. මේක අපේම worked answer එකක්.

2024 Paper II, A, Q3(c) වල loop else එක පාවිච්චි කරලා මේ දේම කරනවා. Loop else එකක් run වෙන්නේ break එකක් නැතුව loop එක ඉවර වුණොත් විතරයි. ඒ කියන්නේ else එකෙන් "කිසිම divisor එකක් හම්බුණේ නෑ" කියන එක අදහස් කරනවා, variable එකක් නැතුව flag එකේ වැඩේම කරනවා. ඒකේ හිස්තැන් පහට එන්නේ int, upper + 1, num, num % i සහ break. මේක අපේම worked answer එකක්.

8. තනියම කරලා බලන්න past paper ප්‍රශ්න

ළමයි හැම ප්‍රශ්නයක්ම අදාළ section එකේ තියෙන ක්‍රමයට තනියම කරලා බලන්න, ඊටපස්සේ එතන දීලා තියෙන උත්තරය එක්ක check කරන්න. මේ post එකේ උත්තර දීලා නැති ප්‍රශ්න තියෙන්නේ practice කරන්න.

  • for සහ range (section 3): 2019 (New Syllabus) Paper I, Q46, 2024 Paper I, Q39, 2025 Paper I, Q37, 2023 (held 2024) Paper II, A, Q3(b).
  • Sentinel while loops (section 4): 2019 (New Syllabus) Paper II, A, Q2(b), 2025 Paper II, A, Q3(b), 2025 Paper II, B, Q8(c), 2026 Paper II, A, Q3(a) සහ (b).
  • Digit loops (section 4): 2022 (held 2023) Paper II, B, Q8(a), 2024 Paper II, B, Q8(b), 2026 Paper II, A, Q3(c).
  • break සහ continue (section 5): 2019 (New Syllabus) Paper I, Q47, 2020 Paper I, Q40, 2021 (held 2022) Paper I, Q44, 2022 (held 2023) Paper I, Q41, 2023 (held 2024) Paper I, Q43, 2024 Paper I, Q41.
  • Nested loops (section 6): 2023 (held 2024) Paper I, Q45, 2024 Paper II, B, Q8(a), 2026 Paper I, Q36.
  • Flags සහ loop else (section 7): 2021 (held 2022) Paper II, A, Q3(c), 2024 Paper II, A, Q3(c), 2026 Paper II, A, Q3(a)(iii).

Old-syllabus papers වලත් මේ skills මයි අහලා තිබුණේ. තව practice වෙන්න මේවත් කරලා බලන්න.

  • 2013 Paper I, Q13: while loop trace එකක්.
  • 2016 Paper II, A, Q4(a): indentation වැරදි නිසා කවදාවත් නතර වෙන්නේ නැති while loop එකක්.
  • 2018 Paper I, Q47: එකතුවක් හදන range() තියෙන for loop එකක්.

මේ Explained එක බෙදාගන්න

A/L ICT කරන යාළුවෙකුට යවන්න.

මේ ලිපියට link කරන ලිපි

  1. සිංහල

    A/L ICT 2027 දෙවැනි පාර ලියන අයට past papers සහ unit weights අනුව හදපු study plan එක

    2027 දී A/L ICT ආයෙත් ලියන ළමයින්ට හදපු study plan එකක්. 2026 results, වැඩිම ලකුණු තියෙන units, past papers එක්ක පාඩම් කරන විදිහ, මාසෙන් මාසෙට යන timeline එකක් සහ මේ site එකේ තියෙන free papers ගැන මේකෙන් පැහැදිලි කරනවා.

  2. සිංහල

    2026 Paper II Q9 හි lists of tuples එක්ක Python functions සහ sequential search

    2026 Paper II Q9 පියවරෙන් පියවර. Fine rule එකේ තේරුම් දෙක, if සහ elif එක්ක function එකක්, loop එකකින් හදන list of tuples, -1 දෙන sequential search එක සහ මේ දේවල් Paper I එකේ එන හැටි.

  3. සිංහල

    Python loop වලට trace tables අඳින හැටි

    Python loop MCQ එකක් ඔළුවෙන් හදන්නේ නැතුව trace table එකක් ඇඳලා හදන හැටි. වැරදි උත්තර එන්නේ ඇයි කියලා past paper ප්‍රශ්නයකින් බලමු.

තවත් Explained

  1. Layer 2 සහ Layer 3 switch වල වෙනස්කම් සහ ඇත්තටම පාවිච්චි වෙන තැන්

    Layer 2 සහ Layer 3 switch එකක් වෙනස් වෙන්නේ කොහොමද, ඒවගේ වැඩ මොනවද, network වල දැන් සහ ඉස්සරහට ඒවා පාවිච්චි වෙන්නේ කොහෙද, ඒ වගේම මේවා අහන A/L ICT past paper ප්‍රශ්න උත්තර එක්කම.

    සිංහලපියවර 7ක්
  2. 1NF ඉඳන් 3NF වෙනකම් dependencies හොයලා normalisation කරන හැටි

    A/L ICT Paper II normalisation ප්‍රශ්න වලට පියවර හතරේ ක්‍රමය. Key එක හොයන්න, dependencies අඳින්න, normal form එක නම් කරන්න, table එක කඩන්න. 2019 ඉඳන් 2026 වෙනකම් paper අටකින්ම ඔප්පු කරලා තියෙනවා.

    සිංහලපියවර 6ක්
  3. Paper II OS ගණන් FAT chain එකෙන් සහ page table එකෙන් හදන හැටි

    හැම A/L ICT Paper II එකකම එන operating system calculations. FAT chains, blocks සහ wasted space, allocation method එක තෝරන හැටි, page සහ frame bits, සහ address translation, හැම එකක්ම ඇත්ත past paper ප්‍රශ්න වලින් හදලා.

    සිංහලපියවර 7ක්
All Explained