1
00:00:00,000 --> 00:00:00,500

2
00:00:00,500 --> 00:00:02,500
ZAMYLA chan: ეს არის ჩემთვის, Zamyla.

3
00:00:02,500 --> 00:00:06,910
დღეს Mario, ჩვენ ვაპირებთ, რომ იყოს
ხატვის ნახევარი პირამიდის Mario

4
00:00:06,910 --> 00:00:08,290
ასვლა.

5
00:00:08,290 --> 00:00:11,570
>> მოდით ვისაუბროთ ჩვენი
to-გავაკეთოთ ამ პრობლემას.

6
00:00:11,570 --> 00:00:13,610
ჩვენ ვაპირებთ, რომ გსურთ
შეეკითხება და შეამოწმოს

7
00:00:13,610 --> 00:00:18,290
მომხმარებელს მოქმედებს შეყვანის როგორ
მაღალი უნდათ Mario პირამიდის უნდა იყოს.

8
00:00:18,290 --> 00:00:20,090
და მაშინ, ჩვენ ვაპირებთ, რომ მოუტანს მას.

9
00:00:20,090 --> 00:00:24,870
მოდით დავიწყოთ კარნახით და
წევრები შესახებ მათი შეყვანა.

10
00:00:24,870 --> 00:00:27,640
>> ჩვენ შეგვიძლია გამოყენება
CS50 ბიბლიოთეკა ფუნქცია

11
00:00:27,640 --> 00:00:31,160
კიდევ int რომელიც უზრუნველყოფს, რომ
მომხმარებლის საშუალებებით რიცხვი.

12
00:00:31,160 --> 00:00:35,730
ნებისმიერი დადებითი რიცხვებით, უარყოფითი
რიცხვებით, ნომერი 0 ყველა სამართლიანი თამაში.

13
00:00:35,730 --> 00:00:41,670
წინააღმდეგ შემთხვევაში, მომხმარებელს მოთხოვნილია
კვალვ, სანამ ისინი შემავალი სწორი რიცხვი.

14
00:00:41,670 --> 00:00:44,210
ახლა მიუხედავად იმისა, რომ კიდევ int აკეთებს
ბევრი ჩვენთვის მუშაობა

15
00:00:44,210 --> 00:00:46,730
იმის უზრუნველსაყოფად, რომ
შესახებ გვაძლევს რიცხვი,

16
00:00:46,730 --> 00:00:50,760
ჩვენ მაინც უნდა მიმართოს
დამატებითი შეზღუდვების შესახებ, რომ.

17
00:00:50,760 --> 00:00:56,420
ყოველივე ამის შემდეგ, ჩვენ არ შეგვიძლია Mario ასვლა
ნახევარი პირამიდის სიმაღლე უარყოფითი 12.

18
00:00:56,420 --> 00:00:59,040
>> გარდა ამისა, რომ
პრობლემა დაზუსტება

19
00:00:59,040 --> 00:01:02,490
ამბობს, რომ ჩვენ შეგვიძლია მხოლოდ
საშუალებას Mario ასვლა

20
00:01:02,490 --> 00:01:06,940
პირამიდის სიმაღლეებზე 0-დან 23.

21
00:01:06,940 --> 00:01:11,120
OK, ასე რომ, ეს იმას ნიშნავს, რომ ჩვენ უნდა
მუდმივად უბიძგონ შესახებ

22
00:01:11,120 --> 00:01:14,320
მოგვცეს ძალაშია
ნომერი და მხოლოდ გაგრძელდება

23
00:01:14,320 --> 00:01:17,120
ერთხელ ისინი მოგვცა სწორი სიმაღლე.

24
00:01:17,120 --> 00:01:18,720
როგორ უნდა გავაკეთოთ, რომ?

25
00:01:18,720 --> 00:01:23,760
>> ისე, უწყვეტი პროცესები მოგვცეს
იდეა მარყუჟების თავისსავე

26
00:01:23,760 --> 00:01:24,720
განმეორებით.

27
00:01:24,720 --> 00:01:28,220
ერთი loop in C, როგორც მაშინ, როდესაც
loop, რომელიც მუდმივად

28
00:01:28,220 --> 00:01:33,480
შეასრულოს ორგანოს მარყუჟის, რადგან
მოცემული მდგომარეობა აფასებს ჭეშმარიტი.

