Discussion :

[petit_chat]

Bonjour,
D'avance merci de l'attention que vous porterez à ce problème. Je suis nul en algo mais pour un développeur ce problème est trivial. Je cherche à programmer en python un script qui produit une playlist. Cette playlist contient des titres de genres musicaux différents (rock, hiphop, musique française, reggae, etc..). Ces genres musicaux ne sont pas tous présents en même proportion: sur la playlist (il y a 34% de musique française, 33% de rock, 12% de hiphop, 7% de reggae, etc...). Je voudrais que mon programme génère une playlist telle que la répartition des genre soit homogène. C'est à dire, par exemple, si j'ai 33% de rock, alors je veux qu'il y ai un titre rock tous les 3 titres. Si j'ai 7% de reggae alors j'aurai un reggae tous les 14 titres à peu près.

Pour simplifier on peut résoudre mon problème à celui-ci plus simple:
On a 100 jetons de 5 couleurs différentes. On a un tableau de 100 cases. Comment répartir dans le tableau les jetons de couleurs différentes de la façon la plus homogène possible ?

Exemple:
50 jetons verts
30 jetons rouges
10 jetons bleus
7 jetons jaune
3 jetons noirs

On peux calculer facilement la fréquence d'un jeton de chaque couleur.
fr(vert) = 100/50 = 2 => un jeton tous les 2 jetons
fr(rouge) = int(100/30) + 100mod30 = 3 reste 10 => un jeton tous les 3 jetons , je ne sais pas traiter le reste
fr(bleus)= 100/10 = 10 => un jeton tous les 10 jetons
fr(jaune)= int(100/7) + 100mod7 = 14 reste 2 => un jeton tous les 14 jetons, comment traiter le reste ?
fr(noir)= int(100/3) + 100mod3 = 33 reste 1 => un jeton tous les 33, que faire du reste ?

Comment construire un tableau qui respecte ces fréquences le mieux possible ? Que faire des restes ? Comment traiter le cas où plusieurs couleurs différentes doivent tomber sur la même case du tableau ? C'est trop complexe pour ma petite tête, je m'y perds. Merci de m'aider.

[mathieu]

ma 1re idée à chaud serait d'utiliser les "cases vides".
si on reprend votre exemple des jetons, après avoir placé les 50 jetons verts, vous placez bien les jetons rouges en comptant seulement les cases vides (50).
par contre 30 jetons sur 50 cases vides ça fait 3 jetons toutes les 5 cases et je ne vois pas trop comment répartir ces 3 jetons. intuitivement je dirais 1 1 0 1 0 mais je ne vois pas comment calculer cela dans le cas général.

[mathieu]

j'avais 3 petits gateaux de noël devant moi donc avant de disparaitre dans ma bouche, ça ma refait penser à cette histoire de 3 jetons.

si on calcule 50 / 30 qui fait environ 1,666, on peut utiliser cela comme base pour la position des jetons rouges qui seront donc aux positions suivantes :

• 1,666
• 3,333
• 5
• 6,666
• 8,333
• 10

en arrondissant à l'entier le plus proche, on a alors le placement 0 1 1 0 1 0 1 1 0 1 ...
et en arrondissant à l'entier supérieur ou inférieur, on a des autres placements mais avec le même motif qui se répète donc je pense que les 3 placements ont la même homogénéité.

[tbc92]

Voici un petit bout de 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
func main() {
	tbObjectif := []float64{0.5, 0.3, 0.1, 0.07, 0.03}
	var tbRealise []int
	var nb int
 
	for j := 0; j < 5; j++ {
		tbRealise = append(tbRealise, 0)
	}
 
	for i := 0; i < 150; i++ {
		nb0 := nb
		if nb0 == 0 {
			nb0 = 1
		}
		qChoixBest := 0
		qValeurBest := tbObjectif[0] - float64(tbRealise[0])/float64(nb0)
		for j := 1; j < 5; j++ {
			qValeur := tbObjectif[j] - float64(tbRealise[j])/float64(nb0)
			if qValeur > qValeurBest {
				qValeurBest = qValeur
				qChoixBest = j
			}
		}
		tbRealise[qChoixBest]++
		nb++
		fmt.Println( "étape n° ", i, "  couleur choisie=", qChoixBest, "   nb  pour cette couleur=", tbRealise[qChoixBest])
	}
}

