1
00:00:07,370 --> 00:00:09,760
[Powered by Google Translate] Tommy MACWILLIAM: ვისაუბროთ იმაზე მარყუჟების, ერთი საერთო

2
00:00:09,760 --> 00:00:13,380
პროგრამირების აშენებს ვნახავთ მთელ CS50.

3
00:00:13,380 --> 00:00:15,570
ჩვენ ვიყენებთ მარყუჟების, როდესაც ჩვენ გვინდა, რომ შეასრულოს

4
00:00:15,570 --> 00:00:17,200
ამოცანა მეტი ერთხელ.

5
00:00:17,200 --> 00:00:20,700
მაგალითად, ჩვენ დაგვჭირდება ბეჭდვა "hi" 100 ჯერ ან ბეჭდვითი

6
00:00:20,700 --> 00:00:22,700
ყველა ასო ანბანი.

7
00:00:22,700 --> 00:00:26,030
ორივე ამ შემთხვევაში, ჩვენ გვაქვს ერთი რამ ჩვენ გვსურს რომ

8
00:00:26,030 --> 00:00:28,700
რამდენჯერმე, ბეჭდვა რაღაც გარეთ.

9
00:00:28,700 --> 00:00:31,970
თუმცა, რაც ჩვენ ამობეჭდოთ ყოველ ჯერზე შეიძლება იცვლებოდეს.

10
00:00:31,970 --> 00:00:34,530
ასე რომ ჩვენ შეგვიძლია გავაკეთოთ რაღაც ოდნავ განსხვავებული თითოეულ

11
00:00:34,530 --> 00:00:37,820
iteration, ან აწარმოებს გავლით, საქართველოში loop.

12
00:00:37,820 --> 00:00:41,280
ჩვენ დავინახავთ, სამი სხვადასხვა ტიპის მარყუჟების დო, ხოლო

13
00:00:41,280 --> 00:00:44,700
მარყუჟების, ამისთვის მარყუჟების, და ნუ ხოლო მარყუჟების.

14
00:00:44,700 --> 00:00:47,850
თუმცა ამ სამი სახის მარყუჟების აქვს სხვადასხვა სინტაქსი,

15
00:00:47,850 --> 00:00:50,630
იდეები მათ უკან არის იგივე.

16
00:00:50,630 --> 00:00:53,930
ჩვენ განსაზღვრავს ზოგიერთი ბლოკის კოდი ფარგლებში Curly braces,

17
00:00:53,930 --> 00:00:57,810
მოუწოდა ორგანოს მარყუჟი, რომ ჩვენ გვინდა შესრულდება

18
00:00:57,810 --> 00:00:59,790
ზოგიერთი რამდენჯერმე.

19
00:00:59,790 --> 00:01:03,370
შეცვლით ღირებულებებს ცვლადები გამოიყენება სხეულის, ჩვენ

20
00:01:03,370 --> 00:01:07,570
შეუძლია ჩვენი loop რაღაც განსხვავებული ყოველ ჯერზე ის აწარმოებს.

21
00:01:07,570 --> 00:01:10,750
ნებისმიერ loop ჩვენ წერენ, ჩვენ ასევე უნდა გადაწყვიტოს, როდესაც

22
00:01:10,750 --> 00:01:12,400
loop შეწყდება გაშვებული.

23
00:01:12,400 --> 00:01:15,650
თუ ჩვენ არ გავაკეთებთ, მაშინ ჩვენი სანდო კომპიუტერი გაგრძელდება

24
00:01:15,650 --> 00:01:19,040
გასაშვებად, რომ მარყუჟი სანამ ჩვენ მოკვლა პროგრამა.

25
00:01:19,040 --> 00:01:22,490
In Scratch, შეიძლება გამოიყენოთ განმეორებითი N ჯერ

26
00:01:22,490 --> 00:01:24,600
ბლოკირება შექმნათ loop.

27
00:01:24,600 --> 00:01:28,200
ყველა დარტყმები შიგნით ბლოკი რომ განაცხადა განმეორებითი 10

28
00:01:28,200 --> 00:01:30,130
იქნებოდა აწარმოებს 10 ჯერ.

29
00:01:30,130 --> 00:01:34,160
და მაშინ ჩვენ ავღნიშნო გადაადგილება, რათა დარტყმები შემდეგ რომ მარყუჟი.

30
00:01:34,160 --> 00:01:38,140
ასე რომ ჩვენი გაჩერება მდგომარეობა იყო უბრალოდ, ამ ბლოკში უკვე

