Essa tarefa faz parte do Primeiro envio periódico de quebra-cabeça de programação Premier .
Você obtém uma hierarquia de itens no seguinte formato:
2
Hat
1
Gloves
que precisam ser colocados em caixas, assim:
.------------.
| Hat |
| .--------. |
| | Gloves | |
| '--------' |
'------------'
No formato de entrada, os números iniciam uma caixa com tantos itens quanto o número especificado. A primeira caixa contém dois itens (o chapéu e a caixa que contém as luvas); a segunda contém apenas um único item - as luvas.
Como pode ser visto, as caixas também podem viver dentro de caixas. E eles são sempre arredondados ... mais ou menos (cantos pontiagudos são um risco de ferimento e não queremos isso).
Abaixo estão os detalhes desagradáveis para aqueles que desejam utilizar cada minúsculo espaço de manobra que a especificação fornece. Lembre-se, não ler as especificações não é desculpa para enviar soluções erradas. Há um script de teste e alguns casos de teste no final.
Especificação
As caixas são construídas com os seguintes caracteres:
|
(U + 007C) é usado para construir as arestas verticais.-
(U + 002D) é usado para construir as arestas horizontais.'
(U + 0027) são os cantos inferiores arredondados..
(U + 002E) são os cantos superiores redondos.
Uma caixa, portanto, fica assim:
.--. | | '--'
Observe que, embora o Unicode também tenha cantos arredondados e caracteres de desenho de caixa adequados, essa tarefa é apenas em ASCII. Por mais que eu goste do Unicode, percebo que existem idiomas e ambientes por aí que ainda não chegaram na segunda à última década.
As caixas podem conter uma sequência de itens que são texto ou outros itens. Itens individuais em uma caixa são renderizados de cima para baixo. A sequência A, B, C é processada da seguinte maneira:
.---. | A | | B | | C | '---'
É claro que isso também se aplica às caixas aninhadas, que são um item como o texto. Portanto, a sequência A, B, Caixa (C, Caixa (D, E)), F renderizará da seguinte maneira:
.-----------. | A | | B | | .-------. | | | C | | | | .---. | | | | | D | | | | | | E | | | | | '---' | | | '-------' | | F | '-----------'
As caixas ajustam seu tamanho ao conteúdo e as caixas aninhadas sempre se estendem ao tamanho de seus pais. Sempre existe um espaço antes e depois do conteúdo, para que nem o texto nem as caixas aninhadas fiquem muito perto da borda da caixa externa. Em resumo, o seguinte está errado:
.---. |Box| '---'
E o seguinte está correto:
.-----. | Box | '-----'
Parece muito melhor também :-)
Os itens de texto (consulte Entrada abaixo) devem ser reproduzidos exatamente.
Sempre há uma única caixa de nível superior (cf. XML). No entanto, uma caixa pode conter várias outras caixas.
Entrada
A entrada é dada na entrada padrão; para um teste mais fácil, provavelmente redirecionado de um arquivo.
A entrada é fornecida em linha, com cada linha representando um item de texto para colocar na caixa atual ou abrindo uma nova caixa.
Cada linha é terminada por uma quebra de linha.
Os itens de texto são marcados por uma linha que não consiste em um número (veja abaixo). O texto usa caracteres alfabéticos, o espaço e a pontuação (
.,-'"?!()
). O texto não inicia nem termina com um espaço e sempre terá pelo menos um caractere.Uma caixa começa com uma única linha com um número. O número indica o tamanho da caixa, ou seja, o número dos seguintes itens que são colocados nela:
2 A B
gera uma caixa com dois itens de texto:
.---. | A | | B | '---'
Uma caixa sempre conterá pelo menos um item.
O final das caixas não é explicitamente marcado com uma linha; em vez disso, as caixas são fechadas implicitamente após o número especificado de itens ser colocado nelas.
Uma caixa é sempre apenas um item, independentemente de quantos itens contenham. Por exemplo
3 A 4 a b c d B
produzirá uma caixa com três itens, o segundo dos quais é outra caixa com quatro itens.
O aninhamento também não afeta o fato de uma caixa ser apenas um item.
Limites
O nível máximo de aninhamento é cinco . Ou seja, existem no máximo cinco caixas uma dentro da outra. Isso inclui o mais externo.
Há um máximo de dez itens por caixa.
Os itens de texto têm um comprimento máximo de 100 caracteres.
Resultado
- Saída é a caixa renderizada, incluindo todos os itens contendo e aninhados de acordo com as regras descritas acima.
- A saída deve ser fornecida na saída padrão e deve corresponder exatamente. Nenhum espaço em branco à esquerda ou à direita é permitido.
- Cada linha deve ser finalizada com uma quebra de linha, incluindo a última.
Condição vencedora
- O código mais curto vence (ou seja, obtém a resposta aceita).
Entrada de amostra 1
3
This is some text!
Oh, more text?
Just text for now, as this is a trivial example.
Saída de amostra 1
.--------------------------------------------------.
| This is some text! |
| Oh, more text? |
| Just text for now, as this is a trivial example. |
'--------------------------------------------------'
Entrada de amostra 2
4
Extreme
nesting
3
of
boxes
4
might
lead
to
2
interesting
1
visuals.
Indeed!
Saída de amostra 2
.--------------------------.
| Extreme |
| nesting |
| .----------------------. |
| | of | |
| | boxes | |
| | .------------------. | |
| | | might | | |
| | | lead | | |
| | | to | | |
| | | .--------------. | | |
| | | | interesting | | | |
| | | | .----------. | | | |
| | | | | visuals. | | | | |
| | | | '----------' | | | |
| | | '--------------' | | |
| | '------------------' | |
| '----------------------' |
| Indeed! |
'--------------------------'
Entrada de amostra 3
1
1
1
1
1
Extreme nesting Part Two
Saída de amostra 3
.------------------------------------------.
| .--------------------------------------. |
| | .----------------------------------. | |
| | | .------------------------------. | | |
| | | | .--------------------------. | | | |
| | | | | Extreme nesting Part Two | | | | |
| | | | '--------------------------' | | | |
| | | '------------------------------' | | |
| | '----------------------------------' | |
| '--------------------------------------' |
'------------------------------------------'
Entrada de amostra 4
3
Foo
2
Bar
Baz
2
Gak
1
Another foo?
Saída de amostra 4
.----------------------.
| Foo |
| .------------------. |
| | Bar | |
| | Baz | |
| '------------------' |
| .------------------. |
| | Gak | |
| | .--------------. | |
| | | Another foo? | | |
| | '--------------' | |
| '------------------' |
'----------------------'
Script de teste
Como acertar os detalhes pode ser difícil às vezes nós ( Ventero e eu) preparamos um script de teste com o qual você pode executar sua solução para verificar se está correto. Está disponível como um script do PowerShell e um script do bash . A invocação é: <test-script> <program invocation>
.
UPDATE: Os scripts de teste foram atualizados; houve vários casos de teste que não respeitavam os limites que eu defini. O script de teste do PowerShell não usou comparação com distinção entre maiúsculas e minúsculas para verificar o resultado. Espero que esteja tudo bem agora. O número de casos de teste foi reduzido para 156, embora o último agora seja bastante ... grande.
ATUALIZAÇÃO 2: Carreguei meu gerador de casos de teste . Escrito em C # , visando o tempo de execução do .NET 2. Funciona em mono. Isso pode ajudar as pessoas a testar sua implementação. Como pior caso definitivo, considerando os limites da tarefa, você pode tentar:
nb.exe 1 10 10 5 100 100 | my invocation
que gerará apenas caixas até o nível mais interno e utilizará o número máximo de itens por caixa e o comprimento máximo de itens de texto. Porém, não incluí este caso de teste no script de teste, pois é muito grande e a saída ainda maior.
ATUALIZAÇÃO 3: Atualizei o script de teste do PowerShell, que estava propenso a gerar erros, dependendo de como as terminações de linha estavam no script e de que termina a linha impressa. Agora deve ser agnóstico para ambos. Desculpe novamente pela confusão.