1
00:00:00,000 --> 00:00:10,216
>> [MUSIC PLAYING]

2
00:00:10,216 --> 00:00:12,060
>> ZAMYLA CHAN: Now let's tackle Greedy.

3
00:00:12,060 --> 00:00:14,390
Say you're a cashier, and you
need to give your customer a

4
00:00:14,390 --> 00:00:16,309
certain amount of change.

5
00:00:16,309 --> 00:00:18,820
Well, if you were a greedy cashier,
you'd want to keep all

6
00:00:18,820 --> 00:00:20,040
the coins to yourself.

7
00:00:20,040 --> 00:00:24,310
So you'd give the customer their change
using as few coins as possible.

8
00:00:24,310 --> 00:00:27,640
>> Your task for this p-set is to implement
Greedy, a program that

9
00:00:27,640 --> 00:00:30,530
calculates the minimum number
of coins used to make any

10
00:00:30,530 --> 00:00:31,940
given amount of change.

11
00:00:31,940 --> 00:00:35,660
Before diving into the programming
concepts and C syntax for Greedy,

12
00:00:35,660 --> 00:00:38,410
let's first talk through the Greedy
program, and see if we

13
00:00:38,410 --> 00:00:40,570
can identify an algorithm.

14
00:00:40,570 --> 00:00:42,560
Remember that an algorithm
is just a set of

15
00:00:42,560 --> 00:00:44,680
instructions for solving problems.

16
00:00:44,680 --> 00:00:48,060
An algorithm for Greedy would just be a
set of logical rules and steps that

17
00:00:48,060 --> 00:00:49,000
we can follow.

18
00:00:49,000 --> 00:00:52,510
And they will always yield the minimum
number of coins needed.

19
00:00:52,510 --> 00:00:54,340
>> The first thing you'd need to
know is how much change

20
00:00:54,340 --> 00:00:55,710
is owed to the customer.

21
00:00:55,710 --> 00:00:58,560
For this example, let's say $0.32.

22
00:00:58,560 --> 00:01:00,880
There are many ways to get back $0.32.

23
00:01:00,880 --> 00:01:03,950
You could use, for instance,
32 pennies.

24
00:01:03,950 --> 00:01:07,560
Or if, you were a bit greedier in
choosing your coins, you could use

25
00:01:07,560 --> 00:01:11,730
five coins instead of 32 by giving
the customer three dimes--

26
00:01:11,730 --> 00:01:14,690
$0.10 each-- and two pennies--
$0.01 each.

27
00:01:14,690 --> 00:01:16,830
>> But can we do better than five coins?

28
00:01:16,830 --> 00:01:18,990
Can we be even greedier?

29
00:01:18,990 --> 00:01:20,410
Quite possibly.

30
00:01:20,410 --> 00:01:23,360
>> Let's continue walking through
the Greedy program, and see.

31
00:01:23,360 --> 00:01:27,090
If your end goal is to use a few coins
as possible, then it would be most

32
00:01:27,090 --> 00:01:29,680
prudent to use the largest
possible coins.

33
00:01:29,680 --> 00:01:32,410
You'd rather give one quarter
back-- $0.25 each--

34
00:01:32,410 --> 00:01:33,640
than five nickels--

35
00:01:33,640 --> 00:01:34,940
$0.05 each.

36
00:01:34,940 --> 00:01:38,260
So perhaps our governing rule for
Greedy can be to always use the

37
00:01:38,260 --> 00:01:40,590
largest coin possible.

38
00:01:40,590 --> 00:01:43,640
Out of quarters, dimes, nickels,
and pennies, our

39
00:01:43,640 --> 00:01:44,830
largest coin is the quarter.

40
00:01:44,830 --> 00:01:47,690
So we'll try to use them first.

41
00:01:47,690 --> 00:01:49,270
>> Back to our $0.32.

42
00:01:49,270 --> 00:01:52,455
Can we use a quarter to give
the customer $0.32?

43
00:01:52,455 --> 00:01:52,930
Yes.

44
00:01:52,930 --> 00:01:55,530
That would leave us with $0.07 left.

45
00:01:55,530 --> 00:01:57,440
>> Can we use another quarter?

46
00:01:57,440 --> 00:02:00,100
No, because 25 is greater than seven.

47
00:02:00,100 --> 00:02:03,470
We don't want to give the customer
any more than we owe them.