29
00:01:33,480 --> 00:01:36,200
როგორც კი მდგომარეობა
აფასებს მცდარია,

30
00:01:36,200 --> 00:01:39,770
პროგრამის გაგრძელება
რაც შეეხება შემდეგ.

31
00:01:39,770 --> 00:01:43,180
ასე რომ, ხოლო მარყუჟების ერთი გზა
უზრუნველსაყოფად, რომ ჩვენ მუდმივად

32
00:01:43,180 --> 00:01:45,320
შეგახსენებთ მომხმარებლის მოქმედებს შეყვანის.

33
00:01:45,320 --> 00:01:50,070
და კიდევ, მათ მოგვცეს სწორი შეყვანის,
ჩვენ გაგრძელება, რასაც მოდის მომავალი.

34
00:01:50,070 --> 00:01:54,380
ჩვენ ვიცით, რომ ვაპირებთ, ვთხოვოთ
მომხმარებლის ამისთვის შეყვანის ერთხელ მაინც.

35
00:01:54,380 --> 00:01:59,200
ასე რომ, ახლა მივალთ დამ
ხოლო loop, რომელიც არის do ხოლო loop.

36
00:01:59,200 --> 00:02:02,650
>> ნუ ხოლო მარყუჟების შეასრულოს
ორგანოს მარყუჟის ერთხელ მაინც.

37
00:02:02,650 --> 00:02:06,150
ასე რომ, შემოწმების გარეშე მდგომარეობაში,
ეს იქნება შეასრულოს ორგანოს loop.

38
00:02:06,150 --> 00:02:09,750
და შემდეგ შეამოწმოს მდგომარეობა ვხედავ
თუ არა მას სჭირდება განმეორებაზე.

39
00:02:09,750 --> 00:02:13,080
ეს მოდის მოსახერხებელია, როდესაც
ჩვენ წევრები მომხმარებლის შეყვანის.

40
00:02:13,080 --> 00:02:15,830
ჩვენ ვიცით, რომ ჩვენ ვაპირებთ
მათ ვთხოვთ, ერთხელ მაინც.

41
00:02:15,830 --> 00:02:18,780
ასე რომ, ნუ ხოლო მარყუჟის შეიძლება
რაღაც ამის მსგავსი.

42
00:02:18,780 --> 00:02:20,090
ჩვენ გვაქვს მთელი რიცხვი n.

43
00:02:20,090 --> 00:02:22,760
და შიგნით do
ხოლო მარყუჟის, ჩვენ დაუყოვნებლივ

44
00:02:22,760 --> 00:02:24,750
შეეკითხება მომხმარებელს რიცხვი.

45
00:02:24,750 --> 00:02:29,740
თუ n არასწორია, მაშინ ჩვენ, აიძულებს
ისევ და ისევ და ისევ, სანამ ისინი

46
00:02:29,740 --> 00:02:31,820
გვაძლევს, რომ სწორი რიცხვი.

47
00:02:31,820 --> 00:02:37,440
და ბოლოს, ერთხელ n არის სწორი შეყვანის, ჩვენ
გაგრძელება დანარჩენი ჩვენი პროგრამა.

48
00:02:37,440 --> 00:02:41,830
>> მოდით დავუბრუნდეთ სპეც და შემოწმება
რა პირობებს მოქმედებს შეყვანის

49
00:02:41,830 --> 00:02:43,670
იქნება.

50
00:02:43,670 --> 00:02:48,090
მოქმედი სიმაღლეებზე ვაპირებთ
იყოს 0-დან 23-ის ჩათვლით.

51
00:02:48,090 --> 00:02:53,350
ასე რომ, არასწორი სიმაღლეებზე ვაპირებთ
იყოს ნაკლები ვიდრე 0 ან მეტი 23.

52
00:02:53,350 --> 00:02:56,420
ასე მახსოვს, რათა შეიმუშავონ
თქვენი მდგომარეობა ყურადღებით,

53
00:02:56,420 --> 00:02:58,660
იცის, რომ მდგომარეობა
იმ do ხოლო loop

54
00:02:58,660 --> 00:03:01,470
უნდა იყოს, ხოლო n არასწორია.

55
00:03:01,470 --> 00:03:05,080
ახლა ეს არ აპირებს იყოს
მარტივი ერთი ლოგიკური გამოხატულებაა.

