1
00:00:00,000 --> 00:00:10,216
>> [მუსიკის დაკვრა]

2
00:00:10,216 --> 00:00:12,060
>> Zamyla CHAN: ახლა მოდით დაძლევის Greedy.

3
00:00:12,060 --> 00:00:14,390
ამბობენ, რომ თქვენ მოლარე, და თქვენ
უნდა მისცეს თქვენს მომხმარებელს

4
00:00:14,390 --> 00:00:16,309
გარკვეული ცვლილება.

5
00:00:16,309 --> 00:00:18,820
ასევე, თუ თქვენ ხარბ მოლარე,
ნეტავ მინდა შენარჩუნება ყველა

6
00:00:18,820 --> 00:00:20,040
მონეტები საკუთარ თავს.

7
00:00:20,040 --> 00:00:24,310
ასე ნეტავ მისცეს მომხმარებელს მათი ცვლილება
გამოყენებით, როგორც რამდენიმე მონეტები, რაც შეიძლება.

8
00:00:24,310 --> 00:00:27,640
>> თქვენი ამოცანაა ამ p-set განხორციელება
Greedy, პროგრამა, რომელიც

9
00:00:27,640 --> 00:00:30,530
ითვლის მინიმალური რაოდენობა
მონეტები გამოყენებულ იქნას, რათა ნებისმიერი

10
00:00:30,530 --> 00:00:31,940
მოცემული რაოდენობის ცვლილება.

11
00:00:31,940 --> 00:00:35,660
ადრე diving შევიდა პროგრამირების
ცნებები და C სინტაქსი Greedy,

12
00:00:35,660 --> 00:00:38,410
მოდით პირველ განხილვა მეშვეობით Greedy
პროგრამა, და თუ ჩვენ

13
00:00:38,410 --> 00:00:40,570
შეუძლია ალგორითმი.

14
00:00:40,570 --> 00:00:42,560
გახსოვდეთ, რომ ალგორითმი
არის მხოლოდ კომპლექტი

15
00:00:42,560 --> 00:00:44,680
ინსტრუქციები პრობლემის გადაჭრის.

16
00:00:44,680 --> 00:00:48,060
ალგორითმი Greedy იქნებოდა მხოლოდ
მითითებული ლოგიკური წესები და ნაბიჯები,

17
00:00:48,060 --> 00:00:49,000
ჩვენ შეგვიძლია მივყვეთ.

18
00:00:49,000 --> 00:00:52,510
და ისინი ყოველთვის გამოიღო მინიმალური
რაოდენობის მონეტები საჭირო.

19
00:00:52,510 --> 00:00:54,340
>> პირველი, რაც ნეტავ უნდა
ვიცი რამდენად შეცვლის

20
00:00:54,340 --> 00:00:55,710
კუთვნილს მომხმარებელს.

21
00:00:55,710 --> 00:00:58,560
ამ მაგალითად, ვთქვათ, $ 0.32.

22
00:00:58,560 --> 00:01:00,880
არსებობს უამრავი გზა დავუბრუნდეთ $ 0.32.

23
00:01:00,880 --> 00:01:03,950
თქვენ შეიძლება გამოიყენოთ, მაგალითად,
32 pennies.

24
00:01:03,950 --> 00:01:07,560
თუ, თქვენ ცოტა greedier in
არჩევის თქვენი მონეტები, თქვენ შეიძლება გამოიყენოთ

25
00:01:07,560 --> 00:01:11,730
ხუთი მონეტა ნაცვლად 32 მიცემის
მომხმარებელს სამი dimes -

26
00:01:11,730 --> 00:01:14,690
$ 0.10 ყოველ - და ორი pennies -
$ 0.01 ყოველ.

27
00:01:14,690 --> 00:01:16,830
>> მაგრამ შეგვიძლია გავაკეთოთ უკეთესია, ვიდრე ხუთი მონეტა?

28
00:01:16,830 --> 00:01:18,990
შეგვიძლია კი greedier?

29
00:01:18,990 --> 00:01:20,410
საკმაოდ შესაძლოა.

30
00:01:20,410 --> 00:01:23,360
>> მოდით, გავაგრძელოთ გავლით
Greedy პროგრამა, და ვხედავ.

31
00:01:23,360 --> 00:01:27,090
იმ შემთხვევაში, თუ თქვენი საბოლოო მიზანი არის გამოიყენოს რამდენიმე მონეტები
ეს შესაძლებელია, მაშინ ეს იქნება ყველაზე

32
00:01:27,090 --> 00:01:29,680
გონივრული გამოყენება უდიდესი
შესაძლო მონეტები.

33
00:01:29,680 --> 00:01:32,410
ნეტავ მისცეს ერთი მეოთხედი
უკან - $ 0.25 ყოველ -

34
00:01:32,410 --> 00:01:33,640
ვიდრე ხუთი nickels -

35
00:01:33,640 --> 00:01:34,940
$ 0.05 ყოველ.

36
00:01:34,940 --> 00:01:38,260
ასე რომ, ალბათ, ჩვენი მმართველი წესი
Greedy შეიძლება ყოველთვის გამოიყენოს

37
00:01:38,260 --> 00:01:40,590
უდიდესი მონეტა შესაძლებელი.

