പൈത്തണ്‍: പാഠം ആറ്

ആമുഖം

1, 2, 3, ... മുതലായ, എണ്ണാനുപയോഗിക്കുന്ന സംഖ്യകളെയാണല്ലോ എണ്ണല്‍സംഖ്യകള്‍ എന്നു വിളിക്കുന്നത്? "സംഖ്യ" എന്ന് വിളിക്കപ്പെടുന്നവയില്‍ ഏറ്റവും ലളിതവും സുഗ്രാഹ്യവുമായവ എണ്ണല്‍സംഖ്യകളാണ്. എണ്ണല്‍സംഖ്യകളെ പരിചയമില്ലാത്ത മുതിര്‍ന്ന ഒരാള്‍പോലും ഉണ്ടാവില്ല; അക്ഷരമറിയാത്തവര്‍ക്കുപോലും എണ്ണല്‍ അറിയുമായിരിക്കും. നമ്മുടെ സമൂഹത്തില്‍ ജീവിച്ചുപോകണമെങ്കില്‍ എണ്ണല്‍ അറിയാതെ നിവൃത്തിയില്ല. നന്നേ ചെറുപ്രായത്തില്‍ത്തന്നെ മറ്റുള്ളവര്‍ നമ്മെ എണ്ണാന്‍ പഠിപ്പിക്കുന്നു. എന്തിന്റെയെങ്കിലുമൊക്കെ എണ്ണം ചോദിക്കുന്നത് കുട്ടികളോടുള്ള കൊഞ്ചലിന്റെതന്നെ ഭാഗമാണ്.

എണ്ണുന്നതിന്റെ അത്രത്തോളം തന്നെ ലളിതവും സ്വാഭാവികവുമാണ് നമ്മില്‍ മിക്കവര്‍ക്കും സങ്കലനം — രണ്ടു സംഖ്യകള്‍ കൂട്ടി ഒരു സംഖ്യയാക്കുക — എന്ന ക്രിയയും. സ്കൂളില്‍ നന്നേ ചെറിയ ക്ളാസില്‍ത്തന്നെ ഇത് പഠിപ്പിക്കുന്നു. സംഖ്യകള്‍ ശരിക്കു കൂട്ടാന്‍ അറിയാതെ സ്കൂളില്‍ "പഠിച്ച്" ഇറങ്ങുന്നവരും പുറംലോകത്ത് എന്തെങ്കിലുമൊക്കെ ജോലിചെയ്തു ജീവിച്ചുതുടങ്ങുമ്പോള്‍ കൂട്ടലും കിഴിക്കലുമൊക്കെ തനിയേ പഠിച്ചുപോകുന്നു. എന്നാല്‍ സങ്കലനത്തിന്റെ അത്രതന്നെ എളുപ്പമല്ല അടുത്ത ക്രിയയായ ഗുണനം — ചെറുപ്പത്തില്‍ ഗുണനപ്പട്ടിക കാണാതെ പഠിക്കാന്‍ പെട്ട പാടും കിട്ടിയ ശിക്ഷകളുമൊക്കെ നമ്മില്‍ ചിലര്‍ക്കെങ്കിലും ഓര്‍മ്മകാണും. സംഖ്യകളെടുത്ത് പെരുമാറി — സ്കൂളിലെന്നതിലുപരി പുറത്ത്: മിക്കവാറും ക്രിക്കറ്റില്‍ സ്കോര്‍ ഗണിച്ചെടുത്തും മറ്റും — കുറേ പരിചയം വരുമ്പോള്‍ ഗുണനത്തെ ആവര്‍ത്തിച്ചുള്ള സങ്കലനമായി കാണാന്‍ നാം അറിയാതെ പഠിക്കുന്നു.

ഗുണനമെന്നാല്‍ ആവര്‍ത്തിച്ചുള്ള സങ്കലനമാണെങ്കിലും രണ്ടിന്റെയും സ്വഭാവങ്ങള്‍തമ്മില്‍ കാതലായ വ്യത്യാസങ്ങളുണ്ട്. ഉദാഹരണമായി, നാലോ അതിലധികമോ ആയ ഏത് എണ്ണല്‍സംഖ്യയെയും മറ്റുരണ്ട് എണ്ണല്‍സംഖ്യകളുടെ തുകയായി ഒന്നിലധികം രീതിയില്‍ എഴുതാം. അതായത്,

• 4 = 1 + 3 = 2 + 2
• 5 = 1 + 4 = 2 + 3
• 10 = 1 + 9 = 2 + 8 = 3 + 7 = 4 + 6 = 5 + 5

എന്നിങ്ങനെ. ഗുണനത്തിന് ഇതേ സ്വഭാവം ഇല്ല . ഉദാഹരണമായി, 10 എന്ന സംഖ്യയെ രണ്ട് എണ്ണല്‍സംഖ്യകളുടെ ഗുണിതമായി രണ്ടുതരത്തില്‍ എഴുതാമെങ്കിലും — 10 = 1 x 10 = 2 x 5 — പതിനൊന്നിനെ ഒരേ ഒരു രീതിയിലേ ഇങ്ങനെ എഴുതാന്‍ പറ്റൂ: 11 = 1 x 11 എന്ന് മാത്രം (മറ്റേതെങ്കിലും രീതിയില്‍ രണ്ട് എണ്ണല്‍സംഖ്യകളുടെ ഗുണിതമായി 11-നെ എഴുതാമോ എന്ന് ശ്രമിച്ചുനോക്കൂ!). 1 അല്ലാതെ മറ്റൊരു സംഖ്യയേയും പലതവണ അതിനോടുതന്നെ കൂട്ടി കൃത്യം 11-ല്‍ എത്തിക്കാന്‍ പറ്റില്ല എന്നര്‍ത്ഥം. ഇങ്ങനെയുള്ള — പതിനൊന്നിനെപ്പോലെയുള്ള — സംഖ്യകളെ അഭാജ്യസംഖ്യകള്‍ (prime numbers) എന്ന് വിളിക്കുന്നു.

അഭാജ്യസംഖ്യകള്‍

