Различие в массиве первого порядка в Ruby

это - Сингл

, см. здесь для большего количества информации о SQL Server к.Net DataTypes

6
задан Peter 17 October 2009 в 10:40
поделиться

8 ответов

Еще один способ .. Кажется, самый короткий пока :)

  module Enumerable
    def diff
        self[1..-1].zip(self).map {|x| x[0]-x[1]}
    end    
  end
2
ответ дан 8 December 2019 в 17:23
поделиться

Мне нравится этот функциональный стиль:

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

РЕДАКТИРОВАТЬ: Я только что понял, что обратный совершенно не нужен. Если бы это был функциональный язык, я бы использовал сопоставление с образцом, но Ruby не поддерживает сопоставление с образцом. Он поддерживает , однако поддерживает связывание с деструктуризацией, что в данном случае является достаточно хорошим приближением для сопоставления с образцом.

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

Однако смайлика нет.

Мне нравится, как это звучит, если вы просто прочитаете его громко слева направо: «Для каждой пары примените разницу между первым и вторым элементами пары». На самом деле, мне обычно не нравится имя collect , и я предпочитаю вместо него map , но в данном случае это читается даже лучше:

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

«Для каждой пары,

5
ответ дан 8 December 2019 в 17:23
поделиться

Концепция, конечно же, исходит из функционального программирования :

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

[1,3,10,5].diff

Обратите внимание, что здесь вам не нужны отдельные промежуточные переменные

2
ответ дан 8 December 2019 в 17:23
поделиться

Вот самый быстрый способ, который я смог найти (быстрее, чем все другие предложенные здесь на данный момент, как в 1.8, так и в 1.9):

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

С этим близким вторым игроком:

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

Из других представленных здесь тестировщиком "слабая" попытка является следующей по скорости, но все же медленнее, чем любая из них.

И если скорость не имеет значения, вот мой эстетический фаворит:

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

  def diff
    dup.diff!
  end
end

Но это (для причины, которые я не совсем понимаю) на порядок медленнее, чем любое другое предложение здесь!

2
ответ дан 8 December 2019 в 17:23
поделиться
# Attempt, requires ruby 1.9.
module Enumerable
  def diff
    each_cons(2).with_object([]){|x,array| array << x[1] - x[0]}
  end
end

Пример:

[1,3,10,5].diff
=> [2, 7, -5]
1
ответ дан 8 December 2019 в 17:23
поделиться

Другой способ сделать это.

module Enumerable
  def diff
    result = []
    each_with_index{ |x, i|
      return result if (i == (self.length-1))
      result << self[i+1] - x
    }
  end
end
0
ответ дан 8 December 2019 в 17:23
поделиться

Моя безуспешная попытка ...

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]
0
ответ дан 8 December 2019 в 17:23
поделиться

Незначительная вариация на тему Йорга Миттага:

module Enumerable
  def diff
    each_cons(2).map{|a,b| b-a}
  end
end
2
ответ дан 8 December 2019 в 17:23
поделиться
Другие вопросы по тегам:

Похожие вопросы: