Comment puis-je supprimer un élément d'un tableau par valeur

J'ai un tableau d'éléments en Ruby

[2,4,6,3,8]

J'ai besoin de supprimer des éléments avec de la valeur 3par exemple

Comment je fais ça?

Je pense que je l'ai compris:

a = [3, 2, 4, 6, 3, 8]
a.delete(3)
#=> 3
a
#=> [2, 4, 6, 8]

Empruntant à Travis dans les commentaires, c'est une meilleure réponse:

J'aime personnellement [1, 2, 7, 4, 5] - [7]ce qui résulte => [1, 2, 4, 5]deirb

J'ai modifié sa réponse en voyant que 3 était le troisième élément de son exemple de tableau. Cela pourrait entraîner une certaine confusion pour ceux qui ne réalisent pas que 3 est en position 2 dans le tableau.

Une autre option:

a = [2,4,6,3,8]

a -= [3]

ce qui se traduit par

=> [2, 4, 6, 8] 

Je ne sais pas si quelqu'un l'a déclaré, mais Array.delete () et - = valeur supprimera chaque instance de la valeur qui lui est transmise dans le tableau. Afin de supprimer la première instance de l'élément particulier, vous pouvez faire quelque chose comme

arr = [1,3,2,44,5]
arr.delete_at(arr.index(44))

#=> [1,3,2,5]

Il pourrait y avoir un moyen plus simple. Je ne dis pas que c'est la meilleure pratique, mais c'est quelque chose qui devrait être reconnu.

En supposant que vous vouliez supprimer 3 par valeur à plusieurs endroits dans un tableau, je pense que la façon la plus simple de faire cette tâche serait d'utiliser la méthode delete_if:

[2,4,6,3,8,3].delete_if {|x| x == 3 } 

Vous pouvez également utiliser delete_if pour supprimer des éléments dans le scénario de «tableau de tableaux».

J'espère que cela résout votre question

J'aime la -=[4]manière mentionnée dans les autres réponses pour supprimer les éléments dont la valeur est 4.

Mais il y a cette façon:

irb(main):419:0> [2,4,6,3,8,6].delete_if{|i|i==6}
=> [2, 4, 3, 8]
irb(main):420:0>

mentionné quelque part dans " Basic Array Operations ", après avoir mentionné la mapfonction.

Vous pouvez simplement exécuter:

[2,4,6,3,8].delete(3)

Un .delete_at(3) 3ici étant la position.

Voici quelques repères:

require 'fruity'


class Array          
  def rodrigo_except(*values)
    self - values
  end    

  def niels_except value
    value = value.kind_of?(Array) ? value : [value]
    self - value
  end
end

ARY = [2,4,6,3,8]

compare do
  soziev  { a = ARY.dup; a.delete(3);               a }
  steve   { a = ARY.dup; a -= [3];                  a }
  barlop  { a = ARY.dup; a.delete_if{ |i| i == 3 }; a }
  rodrigo { a = ARY.dup; a.rodrigo_except(3);         }
  niels   { a = ARY.dup; a.niels_except(3);           }
end

# >> Running each test 4096 times. Test will take about 2 seconds.
# >> soziev is similar to barlop
# >> barlop is faster than steve by 2x ± 1.0
# >> steve is faster than rodrigo by 4x ± 1.0
# >> rodrigo is similar to niels

Et encore une fois avec un tableau plus grand contenant beaucoup de doublons:

class Array          
  def rodrigo_except(*values)
    self - values
  end    

  def niels_except value
    value = value.kind_of?(Array) ? value : [value]
    self - value
  end
end

ARY = [2,4,6,3,8] * 1000

compare do
  soziev  { a = ARY.dup; a.delete(3);               a }
  steve   { a = ARY.dup; a -= [3];                  a }
  barlop  { a = ARY.dup; a.delete_if{ |i| i == 3 }; a }
  rodrigo { a = ARY.dup; a.rodrigo_except(3);         }
  niels   { a = ARY.dup; a.niels_except(3);           }
end

# >> Running each test 16 times. Test will take about 1 second.
# >> steve is faster than soziev by 30.000000000000004% ± 10.0%
# >> soziev is faster than barlop by 50.0% ± 10.0%
# >> barlop is faster than rodrigo by 3x ± 0.1
# >> rodrigo is similar to niels

