Come creare un ciclo annidato con Ruby "Right Way!"?

Question

Sono nel processo di apprendimento Ruby, prendendo MOOC del Berkeley, e, in alcuni dei compiti di questi MOOC abbiamo un esercizio che dice:

definire un metodo sum_to_n? che accetta un array di interi e un intero aggiuntivo , n, come argomenti e restituisce true se due elementi nella matrice di numeri interi sono pari a n. Un array vuoto deve sommare a zero per definizione.

Ho già creato due metodi che possono svolgere il lavoro, ma non mi sento a mio agio con nessuno di loro perché penso che non siano scritti in Ruby Way. Spero che alcuni di voi possano aiutarmi ad imparare quale sarebbe la strada giusta!

Il primo metodo che ho fatto utilizza il metodo each per entrambe le iterazioni, ma quello che non mi piace di questo metodo è che ogni numero viene sommato ad ogni altro numero, anche con lo stesso numero, fare qualcosa di simile:

arr[1, 2, 3, 4] => 1+1, 1+2, 1+3, 1+4, 2+1, 2+2, 2+3, 2+4, 3+1, 3+2... 4+3, 4+4 

Come potete vedere, ci sono un sacco di somme ripetute, e io non voglio quello.

Questo è il codice:

def sum_to_n?(arr, n) 
    arr.each {|x| arr.each {|y| return true if x + y == n && x != y}} 
    return true if n == 0 && arr.length == 0 
    return false 
end 

Con l'altro metodo ho ottenuto quello che volevo, a pochi somme senza ripetere uno di essi o anche sommando gli stessi numeri, ma sembra orribile, e io' m abbastanza sicuro che qualcuno piacerebbe uccidermi per fare in questo modo, ma il metodo fa un ottimo lavoro come si può vedere:

arr[1, 2, 3, 4] => 1+2, 1+3, 1+4, 2+3, 2+4, 3+4 

questo è il codice:

def sum_to_n?(arr, n) 
    for i in 0..arr.length - 1 
    k = i + 1 
    for k in k..arr.length - 1 
     sum = arr[i] + arr[k] 
     if sum == n 
     return true 
     end 
    end 
    end 
    return true if n == 0 && arr.length == 0 
    return false 
end 

Bene, spero che voi ragazzi vi divertiate a fare un metodo migliore e più grazioso come ho provato.

Grazie per il vostro aiuto.

Answer 1

che avrei scritto così:

def sum_to_n?(arr, n) 
    return true if arr.empty? && n.zero? 
    arr.combination(2).any? {|a, b| a + b == n } 
end 

che sembra essere una soluzione abbastanza Rubyish.

Answer 2

Questo farà in O(n.log(n)) piuttosto che O(n²): risposta

a = 1, 2, 3, 4 

class Array 
    def sum_to? n 
    unless empty? 
     false.tap { 
     i, j, sorted = 0, size - 1, sort 
     loop do 
      break if i == j 
      a, b = sorted[i], sorted[j] 
      sum = a + b 
      return a, b if sum == n 
      sum < n ? i += 1 : j -= 1 
     end 
     } 
    end 
    end 
end 

a.sum_to? 7 #=> [3, 4] 

Answer 3

Accanto @ di Jorg-w-Mittag. Ho trovato un'altra soluzione usando "permutazione".

https://stackoverflow.com/a/19351660/66493

def sum_to_n?(arr, n) 
    (arr.empty? && n.zero?) || arr.permutation(2).any? { |a, b| a + b == n } 
end 

non sapeva di permutazione prima. Ancora come @ risposta jorg-w-mittag perché è più leggibile.

Answer 4

Mi sono imbattuto in questo CodeWars. Il accepted answer sembra davvero molto rubino, ma è a costo di prestazioni.Chiamando arr.combination(2) si ottengono molte combinazioni, sarebbe più semplice esaminare l'elemento array per elemento e cercare se il 'complemento' sum - element esiste. Ecco come che sarebbe simile -

def sum_to_n?(arr, n) 
    (arr.empty? and n.zero?) or arr.any? { |x| arr.include?(n - x) } 
end 

Answer 5

ho avuto un pensiero che all'inizio di ogni risposta a questa domanda dovrebbe probabilmente iniziare con potatura l'array per i dati superflui:

non possono utilizzare questo:

arr.select! { |e| e <= n } # may be negative values  

ma questo potrebbe aiutare:

arr.sort! 
    while arr[0] + arr[-1] > n # while smallest and largest value > n 
    arr.delete_at(-1) # delete largest vaue 
    end