31
00:01:38,140 --> 00:01:39,830
აწარმოებს 10 ჯერ.

32
00:01:39,830 --> 00:01:43,900
მოდით ხელახლა ეს C. იმისათვის Scratch, რათა უზრუნველყოს

33
00:01:43,900 --> 00:01:46,920
რომ დარტყმები ფარგლებში განმეორებითი ბლოკი სრულდება

34
00:01:46,920 --> 00:01:51,180
ზუსტად 10 ჯერ, Scratch სჭირდება ტრეკზე ყოველი

35
00:01:51,180 --> 00:01:53,750
აღსრულების განმეორებითი ბლოკი.

36
00:01:53,750 --> 00:01:56,790
შენარჩუნება ტრეკზე რამდენჯერ ჩვენი loop ორგანოს უკვე

37
00:01:56,790 --> 00:02:00,360
შესრულებული, მოდით შევქმნათ ცვლადში მე.

38
00:02:00,360 --> 00:02:03,400
დავიწყოთ მე გამორთვას ნულოვანი, რადგან ჩვენი loop

39
00:02:03,400 --> 00:02:04,650
არ იქნა აწარმოებს ამჟამად.

40
00:02:10,009 --> 00:02:10,949
OK

41
00:02:10,949 --> 00:02:15,560
ახლა ჩვენ ვიყენებთ ხოლო სიტყვით უნდა დაიწყოს off ჩვენი loop.

42
00:02:20,100 --> 00:02:24,180
ახლა ჩვენ უნდა გაერკვნენ, როდესაც ჩვენი loop შეწყდება, თუმცა

43
00:02:24,180 --> 00:02:26,730
მოდით დატოვეთ ეს ახლა და შემდეგ დაუბრუნდეს მას.

44
00:02:30,970 --> 00:02:32,150
ყველა უფლება.

45
00:02:32,150 --> 00:02:35,260
შიგნით ჩვენი მარყუჟის, მოდით უბრალოდ ბეჭდვა გაგზავნა გარეთ, ისევე როგორც

46
00:02:35,260 --> 00:02:38,535
"Hi". ჩვენ შეგვიძლია გამოვიყენოთ printf ფუნქცია ამ.

47
00:02:48,400 --> 00:02:49,230
ყველა უფლება.

48
00:02:49,230 --> 00:02:54,210
ახლა ჩვენ ჩანაწერის iteration of loop ორგანოს აქვს

49
00:02:54,210 --> 00:02:55,750
აღსრულებულა.

50
00:02:55,750 --> 00:03:00,320
ჩვენ შეგვიძლია გავაკეთოთ, რომ დამატებით 1 ან დამატება, ჩვენი counter

51
00:03:00,320 --> 00:03:01,740
ცვლადი, მე.

52
00:03:01,740 --> 00:03:09,180
ამისათვის, ჩვენ შეგვიძლია ვთქვათ, მე უდრის მე პლუს 1 ან მეტი

53
00:03:09,180 --> 00:03:16,520
უბრალოდ, მე Plus Plus.

54
00:03:16,520 --> 00:03:17,320
დიდი.

55
00:03:17,320 --> 00:03:21,810
ახლა ვხედავთ, რომ ყოველ ჯერზე ჩვენი მარყუჟი აწარმოებს, ჩვენი

56
00:03:21,810 --> 00:03:24,500
Counter ცვლადი მიდის up ერთი.

57
00:03:24,500 --> 00:03:29,410
ასე რომ, ჩვენ ვიცით ზუსტად რამდენი iterations ჩვენ აწარმოებს ჯერჯერობით.

58
00:03:29,410 --> 00:03:31,630
შემდეგ ერთი iteration of მარყუჟის, ჩვენი ღირებულება

59
00:03:31,630 --> 00:03:34,270
საქართველოს მე ვიქნები 1.

60
00:03:34,270 --> 00:03:37,460
შემდეგ ორი iterations, მე ვიქნები 2.

61
00:03:37,460 --> 00:03:42,640
ხოლო მას შემდეგ 10 iterations, მე ვიქნები 10.

62
00:03:42,640 --> 00:03:46,780
ასე რომ, თუ ჩვენ გვინდა აწარმოებს ამ loop ზუსტად 10 ჯერ, მაშინ

63
00:03:46,780 --> 00:03:49,240
ეს მაშინ, როცა ჩვენ გვინდა შეჩერება.

64
00:03:49,240 --> 00:03:53,860
ასე რომ ჩვენ გვინდა აწარმოებს ამ loop ხოლო მე ნაკლებია 10, და

