jimmy

##Problem Set 3
## Name: Jimmy
## Time: 15:00

from string import *

target1 = 'atgacatgcacaagtatgcat'
target2 = 'atgaatgcatggatgtaaatgcag'

targets = (target1, target2)

key10 = 'a'
key11 = 'atg'
key12 = 'atgc'
key13 = 'atgca'

keys = (key10, key11, key12, key13)


def subStringMatchOneSub(key,target):
    """search for all locations of key in target, with one substitution"""
    allAnswers = ()
    for miss in range(0,len(key)):
        key1 = key[:miss]
        key2 = key[miss+1:]
        match1 = subStringMatchExact(target,key1)
        match2 = subStringMatchExact(target,key2)
        filtered = constrainedMatchPair(match1,match2,len(key1))
        allAnswers = allAnswers + filtered
    return allAnswers


## problem 3a


def countSubStringMatch(target,key):
        counter = [-1]
        tryrange = range(0, len(target) + 1)
        for x in tryrange:
                location = find(target, key, x) 
                if location not in counter:
                        counter.append(location)
        if counter == -1:
                return 0
        else:
                counter.remove(-1)              
                return len(counter)

def helpcountSubStringMatchRecursive(target, key, incr, counter):
        position = find(target, key, incr)
        incr += 1       
        if position not in counter:
                counter.append(position)
                helpcountSubStringMatchRecursive(target, key, incr, counter)
        if incr -1 >= len(target):
                return counter
        else:
                helpcountSubStringMatchRecursive(target, key, incr, counter)

def countSubStringMatchRecursive(target, key):
        counter = [-1] 
        helpcountSubStringMatchRecursive(target, key, 0, counter)
        counter.remove(-1)
        return len(counter)

## problem 3b

def subStringMatchExact(target,key):
        counter = [-1]
        tryrange = range(0, len(target) + 1)
        for x in tryrange:
                location = find(target, key, x) 
                if location not in counter:
                        counter.append(location)
        if counter == -1:
                return 0
        else:
                counter.remove(-1)      
                return tuple(counter)

## problem 3c

def constrainedMatchPair(firstMatch, secondMatch, length):
        matches = []
        for n in firstMatch:
                for k in secondMatch:
                        m = length                      
                        if n + m + 1 == k:
                                matches.append(n)
        return tuple(matches)


## problem 3d

def subStringMatchExactlyOneSub(target,key):
        exact = subStringMatchExact(target,key) 
        close = subStringMatchOneSub(key,target)
        onesub = []
        for index in close:
                if index not in exact:
                        onesub.append(index)
        return tuple(onesub)

## Problem Set 2
## Name: Jimmy
## Time: forever

##Part A


##McNuggets Package (6, 9, 20)
##
##50 = 6(2) + 9(2) + 20(1)
##
##51 = 6(7) + 9(1) + 20(0)
##
##52 = 6(2) + 9(0) + 20(2)
##
##53 = 6(1) + 9(3) + 20(1)
##
##54 = 6(3) + 9(4) + 20(0)
##
##55 = 6(1) + 9(1) + 20(2)
##
##56 = 6(3) + 9(2) + 20(1)
##
##57 = 6(8) + 9(1) + 20(0)
##
##58 = 6(3) + 9(0) + 20(2)
##
##59 = 6(2) + 9(3) + 20(1)
##
##60 = 6(1) + 9(6) + 20(0)
##
##61 = 6(2) + 9(1) + 20(2)
##
##62 = 6(4) + 9(2) + 20(1)
##
##63 = 6(0) + 9(7) + 20(0)
##
##64 = 6(1) + 9(2) + 20(2)
##
##65 = 6(3) + 9(3) + 20(1)


##Part B

## This theorem is true because any number of McNuggets >= x can be expressed
##as a linear combination 6a+9b+20c if x+1, x+2, x+3, x+4 and x+5 all have a
##solution

##Part C

nuggets = []
counter = 0
n = 0
for n in range(1,1000):
    answer = False
    for a in range(0,n/6+1):
        for b in range(0,n/9+1):
            for c in range(0,n/20+1):
                if (6*a)+(9*b)+(20*c) == n:
                    answer = True
    if answer == True:
        counter = counter + 1
        if counter == 10:
            print 'the largest impossible quantity of nuggets is:', nuggets[-1]
    else:
        nuggets.append(n)
        counter = 0

##Part D

packs=(6, 9, 20)
nuggets=0

for n in range(1, 200):
    answer=False
    for a in range(0,n/6+1):
        for b in range(0,n/9+1):
            for c in range(0,n/20+1):
                if (packs[0]*a)+(packs[1]*b)+(packs[2]*c)==n:
                    answer=True
    if (answer==False):
        if (n>nuggets): nuggets=n
print "Given package sizes "+str(packs[0])+ ', ' +str(packs[1])+  ', and ' +str(packs[2])+", the largest number of McNuggets that cannot be bought in exact quantity is: "+str(nuggets)

# Problem Set 1
# Name: jimmy
# Collaborators: 0
# Time: Atleast 4 days


#Part A

count = 1
prime = 3

while count < 1000:
    divider = prime/2
    
    while divider > 1:
        
        if prime%divider==0:
            prime = prime + 2
            divider = prime / 2
            
        else: divider = divider - 1
        
    count = count + 1
    prime = prime + 2
print "Prime Number", prime-2, "Counter is", count

#Part B

import math

prime=3
counter=1
n=int(raw_input("enter a number "))
sum_logs=math.log(2)
while prime<n:
    divisor=3
    while (divisor<math.sqrt(prime) and prime%divisor <> 0):
        divisor=divisor+2
    if divisor > math.sqrt(prime):
            sum_logs = sum_logs + math.log(prime)
    prime=prime+2
print sum_logs
print prime
ratio=sum_logs/prime
print ratio

# Problem Set 0
# Name: jimmy
# Collaborators: 0
# Time: 00:01:00

firstname = raw_input('Please Enter your first name ')
lastname = raw_input('Please Enter your last name ')
print firstname, lastname