Решение модуля 7.7 Добрый, добрый Python

Модуль 7.7 Рекурсивные функции.

Что такое рекурсивная функция?

это функция, которая вызывает саму себя

Вводится целое положительное число N. Необходимо написать рекурсивную функцию с именем get_rec_N, которая отображает на экране последовательность целых чисел от 1 до N (включительно). Каждое число выводится с новой строки. 

В качестве параметра функция get_rec_N должна принимать одно числовое значение. То есть, иметь только один параметр. Начальный вызов функции будет выглядеть так:

get_rec_N(N)

Вызывать функцию не нужно, только объявить.

# считывание числа N
N = int(input())

#здесь продолжайте программу
def get_rec_N(num):         # объявляем функцию, которая принимает число в качестве аргумента
    if num>0:               # если число больше 0, то
        get_rec_N(num-1)    # вызываем снова функцию, таким образом мы доходим до 1
        print(num)          # выводим числа, с 1 и до заданного числа, т.к. мы с нашего числа опустились до 1 и выводили числа поднимаясь обратно к числу

Вводится список целых чисел в одну строчку через пробел. Необходимо вычислить сумму этих введенных значений, используя рекурсивную функцию (для перебора элементов списка) с именем get_rec_sum. Функция должна возвращать значение суммы. (Выводить на экран она ничего не должна).

Вызовите эту функцию и выведите вычисленное значение суммы на экран.

def get_rec_sum(n):     # объявляем функцию, которая принимает список
    if len(n) == 1:     # Проверяем длину списка и если длина = 1,
        return n[0]     # то возвращаем единственно значение из списка. Это и есть первая сумма списка.
                        # Если условие ложно, то идем дальше
    return n[0] + get_rec_sum(n[1:]) # Здесь мы извлекаем первое значение из списка и к нему плюсуем оставшийся список (вернее его значение), но если второе слагаемое еще не посчитано, то приостанавливается первый вызов ф-ции и приступаем к новому вызову ф-ции 
a = input().split()     # получаем строку с числами и разбиваем на список
res = []                # создаем пустой список
for i in a:             # циклом проходимся по введённому списку 
    res.append(int(i))  # каждое число(с типом строка) преобразуем в тип числа
print(get_rec_sum(res)) # выводим результат вывода функции

Вводится натуральное число N. Необходимо с помощью рекурсивной функции fib_rec(N, f=[]) (здесь N — общее количество чисел Фибоначчи; f — начальный список этих чисел) сформировать последовательность чисел Фибоначчи по правилу: первые два числа равны 1 и 1, а каждое следующе значение равно сумме двух предыдущих. Пример такой последовательности для первых 7 чисел: 1, 1, 2, 3, 5, 8, 13, …

Функция должна возвращать список сформированной последовательности длиной N.

Вызывать функцию не нужно, только объявить.

# ввод числа N
N = int(input())

def fib_rec(N, f=[1, 1]): #объявляем функцию которая принимает число- количество чисел из ряда и список с начальными чисалми
    if N > 2:                   # если ввели число больше двух
        f.append(f[-1] + f[-2]) # то в список добавляем сумму предыдущих 2 чисел
        fib_rec(N - 1, f)       # и вызываем функцию с числом уменьшенным на 1 и измененным списком
    return f                    # возращаем список с числами из ряда

Вводится целое неотрицательное число n. Необходимо с помощью рекурсивной функции fact_rec вычислить факториал числа n. Напомню, что факториал числа, равен: n! = 1 * 2 * 3 *…* n. Функция должна возвращать вычисленное значение.
Вызывать функцию не нужно, только объявить со следующей сигнатурой:

def fact_rec(n): ...

# ввод числа n
n = int(input())


def fact_rec(n):       # объявляем функцию,которая принимает число, для нахождения факториала
    if n == 0:         # если ввели ноль, то возвращаем 1, т.к. факториал от 0 равен 1
        return 1
    return fact_rec(n-1) * n  # иначе возвращаем функцию с числом уменьшенным на 1 и унажаем на насчальное число

Имеется следующий многомерный список:

d = [1, 2, [True, False], ["Москва", "Уфа", [100, 101], ['True', [-2, -1]]], 7.89]

С помощью рекурсивной функции get_line_list создать на его основе одномерный список из значений элементов списка d. Функция должна возвращать новый созданный одномерный список.  (Только возвращать, выводить на экран ничего не нужно.)

