def prime_obsession(): primes = set(prime_sieve(510)) prime_count = 0 for num in solved_set: if num in primes: prime_count += 1 print "Prime Obsession, solve:", 50 - prime_count
def main(N): primes = prime_sieve(N) factorizations = [(2, 2, 2), (4, 2), (8, 1)] length = len(primes) vals = set([]) for a in range(length): for b in range(a + 1, length): val = a**3 * b if val > N: break if not (val in vals): vals.add(val) for a in primes: val = a**7 if val > N: break if not (val in vals): vals.add(val) for a in range(length): for b in range(a + 1, length): for c in range(b + 1, length): val = primes[a] * primes[b] * primes[c] #print val if val > N: break if not (val in vals): vals.add(val) print len(vals)
def main (): max_prime = 10**8-1 p = prime_sieve(max_prime) primes = set(p) test_p = filter(lambda i: len(str(i)) <= int(ceil(len(str(max_prime))/2.)), p) def cat_set_is_prime(prime_set): test_num = prime_set[-1] for num in prime_set[:-1]: if int(''.join(map(str, [num, test_num]))) not in primes or int(''.join(map(str, [test_num, num]))) not in primes: return False return True # get 2-tuples that match the criterion new_tup_list = sorted(set([combo for combo in combinations(test_p, 2) if cat_set_is_prime(combo)])) # try to add each test_p to the combos to make n+1 tuples satisfying the criterion for tup_size in range(3, 5+1): cur_tup_list = new_tup_list new_tup_list = [] for tup in cur_tup_list: for new_num in test_p: if tup[-1] < new_num: cand = tuple(list(tup) + [new_num]) if cat_set_is_prime(cand): new_tup_list.append(cand) print '\nAnswer: {0}'.format(sum(new_tup_list[0])) pass
def is_squarefree(n, k): primes = prime_sieve(n) for p in primes: num = num_primes(p, n) - num_primes(p, k) - num_primes(p, n-k) if num >= 2: return False return True
def main(N=5): primes = prime_sieve(10000) result = False while not result: my_list = [primes.pop(0)] result = iter_loop(my_list, primes, N) return sum(result)
def main(): primes = prime_sieve(500) curr = 1 for i in primes: if curr * i > bound: return curr else: curr *= i
def ans(n): if n < 7: return 3 primes = prime_sieve(n) for p in primes[::-1]: i = 1 # while 10**i % p != 1: i += 1 while pow(10, i, p) != 1: i += 1 #this solves HackerRank constraints, spent a long time on this if p - 1 == i: return p #this is the Number Theory trick: Fermat Little theory
def HackerRankSol(): primes = prime_sieve(1000100) sum_primes = [0] for i in range(1, len(primes) + 1): sum_primes.append(sum_primes[i - 1] + primes[i - 1]) t = int(raw_input().strip()) for a0 in xrange(t): n = int(raw_input().strip()) print sum_primes[bisect_right(primes, n)]
def main (): max_n = 50*10**6 # get the max primes for each exponent slot max_square = int((max_n - 2**3 - 2**4)**(1/2.))+1 max_cube = int((max_n - 2**2 - 2**4)**(1/3.))+1 max_quart = int((max_n - 2**2 - 2**3)**(1/4.))+1 # sieve for the possible sets p_2 = prime_sieve(max_square) p_3 = prime_sieve(max_cube) p_4 = prime_sieve(max_quart) # build all feasible combos & filter pos_tups = [(i ,j, k) for i in p_2 for j in p_3 for k in p_4] pos_nums = [t[0]**2 + t[1]**3 + t[2]**4 for t in pos_tups] sub_max_nums = filter(lambda i: i < max_n, pos_nums) print '\nAnswer: {0}'.format(len(set(sub_max_nums))) pass
def pollard_p_minus_1(n, max_iter, b): """Performing Pollard p- 1 factorization, with odd number input""" for _ in range(max_iter): primes = prime_sieve(b) for i in range(len(primes)): primes[i] = primes[i] ** (int(log(n, primes[i]))) m = reduce(op.mul, primes) g = gcd(modularexponenation(2, m, n) - 1, n) if 1 < g < n: return g if g == 1: b += (b // 5) if g == n: b -= (b // 5)
def main (): cases = filter(lambda i: i < 10**7, map(lambda t: t[0]*t[1], combinations(prime_sieve(int(1.5*(10**7)**.5)),2))) print '' tot_tups = [] for n in cases: f = uniq_f(n) tot_ratio = reduce(mul, map(lambda p:1-p**-1, f))**-1 tot = int(round(n / tot_ratio)) if is_perm(n, tot): tot_tups.append((tot_ratio, n, tot)) for tup in sorted(tot_tups)[:10]: print tup pass
def main(N, limit): def fn(reps): return product(primes, repeat = reps) primes = prime_sieve(N+1) rep_limit = int(ceil(log(limit, 2))) #print list(product(primes, repeat=reps)) #print map(lambda reps: list(product(primes, repeat = reps)), range(1, rep_limit)) filtered = set([]) my_list = chain.from_iterable(map(fn, range(1, rep_limit))) #prods = [x for x in my_list if x < limit] ctr = 0 for item in my_list: prod_val = prod(item, limit) if prod_val > 0 and prod_val not in filtered: filtered.add(prod_val) ctr += 1 #prods = [x for x in chain.from_iterable(map(lambda reps: product(primes, repeat = reps), range(1, rep_limit))) if prod(x, limit) > 0] #print prods print ctr+1
def segmented_sieve(n): delta = n // int(sqrt(n)) def calculate_smallest_mult(a, p): left = a - delta + 1 left_mul = (left) // p tmp = p * left_mul if tmp < left: return tmp + p else: return tmp ms = [] # initialize array of top of segments primes = [] # initialize primes array i = 2 * delta # used to create first delta primes ind = delta while i <= n: ms.append(i) i += delta primes = prime_sieve(delta) k = 1 # index of numbers in ms for num in ms: # num is another starting from the 2*delta topmost value of segments arr = [True] * delta ind = 0 p = primes[ind] while p <= int(sqrt(num)): start = calculate_smallest_mult(num, p) while start <= num: # print(arr) arr[start - delta * k - 1] = False start += p ind += 1 p = primes[ind] for x in range(len(arr)): if arr[x] is True: primes.append(x + delta * k + 1) k += 1 return primes
def sol_2(): primes = prime_sieve(100000) def is_prime_2(n): if primes[bisect_left(primes, n)] == n: return True return False def formula(i, j, k): return k**2 + i * k + j n = int(raw_input().strip()) max_primes, resI, resJ = 0, 0, 0 for i in xrange(-n, n): for j in xrange(i, n): k = 0 while is_prime_2(formula(i, j, k)): k += 1 if k - 1 > max_primes: max_primes = k - 1 resI, resJ = i, j print resI, resJ #this solves all the HackerRank test cases
def F2(n): target = 20010 primes = prime_sieve(10**7) base = 308 factor = 1 count = 0 for p in [1] + primes: num = base * p while True: factor = 2 if test_valid1(num, primes, target): count += 1 if count == n: return num num = base * p * factor factor += 1 else: break factor += 1 return num
def F3(n): target = 20010 base = 308 factor = 1 primes = prime_sieve(10**7) count = 0 for p in [1] + primes: factor = 1 num = base * p * factor while True: if test_valid1(num, primes, target): print num, factorize(num) count += 1 if count == n: return num factor += 1 num = base * p * factor else: break return num
from Euler import prime_sieve primes = prime_sieve(500) print primes def num(x,y,z): return x**2+y**3+z**4 print num(2,2,2) print num(3,2,2) print num(5,2,2) print num(2,3,2) print num(3,3,2) print num(5,3,2) print num(7,2,2) print num(2,2,3) print num(3,2,3) print num(2,3,3) sum=[] for x in prime_sieve(7072): for y in prime_sieve(369): for z in prime_sieve(90): if(num(x,y,z)<50000001): sum.append(num(x,y,z)) sum.sort() print len(sum) print len(set(sum))
''' [See 129] You are given that for all primes, p > 5, that p − 1 is divisible by A(p). For example, when p = 41, A(41) = 5, and 40 is divisible by 5. However, there are rare composite values for which this is also true; the first five examples being 91, 259, 451, 481, and 703. Find the sum of the first twenty-five composite values of n for which GCD(n, 10) = 1 and n − 1 is divisible by A(n). ''' from Euler import prime_sieve from problem00129_repunitdivisibility import * primes = set(prime_sieve(10**6)) valid = [] for n in (n for n in itertools.count(2) if n not in primes): k = A(n) if k > 0 and (n-1)%k==0: valid.append(n) if len(valid) == 25: break ans = sum(valid) print(ans)
import string from Euler import prime_sieve, is_prime def eight_prime_family(prime, rd): c=0 for digit in '0123456789': n = int(string.replace(prime, rd, digit)) if (n>100000 and is_prime(n)): c=c+1 return c==8 primes = prime_sieve(999999) for i in xrange(len(primes)): for digit in '0123456789': if(str(primes[i]).count(str(digit))==3): if (eight_prime_family(str(primes[i]), digit)): print primes[i] exit()
return a % m else: raise ValueError("Reciprocal does not exist") var = 0 def s(p): # (p-5)! + (p-4)! + (p-3)! + (p-2)! + (p-1)! # = (p-5)! * (1 + (p-4) + (p-4)(p-3) + (p-4)(p-3)(p-2) + (p-4)(p-3)(p-2)(p-1)) # = (p-5)! * (1 + (-4) + (-4)(-3) + (-4)(-3)(-2) + (-4)(-3)(-2)(-1)) # = (p-5)! * (1 + -4 + 12 + -24 + 24) # = (p-5)! * 9 # = (p-1)! / ((p-1)(p-2)(p-3)(p-4)) * 9 # = (p-1)! / ((-1)(-2)(-3)(-4)) * 9 # = (p-1)! / 24 * 9 # = (p-1)! * (3 * 3) / (3 * 8) # = (p-1)! * 3 / 8 # = -1 * 3 / 8 (by Wilson's theorem) # = -3/8 mod p. # Every part of the equation is modulo a prime p > 4 return (p - 3) * reciprocal_mod(8 % p, p) % p psieve = prime_sieve(10**8) for x in psieve: if x >= 5: var += s(x) print var
#50. Find the prime below 1 million which is the sum of the most consecutive #primes. from Euler import prime_sieve from Euler import is_prime import time primes = prime_sieve(100000) #this takes some time if incremented t_0 = time.clock() chart = { (0, 1): 5 } #(i,j) gives the sum of the primes from p[i] to p[j] inclusive def sum_of_primes(i, j): #uses chart to sum from p[i] to p[j] inclusive if (i, j) in chart: return chart[(i, j)] else: if i == 0: result = sum_of_primes(i, j - 1) + primes[j] chart[(i, j)] = result return result else: result = sum_of_primes(i - 1, j) - primes[i - 1] chart[(i, j)] = result return result (highest, num_of_terms) = (41, 6) starting_prime_index = 0
#!/usr/bin/env python from Euler import prime_sieve from bisect import bisect_right primes = prime_sieve(2000000) print reduce(lambda x, y: x + y, primes, 0) #my awesome solution for the HackerRank version of the problem using caching and binary search in additio to the sieve def HackerRankSol(): primes = prime_sieve(1000100) sum_primes = [0] for i in range(1, len(primes) + 1): sum_primes.append(sum_primes[i - 1] + primes[i - 1]) t = int(raw_input().strip()) for a0 in xrange(t): n = int(raw_input().strip()) print sum_primes[bisect_right(primes, n)]
from Euler import prime_sieve, is_prime max = 1000000 primes = prime_sieve(max) prime_sum = [0] sum = 0 count = 0 while (sum < terms and is_prime(n)): (terms, max_prime) = (j - i, n) print "Project Euler 50 Solution = ", max_prime, " with ", terms, " terms"
from math import sqrt from Euler import prime_sieve # for i in range(50): # print(i, unique_divisors(i)) N = 100000000 primes = set(prime_sieve(N)) def meets_criteria(n): if 1 + n not in primes: return False if 2 + n // 2 not in primes: return False divisors = [i for i in range(1, int(sqrt(n)) + 1) if n % i == 0] for d in divisors: print(d, n, d + n // d) if d + n // d not in primes: return False return True def main(n): sum = 1 # as 1 works for the problem, but is the only odd to work, we set step size to 2 for i in range(2, N+1, 2): if (meets_criteria(i)): sum += i print(i, "meets criteria") print(sum)
def M(p, q, N): primes = prime_sieve(N) for p in primes: gen = (x for x in primes if x != p) for q in gen: while num1
return int(temp) def get_family_size(repeated_num, pattern_fam): family_size = 0 for i in range(repeated_num, 10): if is_prime(generate_number(i, pattern_fam)): family_size += 1 return int(family_size) assumed_bound = 1000000 primes = prime_sieve(assumed_bound) patterns5 = [[1, 0, 0, 0, 1], [0, 1, 0, 0, 1], [0, 0, 1, 0, 1], [0, 0, 0, 1, 1]] patterns6 = [[1, 1, 0, 0, 0, 1], [1, 0, 1, 0, 0, 1], [1, 0, 0, 1, 0, 1], [1, 0, 0, 0, 1, 1], [0, 1, 1, 0, 0, 1], [0, 1, 0, 1, 0, 1], [0, 1, 0, 0, 1, 1], [0, 0, 1, 1, 0, 1], [0, 0, 1, 0, 1, 1], [0, 0, 0, 1, 1, 1]] # start main algorithm def main(): best = int(1000000) for i in range(11, 1000, 2): if i % 5 == 0: i += 2
from Euler import prime_sieve, is_perm, sqrt min_q, i, L = 2, 0, 10**7 primes = prime_sieve(1.30*sqrt(L)) ll = 0.7*sqrt(L) for n in range(len(primes)): if primes[n]>ll: break del primes[:n] for p1 in primes: i+=1 for p2 in primes[i:]: n = p1 * p2 if n > L: break phi = (p1-1) * (p2-1) q = n / float(phi) if is_perm(phi, n) and min_q>q: min_q, min_n = q, n print "Answer to PE70 = ",min_n
from Euler import prime_sieve, is_prime result = int(100000000) primes = prime_sieve(30000) pairs = None def concat(first, second): return int(str(first) + str(second)) def make_pairs(list_of_primes): pairs = list() if list_of_primes is None: return for elem in list_of_primes: for other_elem in list_of_primes: if elem is other_elem: continue pairs.append(concat(elem, other_elem)) return pairs def main(): answers = list() for index_a in range(0, len(primes)): if primes[index_a] * 5 >= result: break if pairs[index_a] is None: pairs[index_a] = make_pairs([index_a]) for index_b in range(index_a, len(primes)):
from Euler import prime_sieve #From proposition 2, https://sriasat.files.wordpress.com/2012/12/eureka.pdf n = 20000000 r = 15000000 my_sum = 0 for p in prime_sieve(n): p_exp = p while p_exp <= n: my_sum += p * (n // p_exp - r // p_exp - (n - r) // p_exp) p_exp *= p print my_sum
''' What is the 10,001st prime number? ''' from Euler import prime_sieve def nth(iterable, n): for i, value in enumerate(iterable): if i==n: return value raise RuntimeError("Iterable length {} < {}".format(i, n)) if __name__ == '__main__': ans = nth(prime_sieve(200000), 10000) print(ans)
def prime_factors(n): lim = n**0.5+1 below_lim = lambda x: x < lim primes = prime_sieve(lim) return (p for p in itertools.takewhile(below_lim, primes) if n%p==0)
In fact, with the exception of p1 = 3 and p2 = 5, for every pair of consecutive primes, p2 > p1, there exist values of n for which the last digits are formed by p1 and n is divisible by p2. Let S be the smallest of these values of n. Find ∑ S for every pair of consecutive primes with 5 ≤ p1 ≤ 1000000. ''' from Euler import prime_sieve import math def S(p1, p2): # m * p2 = k * 10 ** e + p1 # p1 and p2 are coprime so CRT # d = 10 ** e d = 10 ** math.ceil(math.log10(p1)) # k * d + p1 == 0 (mod p2) # k == (p2 - p1) * d_inv (mod p2) # but precisely because p2 is prime we can take shortcut # and avoid doing modular inverse the long way d_inv = pow(d, p2-2, p2) k = (p2 - p1) * d_inv % p2 return k * d + p1 primes = list(prime_sieve(1000000+100)) ans = sum(S(p1, p2) for p1, p2 in zip(primes, primes[1:]) if 5 <= p1 <= 1000000) print(ans)
""" Find the sum of all the primes below one-hundred thousand that will never be a factor of R(10**n). """ from Euler import prime_sieve ans = sum(p for p in prime_sieve(100000) if pow(10, 10 ** 20, p) != 1) + 3 print(ans)
#!/usr/bin/env python import time from Euler import prime_sieve t_0 = time.clock() primes = set(prime_sieve(1000000)) def is_truncatable(p): r = p while r/10 <> 0: r /= 10 if r not in primes: return False m = 10 while p % m <> p: if p % m not in primes: return False m *= 10 return True truncatable_primes = [] for i in primes - set([2,3,5,7]): if is_truncatable(i): truncatable_primes.append(i) if len(truncatable_primes) == 11: break print "Found %d truncatable primes" % len(truncatable_primes) print truncatable_primes
from Euler import prime_sieve, is_prime max = 1000000 primes = prime_sieve(max) prime_sum = [0] sum = 0 count = 0 while (sum<terms and is_prime(n)): (terms, max_prime) = (j-i, n) print "Project Euler 50 Solution = ", max_prime, " with ", terms, " terms"
It can be seen that the first eight rows of Pascal's triangle contain twelve distinct numbers: 1, 2, 3, 4, 5, 6, 7, 10, 15, 20, 21 and 35. A positive integer n is called squarefree if no square of a prime divides n. Of the twelve distinct numbers in the first eight rows of Pascal's triangle, all except 4 and 20 are squarefree. The sum of the distinct squarefree numbers in the first eight rows is 105. Find the sum of the distinct squarefree numbers in the first 51 rows of Pascal's triangle. """ from math import factorial from Euler import prime_sieve def C(n, k): return factorial(n) // factorial(k) // factorial(n - k) def square_free(n): return all(n % f != 0 for f in squares) N = 51 numbers = {C(n, k) for n in range(N) for k in range(n)} squares = [p ** 2 for p in prime_sieve(max(numbers) ** 0.5)] ans = sum(n for n in numbers if square_free(n)) print(ans)
''' Find the sum of all the primes below two million. ''' from Euler import prime_sieve ans = sum(prime_sieve(2*10**6)) print(ans)
def main(index, upper_bound): primes = prime_sieve(upper_bound) return primes[index]
#50. Find the prime below 1 million which is the sum of the most consecutive #primes. from Euler import prime_sieve from Euler import is_prime import time primes = prime_sieve(100000) #this takes some time if incremented t_0 = time.clock() chart = {(0,1): 5} #(i,j) gives the sum of the primes from p[i] to p[j] inclusive def sum_of_primes(i,j): #uses chart to sum from p[i] to p[j] inclusive if (i,j) in chart: return chart[(i,j)] else: if i==0: result = sum_of_primes(i,j-1) + primes[j] chart[(i,j)] = result return result else: result = sum_of_primes(i-1,j) - primes[i-1] chart[(i,j)] = result return result (highest, num_of_terms) = (41,6) starting_prime_index = 0 for i in xrange(0,4): #index of the starting prime m = num_of_terms for j in xrange(i+m,550): #index of the ending prime
''' [See 129] For example, R(10) = 1111111111 = 11×41×271×9091, and the sum of these prime factors is 9414. Find the sum of the first forty prime factors of R(10**9). ''' from Euler import prime_sieve # any factor of 111...[k] is also a factor of 999...[k] # and 999...[k] is 10**k-1. so if the remainder is 1, the number is a factor # however, skip 3, since it trivially divides 9 found = [p for p in prime_sieve(2E5) if pow(10, 10**9, p)==1][1:41] assert len(found) == 40 ans = sum(found) print(ans)
return True def miller_rabin_pass(a, s, d, n): a_to_power = pow(a, d, n) if a_to_power == 1: return True for i in range(s - 1): if a_to_power == n - 1: return True a_to_power = (a_to_power * a_to_power) % n return a_to_power == n - 1 lim = 10**7 sieve, primes = prime_sieve(lim) print 'done sieving' # From http://stackoverflow.com/a/171784 def get_divisors(n): factors = factor(n) nfactors = len(factors) f = [0] * nfactors while True: yield reduce(lambda x, y: x * y, [factors[x][0]**f[x] for x in range(nfactors)], 1) i = 0 while True: f[i] += 1 if f[i] <= factors[i][1]:
from Euler import prime_sieve, is_prime import string def eight_prime_family(prime, rd): c=0 for digit in '0123456789': n = int(string.replace(prime, rd, digit)) if (n>100000 and is_prime(n)): c=c+1 return c==8 for prime in prime_sieve(1000000): if (prime>100000): s = str(prime) last_digit = s[5:6] if (s.count('0')==3 and eight_prime_family(s,'0') \ or s.count('1')==3 and last_digit != '1' and eight_prime_family(s,'1') \ or s.count('2')==3 and eight_prime_family(s,'2')): print "Answer to PE51: ",s
def project_euler_10(): '''Prints the sum of all the primes below two million. See the prime_sieve method in Euler.py for more details.''' # print(sum(prime_sieve(10))) print(sum(prime_sieve(2*10**6)))
#!/usr/bin/python -tt import sys sys.path.append('/Users/admin/Desktop/python-work/Project_Euler/primes') from Euler import prime_sieve, is_prime nmax = 0; primes = prime_sieve(1000) for a in range(-999,999,2): for b in primes: n = 1 while is_prime(n**2 + a*n + b): n += 1 if n>nmax: nmax, p = n, a*b print "Answer to PE27 = ",p def main(): print 'hello' # Standard boilerplate to call the main() function. if __name__ == '__main__': main()
from Euler import prime_sieve, sqrt L = 10**7 primes = prime_sieve(int(1.30 * sqrt(L))) del primes[:int(0.6 * len(primes))] def Eluer70(limit): min_q, min_n, i = 2, 0, 0 for p1 in primes: i += 1 for p2 in primes[i:]: if (p1 + p2) % 9 != 1: continue n = p1 * p2 if n > limit: return min_n phi = (p1 - 1) * (p2 - 1) q = n / float(phi) if sorted(str(phi)) == sorted(str(n)): if min_q > q: min_q = q min_n = n print Euler70(L)
#243. Find the smallest denominator d having a resilience less than #15499/94744. from Euler import prime_sieve primes = prime_sieve(1000) totient = 1 for k in range(1, 1000): first_k_primes = [p for (i, p) in enumerate(primes) if i < k] prime_product = reduce(lambda x,y:x*y, ((1-1./p) \ for p in first_k_primes)) n = reduce(lambda x, y: x * y, (p for p in first_k_primes)) resilience = float(n) / (n - 1) * prime_product if resilience < 15499. / 94744: #print k, first_k_primes #yields 10,[2,3,...,29] break #From the above test I only need to consider primes up to 29, i.e. the first 10. primes = primes[:9] prime_product = reduce(lambda x,y:x*y, ((1-1./p) \ for p in primes)) n = 8 * 3 * 5 * 7 * 11 * 13 * 17 * 19 * 23 print float(n) / (n - 1) * prime_product < 15499. / 94744 print n, "is our winner" n = 16 * 9 * 5 * 7 * 11 * 13 * 17 * 19 print float(n) / (n - 1) * prime_product < 15499. / 94744
from Euler import factor, prime_sieve from operator import mul from collections import defaultdict import sys def prod(*args): return reduce(mul, *args) def is_valid(*args): return prod(*args) == sum(*args) # Return all decompositions of n into factors primes = prime_sieve(10**6) prime_set = set(primes) def is_prime(n): return n in prime_set # Return all decompositions of n memo = {} def D(n): # Memoize if n in memo: return memo[n] vals = [(n, )] #vals = [] # Base case if is_prime(n) or n == 1: memo[n] = vals return vals
from Euler import prime_sieve, is_prime import itertools primes = prime_sieve(70) prime_set = set(primes) def is_prime_set(vals): subsets = itertools.combinations(vals, 2) failed_set = set([]) for a, b in subsets: a = str(a) b = str(b) str1 = a + b str2 = b + a if not is_prime(int(str1)) or not is_prime(int(str2)): return False return True def main(): d = {} subsets = itertools.combinations(primes, 3) for s in subsets: if is_prime_set(s): print s if s[0] in d: d[s[0]].append(s) else: d[s[0]] = [s]
from itertools import permutations from Euler import prime_sieve def perm(k): sett = set() for z in permutations(str(k)): n = "" for t in z: n += t sett.add(int(n)) return sett k = set(prime_sieve(10000)) for i in k: if i > 1000: if i + 3330 in k and i + 3330 in perm(i): if i + 3330 * 2 in k and i + 3330 * 2 in perm(i): print i, i + 3330, i + 3330 * 2