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.
```

Difficulty: introductory

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 ** .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))