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

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

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

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

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

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

Резултати

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

Код

class RationalSequence
include Enumerable
def initialize(elements_count)
@length = elements_count
end
def each
return if @length.zero?
rational_sum = 2
loop do
(1..rational_sum.pred).each do |number|
yield reciprocal Rational(number, rational_sum - number)
end
rational_sum += 1
end
end
def reciprocal(n)
(n.numerator + n.denominator).even? ? n : 1/n
end
def to_a
rational_sequence = []
enum_for(:each).take_while do |rational|
rational_sequence << rational
rational_sequence.uniq.length < @length
end
rational_sequence.uniq
end
end
class PrimeSequence
include Enumerable
def initialize(elements_count)
@length = elements_count
end
def each
number = 2
counter = 0
while counter < @length do
if number.prime?
yield number
counter += 1
end
number += 1
end
end
end
class FibonacciSequence
include Enumerable
def initialize(elements_count, first: 1, second: 1)
@length = elements_count
@first = first
@second = second
end
def each
previous, current = @first, @second
@length.times.each do
yield previous
previous, current = current, previous + current
end
end
end
module DrunkenMathematician
module_function
def meaningless(n)
group_one = [Rational(1,1)]
group_two = [Rational(1,1)]
rationals = RationalSequence.new(n).to_a
rationals.each do |rational|
if rational.numerator.prime? and rational.denominator.prime?
group_one << rational
else
group_two << rational
end
end
group_one.reduce(&:*) / group_two.reduce(&:*)
end
def aimless(n)
primes = PrimeSequence.new(n).to_a
primes << 1 if n.odd?
prime_couples = primes.each_slice(2).map(&:to_a)
prime_rationals = prime_couples.map { |couple| Rational(*couple) }
prime_rationals.reduce(&:+)
end
def worthless(n)
nth_fibonacci = FibonacciSequence.new(n).to_a.last
rationals = RationalSequence.new(1)
rational_sequence = []
rationals.take_while do |rational|
rational_sequence << rational
rational_sequence.uniq.reduce(&:+) <= nth_fibonacci
end
rational_sequence.uniq[0..-2]
end
end
class Numeric
def prime?
(2..pred).all? { |number| self.remainder(number).nonzero? }
end
end

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

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

Failures:

  1) Fifth task RationalSequence is properly enumerable
     Failure/Error: ones = RationalSequence.new(28).select { |r| r.numerator == 1 }
     Timeout::Error:
       execution expired
     # /tmp/d20151111-27349-1362ryp/solution.rb:13:in `convert'
     # /tmp/d20151111-27349-1362ryp/solution.rb:13:in `Rational'
     # /tmp/d20151111-27349-1362ryp/solution.rb:13:in `block (2 levels) in each'
     # /tmp/d20151111-27349-1362ryp/solution.rb:12:in `each'
     # /tmp/d20151111-27349-1362ryp/solution.rb:12:in `block in each'
     # /tmp/d20151111-27349-1362ryp/solution.rb:11:in `loop'
     # /tmp/d20151111-27349-1362ryp/solution.rb:11:in `each'
     # /tmp/d20151111-27349-1362ryp/spec.rb:19:in `select'
     # /tmp/d20151111-27349-1362ryp/spec.rb:19: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)>'

Finished in 1.3 seconds
20 examples, 1 failure

Failed examples:

rspec /tmp/d20151111-27349-1362ryp/spec.rb:18 # Fifth task RationalSequence is properly enumerable

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

Методи обнови решението на 26.10.2015 13:48 (преди над 9 години)

