# Problem 1
# 2 6 piece 2 9 piece 1 20 piece for 50 total pieces
# 1 6 piece 5 9 piece for 51 total pieces
# 2 6 piece 2 20 piece for 52 total pieces
# 1 6 piece 3 9 piece 1 20 piece for 53 total pieces
# 6 9 piece for 54 total pieces
# 1 6 piece 1 9 piece 2 20 piece for 55 total pieces

# Problem 2
# any quantity x+6 or greater can be created using 6 packs from the previous count
# example x+7 = x+1 + 6

# Problem 3
def minimum_can_buy(packages):
    largest_num = 0
    for min_set in range(1, 51):
        correct = False
        for i in range(0, min(packages)):
            for a in range(0, ((min_set / packages[0]) + 2)):
                # print a
                for b in range(0, (min_set / packages[1]) + 2):
                    for c in range(0, (min_set / packages[2]) + 2):
                        if packages[0] * a + packages[1] * b + packages[2] * c == i + min_set:
                            correct = True
                            break
                    if correct:
                        break
                if correct:
                    break
            if not correct:
                largest_num = i + min_set
        correct = False
    print "The largest number of McNuggets that cannot be bought in exact quantity is:", largest_num

packages = (7, 12, 20)

minimum_can_buy(packages)

# Problem Set: 2.1
#Task: How to may a given number of McNuggets
#Name: Paulina Kieliba
#Time: 0:10

import numpy as np
from math import *

packages = (6,9,20)   # variable that contains package sizes

for desiredAmount in range (50,56):
	for a in range (0,6):
		for b in range (0,6):
			for c in range (0,6):
				if 6*a+9*b+20*c==desiredAmount:
					print desiredAmount, " : ", a, " packs of 6, ",b, " packs of 9 and ",c, " packs of 20"

#56-61 McNuggets is 50-55 McNuggets + 1 package of 6 McNuggets

#62-65 McNuggets is 50-53 McNuggets + 2 package of 6 McNuggets

# Problem Set: 2.2
#Task: Explain the theorem
#Name: Paulina Kieliba
#Time: 0:02

#If you have found the values from x up to x+5 you can always add 6 to the corresponding value and repeat as many times as you wish

# Problem Set: 2.3
#Task: McNuggets you cannot buy
#Name: Paulina Kieliba
#Time: 0:15

n = 1 # nuggets
x = 0 # counter of the amounts of nuggets that may be bought in exact quantity
solution = 0
while x < 6: # if 6 consecutive amounts of nuggets may be bought in exact quantity, according to the theorem any bigger amount ca also be bought in the exact quantity
    val = False
    for a in range (0,10):
        for b in range (0,10):
            for c in range (0,10):
                if 6*a+9*b+20*c == n:
                    val = True
    if val == True: # the amount may be bought in exact quantity
        x+=1
    else:
        x = 0
        solution = n
    n+=1
print "Largest number of McNuggets that cannot be bought in exact quantity: ", solution

# Problem Set: 2.4
#Task: McNuggets you cannot buy
#Name: Paulina Kieliba
#Time: 0:10

bestSoFar = 0     # variable that keeps track of largest number
                  # of McNuggets that cannot be bought in exact quantity
packages = (6,9,20)   # variable that contains package sizes

for n in range(1, 150):   # only search for solutions up to size 150
	val=False
	for a in range(0,10):
		for b in range(0,10):
			for c in range(0,10):
				if a*packages[0]+b*packages[1]+c*packages[2]==n:
					val=True
	if val==False:
		bestSoFar=n					

print "Given package sizes ", packages[0], packages[1], packages[2] 
print "the largest number of McNuggets that cannot be bought in exact quantity is: ", bestSoFar

# smiller148
# PS2, Problem 3
# Program that finds largest number of McNuggets that cannot be bought in exact quantity
# given package sizes of 6, 9, and 20.

counter=0
for n in range(0,50):
    solution=False
    if counter==6:
        break
    for a in range(0,n+1):
        for b in range(0,n+1):
            for c in range(0,n+1):
                if 6*a + 9*b + 20*c == n:
                    solution=True #Critical part here: must get out of
    if solution:				# nested loop to set up conditional statements.
        counter=counter+1
    else:
        high_candidate=n
        counter=0							  # Must reset counter!
                
print 'Largest number of McNuggets that cannot be bought in exact quantity:', high_candidate,'.'

# smiller148
# PS2, Problem 4
# Program that finds largest number of McNuggets that cannot be bought in exact quantity for package size inputs x,y, z.

            
bestSoFar = 0     # variable that keeps track of largest number
                  # of McNuggets that cannot be bought in exact quantity

packages = (7,8,9)   # variable that contains package sizes

for n in range(1, 150):   # only search for solutions up to size 150
    solution=False
    for a in range(0,n/packages[0]+1):
        for b in range(0,n/packages[1]+1):
            for c in range(0,n/packages[2]+1):
                if packages[0]*a + packages[1]*b + packages[2]*c == n:
                    solution=True
    if solution != True:
        bestSoFar=n
        print bestSoFar # Because it's fun to watch progress!
        
print 'Given package sizes ',packages[0],',',packages[1],', and ',packages[2],', the largest number of McNuggets that cannot be bought in exact quantity is:',bestSoFar,'.'

# This is technically correct as written using n+1 in the ranges for a, b, and c, but it is slow to converge when the range maximum is 150.
# To speed up the search, it helps to limit the ranges to the maximum number of packages per size for given n.

#Problem Set 2
#Name: Chapman
#Collaborators: None
#Time: 1:15



### Part 3 ###


def nuggets (curnum):
    a=0
    b=0
    c=0
    while (6*a)<=curnum:
        while (9*b)<=curnum:
            while (20*c)<= curnum:
                n= (6*a) + (9*b) + (20*c)
                if n==curnum:
                    print a,b,c,n
                    return True
                c += 1
            c=0
            b +=1
        c=0
        b=0
        a +=1


largenum=0
counter=0
curnum=0
while counter<6:             #repeats until 6 consecutive numbers which have exact solutions are found.
    if nuggets(curnum):      #if the number has an exact solution, counter is incremented.    
        counter += 1
    else:                    #else the counter is reset to 0.
        largenum=curnum
        counter=0
    curnum +=1

print 'Largest number of McNuggets that cannot be brought in exact quantity:',  largenum







### Part 4 ###


bestSoFar = 0     
                  
packages = (7,9,20)  #sizes available

small= packages[0]
middle= packages[1]
large= packages[2]
def nuggets (n):             
    a=0
    b=0
    c=0
    while (small*a)<=n:
        while (middle*b)<=n:
            while (large*c)<= n:
                ans= (small*a) + (middle*b) + (large*c)
                if ans==n:
                    print a,b,c,n
                    return True
                c += 1
            c=0
            b +=1
        c=0
        b=0
        a +=1


n=0
bestSoFar=0
counter=0


for n in range (1,150):       #runs the code while n is less than 150
    if nuggets(n):            #if there is an exact solution, the counter is incremented.
        counter += 1
    else:                     #else the counter is reset  
        bestSoFar=n
        counter=0
    n +=1
    if counter ==small:       #when the coutner is equal to the smallest number in packages(), the following result is printed. 
        print 'Given package sizes', small,',', middle, 'and', large, 'the largest number of McNuggets that cannot be brought in exact quantity is:', bestSoFar
        break
  

#problem 1

#6a + 9b + 20c = n

#n   a b c
#---------
#50  2 2 1
#51  1 5 0
#52  2 0 2
#53  1 3 1
#54  3 4 0
#55  1 1 2

#56-61 McNuggets is 50-55 McNuggets + 1 package of 6 McNuggets

#62-65 McNuggets is 50-53 McNuggets + 2 package of 6 McNuggets

#problem 2

#After you find those six values: (x, x+1, x+2, x+3, x+4, x+5) you can add 6 to the corresponding values, e.g.: (x+6, x+1+6, x+2+6, x+3+6, x+4+6, x+5+6)
#and then repeat.

#problem 3

n = 1 #nuggets
x = 0 #x in theorem
ln = 0
while x < 6:
    val = False
    for a in range (0,10):
        for b in range (0,10):
            for c in range (0,10):
                if 6*a+9*b+20*c == n:
                    val = True
    if val == True:
        x += 1
    else:
        x = 0
        ln = n
    n += 1
print "Largest number of McNuggets that cannot be bought in exact quantity: ",ln


#problem 4


bsf=0
x = 6
y = 9
z = 20
for n in range(1,200):
    val = False
    for a in range(0,10):
        for b in range(0,10):
            for c in range(0,10):
                if x*a + y*b + z*c == n:
                    val = True
    if  val == False:
        bsf = n
print "Given package sizes", x,y,z
print "The largest number of McNuggets that cannot be bought in exact quantity is:", bsf

# Problem Set 2 (Part II)
# Name: Rajko Vujic
# Collaborators: CuriousReef website
# Time: A few days


n = 1       #Possible instances of numbers of McNuggets that cannot be purchased exactly
x = 0       #Consecutive values of n that in fact pass the test
largnum = 0 #Largest number of McNuggets that cannot be bought in exact quantity

while x < 6:
    ans = False
    for a in range (0,10):
        for b in range (0,10):
            for c in range (0,10):
                if 6*a+9*b+20*c == n:
                    ans = True
    if ans == True:
        x += 1
    else:
        x = 0
        largnum = n
    n += 1
print "Largest number of McNuggets that cannot be bought in exact quantity: ",largnum


# Problem Set 2 (Part III)
# Name: Rajko Vujic
# Collaborators: CuriousReef website
# Time: A few days


bestSoFar = 0     # variable that keeps track of largest number
                  # of McNuggets that cannot be bought in exact quantity
packages = (6,9,20)   # variable that contains package sizes
x = packages[0]
y = packages[1]
z = packages[2]

for n in range(1,150):
    ans = False
    for a in range(0,10):
        for b in range(0,10):
            for c in range(0,10):
                if x*a + y*b + z*c == n:
                    ans = True
    if  ans == False:
        bestSoFar = n
print "Given package sizes", x,y,z
print "The largest number of McNuggets that cannot be bought in exact quantity is:", bestSoFar

#Diophantine equations



n = 1

sixes = 0
nines = 0
twenties = 0

consecutivenumbers = 0


while consecutivenumbers < 6:
    foundn = False
    if n%6 == 0 or n%9 ==0 or n%20 ==0:  #check for really easy solutions
        #print n, 'is divisible by 6, 9, or 20'
        foundn = True
    else:
        sixes = 0
        while 6*sixes <= n and foundn == False:
            nines = 0
            twenties = 0
            while 9*nines <= n and foundn == False:
                twenties = 0
                while 20*twenties <= n and foundn == False:
                    if n == 6*sixes + 9*nines + 20*twenties:
                        foundn = True
                        #print n, 'was found with', sixes, 'sixes, ', nines, 'nines, and ', twenties, 'twenties'
                    twenties = twenties + 1
                    #print 'twenties is now', twenties
                nines = nines + 1
                #print 'nines is now', nines
            sixes = sixes + 1
            #print 'sixes is now', sixes

    if foundn == False and consecutivenumbers <7:
        consecutivenumbers = 0
        largestn = n
        #print largestn, 'is the largest n'
    else:
        consecutivenumbers = consecutivenumbers + 1
    #print 'consecutivenumbers = ', consecutivenumbers
    n = n + 1

print 'Largest number of McNuggets that cannot be bought in exact quantity:', largestn












#Diophantine equations

n = 1

packages = 6, 9, 20


numberofx = 0
numberofy = 0
numberofz = 0

consecutivenumbers = 0


while consecutivenumbers < packages[0]  and n<200:
    foundn = False
    if n%packages[0] == 0 or n%packages[1] ==0 or n%packages[2] ==0:  #check for really easy solutions
        foundn = True
    else:
        numberofx = 0
        while packages[0]*numberofx <= n and foundn == False:
            numberofy = 0
            numberofz = 0
            while packages[1]*numberofy <= n and foundn == False:
                numberofz = 0
                while packages[2]*numberofz <= n and foundn == False:
                    if n == packages[0]*numberofx + packages[1]*numberofy + packages[2]*numberofz:
                        foundn = True
                    numberofz = numberofz + 1
                numberofy = numberofy + 1
            numberofx = numberofx + 1

    if foundn == False and consecutivenumbers <7:
        consecutivenumbers = 0
        bestsofar = n
    else:
        consecutivenumbers = consecutivenumbers + 1
    #print 'consecutivenumbers = ', consecutivenumbers
    n = n + 1

print 'Given package sizes', packages[0], ',', packages[1], ', and', packages[2], 'the largest number of McNuggets that cannot be bought in exact quantity is:', bestsofar

#**************************************************
# DiophEqu.py
#
# 6.00: Introduction to Computer Science and Programming
#
# By: Fhalo
#
# Date Start: 12-May-2012:1509
#
# Largest number of McNuggets that cannot be bought in exact quantity
# 
# 
#*******************************************************/ 

def nuggets(num):
     for a in range(num/packages[0]+1):
        for b in range(num/packages[1]+1):
            for c in range(num/packages[2]+1):
                if packages[0]*a + packages[1]*b + packages[2]*c == num:
                    return True
        return False

###
### template of code for Problem 4 of Problem Set 2, Fall 2008
###
 
bestSoFar = 0     # variable that keeps track of largest number
                  # of McNuggets that cannot be bought in exact quantity
packages = (6,9,20)   # variable that contains package sizes
iter = 0          # iterator
nope = []         # list to hold impossible combinations

for n in range(1, 150):   # only search for solutions up to size 150
    ## complete code here to find largest size that cannot be bought
    ## when done, your answer should be bound to bestSoFar
    if not nuggets(n):
        nope.append(n)
        iter = 0 # reset iterator if impossible combination found
    else:
        iter += 1
    if iter == packages[0]:
        bestSoFar = nope.pop()
        print "Given package sizes " + str(packages[0]) + ", " + str(packages[1]),
        print "and " + str(packages[2]) + ", the largest number of McNuggets",
        print "that cannot be bought in exact quantity is: " + str(bestSoFar)

##for n in range (50, 55):
##    for a in range (0,10):
##        for b in range (0,10):
##            for c in range (0,10):
##                if (6*a) + (9*b) + (20*c) == n:
##                    print a,b,c,n
##
##
##
##counter=0
##for n in range (1, 50):
##    for a in range (0,10):
##        for b in range (0,10):
##            for c in range (0,10):
##                if (6*a) + (9*b) + (20*c) == n:
##                    counter=counter+1
##
##    if counter==0:
##        number.append(n)
##    
##    if counter>0:
##        counter=0
##print "Largest number of McNuggets that cannot be bought in exact quantity", number[-1]
##
##
##number=[]                        
##small=int(raw_input("Enter a number for the small package "))
##medium=int(raw_input("Enter a number for the medium package "))
##large=int(raw_input("Enter a number for the large package "))  
##counter=0
##for n in range (1, 50):
##    for a in range (0,10):
##        for b in range (0,10):
##            for c in range (0,10):
##                if (small*a) + (medium*b) + (large*c) == n:
##                    counter=counter+1
##
##    if counter==0:
##        number.append(n)
##    
##    if counter>0:
##        counter=0
##        
##print "Given package sizes",small,",",medium,",",large,",","The largest number of McNuggets that cannot be bought in exact quantity is",number[-1]                   
##       
##                  
##               


       
    
                    
                

                    


            
            


                    

#Problem Set 2 (Part I)
#Name: Nick
#Collaborators: None
#Time: 0:30

n=1 #no need to test values less than 6 because they are all impossible
#I could start at a higher number but I don't want to be imporoper
works=1#this variable is so I can leave loops when I find 1 combonation that works
consecutive = 0#this variable is so I can see when to stop the whole loop because
#the rest will all work
while consecutive < 6:#runs until 6 consecutive values that work are found
    a=0
    b=0#resets the values of a, b, and c for every loop
    c=0
    #This section tests each possible combination of a, b, and c to test if 6a+9b+20c = n
    #and if it does, it stops as soon as possible to not waste computing power
    while a <= n/6 and works == 1:
        if 6*a+9*b+20*c == n:
            works = 0

        b = 0 #resets b after every time a increases 1
        while b <= n/9 and works == 1:
            if 6*a+9*b+20*c == n:
                works = 0

            c = 0 #resets c after every time b increase 1
            while c <= n/20 and works == 1:
                if 6*a+9*b+20*c == n:
                    works = 0
                c += 1
            b += 1
        a += 1
    #This section sees if there was a combination that worked, and if so added 1
    #to consecutive and sets works back equal to 1 so that the loop will run
    #else it resets consecutive and saves n to be a possible final answer
    if works == 0:
        consecutive +=1
        works = 1
    else:
        consecutive = 0
        largestImpossible = n
    n += 1#This tests the next n on the next iteration
    #now it loops back to the begining of the while loop
print 'Largest number of McNuggets that cannot be bought in exact quantity:',largestImpossible
#prints answer



#Problem Set 2 (Part II)
#Name: Nick
#Collaborators: None
#Time: 1:00

bestSoFar = 0     # variable that keeps track of largest number
                  # of McNuggets that cannot be bought in exact quantity
x = int(raw_input('First Package Size? '))
y = int(raw_input('Second Package Size? '))
z = int(raw_input('Third Package Size? '))

packages = (x, y, z)   # variable that contains package sizes

if x < y and x < z: smallest = x
elif y < z: smallest = y
else: smallest = z

consecutive = 0#this variable is so I can see when to stop the whole loop because
#the rest will all work

n = 1#initial condition
for n in range (1,200):#Runs until all others will be possible or n = 200
    a=0
    b=0#resets the values of a, b, and c for every loop
    c=0
    #This section tests each possible combination of a, b, and c to test if 6a+9b+20c = n
    #and if it does, it stops as soon as possible to not waste computing power
    for a in range(0,n/packages[0]+1):
        for b in range(0,n/packages[1]+1):
            for c in range(0,n/packages[2]+1):
                if packages[0]*a+packages[1]*b+packages[2]*c == n:
                    break
            if packages[0]*a+packages[1]*b+packages[2]*c == n:
                break
        if packages[0]*a+packages[1]*b+packages[2]*c == n:
            consecutive += 1
            break

                
    #This section sees if there was a combination that worked, and if so added 1
    #to consecutive and sets works back equal to 1 so that the loop will run
    #else it resets consecutive and saves n to be a possible final answer
    else:
        consecutive = 0
        bestSoFar = n
    if consecutive == smallest:
        break

    #now it loops back to the begining of the for loop
if consecutive == smallest:print 'Given package sizes, ' + str(x)+', '+ str(y) + ', and '+ str(z) + ', the largest number of McNuggets that cannot be bought in exact quantity:',bestSoFar
else: print 'Given package sizes, ' + str(x)+', '+ str(y) + ', and '+ str(z) + ', the largest number was not neccessarily found, but the largest less than 200 is:', bestSoFar
#prints answer, if we were cut off by the 200 limit we printed a different answer

### lesson 3 assignment 1
### time started 16:27
### template of code for Problem 4 of Problem Set 2, Fall 2008
###

# Problem 1 find 50, 51, 52, 53, 54, and 55 McNuggets
def ferchick(x):
# set the original number of McNuggets
	a = [6]
	b = [9]
	c = [20]
	for e in range(0, x):
		# multiple the original number in sequence o, 1, 2, ...
		add = a[0] * e
		addb = b[0] * e
		addc = c[0] * e
		# if the new number is larger than X we already know it's false
		if add < x:
			a.append(add)
		if addb < x:
			b.append(addb)
		if addc < x:
			c.append(addc)
	# loop through each value and test to see if it equals X
	for w in a:
		for q in b:
			for y in c:
				if w + q + y == x:
					return str(w/6) + " packages of 6 McNuggets and " + str(q/9) + " packages of 9 McNuggets and " + str(y/20) + " packages of 20 McNuggets equal " + str(x) + " total McNuggets"
					# [x,[w/6,q/9,y/20]]
