chrislo-sourceclassifier 0.2.0 → 0.2.1

data/sources/python/knucleotide.python

@@ -1,55 +0,0 @@
-# The Computer Language Shootout
-# http://shootout.alioth.debian.org/
-#
-# submitted by Ian Osgood
-# modified by Sokolov Yura
-# modified by bearophile
-
-from sys import stdin
-
-def gen_freq(seq, frame, frequences):
-    ns = len(seq) + 1 - frame
-    frequences.clear()
-    for ii in xrange(ns):
-        nucleo = seq[ii:ii + frame]
-        if nucleo in frequences:
-            frequences[nucleo] += 1
-        else:
-            frequences[nucleo] = 1
-    return ns, frequences
-
-
-def sort_seq(seq, length, frequences):
-    n, frequences = gen_freq(seq, length, frequences)
-
-    l = sorted(frequences.items(), reverse=True, key=lambda (seq,freq): (freq,seq))
-
-    print '\n'.join("%s %.3f" % (st, 100.0*fr/n) for st,fr in l)
-    print
-
-
-def find_seq(seq, s, frequences):
-    n,t = gen_freq(seq, len(s), frequences)
-    print "%d\t%s" % (t.get(s, 0), s)
-
-
-def main():
-    frequences = {}
-    for line in stdin:
-        if line[0:3] == ">TH":
-            break
-
-    seq = []
-    for line in stdin:
-        if line[0] in ">;":
-            break
-        seq.append( line[:-1] )
-    sequence = "".join(seq).upper()
-
-    for nl in 1,2:
-        sort_seq(sequence, nl, frequences)
-
-    for se in "GGT GGTA GGTATT GGTATTTTAATT GGTATTTTAATTTATAGT".split():
-        find_seq(sequence, se, frequences)
-
-main()

data/sources/python/lists.python

@@ -1,44 +0,0 @@
-#!/usr/bin/python
-# $Id: lists.python,v 1.1.1.1 2004-05-19 18:10:24 bfulgham Exp $
-# http://www.bagley.org/~doug/shootout/
-# with improvements from Mark Baker
-
-import sys
-
-SIZE = 10000
-
-def test_lists():
-    Li1 = range(1, SIZE + 1)
-    Li2 = Li1[:]
-    Li3 = []
-
-    # remove each individual item from left side of Li2 and
-    # append to right side of Li3 (preserving order)
-    # 
-    # popping the first element is *expensive*
-    #
-    #while Li2:
-    #    Li3.append(Li2.pop(0))   
-    Li2.reverse()
-    while Li2:
-        Li3.append(Li2.pop())
-    while Li3:
-        Li2.append(Li3.pop())
-    Li1.reverse()
-    if Li1[0] != SIZE:
-        return 0
-    if Li1 == Li2:
-        return len(Li1)
-    else:
-        return 0
-
-def main():
-    NUM = int(sys.argv[1])
-    if NUM < 1:
-        NUM = 1
-    while NUM > 0:
-        result = test_lists()
-        NUM = NUM - 1
-    print result
-
-main()

data/sources/python/magicsquares.python

