Tarefa:

Crie um interpretador para um Algoritmo de Markov .

Regras tem a sintaxe:

:: = (( | ) +) *

:: = # { }

:: = -> [.]

:: = ( | ) [ ]

Existe uma regra por linha.

Se houver um . (período) presente antes do , então esta é uma regra de terminação, caso em que o intérprete deve parar a execução.

Um conjunto de regras consiste em uma sequência de regras, com comentários opcionais.

Conjuntos de regras

Use os seguintes testes nas entradas:

Conjunto de regras 1:

 Este arquivo de regras é extraído da Wikipedia:
http://en.wikipedia.org/wiki/Markov_AlgorithmA -> apple
B -> saco
S -> loja
T -> o
a loja -> meu irmão
uma regra de terminação nunca usada ->.

Exemplo de texto de:

I bought a B of As from T S.

Deve gerar a saída:

I bought a bag of apples from my brother.

Conjunto de regras 2:

Um teste da regra de terminação

 Ligeiramente modificado das regras na WikipediaA -> maçã
B -> saco
S -> .shop
T -> o
a loja -> meu irmão
uma regra de terminação nunca usada ->.

Exemplo de texto de:

I bought a B of As from T S.

Deve gerar:

I bought a bag of apples from T shop.

Conjunto de regras 3:

Isso testa a ordem de substituição correta e pode interceptar rotinas de substituição baseadas em regexp simples se caracteres especiais de expressão regular não forem escapados.

 Regras de teste de sintaxe BNFA -> apple
WWWW -> com
Bgage -> ->. *
B -> saco
->. * -> dinheiro
W -> WW
S -> .shop
T -> o
a loja -> meu irmão
uma regra de terminação nunca usada ->.

Exemplo de texto de:

I bought a B of As W my Bgage from T S.

Deve gerar:

I bought a bag of apples with my money from T shop.

Conjunto de regras 4:

Isso testa a ordem correta de varredura de regras e pode interceptar rotinas de substituição que digitalizam na ordem errada. Ele implementa um mecanismo geral de multiplicação unário. (Observe que a expressão de entrada deve ser colocada dentro de sublinhados nesta implementação.)

 ## Unary Multiplication Engine, para testar implementações do Algoritmo de Markov
## Por Donal Fellows.
Mecanismo de adição unário_ + 1 -> _1 +
1 + 1 -> 11+
Passe por converter da divisão da multiplicação em comum
addition1! ->! 1
! ->! +
_! -> _
Multiplicação unária duplicando lado esquerdo, lado direito times1 * 1 -> x, @ y
1x -> xx
X, -> 1,1
X1 -> 1X
_x -> _X
, x ->, X
y1 -> 1y
y_ -> _
Próxima fase de aplicação1 @ 1 -> x, @ y
1 @ _ -> @_
@ _ ->! _
++ -> +
Limpeza de terminação para addition_1 -> 1
1 + _ -> 1
_ + _ ->

Exemplo de texto de:

_1111*11111_

deve gerar a saída:

11111111111111111111

Conjunto de regras 5:

Uma simples máquina de Turing

implementando um castor ocupado de três estados.

A fita consiste em 0s e 1s, os estados são A, B, C e H (para Halt), e a posição da cabeça é indicada escrevendo a letra de estado antes do caractere onde a cabeça está.

Todas as partes da fita inicial em que a máquina opera devem ser fornecidas na entrada.

Além de demonstrar que o algoritmo Markov é Turing-complete, ele também me fez pegar um bug na implementação do C ++ que não foi pego pelos quatro primeiros conjuntos de regras.

 Máquina de Turing: castor ocupado de três estados
# estado A, símbolo 0 => escrever 1, mover para a direita, novo estado BA0 -> 1B
estado A, símbolo 1 => escrever 1, mover para a esquerda, novo estado C0A1 -> C01
1A1 -> C11
estado B, símbolo 0 => escrever 1, mover para a esquerda, novo estado A0B0 -> A01
1B0 -> A11
estado B, símbolo 1 => escrever 1, mover para a direita, novo estado BB1 -> 1B
estado C, símbolo 0 => escrever 1, mover para a esquerda, novo estado B0C0 -> B01
1C0 -> B11
estado C, símbolo 1 => escrever 1, mover para a esquerda, halt0C1 -> H01
1C1 -> H11

