Beispiel #1
0
import mtools
import unittest

def get_answer():
    f = file('b003313.txt')
    i = 0
    n = 0
    for line in f:
        l = line.strip().split(' ')
        n += int(l[1])
        i += 1
        if i == 200:
            return n

class TP(unittest.TestCase):
    def test_m(self):
        pass

class P:
    def test(self):
        suite = unittest.TestLoader().loadTestsFromTestCase(TP)
        result = unittest.TextTestRunner(verbosity=2).run(suite)
        return result.wasSuccessful()

    def solve(self):
        return get_answer()

if __name__ == "__main__":
    mtools.run(P())
Beispiel #2
0
                tab[s] = i
        i += 1
    return True

def conv_set(l):
    return [int(x) for x in l.split(',')]

class q105:  
    def test(self):
        assert [37,48,34,59,39,41,40] == conv_set("37,48,34,59,39,41,40")
        assert not is_special_set([1,2,3])
        assert not is_special_set([1,2,3,4])
        assert is_special_set([2, 3, 4])
        assert is_special_set([3, 5, 6, 7])
        assert is_special_set([6, 9, 11, 12, 13])
        assert not is_special_set([81, 88, 75, 42, 87, 84, 86, 65])
        assert is_special_set([157, 150, 164, 119, 79, 159, 161, 139, 158])

    def solve(self):
        f = file("105_sets.txt")
        n = 0
        for l in f:
            s = conv_set(l)
            if is_special_set(s):
                n += sum(s) 
        f.close()
        return n

if __name__ == "__main__":
    mtools.run(q105())
Beispiel #3
0
        cnt = f(n, m)
        for i in range(m, n+1):
            for j in range(n-i+1):
                cnt += g(j-1, m)
        visited[(n,m)] = cnt
        return cnt

def fill(n, m):
    return 1 + g(n,m)

class TestP114(unittest.TestCase):
    def test1(self):
        self.assertEqual(17, fill(7, 3), "p114 known condition")
        
    def test2(self):
        self.assertEqual(673135, fill(29, 3), "p115 known condition")
        self.assertEqual(1089155, fill(30, 3), "p115 known condition")
        pass

class P114:
    def test(self):
        suite = unittest.TestLoader().loadTestsFromTestCase(TestP114)
        result = unittest.TextTestRunner(verbosity=2).run(suite)
        return result.wasSuccessful()

    def solve(self):
        return fill(50, 3)

if __name__ == "__main__":
    mtools.run(P114())
Beispiel #4
0
                return 'Duplicated.'
        except KeyError:
            print h
            d[h] = True                        
    return cnt

class TestP118(unittest.TestCase):
    def test_trunc_number(self):
        numbers = trunc_number(254789631, 1, 4)
        self.assertEqual(4, len(numbers))
        self.assertEqual((2, 54789631), numbers[0])
        self.assertEqual((2547, 89631), numbers[3])

    def test_count_partition(self):
        c, s = count_partition(127859463)
        self.assertEqual(0, c)
        c, s = count_partition(127643859)
        self.assertEqual(2, c)

class P118:
    def test(self):
        suite = unittest.TestLoader().loadTestsFromTestCase(TestP118)
        result = unittest.TextTestRunner(verbosity=2).run(suite)
        return result.wasSuccessful()

    def solve(self):
        return count()

if __name__ == "__main__":
    mtools.run(P118())
Beispiel #5
0
                        fr[w] = v
                    if wt[w] < wt[min]:
                        min = w
                w += 1
        self.mst = st
        self.mst_wt = wt

    def mst_weight(self):
        self.prim_mst()        
        return sum([edge(x) for x in self.mst_wt])
    
    def optimized_flow(self):
        ew = self.edges_weight()
        mw = self.mst_weight()
        print ew, mw
        return ew - mw        

class q107: 
    def test(self):
        g = Graph('107_test.txt')
        assert 10 == g.edges_weight()
        f = g.optimized_flow()
        assert 6 == f

    def solve(self):
        g = Graph('107_network.txt')
        return g.optimized_flow()

if __name__ == "__main__":
    mtools.run(q107())
Beispiel #6
0
            low = n1+1
        elif v > lim:
            high = n1-1
        else:
            return n1
        n2 = (high+low)/2
        if n1 == n2:
            if high > low:
                return high
            return low

class TestP115(unittest.TestCase):
    def test1(self):
        self.assertEqual(880711, fill(56, 10), "p115 known condition")
        self.assertEqual(1148904, fill(57, 10), "p115 known condition")

    def test_search_min(self):
        self.assertEqual(57, search_min(10, 1000000))

class P115:
    def test(self):
        suite = unittest.TestLoader().loadTestsFromTestCase(TestP115)
        result = unittest.TextTestRunner(verbosity=2).run(suite)
        return result.wasSuccessful()

    def solve(self):
        return search_min(50, 1000000)

if __name__ == "__main__":
    mtools.run(P115())
Beispiel #7
0
    def test_f(self):
        self.assertEqual(2, f([1]))
        self.assertEqual(3, f([2]))
        self.assertEqual(5, f([1,1]))
        self.assertEqual(8, f([2,1]))
        self.assertEqual(14, f([1,1,1]))
        self.assertEqual(13, f([2,2]))
        
    def test_expand_states(self):
        self.assertEqual([[2], [1,1]], expand_states([1]))
        self.assertEqual([[3], [2,1]], expand_states([2]))
        self.assertEqual([[2,1], [1,1,1]], expand_states([1,1]))
        self.assertEqual([[3,1], [2,2],[2,1,1]], expand_states([2,1]))
        
    def test_search(self):
        self.assertEqual(180180, search([1], 1000), "p108 answer")
        self.assertEqual(2768774904222066200260800,search([1], 10**9),
                         "answer for 1 billion mentioned in p108 forum thread") 

