Récuperation du nombre de points dans un tableau à partir de suites

Bonjour,

Voilà l'algorithme demandé:
j ai des valeurs au hasard comprises dans un tableau de taille 9 qui sont compris chacune entre 0 et 8. Une suite de nombre peut etre de 1 ou 2 ou 3 ou 4 ou 5 ou 6 ou 7 ou 8 ou 9:
par exemple 0 1 2 3 4 5 6 7 8 9 est une suite de 9.
Et là il y a uns suite de 7 et deux de 1 : 0 3 2 1 4 5 3 6 5 car 0 1 2 3 4 5 6 est une suite de 7 et 5 une suite de 1 et 3 une suite de 1
puis faire le calcul de points a partir de : Suite de 1=1 de 2=3 de 3=7 de 4=13 de 5=21 de 6=30 de 7=40 de 8=50 de 9=60

j'ai tenté de recupérer le nombre de fois qu'un nombre apparait pour determiner le nombre de suite mais je me suis perdu par la suite.

Tu devrais te relire en imaginant ne pas avoir d'autres informations que ce que tu écris. Te rends-tu compte à quel point ton explication est incompréhensible ?

Si ma boule de cristal en bois fonctionne correctement, tu devrais soit détruire les données initiales lorsqu'elles sont lues dans le tableau (genre remplacer une valeur par -1 si tes valeurs ne sont jamais négatives) soit créer un tableau de marqueur. Quand un nombre est utilisable, son marqueur est à 1, sinon, zéro. Tu parcours tes données tant qu'il reste au moins un marqueur à 1.

Bonjour,
tu crées un tableau qui compte le nombre d’occurrences d'un chiffres et la longueur maximale de la chaîne commençant avec ce chiffre.
Dans ton exemple à partir de 0 3 2 1 4 5 3 6 5

indice	0	1	2	3	4	5	6	7	8	9
occurences	1	1	1	2	1	2	1	0	0	0
longueur	7	6	5	4	3	2	1	0	0	0

Tu recherches le maximum des longueurs : cela te donne la plus grande chaîne, ici elle commence en 0 et a pour longueur 7. Tu enlèves 1 aux occurrences de cette chaîne et tu recommences :

indice	0	1	2	3	4	5	6	7	8	9
occurences	0	0	0	1	0	1	0	0	0	0
longueur	0	0	0	1	0	1	0	0	0	0

La plus longue chaîne commence en 3 et a pour longueur 1, tu décrémentes, tu recommences … jusqu'à n'avoir que des 0 en occurrences.

La question est incompréhensible.

Je pensais avoir vaguement compris quelque chose, mais visiblement, ce que j'ai compris est totalement différent de ce que Dinobogan ou Pivcodev ont compris.

Donc je vais m'abstenir, en attendant une question compréhensible.

Vu que certaines personnes n'ont pas compris le sujet, je me permet de prendre le temps de vous expliquez.
J'ai en ma possession différentes marchandises correspondant à une valeur.
marchandises 0 1 2 3 4 5 6 7 8
A partir de là la personne a déjà entré ses marchandises dans n importe quelle ordre et qui peut etre ecrit jusqu'à 9 fois (exemple: 0 0 0 0 0 0 0 0 0)
Le but est de déterminer le nombre de points que la personnes a effectué grâce à des suites (une suite de est représenté par une ou plusieurs cartes qui se suivent)
Série possibles: 9 marchandises successives => 60 pts (0 1 2 3 4 5 6 7 8) 3 marchandises successives => 60 pts (0 1 2)
8 marchandises successives => 50 pts (0 1 2 3 4 5 6 7) 2 marchandises successives => 60 pts (0 1)
7 marchandises successives => 40 pts (0 1 2 3 4 5 6) 1 marchandise => 1 pts (0)
6 " " => 30 pts (0 1 2 3 4 5)
5 " " => 21 pts (0 1 2 3 4)
4 " " => 13 pts (0 1 2 3)
A savoir une série ne commence pas toujours pas 0. Il faut donc à partir de cela déterminer le nombre maximum de points que je peux avoir avec mes marchandises entrées.
(ex: 6 7 1 9 8 7 5 4 4) donne 1 serie de 6 (4 5 6 7 8 9), 3 serie de 1 (1) (7) (4).

