Discussion :

[cyberlp]

Bonjour,

J'ai le problème suivant.

a) J'ai 4 valeurs numériques (de 1 à 13), que je vais appeler "couleurs", saisies par l'utilisateur dans un formulaire :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
$carreau;
$pique;
$coeur;
$trefle;

Il y a toujours 1 couleur + forte d'au moins 1 que toutes les autres, et 1 plus faible d'au moins 1 que toutes les autres.

b) J'ai une autre série de valeurs, que je vais appeler "mots" (entre 4 et 20 mots, choix de l'utilisateur), générée aléatoirement, et que j'aimerais associer aux 4 couleurs de telle façon qu'il y ait un ordre de priorité : on associe d'abord les mots aux couleurs les plus fortes, chaque mot associé retire un à la valeur de la couleur, jusqu'à ce que l'on atteigne la valeur suivante.

Le plus simple c'est de donner un exemple :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
$carreau=5
$pique=7
$coeur=9
$trefle=4
// et 9 mots à répartir.

• - On commence par attribuer 1 mot à la couleur la plus forte, donc $coeur. On opère alors $coeur-- ($coeur=8)
• - $coeur reste la plus forte, donc on continue en attribuant 1 autre mot à $coeur. $coeur-- ($coeur=7)
• - $coeur reste la plus forte (à égalité, mais on reprend dans l'ordre), donc on attribue un 3e mot à $coeur. $coeur-- ($coeur=6)
• - Cette fois c'est $pique le plus fort, donc on lui attribuer 1 mot. $pique-- ($pique=6)
• - Puisqu'on reprend dans l'ordre, c'est à nouveau $coeur, donc $coeur-- ($coeur=5)
• - Puis même logique pour $pique : $pique-- ($pique=5)
• - De retour à $coeur : $coeur-- ($coeur=4)
• - Puis $pique-- ($pique=4)
• - A ce moment-là c'est $carreau qui devient la plus forte, on lui attribue donc 1 mot ($carreau--, $carreau=4).

Et ainsi de suite, jusqu'à épuisement des mots à répartir (en l'occurrence dans cet exemple ça s'arrêterait ici, $trefle n'aurait donc rien)
Il faut donc qu'à chaque étape on vérifie s'il reste des mots à répartir, sinon on arrête.

A la fin, on doit obtenir la répartition détaillée par couleur, par exemple : carreau : mot1, mot2, mot3 / pique : mot4 mot5 / pique : mot6.

J'espère que je suis clair
Et j'avoue que je suis complètement perdu sur la logique même avec laquelle procéder...

Merci par avance pour votre aide !

PS : voilà l'état de ma réflexion :

- Commencer par trier les couleurs :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
$couleur=array($carreau,$pique,$coeur,$trefle);
arsort($couleur);

