Comment puis-je générer une liste de n nombres aléatoires en Ruby?

C'est ce que j'ai à ce jour: 

myArray.map!{ rand(max) }

De toute évidence, cependant, parfois, les numéros de la liste ne sont pas uniques. Comment puis-je m'assurer que ma liste ne contient que des numéros uniques sans avoir à créer un plus grand liste à partir de laquelle j'ai ensuite il suffit de choisir les n nombres uniques?

Edit:

J'aimerais vraiment voir ce fait w/o loop - si possible.

  • Pour info, ma réponse montre un modèle qui fonctionne sans boucle
InformationsquelleAutor Esteban Araya | 2008-09-23
  1. 23

    Ce utilise Set:

    require 'set'

def rand_n(n, max)
    randoms = Set.new
    loop do
        randoms << rand(max)
        return randoms.to_a if randoms.size >= n
    end
end
    • De toute façon, pour ce faire, w/o en boucle? De toute façon de le faire avec une carte?
    • En supposant que le Rubis de l'Ensemble ne permet pas l'insertion de doublons, randoms sera moins aléatoire que rand(max) depuis que vous êtes tout simplement de jeter les numéros "vous n'aimez pas".
    • ce n'est pas correct. L'algorithme n'est pas de jeter des nombres "vous n'aimez pas". Un exemple de cela serait de jeter un certain nombre, car elle est supérieure ou inférieure à une certaine valeur. Ce qu'il est en train de faire est de sauter un numéro si elle a déjà été inclus dans le set, ce qui est une exigence du cas d'utilisation. Cela ne rend pas l'ensemble des nombres moins aléatoire. Elle s'arrête quand elle a assez de chiffres.
    • vous avez raison que je n'était pas correcte. Pas sûr de ce que j'ai fumé, en 2014.
    InformationsquelleAutor Ryan Leavengood
  2. 64
    (0..50).to_a.sort{ rand() - 0.5 }[0..x]

    (0..50).to_a peut être remplacé par n'importe quel tableau.
    0 est "minvalue", 50 "valeur max"
    x est "combien de valeurs de i want out"

    bien sûr, il est impossible de x pour être autorisés à être plus que max-min 🙂

    Dans l'expansion de la façon dont cela fonctionne 

    (0..5).to_a  ==> [0,1,2,3,4,5]
