Bonjour, je vous demande de l'aide aujourd'hui car je n'arrive pas a créer le programme suivant :
def espacer(mot, intermediaire, n):
def espacer(mot, intermediaire, n):
"""
mot -- chaine de caractères
précondition: mot est constitué uniquement de lettres de l'alphabet,
minuscules et sans accent.
intermediaire -- chaîne de caractères
n -- entier naturel (type int)
renvoie une chaîne constituée d'une copie de mot dans lequel n copies de intermediaire
se sont glissées entre chaque couple de caractères de mot.
>>> espacer('nsi', 'x', 2)
'nxxsxxi'
>>> espacer('coucou', ' ', 1)
'c o u c o u'
>>> espacer('a', 'y', 2)
'a'
>>> espacer('zou', 'ba', 3)
'zbababaobababau'
"""
pass
malgré plusieurs heures passées je n'y arrive pas si quelqu'un pouvait m'aider ça serait sympa =) merci d'avance
Déjà il faut faire une boucle pour balayer chaque caractère de mot et fabriquer une autre chaîne de caractères contenant le caractère suivi de n fois intermédiaire. La difficulté étant de gérer le dernier caractère (il n'est pas intermédiare... donc on ne met rien après).
le problème c'est que ça rend "t**e**s**t**" pour t('test') alors que je voudrais que ça rende "t**e**s**t"
l'autre problème va être d'utiliser les deux autres variables dans la fonction de départ
def t(chaine):
alphabet = "abcdefghijklmnopqrstuvwxyz"
mot2 =''
for i in chaine:
mot2 = mot2 + i + '**'
for lettre in chaine:
if lettre in alphabet:
return(mot2)
else:
return('erreur')
- Edité par ArcLeretour 15 octobre 2021 à 14:39:16
j'ai le droit d'utiliser que les fonction apprises en cours x) sinon ça serais bien plus facile
consigne :
Il existe des fonctions spéciales en python comme la fonction replace qui font une partie du travail demandé dans les scripts. L’usage de telles fonctions est strictement interdit. Vous n’avez droit qu’à ce qui a déjà été rappelé dans les cours depuis le début de l’année. Il s’agit en effet d’un travail vous permettant d’apprendre la programmation élémentaire et non de chercher à maîtriser la documentation python et votre capacité à utiliser des “boîtes noires”.
Remarque: ce travail d’utilisation de fonctions et bibliothèques déjà existantes est également un travail important dans l’apprentissage de la programmation, mais ce n’est pas l’objectif visé ici.
Le code Python utilisé pour définir vos fonctions doit obligatoirement se limiter à ce que l'on trouve dans le cours.
- Edité par ArcLeretour 15 octobre 2021 à 15:31:31
sortie = "" for c in mot: if sortie != "": sortie += intermediaire*n sortie += c return sortie
Tu vas tester (le if) la valeur de ton drapeau sortie alors qu'il est différent de la chaîne vide dès la première" étape, autrement dit ce if ne sert quasiment à rien.
ArcLeretour a écrit:
j'ai le droit d'utiliser que les fonction apprises en cours x) sinon ça serais bien plus facile
Oui, ça se fait de manière très élémentaire si tu as été préparé pour ça (ce qui nécessite en fait plusieurs semaines programmation pour avoir les bons réflexes).
L'idée est très simple : si N est la longueur de mot, tu boucles N-1 fois. Et à une chaîne initialement vide tu rajoutes le caractère courant suivi de n*intermediaire (ce schéma est décrit ici). En sortie de boucle, tu rajoutes le dernier caractère. L'énoncé ne semble pas dire ce qui est attendu lorsque mot est la chaîne vide (en principe ça devrait être la chaîne vide).
Ce n'est pas la manière pythonique de faire mais ce n'est pas ce qui est demandé.
Ma variable sortie n'est pas un flag, c'est la chaîne qui cumule le résultat. Je teste pour éviter d'insérer la chaîne intermédiaire au début.
Ceci devrait satisfaire les exigences:
def espace(mot, intermediaire, n): lg = len(mot) sortie = "" for i in range(lg-1): sortie += mot[i] for j in range(n): sortie += intermediaire sortie += mot[lg-1] return sortie
C'est plus pythonique?
return str(intermediaire * n).join(list(mot))
- Edité par PierrotLeFou 15 octobre 2021 à 18:19:33
Le Tout est souvent plus grand que la somme de ses parties.
Ma variable sortie n'est pas un flag, c'est la chaîne qui cumule le résultat.
Oui mais tu l'utilises comme un flag puisque sa non-valeur te permet de surveiller un état.
PierrotLeFou a écrit:
def espace(mot, intermediaire, n): lg = len(mot) sortie = "" for i in range(lg-1): sortie += mot[i] for j in range(n): sortie += intermediaire sortie += mot[lg-1] return sortie
C'est plus pythonique?
return str(intermediaire * n).join(list(mot))
Oui, c'est bien à ton premier code que je pensais. Pour le 2e c'est sans doute la façon pythonique de faire (mais pourquoi str et pourquoi list ?)
Mais bon maintenant seconde difficulté l'exercice 3 x)
énoncé :
def double_voyelle(mot):
"""
mot -- chaine de caractères
précondition: mot est constitué uniquement de lettres de l'alphabet,
minuscules et sans accent.
renvoie une chaine dans laquelle toutes les voyelles de mot ont été doublées
sauf si la voyelle se trouve en fin de mot
ou s'il s'agit d'un 'e' suivi d'un 'n'.
>>> double_voyelle('enduire')
'enduuiire'
>>> double_voyelle('ordinateur')
'oordiinaateeuur'
>>> double_voyelle('nsi')
'nsi'
>>> double_voyelle('lenteur')
'lenteeuur'
"""
pass
mon début de programme :
def t(mot):
voyelle = "aeiouy"
for lettres in mot:
if lettres in voyelle:
lettres = lettres * 2
print(lettres)
else:
print('x-x')
- Edité par ArcLeretour 16 octobre 2021 à 11:21:43
Mais bon maintenant seconde difficulté l'exercice 3 x)
C'est toujours un peu la même chose: une chaîne de caractères au départ, une autre chaîne de caractères à l'arrivée, une difficulté pour la gestion du dernier caractère: la structure du code devrait être semblable et si vous avez compris comment faire l'exercice précédent, çà ne devrait pas poser de problème.
Yes mon seul problème reste de ne pas doubler la dernière lettre
mon programme :
def t(mot):
voyelle = "aeiouy"
e="e"
n="n"
r = ""
l_prec=""
r_prec=""
for lettres in mot:
if lettres in voyelle:
r_prec = r + lettres
r = r + lettres *2
l_prec=lettres
else:
if l_prec==e and lettres==n:
r = r_prec
r = r + lettres
return r
J'ai proposé du code avec range, tu peux regarder de ce côté. Tu ajoutes le dernier élément hors de la boucle.
Absolument, c'est beaucoup moins sujet à erreur que de faire les contorsions qu'impose le parcours sans indice (on pourrait utiliser enumerate mais le bénéfice serait faible). Sinon, bon exercice, un peu difficile pour la 1re je trouve.
- Edité par PascalOrtiz 16 octobre 2021 à 15:24:22
def t(mot):
voyelle = "aeiouy"
e="e"
n="n"
r = ""
l_prec=""
r_prec=""
compteur=""
for lettres in mot:
compteur+=lettres
if compteur==mot:
r = r + lettres
else:
if lettres in voyelle:
r_prec = r + lettres
r = r + lettres *2
l_prec=lettres
else:
if l_prec==e and lettres==n:
r = r_prec
r = r + lettres
return r
sauf que je bloque sur le dernier exercice
consigne :
def substitue_o_ou(mot):
"""
mot -- chaine de caractères
précondition: mot est constitué uniquement de lettres de l'alphabet,
minuscules et sans accent.
renvoie une chaîne copie de mot mais dans laquelle les 'o' sont remplacés par 'ou',
sauf lorsque 'o' est suivi de 'u': dans ce cas, on remplace 'ou' par 'o'.
>>> substitue_o_ou('loup')
'lop'
>>> substitue_o_ou('zozo')
'zouzou'
>>> substitue_o_ou('bou')
'bo'
>>> substitue_o_ou('oo')
'ouou'
>>> substitue_o_ou('ouou')
'oo'
>>> substitue_o_ou('ououo')
'ooou'
>>> substitue_o_ou('uoou')
'uouo'
"""
pass
mon code :
def t(mot):
o="o"
u="u"
r=""
l_prec = ""
for lettres in mot:
if lettres!=o:
r = r + lettres
print(r)
l_prec = lettres
else:
if lettres==u and l_prec==o:
r = r - u
else:
r = r + lettres + u
print(r)
return(r)
je n'arrive pas à faire que lorsque il y a "ou" ça ne renvoie que "o"
- Edité par ArcLeretour 17 octobre 2021 à 11:26:53
def t(mot):
voyelle = "aeiouy"
e="e"
n="n"
r = ""
l_prec=""
r_prec=""
compteur=""
for lettres in mot:
compteur+=lettres
if compteur==mot:
r = r + lettres
else:
if lettres in voyelle:
r_prec = r + lettres
r = r + lettres *2
l_prec=lettres
else:
if l_prec==e and lettres==n:
r = r_prec
r = r + lettres
return r
Non, ça ne marche pas, ton code transforme python en pyythoon au lieu de pyython.
ArcLeretour a écrit:
sauf que je bloque sur le dernier exercice
consigne :
def substitue_o_ou(mot):
"""
mot -- chaine de caractères
précondition: mot est constitué uniquement de lettres de l'alphabet,
minuscules et sans accent.
renvoie une chaîne copie de mot mais dans laquelle les 'o' sont remplacés par 'ou',
sauf lorsque 'o' est suivi de 'u': dans ce cas, on remplace 'ou' par 'o'.
>>> substitue_o_ou('loup')
'lop'
>>> substitue_o_ou('zozo')
'zouzou'
>>> substitue_o_ou('bou')
'bo'
>>> substitue_o_ou('oo')
'ouou'
>>> substitue_o_ou('ouou')
'oo'
>>> substitue_o_ou('ououo')
'ooou'
>>> substitue_o_ou('uoou')
'uouo'
"""
pass
mon code :
def t(mot):
o="o"
u="u"
r=""
l_prec = ""
for lettres in mot:
if lettres!=o:
r = r + lettres
print(r)
l_prec = lettres
else:
if lettres==u and l_prec==o:
r = r - u
else:
r = r + lettres + u
print(r)
return(r)
Celui-là est moins simple et je ne le trouve pas évident pour un exercice de 1re à moins que vous ayez déjà fait 20 heures de TP encadrés de Python depuis la rentrée. Je l'ai incorporé à mes exercices, ICI.
Je pense que c'est une complication inutile de ne pas parcourir avec un indice car à chaque position, on a besoin de savoir ce qui se passe à la position juste après. Personnellement, je te conseille d'utiliser la technique du drapeau (c'est primitif mais efficace : c'est une variable ça sert à mémoriser un état qui évolue et qu'on a besoin de consulter) que l'on pourrait appeler ou, qui initialement est à False et qui bascule à la valeur True chaque fois que la lettre lue pendant le parcours vaut o et qu'elle est suivie d'un u (ne pas oublier de replacer le drapeau à son état initial lorsque l'état évolue).
Pour info, la fonction à écrire est équivalente à :
seul problème, c'est que j'ai pas le droit d'utiliser replace
Je sais bien, comme indiqué, c'était pour info, ça aide par exemple à vérifier des tests.
De toute façon ton code
ArcLeretour a écrit:
mon code :
def t(mot):
o="o"
u="u"
r=""
l_prec = ""
for lettres in mot:
if lettres!=o:
r = r + lettres
print(r)
l_prec = lettres
else:
if lettres==u and l_prec==o:
r = r - u
else:
r = r + lettres + u
print(r)
return(r)
contient plusieurs anomalies. Par exemple, r = r - u va planter si le code passe à cette ligne car la différence de deux chaînes n'existe pas :
>>> "coucou"-"u"
50
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
TypeError: unsupported operand type(s) for -: 'str' and 'str'
>>>
Et tu devrais justement te poser la question de pourquoi ton code ne passe pas à cette ligne.
EDIT. Finalement, c'est gérable de le faire sans indice, voire donne un code plus court, ton truc l_prec = "" marche bien.
- Edité par PascalOrtiz 17 octobre 2021 à 19:16:13
L'exercice m'a intrigué. C'est moins évident qu'il n'y parait. Voici mon essai: - def substitue_o_ou(mot): sortie = "" p = "" for c in mot: if p == "o" and c == "u": sortie += p p = "" elif p == "o" and c != "u": sortie += "ou" p = c else: sortie +=p p = c if p=="o": p+="u" sortie += p return sortie for m in ["loup", "zozo", "bou", "oo", "ouou", "ououo", "do"]: print(m, substitue_o_ou(m)) - loup lop zozo zouzou bou bo oo ouou ouou oo ououo ooou do dou
Le Tout est souvent plus grand que la somme de ses parties.
Maintenant que tu as vendu la mèche , voici mes versions (avec indice, sans indice, récursive) :
def f2(mot):
r=""
prv = ""
for c in mot:
if prv=="o":
if c!="u":
r+='u'+c
else:
r+=c
prv=c
if prv=="o":
r+="u"
return r
def f3(mot):
def h(mot, i):
if i==0:
return mot[0]
if mot[i-1]=="o":
if mot[i]!="u":
return h(mot, i-1)+"u"+mot[i]
else:
return h(mot, i-1)
else:
return h(mot, i-1)+mot[i]
r=h(mot, len(mot)-1)
if mot[-1]=='o':
r+="u"
return r
def f1(mot):
r=''
ou=False
n=len(mot)
for i in range(n):
if not ou:
r+=mot[i]
if mot[i]=="o":
if i==n-1 or mot[i+1]!='u':
r+='u'
else:
ou=True
else:
ou=False
return r
def ok(mot):
return mot.replace("ou", "*").replace("o", "ou").replace("*", "o")
for mot in (("o", "u", "nounou", 'dodo', 'loup', "zozo", "bou", 'oo', 'ouou', 'do','ououo', 'uoou')):
print(mot, ":", ok(mot)== f1(mot)== f2(mot)== f3(mot))
× Après avoir cliqué sur "Répondre" vous serez invité à vous connecter pour que votre message soit publié.
× Attention, ce sujet est très ancien. Le déterrer n'est pas forcément approprié. Nous te conseillons de créer un nouveau sujet pour poser ta question.
Le Tout est souvent plus grand que la somme de ses parties.
Découverte Python Doc Tkinter Les chaînes de caractères
Le Tout est souvent plus grand que la somme de ses parties.
Découverte Python Doc Tkinter Les chaînes de caractères
Le Tout est souvent plus grand que la somme de ses parties.
Le Tout est souvent plus grand que la somme de ses parties.
Découverte Python Doc Tkinter Les chaînes de caractères
Découverte Python Doc Tkinter Les chaînes de caractères
Découverte Python Doc Tkinter Les chaînes de caractères
Le Tout est souvent plus grand que la somme de ses parties.
Découverte Python Doc Tkinter Les chaînes de caractères