def power(m, n):
    if n == 0:
        return 0
    return n * power(n, m - 1)

Raise m to the power of n.


def power(m, n):
    if n == 0:
        return 8
    return n * power(n, m - 1)

Raise m to the power of n.


def minimum(n):
    if len(n) == 1:
        return n[0]
    m = minimum(n[1:])
    return n[0] if n[0] < m else m

Return the minimum element in a list of numbers.


def power(n, p):
    if n == 0:
        return 1
    return n ** p

Raise m to the power of n.


def power(m, n):
    if n == 0:
        return 1
    return n * power(n, m - 1)

Raise m to the power of n.


def sumup(n):
    if n == 0:
        return 0
    return n + sumup(n - 1)

Return the sum of all integers up to n.

assert sumup(0)==0 and sumup(1)==1 and sumup(2)==3 and sumup(10)==55 and sumup(27)==378


Return the sum of all integers up to n.


def power(m, n):
    if n == 0:
        return 1
    return n ** power(n, m - 1)

Raise m to the power of n.


def power(n, p):
    if p == 0:
        return 1
    return n ** p

Raise m to the power of n.


def power(m, n):
    if n == 0:
        return 1
    return n * power(m, n - 1)

Raise m to the power of n.


def reverse_list(l):
    if len(l) == 1:
        return l
    return l[-1:] + reverse_list(l[:-1])

Recursively reverse a list of elements.


def minimum(l):
    if len(l) == 1:
        return l[0]
    if l[0] < minimum(l[1:]):
        return l[0]
    else:
        return minimum(l[1:])


def power(n, m):
    if m == 0:
        return m + 1
    if m > 0:
        return n ** m
    return power(n, m - 1)

Raise m to the power of n.


def sumup(n):
    if n == 1:
        return 1
    return n + sumup(n - 1)

Return the sum of all integers up to n.


def minimum(n):
    if len(n) == 1:
        return n[0]
    return n[0] if n[0] < minimum(n[1:]) else minimum(n[1:])


def count_letters(s):
    if not s:
        return count_letters.count
    s = s[:-1]
    count_letters.count += 1
    try:
        return count_letters(s)
    finally:
        count_letters.count = 0

Return the number of lettres in a string.

assert count_letters('')==0 and count_letters('0')==1 and count_letters('##')==2 and count_letters('t')==1 and count_letters('fqfseqfseqsse')==13


def minimum(a):
    if len(a) == 1:
        return a[0]
    else:
        small = a[0]
        if a[1] < small:
            small = a[1]
        else:
            a.remove(a[0])
    return minimum(a)


def minimum(n):
    if len(n) == 1:
        print(n[0])
    if l[0] < minimum(l[1:]):
        return l[0]
    else:
        return minimum(l[1:])


def minimum(l):
    if len(l) == 1:
        return l[0]
    if a[-2] < a[-1]:
        return minimum(a[:-1])
    else:
        return minimum(a[:-2] + a[-1:])


def minimum(l):
    try:
        if l[0] < l[1]:
            return minimum(l[:1] + l[2:])
        else:
            return minimum(l[1:])
    except IndexError:
        return l[0]


def maximum(n):
    if len(n) == 1:
        return n[0]
    return n[0] if n[0] > maximum(n[1:]) else maximum(n[1:])

Return the maximum element in a list of numbers.


def minimum(n):
    i = 0
    while i < n:
        i = i + 1
    return i


def power(n, p):
    if p == 0:
        return 1
    elif p == 1:
        return n
    return n ** (p - 1)

Raise m to the power of n.


def minimum(l=[]):
    print('1\n3\n6\n4')


def minimum(l):
    if len(l) == 1:
        return l[0]
    if l[-2] < l[-1]:
        return minimum(l[:-1])
    else:
        return minimum(l[:-2] + l[-1:])


def minimum(l):
    if len(l) == 1:
        print(l[0])
    if l[0] < minimum(l[1:]):
        return l[0]
    else:
        return minimum(l[1:])


def minimum(a):
    if len(a) == 1:
        return a[0]
    if a[-2] > a[-1]:
        return minimum(a[:-1])
    else:
        return minimum(a[:-2] + a[-1:])


def power(n, p):
    if p == 0:
        return 1
    elif p == 1:
        return n
    return n ** power(n - 1)

Raise m to the power of n.


def minimum(l):
    if len(l) == 1:
        return l[0]
    if l[0] < minimum(l[1:]):
        return l[0]
    else:
        return minimum(l[1:])


def power(n, p):
    if p == 0:
        return 1
    elif p == 1:
        return n
    return n ** power(n - 1, p)

Raise m to the power of n.


def minimum(k):
    if len(k) == 1:
        return k[0]
    if k[0] < minimum(k[1:]):
        return k[0]
    else:
        return minimum(k[1:])


def power(m, n):
    if n == 0:
        return 1
    return m * power(m, n - 1)

Raise m to the power of n.


Raise m to the power of n.


def maximum(a):
    if len(a) == 1:
        return a[0]
    if a[-2] > a[-1]:
        return maximum(a[:-1])
    else:
        return maximum(a[:-2] + a[-1:])


def maximum(l):
    if len(l) == 1:
        return l[0]
    if l[0] > maximum(l[1:]):
        return l[0]
    else:
        return maximum(l[1:])


def power(n, p):
    if p == 0:
        return 1
    elif p == 1:
        return n
    return n ** power(n, p - 1)

Raise m to the power of n.


def maximum(l):
    if len(l) == 1:
        return l[0]
    if l[-2] > l[-1]:
        return maximum(l[:-1])
    else:
        return maximum(l[:-2] + l[-1:])


def minimum(n):
    if len(n) == 1:
        return n[0]
    m = minimum(n[1:])
    return n[0] if n[0] < m else m


def reverse_list(l):
    if len(l) == 0:
        return []
    return l[-1:] + reverse_list(l[:-1])

Recursively reverse a list of elements.


Recursively reverse a list of elements.


def maximum(l):
    try:
        if l[0] > l[1]:
            return maximum(l[:1] + l[2:])
        else:
            return maximum(l[1:])
    except IndexError:
        return l[0]


def factorial(n):
    if n == 0:
        return 0
    return n * factorila(n - 1)

Compute the factorial of the given number.

assert factorial(-1)==1 and factorial(0)==1 and factorial(1)==1 and factorial(2)==2 and factorial(5)==120 and factorial(20)==2432902008176640000


def power(n, p):
    if p == 0:
        return 1
    elif p == 1:
        return n
    return n * power(n, p - 1)

Raise m to the power of n.


def maximum(l):
    if len(l) == 1:
        return l[0]
    else:
        n, m = l[0], maximum(l[1:])
        return n if n > m else m


def maximum(k):
    if len(k) == 1:
        return k[0]
    if k[0] > maximum(k[1:]):
        return k[0]
    else:
        return maximum(k[1:])


def minimum(l):
    if len(l) == 1:
        return l[0]
    else:
        n, m = l[0], minimum(l[1:])
        return n if n < m else m


def factorial(n):
    if n <= 1:
        return 1
    return n * factorial(n - 1)


def minimum(n):
    if len(n) == 1:
        return n
    if n[0] > minimum(n[1:]):
        return n
    else:
        return minimum(n - 1)


def minimum(l):
    if len(l) == 1:
        return l[0]
    if l[-2] > l[-1]:
        return minimum(l[:-1])
    else:
        return minimum(L[:-2] + l[-1:])


def minimum(l):
    if len(l) == 1:
        return l[0]
    if l[-2] > l[-1]:
        return minimum(l[:-1])
    else:
        return minimum(l[:-2] + l[-1:])


def count_letters(s):
    if s == '':
        return 0
    count = count_letters(s[:-1])
    return len(s) + count


def minimum(l):
    if len(l) == 1:
        return l[0]
    if l[-2] < l[-1]:
        return minimum(l[:-1])
    else:
        return minimum(l[:-2] + l[-1:])


def power(n, p):
    if p == 0:
        return 1
    return n * power(n, p - 1)

Raise m to the power of n.


Raise m to the power of n.


def count_letters(s):
    if s == '':
        return 0
    length = count_letters(s[:-1])
    count += 1
    if length == 0:
        return count


def sumup(n):
    if n == 0:
        return 0
    return n + sumup(n - 1)

Return the sum of all integers up to n.


Return the sum of all integers up to n.


def power(n, m):
    if n == 0:
        return 1
    return n * power(n, m - 1)

Raise m to the power of n.


def power(n, m):
    if m == 0:
        return 1
    return n * power(n, m - 1)

Raise m to the power of n.


def minimum(a):
    if len(a) == 1:
        return a[0]
    else:
        small = a[0]
        if a[1] < small:
            small = a[1]
            a.remove(a[0])
        else:
            a.remove(a[1])
    return minimum(a)


def minimum(l):
    if len(l) == 1:
        return l[0]
    else:
        nl = minimum(l[1:])
    if l[0] < nl:
        return l[0]
    else:
        return nl


def minimum(l):
    if len(l) == 1:
        return l[0]
    smallest = minimum(l[1:])
    if l[0] < smallest:
        return l[0]
    else:
        return smallest


def factorial(n):
    if n == 0:
        return 1
    return n * factorila(n - 1)


def factorial(n):
    if n == 0:
        return 1
    return n * factorial(n - 1)


def count_letters(s):
    count = 0
    if s == '':
        return 0
    length = count_letters(s[:-1])
    count += 1
    if length == 0:
        return count


def minimum(a):
    if len(a) == 1:
        return a[0]
    if a[0] > minimum(a[1:]):
        return a[0]
    else:
        return minimum(a[1:])


def count_letters(s):
    if not s:
        return 0
    return 1 + count_letters(s[1:])


def minimum(a):
    if len(a) == 1:
        return a[0]
    if a[-2] > a[-1]:
        return minimum(a[:-1])
    else:
        return minimum(a[:-2] + a[-1:])


def maximum(l):
    if len(l) == 1:
        return l[0]
    else:
        nl = maximum(l[1:])
    if l[0] > nl:
        return l[0]
    else:
        return nl


def minimum(a):
    if len(a) == 1:
        return a[0]
    if a[-2] < a[-1]:
        return minimum(a[:-1])
    else:
        return minimum(a[:-2] + a[-1:])


def maximum(l):
    if len(l) == 1:
        return l[0]
    biggest = maximum(l[1:])
    if l[0] > biggest:
        return l[0]
    else:
        return biggest


def count_letters(s):
    count = 0
    if s == '':
        return 0
    length = count_letters(s[:-1])
    count = count + 1
    if length == 0:
        return count


def power(m, n):
    if m == 0:
        return 1
    return n * power(m, n - 1)

Raise m to the power of n.


def minimum(a):
    if len(a) == 1:
        return a[0]
    if a[0] < minimum(a[1:]):
        return a[0]
    else:
        return minimum(a[1:])


def power(m, n):
    if n == 1:
        return m
    return m * power(m, n - 1)

Raise m to the power of n.


def power(m, n):
    if m == 0:
        return 1
    return m * power(m, n - 1)

Raise m to the power of n.


def count_letters(s):
    count = 0
    if s == '':
        return 0
    count = count + 1
    length = count_letters(s[:-1])
    if length == 0:
        return count


def power(m, n):
    if n == 0:
        return 1
    return n * power(m, n - 1)

Raise m to the power of n.


def minimum(l):
    if len(l) == 1:
        return l[0]
    if l[-2] < l[-1]:
        return minimum(l[:-1])
    else:
        return minimum(l[:-2] + l[-1:])


def power(m, n):
    if n == 0:
        return 1
    return m * power(m, n - 1)

Raise m to the power of n.


Raise m to the power of n.


def power(n, p):
    if n == 0:
        return 1
    return n * power(n, p - 1)

Raise m to the power of n.


def factorial(n):
    if n == 0:
        return 1
    return n * factorial(n - 1)


def maximum(a):
    if len(a) == 1:
        return a[0]
    if a[0] > minimum(a[1:]):
        return a[0]
    else:
        return minimum(a[1:])


def minimum(n):
    if len(n) == 1:
        return n[0]
    elif n[-2] < n[-1]:
        return minimum(n[:-1])
    else:
        return minimum(n[:-2] + n[-1:])


def reverse_list(l=[]):
    if len(l) == 0:
        return l
    else:
        return l[-1] + reverse_list(l[:-1])

Recursively reverse a list of elements.


def count_letters(word):
    try:
        i = i + 1
        return count_letters(word[1:])
    except:
        return i


def maximum(l):
    if len(l) == 1:
        return l[0]
    else:
        nl = maximum(l[1:])
    if l[0] > nl:
        return l[0]
    else:
        return nl


def power(n, p):
    if p == 0:
        return 1
    return n * power(n, p - 1)

Raise m to the power of n.


def count_letters(s):
    if len(s) == 0:
        return 0
    return len(s)


def count_letters(word):
    i = 0
    try:
        i = i + 1
        return count_letters(word[1:])
    except:
        return i


def reverse_list(l=[]):
    if len(l) == 0:
        return []
    else:
        return l[-1] + reverse_list(l[:-1])

