Private & Protected в ООП

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

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

Решение на Телефонна любов от Лиляна Белчева

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

Към профила на Лиляна Белчева

Резултати

  • 10 точки от тестове
  • 0 бонус точки
  • 10 точки общо
  • 37 успешни тест(а)
  • 0 неуспешни тест(а)

Код

from itertools import repeat
keyboard = {
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']
}
angles = {
0: 300,
1: 30,
2: 60,
3: 90,
4: 120,
5: 150,
6: 180,
7: 210,
8: 240,
9: 270,
}
def rounded_number(number):
base = 30
result = number % base
if result + result > base:
return number + base - result
else:
return number - result
def normalize_angle(angle):
while angle < 0:
angle += 360
while angle > 359:
angle -= 360
return angle
def nums_to_text(nums):
value_list = list(keyboard.values())
output = ''
i, counter = 0, 0
for digit in nums:
if len(nums) == 1:
return value_list[abs(digit)][0]
if i < len(nums) - 1 and digit == nums[i+1]:
counter += 1
else:
if digit == -1:
counter = 0
i += 1
continue
elif digit == 0:
counter = 0
elif digit in [2, 3, 4, 5, 6, 8]:
counter = counter % 3
elif digit in [7, 9]:
counter = counter % 4
output += value_list[digit][counter]
counter = 0
i += 1
return output
def text_to_nums(text):
output = []
if len(text) == 0:
return output
for letter in text:
for key, value in keyboard.items():
if letter.upper() in value:
if len(output) > 0 and key == output[len(output)-1]:
output.append(-1)
ind = value.index(letter.upper()) + 1
output.extend(repeat(key, ind))
return output
def nums_to_angle(nums):
sum = 0
angles_values = list(angles.values())
for digit in nums:
if digit in angles.keys():
sum += angles_values[digit]
return normalize_angle(sum)
def angles_to_nums(list_angles):
disk_num = []
rounded = 0
for angle in list_angles:
if angle < 0 or angle > 359:
angle = normalize_angle(angle)
if angle % 30 != 0:
rounded = rounded_number(angle)
else:
rounded = angle
for key, value in angles.items():
if rounded == value:
disk_num.append(key)
return disk_num
def is_phone_tastic(word):
angle = nums_to_angle(text_to_nums(word))
if len(word) == 0:
return False
if normalize_angle(angle) % len(word) == 0:
return True
else:
return False

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

.....................................
----------------------------------------------------------------------
Ran 37 tests in 0.424s

OK

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

Лиляна обнови решението на 02.11.2022 19:18 (преди над 2 години)

+from itertools import repeat
+
+keyboard = {
+ 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']
+}
+
+angles = {
+ 0: 300,
+ 1: 30,
+ 2: 60,
+ 3: 90,
+ 4: 120,
+ 5: 150,
+ 6: 180,
+ 7: 210,
+ 8: 240,
+ 9: 270,
+}
+
+
+def rounded_number(number):
+ base = 30
+ result = number % base
+
+ if result + result > base:
+ return number + base - result
+ else:
+ return number - result
+
+def normalize_angle(angle):
+ while angle < 0:
+ angle += 360
+ while angle > 359:
+ angle -= 360
+ return angle
+
+def nums_to_text(nums):
+ value_list = list(keyboard.values())
+ output = ''
+ i, counter = 0, 0
+
+ for digit in nums:
+ if len(nums) == 1:
+ return value_list[abs(digit)][0]
+
+ if i < len(nums) - 1 and digit == nums[i+1]:
+ counter += 1
+ else:
+ if digit in [2, 3, 4, 5, 6, 7, 8, 9]:
+ counter = counter % 3
+ output += value_list[digit][counter]
+ elif digit == 0:
+ output += (counter+1) * value_list[digit][0]
+ counter = 0
+ i += 1
+ return output
+
+def text_to_nums(text):
+ output = []
+
+ if len(text) == 0:
+ return [1]
+
+ for letter in text:
+ for key, value in keyboard.items():
+ if letter.upper() in value:
+ if len(output) > 0 and key == output[len(output)-1]:
+ output.append(-1)
+ ind = value.index(letter.upper()) + 1
+ output.extend(repeat(key, ind))
+ return output
+
+def nums_to_angle(nums):
+ sum = 0
+ angles_values = list(angles.values())
+
+ for digit in nums:
+ if digit in angles.keys():
+ sum += angles_values[digit]
+ return normalize_angle(sum)
+
+def angles_to_nums(list_angles):
+ disk_num = []
+ rounded = 0
+
+ for angle in list_angles:
+ if angle < 0 or angle > 359:
+ angle = normalize_angle(angle)
+ if angle % 30 != 0:
+ rounded = rounded_number(angle)
+ else:
+ rounded = angle
+
+ for key, value in angles.items():
+ if rounded == value:
+ disk_num.append(key)
+ return disk_num
+
+def is_phone_tastic(word):
+ angle = nums_to_angle(text_to_nums(word))
+
+ if normalize_angle(angle) % len(word) == 0:
+ return True
+ else:
+ return False

