chrislo-sourceclassifier 0.2.0

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

@@ -0,0 +1,20 @@
+# 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

@@ -0,0 +1,19 @@
+# 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

@@ -0,0 +1,210 @@
+#   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

@@ -0,0 +1,192 @@
+# 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

@@ -0,0 +1,51 @@
+#!/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()