Решение на Телефонна любов от Александра Павлова

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

Към профила на Александра Павлова

Резултати

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

Код

phone_letters = {
'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': ' ',
}
angles_of_digits = {
'1': 30,
'2': 60,
'3': 90,
'4': 120,
'5': 150,
'6': 180,
'7': 210,
'8': 240,
'9': 270,
'0': 300,
}
def nums_to_text(nums):
text = ''
while nums:

Смятам за по-лесно да обходиш nums чрез for, или пак while, но без да редактираш самата колеция. Няма да трябва да правиш nums.remove(-1), del nums[0:index + 1], curr_num = nums[0] и други подобни, а пак можеш да постигнеш същия ефект.

index = -1
curr_num = nums[0]
if str(curr_num) not in phone_letters.keys():
nums.remove(curr_num)
continue
for num in nums:
if curr_num != num:
break
index += 1
if curr_num == 0:
text += phone_letters[str(curr_num)] * (index + 1)
else:
text += phone_letters[str(curr_num)][index % len(phone_letters[str(curr_num)])]
del nums[0:index + 1]
return text
def text_to_nums(text):
text = text.upper()
nums = []
last_digit = ''
for ch in text:
presses = 1
for digit, letters in phone_letters.items():
if ch in letters:
if last_digit == digit and last_digit != '0':
nums.append(-1)
presses += letters.index(ch)
[nums.append(int(digit)) for _ in range(presses)]
last_digit = digit
break
return nums
def normalize_angle(angle):
angle -= 360
if angle > 360:
angle = normalize_angle(angle)
return angle
def nums_to_angle(nums):
normalized_angle = 0
for num in nums:
if str(num) not in angles_of_digits.keys():
continue
normalized_angle += angles_of_digits[str(num)]
if normalized_angle > 360:
normalized_angle = normalize_angle(normalized_angle)
return normalized_angle
def angle_multiple_of_thirty_to_upper(angle):

Тези три функции са един доста дълъг вариант за операцията, която ти трябва. Не изисквам да търсиш ново решение този път, но го имай предвид за следващи домашни. Има по-кратки и лесни алгоритми за закръгляване.

value = 10 - angle % 10
if (angle + value) % 30 != 0:
value += angle_multiple_of_thirty_to_upper(angle + value)
return value
def angle_multiple_of_thirty_to_lower(angle):
value = 10 + angle % 10
if (angle - value) % 30 != 0:
value += angle_multiple_of_thirty_to_lower(angle - value)
return value
def closest_to_number(angle):
to_upper = angle_multiple_of_thirty_to_upper(angle)
to_lower = angle_multiple_of_thirty_to_lower(angle)
if to_upper < to_lower:
return angle + to_upper
return angle - to_lower
def angles_to_nums(angles):
nums = []
for angle in angles:
if angle < 0:
angle += 360
elif angle > 360:
angle -= 360
if angle < 15 or angle > 329:
continue
if angle % 30 != 0:
angle = closest_to_number(angle)
for digit, value in angles_of_digits.items():
if angle == value:
nums.append(int(digit))
break
return nums
def is_phone_tastic(word):
return nums_to_angle(text_to_nums(word)) % len(word) == 0

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

....F.FF..E......F...................
======================================================================
ERROR: test_empty_input (test.TestIsPhonetastic)
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
ZeroDivisionError: integer division or modulo by zero

======================================================================
FAIL: test_multiple_angles (test.TestAnglesToNums)
Test with a couple of angles as 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: [1, 6, 2, 2, 3] != [1, 6, 2, 2, 2]

First differing element 4:
3
2

- [1, 6, 2, 2, 3]
?              ^

+ [1, 6, 2, 2, 2]
?              ^


======================================================================
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_normalizing_for_top_boundary (test.TestNumsToAngles)
Test normalizing when the sum is full circle.
----------------------------------------------------------------------
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: 360 != 0

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

FAILED (failures=4, errors=1)

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

Александра обнови решението на 31.10.2022 18:10 (преди над 1 година)