A tout moment, pour chacune des 5 couleurs, on compare l'objectif, et le réalisé. Et on choisit la couleur pour laquelle cet écart (le retard donc) est le plus important.
Forcément, certaines couleurs sont en avance (proportion réalisée supérieur à l'objectif) et d'autres en retard ; la première fois que la couleur n°4 apparaît est au 11ème tirage, alors que la proportion-objectif pour cette couleur est 3%.

Résultat :

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
étape n°  0   couleur choisie= 0    nb  pour cette couleur= 1
étape n°  1   couleur choisie= 1    nb  pour cette couleur= 1
étape n°  2   couleur choisie= 2    nb  pour cette couleur= 1
étape n°  3   couleur choisie= 0    nb  pour cette couleur= 2
étape n°  4   couleur choisie= 3    nb  pour cette couleur= 1
étape n°  5   couleur choisie= 0    nb  pour cette couleur= 3
étape n°  6   couleur choisie= 1    nb  pour cette couleur= 2
étape n°  7   couleur choisie= 0    nb  pour cette couleur= 4
étape n°  8   couleur choisie= 1    nb  pour cette couleur= 3
étape n°  9   couleur choisie= 0    nb  pour cette couleur= 5
étape n°  10   couleur choisie= 4    nb  pour cette couleur= 1
étape n°  11   couleur choisie= 0    nb  pour cette couleur= 6
étape n°  12   couleur choisie= 1    nb  pour cette couleur= 4
étape n°  13   couleur choisie= 0    nb  pour cette couleur= 7
étape n°  14   couleur choisie= 2    nb  pour cette couleur= 2
étape n°  15   couleur choisie= 0    nb  pour cette couleur= 8
étape n°  16   couleur choisie= 1    nb  pour cette couleur= 5
étape n°  17   couleur choisie= 0    nb  pour cette couleur= 9
étape n°  18   couleur choisie= 1    nb  pour cette couleur= 6
étape n°  19   couleur choisie= 0    nb  pour cette couleur= 10
étape n°  20   couleur choisie= 3    nb  pour cette couleur= 2
étape n°  21   couleur choisie= 0    nb  pour cette couleur= 11
étape n°  22   couleur choisie= 1    nb  pour cette couleur= 7
étape n°  23   couleur choisie= 0    nb  pour cette couleur= 12
étape n°  24   couleur choisie= 2    nb  pour cette couleur= 3
étape n°  25   couleur choisie= 0    nb  pour cette couleur= 13
etc

[petit_chat]

merci mathieu et tbc92 de vous intéresser à ce problème. Je suis toujours perplexe mais moins avec vos réponses.
Si on sait calculer l'intervalle moyen entre chaque jeton de chaque couleur alors on peut facilement contrôler si un tableau tout fait est homogène ou non. (on peut même préciser une tolérance). Donc une approche, barbare, je vous l'accorde serai de générer des tableaux aléatoirement jusqu'à ce qu'un tableau convienne. Vous en pensez quoi ?

[tbc92]

Vérifier qu'un tableau convient, ça peut être compliqué.
Si on a un tableau avec 100 jetons, et que la couleur A est supposée peser 10%, quel contrôle tu vas faire ? Y a-t-il (environ) 10% de A sur le total, ou y-a-t-il (environ )10% de A parmi les 50 premiers, et aussi parmi les 50 derniers ?

Si tu veux utiliser le hasard, tu peux effectivement le faire.
Soit en adaptant le code que je proposais, en modifiant par exemple les lignes 16 et 18 avec ... + random(0.15) par exemple. Mais il faut peut être modifier le 0.15, mettre un peu plus au début, et diminuer ce nombre au fur et a mesure qu'on avance

Ou sinon, tu t'appuies sur le hasard ainsi :

Code :

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

1
2
3
4
5
6
7
8
9
for i=0 ; i<100 ; i++ {
  r = random()  // Un nombre aléatoire entre 0 et 1
  if r < 0.5 then val = 0
  if 0.5 <= r < 0.8  then val=1
  if 0.8 <= r < 0.9  then val=2
  if 0.9 <= r < 0.97  then val=3
  if 0.97 <= r   then val=4
  print ( r)
}

Par construction, ta suite vérifie les pourcentages imposés. C'est assez simple à réécrire, pour une liste de couleurs qui peut avoir un nombre quelconque de couleurs, et des seuils quelconques.

[mathieu]

Donc une approche, barbare, je vous l'accorde serai de générer des tableaux aléatoirement jusqu'à ce qu'un tableau convienne.

si on commence à placer les 30 jetons rouges alors les 50 jetons rouges auront beaucoup plus de mal à être réparti. donc je pense (et ça reste à prouver) que l'algorithme qui commence par placer les jetons les plus fréquent produit un placement optimal.
à partir de la, utiliser un placement aléatoire aurait une seule utilité, c'est si la construction du tableau complet est trop grand pour tenir en mémoire.

pour aller plus loin, le fait de connaitre le nombre total de jeton ainsi que le nombre de la couleur la plus fréquente permet de déterminer les cases occupées. donc j'ai l'impression qu'à partir de la liste de fréquence, il doit exister un algorithme qui permet de savoir quel jeton est à une case donnée sans avoir besoin de calculer le tableau complet.

[Flodelarab]

Bonjour

@petit_chat : Que reproches-tu à la première proposition de tbc92 ? Elle est excellente.

[petit_chat]

"Que reproches-tu à la première proposition de tbc92"
Je ne la comprends pas du tout mais je reproche rien à personne. Par contre si j'écris un script je veux comprendre ce que j'écris. (Je suis admin à la base et pour comprendre un code j'ai besoin de beaucoup réfléchir et de temps, ça ne jaillit pas chez moi comme chez un dev)

En tout cas merci déjà pour toutes vos réponses que je vais étudier.

[tbc92]

Voici l'explication de mon code.
On a 5 styles numérotés de 0 à 4, et on veut que les styles 'pèsent' respectivement 50%, 30%, 10%, 7% et 3%. Ce sont les objectifs. C'est le tableau tbObjectif dans le code.

A tout instant, on regarde l'historique. (on est dans le cas d'une play-list, on a une chronologie, on passe les chansons les unes après les autres).
Si l'historique est 'vide' (on n'a pas commencé la diffusion), c'est un peu particulier, considérons qu'on a diffusé au moins une chanson ... et éventuellement beaucoup plus. (le cas historique vide est traité en disant : si nb0=0 alors nb0=1)
On sait donc calculer la proportion de chaque style dans l'historique. C'est le tableau tbRealisé qui contient le nombre de fois où chaque style est sorti.
Par exemple, on a diffusé 3 titres : 1 du style n°0 et 1 du style n°1 et 1 du style n°2
Dans l'historique, on a donc :
proportion de 0 : 33%
proportion de 1 : 33%
proportion de 2 : 33%
proportion de 3 : 0%
proportion de 4 : 0%

Les styles n°1 et 2 sont en avance, on a diffusé 'trop' de musiques de ces styles par rapports aux objectifs.
Les autres sont en retard ; c'est le style n°0 qui est le plus en retard, puis qu'il lui manque 17% (pour les styles 3 et 4, il manque respectivement 7% et 3%)
Le 4ème titre sera donc du style n°0
Après ce 4ème titre, on a donc :
Historique :
proportion de 0 : 2 titres sur 4 = 50%
proportion de 1 : 1 titre sur 4 = 25%
proportion de 2 : 1 titre sur 4 = 25%
proportion de 3 : 0%
proportion de 4 : 0%
Pour le titre suivant , c'est le titre °3 qui est le plus en retard, il lui manque 7%
Le titre suivant sera donc le n°3

Après ce 5ème titre , on a donc :

Historique :
proportion de 0 : 2 titres sur 5 = 40%
proportion de 1 : 1 titre sur 5 = 20%
proportion de 2 : 1 titre sur 5 = 20%
proportion de 3 : 1 titre sur 5 = 20%
proportion de 4 : 0%
Ici, il y a le style 0 et le style 1 qui sont à égalité. Tous les 2 sont en retard d'exactement 10% par rapport à leur objectif. Le code que je propose va choisir le style n°0 ; il choisirait le style n°1 si on remplaçait > par >= en ligne 19
Etc etc

[petit_chat]

tbc92 alors un super merci pour ces explications, c'est clair maintenant. je passe le topic en résolu. Je ne suis peut être pas un pro mais ta solution semble fine, simple et très élégante. Moi j'ai tendance à vouloir buter les moustiques à coup de tank

[tbc92]

