Return to homepage.

JUNTO


Python Practice

Solution for John
Not Submitted
Solution for Oscar
Not Submitted
Solution for Daniel
Not Submitted
Solution for Cai
Not Submitted

Reading Questions


Python Practice Solutions

2018-11-28

Project Euler Problem 44

Solution for John
import itertools

class Pentagonal():
    def __init__(self):
        self._generator = (
            n * (3 * n - 1) // 2
            for n in itertools.count(1)
        )
        self._max = None
        self._seen = set()
        self._seen_ordered = list()

    def check_pentagonal(self, n):
        while self._max is None or self._max < n:
            item = next(self._generator)
            self._max = item
            self._seen.add(item)
            self._seen_ordered.append(item)

        return n in self._seen

    def get_pentagonal(self, n):
        while len(self._seen_ordered) < n:
            item = next(self._generator)
            self._max = item
            self._seen.add(item)
            self._seen_ordered.append(item)

        return self._seen_ordered[n-1]

def candidate_indices():
    for i in itertools.count(1):
        for j in range(1, i):
            yield (i, j)

db = Pentagonal()

for i, j in candidate_indices():
    p_i = db.get_pentagonal(i)
    p_j = db.get_pentagonal(j)

    sum_pentagonal = db.check_pentagonal(p_i + p_j)
    diff_pentagonal = db.check_pentagonal(abs(p_i - p_j))

    if sum_pentagonal and diff_pentagonal:
        print(f'The answer is {abs(p_i - p_j)}')
        break
Solution for Oscar
#!/usr/bin/env python3

import itertools as it

class Pents:
    def __init__(self):
        self.new_set()
        
    def new_set(self):
        self.pset = self.gen_pents()
    
    def gen_pents(self):
        return map(self.pent,it.count(start=1))

    def pent(self,integer): 
        return int((integer * (3*integer - 1))/2)    

    def is_pent(self,integer):
        self.new_set()
        for p in self.pset:
            if p > integer:
                return False
            elif p == integer:
                return True

def min_d():
    p_i = Pents()
    trail_p = []
    for i in p_i.pset:
        trail_p.append(i)
        # print(i)
        if len(trail_p) > 1:
            for j in range(len(trail_p)-2,-1,-1):
                if ((i - trail_p[j]) in trail_p) and Pents().is_pent(i + trail_p[j]):
                    # print('Got it')
                    return abs(i - trail_p[j]),i,trail_p[j]
                    
d, _, _ = min_d()
print(d)
2018-11-08

Project Euler Problem 25

Solution for John
import math

from decimal import Decimal

def way1():
    def fibonacci():
        a, b = 1, 1
        while True:
            yield a
            a, b = b, a + b
    
    threshold = 10 ** (1000 - 1)
    
    fib_above = (
        (i, n)
        for i, n in enumerate(fibonacci(), start=1)
        if n >= threshold
    )
    
    i, _ = next(fib_above)
    
    return i
    
def way2():
    phi = (1 + Decimal(5).sqrt()) / 2
    
    # Binet’s Formula
    estimate = (999 + Decimal(5).sqrt().log10()) / phi.log10()
    
    return math.ceil(estimate)
    
print(way1())
print(way2())
Solution for Oscar
# This code runs into the maxiumum recursion depth and so cannot reliably be used.

import sys

sys.setrecursionlimit(5000)

def fib(n_prime=1):
    n_prime += n_prime
    if len(str(n_prime)) <= 1000:
        return (fib(n_prime))
    else :
            return n_prime

print(fib())

# %%

# This yields the answer

ind = 0
i = 1
while len(str(i)) < 1000:
    i+=i
    ind += 1
len(str(i))
print(f'The index of the fibonacci number {i} is {ind}.')
2018-10-16

Project Euler Problem 11

Solution for John
import itertools

import numpy as np

