Java/C2/do-while/Gujarati

From Script | Spoken-Tutorial
Revision as of 17:16, 7 August 2013 by Krupali (Talk | contribs)

Jump to: navigation, search
Time' Narration
00:01 જાવામાં do -while લૂપ પરના સ્પોકન ટ્યુટોરીયલમાં તમારું સ્વાગત છે.
00:06 આ ટ્યુટોરીયલમાં આપણે શીખીશું,
  • do-while લુપ અને'
  • તે કેવી રીતે વાપરવું.
00:12 આ ટ્યુટોરીયલ માટે આપણે

Ubuntu 11.10,

JDK 1.6 અને

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

00:20 આ ટ્યુટોરીયલ અનુસરવા માટે, તમને જાવામાં while લુપ વિષે જ્ઞાન હોવું જરૂરી છે
00:25 જો નહિં, તો સંબંધિત ટ્યુટોરિયલ્સ માટે અમારી વેબસાઇટ http://spoken-tutorial.org/ જુઓ.
00:32 અહીં do while લૂપનું સ્ટ્રક્ચર છે.
00:37 નોંધ લો કે તે while લૂપ જેવું જ છે.
00:40 તેના બે ભાગો છે.
00:42 પ્રથમ લુપ રનીંગ કન્ડીશન છે અને બીજું લુપ વેરિયેબલ છે.
00:51 માત્ર એક ફરક છે કે કન્ડીશન do બ્લોક પછી આવે છે.
00:58 અને તેથી કન્ડીશન do બ્લોક અંદર આવેલા સ્ટેટમેન્ટ એક્ઝીક્યુટ થયા પછી ચેક થશે.
01:05 ચાલો ઉદાહરણ જોઈએ.
01:07 eclipse ઉપર જાઓ.
01:11 અહીં આપણી પાસે eclipse IDE અને બાકીના કોડ માટે જરૂરી માળખું છે.
01:17 આપણે DoWhileDemo નામનો એક ક્લાસ બનાવેલ છે અને તે અંદર મેઈન મેથડ ઉમેર્યી છે.
01:22 આપણે do -while લૂપની મદદથી 1 થી 10 નંબરો પ્રિન્ટ કરીશું.
01:27 ટાઇપ કરો,
01:29 int n ઇકવલ ટુ 1
01:32 વેરિયેબલ n આપણું લૂપ વેરિયેબલ બનશે.
01:36 પછી ટાઇપ કરો, do
01:40 ઓપન અને ક્લોસ કૌંસ
01:44 કૌંસ અંદર System.out.println(n);
01:55 આપણે n ની વેલ્યુ પ્રિન્ટ કરીશું અને પછી તેને ઇન્ક્રીમેન્ટ કરીશું. n ઇકવલ ટુ n plus 1;
02:05 અને આપણે આ,
02:08 n લેસ ધેન ઓર ઇકવલ ટુ 10 ન થાય ત્યાં સુધી કરીશું.
02:10 કૌંસ બહાર, ટાઇપ કરો, while કૌંસ અંદર, (n લેસ ધેન ઓર ઇકવલ ટુ 10)
02:20 અને સેમીકોલનનો ઉપયોગ કરી do -while બંધ કરો.
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 અને એ રીતે 10 પ્રિન્ટ થાય ત્યાં સુધી લુપ વધે છે, તે પછી n ની વેલ્યુ 11 બને છે
03:06 જયારે n = 11 થાય છે, કન્ડીશન નિષ્ફળ જાય છે અને લૂપ અટકે છે.
03:11 હવે ચાલો 50 થી 40' નંબરો ઉતરતા ક્રમમાં પ્રિન્ટ કરીએ.
03:17 તો આપણે 50 થી શરૂ કરીશું.
03:19 n = 1 ને n = 50 થી બદલો.
03:23 આપણે મોટા નંબરથી નાના નંબર માટે લુપીંગ કરી રહ્યા છે, તેથી આપણે લુપ વેરિયેબલ ડીક્રીમેન્ટ કર્યો છે.
03:29 તો n=n + 1 ને n=n - 1 થી બદલો.
03:34 આપણે n ગ્રેટર ધેન ઓર ઇકવલ ટુ 40 થાય ત્યાં સુધી લુપ કરીશું.
03:40 તેથી કન્ડીશન n >= 40 થી બદલો.
03:48 ચાલો આઉટપુટ જોઈએ.
03:50 સેવ અને રન કરો.
03:57 આપણે જોઈ શકીએ છીએ, 50 થી 40 નંબરો પ્રિન્ટ થયા છે.
04:02 હવે do-while લુપની મદદથી વિવિધ લોજીકનો પ્રયાસ કરીએ.
04:10 આપેલ નંબર સંપૂર્ણ વર્ગ છે કે નહી તે શોધો.
04:15 પ્રથમ મેઈન મેથડ ક્લીયર કરો.
04:19 પછી ટાઇપ કરો, int n = 25;
04:25 n ની વેલ્યુ સંપૂર્ણ વર્ગ છે કે નહી તે જોઈશું.
04:32 પછી ટાઇપ કરો, int x = 0;
04:37 આપણે, જો નંબર સંપૂર્ણ વર્ગ હોય તો તેનું વર્ગમૂળ સંગ્રહવા માટે x નો ઉપયોગ કરીશું.
04:44 પછી ટાઇપ કરો, do
04:46 ઓપન અને ક્લોસ કૌંસ.
04:49 કૌંસ અંદર, x ઇકવલ ટુ x પ્લ સ 1
04:55 અને કૌંસ બહાર,
04:58 while કૌંસ અંદર (x ઇન ટુ x < n)
05:06 અને સેમી કોલન નો ઉપયોગ કરી do-while બંધ કરો.
05:10 જ્યાં સુધી x ઇન ટુ x લેસ ધેન n હશે, ત્યાં સુધી આપણે x ની વેલ્યુ ઇન્ક્રીમેન્ટ કરીશું.
05:16 તો જયારે લૂપ અટકે છે, આ કન્ડીશનનું વિપરીત true થશે.
05:22 જેનો અર્થ છે, ક્યાં તો x ઇન ટુ x, n સમાન છે,
05:26 અથવા તે n કરતા મોટું છે.
05:28 જો x ઇન ટુ x ઇકવલ ટુ n, તો તે નંબર એક સંપૂર્ણ વર્ગ છે.
05:32 જો તે n સમાન નથી, તો તે નંબર સંપૂર્ણ વર્ગ નથી.
05:37 તેથી છેવટે, આપણે કન્ડીશન પ્રિન્ટ કરીશું.
05:47 System.out.println(x * x == n);
05:55 ચાલો કોડ ને એક્શનમાં જોઈએ.
05:59 Save અને Run કરો. આપણે joi શકીએ છીએ કે આઉટપુટ true છે.
06:07 ચાલો બીજા સંપૂર્ણ વર્ગ સાથે પ્રયાસ કરીએ.
06:10 n = 25 ને n = 49 થી બદલો.
06:15 Save અને Run કરો.
06:20 આપણે જોઈએ છીએ કે ફરી true મળે છે.
06:23 ચાલો એ નંબર સાથે પ્રયાસ કરીએ જે સંપૂર્ણ વર્ગ નથી.
06:26 49 ને 23 માં બદલો. Save અને Run કરો અને
06:34 અપેક્ષા મુજબ આપણને false મળે છે.
06:37 હવે ચાલો જોઈએ શું થશે જો n ની વેલ્યુ 0 હોય.
06:42 n = 23 ને n = 0 થી બદલો, 0 પ્રાકૃતિક નંબર ન હોવાને કારણે, આપણને false મળવું જોઈએ.
06:52 ચાલો કોડ રન કરીએ.
06:54 Save અને Run કરો.
07:00 અપેક્ષા પ્રમાણે આપણને false મળે છે.
07:05 આ થાય છે કારણ કે કન્ડીશન પહેલાં પણ,
07:08 x ઇન ટુ x લેસ ધેન n ચેક થાય છે, x ની વેલ્યુ ઇન્ક્રીમેન્ટ થાય છે અને તે 1 બને છે.
07:16 લુપ કન્ડીશન નિષ્ફળ થાય છે અને લુપ રન નથી થતું.
07:20 આ રીતે, do -while લુપનો ઉપયોગ કરીને, આપણે ખાતરી કરી શકીએ છીએ કે 0 સંપૂર્ણ વર્ગ તરીકે ન ગણી શકાય.
07:26 આ રીતે, do-while લૂપ ઘણી સમસ્યાઓની શ્રેણી ઉકેલવા માટે વપરાય છે.
07:31 ખાસ કરીને, ત્યારે જયારે લૂપ ઓછામાં ઓછી એક વાર રન થવું જોઈએ.
07:37 અહીં આ ટ્યુટોરીયલ સમાપ્ત થાય છે.
07:40 આ ટ્યુટોરીયલમાં આપણે આ વિષે શીખ્યા,
07:42 do -while લુપ અને તે કેવી રીતે વાપરવું.
07:46 આ ટ્યુટોરીયલ માટે એસાઈનમેન્ટ તરીકે નીચેનો પ્રોબ્લેમ ઉકેલો.
07:50 આપેલ બાયનરી નંબર માટે તેનો દશાંશ સમકક્ષ શોધો. ઉદાહરણ તરીકે: 11010 => 26
07:56 સ્પોકન ટ્યુટોરીયલ પ્રોજેક્ટ વિષે વધુ જાણવા માટે, નીચે આપેલ લીંક ઉપર ઉપલબ્ધ વિડીઓ જુઓ,
08:01 તે સ્પોકન ટ્યુટોરીયલ પ્રોજેક્ટ માટે સારાંશ આપે છે. જો તમારી પાસે સારી બેન્ડવિડ્થ ન હોય તો, તમે ડાઉનલોડ કરી તે જોઈ શકો છો
08:06 સ્પોકન ટ્યુટોરીયલ પ્રોજેક્ટ ટીમ,
08:10 સ્પોકન ટ્યુટોરીયલોની મદદથી વર્કશોપ આયોજિત કરે છે. જેઓ ઓનલાઇન પરીક્ષા પાસ કરે છે તેમને પ્રમાણપત્ર આપે છે.
08:16 વધુ વિગતો માટે, contact@spoken-tutorial.org પર સંપર્ક કરો.
08:22 સ્પોકન ટ્યુટોરિયલ પ્રોજેક્ટ એ ટોક ટુ અ ટીચર પ્રોજેક્ટનો એક ભાગ છે. જે આઇસીટી, એમએચઆરડી, ભારત સરકાર દ્વારા શિક્ષણ પર નેશનલ મિશન દ્વારા આધારભૂત છે
08:32 આ મિશન વિશે વધુ માહીતી આ લીંક ઉપર ઉપલબ્ધ છે,
08:36 આઈઆઈટી બોમ્બે તરફથી ભાષાંતર કરનાર હું, કૃપાલી પરમાર વિદાય લઉં છું. જોડાવા બદ્દલ આભાર.

Contributors and Content Editors

Jyotisolanki, Krupali, PoojaMoolya, Pratik kamble