+phone_letters = {
+ '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': ' ',
+}
+
+angles_of_digits = {
+ '1': 30,
+ '2': 60,
+ '3': 90,
+ '4': 120,
+ '5': 150,
+ '6': 180,
+ '7': 210,
+ '8': 240,
+ '9': 270,
+ '0': 300,
+}
+
+
+def nums_to_text(nums):
+ text = ''
+
+ while nums:
+ index = -1
+ curr_num = nums[0]
+
+ if curr_num == -1:
+ nums.remove(-1)
+ continue
+
+ for num in nums:
+ if curr_num != num:
+ break
+ index += 1
+
+ text += phone_letters[str(curr_num)][index - len(phone_letters[str(curr_num)])]
+ del nums[0:index + 1]
+
+ return text
+
+
+def text_to_nums(text):
+ text = text.upper()
+ nums = []
+
+ for ch in text:
+ presses = 1
+
+ for digit, letters in phone_letters.items():
+
+ if ch in letters:
+ presses += letters.index(ch)
+ [nums.append(int(digit)) for _ in range(presses)]
+ break
+
+ return nums
+
+
+def nums_to_angle(nums):
+ normalized_angle = 0
+ for num in nums:
+ normalized_angle += angles_of_digits[str(num)]
+
+ if normalized_angle > 360:
+ normalized_angle = normalized_angle - 360
+
+ return normalized_angle
+
+
+def angle_multiple_of_thirty_to_upper(angle):
+ value = 10 - angle % 10
+ if (angle + value) % 30 != 0:
+ value += angle_multiple_of_thirty_to_upper(angle + value)
+ return value
+
+
+def angle_multiple_of_thirty_to_lower(angle):
+ value = 10 + angle % 10
+ if (angle - value) % 30 != 0:
+ value += angle_multiple_of_thirty_to_lower(angle - value)
+ return value
+
+
+def closest_to_number(angle):
+ to_upper = angle_multiple_of_thirty_to_upper(angle)
+ to_lower = angle_multiple_of_thirty_to_lower(angle)
+ if to_upper < to_lower:
+ angle += to_upper
+ else:
+ angle += to_lower
+
+ return angle
+
+
+def angles_to_nums(angles):
+ nums = []
+
+ for angle in angles:
+
+ if angle < 0:
+ angle += 360
+ elif angle > 360:
+ angle -= 360
+
+ if angle < 15 or angle > 329:
+ continue
+
+ if angle % 30 != 0:
+ angle = closest_to_number(angle)
+
+ for digit, value in angles_of_digits.items():
+ if angle == value:
+ nums.append(int(digit))
+ break
+
+ return nums
+
+
+def is_phone_tastic(word):
+ phone_tastic = False
+ if nums_to_angle(text_to_nums(word)) % len(word) == 0:
+ phone_tastic = True
+ return phone_tastic

Александра обнови решението на 31.10.2022 18:51 (преди над 1 година)

phone_letters = {
'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': ' ',
}
angles_of_digits = {
'1': 30,
'2': 60,
'3': 90,
'4': 120,
'5': 150,
'6': 180,
'7': 210,
'8': 240,
'9': 270,
'0': 300,
}
def nums_to_text(nums):
text = ''
while nums:
index = -1
curr_num = nums[0]
if curr_num == -1:
nums.remove(-1)
continue
for num in nums:
if curr_num != num:
break
index += 1
- text += phone_letters[str(curr_num)][index - len(phone_letters[str(curr_num)])]
+ text += phone_letters[str(curr_num)][index - len(phone_letters[str(curr_num)]) ** 2]
del nums[0:index + 1]
return text
def text_to_nums(text):
text = text.upper()
nums = []
for ch in text:
presses = 1
for digit, letters in phone_letters.items():
if ch in letters:
presses += letters.index(ch)
[nums.append(int(digit)) for _ in range(presses)]
break
return nums
def nums_to_angle(nums):
normalized_angle = 0
for num in nums:
normalized_angle += angles_of_digits[str(num)]
if normalized_angle > 360:
normalized_angle = normalized_angle - 360
return normalized_angle
def angle_multiple_of_thirty_to_upper(angle):
value = 10 - angle % 10
if (angle + value) % 30 != 0:
value += angle_multiple_of_thirty_to_upper(angle + value)
return value
def angle_multiple_of_thirty_to_lower(angle):
value = 10 + angle % 10
if (angle - value) % 30 != 0:
value += angle_multiple_of_thirty_to_lower(angle - value)
return value
def closest_to_number(angle):
to_upper = angle_multiple_of_thirty_to_upper(angle)
to_lower = angle_multiple_of_thirty_to_lower(angle)
if to_upper < to_lower:
angle += to_upper
else:
angle += to_lower
return angle
def angles_to_nums(angles):
nums = []
for angle in angles:
if angle < 0:
angle += 360
elif angle > 360:
angle -= 360
if angle < 15 or angle > 329:
continue
if angle % 30 != 0:
angle = closest_to_number(angle)
for digit, value in angles_of_digits.items():
if angle == value:
nums.append(int(digit))
break
return nums
def is_phone_tastic(word):
phone_tastic = False
if nums_to_angle(text_to_nums(word)) % len(word) == 0:
phone_tastic = True
- return phone_tastic
+ return phone_tastic
+
+

