• API
• FAQ
• Tools
• Archive
SHARE
TWEET # Untitled a guest Jan 20th, 2020 93 Never
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
1. """Exam3."""
2. from typing import List, Tuple, Optional
3. import re
4.
5.
6. def sum_nums(num1: int, num2: int) -> List:
7.     """
8.     Sum two numbers as an integer and as a string.
9.
10.     #01
11.
12.     sum_nums(1, 2) -> [3, '12']
13.     sum_nums(12, 34) -> [46, '1234']
14.     sum_nums(33, 44) -> [77, '3344']
15.     sum_nums(0, 0) -> [0, '00']
16.
17.     :param num1: Given non-negative integer
18.     :param num2: Given non-negative integer
19.     :return: Sums of num1, num2; list with one integer and one string.
20.     """
21.     return [num1 + num2, str(num1) + str(num2)]
22.
23.
24. def numbers_in_list(number1: int, number2: int, numbers: List[int]) -> int:
25.     """
26.     Given two integers and a list, return the required result.
27.
28.     #02
29.
30.     Return sum of the two numbers if both numbers are in the given list.
31.     If only one of these numbers is in the list, return that number minus the other number.
32.     If both of them are not in the list, return product of their multiplication, unless they differ from 0 equally,
33.     then return 0.
34.
35.     numbers_in_list(3, 5, [5, 6, 3, 1]) -> 8
36.     numbers_in_list(0, 2, [3, 2, 9]) -> 2
37.     numbers_in_list(0, 2, [3, 0, 9]) -> -2
38.     numbers_in_list(3, 6, [5, 9, 8]) -> 18
39.     numbers_in_list(9, 9, [0, 6, 32]) -> 0
40.
41.     :param number1: First given number
42.     :param number2: Second given number
43.     :param numbers: Given list
44.     :return: Required result.
45.     """
46.     if number1 in numbers and number2 in numbers:
47.         return number1 + number2
48.     elif number1 in numbers and number2 not in numbers:
49.         return number1 - number2
50.     elif number2 in numbers and number1 not in numbers:
51.         return number2 - number1
52.     elif number1 not in numbers and number2 not in numbers and abs(number1) != abs(number2):
53.         return number1 * number2
54.     elif number1 not in numbers and number2 not in numbers and abs(number1) == abs(number2):
55.         return 0
56.
57.
58. def multiply_after_digit(s: str) -> str:
59.     """
60.     Given a string where the number before letter stands for its quantity, return the result string.
61.
62.     #03
63.
64.     You get 80% (40 points out of 50) if the function works with one digit. To get 100%, is should also work with more digits.
65.
66.     multiply_after_digit('a5b4c') -> 'abbbbbcccc'
67.     multiply_after_digit('2 0nhe2lo world3!') -> '  hello world!!!'
68.     multiply_after_digit('thi10s end3s wit3h 31') -> 'thissssssssss endsss withhh ' (to get 100%)
69.
70.     :param s: Given input string
71.     :return: Result string.
72.     """
73.     string = ""
74.     pattern = r"\d+\s|\s|\d+[^\d]|[^\d]"
75.     mps = [n for n in re.findall(pattern, s)]
76.     print(mps)
77.     for i in mps:
78.         if len(i) == 1:
79.             try:
80.                 if int(i) and i != " ":
81.                     return string
82.             except ValueError:
83.                 string += i
84.         elif len(i) > 1:
85.             if i[-1] == " ":
86.                 string += i[-1] * int(i[:-1])
87.             try:
88.                 if int(i) and i[-1] != " ":
89.                     return string
90.             except ValueError:
91.                 string += i[-1] * int(i[:-1])
92.     return string
93.
94.
95. def mastermind_guess(solution: List[int], guess: List[int]) -> List[int]:
96.     """
97.     Return the result of the guess in Mastermind game.
98.
99.     #04
100.
101.     Mastermind is a game where the player tries to guess the correct order of numbers.
102.     The function has a parameter solution, which indicates the correct order of elements.
103.     All the elements are positive numbers, there are no duplicate elements in the solution.
104.     The parameter guess indicates a guess by the player.
105.     The length of the solution and guess is always the same.
106.
107.     The function should return the outcome of the guess,
108.     where for every element in guess there is a number in the result:
109.     - 2 if the given element in guess was in the correct position (in solution)
110.     - 1 if the given element in guess is in solution, but not in the correct position,
111.     - 0 if the given element is not in the solution.
112.
113.     The length of the solution (and guess) is at least 1.
114.
115.     Examples:
116.
117.     mastermind_guess([1, 2, 3], [1, 2, 3]) => [2, 2, 2]
118.     mastermind_guess([1, 2, 3], [3, 1, 2]) => [1, 1, 1]
119.     mastermind_guess([1, 2, 3], [3, 3, 3]) => [1, 1, 2]
120.     mastermind_guess([1, 2], [7, 3]) => [0, 0]
121.
122.     :param solution: Non-empty list of positive integers.
123.     :param guess: Non-empty list of positive integers.
124.     :return: Result for the guess.
125.     """
127.     for n in range(0, len(solution)):
128.         if solution[n] == guess[n]:
130.         elif guess[n] in solution:
132.         else:
135.
136.
137. def reformat_money(data: dict) -> dict:
138.     """
139.     Reformat data in dictionary.
140.
141.     #05
142.
143.     Dictionary represents money (integers) as keys and people's names (strings) as values.
144.     You should switch key-value pairs in dictionary, to know, how much money each person has.
145.     There can be different money entries with same names, you have to sum the money for each person.
146.     If a persons name contains the words james or bond (non-case sensitive), double the money to be added.
147.
148.     The order of the dict is not important.
149.
150.     reformat_money({10: 'A', 20: 'B', 30: 'a', 40: 'A', 50: 'James'}) => {'A': 50, 'B': 20, 'a': 30, 'James': 100}
151.
152.     :param data: Dictionary with data
153.     :return: Dictionary with reformatted data.
154.     """
155.     new_dict = {}
156.     keys = [i for i in data.keys()]
157.     values = [i for i in data.values()]
158.     for i in range(len(keys)):
159.         if values[i].lower() == "james" or values[i].lower() == "bond" and values[i] not in new_dict:
160.             new_dict[values[i]] = keys[i] * 2
161.         elif values[i].lower() == "james" or values[i].lower() == "bond":
162.             new_dict[values[i]] += keys[i] * 2
163.         elif values[i] not in new_dict:
164.             new_dict[values[i]] = keys[i]
165.         else:
166.             new_dict[values[i]] += keys[i]
167.     return new_dict
168.
169.
170. def collatz_conjecture(num: int, i=0, max_term=0) -> Optional[Tuple[int, int]]:
171.     """
172.     Given integer, return the number of steps Collatz sequence needed to reach 1 and the biggest term on the way.
173.
174.     #06
175.
176.     The solution has to be recursive!
177.
178.     The Collatz conjecture is a conjecture that concerns a sequence that started with any positive integer n.
179.     If the previous term is even, the next term is previous term / 2.
180.     If the previous term is odd, the next term is 3 * previous term + 1.
181.     The conjecture states that no matter what value of n, the sequence will always reach 1.
182.
183.     collatz_conjecture(12) -> 9, 16 (sequence is [12, 6, 3, 10, 5, 16, 8, 4, 2, 1], steps - 9, biggest term - 16)
184.     collatz_conjecture(1) -> 0, 1 (sequence is , steps - 0, biggest term - 1)
185.     collatz_conjecture(27) -> 111, 9232
186.     collatz_conjecture(670617279) -> 949, 966616035460 (close to the border of RecursionError, but should still work)
187.     collatz_conjecture(0) -> None
188.
189.     :param num: Given integer
190.     :return: Tuple with length of sequence and biggest term or None if input is not valid.
191.     """
192.     if num <= 0:
193.         return None
194.     if num > max_term:
195.         max_term = num
196.     if num == 1:
197.         return i, max_term
198.     elif num > 1:
199.         i += 1
200.         if num % 2 == 0:
201.             num = num // 2
202.             return collatz_conjecture(num, i, max_term)
203.         else:
204.             num = 3 * num + 1
205.             return collatz_conjecture(num, i, max_term)
206.
207.
208. def plot_the_tangerines(integers: List[int]) -> str:
209.     """
210.     Given list of non-negative integers create a bar graph.
211.
212.     #07
213.
214.     Recently you have noticed that your consumption of tangerines is too high.
215.     You want to monitor the situation so you try to make a bar graph of tangerines consumption in Excel.
216.     But Excel won't work, because you have just started using Linux.
217.     Oh well, it seems that you have to make your own program to plot graphs and do fancy calculations.
218.
219.     Graph consists of scale (left) and stack of '#'s that represent integer in the list (consumed tangerines in a day).
220.     0 means stack of 0 '#', 1 means stack of 1 '#', 2 means stack of 2 '#' and so on.
221.
222.     Graph max height should be the maximum value from the list, max is always at least 1.
223.     There is always at least one element in the list.
224.     Graph needs to be in a frame consisting of '|', '-' and '+' characters as shown in examples.
225.     There should be no newlines before or after the graph.
226.
227.
228.     plot_the_tangerines([1, 0, 2, 3, 4, 5, 4, 3, 2, 1, 0, 3, 2, 1]) =>
229.      +--------------+
230.     5|     #        |
231.     4|    ###       |
232.     3|   #####   #  |
233.     2|  #######  ## |
234.     1|# ######## ###|
235.     0+--------------+
236.
237.     plot_the_tangerines() =>
238.      +-+
239.     1+ +
240.     0+-+
241.
242.     plot_the_tangerines([0, 0, 0, 0, 0, 0])) =>
243.      +------+
244.     1|      |
245.     0+------+
246.
247.     plot_the_tangerines([1, 4, 5, 3, 1]) =>
248.      +-----+
249.     5|  #  |
250.     4| ##  |
251.     3| ### |
252.     2| ### |
253.     1|#####|
254.     0+-----+
255.
256.     In case the maximum value is is more than 9, the left side should be wider, aligned to right:
257.
258.        +-----
259.     100|
260.      99|
261.      ....
262.       9|#
263.       8|#
264.       ...
265.       0+-----
266.     all.
267.     """
268.     nr_len = len(str(max(integers)))
269.     upper = f"{' ' * nr_len}+{'-' * len(integers)}+"
270.     lower = f"{' ' * (nr_len - 1)}0+{'-' * len(integers)}+"
271.     fill = [f"{' ' * (nr_len - 1)}{i}|{' ' * len(integers)}|" if i <= 9 else f"{' ' * (nr_len - 2)}{i}|{' ' * len(integers)}|" for i in range(1, max(integers) + 1)]
272.     fill.reverse()
273.     # upper = f" +{'-' * len(integers)}+"
274.     # lower = f"0+{'-' * len(integers)}+"
275.     # fill = [f"{i}|{' ' * len(integers)}|" for i in range(1, max(integers) + 1)]
276.     # fill.reverse()
277.     lines = ""
278.     if not fill:
279.         lines = f"1|{' ' * len(integers)}|" + "\n"
280.     for n in range(len(integers)):
281.         for l in range(len(fill)):
282.             if help_func2(fill[l]) <= integers[n]:
283.                 length = len(str(help_func2(fill[l])))
284.                 fill[l] = fill[l][:n + 1 + length] + "#" + fill[l][n + 2 + length:]
285.                 # line[n + 2].replace("#", line[n + 2])
286.     for line in fill:
287.         lines += line + "\n"
288.     table = upper + "\n" + lines + lower
289.     return table
290.     # upper = f" +{'-' * len(integers)}+"
291.     # lower = f"0+{'-' * len(integers)}+"
292.     # fill = [f"{i}|{' ' * len(integers)}|" for i in range(1, max(integers) + 1)]
293.     # fill.reverse()
294.     # lines = ""
295.     # if not fill:
296.     #     lines = f"1|{' ' * len(integers)}|" + "\n"
297.     # for n in range(len(integers)):
298.     #     for l in range(len(fill)):
299.     #         if int(fill[l]) <= integers[n]:
300.     #             fill[l] = fill[l][:n + 2] + "#" + fill[l][n + 3:]
301.     #             # line[n + 2].replace("#", line[n + 2])
302.     # for line in fill:
303.     #     lines += line + "\n"
304.     # table = upper + "\n" + lines + lower
305.     # return table
306.
307.
308. def help_func2(line):
309.     """Help."""
310.     return int([n for n in re.findall(r"\d+", line)])
311.
312. # 08 - OOP1 - transport
313.
314.
315. class Passenger:
316.     """Class that defines passenger object."""
317.
318.     def __init__(self, first_name: str, age: int):
319.         """
320.         Initialize passenger.
321.
322.         self.is_validated - when passenger arrives to the vehicle, they should validate themselves.
323.             If the passenger doesn't do that and inspector arrives, the passenger will be kicked out from the vehicle.
324.         self.vehicle - describes vehicle, where passenger is at the moment.
325.
326.         One passenger can't be on multiple vehicles at the same time.
327.
328.         :param first_name: Passenger's first name.
329.         :param age: Passenger's age.
330.
331.         """
332.         self.first_name = first_name
333.         self.age = age
334.         self.is_validated = False
335.         self.vehicle = None
336.
337.     def validate(self):
338.         """Validate passenger."""
339.         self.is_validated = True
340.
341.
342. class PublicTransportVehicle:
343.     """Class that defines public transport vehicle object."""
344.
345.     def __init__(self, seats: int):
346.         """
347.         Initialize vehicle.
348.
349.         :param seats: Amount of seats in the public transport vehicle. If the amount of seats is smaller than 0, then it should be determined that there is 1 seat in the vehicle.
350.             Vehicle driver does not need a seat.
351.         """
352.         self.seats = seats
353.         self.passengers = []
354.         if self.seats <= 0:
355.             self.seats = 1
356.
357.     def get_amount_of_people(self) -> int:
358.         """
359.         Return amount of people in the bus including the vehicle driver.
360.
361.         Assume that driver is always in the vehicle.
362.
363.         :return: Amount of people as integer.
364.         """
365.         return len(self.passengers) + 1
366.
367.     def get_all_passengers(self) -> List:
368.         """
369.         Return the list of passengers.
370.
371.         :return: Passengers as list.
372.         """
373.         return self.passengers
374.
375.     def add_new_passenger(self, passenger: Passenger) -> bool:
376.         """
377.         Register new passenger if there is a seat for him/her.
378.
379.         :return: True if passenger can be added, otherwise (if not enough seats or passenger is already there) False.
380.         """
381.         if len(self.passengers) < self.seats and passenger not in self.passengers:
382.             self.passengers.append(passenger)
383.             return True
384.         return False
385.
386.     def release_passenger(self, passenger: Passenger):
387.         """Release passenger (passenger leaves the vehicle)."""
388.         self.passengers.remove(passenger) if passenger in self.passengers else None
389.
390.     def inspector_arrival(self):
391.         """All passengers, who are not validated, will be kicked out from vehicle."""
392.         self.passengers = [p for p in self.passengers if p.is_validated]
393.
394.
395. # 09 - OOP2 - village
396.
397.
398. class Building:
399.     """Represents one building."""
400.
401.     def __init__(self, name: str, resources: dict):
402.         """Initialize building."""
403.         self.name = name
404.         self.resources = resources
405.         self.level = 1
406.
409.         self.level += 1
410.
413.         self.level -= 1
414.
415.     def get_name(self):
416.         """Return building name."""
417.         return self.name
418.
419.     def get_level(self):
420.         """Return building level."""
421.         return self.level
422.
423.     def __repr__(self):
424.         """Representation of Building."""
425.         return f"{self.name} ({self.level})"
426.
427.
428. class Village:
429.     """Represents village."""
430.
431.     def __init__(self, name: str, resources: dict):
432.         """Constructor."""
433.         self.name = name
434.         self.resources = resources
435.         self.buildings = [Building("Main building", {"Wood": 200, "Clay": 200, "Iron": 200, "Wheat": 200})]
436.
437.     def can_build(self, resources_needed: dict):
438.         """True if can build building, else False."""
439.         if self.resources["Wood"] - resources_needed["Wood"] >= 0 and self.resources["Clay"] - \
440.                 resources_needed["Clay"] >= 0 and self.resources["Iron"] - \
441.                 resources_needed["Iron"] >= 0 and self.resources["Wheat"] - resources_needed["Wheat"] >= 0:
442.             return True
443.         return False
444.
445.     def build_building(self, resources_needed: dict, name: str) -> bool:
446.         """
447.         Build building.
448.
449.         You can build a building if there is room for a new building in the village and you have enough resources.
450.         There can't be multiple buildings with the same name and name can't be empty.
451.
452.         If you can build the building, build it and add it the buildings list.
453.
454.         Return True if building was successful, else False.
455.
456.         :param resources_needed: Resources needed for building the building.
457.         :param name: Name of the building to be built.
458.         :return: True if building was successful, else False.
459.         """
460.         if len(self.buildings) <= 20 and self.can_build(resources_needed):
461.             self.buildings.append(Building(name, resources_needed))
462.             self.resources["Wood"] -= resources_needed["Wood"]
463.             self.resources["Clay"] -= resources_needed["Clay"]
464.             self.resources["Iron"] -= resources_needed["Iron"]
465.             self.resources["Wheat"] -= resources_needed["Wheat"]
466.             return True
467.         return False
468.
469.     def downgrade_building(self, building_name: str) -> bool:
470.         """
472.
473.         Building can be downgraded if it's in the village. If the building's level is 1 and it is being downgraded,
474.         demolish it (remove completely from village).
475.         If it's the Main Building, its level can't be lower than 1.
476.
477.         Return True if downgrading was successful, else False.
478.
479.         :param building_name: Name of the building to be downgraded.
480.         :return: True if downgrading was successful, else False.
481.         """
482.         if self.get_building_by_name(building_name):
483.             building = self.get_building_by_name(building_name)
484.             if building_name.lower() != "main building" and building.level == 1:
485.                 self.buildings.remove(building)
486.             elif building_name.lower() == "main building" and building.level == 1:
487.                 return False
488.             else:
490.         return False
491.
493.         """Returns True if can upgrade building, else False."""
494.         if self.resources["Wood"] - ((10 + (building.level + 1) * 4) % building.resources["Wood"]) >= 0 and \
495.                 self.resources["Clay"] - ((10 + (building.level + 1) * 4) % building.resources["Clay"]) >= 0 and \
496.                 self.resources["Iron"] - ((10 + (building.level + 1) * 4) % building.resources["Iron"]) >= 0 and \
497.                 self.resources["Wheat"] - ((10 + (building.level + 1) * 4) % building.resources["Wheat"]) >= 0:
498.             return True
499.         return False
500.
501.     def upgrade_building(self, building_name: str) -> bool:
502.         """
504.
505.         Building can be upgraded if its level is not equal to them Main Building's level less than 20
506.         and there is enough resources in the village for the upgrade.
507.
508.         Return True if upgrading was successful, else False.
509.
510.         :param building_name: Name of the building to be upgraded.
511.         # :param resources_needed: Resources needed for the upgrade.
512.         :return: True if upgrading was successful, else False.
513.         """
514.         # (10 + level * 4)% ehitise algsest maksumusest
515.         if self.get_building_by_name(building_name):
516.             building = self.get_building_by_name(building_name)
517.             main_building = self.get_building_by_name("Main building")
518.             if self.can_upgrade(building) and building.level <= 19 and \
519.                     (building.level + 1 > main_building.level or building == main_building):
520.                 self.resources["Wood"] -= (10 + (building.level + 1) * 4) % building.resources["Wood"]
521.                 self.resources["Clay"] -= (10 + (building.level + 1) * 4) % building.resources["Clay"]
522.                 self.resources["Iron"] -= (10 + (building.level + 1) * 4) % building.resources["Iron"]
523.                 self.resources["Wheat"] -= (10 + (building.level + 1) * 4) % building.resources["Wheat"]
525.         return False
526.
527.     def get_building_by_name(self, name: str) -> Building:
528.         """Return Building object corresponding to the given name. If no such building, return None."""
529.         b_names = [b.name.lower() for b in self.buildings]
530.         if name.lower() in b_names:
531.             for b in self.buildings:
532.                 if b.name.lower() == name.lower():
533.                     return b
534.         return None
535.
536.     def get_resources(self) -> dict:  # ?
537.         """Return the dict of resources."""
538.         return self.resources
539.
541.         """Add resources to the resource dict."""
546.
547.     def get_buildings(self) -> list:
548.         """Return buildings."""
549.         return self.buildings
550.
551.     def __repr__(self) -> str:
552.         """Village representation."""
553.         return f"Village: {self.name}, Buildings: {self.buildings}"
554.
555.
556. def group_the_minions(group_sizes: List[int]) -> List[List[int]]:
557.     """
558.     You have to split minions into different groups.
559.
560.     #10
561.
562.     Each minion belongs to one certain group.
563.     You are given an array of numbers, which represents the size of the group in which the Minion belongs to.
564.     Put the minions into the right sized group. The order of groups (lists inside lists) does not matter.
565.
566.     Example:
567.     group_the_minions([3,3,3,3,3,1,3]) -> [,[0,1,2],[3,4,6]]
568.     and this would also be correct as order does not matter -> [[0,1,2],[3,4,6], ]
569.
570.     group_the_minions([2, 2]) -> [[0, 1]].
571.     """
572.     final_list = []
573.     for i in range(len(group_sizes)):
574.         if not final_list:
575.             final_list.append([i])
576.         else:
577.             for f in final_list:
578.                 if len(f) < group_sizes[i]:
579.                     f.append(i)
580.             if help_func(final_list, i):
581.                 final_list.append([i])
582.     return final_list
583.
584.
585. def help_func(listy, i):
586.     """Help func."""
587.     for l in listy:
588.         if i in l:
589.             return False
590.     return True
591.
592.
593. if __name__ == "__main__":
594.     # print(sum_nums(1, 2))  # -> [3, '12']
595.     # print(sum_nums(12, 34))  # -> [46, '1234']
596.     # print(sum_nums(33, 44))  # -> [77, '3344']
597.     # print(sum_nums(0, 0))  # -> [0, '00']
598.     # print(numbers_in_list(3, 5, [5, 6, 3, 1]))  # -> 8
599.     # print(numbers_in_list(0, 2, [3, 2, 9]))  # -> 2
600.     # print(numbers_in_list(0, 2, [3, 0, 9]))  # -> -2
601.     # print(numbers_in_list(3, 6, [5, 9, 8]))  # -> 18
602.     # print(numbers_in_list(9, 9, [0, 6, 32]))  # -> 0
603.     # print(multiply_after_digit('a5b4c'))  # -> 'abbbbbcccc'
604.     # print(multiply_after_digit('2 0nhe2lo world3!'))  # -> '  hello world!!!'
605.     # print(multiply_after_digit('thi10s end3s wit3h 31'))  # -> 'thissssssssss endsss withhh '(to get 100 %)
606.     # print(mastermind_guess([1, 2, 3], [1, 2, 3]))  # = > [2, 2, 2]
607.     # print(mastermind_guess([1, 2, 3], [3, 1, 2]))  # = > [1, 1, 1]
608.     # print(mastermind_guess([1, 2, 3], [3, 3, 3]))  # = > [1, 1, 2]
609.     # print(mastermind_guess([1, 2], [7, 3]))  # = > [0, 0]
610.     # print(reformat_money({10: 'A', 20: 'B', 30: 'a', 40: 'A', 50: 'James'}))  # => {'A': 50, 'B': 20, 'a': 30,
611.     # 'James': 100}
612.     # print(collatz_conjecture(12))  # -> 9, 16(sequence is [12, 6, 3, 10, 5, 16, 8, 4, 2, 1], steps - 9, biggestterm -
613.     # # 16)
614.     # print(collatz_conjecture(1))  # -> 0, 1(sequence is , steps - 0, biggestterm - 1)
615.     # print(collatz_conjecture(27))  # -> 111, 9232
616.     # print(collatz_conjecture(670617279))  # -> 949,
617.     # 966616035460(closetotheborderofRecursionError, butshould stillwork)
618.     # print(collatz_conjecture(0))  # -> None
619.     print(plot_the_tangerines([1, 0, 2, 3, 4, 5, 4, 3, 2, 10, 0, 3, 2, 1]))  # = >
620.     #  +--------------+
621.     # 5|     #        |
622.     # 4|    ###       |
623.     # 3|   #####   #  |
624.     # 2|  #######  ## |
625.     # 1|# ######## ###|
626.     # 0+--------------+
627.
628.     print(plot_the_tangerines())  # = >
629.     #  +-+
630.     # 1+ +
631.     # 0+-+
632.
633.     print(plot_the_tangerines([0, 0, 0, 0, 0, 0]))  # = >
634.     #  +------+
635.     # 1|      |
636.     # 0+------+
637.
638.     print(plot_the_tangerines([1, 4, 5, 3, 1]))  # = >
639.     #  +-----+
640.     # 5|  #  |
641.     # 4| ##  |
642.     # 3| ### |
643.     # 2| ### |
644.     # 1|#####|
645.     # 0+-----+
646.     print(group_the_minions([3, 3, 3, 3, 3, 1, 3]))  # -> [,[0,1,2],[3,4,6]]
RAW Paste Data
We use cookies for various purposes including analytics. By continuing to use Pastebin, you agree to our use of cookies as described in the Cookies Policy.
Top