Java/C2/while-loop/Telugu

Time	Narration
00:02	జావా లోని వైల్ లూప్ అనే స్పోకెన్ టుటోరియల్ కు స్వాగతం.
00:06	ఈ టుటోరియల్ లో మీరు వైల్ లూప్ గురించి మరియు దానిని ఎలా ఉపయోగించాలి అనేది నేర్చుకుంటారు.
00:12	ఈ టుటోరియల్ కొరకు మనం ఉబంటు 11.10, జే‌డి‌కే1.6 మరియు ఎక్లిప్స్3.7 ఉపయోగిస్తున్నాం.
00:21	ఈ టుటోరియల్ ను అనుసరించడానికి మీకు జావా లోని రిలేషనల్ ఆపరేటర్స్ పై అవగాహన ఉండాలి.
00:26	లేదంటే, తత్సంభందిత టుటోరియల్ కొరకు మా వెబ్సైట్ ను సంప్రదించండి. [1]
00:36	ఇది వైల్ లూప్ అమరిక. ఇక్కడ ఒక వైల్ లూప్ యొక్క నిర్మాణం ఉంది.
00:39	ఇది రెండు భాగాలను కలిగిఉంది
00:41	ఒకటి loop running condition మరియు రెండవది loop variable.
00:48	ఇప్పుడు ఒక ఉదాహరణ చూద్దాం.ఎక్లిప్స్ కు మారండి.
00:55	ఇక్కడ మనకు ఎక్లిప్స్IDE మరియు మిగిలినకోడ్ కి అవసరమైన స్కేలిటన్ కలిగి ఉన్నాం
01:00	నేను వైల్ డెమో అనే క్లాస్ సృష్టించి, దానికి మెయిన్ మెథడ్ జతచేసాను.
01:05	మనం వైల్ లూప్ ని ఉపయోగించి 1 నుండి 10 వరకు సంఖ్యలని ముద్రిస్తాము. int n = 1;అని టైప్ చేయండి.
01:15	ఈ వేరియబుల్’ n అనేది మన లూప్ వేరియబుల్’ గా ఉండబోతుంది.
01:21	while పరాంతసిస్ లో n less than or equal to 10 ఓపెన్ మరియు క్లోజ్ బ్రెసెస్ ని టైప్ చేయండి.
01:33	ఈ కండిషన్ ని లూప్ రన్నింగ్ కండిషన్ అంటారు.
01:37	దీని అర్ధం కండిషన్ ఎంతవరకు సత్యం అవుతుందో అంత వరకు loop రన్ అవుతూ ఉంటుంది.
01:42	మన సందర్భంలో, ఇది n యొక్క విలువ 10 కన్నా తక్కువ లేక సమానం అయినంతవరకు రన్ అవుతూవుంటుంది.
01:47	మరియు అది n యొక్క విలువ10 కన్నా ఎక్కువ అయినప్పుడు మాత్రమే ఆగుతుంది.
01:53	లూప్ లోపల మనం n యొక్క విలువ ను ముద్రిద్దాం.
01:58	System.out.println(n); తర్వాత దానిని పెంచండి n = n + 1;
02:12	ఈ విధంగా ,ముందు1 ముద్రించబడి తర్వాత n విలువ 2 అవుతుంది.
02:18	తర్వాత లూప్ కండిషన్ పరీక్షించబడుతుంది.
02:21	అది సత్యం కనుక,2 ముద్రించబడుతుంది మరియు n విలువ 3 అవుతుంది.
02:25	ఆపై .. లూప్ 10 ముద్రించబడే వరకు కొనసాగుతుంది. ఆ తరువాత n, 11 అవటం వలన కండిషన్ అసత్యం అవుతుంది మరియు లూప్ ని నిలిపివేస్తుంది.
02:37	కనుక, కోడ్ ని చర్యలో చూద్దాము.
02:39	సేవ్ చేసి రన్ చేయండి.
02:47	మనము చూస్తున్నట్లుగా, 1 నుండి 10 వరకు సంఖ్యలు ముద్రించబడతాయి.
02:52	ఇప్పుడు మనం 50 నుండి 40 వరకు సంఖ్యలను ముద్రిస్తాము.
02:58	కనుక, మనం 50 తో ప్రారంభిద్దాం. n = 1 ని n = 50 కి మార్చండి.
03:03	మరియు మనం 40 వచ్చేవరకు ఇలా వెళ్తాము.
03:05	ఇంకోలా చెప్పాలంటే, n విలువ 40 కంటే ఎక్కువ లేక 40 కి సమానం అయ్యేవరకు. కనుక ,కండిషన్ ని n గ్రేటర్ దాన్ ఆర్ ఈక్వల్ టు 40 కి మార్చండి.
03:16	మనం గరిష్టసంఖ్యనుండి కనిష్టసంఖ్యకు లూపింగ్ చేస్తున్నాంకాబట్టి మనం లూప్ వేరియబుల్ విలువను తగ్గించాం.
03:22	కావున n=n+1 ని n=n-1 కు మార్చండి.
03:27	సేవ్ చేసి రన్ చేయండి.మనము చూస్తున్నట్లుగా, 50 నుండి 40 వరకు సంఖ్యలు ముద్రించబడతాయి.
03:42	ఇప్పుడు మనం 7 యొక్క మొదటి పది గుణిజాలను ముద్రిస్తాము.
03:48	ఆలా చేయడానికి, మనం 7 తో ప్రారంభిస్తాం.
03:50	కనుక,n = 50 ని n = 7 కి మార్చండి. తరువాత మనం 70 తో ముగిస్తాం.
03:57	కండిషన్ ను n లెస్ దాన్ ఆర్ ఈక్వల్ టు 70 కి మార్చండి.
04:03	ఈ విధంగా, మనం లూప్ 70 దగ్గర ఆగేలా చూసుకోవాలి.
04:07	గుణిజాలను పొందటానికి,మనం loop variable ని 7 చేత పెంపుచేస్తాం.
04:12	కనుక, n=n-1 ని n= n+7; కి మార్చుదాం.
04:18	ఈ విధంగా ముందు 7 ముండ్రించబడి తర్వాత అది 14 అవుతుంది.14 ముద్రించబడి అది అలాగే 70 వచ్చేవరకు కొనసాగుతుంది..సేవ్ చేసి రన్ చేయండి.
04:33	మనం చూస్తున్నట్లుగా,7 యొక్క మొదటి 10 గుణిజాలు ముద్రించబడతాయి.
04:43	మనం ఒక సంఖ్య యొక్క అంకెల మొత్తాన్ని తెలుసుకోవడానికి కూడా వైల్ లూప్ ని ఉపయోగించవచ్చు
04:47	అది ఎలా చేయాలో చూద్దాం.
04:49	ముందు,మెయిన్ మెథడ్ ని తొలగించండి.
04:54	int n equal to 13876;. ఇది మన సంఖ్య.
05:02	తర్వాత, int dSum ఈక్వల్ టు 0 అవుతుంది. dsum వేరియబుల్ అనేది అంకెల మొత్తానికి గుర్తు ఇది అంకెల మొత్తాన్ని కలిగి ఉంటుంది.
05:18	while n గ్రేటర్ దాన్ 0 ఓపెన్ క్లోజ్ పరాంతసిస్ ను టైప్ చేయండి
05:27	ఈ కండిషన్ ను ఉపయోగిస్తున్న కారణం అనేది ఒక సమయంలో స్పష్టమౌతుంది.
05:32	అంకెల యొక్క మొత్తాన్ని పొందటానికి,మనం ముందు అంకెలను పొందాలి.
05:36	దాన్ని చేయడానికి,మనం మాడ్యూలోఆపరేటర్ ను ఉపయోగిస్తాం.
05:40	dSum = dSum + (n % 10) అని టైప్ చేయండి. కనుక, మనం యూనిట్ యొక్క అంకెను పొందుతాం దానిని dsum కు జత చేయండి.
05:52	తర్వాత మనం 10 తో భాగించడం చేత ఆ అంకెను తొలగిస్తాం.n = n / 10
06:08	కనుక, లూప్ మొదటిసారి రన్ అయినప్పుడు dSum అనేది 6 అవుతుంది మరియు n అనేది 1387అవుతుంది.
06:15	ఇంకా,లూప్ రెండవ సారి రన్ అయినప్పుడు dSum అనేది 7 మరియు 6 ల మొత్తం అది 13 మరియు n విలువ 138అవుతుంది.
06:22	అలా లూప్ కొనసాగుతూ, అంకెలు n’ నుండితొలగించబడి చివరికి
06:28	n సున్నా అవుతుంది.ఆ తర్వాత కండిషన్ n గ్రేటర్ దాన్ 0 అనేది అసత్యం అయి లూప్ ముగుస్తుంది.
06:36	కనుక,ఇప్పుడు ప్రింట్ స్టేట్మెంట్ చేర్చుదాం.
06:42	System.out.println(dSum)
06:51	కోడ్ ని చర్యలో చూద్దాం.సేవ్ చేసి రన్ చేద్దాం.
06:59	మనం చూస్తున్నట్లుగా, అంకెల యొక్క మొత్తం 25 ముద్రించబడింది.
07:06	ఈ విధంగా, చాల ప్రాధమిక constructs లో ఒకటి అయిన while loop ను మనం ప్రోగ్రామింగ్ లో ఉపయోగించవచ్చు.
07:16	మనం ఈ టుటోరియల్ చివరకు వచ్చాం
07:20	ఈ టుటోరియల్ లో మనం నేర్చుకున్నవి:వైల్ లూప్ గురించి, ఎలా ఉపయోగించాలి అనేదాని గురించి.
07:26	ఈ టుటోరియల్ కొరకు ఒక అసైన్మెంట్ గా:ఈ క్రింది సమస్యను సాధించండి.
07:29	ఇచ్చిన సంఖ్యను వ్యతిరేకంగా వైల్ లూప్ ను ఉపయోగించి గణించండి. Example: 19435 => 53491
07:37	స్పోకెన్ టుటోరియల్ ప్రాజెక్టు గురించి మరిన్ని వివరాలకోసం, ఈ క్రింది లింక్ లో గల వీడియో చూడండి. ఇది స్పోకెన్ ట్యుటోరియల్ యొక్క సారాంశాన్ని ఇస్తుంది.
07:45	మంచి బాండ్ విడ్త్ లేదంటే , డౌన్ లోడ్ చేసి చూడగలరు.
07:50	స్పోకన్ టుటోరియల్ ప్రాజెక్టు టీమ్: స్పోకన్ టుటోరియల్స్ ద్వారా వర్క్ షాప్ నిర్వహిస్తుంది.ఆన్ లైన్ పరీక్ష లో పాస్ ఐతే సర్టిఫికట్ ఇస్తుంది.
07:57	మరిన్ని వివరాలకు contact @ spoken హైఫన్ tutorial డాట్ org ను సంప్రదించండి.
08:03	స్పోకెన్ ట్యుటోరియల్ టాక్ టు ఎ టీచర్ ప్రాజక్టులోఒక భాగం.
08:07	దీనికి ICT ద్వారా నేషనల్ మిషన్ ఆన్ ఎడ్యుకేషన్ సహాయం అందిస్తోంది
08:12	దీనిపై మరింత సమాచారం ఈ క్రింద లింక్ లో ఉంది.Spoken హైఫన్ tutorial డాట్ org స్లాష్ ఎన్ ఎం ఈ ఐసి టి హైఫన్ ఇంట్రో
08:17	ఈ రచనకు సహాయపడినవారు శ్రీహర్ష మరియు ఉదయ లక్ష్మి. ధన్యవాదములు.

Contributors and Content Editors

Madhurig, Simhadriudaya, Yogananda.india