Qual è il modo più Ruby-simile di generare ogni combinazione unica di 3 interi positivi che aggiungono fino a 100

Question

Condizioni

a + b + c = 100 
a,b,c positive integers or 0 

output desiderato:

[ 
    [0,0,100], 
    [0,1,99 ], 
    ... # all other permutations 
    [99,1,0 ], 
    [100,0,0] 
] 

StackOverflow dice il mio post non ha molto contesto per spiegare le sezioni del codice. Sei d'accordo? (Questo è il testo di riempimento per soddisfare le sue esigenze)

Answer 1

che avrei scritto:

(0..100).flat_map { |x| (0..100-x).map { |y| [x, y, 100-x-y] } } 
#=> [[0, 0, 100], [0, 1, 99]], ..., [99, 1, 0], [100, 0, 0]] 

nota Sito 1: questo è un classico esempio in cui la lista-comprensioni brillantezza (e ancora di più se ci fosse una condizione da qualche parte). Poiché Ruby non ha LC, dobbiamo eseguire la conversione tipica in OOP: N-1flat_map 's + map. Sarebbe fantastico avere LC in Ruby (controllare this feature request), Scala ha dimostrato che anche un puro linguaggio OOP trae molto vantaggio da questo zucchero sintattico (sebbene io possa capire la prevenzione dagli sviluppatori a causa del protocollo/metodo implicito iterabile). Su un rubino immaginario che li ha sostenuti devi scrivere:

[[x, y, 100-x-y] for x in 0..100 for y in 0..100-x] # imaginary Ruby 

Nota a margine 2: Immagina che si preferisce una soluzione meno dispendiosa di memoria (che probabilmente non è necessario l'intero array). Una soluzione pigra con Ruby 2.0 richiede solo di aggiungere un paio di [lazy][2] deleghe:

(0..100).lazy.flat_map { |x| (0..100-x).lazy.map { |y| [x, y, 100-x-y] } } 

Nota a margine 3: Solo per completezza, in linea di risposta @akuhn, un'altra soluzione pigra utilizzando enumeratori:

Enumerator.new do |e| 
    (0..100).each { |x| (0..100-x).each { |y| e.yield([x, y, 100-x-y]) } } 
end 

Answer 2

Ecco la mia soluzione

for a in 0..100; for b in 0..100-a; p [a,b,100-a-b]; end; end 

che trovo si legge quasi come @ di tokland di lista. Se si desidera utilizzare i valori più a valle anziché stampa, inserire il codice in un metodo generatore

def generate 
    return enum_for(:generate) unless block_given? 
    for a in 0..100 
    for b in 0..100-a 
     yield [a,b,100-a-b] 
    end 
    end 
end 

che viene quindi utilizzato come

generate { |a,b,c| puts [a,b,c] } 

o come nel

generate { |each| p each } 

o come

p generate.to_a 

che tutti stampano tutte le tuple generate.

Answer 3

direi modo più rubino-ish (che non è affatto il modo più efficiente) è presente:

(0..100).to_a.repeated_permutation(3).find_all{|triplet|triplet.inject(:+)==100} 

L'unica parte non trasparente di questa catena è il to_a, che converte l'oggetto intervallo dato da (0..100) in un array (gli intervalli sono pigri, il che non funziona con repeated_permutation).