Private & Protected в ООП

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

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

Решение на Телефонна любов от Марио Николов

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

Към профила на Марио Николов

Резултати

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

Код

def nums_to_text(nums):
key_combinations = {
-1: [""],
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"],
0: [" "]
}
result = ""
current_num = None
current_num_counter = 0
for num in nums:
if current_num is None:
current_num = num
if current_num == num:
current_num_counter += 1
else:
index = (current_num_counter %
len(key_combinations[current_num])) - 1
result += key_combinations[current_num][index]
current_num = num
current_num_counter = 1
index = (current_num_counter % len(key_combinations[current_num])) - 1
result += key_combinations[current_num][index]
return result
def text_to_nums(text):
text = text.upper()
key_combinations = {

Това е същият речник, който използваш в предишната функция. Добре е да го изнесеш извън функциите и да имаш само една дефиниция. Реално погледнато, тук ти трябва по-скоро обратното, за което си направил модификацията на ред 60. Ако просто преправиш този речник, това няма да е нужно.

Георги
-1: [""],
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"],
0: [" "]
}
result = []
previous_digit = -1
for letter in text:
digit = [key for key, values in key_combinations.items()
if letter in values][0]
repetition = key_combinations[digit].index(letter) + 1
if (previous_digit == digit):
result.append(-1)
previous_digit = digit
result.extend([digit] * repetition)
return result
def nums_to_angle(nums):
result = sum(map(lambda x: 10 * 30 if x == 0 else x * 30, nums))
return result if result < 360 else abs(360 - result)
def angles_to_nums(angles):
possible_angles = list(range(0, 390, 30))
result = []
for angle in angles:
current_angle = angle
if current_angle < 0:
current_angle = abs(360 + current_angle)
if current_angle >= 360:
current_angle = abs(360 - current_angle)
rounded_angle = min(possible_angles, key=lambda possible_angle:
abs(possible_angle - current_angle))
if rounded_angle == 0 or rounded_angle >= 330:
continue
digit = possible_angles.index(rounded_angle)
if digit == 10:
digit = 0
result.append(digit)
return result
def is_phone_tastic(word):
result = False
if len(word) == 0:
return result
angle = nums_to_angle(text_to_nums(word))
return True if angle % len(word) == 0 else False

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

......FF...F......F...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
KeyError: None

======================================================================
FAIL: test_overflowing_angles (test.TestAnglesToNums)
Test with an overflowed 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: [] != [2]

Second list contains 1 additional elements.
First extra element 0:
2

- []
+ [2]
?  +


======================================================================
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] != [5, 1, 2, 4, 9, 1, 8, 0, 9]

Second list contains 4 additional elements.
First extra element 5:
1

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

======================================================================
FAIL: test_random_falses (test.TestIsPhonetastic)
Test with a random input resulting in False.
----------------------------------------------------------------------
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: True is not false

======================================================================
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: 1950 != 150

----------------------------------------------------------------------
Ran 37 tests in 0.343s

FAILED (failures=4, errors=1)

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

Марио обнови решението на 03.11.2022 10:21 (преди над 2 години)

