Private & Protected в ООП

Програмиране с Python

Курс във Факултета по Математика и Информатика към СУ

Решение на Телефонна любов от Харут Партамиан

Обратно към всички решения

Към профила на Харут Партамиан

Резултати

  • 9 точки от тестове
  • 0 бонус точки
  • 9 точки общо
  • 34 успешни тест(а)
  • 3 неуспешни тест(а)

Код

from itertools import groupby
def working_round(angle):
remainder = angle % 30
if remainder <= 15:
new_angle = angle - remainder
else:
new_angle = angle - remainder + 30
return int((new_angle % 360) / 30)
def nums_to_text(list_of_numbers: list) -> str:
number_to_character_dict = {
0: ' ',
2: ('A', 'B', 'C'),
3: ('D', 'E', 'F'),
4: ('G', 'H', 'I'),
5: ('J', 'K', 'L'),
6: ('M', 'N', 'O'),
7: ('P', 'Q', 'R', 'S'),
8: ('T', 'U', 'V'),
9: ('W', 'X', 'Y', 'Z'),
}
occurrences_list = map(lambda x: (x[0], len(x)), [list(j) for i, j in groupby(list_of_numbers)])
output_string = ""
for pair in occurrences_list:
number, occurrences = pair
if number not in number_to_character_dict:
continue
normalized_occurrences = occurrences % len(number_to_character_dict[number])
output_string += number_to_character_dict[number][normalized_occurrences - 1]
return output_string
def text_to_nums(text: str) -> list:
character_to_number_dict = {
'A': [2], 'B': [2, 2], 'C': [2, 2, 2],
'D': [3], 'E': [3, 3], 'F': [3, 3, 3],
'G': [4], 'H': [4, 4], 'I': [4, 4, 4],
'J': [5], 'K': [5, 5], 'L': [5, 5, 5],
'M': [6], 'N': [6, 6], 'O': [6, 6, 6],
'P': [7], 'Q': [7, 7], 'R': [7, 7, 7], 'S': [7, 7, 7, 7],
'T': [8], 'U': [8, 8], 'V': [8, 8, 8],
'W': [9], 'X': [9, 9], 'Y': [9, 9, 9], 'Z': [9, 9, 9, 9],
' ': [0]
}
output_list = []
previous_number = -1
for case_insensitive_char in text.upper():
current_number = character_to_number_dict[case_insensitive_char][0]
if current_number == previous_number:
output_list.append(-1)
output_list.extend(character_to_number_dict[case_insensitive_char])
previous_number = character_to_number_dict[case_insensitive_char][0]
return output_list
def nums_to_angle(nums: list) -> int:
return sum(nums) * 30 % 360
def angles_to_nums(angles: list) -> list:
return list(
filter(lambda num: num in range(1, 10), map(lambda angle: working_round(angle), angles)))
def is_phone_tastic(word: str) -> bool:
return nums_to_angle(list(filter(lambda num: num in range(0, 10), text_to_nums(word)))) % len(
word) == 0 if word else False

Лог от изпълнението

.......F.....F....F..................
======================================================================
FAIL: test_random_mixed_case (test.TestAnglesToNums)
Test with a random mixed input.
----------------------------------------------------------------------
Traceback (most recent call last):
  File "/storage/deedee/data/rails/pyfmi-2022/releases/20221020151654/lib/language/python/runner.py", line 67, in thread
    raise result
AssertionError: Lists differ: [5, 1, 2, 4, 9, 1, 8, 9] != [5, 1, 2, 4, 9, 1, 8, 0, 9]

First differing element 7:
9
0

Second list contains 1 additional elements.
First extra element 8:
9

- [5, 1, 2, 4, 9, 1, 8, 9]
+ [5, 1, 2, 4, 9, 1, 8, 0, 9]
?                       +++


