പൈത്തണിന്റെ ലോകത്തേക്ക് വായനക്കാര്‍ക്ക് സുസ്വാഗതം. പൈത്തണ്‍ എന്ന പ്രോഗ്രാമിങ്ങ് ലാങ്ഗ്വേജ് പഠിപ്പിക്കാനുള്ള ശ്രമമാണിവിടെ. ആരംഭം മുതലുള്ള പോസ്റ്റുകളുടെ ലിങ്കുകള്‍ ഇടതു വശത്തു കാണാം. ആര്‍ക്കും പഠിക്കാം. ആര്‍ക്കും സംശയങ്ങള്‍ ചോദിക്കാം. വിലക്കുകളോ മോഡറേഷനുകളോ ഇല്ല.

പൈത്തണ്‍ : പാഠം ഏഴ്

>> Thursday, April 7, 2011

ആമുഖം

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

ഘടകങ്ങളും പൊതുഘടകങ്ങളും


കഴിഞ്ഞ പാഠത്തില്‍ ഘടകങ്ങളെ പരിചയപ്പെട്ടത് മറന്നുപോയെങ്കില്‍: 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-നെ അതിനോടുതന്നെ പല പ്രാവശ്യം കൂട്ടി ഏത് എണ്ണല്‍സംഖ്യയിലും എത്തിക്കാം; ഏത് എണ്ണല്‍സംഖ്യയും "ഒരു പ്രാവശ്യം കൂട്ടിയാല്‍" ആ സംഖ്യതന്നെയാണുതാനും.

രണ്ട് സംഖ്യകള്‍ക്ക് പൊതുവായുള്ള ഘടകങ്ങളെ അവയുടെ പൊതുഘടകങ്ങള്‍ (common factors) എന്ന് വിളിക്കുന്നു. ഏതു രണ്ട് എണ്ണല്‍സംഖ്യകളെടുത്താലും അവയ്ക്ക് പൊതുവായി ഒരു ഘടകമെങ്കിലും ഉണ്ടാവും (എന്തുകൊണ്ട്?). ചില സംഖ്യാജോടികള്‍ക്ക് ഏറെ പൊതുഘടകങ്ങള്‍ കാണും. മറ്റു ചിലവയ്ക്ക് വളരെ കുറച്ച് പൊതുഘടകങ്ങളേ കാണൂ. ചില ഉദാഹരണങ്ങള്‍ ഇതാ:



പൊതു ഘടകങ്ങള്‍
ആദ്യത്തെ സംഖ്യരണ്ടാമത്തെ സംഖ്യ ആദ്യത്തെ സംഖ്യയുടെ ഘടകങ്ങള്‍ രണ്ടാമത്തെ സംഖ്യയുടെ ഘടകങ്ങള്‍ പൊതു ഘടകങ്ങള്‍
36161, 2, 3, 4, 6, 9, 12, 18, 361, 2, 4, 8, 161, 2, 4
78241, 2, 3, 6, 13, 26, 39, 781, 2, 3, 4, 6, 8, 12, 241, 2, 3, 6
120355811, 2, 3, 4, 5, 6, 8, 10, 12, 15, 20, 24, 30, 40, 60, 1201, 7, 13, 17, 23, 91, 119, 161, 221, 299, 391, 1547, 2093, 2737, 5083, 355811
482101, 2, 3, 4, 6, 8, 12, 16, 24, 481, 2, 3, 5, 6, 7, 10, 14, 15, 21, 30, 35, 42, 70, 105, 2101, 2, 3, 6
4022451, 2, 3, 6, 67, 134, 201, 4021, 5, 7, 35, 49, 2451


ലിസ്റ്റുകളെപ്പറ്റി രണ്ടുകാര്യങ്ങള്‍


കഴിഞ്ഞ പാഠത്തില്‍ for, range() എന്നിവയോടനുബന്ധിച്ച് നാം ലിസ്റ്റുകളെ പരിചയപ്പെട്ടിരുന്നല്ലോ? അവിടെ സൂചിപ്പിച്ചതുപോലെ പൈത്തണ്‍ ഉപയോഗിച്ച് പ്രോഗ്രാമുകള്‍ എഴുതുമ്പോള്‍ വളരെയധികം ഉപയോഗപ്പെടുന്ന ഒന്നാണ് ലിസ്റ്റ്. ലിസ്റ്റുകളെ കൈകാര്യം ചെയ്യുവാനുള്ള ഒട്ടേറെ ഉപാധികള്‍ പൈത്തണില്‍ ലഭ്യമാണ്. ഇവയില്‍ ലളിതമായ രണ്ട് ഉപാധികളെ ഈ പാഠത്തില്‍ നമുക്ക് പരിചയപ്പെടാം.

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






ലിസ്റ്റിലേക്ക് ആളെക്കൂട്ടുന്ന വഴി മനസ്സിലായല്ലോ? myList എന്ന ലിസ്റ്റിലേക്ക് new_item എന്ന വസ്തു ചേര്‍ക്കാനായി myList.append(new_item) എന്ന് പ്രയോഗിക്കുക. ഇവിടെ new_item എന്നത് 5, "name" എന്നിങ്ങനെയുള്ള മൂല്യങ്ങളോ number, name എന്നിങ്ങനെ ചരങ്ങളോ ആകാം; ചരമാണെങ്കില്‍ അതിന്റെ വിലയാവും ലിസ്റ്റില്‍ കയറിക്കൂടുന്നത്.

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

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


ഒരു ലിസ്റ്റിന്റെ നീളം (അതില്‍ എത്ര അംഗങ്ങള്‍ ഉണ്ടെന്നുള്ളത്) കാണാനുള്ള വിദ്യയാണ് അടുത്തത്. ഇതിനുള്ള ലളിതമായ വഴി പൈത്തണിലെ len() എന്ന ഏകദം ഉപയോഗിക്കുക എന്നതാണ്. ഇത് എങ്ങനെയാണ് ചെയ്യുന്നതെന്ന് താഴെക്കാണുന്ന പ്രോഗ്രാമുകള്‍ പരീക്ഷിച്ചാല്‍ മനസ്സിലാകും.





രണ്ടാമത്തെ പ്രോഗ്രാമില്‍ ഒറ്റസംഖ്യകളുടെ എണ്ണം കാണുക മാത്രം ചെയ്യാന്‍ അവയുടെ ഒരു ലിസ്റ്റ് ഉണ്ടാക്കേണ്ട കാര്യമില്ല എന്നത് ശ്രദ്ധിക്കുക: ഒരു ചരത്തില്‍ ഈ എണ്ണം സൂക്ഷിച്ചാല്‍ മാത്രം മതിയാകും. len() എന്ന ഉപാധിയുടെ പ്രയോഗം ഉദാഹരിക്കാന്‍ മാത്രമാണ് ഇവിടെ odd_numbers എന്ന ലിസ്റ്റ് ഉണ്ടാക്കിയത്.

len() ഉപയോഗിച്ച് ലിസ്റ്റുകളുടെ മാത്രമല്ല, string-കളുടെയും നീളം (string-ല്‍ ഉള്ള സ്പേസും മറ്റു ചിഹ്നങ്ങളും ഉള്‍പ്പടെയുള്ള അക്ഷരങ്ങളുടെ എണ്ണം) കാണാം. പ്രയോഗരീതി മുകളിലത്തേതുപോലെ തന്നെ. ഈ സൗകര്യം ഉപയോഗിച്ച് കേരളത്തിലെ ഏത് ജില്ലയുടെ പേരിനാണ് ഇംഗ്ളീഷില്‍ എഴുതിയാല്‍ ഏറ്റവും നീളം എന്ന് കണ്ടുപിടിക്കുന്ന ഒരു പ്രോഗ്രാം ഇതാ:



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

പ്രവ. 3.
ഈ ഉദാഹരണങ്ങള്‍ മനസ്സിരുത്തി വായിക്കുക. ഇവ പ്രവര്‍ത്തിക്കുന്നത് എങ്ങനെയാണെന്ന് മനസ്സിലായി എന്ന് ഉറപ്പുവരുത്തുക. പ്രത്യേകിച്ച് മൂന്നാമത്തെ ഉദാഹരണത്തിന്റെ 13 മുതല്‍ 19 വരെയുള്ള വരികളില്‍ എന്താണ് സംഭവിക്കുന്നതെന്ന് കൃത്യമായി മനസ്സിലാക്കുക.


ഉത്തമ സാധാരണ ഘടകം


രണ്ട് പൂര്‍ണ്ണസംഖ്യകളുടെ ഏറ്റവും വലിയ പൊതുഘടകത്തെ അവയുടെ ഉത്തമ സാധാരണ ഘടകം (highest common factor, greatest common divisor) എന്ന് വിളിക്കുന്നു: ചുരുക്കത്തില്‍ ഉസാഘ (hcf, gcd) എന്നും. മുകളിലുള്ള പട്ടികയില്‍നിന്ന് നമുക്ക് കിട്ടുന്ന ഉദാഹരണങ്ങള്‍:

  • ഉസാഘ(16, 36) = 4
  • ഉസാഘ(78, 24) = 6
  • ഉസാഘ(120, 35581) = 1
  • ഉസാഘ(210, 48) = 6
  • ഉസാഘ(402, 245) = 1

രണ്ട് പൂര്‍ണ്ണസംഖ്യകള്‍ ഇന്‍പുട് ആയി എടുത്ത് അവയുടെ ഉസാഘ കണ്ടുപിടിക്കുന്ന ഒരു പ്രോഗ്രാം നമുക്ക് എങ്ങനെ എഴുതാം? മുകളിലെ രണ്ടു പ്രവര്‍ത്തനങ്ങളും ചെയ്താല്‍ ഇതിനുള്ള ആശയം കിട്ടും. ലളിതമായ ഒരു രീതി ഇതാ:

  1. ഇന്‍പുട്ട് ആയി കിട്ടിയ സംഖ്യകള്‍ num1, num2 എന്നിവയാണെന്നിരിക്കട്ടെ.
  2. 1 മുതല്‍ num1 വരെയുള്ള ഓരോ സംഖ്യയും ക്രമത്തില്‍ num1, num2 എന്നിവ രണ്ടിനേയും നിശ്ശേഷം ഹരിക്കുന്നുണ്ടോ എന്ന് നോക്കുക.
  3. ഇങ്ങനെ രണ്ടിനേയും ഹരിക്കുന്ന സംഖ്യ കാണുമ്പോള്‍ അത് ഒരു ചരത്തില്‍ (ഇതിനെ നമുക്ക് gcd എന്ന് വിളിക്കാം) സൂക്ഷിച്ചുവെക്കുക.
  4. gcd-ന്റെ അവസാനമുള്ള വിലയാണ് num1, num2 എന്നിവയുടെ ഉസാഘ.
(ഇവിടെ ലിസ്റ്റ് ഉപയോഗിക്കേണ്ട ആവശ്യം ഇല്ല എന്നത് ശ്രദ്ധിക്കുക.)

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

പ്രവ. 4.
രണ്ട് സംഖ്യകളുടെ ഉസാഘ കണ്ടുപിടിക്കാന്‍ മുകളില്‍ കൊടുത്ത രീതി ശരിയാകുന്നത് എന്തുകൊണ്ടാണെന്ന് ആലോചിച്ച് മനസ്സിലാക്കുക.
പ്രവ. 5.
രണ്ട് എണ്ണല്‍സംഖ്യകള്‍ ഇന്‍പുട്ട് ആയി എടുത്ത്, ഈ സംഖ്യകളുടെ ഉസാഘ കണ്ടുപിടിക്കുന്ന പ്രോഗ്രാം മുകളില്‍ കൊടുത്ത രീതിയില്‍ എഴുതുക. പ്രോഗ്രാമിന്റെ പ്രവര്‍ത്തനഫലം താഴെക്കാണുന്ന ചിത്രത്തിലെപ്പോലെ ആയിരിക്കണം (കുറച്ചുകൂടെ വ്യക്തമായ ചിത്രം കാണാന്‍ ഈ ചിത്രത്തില്‍ അമര്‍ത്തുക). ഇവിടെ ഈ പ്രോഗ്രാം നാലു തവണ പ്രവര്‍ത്തിപ്പിച്ചിരിക്കുന്നു (IDLE-ല്‍ F5 നാലു തവണ അമര്‍ത്തിയിരിക്കുന്നു).


യൂക്ളിഡിന്റെ അല്‍ഗോരിതം


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


  1. 287503, 646609
  2. 4143937, 6487923
  3. 55596155, 73187552