48
00:02:03,470 --> 00:02:04,190
>> All right.

49
00:02:04,190 --> 00:02:07,370
Now that we've exhausted our quarters,
let's move on to the next largest

50
00:02:07,370 --> 00:02:09,090
coin, the dime.

51
00:02:09,090 --> 00:02:12,400
Can we use a dime to give the
customer their $0.07 back?

52
00:02:12,400 --> 00:02:15,100
No, since 10 is greater than seven.

53
00:02:15,100 --> 00:02:18,400
>> So then the next largest coin accessible
to us is the nickel.

54
00:02:18,400 --> 00:02:19,590
Can we use a nickel?

55
00:02:19,590 --> 00:02:20,250
Yes.

56
00:02:20,250 --> 00:02:22,940
And then we'd have $0.02 left over.

57
00:02:22,940 --> 00:02:24,910
>> We can't use a nickel to return $0.02.

58
00:02:24,910 --> 00:02:29,510
So we moved the last coin at
our disposal-- the penny.

59
00:02:29,510 --> 00:02:33,090
And after using two pennies, we'd be
left with zero cents, which means that

60
00:02:33,090 --> 00:02:36,350
we've successfully paid back
the user their change owed

61
00:02:36,350 --> 00:02:37,830
using only four coins--

62
00:02:37,830 --> 00:02:40,410
one quarter, one nickel,
and two pennies.

63
00:02:40,410 --> 00:02:43,880
>> You can run the staff solution to see if
our governing rule and process gave

64
00:02:43,880 --> 00:02:44,770
us the right answer.

65
00:02:44,770 --> 00:02:47,820
For most problem sets, you'll be able
to run the staff solution to see how

66
00:02:47,820 --> 00:02:49,900
your own program should work.

67
00:02:49,900 --> 00:02:53,390
And specific instructions will
be in the problem sets specs.

68
00:02:53,390 --> 00:02:57,180
>> Once we run the staff solution, it
prompts us for how much change is owed

69
00:02:57,180 --> 00:02:59,790
note that it asks for the
amount in dollars.

70
00:02:59,790 --> 00:03:03,580
We input $0.32, 0.32.

71
00:03:03,580 --> 00:03:06,830
It tells us that four coins are owed,
consistent with our answer.

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

73
00:03:08,160 --> 00:03:10,210
>> So now let's start looking
at the implementation

74
00:03:10,210 --> 00:03:11,780
of the Greedy algorithm.

75
00:03:11,780 --> 00:03:13,410
We know a couple things.

76
00:03:13,410 --> 00:03:17,280
One, that we'll need to prompt the
user for an amount of change.

77
00:03:17,280 --> 00:03:20,830
>> Two, that we'll want to follow our
governing rule to always use the

78
00:03:20,830 --> 00:03:22,990
largest coin possible.

79
00:03:22,990 --> 00:03:26,370
And three, that we need to keep track
of how many coins we use.

80
00:03:26,370 --> 00:03:30,040
Because lastly, we need to print
the number of coins that we.

81
00:03:30,040 --> 00:03:33,270
>> First, prompting the user
for an amount of change.

82
00:03:33,270 --> 00:03:36,880
Whenever you deal with user input, make
sure that you think of all of the

83
00:03:36,880 --> 00:03:40,010
requirements of the input, and only
accept input that meets those

84
00:03:40,010 --> 00:03:40,880
requirements.

85
00:03:40,880 --> 00:03:44,100
In this case, we want to deal with
a monetary value in dollars.

86
00:03:44,100 --> 00:03:48,230
>> The GetFloat and GetInt functions ensure
that the input is numeric.

87
00:03:48,230 --> 00:03:51,700
But the user is able to input
negative numeric values.

88
00:03:51,700 --> 00:03:56,260
So remember to only use non-negative
inputs, which includes all negative

89
00:03:56,260 --> 00:03:58,370
numbers and zero.

90
00:03:58,370 --> 00:04:00,260
>> In this case, the input
should be a float.

91
00:04:00,260 --> 00:04:01,960
In other words, a decimal number.

92
00:04:01,960 --> 00:04:06,000
Because the problem set spec requires
you to ask for input in dollars.

93
00:04:06,000 --> 00:04:09,540
>> But in C, floating point values can't
be represented accurately.

94
00:04:09,540 --> 00:04:12,490
Because there are a finite number
of bits with which to

95
00:04:12,490 --> 00:04:14,870
represent infinite values.

