Python 递归与迭代

Question

I can't find the error in my code. It runs just fine on my cmd but won't pass the lab platform tests. Here is the question:

You need to design an iterative and a recursive function called replicate_iter and replicate_recur respectively which will receive two arguments: times which is the number of times to repeat and data which is the number or string to be repeated.

The function should return an array containing repetitions of the data argument. For instance, replicate_recur(3, 5) or replicate_iter(3,5) should return [5,5,5] . If the times argument is negative or zero, return an empty array. If the argument is invalid, raise a ValueError ."

Now here is my code:

my_list1 = []
my_list2 = []
   def replicate_iter(times,data):
      try:
        if type(data) != int and type(data) != str:
          raise ValueError('Invalid Argument')
        times += 0
          if times > 0:
            x = 0
            while x < times:
            my_list2.append(data)
            x = x+1
           return my_list2
         else:
          return []
    except (ValueError,AttributeError,TypeError):
        raise ValueError('Invalid Argument')

def replicate_recur(times,data):
    try:
        if type(data) != int and type(data) != str:
          raise ValueError('Invalid Argument')
        times += 0
        if times <= 0:
          return my_list1
        else:
          my_list1.append(data)
          return replicate_recur(times-1,data)
    except(AttributeError,TypeError):
        raise ValueError('Invalid Argument')

Answer 1

This works!

def replicate_iter(times, data):
    if((not isinstance(times, int)) or (not isinstance(data, (int, float, long, complex, str)))):
            raise ValueError("Invalid arguments")
    elif(times <= 0):
            return []
    else:
            array = []
            for x in range(times):
                    array.append(data)
            return array


def replicate_recur(times, data):
    if((not isinstance(times, int)) or (not isinstance(data, (int, float, long, complex, str)))):
            raise ValueError("Invalid arguments")
    elif(times <= 0):
            return []
    else:
            return ([data] + replicate_recur((times - 1), data))        

Answer 2

def replicate(c,times):
    return [c]*times

def replicate2(c,times):
    return [c for i in range(times)]

def replicate3(c,times):
    result = []
    for i in range(times): result.append(c)
    return result

def replicate4(c,times):
    return [c] + (replicate4(c,times-1) if times > 0 else [])

Answer 3

Basic implementation for both (although they are not good Python to be honest) would be:

def replicate_iter(times, data):
    result = []
    for _ in range(times):  # xrange in Python2
        result.append(data)
    return result


def replicate_recur(times, data):
    if times <= 0:
        return []
    return [data] + replicate_recur(times - 1, data)


assert replicate_iter(3, 5) == [5, 5, 5]
assert replicate_recur(3, 5) == [5, 5, 5]
assert replicate_iter(4, "abc") == ["abc", "abc", "abc", "abc"]
assert replicate_recur(4, "abc") == ["abc", "abc", "abc", "abc"]

They are simple, straightforward and shows basic differences between both approaches.

Pythonic code would either use multiplying a sequence or list comprehension:

result = [data for _ in range(times)]
result = [data] * times

Recursion wouldn't really be used for this task in any production code.

Answer 4

I think your code is closer to being correct than other folks are saying -- you just need to rearrange some elements:

def replicate_iter(times, data):
    if type(data) != int and type(data) != str:
        raise TypeError('Invalid Argument')

    try:
        my_list = []

        if times > 0:
            for _ in range(times):
                my_list.append(data)

        return my_list

    except (ValueError, TypeError):
        raise ValueError('Invalid Argument') from None

def replicate_recur(times, data):
    if type(data) != int and type(data) != str:
        raise TypeError('Invalid Argument')

    try:
        my_list = []

        if times > 0:
            my_list.append(data)
            my_list.extend(replicate_recur(times - 1, data))

        return my_list

    except (ValueError, TypeError):
        raise ValueError('Invalid Argument') from None

I agree the error handling is a bit complicated but that's what the specification called for. Though specific about the times argument, the specification was ambiguous about which error to generate if the data isn't one of the accepted types, but TypeError seems to make sense.

Answer 5

for the recursive version I recommend tail recursion as you are already doing, the other examples even if simplest use list concatenation ( + ) which produce a new list with a copy of the elements of each, that is too much waste of time and space when you can pass around a single list where you add elements to it as you do with a iterative version

here is a example

def replicate_recur(times, data, result=None):
    if result is None:
        result = []
    if times <= 0 :
        return result
    else:
        result.append(data)
        return replicate_recur(times-1,data,result)

Additionally, you can avoid repeat the same check over and over again by using an auxiliary function

def replicate_recur_aux(times, data, result):
    if times <= 0 :
        return result
    else:
        result.append(data)
        return replicate_recur_aux(times-1,data,result)  

def replicate_recur(times, data):
    if not isinstance(data, int) and not isinstance(data, str):
        raise ValueError('Invalid Argument')
    return replicate_recur_aux(times,data,[])

this way the main function do all the check that needs to be done and all the necessary setup just once so the auxiliary function do its job without any worry or unnecessary checks of the same thing.

For the iterative version, any of the other examples are good, but maybe your teacher want something like this

def replicate_iter(times, data):
    if not isinstance(data, int) and not isinstance(data, str):
        raise ValueError('Invalid Argument')
    result = []
    if times <=0:
        return result
    for i in range(times):
        result.append(data)
    return result

now notice the similarity between both version, you can easy transform one into the other

Answer 6

I think the iterative version is straightforward, and others have provided good answers. As for the recursion, I always like to see if I can come up with a divide and conquer strategy rather than whittle the problem down one step at a time, to avoid blowing out the stack. The following does that:

def replicate_recur(times, data):
    def f(n, value):
        if n < 1:
            return [] 
        result = f(n // 2, value) * 2
        if n % 2 > 0:
            result += [value] 
        return result

    if not isinstance(data, int) and not isinstance(data, str):
        raise ValueError('Must be int or str')
    return f(times, data)

This uses an internal recursive function f() to avoid repeating the type checking for data . The recursion constructs a list of half the size, and either doubles it (if the current n is even) or doubles it and adds one more occurrence of data (if the current n is odd).

Try it, you'll like it!

Answer 7

I tried this and it worked for that test!

def replicate_iter(times,data):
    Array = []
    if type(times) != int or not isinstance(data, (int, float, complex, str)):
        raise ValueError ('Invalid Value')
    elif times < 0:
        return []
    else:
        for x in range (times):
            Array.append(data)
        return Array


def replicate_recur(times,data):
    Array = []
    if type(times) != int or not isinstance(data, (int, float, complex, str)):
        raise ValueError ('Invalid Value')
    elif times <= 0:
        return []
    else:
       Array = replicate_recur(times-1,data)
       Array.append(data)
    return Array

Answer 8

def replicate_iter(times, data):
    if not isinstance(data, int) and not isinstance(data, str):
        raise ValueError('Must be int or str')
    if times <= 0:
        return []
    return [data for _ in range(times)]

def replicate_recur(times, data):
    if not isinstance(data, int) and not isinstance(data, str):
        raise ValueError('Must be int or str')
    if times <= 0:
        return []
    return [data] + replicate_recur(times-1, data)

Output

>>> replicate_iter(3, 5)
[5, 5, 5]

>>> replicate_recur(3, 5)
[5, 5, 5]

Edge cases

>>> replicate_iter(0, 5)
[]

>>> replicate_iter(3, list())
Traceback (most recent call last):
  File "<pyshell#2>", line 1, in <module>
    replicate_iter(3, list())
  File "C:/temp/temp.py", line 3, in replicate_iter
    raise ValueError('Must be int or str')
ValueError: Must be int or str