In this kata, your task is to identify the pattern underlying a sequence of numbers. For example, if the sequence is [1, 2, 3, 4, 5], then the pattern is [1], since each number in the sequence is equal to the number preceding it, plus 1. See the test cases for more examples.

A few more rules :

pattern may contain negative numbers.
sequence will always be made of a whole number of repetitions of the pattern.
Your answer must correspond to the shortest form of the pattern, e.g. if the pattern is [1], then [1, 1, 1, 1] will not be considered a correct answer.

Difficulty: EASY
Starter code: def find_pattern(seq):
	

Solutions:
from itertools import cycle

def find_pattern(s):
	diffs = [y - x for (x, y) in zip(s, s[1:])]
	for i in range(1, len(diffs) + 1):
		if len(diffs) % i == 0 and all((a == b for (a, b) in zip(diffs, cycle(diffs[:i])))):
			return diffs[:i]


def find_pattern(seq):
	(start, end) = ([], [])
	for i in range(len(seq) - 1):
		start.append(seq[i + 1] - seq[i])
		end.append(seq[-1 - i] - seq[-2 - i])
		if not (len(seq) - 1) % len(start) and start == end[::-1] and (not len(set(start)) == 1):
			return start
	return [start[0]] if len(set(start)) == 1 else []


from operator import sub

def find_pattern(sequence):
	result = list(map(sub, sequence[1:], sequence))
	size = len(result)
	for i in range(1, size + 1):
		(q, r) = divmod(size, i)
		if r == 0:
			check = result[:i]
			if check * q == result:
				return check


def find_pattern(sequence):
	diff = [b - a for (a, b) in zip(sequence, sequence[1:])]
	return next((diff[:i] for i in range(1, len(diff) + 1) if diff[i:] + diff[:i] == diff))


def find_pattern(a):
	d = [a[i + 1] - a[i] for i in range(len(a) - 1)]
	l = len(d)
	return next((d[:i] for i in range(1, len(d) + 1) if l % len(d[:i]) == 0 and d[:i] * (l // len(d[:i])) == d))


def find_pattern(a):
	diff = [a[i + 1] - a[i] for i in range(len(a) - 1)]
	l = len(diff)
	for i in range(1, len(diff) + 1):
		t = diff[:i]
		if l % len(t) == 0:
			if t * (l // len(t)) == diff:
				return t


def find_pattern(seq):
	xs = [b - a for (a, b) in zip(seq, seq[1:])]
	return next((xs[:i] for i in range(1, len(xs) // 2 + 1) if xs[:i] * (len(xs) // i) == xs), xs)


def find_pattern(sequence):
	pattern = [a - b for (a, b) in zip(sequence[1:], sequence)]
	for size in range(1, len(pattern) + 1):
		if len(pattern) // size * pattern[:size] == pattern:
			return pattern[:size]


def find_pattern(seq):
	(n, diffs) = (len(seq) - 1, [b - a for (a, b) in zip(seq, seq[1:])])
	for l in range(1, n + 1):
		if n // l * diffs[:l] == diffs:
			return diffs[:l]