Хешове и keyword аргументи на блокове

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

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

Решение на Девета задача от Малина Демирова

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

Към профила на Малина Демирова

Резултати

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

Код

REPOSITORY = 'https://github.com/MalinaD/ruby-retrospective-2015-1'
# Двадесет неща, които научих.
#
# По първа задача
# 1. Използването на case вместо if прави кода по - четим
# 2. При case може да ползваш различни случаи , да имаш стойност по подразбиране или да нямаш такава зададена
# 3. Можеш да минеш по - бързо през подадените стойности ако използваш хеш или масив
# 4. Използвайки хеш кода става по - ясен и четим , обема му намалява значимо
# 5. Избирането на стойност може да стане използвайки fetch или select{|key, value| value == currency}. Fetch(x) връща елемент намиращ се на
# позицията , на която се намира индексът x. Select минава през хеша/масива и избира само елементите, които отговарят на определено успловие.
# В примера отгоре търси елементи, чиито стойности имат определена стойност.
# 6. С оператора за сравнение <=> си спестяваме доста писане. Той връща 0, 1 или -1 в
# зависимост дали сравняваните стойности са равни, първата е по - голяма или обратното. Ако
# го заместим ни трябва оператор if с две проверки с else. Освен това ще ни ца ни нужни
# другите оператори за сравнение като == , > , < , eql?
#
# По втора задача
# 1. Clone копира класа на змията заедно със състоянието, в което се намира, и неговите методи. Успява да за запази замръзено състояние на змията.
# Dup копира променливите, но не копира рекурсивно самия обект. Dup прави плитко копие
# 2. Може да заменим elements[n] с функциите first и last, които връщат първия и последния елемент от масива
# 3. Sample избира елемент на случаен принцип от масива. Преди това сме определили сподадените височина и дължина всички комбинации от позициите,
# като използваме product функцията. От тях сме извадили местоположенията на храната и на змията за да преценим, кое е останало свободно.
# 4. Като използваме ! вместо not, имаме предвид, че ! има по - висок приоритет както от not така и от другите оператори.
# 5. Може да направим копие на змията, да махнем първия елемент на първата позиция, после да я изместим с едно поле напред, но може да
# преизползваме метода, който вече сме написали grow, за да направим същото и после да махнем първия елемент.Delete_at(index) изтрива елемента от
# позиция с индекс index, докато drop(element) премахва element на брой елемента, започвайки отпред назад и връща останалите.
# 6. Може да използваме select за да изберем останалите полета от всички заети вместо просто да ги вадим.
#
# По трета задача
# 1. Разбрах как по - добре да си подреждам кода, как да използвам по - правилно конструктор, да си дефинирам полетата, да извиквам методи от
# класа или наследниците. Също разбрах как да използвам each и къде.
# 2. Мога да съкратя проверките за простите числа, тъй като при обхождането от 2 до последното зададено число се проверяват всички стойности и
# накрая се връща true независимо от резултата.
# 3. Проверката и обхождането с while може да се замени с n.times do end , което премахва допълнителното увеличаване на стойноста на брояча.
# 4. С оператора ||= добавяме сигурна стойност към масива , ако той е = nil.
# 5. Може да използваме take_while или само while. С inject(:<operator>) заместваме различни операции като +, - , *, / и други. Използването му е
# удобно както и на +=, -= и други. Не е нужно да извикваме стойности като new(Float::INFINITY).lazy към масив, когато можем да извикваме
# различни стойности и ги преобразуваме директно в цикъл.
# 6. Като вземем lazy от Float::INFINITY не влизаме в безкраен цикъл.
#
#
# По четвърта задача
# 1. Използването на map.with_index.to_a превръща хеш в масив, който е по - лесен и удобен за манипулиране. По- елегантно решение е, а също е
# нововъведено с Ruby 1.9.3.
# 2. За методите forty? и twenty? изглежда по - добре като се изведат еднаквите проверки за това дали има двойка от king and queen /дама и поп/ в
# отделен клас. Също е по - бързо да намерим в ръката дали имаме попове, да намерим каква боя са. След това да проверим дали има дами със същият
# цвят.
# 3. В методите forty? и twenty? се прави проверка дали намерените дама и поп от една боя са или не са козове. Може да се провери с any? или с
# анонимна функция ламбда или Proc.new.
# 4. При метода ==(other) е много хитро първо да се проверят двете стойности на боя и рангове дали са равни с <=> и след това да се провери
# стойността от <=> дали е = 0 със .zero? . Операторът <=> връща 0 само когато двете стойности са равни.
# 5. С product може да вземе всички стойности от масива с ранговете и масива от боите и да извлечем всички възможни комбинации без те да се
# повтарят. След това с map или collect се връщат новите комбинации като елементи на нов масив, в нашия случай като карта.

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

