Java/C2/do-while/Malayalam

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