16-നെ 16 = 1 x 16 = 2 x 8 = 4 x 4 എന്നിങ്ങനെ ഗുണിതങ്ങളായി എഴുതാമല്ലോ. 1, 2, 4, 8, 16 എന്നിവയെ 16-ന്റെ ഘടകങ്ങള്‍ (factors) എന്ന് വിളിക്കുന്നു. ഇതുപോലെ 21-നെ 21 = 1 x 21 = 3 x 7 എന്നിങ്ങനെ എഴുതാം; 1, 3, 7, 21 എന്നിവയാണ് 21-ന്റെ ഘടകങ്ങള്‍. ഏത് എണ്ണല്‍സംഖ്യയുടെയും ഘടകമായി 1-ഉം ആ സംഖ്യതന്നെയും ഉണ്ടാവും എന്ന് കുറച്ചൊന്നാലോചിച്ചാല്‍ മനസ്സിലാകും — 1-നെ അതിനോടുതന്നെ പല പ്രാവശ്യം കൂട്ടി ഏത് എണ്ണല്‍സംഖ്യയിലും എത്തിക്കാം; ഏത് എണ്ണല്‍സംഖ്യയും "ഒരു പ്രാവശ്യം കൂട്ടിയാല്‍" ആ സംഖ്യതന്നെയാണുതാനും.

കൃത്യം രണ്ടു ഘടകങ്ങള്‍ ഉള്ള സംഖ്യകളെ — മേല്‍പ്പറഞ്ഞതില്‍നിന്ന് ഈ ഘടകങ്ങള്‍ 1-ഉം ആ സംഖ്യതന്നെയും ആയിരിക്കും എന്നത് വ്യക്തമാണ് — അഭാജ്യസംഖ്യകള്‍ അല്ലെങ്കില്‍ അഭാജ്യങ്ങള്‍ എന്ന് വിളിക്കുന്നു. ഉദാഹരണത്തിന് 2, 3, 5, 7 എന്നിവ അഭാജ്യങ്ങളാണ്. 2 = 1 x 2, 3 = 1 x 3, 5 = 1 x 5, 7 = 1 x 7 എന്നിങ്ങനെ നിസ്സാരമായ (trivial) ഒരേ ഒരു രീതിയിലല്ലാതെ ഈ സംഖ്യകളെ ഗുണനഫലങ്ങളായി എഴുതാന്‍ പറ്റില്ലല്ലോ. വേറൊരു രീതിയില്‍ നോക്കിയാല്‍, ഇവയെ നിസ്സാരമായ രീതിയിലല്ലാതെ ഒരേ പൂര്‍ണ്ണസംഖ്യാവലുപ്പമുള്ള ഭാഗങ്ങളായി "മുറിക്കാന്‍" പറ്റില്ല. ഉദാഹരണത്തിന്, അഞ്ച് മാങ്ങകളെ ഒരു മാങ്ങ വീതമുള്ള അഞ്ച് കൂട്ടങ്ങളാക്കാം; ഒരേ എണ്ണം വീതമുള്ള പല കൂട്ടങ്ങളാക്കാന്‍ മറ്റൊരു രീതിയിലും പറ്റില്ല. "അഭാജ്യം" എന്ന പേരിന് കാരണവും ഇതുതന്നെ. നൂറിനെക്കാള്‍ ചെറുതായ അഭാജ്യങ്ങളെ താഴെ എടുത്തെഴുതുന്നു.

നൂറില്‍ താഴെയുള്ള അഭാജ്യങ്ങള്‍

2	3	5	7	11
13	17	19	23	29
31	37	41	43	47
53	59	61	67	71
73	79	83	89	97

ഇങ്ങനെയൊരു പട്ടിക നമുക്കെങ്ങനെയുണ്ടാക്കാം? 1 മുതല്‍ 100 വരെയുള്ള സംഖ്യകള്‍ ഓരോന്നും അഭാജ്യമാണോ എന്ന് നോക്കിയാല്‍ മതി. 2 ഒഴികെയുള്ള ഇരട്ടസംഖ്യകളൊന്നും തന്നെ അഭാജ്യങ്ങളല്ലാത്തതുകൊണ്ട് 1 മുതല്‍ 100 വരെയുള്ളതില്‍ പകുതി സംഖ്യകളെപ്പറ്റി അധികം പ്രയാസപ്പെടാതെതന്നെ നമുക്കൊരു തീരുമാനമുണ്ടാക്കാം : 2-നെ പട്ടികയില്‍ പെടുത്തണം, മറ്റ് ഇരട്ടസംഖ്യകളൊന്നുംതന്നെ പട്ടികയില്‍ വേണ്ട. ഇനി ബാക്കിയുള്ള അമ്പത് ഒറ്റ സംഖ്യകളെപ്പറ്റി മാത്രം ആലോചിച്ചാല്‍ മതി. ഇവയില്‍ 1-നെ പട്ടികയില്‍ വേണ്ട, 3, 5, 7 എന്നിവയെ വേണം. അവശേഷിക്കുന്ന ഒറ്റസംഖ്യകളില്‍ 3-ന്റെയും 5-ന്റെയും ഗുണിതങ്ങളെ നമുക്ക് വേഗം തിരിച്ചറിഞ്ഞ് ഒഴിവാക്കാം (എങ്ങനെ?). ബാക്കിയുള്ള ഒറ്റസംഖ്യകളുടെ കാര്യമാണ് അത്ര എളുപ്പം കിട്ടാത്തത്. ഉദാഹരണത്തിന്, 67-നെ അതിനെക്കാള്‍ ചെറിയ ഏതെങ്കിലും സംഖ്യകൊണ്ട് പൂര്‍ണ്ണമായും ഹരിക്കാമോ എന്ന് എങ്ങനെ കണ്ടുപിടിക്കും? ഹരിച്ചുനോക്കുകയേ നിവൃത്തിയുള്ളൂ (എനിക്കറിയാവുന്നിടത്തോളം). ഇങ്ങനെ കുറച്ചു കഷ്ടപ്പെട്ടാല്‍ മേല്‍ക്കൊടുത്ത പട്ടികയുണ്ടാക്കാം.

ഇനി 100 മുതല്‍ 200 വരെയുള്ള അഭാജ്യങ്ങളേതാണെന്ന് ചോദിച്ചാലോ? 1000 വരെയുള്ളതാണെങ്കിലോ? ഇതേ രീതിയില്‍ത്തന്നെ കണ്ടുപിടിക്കണം. ഓരോ പുതിയ സംഖ്യയും അഭാജ്യമാണോ എന്ന് നോക്കാനുള്ള ബുദ്ധിമുട്ട് ഏറിയേറി വരും. എവിടെയെങ്കിലും ഒരു തെറ്റുവരുത്താനുള്ള സാധ്യത നല്ലതുപോലെയുണ്ടുതാനും. ചുരുക്കിപ്പറഞ്ഞാല്‍, ലളിതമായ എന്നാല്‍ മടുപ്പിക്കുന്ന പണിക്കുള്ള നല്ല ഒരുദാഹരണം. കംപ്യൂട്ടറിന് ഏറ്റവും ശോഭിക്കാവുന്നതും ഇങ്ങനെയുള്ള കാര്യങ്ങളിലാണ്. മുകളിലെ പട്ടിക ഞാന്‍ മെനക്കെട്ട് കണ്ടുപിടിച്ചതല്ല. മുകളില്‍ വിവരിച്ച അതേ ലോജിക് അനുസരിച്ചുള്ള ഒരു പ്രോഗ്രാം എഴുതി കംപ്യൂട്ടറിനെക്കൊണ്ട് ചെയ്യിച്ചതാണ്. ഈ പ്രോഗ്രാം ഉപയോഗിച്ച് അഭാജ്യങ്ങളുടെ പട്ടികയുണ്ടാക്കാന്‍ കംപ്യൂട്ടര്‍ വളരെക്കുറച്ച് സമയമേ എടുത്തുള്ളൂ: സെക്കന്റിന്റെ പത്തിലൊരംശമോ മറ്റോ. അതായത്, നാം ഈ പട്ടിക വായിക്കാന്‍ എടുക്കുന്ന സമയത്തിന്റെ നൂറിലൊരംശമോ അതില്‍ കുറവോ മാത്രം.