ഈ രീതിയുടെ പരിമിതി എന്താണെന്ന് മനസ്സിലായല്ലോ? ഇന്‍പുട് സംഖ്യകള്‍ വലുതാകുന്തോറും പ്രോഗ്രാം പൂര്‍ത്തിയാകാനെടുക്കുന്ന സമയവും ആനുപാതികമായി കൂടുന്നു. (സംഖ്യകളുടെ വലുപ്പം കുറച്ച് കൂടുമ്പോഴേക്കും ചിലപ്പോള്‍ കംപ്യൂട്ടര്‍ നിശ്ചലമായി എന്നും വരാം; ഇത് നാം ഉപയോഗിക്കുന്ന range() എന്ന ഏകദത്തിന്റെ പ്രവര്‍ത്തനരീതി കാരണമാണ്. range()-നു പകരം xrange() എന്ന് പ്രയോഗിച്ചാല്‍ ഈ പ്രശ്നം ഒഴിവാക്കാം. ഇപ്പോള്‍ കൂടുതല്‍ വിശദീകരിക്കുന്നില്ല.). ഇതു തന്നെയാണ് ഈ രീതിയുടെ വലിയ പരിമിതിയും. കുറച്ചൊന്നാലോചിച്ചാല്‍ ഇങ്ങനെ സംഭവിക്കുന്നത് എന്തുകൊണ്ടാണെന്ന് നമുക്ക് മനസ്സിലാക്കാം. തന്നിരിക്കുന്ന സംഖ്യകളിലൊന്നിന്റെ ഓരോ ഘടകത്തിനെക്കൊണ്ടും മറ്റേ സംഖ്യയെ ഹരിച്ചുനോക്കുക എന്നതാണല്ലോ ഇവിടെ ചെയ്യുന്നത്? ഇതിനായി ഒന്നു മുതല്‍ ആദ്യത്തെ സംഖ്യ വരെയുള്ള എല്ലാ സംഖ്യകളെക്കൊണ്ടും ആദ്യത്തെ സംഖ്യയെ ഹരിച്ചു നോക്കുന്നു. ആദ്യത്തെ സംഖ്യ വലുതാകുന്തോറും പ്രോഗ്രാം പ്രവര്‍ത്തിക്കാനെടുക്കുന്ന സമയം ആനുപാതികമായി കൂടുന്നത് ഇതുകൊണ്ടാണ്.

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

ഇതിലും മികച്ച — താരതമ്യേന വളരെ കുറച്ച് സമയം മാത്രമെടുക്കുന്ന — രീതികള്‍ നിലവിലുണ്ട് എന്നതാണ് അത്ഭുതകരമായ വസ്തുത. ഇവയില്‍ ഏറ്റവും പ്രശസ്തമായ രീതിക്ക് രണ്ടായിരത്തിമുന്നൂറിലേറെ വര്‍ഷം പഴക്കമുണ്ട് എന്നതും അത്ഭുതകരം തന്നെ. ബി. സി. 300-നോടടുപ്പിച്ച് എഴുതപ്പെട്ട യുക്ളിഡിന്റെ 'എലമെന്റ്സ്' എന്ന പുസ്തകസഞ്ചയത്തില്‍ രണ്ട് സംഖ്യകളുടെ ഉസാഘ കണ്ടുപിടിക്കാനുള്ള മനോഹരമായ ഒരു രീതി വിവരിച്ചിട്ടുണ്ട്. "യൂക്ളിഡിന്റെ അല്‍ഗോരിതം" എന്ന പേരില്‍ ഈ രീതി പ്രശസ്തമാണ്. "അല്‍ഗോരിതം" എന്നതിന് "പ്രശ്നപരിഹാരത്തിനുള്ള വഴി" എന്ന് ഏകദേശം അര്‍ത്ഥം പറയാം. ഇനി നമുക്ക് യൂക്ളിഡിന്റെ അല്‍ഗോരിതം എന്താണെന്ന് മനസ്സിലാക്കാന്‍ ശ്രമിക്കാം.

യൂക്ളിഡിന്റെ അല്‍ഗോരിതത്തിന്റെ അടിസ്ഥാനം ഇതാണ്: a, b എന്നീ പൂര്‍ണ്ണസംഖ്യകളുടെ ഉസാഘ കണ്ടുപിടിക്കണമെന്ന് കരുതുക.


  1. a = b ആണെങ്കില്‍ ഉസാഘ (a, b) = a. (എന്തുകൊണ്ട്?)
  2. ഇനി a < b ആണെന്ന് കരുതുക (b < a ആണെങ്കില്‍ ഇനിയുള്ള വാദങ്ങളില്‍ aയും bയും തലതിരിച്ചിട്ടാല്‍ മതി.).
  3. b-യെ a കൊണ്ട് ഹരിച്ചാല്‍ ശിഷ്ടം പൂജ്യമാണെങ്കില്‍ ഉസാഘ (a, b) = a. (എന്തുകൊണ്ട്?)
  4. b-യെ a കൊണ്ട് ഹരിച്ചാല്‍ ശിഷ്ടം r എന്ന അധിസംഖ്യയാണെന്ന് കരുതുക. ഇങ്ങനെയാണെങ്കില്‍ ഉസാഘ(a, b) = ഉസാഘ(r, a).


ഇവയില്‍ ആദ്യത്തെ രണ്ട് കാര്യങ്ങളും ശരിയാണെന്ന് കാണാന്‍ വലിയ പ്രയാസമില്ല (ആലോചിച്ചുനോക്കൂ). മൂന്നാമത്തെ കാര്യം ശരിയാണോ എന്നത് ഒറ്റനോട്ടത്തില്‍ വ്യക്തമല്ല. ഇത് എന്തുകൊണ്ട് ശരിയാകുന്നു എന്ന് നമുക്കൊന്നു നോക്കാം.

മൂന്നാമത്തെ പിരിവില്‍ b-യെ a കൊണ്ട് ഹരിച്ചാല്‍ ശിഷ്ടം r എന്ന അധിസംഖ്യയാണല്ലോ? അപ്പോള്‍ b = ma + r എന്ന് എഴുതാന്‍ കഴിയുന്ന m എന്ന ഒരു അധിസംഖ്യ നിലവിലുണ്ട് : b-യെ a കൊണ്ട് ഹരിച്ചാല്‍ കിട്ടുന്ന ഉത്തരത്തിന്റെ പൂര്‍ണ്ണസംഖ്യാഭാഗമാണ് m. ഈ സമവാക്യത്തെ നമുക്ക് r = b - ma എന്നൊന്ന് മാറ്റി എഴുതാം.

a, b എന്നിവ രണ്ടിന്റേയും ഘടകമാണ് f എന്ന് കരുതുക. അപ്പോള്‍ a = pf, b = qf എന്നിങ്ങനെ എഴുതാവുന്ന p,q എന്ന രണ്ട് അധിസംഖ്യകള്‍ ഉണ്ട്. അതുകൊണ്ട് r = b - ma = qf - mpf = f(q - mp). ഇതില്‍നിന്ന് f എന്നത് r-ന്റെയും ഘടകമാണ് എന്ന് കിട്ടുന്നു. അതുകൊണ്ട് r, a എന്നിവ രണ്ടിന്റേയും ഘടകമാണ് f എന്ന് വരുന്നു.

ഇനി r, a എന്നിവ രണ്ടിന്റേയും ഘടകമാണ് g എന്ന് കരുതുക. അപ്പോള്‍ r = sg, a = tg എന്നിങ്ങനെ എഴുതാവുന്ന s,t എന്ന രണ്ട് അധിസംഖ്യകള്‍ ഉണ്ട്. അതുകൊണ്ട് b = ma + r = mtg + sg = g (mt + s). ഇതില്‍നിന്ന് g എന്നത് b-യുടെയും ഘടകമാണ് എന്ന് കിട്ടുന്നു. അതുകൊണ്ട് a,b എന്നിവ രണ്ടിന്റേയും ഘടകമാണ് g എന്ന് വരുന്നു.

ഇപ്പറഞ്ഞതില്‍നിന്ന് നമുക്ക് കിട്ടുന്നത്: a, b എന്നിവയുടെ ഏത് പൊതുഘടകവും r, a എന്നിവയുടെകൂടി പൊതുഘടകമാണ്. മറിച്ച് r, a എന്നിവയുടെ ഏത് പൊതുഘടകവും a, b എന്നിവയുടെ പൊതുഘടകവുമാണ്. അതുകൊണ്ട് a, b എന്നിവയുടെ പൊതുഘടകങ്ങള്‍ തന്നെയാണ് r, a എന്നിവയുടെ പൊതുഘടകങ്ങളും. a, b എന്നിവയുടെ ഏറ്റവും വലിയ പൊതുഘടകവും r, a എന്നിവയുടെ ഏറ്റവും വലിയ പൊതുഘടകവും ഒന്നുതന്നെയാണെന്ന് ഇതില്‍നിന്ന് വ്യക്തം. അതായത് ഉസാഘ(a,b) = ഉസാഘ(r, a).

അപ്പോള്‍ മുകളിലുള്ള മൂന്നാമത്തെ പിരിവും ശരിയാണ്. യൂക്ളിഡിന്റെ അല്‍ഗോരിതവും ഇതുതന്നെയാണ്: a, b എന്നീ സംഖ്യകളുടെ ഉസാഘ കാണാന്‍:


