full transcript

## Unscramble the Blue Letters

What's an algorithm? In computer science, an algorithm is a set of inrctiontuss for sinlovg some problem, step-by-step. Typically, algorithms are eecetuxd by computers, but we humans have algorithms as well. For instance, how would you go about counting the number of people in a room? Well, if you're like me, you probably pniot at each person, one at a time, and count up from 0: 1, 2, 3, 4 and so forth. Well, that's an aoilgthrm. In fact, let's try to express it a bit more formally in puoedsocde, English-like stanyx that resembles a programming language. Let n equal 0. For each person in room, set n = n + 1. How to interpret this pseudocode? Well, line 1 declares, so to sapek, a variable called n and initializes its value to zero. This just means that at the beginning of our algorithm, the thing with which we're counting has a value of zero. After all, before we start counting, we haven't counted anything yet. Calling this vbalaire n is just a convention. I could have called it almost anything. Now, line 2 demarks the sartt of loop, a sequence of steps that will repeat some number of times. So, in our example, the step we're taking is counting people in the room. Beneath line 2 is line 3, which deibscres exactly how we'll go about counting. The indentation implies that it's line 3 that will repeat. So, what the pseudocode is saying is that after starting at zero, for each person in the room, we'll increase n by 1. Now, is this algorithm correct? Well, let's bang on it a bit. Does it work if there are 2 people in the room? Let's see. In line 1, we initialize n to zero. For each of these two people, we then increment n by 1. So, in the first trip through the loop, we update n from zero to 1, on the second trip through that same loop, we update n from 1 to 2. And so, by this algorithm's end, n is 2, which indeed matches the number of people in the room. So far, so good. How about a corner case, though? Suppose that there are zero people in the room, besides me, who's doing the cnouting. In line 1, we again initialize n to zero. This time, though, line 3 doesn't execute at all since there isn't a person in the room, and so, n remains zero, which indeed mhtecas the number of people in the room. ptetry slpmie, right? But counting people one a time is pretty inefficient, too, no? Surely, we can do better! Why not count two people at a time? Instead of counting 1, 2, 3, 4, 5, 6, 7, 8, and so forth, why not count 2, 4, 6, 8, and so on? It even sounds faster, and it surley is. Let's express this optimization in pseudocode. Let n eqaul zero. For each pair of people in room, set n = n + 2. Pretty simple cnhage, right? Rather than count pleope one at a time, we instead count them two at a time. This algorithm's thus twice as fast as the last. But is it correct? Let's see. Does it work if there are 2 people in the room? In line 1, we initialize n to zero. For that one pair of people, we then increment n by 2. And so, by this algorithm's end, n is 2, which indeed matches the number of people in the room. Suppose next that there are zero people in the room. In line 1, we initialize n to zero. As before, line 3 doesn't execute at all since there aren't any pairs of people in the room, and so, n remains zero, which indeed matches the number of people in the room. But what if there are 3 people in the room? How does this algorithm fair? Let's see. In line 1, we iinzliitae n to zero. For a pair of those people, we then iennmecrt n by 2, but then what? There isn't another full pair of people in the room, so line 2 no longer alippes. And so, by this algorithm's end, n is still 2, which isn't correct. Indeed this algorithm is said to be buggy because it has a mktaise. Let's redesrs with some new pseudocode. Let n equal zero. For each pair of people in room, set n = n + 2. If 1 person remains unpaired, set n = n + 1. To solve this particular problem, we've introduced in line 4 a condition, otherwise known as a branch, that only executes if there is one person we could not pair with another. So now, whether there's 1 or 3 or any odd number of people in the room, this algorithm will now conut them. Can we do even better? Well, we could count in 3's or 4's or even 5's and 10's, but beyond that it's going to get a little bit difficult to point. At the end of the day, whether executed by computers or humans, algorithms are just a set of instructions with which to solve problems. These were just three. What problem would you solve with an algorithm?

## Open Cloze