ഇതേ പ്രോഗ്രാമില്‍ ചെറിയ മാറ്റങ്ങള്‍ വരുത്തി 100 മുതല്‍ 200 വരെയുള്ള അഭാജ്യങ്ങള്‍ കണ്ടുപിടിച്ചത് ഇതാ:

നൂറിനും ഇരുനൂറിനും ഇടയ്ക്കുള്ള അഭാജ്യങ്ങള്‍

101	103	107	109	113	127
131	137	139	149	151	157
163	167	173	179	181	191
193	197	199

ഒരു പൂര്‍ണ്ണസംഖ്യ അഭാജ്യമാണോ എന്ന് പ്രോഗ്രാമെഴുതി എങ്ങനെ കണ്ടുപിടിക്കാം? ഏറ്റവും ലളിതമായ വഴി ആ സംഖ്യയെക്കാള്‍ ചെറുതും 1-നെക്കാള്‍ വലുതുമായ ഏതെങ്കിലും പൂര്‍ണ്ണസംഖ്യകൊണ്ട് അതിനെ നിശ്ശേഷം (നിശ്ശിഷ്ടം?) ഹരിക്കാമോ എന്ന് നോക്കുക എന്നതാണ്. ഉദാഹരണത്തിന് 5 അഭാജ്യമാണോ എന്ന് നോക്കുന്ന പ്രോഗ്രാം ഇതാ:

പ്രവര്‍ത്തനങ്ങള്‍

പ്രവ. 1.

ഈ പ്രോഗ്രാം പ്രവര്‍ത്തിപ്പിച്ചുനോക്കുക. ഇത് ശരിയായ ഉത്തരം തരുന്നുണ്ടോ? ഈ പ്രോഗ്രാം പ്രവര്‍ത്തിക്കുന്നതെങ്ങനെ എന്ന് മനസ്സിലാക്കുക.

പ്രവ. 2.

ഇതേ രീതിയില് 15 അഭാജ്യമാണോ എന്ന് കണ്ടുപിടിക്കുന്ന പ്രോഗ്രാം എഴുതി പ്രവര്‍ത്തിപ്പിച്ചുനോക്കുക.

ഈ പ്രോഗ്രാമിന് എന്താണു കുഴപ്പം?

രണ്ടു പ്രവര്‍ത്തനങ്ങളും ചെയ്തുനോക്കിയാല്‍ മുകളിലെ ഉദാഹരണത്തിന് എന്താണ് കുഴപ്പമെന്ന് മനസ്സിലാകും. ഒരു വലിയ സംഖ്യ (ഉദാ: 1234787) അഭാജ്യമാണോ എന്ന് ഈ രീതിയില്‍ പ്രോഗ്രാമെഴുതി കണ്ടുപിടിക്കുന്ന കാര്യം ആലോചിച്ചുനോക്കൂ. പേജുകണക്കിന് വരുന്ന വളരെ വലിയ ഒരു പ്രോഗ്രാമായിരിക്കും അത്. ചില സംഖ്യകളൊക്കെ എഴുതാന്‍ വിട്ടുപോകുന്നതുവഴി പ്രോഗ്രാമില്‍ തെറ്റുവരാനുള്ള സാധ്യതയും കൂടുതലാണ്. 101 മുതല്‍ 200 വരെയുള്ള അഭാജ്യസംഖ്യകള്‍ ഏതൊക്കെയാണെന്ന് കണ്ടുപിടിക്കാന്‍ ഇങ്ങനെ പ്രോഗ്രാമെഴുതണമെങ്കില്‍ ഒരു ദിവസം മുഴുവന്‍ ഇരുന്നെഴുതേണ്ടിവരും; എഴുതിക്കഴിഞ്ഞാലും അത് ശരിയാണോ എന്ന് നമുക്ക് വലിയ ഉറപ്പൊന്നും കാണുകയുമില്ല — ഏതെങ്കിലുമൊക്കെ സംഖ്യകള്‍കൊണ്ട് ഹരിച്ചാലുള്ള ശിഷ്ടം പൂജ്യമാണോ എന്നുനോക്കാന്‍ ഇടയ്ക്കെങ്ങാനും വിട്ടുപോയിട്ടില്ല എന്ന് എങ്ങനെ ഉറപ്പിക്കും?

1234787 അഭാജ്യമാണ്. ഈ പാഠം പഠിച്ച് ഇതിലെ പ്രവര്‍ത്തനങ്ങള്‍ ചെയ്തുകഴിയുമ്പോഴേക്കും ഏതു സംഖ്യയും അഭാജ്യമാണോ എന്ന് പരിശോധിക്കുന്ന പ്രോഗ്രാമെഴുതാന്‍ നാം പഠിച്ചിരിക്കും.

നമ്മുടെ പ്രോഗ്രാമിന്റെ ലോജിക്കിനെപ്പറ്റി നമുക്ക് ഒന്നുകൂടി ഒന്ന് ആലോചിച്ചുനോക്കാം. 1-നെക്കാള്‍ വലുതും, തന്നിരിക്കുന്ന സംഖ്യയെക്കാള്‍ ചെറുതുമായ ഓരോ പൂര്‍ണ്ണസംഖ്യയെക്കൊണ്ടും തന്നിരിക്കുന്ന സംഖ്യയെ ഹരിച്ചാല്‍ കിട്ടുന്ന ശിഷ്ടം പൂജ്യമാണോ എന്ന് നോക്കുക എന്നതാണ് പ്രോഗ്രാം ചെയ്യുന്നത്. ഇങ്ങനെ വലിയൊരുകൂട്ടം സംഖ്യകളെടുത്ത് പെരുമാറേണ്ടതുകൊണ്ടാണ് പ്രോഗ്രാമിന്റെ വലുപ്പം (അതെഴുതാനെടുക്കുന്ന സമയവും) തന്നിരിക്കുന്ന സംഖ്യ വലുതാകുന്തോറും വലുതായിക്കൊണ്ടേയിരിക്കുന്നത്. ഈ പ്രശ്നം പരിഹരിക്കാന്‍ (മറ്റനേകം ഉപയോഗങ്ങള്‍ക്കും) പൈത്തണില്‍ ലഭ്യമായ ഒരു ഉപാധിയാണ് range() .