======================================================================
FAIL: test_correct_mapping (test.TestNumsToAngles)
Test correct mapping for all numbers.
----------------------------------------------------------------------
Traceback (most recent call last):
  File "/storage/deedee/data/rails/pyfmi-2022/releases/20221020151654/lib/language/python/runner.py", line 67, in thread
    raise result
AssertionError: 0 != 300

======================================================================
FAIL: test_random_mixed_case (test.TestNumsToAngles)
Test with a random mixed input.
----------------------------------------------------------------------
Traceback (most recent call last):
  File "/storage/deedee/data/rails/pyfmi-2022/releases/20221020151654/lib/language/python/runner.py", line 67, in thread
    raise result
AssertionError: 90 != 150

----------------------------------------------------------------------
Ran 37 tests in 0.344s

FAILED (failures=3)

История (5 версии и 5 коментара)

Харут обнови решението на 02.11.2022 11:27 (преди над 2 години)

+from itertools import groupby
+
+N = [1, 2, 2, 3, 3, 3, 4, 4, 4, 4, 5, 5, 5, 5, 5, 1, 1, 1, 1]
+
+
+def nums_to_text(list_of_numbers: list) -> str:
+ number_to_character_dict = {
+ 0: ' ',
+ 2: ('A', 'B', 'C'),
+ 3: ('D', 'E', 'F'),
+ 4: ('G', 'H', 'I'),
+ 5: ('J', 'K', 'L'),
+ 6: ('M', 'N', 'O'),
+ 7: ('P', 'Q', 'R', 'S'),
+ 8: ('T', 'U', 'V'),
+ 9: ('W', 'X', 'Y', 'Z'),
+ }
+
+ if list_of_numbers is None:
+ raise ValueError("Please enter non_empty list")
+
+ occurrences_list = list(map(lambda x: (x[0], len(x)), [list(j) for i, j in groupby(list_of_numbers)]))
+
+ output_string = str()
+ for pair in occurrences_list:
+ number, occurrences = pair
+ if number not in number_to_character_dict:
+ continue
+ normalized_occurrences = occurrences % len(number_to_character_dict[number])
+ output_string += number_to_character_dict[number][normalized_occurrences - 1]
+
+ return output_string
+
+
+def text_to_nums(text: str) -> list:
+ character_to_number_dict = {
+ 'A': [2], 'B': [2, 2], 'C': [2, 2, 2],
+ 'D': [3], 'E': [3, 3], 'F': [3, 3, 3],
+ 'G': [4], 'H': [4, 4], 'I': [4, 4, 4],
+ 'J': [5], 'K': [5, 5], 'L': [5, 5, 5],
+ 'M': [6], 'N': [6, 6], 'O': [6, 6, 6],
+ 'P': [7], 'Q': [7, 7], 'R': [7, 7, 7], 'S': [7, 7, 7, 7],
+ 'T': [8], 'U': [8, 8], 'V': [8, 8, 8],
+ 'W': [9], 'X': [9, 9], 'Y': [9, 9, 9], 'Z': [9, 9, 9, 9],
+ ' ': [0]
+ }
+
+ output_list = list()
+
+ previous_number = -1
+ for char in text:
+ case_insensitive_char = char.upper()
+ current_number = character_to_number_dict[case_insensitive_char][0]
+ if current_number == previous_number:
+ output_list.append(-1)
+ output_list.extend(character_to_number_dict[case_insensitive_char])
+ previous_number = character_to_number_dict[case_insensitive_char][0]
+
+ return output_list
+
+
+def nums_to_angle(nums: list) -> int:
+ return sum(nums) * 30 % 360
+
+
+def angles_to_nums(angles: list) -> list:
+ return list(filter(lambda num: num in range(1, 11), map(lambda angle: round((angle % 360) / 30), angles)))
+
+
+def is_phone_tastic(word: str) -> bool:
+ return nums_to_angle(list(filter(lambda num: num in range(0, 9), text_to_nums(word)))) % len(
+ word.replace(" ", "")) == 0

Харут обнови решението на 02.11.2022 13:05 (преди над 2 години)