+class RationalSequence
+ include Enumerable
+
+ def initialize(elements_count)
+ @length = elements_count
+ end
+
+ def each
+ return if @length.zero?
+ n = 2
+ loop do
+ (1..n.pred).each do |number|
+ yield Rational(number, n - number)
+ end
+ n += 1
+ end
+ end
+
+ def to_a
+ rational_sequence = []
+ enum_for(:each).take_while do |rational|
+ order = (rational.numerator + rational.denominator).even?
+ rational_sequence << (order ? rational : 1/rational)
+ rational_sequence.uniq.length < @length
+ end
+ rational_sequence.uniq
+ end
+end
+
+class PrimeSequence
+ include Enumerable
+
+ def initialize(elements_count)
+ @length = elements_count
+ end
+
+ def each
+ n = 2
+ loop do
+ if n.prime? then yield n end
+ n += 1
+ end
+ end
+
+ def to_a
+ enum_for(:each).take(@length)
+ end
+end
+
+class FibonacciSequence
+ include Enumerable
+
+ def initialize(elements_count, first: 1, second: 1)
+ @length = elements_count
+ @first = first
+ @second = second
+ end
+
+ def each
+ if @length.zero?
+ yield 0
+ return
+ end
+ previous, current = @first, @second
+ loop do
+ yield previous
+ previous, current = current, previous + current
+ end
+ end
+
+ def to_a
+ enum_for(:each).take(@length)
+ end
+end
+
+module DrunkenMathematician
+ module_function
+
+ def meaningless(n)
+ group_one = [Rational(1,1)]
+ group_two = [Rational(1,1)]
+ rationals = RationalSequence.new(n).to_a
+ rationals.each do |rational|
+ if rational.numerator.prime? and rational.denominator.prime?
+ group_one << rational
+ else
+ group_two << rational
+ end
+ end
+ group_one.reduce(&:*) / group_two.reduce(&:*)
+ end
+
+ def aimless(n)
+ primes = PrimeSequence.new(n).to_a
+ primes << 1 if n.odd?
+ prime_couples = primes.each_slice(2).map(&:to_a)
+ prime_rationals = prime_couples.map { |couple| Rational(*couple) }
+ prime_rationals.reduce(&:+)
+ end
+
+ def worthless(n)
+ nth_fibonacci = FibonacciSequence.new(n).to_a.last
+ rationals = RationalSequence.new(1)
+ rational_sequence = []
+ rationals.take_while do |rational|
+ rational_sequence << rational
+ rational_sequence.uniq.reduce(&:+) <= nth_fibonacci
+ end
+ rational_sequence.uniq[0..-2]
+ end
+end
+
+class Numeric
+
+ def prime?
+ (2..pred).all? { |number| self.remainder(number).nonzero? }
+ end
+end

Методи обнови решението на 26.10.2015 14:08 (преди над 9 години)

class RationalSequence
include Enumerable
def initialize(elements_count)
@length = elements_count
end
def each
return if @length.zero?
n = 2
loop do
(1..n.pred).each do |number|
yield Rational(number, n - number)
end
n += 1
end
end
+ def reciprocal(n)
+ (n.numerator + n.denominator).even? ? n : 1/n
+ end
+
def to_a
rational_sequence = []
enum_for(:each).take_while do |rational|
- order = (rational.numerator + rational.denominator).even?
- rational_sequence << (order ? rational : 1/rational)
+ rational_sequence << reciprocal(rational)
rational_sequence.uniq.length < @length
end
rational_sequence.uniq
end
end
class PrimeSequence
include Enumerable
def initialize(elements_count)
@length = elements_count
end
def each
n = 2
loop do
if n.prime? then yield n end
n += 1
end
end
def to_a
enum_for(:each).take(@length)
end
end
class FibonacciSequence
include Enumerable
def initialize(elements_count, first: 1, second: 1)
@length = elements_count
@first = first
@second = second
end
def each
if @length.zero?
yield 0
return
end
previous, current = @first, @second
loop do
yield previous
previous, current = current, previous + current
end
end
def to_a
enum_for(:each).take(@length)
end
end
module DrunkenMathematician
module_function
+ def reciprocal(n)
+ (n.numerator + n.denominator).even? ? n : 1/n
+ end
+
def meaningless(n)
group_one = [Rational(1,1)]
group_two = [Rational(1,1)]
rationals = RationalSequence.new(n).to_a
rationals.each do |rational|
if rational.numerator.prime? and rational.denominator.prime?
group_one << rational
else
group_two << rational
end
end
group_one.reduce(&:*) / group_two.reduce(&:*)
end
def aimless(n)
primes = PrimeSequence.new(n).to_a
primes << 1 if n.odd?
prime_couples = primes.each_slice(2).map(&:to_a)
prime_rationals = prime_couples.map { |couple| Rational(*couple) }
prime_rationals.reduce(&:+)
end
def worthless(n)
nth_fibonacci = FibonacciSequence.new(n).to_a.last
rationals = RationalSequence.new(1)
rational_sequence = []
rationals.take_while do |rational|
- rational_sequence << rational
+ rational_sequence << DrunkenMathematician.reciprocal(rational)
rational_sequence.uniq.reduce(&:+) <= nth_fibonacci
end
rational_sequence.uniq[0..-2]
end
end
class Numeric
def prime?
(2..pred).all? { |number| self.remainder(number).nonzero? }
end
end

Методи обнови решението на 26.10.2015 14:19 (преди над 9 години)

