Produkt kartezjański Ruby

Question

class CartesianProduct 
include Enumerable 
# your code here 
end 
#Examples of use 
c = CartesianProduct.new([:a,:b], [4,5]) 
c.each { |elt| puts elt.inspect } 
# [:a, 4] 
# [:a, 5] 
# [:b, 4] 
# [:b, 5] 
c = CartesianProduct.new([:a,:b], []) 
c.each { |elt| puts elt.inspect } 
# (nothing printed since Cartesian product 
# of anything with an empty collection is empty) 

Jestem nowy w ruby. Rozumiem, jak zdefiniować metodę instancji produktu kartezjańskiego, ale nie mam o tym pojęcia. Jak utworzyć obiekt klasy, aby spełnić wymagania.

Answer 1

Nie chciałbym użyć klasy za to, ale zachowując strukturę pytanie, chciałbym napisać:

class CartesianProduct 
    include Enumerable 

    def initialize(xs, ys) 
    @xs = xs 
    @ys = ys 
    end 

    def each 
    return to_enum unless block_given? 
    @xs.each do |x| 
     @ys.each { |y| yield [x, y] } 
    end 
    end 
end 

Zamiast tego, bym po prostu napisać xs.product(ys) lub zbudować własną Array#lazy_product jeśli lenistwo były ważne (patrz: ticket).

Answer 2

Proponuję użyć Array#product.

[:a, :b].product [4,5] 

Co przyniesie pożądane wyniki.

irb(main):001:0> [:a, :b].product [4,5] 
=> [[:a, 4], [:a, 5], [:b, 4], [:b, 5]] 
irb(main):002:0> 

Jeśli chcesz leniwego generatora permutacji, napisałem coś takiego wcześniej. Ale ostrzegam, jeśli masz dużą liczbę permutacji do obliczenia, może to trochę potrwać. Powinieneś być w stanie wziąć to, czego potrzebujesz od pierwszych 40 - 45 linii this file (ten plik i tak był eksperymentem).

Sztuką jest zbudowanie modułów wyliczających przy użyciu Ruby 1.9.2, aby przejść przez szereg tablic. Najpierw zbudujesz moduł wyliczający, który będzie cyklicznie przechodził przez macierz, aw module wyliczającym tablicę będziesz śledził pierwszy zestaw wyjściowy i zakończy pętlę, gdy zostanie trafiony po raz drugi. To był jedyny sposób, w jaki mogłem wymyślić, jak zakończyć taką pętlę.

def infinite_iterator(array) 
    Enumerator.new do |result| 
    loop do 
     array.cycle { |item| result << item } 
    end 
    end 
end 

def cartesian_iterator(data) 
    Enumerator.new do |result| 
    first = data.map { |p| p.next } 
    result << first 

    i = 1 
    parts = first.dup 
    loop do 
     parts[2-i] = data[2-i].next 
     break if parts == first 

     result << parts.join 
     i = ((i + 1) % parts.size) 
    end 
    end 
end 

array = [ infinite_iterator([:a,:b]), infinite_iterator([4,5]) ] 
generator = cartesian_iterator(array) 

generator.each { |a| p a } 

Answer 3

Musisz określić metodę each w swojej klasie, który wywołuje yield dla każdej kombinacji produktu.

Można użyć Array#product, ale zwraca tablicę, więc nie jest leniwy.

Jest proposal for Array.product w Ruby 2.0, który by to zrobił.