Александра обнови решението на 31.10.2022 19:03 (преди над 1 година)

phone_letters = {
'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': ' ',
}
angles_of_digits = {
'1': 30,
'2': 60,
'3': 90,
'4': 120,
'5': 150,
'6': 180,
'7': 210,
'8': 240,
'9': 270,
'0': 300,
}
def nums_to_text(nums):
text = ''
while nums:
index = -1
curr_num = nums[0]
if curr_num == -1:
nums.remove(-1)
continue
for num in nums:
if curr_num != num:
break
index += 1
text += phone_letters[str(curr_num)][index - len(phone_letters[str(curr_num)]) ** 2]
del nums[0:index + 1]
return text
def text_to_nums(text):
text = text.upper()
nums = []
for ch in text:
presses = 1
for digit, letters in phone_letters.items():
if ch in letters:
presses += letters.index(ch)
[nums.append(int(digit)) for _ in range(presses)]
break
return nums
+def normalize_angle(angle):
+ angle -= 360
+ if angle > 360:
+ angle = normalize_angle(angle)
+ return angle
+
+
def nums_to_angle(nums):
normalized_angle = 0
for num in nums:
normalized_angle += angles_of_digits[str(num)]
if normalized_angle > 360:
- normalized_angle = normalized_angle - 360
+ normalized_angle = normalize_angle(normalized_angle)
return normalized_angle
def angle_multiple_of_thirty_to_upper(angle):
value = 10 - angle % 10
if (angle + value) % 30 != 0:
value += angle_multiple_of_thirty_to_upper(angle + value)
return value
def angle_multiple_of_thirty_to_lower(angle):
value = 10 + angle % 10
if (angle - value) % 30 != 0:
value += angle_multiple_of_thirty_to_lower(angle - value)
return value
def closest_to_number(angle):
to_upper = angle_multiple_of_thirty_to_upper(angle)
to_lower = angle_multiple_of_thirty_to_lower(angle)
if to_upper < to_lower:
angle += to_upper
else:
angle += to_lower
return angle
def angles_to_nums(angles):
nums = []
for angle in angles:
if angle < 0:
angle += 360
elif angle > 360:
angle -= 360
if angle < 15 or angle > 329:
continue
if angle % 30 != 0:
angle = closest_to_number(angle)
for digit, value in angles_of_digits.items():
if angle == value:
nums.append(int(digit))
break
return nums
def is_phone_tastic(word):
phone_tastic = False
if nums_to_angle(text_to_nums(word)) % len(word) == 0:
phone_tastic = True
return phone_tastic
-

Александра обнови решението на 31.10.2022 19:08 (преди над 1 година)