Et encore plus avec plus de doublons:

class Array          
  def rodrigo_except(*values)
    self - values
  end    

  def niels_except value
    value = value.kind_of?(Array) ? value : [value]
    self - value
  end
end

ARY = [2,4,6,3,8] * 100_000

compare do
  soziev  { a = ARY.dup; a.delete(3);               a }
  steve   { a = ARY.dup; a -= [3];                  a }
  barlop  { a = ARY.dup; a.delete_if{ |i| i == 3 }; a }
  rodrigo { a = ARY.dup; a.rodrigo_except(3);         }
  niels   { a = ARY.dup; a.niels_except(3);           }
end

# >> Running each test once. Test will take about 6 seconds.
# >> steve is similar to soziev
# >> soziev is faster than barlop by 2x ± 0.1
# >> barlop is faster than niels by 3x ± 1.0
# >> niels is similar to rodrigo

J'ai amélioré la solution de Niels

class Array          
  def except(*values)
    self - values
  end    
end

Vous pouvez maintenant utiliser

[1, 2, 3, 4].except(3, 4) # return [1, 2]
[1, 2, 3, 4].except(4)    # return [1, 2, 3]

Vous pouvez également le patcher. Je n'ai jamais compris pourquoi Ruby a une exceptméthode pour Hashmais pas pour Array:

class Array
  def except value
    value = value.kind_of(Array) ? value : [value]
    self - value
  end
end

Vous pouvez maintenant:

[1,3,7,"436",354,nil].except(354) #=> [1,3,7,"436",nil]

Ou:

[1,3,7,"436",354,nil].except([354, 1]) #=> [3,7,"436",nil]

Ainsi, lorsque vous avez plusieurs occurrences de 3 et que vous souhaitez uniquement supprimer la première occurrence de 3, vous pouvez simplement faire quelque chose comme ci-dessous.

arr = [2, 4, 6, 3, 8, 10, 3, 12]

arr.delete_at arr.index 3

#This will modify arr as [2, 4, 6, 8, 10, 3, 12] where first occurrence of 3 is deleted. Returns the element deleted. In this case => 3.

Suppression non destructive de la première occurrence:

a = [2, 4, 6, 3, 8]
n = a.index 3
a.take(n)+a.drop(n+1)

Si vous souhaitez également rendre cette opération de suppression chaînable, afin de pouvoir supprimer certains éléments et continuer de chaîner les opérations sur le tableau résultant, utilisez tap:

[2, 4, 6, 3, 8].tap { |ary| ary.delete(3) }.count #=> 4

Compilation de toutes les différentes options de suppression dans ruby

delete - Supprime les éléments correspondants par valeur. Si plusieurs valeurs correspondent, toutes les valeurs seront supprimées. Si vous ne vous souciez pas du nombre d'occurrences ou n'êtes pas sûr d'une occurrence unique, utilisez cette méthode.

a = [2, 6, 3, 5, 3, 7]
a.delete(3)  # returns 3
puts a       # return [2, 6, 5, 7]

delete_at - Supprime l'élément à l'index donné. Si vous connaissez l'index, utilisez cette méthode.

# continuing from the above example
a.delete_at(2) # returns 5
puts a         # returns [2, 6, 7]

delete_if - Supprime chaque élément pour lequel le bloc est vrai. Cela modifiera le tableau. Le tableau change instantanément lors de l'appel du bloc.

b = [1, 2, 5, 4, 9, 10, 11]
b.delete_if {|n| n >= 10}.  # returns [1, 2, 5, 4, 9]

rejeter - Cela retournera un nouveau tableau avec les éléments pour lesquels le bloc donné est faux. La commande est maintenue avec cela.

c = [1, 2, 5, 4, 9, 10, 11]
c.reject {|n| n >= 10}.  # returns [1, 2, 5, 4, 9]

rejeter! - identique à delete_if . Le tableau peut ne pas changer instantanément lors de l'appel du bloc.

Si vous souhaitez supprimer plusieurs valeurs du tableau, la meilleure option est celle ci-dessous.

a = [2, 3, 7, 4, 6, 21, 13]
b = [7, 21]
a = a - b    # a - [2, 3, 4, 6, 13]