38
00:01:40,590 --> 00:01:43,640
აქედან მეოთხედი, dimes, nickels,
და pennies, ჩვენი

39
00:01:43,640 --> 00:01:44,830
უდიდესი მონეტა კვარტალში.

40
00:01:44,830 --> 00:01:47,690
ამიტომ ჩვენ ვცდილობთ გამოვიყენოთ მათ პირველი.

41
00:01:47,690 --> 00:01:49,270
>> უკან ჩვენი $ 0.32.

42
00:01:49,270 --> 00:01:52,455
შეგვიძლია გამოვიყენოთ მეოთხედი მისცეს
მომხმარებელს $ 0.32?

43
00:01:52,455 --> 00:01:52,930
დიახ.

44
00:01:52,930 --> 00:01:55,530
რომ დატოვებენ ჩვენს $ 0.07 დატოვა.

45
00:01:55,530 --> 00:01:57,440
>> შეგვიძლია გამოვიყენოთ მეორე კვარტალში?

46
00:01:57,440 --> 00:02:00,100
არა, რადგან 25 მეტია შვიდი.

47
00:02:00,100 --> 00:02:03,470
ჩვენ არ გვინდა, რათა მომხმარებელს
მეტი, ვიდრე ჩვენ ვალში მათ.

48
00:02:03,470 --> 00:02:04,190
>> ყველა უფლება.

49
00:02:04,190 --> 00:02:07,370
ახლა, როდესაც ჩვენ ამოწურა ჩვენი კვარტლები,
მოდით გადაადგილება, რათა მომდევნო უდიდესი

50
00:02:07,370 --> 00:02:09,090
მონეტა, dime.

51
00:02:09,090 --> 00:02:12,400
შეგვიძლია გამოვიყენოთ dime მისცეს
მომხმარებელს მათი $ 0.07 უკან?

52
00:02:12,400 --> 00:02:15,100
არა, რადგან 10 არის უფრო მეტი, ვიდრე შვიდი.

53
00:02:15,100 --> 00:02:18,400
>> ასე რომ მომდევნო უდიდესი მონეტა ხელმისაწვდომი
ჩვენთვის არის ნიკელს.

54
00:02:18,400 --> 00:02:19,590
შეგვიძლია გამოვიყენოთ ნიკელის?

55
00:02:19,590 --> 00:02:20,250
დიახ.

56
00:02:20,250 --> 00:02:22,940
და მაშინ ჩვენ ავღნიშნო აქვს $ 0.02 დარჩენილი.

57
00:02:22,940 --> 00:02:24,910
>> ჩვენ არ შეგვიძლია გამოვიყენოთ ნიკელის დაბრუნების $ 0.02.

58
00:02:24,910 --> 00:02:29,510
ასე რომ, ჩვენ გადავიდა უკანასკნელი მონეტა at
ჩვენს ხელთ - Penny.

59
00:02:29,510 --> 00:02:33,090
და შემდეგ გამოყენებით ორი pennies, ჩვენ მინდა იყოს
მარცხენა ნულოვანი ცენტი, რაც იმას ნიშნავს,

60
00:02:33,090 --> 00:02:36,350
ჩვენ წარმატებით გადახდილი უკან
მომხმარებელს მათი ცვლილება კუთვნილს

61
00:02:36,350 --> 00:02:37,830
იყენებს მხოლოდ ოთხი მონეტები -

62
00:02:37,830 --> 00:02:40,410
ერთი მეოთხედი, ერთი ნიკელის,
და ორი pennies.

63
00:02:40,410 --> 00:02:43,880
>> თქვენ შეგიძლიათ აწარმოებს პერსონალის გადაწყვეტა თუ
ჩვენი ხელმძღვანელი წესი და პროცესში მისცა

64
00:02:43,880 --> 00:02:44,770
us სწორი პასუხი.

65
00:02:44,770 --> 00:02:47,820
ყველაზე პრობლემა კომპლექტი, თქვენ გექნებათ
აწარმოებს პერსონალის გადაწყვეტა, თუ რამდენად

66
00:02:47,820 --> 00:02:49,900
საკუთარი პროგრამა უნდა იმუშაოს.

67
00:02:49,900 --> 00:02:53,390
და კონკრეტული მითითებები
იყოს პრობლემა კომპლექტი specs.

68
00:02:53,390 --> 00:02:57,180
>> მას შემდეგ, რაც ჩვენ აწარმოებს პერსონალის გადაწყვეტა, ეს
თხოვს us რამდენად შეცვლის კუთვნილს

69
00:02:57,180 --> 00:02:59,790
აღნიშნავენ, რომ ითხოვს
თანხა დოლარი.

70
00:02:59,790 --> 00:03:03,580
ჩვენ input $ 0.32, 0.32.

71
00:03:03,580 --> 00:03:06,830
იგი გვეუბნება, რომ ოთხი მონეტები კუთვნილს,
შეესაბამება ჩვენი პასუხი.

72
00:03:06,830 --> 00:03:08,160
Fantastic.

73
00:03:08,160 --> 00:03:10,210
>> ახლა მოდით დავიწყოთ ეძებს
at განხორციელების

74
00:03:10,210 --> 00:03:11,780
საქართველოს ხარბ ალგორითმი.

