The prime numbers are not regularly spaced. For example from `2` to `3` the step is `1`.
From `3` to `5` the step is `2`. From `7` to `11` it is `4`.
Between 2 and 50 we have the following pairs of 2-steps primes:

`3, 5 - 5, 7, - 11, 13, - 17, 19, - 29, 31, - 41, 43`

We will write a function `step` with parameters:

- `g` (integer >= 2) which indicates the step we are looking for,

- `m` (integer >= 2) which gives the start of the search (m inclusive),

- `n` (integer >= m) which gives the end of the search (n inclusive)

In the example above `step(2, 2, 50)` will return `[3, 5]` which is the first pair between 2 and 50 with a 2-steps.

So this function should return the **first** pair of the two prime numbers spaced with a step of `g`
between the limits `m`, `n` if these g-steps prime numbers exist otherwise `nil` or `null` or `None` or `Nothing` or `[]` or `"0, 0"` or `{0, 0}` or `0 0`(depending on the language). 


#Examples:

- 


`step(2, 5, 7) --> [5, 7] or (5, 7) or {5, 7} or "5 7"`

`step(2, 5, 5) --> nil or ... or [] in Ocaml or {0, 0} in C++`

`step(4, 130, 200) --> [163, 167] or (163, 167) or {163, 167}`

- **See more examples for your language in "RUN"**


- Remarks:

([193, 197] is also such a 4-steps primes between 130 and 200 but it's not the first pair).

`step(6, 100, 110) --> [101, 107]` though there is a prime between 101 and 107 which is 103; the pair 101-103 is a 2-step.


#Notes: 
The idea of "step" is close to that of "gap" but it is not exactly the same. For those interested they can have a look
at . 

A "gap" is more restrictive: there must be no primes in between 
(101-107 is a "step" but not a "gap". Next kata will be about "gaps":-).

For Go: nil slice is expected when there are no `step` between m and n.
Example: step(2,4900,4919) --> nil

Difficulty: introductory

Starter code:

def step(g, m, n):
	

Solutions:
import math
def isPrime(n):
    if n <= 1:
        return False
    for i in range(2,int(math.sqrt(n)+1)):
        if n % i == 0:
            return False
    return True

def step(g,m,n):
    if m >= n:
        return []
    else:
        for i in range(m,n+1-g):
            if isPrime(i) and isPrime(i+g):
                return[i,i+g]


def prime (number):
    if number < 2: return False
    elif number == 2: return True
    elif number % 2 == 0: return False
    for i in range(3, int(number ** 0.5) + 1, 2):
        if number % i == 0: return False
    return True
    
def step(g, m, n):
    res = []
    i = m
    while (i <= n - g):
        if prime(i) and prime(i + g):
            res.append(i)
            res.append(i + g)
            return res
        i += 1
    return None

def is_prime(n):
    for i in range(2,int(n**0.5) + 1):
        if n % i == 0:
            return False
    return True
    
def step(g, m, n):
    for i in range(m, n - g):
        if is_prime(i) and is_prime(i + g):
            return [i,i+g]
    return None

step=lambda g,m,n,A=lambda x:all(x%i for i in range(2,int(x**.5)+1)):next(([i,i+g]for i in range(m,n+1)if A(i)and i+g < n and A(i+g)),None)

import math
def step(g, m, n):

    def prime(n):
        if n >= 2:
            for i in range(2, int(math.sqrt(n)) + 1):
                if not (n % i):
                    return False
        else:
            return False
        return True

    for i in range(m,n-g):
        if prime(i + g) and prime(i):
            return [i, i + g]

def step(g, m, n):
    return next(([a, a+g] for a in range(m, n-g+1) if is_prime(a) and is_prime(a+g)), None)


def is_prime(n):
    factors = 0
    for k in (2, 3):
        while n % k == 0 and factors < 2:
            n //= k
            factors += 1
    k = 5
    step = 2
    while k * k <= n and factors < 2:
        if n % k:
            k += step
            step = 6 - step
        else:
            n //= k
            factors += 1
    if n > 1:
        factors += 1
    return factors == 1


def step(g, m, n):
    def is_prime(n):
        if n==2:
            return True
        elif n<2 or  n%2==0:
            return False
        else:
            import math
            root = math.floor(math.sqrt(n))
            trial_factor = 3
            while trial_factor<= root:
                if n%trial_factor==0:
                    return False
                trial_factor+=2
            return True
    dic = {}
    current_prime = None
    for i in range(m, n+1):
        if is_prime(i):
            current_prime = i
            if current_prime - g  in dic:
                return [current_prime-g, current_prime]
            else:
                dic[current_prime] = True
              
                  
    return None
              
                
  
    # your code


def prime(n):
    for i in range(2, 1000):
        if i != n and n % i == 0:
            return False
    return  True
                
def step(g, m, n):
    for num in range(m, n+1):
        if prime(num) and prime(num+g) and num+g<=n:
            return [num, num + g]
    return None


import itertools
compress = itertools.compress 
def sieve(n): 
    r = [False,True] * (n//2) +[True]
    r[1],r[2] = False,True 
    for i in range(3,int(n**.5)+1): 
        if r[i]: 
            r[i*i::2*i] = [False] * ((n+2*i-1-i*i)//(2*i))
    r = list(compress(range(len(r)),r))
    if r[-1] % 2 == 0:
        return r[:-1]
    return r
primes = set(sieve(2*10**7))
maxi = max(primes) 
def step(g, m, n):
    for i in range(m,n+1): 
        if i > maxi or i+g > n:
            break 
        if i in primes and i+g in primes:
            return [i,i+g]
    return None