CHALLENGE! Computer Science

# Technically I didnt use a sieve  :P
import urllib
Primes = []
sock = urllib.urlopen("http://primes.utm.edu/lists/small/10000.txt")
for line in sock.read().split('\n')[4:-2]:
    Primes += map(int,line.split())
sock.close()
for prime in Primes:
    print prime

from math import sqrt

def Gen_Primes(Limit):
    Primes = [2 , 3]
    N , Count = Primes[::-1]
    for i in Primes:yield i
    while Count < Limit:
        N += 2
        Is_PP , Root = True , sqrt(N)
        for prime in Primes:
            if prime > Root:
                break
            if N % prime ==0:
                Is_PP=False
                break
        if Is_PP:
            Primes.append(N)
            Count += 1
            yield N

for p in Gen_Primes(10**5):
    print p

import java.math.BigInteger;

public class main {
  public static void main(String[] args) {
      int limit = 100000;
      int count = 1;
      System.out.println(2);
      BigInteger N = new BigInteger("1");
      BigInteger Two = new BigInteger("2");
      while (count < limit){
          N = N.add(Two);
          if  (N.isProbablePrime(10)){
              count += 1;
              System.out.println(N);
          }
      }
  }
}

var zeta;  
var natural = 1;  
function Riemann(s) {  
  zeta = 1/(Math.pow(natural,s));  

  for (var i=0; i<1E+7; i++) {  
    natural++;  
    zeta = zeta + 1/(Math.pow(natural,s));   
  }  
  return zeta;  
}  
alert(Riemann(2));

import math

def yieldPrime(n):
    li = []
    num = 2
    while(n):
        for p in li:
            if(p > int(math.sqrt(num))+1):
                li.append(num)
                yield num
                n -= 1
                break
            elif(num % p == 0):
                break
        else:
            li.append(num)
            yield num
            n -= 1
        num += 1

for i in yieldPrime(10000):
    print(i)

from math import *

def nCr(n, r):
    return factorial(n) // factorial(r) // factorial(n-r) # Integer only division '//'

def getPartialPrimesUpto(n, start=2):
    return [
        m for m in range(start, n) # 2 -> n
            if all(m % o != 0 for o in range(2, int(sqrt(m))+1))  # Check if all of 2 -> sqrt(m)+1 are not factor of m
        ]

primesList = [2]
def getPrimesUpto(n): # Saves time on continuously calculating primes
    if primesList[-1] < n:
        primesList.extend(getPartialPrimesUpto(n, primesList[-1]+1))
    return primesList[:n]

def RiemannZetaUsingSeries(s, maxTerms=12):
    y = 1/(s-1)
    s1 = 0
    for n in range(0, maxTerms):
        s2 = 0
        for k in range(0, n+1):
            s2 += pow(-1, k) * pow(1+k, 1-s) * nCr(n, k)
        s1 += s2/(n+1)
    y *= s1
    return y

def RiemannZetaUsingEulerProduct(s, maxPrimes=9999):
    primes = getPrimesUpto(maxPrimes)
    y = 1
    for k in range(0, len(primes)):
        y *= 1/(1-primes[k]**-s)
    return y

def RiemannZeta(s, precision=10000):
    if s == 1:
        return "Infinity"
    y = 0
    if s < 1:
        y = RiemannZetaUsingSeries(s)
    else:
        y = RiemannZetaUsingEulerProduct(s)
    y = floor(y*precision)/precision
    return y

print(getPrimesUpto(10000 )) # Will print 10000 primes

print(RiemannZeta(s))
# Output for some values
# At s = 0    Zeta(s) =  -0.5
# At s = 0.5  Zeta(s) =  -1.4675
# At s = 2    Zeta(s) =  1.6449
# At s = 3    Zeta(s) =  1.202
# At s = 4    Zeta(s) =  1.0823
# At s = -1   Zeta(s) =  -0.0834
# At s = 1.5  Zeta(s) =  2.6076
# At s = -5   Zeta(s) =  -0.004
# At s = -4   Zeta(s) =  0.0
# At s = -3   Zeta(s) =  0.0083
# At s = -2   Zeta(s) =  0.0