chrislo-sourceclassifier 0.2.0 → 0.2.1

data/sources/python/message.python-2.python

@@ -1,20 +0,0 @@
-# The Computer Language Benchmarks Game
-# http://shootout.alioth.debian.org/
-# contributed by Tobias Polzin, translated from Mike Pall's Lua program
-# modified by Brian Atkinson
-# modified again by Heinrich Acker
-
-import sys
-
-def create_coroutine(n):
-    if n > 1:
-	coroutine = create_coroutine(n-1)
-	cn = coroutine.next
-	while 1:
-	    yield cn()+1
-    while 1:
-	yield 1
-
-coroutine = create_coroutine(500)
-cn = coroutine.next
-print sum(cn() for i in xrange(int(sys.argv[1])))

data/sources/python/message.python-3.python

@@ -1,19 +0,0 @@
-# The Computer Language Benchmarks Game
-# http://shootout.alioth.debian.org/
-# contributed by Tobias Polzin, translated from Mike Pall's Lua program
-# modified by Brian Atkinson
-# modified again by Heinrich Acker
-
-import sys, gc
-gc.disable()
-
-def create_coroutine(n):
-    if n > 1:
-	cn = create_coroutine(n-1).next
-	while 1:
-	    yield cn()+1
-    while 1:
-	yield 1
-
-cn = create_coroutine(500).next
-print sum(cn() for i in xrange(int(sys.argv[1])))

data/sources/python/meteor.python

@@ -1,210 +0,0 @@
-#   The Computer Language Shootout
-#   http://shootout.alioth.debian.org/
-#
-#   contributed by: Olof Kraigher
-
-from sys import argv
-
-width = 5
-height = 10
-
-directions  = { "E" : 0, "NE" : 1, "NW" : 2, "W" : 3, "SW" : 4, "SE" : 5}
-rotate      = { "E" : "NE", "NE" : "NW", "NW" : "W", "W" : "SW", "SW" : "SE", "SE" : "E"}
-flip        = { "E" : "W", "NE" : "NW", "NW" : "NE", "W" : "E", "SW" : "SE", "SE" : "SW"}
-move        = { "E" : lambda x,y: (x+1,y), 
-                "W" : lambda x,y: (x-1,y),
-                "NE" : lambda x,y: (x+(y%2),y-1),
-                "NW" : lambda x,y: (x+(y%2)-1,y-1),
-                "SE" : lambda x,y: (x+(y%2),y+1),
-                "SW" : lambda x,y: (x+(y%2)-1,y+1)}
-                
-pieces =   [    ["E", "E", "E", "SE"],
-                ["SE", "SW", "W", "SW"],
-                ["W", "W", "SW", "SE"],
-                ["E",  "E", "SW", "SE"],
-                ["NW", "W", "NW", "SE", "SW"],
-                ["E",  "E", "NE", "W"],
-                ["NW", "NE", "NE", "W"],
-                ["NE", "SE", "E", "NE"],
-                ["SE", "SE", "E", "SE"],
-                ["E", "NW", "NW", "NW"]]
-                
-solutions = []
-masks = [0 for i in xrange(10)]
-            	
-valid = lambda x,y: (0 <= x) and (x < width) and (0 <= y) and (y < height)
-legal = lambda mask,board: (mask & board) == 0
-zerocount = lambda mask: sum(map(lambda x: ((1<<x) & mask) == 0, xrange(50)))
-
-def findFreeCell(board):
-    for y in xrange(height):
-        for x in xrange(width):
-            if board & (1 << (x + width*y)) == 0:
-                return x,y
-                
-
-def floodFill(board, (x, y)):
-    if not valid(x,y):
-        return board
-    if board & (1 << (x + width*y)) != 0:
-        return board
-        
-    board = board | (1 << (x + width*y))
-    
-    for f in move.values():
-        board = board | floodFill(board, f(x,y))
-        
-    return board
-    
-def noIslands(mask):
-    zeroes = zerocount(mask)
-    
-    if zeroes < 5:
-        return False
-    
-    while mask != 0x3FFFFFFFFFFFF:
-        mask = floodFill(mask, findFreeCell(mask))
-        new_zeroes = zerocount(mask)
-        
-        if zeroes - new_zeroes < 5:
-            return False
-            
-        zeroes = new_zeroes
-        
-    return True
-
-def getBitmask(x,y,piece):
-    mask = (1 << (x + width*y))
-    
-    for cell in piece:
-        x,y = move[cell](x,y)
-        if valid(x,y):
-            mask = mask | (1 << (x + width*y))
-        else:
-            return False, 0
-            
-    return True, mask
-    
-def allBitmasks(piece, color):
-    bitmasks = []
-    for orientations in xrange(2):
-        for rotations in xrange(6 - 3*(color == 4)):
-            for y in xrange(height):
-                for x in xrange(width):
-                    isValid, mask = getBitmask(x,y,piece)
-                    if isValid and noIslands(mask):
-                        bitmasks.append(mask)
-                        
-            piece = map(lambda cell: rotate[cell], piece)
-        piece = map(lambda cell: flip[cell], piece)
-        
-                        
-    return bitmasks
-    
-def generateBitmasks():
-    
-    global masksAtCell
-    
-    masksAtCell = [[[] for j in xrange(10)] for i in xrange(width*height)]
-    
-    color = 0
-    for piece in pieces:
-        masks = allBitmasks(piece, color)
-        masks.sort()
-        cellMask = 1 << (width*height-1)
-        cellCounter = width*height-1
-
-        j = len(masks)-1
-        
-        while (j >= 0):
-            if (masks[j] & cellMask) == cellMask:
-                masksAtCell[cellCounter][color].append(masks[j])
-                j = j-1
-            else:
-                cellMask = cellMask >> 1
-                cellCounter -= 1
-        color += 1
-
-
-def solveCell(cell, board, n):
-
-    global solutions, masks, masksAtCell   
-
-    if len(solutions) >= n:
-    	return
-    
-    if board == 0x3FFFFFFFFFFFF:
-        # Solved
-        s = stringOfMasks(masks)
-    	solutions.append(s);
-    	solutions.append(inverse(s));
-    	return
-    
-    if board & (1 << cell) != 0:
-        # Cell full
-    	solveCell(cell-1, board, n)
-    	return
-    
-    if cell < 0:
-    	# Out of board
-    	return
-    
-    for color in xrange(10):
-    	if masks[color] == 0:
-            for mask in masksAtCell[cell][color]:
-                if legal(mask, board):
-                    masks[color] = mask
-                    solveCell(cell-1, board | mask, n);
-                    masks[color] = 0
-    				
-def solve(n):
-    generateBitmasks()
-    solveCell(width*height-1, 0, n)
-    
-  
-def stringOfMasks(masks):
-    s = ""
-    mask = 1;
-    for y in xrange(height):
-        for x in xrange(width):
-            for color in xrange(10):
-                if (masks[color] & mask) != 0:
-                    s += str(color)
-                    break
-                elif color == 9:
-                    s += "."
-            mask = mask << 1
-    return s
-    
-def inverse(s):
-    ns = map(lambda x:x,s)
-    
-    for x in xrange(width):
-        for y in xrange(height):
-            ns[x + y*width] = s[width-x-1 + (width - y - 1)*width]
-            
-    return s
-            
-def printSolution(solution):
-    for y in xrange(height):
-        for x in xrange(width):
-            print solution[x + y*width],
-            
-        if (y%2) == 0:
-            print ""
-            print "",
-        else:
-            print ""
-	
-if __name__ == "__main__":
-    
-    if not len(argv) > 1:
-        exit()
-    
-    solve(int(argv[1]))
-    print len(solutions), "solutions found"
-    print
-    printSolution(min(solutions))
-    print
-    printSolution(max(solutions))
-    print