65
00:03:53,860 --> 00:03:57,630
სწორედ ის, რაც ჩვენ გავხდით წერენ, ხოლო მე

66
00:03:57,630 --> 00:04:02,450
ნაკლებია 10.

67
00:04:02,450 --> 00:04:06,380
ეს მდგომარეობა გამოიყურება ისევე პირობებში ჩვენ გამოიყენება, თუ

68
00:04:06,380 --> 00:04:07,830
სხვაგან ბლოკები.

69
00:04:07,830 --> 00:04:11,690
შემდეგ სხეულის ჩვენი მარყუჟი უკვე შესრულებული, ჩვენი პროგრამა

70
00:04:11,690 --> 00:04:14,690
იქნება ხტომა უკან მდე მარყუჟების მდგომარეობა.

71
00:04:14,690 --> 00:04:17,290
თუ მდგომარეობა მართალია, მაშინ ორგანოს

72
00:04:17,290 --> 00:04:18,990
loop იქნება აწარმოებს ერთხელ.

73
00:04:18,990 --> 00:04:22,190
თუ მდგომარეობა აღარ არის მართალია, მაშინ ჩვენი loop არ იქნება

74
00:04:22,190 --> 00:04:25,700
აწარმოებს უქმნით და გადავა შემდეგ ხაზი კოდი

75
00:04:25,700 --> 00:04:27,876
ქვევმოთ ჩვენი loop.

76
00:04:27,876 --> 00:04:28,550
ყველა უფლება.

77
00:04:28,550 --> 00:04:30,740
მოდით შევხედოთ მეორე ტიპის

78
00:04:30,740 --> 00:04:33,000
მარყუჟის, ამისთვის loop.

79
00:04:33,000 --> 00:04:37,310
შემდეგი to ხოლო სიტყვით, ფრჩხილებში, გვქონდა ერთი რამ,

80
00:04:37,310 --> 00:04:39,840
პირობით, რომ საჭიროა იყოს ეხება

81
00:04:39,840 --> 00:04:42,010
loop ორგანოს უნდა აწარმოებს.

82
00:04:42,010 --> 00:04:45,440
ანუ ჩვენ უნდა შევქმნათ ჩვენი Counter ცვლადი გარეთ

83
00:04:45,440 --> 00:04:48,760
საქართველოს მარყუჟი და მახსოვს ნამატი ეს რაღაც მომენტში

84
00:04:48,760 --> 00:04:51,050
შიგნით loop.

85
00:04:51,050 --> 00:04:54,320
Header ჩვენი ამისთვის მარყუჟის, მეორეს მხრივ, აქვს სამი

86
00:04:54,320 --> 00:04:58,510
ნაწილები, რომელთაგან თითოეული იქნება გამოყოფილი ერთად მძიმით.

87
00:04:58,510 --> 00:05:01,950
ჩვენი პირველი მესამე, ჩვენ შეგვიძლია განაცხადოს ნებისმიერი Counter ან დამხმარე

88
00:05:01,950 --> 00:05:05,000
ცვლადების ჩვენ გვინდა გამოვიყენოთ ჩვენს loop.

89
00:05:05,000 --> 00:05:07,350
პრაქტიკაში, ეს შეიძლება იყოს მართლაც გამოგადგებათ.

90
00:05:07,350 --> 00:05:10,590
ჩვენ ნამდვილად არ გვჭირდება, რომ ცვლადი, I, შემდეგ ჩვენი ხოლო

91
00:05:10,590 --> 00:05:13,650
loop უკვე აწარმოებს, ამიტომ ჩვენ ნამდვილად არ უნდა გამოაცხადოს ის

92
00:05:13,650 --> 00:05:15,810
გარეთ loop.

93
00:05:15,810 --> 00:05:19,080
მეორე მესამე იქნება იმ პირობით, რომ უნდა იყოს ჭეშმარიტი

94
00:05:19,080 --> 00:05:21,850
ამისთვის სხეულის შესრულდება კვლავ, ისევე, როგორც

95
00:05:21,850 --> 00:05:23,330
ჩვენს ხოლო loop.

96
00:05:23,330 --> 00:05:26,350
ჩვენი ბოლო მესამე, ჩვენ შეგვიძლია მას მოვთხოვოთ განცხადება, რომ იქნება

97
00:05:26,350 --> 00:05:30,270
შემდეგ განხორციელებული თითოეული iteration of მარყუჟის, ამიტომ ჩვენ არ გვაქვს

98
00:05:30,270 --> 00:05:32,710
ავაშენოთ იგი loop ორგანო.

