Bonsoir à tous.

Alors voilà, il m'a été demandé de réaliser deux programmes en spécialité NSI à l'aide des énoncés suivants :

Voici les deux programmes que j'ai réalisé, dans l'ordre respectif des questions :

class Pile:

	def __init__(self):
		self.binaire = []

	def empiler(self, valeur):
		self.binaire.append(valeur)

	def read(self):
		self.binaire.reverse()
		return self.binaire


pile1 = Pile()

def decToBin(n):
    while n != 0 or 1:
        if n == 0:
            pile1.empiler(0)
            return pile1.read()
        elif n == 1:
            pile1.empiler(1)
            return pile1.read()
        else:
            reste = n%2
            n = n//2
            pile1.empiler(reste)

def decToBin2(n):
    if n == 1:
        print(1)
    elif n == 0:
        print(0)
    else:
        decToBin2(n//2)
        print(n%2)

Pour la question 1, j'ai donc crée une classe Pile puisque dans l'énoncé on me demande d'utiliser une pile (corrigez moi si il ne fallait absolument pas en faire une ), cependant j'ai tout de même recours à la méthode .reverse() pour pouvoir mettre l'équivalent binaire dans le bon sens. Auriez vous une solution pour directement mettre les chiffres dans l'ordre?

Pour la question 2, j'ai réalisé le programme récursif comme convenu, cependant dans l'énoncé on me demande de faire usage d'une chaîne de caractère pour stocker les restes des divisions successives. Lorsque je lance mon programme, les chiffres s'inscrivent les uns en dessous des autres étant donné que j'ai fais une récursion non-terminale; mais est-ce que le but recherché ne serait pas plutôt d'écrire l'équivalent binaire en "ligne", enfin pas en colonne quoi ^^ ? Et comment y parvenir si c'est le cas, j'ai beau trifouiller je ne vois pas comment faire

Merci beaucoup d'avance pour votre aide

Le premier programme est OK, si tu veux éviter de reverse tu peux par exemple remplacer append(valeur) par insert(0,valeur). Ça permet d'empiler au début de la liste et non pas à la fin.

Pour le second programme effectivement on te demande de renvoyer une chaîne de caractères, pas de l'afficher. La fonction print affiche les choses à l'écran mais ne renvoie rien. À part ça la structure du programme est OK.

Bonjour,

je ne fais pas de Python mais ca a l'air propre et concis. 1 semble bien repondre á la question ; cependant si tu n'aimes pas deleguer une partie des operation au "binaire.reverse", tu pourrais implementer une stack sur base de list (en exposant juste les methodes utiles), et ensuite parcourir la liste dans l'ordre naturel pour l'affichhage final. Cf. https://docs.python.org/3/tutorial/datastructures.html#using-lists-as-stacks

Pour 2, il faut que tu procedes comme 1, non pas avec une pile vierge mais avec une chaine vierge, conformement á la consigne. Cette chaine peut etre une variable globale qui existe en dehors de ta recursion, ou un parametre de la fonction recursive. Il te suffit ensuite de concatener de "0" ou des "1" á une chaine pour obtenir la decomposition.

Le 25 octobre 2021 à 19:56:31 :
Le premier programme est OK, si tu veux éviter de reverse tu peux par exemple remplacer append(valeur) par insert(0,valeur). Ça permet d'empiler au début de la liste et non pas à la fin.

Pour le second programme effectivement on te demande de renvoyer une chaîne de caractères, pas de l'afficher. La fonction print affiche les choses à l'écran mais ne renvoie rien. À part ça la structure du programme est OK.

Salut ! Merci pour ta réponse.

J'ai appliqué ton conseil avec la méthode insert qui fonctionne parfaitement
Il est vrai concernant le second programme que l'on me demande bien de renvoyer et non pas d'afficher, je corrige ça en ce moment même, merci !

Le 25 octobre 2021 à 20:04:42 :
Bonjour,

je ne fais pas de Python mais ca a l'air propre et concis. 1 semble bien repondre á la question ; cependant si tu n'aimes pas deleguer une partie des operation au "binaire.reverse", tu pourrais implementer une stack sur base de list (en exposant juste les methodes utiles), et ensuite parcourir la liste dans l'ordre naturel pour l'affichhage final. Cf. https://docs.python.org/3/tutorial/datastructures.html#using-lists-as-stacks

Pour 2, il faut que tu procedes comme 1, non pas avec une pile vierge mais avec une chaine vierge, conformement á la consigne. Cette chaine peut etre une variable globale qui existe en dehors de ta recursion, ou un parametre de la fonction recursive. Il te suffit ensuite de concatener de "0" ou des "1" á une chaine pour obtenir la decomposition.

Salut ! Merci pour ta réponse.

J'essaye en ce moment même d'appliquer tes conseils pour le second programme. Je suis rendu à ceci :

chaine = ''

def decToBin2(n):
    global chaine
    if n == 1:
        return 1
    elif n == 0:
        return 0
    else:
        return

Je sèche un peu concernant quoi mettre dans le dernier return, je ne vois pas comment je peux concaténer mon rappel récursif avec mon "n%2", j'y étais presque mais ça me mettait plusieurs parenthèses indésirables suite à l'exécution
Un petit coup de pouce? ^^

Merci !

Oublie la variable globale, t'étais sur la bonne piste avec tes print.

Tu veux renvoyer une chaîne de caractères, pas un entier, donc tes deux cas de base vont plutôt être return "0" et return "1". Ensuite pour le cas récursif, tu as decToBin2(n//2) qui est une chaîne de caractères contenant tous les chiffres binaires sauf le dernier. Tu veux y rajouter le dernier chiffre et renvoyer le résultat. En python tu peux concaténer des chaînes de caractère avec l'opérateur + : https://www.w3schools.com/python/gloss_python_string_concatenation.asp

Le 26 octobre 2021 à 12:03:08 :
Oublie la variable globale, t'étais sur la bonne piste avec tes print.

Tu veux renvoyer une chaîne de caractères, pas un entier, donc tes deux cas de base vont plutôt être return "0" et return "1". Ensuite pour le cas récursif, tu as decToBin2(n//2) qui est une chaîne de caractères contenant tous les chiffres binaires sauf le dernier. Tu veux y rajouter le dernier chiffre et renvoyer le résultat. En python tu peux concaténer des chaînes de caractère avec l'opérateur + : https://www.w3schools.com/python/gloss_python_string_concatenation.asp

Salut !

Je ne comprends pas, le decToBin2(n//2) normalement il rappelle juste la fonction avec le nombre n initial divisé par 2 non? Je ne suis pas censé renvoyé le n%2 pour avoir uniquement des 0 et des 1?

Je rame un peu je n'arrive pas du tout à comprendre comment je peux transformer ça en chaîne de caractère, j'ai essayé de mettre en application ce que tu m'as dis, je n'y suis pas du tout mais j'en suis à ça :

def decToBin2(n):
    if n == 1:
        return "1"
    elif n == 0:
        return "0"
    else:
        decToBin2(n//2)
        print(n%2)

Le premier chiffre du nombre binaire ne s'affiche pas, et je me sens tout de même forcé d'utiliser un print pour le n%2, je ne vois pas où est-ce que je dois concaténer... désolé d'un peu peiner à comprendre

désolé d'un peu peiner à comprendre

Et moi désolé de peiner à expliquer !

Ta fonction decToBin2(n) prend en entrée un entier n et renvoie une chaîne de caractères qui contient son écriture binaire. Donc quand tu fais ton appel récursif « decToBin2(n//2) », tu obtiens une chaîne de caractères qui contient l'écriture binaire de n//2. Ce qu'il te reste à faire, c'est y rajouter (concaténer) le dernier chiffre, qui est n%2. Et enfin tu veux renvoyer (avec return), et non pas afficher (avec print) le résultat.

Indice 1 : SpoilAfficherMasquern%2 est un nombre, pour pouvoir le concaténer avec une chaîne de caractères, il faut le convertir en faisant : str(n%2)

Indice 2 :

def decToBin2(n):
    if n == 1:
        return "1"
    elif n == 0:
        return "0"
    else:
        return (... + ...)

Le 26 octobre 2021 à 20:22:18 :

désolé d'un peu peiner à comprendre

Et moi désolé de peiner à expliquer !

Ta fonction decToBin2(n) prend en entrée un entier n et renvoie une chaîne de caractères qui contient son écriture binaire. Donc quand tu fais ton appel récursif « decToBin2(n//2) », tu obtiens une chaîne de caractères qui contient l'écriture binaire de n//2. Ce qu'il te reste à faire, c'est y rajouter (concaténer) le dernier chiffre, qui est n%2. Et enfin tu veux renvoyer (avec return), et non pas afficher (avec print) le résultat.

Indice 1 : SpoilAfficherMasquern%2 est un nombre, pour pouvoir le concaténer avec une chaîne de caractères, il faut le convertir en faisant : str(n%2)

Indice 2 :

SpoilAfficherMasquer

La réponse ressemble à ça:

def decToBin2(n):
    if n == 1:
        return "1"
    elif n == 0:
        return "0"
    else:
        return (... + ...)

Aaahhhh okkkk je comprends beaucoup mieux. Donc si je venais à schématiser l'exécution ça donnerait ceci (corrige moi si besoin) :

Lors de la descente :            Lors de la montée :

decToBin(77)                     1001101
decToBin(38)                     100110
...                              ...
decToBin(2)                      10
decToBin(1) -------------- >     1

Donc on va effectuer la récursivité jusqu'à atteindre notre condition terminale, à savoir ici pour n == 1, on affiche le 1 qui sera notre premier bit, et ensuite on remonte au fur et à mesure en concaténant la valeur de n%2 (avec n la nouvelle valeur issue de l'appel récursif n//2) sous forme de chaîne de caractère. C'est bien ça ? Je m'assure d'avoir bien compris

Le 26 octobre 2021 à 20:29:41 :
SpoilAfficherMasquerdef decTobin2(n): if n == 1: return "1" elif n == 0: return "0" else: return decTobin2(n // 2) + decTobin2(n % 2)

Salut !

Merci beaucoup pour ton aide, j'ai tout de même essayé de comprendre par moi même

Le 26 octobre 2021 à 21:02:38 :

Le 26 octobre 2021 à 20:22:18 :

désolé d'un peu peiner à comprendre

Et moi désolé de peiner à expliquer !

Ta fonction decToBin2(n) prend en entrée un entier n et renvoie une chaîne de caractères qui contient son écriture binaire. Donc quand tu fais ton appel récursif « decToBin2(n//2) », tu obtiens une chaîne de caractères qui contient l'écriture binaire de n//2. Ce qu'il te reste à faire, c'est y rajouter (concaténer) le dernier chiffre, qui est n%2. Et enfin tu veux renvoyer (avec return), et non pas afficher (avec print) le résultat.

Indice 1 : SpoilAfficherMasquern%2 est un nombre, pour pouvoir le concaténer avec une chaîne de caractères, il faut le convertir en faisant : str(n%2)

Indice 2 :

SpoilAfficherMasquer

La réponse ressemble à ça:

def decToBin2(n):
    if n == 1:
        return "1"
    elif n == 0:
        return "0"
    else:
        return (... + ...)

Aaahhhh okkkk je comprends beaucoup mieux. Donc si je venais à schématiser l'exécution ça donnerait ceci (corrige moi si besoin) :

Lors de la descente :            Lors de la montée :

decToBin(77)                     1001101
decToBin(38)                     100110
...                              ...
decToBin(2)                      10
decToBin(1) -------------- >     1

Donc on va effectuer la récursivité jusqu'à atteindre notre condition terminale, à savoir ici pour n == 1, on affiche le 1 qui sera notre premier bit, et ensuite on remonte au fur et à mesure en concaténant la valeur de n%2 (avec n la nouvelle valeur issue de l'appel récursif n//2) sous forme de chaîne de caractère. C'est bien ça ? Je m'assure d'avoir bien compris

Oui c'est tout bon.

Une astuce pour les programmes récursifs, t'es pas obligé de dérouler toute la "descente" et toute la "montée" dans ta tête pour comprendre ce que fait le programme. Si tu connais le raisonnement par récurrence (ça doit être au programme de maths en terminale, je suppose), c'est le même principe :

Je cherche à savoir ce que renvoie decToBin(77), je regarde le code, et je vois qu'il va renvoyer decTobin2(38)+"1". En supposant que ma fonction « decToBin2 » est correcte, je sais que decToBin2(38) va renvoyer la chaîne "100110". Du coup en concaténant "1" à la fin, j'obtiens "1001101". Et si j'ai le droit de faire cette supposition, c'est parce que j'ai vérifié que les deux cas de base sont corrects.