range()

പൈത്തണില്‍ സംഖ്യകളുടെ സമാന്തരശ്രേണികള്‍ (arithmetic progressions) നിര്‍മ്മിക്കാനുള്ള ഒരു ഉപാധിയാണ് range() . ഇതെന്താണെന്ന് മനസ്സിലാക്കാനുള്ള ഏറ്റവും എളുപ്പ വഴി (പ്രോഗ്രാമിംഗില്‍ മറ്റു മിക്ക കാര്യങ്ങള്‍ക്കുമെന്നതുപോലെ) ഇതിന്റെ പെരുമാറ്റം എങ്ങനെയാണ് എന്ന് നോക്കുകയാണ്. പൈത്തണ്‍ ഷെല്‍ (IDLE-ലോ അല്ലാതെയോ) തുറന്ന് താഴെക്കാണുന്ന പ്രോഗ്രാം ശകലങ്ങള്‍ ഓരോന്നായി പരീക്ഷിച്ചുനോക്കുക:





range() -ന്റെ ഒരു ഉപയോഗം മനസ്സിലായല്ലോ. പൂജ്യം മുതല്‍ സൂചിപ്പിച്ച സംഖ്യയ്ക്ക് തൊട്ടുമുമ്പുവരെയുള്ള പൂര്‍ണ്ണസംഖ്യകളുടെ ഒരു ശ്രേണി range() നമുക്ക് [, ] എന്നീ ചതുര ബ്രായ്ക്കറ്റുകള്‍ക്കുള്ളിലായി തരുന്നു. ഇങ്ങനെ ചതുര ബ്രായ്ക്കറ്റുകള്‍ക്കുള്ളില്‍ അര്‍ധവിരാമം (കോമ : , ) ഉപയോഗിച്ച് വേര്‍തിരിച്ച് മൂല്യങ്ങള്‍ എഴുതുന്നതിന് ലിസ്റ്റ് – list – എന്നതാണ് പൈത്തണിലെ സാങ്കേതികപദം. range() മേല്‍ക്കാണിച്ചതുപോലെ ഉപയോഗിച്ച് പൂജ്യം മുതല്‍ ഏത് നിശ്ചിത സംഖ്യ വരെയുമുള്ള പൂര്‍ണ്ണസംഖ്യകളുടെ ലിസ്റ്റുകള്‍ നമുക്കുണ്ടാക്കാം.

range() -ന് വേറെയും ചില കഴിവുകളുണ്ട്. ഇവയെന്താണെന്ന് മനസ്സിലാക്കാന്‍ താഴെക്കാണുന്നവ പരീക്ഷിച്ചുനോക്കുക:









ഓരോ പ്രാവശ്യവും ഏറ്റവും അവസാനം വരുന്ന സംഖ്യ ഏതാണെന്ന് പ്രത്യേകം ശ്രദ്ധിക്കുക.

പ്രവര്‍ത്തനം

പ്രവ. 3.

താഴെക്കൊടുത്തിരിക്കുന്ന പ്രോഗ്രാം ശകലങ്ങളുടെ ഔട്പുട്ട് എന്തായിരിക്കും എന്ന് ഊഹിച്ചുനോക്കുക. ഊഹം കൃത്യമാണോ എന്ന് പരീക്ഷിച്ചുനോക്കുക.

ഒരു സംഖ്യ — ഉദാഹരണത്തിന് 67 — അഭാജ്യമാണോ എന്നറിയാന്‍ നമ്മുടെ പ്രോഗ്രാം 2 മുതല്‍ 66 വരെയുള്ള ഏതെങ്കിലും പൂര്‍ണ്ണസംഖ്യകൊണ്ട് 67-നെ നിശ്ശിഷ്ടം ഹരിക്കാന്‍ പറ്റുമോ എന്ന് നോക്കുന്നു. അതായത് range(2, 67) തരുന്ന ലിസ്റ്റിലുള്ള ഓരോ സംഖ്യകൊണ്ടും 67-നെ ഹരിച്ചുനോക്കുന്നു. range(2, 67) എന്ന് പ്രോഗ്രാമില്‍ പറഞ്ഞാല്‍ [2,3, ... , 66] എന്ന ഈ ലിസ്റ്റ് നമുക്ക് കിട്ടും. എന്നാല്‍ ഈ ലിസ്റ്റിലുള്ള സംഖ്യകള്‍ ഓരോന്നായി എങ്ങനെ കൈയ്യില്‍ക്കിട്ടും? ഇങ്ങനെ ഓരോന്നായി കിട്ടിയാലല്ലേ ഓരോന്നുകൊണ്ടും ഹരിച്ചുനോക്കാന്‍ കഴിയൂ? ഒരു ലിസ്റ്റിലുള്ള മൂല്യങ്ങളെ ഓരോന്നായി എടുത്ത് പ്രയോഗിക്കാന്‍ പാകത്തില്‍ നമുക്കു തരുന്ന പൈത്തണ്‍ ഭാഷാപ്രയോഗമാണ് for .

ലിസ്റ്റുകളും for-ഉം

