1
00:00:00,000 --> 00:00:00,400

2
00:00:00,400 --> 00:00:02,260
>> 1 વક્તા: માતાનો રિફાઇન દો મારા
ઉધરસ અમલ

3
00:00:02,260 --> 00:00:03,230
થોડો વધુ.

4
00:00:03,230 --> 00:00:06,580
જેથી બદલે માત્ર એક જ ખોખલો
સમય, ઉધરસ બ્લોક વાપરી રહ્યા હોય ત્યારે

5
00:00:06,580 --> 00:00:09,780
તમે ખરેખર સ્પષ્ટ કરી શકો છો કે કેટલા
વખત કે સ્પ્રાઈટ ખોખલો જોઈએ.

6
00:00:09,780 --> 00:00:12,000
તેથી આ વખતે હું જાઉં છું
બ્લોક બનાવવા, ક્લિક કરો.

7
00:00:12,000 --> 00:00:13,615
હું ફરી ઉધરસ કૉલ જાઉં છું.

8
00:00:13,615 --> 00:00:16,200
પરંતુ આ વખતે હું જાઉં છું
આ વિકલ્પો વિસ્તૃત.

9
00:00:16,200 --> 00:00:20,450
>> ત્યાં, હું સ્પષ્ટ કરી શકો છો કે આ ઉધરસ
બ્લોક ઇનપુટ તરીકે સંખ્યાબંધ લેવી જોઈએ.

10
00:00:20,450 --> 00:00:22,220
અહીં આ ચિહ્ન પર ક્લિક કરીને.

11
00:00:22,220 --> 00:00:25,850
અન્યથા જાણીતા કે ઇનપુટ માટે મૂળભૂત રીતે
એક દલીલ તરીકે, એક મૂળભૂત છે

12
00:00:25,850 --> 00:00:27,170
નંબર 1 નામ.

13
00:00:27,170 --> 00:00:30,870
પરંતુ હું માત્ર કે સરળ બનાવવા જઈ રહ્યો છું
n એ, અમારા સામાન્ય રીતે નામ આપવામાં આવ્યું ચલ છે

14
00:00:30,870 --> 00:00:32,009
કંઈક ગણતરી માટે.

15
00:00:32,009 --> 00:00:33,960
આ કફ છે.

16
00:00:33,960 --> 00:00:35,780
>> હવે, હું જવા જાઉં છું
આગળ અને બરાબર ક્લિક કરો.

17
00:00:35,780 --> 00:00:38,830
અને હું ફરીથી શરૂઆત છે,
નિર્ધારિત પઝલ ભાગ છે.

18
00:00:38,830 --> 00:00:41,120
નહિં તો એક કાર્ય તરીકે ઓળખાય છે.

19
00:00:41,120 --> 00:00:45,760
હવે, આ કાર્ય મને પરવાનગી રહ્યું છે
કેટલી વખત કોડમાં સ્પષ્ટ કરવા માટે

20
00:00:45,760 --> 00:00:47,230
સ્ક્રેચ ખોખલો જોઈએ.

21
00:00:47,230 --> 00:00:50,020
તેથી આપણે કે પ્રથમ ગ્રેબ દો
પુનરાવર્તન અવરોધિત કરો.

22
00:00:50,020 --> 00:00:53,070
પરંતુ તેના બદલે હાર્ડ કોટ કરતાં નંબર
10 કે ત્રણ, તરીકે

23
00:00:53,070 --> 00:00:54,290
અમે ભૂતકાળમાં કર્યું છે.

24
00:00:54,290 --> 00:00:58,520
>> ચાલો આ ચલ n ગ્રેબ અને સ્પષ્ટ કરો
અમે એક ચલ પુનરાવર્તન કરીશું કે

25
00:00:58,520 --> 00:00:59,630
વખત નંબર.

26
00:00:59,630 --> 00:01:02,480
એન, જો કે ઘણી વખત
વપરાશકર્તા સ્પષ્ટ છે.

27
00:01:02,480 --> 00:01:05,099
હવે અમે શું સ્ક્રેચ કરવા માંગો છો
વખત કોઈ અંક પુનરાવર્તન?

28
00:01:05,099 --> 00:01:08,520
ઠીક છે, હું કહેવા માંગો છો સ્ક્રેચ
એક બીજા માટે ખોખલો.

29
00:01:08,520 --> 00:01:11,810

30
00:01:11,810 --> 00:01:13,600
પછી હું તેમને આપવા માંગો છો
એક ક્ષણ વિરામ.

31
00:01:13,600 --> 00:01:16,710

32
00:01:16,710 --> 00:01:21,030
>> અને હવે હું ખરેખર છે કે કૉલ કરવાની જરૂર
મારા વાસ્તવિક કાર્યક્રમ કાર્ય દ્વારા

33
00:01:21,030 --> 00:01:22,550
ખોખલો સ્ક્રેચ કહેવાની.

34
00:01:22,550 --> 00:01:26,680
તેથી હું મારા નવા ખેંચો જાઉં છું
કરવામાં ઉધરસ પઝલ ભાગ.

35
00:01:26,680 --> 00:01:30,460
અને હવે મૂળભૂત વાપરવા કરતા
1, હું આગળ જાઓ અને સ્પષ્ટ કરવા માટે જઈ રહ્યો છું

36
00:01:30,460 --> 00:01:31,560
ત્રણ કફ.

37
00:01:31,560 --> 00:01:35,080
તેથી હવે થાય છે વિશે શું જ્યારે હું
લીલો ધ્વજ મારા ઉધરસ છે ક્લિક કરો

38
00:01:35,080 --> 00:01:37,010
પઝલ ભાગ ચલાવવામાં કરો રહ્યું છે.

39
00:01:37,010 --> 00:01:41,660
>> તે નંબર 3 માં છેલ્લા પ્રયત્ન રહ્યું છે
આ ઉધરસ કાર્ય જેથી વાત કરવા માટે.

40
00:01:41,660 --> 00:01:45,620
કાર્યો કોડ છે અને તે છે જ્યાં
ત્યાંથી વસ્તુઓ લેવા જઈ રહી છે.

41
00:01:45,620 --> 00:01:49,840
પુનરાવર્તન n વખત અથવા આ ત્રણ
કેસ, એક બીજા માટે ઉધરસ, કહે છે

42
00:01:49,840 --> 00:01:54,000
પુનરાવર્તન, એક બીજા માટે રાહ જોઈ રહ્યું,
પુનરાવર્તન, અને તે છે.

43
00:01:54,000 --> 00:01:56,330
માતાનો લીલો ધ્વજ ક્લિક કરો.

44
00:01:56,330 --> 00:02:02,030
, ઉધરસ, ઉધરસ, અને ત્યાં તમે તેને ઉધરસ.

45
00:02:02,030 --> 00:02:04,040