Tu te permets d'expliquer ... mais essaie au moins de te relire, parce que tu as fait quelques erreurs.

Tu écris par exemple qu'une série de 3, ça rapporte 60 points, et aussi une série de 2, ça rapporte 60 points ?
Tu es sûr de ça ???
Ca ne paraît pas très cohérent.

Essaie encore. Tu vas finir par y arriver.

je rectifie, une serie de 3=> 7 points et une serie de 2=>3 points.
une suite peut commencer a 3 (ex: 3 4 5).

Donc, je reformule ton besoin avec un dernier exemple.

On a la série de chiffres 6 7 1 9 8 7 5 4 4
L'ordre initial n'a aucune importance, on aurait donc pu écrire aussi 1 4 4 5 6 7 7 8 9
A partir de cette série de chiffres, on peut les associer entre autres de cette façon 1 // 4 // 4 5 6 7 // 7 8 9 ou encore 1 // 4 // 4 5 6 7 8 9 // 7
Entre chaque séparateur // on a des chiffres qui se suivent en ordre croissant, sans trou.
L'association 1 4 // 4 5 6 7 // 7 8 9 est interdite.

Quand les chiffres sont regroupés de cette façon, on peut compter des points. Les chiffres isolés rapportent 0 points. les séquences rapportent des points :
2 chiffres= 3 points
3 chiffres= 7 points
4 chiffres= 13 points
5 chiffres= 21 points
6 chiffres= 30 points
7 chiffres= 40 points
8 chiffres= 50 points
9 chiffres= 60 points
On n'a pas le barème pour une séquence de 10 chiffres. Disons que le barème est de 70 points.

Et l'objectif est de choisir le regroupement qui rapporte le plus de points.
Sur l'exemple précédent, le regroupement 1 // 4 // 4 5 6 7 // 7 8 9 rapporte 0+0+13+7 = 20 points
alors que 1 // 4 // 4 5 6 7 8 9 // 7 rapporte 0+0+30+0 = 30 points.

Le décryptage est fait. Maintenant commence le travail d'algorithme.

c est exactement ça sauf un chiffre isolé compte pour 1 point (on appelle une suite de 1 qui vaut 1 point ), apres l'algorithme c est justement ça le problème je voulais avoir une aide pour le réaliser :?

L'algorithme.

Quand on regarde le rapport Barème/Longueur, on constate qu'on a intérêt à former des chaines le plus longues possibles.
Par exemple, si on hésite entre une combinaison 1 2 3 4 // 3 4 5 6 et 1 2 3 4 5 6 // 3 4 , la 2ème combinaison rapporte plus.
Et c'est pareil pour 1 2 3 4 5 // 3 4 5 6 et 1 2 3 4 5 6 // 3 4 5 . Il vaut mieux faire un groupe de 6 et un groupe de 3, plutôt qu'un groupe de 4 et un groupe de 5.
Du coup, l'algorithme est assez simple.

Illustrons avec un jeu de données : 1 2 4 5 8 9 5 6 0 4 5 6 3
Etape 1 : Trier les données par ordre croissant. 0 1 2 3 4 4 5 5 5 6 6 8 9
Etape 2 : Prendre le chiffre le plus à gauche et construire une chaîne aussi longue que possible, avec des nombres en ordre croissant, sans trou.
Sur l'exemple, on obtient 0 1 2 3 4 5 6 et il reste 4 5 5 6 8 9
Boucler sur l'étape 2 autant de fois que nécessaire :

