Write a function generator that will generate the first `n` primes grouped in tuples of size `m`. If there are not enough primes for the last tuple it will have the remaining values as `None`.

## Examples

```python
For n = 11 and m = 2:
(2, 3), (5, 7), (11, 13), (17, 19), (23, 29), (31, None)

For n = 11 and m = 3:
(2, 3, 5), (7, 11, 13), (17, 19, 23), (29, 31, None)

For n = 11 and m = 5:
(2, 3, 5, 7, 11), (13, 17, 19, 23, 29), (31, None, None, None, None)]

For n = 3 and m = 1:
(2,), (3,), (5,)
```

Note: large numbers of `n` will be tested, up to 50000

Difficulty: introductory

Starter code:

def get_primes(how_many, group_size=2):
	

Solutions:
# generate primes up to limit
LIMIT = 10**6
sieve = [0]*2 + list(range(2, LIMIT))
for n in sieve:
    if n:
        for i in range(n*n, LIMIT, n):
            sieve[i] = 0
PRIMES = list(n for n in sieve if n)

def get_primes(n, m=2):
    primes_ = PRIMES[:n] + [None] * m
    return ( tuple(primes_[i:i+m]) for i in range(0, n, m) )

# Known primes
primes = [2, 3, 5, 7, 11]

# Generate prime numbers in sequence
def gen_primes():
    yield from primes
    candidate = primes[-1]
    candidate_root = int(candidate ** 0.5) + 1
    while True:
        candidate += 2
        if candidate_root * candidate_root < candidate:
            candidate_root += 1
        for p in primes:
            if candidate % p == 0:
                break
            if p > candidate_root:
                primes.append(candidate)
                yield candidate
                break

def get_primes(how_many, group_size=2):
    result = []
    for i, p in enumerate(gen_primes(), start=1):
        result.append(p)
        if len(result) == group_size:
            yield tuple(result)
            result = []
        if i == how_many:
            break
    if len(result) > 0:
        while len(result) < group_size:
            result.append(None)
        yield tuple(result)


from itertools import zip_longest
import math

def get_primes(how_many, group_size=2):
    if how_many>0:
        pr = primes(how_many) 
        yield from [ tuple(e) for e in zip_longest(*[iter(pr)]*group_size ) ]
        
def is_prime(n):
    return all(n % i for i in range(3, int(math.sqrt(n)) + 1, 2))
   
def primes(n):
    i, pr = 3, [2]
    while n>1:
        if is_prime(i):
            n -= 1
            pr.append(i)
        i += 2
    return pr
    


from itertools import compress, islice, zip_longest

import numpy as np


s = np.ones(1000000)
s[:2] = s[4::2] = 0
for i in range(3, int(len(s)**0.5)+1, 2):
    if s[i]:
        s[i*i::i] = 0
primes = list(compress(range(len(s)), s))

def get_primes(how_many, group_size=2):
    yield from zip_longest(*[islice(primes, how_many)] * group_size)

def get_primes(how_many, group_size):
    primes = [False] * 2 + list(range(2, 13*how_many))
    for x in primes:
        if x:
            for i in range(x*x, 13*how_many, x):
                primes[i] = False
    seq = sorted(set(primes))[1:how_many+1]
    while len(seq) % group_size != 0:
        seq += [None]
    return (tuple(seq[x:x+group_size]) for x in range(0, len(seq), group_size))

def makePrimes(n):
    sieve, primes = [0]*(n+1), []
    for i in range(2, n+1):
        if not sieve[i]:
            primes.append(i) 
            for j in range(i**2, n+1, i): sieve[j] = 1
    return primes

PRIMES = makePrimes(650000)          # => 52831 prime numbers

def get_primes(how_many, group_size=2):

    lst = PRIMES[:how_many] + [None] * (group_size - how_many%group_size)
    
    for n in range(how_many//group_size + bool(how_many%group_size)):
        yield tuple(lst[n*group_size : (n+1)*group_size])

import gmpy2

def get_primes(how_many, group_size):
    n = 2
    count = 0
    while count < how_many:
        res = []
        for i in range(group_size):
            res.append(int(n) if count < how_many else None)
            n = gmpy2.next_prime(n)
            count += 1
        yield tuple(res)
            
        



from itertools import islice, chain, repeat

def gen_primes():
    D = {}; q = 2
    while True:
        if q not in D: yield q; D[q * q] = [q]
        else:
            for p in D[q]: D.setdefault(p + q, []).append(p)
            del D[q]
        q += 1
def get_primes(how_many, group_size=2):
    return (t for t in zip(*[chain(islice(gen_primes(), how_many), repeat(None, group_size-1))]*group_size))

get_primes=lambda n,m:(tuple(g)for g in zip(*[iter([2]+[p for p in range(3,15*n,2)if all(p%d for d in range(3,int(p**.5)+1,2))][:n-1]+[None]*(m-1))]*m))

import itertools 
def prime(a):
    return not (a < 2 or any(a % x == 0 for x in range(2, int(a**0.5) + 1)))

def get_primes(how_many, group_size=2):
    primes = filter(prime, itertools.count(2))
    yield from itertools.zip_longest(*[itertools.islice(primes, how_many)] * group_size)