96
00:04:14,870 --> 00:04:16,860
Take the number 0.1.

97
00:04:16,860 --> 00:04:21,140
If I were to ask you to write 0.1 by
hand to the hundredth decimal place,

98
00:04:21,140 --> 00:04:24,380
you would write a 1, followed
by 99 zeroes.

99
00:04:24,380 --> 00:04:27,080
We'd expect that our computer would
print the exact same thing

100
00:04:27,080 --> 00:04:28,330
if we asked it to.

101
00:04:28,330 --> 00:04:30,320
>> So let's see what it does.

102
00:04:30,320 --> 00:04:33,150
I'll review printing values towards
the end of this walk through.

103
00:04:33,150 --> 00:04:39,270
For now, see here that f% is a
placeholder for a floating point.

104
00:04:39,270 --> 00:04:44,530
But we specify beforehand that we want
100 decimals displayed, and then a new

105
00:04:44,530 --> 00:04:46,506
line for nicer formatting.

106
00:04:46,506 --> 00:04:51,710
>> After the string, we choose 0.1 as the
float that we want to print out.

107
00:04:51,710 --> 00:04:56,680
And the result, a one, followed
by some zeros, but then a

108
00:04:56,680 --> 00:04:57,980
whole bunch of numbers.

109
00:04:57,980 --> 00:05:00,470
Certainly not as expected.

110
00:05:00,470 --> 00:05:03,490
>> Floating point imprecision can introduce
rounding errors into your

111
00:05:03,490 --> 00:05:07,330
calculations that you will
definitely want to avoid.

112
00:05:07,330 --> 00:05:10,900
If you want to see more examples, you
can download imprecision.ce from the

113
00:05:10,900 --> 00:05:14,880
walk through code, which is a simple
program that asks float and prints it

114
00:05:14,880 --> 00:05:17,550
back to the hundredth decimal place.

115
00:05:17,550 --> 00:05:20,340
Of course, if you want to show
more or less decimal places

116
00:05:20,340 --> 00:05:22,410
you can change yourself.

117
00:05:22,410 --> 00:05:25,740
>> As you'll see, though the difference
between the two is small, when you get

118
00:05:25,740 --> 00:05:30,460
to multiplying and adding floats, that
discrepancy can eventually add up.

119
00:05:30,460 --> 00:05:31,790
Back to Greedy.

120
00:05:31,790 --> 00:05:34,870
We'll want to avoid rounding errors
by dealing with whole numbers.

121
00:05:34,870 --> 00:05:38,090
So after we get valid input from
the user, let's convert this

122
00:05:38,090 --> 00:05:39,550
dollar value to cents.

123
00:05:39,550 --> 00:05:43,420
>> Mentally, we do this by multiplying
the dollar value by 100.

124
00:05:43,420 --> 00:05:46,400
But remember, because of floating point
imprecision, we want to make

125
00:05:46,400 --> 00:05:48,580
sure that we're using the right value.

126
00:05:48,580 --> 00:05:52,510
Multiplying by 100 will essentially move
the decimal place two spaces to

127
00:05:52,510 --> 00:05:56,640
the right, chopping off or truncating
anything afterwards.

128
00:05:56,640 --> 00:05:59,430
>> If you play around with some more
examples, you'll see that you won't

129
00:05:59,430 --> 00:06:02,980
always got the right number if you
use this method of truncating.

130
00:06:02,980 --> 00:06:10,011
For instance, 12.59 printed to 100
decimal places, that gives you

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

132
00:06:14,050 --> 00:06:18,460
You'd get 12.58 if you truncated,
not 12.59, like you need.

133
00:06:18,460 --> 00:06:21,130
>> Instead, it's best to round
the number first.

134
00:06:21,130 --> 00:06:23,930
Luckily, C comes with the
function called Round.

135
00:06:23,930 --> 00:06:25,040
It's in the math library.

136
00:06:25,040 --> 00:06:28,540
>> If You want to know how to use Round,
then you can bring up the manual or

137
00:06:28,540 --> 00:06:30,550
man page for that function.

138
00:06:30,550 --> 00:06:35,510
You do this by typing man, short for
manual, and then the function that you

139
00:06:35,510 --> 00:06:36,620
want to look up.

140
00:06:36,620 --> 00:06:42,280
So typing man round into the terminal
command line will bring up the manual.