Je n'ai pas vérifié, mais je pense qu'on peut corriger un petit problème.
Comme je le faisais remarquer, avec les pourcentages (50, 30, 10, 7, 3), le style qui a le pourcentage 3 apparaît dès le 11ème titre. C'est un peu tôt. En gros, chaque style devrait être un tout petit peu au dessus de son pourcentage cible sur la moitié du temps, et un tout petit peu en dessous l'autre moitié du temps. Ce style qui a un pourcentage de 3% devrait apparaître pour la 1ère fois au 16° ou 17° tirage. Et ici, on constate que les styles qui ont des pourcentages objectifs les plus bas arrivent tôt dans la play-liste.
L'explication, c'est qu'on sélectionne le style qui est le plus en retard, alors qu'on pourrait dire : si je choisis tel style, il va forcément se retrouver en avance par rapport à son objectif, et on va choisir le style qui va se retrouver le moins en avance.
Mais dans ce cas, on aurait probablement le biais inverse.
Je pense que la bonne solution, c'est :

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
func main() {
	tbObjectif := []float64{0.5, 0.3, 0.1, 0.07, 0.03}
	var tbRealise []int
	var nb int
 
	for j := 0; j < 5; j++ {
		tbRealise = append(tbRealise, 0)
	}
 
	for i := 0; i < 150; i++ {
		nb0 := nb
		if nb0 == 0 {
			nb0 = 1
		}
		qChoixBest := 0
		qValeurBest := tbObjectif[0] - float64(tbRealise[0]+0.5)/float64(nb0+0.5)
		for j := 1; j < 5; j++ {
			qValeur := tbObjectif[j] - float64(tbRealise[j]+0.5)/float64(nb0+0.5)
			if qValeur > qValeurBest {
				qValeurBest = qValeur
				qChoixBest = j
			}
		}
		tbRealise[qChoixBest]++
		nb++
		fmt.Println( "étape n° ", i, "  couleur choisie=", qChoixBest, "   nb  pour cette couleur=", tbRealise[qChoixBest])
	}
}

Je pinaille, je pinaille.

[petit_chat]

@tbc92: ça me touche que cet algo te tienne à coeur et que tu l'investisse comme un exercice. Pour l'instant je m'occupe d'autres choses urgentes mais ce week end je vais m'atteler à bien comprendre ton code, le faire tourner en python et l'intégrer enfin au script de production. Tu auras mes retours sur ce topic tbc92. A la lumière de tes explications je vais m'en sortir je pense. En m'inspirant de tes explications je vais enrichir le code en commentaires pour mieux le comprendre si je l'oubli et que j'y reviens.
"je pinaille, je pinaille": les détails sont essentiels

[petit_chat]

@tbc92:
Salut, j'ai eu le temps de bien regarder ton code. Je comprends le principe général je crois. On choisit les jetons de différentes couleurs les uns après les autres. Pour ce faire on a un objectif de fréquence pour chaque couleur. Avant le choix du jeton les différentes couleurs sont plus ou moins en avance ou en retard sur leur fréquence et on choisit toujours la couleur qui est le plus loin de sa fréquence idéale (qui a le plus de retard).
Par contre dans les détails je ne comprends pas certains trucs:
- ligne 10: pourquoi "i<150" ? d'où vient le 150?
- ligne 16: je ne comprends pas le pourquoi de cette formule pour qValeurBest
- ligne 18: idem pour qValeur

Là je le traduis en python pour l'essayer, je risque de revenir avec d'autres questions
D'avance un grand merci

[tbc92]

150 : il faut bien que le programme s'arrête à un moment. J'affiche 150 sélections, et je m'arrête. Tu peux mettre n'importe quel nombre à la place.

Lignes 15 et 16 : j'initialise la meilleure valeur (qValeurBest), et le numéro de style correspondant, en disant (jusqu'à contre-ordre) que c'est le style n°0 qui est le plus en retard.
Puis lignes 17 à 23, je calcule le retard pour tous les autres styles (qValeur= ...), je compare ce retard à qValeurBest, et si ce nouveau style est plus en retard que ce que j'avais mémorisé jusque là, alors je prends cette nouvelle valeur. Je mémorise donc le retard (qValeurBest), et le numéro du style qui correspond (qChoixBest)

Ici, j'ai programmé en go, et go est très contraignant sur les types (entier, flottant ... on ne peut pas soustraire un entier et un float). Dans d'autres langages, la ligne 18 serait simplement

Code :

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

qValeur := tbObjectif[j] -  (tbRealise[j]+0.5)/(nb0+0.5)

[AbsoluteLogic]

Bonjour,

Je passais par là, et souhaitais proposer une solution vite fait, qui revient à peu près au même, mais présenté différemment, et que je trouve plus simple à lire.

Voici un code Python documenté, que tu peux tester par exemple directement ici si tu n'as pas ça

Code python :

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
from random import random
 
# Nombre de jetons de chaque couleur
jetons = [
    ('vert', 50),
    ('rouge', 30),
    ('bleu', 10),
    ('jaune', 7),
    ('noir', 3)
]
 
# Le poids est l'inverse de la fréquence
poids = [1 / nb for color, nb in jetons] # [0.02, 0.033, 0.1, 0.143, 0.333]
 
# La distance représente dans combien de temps un type de jeton va réapparaitre
# EDIT: meilleure initialisation suite au commentaire #17 de tbc92:
# distance = [poid for poid in poids] # initialisation avec une copie des poids
distance = [poid * random() for poid in poids] # initialisation avec des valeurs aléatoires entre 0 et poids
 
for _ in range(100): # tant qu'on veut générer de nouveaux éléments pour la playlist (peut être infini)
    # le prochain élément est le plus proche, ie avec la plus faible distance
    idx = min(range(len(jetons)), key=lambda i : distance[i])
    # On affiche la couleur du jeton choisi
    print(jetons[idx][0])
    # On "éloigne" ce type de jeton selon une valeur (poid) inversement proportionnelle à la fréquence
    # ie, plus un élément un fréquent, moins il sera éloigné
    distance[idx] += poids[idx]

A noter que on peut optimiser cet algo avec une file de priorité pour les intéressés.

[tbc92]

On a d'autres problématiques qui peuvent se greffer.
Imaginons les pourcentages suivants : 42% 23% 15% 12% et 8 autres styles, qui auraient tous exactement le même pourcentage, 1%, que je vais appeler les marginaux.

On va avoir au début de la playlist différents titres, parmi les styles importants, et d'un coup, tous les styles marginaux vont se bousculer au portillon, ils risquent d'être tous diffusés sur une plage horaire assez réduite.
On a peut-être intérêt à dire : aucun style ne doit peser moins de 4% Si certains styles pèsent moins de 4%, on les regroupe ensemble, et ce nouveau groupe a un poids correspondant au cumul des poids.

Donc ici, on aurait les pourcentages 42%, 23%, 15%, 12% et 8%
Quand c'est le groupe 'marginaux' qui est sélectionné, un second process choisit quel est le style le plus en retard parmi les styles regroupés dans cet ensemble. Comme ça, on répartit les styles marginaux, environs 1 titre sur 12 vient de ce groupe.

Illustration : j'ai les pourcentages ci-dessus, et je sais que je vais diffuser exactement 100 titres. Le style n°5, qui pèse 1%, et donc qui n'apparaîtra qu'une fois, on veut qu'il soit diffusé exactement au milieu, 51° ou 51ème titre.
Les styles n°6, 7, 8 ... 12, pareil.