[0,1,2,3,4,5].sort{ -1 }  ==>  [0, 1, 2, 4, 3, 5]  # constant
[0,1,2,3,4,5].sort{  1 }  ==>  [5, 3, 0, 4, 2, 1]  # constant
[0,1,2,3,4,5].sort{ rand() - 0.5 }   ==>  [1, 5, 0, 3, 4, 2 ]  # random
[1, 5, 0, 3, 4, 2 ][ 0..2 ]   ==>  [1, 5, 0 ]

    Notes de bas de page:

    Il est intéressant de mentionner qu'à l'époque, cette question a été à l'origine de réponse, septembre 2008, que Array#shuffle sont pas disponibles ou ne sont pas déjà connues de moi, d'où le rapprochement en Array#tri

    Et il y a un barrage de suggestions de modifications à ce résultat.

    Donc:

    .sort{ rand() - 0.5 }

    Peut être mieux, et de plus courte durée exprimée sur moderne ruby implémentations utilisant

    .shuffle

    En outre,

    [0..x]

    Peut être plus évidemment écrite avec Array#prendre comme:

    .take(x)

    Ainsi, la façon la plus simple pour produire une séquence de nombres aléatoires sur un moderne ruby est:

    (0..50).to_a.shuffle.take(x)
    • brillant. bonne explication trop!
    • n'est pas [0,1,2,3,4,5].shuffle plus facile ?
    • hehehe 🙂 j'avais à dire @Federico. Génial :))
    • Regarder la date @Federico , ruby ne pas disposer d'une telle méthode au début de 2008 avec 1.8.6 ruby-doc.org/core-1.8.6/Array.html , a été ajoutée en 1.8.7 aussi loin que je peux dire. svn.ruby-lang.org/repos/ruby/tags/v1_8_7/ChangeLog
    • ( 1.8.7 était probablement à l'époque, mais je n'avait probablement pas mis à jour encore, ou a appris de l'ajout de .shuffle )
    • (0..50).to_a.shuffle.prendre(x) génial !!
    • Si vous avez une dynamique de limite supérieure, cette méthode est susceptible de générer de très grands tableaux. Je pense qu'il serait préférable d'utiliser n.times.map { rand(lower_limit..upper_limit) }
    • et cette approche de cours donne aucune garantie de l'unicité.

    InformationsquelleAutor Kent Fredric
  3. 22

    Juste pour vous donner une idée sur la vitesse, j'ai couru quatre versions de ce:

    1. À l'aide des Ensembles, à l'instar de Ryan suggestion.
    2. L'aide d'un Tableau légèrement plus grande que nécessaire, puis de le faire uniq! à la fin.
    3. À l'aide d'une table de Hachage, comme Kyle suggéré.
    4. Création d'un Tableau de la taille requise, puis à les trier de façon aléatoire, comme une suggestion de Kent (mais sans le superflu "- 0.5", qui ne fait rien).

    Ils sont tous rapidement à de très petites échelles, donc je leur ai demandé de créer une liste de 1 000 000 de numéros. Voici les temps, en secondes:

    1. Ensembles: 628
    2. Tableau + uniq: 629
    3. Hash: 645
    4. Tableau fixe + tri: 8

    Et non, ce dernier n'est pas une faute de frappe. Donc, si vous vous souciez de la vitesse, et c'est OK pour les nombres entiers de 0 à quoi que ce soit alors mon code exact était:

    a = (0...1000000).sort_by{rand}
    • Un linear feedback shift register devrait être terminée en moins d'une seconde.
    • ` étrangers "- 0.5", qui ne fait rien " Avez-vous l'essayer? Sans - 0.5 , rand() renvoie toujours > 0, et quand > 0, un est toujours plus petit que b, et puis, au lieu de brassage, ... vous obtenez tout simplement retourné la liste dans l'ordre de l'algorithme sous-jacent par rapport à eux. Qui, dans certains cas, retourne la liste dans l'ordre donné. (0..10).to­_a.sort{ Rando­m.rand() } sur tryruby.org/levels/1/challenges/0 me donne d'entrée == sortie. Afin de vous VRAIMENT besoin que de 0,5, ou le aléatoire lui-même ne fait rien
    • Vrai, si vous utilisez sort. J'ai effectivement utilisé sort_by, comme je l'ai montré...
    • Aussi, vous êtes vraiment de répondre à de petits apartés dans un fil de six ans après les faits?!
    InformationsquelleAutor glenn mcdonald
  4. 22

    Ruby 1.9 offre le Tableau#exemple de méthode qui renvoie un élément, ou des éléments sélectionnés au hasard à partir d'un Tableau. Les résultats de #exemple de ne pas inclure le même élément de Tableau à deux reprises.

    (1..999).to_a.sample 5 # => [389, 30, 326, 946, 746]

    Comparativement à la to_a.sort_by approche, la sample méthode semble être nettement plus rapide. Dans un scénario simple, j'ai comparé les sort_by à sample, et a obtenu les résultats suivants.

    require 'benchmark'
range = 0...1000000
how_many = 5

Benchmark.realtime do
  range.to_a.sample(how_many)
end
=> 0.081083

Benchmark.realtime do
  (range).sort_by{rand}[0...how_many]
end
=> 2.907445
    • Aucune idée de la chronologie par rapport à ce que glenn mcdonald rapports?
    InformationsquelleAutor Duncan Beevers
  5. 4

    Oui, il est possible de le faire sans boucle et sans garder trace des numéros ont été choisis. Il a appelé à une Linear Feedback Shift Register: Créer de la Séquence des nombres Aléatoires Sans répétition

    InformationsquelleAutor Bryan Larsen
  6. 2

    Comment agit d'un jeu sur cette? Nombres aléatoires sans avoir à utiliser Ensemble ou de Hachage. 

    x = 0
(1..100).map{|iter| x += rand(100)}.shuffle
    • J'ai un peu l'impression que ces chiffres seront beaucoup moins aléatoire que de les cueillir 100 unique de la gamme de 0 à 10000.
    • yerp, il doit être amélioré, plus le nombre est élevé plus la chance que vous obtiendrez. Mais il y a sûrement un moyen d'obtenir quelque chose le long de ces lignes pour travailler.
    InformationsquelleAutor Sam Saffron
  7. 1

    Vous pouvez utiliser une table de hachage pour suivre les nombres aléatoires que vous avez utilisé jusqu'à présent:

    seen = {}
max = 100
(1..10).map { |n|
  x = rand(max)
  while (seen[x]) 
    x = rand(max)
  end
  x
}
    InformationsquelleAutor Kyle Burton
  8. 1

    Plutôt que d'ajouter des éléments à une liste ou un tableau, les ajouter à un Ensemble.

    InformationsquelleAutor jon
  9. 1

    Si vous avez une liste limitée de possible nombres aléatoires (c'est à dire de 1 à 100), puis de Kent solution est bonne.

    Sinon il n'y a pas d'autre bonne façon de le faire sans boucle. Le problème est que vous DEVEZ faire une boucle si vous en obtenir un duplicata. Ma solution doit être efficace et la boucle ne doit pas être trop beaucoup plus que la taille de votre groupe (si vous voulez 20 nombres aléatoires, il peut prendre de 25 itérations en moyenne.) Si le nombre d'itérations est de pire les numéros plus vous avez besoin et le petit max est. Voici mon code ci-dessus modifiée afin de montrer combien d'itérations sont nécessaires pour l'entrée:

    require 'set'

def rand_n(n, max)
    randoms = Set.new
    i = 0
    loop do
        randoms << rand(max)
        break if randoms.size > n
        i += 1
    end
    puts "Took #{i} iterations for #{n} random numbers to a max of #{max}"
    return randoms.to_a
end

    Je pourrais écrire ce code ressemble plus à de la Matrice.carte, si vous voulez 🙂

    InformationsquelleAutor Ryan Leavengood
  10. 1

    Basé sur Kent Fredric la solution ci-dessus, c'est ce que j'ai fini par utiliser:

    def n_unique_rand(number_to_generate, rand_upper_limit)
  return (0..rand_upper_limit - 1).sort_by{rand}[0..number_to_generate - 1]
end

    Grâce Kent.

    InformationsquelleAutor Doug English
  11. 1

    Pas de boucles avec cette méthode

    Array.new(size) { rand(max) }

require 'benchmark'
max = 1000000
size = 5
Benchmark.realtime do
  Array.new(size) { rand(max) }
end

=> 1.9114e-05
    InformationsquelleAutor Andrei Madalin Butnaru
  12. 0

    Voici une solution:

    Supposons que vous voulez que ces nombres aléatoires entre r_min et r_max. Pour chaque élément dans votre liste, de générer un nombre aléatoire r, et de faire list[i]=list[i-1]+r. Ce serait vous donner des nombres aléatoires qui sont de plus en plus monotone, garantissant l'unicité de la condition que

    • r+list[i-1] n'a pas plus de flux de
    • r > 0

    Pour le premier élément, vous pouvez utiliser r_min au lieu de list[i-1]. Une fois que vous avez terminé, vous pouvez mélanger de la liste les éléments ne sont pas évidemment dans l'ordre.

    Le seul problème avec cette méthode est que lorsque vous allez sur r_max et ont encore plus d'éléments à générer. Dans ce cas, vous pouvez réinitialiser r_min et r_max à 2 adjacentes de l'élément que vous avez déjà calculé, et il suffit de répéter le processus. Effectivement cela fonctionne de la même algorithme sur un intervalle de temps où il n'y a pas les numéros déjà utilisé. Vous pouvez continuer à faire cela jusqu'à ce que vous avez la liste peuplée.

    InformationsquelleAutor freespace
  13. 0

    Aussi loin qu'il est bon de savoir à l'avance le maximum de valeur, vous pouvez le faire de cette façon:

    class NoLoopRand
  def initialize(max)
    @deck = (0..max).to_a
  end

  def getrnd
    return @deck.delete_at(rand(@deck.length - 1))
  end
end

    et vous pouvez obtenir des données aléatoires de cette façon: 

    aRndNum = NoLoopRand.new(10)
puts aRndNum.getrnd

    vous obtiendrez nil lorsque toutes les valeurs seront exausted à partir du pont.

    InformationsquelleAutor TuxmAL
  14. 0

    Méthode 1

    À l'aide de Kent approche, il est possible de générer un tableau de longueur arbitraire en gardant toutes les valeurs dans une gamme limitée:

    # Generates a random array of length n.
#
# @param n     length of the desired array
# @param lower minimum number in the array
# @param upper maximum number in the array
def ary_rand(n, lower, upper)
    values_set = (lower..upper).to_a
    repetition = n/(upper-lower+1) + 1
    (values_set*repetition).sample n
end

    Méthode 2

    Un autre, éventuellement plus efficace, la méthode modifiée de la même Kent une autre réponse:

    def ary_rand2(n, lower, upper)
    v = (lower..upper).to_a
    (0...n).map{ v[rand(v.length)] }
end

    Sortie

    puts (ary_rand 5, 0, 9).to_s # [0, 8, 2, 5, 6] expected
puts (ary_rand 5, 0, 9).to_s # [7, 8, 2, 4, 3] different result for same params
puts (ary_rand 5, 0, 1).to_s # [0, 0, 1, 0, 1] repeated values from limited range
puts (ary_rand 5, 9, 0).to_s # []              no such range :)
    InformationsquelleAutor mmdemirbas