s'il vous plaît aider avec mon code "shuffle" en rubis

Question

c'est la question

Shuffle. Maintenant que vous avez terminé votre nouvel algorithme de tri , qu'en est-il du ci-contre? Écrivez une méthode de mélange aléatoire qui prend un tableau et renvoie une version complètement shuffled. Comme toujours, vous voulez tester, mais tester celui-ci est plus délicate: Comment pouvez-vous tester pour faire que vous obtenez un remaniement parfait? Que diriez-vous même un shuffle parfait serait? Maintenant, tester pour il.

Ceci est ma réponse de code:

def shuffle arr 
    x = arr.length 
while x != 0 
     new_arr = [] 
    rand_arr = (rand(x)) 
    x-- 
    new_arr.push rand_arr 
    arr.pop rand_arr 
end 

new_arr 

end 

puts (shuffle ([1,2,3])) 

Quelles sont mes erreurs? Pourquoi ce code ne fonctionne-t-il pas?

Answer 1

A côté des erreurs mineures autres vous semble ne pas comprendre ce que pop et pousser font (prendre ou en ajoutant quelques éléments de la fin du tableau).

Vous essayez probablement d'écrire quelque chose comme ci-dessous.

def shuffle arr 
    x = arr.length 
    new_arr = [] 
    while x != 0 
     randpos = rand(x) 
     x = x-1 
     item = arr[randpos] 
     new_arr.push item 
     arr[randpos] = arr[x] 
     arr.pop 
    end 

    new_arr 

end 

puts (shuffle ([1,2,3])) 

Answer 2

vous obtenez vos index mélangés avec vos valeurs. Quand vous faites new_arr.push rand_arr, vous mettez n'importe quel index aléatoire que vous avez trouvé comme valeur à la fin de new_arr. Qu'est-ce que vous vouliez dire à faire est new_arr.push arr[rand_arr], où arr[rand_arr] est la valeur à l'indice rand_arr dans arr.

Answer 3

est ici une version beaucoup plus Rubyish:

class Array 
    def shuffle! 
    size.downto(1) { |n| push delete_at(rand(n)) } 
    self 
    end 
end 

puts [1,2,3].shuffle! 

Answer 4

Voici une façon plus concise de l'écrire:

def shuffle(arr) 
    new_arr = [] 

    while (arr.any?) do 
    new_arr << arr.delete_at(rand(arr.length)) 
    end 

    new_arr 
end 

Et quelques tests:

5.times do 
    puts shuffle((1..5).to_a).join(',') 
end 

>> 4,2,1,3,5 
>> 3,2,1,4,5 
>> 4,2,5,1,3 
>> 5,2,1,4,3 
>> 4,3,1,5,2 

Answer 5

Ruby 1.8 .7 et 1.9.2 ont une méthode intégrée Array # shuffle.

Answer 6

Une variante de la réponse de Mark Thomas. Son algorithme peut être assez lent avec un grand tableau, en raison de la suppression des performances de l'opération.

class Array 
    def shuffle! 
    size.downto(1) do |n| 
     index=rand(n) 
     # swap elements at index and the end 
     self[index], self[size-1] = self[size-1],self[index] 
    end 
    self 
    end 
end 

puts [1,2,3].shuffle! 

Cet algorithme est O (taille), tandis que l'algorithme de Mark est O (taille^2). Sur mon ordinateur, la réponse de Mark prend 400 secondes pour mélanger un tableau de 1 000 000 d'éléments sur ma machine, contre 0,5 seconde avec ma méthode.