data/sources/python/meteor.python-2.python

@@ -1,192 +0,0 @@
-# The Computer Language Benchmarks Game
-# http://shootout.alioth.debian.org/
-#
-# contributed by Olof Kraigher
-# modified by Tupteq
-
-import sys
-
-width = 5
-height = 10
-
-rotate = dict(E='NE', NE='NW', NW='W', W='SW', SW='SE', SE='E')
-flip = dict(E='W', NE='NW', NW='NE', W='E', SW='SE', SE='SW')
-move = dict(E=lambda x, y: (x+1, y),
-            W=lambda x, y: (x-1, y),
-            NE=lambda x, y: (x + (y%2), y-1),
-            NW=lambda x, y: (x + (y%2) - 1, y-1),
-            SE=lambda x, y: (x + (y%2), y+1),
-            SW=lambda x, y: (x + (y%2) - 1, y+1))
-
-solutions = []
-masks = 10 * [0]
-
-valid = lambda x, y: 0 <= x < width and 0 <= y < height
-zerocount = lambda mask: sum(map(lambda x: (1<<x) & mask == 0, xrange(50)))
-
-
-def findFreeCell(board):
-    for y in xrange(height):
-        for x in xrange(width):
-            if board & (1 << (x + width*y)) == 0:
-                return x, y
-
-
-def floodFill(board, (x, y)):
-    if valid(x, y) and board & (1 << (x + width*y)) == 0:
-        board |= 1 << (x + width*y)
-
-        for f in move.values():
-            board |= floodFill(board, f(x, y))
-
-    return board
-
-
-def noIslands(mask):
-    zeroes = zerocount(mask)
-
-    if zeroes < 5:
-        return False
-
-    while mask != 0x3FFFFFFFFFFFF:
-        mask = floodFill(mask, findFreeCell(mask))
-        new_zeroes = zerocount(mask)
-
-        if zeroes - new_zeroes < 5:
-            return False
-
-        zeroes = new_zeroes
-
-    return True
-
-
-def getBitmask(x, y, piece):
-    mask = 1 << (x + width*y)
-
-    for cell in piece:
-        x, y = move[cell](x, y)
-        if valid(x, y):
-            mask = mask | (1 << (x + width*y))
-        else:
-            return False, 0
-
-    return True, mask
-
-def allBitmasks(piece, color):
-    bitmasks = []
-    for orientations in xrange(2):
-        for rotations in xrange(6 - 3*(color == 4)):
-            for y in xrange(height):
-                for x in xrange(width):
-                    isValid, mask = getBitmask(x, y, piece)
-                    if isValid and noIslands(mask):
-                        bitmasks.append(mask)
-
-            piece = map(lambda cell: rotate[cell], piece)
-        piece = map(lambda cell: flip[cell], piece)
-
-    return bitmasks
-
-
-def generateBitmasks():
-    global masksAtCell
-
-    pieces = [["E", "E", "E", "SE"], ["SE", "SW", "W", "SW"],
-        ["W", "W", "SW", "SE"], ["E",  "E", "SW", "SE"],
-        ["NW", "W", "NW", "SE", "SW"], ["E",  "E", "NE", "W"],
-        ["NW", "NE", "NE", "W"], ["NE", "SE", "E", "NE"],
-        ["SE", "SE", "E", "SE"], ["E", "NW", "NW", "NW"]]
-
-    masksAtCell = [[[] for j in xrange(10)] for i in xrange(width*height)]
-
-    color = 0
-    for piece in pieces:
-        masks = allBitmasks(piece, color)
-        masks.sort()
-        cellMask = 1 << (width*height - 1)
-        cellCounter = width*height - 1
-        j = len(masks) - 1
-
-        while (j >= 0):
-            if (masks[j] & cellMask) == cellMask:
-                masksAtCell[cellCounter][color].append(masks[j])
-                j = j-1
-            else:
-                cellMask = cellMask >> 1
-                cellCounter -= 1
-        color += 1
-
-
-def solveCell(cell, board):
-    if to_go <= 0:
-        # Got enough solutions
-        pass
-    elif board == 0x3FFFFFFFFFFFF:
-        # Solved
-        addSolutions()
-    elif board & (1 << cell) != 0:
-        # Cell full
-        solveCell(cell-1, board)
-    elif cell < 0:
-        # Out of board
-        pass
-    else:
-        for color in xrange(10):
-            if masks[color] == 0:
-                for mask in masksAtCell[cell][color]:
-                    if mask & board == 0:
-                        masks[color] = mask
-                        solveCell(cell-1, board | mask)
-                        masks[color] = 0
-
-
-def addSolutions():
-    global to_go
-    s = ''
-    mask = 1
-    for y in xrange(height):
-        for x in xrange(width):
-            for color in xrange(10):
-                if masks[color] & mask != 0:
-                    s += str(color)
-                    break
-                elif color == 9:
-                    s += '.'
-            mask <<= 1
-
-    # Inverse
-    ns = ''
-    for y in xrange(height):
-        for x in xrange(width):
-            ns += s[width - x - 1 + (width - y - 1) * width]
-
-    # Finally append
-    solutions.append(s)
-    solutions.append(ns)
-    to_go -= 2
-
-
-def printSolution(solution):
-    for y in xrange(height):
-        for x in xrange(width):
-            print solution[x + y*width],
-
-        print ""
-        if y % 2 == 0:
-            print "",
-    print
-
-
-def solve(n):
-    global to_go
-    to_go = n
-    generateBitmasks()
-    solveCell(width*height - 1, 0)
-
-
-if __name__ == "__main__":
-    solve(int(sys.argv[1]))
-
-    print "%d solutions found\n" % len(solutions)
-    printSolution(min(solutions))
-    printSolution(max(solutions))

data/sources/python/methcall.python

@@ -1,51 +0,0 @@
-#!/usr/bin/python
-# http://www.bagley.org/~doug/shootout/
-
-import sys
-
-class Toggle:
-    def __init__(self, start_state):
-        self.bool = start_state
-    def value(self):
-        return(self.bool)
-    def activate(self):
-        self.bool = not self.bool
-        return(self)
-
-class NthToggle(Toggle):
-    def __init__(self, start_state, max_counter):
-        Toggle.__init__(self, start_state)
-        self.count_max = max_counter
-        self.counter = 0
-    def activate(self):
-        self.counter += 1
-        if (self.counter >= self.count_max):
-            self.bool = not self.bool
-            self.counter = 0
-        return(self)
-
-
-def main():
-    NUM = int(sys.argv[1])
-    if NUM < 1:
-        NUM = 1
-
-    val = 1
-    toggle = Toggle(val)
-    for i in xrange(0,NUM):
-        val = toggle.activate().value()
-    if val:
-        print "true"
-    else:
-        print "false"
-
-    val = 1
-    ntoggle = NthToggle(val, 3)
-    for i in xrange(0,NUM):
-        val = ntoggle.activate().value()
-    if val:
-        print "true"
-    else:
-        print "false"
-
-main()