A configuração

Considere uma caixa de formato estranho contendo 29 células numeradas, como mostrado na Fig. 1 abaixo.

Dentro desta caixa 2D existem duas espécies de animais em forma de quadrado: shubbles e smoles. A Fig. 1 (a) mostra alguns shubbles em azul e alguns smoles em vermelho. Cada criatura ocupa exatamente uma célula da grade. A caixa pode conter entre 0 e 26 shubbles, mas sempre conterá exatamente dois pontos.

Estando sujeitos à gravidade, bolas e focinhos ficam no fundo da caixa, empilhados sobre qualquer coisa abaixo deles. Ambas as espécies são excepcionalmente preguiçosas e permanecem perpetuamente imóveis.

A caixa também contém um ponto, representado como um quadrado preto, que ocupa exatamente uma célula da grade. O stot não está sujeito à gravidade.

A caixa tem uma abertura localizada na parte inferior da célula 28, como representado na figura.

Para representar a configuração de shubbles, smoles e stot na caixa textualmente, usamos uma sequência de 29 caracteres, um caractere por célula de grade, na ordem enumerada, com .representando uma célula vazia, orepresentando um shubble, xrepresentando um smole, e @representando o stot. Por exemplo, a configuração da Fig. 1 (a) é representada pela sequência .........@...o....ooo..xox....

Manipulações

A caixa pode ser girada por qualquer múltiplo de 90 °. Enquanto a caixa está sendo girada, os shubbles e smoles permanecem estacionários dentro de suas células da grade. Assim que a rotação é concluída, elas caem diretamente para baixo até que i ) sejam bloqueadas por uma parede abaixo, ii ) sejam bloqueadas por um shubble, smole ou stot abaixo, ou iii ) caiam pelo buraco na célula 28 e saia da caixa. O stot não cai; permanece fixo em sua célula atual, mesmo que as criaturas descansem em cima dela.

A caixa não pode ser girada novamente até que as criaturas terminem de cair e atinjam uma nova configuração estável.

Textualmente, as rotações da caixa são indicadas por rotação +de 90 ° no sentido horário, rotação |de 180 ° e rotação -de 90 ° no sentido anti-horário.

Além disso, o ponto pode ser movido nas quatro direções da bússola em incrementos de uma célula da grade. Um movimento não pode: i ) causar uma colisão entre o stot e uma criatura (ou seja, a célula da grade de destino deve estar vazia), ii ) causar uma colisão entre o stot e uma parede, nem iii ) fazer com que o stot saia da caixa o buraco na célula 28.

Além disso, o stot pode não se mover se houver alguma criatura repousando sobre ele (com relação à gravidade atual).

Textualmente, os movimentos pontuais são indicados por <para esquerda, >para direita, ^para cima e vpara baixo. Os movimentos pontuais são sempre especificados em relação ao quadro "padrão" (não rotacionado) representado nas figuras. Ou seja, se o stot estiver na célula 10, a movimentação ^sempre a moverá para a célula 5 e a movimentação >sempre a moverá para a célula 11. A orientação da caixa não afeta a direção da movimentação.

Sequências de manipulações são codificadas usando cadeias de caracteres da esquerda para a direita. Por exemplo, a string +<<^-indica que a caixa é girada no sentido horário 90 °, depois o stot é movido para a esquerda duas vezes e para cima uma vez (com relação ao quadro padrão), e a caixa é girada 90 ° no sentido anti-horário de volta à sua orientação original.

O desafio

Por razões perfeitamente boas (que não posso divulgar), desejamos extrair todos os shubbles da caixa sem retirar um único rastro. Para fazer isso, podemos usar as manipulações especificamente descritas acima.

Antes de resolver esse problema, cabe a nós simular como nossas várias manipulações afetarão o conteúdo da caixa, que é o foco desse desafio.

Você deve escrever um programa que aceite dois argumentos de stdin(ou equivalente):

• uma sequência que descreve o estado inicial da caixa
• uma sequência de manipulações

Você pode assumir que ambos os argumentos são sintaticamente válidos, que a caixa inicia na orientação padrão e que o estado inicial da caixa é estável e legal.

O programa deve gerar stdout(ou equivalente):

• ( caso 1 ) o estado final da caixa, expresso como uma sequência, se a sequência de jogadas for legal (não viola as regras de movimentação do stot) e não faz com que nenhum smole saia da caixa. A orientação final da caixa não é importante.

• ( caso 2 ) um único ponto de exclamação !, se a sequência de movimentos for ilegal ou fizer com que qualquer buraque saia da caixa

Pontuação

