Cherche algorithme classement ???

"LE TROLL" <le troll@enfer.fr> a écrit dans le message de
news:uKZ20UF7GHA.2120@TK2MSFTNGP03.phx.gbl...

Bonjour,

Je cherche un algorithme de classement, car ce que je trouve va faire
long, alors tout idée sera bien venue:

Enoncé:
J'ai 5 list de cartes : list2(1) à list2(5) contenant chacune une couleur
d'un jeu de tarot, soit
list2(1) = atout = a
list2(2) = coeur = c
list2(3) = karreau = k
list2(4) = Pique = p
list2(5) = Trèfle = t
Pour mémoire le total des 5 list fait 18 cartes, chaque couleur à 14

cartes,

sauf l'atout qui en a 22...
Que j'ai résumé dans une chaine ch, comme suit
Si la list est vide: ch = ch & "0"
Si la liste n'est pas vide: ch = ch & "1"
Nous avons donc 5 chiffre (pour les 5 list des 5 couleurs du Tarot à

jouer),

soit des 1 soit des 0
Normalement on aura "11111", mais au pire, on ne peut avoir que des atouts
pas exemple "10000"

Problème:
Classer dans un autres list générale list1(4) de 18 cartes, ces 5 list
sus-citées de telle façon que les couleurs des cartes soient intercalées
(rouge/noir), et à défaut (rouge/atout), (noir/atout), et inversement,

sauf

à ne pas pouvoir...

Alors ce que j'ai trouvé pour le moment, c'est de mettre chaque

possibilité,

mais c'est assez laborieux, comme ça:
si ch = "11111"...
si ch = "11110"...
si ch = "11101"... "110111"... 10111... 01111... 11100... 11010...
Plus le traitement derrière des list suivant la couleur qu'elle
contiennent...
Par exemple si j'ai ch="11111" (cas probable de 5 couleur distribuées), je
vais faire:

list2(4).clear
if ch = "11111" then
for j = 1 to 5
k=1 ' atout = a
for i = 0 to list2(k).listcount-1
if list2(j).listcount < 1 then exit for
list2(4).additem list2(k).list(i)
next i
if k = 1 then k = 3 ' k
if k = 3 then k = 4 ' p
if k = 4 then k = 2 ' c
if k = 2 then k = 5 ' t
next j
endif

Mais il faut que je fasse ça pour chaque combinaison possible afin
d'adapter, si par exemple il n'y a pas d'atout (a) = "01111", dans ce cas

le

traitement sera différent, etc...

Je pense à une renumérotation pour le classement, ajouant devant chaque
carte (exp : "a22" = atout n°22), lui donner sa valeur absolue = 78, soit
"78a22", ainsi peut être une solution, je vais voir...

Avez-vous un algorithme à me proposer qui m'évite de mettre chaque

condition

???

nb: le code peut être joint...

Si j'ai bien compris tu voudrais simuler le comportement d'un joueur quand
il classe ses cartes en début de partie, et éventullement en cours de partie
s'il s'est défaussé d'une couleur ? (exemple: il a classé Atout, Pique,
Coeur, Trèfle, Carreau et il vient de jouer son dernier Trèfle et passe donc
ses Carreaux à gauche des Atouts pour ne pas les confondre avec les Coeurs)
?

Je crois que c'est le moment d'apprendre à utiliser les classes
utilisateur - cela te simplifiera la vie énormement.
En effet il suffit de créer une classe "Main" qui sera utilisé pour les 3 à
5 mains en jeu.
Chaque classe main sera composé de 4 fois une sous-classe "Couleur" et une
sous-classe "Atout"
Les sous-classes "Couleur" pourraient avoir des propriétés "Type" (Carreau,
Trèfle etc.), "Color" (Noir, Rouge), "Compte" (évident) et "Existe(1 à 14)";
et des mèthodes "Ajouter" (pendant la distribution et pour l'ajout du chien)
et "Jouer" (pendant le jeu).
On pourrait aussi ajouter des propriétés (en lecture seule) de "CompteTetes"
et "PointsTetes"
La sous-classe "Atout" serait sensiblement identique, mais avec peut-être
"CompteBouts" et "Petit", "Excuse", "VingtEtUn"

La classe Main comprend ces 5 sous-classe et expose leur propriétés et
methodes. En plus il a une propriéte "OrdreTri" qui déterminera l'ordre
d'affichage des couleurs (style 12534 ou 5 est l'atout).
On crée aussi une propriété "OrdreCouleurs" qui reprend l'indice de
OrdreTri et la propriéte "OrdreColor" (en ignorant les couleurs dont le
compte est 0) et qui sortira une chaine du style "rnarn" (rouge, noir,
Atout, Rouge, noir, avec 0 s'il n'y en a pas). Ensuite il suffit d'interoger
cette chaine pour s'assurer qu'elle ne contient ni "rr", ni "nn", ni "r0r",
ni "n0n".