75
00:03:11,780 --> 00:03:13,410
ჩვენ ვიცით, რამდენიმე რამ.

76
00:03:13,410 --> 00:03:17,280
ერთი, რომ ჩვენ უნდა უბიძგონ
პროფაილი თანხის ცვლილება.

77
00:03:17,280 --> 00:03:20,830
>> ორი, რომ ჩვენ გვინდა, რომ დაიცვას ჩვენი
მმართველობის წესის ყოველთვის გამოიყენოს

78
00:03:20,830 --> 00:03:22,990
უდიდესი მონეტა შესაძლებელი.

79
00:03:22,990 --> 00:03:26,370
და სამი, რომ ჩვენ უნდა ტრეკზე
რამდენი მონეტები ვიყენებთ.

80
00:03:26,370 --> 00:03:30,040
იმის გამო, რომ ბოლოს, ჩვენ უნდა ბეჭდვა
რაოდენობის მონეტები, რომ ჩვენ.

81
00:03:30,040 --> 00:03:33,270
>> პირველი, რითაც შესახებ
ამისთვის თანხის ცვლილება.

82
00:03:33,270 --> 00:03:36,880
როდესაც თქვენ გაუმკლავდეთ მომხმარებლის input, რათა
დარწმუნდით, რომ თქვენ ვფიქრობ ყველა

83
00:03:36,880 --> 00:03:40,010
მოთხოვნები input, და მხოლოდ
მიიღოს შეყვანის რომელიც აკმაყოფილებს იმ

84
00:03:40,010 --> 00:03:40,880
მოთხოვნები.

85
00:03:40,880 --> 00:03:44,100
ამ შემთხვევაში, ჩვენ გვინდა, რომ გაუმკლავდეთ
ფულადი ღირებულების დოლარი.

86
00:03:44,100 --> 00:03:48,230
>> GetFloat და GetInt ფუნქციების უზრუნველსაყოფად
რომ შეყვანის numeric.

87
00:03:48,230 --> 00:03:51,700
მაგრამ მომხმარებელს შეუძლია შეყვანის
უარყოფითი რიცხვითი ღირებულებებს.

88
00:03:51,700 --> 00:03:56,260
ასე მახსოვს, მხოლოდ არასამთავრობო უარყოფითი
პორტები, რომელიც მოიცავს ყველა უარყოფითი

89
00:03:56,260 --> 00:03:58,370
ციფრები და ნულოვანი.

90
00:03:58,370 --> 00:04:00,260
>> ამ შემთხვევაში, შემავალი
უნდა იყოს float.

91
00:04:00,260 --> 00:04:01,960
სხვა სიტყვებით, ათობითი რიცხვი.

92
00:04:01,960 --> 00:04:06,000
იმის გამო, რომ პრობლემა კომპლექტი სპეც მოითხოვს
თქვენ მოითხოვოს შეყვანის დოლარი.

93
00:04:06,000 --> 00:04:09,540
>> მაგრამ C, მცურავი პუნქტიანი ღირებულებებს ვერ
წარმოდგენილი იქნება ზუსტად.

94
00:04:09,540 --> 00:04:12,490
რადგან არსებობს სასრული რაოდენობის
ბიტი, რომელიც

95
00:04:12,490 --> 00:04:14,870
წარმოადგენს უსასრულო ღირებულებებს.

96
00:04:14,870 --> 00:04:16,860
მიიღეთ ნომერი 0.1.

97
00:04:16,860 --> 00:04:21,140
მე რომ გთხოვოთ, რომ წერენ 0.1 by
ხელი მეასედ ათობითი ადგილი,

98
00:04:21,140 --> 00:04:24,380
თქვენ უნდა დაწეროთ 1, მოყვება
99 zeroes.

99
00:04:24,380 --> 00:04:27,080
ჩვენ მინდა ველით, რომ ჩვენი კომპიუტერი იქნება
ბეჭდვა ზუსტად იგივე რამ

100
00:04:27,080 --> 00:04:28,330
თუ ჩვენ ვთხოვეთ მას.

101
00:04:28,330 --> 00:04:30,320
>> მოდით ვნახოთ, თუ რას აკეთებს.

102
00:04:30,320 --> 00:04:33,150
მე განიხილავს ბეჭდვა ფასეულობების მიმართ
ბოლოს გავლა.

103
00:04:33,150 --> 00:04:39,270
ახლა, აქ რომ f% არის
placeholder for მცურავი წერტილი.

104
00:04:39,270 --> 00:04:44,530
მაგრამ ჩვენ მიუთითოთ წინასწარ, რომ ჩვენ გვინდა
100 decimals ნაჩვენები, და შემდეგ ახალი

105
00:04:44,530 --> 00:04:46,506
ხაზი გავალამაზოთ გაფორმებით.

106
00:04:46,506 --> 00:04:51,710
>> მას შემდეგ, string, ვირჩევთ 0.1 როგორც
ათწილადი, რომ ჩვენ გვინდა ამობეჭდოთ.

107
00:04:51,710 --> 00:04:56,680
და შედეგი, ერთი, რასაც
ზოგიერთი zeros, მაგრამ შემდეგ

108
00:04:56,680 --> 00:04:57,980
მთელი bunch of ნომრები.