മുമ്പു പറഞ്ഞതുപോലെ, [, ] എന്നീ ബ്രായ്ക്കറ്റുകള്‍ക്കുള്ളിലായി മൂല്യങ്ങളെ കോമയിട്ട് വേര്‍തിരിച്ച് എഴുതുന്നതിനെയാണ് പൈത്തണില്‍ ലിസ്റ്റ് എന്ന് വിളിക്കുന്നത്. വളരെ ലളിതമായ ഒരു ആശയമാണ് ഇതെങ്കിലും പ്രോഗ്രാം എഴുതുന്നതില്‍ വളരെയധികം ഉപയോഗപ്പെടുന്ന ഒന്നാണ് ലിസ്റ്റ്. ഒന്നാലോചിച്ചാല്‍ ഇതില്‍ വലിയ അത്ഭുതമൊന്നുമില്ല: ദൈനംദിന ജീവിതത്തിലും വിവരങ്ങള്‍ സൂക്ഷിച്ചുവെയ്ക്കാന്‍ നാമുപയോഗിക്കുന്ന ചുരുക്കം ചില ഉപാധികളില്‍ പ്രധാനപ്പെട്ടതാണ് ലിസ്റ്റ്. കടയില്‍ നിന്ന് വാങ്ങേണ്ട സാധനങ്ങള്‍, ഫോണ്‍ നമ്പരുകള്‍ (ഡയറിയിലായാലും മൊബൈല്‍ ഫോണിലായാലും), കല്ല്യാണത്തിനു വിളിക്കേണ്ട ആളുകളുടെ വിവരങ്ങള്‍, എന്നിങ്ങനെ ഒന്നിലധികം വിവരങ്ങള്‍ ഉള്ള മിക്കയിടത്തും അവയെ നാം ലിസ്റ്റായി ആണ് രേഖപ്പെടുത്താറ്. ലിസ്റ്റല്ലാതെ ഈ ആവശ്യത്തിന് ഉപയോഗിച്ച് കണ്ടുവരുന്ന ഏക ഉപാധി പട്ടിക (table) ആണ്. ഇതാകട്ടെ ഓഫീസുകളിലോ പഠനസംബന്ധിയായ പ്രമാണങ്ങളിലോ മാത്രമേ കാണാറുള്ളൂ: ഔപചാരികമല്ലാത്ത കാര്യങ്ങള്‍ക്ക് പട്ടികകള്‍ ഉപയോഗിക്കാറില്ലെന്നുതന്നെ പറയാം.

പൈത്തണില്‍ ഒരു ലിസ്റ്റ് ഉണ്ടാക്കാന്‍ ചെയ്യേണ്ടത് ഇത്രമാത്രം: ലിസ്റ്റില്‍ വരേണ്ട മൂല്യങ്ങളെ കോമകൊണ്ട് വേര്‍തിരിച്ച് [, ] എന്നീ ബ്രായ്ക്കറ്റുകള്‍ക്കുള്ളിലായി എഴുതുക. കുറച്ച് ഉദാഹരണങ്ങള്‍:

• ['Bhama', 'Hari', 'Nizar', 'John',]
• [1, 'Thiruvananthapuram', 2, 'Kollam', 3, 'Pathanamthitta']
• [1, ['a', 'b', 'c'], 'd']
• range() സമാന്തരശ്രേണികളെ ഇങ്ങനെ ലിസ്റ്റ് രൂപത്തില്‍ തരുന്നത് മുകളില്‍ കണ്ടല്ലോ.
  

ലിസ്റ്റിന്റെ അവസാനത്തെ അംഗത്തിനുശേഷം ഒരു കോമ വേണമെങ്കില്‍ ആകാം : ആദ്യത്തെ ഉദാഹരണം നോക്കുക. ലിസ്റ്റിലെ ഓരോ അംഗവും ഏതുതരം മൂല്യം വേണമെങ്കിലുമാകാം. മൂന്നാമത്തെ ലിസ്റ്റിലെ രണ്ടാമത്തെ അംഗം ഒരു ലിസ്റ്റ് തന്നെയായിരിക്കുന്നത് ശ്രദ്ധിക്കുക. ഒരു ലിസ്റ്റിലെ അംഗങ്ങളെ ഓരോന്നായി പ്രോഗ്രാമില്‍ ലഭ്യമാക്കാന്‍ പൈത്തണിലുള്ള സംവിധാനമാണ് for . ഇതിന്റെ ഉപയോഗം എങ്ങനെയാണെന്നറിയാന്‍ താഴെക്കാണുന്ന പ്രോഗ്രാമുകള്‍ പരീക്ഷിച്ചുനോക്കുക.

for-നെപ്പറ്റി വിശദമായി

for പ്രോഗ്രാമില്‍ ഉപയോഗിക്കുന്ന വിധം നമുക്ക് കുറച്ചുകൂടി വിശദമായി പരിശോധിക്കാം:

1. for വരിയുടെ (ലഘുവായ) വ്യാകരണം ഇതാണ്: for variable in list : . പേരുസൂചിപ്പിക്കുന്നതുപോലെ ഇവിടെ variable എന്നത് ഒരു ചരവും list എന്നത് ഒരു ലിസ്റ്റുമാണ്. ഉദാഹരണങ്ങളില്‍ കാണുന്നതുപോലെ ലിസ്റ്റ് എന്നത് ഇവിടെ [, ] എന്നിവ ഉപയോഗിക്കുന്ന അക്ഷരാര്‍ത്ഥത്തിലുള്ള ഒരു ലിസ്റ്റോ, അതല്ലെങ്കില്‍ ഒരു ലിസ്റ്റ് മൂല്യമായി കിട്ടുന്ന ഒരു വ്യഞ്ജകമോ (expression) — ഉദാഹരണം: range()-ന്റെ ഏതെങ്കിലും പ്രയോഗം — ആകാം. list കഴിഞ്ഞുള്ള : പ്രത്യേകം ശ്രദ്ധിക്കുക.
2. for വരി കഴിഞ്ഞുവരുന്ന വരികളില്‍ for -ന്റെ പരിധിയില്‍പ്പെടുന്ന വരികള്‍ (ഒന്നോ അതിലധികമോ) എഴുതണം. ഇങ്ങനെയുള്ള വരികള്‍ എല്ലാം തന്നെ ഈ for വരിയെ അപേക്ഷിച്ച് ഒരു നിശ്ചിത അകലം വലതുവശത്തേക്ക് മാറി ആയിരിക്കണം തുടങ്ങേണ്ടത്.
3. മുകളിലെ ഉദാഹരണങ്ങളില്‍ നാലു സ്പേസ് വലത്തേക്ക് മാറിയാണ് എഴുതിയിട്ടുള്ളത്. ഇങ്ങനെ നാലു സ്പേസ് വിട്ടെഴുതുന്നതാണ് പൈത്തണ്‍ മാനകം (standard).
4. IDLE ഉപയോഗിച്ച് പ്രോഗ്രാം എഴുതുകയാണെങ്കില്‍ : എന്നെഴുതി Enter അമര്‍ത്തുമ്പോള്‍ IDLE തനിയെ തന്നെ എഴുതിത്തുടങ്ങാനുള്ള സൂചകം (cursor) പുതിയ വരിയില്‍ നാലു സ്പേസ് വലത്തേക്ക് മാറ്റിത്തരുന്നത് കാണാം. ഇതൊന്ന് പരീക്ഷിച്ചു നോക്കൂ! ഇങ്ങനെ മാറുന്നില്ലെങ്കില്‍ തൊട്ടുമുമ്പത്തെ വരിയുടെ വ്യാകരണം തെറ്റിയതാവും കാരണം. മിക്കവാറും ഇത് അവസാനം കൊടുക്കേണ്ടതായ : വിട്ടുപോയതുകൊണ്ടാവും.
5. list എന്ന ലിസ്റ്റില്‍ എത്ര അംഗങ്ങളുണ്ടോ, അത്രയും തവണ for -ന്റെ പരിധിയില്‍പ്പെടുന്ന വരികളെല്ലാം പ്രവര്‍ത്തിപ്പിക്കുക എന്നതാണ് for -ന്റെ അടിസ്ഥാന സ്വഭാവം. മുകളില്‍ ആദ്യത്തെ ഉദാഹരണം പ്രവര്‍ത്തിപ്പിച്ചു നോക്കിയാല്‍ ഇത് വ്യക്തമായി മനസ്സിലാകും.
6. ഇങ്ങനെ for -ന്റെ പരിധിയില്‍പ്പെടുന്ന വരികള്‍ ഓരോ തവണ പ്രവര്‍ത്തിപ്പിക്കുമ്പോഴും variable എന്ന ചരത്തിന്റെ വില list എന്ന ലിസ്റ്റിലെ ഓരോ അംഗത്തിന്റെയും വിലയായി ക്രമത്തില്‍ തനിയെ മാറുന്നു:
   
   • ആദ്യത്തെ തവണ പ്രവര്‍ത്തിപ്പിക്കുമ്പോള്‍ variable -ന്റെ വില ലിസ്റ്റിലെ ആദ്യത്തെ അംഗത്തിന്റെ വിലയാണ്.
   • രണ്ടാമത്തെ തവണ പ്രവര്‍ത്തിപ്പിക്കുമ്പോള്‍ variable -ന്റെ വില ലിസ്റ്റിലെ രണ്ടാമത്തെ അംഗത്തിന്റെ വിലയാണ്.
   • മൂന്നാമത്തെ തവണ പ്രവര്‍ത്തിപ്പിക്കുമ്പോള്‍ variable -ന്റെ വില ലിസ്റ്റിലെ മൂന്നാമത്തെ അംഗത്തിന്റെ വിലയാണ്.
   • അങ്ങനെയങ്ങനെ ...
   രണ്ടും മൂന്നും ഉദാഹരണങ്ങള്‍ പ്രവര്‍ത്തിപ്പിച്ചുനോക്കിയാല്‍ ഇപ്പറഞ്ഞത് വ്യക്തമായി മനസ്സിലാകും.
   
