Simule um computador do tipo bola de bilhar (com base na gravidade)

A máquina

Uma máquina do tipo bola de bilhar é composta apenas pelos símbolos, \ _ /juntamente com letras maiúsculas e minúsculas, espaços e número 1.

\e /são rampas. Uma bola vinda de cima será desviada para o lado direito ou esquerdo, respectivamente. Para ambas as rampas, se uma bola vier de ambos os lados, ela será desviada para baixo.

_é um elemento lógico. A lógica executada por ele é a parte mais parecida com o bilhar do computador. Primeiro, uma bola vinda da esquerda ou da direita continua na mesma direção. Uma bola vinda de cima será parada. Então, após o final de sua execução (consulte Executando a Máquina abaixo), se o número de bolas cruzando / aterrissando nela for um número par positivo, uma única bola será liberada da parte inferior do elemento.

Um espaço não faz nada. Quaisquer bolas vindas de qualquer direção caem diretamente devido à gravidade.

Letras minúsculas são entradas. Todas as entradas serão um único 1 ou 0.

Letras maiúsculas são saídas. O número emitido será o número de bolas de bilhar que atingem sua localização.

O número 1libera uma bola de bilhar extra nesse local. Representa um 1 lógico.

Além disso, todos os personagens \_/fazem com que qualquer bola vinda de qualquer direção caia diretamente devido à gravidade.

Bolas nunca combinam, partem ou colidem. Eles são criados apenas quando liberados de uma entrada, a _ou a 1. Eles são destruídos apenas quando caem diretamente sobre a _.

Máquina de exemplo

1 a
\_/ b
  \_/
 \/
 /\ /
_  _
A  B

Nunca haverá linhas em branco em uma máquina, mas as _podem parecer que há uma linha em branco.

Executando a máquina

Uma máquina é executada em camadas ou linhas. Todo o movimento da bola de bilhar na camada superior é realizado antes que algo aconteça na segunda camada.

A máquina

ab
\_A
 C

é executado da seguinte maneira:

Primeiro, ele solicita a entrada ano formulário a:. O usuário digitará 1 ou 0 (seguido de enter). Repete isso para a entrada b. Este é o fim da primeira camada. Vou assumir que o usuário inseriu um 1 para ambas as entradas.

Em seguida, ele traça o caminho da primeira bola (de a), que passa ao longo do \, através do _, dentro do Ae cai no local sob o A. Em seguida, traça o caminho para a segunda bola (de b), que vai direto para a _e termina. Este é o fim da segunda camada.

Agora, antes da terceira camada, uma vez que _ela teve duas bolas cruzadas, ela libera uma bola. A saída Ateve uma bola cruzada sobre ela, então ela sai A:1.

Para a terceira camada, ela traça o caminho da primeira bola (da _), que segue pela Ce cai diretamente. A segunda bola (que caiu pela A) também cai diretamente para baixo.

Agora, antes da quarta camada, uma vez que a saída Ctinha uma bola viajando sobre ela, ela sai C:1.

Como a quarta camada está em branco, o programa termina.

O resultado total deve parecer

a:1     (the user entered the one)
b:1     (same here)
A:1
C:1

O objetivo

Seu objetivo é pegar uma máquina da STDIN e simulá-la, levando entradas e saídas de impressão conforme necessário para a STDOUT. A primeira parte da entrada do seu programa consistirá na máquina a ser executada, seguida por uma linha em branco. Quaisquer letras de entrada encontradas devem fazer com que seu programa solicite entrada na forma do nome da entrada seguido por dois pontos. Qualquer saída deve ser mostrada na forma do nome da saída, seguida por dois pontos, seguida pelo número de bolas passando sobre esse ponto.

Isso é golfe.

Exemplos

Uma passagem de arame

ab
\/
AB

Um portão XOR

ab1
\_/
 C

Um somador completo

1 a
\_/ b
  \_/
 \/
 /\
_ __/
 \_/ 
  \/c
 \\_/ 
  _S1
\  \/
 __/
  /
 _
\__
 C

JavaScript ( 392 423)

Assume que a máquina está configurada em uma variável chamada me alerta a saída final.

l=m.split(q='\n');o='';for(r=Array(z=l[i=0].length);i<l.length;i++){L=l[i];n=Array(z);for(c=0;c<z;n[c]=N,r[c++]=R){C=L[c];N=~~n[c];R=~~r[c];if(C>'`'){N+=x=~~prompt(C);R+=x;o+=C+': '+x+q}else if(C=='\\'||C=='/'){for(d=c+(g=C=='/'?-1:1);L[d]=='_';r[d]+=R,d+=g);if(L[d]>'@'&L[d]<'[')r[d]+=r[c];n[d]=~~n[d]+R}else if(C<'2')N+=R+=~~C;else if(C!='_')o+=C+': '+R+q}for(c=0;c<z;c++)if(L[c]=='_')n[c]+=(r[c]%2)?0:r[c]>0;r=n}alert(o)

Fonte de amostra (executa a máquina do somador, consulte o histórico para fontes com menos golfe): http://jsfiddle.net/96yLj/12/

Spoilers:

- rrastreia o número de bolas na linha atual, nrastreia o número de bolas na próxima linha.
- Algoritmo: processa cada caractere de linha por caractere, mas _o último é o processo .
- Algoritmo: \-> siga _e aumente raté não _. O mesmo para, /mas na direção inversa. No final, aumente na gravidade puxando as bolas para baixo. gmantém a direção.
- if(L[d]>'@'&L[d]<'[')r[d]+=r[c];é para o bug mencionado no Edit 1 . A razão pela qual não podemos simplesmente dizer r[d]+=r[c];é \_/que, contando duas vezes as bolas durante o processamento /
- else if(C<'2')lida com os dois casos '1'e ' ', que se ~~Ctransforma em 1 e 0, respectivamente.

Editar 1: Corrigir o erro com a bola atropelada _não incluída no Acódigo de amostra.