import java . io . * ; class GFG { static void findsolution ( long n , long x , long y ) { if ( ( y - n + 1 ) * ( y - n + 1 ) + n - 1 < x || y < n ) { System . out . println ( " No ▁ solution " ) ; return ; } System . out . println ( y - n + 1 ) ; while ( n -- > 1 ) System . out . println ( "1" ) ; } public static void main ( String [ ] args ) { long n , x , y ; n = 5 ; x = 15 ; y = 15 ; findsolution ( n , x , y ) ; } }

def findsolution ( n , x , y ) : NEW_LINE INDENT if ( ( y - n + 1 ) * ( y - n + 1 ) + n - 1 < x or y < n ) : NEW_LINE INDENT print ( " No ▁ solution " ) ; NEW_LINE return ; NEW_LINE DEDENT print ( y - n + 1 ) ; NEW_LINE while ( n > 1 ) : NEW_LINE INDENT print ( 1 ) ; NEW_LINE n -= 1 ; NEW_LINE DEDENT DEDENT n = 5 ; NEW_LINE x = 15 ; NEW_LINE y = 15 ; NEW_LINE findsolution ( n , x , y ) ; NEW_LINE


public final class p068 implements EulerSolution { public static void main ( String [ ] args ) { System . out . println ( new p068 ( ) . run ( ) ) ; } public String run ( ) { int [ ] state = new int [ 10 ] ; for ( int i = 0 ; i < state . length ; i ++ ) state [ i ] = i + 1 ; String max = null ; do { int sum = state [ 0 ] + state [ 5 ] + state [ 6 ] ; if ( state [ 1 ] + state [ 6 ] + state [ 7 ] != sum || state [ 2 ] + state [ 7 ] + state [ 8 ] != sum || state [ 3 ] + state [ 8 ] + state [ 9 ] != sum || state [ 4 ] + state [ 9 ] + state [ 5 ] != sum ) continue ; int minOuterIndex = - 1 ; int minOuter = Integer . MAX_VALUE ; for ( int i = 0 ; i < 5 ; i ++ ) { if ( state [ i ] < minOuter ) { minOuterIndex = i ; minOuter = state [ i ] ; } } String s = " " ; for ( int i = 0 ; i < 5 ; i ++ ) s += " " + state [ ( minOuterIndex + i ) % 5 ] + state [ ( minOuterIndex + i ) % 5 + 5 ] + state [ ( minOuterIndex + i + 1 ) % 5 + 5 ] ; if ( s . length ( ) == 16 && ( max == null || s . compareTo ( max ) > 0 ) ) max = s ; } while ( Library . nextPermutation ( state ) ) ; if ( max == null ) throw new AssertionError ( ) ; return max ; } }

import eulerlib NEW_LINE def compute ( ) : NEW_LINE INDENT state = list ( range ( 1 , 11 ) ) NEW_LINE max = None NEW_LINE while True : NEW_LINE INDENT sum = state [ 0 ] + state [ 5 ] + state [ 6 ] NEW_LINE if state [ 1 ] + state [ 6 ] + state [ 7 ] == sum and state [ 2 ] + state [ 7 ] + state [ 8 ] == sum and state [ 3 ] + state [ 8 ] + state [ 9 ] == sum and state [ 4 ] + state [ 9 ] + state [ 5 ] == sum : NEW_LINE INDENT minouterindex = 0 NEW_LINE minouter = state [ 0 ] NEW_LINE for i in range ( 1 , 5 ) : NEW_LINE INDENT if state [ i ] < minouter : NEW_LINE INDENT minouterindex = i NEW_LINE minouter = state [ i ] NEW_LINE DEDENT DEDENT s = " " NEW_LINE for i in range ( 5 ) : NEW_LINE INDENT s += str ( state [ ( minouterindex + i ) % 5 ] ) NEW_LINE s += str ( state [ ( minouterindex + i ) % 5 + 5 ] ) NEW_LINE s += str ( state [ ( minouterindex + i + 1 ) % 5 + 5 ] ) NEW_LINE DEDENT if len ( s ) == 16 and ( max is None or s > max ) : NEW_LINE INDENT max = s NEW_LINE DEDENT DEDENT if not eulerlib . next_permutation ( state ) : NEW_LINE INDENT break NEW_LINE DEDENT DEDENT assert max is not None NEW_LINE return max NEW_LINE DEDENT if __name__ == " _ _ main _ _ " : NEW_LINE INDENT print ( compute ( ) ) NEW_LINE DEDENT


import java . math . BigInteger ; public final class p243 implements EulerSolution { public static void main ( String [ ] args ) { System . out . println ( new p243 ( ) . run ( ) ) ; } private static final Fraction TARGET = new Fraction ( BigInteger . valueOf ( 15499 ) , BigInteger . valueOf ( 94744 ) ) ; public String run ( ) { BigInteger totient = BigInteger . ONE ; BigInteger denominator = BigInteger . ONE ; for ( int p = 2 ; ; ) { totient = totient . multiply ( BigInteger . valueOf ( p - 1 ) ) ; denominator = denominator . multiply ( BigInteger . valueOf ( p ) ) ; do p ++ ; while ( ! Library . isPrime ( p ) ) ; if ( new Fraction ( totient , denominator ) . compareTo ( TARGET ) < 0 ) { for ( int i = 1 ; i < p ; i ++ ) { BigInteger numer = BigInteger . valueOf ( i ) . multiply ( totient ) ; BigInteger denom = BigInteger . valueOf ( i ) . multiply ( denominator ) ; if ( new Fraction ( numer , denom . subtract ( BigInteger . ONE ) ) . compareTo ( TARGET ) < 0 ) return denom . toString ( ) ; } } } } }

import eulerlib , fractions NEW_LINE def compute ( ) : NEW_LINE INDENT TARGET = fractions . Fraction ( 15499 , 94744 ) NEW_LINE totient = 1 NEW_LINE denominator = 1 NEW_LINE p = 2 NEW_LINE while True : NEW_LINE INDENT totient *= p - 1 NEW_LINE denominator *= p NEW_LINE while True : NEW_LINE INDENT p += 1 NEW_LINE if eulerlib . is_prime ( p ) : NEW_LINE INDENT break NEW_LINE DEDENT DEDENT if fractions . Fraction ( totient , denominator ) < TARGET : NEW_LINE INDENT for i in range ( 1 , p ) : NEW_LINE INDENT numer = i * totient NEW_LINE denom = i * denominator NEW_LINE if fractions . Fraction ( numer , denom - 1 ) < TARGET : NEW_LINE INDENT return str ( denom ) NEW_LINE DEDENT DEDENT DEDENT DEDENT DEDENT if __name__ == " _ _ main _ _ " : NEW_LINE INDENT print ( compute ( ) ) NEW_LINE DEDENT


public final class p037 implements EulerSolution { public static void main ( String [ ] args ) { System . out . println ( new p037 ( ) . run ( ) ) ; } public String run ( ) { long sum = 0 ; for ( int count = 0 , n = 10 ; count < 11 ; n ++ ) { if ( isTruncatablePrime ( n ) ) { sum += n ; count ++ ; } } return Long . toString ( sum ) ; } private static boolean isTruncatablePrime ( int n ) { for ( long i = 10 ; i <= n ; i *= 10 ) { if ( ! Library . isPrime ( n % ( int ) i ) ) return false ; } for ( ; n != 0 ; n /= 10 ) { if ( ! Library . isPrime ( n ) ) return false ; } return true ; } }

import eulerlib , itertools NEW_LINE def compute ( ) : NEW_LINE INDENT ans = sum ( itertools . islice ( filter ( is_truncatable_prime , itertools . count ( 10 ) ) , 11 ) ) NEW_LINE return str ( ans ) NEW_LINE DEDENT def is_truncatable_prime ( n ) : NEW_LINE INDENT i = 10 NEW_LINE while i <= n : NEW_LINE INDENT if not eulerlib . is_prime ( n % i ) : NEW_LINE INDENT return False NEW_LINE DEDENT i *= 10 NEW_LINE DEDENT while n > 0 : NEW_LINE INDENT if not eulerlib . is_prime ( n ) : NEW_LINE INDENT return False NEW_LINE DEDENT n //= 10 NEW_LINE DEDENT return True NEW_LINE DEDENT if __name__ == " _ _ main _ _ " : NEW_LINE INDENT print ( compute ( ) ) NEW_LINE DEDENT


public final class p182 implements EulerSolution { public static void main ( String [ ] args ) { System . out . println ( new p182 ( ) . run ( ) ) ; } private static final int P = 1009 ; private static final int Q = 3643 ; private static final int TOTIENT = ( P - 1 ) * ( Q - 1 ) ; public String run ( ) { int [ ] numUnconcealedP = countAllUnconcealed ( P ) ; int [ ] numUnconcealedQ = countAllUnconcealed ( Q ) ; int minUnconcealedP = Integer . MAX_VALUE ; for ( int x : numUnconcealedP ) minUnconcealedP = Math . min ( x , minUnconcealedP ) ; int minUnconcealedQ = Integer . MAX_VALUE ; for ( int x : numUnconcealedQ ) minUnconcealedQ = Math . min ( x , minUnconcealedQ ) ; long sum = 0 ; for ( int e = 0 ; e < TOTIENT ; e ++ ) { if ( numUnconcealedP [ e % ( P - 1 ) ] == minUnconcealedP && numUnconcealedQ [ e % ( Q - 1 ) ] == minUnconcealedQ ) sum += e ; } return Long . toString ( sum ) ; } private static int [ ] countAllUnconcealed ( int prime ) { int [ ] numUnconcealed = new int [ prime - 1 ] ; for ( int e = 0 ; e < numUnconcealed . length ; e ++ ) { if ( Library . gcd ( e , prime - 1 ) == 1 ) numUnconcealed [ e ] = countUnconcealed ( prime , e ) ; else numUnconcealed [ e ] = Integer . MAX_VALUE ; } return numUnconcealed ; } private static int countUnconcealed ( int modulus , int e ) { int count = 0 ; for ( int m = 0 ; m < modulus ; m ++ ) { if ( Library . powMod ( m , e , modulus ) == m ) count ++ ; } return count ; } }

import fractions NEW_LINE def compute ( ) : NEW_LINE INDENT P = 1009 NEW_LINE Q = 3643 NEW_LINE TOTIENT = ( P - 1 ) * ( Q - 1 ) NEW_LINE numunconcealedp = count_all_unconcealed ( P ) NEW_LINE numunconcealedq = count_all_unconcealed ( Q ) NEW_LINE minunconcealedp = min ( numunconcealedp ) NEW_LINE minunconcealedq = min ( numunconcealedq ) NEW_LINE ans = sum ( e for e in range ( TOTIENT ) if numunconcealedp [ e % ( P - 1 ) ] == minunconcealedp and numunconcealedq [ e % ( Q - 1 ) ] == minunconcealedq ) NEW_LINE return str ( ans ) NEW_LINE DEDENT def count_all_unconcealed ( prime ) : NEW_LINE INDENT result = [ ] NEW_LINE for e in range ( prime - 1 ) : NEW_LINE INDENT if fractions . gcd ( e , prime - 1 ) == 1 : NEW_LINE INDENT result . append ( count_unconcealed ( prime , e ) ) NEW_LINE DEDENT else : NEW_LINE INDENT result . append ( 10 ** 20 ) NEW_LINE DEDENT DEDENT return result NEW_LINE DEDENT def count_unconcealed ( modulus , e ) : NEW_LINE INDENT result = 0 NEW_LINE for m in range ( modulus ) : NEW_LINE INDENT if pow ( m , e , modulus ) == m : NEW_LINE INDENT result += 1 NEW_LINE DEDENT DEDENT return result NEW_LINE DEDENT if __name__ == " _ _ main _ _ " : NEW_LINE INDENT print ( compute ( ) ) NEW_LINE DEDENT


public final class p006 implements EulerSolution { public static void main ( String [ ] args ) { System . out . println ( new p006 ( ) . run ( ) ) ; } private static final int N = 100 ; public String run ( ) { int sum = 0 ; int sum2 = 0 ; for ( int i = 1 ; i <= N ; i ++ ) { sum += i ; sum2 += i * i ; } return Integer . toString ( sum * sum - sum2 ) ; } }

def compute ( ) : NEW_LINE INDENT N = 100 NEW_LINE s = sum ( i for i in range ( 1 , N + 1 ) ) NEW_LINE s2 = sum ( i ** 2 for i in range ( 1 , N + 1 ) ) NEW_LINE return str ( s ** 2 - s2 ) NEW_LINE DEDENT if __name__ == " _ _ main _ _ " : NEW_LINE INDENT print ( compute ( ) ) NEW_LINE DEDENT


import java . math . BigInteger ; public final class p053 implements EulerSolution { public static void main ( String [ ] args ) { System . out . println ( new p053 ( ) . run ( ) ) ; } public String run ( ) { BigInteger MILLION = BigInteger . TEN . pow ( 6 ) ; int count = 0 ; for ( int n = 1 ; n <= 100 ; n ++ ) { for ( int r = 0 ; r <= n ; r ++ ) { if ( Library . binomial ( n , r ) . compareTo ( MILLION ) > 0 ) count ++ ; } } return Integer . toString ( count ) ; } }

import eulerlib NEW_LINE def compute ( ) : NEW_LINE INDENT ans = sum ( 1 for n in range ( 1 , 101 ) for k in range ( 0 , n + 1 ) if eulerlib . binomial ( n , k ) > 1000000 ) NEW_LINE return str ( ans ) NEW_LINE DEDENT if __name__ == " _ _ main _ _ " : NEW_LINE INDENT print ( compute ( ) ) NEW_LINE DEDENT


import java . math . BigInteger ; import java . util . HashSet ; import java . util . Set ; public final class p029 implements EulerSolution { public static void main ( String [ ] args ) { System . out . println ( new p029 ( ) . run ( ) ) ; } public String run ( ) { Set < BigInteger > generated = new HashSet < > ( ) ; for ( int a = 2 ; a <= 100 ; a ++ ) { for ( int b = 2 ; b <= 100 ; b ++ ) generated . add ( BigInteger . valueOf ( a ) . pow ( b ) ) ; } return Integer . toString ( generated . size ( ) ) ; } }

def compute ( ) : NEW_LINE INDENT seen = set ( a ** b for a in range ( 2 , 101 ) for b in range ( 2 , 101 ) ) NEW_LINE return str ( len ( seen ) ) NEW_LINE DEDENT if __name__ == " _ _ main _ _ " : NEW_LINE INDENT print ( compute ( ) ) NEW_LINE DEDENT


public final class p058 implements EulerSolution { public static void main ( String [ ] args ) { System . out . println ( new p058 ( ) . run ( ) ) ; } public String run ( ) { int numPrimes = 0 ; for ( int n = 1 ; ; n += 2 ) { for ( int i = 0 ; i < 4 ; i ++ ) { if ( Library . isPrime ( n * n - i * ( n - 1 ) ) ) numPrimes ++ ; } if ( n > 1 && numPrimes * 10 < n * 2 - 1 ) return Integer . toString ( n ) ; } } }

import eulerlib , fractions , itertools NEW_LINE def compute ( ) : NEW_LINE INDENT TARGET = fractions . Fraction ( 1 , 10 ) NEW_LINE numprimes = 0 NEW_LINE for n in itertools . count ( 1 , 2 ) : NEW_LINE INDENT for i in range ( 4 ) : NEW_LINE INDENT if eulerlib . is_prime ( n * n - i * ( n - 1 ) ) : NEW_LINE INDENT numprimes += 1 NEW_LINE DEDENT DEDENT if n > 1 and fractions . Fraction ( numprimes , n * 2 - 1 ) < TARGET : NEW_LINE INDENT return str ( n ) NEW_LINE DEDENT DEDENT DEDENT if __name__ == " _ _ main _ _ " : NEW_LINE INDENT print ( compute ( ) ) NEW_LINE DEDENT


