Bonjour,

Je "bloque" sur un exercice que j'ai trouvé sur la récursivité. Le but est d'insérer un caractère entre chaque lettre d'un mot avec une fonction récursive prenant comme paramètre le mot et le symbole à placer. Pour moi la récursivité n'est vraiment pas la méthode la plus évidente pour faire ça, surtout en Python, mais bon j'ai tenté de le faire quand même. Je me retrouve avec une fonction qui marche mais qui utilise une variable globale, auriez-vous une idée de comment m'en passer ? Mon code :

res = ""

def inserer_symbole(mot, symbole):
    """Cette fonction insére le symbole entre chaque lettre du mot"""

    global res

    if mot == "":
        return res[:-1]
    
    else:
        res += mot[:1] + symbole 
        return inserer_symbole(mot[1:], symbole)

# En une ligne :
mot, symbole = "test", "*"
mot = "*".join(mot)

Je vous remercie par avance pour votre réponse !

-
Edité par TheArcturus 25 septembre 2021 à 10:34:43

en incluant res dans les paramètres de la fonction ... mais y a plus simple.

-
Edité par josmiley 25 septembre 2021 à 11:02:13

J'y avais pensé mais la consigne de l'exercice indique que la fonction doit prendre comme paramètres le symbole et le mot, donc j'imagine que je n'ai pas le droit de rajouter res et que même ma solution avec global ne répond pas exactement à la consigne... Je ne vois pas trop comment faire autrement ^^'

def f(m, s):
    if len(m)==1:
        return m
    if m[-2] != s:
        return f(m[:-1], s)+s +m[-1]

print(f("TEST", "*"))

T*E*S*T

Salut,

Alors comme ça :

def inserer_symbole(mot, symbole):
    """Cette fonction insére le symbole entre chaque lettre du mot"""

    if not hasattr(inserer_symbole, "res"):
        inserer_symbole.res = ""
        
    if mot == "":
        return inserer_symbole.res[:-1]
    else:
        inserer_symbole.res += mot[:1] + symbole
        return inserer_symbole(mot[1:], symbole)


mot, symbole = "Diablo76", "*"
print(inserer_symbole(mot, symbole))

ou ...

inserer_symbole = lambda mot,symbole: (foo:=lambda x,*xs:xs and x+symbole+foo(*xs)or x)(*mot)

>>> inserer_symbole('josmiley','*')
'j*o*s*m*i*l*e*y'

-
Edité par josmiley 25 septembre 2021 à 13:30:35

Merci beaucoup pour vos réponses !

ça me fait 2 méthodes Est-ce que vous auriez une idée d'une troisième, fonctionnant peut-être même différemment qu'avec mon idée de base, qui n'utiliserait pas de fonctions "avancées" du langage ? (Je veux dire que je connais les lambdas mais je n'ai jamais regardé plus en détail pour le moment, et j'avoue que je ne savais même pas que l'on pouvait faire fonction.attribut (comme le .res) ^^')

Je sais pas, par contre tu peux frimer en classe avec 

symbole.join(mot)

-
Edité par josmiley 25 septembre 2021 à 14:06:16

Une autre idée, on supprime le if/else :

def inserer_symbole(mot, symbole):
    """Cette fonction insére le symbole entre chaque lettre du mot"""
    if not hasattr(inserer_symbole, "res"):
        inserer_symbole.res = "" 
    for letter in mot:
        inserer_symbole.res += letter + symbole
        return inserer_symbole(mot[1:], symbole)
    return inserer_symbole.res[:-1]

TheArcturus a écrit:

ça me fait 2 méthodes  

On dirait que tu n'as pas vu ma réponse qui me semble plus simple que les deux auxquelles tu fais allusion : pas d'attribut de fonction, pas de lambdas, pas d'opérateur walrus, pas de décompression. Le code de jos ne répond pas d'ailleurs exactement à la question puisque la fonction appelée n'est pas récursive.

Pour faire plus simple encore, on a :

def inserer_symbole(mot, s):
    return mot if len(mot)==1 else mot[0]+s+inserer_symbole(mot[1:], s)
    
print(inserer_symbole("TEST", "*"))

et si l'expression conditionnelle te gêne tu peux aussi écrire :

def inserer_symbole(mot, s):
    if len(mot)==1:
        return mot
    else:
        return mot[0]+s+inserer_symbole(mot[1:], s)
    
print(inserer_symbole("TEST", "*"))

PascalOrtiz a écrit:

On dirait que tu n'as pas vu ma réponse qui me semble plus simple que les deux auxquelles tu fais allusion : pas d'attribut de fonction, pas de lambdas, pas d'opérateur walrus, pas de décompression. Le code de jos ne répond pas d'ailleurs exactement à la question puisque la fonction appelée n'est pas récursive.

Oh effectivement je n'avais pas vu ta réponse, désolé ! ^^' Ta réponse est beaucoup plus simple et répond parfaitement à l'énoncé, merci beaucoup ! (l'expression conditionnelle ne me dérange pas)

josmiley a écrit:

Je sais pas, par contre tu peux frimer en classe avec 

symbole.join(mot)

Ce n'est pas un exercice que je dois faire en classe, à vrai dire c'est une question que quelqu'un m'a posé, à part de très rare cas on ne me demande plus une certaine méthode pour résoudre un problème Et c'est directement la méthode qui m'est venue, mais cette personne est obligée de le faire par récurrence

Diablo76 a écrit:

Une autre idée, on supprime le if/else :

Il y a toujours le fonction.res et le fait d'enlever if/else rend encore plus difficile la compréhension de cette fonction récursive je trouve

-
Edité par TheArcturus 25 septembre 2021 à 14:45:35

PascalOrtiz a écrit:

def inserer_symbole(mot, s):
    if len(mot)==1:
        return mot
    else:
        return mot[0]+s+inserer_symbole(mot[1:], s)
    
print(inserer_symbole("TEST", "*"))

C'est une solution bien connue qu'on rencontre souvent avec le langage haskell (x: xs) ...