In this Kata, we define an arithmetic progression as a series of integers in which the differences between adjacent numbers are the same. You will be given an array of ints of `length > 2` and your task will be to convert it into an arithmetic progression by the following rule:
```Haskell
For each element there are exactly three options: an element can be decreased by 1, an element can be increased by 1 
or it can be left unchanged.
```
Return the minimum number of changes needed to convert the array to an arithmetic progression. If not possible, return `-1`.
```Haskell
For example: 
solve([1,1,3,5,6,5]) == 4 because [1,1,3,5,6,5] can be changed to [1,2,3,4,5,6] by making 4 changes.
solve([2,1,2]) == 1 because it can be changed to [2,2,2]
solve([1,2,3]) == 0  because it is already a progression, and no changes are needed.
solve([1,1,10) == -1 because it's impossible.
solve([5,6,5,3,1,1]) == 4. It becomes [6,5,4,3,2,1]
```

More examples in the test cases. Good luck!

Difficulty: introductory

Starter code:

def solve(arr):
	

Solutions:
def solve(arr):
    res = []
    for first in (arr[0]-1, arr[0], arr[0]+1):
        for second in (arr[1]-1, arr[1], arr[1]+1):
            val, step, count = second, second-first, abs(arr[0]-first) + abs(arr[1]-second)
            for current in arr[2:]:
                val += step
                if abs(val-current) > 1: break
                count += abs(val-current)
            else:
                res.append(count)
    return min(res, default=-1)

def solve(arr):
    def isProgression(array):
        prevstep = array[1] - array[0]
        for j, v in enumerate(array[1:]):
            curstep = array[j + 1] - array[j]
            if curstep != prevstep:
                return False
            prevstep = curstep

        return True

    if isProgression(arr):
        return 0

    lst = [arr]
    chg = [0]
    good = [isProgression(arr)]

    for j in range(len(arr)):
        for k in range(len(lst)):
            if j>2 and isProgression(lst[k][:j-1]) is not True:
                continue
            lstp1 = lst[k][:j] + [lst[k][j] + 1] + lst[k][j + 1:]
            lst.append(lstp1)
            chg.append(chg[k] + 1)
            good.append(isProgression(lstp1))

            lstm1 = lst[k][:j] + [lst[k][j] - 1] + lst[k][j + 1:]
            lst.append(lstm1)
            chg.append(chg[k] + 1)
            good.append(isProgression(lstm1))

    filtered_lst = [x for j, x in enumerate(lst) if good[j]]
    filtered_chg = [x for j, x in enumerate(chg) if good[j]]

    if len(filtered_lst) == 0:
        return -1

    return min(filtered_chg)

solve=lambda a,d={-1,0,1}:min((sum(l)for l in([abs(a[0]+u+(a[1]+v-a[0]-u)*n-x)for n,x in enumerate(a)]for u in d for v in d)if set(l)<=d),default=-1)

solve=lambda a,d=(-1,0,1):min((sum(l)for l in([abs(a[0]+u+q*n-x)for n,x in enumerate(a)]for u in d for q,r in(divmod(a[-1]+v-a[0]-u,len(a)-1)for v in d)if r<1)if all(x in d for x in l)),default=-1)

def solve(arr):
    n = len(arr)
    k, s = n - 1, n + 1
    d = arr[k] - arr[0]
    for d in range((d - 2) // k, (d + 2) // k + 1):
        for i in (-1, 0, 1):
            p = [abs(arr[0] + i + d * k - q) for k, q in enumerate(arr)]
            if max(p) < 2: s = min(s, sum(p))
    return (-1 if s > n else s)

def solve(arr):

    head = arr[0]
    tail = arr[-1]
    
    check = [(i,j) for i in range(head-1,head+2) for j in range(tail-1,tail+2)]
    
    possibles = []
    for start, end in check:
        if (end-start)%(len(arr)-1) == 0:
            possibles.append((start,end))
    
    global_changes = float('inf')
    
    for start, end in possibles:
        
        diff = int((end-start)/(len(arr)-1))
        
        if diff == 0: tester = [start]*len(arr)
        else: tester = list(range(start, end+diff, diff))
        
        current_changes = 0
        
        for i in range(len(tester)):
            if abs(tester[i] - arr[i]) > 1:
                current_changes = float('inf')
                break
            elif abs(tester[i] - arr[i]) == 1:
                current_changes += 1
        
        global_changes = min(current_changes, global_changes)
                
    
    return global_changes if global_changes != float('inf') else -1

import numpy as np
def solve(arr):
    l = len(arr)
    fst = arr[0]
    lst = arr[l-1]
    diff_range = lst - fst
    diffs = []
    for diff in range(diff_range - 2, diff_range + 3):
        if diff == 0:
            diffs.append(diff)
        elif diff % (l - 1) == 0:
            diffs.append(diff)
    
    progs = []
    for diff in diffs:
        for i in range(-1, 2):
            for j in range(-1, 2):
                if fst + i + diff == lst + j:
                  seq = []
                  if diff == 0:
                    seq = l * [fst+i]
                  else:
                    k = 1
                    if diff < 0:
                        k = -1 
                    seq = list(np.arange(fst + i, lst + j + k, diff / (l - 1)))
                  if len(seq) == l:
                      progs.append(seq)
      
    changes = []
    for seq in progs:
        change = 0
        complete = True
        for a,b in zip(seq,arr):
            diff = abs(a-b)
            if diff > 1:
              complete = False
              continue
            if diff != 0:
              change += 1
        if complete:
          changes.append(change)
  
    if len(changes) == 0:
      return -1
    return min(changes)


from itertools import product

def solve(arr):
    res = []
    for p, q in product([-1, 0, 1], repeat=2):
        step = (arr[-1] + q - (arr[0] + p)) / (len(arr) - 1)
        if step.is_integer():
            exp = range(arr[0]+p, arr[-1]+q+int(step), int(step)) if step else [arr[0]+p] * len(arr)
            res.append(sum(abs(a - e) if abs(a - e) in (0, 1) else float('inf') for a, e in zip(arr, exp)))
    return min(res) if min(res, default=float('inf')) != float('inf') else -1

def solve(a):
    r = []
    for i in range(-1, 2):
        for j in range(-1, 2):
            curr_diff = a[-1]-a[0]+j-i
            if curr_diff%(len(a)-1) == 0:
                curr_a = [a[0]+i] + a[1:-1] + [a[-1]+j] 
                k = curr_diff//(len(a)-1)
                t = [abs(curr_a[0]+i*k-a[i]) for i in range(len(a))]  
                if max(t) <= 1: r.append(sum(t))
                    
    return min(r) if r else -1

def solve(ls):
    result = [ls[each]-ls[each-1] for each in range(1, len(ls))] 
    gap = round(sum(result)/len(result))
    tries = [ls[0]+1, ls[0], ls[0]-1] 
    answer = []
    
    while True:
        count = 0    
        copy_ls = ls[:]
        
        copy_ls[0] = tries.pop(0)
        if copy_ls[0] != ls[0]:
            count += 1
        
        for each in range(len(ls)-1):
            sub_gap = copy_ls[each+1] - copy_ls[each]
            if sub_gap < gap:
                copy_ls[each+1] += 1
                count += 1
            elif sub_gap > gap:
                copy_ls[each+1] -= 1
                count += 1
        
        result = [copy_ls[each]-copy_ls[each-1] for each in range(1, len(ls))]
        
        if len(set(result)) == 1:
            answer.append(count)
        if len(tries) == 0:
            if len(answer) == 0:
                return -1
            else:
                answer.sort()
                return answer[0]