From https://github.com/fmi/ruby-retrospective-2015-1
 * branch            master     -> FETCH_HEAD
HEAD is now at 767dd8d Update the task name in the readme for clarity
Cloning into 'submission'...
HEAD is now at 8bd6dce Task4: change in twenty? and forty? methods
From /tmp/ruby-retrospective-2015-1/checker
 * branch            master     -> FETCH_HEAD
 * [new branch]      master     -> upstream/master

Changes URL:
https://github.com/MalinaD/ruby-retrospective-2015-1/compare/767dd8dfe46...8bd6dce31aa

‘solutions/04.rb’ -> ‘/tmp/ruby-retrospective-2015-1/checker/solutions/04.rb’
‘solutions/02.rb’ -> ‘/tmp/ruby-retrospective-2015-1/checker/solutions/02.rb’
‘solutions/03.rb’ -> ‘/tmp/ruby-retrospective-2015-1/checker/solutions/03.rb’
‘solutions/01.rb’ -> ‘/tmp/ruby-retrospective-2015-1/checker/solutions/01.rb’
OK
........

Finished in 0.00482 seconds
8 examples, 0 failures
OK
....................

Finished in 0.01406 seconds
20 examples, 0 failures
OK
....................

Finished in 0.11667 seconds
20 examples, 0 failures
OK
.........................................................

Finished in 0.02833 seconds
57 examples, 0 failures
From https://github.com/fmi/ruby-homework
 * branch            master     -> FETCH_HEAD
HEAD is now at 9dd040c Modify a test in task 8 to not include empty cells
.

Finished in 0.00731 seconds
1 example, 0 failures

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

Малина обнови решението на 24.01.2016 18:14 (преди около 9 години)

