http://projecteuler.net/problem=86

#euler 86
import math
import time
t0 = time.time()

def gcd(a,b):
    while b!= 0:
        a, b = b, a%b
    return a

def isCoprime(a,b):
    if gcd(a,b) == 1:
        return True
    else:
        return False

mlimit = 65  # generate a list of primitives
prim = []
for m in range(2, mlimit):
    for n in range(1, m):
        if (n+m) % 2 == 1 and  isCoprime(m,n):
            a = m*m - n*n
            b = 2*m*n
            c = m*m + n*n
            temp = [a,b,c]
            temp.sort()
            ttup = tuple(temp)
            prim.append(ttup)

print len(prim), "primitive triples were generated"
highest = max(x[1] for x in prim)
print "the greatest of the first 2 parts of the triple was ", highest

# from your list of primitives, generate all pythagorean triples where the longer side (not the hypotenuse)
# is less than the longest side observed
allTriples = prim[:]
for x in prim:
    side = x[1]
    counter = highest / side
    if counter > 1:
        for j in range(1, counter):
            factor = j+1
            temp = tuple([factor * y for y in x])
            allTriples.append(temp)

# mergesort (based on second number)
def merge(left, right):
    result = []
    i ,j = 0, 0
    while i < len(left) and j < len(right):
        if left[i][1] <= right[j][1]:
            result.append(left[i])
            i += 1
        else:
            result.append(right[j])
            j += 1
    result += left[i:]
    result += right[j:]
    return result

def mergesort(list):
    if len(list) < 2:
        return list
    else:
        middle = len(list) / 2
        left = mergesort(list[:middle])
        right = mergesort(list[middle:])
        return merge(left, right)

sortedTriples = mergesort(allTriples)

def takeTriple(triple):  #takes triple, returns number of shortest distance cubes
    shorter = triple[0]
    longer = triple[1]
    # when M is shorter, let's count ways to split longer
    # i.e. for triple (6,8,10)
    # shorter is 6, longer is 8
    # we set M to 6, and we want to split 8 into (6,2),  (5,3), (4,4)
    output = {}
    base = longer / 2
    if shorter > base:
        output[shorter] = shorter - base + 1 - (longer % 2)
    base2 = shorter / 2
    output[longer] = shorter - base2 - (shorter % 2)
    return output

mDict = {}
for i in range(1, highest+1):
    mDict[i] = 0

for i in sortedTriples:
    temp = takeTriple(i)
    for j in temp:
        mDict[j] += temp[j]

sumDict = {0:0}
for i in range(1, highest+1):
    sumDict[i] = sumDict[i-1] + mDict[i]

#iterate through dictionary, and stop when you find 1000000

counter = 1
while True:
    counter += 1
    if sumDict[counter] >= 1000000:
        print "The answer is ", counter
        print "There were ", sumDict[counter], "cuboids less than the MxMxM dimensions"
        break

t1 = time.time()
total = t1-t0
print total, "seconds"

Would like to watch these someday….

http://engineering.linkedin.com/event/video-3-big-data-tech-talks-you-can%E2%80%99t-miss

http://projecteuler.net/problem=83

I used the pseudocode from Wikipedia on Dijkstra’s algorithm to solve this problem.

# euler 82
# grid is a dictionary with key as tuple (i,j) and value as value of node
# i is row, j is column of grid

import time
t0 = time.time()

f = open('matrix.txt', 'r')
grid = {}
counter = 1
for line in f:
   temp = line.replace('\n','')
   temp = temp.split(',')
   for a in range(len(temp)):
       grid[(counter,a+1)] = int(temp[a])
   counter += 1
rows = 80
cols = 80

def findNeighbors(vertex):
   i, j = vertex[0], vertex[1]
   output = [(i-1,j), (i+1,j), (i,j-1), (i,j+1)]  # all neighbors
   remove = []
   for v in output:
      if v[0] < 1 or v[0] > rows or v[1] < 1 or v[1] > cols:
         remove.append(v)
   final = [x for x in output if not x in remove]
   return final

# Let's implement Dijkstra's algo from Wikipedia
def dka(graph, source):    # graph will be our grid, source will be (1,1)
   dist = {}
   for v in graph:
      dist[v] = float("inf")
   dist[source] = graph[source]
   Q = dist.copy()   #make a copy of graph, as a hash
   length = len(Q)
   while length > 0:
      u = min(Q, key=Q.get)
      if dist[u] == float("inf"):
         break
      if u == (rows, cols):
         break
      del Q[u]
      length -= 1
      n = findNeighbors((u))
      neighbors = [x for x in n if x in Q]
      for v in neighbors:
         alt = dist[u] + grid[v]
         if alt < dist[v]:
            dist[v] = alt
            Q[v] = alt
   return dist

answerGrid = dka(grid,(1,1))