Recursively reverse a list of elements.


def maximum(n):
    if len(n) == 1:
        return n[0]
    elif n[-2] > n[-1]:
        return maximum(n[:-1])
    else:
        return maximum(n[:-2] + n[-1:])


def maximum(a):
    if len(a) == 1:
        return a[0]
    if a[0] > maximun(a[1:]):
        return a[0]
    else:
        return maximum(a[1:])


def minimum(n):
    if len(n) == 1:
        return n
    if n[0] > minimum(n[1:]):
        return n + 1
    else:
        return minimum(n - 1)


def maximum(a):
    if len(a) == 1:
        return a[0]
    if a[0] > maximum(a[1:]):
        return a[0]
    else:
        return maximum(a[1:])


def reverse_list(l=[]):
    if len(l) == 0:
        return []
    else:
        return [l[-1] + reverse_list(l[:-1])]

Recursively reverse a list of elements.


def count_letters(s):
    if s == '':
        return 0
    return 1 + count_letters(s[:-1])


def minimum(l):
    if len(l) == 1:
        return l[0]
    elif a[0] < minimum(l[1:]):
        return a[0]
    return minimum(l[1:])


def minimum(l):
    if len(l) == 1:
        return l[0]
    elif l[0] < minimum(l[1:]):
        return l[0]
    return minimum(l[1:])


def minimum(x):
    if len(x) == 1:
        return x[0]
    else:
        n, m = x[0], minimum(x[1:])
    if n < m:
        return n
    else:
        return m


def reverse_list(l=[]):
    if len(l) == 0:
        return []
    else:
        return [l[-1]] + reverse_list(l[:-1])

Recursively reverse a list of elements.


Recursively reverse a list of elements.


def count_letters(word):
    if word == '':
        return 0
    try:
        i = i + 1
        return count_letters(word[1:])
    except:
        return i


def count_letters(s):
    if len(s) == 0:
        return 0
    else:
        return 1 + count_letters(s[1:])


def minimum(l):
    if len(l) == 1:
        return l[0]
    return l[0] < minimum(l[1:])


def minimum(l):
    if len(l) == 1:
        return l[0]
    else:
        nl = minimum(l[1:])
    if l[0] < nl:
        return l[0]
    else:
        return nl


def string_length(s):
    return 1 + string_length(s[1:]) if s else 0

def count_letters(s):
    if not s:
        return 0
    return string_length(s)


def minimum(l):
    if len(l) == 1:
        return l[0]
    return minimum(l[1:])


def count_letters(string):
    if string == '':
        return 0
    else:
        return 1 + count_letters(string[1:])


def maximum(a):
    if len(a) == 1:
        return a[0]
    else:
        large = a[0]
        if a[1] > a[0]:
            a.remove(a[0])
        else:
            a.remove(a[1])
    return maximum(a)


def minimum(a):
    if len(a) == 1:
        return a[0]
    head = a[0]
    tail = a[1:]
    mintail = minimum(tail)
    if head > mintail:
        smallest = mintail
    else:
        smallest = head
    return smallest


def maximum(l):
    if len(l) == 1:
        return l[0]
    else:
        nl = maximum(l[1:])
    if l[0] > nl:
        return l[0]
    else:
        return nl


def count_letters(s):
    if s == '':
        return 0
    elif s != '':
        s = s.split()
        total += 1
        return total + count_letters(s)


def power(m, n):
    if n == 0:
        return 1
    return m * power(m, n - 1)

Raise m to the power of n.


Raise m to the power of n.


def maximum(l):
    if len(l) == 1:
        return l[0]
    elif l[0] > maximum(l[1:]):
        return l[0]
    return maximum(l[1:])


def maximum(l):
    if len(l) == 1:
        return l[0]
    if l[-2] > l[-1]:
        return maximum(l[:-1])
    else:
        return maximum(l[:-2] + l[-1:])


def count_letters(s):
    total = 0
    if s == '':
        return 0
    else:
        return 1 + count_letters(s[1:])


def count_letters(n):
    if n == '':
        return 0
    return 1 + count_letters(n[:-1])


def count_letters(n):
    if not n:
        return 0
    return 1 + count_letters(n[1:]) if n else 0


def count_letters(s):
    if s == '':
        return 0
    count = 0
    for ch in s:
        count += 1
    return count


def count_letters(s):
    if not s:
        return 0
    return 1 + count_letters(s[1:]) if s else 0


def minimum(li):
    if len(li) == 1:
        return li[0]
    small = li.pop(0)
    v = minimum(li)
    if v < small:
        small = v
    return small


def count_letters(word):
    if word == '':
        return 0
    else:
        return 1 + count_letters(word[1:])


def maximum(a):
    if len(a) == 1:
        return a[0]
    biggest = minimum(a[1:])
    if a[0] > biggest:
        return a[0]
    else:
        return biggest


def count_letters(s):
    if len(s) == 0:
        return 0
    return count_letters(len(s) - 1)


def maximum(nums):
    if len(nums) == 1:
        return nums[0]
    if nums[-1] < nums[-2]:
        return maximum(nums[:-1])
    else:
        return maximum(nums[:-2] + nums[-1:])


def maximum(x):
    if len(x) == 1:
        return x[0]
    else:
        n, m = x[0], maximum(x[1:])
    if n > m:
        return n
    else:
        return m


def count_letters(s):
    if len(s) == 0:
        return 0
    return count_letters(s[1:])


def count_letters(s):
    if len(s) == 0:
        return 0
    return count_letters(s[:1])


def power(n, t):
    if t == 0:
        return 1
    t -= 1
    return n * power(n, t)

Raise m to the power of n.


Raise m to the power of n.


def minimum(l):
    if len(l) == 1:
        return l[0]
    mini = minimum(l[1:])
    if l[0] > mini:
        return mini
    else:
        return l[0]


def minimum(n):
    if n == 0:
        return n
    elif n[0] < n[1:]:
        return n[0]
    elif n[0] > n[1:]:
        return minimum(n - 1)


def maximum(a):
    if len(a) == 1:
        return a[0]
    head = a[0]
    tail = a[1:]
    mintail = minimum(tail)
    if head < mintail:
        smallest = mintail
    else:
        smallest = head
    return smallest


def maximum(a):
    if len(a) == 1:
        return a[0]
    biggest = maximum(a[1:])
    if a[0] > biggest:
        return a[0]
    else:
        return biggest


def maximum(a):
    if len(a) == 1:
        return a[0]
    head = a[0]
    tail = a[1:]
    mintail = maximum(tail)
    if head < mintail:
        smallest = mintail
    else:
        smallest = head
    return smallest


def count_letters(s):
    if not s:
        return 0
    if len(s) == 1:
        return 1
    return count_letters(s[1:])


def count_letters(s):
    if len(s) == 0:
        return 0
    if len(s) == 1:
        return 1
    return count_letters(s[1:])


def count_letters(s):
    if s == '':
        return 0
    s = s.replace(s[0], '', 1)
    return 1 + count_letters(s)


def count_letters(s):
    if s == '':
        return 0
    return 1 + count_letters(s[1:])


def count_letters(s):
    if s == '':
        return 0
    else:
        return 1 + count_letters(s[1:])


def minimum(l=[]):
    if len(l) == 1:
        return l[0]
    elif l[0] < minimum(l[1:]):
        return l[0]
    else:
        return minimum(l[1:])


def count_letters(s):
    if s == '':
        return 0
    else:
        return 1 + count_letters(s)


def count_letters(s):
    total = 0
    for c in (s - 1):
        total += 1
    return count_letters(s[:-1]) + 1


def maximum(l):
    if len(l) == 1:
        return l[0]
    maxi = maximum(l[1:])
    if l[0] < maxi:
        return maxi
    else:
        return l[0]


def count_letters(s):
    if not s:
        return 0
    if len(s) == 1:
        return 1
    return 1 + count_letters(s[1:])


def power(base, ind):
    if ind == 0:
        return 1
    return base * power(base, ind - 1)

Raise m to the power of n.


Raise m to the power of n.


def maximum(li):
    if len(li) == 1:
        return li[0]
    big = li.pop(0)
    v = maximum(li)
    if big < v:
        big = v
    return big


def count_letters(w):
    if w == '':
        return 0
    return 1 + count_letters(w[1:])


def count_letters(s):
    total = 0
    for c in s[:-1]:
        total += 1
    return count_letters(s[:-1]) + 1


def reverse_list(l):
    if len(l) == 1:
        return l
    return reverse(l[:-1] + l[0])

Recursively reverse a list of elements.


def count_letters(n):
    if n == '':
        return 0
    return 1 + count_letters(n[1:])


def count_letters(s):
    if len(s) == 0:
        return 0
    if len(s) == 1:
        return 1
    return count_letters(s[1:]) + 1


def reverse_list(l):
    if len(l) == 1:
        return l
    return reverse_list(l[:-1] + l[0])

Recursively reverse a list of elements.


def fibonacci(n):
    if n == 0:
        return 1
    elif n == 1:
        return 1
    return fibonacci(n - 1) + fibonacci(n - 2)

Recursively compute the value of the fibonacci series at position n.

assert fibonacci(0)==0 and fibonacci(1)==1 and fibonacci(2)==1 and fibonacci(10)==55 and fibonacci(23)==28657


def minimum(l):
    if len(l) == 1:
        return l[0]
    minimum = minimum(l[1])
    if l[0] < minimum:
        l.pop(minimum)
    else:
        l.pop(l[0])
    return l[0]


def reverse_list(l):
    if len(l) == 1:
        return l
    return reverse_list(l[-1:])

Recursively reverse a list of elements.


def minimum(l):
    if len(l) == 1:
        return l[0]
    mini = minimum(l[1])
    if l[0] < mini:
        l.pop(mini)
    else:
        l.pop(l[0])
    return l[0]


def maximum(l=[]):
    if len(l) == 1:
        return l[0]
    elif l[0] > maximum(l[1:]):
        return l[0]
    else:
        return maximum(l[1:])


Recursively reverse a list of elements.


def minimum(a):
    if len(a) == 1:
        return a[0]
    else:
        nl = minimum(a[1:])
    if a[0] < nl:
        return a[0]
    else:
        return nl


def minimum(n):
    if n == 0:
        return n
    elif n[0] < minimum(n[1:]):
        return n[0]
    elif n[0] > n[1:]:
        return minimum(n - 1)


def count_letters(s):
    i = 0
    for char in s:
        i += 1
    return i


def power(n, p):
    if p == 0:
        return 1
    return n ** p

Raise m to the power of n.


def reverse_list(l):
    if len(l) == 0:
        return []
    else:
        return [l[-1]] + reverse_list(l[:-1])

Recursively reverse a list of elements.


def power(n, p):
    if p == 0:
        return 1
    return n * power(n, p - 1)

Raise m to the power of n.


Raise m to the power of n.


def reverse_list(l):
    if reverse_list.count == len(l) // 2:
        return l
    l.insert(-1, l.pop(0))
    reverse_list.count += 1
    try:
        return reverse_list(l)
    finally:
        reverse_list.count = 0

Recursively reverse a list of elements.


def maximum(a):
    if len(a) == 1:
        return a[0]
    else:
        nl = maximum(a[1:])
    if a[0] > nl:
        return a[0]
    else:
        return nl


def minimum(nums):
    if len(nums) == 1:
        return nums[0]
    min_num = minimum(nums[:-1])
    if nums[-1] < min_num:
        return nums[-1]
    else:
        return min_num


def reverse_list(ihavethehighground):
    if len(ihavethehighground) == 1:
        return ihavethehighground
    else:
        return s[-1] + power(s[-1] - 1)

Recursively reverse a list of elements.


def reverse_list(a):
    if len(a) == 1:
        return a[0]
    return a[0].append(reverse_list(a[1:]))

Recursively reverse a list of elements.


def reverse_list(a):
    if len(a) == 1:
        return a
    else:
        return reverse_list[:-1]

Recursively reverse a list of elements.


def reverse_list(ihavethehighground):
    if len(ihavethehighground) == 1:
        return ihavethehighground
    else:
        return ihavethehighground[-1] + power(ihavethehighground[-1] - 1)

Recursively reverse a list of elements.


def count_letters(s):
    if s == '':
        return 0
    return 1 + count_letters(s[1:])


def minimum(l):
    if len(l) == 1:
        return l[0]
    if l[0] > l[-1]:
        return minimum(l[1:])
    else:
        return minimum(l[:-1])


def reverse_list(s):
    if len(s) == 1:
        return s
    else:
        return s[-1] + reverse_list[:-1]

Recursively reverse a list of elements.


def minimum(n):
    if n == 0:
        return n
    elif n[0] < minimum(n[1:]):
        return n[0]
    else:
        n[0] > n[1:]
    return minimum(n - 1)


def reverse_list(ihavethehighground):
    if len(ihavethehighground) == 1:
        return ihavethehighground
    else:
        return ihavethehighground[-1] + reverse_list(ihavethehighground[-1] - 1
            )

Recursively reverse a list of elements.


def reverse_list(l):
    if len(l) == 1:
        return l
    return reverse_list(l[::-1])

