• self. се изпуска максимално много; в случая на теб не ти е необходим никъде и можеш да го изпуснеш навсякъде
• Проверката за kind_of?е ненужна във fizzbuzz, понеже условието не го изисква; а и е малко излишно да го правиш на всяка итерация, би могъл да провериш begin/end преди началото на map-а
• А, и map се ползва по-често като име, отколкото collect
• Хешът, който връщаш в group_values има страничен ефект — дифолтна стойност; може би не искаш да става така :)

• Не съм сигурен с какво мога да заменя self. Там ще трябва да почета повече, тъй като и на мен не ми хареса.
• Проверката kind_of? я използвам, тъй като ако след n = :fizz if n % 3 == 0, n стане символ на следващите две няма оператор % за него и гърми. Много кофти идея ли е да го използвам така?
• Относно map - мерси, не знаех.
• Дифолтната стойност я използвам, за да мога свободно да си ползвам операторът +, защото иначе не мога да събера nil с Array. Работата е там, че все още не осъзнавам какъв ми е страничният ефект...

Да, кофти идея е да го ползваш така, понеже създаваш темпорална кохезия между двата реда код - ако ги разменя, има друг ефект. Друго което е кофти, е да не го правиш с elsif или с case. И двете правят кода по-труден за разбиране. Въобще, fizzbuzz-а ти е под критика.

Мда, съгласен съм. Направих го така за да ме одобри skeptic за броя редове в метод(5).

Първоначалната имплементация беше:

  if n % 5 == 0 and n % 3 == 0
    :fizzbuzz
  elsif n % 3 == 0
    :fizz
  elsif n % 5 == 0
    :buzz
  else
    n

Ей сега ме изби на простотия с case, след като ми позволи да си ползвам моя метод:

  case n.prime_divisors.join
    when /35/ then :fizzbuzz
    when /3/ then :fizz
    when /5/ then :buzz
    else n
  end

... но и това е 6 реда. Едва след това прочетох повече за case в ruby и ей сега качвам адекватно решение.

• case-а ти не ме кефи. Аз бих го направил с if/elsif, просто защото няма нужда да бъдеш fancy.
• inject({}) { |h, i| h[..] = ..; h } е гнусен anti-pattern. Не го ползвай.
• self.-овете са излишни. Това не е Python.

• Хм...с 8 реда метод ме пусна да предам домашното. Предпочетох да го оставя така, вместо:

  if n % 15 == 0 then :fizzbuzz
  elsif n % 3 == 0 then :fizz
  elsif n % 5 == 0 then :buzz
  else n
  end
  

Греша ли, че това е с едноредовите elsif-ове са кофти идея?

• Ок, не знаех. Така и така го почнах от начало, реших да поразровя за дифолтните стойности в Hash. Попаднах на това обяснение от Gary Wright:

1) Hash.new(x) returns x when a key isn't found. It will be the same x for every key and won't store x in the hash, just return it on a key miss.

2) Hash.new { #code } will run the block on every key miss and return the resulting value but will not store the value in the hash.

3) Hash.new { |h,k| h[k] = #code } will evaluate the code, store it in the hash, and return the value on a key miss. Because the value is stored in the hash on the first key miss, the code will not execute on a subsequent lookup on the same key.

Очевидно мен ме устройва 3). Прав ли съм или като цяло тая идея Hash, с дифолтна стойност Array не е особено приятна?

• Доста mind-blowing ми идва липсата на self., но явно тук така се прави - махнах ги.

Разбирам за self., но ти просто имаш навици от Python... :) Тук self винаги е имплицитният получател при извикване на метод без явен такъв. Затова в 90% от случаите се изпуска.

За хеша — това с дифолтната стойнсот се ползва от време на време, но в случая ти връщаш този обект на потребителя и той се държи странно; не е като нормален хеш, в който като достъпиш липсващ ключ, ти връща nil. Вместо това ти връща някакъв празен списък, което, според мен, не трябва да е така. Ако позлваше хеша само вътрешно, щеше да е окей. Тук или трябва да намериш начин да махнеш тази дифолтна стойност някак (http://www.ruby-doc.org/core-1.9.3/Hash.html), или може да ползваш един от тези идиоми:

result = {}
# ...
result[value] ||= []
result[value] << key

Някои хора го записват на един ред, но аз лично не го харесвам така:

(result[value] ||= []) << key

Също да, тези едноредови if/then се избягват. На един ред е обикновено само в постфиксен вариант. В случая, може би Skeptic пречи.

И дори да останеш на това, две дребни неща:

result = Hash.new{ |hash, key| hash[key] = Array.new }

По-скоро така:

result = Hash.new { |hash, key| hash[key] = [] }

Ок, убеди ме, че е тъпо по поразбиране хеша дето връщам да връща странни дифолтни стойности. Ще използвам това решение с ||=.

Аз съм фен на едноредовите, ако ги идентираш така:

if    n % 15 == 0 then :fizzbuzz
elsif n % 3 == 0  then :fizz
elsif n % 5 == 0  then :buzz
else                   n
end

Love it or hate it, за мен това е добър начин за подреждане на просто "таблично" условие (без side effect-и и други сложнотии).

Сега на мен решението ти ми изглежда супер :) Подредено, чистичко, Ruby style :)

(Като изключим проверката за просто число с регулярен израз, разбира се :))

-6 точки, щото не ми си симпатичен.