MULTIPLIER un ELEMENT de tableau dans la boucle while ruby

Vous pouvez parcourir un tableau inversé avec des index, puis inverser le résultat Array # reverse i% 3 est utilisé pour multiplier chaque 3ème élément.

L'erreur méthode non définie * 'pour nil: NilClass (NoMethodError) dans votre exemple apparaît car array.length est 16 (éléments dans le tableau), mais les index commencent à 0 , donc le dernier index est 15, et dans la première itération, vous essayez d'accéder au tableau [16] qui n'existe pas, donc c'est nil

array = [4, 2, 4, 2, 4, 2, 4, 2, 4, 2, 4, 2, 4, 2, 4, 2, 99]
p array.map.with_index { |n, i| i.odd? ? n * 2 : n } # WRONG RESULT
#=>[4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 99]
p array.reverse.map.with_index { |n, i| i.even? ? n * 2 : n }.reverse
#=>[8, 2, 8, 2, 8, 2, 8, 2, 8, 2, 8, 2, 8, 2, 8, 2, 198]

MISE À JOUR: La réponse de Sekalf Nroc est bonne avec impair? si vous avez besoin que chaque 2ème élément se multiplie, mais si vous aviez par exemple 15 éléments, vous pourriez voir de l'inattendu résultats, donc reverse encore nécessaire pour faire reculer le tableau, en combinant ces approches, vous pouvez faire quelque chose comme ceci:

array = [4, 2, 4, 2, 4, 2, 4, 2, 4, 2, 4, 2, 4, 2, 4, 2]
result = array.reverse.each_with_index.map do |x, i|
  (i % 3).zero? ? x * 2 : x
end.reverse
# p result
#=> [8, 2, 4, 4, 4, 2, 8, 2, 4, 4, 4, 2, 8, 2, 4, 4]

Si vous corrigez l'indexation comme d'autres l'ont suggéré, et modifiez les troisième et quatrième lignes pour modifier réellement les variables de tableau et d'index, alors votre code fonctionne comme prévu pour tout tableau avec un nombre pair d'éléments.

array.map.with_index { |n, i| i.odd? ? n * 2 : n }
# Or if you prefer,
array.map.with_index { |n, i| if i.odd? then n * 2 else n end }

#=> [4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4]

Vous pouvez également effectuer l'opération sur une ligne en utilisant map.with_index en profitant du fait que chaque deuxième élément d'un tableau aura un index qui est un nombre impair.

index = array.length - 1
while index > 0
  array[index] *= 2
  index -= 2
end

# array now =='s [4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4]

Vous pouvez utiliser une plage, qui fournit le Méthode Range # step . Par exemple, étant donné le tableau:

#=> [1, 3, 5, 7, 9, 11, 13, 15]

C'est un moyen pour "multiplier chaque deuxième élément par 2 en reculant dans le tableau" en utilisant Array # reverse_each :

(1...ary.size).step(2).each { |i| ary.size.odd? ? ary[i] *=2 : ary[i-1] *=2 }
#=> [4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4]

Notez que la première partie (1 ... ary.size) .step (2) .to_a renvoie les index impairs:

ary = [4, 2, 4, 2, 4, 2, 4, 2, 4, 2, 4, 2, 4, 2, 4, 2]

Notez également les trois pointe ... dans la plage.

Pour ary = [2, 4, 2] # => [2, 8, 2] p>

Pour ary = [2, 4, 2, 4] # => [4, 4, 4, 4]

Une autre approche, qui utilise Numeric # step . Cela fonctionne bien avec tous les exemples même avec une autre étape (array3)

array1 = [4, 2, 4, 2, 4, 2, 4, 2, 4, 2, 4, 2, 4, 2, 4, 2]
array2 = [2, 4, 2, 4, 2, 4, 2, 4, 2, 4, 2, 4, 2, 4, 2, 4, 2]
array3 = [2, 4, 4, 2, 4, 4, 2, 4, 4, 2, 4, 4, 2, 4, 4, 2]

(array1.size - 1).step(0, -2).each { |i| array1[i] *= 2 }
(array2.size - 1).step(0, -2).each { |i| array2[i] *= 2 }
(array3.size - 1).step(0, -3).each { |i| array3[i] *= 2 }

p array1, array2, array3
#=>[4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4]
#=>[4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4]
#=>[4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4]