Discussion :

[e-ric]

Ta soluce pour le 0 est pas mal.

Suite � ce que je t'ai dit sur l'ordre d'insertion, tu peux presque te passer de la liste de chiffres (entier) Base4 et produire directement une liste de chiffres Shaddock (une liste de chaine de caract�res) � l'aide des �l�ments discut�s avec fred1599. Il suffit de cr�er une liste des chiffres Shaddock, l'indice de chacun �tant le chiffre �quivalent en base 4, ainsi :
on pose Shads=["GA", "BU", "ZO", "MEU"]
et on a Shads[0] �gale � "GA" qui est 0 en Shaddock...
en prenant la variable r comme indice de la liste, on atteint vite le r�sultat demand�.

[Torylyx]

Ca donne de bonnes habitudes. Il est assez logique de nommer un code de calcul que tu vas utiliser par la suite. Cela am�liore la lisibilit� et la compr�hension (pense au prof qui va corriger). Cela donne le sentiment que tu as bien d�compos� le probl�me (diviser pour r�gner, m�thode cart�sienne et blabla).

Je m'en vais donc d�finir cette fonction de ce pas

Elles peuvent �tre �limin�es car elle ne sont que des interm�diaire de calcul sans grand int�r�t. Je ne dis pas lesquelles pour l'instant.

Rha, je vois vraiment pas lesquelles... Bon, pas grave, je verrai �a � la fin.

Un peu de curiosit� ne fait pas de mal. Sinon tu peux utiliser aussi l'op�rateur + qui permet de concat�ner (mot barbare) 2 listes, c'est une autre fa�on de faire. Passer par l'insertion en t�te de liste pr�sente l'avantage de mettre les chiffres (de 0 � 4) dans le sens de lecture classique (du plus grand ordre de grandeur jusqu'� l'unit�). Par chance, les nombres en shaddock suivent la m�me logique des nombres en fran�ais.

Je n'ai pas compris grand chose, mais je vais aller me renseigner!

Il faut se triturer les m�ninges .

J'ai �dit� mon post du dessus avant votre r�ponse. Serai-ce une solution?

[e-ric]

Pour les op�rations sur les listes il y a plein de tutoriels, �a se lit assez vite.

Pour l'ordre des chiffres, ton algorithme initial va produire ceci si je d�compose en puissance de 4 (c'est ce qu'on fait en parlant de base)
pour 9 = 1 + 8 = 1*4^0 + 2*4^1, ton algorithme donne [1, 2]
pour 27 = 3 + 8 + 16 = 3*4^0 + 2*4^1 + 1*4^2 ton algorithme donne [3,2,1]
or, si on respecte le sens de lecture habituel, il faudrait mieux obtenir
pour 9 [2,1]
pour 27 [1,2,3]
Comprends-tu ?
Cela permettra aussi de travailler directement en Shaddock apr�s.

En ce qui concerne l'usage d'une fonction, cela te permet aussi de tester ton code dans une boucle, c'est pratique.

Pour le cas du 0, il y a un autre moyen, en fait le probl�me vient de l'a structure while, pour bien faire il faudrait une autre structure de contr�le (repeat until) mais elle n'existe pas en Python, donc il faut ruser.

Je te proposerais ma solution apr�s... (pas parfaite sans doute mais plus l�g�re)

[Torylyx]

Je suis d�sol�e, je dois �tre vraiment p�nible, mais non je ne comprend pas, j'ai vraiment du mal, d�sol�e :/
(enfin j'ai compris le fait qu'il faut retourner les listes, mais pas le reste)

Toujours est-il qu'on a (un chouilla) avanc� le programme:

Code :

