Bonjour,

j'ai le tableau suivant :
array(0 => 1, 1=> 2, 2 => 2, 3=> 2, 4=> 2)

qui me sert a stocker des positions.

J'aimerai m'assurer qu'il ne comporte pas de doublons, et si il en comporte, incrémenter ses doublons.

Sur le tableau ci-dessous, j'aimerai donc me retrouver avec le tableau suivant :

array(0 => 1, 1=> 2, 2 => 3, 3=> 4, 4=> 5)

Je connais array_unique, mais cela supprime les doublons, ça ne les incrémente pas.

Comment puis-je m'y prendre, en quelques lignes de code ?

array_keys() est ton amie.

la logique c'est que si la position est la même alors il l'incrémente ?

la logique c'est que si la position est la même alors il l'incrémente ?

Voilà, de manière à n'avoir que des positions uniques, et qui se suivent.

Voilà, de manière à n'avoir que des positions uniques, et qui se suivent.

Et tu as creusé la piste que je t'ai donné ? Qu'est-ce qu'il en ressort ?

Voilà, de manière à n'avoir que des positions uniques, et qui se suivent.

Et tu as creusé la piste que je t'ai donné ? Qu'est-ce qu'il en ressort ?

Je suis en train de regarder, mais je ne vois pas trop comment m'y prendre.

Disons qu'à la base, j'ai le tableau de position suivant :

Array
(
    [1] => 1
    [2] => 2
)

où la clé est l'identifiant de l'utilisateur, et la valeur, la position.

Je modifie les positions, j'ai donc le tableau suivant :

Array
(
    [1] => 2
    [2] => 1
)

Puis avec un array_keys, j'ai

Array
(
    [0] => 1
    [1] => 2
)

qui ne stock plus du tout l'identifiant de l'utilisateur. je ne sais plus a qui attribuer quelle position.

Bonjour,

Disons qu'à la base, j'ai le tableau de position suivant :

Array
(
    [1] => 1
    [2] => 2
)

où la clé est l'identifiant de l'utilisateur, et la valeur, la position.

