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

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

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

Решение на Трета задача от Изтрит профил

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

Към профила на Изтрит профил

Резултати

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

Код

class RationalSequence
include Enumerable
def initialize(limit)
@limit = limit
end
def each
numerator = 1
counter = 0
sum = 2
while counter < @limit
if numerator.gcd(sum - numerator) == 1
yield Rational(numerator, sum - numerator)
counter += 1
end
if (sum.even? and numerator == sum - 1) or (sum.odd? && numerator == 1)
sum += 1
numerator = sum * (sum % 2)
end
numerator += if sum.even? then 1 else -1 end
end
end
end
class Integer
def prime?
return false if self <= 1
half = self/2
(2..half).each {|i| return false if self % i == 0}
true
end
end
class PrimeSequence
include Enumerable
def initialize(limit)
@limit = limit
end
def each
current = 2
counter = 0
while counter < @limit
if current.prime?
yield current
counter += 1
end
current += 1
end
end
end
class FibonacciSequence
include Enumerable
def initialize(limit, first: 1, second: 1)
@limit = limit
@first = first
@second = second
end
def each
previous = @first
current = @second
counter = 0
while counter < @limit
yield previous
counter += 1
t = previous
previous = current
current += t
end
end
end
module DrunkenMathematician
module_function
def meaningless(n)
sequence = RationalSequence.new(n)
groups = sequence.group_by { |i| get_group(i) }
groups.default = []
(groups[:group1].reduce(:*) || 1) / (groups[:group2].reduce(:*) || 1)
end
def get_group(i)
if i.numerator.prime? || i.denominator.prime?
:group1
else
:group2
end
end
def aimless(n)
sequence = PrimeSequence.new(n)
sequence.each_slice(2).collect { |i| Rational(i[0], i[1] || 1) }.reduce(:+)
end
def worthless(n)
max = FibonacciSequence.new(n).to_a.last
sequence_size_estimate = (1..n-1).reduce(1, :*)
rationals = RationalSequence.new(sequence_size_estimate)
count = 0
loop do
slice = rationals.take(count+1)
break if slice.reduce(:+) > max or count > sequence_size_estimate
count += 1
end
rationals.take(count)
end
end

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

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

Finished in 0.09481 seconds
20 examples, 0 failures

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

Изтрит обнови решението на 22.10.2015 00:34 (преди над 8 години)

+class RationalSequence
+ include Enumerable
+
+ def initialize(limit)
+ @limit = limit
+ end
+
+ def each
+ numerator = 1
+ counter = 0
+ sum = 2
+
+ while counter < @limit
+ if numerator.gcd(sum - numerator) == 1
+ yield Rational(numerator, sum - numerator)
+ counter += 1
+ end
+
+ if (sum.even? and numerator == sum - 1) or (sum.odd? && numerator == 1)
+ sum += 1
+ numerator = sum * (sum % 2)
+ end
+
+ numerator += if sum.even? then 1 else -1 end
+ end
+ end
+end
+
+class Integer
+ def prime?
+ return false if self <= 1
+ half = self/2
+ (2..half).each {|i| return false if self % i == 0}
+ true
+ end
+end
+
+class PrimeSequence
+ include Enumerable
+
+ def initialize(limit)
+ @limit = limit
+ end
+
+ def each
+ current = 2
+ counter = 0
+
+ while counter < @limit
+ if current.prime?
+ yield current
+ counter += 1
+ end
+
+ current += 1
+ end
+ end
+end
+
+class FibonacciSequence
+ include Enumerable
+
+ def initialize(limit, first: 1, second: 1)
+ @limit = limit
+ @first = first
+ @second = second
+ end
+
+ def each
+ previous = @first
+ current = @second
+ counter = 0
+
+ while counter < @limit
+ yield previous
+ counter += 1
+
+ t = previous
+ previous = current
+ current += t
+ end
+ end
+end
+
+module DrunkenMathematician
+ module_function
+
+ def meaningless(n)
+ sequence = RationalSequence.new(n)
+ groups = sequence.group_by { |i| get_group(i) }
+
+ groups.default = []
+ groups[:group1].reduce(:*) || 1 / groups[:group2].reduce(:*) || 1
+ end
+
+ def get_group(i)
+ if i.numerator.prime? || i.denominator.prime?
+ :group1
+ else
+ :group2
+ end
+ end
+
+ def aimless(n)
+ sequence = PrimeSequence.new(n)
+ sequence.each_slice(2).collect { |i| Rational(i[0], i[1] || 1) }.reduce(:+)
+ end
+
+ def worthless(n)
+ max = FibonacciSequence.new(n).to_a.last
+ sequence_size_estimate = (1..n-1).reduce(1, :*)
+ rationals = RationalSequence.new(sequence_size_estimate)
+
+ count = 0
+ loop do
+ slice = rationals.take(count+1)
+ break if slice.reduce(:+) > max or count > sequence_size_estimate
+ count += 1
+ end
+
+ rationals.take(count)
+ end
+end

Изтрит обнови решението на 24.10.2015 17:27 (преди над 8 години)

class RationalSequence
include Enumerable
def initialize(limit)
@limit = limit
end
def each
numerator = 1
counter = 0
sum = 2
while counter < @limit
if numerator.gcd(sum - numerator) == 1
yield Rational(numerator, sum - numerator)
counter += 1
end
if (sum.even? and numerator == sum - 1) or (sum.odd? && numerator == 1)
sum += 1
numerator = sum * (sum % 2)
end
numerator += if sum.even? then 1 else -1 end
end
end
end
class Integer
def prime?
return false if self <= 1
half = self/2
(2..half).each {|i| return false if self % i == 0}
true
end
end
class PrimeSequence
include Enumerable
def initialize(limit)
@limit = limit
end
def each
current = 2
counter = 0
while counter < @limit
if current.prime?
yield current
counter += 1
end
current += 1
end
end
end
class FibonacciSequence
include Enumerable
def initialize(limit, first: 1, second: 1)
@limit = limit
@first = first
@second = second
end
def each
previous = @first
current = @second
counter = 0
while counter < @limit
yield previous
counter += 1
t = previous
previous = current
current += t
end
end
end
module DrunkenMathematician
module_function
def meaningless(n)
sequence = RationalSequence.new(n)
groups = sequence.group_by { |i| get_group(i) }
groups.default = []
- groups[:group1].reduce(:*) || 1 / groups[:group2].reduce(:*) || 1
+ (groups[:group1].reduce(:*) || 1) / (groups[:group2].reduce(:*) || 1)
end
def get_group(i)
if i.numerator.prime? || i.denominator.prime?
:group1
else
:group2
end
end
def aimless(n)
sequence = PrimeSequence.new(n)
sequence.each_slice(2).collect { |i| Rational(i[0], i[1] || 1) }.reduce(:+)
end
def worthless(n)
max = FibonacciSequence.new(n).to_a.last
sequence_size_estimate = (1..n-1).reduce(1, :*)
rationals = RationalSequence.new(sequence_size_estimate)
count = 0
loop do
slice = rationals.take(count+1)
break if slice.reduce(:+) > max or count > sequence_size_estimate
count += 1
end
rationals.take(count)
end
end