Лиляна обнови решението на 02.11.2022 19:39 (преди над 2 години)

from itertools import repeat
keyboard = {
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']
}
angles = {
0: 300,
1: 30,
2: 60,
3: 90,
4: 120,
5: 150,
6: 180,
7: 210,
8: 240,
9: 270,
}
def rounded_number(number):
base = 30
result = number % base
if result + result > base:
return number + base - result
else:
return number - result
def normalize_angle(angle):
while angle < 0:
angle += 360
while angle > 359:
angle -= 360
return angle
def nums_to_text(nums):
value_list = list(keyboard.values())
output = ''
i, counter = 0, 0
for digit in nums:
if len(nums) == 1:
return value_list[abs(digit)][0]
if i < len(nums) - 1 and digit == nums[i+1]:
counter += 1
else:
- if digit in [2, 3, 4, 5, 6, 7, 8, 9]:
+ if digit in [2, 3, 4, 5, 6, 8]:
counter = counter % 3
output += value_list[digit][counter]
+ elif digit in [7, 9]:
+ counter = counter % 4
+ output += value_list[digit][counter]
elif digit == 0:
output += (counter+1) * value_list[digit][0]
counter = 0
i += 1
return output
def text_to_nums(text):
output = []
if len(text) == 0:
return [1]
for letter in text:
for key, value in keyboard.items():
if letter.upper() in value:
if len(output) > 0 and key == output[len(output)-1]:
output.append(-1)
ind = value.index(letter.upper()) + 1
output.extend(repeat(key, ind))
return output
def nums_to_angle(nums):
sum = 0
angles_values = list(angles.values())
for digit in nums:
if digit in angles.keys():
sum += angles_values[digit]
return normalize_angle(sum)
def angles_to_nums(list_angles):
disk_num = []
rounded = 0
for angle in list_angles:
if angle < 0 or angle > 359:
angle = normalize_angle(angle)
if angle % 30 != 0:
rounded = rounded_number(angle)
else:
rounded = angle
for key, value in angles.items():
if rounded == value:
disk_num.append(key)
return disk_num
def is_phone_tastic(word):
angle = nums_to_angle(text_to_nums(word))
+ lenght_word = len(word) - word.count(' ')
- if normalize_angle(angle) % len(word) == 0:
+ if normalize_angle(angle) % lenght_word == 0:
return True
else:
- return False
+ return False

Лиляна обнови решението на 02.11.2022 23:05 (преди над 2 години)