Pour posser encore plus loin les classes, on pourra créer une classe Joueur
qui contient sa classe "Main" avec ses classes "couleurs" et "atout".
Chaque joueur aurait son nom, sa position devant la table, des infos sur
s'il a pris, son enchère, ses points, etc.
Comme ça le tri des mains (et toutes les autres opérations) devient, pour
ansi dire, un jeu d'enfant.
Comme ceci
'Tri des mains
For each joueur in joueurs
if instr(Joueur.Main.OrdreColor,"nn") > 0 or
instr(Joueur.OrdreColor,"rr") etc. then
OrdreCourant=Joueur.Main.OrdreTri
'Change l'odre de tri selon les règles suivantes
'Si rr ou nn ou r0r, ou n0n en début ou fin de chaine, prendre le
1er ou dernier OrdreCourant et le mettre en dernier ou en 1er
'Si rr ou nn etc. en milieu de chaine, mettre les atouts entre les
deux
Joueur.Main.OrdreTri=OrdreCourant
endif
next Joueur

'Exemple pour les annonces
For each joueur in joueurs
if Joueur.Main.Atouts.Compte = 1 AND Joueur.Main.Atouts.Petit Then
msgbox "Petit Sec chez " & Joueur.Nom
if Joueur.Main.Carreaux.CompteTetes = 0 AND
Joueur.Main.Trefle.CompteTetes = 0 etc. Then msgbox "Blanc de tetes"
if Joueur.Main.Atouts.Compte >= 10 AND NombredeJoueurs= 4 Then MsgBox
"Simple Poignée"
etc.
Next Joueur


Bon courage
Clive

Merci :o)

Tu as bien compris le problème, mais moi je n'ai rien compris à tes
explications, j'ai rarement utilisé des classes dans la mesure ou vb permet
de les ignorer, alors je cherche davantage un algorithme sur ma base
(connaissance du contenu vide ou non vide d'une liste et sa couleur,
immuable d'ailleurs, toujours dans la même liste)...

Sinon, je ne vais pas trop loin, car les prévisions conséquentes ne
fonctionnent jamais comme prévu... Pour les autres joueurs je n'ai nul
besoin de ça, on ne voit pas leurs cartes, alors je gère avec leur liste,
par exemple, chaque joueur à sa liste, s'il joue ça sort de sa liste pour
aller sur la liste de la table de jeu, qui ira dans la liste du camps qui
remporte, etc... Juste de vagues prévisions, j'en suis au classement entre
couleurs...

--
Site éditeur MES ROMANS édités
http://www.manuscritdepot.com/a.joseph-attila-pusztay.1.htm
Site de MES LOGICIELS
http://irolog.free.fr
mon adresse EMail
http://irolog.free.fr/ecrire/index.htm
------------------------------------------------------------------------------------
"Clive Lumb" <clumb2@gratuit_en_anglais.fr.invalid> a écrit dans le message
de news: OdnfoCI7GHA.756@TK2MSFTNGP05.phx.gbl...

"LE TROLL" <le troll@enfer.fr> a écrit dans le message de
news:uKZ20UF7GHA.2120@TK2MSFTNGP03.phx.gbl...

Bonjour,

Je cherche un algorithme de classement, car ce que je trouve va faire
long, alors tout idée sera bien venue:

Enoncé:
J'ai 5 list de cartes : list2(1) à list2(5) contenant chacune une couleur
d'un jeu de tarot, soit
list2(1) = atout = a
list2(2) = coeur = c
list2(3) = karreau = k
list2(4) = Pique = p
list2(5) = Trèfle = t
Pour mémoire le total des 5 list fait 18 cartes, chaque couleur à 14

cartes,

sauf l'atout qui en a 22...
Que j'ai résumé dans une chaine ch, comme suit
Si la list est vide: ch = ch & "0"
Si la liste n'est pas vide: ch = ch & "1"
Nous avons donc 5 chiffre (pour les 5 list des 5 couleurs du Tarot à

jouer),

soit des 1 soit des 0
Normalement on aura "11111", mais au pire, on ne peut avoir que des
atouts
pas exemple "10000"

Problème:
Classer dans un autres list générale list1(4) de 18 cartes, ces 5 list
sus-citées de telle façon que les couleurs des cartes soient intercalées
(rouge/noir), et à défaut (rouge/atout), (noir/atout), et inversement,

sauf

à ne pas pouvoir...

Alors ce que j'ai trouvé pour le moment, c'est de mettre chaque

possibilité,

mais c'est assez laborieux, comme ça:
si ch = "11111"...
si ch = "11110"...
si ch = "11101"... "110111"... 10111... 01111... 11100... 11010...
Plus le traitement derrière des list suivant la couleur qu'elle
contiennent...
Par exemple si j'ai ch="11111" (cas probable de 5 couleur distribuées),
je
vais faire:

list2(4).clear
if ch = "11111" then
for j = 1 to 5
k=1 ' atout = a
for i = 0 to list2(k).listcount-1
if list2(j).listcount < 1 then exit for
list2(4).additem list2(k).list(i)
next i
if k = 1 then k = 3 ' k
if k = 3 then k = 4 ' p
if k = 4 then k = 2 ' c
if k = 2 then k = 5 ' t
next j
endif

Mais il faut que je fasse ça pour chaque combinaison possible afin
d'adapter, si par exemple il n'y a pas d'atout (a) = "01111", dans ce cas

le

traitement sera différent, etc...

Je pense à une renumérotation pour le classement, ajouant devant chaque
carte (exp : "a22" = atout n°22), lui donner sa valeur absolue = 78, soit
"78a22", ainsi peut être une solution, je vais voir...

Avez-vous un algorithme à me proposer qui m'évite de mettre chaque

condition

???

nb: le code peut être joint...

Si j'ai bien compris tu voudrais simuler le comportement d'un joueur quand
il classe ses cartes en début de partie, et éventullement en cours de
partie
s'il s'est défaussé d'une couleur ? (exemple: il a classé Atout, Pique,
Coeur, Trèfle, Carreau et il vient de jouer son dernier Trèfle et passe
donc
ses Carreaux à gauche des Atouts pour ne pas les confondre avec les
Coeurs)
?

