Bonjour, j'ai essayé de créer un programme dont le but est, dans un tableau, de trier les éléments selon leur signe (mettre les nombre strictement négatifs au début, les éléments nuls au milieu et les éléments strictement positifs à la fin de la liste). Voici mon programme :

def triSigne(liste):
    max = 0
    min = 0
    for i in range(len(liste)):
        if liste[i] > 0:
            liste[i], liste[len(liste)-1-max] = liste[len(liste)-1-max], liste[i]
            max = max + 1
        if liste[i] < 0:
            liste[i], liste[min] = liste[min], liste[i]
            min = min + 1
        print(liste)
    return liste

Cependant, voici ce qu'il me renvoie :

In [33]: triSigne([4,5,-1,-1,0,-5,1,42,-42,0])

[0, 5, -1, -1, 0, -5, 1, 42, -42, 4]
[-42, 0, -1, -1, 0, -5, 1, 42, 5, 4]
[-42, -1, 0, -1, 0, -5, 1, 42, 5, 4]
[-42, -1, -1, 0, 0, -5, 1, 42, 5, 4]
[-42, -1, -1, 0, 0, -5, 1, 42, 5, 4]
[-42, -1, -1, -5, 0, 0, 1, 42, 5, 4]
[-42, -1, -1, -5, 0, 0, 42, 1, 5, 4]
[-42, -1, -1, -5, 0, 0, 1, 42, 5, 4]
[-42, -1, -1, -5, 0, 5, 1, 42, 0, 4]
[-42, -1, -1, -5, 4, 5, 1, 42, 0, 0]
Out[33]: [-42, -1, -1, -5, 4, 5, 1, 42, 0, 0]

C'est à peu près la même chose pour tous mes autres tests. Le programme finit par atteindre le bon résultat mais continue à tourner. Et je ne sais pas quand arrêter ma boucle for.

Quel est l'intérêt de les trier par signe? Juste les trier par ordre croissant suffit non?

C'est ce que mon énoncé demande, donc je le fais . Ah ouais, avant que j'oublie de le préciser, le programme doit faire un seul parcours de liste et ne pas utiliser de tableau auxiliaire.

Ben je ne fais qu'un parcours de liste et ça rempli le cahier des charges

def tri_insertion(liste):
    for i in range(len(liste)):
        x = liste[i]
        j = i
        while j > 0 and liste[j-1] > x:
            liste[j] = liste[j-1]
            j -= 1
        liste[j] = x
    return liste


liste = [-15, 20, 0, 4, 7, -8, -21]
print(tri_insertion(liste))

Mais qu'est-ce qu'il est fort ce garçon  (ou cette fille)

N'empêche, j'aimerai bien savoir ce qui cloche dans mon programme.

Pas vraiment, j'ai juste pris le premier tri qui m'est passé par la tête (après j'ai traduit l'algo en python).

Je ne sais pas trop ce qui ne vas pas dans ton code, ça ressemble à un tri à bulle mais un peu foireux, mais comme je suis assez mauvais en algorithmique je vais avoir du mal à t'aider^^

Salut

Tu ne vérifies nulle part que l'élément final est le plus grand, tu te contente juste de dire que s'il est plus grand que zéro je le fou à la fin -1,2..

Il faut stocker le nombre le plus grand dans une variable MAX et tu vérifies que le nombre que tu passes est plus grand que MAX, si c'est le cas tu le swap avec celui d'à côté. Enfin, une petite recherche sur le net t'expliquera mieux que moi.

Voici une version basée sur le tri insertion proposé par Derzal, mais qui s'arrête un peu plus tôt vu qu'on n'a besoin que de trier les signes.

def tri_signe(liste):

"""
Trie par signe.
L'algorithme regarde les éléments de gauche à droite.
Si l'élément est positif, on passe au suivant
S'il est négatif, on l'intervertit avec l'élément précédent jusqu'à
ce que l'élément précédent soit aussi négatif ou qu'on arrive en 
début de liste
Si l'élément est égal à 0, on l'intervertit avec le précedent
jusqu'à ce que l'élément précédent soit strictement inférieur à 1.
"""
for i, element in enumerate(liste):
    if element > 0: # Skip positive elements
        continue

    down_to = 0 if element < 0 else 1 # comparison value for swapping
    j = i
    while j > 0 and liste[j-1] >= down_to:
        liste[j] = liste[j-1]
        j -= 1
       
    liste[j] = element
return liste

liste = [-15, 20, 0, 4, 7, -8, -21, 0, 12, -8, -7, 0, 3] print(tri_signe(liste))

Out: [-15, -8, -21, -8, -7, 0, 0, 0, 20, 4, 7, 12, 3]

</pre>

-
Edité par Dan737 12 janvier 2015 à 17:17:51