print "problem 1 McNuggets 50 to 55"
print ferchick(50)
print ferchick(51)
print ferchick(52)
print ferchick(53)
print ferchick(54)
print ferchick(55)
# ferchick(50) = 2 packages of 6 2 packages of 9 1 packages of 20 McNuggets equal 50
# ferchick(51) = 1 packages of 6 5 packages of 9 0 packages of 20 McNuggets equal 51
# ferchick(52) = 2 packages of 6 0 packages of 9 2 packages of 20 McNuggets equal 52
# ferchick(53) = 1 packages of 6 3 packages of 9 1 packages of 20 McNuggets equal 53
# ferchick(54) = 3 packages of 6 4 packages of 9 0 packages of 20 McNuggets equal 54
# ferchick(55) = 1 packages of 6 1 packages of 9 2 packages of 20 McNuggets equal 55
# completed at 17:44 1 hour 20 minutes
print ""
print "problem 1 part two find 56 - 65"
print "56 McNuggets = " + ferchick(50) + " plus 1 package of 6 McNuggets"
print "57 McNuggets = " + ferchick(51) + " plus 1 package of 6 McNuggets"
print "58 McNuggets = " + ferchick(52) + " plus 1 package of 6 McNuggets"
print "59 McNuggets = " + ferchick(53) + " 1 package of 6 McNuggets"
print "60 McNuggets = " + ferchick(54) + " plus 1 package of 6 McNuggets"
print "61 McNuggets = " + ferchick(55) + " plus 1 package of 6 McNuggets"
print "62 McNuggets = " + ferchick(53) + " plus 1 package of 9 McNuggets"
print "63 McNuggets = " + ferchick(54) + " plus 1 package of 9 McNuggets"
print "64 McNuggets = " + ferchick(55) + " plus 1 package of 9 McNuggets"
print "65 McNuggets = " + ferchick(56) + " plus 1 package of 9 McNuggets"
print ""
print "problem 2 if x possible"
print "If it is possible for combinations of 6, 9, and 20 to comprise the numbers from 50 - 65 then any number larger than 50 should hold because any larger number can be calculated using 6, 9, and 20 and a previous smaller number. However the theoreom isn't actually true for smaller numbers, you can for instance buy 6 McNuggets, but not 7 or 8, similarly you can buy 9 McNuggets, but not 10, 11, 12, 13, or 14 McNuggets. The theoreom only holds for larger quantities of McNuggets because we can calculate x + 1 to x + 5 McNuggets and now have the proper space to calculate in."
print ""
print "Problem 3 Solving a Diophantine Equation"

def dio(n):
	unbuy = []
	buy = []
	while True:
		if ferchick(n) == None:
			unbuy.append(n)
			buy = []
			n = n + 1
		if len(buy) > 5:
			print "These are the inexact quanities " + str(unbuy)
			print "These are the 1st new numbers of an amazingly infinite McNugget world.... " + str(buy)
			print "Largest number of McNuggets that cannot be bought in exact quantity: " + str(unbuy[-1])
			break
		else:
			buy.append(n)
			n = n + 1
dio(1)
#43 was the highest number I got
# the exciting infinite world begins at 44
# completed at 23:45 7 hours of fiddling around with other stuff!
# gotta go to a birthday party... will work on problem 4 later.

print ""
print "Problem 4"

bestSoFar = 0     # variable that keeps track of largest number
                  # of McNuggets that cannot be bought in exact quantity
packages = (6,9,20)   # variable that contains package sizes


def packagez(packs):
	a = [packs[0]]
	b = [packs[1]]
	c = [packs[2]]
	bought = []
	boughtsizes = []
	notbought = []
	for n in range(0, 200):
		add = a[0] * n
		addb = b[0] * n
		addc = c[0] * n
		# if the new number is larger than X we already know it's false
		if add < 200:
			a.append(add)
		if addb < 200:
			b.append(addb)
		if addc < 200:
			c.append(addc)
	for x in range(0, 200):
		for w in a:
			for q in b:
				for y in c:
					if w + q + y == x:
						bought.append(x)
						boughtsizes.append(str(w/6) + " packages of 6 McNuggets and " + str(q/9) + " packages of 9 McNuggets and " + str(y/20) + " packages of 20 McNuggets equal " + str(x) + " total McNuggets")
	for d in range(0, 200):
		if d not in bought:
			notbought.append(d)
	return "Given package sizes %s, %s, and %s, the largest number of McNuggets that cannot be bought in exact quantity is: %s" % (packs[0], packs[1], packs[2], max(notbought))

print packagez(packages)
print packagez((8,10,25))
		
		
   # only search for solutions up to size 150
    ## complete code here to find largest size that cannot be bought
    ## when done, your answer should be bound to bestSoFar

#Problem Set 2a
#Michael

a=6
b=9
c=20
candidate=0
bestSoFar=1

for n in range(1,50):
    for i in range(0,n/a+1):
        for j in range(0,n/b+1):
            for k in range(0,n/c+1):
                if a*i+b*j+c*k==n:
                    break
            if a*i+b*j+c*k==n:
                break
        if a*i+b*j+c*k==n:
            break
    if a*i+b*j+c*k==n:
        candidate+=1
    else:
        candidate=0
        bestSoFar=n
    if candidate==6:
        break

print 'Largest number of McNuggets that cannot be bought in exact quantity: '+str(bestSoFar)
        







#Problem Set 2b
#Michael 

bestSoFar = 0     
                  
packages = (2,4,6)   
a=packages[0]
b=packages[1]
c=packages[2]

for n in range(1, 150):   
    for i in range(0,n/a+1):
        for j in range(0,n/b+1):
            for k in range(0,n/c+1):
                if a*i+b*j+c*k==n:
                    break
            if a*i+b*j+c*k==n:
                break
        if a*i+b*j+c*k==n:
            break
    if a*i+b*j+c*k==n:
        candidate+=1
    else:
        candidate=0
        bestSoFar=n
    if candidate==a:
        break

if candidate<a:
    print 'The largest number of McNuggets that cannot be bought in exact quantity is greater than 150.'
else:
    print 'Given package sizes '+str(a)+', '+str(b)+', and '+str(c)+', the largest number of McNuggets that cannot be bought in exact quantity is: '+str(bestSoFar)

        
        
            

##### Assignment 2              #####
#####################################
##### Problem Set 1             #####  
##### Name: Wolfei              #####  
##### Collaborators: Internet   ##### 
##### Time: pending             #####


##    6       9       20
##    12      18      20      50
##    6       45      0       51
##    12      0       40      52
##    24      9       20      53
##    9       0       0       54
##    6       9       40      55
##
##    We can easily derive the next amounts (56....65) like this
##    (12 + 18 + 20) + 6  =  56
##    (6 + 45 + 0 ) + 6   =  57
##    (12 + 0 + 40) + 6   =  58
##    (24 + 9 + 20) + 6   =  59
##    (9 + 0 + 0) +  6    =  60
##    (6 + 9 + 40) + 6    =  61
##
##    Now we use the newly created and add 6 to them as we did with
##    original ones
##
##    [(12 + 18 + 20) + 6] + 6 =  62
##    [(6 + 45 + 0 ) + 6] + 6 =   63
##    [(12 + 0 + 40) + 6] + 6 =   64
##    [(24 + 9 + 20) + 6] + 6 =   65
    

##### Problem Set 2             #####  
##### Name: Wolfei              #####  
##### Collaborators: Internet   ##### 
##### Time: pending             #####

##The theorem is true because once we have found how to create x, x+1, ....x+5
##we can easily find the next combinations of macnuggets that will lead us to
##higher quantities by adding 6 to x, x+1, ...x+5



##### Problem Set 3             #####  
##### Name: Wolfei              #####  
##### Collaborators: Internet   ##### 
##### Time: 3 weeks             #####


def Problem3():
    x = []
    n = 1
    while n < 200+1:
        if lolcakeA(n) or lolcakeB(n) or lolcakeC(n) == 1:
##            print "saving n", n
            n += 1
        else:
##            print "n isnt good", n
            x += [n]
            n += 1

    print "Largest number of McNuggets that cannot be bought in exact quantity is :"
    raw_input()
    print x[-1]


def lolcakeA(x):
    a = 0
    b = 0
    c = 0
     
    for a in range (0,8+1):
        if 6*a+9*b+20*c == x:
            return 1
        else:
            for b in range (0,5+1):
                if 6*a+9*b+20*c == x:
                    return 1
                else:    
                    for c in range (0,3+1):
                        if 6*a+9*b+20*c == x:
                            return 1
    return 0
                            
    
def lolcakeB(x):
    a = 0
    b = 0
    c = 0
   
    for b in range (0,40+1):
        if 6*a+9*b+20*c == x:
            return 1
        else:
            for c in range (0,40+1):
                if 6*a+9*b+20*c == x:
                    return 1
                else:    
                    for a in range (0,40+1):
                        if 6*a+9*b+20*c == x:
                            return 1
    return 0
    
def lolcakeC(x):
    a = 0
    b = 0
    c = 0

    for c in range (0,40+1):
        if 6*a+9*b+20*c == x:
            return 1
        else:
            for a in range (0,40+1):
                if 6*a+9*b+20*c == x:
                    return 1
                else:    
                    for b in range (0,40+1):
                        if 6*a+9*b+20*c == x:
                            return 1
    return 0


##### Problem Set 4             #####  
##### Name: Wolfei              #####  
##### Collaborators: Internet   ##### 
##### Time: pending             #####

def Problem4():
    
    
    lista = []
    n = 1
    x = input(" tell me the lowest number:  ")
    y = input(" tell me the number in the middle:  ")
    z = input(" tell me the highest number:  ")
    packages = (x, y, z)
    while n < 200+1:
        if lolcakeA2(n,x,y,z) or lolcakeB2(n,x,y,z) or lolcakeC2(n,x,y,z) == 1:
            n += 1
        else:
            lista += [n]
            n += 1

    print ""
    print "Given package sizes",  x , y, "and",  z, 
    print "the largest number of McNuggets that cannot be bought in exact quantity is:", lista[-1] 
      
        

def lolcakeA2(n, x, y, z):
    """ n = number you want to check,  [xyz] are number of packages of McNuggets"""
    x = 0
    y = 0
    z = 0
     
    for x in range (0,40+1):
        if 6*x+9*y+20*z == n:
            return 1
        else:
            for y in range (0,40+1):
                if 6*x+9*y+20*z == n:
                    return 1
                else:    
                    for z in range (0,40+1):
                        if 6*x+9*y+20*z == n:
                            return 1
    return 0

def lolcakeB2(n, x, y, z):
    """ n = number you want to check,  [xyz] are number of packages of McNuggets"""
    x = 0
    y = 0
    z = 0
     
    for y in range (0,40+1):
        if 6*x+9*y+20*z == n:
            return 1
        else:
            for z in range (0,40+1):
                if 6*x+9*y+20*z == n:
                    return 1
                else:    
                    for x in range (0,40+1):
                        if 6*x+9*y+20*z == n:
                            return 1
    return 0

def lolcakeC2(n, x, y, z):
    """ n = number you want to check,  [xyz] are number of packages of McNuggets"""
    x = 0
    y = 0
    z = 0
     
    for z in range (0,40+1):
        if 6*x+9*y+20*z == n:
            return 1
        else:
            for x in range (0,40+1):
                if 6*x+9*y+20*z == n:
                    return 1
                else:    
                    for y in range (0,40+1):
                        if 6*x+9*y+20*z == n:
                            return 1
    return 0

#Rob Carmichael
#Problem Set 2

#Problem 1

##a=6
##b=9
##c=20
##
##for n in range(50,56):
##    for d in range(0,n/a+1):
##        for e in range(0,n/b+1):
##            for f in range(0,n/c+1):
##                if a*d+b*e+c*f==n:
##                    print "a*%d+b*%d+c*%d==%d" % (d,e,f,n)
##
# Not sure how to exit for loops after we initially solve the equation.
# As is the program continues to iterate.

#Problem 2
# Theorem is true because if you can buy nuggets in six consecutive integers,
# then you can just buy a multiple of six for any of those numbers.


#Problem 3

##a=6
##b=9
##c=20
##cantget=[]
##consecutivepasses=0
##
##for n in range(1,150):
##    test = False
##    if consecutivepasses==6:
##        break
##    for d in range(0,n):
##        for e in range(0,n):
##            for f in range(0,n):
##                if a*d+b*e+c*f==n:
##                    test = True
##    if test:
##        consecutivepasses +=1
##    if not test:
##        bestsofar=n
##        cantget.append(n)
##        consecutivepasses = 0
##print "Largest number of McNuggets that cannot be bought in exact quantity: "\
##, str(bestsofar)+"."
##print "Here's the set of numbers of nuggets you can\'t get at McDonalds: ", cantget,'.'
##print consecutivepasses
                    
#Problem 4

### template of code for Problem 4 of Problem Set 2, Fall 2008
###

    # variable that keeps track of largest number
                  # of McNuggets that cannot be bought in exact quantity
   # variable that contains package sizes
  # only search for solutions up to size 150
    ## complete code here to find largest size that cannot be bought
    ## when done, your answer should be bound to bestSoFar

def numberNuggets(x,y,z):
    bestSoFar = 0
    packages = (x,y,z)
    consecutive = 0
    for n in range(1,150):
        if consecutive==min(packages):
            break
        test=False
        for d in range(0,n):
            for e in range(0,n):
                for f in range(0,n):
                    if x*d+y*e+z*f==n:
                        test=True
        if test:
            consecutive+=1
        else:
            bestSoFar=n
            consecutive=0
    print "Given package sizes %d, %d, and %d, the largest number of McNuggets that cannot be bought \
in exact quantity is: %d." % (x,y,z,bestSoFar)


    
   

#!/usr/local/bin/python

##	Problem 1.
	##	Show that it is possible to buy exactly 50, 51, 52, 53, 54, and 55 McNuggets, by finding solutions to the Diophantine equation. You can solve this in your head, using paper and pencil, or writing a program. However you chose to solve this problem, list the combinations of 6, 9 and 20 packs of McNuggets you need to buy in order to get each of the exact amounts.  Given that it is possible to buy sets of 50, 51, 52, 53, 54 or 55 McNuggets by combinations of 6, 9 and 20 packs, show that it is possible to buy 56, 57,..., 65 McNuggets. In other words, show how, given solutions for 50-55, one can derive solutions for 56-65.  If it is possible to buy x,x+1,...,x+5 sets of McNuggets,for some x,then it is possible to buy any number of McNuggets >= x, given that McNuggets come in 6, 9 and 20 packs.

	##	6a + 9b + 20c = n
	##	6a = n - 9b -20c 
	##	a = n/6 - 3/2b - 10/3c
	
	# 49 = (2*20) + (0*6) + (1*9)  # just curious
	# 50 = (1*20) + (2*6) + (2*9)
	# 51 = (0*20) + (4*6) + (3*9)
	# 52 = (2*20) + (2*6) + (0*9)
	# 53 = (1*20) + (1*6) + (3*9)
	# 54 = (0*20) + (0*6) + (6*9)
	# 55 = (2*20) + (1*6) + (1*9)
##------
	# 56 = (1*20) + (3*6) + (2*9)
	# 57 = (0*20) + (4*6) + (3*9)
	# 58 = (2*20) + (3*6) + (0*9)
	# 59 = (1*20) + (2*6) + (3*9)
	# 60 = (0*20) + (1*6) + (6*9)
	# 61 = (2*20) + (2*6) + (1*9)
	# 62 = (1*20) + (4*6) + (2*9)
	# 63 = (0*20) + (6*6) + (3*9)
	# 64 = (2*20) + (4*6) + (0*9)
	# 65 = (1*20) + (3*6) + (3*9)
	
#	Problem 2: Explain, in English, why this theorem is true.
## For this type of problem, if you can find a string of sequential numbers that is as long as the smallest counting unit then you can count to any subsequent number by adding this smallest counting unit a member of this base sequential series. Wow. 


# Problem 3
#
	#	Write an iterative program that finds the largest number of McNuggets that cannot be bought in exact quantity. Your program should print the answer in the following format (where the correct number is provided in place of <n>):

#	largest number of McNuggets that cannot be bought in exact quantity:
	#	Hint: your program should follow the outline above.
	#	Hint: think about what information you need to keep track of as you loop through possible ways of buying exactly n McNuggets. This will guide you in deciding what state variables you will need to utilize.
	#	Save your code for Problem 3 in ps2a.py.



#	Using this theorem, we can write an exhaustive search to find the largest number of McNuggets that cannot be bought in exact quantity. The format of the search should probably follow this outline:
#	Hypothesize possible instances of numbers of McNuggets that cannot be purchased exactly, starting with 1
#For each possible instance, called n,
	#Test if there exists non-negative integers a, b, and c, such that 6a+9b+20c = n. (This can be done by looking at all feasible combinations of a, b, and c) 
	#If not, n cannot be bought in exact quantity, save n
#	When you have found six consecutive values of n that in fact pass the test of having an exact solution, the last answer that was saved (not the last value of n that had a solution) is the correct answer, since you know by the theorem that any amount larger can also be bought in exact quantity

print 'Problem 3'
print

def is_n_solveable(n):
	a = 0
	b = 0
	c = 0
	for a in range(10):
		#print 'in a for loop. a:', a,'b:',b,'c:',c,'n:',n
		if 6*a + 9*b + 20*c == n:
			return 1
			#ns_passed_test.append(n)
			#print n, "passed"	
		for b in range(10):
			#print 'in b for loop. a:', a,'b:',b,'c:',c,'n:',n
			if 6*a + 9*b + 20*c == n:
				return 1
				#ns_passed_test.append(n)
				#print n, "passed"
			for c in range(10):
				#print 'in c for loop. a:', a,'b:',b,'c:',c,'n:',n
				if 6*a + 9*b + 20*c == n:
					return 1
					#ns_passed_test.append(n)
					#print n, "passed"
	return 0

counter = 0
highest_number_to_test = 43

for n in range(highest_number_to_test+7):
	if is_n_solveable(n):
		counter = counter + 1
	else:
		counter = 0

	if counter == 6:
		print n-6, "is highest number of nuggets that can not be ordered in a 6,9,20 combo."
	elif n == highest_number_to_test+7:
		print 'The highest number of noggest that cannot be ordereed in a in 6,9,20 combo is greater than', highest_number_to_test

print 
print 'End of problem 3'
print 

##	Problem 4.
##	Assume that the variable packages is bound to a tuple of length 3, the values of which specify the sizes of the packages, ordered from smallest to largest. Write a program that uses exhaustive search to find the largest number (less than 200) of McNuggets that cannot be bought in exact quantity. We limit the number to be less than 200 (although this is an arbitrary choice) because in some cases there is no largest value that cannot be bought in exact quantity, and we don't want to search forever. Please use ps2b_template.py to structure your code.
##	Have your code print out its result in the following format:
##	"Given package sizes <x>, <y>, and <z>, the largest number of McNuggets that cannot be bought in exact quantity is: <n>"

##	Test your program on a variety of choices, by changing the value for packages. Include the case (6,9,20), as well as some other test cases of your own choosing.

##	This problem took 4-5 hours over the course of a couple days.

print 'Problem 4'
print 

packages = (6, 9, 20)

def is_n_solveable(n,packages):
	"""Takes a value n and a 3-member tuple.  The tuple describes the three package size, e.g., 6, 9, 20 McNuggets. The function tests whether any combination of the packages will add up to exactly n."""

	a = 0
	b = 0
	c = 0
	for a in range(10):
		#print 'in a for loop. a:', a,'b:',b,'c:',c,'n:',n
		if packages[0]*a + packages[1]*b + packages[2]*c == n:
			return 1
			#ns_passed_test.append(n)
			#print n, "passed"	
		for b in range(10):
			#print 'in b for loop. a:', a,'b:',b,'c:',c,'n:',n
			if packages[0]*a + packages[1]*b + packages[2]*c == n:
				return 1
				#ns_passed_test.append(n)
				#print n, "passed"
			for c in range(10):
				#print 'in c for loop. a:', a,'b:',b,'c:',c,'n:',n
				if packages[0]*a + packages[1]*b + packages[2]*c == n:
					return 1
					#ns_passed_test.append(n)
					#print n, "passed"
	return 0

counter = 0	

x = 6
y = 9
z = 20

for n in range(100):
	if is_n_solveable(n, packages):
		counter = counter + 1
	else:
		counter = 0
	if counter == packages[0]:
		print 'Given package sizes', packages[0], ',', packages[1], ', and', packages[2], 'the largest number of McNuggets that cannot be bought in exact quantity is:', n-packages[0]
print		
print 'end of Problem 4'
print 

		
print 'Problem 4.1: the prescribed format.'

bestSoFar = 0     # variable that keeps track of largest number
                  # of McNuggets that cannot be bought in exact quantity

packages = (6,9,20)   # variable that contains package sizes
packages_1 = (16,19,20)   # variable that contains package sizes
packages_2 = (7,15,20)   # variable that contains package sizes
packages_3 = (9,12,20)   # variable that contains package sizes
packages_4 = (11,16,20)   # variable that contains package sizes
packages_5 = (4,9,16)   # variable that contains package sizes

six_packages = (packages,packages_1,packages_2,packages_3,packages_4,packages_5)
packages_to_test = len(six_packages)