109
00:04:57,980 --> 00:05:00,470
რა თქმა უნდა, არ არის, როგორც მოსალოდნელი იყო.

110
00:05:00,470 --> 00:05:03,490
>> მცურავი პუნქტიანი ორაზროვნება შეუძლია გააცნოს
დამრგვალება შეცდომები თქვენს

111
00:05:03,490 --> 00:05:07,330
გათვლებით, რომ თქვენ
აუცილებლად გვინდა თავიდან ავიცილოთ.

112
00:05:07,330 --> 00:05:10,900
თუ გვინდა, რომ მეტი მაგალითები, თქვენ
შეგიძლიათ ჩამოტვირთოთ imprecision.ce საწყისი

113
00:05:10,900 --> 00:05:14,880
გავლა კოდი, რომელიც არის მარტივი
პროგრამა, რომელიც სთხოვს float და ბეჭდავს ეს

114
00:05:14,880 --> 00:05:17,550
უკან მეასედ ათობითი ადგილი.

115
00:05:17,550 --> 00:05:20,340
რა თქმა უნდა, თუ გსურთ ნახოთ
მეტნაკლებად ათობითი ადგილებში

116
00:05:20,340 --> 00:05:22,410
თქვენ შეგიძლიათ შეცვალოთ საკუთარ თავს.

117
00:05:22,410 --> 00:05:25,740
>> როგორც თქვენ ნახავთ, რომ განსხვავება
ორ არის პატარა, როდესაც თქვენ

118
00:05:25,740 --> 00:05:30,460
to გამრავლებით და დასძინა, მოძრავი, რომ
განსხვავება შეიძლება საბოლოოდ დაამატოთ მდე.

119
00:05:30,460 --> 00:05:31,790
დასაწყისზე Greedy.

120
00:05:31,790 --> 00:05:34,870
ჩვენ გვინდა, რომ თავიდან ავიცილოთ დამრგვალება შეცდომები
by საქმე მთელი ნომრები.

121
00:05:34,870 --> 00:05:38,090
ასე რომ, შემდეგ მივიღებთ ძალაშია შეიტანენ
შესახებ, მოდით გადაიყვანოთ ამ

122
00:05:38,090 --> 00:05:39,550
დოლარი ღირებულება ცენტი.

123
00:05:39,550 --> 00:05:43,420
>> გონებრივად ჩვენ ამისათვის გამრავლებით
დოლარის ღირებულების 100.

124
00:05:43,420 --> 00:05:46,400
მაგრამ მახსოვს, იმიტომ, რომ მცურავი წერტილი
ორაზროვნება, ჩვენ გვსურს

125
00:05:46,400 --> 00:05:48,580
დარწმუნებული ვარ, რომ ჩვენ იყენებთ სწორი მნიშვნელობა.

126
00:05:48,580 --> 00:05:52,510
გამრავლებით 100 არსებითად გადავა
ათობითი ადგილზე ორი ფართები

127
00:05:52,510 --> 00:05:56,640
მარჯვენა, chopping off ან truncating
არაფერი შემდეგ.

128
00:05:56,640 --> 00:05:59,430
>> თუ თქვენ ითამაშოს გარშემო კიდევ რამდენიმე
მაგალითები, თქვენ ნახავთ, რომ თქვენ არ

129
00:05:59,430 --> 00:06:02,980
ყოველთვის მაქვს უფლება, თუ თქვენ
ამ მეთოდის გამოყენება truncating.

130
00:06:02,980 --> 00:06:10,011
მაგალითად, 12.59 ბეჭდური 100
ათობითი ადგილებში, რომელიც გაძლევთ

131
00:06:10,011 --> 00:06:14,050
12,5899, et cetera.

132
00:06:14,050 --> 00:06:18,460
ნეტავ კიდევ 12,58 თუ truncated,
არ 12.59, ისევე, როგორც თქვენ გჭირდებათ.

133
00:06:18,460 --> 00:06:21,130
>> სამაგიეროდ, ეს საუკეთესო გარშემო
პირველი ნომერი.

134
00:06:21,130 --> 00:06:23,930
საბედნიეროდ, C გააჩნია
ფუნქცია მოუწოდა რაუნდი.

135
00:06:23,930 --> 00:06:25,040
ეს არის მათემატიკის ბიბლიოთეკაში.

136
00:06:25,040 --> 00:06:28,540
>> თუ გსურთ ვიცით, როგორ გამოვიყენოთ რაუნდი,
მაშინ თქვენ შეგიძლიათ ზრდიან სახელმძღვანელო, ან

137
00:06:28,540 --> 00:06:30,550
კაცი გვერდზე რომ ფუნქცია.

138
00:06:30,550 --> 00:06:35,510
თქვენ ამ აკრეფით კაცი, მოკლე
სახელმძღვანელო, და შემდეგ ფუნქცია, რომ თქვენ

139
00:06:35,510 --> 00:06:36,620
გვინდა გამოიყურებოდეს up.

140
00:06:36,620 --> 00:06:42,280
ასე აკრეფით კაცი რაუნდი შევიდა ტერმინალში
ბრძანების გამოიტანს სახელმძღვანელო.