import java . math . BigDecimal ; import java . math . BigInteger ; import java . math . RoundingMode ; import java . util . Stack ; public final class p493 implements EulerSolution { public static void main ( String [ ] args ) { System . out . println ( new p493 ( ) . run ( ) ) ; } private static final int NUM_COLORS = 7 ; private static final int BALLS_PER_COLOR = 10 ; private static final int NUM_PICKED = 20 ; private BigInteger numerator = BigInteger . ZERO ; public String run ( ) { explore ( NUM_PICKED , BALLS_PER_COLOR , new Stack < Integer > ( ) ) ; BigInteger denominator = Library . binomial ( NUM_COLORS * BALLS_PER_COLOR , NUM_PICKED ) ; BigDecimal num = new BigDecimal ( numerator ) ; BigDecimal den = new BigDecimal ( denominator ) ; return num . divide ( den , 9 , RoundingMode . HALF_EVEN ) . toString ( ) ; } private void explore ( int remain , int limit , Stack < Integer > history ) { if ( remain == 0 ) { int [ ] hist = new int [ NUM_COLORS ] ; for ( int i = 0 ; i < history . size ( ) ; i ++ ) hist [ i ] = history . get ( i ) ; int [ ] histogram = new int [ BALLS_PER_COLOR + 1 ] ; for ( int x : hist ) histogram [ x ] ++ ; BigInteger count = Library . factorial ( NUM_COLORS ) ; for ( int x : histogram ) count = divideExactly ( count , Library . factorial ( x ) ) ; for ( int x : hist ) count = count . multiply ( Library . binomial ( BALLS_PER_COLOR , x ) ) ; int distinctColors = history . size ( ) ; numerator = numerator . add ( count . multiply ( BigInteger . valueOf ( distinctColors ) ) ) ; } else if ( history . size ( ) < NUM_COLORS ) { for ( int i = Math . min ( limit , remain ) ; i > 0 ; i -- ) { history . push ( i ) ; explore ( remain - i , i , history ) ; history . pop ( ) ; } } } private static BigInteger divideExactly ( BigInteger x , BigInteger y ) { BigInteger [ ] temp = x . divideAndRemainder ( y ) ; if ( temp [ 1 ] . signum ( ) != 0 ) throw new IllegalArgumentException ( " Not ▁ divisible " ) ; return temp [ 0 ] ; } }

import eulerlib , fractions , math NEW_LINE def compute ( ) : NEW_LINE INDENT NUM_COLORS = 7 NEW_LINE BALLS_PER_COLOR = 10 NEW_LINE NUM_PICKED = 20 NEW_LINE DECIMALS = 9 NEW_LINE numerator = [ 0 ] NEW_LINE def explore ( remain , limit , history ) : NEW_LINE INDENT if remain == 0 : NEW_LINE INDENT hist = list ( history ) NEW_LINE while len ( hist ) < NUM_COLORS : NEW_LINE INDENT hist . append ( 0 ) NEW_LINE DEDENT histogram = [ 0 ] * ( BALLS_PER_COLOR + 1 ) NEW_LINE for x in hist : NEW_LINE INDENT histogram [ x ] += 1 NEW_LINE DEDENT count = math . factorial ( NUM_COLORS ) NEW_LINE for x in histogram : NEW_LINE INDENT count = divide_exactly ( count , math . factorial ( x ) ) NEW_LINE DEDENT for x in hist : NEW_LINE INDENT count *= eulerlib . binomial ( BALLS_PER_COLOR , x ) NEW_LINE DEDENT distinctcolors = len ( history ) NEW_LINE numerator [ 0 ] += count * distinctcolors NEW_LINE DEDENT elif len ( history ) < NUM_COLORS : NEW_LINE INDENT for i in range ( min ( limit , remain ) , 0 , - 1 ) : NEW_LINE INDENT history . append ( i ) NEW_LINE explore ( remain - i , i , history ) NEW_LINE history . pop ( ) NEW_LINE DEDENT DEDENT DEDENT explore ( NUM_PICKED , BALLS_PER_COLOR , [ ] ) NEW_LINE denominator = eulerlib . binomial ( NUM_COLORS * BALLS_PER_COLOR , NUM_PICKED ) NEW_LINE ans = fractions . Fraction ( numerator [ 0 ] , denominator ) NEW_LINE return format_fraction ( ans , DECIMALS ) NEW_LINE DEDENT def format_fraction ( val , digits ) : NEW_LINE INDENT if digits <= 0 : NEW_LINE INDENT raise ValueError ( ) NEW_LINE DEDENT if val < 0 : NEW_LINE INDENT return " - " + format_fraction ( - val , digits ) NEW_LINE DEDENT s = str ( round ( val * 10 ** digits ) ) . zfill ( digits + 1 ) NEW_LINE return f " { s [ : - digits ] } . { s [ - digits : ] } " NEW_LINE DEDENT def divide_exactly ( x , y ) : NEW_LINE INDENT if x % y != 0 : NEW_LINE INDENT raise ValueError ( " Not ▁ divisible " ) NEW_LINE DEDENT return x // y NEW_LINE DEDENT if __name__ == " _ _ main _ _ " : NEW_LINE INDENT print ( compute ( ) ) NEW_LINE DEDENT


public final class p218 implements EulerSolution { public static void main ( String [ ] args ) { System . out . println ( new p218 ( ) . run ( ) ) ; } public String run ( ) { return "0" ; } }

def compute ( ) : NEW_LINE INDENT return "0" NEW_LINE DEDENT if __name__ == " _ _ main _ _ " : NEW_LINE INDENT print ( compute ( ) ) NEW_LINE DEDENT


import java . math . BigInteger ; public final class p076 implements EulerSolution { public static void main ( String [ ] args ) { System . out . println ( new p076 ( ) . run ( ) ) ; } public String run ( ) { return partitions ( 100 , 1 ) . subtract ( BigInteger . ONE ) . toString ( ) ; } private static BigInteger partitions ( int n , int k ) { BigInteger [ ] [ ] table = new BigInteger [ n + 1 ] [ n + 1 ] ; for ( int i = 0 ; i <= n ; i ++ ) { for ( int j = n ; j >= 0 ; j -- ) { if ( j == i ) table [ i ] [ j ] = BigInteger . ONE ; else if ( j > i ) table [ i ] [ j ] = BigInteger . ZERO ; else if ( j == 0 ) table [ i ] [ j ] = table [ i ] [ j + 1 ] ; else table [ i ] [ j ] = table [ i ] [ j + 1 ] . add ( table [ i - j ] [ j ] ) ; } } return table [ n ] [ k ] ; } }

def compute ( ) : NEW_LINE INDENT LIMIT = 100 NEW_LINE partitions = [ ] NEW_LINE for i in range ( LIMIT + 1 ) : NEW_LINE INDENT partitions . append ( [ None ] * ( LIMIT + 1 ) ) NEW_LINE for j in reversed ( range ( LIMIT + 1 ) ) : NEW_LINE INDENT if j == i : NEW_LINE INDENT val = 1 NEW_LINE DEDENT elif j > i : NEW_LINE INDENT val = 0 NEW_LINE DEDENT elif j == 0 : NEW_LINE INDENT val = partitions [ i ] [ j + 1 ] NEW_LINE DEDENT else : NEW_LINE INDENT val = partitions [ i ] [ j + 1 ] + partitions [ i - j ] [ j ] NEW_LINE DEDENT partitions [ i ] [ j ] = val NEW_LINE DEDENT DEDENT ans = partitions [ LIMIT ] [ 1 ] - 1 NEW_LINE return str ( ans ) NEW_LINE DEDENT if __name__ == " _ _ main _ _ " : NEW_LINE INDENT print ( compute ( ) ) NEW_LINE DEDENT


public final class p357 implements EulerSolution { public static void main ( String [ ] args ) { System . out . println ( new p357 ( ) . run ( ) ) ; } private static final int LIMIT = Library . pow ( 10 , 8 ) ; private boolean [ ] isPrime ; public String run ( ) { isPrime = Library . listPrimality ( LIMIT + 1 ) ; long sum = 0 ; for ( int n = 0 ; n <= LIMIT ; n ++ ) { if ( isPrime [ n + 1 ] && isPrimeGenerating ( n ) ) sum += n ; } return Long . toString ( sum ) ; } private boolean isPrimeGenerating ( int n ) { for ( int i = 1 , end = Library . sqrt ( n ) ; i <= end ; i ++ ) { if ( n % i == 0 && ! isPrime [ i + n / i ] ) return false ; } return true ; } }

