Comment la somme de tableau de nombres en Ruby?

Essayez ceci:

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

Voir Ruby Énumérable de la Documentation

(note: le 0 cas de base est nécessaire afin que les 0 sera renvoyé sur un tableau vide au lieu de nil)

array.reduce(0, :+)

Alors que l'équivalent de array.inject(0, :+), le terme réduire entre dans une commune de la langue vernaculaire à la montée de Les modèles de programmation MapReduce.

injecter, réduire, fois, accumuler, et compresser sont synonymes comme une classe de fonctions de pliage. - Je trouver de la cohérence dans l'ensemble de votre base de code plus important, mais depuis que les différentes communautés ont tendance à préférer un mot par un autre, il est néanmoins utile de connaître les alternatives.

À souligner la carte-réduire le verbiage, voici une version un peu plus indulgent sur ce qui se retrouve dans ce tableau.

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

Certains pertinentes supplémentaires de lecture:

• 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_(plus-order_function)

Pour Ruby >=2.4.0 vous pouvez utiliser sum de Enumerables.

[1, 2, 3, 4].sum

Il est dangereux de mokeypatch classes de base. Si vous aimez le danger, et en utilisant une ancienne version de Ruby, vous pouvez ajouter #sum à la Array classe:

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

Juste pour le plaisir de la diversité, vous pouvez également le faire si votre tableau n'est pas un tableau de nombres, mais plutôt un tableau d'objets qui ont des propriétés qui sont des nombres (par exemple, quantité):

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

ruby 1.8.7 est la suivante:

array.inject(0, &:+) 

Ruby 2.4.0 est sorti, et il a une Énumérable#somme méthode. Ainsi, vous pouvez faire

array.sum

Exemples de la documentation:

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

Permet également [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

array.reduce(:+)

Fonctionne pour Plages trop...
par conséquent,

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

Méthode 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éthode 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éthode 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éthode 4:
Lorsque le Tableau contient un néant et le vide des valeurs par défaut si vous utilisez toutes les fonctions ci-dessus réduire, somme, injecter tout ce qui va par le biais de la

TypeError: nul ne peut être contraint de Entier

Vous pouvez surmonter cela,

   [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éthode 6:
eval

Évalue le Rubis expression(s) dans la chaîne.

  [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+

C'est le chemin le plus court. L'essayer.

array.inject :+

3 façons de faire la somme de la matrice de

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

2) array.inject('+')

3) array.join('+')

Vous pouvez utiliser .carte et .somme comme:

array.map { |e| e }.sum