Esse desafio é vagamente inspirado no jogo Zachtronics Infinifactory .
Você tem uma visão de cima para baixo de uma grade retangular de transportadores, representada por >v<^
. Pode haver células sem transportadores, representadas por espaços. Aqui está um exemplo:
> <vv <
v ^ >v v
>v^^>vv^
^>^ v
> v<v >>
>v v<^
Essa configuração é implicitamente cercada por um número infinito de espaços.
Além disso, você recebe as dimensões de uma carga retangular que é colocada nos transportadores no canto superior esquerdo da grade. Sua tarefa é descobrir se a carga pára ou se acaba se movendo em um loop.
Obviamente, é provável que a carga cubra vários transportadores de uma só vez, portanto, aqui estão as regras para determinar a direção da carga em cada etapa:
Transportadores opostos se cancelam. Portanto, se uma carga 3x2 cobrir qualquer uma das seguintes correções (descritas com hífens e tubos para maior clareza), o resultado será o mesmo:
+---+ +---+ +---+ |>>^| | ^| |v^^| |^<<| |^ | |^^v| +---+ +---+ +---+
O mesmo vale para estes:
+---+ +---+ +---+ |v^<| | | |><>| |>>>| |>> | |>><| +---+ +---+ +---+
Como a posição exata de um transportador embaixo da carga é irrelevante, não importa quais pares você cancela.
Este cancelamento é aplicado antes das outras regras. Portanto, para as outras regras, só haverá transportadores em no máximo duas direções.
- Se a carga não cobrir nenhum transportador (seja porque todos os transportadores cancelam, porque cobre apenas espaços ou porque saiu totalmente da grade), ela pára.
Se a carga cobre mais transportadores de uma direção do que da outra, a carga se move nessa direção. Por exemplo, se uma carga 3x2 cobria o seguinte patch
>> ^>^
moveria para a direita, porque há mais
>
de^
. Por outro lado, se abrangesse>>^ ^
essa regra não se aplicaria, porque há um empate entre
>
e^
.Isso deixa apenas os casos em que há um empate entre as direções adjacentes (um empate entre as direções opostas teria sido cancelado). Nesse caso, a carga continua se movendo ao longo do eixo em que ela já está se movendo. Por exemplo, se uma carga 3x2 em movimento à direita ou esquerda estiver agora cobrindo o trecho
>>^ ^
se moveria para a direita. Se ele chegasse nesse patch subindo ou descendo, agora seria movido para cima. Se esse tipo de conflito ocorrer no primeiro passo da simulação, assuma que a carga estava se movendo para a direita.
Exemplos detalhados
Considere a grade do transportador na parte superior e uma carga 3x2. A seguir, é apresentada uma visualização passo a passo do processo. Cada etapa consiste na grade, com a carga representada por #
, uma pequena caixa que mostra os transportadores cobertos pela carga, outra caixa com os transportadores após o cancelamento e a regra que determina para onde a carga se move:
###vv < > <vv < > <vv < > <vv < > <vv < > <vv <
###^ >v v ###^ >v v v ^ >v v v ^ >v v v ^ >v v v ^ >v v
>v^^>vv^ ###v^^>vv^ ###v^^>vv^ ###^^>vv^ ###^>vv^ >###>vv^
^>^ v ^>^ v ### ^>^ v ###^>^ v ###>^ v ###^ v
> v<v >> > v<v >> > v<v >> > v<v >> > v<v >> > v<v >>
>v v<^ >v v<^ >v v<^ >v v<^ >v v<^ >v v<^
+---+ +---+ +---+ +---+ +---+ +---+ +---+ +---+ +---+ +---+ +---+ +---+
|> <| | | | v | | v | | >| | >| | >v| | >v| |>v^| |> ^| |v^^| | ^^|
| v | | v | | >| | >| | | | | | | | | | ^| | | | ^>| | >|
+---+ +---+ +---+ +---+ +---+ +---+ +---+ +---+ +---+ +---+ +---+ +---+
Rule 3 Rule 4 Rule 3 Rule 4 Rule 4 Rule 3
================================================================================
> <vv < > <### < > <vv <
v ###v v v ###v v v ###v v
>###>vv^ >v^^>vv^ >###>vv^
^>^ v ^>^ v ^>^ v
> v<v >> > v<v >> > v<v >>
>v v<^ >v v<^ >v v<^
+---+ +---+ +---+ +---+ +---+ +---+
|^ >| | >| |vv | | v | |^ >| | >|
|v^^| | ^^| |^ >| | >| |v^^| | ^^|
+---+ +---+ +---+ +---+ +---+ +---+
Rule 3 Rule 4 Rule 3
Nesse ponto, a carga entra em um loop entre os dois últimos quadros.
Agora considere uma carga 2x3:
##<vv < >##vv < > <vv < > <vv < > <vv < > <vv <
## ^ >v v ##^ >v v ##^ >v v v ^ >v v v ^ >v v v ^ >v v
##>v^^>vv^ ##v^^>vv^ ##v^^>vv^ ##v^^>vv^ ##^^>vv^ >v^^>vv^
^>^ v ^>^ v ## ^>^ v ## ^>^ v ##^>^ v ##^>^ v
> v<v >> > v<v >> > v<v >> >##v<v >> > ##<v >> > ##<v >>
>v v<^ >v v<^ >v v<^ >v v<^ >v v<^ ## v<^
+--+ +--+ +--+ +--+ +--+ +--+ +--+ +--+ +--+ +--+ +--+ +--+
|> | |> | | <| | | |v | |v | | >| | >| |>v| |>v| | | | |
| v| | v| |v | |v | | >| | >| | | | | | | | | | v| | v|
| | | | | >| | | | | | | | | | | | v| | v| |>v| |>v|
+--+ +--+ +--+ +--+ +--+ +--+ +--+ +--+ +--+ +--+ +--+ +--+
Rule 4 Rule 3 Rule 4 Rule 3 Rule 3 Rule 3
================================================================================
> <vv < > <vv < > <vv <
v ^ >v v v ^ >v v v ^ >v v
>v^^>vv^ >v^^>vv^ >v^^>vv^
^>^ v ^>^ v ^>^ v
> ##<v >> > v<v >> > v<v >>
## v<^ ## v<^ >v v<^
## ## ##
## ##
##
+--+ +--+ +--+ +--+ +--+ +--+
| v| | v| |>v| |>v| | | | |
|>v| |>v| | | | | | | | |
| | | | | | | | | | | |
+--+ +--+ +--+ +--+ +--+ +--+
Rule 3 Rule 4 Rule 2
Na última etapa, a regra 2 se aplica porque a carga saiu da grade e, portanto, pára e não haverá um loop.
Regras e premissas
Sua entrada será a grade do transportador, conforme descrito acima, juntamente com a largura e a altura da carga. Você pode levar esses três parâmetros em qualquer ordem e formato convenientes. Para a grade, isso significa que você pode ler uma única seqüência de caracteres com linhas separadas por novas linhas ou outros caracteres, ou uma matriz de cadeias de caracteres ou uma matriz de matrizes de caracteres, desde que as células individuais da grade ainda sejam representadas pelos caracteres >v<^
e espaços.
Você deve saída um truthy valor se os resultados de instalação em um loop de pelo menos dois quadros ou um Falsas valor se a carga virá para descansar.
Você pode supor que a grade será preenchida com um retângulo com espaços e que a carga se ajustará inicialmente à grade.
Você pode escrever um programa ou função, recebendo entrada via STDIN (ou alternativa mais próxima), argumento da linha de comando ou argumento da função e emitindo o resultado via STDOUT (ou alternativa mais próxima), valor de retorno da função ou parâmetro da função (saída).
Isso é código de golfe, então a resposta mais curta (em bytes) vence.
Casos de teste
Os casos de teste são agrupados por grades.
Grid (2x2):
>v
^<
Width Height Loop?
1 1 True
1 2 True
2 1 True
2 2 False
Grid (3x3):
> v
^ <
Width Height Loop?
1 1 False
1 2 False
1 3 False
2 1 False
2 2 True
2 3 True
3 1 False
3 2 True
3 3 False
Grid (4x3):
>^>v
v^v
^ <<
Width Height Loop?
2 2 False
Grid (6x5):
>v>v>v
^v^v^v
^v^v^v
^>^>^v
^<<<<<
Width Height Loop?
1 1 True
1 2 False
2 1 True
2 2 True
2 4 True
2 5 False
3 1 False
3 2 True
3 3 True
3 5 True
6 2 False
6 3 True
6 5 False
Grid (10x6):
> <vv <
v ^ >v v
>v^^>vv^
^>^ v
> v<v >>
>v v<^
Width Height Loop?
1 1 False
2 3 False
2 6 False
3 2 True
5 4 False
6 1 True
10 6 False
Como um conjunto adicional de casos de teste, considere que qualquer entrada em que a grade consiste apenas em espaços deve produzir um resultado falso.
Verifiquei todos os casos de teste manualmente, então, deixe-me saber se você acha que cometi um erro.
[^^/v<]
torna - se [[0,1] [0,1];[0,-1] [-1,0]]
? Ou você quer dizer que depende de nós se é STDIN, uma entrada de string, uma entrada de array de caracteres, etc, mas ainda precisa estar na forma de ^, v,> e <?
><^v
ou por um espaço. Eu vou esclarecer isso.