141
00:06:42,280 --> 00:06:44,790
>> ეს შეიძლება იყოს ცოტა რთულია decipher,
მაგრამ საბოლოოდ თქვენ

142
00:06:44,790 --> 00:06:45,660
შეეგუონ მას.

143
00:06:45,660 --> 00:06:48,290
კაცი გვერდებზე ნახოთ თუ რა ფუნქცია
აკეთებს, და შემდეგ რამდენიმე

144
00:06:48,290 --> 00:06:50,170
შესაძლო გამოყენებისათვის იგი.

145
00:06:50,170 --> 00:06:52,340
მე დატოვება თქვენ შეისწავლონ
კაცი გვერდზე რაუნდი.

146
00:06:52,340 --> 00:06:55,960
მაგრამ ვიცით, რომ თქვენ შეგიძლიათ გამოიყენოთ ის გარშემო
ღირებულება დროს კონვერტაცია

147
00:06:55,960 --> 00:06:57,180
დოლარი ცენტი.

148
00:06:57,180 --> 00:06:59,690
>> მრგვალი მოგცემთ უკან ნომერი
მონაცემთა type ორმაგი.

149
00:06:59,690 --> 00:07:03,810
და თქვენ შეგიძლიათ გადაიყვანოთ ან მსახიობი
მას int შემდეგ.

150
00:07:03,810 --> 00:07:04,980
დიდი.

151
00:07:04,980 --> 00:07:08,120
ახლა ჩვენ აიძულა შესახებ
ამისთვის ფულადი თანხა, და

152
00:07:08,120 --> 00:07:09,520
გადაიყვანება ის ცენტი.

153
00:07:09,520 --> 00:07:12,410
ახლა ჩვენ შეგვიძლია განახორციელოს ალგორითმი
რომ ყოველთვის იყენებს

154
00:07:12,410 --> 00:07:14,640
ყველაზე დიდი მონეტა შესაძლებელი.

155
00:07:14,640 --> 00:07:17,790
>> გაითვალისწინეთ, რომ არსებობს მრავალი
როგორ უნდა განხორციელდეს Greedy, ისევე, როგორც

156
00:07:17,790 --> 00:07:21,200
არსებობს მრავალი გზა მიახლოება
ყველა კომპიუტერულ მეცნიერებათა პრობლემა.

157
00:07:21,200 --> 00:07:24,040
მოძიებაში ყველაზე უფრო ელეგანტურ გზა,
რომ fun ნაწილი.

158
00:07:24,040 --> 00:07:27,030
მთელი ამ p-კომპლექტი, თუ თქვენი პროგრამა
ზუსტად არ ემთხვევა ჩემი

159
00:07:27,030 --> 00:07:29,190
ახსნა walkthroughs,
რომ კარგადაა.

160
00:07:29,190 --> 00:07:32,870
მაგრამ უბრალოდ დარწმუნდით, რომ ის გადის
შემოწმება 50, აკმაყოფილებს ყველა

161
00:07:32,870 --> 00:07:36,270
მოთხოვნების ჩამოყალიბება სპეციფიკაციები,
და რომ თქვენ განიხილოს თუ არა თქვენი

162
00:07:36,270 --> 00:07:37,670
მიდგომა აქვს კარგი დიზაინი.

163
00:07:37,670 --> 00:07:39,750
>> სხვა სიტყვებით, თუ რამდენად ეფექტური არის ეს?

164
00:07:39,750 --> 00:07:44,400
მაგალითად, თუ ჩაწერეთ განმეორებითი
კოდი ხაზები, ნაცვლად გამოყენებით loop?

165
00:07:44,400 --> 00:07:47,580
წერა კოდი უკეთესი დიზაინი
მოდის გამოცდილება, როგორც თქვენ პროგრესის

166
00:07:47,580 --> 00:07:49,192
მეშვეობით რა თქმა უნდა.

167
00:07:49,192 --> 00:07:52,350
>> ამ გავლა, მე წასვლა მეტი
ორი მეთოდები, რომ შეიძლება გამოყენებულ იქნას

168
00:07:52,350 --> 00:07:53,540
შეავსოთ Greedy.

169
00:07:53,540 --> 00:07:57,160
პირველი მეთოდი არის მეთოდი
მარყუჟების და გამოკლება.

170
00:07:57,160 --> 00:08:00,050
ადრე, როდესაც ჩვენ ვისაუბრეთ მეშვეობით
Greedy პროცესი, ჩვენ მუდმივად

171
00:08:00,050 --> 00:08:03,220
შემოწმდება თუ არა ჩვენ შეგვიძლია გამოვიყენოთ კვარტალში,
და გამოიყენება მეოთხედი სანამ

172
00:08:03,220 --> 00:08:05,670
ღირებულება დარჩენილი ნაკლები იყო $ 0.25.

173
00:08:05,670 --> 00:08:07,990
>> ეს ითარგმნება კარგად
ხოლო loop სტრუქტურა.

174
00:08:07,990 --> 00:08:11,550
მიუხედავად იმისა, რომ შეგიძლიათ კვლავ გამოიყენოთ
კვარტალში, გამოიყენოთ ერთი.

175
00:08:11,550 --> 00:08:15,900
რომ სანამ loop უნდა შეასრულოს მანამ,
როგორც დარჩენილი მნიშვნელობა მეტია