+def nums_to_text(nums):
+
+ key_combinations = {
+ -1: [""],
+ 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"],
+ 0: [" "]
+ }
+
+ result = ""
+
+ current_num = None
+ current_num_counter = 0
+ for num in nums:
+ if current_num is None:
+ current_num = num
+
+ if current_num == num:
+ current_num_counter += 1
+ else:
+ index = (current_num_counter %
+ len(key_combinations[current_num])) - 1
+ result += key_combinations[current_num][index]
+ current_num = num
+ current_num_counter = 1
+
+ index = (current_num_counter % len(key_combinations[current_num])) - 1
+ result += key_combinations[current_num][index]
+
+ return result
+
+
+def text_to_nums(text):
+ text = text.upper()
+ key_combinations = {
+ -1: [""],
+ 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"],
+ 0: [" "]
+ }
+
+ result = []
+ previous_digit = -1
+
+ for letter in text:
+ digit = [key for key, values in key_combinations.items()
+ if letter in values][0]
+ repetition = key_combinations[digit].index(letter) + 1
+
+ if (previous_digit == digit):
+ result.append(-1)
+
+ previous_digit = digit
+ result.extend([digit] * repetition)
+
+ return result
+
+
+def nums_to_angle(nums):
+ result = sum(map(lambda x: 10*30 if x == 0 else x * 30, nums))
+ return result if result < 360 else abs(360 - result)
+
+
+def angles_to_nums(angles):
+ result = []
+
+ for angle in angles:
+ if angle < 0:
+ normalized_angle = abs(360 + angle)
+ if normalized_angle // 30 == 11:
+ continue
+
+ if normalized_angle >= 15 and normalized_angle <= 30:
+ result.append(1)
+ elif normalized_angle > 30 and normalized_angle <= 345:
+ result.append(normalized_angle // 30)
+ else:
+ if angle // 30 == 11:
+ continue
+
+ if angle >= 15 and angle <= 30:
+ result.append(1)
+ elif angle > 30 and angle <= 345:
+ result.append(angle // 30)
+
+ return result
+
+
+def is_phone_tastic(word):
+ result = False
+ if len(word) == 0:
+ return result
+ angle = nums_to_angle(text_to_nums(word))
+ return True if angle % len(word) == 0 else False

Марио обнови решението на 03.11.2022 10:37 (преди над 2 години)

def nums_to_text(nums):
key_combinations = {
-1: [""],
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"],
0: [" "]
}
result = ""
current_num = None
current_num_counter = 0
for num in nums:
if current_num is None:
current_num = num
if current_num == num:
current_num_counter += 1
else:
index = (current_num_counter %
len(key_combinations[current_num])) - 1
result += key_combinations[current_num][index]
current_num = num
current_num_counter = 1
index = (current_num_counter % len(key_combinations[current_num])) - 1
result += key_combinations[current_num][index]
return result
def text_to_nums(text):
text = text.upper()
key_combinations = {
-1: [""],
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"],
0: [" "]
}
result = []
previous_digit = -1
for letter in text:
digit = [key for key, values in key_combinations.items()
if letter in values][0]
repetition = key_combinations[digit].index(letter) + 1
if (previous_digit == digit):
result.append(-1)
previous_digit = digit
result.extend([digit] * repetition)
return result
def nums_to_angle(nums):
result = sum(map(lambda x: 10*30 if x == 0 else x * 30, nums))
return result if result < 360 else abs(360 - result)
def angles_to_nums(angles):
result = []
for angle in angles:
if angle < 0:
normalized_angle = abs(360 + angle)
- if normalized_angle // 30 == 11:
+ if normalized_angle >= 330:
continue
if normalized_angle >= 15 and normalized_angle <= 30:
result.append(1)
- elif normalized_angle > 30 and normalized_angle <= 345:
+ else:
result.append(normalized_angle // 30)
else:
- if angle // 30 == 11:
+ if angle >= 330:
continue
if angle >= 15 and angle <= 30:
result.append(1)
- elif angle > 30 and angle <= 345:
- result.append(angle // 30)
+ else:
+ digit = angle // 30
+ result.append(0 if digit == 10 else digit)
return result
def is_phone_tastic(word):
result = False
if len(word) == 0:
return result
angle = nums_to_angle(text_to_nums(word))
return True if angle % len(word) == 0 else False

Марио обнови решението на 03.11.2022 13:27 (преди над 2 години)

def nums_to_text(nums):
key_combinations = {
-1: [""],
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"],
0: [" "]
}
result = ""
current_num = None
current_num_counter = 0
for num in nums:
if current_num is None:
current_num = num
if current_num == num:
current_num_counter += 1
else:
index = (current_num_counter %
len(key_combinations[current_num])) - 1
result += key_combinations[current_num][index]
current_num = num
current_num_counter = 1
index = (current_num_counter % len(key_combinations[current_num])) - 1
result += key_combinations[current_num][index]
return result
def text_to_nums(text):
text = text.upper()
key_combinations = {
-1: [""],
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"],
0: [" "]
}
result = []
previous_digit = -1
for letter in text:
digit = [key for key, values in key_combinations.items()
if letter in values][0]
repetition = key_combinations[digit].index(letter) + 1
if (previous_digit == digit):
result.append(-1)
previous_digit = digit
result.extend([digit] * repetition)
return result
def nums_to_angle(nums):
result = sum(map(lambda x: 10*30 if x == 0 else x * 30, nums))
return result if result < 360 else abs(360 - result)
def angles_to_nums(angles):
result = []
for angle in angles:
if angle < 0:
normalized_angle = abs(360 + angle)
if normalized_angle >= 330:
continue
if normalized_angle >= 15 and normalized_angle <= 30:
result.append(1)
- else:
+ elif normalized_angle > 30:
result.append(normalized_angle // 30)
else:
if angle >= 330:
continue
if angle >= 15 and angle <= 30:
result.append(1)
- else:
+ elif angle > 30:
digit = angle // 30
result.append(0 if digit == 10 else digit)
return result
def is_phone_tastic(word):
result = False
if len(word) == 0:
return result
angle = nums_to_angle(text_to_nums(word))
return True if angle % len(word) == 0 else False

Марио обнови решението на 03.11.2022 14:28 (преди над 2 години)

def nums_to_text(nums):
key_combinations = {
-1: [""],
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"],
0: [" "]
}
result = ""
current_num = None
current_num_counter = 0
for num in nums:
if current_num is None:
current_num = num
if current_num == num:
current_num_counter += 1
else:
index = (current_num_counter %
len(key_combinations[current_num])) - 1
result += key_combinations[current_num][index]
current_num = num
current_num_counter = 1
index = (current_num_counter % len(key_combinations[current_num])) - 1
result += key_combinations[current_num][index]
return result
def text_to_nums(text):
text = text.upper()
key_combinations = {

Това е същият речник, който използваш в предишната функция. Добре е да го изнесеш извън функциите и да имаш само една дефиниция. Реално погледнато, тук ти трябва по-скоро обратното, за което си направил модификацията на ред 60. Ако просто преправиш този речник, това няма да е нужно.

Георги
-1: [""],
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"],
0: [" "]
}
result = []
previous_digit = -1
for letter in text:
digit = [key for key, values in key_combinations.items()
if letter in values][0]
repetition = key_combinations[digit].index(letter) + 1
if (previous_digit == digit):
result.append(-1)
previous_digit = digit
result.extend([digit] * repetition)
return result
def nums_to_angle(nums):
- result = sum(map(lambda x: 10*30 if x == 0 else x * 30, nums))
+ result = sum(map(lambda x: 10 * 30 if x == 0 else x * 30, nums))
return result if result < 360 else abs(360 - result)
def angles_to_nums(angles):
+ possible_angles = list(range(0, 390, 30))
result = []
for angle in angles:
- if angle < 0:
- normalized_angle = abs(360 + angle)
- if normalized_angle >= 330:
- continue
+ current_angle = angle
+ if current_angle < 0:
+ current_angle = abs(360 + current_angle)
- if normalized_angle >= 15 and normalized_angle <= 30:
- result.append(1)
- elif normalized_angle > 30:
- result.append(normalized_angle // 30)
- else:
- if angle >= 330:
- continue
+ if current_angle >= 360:
+ current_angle = abs(360 - current_angle)
- if angle >= 15 and angle <= 30:
- result.append(1)
- elif angle > 30:
- digit = angle // 30
- result.append(0 if digit == 10 else digit)
+ rounded_angle = min(possible_angles, key=lambda possible_angle:
+ abs(possible_angle - current_angle))
+
+ if rounded_angle == 0 or rounded_angle >= 330:
+ continue
+
+ digit = possible_angles.index(rounded_angle)
+
+ if digit == 10:
+ digit = 0
+ result.append(digit)
return result
def is_phone_tastic(word):
result = False
if len(word) == 0:
return result
angle = nums_to_angle(text_to_nums(word))
return True if angle % len(word) == 0 else False