Comment puis-je aléatoire d'un tableau/hachage en Ruby?

À des fins d'apprentissage, qu'est-ce que cela s'appelle? Est l'objet en cours de création d'un tableau ou d'une table de hachage?

stack_of_cards = []

C'est la façon dont je suis le remplir:

stack_of_cards << Card.new("A", "Spades", 1)
stack_of_cards << Card.new("2", "Spades", 2)
stack_of_cards << Card.new("3", "Spades", 3)
...

Voici ma Carte de classe:

class Card

  attr_accessor :number, :suit, :value

  def initialize(number, suit, value)
    @number = number
    @suit = suit
    @value = value
  end

  def to_s
    "#{@number} of #{@suit}"
  end
end

J'aimerais mélangez les éléments de ce tableau/table de hachage (qu'est-ce que cela s'appelle? :S)

Des suggestions?

Je peux imaginer que vous sauté Struct, mais quand vous avez le temps, regardez dedans.

OriginalL'auteur | 2011-02-20

ruby shuffle

18
```
stack_of_cards.shuffle
```
C'est un Tableau, voir http://www.ruby-doc.org/core-1.8.7/classes/Array.html pour plus d'informations.

J'ai écrit le fonctionnelle forme, qui renvoie un nouveau Tableau, et c'est la nouvelle qui est mélangé. Vous pouvez à la place utiliser:
```
stack_of_cards.shuffle!
```
...mélanger le tableau en place.

Et OP du droit, il est appelé "tableau".
Word? Il est en fait un shuffle méthode sur le Tableau de la classe? Jésus!
Cela ne veut pas modifier le tableau. FYI. 😛 un mépris, vous avez édité votre réponse...
Regarder le Changelog, #shuffle semble avoir été ajouté sur le dernier jour du mois d'août en 2006, qui pourraient résulter en apparaissant d'abord, je pense que, dans 1.8.6. C'est certainement trop tard pour certaines éditions de divers Ruby livres.
"C'est certainement trop tard pour certaines éditions de divers Ruby livres". Le plus certainement. Ruby est l'un des plus rapides de cibles pour un éditeur, il me semble. Je n'ai même pas envie de parler trouver les bons Rails livres parce qu'ils sont hors de la date à laquelle ils sont publiés. 🙂

OriginalL'auteur DigitalRoss
10

Si vous voulez shuffle d'une valeur de hachage, vous pouvez utiliser quelque chose comme ceci:
```
class Hash
  def shuffle
    Hash[self.to_a.sample(self.length)]
  end

  def shuffle!
    self.replace(self.shuffle)
  end
end
```
J'ai posté cette réponse car j'ai toujours trouver cette question si je recherche pour "ruby shuffle de hachage".

+1, une bonne idée, mais que diriez-vous: Hash[self.to_a.shuffle]

OriginalL'auteur 2called-chaos
1

En plus de à l'aide de la méthode de lecture aléatoire, vous pouvez utiliser la méthode de tri:
```
array.sort {|a, b| rand <=> rand }
```
Cela peut être utile si vous utilisez une ancienne version de Ruby où shuffle n'est pas mis en œuvre. Comme avec shuffle!, vous pouvez utiliser sort! de travailler sur le tableau existant.

Qui ne fonctionnent pas bien. [1, 2, 3].sort { rand.round } retourne toujours [1, 2, 3] ou [3, 2, 1]. Le droit doit être [1, 2, 3].sort { rand <=> rand }, ou [1, 2, 3].sort_by { rand } (à éviter si shuffle peut être utilisé).
mention de HACHAGE aussi, si vous savez... au cas où

OriginalL'auteur david4dev
1

Si vous voulais devenir fou et d'écrire votre propre endroit aléatoire de la méthode, vous pourriez faire quelque chose comme cela.
```
 def shuffle_me(array)
   (array.size-1).downto(1) do |i|
     j = rand(i+1)
     array[i], array[j] = array[j], array[i]
   end

   array
 end 
```
Pourquoi rand(array.size-1) et pas rand(array.size)? rand n'est pas compris, par exemple rand(5) sera de sortie des nombres de 0 - 4.
Ouais, il y avait effectivement quelques problèmes avec mon précédent de mise en œuvre. J'ai révisé ma méthode ci-dessus pour refléter les Knuth algorithme de Shuffle. en.wikipedia.org/wiki/...

OriginalL'auteur davissp14

Pour les tableaux:

array.shuffle
[1, 3, 2].shuffle
#=> [3, 1, 2]

Pour le hachage:

Hash[*hash.to_a.shuffle.flatten]
Hash[*{a: 1, b: 2, c: 3}.to_a.shuffle.flatten(1)]
#=> {:b=>2, :c=>3, :a=>1}
#=> {:c=>3, :a=>1, :b=>2}
#=> {:a=>1, :b=>2, :c=>3}
# Also works for hashes containing arrays
Hash[*{a: [1, 2], b: [2, 3], c: [3, 4]}.to_a.shuffle.flatten(1)]
#=> {:b=>2, :c=>3, :a=>1}
#=> {:c=>[3, 4], :a=>[1, 2], :b=>[2, 3]}

OriginalL'auteur Dorian

0

Si vous voulez shuffle d'une valeur de hachage, mais qui ne veulent pas surcharger la classe Hash, vous pouvez utiliser la fonction de tri, puis de la convertir à une table de hachage avec la to_h fonction (Ruby 2.1+):
```
a = {"a" => 1, "b" => 2, "c" => 3}
puts a.inspect
a = a.sort {|a, b| rand <=> rand }.to_h
puts a.inspect
```
OriginalL'auteur Evan Appleby

Vous devez vous connecter pour publier un commentaire.