Великденски Яйца

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

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

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

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

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

Резултати

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

Код

def extract_type(extr_in, rule):
extr_out = [str(i[0])*i[1] for i in extr_in if type(i[0]) == rule]
return "".join(extr_out)
def reversed_dict(rev_in):
rev_out = dict((v,k) for k,v in rev_in.items())
return rev_out
def flatten_dict(flat_in, trans_k = "", trans_f = {}):
flat_out = trans_f
for i in flat_in:
key = trans_k + str(i)
if type(flat_in[i]) is dict:
flatten_dict(flat_in[i], key + ".", flat_out)
else:
flat_out[key] = flat_in[i]
return flat_out
def unflatten_dict(flat_in):
flat_out = {}
for f_k, f_v in flat_in.items():
sub = f_k.split(".")
d = flat_out
for x in sub[:-1]:
if x not in d:
d[x] = {}
d = d[x]
d[sub[-1]] = f_v
return flat_out
def reps(ref):
refined = [i for i in ref if ref.count(i) > 1]
return tuple(refined)

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

...................
----------------------------------------------------------------------
Ran 19 tests in 0.205s

OK

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

Васил обнови решението на 20.03.2015 20:31 (преди над 9 години)

+#EXTRACTOR
+def extract_typel(extraction, rule):
+ extracted = []
+ for i in extraction:
+ if type(i[0]) == rule:
+ extracted.append(str(i[0]) * i[1])
+ return "".join(extracted)
+
+def extract_type(extr_in, rule):
+ extr_out = [str(i[0])*i[1] for i in extr_in if type(i[0]) == rule]
+ return "".join(extr_out)
+
+#REVERSE_DICTIONARY
+def reversed_dict(rev_in):
+ rev_out = dict((v,k) for k,v in rev_in.items())
+ return rev_out
+
+#FLATTEN_DICTIONARY
+def flatten_dict(flat_in, trans_k = "", trans_f = {}):
+ flat_out = trans_f
+ for i in flat_in:
+ key = trans_k + str(i)
+ if type(flat_in[i]) is dict:
+ flatten_dict(flat_in[i], key + ".", flat_out)
+ else:
+ flat_out[key] = flat_in[i]
+ return flat_out
+
+#UNFLATTEN_DICTIONARY
+def unflatten_dict(flat_in):
+ flat_out = {}
+ for f_k, f_v in flat_in.items():
+ sub = f_k.split(".")
+ d = flat_out
+ for x in sub[:-1]:
+ if x not in d:
+ d[x] = {}
+ d = d[x]
+ d[sub[-1]] = f_v
+ return flat_out
+
+#REPETATIVE
+def reps(ref):
+ refined = [i for i in ref if ref.count(i) > 1]
+ return tuple(refined)

Вече от няколко дена се боричкам с тестовете и немога да се преборя. Ще е възможно ли да ми асисирате в търсенето на проблема?

От всички тестове само един не минава или поне така ми излиза. Тестът за flatten_dict, ми създава проблеми. В теста излиза че фейлва. Като го проверя на ръка си излизат същите резултати. На ръка имам в предвид че взимам масивите от теста пускам ги в моята функция и после ги сравнявам.

Васил обнови решението на 23.03.2015 12:46 (преди над 9 години)

#EXTRACTOR
-def extract_typel(extraction, rule):
- extracted = []
- for i in extraction:
- if type(i[0]) == rule:
- extracted.append(str(i[0]) * i[1])
- return "".join(extracted)
-
def extract_type(extr_in, rule):
extr_out = [str(i[0])*i[1] for i in extr_in if type(i[0]) == rule]
return "".join(extr_out)
#REVERSE_DICTIONARY
def reversed_dict(rev_in):
rev_out = dict((v,k) for k,v in rev_in.items())
return rev_out
#FLATTEN_DICTIONARY
def flatten_dict(flat_in, trans_k = "", trans_f = {}):
flat_out = trans_f
for i in flat_in:
key = trans_k + str(i)
if type(flat_in[i]) is dict:
flatten_dict(flat_in[i], key + ".", flat_out)
else:
flat_out[key] = flat_in[i]
return flat_out
#UNFLATTEN_DICTIONARY
def unflatten_dict(flat_in):
flat_out = {}
for f_k, f_v in flat_in.items():
sub = f_k.split(".")
d = flat_out
for x in sub[:-1]:
if x not in d:
d[x] = {}
d = d[x]
d[sub[-1]] = f_v
return flat_out
#REPETATIVE
def reps(ref):
refined = [i for i in ref if ref.count(i) > 1]
return tuple(refined)

Омазваш ключовете в резултата допускайки, че всеки елемент трябва да бъде манипулиран. Подай на твоята функция следния речник: {a: 1, b:2, c: 3} и виж какво се случва :)

Освен това, махни тези коментари над всяка функция. Нямат работа там.

Васил обнови решението на 23.03.2015 14:26 (преди над 9 години)

-#EXTRACTOR
def extract_type(extr_in, rule):
extr_out = [str(i[0])*i[1] for i in extr_in if type(i[0]) == rule]
return "".join(extr_out)
-#REVERSE_DICTIONARY
def reversed_dict(rev_in):
rev_out = dict((v,k) for k,v in rev_in.items())
return rev_out
-#FLATTEN_DICTIONARY
def flatten_dict(flat_in, trans_k = "", trans_f = {}):
flat_out = trans_f
for i in flat_in:
key = trans_k + str(i)
if type(flat_in[i]) is dict:
flatten_dict(flat_in[i], key + ".", flat_out)
else:
flat_out[key] = flat_in[i]
return flat_out
-#UNFLATTEN_DICTIONARY
def unflatten_dict(flat_in):
flat_out = {}
for f_k, f_v in flat_in.items():
sub = f_k.split(".")
d = flat_out
for x in sub[:-1]:
if x not in d:
d[x] = {}
d = d[x]
d[sub[-1]] = f_v
return flat_out
-#REPETATIVE
def reps(ref):
refined = [i for i in ref if ref.count(i) > 1]
return tuple(refined)