Tengo una serie de enteros.

Por ejemplo:

array = [123,321,12389]

¿Hay alguna forma agradable de obtener la suma de ellos?

Yo sé eso

sum = 0
array.each { |a| sum+=a }

trabajaría.

Prueba esto:

array.inject(0){|sum,x| sum + x }

Ver la documentación enumerable de Ruby

(nota: el 0caso base es necesario para que 0se devuelva en una matriz vacía en lugar de nil)

O prueba la forma Ruby 1.9:

array.inject(0, :+)

Nota: el 0caso base es necesario; de lo contrario nil, se devolverá en matrices vacías:

> [].inject(:+)
nil
> [].inject(0, :+)
0

array.reduce(0, :+)

Si bien es equivalente a array.inject(0, :+), el término reducir está entrando en una lengua vernácula más común con el surgimiento de los modelos de programación MapReduce .

inyectar , reducir , plegar , acumular y comprimir son sinónimos de una clase de funciones de plegado . Considero que la coherencia en su código base es lo más importante, pero dado que varias comunidades tienden a preferir una palabra sobre otra, de todos modos es útil conocer las alternativas.

Para enfatizar el lenguaje de reducción de mapas, aquí hay una versión que es un poco más indulgente con lo que termina en esa matriz.

array.map(&:to_i).reduce(0, :+)

Algunas lecturas relevantes adicionales:

• http://ruby-doc.org/core-1.9.3/Enumerable.html#method-i-inject
• http://en.wikipedia.org/wiki/MapReduce
• http://en.wikipedia.org/wiki/Fold_(higher-order_function)

Alternativamente (solo para comparación), si tiene Rails instalado (en realidad solo ActiveSupport):

require 'activesupport'
array.sum

Para Ruby> = 2.4.0 puede usar sumde Enumerables.

[1, 2, 3, 4].sum

Es peligroso para las clases base mokeypatch. Si le gusta el peligro y utiliza una versión anterior de Ruby, puede agregar #suma la Arrayclase:

class Array
  def sum
    inject(0) { |sum, x| sum + x }
  end
end

Nuevo para Ruby 2.4.0

Puede usar el método acertadamente nombrado Enumerable#sum. Tiene muchas ventajas, inject(:+)pero también hay algunas notas importantes para leer al final.

Ejemplos

Rangos

(1..100).sum
#=> 5050

Matrices

[1, 2, 4, 9, 2, 3].sum
#=> 21

[1.9, 6.3, 20.3, 49.2].sum
#=> 77.7

Nota IMPORTANTE

Este método no es equivalente a #inject(:+). Por ejemplo

%w(a b c).inject(:+)
#=> "abc"
%w(a b c).sum
#=> TypeError: String can't be coerced into Integer

También,

(1..1000000000).sum
#=> 500000000500000000 (execution time: less than 1s)
(1..1000000000).inject(:+)
#=> 500000000500000000 (execution time: upwards of a minute)

Consulte esta respuesta para obtener más información sobre por qué sumes así.

Ruby 2.4+ / Rails - array.sumes decir[1, 2, 3].sum # => 6

Ruby pre 2.4 - array.inject(:+)oarray.reduce(:+)

* Nota: El #summétodo es una nueva adición a 2.4, por enumerablelo que ahora podrá usarlo array.sumen rubí puro, no solo en Rails.

Solo por el bien de la diversidad, también puede hacer esto si su matriz no es una matriz de números, sino una matriz de objetos que tienen propiedades que son números (por ejemplo, cantidad):

array.inject(0){|sum,x| sum + x.amount}

ruby 1.8.7 way es el siguiente:

array.inject(0, &:+) 

Simplemente puede usar:

    example = [1,2,3]
    example.inject(:+)

Esto es suficiente [1,2,3].inject('+')

Se lanza Ruby 2.4.0 y tiene un método Enumerable # sum . Entonces puedes hacer

array.sum

Ejemplos de los documentos:

