JUNTO

About JUNTO

JUNTO is private self-directed investment club.

Club members:

The JUNTO MarketWatch Game runs from to .

Next Meeting

John runs the next meeting: , .

Action items:

Python Practice. This meeting’s practice is Project Euler Problem 44: “Pentagon numbers”.

Solution: 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: Oscar

Not Yet Submitted

Solution: Daniel

Not Yet Submitted

Solution: Cai

Not Yet Submitted

Historical Information

Table: Historical Meeting Index. Shows who is present at what meeting. Mouse-over dates to get longhand.
Cai Daniel John Oscar
⬛︎ ⬛︎ ⬛︎
⬛︎ ⬛︎ ⬛︎ ⬛︎
⬛︎ ⬛︎
⬛︎ ⬛︎ ⬛︎
⬛︎ ⬛︎ ⬛︎ ⬛︎
⬛︎ ⬛︎ ⬛︎
⬛︎ ⬛︎ ⬛︎
⬛︎ ⬛︎ ⬛︎
⬛︎ ⬛︎ ⬛︎
⬛︎ ⬛︎ ⬛︎ ⬛︎
⬛︎ ⬛︎ ⬛︎ ⬛︎
⬛︎ ⬛︎ ⬛︎ ⬛︎
⬛︎ ⬛︎ ⬛︎
⬛︎ ⬛︎ ⬛︎ ⬛︎
⬛︎ ⬛︎ ⬛︎ ⬛︎
⬛︎ ⬛︎ ⬛︎ ⬛︎
⬛︎ ⬛︎ ⬛︎ ⬛︎
⬛︎ ⬛︎ ⬛︎ ⬛︎
⬛︎ ⬛︎ ⬛︎
⬛︎ ⬛︎ ⬛︎ ⬛︎
⬛︎ ⬛︎ ⬛︎ ⬛︎
⬛︎ ⬛︎ ⬛︎ ⬛︎

Archived Python Practice solutions:

: Project Euler Problem 25

Project Euler Problem 25: “1000-digit Fibonacci number”.

Solution: 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: 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}.')
Solution: Daniel

Not Yet Submitted

Solution: Cai

Not Yet Submitted

: Project Euler Problem 11

Project Euler Problem 11: “Largest product in a grid”.

Solution: 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: 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())
Solution: Daniel

Not Submitted

Solution: Cai

Not Submitted

: Project Euler Problem 4

Project Euler Problem 4: “Largest palindrome product”.

Solution: 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: Oscar
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()')
Solution: Daniel

Not Submitted

Solution: Cai

Not Submitted

: Project Euler Problem 1

Project Euler Problem 1: “Multiples of 3 and 5”.

Solution: John
sum(
    i
    for i in range(1000)
    if not (i%5 and i%3)
)
Solution: 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: Daniel
sum({*range(3, 1000, 3)} | {*range(5, 1000, 5)})
Solution: Cai

Not Submitted

: Complementing DNA

Rosalind’s “Complementing a Strand of DNA”.

Solution: 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: 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')))
Solution: Daniel

Not Submitted

Solution: Cai

Not Submitted

: Project Euler Problem 22

Project Euler Problem 22.

Solution: 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: 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)
Solution: Daniel

Not Submitted

Solution: Cai

Not Submitted