Recursively reverse a list of elements.


def reverse_list(a):
    if len(a) == 1:
        return a
    return a[0].append(reverse_list(a[1:]))

Recursively reverse a list of elements.


def reverse_list(a):
    if len(a) == 1:
        return a
    else:
        return reverse_list[:-2]

Recursively reverse a list of elements.


def reverse_list(l):
    if l == []:
        return l
    tmp = reverse_list(l[1:])
    tmp.append(l[0])
    return tmp

Recursively reverse a list of elements.


def reverse_list(a):
    return reverse(a)

Recursively reverse a list of elements.


Recursively reverse a list of elements.


def reverse_list(a):
    return a.reverse()

Recursively reverse a list of elements.


def maximum(l):
    if len(l) == 1:
        return l[0]
    if l[0] < l[-1]:
        return maximum(l[1:])
    else:
        return maximum(l[:-1])


def reverse_list(ihavethehighground):
    if len(ihavethehighground) == 1:
        return ihavethehighground
    else:
        return ihavethehighground[-1] + reverse_list(ihavethehighground[:-1])

Recursively reverse a list of elements.


def reverse_list(a):
    if len(a) == 1:
        return a
    return reverse_list(a[1:]).append(a[0])

Recursively reverse a list of elements.


def count_letters(s):
    total = 0
    if not s:
        return total
    else:
        for c in s[:-1]:
            total += 1
    return count_letters(s) + 1


def minimum(l):
    if len(l) == 1:
        return l[0]
    else:
        new_l = minimum(l[1:])
    if l[0] > new_l:
        return l[0]
    else:
        return new_l


def minimum(l):
    if len(l) == 1:
        return l[0]
    else:
        new_l = minimum(l[1:])
    if l[0] < new_l:
        return l[0]
    else:
        return new_l


def reverse_list(ihavethehighground):
    if len(ihavethehighground) == 1:
        return ihavethehighground
    else:
        return [ihavethehighground[-1]] + reverse_list(ihavethehighground[:-1])

Recursively reverse a list of elements.


def reverse_list(l):
    if len(l) == 0:
        return []
    return [l[-1]] + reverse_list(l[:-1])

Recursively reverse a list of elements.


def reverse_list(s, x=[]):
    if len(s) == 1:
        return s
    else:
        x.append(s[-1])
        return x + reverse_list(s[0:len(s) - 1], x)

Recursively reverse a list of elements.


def reverse_list(a):
    if len(a) == 1:
        return a[0]
    l = reverse_list(a[1:]).append(a[0])
    return l

Recursively reverse a list of elements.


def minimum(l):
    if len(l) == 1:
        return l[0]
    mini = minimum(l[1])
    if l[0] < mini:
        l.pop(mini)
    else:
        l.pop(l[0])
    return l[0]


def maximum(l):
    if len(l) == 1:
        return l[0]
    else:
        new_l = maximum(l[1:])
    if l[0] > new_l:
        return l[0]
    else:
        return new_l


def reverse_list(a):
    if len(a) == 1:
        return a
    l = reverse_list(a[1:]).append(a[0])
    return l

Recursively reverse a list of elements.


def reverse_list(a, x=0):
    if len(a) == 1:
        return a
    f = reverse_list[:-1]
    x.append(f)
    return x

Recursively reverse a list of elements.


def reverse_list(n):
    if len(n) == 0:
        return []
    return [n[-1]] + reverse_list(n[:-1])

Recursively reverse a list of elements.


Recursively reverse a list of elements.


def reverse_list(a, x=[]):
    if len(a) == 1:
        return a
    f = reverse_list[:-1]
    x.append(f)
    return x

Recursively reverse a list of elements.


def reverse_list(l):
    if len(l) == 0:
        return l
    return [l[-1]] + reverse_list(l[:-1])

Recursively reverse a list of elements.


def fibonacci(n):
    if n <= 1:
        return 1
    return n + fibonacci(n - 1) + fibonacci(n - 2)


def reverse_list(ihavethehighground):
    if len(ihavethehighground) == 1 or len(ihavethehighground) == 0:
        return ihavethehighground
    else:
        return [ihavethehighground[-1]] + reverse_list(ihavethehighground[:-1])

Recursively reverse a list of elements.


def reverse_list(a, x=[]):
    if len(a) == 1:
        return a
    f = reverse_list(a[:-1])
    x.append(f)
    return x

Recursively reverse a list of elements.


def reverse_list(a, b=0):
    if a == 0:
        return 0
    c = reverse_list[-1:]
    a.append(c)
    return c

Recursively reverse a list of elements.


def fibonacci(n):
    if n == 0 or n == 1:
        return 1
    return fibonacci(n - 2) + fibonacci(n - 1)


def minimum(a):
    if len(a) == 1:
        return a[0]
    le = a[0:1]
    a = a[1:]
    if minimum(le) < minimum(a):
        return minimum(le)
    else:
        return minimum(a)


def minimum(l):
    if len(l) == 1:
        return l[0]
    else:
        new_l = minimum(l[1:])
    if l[0] < new_l:
        return l[0]
    else:
        return new_l


def reverse_list(s, x=[]):
    if len(s) == 1 or len(s) == 0:
        return s
    else:
        x.append(s[-1])
        return x + reverse_list(s[:-1], x)

Recursively reverse a list of elements.


def minimum(l):
    if len(l) == 1:
        return l[0]
    if l[0] <= minimum(l[1:]):
        return l[0]
    else:
        return minimum(l[1:])


def reverse_list(a, x=[]):
    if len(a) == 1 or len(a) == 0:
        return a
    f = reverse_list(a[:-1])
    x.append(f)
    return x

Recursively reverse a list of elements.


def reverse_list(a):
    if len(a) == 1:
        return a
    l = reverse_list(a[1:])
    l.append(a[0])
    return l

Recursively reverse a list of elements.


def fibonacci(N):
    if N == 0 or N == 1:
        return 1
    return fibonacci(N - 1) + fibonacci(N - 2)


def reverse_list(s):
    if len(s) == 1 or len(s) == 0:
        return s
    else:
        return s[-1] + reverse_list(s[:-1])

Recursively reverse a list of elements.


def count_letters(s):
    if s == '':
        return 0
    s = s[1:]
    return 1 + count_letters(s)


def count_letters(s):
    if s == '':
        return 0
    return count_letters(s[1:]) + 1


def reverse_list(a):
    if not a:
        return a
    if len(a) == 1:
        return a
    l = reverse_list(a[1:])
    l.append(a[0])
    return l

Recursively reverse a list of elements.


Recursively reverse a list of elements.


def reverse_list(x):
    if x == '':
        return x
    else:
        return x[-1] + reverse_list(x[:-1])

Recursively reverse a list of elements.


def reverse_list(s):
    if len(s) == 1 or len(s) == 0:
        return s
    else:
        return [s[-1]] + reverse_list(s[:-1])

Recursively reverse a list of elements.


def reverse_list(a, b=0):
    if len(a) == 0 or len(a) == 1:
        return 0
    else:
        return a[-1:]

Recursively reverse a list of elements.


def reverse_list(a):
    if len(a) == 1 or len(a) == 0:
        return a
    return reverse_list(a[1:]).append(a[0])

Recursively reverse a list of elements.


def count_letters(a):
    if a == '':
        return 0
    return count_letters(s[1:]) + 1


def reverse_list(a):
    if len(a) == 1 or len(a) == 0:
        return a
    else:
        return [a[-1]] + reverse_list(a[:-1])

Recursively reverse a list of elements.


def fibonacci(n):
    if n == 0:
        return 1
    if n == 1:
        return 1
    return fibonacci(n - 2) + fibonacci(n - 1)


def maximum(l):
    if len(l) == 1:
        return l[0]
    else:
        new_l = maximum(l[1:])
    if l[0] > new_l:
        return l[0]
    else:
        return new_l


def count_letters(a):
    if a == '':
        return 0
    return count_letters(a[1:]) + 1


def count_letters(s):
    total = 0
    if s == '':
        return 0
    else:
        for c in s[:-1]:
            total += 1
            s = s[c:-1]
        return count_letters(s) + 1


def reverse_list(a):
    if len(a) == 1 or len(a) == 0:
        return a
    cancer = reverse_list(a[1:])
    cancer.append(a[0])
    return cancer

Recursively reverse a list of elements.


def reverse_list(a):
    if len(a) == 1 or len(a) == 0:
        return a
    can = reverse_list(a[1:])
    can.append(a[0])
    return can

Recursively reverse a list of elements.


def reverse_list(a, b=0):
    if len(a) == 0 or len(a) == 1:
        return 0
    else:
        return [a[-1:]] + reverse_list(a[:-1])

Recursively reverse a list of elements.


def count_letters(s):
    if s == '':
        return 0
    else:
        ns = s[1:]
    return 1 + count_letters(ns)


def fibonacci(n):
    if n == 0:
        return 1
    elif n == 1:
        return 1
    return fibonacci(n - 1) + fibonacci(n - 2)


def reverse_list(a, b=0):
    if len(a) == 0 or len(a) == 1:
        return 0
    else:
        return [a[-1]] + reverse_list(a[:-1])

Recursively reverse a list of elements.


def fibonacci(n):
    if n == 0 or n == 1:
        return 1
    return fibonacci(n - 1) + fibonacci(n - 2)


def maximum(nums):
    if len(nums) == 1:
        return nums[0]
    max_num = maximum(nums[:-1])
    if nums[-1] > max_num:
        return nums[-1]
    else:
        return max_num


def maximum(l):
    if len(l) == 1:
        return l[0]
    if l[0] >= maximum(l[1:]):
        return l[0]
    else:
        return maximum(l[1:])


def reverse_list(a):
    if len(a) == 0 or len(a) == 1:
        return 0
    else:
        return [a[-1]] + reverse_list(a[:-1])

Recursively reverse a list of elements.


def count_letters(s):
    total = 0
    if s == '':
        return 0
    else:
        i = 0
        for c in s[:-1]:
            total += 1
            i += 1
            s = s[i:-1]
        return count_letters(s) + 1


def minimum(l, i=0):
    j = i
    while j < len(l) and l[j] > l[-1]:
        j += 1
    if j < len(l):
        tmp = l[i]
        l[i] = l[j]
        l[j] = tmp
    if j > len(l):
        return l[0]
    return minimum(l, i + 1)


def count_letters(s):
    total = 0
    if s == '':
        return total
    else:
        i = 0
        for c in s[:-1]:
            total += 1
            i += 1
            s = s[i:-1]
        return count_letters(s) + 1


def reverse_list(a):
    if len(a) == 0 or len(a) == 1:
        return 1
    else:
        return [a[-1]] + reverse_list(a[:-1])

Recursively reverse a list of elements.


Recursively reverse a list of elements.


def minimum(l=[]):
    if len(l) == 1:
        return l[0]
    if l[0] < minimum(l[:]):
        return l[0]
    else:
        return minimum(l[:])


def minimum(n):
    if n == 0:
        return n
    elif n[0] < minimum(n[1:]):
        return n[0]
    else:
        n[0] > n[1:]
    return minimum(n - 1)


def count_letters(s):
    total = 0
    if s == '':
        return 0
    return total + count_letters(s)


def fibonacci(n):
    if n == 0 or n == 1:
        return 1
    return fibonacci(n - 2) + fibonacci(n - 1)


def minimum(l=[]):
    if len(l) == 1:
        return l[0]
    if l[0] < minimum(l[0:]):
        return l[0]
    else:
        return minimum(l[:])


def minimum(l=[]):
    if len(l) == 1:
        return l[0]
    if l[0] < minimum(l[1:]):
        return l[0]
    else:
        return minimum(l[:])


def minimum(l=[]):
    if len(l) == 1:
        return l[0]
    if l[0] < minimum(l[1:]):
        return l[0]
    else:
        return minimum(l[1:])


def maximum(l, i=0):
    j = i
    while j < len(l) and l[j] > l[-1]:
        j += 1
    if j < len(l):
        tmp = l[i]
        l[i] = l[j]
        l[j] = tmp
    if j > len(l):
        return l[-1]
    return minimum(l, i + 1)


def reverse_list(x):
    if len(x) == 0:
        return x
    else:
        return [x[-1]] + reverse_list(x[0:-1])

Recursively reverse a list of elements.


def reverse_list(a):
    if len(a) == 1:
        return a
    return a[-1:] + reverse_list(a[:-1])

Recursively reverse a list of elements.


def maximum(l, i=0):
    j = i
    while j < len(l) and l[j] > l[-1]:
        j += 1
    if j < len(l):
        tmp = l[i]
        l[i] = l[j]
        l[j] = tmp
    if j > len(l):
        return l[-1]
    return maximum(l, i + 1)


def reverse_list(a):
    if len(a) == 1:
        return a
    return a[len(a) - 1] + reverse_list(a[:-1])

Recursively reverse a list of elements.


def maximum(l=[]):
    if len(l) == 1:
        return l[0]
    if l[0] > maximum(l[1:]):
        return l[0]
    else:
        return maximum(l[1:])