import eulerlib NEW_LINE def compute ( ) : NEW_LINE INDENT LIMIT = 10 ** 8 NEW_LINE isprime = eulerlib . list_primality ( LIMIT + 1 ) NEW_LINE def is_prime_generating ( n ) : NEW_LINE INDENT return all ( ( n % d != 0 or isprime [ d + n // d ] ) for d in range ( 2 , eulerlib . sqrt ( n ) + 1 ) ) NEW_LINE DEDENT ans = sum ( n for n in range ( LIMIT + 1 ) if isprime [ n + 1 ] and is_prime_generating ( n ) ) NEW_LINE return str ( ans ) NEW_LINE DEDENT if __name__ == " _ _ main _ _ " : NEW_LINE INDENT print ( compute ( ) ) NEW_LINE DEDENT


public final class p094 implements EulerSolution { public static void main ( String [ ] args ) { System . out . println ( new p094 ( ) . run ( ) ) ; } private static final int LIMIT = Library . pow ( 10 , 9 ) ; public String run ( ) { long sum = 0 ; for ( int s = 1 ; s * s <= ( LIMIT + 1 ) / 3 ; s += 2 ) { for ( int t = s - 2 ; t > 0 ; t -= 2 ) { if ( Library . gcd ( s , t ) == 1 ) { int a = s * t ; int b = ( s * s - t * t ) / 2 ; int c = ( s * s + t * t ) / 2 ; if ( a * 2 == c - 1 ) { int p = c * 3 - 1 ; if ( p <= LIMIT ) sum += p ; } if ( a * 2 == c + 1 ) { int p = c * 3 + 1 ; if ( p <= LIMIT ) sum += p ; } if ( b * 2 == c - 1 ) { int p = c * 3 - 1 ; if ( p <= LIMIT ) sum += p ; } if ( b * 2 == c + 1 ) { int p = c * 3 + 1 ; if ( p <= LIMIT ) sum += p ; } } } } return Long . toString ( sum ) ; } }

import eulerlib , fractions , itertools NEW_LINE def compute ( ) : NEW_LINE INDENT LIMIT = 10 ** 9 NEW_LINE ans = 0 NEW_LINE for s in itertools . count ( 1 , 2 ) : NEW_LINE INDENT if s * s > ( LIMIT + 1 ) // 3 : NEW_LINE INDENT break NEW_LINE DEDENT for t in range ( s - 2 , 0 , - 2 ) : NEW_LINE INDENT if fractions . gcd ( s , t ) == 1 : NEW_LINE INDENT a = s * t NEW_LINE b = ( s * s - t * t ) // 2 NEW_LINE c = ( s * s + t * t ) // 2 NEW_LINE if a * 2 == c - 1 : NEW_LINE INDENT p = c * 3 - 1 NEW_LINE if p <= LIMIT : NEW_LINE INDENT ans += p NEW_LINE DEDENT DEDENT if a * 2 == c + 1 : NEW_LINE INDENT p = c * 3 + 1 NEW_LINE if p <= LIMIT : NEW_LINE INDENT ans += p NEW_LINE DEDENT DEDENT if b * 2 == c - 1 : NEW_LINE INDENT p = c * 3 - 1 NEW_LINE if p <= LIMIT : NEW_LINE INDENT ans += p NEW_LINE DEDENT DEDENT if b * 2 == c + 1 : NEW_LINE INDENT p = c * 3 + 1 NEW_LINE if p <= LIMIT : NEW_LINE INDENT ans += p NEW_LINE DEDENT DEDENT DEDENT DEDENT DEDENT return str ( ans ) NEW_LINE DEDENT if __name__ == " _ _ main _ _ " : NEW_LINE INDENT print ( compute ( ) ) NEW_LINE DEDENT


import java . util . Arrays ; public final class p211 implements EulerSolution { public static void main ( String [ ] args ) { System . out . println ( new p211 ( ) . run ( ) ) ; } private static final int LIMIT = 64000000 ; public String run ( ) { long [ ] sigma2 = new long [ LIMIT ] ; Arrays . fill ( sigma2 , 1 , sigma2 . length , 1 ) ; for ( int i = 2 ; i < sigma2 . length ; i ++ ) { if ( sigma2 [ i ] == 1 ) { for ( int j = i ; j < sigma2 . length ; j += i ) sigma2 [ j ] *= powerSquareSum ( j , i ) ; } } long sum = 0 ; SquareTester sqt = new SquareTester ( 3 * 5 * 7 * 11 * 13 * 17 ) ; for ( int i = 1 ; i < sigma2 . length ; i ++ ) { if ( sqt . isPerfectSquare ( sigma2 [ i ] ) ) sum += i ; } return Long . toString ( sum ) ; } private static long powerSquareSum ( int n , int k ) { long result = 1 ; long k2 = ( long ) k * k ; while ( n % k == 0 ) { n /= k ; result = result * k2 + 1 ; } return result ; } private static final class SquareTester { private boolean [ ] isResidue ; public SquareTester ( int modulus ) { if ( modulus < 1 ) throw new IllegalArgumentException ( ) ; isResidue = new boolean [ modulus ] ; for ( int i = 0 ; i < modulus ; i ++ ) isResidue [ ( int ) ( ( long ) i * i % modulus ) ] = true ; } public boolean isPerfectSquare ( long x ) { if ( ! isResidue [ ( int ) ( x % isResidue . length ) ] ) return false ; long y = 0 ; for ( long i = 1L << 31 ; i != 0 ; i >>>= 1 ) { y |= i ; if ( y > 3037000499L || y * y > x ) y ^= i ; } return y * y == x ; } } }

import array , eulerlib NEW_LINE def compute ( ) : NEW_LINE INDENT LIMIT = 64000000 NEW_LINE RESIDUE_TEST = 3 * 5 * 7 * 11 * 13 NEW_LINE isresidue = [ False ] * RESIDUE_TEST NEW_LINE for i in range ( RESIDUE_TEST ) : NEW_LINE INDENT isresidue [ i * i % RESIDUE_TEST ] = True NEW_LINE DEDENT def is_perfect_square ( x ) : NEW_LINE INDENT return isresidue [ x % RESIDUE_TEST ] and eulerlib . is_square ( x ) NEW_LINE DEDENT sigma2 = list_sigma2 ( LIMIT - 1 ) NEW_LINE ans = sum ( i for i in range ( 1 , LIMIT ) if is_perfect_square ( sigma2 [ i ] ) ) NEW_LINE return str ( ans ) NEW_LINE DEDENT def list_sigma2 ( n ) : NEW_LINE INDENT sqrt = eulerlib . sqrt ( n ) NEW_LINE quasiprimefactor = array . array ( " H " , ( 0 for _ in range ( n + 1 ) ) ) NEW_LINE for i in range ( 2 , sqrt + 1 ) : NEW_LINE INDENT if quasiprimefactor [ i ] == 0 : NEW_LINE INDENT quasiprimefactor [ i ] = i NEW_LINE for j in range ( i * i , n + 1 , i ) : NEW_LINE INDENT if quasiprimefactor [ j ] == 0 : NEW_LINE INDENT quasiprimefactor [ j ] = i NEW_LINE DEDENT DEDENT DEDENT DEDENT sigma2 = array . array ( " Q " , ( 0 for _ in range ( n + 1 ) ) ) NEW_LINE sigma2 [ 1 ] = 1 NEW_LINE for i in range ( 2 , len ( sigma2 ) ) : NEW_LINE INDENT p = quasiprimefactor [ i ] NEW_LINE if p == 0 : NEW_LINE INDENT p = i NEW_LINE DEDENT sum = 1 NEW_LINE j = i NEW_LINE p2 = p * p NEW_LINE k = p2 NEW_LINE while j % p == 0 : NEW_LINE INDENT sum += k NEW_LINE j //= p NEW_LINE k *= p2 NEW_LINE DEDENT sigma2 [ i ] = sum * sigma2 [ j ] NEW_LINE DEDENT return sigma2 NEW_LINE DEDENT if __name__ == " _ _ main _ _ " : NEW_LINE INDENT print ( compute ( ) ) NEW_LINE DEDENT


public final class p012 implements EulerSolution { public static void main ( String [ ] args ) { System . out . println ( new p012 ( ) . run ( ) ) ; } public String run ( ) { int triangle = 0 ; for ( int i = 1 ; ; i ++ ) { if ( Integer . MAX_VALUE - triangle < i ) throw new ArithmeticException ( " Overflow " ) ; triangle += i ; if ( countDivisors ( triangle ) > 500 ) return Integer . toString ( triangle ) ; } } private static int countDivisors ( int n ) { int count = 0 ; int end = Library . sqrt ( n ) ; for ( int i = 1 ; i < end ; i ++ ) { if ( n % i == 0 ) count += 2 ; } if ( end * end == n ) count ++ ; return count ; } }

import eulerlib , itertools NEW_LINE def compute ( ) : NEW_LINE INDENT triangle = 0 NEW_LINE for i in itertools . count ( 1 ) : NEW_LINE INDENT triangle += i NEW_LINE if num_divisors ( triangle ) > 500 : NEW_LINE INDENT return str ( triangle ) NEW_LINE DEDENT DEDENT DEDENT def num_divisors ( n ) : NEW_LINE INDENT end = eulerlib . sqrt ( n ) NEW_LINE result = sum ( 2 for i in range ( 1 , end + 1 ) if n % i == 0 ) NEW_LINE if end ** 2 == n : NEW_LINE INDENT result -= 1 NEW_LINE DEDENT return result NEW_LINE DEDENT if __name__ == " _ _ main _ _ " : NEW_LINE INDENT print ( compute ( ) ) NEW_LINE DEDENT


public final class p002 implements EulerSolution { public static void main ( String [ ] args ) { System . out . println ( new p002 ( ) . run ( ) ) ; } public String run ( ) { int sum = 0 ; int x = 1 ; int y = 2 ; while ( x <= 4000000 ) { if ( x % 2 == 0 ) sum += x ; int z = x + y ; x = y ; y = z ; } return Integer . toString ( sum ) ; } }

def compute ( ) : NEW_LINE INDENT ans = 0 NEW_LINE x = 1 NEW_LINE y = 2 NEW_LINE while x <= 4000000 : NEW_LINE INDENT if x % 2 == 0 : NEW_LINE INDENT ans += x NEW_LINE DEDENT x , y = y , x + y NEW_LINE DEDENT return str ( ans ) NEW_LINE DEDENT if __name__ == " _ _ main _ _ " : NEW_LINE INDENT print ( compute ( ) ) NEW_LINE DEDENT


public final class p033 implements EulerSolution { public static void main ( String [ ] args ) { System . out . println ( new p033 ( ) . run ( ) ) ; } public String run ( ) { int numer = 1 ; int denom = 1 ; for ( int d = 10 ; d < 100 ; d ++ ) { for ( int n = 10 ; n < d ; n ++ ) { int n0 = n % 10 , n1 = n / 10 ; int d0 = d % 10 , d1 = d / 10 ; if ( n1 == d0 && n0 * d == n * d1 || n0 == d1 && n1 * d == n * d0 ) { numer *= n ; denom *= d ; } } } return Integer . toString ( denom / Library . gcd ( numer , denom ) ) ; } }

import fractions NEW_LINE def compute ( ) : NEW_LINE INDENT numer = 1 NEW_LINE denom = 1 NEW_LINE for d in range ( 10 , 100 ) : NEW_LINE INDENT for n in range ( 10 , d ) : NEW_LINE INDENT n0 = n % 10 NEW_LINE n1 = n // 10 NEW_LINE d0 = d % 10 NEW_LINE d1 = d // 10 NEW_LINE if ( n1 == d0 and n0 * d == n * d1 ) or ( n0 == d1 and n1 * d == n * d0 ) : NEW_LINE INDENT numer *= n NEW_LINE denom *= d NEW_LINE DEDENT DEDENT DEDENT return str ( denom // fractions . gcd ( numer , denom ) ) NEW_LINE DEDENT if __name__ == " _ _ main _ _ " : NEW_LINE INDENT print ( compute ( ) ) NEW_LINE DEDENT


public final class p091 implements EulerSolution { public static void main ( String [ ] args ) { System . out . println ( new p091 ( ) . run ( ) ) ; } private static final int LIMIT = 50 ; public String run ( ) { int count = 0 ; for ( int x1 = 0 ; x1 <= LIMIT ; x1 ++ ) { for ( int y1 = 0 ; y1 <= LIMIT ; y1 ++ ) { for ( int x2 = 0 ; x2 <= LIMIT ; x2 ++ ) { for ( int y2 = 0 ; y2 <= LIMIT ; y2 ++ ) { if ( y2 * x1 < y1 * x2 && isRightTriangle ( x1 , y1 , x2 , y2 ) ) count ++ ; } } } } return Integer . toString ( count ) ; } private static boolean isRightTriangle ( int x1 , int y1 , int x2 , int y2 ) { int a = x1 * x1 + y1 * y1 ; int b = x2 * x2 + y2 * y2 ; int c = ( x2 - x1 ) * ( x2 - x1 ) + ( y2 - y1 ) * ( y2 - y1 ) ; return a + b == c || b + c == a || c + a == b ; } }

def compute ( ) : NEW_LINE INDENT LIMIT = 51 NEW_LINE ans = sum ( 1 for x1 in range ( LIMIT ) for y1 in range ( LIMIT ) for x2 in range ( LIMIT ) for y2 in range ( LIMIT ) if y2 * x1 < y1 * x2 and is_right_triangle ( x1 , y1 , x2 , y2 ) ) NEW_LINE return str ( ans ) NEW_LINE DEDENT def is_right_triangle ( x1 , y1 , x2 , y2 ) : NEW_LINE INDENT a = x1 ** 2 + y1 ** 2 NEW_LINE b = x2 ** 2 + y2 ** 2 NEW_LINE c = ( x2 - x1 ) ** 2 + ( y2 - y1 ) ** 2 NEW_LINE return ( a + b == c ) or ( b + c == a ) or ( c + a == b ) NEW_LINE DEDENT if __name__ == " _ _ main _ _ " : NEW_LINE INDENT print ( compute ( ) ) NEW_LINE DEDENT


import java . math . BigInteger ; public final class p113 implements EulerSolution { public static void main ( String [ ] args ) { System . out . println ( new p113 ( ) . run ( ) ) ; } private static final int DIGITS = 100 ; public String run ( ) { BigInteger increasing = Library . binomial ( DIGITS + 9 , 9 ) . subtract ( BigInteger . ONE ) ; BigInteger decreasing = Library . binomial ( DIGITS + 10 , 10 ) . subtract ( BigInteger . valueOf ( DIGITS + 1 ) ) ; BigInteger flat = BigInteger . valueOf ( DIGITS * 9 ) ; return increasing . add ( decreasing ) . subtract ( flat ) . toString ( ) ; } }

import eulerlib NEW_LINE def compute ( ) : NEW_LINE INDENT DIGITS = 100 NEW_LINE increasing = eulerlib . binomial ( DIGITS + 9 , 9 ) - 1 NEW_LINE decreasing = eulerlib . binomial ( DIGITS + 10 , 10 ) - ( DIGITS + 1 ) NEW_LINE flat = DIGITS * 9 NEW_LINE ans = increasing + decreasing - flat NEW_LINE return str ( ans ) NEW_LINE DEDENT if __name__ == " _ _ main _ _ " : NEW_LINE INDENT print ( compute ( ) ) NEW_LINE DEDENT


public final class p071 implements EulerSolution { public static void main ( String [ ] args ) { System . out . println ( new p071 ( ) . run ( ) ) ; } private static final int LIMIT = 1000000 ; public String run ( ) { int maxN = 0 ; int maxD = 1 ; for ( int d = 1 ; d <= LIMIT ; d ++ ) { int n = d * 3 / 7 ; if ( d % 7 == 0 ) n -- ; if ( ( long ) n * maxD > ( long ) maxN * d ) { maxN = n ; maxD = d ; } } return Integer . toString ( maxN ) ; } }

def compute ( ) : NEW_LINE INDENT LIMIT = 1000000 NEW_LINE maxnumer = 0 NEW_LINE maxdenom = 1 NEW_LINE for d in range ( 1 , LIMIT + 1 ) : NEW_LINE INDENT n = d * 3 // 7 NEW_LINE if d % 7 == 0 : NEW_LINE INDENT n -= 1 NEW_LINE DEDENT if n * maxdenom > d * maxnumer : NEW_LINE INDENT maxnumer = n NEW_LINE maxdenom = d NEW_LINE DEDENT DEDENT return str ( maxnumer ) NEW_LINE DEDENT if __name__ == " _ _ main _ _ " : NEW_LINE INDENT print ( compute ( ) ) NEW_LINE DEDENT


public final class p003 implements EulerSolution { public static void main ( String [ ] args ) { System . out . println ( new p003 ( ) . run ( ) ) ; } public String run ( ) { long n = 600851475143L ; while ( true ) { long p = smallestFactor ( n ) ; if ( p < n ) n /= p ; else return Long . toString ( n ) ; } } private static long smallestFactor ( long n ) { if ( n <= 1 ) throw new IllegalArgumentException ( ) ; for ( long i = 2 , end = Library . sqrt ( n ) ; i <= end ; i ++ ) { if ( n % i == 0 ) return i ; } return n ; } }

import eulerlib NEW_LINE def compute ( ) : NEW_LINE INDENT n = 600851475143 NEW_LINE while True : NEW_LINE INDENT p = smallest_prime_factor ( n ) NEW_LINE if p < n : NEW_LINE INDENT n //= p NEW_LINE DEDENT else : NEW_LINE INDENT return str ( n ) NEW_LINE DEDENT DEDENT DEDENT def smallest_prime_factor ( n ) : NEW_LINE INDENT assert n >= 2 NEW_LINE for i in range ( 2 , eulerlib . sqrt ( n ) + 1 ) : NEW_LINE INDENT if n % i == 0 : NEW_LINE INDENT return i NEW_LINE DEDENT DEDENT return n NEW_LINE DEDENT if __name__ == " _ _ main _ _ " : NEW_LINE INDENT print ( compute ( ) ) NEW_LINE DEDENT


import java . util . HashSet ; import java . util . Set ; public final class p125 implements EulerSolution { public static void main ( String [ ] args ) { System . out . println ( new p125 ( ) . run ( ) ) ; } public String run ( ) { Set < Integer > nums = new HashSet < > ( ) ; for ( int i = 1 ; i <= 10000 ; i ++ ) { int sum = i * i ; for ( int j = i + 1 ; ; j ++ ) { sum += j * j ; if ( sum >= 100000000 ) break ; if ( Library . isPalindrome ( sum ) ) nums . add ( sum ) ; } } long sum = 0 ; for ( int x : nums ) sum += x ; return Long . toString ( sum ) ; } }

import itertools NEW_LINE def compute ( ) : NEW_LINE INDENT nums = set ( ) NEW_LINE for i in range ( 1 , 10001 ) : NEW_LINE INDENT sigma = i * i NEW_LINE for j in itertools . count ( i + 1 ) : NEW_LINE INDENT sigma += j * j NEW_LINE if sigma >= 100000000 : NEW_LINE INDENT break NEW_LINE DEDENT s = str ( sigma ) NEW_LINE if s == s [ : : - 1 ] : NEW_LINE INDENT nums . add ( sigma ) NEW_LINE DEDENT DEDENT DEDENT return str ( sum ( nums ) ) NEW_LINE DEDENT if __name__ == " _ _ main _ _ " : NEW_LINE INDENT print ( compute ( ) ) NEW_LINE DEDENT


import java . math . BigInteger ; public final class p121 implements EulerSolution { public static void main ( String [ ] args ) { System . out . println ( new p121 ( ) . run ( ) ) ; } private static final int TURNS = 15 ; public String run ( ) { BigInteger [ ] [ ] ways = new BigInteger [ TURNS + 1 ] [ ] ; ways [ 0 ] = new BigInteger [ ] { BigInteger . ONE } ; for ( int i = 1 ; i <= TURNS ; i ++ ) { ways [ i ] = new BigInteger [ i + 1 ] ; for ( int j = 0 ; j <= i ; j ++ ) { BigInteger temp = BigInteger . ZERO ; if ( j < i ) temp = ways [ i - 1 ] [ j ] . multiply ( BigInteger . valueOf ( i ) ) ; if ( j > 0 ) temp = temp . add ( ways [ i - 1 ] [ j - 1 ] ) ; ways [ i ] [ j ] = temp ; } } BigInteger numer = BigInteger . ZERO ; for ( int i = TURNS / 2 + 1 ; i <= TURNS ; i ++ ) numer = numer . add ( ways [ TURNS ] [ i ] ) ; BigInteger denom = Library . factorial ( TURNS + 1 ) ; return denom . divide ( numer ) . toString ( ) ; } }

import math NEW_LINE def compute ( ) : NEW_LINE INDENT TURNS = 15 NEW_LINE ways = [ [ 1 ] ] NEW_LINE for i in range ( 1 , TURNS + 1 ) : NEW_LINE INDENT row = [ ] NEW_LINE for j in range ( i + 1 ) : NEW_LINE INDENT temp = 0 NEW_LINE if j < i : NEW_LINE INDENT temp = ways [ i - 1 ] [ j ] * i NEW_LINE DEDENT if j > 0 : NEW_LINE INDENT temp += ways [ i - 1 ] [ j - 1 ] NEW_LINE DEDENT row . append ( temp ) NEW_LINE DEDENT ways . append ( row ) NEW_LINE DEDENT numer = sum ( ways [ TURNS ] [ i ] for i in range ( TURNS // 2 + 1 , TURNS + 1 ) ) NEW_LINE denom = math . factorial ( TURNS + 1 ) NEW_LINE return str ( denom // numer ) NEW_LINE DEDENT if __name__ == " _ _ main _ _ " : NEW_LINE INDENT print ( compute ( ) ) NEW_LINE DEDENT


import java . math . BigInteger ; public final class p025 implements EulerSolution { public static void main ( String [ ] args ) { System . out . println ( new p025 ( ) . run ( ) ) ; } private static final int DIGITS = 1000 ; public String run ( ) { BigInteger lowerThres = BigInteger . TEN . pow ( DIGITS - 1 ) ; BigInteger upperThres = BigInteger . TEN . pow ( DIGITS ) ; BigInteger prev = BigInteger . ONE ; BigInteger cur = BigInteger . ZERO ; for ( int i = 0 ; ; i ++ ) { if ( cur . compareTo ( upperThres ) >= 0 ) throw new RuntimeException ( " Not ▁ found " ) ; else if ( cur . compareTo ( lowerThres ) >= 0 ) return Integer . toString ( i ) ; BigInteger temp = cur . add ( prev ) ; prev = cur ; cur = temp ; } } }

import itertools NEW_LINE def compute ( ) : NEW_LINE INDENT DIGITS = 1000 NEW_LINE prev = 1 NEW_LINE cur = 0 NEW_LINE for i in itertools . count ( ) : NEW_LINE INDENT if len ( str ( cur ) ) > DIGITS : NEW_LINE INDENT raise RuntimeError ( " Not ▁ found " ) NEW_LINE DEDENT elif len ( str ( cur ) ) == DIGITS : NEW_LINE INDENT return str ( i ) NEW_LINE DEDENT prev , cur = cur , prev + cur NEW_LINE DEDENT DEDENT if __name__ == " _ _ main _ _ " : NEW_LINE INDENT print ( compute ( ) ) NEW_LINE DEDENT


import java . util . Arrays ; public final class p127 implements EulerSolution { public static void main ( String [ ] args ) { System . out . println ( new p127 ( ) . run ( ) ) ; } private static final int LIMIT = 120000 ; public String run ( ) { int [ ] rads = new int [ LIMIT ] ; Arrays . fill ( rads , 1 , rads . length , 1 ) ; for ( int i = 2 ; i < rads . length ; i ++ ) { if ( rads [ i ] == 1 ) { for ( int j = i ; j < rads . length ; j += i ) rads [ j ] *= i ; } } long sum = 0 ; for ( int c = 2 ; c < LIMIT ; c ++ ) { if ( rads [ c ] == c ) continue ; for ( int a = 1 , end = ( c - 1 ) / 2 ; a <= end ; a ++ ) { int b = c - a ; assert a < b ; if ( ( long ) rads [ a ] * rads [ b ] * rads [ c ] < c && Library . gcd ( a , b ) == 1 ) sum += c ; } } return Long . toString ( sum ) ; } }

import fractions NEW_LINE def compute ( ) : NEW_LINE INDENT LIMIT = 120000 NEW_LINE rads = [ 0 ] + [ 1 ] * ( LIMIT - 1 ) NEW_LINE for i in range ( 2 , len ( rads ) ) : NEW_LINE INDENT if rads [ i ] == 1 : NEW_LINE INDENT for j in range ( i , len ( rads ) , i ) : NEW_LINE INDENT rads [ j ] *= i NEW_LINE DEDENT DEDENT DEDENT sortedrads = sorted ( ( rad , n ) for ( n , rad ) in enumerate ( rads ) ) NEW_LINE sortedrads = sortedrads [ 1 : ] NEW_LINE ans = 0 NEW_LINE for c in range ( 2 , LIMIT ) : NEW_LINE INDENT for ( rad , a ) in sortedrads : NEW_LINE INDENT rad *= rads [ c ] NEW_LINE if rad >= c : NEW_LINE INDENT break NEW_LINE DEDENT b = c - a NEW_LINE if a < b and rad * rads [ b ] < c and fractions . gcd ( a , b ) == 1 : NEW_LINE INDENT ans += c NEW_LINE DEDENT DEDENT DEDENT return str ( ans ) NEW_LINE DEDENT if __name__ == " _ _ main _ _ " : NEW_LINE INDENT print ( compute ( ) ) NEW_LINE DEDENT


public final class p120 implements EulerSolution { public static void main ( String [ ] args ) { System . out . println ( new p120 ( ) . run ( ) ) ; } public String run ( ) { int sum = 0 ; for ( int a = 3 ; a <= 1000 ; a ++ ) sum += a * ( a - ( a % 2 == 0 ? 2 : 1 ) ) ; return Integer . toString ( sum ) ; } }

def compute ( ) : NEW_LINE INDENT ans = sum ( i * ( i - ( 2 if i % 2 == 0 else 1 ) ) for i in range ( 3 , 1001 ) ) NEW_LINE return str ( ans ) NEW_LINE DEDENT if __name__ == " _ _ main _ _ " : NEW_LINE INDENT print ( compute ( ) ) NEW_LINE DEDENT


import java . util . Arrays ; public final class p124 implements EulerSolution { public static void main ( String [ ] args ) { System . out . println ( new p124 ( ) . run ( ) ) ; } private static final int LIMIT = 100000 ; public String run ( ) { int [ ] rads = new int [ LIMIT + 1 ] ; Arrays . fill ( rads , 1 , rads . length , 1 ) ; for ( int i = 2 ; i < rads . length ; i ++ ) { if ( rads [ i ] == 1 ) { for ( int j = i ; j < rads . length ; j += i ) rads [ j ] *= i ; } } IntPair [ ] data = new IntPair [ LIMIT ] ; for ( int i = 0 ; i < data . length ; i ++ ) data [ i ] = new IntPair ( rads [ i + 1 ] , i + 1 ) ; Arrays . sort ( data ) ; return Integer . toString ( data [ 10000 - 1 ] . b ) ; } private static final class IntPair implements Comparable < IntPair > { public final int a ; public final int b ; public IntPair ( int a , int b ) { this . a = a ; this . b = b ; } public int compareTo ( IntPair other ) { if ( a != other . a ) return Integer . compare ( a , other . a ) ; else return Integer . compare ( b , other . b ) ; } } }

def compute ( ) : NEW_LINE INDENT LIMIT = 100000 NEW_LINE rads = [ 0 ] + [ 1 ] * LIMIT NEW_LINE for i in range ( 2 , len ( rads ) ) : NEW_LINE INDENT if rads [ i ] == 1 : NEW_LINE INDENT for j in range ( i , len ( rads ) , i ) : NEW_LINE INDENT rads [ j ] *= i NEW_LINE DEDENT DEDENT DEDENT data = sorted ( ( rad , i ) for ( i , rad ) in enumerate ( rads ) ) NEW_LINE return str ( data [ 10000 ] [ 1 ] ) NEW_LINE DEDENT if __name__ == " _ _ main _ _ " : NEW_LINE INDENT print ( compute ( ) ) NEW_LINE DEDENT


import java . math . BigInteger ; import java . util . ArrayList ; import java . util . List ; public final class p172 implements EulerSolution { public static void main ( String [ ] args ) { System . out . println ( new p172 ( ) . run ( ) ) ; } private static final int LENGTH = 18 ; private static final int MAX_COUNT = 3 ; private static final int BASE = 10 ; public String run ( ) { BigInteger ways = partitionAndCount ( LENGTH , MAX_COUNT , new ArrayList < Integer > ( ) ) ; BigInteger BASE_BI = BigInteger . valueOf ( BASE ) ; ways = ways . multiply ( BASE_BI . subtract ( BigInteger . ONE ) ) ; ways = divideExactly ( ways , BASE_BI ) ; return ways . toString ( ) ; } private BigInteger partitionAndCount ( int sum , int max , List < Integer > terms ) { if ( terms . size ( ) == BASE ) { if ( sum == 0 ) return countWays ( terms ) ; else return BigInteger . ZERO ; } else { BigInteger result = BigInteger . ZERO ; for ( int i = Math . min ( max , sum ) ; i >= 0 ; i -- ) { terms . add ( i ) ; result = result . add ( partitionAndCount ( sum - i , i , terms ) ) ; terms . remove ( terms . size ( ) - 1 ) ; } return result ; } } private BigInteger countWays ( List < Integer > freqs ) { int [ ] histogram = new int [ MAX_COUNT + 1 ] ; for ( int x : freqs ) histogram [ x ] ++ ; BigInteger ways = Library . factorial ( BASE ) ; for ( int x : histogram ) ways = ways . divide ( Library . factorial ( x ) ) ; ways = ways . multiply ( Library . factorial ( LENGTH ) ) ; for ( int x : freqs ) ways = ways . divide ( Library . factorial ( x ) ) ; return ways ; } private static BigInteger divideExactly ( BigInteger x , BigInteger y ) { BigInteger [ ] temp = x . divideAndRemainder ( y ) ; if ( temp [ 1 ] . signum ( ) != 0 ) throw new IllegalArgumentException ( " Not ▁ divisible " ) ; return temp [ 0 ] ; } }

import math NEW_LINE LENGTH = 18 NEW_LINE MAX_COUNT = 3 NEW_LINE BASE = 10 NEW_LINE def compute ( ) : NEW_LINE INDENT ans = partition_and_count ( LENGTH , MAX_COUNT , [ ] ) NEW_LINE ans = divide_exactly ( ans * ( BASE - 1 ) , BASE ) NEW_LINE return str ( ans ) NEW_LINE DEDENT def partition_and_count ( sum , max , terms ) : NEW_LINE INDENT if len ( terms ) == BASE : NEW_LINE INDENT return count_ways ( terms ) if ( sum == 0 ) else 0 NEW_LINE DEDENT else : NEW_LINE INDENT result = 0 NEW_LINE for i in reversed ( range ( min ( max , sum ) + 1 ) ) : NEW_LINE INDENT terms . append ( i ) NEW_LINE result += partition_and_count ( sum - i , i , terms ) NEW_LINE terms . pop ( ) NEW_LINE DEDENT return result NEW_LINE DEDENT DEDENT def count_ways ( freqs ) : NEW_LINE INDENT histogram = [ 0 ] * ( MAX_COUNT + 1 ) NEW_LINE for x in freqs : NEW_LINE INDENT histogram [ x ] += 1 NEW_LINE DEDENT ways = math . factorial ( BASE ) NEW_LINE for x in histogram : NEW_LINE INDENT ways //= math . factorial ( x ) NEW_LINE DEDENT ways *= math . factorial ( LENGTH ) NEW_LINE for x in freqs : NEW_LINE INDENT ways //= math . factorial ( x ) NEW_LINE DEDENT return ways NEW_LINE DEDENT def divide_exactly ( x , y ) : NEW_LINE INDENT if x % y != 0 : NEW_LINE INDENT raise ValueError ( " Not ▁ divisible " ) NEW_LINE DEDENT return x // y NEW_LINE DEDENT if __name__ == " _ _ main _ _ " : NEW_LINE INDENT print ( compute ( ) ) NEW_LINE DEDENT


public final class p587 implements EulerSolution { public static void main ( String [ ] args ) { System . out . println ( new p587 ( ) . run ( ) ) ; } public String run ( ) { double lSectionArea = 1 - Math . PI / 4 ; for ( int i = 1 ; ; i ++ ) { double slope = 1.0 / i ; double a = slope * slope + 1 ; double b = - 2 * ( slope + 1 ) ; double c = 1 ; double x = ( 2 * c ) / ( - b + Math . sqrt ( b * b - 4 * a * c ) ) ; double concaveTriangleArea = ( x * x * slope / 2 ) + ( integral ( 1 ) - integral ( x ) ) ; if ( concaveTriangleArea / lSectionArea < 0.001 ) return Integer . toString ( i ) ; if ( i == Integer . MAX_VALUE ) throw new AssertionError ( ) ; } } private static double integral ( double x ) { double t = x - 1 ; return t - ( Math . sqrt ( x * ( 2 - x ) ) * t + Math . asin ( t ) ) / 2 ; } }

import itertools , math NEW_LINE def compute ( ) : NEW_LINE INDENT def integral ( x ) : NEW_LINE INDENT t = x - 1.0 NEW_LINE return t - ( math . sqrt ( x * ( 2.0 - x ) ) * t + math . asin ( t ) ) / 2.0 NEW_LINE DEDENT lsectionarea = 1.0 - math . pi / 4.0 NEW_LINE for i in itertools . count ( 1 ) : NEW_LINE INDENT slope = 1.0 / i NEW_LINE a = slope ** 2 + 1.0 NEW_LINE b = - 2.0 * ( slope + 1.0 ) NEW_LINE c = 1.0 NEW_LINE x = ( 2.0 * c ) / ( - b + math . sqrt ( b * b - 4 * a * c ) ) NEW_LINE concavetrianglearea = ( x ** 2 * slope / 2 ) + ( integral ( 1.0 ) - integral ( x ) ) NEW_LINE if concavetrianglearea / lsectionarea < 0.001 : NEW_LINE INDENT return str ( i ) NEW_LINE DEDENT DEDENT DEDENT if __name__ == " _ _ main _ _ " : NEW_LINE INDENT print ( compute ( ) ) NEW_LINE DEDENT


import java . math . BigInteger ; public final class p106 implements EulerSolution { public static void main ( String [ ] args ) { System . out . println ( new p106 ( ) . run ( ) ) ; } private static final int SET_SIZE = 12 ; public String run ( ) { BigInteger ans = BigInteger . ZERO ; for ( int i = 2 ; i * 2 <= SET_SIZE ; i ++ ) { BigInteger x = Library . binomial ( SET_SIZE , i * 2 ) ; BigInteger y = Library . binomial ( i * 2 , i ) . shiftRight ( 1 ) ; BigInteger z = Library . binomial ( i * 2 , i ) . divide ( BigInteger . valueOf ( i + 1 ) ) ; ans = ans . add ( x . multiply ( y . subtract ( z ) ) ) ; } return ans . toString ( ) ; } }

import eulerlib NEW_LINE def compute ( ) : NEW_LINE INDENT SET_SIZE = 12 NEW_LINE def catalan ( n ) : NEW_LINE INDENT return eulerlib . binomial ( n * 2 , n ) // ( n + 1 ) NEW_LINE DEDENT ans = sum ( eulerlib . binomial ( SET_SIZE , i * 2 ) * ( eulerlib . binomial ( i * 2 , i ) // 2 - catalan ( i ) ) for i in range ( 2 , SET_SIZE // 2 + 1 ) ) NEW_LINE return str ( ans ) NEW_LINE DEDENT if __name__ == " _ _ main _ _ " : NEW_LINE INDENT print ( compute ( ) ) NEW_LINE DEDENT


public final class p017 implements EulerSolution { public static void main ( String [ ] args ) { System . out . println ( new p017 ( ) . run ( ) ) ; } public String run ( ) { int sum = 0 ; for ( int i = 1 ; i <= 1000 ; i ++ ) sum += toEnglish ( i ) . length ( ) ; return Integer . toString ( sum ) ; } private static String toEnglish ( int n ) { if ( 0 <= n && n < 20 ) return ONES [ n ] ; else if ( 20 <= n && n < 100 ) return TENS [ n / 10 ] + ( n % 10 != 0 ? ONES [ n % 10 ] : " " ) ; else if ( 100 <= n && n < 1000 ) return ONES [ n / 100 ] + " hundred " + ( n % 100 != 0 ? " and " + toEnglish ( n % 100 ) : " " ) ; else if ( 1000 <= n && n < 1000000 ) return toEnglish ( n / 1000 ) + " thousand " + ( n % 1000 != 0 ? toEnglish ( n % 1000 ) : " " ) ; else throw new IllegalArgumentException ( ) ; } private static String [ ] ONES = { " zero " , " one " , " two " , " three " , " four " , " five " , " six " , " seven " , " eight " , " nine " , " ten " , " eleven " , " twelve " , " thirteen " , " fourteen " , " fifteen " , " sixteen " , " seventeen " , " eighteen " , " nineteen " } ; private static String [ ] TENS = { " " , " " , " twenty " , " thirty " , " forty " , " fifty " , " sixty " , " seventy " , " eighty " , " ninety " } ; }

def compute ( ) : NEW_LINE INDENT ans = sum ( len ( to_english ( i ) ) for i in range ( 1 , 1001 ) ) NEW_LINE return str ( ans ) NEW_LINE DEDENT def to_english ( n ) : NEW_LINE INDENT if 0 <= n < 20 : NEW_LINE INDENT return ONES [ n ] NEW_LINE DEDENT elif 20 <= n < 100 : NEW_LINE INDENT return TENS [ n // 10 ] + ( ONES [ n % 10 ] if ( n % 10 != 0 ) else " " ) NEW_LINE DEDENT elif 100 <= n < 1000 : NEW_LINE INDENT return ONES [ n // 100 ] + " hundred " + ( ( " and " + to_english ( n % 100 ) ) if ( n % 100 != 0 ) else " " ) NEW_LINE DEDENT elif 1000 <= n < 1000000 : NEW_LINE INDENT return to_english ( n // 1000 ) + " thousand " + ( to_english ( n % 1000 ) if ( n % 1000 != 0 ) else " " ) NEW_LINE DEDENT else : NEW_LINE INDENT raise ValueError ( ) NEW_LINE DEDENT DEDENT ONES = [ " zero " , " one " , " two " , " three " , " four " , " five " , " six " , " seven " , " eight " , " nine " , " ten " , " eleven " , " twelve " , " thirteen " , " fourteen " , " fifteen " , " sixteen " , " seventeen " , " eighteen " , " nineteen " ] NEW_LINE TENS = [ " " , " " , " twenty " , " thirty " , " forty " , " fifty " , " sixty " , " seventy " , " eighty " , " ninety " ] NEW_LINE if __name__ == " _ _ main _ _ " : NEW_LINE INDENT print ( compute ( ) ) NEW_LINE DEDENT


public final class p046 implements EulerSolution { public static void main ( String [ ] args ) { System . out . println ( new p046 ( ) . run ( ) ) ; } public String run ( ) { for ( int i = 9 ; ; i += 2 ) { if ( ! satisfiesConjecture ( i ) ) return Integer . toString ( i ) ; } } private static boolean satisfiesConjecture ( int n ) { if ( n % 2 == 0 || Library . isPrime ( n ) ) return true ; for ( int i = 1 ; i * i * 2 <= n ; i ++ ) { if ( Library . isPrime ( n - i * i * 2 ) ) return true ; } return false ; } }

import eulerlib , itertools NEW_LINE def compute ( ) : NEW_LINE INDENT ans = next ( itertools . filterfalse ( test_goldbach , itertools . count ( 9 , 2 ) ) ) NEW_LINE return str ( ans ) NEW_LINE DEDENT def test_goldbach ( n ) : NEW_LINE INDENT if n % 2 == 0 or eulerlib . is_prime ( n ) : NEW_LINE INDENT return True NEW_LINE DEDENT for i in itertools . count ( 1 ) : NEW_LINE INDENT k = n - 2 * i * i NEW_LINE if k <= 0 : NEW_LINE INDENT return False NEW_LINE DEDENT elif eulerlib . is_prime ( k ) : NEW_LINE INDENT return True NEW_LINE DEDENT DEDENT DEDENT if __name__ == " _ _ main _ _ " : NEW_LINE INDENT print ( compute ( ) ) NEW_LINE DEDENT


import java . util . Arrays ; public final class p038 implements EulerSolution { public static void main ( String [ ] args ) { System . out . println ( new p038 ( ) . run ( ) ) ; } public String run ( ) { int max = - 1 ; for ( int n = 2 ; n <= 9 ; n ++ ) { for ( int i = 1 ; i < Library . pow ( 10 , 9 / n ) ; i ++ ) { String concat = " " ; for ( int j = 1 ; j <= n ; j ++ ) concat += i * j ; if ( isPandigital ( concat ) ) max = Math . max ( Integer . parseInt ( concat ) , max ) ; } } return Integer . toString ( max ) ; } private static boolean isPandigital ( String s ) { if ( s . length ( ) != 9 ) return false ; char [ ] temp = s . toCharArray ( ) ; Arrays . sort ( temp ) ; return new String ( temp ) . equals ( "123456789" ) ; } }

def compute ( ) : NEW_LINE INDENT ans = " " NEW_LINE for n in range ( 2 , 10 ) : NEW_LINE INDENT for i in range ( 1 , 10 ** ( 9 // n ) ) : NEW_LINE INDENT s = " " . join ( str ( i * j ) for j in range ( 1 , n + 1 ) ) NEW_LINE if " " . join ( sorted ( s ) ) == "123456789" : NEW_LINE INDENT ans = max ( s , ans ) NEW_LINE DEDENT DEDENT DEDENT return ans NEW_LINE DEDENT if __name__ == " _ _ main _ _ " : NEW_LINE INDENT print ( compute ( ) ) NEW_LINE DEDENT


public final class p130 implements EulerSolution { public static void main ( String [ ] args ) { System . out . println ( new p130 ( ) . run ( ) ) ; } public String run ( ) { int sum = 0 ; int found = 0 ; for ( int i = 7 ; found < 25 ; i += 2 ) { if ( i % 5 != 0 && ! Library . isPrime ( i ) && ( i - 1 ) % findLeastDivisibleRepunit ( i ) == 0 ) { sum += i ; found ++ ; } } return Integer . toString ( sum ) ; } private static int findLeastDivisibleRepunit ( int n ) { if ( n % 2 == 0 || n % 5 == 0 ) return 0 ; if ( n > Integer . MAX_VALUE / 10 ) throw new IllegalArgumentException ( " Arithmetic ▁ overflow " ) ; int sum = 1 ; int pow = 1 ; int k = 1 ; while ( sum % n != 0 ) { k ++ ; pow = pow * 10 % n ; sum = ( sum + pow ) % n ; } return k ; } }

import eulerlib , itertools NEW_LINE def compute ( ) : NEW_LINE INDENT cond = lambda i : ( i % 5 != 0 ) and ( not eulerlib . is_prime ( i ) ) and ( ( i - 1 ) % find_least_divisible_repunit ( i ) == 0 ) NEW_LINE ans = sum ( itertools . islice ( filter ( cond , itertools . count ( 7 , 2 ) ) , 25 ) ) NEW_LINE return str ( ans ) NEW_LINE DEDENT def find_least_divisible_repunit ( n ) : NEW_LINE INDENT if n % 2 == 0 or n % 5 == 0 : NEW_LINE INDENT return 0 NEW_LINE DEDENT sum = 1 NEW_LINE pow = 1 NEW_LINE k = 1 NEW_LINE while sum % n != 0 : NEW_LINE INDENT k += 1 NEW_LINE pow = pow * 10 % n NEW_LINE sum = ( sum + pow ) % n NEW_LINE DEDENT return k NEW_LINE DEDENT if __name__ == " _ _ main _ _ " : NEW_LINE INDENT print ( compute ( ) ) NEW_LINE DEDENT


import java . math . BigInteger ; public final class p287 implements EulerSolution { public static void main ( String [ ] args ) { System . out . println ( new p287 ( ) . run ( ) ) ; } private static final int N = 24 ; private static final long RADIUS_SQUARED = 1L << ( 2 * N - 2 ) ; public String run ( ) { int temp = 1 << ( N - 1 ) ; return compressedLength ( N , - temp , temp , - temp , temp ) . toString ( ) ; } private BigInteger compressedLength ( int n , int xStart , int xEnd , int yStart , int yEnd ) { assert n >= 0 ; assert xStart < xEnd && xEnd - xStart == 1 << n ; assert yStart < yEnd && yEnd - yStart == 1 << n ; int minAbsX = xStart <= 0 && 0 < xEnd ? 0 : Math . min ( Math . abs ( xStart ) , Math . abs ( xEnd - 1 ) ) ; int minAbsY = yStart <= 0 && 0 < yEnd ? 0 : Math . min ( Math . abs ( yStart ) , Math . abs ( yEnd - 1 ) ) ; int maxAbsX = Math . max ( Math . abs ( xStart ) , Math . abs ( xEnd - 1 ) ) ; int maxAbsY = Math . max ( Math . abs ( yStart ) , Math . abs ( yEnd - 1 ) ) ; long minRadius = ( long ) minAbsX * minAbsX + ( long ) minAbsY * minAbsY ; long maxRadius = ( long ) maxAbsX * maxAbsX + ( long ) maxAbsY * maxAbsY ; if ( maxRadius <= RADIUS_SQUARED || minRadius > RADIUS_SQUARED ) return BigInteger . valueOf ( 2 ) ; else { int xMid = ( xStart + xEnd ) / 2 ; int yMid = ( yStart + yEnd ) / 2 ; return BigInteger . ONE . add ( compressedLength ( n - 1 , xStart , xMid , yMid , yEnd ) ) . add ( compressedLength ( n - 1 , xMid , xEnd , yMid , yEnd ) ) . add ( compressedLength ( n - 1 , xStart , xMid , yStart , yMid ) ) . add ( compressedLength ( n - 1 , xMid , xEnd , yStart , yMid ) ) ; } } }

def compute ( ) : NEW_LINE INDENT N = 24 NEW_LINE RADIUS_SQUARED = 2 ** ( 2 * N - 2 ) NEW_LINE def compressed_length ( xstart , xend , ystart , yend ) : NEW_LINE INDENT if xstart * xstart + ystart * ystart > RADIUS_SQUARED : NEW_LINE INDENT return 2 NEW_LINE DEDENT elif ( xend - 1 ) * ( xend - 1 ) + ( yend - 1 ) * ( yend - 1 ) <= RADIUS_SQUARED : NEW_LINE INDENT return 2 NEW_LINE DEDENT else : NEW_LINE INDENT xmid = ( xstart + xend ) >> 1 NEW_LINE ymid = ( ystart + yend ) >> 1 NEW_LINE return ( 1 + compressed_length ( xstart , xmid , ymid , yend ) + compressed_length ( xmid , xend , ymid , yend ) + compressed_length ( xstart , xmid , ystart , ymid ) + compressed_length ( xmid , xend , ystart , ymid ) ) NEW_LINE DEDENT DEDENT temp = 2 ** ( N - 1 ) NEW_LINE return str ( 1 + compressed_length ( 0 , temp , 0 , temp ) + compressed_length ( 0 , temp , 1 , temp + 1 ) + compressed_length ( 1 , temp + 1 , 0 , temp ) + compressed_length ( 1 , temp + 1 , 1 , temp + 1 ) ) NEW_LINE DEDENT if __name__ == " _ _ main _ _ " : NEW_LINE INDENT print ( compute ( ) ) NEW_LINE DEDENT


public final class p112 implements EulerSolution { public static void main ( String [ ] args ) { System . out . println ( new p112 ( ) . run ( ) ) ; } public String run ( ) { int bouncy = 0 ; for ( int i = 1 ; ; i ++ ) { if ( isBouncy ( i ) ) bouncy ++ ; if ( bouncy * 100 == i * 99 ) return Integer . toString ( i ) ; } } private static boolean isBouncy ( int x ) { if ( x < 100 ) return false ; else { boolean nonincreasing = true ; boolean nondecreasing = true ; int lastDigit = x % 10 ; x /= 10 ; while ( x != 0 ) { int digit = x % 10 ; if ( digit > lastDigit ) nondecreasing = false ; else if ( digit < lastDigit ) nonincreasing = false ; lastDigit = digit ; x /= 10 ; } return ! nonincreasing && ! nondecreasing ; } } }

import itertools NEW_LINE def compute ( ) : NEW_LINE INDENT count = 0 NEW_LINE for i in itertools . count ( 1 ) : NEW_LINE INDENT s = str ( i ) NEW_LINE t = " " . join ( sorted ( s ) ) NEW_LINE if s != t and s [ : : - 1 ] != t : NEW_LINE INDENT count += 1 NEW_LINE DEDENT if count * 100 == 99 * i : NEW_LINE INDENT return str ( i ) NEW_LINE DEDENT DEDENT DEDENT if __name__ == " _ _ main _ _ " : NEW_LINE INDENT print ( compute ( ) ) NEW_LINE DEDENT


public final class p315 implements EulerSolution { public static void main ( String [ ] args ) { System . out . println ( new p315 ( ) . run ( ) ) ; } public String run ( ) { boolean [ ] isPrime = Library . listPrimality ( 20000000 ) ; int sum = 0 ; for ( int i = 10000000 ; i < isPrime . length ; i ++ ) { if ( isPrime [ i ] ) sum += samTransitionsMinusMaxTransitions ( i ) ; } return Integer . toString ( sum ) ; } private static int samTransitionsMinusMaxTransitions ( int n ) { int samTrans = 0 ; int maxTrans = 0 ; long segmentState = 0 ; while ( true ) { long newState = numberToSegments ( n ) ; if ( newState == segmentState ) break ; maxTrans += Long . bitCount ( newState ^ segmentState ) ; segmentState = newState ; samTrans += 2 * Long . bitCount ( newState ) ; n = digitSum ( n ) ; } maxTrans += Long . bitCount ( segmentState ) ; return samTrans - maxTrans ; } private static long numberToSegments ( int n ) { if ( n < 0 || n > 999999999 ) throw new IllegalArgumentException ( ) ; long result = 0 ; int i = 0 ; do { result |= ( long ) DECIMAL_DIGIT_TO_SEGMENT [ n % 10 ] << ( i * 7 ) ; n /= 10 ; i ++ ; } while ( n != 0 ) ; return result ; } private static int digitSum ( int n ) { if ( n < 0 ) throw new IllegalArgumentException ( ) ; int result = 0 ; while ( n != 0 ) { result += n % 10 ; n /= 10 ; } return result ; } private static final int [ ] DECIMAL_DIGIT_TO_SEGMENT = { 0x77 , 0x12 , 0x5D , 0x5B , 0x3A , 0x6B , 0x6F , 0x72 , 0x7F , 0x7B } ; }

import eulerlib NEW_LINE def compute ( ) : NEW_LINE INDENT isprime = eulerlib . list_primality ( 20000000 ) NEW_LINE ans = sum ( sam_transitions_minus_max_transitions ( i ) for ( i , p ) in enumerate ( isprime ) if i >= 10000000 and p ) NEW_LINE return str ( ans ) NEW_LINE DEDENT def sam_transitions_minus_max_transitions ( n ) : NEW_LINE INDENT samtrans = 0 NEW_LINE maxtrans = 0 NEW_LINE segmentstate = 0 NEW_LINE while True : NEW_LINE INDENT newstate = number_to_segments ( n ) NEW_LINE if newstate == segmentstate : NEW_LINE INDENT break NEW_LINE DEDENT maxtrans += eulerlib . popcount ( newstate ^ segmentstate ) NEW_LINE segmentstate = newstate NEW_LINE samtrans += 2 * eulerlib . popcount ( newstate ) NEW_LINE n = digit_sum ( n ) NEW_LINE DEDENT maxtrans += eulerlib . popcount ( segmentstate ) NEW_LINE return samtrans - maxtrans NEW_LINE DEDENT def number_to_segments ( n ) : NEW_LINE INDENT if n < 0 : NEW_LINE INDENT raise ValueError ( ) NEW_LINE DEDENT result = 0 NEW_LINE i = 0 NEW_LINE while True : NEW_LINE INDENT result |= DECIMAL_DIGIT_TO_SEGMENT [ n % 10 ] << ( i * 7 ) NEW_LINE n //= 10 NEW_LINE i += 1 NEW_LINE if n == 0 : NEW_LINE INDENT return result NEW_LINE DEDENT DEDENT DEDENT def digit_sum ( n ) : NEW_LINE INDENT if n < 0 : NEW_LINE INDENT raise ValueError ( ) NEW_LINE DEDENT result = 0 NEW_LINE while n != 0 : NEW_LINE INDENT result += n % 10 NEW_LINE n //= 10 NEW_LINE DEDENT return result NEW_LINE DEDENT DECIMAL_DIGIT_TO_SEGMENT = [ 0b1110111 , 0b0010010 , 0b1011101 , 0b1011011 , 0b0111010 , 0b1101011 , 0b1101111 , 0b1110010 , 0b1111111 , 0b1111011 ] NEW_LINE if __name__ == " _ _ main _ _ " : NEW_LINE INDENT print ( compute ( ) ) NEW_LINE DEDENT


import java . math . BigInteger ; import java . util . ArrayList ; import java . util . HashSet ; import java . util . List ; import java . util . Set ; public final class p271 implements EulerSolution { public static void main ( String [ ] args ) { System . out . println ( new p271 ( ) . run ( ) ) ; } private static final int [ ] FACTORS = { 2 , 3 , 5 , 7 , 11 , 13 , 17 , 19 , 23 , 29 , 31 , 37 , 41 , 43 } ; private List < Set < Integer > > factorSolutions = new ArrayList < > ( ) ; public String run ( ) { for ( int fact : FACTORS ) { Set < Integer > sols = new HashSet < > ( ) ; for ( int j = 1 ; j < fact ; j ++ ) { if ( Library . powMod ( j , 3 , fact ) == 1 ) sols . add ( j ) ; } factorSolutions . add ( sols ) ; } BigInteger sum = buildAndSumSolutions ( 0 , BigInteger . ZERO , BigInteger . ONE ) ; return sum . subtract ( BigInteger . ONE ) . toString ( ) ; } private BigInteger buildAndSumSolutions ( int factorIndex , BigInteger x , BigInteger m ) { if ( factorIndex == FACTORS . length ) return x ; else { BigInteger result = BigInteger . ZERO ; BigInteger fact = BigInteger . valueOf ( FACTORS [ factorIndex ] ) ; for ( int sol : factorSolutions . get ( factorIndex ) ) { BigInteger newx = chineseRemainderTheorem ( x , m , BigInteger . valueOf ( sol ) , fact ) ; BigInteger temp = buildAndSumSolutions ( factorIndex + 1 , newx , m . multiply ( fact ) ) ; result = result . add ( temp ) ; } return result ; } } private static BigInteger chineseRemainderTheorem ( BigInteger a , BigInteger p , BigInteger b , BigInteger q ) { return a . add ( b . subtract ( a ) . multiply ( p . modInverse ( q ) ) . multiply ( p ) ) . mod ( p . multiply ( q ) ) ; } }

import eulerlib NEW_LINE def compute ( ) : NEW_LINE INDENT FACTORS = ( 2 , 3 , 5 , 7 , 11 , 13 , 17 , 19 , 23 , 29 , 31 , 37 , 41 , 43 ) NEW_LINE factorsols = [ [ j for j in range ( fact ) if pow ( j , 3 , fact ) == 1 ] for fact in FACTORS ] NEW_LINE def build_and_sum_solutions ( i , x , mod ) : NEW_LINE INDENT if i == len ( FACTORS ) : NEW_LINE INDENT return x NEW_LINE DEDENT else : NEW_LINE INDENT fact = FACTORS [ i ] NEW_LINE return sum ( build_and_sum_solutions ( i + 1 , chinese_remainder_theorem ( x , mod , sol , fact ) , mod * fact ) for sol in factorsols [ i ] ) NEW_LINE DEDENT DEDENT ans = build_and_sum_solutions ( 0 , 0 , 1 ) - 1 NEW_LINE return str ( ans ) NEW_LINE DEDENT def chinese_remainder_theorem ( a , p , b , q ) : NEW_LINE INDENT return ( a + ( b - a ) * eulerlib . reciprocal_mod ( p % q , q ) * p ) % ( p * q ) NEW_LINE DEDENT if __name__ == " _ _ main _ _ " : NEW_LINE INDENT print ( compute ( ) ) NEW_LINE DEDENT


public final class p231 implements EulerSolution { public static void main ( String [ ] args ) { System . out . println ( new p231 ( ) . run ( ) ) ; } private static final int N = 20000000 ; private static final int K = 15000000 ; public String run ( ) { smallestPrimeFactor = Library . listSmallestPrimeFactors ( N ) ; return Long . toString ( factorialPrimeFactorSum ( N ) - factorialPrimeFactorSum ( K ) - factorialPrimeFactorSum ( N - K ) ) ; } private int [ ] smallestPrimeFactor ; private long factorialPrimeFactorSum ( int n ) { long sum = 0 ; for ( int i = 1 ; i <= n ; i ++ ) { int j = i ; while ( j > 1 ) { int p = smallestPrimeFactor [ j ] ; sum += p ; j /= p ; } } return sum ; } }

import eulerlib NEW_LINE def compute ( ) : NEW_LINE INDENT N = 20000000 NEW_LINE K = 15000000 NEW_LINE smallestprimefactor = eulerlib . list_smallest_prime_factors ( N ) NEW_LINE def factorial_prime_factor_sum ( n ) : NEW_LINE INDENT result = 0 NEW_LINE for i in range ( n + 1 ) : NEW_LINE INDENT j = i NEW_LINE while j > 1 : NEW_LINE INDENT p = smallestprimefactor [ j ] NEW_LINE result += p NEW_LINE j //= p NEW_LINE DEDENT DEDENT return result NEW_LINE DEDENT ans = factorial_prime_factor_sum ( N ) - factorial_prime_factor_sum ( K ) - factorial_prime_factor_sum ( N - K ) NEW_LINE return str ( ans ) NEW_LINE DEDENT if __name__ == " _ _ main _ _ " : NEW_LINE INDENT print ( compute ( ) ) NEW_LINE DEDENT


import java . util . Arrays ; public final class p225 implements EulerSolution { public static void main ( String [ ] args ) { System . out . println ( new p225 ( ) . run ( ) ) ; } private static final int INDEX = 124 ; public String run ( ) { int count = 0 ; for ( int i = 1 ; ; i += 2 ) { if ( ! hasTribonacciMultiple ( i ) ) { count ++ ; if ( count == INDEX ) return Integer . toString ( i ) ; } } } private static boolean hasTribonacciMultiple ( int modulus ) { int [ ] slow = { 1 , 1 , 1 } ; int [ ] fast = slow . clone ( ) ; for ( boolean head = true ; ; head = false ) { if ( slow [ 0 ] % modulus == 0 ) return true ; if ( ! head && Arrays . equals ( slow , fast ) ) return false ; tribonacci ( slow , modulus ) ; tribonacci ( fast , modulus ) ; tribonacci ( fast , modulus ) ; } } private static void tribonacci ( int [ ] state , int mod ) { int a = state [ 0 ] ; int b = state [ 1 ] ; int c = state [ 2 ] ; state [ 0 ] = b ; state [ 1 ] = c ; state [ 2 ] = ( a + b + c ) % mod ; } }

import itertools NEW_LINE def compute ( ) : NEW_LINE INDENT INDEX = 124 NEW_LINE stream = ( i for i in itertools . count ( 1 , 2 ) if not has_tribonacci_multiple ( i ) ) NEW_LINE ans = next ( itertools . islice ( stream , INDEX - 1 , None ) ) NEW_LINE return str ( ans ) NEW_LINE DEDENT def has_tribonacci_multiple ( i ) : NEW_LINE INDENT seen = set ( ) NEW_LINE a , b , c = 1 , 1 , 1 NEW_LINE while True : NEW_LINE INDENT key = ( a , b , c ) NEW_LINE if key in seen : NEW_LINE INDENT return False NEW_LINE DEDENT seen . add ( key ) NEW_LINE if a % i == 0 : NEW_LINE INDENT return True NEW_LINE DEDENT a , b , c = b , c , ( a + b + c ) % i NEW_LINE DEDENT DEDENT if __name__ == " _ _ main _ _ " : NEW_LINE INDENT print ( compute ( ) ) NEW_LINE DEDENT


import java . util . ArrayList ; import java . util . Arrays ; import java . util . Collections ; import java . util . HashMap ; import java . util . List ; import java . util . Map ; public final class p151 implements EulerSolution { public static void main ( String [ ] args ) { System . out . println ( new p151 ( ) . run ( ) ) ; } public String run ( ) { List < Integer > startState = Arrays . asList ( 1 ) ; return String . format ( " % .6f " , getExpectedSingles ( startState ) - 2 ) ; } private Map < List < Integer > , Double > expectedSingles = new HashMap < > ( ) ; private double getExpectedSingles ( List < Integer > state ) { if ( expectedSingles . containsKey ( state ) ) return expectedSingles . get ( state ) ; double result = 0 ; if ( ! state . isEmpty ( ) ) { for ( int i = 0 ; i < state . size ( ) ; i ++ ) { List < Integer > newState = new ArrayList < > ( state ) ; int sheet = state . get ( i ) ; newState . remove ( i ) ; for ( int j = sheet + 1 ; j <= 5 ; j ++ ) newState . add ( j ) ; Collections . sort ( newState ) ; result += getExpectedSingles ( newState ) ; } result /= state . size ( ) ; if ( state . size ( ) == 1 ) result ++ ; } expectedSingles . put ( state , result ) ; return result ; } }

import eulerlib NEW_LINE def compute ( ) : NEW_LINE INDENT ans = get_expected_singles ( ( 1 , ) ) - 2 NEW_LINE return f " { ans : .6f } " NEW_LINE DEDENT @ eulerlib . memoize NEW_LINE def get_expected_singles ( state ) : NEW_LINE INDENT result = 0.0 NEW_LINE if len ( state ) > 0 : NEW_LINE INDENT for i in range ( len ( state ) ) : NEW_LINE INDENT tempstate = list ( state ) NEW_LINE sheet = state [ i ] NEW_LINE del tempstate [ i ] NEW_LINE for j in range ( sheet + 1 , 6 ) : NEW_LINE INDENT tempstate . append ( j ) NEW_LINE DEDENT tempstate . sort ( ) NEW_LINE result += get_expected_singles ( tuple ( tempstate ) ) NEW_LINE DEDENT result /= len ( state ) NEW_LINE if len ( state ) == 1 : NEW_LINE INDENT result += 1.0 NEW_LINE DEDENT DEDENT return result NEW_LINE DEDENT if __name__ == " _ _ main _ _ " : NEW_LINE INDENT print ( compute ( ) ) NEW_LINE DEDENT


import java . util . Arrays ; public final class p187 implements EulerSolution { public static void main ( String [ ] args ) { System . out . println ( new p187 ( ) . run ( ) ) ; } private static final int LIMIT = Library . pow ( 10 , 8 ) - 1 ; public String run ( ) { int count = 0 ; int [ ] primes = Library . listPrimes ( LIMIT / 2 ) ; for ( int i = 0 , sqrt = Library . sqrt ( LIMIT ) ; i < primes . length && primes [ i ] <= sqrt ; i ++ ) { int end = Arrays . binarySearch ( primes , LIMIT / primes [ i ] ) ; if ( end >= 0 ) end ++ ; else end = - end - 1 ; count += end - i ; } return Integer . toString ( count ) ; } }

import eulerlib NEW_LINE def compute ( ) : NEW_LINE INDENT LIMIT = 10 ** 8 - 1 NEW_LINE ans = 0 NEW_LINE primes = eulerlib . list_primes ( LIMIT // 2 ) NEW_LINE sqrt = eulerlib . sqrt ( LIMIT ) NEW_LINE for ( i , p ) in enumerate ( primes ) : NEW_LINE INDENT if p > sqrt : NEW_LINE INDENT break NEW_LINE DEDENT end = binary_search ( primes , LIMIT // p ) NEW_LINE ans += ( end + 1 if end >= 0 else - end - 1 ) - i NEW_LINE DEDENT return str ( ans ) NEW_LINE DEDENT def binary_search ( lst , x ) : NEW_LINE INDENT start = 0 NEW_LINE end = len ( lst ) NEW_LINE while start < end : NEW_LINE INDENT mid = ( start + end ) // 2 NEW_LINE if x < lst [ mid ] : NEW_LINE INDENT end = mid NEW_LINE DEDENT elif x > lst [ mid ] : NEW_LINE INDENT start = mid + 1 NEW_LINE DEDENT elif x == lst [ mid ] : NEW_LINE INDENT return mid NEW_LINE DEDENT else : NEW_LINE INDENT raise AssertionError ( ) NEW_LINE DEDENT DEDENT return - start - 1 NEW_LINE DEDENT if __name__ == " _ _ main _ _ " : NEW_LINE INDENT print ( compute ( ) ) NEW_LINE DEDENT


import java . math . BigInteger ; public final class p133 implements EulerSolution { public static void main ( String [ ] args ) { System . out . println ( new p133 ( ) . run ( ) ) ; } public String run ( ) { long sum = 0 ; for ( int p : Library . listPrimes ( 100000 ) ) { if ( p == 2 || p == 5 || ! hasDivisibleRepunit ( p ) ) sum += p ; } return Long . toString ( sum ) ; } private static final BigInteger EXPONENT = BigInteger . TEN . pow ( 16 ) ; private static boolean hasDivisibleRepunit ( int p ) { return ( BigInteger . TEN . modPow ( EXPONENT , BigInteger . valueOf ( p * 9 ) ) . intValue ( ) - 1 ) / 9 % p == 0 ; } }

import eulerlib NEW_LINE def compute ( ) : NEW_LINE INDENT primes = eulerlib . list_primes ( 100000 ) NEW_LINE ans = sum ( p for p in primes if p == 2 or p == 5 or not has_divisible_repunit ( p ) ) NEW_LINE return str ( ans ) NEW_LINE DEDENT def has_divisible_repunit ( p ) : NEW_LINE INDENT return ( pow ( 10 , 10 ** 16 , p * 9 ) - 1 ) // 9 % p == 0 NEW_LINE DEDENT if __name__ == " _ _ main _ _ " : NEW_LINE INDENT print ( compute ( ) ) NEW_LINE DEDENT


import java . util . PriorityQueue ; import java . util . Queue ; public final class p500 implements EulerSolution { public static void main ( String [ ] args ) { System . out . println ( new p500 ( ) . run ( ) ) ; } private static final int TARGET = 500500 ; private static final long MODULUS = 500500507 ; public String run ( ) { Queue < Long > queue = new PriorityQueue < > ( ) ; int nextPrime = 2 ; queue . add ( ( long ) nextPrime ) ; long product = 1 ; for ( int i = 0 ; i < TARGET ; i ++ ) { long item = queue . remove ( ) ; product *= item % MODULUS ; product %= MODULUS ; queue . add ( item * item ) ; if ( item == nextPrime ) { do nextPrime ++ ; while ( ! Library . isPrime ( nextPrime ) ) ; queue . add ( ( long ) nextPrime ) ; } } return Long . toString ( product ) ; } }

import eulerlib , heapq NEW_LINE def compute ( ) : NEW_LINE INDENT TARGET = 500500 NEW_LINE MODULUS = 500500507 NEW_LINE isprime = eulerlib . list_primality ( 7376507 ) NEW_LINE queue = [ ] NEW_LINE nextprime = 2 NEW_LINE heapq . heappush ( queue , nextprime ) NEW_LINE ans = 1 NEW_LINE for _ in range ( TARGET ) : NEW_LINE INDENT item = heapq . heappop ( queue ) NEW_LINE ans *= item NEW_LINE ans %= MODULUS NEW_LINE heapq . heappush ( queue , item ** 2 ) NEW_LINE if item == nextprime : NEW_LINE INDENT nextprime += 1 NEW_LINE while not isprime [ nextprime ] : NEW_LINE INDENT nextprime += 1 NEW_LINE DEDENT heapq . heappush ( queue , nextprime ) NEW_LINE DEDENT DEDENT return str ( ans ) NEW_LINE DEDENT if __name__ == " _ _ main _ _ " : NEW_LINE INDENT print ( compute ( ) ) NEW_LINE DEDENT


public final class p429 implements EulerSolution { public static void main ( String [ ] args ) { System . out . println ( new p429 ( ) . run ( ) ) ; } private static final int LIMIT = Library . pow ( 10 , 8 ) ; private static final int MODULUS = 1000000009 ; public String run ( ) { int [ ] primes = Library . listPrimes ( LIMIT ) ; long sum = 1 ; for ( int p : primes ) { int power = countFactors ( LIMIT , p ) ; sum *= 1 + Library . powMod ( p , power * 2 , MODULUS ) ; sum %= MODULUS ; } return Long . toString ( sum ) ; } private static int countFactors ( int n , int p ) { if ( n == 0 ) return 0 ; else return n / p + countFactors ( n / p , p ) ; } }

import eulerlib NEW_LINE def compute ( ) : NEW_LINE INDENT LIMIT = 10 ** 8 NEW_LINE MOD = 1000000009 NEW_LINE ans = 1 NEW_LINE for p in eulerlib . prime_generator ( LIMIT ) : NEW_LINE INDENT power = count_factors ( LIMIT , p ) NEW_LINE ans *= 1 + pow ( p , power * 2 , MOD ) NEW_LINE ans %= MOD NEW_LINE DEDENT return str ( ans ) NEW_LINE DEDENT def count_factors ( n , p ) : NEW_LINE INDENT if n == 0 : NEW_LINE INDENT return 0 NEW_LINE DEDENT else : NEW_LINE INDENT return n // p + count_factors ( n // p , p ) NEW_LINE DEDENT DEDENT if __name__ == " _ _ main _ _ " : NEW_LINE INDENT print ( compute ( ) ) NEW_LINE DEDENT


public final class p007 implements EulerSolution { public static void main ( String [ ] args ) { System . out . println ( new p007 ( ) . run ( ) ) ; } public String run ( ) { for ( int i = 2 , count = 0 ; ; i ++ ) { if ( Library . isPrime ( i ) ) { count ++ ; if ( count == 10001 ) return Integer . toString ( i ) ; } } } }

import eulerlib , itertools NEW_LINE def compute ( ) : NEW_LINE INDENT ans = next ( itertools . islice ( filter ( eulerlib . is_prime , itertools . count ( 2 ) ) , 10000 , None ) ) NEW_LINE return str ( ans ) NEW_LINE DEDENT if __name__ == " _ _ main _ _ " : NEW_LINE INDENT print ( compute ( ) ) NEW_LINE DEDENT


import java . util . Arrays ; public final class p052 implements EulerSolution { public static void main ( String [ ] args ) { System . out . println ( new p052 ( ) . run ( ) ) ; } public String run ( ) { for ( int i = 1 ; ; i ++ ) { if ( i > Integer . MAX_VALUE / 6 ) throw new ArithmeticException ( " Overflow " ) ; if ( multiplesHaveSameDigits ( i ) ) return Integer . toString ( i ) ; } } private static boolean multiplesHaveSameDigits ( int x ) { for ( int i = 2 ; i <= 6 ; i ++ ) { if ( ! Arrays . equals ( toSortedDigits ( x ) , toSortedDigits ( i * x ) ) ) return false ; } return true ; } private static char [ ] toSortedDigits ( int x ) { char [ ] result = Integer . toString ( x ) . toCharArray ( ) ; Arrays . sort ( result ) ; return result ; } }

import itertools NEW_LINE def compute ( ) : NEW_LINE INDENT cond = lambda i : all ( sorted ( str ( i ) ) == sorted ( str ( j * i ) ) for j in range ( 2 , 7 ) ) NEW_LINE ans = next ( i for i in itertools . count ( 1 ) if cond ( i ) ) NEW_LINE return str ( ans ) NEW_LINE DEDENT if __name__ == " _ _ main _ _ " : NEW_LINE INDENT print ( compute ( ) ) NEW_LINE DEDENT


public final class p043 implements EulerSolution { public static void main ( String [ ] args ) { System . out . println ( new p043 ( ) . run ( ) ) ; } private static int [ ] DIVISIBILITY_TESTS = { 2 , 3 , 5 , 7 , 11 , 13 , 17 } ; public String run ( ) { long sum = 0 ; int [ ] digits = { 0 , 1 , 2 , 3 , 4 , 5 , 6 , 7 , 8 , 9 } ; outer : do { for ( int i = 0 ; i < DIVISIBILITY_TESTS . length ; i ++ ) { if ( toInteger ( digits , i + 1 , 3 ) % DIVISIBILITY_TESTS [ i ] != 0 ) continue outer ; } sum += toInteger ( digits , 0 , digits . length ) ; } while ( Library . nextPermutation ( digits ) ) ; return Long . toString ( sum ) ; } private static long toInteger ( int [ ] digits , int off , int len ) { long result = 0 ; for ( int i = off ; i < off + len ; i ++ ) result = result * 10 + digits [ i ] ; return result ; } }

import itertools NEW_LINE def compute ( ) : NEW_LINE INDENT ans = sum ( int ( " " . join ( map ( str , num ) ) ) for num in itertools . permutations ( list ( range ( 10 ) ) ) if is_substring_divisible ( num ) ) NEW_LINE return str ( ans ) NEW_LINE DEDENT DIVISIBILITY_TESTS = [ 2 , 3 , 5 , 7 , 11 , 13 , 17 ] NEW_LINE def is_substring_divisible ( num ) : NEW_LINE INDENT return all ( ( num [ i + 1 ] * 100 + num [ i + 2 ] * 10 + num [ i + 3 ] ) % p == 0 for ( i , p ) in enumerate ( DIVISIBILITY_TESTS ) ) NEW_LINE DEDENT if __name__ == " _ _ main _ _ " : NEW_LINE INDENT print ( compute ( ) ) NEW_LINE DEDENT


import java . util . HashSet ; import java . util . Set ; public final class p075 implements EulerSolution { public static void main ( String [ ] args ) { System . out . println ( new p075 ( ) . run ( ) ) ; } private static final int LIMIT = 1500000 ; public String run ( ) { Set < IntTriple > triples = new HashSet < > ( ) ; for ( int s = 3 ; s * s <= LIMIT ; s += 2 ) { for ( int t = s - 2 ; t > 0 ; t -= 2 ) { if ( Library . gcd ( s , t ) == 1 ) { int a = s * t ; int b = ( s * s - t * t ) / 2 ; int c = ( s * s + t * t ) / 2 ; if ( a + b + c <= LIMIT ) triples . add ( new IntTriple ( a , b , c ) ) ; } } } byte [ ] ways = new byte [ LIMIT + 1 ] ; for ( IntTriple triple : triples ) { int sum = triple . a + triple . b + triple . c ; for ( int i = sum ; i < ways . length ; i += sum ) ways [ i ] = ( byte ) Math . min ( ways [ i ] + 1 , 2 ) ; } int count = 0 ; for ( int x : ways ) { if ( x == 1 ) count ++ ; } return Integer . toString ( count ) ; } private static final class IntTriple { public final int a ; public final int b ; public final int c ; public IntTriple ( int a , int b , int c ) { this . a = a ; this . b = b ; this . c = c ; } public boolean equals ( Object obj ) { if ( ! ( obj instanceof IntTriple ) ) return false ; else { IntTriple other = ( IntTriple ) obj ; return a == other . a && b == other . b && c == other . c ; } } public int hashCode ( ) { return a + b + c ; } } }

import eulerlib , fractions NEW_LINE def compute ( ) : NEW_LINE INDENT LIMIT = 1500000 NEW_LINE triples = set ( ) NEW_LINE for s in range ( 3 , eulerlib . sqrt ( LIMIT ) + 1 , 2 ) : NEW_LINE INDENT for t in range ( s - 2 , 0 , - 2 ) : NEW_LINE INDENT if fractions . gcd ( s , t ) == 1 : NEW_LINE INDENT a = s * t NEW_LINE b = ( s * s - t * t ) // 2 NEW_LINE c = ( s * s + t * t ) // 2 NEW_LINE if a + b + c <= LIMIT : NEW_LINE INDENT triples . add ( ( a , b , c ) ) NEW_LINE DEDENT DEDENT DEDENT DEDENT ways = [ 0 ] * ( LIMIT + 1 ) NEW_LINE for triple in triples : NEW_LINE INDENT sigma = sum ( triple ) NEW_LINE for i in range ( sigma , len ( ways ) , sigma ) : NEW_LINE INDENT ways [ i ] += 1 NEW_LINE DEDENT DEDENT ans = ways . count ( 1 ) NEW_LINE return str ( ans ) NEW_LINE DEDENT if __name__ == " _ _ main _ _ " : NEW_LINE INDENT print ( compute ( ) ) NEW_LINE DEDENT


public final class p205 implements EulerSolution { public static void main ( String [ ] args ) { System . out . println ( new p205 ( ) . run ( ) ) ; } private static final int [ ] PYRAMIDAL_DIE_PDF = { 0 , 1 , 1 , 1 , 1 } ; private static final int [ ] CUBIC_DIE_PDF = { 0 , 1 , 1 , 1 , 1 , 1 , 1 } ; public String run ( ) { int [ ] ninePyramidalPdf = { 1 } ; for ( int i = 0 ; i < 9 ; i ++ ) ninePyramidalPdf = convolve ( ninePyramidalPdf , PYRAMIDAL_DIE_PDF ) ; int [ ] sixCubicPdf = { 1 } ; for ( int i = 0 ; i < 6 ; i ++ ) sixCubicPdf = convolve ( sixCubicPdf , CUBIC_DIE_PDF ) ; long numer = 0 ; for ( int i = 0 ; i < ninePyramidalPdf . length ; i ++ ) numer += ( long ) ninePyramidalPdf [ i ] * sum ( sixCubicPdf , 0 , i ) ; long denom = ( long ) sum ( ninePyramidalPdf , 0 , ninePyramidalPdf . length ) * sum ( sixCubicPdf , 0 , sixCubicPdf . length ) ; return String . format ( " % .7f " , ( double ) numer / denom ) ; } private static int [ ] convolve ( int [ ] a , int [ ] b ) { int [ ] c = new int [ a . length + b . length - 1 ] ; for ( int i = 0 ; i < a . length ; i ++ ) { for ( int j = 0 ; j < b . length ; j ++ ) c [ i + j ] += a [ i ] * b [ j ] ; } return c ; } private static int sum ( int [ ] array , int start , int end ) { int sum = 0 ; for ( int i = start ; i < end ; i ++ ) sum += array [ i ] ; return sum ; } }

def compute ( ) : NEW_LINE INDENT nine_pyramidal_pdf = [ 1 ] NEW_LINE PYRAMIDAL_DIE_PDF = [ 0 , 1 , 1 , 1 , 1 ] NEW_LINE for i in range ( 9 ) : NEW_LINE INDENT nine_pyramidal_pdf = convolve ( nine_pyramidal_pdf , PYRAMIDAL_DIE_PDF ) NEW_LINE DEDENT six_cubic_pdf = [ 1 ] NEW_LINE CUBIC_DIE_PDF = [ 0 , 1 , 1 , 1 , 1 , 1 , 1 ] NEW_LINE for i in range ( 6 ) : NEW_LINE INDENT six_cubic_pdf = convolve ( six_cubic_pdf , CUBIC_DIE_PDF ) NEW_LINE DEDENT ans = 0 NEW_LINE for i in range ( len ( nine_pyramidal_pdf ) ) : NEW_LINE INDENT ans += nine_pyramidal_pdf [ i ] * sum ( six_cubic_pdf [ : i ] ) NEW_LINE DEDENT ans = float ( ans ) / ( sum ( nine_pyramidal_pdf ) * sum ( six_cubic_pdf ) ) NEW_LINE return f " { ans : .7f } " NEW_LINE DEDENT def convolve ( a , b ) : NEW_LINE INDENT c = [ 0 ] * ( len ( a ) + len ( b ) - 1 ) NEW_LINE for i in range ( len ( a ) ) : NEW_LINE INDENT for j in range ( len ( b ) ) : NEW_LINE INDENT c [ i + j ] += a [ i ] * b [ j ] NEW_LINE DEDENT DEDENT return c NEW_LINE DEDENT if __name__ == " _ _ main _ _ " : NEW_LINE INDENT print ( compute ( ) ) NEW_LINE DEDENT


public final class p348 implements EulerSolution { public static void main ( String [ ] args ) { System . out . println ( new p348 ( ) . run ( ) ) ; } private static final int TARGET_WAYS = 4 ; private static final int TARGET_COUNT = 5 ; static { assert 0 <= TARGET_COUNT ; assert 0 <= TARGET_WAYS && TARGET_WAYS <= Byte . MAX_VALUE - 1 ; } public String run ( ) { for ( long limit = 1 ; ; limit *= 10 ) { if ( limit > Integer . MAX_VALUE ) throw new AssertionError ( " Overflow " ) ; long answer = trySearch ( ( int ) limit ) ; if ( answer != - 1 ) return Long . toString ( answer ) ; } } private static long trySearch ( int limit ) { byte [ ] ways = new byte [ limit ] ; for ( int i = cbrt ( limit - 1 ) ; i > 1 ; i -- ) { int cube = i * i * i ; for ( int j = Library . sqrt ( limit - 1 - cube ) ; j > 1 ; j -- ) { int index = cube + j * j ; ways [ index ] = ( byte ) Math . min ( ways [ index ] + 1 , TARGET_WAYS + 1 ) ; } } long result = 0 ; int count = 0 ; for ( int i = 0 ; i < ways . length ; i ++ ) { if ( ways [ i ] == TARGET_WAYS && Library . isPalindrome ( i ) ) { result += i ; count ++ ; if ( count == TARGET_COUNT ) return result ; } } return - 1 ; } private static int cbrt ( int x ) { if ( x < 0 ) throw new IllegalArgumentException ( " Not ▁ implemented " ) ; int y = 0 ; for ( int i = 1 << 10 ; i != 0 ; i >>>= 1 ) { y |= i ; if ( y > 1290 || y * y * y > x ) y ^= i ; } return y ; } }

import eulerlib , itertools NEW_LINE TARGET_WAYS = 4 NEW_LINE TARGET_COUNT = 5 NEW_LINE def compute ( ) : NEW_LINE INDENT for i in itertools . count ( ) : NEW_LINE INDENT limit = 10 ** i NEW_LINE ans = try_search ( limit ) NEW_LINE if ans is not None : NEW_LINE INDENT return str ( ans ) NEW_LINE DEDENT DEDENT DEDENT def try_search ( limit ) : NEW_LINE INDENT ways = { } NEW_LINE for i in itertools . count ( 2 ) : NEW_LINE INDENT cube = i ** 3 NEW_LINE if cube >= limit : NEW_LINE INDENT break NEW_LINE DEDENT for j in range ( 2 , eulerlib . sqrt ( limit - 1 - cube ) + 1 ) : NEW_LINE INDENT index = cube + j ** 2 NEW_LINE ways [ index ] = ways . get ( index , 0 ) + 1 NEW_LINE DEDENT DEDENT result = 0 NEW_LINE count = 0 NEW_LINE for i in sorted ( ways . keys ( ) ) : NEW_LINE INDENT if ways [ i ] == TARGET_WAYS and is_palindrome ( i ) : NEW_LINE INDENT result += i NEW_LINE count += 1 NEW_LINE if count == TARGET_COUNT : NEW_LINE INDENT return result NEW_LINE DEDENT DEDENT DEDENT return None NEW_LINE DEDENT def is_palindrome ( x ) : NEW_LINE INDENT s = str ( x ) NEW_LINE return s == s [ : : - 1 ] NEW_LINE DEDENT if __name__ == " _ _ main _ _ " : NEW_LINE INDENT print ( compute ( ) ) NEW_LINE DEDENT


public final class p078 implements EulerSolution { public static void main ( String [ ] args ) { System . out . println ( new p078 ( ) . run ( ) ) ; } private static final int MODULUS = Library . pow ( 10 , 6 ) ; public String run ( ) { for ( int limit = 1 ; ; limit *= 2 ) { int result = search ( limit ) ; if ( result != - 1 ) return Integer . toString ( result ) ; } } private static int search ( int limit ) { int [ ] partitions = new int [ limit ] ; partitions [ 0 ] = 1 ; for ( int i = 1 ; i < limit ; i ++ ) { for ( int j = i ; j < limit ; j ++ ) partitions [ j ] = ( partitions [ j ] + partitions [ j - i ] ) % MODULUS ; } for ( int i = 0 ; i < limit ; i ++ ) { if ( partitions [ i ] == 0 ) return i ; } return - 1 ; } }

import itertools NEW_LINE MODULUS = 10 ** 6 NEW_LINE def compute ( ) : NEW_LINE INDENT partitions = [ 1 ] NEW_LINE for i in itertools . count ( len ( partitions ) ) : NEW_LINE INDENT item = 0 NEW_LINE for j in itertools . count ( 1 ) : NEW_LINE INDENT sign = - 1 if j % 2 == 0 else + 1 NEW_LINE index = ( j * j * 3 - j ) // 2 NEW_LINE if index > i : NEW_LINE INDENT break NEW_LINE DEDENT item += partitions [ i - index ] * sign NEW_LINE index += j NEW_LINE if index > i : NEW_LINE INDENT break NEW_LINE DEDENT item += partitions [ i - index ] * sign NEW_LINE item %= MODULUS NEW_LINE DEDENT if item == 0 : NEW_LINE INDENT return str ( i ) NEW_LINE DEDENT partitions . append ( item ) NEW_LINE DEDENT DEDENT if __name__ == " _ _ main _ _ " : NEW_LINE INDENT print ( compute ( ) ) NEW_LINE DEDENT


public final class p173 implements EulerSolution { public static void main ( String [ ] args ) { System . out . println ( new p173 ( ) . run ( ) ) ; } private static final int TILES = 1000000 ; public String run ( ) { int count = 0 ; for ( int n = 3 ; n <= TILES / 4 + 1 ; n ++ ) { for ( int k = n - 2 ; k >= 1 ; k -= 2 ) { if ( ( long ) n * n - ( long ) k * k > TILES ) break ; count ++ ; } } return Integer . toString ( count ) ; } }

def compute ( ) : NEW_LINE INDENT TILES = 10 ** 6 NEW_LINE ans = 0 NEW_LINE for n in range ( 3 , TILES // 4 + 2 ) : NEW_LINE INDENT for k in range ( n - 2 , 0 , - 2 ) : NEW_LINE INDENT if n * n - k * k > TILES : NEW_LINE INDENT break NEW_LINE DEDENT ans += 1 NEW_LINE DEDENT DEDENT return str ( ans ) NEW_LINE DEDENT if __name__ == " _ _ main _ _ " : NEW_LINE INDENT print ( compute ( ) ) NEW_LINE DEDENT


import java . util . HashMap ; import java . util . Map ; public final class p026 implements EulerSolution { public static void main ( String [ ] args ) { System . out . println ( new p026 ( ) . run ( ) ) ; } public String run ( ) { int bestNumber = 0 ; int bestLength = 0 ; for ( int i = 1 ; i <= 1000 ; i ++ ) { int len = getCycleLength ( i ) ; if ( len > bestLength ) { bestNumber = i ; bestLength = len ; } } return Integer . toString ( bestNumber ) ; } private static int getCycleLength ( int n ) { Map < Integer , Integer > stateToIter = new HashMap < > ( ) ; int state = 1 ; for ( int iter = 0 ; ; iter ++ ) { if ( stateToIter . containsKey ( state ) ) return iter - stateToIter . get ( state ) ; else { stateToIter . put ( state , iter ) ; state = state * 10 % n ; } } } }

import itertools NEW_LINE def compute ( ) : NEW_LINE INDENT ans = max ( range ( 1 , 1000 ) , key = reciprocal_cycle_len ) NEW_LINE return str ( ans ) NEW_LINE DEDENT def reciprocal_cycle_len ( n ) : NEW_LINE INDENT seen = { } NEW_LINE x = 1 NEW_LINE for i in itertools . count ( ) : NEW_LINE INDENT if x in seen : NEW_LINE INDENT return i - seen [ x ] NEW_LINE DEDENT else : NEW_LINE INDENT seen [ x ] = i NEW_LINE x = x * 10 % n NEW_LINE DEDENT DEDENT DEDENT if __name__ == " _ _ main _ _ " : NEW_LINE INDENT print ( compute ( ) ) NEW_LINE DEDENT


public final class p135 implements EulerSolution { public static void main ( String [ ] args ) { System . out . println ( new p135 ( ) . run ( ) ) ; } private static final int LIMIT = Library . pow ( 10 , 6 ) ; public String run ( ) { int [ ] solutions = new int [ LIMIT ] ; for ( int m = 1 ; m < LIMIT * 2 ; m ++ ) { for ( int k = m / 5 + 1 ; k * 2 < m ; k ++ ) { long temp = ( long ) ( m - k ) * ( k * 5 - m ) ; if ( temp >= solutions . length ) break ; solutions [ ( int ) temp ] ++ ; } } int count = 0 ; for ( int x : solutions ) { if ( x == 10 ) count ++ ; } return Integer . toString ( count ) ; } }

def compute ( ) : NEW_LINE INDENT LIMIT = 10 ** 6 NEW_LINE solutions = [ 0 ] * LIMIT NEW_LINE for m in range ( 1 , LIMIT * 2 ) : NEW_LINE INDENT for k in range ( m // 5 + 1 , ( m + 1 ) // 2 ) : NEW_LINE INDENT temp = ( m - k ) * ( k * 5 - m ) NEW_LINE if temp >= LIMIT : NEW_LINE INDENT break NEW_LINE DEDENT solutions [ temp ] += 1 NEW_LINE DEDENT DEDENT ans = solutions . count ( 10 ) NEW_LINE return str ( ans ) NEW_LINE DEDENT if __name__ == " _ _ main _ _ " : NEW_LINE INDENT print ( compute ( ) ) NEW_LINE DEDENT


public final class p139 implements EulerSolution { public static void main ( String [ ] args ) { System . out . println ( new p139 ( ) . run ( ) ) ; } private static final int LIMIT = 100000000 ; public String run ( ) { int count = 0 ; for ( int s = 3 ; s * s / 2 < LIMIT ; s += 2 ) { for ( int t = 1 ; t < s ; t += 2 ) { int a = s * t ; int b = ( s * s - t * t ) / 2 ; int c = ( s * s + t * t ) / 2 ; int p = a + b + c ; if ( p >= LIMIT ) break ; if ( c % ( a - b ) == 0 && Library . gcd ( s , t ) == 1 ) count += ( LIMIT - 1 ) / p ; } } return Integer . toString ( count ) ; } }

import eulerlib , fractions NEW_LINE def compute ( ) : NEW_LINE INDENT LIMIT = 100000000 NEW_LINE ans = 0 NEW_LINE for s in range ( 3 , eulerlib . sqrt ( LIMIT * 2 ) , 2 ) : NEW_LINE INDENT for t in range ( 1 , s , 2 ) : NEW_LINE INDENT a = s * t NEW_LINE b = ( s * s - t * t ) // 2 NEW_LINE c = ( s * s + t * t ) // 2 NEW_LINE p = a + b + c NEW_LINE if p >= LIMIT : NEW_LINE INDENT break NEW_LINE DEDENT if c % ( a - b ) == 0 and fractions . gcd ( s , t ) == 1 : NEW_LINE INDENT ans += ( LIMIT - 1 ) // p NEW_LINE DEDENT DEDENT DEDENT return str ( ans ) NEW_LINE DEDENT if __name__ == " _ _ main _ _ " : NEW_LINE INDENT print ( compute ( ) ) NEW_LINE DEDENT


public final class p073 implements EulerSolution { public static void main ( String [ ] args ) { System . out . println ( new p073 ( ) . run ( ) ) ; } public String run ( ) { return Integer . toString ( sternBrocotCount ( 1 , 3 , 1 , 2 ) ) ; } private static int sternBrocotCount ( int leftN , int leftD , int rightN , int rightD ) { int n = leftN + rightN ; int d = leftD + rightD ; if ( d > 12000 ) return 0 ; else return 1 + sternBrocotCount ( leftN , leftD , n , d ) + sternBrocotCount ( n , d , rightN , rightD ) ; } }

def compute ( ) : NEW_LINE INDENT ans = 0 NEW_LINE stack = [ ( 1 , 3 , 1 , 2 ) ] NEW_LINE while len ( stack ) > 0 : NEW_LINE INDENT leftn , leftd , rightn , rightd = stack . pop ( ) NEW_LINE d = leftd + rightd NEW_LINE if d <= 12000 : NEW_LINE INDENT n = leftn + rightn NEW_LINE ans += 1 NEW_LINE stack . append ( ( n , d , rightn , rightd ) ) NEW_LINE stack . append ( ( leftn , leftd , n , d ) ) NEW_LINE DEDENT DEDENT return str ( ans ) NEW_LINE DEDENT if __name__ == " _ _ main _ _ " : NEW_LINE INDENT print ( compute ( ) ) NEW_LINE DEDENT


import java . math . BigInteger ; import java . util . Arrays ; import java . util . HashMap ; import java . util . Map ; public final class p062 implements EulerSolution { public static void main ( String [ ] args ) { System . out . println ( new p062 ( ) . run ( ) ) ; } public String run ( ) { int numDigits = 0 ; Map < String , Integer > lowest = new HashMap < > ( ) ; Map < String , Integer > counts = new HashMap < > ( ) ; for ( int i = 0 ; ; i ++ ) { String numClass = getCubeNumberClass ( i ) ; if ( numClass . length ( ) > numDigits ) { int min = Integer . MAX_VALUE ; for ( String nc : counts . keySet ( ) ) { if ( counts . get ( nc ) == 5 ) min = Math . min ( lowest . get ( nc ) , min ) ; } if ( min != Integer . MAX_VALUE ) return cube ( min ) . toString ( ) ; lowest . clear ( ) ; counts . clear ( ) ; numDigits = numClass . length ( ) ; } if ( ! lowest . containsKey ( numClass ) ) { lowest . put ( numClass , i ) ; counts . put ( numClass , 0 ) ; } counts . put ( numClass , counts . get ( numClass ) + 1 ) ; } } private static String getCubeNumberClass ( int x ) { char [ ] digits = cube ( x ) . toString ( ) . toCharArray ( ) ; Arrays . sort ( digits ) ; return new String ( digits ) ; } private static BigInteger cube ( int x ) { return BigInteger . valueOf ( x ) . pow ( 3 ) ; } }

import itertools NEW_LINE def compute ( ) : NEW_LINE INDENT numdigits = 0 NEW_LINE data = { } NEW_LINE for i in itertools . count ( ) : NEW_LINE INDENT digits = [ int ( c ) for c in str ( i ** 3 ) ] NEW_LINE digits . sort ( ) NEW_LINE numclass = " " . join ( str ( d ) for d in digits ) NEW_LINE if len ( numclass ) > numdigits : NEW_LINE INDENT candidates = [ lowest for ( lowest , count ) in data . values ( ) if count == 5 ] NEW_LINE if len ( candidates ) > 0 : NEW_LINE INDENT return str ( min ( candidates ) ** 3 ) NEW_LINE DEDENT data = { } NEW_LINE numdigits = len ( numclass ) NEW_LINE DEDENT lowest , count = data . get ( numclass , ( i , 0 ) ) NEW_LINE data [ numclass ] = ( lowest , count + 1 ) NEW_LINE DEDENT DEDENT if __name__ == " _ _ main _ _ " : NEW_LINE INDENT print ( compute ( ) ) NEW_LINE DEDENT


public final class p214 implements EulerSolution { public static void main ( String [ ] args ) { System . out . println ( new p214 ( ) . run ( ) ) ; } private static final int LIMIT = 40000000 ; public String run ( ) { int [ ] totient = Library . listTotients ( LIMIT - 1 ) ; int [ ] totientChainLength = new int [ totient . length ] ; totientChainLength [ 0 ] = 0 ; long sum = 0 ; for ( int i = 1 ; i < totient . length ; i ++ ) { int chainlen = totientChainLength [ totient [ i ] ] + 1 ; totientChainLength [ i ] = chainlen ; if ( chainlen == 25 && totient [ i ] == i - 1 ) sum += i ; } return Long . toString ( sum ) ; } }

import array NEW_LINE def compute ( ) : NEW_LINE INDENT LIMIT = 40000000 NEW_LINE totient = list_totients ( LIMIT - 1 ) NEW_LINE totientchainlen = array . array ( " L " , [ 0 , 1 ] ) NEW_LINE ans = 0 NEW_LINE for i in range ( len ( totientchainlen ) , len ( totient ) ) : NEW_LINE INDENT chainlen = totientchainlen [ totient [ i ] ] + 1 NEW_LINE totientchainlen . append ( chainlen ) NEW_LINE if chainlen == 25 and totient [ i ] == i - 1 : NEW_LINE INDENT ans += i NEW_LINE DEDENT DEDENT return str ( ans ) NEW_LINE DEDENT def list_totients ( n ) : NEW_LINE INDENT assert n < ( 1 << 32 ) NEW_LINE result = array . array ( " L " , range ( n + 1 ) ) NEW_LINE for i in range ( 2 , n + 1 ) : NEW_LINE INDENT if result [ i ] == i : NEW_LINE INDENT for j in range ( i , n + 1 , i ) : NEW_LINE INDENT result [ j ] = result [ j ] // i * ( i - 1 ) NEW_LINE DEDENT DEDENT DEDENT return result NEW_LINE DEDENT if __name__ == " _ _ main _ _ " : NEW_LINE INDENT print ( compute ( ) ) NEW_LINE DEDENT


public final class p041 implements EulerSolution { public static void main ( String [ ] args ) { System . out . println ( new p041 ( ) . run ( ) ) ; } public String run ( ) { for ( int n = 9 ; n >= 1 ; n -- ) { int [ ] digits = new int [ n ] ; for ( int i = 0 ; i < digits . length ; i ++ ) digits [ i ] = i + 1 ; int result = - 1 ; do { if ( Library . isPrime ( toInteger ( digits ) ) ) result = toInteger ( digits ) ; } while ( Library . nextPermutation ( digits ) ) ; if ( result != - 1 ) return Integer . toString ( result ) ; } throw new RuntimeException ( " Not ▁ found " ) ; } private static int toInteger ( int [ ] digits ) { int result = 0 ; for ( int x : digits ) result = result * 10 + x ; return result ; } }

import eulerlib NEW_LINE def compute ( ) : NEW_LINE INDENT for n in reversed ( range ( 2 , 10 ) ) : NEW_LINE INDENT arr = list ( reversed ( range ( 1 , n + 1 ) ) ) NEW_LINE while True : NEW_LINE INDENT if arr [ - 1 ] not in NONPRIME_LAST_DIGITS : NEW_LINE INDENT n = int ( " " . join ( str ( x ) for x in arr ) ) NEW_LINE if eulerlib . is_prime ( n ) : NEW_LINE INDENT return str ( n ) NEW_LINE DEDENT DEDENT if not prev_permutation ( arr ) : NEW_LINE INDENT break NEW_LINE DEDENT DEDENT DEDENT raise AssertionError ( ) NEW_LINE DEDENT NONPRIME_LAST_DIGITS = { 0 , 2 , 4 , 5 , 6 , 8 } NEW_LINE def prev_permutation ( arr ) : NEW_LINE INDENT i = len ( arr ) - 1 NEW_LINE while i > 0 and arr [ i - 1 ] <= arr [ i ] : NEW_LINE INDENT i -= 1 NEW_LINE DEDENT if i <= 0 : NEW_LINE INDENT return False NEW_LINE DEDENT j = len ( arr ) - 1 NEW_LINE while arr [ j ] >= arr [ i - 1 ] : NEW_LINE INDENT j -= 1 NEW_LINE DEDENT arr [ i - 1 ] , arr [ j ] = arr [ j ] , arr [ i - 1 ] NEW_LINE arr [ i : ] = arr [ len ( arr ) - 1 : i - 1 : - 1 ] NEW_LINE return True NEW_LINE DEDENT if __name__ == " _ _ main _ _ " : NEW_LINE INDENT print ( compute ( ) ) NEW_LINE DEDENT


public final class p019 implements EulerSolution { public static void main ( String [ ] args ) { System . out . println ( new p019 ( ) . run ( ) ) ; } public String run ( ) { int count = 0 ; for ( int y = 1901 ; y <= 2000 ; y ++ ) { for ( int m = 1 ; m <= 12 ; m ++ ) { if ( dayOfWeek ( y , m , 1 ) == 0 ) count ++ ; } } return Integer . toString ( count ) ; } private static int dayOfWeek ( int year , int month , int day ) { if ( year < 0 || year > 10000 || month < 1 || month > 12 || day < 1 || day > 31 ) throw new IllegalArgumentException ( ) ; int m = ( month - 3 + 4800 ) % 4800 ; int y = ( year + m / 12 ) % 400 ; m %= 12 ; return ( y + y / 4 - y / 100 + ( 13 * m + 2 ) / 5 + day + 2 ) % 7 ; } }

import datetime NEW_LINE def compute ( ) : NEW_LINE INDENT ans = sum ( 1 for y in range ( 1901 , 2001 ) for m in range ( 1 , 13 ) if datetime . date ( y , m , 1 ) . weekday ( ) == 6 ) NEW_LINE return str ( ans ) NEW_LINE DEDENT if __name__ == " _ _ main _ _ " : NEW_LINE INDENT print ( compute ( ) ) NEW_LINE DEDENT


import java . util . HashSet ; import java . util . Set ; public final class p095 implements EulerSolution { public static void main ( String [ ] args ) { System . out . println ( new p095 ( ) . run ( ) ) ; } private static final int LIMIT = Library . pow ( 10 , 6 ) ; public String run ( ) { int [ ] divisorSum = new int [ LIMIT + 1 ] ; for ( int i = 1 ; i <= LIMIT ; i ++ ) { for ( int j = i * 2 ; j <= LIMIT ; j += i ) divisorSum [ j ] += i ; } int maxChainLen = 0 ; int minChainElem = - 1 ; for ( int i = 0 ; i <= LIMIT ; i ++ ) { Set < Integer > visited = new HashSet < > ( ) ; for ( int count = 1 , cur = i ; ; count ++ ) { visited . add ( cur ) ; int next = divisorSum [ cur ] ; if ( next == i ) { if ( count > maxChainLen ) { minChainElem = i ; maxChainLen = count ; } break ; } else if ( next > LIMIT || visited . contains ( next ) ) break ; else cur = next ; } } return Integer . toString ( minChainElem ) ; } }

import itertools NEW_LINE def compute ( ) : NEW_LINE INDENT LIMIT = 10 ** 6 NEW_LINE divisorsum = [ 0 ] * ( LIMIT + 1 ) NEW_LINE for i in range ( 1 , LIMIT + 1 ) : NEW_LINE INDENT for j in range ( i * 2 , LIMIT + 1 , i ) : NEW_LINE INDENT divisorsum [ j ] += i NEW_LINE DEDENT DEDENT maxchainlen = 0 NEW_LINE ans = - 1 NEW_LINE for i in range ( LIMIT + 1 ) : NEW_LINE INDENT visited = set ( ) NEW_LINE cur = i NEW_LINE for count in itertools . count ( 1 ) : NEW_LINE INDENT visited . add ( cur ) NEW_LINE next = divisorsum [ cur ] NEW_LINE if next == i : NEW_LINE INDENT if count > maxchainlen : NEW_LINE INDENT ans = i NEW_LINE maxchainlen = count NEW_LINE DEDENT break NEW_LINE DEDENT elif next > LIMIT or next in visited : NEW_LINE INDENT break NEW_LINE DEDENT else : NEW_LINE INDENT cur = next NEW_LINE DEDENT DEDENT DEDENT return str ( ans ) NEW_LINE DEDENT if __name__ == " _ _ main _ _ " : NEW_LINE INDENT print ( compute ( ) ) NEW_LINE DEDENT