Array-Unterschied erster Ordnung in Ruby

Question

Was ist der glatteste, Ruby-ähnliche Weg, dies zu tun?

[1, 3, 10, 5].diff 

sollte

[2, 7, -5] 

erzeugen, das heißt, eine Anordnung von Differenzen erster Ordnung. Ich habe eine Lösung gefunden, die ich unten hinzufügen werde, aber es erfordert Rubin 1.9 und ist nicht ganz so glatt. Was ist noch möglich?

Answer 1

Noch ein anderes way..Seems die kürzeste bisher :)

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 

Beispiel:

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

Answer 3

Das Konzept stammt aus der funktionalen Programmierung, natürlich:

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

[1,3,10,5].diff 

Beachten Sie, dass keine separaten Zwischenvariablen hier brauchen

Answer 4

Eine andere Möglichkeit, es zu tun.

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

Ich mag diese funktionalen Stil:

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

EDIT: Ich habe erkannt, dass die reverse völlig unnötig ist. Wenn dies eine funktionale Sprache wäre, hätte ich die Mustererkennung verwendet, aber Ruby unterstützt keine Mustererkennung. Es tut, unterstützt jedoch Destrukturierung binden, die eine gute Näherung für die Mustererkennung in diesem Fall ist.

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

Kein smiley, obwohl.

Ich mag, wie das klingt, wenn Sie es gerade von links nach rechts vorlesen: "Wenden Sie für jedes Paar die Differenz zwischen dem ersten und zweiten Element des Paares an." In der Tat, ich mag normalerweise nicht den Namen collect und bevorzugen map statt, aber in diesem Fall, der liest noch besser: „Für jedes Paar, den Unterschied zwischen seinen Elementen sammeln“

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

Klingt fast wie eine Definition von erster Ordnung Unterschied.

Answer 6

Mein schwacher Versuch ...

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

Hier den schnellsten Weg, die ich finden konnte (schneller als alle andere vorgeschlagen hier ab diesem Moment, in beide 1.8 und 1.9):

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

Mit diesem engen Runner-up:

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

Von den anderen hier ist Testrs selbstbeschriebener "schwacher" Versuch der zweitschnellste, aber er ist immer noch langsamer als beide.

Und wenn die Geschwindigkeit keine Rolle spielt, hier ist mein ästhetischer Favorit: hier

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

    def diff 
    dup.diff! 
    end 
end 

Aber das ist (aus Gründen, verstehe ich nicht ganz) eine Größenordnung langsamer als jeder anderer Vorschlag!

Answer 8

Minor Variante Jörg W Mittag suchen:

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