web-dev-qa-db-fra.com

Imprimer récursivement la pyramide des nombres

Je dois imprimer une pyramide de nombres avec cette règle:

index impair: 1 à indexer, même index: index à 1:

1
21
123
4321
12345
654321
1234567
87654321
123456789

J'ai écrit ce code:

def printFigure(rows):
    if rows > 0:
        if rows%2 == 0:
            printFigure(rows-1)
            while(rows>0):
                print(str(rows)[::-1], end = '')
                rows -= 1
            print('')

        if rows%2 == 1:
            printFigure(rows-1)
            while (rows>0):
                print(str(rows),end = '')
                rows -= 1
            print('')

mais le résultat est:

1
21
321,
4321
54321
654321
7654321
87654321
987654321

Je suis un débutant avec la récursion, je serai ravi de vos explications aussi . Merci.

pythonrecursion
5
Benjamin Yakobi

Vous avez deux problèmes majeurs avec votre code actuel. Premièrement, il faut vérifier si rows est pair ou impair après l'appel récursif à printFigure. La raison en est que c'est après le retrait de l'appel récursif que vous voulez décider d'imprimer la ligne dans l'ordre ou à l'envers.

Le deuxième problème était lié à la logique dans la condition d'impression else. Vous devez imprimer à partir de 1, jusqu’au nombre de lignes. J'ai utilisé une variable muette pour y parvenir, bien qu'il existe probablement plusieurs autres moyens de le faire.

def printFigure(rows):
    if rows > 0:
        printFigure(rows-1)
        if rows%2 == 0:
            while(rows>0):
                print(str(rows)[::-1], end='')
                rows -= 1
            print('')
        else:
            i = 1
            while (i <= rows):
                print(str(i), end='')
                i += 1
            print('')

printFigure(9)

1
21
123
4321
12345
654321
1234567
87654321
123456789
4
Tim Biegeleisen

si vous n'avez pas besoin de recourir à la récursion, une autre solution simple est

def printFigure(rows): 
    for x in range(rows): 
        items = [str(i) for i in range(1, x + 1)] 
        if x % 2 == 0: 
            items = items[::-1] 
        print(''.join(items))
3
Bear Brown

Vous pouvez utiliser une fonction interne qui imprime de bas en haut et appeler cette fonction depuis une fonction externe, par exemple:

def print_rows(n, limit):
    if n < limit:
        numbers = range(1, n + 1) if n % 2 == 1 else reversed(range(1, n + 1))
        print(''.join(map(str, numbers)))
        print_rows(n + 1, limit)


def print_pyramid_recursive(n):
    if n > 0:
        print_rows(1, n)


print_pyramid_recursive(10)

Sortie 

1
21
123
4321
12345
654321
1234567
87654321
123456789

Dans ce cas, la fonction interne est print_rows et la fonction externe est print_pyramid_recursive. Notez que ce problème a une solution très simple non-récursive, par exemple:

def print_pyramid(n):
    for i in range(1, n + 1):
        numbers = range(1, i + 1) if i % 2 == 1 else reversed(range(1, i + 1))
        print(''.join(map(str, numbers)))
2
Daniel Mesejo

Voici la version de boucle la plus simple:

is_reversed = False
for i in range(1, 10):
    step = -1 if is_reversed else 1
    print(''.join(map(str, range(1, i + 1)))[::step])
    is_reversed = not is_reversed

Cela régénère une chaîne à chaque itération. Nous pouvons également stocker la valeur du résultat précédent et en tirer parti:

s = ''
is_reversed = False
for i in range(1, 10):
    s += str(i)
    step = -1 if is_reversed else 1
    print(s[::step])
    is_reversed = not is_reversed

Et bien sûr, cela peut facilement (et sans raison) être converti en une fonction queue-récursive en passant simplement par la pile

def f(s, i, max_i, is_reversed):
    if i == max_i:
        return
    s += str(i)
    step = -1 if is_reversed else 1
    print(s[::step])
    is_reversed = not is_reversed
    i += 1
    f(s, i, max_i, is_reversed)

f('', 1, 10, False)

Les résultats pour chacun de ces morceaux de code de plus en plus étranges:

1
21
123
4321
12345
654321
1234567
87654321
123456789
2
Mateen Ulhaq

Vous pouvez utiliser une récursivité simple:

def print_pyramid(_count = 1):
  if _count < 10:
    print((lambda x:x[::-1] if not _count%2 else x)(''.join(map(str, range(1, _count+1)))))
    print_pyramid(_count+1)


print_pyramid()

Sortie:

1
21
123
4321
12345
654321
1234567
87654321
123456789
1
Ajax1234