Как найти арифметическая прогрессия python

import numpy as np
from collections import deque
from itertools import combinations

# data = np.array([1487, 1847, 4817, 4871, 7481, 7841, 8147, 8741])

np.random.seed(42)
data = np.random.randint(0, 100000, 1000)
data.sort()

# Интуитивный подход (baseline), O(n^3)
def find_evenly_spaced_v1(data):
    for a, b, c in combinations(data, 3):
        if b - a == c - b:
            yield a, b, c
            
# Эмпирическая оптимизация, O(n^2)
def find_evenly_spaced_v2(data):
    dataset = set(data)
    for a, c in combinations(data, 2):
        b, mod = divmod(a + c, 2)
        if (mod == 0) and (b in dataset):
            yield a, b, c

# Векторный вариант
def find_evenly_spaced_v3(data):
    grid = data.reshape(-1, 1) + data.reshape(1, -1)
    divs, mods = np.divmod(grid, 2)
    mask = np.tri(*grid.shape, -1, dtype='bool') & np.isin(divs, data) & ~ mods.astype('bool')
    for c, a in zip(*np.where(mask)):
        b = divs[a, c]
        a, c = data[[a, c]]
        yield a, b, c

Измерения скорости для 1000 элементов:

M arithmetic progressions each having N terms (with the terms differing by d1,d2,…dm) are passed as input with the terms shuffled. The program must print the terms in M arithmetic progressions in sequential order with the smallest starting term first.

Example Input/Output 1:

Input: 2
       1 4 8 12 7 16 
Output: 1 4 7 8 12 16
Explanation: There are two progressions. Hence 6/2 = 3 terms in each progression. So the first A.M has 1 4 7 and the second has 8 12 16 As 1 < 8, 1 4 7 is printed followed by 8 12 16

Example Input/Output 2:

Input: 3
       2 6 8 10 15 22 12 11 4
Output: 2 4 6 8 15 22 10 11 12 

