Private & Protected в ООП

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

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

Решение на Телефонна любов от Огнян Йончев

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

Към профила на Огнян Йончев

Резултати

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

Код

number_to_letter_dict = {
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: [' ', ' ', ' '],
}
letter_to_number_dict = {
'A': [2, 1], '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],
}
number_to_angle_dict = {
1: 30, 2: 60, 3: 90, 4: 120, 5: 150,
6: 180, 7: 210, 8: 240, 9: 270, 0: 300,
}
# Make letter from number and number sequence in text.
def make_letter(number, number_sequence):
if number in (7, 9):
return number_to_letter_dict[number][number_sequence % 4]
else:
return number_to_letter_dict[number][number_sequence % 3]
# Normalize angle.
def normalize(number):
if number < 0:
return 360 + number
else:
return number - 360
def nums_to_text(numbers):
number_sequence = 0
message = ''
for index, number in enumerate(numbers):
if number == -1:
continue
if index == len(numbers) - 1 or number != numbers[index + 1]:
message += make_letter(number, number_sequence)
number_sequence = 0
else:
number_sequence += 1
return message
def text_to_nums(text):
numbers = []
for index, letter in enumerate(text.upper()):
numbers.extend([letter_to_number_dict[letter][0]]
* letter_to_number_dict[letter][1])
if index != len(text) - 1 and \
letter_to_number_dict[letter][0] == \
letter_to_number_dict[text[index + 1].upper()][0]:
numbers.append(-1)
return numbers
def nums_to_angle(numbers):
angle = 0
for number in numbers:
if number == -1:
continue
angle += number_to_angle_dict[number]
return angle % 360
def angles_to_nums(angles):
numbers = []
for angle in angles:
if angle < 0 or angle > 359:
angle = normalize(angle)
if 15 < angle <= 45:
numbers.append(1)
elif 45 < angle <= 75:
numbers.append(2)
elif 75 < angle <= 105:
numbers.append(3)
elif 105 < angle <= 135:
numbers.append(4)
elif 135 < angle <= 165:
numbers.append(5)
elif 165 < angle <= 195:
numbers.append(6)
elif 195 < angle <= 225:
numbers.append(7)
elif 225 < angle <= 255:
numbers.append(8)
elif 255 < angle <= 285:
numbers.append(9)
elif 285 < angle <= 315:
numbers.append(0)
return numbers
def is_phone_tastic(word):
if not word:
return False
size = len(word)
angle = nums_to_angle(text_to_nums(word))
return angle % size == 0

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

......FF.............................
======================================================================
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]

----------------------------------------------------------------------
Ran 37 tests in 0.364s

FAILED (failures=2)

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

Огнян обнови решението на 02.11.2022 07:59 (преди над 1 година)

+number_to_letter_dict = {
+ 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: [' ', ' ', ' '],
+}
+
+
+letter_to_number_dict = {
+ 'A': [2, 1], '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],
+}
+
+
+number_to_angle_dict = {
+ 1: 30, 2: 60, 3: 90, 4: 120, 5: 150,
+ 6: 180, 7: 210, 8: 240, 9: 270, 0: 300,
+}
+
+
+# Make letter from number and number sequence in text.
+def make_letter(number, number_sequence):
+ if number in (7, 9):
+ return number_to_letter_dict[number][number_sequence % 4]
+ else:
+ return number_to_letter_dict[number][number_sequence % 3]
+
+
+# Normalize angle
+def normalize(number):
+ if number < 0:
+ return 360 + number
+ else:
+ return number - 360
+
+
+def nums_to_text(numbers):
+ number_sequence = 0
+ message = ''
+ for index, number in enumerate(numbers):
+ if number == -1:
+ continue
+ if index == len(numbers) - 1 or number != numbers[index + 1]:
+ message += make_letter(number, number_sequence)
+ number_sequence = 0
+ else:
+ number_sequence += 1
+ return message
+
+
+def text_to_nums(text):
+ numbers = []
+ for letter in text:
+ upper_letter = letter.upper()
+ numbers.extend([letter_to_number_dict[upper_letter][0]]
+ * letter_to_number_dict[upper_letter][1])
+ return numbers
+
+
+def nums_to_angle(numbers):
+ angle = 0
+ for number in numbers:
+ angle += number_to_angle_dict[number]
+ return angle % 360
+
+
+def angles_to_nums(angles):
+ numbers = []
+ for angle in angles:
+ if angle < 0 or angle > 359:
+ angle = normalize(angle)
+ if angle > 15 and angle <= 45:
+ numbers.extend([1])
+ elif angle > 45 and angle <= 75:
+ numbers.extend([2])
+ elif angle > 75 and angle <= 105:
+ numbers.extend([3])
+ elif angle > 105 and angle <= 135:
+ numbers.extend([4])
+ elif angle > 135 and angle <= 165:
+ numbers.extend([5])
+ elif angle > 165 and angle <= 195:
+ numbers.extend([6])
+ elif angle > 195 and angle <= 225:
+ numbers.extend([7])
+ elif angle > 225 and angle <= 255:
+ numbers.extend([8])
+ elif angle > 255 and angle <= 285:
+ numbers.extend([9])
+ elif angle > 285 and angle <= 315:
+ numbers.extend([0])
+ else:
+ continue
+ return numbers
+
+
+def is_phone_tastic(word):
+ size = len(word)
+ angle = nums_to_angle(text_to_nums(word))
+ return normalize(angle) % size == 0

Огнян обнови решението на 02.11.2022 08:00 (преди над 1 година)

number_to_letter_dict = {
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: [' ', ' ', ' '],
}
letter_to_number_dict = {
'A': [2, 1], '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],
}
number_to_angle_dict = {
1: 30, 2: 60, 3: 90, 4: 120, 5: 150,
6: 180, 7: 210, 8: 240, 9: 270, 0: 300,
}
# Make letter from number and number sequence in text.
def make_letter(number, number_sequence):
if number in (7, 9):
return number_to_letter_dict[number][number_sequence % 4]
else:
return number_to_letter_dict[number][number_sequence % 3]
-# Normalize angle
+# Normalize angle.
def normalize(number):
if number < 0:
return 360 + number
else:
return number - 360
def nums_to_text(numbers):
number_sequence = 0
message = ''
for index, number in enumerate(numbers):
if number == -1:
continue
if index == len(numbers) - 1 or number != numbers[index + 1]:
message += make_letter(number, number_sequence)
number_sequence = 0
else:
number_sequence += 1
return message
def text_to_nums(text):
numbers = []
for letter in text:
upper_letter = letter.upper()
numbers.extend([letter_to_number_dict[upper_letter][0]]
* letter_to_number_dict[upper_letter][1])
return numbers
def nums_to_angle(numbers):
angle = 0
for number in numbers:
angle += number_to_angle_dict[number]
return angle % 360
def angles_to_nums(angles):
numbers = []
for angle in angles:
if angle < 0 or angle > 359:
angle = normalize(angle)
if angle > 15 and angle <= 45:
numbers.extend([1])
elif angle > 45 and angle <= 75:
numbers.extend([2])
elif angle > 75 and angle <= 105:
numbers.extend([3])
elif angle > 105 and angle <= 135:
numbers.extend([4])
elif angle > 135 and angle <= 165:
numbers.extend([5])
elif angle > 165 and angle <= 195:
numbers.extend([6])
elif angle > 195 and angle <= 225:
numbers.extend([7])
elif angle > 225 and angle <= 255:
numbers.extend([8])
elif angle > 255 and angle <= 285:
numbers.extend([9])
elif angle > 285 and angle <= 315:
numbers.extend([0])
else:
continue
return numbers
def is_phone_tastic(word):
size = len(word)
angle = nums_to_angle(text_to_nums(word))
return normalize(angle) % size == 0
+

Огнян обнови решението на 02.11.2022 08:01 (преди над 1 година)

number_to_letter_dict = {
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: [' ', ' ', ' '],
}
letter_to_number_dict = {
'A': [2, 1], '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],
}
number_to_angle_dict = {
1: 30, 2: 60, 3: 90, 4: 120, 5: 150,
6: 180, 7: 210, 8: 240, 9: 270, 0: 300,
}
# Make letter from number and number sequence in text.
def make_letter(number, number_sequence):
if number in (7, 9):
return number_to_letter_dict[number][number_sequence % 4]
else:
return number_to_letter_dict[number][number_sequence % 3]
# Normalize angle.
def normalize(number):
if number < 0:
return 360 + number
else:
return number - 360
def nums_to_text(numbers):
number_sequence = 0
message = ''
for index, number in enumerate(numbers):
if number == -1:
continue
if index == len(numbers) - 1 or number != numbers[index + 1]:
message += make_letter(number, number_sequence)
number_sequence = 0
else:
number_sequence += 1
return message
def text_to_nums(text):
numbers = []
for letter in text:
upper_letter = letter.upper()
numbers.extend([letter_to_number_dict[upper_letter][0]]
* letter_to_number_dict[upper_letter][1])
return numbers
def nums_to_angle(numbers):
angle = 0
for number in numbers:
angle += number_to_angle_dict[number]
return angle % 360
def angles_to_nums(angles):
numbers = []
for angle in angles:
if angle < 0 or angle > 359:
angle = normalize(angle)
if angle > 15 and angle <= 45:
numbers.extend([1])
elif angle > 45 and angle <= 75:
numbers.extend([2])
elif angle > 75 and angle <= 105:
numbers.extend([3])
elif angle > 105 and angle <= 135:
numbers.extend([4])
elif angle > 135 and angle <= 165:
numbers.extend([5])
elif angle > 165 and angle <= 195:
numbers.extend([6])
elif angle > 195 and angle <= 225:
numbers.extend([7])
elif angle > 225 and angle <= 255:
numbers.extend([8])
elif angle > 255 and angle <= 285:
numbers.extend([9])
elif angle > 285 and angle <= 315:
numbers.extend([0])
else:
continue
return numbers
def is_phone_tastic(word):
size = len(word)
angle = nums_to_angle(text_to_nums(word))
return normalize(angle) % size == 0
-

Огнян обнови решението на 02.11.2022 08:10 (преди над 1 година)

number_to_letter_dict = {
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: [' ', ' ', ' '],
}
letter_to_number_dict = {
'A': [2, 1], '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],
}
number_to_angle_dict = {
1: 30, 2: 60, 3: 90, 4: 120, 5: 150,
6: 180, 7: 210, 8: 240, 9: 270, 0: 300,
}
# Make letter from number and number sequence in text.
def make_letter(number, number_sequence):
if number in (7, 9):
return number_to_letter_dict[number][number_sequence % 4]
else:
return number_to_letter_dict[number][number_sequence % 3]
# Normalize angle.
def normalize(number):
if number < 0:
return 360 + number
else:
return number - 360
def nums_to_text(numbers):
number_sequence = 0
message = ''
for index, number in enumerate(numbers):
if number == -1:
continue
if index == len(numbers) - 1 or number != numbers[index + 1]:
message += make_letter(number, number_sequence)
number_sequence = 0
else:
number_sequence += 1
return message
def text_to_nums(text):
numbers = []
- for letter in text:
+ for index,letter in enumerate(text):
upper_letter = letter.upper()
numbers.extend([letter_to_number_dict[upper_letter][0]]
* letter_to_number_dict[upper_letter][1])
+ if index != len(text) - 1 and letter == text[index + 1]:
+ numbers.extend([-1])
return numbers
def nums_to_angle(numbers):
angle = 0
for number in numbers:
angle += number_to_angle_dict[number]
return angle % 360
def angles_to_nums(angles):
numbers = []
for angle in angles:
if angle < 0 or angle > 359:
angle = normalize(angle)
if angle > 15 and angle <= 45:
numbers.extend([1])
elif angle > 45 and angle <= 75:
numbers.extend([2])
elif angle > 75 and angle <= 105:
numbers.extend([3])
elif angle > 105 and angle <= 135:
numbers.extend([4])
elif angle > 135 and angle <= 165:
numbers.extend([5])
elif angle > 165 and angle <= 195:
numbers.extend([6])
elif angle > 195 and angle <= 225:
numbers.extend([7])
elif angle > 225 and angle <= 255:
numbers.extend([8])
elif angle > 255 and angle <= 285:
numbers.extend([9])
elif angle > 285 and angle <= 315:
numbers.extend([0])
else:
continue
return numbers
def is_phone_tastic(word):
size = len(word)
angle = nums_to_angle(text_to_nums(word))
return normalize(angle) % size == 0
+

Огнян обнови решението на 02.11.2022 08:15 (преди над 1 година)

number_to_letter_dict = {
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: [' ', ' ', ' '],
}
letter_to_number_dict = {
'A': [2, 1], '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],
}
number_to_angle_dict = {
1: 30, 2: 60, 3: 90, 4: 120, 5: 150,
6: 180, 7: 210, 8: 240, 9: 270, 0: 300,
}
# Make letter from number and number sequence in text.
def make_letter(number, number_sequence):
if number in (7, 9):
return number_to_letter_dict[number][number_sequence % 4]
else:
return number_to_letter_dict[number][number_sequence % 3]
# Normalize angle.
def normalize(number):
if number < 0:
return 360 + number
else:
return number - 360
def nums_to_text(numbers):
number_sequence = 0
message = ''
for index, number in enumerate(numbers):
if number == -1:
continue
if index == len(numbers) - 1 or number != numbers[index + 1]:
message += make_letter(number, number_sequence)
number_sequence = 0
else:
number_sequence += 1
return message
def text_to_nums(text):
numbers = []
- for index,letter in enumerate(text):
+ for index, letter in enumerate(text):
upper_letter = letter.upper()
numbers.extend([letter_to_number_dict[upper_letter][0]]
* letter_to_number_dict[upper_letter][1])
- if index != len(text) - 1 and letter == text[index + 1]:
+ if index != len(text) - 1 and letter_to_number_dict[upper_letter][0] == letter_to_number_dict[text[index + 1].upper()][0]:
numbers.extend([-1])
return numbers
def nums_to_angle(numbers):
angle = 0
for number in numbers:
angle += number_to_angle_dict[number]
return angle % 360
def angles_to_nums(angles):
numbers = []
for angle in angles:
if angle < 0 or angle > 359:
angle = normalize(angle)
if angle > 15 and angle <= 45:
numbers.extend([1])
elif angle > 45 and angle <= 75:
numbers.extend([2])
elif angle > 75 and angle <= 105:
numbers.extend([3])
elif angle > 105 and angle <= 135:
numbers.extend([4])
elif angle > 135 and angle <= 165:
numbers.extend([5])
elif angle > 165 and angle <= 195:
numbers.extend([6])
elif angle > 195 and angle <= 225:
numbers.extend([7])
elif angle > 225 and angle <= 255:
numbers.extend([8])
elif angle > 255 and angle <= 285:
numbers.extend([9])
elif angle > 285 and angle <= 315:
numbers.extend([0])
else:
continue
return numbers
def is_phone_tastic(word):
size = len(word)
angle = nums_to_angle(text_to_nums(word))
return normalize(angle) % size == 0

Огнян обнови решението на 02.11.2022 08:39 (преди над 1 година)

number_to_letter_dict = {
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: [' ', ' ', ' '],
}
letter_to_number_dict = {
'A': [2, 1], '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],
}
number_to_angle_dict = {
1: 30, 2: 60, 3: 90, 4: 120, 5: 150,
6: 180, 7: 210, 8: 240, 9: 270, 0: 300,
}
# Make letter from number and number sequence in text.
def make_letter(number, number_sequence):
if number in (7, 9):
return number_to_letter_dict[number][number_sequence % 4]
else:
return number_to_letter_dict[number][number_sequence % 3]
# Normalize angle.
def normalize(number):
if number < 0:
return 360 + number
else:
return number - 360
def nums_to_text(numbers):
number_sequence = 0
message = ''
for index, number in enumerate(numbers):
if number == -1:
continue
if index == len(numbers) - 1 or number != numbers[index + 1]:
message += make_letter(number, number_sequence)
number_sequence = 0
else:
number_sequence += 1
return message
def text_to_nums(text):
numbers = []
for index, letter in enumerate(text):
upper_letter = letter.upper()
numbers.extend([letter_to_number_dict[upper_letter][0]]
* letter_to_number_dict[upper_letter][1])
if index != len(text) - 1 and letter_to_number_dict[upper_letter][0] == letter_to_number_dict[text[index + 1].upper()][0]:
numbers.extend([-1])
return numbers
def nums_to_angle(numbers):
angle = 0
for number in numbers:
+ if number == -1:
+ continue
angle += number_to_angle_dict[number]
return angle % 360
def angles_to_nums(angles):
numbers = []
for angle in angles:
if angle < 0 or angle > 359:
angle = normalize(angle)
if angle > 15 and angle <= 45:
numbers.extend([1])
elif angle > 45 and angle <= 75:
numbers.extend([2])
elif angle > 75 and angle <= 105:
numbers.extend([3])
elif angle > 105 and angle <= 135:
numbers.extend([4])
elif angle > 135 and angle <= 165:
numbers.extend([5])
elif angle > 165 and angle <= 195:
numbers.extend([6])
elif angle > 195 and angle <= 225:
numbers.extend([7])
elif angle > 225 and angle <= 255:
numbers.extend([8])
elif angle > 255 and angle <= 285:
numbers.extend([9])
elif angle > 285 and angle <= 315:
numbers.extend([0])
else:
continue
return numbers
def is_phone_tastic(word):
size = len(word)
angle = nums_to_angle(text_to_nums(word))
return normalize(angle) % size == 0
-