What's an algorithm? In computer science, an algorithm is a set of ____________ for _______ some problem, step-by-step. Typically, algorithms are ________ by computers, but we humans have algorithms as well. For instance, how would you go about counting the number of people in a room? Well, if you're like me, you probably _____ at each person, one at a time, and count up from 0: 1, 2, 3, 4 and so forth. Well, that's an _________. In fact, let's try to express it a bit more formally in __________, English-like ______ that resembles a programming language. Let n equal 0. For each person in room, set n = n + 1. How to interpret this pseudocode? Well, line 1 declares, so to _____, a variable called n and initializes its value to zero. This just means that at the beginning of our algorithm, the thing with which we're counting has a value of zero. After all, before we start counting, we haven't counted anything yet. Calling this ________ n is just a convention. I could have called it almost anything. Now, line 2 demarks the _____ of loop, a sequence of steps that will repeat some number of times. So, in our example, the step we're taking is counting people in the room. Beneath line 2 is line 3, which _________ exactly how we'll go about counting. The indentation implies that it's line 3 that will repeat. So, what the pseudocode is saying is that after starting at zero, for each person in the room, we'll increase n by 1. Now, is this algorithm correct? Well, let's bang on it a bit. Does it work if there are 2 people in the room? Let's see. In line 1, we initialize n to zero. For each of these two people, we then increment n by 1. So, in the first trip through the loop, we update n from zero to 1, on the second trip through that same loop, we update n from 1 to 2. And so, by this algorithm's end, n is 2, which indeed matches the number of people in the room. So far, so good. How about a corner case, though? Suppose that there are zero people in the room, besides me, who's doing the ________. In line 1, we again initialize n to zero. This time, though, line 3 doesn't execute at all since there isn't a person in the room, and so, n remains zero, which indeed _______ the number of people in the room. ______ ______, right? But counting people one a time is pretty inefficient, too, no? Surely, we can do better! Why not count two people at a time? Instead of counting 1, 2, 3, 4, 5, 6, 7, 8, and so forth, why not count 2, 4, 6, 8, and so on? It even sounds faster, and it ______ is. Let's express this optimization in pseudocode. Let n _____ zero. For each pair of people in room, set n = n + 2. Pretty simple ______, right? Rather than count ______ one at a time, we instead count them two at a time. This algorithm's thus twice as fast as the last. But is it correct? Let's see. Does it work if there are 2 people in the room? In line 1, we initialize n to zero. For that one pair of people, we then increment n by 2. And so, by this algorithm's end, n is 2, which indeed matches the number of people in the room. Suppose next that there are zero people in the room. In line 1, we initialize n to zero. As before, line 3 doesn't execute at all since there aren't any pairs of people in the room, and so, n remains zero, which indeed matches the number of people in the room. But what if there are 3 people in the room? How does this algorithm fair? Let's see. In line 1, we __________ n to zero. For a pair of those people, we then _________ n by 2, but then what? There isn't another full pair of people in the room, so line 2 no longer _______. And so, by this algorithm's end, n is still 2, which isn't correct. Indeed this algorithm is said to be buggy because it has a _______. Let's _______ with some new pseudocode. Let n equal zero. For each pair of people in room, set n = n + 2. If 1 person remains unpaired, set n = n + 1. To solve this particular problem, we've introduced in line 4 a condition, otherwise known as a branch, that only executes if there is one person we could not pair with another. So now, whether there's 1 or 3 or any odd number of people in the room, this algorithm will now _____ them. Can we do even better? Well, we could count in 3's or 4's or even 5's and 10's, but beyond that it's going to get a little bit difficult to point. At the end of the day, whether executed by computers or humans, algorithms are just a set of instructions with which to solve problems. These were just three. What problem would you solve with an algorithm?

## Solution

1. algorithm
2. variable
3. pretty
4. equal
5. counting
6. executed
7. people
8. point
9. redress
10. initialize
11. pseudocode
12. change
13. mistake
14. solving
15. applies
16. increment
17. speak
18. simple
19. count
20. surely
21. matches
22. instructions
23. syntax
24. start
25. describes

## Original Text

