Java/C2/while-loop/Telugu

From Script | Spoken-Tutorial
Revision as of 20:57, 16 November 2017 by Simhadriudaya (Talk | contribs)

(diff) ← Older revision | Latest revision (diff) | Newer revision → (diff)
Jump to: navigation, search
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 ఒకటి లూప్ రన్నింగ్ కండిషన్ మరియు రెండవది లూప్ వేరియబుల్.
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 గుణిజాలను పొందటానికి,మనం లూప్ వేరియబుల్ ని 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