bif="bb.jpg" #black background#
mif="b.png"   #ball#



import pygame, sys, glob
from pygame.locals import *

pygame.init()

screen=pygame.display.set_mode((640,360),0,32)
background=pygame.image.load(bif).convert()
ball=pygame.image.load(mif).convert_alpha()

x=0
clock=pygame.time.Clock()
speed=250
while True:

    for event in pygame.event.get():
        if event.type == QUIT:
            pygame.quit()
            sys.exit()

screen.blit(background, (0,0))
screen.blit(ball, (x, 160))

milli=clock.tick()
seconds=milli/1000.0
dm=seconds*speed
x+=dm

if x>640:
    x=0
    
pygame.display.update()

def largestNumberUnpurchasableMcNuggets(pack,limit):
    """Largest number of McNuggets that cannot be bought in exact quantity"""

    def mcNuggets(requested,pack,limit):
        """Complete search"""
        for q1 in range(0,limit/pack[0]+1):
            for q2 in range(0,limit/pack[1]+1):
                 for q3 in range(0,limit/pack[2]+1):
                     if pack[0]*q1+pack[1]*q2+pack[2]*q3 == requested:
                         return (q1,q2,q3)
        assert(False)

    n = limit
    while (n > pack[0]-1):
        try:
            quantities = mcNuggets(n,pack,limit)
            n -= 1
        except:
            assert(n<limit)
            return n
    return pack[0]-1

def problemSet2():
    """McNuggets Diophantine equation"""

    pack = (6, 9, 20)
    limit = 200
    print "Given package sizes",pack,"the largest number of McNuggets that cannot be bought in exact quantity is:",largestNumberUnpurchasableMcNuggets(pack, limit)

    pack = (7, 13, 20)
    limit = 200
    print "Given package sizes",pack,"the largest number of McNuggets that cannot be bought in exact quantity is:",largestNumberUnpurchasableMcNuggets(pack, limit)

    pack = (9, 17, 20)
    limit = 200
    print "Given package sizes",pack,"the largest number of McNuggets that cannot be bought in exact quantity is:",largestNumberUnpurchasableMcNuggets(pack, limit)

def largestNumberUnpurchasableMcNuggets():
    """Largest number of McNuggets that cannot be bought in exact quantity"""

    def mcNuggets(requested,pack,limit):
        """Complete search"""
        for q1 in range(0,limit):
            for q2 in range(0,limit):
                 for q3 in range(0,limit):
                     if pack[0]*q1+pack[1]*q2+pack[2]*q3 == requested:
                         return (q1,q2,q3)
        assert(False)

    pack = (6, 9, 20)
    limit = 11
    n = 49
    while (n > 5):
        try:
            quantities = mcNuggets(n,pack,limit)
            n -= 1
        except:
            return n
    return 5

def problemSet2():
    """McNuggets Diophantine equation"""
    print "Largest number of McNuggets that cannot be bought in exact quantity: ", largestNumberUnpurchasableMcNuggets()

def updateScroll():
    global grid, gamemap
    for i in range(rows):    
        for row in range(rows):
            grid[i][row] = gamemap[mapx+i][row]   

from math import *

def sumPrimesLogsTo(n):
    """Computes the sum of logs of primes < n"""

    def divisible(curr,d):
        """Check if curr is divisible by an element of d"""
        for i in d:
            if (i > sqrt(curr)):
                return False
            elif (curr % i == 0):
                return True
        return False

    def calculatePrimesLessThan(n):
        """Computes the primes less then"""
        d = {1:2}
        d1 = {}
        idx = 2
        cnt = 1
        curr = 1+2*cnt
        while (curr <= n):
            if (not divisible(curr,d1.values())):
                d1.update({idx:curr})
                idx += 1
            cnt += 1
            curr = 1+2*cnt
        d.update(d1)
        return d

    assert(n > 2)
    assert(type(n)==type(1))
    d = calculatePrimesLessThan(n)
    res = 0.0
    for v in d.values():
        res += log(v)
    return res

def problemSet1():
    """Verify for different values of n the sum of logs of primes < n"""
    n = 3
    res = sumPrimesLogsTo(n)
    print 'Logs sum: ',res, 'n: ', n, 'ratio: ', res/n
    n = 10
    res = sumPrimesLogsTo(n)
    print 'Logs sum: ',res, 'n: ', n, 'ratio: ', res/n
    n = 100
    res = sumPrimesLogsTo(n)
    print 'Logs sum: ',res, 'n: ', n, 'ratio: ', res/n
    n = 1000
    res = sumPrimesLogsTo(n)
    print 'Logs sum: ',res, 'n: ', n, 'ratio: ', res/n
    n = 10000
    res = sumPrimesLogsTo(n)
    print 'Logs sum: ',res, 'n: ', n, 'ratio: ', res/n
    n = 100000
    res = sumPrimesLogsTo(n)
    print 'Logs sum: ',res, 'n: ', n, 'ratio: ', res/n

from math import *

def defineIthPrime(position):
    """Computes the ith prime number"""

    def divisible(curr,d):
        """Check if curr is divisible by an element of d"""
        for i in d:
            if (i > sqrt(curr)):
                return False
            elif (curr % i == 0):
                return True
        return False

    def calculateIthPrime(position):
        """Computes the 1:ith prime number"""
        d = {1:2}
        d1 = {}
        idx = 2
        cnt = 1
        curr = 1+2*cnt
        while (idx <= position):
            if (not divisible(curr,d1.values())):
                d1.update({idx:curr})
                idx += 1
            cnt += 1
            curr = 1+2*cnt
        d.update(d1)
        return d

    assert(position > 0)
    assert(type(position)==type(1))
    d = calculateIthPrime(position)
    return d[position]

def problemSet1():
    """Computes and prints the 1000th prime number"""
    result = defineIthPrime(1000)
    print "The 1000th prime number is ", result

#!/usr/bin/python
import os, sys, getopt, shutil
branch, user = "",""

if __name__ == "__main__":
    argv = sys.argv[1:]
    try:
       opts, args = getopt.getopt(argv, 'hd:e', ['help', 'branch=', 'user='])
    except getopt.GetoptError:
       print __doc__
       sys.exit()

    for opt, arg in opts:
       if opt in ('-h', '--help'):
           print __doc__
           sys.exit()
       if opt in ('-d', '--branch'):
           branch = arg
       if opt in ('-e', '--user'):
           user = arg

shutil.rmtree("/home/company/%s/%s" % (branch , user))