O programa vencedor é o programa mais curto por contagem de bytes , sujeito a alguns multiplicadores de bônus extremamente lucrativos:

• reivindique um multiplicador de 0,65 se, em vez de imprimir a saída codificada para o caso 1, o programa produzir uma imagem ASCII da caixa em seu estado e orientação finais, usando os caracteres de especificação para barras, smoles, stots e células vazias e colocando um *na célula do lado de fora do buraco na célula 28. Os espaços em branco à esquerda e à direita são ignorados.

  Por exemplo, se a Fig. 1 (a) for girada em 90 °, a saída será

     .  .
    .....
    .o...
    xo.@.
   *ooo..
    x  .
  

• reivindique um multiplicador de 0,22 se, em vez de imprimir a saída codificada para o caso 1, o programa gerar um arquivo de imagem ou exibir uma janela da GUI com uma imagem da caixa em seu estado final e orientação. A figura deve estar no estilo da Fig. 1 (a), mostrando as células da grade, paredes e criaturas / pontos usando caixas coloridas.

• reivindique um multiplicador de 0,15 se, em vez de imprimir a saída codificada para o caso 1, o programa exibir uma janela animada .gif ou animada, mostrando todos os estados intermediários da simulação em intervalos de 1 segundo. As mesmas regras de imagem do multiplicador de 0,22 se aplicam. O primeiro quadro da animação deve representar o estado inicial da simulação. Além disso, a animação deve mostrar estados intermediários "ocultos", que são

  • os shubbles / smoles que caem em uma configuração estável por uma célula por quadro de animação após uma rotação

  • o estado intermediário rotacionado em 90 ° da caixa em uma rotação de 180 °

• reivindique um multiplicador de 0,12 se o programa produzir uma janela animada .gif ou animada da GUI do estilo acima, mas executar a 20 fps e mostrar

  • animações suaves e contínuas da caixa girando

  • animações contínuas e suaves do stot em movimento e dos shubbles / smoles que caem em uma configuração estável

  Os flocos que caem através do orifício na célula 28 devem ser mostrados saindo da caixa e devem desaparecer uma vez totalmente do lado de fora. Você pode escolher seu próprio tempo para a animação, desde que não mais que 1 manipulação / s seja realizada.

A pontuação total é floor( base score * multiplier ). Apenas um multiplicador pode ser reivindicado.

Afinal, é um mundo desprezível. ;)

MATLAB, ainda não destruído * 0,15

Seria ótimo se alguém pudesse arriscar um palpite sobre se isso funciona corretamente.

n = @()input('', 's');
E = @()fprintf('!');
M = zeros(7,9);
G = M;
I = [9:7:44 17:7:52 18:7:46 12:7:47 20:7:55];
M0 = M;
M0(I) = 1;
M([I 49]) = 1;
G(I) = n()-46;
trot = 0;
Xtr = [0 1-10i 11-7i 8+i];
X0 ='c66++66++oozzoozzn'-i*'YYNNAA--  ++88LLYY'-22+22i;
for a = [97 n()]
    a = find('-|+a^<v>'==a);
    if a<5
        R = @(m) rot90(m, a);
        G = R(G);
        [nr,nc] = size(G);
        M = R(M);
        M0 = R(M0);
        trot = mod(trot+a,4);
        X = exp(i*pi*trot/2)*X0 + 11*Xtr(trot+1);
    else
        z = find(G==18);
        J = z + [-nr,1]*[0,-1;1,0]^(trot+a)*[1;0];
        if ~M0(J) | G(J) | G(z+1)
            E();return
        end
        G(z) = 0;
        G(J) = 18;
    end
    fall = 1; 
    while fall
        clf
        plot(X/11,'k','LineW',3);
        for x = 2:nc; for y = 2:nr
             ch = G(y,x);
             if M0(y,x) 
                 rectangle('Po',[x,-y,1,1],'F',~ch|ch==[74 1 65]);
             end
        end;end
        pause(1);
        G2 = G;
        for r = nr-1:-1:2
            s = G2 > 30;
            f = G2(r,:) .* (s(r,:) & ~s(r+1,:) & M(r+1,:) & G(r+1,:)~=18);
            if r==size(G,1)-1 & any(f==74)
                E();return
            end
            G2(r:r+1,:) = G2(r:r+1,:) + [-f;f];
        end
        G2 = G2 .* M0;
        fall = any(any(G2 ~= G));
        G = G2;
    end 
end

Exemplo de resultado final para alguns movimentos aleatórios:

.........@...o....ooo..xox...
+>|<-v+^+