Este conjunto de regras deve virar

000000A000000

para dentro

00011H1111000

```yml tests: - text: markov é uma função. testString: 'assert(typeof markov === "function", "markov is a function.");' - text: '

markov(["A -> apple","B -> bag","S -> shop","T -> the","the shop -> my brother","a never used -> .terminating rule"],"I bought a B of As from T S.")

deve retornar "Eu comprei um saco de maçãs do meu irmão".' testString: 'assert.deepEqual(markov(rules[0],tests[0]),outputs[0],"

markov(["A -> apple","B -> bag","S -> shop","T -> the","the shop -> my brother","a never used -> .terminating rule"],"I bought a B of As from T S.")

should return "I bought a bag of apples from my brother.".");' - text: '

markov(["A -> apple","B -> bag","S -> .shop","T -> the","the shop -> my brother","a never used -> .terminating rule"],"I bought a B of As from T S.")

deveria devolver" Eu comprei uma bolsa de maçãs de loja de T. ".' testString: 'assert.deepEqual(markov(rules[1],tests[1]),outputs[1],"

markov(["A -> apple","B -> bag","S -> .shop","T -> the","the shop -> my brother","a never used -> .terminating rule"],"I bought a B of As from T S.")

should return "I bought a bag of apples from T shop.".");' - text: '

markov(["A -> apple","WWWW -> with","Bgage -> ->.*","B -> bag","->.* -> money","W -> WW","S -> .shop","T -> the","the shop -> my brother","a never used -> .terminating rule"],"I bought a B of As W my Bgage from T S.")

deve retornar 'Eu comprei um saco de maçãs com o meu dinheiro de loja T.'.' testString: 'assert.deepEqual(markov(rules[2],tests[2]),outputs[2],"

markov(["A -> apple","WWWW -> with","Bgage -> ->.*","B -> bag","->.* -> money","W -> WW","S -> .shop","T -> the","the shop -> my brother","a never used -> .terminating rule"],"I bought a B of As W my Bgage from T S.")

should return "I bought a bag of apples with my money from T shop.".");' - text: '

markov(["_+1 -> _1+","1+1 -> 11+","1! -> !1",",! -> !+","_! -> _","1*1 -> x,@y","1x -> xX","X, -> 1,1","X1 -> 1X","_x -> _X",",x -> ,X","y1 -> 1y","y_ -> _","1@1 -> x,@y","1@_ -> @_",",@_ -> !_","++ -> +","_1 -> 1","1+_ -> 1","_+_ -> "],"_1111*11111_")

deve retornar" 11111111111111111111 ".' testString: 'assert.deepEqual(markov(rules[3],tests[3]),outputs[3],"

markov(["_+1 -> _1+","1+1 -> 11+","1! -> !1",",! -> !+","_! -> _","1*1 -> x,@y","1x -> xX","X, -> 1,1","X1 -> 1X","_x -> _X",",x -> ,X","y1 -> 1y","y_ -> _","1@1 -> x,@y","1@_ -> @_",",@_ -> !_","++ -> +","_1 -> 1","1+_ -> 1","_+_ -> "],"_1111*11111_")

should return "11111111111111111111".");' - text: '

markov(["A0 -> 1B","0A1 -> C01","1A1 -> C11","0B0 -> A01","1B0 -> A11","B1 -> 1B","0C0 -> B01","1C0 -> B11","0C1 -> H01","1C1 -> H11"],"")

deve retornar" 00011H1111000 ".' testString: 'assert.deepEqual(markov(rules[4],tests[4]),outputs[4],"

markov(["A0 -> 1B","0A1 -> C01","1A1 -> C11","0B0 -> A01","1B0 -> A11","B1 -> 1B","0C0 -> B01","1C0 -> B11","0C1 -> H01","1C1 -> H11"],"")

should return "00011H1111000".");' ```