141
00:06:42,280 --> 00:06:44,790
>> It might be a little hard to decipher,
but eventually you'll

142
00:06:44,790 --> 00:06:45,660
get the hang of it.

143
00:06:45,660 --> 00:06:48,290
Man pages show you what the function
does, and then some

144
00:06:48,290 --> 00:06:50,170
possible uses of it.

145
00:06:50,170 --> 00:06:52,340
I'll leave you to explore
the man page for Round.

146
00:06:52,340 --> 00:06:55,960
But know that you can use it to round
the value during your conversion from

147
00:06:55,960 --> 00:06:57,180
dollars to cents.

148
00:06:57,180 --> 00:06:59,690
>> Round will give you back a number
of data type double.

149
00:06:59,690 --> 00:07:03,810
And you can convert or cast
it to an int afterwards.

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

151
00:07:04,980 --> 00:07:08,120
By now we've prompted the user
for a monetary amount, and

152
00:07:08,120 --> 00:07:09,520
converted it into cents.

153
00:07:09,520 --> 00:07:12,410
Now we can implement an algorithm
that always uses the

154
00:07:12,410 --> 00:07:14,640
biggest coins available.

155
00:07:14,640 --> 00:07:17,790
>> Keep in mind that there are multiple
ways to implement Greedy, just like

156
00:07:17,790 --> 00:07:21,200
there are multiple ways to approach
every computer science problem.

157
00:07:21,200 --> 00:07:24,040
Finding the most elegant way,
that's the fun part.

158
00:07:24,040 --> 00:07:27,030
Throughout these p-sets, if your program
doesn't exactly match my

159
00:07:27,030 --> 00:07:29,190
explanation in the walkthroughs,
that's OK.

160
00:07:29,190 --> 00:07:32,870
But just make sure that it passes
check 50, satisfies all the

161
00:07:32,870 --> 00:07:36,270
requirements form the specifications,
and that you consider whether your

162
00:07:36,270 --> 00:07:37,670
approach has good design.

163
00:07:37,670 --> 00:07:39,750
>> In other words, how efficient is it?

164
00:07:39,750 --> 00:07:44,400
For example, did you type repetitive
code lines, instead of using a loop?

165
00:07:44,400 --> 00:07:47,580
Writing code with better design will
come experience as you progress

166
00:07:47,580 --> 00:07:49,192
through the course.

167
00:07:49,192 --> 00:07:52,350
>> For this walk through, I'll go over
two methods that can be used to

168
00:07:52,350 --> 00:07:53,540
complete Greedy.

169
00:07:53,540 --> 00:07:57,160
The first method is a method using
loops and subtraction.

170
00:07:57,160 --> 00:08:00,050
Earlier, when we talked through the
Greedy process, we continuously

171
00:08:00,050 --> 00:08:03,220
checked whether we could use a quarter,
and used a quarter until the

172
00:08:03,220 --> 00:08:05,670
value remaining was less than $0.25.

173
00:08:05,670 --> 00:08:07,990
>> This translates well to a
while loop structure.

174
00:08:07,990 --> 00:08:11,550
While we can still use
a quarter, use one.

175
00:08:11,550 --> 00:08:15,900
That while loop should execute as long
as the remaining value is greater than

176
00:08:15,900 --> 00:08:18,240
or equal to a quarter's cent value.

177
00:08:18,240 --> 00:08:20,970
That means that you'll also want to
keep track of the remaining cash

178
00:08:20,970 --> 00:08:24,570
value, and update it every
time that you use a coin.

179
00:08:24,570 --> 00:08:28,350
>> Also remember that at the end, your
output is the number of coins used.

180
00:08:28,350 --> 00:08:32,400
So another thing to keep track of is
the number of coins that you use.

181
00:08:32,400 --> 00:08:35,450
You can keep track of these using
well-named variables.

182
00:08:35,450 --> 00:08:39,730
And within the body of your loop would
be an update to those variables.

183
00:08:39,730 --> 00:08:43,400
Once the loop for quarter finishes, you
can use a similar one for dimes,

184
00:08:43,400 --> 00:08:47,180
and so on and so forth, until you've
returned all of the cash.

185
00:08:47,180 --> 00:08:50,640
>> I've written some pseudo-code here to
help you visualize just how the

186
00:08:50,640 --> 00:08:55,080
process we discussed might translate to
C. As you see here, I'm still using

187
00:08:55,080 --> 00:08:55,760
English words.

