Java/C2/do-while/Malayalam

From Script | Spoken-Tutorial
Jump to: navigation, search
Time Narration
00:01 Javaയിലെ do-while Loop എന്ന സ്പോകെന്‍ ട്യൂട്ടോറിയലിലേക്ക് സ്വാഗതം.
00:06 ഇവിടെ പഠിക്കുന്നത്,

do-while loop അതിന്റെ ഉപയോഗം

00:12 ഇതിനായി ഉപയോഗിക്കുന്നത്

Ubuntu 11.10

JDK 1.6

Eclipse 3.7

00:20 ഇതിനായി Javaയിലെ while loop അറിഞ്ഞിരിക്കണം.
00:25 അറിയില്ലെങ്കിൽ അതുമായി ബന്ധപ്പെട്ട ട്യൂട്ടോറിയലുകൾക്കായി ഈ വെബ്സൈറ്റ് സന്ദർശിക്കുക.
00:32 ഇതാണ് do-while loopന്റെ ഘടന.
00:37 ഇത് while loopന് സമാനമാണ്.
00:40 ഇതിന് രണ്ട് ഭാഗങ്ങൾ ഉണ്ട്.
00:42 ആദ്യത്തേത് loop running കണ്‍ഡിഷൻ. രണ്ടാമത്തേത് loop വേരിയബിൾ.
00:51 ഒരേ ഒരു വ്യത്യാസം കണ്‍ഡിഷൻ എഴുതുന്നത് do ബ്ലോക്കിന് ശേഷമാണ് എന്നതാണ്.
00:58 അതായത്, do ബ്ലോക്കിനുള്ളിലെ statements എക്സിക്യൂട്ട് ചെയ്തതിന് ശേഷം കണ്‍ഡിഷൻ പരിശോധിക്കുന്നു.
01:05 ഇപ്പോൾ ഒരു ഉദാഹരണം നോക്കാം.
01:07 eclipseലേക്ക് പോകുക.
01:11 ഇവിടെ നമുക്ക് Eclipse IDEയും ബാക്കിയുള്ള കോഡിന് ആവശ്യമായ ഘടനയും ഉണ്ട്.
01:17 DoWhileDemo എന്ന ക്ലാസ്സ്‌ സൃഷ്ടിച്ച് അതിൽ main method ചേർത്തിട്ടുണ്ട്.
01:22 ഇവിടെ, 1 മുതൽ 10 വരെയുള്ള സംഖ്യകൾ do-while loop ഉപയോഗിച്ച് പ്രിന്റ്‌ ചെയ്യുന്നു.
01:27 ടൈപ്പ് ചെയ്യുക,
01:29 int n equalto 1
01:32 n ആണ് loop വേരിയബിൾ.
01:36 എന്നിട്ട് do.
01:40 braces തുറക്കുകയും അടയ്ക്കുകയും ചെയ്യുക.
01:44 bracesനുള്ളിൽ System.out.println(n);
01:55 nന്റെ മൂല്യം പ്രിന്റ്‌ ചെയ്തിട്ട് അത് വർദ്ധിപ്പിക്കുന്നു. n equalto n plus 1;
02:05 ഇത് n പത്തോ അതിനെക്കാൾ ചെറുതോ ആയിരിക്കുന്നിടത്തോളം ചെയ്തു കൊണ്ടിരിക്കുന്നു.
02:10 bracesന് പുറത്ത് ടൈപ്പ് ചെയ്യുക while പരാൻതീസിസിനുള്ളിൽ (n less than equal to 10)
02:20 എന്നിട്ട് semi-colon കൊടുക്കുന്നു.
02:25 കോഡ് പ്രവർത്തിപ്പിച്ച് നോക്കാം.
02:28 സേവ് ചെയ്ത് റണ്‍ ചെയ്യുക.
02:37 1 മുതൽ 10 വരെയുള്ള സംഖ്യകൾ പ്രിന്റ്‌ ചെയ്യുന്നത് കാണാം.
02:42 ഇപ്പോൾ കോഡിന്റെ എക്സിക്യൂഷൻ മനസിലാക്കാം.
02:47 ആദ്യം 1ന്റെ മൂല്യം പ്രിന്റ്‌ ചെയ്തിട്ട് n, 2 ആകുന്നു.
02:52 എന്നിട്ട് കണ്‍ഡിഷൻ പരിശോധിക്കുന്നു.
02:55 ഇത് true ആയതിനാൽ വീണ്ടും 2 പ്രിന്റ്‌ ചെയ്തിട്ട് n, 3 ആകുന്നു.
03:00 അങ്ങനെ പത്ത് വരെയുള്ള എല്ലാ സംഖ്യകളും പ്രിന്റ്‌ ചെയ്തതിന് ശേഷം nന്റെ മൂല്യം 11 ആകുന്നു.
03:06 n = 11 ആകുമ്പോൾ കണ്‍ഡിഷൻ false ആകുകയും loop അവസാനിക്കുകയും ചെയ്യുന്നു.
03:11 ഇപ്പോൾ 50 മുതൽ 40 വരെയുള്ള സംഖ്യകൾ പ്രിന്റ്‌ ചെയ്യാം.
03:17 അതിനായി 50ൽ നിന്ന് തുടങ്ങുന്നു.
03:19 n = 1നെ n = 50 ആക്കുക.
03:23 വലിയ സംഖ്യയിൽ നിന്ന് ചെറിയ സംഖ്യയിലേക്ക് loop പുരോഗമിക്കേണ്ടതിനാൽ, ഇവിടെ loop വേരിയബിളിൽ കുറവ് വരുത്തുന്നു.
03:29 n = n + 1നെ n = n – 1 ആക്കുക.
03:34 n 40ഓ അതിനെക്കാൾ കൂടുതലോ ആയിരിക്കുന്നിടത്തോളം loop റണ്‍ ചെയ്യുന്നു.
03:40 അതിനായി n >= 40 എന്ന കണ്‍ഡിഷൻ കൊടുക്കുക.
03:48 ഔട്ട്‌പുട്ട് നോക്കാം.
03:50 സേവ് ചെയ്ത് റണ്‍ ചെയ്യുക.
03:57 50 മുതൽ 40 വരെയുള്ള സംഖ്യകൾ പ്രിന്റ്‌ ചെയ്യുന്നത് കാണാം.
04:02 do-while loop ഉപയോഗിക്കുന്ന ഒരു വ്യത്യസ്ഥമായ logic പരിശോധിക്കാം.
04:10 ഒരു സംഖ്യ പൂർണ്ണ വർഗമാണോ അല്ലയോ എന്ന് പരിശോധിക്കുന്നു.
04:15 ആദ്യം main method വൃത്തിയാക്കുക.
04:19 എന്നിട്ട് ടൈപ്പ് ചെയ്യുക int n = 25;
04:25 n ന്റെ മൂല്യം പൂർണ്ണ വർഗമാണോ അല്ലെയോ എന്ന് പരിശോധിക്കുന്നു.
04:32 എന്നിട്ട് ടൈപ്പ് ചെയ്യുക int x = 0;
04:37 നമ്മുടെ സംഖ്യ പൂർണ്ണ വർഗമാണെങ്കിൽ അതിന്റെ വർഗ മൂലം സ്റ്റോർ ചെയ്യാൻ x ഉപയോഗിക്കുന്നു.
04:44 ടൈപ്പ് ചെയ്യുക do
04:46 Braces തുറക്കുകയും അടക്കുകയും ചെയ്യുക.
04:49 bracesനുള്ളിൽ x equal to x plus 1
04:55 bracesന് പുറത്ത്
04:58 while പരാൻതീസിസിനുള്ളിൽ (x into x < n)
05:06 semi colon കൊടുക്കുക.
05:10 x into x , n നെക്കാൾ ചെറുതായിരിക്കുന്നിടത്തോളം xന്റെ മൂല്യം വർദ്ധിപ്പിച്ചു കൊണ്ടിരിക്കുന്നു.
05:16 loop അവസാനിക്കുമ്പോൾ ഈ കണ്‍ഡിഷൻ false ആകുന്നു.
05:22 അതായത് x into x, nന് സമമോ അതിനെക്കാൾ വലുതോ ആയിരിക്കും.
05:28 x into x, nന് സമമാണെങ്കിൽ നമ്മുടെ സംഖ്യ പൂർണ്ണ വർഗം ആയിരിക്കും.
05:32 ഇത് nന് സമമല്ലെങ്കിൽ സംഖ്യ പൂർണ്ണ വർഗം ആയിരിക്കില്ല.
05:37 അവസാനമായി ഈ കണ്‍ഡിഷൻ പ്രിന്റ്‌ ചെയ്യുന്നു.
05:47 System.out.println(x * x == n);
05:55 കോഡ് പ്രവർത്തിപ്പിച്ച് നോക്കാം.
05:59 സേവ് ചെയ്ത് റണ്‍ ചെയ്യുക. ഔട്ട്‌പുട്ട് true ആണെന്ന് കാണാം.
06:07 മറ്റൊരു പൂർണ്ണ വർഗ സംഖ്യ കൊടുക്കാം.
06:10 n = 25നെ n = 49 ആക്കുക.
06:15 സേവ് ചെയ്ത് റണ്‍ ചെയ്യുക.
06:20 വീണ്ടും true ലഭിക്കുന്നു.
06:23 പൂർണ്ണ വർഗം അല്ലാത്ത ഒരു സംഖ്യ കൊടുക്കാം.
06:26 49നെ 23 ആക്കുക. സേവ് ചെയ്ത് റണ്‍ ചെയ്യുക.
06:34 പ്രതീക്ഷിച്ചത് പോലെ false കിട്ടുന്നു.
06:37 nന്റെ മൂല്യം പൂജ്യം ആണെങ്കിൽ എന്ത് സംഭവിക്കും എന്ന് നോക്കാം.
06:42 n = 23യെ n = 0 ആക്കുക. 0 ഒരു natural number അല്ലാത്തതിനാൽ നമുക്ക് false കിട്ടണം.
06:52 കോഡ് റണ്‍ ചെയ്ത് നോക്കാം.
06:54 സേവ് ചെയ്ത് റണ്‍ ചെയ്യുക.
07:00 പ്രതീക്ഷിച്ചത് പോലെ false കിട്ടുന്നത് കാണാം.
07:05 ഇങ്ങനെ സംഭവിച്ചതിന് കാരണം കണ്‍ഡിഷൻ, x into x is less than n, പരിശോധിക്കുന്നതിന് മുൻപ് തന്നെ xന്റെ മൂല്യം ഒരു തവണ വർദ്ധിപ്പിച്ച് കഴിയുന്നു.
07:16 Loop കണ്‍ഡിഷൻ പരാജയപ്പെടുന്നതിനാൽ loop പിന്നീട് റണ്‍ ചെയ്യുന്നില്ല.
07:20 ഇങ്ങനെ, do-while loop ഉപയോഗിച്ച് പൂജ്യത്തെ ഒരു പൂർണ്ണ വർഗമായി പരിഗണിക്കുന്നില്ല എന്ന് നമ്മൾ ഉറപ്പ് വരുത്തുന്നു.
07:26 ഇത് പോലെ do while loop പല തരത്തിലുള്ള പ്രശ്നങ്ങൾ പരിഹരിക്കാൻ ഉപയോഗിക്കുന്നു.
07:31 പ്രത്യേകിച്ച് loop ഒരു തവണ എങ്കിലും റണ്‍ ചെയ്യേണ്ട അവസരങ്ങളിൽ.
07:37 ഇതോടെ ട്യൂട്ടോറിയലിന്റെ അവസാന ഭാഗത്ത്‌ എത്തിയിരിക്കുന്നു.
07:40 ഇവിടെ പഠിച്ചത്,
07:42 do-while loopഉം അത് ഉപയോഗിക്കുന്നതും.
07:46 ഒരു അസ്സൈൻമെന്റ്, താഴെ പറയുന്ന പ്രശ്നങ്ങൾ പരിഹരിക്കുക.
07:50 ഒരു ബൈനറി നമ്പർ തന്നാൽ അതിന് സമാനമായ decimal number കണ്ടെത്തുക. ഉദാഹരണം 11010 ആണെങ്കിൽ 26.
07:56 സ്പോകെന്‍ ട്യൂട്ടോറിയൽ പ്രൊജക്റ്റിനെ കുറിച്ച് കൂടുതൽ അറിയുന്നതിനായി, ഇവിടെ ലഭ്യമായ വീഡിയോ കാണുക.
08:01 ഇത് സ്പോകെന്‍ ട്യൂട്ടോറിയൽ പ്രൊജക്റ്റിനെ സംഗ്രഹിക്കുന്നു. നല്ല ബാന്‍ഡ് വിഡ്ത്ത് ഇല്ലെങ്കില്‍, ഡൌണ്‍ലോഡ് ചെയ്ത് കാണാവുന്നതാണ്.
08:06 സ്പോകെന്‍ ട്യൂട്ടോറിയല്‍ പ്രൊജക്റ്റ്‌ ടീം,
08:10 സ്പോകെന്‍ ട്യൂട്ടോറിയലുകള്‍ ഉപയോഗിച്ച് വര്‍ക്ക് ഷോപ്പുകള്‍ നടത്തുന്നു. ഓണ്‍ലൈന്‍ ടെസ്റ്റ്‌ പാസ്സാകുന്നവര്‍ക്ക് സര്‍ട്ടിഫികറ്റുകള്‍ നല്കുന്നു.
08:16 കൂടുതൽ വിവരങ്ങൾക്കായി ഈ വെബ്സൈറ്റ് സന്ദർശിക്കുക
08:22 സ്പോകെന്‍ ട്യൂട്ടോറിയല്‍ പ്രൊജക്റ്റ്‌, ടോക്ക് ടു എ ടീച്ചര്‍ പ്രൊജക്റ്റിന്റെ ഭാഗമാണ്. ഇതിനെ പിന്താങ്ങുന്നത് "നാഷണല്‍ മിഷന്‍ ഓണ്‍ എഡ്യൂക്കേഷന്‍ ത്രൂ ICT, MHRD, ഗവന്മെന്റ് ഓഫ് ഇന്ത്യ".
08:32 ഈ മിഷനെ കുറിച്ചുള്ള കുടുതല്‍ വിവരങ്ങള്‍ ഇവിടെ ലഭ്യമാണ്.
08:36 ഞാൻ ദേവി സേനന്‍, IIT Bombay. നന്ദി.

Contributors and Content Editors

Devisenan, Gaurav, Pratik kamble