99
00:05:32,710 --> 00:05:38,390
მოდით დავწეროთ ამისთვის loop რომ ითვლის ქვემოთ 5 დან 1.

100
00:05:38,390 --> 00:05:41,790
დავიწყოთ იმ სიტყვით.

101
00:05:41,790 --> 00:05:44,680
ჩვენ შეგვიძლია შევქმნათ counter ცვლადი პირველი, რაც ჩვენ გამოგიგზავნით

102
00:05:44,680 --> 00:05:47,840
მითითებული 5 ამჯერად რადგან ჩვენ დათვლის down,

103
00:05:47,840 --> 00:05:50,110
მოჰყვა მძიმით.

104
00:05:50,110 --> 00:05:53,660
შემდეგი არის ჩვენი მდგომარეობა, რომელიც ჩვენ დაბრუნდება.

105
00:05:53,660 --> 00:05:57,540
მესამე, ჩვენ მინდა decrement ჩვენი Counter ცვლადი შემდეგ

106
00:05:57,540 --> 00:05:59,620
ყოველ iteration of loop.

107
00:05:59,620 --> 00:06:04,740
ასე რომ, ვიდრე ამბობდა მე Plus Plus, ჩვენ ვთქვა მინუს მინუს.

108
00:06:04,740 --> 00:06:05,300
ყველა უფლება.

109
00:06:05,300 --> 00:06:09,490
ასე რომ ჩვენ გვინდა loop ორგანო აწარმოებს, ხოლო მე ჯერ კიდევ

110
00:06:09,490 --> 00:06:11,960
უფრო მეტი, ვიდრე 0.

111
00:06:11,960 --> 00:06:16,160
სხეულში მარყუჟის, მოდით ამობეჭდოთ ღირებულება მე.

112
00:06:16,160 --> 00:06:20,480
ამისათვის ჩვენ ვიყენებთ printf ფუნქცია გამოყენებით% d

113
00:06:20,480 --> 00:06:21,650
placeholder.

114
00:06:21,650 --> 00:06:24,820
გახსოვდეთ, რომ placeholder შეიცვლება

115
00:06:24,820 --> 00:06:27,040
ღირებულება მე.

116
00:06:27,040 --> 00:06:32,060
საბოლოოდ, მოდით დაამატოთ განაცხადი შემდეგ ჩვენი ამისთვის loop.

117
00:06:32,060 --> 00:06:35,850
როდესაც ჩვენ აწარმოებს ამ მარყუჟის, დავიწყებ გამორთვას 5,

118
00:06:35,850 --> 00:06:38,070
ასე 5 დაიბეჭდება.

119
00:06:38,070 --> 00:06:42,000
ერთხელ იღებს 0, გაგრძელება მდგომარეობა, მე არის

120
00:06:42,000 --> 00:06:44,450
უფრო მეტი, ვიდრე 0, აღარ გამართავს.

121
00:06:44,450 --> 00:06:47,330
ასე რომ ჩვენი loop შეწყდება შესრულებაში, და ვნახავთ

122
00:06:47,330 --> 00:06:49,850
განაცხადი შემდეგ loop.

123
00:06:49,850 --> 00:06:51,340
მოდით აწარმოებს ამ კოდი.

124
00:06:51,340 --> 00:06:52,700
პირველი, ჩვენ კომპილაციის

125
00:06:52,700 --> 00:06:56,460
countdown.c ერთად მიიღოს countdown.

126
00:06:56,460 --> 00:06:59,320
ახლა შეგვიძლია, აწარმოებს ამ კოდი ერთად. / Countdown.

127
00:07:02,340 --> 00:07:06,040
ორივე ხოლო მარყუჟების და მარყუჟების, ჩვენი გაგრძელება

128
00:07:06,040 --> 00:07:09,010
მდგომარეობა მოწმდება სანამ სხეული

129
00:07:09,010 --> 00:07:10,960
საქართველოს loop ხორციელდება.

130
00:07:10,960 --> 00:07:13,840
ეს იმას ნიშნავს, რომ, თუ ჩვენი მდგომარეობა არ არის თავდაპირველად

131
00:07:13,840 --> 00:07:18,100
მართალია, მაშინ სხეულის ჩვენი loop არასოდეს აწარმოებს.

132
00:07:18,100 --> 00:07:22,060
ასე რომ ხანდახან სასარგებლოა, რათა შეამოწმოს მდგომარეობა მას შემდეგ, რაც

133
00:07:22,060 --> 00:07:25,150
ორგანოს loop ვიდრე ადრე იყო.

