Differenza dell'array del primo ordine in Ruby

Question

Qual è il modo più intelligente, più simile a Ruby per farlo?

[1, 3, 10, 5].diff 

dovrebbe produrre

[2, 7, -5] 

cioè una serie di differenze del primo ordine. Ho trovato una soluzione che aggiungerò qui di seguito, ma richiede Ruby 1.9 e non è poi così liscia. cos'altro è possibile?

Answer 1

Ancora un altro way..Seems più breve finora :)

module Enumerable 
    def diff 
     self[1..-1].zip(self).map {|x| x[0]-x[1]} 
    end  
    end 

Answer 2

# Attempt, requires ruby 1.9. 
module Enumerable 
    def diff 
    each_cons(2).with_object([]){|x,array| array << x[1] - x[0]} 
    end 
end 

Esempio:

[1,3,10,5].diff 
=> [2, 7, -5] 

Answer 3

Il concetto viene dalla programmazione funzionale, naturalmente:

module Enumerable 
    def diff 
    self.inject([0]) { |r,x| r[-1] += x; r << -x } [1..-2] 
    end 
end 

[1,3,10,5].diff 

Si noti che non è necessario alcun variabili intermedie separati qui

Answer 4

Un altro modo per farlo.

module Enumerable 
    def diff 
    result = [] 
    each_with_index{ |x, i| 
     return result if (i == (self.length-1)) 
     result << self[i+1] - x 
    } 
    end 
end 

Answer 5

mi piace questo stile funzionale:

module Enumerable 
    def diff 
    each_cons(2).map {|pair| pair.reverse.reduce :-} 
    end 
end 

EDIT: Ho appena realizzato che il reverse è del tutto inutile. Se si trattasse di un linguaggio funzionale, avrei utilizzato la corrispondenza dei modelli, ma Ruby non supporta la corrispondenza dei modelli. Lo fa, tuttavia, supporta il bind di destrutturazione, che è un'approssimazione abbastanza buona per la corrispondenza del modello in questo caso.

each_cons(2).map {|first, second| second - first} 

Nessun smile, comunque.

Mi piace come suona questa cosa se la leggete ad alta voce da sinistra a destra: "Per ogni coppia, applica la differenza tra il primo e il secondo elemento della coppia." In realtà, io di solito non mi piace il nome collect e preferiscono map invece, ma in questo caso, che recita ancora meglio: "Per ogni coppia, raccogliere la differenza tra i suoi elementi"

each_cons(2).collect {|first, second| second - first} 

Sembra quasi una definizione della differenza del primo ordine.

Answer 6

mio debole tentativo ...

module Enumerable 
    def diff 
    na = [] 
    self.each_index { |x| r << self[x]-self[x-1] if x > 0 } 
    na 
    end 
end 

p [1,3,10,5].diff #returned [2, 7, -5] 

Answer 7

Ecco il modo più veloce che ho trovato (più veloce di tutti gli altri hanno suggerito qui da questo momento, sia 1.8 e 1.9):

module Enumerable 
    def diff 
    last=nil 
    map do |x| 
     r = last ? x - last : nil 
     last = x 
     r 
    end.compact 
    end 
end 

Con questa close runner-up:

012.

module Enumerable 
    def diff 
    r = [] 
    1.upto(size-1) {|i| r << self[i]-self[i-1]} 
    r 
    end 
end 

Degli altri qui, il tentativo "debole" descritto da Testr è il più veloce, ma è ancora più lento di uno di questi.

E se la velocità non è oggetto, ecco il mio preferito estetica:

module Enumerable 
    def diff! 
    [-shift+first] + diff! rescue [] 
    end 

    def diff 
    dup.diff! 
    end 
end 

Ma questo è (per ragioni che non capisco del tutto) un ordine di grandezza più lento rispetto a qualsiasi altro suggerimento qui!

Answer 8

variazione minore su Jörg W Mittag di:

module Enumerable 
    def diff 
    each_cons(2).map{|a,b| b-a} 
    end 
end