S�lectionner tout - Visualiser dans une fen�tre � part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
#FONCTION convertBase10toShadocks
#Résultat: Convertit un nombre en base 10 entré par l'utilisateur en langage Shadock
def convertBase10toShadocks():
    n=int(input("Entrez le nombre en base 10:"))     #nb entré par l'utilisateur en base 10
    q=n                                              #variable qui contiendra le quotient de la division euclidienne n//4
    r=0                                              #variable qui contiendra le reste de cette division.
    Base4=[]                                         #liste qui contiendra la conversion du nombre base 10 en base 4
    Shads=["GA","BU","ZO","MEU"]                     #liste des termes du langage des Shadocks
    if q==0:                                         #permet de traiter le cas où n=0
        Base4.append(0)                              #valeur 0 entre dans liste Base4 
    else:
        while q>0:
            q=n//4                                   #q reçoit le quotient de la division euclidienne n//4
            r=n%4                                    #r reçoit le reste de la division
            n=q                                      #n reçoit la valeur du quotient q
            Base4.append(r)                          #la valeur du reste r entre dans liste Base4
    for i in range(0,Base4[i]):
 
 
 
convertBase10toShadocks()

Manque maintenant � retourner la liste et � la convertir la liste en Shadock. Mais je ne comprend pas du tout comment faire correspondre les chiffres avec les mots Shadocks... :/

EDIT: J'ai r�ussi � faire retourner la liste. En r�alit�, c'�tait juste super simple *honte � moi* x)... Par contre, pour ce qui est d'associer les mots Shadocks, �a reste toujours aussi flou :/

[e-ric]

Question : � quoi sert l'instruction ?

Code :

S�lectionner tout - Visualiser dans une fen�tre � part

for i in range(0,Base4[i]):

Tu as compl�t� ta liste Base4 avec des chiffres allant de 0 � 3, qui sont les restes des divisions enti�res successives que tu r�alises dans ta boucle while. Jusque l�, �a va?

Dans une liste en Python, les �l�ments sont accessibles par un entier allant de 0 au nombre d'�l�ment moins 1. Ainsi :
Shads[0] = "GA"
Shads[1] = "BU"
Shads[2] = "ZO"
Shads[3] = "MEU"
Tu as donc une correspondance imm�diate entre les restes et l'indice du chiffre Shadock contenus dans Shads.

Pour finir, tu parcours la liste Base4, pour chaque �l�ment, tu trouves le correspondant dans Shads que tu places dans une nouvelle liste.
Capito ?

La transformation en cha�ne de caract�re sera vue apr�s.

R�pond vite fait.

[Torylyx]

Pour ' for i in range', j'avais juste marqu� �a, apres �tre partie sur une piste idiote, j'ai seulement oubli� de le supprimer avant de poster.

Dans une liste en Python, les �l�ments sont accessibles par un entier allant de 0 au nombre d'�l�ment moins 1. Ainsi :
Shads[0] = "GA"
Shads[1] = "BU"
Shads[2] = "ZO"
Shads[3] = "MEU"
Tu as donc une correspondance imm�diate entre les restes et l'indice du chiffre Shadock contenus dans Shads.

Pour finir, tu parcours la liste Base4, pour chaque �l�ment, tu trouves le correspondant dans Shads que tu places dans une nouvelle liste.
Capito ?

Capito. Seulement, je ne sais pas comment faire pour donner l'instruction de placer l'�l�ment correspondant dans une autre liste :/

Pour l'instant mon prog donne �a:

Code :

S�lectionner tout - Visualiser dans une fen�tre � part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
#FONCTION convertBase10toShadocks
#Résultat: Convertit un nombre en base 10 entré par l'utilisateur en langage Shadock
def convertBase10toShadocks():
    n=int(input("Entrez le nombre en base 10:"))     #nb entré par l'utilisateur en base 10
    q=n                                              #variable qui contiendra le quotient de la division euclidienne n//4
    r=0                                              #variable qui contiendra le reste de cette division.
    Base4=[]                                         #liste qui contiendra la conversion du nombre base 10 en base 4
    Shads=["GA","BU","ZO","MEU"]                     #liste des termes du langage des Shadocks
    if q==0:                                         #permet de traiter le cas où n=0
        Base4.append(0)                              #valeur 0 entre dans liste Base4 
    else:
        while q>0:
            q=n//4                                   #q reçoit le quotient de la division euclidienne n//4
            r=n%4                                    #r reçoit le reste de la division
            n=q                                      #n reçoit la valeur du quotient q
            Base4.append(r)                          #la valeur du reste r entre dans liste Base4
    Base4.reverse()
 
 
 
 