188
00:08:55,760 --> 00:08:56,830
It isn't C yet.

189
00:08:56,830 --> 00:08:58,590
But I've started to indent things.

190
00:08:58,590 --> 00:09:00,690
I've put conditions inside
my parentheses.

191
00:09:00,690 --> 00:09:03,710
It's starting to look a little
bit like programming code.

192
00:09:03,710 --> 00:09:06,410
>> Pseudo-code is a great way
to get yourself started.

193
00:09:06,410 --> 00:09:08,810
Visualize your code before
you look up syntax.

194
00:09:08,810 --> 00:09:12,570
Because often the hardest part about a
problem is really understanding what

195
00:09:12,570 --> 00:09:14,450
exactly you need to do.

196
00:09:14,450 --> 00:09:17,490
Once you write that down, then it's a
lot easier to look up the functions

197
00:09:17,490 --> 00:09:20,390
and syntax specific to your
line of pseudo-code

198
00:09:20,390 --> 00:09:23,760
>> Keep in mind that this might not be
identical to the kind of skeleton of

199
00:09:23,760 --> 00:09:25,560
your code that you write.

200
00:09:25,560 --> 00:09:27,640
There are always optimizations
to be made.

201
00:09:27,640 --> 00:09:31,250
And especially in my pseudo-code
here, see if you can spot it.

202
00:09:31,250 --> 00:09:33,380
>> But essentially the process
and the way of thinking

203
00:09:33,380 --> 00:09:35,250
is just as we discussed.

204
00:09:35,250 --> 00:09:38,350
The first line tells us to obtain
a certain amount in dollars.

205
00:09:38,350 --> 00:09:40,960
And the second tells us to
convert it to cents.

206
00:09:40,960 --> 00:09:45,640
>> And then, while quarters can be used, we
want to increase the coin count and

207
00:09:45,640 --> 00:09:47,200
decrease the cash amount.

208
00:09:47,200 --> 00:09:49,880
Same goes for dimes, nickels,
and pennies.

209
00:09:49,880 --> 00:09:53,230
And finally, we tell the user
how many coins we used.

210
00:09:53,230 --> 00:09:53,750
>> Great.

211
00:09:53,750 --> 00:09:55,680
So that concludes the loop method.

212
00:09:55,680 --> 00:09:59,720
Now let's talk about the modular method,
which is more like division.

213
00:09:59,720 --> 00:10:03,630
>> We're all familiar with the plus, minus,
multiply, and divide operators

214
00:10:03,630 --> 00:10:05,030
available to us.

215
00:10:05,030 --> 00:10:09,060
C has all four of those, but also has
the modulo operator, represented by a

216
00:10:09,060 --> 00:10:10,640
percent sign.

217
00:10:10,640 --> 00:10:11,940
Modulo is really neat.

218
00:10:11,940 --> 00:10:14,880
It gives you the remainder from
dividing two numbers.

219
00:10:14,880 --> 00:10:19,910
>> Remember the long division message when
you divide, say, 74 by three?

220
00:10:19,910 --> 00:10:23,510
Starting with the tens place, you would
know that 3 goes into seven

221
00:10:23,510 --> 00:10:27,620
twice to make a six with
remainder one.

222
00:10:27,620 --> 00:10:31,870
You'd write two at the top, and then
subtract 6 from seven, carrying over

223
00:10:31,870 --> 00:10:34,980
the remainder of 14 to
repeat the process.

224
00:10:34,980 --> 00:10:39,410
>> Three goes into 14 four times to
make 12, with remainder two.

225
00:10:39,410 --> 00:10:40,930
And two doesn't carry over anymore.

226
00:10:40,930 --> 00:10:44,170
So two would be left at the
bottom as the remainder.

227
00:10:44,170 --> 00:10:46,800
>> And that's what modulo gives, you
that number at the bottom.

228
00:10:46,800 --> 00:10:49,790
So 74 modulo three would give you two.

229
00:10:49,790 --> 00:10:52,980
And 10 modulo two, well that
would give you zero.

230
00:10:52,980 --> 00:10:56,500
Because there isn't any remainder
when you divide 10 by two.

231
00:10:56,500 --> 00:11:00,190
>> Six modulo five, well five
goes into six once.

232
00:11:00,190 --> 00:11:01,830
And then it has one left over.

233
00:11:01,830 --> 00:11:04,720
So six modulo five is one.

