Your task is to find the first element of an array that is not consecutive.

By not consecutive we mean not exactly 1 larger than the previous element of the array.

E.g. If we have an array `[1,2,3,4,6,7,8]` then `1` then `2` then `3` then `4` are all consecutive but `6` is not, so that's the first non-consecutive number.

```if:c
If a non consecutive number is found then return `true` and set the passed in pointer to the number found.

If the whole array is consecutive then return `false`.
```
```if-not:c
If the whole array is consecutive then return `null`^(2).
```
The array will always have at least `2` elements^(1) and all elements will be numbers. The numbers will also all be unique and in ascending order. The numbers could be positive or negative and the first non-consecutive could be either too!

If you like this Kata, maybe try this one next: https://www.codewars.com/kata/represent-array-of-numbers-as-ranges

```if:c
^(1) Can you write a solution that will return `false` for both `[]` and `[ x ]` (an empty array and one with a single number) though? (This is an empty array and one with a single number and is not tested for, but you can write your own example test. )
```
```if-not:c
^(1) Can you write a solution that will return `null`^(2) for both `[]` and `[ x ]` though?  (This is an empty array and one with a single number and is not tested for, but you can write your own example test. )

^(2)  
Swift, Ruby and Crystal: `nil`  
Haskell: `Nothing`  
Python, Rust: `None`  
Julia: `nothing`  
Nim: `none(int)` (See [options](https://nim-lang.org/docs/options.html))
```

Difficulty: introductory

Starter code:

def first_non_consecutive(arr):
	

Solutions:
def first_non_consecutive(arr):
    if not arr: return 0
    for i, x in enumerate(arr[:-1]):
        if x + 1 != arr[i + 1]:
            return arr[i + 1]

def first_non_consecutive(a):
    i = a[0]
    for e in a:
        if e != i:
            return e
        i += 1
    return None

def first_non_consecutive(arr):
    for i in range(1, len(arr)):
        if arr[i] - arr[i-1] > 1:
            return arr[i]

def first_non_consecutive(arr):
    return next((j for i, j in zip(arr, arr[1:]) if i + 1 != j), None)

def first_non_consecutive(arr):
    for i, v in enumerate(arr, arr[0]):
        if v != i:
            return v

def first_non_consecutive(arr):
    for b in range(len(arr) - 1):
        if arr[b + 1] - arr[b] != 1:
            return arr[b + 1]


def first_non_consecutive(arr):
    for i, j in zip(arr, arr[1:]):
        if abs(j-i) > 1:
            return j
    return None

def first_non_consecutive(arr):
    init = arr[0]
    for i in arr:
        if init != i:
            return i
        else:
            init += 1
    return None

def first_non_consecutive(arr):
    pre=arr[0]-1
    for e in arr:
        if e-pre!=1:
            return e
        pre=e
    return


def first_non_consecutive(arr):
    if not arr:
        return None

    for i, x in enumerate(arr, arr[0]):
        if i != x:
            return x

    return None

def first_non_consecutive(a):
    return [e for i,e in enumerate(a + [None]) if e != a[0] + i][0]

def first_non_consecutive(arr):
    a = [x+1 for x in range(min(arr), max(arr)+1) if x not in arr]
    return None if a == [] else a[0]

def first_non_consecutive(arr):
    for i in range(1,len(arr)):
        if arr[i-1]+ 1 < arr[i]:
            return arr[i]


def first_non_consecutive(arr):
    for x in range(min(arr), max(arr)+1):
        if x not in arr:
            return x+1

def first_non_consecutive(arr):
    for n in range(len(arr) - 1):
        if arr[n + 1] != arr[n] + 1:
            return arr[n + 1]
    return None

def first_non_consecutive(arr):
    for i, q in enumerate(arr, arr[0]):
        if i != q:
            return q

def first_non_consecutive(arr):
    b = arr.pop(0);
    for i in arr:
        if b + 1 == i : b = i;
        else: return i

