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

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

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

Решение на Трета задача от Адриана Стефанова

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

Към профила на Адриана Стефанова

Резултати

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

Код

class RationalSequence
include Enumerable
def initialize(limit)
@limit = limit
end
def each
array = Array.new
while array.size < @limit
current = generate(array)
yield current
array << current
end
end
def generate(array)
Range.new(1, @limit ** 2).each { |current_limit|
batch = next_batch(current_limit, array)
return batch if batch.class == Rational
}
end
def next_batch(current_limit, array)
last = (( current_limit + 1 ) / 2)
Range.new(1, last).each { |fraction_part|
current = next_rational(last, fraction_part, array)
return current if current != nil
}
end
def next_rational(last, fraction_part, array)
other_fraction_part = last - fraction_part + 1
if last % 2 == 1
current = Rational(fraction_part, other_fraction_part)
unless array.include?(current)
return current
end
else
current = Rational(other_fraction_part, fraction_part)
unless array.include?(current)
return current
end
end
end
end
class PrimeSequence
include Enumerable
def initialize(limit)
@limit = limit
end
def each
current = 2
yield current
count = 1
while count < @limit
if is_prime?(current)
yield current
count += 1
end
current += 1
end
end
def is_prime?(current)
Range.new(2, (Math.sqrt(current).ceil)).each { |prime|
return false if current % prime == 0
}
true
end
end
class FibonacciSequence
include Enumerable
def initialize(limit, first: 1, second: 1)
@limit = limit
@first = first
@second = second
end
def each
current, previous = @first, @second - @first
count = 0
while count < @limit
yield current
count += 1
current, previous = current + previous, current
end
end
end
module DrunkenMathematician
module_function
def meaningless(limit)
rationals = RationalSequence.new(limit).to_a
primes = PrimeSequence.new(limit).to_a
groups = rationals.partition{|rational| has_prime?(primes, rational)}
groups[0] << Rational(1, 1) if groups[0].size < 1
groups[1] << Rational(1, 1) if groups[1].size < 1
Rational(groups[0].inject(:*), groups[1].inject(:*))
end
def has_prime?(primes, rational)
(primes.include? rational.numerator) || (primes.include? rational.denominator)
end
def aimless(limit)
sum = 0
PrimeSequence.new(limit).to_a.each_slice(2) { |numerator, denominator|
sum += Rational(numerator, denominator)
}
sum
end
def worthless(limit)
nth_fibonacci_number = FibonacciSequence.new(limit).to_a.last
rationals = RationalSequence.new(1)
if limit == 1
return rationals.to_a
end
count = 1
while rationals.inject{ |sum, rational| sum + rational } < nth_fibonacci_number
rationals = RationalSequence.new(count)
count += 1
end
rationals.to_a.tap(&:pop)
end
end

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

........F.....F..F.F