യൂക്ളിഡിന്റെ അല്‍ഗോരിതം

  1. a = b ആണെങ്കില്‍ ഉസാഘ(a, b) = a
  2. a < b എങ്കില്‍: b-യെ a കൊണ്ട് ഹരിച്ചാല്‍ കിട്ടുന്ന ശിഷ്ടം കണ്ടുപിടിക്കുക. ഇത് r ആണെന്നിരിക്കട്ടെ.
    1. r = 0 ആണെങ്കില്‍ ഉസാഘ(a, b) = a
    2. അല്ലെങ്കില്‍ r, a എന്നിവയുടെ ഉസാഘ കണ്ടുപിടിക്കുക; ഇതുതന്നെയാണ് a, b എന്നിവയുടെ ഉസാഘ.
  3. അതല്ല a > b ആണെങ്കില്‍: a-യെ b കൊണ്ട് ഹരിച്ചാല്‍ കിട്ടുന്ന ശിഷ്ടം കണ്ടുപിടിക്കുക. ഇത് r ആണെന്നിരിക്കട്ടെ.
    1. r = 0 ആണെങ്കില്‍ ഉസാഘ(a, b) = b
    2. അല്ലെങ്കില്‍ r, b എന്നിവയുടെ ഉസാഘ കണ്ടുപിടിക്കുക; ഇതുതന്നെയാണ് a, b എന്നിവയുടെ ഉസാഘ.

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

    പ്രവ. 5.
    യൂക്ളിഡിന്റെ അല്‍ഗോരിതം മനസ്സിരുത്തി വായിക്കുക. ഇതിന്റെ പ്രവര്‍ത്തനരീതി മനസ്സിലായി എന്ന് ഉറപ്പുവരുത്താന്‍:
    1. a, b എന്നിവയ്ക്ക് പല വിലകള്‍ കൊടുത്ത് ഈ രീതിയില്‍ (കടലാസും പേനയും ഉപയോഗിച്ച്) അവയുടെ ഉസാഘ കാണുക.
    2. ഈ പാഠഭാഗത്തിന്റെ ആദ്യം കാണുന്ന മൂന്ന് ജോടി സംഖ്യകളുടെ ഉസാഘയും ഈ രീതി ഉപയോഗിച്ച് കണ്ടുപിടിക്കുക. മൂന്നാമത്തെ ജോടിയുടെ ഉസാഘ കണ്ടുപിടിക്കാന്‍ നിങ്ങളെടുത്ത സമയം കംപ്യൂട്ടര്‍ ഇതു ചെയ്യാന്‍ എടുത്ത സമയവുമായി താരതമ്യം ചെയ്യുക.
    3. വളരെ വലിയ സംഖ്യകള്‍ (ഉദാ: പത്തക്ക സംഖ്യകള്‍) ഉള്‍പ്പെടുന്ന ഒരു ഉദാഹരണമെങ്കിലും യൂക്ളിഡിന്റെ രീതി ഉപയോഗിച്ച് ചെയ്തു നോക്കുക.

    യൂക്ളിഡിന്റെ അല്‍ഗോരിതത്തെക്കുറിച്ച് ന്യായമായി ഉണ്ടാകാവുന്ന ചില സംശയങ്ങള്‍:


    1. ഈ രീതിയില്‍ ഉസാഘ കണ്ടുപിടിക്കാന്‍ നോക്കിയാല്‍ അത് എപ്പോഴെങ്കിലും അവസാനിക്കുമെന്ന് എന്താണുറപ്പ്? ചില ജോടി സംഖ്യകള്‍ക്ക് ഇത് അനന്തമായി നീണ്ടുപോയെങ്കിലോ?
    2. ഈ രീതി ശരിയാണോ? ഏതു ജോടി പൂര്‍ണ്ണസംഖ്യകളുടെ ഉസാഘയും ഇതുവഴി കിട്ടുമോ?
    3. നാം ഇതിനുമുമ്പ് കണ്ട ലളിതമായ രീതിയെക്കാള്‍ വളരെ വേഗത്തില്‍ യൂക്ളിഡിന്റെ രീതി ഉത്തരം തരുമോ?

    ആദ്യത്തെ സംശയത്തിന് പ്രധാന കാരണം ഇതാകാം: ഒരു ജോടി സംഖ്യകളുടെ ഉസാഘ കണ്ടുപിടിക്കാന്‍വേണ്ടി നാം മറ്റൊരു ജോടി സംഖ്യകളുടെ ഉസാഘ കണ്ടുപിടിക്കേണ്ടി വരുന്നു. ഇത് ഇങ്ങനെ അനന്തമായി നീണ്ടുപോയാലോ? ഇങ്ങനെ നീണ്ടുപോകില്ല എന്ന് കാണാന്‍ ഒരു കാര്യം ശ്രദ്ധിച്ചാല്‍ മതി: രണ്ടാമത്തെ ജോടിയിലെ ഒരു സംഖ്യ (r) ആദ്യത്തെ ജോടിയിലെ രണ്ടു സംഖ്യകളെക്കാളും ചെറുതാണ് (എന്തുകൊണ്ട്?). എല്ലാ സംഖ്യകളും അധിസംഖ്യകളുമാണ്. അധിസംഖ്യകളുടെ കുറഞ്ഞുവരുന്ന ഒരു ശ്രേണി അനന്തമായി നീളുകയില്ലല്ലോ? അതുകൊണ്ടുതന്നെ ഈ രീതിയുടെ പ്രവര്‍ത്തനവും അനന്തമായി നീളുകയില്ല.

    രണ്ടാമത്തെ സംശയത്തിന്റെ ഉത്തരം നാം മുകളില്‍ കണ്ടുകഴിഞ്ഞു: ഏത് ജോടി പൂര്‍ണ്ണസംഖ്യകളുടെയും ഉസാഘ ഈ രീതിയില്‍ കണ്ടുപിടിക്കാനാകും.

    ഈ രീതിയുടെ വേഗത്തെപ്പറ്റി ഒരു ഏകദേശ രൂപം കിട്ടാന്‍ പ്രവര്‍ത്തനം 5 സഹായിക്കും. ഇതുകൂടാതെ നാം പൈത്തണില്‍ ഈ രീതി എഴുതി പ്രവര്‍ത്തിപ്പിച്ച് നോക്കുമ്പോഴും ഇത് നമുക്ക് കൂടുതല്‍ ബോധ്യം വരും. യൂക്ളിഡിന്റെ അല്‍ഗോരിതം ഉസാഘ കണ്ടുപിടിക്കാനായി എത്ര സമയം വരെ എടുക്കാം എന്നതിന് (ഈ സമയം ഇന്‍പുട്ട് ആയി കിട്ടുന്ന സംഖ്യകളെ ആശ്രയിച്ചിരിക്കുന്നു എന്ന് വ്യക്തമാണല്ലോ?) കൃത്യമായ കണക്കുകളുണ്ട്. ഇവിടെ ഇതിനെപ്പറ്റി കൂടുതല്‍ വിശദീകരിക്കുന്നില്ല; ഈ സമയപരിധി ഫിബോനാച്ചി സംഖ്യകളുമായി നേരിട്ട് ബന്ധപ്പെട്ടിരിക്കുന്നു എന്ന അതിശയകരമായ കാര്യം മാത്രം സൂചിപ്പിക്കുന്നു.





    യൂക്ളിഡിന്റെ അല്‍ഗോരിതം : പൈത്തണില്‍


    ഇനി നമുക്ക് യൂക്ളിഡിന്റെ അല്‍ഗോരിതം പൈത്തണിലേക്ക് മൊഴിമാറ്റം നടത്താന്‍ ശ്രമിക്കാം. ഇതിന് ഒരു തുടക്കമായി ഈ അല്‍ഗോരിതത്തിലെ എളുപ്പമുള്ള ഭാഗങ്ങള്‍ പൈത്തണിലേക്ക് പകര്‍ത്തിനോക്കാം. പറയാനുള്ള സൗകര്യത്തിനായി a, b-യെക്കാള്‍ വലുതല്ല എന്ന് സങ്കല്‍പ്പിക്കാം:



    ഈ പ്രോഗ്രാമില്‍ b -യെ a കൊണ്ട് ഹരിച്ചാല്‍ കിട്ടുന്ന r എന്ന ശിഷ്ടം പൂജ്യമാണെങ്കില്‍ നമുക്ക് വേണ്ട ഉസാഘ കിട്ടുന്നു. r പൂജ്യത്തെക്കാള്‍ വലുതാണെങ്കില്‍ r, a എന്നിവയുടെ ഉസാഘ കണ്ടുപിടിക്കണമല്ലോ? ഇതിനുള്ള കോഡ് നാം എഴുതിയിട്ടില്ല എന്നത് ശ്രദ്ധിക്കുക; ഇതിനുപകരം ഇങ്ങനെ ചെയ്യണം എന്ന് നമ്മെത്തന്നെ ഓര്‍മ്മിപ്പിക്കാനുള്ള ഒരു കമന്റ് മാത്രം യഥാസ്ഥാനത്ത് എഴുതിയിട്ടുണ്ട്.

    ഈ കോഡ് നമുക്ക് എങ്ങനെ എഴുതാം? ഇത് മനസ്സിലാക്കാനായി പ്രവര്‍ത്തനം 5-ല്‍ ഈ ഭാഗം എങ്ങനെയാണ് ചെയ്തതെന്ന് ആലോചിച്ചു നോക്കുക. തുടക്കത്തില്‍ കൊടുത്ത a, b എന്നിവയ്ക്ക് പകരം r, a എന്നീ വിലകള്‍ പകരം വെച്ച് ആദ്യം മുതല്‍ ചെയ്താല്‍ മതിയാകും: കടലാസും പേനയും ഉപയോഗിച്ച് ചെയ്തപ്പോഴും ഇങ്ങനെയാണല്ലോ ചെയ്തത്? ഇങ്ങനെ രണ്ടാമതും ചെയ്യുമ്പോള്‍ a == b ആവുകയില്ലല്ലോ (എന്തുകൊണ്ട്?) അതുകൊണ്ട് ഇക്കാര്യം പരിശോധിക്കുന്ന വരി ഒഴിവാക്കാം. ഇങ്ങനെ ഒന്നുകൂടി വിസ്തരിച്ചെഴുതിയ പ്രോഗ്രാം ഇതാ:




    ഈ പ്രോഗ്രാമില്‍ നാം എന്താണ് ചെയ്തത് എന്ന് ശ്രദ്ധിക്കുക. ആദ്യത്തെ പ്രോഗ്രാമില്‍ "r, a എന്നിവയുടെ ഉസാഘ കണ്ടുപിടിക്കൂ" എന്ന് കമന്റായി എഴുതിയ സ്ഥാനത്ത് നാം ഇക്കാര്യം ചെയ്യാനുള്ള കോഡ് എഴുതി. ഇതിനായി ആദ്യം r, a എന്നിവയെ യഥാക്രമം a, b എന്നിങ്ങനെ പേരുമാറ്റി; ഇങ്ങനെയാകുമ്പോള്‍ a, b എന്നിവയുടെ ഉസാഘ കാണാന്‍ മുകളില്‍ എഴുതിയ കോഡ് അതേപടി പകര്‍ത്തിയാല്‍ മതിയാകുമല്ലോ. പിന്നെ നാം ഈ കോഡ് മുകളില്‍നിന്ന് പകര്‍ത്തിയെഴുതി. ഇവിടെ രണ്ടാമത്തെ തവണ ഹരിക്കുമ്പോള്‍ കിട്ടുന്ന ശിഷ്ടം പൂജ്യമാണെങ്കില്‍ നമുക്കുവേണ്ടതായ ഉസാഘ കിട്ടും; ഇല്ലെങ്കിലാണ് പ്രശ്നം. ഇവിടെയും ശിഷ്ടം കിട്ടുന്ന r പൂജ്യമല്ലെങ്കില്‍ r, a എന്നിവയുടെ ഉസാഘ കണ്ടുപിടിക്കൂ എന്ന് കമന്റായി മാത്രം വീണ്ടും എഴുതിയത് ശ്രദ്ധിക്കുക.


    ഈ രീതിയില്‍ പ്രോഗ്രാം വികസിച്ചുവന്നാലുള്ള കുഴപ്പം മനസ്സിലായല്ലോ? സ്ക്രീനിന്റെ വലതുവശത്തേക്ക് പ്രോഗ്രാം അടിവച്ച് നീങ്ങിപ്പോകുന്നതു പോകട്ടെ, എത്രതവണ ശിഷ്ടം കണ്ടാലാണ് ഉസാഘ കിട്ടുക എന്നത് പ്രോഗ്രാം എഴുതുന്ന സമയത്ത് നമുക്കറിഞ്ഞുകൂടാ എന്ന ഒരു വലിയ പ്രശ്നം ഈ രീതിക്കുണ്ട്: ഇന്‍പുട്ട് കിട്ടുന്ന സംഖ്യകള്‍ക്കനുസരിച്ച് ഇത് എത്രവേണമെങ്കിലും വരെ ആകാം. ഈ പ്രശ്നം എങ്ങനെ പരിഹരിക്കാം? ഇവിടെ നമ്മുടെ കോഡ് എത്ര വരെ പ്രവര്‍ത്തിക്കണം എന്നത് ഒരു വ്യവസ്ഥയെ (condition) ആശ്രയിച്ചിരിക്കുന്നു എന്നത് ശ്രദ്ധിക്കുക: ശിഷ്ടമായി കിട്ടുന്ന r എപ്പോള്‍ പൂജ്യമാകുന്നോ അപ്പോള്‍ നമുക്ക് പ്രോഗ്രാമിന്റെ പ്രവര്‍ത്തനം നിര്‍ത്താം — ഈ സമയത്തെ a-യുടെ വിലയാണ് നമുക്കുവേണ്ട ഉസാഘ.


    വ്യവസ്ഥ ശരിയാകുന്നതുവരെ ആവര്‍ത്തിക്കാന്‍: while


    ഇങ്ങനെ, ഒരു വ്യവസ്ഥ ശരിയാകുന്നതുവരെ കുറേക്കാര്യങ്ങള്‍ ആവര്‍ത്തിച്ച് ചെയ്യാന്‍ പൈത്തണിലും മറ്റ് മിക്ക കംപ്യൂട്ടര്‍ ഭാഷകളിലുമുള്ള ഉപാധിയാണ് while . ഇതിനുമുമ്പ് നാം പരിചയപ്പെട്ട if, for എന്നിവയുടെ സമ്മിശ്ര സ്വഭാവമുള്ള ഒരു ഉപാധിയാണ് ഇത്. ഇനി നമുക്ക് while -നെ പരിചയപ്പെടാം. ഇതിനായി താഴെക്കാണുന്ന പ്രോഗ്രാമുകള്‍ പ്രവര്‍ത്തിപ്പിച്ചുനോക്കുക.







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


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

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


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

    പ്രവ. 6.
    while-ല്‍ പറയുന്ന വ്യവസ്ഥ (condition) എപ്പോള്‍ വരെ ശരിയായിരിക്കുന്നോ, അപ്പോള്‍ വരെ while-ന്റെ പരിധിയില്‍പ്പെടുന്ന വരികള്‍ പ്രവര്‍ത്തിപ്പിക്കുക എന്നതാണല്ലോ while-ന്റെ സ്വഭാവം? ഇതുകൊണ്ടുതന്നെ while -ന്റെ പരിധിയില്‍പ്പെടുന്ന വരികള്‍ ഓരോ തവണ പ്രവര്‍ത്തിപ്പിക്കുമ്പോഴും ഈ വ്യവസ്ഥയെ (നേരിട്ടോ അല്ലാതെയോ)ബാധിക്കുന്ന എന്തെങ്കിലും മാറ്റം വരേണ്ടത് സാധാരണ ഗതിയില്‍ പ്രോഗ്രാം ശരിയാകാന്‍ ആവശ്യമാണ്. മുകളിലെ ഉദാഹരണങ്ങളില്‍ ഇങ്ങനെയുള്ളതരം മാറ്റം വരുത്തുന്ന വരികള്‍ ഏതാണെന്ന് കണ്ടുപിടിക്കുക.



  4. യൂക്ളിഡിന്റെ അല്‍ഗോരിതം : പൈത്തണില്‍ വീണ്ടും


    ഇനി നമുക്ക് while ഉപയോഗിച്ച് യൂക്ളിഡിന്റെ അല്‍ഗോരിതത്തിനെ എങ്ങനെ മുഴുമിപ്പിക്കാം എന്ന് നോക്കാം. നമ്മുടെ രണ്ടാമത്തെ പ്രോഗ്രാം ഒന്നുകൂടെ എടുത്തെഴുതുന്നു. പറയാനുള്ള സൗകര്യത്തിനായി a, b-യെക്കാള്‍ വലുതല്ല എന്ന് സങ്കല്‍പ്പിച്ചിരിക്കുന്നു എന്ന് ഓര്‍ക്കുക:



    while ഉപയോഗിച്ച് ഈ കോഡിനെ എങ്ങനെ മുഴുമിപ്പിക്കാം? ഇവിടെ r എന്ന ചരത്തിന്റെ വില പൂജ്യം ആകുന്നതുവരെയാണ് നമുക്ക് ശിഷ്ടം കാണുകയും മറ്റും വേണ്ടത്. ഇത് while ഉപയോഗിച്ച് എഴുതുമ്പോള്‍ ഇങ്ങനെയാകും:




    ഇവിടെ ചെയ്തിരിക്കുന്നത് ശ്രദ്ധിക്കുക. ഒമ്പതാമത്തെ വരിയില്‍ b-യെ a കൊണ്ട് ഹരിച്ചാല്‍ കിട്ടുന്ന ശിഷ്ടം r എന്ന ചരത്തില്‍ സൂക്ഷിച്ചുവെക്കുന്നു. r-ന്റെ വില പൂജ്യമാണെങ്കില്‍ നമുക്കുവേണ്ടതായ ഉസാഘ a-യുടെ വില തന്നെയാണെന്ന് നാം കണ്ടു. r-ന്റെ വില പൂജ്യം അല്ലെങ്കില്‍ ഈ വില പൂജ്യം ആകുന്നതുവരെ ഒരുകൂട്ടം കാര്യങ്ങള്‍ ചെയ്യണം. ഇത് സംഭവിക്കുന്നത് 11 മുതല്‍ 18 വരെയുള്ള വരികളിലാണ്. പതിനൊന്നാം വരിയില്‍ while-ന് തുടക്കമിട്ടിരിക്കുന്നു. ഈ while-ന്റെ പരിധി പതിനെട്ടാം വരി വരെയാണ്. പന്ത്രണ്ടുമുതല്‍ പതിനെട്ടുവരെയുള്ള വരികള്‍ എത്രത്തോളം ആവര്‍ത്തിക്കണം എന്നത് പതിനൊന്നാം വരിയില്‍ പറഞ്ഞിരിക്കുന്നു: "r-ന്റെ വില പൂജ്യം അല്ലാത്തിടത്തോളം".

    മുകളിലത്തെ പ്രോഗ്രാമിനെ നമുക്ക് കുറച്ചുകൂടെ ചെറുതാക്കാം. a == b ആണെങ്കില്‍ b-യെ a കൊണ്ട് ഹരിച്ചാല്‍ ശിഷ്ടം പൂജ്യമാണല്ലോ? ഇക്കാര്യം മുതലെടുത്ത് ആദ്യത്തെ വ്യവസ്ഥ പരിശോധിക്കുന്നത് നമുക്ക് ഒഴിവാക്കാം. ഇനി a, b-യെക്കാള്‍ വലുതാണെങ്കില്‍ b-യെ a കൊണ്ട് ഹരിച്ചാല്‍ ശിഷ്ടം b തന്നെയാണല്ലോ? അതുകൊണ്ട് while ആദ്യത്തെ തവണ പ്രവര്‍ത്തിക്കുമ്പോള്‍ a, b എന്നിവയുടെ വിലകള്‍ തമ്മില്‍ വെച്ചുമാറുകയും a,b-യെക്കാള്‍ ചെറുതാകുകയും ചെയ്യും. ഫലം : a, b-യെക്കാള്‍ വലുതായാല്‍ പോലും ഇതേ കോഡ് ശരിയായി പ്രവര്‍ത്തിക്കും. ഈ മാറ്റങ്ങളൊക്കെ വരുത്തിയ കോഡ് ഇതാ:



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

    പ്രവ. 7.
  5. മുകളിലത്തെ പ്രോഗ്രാമും അതിന് തൊട്ടുമുമ്പ് കൊടുത്തിട്ടുള്ള പ്രോഗ്രാമും തമ്മിലുള്ള വ്യത്യാസങ്ങള്‍ എന്തൊക്കെയാണ്? ഈ വ്യത്യാസങ്ങളൊക്കെ ഉണ്ടായിട്ടും രണ്ടു പ്രോഗ്രാമും എന്തുകൊണ്ടാണ് ഒരേപോലെ പ്രവര്‍ത്തിക്കുന്നത്?
  6. രണ്ട് എണ്ണല്‍സംഖ്യകള്‍ ഇന്‍പുട്ട് ആയി എടുത്ത്, യൂക്ളിഡിന്റെ അല്‍ഗോരിതം ഉപയോഗിച്ച് ഈ സംഖ്യകളുടെ ഉസാഘ കണ്ടുപിടിക്കുന്ന പ്രോഗ്രാം മുകളില്‍ കൊടുത്ത രീതിയില്‍ എഴുതുക. പ്രോഗ്രാമിന്റെ പ്രവര്‍ത്തനഫലം താഴെക്കാണുന്ന ചിത്രത്തിലെപ്പോലെ ആയിരിക്കണം (കുറച്ചുകൂടെ വ്യക്തമായ ചിത്രം കാണാന്‍ ഈ ചിത്രത്തില്‍ അമര്‍ത്തുക). ഇവിടെ ഈ പ്രോഗ്രാം നാലു തവണ പ്രവര്‍ത്തിപ്പിച്ചിരിക്കുന്നു (IDLE-ല്‍ F5 നാലു തവണ അമര്‍ത്തിയിരിക്കുന്നു).
  7. മുകളില്‍ "യൂക്ളിഡിന്റെ അല്‍ഗോരിതം" എന്ന ഭാഗത്തിന്റെ തുടക്കത്തില്‍ കാണുന്ന മൂന്ന് ജോടി സംഖ്യകള്‍ ഈ പ്രോഗ്രാമിന് ഇന്‍പുട്ട് ആയി കൊടുക്കുക. ഈ പ്രോഗ്രാം ഇവയുടെ ഉത്തരം കണ്ടുപിടിക്കാന്‍ ഏറെ സമയം എടുക്കുന്നുണ്ടോ?
  8. വളരെ വലിയ സംഖ്യകള്‍ ഉള്‍പ്പെടുന്ന ജോടികള്‍ ഈ പ്രോഗ്രാമിന് ഇന്‍പുട്ട് ആയി കൊടുക്കുക. സംഖ്യകള്‍ വലുതാകുന്ന അതേ തോതില്‍ പ്രോഗ്രാം എടുക്കുന്ന സമയവും കൂടുന്നതായി തോന്നുന്നുണ്ടോ?