print "The answer is ", answerGrid[(rows,cols)]
t1= time.time()
total = t1-t0
print total, "seconds"

From StackOverflow:

http://stackoverflow.com/questions/3282823/python-get-key-with-the-least-value-from-a-dictionary

min(d, key=d.get)

http://projecteuler.net/problem=82

I’m looking forward to reading the forums in Euler for this one, as I’m curious to find a more elegant way to solve this problem…

# euler 82

f = open('matrix.txt', 'r')

# grid is a dictionary with key as tuple (i,j) and value as value of node
# i is row, j is column of grid
grid = {}
counter = 1
for line in f:
   temp = line.replace('\n','')
   temp = temp.split(',')
   for a in range(len(temp)):
       grid[(counter,a+1)] = int(temp[a])
   counter += 1

rows = 80
cols = 80

minGrid = {}
# first column of min grid is just the value of the node
for i in range(1,rows+1):
    minGrid[(i,1)] = grid[(i,1)]

def compare(location):  # takes a node (i,j) returns cheapest way to get there
    i, j = location[0], location[1]
    lookleft = minGrid[(i,j-1)]
    upSum = 0
    cellsUp = 0
    maxUp = i-1 #this is the max number of cells up to check
    while cellsUp < maxUp:
        cellsUp += 1
        upSum += grid[(i-cellsUp, j)]
        if upSum > lookleft:   #going up is too expensive
            cellsUp -= 1
            break
    downSum = 0
    cellsDown = 0
    maxDown = rows - i
    while cellsDown < maxDown:  #checking cells down
        cellsDown += 1
        downSum += grid[(i+cellsDown, j)]
        if downSum > lookleft:
            cellsDown -= 1
            break
    upMemo = {0:0}
    upMin = []
    downMemo = {0:0}
    downMin = []
    if cellsUp > 0:
        for cu in range(1, cellsUp+1):
            upMemo[cu] = upMemo[cu-1] + grid[(i-cu,j)]
            upMin.append(upMemo[cu] + minGrid[(i-cu, j-1)])
    if cellsDown > 0:
        for cd in range(1, cellsDown+1):
            downMemo[cd] = downMemo[cd-1] + grid[(i+cd,j)]
            downMin.append(downMemo[cd] + minGrid[(i+cd, j-1)])
    bigList = [lookleft]
    for a in upMin:
        bigList.append(a)
    for b in downMin:
        bigList.append(b)
    lowest = min(bigList)
    return grid[(i,j)] + lowest

for c in range(2, cols+1):
    for d in range(1, rows+1):
        minGrid[(d,c)] = compare((d,c))

cheapestList = []
for a in range(1, rows+1):
    cheapestList.append(minGrid[(a,cols)])

print "Cheapest path is ", min(cheapestList)

I posed a question on StackExchange today….

http://stackoverflow.com/q/9020500/1171561

http://projecteuler.net/problem=79

As I was researching the web for approaches to solving this problem, I found Kristian’s MathBlog article quite useful (as usual), and so I took up his suggestion to try implementing a topological sorting algorithm, which I found described in Wikipedia.

I had some problems just using the pseudocode described in Wikipedia, mostly because Python won’t let you iterate over a set if you change the set during the iteration, so I had to figure out some workarounds.

#euler 79

f = open('keylog.txt', 'r')
attempts = []
for line in f:
    attempts.append(line.replace('\n',''))

candidates = []   #possible numbers in passcode
for i in attempts:
    for j in i:
        if not j in candidates:
            candidates.append(j)

# let's take attempts, and turn it into a set of directed edges
# each edge is a tuple (a, b) where a precedes b

edges = set()
for i in attempts:
    e1 = (i[0],i[1])
    e2 = (i[1],i[2])
    edges.add(e1)
    edges.add(e2)

#let's implement the Kahn topological sorting algo (see Wikipedia)
def findNoEdge(candidates, edges):  # returns list of candidates with no incoming edge
    output = []
    for a in candidates:
        test = True
        for b in edges:
            if b[1] == a:
                test = False
                break
        if test:
            output.append(a)
    return output

L = []  #empty list of sorted elements
S = findNoEdge(candidates, edges)

def removeNode(n, S, L, edges):
    S.remove(n)
    L.append(n)
    edgesToRemove = []
    for i in edges:  # i is a tuple of node a pointing to node b
        if i[0] == n:
            edgesToRemove.append(i)
    for j in edgesToRemove:
        edges.remove(j)
    for j in edgesToRemove:
        temp = findNoEdge(j, edges)  #this is a list of nodes that have no incoming edges
        for k in temp:
            if not k in L:
                S.append(k)
    return S, L, edges

keepGoing = True
while keepGoing:
    a = len(S)
    sCopy = S[:]
    for counter in range(a):
        S, L, edges = removeNode(sCopy[counter], S, L, edges)
    if len(S) == 0:
        print "".join(str(x) for x in L)
        break