diff --git a/Alice/humpty-dumpty.py b/Alice/humpty-dumpty.py new file mode 100644 index 0000000..16af3d7 --- /dev/null +++ b/Alice/humpty-dumpty.py @@ -0,0 +1,34 @@ +import math + + +def checkio(height, width): + return [round(calculate_volume(height, width), 2), round(calculate_area(height, width), 2)] + + +def calculate_area(height, width): + r_width = width / 2 + r_height = height / 2 + if r_width == r_height: + return 4 * math.pi * math.pow(r_width, 2) + return calculate_area_c_less_than_a(r_width, r_height) if height <= width else calculate_area_c_more_than_a(r_width, r_height) + + +def calculate_area_c_less_than_a(r_width, r_height): + e = math.sqrt(1 - (math.pow(r_height, 2) / math.pow(r_width, 2))) + return 2 * math.pi * math.pow(r_width, 2) + math.pi * (math.pow(r_height, 2) / e) * math.log((1 + e) / (1 - e)) + + +def calculate_area_c_more_than_a(r_width, r_height): + e = math.sqrt(1 - (math.pow(r_width, 2) / math.pow(r_height, 2))) + return 2 * math.pi * math.pow(r_width, 2) * (1+(r_height/(r_width*e))*math.asin(e)) + + +def calculate_volume(height, width): + return (4 * math.pi / 3) * math.pow(width / 2, 2) * (height / 2) + + +# These "asserts" using only for self-checking and not necessary for auto-testing +if __name__ == '__main__': + assert checkio(4, 2) == [8.38, 21.48], "Prolate spheroid" + assert checkio(2, 2) == [4.19, 12.57], "Sphere" + assert checkio(2, 4) == [16.76, 34.69], "Oblate spheroid" diff --git a/ElectronicStation/brackets.py b/ElectronicStation/brackets.py new file mode 100644 index 0000000..cd945ef --- /dev/null +++ b/ElectronicStation/brackets.py @@ -0,0 +1,28 @@ +def checkio(expression): + OPENING_BRACKETS = ["(", "[", "{"] + CLOSING_BRACKETS = [")", "]", "}"] + current_bracket = [] + for letter in expression: + if letter in CLOSING_BRACKETS: + if len(current_bracket) == 0: + return False + else: + last_bracket = current_bracket[-1:][0] + if OPENING_BRACKETS.index(last_bracket) == CLOSING_BRACKETS.index(letter): + current_bracket.pop() + else: + return False + if letter in OPENING_BRACKETS: + current_bracket.append(letter) + return len(current_bracket) == 0 + + +# These "asserts" using only for self-checking and not necessary for auto-testing +if __name__ == '__main__': + assert checkio("((5+3)*2+1)") == True, "Simple" + assert checkio("{[(3+1)+2]+}") == True, "Different types" + assert checkio("(3+{1-1)}") == False, ") is alone inside {}" + assert checkio("[1+1]+(2*2)-{3/3}") == True, "Different operators" + assert checkio("(({[(((1)-2)+3)-3]/3}-3)") == False, "One is redundant" + assert checkio("2+3") == True, "No brackets, no problem" + assert checkio("(((([[[{{{3}}}]]]]))))") == False, "No brackets, no problem" diff --git a/ElectronicStation/count-consecutive-summers.py b/ElectronicStation/count-consecutive-summers.py new file mode 100644 index 0000000..c92a4e2 --- /dev/null +++ b/ElectronicStation/count-consecutive-summers.py @@ -0,0 +1,26 @@ +def count_consecutive_summers(num): + index = num + number_of_consecutive_summers = 1 + while index > 0: + index -= 1 + sums = index + count = 1 + while sums <= num and index - count >= 0: + if sums == num: + number_of_consecutive_summers += 1 + break + sums += index - count + count += 1 + return number_of_consecutive_summers + + +if __name__ == '__main__': + print("Example:") + print(count_consecutive_summers(42)) + + # These "asserts" are used for self-checking and not for an auto-testing + assert count_consecutive_summers(42) == 4 + assert count_consecutive_summers(99) == 6 + assert count_consecutive_summers(1) == 1 + assert count_consecutive_summers(15) == 4 + print("Coding complete? Click 'Check' to earn cool rewards!") diff --git a/ElectronicStation/date-and-time-converter.py b/ElectronicStation/date-and-time-converter.py new file mode 100644 index 0000000..8bdfe6e --- /dev/null +++ b/ElectronicStation/date-and-time-converter.py @@ -0,0 +1,35 @@ +def date_time(time: str) -> str: + [date, time] = time.split(" ") + return "{} {}".format(parse_date(date), parse_time(time)) + + +def parse_date(date: str) -> str: + MONTHS = [ + "", "January", "February", "March", "April", + "May", "June", "July", "August", "September", + "October", "November", "December" + ] + [day, month, year] = date.split(".") + day = int(day) + return "{} {} {} year".format(int(day), MONTHS[int(month)], year) + + +def parse_time(time: str) -> str: + [hours, minutes] = time.split(":") + return "{} hour{} {} minute{}".format( + int(hours), + "s" if int(hours) != 1 else "", + int(minutes), + "s" if int(minutes) != 1 else "" + ) + + +if __name__ == '__main__': + print("Example:") + print(date_time('01.01.2000 00:00')) + + # These "asserts" using only for self-checking and not necessary for auto-testing + assert date_time("01.01.2000 00:00") == "1 January 2000 year 0 hours 0 minutes", "Millenium" + assert date_time("09.05.1945 06:30") == "9 May 1945 year 6 hours 30 minutes", "Victory" + assert date_time("20.11.1990 03:55") == "20 November 1990 year 3 hours 55 minutes", "Somebody was born" + print("Coding complete? Click 'Check' to earn cool rewards!") diff --git a/ElectronicStation/largest-histogram.py b/ElectronicStation/largest-histogram.py new file mode 100644 index 0000000..d122fa1 --- /dev/null +++ b/ElectronicStation/largest-histogram.py @@ -0,0 +1,33 @@ +def largest_histogram(histogram): + stack = list() + + max_area = 0 + + index = 0 + while index < len(histogram): + if (not stack) or (histogram[stack[-1]] <= histogram[index]): + stack.append(index) + index += 1 + else: + top_of_stack = stack.pop() + area = (histogram[top_of_stack] * + ((index - stack[-1] - 1) + if stack else index)) + max_area = max(max_area, area) + while stack: + top_of_stack = stack.pop() + area = (histogram[top_of_stack] * + ((index - stack[-1] - 1) + if stack else index)) + max_area = max(max_area, area) + return max_area + + +if __name__ == "__main__": + # These "asserts" using only for self-checking and not necessary for auto-testing + assert largest_histogram([5]) == 5, "one is always the biggest" + assert largest_histogram([5, 3]) == 6, "two are smallest X 2" + assert largest_histogram([1, 1, 4, 1]) == 4, "vertical" + assert largest_histogram([1, 1, 3, 1]) == 4, "horizontal" + assert largest_histogram([2, 1, 4, 5, 1, 3, 3]) == 8, "complex" + print("Done! Go check it!") diff --git a/ElectronicStation/multicolored-lamp.py b/ElectronicStation/multicolored-lamp.py new file mode 100644 index 0000000..6006c0a --- /dev/null +++ b/ElectronicStation/multicolored-lamp.py @@ -0,0 +1,43 @@ +import abc + + +class State(object, metaclass=abc.ABCMeta): + def __init__(self): + self.color_index = 0 + + @abc.abstractmethod + def light(self): + COLORS = ["Green", "Red", "Blue", "Yellow"] + state_color = COLORS[self.color_index] + self.color_index += 1 + if self.color_index == len(COLORS): + self.color_index = 0 + return state_color + + +class Lamp(State): + def __init__(self): + super().__init__() + self.color = None + + def light(self): + self.color = super().light() + return self.color + + +if __name__ == '__main__': + # These "asserts" using only for self-checking and not necessary for auto-testing + + lamp_1 = Lamp() + lamp_2 = Lamp() + + lamp_1.light() # Green + lamp_1.light() # Red + lamp_2.light() # Green + + assert lamp_1.light() == "Blue" + assert lamp_1.light() == "Yellow" + assert lamp_1.light() == "Green" + assert lamp_2.light() == "Red" + assert lamp_2.light() == "Blue" + print("Coding complete? Let's try tests!") diff --git a/ElectronicStation/restricted-sum.py b/ElectronicStation/restricted-sum.py new file mode 100644 index 0000000..12a6265 --- /dev/null +++ b/ElectronicStation/restricted-sum.py @@ -0,0 +1,36 @@ +def checkio(data): + result = 0 + data_length = len(data) + if data_length > 0: + result += data[0] + if data_length > 1: + result += data[1] + if data_length > 2: + result += data[2] + if data_length > 3: + result += data[3] + if data_length > 4: + result += data[4] + if data_length > 5: + result += data[5] + if data_length > 6: + result += data[6] + if data_length > 7: + result += data[7] + if data_length > 8: + result += data[8] + if data_length > 9: + result += data[9] + if data_length > 10: + result += data[10] + if data_length > 11: + result += data[11] + if data_length > 12: + result += data[12] + if data_length > 13: + result += data[13] + return result + + +assert checkio([43, -10, 68, 84, 91, 71, -10, -80, 38]) == 295 +assert checkio([1, 37, -64, 57, -78, 57, 64, -38, -91, 61, 53, -89, 41]) == 295 diff --git a/ElectronicStation/reverse-roman-numerals.py b/ElectronicStation/reverse-roman-numerals.py new file mode 100644 index 0000000..2ebbbda --- /dev/null +++ b/ElectronicStation/reverse-roman-numerals.py @@ -0,0 +1,71 @@ +def reverse_roman(roman_string): + mille = ['', 'M', 'MM', 'MMM'] + centaine = ['', 'C', 'CC', 'CCC', 'CD', 'D', 'DC', 'DCC', 'DCCC', 'CM'] + dixaine = ['', 'X', 'XX', 'XXX', 'XL', 'L', 'LX', 'LXX', 'LXXX', 'XC'] + unite = ['', 'I', 'II', 'III', 'IV', 'V', 'VI', 'VII', 'VIII', 'IX'] + number = 0 + roman_string_length = len(roman_string) + index = 0 + while True: + letter = roman_string[index] + current_number = letter + is_multiple = False + if current_number in mille: + while current_number in mille and index < roman_string_length - 1: + index += 1 + current_number += roman_string[index] + if current_number not in mille: + is_multiple = True + current_number = current_number[0:-1] + number += (mille.index(current_number) * 1000) + elif current_number in centaine: + while current_number in centaine and index < roman_string_length - 1: + index += 1 + current_number += roman_string[index] + if current_number not in centaine: + is_multiple = True + current_number = current_number[0:-1] + number += 100 * (centaine.index(current_number)) + elif current_number in dixaine: + while current_number in dixaine and index < roman_string_length - 1: + index += 1 + current_number += roman_string[index] + if current_number not in dixaine: + is_multiple = True + current_number = current_number[0:-1] + number += 10 * (dixaine.index(current_number)) + elif current_number in unite: + while current_number in unite and index < roman_string_length - 1: + index += 1 + current_number += roman_string[index] + if current_number not in unite: + is_multiple = True + current_number = current_number[0:-1] + number += unite.index(current_number) + + if index == roman_string_length - 1: + if is_multiple: + letter = roman_string[index] + if letter in mille: + number += (mille.index(letter)) * 1000 + elif letter in centaine: + number += 100 * (centaine.index(letter)) + elif letter in dixaine: + number += 10 * (dixaine.index(letter)) + elif letter in unite: + number += unite.index(letter) + break + + return number + + +if __name__ == '__main__': + # These "asserts" using only for self-checking and not necessary for auto-testing + assert reverse_roman('VI') == 6, '6' + assert reverse_roman('LXXVI') == 76, '76' + assert reverse_roman('CDXCIX') == 499, '499' + assert reverse_roman('MMMDCCCLXXXVIII') == 3888, '3888' + assert reverse_roman("I") == 1, '1' + assert reverse_roman("X") == 10, '10' + assert reverse_roman("MMMDCCCX") == 3810, '3810' + print('Great! It is time to Check your code!') diff --git a/ElectronicStation/time-converter-12h-to-24h.py b/ElectronicStation/time-converter-12h-to-24h.py new file mode 100644 index 0000000..47862cb --- /dev/null +++ b/ElectronicStation/time-converter-12h-to-24h.py @@ -0,0 +1,26 @@ +def time_converter(time): + [time, apm] = time.split(" ") + time_int = int(time.replace(':', '')) + if apm == "a.m.": + if time_int < 1200: + return time.rjust(5, "0") + else: + [hours, minutes] = time.split(":") + return "00:{}".format(minutes) + else: + if time_int < 1200: + [hours, minutes] = time.split(":") + return "{}:{}".format(int(hours) + 12, minutes) + else: + return time + + +if __name__ == '__main__': + print("Example:") + print(time_converter('12:30 p.m.')) + + # These "asserts" using only for self-checking and not necessary for auto-testing + assert time_converter('12:30 p.m.') == '12:30' + assert time_converter('9:00 a.m.') == '09:00' + assert time_converter('11:15 p.m.') == '23:15' + print("Coding complete? Click 'Check' to earn cool rewards!") diff --git a/IceBase/count-inversions.py b/IceBase/count-inversions.py new file mode 100644 index 0000000..e02b33b --- /dev/null +++ b/IceBase/count-inversions.py @@ -0,0 +1,25 @@ +def count_inversion(sequence): + """ + Count inversions in a sequence of numbers + """ + sequence = list(sequence) + ordered_sequence = sorted(sequence) + inversions = 0 + for index, number in enumerate(ordered_sequence): + if sequence.index(number) == index: + continue + inversions += sequence.index(number) - index + sequence.insert(index, sequence.pop(sequence.index(number))) + return inversions + + +if __name__ == '__main__': + print("Example:") + print(count_inversion([1, 2, 5, 3, 4, 7, 6])) + + # These "asserts" using only for self-checking and not necessary for auto-testing + assert count_inversion((1, 2, 5, 3, 4, 7, 6)) == 3, "Example" + assert count_inversion((0, 1, 2, 3)) == 0, "Sorted" + assert count_inversion((5, 3, 2, 1, 0)) == 10, "Reversed" + assert count_inversion((99, -99)) == 1, "Two numbers" + print("Coding complete? Click 'Check' to review your tests and earn cool rewards!") diff --git a/IceBase/cut-sentence.py b/IceBase/cut-sentence.py new file mode 100644 index 0000000..1e44f26 --- /dev/null +++ b/IceBase/cut-sentence.py @@ -0,0 +1,20 @@ +def cut_sentence(line, length): + """ + Cut a given sentence, so it becomes shorter than or equal to a given length. + """ + if length >= len(line): + return line + if line[length] == " ": + return line[:length]+"..." + line = line[:length].split(" ") + line.pop() + return " ".join(line)+"..." + + +if __name__ == '__main__': + # These "asserts" using only for self-checking and not necessary for auto-testing + assert cut_sentence("Hi my name is Alex", 4) == "Hi...", "First" + assert cut_sentence("Hi my name is Alex", 8) == "Hi my...", "Second" + assert cut_sentence("Hi my name is Alex", 18) == "Hi my name is Alex", "Third" + assert cut_sentence("Hi my name is Alex", 20) == "Hi my name is Alex", "Fourth" + print('Done! Do you like it? Go Check it!') diff --git a/IceBase/short-string-conversion.py b/IceBase/short-string-conversion.py new file mode 100644 index 0000000..600bc7b --- /dev/null +++ b/IceBase/short-string-conversion.py @@ -0,0 +1,38 @@ +def steps_to_convert(line1, line2): + len_line1 = len(line1) + len_line2 = len(line2) + if line1 == "" or line2 == "": + return len_line1 if len_line1 != 0 else len_line2 + similarities = has_similar(line1, line2) + if len(similarities) > 0: + return abs(max(len_line1, len_line2) - len(similarities)) + else: + + if len_line1 < len_line2: + if line1 in line2: + return len_line2 - len_line1 + else: + if line2 in line1: + return len_line1 - len_line2 + return 0 + + +def has_similar(line1, line2): + similarities = [] + for index, letter in enumerate(line1): + if letter == line2[index]: + similarities.append(index) + return similarities + + +if __name__ == "__main__": + # These "asserts" using only for self-checking and not necessary for auto-testing + assert steps_to_convert('line1', 'line1') == 0, "eq" + assert steps_to_convert('line1', 'line2') == 1, "2" + assert steps_to_convert('line', 'line2') == 1, "none to 2" + assert steps_to_convert('ine', 'line2') == 2, "need two more" + assert steps_to_convert('line1', '1enil') == 4, "everything is opposite" + assert steps_to_convert('', '') == 0, "two empty" + assert steps_to_convert('l', '') == 1, "one side" + assert steps_to_convert('', 'l') == 1, "another side" + print("You are good to go!") diff --git a/ScientificExpedition/double-substring.py b/ScientificExpedition/double-substring.py new file mode 100644 index 0000000..907063a --- /dev/null +++ b/ScientificExpedition/double-substring.py @@ -0,0 +1,21 @@ +def double_substring(line): + """ + length of the longest substring that non-overlapping repeats more than once. + """ + result = [] + for i in range(len(line) - 1): + for j in range(i + 1, len(line) + 1): + if line[i:j] in line[j:]: + result.append(len(line[i:j])) + + if len(result) > 0: + return max(result) + else: + return 0 + + +if __name__ == '__main__': + # These "asserts" using only for self-checking and not necessary for auto-testing + assert double_substring('aaaa') == 2, "First" + assert double_substring('abc') == 0, "Second" + assert double_substring('aghtfghkofgh') == 3, "Third"