git hooks

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

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

Решение на Пет функции от Георги Стайков

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

Към профила на Георги Стайков

Резултати

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

Код

import re
from functools import cmp_to_key
from collections import defaultdict
ALPHABET = set('АБВГДЕЖЗИЙКЛМНОПРСТУФХЦЧШЩЬЪЮЯ')
def is_pangram(sentence):
return set(re.findall("[А-Я]", sentence.upper())) == ALPHABET
def char_histogram(text):
return {symbol: text.count(symbol) for symbol in text}
def sort_by(func, arguments):
return sorted(arguments, key=cmp_to_key(func))
def group_by_type(dictionary):
result = {}
for key, value in dictionary.items():
result.setdefault(type(key), {}).update({key: value})
return result
def change(word):
return ''.join(sorted(re.sub(r"[\W_\d]", '', word.upper())))
def anagrams(words):
result = defaultdict(list)
for word in words:
result[change(word)].append(word)
return list(result.values())

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

................
----------------------------------------------------------------------
Ran 16 tests in 0.019s

OK

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

Георги обнови решението на 13.03.2014 20:37 (преди над 10 години)

+import re
+from functools import cmp_to_key
+from itertools import groupby
+from operator import itemgetter
+ALPHABET = set('АБВГДЕЖЗИЙКЛМНОПРСТУФХЦЧШЩЬЪЮЯ')
+
+
+def is_pangram(sentence):
+ return set(re.findall("[а-яА-Я]", sentence.upper())) == ALPHABET
+
+
+def char_histogram(text):
+ return {symbol: text.count(symbol) for symbol in text}
+
+
+def sort_by(func, arguments):
+ return sorted(arguments, key=cmp_to_key(func))
+
+
+def group_by_type(dictionary):
+ result = dict()
+ for key, value in dictionary.items():
+ result.setdefault(type(key), {}).update({key: value})
+ return result
+
+
+def is_Anagram(word1, word2):
+ return sorted(word1) == sorted(word2)
+
+
+def anagrams(words):
+ result = list()
+ counter = 0
+ for x in range(0, len(words)):
+ if words[x] != '1':
+ result.append(list())
+ result[counter].append(words[x])
+ for y in range(x + 1, len(words)):
+ if is_Anagram(words[x], words[y]) and words[y] != '1':
+ result[counter].append(words[y])
+ words[y] = '1'
+ counter += 1
+
+ return result

Георги обнови решението на 13.03.2014 20:42 (преди над 10 години)

import re
from functools import cmp_to_key
from itertools import groupby
from operator import itemgetter
ALPHABET = set('АБВГДЕЖЗИЙКЛМНОПРСТУФХЦЧШЩЬЪЮЯ')
def is_pangram(sentence):
return set(re.findall("[а-яА-Я]", sentence.upper())) == ALPHABET
def char_histogram(text):
return {symbol: text.count(symbol) for symbol in text}
def sort_by(func, arguments):
return sorted(arguments, key=cmp_to_key(func))
def group_by_type(dictionary):
result = dict()
for key, value in dictionary.items():
result.setdefault(type(key), {}).update({key: value})
return result
-def is_Anagram(word1, word2):
+def is_anagram(word1, word2):
return sorted(word1) == sorted(word2)
def anagrams(words):
result = list()
counter = 0
for x in range(0, len(words)):
if words[x] != '1':
result.append(list())
result[counter].append(words[x])
for y in range(x + 1, len(words)):
- if is_Anagram(words[x], words[y]) and words[y] != '1':
+ if is_anagram(words[x], words[y]) and words[y] != '1':
result[counter].append(words[y])
words[y] = '1'
counter += 1
-
return result

Здравейте, тъй като попитах във форума относно функцията sort_by(func, arguments) и ми казахте, че func може да връща 0 това означава, че не може да ползваме вградения сорт

def sort_by(func, arguments):
....return sorted(arguments, key=cmp_to_key(func))

защото той противно на условието при 0 не сортира,а сортира при отрицателни стойности само (пак си е stable sort). Трябва ли да си променям решението,за да покрия случая с 0 или така си е ОК ? А и също така има ли начин да накарам sorted() при 0 да извършва сортиране

Не. Ок е да ползваш sorted.

Анаграма е дума или фраза образувана от буквите на друга дума или фраза, чрез пермутация.

  • Твоето решение не прави разлика между буква и символ.
  • word1 и word2 не са особено добри имена

Георги обнови решението на 16.03.2014 23:39 (преди над 10 години)