Je crois que c'est le moment d'apprendre à utiliser les classes
utilisateur - cela te simplifiera la vie énormement.
En effet il suffit de créer une classe "Main" qui sera utilisé pour les 3
à
5 mains en jeu.
Chaque classe main sera composé de 4 fois une sous-classe "Couleur" et une
sous-classe "Atout"
Les sous-classes "Couleur" pourraient avoir des propriétés "Type"
(Carreau,
Trèfle etc.), "Color" (Noir, Rouge), "Compte" (évident) et "Existe(1 à
14)";
et des mèthodes "Ajouter" (pendant la distribution et pour l'ajout du
chien)
et "Jouer" (pendant le jeu).
On pourrait aussi ajouter des propriétés (en lecture seule) de
"CompteTetes"
et "PointsTetes"
La sous-classe "Atout" serait sensiblement identique, mais avec peut-être
"CompteBouts" et "Petit", "Excuse", "VingtEtUn"

La classe Main comprend ces 5 sous-classe et expose leur propriétés et
methodes. En plus il a une propriéte "OrdreTri" qui déterminera l'ordre
d'affichage des couleurs (style 12534 ou 5 est l'atout).
On crée aussi une propriété "OrdreCouleurs" qui reprend l'indice de
OrdreTri et la propriéte "OrdreColor" (en ignorant les couleurs dont le
compte est 0) et qui sortira une chaine du style "rnarn" (rouge, noir,
Atout, Rouge, noir, avec 0 s'il n'y en a pas). Ensuite il suffit
d'interoger
cette chaine pour s'assurer qu'elle ne contient ni "rr", ni "nn", ni
"r0r",
ni "n0n".

Pour posser encore plus loin les classes, on pourra créer une classe
Joueur
qui contient sa classe "Main" avec ses classes "couleurs" et "atout".
Chaque joueur aurait son nom, sa position devant la table, des infos sur
s'il a pris, son enchère, ses points, etc.
Comme ça le tri des mains (et toutes les autres opérations) devient, pour
ansi dire, un jeu d'enfant.
Comme ceci
'Tri des mains
For each joueur in joueurs
if instr(Joueur.Main.OrdreColor,"nn") > 0 or
instr(Joueur.OrdreColor,"rr") etc. then
OrdreCourant=Joueur.Main.OrdreTri
'Change l'odre de tri selon les règles suivantes
'Si rr ou nn ou r0r, ou n0n en début ou fin de chaine, prendre le
1er ou dernier OrdreCourant et le mettre en dernier ou en 1er
'Si rr ou nn etc. en milieu de chaine, mettre les atouts entre les
deux
Joueur.Main.OrdreTri=OrdreCourant
endif
next Joueur

