递归倒三角形

Question

I'm supposed to create a recursive statement that if first calls triangle(n) it returns

'******\n *****\n ****\n ***\n **\n *'

This above is called for triangle(6) and if I print(triangle(6)) it returns below.

******
 *****
  ****
   ***
    **
     *

Then I must create another code recursive_triangle(x, n) that returns a string with the LAST x lines of a right triangle of base and height n. For example if I did recursive_triangle(3, 6) it returns

'   ***\n    **\n     *'

and if i print it should returns

***
 ** 
  *

So far my code is

#### DO NOT modify the triangle(n) function in any way! 
def triangle(n):
    return recursive_triangle(n, n)
###################


def recursive_triangle(k, n=0):
    '''
    Takes two integers k and n
    >>> recursive_triangle(2,4)
    '  **\\n   *'
    >>> print(recursive_triangle(2,4))
      **
       *
    >>> triangle(4)
    '****\\n ***\\n  **\\n   *'
    >>> print(triangle(4))
    ****
     ***
      **
       *
'''
    # --- YOUR CODE STARTS HERE
    if n == 1:
        return "*"


    else:
        for i in range(1, n+1):
            return ("*" *n) + "\n" + (' ' * i) + triangle (n - 1)

for print(triangle(4)) this is what i got

****
 ***
 **
 *

How do I modify the code to get the output above?

Answer 1

Your recursion case is ill-formed:

else:
    for i in range(1, n+1):
        return ("*" *n) + "\n" + (' ' * i) + triangle (n - 1)

First of all, this code returns after a single iteration: return ends your function instance, so i never gets to a value of 2. You need to do something simple, and then recur on a simpler case to handle the rest.

Next, triangle exists only to call recursive_triangle . Then, recursive_triangle needs to call itself , not loop back to triangle .

Finally, note that recursive_triangle utterly ignores the parameter k . This value is critical to determine where in the line to place the asterisks.

Each instance of recursive_triangle should produce a single line of the triangle -- you have that correct -- and then concatenate that line with the remainder of the triangle, returning that concatenated whole to the instance that called it. You'll want something roughly like:

else:
    line = ... # build a line of k-n spaces and n asterisks
    return line + recursive_triangle(k, n-1)

Can you take it from there? Among other things, remember to insert a few useful print commands to trace your execution flow and the values you generate.

Answer 2

First of all, there are better ways to achieve this. However, if you really want to go this way, the following code can fix the spacing issues.

#### DO NOT modify the triangle(n) function in any way! 
def triangle(n):
    return recursive_triangle(n, n)
###################


def recursive_triangle(k, n=0):
    '''
    Takes two integers k and n
    >>> recursive_triangle(2,4)
    '  **\\n   *'
    >>> print(recursive_triangle(2,4))
      **
       *
    >>> triangle(4)
    '****\\n ***\\n  **\\n   *'
    >>> print(triangle(4))
    ****
     ***
      **
       *
'''
    # --- YOUR CODE STARTS HERE
    if n == 1:
        return "*"


    else:
        for i in range(1, n+1):
            return ("*" *n) + "\n" + (' ' * i) + triangle (n - 1).replace("\n", "\n ")

which gives you

****
 ***
  **
   *

in Python 3.6.5.

Answer 3

You can count the row with r and use a secondary parameter to count the spaces, s

def triangle (r = 0, s = 0):
  if r is 0:
    return ""
  else:
    return (" " * s) + ("*" * r) + "\n" + triangle (r - 1, s + 1)

print (triangle(5))
# *****
#  ****
#   ***
#    **
#     *

Answer 4

code.py :

#!/usr/bin/env python3

import sys


#### DO NOT modify the triangle(n) function in any way! 
def triangle(n):
    return recursive_triangle(n, n)
###################


def recursive_triangle(k, n=0):
    '''
    Takes two integers k and n
    >>> recursive_triangle(2,4)
    '  **\\n   *'
    >>> print(recursive_triangle(2,4))
      **
       *
    >>> triangle(4)
    '****\\n ***\\n  **\\n   *'
    >>> print(triangle(4))
    ****
     ***
      **
       *
    '''
    # --- YOUR CODE STARTS HERE

    if k == 0:
        return ""
    else:
        return "\n".join(["".join([" " * (n - k), "*" * k]), recursive_triangle(k - 1, n)])
        #return " " * (n - k) + "*" * k + "\n" + recursive_triangle(k - 1, n)


def main():
    print("triangle(6):\n{:s}".format(triangle(6)))
    print("recursive_triangle(3, 6):\n{:s}".format(recursive_triangle(3, 6)))
    print("repr recursive_triangle(2, 4): {:s}".format(repr(recursive_triangle(2, 4))))
    print("repr triangle(4): {:s}".format(repr(triangle(4))))


if __name__ == "__main__":
    print("Python {:s} on {:s}\n".format(sys.version, sys.platform))
    main()

Notes :

• To make things simpler, you can look at recursive_triangle(k, n) 's argument meanings like:
  • k : Recursion step, and also the number of " * " characters. Decrements with every recursive function call
  • n : 1 ^st (longest) triangle line length (the number of SPACE s + k ). Remains constant inside recursion
• Current line contains n - k SPACE s followed by k " * " s ( n characters in total). Lines are joined together via [Python 3]: str. join ( iterable ) (or "manually", in the (next) commented line)
• The function calls itself until there are no more "*" characters ( k becomes 0 )

Output :

 (py35x64_test) e:\\Work\\Dev\\StackOverflow\\q052652407>"e:\\Work\\Dev\\VEnvs\\py35x64_test\\Scripts\\python.exe" code.py Python 3.5.4 (v3.5.4:3f56838, Aug 8 2017, 02:17:05) [MSC v.1900 64 bit (AMD64)] on win32 triangle(6): ****** ***** **** *** ** * recursive_triangle(3, 6): *** ** * repr recursive_triangle(2, 4): ' **\\n *\\n' repr triangle(4): '****\\n ***\\n **\\n *\\n'