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'