class RationalSequence
include Enumerable
def initialize(elements_count)
@length = elements_count
end
def each
return if @length.zero?
n = 2
loop do
(1..n.pred).each do |number|
yield Rational(number, n - number)
end
n += 1
end
end
def reciprocal(n)
(n.numerator + n.denominator).even? ? n : 1/n
end
def to_a
rational_sequence = []
enum_for(:each).take_while do |rational|
rational_sequence << reciprocal(rational)
rational_sequence.uniq.length < @length
end
rational_sequence.uniq
end
end
class PrimeSequence
include Enumerable
def initialize(elements_count)
@length = elements_count
end
def each
n = 2
loop do
if n.prime? then yield n end
n += 1
end
end
def to_a
enum_for(:each).take(@length)
end
end
class FibonacciSequence
include Enumerable
def initialize(elements_count, first: 1, second: 1)
@length = elements_count
@first = first
@second = second
end
def each
if @length.zero?
yield 0
return
end
previous, current = @first, @second
loop do
yield previous
previous, current = current, previous + current
end
end
def to_a
enum_for(:each).take(@length)
end
end
module DrunkenMathematician
module_function
- def reciprocal(n)
- (n.numerator + n.denominator).even? ? n : 1/n
- end
-
def meaningless(n)
group_one = [Rational(1,1)]
group_two = [Rational(1,1)]
rationals = RationalSequence.new(n).to_a
rationals.each do |rational|
if rational.numerator.prime? and rational.denominator.prime?
group_one << rational
else
group_two << rational
end
end
group_one.reduce(&:*) / group_two.reduce(&:*)
end
def aimless(n)
primes = PrimeSequence.new(n).to_a
primes << 1 if n.odd?
prime_couples = primes.each_slice(2).map(&:to_a)
prime_rationals = prime_couples.map { |couple| Rational(*couple) }
prime_rationals.reduce(&:+)
end
def worthless(n)
nth_fibonacci = FibonacciSequence.new(n).to_a.last
rationals = RationalSequence.new(1)
rational_sequence = []
rationals.take_while do |rational|
- rational_sequence << DrunkenMathematician.reciprocal(rational)
+ rational_sequence << rationals.reciprocal(rational)
rational_sequence.uniq.reduce(&:+) <= nth_fibonacci
end
rational_sequence.uniq[0..-2]
end
end
class Numeric
def prime?
(2..pred).all? { |number| self.remainder(number).nonzero? }
end
end

Методи обнови решението на 26.10.2015 16:59 (преди над 9 години)

class RationalSequence
include Enumerable
def initialize(elements_count)
@length = elements_count
end
def each
return if @length.zero?
- n = 2
+ rational_sum = 2
loop do
- (1..n.pred).each do |number|
- yield Rational(number, n - number)
+ (1..rational_sum.pred).each do |number|
+ yield reciprocal Rational(number, rational_sum - number)
end
- n += 1
+ rational_sum += 1
end
end
def reciprocal(n)
(n.numerator + n.denominator).even? ? n : 1/n
end
def to_a
rational_sequence = []
enum_for(:each).take_while do |rational|
- rational_sequence << reciprocal(rational)
+ rational_sequence << rational
rational_sequence.uniq.length < @length
end
rational_sequence.uniq
end
end
class PrimeSequence
include Enumerable
def initialize(elements_count)
@length = elements_count
end
def each
- n = 2
- loop do
- if n.prime? then yield n end
- n += 1
+ number = 2
+ counter = 0
+ while counter < @length do
+ if number.prime?
+ yield number
+ counter += 1
+ end
+ number += 1
end
end
-
- def to_a
- enum_for(:each).take(@length)
- end
end
class FibonacciSequence
include Enumerable
def initialize(elements_count, first: 1, second: 1)
@length = elements_count
@first = first
@second = second
end
def each
- if @length.zero?
- yield 0
- return
- end
previous, current = @first, @second
- loop do
+ @length.times.each do
yield previous
previous, current = current, previous + current
end
end
-
- def to_a
- enum_for(:each).take(@length)
- end
end
module DrunkenMathematician
module_function
def meaningless(n)
group_one = [Rational(1,1)]
group_two = [Rational(1,1)]
rationals = RationalSequence.new(n).to_a
rationals.each do |rational|
if rational.numerator.prime? and rational.denominator.prime?
group_one << rational
else
group_two << rational
end
end
group_one.reduce(&:*) / group_two.reduce(&:*)
end
def aimless(n)
primes = PrimeSequence.new(n).to_a
primes << 1 if n.odd?
prime_couples = primes.each_slice(2).map(&:to_a)
prime_rationals = prime_couples.map { |couple| Rational(*couple) }
prime_rationals.reduce(&:+)
end
def worthless(n)
nth_fibonacci = FibonacciSequence.new(n).to_a.last
rationals = RationalSequence.new(1)
rational_sequence = []
rationals.take_while do |rational|
- rational_sequence << rationals.reciprocal(rational)
+ rational_sequence << rational
rational_sequence.uniq.reduce(&:+) <= nth_fibonacci
end
rational_sequence.uniq[0..-2]
end
end
class Numeric
def prime?
(2..pred).all? { |number| self.remainder(number).nonzero? }
end
end