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

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

Решение на Първа задача от Красимира Божанова

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

Към профила на Красимира Божанова

Резултати

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

Код

class Integer
def prime?
return false if self < 2
2.upto(pred).all? { |divisor| remainder(divisor).nonzero? }
end
def prime_factors
return [] if abs < 2
divisor = 2.upto(abs).find { |divisor| remainder(divisor).zero? }
[divisor] + (abs / divisor).prime_factors
end
def harmonic
1.upto(self).map { |number| Rational(1, number) }.reduce(:+)
end
def digits
abs.to_s.chars.map(&:to_i)
end
end
class Array
def frequencies
frequencies = Hash.new(0)
each { |element| frequencies[element] += 1 }
frequencies
end
def average
reduce(:+) / size.to_f unless empty?
end
def drop_every(n)
values_at(*each_index.reject { |index| (index + 1).remainder(n).zero? })
end
def combine_with(other)
smaller_size = [size, other.size].min
remainder = drop(smaller_size) + other.drop(smaller_size)
zip(other).flatten.take(2 * smaller_size) + remainder
end
end

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

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

Finished in 0.0186 seconds
14 examples, 0 failures

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

Красимира обнови решението на 13.10.2013 21:54 (преди около 11 години)

+class Integer
+ def prime?
+ return false if self < 2
+ 2.upto(pred).all? { |divisor| remainder(divisor) != 0 }
+ end
+
+ def prime_factors
+ return [] if abs < 2
+ divisor = 2.upto(abs).find { |divisor| remainder(divisor) == 0 }
+ [divisor] + abs.div(divisor).prime_factors
+ end
+
+ def harmonic
+ 1.upto(self).map { |number| Rational(1,number) }.inject(:+)
+ end
+
+ def digits
+ abs.to_s.chars.map(&:to_i)
+ end
+end
+
+
+class Array
+ def frequencies
+ result = {}
+ each do |element|
+ result[element] ||= 0
+ result[element] += 1
+ end
+ result
+ end
+
+ def average
+ inject(:+).fdiv(count) unless empty?
+ end
+
+ def drop_every(n)
+ values_at(*each_index.reject { |index| (index + 1) % n == 0 })
+ end
+
+ def combine_with(other)
+ smaller_length = [self, other].map(&:length).min
+ remainder = drop(smaller_length) + other.drop(smaller_length)
+ zip(other).flatten.take(2 * smaller_length) + remainder
+ end
+end

Много добро решение, браво!

Малко бележки:

  • Предпочитаме вариантите с думи на проверката за делимост, т.е. remainder(number), zero? и nonzero?
  • Все пак, обаче, ползваме / за делене, вместо div
  • На ред 14 трябва да има интервал след ,
  • Предпочитаме reduce пред inject
  • Само един празен ред между дефиницията на двата класа се оставя
  • result е кофти име на променлива (ред 25); спокойно може да е поне frequencies
  • За frequencies, виж конструктора на Hash и виж дали няма да ти свърши работа някоя негова алтернативна версия
  • За fdiv съм раздвоен; аз бих го написал reduce(:+) / size.to_f unless empty?
  • Предпочитаме size пред length и пред count; count се ползва в други случаи, защото е по-мощен метод от предите две
  • Кодът на ред 42 е излишно "DRY"-нат (говоря за map-а); по-добре е да го напишеш [size, other.size].min

Би ли споделила откъде разбра за map(&:to_i), map(&:length), foo(*array), както и за всички други методи, които все още не сме показвали, но си използвала (съвсем на място) в решението си? Занимавала ли си се преди с Ruby?

Красимира обнови решението на 13.10.2013 23:07 (преди около 11 години)

class Integer
def prime?
return false if self < 2
- 2.upto(pred).all? { |divisor| remainder(divisor) != 0 }
+ 2.upto(pred).all? { |divisor| remainder(divisor).nonzero? }
end
def prime_factors
return [] if abs < 2
- divisor = 2.upto(abs).find { |divisor| remainder(divisor) == 0 }
- [divisor] + abs.div(divisor).prime_factors
+ divisor = 2.upto(abs).find { |divisor| remainder(divisor).zero? }
+ [divisor] + (abs / divisor).prime_factors
end
def harmonic
- 1.upto(self).map { |number| Rational(1,number) }.inject(:+)
+ 1.upto(self).map { |number| Rational(1, number) }.reduce(:+)
end
def digits
abs.to_s.chars.map(&:to_i)
end
end
-
class Array
def frequencies
- result = {}
- each do |element|
- result[element] ||= 0
- result[element] += 1
- end
- result
+ frequencies = Hash.new(0)
+ each { |element| frequencies[element] += 1 }
+ frequencies
end
def average
- inject(:+).fdiv(count) unless empty?
+ reduce(:+) / size.to_f unless empty?
end
def drop_every(n)
- values_at(*each_index.reject { |index| (index + 1) % n == 0 })
+ values_at(*each_index.reject { |index| (index + 1).remainder(n).zero? })
end
def combine_with(other)
- smaller_length = [self, other].map(&:length).min
- remainder = drop(smaller_length) + other.drop(smaller_length)
- zip(other).flatten.take(2 * smaller_length) + remainder
+ smaller_size = [size, other.size].min
+ remainder = drop(smaller_size) + other.drop(smaller_size)
+ zip(other).flatten.take(2 * smaller_size) + remainder
end
end