- Créer une boucle qui va récupérer les valeurs des $mots dans la BDD ($req vient chercher le nombre de mots choisis par l'utilisateur) :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
while ($data = mysqli_fetch_array($req)) {
    echo $data['mot'];       
}

Mais pour la suite...

[rawsrc]

salut,

quelque chose dans ce genre devrait faire l'affaire :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
$couleurs = ['carreau' => 5, 'pique' => 7, 'coeur' => 9, 'trefle' => 4];
 
// ici ça représente ton dictionnaire de mots,
// pour l'exemple je prends les lettres de a à j (10 lettres)
$dic = range('a', 'j');
 
// mots affectés à chaque couleur : [couleur => []]
$mots = array_fill_keys(array_keys($couleurs), []);
 
foreach ($dic as $mot) {
    // tri des couleurs par poids décroissant avec préservation des clés
    arsort($couleurs, SORT_NUMERIC);
    // récupération de la couleur avec le poids  le plus fort
    $key = key($couleurs);
    // affectation du mot à la couleur
    $mots[$key][] = $mot;
    // diminution du poids de la couleur de 1
    --$couleurs[$key];
}

[cyberlp]

Merci pour ta réactivité !

Alors j'ai essayé en adaptant :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
 
         $couleurs = ['carreau' => $carreau, 'pique' => $pique, 'coeur' => $coeur, 'trefle' => $trefle];
 
         $nbr_mots = $_POST['nbr_mots'];
         $sql = 'SELECT magimot FROM logos ORDER BY RAND() LIMIT '.$nbr_mots;
         $req = $base->query($sql) or die('Erreur SQL !<br />'.$sql.'<br />'.mysql_error());        
         $dic = mysqli_fetch_array($req);
 
         $mots = array_fill_keys(array_keys($couleurs), []);
 
         foreach ($dic as $mot) {
            arsort($couleurs, SORT_NUMERIC);
            $key = key($couleurs);
            $mots[$key][] = $mot;
            --$couleurs[$key];
         }

Evidemment il y a d'abord la ligne de connexion à la BDD, et les variables $carreau etc. sont correctement récupérées.
Est-ce que j'ai commis une erreur ? Et comment puis-je afficher le résultat sous la forme :
"Carreau : mot1, mot2, mot3
Pique : mot4, mot5"
etc.

Par ailleurs, les mots dans la BDD sont stockés par groupe de 3 ou 4, séparés par des virgules. Il faut donc d'abord en choisir 1 seul du groupe (aléatoirement). Pour cela j'appliquais le code suivant, qui fonctionnait bien, mais comment l'intégrer à ta proposition ?

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
 while ($data = mysqli_fetch_array($req)) {
        $data1=$data['magimot'];
        $data1_random = explode(',',$data1);
         echo $data1_random[array_rand($data1_random,1)];
        }

Merci encore !

[rawsrc]

je ne rien testé alors...

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

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
$couleurs = ['carreau' => $carreau, 'pique' => $pique, 'coeur' => $coeur, 'trefle' => $trefle];
$nbr_mots = isset($_POST['nbr_mots']) && intval($_POST['nbr_mots']) ? intval($_POST['nbr_mots']) : 10;
 
$sql = 'SELECT magimot FROM logos ORDER BY RAND() LIMIT '.$nbr_mots;
$qry = $base->query($sql) or die('Erreur SQL !<br />'.$sql.'<br />'.$base->error);
$dic = [];
 
while ($words = $qry->fetch_array()) {
    array_push($dic, ...explode(',', $words));
}
 
shuffle($dic); // on mélange tous les mots
 
$mots = array_fill_keys(array_keys($couleurs), []);
 
foreach ($dic as $mot) {
    arsort($couleurs, SORT_NUMERIC);
    $key = key($couleurs);
    $mots[$key][] = $mot;
    --$couleurs[$key];
}
 
$resultat = [];
foreach ($mots as $c => $m) {
    $resultat[] = $c.' : '.implode(', ', $m);
}
 
echo implode('<br>', $resultat);

[cyberlp]

J'ai corrigé le fetch au lieu de fecth et supprimé les ... avant explode, mais ça ne marche pas chez moi.

Il y a bien l'affichage du nom des couleurs, mais les valeurs n'apparaissent pas, et je ne comprends pas pourquoi :-(


PS : et pourquoi la ligne :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

$nbr_mots = isset($_POST['nbr_mots']) && intval($_POST['nbr_mots']) ? intval($_POST['nbr_mots']) : 10;

par rapport à la simple :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

$nbr_mots=$_POST['nbr_mots'];

[rawsrc]

euh les ... ont leur utilité. Ils servent à déstructurer un tableau en parties.
Et la ligne : array_push($dic, ...explode(',', $words)); permet d'ajouter les parties à la suite dans le tableau $dic.

La ligne $nbr_mots = isset($_POST['nbr_mots']) && intval($_POST['nbr_mots']) ? intval($_POST['nbr_mots']) : 10;, s'assure juste que la variable $_POST['nbr_mots'] est bien définie et qu'elle est numérique sinon par défaut elle prend la valeur 10.

Tu as une erreur en particulier ?

[cyberlp]

euh les ... ont leur utilité. Ils servent à déstructurer un tableau en parties.
Tu as une erreur en particulier ?

Aïe au temps pour moi ! Je les ai rajoutés.
Pas d'erreur en particulier, s'affiche seulement :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
 
carreau :
pique :
coeur :
trefle :

J'ai vérifié et $nbr_mots ainsi que les 4 variables $carreau etc. sont bien récupérées.

[rawsrc]

j'ai fait un essai chez moi avec ce code :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

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
$carreau = 5;
$pique   = 7;
$coeur   = 9;
$trefle  = 4;
 
$couleurs = ['carreau' => $carreau, 'pique' => $pique, 'coeur' => $coeur, 'trefle' => $trefle];
$nbr_mots = isset($_POST['nbr_mots']) && intval($_POST['nbr_mots']) ? intval($_POST['nbr_mots']) : 10;
 
//$sql = 'SELECT magimot FROM logos ORDER BY RAND() LIMIT '.$nbr_mots;
//$qry = $base->query($sql) or die('Erreur SQL !<br />'.$sql.'<br />'.$base->error);
$dic = [];
 
$data = ['a,b,c,d', 'e,f,g', 'i,j,k,l,m'];
foreach ($data as $k => $words) {
    array_push($dic, ...explode(',', $words));
}
/*
while ($words = $qry->fecth_array()) {
    array_push($dic, ...explode(',', $words));
}
*/
shuffle($dic); // on mélange tous les mots
 
$mots = array_fill_keys(array_keys($couleurs), []);
 
foreach ($dic as $mot) {
    arsort($couleurs, SORT_NUMERIC);
    $key = key($couleurs);
    $mots[$key][] = $mot;
    --$couleurs[$key];
}
 
$resultat = [];
foreach ($mots as $c => $m) {
    $resultat[] = $c.' : '.implode(', ', $m);
}
 
echo implode('<br>', $resultat);

et ça roule très bien.

[cyberlp]

Alors je crois comprendre : dans la BDD, les mots sont stockés par groupe, par exemple :
id
1- mot1,mot2,mot3
2- mot4,mot5,mot6
etc.

il ne faut donc en sélectionner qu'un par ligne.
Donc j'ai modifié la ligne :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

 array_push($dic, ...explode(',', utf8_encode($words[array_rand($words,1)])));

Cette fois les mots s'affichent correctement comme résultats, mais il y en a beaucoup trop, puisque seulement $nbr_mots devraient s'afficher, et là j'ai autant de mots que la valeur de départ de chaque couleur (donc 5 mots pour carreau, 7 pour pique etc.)

[rawsrc]

tu as combien de mots par cellule ? c'est fixe ou variable ?

[cyberlp]

c'est variable (entre 2 et 5)

[rawsrc]

ok, c'est nécessaire utf8_encode(), t'as un souci avec les encodages ?
Pour retomber sur tes pieds, quand tu as fini d'extraire tous les mots, tu fais un array_slice() à la longueur que tu veux.

[cyberlp]

Pour le utf8 oui sur les accents, mais j'imagine que c'est ma table sql qui est mal paramétrée ? je vais aller vérifier ça

Sinon pour l'array_slice(), j'ai fait quelques essais et je ne vois pas du tout comment l'utiliser par rapport à mon array_rand()
Est-ce ainsi ?

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
shuffle($dic);
 $dic=array_slice($dic,0,$nbr_mots);

[rawsrc]

quand tu as fini d'extraire tous les mots, tu fais un array_slice() à la longueur que tu veux.

Tu dois déboguer un peu de ton côté, je ne vais pas jouer aux devinettes.

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
while ($words = $qry->fetch_array()) {
    $parts = explode(',', $words);
    echo $words, '<br>';
    print_r($parts);
    array_push($dic, ...explode(',', $parts));
}
exit;

Poste le résultat stp.

[cyberlp]

ça me génère

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
Array
Array
Array
...

Par contre, la version de mon post ci-dessus (j'ai modifié trop tard, tu avais déjà répondu, désolé !) :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
shuffle($dic);
 $dic=array_slice($dic,0,$nbr_mots);

a l'air de fonctionner, ou bien est-ce moi qui me trompé-je ?

[rawsrc]

ok donc il faut essayer avec ceci :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

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
$couleurs = ['carreau' => $carreau, 'pique' => $pique, 'coeur' => $coeur, 'trefle' => $trefle];
$nbr_mots = isset($_POST['nbr_mots']) && intval($_POST['nbr_mots']) ? intval($_POST['nbr_mots']) : 10;
 
$sql = 'SELECT magimot FROM logos ORDER BY RAND() LIMIT '.$nbr_mots;
$qry = $base->query($sql) or die('Erreur SQL !<br />'.$sql.'<br />'.$base->error);
$dic = [];
 
while ($words = $qry->fecth_array()) {
    array_push($dic, ...explode(',', $words[0]));
}
shuffle($dic); // on mélange tous les mots
$dic = array_slice($dic, 0, $nbr_mots);
 
$mots = array_fill_keys(array_keys($couleurs), []);
 
foreach ($dic as $mot) {
    arsort($couleurs, SORT_NUMERIC);
    $key = key($couleurs);
    $mots[$key][] = utf8_encode($mot);
    --$couleurs[$key];
}
 
$resultat = [];
foreach ($mots as $c => $m) {
    $resultat[] = $c.' : '.implode(', ', $m);
}
echo implode('<br>', $resultat);

[cyberlp]

ça m'a l'air parfait, merci beaucoup !

une remarque : si je veux afficher les valeurs correspondant à chaque mot, est-ce possible ?
par exemple :
Carreau : 9 (mot1), 8 (mot2)...
Pique : 7 (mot3)...

Si j'ai bien compris elles sont stockées dans $couleurs[$key], mais comment les afficher au niveau du résultat final hors de la boucle foreach ?

[rawsrc]

comme ça :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

$mots[$key][] = utf8_encode($couleurs[$key].' '.$mot);

[cyberlp]

Super, c'est nickel !

Un détail dont je me rends compte. J'aimerais éviter les doublons dans la requête :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

$sql = 'SELECT magimot FROM logos ORDER BY RAND() LIMIT '.$nbr_mots;

J'ai donc modifié en SELECT DISTINCT magimot, mais cela ne semble rien changer, il continue de générer des doublons.

[rawsrc]

euh, t'es sûr de connaître à minima le PHP ?
Je me pose la question si tu comprends et retiens les réponses qui te sont données parce que là tu ne fais aucun effort de recherche pour être un minimum autonome.
En gros, ta solution de facilité : un problème => une question alors que cela devrait être : un problème => je recherche et essaie de me débrouiller => j'apprends => je passe au problème suivant. Dans ce schéma, si effectivement la solution ou la rustine trouvée ne colle pas alors je vais poser ma question sur le forum DVP.

Un autre point : la logique est essentielle dans le processus de développement :
Réfléchis 30 secondes :
Chaque enregistrement de ta base de données contient une liste de mots sous cette forme : mot1,mot2,mot3...
Donc quand tu vas faire un SELECT DISTINCT, le filtre d'unicité s'appliquera logiquement à la totalité du contenu de la cellule, c'est-à-dire mot1,mot2,mot3...
Si tu as dans une cellule mot1,mot2,mot3... et dans la suivante mot1,mot2,mot4... alors c'est bien deux valeurs distinctes pour le moteur quand bien même pour toi les mots1 et mots2 sont des doublons. Le moteur n'a aucune conscience de tes mots.

Donc utiliser SELECT DISTINCT dans ta requête est totalement illogique.

En conséquence, tu dois travailler sur l'unicité des mots une fois qu'ils sont séparés les uns des autres dans le tableau $dic.
A la fin du traitement $dic = ['mot1', 'mot2', 'mot3', 'mot1', 'mot2', 'mot4'], donc pour n'avoir que des valeurs distinctes, PHP te met à disposition une fonction qui se charge de ce travail : array_unique(). Tu n'as qu'à faire : $dic = array_unique($dic); et tu auras : $dic = ['mot1', 'mot2', 'mot3', 'mot4']