from itertools import groupby
N = [1, 2, 2, 3, 3, 3, 4, 4, 4, 4, 5, 5, 5, 5, 5, 1, 1, 1, 1]
def nums_to_text(list_of_numbers: list) -> str:
number_to_character_dict = {
0: ' ',
2: ('A', 'B', 'C'),
3: ('D', 'E', 'F'),
4: ('G', 'H', 'I'),
5: ('J', 'K', 'L'),
6: ('M', 'N', 'O'),
7: ('P', 'Q', 'R', 'S'),
8: ('T', 'U', 'V'),
9: ('W', 'X', 'Y', 'Z'),
}
if list_of_numbers is None:
raise ValueError("Please enter non_empty list")
occurrences_list = list(map(lambda x: (x[0], len(x)), [list(j) for i, j in groupby(list_of_numbers)]))
output_string = str()
for pair in occurrences_list:
number, occurrences = pair
if number not in number_to_character_dict:
continue
normalized_occurrences = occurrences % len(number_to_character_dict[number])
output_string += number_to_character_dict[number][normalized_occurrences - 1]
return output_string
def text_to_nums(text: str) -> list:
character_to_number_dict = {
'A': [2], 'B': [2, 2], 'C': [2, 2, 2],
'D': [3], 'E': [3, 3], 'F': [3, 3, 3],
'G': [4], 'H': [4, 4], 'I': [4, 4, 4],
'J': [5], 'K': [5, 5], 'L': [5, 5, 5],
'M': [6], 'N': [6, 6], 'O': [6, 6, 6],
'P': [7], 'Q': [7, 7], 'R': [7, 7, 7], 'S': [7, 7, 7, 7],
'T': [8], 'U': [8, 8], 'V': [8, 8, 8],
'W': [9], 'X': [9, 9], 'Y': [9, 9, 9], 'Z': [9, 9, 9, 9],
' ': [0]
}
output_list = list()
previous_number = -1
for char in text:
case_insensitive_char = char.upper()
current_number = character_to_number_dict[case_insensitive_char][0]
if current_number == previous_number:
output_list.append(-1)
output_list.extend(character_to_number_dict[case_insensitive_char])
previous_number = character_to_number_dict[case_insensitive_char][0]
return output_list
def nums_to_angle(nums: list) -> int:
return sum(nums) * 30 % 360
def angles_to_nums(angles: list) -> list:
- return list(filter(lambda num: num in range(1, 11), map(lambda angle: round((angle % 360) / 30), angles)))
+ return list(filter(lambda num: num in range(1, 11), map(lambda angle: round(((angle % 360) / 30) - 0.9), angles)))
def is_phone_tastic(word: str) -> bool:
return nums_to_angle(list(filter(lambda num: num in range(0, 9), text_to_nums(word)))) % len(
word.replace(" ", "")) == 0

Харут обнови решението на 02.11.2022 18:26 (преди над 2 години)

