Създаване на хеш чрез map

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

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

Решение на Втора задача - хешове, масиви и структура от Стамен Драгоев

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

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

Резултати

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

Код

class Hash
def find_type_of_key(source, key)
return key.to_i if source.is_a?(Array) && source.fetch(key.to_i) { false }
return key.to_i if source.is_a?(Hash) && source.key?(key.to_i)
return key.to_sym if source.is_a?(Hash) && source.key?(key.to_sym)
return key if source.is_a?(Hash) && source.key?(key)
nil
end
def fetch_deep_with_index(source, path_in_arr, index)
if find_type_of_key(source, path_in_arr[index]) == nil
return nil
else
key = find_type_of_key(source, path_in_arr[index])
end
return source[key] if index == path_in_arr.size - 1
index += 1
fetch_deep_with_index(source[key], path_in_arr, index)
end
def fetch_deep(path)
arr = path.split(".")
fetch_deep_with_index(self, arr, 0)
end
def last_el(main_source)
each do |k, v|
if v.is_a?(Hash) == true
v.last_el(main_source)
else
self[k] = main_source.fetch_deep(v.to_s)
end
end
end
def reshape(form)
form_work = {}
form.each do |k, v|
form_work.store(k, v)
end
form_work.last_el(self)
end
end
class Array
def reshape(form)
each do |e|
new_hash = e.reshape(form)
e.clear
new_hash.each do |k, v|
e.store(k, v)
end
end
end
end

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

...............

Finished in 0.00806 seconds
15 examples, 0 failures

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

Стамен обнови решението на 19.10.2016 12:55 (преди около 8 години)

+class Hash
+ def find_type_of_key(source, key)
+ return key.to_i if source.is_a?(Array)
+ return key.to_i if source.is_a?(Hash) && source.key?(key.to_i)
+ return key.to_sym if source.is_a?(Hash) && source.key?(key.to_sym)
+ return key if source.is_a?(Hash) && source.key?(key)
+ nil
+ end
+
+ def fetch_deep_with_index(source, path_in_arr, index)
+ if find_type_of_key(source, path_in_arr[index]) == nil
+ return nil
+ else
+ key = find_type_of_key(source, path_in_arr[index])
+ end
+ return source[key] if index == path_in_arr.size - 1
+ index += 1
+ fetch_deep_with_index(source[key], path_in_arr, index)
+ end
+
+ def fetch_deep(path)
+ arr = path.split(".")
+ fetch_deep_with_index(self, arr, 0)
+ end
+
+ def last_el(main_source)
+ each do |k, v|
+ if v.is_a?(Hash) == true
+ v.last_el(main_source)
+ else
+ self[k] = main_source.fetch_deep(v.to_s)
+ end
+ end
+ end
+
+ def reshape(form)
+ form.last_el(self)
+ clear
+ form.each do |k, v|
+ store(k, v)
+ end
+ end
+end
+
+class Array
+ def reshape(form)
+ each do |e|
+ form_work = {}
+ form.each do |k, v|
+ form_work.store(k, v)
+ end
+ e.reshape(form_work)
+ end
+ end
+end

def fetch_deep_with_index(source, path_in_arr, index)

if find_type_of_key(source, path_in_arr[index]) == nil
  return nil
else
  key = find_type_of_key(source, path_in_arr[index])
end
return source[key] if index == path_in_arr.size - 1
index += 1
fetch_deep_with_index(source[key], path_in_arr, index)

end

Само не знам дали това отговаря на 8 реда за метод?(надявам се,че става въпрос за тялото на функцията)

Също така къде мога да променя решението си, за да има използване и на map

Щом сайтът ти го е приел, значи отговаря на ограничението. Още, може да имаш празни редове - тях не ги брои.

Иначе, в условието пише "Добавете метод reshape на всички хешове, който преобразува текущия хеш в нов с различна структура."

Правиш плитко копиране. Тоест копираш само самия хеш, но не и стойностите в него. Тези стойности после ги променяш.

Тръгнал си с кофти подход. Не променяй на място. Просто гледай от единия хеш и пълни в другия. :)

Освен това, разгледай какви методи ти дава класа Hash. Например, map би бил много полезен за reshape. Преди да почнеш да пишеш сам всичко, разгледай дали няма нещо готово, което може да те улесни :)

Стамен обнови решението на 22.10.2016 01:52 (преди около 8 години)

class Hash
def find_type_of_key(source, key)
- return key.to_i if source.is_a?(Array)
+ return key.to_i if source.is_a?(Array) && source.fetch(key.to_i) { false }
return key.to_i if source.is_a?(Hash) && source.key?(key.to_i)
return key.to_sym if source.is_a?(Hash) && source.key?(key.to_sym)
return key if source.is_a?(Hash) && source.key?(key)
nil
end
def fetch_deep_with_index(source, path_in_arr, index)
if find_type_of_key(source, path_in_arr[index]) == nil
return nil
else
key = find_type_of_key(source, path_in_arr[index])
end
return source[key] if index == path_in_arr.size - 1
index += 1
fetch_deep_with_index(source[key], path_in_arr, index)
end
def fetch_deep(path)
arr = path.split(".")
fetch_deep_with_index(self, arr, 0)
end
def last_el(main_source)
each do |k, v|
if v.is_a?(Hash) == true
v.last_el(main_source)
else
self[k] = main_source.fetch_deep(v.to_s)
end
end
end
def reshape(form)
- form.last_el(self)
- clear
- form.each do |k, v|
- store(k, v)
+ form_work = {}
+ form.each do |k, v|
+ form_work.store(k, v)
end
+ form_work.last_el(self)
end
end
class Array
def reshape(form)
each do |e|
- form_work = {}
- form.each do |k, v|
- form_work.store(k, v)
+ new_hash = e.reshape(form)
+ e.clear
+ new_hash.each do |k, v|
+ e.store(k, v)
end
- e.reshape(form_work)
end
end
end