def is_n_solveable(n,packages):
	"""Takes a value n and a 3-member tuple.  The tuple describes the three package size, e.g., 6, 9, 20 McNuggets. The function tests whether any combination of the packages will add up to exactly n."""
	a = 0	# Initialize the multiples of each package size.
	b = 0
	c = 0
	for a in range(10):
		# print 'in a for loop. a:', a,'b:',b,'c:',c,'n:',n
		# print packages[0]
		
		if packages[0]*a + packages[1]*b + packages[2]*c == n:
			return 1
			#ns_passed_test.append(n)
			#print n, "passed"	
		for b in range(10):
			#print 'in b for loop. a:', a,'b:',b,'c:',c,'n:',n
			if packages[0]*a + packages[1]*b + packages[2]*c == n:
				return 1
				#ns_passed_test.append(n)
				#print n, "passed"
			for c in range(10):
				#print 'in c for loop. a:', a,'b:',b,'c:',c,'n:',n
				if packages[0]*a + packages[1]*b + packages[2]*c == n:
					return 1
					#ns_passed_test.append(n)
					#print n, "passed"
	return 0

	
def test_multiple_pack_combos(packages):
	"""This function takes a tuple of tuples and tests each tuple to see what is the highest number of nuggets that cannot be exactly purchased by the packages sizes described in the tuples."""
	for n in range(1, 150):   # only search for solutions up to size 150
		## complete code here to find largest size that cannot be bought
		## when done, your answer should be bound to bestSoFar
		
		
		if is_n_solveable(n, packages):
			bestSoFar = bestSoFar + 1
		else:
			bestSoFar = 0
		
		if bestSoFar == packages[0]:
			print 'Given package sizes', packages[0], ',', packages[1], ', and', packages[2], 'the largest number of McNuggets that cannot be bought in exact quantity is:', n-packages[0]
			
for each in range(packages_to_test-1):
	#	print six_packages[each]
	test_multiple_pack_combos(six_packages[each])

# Problem set 2.1a
# Shemmerson

# Show that it is possible to buy exactly 50, 51, 52, 53, 54, and 55 McNuggets, by finding
# solutions to the Diophantine equation.

a = 6
b = 9
c = 20

for n in range(50, 56):
    for d in range(0, n):
        for e in range(0, n):
            for f in range(0, n):
                if a*d + b*e + c*f == n:
                    print d, 'a', '+', e, 'b', '+', f, 'c', '=', n

# Substitute 

#                   for x in range (56, 66):
#                        if n + a == x:
#                           print n, '+', a, '=', x
#                       if n + b == x:
#                            print n, '+', b, '=', x

# for 

#                print d, 'a', '+', e, 'b', '+', f, 'c', '=', n

# To use given solutions to solve range (55, 66)





# Problem set 2.1b
# Shemmerson

# Once the equation is satisfied for x, x +1 ....x +5 then all further answers are 
# multiples of the same values.



# Problem set 2.3
# Shemmerson

# Shows largest number of nuggets that cannot be bought in an exact quantity. 

nugget=[]
ctr=0
n=0


for n in range (1,50): 
    test = False 
    for d in range (0,n):  
        for e in range (0,n):
            for f in range (0,n):
                if (6*d) + (9*e) + (20*f) == n:
                    test = True
                


    if test == True:
        ctr +=1
        if ctr > 5:
            print "Largest exact quantity is",nugget[-1]
    else:
        nugget.append(n)
        ctr = 0


# Problem set 2.4
# Shemmerson

# Same as above with added user control over values 

bestSoFar = []
packages = (6,9,20)
ctr = 0
n=0

for n in range(1, 100): 
    test = False
    for a in range(0,n):
        for b in range(0,n):
            for c in range(0,n):
                if (packages[0]*a) + (packages[1]*b) + (packages[2]*c) == n:
                    test = True


    if test == True:
        ctr += 1
        if ctr == 6:
            print bestSoFar[-1], "is the largest quantity not purchasable in 6,9,20 packages"
            print "............................................................"
            print "Enter your own quantities to find largest quantity not divisable:"
            bestSoFar2 = []
            ctr1 = 0
            n1=0
            x = int(raw_input ("First: "))
            y = int(raw_input ("Second: "))
            z = int(raw_input ("Third: "))
            packages = (x,y,z)
            for n1 in range(1, 50): 
                test = False
                for a in range(0,n1):
                    for b in range(0,n1):
                        for c in range(0,n1):
                            if (packages[0]*a) + (packages[1]*b) + (packages[2]*c) == n1:
                                test = True


                if test == True:
                    ctr1 += 1
                    if ctr1 == 6:
                        print bestSoFar2[-1], "is the largest exact quantity not purchasable in", + x, ",", y, "and/or", z, "packages"
                        

                else:
                    bestSoFar2.append(n1)
                    ctr1 = 0
    else:
        bestSoFar.append(n)
        ctr = 0

#PS 2.1
#Jill Ann

Where sets of 6-McNuggets = a,
  and sets of 9-McNuggets = b,
  and sets of 20-McNuggets = c,

for:
        n = 50: a=2, b=2, c=1
        n = 51: a=4, b=3, c=0
        n = 52: a=2, b=0, c=2
        n = 53: a=1, b=3, c=1
        n = 54: a=0, b=6, c=0
        n = 55: a=1, b=1, c=2


#PS 2.2
#Jill Ann

        
Where the smallest possible number McNuggets in a single box is "a", any sequence of total (n) McNuggets n, n+1, ... until n+a allows purchase of any infinite exact numbers of McNuggets beyond the given n.
If a bunch of combinations are possible, and the difference between the smallest total transfatpacks and largest total transfatpacks in the combinations is the size of the smallest box, adding the smallest box to each subsequent combination will repeat the "flush" of possible patty combinations to infinity and beyond!


#PS 2.3
#Jill Ann

testnumber=1
countconsecutive=0
while countconsecutive<=6:
        match=False
        for samplea in range(0,testnumber):
                for sampleb in range(0,testnumber):
                        for samplec in range(0,testnumber):
                                if 6*samplea + 9*sampleb + 20*samplec == testnumber:
                                        match=True
                                        print `testnumber` + " matches with a=" + `samplea` + ", and b=" + `sampleb` + ", and c=" + `samplec`
                                        testnumber+=1
        if match == True:
                countconsecutive+=1
        if match == False:
                print `testnumber` + " is not a match"
                highestunmatched = testnumber
                testnumber +=1
                countconsecutive=0
print `highestunmatched` + " is the largest number of McNuggets that cannot be bought in exact quantity."

smallest=raw_input("How many McNuggets are in the smallest box you can buy? ")
medium=raw_input("How many McNuggets are in the 2nd smallest box you can buy? ")
largest=raw_input("How many McNuggets are in the largest box you can buy? ")


McDsizes = ( smallest, medium, largest )
a = int(McDsizes [0])
b = int(McDsizes [1])
c = int(McDsizes [2])
print a, b, c

testnumber=1
countconsecutive=0
while countconsecutive<=a:
        if testnumber < 200:
                match=False
                for samplea in range(0,testnumber):
                        for sampleb in range(0,testnumber):
                                for samplec in range(0,testnumber):
                                        if a*samplea + b*sampleb + c*samplec == testnumber:
                                                match=True
                                                #print `testnumber` + " matches with a=" + `samplea` + ", and b=" + `sampleb` + ", and c=" + `samplec`
                                                testnumber+=1
                if match == True:
                        countconsecutive+=1
                if match == False:
                        #print `testnumber` + " is not a match"
                        highestunmatched = testnumber
                        testnumber +=1
                        countconsecutive=0
print `highestunmatched` + " is the largest number of McNuggets that cannot be bought in an exact quantity."

#Problem Set 2
#Name: Andrew
#Time: 3-5 hours
#Collaborators: Curious Reef

def getCombination(n): #returns a dictionary of combinations for a quantity of n chicken nuggets if you can only get them in units of 6, 9, and 20.
    numOfCombos = 0
    combos = {}
    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 (a*6) + (b * 9) + (c * 20) == n:
                    print "a = ",a," b = ",b, " c = ",c, " n = ", n
                    numOfCombos += 1
                    combos["a"+str(numOfCombos)] = a
                    combos["b"+str(numOfCombos)] = b
                    combos["c"+str(numOfCombos)] = c
                    combos["n"+str(numOfCombos)] = n
    return combos

def middle(v1,v2,v3): ##returns the middle value for a set of three numbers
    nums = []
    smallest = min(v1,v2,v3)
    largest = max(v1,v2,v3)

    nums = [smallest, largest]

    if not v1 in nums:
        return v1
    elif not v2 in nums:
        return v2
    else:
        return v3
    
def newGetCombo(n, v1,v2,v3): ##for problem number four. built upon the first getCombination() function.
    numOfCombos = 0
    combos = {}
    for a in range(0, n/min(v1,v2,v3) + 1):
        for b in range(0, n/middle(v1,v2,v3) + 1):
            for c in range(0, n/max(v1,v2,v3) + 1):
                if (a*v1) + (b * v2) + (c * v3) == n:
                    print "a = ",a," b = ",b, " c = ",c, " n = ", n
                    numOfCombos += 1
                    combos["a"+str(numOfCombos)] = a
                    combos["b"+str(numOfCombos)] = b
                    combos["c"+str(numOfCombos)] = c
                    combos["n"+str(numOfCombos)] = n
    return combos

def problemOne():
    for n in range(50,56):
        getCombination(n)

def problemThree():
    for i in range(1,1000):
        if len(getCombination(i)) > 0:
            for j in range(1,6):
                if len(getCombination(i+j)) > 0:
                    if j == 5:
                        print "Largest number of McNuggets that cannot be bought in exact quantity: %d" % (i-1)
                        return i-1
                else:
                    i += j+1
                    break

def problemFour():
    print "Give me three McNugget sizes: " 
    v1 = input()
    v2 = input()
    v3 = input()
    for i in range(1,150):
        if len(newGetCombo(i,v1,v2,v3)) > 0:
            for j in range(1,min(v1,v2,v3)):
                if len(newGetCombo((i+j),v1,v2,v3)) > 0:
                    if j == min(v1,v2,v3)-1:
                        print "Largest number of McNuggets that cannot be bought in exact quantity: %d" % (i-1)
                        return i-1
                else:
                    i += j+1
                    break

def main():
##    problemOne()
##    problemThree()
    problemFour()

if __name__ == "__main__":
    main()

# Problem Set 2
# Name: Hans Jacob T. Stephensen (Dith)
# Collaborators: None
# Time: XX:XX (But I've used far more than I feel I should)
# Problem ps2a.py

def nuggets(lower_limit, upper_limit):
    '''Calculate possible solutions for the Diophantine Equation of:
       "n = a*6 + b*9 + c*20" (using "exhausting enumeration")
       where n is defined by the lower and upper limit
       returns True or False if a solution is found'''
    # Checks for parameters that wouldn't yield useful results
    assert lower_limit <= upper_limit, 'the lower limit lies above the upper limit'
    assert type(lower_limit*upper_limit) == int, 'an input value is not an integer'
    assert lower_limit >= 0 and upper_limit >= 0, 'an input value is negative'
    result = False
    # Bruteforcing the three valiables by enumeration attempts, trying every possibility.
    # Dividing by 6 to get worst case scenario and to improve efficiency
    for c in range(int(upper_limit/20)+1):
        for b in range(int(upper_limit/9)+1):
            for a in range(int(upper_limit/6)+1):
                n = 6*a+9*b+20*c
                if n >= lower_limit and n <= upper_limit:
                    print 'Succes n =', n, 'With values a =', a, 'b =', b, 'c =', c
                    result = True
    print 'done'
    if result == False:
        print 'No solutions between:', lower_limit, 'and', upper_limit
        return True
    else: return False

def test_a():
    '''It't a test for the nuggets function'''
    raw_input("Testing 50 to 55")
    nuggets(50,55) #base test 1
    raw_input("Testing 56 to 65")
    nuggets(56,65) #base test 2
    raw_input("Testing 16 to 17")
    nuggets(16,17) #base test with no results
    raw_input("")
    nuggets(120,121)
    raw_input("")

test_a()

# Problem ps2b.py

def nuggets_b(nu):
    '''finds the highest value of n which lower than input value in:
    "n = 6*a + 9*b + 20*c" by use of exhausting enumeration.
    Note that values higher than 200 takes some seconds'''
    n = abs(int(nu))
    result = True
    # Checks for parameters that wouldn't yield useful results
    if type(nu) != int:
        print 'value not integer! Converting:', nu, 'to the integer of:', n
    if nu < 0:
        print 'value is not positive! Using absolute value'
    while result:
        res = 0 
        for c in range(int(n/20)+1):
            for b in range(int(n/9)+1):
                for a in range(int(n/6)+1):
                    num = 6*a+9*b+20*c
                    if num == n:
                        res += 1
                        #Edited out: print 'Solution for n =', n, 'found!'
        if res == 0:
            result = False
            print 'No solutions for n =', n, 'below the value of', nu
        n -= 1

nuggets_b(200)

def test_b():
    '''It't a test for the nuggets function'''
    raw_input("")
    nuggets_b(50) 
    raw_input("")
    nuggets_b(55.5) 
    raw_input("")
    nuggets_b(30)
    raw_input("")
    nuggets_b(-50)
    raw_input("")

test_b()

#Problem Set 2 (Part I)
#Name: mattb
#Time: 00:10
#Collaborators: Curious Reef

for n in range (50,55):
    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:
                    print a,'a', ' + ',b,'b', '+', c,'c = ', n

# Problem Set 2 (Part II)
# Name: mattb
# Collaborators: Curious Reef
# Time: 5 minutes

#All values greater than x + 5 can be attained
#by adding multiples of 6 to the appropriate value in
#the range x, x + 1,... x + 5

# Problem Set 2 (Part III)
# Name: mattb
# Collaborators: Curious Reef
# Time: 2:00

maxn = 6
ncount = 0
n = 7
while ncount < 6:
    n += 1
    ans = 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:
                    ans = True
    if ans:
        ncount += 1
    else:
        ncount = 0
        maxn = n
        print maxn                   
print 'Largest number of McNuggets that \
cannot be bought in exact quantity: ',  maxn

# Problem Set 2 (Part IIII)
# Name: mattb
# Collaborators: Curious Reef
# Time: 20 mins

x = int(raw_input('x = '))
y = int(raw_input('y = '))
z = int(raw_input('z = '))

packages = (x,y,z)

maxn = 0
ncount = 0
n = 0
while ncount < 6 and n <200:
    n += 1
    ans = False
    for a in range(0,n/packages[0] + 1):
        for b in range(0,n/packages [1] + 1):
            for c in range(0,n/packages [2] + 1):
                if (x*a)+(y*b)+(z*c) == n:
                    ans = True
    if ans:
        ncount += 1
    else:
        ncount = 0
        maxn = n
        print maxn                   
print 'Given package sizes ', packages,' the largest \
number of McNuggets that cannot be bought in exact quantity is: ',  maxn

# Problem 3

# mcdio takes an integer, num, and determines if it has a solution
# to the equation 20a + 9b + 6c = num. If it does, it returns True.
# If not, it returns nothing.
def mcdio(num):
    for i in range(0,num/20+1):
        for j in range(0,num/9+1):
	    for k in range(0,num/6+1):
	        if 20*i + 9*j + 6*k == num:
		    return True
		    print i,j,k
		    break

# mcdioSoln starts at 0 and tests every integer x to determine
# if there is a solution to 20a + 9b + 6c = x. When 5 consecutive
# x's are found such that there is a solution to the equation, it
# returns the last x such that there is no such solution.
def mcdioSoln():
    num = 0
    cons = 0
    bestFound = 0
    while cons < 6:
        num += 1
        if mcdio(num) == True:
	    cons += 1
	else:
	    cons = 0
	    bestFound = num
    return bestFound



# Problem 4

# gen_mcdio will be called by gen_mcdio_search to determine if the
# current number being tested by gen_mcdio_search has a solution
# for the given a,b,c.
def gen_mcdio(a,b,c,n):
    for i in range(0,n/c+1):
        for j in range(0,n/b+1):
	    for k in range(0,n/a+1):
	        if c*i + b*j + a*k == n:
	            return True

# gen_mcdio_search iterates through the positive integers less than
# 200 and calls gen_mcdio to test if a number has a solution.
def gen_mcdio_search(num1,num2,num3):
    cons = 0
    bestFound = 0
    while cons < 6:
        for n in range(0,200):
	    n += 1
            if gen_mcdio(num1,num2,num3,n):
	        cons += 1
	    else:
	        cons = 0
		bestFound = n
    return bestFound

# Example:
gen_mcdio_search(5,8,10)  # returns 27

  4 # Problem Set 2
  5 # Problem #1
  6 # Gio
  7 #
  8 def mcnugget(n):
  9     a = 6
 10     b = 9
 11     c = 20
 12     for x in range(0, n):
 13         for y in range(0, n):
 14             for z in range(0, n):
 15                     if a*x + b*y + c*z == n:
 16                         #print x, y, z
 17                         return True
 18     return False
 19 
 20 #print mcnugget(50)
 21 
 22 
 23 #Problem 3
 24 def largest_mcnugget():
 25     n = 1
 26     while n < 100:
 27         if not mcnugget(n):
 28             new_n = n
 29         n += 1
 30     print 'Largest number of McNuggets that cannot be bought in exact quantity: %d' % new_n
 31 
 32 largest_mcnugget()

#########################################

 13 # Problem Set 2
 14 # Problem 4
 15 # Gio
 16 packages = (5, 11, 19)
 17 
 18 def mcnuggets(n):
 19     a = packages[0]
 20     b = packages[1]
 21     c = packages[2]
 22     for x in range(0, n):
 23         for y in range(0, n):
 24             for z in range(0, n):
 25                 if a*x + b*y + c*z == n:
 26                    # print x, y, z
 27                     return True
 28     return False
 29 
 30 #print mcnuggets(55)
 31 
 32 # Problem 3
 33 def largest_mcnuggets():
 34    # bestSoFar = 0
 35     for n in range(1, 200):
 36         if not mcnuggets(n):
 37             bestSoFar = n
 38     print 'Given package sizes %r, %r, and %r, the largest number of McNuggets\nThat cannot be bought in exact quantity is: %r' % (packages[0], packages[1], packages[2], bestSoFar)
 39 
 40 largest_mcnuggets()

#Problem Set 2
#Name: Nick
#Time: 00:10
#Collaborators: None

#Problem 1
region = range(50, 55)

for a in range (0, 20):
        for b in range(0,20):
                for c in range(0,20):
                        k = 6 * a + 9 * b + 20 * c;
                        if k in region:
                                print("{0:2}*6 + {1}*9 + {2}*20 = {3}".format(a,b,c,k));

#       2*6 + 2*9 + 1*20 = 50
#       5*6 + 1*9 + 0*20 = 51
#       2*6 + 0*9 + 2*20 = 52
#       1*6 + 3*9 + 1*20 = 53   
#       9*6 + 0*9 + 0*20 = 54
#       1*6 + 1*9 + 2*20 = 55

#Problem 2
"""
        Theorem is true because when we had all x, x+1,..., x+5 all next steps will repeat.
        For example if we has 54 nugets we can add 6 and get 60 or 51 + 6 =57.
        This works for any x, ...,  x+5 values
"""

#Problem 3
def can_buy(n, ax, bx, cx):
        for a in range(0,20):
                for b in range(0,20):
                        for c in range(0,20):
                                k = ax * a + bx * b + cx * c
                                if k == n:
                                        return True
        return False

def solve(a,b,c):
        count = 0
        for n in range(1,200):
                if not can_buy(n,a,b,c):
                        ans = n
                        count = 0
                else:   count += 1
                if count == 6:  break
        print("Given package sizes <{0}>, <{1}>, <{2}>, the largest number of McNuggets that cannot be bought in exact quantity is: {3}".format(a,b,c,ans))


solve(6,9,20)

#Problem 4
solve(10,14,15)

##x = input('Please enter number of nuggets you would like ')



packages = input('Input list of package sizes [a,b,c] ')

vec_len = len(packages)

abc_vars_limit = range(1,vec_len+1)


x = 0
limit = 100
num_n_log = []

while x < limit:


    m = 0
    while m < vec_len:
        abc_vars_limit[m] = x/packages[m]
        m += 1 

    ##print abc_vars_limit

    a = range(0,abc_vars_limit[0]+1)
    b = range(0,abc_vars_limit[1]+1)
    c = range(0,abc_vars_limit[2]+1)

    ##print a
    ##print b
    ##print c

    a2 = []
    b2 = []
    c2 = []
    abc = []

    for i in a:
        for j in b:
            for k in c:         
                if x == packages[0]*a[i]+packages[1]*b[j]+packages[2]*c[k]:
                  a2 = a2 + [i]
                  b2 = b2 + [j]
                  c2 = c2 + [k]

    if a2 == [] and b2 == [] and c2 == []:
    
     num_n_log = num_n_log + [x]