def fibonacci(nth):
    if n == 1 or n == 0:
        return 1
    return n - 1 + power(n - 2)


def reverse_list(a):
    if len(a) == 1:
        return a
    return a[-1] + reverse_list(a[:-1])

Recursively reverse a list of elements.


def fibonacci(nth):
    if nth == 1 or nth == 0:
        return 1
    return nth - 1 + power(nth - 2)


Recursively reverse a list of elements.


def count_letters(s):
    if len(s) == 1:
        return 1
    return 1 + count_letters(s[1:])


def fibonacci(nth):
    if nth == 1 or nth == 0:
        return 1
    return nth - 1 + fibonacci(nth - 2)


def minimum(l):
    if len(l) == 1:
        return l[0]
    mins = minimum(l[1:])
    if mins < l[0]:
        return mins
    else:
        return l[0]


def reverse_list(l):
    if reverse_list.count == len(l) // 2:
        return l
    x = l.pop(0)
    l.append(x)
    reverse_list.count += 1
    try:
        print(reverse_list.count)
        return reverse_list(l)
    finally:
        reverse_list.count = 0

Recursively reverse a list of elements.


def reverse_list(l):
    if len(l) == 0:
        return l
    return l[-1:] + reverse_list(l[:-1])

Recursively reverse a list of elements.


def fibonacci(a):
    if a == 0 or a == 1:
        return 1
    else:
        return a + fibonacci(a - 1)


def fibonacci(n):
    if n == 1 or n == 0:
        return 1
    else:
        return n + fibonacci(n - 1)


def fibonacci(x):
    if x == 0:
        return 1
    elif x == 1:
        return 1
    return fibonacci(x - 1) + fibonacci(x - 2)


def count_letters(s):
    if len(s) == 0:
        return 0
    return 1 + count_letters(s[1:])


def fibonacci(nth):
    if nth == 1 or nth == 0:
        return 1
    return nth + fibonacci(nth - 1)


def minimum(l, i=0):
    j = i
    while j < len(l) and l[j] > l[-1]:
        j += 1
    if j < len(l):
        tmp = l[i]
        l[i] = l[j]
        l[j] = tmp
    if j > len(l):
        return l[0]
    return minimum(l, i + 1)


def reverse_list(a):
    if len(a) == 0:
        return a
    return a[-1:] + reverse_list(a[:-1])

Recursively reverse a list of elements.


def reverse_list(a):
    if len(a) == 1:
        return a[0]
    b = []
    b.append(reverse_list(a))
    return b[-1:]

Recursively reverse a list of elements.


def fibonacci(n):
    if n == 1 or n == 0:
        return 1
    else:
        return n + fibonacci(n - 3)


def fibonacci(nth):
    if nth == 1 or nth == 0:
        return 1
    return nth - 1 + fibonacci(nth - 1)


def fibonacci(a):
    if a == 0 or a == 1:
        return 1
        x = a
    else:
        return x + fibonacci(a - x)


def fibonacci(nth):
    if nth == 1 or nth == 0:
        return 1
    return nth + 1 + fibonacci(nth - 1)


Recursively reverse a list of elements.


def fibonacci(a):
    if a == 0 or a == 1:
        return 1
        x = a
    else:
        return a + fibonacci(a - x)


def count_letters(s):
    if not s:
        return 0
    return 1 + count_letters(s[:-1])


def fibonacci(a):
    x = a
    if a == 0 or a == 1:
        return 1
    else:
        return a + fibonacci(a - x)


def count_letters(s):
    total = 0
    if s == '':
        return 0
    return total + count_letters(s[1:])


def fibonacci(n):
    if n == 1 or n == 0:
        return 1
    else:
        return n - 1 + fibonacci(n - 2)


def count_letters(s):
    total = 0
    if s == '':
        return 0
    return total + count_letters(s[0:])


def fibonacci(nth):
    if nth == 1 or nth == 0:
        return 1
    return fibonacci(nth - 1) + fibonacci(nth - 2)


def fibonacci(n):
    if n == 1 or n == 0:
        return 1
    else:
        return n + fibonacci((n - 2) * 2)


def reverse_list(a):
    if len(a) == 1:
        return a[0]
    b = []
    i = 0
    b.append(reverse_list(a[i])) + 1
    return b[-1:]

Recursively reverse a list of elements.


def fibonacci(n):
    if n == 0 or n == 1:
        return 1
    return fibonacci(n) + fibonacci(n - 1)


def fibonacci(a):
    if a == 0 or a == 1:
        return 1
    else:
        return fibonacci(a - 1) + fibonacci(a - 2)


def fibonacci(nth):
    if nth == 1 or nth == 0:
        return 1
    return nth - 1 + fibonacci(nth - 2)


def minimum(n):
    if n == 1:
        return n[0]
    else:
        return n[0] if n[0] < minimum else minimum


def fibonacci(n):
    if n == 1 or n == 0:
        return 1
    else:
        return n + fibonacci(n - 2)


def fibonacci(n):
    if n == 0 or n == 1:
        return 1
    return n + fibonacci(n - 1)


def fibonacci(n):
    if n == 1 or n == 0:
        return 1
    else:
        return n - 1 + fibonacci(n - 2) + 1


def count_letters(l):
    if l == '':
        return 0
    return count_letters(l[:-1]) + 1


def count_letters(s):
    total = 0
    if s == '':
        return 0
    return count + count_letters(s[1:])


def fibonacci(n):
    if n == 1 or n == 0:
        return 1
    else:
        return n - 1 + fibonacci(n - 1)


def maximum(l):
    if len(l) == 1:
        return l[0]
    maxs = maximum(l[1:])
    if maxs > l[0]:
        return maxs
    else:
        return l[0]


def count_letters(s):
    total = 0
    if s == '':
        return 0
    return total + count_letters(s[1:])


def fibonacci(n):
    if n == 1 or n == 0:
        return 1
    else:
        return fibonacci(n - 1) + fibonacci(n - 2)


def count_letters(s):
    total = 0
    if s == '':
        return 0
    return total + count_letters(s[1])


def count_letters(s):
    total = 0
    if s == '':
        return 0
    return total + count_letters(s[0:])


def fibonacci(n):
    if n == 0 or n == 1:
        return 1
    return n - 1 + fibonacci(n - 1)


def count_letters(s):
    total = 0
    if s == '':
        return 0
    return total + count_letters(s[0])


def minimum(n):
    if n == 1:
        return n[0]
    else:
        min_ret = minimum
        return n[0] if n[0] < min_ret else min_ret


def count_letters(s='', i=0):
    if s == '':
        return i
    i += 1
    return count_letters(s.replace(s[0], '', 1), i)


def power(m, n):
    if n == 0:
        return 1
    return m * power(m, n - 1)

Raise m to the power of n.


Raise m to the power of n.


def count_letters(s):
    if len(s) == 0:
        return 0
    return 1 + count_letters(s[1:])


def reverse_list(a):
    if len(a) == 2:
        return ''
    return reverse_list(a[1:] + a[0])

Recursively reverse a list of elements.


def reverse_list(a):
    if len(a) == 1:
        return a[0]
    tmp = reverse_list(a[1:])
    tmp.append(a[0])
    return tmp

Recursively reverse a list of elements.


def count_letters(s):
    total = 0
    if s == '':
        return total
    else:
        i = 0
        for c in s:
            if c.isalpha():
                s[i] = 1
                t = s[:i]
                t += s[i]
                t += s[i:]
                s = t
        if not s.isupper():
            total = 0
            for c in s:
                total += c
            return total
        else:
            return count_letters(s)


def reverse_list(a):
    if a == []:
        return a
    tmp = reverse_list(a[1:])
    tmp.append(a[0])
    return tmp

Recursively reverse a list of elements.


Recursively reverse a list of elements.


def count_letters(s):
    total = 0
    if s == '':
        return total
    else:
        i = 0
        for c in s:
            if c.isalpha():
                s[i] = '1'
                t = s[:i]
                t += s[i]
                t += s[i:]
                s = t
        if not s.isupper():
            total = 0
            for c in s:
                total += int(c)
            return total
        else:
            return count_letters(s)


def count_letters(s='', i=0):
    print((s, i))
    if s == '':
        return i
    i += 1
    return count_letters(s.replace[s[0], '', 1], i)


def fibonacci(n):
    if n == 0 or n == 1:
        return 1
    return fibonacci(n - 1) + fibonacci(n - 2)


def count_letters(s='', i=0):
    print((s, i))
    if s == '':
        return i
    i += 1
    return count_letters(s.replace(s[0], '', 1), i)


def count_letters(s):
    total = 0
    if s == '':
        return total
    else:
        i = 0
        for c in s:
            if c.isalpha():
                t = s[:i]
                t += '1'
                t += s[i:]
                s = t
            i += 1
        if not s.isupper():
            total = 0
            for c in s:
                total += int(c)
            return total
        else:
            return count_letters(s)


def reverse_list(l, i=0):
    if i == len(l) // 2:
        return l
    tmp = l[i]
    l[i] = l[len(l) - 1 - i]
    l[len(l) - 1 - i] = tmp
    i += 1
    return reverse_list(l, i)

Recursively reverse a list of elements.


def count_letters(s):
    total = 0
    if s == '':
        return total
    else:
        i = 0
        for c in s.lower():
            if c.islower():
                t = s[:i]
                t += '1'
                t += s[i:]
                s = t
            i += 1
        if not s.islower():
            total = 0
            for c in s:
                total += 1
            return total
        else:
            return count_letters(s)


def minimum(list):
    if len(list) == 1:
        return list[0]
    max_value = max(list)
    return list.remove(max_value)


def minimum(list):
    if len(list) == 2:
        return list[0]
    max_value = max(list)
    return list.remove(max_value)


def fibonacci(n):
    if n == 1 or n == 0:
        return 1
    return fibonacci(n - 1) + fibonacci(n - 2)


def minimum(list):
    if len(list) == 2:
        return list[0]
    max_value = max(list)
    return minimum(list.remove(max_value))


def reverse_list(l):
    if len(l) == 0:
        return l
    return reverse_list(l[1:]) + l[:1]

Recursively reverse a list of elements.


def reverse_list(a):
    if len(a) == 2:
        return a
    return reverse_list(a[1:] + a[0])

Recursively reverse a list of elements.


def minimum(list=[]):
    if len(list) == 2:
        return list[0]
    max_value = max(list)
    return minimum(list.remove(max_value))


def reverse_list(l):
    if len(l) == 0:
        return reverse_list.m
    reverse_list.m.append(l.pop())
    try:
        return reverse_list(l)
    finally:
        reverse_list.m = []

Recursively reverse a list of elements.


def reverse_list(a):
    if len(a) == 1:
        return a
    return a + reverse_list(a[1:1])

Recursively reverse a list of elements.


Recursively reverse a list of elements.


def count_letters(s):
    if s == '':
        return 0
    return 1 + count_letters(s[1:])


def minimum(list=[]):
    if len(list) == 1:
        return list[0]
    max_value = max(list)
    return minimum(list.remove(max_value))


def count_letters(s):
    if not s:
        return 0
    else:
        return 1 + count_letters(s[1:])


def minimum(list=[]):
    if len(list) == 1:
        return list[0]
    max_value = max(list)
    print(max_value)


def fibonacci(n):
    if n == 0 or n == 1:
        return 1
    return fibonacci(n - 1) + fibonacci(n - 2)


def fibonacci(i, n=1):
    if i == 1 or i == 0:
        return 1
    return fibonacci(i - 1) + fibonacci(i - 2)


def minimum(list):
    if len(list) == 1:
        return list[0]
    max_value = max(list)
    print(max_value)


def reverse_list(nums):
    if len(nums) == 0:
        new_nums = list()
        return new_nums
    new_nums = reverse_list(nums[1:])
    new_nums.append(nums[0])
    return new_nums

Recursively reverse a list of elements.


def fibonacci(a):
    if a == 0:
        return 1
    if a == 1:
        return 1
    return fibonacci(a - 1) + fibonacci(a - 2)


def reverse_list(l):
    if len(l) == 1:
        return l
    new_l = reverse_list(l[1:]) + l[:1]
    return new_l

Recursively reverse a list of elements.


def reverse_list(l):
    if len(l) == 0:
        return l
    new_l = reverse_list(l[1:]) + l[:1]
    return new_l

Recursively reverse a list of elements.


def minimum(list):
    if len(list) == 1:
        return list[0]
    list = sorted(list)
    return minimum(list.pop())


def reverse_list(l):
    if not l:
        return l
    return reverse_list(l[1:]) + [l[0]]

Recursively reverse a list of elements.


def reverse_list(l):
    if l == []:
        return []
    return reverse_list(l[1:]) + list(l[0])

Recursively reverse a list of elements.


def fibonacci(i):
    if i == 1 or i == 0:
        return 1
    return fibonacci(i - 1) + fibonacci(i - 2)


def reverse_list(l):
    if l == []:
        return []
    return reverse_list(l[1:]) + l[:1]

Recursively reverse a list of elements.


Recursively reverse a list of elements.


