Besoin d'aide sur le loop d'une fonction Python

[fred]

Ce que tu veux comme sortie c'est quelquechose du genre là?

[email protected]:~/Bureau$ python test.py 12 5 4 8
ma_liste[1] - ma_liste[0] = 5 - 12 = -7
ma_liste[2] - ma_liste[1] = 4 - 5 = -1
ma_liste[3] - ma_liste[2] = 8 - 4 = 4

[comaX]

Du tout, en effet ca serait plus simple avec une vraie sortie. Tant pis pour le challenge d'un autre site, mais je ne vais pas m'amuser à recoder un truc.

./modulo.py 0 19 22 40 49 65 85 96 105 109 113 122 127 142 163 168 182 185 200 218
S
C
R
I
P
T
K
I
D
D
I
E
O
U
E
N
C
O
R
Traceback (most recent call last):
File "./modulo.py", line 16, in <module>
A = int(sys.argv[i+1])
IndexError: list index out of range

Ca c'est ma sortie actuelle, il me faudrait la même chose, mais sur une seule ligne. Pour le bug de la première lettre, oubliez ce que j'ai dit, j'avais oublié un nombre...

[afranck64]

Du tout, en effet ca serait plus simple avec une vraie sortie. Tant pis pour le challenge d'un autre site, mais je ne vais pas m'amuser à recoder un truc.
Ca c'est ma sortie actuelle, il me faudrait la même chose, mais sur une seule ligne. Pour le bug de la première lettre, oubliez ce que j'ai dit, j'avais oublié un nombre...

Dans votre algorithme, il y avait "tant qu'il y a des arguments" vous ne l'avez pas reconduit dans le code.
Pour afficher le tout sur une ligne:

    print(chr(((A-B) % 26) + off - 1)),     #La virgule fera continuer sur la même ligne

[comaX]

Dans votre algorithme, il y avait "tant qu'il y a des arguments" vous ne l'avez pas reconduit dans le code.

Exact, car je ne sais pas comment faire !

Pour afficher le tout sur une ligne:

    print(chr(((A-B) % 26) + off - 1)),     #La virgule fera continuer sur la même ligne

Mon dieu, si simple et si dur à trouver... Merci beaucoup !

[fred]

Du tout, en effet ca serait plus simple avec une vraie sortie. Tant pis pour le challenge d'un autre site, mais je ne vais pas m'amuser à recoder un truc.

Si si c'est sur le même principe

[email protected]:~/Bureau$ python test.py 12 5 4 8
ma_liste[1] - ma_liste[0] = 5 - 12 = T
ma_liste[2] - ma_liste[1] = 4 - 5 = Z
ma_liste[3] - ma_liste[2] = 8 - 4 = E
TZE

[comaX]

Autant pour moi, alors !

Bien, il ne reste plus qu'à régler cette histoire de nombre d'arguments. Il n'existe pas de truc comme $# avec awk (si je ne m'abuse), qui donne le nombre d'arguments ?

Auquel cas, on pourrait faire while "i < $#" :
ou quelque chose de la sorte.

[afranck64]

Exact, car je ne sais pas comment faire !!

Récupération de la longueur de la liste via:

long = len(ma_liste)

Vérification que <i> est toujours inférieur à <long-1> car on fait: ma_liste[i+1]:

while (i<(long-1)):
     #... traitement

[fred]

Voici un code que je te propose

import sys
liste = []
ma_liste = [int(i) for i in sys.argv[1:]]
for i in xrange(0, len(ma_liste)-1):
    lettre = chr((ma_liste[i+1] - ma_liste[i])%26 + 65)
    print "ma_liste[%d] - ma_liste[%d] = %d - %d = %s" %(i+1, i, ma_liste[i+1], ma_liste[i], lettre)
    liste.append(lettre)
print ''.join(liste)

Tu n'as plus qu'à modifier ce code selon tes besoins

[comaX]

Récupération de la longueur de la liste via:

long = len(ma_liste)

Vérification que <i> est toujours inférieur à <long-1> car on fait: ma_liste[i+1]:

while (i<(long-1)):
     #... traitement

On dirait que sys.argv ne peut être utilisé comme une liste, car que je fasse :

no = len(sys.argv)

while ((i+1)< no):

ou

no = len(sys.argv)

while (i< (no-1)):

Rien ne semble marcher. je vais creuser un peu plus.*

Voici un code que je te propose

import sys
liste = []
ma_liste = [int(i) for i in sys.argv[1:]]
for i in xrange(0, len(ma_liste)-1):
    lettre = chr((ma_liste[i+1] - ma_liste[i])%26 + 65)
    print "ma_liste[%d] - ma_liste[%d] = %d - %d = %s" %(i+1, i, ma_liste[i+1], ma_liste[i], lettre)
    liste.append(lettre)
print ''.join(liste)

Tu n'as plus qu'à modifier ce code selon tes besoins

Il faut seulement remettre le -1, mais sinon, c'est vrai que c'est pas mal du tout ! Je pense que pour les besoin d'un outil de décryptage on pourra se passer des détails, et s'en tenir au message de fin. Ceci-dit, on verra ça quand on en sera à faire le tool !

*Du coup, avec le code de Fred, j'ai compris comment avoir le nombre d'arguments !

Merci beaucoup à vous deux, votre aide m'a été précieuse et instructive !

[afranck64]

Pour un peu plus:

import sys

lst = ["12", "5", "4", "8"]
def walkList(lst, offset=0):
    length = len(lst)
    for i, elt in enumerate(lst):
        if (i<length-1 and i>=offset):
            print(chr(((int(lst[i+1])-int(lst[i])) % 26) + 65)),

walkList(lst) #T,Z,E