phone_letters = {
'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': ' ',
}
angles_of_digits = {
'1': 30,
'2': 60,
'3': 90,
'4': 120,
'5': 150,
'6': 180,
'7': 210,
'8': 240,
'9': 270,
'0': 300,
}
def nums_to_text(nums):
text = ''
while nums:
index = -1
curr_num = nums[0]
if curr_num == -1:
nums.remove(-1)
continue
for num in nums:
if curr_num != num:
break
index += 1
text += phone_letters[str(curr_num)][index - len(phone_letters[str(curr_num)]) ** 2]
del nums[0:index + 1]
return text
def text_to_nums(text):
text = text.upper()
nums = []
for ch in text:
presses = 1
for digit, letters in phone_letters.items():
if ch in letters:
presses += letters.index(ch)
[nums.append(int(digit)) for _ in range(presses)]
break
return nums
def normalize_angle(angle):
angle -= 360
if angle > 360:
angle = normalize_angle(angle)
return angle
def nums_to_angle(nums):
normalized_angle = 0
for num in nums:
normalized_angle += angles_of_digits[str(num)]
if normalized_angle > 360:
normalized_angle = normalize_angle(normalized_angle)
return normalized_angle
def angle_multiple_of_thirty_to_upper(angle):
value = 10 - angle % 10
if (angle + value) % 30 != 0:
value += angle_multiple_of_thirty_to_upper(angle + value)
return value
def angle_multiple_of_thirty_to_lower(angle):
value = 10 + angle % 10
if (angle - value) % 30 != 0:
value += angle_multiple_of_thirty_to_lower(angle - value)
return value
def closest_to_number(angle):
to_upper = angle_multiple_of_thirty_to_upper(angle)
to_lower = angle_multiple_of_thirty_to_lower(angle)
if to_upper < to_lower:
angle += to_upper
else:
angle += to_lower
return angle
def angles_to_nums(angles):
nums = []
for angle in angles:
if angle < 0:
angle += 360
elif angle > 360:
angle -= 360
if angle < 15 or angle > 329:
continue
if angle % 30 != 0:
angle = closest_to_number(angle)
for digit, value in angles_of_digits.items():
if angle == value:
nums.append(int(digit))
break
return nums
def is_phone_tastic(word):
- phone_tastic = False
- if nums_to_angle(text_to_nums(word)) % len(word) == 0:
+ return bool(nums_to_angle(text_to_nums(word)) % len(word) == 0)
- phone_tastic = True
- return phone_tastic
-

Александра обнови решението на 31.10.2022 19:12 (преди над 1 година)

phone_letters = {
'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': ' ',
}
angles_of_digits = {
'1': 30,
'2': 60,
'3': 90,
'4': 120,
'5': 150,
'6': 180,
'7': 210,
'8': 240,
'9': 270,
'0': 300,
}
def nums_to_text(nums):
text = ''
while nums:

Смятам за по-лесно да обходиш nums чрез for, или пак while, но без да редактираш самата колеция. Няма да трябва да правиш nums.remove(-1), del nums[0:index + 1], curr_num = nums[0] и други подобни, а пак можеш да постигнеш същия ефект.

index = -1
curr_num = nums[0]
if curr_num == -1:
nums.remove(-1)
continue
for num in nums:
if curr_num != num:
break
index += 1
text += phone_letters[str(curr_num)][index - len(phone_letters[str(curr_num)]) ** 2]
del nums[0:index + 1]
return text
def text_to_nums(text):
text = text.upper()
nums = []
for ch in text:
presses = 1
for digit, letters in phone_letters.items():
if ch in letters:
presses += letters.index(ch)
[nums.append(int(digit)) for _ in range(presses)]
break
return nums
def normalize_angle(angle):
angle -= 360
if angle > 360:
angle = normalize_angle(angle)
return angle
def nums_to_angle(nums):
normalized_angle = 0
for num in nums:
normalized_angle += angles_of_digits[str(num)]
if normalized_angle > 360:
normalized_angle = normalize_angle(normalized_angle)
return normalized_angle
def angle_multiple_of_thirty_to_upper(angle):

Тези три функции са един доста дълъг вариант за операцията, която ти трябва. Не изисквам да търсиш ново решение този път, но го имай предвид за следващи домашни. Има по-кратки и лесни алгоритми за закръгляване.

value = 10 - angle % 10
if (angle + value) % 30 != 0:
value += angle_multiple_of_thirty_to_upper(angle + value)
return value
def angle_multiple_of_thirty_to_lower(angle):
value = 10 + angle % 10
if (angle - value) % 30 != 0:
value += angle_multiple_of_thirty_to_lower(angle - value)
return value
def closest_to_number(angle):
to_upper = angle_multiple_of_thirty_to_upper(angle)
to_lower = angle_multiple_of_thirty_to_lower(angle)
if to_upper < to_lower:
- angle += to_upper
- else:
- angle += to_lower
+ return angle + to_upper
+ return angle + to_lower
- return angle
-
def angles_to_nums(angles):
nums = []
for angle in angles:
if angle < 0:
angle += 360
elif angle > 360:
angle -= 360
if angle < 15 or angle > 329:
continue
if angle % 30 != 0:
angle = closest_to_number(angle)
for digit, value in angles_of_digits.items():
if angle == value:
nums.append(int(digit))
break
return nums
def is_phone_tastic(word):
- return bool(nums_to_angle(text_to_nums(word)) % len(word) == 0)
+ return bool(nums_to_angle(text_to_nums(word)) % len(word) == 0)
+