Explanation: There are three progressions. Hence 9/3 = 3 terms in each progression. So the first A.M has 2 4 6 and the second has 8 15 22. The third has 10 11 12. Note: We cannot have 8 10 12 as the second progression as the remaining numbers 11 15 22 do not for an arithmetic progression.`

I thought of an approach to initially sort the numbers and then generate a list of lists containing the difference of each number with every other number.

inp=raw_input()
inputList=[int(c) for c in inp]
inputList.sort()
for i in range(0,len(inputList)):
   for j in range(0,len(inputList)):
      if(i!=j): #To avoid zeros
         newlist.append(abs(inputList[j]-inputList[i]))

Then, map each of the numbers in the same place with that in the other list. Thus, a sequence can be identified. But it didn’t work out. Is there a better way to solve this problem (preferably in Python)?

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

Синтаксис:

range(stop)
range(start, stop)
range(start, stop, step)

Параметры:

• start — int, начало последовательности,
• stop — int, конец последовательности,
• step — int, шаг последовательности.

Возвращаемое значение:

• int, последовательность целых чисел, с заданным шагом.

Описание:

Класс range() (диапазон) генерирует арифметическую прогрессию целых чисел, с заданным шагом. По существу это отдельный неизменяемый тип данных в языке Python. Диапазоны реализуют все общие операции с последовательностями, кроме конкатенации и повторения, поскольку объекты диапазона могут представлять только последовательности, которые следуют строгому шаблону, а повторение и конкатенация обычно нарушают этот шаблон.

Последовательности реализуют интерфейс ABC collections.abc.Sequence, и предоставляют такие возможности как проверка вхождения if num in range, обращение к элементу по индексу range[i], поиск индекса элемента, взятие среза и отрицательную индексацию.

Аргументы конструктора класса range() должны быть целыми числами, или любым объектом, который реализует специальный метод __index__. Если аргумент шага step опущен, по умолчанию используется значение step=1. Если аргумент start пропущен, то по умолчанию используется значение start=0. Если шаг равен нулю step=1, бросается исключение ValueError.

• Для положительного шага содержимое диапазона range() определяется по формуле r[i] = start + step*i, где i >= 0 и r[i] < stop
• Для отрицательного шага содержимое диапазона range() так же определяется по формуле r[i] = start + step*i, но есть ограничения i >= 0 и r[i] > stop.

Объект range() будет пустым, если r[0] не соответствует ограничению значения. Диапазоны поддерживают отрицательные индексы, но они интерпретируются как индексация с конца последовательности, которая определена положительными индексами.

Диапазоны, содержащие абсолютные значения, превышающие допустимые sys.maxsize будут работать, но некоторые функции, например len(), могут вызывать OverflowError.

Проверка range() на равенство при помощи == и != сравнивает их как последовательности. Это означает, что два диапазона равны, если они представляют одинаковую последовательность значений. Обратите внимание, что два равных диапазона могут иметь разные start, stop и step. Например: range(0) == range(2, 1, 3) или range(0, 3, 2) == range(0, 4, 2).

Преимущество типа данных range над списками list или кортежами tuple в том, что диапазоны range всегда будут занимать небольшое количество памяти, независимо от размера диапазона, которое он представляет, так как он хранит в памяти только значение start, stop и step, а элементы последовательности вычисляется по мере необходимости.

Пример использования range().

• Примеры создания арифметических последовательностей;
• Примеры операций с классом range();
• Пример использования range() в цикле for/in;
• Пример использования range() для генерации float значений;

Примеры создания арифметических последовательностей.

# Общие примеры
>>> list(range(10))
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
>>> list(range(1, 11))
[1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
>>> list(range(0, 30, 5))
[0, 5, 10, 15, 20, 25]
>>> list(range(0, 10, 3))
[0, 3, 6, 9]
>>> list(range(0, -10, -1))
[0, -1, -2, -3, -4, -5, -6, -7, -8, -9]
>>> list(range(0))
[]
>>> list(range(1, 0))
[]

Примеры операций с классом range().

>>> r = range(0, 20, 2)

# Проверка вхождения
>>> 11 in r
False
>>> 10 in r
True

# Поиск индекса элемента 
>>> r.index(10)
5

# Обращение к элементу по его индексу
>>> r[5]
10

# Срез диапазона 
>>> r[:5]
range(0, 10, 2)
>>> r[-1]
18

Пример использования range() в цикле for/in.

# отсчет с нуля
>>> for i in range(0, 5):
...     print(i)
... 
# 0
# 1
# 2
# 3
# 4

# отсчет с единицы
>>> for i in range(1, 6):
...     print(i)
... 
# 1
# 2
# 3
# 4
# 5

# использование шага в циклах
>>> for n, i in enumerate(range(0, 7, 2), 1):
...     print(f'{n}) => {i}')
... 
# 1) => 0
# 2) => 2
# 3) => 4
# 4) => 6

# обратный отсчет с шагом в циклах 
# при помощи класса `range()`
>>> for n, i in enumerate(range(-7, 0, 2), 1):
...     print(f'{n}) => {abs(i)}')
... 
# 1) => 7
# 2) => 5
# 3) => 3
# 4) => 1

Пример использования range() для генерации float значений.

Для генерации последовательности чисел с шагом 0.1, необходимо умножить результат функции range() на 0.1, а затем округлить значение при помощи round() (т.к. математика типа float в Python не совсем точная).

>>> for i in range(100):
...     n = round(i * 0.1, 1)
...     print(n)
... 
# 0.0
# 0.1
# 0.2
# 0.3
# ...
# 9.6
# 9.7
# 9.8
# 9.9

Генерация float с шагом 0.5:

>>> for i in range(0, 30, 5):
...     n = round(i * 0.1, 1)
...     print(n)
... 
# 0.0
# 0.5
# 1.0
# 1.5
# 2.0
# 2.5

Генерация float с шагом 0.02:

>>> for i in range(0, 30, 2):
...     # умножаем на 0.01 и округляем до 
...     # 2-х значений после запятой
...     n = round(i * 0.01, 2)
...     print(n)
... 
# 0.0
# 0.02
# 0.04
# 0.06
# 0.08
# 0.1
# ...
# 0.22
# 0.24
# 0.26
# 0.28