#Style JSmiley :mouarf:
print " ".join(( chr(((int(lst[i+1])-int(lst[i])) % 26) + 65) for i in xrange(len(lst)-1))) #T,Z,E

#walkList(sys.argv, 1)

[comaX]

J'ai commenté le code, pour m'assurer de l'avoir bien compris tout de même. Sinon, j'ai juste enlevé la ligne print ma liste, etc., car je n'en vois pas l'intérêt.

import sys
liste = [] #on commence avec une liste vide
ma_liste = [int(i) for i in sys.argv[1:]] #on inscrit dans ma_liste tous les arguments
for i in xrange(0, len(ma_liste)-1): #tant que i est entre 0 et la longueur de ma_liste faire...
    lettre = chr((ma_liste[i+1] - ma_liste[i])%26 + 65) # "calcul" de la lettre
    liste.append(lettre) #On ajoute la lettre ainsi trouvée à la liste
print ''.join(liste)# On sort la liste, unifiée.

[comaX]

Pour un peu plus:

import sys

lst = ["12", "5", "4", "8"]
def walkList(lst, offset=0):
    length = len(lst)
    for i, elt in enumerate(lst):
        if (i<length-1 and i>=offset):
            print(chr(((int(lst[i+1])-int(lst[i])) % 26) + 65)),

walkList(lst) #T,Z,E

#Style JSmiley :mouarf:
print " ".join(( chr(((int(lst[i+1])-int(lst[i])) % 26) + 65) for i in xrange(len(lst)-1))) #T,Z,E

#walkList(sys.argv, 1)

Ce code ne marche pas pour moi, et pour le coup, je ne le comprend pas du tout !
D'ou vient ce "lst" au début, avec des nombres qui me parraissent aléatoires ?

Je crois qu'il faut rester dans le simple et efficace !

[fred]

Correction :

import sys
chaine = '' # Au départ mon résultat chaine vaut '' et on va le concaténer pour arriver à notre résultat final
ma_liste = [int(i) for i in sys.argv[1:]] # sys.argv[1:] renvoi la liste des arguments en chaine, donc je les transforme en entiers
for i in xrange(0, len(ma_liste)-1):# Pour indice i allant de 0 à longueur de liste-1
    lettre = chr((ma_liste[i+1] - ma_liste[i])%26 + 65) # je récupère dans la variable lettre la transpo nombre --> lettre
    chaine += lettre # concaténation des lettres
print chaine

Sinon, j'ai juste enlevé la ligne print ma liste, etc., car je n'en vois pas l'intérêt.

Normalement si, pour que tu vois comment fonctionnes le code, après je t'ai dis d'adapter et donc ça voulait dire le retirer, mais en ce qui me concerne ça devait avoir un intérêt pour toi.

J'ai modifié le code qui est plus efficace (rapide)

[comaX]

Normalement si, pour que tu vois comment fonctionnes le code, après je t'ai dis d'adapter et donc ça voulait dire le retirer, mais en ce qui me concerne ça devait avoir un intérêt pour toi.

Tout à fait d'accord ! Quand je disais que je n'y voyais pas d'intérêt, c'était pour l'utilisateur final.

Sinon, c'est fou toutes les façons différentes qu'il y a d'arriver au même résultat.
Bien, si jamais on doit inclure cet instrument dans le tool de crypto, je propose qu'on utilise ce dernier code ! Ah moins bien sur qu'il n'y ait encore plus efficace ^^

Je serais tenté de demandé en quoi il est plus efficace, mais j'ai peur de vous en demander trop pour mon niveau de simple juriste passionné d'informatique. A la limite, si c'est pas trop chiant à expliquer et pas trop dur à comprendre, je veux bien un PM, mais sinon, ne vous embêtez pas, vous m'avez déjà bien assez aidé pour un soir !

[fred]

Je ne sais plus trop c'est dans mes lectures.

Par contre j'ai testé leur temps

[email protected]:~/Bureau$ python test.py 12 5 4 8
sol_1 met : 9.28 concaténation
sol_2 met : 11.6 ''.join()
walkList met : 15.35

Donc ma deuxième solution est meilleure, je confirme

Voici mon code pour ce test

import sys
from time import clock


def sol_1():
    chaine = ''
    ma_liste = [int(i) for i in sys.argv[1:]] # sys.argv[1:] renvoi la liste des arguments en chaine, donc je les transforme en entiers
    for i in xrange(0, len(ma_liste)-1):# Pour indice i allant de 0 à longueur de liste-1
        lettre = chr((ma_liste[i+1] - ma_liste[i])%26 + 65) # je récupère dans la variable lettre la transpo nombre --> lettre
    chaine += lettre # concaténation des lettres
    return chaine
    

def sol_2():
    chaine = []
    ma_liste = [int(i) for i in sys.argv[1:]] # sys.argv[1:] renvoi la liste des arguments en chaine, donc je les transforme en entiers
    for i in xrange(0, len(ma_liste)-1):# Pour indice i allant de 0 à longueur de liste-1
        lettre = chr((ma_liste[i+1] - ma_liste[i])%26 + 65) # je récupère dans la variable lettre la transpo nombre --> lettre
    chaine.append(lettre)
    return ''.join(chaine)
    
def walkList():
    offset = 0
    ch = ''
    lst = [int(i) for i in sys.argv[1:]]
    length = len(lst)
    for i, elt in enumerate(lst):
        if (i<length-1 and i>=offset):
            ch += chr(((int(lst[i+1])-int(lst[i])) % 26) + 65)
    return ch

def test(fonction):
    start = clock()
    for i in xrange(1000000):
        fonction()
    print "%s met : "%fonction.__name__, clock() - start

for i in (sol_1, sol_2, walkList):
    test(i)