git hooks

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

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

Решение на Пет функции от Никола Ненков

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

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

Резултати

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

Код

from functools import cmp_to_key
from itertools import groupby
import re
BULGARIAN_ALPHABET = {
'а', 'б', 'в', 'г', 'д', 'е', 'ж', 'з', 'и', 'й', 'к', 'л', 'м', 'н', 'о',
'п', 'р', 'с', 'т', 'у', 'ф', 'х', 'ц', 'ч', 'ш', 'щ', 'ъ', 'ь', 'ю', 'я',
}
def is_pangram(sentence):
return all(letter in sentence.lower() for letter in BULGARIAN_ALPHABET)
def char_histogram(text):
return dict([character, text.count(character)] for character in text)
def sort_by(func, arguments):
return sorted(arguments, key=cmp_to_key(func))
def group_by_type(dictionary):
type_key_value = {}
for key, value in dictionary.items():
type_key_value.setdefault(type(key), {})
type_key_value[type(key)][key] = value
return type_key_value
def only_letters_ignore_case_and_order(text):
return ''.join(sorted(re.sub('[\W\d_]+', '', text).lower()))
def anagrams(words):
sorted_words = sorted(words, key=only_letters_ignore_case_and_order)
grouped_words = groupby(sorted_words, only_letters_ignore_case_and_order)
return [list(group) for _, group in grouped_words]

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

................
----------------------------------------------------------------------
Ran 16 tests in 0.010s

OK

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

Никола обнови решението на 16.03.2014 15:46 (преди около 10 години)

+from functools import cmp_to_key
+from itertools import groupby
+import re
+
+
+def bulgarian_alphabet():
+ slavic_alphabet = {chr(letter) for letter in range(ord('а'), ord('я') + 1)}
+ slavic_alphabet.remove('ы')
+ slavic_alphabet.remove('э')
+ return slavic_alphabet
+
+
+def is_pangram(sentence):
+ return all(letter in sentence.lower() for letter in bulgarian_alphabet())
+
+
+def char_histogram(text):
+ return dict([character, text.count(character)] for character in text)
+
+
+def sort_by(func, arguments):
+ return sorted(arguments, key=cmp_to_key(func))
+
+
+def group_by_type(dictionary):
+ grouped_pairs = dict([type(key), {}] for key in dictionary)
+ for key, value in dictionary.items():
+ grouped_pairs[type(key)][key] = value
+ return grouped_pairs
+
+
+def histogram_as_string(text):
+ string_histogram = str(char_histogram(text))
+ only_letters = sorted(re.sub('[\W_0-9]', '', string_histogram).lower())
+ return ''.join(only_letters)
+
+
+def anagrams(words):
+ sorted_words = sorted(words, key=histogram_as_string)
+ return [list(g) for _, g in groupby(sorted_words, histogram_as_string)]
+
+ slavic_alphabet = [chr(letter) for letter in range(ord('а'), ord('я') + 1)]

Никола обнови решението на 16.03.2014 15:50 (преди около 10 години)

from functools import cmp_to_key
from itertools import groupby
import re
def bulgarian_alphabet():
slavic_alphabet = {chr(letter) for letter in range(ord('а'), ord('я') + 1)}
slavic_alphabet.remove('ы')
slavic_alphabet.remove('э')
return slavic_alphabet
def is_pangram(sentence):
return all(letter in sentence.lower() for letter in bulgarian_alphabet())
def char_histogram(text):
return dict([character, text.count(character)] for character in text)
def sort_by(func, arguments):
return sorted(arguments, key=cmp_to_key(func))
def group_by_type(dictionary):
grouped_pairs = dict([type(key), {}] for key in dictionary)
for key, value in dictionary.items():
grouped_pairs[type(key)][key] = value
return grouped_pairs
def histogram_as_string(text):
string_histogram = str(char_histogram(text))
only_letters = sorted(re.sub('[\W_0-9]', '', string_histogram).lower())
return ''.join(only_letters)
def anagrams(words):
sorted_words = sorted(words, key=histogram_as_string)
return [list(g) for _, g in groupby(sorted_words, histogram_as_string)]
-
- slavic_alphabet = [chr(letter) for letter in range(ord('а'), ord('я') + 1)]

Никола обнови решението на 16.03.2014 15:52 (преди около 10 години)