##    print a2
##    print b2
##    print c2
##    print num_n_log
    x += 1
## 
##
##
##
print 'These numbers cannot be bought in exact quantity'
print num_n_log
 
s = 'Given package sizes ' + repr(packages[0])+ ' ' + repr(packages[1]) + ' and ' + repr(packages[2]) + ' the largest number of McNuggets that cannot be bought in exact quantity is: ' + repr(num_n_log[-1])
print s 

##problem2
##since we can buy nuggets in x, x +1, x+5,
##in packs of 6,9,20. Which means that any large enough of ##amounts  of nuggets can be bought with these sizes of ##packs  as long as the first six continuous amount of ##nuggets set are established, as the 7th nugget is just ##6more than the first nugget and the 8th is 6 more than the ##2 nugget of that set
##and so on..... 









##PROBLEM 3




notreachable=[]
counter=0
n=0
for n in range (6,100):
    ans = False
    for s in range (0,n+1):
        for m in range (0,n+1):
            for l in range (0,n+1):
                if (6*s) + (9*m) + (20*l) == n:
                    ans = True
                


    if ans:
        counter +=1
        if counter == 6:
            print ("Largest number of McNuggets that cannot be bought in exact quantity:  ",notreachable[-1])
    else:
        notreachable.append(n)
        counter = 0




##problem 4
package = (13,17,19)
notreachable = 0
counter = 0
n = 0
for n in range (n, 200):
    ans = False
    for s in range (0, n+1):
        for m in range (0, n+1):
            for l in range (0,n+1):
                if ((s*package[0]) + (m*package[1]) + (l*package[2]) == n):
                    ans = True    
                
                    
    


    if ans:
        counter+=1
        if package[0] == counter:
            break;
    else:
        counter = 0
        notreachable = n
print ("Given that sizes %d, %d, and %d, the largest number of McNuggets that cannot be bought in exact quantity is: %d" % (package[0], package[1], package[2], notreachable))

##6a + 9b + 20c = n
##
##n | a  b  c		n | a  b  c		n | a  b  c
##——————————————————————————————————————————————-------------
##50  5  0  1		56  6  0  1		62  7  0  1
##51  7  1  0		57  8  1  0		63  9  1  0
##52  2  0  2		58  3  0  2		64  4  0  2
##53  4  1  1		59  5  1  1		65  6  1  1
##54  9  0  0		60  10 0  0		
##55  1  1  2		61  2  1  2		
##
##This theorem is true because when six consecutive numbers are solvable every number afterwards is solvable by adding another six to the previous totals.


# Problem Set 2 (Problem 3)
# tuckertuck
# time = 4:00

BestSoFar = 0
packages = (9,6,20)
count = 0

def BruteForceNuggets(n,(x,y,z)):
    for a in range(0, n + 1):
        for b in range(0, n - (a * x) + 1):
            c = (n - (b * y) - (a * x)) / z
            if c >= 0:
                #print (x*a),'+',(y*b),'+',(z*c),'=',n
                if (a * x) + (b * y) + (c * z) == n:
                    return True
    return False

for n in range(1, 200):
    if not BruteForceNuggets(n,packages):
        BestSoFar = n
        print BestSoFar,
        count = 0
    count += 1
    print count
    sortPackage = sorted(packages)
    if count > sortPackage[0]:
        break
print 'Largest number of McNuggets that cannot be bought in exact quantity:',BestSoFar



# Problem Set 2 (Problem 4)
# tuckertuck


bestSoFar = 0     # variable that keeps track of largest number
                  # of McNuggets that cannot be bought in exact quantity
packages = (13,16,25)   # variable that contains package sizes

count = 0

def BruteForceNuggets(n,(x,y,z)):
    for a in range(0, n + 1):
        for b in range(0, n - (a * x) + 1):
            c = (n - (b * y) - (a * x)) / z
            if c >= 0:
                #print (x*a),'+',(y*b),'+',(z*c),'=',n
                if (a * x) + (b * y) + (c * z) == n:
                    return True
    return False

    
for n in range(1, 200):
    if not BruteForceNuggets(n,packages):
        BestSoFar = n
        #print BestSoFar
        count = 0
    count += 1
    #print count,
    sortPackage = sorted(packages)
    if count > sortPackage[0]:
        break
print "Given package sizes", packages[0], packages[1], "and", packages[2], "the largest number of McNuggets that cannot be bought in exact quantity is:", BestSoFar

def solve(n,a,b,c):
    for x in range(0,int(n/a)+1):
        for y in range(0,int(n/b)+1):
            for z in range(0,int(n/c)+1):
                if n==a*x + b*y + c*z:
                    return n
    return False
def item(a,b,c):
    n = 6
    while True:
        if solve(n,a,b,c) and solve(n+1,a,b,c)\
           and solve(n+2,a,b,c) and solve(n+3,a,b,c)\
           and solve(n+4,a,b,c) and solve(n+5,a,b,c):
            print(n-1,'is the last sum of Mcnuggets that can\'t be bought.')
            return
        n+=1

##Problem 1
##
##50 = 2,2,1
##51 = 1,5,0
##52 = 2,0,2
##53 = 1,3,1
##54 = 0,6,0
##55 = 1,1,2
##
##Problem 2
##
##Since it is possible to buy x,x+1...,x+5 McNuggets,
##you can add the lowest choice 6 to the total and still
##have a number that is able to be purchased with the
##combination of 6, 9,or 20 McNuggets.
##
##Problem 3

nuggets = (6,9,20)    
best_so_far = 0       
counter = 0           
for loop_counter in range(1,200):    
    checker = False
    for a in range(0,loop_counter/nuggets[0] +1):
        for b in range(0,loop_counter/nuggets[1] + 1):
            for c in range(0,loop_counter/nuggets[2] + 1):
                solution = a*nuggets[0]+b*nuggets[1]+c*nuggets[2]
                if solution == loop_counter:
                    counter = counter + 1
                    checker = True
                if checker == True:
                    break
            if checker == True:
                break
        if checker == True:
            break
    if checker == False:
        counter = 0
        best_so_far = loop_counter
print 'Largest number of McNuggets that cannot be bought in an exact quantity is',best_so_far

##Problem 4

nuggets = (6,9,20)    
best_so_far = 0       
counter = 0
for loop_counter in range(1,200):
    checker = False
    for a in range(0,loop_counter/nuggets[0] +1):
        for b in range(0,loop_counter/nuggets[1] + 1):
            for c in range(0,loop_counter/nuggets[2] + 1):
                solution = a*nuggets[0]+b*nuggets[1]+c*nuggets[2]
                if solution == loop_counter:
                    counter = counter + 1
                    checker = True
                if checker == True:
                    break
            if checker == True:
                break
        if checker == True:
            break
    if checker == False:
        counter = 0
        best_so_far = loop_counter
print 'Given package sizes',nuggets[0],',',nuggets[1],', and',nuggets[2],' the largest number of McNuggets that cannot be bought in exact quantity is',best_so_far

# Problem Set 2  (Lesson 2, assignment 1)

import math

a=0
b=0
c=0
n=50


for n in range (50,56):
    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):
                    print 'ok a,b,c ' , a,b,c
            c=+1
        b=+1
    a=+1
n=+1

#problem 3 -mcnuggets


count=0

n=1
exact=0

while count<6 :
  
    for a in range (0,9) :
        for b in range (0,6) :
            for c in range (0,3):
                if 6*a + 9*b + 20*c == n :
                    exact=1
    if exact == 1 :
        count +=1
    else :
        largest=n
        count=0
    n+=1
    exact=0          

print "Largest number of McNuggets that cannot be bought in exact quantity: "largest

----------------------------------------------------

#problem 4 -mcnuggets



x=(int(raw_input("small package size: ")))
y=(int(raw_input("medium package size: ")))
z=(int(raw_input("large package size: ")))

up=(int(raw_input("up to what number to check?")))

packages=(x,y,z)
count=0
n=1
bestSoFar=0
exact=0
flag=0


while count<x :
  for n in range (1,up):
    for a in range (0,up/x+x) :
        for b in range (0,up/y+y) :
            for c in range (0,up/z+z):
                if x*a + y*b + z*c == n :
                    exact=1
    if exact == 1 :
        count +=1
    else :
        bestSoFar=n
        count=0
    n+=1
    exact=0          
  if count<x :
      flag=1
      print "There is no number up to ",up ,"which cannot be bought"
      break

if flag!=1:
    print "Given package sizes ",x ,y, z
    print "the largest number of McNuggets that cannot be bought"
    print "in exact quantity is: ",bestSoFar

0

## 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 2
# Name: TheHedge
# Collaborators: 0
# Time: 05:00:00

# PROBLEM 1
packages = (6,9,20)

def mcComboPossible(n):
    Possible = False
    for a in range (0,n):
        for b in range (0,n):
            for c in range (0,n):
                if (packages[0]*a) + (packages[1]*b) + (packages[2]*c) ==n:
                    Possible = True
                c += 1
            b += 1
        a += 1
    return Possible

def mcCombo(n):
    for a in range (0,n):
        for b in range (0,n):
            for c in range (0,n):
                if (packages[0]*a) + (packages[1]*b) + (packages[2]*c) ==n:
                    print 'to get' ,n, 'nuggets, you could buy ' ,a, 'x ', packages[0],' nuggets' ,b, 'x', packages[1],' nuggets, and' ,c, 'x ',packages[2],' nuggets'
                c += 1
            b += 1
        a += 1

numNuggets = int(raw_input('How many nuggets would you like? \n'))

if mcComboPossible(numNuggets) == False:
    print 'Sorry, that is not possible!'
else:
    mcCombo(numNuggets)

# PROBLEM 3
nCount =0

for a in range (6,100):
    if mcComboPossible(a) == True:
        nCount +=1
        if nCount == 6:
            print 'The largest number of McNuggets that cannot be bought in exact quantity is' ,a-6,' \n'  
    else:
        nCount = 0
        
# PROBLEM 4
limit = 50

def getMcCombos(limit,x,y,z):
    Possible = False
    for a in range (0,limit):
        for b in range (0,limit):
            for c in range (0,limit):
                if (packages[0]*a) + (packages[1]*b) + (packages[2]*c) ==limit:
                    Possible = True
                c += 1
            b += 1
        a += 1
    return Possible


while getMcCombos(limit,packages[0],packages[1],packages[2]) == True:
    limit -=1
    getMcCombos(limit,packages[0],packages[1],packages[2])
print 'Given package sizes ', packages[0],',', packages[1], 'and', packages[2],'the largest number of nuggets that connot be bought in the exact quantity is', limit,
    

#####################PS2a.py############
#!/usr/bin/env python
#encoding=utf-8

#6a+9b+20c=n n=50 to 55
def solve(n):
    """finds one solution for the dioohantine equation 6a+9b+20c=n"""
    for a in range (0,n/6+1):#upper limit is set so you don't extrapolate the upper value of n+5 when multiplying a, b, or c.
            for b in range(0,n/9+1):#same here
                for c in range (0,n/20+1):#same here
                    randomcombo = 6*a + 9*b + 20*c
                    if n == randomcombo: 
                        #print "Solução para n = " + str(n) + ":", "("+str(a)+","+str(b)+","+str(c)+")"
                        return [randomcombo,a,b,c]
                    else:
                        pass
    return False
                        
def FindSolutions(x):
    """tries to find 5 consecutive solutions for the McNuggets problem, this is for problem 1 of problem set 2 when x = 50"""
    solutionslist = []
    L = range(x,x+6)
    for numberNuggets in L: #try combinations of a, b and c till one solution is found
        if solve(numberNuggets) != False:       
            solutionslist.append(solve(numberNuggets))    
    return solutionslist


#def verify(x):
#    """checks if there exists solutions for all elements in range x,x+5"""
#    x=raw_input("input x: ")
#    FindSolutions(x)
#    if len(solutionslist) < 5:
#        return False 
#    else:   
#        return True
#see if verify(x) is true then there exists solutions for every number > x+5 because we can write any of them in terms of previous solution plus packages of 6, 9 and 20.

## Agora para a segunda parte do problema:

def nope():
    """Encontra o maior número de McNuggets que não pode ser comprado em quantidade exata"""
    unbuyable=[]
    x = 0
    while len(FindSolutions(x)) < 6:#we know from the theorem that once 6 consecutive solutions are found, there are endless solutions.
        x+=1
        if solve(x) == False:
            unbuyable.append(x)#saves an unbuyable value everytime one is found.           
    else:
        print "Largest number of McNuggets that cannot be bought in exact quantity:", unbuyable[-1]
        
print solve(52)
nope()
#print len(FindSolutions(50))

######ps2b.py##############################
#!/usr/bin/env python
#encoding=utf-8


###
### template of code for Problem 4 of Problem Set 2, Fall 2008
####x.a+y.b+z.c=n 

#bestSoFar = 0     # variable that keeps track of largest number
                  # of McNuggets that cannot be bought in exact quantity
packages = (9,12,23)   # variable that contains package sizes
maxn=150
#for n in range(1, 150):   # only search for solutions up to size 150
    ## complete code here to find largest size that cannot be bought
    ## when done, your answer should be bound to bestSoFar

def solve(n):
    """finds one solution for the dioohantine equation 6a+9b+20c=n"""
    for a in range (0,n/packages[0]+1):#upper limit is set so you don't extrapolate the upper value of n+5 when multiplying a, b, or c.
            for b in range(0,n/packages[1]+1):#same here
                for c in range (0,n/packages[2]+1):#same here
                    randomcombo = packages[0]*a + packages[1]*b + packages[2]*c
                    if n == randomcombo: 
                        #print "Solução para n = " + str(n) + ":", "("+str(a)+","+str(b)+","+str(c)+")"
                        return [randomcombo,a,b,c]
                    else:
                        pass
    #print 'There is no solution' 
    return False

def FindSolutions(x):
    """tries to find 5 consecutive solutions for the McNuggets problem, this is for problem 1 of problem set 2 when x = 50"""
    solutionslist = []
    L = range(x,x+packages[0])
    for numberNuggets in L: #try combinations of a, b and c till one solution is found
        if solve(numberNuggets) != False:       
            solutionslist.append(solve(numberNuggets))    
    return solutionslist


def nope():
    """Encontra o maior número de McNuggets que não pode ser comprado em quantidade exata"""
    unbuyable=[]
    x = 0
    while len(FindSolutions(x)) < packages[0]:#we know from the theorem that once 6 consecutive solutions are found, there are endless solutions.
        x+=1
        if solve(x) == False:
            unbuyable.append(x)#saves an unbuyable value everytime one is found.
        elif x > maxn:
            print 'não existe n<', maxn, 'que funciona nessa esquação.'
            return            
    else:
        print "Largest number of McNuggets that cannot be bought in exact quantity:", unbuyable[-1]

nope()

# Problem Set 2
# Name: Fredrik Gustafsson
# Python version: 3.2
# Time: 1:00


##
## Problem 2a
##

def mcnuggets(n, p):
    
    x = 0
    y = 0
    z = 0
    count = 0

    while x*p[0]+y*p[1]+z*p[2] <= n:
        while x*p[0]+y*p[1]+z*p[2] <= n:
            while x*p[0]+y*p[1]+z*p[2] <= n:
                if x*p[0]+y*p[1]+z*p[2] == n:
                    return ("Solution found")
                    count += 1
                x += 1
            x = 0
            y += 1
        y = 0
        z += 1
    return (count)

for i in range (50, 56):
    print ("Nr of solutions to the equation: 6x + 9y + 20z =", i, "is:", mcnuggets(i, (6, 9, 20)))


##
## Problem 2b: Any number of McNuggets >= x can be expressed as a linear combination
## 6a+9b+20c if x+1, x+2, ..., x+5 all have a solution
##


##
## Problem 2c
##

def serch(p):

    count = 0
    x = 0

    while count <= (p[0]-1):
        if  x > 200:
            return ("No solution found for largest number of McNuggets that cannot be bought in exact quantity whithin the range 0 - 200")
        if mcnuggets(x, (p[0], p[1], p[2])) != 0:
            count += 1
            x += 1
        else:
            count = 0
            x += 1

    return(x-(p[0]+1))


##
## Problem 2d
##

a = int(input("Pleas input nr of McNuggets in smallest package: "))
b = int(input("Pleas input nr of McNuggets in middle package: "))
c = int(input("Pleas input nr of McNuggets in largest package: "))

packages = (a, b, c)        # variable that contains package sizes
bestSoFar = serch(packages)     # variable that keeps track of largest number
                                # of McNuggets that cannot be bought in exact quantity
print (bestSoFar)

#===================== Problem 1 ==========================
def nuggetsFound(n):
    """
    Returns a dictionary contaning Key: number of Nuggets Value: the
    packages
    """
    dic = {}
    for i in range(0,n+1):
        for j in range(0,n+1):
            for k in range(0,n+1):
                if (6*i) + (9*j)+ (20*k) == n:
                    if n in dic:
                        dic[n].append((i,j,k))
                    else:
                        dic[n] = [(i,j,k)] 
    return dic

def displayNuggestsFound(n):
    """
    Gets a input (number of Nuggets) and pass it as an argument to 
    nuggetsFound(). Finally prints the output from nuggetsFound
    """
    nMcNuggets = n # n = 50,51,52,53,54,54
    dicNuggets = nuggetsFound(nMcNuggets)
    for nuggets,numbers in dicNuggets.iteritems():
       if type(numbers) == type([]):
            for number in numbers:
                 print 'Number of McNuggets:',nuggets,'The set:', number
       else:
                 print 'Number of McNuggets:',nuggets,'The set:', number

#===================== Problem 2 ===================
##### The theorem is true becasue any set after x, x+5 is a multiplay of 6.
##### Because 50 + 6 = 56 (a new set with only 6 added), 51 + 6 = 57 (new set with adding 6) and so on so on. 
##### Therefore we can create a new set with the combination of 6, 9 and 12!

#==================== Problem 3 ====================
def numNuggetsNotExact(n):
    """
    """
    Found = False
    notExact = 0
    for i in range(0,n):
        for j in range(0,n):
            for k in range(0,n):
                if (6*i) + (9*j)+ (20*k) == n:
                    Found = True
    return Found  


def displaynumNuggetsNotExact():
    nuggetsNotPurchased = 1 
    n = 2
    counter = 1
    while n < 50:
        n = n +1 
        if not numNuggetsNotExact(n):
            nuggetsNotPurchased = n
            counter = 0
        else:
            counter = counter + 1
        if counter == 6:
            return "Largest number of McNuggets that cannot be bought in exact quantity: %d" % nuggetsNotPurchased

# ================== Problem 4 =========================


def nNumberNuggetsNotExact(x,y,z):
    bestSoFar = 0
    packages = (x,y,z)
    counter = 0
    for n in range(1,200):
        found = False
        for i in range(0 ,200):
            for j in range(0,200):
                for k in range(0,200):
                    if (i * packages[0]) + (j * packages[1])+ (k * packages[2]) == n:
                        found = True
        if found:
            counter = counter + 1
        if not found: 
            bestSoFar = n
            counter = 0
        if counter == packages[0]:
            print "Given package sizes %d, %d and %d, the largest number of McNuggets that cannot be bought in exact quantity is %d" % (packages[0],packages[1],packages[2],bestSoFar) 

# Prob 1

def combos(n): 
   for a in range (0,n): 
      for b in range (0,n):
         for c in range (0,n):
            if (6*a) + (9*b) + (20*c) == n:
               print a, "x6pcks + ",b,"x9pcks+ ",c, "x20pcks = ", n, "nuggets."
            c = c + 1
         b = b + 1
      a = a + 1
      
combos (12)

# Prob 2
#Magic

# Prob 3

answer=[]
n_counter=0
n=0
for n in range(1, 200):
    ans=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:
                    ans = True
    if ans:
        n_counter+=1
        if n_counter==6:
            print 'the largest impossible quantity of nuggets is: ',  answer[-1]
    else:
        answer.append(n)
        n_counter = 0


# Prob 4
packages=(6, 9, 20)
answer=0

for n in range(1, 200):
    ans=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 (packages[0]*a)+(packages[1]*b)+(packages[2]*c)==n:
                    ans=True
    if (ans==False):
        if (n>answer): answer=n
print "Given package sizes "+str(packages[0])+ ', ' +str(packages[1])+  ', and ' +str(packages[2])+", the largest number of McNuggets that cannot be bought in exact quantity is: "+str(answer)

# Problem 1
#
# Name: Ariel Mamani (ariel0)    
# Collaborators: 
# Time: 9:31
#

#funcion que devuelve el valor de la ecuacion
#6a+9b+20c
def ecuacion(a,b,c):
    return 6*a+9*b+20*c