Ici, on a donc successivement :
0 1 2 3 4 4 5 5 5 6 6 8 9
Boucle n°1 : 0 1 2 3 4 5 6 trié et reste = 4 5 5 6 8 9
Boucle n°2 : 0 1 2 3 4 5 6 // 4 5 6 et reste 5 8 9
Boucle n°3 : 0 1 2 3 4 5 6 // 4 5 6 // 5 et reste 8 9
Boucle n°4 : 0 1 2 3 4 5 6 // 4 5 6 // 5 // 8 9 et reste rien

salut

la fin de ton algo est pas très clair ^^

j'aurais plutôt écris

1 2 4 5 8 9 5 6 0 4 5 6 3 => trié
Boucle n°1 : 0 1 2 3 4 4 5 5 5 6 6 8 9 // 0 1 2 3 4 5 6 et reste = 4 5 5 6 8 9
Boucle n°2 : 4 5 5 6 8 9 // 4 5 6 et reste 5 8 9
Boucle n°3 : 5 8 9 // 89 et reste 5
Boucle n°4 : 5 // 5 et reste rien

j'en conviens le résultat et le même sauf que tu perçois a mon avis mieux les étapes

Merci mais je n'arrive pas à le coder. Je comprends ce qu'il faut faire mais le coder c'est plus dure.

salut

il te faut chercher la suite la plus longue

comme ton nombre est trie c'est plus simple
voici un pseudocode ... je pense qu'il y a des optimisation a faire mais le principe générale est ici

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

Pour Increment = 0 jusqu'a Longueur(Table) Faire debut Pour ori := table[Increment]; pas := Increment; ChCurrent := ori fin = Faux; rupture = Faux; lg := 1; tansque rupture = Faux et fin = Faux faire debut tansque pas := Pas+1; si pas > Longueur(Table) alors Fin = vrai sinon si table[pas] = ChCurrent+1 alors lg = lg+1; finsi si table[pas] > ChCurrent+1 alors rupture = vrai Enregistre(Ori,Increment,lg); finsi ChCurrent = table[pas]; finsinon Fin tansque fin pour ChercheMaxLg dans enregistrement

---

j'espere avoir ete assez clair

Citation:

---

Envoyé par anapurna

salut

la fin de ton algo est pas très clair ^^

j'aurais plutôt écris

1 2 4 5 8 9 5 6 0 4 5 6 3 => trié
Boucle n°1 : 0 1 2 3 4 4 5 5 5 6 6 8 9 // 0 1 2 3 4 5 6 et reste = 4 5 5 6 8 9
Boucle n°2 : 4 5 5 6 8 9 // 4 5 6 et reste 5 8 9
Boucle n°3 : 5 8 9 // 89 et reste 5
Boucle n°4 : 5 // 5 et reste rien

j'en conviens le résultat et le même sauf que tu perçois a mon avis mieux les étapes

---

La différence entre nos 2 points de vue intervient quand on doit traiter 5 8 9.
Dans mon point de vue, on construit 5 ... et il reste 8 9. Et dans ton point de vue, on construit 8 9 , et il reste 5.

En terme de compréhension,... on peut discuter.
En terme de développement, et de performance, ma version est clairement plus simple.

J'ai le tableau 5 8 9.
Je prends le chiffre le plus à gauche, et je bâtis une suite qui commence par ce chiffre. Ici ma suite à un seul élément.
Et je continue mes itérations.
Je n'ai plus besoin de chercher la suite la plus longue possible, puisque je sais que de toutes façons je vais prendre la suite qui commence par le 1er élément de mon tableau.
Un niveau de boucle en moins dans le programme.

salut

sauf que tu change de logique dans ta boucle et comme le nombre de boucle peut être variable
tu risque de te trouver confronté a un problème
dans mon cas j'utilise toujours la même logique récupérer la suite la plus longue a chaque itération
mais bon ça se discute


PS : après réflexion, effectivement ton choix est judicieux et beaucoup plus optimisé que le mien
par contre l'ordre des suites n'est pas forcement trié