7. for -ന്റെ പരിധിയില്‍പ്പെടുന്ന വരികളില്‍ variable എന്ന ചരത്തിനെ ക്രിയകളിലും മറ്റും ചരങ്ങള്‍ സാധാരണ ഉപയോഗിക്കുന്നതുപോലെ ഉപയോഗിക്കാം. നാലു മുതല്‍ ആറു വരെ ഉദാഹരണങ്ങള്‍ പ്രവര്‍ത്തിപ്പിച്ചുനോക്കിയാല്‍ ഇത് വ്യക്തമാകും.
8. for -ന്റെ പരിധിയില്‍ വരേണ്ടുന്ന — ലിസ്റ്റിലെ അംഗങ്ങളുടെ എണ്ണത്തിന്റെ അത്രതവണ പ്രവര്‍ത്തിപ്പിക്കേണ്ടുന്ന — വരികള്‍ എഴുതിക്കഴിഞ്ഞാല്‍ പിന്നീടുള്ള വരി for വരി തുടങ്ങുന്ന അതേ അകലം ഇടതുവശത്തുനിന്ന് വിട്ട് വേണം തുടങ്ങാന്‍. അതായത്, നാലു സ്പേസ് വലത്തേക്ക് മാറി എഴുതുന്നത് നിര്‍ത്തണം എന്നര്‍ത്ഥം. for -ന്റെ പരിധിയില്‍പ്പെടുന്ന വരികള്‍ ഏതൊക്കെയാണെന്ന് പൈത്തണ്‍ മനസ്സിലാക്കുന്നത് for -നു ശേഷവും for -ന്റെ അതേ നിരപ്പിലുള്ള ആദ്യത്തെ വരി കാണുന്നതിന് മുന്‍പും നാലു സ്പേസ് വലത്തേക്ക് മാറി വരുന്ന വരികള്‍ ഏതൊക്കെയാണ് എന്ന് നോക്കിയിട്ടാണ്. അഞ്ചും ആറും ഉദാഹരണങ്ങള്‍ പ്രവര്‍ത്തിപ്പിച്ചുനോക്കിയാല്‍ ഇത് വ്യക്തമാകും.
9. ഇവിടെ നാലു സ്പേസ് എന്ന് പറഞ്ഞയിടത്തൊക്കെ അതിനു പകരം വേറെ ഏതെങ്കിലും ഒരു നിശ്ചിത അകലം ഇതേ ആവശ്യത്തിന് ഉപയോഗിക്കാം. ഉദാഹരണത്തിന്, ഒരു ടാബ് (കംപ്യൂട്ടറിന്റെ Tab കീ അമര്‍ത്തിയാല്‍ കിട്ടുന്നത്) ഇതിനായി ഉപയോഗിക്കാം. ഒരേ പ്രോഗ്രാമില്‍ ടാബുകളും സ്പേസുകളും രണ്ടുംകൂടി ഈ ആവശ്യത്തിന് ഉപയോഗിക്കരുത്. ഈ ആവശ്യത്തിന് നാലു സ്പേസ് ഉപയോഗിക്കുന്നതാണ് നല്ല പൈത്തണ്‍ ശൈലിയായി കണക്കാക്കുന്നത്.
10. ഇക്കാര്യങ്ങളിലെല്ലാം മുമ്പത്തെ പാഠത്തില്‍ നാം പരിചയപ്പെട്ട if -ന്റെ ഘടനയുമായുള്ള സാമ്യം ശ്രദ്ധിക്കുക.
11. നാലും ആറും ഉദാഹരണങ്ങളില്‍ for -ന്റെ പരിധിക്കുള്ളില്‍ if ഉപയോഗിച്ചിരിക്കുന്നത് ശ്രദ്ധിക്കുക. പൊതുവേ പറഞ്ഞാല്‍ if, for എന്നിവയുടെ പരിധിക്കുള്ളില്‍ ഇങ്ങനെ എന്തുവേണമെങ്കിലും എത്രവേണമെങ്കിലും "ആഴത്തില്‍" എഴുതാം. ഇങ്ങനെ എഴുതുമ്പോള്‍ സ്പേസ് കൊടുക്കുന്ന കാര്യത്തില്‍ ഇതുവരെ പറഞ്ഞ (ലളിതങ്ങളായ) നിയമങ്ങള്‍ പാലിച്ചിരിക്കണമെന്ന് മാത്രം : പുതിയ ഒരു പരിധി തുടങ്ങുമ്പോള്‍ നാലു സ്പേസ് വലത്തേക്ക് മാറി എഴുതിത്തുടങ്ങുക. ഈ പരിധി അവസാനിക്കുമ്പോള്‍ ഇങ്ങനെ വലത്തേക്ക് മാറുന്നതും നിര്‍ത്തുക. നാലും ആറും ഉദാഹരണങ്ങള്‍ ശ്രദ്ധിച്ചു വായിച്ച് ഇത് മനസ്സിലായി എന്ന് ഉറപ്പുവരുത്തുക. സംശയമുണ്ടെങ്കില്‍ ചോദിക്കുക.