from functools import cmp_to_key
from itertools import groupby
import re
def bulgarian_alphabet():
slavic_alphabet = {chr(letter) for letter in range(ord('а'), ord('я') + 1)}
slavic_alphabet.remove('ы')
slavic_alphabet.remove('э')
return slavic_alphabet
def is_pangram(sentence):
return all(letter in sentence.lower() for letter in bulgarian_alphabet())
def char_histogram(text):
return dict([character, text.count(character)] for character in text)
def sort_by(func, arguments):
return sorted(arguments, key=cmp_to_key(func))
def group_by_type(dictionary):
grouped_pairs = dict([type(key), {}] for key in dictionary)
for key, value in dictionary.items():
grouped_pairs[type(key)][key] = value
return grouped_pairs
def histogram_as_string(text):
string_histogram = str(char_histogram(text))
only_letters = sorted(re.sub('[\W_0-9]', '', string_histogram).lower())
return ''.join(only_letters)
def anagrams(words):
sorted_words = sorted(words, key=histogram_as_string)
- return [list(g) for _, g in groupby(sorted_words, histogram_as_string)]
+ grouped = groupby(sorted_words, histogram_as_string)
+ return [list(group) for _, group in grouped]

  • по-добрият вариант е да имаш константа, в която да пазиш българската азбука; не е дълга и няма да се промени в бъдеще, така че няма смисъл да се генерира с фунцкия

  • и така става dict([type(key), {}] for key in dictionary), но можеш да разгледаш хитринките за идеи за по-добър вариант

  • с това string_histogram = str(char_histogram(text)); only_letters = sorted(re.sub('[\W_0-9]', '', string_histogram).lower()) премахваш повтарящите се символи, но минаваш през повече представяния от колкото ти са нужни; т.е. правиш лесното сложно

  • разцъкай anagrams с думи с главни и малки букви, особено такива, в които имаш една и съща буква и lowercase, и uppercase

Благодаря за feedback-a.

  • Наистина не исках да я hardcode-вам, но добре. Btw дали няма да се промени в бъдеще като се има предвид колко безполезна е ь не се знае :)

  • Вярно, нямам идея как го пропуснах, въпреки че го видях 10 пъти.

  • С това не махам повтарящи се символи, а символи, които не са букви. Напълно съм убеден, че има по-лесен и ясен начин, но не го видях.

  • Не съм сигурен какво имаш предвид. Опитах ['a', 'A'], ['aA', 'Aa'], ['ab', 'AB'] и изглежда работят нормално. Може ли обясниш по-точно какъв е проблемът.

Никола обнови решението на 16.03.2014 18:44 (преди около 10 години)

from functools import cmp_to_key
from itertools import groupby
import re
-def bulgarian_alphabet():
- slavic_alphabet = {chr(letter) for letter in range(ord('а'), ord('я') + 1)}
- slavic_alphabet.remove('ы')
- slavic_alphabet.remove('э')
- return slavic_alphabet
+BULGARIAN_ALPHABET = {
+ 'а', 'б', 'в', 'г', 'д', 'е', 'ж', 'з', 'и', 'й', 'к', 'л', 'м', 'н', 'о',
+ 'п', 'р', 'с', 'т', 'у', 'ф', 'х', 'ц', 'ч', 'ш', 'щ', 'ъ', 'ь', 'ю', 'я',
+}
def is_pangram(sentence):
- return all(letter in sentence.lower() for letter in bulgarian_alphabet())
+ return all(letter in sentence.lower() for letter in BULGARIAN_ALPHABET)
def char_histogram(text):
return dict([character, text.count(character)] for character in text)
def sort_by(func, arguments):
return sorted(arguments, key=cmp_to_key(func))
def group_by_type(dictionary):
- grouped_pairs = dict([type(key), {}] for key in dictionary)
+ grouped_pairs = {}
for key, value in dictionary.items():
+ grouped_pairs.setdefault(type(key), {})
grouped_pairs[type(key)][key] = value
return grouped_pairs
+
+
+def are_anagrams(first_text, second_text):
+ first_text_letters = re.findall('\w', first_text)
+ second_text_letters = re.findall('\w', second_text)
+ return sorted(first_text_letters) == sorted(second_text_letters)
def histogram_as_string(text):
string_histogram = str(char_histogram(text))
only_letters = sorted(re.sub('[\W_0-9]', '', string_histogram).lower())
return ''.join(only_letters)
def anagrams(words):
sorted_words = sorted(words, key=histogram_as_string)
grouped = groupby(sorted_words, histogram_as_string)
return [list(group) for _, group in grouped]

Никола обнови решението на 16.03.2014 18:46 (преди около 10 години)