അടിക്കുറിപ്പ്

ഈ പാഠത്തില്‍ നാം കുറെയേറെ പുതിയ കാര്യങ്ങള്‍ കണ്ടു. സാവധാനം മനസ്സിരുത്തി വായിച്ച് ഉദാഹരണങ്ങള്‍ പ്രവര്‍ത്തിപ്പിച്ചുനോക്കുകയും പ്രവര്‍ത്തനങ്ങള്‍ ചെയ്തുനോക്കുകയും ചെയ്താല്‍ അധികം പ്രയാസമില്ലാതെ ഈ പാഠത്തിലെ കാര്യങ്ങള്‍ മനസ്സിലാക്കാം. സംശയങ്ങള്‍ ഉണ്ടാകുമ്പോള്‍ കമന്റുകളിലൂടെ ചോദിക്കുക. മുമ്പ് പലതവണ പറഞ്ഞിട്ടുള്ളതുപോലെ, പ്രോഗ്രാമുകള്‍ എഴുതി പ്രവര്‍ത്തിപ്പിച്ച് തെറ്റുതിരുത്തി പരിശീലിച്ചാല്‍ അനായാസം സ്വായത്തമാക്കാവുന്ന ഒന്നാണ് പ്രോഗ്രാമിംഗ്.

72 comments:

ഫിലിപ്പ് April 7, 2011 at 8:18 AM  

എന്തോ പിശകു കാരണം മുമ്പ് പ്രസിദ്ധീകരിച്ച പോസ്റ്റില്‍ പ്രോഗ്രാമുകള്‍ തെറ്റായ രീതിയിലാണ് കാണിച്ചിരുന്നത്. അത് തിരുത്താന്‍ വീണ്ടും പോസ്റ്റ് ചെയ്യേണ്ടി വന്നു. ഇതുവരെയുള്ള കമന്റുകള്‍ ഇതാ:

ഹോംസ്:

നീണ്ട ഇടവേളയ്ക്കുശേഷം പൈത്തണ്‍ പാഠങ്ങള്‍ തിരിച്ചെത്തിയതില്‍ സന്തോഷം!
എന്റെ പൈത്തണ്‍ പഠനം എപ്പോഴോ മൂന്നാം പാഠത്തില്‍ തട്ടി നിന്നുപോയി..പ്രോഗ്രാമിങ്ങിനുവേണ്ട പ്രത്യേക സ്കില്ലിന്റെ അഭാവമായിരിക്കണം കാരണം. എങ്കിലും ഇലക്ഷനൊന്ന് കഴിഞ്ഞോട്ടെ, മനസ്സിരുത്തി ശ്രമിക്കുന്നുണ്ട്. ഫിലിപ്പ് മാഷിന്റെ ഈ സ്വര്‍ണ്ണം പത്തരമാറ്റുള്ള 91.6 തന്നെ!!

വി. കെ. നിസാര്‍:

പുതിയ ഒമ്പതാം ക്ലാസ് ഐസിടി ടെക്സ്റ്റ്ബുക്കില്‍ പൈത്തണ്‍ സംബന്ധമായുള്ള ചാപ്റ്റര്‍ കൈകാര്യം ചെയ്യാനുണ്ടല്ലോ..?ഈ വെക്കേഷന് ഈ പാഠങ്ങള്‍ മുഴുവന്‍ സ്വാംശീകരിച്ചാല്‍ അധ്യാപനം പാല്പായസമാകുമെന്നുറപ്പ്..
നന്ദി, ഫിലിപ്പ് സാര്‍!

bhama:

പൈത്തണ്‍ പഠനം പാല്‍പായസം

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

fasal:

പൈത്തണ്‍ ഈ വര്‍ഷവും കുട്ടികളെ പഠി്പ്പിക്കാനുണ്ടല്ലോ. ഈ പാഠങ്ങള്‍ എന്തായാലും സഹായകമാകും.

bhama April 7, 2011 at 4:30 PM  

മുകളില്‍ എഴുതിയ പ്രോഗ്രാമില്‍ append() എന്ന ഏകദം ഉപയോഗിച്ചിരുന്നില്ല. അതുപയോഗിച്ച് എഴുതിയതാണ് ഇവിടെ

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


പ്രവ. 2. രണ്ട് എണ്ണല്‍സംഖ്യകള്‍ ഇന്‍പുട്ട് ആയി എടുത്ത്, ഈ സംഖ്യകളുടെ പൊതു ഘടകങ്ങളുടെ ഒരു ലിസ്റ്റ് ഔട്പുട്ട് ആയി തരുന്ന പ്രോഗ്രാം ഇതാ

bhama April 7, 2011 at 8:10 PM  

പ്രവ. 5.
രണ്ട് എണ്ണല്‍സംഖ്യകള്‍ ഇന്‍പുട്ട് ആയി എടുത്ത്, ഈ സംഖ്യകളുടെ ഉസാഘ കണ്ടുപിടിക്കുന്ന പ്രോഗ്രാം

chithrakaran:ചിത്രകാരന്‍ April 8, 2011 at 12:45 PM  

പൈത്തണ്‍ പാഠം നടക്കട്ടെ.
ആശംസകള്‍ !!!
അതിനിടക്ക് ഒരു ചിന്ന ഓഫ് :)

അന്ന ഹസാരെ നടത്തുന്ന അഴിമതിക്കെതിരെയുള്ള സമരത്തോട് അഭിവാദ്യം പ്രകടിപ്പിച്ചുകൊണ്ട് കൊച്ചിയില്‍ ഒരു ഒത്തുകൂടല്‍ ശ്രമം ആരംഭിച്ചിട്ടുണ്ട്. അധ്യാപക വിദ്യാര്‍ത്ഥി തലങ്ങളിലാണ് സാമൂഹ്യമാറ്റത്തിന്റെ വിത്ത് മുളക്കേണ്ടതെന്നതിനാല്‍ മാത്തമറ്റിക്സ് ബ്ലോഗ് ടീം മുന്നോട്ടുവരുന്നത് ബ്ലോഗിന്റെ തന്നെ ജനകീയ വികാസത്തിനു വഴിവെക്കുമെന്നതിനാല്‍ കഴിയുമെങ്കില്‍ ശ്രമിക്കുക.
കൂടുതല്‍ വിവരങ്ങള്‍ക്ക് ചില പോസ്റ്റുകള്‍:ഇന്ത്യയിലും നെറ്റ് വിപ്ലവം ! അഴിമതിക്കെതിരായുള്ള രണ്ടാം സ്വാതന്ത്ര്യ സമരം !