#funcion que calcula las combinaciones de McNuggets
#para una cantidad dada
def comprar(cantidad):
    #3 bucles que iteran los valores de a,b y c en:
    #6a+9b+20c
    a=0
    while a<=cantidad:
        b=0
        if(ecuacion(a,b,0)>cantidad): break
        while b<=cantidad:
            c=0
            if(ecuacion(a,b,c)>cantidad): break
            while c<=cantidad:
                if(ecuacion(a,b,c)==cantidad):
                    print "(a="+str(a)+",b="+str(b)+",c="+str(c)+") , 6*"+str(a)+"+9*"+str(b)+"+20*"+str(c)+"="+str(cantidad)
                elif(ecuacion(a,b,c)>cantidad): break
                c=c+1
            b=b+1
        a=a+1

#probar desde 50 -> 65
for i in range(140,150):
    print "Para comprar "+str(i)+" McNuggets:"
    comprar(i)


#Problem 2
#
#El teorema es cierto ya que si es posible comprar x, x+1,…, x+5 McNuggets 
#y se tiene paquetes de 6, 9 y 20, todos los siguientes valores se pueden 
#comprar añadiendo a cada valor en el rango de x, x+1,…, x+5 un multiplo de 6.
#Es decir, si x+y es cualquier valor mayor a x+5:
#x+y=6*i donde i es cualquier valor de x -> x+5.

#The theorem is true because if you can buy x, x +1, ..., x +5 McNuggets
#and we have packages of 6, 9 and 20, all of the following values can be
#buy adding to each value in the range of x, x +1, ..., x +5 a multiple of 6.
#That is, if x + y is any value greater than x + 5:
#	x+y=6*i where i is any value of x -> x+5.


# Problem 3
# 
# Name: Ariel Mamani (ariel0)    
# Collaborators: 
# Time: 10:31
#

#funcion que devuelve el valor de la ecuacion
#6a+9b+20c
def ecuacion(a,b,c):
    return 6*a+9*b+20*c


#funcion que devuelve True si existe una combinacion para comprar la cantidad McNuggets
#devuelve False si no es posible comprar la cantidad dada
def comprar(cantidad):
    #3 bucles que iteran los valores de a,b y c en:
    #6a+9b+20c
    a=0
    while a<=cantidad:
        b=0
        if(ecuacion(a,b,0)>cantidad): break
        while b<=cantidad:
            c=0
            if(ecuacion(a,b,c)>cantidad): break
            while c<=cantidad:
                if(ecuacion(a,b,c)==cantidad):
                    return True
                elif(ecuacion(a,b,c)>cantidad): break
                c=c+1
            b=b+1
        a=a+1
    return False

#probar desde 49 -> 0
#como con el Teorema anterior se probo que se puede comprar McNuggets desde 50 en
#adelante, no tiene sentido comprobar desde 50 en adelante
#si probamos desde 49 hacia abajo, la primera vez que obtengamos una cantidad que
#no puede ser comprada, esta sera la mayor.
i=49
while(i>=0):
    if(comprar(i)==False):
        print "Largest number of McNuggets that cannot be bought in exact quantity: "+str(i)
        break
    i=i-1



# Problem 4
#
# Name: Ariel Mamani (ariel0)  
# Collaborators: 
# Time: 10:31
#
###
### template of code for Problem 4 of Problem Set 2, Fall 2008
###

bestSoFar = 0     # variable that keeps track of largest number
                  # of McNuggets that cannot be bought in exact quantity
packages = (6,9,20)   # variable that contains package sizes

for n in range(1, 150):   # only search for solutions up to size 150
    ## complete code here to find largest size that cannot be bought
    ## when done, your answer should be bound to bestSoFar

    posible=False
    a=0
    while a<=n:
        b=0
        c=0
        if(packages[0]*a+packages[1]*b+packages[2]*c>n): break
        while b<=n:
            c=0
            if(packages[0]*a+packages[1]*b+packages[2]*c>n): break
            while c<=n:
                if(packages[0]*a+packages[1]*b+packages[2]*c==n):
                    posible=True
                elif(packages[0]*a+packages[1]*b+packages[2]*c>n): break
                c=c+1
            b=b+1
        a=a+1
    if(posible==False):
        if(n>bestSoFar):bestSoFar=n

print "Given package sizes "+str(packages[0])+", "+str(packages[1])+", and "+str(packages[2])+", the largest number of McNuggets that cannot be bought in exact quantity is: "+str(bestSoFar)

#Name: Waz
# Problem set 2

# _____________Part 1_______
#to show the combos, let's create a function to do so
def showcombos(noofng):
   for a in range (0,noofng+1):
      for b in range (0,noofng+1):
         for c in range (0,noofng+1):
            if (6*a) + (9*b) + (20*c) == noofng:
               print a, "x6pcks + ",b,"x9pcks+ ",c, "x20pcks = ", noofng, "nuggets."
            c = c + 1
         b = b + 1
      a = a + 1
#let's show the results
print "\n Combos for 50 nuggets"
showcombos (50)
print "\n Combos for 51 nuggets"
showcombos (51)
print "\n Combos for 52 nuggets"
showcombos (52)
print "\n Combos for 53 nuggets"
showcombos (53)
print "\n Combos for 54 nuggets"
showcombos (54)
print "\n Combos for 55 nuggets"
showcombos (55)


____________Part 2_______

print "\n The reason that every number greater than x will generate a combo is \n because every number higher than x+5 equals to a number between x and x+5 plus \n a multiple of 6. That multiple will only augment 'a' but we will still have a combo"

___________Part3___________


def showcombos(noofng): #noofng = number of nuggets
   for a in range (0,noofng+1):
      for b in range (0,noofng+1):
         for c in range (0,noofng+1):
            if (6*a) + (9*b) + (20*c) == noofng:
               Hascombo = True
               return Hascombo
          
strt=50  #we are starting from 50 because we know anything >50 will have a combo.
while showcombos(strt)<> None:
    strt = strt - 1
    showcombos (strt)
print "Largest number of McNuggets that cannot be bought in exact quantity: ", strt

#------------Generalized version--------------------
def showcombos(noofng,x,y,z):  
   for a in range (0,noofng+1):
      for b in range (0,noofng+1):
         for c in range (0,noofng+1):
            if (x*a) + (y*b) + (z*c) == noofng:
               Hascombo = True
               return Hascombo
          
def findbiggest (strt, x,y,z): #x,y,z are the sizes of the packages & strt= where to start counting down
   while showcombos(strt,x,y,z)<> None:
       print strt, "has combos"
       strt -= 1
       showcombos (strt,x,y,z)
   print strt, " is the biggest number of nuggets that you can't\nhave the exact amount with that combo."

_________Part 4________________


def showcombos(noofng,x,y,z):  
   for a in range (0,noofng+1):
      for b in range (0,noofng+1):
         for c in range (0,noofng+1):
            if (x*a) + (y*b) + (z*c) == noofng:
               Hascombo = True
               return Hascombo
          
def findbiggestu200 (x,y,z): #x,y,z are the sizes of the packages 
   strt =200
   while showcombos(strt,x,y,z)<> None:
       strt -= 1
       showcombos (strt,x,y,z)
   print "Given package sizes ",x,",", y, "and ",z," the largest number of McNuggets that cannot be bought in exact quantity is: ", strt

# Lesson 3 Problems 1-4
# Name: 4orty4
# Time: 4:00


##                Problem 1
## 7 * 3   +   9 * 1   +   20 * 1   ==   50
## 7 * 6   +   9 * 1   +   20 * 0   ==   51
## 7 * 1   +   9 * 5   +   20 * 0   ==   52
## 7 * 2   +   9 * 2   +   20 * 1   ==   52
## 7 * 5   +   9 * 2   +   20 * 0   ==   53
## 7 * 0   +   9 * 6   +   20 * 0   ==   54
## 7 * 1   +   9 * 3   +   20 * 1   ==   54
## 7 * 2   +   9 * 0   +   20 * 2   ==   54
## 7 * 4   +   9 * 3   +   20 * 0   ==   55

##              Problem 2
## For package sizes 6,9 and 20 six consecutive
## solutions prove that any higher number can
## also be purchased, because any combination can
## be increased by six by adding an additional
## package of six. For different package sizes,
## (n) consecutive solutions must be found, where
## (n) = the size of the smallest package.

##             Problems 3 and 4
## Solution condensed into one program. Tuple 'packages'
## can be changed to any other non-zero package sizes,
## provided the smallest package is listed first.

# packages[1]*x + packages[2]*y + packages[3]*z = n
# This program will find the highest whole number <200
# that can be purchased given the package sizes.

# Change package size by changing these values
# Smallest package size must be entered first for the program
# to function correctly
packages = (6,9,20)

#initialize values
total = 0
x, y, z = 0, 0, 0
n=0
solCounter = 0
isSolFound = 0
bestSoFar = 0

# For each x, y and z all values are tested between 0 and (n/package size + 1)

for n in range (1, 200):
    for x in range (0, (n/packages[0]+1)): 
        for y in range(0, (n/packages[1]+1)):
            for z in range(0, (n/packages[2]+2)):
                total = packages[0]*x + packages[1]*y + packages[2]*z
                if total == n:
                    print packages[0],'*',x,'  +  ',packages[1],'*',y,'  +  ',packages[2],'*',z,'  ==  ',total
                    isSolFound = 1
    #the loop continues even if a solution is found
    #not ideal but not sure how to break out of all 3 for loops
    #at once.

    if isSolFound == 1:
        solCounter += 1
        isSolFound = 0
    else:
        solCounter = 0
        bestSoFar = n # Stops when consecutive solutions = smallest package size
    if solCounter == packages [0]:
        break #breaks the loop so it doesn't have to try all 200 n's

print 'Package sizes are', packages[0], packages[1],'and', packages[2]               
print 'Largest number that can not be bought in exact quantity:', bestSoFar

#Problem Set 2 (Part 1)
#Name: conwayblue

#Problem 1-------------------------------------------------------


def nuggets(totalNuggets):
    """needs total number of nuggets"""

    for pack20 in range(0, totalNuggets / 20 + 1):
        for pack9 in range(0, totalNuggets / 9 + 1):
            for pack6 in range(0,totalNuggets / 6 + 1):
                
                totalNuggetsCalc = 20*pack20 + 9*pack9 + 6*pack6
                if totalNuggetsCalc == totalNuggets and pack6 > -1:
                    return (pack6, pack9, pack20)
    return(None, None, None)
     

def mcdonalds():
    """will ask how many total nuggets"""
    
    totalNuggets = int(raw_input("How many total nuggets do you want? "))
    pack6, pack9, pack20 = nuggets(totalNuggets)

    if pack6 == None:
        print "You can't buy that many nuggets"
    else:
        print "You could buy", pack6, "six packs"
        print "You could buy", pack9, "nine packs"
        print "You could buy", pack20, "twenty packs"


#Problem 2--------------------------------------------------
        

def nuggetrange(startnumber):
    """needs a number and will give you the possible number packs for the next 6"""

    for each in range(startnumber, startnumber+7):
        pack6, pack9, pack20 = nuggets(each)
        if pack6 == None:
            print "You can\'t have", each, "nuggets dummy!"
        else:
            print "For", each, "nuggets you need", pack6, "six packs", pack9, "nine packs", pack20, "twenty packs"


#Problem 3---------------------------------------------------


def maxNonNugget():

    notNuggetFriendly = []

    for nuggetCount in range(0,50):

        packList = nuggets(nuggetCount)

        if packList[0] == None:

            notNuggetFriendly.append(nuggetCount)


    print "Largest number of McNuggets that cannot be bought in exact quantity: ", notNuggetFriendly[-1]
            
        
#Problem 4--------------------------------------------------------

def crazyNugget():
    
    packages = (6,9,20)
    notNuggetFriendly = 0
    foundRow = 0

    for totalNuggets in range(0,200):
        
        friendly = False

        for a in range(0, totalNuggets + 1):
            for b in range(0, totalNuggets + 1):
                for c  in range(0, totalNuggets + 1):
                    runningCalc = (a * packages[0]) + (b * packages[1]) + (c * packages[2])
                    if runningCalc == totalNuggets:
                        friendly = True

        if friendly:
            foundRow += 1
            if foundRow == packages[0]:
                break
        else:
            foundRow = 0
            notNuggetFriendly = totalNuggets

    print "Given sizes %s, %s, and %s, the largest number of nuggets than can't be purchased is %s" % (packages[0], packages[1], packages[2], notNuggetFriendly)



                



    

    

# Lesson 3 Problems 1-4
# Name: 4orty4
# Time: 4:00


##                Problem 1
## 7 * 3   +   9 * 1   +   20 * 1   ==   50
## 7 * 6   +   9 * 1   +   20 * 0   ==   51
## 7 * 1   +   9 * 5   +   20 * 0   ==   52
## 7 * 2   +   9 * 2   +   20 * 1   ==   52
## 7 * 5   +   9 * 2   +   20 * 0   ==   53
## 7 * 0   +   9 * 6   +   20 * 0   ==   54
## 7 * 1   +   9 * 3   +   20 * 1   ==   54
## 7 * 2   +   9 * 0   +   20 * 2   ==   54
## 7 * 4   +   9 * 3   +   20 * 0   ==   55

##              Problem 2
## For package sizes 6,9 and 20 six consecutive
## solutions prove that any higher number can
## also be purchased, because any combination can
## be increased by six by adding an additional
## package of six. For different package sizes,
## (n) consecutive solutions must be found, where
## (n) = the size of the smallest package.

##             Problems 3 and 4
## Solution condensed into one program. Tuple 'packages'
## can be changed to any other non-zero package sizes,
## provided the smallest package is listed first.

# packages[1]*x + packages[2]*y + packages[3]*z = n
# This program will find the highest whole number <200
# that can be purchased given the package sizes.

# Change package size by changing these values
# Smallest package size must be entered first for the program
# to function correctly
packages = (6,9,20)

#initialize values
total = 0
x, y, z = 0, 0, 0
n=0
solCounter = 0
isSolFound = 0
bestSoFar = 0

# For each x, y and z all values are tested between 0 and (n/package size + 1)

for n in range (1, 200):
    for x in range (0, (n/packages[0]+1)): 
        for y in range(0, (n/packages[1]+1)):
            for z in range(0, (n/packages[2]+2)):
                total = packages[0]*x + packages[1]*y + packages[2]*z
                if total == n:
                    print packages[0],'*',x,'  +  ',packages[1],'*',y,'  +  ',packages[2],'*',z,'  ==  ',total
                    isSolFound = 1
    #the loop continues even if a solution is found
    #not ideal but not sure how to break out of all 3 for loops
    #at once.

    if isSolFound == 1:
        solCounter += 1
        isSolFound = 0
    else:
        solCounter = 0
        bestSoFar = n # Stops when consecutive solutions = smallest package size
    if solCounter == packages [0]:
        break #breaks the loop so it doesn't have to try all 200 n's

print 'Package sizes are', packages[0], packages[1],'and', packages[2]               
print 'Largest number that can not be bought in exact quantity:', bestSoFar

# Amy Karoline
# Course 600
# Problem Set 2, Diophantine Equations - McNuggets
# Time: Problem 1: 3 hrs 15 mins, Problem 2: 45 mins
# Problem 3: 45 mins, Problem 4: 1 hr 30 mins
# 01242011
####

from math import *

## 6a + 9b + 20c = n McNuggets Diophantine equation
##
## Problem 1:
## Show it's possible to buy exactly 50, 51, 52, 53, 54, and 55 McNuggets by
## finding solutions to the Diophantine equation. List the combos of 6, 9, and
## 20 packs of Nuggets you need to buy in order to get each of the exact amounts

a = 0
b = 0
c = 0
n = 0
soln = 0
solns = []
possibleN =[]

# creates lists of possible n values and solutions to the n values
while n <= 55:
    solns.append('nada')
    for a in range(0, n/6+1):
        for b in range(0, n/9+1):
            for c in range(0, n/20+1):
                soln = 6*a + 9*b + 20*c
                if soln == n:
                    if solns[n] == 'nada':
                        solns.insert(n,[a,b,c])
                        possibleN.append(n)
    n += 1
print 'Problem 1:'        
for y in range(50,56):
    print 'For ',y,' nuggets, buy ', solns[y][0],' 6-pack(s), ', solns[y][1],' 9-pack(s), and ', solns[y][2],' 20-pack(s)'

## Then show how, given solutions for 50-55. you can also derive solutions
## for 56-65.
print ''

n=0
soln = 0

for n in range(56,66):
    for z in range(50,56):
        for w in range(1,3):
            if n == 6*w + 6*solns[z][0] + 9*solns[z][1] + 20*solns[z][2]:
                solns.insert(n,[solns[z][0]+w, solns[z][1], solns[z][2]])
                possibleN.append(n)
                
for y in range(56,66):
    print 'For ',y,' nuggets, buy ', solns[y][0],' 6-pack(s), ', solns[y][1],' 9-pack(s), and ', solns[y][2],' 20-pack(s)'

##Problem 2:
##    This theorem is true because the smallest set of McNuggets possible to buy is
##    6. The range from x to x+5 contains 6 sequential values, therefore, every x+n
##    beyond x+5 will be one of the values in the range from x to x+5 plus a multiple
##    of 6.  x+n = 6*z + (one of x to x+5), where z is an integer

##Problem 3: Solving a Diophantine equation
##    Write an exhaustive search to find the largest number of McNuggets that
##    cannot be bought in exact quantity.
##    Mmmm... this is making me crave nuggets.
print ''
print 'Problem 3:'        

a=0
b=0
c=0
n=0
sol=0
consecutiveN = 0        
impossibleN=[]

for n in range(1,200):
    ans=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):
                sol = 6*a + 9*b + 20*c
                if sol == n:
                    ans = True
    if ans:
        consecutiveN += 1
        if consecutiveN == 6:
            print 'The largest impossible quantity of McNuggets is: ',impossibleN[-1]
    else:
        impossibleN.append(n)
        consecutiveN = 0


##Problem 4:
##    Use exhaustive search to find the largest number less than 200 of McNuggets
##    that cannot be bought in exact quantity. Sometimes there is not largest value
##    so we have to have the limit of 200 to protect for infinite looping.
print ''
print 'Problem 4:'        

x=1
y=9
z=500

sol=0
consN=0
impN=[]
n=0

packages = (x,y,z)
foundLargest = False

for n in range(1,200):
    ans=False
    for a in range(0, n/packages[0]+1):
        for b in range(0, n/packages[1]+1):
            for c in range(0, n/packages[2]+1):
                sol = packages[0]*a + packages[1]*b + packages[2]*c
                if sol == 1:
                    foundLargest = False
                elif sol == n:
                        ans = True
    if ans:
        consN += 1
        if consN == 6 and packages[0] != 1:
            print 'Given package sizes %d, %d, %d, the largest number of McNuggets that cannot be bought in exact quantity is: %d' % (packages[0], packages[1], packages[2], impN[-1])
            foundLargest = True
    else:
        impN.append(n)
        consN = 0
if not foundLargest:
    print 'There is no largest impossible purchaseable quantity of nuggets under 200 for package sizes ',x,', ',y,', ',z,'.'


        
    


    

# Problem 1 Part 1

lookingFor = (50, 51, 52, 53, 54, 55)
for a in range(0, 55 / 6 + 1):
    for b in range(0, 55 / 9 + 1):
        for c in range(0, 55 / 20 + 1):
            solution = (6 * a) + (9 * b) + (20 * c)
            if solution in lookingFor:
                print "Combination found for %d: (%d packages of 6, %d packages of 9, %d packages of 20)" % (solution, a, b, c)

# Problem 2
#
# Because we know there is a valid combination for purchasing 50, 51,
# 52, 53, 54 and 55 Chicken McNuggets, and because we are able to
# purchase packages in sizes 6 or 9, we know there must be valid combinations 
# for purchasing 56-65 as we only need to add another package of "6" to our
# solution for purchasing "50" to get "56", another package of "6" to
# our solution for purchasing "51" to get "57", another package of "6"
# to our solution for purchasing "52" to get "58", another package of "6"
# to our solution for purchasing "53" or another package of "9" to our
# solution for puchasing "50" to get "59", etc.


# Problem 3
#
# Use this to write an exhaustive search to find the *largest* number of
# chicken nuggets that *cannot* be bought

foundInARow = 0
maxThatCannotBePurchased = 0

for i in range(0, 50):
    canPurchaseThisAmount = False

    for a in range(0, i / 6 + 1):
        for b in range(0, i / 9 + 1):
            for c in range(0, i / 20 + 1):
                solution = (6 * a) + (9 * b) + (20 * c)
                if solution == i:
                    canPurchaseThisAmount = True

    if canPurchaseThisAmount:
        foundInARow += 1
        if 6 == foundInARow:
            break;
    else:
        foundInARow = 0
        maxThatCannotBePurchased = i