@@ -1,145 +0,0 @@
-#!/usr/bin/python
-##   The Computer Language Shootout
-##   http://shootout.alioth.debian.org/
-##
-##   benchmark implementation (not optimized)
-##   contributed by Josh Goldfoot
-
-import sys
-import Queue
-import bisect
-
-n = mn = 0
-
-class PriorityQueue(Queue.Queue):
-    def _init(self, maxsize):
-        self.maxsize = maxsize
-        self.queue = [] 
-    def _put(self, item):
-        bisect.insort(self.queue, item)
-    def _get(self):
-        return self.queue.pop(0) 
-
-class square(object):
-    __slots__ = ['grid', 'ffm', '__priority']
-    def __init__(self):
-        self.grid = [0 for i in xrange(n * n)]
-        self.ffm = None
-        self.__priority = None
-    def copy(self):
-        ret = square()
-        ret.grid[:] = self.grid
-        return ret
-    def gridRow(self, y):
-        return [ self.grid[x + y * n] for x in xrange(n)]
-    def gridCol(self, x):
-        return [ self.grid[x + y * n] for y in xrange(n)]
-    def __str__(self):
-        return "\n".join( [" ".join([str(self.grid[x + y * n])
-                    for x in xrange(n)]) for y in xrange(n)])
-    def possibleMoves(self, x,y):
-##Return all moves that can go in the cell x,y for a given
-##grid.  A move is possible if the move (number) is not already
-##in the grid, and if, after making that move, it is still possible to
-##satisfy the magic square conditions (all rows, columns, diagonals adding
-##up to mn, the magic number)
-        if self.grid[x + y * n] != 0:
-            return []
-        cellGroups = [self.gridRow(y), self.gridCol(x)]
-        if x == y:
-            cellGroups.append([ self.grid[i + i * n] for i in xrange(n) ])
-        if x + y == n - 1:
-            cellGroups.append([ self.grid[i + (n - 1 - i) * n] for i in xrange(n) ])
-        usedNumbers = set(self.grid)
-        onePossible = set()
-        for g in cellGroups:
-            if g.count(0) == 1:
-                onePossible.add(mn - sum(g))
-        if len(onePossible) == 1:
-            onlyPossibleMove = onePossible.pop()
-            if 1 <= onlyPossibleMove <= n*n and onlyPossibleMove not in usedNumbers:
-                return [onlyPossibleMove]
-            else:
-                return []
-        elif len(onePossible) > 1:
-            return []
-        highestCandidates = [mn - sum(g) for g in cellGroups]
-        highestCandidates.append(n * n)
-        highest = min(highestCandidates)
-        return [ i for i in xrange(highest + 1) if i not in usedNumbers ]
-    def findFewestMoves(self):
-##Go through the grid (starting at the top-left, and moving
-##right and down), checking all 0 cells to find the cell with the fewest
-##possible moves.
-        if self.ffm:
-            return self.ffm
-        minSoFar = []
-        minX = minY = None
-        minLenSoFar = 0
-        for y in xrange(n):
-            for x in xrange(n):
-                ind = x + y * n
-                if self.grid[ind] == 0:
-                    pm = self.possibleMoves(x,y)
-                    if minX == None or len(pm) < minLenSoFar:
-                        minSoFar[:] = pm
-                        minLenSoFar = len(pm)
-                        minX = x
-                        minY = y
-        self.ffm = (minSoFar, minLenSoFar, minX, minY)
-        return self.ffm
-        return (minSoFar, minLenSoFar, minX, minY)
-    
-    def successorNodes(self):
-##successorNodes: Find the cell with the fewest
-##possible moves left, and then creates a new node for each possible move
-##in that cell.  
-        (pm, len_pm, x, y) = self.findFewestMoves()
-        node = self.copy()  # Create a copy of yourself
-        ind = x + y * n
-        for move in pm:
-            node.grid[ind] = move
-            yield node
-    def priority(self):
-##The priority function is:
-##(number of zeros in the grid) plus
-##(number of possible moves in the cell with the fewest possible moves)
-##the lower the priority, the sooner the node will be popped from the queue.
-        if self.__priority == None:
-            (pm, len_pm, x, y) = self.findFewestMoves()
-            self.__priority = self.grid.count(0) + len_pm
-        return self.__priority
-    def __cmp__(self, other):
-##The priority queue is sorted first by
-##the node's calculated priority; then, if the priorities
-##are equal, by whichever node has the lowest numbers
-##in the top-left of the array (or the next cell over,
-##and so on).
-        c = cmp(self.priority(), other.priority())
-        if c == 0:
-            i = 0
-            while c == 0 and i < n * n:
-                c = cmp(self.grid[i], other.grid[i])
-                i += 1
-        return c
-
-def main():
-    global n, mn
-    n = len(sys.argv) > 1 and int(sys.argv[1]) or 3
-    mn = n * (1 + n * n) / 2
-    # Initialize priority queue and push a square full of zeros on it
-    priorityQueue = PriorityQueue()
-    priorityQueue.put( square() )
-    # Loop through the priority queue...
-    while not priorityQueue.empty():
-        node = priorityQueue.get()
-        # if priority is 0, then this is a complete square; stop
-        if node.priority() == 0:
-            break
-        # otherwise, add to the queue all squares that can be derived by filling in
-        #  one cell in this magic square
-        for newnode in node.successorNodes():
-            priorityQueue.put(newnode.copy() )
-    if node.priority() == 0:
-        print node
-main()

data/sources/python/mandelbrot.python

@@ -1,44 +0,0 @@
-# The Computer Language Benchmarks Game
-# http://shootout.alioth.debian.org/
-#
-# contributed by Tupteq
-
-import sys
-
-def main():
-    cout = sys.stdout.write
-    size = int(sys.argv[1])
-    xr_size = xrange(size)
-    xr_iter = xrange(50)
-    bit = 128
-    byte_acc = 0
-
-    cout("P4\n%d %d\n" % (size, size))
-
-    size = float(size)
-    for y in xr_size:
-        fy = 2j * y / size - 1j
-        for x in xr_size:
-            z = 0j
-            c = 2. * x / size - 1.5 + fy
-
-            for i in xr_iter:
-                z = z * z + c
-                if abs(z) >= 2.0:
-                    break
-            else:
-                byte_acc += bit
-
-            if bit > 1:
-                bit >>= 1
-            else:
-                cout(chr(byte_acc))
-                bit = 128
-                byte_acc = 0
-
-        if bit != 128:
-            cout(chr(byte_acc))
-            bit = 128
-            byte_acc = 0
-
-main()