Огнян обнови решението на 02.11.2022 08:49 (преди над 1 година)

number_to_letter_dict = {
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: [' ', ' ', ' '],
}
letter_to_number_dict = {
'A': [2, 1], '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],
}
number_to_angle_dict = {
1: 30, 2: 60, 3: 90, 4: 120, 5: 150,
6: 180, 7: 210, 8: 240, 9: 270, 0: 300,
}
# Make letter from number and number sequence in text.
def make_letter(number, number_sequence):
if number in (7, 9):
return number_to_letter_dict[number][number_sequence % 4]
else:
return number_to_letter_dict[number][number_sequence % 3]
# Normalize angle.
def normalize(number):
if number < 0:
return 360 + number
else:
return number - 360
def nums_to_text(numbers):
number_sequence = 0
message = ''
for index, number in enumerate(numbers):
if number == -1:
continue
if index == len(numbers) - 1 or number != numbers[index + 1]:
message += make_letter(number, number_sequence)
number_sequence = 0
else:
number_sequence += 1
return message
def text_to_nums(text):
numbers = []
for index, letter in enumerate(text):
upper_letter = letter.upper()
numbers.extend([letter_to_number_dict[upper_letter][0]]
* letter_to_number_dict[upper_letter][1])
if index != len(text) - 1 and letter_to_number_dict[upper_letter][0] == letter_to_number_dict[text[index + 1].upper()][0]:
numbers.extend([-1])
return numbers
def nums_to_angle(numbers):
angle = 0
for number in numbers:
if number == -1:
continue
angle += number_to_angle_dict[number]
return angle % 360
def angles_to_nums(angles):
numbers = []
for angle in angles:
if angle < 0 or angle > 359:
angle = normalize(angle)
if angle > 15 and angle <= 45:
numbers.extend([1])
elif angle > 45 and angle <= 75:
numbers.extend([2])
elif angle > 75 and angle <= 105:
numbers.extend([3])
elif angle > 105 and angle <= 135:
numbers.extend([4])
elif angle > 135 and angle <= 165:
numbers.extend([5])
elif angle > 165 and angle <= 195:
numbers.extend([6])
elif angle > 195 and angle <= 225:
numbers.extend([7])
elif angle > 225 and angle <= 255:
numbers.extend([8])
elif angle > 255 and angle <= 285:
numbers.extend([9])
elif angle > 285 and angle <= 315:
numbers.extend([0])
else:
continue
return numbers
def is_phone_tastic(word):
size = len(word)
angle = nums_to_angle(text_to_nums(word))
return normalize(angle) % size == 0
+

Огнян обнови решението на 02.11.2022 08:58 (преди над 1 година)