def fibonacci(n):
    if n == 0 or n == 1:
        return 1
    else:
        return fibonacci(n - 1) + fibonacci(n - 2)


def minimum(a):
    if len(a) == 1:
        return a[0]
    smallest = a.pop(0)
    x = minimum(a)
    if smallest > minimum(a):
        smallest = x
    return smallest


def minimum(list):
    if len(list) == 1:
        return list[0]
    elif list[0] < minimum(list[1:]):
        list[0]
    else:
        return minimum(list[1:])


def minimum(list):
    if len(list) == 1:
        return list[0]
    elif list[0] < minimum(list[1:]):
        return list[0]
    else:
        return minimum(list[1:])


def minimum(list):
    if len(list) == 1:
        return list[0]
    elif list[0] < minimum(list[1:]):
        return list[0]


def fibonacci(n):
    if n == 0 or 1:
        return 1
    return fibonacci(n - 1) + fibonacci(n - 2)


def fibonacci(n):
    if n == 0:
        return 1
    elif n < 0:
        return 0
    return fibonacci(n - 1) + fibonacci(n - 2)


def fibonacci(n):
    if n < 3:
        return n
    return fibonacci(n - 2) + fibonacci(n - 1)


def reverse_list(l):
    if len(l) == 0:
        return []
    return reverse_list(l[1:]) + l[:1]

Recursively reverse a list of elements.


def fibonacci(n):
    if n == 0 or n == 1:
        return 1
    return fibonacci(n - 1) + fibonacci(n - 2)


def fibonacci(n):
    if n == 0:
        return 1
    elif n < 3:
        return n
    return fibonacci(n - 2) + fibonacci(n - 1)


def reverse_list(a):
    if len(a) == 0:
        return a
    else:
        return a[-1] + reverse_list(a[:-1])

Recursively reverse a list of elements.


def fibonacci(n):
    if n <= 2:
        return n
    else:
        return fibonacci(n - 1) + fibonacci(n - 2)


def fibonacci(n):
    if n == 0:
        return 1
    if n == 1:
        return 1
    return fibonacci(n - 1) + fibonacci(n - 2)


def count_letters(s):
    if not s:
        return 0
    return 1 + s[1:]


def factorial(n):
    if n == 0:
        return 1
    return n * factorial(n - 1)


def fibonacci(num):
    if num == 0 or num == 1:
        return 1
    return fibonacci(num - 1) + fibonacci(num - 2)


def maximum(l):
    if len(l) == 1:
        return l[0]
    else:
        return maximum(l[1:] if l[0] < l[-1] else l[:-1])


def minimum(l):
    if len(l) == 1:
        return l[0]
    else:
        return minimum(l[1:] if l[0] > l[-1] else l[:-1])


def power(m, n):
    if n == 0:
        return 1
    return m * power(m, n - 1)

Raise m to the power of n.


Raise m to the power of n.


def sumup(n):
    if n == 0:
        return 0
    return n + sumup(n - 1)

Return the sum of all integers up to n.


Return the sum of all integers up to n.


def reverse_list(l):
    if len(l) == 1:
        return l
    return l[-1:] + reverse_list(l[:-1])

Recursively reverse a list of elements.


def reverse_list(a):
    if len(a) == 0:
        return a
    return [l[-1]] + reverse_list(l[:-1])
    return reverse_list(a[a:])

Recursively reverse a list of elements.


def fibonacci(n):
    if n == 0:
        return 1
    if n <= 2:
        return n
    else:
        return fibonacci(n - 2) + fibonacci(n - 1)


def reverse_list(a):
    if len(a) == 0:
        return a
    return [a[-1]] + reverse_list(a[:-1])

Recursively reverse a list of elements.


Recursively reverse a list of elements.


def count_letters(s):
    if not s:
        return 0
    return 1 + count_letters(s[1:])


def sumup(n):
    if n == 1:
        return 1
    sum_to_n_1 = sumup(n - 1)
    return n + sum_to_n_1

Return the sum of all integers up to n.


def reverse_list(nums):
    if len(nums) == 0:
        return []
    return reverse_list(nums[1:]) + nums[:1]

Recursively reverse a list of elements.


def count_letters(string):
    if len(string) == 0:
        return 0
    return 1 + count_letters(string[:-1])


def reverse_list(l):
    if len(l) == 0:
        return []
    return [l[-1]] + reverse_list(l[:-1])

Recursively reverse a list of elements.


def reverse_list(l):
    if len(l) == 0:
        return l
    return l[-1:] + reverse_list(l[:-1])

Recursively reverse a list of elements.


def sumup(x):
    x = x + sumup(x)
    return x

Return the sum of all integers up to n.


def sumup(n):
    if n == 0:
        return 0
    return n + sum_up_to(n - 1)

Return the sum of all integers up to n.


def maximum(list):
    if len(list) == 1:
        return list[0]
    elif list[0] > maximum(list[1:]):
        return list[0]
    else:
        return maximum(list[1:])


def fibonacci(l):
    if fibonacci(0) == 1 and fibonacci(1) == 1:
        return 1
    return fibonacci(n - 1) + fibonacci(n - 2)


def factorial(n):
    if n == 1:
        return 1
    return n * factorial(n - 1)


def fibonacci(l):
    if fibonacci(0) == 1 or fibonacci(1) == 1:
        return 1
    return fibonacci(n - 1) + fibonacci(n - 2)


def fibonacci(n):
    if n == 0:
        return 1
    elif n == 1:
        return 1
    return fibonacci(n - 1) + fibonacci(n - 2)


def fibonacci(l):
    if l == 1 or l == 1:
        return 1
    return fibonacci(n - 1) + fibonacci(n - 2)


def fibonacci(l):
    if l == 1 or l == 1:
        return 1
    return fibonacci(l - 1) + fibonacci(l - 2)


def fibonacci(l):
    if l == 0 or l == 1:
        return 1
    return fibonacci(l - 1) + fibonacci(l - 2)


def factorial(n):
    if n == 0:
        return 0
    return n * factorial(n - 1)


def fibonacci(n):
    if n == 0 or n == 1:
        return 1
    return fibonacci(n - 1) + fibonacci(n - 2)


def factorial(n):
    if n == 1:
        return 1
    prod_to_n_1 = factorial(n - 1)
    return n * prod_to_n_1


def sumup(n):
    if n > 0:
        n = n + sumup(n - 1)
    else:
        print(n)

Return the sum of all integers up to n.


def sumup(n):
    n = int(n)
    if n > 0:
        n = n + sumup(n - 1)
    else:
        print(n)

Return the sum of all integers up to n.


def sumup(n):
    n = int(n)
    if n > 0:
        n = n + sumup(n - 1)
        return n
    else:
        print(n)

Return the sum of all integers up to n.


def sumup(n):
    n = int(n)
    if n > 0:
        n = n + sumup(n - 1)
    else:
        return n

Return the sum of all integers up to n.


def reverse_list(l):
    if len(l) == 0:
        return l[0]
    return new.append(reverse_list[:-1])

Recursively reverse a list of elements.


def reverse_list(l):
    if len(l) == 0:
        return l[0]
    return l.append(reverse_list[:-1])

Recursively reverse a list of elements.


def reverse_list(a, new_a=None):
    if new_a == None:
        new_a = []
    if len(a) > 0:
        new_a.append(a.pop())
        return reverse_list(a, new_a)
    else:
        return new_a

Recursively reverse a list of elements.


def reverse_list(l):
    if len(l) == 0:
        return l[0]
    return l.append(reverse_list(l[:-1]))

Recursively reverse a list of elements.


def factorial(n):
    return 1 if n < 1 else n * factorial(n - 1)


def sumup(n):
    if n == 0:
        return 0
    elif n == 1:
        return 1
    return n + sumup(n - 1)

Return the sum of all integers up to n.


Return the sum of all integers up to n.


def reverse_list(l):
    if len(l) == 0:
        return l[0]
    return l.append(reverse_list(l[:1]))

Recursively reverse a list of elements.


def factorial(n):
    if n == 0:
        return 0
    if n == 1:
        return 1
    return n * factorial(n - 1)


def factorial(n):
    if n == 0:
        return 1
    if n == 1:
        return 1
    return n * factorial(n - 1)


def maximum(a):
    if len(a) == 1:
        return a[0]
    biggest = a.pop()
    x = maximum(a)
    if biggest < x:
        biggest = x
    return biggest


def minimum(a):
    if len(a) == 1:
        return a[0]
    smallest = a.pop(0)
    x = minimum(a)
    if smallest > minimum(a):
        smallest = x
    return smallest


def reverse_list(l):
    if len(l) == 0:
        return l[0]
    new = reverse_list(l[1:]) + l[:1]
    return new

Recursively reverse a list of elements.


def reverse_list(l):
    if len(l) == 0:
        return 1
    new = reverse_list(l[1:]) + l[:1]
    return new

Recursively reverse a list of elements.


def reverse_list(l=[]):
    if len(l) == 0:
        return 1
    new = reverse_list(l[1:]) + l[:1]
    return new

Recursively reverse a list of elements.


def reverse_list(l=[]):
    if len(l) == 0:
        return l
    new = reverse_list(l[1:]) + l[:1]
    return new

Recursively reverse a list of elements.


Recursively reverse a list of elements.


def fibonacci(n):
    if n <= 1:
        return n
    else:
        return fibonacci(n - 1) + fibonacci(n - 2)


def power(n, p):
    print('Oopsie woopsie I did something wrong!')

Raise m to the power of n.


def fibonacci(n):
    if n <= 1:
        return 1
    else:
        return fibonacci(n - 1) + fibonacci(n - 2)


def minimum(n):
    if len(n) == 1:
        return n[0]
    else:
        min_ret = minimum(n[1:])
        return n[0] if n[0] < min_ret else min_ret


def power(n, p):
    if p == 0:
        return 1
    if p == 1:
        return n
    return n ** p - 1

Raise m to the power of n.


def power(n, p):
    if p == 0:
        return 1
    if p == 1:
        return n + 1
    return n ** p - 1

Raise m to the power of n.


def sub_power(n, p):
    if p == 0:
        return 1
    if p == 1:
        return n
    return n ** p - 1

def power(n, p):

    def sub_power(n, p):
        if p == 0:
            return 1
        if p == 1:
            return n
        return n ** p - 1
    return sub_power(n, p) + 1

Raise m to the power of n.


def sub_power(n, p):
    if p == 0:
        return 1
    if p == 1:
        return n
    return n ** p - 1

def power(n, p):

    def sub_power(n, p):
        if p == 0:
            return 1
        if p == 1:
            return n
        return n ** p - 1
    if sub_power(n, p) + 1 == 1:
        return 2
    return sub_power(n, p) + 1

Raise m to the power of n.


def sub_power(n, p):
    if p == 0:
        return n
    if p == 1:
        return n
    return n ** p - 1

def power(n, p):

    def sub_power(n, p):
        if p == 0:
            return n
        if p == 1:
            return n
        return n ** p - 1
    return sub_power(n, p) + 1

Raise m to the power of n.


def sub_power(n, p):
    if p == 0:
        return p
    if p == 1:
        return n
    return n ** p - 1

def power(n, p):

    def sub_power(n, p):
        if p == 0:
            return p
        if p == 1:
            return n
        return n ** p - 1
    return sub_power(n, p) + 1

Raise m to the power of n.


Raise m to the power of n.


def power(x, y):
    if y == 0:
        return 1
    if y >= 1:
        return x * power(x, y - 1)

Raise m to the power of n.


def minimum(l):
    if len(l) == 1:
        return l[0]
    else:
        return min(l[0], minimum(l[1:]))


def minimum(a):
    if len(a) == 1:
        return a[0]
    if a[0] < a[1]:
        a.append(a[0])
    return minmum(a[1:])


def minimum(a):
    if len(a) == 1:
        return a[0]
    if a[0] < a[1]:
        a.append(a[0])
    return minimum(a[1:])


def maximum(a):
    if len(a) == 1:
        return a[0]
    if a[0] > a[1]:
        a.append(a[0])
    return minimum(a[1:])


def maximum(a):
    if len(a) == 1:
        return a[0]
    if a[0] > a[1]:
        a.append(a[0])
    return maximum(a[1:])


def count_letters(s, i=0):
    if s != '':
        i += 1
        return count_letters(s[1:], i)
    else:
        return i


def reverse_list(a, b=[]):
    if len(b) != len(a):
        b.append(a[-1])
        return reverse_list(a[:-1], b)
    else:
        return b

Recursively reverse a list of elements.


def reverse_list(a, b=[]):
    if len(b) != len(a) and len(a) != 0:
        b.append(a[-1])
        return reverse_list(a[:-1], b)
    else:
        return b

Recursively reverse a list of elements.


def sumup(num):
    if num == 0:
        return 0
    return num + sumup(num - 1)

Return the sum of all integers up to n.


Return the sum of all integers up to n.


def maximum(l):
    if len(l) == 1:
        return l[0]
    else:
        return max(l[0], maximum(l[1:]))


Recursively reverse a list of elements.


def factorial(n):
    if n == 0:
        return 1
    return n * factorial(n - 1)