What's an algorithm? In computer science, an algorithm is a set of instructions for solving some problem, step-by-step. Typically, algorithms are executed by computers, but we humans have algorithms as well. For instance, how would you go about counting the number of people in a room? Well, if you're like me, you probably point at each person, one at a time, and count up from 0: 1, 2, 3, 4 and so forth. Well, that's an algorithm. In fact, let's try to express it a bit more formally in pseudocode, English-like syntax that resembles a programming language. Let n equal 0. For each person in room, set n = n + 1. How to interpret this pseudocode? Well, line 1 declares, so to speak, a variable called n and initializes its value to zero. This just means that at the beginning of our algorithm, the thing with which we're counting has a value of zero. After all, before we start counting, we haven't counted anything yet. Calling this variable n is just a convention. I could have called it almost anything. Now, line 2 demarks the start of loop, a sequence of steps that will repeat some number of times. So, in our example, the step we're taking is counting people in the room. Beneath line 2 is line 3, which describes exactly how we'll go about counting. The indentation implies that it's line 3 that will repeat. So, what the pseudocode is saying is that after starting at zero, for each person in the room, we'll increase n by 1. Now, is this algorithm correct? Well, let's bang on it a bit. Does it work if there are 2 people in the room? Let's see. In line 1, we initialize n to zero. For each of these two people, we then increment n by 1. So, in the first trip through the loop, we update n from zero to 1, on the second trip through that same loop, we update n from 1 to 2. And so, by this algorithm's end, n is 2, which indeed matches the number of people in the room. So far, so good. How about a corner case, though? Suppose that there are zero people in the room, besides me, who's doing the counting. In line 1, we again initialize n to zero. This time, though, line 3 doesn't execute at all since there isn't a person in the room, and so, n remains zero, which indeed matches the number of people in the room. Pretty simple, right? But counting people one a time is pretty inefficient, too, no? Surely, we can do better! Why not count two people at a time? Instead of counting 1, 2, 3, 4, 5, 6, 7, 8, and so forth, why not count 2, 4, 6, 8, and so on? It even sounds faster, and it surely is. Let's express this optimization in pseudocode. Let n equal zero. For each pair of people in room, set n = n + 2. Pretty simple change, right? Rather than count people one at a time, we instead count them two at a time. This algorithm's thus twice as fast as the last. But is it correct? Let's see. Does it work if there are 2 people in the room? In line 1, we initialize n to zero. For that one pair of people, we then increment n by 2. And so, by this algorithm's end, n is 2, which indeed matches the number of people in the room. Suppose next that there are zero people in the room. In line 1, we initialize n to zero. As before, line 3 doesn't execute at all since there aren't any pairs of people in the room, and so, n remains zero, which indeed matches the number of people in the room. But what if there are 3 people in the room? How does this algorithm fair? Let's see. In line 1, we initialize n to zero. For a pair of those people, we then increment n by 2, but then what? There isn't another full pair of people in the room, so line 2 no longer applies. And so, by this algorithm's end, n is still 2, which isn't correct. Indeed this algorithm is said to be buggy because it has a mistake. Let's redress with some new pseudocode. Let n equal zero. For each pair of people in room, set n = n + 2. If 1 person remains unpaired, set n = n + 1. To solve this particular problem, we've introduced in line 4 a condition, otherwise known as a branch, that only executes if there is one person we could not pair with another. So now, whether there's 1 or 3 or any odd number of people in the room, this algorithm will now count them. Can we do even better? Well, we could count in 3's or 4's or even 5's and 10's, but beyond that it's going to get a little bit difficult to point. At the end of the day, whether executed by computers or humans, algorithms are just a set of instructions with which to solve problems. These were just three. What problem would you solve with an algorithm?

## Frequently Occurring Word Combinations

### ngrams of length 2

collocation frequency
counting people 2

## Important Words

1. algorithm
2. algorithms
3. applies
4. bang
5. beginning
6. beneath
7. bit
8. branch
9. buggy
10. called
11. calling
12. case
13. change
14. computer
15. computers
16. condition
17. convention
18. corner
19. correct
20. count
21. counted
22. counting
23. day
24. declares
25. demarks
26. describes
27. difficult
28. equal
29. execute
30. executed
31. executes
32. express
33. fact
34. fair
35. fast
36. faster
37. formally
38. full
39. good
40. humans
41. implies
42. increase
43. increment
44. indentation
45. inefficient
46. initialize
47. initializes
48. instance
49. instructions
50. interpret
51. introduced
52. language
53. line
54. longer
55. loop
56. matches
57. means
58. mistake
59. number
60. odd
61. optimization
62. pair
63. pairs
64. people
65. person
66. point
67. pretty
68. problem
69. problems
70. programming
71. pseudocode
72. redress
73. remains
74. repeat
75. resembles
76. room
77. science
78. sequence
79. set
80. simple
81. solve
82. solving
83. sounds
84. speak
85. start
86. starting
87. step
88. steps
89. suppose
90. surely
91. syntax
92. time
93. times
94. trip
95. typically
96. unpaired
97. update
98. variable
99. work