C'est le genre d'information que tu aurais pu nous donner dès le départ, car ça change toutes les données du problème (le tableau initial commençait à l'index 0, et rien ne laissait sous-entendre que les index pouvaient être des identifiants).

De plus rien ne laissait sous-entendre que tu allais réutiliser le tableau sous forme de paires clé-valeur, c'est pourquoi tu aurais pu nous copier un peu de ton code dès le départ pour éviter tous ces non-dits.

Donc, histoire d'être sûr, parceque là ça devient vraiment confus entre le post initial et ces dernières infos :

- Les "ID" c'est les valeurs du tableau ou les clés ?
- les doublons se font bien sur la position, et non sur l'id ? (Tu as deux id avec la même position, mais pas deux positions avec le même id ?)

Je modifie les positions, j'ai donc le tableau suivant :

Array
(
    [1] => 2
    [2] => 1
)

Question : En supposant que les identifiants soient les clés du tableau, et les positions les valeurs : il n'y a pas quelquechose qui te gêne dans ce tableau ? Quelquechose d'évident.

Tu associes à chaque id un chiffre repérant sa position. Très bien, soit. Mais ce ne serait pas infiniment mieux si l'ordre de ton tableau reflétait l'ordre de la position, plutôt que l'ordre des ID, dont tout le monde se fiche ?

Ce n'est pas seulement un + esthétique, c'est une étape vers la solution. J'attendrai que tu en arrives là, ainsi que les réponses définitives aux quelques questions posées pour bien définir ton problème, pour poursuivre

( Oublions array_keys pour l'instant, cette piste n'est sans doute pas la plus adaptée à ton cas tel qu'il se présente - mais ça va peut-être intervenir plus tard. )

- Les "ID" c'est les valeurs du tableau ou les clés ?
- les doublons se font bien sur la position, et non sur l'id ? (Tu as deux id avec la même position, mais pas deux positions avec le même id ?)

- Les ID des utilisateurs sont les clés. les positions sont les valeurs.
- Il ne peut pas y avoir plusieurs ID identiques.
- Au final, il ne doit pas y avoir plusieurs positions identiques, mais cela peut être le cas à l'entrée, si l'utilisateur définie 2 fois la même position pour deux ID différents.

Question : En supposant que les identifiants soient les clés du tableau, et les positions les valeurs : il n'y a pas quelquechose qui te gêne dans ce tableau ? Quelquechose d'évident.

Tu associes à chaque id un chiffre repérant sa position. Très bien, soit. Mais ce ne serait pas infiniment mieux si l'ordre de ton tableau reflétait l'ordre de la position, plutôt que l'ordre des ID, dont tout le monde se fiche ?

Ce n'est pas seulement un + esthétique, c'est une étape vers la solution. J'attendrai que tu en arrives là, ainsi que les réponses définitives aux quelques questions posées pour bien définir ton problème, pour poursuivre

( Oublions array_keys pour l'instant, cette piste n'est sans doute pas la plus adaptée à ton cas tel qu'il se présente - mais ça va peut-être intervenir plus tard. )

Ok, je reviens dès que j'ai avancé.

donc partant de ton exemple ca va au delà de incrémentation :
si on a une liste du genre :

1, 2, 2, 2, 2, 7, 8, 9, 9, 9, 8, 8, 8, 8, 8, 1, 1, 1, 1

ca nous ferais

1, 2, 3, 4, 5, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 6, 17, 18, 19

Merci pour les précisions VaN, on avance Manque plus qu'un petit tri et on va pouvoir attaquer le morceau intéressant.

donc partant de ton exemple ca va au delà de incrémentation :
si on a une liste du genre :

1, 2, 2, 2, 2, 7, 8, 9, 9, 9, 8, 8, 8, 8, 8, 1, 1, 1, 1

ca nous ferais

1, 2, 3, 4, 5, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 6, 17, 18, 19

D'ou l'intérêt de regénérer tous les nombres d'un coup (après tout les nombres n'ont pas de sens en tant que tels, ils servent juste de support pour stocker une information : l'ordre relatif des éléments les uns par rapport aux autres, information qui pourrait être représentée de manière naturelle), à plus forte raison s'il y a des doublons dedans

Je reviens vers vous, car j'ai enfin un peu de temps pour me pencher à nouveau sur le problème.

En entrée :

Array
(
    [2] => 3
    [3] => 2
    [4] => 2
    [5] => 4
    [6] => 2
)

Et après un asort() :

Array
(
    [6] => 2
    [4] => 2
    [3] => 2
    [2] => 3
    [5] => 4
)
)

Dans chacun de ces tableaux, les clés sont les identifiants des utilisateurs, et les valeurs sont leur position.

Au final, il me faut un tableau dont chaque valeur est unique, se suit, et dont la première valeur vaut 1.

Ici, j'ai pris un cas extrême en exemple, car il faut également que cela fonctionne si la personne qui modifie les positions fait n'importe quoi.

Mon problème est le suivant : Il faut absolument que je garde une association clé => valeur, et la première clé du tableau ne vaut pas forcément 0. J'avoue que je sèche sur comment faire..

EDIT : Mais lol.. une clope au balcon, on respire un grand coup, et la solution vient d'elle même. Tellement évidente qu'elle ne me sautait pas au yeux.. J'étais focus sur une méthode beaucoup plus compliquée.

bref :

asort($positions);
		
		$start = 1;
		foreach($positions as $key => $position) {
			$positions[$key] = $start;
			$start++;
		}

Et la lumière fût...

Pour la petite histoire, en appliquant un array_flip(array_keys($tableau)) à ton dernier tableau (et revoilà le fameux array_keys), tu avais une façon simple et intéressante de regénérer toutes les positions d'un seul coup (à partir de zéro cependant, mais sans aucun risque de collision), ce à quoi je voulais t'amener (c'était pas non plus très dur par la suite d'incrémenter toutes les positions de 1...).

En tout cas bien joué