Александра обнови решението на 01.11.2022 18:47 (преди над 1 година)

phone_letters = {
'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': ' ',
}
angles_of_digits = {
- '1': 30,
- '2': 60,
- '3': 90,
- '4': 120,
- '5': 150,
- '6': 180,
- '7': 210,
- '8': 240,
- '9': 270,
- '0': 300,
+ 1: 30,
+ 2: 60,
+ 3: 90,
+ 4: 120,
+ 5: 150,
+ 6: 180,
+ 7: 210,
+ 8: 240,
+ 9: 270,
+ 0: 300,
}
def nums_to_text(nums):
text = ''
while nums:
index = -1
curr_num = nums[0]
if curr_num == -1:
nums.remove(-1)
continue
for num in nums:
if curr_num != num:
break
index += 1
- text += phone_letters[str(curr_num)][index - len(phone_letters[str(curr_num)]) ** 2]
+ text += phone_letters[curr_num][index - len(phone_letters[str(curr_num)]) ** 2]
del nums[0:index + 1]
return text
def text_to_nums(text):
text = text.upper()
nums = []
for ch in text:
presses = 1
for digit, letters in phone_letters.items():
if ch in letters:
presses += letters.index(ch)
[nums.append(int(digit)) for _ in range(presses)]
break
return nums
def normalize_angle(angle):
angle -= 360
if angle > 360:
angle = normalize_angle(angle)
return angle
def nums_to_angle(nums):
normalized_angle = 0
for num in nums:
- normalized_angle += angles_of_digits[str(num)]
+ normalized_angle += angles_of_digits[num]
if normalized_angle > 360:
normalized_angle = normalize_angle(normalized_angle)
return normalized_angle
def angle_multiple_of_thirty_to_upper(angle):
value = 10 - angle % 10
if (angle + value) % 30 != 0:
value += angle_multiple_of_thirty_to_upper(angle + value)
return value
def angle_multiple_of_thirty_to_lower(angle):
value = 10 + angle % 10
if (angle - value) % 30 != 0:
value += angle_multiple_of_thirty_to_lower(angle - value)
return value
def closest_to_number(angle):
to_upper = angle_multiple_of_thirty_to_upper(angle)
to_lower = angle_multiple_of_thirty_to_lower(angle)
if to_upper < to_lower:
return angle + to_upper
return angle + to_lower
def angles_to_nums(angles):
nums = []
for angle in angles:
if angle < 0:
angle += 360
elif angle > 360:
angle -= 360
if angle < 15 or angle > 329:
continue
if angle % 30 != 0:
angle = closest_to_number(angle)
for digit, value in angles_of_digits.items():
if angle == value:
nums.append(int(digit))
break
return nums
def is_phone_tastic(word):
- return bool(nums_to_angle(text_to_nums(word)) % len(word) == 0)
+ return nums_to_angle(text_to_nums(word)) % len(word) == 0
+

Александра обнови решението на 02.11.2022 19:40 (преди над 1 година)

phone_letters = {
'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': ' ',
}
angles_of_digits = {
- 1: 30,
- 2: 60,
- 3: 90,
- 4: 120,
- 5: 150,
- 6: 180,
- 7: 210,
- 8: 240,
- 9: 270,
- 0: 300,
+ '1': 30,
+ '2': 60,
+ '3': 90,
+ '4': 120,
+ '5': 150,
+ '6': 180,
+ '7': 210,
+ '8': 240,
+ '9': 270,
+ '0': 300,
}
def nums_to_text(nums):
text = ''
while nums:
index = -1
curr_num = nums[0]
if curr_num == -1:
nums.remove(-1)
continue
for num in nums:
if curr_num != num:
break
index += 1
- text += phone_letters[curr_num][index - len(phone_letters[str(curr_num)]) ** 2]
+ text += phone_letters[str(curr_num)][index - len(phone_letters[str(curr_num)])]
del nums[0:index + 1]
return text
def text_to_nums(text):
text = text.upper()
nums = []
for ch in text:
presses = 1
for digit, letters in phone_letters.items():
if ch in letters:
presses += letters.index(ch)
[nums.append(int(digit)) for _ in range(presses)]
break
return nums
def normalize_angle(angle):
angle -= 360
if angle > 360:
angle = normalize_angle(angle)
return angle
def nums_to_angle(nums):
normalized_angle = 0
for num in nums:
- normalized_angle += angles_of_digits[num]
+ normalized_angle += angles_of_digits[str(num)]
if normalized_angle > 360:
normalized_angle = normalize_angle(normalized_angle)
return normalized_angle
def angle_multiple_of_thirty_to_upper(angle):
value = 10 - angle % 10
if (angle + value) % 30 != 0:
value += angle_multiple_of_thirty_to_upper(angle + value)
return value
def angle_multiple_of_thirty_to_lower(angle):
value = 10 + angle % 10
if (angle - value) % 30 != 0:
value += angle_multiple_of_thirty_to_lower(angle - value)
return value
def closest_to_number(angle):
to_upper = angle_multiple_of_thirty_to_upper(angle)
to_lower = angle_multiple_of_thirty_to_lower(angle)
if to_upper < to_lower:
return angle + to_upper
return angle + to_lower
def angles_to_nums(angles):
nums = []
for angle in angles:
if angle < 0:
angle += 360
elif angle > 360:
angle -= 360
if angle < 15 or angle > 329:
continue
if angle % 30 != 0:
angle = closest_to_number(angle)
for digit, value in angles_of_digits.items():
if angle == value:
nums.append(int(digit))
break
return nums
def is_phone_tastic(word):
return nums_to_angle(text_to_nums(word)) % len(word) == 0
+

Александра обнови решението на 03.11.2022 11:11 (преди над 1 година)

phone_letters = {
'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': ' ',
}
angles_of_digits = {
'1': 30,
'2': 60,
'3': 90,
'4': 120,
'5': 150,
'6': 180,
'7': 210,
'8': 240,
'9': 270,
'0': 300,
}
def nums_to_text(nums):
text = ''
while nums:
index = -1
curr_num = nums[0]
- if curr_num == -1:
- nums.remove(-1)
+ if str(curr_num) not in phone_letters.keys():
+ nums.remove(curr_num)
continue
for num in nums:
if curr_num != num:
break
index += 1
- text += phone_letters[str(curr_num)][index - len(phone_letters[str(curr_num)])]
+ if curr_num == 0:
+ text += phone_letters[str(curr_num)] * (index + 1)
+ else:
+ text += phone_letters[str(curr_num)][index % len(phone_letters[str(curr_num)])]
del nums[0:index + 1]
return text
def text_to_nums(text):
text = text.upper()
nums = []
+ last_digit = ''
for ch in text:
presses = 1
for digit, letters in phone_letters.items():
if ch in letters:
+
+ if last_digit == digit and last_digit != '0':
+ nums.append(-1)
+
presses += letters.index(ch)
[nums.append(int(digit)) for _ in range(presses)]
+ last_digit = digit
break
return nums
def normalize_angle(angle):
angle -= 360
if angle > 360:
angle = normalize_angle(angle)
return angle
def nums_to_angle(nums):
normalized_angle = 0
for num in nums:
+ if str(num) not in angles_of_digits.keys():
+ continue
normalized_angle += angles_of_digits[str(num)]
if normalized_angle > 360:
normalized_angle = normalize_angle(normalized_angle)
return normalized_angle
def angle_multiple_of_thirty_to_upper(angle):
value = 10 - angle % 10
if (angle + value) % 30 != 0:
value += angle_multiple_of_thirty_to_upper(angle + value)
return value
def angle_multiple_of_thirty_to_lower(angle):
value = 10 + angle % 10
if (angle - value) % 30 != 0:
value += angle_multiple_of_thirty_to_lower(angle - value)
return value
def closest_to_number(angle):
to_upper = angle_multiple_of_thirty_to_upper(angle)
to_lower = angle_multiple_of_thirty_to_lower(angle)
if to_upper < to_lower:
return angle + to_upper
- return angle + to_lower
+ return angle - to_lower
def angles_to_nums(angles):
nums = []
for angle in angles:
if angle < 0:
angle += 360
elif angle > 360:
angle -= 360
if angle < 15 or angle > 329:
continue
if angle % 30 != 0:
angle = closest_to_number(angle)
for digit, value in angles_of_digits.items():
if angle == value:
nums.append(int(digit))
break
return nums
def is_phone_tastic(word):
return nums_to_angle(text_to_nums(word)) % len(word) == 0
-