convertBase10toShadocks()

[e-ric]

Comme tu d�j� fait ps mal de travail, je te fournis une routine (c'est pas la solution compl�te) pour transformer un nombre en une suite de reste provenant de la division enti�re par une base quelconque (non nulle bien s�r) :

Code :

S�lectionner tout - Visualiser dans une fen�tre � part

1
2
3
4
5
6
7
8
9
10
11
12
def ToBase(N, base):
    ## traite le cas de l'unité y compris 0.
    chiffres = []
    while True:
        ## dans l'ordre de lecture classique
        chiffres = [N % base] + chiffres # équivalent à une insertion en tête de liste.
        N = N // base  ##on passe à la suite 
        if N == 0: break
    return chiffres
 
#Exemple d'appel
ToBase(27, 4) ## base = 4

M�dite un peu l�-dessus, pas de variables inutiles, tu peux en convenir. J'ai choisi une boucle infinie pour placer la condition de sortie en fin de boucle, comme �a le code calcul est �crit une seule fois et tient compte du 0.

Pour la suite de ton probl�me, il ya plusieurs solution, dont une avec une boucle, l'autre avec une d�finition de liste en compr�hension (ma pr�f�r�e car tr�s concise) :
M�thode "pascalienne", assez logique

Code :

S�lectionner tout - Visualiser dans une fen�tre � part

1
2
3
4
 
L = []
for i in range(Base4.count()):
  L.append(Shads[Base4[i]])

Plus rigolo :

Code :

S�lectionner tout - Visualiser dans une fen�tre � part

1
2
3
4
 
L = []
for x in Base4:
  L.append(Shads[x])

Franchement plus fun (liste en compr�hension):

Code :

S�lectionner tout - Visualiser dans une fen�tre � part

1
2
 
L = [Shads[x] for x in Base4]

C'est plus proche d'un code pythonien.
Tu choisis ce que tu comprends le mieux.

D�finis Shads en dehors de ta fonction, �a peut toujours servir ailleurs...

[Torylyx]

Merci beaucoup de tout �a!
Mais franchement, je n'ai vraiment quasiment rien compris � toutes les commandes utilis�es dans votre solution :/ Et je ne pense pas qu'il soit judicieux de les mettre dans le programme si nous ne les avons pas vues en classe?

La plus compr�hensible pour moi est la 1ere.
Cependant, je ne comprends pas le (Base4.count())

[e-ric]

L'id�e est � chaque fois de parcourir tous les �l�ments de la liste Base4, de convertir chacun en chiffre Shadock et de construire la liste des chiffres Shadock.

La premi�re consiste � parcourir la liste en utilisant un indice entier, Base4.count() retourne le nombre d'�l�ments de Base4, tout simplement. La variable i va donc prendre les valeurs de 0 � Count()-1. Base4[i] est le i-�me �l�ments de la liste Base4, Shads[Base4[i]] est le chiffre Shadock correspondant.

La seconde est la m�me solution que la premi�re mais sans utiliser un indice entier. On it�re directement sur le contenu de la liste (les chiffres 0..3) en suivant l'ordre de celle-ci.

La troisi�me est �quivalente � la deuxi�me avec une notation particuli�re permise par Python (liste en compr�hension), plus compacte que l'it�ration �quivalente. Sur le principe, cela ressemble � la d�finition d'un ensemble en maths. Le premier terme de la d�finition est le calcul du terme de la liste (ici, la conversion du chiffre 0..3 en chiffre Shadock), l'instruction for d�termine d'o� viennent les x, ce sont les chiffres 0...3 de Base4. Un exemple plus simple, construisons la liste des 10 premiers entiers pairs : [2*x for x in range(10)].

Avez-vous compris le code de ToBase() ? En voici, une version qui utilise directement la base 4 et qui utilise la m�thode insert :

Code :

S�lectionner tout - Visualiser dans une fen�tre � part

1
2
3
4
5
6
7
8
9
10
 
def ToBase(N):
    ## traite le cas de l'unité y compris 0.
    chiffres = []
    while True:
        ## dans l'ordre de lecture classique
        chiffres.insert(0, N % 4)  ## insertion en tête de liste
        N = N // 4
        if N == 0: break
    return chiffres

[e-ric]

La fonction de d�composition base 4 avec append() :

Code :

S�lectionner tout - Visualiser dans une fen�tre � part

1
2
3
4
5
6
7
8
9
10
11
12
 
def ToBase4(N):
    chiffres = []
    while True:
        chiffres.append(N % 4) # ajout du reste dans la liste, pas besoin de variable
        N = N // 4 # pour passer au chiffre suivant 
        if N == 0: break # on sort de la boucle quand il n'y a plus de chiffres à récupérer
    chiffres.reverse()
    return chiffres
 
#exemple
Base4 = ToBase4(29)

Est-ce votre prof vous a donn� des consignes sur la programmation ? que vous-a-t-il enseign� ?
Je vous pose la question afin de savoir comment vous orienter vers une bonne solution.

[josmiley]

Code :

S�lectionner tout - Visualiser dans une fen�tre � part

1
2
3
4
5
6
7
8
9
def shadock(n):
    out = ''
    while n:
        n,r = divmod(n,4)
        out = ('GA','BU','ZO','MEU')[r] + out
    return out
 
print(shadock(27))
>>> BUZOMEU

ce qui est int�ressant maintenant c'est de faire la fonction inverse.

[e-ric]

Code :

S�lectionner tout - Visualiser dans une fen�tre � part

1
2
3
4
5
6
7
8
9
def shadock(n):
    out = ''
    while n:
        n,r = divmod(n,4)
        out = ('GA','BU','ZO','MEU')[r] + out
    return out
 
print(shadock(27))
>>> BUZOMEU

ce qui est int�ressant maintenant c'est de faire la fonction inverse.

Du code pythonien impec, cependant pour la sortie, je pensais s�parer les chiffres par des espaces pour simplifier le lecture (par un humain, comme sur le site exemple dans le premier post) et faciliter le code de la conversion inverse (avec split). En outre, je privil�gie une approche plus graduelle, car les codeurs sont des lyc�ens pas encore � l'aise avec le langage (ils n'ont pas que �a �� faire, le bac de fran�ais arrive...)