print "Largest number of McNuggets that cannot be bought in exact quantity: %d" % maxThatCannotBePurchased

# Problem 4
#
# Assume that the variable packages is bound to a tuple of length 3, the
# values of which specify the sizes of the packages, ordered from
# smallest to largest. Write a program that uses exhaustive search to
# find the largest number (less than 200) of McNuggets that cannot be
# bought in exact quantity.

packages = (15, 24, 32)
maxThatCannotBePurchased = 0

for i in range(0, 200):
    canPurchaseThisAmount = False

    for a in range(0, i / packages[0] + 1):
        for b in range(0, i / packages[1] + 1):
            for c in range(0, i / packages[2] + 1):
                solution = (packages[0] * a) + (packages[1] * b) + (packages[2] * c)
                if solution == i:
                    canPurchaseThisAmount = True

    if canPurchaseThisAmount:
        foundInARow += 1
        if packages[0] == foundInARow:
            break;
    else:
        foundInARow = 0
        maxThatCannotBePurchased = i
 
print "Given that sizes %d, %d, and %d, the largest number of McNuggets that cannot be bought in exact quantity is: %d" % (packages[0], packages[1], packages[2], maxThatCannotBePurchased)

#Solutions to problems 1 and 2
A	B	C   	         D
6	9	20	= 	 X
---------------------------
2	2	1      =      50
5	0	1	=	51
2	0	2	=	52
4	1	1	=	53
1	1	0	=	54
1	1	2	=	55
3	2	1	=	56
6	0	1	=	57
3	0	2	=	58
5	1	1	=	59
2	1	0	=	60
2	1	2	=	61	
4	2	1	=	62
7	0	1	=	63
4	0	2	=	64
6	1	1	=	65

Every six iterations, A increases by 1; B repeats the pattern: 0,0,1,1,1 and C repeats the pattern:
1,1,2,1,0,2. When D increases by 6 A increases by 1.

#Solutions to problems 3 and 4
packages = (6, 9, 20)
BestSoFar = packages[0]-1
n = 1
counter = 0

def BuildTable(packages):
	LookUpTable = []
	sum = 0
	for first in range(0, 10):
		for second in range(0, 10):
			for third in range(0, 10):
				sum = first*packages[0]+second*packages[1]+third*packages[2]
				LookUpTable.append(sum)
	LookUpTable = list(set(LookUpTable))
	return LookUpTable
	
array = BuildTable(packages)

while n < len(array):
	if array[n] - array[n-1] == 1:
		counter += 1
	else:	
		counter = 0
	if counter == packages[0]:
		BestSoFar = array[n-packages[0]] - 1
	n += 1
	
print "Largest number of McNuggets that cannot be bought in exact quantity:", BestSoFar
print "Given sizes package sizes", packages[0], ",", packages[1], "and", packages[2], ", the largest number of McNuggets that cannot be bought in exact quantity is:", BestSoFar  			

#variables
bestSoFar = 0                               # variable that keeps track of largest number
                                            # of McNuggets that cannot be bought in exact quantity
packages = (6,9,20)                         #variable that contains package sizes
number_of_nuggets=1
number=0                                    #the number that changes to reach our wanted number of nuggets
count=0                                     #if 6 we have the largest possible number

packs_of_small=0                            #any way to declare all these in a shorter way?
packs_of_medium=0
packs_of_large=0
max_packs_large=0 
max_packs_medium=0
max_packs_small=0


#function
def brute_force_and_calculate():                                          #actual bruteforcing
    global packs_of_large
    global packs_of_medium
    global packs_of_small
    global number
    for packs in range(0,max_packs_large+1):			 
        packs_of_large=packs       
        for packs in range(0,max_packs_medium+1):
            packs_of_medium=packs
            for packs in range(0,max_packs_small+1):
                packs_of_small=packs
                number = (6*packs_of_small)+(9*packs_of_medium)+(20*packs_of_large)   #used to be calculate_number() on it's own, but this actually works
                if number == number_of_nuggets:
                  return number
                  return packs_of_large
                  return packs_of_small
                  return packs_of_medium

#program itself
while number_of_nuggets <150:   		# only search for solutions up to size 150
                            			# complete code here to find largest size that cannot be bought
    max_packs_small=(number_of_nuggets/packages[0])+1         
    max_packs_medium=(number_of_nuggets/packages[1])+1
    max_packs_large=(number_of_nuggets/packages[2])+1                                  #calculate packs per number
    brute_force_and_calculate()
    if number == number_of_nuggets:                         # if it's what we want the counter goes up, 6 means we have to stop
        count+=1
        if count >6:
            print 'the largest number that we cannot create is:',bestSoFar
            number_of_nuggets=150                           #stop the while loop
            
    else: 
        bestSoFar=number_of_nuggets
        count=0                                             #reset counter
    number_of_nuggets+=1
    
                        
print 'done'

# Problem Set 2

# pt. 3

n = 1
csols = 0
solution = 0
found = 0

while csols < 6 :

    found = 0

    for a in range (0, 9) :

        for b in range (0, 6) :

            for c in range (0, 3) :

                if (6 * a) + (9 * b) + (20 * c) == n :
                   found = 1

    if found == 1 :

        csols += 1

    else :

        csols = 0
        solution = n

    n += 1

print "Largest number of McNuggets that cannot be bought in exact quantity:", solution


# pt. 4

bestSoFar = 0
packages = (6,9,20)

for n in range(1, 200) :

    exact = False
    for a in range (0, 33) :

        for b in range (0, 22) :

            for c in range (0, 10) :

                if (packages[0] * a) + (packages[1] * b) + (packages[2] * c) == n :

                    exact = True
                    break

    if exact == False and bestSoFar < n :

        bestSoFar = n

print "Given package sizes " + str(packages[0]) + ", " + str(packages[1]) + ", and " + str(packages[2]) + ", the largest number of McNuggets that"
print "cannot be bought in exact quantity is " + str(bestSoFar) + "."

# Problem Set 2 (Part 4)                                                                              
# Name: Boogie Devera                                                                                 
# Collaborators: None                                                                                 
# Time: 00:30                                                                                         

bestSoFar = 0

packages = (6, 9, 20)

for n in range(1,200):

    exactQtyFlag = False # does not solve the diophantine equation                                    

    for a in range(0,10):
        for b in range(0,10):
            for c in range(0,10):
                calc =  a * packages[0] + b * packages[1] + c * packages[2]
                if n == calc:
                    exactQtyFlag = True
                    break

    if not exactQtyFlag and bestSoFar < n:
        bestSoFar = n

print "Given packages sizes <6>, <9>, and <20>, the largest number of McNuggets that"
print "cannot be bought in exact quantity is: ", bestSoFar

#code to calculate possible McNugget combinations up to n = 55 nuggets

n=0
a=0
b=0
c=0
while n < 55:
    if 6*a + 9*b + 20*c < n:
        a = a + 1
    elif 6*a + 9*b + 20*c > n:
        a = 0
        b = b + 1
        if 9*b > n:
            b = 0
            c = c + 1
            if 20*c > n:
                c = 0
                n = n + 1 
    elif 6*a + 9*b + 20*c == n:        
        print 'For', n, 'McNuggets, a =', a, ', b =', b, ', c =', c
        a = a + 1

#code to calculate the largest quantity of McNuggets which cannot be obtained using the three sizes small, medium, and large

bestSoFar = 0     # variable that keeps track of largest number
                  # of McNuggets that cannot be bought in exact quantity
packages = (6,9,20)   # variable that contains package sizes
(small, medium, large) = packages
for n in range(1, 200):   # only search for solutions up to size 200
    a = 0
    b = 0
    c = 0
    while large*c < n:
        if small*a + medium*b + large*c < n:
            a = a + 1
        elif small*a + medium*b + large*c > n:
            a = 0
            b = b + 1
            if medium*b > n:
                b = 0
                c = c + 1
        if small*a + medium*b + large*c == n:
            break
        elif large*c > n:
            print n, "McNuggets cannot be bought in exact quantity."
            bestSoFar = n
print "Largest number of McNuggets that cannot be bought in exact quantity:", bestSoFar
 

###==================================================
## Problem Set 2 (Part I)
## Time: 1:10
###==================================================

currentTesNum = 1

lastNum = 0

solutions = 0

a = 6
b = 9
c = 20


while solutions<6: #when we find 6 consecutive solutions...
    solved=False
    #Ax+By+Cz = n Diophantine Equation
    for countForA in range(0,a+1): ##nested for loop helps count 'all feasible solutions'
        for countForB in range(0,b+1):
            for countForC in range(0,c+1): 
                if currentTestNum == a*countForA + b*countForB + c*countForC:
                    solved = True
                    #print currentTestNum
    if solved == True:
        solutions += 1
    else:
        lastNum = currentTestNum
        solutions = 0

    currentTestNum += 1

print "Largest number of McNuggets that cannot be bought in exact quantity:",lastNum

#######################################################

###==================================================
## Problem Set 2 (Part II)
## Time: 25 
###==================================================


bestSoFar = 0     # variable that keeps track of largest number
                  # of McNuggets that cannot be bought in exact quantity
packages = (6,9,20)   # variable that contains package sizes

for n in range(1, 150):   # only search for solutions up to size 150
    ## complete code here to find largest size that CANNOT be bought
    ## when done, your answer should be bound to bestSoFar
    #Ax+By+Cz = n Diophantine Equation
    solved=False
    for countForA in range(0,packages[0]+1):
        for countForB in range(0,packages[1]+1):
            for countForC in range(0,packages[2]+1):
                if n == packages[0]*countForA + packages[1]*countForB + packages[2]*countForC:
                    solved = True
                    #print n
    if solved != True:
        bestSoFar = n
        
    
print "Given package sizes",packages[0],",",packages[1],", and",packages[2],'\n'
print "Largest number of McNuggets that cannot be bought in exact quantity:",bestSoFar

##Problem #1
#We wish to show there are solutions to the eq 6a + 9b + 20c = n
#where n is 50 - 55

n = range(50,56)                            #create the list for which to check

for i in n:                                 #search the list by setting n
    for a in range(0,11):                   #for some n search a
        for b in range(0,8):                #for some n, a search b
            for c in range(0,4):            #for some n, a, b search c
                if 6*a + 9*b + 20*c == i:   #test if this is true. If yes print. If not do the try the next c
                    print 'we have a solution!'
                    print a,b,c, 'yields', i

##Problem #2
#Here we chose to show that if 50 - 55 can be made in exact quantity then so can
#any number greater than 55

newset = range(56,66)                       #adptation of previous program. simply new set of numbers to check

for i in newset:
    for a in range(0,15):
        for b in range(0,15):                   
            for c in range(0,5):
                if 6*a + 9*b + 20*c == i:
                    print 'we have a solution!'
                    print a,b,c, 'yields', i

##Problem 3
#This program will search for the largest value that cannot be made
#in exact quantity

highnum = range(1,50)                       #range of numbers to check
good = (6,)                                 #initiates the tuple of values that can be found
duds = ()                                   #initiates the tuple of values that can't be found

for i in highnum:
    for a in range(0,50/6 + 1):
        for b in range(0,50/9 + 1):
            for c in range(0,50/20 + 1):
                if 6*a + 9*b + 20*c == i and i != good[-1]:       #search for numbers that can be found and            
                    good += (i,)                                  #put them in good. i != good[-1] checks if
                                                                  #the value is already in good
n = 1
b = 0                                       #This added code takes what is not in good and puts it in duds.
while n < 50:
    if n != good[b]:                        #check if it is not in good
        duds += (n,)                        #and put it in dud
        n += 1
    else:
        b += 1                              #b is meant to check if there is double counting. it is redundant now that  
        n += 1                              #i != good[-1] is checked

print 'The largest number of McNuggets that cannot be bought in exact quantity is: ' + str(duds[-1])

##Problem #4
#This adaptation performs a search for vaules less than 200 that cannot be found by combinations of 3 separate package sizes
#This is a generalized form of the previous code.

pck1 = input('Enter the smallest of the packages: ')
pck2 = input('Enter the medium of the packages: ')
pck3 = input('Enter the largest of the packages: ')
package = (pck1, pck2, pck3)
print 'The package quantities you chose were', package

good1 = (pck1,)             
duds1 = ()
limit = range(1,201)                            

for i in limit:
    for a in range(0, 200/pck1 + 2):
        for b in range(0, 200/pck2 + 2):
            for c in range(0, 200/pck3 + 2):
                if pck1*a + pck2*b + pck3*c == i and i != good1[-1]:                   
                    good1 += (i,)

n = 1
b = 0
while n < 201:
    if n != good1[b]:
        duds1 += (n,)
        n += 1
    else:
        b += 1
        n += 1

print 'Given package', package, 'the largest quantity of McNuggets, less that 200, that cannot be bought is: ', duds1[-1]

###PS2a###

n = 1					#The desired total number of nuggets, starting with 1
maxTest = 20		#the largest polynomial coefficient to test
cantObtain = 0  	#last found number can't be obtained by combo of 6, 9, 20
consecutive = 0 	#number of consecutive combinations found
found = False		#have we found a valid combination?

while consecutive < 6:
	found = False
	#these for loops try every combination of coefficients up to maxTest
	for a in range(maxTest):
		for b in range(maxTest):
			for c in range(maxTest):
				#print 'a:{0:2d} b:{1:2d} c:{2:2d} -> {3:4d}'.format(a, b, c, 6*a+9*b+20*c)
				if 6*a+9*b+20*c == n:
					print 'Found a combination for', n
					found = True					
	if found == False:
		cantObtain = n
		consecutive = 0
	elif found == True:
		consecutive += 1
	n += 1
	
print 'The last unobtainable number was', cantObtain



###PS2b###

n = 1					#The desired total number of nuggets, starting with 1
maxTest = 40		#the largest polynomial coefficient to test
cantObtain = 0  	#last found number can't be obtained by combo of tuple box
consecutive = 0 	#number of consecutive combinations found
found = False		#have we found a valid combination?

#box = (1, 2, 3)
#box = (6, 9, 20)
#box = (3, 10, 12)
#box = (4, 6, 9)
#box = (2, 4, 6)
box = (7, 9, 11)

while consecutive < 6:
	found = False
	#these for loops try every combination of coefficients up to maxTest
	for a in range(maxTest):
		for b in range(maxTest):
			for c in range(maxTest):
				#print 'a:{0:2d} b:{1:2d} c:{2:2d} -> {3:4d}'.format(a, b, c, 6*a+9*b+20*c)
				if box[0]*a+box[1]*b+box[2]*c == n:
					print 'Found a combination for', n
					found = True					
	if found == False:
		cantObtain = n
		consecutive = 0
	elif found == True:
		consecutive += 1
		if n >= 200: 
			print 'Limit exceeded, probably no answer'
			break
	n += 1

print "Given package sizes " + str(box[0]) + ", " + str(box[1]) + " and " + str(box[2]) + " the largest number of McNuggets that cannot be bought in exact quantity is: " + str(cantObtain)

# Problem Set 2
# Name: Matt Coley
# Time:
#

nugPk1 = 6
nugPk2 = 9
nugPk3 = 20
nugTotal = 0
nugCombo = 51
nugPk1Cnt = 0
nugPk2Cnt = 0
nugPk3Cnt = 0

# loop through each type of nugget limiting the test to the desired amount / each package size
# also including 0 as a size
while nugPk1Cnt < (nugCombo/nugPk1+1):
    nugPk2Cnt = 0
    nugTotal = nugPk1Cnt*nugPk1
    while nugPk2Cnt < (nugCombo/nugPk2+1):
        nugPk3Cnt = 0
        nugTotal = (nugPk1Cnt*nugPk1) + (nugPk2Cnt*nugPk2) + (nugPk3Cnt*nugPk3)
        while nugPk3Cnt < (nugCombo/nugPk3+1):
            if nugTotal == nugCombo:
                print nugTotal, "nuggets can be exactly obtained buying", nugPk1Cnt, nugPk1, \
                "packs,", nugPk2Cnt, nugPk2, "packs, and", nugPk3Cnt, nugPk3, "packs."
            nugTotal += nugPk3
            nugPk3Cnt += 1
        nugTotal += nugPk2
        nugPk2Cnt += 1
    nugTotal += nugPk1
    nugPk1Cnt += 1

# Any number above 55 can now be obtained by multiples of 6.  For example, 56 can be obtained by 50 + 6.
# 65 can be obtained by 53 + 6 = 59 + 6 = 65.  Since the next available number past 50-55 is at least 6 numbers
#   away from the start and one of the nugget sizes is 6, you can continue to generate groupings of 6 off into
#   infinity.  50-55, 56-61, 62-67, etc.

# Problem Set 2a & 2b
# Name: Matt Coley
# Time:
#

nugPk1 = 6
nugPk2 = 9
nugPk3 = 20
nugTotal = 0
nugCombo = 200
nugPk1Cnt = 0
nugPk2Cnt = 0
nugPk3Cnt = 0
testNum = 0
lastConseq = 0
lastUACnt = 0
conseqChk = 0
conseqCnt = 0

while testNum < nugCombo:
    conseqChk = 0
    testNum += 1
    nugPk1Cnt = 0
    while nugPk1Cnt < (nugCombo/nugPk1+1):
        nugPk2Cnt = 0
        nugTotal = nugPk1Cnt*nugPk1
        while nugPk2Cnt < (nugCombo/nugPk2+1):
            nugPk3Cnt = 0
            nugTotal = (nugPk1Cnt*nugPk1) + (nugPk2Cnt*nugPk2) + (nugPk3Cnt*nugPk3)
            while nugPk3Cnt < (nugCombo/nugPk3+1):
                if testNum == nugTotal:
                    conseqChk = 1
                else:
                    lastUACnt = testNum
                nugTotal += nugPk3
                nugPk3Cnt += 1
            nugTotal += nugPk2
            nugPk2Cnt += 1
        nugTotal += nugPk1
        nugPk1Cnt += 1
    if conseqChk == 1:
        conseqCnt += 1
    else:
        conseqCnt = 0
    if conseqCnt == nugPk1:
        print lastUACnt, "is the largest exact unpurchasable amount."
if conseqCnt < nugPk1:
    print lastUACnt, "is the largest exact unpurchasable amount."

#Problem Set #2
#Name: Alex Wan
#Time: Far too long
#Collaborators: CuriousReef

#Problem 1
#McNuggets come in packs of 6, 9, and 20. Show that it is possible to buy 
#exactly 50, 51, 52, 53, 54, and 55 McNuggets using this Diophantine equation:
#6a + 9b + 15c = n, where n is the number of McNuggets.
#List all combinations.


#I tried finding it for any range, however I'm not sure how to fill the values
#between the first and last values. So I'll just go from 50 to 55.

nuggetrange = (50, 51, 52, 53, 54, 55)

for a in range (0, 20):
        for b in range (0, 20):
                for c in range (0, 20):
                        n = 6*a+9*b+20*c;
                        if n in nuggetrange:
                                print (a, b, c, n)

##(0, 6, 0, 54)
##(1, 1, 2, 55)
##(1, 3, 1, 53)
##(1, 5, 0, 51)
##(2, 0, 2, 52)
##(2, 2, 1, 50)
##(3, 4, 0, 54)
##(4, 1, 1, 53)
##(4, 3, 0, 51)
##(5, 0, 1, 50)
##(6, 2, 0, 54)
##(7, 1, 0, 51)
##(9, 0, 0, 54)

#Problem 2                           
#Theorem: If it is possible to buy x, x+1,...,x+5 sets of McNuggets for some x,
#then it is possible to buy any number of McNuggets greater than or equal to x,
#given that McNuggets come in sets of 6, 9, and 20.
#Explain why this is true.

#Um... because it is? Well, I know x must at least be bigger than 6, because that
#is the minimum amount you can buy. But 7 (6+1) and 8 (6+2) are impossible to buy.
#The reason lies in the fact that the smallest they come in is 6. If you can get
#a combination for any number from x to x+5, then x+6 would merely be another set
#of 6 McNuggets. For example, x+11 would be broken down into x+5 and 6. If you can
#get a combination for x+5 McNuggets, all you need is another set of 6. The theorem
#holds true for sets of 6 and 9, or 6 and 20, or 6 and any number.

#Problem 3:
#Find the largest amount of McNuggets that cannot be bought in exact quantity. 
#Print the following line at the end:
#"Largest number of McNuggets that cannot be bought in exact quantity: <n>"

#My idea is to start n at 1, and keep increasing n until we get six consecutive solutions.
#Of course, it's always harder than it sounds. I'm not sure how I can get Python to
#record six consecutive solutions, and tell the program to stop if I do. The main problem
#lies in the fact that the solution generator does not generate n in sequential order.
#I might get solutions for 54, then 53, and then 50, making increasing the number useless.