Вызывать функцию не нужно, только объявить со следующей сигнатурой:

def get_line_list(d,a=[]): ...

где d — исходный список; a — новый формируемый.

d = [1, 2, [True, False], ["Москва", "Уфа", [100, 101], ['True', [-2, -1]]], 7.89]

def get_line_list (d,a=[]):   # объявляем функцию, которая принимает список и пустой список
    for i in d:               # проходимся по заданному списку
        if type(i) != list:   # если тип элемента не список
            a.append(i)       # добавляем его в пустой список
        elif type(i) == list: # если это список
            get_line_list(i)  # то вызываем функцию передавая этот список
    return a                  # возвращаем готовый список

Лягушка прыгает вперед и может скакнуть либо на одно деление, либо сразу на два. Наша задача определить количество вариантов маршрутов, которыми лягушка может достичь риски под номером N (натуральное число N вводится с клавиатуры).

Решать задачу следует с применением рекурсивной функции. Назовем ее get_path. Алгоритм решения будет следующий. Рассмотрим, например, риску под номером 4. Очевидно, в нее лягушка может скакнуть либо с риски номер 2, либо с риски номер 3. Значит, общее число вариантов перемещений лягушки можно определить как: 

get_path(4) = get_path(3) + get_path(2)

Аналогично будет справедливо и для любой риски N:

get_path(N) = get_path(N-1) + get_path(N-2)

А начальные условия задачи, следующие:

get_path(1) = 1
get_path(2) = 2

Реализуйте такую рекурсивную функцию, которая должна возвращать количество вариантов перемещений лягушки для риски под номером N.

Вызовите эту функцию для введенного числа N и отобразите результат на экране.

def get_path(N):      # объявляем функцию, которая принимает число
    total = 0         # переменная счетчик
    if N == 0:        # если ввели - 0, то она никуда не сдвинется и останется в той же точке
        return total
    elif N == 1:      # если ввели 1, то есть только 1 вариант туда попасть
        return total + 1
    elif N == 2:      # если ввели 2, то есть только 2 варианта туда попасть
        return total + 2
    else:             # иначе возвращем сумму от вызова функций с уменьшенным числом на 1 и на 2
        return get_path(N-1) + get_path(N-2)

#вызов функции
end = int(input())
print(get_path(end))

Вводится список из целых чисел в одну строчку через пробел. Необходимо выполнить его сортировку по возрастанию с помощью алгоритма сортировки слиянием. Функция должна возвращать новый отсортированный список.
Вызовите результирующую функцию сортировки для введенного списка и отобразите результат на экран в виде последовательности чисел, записанных через пробел.

Подсказка. Для разбиения списка и его последующей сборки используйте рекурсивные функции.

P. S. Теория сортировки в видео предыдущего шага.

def sort_merg(lst):
    if len(lst) == 1:                            # условие выхода из рекурсии
        return lst                               # выход из рекурсии
    cent = len(lst)//2                           # поиск середины списка
    left_lst = sort_merg(lst[:cent])             # рекурсивный запуск на деление первой части
    right_lst = sort_merg(lst[cent:])            # рекурсивный запуск на деление второй части
    return combine_lst(left_lst, right_lst, [])  # запуск функции слияния списков

def combine_lst(lst_a, lst_b, comb):
    if len(lst_a+lst_b) > 0:                        # пока в списках что то есть
        a, b = lst_a[:1],lst_b[:1]                  # присвоим значения срезами, на случай пустого
        if a and a >= b: comb.append(lst_a.pop(0))  # добавляем в список слияния большее
        if b and b >= a: comb.append(lst_b.pop(0))  # добавляем в список слияния большее
        return combine_lst(lst_a, lst_b, comb)      # рекурсивно запускаем повтор
    else:
        return comb                                 # возвращаем комбинированый список
    
lst = [int(i) for i in input().split()]    # ввод с клавиатуры
print(*sort_merg(lst)[::-1])               # вывод результата функции

Если у вас не отображается решение последних задач, значит у вас включен блокировщик рекламы который вырезает эти ответы

Понравилась статья? Поделиться с друзьями:
Подписаться
Уведомить о
guest

0 комментариев
Межтекстовые Отзывы
Посмотреть все комментарии
0
Оставьте комментарий! Напишите, что думаете по поводу статьи.x