shemi April 8, 2011 at 8:14 PM  

ഫിലിപ്പ് സര്‍, പോസ്റ്റ് കണ്ടതിപ്പോഴാണ്. സന്തോഷം. ഫഠിച്ചതൊക്കെ ഒന്ന് പുതുക്കട്ടെ. എന്നാലെ ഒരു തുടര്‍ച്ച കിട്ടു.

ഫിലിപ്പ് April 8, 2011 at 9:09 PM  

ഹോംസ് സാര്‍,

പ്രോഗ്രാമിംഗ് ഡ്രൈവിംഗ് പോലെയാണ്: സാമാന്യം ഉപകരിക്കത്തക്ക തോതില്‍ പഠിക്കാനുള്ള സ്കില്‍ എല്ലാവര്‍ക്കും ഉണ്ട്.

ഭാമ ടീച്ചര്‍,
പ്രോഗ്രാമുകളെല്ലാം വളരെ നന്നായിട്ടുണ്ട്. ഈ പ്രോഗ്രാം ചെയ്ത് രീതി രസകരവുമാണ്.
ഈ പ്രോഗ്രാമിലെയും ഈ പ്രോഗ്രാമിലെയും 6,7 എന്നീ വരികള്‍ എന്താണ് ചെയ്യുന്നത്?

ഫസല്‍ സാര്‍, ഷെമി ടീച്ചര്‍,
പൈത്തണ്‍ പഠനത്തിലേക്ക് (വീണ്ടും) സ്വാഗതം.

-- ഫിലിപ്പ്

bhama April 9, 2011 at 7:16 AM  

പ്രവ.2 ല്‍ 5,6 വരികള്‍ പ്രോഗ്രാമിന്റെ പ്രവര്‍ത്തനത്തിന് ആവശ്യമില്ല. Range നല്കുന്ന അവസരത്തില്‍ ചെറിയ സംഖ്യ കണ്ടെത്തേണ്ടതുണ്ടോ ?

രണ്ട് എണ്ണല്‍സംഖ്യകള്‍ ഇന്‍പുട്ട് ആയി എടുത്ത്, യൂക്ളിഡിന്റെ അല്‍ഗോരിതം ഉപയോഗിച്ച് ഈ സംഖ്യകളുടെ ഉസാഘ കണ്ടുപിടിക്കുന്ന പ്രോഗ്രാം ചെയ്യാന്‍ ശ്രമിച്ചതാണ് ഇവിടെ.
ഇതില്‍ 12 ം വരിയില്‍ a,b ഇവയുടെ വിലകള്‍ input നല്കുന്നതു തന്നെ കിട്ടാന്‍ എന്തു ചെയ്യണം ?

ഫിലിപ്പ് April 9, 2011 at 8:22 AM  

ഭാമ ടീച്ചര്‍,

ടീച്ചര്‍ വളരെ വേഗം പഠിക്കുന്നുണ്ട്. പ്രോഗ്രാം നന്നായിട്ടുണ്ട്. 12-മത്തെ വരിയിലെ a-യുടെ വിലയും ഉസാഘയുമായി എന്തെങ്കിലും ബന്ധം ഉണ്ടോ?

ഇവിടെ ടീച്ചര്‍ക്ക് വേണ്ടത് എന്താണെന്ന് നോക്കാം:

1. രണ്ട് സംഖ്യകള്‍ ഇന്‍പുട് ആയി കിട്ടുന്നു. ഇവയെ നാം a, b എന്നീ ചരങ്ങളിലായി സൂക്ഷിക്കുന്നു.

2. ഈ ചരങ്ങള്‍ ഉപയോഗിച്ച് നാം കുറേ "പ്രോഗ്രാമിക" ക്രിയകള്‍ ചെയ്യുന്നു. ഇങ്ങനെ ചെയ്യുന്നതിനിടയ്ക്ക് മറ്റ് വിലകള്‍ ഇതേ ചരങ്ങളില്‍ സൂക്ഷിച്ചുവെയ്ക്കുന്നതുകൊണ്ട് ഇവയില്‍ സൂക്ഷിച്ചിരുന്ന വിലകള്‍ക്ക് മാറ്റം വരുന്നു.

3. ഒരു ഘട്ടത്തില്‍ നമുക്ക് വേണ്ടതായ ഉത്തരം കിട്ടുന്നു. ഇന്‍പുട് കിട്ടിയ വിലകളെക്കൂടി ചേര്‍ത്ത് ഉത്തരം കിട്ടിയതായി പറയണമെന്നാണ് നമ്മുടെ ആഗ്രഹം. പക്ഷേ a, b എന്നിവയുടെ വിലകള്‍ മാറിപ്പോയതിനാല്‍ അവ ഈ ആവശ്യത്തിന് ഇനി ഉപകരിക്കുകയില്ല.

4. എന്തു ചെയ്യാന്‍ കഴിയും?

ആലോചിച്ചുനോക്കൂ. ഈ പ്രശ്നത്തിന് ലളിതമായ ഉത്തരം ഉണ്ട്: ഉദാ: a, b എന്നിവയുടെ അവസാനത്തെ വിലകളില്‍നിന്ന് പുറകോട്ട് പോവുകയും മറ്റും വേണ്ട.

ഇനിയും ഉത്തരം കിട്ടുന്നില്ലെങ്കില്‍ ചോദിച്ചോളൂ, പറഞ്ഞുതരാം.

-- ഫിലിപ്പ്

VIJAYAKUMAR M D April 10, 2011 at 3:46 PM  

പാഠം 7 പഠിക്കാന്‍ തുടങ്ങിയപ്പോളാണ് അതുവരെയുള്ള പാഠങ്ങള്‍ ഓര്‍മ്മയില്ലെന്ന് മനസ്സിലായത്. വീണ്ടും പഠിച്ചുവരുന്നു. പാഠങ്ങള്‍ കൂടുതല്‍ രസകരമാകുന്നുണ്ട്

ഫിലിപ്പ് April 13, 2011 at 10:49 AM  

ഈ പാഠത്തിന്റെ പിഡിഎഫ് പതിപ്പ് ഇവിടെ .

bhama April 14, 2011 at 4:22 PM  

ഇലക്ഷോടനുബന്ധിച്ചുള്ള തിരഞ്ഞെടുപ്പു കമ്മീഷന്റെ വോട്ടേഴ്സ് സ്ലിപ്പ് വിതരണത്തിന്റെ തിരക്കിലായിരുന്നു. അതുകൊ​ണ്ട് പ്രോഗ്രാം നോക്കുന്നതിന് സമയം കിട്ടിയില്ല.
a, b എന്നിവയുടെ അവസാനത്തെ വിലകളില്‍നിന്ന് പുറകോട്ട് പോകാതെ ആദ്യവില കണ്ടെത്താനുള്ള വഴി ഇപ്പൊ കിട്ടിയിട്ടില്ല. ഒന്നു കൂടി നോക്കട്ടെ എന്നിട്ടു പറയാം

bhama April 14, 2011 at 8:59 PM  

എനിക്കു ഉത്തരം കിട്ടുന്നില്ല. സാറു തന്നെ പറഞ്ഞു തരു

ഫിലിപ്പ് April 14, 2011 at 9:27 PM  

ഭാമ ടീച്ചര്‍,

നമുക്ക് പിന്നീട് ആവശ്യം വരുന്ന വില ഒരു പുതിയ ചരത്തില്‍ സൂക്ഷിച്ച് വെച്ചാല്‍ മതിയാകില്ലേ?

original_a = a
original_b = b

എന്നോ മറ്റോ തുടക്കത്തില്‍ പറഞ്ഞാല്‍ ഉത്തരം പ്രിന്റ് ചെയ്യുന്നിടത്ത് ഈ വിലകള്‍ ഉപയോഗിക്കാമല്ലോ.

-- ഫിലിപ്പ്

bhama April 14, 2011 at 9:45 PM  

Thank you sir.
ഉത്തരം വളരെ ലളിതം
ഇത്തരത്തില്‍ ചിന്തിച്ചതേ ഇല്ല. അവസാന വിലകളെ ബന്ധപ്പെടുത്തി മാത്രമേ നോക്കിയുള്ളു.

Babu April 21, 2011 at 4:45 PM  

Thank for Publishing the Ninth standard I.T Handbook

Suraj Kiran May 4, 2011 at 8:00 PM  

sir
how can i connect my programme to linux GUI

ഫിലിപ്പ് May 4, 2011 at 10:04 PM  

സൂരജ്,

പൈത്തണ്‍ ഉപയോഗിച്ച് ലിനക്സില്‍ GUI പ്രോഗ്രാമുകള്‍ എങ്ങനെ എഴുതാം എന്നാണ് താങ്കളുടെ ചോദ്യം എന്ന് കരുതുന്നു.

ഇതിനായി കുറെയേറെ സംവിധാനങ്ങള്‍ ലഭ്യമാണ്. പൈത്തണിന്റെ കൂടെ സ്വതവേ ലഭ്യമാക്കിയിട്ടുള്ള (വേറൊന്നും ഇന്‍സ്റ്റാള്‍ ചെയ്യാതെതന്നെ ഉപയോഗിക്കാവുന്ന) ഒന്നാണ് TkInter . ഇതുപയോഗിച്ച് എഴുതാവുന്ന ലളിതമായ ഒരു പ്രോഗ്രാം ഇതാ:

###########
from Tkinter import *

root = Tk()

w = Label(root, text="Hello, world!")
w.pack()

root.mainloop()
###########

ഈ പ്രോഗ്രാം hello.py എന്നോ മറ്റോ പേരുള്ള ഒരു ഫയലില്‍ സേവ് ചെയ്ത് python hello.py എന്ന് പ്രവര്‍ത്തിപ്പിച്ചുനോക്കൂ.

TkInter ഉപയോഗിച്ച് കൂടുതല്‍ കാര്യങ്ങള്‍ ചെയ്യാന്‍ പഠിക്കാന്‍ ഇവിടെ നോക്കുക.

-- ഫിലിപ്പ്

Mubarak May 5, 2011 at 10:35 PM  

സാര്‍ ഒന്‍പതാം ക്ലാസ്സിലെ പൈത്തണുമായി ബന്ധപ്പെട്ട ഒരു സംശയം ചോദിക്കുകയാണ്.python sപell-ല്‍ new window-യില്‍ from turtle import*
circle(20) അടിച്ചു കഴിഞ്ഞപ്പോള്‍
"Name error: name 'circle' is not defined"
എന്നെഴുതി വരുന്നു എന്താണ് കാരണം

Manju May 6, 2011 at 5:59 AM  
This comment has been removed by the author.
ഫിലിപ്പ് May 6, 2011 at 6:02 AM  

മുബാറക് സാര്‍,

ഈ ഷെല്ലില്‍ നിന്ന് പുറത്തുകടക്കുക (quit() അല്ലെങ്കില്‍ Ctrl-D). ഇതുകഴിഞ്ഞ് താങ്കള്‍ turtle.py എന്ന പേരില്‍ ഉണ്ടാക്കിയ ഫയലിന്റെ പേര് വേറെ എന്തെങ്കിലും (ഉദാ: 'myturtle.py') ആക്കുക. ഇനി ഒരു പുതിയ ഷെല്‍ തുറന്ന് ഇതേ വരികള്‍ പ്രയോഗിച്ചു നോക്കൂ.

സംഭവം ശരിയായാലും ഇല്ലെങ്കിലും ഇവിടെ പറയുമല്ലോ. ഇതേ സംശയമുള്ള മറ്റുള്ളവര്‍ക്കും ഇത് ഉപകരിക്കും.

-- ഫിലിപ്പ്.

Mubarak May 6, 2011 at 11:03 PM  

വളരെയധികം നന്ദി ഫിലിപ്പ് സര്‍,
ഈ സിസ്റ്റത്തില്‍ എന്തോ കുഴപ്പം പറ്റിയതാണെന്നാന് ഞ്ന്‍ കരുതിയത്. സാര്‍ പറഞ്ഞ രീതിയില്‍ ചെയ്തു നോക്കി, ശരിയായി. വളരെയധികം നന്ദി സര്‍

ഫിലിപ്പ് May 17, 2011 at 8:01 AM  

$\LaTeX$ ഉപയോഗിച്ച് കമന്റ് എഴുതാന്‍ പറ്റുമോ എന്ന് ഒരു പരീക്ഷണം:

$\frac{\sqrt{101^{n}}}{n!}$

preethi June 4, 2011 at 9:07 PM  

sir,
ente collegil(KNM Govt. College, kanjiramkulam, thiruvananthapuram) python paathangalil oru seminar conduct cheyyan aagrahikkunnu..G.Philip sirinu oru class edukkan pattumo?

please reply positively

ഫിലിപ്പ് June 4, 2011 at 10:57 PM  
This comment has been removed by the author.
ഫിലിപ്പ് June 4, 2011 at 10:59 PM  

പ്രീതി ടീച്ചര്‍,