#My solution lies in the ability to remove the first element in a queue. With a brute forced list of possible answers,
#I checked if the first element was exactly five less than the sixth element. If not, the first element was removed, and
#the test was repeated until an answer was found.

from collections import deque

rightanswers = []
answer = False
count = 0

for a in range (0, 20):
        for b in range (0, 20):
                for c in range (0, 20):
                        n = 6*a+9*b+20*c;
                        #print (a, b, c, n)
                        rightanswers.append(n)
                        rightanswers.sort()
                        rightanswers = list(set(rightanswers))

print rightanswers
rightanswers = deque(set(rightanswers))
while answer == False:
        if rightanswers[0] + 5 == rightanswers[5]:
                answer = True
                print possibleanswer, 'is the largest number of McNuggets that cannot be bought in exact quantity.'
        else:
                possibleanswer = rightanswers[0]
                rightanswers.popleft()

#Problem 4:
#Assign a tuple to be the coefficents of the variables in the diophantine equation.
#Then, exhaustively search for the largest number less than 150 that cannot be bought in exact quantity.

#I used the same code as atop, but added the restrictive template and user friendlied the code.

from collections import deque

bestSoFar = 0     # variable that keeps track of largest number of McNuggets that cannot be bought in exact quantity
first = int(input('Enter the first package size:'))
second = int(input('Enter the second package size:'))
third = int(input('Enter the third package size:'))
packages = [first,second,third]   # variable that contains package sizes
packages.sort()
x = packages[0]
y = packages[1]
z = packages[2]
rightanswers = []
finalanswers = []
answer = False

for a in range (0, 20):
        for b in range (0, 20):
                for c in range (0, 20):
                        n = x*a+y*b+z*c;
                        #print (a, b, c, n)
                        rightanswers.append(n)
                        rightanswers.sort()
                        rightanswers = list(set(rightanswers))
print rightanswers
rightanswers = deque(set(rightanswers))
while answer == False:
        if rightanswers[0] + packages[0] == rightanswers[x]:
                answer = True
        else:
                possibleanswer = rightanswers[0]
                rightanswers.popleft()

for n in range(1, 150): # only search for solutions up to size 150
        if n in rightanswers:
                finalanswers.append(n)
        if possibleanswer in range (1, 150):
                finalanswers.append(possibleanswer)
print finalanswers
bestSoFar = finalanswers[0]
print 'Given package sizes', x, y, z, 'the largest number of McNuggets that cannot be bought in exact quantity is:', bestSoFar
        ## complete code here to find largest size that cannot be bought
        ## when done, your answer should be bound to bestSoFar
        ## SUCCESS!                        

#Problem Set 2
#Name: chip
#Time: 4:00
#

#Problem 1
region = range(50, 55)

for a in range (0, 20):
	for b in range(0,20):
		for c in range(0,20):
			k = 6 * a + 9 * b + 20 * c;
			if k in region:
				print("{0:2}*6 + {1}*9 + {2}*20 = {3}".format(a,b,c,k));

#	2*6 + 2*9 + 1*20 = 50
#	5*6 + 1*9 + 0*20 = 51
#	2*6 + 0*9 + 2*20 = 52
#	1*6 + 3*9 + 1*20 = 53	
#	9*6 + 0*9 + 0*20 = 54
#	1*6 + 1*9 + 2*20 = 55

#Problem 2
"""
	Theorem is true because when we had all x, x+1,..., x+5 all next steps will repeat.
	For example if we has 54 nugets we can add 6 and get 60 or 51 + 6 =57.
	This works for any x, ...,  x+5 values
"""

#Problem 3
def can_buy(n, ax, bx, cx):
	for a in range(0,20):
		for b in range(0,20):
			for c in range(0,20):
				k = ax * a + bx * b + cx * c
				if k == n:
					return True
	return False

def solve(a,b,c):
	count = 0
	for n in range(1,200):
		if not can_buy(n,a,b,c):
			ans = n
			count = 0
		else:	count += 1
		if count == 6:	break
	print("Given package sizes <{0}>, <{1}>, <{2}>, the largest number of McNuggets that cannot be bought in exact quantity is: {3}".format(a,b,c,ans))


solve(6,9,20)

#Problem 4
solve(10,14,15)

# Problem Set 2 (Part I)
# Name: Joe Li
# Time: 4:00
#

count=0                             # the number of successive n McNuggets can be bought
n=1                                 # n start from 1
a=0                                 # make a,b,c,recognizable
b=0
c=0                          
while count!=6:                     # do as following untill count=6
      while 6*a+9*b+20*c!=n:        # test if n McNuggets can be bought with the combination abc. if test fail, do as following
            if 6*a>n:               # if a exceeds the limit
                  a=0               # reset a
                  b+=1              # try next b
            elif 9*b>n:             # if b exceeds the limit
                  a=0               # reset a
                  b=0               # reset b
                  c+=1              # try next c
            elif 20*c>n:            # if c excceds the limit
                  a=0               # reset a
                  b=0               # reset b
                  c=0               # reset c
                  count=0           # reset count
                  m=n               # store last n cannot be bought to m
                  n+=1              # test next n
            else:                   # if none of a,b,c exceeds the limit
                  a+=1              # try next a
      else:                         # if pass the test
            count+=1                # count plus 1
            n+=1                    # try the next n
            a=0                     # reset a
            b=0                     # reset b
            c=0                     # reset c
else:                               # if got 6 successive n McNuggets can be bought,
      print 'Largest number of \
McNuggets that cannot \
be bought in exact \
quantity: <'+str(m)+'>'             # print the last n cannot be bought
                                    

# Problem Set 2 (Part II)
# Name: Joe Li
# Time: 3:00
#
bestSoFar=0                               # variable that keeps track of largest number of McNuggets that cannot be bought in exact quantity
package=(7,13,19)                          # variable that cantains package sizes             
x=package[0]
y=package[1]
z=package[2]
for n in range(1,200):                    # test n from 1 to 199
      m=1                                 # variable that remains 1 unless such n McNuggets can be bought with some combination
      for c in range(0,n/z+2):            # test c from 0 to n/z+1
            for b in range(0,n/y+2):      # test b from 0 to n/y+1
                  for a in range(0,n/x+2):# test a from 0 to n/x+1
                        if x*a+y*b+z*c==n:# if n McNuggets can be bought with such combination abc
                             m=0          # set m to 0
      if m==1:                            # if m hasn't been set to 0 which means there's no combination with whitch n McNuggets can be bought
            bestSoFar=n                   # assign such n to bestSoFar
print 'Given package sizes <'+str(x)+'>, \
<'+str(y)+'>, and <'+str(z)+'>, the largest \
number of McNuggets that cannot be bought \
in exact quantity is: <'+str(bestSoFar)+'>'

# Problem 3
a = 1
b = 1
c = 1
eq = 6 * a + 9 * b + 20 * c

n = 200

max_a = n / 6 + 1
max_b = n / 9 + 1
max_c = n / 20 + 1

n_tuple = ()
for n in range(1, n):
    for a in range(0, max_a):
        for b in range(0, max_b):
            for c in range(0, max_c):
                eq = 6 * a + 9 * b + 20 * c
                if eq == n:
                    print n
                    print 'We found it: a =', a, ',  b=', b, ', c=', c
                    is_unique = True
                    for tmp_n in n_tuple:
                        if tmp_n == n:
                            is_unique = False
                    if is_unique:
                        n_tuple += (n,)
print n_tuple

maximum = 0
for max_n in range(1, n):
    if max_n not in n_tuple:
        maximum = max_n
        
print 'Largest number of McNuggets that cannot be bought in exact quantity: ', maximum


# Problem 4
bestSoFar = 0           # variable that keeps track of largest number
packages = (3,14,17)     # variable that contains package sizes

max_n = 150
max_values = (max_n/packages[0] +1, max_n/packages[1] + 1, max_n/packages[2] + 1)

n_tuple = ()
for n in range(1, max_n):   # only search for solutions up to size 150
    for a in range(0, max_values[0]):
        for b in range(0, max_values[0]):
            for c in range(0, max_values[0]):
                eq = packages[0] * a + packages[1] * b + packages[2] * c
                if eq == n:
                    is_unique = True
                    for tmp_n in n_tuple:
                        if tmp_n == n:
                            is_unique = False
                    if is_unique:
                        n_tuple += (n,)

print n_tuple
maximum = 0
for max_n in range(1, n):
    if max_n not in n_tuple:
        bestSoFar = max_n
        
print 'Given package sizes', packages[0], ',', packages[1], 'and', packages[2], ' the largest number of McNuggets that cannot be bought in exact quantity is: ', bestSoFar

# This script calculates solutions to a diophantine equation with McDonalds
# Chicken McNuggets as the integer values of 6, 9, and 20.

def nuggerator(x):
    for num6p in range(0,x/6+1):
        for num9p in range(0,x/9+1):
            for num20p in range(0,x/20+1):
                n = (6 * num6p) + (9 * num9p) + (20 * num20p)
                if n == x:
                    #print (x),"McNuggets can be purchased with",(num6p),"six packs,",(num9p),"nine packs, and",(num20p),"twenty packs."
                    return True

testval = 0
count = 0

while count < 6:
    if nuggerator(testval) == True:
        count = count + 1
    else:
        count = 0
    testval = testval + 1
print "Largest number of McNuggets that cannot be bought in exact quantity:",(testval - 7)

## Problem set 2b

# Packages tuple as requested in the handout.
packages=(6,9,20)

# This is sort of a brute force hack but it works.
def nuggerator(a):
    for small in range(0,a/packages[0]+1):
        for medium in range(0,a/packages[1]+1):
            for large in range(0,a/packages[2]+1):
                n = (packages[0] * small) + (packages[1] * medium) + (packages[2] * large)
                if n == a:
                    print (a),"McNuggets can be purchased with",(small),(packages[0]),"packs,",(medium),(packages[1]),"packs, and",(large),(packages[2]),"packs."
                    return True

testval = 200
while nuggerator(testval) == True:
    testval = testval - 1
print "Given package sizes",(packages[0]),(packages[1]),"and",(packages[2]),"the largest number of McNuggets that cannot be bought in exact quantity is:",(testval)

# Problem Set 2
# jyen
# 1 hour

# Problem 1
# 50 = 6(5) + 9(0) + 20(1)
# 51 = 6(1) + 9(5) + 20(0)
# 52 = 6(2) + 9(0) + 20(2)
# 53 = 6(1) + 9(3) + 20(1)
# 54 = 6(9) + 9(0) + 20(0)
# 55 = 6(1) + 9(1) + 20(2)
# 56 = 50 + 6(1)
# 57 = 51 + 6(1)
# 58 = 52 + 6(1)
# 59 = 53 + 6(1)
# 60 = 54 + 6(1)
# 61 = 55 + 6(1)
# 62 = 56 + 6(1)
# 63 = 57 + 6(1)
# 64 = 58 + 6(1)
# 65 = 59 + 6(1)

# Problem 2
# The theorem is true because x+5 and x+6(1) are contiguous. We can then continue indefinitely: x + (1 ...) + 6(1).   However, only when x is sufficently large so x...x+5 is contiguous.

# Problem 3

candidatenumber = 1
satisfied = 0
while satisfied <6:
    if candidatenumber%6 == 0 or candidatenumber%9 == 0 or candidatenumber%20 == 0:
        satisfied += 1
        #print "Candidate: ", candidatenumber, " is divisible by 6, 9 or 20"
    else:
        solved = 0
        c = 0
        while solved == 0 and candidatenumber > 20*c:
            a = 0
            b = 0
            while solved == 0 and candidatenumber > 9*b + 20*c:
                a = 0
                while solved == 0 and candidatenumber > 6*a + 9*b + 20*c:
                    #print candidatenumber, a, b, c
                    if (candidatenumber - (6*a) - (9*b) - (20*c))%6 == 0 or (candidatenumber - (6*a) - (9*b) - (20*c))%9 == 0 or (candidatenumber - (6*a) - (9*b) - (20*c))%20 == 0:
                        solved = 1
                        #print "Candidate: ", candidatenumber, " solved by ", a, b, c
                    a += 1
                b +=1
            c += 1
        if solved == 1:
            satisfied +=1
        else:
            satisfied = 0
            #print "Candidate: ", candidatenumber, " not solved."
    candidatenumber += 1

print "The largest number of McNuggets that cannot be bought in exact quantity is ", candidatenumber - 7

#problem 4

candidatenumber = 1
satisfied = 0
packages = (6, 9, 20)

while satisfied <6 and candidatenumber <= 200:
    if candidatenumber%packages[0] == 0 or candidatenumber%packages[1] == 0 or candidatenumber%packages[2] == 0:
        satisfied += 1
        #print "Candidate: ", candidatenumber, " is divisible by a package size"
    else:
        solved = 0
        c = 0
        while solved == 0 and candidatenumber > packages[2]*c:
            a = 0
            b = 0
            while solved == 0 and candidatenumber > packages[1]*b + packages[2]*c:
                a = 0
                while solved == 0 and candidatenumber > packages[0]*a + packages[1]*b + packages[2]*c:
                    #print candidatenumber, a, b, c
                    if (candidatenumber - (packages[0]*a) - (packages[1]*b) - (packages[2]*c))%packages[0] == 0 or (candidatenumber - (packages[0]*a) - (packages[1]*b) - (packages[2]*c))%packages[1] == 0 or (candidatenumber - (packages[0]*a) - (packages[1]*b) - (packages[2]*c))%packages[2] == 0:
                        solved = 1
                        #print "Candidate: ", candidatenumber, " solved by ", a, b, c
                    a += 1
                b +=1
            c += 1
        if solved == 1:
            satisfied +=1
        else:
            satisfied = 0
            #print "Candidate: ", candidatenumber, " not solved."
    candidatenumber += 1

if candidatenumber <= 200:
    print "The largest number of McNuggets that cannot be bought in exact quantity is ", candidatenumber - 7
else: print "No solution found - max limit reached."

###
### template of code for Problem 4 of Problem Set 2, Fall 2008
###

bestSoFar = 1     # variable that keeps track of largest number
                  # of McNuggets that cannot be bought in exact quantity
buyable = False
packages = (6,9,20)   # variable that contains package sizes

for n in range(1, 55):   # only search for solutions up to size 200
    ## complete code here to find largest size that cannot be bought
    ## when done, your answer should be bound to bestSoFar
    print n
    for a in range (0, 55):
        for b in range (0, 55):
            for c in range (0, 55):
                if n == (packages[0] * a) + (packages[1] * b) + (packages[2] * c):
                    print n
                    buyable = True
                    break
                else:
                    buyable = False
            if buyable == True : break
        if buyable == True : break

    if buyable == False:
        bestSoFar = n

print "Largest number of McNuggets that cannot be bought in exact quantity:", bestSoFar

-------------------------------------------------------------------------

###
### template of code for Problem 4 of Problem Set 2, Fall 2008
###

bestSoFar = 1     # variable that keeps track of largest number
                  # of McNuggets that cannot be bought in exact quantity
buyable = False
packages = (7,9,20)   # variable that contains package sizes

for n in range(1, 200):   # only search for solutions up to size 200
    ## complete code here to find largest size that cannot be bought
    ## when done, your answer should be bound to bestSoFar
    print n
    for a in range (0, 200):
        for b in range (0, 200):
            for c in range (0, 200):
                if n == (packages[0] * a) + (packages[1] * b) + (packages[2] * c):
                    print n
                    buyable = True
                    break
                else:
                    buyable = False
            if buyable == True : break
        if buyable == True : break

    if buyable == False:
        bestSoFar = n

print "Largest number of McNuggets that cannot be bought in exact quantity:", bestSoFar

def mcSolver(n, packs):
    x = packs[0]
    y = packs[1]
    z = packs[2]
    for i in xrange(0,n/x+1):
        for j in xrange(0,n/y+1):
            for k in xrange(0,n/z+1):
                if i*x + j*y + k*z == n:
                    return (i, j, k)
    else: return 'No solution.'


#Problem 1
for a in xrange(50,66):
    print a,':',mcSolver(a,(6,9,20))

#Problem 2------------------------------------------------#
#The theorem is true because if six consecutive values are#
#possible to buy, the next (7th) is simply 6 more than the#
#first one, and we already know that you can buy a pack of#
#6 nuggets. Similarly, every larger number can be obtained#
#---------------------------------------------------------#

#Problem 3
mcsolved = 0
n = 0
while mcsolved < 6:
    n += 1
    N = mcSolver(n,(6,9,20))
    if N == 'No solution.':
        mcsolved = 0
    else: mcsolved += 1

print 'Largest number of McNuggets that cannot be bought in exact quantity:',n-6

#Problem 4
bestSoFar = 0
packs = (6,9,20)
for n in xrange(1,201):
    if mcSolver(n, packs) == 'No solution.':
        bestSoFar = n

print 'Given package sizes',str(packs[0])+', '+str(packs[1])+', and '+\
      str(packs[2])+',','the largest number of nuggets that cannot be bought'+\
      'in exact quantity is:',bestSoFar

# Problem 3
# Name: danmanuk


def solve(n):
    #Solve the linear equation 6a+9b+20c=n using exhaustive enumeration
    found = False
    for a in range(0,n+1):
        for b in range(0,n+1):
            for c in range(0,n+1):
                if (6*a)+(9*b)+(20*c) == n:
                    return (a,b,c)
                    found = True
    if not found:return None

count = 0

for num in range(1,100):
    if solve(num) == None:
        ans = num
        count = 0
    else:count+=1
    if count == 6:
        #This gives us an answer given that 6 is the smallest number
        #of nuggests available
        break

print 'The largest number of McNuggets that cannot be bought in exact quantity:',ans 

# Problem 4
# Name: danmanuk

def solve(n,packages):
    #function that finds answer to McNugget problem given
    #a value of n and tuple for x,y,z
    x,y,z = packages
    found = False
    for a in range(0,n+1):
        for b in range(0,n+1):
            for c in range(0,n+1):
                if (x*a)+(y*b)+(z*c) == n:
                    return True
    return None

count = 0       # coutning variable used to keep track of successes
bestSoFar = 0     # variable that keeps track of largest number of McNuggets that cannot be bought in exact quantity
packages = (6,9,20)   # variable that contains package sizes

for n in range(1, 150):
    if solve(n,packages) == None:
        bestSoFar = n
        count = 0
    else:count+=1
    if count == 6:
        break

print 'Given package sizes', packages[0], packages[1], ' and ', packages[2], ' the largest number of McNuggets that cannot be bought in exact quantity is: ',bestSoFar

#
# Problem 3
#
#function isBuyable(n)
def isBuyable(n):
 #if n is divisible, return true
 if n%6==0 or n%9==0 or n%20==0:
  return True
 #if not divisible, subtract 20, 9 and 6 and
 #keep looking again recursively
 if n>20:
  return isBuyable(n-20)
  return isBuyable(n-9)
  return isBuyable(n-6)
 else:
  if n>9:
    return isBuyable(n-9)
    return isBuyable(n-6)
  else:
    if n>6:
     return isBuyable(n-6)
 #the function returns false when
 #n is less than 6
 return False
#function isBuyable(n) END

maxNotBuyable=1
sixConsecBuyableFound=False
n=1
consecBuyableCount=0

while sixConsecBuyableFound==False :
 if isBuyable(n):
  consecBuyableCount+=1
 else:
  consecBuyableCount=0
  maxNotBuyable=n
 if consecBuyableCount==6:
  sixConsecBuyableFound=True
 n+=1

print 'Largest number of Mcnuggets not buyable : ', maxNotBuyable


#
# Problem 4
#
#function isBuyable(n,x,y,z)
def isBuyable(n,x,y,z):
 if n%x==0 or n%y==0 or n%z==0:
  return True
 if n>z:
  return isBuyable(n-z,x,y,z)
  return isBuyable(n-y,x,y,z)
  return isBuyable(n-x,x,y,z)
 else:
  if n>y:
    return isBuyable(n-y,x,y,z)
    return isBuyable(n-x,x,y,z)
  else:
    if n>x:
     return isBuyable(n-x,x,y,z)
 return False
#function isBuyable(n,x,y,z) END

maxNotBuyable=1
smallNumConsecBuyableFound=False
n=1
consecBuyableCount=0
x=int(raw_input('enter x:'))
y=int(raw_input('enter y:'))
z=int(raw_input('enter z:'))
packages=(x,y,z)

while smallNumConsecBuyableFound==False :
 if isBuyable(n,packages[0],packages[1],packages[2]):
  consecBuyableCount+=1
 else:
  consecBuyableCount=0
  maxNotBuyable=n
 if consecBuyableCount==packages[0]:
  smallNumConsecBuyableFound=True
 n+=1
 if n>1000:
  maxNotBuyable='Beyond what could be bought'
  break