def first_non_consecutive(arr):
    for index in range(len(arr)-1):
        if abs(arr[index+1] - arr[index]) != 1:
            return arr[index+1]
    return None

def first_non_consecutive(a):
    for i, x in enumerate(a, a[0]):
        if i != x:
            return x

def first_non_consecutive(arr):
    for ind in range(1, len(arr)):
        if arr[ind] - arr[ind-1] > 1:
            return arr[ind]

def first_non_consecutive(list):
    tmp = ''
    for item in list:
        if tmp == '':
            tmp = str(item)
        else:
            if item == int(tmp) + 1:
                tmp = str(item)
            else:
                return item

def first_non_consecutive(arr):
    k = arr[0]
    for i in arr:
        if i!=k:
            return i
        k+=1
    return None

def first_non_consecutive(arr):
  for i in range(1,len(arr)):
    if ( arr[i] - arr[i-1] != 1 ): return arr[i]
  else:
    return None

def first_non_consecutive(arr):
    for x in range(1,len(arr)):
        if arr[x]-1 != arr[x-1]:
            return arr[x]


def first_non_consecutive(arr):
    for i, a in enumerate(arr):
        if 0 < i < len(arr) + 1 and a != arr[i-1] + 1:
            return a

def first_non_consecutive(arr):
    for i in range(len(arr)-1):
        if not arr[i]+1 == arr[i+1]: return arr[i+1]
    return None

def first_non_consecutive(arr):
    for i in range(len(arr)-1):
        if arr[i] != arr[i+1]-1:
            return arr[i+1]
    return None

def first_non_consecutive(arr):
    #your code here
    for i in range(1, len(arr)):
        if arr[i] - arr[i-1] != 1:
            return arr[i]
    return None

def first_non_consecutive(arr):
    #your code here
    for i in range(len(arr)-1):
        if arr[i]+1!=arr[i+1]:
            return arr[i+1]
    return None


first_non_consecutive = lambda a: min([e for i,e in enumerate(a) if i>0 and e!=a[i-1]+1] or [None])

def first_non_consecutive(arr):
    for j in range(1, len(arr)):
        if arr[j] != arr[j-1]+1:
            return arr[j]

from itertools import count
def first_non_consecutive(arr):
    return next((a for a, b in zip(arr, count(arr[0])) if a != b), None)

def first_non_consecutive(arr):
  return next(iter(a for a, b in zip(arr, range(arr[0], arr[-1])) if a != b), None)

def first_non_consecutive(arr):
    for i in range(1, len(arr)):
        if abs(arr[i] - arr[i-1]) > 1:
            return arr[i]

def first_non_consecutive(arr):
    for ix in range(len(arr) - 1):
        if arr[ix] + 1 != arr[ix + 1]:
            return arr[ix + 1]

def first_non_consecutive(arr):
    expected = arr[0]
    for x in arr:
        if x != expected:
            return x
        else:
            expected = x + 1
            


def first_non_consecutive(arr):
    res = [arr[i] for i in range(1, len(arr)) if arr[i-1] != arr[i]-1]
    return res[0] if res else None

def first_non_consecutive(a):
    i = 0
    n = None
    while i < len(a)-1:
        if a[i]+1 != a[i+1]:
            n = a[i+1]
            break
        i += 1
    return n

def first_non_consecutive(arr):
    for number_lag, number in zip(arr[:-1], arr[1:]):
        if number_lag+1 != number:
            return number
    else:
        return None
      


def checkConsecutive(l): 
    return sorted(l) == list(range(min(l), max(l)+1))

def first_non_consecutive(nums):
    if checkConsecutive(nums):
        return None
    else:
        gaps = [[s, e] for s, e in zip(nums, nums[1:]) if s+1 < e]
        edges = iter(nums[:1] + sum(gaps, []) + nums[-1:])
        A=list(zip(edges,edges))
        A.pop(0)
        L=[]
        for i in A:
            for j in i:
                L.append(j)
        return L[0]

