Difference between revisions of "Java/C2/while-loop/Gujarati"

From Script | Spoken-Tutorial
Jump to: navigation, search
 
Line 1: Line 1:
 
   
 
   
 
{| border=1
 
{| border=1
|| ''Time'''
+
|| '''Time'''
 
|| '''Narration'''
 
|| '''Narration'''
  

Latest revision as of 12:46, 23 June 2014

Time Narration
00:02 જાવામાં While Loop પરના સ્પોકન ટ્યુટોરીયલમાં તમારું સ્વાગત છે.
00:06 આ ટ્યુટોરીયલ માં, તમે while loop વિષે,

અને તે કેવી રીતે વાપરવું તે વિષે શીખશો.

00:12 આ ટ્યુટોરીયલ માટે આપણે

Ubuntu 11.10,

JDK 1.6 અને

Eclipse 3.7 નો ઉપયોગ કરી રહ્યા છીએ.

00:21 આ ટ્યુટોરીયલ અનુસરવા માટે, તમને જાવામાં રીલેશનલ ઓપરેટરો વિષે જ્ઞાન હોવું જરૂરી છે
00:26 જો નહિં, તો સંબંધિત ટ્યુટોરિયલ્સ માટે અમારી વેબસાઇટ http://spoken-tutorial.org/ જુઓ.
00:36 અહીં while લૂપનું સ્ટ્રક્ચર છે.
00:39 તેના બે ભાગો છે.
00:41 પ્રથમ લુપ રનીંગ કન્ડીશન છે અને બીજું લુપ વેરિયેબલ છે.
00:48 ચાલો હવે ઉદાહરણ જોઈએ. Eclipse પર જાઓ.
00:55 અહીં આપણી પાસે eclipse IDE અને બાકીના કોડ માટે જરૂરી માળખું છે.
01:00 મેં WhileDemo નામનો એક ક્લાસ બનાવેલ છે અને તે અંદર મેઈન મેથડ ઉમેર્યી છે.
01:05 આપણે while લૂપની મદદથી 1 થી 10 નંબરો પ્રિન્ટ કરીશું. ટાઇપ કરો, int n = 1
01:15 આ વેરિયેબલ n આપણું લૂપ વેરિયેબલ બનશે.
01:21 ટાઇપ કરો, while કૌંસ અંદર, n લેસ ધેન ઓર ઇકવલ ટુ 10 ઓપન અને ક્લોસ કૌંસ.
01:33 આ કન્ડીશન લુપીંગ રનીંગ કન્ડીશન કહેવામાં આવે છે.
01:37 એનો અર્થ છે, લૂપ ત્યાં સુધી રન થશે જ્યાં સુધી આ કન્ડીશન true થશે.
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 તે true છે તેથી 2 પ્રિન્ટ કરશે અને 3 બને છે.
02:25 અને એ રીતે 10 પ્રિન્ટ થાય ત્યાં સુધી લુપ વધે છે, તે પછી એ 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 કરતા વધારે અથવા બરાબર હોય. તો કન્ડીશન n ગ્રેટર ધેન ઓર ઇકવલ ટુ થી બદલો.
03:16 અને આપણે મોટા નંબરથી નાના નંબર માટે લુપીંગ કરી રહ્યા છે, તેથી આપણે લુપ વેરિયેબલ ડીક્રીમેન્ટ કર્યો છે.
03:22 તો n=n + 1 ને n=n - 1 થી બદલો.
03:27 સેવ અને રન કરો. આપણે જોઈ શકીએ છીએ, 50 થી 40 નંબરો પ્રિન્ટ કરવામાં આવેલ છે.
03:42 હવે આપણે પ્રથમ 10, 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 પ્રિન્ટ થશે અને પછી n 14 બનશે, 14 પ્રિન્ટ થશે અને એ જ રીતે 70 સુધી. સેવ અને રન કરો.
04:33 આપણે જોઈ શકીએ છીએ, પ્રથમ 10, 7 ના ગુણાંક પ્રિન્ટ કરવામાં આવેલ છે.
04:43 આપણે નંબરના અંકોનો સરવાળો મેળવવા માટે પણ while લૂપ વાપરી શકો છો.
04:47 ચાલો જોઈએ તે કેવી રીતે કરવું.
04:49 પ્રથમ મેઈન મેથડ ક્લીયર કરો.
04:54 int n ઇકવલ ટુ 13876. આ નંબર છે.
05:02 એટલે કે ડીજીટ સમ દર્શાવતું આ વેરિયેબલ નંબરના અંકોનો સરવાળો સમાવે છે.
05:18 ટાઇપ કરો, while, n ગ્રેટર ધેન 0 ઓપન ક્લોસ કૌંશ
05:27 આ કન્ડીશન વાપરવા માટેનું કારણ થોડા સમયમાં જાણીશું.
05:32 અંકોનો સરવાળો મેળવવા માટે, આપણે પ્રથમ અંકો મેળવવા જોઈએ.
05:36 તે કરવા માટે આપણે મોડ્યુલો ઓપરેટર વાપરીશું.
05:40 ટાઇપ કરો, dSum = dSum + (n % 10) તો આપણને એકમ ડીજીટ મળ્યું છે અને તેને dsum માં ઉમેરીશું.
05:5 તે પછી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 કન્ડીશન false થશે અને લુપ બંધ થશે.
06:36 ચાલો પ્રિન્ટ સ્ટેટમેન્ટ ઉમેરીએ.
06:42 System.out.println(dSum)
06:51 ચાલો કોડ અને એક્શન જોઈએ. સેવ અને રન કરો.
06:59 આપણે જોઈ શકીએ છીએ, નંબરના આંકડાનો સરવાળો 25 પ્રિન્ટ કરવામાં આવેલ છે.
07:06 આ રીતે, પ્રોગ્રામીંગનું સૌથી મૂળભૂત કન્સ્ટ્રકટ while લુપ વાપરી શકાય છે.
07:16 અહીં આ ટ્યુટોરીયલ સમાપ્ત થાય છે.
07:20 આ ટ્યુટોરીયલમાં આપણે આ વિષે શીખ્યા,
  • while લુપ
  • તે કેવી રીતે વાપરવું.
07:26 આ ટ્યુટોરીયલ માટે એસાઈનમેન્ટ તરીકે નીચેનો પ્રોબ્લેમ ઉકેલો.
07:29 while લૂપનો ઉપયોગ કરી આપેલ નંબરને રિવર્સ કરવા માટેની ગણતરી કરો. ઉદાહરણ તરીકે: 19435 => 53491
07:37 સ્પોકન ટ્યુટોરીયલ પ્રોજેક્ટ વિષે વધુ જાણવા માટે, નીચે આપેલ લીંક ઉપર ઉપલબ્ધ વિડીઓ જુઓ, તે સ્પોકન ટ્યુટોરીયલ પ્રોજેક્ટ માટે સારાંશ આપે છે.
07:45 જો તમારી પાસે સારી બેન્ડવિડ્થ ન હોય તો, તમે ડાઉનલોડ કરી તે જોઈ શકો છો
07:50 સ્પોકન ટ્યુટોરીયલ પ્રોજેક્ટ ટીમ, સ્પોકન ટ્યુટોરીયલોની મદદથી વર્કશોપ આયોજિત કરે છે. જેઓ ઓનલાઇન પરીક્ષા પાસ કરે છે તેમને પ્રમાણપત્ર આપે છે.
07:57 વધુ વિગતો માટે, contact@spoken-tutorial.org પર સંપર્ક કરો.
08:03 સ્પોકન ટ્યુટોરિયલ પ્રોજેક્ટ એ ટોક ટુ અ ટીચર પ્રોજેક્ટનો એક ભાગ છે.
08:07 જે આઇસીટી, એમએચઆરડી, ભારત સરકાર દ્વારા શિક્ષણ પર નેશનલ મિશન દ્વારા આધારભૂત છે
08:12 આ મિશન વિશે વધુ માહીતી આ લીંક ઉપર ઉપલબ્ધ છે,
08:17 આઈઆઈટી બોમ્બે તરફથી ભાષાંતર કરનાર હું, કૃપાલી પરમાર વિદાય લઉં છું. જોડાવા બદ્દલ આભાર.

Contributors and Content Editors

Krupali, Pratik kamble