[josmiley]

bha, je trouve qu'une indexation et une concat�nation c'est plus 'd�butant' que deux m�thodes de list.

Code :

S�lectionner tout - Visualiser dans une fen�tre � part

1
2
3
4
5
6
7
8
9
10
def docksha(n):
    n = n.replace('GA' ,'0').\
          replace('BU' ,'1').\
          replace('ZO' ,'2').\
          replace('MEU','3')
    return int(n,4)
 
a = docksha('BOZUMEU')
print(a)
>>> 27

[e-ric]

Mon exp�rience de programmation (tr�s pascalienne) ne m'am�ne pas aux m�mes solutions que toi qui es visiblement plus habitu� et exp�riment� en Python. Ta solution de conversion est concise, la mienne passe par une liste, je ne l'expose pas maintenant car j'attend que nos codeurs en herbe aboutissent d'abord � une solution pour la premi�re partie.

Je ne connaissais pas le constructeur int avec la base en param�tre, c'est effectivement pratique au vu du probl�me � r�soudre.

Cependant, le test que tu donnes n'est pas juste, on aurait d� avoir une exception avec ton code : BOZUMEU n'et pas lexicalement correct, BUZOMEU l'est. Je chipote..

[josmiley]

h�h�h�, effectivement ...
bien vu.

[Azerx]

Ouf, vous vous �tes bien emball� sur la fin mais on a r�ussi a trouver une solution! On vous la poste des que possible; maintenant on s' attaque au probl�me inverse!