number_to_letter_dict = {
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: [' ', ' ', ' '],
}
letter_to_number_dict = {
'A': [2, 1], '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],
}
number_to_angle_dict = {
1: 30, 2: 60, 3: 90, 4: 120, 5: 150,
6: 180, 7: 210, 8: 240, 9: 270, 0: 300,
}
# Make letter from number and number sequence in text.
def make_letter(number, number_sequence):
if number in (7, 9):
return number_to_letter_dict[number][number_sequence % 4]
else:
return number_to_letter_dict[number][number_sequence % 3]
# Normalize angle.
def normalize(number):
if number < 0:
return 360 + number
else:
return number - 360
def nums_to_text(numbers):
number_sequence = 0
message = ''
for index, number in enumerate(numbers):
if number == -1:
continue
if index == len(numbers) - 1 or number != numbers[index + 1]:
message += make_letter(number, number_sequence)
number_sequence = 0
else:
number_sequence += 1
return message
def text_to_nums(text):
numbers = []
for index, letter in enumerate(text):
upper_letter = letter.upper()
numbers.extend([letter_to_number_dict[upper_letter][0]]
* letter_to_number_dict[upper_letter][1])
- if index != len(text) - 1 and letter_to_number_dict[upper_letter][0] == letter_to_number_dict[text[index + 1].upper()][0]:
+ if index != len(text) - 1 and \
+ letter_to_number_dict[upper_letter][0] == \
+ letter_to_number_dict[text[index + 1].upper()][0]:
numbers.extend([-1])
return numbers
def nums_to_angle(numbers):
angle = 0
for number in numbers:
if number == -1:
continue
angle += number_to_angle_dict[number]
return angle % 360
def angles_to_nums(angles):
numbers = []
for angle in angles:
if angle < 0 or angle > 359:
angle = normalize(angle)
if angle > 15 and angle <= 45:
numbers.extend([1])
elif angle > 45 and angle <= 75:
numbers.extend([2])
elif angle > 75 and angle <= 105:
numbers.extend([3])
elif angle > 105 and angle <= 135:
numbers.extend([4])
elif angle > 135 and angle <= 165:
numbers.extend([5])
elif angle > 165 and angle <= 195:
numbers.extend([6])
elif angle > 195 and angle <= 225:
numbers.extend([7])
elif angle > 225 and angle <= 255:
numbers.extend([8])
elif angle > 255 and angle <= 285:
numbers.extend([9])
elif angle > 285 and angle <= 315:
numbers.extend([0])
else:
continue
return numbers
def is_phone_tastic(word):
size = len(word)
angle = nums_to_angle(text_to_nums(word))
return normalize(angle) % size == 0

Огнян обнови решението на 02.11.2022 22:15 (преди над 1 година)

number_to_letter_dict = {
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: [' ', ' ', ' '],
}
letter_to_number_dict = {
'A': [2, 1], '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],
}
number_to_angle_dict = {
1: 30, 2: 60, 3: 90, 4: 120, 5: 150,
6: 180, 7: 210, 8: 240, 9: 270, 0: 300,
}
# Make letter from number and number sequence in text.
def make_letter(number, number_sequence):
if number in (7, 9):
return number_to_letter_dict[number][number_sequence % 4]
else:
return number_to_letter_dict[number][number_sequence % 3]
# Normalize angle.
def normalize(number):
if number < 0:
return 360 + number
else:
return number - 360
def nums_to_text(numbers):
number_sequence = 0
message = ''
for index, number in enumerate(numbers):
if number == -1:
continue
if index == len(numbers) - 1 or number != numbers[index + 1]:
message += make_letter(number, number_sequence)
number_sequence = 0
else:
number_sequence += 1
return message
def text_to_nums(text):
numbers = []
for index, letter in enumerate(text):
upper_letter = letter.upper()
numbers.extend([letter_to_number_dict[upper_letter][0]]
* letter_to_number_dict[upper_letter][1])
if index != len(text) - 1 and \
letter_to_number_dict[upper_letter][0] == \
letter_to_number_dict[text[index + 1].upper()][0]:
numbers.extend([-1])
return numbers
def nums_to_angle(numbers):
angle = 0
for number in numbers:
if number == -1:
continue
angle += number_to_angle_dict[number]
return angle % 360
def angles_to_nums(angles):
numbers = []
for angle in angles:
if angle < 0 or angle > 359:
angle = normalize(angle)
if angle > 15 and angle <= 45:
numbers.extend([1])
elif angle > 45 and angle <= 75:
numbers.extend([2])
elif angle > 75 and angle <= 105:
numbers.extend([3])
elif angle > 105 and angle <= 135:
numbers.extend([4])
elif angle > 135 and angle <= 165:
numbers.extend([5])
elif angle > 165 and angle <= 195:
numbers.extend([6])
elif angle > 195 and angle <= 225:
numbers.extend([7])
elif angle > 225 and angle <= 255:
numbers.extend([8])
elif angle > 255 and angle <= 285:
numbers.extend([9])
elif angle > 285 and angle <= 315:
numbers.extend([0])
else:
continue
return numbers
def is_phone_tastic(word):
+ if word == '':
+ return False
size = len(word)
angle = nums_to_angle(text_to_nums(word))
- return normalize(angle) % size == 0
+ if angle < 0 or angle > 359:
+ angle = normalize(angle)
+ return angle % size == 0

Огнян обнови решението на 03.11.2022 10:47 (преди над 1 година)