def power(n, p):
    if p == 0:
        return 1
    return power(n ** p)

Raise m to the power of n.


def count_letters(s):
    if s == '':
        return 0
    else:
        return 1 + count_letters(s[1:])


def power(n, p):
    if p == 0:
        return 1
    return n ** p

Raise m to the power of n.


Raise m to the power of n.


def reverse_list(l):
    if len(l) == 1:
        return l[0]
    else:
        return l[::1], reverse_list(l[::1])

Recursively reverse a list of elements.


def minimum(l):
    if len(l) == 0:
        return 0
    lowest = 100
    for line in l:
        if line < lowest:
            lowest = line
    return minimum(lowest)


def reverse_list(l):
    if len(l) == 0:
        return []
    return [l[-1] + reverse_list(l[:-1])]

Recursively reverse a list of elements.


def sumup(n):
    if n == 0:
        return 0
    return n + sumup(n - 1)

Return the sum of all integers up to n.


def minimum(l):
    if l == []:
        return []
    lowest = 100
    for line in l:
        if line < lowest:
            lowest = line
    return minimum(lowest)


def reverse_list(l):
    if not l:
        return l
    return l[-1:] + reverse(l[:-1])

Recursively reverse a list of elements.


def reverse_list(l):
    if not l:
        return l
    return l[-1:] + reverse_list(l[:-1])

Recursively reverse a list of elements.


def reverse_list(a):
    if len(a) == 1 or len(a) == 0:
        return a
    return [a[-1]] + reverse_list[:-1]

Recursively reverse a list of elements.


def minimum(l):
    lowest = l[0]
    if l == []:
        return 0
    if l[0] < lowest:
        lowest = l[0]
    return minimum(l).pop(l[0])


def reverse_list(a):
    if len(a) == 1 or len(a) == 0:
        return a
    return [a[-1]] + reverse_list(a[:-1])

Recursively reverse a list of elements.


def minimum(l):
    lowest = 10000000000
    if l == []:
        return lowest
    if l[0] < lowest:
        lowest = l[0]
    return minimum(l[0]).pop


def minimum(l):
    lowest = 10000000000
    print(l[0])
    if l == []:
        return lowest
    if l[0] < lowest:
        lowest = l[0]
    return minimum(l[0]).pop


def minimum(l):
    lowest = 10000000000
    if l == []:
        return lowest
    if l < lowest:
        lowest = l[0]
    return minimum(l[0]).pop


def fibonacci(x):
    if x == 0:
        return 0
    elif x == 1:
        return 1
    else:
        return fibonacci(n - 1) + fibonacci(n - 2)


def fibonacci(x):
    if x == 0:
        return 0
    elif x == 1:
        return 1
    else:
        return fibonacci(x - 1) + fibonacci(x - 2)


def fibonacci(x):
    if x == 0:
        return 1
    elif x == 1:
        return 1
    else:
        return fibonacci(x - 1) + fibonacci(x - 2)


def minimum(l):
    lowest = 10000000000
    if l == []:
        return lowest
    if int(l[0]) < lowest:
        lowest = l[0]
    return minimum(l[0]).pop


def minimum(l):
    lowest = 10000000000
    if l == []:
        return lowest
    if int(l[0]) < lowest:
        lowest = int(l[0])
    return minimum(l[0]).pop


def minimum(l):
    for line in l:
        print(line)


def minimum(l):
    lowest = l[0]
    for line in l:
        if line < lowest:
            lowest = line
    return lowest


def maximum(l):
    max = 0
    if len(l) == 1:
        return l[0]
    elif l[0] > l[1]:
        return maximum.pop(l[1])
    else:
        return maximum.pop(l[0])


def maximum(l):
    max = 0
    if len(l) == 1:
        return l[0]
    elif l[0] > l[1]:
        return maximum(l).pop(l[1])
    else:
        return maximum(l).pop(l[0])


def maximum(l):
    if len(l) == 1:
        return l[0]
    elif l[0] > l[1]:
        return maximum(l).pop(l[1])
    else:
        return maximum(l).pop(l[0])


def maximum(l):
    if len(l) == 1:
        return l[0]
    elif l[0] > l[1]:
        return maximum(l.pop(l[1]))
    else:
        return maximum(l.pop(l[0]))


def maximum(l):
    if len(l) == 0:
        return 0
    if len(l) == 1:
        return l[0]
    elif l[0] > l[1]:
        return maximum(l.pop(l[1]))
    else:
        return maximum(l.pop(l[0]))


def maximum(l):
    m = 0
    for line in l:
        if line > m:
            m = line
    return m


def count_letters(s):
    count = 0
    if s == '':
        return count
    return count + 1, count_letters(s - s[0])


def count_letters(s):
    count = 0
    if s == '':
        return count
    return count + 1, count_letters(s.remove[s[0]])


def count_letters(s):
    count = 0
    if s == '':
        return count
    return count + 1, count_letters(s.replace[s[0], ''])


def count_letters(s):
    count = 0
    if s == '':
        return count
    return count + 1, count_letters(s)


def count_letters(s):
    count = 0
    if s == '':
        return count
    count + 1
    s = s - s[0]
    return count_letters(s)


def sumup(n):
    if n == 0:
        return 0
    else:
        return n + sumup(n - 1)

Return the sum of all integers up to n.


Return the sum of all integers up to n.


def factorial(n):
    if n == 0:
        return 1
    return n * factorial(n - 1)


def minimum(li):
    if len(li) == 1:
        return li[0]
    if li[0] < li[-1]:
        li[-1] = li[0]
    return minimum(li[1:])


def maximum(li):
    if len(li) == 1:
        return li[0]
    if li[0] > li[-1]:
        li[-1] = li[0]
    return maximum(li[1:])


def count_letters(s, n=0):
    if len(s) == 0:
        return n
    return count_letters(s[1:], n + 1)


def reverse_list(li, n=0):
    if n == int(len(li) / 2):
        return li
    else:
        li[n], li[-n - 1] = li[-n - 1], li[n]
        return reverse_list(li, n + 1)

Recursively reverse a list of elements.


Recursively reverse a list of elements.


def fibonacci(n):
    if n == 1 or n == 0:
        return 1
    return fibonacci(n - 1) + fibonacci(n - 2)


def sumup(n):
    if n == 1:
        return
    sum_to_n = sumup(n - 1)
    return n + sum_to_n

Return the sum of all integers up to n.


def sumup(n):
    if n == 1:
        return 1
    sum_to_n = sumup(n - 1)
    return n + sum_to_n

Return the sum of all integers up to n.


def minimum(a):
    if len(a) == 1:
        return a[0]
    small = a[0]
    if small < minimum(a[1:]):
        return small
    else:
        return minimum(a[1:])


def maximum(a):
    if len(a) == 1:
        return a[0]
    big = a[0]
    if big > maximum(a[1:]):
        return big
    else:
        return maximum(a[1:])


def factorial(n):
    if n == 1:
        return 1
    return n * factorial(n - 1)


def factorial(n):
    if n < 2:
        return 1
    return n * factorial(n - 1)


def sumup(n):
    if n < 2:
        return 1
    sum_to_n = sumup(n - 1)
    return n + sum_to_n

Return the sum of all integers up to n.


def sumup(n):
    if n < 2:
        return n
    sum_to_n = sumup(n - 1)
    return n + sum_to_n

Return the sum of all integers up to n.


def power(n, m):
    if m == 0:
        return 1
    return n * power(n, m - 1)

Raise m to the power of n.


Raise m to the power of n.


def fibonacci(n, older=0, old=1):
    if n == 0:
        return old
    return fibonacci(n - 1, old, older + old)


def minimum(l):
    if len(l) == 1:
        return l
    f, m = l[0], minimum(l[1:])
    if f < m:
        return f
    else:
        return m


def sumup(n):
    if n == 1:
        return n
    return n + sumup(n - 1)

Return the sum of all integers up to n.


def factorial(n):
    if n == 1:
        return n
    return n * factorial(n - 1)


def sumup(n):
    if n == 0:
        return n
    return n + sumup(n - 1)

Return the sum of all integers up to n.


Return the sum of all integers up to n.


def factorial(n):
    if n == 0:
        return n
    return n * factorial(n - 1)


def factorial(n):
    if n == 0:
        return n + 1
    return n * factorial(n - 1)


def power(m, n):
    if n == 0:
        return 1
    return m * power(m, n - 1)

Raise m to the power of n.


def power(m, n):
    if n < 1:
        return 1
    return m * power(m, n - 1)

Raise m to the power of n.


def sumup(n):
    if n == 0:
        return 0
    return n + sumup(n - 1)

Return the sum of all integers up to n.


def factorial(n):
    if n == 0 or n == 1:
        return 1
    return n * factorial(n - 1)


def power(m, n):
    if m == 1:
        return 1
    return m ** power(m, n)

Raise m to the power of n.


def minimum(l):
    if len(l) == 1:
        return l
    else:
        return mini(l[0], minimum(l[1:]))


def count_letters(s):
    total = 0
    if len(s) == 0:
        return 0
    return 1 + count_letters(s[1:])


def sumup(n):
    if n == 1:
        return 1
    else:
        return n + sumup(n - 1)

Return the sum of all integers up to n.


def sumup(n):
    if n == 0:
        return 0
    else:
        return n + sumup(n - 1)

Return the sum of all integers up to n.


def sumup(n):
    if n == 1:
        return 1
    else:
        return n * sumup(n - 1)

Return the sum of all integers up to n.


def sumup(n):
    if n == 0:
        return 1
    else:
        return n * sumup(n - 1)

Return the sum of all integers up to n.


def sumup(n):
    print(n)
    if n == 0:
        return 1
    else:
        return n * sumup(n - 1)

Return the sum of all integers up to n.


def sumup(n):
    if n == 0:
        return 0
    else:
        return n * sumup(n - 1)

Return the sum of all integers up to n.


def factorial(n):
    if n == 0:
        return 1
    else:
        return n * sumup(n - 1)


def factorial(n):
    if n == 0:
        return 1
    else:
        return n * factorial(n - 1)


def power(n, p):
    if p == 1:
        return n
    else:
        return n * power(n, p - 1)

Raise m to the power of n.


def power(n, p):
    if p == 0:
        return 1
    if p == 1:
        return n
    else:
        return n * power(n, p - 1)

Raise m to the power of n.


Raise m to the power of n.


def minimum(l):
    if len(l) == 1:
        return l[0]
    else:
        l = min(l[0], miminum(l[1:]))
        return l


def minimum(l):
    if len(l) == 1:
        return l[0]
    else:
        l = min(l[0], mininum(l[1:]))
        return l


def minimum(l):
    if len(l) == 1:
        return l[0]
    else:
        l = min(l[0], minimum(l[1:]))
        return l


def maximum(l):
    if len(l) == 1:
        return l[0]
    else:
        l = max(l[0], maximum(l[1:]))
        return l


def count_letters(s):
    if s == '':
        return 0
    else:
        return 1 + count_letters(s.replace(s[0], '', 1))


def reverse_list(l):
    if len(l) == 1:
        return l
    else:
        return reverse_list(l[1:]).append(l.pop(s[0]))

Recursively reverse a list of elements.


def reverse_list(l):
    if len(l) == 1:
        return l
    else:
        return reverse_list(l[1:]).append(l.pop(l[0]))

Recursively reverse a list of elements.


def reverse_list(l):
    if len(l) == 1:
        return l
    else:
        return reverse_list(l[1:]).append(l.pop(0))

Recursively reverse a list of elements.


def reverse_list(l):
    if len(l) == 0:
        return []
    else:
        return reverse_list(l[1:]).append(l.pop(0))

Recursively reverse a list of elements.


def reverse_list(l):
    if len(l) == 0:
        return []
    else:
        l = reverse_list(l[1:]) + l.pop(0)
        return l

Recursively reverse a list of elements.


def reverse_list(l):
    if len(l) == 0:
        return []
    else:
        l = reverse_list(l[1:]) + list(l.pop(0))
        return l

Recursively reverse a list of elements.


def reverse_list(l):
    if len(l) == 1:
        return l
    else:
        j = l.pop(0)
        return reverse_list(l).append(j)

Recursively reverse a list of elements.


def reverse_list(l):
    if len(l) == 1:
        return l
    else:
        j = list(l.pop(0))
        return reverse_list(l) + j

Recursively reverse a list of elements.


def reverse_list(a):
    if a == []:
        return a
    return [a[-1]] + reverse_list(a[:-1])

Recursively reverse a list of elements.


Recursively reverse a list of elements.


def sumup(n):
    if n == 0:
        return 0
    return n + sumup(n - 1)

Return the sum of all integers up to n.


Return the sum of all integers up to n.


def factorial(n):
    if n == 0:
        return 0
    return n * factorial(n - 1)


def factorial(n):
    if n == 0:
        return 1
    return n * factorial(n - 1)


def power(m, n):
    if n == 0:
        return 1
    return m * power(m, n - 1)

Raise m to the power of n.


Raise m to the power of n.