from itertools import groupby
-N = [1, 2, 2, 3, 3, 3, 4, 4, 4, 4, 5, 5, 5, 5, 5, 1, 1, 1, 1]
-
def nums_to_text(list_of_numbers: list) -> str:
number_to_character_dict = {
0: ' ',
2: ('A', 'B', 'C'),
3: ('D', 'E', 'F'),
4: ('G', 'H', 'I'),
5: ('J', 'K', 'L'),
6: ('M', 'N', 'O'),
7: ('P', 'Q', 'R', 'S'),
8: ('T', 'U', 'V'),
9: ('W', 'X', 'Y', 'Z'),
}
if list_of_numbers is None:
raise ValueError("Please enter non_empty list")
occurrences_list = list(map(lambda x: (x[0], len(x)), [list(j) for i, j in groupby(list_of_numbers)]))
output_string = str()
for pair in occurrences_list:
number, occurrences = pair
if number not in number_to_character_dict:
continue
normalized_occurrences = occurrences % len(number_to_character_dict[number])
output_string += number_to_character_dict[number][normalized_occurrences - 1]
return output_string
def text_to_nums(text: str) -> list:
character_to_number_dict = {
'A': [2], 'B': [2, 2], 'C': [2, 2, 2],
'D': [3], 'E': [3, 3], 'F': [3, 3, 3],
'G': [4], 'H': [4, 4], 'I': [4, 4, 4],
'J': [5], 'K': [5, 5], 'L': [5, 5, 5],
'M': [6], 'N': [6, 6], 'O': [6, 6, 6],
'P': [7], 'Q': [7, 7], 'R': [7, 7, 7], 'S': [7, 7, 7, 7],
'T': [8], 'U': [8, 8], 'V': [8, 8, 8],
'W': [9], 'X': [9, 9], 'Y': [9, 9, 9], 'Z': [9, 9, 9, 9],
' ': [0]
}
output_list = list()
previous_number = -1
for char in text:
case_insensitive_char = char.upper()
current_number = character_to_number_dict[case_insensitive_char][0]
if current_number == previous_number:
output_list.append(-1)
output_list.extend(character_to_number_dict[case_insensitive_char])
previous_number = character_to_number_dict[case_insensitive_char][0]
return output_list
def nums_to_angle(nums: list) -> int:
return sum(nums) * 30 % 360
def angles_to_nums(angles: list) -> list:
return list(filter(lambda num: num in range(1, 11), map(lambda angle: round(((angle % 360) / 30) - 0.9), angles)))
def is_phone_tastic(word: str) -> bool:
return nums_to_angle(list(filter(lambda num: num in range(0, 9), text_to_nums(word)))) % len(
word.replace(" ", "")) == 0

Харут обнови решението на 03.11.2022 10:25 (преди над 2 години)

from itertools import groupby
+def working_round(angle):
+ remainder = angle % 30
+ if remainder <= 15:
+ new_angle = angle - remainder
+ else:
+ new_angle = angle - remainder + 30
+
+ return int((new_angle % 360) / 30)
+
+
def nums_to_text(list_of_numbers: list) -> str:
number_to_character_dict = {
0: ' ',
2: ('A', 'B', 'C'),
3: ('D', 'E', 'F'),
4: ('G', 'H', 'I'),
5: ('J', 'K', 'L'),
6: ('M', 'N', 'O'),
7: ('P', 'Q', 'R', 'S'),
8: ('T', 'U', 'V'),
9: ('W', 'X', 'Y', 'Z'),
}
if list_of_numbers is None:
raise ValueError("Please enter non_empty list")
occurrences_list = list(map(lambda x: (x[0], len(x)), [list(j) for i, j in groupby(list_of_numbers)]))
output_string = str()
for pair in occurrences_list:
number, occurrences = pair
if number not in number_to_character_dict:
continue
normalized_occurrences = occurrences % len(number_to_character_dict[number])
output_string += number_to_character_dict[number][normalized_occurrences - 1]
return output_string
def text_to_nums(text: str) -> list:
character_to_number_dict = {
'A': [2], 'B': [2, 2], 'C': [2, 2, 2],
'D': [3], 'E': [3, 3], 'F': [3, 3, 3],
'G': [4], 'H': [4, 4], 'I': [4, 4, 4],
'J': [5], 'K': [5, 5], 'L': [5, 5, 5],
'M': [6], 'N': [6, 6], 'O': [6, 6, 6],
'P': [7], 'Q': [7, 7], 'R': [7, 7, 7], 'S': [7, 7, 7, 7],
'T': [8], 'U': [8, 8], 'V': [8, 8, 8],
'W': [9], 'X': [9, 9], 'Y': [9, 9, 9], 'Z': [9, 9, 9, 9],
' ': [0]
}
output_list = list()
previous_number = -1
for char in text:
case_insensitive_char = char.upper()
current_number = character_to_number_dict[case_insensitive_char][0]
if current_number == previous_number:
output_list.append(-1)
output_list.extend(character_to_number_dict[case_insensitive_char])
previous_number = character_to_number_dict[case_insensitive_char][0]
return output_list
def nums_to_angle(nums: list) -> int:
return sum(nums) * 30 % 360
def angles_to_nums(angles: list) -> list:
- return list(filter(lambda num: num in range(1, 11), map(lambda angle: round(((angle % 360) / 30) - 0.9), angles)))
+ return list(
+ filter(lambda num: num in range(1, 10), map(lambda angle: working_round(angle), angles)))
def is_phone_tastic(word: str) -> bool:
- return nums_to_angle(list(filter(lambda num: num in range(0, 9), text_to_nums(word)))) % len(
- word.replace(" ", "")) == 0
+ return nums_to_angle(list(filter(lambda num: num in range(0, 10), text_to_nums(word)))) % len(
+ word) == 0 if word else False