176
00:08:15,900 --> 00:08:18,240
ან ტოლია კვარტლის cent ღირებულება.

177
00:08:18,240 --> 00:08:20,970
ეს იმას ნიშნავს, რომ თქვენ ასევე მინდა
ტრეკზე დარჩენილი ნაღდი

178
00:08:20,970 --> 00:08:24,570
ღირებულება, და განახლება ყოველ
დრო, რომ გამოიყენოთ მონეტა.

179
00:08:24,570 --> 00:08:28,350
>> ასევე გახსოვდეთ, რომ დასასრულს, თქვენი
გამომავალი რაოდენობის მონეტები გამოიყენება.

180
00:08:28,350 --> 00:08:32,400
ასე რომ, კიდევ ერთი რამ ტრეკზე არის
რაოდენობის მონეტები, რომ გამოიყენოთ.

181
00:08:32,400 --> 00:08:35,450
თქვენ შეგიძლიათ შეინახოთ სიმღერა ამ გამოყენებით
კარგად დაასახელა ცვლადები.

182
00:08:35,450 --> 00:08:39,730
და შიგნით ორგანოს თქვენი loop იქნება
იქნება განახლება იმ ცვლადების.

183
00:08:39,730 --> 00:08:43,400
მას შემდეგ, რაც მარყუჟის კვარტალში დასრულდება, თქვენ
შეგიძლიათ გამოიყენოთ მსგავსი ერთი dimes,

184
00:08:43,400 --> 00:08:47,180
და ასე შემდეგ და ასე შემდეგ, სანამ თქვენ
დაბრუნდა ყველა ნაღდი.

185
00:08:47,180 --> 00:08:50,640
>> მე დაწერილი ზოგიერთი ფსევდო კოდი აქ
დაგეხმარებათ ვიზუალიზაციისთვის, თუ რამდენად

186
00:08:50,640 --> 00:08:55,080
პროცესი განვიხილეთ შეიძლება თარგმნოს
C. როგორც ხედავთ აქ, მე ჯერ კიდევ გამოყენებით

187
00:08:55,080 --> 00:08:55,760
ინგლისური სიტყვა.

188
00:08:55,760 --> 00:08:56,830
ეს არ არის C არავის გაუკეთებია.

189
00:08:56,830 --> 00:08:58,590
მაგრამ მე დაიწყო აბზაცის რამ.

190
00:08:58,590 --> 00:09:00,690
მე დააყენა პირობებში შიგნით
ჩემი ფრჩხილებში.

191
00:09:00,690 --> 00:09:03,710
ის იწყებს გამოიყურებოდეს პატარა
ცოტა მოსწონს პროგრამირების კოდი.

192
00:09:03,710 --> 00:09:06,410
>> ფსევდო კოდი არის დიდი გზა
მისაღებად დაიწყო.

193
00:09:06,410 --> 00:09:08,810
ვიზუალიზაციისთვის თქვენი კოდი ადრე
თქვენ ეძებოთ სინტაქსი.

194
00:09:08,810 --> 00:09:12,570
რადგან ხშირად უმძიმესი ნაწილი შესახებ
პრობლემა მართლაც გაგება, თუ რა

195
00:09:12,570 --> 00:09:14,450
ზუსტად თქვენ უნდა გავაკეთოთ.

196
00:09:14,450 --> 00:09:17,490
მას შემდეგ წერთ, რომ ქვემოთ, მაშინ ის
ბევრი ადვილია ეძებოთ ფუნქციები

197
00:09:17,490 --> 00:09:20,390
და სინტაქსის სპეციფიკური თქვენი
ონლაინ ფსევდო კოდი

198
00:09:20,390 --> 00:09:23,760
>> გაითვალისწინეთ, რომ ეს არ შეიძლება იყოს
იდენტური სახის ჩონჩხი

199
00:09:23,760 --> 00:09:25,560
თქვენი კოდი რომ წერთ.

200
00:09:25,560 --> 00:09:27,640
ყოველთვის არსებობს ოპტიმიზაციით
უნდა განხორციელდეს.

201
00:09:27,640 --> 00:09:31,250
და, განსაკუთრებით, ჩემი ფსევდო კოდი
აქ, თუ შეგიძლიათ მიხვდებიან, რაშია საქმე.

202
00:09:31,250 --> 00:09:33,380
>> მაგრამ არსებითად პროცესი
და აზროვნებას

203
00:09:33,380 --> 00:09:35,250
ისევე, როგორც ჩვენ განვიხილეთ.

204
00:09:35,250 --> 00:09:38,350
პირველი ხაზი გვეუბნება, რომ მიიღოს
გარკვეული თანხის დოლარი.

205
00:09:38,350 --> 00:09:40,960
და მეორე გვეუბნება
გადაიყვანოთ იგი ცენტი.

206
00:09:40,960 --> 00:09:45,640
>> და შემდეგ, ხოლო მეოთხედი შეიძლება გამოყენებულ იქნას, ჩვენ
გსურთ გაზარდოთ მონეტის რაოდენობა და

207
00:09:45,640 --> 00:09:47,200
შემცირდება ფულადი თანხა.