'Exemple pour les annonces
For each joueur in joueurs
if Joueur.Main.Atouts.Compte = 1 AND Joueur.Main.Atouts.Petit Then
msgbox "Petit Sec chez " & Joueur.Nom
if Joueur.Main.Carreaux.CompteTetes = 0 AND
Joueur.Main.Trefle.CompteTetes = 0 etc. Then msgbox "Blanc de tetes"
if Joueur.Main.Atouts.Compte >= 10 AND NombredeJoueurs= 4 Then MsgBox
"Simple Poignée"
etc.
Next Joueur


Bon courage
Clive

LE TROLL wrote:

Merci :o)

Tu as bien compris le problème, mais moi je n'ai rien compris à tes
explications, j'ai rarement utilisé des classes dans la mesure ou vb
permet de les ignorer, alors je cherche davantage un algorithme sur
ma base (connaissance du contenu vide ou non vide d'une liste et sa
couleur, immuable d'ailleurs, toujours dans la même liste)...

Sinon, je ne vais pas trop loin, car les prévisions conséquentes ne
fonctionnent jamais comme prévu... Pour les autres joueurs je n'ai nul
besoin de ça, on ne voit pas leurs cartes, alors je gère avec leur
liste, par exemple, chaque joueur à sa liste, s'il joue ça sort de sa
liste pour aller sur la liste de la table de jeu, qui ira dans la
liste du camps qui remporte, etc... Juste de vagues prévisions, j'en
suis au classement entre couleurs...

Franchement tu devrais te lancer dans l'utilisation des classes.
C'est surtout utile quand tu as des instance multiples d'objets semblables
sur lequels tu veux faire des manipulations complexes.

Imaginons que tu voudrais créer un jeu de course de voitures.
Chaque voiture a sa puissance, poids, tenue de route, dommages, couleur etc.
Quand on appuie sur le pédale (de frein ou accelerateur) tu as écrit un
super algo qui calcule l'accéleration/déceleration.
Pour chaque voiture il faut donc aller chercher poids, puissance etc. dans
une matrice où il faut se souvenir que la ligne 4 est la Subaru Impreza et
que la colonne 6 est son poids, la 7 sa puissance etc. Ensuite tu dois
passer ces valeurs a ton algo.

Si par contre tu crées une classe Voiture qui contient tous ces données (un
peu comme un type défini par l'utilisateur) c'est déjà plus facile.
Si en plus tu mets ton algo sans la classe ça devient fastoche, car au lieu
de devoir rappeler les valeurs précedentes, faire le calcul, sauver les
nouvelles valeurs etc., il suffit de modifier la propriété de la classe qui
déclenche l'algo (par exemple position de l'accelerateur).

Un autre exemple (qui est en effet un contrôle utilisateur - c'est un
classe).
Tu voudrais créer un afficheur LCD style calculette.
Chaque chiffre de l'afficheur est indentique car il comporte 7 segments et
la virgule, qui peuvent être allumés ou pas.
Donc tu commencce par créer une classe "chiffre". Dedans tu as tous ce qu'il
faut pour dessiner les segments, les allumer etc.
Ensuite tu ajoutes une propriété "valeur" qui peut aller de 0 à 9. "virgule"
qui est booleen, "allumé" booleen aussi.
Dans le code derriere cette valeur (propriété "let") tu as tous les "select
case" pour les valeurs possibles qui allument ou eteignent les segments.
Donc pour changer ce qui est affiché, il suffit de faire chiffre.valeur=7
Tu pourras ensuite créer une collection de ces chiffres, ou un groupe de
contrôles.
Ensuite tu fais une classe qui contient ces chiffres, c'est ton afficheur.


Je t'assure que cela permet de créer du code beaucoup plus compacte, et
surtout beaucoup plus facile à dépanner et comprendre.

Clive

Pour classer des jeux de bridge j'ai numéroté les cartes de 0 à 51. Chaque
carte est représentée par un entier et réciproquement. Une main contient 13
entiers et il est facile de les trier par ordre croissant ou décroissant.
On connaît facilement la couleur et le rang de la carte au moyen des
opérations Modulo et Division entière.
Peut-être l'idée peut-elle te servir.