number_to_letter_dict = {
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: [' ', ' ', ' '],
}
letter_to_number_dict = {
'A': [2, 1], '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],
}
number_to_angle_dict = {
1: 30, 2: 60, 3: 90, 4: 120, 5: 150,
6: 180, 7: 210, 8: 240, 9: 270, 0: 300,
}
# Make letter from number and number sequence in text.
def make_letter(number, number_sequence):
if number in (7, 9):
return number_to_letter_dict[number][number_sequence % 4]
else:
return number_to_letter_dict[number][number_sequence % 3]
# Normalize angle.
def normalize(number):
if number < 0:
return 360 + number
else:
return number - 360
def nums_to_text(numbers):
number_sequence = 0
message = ''
for index, number in enumerate(numbers):
if number == -1:
continue
if index == len(numbers) - 1 or number != numbers[index + 1]:
message += make_letter(number, number_sequence)
number_sequence = 0
else:
number_sequence += 1
return message
def text_to_nums(text):
numbers = []
for index, letter in enumerate(text):
upper_letter = letter.upper()
numbers.extend([letter_to_number_dict[upper_letter][0]]
* letter_to_number_dict[upper_letter][1])
if index != len(text) - 1 and \
letter_to_number_dict[upper_letter][0] == \
letter_to_number_dict[text[index + 1].upper()][0]:
numbers.extend([-1])
return numbers
def nums_to_angle(numbers):
angle = 0
for number in numbers:
if number == -1:
continue
angle += number_to_angle_dict[number]
return angle % 360
def angles_to_nums(angles):
numbers = []
for angle in angles:
if angle < 0 or angle > 359:
angle = normalize(angle)
if angle > 15 and angle <= 45:
numbers.extend([1])
elif angle > 45 and angle <= 75:
numbers.extend([2])
elif angle > 75 and angle <= 105:
numbers.extend([3])
elif angle > 105 and angle <= 135:
numbers.extend([4])
elif angle > 135 and angle <= 165:
numbers.extend([5])
elif angle > 165 and angle <= 195:
numbers.extend([6])
elif angle > 195 and angle <= 225:
numbers.extend([7])
elif angle > 225 and angle <= 255:
numbers.extend([8])
elif angle > 255 and angle <= 285:
numbers.extend([9])
elif angle > 285 and angle <= 315:
numbers.extend([0])
else:
continue
return numbers
def is_phone_tastic(word):
if word == '':
return False
size = len(word)
angle = nums_to_angle(text_to_nums(word))
if angle < 0 or angle > 359:
angle = normalize(angle)
return angle % size == 0
-

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