208
00:09:47,200 --> 00:09:49,880
იგივე ეხება dimes, nickels,
და pennies.

209
00:09:49,880 --> 00:09:53,230
და ბოლოს, ჩვენ გითხრათ შესახებ
რამდენი მონეტები გამოვიყენეთ.

210
00:09:53,230 --> 00:09:53,750
>> დიდი.

211
00:09:53,750 --> 00:09:55,680
ასე რომ, ასკვნის loop მეთოდით.

212
00:09:55,680 --> 00:09:59,720
ახლა მოდით ვისაუბროთ მოდულარული მეთოდი,
რაც უფრო გაყოფა.

213
00:09:59,720 --> 00:10:03,630
>> ჩვენ ყველა იცნობს პლუს, მინუს,
გამრავლება და გაყოფა ოპერატორები

214
00:10:03,630 --> 00:10:05,030
ჩვენს ხელთ არსებული.

215
00:10:05,030 --> 00:10:09,060
C აქვს ოთხივე იმ, მაგრამ ასევე აქვს
modulo ოპერატორი, რომელსაც წარმოადგენს

216
00:10:09,060 --> 00:10:10,640
პროცენტი ნიშანი.

217
00:10:10,640 --> 00:10:11,940
Modulo მართლაც სისუფთავე.

218
00:10:11,940 --> 00:10:14,880
ეს გაძლევთ დარჩენილი დან
გამყოფი ორი ნომერი.

219
00:10:14,880 --> 00:10:19,910
>> დამახსოვრება ხანგრძლივი სამმართველოს როდესაც
თქვენ დაყოფის, ვთქვათ, 74 სამი?

220
00:10:19,910 --> 00:10:23,510
დაწყებული ათობით ადგილი, თქვენ
ვიცი, რომ 3 გადადის შვიდი

221
00:10:23,510 --> 00:10:27,620
ორჯერ, რათა ექვსი
დარჩენილი ერთი.

222
00:10:27,620 --> 00:10:31,870
ნეტავ დაწერა ორი ზედა, და შემდეგ
სხვაობა 6 შვიდი, ტარების მეტი

223
00:10:31,870 --> 00:10:34,980
დარჩენილი 14
ვიმეორებ პროცესში.

224
00:10:34,980 --> 00:10:39,410
>> სამი გადადის 14 ოთხჯერ
მიიღოს 12, დანარჩენი ორი.

225
00:10:39,410 --> 00:10:40,930
და ორი არ განახორციელოს მეტი აღარ.

226
00:10:40,930 --> 00:10:44,170
ასე რომ, ორი იქნება დატოვეს
ბოლოში დარჩენილი.

227
00:10:44,170 --> 00:10:46,800
>> და ეს რა modulo იძლევა, თქვენ
რომ ნომერი ბოლოში.

228
00:10:46,800 --> 00:10:49,790
ასე რომ 74 modulo სამი მისცემს თქვენ ორი.

229
00:10:49,790 --> 00:10:52,980
10 Modulo ორი, ისე, რომ
მისცემს თქვენ ნულოვანი.

230
00:10:52,980 --> 00:10:56,500
იმის გამო, რომ არ არსებობს რაიმე ნაშთი
როდესაც თქვენ დაყოფის 10 ორი.

231
00:10:56,500 --> 00:11:00,190
>> ექვსი modulo ხუთი, კარგად ხუთ
გადადის ექვსი ერთხელ.

232
00:11:00,190 --> 00:11:01,830
და მერე უკვე ერთი დარჩენილი.

233
00:11:01,830 --> 00:11:04,720
ასე ექვსი modulo ხუთ ერთი.

234
00:11:04,720 --> 00:11:07,950
>> თუ თქვენ გაქვთ შვიდი modulo
ცხრა, ნეტავ კიდევ შვიდი.

235
00:11:07,950 --> 00:11:09,840
იმის გამო, რომ ცხრა მეტია, ვიდრე შვიდი.

236
00:11:09,840 --> 00:11:15,020
ასე რომ არ ყოფს მას ყველა შევიდა შვიდი,
ტოვებს შვიდი რადგან თქვენი პასუხი.

237
00:11:15,020 --> 00:11:18,340
>> თუ ფიქრობთ Modulo ცოტა მეტი,
გახსოვდეთ, რომ იგი გაძლევთ

238
00:11:18,340 --> 00:11:21,020
დანარჩენი შემდეგ თქვენ გაყოფა რაღაც.

239
00:11:21,020 --> 00:11:23,620
ვიფიქროთ, თუ როგორ შეიძლება
შეუძლია გამოიყენოს იგი ხარბ.

240
00:11:23,620 --> 00:11:27,620
ვთქვათ პროფაილი სთხოვს for $ 400,11.

241
00:11:27,620 --> 00:11:30,470
რა გზა გაერკვნენ, თუ რამდენი
მეოთხედი გჭირდებათ გარეშე

242
00:11:30,470 --> 00:11:32,360
იმედი თითოეული?

243
00:11:32,360 --> 00:11:37,480
>> ერთხელ თქვენ გაერკვნენ, თუ რამდენი მეოთხედი
თქვენ შეგიძლიათ გამოიყენოთ, რათა $ 400,11, რამდენად

244
00:11:37,480 --> 00:11:38,880
შეცვლის ნაშთები?

