Private & Protected в ООП

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

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

Решение на Телефонна любов от Таня Сейкова

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

Към профила на Таня Сейкова

Резултати

  • 10 точки от тестове
  • 1 бонус точка
  • 11 точки общо
  • 36 успешни тест(а)
  • 1 неуспешни тест(а)

Код

num_to_text_mapping = {
0: [" "],
1: [""],
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"]
}
text_to_num_mapping = {
'A': (2, 1), # (digit, num of times)
'B': (2, 2),
'C': (2, 3),
'D': (3, 1),
'E': (3, 2),
'F': (3, 3),
'G': (4, 1),
'H': (4, 2),
'I': (4, 3),
'J': (5, 1),
'K': (5, 2),
'L': (5, 3),
'M': (6, 1),
'N': (6, 2),
'O': (6, 3),
'P': (7, 1),
'Q': (7, 2),
'R': (7, 3),
'S': (7, 4),
'T': (8, 1),
'U': (8, 2),
'V': (8, 3),
'W': (9, 1),
'X': (9, 2),
'Y': (9, 3),
'Z': (9, 4),
' ': (0, 1)
}
def nums_to_text(nums):
count = 1
split_nums = []
last_digit = nums[0]
if len(nums) == 1:
if last_digit == -1:
return ""
return num_to_text_mapping[last_digit][0]
for index, digit in enumerate(nums):
if index == 0:
continue
if last_digit != digit:
split_nums.append((last_digit, count))
count = 0
last_digit = digit
count += 1
if index == len(nums) - 1:
split_nums.append((digit, count))
result = ""
for digit, num_times in split_nums:
if digit == -1:
continue
key = num_to_text_mapping[digit]
num_letters = len(key)
result += key[int((num_times - 1) % num_letters)]
return result
def text_to_nums(text):
result = []
last_num = -2
upper_text = text.upper()
for letter in upper_text:
num = text_to_num_mapping[letter][0]
number_times = text_to_num_mapping[letter][1]
if last_num == num:
result.append(-1)
last_num = num
result.extend([num] * number_times)
return result
def nums_to_angle(nums):
sum_angles = 0
for digit in nums:
if digit == 0:
sum_angles += 30 * 10
else:
sum_angles += 30 * digit
result = sum_angles % 360
return result
def angles_to_nums(angles):
possible_angles = [0, 30, 60, 90, 120, 150, 180, 210, 240, 270, 300, 330]
result = []
for angle in angles:
angle = angle % 360
angle_normalized = min(possible_angles, key=lambda x: abs(x-angle))
if angle_normalized == 0 or angle_normalized == 330:
continue
if angle_normalized == 360:
result.append(0)
else:
result.append(int((angle_normalized / 30) % 10))
return result
def is_phone_tastic(word):
if len(word) == 0:
return False
to_numbers = text_to_nums(word)
to_angle = nums_to_angle(to_numbers)
return to_angle % len(word) == 0

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

......................E..............
======================================================================
ERROR: test_empty_input (test.TestNumsToText)
Test with empty 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
IndexError: list index out of range

----------------------------------------------------------------------
Ran 37 tests in 0.312s

FAILED (errors=1)

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

Таня обнови решението на 30.10.2022 15:16 (преди над 1 година)

+num_to_text_mapping = {
+ 0: [" "],
+ 1: [""],
+ 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"]
+}
+
+text_to_num_mapping = {
+ 'A': (2, 1), # (digit, num of times)
+ 'B': (2, 2),
+ 'C': (2, 3),
+ 'D': (3, 1),
+ 'E': (3, 2),
+ 'F': (3, 3),
+ 'G': (4, 1),
+ 'H': (4, 2),
+ 'I': (4, 3),
+ 'J': (5, 1),
+ 'K': (5, 2),
+ 'L': (5, 3),
+ 'M': (6, 1),
+ 'N': (6, 2),
+ 'O': (6, 3),
+ 'P': (7, 1),
+ 'Q': (7, 2),
+ 'R': (7, 3),
+ 'S': (7, 4),
+ 'T': (8, 1),
+ 'U': (8, 2),
+ 'V': (8, 3),
+ 'W': (9, 1),
+ 'X': (9, 2),
+ 'Y': (9, 3),
+ 'Z': (9, 4),
+ ' ': (0, 1)
+
+}
+
+
+def nums_to_text(nums):
+ count = 1
+ splitted_nums = []
+ last_digit = nums[0]
+ if len(nums) == 1:
+ return num_to_text_mapping[last_digit][0]
+
+ for index, digit in enumerate(nums):
+ if index == 0:
+ continue
+ if last_digit != digit:
+ splitted_nums.append((last_digit, count))
+ count = 0
+ last_digit = digit
+ count += 1
+ if index == len(nums) - 1:
+ splitted_nums.append((digit, count))
+
+ result = ""
+
+ for digit, num_times in splitted_nums:
+ key = num_to_text_mapping[digit]
+ num_letters = len(key)
+ result += key[int((num_times - 1) % num_letters)]
+
+ return result
+
+
+def text_to_nums(text):
+ result = []
+ last_num = -2
+ upper_text = text.upper()
+
+ for letter in upper_text:
+ num = text_to_num_mapping[letter][0]
+ number_times = text_to_num_mapping[letter][1]
+ if last_num == num:
+ result.append(-1)
+ last_num = num
+ result.extend([num] * number_times)
+
+ return result
+
+text_to_nums("PYTHON")
+
+def nums_to_angle(nums):
+ sum_angles = 0
+ for digit in nums:
+ if digit == 0:
+ sum_angles += 30 * 10
+ else:
+ sum_angles += 30 * digit
+
+ result = sum_angles % 360
+ return result
+
+def angles_to_nums(angles):
+ possible_angles = [0, 30, 60, 90, 120, 150, 180, 210, 240, 270, 300]
+ result = []
+
+ for angle in angles:
+ angle = angle % 360
+ if angle < 0:
+ angle = 360 + angle
+ angle_normalized = min(possible_angles, key=lambda x:abs(x-angle))
+ if angle_normalized == 0:
+ continue
+ result.append(int((angle_normalized / 30) % 10))
+
+ return result
+
+def is_phone_tastic(word):
+ len_ = len(word)
+ to_numbers = text_to_nums(word)
+ to_angle = nums_to_angle(to_numbers)
+
+ return to_angle % len_ == 0

