problème de redondance en aléatoire

Version imprimable

bonjours
j'essaye de crée un tableau de nombre tirer aléatoirement entre deux valeur et cela sans redondance
car j'ai un tableau de 25 valeur, et je voudrais tirer aléatoirement les 5 premières valeurs , puis les valeur entre [5;10[ ect... jusqu'au 5 dernières valeurs
pour cela j'ai ce code qui crée des tableau de valeur aléatoire entre deux variable et cela sans redondance. Mon soucis est que je ne sais pas comment l'adapter pour qu'il puisse me servir a retourner le tableau de valeur aléatoire pour m en servir dans une phrase du genre

Code:

1
2
3
4
5
6
7
 
 
int tab[12]= { 1,2,3,4,5,6,7,8,9,10,11,22};
int test[5];
 
    test= TablAlea(0,4);
    cout<<tab[test]<<endl;

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
#include <iostream>
#include <ctime>
#include <cstdlib>
using namespace std;
 
int randomNoDouble(int min, int max, long *tableau, long sizeTableau, int i);
int random(const int MIN, const int MAX);
 
int TablAlea(int i; int j)
{
        srand(time(NULL));
        long size = 5;
        long *tab = NULL;
        int min = i, max = j;
 
        tab = new long[size];
        for (int i=0;i<5;i++) {
                tab[i] = -1;
// j'initialise les valeurs de ton tableau à des valeurs qu'il ne devrait pas contenir
        }
 
        for(int i = 0 ; i < 5 ; i++)
        {
                cout<<randomNoDouble(min,max,tab,size,i)<<endl;
        }
 
        delete[] tab;
 
        return 0;
}
 
int randomNoDouble(int min, int max, long *tableau, long sizeTableau, int i)
{
        bool ok;
 
        do // plus pratique parce qu'on test au moins une fois
        {
                tableau[i] = random(min,max);
                ok = false;
                if(i>0)
                {
// condition de sortie : tant qu'il es tdifférent de -1 parce que ça sert à rien de tester plus loin
                        for(int j=0; j<sizeTableau && tableau[j] != -1;j++)
                        {
// Si tu dis pas que j est différent de i alors tu tourneras en rond pendant des heures
// Il testera la même valeur en permanence.
                                if(i != j && tableau[i] == tableau[j])
                                {
// on continue la boucle si on trouve 2 valeurs identiques.
                                        ok = true;                                }
                        }
                }
        }while(ok);
 
        return tableau[i];
}
 
int random(const int MIN, const int MAX)
{
        int random;
        return random = (rand() % (MAX - MIN + 1)) + MIN;
}

26/11/2017, 00h07
koala01
Salut,

Commence déjà par virer ces affeux tableaux de taille fixe C style et cette directive using namespace std;que je ne saurais voir...

Cette directive a été créée, au tous débuts de la normalisation du langage, lorsque la notion d'espace de noms est apparue, pour permettre à la base de code existante de continuer à compiler en ne nécessitant qu'"un minimum de modifications". C'était très bien pour du code écrit avant 1998. Mais cela fait presque vingt ans, maintenant, que les espaces de noms existent et que la bibliothèque standard se trouve dans std.

On ne peut pas dire que le code que tu as écrit hier ou avant-hier (et, quand bien même l'aurais-tu laissé de coté pendant un mois ou un an) entre dans la catégorie de code pour lequel cette directive a été créée ;)

Pour ce qui est des tableaux, deux solutions s'offrent à toi :
1. std::vector, qui existe depuis toujours, et qui permet de représenter des tableaux dont la taille est connue à l'exécution et
2. std::array, qui est arrivé en C++11 (cela fait quand même six ans qui permet de représenter des tableaux dont la taille est connue à la compilation
Ensuite, tu me fera le plaisir de virer rand et srand qui sont dans la même veine, et de les remplacer par les fonctionnalités que l'on retrouve dans le fichier d'en-tête <random> qui est (aussi) apparu en C++11.

Tout de suite après, tu vas me virer ces long * et ces sizeTableau (au passage: attention aux type de tes paramètres, int est différent de long) Si tu as besoin de tableaux dont la taille est connue à l'exécution, c'est std::vector que tu dois utiliser.

Enfin, tu me feras énormément plaisir en évitant le franglais: il est toujours préférable de choisir sa langue et de s'y tenir: soit tu choisi tous tes identifiants dans la langue de Shakespeare, soit dans celle de Voltaire, mais tu ne les mélanges pas. Et encore moins dans un seul et même identifiant ;)

Et pour finir, tu envisageras de supprimer les commentaires, car les meilleurs commentaires sont ceux... que l'on écrit pas: la seule chose que le compilateur utilise, c'est le code. Si tu commence à mettre -- sous forme de commentaires -- des informations qui ne seront de toutes manières comprises que par l'humain, tu te retrouve avec deux sources d'informations distinctes, qui risquent, à l'usage, de diverger.

Or, l'humain -- qui est une d'une fainéantise crasse -- lira en priorité ce qui lui demande le moins de concentration, et sera souvent tenté de ne même pas lire le code s'il a une autre source d'information.

Du coup, il lira en priorité les commentaires et "laissera" le code de coté. Si bien que, si les commentaires ne sont pas en adéquation avec le code, on est mal barre!

Si tu as l'impression qu'une ligne de code mérite un commentaire, essaye d'exprimer ton idée d'une autre manière, par exemple, en choisissant un identifiant différent, ou en créant une constante (correctement nommée), qui sera comprise aussi bien par le compilateur que par le lecteur humain. Tu verras, ta vie de développeur en sera totalement changée ;)

Une fois que tout cela sera fait, nous pourrons commencer à réfléchir à ton problème ;)
27/11/2017, 16h05
bacelar
Une fois le ménage fait en suivant les conseils de @koala01, et que c'est encore votre solveur d’énigme d'Einstein
Pour votre quintuplet:
Code:

1 2 3 4 5 6 7 8 std::default_random_engine generator; std::uniform_int_distribution<int> distribution(0,4); for(int i = 0 ; i<5; i++) { info.push_bask(distribution(generator)+(i*5)); }
Mais bon, votre "randomiseur" n'a rien à faire dans votre solveur.
29/11/2017, 07h24
Médinoc

Si l'espace entre MIN et MAX n'est pas trop grand, tu peux utiliser la technique classique de créer un tableau contenant toutes les valeurs possibles dans l'ordre, puis faire un random_shuffle() dessus...
29/11/2017, 09h23
JolyLoic

Citation:

Envoyé par Médinoc

Si l'espace entre MIN et MAX n'est pas trop grand, tu peux utiliser la technique classique de créer un tableau contenant toutes les valeurs possibles dans l'ordre, puis faire un random_shuffle() dessus...

Petit détail : std::random_shuffle est basé sur rand, et est donc à éviter désormais (il est déprécié en C++14, et a même été supprimé en C++17), il vaut mieux utiliser std::shuffle, qui lui utilise un générateur uniforme de <random>
29/11/2017, 11h51
Médinoc

Ah d'accord, j'ai vu shuffle apparaître dans ma recherche Google pour vérifier que random_shuffle existait bel et bien, et je me suis demandé ce que c'était sur le coup...