245
00:11:38,880 --> 00:11:42,110
ალბათ კომბინაცია აქ შორის
modulo და გაყოფა მოვიდოდა

246
00:11:42,110 --> 00:11:46,200
მოსახერხებელი გადმოგცეთ მაგარი, დახვეწილი
მიუახლოვდნენ Greedy პრობლემა.

247
00:11:46,200 --> 00:11:49,030
მაგრამ გვახსოვდეს, რომ მმართველი
წესი მაინც ვრცელდება.

248
00:11:49,030 --> 00:11:51,610
ყოველთვის გამოიყენეთ უდიდესი მონეტა შესაძლებელი.

249
00:11:51,610 --> 00:11:55,340
>> ერთხელ თქვენ კეთდება გაანგარიშება როგორ
ბევრი მონეტები გამოყენება, ბოლო ნაბიჯი

250
00:11:55,340 --> 00:11:57,930
არის ამობეჭდოთ ნომერი
მონეტები, რომ თქვენ გათვლილი.

251
00:11:57,930 --> 00:12:01,610
ჯერჯერობით, ჩვენ უკვე გამოყენებით printf
ფუნქციონირებს მხოლოდ სიმები.

252
00:12:01,610 --> 00:12:05,200
მაგრამ როდესაც თქვენ გსურთ ამობეჭდოთ, ან
უბრალოდ ნებისმიერი სახის მონაცემები, რომელიც ინახება

253
00:12:05,200 --> 00:12:09,200
ცვლადი, თქვენ უნდა მიუთითოს
რომ გამოყენებით placeholder.

254
00:12:09,200 --> 00:12:12,400
>> აქ მე შედის მხოლოდ რამდენიმე რჩევა
როგორ უნდა ამობეჭდოთ ღირებულებებს.

255
00:12:12,400 --> 00:12:16,390
თუ თქვენ გაქვთ რიცხვი, თქვენ ამას
დაწერეთ თქვენი string გამოყენებით% d, როგორც

256
00:12:16,390 --> 00:12:17,450
placeholder.

257
00:12:17,450 --> 00:12:20,170
დახურვის შემდეგ ციტატა
მარკა, შეიყვანეთ მძიმით.

258
00:12:20,170 --> 00:12:24,530
და შემდეგ დააყენა მთელი რიცხვი, რომელიც
მიიღოს ადგილის% d როდესაც იბეჭდება.

259
00:12:24,530 --> 00:12:27,150
>> ამიტომ მას შემდეგ, ჩვენებისას ნომერი
მონეტები გამოყენებული, თქვენ

260
00:12:27,150 --> 00:12:28,500
დასრულდა Greedy.

261
00:12:28,500 --> 00:12:32,000
დარწმუნდით, რომ შეამოწმოს ყველა კუთხეში შემთხვევაში,
tidy up თქვენი სტილი ცოტა, და თქვენ

262
00:12:32,000 --> 00:12:33,350
ყველა მითითებული წარმოადგინოს.

263
00:12:33,350 --> 00:12:36,000
ბოლოს, ეს პრობლემა კომპლექტი, თქვენ
იყოს უფრო იცნობს CS50

264
00:12:36,000 --> 00:12:39,940
მოწყობილობების, ტერმინალში და loop
კონსტრუქციები და ცვლადები in C.

265
00:12:39,940 --> 00:12:41,470
>> თქვენ კარგად თქვენს გზა.

266
00:12:41,470 --> 00:12:43,040
სასწავლო მრუდი შეიძლება ჩანს მკაცრი.

267
00:12:43,040 --> 00:12:44,690
ასე რომ, ეტაპობრივად.

268
00:12:44,690 --> 00:12:47,110
დარწმუნდით, რომ თქვენ წერენ გარეთ ფსევდო კოდი
ადრე diving ძალიან ღრმა

269
00:12:47,110 --> 00:12:49,000
თარგმნეს უცხო სინტაქსი.

270
00:12:49,000 --> 00:12:52,030
>> მიიღოს გავაკეთოთ სია, და გაწყვეტის
დავალება შევიდა პატარა, უფრო

271
00:12:52,030 --> 00:12:53,440
მართვადი ამოცანები.

272
00:12:53,440 --> 00:12:55,810
შეისწავლონ ყველა CS50 რესურსები.

273
00:12:55,810 --> 00:12:58,270
გარდა იმისა, რომ ლექციის rewatch
ამ გავლა.

274
00:12:58,270 --> 00:12:59,790
>> გადაიხადოს ყურადღებას მონაკვეთზე.

275
00:12:59,790 --> 00:13:00,710
შეამოწმეთ შორტები.

276
00:13:00,710 --> 00:13:04,640
წავიკითხე თქვენი თანაკლასელები კითხვებს
on საუბარი, და გამოაქვეყნოთ თქვენი საკუთარი.

277
00:13:04,640 --> 00:13:06,110
>> საუკეთესო გისურვებთ p-set.

278
00:13:06,110 --> 00:13:07,200
და მადლობა თვალს.

279
00:13:07,200 --> 00:13:08,690
ეს იყო Greedy.

280
00:13:08,690 --> 00:13:15,691
>> [მუსიკის დაკვრა]