print 'Largest number of Mcnuggets : ', maxNotBuyable

#Problem Set 2a: Return the largest unsolvable diophantine equation 
#jayd

def numNuggets(nuggets):
    for numPack20 in range(0,nuggets/20+1):
        #When setting to range it this takes into account the currently selected pack of 20
        for numPack9 in range(0,((nuggets-numPack20*20)/9)+1):
            numPack6=(nuggets-20*numPack20-9*numPack9)/6
            totNuggets = 20*numPack20+9*numPack9 + 6 * numPack6
            if nuggets == totNuggets:
                return True
    return False               
#state varables
n=0
unsolvable=[]
numSolved=0
#Keep solving untill 5 are solved in a row
while numSolved <= 5:
    n+=1
    solved = numNuggets(n)
    if solved == True:
        numSolved+=1
    
    if solved == False:
        numSolved=0
        unsolvable.append(n)
    
print "Largest number of McNuggets that cannot be bought in exact quantity: %i" % unsolvable.pop()
       
#Solution = 43 




#Problem Set 2a
#jayd
#This Function solves the diophantine equation for a tuple of values ordered least to greatest.
def numNuggets(packages,nuggets):
    for large in range(0,nuggets/packages[2]+1):
        #Maximum range takes into account currently selected larger pack
        for medium in range(0,((nuggets-large*packages[2])/packages[1])+1):
            small=(nuggets-packages[2]*large-packages[1]*medium)/packages[0]
            totNuggets = packages[2]*large+packages[1]*medium + packages[0] * small
            #Return True when we find the first soltion
            if nuggets == totNuggets:
                return True
    #When all combinations have been iterated without a solution return false
    return False               

#state varables
n=0
unsolvable=[]
numSolved=0
packsize = (3,7,11)
#Keeps Solving diophantine equations until we have solved at least as many in a row as the smallest pack
while numSolved <= packsize[0]:
    noSolution=False
    n+=1
    #break if no solution found before 200
    if n >= 200:
        noSolution = True
        break
    solved = numNuggets(packsize,n)
    if solved == True:
        numSolved+=1
    
    if solved == False:
        numSolved=0
        unsolvable.append(n)    
if noSolution == False:
    print "Given package sizes %i, %i and %i the largest number of McNuggets that cannot be bought in exact quantity is: %i" % (packsize[0],packsize[1],packsize[2],unsolvable.pop())
else:
    print "Can not find a soltion less than 200"       
 
#Some results from the code
#8,9,20=39
#7,18,23=52
#3,7,11=8


   

def calculate_combinations(x,y,z, limit=200):
    """ Calculates products less than 'limit' that can be made from three integer factors. The integer factors must be provided as arguments in ascending order, followed by the limit (optional)"""
    
    if not x < y < z:
        return "arguments must be provided in ascending order."
    
    if x == 1:
        return "You provided 1, therefore any positive integer can be made."
    
    if x % 2 == 0 and y % 2 == 0 and z % 2 == 0:
        return "You provided all even numbers, I won't bother computing that. Sorry."

    possible = []
    impossible = []
    
    i = 1
    while i <= limit + x:
        if can_be_made(i, x, y, z):
            possible.append(i)
            possible.sort()
            # print "added", i, "to possible" #debug
        else:
            impossible.append(i)
            impossible.sort()
            # print "added", i, "to impossible" #debug
        i += 1
        if len(possible) > x and possible[-1] == (possible[-x] + (x -1)):
            return "Any number greater than %s can be made. The highest number that cannot be made is %s." % (possible[-x], impossible[-1])
    
    #when i gets higher than the limit
    return "The greatest number that cannot be made is greater than the limit"

def can_be_made(n, x,y,z):
        is_possible = False
        for a in range(0, (n/x) + 1):
            for b in range(0, (n/y) + 1):
                for c in range(0, (n/z) + 1):
                    if (a * x) + (b * y) + (c * z) == n:
                        is_possible = True
        return is_possible


## samples
print "Calculating for 6,9,20:", calculate_combinations(6,9,20)
print "Calculating for 3,7,22:", calculate_combinations(3,7,22)
print "Calculating for 3,7,22:", calculate_combinations(3,7,22,10) #low limit
print "Calculating for 3,7,22:", calculate_combinations(3,7,22,11) #bounds test
print "Calculating for 2,4,6:", calculate_combinations(2,4,6)
print "Calculating for 4,3,6:", calculate_combinations(4,3,6)
print "Calculating for 20, 42, 81:", calculate_combinations(20,41,81)
print "Calculating for 20, 42, 81:", calculate_combinations(20, 42, 81, 500) #extend limit

import sys

"""
Return the combinations possbile as a list  
"""
def getNuggets(param,val):
    if not len(param) or val <= 0:
        return []
    # list 
    return [(a1,a2,a3) for a1 in range(val/param[0]+1) for a2 in range(val/param[1]+1) for a3 in range(val/param[2]+1) if (a1*param[0] + a2*param[1] + a3*param[2] == val)]
        
def getMaxNotPossible(param):
    i = count = 0 
    while i < sys.maxint:
        if len(getNuggets(param,i)) != 0: 
            count += 1 
        else: 
            count = 0
        if count == min(param): 
            break;     
        i += 1          
    if count == min(param): 
        return i-min(param)
    else: 
        return -1 
    
        
if __name__ == "__main__":
    print "Largest number of McNuggets that cannot be bought in exact quantity: " , getMaxNotPossible((6,9,20))
    print max([i for i in range(201) if len(getNuggets( (6,9,20), i )) == 0])
    print max([i for i in range(201) if len(getNuggets( (4,5,6), i )) == 0])    
    
    

# Problem Set 2
# Name: jspash
# Collaborators: me
# Time:
#

# Problem #1
targets = range(50, 56)

for i in range(0, 20):
    for j in range(0, 20):
	for k in range(0, 20):
	    tmp = 6*i + 9*j + 20*k
	    if tmp in targets:
		print 'Valid:',
		print str(i) + '*6',
		print str(j) + '*9',
		print str(k) + '*20',
		print '=', tmp

#Program output:
#Valid: 0*6 6*9 0*20 = 54
#Valid: 1*6 1*9 2*20 = 55
#Valid: 1*6 3*9 1*20 = 53
#Valid: 1*6 5*9 0*20 = 51
#Valid: 2*6 0*9 2*20 = 52
#Valid: 2*6 2*9 1*20 = 50
#Valid: 3*6 4*9 0*20 = 54
#Valid: 4*6 1*9 1*20 = 53
#Valid: 4*6 3*9 0*20 = 51
#Valid: 5*6 0*9 1*20 = 50
#Valid: 6*6 2*9 0*20 = 54
#Valid: 7*6 1*9 0*20 = 51
#Valid: 9*6 0*9 0*20 = 54


# Problem #2
# Theorem: If it is possible to buy x, x+1,...,x+5 sets of McNuggets, for some x, then it is
# possible to buy any number of McNuggets >= x, given that McNuggets come in 6, 9 and 20 packs.
#
# Solution: Since it is possible to buy x to x+5, then the next value would be covered by a box
# of 6. Then the x to x+5 sequence would start over. (Not sure how to phrase this in a math-y way!)


def can_be_bought(x):
    for i in range(0, 20):
	for j in range(0, 20):
	    for k in range(0, 20):
		tmp = 6*i + 9*j + 20*k
		if tmp == x:
#		    print 'Found for:', x
		    return True

def is_consecutive(testme):
    if list(testme) == range(testme[0], testme[-1]+1):
	return True

results = []
for n in range(1, 150):
    if not can_be_bought(n):
	# create list of totals which cannot be bought
	results.append(n)

print results
print 'Largest number of McNuggets that cannot be bought in exact quantity:', results[-1]

for x in range(0, len(results)-6):
    slice = results[x:x+6]
    if is_consecutive(slice):
	print 'Found one:', slice


# Problem Set 2
# Name: jspash
# Collaborators: me
# Time: 2:00

def can_be_bought(x, packages):
    for i in range(0, 20):
	for j in range(0, 20):
	    for k in range(0, 20):
		tmp = packages[0]*i + packages[1]*j + packages[2]*k
		if tmp == x:
#		    print 'Found for:', x
		    return True

def is_consecutive(testme):
    if list(testme) == range(testme[0], testme[-1]+1):
	return True

####
#### template of code for Problem 4 of Problem Set 2, Fall 2008
####
#
#bestSoFar = 0     # variable that keeps track of largest number
#    # of McNuggets that cannot be bought in exact quantity
#packages = (6, 9, 20)   # variable that contains package sizes
#
#for n in range(1, 150):   # only search for solutions up to size 150
#    ## complete code here to find largest size that cannot be bought
#    ## when done, your answer should be bound to bestSoFar

bestSoFar = 0
packages = (6, 9, 20)
results = []
for x in range(6, 2000):
    if not can_be_bought(x, packages):
	# create list of totals which cannot be bought
	results.append(x)

#print results

for x in range(0, len(results)-6):
    slice = results[x:x+6]
    if is_consecutive(slice):
	print 'Found it:', slice
	exit();

#testing for maximum n where 6a+9b+20c =! n  PROBLEM #3
impossible_Order = [0,] #collection of impossible order (aka n)
#successful impossible_Order should be (1, 2, 3, 4, 5, 7, 8, 10, 11, 13, 14, 16, etc)
possible_Order = [0, 0, 0, 0, 0, 0]
#collection of values that have a possible solution (not sure if needed)
#prepopulate the first 6 impossible values for calculation reasons
n = 1 #possible instances of numbers of McNuggets that cannot be purchased exactly
max_n = 100 #this is the biggest n we're going to try. 

max_multiplier = int(max_n / 6) #6 is the lowest "denominator" that will fit into n. 

def test_consecutive_values(): #this function will add up the last 6 numbers in possible_Order to see if we've found the solution
    sum_of_values = 0
    if possible_Order[-1] - 1 == possible_Order[-2] and possible_Order[-1] - 2 == possible_Order[-3] and possible_Order[-1] - 3 == possible_Order[-4] and possible_Order[-1] - 4 == possible_Order[-5] and possible_Order[-1] - 5 == possible_Order[-6]:
    #the if statement above tests to see if the orders are consecutive. There is probably a more elegant way of doing this
        return True
    else:
        return False
      
while n < max_n and test_consecutive_values() != True:
    for a in range(max_multiplier):
        for b in range(max_multiplier):
            for c in range(max_multiplier):
                if (6*a + 9*b +20*c == n) and possible_Order[-1] != n:
                    #the above tests n as a possible solution, and also verifies that other solutions (of a,b,c for n weren't found
                    possible_Order.append(n)                   
                    break               
    if possible_Order[-1] != n: #test to see if a possible solution to n has been found. If not, make it an impossible solution.
        impossible_Order.append(n)
    n += 1
possible_Order = possible_Order[6:] # just cleanup since this was preinitialized with six zeroes. 
print "Largest number of McNuggets that cannot be bought in exact quantity: ", impossible_Order[-1]

#the end of problem 3

#########################################
#testing for maximum n where 6a+9b+20c =! n  PROBLEM #4
bestSoFar = 0
packages = (6,9,20)
possible_Order = [0, 0, 0, 0, 0, 0]
#collection of values that have a possible solution (not sure if needed)
#prepopulate the first 6 impossible values for calculation reasons
n = 1 #possible instances of numbers of McNuggets that cannot be purchased exactly
max_n = 200 #this is the biggest n we're going to try. 

max_multiplier = int(max_n / packages[-3]) #divide by the lowest "denominator" that will fit into n. 

def test_consecutive_values(): #this function will add up the last 6 numbers in possible_Order to see if we've found the solution
    sum_of_values = 0
    if possible_Order[-1] - 1 == possible_Order[-2] and possible_Order[-1] - 2 == possible_Order[-3] and possible_Order[-1] - 3 == possible_Order[-4] and possible_Order[-1] - 4 == possible_Order[-5] and possible_Order[-1] - 5 == possible_Order[-6]:
    #the if statement above tests to see if the orders are consecutive. There is probably a more elegant way of doing this
        return True
    else:
        return False

for n in range(1, max_n):
    if test_consecutive_values() == True:
        break
    for a in range(max_multiplier):
        for b in range(max_multiplier):
            for c in range(max_multiplier):
                if (packages[-3]*a + packages[-2]*b +packages[-1]*c == n) and possible_Order[-1] != n:
                    #the above tests n as a possible solution, and also verifies that other solutions (of a,b,c for n weren't found
                    possible_Order.append(n)                   
                    break               
    if possible_Order[-1] != n: #test to see if a possible solution to n has been found. If not, make it an impossible solution.
        bestSoFar = n
possible_Order = possible_Order[6:] # just cleanup since this was preinitialized with six zeroes. 
print "Given package sizes %d, %d, and %d, the largest number of McNuggets that cannot be bought in exact quantity is: %d" % (packages[-3], packages[-2], packages[-1], bestSoFar)

#the end of problem 4

def diophantine(packages=(6,9,20), maxcheck=200):
  sortpack = list(packages)
  sortpack.sort()
  if sortpack[0] <= 1: # Considering a <2pack to mean you don't want an answer
    return None
  unavailable = [1]
  check = 2
  while check < maxcheck and check - unavailable[-1] <= sortpack[0]:
    if not diophantine_test(sortpack, check):
      unavailable.append(check)
    check += 1
  return unavailable


def diophantine_test(sortpack, value):
# Check for single pack size matches
  for pack in sortpack:
    if value % pack == 0:
      return True
  if sortpack[2] > value: # Discard unusable pack size
    if sortpack[1] > value:
      return False # Single packs already checked by modulus
    else:
      return diophantine_two(sortpack[0:2], value)
  else:
    return diophantine_three(sortpack, value)
  return False


def diophantine_two(sortpack, value):
  if value % sortpack[1] == 0:
    return True
  while value >= sortpack[0]:
    if value % sortpack[0] == 0:
      return True
    value -= sortpack[1]
  return False


def diophantine_three(sortpack, value):
  while value >= sortpack[0]:
    if diophantine_two(sortpack[0:2], value):
      return True
    value -= sortpack[2]
  return False


# Part 1
# t  | 20pc | 9pc | 6pc
# 50 | 1    | 2   | 2
# 51 | 0    | 5   | 1
# 52 | 2    | 0   | 2
# 53 | 1    | 1   | 4
# 54 | 0    | 6   | 0
# 55 | 2    | 1   | 1
#
# Given the solutions above the values for 56-65 can be achieved.
# For 56-61 simply take one of the above and add an extra six-pack.
# For 62-65 simply take 56-59 and add an extra six-pack.

# Part 2
# The theorem is true because once you have covered an entire "step" of the lowest size pack
# you can simply add another of the smallest pack to achieve the next number of your choosing.
#
# Note that the same will hold for a larger pack's step-size, if achieveable. However, that
# is not strictly necessary as you will have already met the requirement for the smaller pack.

# Part 3
standard_mcdiophantine = diophantine()
print("Part 3")
print("Largest number of McNuggets that cannot be bought in exact quantity: %d" % standard_mcdiophantine[-1])

# Part 4

def vary_mcdiophantine(x,y,z):
  varied_mcdiophantine = diophantine((x,y,z))
  
  print("Given package sizes %d, %d, and %d, the largest number of McNuggets that cannot be bought in exact quantity is: %d" % (x,y,z,varied_mcdiophantine[-1]))

print("\nPart 4")
vary_mcdiophantine(3,5,7)
vary_mcdiophantine(9,4,6)
vary_mcdiophantine(3,7,11)
vary_mcdiophantine(4,11,8)

#! /usr/bin/env python
# -*- coding: utf8 -*-
## (i'm using linux now. Much easier. For the uninitiated: the 
## above invokes python in a terminal window to interpret the 
## script file I write my code in.)

# Problem 2
## If you can buy x, x+ 1... x + 5,
## adding 6 to your previous values will get the next numbers in the sequence. 
## Therefore, if you can find solutions for 6 in a row, then you can find solutions
## for aall greater values of x.

# Problem 3

## maxval(box, guess) finds the largest feasible number
## of boxes worth trying for a given guess. This will later be 
## converted into a range. In retrospect, this function could 
## just as well have returned the range.

def maxval(box, guess):
	counter = 0
	x = 0
	while x <= guess:
		counter += 1
		x += box
	if counter > 1:	
		return counter
	else:
		return 1

## The code below "return False" is the workhorse of solving this
## problem. As the code finds solutions to the equation 6a + 9b 
## +20c, it stores them in the list 'solutions.' 
## sixconsecutive(list, value) appends the value to the list if it's ## not there already, then checks to see if there are 6 consecutive ## values in a row. If not, the function returns 'False.' If yes, the 
## function returns "True," which will return a solution below.

def sixconsecutive(placeholder, newitem):
	if newitem not in placeholder:
		placeholder.append(newitem)
	if (len(placeholder) >= 6) and (placeholder[-1] - placeholder[-6] == 5):
		return True
	else:
		return False

##initializing some variables
guess = 0
solutions = []
solution = False
while solution == False:
	guess += 1
	# generating ranges to test
	ma = maxval(6, guess)
	mb = maxval(9, guess)
	mc = maxval(20, guess)
	Arange = range(0, ma)
	Brange = range(0, mb)
	Crange = range(0, mc)
	for a in Arange:
		for b in Brange:
			for c in Crange:
				if (6*a + 9*b + 20*c) == guess:
					print guess, solutions, a, b, c
					solution = sixconsecutive(solutions, guess)				
print "Largest number of McNuggets that cannot be bought in exact quantity: ", guess - 6

# Problem 4

a = int(raw_input("a: "))
b = int(raw_input("b: "))
c = int(raw_input("c: "))
packages = (a, b, c)
smallest = min(packages)

# Used the exact same strategy from problem 3 and most of the same code. Basically, I just replaced 6, 9, and 20 with the values given by 'packages,' and replaced '6' with min(packages) where appropriate.

def maxconsecutive(placeholder, newitem):
	if newitem not in placeholder:
		placeholder.append(newitem)
	if (len(placeholder) >= smallest) and (placeholder[-1] - placeholder[-smallest] == smallest -1):
		return True
	else:
		return False

guess = 0
solutions = []
solution = False
p = packages[0]
q = packages[1]
r = packages[2]
while solution == False:
	guess += 1
	ma = maxval(p, guess)
	mb = maxval(q, guess)
	mc = maxval(r, guess)
	Arange = range(0, ma)
	Brange = range(0, mb)
	Crange = range(0, mc)
	for a in Arange:
		for b in Brange:
			for c in Crange:
				if (p*a + q*b + r*c) == guess:
					print guess, solutions, a, b, c
					solution = maxconsecutive(solutions, guess)				
print "Largest number of McNuggets that cannot be bought in exact quantity: ", guess - smallest

combinations = []

#increment a, increment b, increment c, add those combinations 
#together, and store in list
#this doesn't create all possible permutations, but it goes far beyond 
#what I needed here.  Which was to show that if 49,50,51 can be achieved 
#then so can 52,53,54.  I choose to prove it by just generating many 
#combinations

def brute_force_nugget():
    for a in range(0,100):
            for b in range(0,100):
                    for c in range(0,100):
                            #append these combinations to a list, 			
                            combinations.append(a*6+b*9+c*20)

    #defining a new list that is an numerically ascending copy of 
    #combinations
    sort_combo = sorted(combinations)

    #define a new list, and then append non-duplicate numbers into it
    sifted_combo = []
    for i in range(0,len(sort_combo)-1):
            if sort_combo[i] != sort_combo[i+1]:
                    sifted_combo.append(sort_combo[i])


    #define a list to store the 'gaps', count returns number of instances a 
    #number appears in a list.
    store_list = []
    for i in range(0,100):
            if sifted_combo.count(i) == 0:
                    store_list.append(i)

    #trick to remember: [-1] is last entry in a list
    #finally the solution:

    print "The largest number of nuggets unable to be ordered if there are"
    print "6, 9 and 20 available is", store_list[-1]


def not_possible_to_buy(packages):
    combinations = []
        
    for a in range (0,100+min(packages)):
        for b in range (0,100 + min(packages)):
            for c in range (0,100 + min(packages)):
                combinations.append(a*packages[0]+b*packages[1]+c*packages[2])                

    sort_combo = sorted(combinations)

    sifted_combo = []

    for i in range(0,len(sort_combo)-1):
        if sort_combo[i] != sort_combo[i+1]:
            sifted_combo.append(sort_combo[i])

    store_list = []

    for i in range(0,200):
            if sifted_combo.count(i) == 0:
                    store_list.append(i)
    print "The largest number unable to be ordered for, ", packages, "is ", store_list[-1], "."