+REPOSITORY = 'https://github.com/MalinaD/ruby-retrospective-2015-1'
+
+# Двадесет неща, които научих.
+#
+# По първа задача
+# 1. Използването на case вместо if прави кода по - четим
+# 2. При case може да ползваш различни случаи , да имаш стойност по подразбиране или да нямаш такава зададена
+# 3. Можеш да минеш по - бързо през подадените стойности ако използваш хеш или масив
+# 4. Използвайки хеш кода става по - ясен и четим , обема му намалява значимо
+# 5. Избирането на стойност може да стане използвайки fetch или select{|key, value| value == currency}. Fetch(x) връща елемент намиращ се на
+# позицията , на която се намира индексът x. Select минава през хеша/масива и избира само елементите, които отговарят на определено успловие.
+# В примера отгоре търси елементи, чиито стойности имат определена стойност.
+# 6. С оператора за сравнение <=> си спестяваме доста писане. Той връща 0, 1 или -1 в
+# зависимост дали сравняваните стойности са равни, първата е по - голяма или обратното. Ако
+# го заместим ни трябва оператор if с две проверки с else. Освен това ще ни ца ни нужни
+# другите оператори за сравнение като == , > , < , eql?
+#
+# По втора задача
+# 1. Clone копира класа на змията заедно със състоянието, в което се намира, и неговите методи. Успява да за запази замръзено състояние на змията.
+# Dup копира променливите, но не копира рекурсивно самия обект. Dup прави плитко копие
+# 2. Може да заменим elements[n] с функциите first и last, които връщат първия и последния елемент от масива
+# 3. Sample избира елемент на случаен принцип от масива. Преди това сме определили сподадените височина и дължина всички комбинации от позициите,
+# като използваме product функцията. От тях сме извадили местоположенията на храната и на змията за да преценим, кое е останало свободно.
+# 4. Като използваме ! вместо not, имаме предвид, че ! има по - висок приоритет както от not така и от другите оператори.
+# 5. Може да направим копие на змията, да махнем първия елемент на първата позиция, после да я изместим с едно поле напред, но може да
+# преизползваме метода, който вече сме написали grow, за да направим същото и после да махнем първия елемент.Delete_at(index) изтрива елемента от
+# позиция с индекс index, докато drop(element) премахва element на брой елемента, започвайки отпред назад и връща останалите.
+# 6. Може да използваме select за да изберем останалите полета от всички заети вместо просто да ги вадим.
+#
+# По трета задача
+# 1. Разбрах как по - добре да си подреждам кода, как да използвам по - правилно конструктор, да си дефинирам полетата, да извиквам методи от
+# класа или наследниците. Също разбрах как да използвам each и къде.
+# 2. Мога да съкратя проверките за простите числа, тъй като при обхождането от 2 до последното зададено число се проверяват всички стойности и
+# накрая се връща true независимо от резултата.
+# 3. Проверката и обхождането с while може да се замени с n.times do end , което премахва допълнителното увеличаване на стойноста на брояча.
+# 4. С оператора ||= добавяме сигурна стойност към масива , ако той е = nil.
+# 5. Може да използваме take_while или само while. С inject(:<operator>) заместваме различни операции като +, - , *, / и други. Използването му е
+# удобно както и на +=, -= и други. Не е нужно да извикваме стойности като new(Float::INFINITY).lazy към масив, когато можем да извикваме
+# различни стойности и ги преобразуваме директно в цикъл.
+# 6. Като вземем lazy от Float::INFINITY не влизаме в безкраен цикъл.
+#
+#
+# По четвърта задача
+# 1. Използването на map.with_index.to_a превръща хеш в масив, който е по - лесен и удобен за манипулиране. По- елегантно решение е, а също е
+# нововъведено с Ruby 1.9.3.
+# 2. За методите forty? и twenty? изглежда по - добре като се изведат еднаквите проверки за това дали има двойка от king and queen /дама и поп/ в
+# отделен клас. Също е по - бързо да намерим в ръката дали имаме попове, да намерим каква боя са. След това да проверим дали има дами със същият
+# цвят.
+# 3. В методите forty? и twenty? се прави проверка дали намерените дама и поп от една боя са или не са козове. Може да се провери с any? или с
+# анонимна функция ламбда или Proc.new.
+# 4. При метода ==(other) е много хитро първо да се проверят двете стойности на боя и рангове дали са равни с <=> и след това да се провери
+# стойността от <=> дали е = 0 със .zero? . Операторът <=> връща 0 само когато двете стойности са равни.
+# 5. С product може да вземе всички стойности от масива с ранговете и масива от боите и да извлечем всички възможни комбинации без те да се
+# повтарят. След това с map или collect се връщат новите комбинации като елементи на нов масив, в нашия случай като карта.

Отнемам ти няколко точки поради две причини:

  1. Заради проблеми с окончателните ти решения.
  2. Заради проблеми с написаните поуки.

По точка едно

  • В решението ти на първа задача имаш проблеми с конвенциите - с идентиране на кода, с поставяне на интервали, с именуването на неща.
  • Пак там, използвала си неконвенционално Hash#fetch, когато Hash#[] щеше да ти свърши същата работа. fetch ще хвърли изключение, ако няма такъв ключ, а в тази задача няма такова изискване.
  • Имаш проблеми с идентацията и във втора, трета и четвърта задача. В края на курса това си е проблем. Ако не успяваш да си настроиш редактора правилно, моля те, питай във форумите за съвет, или ни пиши.
  • Във втора, трета и четвърта задача имаш и други проблеми със спазване на конвенциите. Чети ръководството по стил по-внимателно.

Изглежда ми като да не си разгледала достатъчно внимателно и осмислила нашите и решенията на колегите си.

По точка две

В доста от точките не си описала добре какво си научила в дадената точка. Някои от нещата не са верни, или поне не в контекста, който си дала. Ето няколко примера:

По втора задача 1. Clone копира класа на змията заедно със състоянието, в което се намира, и неговите методи. Успява да за запази замръзено състояние на змията. Dup копира променливите, но не копира рекурсивно самия обект. Dup прави плитко копие

clone също прави плитко копие. Вярно е, че копира и флага frozen?, но копието пак е плитко.

По трета задача 1. Разбрах как по - добре да си подреждам кода

Точно на трета задача имаш като че ли най-сериозни проблеми с подредбата на кода, поне като идентация.

По четвърта задача 1. Използването на map.with_index.to_a превръща хеш в масив, който е по - лесен и удобен за манипулиране. По- елегантно решение е, а също е нововъведено с Ruby 1.9.3.

Не бих казал, че манипулиране на масив е по-удобно от манипулиране на хеш. Зависи от ситуацията. А за да се обърне хеш до масив е достатъчно да се направи само to_a.