Coding katas: MV Coders on Fire II

Lecherito #61 Feb '13 A toda leche

#60 Ahora mismo lo estaba haciendo del tipo:

1- Lee caracter
1.1- si es [ que coja todo el bucle e interpretalo

Pero no sé en que puedo fallar <.<

elkaoD #62 Feb '13

Se me pasó completamente #13 y revisando los posts lo he visto. Tiene buena pinta y por lo que veo los participantes manejan. ¿Se puede apuntar cualquiera?

Aún así, te animo a que te apuntes a alguna de estas

#60 si lo dices por stdin, tienes abajo un link que pone "haga click aquí para pegar entrada (stdin)". Imagino que funcionará también con Octave.

ItNaS #63 Feb '13

nada no hay manera de coger el input en ideone con octave, no le da la gana.

Os pongo mi solución igualmente en Octave
http://ideone.com/HI1ZCm (no lee el stdin, tarda en correr un poquillo)

1 2 respuestas

elkaoD #64 Feb '13

#63 buena, aunque te falta la parte de ancho de celda/IO y la de 10 = \n.

Para STDIN haz aunque sea que lea de un string, si no la solución no es válida

1 respuesta

themaz #65 Feb '13

voy a participar en esta kata , ya que la anterior no me dio tiempo a participar. pero tengo las siguientes dudas:

Cuando dice que tiene que leer un código y una entrada, ¿con lo de la entrada a que se refiere?
El ancho de I/O para que sirve ?
Y la cinta ?

alguien me lo puede explicar, con algún ejemplo o algo ? porque no lo pillo :s

2 respuestas

Khanser #66 Feb '13 :psyduck:

#65 La kata consiste en crear un programa intérprete de código brainfuck. Seria como si elkaoD te pidiera que hicieras un programa que lee PHP y lo ejecuta, pero en vez de PHP, es brainfuck
La cinta, con esto se refiere a la memoria que puede usar el programa, en este caso 30000 bytes, esto quiere decir que el programa en brainfuck solo podrá tener ese espacio, y la cinta es que si el programa en brainfuck intenta acceder a la posición 30000 de la memoria, el puntero volverá a 0, por lo que solo podrá almacenar memoria entre la 0 y la 29999.

El tema de I/O es como vas a pasarle el programa en brainfuck, si como parámetro en la consola, si poniendo una ruta de fichero (y tu programa leera el contenido del fichero antes de ponerse a ejecutarlo).... etc

Y el ancho ya te lo dicen en #67 XD

1 respuesta

elkaoD #67 Feb '13

#65 Lo de la cinta justo lo que explica #66.

La entrada es stdin, la entrada estándar, como cuando en Linux haces echo "cadena de entrada" | programa o en Windows también programa < archivo.

http://es.wikipedia.org/wiki/Entrada_est%C3%A1ndar

Ojo, la entrada de tu programa no tienes por qué leerla de la entrada estándar de tu SO, puede ser un array, un string... sólo es para ilustrar el paralelismo con la entrada estándar.

Las operaciones en Brainfuck son la coma (,) para leer UN byte de la entrada, y el punto (.) para escribir UN byte en la salida.

El ancho de I/O es el tamaño de entrada/salida. Un ancho de 8 bits significa que tanto la entrada como la salida pueden ser un número entre 0 y (2⁸)-1.

¿Por qué difiere del tamaño de celda? Porque un archivo se lee byte a byte por huevos. Para la entrada no tiene importancia (porque las reglas dicen que toda entrada están entre 0-255, no hace falta asegurarse) pero para la salida... ¿qué pasa si quieres imprimir 256? Eso no cabe en un byte... y no puedes imprimir dos bytes en uno La salida debe ser por tanto 0 (overflow).

1 respuesta

BLZKZ #68 Feb '13

#60 con lo facil que es llamarlo pila... xD

ItNaS #69 Feb '13

#64 no entiendo, el 10 ya es un salto de línea de por si, no?

1 1 respuesta

elkaoD #70 Feb '13

#69 cada cual lo implementa como le sale de los cojones (en win hay \r\n) así que he decidido eliminar la regla por no poder comprobarla en condiciones. No hace falta que tratéis \n especialmente.

Para todos: con respecto a PRIME, recordad que la entrada tiene que acabar en \n (10, 0x0a) si no, entra en un bucle infinito (el programa usa \n para saber cuando ha acabado el string del número, como el \0 en C).

elkaoD #71 Feb '13

Bueno, pues aquí va

mi kata en CoffeeScript

TAPE_SIZE = 30000
CELL_WIDTH = 16
IO_WIDTH = 8

mod = (a, n) -> (a % n + n) % n

bf = (code, stdin) ->
  code = code.split ''
  cptr = iptr = tptr = 0
  tape = (0 for x in [1..TAPE_SIZE])
  out = []

  stack = []
  backFrom = []
  forwardFrom = []

  for op, i in code
    if op == '['
      stack.push(i + 1)
    else if op == ']'
      origin = stack.pop()
      forwardFrom[origin] = i+1
      backFrom[i+1] = origin
  throw "Unbalanced [" if stack.length

  ops =
   '>': -> tptr = mod tptr + 1, TAPE_SIZE
   '<': -> tptr = mod tptr - 1, TAPE_SIZE
   '+': -> tape[tptr] = mod tape[tptr] + 1, (1 << CELL_WIDTH)
   '-': -> tape[tptr] = mod tape[tptr] - 1, (1 << CELL_WIDTH)
   '.': -> out.push mod tape[tptr], (1 << IO_WIDTH)
   ',': -> tape[tptr] = if iptr < stdin.length then stdin[iptr++] else (1 << CELL_WIDTH) - 1
   '[': -> cptr = forwardFrom[cptr] if not tape[tptr]
   ']': -> cptr = backFrom[cptr] if tape[tptr]

  ops[x]?() while (x = code[cptr++])?

  out: out
  tape: tape

Uso: bf(string, [byte, byte, byte...])

Devuelve un objeto: {out: [...], tape: [...]}, ambas un array de bytes.

La podéis probar copiando el código de https://gist.github.com/alvaro-cuesta/4745047 en http://coffeescript.org/#try: , haciendo click en Run y veréis el resultado en la consola de JS (en Chrome se abre con F12). Imprime Hello World!, Fibonacci hasta 89, un triángulo de Sierpinski y los primos hasta 20. Incluye str2byte y byte2str para convertir la entrada/salida.

Explicación para los curiosos

Esta función se asegura de que a está entre 0 y n-1 (ambos incluidos). La uso para el overflow de celda, la cinta circular, la salida...

mod = (a, n) -> (a % n + n) % n

Aquí genero una tabla para los saltos. Se recorre el código y por cada '[' hace push a una pila de su posición. En cada ']' se hace pop de la pila (se toma el último elemento) y añade a una tabla la dirección de '[' a ']' y en otra de ']' a '['.

stack = []
backFrom = []
forwardFrom = []

for op, i in code
  if op == '['
    stack.push(i + 1)
  else if op == ']'
    origin = stack.pop()
    forwardFrom[origin] = i+1
    backFrom[i+1] = origin
throw "Unbalanced [" if stack.length

En ops es donde están definidas las operaciones. Este es el bucle de ejecución del código:

ops[x]?() while (x = code[cptr++])?

Mi parte favorita de Coffee frente a JS es el operador existencial (?). Esto se traduce como:

while ((x = code[cptr++]) != null) {
  if (typeof ops[x] === "function") {
    ops[x]();
  }
}

7

The-Force #72 Feb '13

Pues aquí esta mi

código (python)

import sys
import time

def show_halp():
    print ('===============================================================================')
    print ('Python BrainFuck Interpreter by The-Force for MV Coding Katas')
    print ('')
    print ('Usage: BrainFuck.py Program_File [Output_File [Input_File]]')
    print ('')
    print ('Program_File: file containing the Brainfuck code to be interpreted.')
    print ('Output_File : file for the program output. If not specified a new file will be created.')
    print ('Input_File  : Optional file containing input for the program.')
    print ('===============================================================================' )  
   

def get_file_string(file_name):    

    try:
        file_ = open(file_name, 'r')
    except IOError:
        sys.exit('IOERROR: Cant open ' + file_name)
    else:
        content = file_.read()
        file_.close()
        return content

def set_file_string(file_name,content):
    try:
        file_ = open(file_name, 'w')
    except IOError:
        sys.exit('IOERROR: Cant open ' + file_name)
    else:
        file_.write(content)
        file_.close()
    

class MyError(Exception):
    def __init__(self, s):
        self.description = s
    def __str__(self):
        return repr(self.description)

class Program:
    def __init__(self, original_code):
        self.valid = False
        self.set_code(original_code)        

def set_code(self,original_code):
    self.optimized_code = []
    self.jump = {}
    self.op_counter = []    
    self.original_code = original_code
    self.preprocess()
   
def preprocess(self):
    original_code = self.original_code
    op_alphabet = ['>','<','+','-','.',',','[',']']
    op_optimizable = ['>','<','+','-','.',',']        
    op = ''
    op_last = ''        
    code_ptr = 0
    code_size = len(self.original_code)        
    new_ptr = 0        
    stack = []        
    op_counter = []
    optimized_code = []
    jump = {}
    
    while code_ptr < code_size:    
        op = original_code[code_ptr]            
        if op in op_alphabet:
            if op not in op_optimizable:
                optimized_code.append(ord(op))
                op_counter.append(0)
                op_last = op                    
                if op == '[':            
                    stack.append(len(optimized_code)-1)
                elif op == ']':
                    f = stack.pop()
                    jump[f] = len(optimized_code)-1;
                    jump[len(optimized_code)-1] = f;
            else:
                if op != op_last:
                    op_last = op
                    new_ptr = len(optimized_code)
                    optimized_code.append(ord(op))
                    op_counter.append(1)
                else:
                    op_counter[new_ptr] += 1
        code_ptr += 1
        
    if len(stack) > 0:
        raise MyError('ERROR: Invalid Brainfuck syntax')       
    
    self.valid = True
    self.op_counter = op_counter
    self.optimized_code = optimized_code
    self.jump = jump
        
def run(self,input_string):        
    if not self.valid:
        raise MyError('ERROR: Invalid Brainfuck syntax')

    op_counter = self.op_counter
    optimized_code = self.optimized_code
    jump = self.jump
    
    value_size = 65536
    output_size = 256        
    array = [0] * 30000
    array_size = len(array)
    array_ptr = 0
    input_size = len(input_string)
    input_ptr = 0
    code_size = len(optimized_code)
    code_ptr = 0
    output = []
    op = 0
    
    while code_ptr < code_size:            
        op = optimized_code[code_ptr]
        
        if op == 62: # >
            array_ptr += op_counter[code_ptr]
            if array_ptr >= array_size:
                array_ptr = array_ptr - array_size
                
        elif op == 60: # <
            array_ptr -= op_counter[code_ptr]
            if array_ptr < 0:
                array_ptr = array_size + array_ptr
                
        elif op == 43: # +
            array[array_ptr] += op_counter[code_ptr]
            if array[array_ptr] >= value_size:
                array[array_ptr] = array[array_ptr] - value_size
                
        elif op == 45: # -
            array[array_ptr] -= op_counter[code_ptr]
            if array[array_ptr] < 0:
                array[array_ptr] = value_size + array[array_ptr]
                
        elif op == 93 and array[array_ptr] > 0: # ]
            code_ptr = jump[code_ptr]
            
        elif op == 91 and array[array_ptr] <= 0: # [
            code_ptr = jump[code_ptr]
            
        elif op == 46: # .
            for i in range(op_counter[code_ptr]):
                output.append(chr(array[array_ptr] % output_size))
                
        elif op == 44: # ,
            for i in range(op_counter[code_ptr]):
                if input_ptr < input_size:  
                    array[array_ptr] = ord(input_string[input_ptr])
                    input_ptr += 1                    
                else:
                    array[array_ptr] = value_size - 1 # 65535 0xFFFF
                    break;
        code_ptr += 1            
    return ''.join(output)            

#============================================================================
start_time = time.time()
    

if len(sys.argv) < 2 or len(sys.argv) > 4:
    show_halp()
    sys.exit()

program_s = get_file_string(sys.argv[1])
input_s = ''
if len(sys.argv) == 4:
    input_s = get_file_string(sys.argv[3])
    

try:
    program = Program(program_s)            

    output_s = program.run(input_s)    

except MyError as e:
    sys.exit(e)
    

if len(sys.argv) > 2:
    set_file_string(sys.argv[2],output_s)  

else:
    set_file_string(sys.argv[1] + '.out.txt',output_s)

print ('Done in: ' + str(time.time() - start_time) + ' seconds')

y aquí la

screen

La velocidad de ejecución no es nada fiable. En el pc de cmo7 tarda la mitad que en el mio xD
No me metais mucha mierda si mi código es feo y tocho. Es así de largo para optimizar la velocidad de ejecución. De todos modos seguiré intentando optimizarlo mas. Acepto sugerencias

2 2 respuestas

Amazon #73 Feb '13 Ramonchu

Ni mucho menos busco que vaya rápido, sólo quería que me funcionara, y pillé la idea de #72 (aunque yo se la sonsaqué a cmo7 xDD) de

spoiler

Codigo

import time

__author__ = 'Amazon'

import sys

__LIMIT__ = 30000
__HELLO_WORLD__ = "++++++++++[>+++++++>++++++++++>+++>+<<<<-]>++.>+.+++++++..+++.>++.<<+++++++++++++++.>.+++.------.--------.>+.>."
__FIBONACCI__ = "+++++++++++>+>>>>++++++++++++++++++++++++++++++++++++++++++++>++++++++++++++++++++++++++++++++<<<<<<[>[>>>>>>+>+<<<<<<<-]>>>>>>>[<<<<<<<+>>>>>>>-]<[>++++++++++[-<-[>>+>+<<<-]>>>[<<<+>>>-]+<[>[-]<[-]]>[<<[>>>+<<<-]>>[-]]<<]>>>[>>+>+<<<-]>>>[<<<+>>>-]+<[>[-]<[-]]>[<<+>>[-]]<<<<<<<]>>>>>[++++++++++++++++++++++++++++++++++++++++++++++++.[-]]++++++++++<[->-<]>++++++++++++++++++++++++++++++++++++++++++++++++.[-]<<<<<<<<<<<<[>>>+>+<<<<-]>>>>[<<<<+>>>>-]<-[>>.>.<<<[-]]<<[>>+>+<<<-]>>>[<<<+>>>-]<<[<+>-]>[<+>-]<<<-]"
__PRIME__ = ">++++++++[<++++++++>-]<++++++++++++++++.[-]>++++++++++[<++++++++++>-]<++++++++++++++.[-]>++++++++++[<++++++++++>-]<+++++.[-]>++++++++++[<++++++++++>-]<+++++++++.[-]>++++++++++[<++++++++++>-]<+.[-]>++++++++++[<++++++++++>-]<+++++++++++++++.[-]>+++++[<+++++>-]<+++++++.[-]>++++++++++[<++++++++++>-]<+++++++++++++++++.[-]>++++++++++[<++++++++++>-]<++++++++++++.[-]>+++++[<+++++>-]<+++++++.[-]>++++++++++[<++++++++++>-]<++++++++++++++++.[-]>++++++++++[<++++++++++>-]<+++++++++++.[-]>+++++++[<+++++++>-]<+++++++++.[-]>+++++[<+++++>-]<+++++++.[-]+[->,----------[<+>-------------------------------------->[>+>+<<-]>>[<<+>>-]<>>>+++++++++[<<<[>+>+<<-]>>[<<+>>-]<[<<+>>-]>>-]<<<[-]<<[>+<-]]<]>>[<<+>>-]<<>+<-[>+[>+>+<<-]>>[<<+>>-]<>+<-->>>>>>>>+<<<<<<<<[>+<-<[>>>+>+<<<<-]>>>>[<<<<+>>>>-]<<<>[>>+>+<<<-]>>>[<<<+>>>-]<<<<>>>[>+>+<<-]>>[<<+>>-]<<<[>>>>>+<<<[>+>+<<-]>>[<<+>>-]<[>>[-]<<-]>>[<<<<[>+>+<<-]>>[<<+>>-]<>>>-]<<<-<<-]+>>[<<[-]>>-]<<>[-]<[>>>>>>[-]<<<<<<-]<<>>[-]>[-]<<<]>>>>>>>>[-<<<<<<<[-]<<[>>+>+<<<-]>>>[<<<+>>>-]<<<>>[>+<-]>[[>+>+<<-]>>[<<+>>-]<>+++++++++<[>>>+<<[>+>[-]<<-]>[<+>-]>[<<++++++++++>>-]<<-<-]+++++++++>[<->-]<[>+<-]<[>+<-]<[>+<-]>>>[<<<+>>>-]<>+++++++++<[>>>+<<[>+>[-]<<-]>[<+>-]>[<<++++++++++>>>+<-]<<-<-]>>>>[<<<<+>>>>-]<<<<>[-]<<+>]<[[>+<-]+++++++[<+++++++>-]<-><.[-]>>[<<+>>-]<<-]>++++[<++++++++>-]<.[-]>>>>>>>]<<<<<<<<>[-]<[-]<<-]++++++++++.[-]"
__ROT13__ = "+[,+[-[>+>+<<-]>[<+>-]+>>++++++++[<-------->-]<-[<[-]>>>+[<+<+>>-]<[>+<-]<[<++>>>+[<+<->>-]<[>+<-]]>[<]<]>>[-]<<<[[-]<[>>+>+<<<-]>>[<<+>>-]>>++++++++[<-------->-]<->>++++[<++++++++>-]<-<[>>>+<<[>+>[-]<<-]>[<+>-]>[<<<<<+>>>>++++[<++++++++>-]>-]<<-<-]>[<<<<[-]>>>>[<<<<->>>>-]]<<++++[<<++++++++>>-]<<-[>>+>+<<<-]>>[<<+>>-]+>>+++++[<----->-]<-[<[-]>>>+[<+<->>-]<[>+<-]<[<++>>>+[<+<+>>-]<[>+<-]]>[<]<]>>[-]<<<[[-]<<[>>+>+<<<-]>>[<<+>>-]+>------------[<[-]>>>+[<+<->>-]<[>+<-]<[<++>>>+[<+<+>>-]<[>+<-]]>[<]<]>>[-]<<<<<------------->>[[-]+++++[<<+++++>>-]<<+>>]<[>++++[<<++++++++>>-]<-]>]<[-]++++++++[<++++++++>-]<+>]<.[-]+>>+<]>[[-]<]<]"
__SQUARE__ = "++++[>+++++<-]>[<+++++>-]+<+[>[>+>+<<-]++>>[<<+>>-]>>>[-]++>[-]+>>>+[[-]++++++>>>]<<<[[<++++++++<++>>-]+<.<[>----<-]<]<<[>>>>>[>>>[-]+++++++++<[>-<-]+++++++++>[-[<->-]+[<<<]]<[>+<-]>]<<-]<<-]"

class maquinaTuring():
    def __init__(self, code, rfile):
        self.cinta = [0] * __LIMIT__
        self.pos = 0
        self.code = code
        self.codepos = 0
        self.codedict = dict()
        if rfile != '':
            rfile = open(rfile,'r')
            self.rbufferpos = 0
            self.oldlen = 0
            self.rbuffer = ""
            while True:
                self.rbuffer += rfile.readline()
                if (self.oldlen == len(self.rbuffer)):
                    break
                self.oldlen = len(self.rbuffer)

def sumb(self):
    if self.cinta[self.pos] < 65535:
        self.cinta[self.pos] += 1
    else:
        self.cinta[self.pos] = 0

def resb(self):
    if self.cinta[self.pos] > 0:
        self.cinta[self.pos] -= 1
    else:
        self.cinta[self.pos] = 65535

def sump(self):
    if self.pos < (__LIMIT__ - 1):
        self.pos += 1
    else:
        self.pos = 0

def resp(self):
    if self.pos > 0:
        self.pos -= 1
    else:
        self.pos = (__LIMIT__ - 1)

def buco(self):
    if self.cinta[self.pos] == 0:
        self.codepos = self.codedict[self.codepos]

def bucc(self):
    if self.cinta[self.pos] > 0:
        self.codepos = self.codedict[self.codepos]

def impr(self):
    while self.cinta[self.pos] > 255:
        self.cinta[self.pos] -= 255
    sys.stdout.write(chr(self.cinta[self.pos]))

def read(self):
    if self.rbufferpos < len(self.rbuffer):
        self.cinta[self.pos] = ord(self.rbuffer[self.rbufferpos])
        self.rbufferpos += 1
    else:
        self.cinta[self.pos] = 0xFFFF
        return

def executeCode(self):
    start = time.time()
    pila = []
    for i in range(len(self.code)):
        if self.code[i] == '[':
            pila.append(i)
        elif self.code[i] == ']':
            self.codedict[i] = pila[len(pila) - 1]
            self.codedict[pila[len(pila)-1]] = i
            pila.remove(pila[len(pila)-1])
    print("Tiempo de preparacion: " + str(time.time() - start))
    while self.codepos < len(self.code):
        if self.code[self.codepos] == '+':
            self.sumb()
        elif self.code[self.codepos] == '-':
            self.resb()
        elif self.code[self.codepos] == '.':
            self.impr()
        elif self.code[self.codepos] == ',':
            self.read()
        elif self.code[self.codepos] == '>':
            self.sump()
        elif self.code[self.codepos] == '<':
            self.resp()
        elif self.code[self.codepos] == '[':
            self.buco()
        elif self.code[self.codepos] == ']':
            self.bucc()
        self.codepos += 1
    print("\n\rTiempo de ejecucion: " + str(time.time()-start))


a = maquinaTuring(__PRIME__,'entrada.txt')
a.executeCode()

e

imagen

Y me planto, no pienso modificarlo para optimizarlo ni nada xD

Edit: V2 #78

Edit: V3 #86 (soporte para caracteres que no son de bf y pequeña optimización del código (elimino espacios sobrantes únicamente xd)

1 1 respuesta

elkaoD #74 Feb '13

#72 #73

sugerencias

a ambos dos os sugiero por concisión que hagáis la ejecución como un diccionario en lugar de una cadena de if/elif o la alternativa, switches.

La idea es algo como en #71 lineas 26-34. En Python algo así:

# En el constructor
self.operations = {
  '+': self.sumb  # sin (), devuelve la propia función para ser ejecutada
  '-': self.resb
  ...
}

# En el run()
while self.codepos < len(self.code):
  self.operations[self.code[self.codepos]]()  # con () ejecutamos la función del diccionario
  self.codepos += 1

A mí personalmente me gusta más, me parece más mantenible/extensible y sobre todo natural (es un mapeo char -> función). A otros les parecerá feo, decidid vosotros mismos.

Por otro lado, #73 entre las linea 89-103 repites varias veces self.code[self.codepos]. Yo eso lo guardaría en una variable. No sé si el JIT de Python lo optimiza, pero incluso por legibilidad... Lo mismo con len(self.code) y con esta ten cuidado porque es posible que se te esté ejecutando en cada iteración del bucle! Y esos 65535 ahí a piñón piden a gritos una constante

Por lo demás buen código ambos, no he sabido con cual quedarme así que manita para los dos

#72 me mola la idea de la optimización. Yo lo hice en JS (¡compilando con strings a una función JS directamente!) pero no sólo no gané rendimiento sino que perdía. Tengo que probar en Node, pero en browser iba como un 30% peor.

¿Como cuánto te tardan los primos hasta 200?

2 respuestas

Amazon #75 Feb '13 Ramonchu

#74 personalmente me quedo con el suyo

spoiler

The-Force #76 Feb '13

#74 Lo del mapeo lo deseché por que requiere que muchas variables sean elementos de la clase y eso se traduce a muchisimos "self." en cada operación. Tengo una versión del código que hace exactamente eso y ademas de ser ilegible con tanto self es mas lento. Lo único bueno es que el método run se reduce mucho.

1 respuesta

elkaoD #77 Feb '13

#76 eso os pasa por usar clases http://stackoverflow.com/questions/4020419/closures-in-python

EDIT: rectifico, me informa The-Force que las closures en Python son read-only. Ains...

Amazon #78 Feb '13 Ramonchu

Código de #73 actualizado para optimizarlo.

spoiler

import time
import sys

__author__ = 'Amazon'

__CINTA_LIMIT__ = 30000
__BYTE_LIMIT__ = 65535
__IO_LIMIT__ = 255
__HELLO_WORLD__ = "++++++++++[>+++++++>++++++++++>+++>+<<<<-]>++.>+.+++++++..+++.>++.<<+++++++++++++++.>.+++.------.--------.>+.>."
__FIBONACCI__ = "+++++++++++>+>>>>++++++++++++++++++++++++++++++++++++++++++++>++++++++++++++++++++++++++++++++<<<<<<[>[>>>>>>+>+<<<<<<<-]>>>>>>>[<<<<<<<+>>>>>>>-]<[>++++++++++[-<-[>>+>+<<<-]>>>[<<<+>>>-]+<[>[-]<[-]]>[<<[>>>+<<<-]>>[-]]<<]>>>[>>+>+<<<-]>>>[<<<+>>>-]+<[>[-]<[-]]>[<<+>>[-]]<<<<<<<]>>>>>[++++++++++++++++++++++++++++++++++++++++++++++++.[-]]++++++++++<[->-<]>++++++++++++++++++++++++++++++++++++++++++++++++.[-]<<<<<<<<<<<<[>>>+>+<<<<-]>>>>[<<<<+>>>>-]<-[>>.>.<<<[-]]<<[>>+>+<<<-]>>>[<<<+>>>-]<<[<+>-]>[<+>-]<<<-]"
__PRIME__ = ">++++++++[<++++++++>-]<++++++++++++++++.[-]>++++++++++[<++++++++++>-]<++++++++++++++.[-]>++++++++++[<++++++++++>-]<+++++.[-]>++++++++++[<++++++++++>-]<+++++++++.[-]>++++++++++[<++++++++++>-]<+.[-]>++++++++++[<++++++++++>-]<+++++++++++++++.[-]>+++++[<+++++>-]<+++++++.[-]>++++++++++[<++++++++++>-]<+++++++++++++++++.[-]>++++++++++[<++++++++++>-]<++++++++++++.[-]>+++++[<+++++>-]<+++++++.[-]>++++++++++[<++++++++++>-]<++++++++++++++++.[-]>++++++++++[<++++++++++>-]<+++++++++++.[-]>+++++++[<+++++++>-]<+++++++++.[-]>+++++[<+++++>-]<+++++++.[-]+[->,----------[<+>-------------------------------------->[>+>+<<-]>>[<<+>>-]<>>>+++++++++[<<<[>+>+<<-]>>[<<+>>-]<[<<+>>-]>>-]<<<[-]<<[>+<-]]<]>>[<<+>>-]<<>+<-[>+[>+>+<<-]>>[<<+>>-]<>+<-->>>>>>>>+<<<<<<<<[>+<-<[>>>+>+<<<<-]>>>>[<<<<+>>>>-]<<<>[>>+>+<<<-]>>>[<<<+>>>-]<<<<>>>[>+>+<<-]>>[<<+>>-]<<<[>>>>>+<<<[>+>+<<-]>>[<<+>>-]<[>>[-]<<-]>>[<<<<[>+>+<<-]>>[<<+>>-]<>>>-]<<<-<<-]+>>[<<[-]>>-]<<>[-]<[>>>>>>[-]<<<<<<-]<<>>[-]>[-]<<<]>>>>>>>>[-<<<<<<<[-]<<[>>+>+<<<-]>>>[<<<+>>>-]<<<>>[>+<-]>[[>+>+<<-]>>[<<+>>-]<>+++++++++<[>>>+<<[>+>[-]<<-]>[<+>-]>[<<++++++++++>>-]<<-<-]+++++++++>[<->-]<[>+<-]<[>+<-]<[>+<-]>>>[<<<+>>>-]<>+++++++++<[>>>+<<[>+>[-]<<-]>[<+>-]>[<<++++++++++>>>+<-]<<-<-]>>>>[<<<<+>>>>-]<<<<>[-]<<+>]<[[>+<-]+++++++[<+++++++>-]<-><.[-]>>[<<+>>-]<<-]>++++[<++++++++>-]<.[-]>>>>>>>]<<<<<<<<>[-]<[-]<<-]++++++++++.[-]"
__ROT13__ = "+[,+[-[>+>+<<-]>[<+>-]+>>++++++++[<-------->-]<-[<[-]>>>+[<+<+>>-]<[>+<-]<[<++>>>+[<+<->>-]<[>+<-]]>[<]<]>>[-]<<<[[-]<[>>+>+<<<-]>>[<<+>>-]>>++++++++[<-------->-]<->>++++[<++++++++>-]<-<[>>>+<<[>+>[-]<<-]>[<+>-]>[<<<<<+>>>>++++[<++++++++>-]>-]<<-<-]>[<<<<[-]>>>>[<<<<->>>>-]]<<++++[<<++++++++>>-]<<-[>>+>+<<<-]>>[<<+>>-]+>>+++++[<----->-]<-[<[-]>>>+[<+<->>-]<[>+<-]<[<++>>>+[<+<+>>-]<[>+<-]]>[<]<]>>[-]<<<[[-]<<[>>+>+<<<-]>>[<<+>>-]+>------------[<[-]>>>+[<+<->>-]<[>+<-]<[<++>>>+[<+<+>>-]<[>+<-]]>[<]<]>>[-]<<<<<------------->>[[-]+++++[<<+++++>>-]<<+>>]<[>++++[<<++++++++>>-]<-]>]<[-]++++++++[<++++++++>-]<+>]<.[-]+>>+<]>[[-]<]<]"
__SQUARE__ = "++++[>+++++<-]>[<+++++>-]+<+[>[>+>+<<-]++>>[<<+>>-]>>>[-]++>[-]+>>>+[[-]++++++>>>]<<<[[<++++++++<++>>-]+<.<[>----<-]<]<<[>>>>>[>>>[-]+++++++++<[>-<-]+++++++++>[-[<->-]+[<<<]]<[>+<-]>]<<-]<<-]"

class maquinaTuring():
    def __init__(self, code, rfile):
        self.cinta = [0] * __CINTA_LIMIT__
        self.pos = 0
        self.code = code
        self.codelen = len(code)
        self.codepos = 0
        self.codedict = dict()
        self.operations ={'+': self.sumb,'-': self.resb,'<': self.resp,'>':self.sump,'[': self.buco,']':self.bucc,',': self.read,'.':self.impr}
        if rfile != '':
            rfile = open(rfile,'r')
            self.rbufferpos = 0
            oldlen = 0
            self.rbuffer = ""
            while True:
                self.rbuffer += rfile.readline()
                if (oldlen == len(self.rbuffer)):
                    break
                oldlen = len(self.rbuffer)
            self.rbufferlen = oldlen

def sumb(self):
    if self.cinta[self.pos] < __BYTE_LIMIT__:
        self.cinta[self.pos] += 1
    else:
        self.cinta[self.pos] = 0

def resb(self):
    if self.cinta[self.pos] > 0:
        self.cinta[self.pos] -= 1
    else:
        self.cinta[self.pos] = __BYTE_LIMIT__

def sump(self):
    if self.pos < (__CINTA_LIMIT__ - 1):
        self.pos += 1
    else:
        self.pos = 0

def resp(self):
    if self.pos > 0:
        self.pos -= 1
    else:
        self.pos = (__CINTA_LIMIT__ - 1)

def buco(self):
    if self.cinta[self.pos] == 0:
        self.codepos = self.codedict[self.codepos]

def bucc(self):
    if self.cinta[self.pos] > 0:
        self.codepos = self.codedict[self.codepos]

def impr(self):
    sys.stdout.write(chr(self.cinta[self.pos] % 255))

def read(self):
    if self.rbufferpos < self.rbufferlen:
        self.cinta[self.pos] = ord(self.rbuffer[self.rbufferpos]) % 255
        self.rbufferpos += 1
    else:
        self.cinta[self.pos] = 0xFFFF
        return

def executeCode(self):
    start = time.time()
    pila = []
    for i in range(len(self.code)):
        if self.code[i] == '[':
            pila.append(i)
        elif self.code[i] == ']':
            j = pila.pop()
            self.codedict[i] = j
            self.codedict[j] = i
    print("Tiempo de preparacion: " + str(time.time() - start))
    while self.codepos < self.codelen:
        self.operations[self.code[self.codepos]]()
        self.codepos += 1
    print("\n\rTiempo de ejecucion: " + str(time.time()-start))


a = maquinaTuring(__PRIME__,'entrada.txt')
a.executeCode()

spoiler

ItNaS #79 Feb '13

estaba jugando con la siguiente idea pero no tengo más tiempo para dedicarle. A ver si alguien se anima

http://ideone.com/Gedt4K

4 respuestas

Lecherito #80 Feb '13 A toda leche

#79 Yo ya lo pensé pero tampoco pensé que sería legal xDD

A cambio un no del todo funcional (ya que no soporta bucles anidados, no, no he conseguido hacerlo): http://ideone.com/QRuwoX

2 respuestas

elkaoD #81 Feb '13

#79 #80 aquí otro que también jugó con la idea (en JS también), además colapsando cosas como "+++++" en "+= 5". Irónicamente pierdo rendimiento frente a la solución ingenua en #71, no entiendo muy bien por qué.

Cuidado #79, (-1 % 5) == -1

http://ideone.com/AY07KD

No es lo mismo módulo que resto.

1 2 respuestas

ItNaS #82 Feb '13

#81 no lo testee mucho tampoco. Me tenía que centrar en otras cosas jejeje

Amazon #83 Feb '13 Ramonchu

#79 #80 #81 creo que force hizo lo de '+= 5' y le salió bien, echadle un ojo a su code. Optimiza el codigo bf para que la ejecución de este sea mas rápidav(no vi tu codigo #79)

meuxx #84 Feb '13

Siguiendo la idea de #79 he hecho esto en JS que creo que sigue todas las normas

Code

var execBF = function(code, input) {
	var TAPE_LIMIT = 30001;
	var CELL_LIMIT = 65536;
	var IO_LIMIT = 256;

var cleanCode = "";
var output = "";
var pointer = 0;
var inputPointer = 0;
var tape = [];

input += "\n";
if(code.indexOf(",") != -1 && input == "\n") return "ERROR: Input required";

for(var i=0; i<TAPE_LIMIT; i++) tape.push(0);

for(var i=0; i<code.length; i++) {
	switch(code[i]) {
		case '>':
		case '<':
		case '+':
		case '-':
		case '.':
		case ',':
		case ']':
		case '[':
			cleanCode += code[i];
			break;
	}
}

cleanCode = cleanCode.replace(/\]/g, "}");
cleanCode = cleanCode.replace(/\[/g, "while(tape[pointer]){");
cleanCode = cleanCode.replace(/\+/g, "tape[pointer]=(tape[pointer]+1)%CELL_LIMIT;");
cleanCode = cleanCode.replace(/-/g, "tape[pointer]=(tape[pointer]-1)%CELL_LIMIT;");
cleanCode = cleanCode.replace(/>/g, "pointer=(pointer+1)%TAPE_LIMIT;");
cleanCode = cleanCode.replace(/</g, "pointer=(pointer-1)%TAPE_LIMIT;");
cleanCode = cleanCode.replace(/\./g, "output += String.fromCharCode(tape[pointer]);");
cleanCode = cleanCode.replace(/,/g, "tape[pointer] = input.charCodeAt(inputPointer);inputPointer=(inputPointer+1)%IO_LIMIT;");

try {
	eval(cleanCode);
} catch(e) {
	output = e.message;
}

return output;
}

Imagen

Para probarlo http://jsfiddle.net/AaMzG/

2

aitorman #85 Feb '13

Bueno, he estado unos mesecillos sin postear en el foro (he tenido bastante aparcados mis proyectos, aunque si que he hecho un par de cosas que ya pondre en la Guía de desarrollo de juegos indie) y que mejor manera de volver que con una kata, asi que aqui va la mia en C++:

#include <cstdlib>
#include <stack>
#include <string>
#include <iostream>
#include <fstream>
#include <iostream>
#include <sstream>
#define CELL_SIZE 65535
#define IO_SIZE 255
using namespace std;

class Program
{
	string code;
	string input;
	stack<int> bracketStack;
	int line;
	int cell;
	int *data;
public:
	Program(char *codeFile, char *inFile);
	~Program();
	void Execute();
	void ProcessChar(char c);
	int ClosingForBracketAtPos(int pos);
};
int main(int argc, char *argv[])
{
    Program *program=new Program("C:\\Users\\Aitor\\Desktop\\PRIMEBF.txt","C:\\Users\\Aitor\\Desktop\\input.txt");
    program->Execute();
    delete program;
    program=new Program("C:\\Users\\Aitor\\Desktop\\Sierpinski.txt","C:\\Users\\Aitor\\Desktop\\input.txt");
    program->Execute();
    delete program;
    program=new Program("C:\\Users\\Aitor\\Desktop\\Fibonacci.txt","C:\\Users\\Aitor\\Desktop\\input.txt");
    program->Execute();
    delete program;
    system("PAUSE");
    return 0;
}

Program::Program(char *codeFile, char *inFile)
{
	line=0;
	cell=0;
	data=new int[30000];
	
for (int i=0;i<30000;i++)
{
	data[i]=0;
}
ifstream codeF(codeFile);
string line;
while (!codeF.eof())
{
      getline(codeF,line);
      code.append(line);
}
codeF.close();
ifstream inF(inFile);
std::stringstream inStream;
inStream<<inF.rdbuf();
input=inStream.str();
inF.close();
}
Program::~Program()
{
	delete[] data;
}
void Program:: Execute()
{
     int size=code.size();
     while (line<size)
     {
           ProcessChar(code[line]);
           line++;
     }
}
void Program::ProcessChar(char c)
{
	switch (c) {
	case '+':
		data[cell]++;
		if (data[cell]>CELL_SIZE)
		   data[cell]=0;
		break;
	case '-':
		data[cell]--;
		if (data[cell]<0)
		   data[cell]=CELL_SIZE;
		break;
	case ',':
		if (input.size()>0)
        {
           data[cell]=input[0];
           input.erase(0,1);
           if (data[cell]=='\r')
           {
                data[cell]=input[0];
                input.erase(0,1);  

           }
        }
        else
        {
            data[cell]=65535;
        }
		break;
	case '.':
    {
         int outValue=data[cell];
         int r=outValue/255;
         if (r>0)
            outValue=-(255*r)+outValue;
         char c=outValue;
		cout<<c;
		break;
    }
	case '<':
		cell--;
	    if (cell<0) cell=29999;
		break;
	case '>':
		cell++;
		if (cell>29999) cell=0;
		break;
	case '[':
		if (data[cell]==0)
		   line=ClosingForBracketAtPos(line);
        else
           bracketStack.push(line);
		break;
	case ']':
	{
        int line=bracketStack.top();
        bracketStack.pop();
        if (data[cell]!=0)
           this->line=line-1;
		break;
    }
	default:
		break;
	}
}
int Program::ClosingForBracketAtPos(int pos)
{
    if (code[pos]!='[')
    {
       return -1;
    }
    int nestLevel=0;
    int i;
    for (i=pos;i<code.size();i++)
    {
        if (code[i]=='[')
           nestLevel++;
        if (code[i]==']')
           nestLevel--;
        if (nestLevel<1)
           break;
    }
    if (nestLevel<1)
       return i;
    else
        return -1;
}

La clase Program se usa así:

Program *programa=new Program("archivo_programa","archivo_input");
programa->Execute();

En el codigo que he puesto ejecuta el PRIME.BF (entrada "20\n", el triangulo de Sierpinski y el Fibonacci.
Imagen del output:

El codigo esta bastante cacosamente optimizado (cada vez que se encuentra un '[' busca el ']' correspondiente en ved de precalcularlo y cosas asi), pero bueno, es lo primero que me salio y no hay ganas de optimizarlo mas xD

1

Amazon #86 Feb '13 Ramonchu

Versión 3 de mi programa, que me di cuenta que no me ejecutaba el triangulo de sierpinski (no contemplaba caracteres en el código que no estuviesen aceptados )

spoiler

import time
import sys

__author__ = 'Amazon'

__CINTA_LIMIT__ = 30000
__BYTE_LIMIT__ = 65535
__IO_LIMIT__ = 255
__HELLO_WORLD__ = '++++++++++[>+++++++>++++++++++>+++>+<<<<-]>++.>+.+++++++..+++.>++.<<+++++++++++++++.>.+++.------.--------.>+.>.'
__FIBONACCI__ = '+++++++++++>+>>>>++++++++++++++++++++++++++++++++++++++++++++>++++++++++++++++++++++++++++++++<<<<<<[>[>>>>>>+>+<<<<<<<-]>>>>>>>[<<<<<<<+>>>>>>>-]<[>++++++++++[-<-[>>+>+<<<-]>>>[<<<+>>>-]+<[>[-]<[-]]>[<<[>>>+<<<-]>>[-]]<<]>>>[>>+>+<<<-]>>>[<<<+>>>-]+<[>[-]<[-]]>[<<+>>[-]]<<<<<<<]>>>>>[++++++++++++++++++++++++++++++++++++++++++++++++.[-]]++++++++++<[->-<]>++++++++++++++++++++++++++++++++++++++++++++++++.[-]<<<<<<<<<<<<[>>>+>+<<<<-]>>>>[<<<<+>>>>-]<-[>>.>.<<<[-]]<<[>>+>+<<<-]>>>[<<<+>>>-]<<[<+>-]>[<+>-]<<<-]'
__PRIME__ = '>++++++++[<++++++++>-]<++++++++++++++++.[-]>++++++++++[<++++++++++>-]<++++++++++++++.[-]>++++++++++[<++++++++++>-]<+++++.[-]>++++++++++[<++++++++++>-]<+++++++++.[-]>++++++++++[<++++++++++>-]<+.[-]>++++++++++[<++++++++++>-]<+++++++++++++++.[-]>+++++[<+++++>-]<+++++++.[-]>++++++++++[<++++++++++>-]<+++++++++++++++++.[-]>++++++++++[<++++++++++>-]<++++++++++++.[-]>+++++[<+++++>-]<+++++++.[-]>++++++++++[<++++++++++>-]<++++++++++++++++.[-]>++++++++++[<++++++++++>-]<+++++++++++.[-]>+++++++[<+++++++>-]<+++++++++.[-]>+++++[<+++++>-]<+++++++.[-]+[->,----------[<+>-------------------------------------->[>+>+<<-]>>[<<+>>-]<>>>+++++++++[<<<[>+>+<<-]>>[<<+>>-]<[<<+>>-]>>-]<<<[-]<<[>+<-]]<]>>[<<+>>-]<<>+<-[>+[>+>+<<-]>>[<<+>>-]<>+<-->>>>>>>>+<<<<<<<<[>+<-<[>>>+>+<<<<-]>>>>[<<<<+>>>>-]<<<>[>>+>+<<<-]>>>[<<<+>>>-]<<<<>>>[>+>+<<-]>>[<<+>>-]<<<[>>>>>+<<<[>+>+<<-]>>[<<+>>-]<[>>[-]<<-]>>[<<<<[>+>+<<-]>>[<<+>>-]<>>>-]<<<-<<-]+>>[<<[-]>>-]<<>[-]<[>>>>>>[-]<<<<<<-]<<>>[-]>[-]<<<]>>>>>>>>[-<<<<<<<[-]<<[>>+>+<<<-]>>>[<<<+>>>-]<<<>>[>+<-]>[[>+>+<<-]>>[<<+>>-]<>+++++++++<[>>>+<<[>+>[-]<<-]>[<+>-]>[<<++++++++++>>-]<<-<-]+++++++++>[<->-]<[>+<-]<[>+<-]<[>+<-]>>>[<<<+>>>-]<>+++++++++<[>>>+<<[>+>[-]<<-]>[<+>-]>[<<++++++++++>>>+<-]<<-<-]>>>>[<<<<+>>>>-]<<<<>[-]<<+>]<[[>+<-]+++++++[<+++++++>-]<-><.[-]>>[<<+>>-]<<-]>++++[<++++++++>-]<.[-]>>>>>>>]<<<<<<<<>[-]<[-]<<-]++++++++++.[-]'
__ROT13__ = '+[,+[-[>+>+<<-]>[<+>-]+>>++++++++[<-------->-]<-[<[-]>>>+[<+<+>>-]<[>+<-]<[<++>>>+[<+<->>-]<[>+<-]]>[<]<]>>[-]<<<[[-]<[>>+>+<<<-]>>[<<+>>-]>>++++++++[<-------->-]<->>++++[<++++++++>-]<-<[>>>+<<[>+>[-]<<-]>[<+>-]>[<<<<<+>>>>++++[<++++++++>-]>-]<<-<-]>[<<<<[-]>>>>[<<<<->>>>-]]<<++++[<<++++++++>>-]<<-[>>+>+<<<-]>>[<<+>>-]+>>+++++[<----->-]<-[<[-]>>>+[<+<->>-]<[>+<-]<[<++>>>+[<+<+>>-]<[>+<-]]>[<]<]>>[-]<<<[[-]<<[>>+>+<<<-]>>[<<+>>-]+>------------[<[-]>>>+[<+<->>-]<[>+<-]<[<++>>>+[<+<+>>-]<[>+<-]]>[<]<]>>[-]<<<<<------------->>[[-]+++++[<<+++++>>-]<<+>>]<[>++++[<<++++++++>>-]<-]>]<[-]++++++++[<++++++++>-]<+>]<.[-]+>>+<]>[[-]<]<]'
__SQUARE__ = '++++[>+++++<-]>[<+++++>-]+<+[>[>+>+<<-]++>>[<<+>>-]>>>[-]++>[-]+>>>+[[-]++++++>>>]<<<[[<++++++++<++>>-]+<.<[>----<-]<]<<[>>>>>[>>>[-]+++++++++<[>-<-]+++++++++>[-[<->-]+[<<<]]<[>+<-]>]<<-]<<-]'
__SIERPINSKI_TRIANGLE__ = '[This program prints Sierpinski triangle on 80-column display. ]>+ ++   +[ < + ++       ++ +     + +>   -   ]   >+ + + + + + + +[               >+ +             + +<   -           ]   >> + + >         > > + >>       >       +       << <     < <     < <     < <<   [   -   [   -   >   +   <] > [ - < + > > > . < < ] > > >    [                               [                                        - >                             + +                                        +   +                           +   +                                        + + [ >                         + + + +                                        <       -                       ]       >. <     < [                     - >     + <    ]   +   >   [                   -   >   +   ++ + + + + + + +                 < < + > ] > . [                                                  -               ]               >               ]] +             < <             < [             - [    -   >           +   <           ]   +           >   [                                                    - < + >         > > - [         - > + <         ] + + >                                                    [       -       <       -       >       ]       <       << ]     < <     < <     ] +     + +     + +     + +     + ++   .   +   +   +   .   [   -   ]   <   ]   +   +   +   +   +* * * * * M a d e * B y : * N Y Y R I K K I * 2 0 0 2 * * * * *'

class maquinaTuring():
    def __init__(self, code, rfile):
        self.cinta = [0] * __CINTA_LIMIT__
        self.pos = 0
        self.code = str.replace(code,' ', '')
        self.codelen = len(code)
        self.codepos = 0
        self.codedict = dict()
        self.operations ={'+': self.sumb,'-': self.resb,'<': self.resp,'>':self.sump,'[': self.buco,']':self.bucc,',': self.read,'.':self.impr}
        if rfile != '':
            rfile = open(rfile,'r')
            self.rbufferpos = 0
            oldlen = 0
            self.rbuffer = ""
            while True:
                self.rbuffer += rfile.readline()
                if (oldlen == len(self.rbuffer)):
                    break
                oldlen = len(self.rbuffer)
            self.rbufferlen = oldlen

def sumb(self):
    if self.cinta[self.pos] < __BYTE_LIMIT__:
        self.cinta[self.pos] += 1
    else:
        self.cinta[self.pos] = 0

def resb(self):
    if self.cinta[self.pos] > 0:
        self.cinta[self.pos] -= 1
    else:
        self.cinta[self.pos] = __BYTE_LIMIT__

def sump(self):
    if self.pos < (__CINTA_LIMIT__ - 1):
        self.pos += 1
    else:
        self.pos = 0

def resp(self):
    if self.pos > 0:
        self.pos -= 1
    else:
        self.pos = (__CINTA_LIMIT__ - 1)

def buco(self):
    if self.cinta[self.pos] == 0:
        self.codepos = self.codedict[self.codepos]

def bucc(self):
    if self.cinta[self.pos] > 0:
        self.codepos = self.codedict[self.codepos]

def impr(self):
    sys.stdout.write(chr(self.cinta[self.pos] % 255))

def read(self):
    if self.rbufferpos < self.rbufferlen:
        self.cinta[self.pos] = ord(self.rbuffer[self.rbufferpos]) % 255
        self.rbufferpos += 1
    else:
        self.cinta[self.pos] = 0xFFFF
        return

def executeCode(self):
    start = time.time()
    pila = []
    for i in range(len(self.code)):
        if self.code[i] == '[':
            pila.append(i)
        elif self.code[i] == ']':
            j = pila.pop()
            self.codedict[i] = j
            self.codedict[j] = i
    print("Tiempo de preparacion: " + str(time.time() - start))
    while self.codepos < self.codelen:
        try:
            self.operations[self.code[self.codepos]]()
        except:
            pass
        self.codepos += 1
    print("\n\rTiempo de ejecucion: " + str(time.time()-start))


a = maquinaTuring(__SIERPINSKI_TRIANGLE__,'entrada.txt')
a.executeCode()

spoiler

Y con esto acabo :>

2

cm07 #87 Feb '13 Me creo c0d3r

Nada especial, resuelve el problema con el código más claro y limpio que he podido hacer en el tiempo que le he dedicado

Code

import sys
import time

startTime = time.time()   

try:
    f = open("program", "r")
    program = " ".join(f.readlines())
except IOError:
    print "Invalid program file"
    exit()
    

try:
    i = open("input", "r")
    inputStr = " ".join(i.readlines())
except IOError:
    print "Invalid input file"
    inputStr = ""

memory = [0] * 30000
memoryPointer = 0
programPointer = 0
inputPointer = 0

stack = []
jumps = dict()
for i in xrange(len(program)):
    if program[i] == '[':
        stack.append(i)
    elif program[i] == ']':
        j = stack.pop()
        jumps[j] = i
        jumps[i] = j

print "Preprocessing: " + str(time.time() - startTime) + " seconds"

while programPointer < len(program):
    """Main Loop"""
    if program[programPointer] == '>':
        memoryPointer += 1
        memoryPointer %= 3000
        

elif program[programPointer] == '<':
    memoryPointer -= 1
    memoryPointer %= 3000
    
elif program[programPointer] == '+':
    memory[memoryPointer] += 1
    memory[memoryPointer] %= 65536
    
elif program[programPointer] == '-':
    memory[memoryPointer] -= 1
    memory[memoryPointer] %= 65536
    
elif program[programPointer] == ']' and memory[memoryPointer] > 0:
    programPointer = jumps[programPointer]
    
elif program[programPointer] == '[' and memory[memoryPointer] == 0:
    programPointer = jumps[programPointer]

    
elif program[programPointer] == ',':
    memory[memoryPointer] = ord(inputStr[inputPointer])
    inputPointer += 1
    
elif program[programPointer] == '.':
    sys.stdout.write(chr(memory[memoryPointer] % 255))
    sys.stdout.flush()
                

programPointer += 1

print "Total Time: " + str(time.time() - startTime) + " seconds"

Screenshot