def minimum(l):
    if len(l) == 1:
        return l[0]
    if l[0] <= minimum(l[1:]):
        return l[0]
    else:
        return minimum(l[n + 1:])


def maximum(l):
    if len(l) == 1:
        return l[0]
    if l[0] >= maximum(l[1:]):
        return l[0]
    else:
        return maximum(l[n + 1:])


def count_letters(s):
    if s == '':
        return 0
    return 1 + count_letters(s[1:])


def count_letters(s, i=0):
    i += 1
    if i == len(s):
        return 1
    if len(s) > 0:
        return 1 + count_letters(s, i)
    else:
        return 0


def reverse_list(l):
    if len(l) == 0:
        return []
    return l[-1:] + reverse_list(l[:-1])

Recursively reverse a list of elements.


def fibonacci(n):
    if n == 0 or n == 1:
        return 1
    return fibonacci(n - 1) + fibonacci(n - 2)


def maximum(n):
    if len(n) == 1:
        return n[0]
    m = maximum(n[1:])
    return n[0] if n[0] > m else m


def sumup(n):
    sum = 0
    for x in range(0, n):
        sum += x
    return sum

Return the sum of all integers up to n.


def sumup(n):
    sum = 0
    for x in range(0, n + 1):
        sum += x
    return sum

Return the sum of all integers up to n.


def factorial(n):
    if n == 1:
        return 1
    return n * factorial(n - 1)


def factorial(n):
    product = 1
    for x in range(0, n + 1):
        product *= x
    return product


def factorial(n):
    product = 1
    for x in range(1, n + 1):
        product *= x
    return product


def minimum(l):
    min = 10000000000
    for x in l:
        if x < min:
            min = x
    return min


def power(m, n):
    if n == 0:
        return m
    m *= n
    return power(m, n - 1)

Raise m to the power of n.


def power(m, n):
    if n == 0:
        return m
    m *= m
    return power(m, n - 1)

Raise m to the power of n.


def power(m, n):
    if n == 0:
        return m
    m = m * m
    return power(m, n - 1)

Raise m to the power of n.


def power(m, n):
    if n == 0:
        return m
    m = m ** 2
    return power(m, n - 1)

Raise m to the power of n.


def power(m, n):
    if n == 1:
        return m
    m = m ** 2
    return power(m, n - 1)

Raise m to the power of n.


def power(m, n):
    if n == 0:
        return m
    new = m * m
    return new

Raise m to the power of n.


def power(m, n):
    if n == 0:
        return m
    return m * power(m, n - 1)

Raise m to the power of n.


def power(m, n):
    if n == 1:
        return m
    return m * power(m, n - 1)

Raise m to the power of n.


Raise m to the power of n.


def count_letters(s):
    if s == '':
        return 0
    s = s.replace(s[-1], '', 1)
    return count_letters(s) + 1


def sumup(n):
    if n == 0:
        return n
    return n + sumup(n - 1)

Return the sum of all integers up to n.


Return the sum of all integers up to n.


def factorial(n):
    if n <= 1:
        return 1
    return n * factorial(n - 1)


def reverse_list(l):
    if len(l) == 1:
        return l
    else:
        return reverse_list(l) + list(l.pop(0))

Recursively reverse a list of elements.


def reverse_list(l):
    if len(l) == 1:
        return l
    else:
        return list(l.pop(0)) + reverse_list(l)

Recursively reverse a list of elements.


def reverse_list(l):
    if len(l) == 2:
        return l
    else:
        return list(l.pop(0)) + reverse_list(l)

Recursively reverse a list of elements.


Recursively reverse a list of elements.


def fibonacci(n):
    num_one = 0
    num_two = 1
    while i < n:
        num_two = num_two + num_one
        num_one = num_two - num_one
        i = i + 1
    return num_two


def fibonacci(n):
    num_one = 0
    num_two = 1
    i = 0
    while i < n:
        num_two = num_two + num_one
        num_one = num_two - num_one
        i = i + 1
    return num_two


def power(n, p):
    if n == 0:
        return 0
    return n ** power(n, p - 1)

Raise m to the power of n.


def power(n, p):
    if p == 0:
        return 0
    return n ** power(n, p - 1)

Raise m to the power of n.


def power(n, p):
    if p == 0:
        return 1
    return n * power(n, p - 1)

Raise m to the power of n.


def minimum(l):
    if len(l) == 1:
        return l[0]
    elif l[0] < l[1]:
        l.remove(l[1])
    else:
        l.remove(l[0])
    return minimum(l)


def maximum(l):
    if len(l) == 1:
        return l[0]
    elif l[0] > l[1]:
        l.remove(l[1])
    else:
        l.remove(l[0])
    return maximum(l)


def count_letters(s):
    if s == '':
        return 0
    return 1 + count_letters(s[1:])


def reverse_list(l, l1=None):
    if l1 is None:
        l1 = []
    if l == []:
        return l1
    l1.append(l[-1])
    return reverse_list(l[:-1], l1)

Recursively reverse a list of elements.


def fibonacci(n):
    if n == 0 or n == 1:
        return 1
    return fibonacci(n - 1) + fibonacci(n - 2)


def sumup(n):
    if n == 1:
        return 1
    sum_to_n_1 = sumup(n - 1)
    return n + sum_to_n_1

Return the sum of all integers up to n.


Return the sum of all integers up to n.


def count_letters(s):
    if s == '':
        return 0
    elif s != '':
        s = list(s)
        s.pop()
        count += 1
        count_letters(s.join())
    else:
        return count_letters(s)


def count_letters(s):
    count = 0
    if s == '':
        return 0
    elif s != '':
        s = list(s)
        s.pop()
        count += 1
        count_letters(s.join())
    else:
        return count_letters(s)


def count_letters(s):
    count = 0
    if s == '':
        return 0
    elif s != '':
        s = list(s)
        s.pop()
        count += 1
        count_letters(''.join(s))
    else:
        return count_letters(s)


def count_letters(s):
    count = 0
    if s == '':
        return 0
    elif s != '':
        s = list(s)
        s.pop()
        count += 1
        return count_letters(''.join(s))
    else:
        return count_letters(s)


def count_letters(s):
    if s == '':
        return 0
    else:
        return count_letters(s[:-1]) + 1


def minimum(l):
    if len(l) == 1:
        return l[0]
    f, m = l[0], minimum(l[1:])
    if f < m:
        return f
    else:
        return m


def count_letters(s):
    count = 0
    if s == '':
        return count
    elif s != '':
        s = list(s)
        s.pop()
        """""".join(s)
        count += 0
        return count_letters(s)


def count_letters(s):
    count = 0
    if s == '':
        return count
    elif s != '':
        s = list(s)
        s.pop()
        """""".join(s)
        print(count)
        count += 1
        return count_letters(s)


def reverse_list(l):
    if l == []:
        return []
    elif len(l) == 1:
        return l
    else:
        return reverse_list(l[1:]).append(l[0])

Recursively reverse a list of elements.


def reverse_list(l):
    if l == []:
        return []
    elif len(l) == 1:
        return l
    else:
        return reverse_list(l[-1:]).append(l[0])

Recursively reverse a list of elements.


Recursively reverse a list of elements.


def reverse_list(l):
    if l == []:
        return []
    elif len(l) == 1:
        return l
    else:
        return reverse_list(l[len(l) - 2:]).append(l[0])

Recursively reverse a list of elements.


def power(m, n):
    if n == 0:
        return m
    m = m * m
    return power(m, n - 1)

Raise m to the power of n.


def power(m, n):
    if n == 0:
        return m
    return m * power(m, n - 1)

Raise m to the power of n.


def fibonacci(n):
    if n == 0:
        return 1
    else:
        return fibonacci(n - 1) + fibonacci(n - 2)


def fibonacci(n):
    if n == 0 or n == 1:
        return 1
    else:
        return fibonacci(n - 1) + fibonacci(n - 2)


def count_letters(s):
    count = 0
    if s == '':
        return count
    elif s != '':
        s = list(s)
        s.pop()
        """""".join(s)
        count += 1
        return count_letters(s)


def sumup(n):
    if n == 0:
        return 0
    return n - sumup(n - 1)

Return the sum of all integers up to n.


def sumup(n):
    if n == 0:
        return 0
    return n + sumup(n - 1)

Return the sum of all integers up to n.


Return the sum of all integers up to n.


def factorial(n):
    if n == 0:
        return 0
    return n * factorial(n)


def factorial(n):
    if n == 0:
        return 0
    return n * factorial(n - 1)


def factorial(n):
    if n == 1:
        return 1
    return n * factorial(n - 1)


def count_letters(s):
    s = list(s)
    if s == []:
        return 0
    else:
        count = 0
        for c in s:
            count += 1
        return count


def power(m, n):
    if n == 0:
        return 1
    return m ** power(n - 1)

Raise m to the power of n.


def reverse_list(l):
    if l == []:
        return []
    else:
        return reverse_list(l[1:]).append(l[0])

Recursively reverse a list of elements.


def reverse_list(l):
    if l == []:
        return []
    else:
        return list(reverse_list(l[1:])).append(l[0])

Recursively reverse a list of elements.


def reverse_list(l):
    if l == []:
        return []
    elif len(l) == 1:
        return l
    else:
        return reverse_list(l[1:]).append(l[0])

Recursively reverse a list of elements.


Recursively reverse a list of elements.


def reverse_list(l=[]):
    if len(l) == 0:
        return l
    else:
        return reverse_list(l[1:]) + l[:1]

Recursively reverse a list of elements.


def reverse_list(l=[]):
    if len(l) == 0:
        return l
    else:
        return reverse_list(l[1:]) + l[0]

Recursively reverse a list of elements.


def reverse_list(l):
    if len(l) == 0:
        return l
    else:
        return reverse_list(l[1:]) + l[:1]

Recursively reverse a list of elements.


def fibonacci(n):
    if n <= 1:
        return 1
    return fibonacci(n - 1) + fibonacci(n - 2)


def minimum(n):
    if len(n) == 1:
        return n[0]
    else:
        min_ret = minimum(n[1:])
        return n[0] if n[0] > min_ret else min_ret


def maximum(n):
    if len(n) == 1:
        return n[0]
    else:
        min_ret = minimum(n[1:])
        return n[0] if n[0] > min_ret else min_ret


def maximum(n):
    if len(n) == 1:
        return n[0]
    else:
        min_ret = maximum(n[1:])
        return n[0] if n[0] > min_ret else min_ret


def power(m, n):
    if n == 0:
        return 1
    return m * power(m, n - 1)

Raise m to the power of n.


Raise m to the power of n.


def sumup(x):
    if x == 0:
        return 0
    return x + sumup(x - 1)

Return the sum of all integers up to n.


def count_letters(s):
    if s == '':
        return 0
    return 1 + count_letters(s[1:])


def factorial(x):
    if x == 1:
        return 1
    return x * factorial(x - 1)


Return the sum of all integers up to n.


def factorial(x):
    if x == 0:
        return 0
    if x == 1:
        return 1
    return x * factorial(x - 1)


def factorial(x):
    if x >= 1:
        return 1
    return x * factorial(x - 1)


def factorial(x):
    if x <= 1:
        return 1
    return x * factorial(x - 1)


def maximum(a):
    if len(a) == 1:
        return a[0]
    return maximum(a.remove(min(a)))


def maximum(a):
    if len(a) == 1:
        return list(a[0])
    return maximum(a.remove(min(a)))


Recursively reverse a list of elements.


def sumup(n):
    if n == 0:
        return 0
    return n + sumup(n - 1)

Return the sum of all integers up to n.


def factorial(n):
    if n == 1:
        return 1
    return n * factorial(n - 1)


def factorial(n):
    if n == 0:
        return 1
    return n * factorial(n - 1)


def fibonacci(m):
    if m == 1 or m == 0:
        return 1
    return fibonacci(m - 1) + fibonacci(m - 2)


def fibonacci(x):
    if x == 0:
        return 1
    elif x == 1:
        return 1
    else:
        return fibonacci(x - 1) + fibonacci(x - 2)


def minimum(a):
    if len(a) == 1:
        return a[0]
    smallest = minimum(a[1:])
    if a[0] < smallest:
        smallest = a[0]
    return smallest


def maximum(a):
    if len(a) == 1:
        return a[0]
    biggest = maximum(a[1:])
    if a[0] > biggest:
        biggest = a[0]
    return biggest


def sumup(n):
    if n == 1:
        return 1
    return n + sumup(n - 1)

Return the sum of all integers up to n.


def sumup(n):
    if n == 1:
        return 1
    if n != 0:
        return n + sumup(n - 1)
    else:
        return 0

Return the sum of all integers up to n.


def factorial(n):
    if n == 1 or n == 0:
        return 1
    return n * factorial(n - 1)


def power(m, n):
    if m == 0:
        return 1
    return n * power(n, m - 1)

Raise m to the power of n.


def power(m, n):
    if m == 0:
        return 1
    return n * power(m, n - 1)

Raise m to the power of n.


Raise m to the power of n.


def power(n, m):
    if m == 0:
        return 1
    return n * power(n, m - 1)

Raise m to the power of n.