Много ми хареса стилът на решението! Чисто, ясно, методично.

Обърни внимание на граничните стойности и по-специфичните изисквания. Имаш пропуски по изпълняване на някои изисквания.

Таня обнови решението на 01.11.2022 21:28 (преди над 1 година)

num_to_text_mapping = {
0: [" "],
1: [""],
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"]
}
text_to_num_mapping = {
'A': (2, 1), # (digit, num of times)
'B': (2, 2),
'C': (2, 3),
'D': (3, 1),
'E': (3, 2),
'F': (3, 3),
'G': (4, 1),
'H': (4, 2),
'I': (4, 3),
'J': (5, 1),
'K': (5, 2),
'L': (5, 3),
'M': (6, 1),
'N': (6, 2),
'O': (6, 3),
'P': (7, 1),
'Q': (7, 2),
'R': (7, 3),
'S': (7, 4),
'T': (8, 1),
'U': (8, 2),
'V': (8, 3),
'W': (9, 1),
'X': (9, 2),
'Y': (9, 3),
'Z': (9, 4),
' ': (0, 1)
}
def nums_to_text(nums):
count = 1
- splitted_nums = []
+ split_nums = []
last_digit = nums[0]
if len(nums) == 1:
+ if last_digit == -1:
+ return ""
return num_to_text_mapping[last_digit][0]
-
+
for index, digit in enumerate(nums):
if index == 0:
continue
+
if last_digit != digit:
- splitted_nums.append((last_digit, count))
+ split_nums.append((last_digit, count))
count = 0
last_digit = digit
count += 1
if index == len(nums) - 1:
- splitted_nums.append((digit, count))
+ split_nums.append((digit, count))
result = ""
- for digit, num_times in splitted_nums:
+ for digit, num_times in split_nums:
+ if digit == -1:
+ continue
key = num_to_text_mapping[digit]
num_letters = len(key)
result += key[int((num_times - 1) % num_letters)]
return result
def text_to_nums(text):
result = []
last_num = -2
upper_text = text.upper()
for letter in upper_text:
num = text_to_num_mapping[letter][0]
number_times = text_to_num_mapping[letter][1]
if last_num == num:
result.append(-1)
last_num = num
result.extend([num] * number_times)
return result
text_to_nums("PYTHON")
def nums_to_angle(nums):
sum_angles = 0
for digit in nums:
if digit == 0:
sum_angles += 30 * 10
else:
sum_angles += 30 * digit
result = sum_angles % 360
return result
def angles_to_nums(angles):
- possible_angles = [0, 30, 60, 90, 120, 150, 180, 210, 240, 270, 300]
+ possible_angles = [0, 30, 60, 90, 120, 150, 180, 210, 240, 270, 300, 330]
result = []
for angle in angles:
angle = angle % 360
- if angle < 0:
- angle = 360 + angle
- angle_normalized = min(possible_angles, key=lambda x:abs(x-angle))
- if angle_normalized == 0:
+ angle_normalized = min(possible_angles, key=lambda x: abs(x-angle))
+ if angle_normalized == 0 or angle_normalized == 330:
continue
- result.append(int((angle_normalized / 30) % 10))
+ if angle_normalized == 360:
+ result.append(0)
+ else:
+ result.append(int((angle_normalized / 30) % 10))
return result
def is_phone_tastic(word):
- len_ = len(word)
to_numbers = text_to_nums(word)
to_angle = nums_to_angle(to_numbers)
- return to_angle % len_ == 0
+ return to_angle % len(word) == 0

Таня обнови решението на 03.11.2022 14:25 (преди над 1 година)