import re
from functools import cmp_to_key
-from itertools import groupby
-from operator import itemgetter
ALPHABET = set('АБВГДЕЖЗИЙКЛМНОПРСТУФХЦЧШЩЬЪЮЯ')
def is_pangram(sentence):
- return set(re.findall("[а-яА-Я]", sentence.upper())) == ALPHABET
+ return set(re.findall("[А-Я]", sentence.upper())) == ALPHABET
def char_histogram(text):
return {symbol: text.count(symbol) for symbol in text}
def sort_by(func, arguments):
return sorted(arguments, key=cmp_to_key(func))
def group_by_type(dictionary):
result = dict()
for key, value in dictionary.items():
result.setdefault(type(key), {}).update({key: value})
return result
-def is_anagram(word1, word2):
- return sorted(word1) == sorted(word2)
+def get_letters_of(word):
+ return re.sub("[^а-яА-яA-Za-z]", '', word)
+def change(word):
+ return ''.join(sorted(get_letters_of(word.upper())))
+
+
def anagrams(words):
- result = list()
- counter = 0
+ result = dict()
- for x in range(0, len(words)):
+ for word in words:
- if words[x] != '1':
+ if change(word) in result and isinstance(result[change(word)], list):
- result.append(list())
+ result[change(word)].append(word)
- result[counter].append(words[x])
+ else:
- for y in range(x + 1, len(words)):
+ result[change(word)] = []
- if is_anagram(words[x], words[y]) and words[y] != '1':
+ result[change(word)].append(word)
- result[counter].append(words[y])
+ return list(result.values())
- words[y] = '1'
- counter += 1
- return result

Георги обнови решението на 16.03.2014 23:46 (преди над 10 години)

import re
from functools import cmp_to_key
ALPHABET = set('АБВГДЕЖЗИЙКЛМНОПРСТУФХЦЧШЩЬЪЮЯ')
def is_pangram(sentence):
return set(re.findall("[А-Я]", sentence.upper())) == ALPHABET
def char_histogram(text):
return {symbol: text.count(symbol) for symbol in text}
def sort_by(func, arguments):
return sorted(arguments, key=cmp_to_key(func))
def group_by_type(dictionary):
result = dict()
for key, value in dictionary.items():
result.setdefault(type(key), {}).update({key: value})
return result
def get_letters_of(word):
- return re.sub("[^а-яА-яA-Za-z]", '', word)
+ return re.sub("[^а-яА-ЯA-Za-z]", '', word)
def change(word):
return ''.join(sorted(get_letters_of(word.upper())))
def anagrams(words):
result = dict()
for word in words:
if change(word) in result and isinstance(result[change(word)], list):
result[change(word)].append(word)
else:
result[change(word)] = []
result[change(word)].append(word)
return list(result.values())

Георги обнови решението на 17.03.2014 00:02 (преди над 10 години)

import re
from functools import cmp_to_key
ALPHABET = set('АБВГДЕЖЗИЙКЛМНОПРСТУФХЦЧШЩЬЪЮЯ')
def is_pangram(sentence):
return set(re.findall("[А-Я]", sentence.upper())) == ALPHABET
def char_histogram(text):
return {symbol: text.count(symbol) for symbol in text}
def sort_by(func, arguments):
return sorted(arguments, key=cmp_to_key(func))
def group_by_type(dictionary):
result = dict()
for key, value in dictionary.items():
result.setdefault(type(key), {}).update({key: value})
return result
def get_letters_of(word):
- return re.sub("[^а-яА-ЯA-Za-z]", '', word)
+ return re.sub("[^\w]", '', word)
def change(word):
return ''.join(sorted(get_letters_of(word.upper())))
def anagrams(words):
result = dict()
for word in words:
if change(word) in result and isinstance(result[change(word)], list):
result[change(word)].append(word)
else:
result[change(word)] = []
result[change(word)].append(word)
return list(result.values())

Георги обнови решението на 17.03.2014 00:54 (преди над 10 години)

import re
from functools import cmp_to_key
ALPHABET = set('АБВГДЕЖЗИЙКЛМНОПРСТУФХЦЧШЩЬЪЮЯ')
def is_pangram(sentence):
return set(re.findall("[А-Я]", sentence.upper())) == ALPHABET
def char_histogram(text):
return {symbol: text.count(symbol) for symbol in text}
def sort_by(func, arguments):
return sorted(arguments, key=cmp_to_key(func))
def group_by_type(dictionary):
result = dict()
for key, value in dictionary.items():
result.setdefault(type(key), {}).update({key: value})
return result
-def get_letters_of(word):
- return re.sub("[^\w]", '', word)
-
-
def change(word):
- return ''.join(sorted(get_letters_of(word.upper())))
+ return ''.join(sorted(re.sub("[\W_\d]", '', word.upper())))
def anagrams(words):
result = dict()
for word in words:
if change(word) in result and isinstance(result[change(word)], list):
result[change(word)].append(word)
else:
result[change(word)] = []
result[change(word)].append(word)
return list(result.values())