data/sources/python/mandelbrot.python-2.python

@@ -1,35 +0,0 @@
-# The Computer Language Benchmarks Game
-# http://shootout.alioth.debian.org/
-#
-# contributed by Heinrich Acker
-
-import sys
-import numpy
-
-limit = 2.
-size = int(sys.argv[1])
-
-# create an array of NxN complex constants
-grid = numpy.arange(0, 2, 2./size)
-c = (grid-1.5).reshape(1, size).repeat(size, 0) + \
-     1j*(grid-1).reshape(size, 1).repeat(size, 1)
-
-# create NxN arrays for iteration and results
-z = 0*c
-mask = z==0
-
-# compute the mandelbrot set vectorized
-for i in range(50):
-    z = mask * (z * z + c)
-    mask = numpy.logical_and(mask, numpy.abs(z)<limit)
-
-# map the bool results to their binary value
-mask = mask.reshape(-1, 8).astype('uint8')
-for bit in range(8):
-    mask[:, 7-bit] *= 1 << bit
-
-# pack the results into bytes
-mask = mask.sum(1, 'uint8')
-
-# write image data
-sys.stdout.write("P4\n%d %d\n%s" % (size, size, mask.tostring()))

data/sources/python/mandelbrot.python-3.python

@@ -1,46 +0,0 @@
-# The Computer Language Benchmarks Game
-# http://shootout.alioth.debian.org/
-#
-# contributed by Tupteq
-
-import sys
-
-def main():
-    cout = sys.stdout.write
-    iter = 50
-    limit = 2.
-    size = int(sys.argv[1])
-    fsize = float(size)
-    xr_size = xrange(size)
-    xr_iter = xrange(iter)
-    bit_num = 7
-    byte_acc = 0
-
-    cout("P4\n%d %d\n" % (size, size))
-
-    for y in xr_size:
-        fy = 2j * y / fsize - 1j
-        for x in xr_size:
-            z = 0j
-            c = 2. * x / fsize - 1.5 + fy
-
-            for i in xr_iter:
-                z = z * z + c
-                if abs(z) >= limit:
-                    break
-            else:
-                byte_acc += 1 << bit_num
-
-            if bit_num == 0:
-                cout(chr(byte_acc))
-                bit_num = 7
-                byte_acc = 0
-            else:
-                bit_num -= 1
-
-        if bit_num != 7:
-            cout(chr(byte_acc))
-            bit_num = 7
-            byte_acc = 0
-
-main()

data/sources/python/matrix.python

@@ -1,34 +0,0 @@
-#!/usr/bin/env python
-#
-#
-# Author: �smund �deg�rd
-#         Simula Research Laboratory (2004)
-#
-#         modeled after the original matrix.py at the shootout.
-
-import sys
-from numarray import *
-
-size = 30
-
-def mkmatrix(rows,cols):
-    m = array([[i+(j-1)*rows for i in xrange(1,rows+1)] for j in xrange(1,cols+1)])
-    return m
-
-
-def mmult(m1,m2):
-    return dot(m1,m2)
-
-
-def main():
-    try: iter = int(sys.argv[1])
-    except: iter = 1
-
-    m1 = mkmatrix(size,size)
-    m2 = mkmatrix(size,size)
-    for i in xrange(iter):
-        mm = mmult(m1,m2)
-    print mm[0,0], mm[2,3], mm[3,2], mm[4,4]
-
-main()
-

data/sources/python/matrix.python-2.python

@@ -1,23 +0,0 @@
-#!/usr/bin/env python
-# $Id: matrix.python-2.python,v 1.1 2004-11-10 06:47:57 bfulgham Exp $
-# from Kevin Turner
-# this example uses NumPy:
-# Numeric Python is available at http://www.pfdubois.com/numpy/
-
-import sys
-from Numeric import *
-
-size = 30
-
-def main():
-    iter = int(sys.argv[1])
-
-    # Create an array of size*size consecutive numbers (starting at 1,
-    # not 0), and reshape it into a (size, size) matrix.
-    m1 = reshape(arange(1, size*size + 1), (size,size))
-    m2 = reshape(arange(1, size*size + 1), (size,size))
-    for i in xrange(iter):
-        mm = matrixmultiply(m1, m2)
-    print mm[0][0], mm[2][3], mm[3][2], mm[4][4]
-
-main()

data/sources/python/message.python

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