[e-ric]

Ca fait du bien de s'amuser un peu
Tr�s bien, on attend de voir votre travail avec impatience.
Vous pouvez poster ce que vous avez fait.

[Torylyx]

Oui, vous vous �tes bien amus�s sur la fin, et on n'a pas vraiment tout compris, donc... Pas grave, on s'est quand m�me d�brouill�s pour que le programme fonctionne!

Bon, voil� la version qu'on laissera finie je pense, puisque je ne comprends absolument pas comment le simplifier en fait, et comme nous ne sommes que des petits d�butants qui ne comprennent rien, du moment que �a marche... x)

Code :

S�lectionner tout - Visualiser dans une fen�tre � part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
#FONCTION convertBase10toShadock
#Résultat: Convertit un nombre en base 10 entré par l'utilisateur en langage Shadock
def convertBase10toShadocks():
    n=int(input("Entrez le nombre en base 10:"))     #nb entré par l'utilisateur en base 10
    q=n                                              #variable qui contiendra le quotient de la division euclidienne n//4
    r=0                                              #variable qui contiendra le reste de cette division.
    Base4=[]                                         #liste qui contiendra la conversion du nombre base 10 en base 4
    Shads=["GA","BU","ZO","MEU"]                     #liste des termes du langage des Shadocks
    if q==0:                                         #permet de traiter le cas où n=0
        Base4.append(0)                              #valeur 0 entre dans liste Base4 
    else:
        while q>0:
            q=n//4                                   #q reçoit le quotient de la division euclidienne n//4
            r=n%4                                    #r reçoit le reste de la division
            n=q                                      #n reçoit la valeur du quotient q
            Base4.append(r)                          #la valeur du reste r entre dans liste Base4
    Base4.reverse()                                  # On retourne la liste
    VocShad = [Shads[i] for i in Base4]              #On affecte la valeur du rang i de la liste Shads à la valeur correspondante de la liste Base4, et on stocke ceci dans la liste VocShad
    print(VocShad)
convertBase10toShadocks()

Bon, on a aussi essay� de commencer le 2nd programme. C'est du gros bidouillage, vraiment, il n'est absolument pas 'simplifi�' ou 'all�g�' on pourrait faire bien mieux je pense, mais pour l'instant, c'est tout ce qu'on a trouv�:

Code :

S�lectionner tout - Visualiser dans une fen�tre � part

1
2
3
4
5
6
7
8
9
10
11
12
#FONCTION covertShadocksToBase10
#Résultat:Convertit un nombre entré en Shadock en nombre en base 10
def convertShadockToBase10():
    m=int(input("Entrez le nombre de mot que contient le chiffre en Shadock:"))
    Shads=["GA","BU","ZO","MEU"]
    NbShad=[]
    for i in range (0,m):
        mS=str(input("Entrez le mot en shadock:"))
        NbShad.append(mS)
 
 
convertShadockToBase10()

[e-ric]

Ne m�langez pas le code de dialogue utilisateur avec celui du calcul, pour �tre plus pr�cis, s�parer les fonctions de calcul proprement dit du code de saisie par l'utilisateur.

Les fonctions de calcul ne renvoient que des valeurs.

Je vois que le principe des listes en compr�hension a �t� mis en oeuvre, preuve de la compr�hension du principe .

Pour la saisie du nombre en Shadock, il suffit de saisir une cha�ne de caract�res dont les chiffres Shadocks sont s�par�s par des espaces "GA BU GA" par exemple. La conversion en liste se fait � l'aide de la m�thode split() (� vous de chercher la fa�on dont �a fonctionne dans les docs).

[josmiley]

Oops, j'ai juste oubli� de prendre en compte z�ro en param�tre, c'est corrig� dans le return

Code :

S�lectionner tout - Visualiser dans une fen�tre � part

1
2
3
4
5
6
def shadock(n):
    out = ''
    while n:
        n,r = divmod(n,4)
        out = ('GA','BU','ZO','MEU')[r] + out
    return out or 'GA'