Последната версия ОК ли е ?

П.П Този регулярен израз "re.sub("[\W_\d]", '', word.upper())" малко ме притеснява... Би трябвало да вземе всички букви (от всички съществуващи азбуки. Гаврих се доста с него и уж работеше, но честно казано не знам как се пишат регулярни изрази (като синтаксис) и просто сглобявам отделни части от нета в една обща ... )

Тоест ksdfjk213 не е дума така ли ?!?

Не е дума.

И трябва всяка дума да я прекарвам през регулярен израз, за да проверя дали съдържа само букви това ли е идеята ?

Знаейки за оператора in, аз не бих го направил така, но това си е решение, което ти трябва да вземемш.

first_word и second_word ок ли са като имена ?

Да

П.П Този регулярен израз "re.sub("[\W_\d]", '', word.upper())" малко ме притеснява... Би трябвало да вземе всички букви (от всички съществуващи азбуки. Гаврих се доста с него и уж работеше, но честно казано не знам как се пишат регулярни изрази (като синтаксис) и просто сглобявам отделни части от нета в една обща ... )

Не хваща всички съществуващи букви от всички азбуки. Ако не си супер уверен с регулярните изрази, не ги ползвай. Не сме ви говорили още за тях => има друг начин да се реши това :)

Факт е, че създава стабилното впечатление, че работи този регулярен израз. Не казвам, че е грешен. Просто казвам, че аз не бих го имплементирал по този начин :)

Дай да оправим няколко стилови проблема:

  • Слагай r пред стринг, който е шаблон на регулярен израз. Демек "[\W_\d]" искаш да го направиш на r"[\W_\d]". Ще обясним защо като стигнем до там
  • Не инстанцирай речници с dict(), а с {}
  • Не прави такава проверка isinstance(result[change(word)], list). Ако ти подам нещо, което не е списък, но може да се обхожда като списък (вчера ви показахме как се прави това), твоето решение ще се счупи. Виж как работи defaultdict (можеш да го намериш в collections)

Георги обнови решението на 19.03.2014 15:00 (преди над 10 години)

import re
from functools import cmp_to_key
+from collections import defaultdict
ALPHABET = set('АБВГДЕЖЗИЙКЛМНОПРСТУФХЦЧШЩЬЪЮЯ')
def is_pangram(sentence):
return set(re.findall("[А-Я]", sentence.upper())) == ALPHABET
def char_histogram(text):
return {symbol: text.count(symbol) for symbol in text}
def sort_by(func, arguments):
return sorted(arguments, key=cmp_to_key(func))
def group_by_type(dictionary):
- result = dict()
+ result = {}
for key, value in dictionary.items():
result.setdefault(type(key), {}).update({key: value})
return result
def change(word):
- return ''.join(sorted(re.sub("[\W_\d]", '', word.upper())))
+ return ''.join(sorted(re.sub(r"[\W_\d]", '', word.upper())))
def anagrams(words):
- result = dict()
+ result = defaultdict(list)
for word in words:
- if change(word) in result and isinstance(result[change(word)], list):
- result[change(word)].append(word)
- else:
- result[change(word)] = []
- result[change(word)].append(word)
+ result[change(word)].append(word)
return list(result.values())

Георги обнови решението на 19.03.2014 15:12 (преди над 10 години)

import re
from functools import cmp_to_key
from collections import defaultdict
ALPHABET = set('АБВГДЕЖЗИЙКЛМНОПРСТУФХЦЧШЩЬЪЮЯ')
def is_pangram(sentence):
return set(re.findall("[А-Я]", sentence.upper())) == ALPHABET
def char_histogram(text):
return {symbol: text.count(symbol) for symbol in text}
def sort_by(func, arguments):
return sorted(arguments, key=cmp_to_key(func))
def group_by_type(dictionary):
result = {}
for key, value in dictionary.items():
result.setdefault(type(key), {}).update({key: value})
return result
def change(word):
return ''.join(sorted(re.sub(r"[\W_\d]", '', word.upper())))
def anagrams(words):
result = defaultdict(list)
for word in words:
result[change(word)].append(word)
- return list(result.values())
+ return list(result.values())