grid_str = '''
08 02 22 97 38 15 00 40 00 75 04 05 07 78 52 12 50 77 91 08
49 49 99 40 17 81 18 57 60 87 17 40 98 43 69 48 04 56 62 00
81 49 31 73 55 79 14 29 93 71 40 67 53 88 30 03 49 13 36 65
52 70 95 23 04 60 11 42 69 24 68 56 01 32 56 71 37 02 36 91
22 31 16 71 51 67 63 89 41 92 36 54 22 40 40 28 66 33 13 80
24 47 32 60 99 03 45 02 44 75 33 53 78 36 84 20 35 17 12 50
32 98 81 28 64 23 67 10 26 38 40 67 59 54 70 66 18 38 64 70
67 26 20 68 02 62 12 20 95 63 94 39 63 08 40 91 66 49 94 21
24 55 58 05 66 73 99 26 97 17 78 78 96 83 14 88 34 89 63 72
21 36 23 09 75 00 76 44 20 45 35 14 00 61 33 97 34 31 33 95
78 17 53 28 22 75 31 67 15 94 03 80 04 62 16 14 09 53 56 92
16 39 05 42 96 35 31 47 55 58 88 24 00 17 54 24 36 29 85 57
86 56 00 48 35 71 89 07 05 44 44 37 44 60 21 58 51 54 17 58
19 80 81 68 05 94 47 69 28 73 92 13 86 52 17 77 04 89 55 40
04 52 08 83 97 35 99 16 07 97 57 32 16 26 26 79 33 27 98 66
88 36 68 87 57 62 20 72 03 46 33 67 46 55 12 32 63 93 53 69
04 42 16 73 38 25 39 11 24 94 72 18 08 46 29 32 40 62 76 36
20 69 36 41 72 30 23 88 34 62 99 69 82 67 59 85 74 04 36 16
20 73 35 29 78 31 90 01 74 31 49 71 48 86 81 16 23 57 05 54
01 70 54 71 83 51 54 69 16 92 33 48 61 43 52 01 89 19 67 48
'''

grid = np.fromiter(grid_str.split(), dtype=np.uint64)
grid.shape = 20, 20

def candidates():
    global grid
    
    for r, c in itertools.product(range(20), repeat=2):
        can_vertical   = r <= 16
        can_horizontal = c <= 16

        if can_horizontal:
            yield grid[r, c:c+4]
        
        if can_vertical:
            yield grid[r:r+4, c]
        
        if can_horizontal and can_vertical:
            sub_grid = grid[r:r+4, c:c+4]
            yield np.diagonal(sub_grid)
            yield np.diagonal(np.fliplr(sub_grid))

solution = max(
    np.prod(c)
    for c in candidates()
)

print(solution)
Solution for Oscar
import numpy as np

with open('p11.txt') as gridfl:
    grid = gridfl.readlines()

for i,row in enumerate(grid):
    grid[i] = row.replace("\n",'').split(' ')

def best_quad():
    temp_max = 0
    max_val = 0
    for index in range(0,17):
        temp_max = g_arr[0:20 , index : (index + 4)].prod(axis=1).max()
        if max_val < temp_max:
            max_val = temp_max
        temp_max = g_arr[index : (index + 4) , 0:20].prod(axis=0).max()
        if max_val < temp_max:
            max_val = temp_max    
    rdiag = 1
    for row in range(0,17):
        for column in range(0,17):
            if max_val < rdiag:
                max_val = rdiag
            rdiag = 1
            for shift in range(0,4):
                rdiag *= g_arr[row + shift, column + shift]
    ldiag = 1
    for row in range(19,2,-1):
        for column in range(0,17):
            if max_val < ldiag:
                max_val = ldiag
            ldiag = 1
            for shift in range(0,4):
                ldiag *= g_arr[row - shift, column + shift]
    
    return(max_val)

print(best_quad())
2018-10-01

Project Euler Problem 4

Solution for John
import itertools

palindrome = lambda n: str(n) == str(n)[::-1]

three_digit_num = range(100, 1000)

squares = (
    n ** 2
    for n in three_digit_num
)

products = (
    n * m
    for n, m in itertools.combinations(three_digit_num, 2)
)

max_palindrome = max(
    p
    for p in itertools.chain(squares, products)
    if palindrome(p)
)

print(max_palindrome)
Solution for Ocsar
def euler4():
    sMaxPalin = 0
    iFactor = 999

    def isPalin(iNumber):
        return(''.join(reversed(str(iNumber))) == str(iNumber))

    while iFactor > 99:
        for i in range(999,99,-1):
            iTempMult = iFactor * i
            if isPalin(iTempMult) and iTempMult > sMaxPalin:
                sMaxPalin = iTempMult

        iFactor -= 1

    return(sMaxPalin)

import cProfile

cProfile.run('euler4()')
2018-09-18

Project Euler Problem 1

Solution for John
sum(
    i
    for i in range(1000)
    if not (i%5 and i%3)
)
Solution for Oscar
# -*- coding: utf-8 -*-
"""
Created on Thu Sep  6 12:16:50 2018

@author: omartinez
"""

#%% JUNTO Practice Problem 3
# We want to find the sum of the multiples of 3 or 5 in a range, [1,N)
# In this case N is 1000, range is [1,1000)

# We opt to store the values in an array and then sum them,
# in case we wanted to list the numbers
# Start with empty array
arr_multiples = []

# Loop through [1,1000)
# Check if remainder is 0, the number is a multiple and we store it
for i in range(1,1000):
    if i % 3 == 0 or i % 5 == 0:
        arr_multiples.append(i)
        
arr_multiples
sum(arr_multiples)
Solution for Daniel
sum({*range(3, 1000, 3)} | {*range(5, 1000, 5)})
2018-09-04