134
00:07:25,150 --> 00:07:28,270
მოდით დავწეროთ loop უბიძგონ მომხმარებლის რიგი

135
00:07:28,270 --> 00:07:30,990
სანამ პოზიტიური ხმების მიეწოდება.

136
00:07:30,990 --> 00:07:34,740
თუ მომხმარებლის საშუალებებით უარყოფითი ნომერი, ჩვენ გვინდა ვთხოვოთ მათ

137
00:07:34,740 --> 00:07:36,260
მეორე ნომერი.

138
00:07:36,260 --> 00:07:38,940
ასე რომ ჩვენ გვინდა ამ სწრაფი იქნება შიგნით

139
00:07:38,940 --> 00:07:41,050
სხეულის off loop.

140
00:07:41,050 --> 00:07:44,730
თუმცა, როდესაც მარყუჟი აწარმოებს პირველად, მომხმარებლის

141
00:07:44,730 --> 00:07:46,750
არ მოგვცა ხმების ამჟამად.

142
00:07:46,750 --> 00:07:49,640
ასე რომ არ აქვს აზრი, რათა შეამოწმოთ, თუ ის დადებითია.

143
00:07:49,640 --> 00:07:54,020
სამაგიეროდ, ჩვენ გვინდა, რომ შეამოწმოთ ნომერი შემდეგ ორგანოს

144
00:07:54,020 --> 00:07:55,720
მარყუჟი აწარმოებს.

145
00:07:55,720 --> 00:08:00,310
ჩვენ შეგვიძლია გავაკეთოთ ამ do ხოლო loop.

146
00:08:00,310 --> 00:08:03,560
პირველი, ჩვენ დაგიმზადებთ ცვლადი, N, რომ გამართავს

147
00:08:03,560 --> 00:08:05,230
მომხმარებლის შეყვანის.

148
00:08:05,230 --> 00:08:09,960
ახლა ჩვენ ვიყენებთ do სიტყვით, რასაც მოჰყვა Curly braces რომ

149
00:08:09,960 --> 00:08:12,930
დაიწყება off ორგანოს ჩვენი loop.

150
00:08:12,930 --> 00:08:16,230
სხეულში, ჩვენ შეგვიძლია შეეკითხება მომხმარებელს ამისთვის ნომერი

151
00:08:16,230 --> 00:08:18,480
GetInt ფუნქცია.

152
00:08:18,480 --> 00:08:23,230
ახლა ჩვენ გვინდა ორგანო ამ loop შეასრულოს ერთხელ თუ

153
00:08:23,230 --> 00:08:28,370
მომხმარებლის აკრეფილი უარყოფითი ნომერი, ამიტომ ჩვენ ვიტყვით, ხოლო n

154
00:08:28,370 --> 00:08:30,420
ნაკლებია, ვიდრე 0.

155
00:08:30,420 --> 00:08:33,140
გაითვალისწინეთ მძიმით აქ შემდეგ ხოლო განცხადებაში.

156
00:08:38,909 --> 00:08:40,679
მოდით აწარმოებს ამ კოდი.

157
00:08:40,679 --> 00:08:44,780
პირველი, ჩვენ შეადგინონ ამ გახადოს დადებითი.

158
00:08:44,780 --> 00:08:49,340
ახლა ჩვენ შეგვიძლია მას მოვთხოვოთ პროგრამა. / დადებითი.

159
00:08:49,340 --> 00:08:52,660
თუ ვაძლევთ ამ პროგრამის უარყოფითი ნომერი, როგორიც უარყოფითი

160
00:08:52,660 --> 00:08:56,560
4, მაშინ ჩვენ უნდა აიძულა კვლავ ხმების წლიდან

161
00:08:56,560 --> 00:09:00,490
მდგომარეობა ჩვენი do ხოლო loop იყო ჭეშმარიტი.

162
00:09:00,490 --> 00:09:04,690
ერთხელ ვაძლევთ დადებითი ნომერი, როგორიც 8, მაშინ

163
00:09:04,690 --> 00:09:08,560
მდგომარეობა ჩვენი do ხოლო loop აღარ იქნება ჭეშმარიტი.

164
00:09:08,560 --> 00:09:12,080
ასე რომ მარყუჟი არ იქნება შესრულებული ერთხელ.

165
00:09:12,080 --> 00:09:15,290
სწორედ ეს სამი ტიპის მარყუჟების ჩვენ გამოიყენონ C.

166
00:09:15,290 --> 00:09:18,840
ჩემი სახელი არის ტომი, და ეს არის CS50.