def power(m, n):
    if n == 0:
        return 1
    if n == 1:
        return m
    return m * power(m, n - 1)

Raise m to the power of n.


def power(n, e):
    if e == 0:
        return 1
    return n * power(n, e - 1)

Raise m to the power of n.


def minimum(a):
    if len(a) == 1:
        return a[0]
    if a[0] < minimum(a[1:]):
        return a[0]
    else:
        return minimum(a[1:])


def maximum(a):
    if len(a) == 1:
        return a[0]
    if a[0] > maximum(a[1:]):
        return a[0]
    else:
        return maximum(a[1:])


def power(m, n):
    if n == 0:
        return 1
    return m ** power(n, e - 1)

Raise m to the power of n.


def factorial(n):
    if n == 1:
        return 1
    return n * factorial(n - 1)


def factorial(n):
    if n == 0:
        return 0
    elif n == 1:
        return 1
    return n * factorial(n - 1)


def factorial(n):
    if n == 0:
        return 1
    elif n == 1:
        return 1
    return n * factorial(n - 1)


def count_letters(word):
    if word == '':
        return 0
    return 1 + count_letters(word[1:])


def minimum(l):
    if len(l) == 1:
        return l[0]
    if l[0] < l[1]:
        l.remove(l[1])
    elif l[0] > l[1]:
        l.remove(l[0])
    return minimum(l)


def minimum(l):
    if len(l) == 1:
        return l[0]
    if l[0] > l[1]:
        l.remove(l[1])
    elif l[0] < l[1]:
        l.remove(l[0])
    return minimum(l)


def maximum(l):
    if len(l) == 1:
        return l[0]
    if l[0] > l[1]:
        l.remove(l[1])
    elif l[0] < l[1]:
        l.remove(l[0])
    return maximum(l)


def factorial(n):
    if n == 0:
        return 1
    return n * factorial(n - 1)


def reverse_list(a):
    if len(a) == 1:
        return a[0]
    return a[-1] + reverse_list(a[::-1])

Recursively reverse a list of elements.


def count_letters(s):
    if s == '':
        return 0
    return 1 + count_letters(s[1:])


def reverse_list(a):
    if len(a) == 1:
        return a[0]
    return [a[-1]] + reverse_list(a[::-1])

Recursively reverse a list of elements.


def reverse_list(a):
    if len(a) == 1:
        return a[0]
    return [a[:-1]] + reverse_list(a[::-1])

Recursively reverse a list of elements.


def reverse_list(a):
    if len(a) == 1:
        return a[0]
    return [a[:-1]] + reverse_list(a[:-1])

Recursively reverse a list of elements.


def reverse_list(a):
    if len(a) == 1 or len(a) == 0:
        return a
    return [a[:-1]] + reverse_list(a[:-1])

Recursively reverse a list of elements.


def reverse_list(a):
    if len(a) == 1 or len(a) == 0:
        return a
    return [a[-1]] + reverse_list(a[:-1])

Recursively reverse a list of elements.


Recursively reverse a list of elements.


def fibonacci(n):
    if n == 1 or n == 0:
        return 1
    return fibonacci(n - 1) + fibonacci(n - 2)


def power(m, n):
    if n == 0:
        return 1
    return m * power(m, n - 1)

Raise m to the power of n.


Raise m to the power of n.


def fibonacci(n):
    if n == 0 and n == 1:
        return 1
    return fibonacci(n - 1) + fibonacci(n - 2)


def fibonacci(n):
    if n == 0 or n == 1:
        return 1
    return fibonacci(n - 1) + fibonacci(n - 2)


def minimum(a):
    if len(a) == 1:
        return a[0]
    if a[-2] < a[-1]:
        return minimum(a[:-1])
    else:
        return minimum(a[:-2] + a[-1:])


def sumup(n):
    if n == 0:
        return 0
    return n + sumup(n - 1)

Return the sum of all integers up to n.


Return the sum of all integers up to n.


def factorial(n):
    if n == 1:
        return 1
    return n + factorial(n)


def factorial(n):
    if n == 1:
        return 1
    return n + factorial(n - 1)


def factorial(n):
    if n == 1:
        return 1
    return n * factorial(n - 1)


def factorial(n):
    if n == 0:
        return 1
    return n * factorial(n - 1)


def power(x, y):
    if y == 1:
        return x
    return x * power(x, y - 1)

Raise m to the power of n.


def power(x, y):
    if y == 0:
        return 1
    return x * power(x, y - 1)

Raise m to the power of n.


def minimum(l):
    if len(l) == 1:
        return l[0]
    else:
        min_a, min_b = l[0], minimum(l[1:])
        if min_a > min_b:
            min_a = min_b
        return min_a


def maximum(l):
    if len(l) == 1:
        return l[0]
    else:
        max_a, max_b = l[0], maximum(l[1:])
        if max_a < max_b:
            max_a = max_b
        return max_a


def count_letters(s):
    if len(s) == 0:
        return 0
    return 1 + count_letters(s[1:])


def reverse_list(l):
    if not l:
        return []
    return [l.pop()] + reverse_list(l)

Recursively reverse a list of elements.


Recursively reverse a list of elements.


def count_letters(s):
    count = 0
    while s[i] != '':
        count += 1
        return count_letters(s)
    return count


def count_letters(s):
    count = 0
    i = 0
    while s[i] != '':
        count += 1
        i += 1
        return count_letters(s)
    return count


def count_letters(s):
    count = 0
    for x in s:
        count += 1
        return count_letters(s)
    return count


def count_letters(s):
    count = 0
    for x in s:
        count += 1
        return count_letters(s[1:])
    return count


def count_letters(s):
    if s == '':
        return count
    count = 0
    count += 1
    return count_letters(s[1:])
    return count


def count_letters(s):
    count = 0
    if s == '':
        return count
    count = 0
    count += 1
    return count_letters(s[1:])


def count_letters(s):
    count = 0
    if s == '':
        return count
    count += 1
    return count_letters(s[1:])


def count_letters(s):
    if s == '':
        return count
    else:
        count += 1
    return count_letters(s[1:])


def count_letters(s):
    count = 0
    if s == '':
        return count
    return 1 + count_letters(s[1:])


def sumup(n):
    return sum(list(range(n))) + n

Return the sum of all integers up to n.


Return the sum of all integers up to n.


def reverse_list(l):
    if len(l) == reverse_list():
        return l
    return 1 + reverse_list(l[-1] + l[:-1])

Recursively reverse a list of elements.


def reverse_list(l):
    if len(l) == reverse_list(l):
        return l
    return 1 + reverse_list(l[-1] + l[:-1])

Recursively reverse a list of elements.


def reverse_list(l):
    return reverse_list(l[-1] + l[:-1])

Recursively reverse a list of elements.


def reverse_list(l):
    return l[-1] + reverse_list(l[:-1])

Recursively reverse a list of elements.


def reverse_list(l):
    return l.reverse()

Recursively reverse a list of elements.


def reverse_list(l):
    if len(l) == 0:
        return []
    return [l[-1]] + reverse_list(l[:-1])

Recursively reverse a list of elements.


Recursively reverse a list of elements.


def fibonacci(n):
    if n == 0 or n == 1:
        return 1
    return fibonacci(n - 1) + fibonacci(n - 2)


def factorial(n):
    return product(list(range(n))) * n


def factorial(n=0):
    return product(list(range(n))) * n


def factorial(n=0):
    return math.factorial(n)


Raise m to the power of n.


def fibonacci(n):
    if n < 2:
        return 1
    return fibonacci(n - 2) + fibonacci(n - 1)


def reverse_list(l):
    l2 = []
    if len(l) == 1:
        l2.append(l.pop(-1))
    while len(l) >= 1:
        l2.append(l.pop(-1))
    return l2

Recursively reverse a list of elements.


def maximum(n=[]):
    return max(maximum(n))


def count_letters(s=''):
    return count(s)


def count_letters(s=''):
    return len(s)


def reverse_list(l=[]):
    return l.reverse()

Recursively reverse a list of elements.


def reverse_list(l=[]):
    return l.sort(reverse=True)

Recursively reverse a list of elements.


def reverse_list(l=[]):
    i = 0
    while i < len(l):
        new_list = new_list.append(l[len(l) - i])
        i += 1

Recursively reverse a list of elements.


def reverse_list(l=[]):
    i = 0
    new_list = []
    while i < len(l):
        new_list.append(l[len(l) - i])
        i += 1
    return new_list

Recursively reverse a list of elements.


def reverse_list(l=[]):
    i = 0
    new_list = []
    while i < len(l):
        new_list.append(l[len(l) - i - 1])
        i += 1
    return new_list

Recursively reverse a list of elements.


def reverse_list(l):
    l2 = []
    while len(l) >= 1:
        l2.append(l.pop(-1))
    return l2

Recursively reverse a list of elements.


Recursively reverse a list of elements.


def sumup(n):
    if n == 0:
        return 0
    return n + sumup(n - 1)

Return the sum of all integers up to n.


Return the sum of all integers up to n.


def factorial(n):
    if n == 0:
        return 1
    return n * factorial(n - 1)


def power(m, n):
    if n == 0:
        return 1
    return m * power(m, n - 1)

Raise m to the power of n.


Raise m to the power of n.


def minimum(l):
    if len(l) == 1:
        return l[0]
    return minimum(l[1:] if l[0] > l[1] else l[:-1])


def minimum(l):
    if len(l) == 1:
        return l[0]
    return minimum(l[1:] if l[0] > l[-1] else l[:-1])


def maximum(l):
    if len(l) == 1:
        return l[0]
    return maximum(l[1:] if l[0] < l[-1] else l[:-1])


def count_letters(s):
    if not s:
        return 0
    return 1 + count_letters(s[1:])


def reverse_list(l):
    if len[l] == 0:
        return l
    return l[-1:] + reverse_list(l[:-1])

Recursively reverse a list of elements.


def reverse_list(l):
    if len(l) == 0:
        return l
    return l[-1:] + reverse_list(l[:-1])

Recursively reverse a list of elements.


def fibonacci(n):
    if n == 0:
        return 1
    if n == 1:
        return 1
    return fibonacci(n - 1) + fibonacci(n - 2)


def factorial(n):
    if n < 1:
        return 1
    return n * factorial(n - 1)


def power(m, n):
    if n == 0:
        return 1
    return m ** power(m, n - 1)

Raise m to the power of n.


def count_letters(n, word):
    if len(word) == 0:
        return 0
    if word[0] == n:
        count = 1
    else:
        return count + count_letters(n, word[1:])


def reverse_list(li):
    newli = []
    if len(li) == 1:
        return li
    x = li.pop()
    newli.append(x)
    s = reverse_list(li)
    for i in s:
        newli.append(i)
    return newli

Recursively reverse a list of elements.


def reverse_list(li):
    newli = []
    if len(li) == 1:
        return li
    x = li.pop()
    newli = reverse_list(li)
    newli.append(x)
    return newli

Recursively reverse a list of elements.


def reverse_list(li):
    newli = []
    if len(li) == 1:
        return li
    x = li.pop(0)
    newli = reverse_list(li)
    newli.append(x)
    return newli

Recursively reverse a list of elements.


def reverse_list(li):
    try:
        newli = []
        if len(li) == 1:
            return li
        x = li.pop(0)
        newli = reverse_list(li)
        newli.append(x)
        return newli
    except:
        return li

Recursively reverse a list of elements.


def reverse_list(li):
    newli = []
    if len(li) == 1 or len(li) == 0:
        return li
    x = li.pop(0)
    newli = reverse_list(li)
    newli.append(x)
    return newli

Recursively reverse a list of elements.


Recursively reverse a list of elements.


def sumup(n):
    if n == 0:
        return 0
    else:
        return n + sumup(n - 1)

Return the sum of all integers up to n.


Return the sum of all integers up to n.


def factorial(n):
    if n == 0:
        return 1
    return n * factorial(n - 1)


def power(n, m):
    if m == 1:
        return n
    if m == 0:
        return 1
    return n * power(n, m - 1)

Raise m to the power of n.


Raise m to the power of n.


def minimum(l):
    if len(l) == 1:
        return l[0]
    if l[0] < l[1]:
        l.remove(l[1])
    else:
        l.remove(l[0])
    return minimum(l)


def maximum(l):
    if len(l) == 1:
        return l[0]
    if l[0] > l[1]:
        l.remove(l[1])
    else:
        l.remove(l[0])
    return maximum(l)


def count_letters(s, n=0):
    if len(s) == 0:
        return n
    return count_letters(s[1:], n + 1)


def reverse_list(li, n=0):
    if n == int(len(li) / 2):
        return li
    else:
        li[n], li[-n - 1] = li[-n - 1], li[n]
        return reverse_list(li, n + 1)

Recursively reverse a list of elements.


def fibonacci(n):
    if n == 0:
        return 1
    elif n == 1:
        return 1
    return fibonacci(n - 1) + fibonacci(n - 2)


def minimum(n):
    if len(n) == 1:
        return n[0]
    else:
        min_ret = minimum(n[1:])
        return n[0] if n[0] > min_ret else min_ret