ക്ഷണത്തിന് നന്ദി. ജോലിത്തിരക്കു കാരണം ക്ഷണം സ്വീകരിക്കാന്‍ തത്കാലം നിര്‍‌വാഹമില്ല എന്ന് ഖേദപൂര്‍‌വം പറയട്ടെ.

ത്രിശ്ശൂരിലുള്ള പ്രമോദ് സാര്‍ ഇങ്ങനെയുള്ള ക്ളാസുകള്‍ കുറച്ചുകാലം മുന്‍പുവരെ എടുത്തിരുന്നതായി അറിയാം. അദ്ദേഹം ഇതിനുമുമ്പ് കേരളത്തിലെ പല കോളജുകളിലും സ്കൂളുകളീലുമായി എടുത്ത ചില ക്ളാസുകളുടെ റിപ്പോര്‍ട്ടുകള്‍ കാണൂ. ഇപ്പോള്‍ അദ്ദേഹം ഇങ്ങനെയുള്ള ക്ളാസുകള്‍ എടുക്കുന്നുണ്ടോ എന്ന് അറിഞ്ഞുകൂടാ. അദ്ദേഹത്തിന്റെ വെബ്സൈറ്റിലുള്ള വിലാസത്തില്‍ ഒരു ഈമെയില്‍ അയച്ച് ചോദിച്ചുനോക്കൂ. ഇക്കാര്യത്തില്‍ എന്നെക്കാള്‍ ഏറെ പ്രാഗല്‍ഭ്യവും അനുഭവസമ്പത്തും ഉള്ളയാളാണ് അദ്ദേഹം.

-- ഫിലിപ്പ്

bhama June 12, 2011 at 6:25 AM  

പ്രോജക്ട് ഓയിലറിലെ 3ാമത്തെ ചോദ്യത്തില്‍ ഞാന്‍ ചെയ്തരീതിയില്‍ അതില്‍ തന്നിരിക്കുന്ന വലിയ സംഖ്യയുടെ ഏറ്റവും വലിയ അഭാജ്യ ഘടകം കണ്ടെത്താന്‍ കഴിയുന്നില്ല. പ്രോഗ്രാമില്‍ എന്തു മാറ്റമാണ് വരുത്തേണ്ടത് ?

1,2,4,5,6,9 എന്നി ചോദ്യങ്ങളുടെ പ്രോഗ്രാമുകള്‍ എഴുതി ഉത്തരം ശരിയായിട്ടുണ്ടെങ്കിലും പ്രോഗ്രാമിനുണ്ടായിരിക്കേണ്ട എല്ലാ ഗുണങ്ങളും അതിലുണ്ടോ എന്നൊരു സംശയം ഇല്ലാതില്ല.

ഫിലിപ്പ് June 12, 2011 at 3:08 PM  

ഭാമ ടീച്ചര്‍,

ടീച്ചറുടെ ഈ പ്രോഗ്രാം പ്രവര്‍ത്തിപ്പിച്ചപ്പോള്‍ എന്ത് ഫലമാണ് കിട്ടിയത്?

പ്രോഗ്രാമിനുണ്ടാകേണ്ട പ്രധാന ഗുണം ഉത്തരം ശരിയാകുക എന്നതാണ്! പ്രോജക്റ്റ് ഓയ്‌ലറിലെ ടീച്ചര്‍ എഴുതിയ പ്രോഗ്രാമുകളുടെ ലിങ്ക് ഇവിടെ കൊടുത്താല്‍ നമുക്ക് നോക്കാമല്ലോ. ‍

-- ഫിലിപ്പ്

bhama June 12, 2011 at 8:43 PM  

3ാമത്തെ ചോദ്യത്തിന്റെ പ്രോഗ്രാം പ്രവര്‍ത്തിപ്പിച്ചപ്പോള്‍ കിട്ടിയത്

>>>
Enter a composite number 13195
29
>>>
Enter a composite number 600851475143
Traceback (most recent call last):
File "/home/bhama/Desktop/Project Euler/p3.py", line 11, in
for i in range (1,(c_num/2)+1):
OverflowError: range() result has too many items
>>>

bhama June 12, 2011 at 9:27 PM  

പ്രോജക്ട് ഓയിലറിലെ 1 , 2 , 4 ചോദ്യങ്ങളുടെ ഉത്തരം കണ്ടെത്താനായി എഴുതിയ പ്രോഗ്രാമുകള്‍

ഫിലിപ്പ് June 12, 2011 at 9:49 PM  

range() എന്ന ഏകദം ചെയ്യുന്നത് പൂര്‍ണ്ണസംഖ്യകളുടെ ഒരു ലിസ്റ്റ് ഉണ്ടാക്കുക എന്നതാണല്ലോ. ഈ സന്ദേശം പറയുന്നത് range() എന്ന ഏകദത്തിന് ഉണ്ടാക്കാവുന്ന ഏറ്റവും വലിയ ലിസ്റ്റില്‍ ഉള്‍ക്കൊള്ളിക്കാവുന്നതിലും കൂടുതല്‍ അംഗങ്ങള്‍ ഉള്ള ഒരു ലിസ്റ്റ് ഉണ്ടാക്കാനാണ് നാം ആവശ്യപ്പെട്ടത് എന്നാണ്. ചുരുക്കത്തില്‍ : range()-ന് കൊടുത്ത സംഖ്യ അതിന് താങ്ങാവുന്നതിലും അപ്പുറം ആയിപ്പോയി.

ഈ പ്രശ്നം പരിഹരിക്കാന്‍ മൂന്ന് വഴികള്‍ (എങ്കിലും) ഉണ്ട്:

1. range()-ന് പകരം xrange() എന്ന ഏകദം ഉപയോഗിക്കുക. ഇതിന് range എന്ന് എഴുതിയതിന് പകരം xrange എന്ന് ആക്കിയാല്‍ മതിയാകും. range()-ന് സാധിക്കുന്നതിനെക്കാള്‍ വളരെ വലിയ ലിസ്റ്റുകള്‍ കൈകാര്യം ചെയ്യാന്‍ xrange()-ന് കഴിയും.

2. for ഉപയോഗിക്കുന്നതിന് പകരം while ഉപയോഗിക്കുക. ഇങ്ങനെയാകുമ്പോള്‍ 1 മുതല്‍ 600851475143 വരെയുള്ള വലിയ ലിസ്റ്റ് ഉണ്ടാക്കേണ്ടി വരില്ല; ഇതാണല്ലോ ഇപ്പോഴുള്ള പ്രോഗ്രാമിന്റെ പ്രശ്നം. ഇതിന് പകരം ഒരു ചരത്തിന്റെ വില 1 മുതല്‍ 600851475143 വരെ മാറ്റിക്കൊണ്ടിരുന്നാല്‍ മതി.

3. മുകളിലെ രണ്ട് വഴികള്‍ക്കും ഉള്ള ഒരു പ്രശ്നം എന്താണെന്ന് മനസ്സിലാക്കാന്‍ ഇത് കാണുക. 1 മുതല്‍ 600851475143 വരെ ക്രമത്തില്‍ പ്രവര്‍ത്തിക്കുന്ന for അഥവാ while-ന്റെ ഉള്ളടക്കം ഒരു തവണ ചെയ്യാന്‍ കംപ്യൂട്ടര്‍ ഒരു നാനോസെക്കന്റ് എടുക്കുന്നു എന്ന് കരുതുകയാണെങ്കില്‍ പ്രോഗ്രാം മുഴുവന്‍ പ്രവര്‍ത്തിച്ചു തീരാന്‍ പത്ത് മിനിറ്റോളം എടുക്കും. ഒരു മൈക്രോസെക്കന്റ് എടുത്താലോ, ഏഴ് ദിവസവും!. ഇതിന് ഇടയില്‍ എവിടെയെങ്കിലും (രണ്ടാമത്തെ കാലയളവിനോട് അടുത്ത്) ആയിരിക്കും ഈ പ്രോഗ്രാം യഥാര്‍ത്ഥത്തില്‍ എടുക്കുന്ന സമയം. ഇത്ര തവണ ആവര്‍ത്തനം ആവശ്യമില്ലാത്ത തരത്തില്‍ ഉത്തരം കണ്ടുപിടിക്കാന്‍ ഉപയോഗിച്ച രീതി മാറ്റുക എന്നതാണ് മൂന്നാമത്തെ വഴി.

സ്വതവേ തോന്നുന്ന രീതിയില്‍ (naive approach അല്ലെങ്കില്‍ brute force approach എന്ന് ഇംഗ്ളീഷില്‍) ചെയ്താല്‍ ഉത്തരം കിട്ടാതിരിക്കുന്നതുകൊണ്ട് കുറച്ചുകൂടെ ആലോചിച്ച് പ്രോഗ്രാം മാറ്റി എഴുതാന്‍ നമ്മെ പ്രേരിപ്പിക്കാനാണ് പ്രോജക്റ്റ് ഓയ്ലറിലെ പല ചോദ്യങ്ങളിലും ഇതേപോലെയുള്ള വളരെ വലിയ സംഖ്യകള്‍ ഉള്ലത്.

-- ഫിലിപ്പ്

ഫിലിപ്പ് June 12, 2011 at 10:09 PM  

ഭാമ ടീച്ചര്‍,

1, 2, 4 എന്നീ ചോദ്യങ്ങള്‍ക്കായി എഴുതിയ പ്രോഗ്രാമുകള്‍ തികച്ചും ശരിയാണെന്നാണ് എനിക്ക് തോന്നുന്നത്.

-- ഫിലിപ്പ്

bhama June 13, 2011 at 5:33 PM  

പ്രോജക്ട് ഓയിലറിലെ 5 , 6 9 ചോദ്യങ്ങളുടെ ഉത്തരം കണ്ടെത്താനായി എഴുതിയ പ്രോഗ്രാമുകള്‍

xrange എന്ന ഏകദം ഉപയോഗിച്ചപ്പോള്‍ OverflowError: range() result has too many items എന്നു വരുന്നു while ഉപയോഗിച്ചപ്പോള്‍ 10 - 15 മിനിറ്റുനേരം കഴിഞ്ഞിട്ടും ഒരു പ്രവര്‍ത്തനവും കാണുന്നില്ല. IDLE ഹാങ്ങാകുന്നു. എന്തു ചെയ്യണം ??

ഫിലിപ്പ് June 13, 2011 at 8:07 PM  

ഭാമ ടീച്ചര്‍,

മൂന്നാമത്തെ പ്രശ്നത്തിന് --- തന്നിരിക്കുന്ന വളരെ വലിയ സംഖ്യയുടെ ഏറ്റവും വലിയ അഭാജ്യ ഘടകം കണ്ടുപിടിക്കുക --- ഉത്തരം കാണാനുള്ള പ്രോഗ്രാം എഴുതാന്‍ താഴെപ്പറയുന്ന വസ്തുത ഉപയോഗിക്കാം :

ഏത് ഭാജ്യസംഖ്യയ്ക്കും തന്റെ വര്‍ഗമൂലത്തെക്കാള്‍ വലുതല്ലാത്ത ഒരു ഘടകമെങ്കിലും ഉണ്ട്.

ഇത് ഉപയോഗിച്ച് എഴുതുന്ന പ്രോഗ്രാമിന്റെ ഏകദേശ രൂപം ഇങ്ങനെ: തന്നിരിക്കുന്ന സംഖ്യ $x$ ആണെങ്കില്‍ രണ്ടു മുതല്‍ $\lceil\sqrt{x}\,\rceil$ വരെയുള്ള സംഖ്യകളെക്കൊണ്ട് ക്രമത്തില്‍ $x$-നെ ഹരിച്ച് ശിഷ്ടം കാണുക.

1. $a$ എന്ന സംഖ്യയാണ് ആദ്യമായി ശിഷ്ടമില്ലാതെ $x$-നെ ഹരിക്കുന്നതെങ്കില്‍ $a$ അഭാജ്യ സംഖ്യയാണ് (എന്തുകൊണ്ട്?). $x$-ന് ഇതുവരെ കിട്ടിയ അഭാജ്യ ഘടകങ്ങളെക്കാള്‍ വലുതാണ് $a$ എങ്കില്‍ ഇക്കാര്യം ഓര്‍ത്തു വെയ്ക്കുക. ഇനി $x\gets x/a$ എന്ന് വില മാറ്റി ഇതേ കാര്യങ്ങള്‍ ആവര്‍ത്തിക്കുക.

2. ഇക്കൂട്ടത്തില്‍ ഒരു സംഖ്യയും $x$-നെ നിശ്ശേഷം ഹരിക്കുന്നില്ലെങ്കില്‍ $x$ അഭാജ്യമാണ്, $x$ തന്നെയാണ് ഉത്തരവും (എന്തുകൊണ്ട്?).

