මේ post එකෙන් අපි කතා කරන්නේ 2026 Paper II, B, Q9 ප්රශ්නය ගැන. මේක library fine එකක් ගැන අහන ප්රශ්නයක්. මේකෙන් Unit 9 හි කොටස් තුනක් එකතු කරනවා. ඒ තමයි functions (9.9), data structures (9.10) සහ sequential search (9.13). මේ ප්රශ්නයේ හැඩයම 2024, 2025 සහ 2026 අවුරුදු වල ආවා. ඒ නිසා මෙතන තියෙන ක්රමයම ඊළඟ paper එකටත් වැඩ කරනවා.
මේ post එකේ කොටස් තුනක් තියෙනවා:
- ප්රශ්නය: අහන්නේ මොකක්ද, ඒක පිටිපස්සේ තියෙන අවුරුදු තුනේ රටාව සහ වෙනස් දේවල් දෙකක් කියන fine rule එක (කොටස් 1 සහ 2).
- උත්තර: (a) හි function එක, (b) හි list of tuples, (c) හි search එක සහ (d) හි trace එක (කොටස් 3 ඉඳන් 5 වෙනකම්).
- Q9 වලින් එහාට: Paper I එකේ functions ඇතුළේ එන lists සහ tuples, ඒ වගේම තනියම කරලා බලන්න past paper ප්රශ්න (කොටස් 6 සහ 7).
1. 2026 Paper II Q9 වලින් අහන දේ
Q9 එකේදී library එකකට පරක්කු වෙලා පොත් දෙන අයගේ විස්තර list of tuples විදිහට දීලා දේවල් හතරක් අහනවා: function එකක්, අලුත් list එකක්, search function එකක් සහ trace එකක්. හැම record එකක්ම (memberNo, lateDays) කියන tuple එකක්. මේ records ඔක්කොම තියෙන්නේ lateReturns කියන එකම list එකක (G.C.E. (A/L) 2026 ICT Paper II, Sinhala medium, pages 12 and 13).
මේ කොටස් හතරට ලකුණු 15 ක් දෙනවා:
- (a), ලකුණු 5: එක member කෙනෙක්ගේ fine එක return කරන
calculateFine(lateDays)ලියන්න. - (b), ලකුණු 4: සල්ලි ගෙවන්න ඕන members ලා වෙනුවෙන්
(memberNo, fine)කියන tuples තියෙනfineListකියන අලුත් list එක හදන්න. - (c), ලකුණු 4: sequential search එකක් එක්ක
searchFine(fineList, memberNo)ලියන්න. මේකෙන් fine එක return කරනවා, එහෙම නැත්නම් member ඒ list එකේ නැති වුණාම -1 return කරනවා. - (d), ලකුණු 2:
calculateFinecalls තුනක සහ එකsearchFinecall එකක output එක ලියන්න.
එකම හැඩය අවුරුදු තුනක් එක දිගට
2026 දී Python ප්රශ්නය Paper II, Part B වල Q8 ඉඳන් Q9 ට මාරු වුණා. හැබැයි මේක හදලා තියෙන මූලික කොටස් ඒ විදිහටම තියෙනවා. මේ ටික එකම කොටසක් විදිහට ඉගෙන ගන්න ළමයි.
- 2024 Paper II, B, Q8(c) list comprehension එකකින් list of tuples එකක් හදනවා. ඒක
key=lambda x: x[0]වලින් sort කරලාfor value, weight, name, index in mergedවලින් loop කරනවා. Labels නවයට අපි හදපු උත්තරේ මේකයි: An, Bweights, Cres, Dres, Eremainder, Fremainder, Gweight, Hitem_selector, Iselected. - 2025 Paper II, B, Q8 වලින් tuple එකක් return කරන function එකකුත්, list of tuples එකක් පුරවන sentinel loop එකකුත් අහනවා. ඒකේ අන්තිම කොටසින් list එක search කරලා එක ළමයෙක්ගේ marks print කරනවා. 2025 Paper II, B, Q8(b) එකට official උත්තරය එක පේළියයි:
return indexNumber, mark1, mark2, mark3. මේකේ කමා වලින්ම tuple එක හැදෙනවා. - 2026 Paper II, B, Q9 මේ දේවල් ඔක්කොම එකම ප්රශ්නයකින් අහනවා. ඒ වගේම search එකට "not found" value එකකුත් එකතු කරනවා.
Official 2025 scheme එකෙන් code එකේ හැම කොටසකටම ලකුණු දෙනවා: def පේළියට, loop එකට, if එකට සහ output එකට. ඒකේ "Codes with the same functionality are acceptable" කියලත් තියෙනවා. ඒ නිසා වෙනස් විදිහකට ලිව්වත් හරි code එකකට ලකුණු හම්බවෙනවා.
අලුත් නිර්දේශයේ 2019 ඉඳන් 2026 වෙනකම් papers අටේම functions (9.9) වලින් MCQs 10 කුත් Paper II ලකුණු 20.5 කුත් අහලා තියෙනවා. Papers හතක data structures (9.10) වලින් MCQs 9 කුත් Paper II ලකුණු 34 කුත් අහලා තියෙනවා. Sequential search සහ bubble sort (9.13) වලින් Paper II ලකුණු 9 ක් අහලා තියෙනවා. ඒ ඔක්කොම ඇවිත් තියෙන්නේ 2023 (held 2024) සහ 2026 කියන අවුරුදු දෙකේ විතරයි.
2. Fine rule එක සහ ඒකේ තේරුම් දෙක
Q9 එකේ තියෙන fine rule එක විදි දෙකකට තේරුම් ගන්න පුළුවන්. දවස් 10 කට වඩා වැඩි වුණාම මේ තේරුම් දෙකෙන් වෙනස් fines දෙකක් එනවා. Paper එකේ table එකේ තියෙන දේ මෙහෙමයි:
- දවස් 0 ඉඳන් 5 වෙනකම්: fine එකක් නෑ.
- දවස් 6 ඉඳන් 10 වෙනකම්: මුල් දවස් 5 න් පස්සේ එන හැම දවසකටම රු. 10 යි.
- දවස් 10 කට වඩා වැඩිනම්: මුල් දවස් 5 ට දවසකට රු. 10 ගානේ, ඉතුරු දවස් වලට දවසකට රු. 25 ගානේ.
- උපරිම fine එක: රු. 500 යි.
ඊට පස්සේ paper එකේ එක උදාහරණයක් දෙනවා: "lateDays = 12 නම්, fine එක (5 × 10) + (7 × 25) = 225" (G.C.E. (A/L) 2026 ICT Paper II, Sinhala medium, page 12).
තේරුම 1 තමයි worked example එක
Example එකෙන් දවස් 5 ට පස්සේ එන හැම දවසකටම රු. 25 ක් ගන්නවා. දවස් 12 කට ඒ කියන්නේ රු. 10 ගානේ දවස් 5 යි, රු. 25 ගානේ දවස් 7 යි. ඒ කියන්නේ 225 යි. Code එකේ තුන්වෙනි branch එක වෙන්නේ 5 * 10 + (lateDays - 5) * 25.
තේරුම 2 තමයි table එක විතරක් ගත්තම
6 ඉඳන් 10 වෙනකම් පේළියෙන් මුල් දවස් 5 නොමිලේ දෙනවා. ඒ නිසා රු. 10 ගානේ තියෙන "මුල් දවස් 5" කියන්නේ දවස් 6 ඉඳන් 10 වෙනකම් දවස් වලට විතරයි. "ඉතුරු දවස්" පටන් ගන්නේ 11 වෙනි දවසේ ඉඳන්. දවස් 12 කට ඒ කියන්නේ 50 + 2 × 25 = 100 යි. Code එකේ තුන්වෙනි branch එක වෙන්නේ 5 * 10 + (lateDays - 10) * 25.
Table එකෙන් එන තේරුමට කරුණු දෙකක් සහය දෙනවා:
- Example එකේ rule එකත් එක්ක fine එක දවස් 10 දී රු. 50 ඉඳන් දවස් 11 දී රු. 200 ට එකපාරටම පනිනවා. එක දවසක් පරක්කු වුණාම රු. 150 ක් එකතු වෙනවා.
- (d) කොටසේදී 125 කියන fine එක තියෙන list එකක් search කරනවා. Table එකට අනුව දවස් 13 කට 125 එනවා. හැබැයි example එකට අනුව කිසිම දවසක ගාණකට 125 එන්නේ නෑ.
හැබැයි paper එකේ rule එක ඉලක්කම් වලින් පෙන්නන එකම තැන තමයි example එක. මේ post එකේ උත්තර වලට අපි පාවිච්චි කරන්නේ example එක. ඒ වගේම table එකෙන් එන උත්තරෙත් ඒ ළඟින්ම දෙනවා.
3. if සහ elif එක්ක calculateFine
(a) කොටසට late days කියන එක parameter එකක් විදිහට අරගෙන, if සහ elif වලින් එක branch එකක් තෝරගෙන, උපරිමය බලලා, fine එක return කරන function එකක් ඕනේ. Resource Book එකේ function එකක් කියන්නේ "a block of code which only runs when it is called" කියලා. ඒකෙන් value එකක් ආපහු යවන්න return පාවිච්චි කරනවා (Resource Book 9.9, pages 53 and 54) (Resource Book 9.9, පිටු 59 සහ 60). Syllabus එකේ user defined functions යටතේ parameter passing, return values සහ default values ගැන තියෙනවා (Syllabus 9.9, page 39) (විෂය නිර්දේශය 9.9, පිටුව 36).
අපි හදපු උත්තරය (our own worked answer), worked example එකේ rule එකත් එක්ක:
def calculateFine(lateDays):
if lateDays <= 5:
fine = 0
elif lateDays <= 10:
fine = (lateDays - 5) * 10
else:
fine = 5 * 10 + (lateDays - 5) * 25
if fine > 500:
fine = 500
return fine
Table එකෙන් එන තේරුමට, else පේළිය විතරක් fine = 5 * 10 + (lateDays - 10) * 25 විදිහට වෙනස් කරන්න.
ලකුණු නැති වෙන තැන් හතරක්
- Tests වල පිළිවෙල.
elif lateDays <= 10True වෙන්නේlateDays <= 5False වුණොත් විතරයි. ඒ නිසා දෙවෙනි branch එකටlateDays >= 6ඕන වෙන්නේ නෑ. Tests අනිත් පැත්තට තිබුණොත්, දවස් 3 ත් දවස් 10 branch එකට වැටිලා -20 ක් එනවා. - return කරන්න, print නෙමෙයි. (b) කොටසේදී ගණනය කිරීමකට fine එක පාවිච්චි කරනවා. Fine එක print කරන function එකකින්
Nonereturn වෙනවා, ඊට පස්සේNone > 0නිසා error එකක් ඇවිත් program එක නවතිනවා. - උපරිමය. රු. 500 limit එක දාන්න ඕනේ branches වලට පස්සේ.
fine = min(fine, 500)කිව්වමත් මේ වැඩේම එක පේළියෙන් වෙනවා. - Parameter එකේ නම. නියත ඉලක්කමක් හරි global variable එකක් හරි නැතුව, function එක ඇතුළේ
lateDaysම පාවිච්චි කරන්න ළමයි.calculateFine(15)කියන call එක ඕනෙම ඉලක්කමකට වැඩ කරන්න ඕනේ.
(d) කොටසේ මුල් calls තුන trace කරමු
calculateFine(4): 4 කියන්නේ 5 ට සමාන හෝ අඩු ගාණක්, ඒ නිසා output එක0යි.calculateFine(7): 7 කියන්නේ 10 ට සමාන හෝ අඩු ගාණක්, ඒ නිසා (7 - 5) × 10 න්20එනවා.calculateFine(15): worked example එකත් එක්ක, 50 + 10 × 25 න්300එනවා. Table එකත් එක්ක, 50 + 5 × 25 න්175එනවා. මේ දෙකම උපරිමයට වඩා අඩුයි.
4. list of tuples එකකින් fineList එක හැදීම
(b) කොටසට lateReturns දිගේ යන loop එකක් ඕනේ. ඒකෙන් හැම record එකකටම calculateFine call කරලා, fine එක 0 ට වඩා වැඩි නම් විතරක් අලුත් tuple එකක් එකතු කරන්න ඕනේ. List එකක් කියන්නේ "ordered and changeable" දෙයක්, ඒකට කොටු වරහන් පාවිච්චි කරනවා. Tuple එකක් ordered වුණාට ඒක "unchangeable (immutable)" දෙයක්, ඒකට රවුම් වරහන් පාවිච්චි කරනවා (Resource Book 9.10, pages 56 and 59) (Resource Book 9.10, පිටු 62 සහ 65). සිංහල Resource Book එකේ මේවට කියන්නේ "ලැයිස්තුව" සහ "ටපලය" කියලා, සිංහල paper එකේ පාවිච්චි කරන්නේත් මේ වචනම තමයි.
අපි හදපු උත්තරය:
lateReturns = [("M001", 1), ("M002", 5), ("M003", 10), ("M004", 20), ("M005", 30)]
fineList = []
for memberNo, lateDays in lateReturns:
fine = calculateFine(lateDays)
if fine > 0:
fineList.append((memberNo, fine))
print(fineList)
Worked example එකේ rule එකත් එක්ක fineList එක වෙන්නේ [("M003", 50), ("M004", 425), ("M005", 500)]. Table එකත් එක්ක බැලුවොත් M004 ට 425 වෙනුවට 300 එනවා. M001 ට සහ M002 ට පරක්කු වුණ දවස් 1 යි 5 යි තියෙන්නේ, ඒ නිසා එයාලගේ fine එක 0 යි, එයාලව අයින් කරනවා. M005 ට දවස් 30 ක් තියෙන නිසා fine එක රු. 500 උපරිමයෙන් නවතිනවා.
Loop එක ඇතුළේ තියෙන කරුණු තුනක්
- for පේළියේදී tuple එක unpack කරන්න.
for memberNo, lateDays in lateReturnsවලින් හැම කොටසකටම නමක් දෙනවා.record[0]සහrecord[1]එක්කfor record in lateReturnsකියලා ලිව්වත් හරි. - append එකේ වරහන් දෙකක්.
appendඑකට එක දෙයයි දෙන්න පුළුවන්, මෙතන ඒ දේ වෙන්නේ tuple එකක්. ඒ නිසාfineList.append((memberNo, fine))කියලා ලියන්න.fineList.append(memberNo, fine)කියලා ලිව්වොත් TypeError එකක් ඇවිත් නවතිනවා. - හිස් list එකකින් පටන්ගන්න.
fineList = []එන්නේ loop එකට කලින්. ඒක loop එක ඇතුළේ තිබ්බොත්, හැම පාරකදීම list එක හිස් වෙනවා.
2024 Paper II, B, Q8(c) වල තිබ්බ විදිහටම, list comprehension එකකින් මේ list එකම එක පේළියකින් හදන්න පුළුවන්:
fineList = [(m, calculateFine(d)) for m, d in lateReturns if calculateFine(d) > 0]
fineList එක ඇතුළේ තියෙන tuples වෙනස් කරන්න බෑ, හැබැයි list එක වෙනස් කරන්න පුළුවන්. M004 ගේ fine එක වෙනස් කරන්න ඕනෙ නම්, සම්පූර්ණ tuple එකම අලුතින් දාන්න: fineList[1] = ("M004", 300). fineList[1][1] = 300 කියලා ලිව්වොත් TypeError එකක් ඇවිත් නවතිනවා. මේක තමයි tuple එකකට Resource Book එකේ පෙන්නන error එක (Resource Book 9.10, page 59) (Resource Book 9.10, පිටුව 65).
5. Sequential search එකක් විදිහට searchFine
Sequential search එකකදී මුල ඉඳන් එකින් එක අයිතම check කරනවා, එකක් හම්බවුණු ගමන්ම return වෙනවා. "not found" කියලා කියන්නේ loop එක ඉවර වුණාට පස්සේ විතරයි. Teachers' Guide එකේ ළමයින්ට කියනවා මේ ක්රමයෙන් "a data set stored in an array" search කරන්න කියලා (Teachers' Guide 9.13, page 84) (ගුරු අත්පොත 9.13, පිටුව 83). සිංහල පොත් වල මේකට කියන්නේ "අනුක්රමික සෙවුම", මේ වචනය තමයි සිංහල paper එකේ තියෙන්නෙත්.
(c) කොටසට අපි හදපු උත්තරය:
def searchFine(fineList, memberNo):
for record in fineList:
if record[0] == memberNo:
return record[1]
return -1
Loop එක ඇතුළේ තියෙන return record[1] නිසා මුලින්ම ගැලපෙන තැනින් function එක ඉවර වෙනවා. return -1 එක වැඩ කරන්නේ ගැලපෙන මුකුත් නැතුව loop එක ඉවර වුණොත් විතරයි. Fine එකක් කවදාවත් සෘණ වෙන්නේ නෑ, ඒ නිසා -1 කියන්නේ ඇත්ත fine එකක් කියලා පටලවගන්න විදිහක් නෑ. මේක while loop එකක එන sentinel value එකේ අදහසම තමයි.
අහුවෙන උගුල තමයි loop එක ඇතුළේ return -1 ලියන එක
return -1 එක if එක යටතේ else එකක ලිව්වොත්, ගැලපුනත් නැතත් පලවෙනි record එකෙන්ම function එක return වෙනවා. fineList = [("M003", 50), ("M004", 425), ("M005", 500)] එක්ක M004 ව හොයද්දී, මුලින්ම M003 ව check කරනවා, else එකට යනවා, ඊට පස්සේ -1 return කරනවා. මේකෙන් හොයාගන්න පුළුවන් වෙන්නේ පලවෙනි member ව විතරයි. නිවැරදි code එකෙන් එන උත්තරයම flag එකක් පාවිච්චි කරලත් ගන්න පුළුවන්. Loop එකට කලින් found = False කියලා දෙන්න, ගැලපෙන තැනකදී ඒක True කරන්න, ඊට පස්සේ loop එක ඉවර වුණාම ඒක test කරන්න. මේ flag ක්රමය Python loop tracing with trace tables post එකේ තියෙනවා.
(d) කොටසේ අන්තිම call එක
searchFine([("M002", 30), ("M003", 125), ("M005", 500)], "M003") call එක මුලින්ම M002 ව check කරනවා, ඊට පස්සේ M003 ව හොයාගෙන 125 return කරනවා. මේ call එකේදී calculateFine පාවිච්චි කරන්නේ නෑ. ඒකෙන් කරන්නේ list එකේ තියෙන ඉලක්කම කියවන එක විතරයි. ඒ නිසා (d) කොටසේ සම්පූර්ණ output එක වෙන්නේ 0, 20, 300 සහ 125. මේවා එකින් එක වෙනම පේළි වල ලියන්න. Table එකෙන් එන තේරුමට අනුව තුන්වෙනි පේළිය 175 වෙනවා.
6. Paper I එකේ functions ඇතුළේ එන lists සහ tuples
Paper I එකෙනුත් මේ කොටස්ම කෙටි code වලින් අහනවා: function එකකට list එකක් යවන හැටි, list එකක copy එකක් ගන්න හැටි සහ එක එක data structure එකට එන වරහන් මොනවාද කියලා. Teachers' Guide එකේ ළමයින්ට කියනවා "identify the data structures Strings, Lists, Tuples, Dictionaries used in a sample program" කියලා (Teachers' Guide 9.10, page 81) (ගුරු අත්පොත 9.10, පිටුව 80).
Function එකකට යවන list එකක් කියන්නේ ඒ list එකමයි
2026 Paper I, Q37 ප්රශ්නයේදී stock = [5, 10, 15] කියන එක functions දෙකකට යවනවා. update එකෙන් item 1 ව 50 කරනවා. restock එකෙන් range(2) හරහා ගිහින් items 0 සහ 1 වලට 10 ගානේ එකතු කරනවා. උත්තරය [15, 60, 15] වෙනවා, ඒ කියන්නේ (3) වෙනි option එක. ඒක අපි හදපු උත්තරය. Option (1) එකෙන් හිතන්නේ function එක වැඩ කරන්නේ copy එකක් එක්ක කියලා. Option (4) එකෙන් range(2) කියන්නේ items තුනක් කියලා හිතනවා.
Copy method එක සහ structure එකකට එන වරහන්
- 2026 Paper I, Q38:
record["ICT"]පටන් ගන්නේ 20 වෙනstudent[2]වලින්, ඊට පස්සේ ඒක 70 වෙනවා.copy()වලින් අලුත් list එකක් හැදෙනවා, ඒ නිසාclear()සහappend(100)වලින් වෙනස් වෙන්නේnew_listඑක විතරයි. උත්තරය['Saman', 70] [100], (1) වෙනි option එක. ඒක අපි හදපු උත්තරය. Option (2) එක පාවිච්චි කරන්නේstudent[1], ඒ කියන්නේ 17. - 2026 Paper I, Q39: වරහන් වලින් structure එක මොකක්ද කියලා කියනවා.
"My Name"කියන්නේ string එකක්,[10, 20, 30]කියන්නේ list එකක්,(10, 20, 30)කියන්නේ tuple එකක් සහ{"B": 85, "A": 90}කියන්නේ dictionary එකක්. උත්තරය වෙන්නේ A 4, B 1, C 3, D 2, ඒ කියන්නේ (4) වෙනි option එක. ඒක අපි හදපු උත්තරය. - 2025 Paper I, Q36:
(1,2,3)[-1]කියන්නේ අන්තිම අයිතමය, ඒ කියන්නේ 3. ගුණ කිරීම මුලින්ම වෙනවා, ඒ නිසා 3 + 12 න් 15 එනවා, ඒ කියන්නේ (2) වෙනි option එක, official key එක.
7. තනියම කරලා බලන්න past paper ප්රශ්න
හැම ප්රශ්නයක්ම ඒ අදාළ section එකේ ක්රමයට කරලා බලන්න. ඊට පස්සේ එතන දීලා තියෙන උත්තරේ එක්ක බලන්න. මේ post එකේ උත්තර දීලා නැති ප්රශ්න තියෙන්නේ practice කරන්න.
- Functions (3 වෙනි කොටස): 2019 (New Syllabus) Paper I, Q48, 2020 Paper I, Q38, 2021 (held 2022) Paper I, Q42, 2022 (held 2023) Paper I, Q38, Q39 සහ Q42, 2022 (held 2023) Paper II, B, Q8(b), 2023 (held 2024) Paper I, Q40 සහ Q41, 2023 (held 2024) Paper II, A, Q3(c), 2024 Paper I, Q40, 2024 Paper II, A, Q3(b), 2025 Paper II, B, Q8(a).
- Lists, tuples සහ dictionaries (4 සහ 6 වෙනි කොටස්): 2020 Paper I, Q36 සහ Q37, 2020 Paper II, A, Q2(b), 2021 (held 2022) Paper I, Q43, 2022 (held 2023) Paper I, Q40, 2023 (held 2024) Paper I, Q42 සහ Q44, 2025 Paper I, Q36, 2026 Paper I, Q37, Q38 සහ Q39.
- Paper II හි Lists of tuples (1 සහ 4 වෙනි කොටස්): 2024 Paper II, B, Q8(c), 2025 Paper II, B, Q8(b) සහ (c), 2026 Paper II, B, Q9(a), (b) සහ (d).
- Search සහ sort (5 වෙනි කොටස): 2023 (held 2024) Paper II, B, Q8(b), 2025 Paper II, B, Q8(d), 2026 Paper II, B, Q9(c).
පරණ නිර්දේශයේ papers වලත් මේ කොටස්ම අහලා තියෙනවා. තව practice කරන්න මේවත් කරලා බලන්න ළමයි.
- 2012 Paper I, Q49: list එකක තියෙන ලොකුම අයිතමයේ index එක return කරන function එකක්.
- 2015 Paper I, Q46: tuple එකක් return කරන function එකක්.
- 2018 Paper II, B, Q4(b)(ii): sequential search එකක අරමුණ.