def first_non_consecutive(arr):
    #your code here
    length = len(arr)
    if length <=2:
        return None
    len_list = list(range(length))
    for item in len_list:
        try:
            if abs(arr[item+1] - arr[item]) != 1:
                return arr[item+1]
                break
        except:
            return None

def first_non_consecutive(arr):
    for n in arr:
        if n != arr.index(n)+arr[0]:
            return n

def first_non_consecutive(arr):
    for i in range(len(arr)-1):
        next = arr[i+1]
        if arr[i] +1 != next:
            return next
    return None

def first_non_consecutive(arr):
    return next((n for i,n in enumerate(arr[1:]) if n != arr[i]+1), None)
    """ WARNING: i = 0 for the second element of arr! ;) """

def first_non_consecutive(arr):
    for i in range(1,len(arr)):
        if (arr[i]-1)!=arr[i-1]:
            return arr[i]
    return None

def first_non_consecutive(arr):
    is_consecutive = True
    for index, item in enumerate(arr[0:-1]):
        if item + 1 == arr[index + 1]:
            continue
        else:
            is_consecutive = False
            return arr[index + 1]
            break
    if is_consecutive == True:
            return None

def first_non_consecutive(arr):
    for i in range(len(arr)-1):
        if arr[i+1] - arr[i] != 1:
            return arr[i+1]
    return None
        


from typing import List, Optional

def first_non_consecutive(arr: List[int]) -> Optional[int]:
    """ Find the first element of an array that is not consecutive. """
    for prev, next in zip(arr, arr[1:]):
        if next - prev > 1:
            return next

def first_non_consecutive(arr):
    return None if len(arr) < 2 else (arr[1] if arr[1]-arr[0] != 1 else first_non_consecutive(arr[1::]))

from operator import eq
from itertools import compress

def first_non_consecutive(a):
   return next(compress(a, [not eq(*x) for x in zip(a,list(range(a[0],a[0]+len(a)+1)))]), None)


def first_non_consecutive(arr):
    return next((y for x, y in zip(arr, arr[1:]) if y - x > 1), None)

def first_non_consecutive(arr):
    return next((i for i in arr if not min(arr)+arr.index(i)==i), None)

def first_non_consecutive(arr):
    try:
        return [i for i in arr if not min(arr)+arr.index(i)==i][0]
    except:
        return None

def first_non_consecutive(lst_input): 
    if sorted(lst_input) == list(range(min(lst_input), max(lst_input)+1)):
      return None 
    else:
      if sorted(lst_input) != list(range(min(lst_input), max(lst_input)+1)):
        for val, val2 in zip(sorted(lst_input), list(range(min(lst_input), max(lst_input)+1))):
          if val != val2:
            return val

def first_non_consecutive(arr):
    i = 0
    for i in range(0, len(arr)):
        if (i + 1 < len(arr)):
            if (arr[i]+1 != arr[i+1]):
                i += 1       
                return arr[i]


def first_non_consecutive(arr):
    for i in range(len(arr)-1):
        if arr[i+1] - arr[i] != 1 :
            return(arr[i+1])
        else:
            print('',end="")


def first_non_consecutive(arr):
    numbers = list(range(arr[0], arr[-1] + 1))
    missing = [number for number in numbers if number not in arr]
    return missing[0] + 1 if missing != [] else None

def first_non_consecutive(x):
    
    for i in x:
        if i-1 not in x:
            if i == x[0]:
                pass
            else:
                return i


def first_non_consecutive(arr):
    for i, e in enumerate(arr):
        if i == len(arr)-1: return None
        elif e+1 != arr[i+1]: return arr[i+1]


def first_non_consecutive(arr):
    #your code here
    a=[arr[i+1] for i in range(len(arr)) if i+1<len(arr) and arr[i+1]-arr[i] >1]
    print(a)
    return a[0] if len(a)>0 else None

def first_non_consecutive(arr):
    return None if list(range(arr[0], arr[-1] + 1)) == arr else [arr[i + 1] for i in range(0, len(arr) - 1) if arr[i] + 1 != arr[i + 1]][0]