പ്രവര്‍ത്തനങ്ങള്‍

പ്രവ. 4.

ഒരു എണ്ണല്‍സംഖ്യ ഇന്‍പുട്ട് ആയി എടുത്ത്, ആ സംഖ്യയെക്കാള്‍ ചെറുതും 3, 5 എന്നിവയില്‍ ഒന്നിനെക്കൊണ്ടെങ്കിലും നിശ്ശേഷം ഹരിക്കാവുന്നതുമായ എണ്ണല്‍സംഖ്യകളുടെ ഒരു ലിസ്റ്റ് ഔട്പുട്ട് ആയി തരുന്ന പ്രോഗ്രാം എഴുതുക. പ്രോഗ്രാമിന്റെ പ്രവര്‍ത്തനഫലം താഴെക്കാണുന്ന ചിത്രത്തിലെപ്പോലെ ആയിരിക്കണം (കുറച്ചുകൂടെ വ്യക്തമായ ചിത്രം കാണാന്‍ ഈ ചിത്രത്തില്‍ അമര്‍ത്തുക).

പ്രവ. 5.

ഒരു എണ്ണല്‍സംഖ്യ ഇന്‍പുട്ട് ആയി എടുത്ത്, ആ സംഖ്യയെക്കാള്‍ ചെറുതും 3, 5 എന്നിവയില്‍ ഒന്നിനെക്കൊണ്ടെങ്കിലും നിശ്ശേഷം ഹരിക്കാവുന്നതുമായ എണ്ണല്‍സംഖ്യകളുടെ എണ്ണം ഔട്പുട്ട് ആയി തരുന്ന പ്രോഗ്രാം എഴുതുക. പ്രോഗ്രാമിന്റെ പ്രവര്‍ത്തനഫലം താഴെക്കാണുന്ന ചിത്രത്തിലെപ്പോലെ ആയിരിക്കണം (കുറച്ചുകൂടെ വ്യക്തമായ ചിത്രം കാണാന്‍ ഈ ചിത്രത്തില്‍ അമര്‍ത്തുക). ഇവിടെ ഈ പ്രോഗ്രാം മൂന്നുതവണ പ്രവര്‍ത്തിപ്പിച്ചിരിക്കുന്നു (IDLE-ല്‍ F5 മൂന്നു തവണ അമര്‍ത്തിയിരിക്കുന്നു).

പ്രവ. 6.

ഒരു എണ്ണല്‍സംഖ്യ ഇന്‍പുട്ട് ആയി എടുത്ത്, ആ സംഖ്യയെക്കാള്‍ ചെറുതും 3, 5 എന്നിവയില്‍ ഒന്നിനെക്കൊണ്ടെങ്കിലും നിശ്ശേഷം ഹരിക്കാവുന്നതുമായ എണ്ണല്‍സംഖ്യകളുടെ തുക ഔട്പുട്ട് ആയി തരുന്ന പ്രോഗ്രാം എഴുതുക. പ്രോഗ്രാമിന്റെ പ്രവര്‍ത്തനഫലം താഴെക്കാണുന്ന ചിത്രത്തിലെപ്പോലെ ആയിരിക്കണം (കുറച്ചുകൂടെ വ്യക്തമായ ചിത്രം കാണാന്‍ ഈ ചിത്രത്തില്‍ അമര്‍ത്തുക). ഇവിടെ ഈ പ്രോഗ്രാം മൂന്നുതവണ പ്രവര്‍ത്തിപ്പിച്ചിരിക്കുന്നു (IDLE-ല്‍ F5 മൂന്നു തവണ അമര്‍ത്തിയിരിക്കുന്നു).

ഈ മൂന്നു പ്രവര്‍ത്തനങ്ങള്‍ ചെയ്തുകഴിയുമ്പോഴേക്കും നിങ്ങള്‍ പ്രൊജക്റ്റ് ഓയ്ലറിലെ (Project Euler) ആദ്യത്തെ പ്രശ്നത്തിന്റെ ഉത്തരം കണ്ടെത്തിക്കഴിഞ്ഞു!

അഭാജ്യസംഖ്യകള്‍ - പ്രോഗ്രാം

ഒരു സംഖ്യ അഭാജ്യമാണോ എന്ന് കണ്ടുപിടിക്കാനുള്ള ലളിതമായ പ്രോഗ്രാം എഴുതാന്‍ വേണ്ടത്ര പൈത്തണ്‍ നാം പഠിച്ചുകഴിഞ്ഞു. മുമ്പു പറഞ്ഞതുപോലെ, തന്നിരിക്കുന്ന സംഖ്യ അഭാജ്യമാണോ എന്ന് കണ്ടുപിടിക്കാനുള്ള ഒരു വഴി 1-നെക്കാള്‍ വലുതും ആ സംഖ്യയെക്കാള്‍ ചെറുതുമായ ഏതെങ്കിലും സംഖ്യകൊണ്ട് അതിനെ പൂര്‍ണ്ണമായി ഹരിക്കാന്‍ പറ്റുമോ എന്നു നോക്കുക എന്നതാണ്. ഇത് ചെയ്യുന്ന ഒരു പ്രോഗ്രാം ഇതാ. ഈ പ്രോഗ്രാമില്‍ ഒരു ചെറിയ സൂത്രപ്പണി ഉപയോഗിച്ചിരിക്കുന്നത് ശ്രദ്ധിക്കുക.





ഈ പ്രോഗ്രാമില്‍ നാം ഇതുവരെ കാണാത്തതായ ഒരേ ഒരു കാര്യമേ ഉള്ളൂ : number_is_prime എന്ന പേരുള്ള ബൂളിയന്‍ (ശരി അല്ലെങ്കില്‍ തെറ്റ് എന്നീ രണ്ടു വിലകള്‍ മാത്രമെടുക്കുന്ന) ചരത്തിന്റെ പ്രത്യേക രീതിയിലുള്ള പ്രയോഗം.