number_to_letter_dict = {
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: [' ', ' ', ' '],
}
letter_to_number_dict = {
'A': [2, 1], '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],
}
number_to_angle_dict = {
1: 30, 2: 60, 3: 90, 4: 120, 5: 150,
6: 180, 7: 210, 8: 240, 9: 270, 0: 300,
}
# Make letter from number and number sequence in text.
def make_letter(number, number_sequence):
if number in (7, 9):
return number_to_letter_dict[number][number_sequence % 4]
else:
return number_to_letter_dict[number][number_sequence % 3]
# Normalize angle.
def normalize(number):
if number < 0:
return 360 + number
else:
return number - 360
def nums_to_text(numbers):
number_sequence = 0
message = ''
for index, number in enumerate(numbers):
if number == -1:
continue
if index == len(numbers) - 1 or number != numbers[index + 1]:
message += make_letter(number, number_sequence)
number_sequence = 0
else:
number_sequence += 1
return message
def text_to_nums(text):
numbers = []
- for index, letter in enumerate(text):
- upper_letter = letter.upper()
- numbers.extend([letter_to_number_dict[upper_letter][0]]
- * letter_to_number_dict[upper_letter][1])
+ for index, letter in enumerate(text.upper()):
+
+ numbers.extend([letter_to_number_dict[letter][0]]
+ * letter_to_number_dict[letter][1])
if index != len(text) - 1 and \
- letter_to_number_dict[upper_letter][0] == \
+ letter_to_number_dict[letter][0] == \
letter_to_number_dict[text[index + 1].upper()][0]:
- numbers.extend([-1])
+ numbers.append(-1)
return numbers
def nums_to_angle(numbers):
angle = 0
for number in numbers:
if number == -1:
continue
angle += number_to_angle_dict[number]
return angle % 360
def angles_to_nums(angles):
numbers = []
for angle in angles:
if angle < 0 or angle > 359:
angle = normalize(angle)
- if angle > 15 and angle <= 45:
- numbers.extend([1])
- elif angle > 45 and angle <= 75:
- numbers.extend([2])
- elif angle > 75 and angle <= 105:
- numbers.extend([3])
- elif angle > 105 and angle <= 135:
- numbers.extend([4])
- elif angle > 135 and angle <= 165:
- numbers.extend([5])
- elif angle > 165 and angle <= 195:
- numbers.extend([6])
- elif angle > 195 and angle <= 225:
- numbers.extend([7])
- elif angle > 225 and angle <= 255:
- numbers.extend([8])
- elif angle > 255 and angle <= 285:
- numbers.extend([9])
- elif angle > 285 and angle <= 315:
- numbers.extend([0])
- else:
- continue
+ if 15 < angle <= 45:
+ numbers.append(1)
+ elif 45 < angle <= 75:
+ numbers.append(2)
+ elif 75 < angle <= 105:
+ numbers.append(3)
+ elif 105 < angle <= 135:
+ numbers.append(4)
+ elif 135 < angle <= 165:
+ numbers.append(5)
+ elif 165 < angle <= 195:
+ numbers.append(6)
+ elif 195 < angle <= 225:
+ numbers.append(7)
+ elif 225 < angle <= 255:
+ numbers.append(8)
+ elif 255 < angle <= 285:
+ numbers.append(9)
+ elif 285 < angle <= 315:
+ numbers.append(0)
return numbers
def is_phone_tastic(word):
- if word == '':
+ if not word:
return False
size = len(word)
- angle = nums_to_angle(text_to_nums(word))
- if angle < 0 or angle > 359:
- angle = normalize(angle)
+ angle = normalize(nums_to_angle(text_to_nums(word)))
return angle % size == 0
+

Огнян обнови решението на 03.11.2022 15:12 (преди над 1 година)

number_to_letter_dict = {
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: [' ', ' ', ' '],
}
letter_to_number_dict = {
'A': [2, 1], '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],
}
number_to_angle_dict = {
1: 30, 2: 60, 3: 90, 4: 120, 5: 150,
6: 180, 7: 210, 8: 240, 9: 270, 0: 300,
}
# Make letter from number and number sequence in text.
def make_letter(number, number_sequence):
if number in (7, 9):
return number_to_letter_dict[number][number_sequence % 4]
else:
return number_to_letter_dict[number][number_sequence % 3]
# Normalize angle.
def normalize(number):
if number < 0:
return 360 + number
else:
return number - 360
def nums_to_text(numbers):
number_sequence = 0
message = ''
for index, number in enumerate(numbers):
if number == -1:
continue
if index == len(numbers) - 1 or number != numbers[index + 1]:
message += make_letter(number, number_sequence)
number_sequence = 0
else:
number_sequence += 1
return message
def text_to_nums(text):
numbers = []
for index, letter in enumerate(text.upper()):
-
numbers.extend([letter_to_number_dict[letter][0]]
* letter_to_number_dict[letter][1])
if index != len(text) - 1 and \
letter_to_number_dict[letter][0] == \
letter_to_number_dict[text[index + 1].upper()][0]:
numbers.append(-1)
return numbers
def nums_to_angle(numbers):
angle = 0
for number in numbers:
if number == -1:
continue
angle += number_to_angle_dict[number]
return angle % 360
def angles_to_nums(angles):
numbers = []
for angle in angles:
if angle < 0 or angle > 359:
angle = normalize(angle)
if 15 < angle <= 45:
numbers.append(1)
elif 45 < angle <= 75:
numbers.append(2)
elif 75 < angle <= 105:
numbers.append(3)
elif 105 < angle <= 135:
numbers.append(4)
elif 135 < angle <= 165:
numbers.append(5)
elif 165 < angle <= 195:
numbers.append(6)
elif 195 < angle <= 225:
numbers.append(7)
elif 225 < angle <= 255:
numbers.append(8)
elif 255 < angle <= 285:
numbers.append(9)
elif 285 < angle <= 315:
numbers.append(0)
return numbers
def is_phone_tastic(word):
if not word:
return False
size = len(word)
- angle = normalize(nums_to_angle(text_to_nums(word)))
+ angle = nums_to_angle(text_to_nums(word))
return angle % size == 0
-