$\lceil\sqrt{x}\,\rceil$-ന്റെ വില കാണാനായി ഒരു ചരത്തിന്റെ വില ഒന്നു മുതല്‍ അതിന്റെ വര്‍ഗം $x$-നെക്കാള്‍ വലുതോ സമമോ ആകുന്നതു വരെ ഒന്നു വീതം കൂട്ടിക്കൊണ്ടിരുന്നാല്‍ മതിയാകും.

‍ഈ രീതിയില്‍ ഒരു പ്രോഗ്രാം എഴുതി നോക്കൂ. സംശയങ്ങള്‍ ഉണ്ടെങ്കില്‍ ചോദിക്കാന്‍ മടിക്കരുത്!

-- ഫിലിപ്പ്

bhama June 14, 2011 at 7:36 AM  

മൂന്നാമത്തെ പ്രശ്നത്തിന് തന്നിരിക്കുന്ന വളരെ വലിയ സംഖ്യയുടെ ഏറ്റവും വലിയ അഭാജ്യ ഘടകം കണ്ടുപിടിച്ചു. പകുതി വിജയിച്ചു.
പക്ഷേ ഈ
പ്രോഗ്രാം
ഉപയോഗിച്ച് നല്കുന്ന സംഖ്യ അഭാജ്യസംഖ്യ ആണെങ്കില്‍ ശരിയാകുന്നില്ല.

ഫിലിപ്പ് June 14, 2011 at 12:49 PM  

ഭാമ ടീച്ചര്‍,

ഈ പ്രോഗ്രാം എങ്ങനെ ശരിയാക്കാം എന്ന് പറയുന്നതിലും മനസ്സിലാക്കാന്‍ എളുപ്പം ഒരു ഉദാഹരണം കാണുന്നതാണ് എന്ന് തോന്നിയതുകൊണ്ട്, മൂന്നാമത്തെ ചോദ്യത്തിന് ഉത്തരം കണ്ടുപിടിക്കാന്‍ എഴുതിയ ഒരു പ്രോഗ്രാം ഇതാ. ഈ പ്രോഗ്രാം തന്നെ കൂടുതല്‍ കമന്റുകളോടെ ഇവിടെ. ഈ പ്രോഗ്രാമുകളില്‍ while, ബൂളിയന്‍ ചരം എന്നിവ ഉപയോഗിച്ചിരിക്കുന്നത് ശ്രദ്ധിക്കുക. ചരങ്ങള്‍ക്ക് വിവരണാത്മകമായ (descriptive) പേരുകള്‍ കൊടുത്തിരിക്കുന്നതുകൊണ്ട് പ്രോഗ്രാം വായന എളുപ്പമാകുന്നില്ലേ?


-- ഫിലിപ്പ്

bhama June 17, 2011 at 6:53 AM  

മൂന്നാമത്തെ പ്രോഗ്രാം വായിച്ചു മനസ്സിലാക്കി എങ്കിലും അഭാജ്യസംഖ്യ വരുമ്പോള്‍ എവിടെയോ ഒരു സംശയം. അതുകൊണ്ടാണെന്നു തോന്നുന്നു 7ാം ചോദ്യത്തില്‍ ഉടക്കി നില്‍ക്കുന്നു.എങ്കിലും ശ്രമം തുടരുന്നു.

8ാം ചോദ്യത്തിനുള്ള പ്രോഗ്രാം

ഫിലിപ്പ് June 17, 2011 at 7:38 PM  

അഞ്ചാമത്തെ പ്രശ്നത്തിനുള്ള പ്രോഗ്രാം ഉത്തരമായി തരുന്ന ഏറ്റവും ചെറിയ സംഖ്യയുടെ പകുതി വരുന്ന സംഖ്യയെയും ഒന്നു മുതല്‍ ഇരുപതു വരെയുള്ള എല്ലാ സംഖ്യകളെക്കൊണ്ടും നിശ്ശേഷം ഹരിക്കാമല്ലോ. പ്രോഗ്രാമില്‍ എന്താണ് പ്രശ്നം?

മറ്റ് പ്രോഗ്രാമുകള്‍ എല്ലാം ശരിയാണ്.

-- ഫിലിപ്പ്

ഫിലിപ്പ് June 17, 2011 at 8:19 PM  

ഭാമ ടീച്ചര്‍,

പ്രോജക്റ്റ് ഓയ്ലറിലെ ഏഴാമത്തെ പ്രശ്നത്തിന് ഉത്തരം കണ്ടുപിടിക്കാന്‍ ഇറാറ്റോസ്തനീസിന്റെ അരിപ്പയും അഭാജ്യ സംഖ്യാ പ്രമേയത്തിന്റെ അനുപ്രമേയവും ഉപയോഗിച്ച് ശ്രമിച്ചുനോക്കൂ.

-- ഫിലിപ്പ്

bhama June 18, 2011 at 2:20 PM  

അഞ്ചാമത്തെ പ്രശ്നത്തിനുള്ള പ്രോഗ്രാം ഉത്തരമായി തരുന്ന ഏറ്റവും ചെറിയ സംഖ്യയുടെ പകുതി വരുന്ന സംഖ്യയെ 16 കൊണ്ട് നിശ്ശേഷം ഹരിക്കാന്‍ കഴിയില്ലല്ലോ .

bhama June 18, 2011 at 2:40 PM  

പ്രോജക്ട് ഓയിലറിലെ 13 , 16 , 20 ചോദ്യങ്ങളുടെ ഉത്തരം കണ്ടെത്താനായി എഴുതിയ പ്രോഗ്രാമുകള്‍

bhama June 18, 2011 at 3:15 PM  

പൈത്തണ്‍ പ്രോഗ്രാമിന്റെ പ്രവര്‍ത്തനം ഇടയ്ക്കുവച്ചു നിര്‍ത്തുവാന്‍ എന്തു ചെയ്യണം ?
പ്രോഗ്രാമിലെ തെറ്റുകാരണമാകാം പ്രോഗ്രാം പ്രവര്‍ത്തിപ്പിക്കുന്ന അവസരത്തില്‍ ചിലപ്പോഴെല്ലാം idle ഹാങ്ങാകുന്നു. അതിന് എന്തുചെയ്യാം?

bhama June 18, 2011 at 7:37 PM  

പ്രോജക്ട് ഓയിലറിലെ 16 ാം ചോദ്യത്തിന്റെ ഉത്തരം കണ്ടെത്താനായി എഴുതിയ പ്രോഗ്രാം

ഫിലിപ്പ് June 20, 2011 at 10:56 AM  

ശരിയാണ് ഭാമ ടീച്ചര്‍. അഞ്ചാമത്തെ പ്രശ്നത്തിനുള്ല പ്രോഗ്രാമിന്റെ 23-ല്‍ തുടങ്ങുന്ന ഔട്പുട്ട് ഞാന്‍ മുമ്പ് ശ്രദ്ധിച്ചില്ല.

പ്രോഗ്രാമിന്റെ പ്രവര്‍ത്തനം ഇടയ്ക്കുവച്ച് നിര്‍ത്താനായി Ctrl-C (Ctrl, c എന്നീ കീകള്‍ ഒരുമിച്ച് അമര്‍ത്തുന്നത്) പ്രയോഗിക്കാം. ഇന്‍പുട്ട് കൊടുക്കുന്ന സ്ഥലത്ത് ശ്രദ്ധ (focus) ഉള്ളപ്പോള്‍ വേണം ഇത് പ്രയോഗിക്കാന്‍. ഇന്‍പുട് ആയി Ctrl-C കൊടുക്കുന്നു എന്ന് കരുതാം.

ഇങ്ങനെ ചെയ്തിട്ടും IDLE പ്രവര്‍ത്തനം നിര്‍ത്തുന്നില്ലെങ്കില്‍ IDLE-നെ കൊന്നുകളയുക എന്ന അറ്റകൈ പ്രയോഗം നടത്താം. ഇതിനായി ഒരു ടെര്‍മിനലില്‍ killall -9 idle എന്ന കമാന്റ് ഉപയോഗിക്കാം.

ഈ killall കമാന്റ് കിറുങ്ങി നില്‍ക്കുന്ന ഏത് പ്രോഗ്രാമിനെ കൊന്നുകളയാനും ഉപയോഗിക്കാം. ഉദാഹരണത്തിന് ഫയര്‍ഫോക്സിനെ കൊന്നുകളയാനായി killall -9 firefox എന്ന് ടെര്‍മിനലില്‍ കൊടുത്താല്‍ മതിയാകും.

13, 16, 20 എന്നീ ചോദ്യങ്ങള്‍ക്കുള്ള പ്രോഗ്രാമുകള്‍ ശരിയാണ്. പതിമൂന്നാമത്തെ ചോദ്യത്തിനുള്ള പ്രോഗ്രാമില്‍ x എന്ന ചരത്തിന്റെ ആവശ്യമില്ല (ഉള്ലതുകൊണ്ട് കുഴപ്പവുമില്ല). y = int(i) എന്ന് നേരിട്ട് പ്രയോഗിക്കാം. കുറച്ചുകൂടി ചുരുക്കണമെങ്കില്‍ y എന്ന ചരവും ഒഴിവാക്കാം : sum = sum + int(i) എന്ന് പ്രയോഗിച്ചാല്‍ മതി. ഇതേപോലെ തന്നെ മറ്റു രണ്ട് പ്രോഗ്രാമുകളിലും. ഇപ്പോഴുള്ല രീതിയില്‍ എഴുതുന്നതുകൊണ്ടും കുഴപ്പമൊന്നും ഇല്ല, വായിച്ചു മനസ്സിലാക്കാന്‍ കൂടുതല്‍ എളുപ്പമാണുതാനും.

പതിനാറാമത്തെ ചോദ്യത്തിനുള്ള രണ്ടാമത്തെ പ്രോഗ്രാമില്‍ ഒരു തെറ്റുണ്ട്. എന്താണെന്ന് നോക്കാമോ?

--ഫിലിപ്പ്

bhama June 20, 2011 at 2:27 PM  

പതിനാറാമത്തെ ചോദ്യത്തിനുള്ള രണ്ടാമത്തെ പ്രോഗ്രാമില്‍ ശരിയായ ഉത്തരം കിട്ടുന്നുണ്ടല്ലോ . തെറ്റി കണ്ടെത്താനായില്ല.

bhama June 21, 2011 at 7:54 PM  

പ്രോജക്റ്റ് ഓയ്ലറിലെ ഏഴാമത്തെ പ്രശ്നത്തിന് ഉത്തരം കണ്ടെത്തിയ സന്തോഷത്തില്‍ !

ഫിലിപ്പ് June 21, 2011 at 8:51 PM  

ടീച്ചര്‍,

നന്നായിട്ടുണ്ട്, അഭിനന്ദനങ്ങള്‍!

ഇതേ ചോദ്യത്തിന് വേറൊരു രീതിയില്‍ എഴുതിയ പ്രോഗ്രാം ഇതാ.

പതിനാറാമത്തെ ചോദ്യത്തിന് ടീച്ചര്‍ എഴുതിയ ഈ പ്രോഗ്രാമും ഇതും രണ്ട് ഉത്തരങ്ങളാണല്ലോ തരുന്നത്? ഇതില്‍ ഏതാണ് ശരി?

--ഫിലിപ്പ്

bhama June 21, 2011 at 10:07 PM  

പതിനാറാമത്തെ ചോദ്യത്തിനുള്ള രണ്ടാമത്തെ പ്രോഗ്രാമിലെ തെറ്റ് തിരുത്തിയത്

ഇപ്പോള്‍ രണ്ടു പ്രോഗ്രാമിലും ഒരേ ഉത്തരം

bhama June 21, 2011 at 10:46 PM  

പ്രോജക്റ്റ് ഓയ്ലറിലെ പത്താമത്തെ പ്രശ്നത്തിന് എഴുതിയ ഈ പ്രോഗ്രാം ഉത്തരത്തിലെത്തുന്നതിന് 10 മിനിറ്റ് എടുക്കുന്നു. ഇതിലും വേഗത്തില്‍ ചെയ്യാന്‍ കഴിയുമോ ?

ഫിലിപ്പ് June 21, 2011 at 11:07 PM  

പത്താമത്തെ പ്രശ്നത്തിനുള്ള പ്രോഗ്രാമില്‍ അഭാജ്യങ്ങള്‍ ഓരോന്നായി കണ്ടുപിടിക്കുന്നതുകൊണ്ടാണ് ഇത്രയും സമയമെടുക്കുന്നത്. ഈ പ്രോഗ്രാമില്‍ ചെയ്ത രീതിയില്‍ ഇറാറ്റോസ്തനീസിന്റെ അരിപ്പയും അഭാജ്യ സംഖ്യാ പ്രമേയത്തിന്റെ അനുപ്രമേയവും ഉപയോഗിച്ചാല്‍ ഇതിലും വളരെ വേഗത്തില്‍ ഉത്തരം കിട്ടേണ്ടതാണ്.

ഫിലിപ്പ് June 21, 2011 at 11:16 PM  