num_to_text_mapping = {
0: [" "],
1: [""],
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"]
}
text_to_num_mapping = {
'A': (2, 1), # (digit, num of times)
'B': (2, 2),
'C': (2, 3),
'D': (3, 1),
'E': (3, 2),
'F': (3, 3),
'G': (4, 1),
'H': (4, 2),
'I': (4, 3),
'J': (5, 1),
'K': (5, 2),
'L': (5, 3),
'M': (6, 1),
'N': (6, 2),
'O': (6, 3),
'P': (7, 1),
'Q': (7, 2),
'R': (7, 3),
'S': (7, 4),
'T': (8, 1),
'U': (8, 2),
'V': (8, 3),
'W': (9, 1),
'X': (9, 2),
'Y': (9, 3),
'Z': (9, 4),
' ': (0, 1)
}
def nums_to_text(nums):
count = 1
split_nums = []
last_digit = nums[0]
if len(nums) == 1:
if last_digit == -1:
return ""
return num_to_text_mapping[last_digit][0]
for index, digit in enumerate(nums):
if index == 0:
continue
if last_digit != digit:
split_nums.append((last_digit, count))
count = 0
last_digit = digit
count += 1
if index == len(nums) - 1:
split_nums.append((digit, count))
result = ""
for digit, num_times in split_nums:
if digit == -1:
continue
key = num_to_text_mapping[digit]
num_letters = len(key)
result += key[int((num_times - 1) % num_letters)]
return result
def text_to_nums(text):
result = []
last_num = -2
upper_text = text.upper()
for letter in upper_text:
num = text_to_num_mapping[letter][0]
number_times = text_to_num_mapping[letter][1]
if last_num == num:
result.append(-1)
last_num = num
result.extend([num] * number_times)
return result
-text_to_nums("PYTHON")
def nums_to_angle(nums):
sum_angles = 0
for digit in nums:
if digit == 0:
sum_angles += 30 * 10
else:
sum_angles += 30 * digit
result = sum_angles % 360
return result
def angles_to_nums(angles):
possible_angles = [0, 30, 60, 90, 120, 150, 180, 210, 240, 270, 300, 330]
result = []
for angle in angles:
angle = angle % 360
angle_normalized = min(possible_angles, key=lambda x: abs(x-angle))
if angle_normalized == 0 or angle_normalized == 330:
continue
if angle_normalized == 360:
result.append(0)
else:
result.append(int((angle_normalized / 30) % 10))
return result
def is_phone_tastic(word):
to_numbers = text_to_nums(word)
to_angle = nums_to_angle(to_numbers)
return to_angle % len(word) == 0

Таня обнови решението на 03.11.2022 14:42 (преди над 1 година)

num_to_text_mapping = {
0: [" "],
1: [""],
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"]
}
text_to_num_mapping = {
'A': (2, 1), # (digit, num of times)
'B': (2, 2),
'C': (2, 3),
'D': (3, 1),
'E': (3, 2),
'F': (3, 3),
'G': (4, 1),
'H': (4, 2),
'I': (4, 3),
'J': (5, 1),
'K': (5, 2),
'L': (5, 3),
'M': (6, 1),
'N': (6, 2),
'O': (6, 3),
'P': (7, 1),
'Q': (7, 2),
'R': (7, 3),
'S': (7, 4),
'T': (8, 1),
'U': (8, 2),
'V': (8, 3),
'W': (9, 1),
'X': (9, 2),
'Y': (9, 3),
'Z': (9, 4),
' ': (0, 1)
}
def nums_to_text(nums):
count = 1
split_nums = []
last_digit = nums[0]
if len(nums) == 1:
if last_digit == -1:
return ""
return num_to_text_mapping[last_digit][0]
for index, digit in enumerate(nums):
if index == 0:
continue
if last_digit != digit:
split_nums.append((last_digit, count))
count = 0
last_digit = digit
- count += 1
+ count += 1
if index == len(nums) - 1:
split_nums.append((digit, count))
-
+
result = ""
for digit, num_times in split_nums:
if digit == -1:
continue
key = num_to_text_mapping[digit]
num_letters = len(key)
result += key[int((num_times - 1) % num_letters)]
-
+
return result
def text_to_nums(text):
result = []
last_num = -2
upper_text = text.upper()
for letter in upper_text:
num = text_to_num_mapping[letter][0]
number_times = text_to_num_mapping[letter][1]
if last_num == num:
result.append(-1)
last_num = num
result.extend([num] * number_times)
return result
def nums_to_angle(nums):
sum_angles = 0
for digit in nums:
if digit == 0:
sum_angles += 30 * 10
else:
sum_angles += 30 * digit
result = sum_angles % 360
return result
def angles_to_nums(angles):
possible_angles = [0, 30, 60, 90, 120, 150, 180, 210, 240, 270, 300, 330]
result = []
for angle in angles:
angle = angle % 360
angle_normalized = min(possible_angles, key=lambda x: abs(x-angle))
if angle_normalized == 0 or angle_normalized == 330:
continue
if angle_normalized == 360:
result.append(0)
else:
result.append(int((angle_normalized / 30) % 10))
return result
def is_phone_tastic(word):
+ if len(word) == 0:
+ return False
to_numbers = text_to_nums(word)
to_angle = nums_to_angle(to_numbers)
return to_angle % len(word) == 0