Define a "prime prime" number to be a rational number written as one prime number over another prime number: `primeA / primeB` (e.g. `7/31`)

Given a whole number `N`, generate the number of "prime prime" rational numbers less than 1, using only prime numbers between `0` and `N` (non inclusive).

Return the count of these "prime primes", and the integer part  of their sum.

## Example

```python
N = 6

# The "prime primes" less than 1 are:
2/3, 2/5, 3/5               # count: 3

2/3 + 2/5 + 3/5 = 1.6667    # integer part: 1

Thus, the function should return 3 and 1.
```

Source: codewars | Difficulty: EASY

Starter code: def prime_primes(N):
	

Solutions:
from bisect import bisect_left

def sieve(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 = sieve(100000)

def prime_primes(n):
	lst = PRIMES[:bisect_left(PRIMES, n)]
	divs = [p / q for (i, p) in enumerate(lst) for q in lst[i + 1:]]
	return (len(divs), int(sum(divs)))


primes = [2] + [n for n in range(3, 1000, 2) if all((n % r for r in range(3, int(n ** 0.5) + 1, 2)))]
import itertools

def prime_primes(N):
	pairs = list(itertools.combinations((p for p in primes if p < N), 2))
	return (len(pairs), int(sum((a / b for (a, b) in pairs))))


from itertools import combinations

def prime_primes(N):
	primes = [2] + [n for n in range(3, N, 2) if all((n % d for d in range(3, int(n ** 0.5) + 1, 2)))]
	pp = [n / float(d) for (n, d) in combinations(primes, 2)]
	return (len(pp), int(sum(pp)))


from bisect import bisect_left as bisect
from itertools import combinations
import numpy as np
N = 100001
xs = np.ones(N)
xs[:2] = 0
xs[2 * 2::2] = 0
for i in range(3, int(N ** 0.5) + 1):
	if xs[i]:
		xs[i * i::i] = 0
primes = [i for (i, x) in enumerate(xs) if x]

def prime_primes(N):
	i = bisect(primes, N)
	xs = [a / b for (a, b) in combinations(primes[:i], 2)]
	return (len(xs), int(sum(xs)))


def prime_primes(n):
	sieve = [0, 0] + [1] * (n - 2)
	for k in range(2, int(n ** 0.5) + 1):
		if sieve[k]:
			sieve[k * k::k] = ((n - k * k - 1) // k + 1) * [0]
	primes = [p for (p, b) in enumerate(sieve) if b]
	ratios = [b / a for (i, a) in enumerate(primes) for b in primes[:i]]
	return (len(ratios), int(sum(ratios)))


p = [2]
for i in range(3, 1000, 2):
	if all((i % j for j in p)):
		p.append(i)

def prime_primes(N):
	cnt = 0
	sm = 0
	for i in range(len(p)):
		for j in range(i + 1, len(p)):
			if p[j] >= N:
				break
			cnt += 1
			sm += p[i] / p[j]
		if p[i] >= N:
			break
	return (cnt, int(sm))


import math

def prime_primes(N):
	primes = [i for i in range(N) if is_prime(i)]
	prime_prms = []
	for i in range(len(primes) - 1):
		for j in range(primes.index(primes[i]) + 1, len(primes)):
			prime_prms.append(primes[i] / primes[j])
	count_of_prime_primes = len(prime_prms)
	return (count_of_prime_primes, math.floor(sum(prime_prms)))

def is_prime(nr):
	if nr > 1:
		for i in range(2, nr):
			if nr % i == 0:
				return False
		return True
	return False


def prime_primes(N):
	prime = []
	for iter in range(2, N):
		for i in range(2, iter):
			if iter % i == 0:
				break
		else:
			prime.append(iter)
	l = [j / i for i in prime for j in prime if j / i < 1]
	return (len(l), int(sum(l)))


import math

def is_prime(n):
	return n == 2 or (n > 2 and n % 2 and all((n % i for i in range(3, int(n ** 0.5) + 1, 2))))

def prime_primes(N):
	a = [i for i in range(2, N) if is_prime(i)]
	(total, count) = (0, 0)
	for elem1 in a:
		for elem2 in a:
			if elem1 < elem2:
				count += 1
				total += elem1 / elem2
	return (count, math.floor(total))