{ 1 => 10, 2 => 20 }.sum {|k, v| k * v }  #=> 50
(1..10).sum                               #=> 55
(1..10).sum {|v| v * 2 }                  #=> 110

También permite [1,2].sum{|x| x * 2 } == 6:

# http://madeofcode.com/posts/74-ruby-core-extension-array-sum
class Array
  def sum(method = nil, &block)
    if block_given?
      raise ArgumentError, "You cannot pass a block and a method!" if method
      inject(0) { |sum, i| sum + yield(i) }
    elsif method
      inject(0) { |sum, i| sum + i.send(method) }
    else
      inject(0) { |sum, i| sum + i }
    end
  end
end

para una matriz con valores nulos podemos hacer compactos y luego inyectar la suma ex

a = [1,2,3,4,5,12,23.45,nil,23,nil]
puts a.compact.inject(:+)

array.reduce(:+)

Funciona también para rangos ... por lo tanto,

(1..10).reduce(:+) returns 55

Si te sientes golfista, puedes hacer

eval([123,321,12389]*?+)

Esto creará una cadena "123 + 321 + 12389" y luego usará la función eval para hacer la suma. Esto es solo para fines de golf , no debe usarlo en el código adecuado.

Método 1:

    [1] pry(main)> [1,2,3,4].sum
    => 10
    [2] pry(main)> [].sum
    => 0
    [3] pry(main)> [1,2,3,5,nil].sum
    TypeError: nil can't be coerced into Integer

Método 2:

   [24] pry(main)> [].inject(:+)
   => nil
   [25] pry(main)> [].inject(0, :+)
   => 0
   [4] pry(main)> [1,2,3,4,5].inject(0, :+)
   => 15
   [5] pry(main)> [1,2,3,4,nil].inject(0, :+)
   TypeError: nil can't be coerced into Integer
   from (pry):5:in `+'

Método 3:

   [6] pry(main)> [1,2,3].reduce(:+)
   => 6
   [9] pry(main)> [].reduce(:+)
   => nil
   [7] pry(main)> [1,2,nil].reduce(:+)
   TypeError: nil can't be coerced into Integer
   from (pry):7:in `+'

Método 4: cuando la matriz contiene valores nulos y vacíos, de manera predeterminada si utiliza alguna de las funciones anteriores, reduzca, sume, inyecte todo a través del

TypeError: nil no se puede convertir en Integer

Puedes superar esto,

   [16] pry(main)> sum = 0 
   => 0
   [17] pry(main)> [1,2,3,4,nil, ''].each{|a| sum+= a.to_i }
   => [1, 2, 3, 4, nil, ""]
   [18] pry(main)> sum
   => 10

Método 6: eval

Evalúa las expresiones de Ruby en cadena.

  [26] pry(main)> a = [1,3,4,5]
  => [1, 3, 4, 5]
  [27] pry(main)> eval a.join '+'
  => 13
  [30] pry(main)> a = [1,3,4,5, nil]
  => [1, 3, 4, 5, nil]
  [31] pry(main)> eval a.join '+'
  SyntaxError: (eval):1: syntax error, unexpected end-of-input
  1+3+4+5+

3 formas en que podemos hacer la suma de la matriz

1) array.inject(0){|sum,x| sum + x }

2) array.inject('+')

3) array.join('+')

O puedes probar este método:

def sum arr
  0 if arr.empty
  arr.inject :+
end

Este es el camino más corto. Intentalo.

array.inject :+

number = [1..100]

number. each do |n|

    final_number = n.sum

    puts "The sum is #{final_number}"
end

* Esto funcionó bien para mí como nuevo desarrollador. Puede ajustar su rango de números cambiando los valores dentro de []

También puedes hacerlo de manera fácil

def sum(numbers)
  return 0 if numbers.length < 1
  result = 0
  numbers.each { |num| result += num }
  result
end

Puede usar .map y .sum como:

array.map { |e| e }.sum