German mathematician Christian Goldbach (1690-1764) [conjectured](https://en.wikipedia.org/wiki/Goldbach%27s_conjecture) that every even number greater than 2 can be represented by the sum of two prime numbers. For example, `10` can be represented as `3+7` or `5+5`.

Your job is to make the function return a list containing all unique possible representations of `n` in an increasing order if `n` is an even integer; if `n` is odd, return an empty list. Hence, the first addend must always be less than or equal to the second to avoid duplicates.

Constraints : `2 < n < 32000` and `n` is even


## Examples
```
26  -->  ['3+23', '7+19', '13+13']

100 -->  ['3+97', '11+89', '17+83', '29+71', '41+59', '47+53']

7   -->  [] 
```

Difficulty: introductory

Starter code:

def goldbach_partitions(n):
	

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

    if n % 2: return []

    ret = []
    for first in range(2, n//2 + 1):
        if is_prime(first):
            second = n - first
            if is_prime(second):
                ret.append('%d+%d' %(first, second))
    return ret

f=lambda n:n>1and all(n%d for d in range(2,int(n**.5)+1))
goldbach_partitions=lambda n:[]if n%2else['%d+%d'%(p,n-p)for p in range(n//2+1)if f(p)*f(n-p)]

from itertools import chain

import numpy as np

N = 32001
xs = np.ones(N)
xs[:2] = 0
xs[4::2] = 0
for i in range(3, int(N ** 0.5) + 1, 2):
    if xs[i]:
        xs[i*i::i] = 0
primes = {i for i, x in enumerate(xs) if x}


def goldbach_partitions(n):
    if n % 2:
        return []
    return [
        f"{i}+{n-i}"
        for i in chain([2], range(3, n // 2 + 1, 2))
        if i in primes and n - i in primes
    ]

odd_primes = {n for n in range(3, 32000, 2) if all(n % k for k in range(3, int(n**0.5)+1, 2))}

def goldbach_partitions(n):
    if n % 2 == 1:
        return []
    if n == 4:
        return ["2+2"]
    return [f"{p}+{q}" for p, q in sorted((p, n-p) for p in odd_primes if p <= (n-p) and (n-p) in odd_primes)]


def goldbach_partitions(n):
  is_prime = lambda n: all(n%j for j in range(2, int(n**0.5)+1)) and n>1
  return [] if n%2 else [f'{i}+{n-i}' for i in range(2, int(n/2)+1) if is_prime(i) and is_prime(n-i)]

def goldbach_partitions(n):
    def prime(a):
        if a == 2: return True
        if a < 2 or a % 2 == 0: return False
        return not any(a % x == 0 for x in range(3, int(a ** 0.5) + 1, 2))

    if n<4 or n%2!=0:
        return []
    if n==4:
        return ['2+2']
    res = []
    x = 3
    while True:
        y = n-x
        if x>y:
            return res
        if prime(y):
            res.append(str(x) + '+' + str(y))            
        x += 2
        while not prime(x):
            x += 2

def prime(givenNumber): 
  primes = []
  for possiblePrime in range(2, givenNumber + 1):
  
    isPrime = True
    for num in range(2, int(possiblePrime ** 0.5) + 1):
      if possiblePrime % num == 0:
        isPrime = False
        break

    if isPrime:
      primes.append(possiblePrime)
  
  return(primes)

def goldbach_partitions(n):
  if n % 2 != 0:
    return []
  else:
    p = prime(n)
    res = []
  
    for i in p:
      if (n-i) in p:
        res.append('{}+{}'.format(i, n-i)) 
        p.remove(n-i)
    return res

import math
def goldbach_partitions(n):
    primes = []
    partitions = []
    
    if n%2 != 0: return []
    for i in range(0, n+1):
        if i > 1:
            for j in range(2, int(math.sqrt(i))+1):
                if (i % j) == 0:
                    break
            else:
                primes.append(i)

    for i in primes:
        if i <= n/2:
            if n - i in primes:
                partitions.append(str(i) + '+' + str(n - i))

    return(partitions)

sieve = [False] * 2 + [True] * 32000
for i in range(2, 200):
    if sieve[i]:
        for j in range(2, 32000):
            if i * j >= len(sieve): break
            sieve[i*j] = False

def goldbach_partitions(n):
    if n % 2: return []
    if n == 4: return ['2+2']
    return ['{}+{}'.format(i, n-i) for i in range(2, n//2+1) if sieve[i] and sieve[n-i]]