diff --git a/FAQ.md b/FAQ.md index 079a21ad8..c4d947a82 100644 --- a/FAQ.md +++ b/FAQ.md @@ -7,11 +7,11 @@ * [What's the difference between space and time complexity?](#q100) * [What's an easy way to swap two values?](#q200) - ## Questions -### What's the difference between space and time complexity? + +### What's the difference between space and time complexity Space complexity refers to how memory usage increaes as the size of input increases. Time complexity refers to how the number of operations an algorithm requires to finish increases as the size of input increases. @@ -20,7 +20,8 @@ Many solutions will involve trade-offs between space & time complexity - the low ------------------------------------------------------------------------ -### What's an easy way to swap two values? + +### What's an easy way to swap two values ```python # With a temp variable... diff --git a/README.md b/README.md index a93788ea5..d4574f3a6 100644 --- a/README.md +++ b/README.md @@ -2,7 +2,7 @@ Each directory contains a separate problem that you'll be tasked with solving. Inside each directory, you'll find instructions for that problem, along with a -test file as well as an empty skeleton file. +test file as well as an empty skeleton file. There isn't an official prescribed order for tackling the problems, though a subjective ranking of the given problems from easiest to hardest might go @@ -17,7 +17,7 @@ something like this: For each problem, `cd` into the directory, read the instructions for the problem, implement your solution in the skeleton file, then test it using the -provided test file. +provided test file. The later problems definitely get progressively more difficult, especially when it comes to deriving a more performant solution. Don't feel bad if you aren't @@ -34,4 +34,4 @@ When you're confronted with a problem you haven't encountered before, the general strategy (adapted from [George Pólya's Problem Solving Principles](https://en.wikipedia.org/wiki/How_to_Solve_It)) is as follows: -https://github.com/LambdaSchool/CS-Wiki/wiki/Lambda-Problem-Solving-Framework + diff --git a/eating_cookies/README.md b/eating_cookies/README.md index 752e818b1..8d2bbe78a 100644 --- a/eating_cookies/README.md +++ b/eating_cookies/README.md @@ -1,21 +1,21 @@ # Eating Cookies -Cookie Monster can eat either 0, 1, 2, or 3 cookies at a time. If he were given a jar of cookies with `n` cookies inside of it, how many ways could he eat all `n` cookies in the cookie jar? Implement a function `eating_cookies` that counts the number of possible ways Cookie Monster can eat all of the cookies in the jar. +Cookie Monster can eat either 0, 1, 2, or 3 cookies at a time. If he were given a jar of cookies with `n` cookies inside of it, how many ways could he eat all `n` cookies in the cookie jar? Implement a function `eating_cookies` that counts the number of possible ways Cookie Monster can eat all of the cookies in the jar. For example, for a jar of cookies with `n = 3` (the jar has 3 cookies inside it), there are 4 possible ways for Cookie Monster to eat all the cookies inside it: 1. He can eat 1 cookie at a time 3 times - 2. He can eat 1 cookie, then 2 cookies + 2. He can eat 1 cookie, then 2 cookies 3. He can eat 2 cookies, then 1 cookie - 4. He can eat 3 cookies all at once. + 4. He can eat 3 cookies all at once. Thus, `eating_cookies(3)` should return an answer of 4. ## Testing -For this problem, there's a test that tests your implementation with small inputs (n <= 10). There's also a separate test that tests your implementation with large inputs (n >= 50). +For this problem, there's a test that tests your implementation with small inputs (n <= 10). There's also a separate test that tests your implementation with large inputs (n >= 50). -You'll find that without implementing performance optimizations into your solution, your solution will likely hang on the large input test. +You'll find that without implementing performance optimizations into your solution, your solution will likely hang on the large input test. To run the tests separately, run `python test_eating_cookies.py -k small` in order to run just the small input test. Run `python test_eating_cookies.py -k large` to execute just the large input test. If you want to run both tests, just run `python test_eating_cookies.py`. @@ -23,7 +23,7 @@ You can also test your implementation manually by executing `python eating_cooki ## Hints - * Since this question is asking you to generate a bunch of possible permutations, you'll probably want to use recursion for this. - * Think about base cases that we would want our recursive function to stop recursing on. How many ways are there to eat 0 cookies? What about a negative number of cookies? - * Once we've established some base cases, how can we recursively call our function such that we move towards one or more of these base cases? - * As far as performance optimizations go, caching/memoization might be one avenue we could go down? How should we make a cache available to our recursive function through multiple recursive calls? +* Since this question is asking you to generate a bunch of possible permutations, you'll probably want to use recursion for this. +* Think about base cases that we would want our recursive function to stop recursing on. How many ways are there to eat 0 cookies? What about a negative number of cookies? +* Once we've established some base cases, how can we recursively call our function such that we move towards one or more of these base cases? +* As far as performance optimizations go, caching/memoization might be one avenue we could go down? How should we make a cache available to our recursive function through multiple recursive calls? diff --git a/eating_cookies/eating_cookies.py b/eating_cookies/eating_cookies.py index 62655d803..f9c395ca2 100644 --- a/eating_cookies/eating_cookies.py +++ b/eating_cookies/eating_cookies.py @@ -3,14 +3,20 @@ import sys # The cache parameter is here for if you want to implement -# a solution that is more efficient than the naive +# a solution that is more efficient than the naive # recursive solution def eating_cookies(n, cache=None): - pass + pass + if __name__ == "__main__": - if len(sys.argv) > 1: - num_cookies = int(sys.argv[1]) - print("There are {ways} ways for Cookie Monster to eat {n} cookies.".format(ways=eating_cookies(num_cookies), n=num_cookies)) - else: - print('Usage: eating_cookies.py [num_cookies]') \ No newline at end of file + if len(sys.argv) > 1: + num_cookies = int(sys.argv[1]) + print( + "There are {ways} ways for Cookie Monster to eat {n} cookies.".format( + ways=eating_cookies(num_cookies), n=num_cookies + ) + ) + else: + print("Usage: eating_cookies.py [num_cookies]") + diff --git a/eating_cookies/test_eating_cookies.py b/eating_cookies/test_eating_cookies.py index 1a4644786..3c2776c82 100644 --- a/eating_cookies/test_eating_cookies.py +++ b/eating_cookies/test_eating_cookies.py @@ -1,20 +1,25 @@ import unittest from eating_cookies import eating_cookies -class Test(unittest.TestCase): - def test_eating_cookies_small_n(self): - self.assertEqual(eating_cookies(0), 1) - self.assertEqual(eating_cookies(1), 1) - self.assertEqual(eating_cookies(2), 2) - self.assertEqual(eating_cookies(5), 13) - self.assertEqual(eating_cookies(10), 274) +class Test(unittest.TestCase): + def test_eating_cookies_small_n(self): + self.assertEqual(eating_cookies(0), 1) + self.assertEqual(eating_cookies(1), 1) + self.assertEqual(eating_cookies(2), 2) + self.assertEqual(eating_cookies(5), 13) + self.assertEqual(eating_cookies(10), 274) - def test_eating_cookies_large_n(self): - self.assertEqual(eating_cookies(50, [0 for i in range(51)]), 10562230626642) - self.assertEqual(eating_cookies(100, [0 for i in range(101)]), 180396380815100901214157639) - self.assertEqual(eating_cookies(500, [0 for i in range(501)]), 1306186569702186634983475450062372018715120191391192207156664343051610913971927959744519676992404852130396504615663042713312314219527) + def test_eating_cookies_large_n(self): + self.assertEqual(eating_cookies(50, [0 for i in range(51)]), 10562230626642) + self.assertEqual( + eating_cookies(100, [0 for i in range(101)]), 180396380815100901214157639 + ) + self.assertEqual( + eating_cookies(500, [0 for i in range(501)]), + 1306186569702186634983475450062372018715120191391192207156664343051610913971927959744519676992404852130396504615663042713312314219527, + ) -if __name__ == '__main__': - unittest.main() +if __name__ == "__main__": + unittest.main() diff --git a/knapsack/README.md b/knapsack/README.md index 149a19ca3..8d1752fa4 100644 --- a/knapsack/README.md +++ b/knapsack/README.md @@ -36,14 +36,16 @@ Total value: 117 ``` ## Testing + For this problem, there are tests that test your implementation with small (10 items to consider), medium (200 items to consider), and large inputs (1000 items to consider). You can run all of the tests with `python test_knapsack.py`, or run the tests individually with `python test_knapsack.py -k small`, `python test_knapsack.py -k medium`, or `python test_knapsack.py -k large`. ## Hints + 1. Base cases you might want to consider for a naive recursive implementation of this problem are: * What if there are no items left to consider? * What if the item I'm considering is too large to fit in my bag's remaining capacity? -2. In order to move towards one of our base cases, we'll pick up an item from the pile to consider, and add it to a copy of our bag. Now we have two versions of our bag, one with the item we're considering, and one without. All we have to do now is pick the bag that yields us a higher value. -3. As far as caching for this problem is concerned, a simple hash table or array is not going to suffice, because each solution now depends upon two parameters: the number of items in our pile to consider, as well as the capacity of our bag. So we'll need a 2x2 matrix in order to cache our answers adequately. +2. In order to move towards one of our base cases, we'll pick up an item from the pile to consider, and add it to a copy of our bag. Now we have two versions of our bag, one with the item we're considering, and one without. All we have to do now is pick the bag that yields us a higher value. +3. As far as caching for this problem is concerned, a simple hash table or array is not going to suffice, because each solution now depends upon two parameters: the number of items in our pile to consider, as well as the capacity of our bag. So we'll need a 2x2 matrix in order to cache our answers adequately. 4. Here's another way we might consider tackling this problem: what if we iterated through every single element in our pile and assign each one a value given by its value/weight ratio. Then we can sort all of the items based on this assigned value such that those items with a higher value/weight ratio are at the top of our sorted list of items. From there, we can just grab off the items at the top of our list until our bag is full. What would be the runtime complexity of this scheme? Would it work in every single scenario for any pile of items? diff --git a/knapsack/knapsack.py b/knapsack/knapsack.py index a130284f1..a8462ea37 100644 --- a/knapsack/knapsack.py +++ b/knapsack/knapsack.py @@ -3,24 +3,26 @@ import sys from collections import namedtuple -Item = namedtuple('Item', ['index', 'size', 'value']) +Item = namedtuple("Item", ["index", "size", "value"]) + def knapsack_solver(items, capacity): - pass - - -if __name__ == '__main__': - if len(sys.argv) > 1: - capacity = int(sys.argv[2]) - file_location = sys.argv[1].strip() - file_contents = open(file_location, 'r') - items = [] - - for line in file_contents.readlines(): - data = line.rstrip().split() - items.append(Item(int(data[0]), int(data[1]), int(data[2]))) - - file_contents.close() - print(knapsack_solver(items, capacity)) - else: - print('Usage: knapsack.py [filename] [capacity]') \ No newline at end of file + pass + + +if __name__ == "__main__": + if len(sys.argv) > 1: + capacity = int(sys.argv[2]) + file_location = sys.argv[1].strip() + file_contents = open(file_location, "r") + items = [] + + for line in file_contents.readlines(): + data = line.rstrip().split() + items.append(Item(int(data[0]), int(data[1]), int(data[2]))) + + file_contents.close() + print(knapsack_solver(items, capacity)) + else: + print("Usage: knapsack.py [filename] [capacity]") + diff --git a/knapsack/test_knapsack.py b/knapsack/test_knapsack.py index 33e82a291..a7e8cf59e 100644 --- a/knapsack/test_knapsack.py +++ b/knapsack/test_knapsack.py @@ -3,107 +3,214 @@ from collections import namedtuple from knapsack import knapsack_solver -Item = namedtuple('Item', ['index', 'size', 'value']) +Item = namedtuple("Item", ["index", "size", "value"]) + class Test(unittest.TestCase): - def setUp_small(self): - file_contents = open('data/small1.txt', 'r') - self.small_1_items = [] - - for line in file_contents.readlines(): - data = line.rstrip().split() - self.small_1_items.append(Item(int(data[0]), int(data[1]), int(data[2]))) - - file_contents.close() - - file_contents = open('data/small2.txt', 'r') - self.small_2_items = [] - - for line in file_contents.readlines(): - data = line.rstrip().split() - self.small_2_items.append(Item(int(data[0]), int(data[1]), int(data[2]))) - - file_contents.close() - - file_contents = open('data/small3.txt', 'r') - self.small_3_items = [] - - for line in file_contents.readlines(): - data = line.rstrip().split() - self.small_3_items.append(Item(int(data[0]), int(data[1]), int(data[2]))) - - file_contents.close() - - def cleanUp_small(self): - del self.small_1_items - del self.small_2_items - del self.small_3_items - - def setUp_medium(self): - file_contents = open('data/medium1.txt', 'r') - self.medium_1_items = [] - - for line in file_contents.readlines(): - data = line.rstrip().split() - self.medium_1_items.append(Item(int(data[0]), int(data[1]), int(data[2]))) - - file_contents.close() - - file_contents = open('data/medium2.txt', 'r') - self.medium_2_items = [] - - for line in file_contents.readlines(): - data = line.rstrip().split() - self.medium_2_items.append(Item(int(data[0]), int(data[1]), int(data[2]))) - - file_contents.close() - - file_contents = open('data/medium3.txt', 'r') - self.medium_3_items = [] - - for line in file_contents.readlines(): - data = line.rstrip().split() - self.medium_3_items.append(Item(int(data[0]), int(data[1]), int(data[2]))) - - file_contents.close() - - def cleanUp_medium(self): - del self.medium_1_items - del self.medium_2_items - del self.medium_3_items - - def setUp_large(self): - file_contents = open('data/large1.txt', 'r') - self.large_1_items = [] - - for line in file_contents.readlines(): - data = line.rstrip().split() - self.large_1_items.append(Item(int(data[0]), int(data[1]), int(data[2]))) - - file_contents.close() - - def cleanUp_large(self): - del self.large_1_items - - def test_with_small_input(self): - self.setUp_small() - self.assertEqual(knapsack_solver(self.small_1_items, 100), {'Value': 197, 'Chosen': [1, 7, 8]}) - self.assertEqual(knapsack_solver(self.small_2_items, 100), {'Value': 259, 'Chosen': [1, 9, 10]}) - self.assertEqual(knapsack_solver(self.small_3_items, 100), {'Value': 129, 'Chosen': [4, 5, 7, 9]}) - self.cleanUp_small() - - def test_with_medium_input(self): - self.setUp_medium() - self.assertEqual(knapsack_solver(self.medium_1_items, 100), {'Value': 1042, 'Chosen': [44, 49, 60, 77, 80, 83, 94, 104, 107, 117, 127, 134, 157, 160, 170]}) - self.assertEqual(knapsack_solver(self.medium_2_items, 100), {'Value': 969, 'Chosen': [1, 10, 27, 28, 66, 120, 139, 145, 153, 155, 174, 188, 191]}) - self.assertEqual(knapsack_solver(self.medium_3_items, 100), {'Value': 868, 'Chosen': [9, 14, 15, 47, 68, 108, 116, 120, 133, 154, 158, 161, 164, 170, 181, 198]}) - self.cleanUp_medium() - - def test_with_large_input(self): - self.setUp_large() - self.assertEqual(knapsack_solver(self.large_1_items, 100), {'Value': 2640, 'Chosen': [44, 83, 104, 107, 134, 160, 239, 271, 295, 297, 308, 335, 337, 370, 373, 420, 432, 561, 566, 623, 648, 671, 693, 704, 737, 782, 795, 796, 814, 844, 866, 907, 909, 913, 935, 949, 987, 997]}) - self.cleanUp_large() - - -if __name__ == '__main__': - unittest.main() \ No newline at end of file + def setUp_small(self): + file_contents = open("data/small1.txt", "r") + self.small_1_items = [] + + for line in file_contents.readlines(): + data = line.rstrip().split() + self.small_1_items.append(Item(int(data[0]), int(data[1]), int(data[2]))) + + file_contents.close() + + file_contents = open("data/small2.txt", "r") + self.small_2_items = [] + + for line in file_contents.readlines(): + data = line.rstrip().split() + self.small_2_items.append(Item(int(data[0]), int(data[1]), int(data[2]))) + + file_contents.close() + + file_contents = open("data/small3.txt", "r") + self.small_3_items = [] + + for line in file_contents.readlines(): + data = line.rstrip().split() + self.small_3_items.append(Item(int(data[0]), int(data[1]), int(data[2]))) + + file_contents.close() + + def cleanUp_small(self): + del self.small_1_items + del self.small_2_items + del self.small_3_items + + def setUp_medium(self): + file_contents = open("data/medium1.txt", "r") + self.medium_1_items = [] + + for line in file_contents.readlines(): + data = line.rstrip().split() + self.medium_1_items.append(Item(int(data[0]), int(data[1]), int(data[2]))) + + file_contents.close() + + file_contents = open("data/medium2.txt", "r") + self.medium_2_items = [] + + for line in file_contents.readlines(): + data = line.rstrip().split() + self.medium_2_items.append(Item(int(data[0]), int(data[1]), int(data[2]))) + + file_contents.close() + + file_contents = open("data/medium3.txt", "r") + self.medium_3_items = [] + + for line in file_contents.readlines(): + data = line.rstrip().split() + self.medium_3_items.append(Item(int(data[0]), int(data[1]), int(data[2]))) + + file_contents.close() + + def cleanUp_medium(self): + del self.medium_1_items + del self.medium_2_items + del self.medium_3_items + + def setUp_large(self): + file_contents = open("data/large1.txt", "r") + self.large_1_items = [] + + for line in file_contents.readlines(): + data = line.rstrip().split() + self.large_1_items.append(Item(int(data[0]), int(data[1]), int(data[2]))) + + file_contents.close() + + def cleanUp_large(self): + del self.large_1_items + + def test_with_small_input(self): + self.setUp_small() + self.assertEqual( + knapsack_solver(self.small_1_items, 100), + {"Value": 197, "Chosen": [1, 7, 8]}, + ) + self.assertEqual( + knapsack_solver(self.small_2_items, 100), + {"Value": 259, "Chosen": [1, 9, 10]}, + ) + self.assertEqual( + knapsack_solver(self.small_3_items, 100), + {"Value": 129, "Chosen": [4, 5, 7, 9]}, + ) + self.cleanUp_small() + + def test_with_medium_input(self): + self.setUp_medium() + self.assertEqual( + knapsack_solver(self.medium_1_items, 100), + { + "Value": 1042, + "Chosen": [ + 44, + 49, + 60, + 77, + 80, + 83, + 94, + 104, + 107, + 117, + 127, + 134, + 157, + 160, + 170, + ], + }, + ) + self.assertEqual( + knapsack_solver(self.medium_2_items, 100), + { + "Value": 969, + "Chosen": [1, 10, 27, 28, 66, 120, 139, 145, 153, 155, 174, 188, 191], + }, + ) + self.assertEqual( + knapsack_solver(self.medium_3_items, 100), + { + "Value": 868, + "Chosen": [ + 9, + 14, + 15, + 47, + 68, + 108, + 116, + 120, + 133, + 154, + 158, + 161, + 164, + 170, + 181, + 198, + ], + }, + ) + self.cleanUp_medium() + + def test_with_large_input(self): + self.setUp_large() + self.assertEqual( + knapsack_solver(self.large_1_items, 100), + { + "Value": 2640, + "Chosen": [ + 44, + 83, + 104, + 107, + 134, + 160, + 239, + 271, + 295, + 297, + 308, + 335, + 337, + 370, + 373, + 420, + 432, + 561, + 566, + 623, + 648, + 671, + 693, + 704, + 737, + 782, + 795, + 796, + 814, + 844, + 866, + 907, + 909, + 913, + 935, + 949, + 987, + 997, + ], + }, + ) + self.cleanUp_large() + + +if __name__ == "__main__": + unittest.main() + diff --git a/making_change/README.md b/making_change/README.md index 224aa299e..59706073d 100644 --- a/making_change/README.md +++ b/making_change/README.md @@ -1,18 +1,18 @@ # Making Change You work as a bank teller, handling people's bank transactions (this is your -part-time gig while you're studying at Lambda). +part-time gig while you're studying at Lambda). One day one of the wealthiest and also most eccentric patrons of the bank walks up to your stall. They hand you some cash and tell you they want you to figure out exactly how many ways there are to make change for the amount of money they plopped down in front of you using only pennies, nickels, dimes, quarters, and -half-dollars. +half-dollars. Since this is a bank, you have an infinite supply of coinange. Write a function `making_change` that receives as input an amount of money in cents as well as an array of coin denominations and calculates the total number of ways in which -change can be made for the input amount using the given coin denominations. +change can be made for the input amount using the given coin denominations. For example, `making_change(10)` should return 4, since there are 4 ways to make change for 10 cents using pennies, nickels, dimes, quarters, and half-dollars: @@ -22,14 +22,14 @@ change for 10 cents using pennies, nickels, dimes, quarters, and half-dollars: 3. We can use 2 nickels 4. We can use a single dime -## Testing +## Testing For this problem, there's a test that tests your implementation with small inputs (amounts of change up to 300 cents). There's also a separate test that -tests your implementation with large inputs (amounts of change >= 350 cents). +tests your implementation with large inputs (amounts of change >= 350 cents). You'll find that without implementing performance optimizations into your -solution, your solution will likely hang on the large input test. +solution, your solution will likely hang on the large input test. To run the tests separately, run `python test_making_change.py -k small` in order to run just the small input test. Run `python test_making_change.py -k @@ -41,24 +41,24 @@ making_change.py [amount]` ## Hints - * This problem can be thought of as a more difficult version of the eating - cookies problem. - * As far as base cases go, again, think about some cases where we'd want the +* This problem can be thought of as a more difficult version of the eating + cookies problem. +* As far as base cases go, again, think about some cases where we'd want the recursion to stop executing. What should happen when the amount of cents given is 0? What should happen when the amount of cents given is negative? What about when we've used up all of the available coin denominations? - * As far as performance optimizations go, caching/memoization might be one - avenue we could go down. - * Building up values in our cache in an iterative fashion might also be a good - way to go about improving our implementation. - +* As far as performance optimizations go, caching/memoization might be one + avenue we could go down. +* Building up values in our cache in an iterative fashion might also be a good + way to go about improving our implementation. + Here's a general idea: we can initialize a cache as a list (a dictionary would work fine as well) of 0s with a length equal to the amount we're looking to make change for. Each value of the list will represent the number of ways to make `i` cents, where `i` are the indices of the list. So `cache[10] == 4` from our example above. Since we know there is one way to make 0 cents in change, we'll initialize `cache[0] = 1` (you can seed entries - for additional values as well, though you don't actually need to). + for additional values as well, though you don't actually need to). Now that we've initialized our cache, we'll start building it up. We have an initial value in our cache, so we'll want to build up subsequent answers in @@ -66,18 +66,18 @@ making_change.py [amount]` the higher amounts between our coin and the amount (i.e., `for higher_amount in range(coin, amount + 1)`). If we take the difference between the higher amount and the value of our coin, we can start building up the values in our - cache. + cache. To go into a little more detail, let's walk through a small example. If we imagine our coin is a penny, in the first loop iteration, `higher_amount` is going to be 1 (since it will at first be the same value as our coin). If we take the difference between `higher_amount` and our coin value, we get 0. We already have a value for 0 in our cache; it's 1. So now we've just figured - out 1 way to 1 cent from a penny. Add that answer to our cache. + out 1 way to 1 cent from a penny. Add that answer to our cache. Next up, on the next iteration, `higher_amount` will now be 2. The difference between `higher_amount` and our coin value now is 1. Well we just figured out - an answer for 1, so now we have an answer for 2. Add that to our cache. + an answer for 1, so now we have an answer for 2. Add that to our cache. Once this loop finishes, we'll have figured out all of the ways to make different amounts using the current coin. At that point, all we have to do is diff --git a/making_change/making_change.py b/making_change/making_change.py index 9adad4470..f69edb0df 100644 --- a/making_change/making_change.py +++ b/making_change/making_change.py @@ -2,16 +2,22 @@ import sys + def making_change(amount, denominations): - pass + pass if __name__ == "__main__": - # Test our your implementation from the command line - # with `python making_change.py [amount]` with different amounts - if len(sys.argv) > 1: - denominations = [1, 5, 10, 25, 50] - amount = int(sys.argv[1]) - print("There are {ways} ways to make {amount} cents.".format(ways=making_change(amount, denominations), amount=amount)) - else: - print("Usage: making_change.py [amount]") \ No newline at end of file + # Test our your implementation from the command line + # with `python making_change.py [amount]` with different amounts + if len(sys.argv) > 1: + denominations = [1, 5, 10, 25, 50] + amount = int(sys.argv[1]) + print( + "There are {ways} ways to make {amount} cents.".format( + ways=making_change(amount, denominations), amount=amount + ) + ) + else: + print("Usage: making_change.py [amount]") + diff --git a/making_change/test_making_change.py b/making_change/test_making_change.py index 8e0505daa..9827287d1 100644 --- a/making_change/test_making_change.py +++ b/making_change/test_making_change.py @@ -1,30 +1,31 @@ import unittest -from making_change import making_change +from making_change import making_change + class Test(unittest.TestCase): + def setUp(self): + self.denominations = [1, 5, 10, 25, 50] - def setUp(self): - self.denominations = [1, 5, 10, 25, 50] + def test_making_change_small_amount(self): + self.assertEqual(making_change(0, self.denominations), 1) + self.assertEqual(making_change(1, self.denominations), 1) + self.assertEqual(making_change(5, self.denominations), 2) + self.assertEqual(making_change(10, self.denominations), 4) + self.assertEqual(making_change(20, self.denominations), 9) + self.assertEqual(making_change(30, self.denominations), 18) + self.assertEqual(making_change(100, self.denominations), 292) + self.assertEqual(making_change(200, self.denominations), 2435) + self.assertEqual(making_change(300, self.denominations), 9590) - def test_making_change_small_amount(self): - self.assertEqual(making_change(0, self.denominations), 1) - self.assertEqual(making_change(1, self.denominations), 1) - self.assertEqual(making_change(5, self.denominations), 2) - self.assertEqual(making_change(10, self.denominations), 4) - self.assertEqual(making_change(20, self.denominations), 9) - self.assertEqual(making_change(30, self.denominations), 18) - self.assertEqual(making_change(100, self.denominations), 292) - self.assertEqual(making_change(200, self.denominations), 2435) - self.assertEqual(making_change(300, self.denominations), 9590) + def test_making_change_large_amount(self): + self.assertEqual(making_change(350, self.denominations), 16472) + self.assertEqual(making_change(400, self.denominations), 26517) + self.assertEqual(making_change(1000, self.denominations), 801451) + self.assertEqual(making_change(2000, self.denominations), 11712101) + self.assertEqual(making_change(5000, self.denominations), 432699251) + self.assertEqual(making_change(10000, self.denominations), 6794128501) - def test_making_change_large_amount(self): - self.assertEqual(making_change(350, self.denominations), 16472) - self.assertEqual(making_change(400, self.denominations), 26517) - self.assertEqual(making_change(1000, self.denominations), 801451) - self.assertEqual(making_change(2000, self.denominations), 11712101) - self.assertEqual(making_change(5000, self.denominations), 432699251) - self.assertEqual(making_change(10000, self.denominations), 6794128501) +if __name__ == "__main__": + unittest.main() -if __name__ == '__main__': - unittest.main() \ No newline at end of file diff --git a/recipe_batches/README.md b/recipe_batches/README.md index 1cb922ded..129bb0f0d 100644 --- a/recipe_batches/README.md +++ b/recipe_batches/README.md @@ -11,9 +11,9 @@ Write a function that receives a recipe in the form of a dictionary, as well as } ``` -The keys will be the ingredient names, with their associated values being the amounts. In the case of the recipe dictionary, these amounts will represent the amount of each ingredient needed for the recipe, while in the case of the ingredients dictionary, the amounts represent the amounts available to you. +The keys will be the ingredient names, with their associated values being the amounts. In the case of the recipe dictionary, these amounts will represent the amount of each ingredient needed for the recipe, while in the case of the ingredients dictionary, the amounts represent the amounts available to you. -Your function should output the maximum number of whole batches that can be made for the supplied recipe using the ingredients available to you, as indicated by the second dictionary. +Your function should output the maximum number of whole batches that can be made for the supplied recipe using the ingredients available to you, as indicated by the second dictionary. For example @@ -25,7 +25,7 @@ recipe_batches( ) ``` -## Testing +## Testing Run the test file by executing `python test_recipe_batches.py`. @@ -33,5 +33,5 @@ You can also test your implementation manually by executing `python recipe_batch ## Hints - * If there's a dictionary operation you aren't sure of how to perform in Python, look it up! - * What's the _minimum_ number of loops we need to perform in order to write a working implementation? \ No newline at end of file +* If there's a dictionary operation you aren't sure of how to perform in Python, look it up! +* What's the _minimum_ number of loops we need to perform in order to write a working implementation? diff --git a/recipe_batches/recipe_batches.py b/recipe_batches/recipe_batches.py index c845950c5..5088ab335 100644 --- a/recipe_batches/recipe_batches.py +++ b/recipe_batches/recipe_batches.py @@ -2,13 +2,19 @@ import math + def recipe_batches(recipe, ingredients): - pass + pass + +if __name__ == "__main__": + # Change the entries of these dictionaries to test + # your implementation with different inputs + recipe = {"milk": 100, "butter": 50, "flour": 5} + ingredients = {"milk": 132, "butter": 48, "flour": 51} + print( + "{batches} batches can be made from the available ingredients: {ingredients}.".format( + batches=recipe_batches(recipe, ingredients), ingredients=ingredients + ) + ) -if __name__ == '__main__': - # Change the entries of these dictionaries to test - # your implementation with different inputs - recipe = { 'milk': 100, 'butter': 50, 'flour': 5 } - ingredients = { 'milk': 132, 'butter': 48, 'flour': 51 } - print("{batches} batches can be made from the available ingredients: {ingredients}.".format(batches=recipe_batches(recipe, ingredients), ingredients=ingredients)) \ No newline at end of file diff --git a/recipe_batches/test_recipe_batches.py b/recipe_batches/test_recipe_batches.py index ba0c63190..d9312092c 100644 --- a/recipe_batches/test_recipe_batches.py +++ b/recipe_batches/test_recipe_batches.py @@ -1,14 +1,33 @@ import unittest from recipe_batches import recipe_batches + class Test(unittest.TestCase): + def test_recipe_batches(self): + self.assertEqual( + recipe_batches( + {"milk": 100, "flour": 4, "sugar": 10, "butter": 5}, + {"milk": 1288, "flour": 9, "sugar": 95}, + ), + 0, + ) + self.assertEqual( + recipe_batches( + {"milk": 100, "butter": 50, "cheese": 10}, + {"milk": 198, "butter": 52, "cheese": 10}, + ), + 1, + ) + self.assertEqual( + recipe_batches( + {"milk": 2, "sugar": 40, "butter": 20}, + {"milk": 5, "sugar": 120, "butter": 500}, + ), + 2, + ) + self.assertEqual(recipe_batches({"milk": 2}, {"milk": 200}), 100) - def test_recipe_batches(self): - self.assertEqual(recipe_batches({ 'milk': 100, 'flour': 4, 'sugar': 10, 'butter': 5 }, { 'milk': 1288, 'flour': 9, 'sugar': 95 }), 0) - self.assertEqual(recipe_batches({ 'milk': 100, 'butter': 50, 'cheese': 10 }, { 'milk': 198, 'butter': 52, 'cheese': 10 }), 1) - self.assertEqual(recipe_batches({ 'milk': 2, 'sugar': 40, 'butter': 20 }, { 'milk': 5, 'sugar': 120, 'butter': 500 }), 2) - self.assertEqual(recipe_batches({ 'milk': 2 }, { 'milk': 200}), 100) +if __name__ == "__main__": + unittest.main() -if __name__ == '__main__': - unittest.main() \ No newline at end of file diff --git a/rock_paper_scissors/README.md b/rock_paper_scissors/README.md index 5104b9fd2..1f98f62cc 100644 --- a/rock_paper_scissors/README.md +++ b/rock_paper_scissors/README.md @@ -1,6 +1,6 @@ # Rock Paper Scissors -Write a function `rock_paper_scissors` to generate all of the possible plays that can be made in a game of "Rock Paper Scissors", given some input `n`, which represents the number of plays per round. +Write a function `rock_paper_scissors` to generate all of the possible plays that can be made in a game of "Rock Paper Scissors", given some input `n`, which represents the number of plays per round. For example, given n = 2, your function should output the following: @@ -18,7 +18,7 @@ You can also test your implementation manually by executing `python rps.py [n]`. ## Hints - * You'll want to define a list with all of the possible Rock Paper Scissors plays. - * Another problem that asks you to generate a bunch of permutations, so we're probably going to want to opt for using recursion again. Since we're building up a list of results, we'll have to pass the list we're constructing around to multiple recursive calls so that each recursive call can add to the overall result. However, the tests only give our function `n` as input. To get around this, we could define an inner recursive helper function that will perform the recursion for us, while allowing us to preserve the outer function's function signature. - * In Python, you can concatenate two lists with the `+` operator. However, you'll want to make sure that both operands are lists! - * If you opt to define an inner recursive helper function, don't forget to make an initial call to the recursive helper function to kick off the recursion. \ No newline at end of file +* You'll want to define a list with all of the possible Rock Paper Scissors plays. +* Another problem that asks you to generate a bunch of permutations, so we're probably going to want to opt for using recursion again. Since we're building up a list of results, we'll have to pass the list we're constructing around to multiple recursive calls so that each recursive call can add to the overall result. However, the tests only give our function `n` as input. To get around this, we could define an inner recursive helper function that will perform the recursion for us, while allowing us to preserve the outer function's function signature. +* In Python, you can concatenate two lists with the `+` operator. However, you'll want to make sure that both operands are lists! +* If you opt to define an inner recursive helper function, don't forget to make an initial call to the recursive helper function to kick off the recursion. diff --git a/rock_paper_scissors/rps.py b/rock_paper_scissors/rps.py index 0fc53356e..d23004634 100644 --- a/rock_paper_scissors/rps.py +++ b/rock_paper_scissors/rps.py @@ -2,13 +2,15 @@ import sys + def rock_paper_scissors(n): - pass + pass if __name__ == "__main__": - if len(sys.argv) > 1: - num_plays = int(sys.argv[1]) - print(rock_paper_scissors(num_plays)) - else: - print('Usage: rps.py [num_plays]') \ No newline at end of file + if len(sys.argv) > 1: + num_plays = int(sys.argv[1]) + print(rock_paper_scissors(num_plays)) + else: + print("Usage: rps.py [num_plays]") + diff --git a/rock_paper_scissors/test_rps.py b/rock_paper_scissors/test_rps.py index 9bcefd746..a4332788c 100644 --- a/rock_paper_scissors/test_rps.py +++ b/rock_paper_scissors/test_rps.py @@ -1,16 +1,393 @@ import unittest -from rps import rock_paper_scissors +from rps import rock_paper_scissors + class Test(unittest.TestCase): + def test_rock_paper_scissors_output(self): + self.assertEqual(rock_paper_scissors(0), [[]]) + self.assertEqual(rock_paper_scissors(1), [["rock"], ["paper"], ["scissors"]]) + self.assertEqual( + rock_paper_scissors(2), + [ + ["rock", "rock"], + ["rock", "paper"], + ["rock", "scissors"], + ["paper", "rock"], + ["paper", "paper"], + ["paper", "scissors"], + ["scissors", "rock"], + ["scissors", "paper"], + ["scissors", "scissors"], + ], + ) + self.assertEqual( + rock_paper_scissors(3), + [ + ["rock", "rock", "rock"], + ["rock", "rock", "paper"], + ["rock", "rock", "scissors"], + ["rock", "paper", "rock"], + ["rock", "paper", "paper"], + ["rock", "paper", "scissors"], + ["rock", "scissors", "rock"], + ["rock", "scissors", "paper"], + ["rock", "scissors", "scissors"], + ["paper", "rock", "rock"], + ["paper", "rock", "paper"], + ["paper", "rock", "scissors"], + ["paper", "paper", "rock"], + ["paper", "paper", "paper"], + ["paper", "paper", "scissors"], + ["paper", "scissors", "rock"], + ["paper", "scissors", "paper"], + ["paper", "scissors", "scissors"], + ["scissors", "rock", "rock"], + ["scissors", "rock", "paper"], + ["scissors", "rock", "scissors"], + ["scissors", "paper", "rock"], + ["scissors", "paper", "paper"], + ["scissors", "paper", "scissors"], + ["scissors", "scissors", "rock"], + ["scissors", "scissors", "paper"], + ["scissors", "scissors", "scissors"], + ], + ) + self.assertEqual( + rock_paper_scissors(4), + [ + ["rock", "rock", "rock", "rock"], + ["rock", "rock", "rock", "paper"], + ["rock", "rock", "rock", "scissors"], + ["rock", "rock", "paper", "rock"], + ["rock", "rock", "paper", "paper"], + ["rock", "rock", "paper", "scissors"], + ["rock", "rock", "scissors", "rock"], + ["rock", "rock", "scissors", "paper"], + ["rock", "rock", "scissors", "scissors"], + ["rock", "paper", "rock", "rock"], + ["rock", "paper", "rock", "paper"], + ["rock", "paper", "rock", "scissors"], + ["rock", "paper", "paper", "rock"], + ["rock", "paper", "paper", "paper"], + ["rock", "paper", "paper", "scissors"], + ["rock", "paper", "scissors", "rock"], + ["rock", "paper", "scissors", "paper"], + ["rock", "paper", "scissors", "scissors"], + ["rock", "scissors", "rock", "rock"], + ["rock", "scissors", "rock", "paper"], + ["rock", "scissors", "rock", "scissors"], + ["rock", "scissors", "paper", "rock"], + ["rock", "scissors", "paper", "paper"], + ["rock", "scissors", "paper", "scissors"], + ["rock", "scissors", "scissors", "rock"], + ["rock", "scissors", "scissors", "paper"], + ["rock", "scissors", "scissors", "scissors"], + ["paper", "rock", "rock", "rock"], + ["paper", "rock", "rock", "paper"], + ["paper", "rock", "rock", "scissors"], + ["paper", "rock", "paper", "rock"], + ["paper", "rock", "paper", "paper"], + ["paper", "rock", "paper", "scissors"], + ["paper", "rock", "scissors", "rock"], + ["paper", "rock", "scissors", "paper"], + ["paper", "rock", "scissors", "scissors"], + ["paper", "paper", "rock", "rock"], + ["paper", "paper", "rock", "paper"], + ["paper", "paper", "rock", "scissors"], + ["paper", "paper", "paper", "rock"], + ["paper", "paper", "paper", "paper"], + ["paper", "paper", "paper", "scissors"], + ["paper", "paper", "scissors", "rock"], + ["paper", "paper", "scissors", "paper"], + ["paper", "paper", "scissors", "scissors"], + ["paper", "scissors", "rock", "rock"], + ["paper", "scissors", "rock", "paper"], + ["paper", "scissors", "rock", "scissors"], + ["paper", "scissors", "paper", "rock"], + ["paper", "scissors", "paper", "paper"], + ["paper", "scissors", "paper", "scissors"], + ["paper", "scissors", "scissors", "rock"], + ["paper", "scissors", "scissors", "paper"], + ["paper", "scissors", "scissors", "scissors"], + ["scissors", "rock", "rock", "rock"], + ["scissors", "rock", "rock", "paper"], + ["scissors", "rock", "rock", "scissors"], + ["scissors", "rock", "paper", "rock"], + ["scissors", "rock", "paper", "paper"], + ["scissors", "rock", "paper", "scissors"], + ["scissors", "rock", "scissors", "rock"], + ["scissors", "rock", "scissors", "paper"], + ["scissors", "rock", "scissors", "scissors"], + ["scissors", "paper", "rock", "rock"], + ["scissors", "paper", "rock", "paper"], + ["scissors", "paper", "rock", "scissors"], + ["scissors", "paper", "paper", "rock"], + ["scissors", "paper", "paper", "paper"], + ["scissors", "paper", "paper", "scissors"], + ["scissors", "paper", "scissors", "rock"], + ["scissors", "paper", "scissors", "paper"], + ["scissors", "paper", "scissors", "scissors"], + ["scissors", "scissors", "rock", "rock"], + ["scissors", "scissors", "rock", "paper"], + ["scissors", "scissors", "rock", "scissors"], + ["scissors", "scissors", "paper", "rock"], + ["scissors", "scissors", "paper", "paper"], + ["scissors", "scissors", "paper", "scissors"], + ["scissors", "scissors", "scissors", "rock"], + ["scissors", "scissors", "scissors", "paper"], + ["scissors", "scissors", "scissors", "scissors"], + ], + ) + self.assertEqual( + rock_paper_scissors(5), + [ + ["rock", "rock", "rock", "rock", "rock"], + ["rock", "rock", "rock", "rock", "paper"], + ["rock", "rock", "rock", "rock", "scissors"], + ["rock", "rock", "rock", "paper", "rock"], + ["rock", "rock", "rock", "paper", "paper"], + ["rock", "rock", "rock", "paper", "scissors"], + ["rock", "rock", "rock", "scissors", "rock"], + ["rock", "rock", "rock", "scissors", "paper"], + ["rock", "rock", "rock", "scissors", "scissors"], + ["rock", "rock", "paper", "rock", "rock"], + ["rock", "rock", "paper", "rock", "paper"], + ["rock", "rock", "paper", "rock", "scissors"], + ["rock", "rock", "paper", "paper", "rock"], + ["rock", "rock", "paper", "paper", "paper"], + ["rock", "rock", "paper", "paper", "scissors"], + ["rock", "rock", "paper", "scissors", "rock"], + ["rock", "rock", "paper", "scissors", "paper"], + ["rock", "rock", "paper", "scissors", "scissors"], + ["rock", "rock", "scissors", "rock", "rock"], + ["rock", "rock", "scissors", "rock", "paper"], + ["rock", "rock", "scissors", "rock", "scissors"], + ["rock", "rock", "scissors", "paper", "rock"], + ["rock", "rock", "scissors", "paper", "paper"], + ["rock", "rock", "scissors", "paper", "scissors"], + ["rock", "rock", "scissors", "scissors", "rock"], + ["rock", "rock", "scissors", "scissors", "paper"], + ["rock", "rock", "scissors", "scissors", "scissors"], + ["rock", "paper", "rock", "rock", "rock"], + ["rock", "paper", "rock", "rock", "paper"], + ["rock", "paper", "rock", "rock", "scissors"], + ["rock", "paper", "rock", "paper", "rock"], + ["rock", "paper", "rock", "paper", "paper"], + ["rock", "paper", "rock", "paper", "scissors"], + ["rock", "paper", "rock", "scissors", "rock"], + ["rock", "paper", "rock", "scissors", "paper"], + ["rock", "paper", "rock", "scissors", "scissors"], + ["rock", "paper", "paper", "rock", "rock"], + ["rock", "paper", "paper", "rock", "paper"], + ["rock", "paper", "paper", "rock", "scissors"], + ["rock", "paper", "paper", "paper", "rock"], + ["rock", "paper", "paper", "paper", "paper"], + ["rock", "paper", "paper", "paper", "scissors"], + ["rock", "paper", "paper", "scissors", "rock"], + ["rock", "paper", "paper", "scissors", "paper"], + ["rock", "paper", "paper", "scissors", "scissors"], + ["rock", "paper", "scissors", "rock", "rock"], + ["rock", "paper", "scissors", "rock", "paper"], + ["rock", "paper", "scissors", "rock", "scissors"], + ["rock", "paper", "scissors", "paper", "rock"], + ["rock", "paper", "scissors", "paper", "paper"], + ["rock", "paper", "scissors", "paper", "scissors"], + ["rock", "paper", "scissors", "scissors", "rock"], + ["rock", "paper", "scissors", "scissors", "paper"], + ["rock", "paper", "scissors", "scissors", "scissors"], + ["rock", "scissors", "rock", "rock", "rock"], + ["rock", "scissors", "rock", "rock", "paper"], + ["rock", "scissors", "rock", "rock", "scissors"], + ["rock", "scissors", "rock", "paper", "rock"], + ["rock", "scissors", "rock", "paper", "paper"], + ["rock", "scissors", "rock", "paper", "scissors"], + ["rock", "scissors", "rock", "scissors", "rock"], + ["rock", "scissors", "rock", "scissors", "paper"], + ["rock", "scissors", "rock", "scissors", "scissors"], + ["rock", "scissors", "paper", "rock", "rock"], + ["rock", "scissors", "paper", "rock", "paper"], + ["rock", "scissors", "paper", "rock", "scissors"], + ["rock", "scissors", "paper", "paper", "rock"], + ["rock", "scissors", "paper", "paper", "paper"], + ["rock", "scissors", "paper", "paper", "scissors"], + ["rock", "scissors", "paper", "scissors", "rock"], + ["rock", "scissors", "paper", "scissors", "paper"], + ["rock", "scissors", "paper", "scissors", "scissors"], + ["rock", "scissors", "scissors", "rock", "rock"], + ["rock", "scissors", "scissors", "rock", "paper"], + ["rock", "scissors", "scissors", "rock", "scissors"], + ["rock", "scissors", "scissors", "paper", "rock"], + ["rock", "scissors", "scissors", "paper", "paper"], + ["rock", "scissors", "scissors", "paper", "scissors"], + ["rock", "scissors", "scissors", "scissors", "rock"], + ["rock", "scissors", "scissors", "scissors", "paper"], + ["rock", "scissors", "scissors", "scissors", "scissors"], + ["paper", "rock", "rock", "rock", "rock"], + ["paper", "rock", "rock", "rock", "paper"], + ["paper", "rock", "rock", "rock", "scissors"], + ["paper", "rock", "rock", "paper", "rock"], + ["paper", "rock", "rock", "paper", "paper"], + ["paper", "rock", "rock", "paper", "scissors"], + ["paper", "rock", "rock", "scissors", "rock"], + ["paper", "rock", "rock", "scissors", "paper"], + ["paper", "rock", "rock", "scissors", "scissors"], + ["paper", "rock", "paper", "rock", "rock"], + ["paper", "rock", "paper", "rock", "paper"], + ["paper", "rock", "paper", "rock", "scissors"], + ["paper", "rock", "paper", "paper", "rock"], + ["paper", "rock", "paper", "paper", "paper"], + ["paper", "rock", "paper", "paper", "scissors"], + ["paper", "rock", "paper", "scissors", "rock"], + ["paper", "rock", "paper", "scissors", "paper"], + ["paper", "rock", "paper", "scissors", "scissors"], + ["paper", "rock", "scissors", "rock", "rock"], + ["paper", "rock", "scissors", "rock", "paper"], + ["paper", "rock", "scissors", "rock", "scissors"], + ["paper", "rock", "scissors", "paper", "rock"], + ["paper", "rock", "scissors", "paper", "paper"], + ["paper", "rock", "scissors", "paper", "scissors"], + ["paper", "rock", "scissors", "scissors", "rock"], + ["paper", "rock", "scissors", "scissors", "paper"], + ["paper", "rock", "scissors", "scissors", "scissors"], + ["paper", "paper", "rock", "rock", "rock"], + ["paper", "paper", "rock", "rock", "paper"], + ["paper", "paper", "rock", "rock", "scissors"], + ["paper", "paper", "rock", "paper", "rock"], + ["paper", "paper", "rock", "paper", "paper"], + ["paper", "paper", "rock", "paper", "scissors"], + ["paper", "paper", "rock", "scissors", "rock"], + ["paper", "paper", "rock", "scissors", "paper"], + ["paper", "paper", "rock", "scissors", "scissors"], + ["paper", "paper", "paper", "rock", "rock"], + ["paper", "paper", "paper", "rock", "paper"], + ["paper", "paper", "paper", "rock", "scissors"], + ["paper", "paper", "paper", "paper", "rock"], + ["paper", "paper", "paper", "paper", "paper"], + ["paper", "paper", "paper", "paper", "scissors"], + ["paper", "paper", "paper", "scissors", "rock"], + ["paper", "paper", "paper", "scissors", "paper"], + ["paper", "paper", "paper", "scissors", "scissors"], + ["paper", "paper", "scissors", "rock", "rock"], + ["paper", "paper", "scissors", "rock", "paper"], + ["paper", "paper", "scissors", "rock", "scissors"], + ["paper", "paper", "scissors", "paper", "rock"], + ["paper", "paper", "scissors", "paper", "paper"], + ["paper", "paper", "scissors", "paper", "scissors"], + ["paper", "paper", "scissors", "scissors", "rock"], + ["paper", "paper", "scissors", "scissors", "paper"], + ["paper", "paper", "scissors", "scissors", "scissors"], + ["paper", "scissors", "rock", "rock", "rock"], + ["paper", "scissors", "rock", "rock", "paper"], + ["paper", "scissors", "rock", "rock", "scissors"], + ["paper", "scissors", "rock", "paper", "rock"], + ["paper", "scissors", "rock", "paper", "paper"], + ["paper", "scissors", "rock", "paper", "scissors"], + ["paper", "scissors", "rock", "scissors", "rock"], + ["paper", "scissors", "rock", "scissors", "paper"], + ["paper", "scissors", "rock", "scissors", "scissors"], + ["paper", "scissors", "paper", "rock", "rock"], + ["paper", "scissors", "paper", "rock", "paper"], + ["paper", "scissors", "paper", "rock", "scissors"], + ["paper", "scissors", "paper", "paper", "rock"], + ["paper", "scissors", "paper", "paper", "paper"], + ["paper", "scissors", "paper", "paper", "scissors"], + ["paper", "scissors", "paper", "scissors", "rock"], + ["paper", "scissors", "paper", "scissors", "paper"], + ["paper", "scissors", "paper", "scissors", "scissors"], + ["paper", "scissors", "scissors", "rock", "rock"], + ["paper", "scissors", "scissors", "rock", "paper"], + ["paper", "scissors", "scissors", "rock", "scissors"], + ["paper", "scissors", "scissors", "paper", "rock"], + ["paper", "scissors", "scissors", "paper", "paper"], + ["paper", "scissors", "scissors", "paper", "scissors"], + ["paper", "scissors", "scissors", "scissors", "rock"], + ["paper", "scissors", "scissors", "scissors", "paper"], + ["paper", "scissors", "scissors", "scissors", "scissors"], + ["scissors", "rock", "rock", "rock", "rock"], + ["scissors", "rock", "rock", "rock", "paper"], + ["scissors", "rock", "rock", "rock", "scissors"], + ["scissors", "rock", "rock", "paper", "rock"], + ["scissors", "rock", "rock", "paper", "paper"], + ["scissors", "rock", "rock", "paper", "scissors"], + ["scissors", "rock", "rock", "scissors", "rock"], + ["scissors", "rock", "rock", "scissors", "paper"], + ["scissors", "rock", "rock", "scissors", "scissors"], + ["scissors", "rock", "paper", "rock", "rock"], + ["scissors", "rock", "paper", "rock", "paper"], + ["scissors", "rock", "paper", "rock", "scissors"], + ["scissors", "rock", "paper", "paper", "rock"], + ["scissors", "rock", "paper", "paper", "paper"], + ["scissors", "rock", "paper", "paper", "scissors"], + ["scissors", "rock", "paper", "scissors", "rock"], + ["scissors", "rock", "paper", "scissors", "paper"], + ["scissors", "rock", "paper", "scissors", "scissors"], + ["scissors", "rock", "scissors", "rock", "rock"], + ["scissors", "rock", "scissors", "rock", "paper"], + ["scissors", "rock", "scissors", "rock", "scissors"], + ["scissors", "rock", "scissors", "paper", "rock"], + ["scissors", "rock", "scissors", "paper", "paper"], + ["scissors", "rock", "scissors", "paper", "scissors"], + ["scissors", "rock", "scissors", "scissors", "rock"], + ["scissors", "rock", "scissors", "scissors", "paper"], + ["scissors", "rock", "scissors", "scissors", "scissors"], + ["scissors", "paper", "rock", "rock", "rock"], + ["scissors", "paper", "rock", "rock", "paper"], + ["scissors", "paper", "rock", "rock", "scissors"], + ["scissors", "paper", "rock", "paper", "rock"], + ["scissors", "paper", "rock", "paper", "paper"], + ["scissors", "paper", "rock", "paper", "scissors"], + ["scissors", "paper", "rock", "scissors", "rock"], + ["scissors", "paper", "rock", "scissors", "paper"], + ["scissors", "paper", "rock", "scissors", "scissors"], + ["scissors", "paper", "paper", "rock", "rock"], + ["scissors", "paper", "paper", "rock", "paper"], + ["scissors", "paper", "paper", "rock", "scissors"], + ["scissors", "paper", "paper", "paper", "rock"], + ["scissors", "paper", "paper", "paper", "paper"], + ["scissors", "paper", "paper", "paper", "scissors"], + ["scissors", "paper", "paper", "scissors", "rock"], + ["scissors", "paper", "paper", "scissors", "paper"], + ["scissors", "paper", "paper", "scissors", "scissors"], + ["scissors", "paper", "scissors", "rock", "rock"], + ["scissors", "paper", "scissors", "rock", "paper"], + ["scissors", "paper", "scissors", "rock", "scissors"], + ["scissors", "paper", "scissors", "paper", "rock"], + ["scissors", "paper", "scissors", "paper", "paper"], + ["scissors", "paper", "scissors", "paper", "scissors"], + ["scissors", "paper", "scissors", "scissors", "rock"], + ["scissors", "paper", "scissors", "scissors", "paper"], + ["scissors", "paper", "scissors", "scissors", "scissors"], + ["scissors", "scissors", "rock", "rock", "rock"], + ["scissors", "scissors", "rock", "rock", "paper"], + ["scissors", "scissors", "rock", "rock", "scissors"], + ["scissors", "scissors", "rock", "paper", "rock"], + ["scissors", "scissors", "rock", "paper", "paper"], + ["scissors", "scissors", "rock", "paper", "scissors"], + ["scissors", "scissors", "rock", "scissors", "rock"], + ["scissors", "scissors", "rock", "scissors", "paper"], + ["scissors", "scissors", "rock", "scissors", "scissors"], + ["scissors", "scissors", "paper", "rock", "rock"], + ["scissors", "scissors", "paper", "rock", "paper"], + ["scissors", "scissors", "paper", "rock", "scissors"], + ["scissors", "scissors", "paper", "paper", "rock"], + ["scissors", "scissors", "paper", "paper", "paper"], + ["scissors", "scissors", "paper", "paper", "scissors"], + ["scissors", "scissors", "paper", "scissors", "rock"], + ["scissors", "scissors", "paper", "scissors", "paper"], + ["scissors", "scissors", "paper", "scissors", "scissors"], + ["scissors", "scissors", "scissors", "rock", "rock"], + ["scissors", "scissors", "scissors", "rock", "paper"], + ["scissors", "scissors", "scissors", "rock", "scissors"], + ["scissors", "scissors", "scissors", "paper", "rock"], + ["scissors", "scissors", "scissors", "paper", "paper"], + ["scissors", "scissors", "scissors", "paper", "scissors"], + ["scissors", "scissors", "scissors", "scissors", "rock"], + ["scissors", "scissors", "scissors", "scissors", "paper"], + ["scissors", "scissors", "scissors", "scissors", "scissors"], + ], + ) - def test_rock_paper_scissors_output(self): - self.assertEqual(rock_paper_scissors(0), [[]]) - self.assertEqual(rock_paper_scissors(1), [['rock'], ['paper'], ['scissors']]) - self.assertEqual(rock_paper_scissors(2), [['rock', 'rock'], ['rock', 'paper'], ['rock', 'scissors'], ['paper', 'rock'], ['paper', 'paper'], ['paper', 'scissors'], ['scissors', 'rock'], ['scissors', 'paper'], ['scissors', 'scissors']]) - self.assertEqual(rock_paper_scissors(3), [['rock', 'rock', 'rock'], ['rock', 'rock', 'paper'], ['rock', 'rock', 'scissors'], ['rock', 'paper', 'rock'], ['rock', 'paper', 'paper'], ['rock', 'paper', 'scissors'], ['rock', 'scissors', 'rock'], ['rock', 'scissors', 'paper'], ['rock', 'scissors', 'scissors'], ['paper', 'rock', 'rock'], ['paper', 'rock', 'paper'], ['paper', 'rock', 'scissors'], ['paper', 'paper', 'rock'], ['paper', 'paper', 'paper'], ['paper', 'paper', 'scissors'], ['paper', 'scissors', 'rock'], ['paper', 'scissors', 'paper'], ['paper', 'scissors', 'scissors'], ['scissors', 'rock', 'rock'], ['scissors', 'rock', 'paper'], ['scissors', 'rock', 'scissors'], ['scissors', 'paper', 'rock'], ['scissors', 'paper', 'paper'], ['scissors', 'paper', 'scissors'], ['scissors', 'scissors', 'rock'], ['scissors', 'scissors', 'paper'], ['scissors', 'scissors', 'scissors']]) - self.assertEqual(rock_paper_scissors(4), [['rock', 'rock', 'rock', 'rock'], ['rock', 'rock', 'rock', 'paper'], ['rock', 'rock', 'rock', 'scissors'], ['rock', 'rock', 'paper', 'rock'], ['rock', 'rock', 'paper', 'paper'], ['rock', 'rock', 'paper', 'scissors'], ['rock', 'rock', 'scissors', 'rock'], ['rock', 'rock', 'scissors', 'paper'], ['rock', 'rock', 'scissors', 'scissors'], ['rock', 'paper', 'rock', 'rock'], ['rock', 'paper', 'rock', 'paper'], ['rock', 'paper', 'rock', 'scissors'], ['rock', 'paper', 'paper', 'rock'], ['rock', 'paper', 'paper', 'paper'], ['rock', 'paper', 'paper', 'scissors'], ['rock', 'paper', 'scissors', 'rock'], ['rock', 'paper', 'scissors', 'paper'], ['rock', 'paper', 'scissors', 'scissors'], ['rock', 'scissors', 'rock', 'rock'], ['rock', 'scissors', 'rock', 'paper'], ['rock', 'scissors', 'rock', 'scissors'], ['rock', 'scissors', 'paper', 'rock'], ['rock', 'scissors', 'paper', 'paper'], ['rock', 'scissors', 'paper', 'scissors'], ['rock', 'scissors', 'scissors', 'rock'], ['rock', 'scissors', 'scissors', 'paper'], ['rock', 'scissors', 'scissors', 'scissors'], ['paper', 'rock', 'rock', 'rock'], ['paper', 'rock', 'rock', 'paper'], ['paper', 'rock', 'rock', 'scissors'], ['paper', 'rock', 'paper', 'rock'], ['paper', 'rock', 'paper', 'paper'], ['paper', 'rock', 'paper', 'scissors'], ['paper', 'rock', 'scissors', 'rock'], ['paper', 'rock', 'scissors', 'paper'], ['paper', 'rock', 'scissors', 'scissors'], ['paper', 'paper', 'rock', 'rock'], ['paper', 'paper', 'rock', 'paper'], ['paper', 'paper', 'rock', 'scissors'], ['paper', 'paper', 'paper', 'rock'], ['paper', 'paper', 'paper', 'paper'], ['paper', 'paper', 'paper', 'scissors'], ['paper', 'paper', 'scissors', 'rock'], ['paper', 'paper', 'scissors', 'paper'], ['paper', 'paper', 'scissors', 'scissors'], ['paper', 'scissors', 'rock', 'rock'], ['paper', 'scissors', 'rock', 'paper'], ['paper', 'scissors', 'rock', 'scissors'], ['paper', 'scissors', 'paper', 'rock'], ['paper', 'scissors', 'paper', 'paper'], ['paper', 'scissors', 'paper', 'scissors'], ['paper', 'scissors', 'scissors', 'rock'], ['paper', 'scissors', 'scissors', 'paper'], ['paper', 'scissors', 'scissors', 'scissors'], ['scissors', 'rock', 'rock', 'rock'], ['scissors', 'rock', 'rock', 'paper'], ['scissors', 'rock', 'rock', 'scissors'], ['scissors', 'rock', 'paper', 'rock'], ['scissors', 'rock', 'paper', 'paper'], ['scissors', 'rock', 'paper', 'scissors'], ['scissors', 'rock', 'scissors', 'rock'], ['scissors', 'rock', 'scissors', 'paper'], ['scissors', 'rock', 'scissors', 'scissors'], ['scissors', 'paper', 'rock', 'rock'], ['scissors', 'paper', 'rock', 'paper'], ['scissors', 'paper', 'rock', 'scissors'], ['scissors', 'paper', 'paper', 'rock'], ['scissors', 'paper', 'paper', 'paper'], ['scissors', 'paper', 'paper', 'scissors'], ['scissors', 'paper', 'scissors', 'rock'], ['scissors', 'paper', 'scissors', 'paper'], ['scissors', 'paper', 'scissors', 'scissors'], ['scissors', 'scissors', 'rock', 'rock'], ['scissors', 'scissors', 'rock', 'paper'], ['scissors', 'scissors', 'rock', 'scissors'], ['scissors', 'scissors', 'paper', 'rock'], ['scissors', 'scissors', 'paper', 'paper'], ['scissors', 'scissors', 'paper', 'scissors'], ['scissors', 'scissors', 'scissors', 'rock'], ['scissors', 'scissors', 'scissors', 'paper'], ['scissors', 'scissors', 'scissors', 'scissors']]) - self.assertEqual(rock_paper_scissors(5), [['rock', 'rock', 'rock', 'rock', 'rock'], ['rock', 'rock', 'rock', 'rock', 'paper'], ['rock', 'rock', 'rock', 'rock', 'scissors'], ['rock', 'rock', 'rock', 'paper', 'rock'], ['rock', 'rock', 'rock', 'paper', 'paper'], ['rock', 'rock', 'rock', 'paper', 'scissors'], ['rock', 'rock', 'rock', 'scissors', 'rock'], ['rock', 'rock', 'rock', 'scissors', 'paper'], ['rock', 'rock', 'rock', 'scissors', 'scissors'], ['rock', 'rock', 'paper', 'rock', 'rock'], ['rock', 'rock', 'paper', 'rock', 'paper'], ['rock', 'rock', 'paper', 'rock', 'scissors'], ['rock', 'rock', 'paper', 'paper', 'rock'], ['rock', 'rock', 'paper', 'paper', 'paper'], ['rock', 'rock', 'paper', 'paper', 'scissors'], ['rock', 'rock', 'paper', 'scissors', 'rock'], ['rock', 'rock', 'paper', 'scissors', 'paper'], ['rock', 'rock', 'paper', 'scissors', 'scissors'], ['rock', 'rock', 'scissors', 'rock', 'rock'], ['rock', 'rock', 'scissors', 'rock', 'paper'], ['rock', 'rock', 'scissors', 'rock', 'scissors'], ['rock', 'rock', 'scissors', 'paper', 'rock'], ['rock', 'rock', 'scissors', 'paper', 'paper'], ['rock', 'rock', 'scissors', 'paper', 'scissors'], ['rock', 'rock', 'scissors', 'scissors', 'rock'], ['rock', 'rock', 'scissors', 'scissors', 'paper'], ['rock', 'rock', 'scissors', 'scissors', 'scissors'], ['rock', 'paper', 'rock', 'rock', 'rock'], ['rock', 'paper', 'rock', 'rock', 'paper'], ['rock', 'paper', 'rock', 'rock', 'scissors'], ['rock', 'paper', 'rock', 'paper', 'rock'], ['rock', 'paper', 'rock', 'paper', 'paper'], ['rock', 'paper', 'rock', 'paper', 'scissors'], ['rock', 'paper', 'rock', 'scissors', 'rock'], ['rock', 'paper', 'rock', 'scissors', 'paper'], ['rock', 'paper', 'rock', 'scissors', 'scissors'], ['rock', 'paper', 'paper', 'rock', 'rock'], ['rock', 'paper', 'paper', 'rock', 'paper'], ['rock', 'paper', 'paper', 'rock', 'scissors'], ['rock', 'paper', 'paper', 'paper', 'rock'], ['rock', 'paper', 'paper', 'paper', 'paper'], ['rock', 'paper', 'paper', 'paper', 'scissors'], ['rock', 'paper', 'paper', 'scissors', 'rock'], ['rock', 'paper', 'paper', 'scissors', 'paper'], ['rock', 'paper', 'paper', 'scissors', 'scissors'], ['rock', 'paper', 'scissors', 'rock', 'rock'], ['rock', 'paper', 'scissors', 'rock', 'paper'], ['rock', 'paper', 'scissors', 'rock', 'scissors'], ['rock', 'paper', 'scissors', 'paper', 'rock'], ['rock', 'paper', 'scissors', 'paper', 'paper'], ['rock', 'paper', 'scissors', 'paper', 'scissors'], ['rock', 'paper', 'scissors', 'scissors', 'rock'], ['rock', 'paper', 'scissors', 'scissors', 'paper'], ['rock', 'paper', 'scissors', 'scissors', 'scissors'], ['rock', 'scissors', 'rock', 'rock', 'rock'], ['rock', 'scissors', 'rock', 'rock', 'paper'], ['rock', 'scissors', 'rock', 'rock', 'scissors'], ['rock', 'scissors', 'rock', 'paper', 'rock'], ['rock', 'scissors', 'rock', 'paper', 'paper'], ['rock', 'scissors', 'rock', 'paper', 'scissors'], ['rock', 'scissors', 'rock', 'scissors', 'rock'], ['rock', 'scissors', 'rock', 'scissors', 'paper'], ['rock', 'scissors', 'rock', 'scissors', 'scissors'], ['rock', 'scissors', 'paper', 'rock', 'rock'], ['rock', 'scissors', 'paper', 'rock', 'paper'], ['rock', 'scissors', 'paper', 'rock', 'scissors'], ['rock', 'scissors', 'paper', 'paper', 'rock'], ['rock', 'scissors', 'paper', 'paper', 'paper'], ['rock', 'scissors', 'paper', 'paper', 'scissors'], ['rock', 'scissors', 'paper', 'scissors', 'rock'], ['rock', 'scissors', 'paper', 'scissors', 'paper'], ['rock', 'scissors', 'paper', 'scissors', 'scissors'], ['rock', 'scissors', 'scissors', 'rock', 'rock'], ['rock', 'scissors', 'scissors', 'rock', 'paper'], ['rock', 'scissors', 'scissors', 'rock', 'scissors'], ['rock', 'scissors', 'scissors', 'paper', 'rock'], ['rock', 'scissors', 'scissors', 'paper', 'paper'], ['rock', 'scissors', 'scissors', 'paper', 'scissors'], ['rock', 'scissors', 'scissors', 'scissors', 'rock'], ['rock', 'scissors', 'scissors', 'scissors', 'paper'], ['rock', 'scissors', 'scissors', 'scissors', 'scissors'], ['paper', 'rock', 'rock', 'rock', 'rock'], ['paper', 'rock', 'rock', 'rock', 'paper'], ['paper', 'rock', 'rock', 'rock', 'scissors'], ['paper', 'rock', 'rock', 'paper', 'rock'], ['paper', 'rock', 'rock', 'paper', 'paper'], ['paper', 'rock', 'rock', 'paper', 'scissors'], ['paper', 'rock', 'rock', 'scissors', 'rock'], ['paper', 'rock', 'rock', 'scissors', 'paper'], ['paper', 'rock', 'rock', 'scissors', 'scissors'], ['paper', 'rock', 'paper', 'rock', 'rock'], ['paper', 'rock', 'paper', 'rock', 'paper'], ['paper', 'rock', 'paper', 'rock', 'scissors'], ['paper', 'rock', 'paper', 'paper', 'rock'], ['paper', 'rock', 'paper', 'paper', 'paper'], ['paper', 'rock', 'paper', 'paper', 'scissors'], ['paper', 'rock', 'paper', 'scissors', 'rock'], ['paper', 'rock', 'paper', 'scissors', 'paper'], ['paper', 'rock', 'paper', 'scissors', 'scissors'], ['paper', 'rock', 'scissors', 'rock', 'rock'], ['paper', 'rock', 'scissors', 'rock', 'paper'], ['paper', 'rock', 'scissors', 'rock', 'scissors'], ['paper', 'rock', 'scissors', 'paper', 'rock'], ['paper', 'rock', 'scissors', 'paper', 'paper'], ['paper', 'rock', 'scissors', 'paper', 'scissors'], ['paper', 'rock', 'scissors', 'scissors', 'rock'], ['paper', 'rock', 'scissors', 'scissors', 'paper'], ['paper', 'rock', 'scissors', 'scissors', 'scissors'], ['paper', 'paper', 'rock', 'rock', 'rock'], ['paper', 'paper', 'rock', 'rock', 'paper'], ['paper', 'paper', 'rock', 'rock', 'scissors'], ['paper', 'paper', 'rock', 'paper', 'rock'], ['paper', 'paper', 'rock', 'paper', 'paper'], ['paper', 'paper', 'rock', 'paper', 'scissors'], ['paper', 'paper', 'rock', 'scissors', 'rock'], ['paper', 'paper', 'rock', 'scissors', 'paper'], ['paper', 'paper', 'rock', 'scissors', 'scissors'], ['paper', 'paper', 'paper', 'rock', 'rock'], ['paper', 'paper', 'paper', 'rock', 'paper'], ['paper', 'paper', 'paper', 'rock', 'scissors'], ['paper', 'paper', 'paper', 'paper', 'rock'], ['paper', 'paper', 'paper', 'paper', 'paper'], ['paper', 'paper', 'paper', 'paper', 'scissors'], ['paper', 'paper', 'paper', 'scissors', 'rock'], ['paper', 'paper', 'paper', 'scissors', 'paper'], ['paper', 'paper', 'paper', 'scissors', 'scissors'], ['paper', 'paper', 'scissors', 'rock', 'rock'], ['paper', 'paper', 'scissors', 'rock', 'paper'], ['paper', 'paper', 'scissors', 'rock', 'scissors'], ['paper', 'paper', 'scissors', 'paper', 'rock'], ['paper', 'paper', 'scissors', 'paper', 'paper'], ['paper', 'paper', 'scissors', 'paper', 'scissors'], ['paper', 'paper', 'scissors', 'scissors', 'rock'], ['paper', 'paper', 'scissors', 'scissors', 'paper'], ['paper', 'paper', 'scissors', 'scissors', 'scissors'], ['paper', 'scissors', 'rock', 'rock', 'rock'], ['paper', 'scissors', 'rock', 'rock', 'paper'], ['paper', 'scissors', 'rock', 'rock', 'scissors'], ['paper', 'scissors', 'rock', 'paper', 'rock'], ['paper', 'scissors', 'rock', 'paper', 'paper'], ['paper', 'scissors', 'rock', 'paper', 'scissors'], ['paper', 'scissors', 'rock', 'scissors', 'rock'], ['paper', 'scissors', 'rock', 'scissors', 'paper'], ['paper', 'scissors', 'rock', 'scissors', 'scissors'], ['paper', 'scissors', 'paper', 'rock', 'rock'], ['paper', 'scissors', 'paper', 'rock', 'paper'], ['paper', 'scissors', 'paper', 'rock', 'scissors'], ['paper', 'scissors', 'paper', 'paper', 'rock'], ['paper', 'scissors', 'paper', 'paper', 'paper'], ['paper', 'scissors', 'paper', 'paper', 'scissors'], ['paper', 'scissors', 'paper', 'scissors', 'rock'], ['paper', 'scissors', 'paper', 'scissors', 'paper'], ['paper', 'scissors', 'paper', 'scissors', 'scissors'], ['paper', 'scissors', 'scissors', 'rock', 'rock'], ['paper', 'scissors', 'scissors', 'rock', 'paper'], ['paper', 'scissors', 'scissors', 'rock', 'scissors'], ['paper', 'scissors', 'scissors', 'paper', 'rock'], ['paper', 'scissors', 'scissors', 'paper', 'paper'], ['paper', 'scissors', 'scissors', 'paper', 'scissors'], ['paper', 'scissors', 'scissors', 'scissors', 'rock'], ['paper', 'scissors', 'scissors', 'scissors', 'paper'], ['paper', 'scissors', 'scissors', 'scissors', 'scissors'], ['scissors', 'rock', 'rock', 'rock', 'rock'], ['scissors', 'rock', 'rock', 'rock', 'paper'], ['scissors', 'rock', 'rock', 'rock', 'scissors'], ['scissors', 'rock', 'rock', 'paper', 'rock'], ['scissors', 'rock', 'rock', 'paper', 'paper'], ['scissors', 'rock', 'rock', 'paper', 'scissors'], ['scissors', 'rock', 'rock', 'scissors', 'rock'], ['scissors', 'rock', 'rock', 'scissors', 'paper'], ['scissors', 'rock', 'rock', 'scissors', 'scissors'], ['scissors', 'rock', 'paper', 'rock', 'rock'], ['scissors', 'rock', 'paper', 'rock', 'paper'], ['scissors', 'rock', 'paper', 'rock', 'scissors'], ['scissors', 'rock', 'paper', 'paper', 'rock'], ['scissors', 'rock', 'paper', 'paper', 'paper'], ['scissors', 'rock', 'paper', 'paper', 'scissors'], ['scissors', 'rock', 'paper', 'scissors', 'rock'], ['scissors', 'rock', 'paper', 'scissors', 'paper'], ['scissors', 'rock', 'paper', 'scissors', 'scissors'], ['scissors', 'rock', 'scissors', 'rock', 'rock'], ['scissors', 'rock', 'scissors', 'rock', 'paper'], ['scissors', 'rock', 'scissors', 'rock', 'scissors'], ['scissors', 'rock', 'scissors', 'paper', 'rock'], ['scissors', 'rock', 'scissors', 'paper', 'paper'], ['scissors', 'rock', 'scissors', 'paper', 'scissors'], ['scissors', 'rock', 'scissors', 'scissors', 'rock'], ['scissors', 'rock', 'scissors', 'scissors', 'paper'], ['scissors', 'rock', 'scissors', 'scissors', 'scissors'], ['scissors', 'paper', 'rock', 'rock', 'rock'], ['scissors', 'paper', 'rock', 'rock', 'paper'], ['scissors', 'paper', 'rock', 'rock', 'scissors'], ['scissors', 'paper', 'rock', 'paper', 'rock'], ['scissors', 'paper', 'rock', 'paper', 'paper'], ['scissors', 'paper', 'rock', 'paper', 'scissors'], ['scissors', 'paper', 'rock', 'scissors', 'rock'], ['scissors', 'paper', 'rock', 'scissors', 'paper'], ['scissors', 'paper', 'rock', 'scissors', 'scissors'], ['scissors', 'paper', 'paper', 'rock', 'rock'], ['scissors', 'paper', 'paper', 'rock', 'paper'], ['scissors', 'paper', 'paper', 'rock', 'scissors'], ['scissors', 'paper', 'paper', 'paper', 'rock'], ['scissors', 'paper', 'paper', 'paper', 'paper'], ['scissors', 'paper', 'paper', 'paper', 'scissors'], ['scissors', 'paper', 'paper', 'scissors', 'rock'], ['scissors', 'paper', 'paper', 'scissors', 'paper'], ['scissors', 'paper', 'paper', 'scissors', 'scissors'], ['scissors', 'paper', 'scissors', 'rock', 'rock'], ['scissors', 'paper', 'scissors', 'rock', 'paper'], ['scissors', 'paper', 'scissors', 'rock', 'scissors'], ['scissors', 'paper', 'scissors', 'paper', 'rock'], ['scissors', 'paper', 'scissors', 'paper', 'paper'], ['scissors', 'paper', 'scissors', 'paper', 'scissors'], ['scissors', 'paper', 'scissors', 'scissors', 'rock'], ['scissors', 'paper', 'scissors', 'scissors', 'paper'], ['scissors', 'paper', 'scissors', 'scissors', 'scissors'], ['scissors', 'scissors', 'rock', 'rock', 'rock'], ['scissors', 'scissors', 'rock', 'rock', 'paper'], ['scissors', 'scissors', 'rock', 'rock', 'scissors'], ['scissors', 'scissors', 'rock', 'paper', 'rock'], ['scissors', 'scissors', 'rock', 'paper', 'paper'], ['scissors', 'scissors', 'rock', 'paper', 'scissors'], ['scissors', 'scissors', 'rock', 'scissors', 'rock'], ['scissors', 'scissors', 'rock', 'scissors', 'paper'], ['scissors', 'scissors', 'rock', 'scissors', 'scissors'], ['scissors', 'scissors', 'paper', 'rock', 'rock'], ['scissors', 'scissors', 'paper', 'rock', 'paper'], ['scissors', 'scissors', 'paper', 'rock', 'scissors'], ['scissors', 'scissors', 'paper', 'paper', 'rock'], ['scissors', 'scissors', 'paper', 'paper', 'paper'], ['scissors', 'scissors', 'paper', 'paper', 'scissors'], ['scissors', 'scissors', 'paper', 'scissors', 'rock'], ['scissors', 'scissors', 'paper', 'scissors', 'paper'], ['scissors', 'scissors', 'paper', 'scissors', 'scissors'], ['scissors', 'scissors', 'scissors', 'rock', 'rock'], ['scissors', 'scissors', 'scissors', 'rock', 'paper'], ['scissors', 'scissors', 'scissors', 'rock', 'scissors'], ['scissors', 'scissors', 'scissors', 'paper', 'rock'], ['scissors', 'scissors', 'scissors', 'paper', 'paper'], ['scissors', 'scissors', 'scissors', 'paper', 'scissors'], ['scissors', 'scissors', 'scissors', 'scissors', 'rock'], ['scissors', 'scissors', 'scissors', 'scissors', 'paper'], ['scissors', 'scissors', 'scissors', 'scissors', 'scissors']]) +if __name__ == "__main__": + unittest.main() -if __name__ == '__main__': - unittest.main() \ No newline at end of file diff --git a/stock_prices/README.md b/stock_prices/README.md index 75d1af9e9..91f68825d 100644 --- a/stock_prices/README.md +++ b/stock_prices/README.md @@ -1,10 +1,10 @@ # Stock Prices -You want to write a bot that will automate the task of day-trading for you while you're going through Lambda. You decide to have your bot just focus on buying and selling Amazon stock. +You want to write a bot that will automate the task of day-trading for you while you're going through Lambda. You decide to have your bot just focus on buying and selling Amazon stock. Write a function `find_max_profit` that receives as input a list of stock prices. Your function should return the maximum profit that can be made from a single buy and sell. You must buy first before selling; no shorting is allowed here. -For example, `find_max_profit([1050, 270, 1540, 3800, 2])` should return 3530, which is the maximum profit that can be made from a single buy and then sell of these stock prices. +For example, `find_max_profit([1050, 270, 1540, 3800, 2])` should return 3530, which is the maximum profit that can be made from a single buy and then sell of these stock prices. ## Testing @@ -14,6 +14,6 @@ You can also test your implementation manually by executing `python stock_prices ## Hints - For this problem, we essentially want to find the maximum difference between the smallest and largest prices in the list of prices, but we also have to make sure that the max profit is computed by subtracting some price by another price that comes _before_ it; it can't come after it in the list of prices. + For this problem, we essentially want to find the maximum difference between the smallest and largest prices in the list of prices, but we also have to make sure that the max profit is computed by subtracting some price by another price that comes _before_ it; it can't come after it in the list of prices. - So what if we kept track of the `current_min_price_so_far` and the `max_profit_so_far`? \ No newline at end of file + So what if we kept track of the `current_min_price_so_far` and the `max_profit_so_far`? diff --git a/stock_prices/stock_prices.py b/stock_prices/stock_prices.py index 9de20bc94..fb103d885 100644 --- a/stock_prices/stock_prices.py +++ b/stock_prices/stock_prices.py @@ -2,14 +2,22 @@ import argparse + def find_max_profit(prices): - pass + pass + +if __name__ == "__main__": + # This is just some code to accept inputs from the command line + parser = argparse.ArgumentParser(description="Find max profit from prices.") + parser.add_argument( + "integers", metavar="N", type=int, nargs="+", help="an integer price" + ) + args = parser.parse_args() -if __name__ == '__main__': - # This is just some code to accept inputs from the command line - parser = argparse.ArgumentParser(description='Find max profit from prices.') - parser.add_argument('integers', metavar='N', type=int, nargs='+', help='an integer price') - args = parser.parse_args() + print( + "A profit of ${profit} can be made from the stock prices {prices}.".format( + profit=find_max_profit(args.integers), prices=args.integers + ) + ) - print("A profit of ${profit} can be made from the stock prices {prices}.".format(profit=find_max_profit(args.integers), prices=args.integers)) \ No newline at end of file diff --git a/stock_prices/test_stock_prices.py b/stock_prices/test_stock_prices.py index a04f8e762..9524fbf26 100644 --- a/stock_prices/test_stock_prices.py +++ b/stock_prices/test_stock_prices.py @@ -1,14 +1,20 @@ import unittest -from stock_prices import find_max_profit +from stock_prices import find_max_profit + class Test(unittest.TestCase): + def test_find_max_profit(self): + self.assertEqual(find_max_profit([10, 7, 5, 8, 11, 9]), 6) + self.assertEqual(find_max_profit([100, 90, 80, 50, 20, 10]), -10) + self.assertEqual(find_max_profit([1050, 270, 1540, 3800, 2]), 3530) + self.assertEqual( + find_max_profit( + [100, 55, 4, 98, 10, 18, 90, 95, 43, 11, 47, 67, 89, 42, 49, 79] + ), + 94, + ) + - def test_find_max_profit(self): - self.assertEqual(find_max_profit([10, 7, 5, 8, 11, 9]), 6) - self.assertEqual(find_max_profit([100, 90, 80, 50, 20, 10]), -10) - self.assertEqual(find_max_profit([1050, 270, 1540, 3800, 2]), 3530) - self.assertEqual(find_max_profit([100, 55, 4, 98, 10, 18, 90, 95, 43, 11, 47, 67, 89, 42, 49, 79]), 94) - +if __name__ == "__main__": + unittest.main() -if __name__ == '__main__': - unittest.main() \ No newline at end of file