Rosalind, Complementing a Strand of DNA

Solution for John
#!/usr/bin/env python3
#
# Read a string of DNA from standard input and output
# its reverse complement on standard output.
#

import sys

# Guanine, Adenine, Cytosine, Thymine.
#
bases = { 'G', 'A', 'T', 'C' }

# Complements of above bases.
#
complement_table = {
    'G': 'C',
    'A': 'T',
    'T': 'A',
    'C': 'G'
}

# Function that applies `complement_table` to complement a base.
# Ex. complement('G') == 'C'
#
complement = complement_table.get

# Read string of characters from standard input and only keep characters
# corresponding to one of the bases.
#
dna_string = list(filter(lambda c: c in bases, sys.stdin.read()))

# Reverse and then complement `dna_string`.
#
rc_string = map(complement, reversed(dna_string))

# Print the result to standard output as a string.
#
print(''.join(rc_string))
Solution for Oscar
def reverse_complement (s):
    original = 'ATCG'
    complement = 'TAGC'
    nucl_compl = ''.maketrans(original,complement)
    return(''.join(reversed(s)).translate(nucl_compl))

print(reverse_complement(reverse_complement('ATCGATTCAAATTT')))
2018-08-20

Project Euler Problem 22

Solution for John
#!/usr/bin/env python3

with open('names.txt', 'r') as namefile:
    content = namefile.read().replace('"', '')
    names = sorted(content.split(','))
    total = 0

    for i, name in enumerate(names, start=1):
        alpha_val = sum(map(lambda c: 1 + ord(c) - ord('A'), name))
        total += i * alpha_val

    print(total)
Solution for Oscar
#!/usr/bin/env python3
# -*- coding: utf-8 -*-
"""
Created on Sat Aug 18 18:50:36 2018

@author: oscarmartinez
"""

#%%

'''Set Working Directory, change to your needs.'''

import os
os.getcwd()
os.chdir('/Users/oscarmartinez/Master Files/JUNTO')

#%%

'''Read off the names, remove the quotation marks and split on commas'''
'''Sort the list in place as specified by problem'''

strNamesList = open('p022_names.txt').read().replace('"','')
lstNames = strNamesList.split(sep=',')
lstNames.sort()

#%%

'''create Dict to map strings'''
'''NOTE: could use method .maketrans() and then str.translate() instead
in order to create a way to map name scores'''

import string

dictCharScore = {}
for i,char in enumerate(string.ascii_uppercase):
    dictCharScore[char] = i + 1

#%%

'''manual sum over the list, could also use a list of numbers and then
sum over the list'''

fltTotalScore = 0.0
for row,name in enumerate(lstNames):
    iBaseScore = 0
    for char in name: 
        iBaseScore += dictCharScore[char]
    
    iScore=iBaseScore * (row + 1) 
    fltTotalScore += iScore

print(fltTotalScore)

Meeting Attendance

Cai Daniel John Oscar
2018-11-28 ⬛︎ ⬛︎ ⬛︎
2018-11-08 ⬛︎ ⬛︎ ⬛︎
2018-10-16 ⬛︎ ⬛︎ ⬛︎ ⬛︎
2018-10-01 ⬛︎ ⬛︎
2018-09-18 ⬛︎ ⬛︎ ⬛︎
2018-09-04 ⬛︎ ⬛︎ ⬛︎ ⬛︎
2018-08-20 ⬛︎ ⬛︎ ⬛︎
2018-08-06 ⬛︎ ⬛︎ ⬛︎
2018-07-14 ⬛︎ ⬛︎ ⬛︎
2018-07-07 ⬛︎ ⬛︎ ⬛︎
2018-05-30 ⬛︎ ⬛︎ ⬛︎ ⬛︎
2018-05-15 ⬛︎ ⬛︎ ⬛︎ ⬛︎
2018-04-10 ⬛︎ ⬛︎ ⬛︎ ⬛︎
2018-03-17 ⬛︎ ⬛︎ ⬛︎
2018-03-03 ⬛︎ ⬛︎ ⬛︎ ⬛︎
2018-02-17 ⬛︎ ⬛︎ ⬛︎ ⬛︎
2018-02-03 ⬛︎ ⬛︎ ⬛︎ ⬛︎
2018-01-20 ⬛︎ ⬛︎ ⬛︎ ⬛︎
2018-01-06 ⬛︎ ⬛︎ ⬛︎ ⬛︎
2017-12-09 ⬛︎ ⬛︎ ⬛︎
2017-11-11 ⬛︎ ⬛︎ ⬛︎ ⬛︎
2017-10-21 ⬛︎ ⬛︎ ⬛︎ ⬛︎
2017-10-07 ⬛︎ ⬛︎ ⬛︎ ⬛︎