Du coup, ça incite à aller vers une autre méthode, parce que regrouper les styles marginaux, ok; mais où fixe -t-on la limite, c'est arbitraire, et ça influe éventuellement pas mal sur le résultat.

Je veux diffuser exactement 100 titres (je dois connaître le nombre total dès le début, c'est la contrainte pour cette méthode). Je sais exactement le nombre de titres par style qu'il y aura.
Je prends le style le plus important (42 titres dans mon exemple).
Ce style aura les places n°1, et n°100, et je répartis les autres régulièrement. 42 morceaux, donc 41 intervalles. La somme des 41 intervalles doit donner 99. Donc 0*41/99 pour le premier titre, et k*41/99 pour le k-ème titre (que j'arrondis évidemment).

Reste 58 emplacements, et je case maintenant le 2ème style celui qui doit avoir 23 titres. Je ne regarde que les 58 emplacements laissés vides (donc 57 intervalles), ils portent les n°0 à 57. Et je place mes 23 titres aux rangs k*22/57 pour k allant de 0 à 22.
Etc etc.

Ainsi, quand je vais arriver aux styles qui doivent passer une seule fois, il restera 8 emplacements à peu près régulièrement répartis. Je n'ai plus le problème évoqué au début.

[AbsoluteLogic]

On a d'autres problématiques qui peuvent se greffer.
Imaginons les pourcentages suivants : 42% 23% 15% 12% et 8 autres styles, qui auraient tous exactement le même pourcentage, 1%, que je vais appeler les marginaux.

On va avoir au début de la playlist différents titres, parmi les styles importants, et d'un coup, tous les styles marginaux vont se bousculer au portillon, ils risquent d'être tous diffusés sur une plage horaire assez réduite.

Effectivement, j'ai réglé ce problème dans mon algo "simplement" avec l'initialisation des distances, que j'avais avant arbitrairement choisi égales au poids, mais que j'initialise maintenant avec une valeur aléatoire entre 0 et poids. Si on ne veut pas d'aléatoire, on peut également imaginer une répartition uniforme des valeurs d'initialisation entre 0 et poids, mais c'est un peu plus compliqué à coder.

[APL-AML]

Exercice corrigé d’algorithmique

■ ■ ■ SOMMAIRE ■ ■ ■

1. La problématique
2. Tableaux Excel
3. Simulation
   
   • Identification des données
   • Les données et leur calcul
   • Simulation pour chaque couleur
4. Algorigramme pour renseigner un tableau en deux dimensions (Matrice)
   
   • Les variables
   • L’Algorigramme
5. Algorigramme pour créer une playlist depuis une matrice
   
   • Les variables de la Matrice (100 lignes x 5 colonnes)
   • L’Algorigramme
6. Algorigramme pour créer une table "couleur" BDD
   
   • Les tables
   • Les variables
   • L’Algorigramme
7. Algorigramme pour créer une playlist depuis une table BDD
   
   • Création de la table t_jetons
   • Les variables de la table t_jetons
   • Les variables de la table playlist
   • L’Algorigramme
8. Conclusion

■ § 1. La problématique

On a donc 100 jetons de 5 couleurs différentes correspondant à des genres musicaux différents. Comment répartir ces jetons en proportions différentes dans une playlist de genres musicaux la plus homogène possible ?

• 50 jetons verts (variété française)
• 30 jetons rouges (rock)
• 10 jetons bleus (hiphop)
• 7 jetons jaunes (reggae)
• 3 jetons noirs (musique de film)

petit_chat propose comme exemple, un pourcentage sur un total de 100 jetons, mais rien n’empêche, bien sûr, de définir un pourcentage par rapport à un total de jetons inférieur ou supérieur à 100.

Ma réflexion s’appuie sur l’exemple de petit_chat. Elle n’est en aucun cas universelle. En effet, si le pourcentage le plus important était supérieur à 50%, ma démarche concernant un tel pourcentage ne pourrait plus s’appliquer. Il y aurait alors une alternance aléatoire des jetons du genre : jeton, jeton, vide, jeton, vide…

Prenons cet exemple de petit_chat comme un exercice d’algorithmique. La solution nécessite à priori deux algorithmes.

1. Un premier algorithme pour affecter les jetons dans un tableau en deux dimensions de 100 liges sur 5 colonnes (1er tableau Excel joint) :
   
   • Soit un algorithme appliqué à un tableau en deux dimensions
   • Soit un algorithme appliqué à une table BDD
   
   
2. Un second algorithme pour créer la playlist (2ème tableau Excel joint)

Avant d’aller plus loin, je vous montre d’abord le résultat de ma réflexion à l’aide de deux tableaux Excel, puis je vous explique.

Ces deux tableaux résultent d’une simple simulation. Il n’est pas encore question d’algorithmique, c’est juste de la réflexion pragmatique avec le dernier neurone qui me reste et non avec des instructions. De toute façon, je ne dispose plus de mes outils informatiques, je suis à la retraite depuis plus de quinze ans.

Attention !

Excel permettant d’utiliser la couleur, un jeton peut être représenté à la fois par une cellule de couleur et le chiffre "1". Les totalisations verticales et horizontales valident ainsi l’algorithme utilisé à base de calculs.

Sans la couleur, la playlist (2ème tableau Excel), n’afficherait qu’une liste de "1" inexploitable.

La programmation ne permettant pas d’utiliser la couleur, il faudra bien à un moment ou à un autre, concrétiser les jetons par le libellé ou le code de leur couleur.

Cela peut se faire dès le premier algorithme mais pour cet exercice, c’est le 2ème algorithme qui s’en charge.


■ § 2. Tableaux Excel

• Le premier tableau (matrice 100 x 5) correspond au 1er algorithme.
• Le deuxième tableau (playlist) correspond au 2ème algorithme.

Pièce jointe 633567

■ § 3. Simulation

■ § 3.1. Identification des données

Ce n’est finalement qu’un problème d’intervalles.

 
  ┌────────────────> N° de ligne (1 à 100)
  │
  │   ┌────────────> Pourcentage (50, 30, 10, 7, 3)
┌─┴─┬─┴─┐
│ N°│NB%│
├───┼───┤ ───┐
│  1│   │    │
├───┼───┤    ├────> Cellules_Avant (sans jetons)
│  2│   │    │
├───┼───┤ ───┴──────────────────────────────────────────────────────────────────┐
│  3│ 1 │ ───────> 1ère Cellule avec jeton                                      │
├───┼───┤ ───┐                                                                  │
│  4│   │    │                                                                  │
├───┼───┤    │                                                                  │
│  5│   │    ├───> Cellules_Intervalle (sans jetons) ───┐                       │
├───┼───┤    │                                          │                       │
│  6│   │    │                                          │                       │
├───┼───┤ ───┘                                          │                       │
│  7│ 1 │                                               ├─> Total_Intervalles   ├─> Cellules_Début-Fin
├───┼───┤ ───┐                                          │                       │
│  8│   │    │                                          │                       │
├───┼───┤    │                                          │                       │
│  9│   │    ├───> Cellules_Intervalle (sans jetons) ───┘                       │
├───┼───┤    │                                                                  │
│ 10│   │    │                                                                  │
├───┼───┤ ───┘                                                                  │
│ 11│ 1 │ ───────> dernière Cellule avec jeton                                  │
├───┼───┤ ───┬──────────────────────────────────────────────────────────────────┘
│ 12│   │    │
├───┼───┤    ├────> Cellules_Après (sans jetons)
│ 13│   │    │
└───┴───┘ ───┘

L’idée est simple, il s’agit de calculer le nombre entier de cellules d’un intervalle entre deux jetons.

Le nombre de Cellules_Avant correspond au nombre de Cellules_Début-Fin divisé par 2 (on ne considère que les entiers).

Le nombre de Cellules_Après correspond au reste de cette division par 2. Ce reste est ce qu’il est, il ne sera pas forcément égal au nombre de Cellules_Avant mais il n’est pas nécessaire de le connaitre.

petit_chat qui s’inquiétait de savoir que faire des restes de ses opérations… En fait, on les ignore, on ne considère que les entiers.


■ § 3.2. Les données et leur calcul

Définition	Mnémonique	Calcul
N° de ligne	N°	De 1 à n
Pourcentage	NB%	NB% = 50, 30, 17, ou 3
Nombre total de cellules sans jeton	Cellules_vides	100 – NB%
Nombre de cellules sans jeton entre deux cellules avec jeton	Cellules_Intervalle	Cellules_Vides / NB%
Total des cellules vides entre la 1ère cellule avec jeton et la dernière cellule avec jeton	Total_Intervalles	Cellules_Intervalle * (NB% - 1)
Cellules avant la 1ère cellule avec jeton et après la dernière cellule avec jeton	Cellules_Restantes	100 - Cellules_Début-Fin
Nombre de cellules sans jeton avant la 1ère cellule avec jeton	Cellules_Avant	Cellules_Restantes / 2
Nombre de cellules sans jeton après la dernière cellule avec jeton	Cellules_Après	Cellules_Restantes – Cellules_Avant

■ § 3.3. Simulation pour chaque couleur

Pourcentage COULEUR VERTE (50%)	Calcul	Résultat
Calcul des cellules sans jeton	100 – 50	= 50
Calcul d’un intervalle	50 / 50	= 1
Calcul du nombre total de cellules "intervalles"	1 * (50 - 1)	= 49
Calcul du nombre de cellules entre le 1er jeton et le dernier jeton	50 + 49	= 99
Calcul du nombre de cellules restantes	100 – 99	= 1
Calcul du nombre de cellules avant le 1er jeton	1 / 2	= 0

Pourcentage COULEUR ROUGE (30%)	Calcul	Résultat
Calcul des cellules sans jeton	100 – 30	= 70
Calcul d’un intervalle	70 / 30	= 2
Calcul du nombre total de cellules "intervalles"	2 * (30 - 1)	= 58
Calcul du nombre de cellules entre le 1er jeton et le dernier jeton	30 + 58	= 88
Calcul du nombre de cellules restantes	100 – 88	= 12
Calcul du nombre de cellules avant le 1er jeton	12 / 2	= 6

Pourcentage COULEUR BLEUE (10%)	Calcul	Résultat
Calcul des cellules sans jeton	100 – 10	= 90
Calcul d’un intervalle	90 / 10	= 9
Calcul du nombre total de cellules "intervalles"	9 * (10 - 1)	= 81
Calcul du nombre de cellules entre le 1er jeton et le dernier jeton	10 + 81	= 91
Calcul du nombre de cellules restantes	100 – 91	= 9
Calcul du nombre de cellules avant le 1er jeton	9 / 2	= 4

Pourcentage COULEUR JAUNE (7%)	Calcul	Résultat
Calcul des cellules sans jeton	100 – 7	= 93
Calcul d’un intervalle	93 / 7	= 13
Calcul du nombre total de cellules "intervalles"	13 * (7 - 1)	= 78
Calcul du nombre de cellules entre le 1er jeton et le dernier jeton	7 + 78	= 85
Calcul du nombre de cellules restantes	100 – 85	= 15
Calcul du nombre de cellules avant le 1er jeton	15 / 2	= 7

Pourcentage COULEUR NOIRE (3%)	Calcul	Résultat
Calcul des cellules sans jeton	100 – 3	= 97
Calcul d’un intervalle	97 / 3	= 32
Calcul du nombre total de cellules "intervalles"	32 * (3 - 1)	= 64
Calcul du nombre de cellules entre le 1er jeton et le dernier jeton	3 + 64	= 67
Calcul du nombre de cellules restantes	100 – 67	= 33
Calcul du nombre de cellules avant le 1er jeton	33 / 2	= 16

NB : Après positionnement des jetons dans chaque colonne, certaines lignes comptabilisent jusqu’à trois jetons alors que d’autres lignes n’en n’ont aucun. C'est normal.


■ § 4. Algorigramme pour renseigner un Tableau en deux dimensions (Matrice)

Les variables

ÉLÉMENT_MATRICIE	= Élément Matriciel correspondant à une cellule du 1er tableau Excel
NB_COLONNES	= Nombre de Colonnes (5)
NB_JETONS	= Nombre de Jetons (Pourcentage : 50, 30, 10, 7, 3)
CTR_JETONS	= Compteur_Jetons
I_LIGNE	= Index Ligne
I_COLONNE	= Index Colonne
I_INTERVALLE	= Index Intervalle

L'algorigramme

                     ┌───────────────────────────────────────────────────────┐
              D_PROG │ NB_COLONNES                     = 5                   │
                     │ I_COLONNE                       = 0                   │
                     └───────────────────────────┬───────────────────────────┘
                                                 │◄──────────────────────────────────────┐
                     ┌───────────────────────────┴───────────────────────────┐           │
           D_COLONNE │ 100 – NB% (ex. : NB% = 50)      = Cellules_Vides      │           │
                     │ Cellules_Vides / NB%            = Cellules_Intervalle │           │
                     │ Cellules_Intervalle * (NB% - 1) = Total_Intervalles   │           │
                     │ NB% + Total_intervalles         = Cellules_Début-Fin  │           │
                     │ 100 – Cellules_Début-Fin        = Cellules_Après      │           │
                     │ Cellules_restantes / 2          = Cellules_Avant      │           │
                     ├───────────────────────────────────────────────────────┤           │
                     │ I_COLONNE                       = I-COLONNE + 1       │           │
                     │ I_LIGNE                         = 0                   │           │
                     │ CTR_JETONS                      = 0                   │           │
                     └───────────────────────────┬───────────────────────────┘           │
                                                 │◄──────────────────────────────┐       │
                     ┌───────────────────────────┴───────────────────────────┐   │       │
             T_AVANT │                  I_LIGNE = I_LIGNE + 1                │   │       │
                     │                  I_LIGNE :: Cellules_Avant            │   │       │
                     └───────────────────────────┬───────────────────────────┘ < │       │
                                                 ●───────────────────────────────┘       │
                                                 │◄──────────────────────────────────┐   │
                     ┌───────────────────────────┴───────────────────────────┐       │   │
             D_JETON │ ÉLÉMENT_MATRICIEL (I_LIGNE, I_COLONNE) = "1"          │       │   │
                     │               CTR_JETONS = CTR_JETONS + 1             │       │   │
                     │             I_INTERVALLE = 0                          │       │   │
                     └───────────────────────────┬───────────────────────────┘       │   │
                                                 │◄──────────────────────────────┐   │   │
                     ┌───────────────────────────┴───────────────────────────┐   │   │   │
        T_INTERVALLE │                  I_LIGNE = I_LIGNE + 1                │   │   │   │
                     │             I_INTERVALLE = I_INTERVALLE + 1           │   │   │   │
                     │             I_INTERVALLE :: Cellules_Intervalle       │   │   │   │
                     └───────────────────────────┬───────────────────────────┘ < │   │   │
                                                 ●───────────────────────────────┘   │   │
                     ┌───────────────────────────┴───────────────────────────┐       │   │
             F_JETON │               CTR_JETONS :: (NB_JETONS – 1)           │       │   │
                     └───────────────────────────┬───────────────────────────┘ <     │   │
                                                 ●───────────────────────────────────┘   │
                     ┌───────────────────────────┴───────────────────────────┐           │
           F_COLONNE │ ÉLÉMENT_MATRICIEL (I_LIGNE, I_COLONNE) = "1"          │           │
                     │                I_COLONNE :: NB_COLONNES               │           │
                     └───────────────────────────┬───────────────────────────┘ <         │
                                                 ●───────────────────────────────────────┘
                     ┌───────────────────────────┴───────────────────────────┐
              F_PROG │                          Ø                            │
                     └───────────────────────────────────────────────────────┘

■ § 5. Algorigramme pour créer la playlist depuis une matrice

Il suffit de lire chaque ligne de la matrice de la gauche vers la droite en parcourant la matrice verticalement de la première ligne à la dernière et de reporter chronologiquement chaque jeton (son libellé ou son code) dans la playlist.

Les variables de la Matrice (100 lignes x 5 colonnes)

ÉLÉMENT_MATRICIEL	= Élément Matriciel
I_LIGNE	= Index Ligne
K_LIGNE	= Index Borne Ligne
I_COLONNE	= Index Colonne
K_COLONNE	= Index Borne Colonne (5)
JETON	= Couleur du jeton ("V", "R", "B", "J", "N")

Les variables de la Table Playlist (100 lignes)

I_PLAYLIST

= Index Playlist

L'Algorigramme

                     ┌───────────────────────────────────────────────────────┐
              D_PROG │                   I_LIGNE = 0                         │
                     │                   K_LIGNE = 100                       │
                     │                 I_COLONNE = 0                         │
                     │                 K_COLONNE = 5                         │
                     │                I_PLAYLIST = 0                         │
                     └───────────────────────────┬───────────────────────────┘
                                                 │◄────────────────────────────────────┐
                     ┌───────────────────────────┴───────────────────────────┐         │
             D_LIGNE │                   I_LIGNE = I_LIGNE + 1               │         │
                     │                 I_COLONNE = 0                         │         │
                     │                     JETON = ""                        │         │
                     └───────────────────────────┬───────────────────────────┘         │
                                                 │◄───────────────────────────────┐    │
                     ┌───────────────────────────┴───────────────────────────┐    │    │
           D_COLONNE │                 I_COLONNE = I_COLONNE + 1             │    │    │
                     │                 I_COLONNE :: 1                        │    │    │
                     └───────────────────────────┬───────────────────────────┘    │    │
                             NULL ┌──────────────●──────────────┐ =               │    │
                     ┌────────────┴────────────┐   ┌────────────┴────────────┐    │    │
                     │            Ø            │   │      JETON = "V"        │    │    │
                     └────────────┬────────────┘   └────────────┬────────────┘    │    │
                                  └──────────────┬──────────────┘                 │    │
                     ┌───────────────────────────┴───────────────────────────┐    │    │
                     │                 I_COLONNE :: 2                        │    │    │
                     └───────────────────────────┬───────────────────────────┘    │    │
                             NULL ┌──────────────●──────────────┐ =               │    │
                     ┌────────────┴────────────┐   ┌────────────┴────────────┐    │    │
                     │            Ø            │   │      JETON = "R"        │    │    │
                     └────────────┬────────────┘   └────────────┬────────────┘    │    │
                                  └──────────────┬──────────────┘                 │    │
                     ┌───────────────────────────┴───────────────────────────┐    │    │
                     │                 I_COLONNE :: 3                        │    │    │
                     └───────────────────────────┬───────────────────────────┘    │    │
                             NULL ┌──────────────●──────────────┐ =               │    │
                     ┌────────────┴────────────┐   ┌────────────┴────────────┐    │    │
                     │            Ø            │   │      JETON = "B"        │    │    │
                     └────────────┬────────────┘   └────────────┬────────────┘    │    │
                                  └──────────────┬──────────────┘                 │    │
                     ┌───────────────────────────┴───────────────────────────┐    │    │
                     │                 I_COLONNE :: 4                        │    │    │
                     └───────────────────────────┬───────────────────────────┘    │    │
                             NULL ┌──────────────●──────────────┐ =               │    │
                     ┌────────────┴────────────┐   ┌────────────┴────────────┐    │    │
                     │            Ø            │   │      JETON = "J"        │    │    │
                     └────────────┬────────────┘   └────────────┬────────────┘    │    │
                                  └──────────────┬──────────────┘                 │    │
                     ┌───────────────────────────┴───────────────────────────┐    │    │
                     │                 I_COLONNE :: 5                        │    │    │
                     └───────────────────────────┬───────────────────────────┘    │    │
                             NULL ┌──────────────●──────────────┐ =               │    │
                     ┌────────────┴────────────┐   ┌────────────┴────────────┐    │    │
                     │            Ø            │   │      JETON = "N"        │    │    │
                     └────────────┬────────────┘   └────────────┬────────────┘    │    │
                                  └──────────────┬──────────────┘                 │    │
                     ┌───────────────────────────┴───────────────────────────┐    │    │
                     │ ÉLÉMENT_MATRICIEL (I_LIGNE, I_COLONNE) :: "1"         │    │    │
                     └───────────────────────────┬───────────────────────────┘    │    │
                             NULL ┌──────────────●──────────────┐ =               │    │
                     ┌────────────┴────────────┐   ┌────────────┴────────────┐    │    │
 T_ELEMENT_MATRICIEL │                         │   │ I_PLAYLIST = I_PLAYLIST │    │    │
                     │            Ø            │   │            + 1          │    │    │
                     │                         │   │ Print I_PLAYLIST, " = ",│    │    │
                     │                         │   │       JETON             │    │    │
                     └────────────┬────────────┘   └────────────┬────────────┘    │    │
                                  └──────────────┬──────────────┘                 │    │
                     ┌───────────────────────────┴───────────────────────────┐    │    │
           F_COLONNE │                 I_COLONNE :: K_COLONNE                │    │    │
                     └───────────────────────────┬───────────────────────────┘ <  │    │
                                                 ●────────────────────────────────┘    │
                     ┌───────────────────────────┴───────────────────────────┐         │
             F_LIGNE │                   I_LIGNE :: K_LIGNE                  │         │
                     └───────────────────────────┬───────────────────────────┘ <       │
                                                 ●─────────────────────────────────────┘
                     ┌───────────────────────────┴───────────────────────────┐
              F_PROG │                          Ø                            │
                     └───────────────────────────────────────────────────────┘

■ § 6. Algorigramme pour créer une table "couleur" BDD

Le programme doit être exécuté pour chaque couleur. Les 5 tables couleurs étant créées, il reste à concaténer ces 5 tables en une seule via des requêtes SQL. Chaque table doit être constituée de tous les N° de ligne avec ou sans jeton.

Cette table unique pourra être traitée comme le tableau en deux dimensions pour réaliser une liste séquentielle des jetons de couleurs.

Création de la table t_couleur

Après création de cette table pour une couleur, une requête SQL copie t_couleur.j_couleur dans l’attribut correspondant de la table t_jetons (
j_vert, j_rouge, j_bleu, j_jaune ou j_noir).

{ t_couleur (table couleur) ---------------------------------------------------}

create table t_couleur
(
n_ligne         integer  not null,
j_couleur       char(1)
) ;

{------------------------------------------------------------------------------}

Les variables

JETON	= Couleur du jeton ("V", "R", "B", "J", "N")
NB_JETON	= Nombre de Jetons (Pourcentage : 50, 30, 10, 7, 3)
CTR_JETON	Compteur_Jetons
I_LIGNE	= Index Ligne
I_COLONNE	= Index Colonne
I_INTERVALLE	= Index Intervalle
SÉPARATEUR	= "ǀ" (pipe)

La requête SQL pour la couleur verte

{------------------------------------------------------------------------------}

update t_jetons
set t_jetons.j_vert = (select t_couleur.j_couleur
from t_couleur
where t_couleur.ligne = t_jetons.ligne)
where t_couleur.ligne = t_jetons.ligne ;

{------------------------------------------------------------------------------}

L'Algorigramme

                     ┌───────────────────────────────────────────────────────┐
              D_PROG │ 100 – NB% (ex. : NB% = 50)      = Cellules_Vides      │
                     │ Cellules_Vides / NB%            = Cellules_Intervalle │
                     │ Cellules_Intervalle * (NB% - 1) = Total_Intervalles   │
                     │ NB% + Total_intervalles         = Cellules_Début-Fin  │
                     │ 100 – Cellules_Début-Fin        = Cellules_Après      │
                     │ Cellules_restantes / 2          = Cellules_Avant      │
                     ├───────────────────────────────────────────────────────┤
                     │ JETON                           = V, R, B, J, ou N    │
                     │ NB_JETONS                       = 50, 30 10, 7, 3     │
                     │ CTR_JETONS                      = 0                   │
                     │ I_LIGNE                         = 1                   │
                     └───────────────────────────┬───────────────────────────┘
                                                 │◄───────────────────────────────┐
                     ┌───────────────────────────┴───────────────────────────┐    │
             D_LIGNE │                  I_LIGNE = I_LIGNE + 1                │    │
                     │                  I_LIGNE :: Cellules_Avant            │    │  
                     └───────────────────────────┬───────────────────────────┘    │
                                  ┌──────────────●──────────────┐                 │
                     ┌────────────┴────────────┐   ┌────────────┴────────────┐    │
             T_AVANT │            Ø            │   │ PRINT I_LIGNE, "ǀǀ"     │    │
                     └────────────┬────────────┘   └────────────┬────────────┘    │
                                  └──────────────┬──────────────┘                 │
                     ┌───────────────────────────┴───────────────────────────┐    │
                     │                   I_LIGNE :: Cellules_Avant           │    │
                     └───────────────────────────┬───────────────────────────┘ <  │
                                                 ●────────────────────────────────┘
                                                 │◄──────────────────────────────────┐
                     ┌───────────────────────────┴───────────────────────────┐       │
             T_JETON │        PRINT I_LIGNE, "ǀ", "JETON", "ǀ"               │       │
                     │               CTR_JETONS = CTR_JETONS + 1             │       │
                     │              I_INTERVALLE = 0                         │       │
                     └───────────────────────────┬───────────────────────────┘       │
                                                 │◄──────────────────────────────┐   │
                     ┌───────────────────────────┴───────────────────────────┐   │   │
        T_INTERVALLE │             PRINT I_LIGNE, "ǀ", "ǀ"                   │   │   │
                     │              I_INTERVALLE = I_INTERVALLE + 1          │   │   │
                     │              I_INTERVALLE :: Cellules_Intervalle      │   │   │
                     └───────────────────────────┬───────────────────────────┘ < │   │
                                                 ●───────────────────────────────┘   │
                     ┌───────────────────────────┴───────────────────────────┐       │
             F_JETON │               CTR_JETONS :: (NB_JETONS – 1)           │       │
                     └───────────────────────────┬───────────────────────────┘ <     │
                                                 ●───────────────────────────────────┘
                     ┌───────────────────────────┴──────────────────────────┐
               INTER │             PRINT I_LIGNE, "ǀ", JETON, "ǀ"           │
                     └───────────────────────────┬──────────────────────────┘
                                                 │◄──────────────────────────────┐
                     ┌───────────────────────────┴───────────────────────────┐   │
             D_APRES │                  I_LIGNE = I_LIGNE + 1                │   │
                     │                  I_LIGNE :: NB_LIGNES                 │   │
                     └───────────────────────────┬───────────────────────────┘   │
                                = ┌──────────────●──────────────┐ <              │
                     ┌────────────┴────────────┐   ┌────────────┴────────────┐   │
             T_APRES │            Ø            │   │ PRINT I_LIGNE, "ǀ", "ǀ" │   │
                     └────────────┬────────────┘   └────────────┬────────────┘   │
                                  └──────────────┬──────────────┘                │
                     ┌───────────────────────────┴───────────────────────────┐   │
             F_APRES │                   I_LIGNE :: NB_LIGNES                │   │
                     └───────────────────────────┬───────────────────────────┘ < │
                                                 ●───────────────────────────────┘
                     ┌───────────────────────────┴───────────────────────────┐
              F_PROG │                          Ø                            │
                     └───────────────────────────────────────────────────────┘

■ § 7. Algorigramme pour créer la playlist depuis une table BDD

Il suffit de lire chaque item de la table BDD (t_jetons), de tester chaque attribut (j_vert, j_rouge, j_bleu, j_jaune, j_noir) et de reporter chronologiquement chaque jeton dans la playlist.

Création de la table t_jetons

{ t_jetons (table jetons) -----------------------------------------------------}


create table t_jetons
(
n_ligne         integer  not null,
j_vert          char(1),
j_rouge         char(1),
j_bleu          char(1),
j_jaune         char(1),
j_noir          char(1)
) ;

{------------------------------------------------------------------------------}

Les variables de la Table t_jetons (100 items)

T_JETONS	= Table des Jetons
I_LIGNE	= Index Ligne
K_LIGN	= Index Playlist

Les variables de la Table Playlist (100 lignes)

I_PLAYLIST

= Index Playlist

L'Algorigramme

                     ┌───────────────────────────────────────────────────────┐
              D_PROG │                   I_LIGNE = 0                         │
                     │                   K_LIGNE = 100                       │
                     │                I_PLAYLIST = 0                         │
                     └───────────────────────────┬───────────────────────────┘
                                                 │◄────────────────────────────────────┐
                     ┌───────────────────────────┴───────────────────────────┐         │
              D_ITEM │                   I_LIGNE = I_LIGNE + 1               │         │
                     └───────────────────────────┬───────────────────────────┘         │
                ┌────────────────────────────────┼────────────────────────────────┐    │
                │    ┌───────────────────────────┴───────────────────────────┐    │    │
         T_ITEM │    │                    j_vert :: "V"                      │    │    │
                │    └───────────────────────────┬───────────────────────────┘    │    │
                │            NULL ┌──────────────●──────────────┐ =               │    │
                │    ┌────────────┴────────────┐   ┌────────────┴────────────┐    │    │
                │    │                         │   │ I_PLAYLIST = I_PLAYLIST │    │    │
                │    │            Ø            │   │            + 1          │    │    │
                │    │                         │   │ Print I_PLAYLIST, "ǀBǀ" │    │    │
                │    └────────────┬────────────┘   └────────────┬────────────┘    │    │
                │                 └──────────────┬──────────────┘                 │    │
                │    ┌───────────────────────────┴───────────────────────────┐    │    │
                │    │                   j_rouge :: "R"                      │    │    │
                │    └───────────────────────────┬───────────────────────────┘    │    │
                │            NULL ┌──────────────●──────────────┐ =               │    │
                │    ┌────────────┴────────────┐   ┌────────────┴────────────┐    │    │
                │    │                         │   │ I_PLAYLIST = I_PLAYLIST │    │    │
                │    │            Ø            │   │            + 1          │    │    │
                │    │                         │   │ Print I_PLAYLIST, "ǀRǀ" │    │    │
                │    └────────────┬────────────┘   └────────────┬────────────┘    │    │
                │                 └──────────────┬──────────────┘                 │    │
                │    ┌───────────────────────────┴───────────────────────────┐    │    │
                │    │                    j_bleu :: "B"                      │    │    │
                │    └───────────────────────────┬───────────────────────────┘    │    │
                │            NULL ┌──────────────●──────────────┐ =               │    │
                │    ┌────────────┴────────────┐   ┌────────────┴────────────┐    │    │
                │    │                         │   │ I_PLAYLIST = I_PLAYLIST │    │    │
                │    │            Ø            │   │            + 1          │    │    │
                │    │                         │   │ Print I_PLAYLIST, "ǀBǀ" │    │    │
                │    └────────────┬────────────┘   └────────────┬────────────┘    │    │
                │                 └──────────────┬──────────────┘                 │    │
                │    ┌───────────────────────────┴───────────────────────────┐    │    │
                │    │                   j_jaune :: "J"                      │    │    │
                │    └───────────────────────────┬───────────────────────────┘    │    │
                │            NULL ┌──────────────●──────────────┐ =               │    │
                │    ┌────────────┴────────────┐   ┌────────────┴────────────┐    │    │
                │    │                         │   │ I_PLAYLIST = I_PLAYLIST │    │    │
                │    │            Ø            │   │            + 1          │    │    │
                │    │                         │   │ Print I_PLAYLIST, "ǀJǀ" │    │    │
                │    └────────────┬────────────┘   └────────────┬────────────┘    │    │
                │                 └──────────────┬──────────────┘                 │    │
                │    ┌───────────────────────────┴───────────────────────────┐    │    │
                │    │                    j_noir :: "N"                      │    │    │
                │    └───────────────────────────┬───────────────────────────┘    │    │
                │            NULL ┌──────────────●──────────────┐ =               │    │
                │    ┌────────────┴────────────┐   ┌────────────┴────────────┐    │    │
                │    │                         │   │ I_PLAYLIST = I_PLAYLIST │    │    │
                │    │            Ø            │   │            + 1          │    │    │
                │    │                         │   │ Print I_PLAYLIST, "ǀNǀ" │    │    │
                │    └────────────┬────────────┘   └────────────┬────────────┘    │    │
                │                 └──────────────┬──────────────┘                 │    │
                └────────────────────────────────┼────────────────────────────────┘    │
                     ┌───────────────────────────┴───────────────────────────┐         │
              F_ITEM │                   I_LIGNE :: K_LIGNE                  │         │
                     └───────────────────────────┬───────────────────────────┘ <       │
                                                 ●─────────────────────────────────────┘
                     ┌───────────────────────────┴───────────────────────────┐
              F_PROG │                          Ø                            │
                     └───────────────────────────────────────────────────────┘

---

■ § 8. Conclusion

Je ne sais pas si ma proposition matricielle est réalisable mais j’aime bien ma solution BDD.

Ma simulation avec Excel n’est pas mal non plus. Elle est même suffisante, non ?

En fait, je voulais savoir s’il était possible d’ajouter un message à une discussion fermée.

Vous pouvez retrouver ce message sous forme d’un billet dans mon blog logique...

ALGORITHMIQUE

Bisous…

---