from functools import cmp_to_key
from itertools import groupby
import re
BULGARIAN_ALPHABET = {
'а', 'б', 'в', 'г', 'д', 'е', 'ж', 'з', 'и', 'й', 'к', 'л', 'м', 'н', 'о',
'п', 'р', 'с', 'т', 'у', 'ф', 'х', 'ц', 'ч', 'ш', 'щ', 'ъ', 'ь', 'ю', 'я',
}
def is_pangram(sentence):
return all(letter in sentence.lower() for letter in BULGARIAN_ALPHABET)
def char_histogram(text):
return dict([character, text.count(character)] for character in text)
def sort_by(func, arguments):
return sorted(arguments, key=cmp_to_key(func))
def group_by_type(dictionary):
grouped_pairs = {}
for key, value in dictionary.items():
grouped_pairs.setdefault(type(key), {})
grouped_pairs[type(key)][key] = value
return grouped_pairs
-def are_anagrams(first_text, second_text):
- first_text_letters = re.findall('\w', first_text)
- second_text_letters = re.findall('\w', second_text)
- return sorted(first_text_letters) == sorted(second_text_letters)
-
-
def histogram_as_string(text):
string_histogram = str(char_histogram(text))
only_letters = sorted(re.sub('[\W_0-9]', '', string_histogram).lower())
return ''.join(only_letters)
def anagrams(words):
sorted_words = sorted(words, key=histogram_as_string)
grouped = groupby(sorted_words, histogram_as_string)
return [list(group) for _, group in grouped]

Никола обнови решението на 19.03.2014 12:55 (преди около 10 години)

from functools import cmp_to_key
from itertools import groupby
import re
BULGARIAN_ALPHABET = {
'а', 'б', 'в', 'г', 'д', 'е', 'ж', 'з', 'и', 'й', 'к', 'л', 'м', 'н', 'о',
'п', 'р', 'с', 'т', 'у', 'ф', 'х', 'ц', 'ч', 'ш', 'щ', 'ъ', 'ь', 'ю', 'я',
}
def is_pangram(sentence):
return all(letter in sentence.lower() for letter in BULGARIAN_ALPHABET)
def char_histogram(text):
return dict([character, text.count(character)] for character in text)
def sort_by(func, arguments):
return sorted(arguments, key=cmp_to_key(func))
def group_by_type(dictionary):
grouped_pairs = {}
for key, value in dictionary.items():
grouped_pairs.setdefault(type(key), {})
grouped_pairs[type(key)][key] = value
return grouped_pairs
-def histogram_as_string(text):
- string_histogram = str(char_histogram(text))
- only_letters = sorted(re.sub('[\W_0-9]', '', string_histogram).lower())
- return ''.join(only_letters)
+def only_letters_ignore_case_and_order(text):
+ return ''.join(sorted(re.sub('[\W\d_]', '', text).lower()))
def anagrams(words):
- sorted_words = sorted(words, key=histogram_as_string)
- grouped = groupby(sorted_words, histogram_as_string)
+ sorted_words = sorted(words, key=only_letters_ignore_case_and_order)
+ grouped = groupby(sorted_words, only_letters_ignore_case_and_order)
return [list(group) for _, group in grouped]

Сега го видях. Предполагам преди това дотолкова съм искал да използвам char_histogram поради някаква причина, че съм минал през няколко глупави представяния, само за да го включа някакси. Все още не разбирам проблема с главните и малки букви обаче.

Никола обнови решението на 19.03.2014 13:40 (преди около 10 години)

from functools import cmp_to_key
from itertools import groupby
import re
BULGARIAN_ALPHABET = {
'а', 'б', 'в', 'г', 'д', 'е', 'ж', 'з', 'и', 'й', 'к', 'л', 'м', 'н', 'о',
'п', 'р', 'с', 'т', 'у', 'ф', 'х', 'ц', 'ч', 'ш', 'щ', 'ъ', 'ь', 'ю', 'я',
}
def is_pangram(sentence):
return all(letter in sentence.lower() for letter in BULGARIAN_ALPHABET)
def char_histogram(text):
return dict([character, text.count(character)] for character in text)
def sort_by(func, arguments):
return sorted(arguments, key=cmp_to_key(func))
def group_by_type(dictionary):
- grouped_pairs = {}
+ type_key_value = {}
for key, value in dictionary.items():
- grouped_pairs.setdefault(type(key), {})
- grouped_pairs[type(key)][key] = value
- return grouped_pairs
+ type_key_value.setdefault(type(key), {})
+ type_key_value[type(key)][key] = value
+ return type_key_value
def only_letters_ignore_case_and_order(text):
- return ''.join(sorted(re.sub('[\W\d_]', '', text).lower()))
+ return ''.join(sorted(re.sub('[\W\d_]+', '', text).lower()))
def anagrams(words):
sorted_words = sorted(words, key=only_letters_ignore_case_and_order)
- grouped = groupby(sorted_words, only_letters_ignore_case_and_order)
- return [list(group) for _, group in grouped]
+ grouped_words = groupby(sorted_words, only_letters_ignore_case_and_order)
+ return [list(group) for _, group in grouped_words]