Failures:

  1) Fifth task PrimeSequence returns an empty array for 0 primes
     Failure/Error: expect(PrimeSequence.new(0).to_a).to eq []
       
       expected: []
            got: [2]
       
       (compared using ==)
     # /tmp/d20151111-27349-1wba5sq/spec.rb:53:in `block (3 levels) in <top (required)>'
     # ./lib/language/ruby/run_with_timeout.rb:5:in `block (3 levels) in <top (required)>'
     # ./lib/language/ruby/run_with_timeout.rb:5:in `block (2 levels) in <top (required)>'

  2) Fifth task DrunkenMathematician #aimless can calculate for 3
     Failure/Error: expect(DrunkenMathematician.aimless(3)).to eq(Rational(2, 3) + Rational(5, 1))
     TypeError:
       can't convert nil into Rational
     # /tmp/d20151111-27349-1wba5sq/solution.rb:124:in `convert'
     # /tmp/d20151111-27349-1wba5sq/solution.rb:124:in `Rational'
     # /tmp/d20151111-27349-1wba5sq/solution.rb:124:in `block in aimless'
     # /tmp/d20151111-27349-1wba5sq/solution.rb:123:in `each_slice'
     # /tmp/d20151111-27349-1wba5sq/solution.rb:123:in `aimless'
     # /tmp/d20151111-27349-1wba5sq/spec.rb:88:in `block (4 levels) in <top (required)>'
     # ./lib/language/ruby/run_with_timeout.rb:5:in `block (3 levels) in <top (required)>'
     # ./lib/language/ruby/run_with_timeout.rb:5:in `block (2 levels) in <top (required)>'

  3) Fifth task DrunkenMathematician #worthless can calculate for 2
     Failure/Error: expect(DrunkenMathematician.worthless(2)).to eq %w(1/1).map(&:to_r)
       
       expected: [(1/1)]
            got: []
       
       (compared using ==)
     # /tmp/d20151111-27349-1wba5sq/spec.rb:103:in `block (4 levels) in <top (required)>'
     # ./lib/language/ruby/run_with_timeout.rb:5:in `block (3 levels) in <top (required)>'
     # ./lib/language/ruby/run_with_timeout.rb:5:in `block (2 levels) in <top (required)>'

  4) Fifth task DrunkenMathematician #worthless can calculate for 15
     Failure/Error: expect(DrunkenMathematician.worthless(15)).to eq %w(
     Timeout::Error:
       execution expired
     # /tmp/d20151111-27349-1wba5sq/solution.rb:41:in `include?'
     # /tmp/d20151111-27349-1wba5sq/solution.rb:41:in `next_rational'
     # /tmp/d20151111-27349-1wba5sq/solution.rb:27:in `block in next_batch'
     # /tmp/d20151111-27349-1wba5sq/solution.rb:26:in `each'
     # /tmp/d20151111-27349-1wba5sq/solution.rb:26:in `next_batch'
     # /tmp/d20151111-27349-1wba5sq/solution.rb:19:in `block in generate'
     # /tmp/d20151111-27349-1wba5sq/solution.rb:18:in `each'
     # /tmp/d20151111-27349-1wba5sq/solution.rb:18:in `generate'
     # /tmp/d20151111-27349-1wba5sq/solution.rb:11:in `each'
     # /tmp/d20151111-27349-1wba5sq/solution.rb:139:in `inject'
     # /tmp/d20151111-27349-1wba5sq/solution.rb:139:in `worthless'
     # /tmp/d20151111-27349-1wba5sq/spec.rb:112:in `block (4 levels) in <top (required)>'
     # ./lib/language/ruby/run_with_timeout.rb:5:in `block (3 levels) in <top (required)>'
     # ./lib/language/ruby/run_with_timeout.rb:5:in `block (2 levels) in <top (required)>'

Finished in 1.11 seconds
20 examples, 4 failures

Failed examples:

rspec /tmp/d20151111-27349-1wba5sq/spec.rb:52 # Fifth task PrimeSequence returns an empty array for 0 primes
rspec /tmp/d20151111-27349-1wba5sq/spec.rb:87 # Fifth task DrunkenMathematician #aimless can calculate for 3
rspec /tmp/d20151111-27349-1wba5sq/spec.rb:102 # Fifth task DrunkenMathematician #worthless can calculate for 2
rspec /tmp/d20151111-27349-1wba5sq/spec.rb:111 # Fifth task DrunkenMathematician #worthless can calculate for 15

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

Адриана обнови решението на 25.10.2015 23:07 (преди над 9 години)

+class RationalSequence
+ include Enumerable
+
+ def initialize(limit)
+ @limit = limit
+ end
+
+ def each
+ array = Array.new
+ while array.size < @limit
+ current = generate(array)
+ yield current
+ array << current
+ end
+ end
+
+ def generate(array)
+ Range.new(1, @limit ** 2).each { |current_limit|
+ batch = next_batch(current_limit, array)
+ return batch if batch.class == Rational
+ }
+ end
+
+ def next_batch(current_limit, array)
+ last = (( current_limit + 1 ) / 2)
+ Range.new(1, last).each { |fraction_part|
+ current = next_rational(last, fraction_part, array)
+ return current if current != nil
+ }
+ end
+
+ def next_rational(last, fraction_part, array)
+ other_fraction_part = last - fraction_part + 1
+ if last % 2 == 1
+ current = Rational(fraction_part, other_fraction_part)
+ unless array.include?(current)
+ return current
+ end
+ else
+ current = Rational(other_fraction_part, fraction_part)
+ unless array.include?(current)
+ return current
+ end
+ end
+ end
+
+end
+
+class PrimeSequence
+ include Enumerable
+
+ def initialize(limit)
+ @limit = limit
+ end
+
+ def each
+ current = 2
+ yield current
+ count = 1
+ while count < @limit
+ if is_prime?(current)
+ yield current
+ count += 1
+ end
+ current += 1
+ end
+ end
+
+ def is_prime?(current)
+ Range.new(2, (Math.sqrt(current).ceil)).each { |prime|
+ return false if current % prime == 0
+ }
+ true
+ end
+
+end
+
+class FibonacciSequence
+ include Enumerable
+
+ def initialize(limit, first: 1, second: 1)
+ @limit = limit
+ @first = first
+ @second = second
+ end
+
+ def each
+ current, previous = @first, @second - @first
+
+ count = 0
+ while count < @limit
+ yield current
+ count += 1
+ current, previous = current + previous, current
+ end
+ end
+
+end
+
+module DrunkenMathematician
+ module_function
+
+ def meaningless(limit)
+
+ rationals = RationalSequence.new(limit).to_a
+ primes = PrimeSequence.new(limit).to_a
+
+ groups = rationals.partition{|rational| has_prime?(primes, rational)}
+
+ groups[0] << Rational(1, 1) if groups[0].size < 1
+ groups[1] << Rational(1, 1) if groups[1].size < 1
+
+ Rational(groups[0].inject(:*), groups[1].inject(:*))
+ end
+
+ def has_prime?(primes, rational)
+ (primes.include? rational.numerator) || (primes.include? rational.denominator)
+ end
+
+ def aimless(limit)
+ sum = 0
+
+ PrimeSequence.new(limit).to_a.each_slice(2) { |numerator, denominator|
+ sum += Rational(numerator, denominator)
+ }
+
+ sum
+ end
+
+ def worthless(limit)
+ nth_fibonacci_number = FibonacciSequence.new(limit).to_a.last
+ rationals = RationalSequence.new(1)
+
+ if limit == 1
+ return rationals.to_a
+ end
+
+ count = 1
+ while rationals.inject{ |sum, rational| sum + rational } < nth_fibonacci_number
+ rationals = RationalSequence.new(count)
+ count += 1
+ end
+ rationals.to_a.tap(&:pop)
+ end
+end