പത്താമത്തെ പ്രശ്നത്തിന് അരിപ്പ മാത്രം മതി; കിട്ടേണ്ട ഏറ്റവും വലിയ അഭാജ്യത്തിന്റെ ഏകദേശവില ചോദ്യത്തില്‍ത്തന്നെ ഉണ്ടല്ലോ.

bhama July 14, 2011 at 9:33 PM  

The area and perimeter of a triangle with sides 5,5,6 and a rectangle with sides 6,2 are 12 ,16 respectively. (the area and perimeter same). Find other sets of triangle and rectangle with same area and perimeter?

വിജയന്‍ സാറിന്റ ഈ ചോദ്യത്തിന് ഉത്തരം കണ്ടത്താനായി എഴുതിയ പ്രോഗ്രാമാണ് ഇത്

ഫിലിപ്പ് July 17, 2011 at 9:29 AM  

ഭാമ ടീച്ചര്‍,

ടീച്ചര്‍ എഴുതിയ ഈ പ്രോഗ്രാമും പസിലുകളുടെ ഉത്തരം കണ്ടുപിടിക്കാനായി എഴുതിയ മറ്റ് പ്രോഗ്രാമുകളും കണ്ടു. നന്നായിട്ടുണ്ട്, അഭിനന്ദനങ്ങള്‍.

-- ഫിലിപ്പ്

bhama July 17, 2011 at 6:38 PM  

Thank you sir.

പ്രോജക്ട് ഓയിലറിലെ 14ാം ചോദ്യത്തില്‍ ഉടക്കി നില്ക്കുന്നു.

ഫിലിപ്പ് July 18, 2011 at 11:36 AM  

പതിന്നാലാം ചോദ്യത്തിനുള്ള പ്രോഗ്രാമില്‍ എവിടെയാണ് പ്രശ്നം? ഒരു സംഖ്യ ഇന്‍പുട്ട് ആയി എടുത്ത് ആ സംഖ്യയുടെ ചങ്ങലയുടെ നീളം കണ്ടുപിടിക്കാനുള്ള പ്രോഗ്രാം എഴുതാമോ?

-- ഫിലിപ്പ്

bhama July 19, 2011 at 6:54 PM  
This comment has been removed by the author.
bhama July 21, 2011 at 6:03 PM  

പ്രോജക്ട് ഓയിലറിലെ 14ാം ചോദ്യത്തിനുള്ള പ്രോഗ്രാം

bhama July 22, 2011 at 6:19 AM  

പ്രോജക്ട് ഓയിലറിലെ 12ാം ചോദ്യത്തിനായി എഴുതിയ പ്രോഗ്രാം

ഇതില്‍ 12 ാം ചോദ്യത്തിനുള്ള ഉത്തരം മാത്രം കിട്ടുന്നില്ല. 200 ഘടകങ്ങള്‍ ഉള്ളതുവരെ കണ്ടെത്തി. 500 കൊടുത്താല്‍ 2 മണിക്കൂര്‍ കഴിഞ്ഞിട്ടും ഔട്ട്പുട്ട് കിട്ടുന്നില്ല.
പ്രോഗ്രാമില്‍ എന്താണു പ്രശ്നം ?

ഫിലിപ്പ് July 22, 2011 at 12:41 PM  

പതിനാലാമത്തെ ചോദ്യത്തിന്റെ ഉത്തരം വളരെ നന്നായിരിക്കുന്നു : ഒരു കഥ പോലെ വായിക്കാവുന്ന തരത്തില്‍ ടീച്ചര്‍ എഴുതിയിട്ടുണ്ട്.

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

1. പ്രോഗ്രാം മൊത്തമായി പ്രവര്‍ത്തിച്ച് തീരുമ്പോഴേക്കും പ്രോഗ്രാമിലെ 36-മത്തെ വരി എത്ര പ്രാവശ്യം ആവര്‍ത്തിച്ചിരിക്കും? "ഇത്ര പ്രാവശ്യമെങ്കിലും" എന്ന തരത്തിലുള്ള ഒരു ഏകദേശ കണക്കാണ് ഉദ്ദേശിക്കുന്നത്. വലിയ കൃത്യത വേണമെന്നില്ല : പത്തിന്റെ കൃതി ആയാലും മതി.

2. നമ്മുടെ കംപ്യൂട്ടറുകളിലെ പ്രോസസറുകള്‍ ഇപ്പോള്‍ ഗിഗാഹെര്‍ട്സ് വേഗതയിലാണല്ലോ പ്രവര്‍ത്തിക്കുന്നത്? ഗിഗാഹെര്‍ട്സ് എന്നാല്‍ ഒരു സെക്കന്റില്‍ $10^{9}$ തവണ എന്നര്‍ത്ഥം. ഒരു സെക്കന്റിന്റെ $10^{9}$-ല്‍ ഒരു അംശമായ ഒരു നാനോസെക്കന്റില്‍ പ്രോസസറിന് തന്റെ നിര്‍ദ്ദേശപ്പട്ടികയിലുള്ള (instruction set) ഒരു ക്രിയ ചെയ്യാന്‍ കഴിയും എന്നാണ് ഇതിന്റെ ഏകദേശ അര്‍ത്ഥം. നമ്മുടെ പ്രോഗ്രാമിലെ 36-മത്തെ വരി ഈ പട്ടികയിലുളള കുറെയേറെ നിര്‍ദ്ദേശങ്ങളായി തര്‍ജ്ജമ ചെയ്തിട്ടാണ് പ്രോസസര്‍ നടപ്പിലാക്കുന്നത്. എന്നിരുന്നാലും കണക്കുകൂട്ടാനുള്ള എളുപ്പത്തിനായി ഈ വരി ഒരു നാനോസെക്കന്റില്‍ കമ്പ്യൂട്ടര്‍ നടപ്പിലാക്കുന്നു എന്നു കരുതുക. ഇങ്ങനെയാണെങ്കില്‍ പ്രോഗ്രാമിന്റെ മൊത്തം പ്രവര്‍ത്തനത്തില്‍ ഈ വരി മാത്രം നടപ്പിലാക്കാന്‍ എത്ര സെക്കന്റ് വേണമെന്നാണ് ഒന്നാമത്തെ ചോദ്യത്തിന്റെ ‍ഉത്തരം സൂചിപ്പിക്കുന്നത്? എത്ര ദിവസമാണിത്? എത്ര വര്‍ഷം?


(സെക്കന്റുകളെ ദിവസവും വര്‍ഷവുമൊക്കെയാക്കാന്‍ ഗൂഗിളിനോട് ചോദിച്ചാല്‍ മതി: 1 year in seconds എന്ന രീതിയില്‍)

ടീച്ചറുടെ പ്രോഗ്രാമിന് കുഴപ്പമൊന്നുമില്ല. പക്ഷേ അതിന്റെ പിന്നിലുള്ള ആശയം (അല്ഗോരിതം എന്ന് ശാസ്ത്രനാമം) ഉപയോഗിച്ച് ഈ പ്രശ്നത്തിന് ഉത്തരം കണ്ടുപിടിക്കാന്‍ വളരെയേറെ സമയം എടുക്കും. കുറച്ചുകൂടി ആലോചിച്ച് ഇതിനെക്കാള്‍ വേഗത്തില്‍ പ്രവര്‍ത്തിക്കുന്ന മറ്റൊരു അല്ഗോരിതം കണ്ടുപിടിക്കുക എന്നതാണ് പോംവഴി. ടീച്ചര്‍ ഉപയോഗിച്ച അല്ഗോരിതം നമുക്ക് ഒറ്റനോട്ടത്തില്‍ തോന്നുന്ന രീതി ആണല്ലോ : ചോദ്യത്തില്‍ നിന്ന് നേരിട്ട് കിട്ടുന്ന -- naive, straightforward, brute force എന്നൊക്കെ ഇംഗ്ലീഷില്‍ വിവക്ഷിക്കുന്ന -- ആശയമാണിത്. ഗണിതതത്വങ്ങള്‍ കൂടെ ഉപയോഗിച്ചുള്ള മറ്റ് രീതികള്‍ പ്രയോഗിച്ചാല്‍ ഇതിലും വളരെ വേഗം ഉത്തരം കിട്ടേണ്ടതാണ്. ഉസാഘ കണ്ടുപിടിക്കാനുള്ള naive അല്ഗോരിതവും യൂക്ളിഡിന്റെ അല്ഗോരിതവും തമ്മിലുള്ള വേഗവ്യത്യാസം ഓര്‍ക്കുക.

-- ഫിലിപ്പ്

bhama July 25, 2011 at 10:46 PM  

12ാം ചോദ്യം മുഴുവനാക്കിയ്ല്ല. ഒന്നുകൂടി ശ്രദ്ധിച്ചിരിക്കണം. അതിനിടയില്‍ 48ാം ചോദ്യത്തിന് ഉത്തരം കണ്ടെത്തിയത് ഇങ്ങനെ

bhama July 26, 2011 at 8:01 PM  

പ്രോജക്ട് ഓയിലറിലെ 25ാം ചോദ്യത്തിനായി എഴുതിയ പ്രോഗ്രാം

ഫിലിപ്പ് July 27, 2011 at 8:38 PM  

25-മത്തെ ചോദ്യത്തിനുള്ള പ്രോഗ്രാമിനെപ്പറ്റി :

1. ഇവിടെ num എന്ന ചരം ട്രാഫിക് പോലീസുകാരന്റെ കൈയിലെ STOP ചിഹ്നം പോലെയോ, ഫുട്ബോള്‍ റഫറിയുടെ വിസില്‍ പോലെയോ ആണല്ലോ ഉപകരിക്കുന്നത്? ഇങ്ങനെയുള്ളപ്പോള്‍ ഒരു ബൂളിയന്‍ ചരം ഉപയോഗിക്കുന്നതാണ് നല്ല ശൈലി. ഉദാഹരണത്തിന്, found എന്ന ബൂളിയന്‍ ചരം ഉപയോഗിക്കുകയാണെങ്കില്‍ num = 0 എന്നതിന് പകരം found = False എന്ന് തുടക്കത്തിലും, while num == 0 എന്നതിനു പകരം while not found എന്നും എഴുതാം. num = 1 എന്ന് പറയുന്നിടത്ത് found = True എന്നും.

2. പുതുതായി കിട്ടിയ ഫിബോനാച്ചി സംഖ്യയ്ക്ക് ആയിരത്തിലധികം അക്കങ്ങള്‍ ഉണ്ടോ എന്ന് അറിയാന്‍ അത് 10 ** 999-നോളമെങ്കിലും വരുമോ എന്ന് നോക്കിയാല്‍ മതിയാകില്ലേ?

bhama July 29, 2011 at 9:48 PM  
This comment has been removed by the author.
bhama July 29, 2011 at 9:50 PM  
This comment has been removed by the author.
bhama July 29, 2011 at 10:04 PM  

25ാം ചോദ്യത്തിന് സാറു പറഞ്ഞരീതിയില്‍ എഴുതിയപ്പോള്‍ ഞാനെഴുത്യതിനേക്കാള്‍ പത്തുസ്റ്റെപ്പോളം കുറവുമതി ഉത്തരത്തിലെത്താന്‍ .മാറ്റി എഴുതിയ പ്രോഗ്രാം.
12ാം ചോദ്യം ഇനിയും മുഴുവനാക്കിയില്ല
21ാം ചോദ്യത്തിന് എഴുതിയ പ്രോഗ്രാം

DILEESH October 25, 2011 at 8:13 AM  

hai...dileesh ek .new in 'mathsblog'.works as a lab asst.i am going to make a blog for "Advanced Linux scripting and Ubuntu administration soon...."
philip sir,ur great....its a great effort....why dnt u make a website for tutorial python

ഫിലിപ്പ് October 25, 2011 at 12:10 PM  

Dileesh,

Good luck with your efforts for the blog.

There are any number of good Python tutorials already available online. Swaroop's "A Byte of Python" is highly recommended.

Unnikrishnan,Valanchery December 20, 2011 at 10:28 PM  
This comment has been removed by the author.
Unnikrishnan,Valanchery December 20, 2011 at 10:30 PM  
This comment has been removed by the author.
mps May 17, 2012 at 3:57 PM  

mps


Where will we get wxGlade materials ?

ഫിലിപ്പ് May 17, 2012 at 4:25 PM  

mps,

See if these help:

1. The wxGlade user manual

2. A getting started guide for wxPython

Regards,
Philip

mps May 25, 2012 at 9:30 PM  

philip sir,
Thank you very much for ur reply.

how can we use the find function (which is equivalent to inStr function in other languages) in python.

i tried it as follows:
a='peruvallur'
b='uv'
k=find(a,b)
but didn't work.

ഫിലിപ്പ് May 26, 2012 at 1:31 AM  

mps,

Please try

...
k = a.find(b)

See this for similar functions.

-- Philip

പകര്‍പ്പവകാശ സൂചന

SyntaxHighlighter