class P110:
    def test(self):
        suite = unittest.TestLoader().loadTestsFromTestCase(TestP110)
        result = unittest.TextTestRunner(verbosity=2).run(suite)
        return result.wasSuccessful()

    def solve(self):
        return search([1], 4000000)

if __name__ == "__main__":
    mtools.run(P110())
Beispiel #8
0
'''

import mtools
import unittest

def f(x, y):
    return mtools.c(x+y-1, y)

def count_not_bouncy(m, n):
    return sum([f(m, y) for y in range(1,n+1)]) \
        + sum([f(x, y) for x in range(1,m+1) for y in range(1, n+1)]) \
        - n*m

class TestP113(unittest.TestCase):
    def test1(self):
        self.assertEqual(12951, count_not_bouncy(6, 9))
    def test2(self):
        self.assertEqual(277032, count_not_bouncy(10, 9))

class P113:
    def test(self):
        suite = unittest.TestLoader().loadTestsFromTestCase(TestP113)
        result = unittest.TextTestRunner(verbosity=2).run(suite)
        return result.wasSuccessful()

    def solve(self):
        return count_not_bouncy(100, 9)

if __name__ == "__main__":
    mtools.run(P113())
Beispiel #9
0
        for m in range(2,5):
            for j in range(n-m+1):
                ret += g(j)
        visited[n] = ret
        return ret

def fill(n):
    return 1 + g(n)

class TestP117(unittest.TestCase):
    def test_g(self):
        self.assertEqual(1, g(2))
        self.assertEqual(3, g(3))
        self.assertEqual(7, g(4))
        
    def test_fill(self):
        #p117 known condition
        self.assertEqual(15, fill(5))
        
class P117:
    def test(self):
        suite = unittest.TestLoader().loadTestsFromTestCase(TestP117)
        result = unittest.TextTestRunner(verbosity=2).run(suite)
        return result.wasSuccessful()

    def solve(self):
        return fill(50)

if __name__ == "__main__":
    mtools.run(P117())
Beispiel #10
0
                sc.remove_step()
            if n < 0:
                return
            n = n1

def checkout(n):
    sc = SearchContext(0)
    dart(n, 1, sc)
    return sc.count

def total_checkout(m):
        l = [(n, checkout(n)) for n in range(1, m)]
        a = 0
        for (x, y) in l:
            if y > 0:
                a += y
        return a

class q109: 
    def test(self):
        assert 11 == checkout(6)
        assert 5 == checkout(5)
        assert 42336 == total_checkout(171)
        
    def solve(self):
        return total_checkout(100)

if __name__ == "__main__":
    double_points, points = init_points()
    mtools.run(q109())
Beispiel #11
0
    s = 0
    for i in range(n):
        for j in range(i+1, n):
            if need_compare(combs[i], combs[j]):
                #print 'cmp: %s & %s' % (combs[i], combs[j])
                s += 1
    return s

def sum_c(n):
    s = 0
    l = range(n)
    for i in range(2, n-1):
        combs = mtools.comb(l, i)
        combs2 = [c for c in combs]
        #print combs2
        s += to_compare(combs2)
    return s

class q106: 
    def test(self):
        assert need_compare([1, 4], [2, 3])
        assert not need_compare([1, 2], [3, 4])
        assert 1 == sum_c(4)
        assert 70 == sum_c(7)
        
    def solve(self):
        return sum_c(12)
    
if __name__ == "__main__":
    mtools.run(q106())
    
Beispiel #12
0
        for i in range(n-m+1):
            ret += g(i, m)
        visited[(n,m)] = ret
        return ret

def fill2(n):
    return sum([g(n, i) for i in range(2,5)])

class TestP116(unittest.TestCase):
    def test_g(self):
        #p116 known condition
        self.assertEqual(7, g(5,2))
        self.assertEqual(3, g(5,3))
        self.assertEqual(2, g(5,4))

    def test_fill2(self):
        #p116 known condition
        self.assertEqual(12, fill2(5))
        
class P116:
    def test(self):
        suite = unittest.TestLoader().loadTestsFromTestCase(TestP116)
        result = unittest.TextTestRunner(verbosity=2).run(suite)
        return result.wasSuccessful()

    def solve(self):
        return fill2(50)

if __name__ == "__main__":
    mtools.run(P116())
Beispiel #13
0
                try:
                    if checked[inum]:
                        continue
                except KeyError:
                    checked[inum] = True
                if mtools.is_prime(inum):
                    prime_found = True
                    primes_sum += inum
        i += 1
    return primes_sum


class p111:
    def test(self):
        assert 3 == M(4, 1)
        assert 2 == M(4, 0)
        assert 3 == M(4, 7)
        assert 1 == N(4, 2)
        assert 12 == N(4, 3)
        assert 13 == N(4, 0)
        assert 67061 == S(4, 0)
        assert 22275 == S(4, 1)
        assert 2221 == S(4, 2)

    def solve(self):
        return sum([S(10, d) for d in range(10)])


if __name__ == "__main__":
    mtools.run(p111())