Je vous explique mon probleme, je veux une liste de 32 nombres (avec
des chiffres compris de 1 =E0 60).
Le probleme c'est que dans cette liste je retrouve des nombres
identiques, ce que je ne veux pas.
Mon script bien sur ne fonctionne pas vraiment car je ne teste que le
chiffre precedent si il est identique je relance un nombre pseudo
aleatoire
Cette action est irreversible, confirmez la suppression du commentaire ?
Signaler le commentaire
Veuillez sélectionner un problème
Nudité
Violence
Harcèlement
Fraude
Vente illégale
Discours haineux
Terrorisme
Autre
Paul Gaborit
À (at) 19 Jul 2005 04:49:25 -0700, "osiris" écrivait (wrote):
Je vous explique mon probleme, je veux une liste de 32 nombres (avec des chiffres compris de 1 à 60).
Vous voulez choisir au hasard 32 éléments parmi 60. Une méthode simple à mettre en oeuvre est la suivante : mélanger un tableau contenant les 60 éléments puis ne prendre que les 32 premiers.
En utilisant le module List::Util : ---------------------------------------- use List::Util qw/shuffle/;
my @nombres = (shuffle 1..60)[0..31]; ----------------------------------------
Si vous ne voulez pas utiliser List::Util, une subroutine shuffle (fisher_yates_shuffle) est disponible dans la FAQ :
perldoc -q shuffle
Ce qui donne alors : ---------------------------------------- # fisher_yates_shuffle( @array ) : # generate a random permutation of @array in place sub fisher_yates_shuffle { my $array = shift; my $i; for ($i = @$array; --$i; ) { my $j = int rand ($i+1); @$array[$i,$j] = @$array[$j,$i]; } }
my @elements = 1..60; fisher_yates_shuffle(@elements); my @nombres = @elements[0..31]; ----------------------------------------
-- Paul Gaborit - <http://perso.enstimac.fr/~gaborit/> Perl en français - <http://perl.enstimac.fr/>
Je vous explique mon probleme, je veux une liste de 32 nombres (avec
des chiffres compris de 1 à 60).
Vous voulez choisir au hasard 32 éléments parmi 60. Une méthode simple
à mettre en oeuvre est la suivante : mélanger un tableau contenant les
60 éléments puis ne prendre que les 32 premiers.
En utilisant le module List::Util :
----------------------------------------
use List::Util qw/shuffle/;
my @nombres = (shuffle 1..60)[0..31];
----------------------------------------
Si vous ne voulez pas utiliser List::Util, une subroutine shuffle
(fisher_yates_shuffle) est disponible dans la FAQ :
perldoc -q shuffle
Ce qui donne alors :
----------------------------------------
# fisher_yates_shuffle( @array ) :
# generate a random permutation of @array in place
sub fisher_yates_shuffle {
my $array = shift;
my $i;
for ($i = @$array; --$i; ) {
my $j = int rand ($i+1);
@$array[$i,$j] = @$array[$j,$i];
}
}
my @elements = 1..60;
fisher_yates_shuffle(@elements);
my @nombres = @elements[0..31];
----------------------------------------
--
Paul Gaborit - <http://perso.enstimac.fr/~gaborit/>
Perl en français - <http://perl.enstimac.fr/>
À (at) 19 Jul 2005 04:49:25 -0700, "osiris" écrivait (wrote):
Je vous explique mon probleme, je veux une liste de 32 nombres (avec des chiffres compris de 1 à 60).
Vous voulez choisir au hasard 32 éléments parmi 60. Une méthode simple à mettre en oeuvre est la suivante : mélanger un tableau contenant les 60 éléments puis ne prendre que les 32 premiers.
En utilisant le module List::Util : ---------------------------------------- use List::Util qw/shuffle/;
my @nombres = (shuffle 1..60)[0..31]; ----------------------------------------
Si vous ne voulez pas utiliser List::Util, une subroutine shuffle (fisher_yates_shuffle) est disponible dans la FAQ :
perldoc -q shuffle
Ce qui donne alors : ---------------------------------------- # fisher_yates_shuffle( @array ) : # generate a random permutation of @array in place sub fisher_yates_shuffle { my $array = shift; my $i; for ($i = @$array; --$i; ) { my $j = int rand ($i+1); @$array[$i,$j] = @$array[$j,$i]; } }
my @elements = 1..60; fisher_yates_shuffle(@elements); my @nombres = @elements[0..31]; ----------------------------------------
-- Paul Gaborit - <http://perso.enstimac.fr/~gaborit/> Perl en français - <http://perl.enstimac.fr/>
Stephane Zuckerman
Bonjour,
Je vous explique mon probleme, je veux une liste de 32 nombres (avec des chiffres compris de 1 à 60).
Le probleme c'est que dans cette liste je retrouve des nombres identiques, ce que je ne veux pas.
-- "Je deteste les ordinateurs : ils font toujours ce que je dis, jamais ce que je veux !" "The obvious mathematical breakthrough would be development of an easy way to factor large prime numbers." (Bill Gates, The Road Ahead)
Bonjour,
Je vous explique mon probleme, je veux une liste de 32 nombres (avec
des chiffres compris de 1 à 60).
Le probleme c'est que dans cette liste je retrouve des nombres
identiques, ce que je ne veux pas.
--
"Je deteste les ordinateurs : ils font toujours ce que je dis, jamais ce
que je veux !"
"The obvious mathematical breakthrough would be development of an easy
way to factor large prime numbers." (Bill Gates, The Road Ahead)
-- "Je deteste les ordinateurs : ils font toujours ce que je dis, jamais ce que je veux !" "The obvious mathematical breakthrough would be development of an easy way to factor large prime numbers." (Bill Gates, The Road Ahead)
osiris
À (at) 19 Jul 2005 04:49:25 -0700, "osiris" écrivait (wrote):
Je vous explique mon probleme, je veux une liste de 32 nombres (avec des chiffres compris de 1 à 60).
Vous voulez choisir au hasard 32 éléments parmi 60. Une méthode sim ple à mettre en oeuvre est la suivante : mélanger un tableau contenant les 60 éléments puis ne prendre que les 32 premiers.
En utilisant le module List::Util : ---------------------------------------- use List::Util qw/shuffle/;
my @nombres = (shuffle 1..60)[0..31]; ----------------------------------------
Si vous ne voulez pas utiliser List::Util, une subroutine shuffle (fisher_yates_shuffle) est disponible dans la FAQ :
perldoc -q shuffle
Ce qui donne alors : ---------------------------------------- # fisher_yates_shuffle( @array ) : # generate a random permutation of @array in place sub fisher_yates_shuffle { my $array = shift; my $i; for ($i = @$array; --$i; ) { my $j = int rand ($i+1); @$array[$i,$j] = @$array[$j,$i]; } }
my @elements = 1..60; fisher_yates_shuffle(@elements); my @nombres = @elements[0..31]; ----------------------------------------
-- Paul Gaborit - <http://perso.enstimac.fr/~gaborit/> Perl en français - <http://perl.enstimac.fr/>
Je vous explique mon probleme, je veux une liste de 32 nombres (avec
des chiffres compris de 1 à 60).
Vous voulez choisir au hasard 32 éléments parmi 60. Une méthode sim ple
à mettre en oeuvre est la suivante : mélanger un tableau contenant les
60 éléments puis ne prendre que les 32 premiers.
En utilisant le module List::Util :
----------------------------------------
use List::Util qw/shuffle/;
my @nombres = (shuffle 1..60)[0..31];
----------------------------------------
Si vous ne voulez pas utiliser List::Util, une subroutine shuffle
(fisher_yates_shuffle) est disponible dans la FAQ :
perldoc -q shuffle
Ce qui donne alors :
----------------------------------------
# fisher_yates_shuffle( @array ) :
# generate a random permutation of @array in place
sub fisher_yates_shuffle {
my $array = shift;
my $i;
for ($i = @$array; --$i; ) {
my $j = int rand ($i+1);
@$array[$i,$j] = @$array[$j,$i];
}
}
my @elements = 1..60;
fisher_yates_shuffle(@elements);
my @nombres = @elements[0..31];
----------------------------------------
--
Paul Gaborit - <http://perso.enstimac.fr/~gaborit/>
Perl en français - <http://perl.enstimac.fr/>
À (at) 19 Jul 2005 04:49:25 -0700, "osiris" écrivait (wrote):
Je vous explique mon probleme, je veux une liste de 32 nombres (avec des chiffres compris de 1 à 60).
Vous voulez choisir au hasard 32 éléments parmi 60. Une méthode sim ple à mettre en oeuvre est la suivante : mélanger un tableau contenant les 60 éléments puis ne prendre que les 32 premiers.
En utilisant le module List::Util : ---------------------------------------- use List::Util qw/shuffle/;
my @nombres = (shuffle 1..60)[0..31]; ----------------------------------------
Si vous ne voulez pas utiliser List::Util, une subroutine shuffle (fisher_yates_shuffle) est disponible dans la FAQ :
perldoc -q shuffle
Ce qui donne alors : ---------------------------------------- # fisher_yates_shuffle( @array ) : # generate a random permutation of @array in place sub fisher_yates_shuffle { my $array = shift; my $i; for ($i = @$array; --$i; ) { my $j = int rand ($i+1); @$array[$i,$j] = @$array[$j,$i]; } }
my @elements = 1..60; fisher_yates_shuffle(@elements); my @nombres = @elements[0..31]; ----------------------------------------
-- Paul Gaborit - <http://perso.enstimac.fr/~gaborit/> Perl en français - <http://perl.enstimac.fr/>
Merci encore, super ça fonctionne !!!!
damien guerin
Je trouve cette méthode bof, car il y aura toujours des itérations de trop...
Je trouve cette méthode bof, car il y aura toujours des itérations de
trop...
Du coup le tableau contiendra toujours l'ensemble des valeurs possible moins celles déjà sorties...
Stephane Zuckerman
Je trouve cette méthode bof, car il y aura toujours des itérations de trop...
Mmmh. J'essayais de garder l'esprit de sa solution en fait. Au final, la "vraie" itération de trop, c'est l'obligation d'avoir à recopier toutes les clés du hash dans un tableau en fin de script. Sinon, les itérations en trop étaient inhérentes à la solution choisie par le PO :-)
-- "Je deteste les ordinateurs : ils font toujours ce que je dis, jamais ce que je veux !" "The obvious mathematical breakthrough would be development of an easy way to factor large prime numbers." (Bill Gates, The Road Ahead)
Je trouve cette méthode bof, car il y aura toujours des itérations de
trop...
Mmmh. J'essayais de garder l'esprit de sa solution en fait. Au final, la
"vraie" itération de trop, c'est l'obligation d'avoir à recopier toutes
les clés du hash dans un tableau en fin de script. Sinon, les itérations
en trop étaient inhérentes à la solution choisie par le PO :-)
--
"Je deteste les ordinateurs : ils font toujours ce que je dis, jamais ce
que je veux !"
"The obvious mathematical breakthrough would be development of an easy
way to factor large prime numbers." (Bill Gates, The Road Ahead)
Je trouve cette méthode bof, car il y aura toujours des itérations de trop...
Mmmh. J'essayais de garder l'esprit de sa solution en fait. Au final, la "vraie" itération de trop, c'est l'obligation d'avoir à recopier toutes les clés du hash dans un tableau en fin de script. Sinon, les itérations en trop étaient inhérentes à la solution choisie par le PO :-)
-- "Je deteste les ordinateurs : ils font toujours ce que je dis, jamais ce que je veux !" "The obvious mathematical breakthrough would be development of an easy way to factor large prime numbers." (Bill Gates, The Road Ahead)