def first_non_consecutive(arr):
    d=[arr[0]]
    for i in arr:
        d.append(i+1)
    if len(list(set(d[:-1]).difference(arr)))==0:
        return None
    else:
        return min(list(set(d[:-1]).difference(arr)))+1

def first_non_consecutive(arr):
    for i in range(len(arr)-1):
        if arr[i+1]-arr[i]==1:
            continue
        elif arr[i+1]-arr[i]!=1:
            return arr[i+1]
        else:
            return None

def first_non_consecutive(arr):
    results = set(range(arr[0], arr[-1])) - set(arr)
    return min(results)+1 if len(results) > 0 else None

def first_non_consecutive(arr):
    comparator = arr[0]
    for n in arr:
        if comparator == n:
            comparator = comparator + 1
        else:
            return n

def first_non_consecutive(arr):
    n = 0
    while n < len(arr)-1:
        if arr[n+1] - arr[n] != 1:
            return arr[n+1] 
        n +=1        

def first_non_consecutive(arr):
    result = arr[0]
    for i in arr[1:]:
        if i - result != 1:
            return i
        result = i

def first_non_consecutive(arr):
    new_list = arr.pop(0)
    for num in arr:
        new_list += 1
        if num != new_list:
            return num


def first_non_consecutive(arr):
    
    
    for int in range(1,len(arr)):
        if arr[int]-arr[int-1]!=1:
            return  arr[int]
    
    
    
    return None

def first_non_consecutive(l):
    for i,n in enumerate(l[1:]):
        if n!=l[i]+1:
            return n

def first_non_consecutive(arr):
    for i, x in enumerate(arr):
        if x != arr[i-1]+1 and i > 0:
            return x
    return None



def first_non_consecutive(arr):
    i = arr.pop(0)
    for item in arr:
        i += 1
        if item != i:
            return item 
    return None

def first_non_consecutive(arr):
    i = 0
    for num in range(arr[0], arr[len(arr) - 1]):
        if num != arr[i]:
            return arr[i]
        i += 1
    return None

def first_non_consecutive(arr):
    for i in range(1, len(arr)):
        if not arr[i] == arr[i - 1] + 1:
            return arr[i]
    return None

def first_non_consecutive(arr):
    first, last = arr[0], arr[-1]
    diff = set(range(first, last + 1)) - set(arr)
    return min(diff) + 1 if diff else None


def first_non_consecutive(arr):
    x = len(arr)
    z= []
    y = []
    for k in range(0,x-1):
        if (arr[k]+1) == arr[(k+1)]:
            y.append(arr[k+1])
        else:
            z.append(arr[k+1])
    
    if z==[]:
        return None
    else:
        z = min(z)
        return z
            


    #your code here


def first_non_consecutive(arr):
    for n in range(len(arr)):
        if n+1 < len(arr):
            if arr[n+1] - arr[n] > 1:
                return arr[n+1]
    return None

def first_non_consecutive(arr):
    ans = arr[0]
    for i in arr:
        if ans != i:
            return i
        else:
            ans += 1
    return None


def first_non_consecutive(arr):
    for i in range(len(arr)-1):
        if arr[i] - arr[i+1] != -1:
            return arr[i+1]
    else:
        return None

def first_non_consecutive(arr):
    size = len(arr)
    for i in range(size):
        if i == size-1:
            return None
        elif arr[i+1] > arr[i]+1:
            return arr[i+1]

def first_non_consecutive(arr=[]):
    if len(arr) > 1:
        for i in range(len(arr)):
            if i < len(arr) - 1:
                if arr[i + 1] != arr[i] + 1:
                    return arr[i + 1]
    else:
        return None

def first_non_consecutive(arr):
    n = 0
    try:
        for i in arr:
            if i + 1 == arr[n + 1]:
                n += 1
                continue
            elif i + 1 != arr[n + 1]:
                return arr[n + 1]
    except:
        return None

def first_non_consecutive(arr):
    i = 0
    while i < len(arr) - 1:
        i += 1
        if arr[0] >= 0 and arr[i] - arr[i - 1] != 1:
            return arr[i]
            break
        elif arr[0] < 0 and abs(arr[i - 1]) - abs(arr[i]) != 1:
            return arr[i]
            break
    else:
        return None

def first_non_consecutive(arr):
    lena = len(arr)
    b = arr[0]
    for i in arr:
        if b == i:
            b = b + 1
            print("tut")
        else:
            return i
            
            



def first_non_consecutive(arr):
    for i, v in enumerate(arr, arr[0]):
        if i != v:
            return i + 1
    return None

def first_non_consecutive(a):
    temp = [a[i] for i in range(len(a)) if i !=0 and a[i] != a[i-1]+1]
    return temp[0] if temp else None

def first_non_consecutive(arr):
    #your code here
    first_ele = arr[0]
    for i in range(1,len(arr)):
        if arr[i] == first_ele +1:
            first_ele=first_ele + 1
        else:
            return arr[i]


def first_non_consecutive(arr):
    for i in range(len(arr)-1):
        if arr[i+1] != arr[i]+1:
            return arr[i+1]
        if len(arr) == 0:
            return None


def first_non_consecutive(arr):
    i = 0
    j = 1
    for k in range(len(arr)-1):
        if arr[i] +1 != arr[j]:
            return arr[j]
        else:
            i += 1
            j+= 1

first_non_consecutive = lambda arr: (lambda x:None if len(x)==0 else min(x)+1)({*range(min(arr),max(arr)+1)}.difference({*arr}))

def first_non_consecutive(arr):
    for el in range(0, len(arr) - 1):
        if(arr[el + 1] - arr[el] > 1):
            return arr[el + 1]

def first_non_consecutive(arr):
    if len(arr) > 1:
        for i in range(len(arr) - 1):
            if arr[i + 1] - arr[i] > 1:
                return arr[i + 1]
        return 
    else:
        return 

import numpy
def first_non_consecutive(arr):
    if sorted(arr) == list(range(min(arr), max(arr)+1)):
        return None
    else:
        difference = list(numpy.diff(arr))
        for i in difference:
            if i > 1:
                index = difference.index(i)
                return arr[index+1]
        
        
    #your code here


def first_non_consecutive(arr):
    return next((arr[i] for i in range(1, len(arr)) if arr[i] - 1 != arr[i-1]), None)

def first_non_consecutive(arr):
    if len(arr) == 2:
        return None
    elem_1 = arr[0]
    elem_2 = arr[1]
    elem_3 = arr[2]
    diff_1 = elem_2 - elem_1
    diff_2 = elem_3 - elem_2
    if diff_1 > diff_2:
        grade_1 = diff_2
    elif diff_1 < diff_2:
        grade_1 = diff_1
    else:
        grade_1 = diff_1
    for i in range(0, len(arr) - 1):
        if arr[i + 1] != arr[i] + grade_1:
            return arr[i + 1]
    
    return None


    
    
def first_non_consecutive(arr):
    for a,b in zip(arr[:-1], arr[1:]):
        if b!=a+1:
            return b


def first_non_consecutive(arr):
    expected = arr[0]
    for x in arr:
        if x != expected:
            return x
        else:
            expected += 1


def first_non_consecutive(arr):
    x = arr[0]
    for index in arr:
        if index != x:
            result = index
            break
        x += 1
    else:
        result = None
    return result

def first_non_consecutive(arr):
    try:
        for i in range(len(arr)):
            if arr[i] != arr[i+1] - 1:
                return arr[i+1]
    except:
        return None

def first_non_consecutive(arr):
    for num in arr:
        i = arr.index(num)
        if i > (len(arr) - 2):
            return None
        elif arr[i + 1] == int(num + 1):
            continue
        else:
            return arr[i + 1]
    #your code here