56
00:03:05,080 --> 00:03:07,630
ჩვენ ვაპირებთ, რომ უნდა დააკავშიროთ
ორი სხვადასხვა გამონათქვამები

57
00:03:07,630 --> 00:03:09,900
იმისათვის, რომ ჩვენი მთელი მდგომარეობა.

58
00:03:09,900 --> 00:03:13,290
>> მოდით შევხედოთ სიმართლე მაგიდა მე
უკვე მოცემული მინიშნება, რომ ჩვენ

59
00:03:13,290 --> 00:03:15,200
იქნება საქმე ორი Booleans.

60
00:03:15,200 --> 00:03:19,620
ასე რომ, აქ არის სიმართლე მაგიდა, სადაც მე
აქვს ორი Booleans-- ლოგიკური 1 და 2.

61
00:03:19,620 --> 00:03:27,050
ასე რომ, ჩვენ გვაქვს შესაძლებლობა შეაფასოს
bool1 და bool2 ან bool1 ან bool2.

62
00:03:27,050 --> 00:03:31,980
და მხოლოდ მაშინ იქნება ნამდვილი თუ ორივე
Booleans შეაფასოს ჭეშმარიტი, ხოლო ყველა

63
00:03:31,980 --> 00:03:37,280
ან იქნება ჭეშმარიტი, რადგან ერთ-ერთი
ორი Booleans აფასებს ჭეშმარიტი.

64
00:03:37,280 --> 00:03:41,450
OK, ასე რომ, ერთი წუთით, შეაჩეროს ეს
ვიდეო და მონელება სიმართლე მაგიდა.

65
00:03:41,450 --> 00:03:42,930
მე ვიქნები უფლება აქ გელოდებათ.

66
00:03:42,930 --> 00:03:45,760
როცა დავბრუნდები, ვხედავ
თუ შეგიძლიათ ცალი ერთად

67
00:03:45,760 --> 00:03:51,910
ლოგიკური გამოხატვის თქვენი
მდგომარეობა n მყოფი არასწორი შეყვანის.

68
00:03:51,910 --> 00:03:54,420
>> ასე რომ, ახლა, რომ ჩვენ გვაქვს
მოქმედებს მომხმარებლის შეყვანის, მოდით

69
00:03:54,420 --> 00:03:58,710
წავიდეთ წინ და ვისაუბროთ, თუ როგორ
შეიძლება შევაჩერო ნახევარი პირამიდის.

70
00:03:58,710 --> 00:04:03,410
აქ, ამ მარტივი ტექსტური რედაქტორი,
მე შედგენილი მარცხენა მიუერთდა პირამიდის.

71
00:04:03,410 --> 00:04:07,050
მაგრამ ჩვენ ვიცით, რომ ჩვენ უნდა ჩვენი
პირამიდის იყოს უფლება მიუერთდა.

72
00:04:07,050 --> 00:04:08,650
ასე როგორ შეიძლება ამის გაკეთება?

73
00:04:08,650 --> 00:04:11,440
ისე, მე შეიძლება ცდილობენ დააყენებს
იმისათვის, რომ მხარე

74
00:04:11,440 --> 00:04:14,880
მხოლოდ აყენებს პატარა
ხასიათი შორის.

75
00:04:14,880 --> 00:04:16,779
და შემდეგ, მომდევნო
ხაზი, მე ვაპირებ დააყენა

76
00:04:16,779 --> 00:04:20,970
კიდევ რამდენიმე პერსონაჟი დააყენებს ის გასწვრივ,
და further-- და ასე forth--

77
00:04:20,970 --> 00:04:23,360
სანამ მე მაქვს უფლება მიუერთდა პირამიდის.

78
00:04:23,360 --> 00:04:27,780
ასე რომ, ჩვენ გვაქვს უფლება align პირამიდის, მაგრამ
ეს არ გამოიყურება ისე დიდი წერტილები.

79
00:04:27,780 --> 00:04:30,680
მაგრამ ჩვენ მაინც მინდა
ამტკიცებენ, რომ ლამაზი ინტერვალი.

80
00:04:30,680 --> 00:04:35,260
ამიტომ, მე ვაპირებ, რომ ფაქტიურად
ჩადეთ ზოგიერთი ფართები.

81
00:04:35,260 --> 00:04:39,420
>> იმის ნაცვლად, რომ სამი წერტილი, მე
ბოლო ერთი, ორი, სამი ფართები.

