Рубрики
Без рубрики

Понимание последовательности Collatz в Python

Последовательность Collatz в python проста. Если предыдущий член четный, то следующий член равен n/2, если нечетный, то следующий член равен 3n+1. Последний член равен 1.

Автор оригинала: Team Python Pool.

Понимание последовательности Collatz в Python

Привет, кодеры!! В этой статье мы познакомимся с последовательностью collatz в Python. Сначала мы поймем, что это значит. Затем мы будем следовать ему, понимая реализацию последовательности collatz в Python. Итак, давайте сразу перейдем к теме.

Что такое последовательность коллатца?

Предположим, что существует положительное целое число n. Тогда следующий член последовательности коллатца будет следующим:

  • Если предыдущий член четный, то следующий член равен половине предыдущего члена, то есть n/2
  • Если предыдущий член нечетен, то следующий член в 3 раза больше предыдущего плюс 1, то есть 3n+1
  • Гипотеза состоит в том, что независимо от того, какое значение n, последовательность всегда будет достигать 1

Иллюстрация последовательности коллатца:

Рассмотрим первое число последовательности как 3.

2-й семестр:

  • Предыдущий член равен 3, что странно.
  • Итак, следующий семестр будет (3*3 + 1) 10.

3-й семестр:

  • Предыдущий срок равен 10, что даже
  • Итак, следующий член будет (10/2) 5.

4-й семестр:

  • Предыдущий термин-5, что странно.
  • Итак, следующий семестр будет (3*5 + 1) 16.

5-й семестр:

  • Предыдущий срок-16, что даже
  • Итак, следующий член будет (16/2) 8.

6-й семестр:

  • Предыдущий термин равен 8, что даже
  • Итак, следующий член будет (8/2) 4.

7-й семестр:

  • Предыдущий термин равен 4, что является четным
  • Итак, следующий член будет (4/2) 2.

8-й семестр:

  • Предыдущий член равен 2, что является четным
  • Итак, следующий член будет (2/2) 1.

Поскольку мы достигли значения 1, последовательность теперь завершена.

 3, 10, 5, 16, 8, 4, 2, 1

Функция гипотезы Коллатца в python:

def Collatz(n): 

	while n: 
		print(n,) 

		if n & 1: 
		 * n + 1

		else: 
		 // 2
	print(n) 

Collatz(21)

Выход:

21, 64, 32, 16, 8, 4, 2, 1

Это простой код, который мы использовали для реализации последовательности collatz Python. Мы определили функцию Collatz (), которая принимает в качестве входных данных целочисленную переменную. Затем мы использовали цикл while для печати последовательности. Сначала мы проверяем n-й член. Если он четный, мы меняем его на n/2. В противном случае мы меняем его на 3n+1 и печатаем этот термин. Мы продолжаем этот процесс до тех пор, пока число не станет 1, давая желаемый результат.

Гипотеза Коллаца Рекурсия Python:

def collatz(n):
    list1 = [n]
    if n :
        return [1]                 
    elif n % 2 :
        
        list1.extend(collatz(n//2))     
    else:
        list1.extend(collatz(n*3+1))    
    return list1

collatz(21)

Выход:

[21, 64, 32, 16, 8, 4, 2, 1]

В этом коде мы использовали рекурсию для получения последовательности коллатца. Мы проверяем параметр, который передается функции collatz (). Если это 1, то есть последний член последовательности, то рекурсия прекращается, и 1 возвращается в список. В противном случае, если элемент четный, функция collatz() рекурсивно вызывается со значением n/2, и результат расширяется до списка. Однако если элемент нечетный, функция collatz() рекурсивно вызывается со значением 3*n+1, и результат расширяется до списка. В конце концов список возвращается, давая желаемый результат.

Самая длинная последовательность коллатца python:

import time.time()
# to cache the values
cache = {n: 0 for n in range(1,1000000)}
# initial values
# looping through the numbers
for n in range(3,1000000):
   
   
    while n > 1:
        if n < current:
           [n] + counter
            break
        if n%2:
           /2
            counter
        else:
           *n+1
            counter
print(list(cache.values()).index(max(cache.values()))+1)
print(time.time()-start)
837799
4.36925745010376

В этом коде мы использовали словарь для хранения предварительно вычисленных значений последовательности collatz. Мы уменьшаем временную сложность программы с O(n^2) до O(nlogn). Поскольку нам нужно найти самую большую последовательность между 1 и 1 миллионом, мы будем использовать кэш, чтобы сэкономить время для пересчета. Эта техника называется href=”https://en.wikipedia.org/wiki/Memoization”>Memoization. href=”https://en.wikipedia.org/wiki/Memoization”>Memoization.

Memoization-это процесс хранения результатов, которые уже были вычислены. В этом коде мы использовали технику запоминания, чтобы оптимизировать наш код. Мы создали словарь “кэш”. Затем мы повторяем цикл до 1 миллиона, чтобы найти число, которое сгенерирует самую длинную последовательность коллатца. Мы храним все уникальные числа в словаре ” кэш ” и, наконец, выводим число с максимальной последовательностью коллатца. Время, затраченное этим кодом на выполнение, составляет 4.36925745010376 из-за оптимизации с использованием memoization.

Ниже приведен тот же код, выполненный без запоминания:

import time.time()
def collatzSeq(n):
   
   
    while current:
        if current % 2:
           /2
            chainNumber
        else:
            current = (3*current) + 1
            chainNumber
    return [chainNumber, n]
data = []
for i in range(2, 1000000):
    data.append(collatzSeq(i))
print(sorted(data,)[:1][0][1])
print('Time:', time.time() - start)
837799 
Time: 27.117942571640015

Когда приведенный выше код будет выполнен, вы заметите, что он занимает примерно на 30 секунд больше, чем тот, с кодом запоминания. Таким образом, вы можете ясно видеть разницу между временем, затраченным двумя кодами.

Collatz Python sequence Infinite loop bug:

def collatz(n):
    if n % 2:
        // 2
        print(n)
        return n
    elif n % 2:
        * 3 + 1
        print(n)
        return n

print('Enter an Integer')(input())
while n > 1:
    collatz(n)

Когда мы запускаем приведенный выше код, мы видим, что застреваем в бесконечном цикле. Это происходит потому, что return содержит новое значение только в том случае, если вы назначаете его переменной. Чтобы исправить эту ошибку, нам нужно отформатировать код следующим образом:

while n > 1:
   (n)

Гипотеза Коллаца количество шагов:

Мы можем изменить нашу программу последовательности коллатца, чтобы получить количество шагов, участвующих в получении последовательности коллатца числа.

def collatz(n):
    if n:
        return 0
   
    while n:
        n = (n / 2) if n % 2 else (3 * n + 1)
        cnt
    return cnt

print(collatz(3))
8

Как вы можете видеть, мы только что изменили приведенный выше код и использовали переменную счетчика ” cnt ” для вычисления количества шагов, необходимых для получения гипотезы Коллатца.

Должен Читать

  • Битоническая сортировка: Алгоритм и реализация в Python
  • Серия Фибоначчи в Python и программа чисел Фибоначчи
  • Алгоритм Витерби: Реализация на Python
  • Использование функции Python Max Как Pro | Python max()

Вывод:

На этом мы заканчиваем нашу статью. В этой статье мы узнали о последовательности коллатца. Мы также узнали, как реализовать последовательность collatz в Python как рекурсивно, так и нерекурсивно.

Однако, если у вас есть какие-либо сомнения или вопросы, дайте мне знать в разделе комментариев ниже. Я постараюсь помочь вам как можно скорее.

Счастливого Пифонирования!

Читайте ещё по теме: