പൈത്തണ്‍: പാഠം ആറ്
>> Thursday, September 2, 2010
ആമുഖം
1, 2, 3, ... മുതലായ, എണ്ണാനുപയോഗിക്കുന്ന സംഖ്യകളെയാണല്ലോ എണ്ണല്‍സംഖ്യകള്‍ എന്നു വിളിക്കുന്നത്? "സംഖ്യ" എന്ന് വിളിക്കപ്പെടുന്നവയില്‍ ഏറ്റവും ലളിതവും സുഗ്രാഹ്യവുമായവ എണ്ണല്‍സംഖ്യകളാണ്. എണ്ണല്‍സംഖ്യകളെ പരിചയമില്ലാത്ത മുതിര്‍ന്ന ഒരാള്‍പോലും ഉണ്ടാവില്ല; അക്ഷരമറിയാത്തവര്‍ക്കുപോലും എണ്ണല്‍ അറിയുമായിരിക്കും. നമ്മുടെ സമൂഹത്തില്‍ ജീവിച്ചുപോകണമെങ്കില്‍ എണ്ണല്‍ അറിയാതെ നിവൃത്തിയില്ല. നന്നേ ചെറുപ്രായത്തില്‍ത്തന്നെ മറ്റുള്ളവര്‍ നമ്മെ എണ്ണാന്‍ പഠിപ്പിക്കുന്നു. എന്തിന്റെയെങ്കിലുമൊക്കെ എണ്ണം ചോദിക്കുന്നത് കുട്ടികളോടുള്ള കൊഞ്ചലിന്റെതന്നെ ഭാഗമാണ്.എണ്ണുന്നതിന്റെ അത്രത്തോളം തന്നെ ലളിതവും സ്വാഭാവികവുമാണ് നമ്മില്‍ മിക്കവര്‍ക്കും സങ്കലനം — രണ്ടു സംഖ്യകള്‍ കൂട്ടി ഒരു സംഖ്യയാക്കുക — എന്ന ക്രിയയും. സ്കൂളില്‍ നന്നേ ചെറിയ ക്ളാസില്‍ത്തന്നെ ഇത് പഠിപ്പിക്കുന്നു. സംഖ്യകള്‍ ശരിക്കു കൂട്ടാന്‍ അറിയാതെ സ്കൂളില്‍ "പഠിച്ച്" ഇറങ്ങുന്നവരും പുറംലോകത്ത് എന്തെങ്കിലുമൊക്കെ ജോലിചെയ്തു ജീവിച്ചുതുടങ്ങുമ്പോള്‍ കൂട്ടലും കിഴിക്കലുമൊക്കെ തനിയേ പഠിച്ചുപോകുന്നു. എന്നാല്‍ സങ്കലനത്തിന്റെ അത്രതന്നെ എളുപ്പമല്ല അടുത്ത ക്രിയയായ ഗുണനം — ചെറുപ്പത്തില്‍ ഗുണനപ്പട്ടിക കാണാതെ പഠിക്കാന്‍ പെട്ട പാടും കിട്ടിയ ശിക്ഷകളുമൊക്കെ നമ്മില്‍ ചിലര്‍ക്കെങ്കിലും ഓര്‍മ്മകാണും. സംഖ്യകളെടുത്ത് പെരുമാറി — സ്കൂളിലെന്നതിലുപരി പുറത്ത്: മിക്കവാറും ക്രിക്കറ്റില്‍ സ്കോര്‍ ഗണിച്ചെടുത്തും മറ്റും — കുറേ പരിചയം വരുമ്പോള്‍ ഗുണനത്തെ ആവര്‍ത്തിച്ചുള്ള സങ്കലനമായി കാണാന്‍ നാം അറിയാതെ പഠിക്കുന്നു.
ഗുണനമെന്നാല്‍ ആവര്‍ത്തിച്ചുള്ള സങ്കലനമാണെങ്കിലും രണ്ടിന്റെയും സ്വഭാവങ്ങള്‍തമ്മില്‍ കാതലായ വ്യത്യാസങ്ങളുണ്ട്. ഉദാഹരണമായി, നാലോ അതിലധികമോ ആയ ഏത് എണ്ണല്‍സംഖ്യയെയും മറ്റുരണ്ട് എണ്ണല്‍സംഖ്യകളുടെ തുകയായി ഒന്നിലധികം രീതിയില് എഴുതാം. അതായത്,
- 4 = 1 + 3 = 2 + 2
- 5 = 1 + 4 = 2 + 3
- 10 = 1 + 9 = 2 + 8 = 3 + 7 = 4 + 6 = 5 + 5
അഭാജ്യസംഖ്യകള്‍
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 പ്രോഗ്രാമില്‍ ഉപയോഗിക്കുന്ന വിധം നമുക്ക് കുറച്ചുകൂടി വിശദമായി പരിശോധിക്കാം: -
forവരിയുടെ (ലഘുവായ) വ്യാകരണം ഇതാണ്:for variable in list :. പേരുസൂചിപ്പിക്കുന്നതുപോലെ ഇവിടെvariableഎന്നത് ഒരു ചരവുംlistഎന്നത് ഒരു ലിസ്റ്റുമാണ്. ഉദാഹരണങ്ങളില്‍ കാണുന്നതുപോലെ ലിസ്റ്റ് എന്നത് ഇവിടെ [, ] എന്നിവ ഉപയോഗിക്കുന്ന അക്ഷരാര്‍ത്ഥത്തിലുള്ള ഒരു ലിസ്റ്റോ, അതല്ലെങ്കില്‍ ഒരു ലിസ്റ്റ് മൂല്യമായി കിട്ടുന്ന ഒരു വ്യഞ്ജകമോ (expression) — ഉദാഹരണം:range()-ന്റെ ഏതെങ്കിലും പ്രയോഗം — ആകാം.listകഴിഞ്ഞുള്ള:പ്രത്യേകം ശ്രദ്ധിക്കുക. -
forവരി കഴിഞ്ഞുവരുന്ന വരികളില്‍for-ന്റെ പരിധിയില്‍പ്പെടുന്ന വരികള്‍ (ഒന്നോ അതിലധികമോ) എഴുതണം. ഇങ്ങനെയുള്ള വരികള്‍ എല്ലാം തന്നെ ഈforവരിയെ അപേക്ഷിച്ച് ഒരു നിശ്ചിത അകലം വലതുവശത്തേക്ക് മാറി ആയിരിക്കണം തുടങ്ങേണ്ടത്. - മുകളിലെ ഉദാഹരണങ്ങളില്‍ നാലു സ്പേസ് വലത്തേക്ക് മാറിയാണ് എഴുതിയിട്ടുള്ളത്. ഇങ്ങനെ നാലു സ്പേസ് വിട്ടെഴുതുന്നതാണ് പൈത്തണ്‍ മാനകം (standard).
- IDLE ഉപയോഗിച്ച് പ്രോഗ്രാം എഴുതുകയാണെങ്കില്‍
:എന്നെഴുതി Enter അമര്‍ത്തുമ്പോള്‍ IDLE തനിയെ തന്നെ എഴുതിത്തുടങ്ങാനുള്ള സൂചകം (cursor) പുതിയ വരിയില്‍ നാലു സ്പേസ് വലത്തേക്ക് മാറ്റിത്തരുന്നത് കാണാം. ഇതൊന്ന് പരീക്ഷിച്ചു നോക്കൂ! ഇങ്ങനെ മാറുന്നില്ലെങ്കില്‍ തൊട്ടുമുമ്പത്തെ വരിയുടെ വ്യാകരണം തെറ്റിയതാവും കാരണം. മിക്കവാറും ഇത് അവസാനം കൊടുക്കേണ്ടതായ:വിട്ടുപോയതുകൊണ്ടാവും. -
listഎന്ന ലിസ്റ്റില്‍ എത്ര അംഗങ്ങളുണ്ടോ, അത്രയും തവണfor-ന്റെ പരിധിയില്‍പ്പെടുന്ന വരികളെല്ലാം പ്രവര്‍ത്തിപ്പിക്കുക എന്നതാണ്for-ന്റെ അടിസ്ഥാന സ്വഭാവം. മുകളില്‍ ആദ്യത്തെ ഉദാഹരണം പ്രവര്‍ത്തിപ്പിച്ചു നോക്കിയാല്‍ ഇത് വ്യക്തമായി മനസ്സിലാകും. - ഇങ്ങനെ
for-ന്റെ പരിധിയില്‍പ്പെടുന്ന വരികള്‍ ഓരോ തവണ പ്രവര്‍ത്തിപ്പിക്കുമ്പോഴുംvariableഎന്ന ചരത്തിന്റെ വിലlistഎന്ന ലിസ്റ്റിലെ ഓരോ അംഗത്തിന്റെയും വിലയായി ക്രമത്തില്‍ തനിയെ മാറുന്നു:
- ആദ്യത്തെ തവണ പ്രവര്‍ത്തിപ്പിക്കുമ്പോള്‍
variable-ന്റെ വില ലിസ്റ്റിലെ ആദ്യത്തെ അംഗത്തിന്റെ വിലയാണ്. - രണ്ടാമത്തെ തവണ പ്രവര്‍ത്തിപ്പിക്കുമ്പോള്‍
variable-ന്റെ വില ലിസ്റ്റിലെ രണ്ടാമത്തെ അംഗത്തിന്റെ വിലയാണ്. - മൂന്നാമത്തെ തവണ പ്രവര്‍ത്തിപ്പിക്കുമ്പോള്‍
variable-ന്റെ വില ലിസ്റ്റിലെ മൂന്നാമത്തെ അംഗത്തിന്റെ വിലയാണ്. - അങ്ങനെയങ്ങനെ ...
- ആദ്യത്തെ തവണ പ്രവര്‍ത്തിപ്പിക്കുമ്പോള്‍
-
for-ന്റെ പരിധിയില്‍പ്പെടുന്ന വരികളില്‍variableഎന്ന ചരത്തിനെ ക്രിയകളിലും മറ്റും ചരങ്ങള്‍ സാധാരണ ഉപയോഗിക്കുന്നതുപോലെ ഉപയോഗിക്കാം. നാലു മുതല്‍ ആറു വരെ ഉദാഹരണങ്ങള്‍ പ്രവര്‍ത്തിപ്പിച്ചുനോക്കിയാല്‍ ഇത് വ്യക്തമാകും. -
for-ന്റെ പരിധിയില്‍ വരേണ്ടുന്ന — ലിസ്റ്റിലെ അംഗങ്ങളുടെ എണ്ണത്തിന്റെ അത്രതവണ പ്രവര്‍ത്തിപ്പിക്കേണ്ടുന്ന — വരികള്‍ എഴുതിക്കഴിഞ്ഞാല്‍ പിന്നീടുള്ള വരിforവരി തുടങ്ങുന്ന അതേ അകലം ഇടതുവശത്തുനിന്ന് വിട്ട് വേണം തുടങ്ങാന്‍. അതായത്, നാലു സ്പേസ് വലത്തേക്ക് മാറി എഴുതുന്നത് നിര്‍ത്തണം എന്നര്‍ത്ഥം.for-ന്റെ പരിധിയില്‍പ്പെടുന്ന വരികള്‍ ഏതൊക്കെയാണെന്ന് പൈത്തണ്‍ മനസ്സിലാക്കുന്നത്for-നു ശേഷവുംfor-ന്റെ അതേ നിരപ്പിലുള്ള ആദ്യത്തെ വരി കാണുന്നതിന് മുന്‍പും നാലു സ്പേസ് വലത്തേക്ക് മാറി വരുന്ന വരികള്‍ ഏതൊക്കെയാണ് എന്ന് നോക്കിയിട്ടാണ്. അഞ്ചും ആറും ഉദാഹരണങ്ങള്‍ പ്രവര്‍ത്തിപ്പിച്ചുനോക്കിയാല്‍ ഇത് വ്യക്തമാകും. - ഇവിടെ നാലു സ്പേസ് എന്ന് പറഞ്ഞയിടത്തൊക്കെ അതിനു പകരം വേറെ ഏതെങ്കിലും ഒരു നിശ്ചിത അകലം ഇതേ ആവശ്യത്തിന് ഉപയോഗിക്കാം. ഉദാഹരണത്തിന്, ഒരു ടാബ് (കംപ്യൂട്ടറിന്റെ Tab കീ അമര്‍ത്തിയാല്‍ കിട്ടുന്നത്) ഇതിനായി ഉപയോഗിക്കാം. ഒരേ പ്രോഗ്രാമില്‍ ടാബുകളും സ്പേസുകളും രണ്ടുംകൂടി ഈ ആവശ്യത്തിന് ഉപയോഗിക്കരുത്. ഈ ആവശ്യത്തിന് നാലു സ്പേസ് ഉപയോഗിക്കുന്നതാണ് നല്ല പൈത്തണ്‍ ശൈലിയായി കണക്കാക്കുന്നത്.
- ഇക്കാര്യങ്ങളിലെല്ലാം മുമ്പത്തെ പാഠത്തില്‍ നാം പരിചയപ്പെട്ട
if-ന്റെ ഘടനയുമായുള്ള സാമ്യം ശ്രദ്ധിക്കുക. - നാലും ആറും ഉദാഹരണങ്ങളില്‍
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-ന്റെ ആശയത്തിന് കടപ്പാട്: വിജയന്‍ ലാര്‍വ.
117 comments:
ഫിലിപ്പ്മാഷേ..,
കഴിഞ്ഞ രണ്ടുപാഠങ്ങളുടെ കുടിശ്ശിക ഞാന്‍ തീര്‍ത്തുകൊണ്ടിരിക്കുന്നേയുള്ളൂ..
തീര്‍ച്ചയായും ഈ പാഠത്തിലേക്കെത്തിയിട്ട് സംശയങ്ങല്‍ ചോദിക്കാം..
പേജ് കോപ്പി ചെയ്തെടുക്കുന്നു. മറ്റ് വിവരങ്ങള്‍ പിന്നീടാകാം. ഫിലിപ്പ് മാഷ് ശരിക്കും ഹാര്‍ഡ് വര്‍ക്ക് ചെയ്യുന്നുണ്ട്.
ഈ പാഠത്തിന്റെ പി.ഡി.എഫ് .
എന്റെ system down ആയതു കൊണ്ട് പാഠം നോക്കിയത് ഇപ്പോള്‍ മാത്രമാണ്.
എന്തായാലും പാഠത്തിന്റെ ഒരു print എടുത്തിട്ടുണ്ട്.
പഠിക്കട്ടെ.
സര്‍, പഠനം നടന്നുകൊണ്ടിരിക്കുന്നേ ഉള്ളു.ഇപ്പൊ നാലാം പാഠത്തിലാണ്.ഇതും കുറച്ച് വായിച്ചു.conditional statement ഉപയോഗിച്ച് ഇതു ചെയ്യാമല്ലോ
പൈത്തണ്‍ പഠനം ഞങ്ങള്‍ക്ക് നല്‍കുന്ന ആത്മവിശ്വാസം ചെറുതല്ല.ചെയ്തു നോക്കും. ഇത്തവണ ഇടപെടലുകള്‍ പ്രതീക്ഷിക്കാം.
I am a new visitor of this blog. I have not read other programming lessons. But I feel the lessons will be very good just by reading this lesson. But I have a doubt. To check whether 'n' is prime should we try to divide 'n' with numbers up to n-1. Isn't it enough to divide with numbers up to square root of n? (If n=pxq either p or q will be less than square root of n)
ഫിലിപ്പ് സാര്‍,
ചില തിരക്കുകള്‍ മൂലം കഴിഞ്ഞ രണ്ടു പൈത്തണ്‍ പാഠങ്ങളും ചെയ്തു നോക്കാനായില്ല. PDF കിട്ടി. എന്തായാലും ഈ പാഠം മുതല്‍ പഠിക്കുമെന്നുറപ്പിച്ചിട്ടുണ്ട്.
പ്രവ. 4.
ഒരു എണ്ണല്‍സംഖ്യ ഇന്‍പുട്ട് ആയി എടുത്ത്, ആ സംഖ്യയെക്കാള്‍ ചെറുതും 3, 5 എന്നിവയില്‍ ഒന്നിനെക്കൊണ്ടെങ്കിലും നിശ്ശേഷം ഹരിക്കാവുന്നതുമായ എണ്ണല്‍സംഖ്യകളുടെ ഒരു ലിസ്റ്റ് ഔട്പുട്ട് ആയി തരുന്ന പ്രോഗ്രാം എഴുതുക.
ഇതിനുള്ള പ്രോഗ്രാം ഇതല്ലേ?
പ്രവ. 5.
ഒരു എണ്ണല്‍സംഖ്യ ഇന്‍പുട്ട് ആയി എടുത്ത്, ആ സംഖ്യയെക്കാള്‍ ചെറുതും 3, 5 എന്നിവയില്‍ ഒന്നിനെക്കൊണ്ടെങ്കിലും നിശ്ശേഷം ഹരിക്കാവുന്നതുമായ എണ്ണല്‍സംഖ്യകളുടെ എണ്ണം ഔട്പുട്ട് ആയി തരുന്ന പ്രോഗ്രാം എഴുതുക.
പ്രോഗ്രാം
പ്രവ. 6.
ഒരു എണ്ണല്‍സംഖ്യ ഇന്‍പുട്ട് ആയി എടുത്ത്, ആ സംഖ്യയെക്കാള്‍ ചെറുതും 3, 5 എന്നിവയില്‍ ഒന്നിനെക്കൊണ്ടെങ്കിലും നിശ്ശേഷം ഹരിക്കാവുന്നതുമായ എണ്ണല്‍സംഖ്യകളുടെ തുക ഔട്പുട്ട് ആയി തരുന്ന പ്രോഗ്രാം എഴുതുക.
പ്രോഗ്രാം
തെറ്റുണ്ടെങകില്‍ പറയണേ
പ്രവ. 6.
ഒരു എണ്ണല്‍സംഖ്യ ഇന്‍പുട്ട് ആയി എടുത്ത്, ആ സംഖ്യയെക്കാള്‍ ചെറുതും 3, 5 എന്നിവയില്‍ ഒന്നിനെക്കൊണ്ടെങ്കിലും നിശ്ശേഷം ഹരിക്കാവുന്നതുമായ എണ്ണല്‍സംഖ്യകളുടെ തുക ഔട്പുട്ട് ആയി തരുന്ന പ്രോഗ്രാം എഴുതുക.
പ്രോഗ്രാം
ശരിയല്ലേ ?
ഹോംസ് സാര്‍, ശങ്കരന്‍ മാഷ്, ഷെമി ടീച്ചര്‍, മന്‍മോഹന്‍ സാര്‍, സ്വപ്ന ടീച്ചര്‍,
പാഠങ്ങള്‍ വായിക്കുന്നതിന്റെ കൂടെ പ്രവര്‍ത്തനങ്ങള്‍ ചെയ്തുനോക്കാനും മടിക്കരുത്. സംശയങ്ങള്‍ മടിക്കാതെ ചോദിക്കുക. ഉത്തരങ്ങള്‍ ഇനി വരുന്നവര്‍ക്കും ഉപകാരപ്പെടും.
ഭാമ ടീച്ചര്‍,
രണ്ടു പ്രോഗ്രാമും തികച്ചും ശരിയായിട്ടുണ്ട്. രണ്ടാമത്തെ പ്രോഗ്രാമിന്റെ ഏഴാമത്തെ വരിയില്‍ ഒരു ചെറിയ കാര്യം വിട്ടുപോയിട്ടുണ്ട്.
കുറച്ച് വ്യത്യസ്തമായ, രസകരമായ ഒരു പ്രവര്‍ത്തനത്തിന് പ്രോജക്റ്റ് ഓയ്ലറിന്റെ ഒമ്പതാമത്തെ ചോദ്യം ചെയ്തുനോക്കൂ.
-- ഫിലിപ്പ്
പ്രവ. 5 ഇതാ തിരുത്തി
പ്രവ. 6.
ഒരു എണ്ണല്‍സംഖ്യ ഇന്‍പുട്ട് ആയി എടുത്ത്, ആ സംഖ്യയെക്കാള്‍ ചെറുതും 3, 5 എന്നിവയില്‍ ഒന്നിനെക്കൊണ്ടെങ്കിലും നിശ്ശേഷം ഹരിക്കാവുന്നതുമായ എണ്ണല്‍സംഖ്യകളുടെ തുക ഔട്പുട്ട് ആയി തരുന്ന പ്രോഗ്രാം എഴുതുക
പ്രോഗ്രാം
ഓയിലറുടെ 9-ം ചോദ്യം ചെയ്തു നോക്കട്ടെ
പ്രവ. 5 ഇതാ തിരുത്തി
പ്രവ. 6.
ഒരു എണ്ണല്‍സംഖ്യ ഇന്‍പുട്ട് ആയി എടുത്ത്, ആ സംഖ്യയെക്കാള്‍ ചെറുതും 3, 5 എന്നിവയില്‍ ഒന്നിനെക്കൊണ്ടെങ്കിലും നിശ്ശേഷം ഹരിക്കാവുന്നതുമായ എണ്ണല്‍സംഖ്യകളുടെ തുക ഔട്പുട്ട് ആയി തരുന്ന പ്രോഗ്രാം എഴുതുക
പ്രോഗ്രാം
ഓയിലറുടെ 9-ം ചോദ്യം ചെയ്തു നോക്കട്ടെ
paithon lessons are good...
ജയന്‍ സാര്‍,
താങ്കള്‍ പറഞ്ഞത് തികച്ചും ശരിയാണ്. പ്രോഗ്രാമെഴുത്ത് ലളിതമാക്കാനാണ് പാഠത്തിലേതുപോലെ പറഞ്ഞത്.
-- ഫിലിപ്പ്
ഫിലിപ്പ്,
നിങ്ങള്‍ അദ്ധ്യാപകനെന്ന നിലയില്‍ വ്യത്യസ്തത പുലര്‍ത്തുന്നു. കാരണം, ആത്മാര്‍ത്ഥതയോടെയാണ് ഈ പോസ്റ്റ് കണ്ടന്റ് കണ്ടാലറിയാം. നിര്‍വികാരരായ നിങ്ങളുടെ അദ്ധ്യാപക സുഹൃത്തുക്കളില്‍ നിന്ന് കൂടുതലൊന്നും പ്രതീക്ഷിക്കരുത്.
@ ജനാര്‍ദ്ദനന്‍.സി.എം,
ഈ പരസ്യമിടല്‍ മോശമാണ്. നിങ്ങളുടെ ബ്ലോഗ് വായിക്കേണ്ടവര്‍ അവിടെ വന്ന് വായിക്കില്ലേ?
ജെയിംസ് ബോണ്ടേ,
ഞങ്ങളുടെ ആവശ്യപ്രകാരമാണ് ബ്ലോഗ് ടീമംഗം കൂടിയായ ജനാര്‍ദ്ദനന്‍ മാഷ് തന്റെ പുതിയ പോസ്റ്റുകളെപ്പറ്റി കമന്റിലൂടെ അറിയിക്കുന്നത്.
ഹൃദയം ഒരല്പംകൂടി വിശാലമാക്കിക്കൂടേ..?
Sir
Python Lesson is very interesting
Thank you sir
I do all activities in these lessons
because i need python in my blender animation
Your lesson help me so much
പ്രോജക്റ്റ് ഓയ്ലറിന്റെ ഒമ്പതാമത്തെ ചോദ്യം ചെയ്യുന്നത് ഇങ്ങനെ യാണോ ?
ഭാമ ടീച്ചര്‍,
200, 375, 425 എന്നിവയുടെ ഗുണനഫലം 7940179730201940 അല്ലല്ലോ? പിന്നെയെന്തുകൊണ്ടാണ് പ്രോഗ്രാം അങ്ങനെ പറയുന്നത്?
-- ഫിലിപ്പ്
തെറ്റു തിരുത്തി. 200, 375, 425 എന്നിവയുടെ ഗുണനഫലം 31875000 .
പ്രോഗ്രാം
ഭാമ ടീച്ചര്‍,
ടീച്ചറുടെ പ്രോഗ്രാം ശരിയാണ്. ഇതുകൂടി ഒന്ന് നോക്കൂ.
-- ഫിലിപ്പ്
താങ്കളുടെ പൈത്തന്‍ ആറാം പാഠവും ഗംഭീരമായി.എല്ലാ ദിവസവും ഈ വിഷയത്തിലുള്ള കമെന്റുകള്‍ ശ്രദ്ദിക്കാറുണ്ട്.മറ്റു പോസ്റ്റുകള്‍ വന്നതോടെ ഈ പോസ്റ്റിനെ ചിലരെങ്കിലും മറന്നോ എന്ന് സംശയം .തൊട്ടു മുന്‍പത്തെ പോസ്റ്റുകളെ പോലെ ഭാമ ടീച്ചര്‍ വളരെ നന്നായി പ്രോഗ്രാം ചെയ്യുന്നത് കണ്ടു.ചുരുക്കം ചിലര്‍ പഠിച്ചു വരുന്നു എന്നുള്ളതും സന്തോഷകരം.പക്ഷേ ഇത്ര പേരുമാത്രമേ പൈത്തന്‍ പഠിക്കുന്നുള്ളൂ എങ്കില്‍ കുട്ടികളുടെ കാര്യം കഷ്ടം തന്നെ .
@ഫിലിപ്പ് സാര്‍
താങ്കളുടെ അഭാജ്യ സന്ഘ്യകളുടെ പ്രോഗ്രാമ്മില്‍ വരി 16 ഇല്‍
for i in range(2, number) : അഭാജ്യ മാണോ എന്ന് പരിശോധിക്കാന്‍ രണ്ടു മുതല്‍ ആ സന്ഗ്യ വരെ പരിശോദിക്കണോ ??.ഉദാഹരണം 11 എന്ന നമ്പര്‍ അഭാജ്യമാണോ എന്ന് പരിശോധിക്കാന്‍ നമുക്ക് 4 വരെ ഹരിച്ചു നോക്കിയാല്‍ പോരെ.കാരണം 4 * 4 ആകുമ്പോള്‍ തന്നെ 16 ആകുന്നു.അഥവാ നമുക്ക് കാണേണ്ട സന്ഗ്യയുടെ square root വരെ ചെക്ക്‌ ചെയ്‌താല്‍ മതിയാകും.അപ്പോള്‍ വരി 16 നു പകരം ഇങ്ങിനെ നല്കിക്കൂടെ
limit =int(number**(1.0/2))+1
for i in range(2,limit) :
limit എന്ന ചരം നമ്പറിന്റെ square root നോട് കൂടി ഒന്ന് കൂട്ടിയ എന്നാല്‍ സംഘ്യ ആയിരിക്കും
"പക്ഷേ ഇത്ര പേരുമാത്രമേ പൈത്തന്‍ പഠിക്കുന്നുള്ളൂ എങ്കില്‍ കുട്ടികളുടെ കാര്യം കഷ്ടം തന്നെ ."
പഠനത്തില്‍ താല്പര്യമുള്ള, എന്നാല്‍ പ്രോഗ്രാമിങ്ങ് ബുദ്ധി കുറഞ്ഞ എന്നേപ്പോലുള്ള പലരും പാഠങ്ങളില്‍ പിന്നിലാണെന്നേയുള്ളൂ..!
ഒരുനാള്‍ ഞാനും കിരണം ചേട്ടനെപ്പോലെ വളരും വലുതാകും,
ചേട്ടനെപ്പോലെ പൈത്തണ്‍പ്രോഗ്രാം ചെയ്യുകതന്നെ ചെയ്യും!
ഗീത ടീച്ചര്‍,
ടീച്ചര്‍ക്ക് പാഠങ്ങള്‍ ബുദ്ധിമുട്ടായി തോന്നുന്നുണ്ടെങ്കില്‍ അതിന്റെ കാരണം ടീച്ചറുടെ പ്രോഗ്രാമിംഗ് ബുദ്ധി കുറഞ്ഞതൊന്നുമല്ല, പാഠങ്ങള്‍ വേണ്ടത്ര വ്യക്തമല്ല എന്നതാണ്. പ്രോഗ്രാമിംഗ് പരിചയമില്ലാത്ത ഒരാള്‍ക്ക് എന്തൊക്കെയാണ് അറിഞ്ഞുകൂടാത്തത് എന്ന് മനസ്സിലാക്കാന്‍ വര്‍ഷങ്ങളായി പ്രോഗ്രാമിംഗുമായി ഇടപഴകുന്ന എനിക്ക് ശരിക്ക് കഴിയാത്തതുകൊണ്ടാണ് ഇത് സംഭവിക്കുന്നത്. മനസ്സിലാകാത്ത/സംശയമുള്ള കാര്യങ്ങള്‍ മടികൂടാതെ — മറ്റുള്ളവര്‍ എന്തുകരുതും എന്ന് വിചാരിക്കാതെയും — ഇവിടെ ചോദിക്കുക എന്നതു മാത്രമാണ് ഇതുകാരണം പാഠങ്ങളില്‍ ഉണ്ടാകുന്ന കുറവുകള്‍ നികത്താനുള്ള ഏകവഴി. ഇങ്ങനെയുള്ള ചോദ്യങ്ങള്‍ കാണുമ്പോള്‍ പാഠത്തില്‍ എവിടെയാണ് അവ്യക്തത എന്ന് എനിക്ക് മനസ്സിലാക്കാനും അത് തിരുത്താനും കഴിയും.
ഇങ്ങനെയുള്ള സംശയങ്ങള്‍ ഏത് പാഠത്തിനെക്കുറിച്ചായാലും എപ്പോഴായാലും പ്രയോജനപ്രദമാണ്. പുതിയ പാഠം തിരുത്തുന്നതും പഴയ പാഠം തിരുത്തുന്നതും ബ്ളോഗില്‍ ഒരേപോലെ എളുപ്പമാണല്ലോ.
പിന്നെ, പ്രോഗ്രാമിംഗ് ഒരു കലയാണ് എന്നതും ചിലര്‍ക്ക് മറ്റുള്ളവരെക്കാള്‍ ഈ കലാവാസന കൂടുതല്‍ ഉണ്ടായിരിക്കും എന്നതും ശരിതന്നെ. ഇതുപക്ഷേ ഡ്രൈവിംഗ് ഒരു കലയാണ് എന്ന് പറയുന്നതുപോലെയേ ഉള്ളൂ; ജീവിച്ചുപോകാന്‍ ആവശ്യമുള്ളത്ര ഡ്രൈവിംഗ് പഠിക്കാന്‍ എല്ലാവരെക്കൊണ്ടും സാധിക്കും. ഈ പാഠന പദ്ധതിയില്‍ ഇതുവരെ ഇങ്ങനെ കലയോടടുത്തുനില്‍ക്കുന്ന ഒന്നുംതന്നെ പരിചയപ്പെടുത്തിയിട്ടില്ല. ഇനിയുള്ള പാഠങ്ങളിലും ഈ കല പ്രയോഗിക്കാനുള്ള ഉപകരണങ്ങള്‍ (tools) പരിചയപ്പെടുത്തും എന്നല്ലാതെ "കല" എന്ന് വിളിക്കാവുന്നതൊന്നും നേരിട്ട് പരിചയപ്പെടുത്താന്‍ ഉദ്ദേശമില്ല; എനിക്ക് ഈ കല വശമില്ല എന്നതുതന്നെ കാരണം. ഈ പാഠങ്ങള്‍ വായിക്കുന്ന, ഈ കല കൂടുതല്‍ പഠിക്കണമെന്ന് താത്പര്യമുള്ളവര്‍ക്ക് ഉപകരിക്കുന്ന അടിസ്ഥാന വിവരങ്ങളും സൂചനകളും പാഠങ്ങളില്‍ അങ്ങിങ്ങായി ഉള്‍പ്പെടുത്താനാണ് ഉദ്ദേശിക്കുന്നത്.
-- ഫിലിപ്പ്
യാതൊരു ബുദ്ധിമുട്ടുമില്ല സര്‍..
ഇതിനേക്കാള്‍ ലളിതമായി പഠിപ്പിക്കാന്‍ ആര്‍ക്കും കഴിയില്ല.
തിരക്കുകള്‍ക്കിടയില്‍ പാഠങ്ങള്‍ക്കൊപ്പമെത്താന്‍ സമയമെടുക്കുന്നുവെന്നേയുള്ളൂ..
num=input("Enter a number to check Prime--> ")
for x in range(2,num):
if(num % x==0):
break
if(num-1==x or num==2 or num==1) :
print num," is a prime Number"
else :
print num," is not a Prime Number"
ഫിലിപ്പ്മാഷേ..,
Here is it
num=input("Enter the Limit--> ")
for x in range(1,num):
if x % 3==0 or x%5==0:
print x;
ഫിലിപ്പ്മാഷേ.., next
r the Limit--> ")
for x in range(1,num):
if x % 3==0 or x%5==0:
count=count+1
print "There are ", count,"whole numbers less than",num,"that are divisible by 3 or 5 (or both)"
ഫിലിപ്പ്മാഷേ.., Sorry Last post has some error while copying sorry the corrected one as follows. Is it right
count=0
num=input("Enter the Limit--> ")
for x in range(1,num):
if x % 3==0 or x%5==0:
count=count+1
print "There are ", count,"whole numbers less than",num,"that are divisible by 3 or 5 (or both)"
sum=0
num=input("Enter the Limit--> ")
for x in range(1,num):
if x % 3==0 or x%5==0:
sum=sum+x
print "The sum of whole numbers less than ", num,"that are divisible by 3 or 5 (or both) is :",sum
പ്രവ. 7.
Sir I don't know why u give a true there. With out that true I think we can do it in this way..Isn't it
-----------------
num=input("Enter a number to check Prime--> ")
for x in range(2,num):
if(num % x==0):
break
if(num-1==x or num==2 or num==1) :
print num," is a prime Number"
else :
print num," is not a Prime Number"
പ്രവ. 8.
Ho here's the last one
Sir I need your comments to all
I'm Sachin.G.Nair
HSA English
St.John's HSS Mattom,Mavelikara
sachingnair.stjohns@gmail.com
9496828002
--------------------------
Last Program follows
--------------------------------------
num1=input("Enter First Number-->")
num2=input("Enter Second Number--->")
for x1 in range(num1,num2):
for x2 in range (2,x1):
if(x1 % x2==0):
break
if(x1-1==x2):
print x1," is prime"
A modified one for 1 and 2 with a change in the second last statement
**************************************
I think it's the right one
********************************
num1=input("Enter First Number-->")
num2=input("Enter Second Number--->")
for x1 in range(num1,num2):
for x2 in range (2,x1):
if(x1 % x2==0):
break
if(x1-1==x2 or x1==1 or x1==2):
print x1," is prime"
സച്ചിന്‍ സാര്‍,
1. ഉത്തരം ഇവിടെ എഴുതി അവിടെനിന്നുകിട്ടുന്ന ലിങ്ക് ഇവിടെ കൊടുത്താല്‍ സ്പേസുകളും മറ്റും ശരിയാകുന്ന രീതിയില് വായിക്കാന്‍ കഴിയും. ഇതല്ലെങ്കില്‍ പ്രോഗ്രാം ശരിയാണോ എന്ന് മനസ്സിലാകില്ല. ഭാമ ടീച്ചറും കിരണം സാറുമൊക്കെ ഉത്തരങ്ങള്‍ തന്ന രീതി നോക്കുക.
2. പാഠത്തില്‍ നാം പരിചയപ്പെടുത്തിയിട്ടില്ലാത്ത കാര്യങ്ങള്‍ (ഉദാ: "break") പ്രോഗ്രാമില്‍ ഉപയോഗിക്കാതെയായിരുന്നെങ്കില്‍ കൂടുതല്‍ നന്നായേനേ. അതല്ലെങ്കില്‍ പ്രോഗ്രാം ഇവിടെ എഴുതിയതിന്റെ കൂടെ "break" എന്താണെന്നുള്ള, എളുപ്പം മനസ്സിലാകുന്ന ഒരു വിശദീകരണം കൂടി ഉണ്ടെങ്കിലും വായനക്കാര്‍ക്ക് പ്രോഗ്രാം വായിച്ചു മനസ്സിലാക്കാന്‍ കഴിയും. ഇത് രണ്ടുമല്ലെങ്കില്‍ ഈ പാഠങ്ങളെ മാത്രമാശ്രയിച്ച് പ്രോഗ്രാമിംഗ് പഠിക്കുന്നവര്‍ക്ക് അത് മനസ്സിലാകുകയില്ലല്ലോ.
-- ഫിലിപ്പ്
ഫിലിപ്പ്മാഷേ..,
ക്ഷമിക്കണം സാര്‍,
നേരത്തെയുള്ള പോസ്ററുകള്‍ ഒന്നും വായിച്ചിരുന്നില്ല.
വെറുതെ ശ്രമിച്ചപ്പോള്‍ ഉത്തരങ്ങള്‍ കിട്ടിയതിനാലാണ് പോസ്ററു ചെയ്തത് copy-paste.
break use ചെയ്തതാല്‍ ലൂപ്പുകളില്‍ നിന്നു പുറത്ത് ചാടാമെന്ന് എവിടെയോ വായിച്ച്തു വച്ച് ചെയ്തു നോക്കിയപ്പോള്‍ കിട്ടി....
http://ideone.com/2yrmr
http://ideone.com/2yrmr
കുറച്ചു ദിവസം കമെന്റുകള്‍ ഇടാന്‍ സാധിച്ചില്ല.എന്റെ തൊട്ടു മുന്‍പത്തെ കമെന്റിനു ഗീത ടീച്ചര്‍ നല്‍കിയ മറുപടി കണ്ടു.ടീച്ചറെ ഞാന്‍ വലിയ പ്രോഗ്രാമ്മര്‍ ഒന്നുമല്ല പിന്നെ കുറച്ചു കാലം പൈതനില്‍ പ്രോഗ്രാം ചെയ്യാന്‍ അവസരം കിട്ടി അതുകൊണ്ട് ഇവിടെ അഭിപ്രായം പറയുന്നു .മറ്റു പോസ്റ്റുകളില്‍ സജീവമായി ഇടപെടുന്ന പലരെയും ഇങ്ങോട്ട് കാണുന്നില്ല.അതിനു പല കാരണവും ഉണ്ടാകും.പ്രേതെകിച്ചു ഈ വര്‍ഷം പയ്തൊന്‍ കൂടുതല്‍ ഒന്നും പഠിപ്പിക്കാന്‍ ഇല്ലാത്തതു കൊണ്ടായിരിക്കും .അല്ലെങ്കിലും ആവശ്യമില്ലാത്തത് പഠിക്കാന്‍ നാം താല്‍പര്യ പെടാറില്ലല്ലോ.
@ഫിലിപ്പ് സാര്‍
അഭാജ്യ സംഖ്യകള്‍ കാണുന്നതിനുള്ള പ്രോഗ്രാമില്‍ ഞാന്‍ പറഞ്ഞ അഭിപ്രായം താങ്കള്‍ ശ്രടിചിരിക്കുമല്ലോ .കൂടാതെ സച്ചിന്‍ സാറ് ചെയ്തപോലെ ബ്രേക്ക്‌ ഉപയോഗിക്കുക കൂടി ചെയ്‌താല്‍ പ്രോഗ്രാം വളരെ വേഗത്തില്‍ ഉത്തരം നല്‍കില്ലേ .
ഇനി ചില പഠന പ്രവര്‍ത്തനം നമുക്ക് ചെയ്തു നോക്കാം
നൂറു വരെ ഉള്ള ഒറ്റ സംഖ്യകളുടെ തുക കാണാന്‍ പ്രോഗ്രാം എഴുതുക
രണ്ടു സംഖ്യകള്‍ക്കു ഇടയിലുള്ള മൂന്നുകൊണ്ടു ഹരിക്കാവുന്ന എന്നാല്‍ അഞ്ചു കൊണ്ട് ഹരിക്കാന്‍ സാധിക്കാത്ത സംഖ്യകളുടെ ശരാശരി കാണുക
Prime Between 2 Numbers
Check for prime
നൂറു വരെ ഉള്ള ഒറ്റ സംഖ്യകളുടെ തുക കാണാന്‍ പ്രോഗ്രാം
ഇതല്ലേ?
രണ്ടു സംഖ്യകള്‍ക്കു ഇടയിലുള്ള മൂന്നുകൊണ്ടു ഹരിക്കാവുന്ന എന്നാല്‍ അഞ്ചു കൊണ്ട് ഹരിക്കാന്‍ സാധിക്കാത്ത സംഖ്യകളുടെ ശരാശരി
ഇതിനുള്ള പ്രോഗ്രാം ഇതല്ലേ?
സച്ചിന്‍ സാറിന്റെ ഈ രണ്ട് പ്രോഗ്രാമുകള്‍ എന്താണ് ചെയ്യുന്നതെന്ന് — പ്രത്യേകിച്ച് അവ ഔട്പുട്ട് എങ്ങനെയാണ് എഴുതുന്നത് എന്നത് — വായിച്ച് മനസ്സിലാക്കാന്‍ ശ്രമിക്കുക. ഇനി ഈ പ്രോഗ്രാമുകള്‍ പ്രവര്‍ത്തിപ്പിച്ചുനോക്കൂ : വായിച്ചപ്പോള്‍ മനസ്സിലായതുമായി പ്രവര്‍ത്തനഫലം ഒത്തുപോകുന്നുണ്ടോ?
സച്ചിന്‍ സാര്‍,
പാഠത്തിലെ പ്രോഗ്രാമില്‍ number_is_prime എന്ന ചരം ഉപയോഗിച്ചിരിക്കുന്ന വിദ്യ വായനക്കാര്‍ക്ക് മനസ്സിലായി എന്ന് ഉറപ്പാക്കാന്‍ വേണ്ടിയാണ് പ്രവര്‍ത്തനം 7-ലെ ചോദ്യം ചോദിച്ചിരിക്കുന്നത്. പലയിടത്തും പ്രോഗ്രാമെഴുത്ത് സുകരമാക്കുന്ന ഈ വിദ്യ നാം അവശ്യം അറിഞ്ഞിരിക്കേണ്ടതായ ഒന്നാണ്. ഇത് മനസ്സിലാക്കിയാല്‍ "ചരം" എന്ന ആശയം കുറച്ചുകൂടെ വ്യക്തമാകും എന്ന ഗുണവും ഉണ്ട്.
കിരണം സാര്‍,
ജയന്‍ സാറിന്റെ ഇതേ ചോദ്യത്തിന് കൊടുത്ത ഉത്തരം ശ്രദ്ധിച്ചുകാണുമല്ലോ?
സാര്‍ തന്ന പ്രവര്‍ത്തനങ്ങള്‍ പാഠത്തിലേക്ക് എടുത്തെഴുതുന്നു. വിരോധമില്ലല്ലോ?
കഴിയുന്നത്ര ലളിതമായ രീതിയില് പ്രോഗ്രാമിംഗ് അവതരിപ്പിക്കുക എന്നതാണല്ലോ നമ്മുടെ ഉദ്ദേശ്യം? ഈ പാഠങ്ങളെ മാത്രമാശ്രയിച്ച് പ്രോഗ്രാമിംഗ് പഠിക്കുന്ന, പ്രോഗ്രാമിംഗില്‍ പ്രത്യേക വാസന ഒന്നുമില്ലാത്ത, എന്നാല്‍ കുറച്ച് ബുദ്ധിമുട്ടാന്‍ തയ്യാറുള്ള ഒരാളെ മനസ്സില്‍ കണ്ടാണ് ഞാന്‍ പാഠങ്ങളും കമന്റുകളും എഴുതുന്നത്. അതുകൊണ്ട് ഏറ്റവും വേഗം ഉത്തരം കിട്ടുന്ന പ്രോഗ്രാം എഴുതുക എന്നതിനെക്കാള്‍ ഏറ്റവും എളുപ്പം വായിച്ച് മനസ്സിലാക്കാവുന്ന പ്രോഗ്രാം എഴുതുക എന്നതിനാണ് ഞാന്‍ മുന്‍ഗണന കൊടുക്കുന്നത്. ഞാനെഴുതുന്ന പ്രോഗ്രാമുകളില്‍ ധാരാളമായി കമന്റുകള്‍ കൊടുക്കുകയും, അങ്ങനെ ചെയ്യാന്‍ എല്ലാവരേയും പ്രോത്സാഹിപ്പിക്കുകയും ചെയ്യുന്നതിന്റെ ഒരു ഉദ്ദേശ്യവും ഇതുതന്നെ. പ്രോഗ്രാമിംഗ് എന്തോതരം കൂടോത്രം (black magic) ആണെന്ന തോന്നല്‍ ഇല്ലാതാക്കുക എന്നതാണ് ഈ പാഠങ്ങളുടെ ലക്ഷ്യം.
-- ഫിലിപ്പ്
1
ഫിലിപ്പ് സാര്‍ ,
താങ്കളുടെ പൈത്തന്‍ ക്ലാസ്സ്‌ ഒന്നുകൊണ്ടു മാത്രമാണ ഞാന്‍ ഈ പ്രോഗ്രാമിംഗ് ലാംഗ്വേജ് പഠിക്കാന്‍ ആരംഭിച്ചത് . വളരെ നന്ദിയുണ്ട് . സാധാരണയായി for loop പഠിക്കുന്നവര്‍ ചെയ്തുനോക്കുന്ന multiplication table, കുറച്ചു patterns എന്നിവ ചേര്‍ക്കുന്നു . ഇത് കുടുതല്‍ പാറ്റെന്നുകള്‍ കണ്ടെത്താന്‍ പഠിതാക്കളെ സഹായിക്കുമായിരിക്കും.
ഇന്പുട്റ്റ് ചെയ്യുന്ന നമ്പറിന്റെ ഗുണന പട്ടിക
ഇവിടെ
ഒന്നുമുതല്‍ പത്തുവരെ നമ്പറിന്റെ ഗുണന പട്ടിക keypress ചെയ്യുമ്പോള്‍
ഇവിടെ
raw_input("Press Any Key to Continue: ")
ഈ വരിയുടെ ഉപയോഗം പ്രത്യേകം മനസ്സിലാക്കുക.
പത്ത് വരെ സംഖ്യകളുടെ ഗുണനപ്പട്ടിക.
ഇവിടെ
അടുത്ത സംഖ്യ കിട്ടാന്‍ ഒരു കി അമര്‍ത്തുക
raw_input("Press Any Key to Continue: ")
ഈ നിര്‍ദ്ദേശം ശ്രദ്ധിക്കുക
Pattern 1
ഇവിടെ
Pattern-2
Here
Pattern 3
Pattern -3
Pattern-4
Pattern-4
Pattern (പ്രവ. 12. )
പ്രവ. 13.
പ്രവ. 14.
പ്രവ. 15.
പ്രവ. 11 ഇങ്ങനെ യാണോ ?
ഭാമ ടീച്ചര്‍,
പ്രോഗ്രാമിന്റെ ഏകദേശ രൂപം ശരിയാണ്. രണ്ട് ചെറിയ കാര്യങ്ങള്‍:
1. b, c എന്നിവ 1000-ത്തിനെക്കാള്‍ ചെറുതാണ് എന്ന് കരുതുന്നതുകൊണ്ട് അത്ര വലുതല്ലാത്ത ചില സംഖ്യകള്‍ ഇന്‍പുട്ട് ആയി കൊടുത്താലും ഉത്തരം തെറ്റിപ്പോകും. ഉദാ: 45 എന്ന ഇന്‍പുട്ടിന് ടീച്ചറുടെ പ്രോഗ്രാം താഴെപ്പറയുന്ന ത്രയങ്ങള്‍ ഔട്പുട്ട് ആയി തരുന്നു:
45 24 51
45 27 36
45 28 53
45 60 75
45 108 117
45 200 205
45 336 339
ഇക്കൂട്ടത്തില്‍ വരേണ്ടതായ (45, 1012, 1013) എന്ന ത്രയം ഉത്തരത്തില്‍ വരില്ല. അതുപോലെ 47 എന്ന ഇന്‍പുട്ടിന് ഈ പ്രോഗ്രാം ഒരു ത്രയവും ഔട്പുട്ട് തരില്ല. എന്നാല്‍ 1104 ^2 + 47 ^2 = 1105 ^2 ആണുതാനും (ഇത് പൈത്തണ്‍ ഷെല്‍ ഉപയോഗിച്ചുതന്നെ പരിശോധിക്കാം).
അപ്പോള്‍: 1000 എന്ന പരിധിക്കു പകരം ഇന്‍പുട്ട് ആയി കിട്ടിയ a എന്ന സംഖ്യയെ അടിസ്ഥാനപ്പെടുത്തിയുള്ള ഒരു പരിധി — ഈ പരിധിക്കപ്പുറം b, c എന്നിവ പോവില്ല എന്ന് തെളിവുള്ള ഒന്ന് — പ്രോഗ്രാമില്‍ എഴുതിയാല്‍ പ്രോഗ്രാം കുറേക്കൂടി ശരി ആകും.
2. പ്രോഗ്രാമിന്റെ ആറാമത്തെ വരിയിലെ മൂന്ന് ഉപാധികളില്‍ ഒന്ന് ആവശ്യമുണ്ടോ?
-- ഫിലിപ്പ്
ഫിലിപ്പ് സാര്‍,
1000നു പകരം a^2 നല്കിയാല്‍ കുറച്ചുകൂടി ശരിയാകുമെന്നു തോന്നുന്നു. അതല്ലാതെ മറ്റുവല്ല പരിധിയും കൊടുക്കാന്‍ കഴിയുമോ ?
പ്രോഗ്രാമിന്റെ ആറാമത്തെ വരിയിലെ മൂന്ന് ഉപാധികളില്‍ ഒന്ന് മാത്രം കൊടുത്താലും മതി എന്നു തോന്നുന്നു.
ക്യൂബ് റൂട്ട് കാണാനുള്ള കോഡ് എന്താണ് ?
>>> 64**(1.0/3)
3.9999999999999996
ഇത് ശരിയല്ലല്ലോ ?
വിജയന്‍ സാറിന്റെ ഈ ചോദ്യത്തിനുത്തരം കണ്ടെത്താന്‍ ശ്രമിച്ചപ്പോഴാണ് പ്രശ്നം ( 144,192,240) ചുറ്റളവ്‌ പൂര്നവര്‍ഗവും (24^2=576),പരപ്പളവ്‌ പൂര്‍ണ ഘനവും(24^3=13824 )ആയ ഒരു പൈതഗോര്യന്‍ ട്രിപ്പിള്‍ ആണ് . ഇതേ സവിശേഷതയുള്ള അനേകം പൈതഗോര്യന്‍ ത്രയങ്ങള്‍ ഉണ്ടോ? ഒരു ചുരുങ്ങിയ ലിസ്റ്റ് പ്രതീക്ഷിക്കുന്നു)
150,360,390 ഇങ്ങനെ കണ്ടെത്തിയതാണ്.
ഭാമ ടീച്ചര്‍,
(ഇന്നലെ ഇവിടെ ഇന്റര്‍നെറ്റ് ഇല്ലാതിരുന്നതുകൊണ്ടാണ് മറുപടി വൈകിയത്)
എനിക്ക് തോന്നിയതും a^2 എന്ന പരിധി തന്നെ. ഇതിലും ചെറിയ പരിധി ഉണ്ടോ എന്ന് അറിഞ്ഞുകൂടാ. കുറച്ചുകൂടി ആലോചിച്ചാല്‍ ഉത്തരം (ഉണ്ടെന്നോ ഇല്ലെന്നോ) കിട്ടിയേക്കാം.
ക്യൂബ് റൂട്ട് കാണാന്‍ (വിജയന്‍ സാറിന്റെ പ്രശ്നത്തിന് തന്നെ) ഞാന്‍ ഈ കോഡാണ് ഉപയോഗിച്ചത്. 1000 വരെയുള്ള സംഖ്യകളില്‍ എനിക്കും (150, 360, 390) എന്നതുമാത്രമേ പുതുതായി കിട്ടിയുള്ളൂ.
-- ഫിലിപ്പ്
പൈത്തണ്‍ പുതിയ പാഠം ഇതു വരെ തയ്യാറായില്ലേ? ഈ പോസ്റ്റ് വന്നിട്ട് ഒന്നര മാസം കഴിഞ്ഞു.
ശങ്കരന്‍ മാഷ്,
നല്ല ജോലിത്തിരക്കായതുകൊണ്ടാണ് അടുത്ത പാഠം എഴുതാഞ്ഞത്. തന്നെയുമല്ല, മിക്കവരും ആദ്യ പാഠങ്ങള്‍ പഠിച്ചുവരുന്നതേ ഉള്ളൂ. ഇതുവരെയുള്ള പാഠങ്ങള്‍ പഠിച്ച് പ്രവര്‍ത്തനങ്ങളൊക്കെ ചെയ്യാന്‍ കെല്‍പ്പുള്ളവരായാലേ ഇനിയുള്ള പാഠങ്ങള്‍ ശരിയായ വിധത്തില്‍ മനസ്സിലാക്കാന്‍ (ആസ്വദിക്കാനും) പറ്റൂ.
മുമ്പ് പറഞ്ഞതുപോലെ, പ്രോഗ്രാമിംഗ് എന്നത് പ്രവര്‍ത്തനങ്ങള്‍ ചെയ്തുമാത്രം സ്വായത്തമാക്കാവുന്ന ഒരു കഴിവ് ആണ് : നീന്തലോ സൈക്കിളോടിക്കലോ പോലെ. പാഠങ്ങള്‍ വായിച്ചാല്‍ നമുക്ക് മനസ്സിലായി എന്ന് തോന്നുമെങ്കിലും, തനിയെ ഒരു പ്രവര്‍ത്തനം ചെയ്ത് നോക്കുമ്പോഴേ പല കാര്യങ്ങളും നാം കരുതിയതുപോലെ അല്ല എന്ന് മനസ്സിലാവുകയുള്ളൂ.
-- ഫിലിപ്പ്
എല്ലാ പാഠവും എല്ലാവരും പഠിച്ചുതീരണമെന്നില്ല സാര്‍.
അടുത്ത പാഠം സൃഷ്ടിക്കുന്ന ഓളം നിശ്ചയമായും നിശ്ചലരായിരിക്കുന്ന കുറേപ്പേരെ ഒന്നുരണ്ടു ചാണെങ്കിലും മുന്നോട്ടു നീക്കും.
കാത്തിരിക്കുന്നു.
ഏഴാം പാഠം ഇല്ലേ..?
പഠിക്കാന്‍ തുടങ്ങുന്നു. അണിയറ പ്രവര്‍ത്തകര്‍ക്ക്‌ ഭാവുകങ്ങള്‍
ഫിലിപ്പ് സാര്‍,
ജോലി തിരക്കായതുകൊണ്ടാണോ അടുത്ത പാഠം തയ്യാറാക്കാത്തത് ?
ഒമ്പതാം ക്ലാസ്സിലെ പുതിയ ഐ സി ടി പുസ്തകത്തില്‍ ചിത്രം വരയ്ക്കുന്നതിനുള്ള പ്രോഗ്രാമൊക്കെ എഴുതാനുണ്ട്. അതുകൊണ്ടു തന്നെ അതിനെ കുറിച്ച് വിശദമായ ഒരു പാഠം കൂടി സാറില്‍ നിന്ന് പ്രതീക്ഷിക്കുന്നു
ഭാമ ടീച്ചര്‍,
ജോലിത്തിരക്കായതുകൊണ്ടാണ് പാഠം തയ്യാറാക്കാന്‍ താമസിച്ചത്. ഇടയ്ക്ക് തിരക്കല്‍പ്പം കുറഞ്ഞ സമയം നോക്കി ഏഴാം പാഠം തയ്യാറാക്കി നല്‍കിയിരുന്നു. മാത്‌സ് ബ്ളോഗില്‍ പരീക്ഷാസെന്‍സസാദികളുടെ തിരക്കായതുകൊണ്ടായിരിക്കണം ഇതുവരെ ഇത് പ്രസിദ്ധീകരിക്കാഞ്ഞത്.
ഒമ്പതാം ക്ളാസിലെ പുതിയ ഐ സി ടി പുസ്തകം ഓണ്‍ലൈനായി കിട്ടാനുണ്ടോ? അവിടെ വേണ്ടത് എന്താണെന്ന് മനസ്സിലായാല്‍ അത്തരത്തിലുള്ള ഒരു പാഠം എഴുതാന്‍ ബുദ്ധിമുട്ടുണ്ടാവില്ല എന്നാണ് തോന്നുന്നത്.
-- ഫിലിപ്പ്
സാര്‍,
ഒമ്പതാം ക്ലാസ്സിലെ ഐ സി ടി പുസ്തകം downloads (23/2/2011)ല്‍ നല്കിയിട്ടുണ്ട്.
ICT textbook for standard 9
Malayalam ,
English
pattern 1 ,
Pattern 2
മുകളില്‍ കൊടുത്ത രണ്ടു പ്രോഗ്രാമിന്‍റേയും output ഒന്നു തന്നെയാണ് . നിറം മാത്രം മാറുന്നു. ഒന്നാമത്തെ പ്രോഗ്രാമില്‍ എങ്ങനെ വ്യത്യസ്ത നിറങ്ങള്‍ നല്കാം ?
എന്തെല്ലാം മാറ്റം വരുത്തണം ?
ഭാമ ടീച്ചര്‍,
പുസ്തകങ്ങള്‍ക്ക് നന്ദി. പുസ്തകം ഒന്ന് ഓടിച്ചുനോക്കി. ഇതെക്കുറിച്ചുള്ള പാഠങ്ങളും ചര്‍ച്ചയും ഇവിടെ നമുക്ക് തീര്‍ച്ചയായും ആകാം.
ടീച്ചര്‍ തന്ന രണ്ട് പ്രോഗ്രാമിലും import time എന്ന വരി അധികപ്പറ്റാണ്. ഇതുള്ളതുകൊണ്ട് ഈ പ്രോഗ്രാമുകള്‍ക്ക് പ്രത്യേകിച്ച് ഗുണമൊന്നും ഇല്ല. ഈ വരി ഒഴിവാക്കിയാലും ഈ പ്രോഗ്രാമുകള്‍ ഭംഗിയായി പ്രവര്‍ത്തിക്കും.
ടീച്ചര്‍ക്ക് ഈ പ്രോഗ്രാമുകള്‍ എങ്ങനെയാണ് പ്രവര്‍ത്തിക്കുന്നത് എന്ന് സംശയമുണ്ടോ, അതോ ആദ്യത്തെ പ്രോഗ്രാം എങ്ങനെ മാറ്റണം എന്നത് മാത്രമാണോ അറിയേണ്ടത്?
-- ഫിലിപ്പ്
ആദ്യത്തെ പ്രോഗ്രാമില്‍ നിറം നല്കുന്നത് എങ്ങനെ ?
ആ പ്രോഗ്രാമില്‍ എന്തെങ്കിലും മാറ്റം വരുത്തിയാല്‍ ഒരേ ആരമുള്ള വൃത്തങ്ങള്‍ വരച്ച് അടുത്ത റൗണ്ട് തുടരാന്‍ കഴിയുമോ ?
ഭാമ ടീച്ചര്‍,
ഇവിടെ നോക്കുക.
-- ഫിലിപ്പ്
സാറ് തന്ന നോട്സ് turtle നെ കുറിച്ച് കൂടുതലറിയാന്‍ സ‌ഹായകമായി.അതിലേക്കു കടക്കുന്നതിനു മുമ്പ് ആദ്യഭാഗങ്ങള്‍ ഒന്നുകൂടി നോക്കിയപ്പോള്‍ ചില പ്രോഗ്രാമുകളില്‍ സംശയം വന്നു.
1 ദ്വിമാനസമവാക്യങ്ങളുടെ മൂല്യം കാണുന്ന ഈ പ്രോഗ്രാമില്‍ മൂല്യം പൂര്‍ണ്ണസംഖ്യ മാത്രമേ കിട്ടുന്നുള്ളു.
2.ഇതേ പാഠത്തിലെ പാറ്റേണുകളുടെ പ്രോഗ്രാമില്‍ range എടുക്കുന്നത് ഏതടിസ്ഥാനത്തിലാണ് ?
ഒന്നു വിശദീകരിക്കാമോ ?
ഭാമ ടീച്ചര്‍,
1. അല്ലല്ലോ. തക്കതായ ഇന്‍പുട്ടിന് അവിടെത്തന്നെ അങ്ങനെ അല്ലാത്ത ഉത്തരം കിട്ടുന്നുണ്ടല്ലോ. ടീച്ചര്‍ തനിയെ പ്രോഗ്രാം എഴുതിയപ്പോഴാണ് ഇങ്ങനെ കാണുന്നതെങ്കില്‍ രണ്ടാം പാഠത്തിലെ "കൂട്ടലും കുറയ്ക്കലും (മറ്റു ക്രിയകളും)" എന്ന ഭാഗത്ത് കൊടുത്തിരിക്കുന്ന ഉദാഹരണങ്ങള്‍ ശ്രദ്ധിച്ച് വായിച്ചുനോക്കുക. കൂടാതെ മൂന്നാം പാഠത്തിലെ "പൈത്തണ്‍ ദ്വിഭാഷിയുടെ മറ്റൊരു മുഖം" എന്ന ഭാഗത്തെ ഉദാഹരണങ്ങളും നോക്കുക. ഇനിയും പ്രോഗ്രാം ശരിയാകുന്നില്ലെങ്കില്‍ ചോദിക്കുക.
2. നാലാം പാഠത്തിലെ നാലും അഞ്ചും പ്രവര്‍ത്തനങ്ങള്‍ ചെയ്തുനോക്കുക. അഞ്ചാമത്തെ പ്രവര്‍ത്തനത്തില്‍ സംഭവിക്കുന്നത് എന്താണ്? പാറ്റേണ്‍ പ്രോഗ്രാമുകള്‍ എഴുതുന്നത് എങ്ങനെയെന്ന് ഇത് കഴിഞ്ഞും വ്യക്തമാകുന്നില്ലെങ്കില്‍ ചോദിക്കുക.
-- ഫിലിപ്പ്
സാര്‍,
ദ്വിമാനസമവാക്യത്തിലെ മൂല്യം കാണുന്നതിനുള്ള ഈ പ്രോഗ്രാമില്‍ 28 മുതല്‍ 31 വരെയുള്ള വരികളിലാണ് എന്റെ സംശയം.
9x^2 - 12x +4 എന്ന വാക്യത്തിന്റെ മൂല്യം കാണുമ്പോള്‍
>>>
A program that finds the roots of the quadratic equation
ax^2+bx+c=0 where a is not 0
a = 9
b = -12
c = 4
The two roots of the equation coincide.
The single value of the roots is: 0
>>> എന്ന ഉത്തരമല്ലെ കിട്ടുന്നത് ?
.66666 അല്ലെ കിട്ടേണ്ടത്
ഭാമ ടീച്ചര്‍,
ടീച്ചര്‍ പറഞ്ഞത് ശരിയാണ്, ഇത് പ്രോഗ്രാമിലെ ഒരു ബഗ് ആണ് (ആയിരുന്നു). ഞാന്‍ ഇത് തിരുത്തിയിട്ടുണ്ട്.
ദശാംശചിഹ്നം ഇല്ലാത്ത ഒരു സംഖ്യയെ അതേപോലുള്ള വേറൊന്നുകൊണ്ട് ഹരിച്ചാല്‍ പൈത്തണില്‍ കിട്ടുന്ന ഉത്തരത്തിലും ദശാംശചിഹ്നവും അതു കഴിഞ്ഞുള്ള അക്കങ്ങളും കാണുകയില്ല. പൂര്‍ണ്ണസംഖ്യാഹരണം (Integer Division) എന്നാണ് ഇതിന് പറയുന്നത്. ഇത് പൈത്തണിന്റെ നിര്‍വചിക്കപ്പെട്ട സ്വഭാവത്തിന്റെ ഭാഗമാണ്, ബഗ് അല്ല. ഉത്തരത്തിന്റെ പൂര്‍ണ്ണസംഖ്യാഭാഗത്തില്‍ മാത്രമാണ് നമ്മുടെ നോട്ടമെങ്കില്‍ ഈ രീതിയില് ഹരിക്കുന്നതിനാണ് വേഗക്കൂടുതല്‍.
നമ്മുടെ പ്രോഗ്രാമില്‍ ദശാംശ സംഖ്യകള്‍ ഉത്തരമായി കിട്ടേണ്ട പലയിടത്തും പൂര്‍ണ്ണസംഖ്യാഹരണമായിരുന്നു പ്രയോഗിച്ചിരുന്നത്. ഇതായിരുന്നു പ്രോഗ്രാമിലെ ബഗ്. 20, 21, 31, 36, 37 എന്നീ വരികളില്‍ ഇത് ഞാന്‍ തിരുത്തിയിട്ടുണ്ട്. ഇവിടെയെല്ലാം 2 എന്നുണ്ടായിരുന്നത് 2.0 എന്ന് മാറ്റുകയാണ് തിരുത്തില്‍ ചെയ്തത്.
-- ഫിലിപ്പ്
സാര്‍ ,
ഈ ബഗ് കണ്ടെത്താന്‍ എനിക്കു കഴിഞ്ഞില്ല.
പാറ്റണ്‍ പ്രോഗ്രാം ചെയ്യാന്‍ കഴിഞ്ഞു എന്നു തന്നെ വിശ്വസിക്കുന്നു.
hai masters and friends
yes today (17-2011) I am going to start to learn sixth lesson
മുഹമ്മദ് സാര്‍,
ദ്വിമാന സമവാക്യത്തിന്റെ നിര്‍ദ്ധാരണത്തിനുള്ള പ്രോഗ്രാം താങ്കള്‍ക്ക് ശരിയാക്കാന്‍ പറ്റിയോ എന്ന് കമന്റുകളില്‍നിന്ന് വ്യക്തമല്ല. പൂര്‍ണ്ണസംഖ്യകള്‍ ഉപയോഗിച്ച് ക്രിയകള്‍ ചെയ്യുമ്പോള്‍ ഉത്തരവും പൂര്‍ണ്ണസംഖ്യ തന്നെ ആയിരിക്കുക എന്ന പൈത്തണിന്റെ (നിര്‍വചിക്കപ്പെട്ട) സ്വഭാവം കാരണമാണ് താങ്കളുടെ പ്രോഗ്രാം തെറ്റായ ഉത്തരം തന്നത്. ഉദാഹരണത്തിന്, 1/2 എന്നതിന്റെ വില 0.5 എന്നതിന് പകരം 0 എന്നാണ് കിട്ടുക. 0.5 എന്ന് കിട്ടണമെങ്കില്‍ ക്രിയയില്‍ ഉള്‍പെട്ട രണ്ട് സംഖ്യകളില്‍ ഒന്നെങ്കിലും ദശാംശ സംഖ്യ ആകണം : 1.0/2, 1/2.0, അല്ലെങ്കില്‍ 1.0/2.0 എന്നൊക്കെ എഴുതിയാല്‍ 0.5 എന്നാകും അതിന്റെ വില.
ഇത് കൂടാതെ ** (ഘാതം) എന്ന സംകാരകത്തിന് ഗുണനം, ഹരണം എന്നിവയെക്കാള്‍ മുന്‍ഗണന (precedence) ഉള്ളതുകൊണ്ട് D**1.0/2 എന്നതിന് D-യെ രണ്ടുകൊണ്ട് ഹരിക്കുക എന്നാകും അര്‍ത്ഥം. D-യുടെ വര്‍ഗമൂലം കാണണമെങ്കില്‍ D**(1.0/2) എന്നിങ്ങനെ ഹരണം ആദ്യം നടക്കത്തക്കവിധം ബ്രായ്ക്കറ്റുകള്‍ ഉപയോഗിച്ച് എഴുതണം.
വിവേചകം നെഗറ്റീവ് ആകുന്നത് കൈകാര്യം ചെയ്യാന്‍ (താങ്കള്‍ സ്വയം മനസ്സിലാക്കി എടുത്തതുപോലെ) "i" എന്ന അക്ഷരത്തെ ബാക്കിയുള്ള ഉത്തരത്തോട് പറ്റിച്ചുവെക്കുക എന്ന ഒരു "കുരുട്ടുവിദ്യ" ആണ് നമ്മള്‍ ഉപയോഗിക്കുന്നത് . അവാസ്തവിക/സങ്കീര്‍ണ്ണ സംഖ്യകള്‍ പൈത്തണില്‍ സ്വതവേ ഉണ്ടെങ്കിലും ഒരു നെഗറ്റീവ് സംഖ്യയുടെ ഭിന്ന ഘാതം (fractional power) കാണുക എന്നത് പൈത്തണിലെ ** എന്ന സംകാരകത്തിന്റെ പരിധിയില്‍ ഉള്‍പ്പെടുത്തിയിട്ടില്ല.
അവാസ്തവിക സംഖ്യയെ കുറിക്കാന്‍ j അല്ലെങ്കില്‍ J എന്നത് ഒരു വാസ്തവിക സംഖ്യയുടെ കൂടെ ചേര്‍ത്ത് എഴുതിയാല്‍ മതി. ഉദാഹരണത്തിന്, (1 + 2j)*(1 - 2j) എന്നതിന്റെ വില ഷെല്‍ ഉപയോഗിച്ച് കണ്ടുനോക്കൂ.
ആറാം പാഠം പഠിക്കാന്‍ സര്‍വവിധ ആശംസകളും!
-- ഫിലിപ്പ്
Thank you philip sir, thank you
I understood my mistakes. Your advice is more valuable which helped me to clear my many doubts.
I started sixth lesson.
#thank you philip sir
# this is the activity 4 in the lesson 6
n=input("enter a number ")
n_is_divisible=True
for i in range(3,n):
if (i%3==0) or (i%5==0):
n_is_divisible==True
print i
I checked this program , it is ok.
please give me more advice
# this is activity 6
number=input ("enter a number")
sum=0
for i in range(3,number):
if i%3==0 or i%5==0:
sum=sum+i
print "sum of the numbers divisible by 3 or 5 \
by number less than you give =", sum
മുഹമ്മദ് സാര്‍,
ഇവിടെ കമന്റ് ബോക്സില്‍ പ്രോഗ്രാം എഴുതുമ്പോള്‍ അതിന്റെ നിരപ്പ് (alignment) തെറ്റിപ്പോകുന്നത് ശ്രദ്ധിച്ചുകാണുമല്ലോ? ഇതുകാരണം പ്രോഗ്രാമിന്റെ അര്‍ത്ഥം തന്നെ മാറിപ്പോകുന്നു. ഈ പ്രശ്നം ഒഴിവാക്കാന്‍ പ്രോഗ്രാമുകള്‍ ഇവിടെ എഴുതി "submit" അമര്‍ത്തിയാല്‍ കിട്ടുന്ന ലിങ്ക് ഇവിടെ കൊടുത്താല്‍ മതിയാകും. അവിടെ പ്രോഗ്രാം എഴുതുമ്പോള്‍ ഭാഷ പൈത്തണ്‍ ആയി തിരഞ്ഞെടുക്കാന്‍ ശ്രദ്ധിക്കണം. കുടാതെ "run code" എന്നത് ഇല്ലാതെയും വേണം. മുമ്പുള്ള കമന്റുകളില്‍ ഭാമ ടീച്ചറും മറ്റും ഇങ്ങനെ ചെയ്തിട്ടുള്ളത് ശ്രദ്ധിക്കുക.
-- ഫിലിപ്പ്
lesson 6 activity 9
adding odd number upto given input number
here is the program
http://ideone.com/zCnPa
മുഹമ്മദ് സാര്‍,
പ്രോഗ്രാം മിക്കവാറും ശരിയാണ്. ഇന്‍പുട്ട് കിട്ടുന്ന സംഖ്യ ഒറ്റസംഖ്യയാണെങ്കില്‍ ഉത്തരം ശരിയാകുമോ? ഇത് എങ്ങനെ ശരിയാക്കാം?
-- ഫിലിപ്പ്
philip sir
sub: about activity in lesson 6-
when I gave odd number or even number as input I got answer. I could not find further mistakes. Please help
activity 10 in lesson 6
philip sir
here I give its code but it is not ok please point out my mistake
http://ideone.com/0HGwO
phlilip sir I am waiting
മുഹമ്മദ് സാര്‍,
പ്രോഗ്രാം തെറ്റുന്നു എന്ന് എന്തുകൊണ്ടാണ് പറഞ്ഞത്? പ്രോഗ്രാമില്‍നിന്ന് എന്താണ് പ്രതീക്ഷിച്ചത്? പ്രതീക്ഷിച്ചതില്‍നിന്ന് വ്യത്യസ്തമായി അത് എന്താണ് പ്രവര്‍ത്തിച്ചത്?
-- ഫിലിപ്പ്
Philip sir, I could not run this program (activity 10 in lesson 6) correctly. when I run this program an error message given below is shown:
Traceback (most recent call last):
File "C:/Python27/dd.py", line 7, in
for i in range(n_1, n_2):
TypeError: range() integer end argument expected, got str
please give suggestions.
Philip sir,
I cannot run this program, When I press F5 an error message comes as given below,
Traceback (most recent call last):
File "C:/Python27/dd.py", line 7, in
for i in range(n_1, n_2):
TypeError: range() integer end argument expected, got str.
please help to get confidence for next activity.
മുഹമ്മദ് സാര്‍,
ഈ സന്ദേശം എന്താണ് പറയുന്നതെന്ന് നോക്കാം : C:/Python27/dd.py എന്ന ഫയലിലെ ഏഴാമത്തെ വരിയിലാണ് പ്രശ്നം എന്നാണ് ഇവിടെ പറയുന്നത്. പ്രശ്നം എന്താണെന്നുകൂടി പറയുന്നുണ്ട്: range() എന്ന ഏകദത്തിന് വാക്യമായി (argument) പൂര്‍ണ്ണസംഖ്യകളെയാണ് (integer) പ്രതീക്ഷിച്ചത്. കിട്ടിയതോ, സ്ട്രിംഗും (str എന്നതുകൊണ്ട് വിവക്ഷിച്ചിരിക്കുന്നു).
താങ്കളുടെ പ്രോഗ്രാമില്‍ range() എന്ന ഏകദത്തിന്റെ വാക്യങ്ങള്‍ (arguments -- ഏകദത്തിലേക്ക് കൊടുത്ത കാര്യങ്ങള്‍) സംഖ്യകള്‍ക്ക് പകരം string-കള്‍ ആയിപ്പോയത് എന്താണെന്ന് നോക്കുമോ?
-- ഫിലിപ്പ്
Thank you sir
I understood my mistake. I forgot to give input command.
sir, I corrected the code and I got average correctly. But sir when I gave interval from 1 to 20 I got answer as 9 but actual answer is 9.8
decimal place is not indicated. To get decimal place what steps to be included. give me hints only.
activity 10 in lesson 6
program code is given below
http://ideone.com/l8Vwk
മുഹമ്മദ് സാര്‍,
ഈ പ്രോഗ്രാമിന് യഥാക്രമം 1, 2 എന്നിവ ഇന്‍പുട് ആയി കൊടുത്താല്‍ എന്ത് ഉത്തരമാണ് കിട്ടേണ്ടത്?
എന്ത് ഉത്തരമാണ് കിട്ടുന്നത്?
-- ഫിലിപ്പ്
hai everybody I am mohammed ashraf is back now. really I missed philip sir and my online friends. I could not attend and complete sixth lesson due to some personal matters.
bless me to complete sixth lesson soon
for ഉപയോഗിച്ചുള്ള പ്രോഗ്രാമിംഗ് അത്ര എളുപ്പമായി തോന്നുന്നില്ല. കുറച്ചു കൂടി ഉദാഹരണങ്ങൾ സഹിതം വിശദീകരിക്കാമോ..അതായത് for ന്റെ കൂടെ number എന്ന് എപ്പോഴും നൽകണോ..? സത്യം പറഞ്ഞാൽ for നെ എനിക്ക് ശരിക്ക് മനസ്സിലാക്കാൻ സാധിച്ചിട്ടില്ല.
"ഒരു ലിസ്റ്റിലെ അംഗങ്ങളെ ഓരോന്നായി പ്രോഗ്രാമില്‍ ലഭ്യമാക്കാന്‍ പൈത്തണിലുള്ള സംവിധാനമാണ് for ." എന്ന് പറഞ്ഞിരിക്കുന്നത് ശ്രദ്ധിക്കുക.
"for ന്റെ കൂടെ number എന്ന് എപ്പോഴും നൽകണോ..?"
ഇങ്ങനെ അല്ലാതുള്ള ഉദാഹരണം പാഠത്തിൽത്തന്നെ "ലിസ്റ്റുകളും for-ഉം" എന്ന ഭാഗത്ത് ഉണ്ടല്ലോ. ഇനി: for-ന്റെ കൂടെ number എന്ന് അല്ലാതെ കൊടുത്തുനോക്കാമല്ലോ? മാറ്റങ്ങൾ വരുത്തി പ്രോഗ്രാം പ്രവർത്തിപ്പിച്ച് നോക്കാൻ (സമയനഷ്ടമല്ലാതെ) മറ്റ് ചെലവൊന്നുമില്ലല്ലോ. പാഠത്തിൽ കൊടുത്തിട്ടുള്ള പ്രോഗ്രാമുകൾ അതേപടി പ്രയോഗിക്കുന്നതുകൂടാതെ ഇങ്ങനെ പലതരം മാറ്റങ്ങൾ വരുത്തിനോക്കിയാൽ ആശയങ്ങൾ കൂടുതൽ വേഗം മനസ്സിലാകും. ഇങ്ങനെ ചെറിയ മാറ്റങ്ങൾ (tinkering) വരുത്തിനോക്കാനുള്ള താത്പര്യം പ്രോഗ്രാമിംഗിൽ വളരെ ഉപകരിക്കുന്ന ഒന്നാണ്. ഇലക്ട്രോണിക്സിലും അങ്ങനെ തന്നെയല്ലേ?
for-നെ ശരിക്ക് മനസ്സിലാക്കാൻ ഇത് ചെയ്യുക: "for-നെപ്പറ്റി വിശദമായി" എന്ന ഭാഗത്തെ അക്കമിട്ട കാര്യങ്ങൾ ഓരോന്നായി വായിക്കുക. ഇതിൽ ഓരോ കാര്യവും വായിച്ച ഉടനെ അത് തൊട്ടുമുൻപുള്ള ഭാഗത്തെ ഓരോ ഉദാഹരണത്തിലും ശരിയായി വരുന്നുണ്ടോ എന്ന് ശ്രദ്ധിച്ച് ഉറപ്പുവരുത്തുക. അക്കമിട്ട് പറഞ്ഞിരിക്കുന്ന ഓരോന്നിലും കുറേ സൂക്ഷ്മാംശങ്ങൾ (details) ഉണ്ടെന്നത് ശ്രദ്ധിക്കുക. ഇതിൽ ഓരോ കാര്യവും ഉദാഹരണങ്ങളിൽ വരുന്നുണ്ടോ, ഉണ്ടെങ്കിൽ എങ്ങനെ എന്നത് നോക്കുക.
നാം ആദ്യമായി കാണുന്ന രേഖീയമല്ലാത്ത പ്രോഗ്രാമിംഗ് സങ്കേതമാണ് for. അതുകൊണ്ടാകണം ഇത് മനസ്സിലാക്കാൻ അത്ര എളുപ്പമല്ലാത്തത്. മുകളിൽ പറഞ്ഞ പ്രവർത്തനം ചെയ്താൽ ഇത് മനസ്സിലാക്കാൻ കഴിയും.
ഭാമടീച്ചർ പ്രവർത്തനം 5നും 6നും ചെയ്തിരിക്കുന്ന ഉത്തരങ്ങൾ കണ്ടു. പക്ഷേ അതിൽ രണ്ടു വരികൾ മനസ്സിലാവുന്നില്ല. http://ideone.com/C3qKW ഈ ലിങ്കിലെ കോഡിൽ sum=0 എന്നു കൊടുത്തിരിക്കുന്നതും sum=sum+number എന്നു കൊടുത്തിരിക്കുന്നതും വിശദീകരിക്കാമോ..?
പല തുടക്കക്കാരും നേരിടുന്ന പ്രധാനപ്പെട്ട ഒരു കടന്പയിലാണ് താങ്കൾ എത്തിയിരിക്കുന്നത്. ഇവിടെ കൃത്യമായി സംശയനിവാരണം നടത്തി മാത്രം മുൻപോട്ട് പോകേണ്ടത് ഇനിയുള്ള പഠനത്തിന് അനിവാര്യമാണ്. ഇതിനായി ചെയ്യേണ്ട കാര്യങ്ങൾ:
1. നാലാം പാഠത്തിലെ "ചരങ്ങൾ" എന്ന ഭാഗത്തെ "ചരങ്ങളുടെ മൂല്യം" എന്ന ഉപഭാഗം ശ്രദ്ധിച്ച് വായിക്കുക. അവിടെ ചിത്രങ്ങൾ വരച്ച് കാണിച്ചിട്ടുള്ള ഉദാഹരണം നല്ലതുപോലെ മനസ്സിലാക്കുക.
2. പ്രോഗ്രാമിംഗിൽ താങ്കൾക്ക് എക്കാലവും പ്രയോജനപ്പെടുത്താവുന്ന ഒരു ഉപായമാണ് ഇനിപ്പറയുന്നത്. ഭാമടീച്ചറുടെ പ്രോഗ്രാം മനസ്സിലാക്കാനായി, നമുക്കത് കൈകൊണ്ട് പ്രവർത്തിപ്പിച്ച് നോക്കാം.
ഒരു പ്രോഗ്രാമിന്റെ ഓരോ സമയത്തെയും തൽസ്ഥിതി (state) എന്നാൽ അതിലെ ചരങ്ങളുടെ അപ്പോഴുള്ള വിലകൾ, പ്രോഗ്രാമിലെ ഏത് വരിയാണ് അപ്പോൾ പ്രവർത്തിക്കുന്നത് എന്നിവ ചേർന്നതാണ്. പ്രോഗ്രാം കൈകൊണ്ട് പ്രവർത്തിപ്പിച്ച് നോക്കാനായി നാം ചെയ്യേണ്ടത് ഇത്രമാത്രം: പ്രോഗ്രാമിന്റെ തൽസ്ഥിതി എങ്ങനെയാണ് മാറുന്നത് എന്നത് കടലാസും പേനയും ഉപയോഗിച്ച് നിരീക്ഷിക്കുക. ഭാമടീച്ചറുടെ താങ്കൾ ലിങ്കുചെയ്ത പ്രോഗ്രാമിൽ മൂന്ന് ചരങ്ങളാണുള്ളത് (ഏതൊക്കെയാണിവ?). മൂന്ന് കോളമുള്ള ഒരു പട്ടിക വരയ്ക്കുക: അല്പം അകലമിട്ട് കുത്തനെ രണ്ടു വര വരച്ചാൽ മതിയാകും. ഈ മൂന്ന് കോളങ്ങൾക്ക് ചരങ്ങളുടെ പേരുകൾ കൊടുക്കുക. ഇപ്പോൾ ചരങ്ങളുടെ വിലകൾ ഓർത്തുവയ്ക്കാനുള്ള സ്ഥലമായി. ഇനി പ്രോഗ്രാമിന്റെ തൽസ്ഥിതി സമയം പോകുന്തോറും എങ്ങനെയാണ് മാറുന്നത് എന്ന് നോക്കാം. പ്രോഗ്രാമിന്റെ ആദ്യത്തെ വരിയിൽ n എന്ന ചരത്തിലേക്ക് ഇൻപുട്ട് എടുക്കുകയാണല്ലോ. ഇവിടെ n-ന് വിലയായി 6 എന്ന സംഖ്യയാണ് കിട്ടിയതെന്ന് കരുതുക. പട്ടികയിൽ n എന്ന കോളത്തിൽ 6 എന്ന് എഴുതുക. പ്രോഗ്രാമിന്റെ അടുത്ത വരിയിൽ sum എന്ന ചരത്തിന് 0 എന്ന വില കൊടുക്കുന്നു. നമ്മുടെ പട്ടികയിലും sum-ന് ഈ വില കൊടുക്കുക. ഇനിയുള്ള for എത്ര തവണ ആവർത്തിക്കും?ത്ക് ഓരോ തവണ ആവർത്തിക്കുന്പോഴും ഒരു ചരത്തിന്റെ വില നിശ്ചയമായും മാറും (ഏതാണിത്?). മറ്റൊരു ചരത്തിന്റെ വിലയും മാറാം. നമ്മുടെ പട്ടികയിൽ ഇതനുസരിച്ച് പല തവണയായി മാറ്റങ്ങൾ വരുത്തുക. for-ന്റെ പ്രവർത്തനം അവസാനിക്കുന്പോഴേക്കും നമുക്ക് വേണ്ട ഉത്തരം sum എന്ന ചരത്തിൽ വരുന്നുണ്ടോ?
പ്രോഗ്രാം പ്രവർത്തിപ്പിച്ചപ്പോൾ sum എന്ന ചരത്തിന്റെ വില എങ്ങനെയൊക്കെയാണ് മാറിയത് എന്ന് നോക്കുക. ഇതിൽനിന്ന് sum-ന് ഒരു "അർത്ഥം" കൊടുക്കാൻ കഴിയുന്നുണ്ടോ? ഏത് വിവരണമാണ് sum-ന് യോജിക്കുക? ഇത് മനസ്സിലാക്കാനായി, n-ന് മറ്റ് വിലകൾ (ഉദാ: 7, 8, 9, 10) കൊടുത്തും പ്രോഗ്രാം കൈകൊണ്ട് പ്രവർത്തിപ്പിച്ച് നോക്കുക.
ഇവിടെ വളരെയധികം ശ്രദ്ധിക്കേണ്ട ഒരു കാര്യം: പ്രോഗ്രാമിൽ പറയുന്നതെന്തോ, അതാണ് കടലാസിലും ചെയ്യേണ്ടത്; മറിച്ച് പ്രോഗ്രാം ചെയ്യേണ്ടതെന്താണെന്ന് നമുക്ക് തോന്നുന്ന കാര്യം അല്ല ചെയ്യേണ്ടത്. ഇത് എടുത്തുപറയേണ്ടതില്ലെന്ന് തോന്നാം, പക്ഷേ പലർക്കും ഇത് ചെയ്യാനുള്ള അച്ചടക്കം സ്വതവേ ഉണ്ടാവാറില്ല. പരിശീലനം കൊണ്ട് നേടിയെടുക്കേണ്ടതാണിത്.
ഇത്രയും ചെയ്തുകഴിയുന്പോൾ താങ്കളുടെ ചോദ്യത്തിന് ഉത്തരം കിട്ടേണ്ടതാണ്. ഇല്ലെങ്കിൽ ചോദിക്കാൻ മടിക്കരുത്.
ഫിലിപ്പ് സാർ,
താങ്കൾ പറഞ്ഞതു പോലെ പാഠങ്ങൾ ഒരാവർത്തികൂടി വായിക്കുന്നതിനു പകരം ഞാൻ ടീച്ചറുടെ പ്രോഗ്രാം എന്റെ മനസ്സിന്റെ കമ്പൈലറിൽ കമ്പൈൽ ചെയ്തു. തനി മലയാളഭാഷയിൽ തന്നെ. അദ്ഭുതം ..! എനിക്കു മുൻപിൽ അതിന്റെ വ്യാകരണം തെളിഞ്ഞു വന്നു. ഞാൻ ചിന്തിച്ച രീതി ഇവിടെക്കൊടുക്കുന്നു. ദൈർഘ്യം കൂടിയെങ്കിൽ ക്ഷമിക്കുക.
1- യൂസറിൽ നിന്ന് ഇൻപുട്ട് സ്വീകരിക്കുന്നു, എന്നിട്ട് ആ ഇൻപുട്ടിനെ n എന്ന വേരിയബിളിൽ സൂക്ഷിക്കുന്നു.
2- ശൂന്യം
3- sum എന്ന വേരിയബിളിന് 0 എന്ന വില നൽകുന്നു.
4- number എന്ന വേരിയബിളിൽ, ഒന്നിനും n നും ഇടയ്ക്കുള്ള സംഖ്യകൾ സൂക്ഷിക്കുന്നു.
5- number എന്ന വേരിയബിളിനെ മൂന്നു കൊണ്ട് ഹരിച്ചാൽ ശിഷ്ടം പൂജ്യമെങ്കിലോ അല്ലെങ്കിൽ number എന്ന വേരിയബിളിനെ അഞ്ചു കൊണ്ട് ഹരിച്ചാൽ ശിഷ്ടം പൂജ്യമെങ്കിലോ
6- sum എന്ന വേരിയബിളിന്റെ വില = sum + 1 അതായത് 0 + 1
7- പ്രിന്റ് ചെയ്യാൻ തന്നിരിക്കുന്ന നിർദ്ദേശങ്ങൾ പ്രിന്റ് ചെയ്യുക.
ഇപ്രകാരം ഈ പ്രോഗ്രാം പ്രവർത്തിക്കുമ്പോൾ യൂസർ 6 എന്ന ഇൻപുട്ട് കൊടുക്കുന്നു എങ്കിൽ
n ന്റെ വില 6 ആകുന്നു.
sum ന്റെ വില 0 ആകുന്നു.
number ന്റെ വില (1,2,3,4,5) ആകുന്നു.
number=1 എന്നു പരിഗണിച്ചാൽ
1 നെ മൂന്നു കൊണ്ട് ഹരിച്ചാൽ ശിഷ്ടം 0 ആണോ എന്നു നോക്കുന്നു.
1 നെ 5 കൊണ്ട് ഹരിച്ചാൽ ശിഷ്ടം 0 ആണോ എന്ന് നോക്കുന്നു.
ശിഷ്ടം പൂജ്യം ആണെങ്കിൽ
sum(ഇപ്പോൾ 0) = sum + 1 അതായത് 0 + 1 = 1
പ്രോഗ്രാം സ്റ്റെപ് നമ്പർ നാലിലേയ്ക്ക് പോകുന്നു. ഇപ്പോളും sum ന്റെ വില=0
number = 2 എന്നു പരിഗണിക്കുന്നു.
2 നെ മൂന്നു കൊണ്ട് ഹരിച്ചാൽ ശിഷ്ടം 0 ആണോ എന്നു നോക്കുന്നു.
2 നെ 5 കൊണ്ട് ഹരിച്ചാൽ ശിഷ്ടം 0 ആണോ എന്ന് നോക്കുന്നു.
ശിഷ്ടം പൂജ്യം ആണെങ്കിൽ
sum(ഇപ്പോൾ 0) = sum + 1 അതായത് 0 + 1 =1
പ്രോഗ്രാം വീണ്ടും സ്റ്റെപ് നമ്പർ നാലിലേയ്ക്ക് പോകുന്നു. ഇപ്പോളും sum ന്റെ വില = 0
number =3 എന്നു പരിഗണിക്കുന്നു.
3 നെ മൂന്നു കൊണ്ട് ഹരിച്ചാൽ ശിഷ്ടം 0 ആണോ എന്നു നോക്കുന്നു.
3 നെ 5 കൊണ്ട് ഹരിച്ചാൽ ശിഷ്ടം 0 ആണോ എന്ന് നോക്കുന്നു.
രണ്ട് പരിശോധനകളിൽ ഒന്ന് ശരിയായതിനാൽ If സ്റ്റേറ്റ്മെന്റ് ട്രൂ ആകുന്നു.
sum (ഇപ്പോൾ 0) = 0 + 1 = 1 ആകുന്നു
പ്രോഗ്രാം വീണ്ടും സ്റ്റെപ് നമ്പർ നാലിലേയ്ക്ക് പോകുന്നു. ഇപ്പോൾ sum ന്റെ വില = 1
അവസാനം 5 എന്ന അവസാന ലിസ്റ്റ് അംഗത്തെ പരിഗണിക്കുന്നു.
അതായത് number = 5
5 നെ മൂന്നു കൊണ്ട് ഹരിച്ചാൽ ശിഷ്ടം 0 ആണോ എന്നു നോക്കുന്നു.
5 നെ 5 കൊണ്ട് ഹരിച്ചാൽ ശിഷ്ടം 0 ആണോ എന്ന് നോക്കുന്നു.
രണ്ട് പരിശോധനകളിൽ ഒന്ന് ശരിയായതിനാൽ If സ്റ്റേറ്റ്മെന്റ് ട്രൂ ആകുന്നു.
sum (ഇപ്പോൾ 1) = 1 + 1 = 2 ആകുന്നു
ഇനി ലിസ്റ്റിൽ അംഗങ്ങൾ ഇല്ലാത്തതിനാൽ പ്രോഗ്രാം for ലൂപ്പിൽ നിന്ന് പുറത്ത് കടക്കുന്നു.
പ്രിന്റ് ചെയ്യാൻ പറഞ്ഞിരിക്കുന്ന കാര്യങ്ങൾ പ്രിന്റ് ചെയ്യുന്നു. അക്കൂട്ടത്തിൽ sum ന്റെ ഇപ്പോളത്തെ വിലയായ 2 എന്ന സംഖ്യയും പെടുന്നു.
എന്റെ ലോജിക് ശരിയായോ..?
ശ്രീ വിനോദ്,
താങ്കളുടെ ലോജിക് പൊതുവേ ശരിയാണ്. എന്നാൽ:
4- number എന്ന വേരിയബിളിൽ, ഒന്നിനും n നും ഇടയ്ക്കുള്ള സംഖ്യകൾ സൂക്ഷിക്കുന്നു.
എന്ന് കരുതുന്നതിന് പകരം,
4 - number എന്ന ചരത്തിന് 1 മുതൽ (n - 1) വരെയുള്ള എണ്ണൽ സംഖ്യകൾ ഓരോന്നായി വിലയായി കൊടുത്ത്, 5-6 വരികൾ പ്രവർത്തിപ്പിക്കുന്നു.
എന്ന് കരുതുന്നതാണ് കൂടുതൽ ശരി. for-ന് ഒരു ആവർത്തന സ്വഭാവം ഉണ്ട്. number എന്ന ചരത്തിന് വിലകൾ ഓരോന്നായാണ് കൊടുക്കുന്നത്. range() എന്ന ഏകദത്തിന്റെ ഔട്പുട്ട് എങ്ങനെയാണെന്നതിലെ സൂക്ഷ്മമായ വ്യത്യാസവും ശ്രദ്ധിക്കുക.
താങ്കൾ എന്റെ ഒരു ചോദ്യത്തിന്റെ ഉത്തരം പറഞ്ഞില്ല: sum-ന് ഒരു "അർത്ഥം" കൊടുക്കാൻ കഴിയുന്നുണ്ടോ? ഏത് വിവരണമാണ് sum-ന് യോജിക്കുക?
ക്ഷമിക്കണം, sum ന് എന്ത് അർത്ഥം കല്പിക്കണം എന്ന് എനിക്ക് തെളിഞ്ഞു കിട്ടുന്നില്ല. for ന്റെ പ്രവർത്തനങ്ങൾ എണ്ണുന്ന ഒരു കാഴ്ചക്കാരൻ എന്നു വേണമെങ്കിൽ പറയാം.
"ഇതുവരെ കണ്ടുകഴിഞ്ഞ എണ്ണൽസംഖ്യകളെ അടിസ്ഥാനപ്പെടുത്തിയുള്ള ഭാഗികമായ ഉത്തരം" എന്ന് sum-നെ വിളിക്കാം.
ഇൻപുട് സീകരിച്ചുകഴിഞ്ഞ ഉടനെ എണ്ണൽസംഖ്യകൾ ഒന്നും പ്രോഗ്രാം കണ്ടിട്ടില്ല. അതുകൊണ്ട് ഈ ഭാഗികമായ ഉത്തരം പൂജ്യം (പൂജ്യം എണ്ണം എണ്ണൽസംഖ്യകളുടെ തുക പൂജ്യം).
ഓരോ തവണ for-ന്റെ ഉള്ളടക്കം (5, 6 വരികൾ) ചെയ്തുകഴിയുന്പോഴും പുതിയ ഒരു എണ്ണൽസംഖ്യയെക്കൂടി നമ്മുടെ പ്രോഗ്രാം കണ്ടുകഴിഞ്ഞു. 6-ആം വരിയിൽ ഇതനുസരിച്ച് ഭാഗികമായ ഉത്തരം തിരുത്തുന്നു.
for മൊത്തമായി ചെയ്ത് കഴിയുന്പോഴേക്കും (നമുക്കുവേണ്ട) എല്ലാ എണ്ണൽസംഖ്യകളെയും കണ്ടുകഴിഞ്ഞു. ഓരോ പുതിയ എണ്ണൽസംഖ്യയെയും കാണുന്പോൾ sum ശരിയായ രീതിയിൽ തിരുത്തിയതു കാരണം, എല്ലാ സംഖ്യകളെയും കണ്ടുകഴിയുന്പോഴേക്കും sum-ന്റെ വില നമുക്കുവേണ്ട ഉത്തരം തന്നെയാണ്.
പ്രോഗ്രാമിലെ ചരങ്ങളും അവയ്ക്ക് വരുത്തുന്ന മാറ്റങ്ങളും മറ്റും ഒരുതരം "മാജിക്" ആയി കാണുന്നത് നമ്മുടെ പഠനത്തെ ബാധിക്കും. പകരം ഇത്തരം അർത്ഥം കൊടുത്താൽ എളുപ്പം മനസ്സിലാകും. പുതിയ ഒരു ചോദ്യത്തിന് ഉത്തരമായി പ്രോഗ്രാം എഴുതുന്പോൾ, ആ ചോദ്യം നാം തനിയെ കടലാസും പേനയും ഉപയോഗിച്ച് എങ്ങനെയാണ് ചെയ്യുന്നത് എന്ന് ആലോചിച്ചാൽ പ്രോഗ്രാമിനെക്കൊണ്ട് എങ്ങനെയാണ് അത് ചെയ്യിക്കേണ്ടതെന്ന് മനസ്സിലാകും. ഉദാഹരണത്തിന്: അഞ്ചാം പ്രവർത്തനത്തിന് ഇൻപുട്ട് ആയി ചെറുതല്ലാത്ത (നൂറുകണക്കായ) ഒരു സംഖ്യ കിട്ടിയാൽ കടലാസും പേനയും ഉപയോഗിച്ച് ഈ പ്രശ്നം എങ്ങനെ ചെയ്യും എന്ന് ആലോചിക്കുക. ആ ചെയ്യുന്നതും ടീച്ചറുടെ പ്രോഗ്രാമിൽ ഉപയോഗിച്ചിരിക്കുന്ന ചരങ്ങളും തമ്മിൽ ബന്ധമുണ്ടോ?
(ഭാമ ടീച്ചറുടെ പ്രോഗ്രാം ശരിയായ ഉത്തരമാണ് തരുന്നത് എന്നതിനുള്ള ഒരു തെളിവു (proof) കൂടിയാണ് മുകളിൽ പറഞ്ഞത്.)
ശരിയാണ് സർ.
അതിരിക്കട്ടെ, GUI നിർമ്മിക്കുന്നതും Button,Textbox, MsgBox, Menu എന്നിവ നിർമ്മിക്കുന്നതും പരിചയപ്പെടുത്തുകയില്ലേ..?
ഇല്ല. പ്രോഗ്രാമിംഗ് ബാലപാഠങ്ങൾ മാത്രമാണ് ഇതുകൊണ്ട് ഉദ്ദേശിക്കുന്നത്.
നന്ദി.
Post a Comment