82
00:04:39,420 --> 00:04:40,370
მეორე ხაზი.

83
00:04:40,370 --> 00:04:42,640
მე ამას ერთი, ორი ფართები.

84
00:04:42,640 --> 00:04:45,370
და ბოლოსწინა
ხაზი, უბრალოდ ერთ სივრცეში.

85
00:04:45,370 --> 00:04:48,290
და აქ მე მაქვს უფლება მიუერთდა პირამიდის.

86
00:04:48,290 --> 00:04:52,170
აკეთებს, მაგალითად, ტექსტი
რედაქტორი, ჩვენ გვაქვს იდეა ნიმუში

87
00:04:52,170 --> 00:04:54,590
რომ ჩვენ გამოვიყენებთ მიაპყროს ნახევარი პირამიდის.

88
00:04:54,590 --> 00:04:58,080
ყოველ ზედიზედ, რაც ჩვენ გავაკეთეთ
არის ჩვენ აკრიფოთ ზოგიერთი ფართები,

89
00:04:58,080 --> 00:05:00,170
და მაშინ აკრეფილი ზოგიერთი
ჰეშები და მაშინ აკრეფილი

90
00:05:00,170 --> 00:05:03,020
Enter, რომელიც
შექმნა ახალი ხაზი.

91
00:05:03,020 --> 00:05:07,770
ასე რომ, ახლა, რომ ჩვენ გვაქვს, რომ, მოდით წავიდეთ
ერთი ნაბიჯია და ნიმუში.

92
00:05:07,770 --> 00:05:10,170
>> ასე რომ, მე ვაპირებ ვთქვა, რომ
ინტერესი ამ მაგალითად,

93
00:05:10,170 --> 00:05:12,480
ჩვენ საქმე გვაქვს სიმაღლე 8.

94
00:05:12,480 --> 00:05:17,100
პირველი რიგის აპირებს აქვს ორი
ჰეშები რომ შემდეგნაირად შვიდი სივრცეებს.

95
00:05:17,100 --> 00:05:20,020
Second-- სამი ჰეშები, ექვსი ფართები.

96
00:05:20,020 --> 00:05:24,260
მესამე row-- ოთხი ჰეშები, ხუთ
spaces-- ასე შემდეგ და ასე შემდეგ

97
00:05:24,260 --> 00:05:26,350
სანამ არ მივიღებთ nth ზედიზედ.

98
00:05:26,350 --> 00:05:31,540
ასე რომ, მე გთხოვთ nth ზედიზედ
რამდენი ჰეშები ჩვენ ვაპირებთ აქვს

99
00:05:31,540 --> 00:05:33,120
და რამდენი ფართები?

100
00:05:33,120 --> 00:05:37,000
ასე რომ, ეს თქვენ, რათა გაერკვნენ
ფორმულა წარმოადგენს რამდენი ჰეშები

101
00:05:37,000 --> 00:05:42,020
და რამდენი ფართები საჭირო
nth ზედიზედ როდესაც თქვენ გაქვთ გარკვეული სიმაღლე.

102
00:05:42,020 --> 00:05:46,060
>> ახლა, როდესაც თქვენ მჭიდროდაა ამ გარეთ,
ფრთხილად, თუ თქვენ ინდექსირებას.

103
00:05:46,060 --> 00:05:49,170
რა ნიშნავს ეს ის არის, რომ
ყოველდღიურ ცხოვრებაში ყველა ჩვენგანისთვის

104
00:05:49,170 --> 00:05:51,540
დაიწყება დათვლის, როგორც წესი 1.

105
00:05:51,540 --> 00:05:55,950
მაგრამ CS50 და კომპიუტერულ მეცნიერებათა
ზოგადად, ჩვენ 0 ინდექსირებული.

106
00:05:55,950 --> 00:06:00,620
ასე რომ, პირველი რიგის იქნება
n 0 განსხვავებით 1.

107
00:06:00,620 --> 00:06:04,550
ფრთხილად, როდესაც თქვენ
ცდილობენ გაერკვნენ თქვენი ნიმუში.

108
00:06:04,550 --> 00:06:07,570
ასე რომ, ახლა მოდით დავუბრუნდეთ, თუ როგორ
ჩვენ ვაპირებთ, რომ მიაპყროს ჩვენი პირამიდის.