234
00:11:04,720 --> 00:11:07,950
>> Then if you have seven modulo
nine, you'd get seven.

235
00:11:07,950 --> 00:11:09,840
Because nine is bigger than seven.

236
00:11:09,840 --> 00:11:15,020
So it doesn't divide it all into seven,
leaving seven as your answer.

237
00:11:15,020 --> 00:11:18,340
>> If you think about modulo a little more,
remember that it gives you the

238
00:11:18,340 --> 00:11:21,020
remainder after you divide something.

239
00:11:21,020 --> 00:11:23,620
Think about how you might be
able to use it in Greedy.

240
00:11:23,620 --> 00:11:27,620
Let's say the user asks for $400.11.

241
00:11:27,620 --> 00:11:30,470
What's a way to figure out how many
quarters you need without having to

242
00:11:30,470 --> 00:11:32,360
count each one?

243
00:11:32,360 --> 00:11:37,480
>> Once you figure out how many quarters
you can use to make $400.11, how much

244
00:11:37,480 --> 00:11:38,880
change remains?

245
00:11:38,880 --> 00:11:42,110
Perhaps a combination here between
modulo and division would come in

246
00:11:42,110 --> 00:11:46,200
handy to give you a cool, elegant
approach to the Greedy problem.

247
00:11:46,200 --> 00:11:49,030
But remember that the governing
rule still applies.

248
00:11:49,030 --> 00:11:51,610
Always use the largest coin possible.

249
00:11:51,610 --> 00:11:55,340
>> Once you've done the calculation of how
many coins to use, the last step

250
00:11:55,340 --> 00:11:57,930
is to print out the number of
coins that you calculated.

251
00:11:57,930 --> 00:12:01,610
So far, we've been using the printf
function solely for strings.

252
00:12:01,610 --> 00:12:05,200
But when you want to print out an In, or
just any type of data that's stored

253
00:12:05,200 --> 00:12:09,200
in a variable, you have to indicate
that using a placeholder.

254
00:12:09,200 --> 00:12:12,400
>> Here I've included just some tips
on how to print out values.

255
00:12:12,400 --> 00:12:16,390
If you have an integer, you would
write your string using %d as a

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

257
00:12:17,450 --> 00:12:20,170
After the closing quotation
mark, enter a comma.

258
00:12:20,170 --> 00:12:24,530
And then put in the integer that will
take the place of %d when printed out.

259
00:12:24,530 --> 00:12:27,150
>> So after displaying the number
of coins used, you're

260
00:12:27,150 --> 00:12:28,500
finished with Greedy.

261
00:12:28,500 --> 00:12:32,000
Make sure to check all corner cases,
tidy up your style a bit, and you're

262
00:12:32,000 --> 00:12:33,350
all set to submit.

263
00:12:33,350 --> 00:12:36,000
At the end of this problem set, you'll
be more familiar with the CS50

264
00:12:36,000 --> 00:12:39,940
appliance, the terminal, and loop
structures and variables in C.

265
00:12:39,940 --> 00:12:41,470
>> You're well on your way.

266
00:12:41,470 --> 00:12:43,040
The learning curve can seem tough.

267
00:12:43,040 --> 00:12:44,690
So take it step by step.

268
00:12:44,690 --> 00:12:47,110
Make sure you write out pseudo-code
before diving too deep

269
00:12:47,110 --> 00:12:49,000
into unfamiliar syntax.

270
00:12:49,000 --> 00:12:52,030
>> Make a to do list, and break up the
assignment into smaller, more

271
00:12:52,030 --> 00:12:53,440
manageable tasks.

272
00:12:53,440 --> 00:12:55,810
Explore all of the CS50 resources.

273
00:12:55,810 --> 00:12:58,270
In addition to lecture, rewatch
this walk through.

274
00:12:58,270 --> 00:12:59,790
>> Pay close attention to section.

275
00:12:59,790 --> 00:13:00,710
Check out the shorts.

276
00:13:00,710 --> 00:13:04,640
Read your classmates' questions
on Discuss, and post your own.

277
00:13:04,640 --> 00:13:06,110
>> Best of luck with the p-set.

278
00:13:06,110 --> 00:13:07,200
And thanks for watching.

279
00:13:07,200 --> 00:13:08,690
This was Greedy.

280
00:13:08,690 --> 00:13:15,691
>> [MUSIC PLAYING]