പ്രവര്‍ത്തനങ്ങള്‍

പ്രവ. 7.

ഈ പ്രോഗ്രാമില്‍ number_is_prime എന്ന ചരത്തിന്റെ ഉപയോഗം എന്താണെന്ന് ആലോചിച്ച് കണ്ടുപിടിക്കുക. എന്തിനാണ് ഇതിന് True എന്ന വില ആദ്യമേ കൊടുക്കുന്നത്?

പ്രവ. 8.

രണ്ടു സംഖ്യകള്‍ ഇന്‍പുട് ആയി എടുത്ത്, ആ രണ്ടു സംഖ്യകള്‍ക്കിടയ്ക്കുള്ള എല്ലാ അഭാജ്യ സംഖ്യകളെയും ഔട്പുട്ട് ആയി തരുന്ന പ്രോഗ്രാം എഴുതുക. പ്രോഗ്രാമിന്റെ പ്രവര്‍ത്തനഫലം താഴെക്കാണുന്ന ചിത്രത്തിലെപ്പോലെ ആയിരിക്കണം (കുറച്ചുകൂടെ വ്യക്തമായ ചിത്രം കാണാന്‍ ഈ ചിത്രത്തില്‍ അമര്‍ത്തുക).

സൂചന: ഒരു സംഖ്യ അഭാജ്യമാണോ എന്ന് പരിശോധിക്കുന്ന (ഈ പാഠത്തിലുള്ള) പ്രോഗ്രാമിനെ അനുയോജ്യമായ ഒരു for -ന്റെ പരിധിക്കകത്താക്കുക.

പ്രവ. 9.

ഒരു പൂര്‍ണ്ണസംഖ്യ ഇന്‍പുട് ആയി എടുത്ത്, ഒന്നു മുതല്‍ ആ സംഖ്യ വരെയുള്ള ഒറ്റ സംഖ്യകളുടെ തുക ഔട്പുട്ട് ആയി തരുന്ന പ്രോഗ്രാം എഴുതുക.

പ്രവ. 10.

രണ്ടു പൂര്‍ണ്ണസംഖ്യകള്‍ ഇന്‍പുട് ആയി എടുത്ത്, ആ രണ്ടു സംഖ്യകള്‍ക്കിടയ്ക്കുള്ള മൂന്നുകൊണ്ട് ഹരിക്കാവുന്ന എന്നാല്‍ അഞ്ചുകൊണ്ട് ഹരിക്കാന്‍ സാധിക്കാത്ത എല്ലാ പൂര്‍ണ്ണ സംഖ്യകളുടെയും ശരാശരി ഔട്പുട്ട് ആയി തരുന്ന പ്രോഗ്രാം എഴുതുക.

പ്രവ. 11.

ഒരു പൂര്‍ണ്ണസംഖ്യ ഇന്‍പുട് ആയി എടുത്ത്, ആ സംഖ്യ ഒരു വശമായി വരുന്ന, പൂര്‍ണ്ണസംഖ്യകള്‍ വശങ്ങളായുള്ള എല്ലാ മട്ടത്രികോണങ്ങളുടെയും മറ്റു രണ്ട് വശങ്ങള്‍ കണ്ടുപിടിക്കുക. പ്രോഗ്രാമിന്റെ പ്രവര്‍ത്തനഫലം താഴെക്കാണുന്ന ചിത്രത്തിലെപ്പോലെ ആകാം (കുറച്ചുകൂടെ വ്യക്തമായ ചിത്രം കാണാന്‍ ഈ ചിത്രത്തില്‍ അമര്‍ത്തുക). ഇവിടെ പ്രോഗ്രാം നാലു പ്രാവശ്യം പ്രവര്‍ത്തിപ്പിച്ചിട്ടുണ്ട്.

പ്രവ. 12.

ഒരു പൂര്‍ണ്ണസംഖ്യ ഇന്‍പുട് ആയി എടുത്ത്, ആ സംഖ്യയുടെയത്ര വരികളുള്ള, താഴെക്കൊടുത്തിരിക്കുന്ന ആകൃതിയുള്ള ഒരു ത്രികോണം "*" എന്ന ചിഹ്നം ഉപയോഗിച്ച് വരയ്ക്കുക.(കുറച്ചുകൂടെ വ്യക്തമായ ചിത്രം കാണാന്‍ ഈ ചിത്രത്തില്‍ അമര്‍ത്തുക).

 

പ്രവ. 13.

ഒരു പൂര്‍ണ്ണസംഖ്യ ഇന്‍പുട് ആയി എടുത്ത്, ആ സംഖ്യയുടെയത്ര വരികളുള്ള, താഴെക്കൊടുത്തിരിക്കുന്ന ആകൃതിയുള്ള ഒരു ത്രികോണം "*" എന്ന ചിഹ്നം ഉപയോഗിച്ച് വരയ്ക്കുക.(കുറച്ചുകൂടെ വ്യക്തമായ ചിത്രം കാണാന്‍ ഈ ചിത്രത്തില്‍ അമര്‍ത്തുക).

 

പ്രവ. 14.

ഒരു പൂര്‍ണ്ണസംഖ്യ ഇന്‍പുട് ആയി എടുത്ത്, ആ സംഖ്യയുടെയത്ര വരികളുള്ള, താഴെക്കൊടുത്തിരിക്കുന്ന ആകൃതിയുള്ള ഒരു ത്രികോണം "*" എന്ന ചിഹ്നം ഉപയോഗിച്ച് വരയ്ക്കുക.(കുറച്ചുകൂടെ വ്യക്തമായ ചിത്രം കാണാന്‍ ഈ ചിത്രത്തില്‍ അമര്‍ത്തുക).

പ്രവ. 15.

ഒരു പൂര്‍ണ്ണസംഖ്യ ഇന്‍പുട് ആയി എടുത്ത്, ആ സംഖ്യയുടെയത്ര വരികളുള്ള, താഴെക്കൊടുത്തിരിക്കുന്ന ആകൃതിയുള്ള ഒരു ത്രികോണം "*" എന്ന ചിഹ്നം ഉപയോഗിച്ച് വരയ്ക്കുക.(കുറച്ചുകൂടെ വ്യക്തമായ ചിത്രം കാണാന്‍ ഈ ചിത്രത്തില്‍ അമര്‍ത്തുക).

 

പ്രവര്‍ത്തനം 9, 10 എന്നിവയ്ക്ക് കടപ്പാട്: കിരണം.
പ്രവര്‍ത്തനം 11-ന്റെ ആശയത്തിന് കടപ്പാട്: വിജയന്‍ ലാര്‍വ.