from itertools import repeat
keyboard = {
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']
}
angles = {
0: 300,
1: 30,
2: 60,
3: 90,
4: 120,
5: 150,
6: 180,
7: 210,
8: 240,
9: 270,
}
def rounded_number(number):
base = 30
result = number % base
if result + result > base:
return number + base - result
else:
return number - result
def normalize_angle(angle):
while angle < 0:
angle += 360
while angle > 359:
angle -= 360
return angle
def nums_to_text(nums):
value_list = list(keyboard.values())
output = ''
i, counter = 0, 0
for digit in nums:
if len(nums) == 1:
return value_list[abs(digit)][0]
if i < len(nums) - 1 and digit == nums[i+1]:
counter += 1
else:
- if digit in [2, 3, 4, 5, 6, 8]:
+ if digit == -1:
+ counter = 0
+ i += 1
+ continue
+ elif digit == 0:
+ counter = 0
+ elif digit in [2, 3, 4, 5, 6, 8]:
counter = counter % 3
- output += value_list[digit][counter]
elif digit in [7, 9]:
counter = counter % 4
- output += value_list[digit][counter]
- elif digit == 0:
- output += (counter+1) * value_list[digit][0]
+ output += value_list[digit][counter]
counter = 0
i += 1
return output
def text_to_nums(text):
output = []
if len(text) == 0:
- return [1]
+ return output
for letter in text:
for key, value in keyboard.items():
if letter.upper() in value:
if len(output) > 0 and key == output[len(output)-1]:
output.append(-1)
ind = value.index(letter.upper()) + 1
output.extend(repeat(key, ind))
return output
def nums_to_angle(nums):
sum = 0
angles_values = list(angles.values())
for digit in nums:
if digit in angles.keys():
sum += angles_values[digit]
return normalize_angle(sum)
def angles_to_nums(list_angles):
disk_num = []
rounded = 0
for angle in list_angles:
if angle < 0 or angle > 359:
angle = normalize_angle(angle)
if angle % 30 != 0:
rounded = rounded_number(angle)
else:
rounded = angle
for key, value in angles.items():
if rounded == value:
disk_num.append(key)
return disk_num
def is_phone_tastic(word):
+ if len(word) == 0:
+ return False
+
angle = nums_to_angle(text_to_nums(word))
lenght_word = len(word) - word.count(' ')
if normalize_angle(angle) % lenght_word == 0:
return True
else:
- return False
+ return False

Лиляна обнови решението на 03.11.2022 10:30 (преди над 2 години)

from itertools import repeat
keyboard = {
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']
}
angles = {
0: 300,
1: 30,
2: 60,
3: 90,
4: 120,
5: 150,
6: 180,
7: 210,
8: 240,
9: 270,
}
def rounded_number(number):
base = 30
result = number % base
if result + result > base:
return number + base - result
else:
return number - result
def normalize_angle(angle):
while angle < 0:
angle += 360
while angle > 359:
angle -= 360
return angle
def nums_to_text(nums):
value_list = list(keyboard.values())
output = ''
i, counter = 0, 0
for digit in nums:
if len(nums) == 1:
return value_list[abs(digit)][0]
if i < len(nums) - 1 and digit == nums[i+1]:
counter += 1
else:
if digit == -1:
counter = 0
i += 1
continue
elif digit == 0:
counter = 0
elif digit in [2, 3, 4, 5, 6, 8]:
counter = counter % 3
elif digit in [7, 9]:
counter = counter % 4
output += value_list[digit][counter]
counter = 0
i += 1
return output
def text_to_nums(text):
output = []
if len(text) == 0:
return output
for letter in text:
for key, value in keyboard.items():
if letter.upper() in value:
if len(output) > 0 and key == output[len(output)-1]:
output.append(-1)
ind = value.index(letter.upper()) + 1
output.extend(repeat(key, ind))
return output
def nums_to_angle(nums):
sum = 0
angles_values = list(angles.values())
for digit in nums:
if digit in angles.keys():
sum += angles_values[digit]
return normalize_angle(sum)
def angles_to_nums(list_angles):
disk_num = []
rounded = 0
for angle in list_angles:
if angle < 0 or angle > 359:
angle = normalize_angle(angle)
if angle % 30 != 0:
rounded = rounded_number(angle)
else:
rounded = angle
for key, value in angles.items():
if rounded == value:
disk_num.append(key)
return disk_num
def is_phone_tastic(word):
+ angle = nums_to_angle(text_to_nums(word))
+
if len(word) == 0:
return False
- angle = nums_to_angle(text_to_nums(word))
- lenght_word = len(word) - word.count(' ')
-
- if normalize_angle(angle) % lenght_word == 0:
+ if normalize_angle(angle) % len(word) == 0:
return True
else:
- return False
+ return False