Харут обнови решението на 03.11.2022 14:55 (преди над 2 години)

from itertools import groupby
def working_round(angle):
remainder = angle % 30
if remainder <= 15:
new_angle = angle - remainder
else:
new_angle = angle - remainder + 30
return int((new_angle % 360) / 30)
def nums_to_text(list_of_numbers: list) -> str:
number_to_character_dict = {
0: ' ',
2: ('A', 'B', 'C'),
3: ('D', 'E', 'F'),
4: ('G', 'H', 'I'),
5: ('J', 'K', 'L'),
6: ('M', 'N', 'O'),
7: ('P', 'Q', 'R', 'S'),
8: ('T', 'U', 'V'),
9: ('W', 'X', 'Y', 'Z'),
}
- if list_of_numbers is None:
- raise ValueError("Please enter non_empty list")
+ occurrences_list = map(lambda x: (x[0], len(x)), [list(j) for i, j in groupby(list_of_numbers)])
- occurrences_list = list(map(lambda x: (x[0], len(x)), [list(j) for i, j in groupby(list_of_numbers)]))
-
- output_string = str()
+ output_string = ""
for pair in occurrences_list:
number, occurrences = pair
if number not in number_to_character_dict:
continue
normalized_occurrences = occurrences % len(number_to_character_dict[number])
output_string += number_to_character_dict[number][normalized_occurrences - 1]
return output_string
def text_to_nums(text: str) -> list:
character_to_number_dict = {
'A': [2], 'B': [2, 2], 'C': [2, 2, 2],
'D': [3], 'E': [3, 3], 'F': [3, 3, 3],
'G': [4], 'H': [4, 4], 'I': [4, 4, 4],
'J': [5], 'K': [5, 5], 'L': [5, 5, 5],
'M': [6], 'N': [6, 6], 'O': [6, 6, 6],
'P': [7], 'Q': [7, 7], 'R': [7, 7, 7], 'S': [7, 7, 7, 7],
'T': [8], 'U': [8, 8], 'V': [8, 8, 8],
'W': [9], 'X': [9, 9], 'Y': [9, 9, 9], 'Z': [9, 9, 9, 9],
' ': [0]
}
- output_list = list()
+ output_list = []
previous_number = -1
- for char in text:
- case_insensitive_char = char.upper()
+ for case_insensitive_char in text.upper():
current_number = character_to_number_dict[case_insensitive_char][0]
if current_number == previous_number:
output_list.append(-1)
output_list.extend(character_to_number_dict[case_insensitive_char])
previous_number = character_to_number_dict[case_insensitive_char][0]
return output_list
def nums_to_angle(nums: list) -> int:
return sum(nums) * 30 % 360
def angles_to_nums(angles: list) -> list:
return list(
filter(lambda num: num in range(1, 10), map(lambda angle: working_round(angle), angles)))
def is_phone_tastic(word: str) -> bool:
return nums_to_angle(list(filter(lambda num: num in range(0, 10), text_to_nums(word)))) % len(
- word) == 0 if word else False
+ word) == 0 if word else False