109
00:06:07,570 --> 00:06:12,300
ყოველ ზედიზედ, ჩვენ ვაპირებთ, რომ სურს
ბეჭდვა ფართები, ბეჭდვა ჰეშები,

110
00:06:12,300 --> 00:06:14,050
და შემდეგ ბეჭდვა ახალი ხაზი.

111
00:06:14,050 --> 00:06:19,160
მინიშნება აქ არის
სიტყვა "" ყოველ ზედიზედ.

112
00:06:19,160 --> 00:06:21,470
In C, ჩვენ გვაქვს მშენებლობა
მოუწოდა ამისთვის მარყუჟის,

113
00:06:21,470 --> 00:06:25,250
რომელიც შედგება საქართველოს
ინიციალიზაციისას, მდგომარეობა, განახლება,

114
00:06:25,250 --> 00:06:26,790
და ორგანოს loop.

115
00:06:26,790 --> 00:06:31,360
>> ამბობენ, რომ ამის თქმა მინდოდა, hello
მსოფლიოში, 50 ჯერ, ჩემი ამისთვის loop

116
00:06:31,360 --> 00:06:32,880
გამოიყურება რაღაც მოსწონს ეს.

117
00:06:32,880 --> 00:06:35,480
ინიციალიზაცია ჩემი რიცხვი 0.

118
00:06:35,480 --> 00:06:38,230
მდგომარეობა არის, რომ მე ნაკლებია, ვიდრე 50.

119
00:06:38,230 --> 00:06:42,350
და მაშინ ჩემი განახლება მხოლოდ
დამატება I ერთი ყოველ ჯერზე.

120
00:06:42,350 --> 00:06:45,140
ჩვენ ასევე შეგიძლიათ მარყუჟების
iterate მეტი რამ.

121
00:06:45,140 --> 00:06:47,820
გაითვალისწინეთ აქ როგორ არ გვაქვს
მყარი კოდირებული ნომერი,

122
00:06:47,820 --> 00:06:51,820
არამედ განთავსებული ცვლადი
სიმაღლე ნაცვლად შევიდა მდგომარეობაშია.

123
00:06:51,820 --> 00:06:56,420
ასე რომ, რასაც მე ვაკეთებ, აქ მე iterating
ყოველ ზედიზედ პირამიდის.

124
00:06:56,420 --> 00:07:00,160
შემიძლია რაღაც თითოეული
ზედიზედ შიგნით ორგანო ჩემი loop.

125
00:07:00,160 --> 00:07:02,350
>> რას ვაკეთებთ შიგნით
ორგანოს loop?

126
00:07:02,350 --> 00:07:07,120
ისე, როგორც უკვე განაცხადა, ჩვენ დაბეჭდვის
ფართები და ჩვენ დაბეჭდვის ჰეშები

127
00:07:07,120 --> 00:07:09,480
და ჩვენ დაბეჭდვის ახალი ხაზი.

128
00:07:09,480 --> 00:07:11,950
ასე რომ, ჩემი გარე მარყუჟის
ასე გამოიყურება.

129
00:07:11,950 --> 00:07:15,070
მე iterate მეტი ყოველ ზედიზედ
პირამიდის გამოყენებით,

130
00:07:15,070 --> 00:07:18,890
ამ შემთხვევაში, სიმაღლე, როგორც ცვლადი
რომ ინახავს სიმაღლე პირამიდის.

131
00:07:18,890 --> 00:07:22,870
შიგნით ორგანოს, რომ loop, მე
აპირებს ბეჭდვა ფართები არაერთხელ, ბეჭდვა

132
00:07:22,870 --> 00:07:26,730
ჰეშები არაერთგზის,
და შემდეგ ბეჭდვა ახალი ხაზი.

133
00:07:26,730 --> 00:07:31,010
>> ასე რომ, ახლა გამოყენებით ყველა ცნებები,
მე ისაუბრა ამ მსვლელობა მეშვეობით,

134
00:07:31,010 --> 00:07:35,210
თქვენ უნდა შეეძლოს შეეკითხება
მომხმარებლის შეყვანის, შეამოწმოს, რომ input,

135
00:07:35,210 --> 00:07:37,370
ხოლო შემდეგ მიაპყროს ნახევარი პირამიდის.

136
00:07:37,370 --> 00:07:41,510
>> ჩემი სახელი არის Zamyla, და ეს არის CS50.

137
00:07:41,510 --> 00:07:43,167