Feliz aniversário, vamos comer um bolo!

12

É aniversário do meu amigo em breve e, como ele é um programador e amante de arte ASCII, pensei em fazer um bolo ASCII para ele!

Infelizmente, continuo esquecendo sua idade atual, então eu gostaria de ter um programa para o meu forno ASCII, que assa um bolo com um número especificado de velas, para que eu não precise fazê-lo novamente se estiver errado com o dele. era.

Os fornos ASCII possuem apenas capacidade limitada de memória e armazenamento; portanto, use o menor número possível de bytes .


Sua tarefa:

Escreva um programa que envie um bolo de aniversário para o console, com tantas velas quanto a entrada especificar.

Os requisitos do bolo são:

  • Ele deve ter uma borda, formada por linhas horizontais -e verticais |e vértices +.
  • Pelo menos 5 caracteres de largura (incluindo borda do bolo |)
  • Pelo menos 5 caracteres de altura (incluindo borda do bolo -)
  • Deve haver um caractere de espaço em branco entre a borda do bolo e a primeira base da vela (não a chama), de cada lado, exceto se houver chama nesse espaço. Uma chama ou base de vela não deve se sobrepor às bordas do bolo.
  • A largura máxima do bolo é de 9 caracteres, portanto, há um máximo de 5 velas por linha.
  • Como não queremos que o nosso bolo seja bidimensional, ele precisa ter mais 2 linhas de altura, para dar algum volume. Adicione outra borda na parte inferior e conecte os vértices com os que estão acima deles, novamente usando os caracteres ASCII de cima ( -, |e +).

Os requisitos de vela são:

  • Consiste na base |e na chama *, com a chama empilhada em cima da base.
  • As velas não podem estar diretamente adjacentes uma à outra, exceto na diagonal.
  • As velas são colocadas da esquerda para a direita e de cima para baixo, com 5 em uma linha no máximo.
    (Nota: se houvesse 5 velas na linha anterior, a próxima linha não poderá ter 5 também, pois elas seriam adjacentes.)

Notas Adicionais:

  • A largura do bolo depende do número de velas na primeira linha, mas deve ter no mínimo 5 caracteres e no máximo 9 caracteres.
  • As velas são preenchidas começando na linha superior, indo da esquerda para a direita. Uma vez que uma linha estiver cheia, a próxima deve começar na linha abaixo da primeira.

Entrada:

Você pode aceitar um número no formato (razoável) que desejar.

Para esse desafio, você pode supor que o número esteja entre 0 e 2 31 (não incluindo 0), mesmo que eu não reconheça alguém com essa idade.

Resultado:

Você pode retornar uma sequência ou gravar diretamente o bolo resultante no console de saída.

Regras:

  • As brechas padrão são proibidas.
  • Isso é , então o código mais curto em bytes, em qualquer idioma, vence.

Exemplos:

Entrada: 8

+-----------+
| * * * * * |
| |*|*|*| | |
|  | | |    |
|           |
+-----------+
|           |
+-----------+

Entrada: 2

+-----+
| * * |
| | | |
|     |
+-----+
|     |
+-----+

Entrada: 12

+-----------+
| * * * * * |
| |*|*|*|*| |
| *|*|*| |  |
| | | |     |
|           |
+-----------+
|           |
+-----------+

Boa sorte!

Ian H.
fonte
Pode haver várias soluções válidas para uma entrada?
officialaimm
1
@officialaimm Como existem especificações para pedidos de velas e dimensionamento de bolos, não deve ser possível.
Ian H.
2
Fato inútil: se você comemora seu aniversário a cada segundo, em vez de todo ano, então 2 ^ 31 ~ = 68 anos. Mas isso faz muitos bolos todos os dias e pode se tornar tedioso depois de algum tempo.
Arnauld
1
@Arnauld Mas, em seguida, 99% do tempo não é seu aniversário :( ... exceto se você está comemorando o fato geral de que você nasceu.
Ian H.
3
@IanH. Digamos que você esteja comemorando seu carimbo de data / hora de criação, então. :-)
Arnauld

Respostas:

10

Carvão , 76 71 70 66 46 bytes

NθF=+B⁺³⌊⟦χ⁺θθ⟧÷⁺℅ι⁺θθ⁹↘↘Fθ«↑|*¶¶¿‹⁶﹪⁺ιι⁹«M⁹←↓

Experimente online! Link é a versão detalhada do código. Editar: salvou 1 byte graças a @ASCII_Only. Economizou 20 bytes enormes ao descobrir uma maneira elegante de desenhar as velas. Explicação:

NθF=+B⁺³⌊⟦χ⁺θθ⟧÷⁺℅ι⁺θθ⁹

Calcule o tamanho de todo o bolo, incluindo volume extra e apenas a parte superior do bolo, para que possam ser desenhados. (( == ASCII 61) = ( += ASCII 43) + 9 * 2 para o volume extra.)

↘↘Fθ«

Mova o cursor para a primeira linha de 5 velas. Passe por cada vela.

↑|*¶¶

Imprima uma vela e mova para a direita dois caracteres para a próxima vela.

¿‹⁶﹪⁺ιι⁹«

No entanto, após as velas (indexadas a zero) 4, 8, 13, 17, 22, etc., etc. (que estão no final de uma linha),

M⁹←↓

mova o cursor para a primeira vela na próxima linha. Isso funciona em linhas ímpares e pares!

Neil
fonte
1
Sua solução coloca um (indesejada) linha extra para o número de entrada menor que 6. :)
Ian H.
@IanH. Desculpe, pensei que essa fosse a altura mínima por algum motivo. A correção que realmente me salvou 4 bytes!
Neil
Ainda é exibido incorretamente no TIO: /
Ian H.
1
@IanH. Experimente online! me dá saída idêntica ao seu exemplo ...
Neil
1
@Neil lembre-se que você não precisa o no início: P (btw obrigado por encontrar um outro jogador (não tão) caso extremo)
ASCII-only
3

Geléia , 67 bytes

s9s€5Ẏa;⁶;⁶z⁶Z
ç”|ṙ-ż"ç”*$U⁸RḤ’¤¦Ẏ€j@€“| “|”Zj@€⁾--Z”+®¦€0,1©¦;ṫ¥-Y

Um link monádico que pega um número e retorna uma lista de caracteres ou um programa completo que imprime a saída.

Experimente online!

Quão?

s9s€5Ẏa;⁶;⁶z⁶Z - Link 1, make some candle parts & topping: number, age; character, part
s9             - split (implicit range(age)) into chunks of 9 (or remainder)
  s€5          - split each chunk of 9 into chunks of 5 (a 5 and a 4 or remainder)
     Ẏ         - tighten (to a list of lists of length 5, 4, 5, 4, ..., remainder)
      a        - logical and with the part character (either | or * here)
       ;⁶      - concatenate a space (we all still want topping when no candles)
         ;⁶    - ...and another (we also want some extra topping below the last row)
           z⁶  - transpose with filler space (fill the top with topping!)
             Z - transpose (put it back around the right way again chef)

ç”|ṙ-ż"ç”*$U⁸RḤ’¤¦Ẏ€j@€“| “|”Zj@€⁾--Z”+®¦€0,1©¦;ṫ¥-Y - Main link: number, age
ç”|                                                  - call last link (1) as a dyad with '|'
   ṙ-                                                - rotate left by -1
          $                                          - last two links as a monad:
       ç”*                                           -   call (1) as a dyad with '*'
      "                                              - zip with the dyadic operation:
     ż                                               -   zip (interleave each)
                 ¦                                   - sparse application:
           U                                         - ...of: upend (reverse each)
                ¤                                    - ...to indexes: nilad+links as a nilad:
            ⁸                                        -   chain's left argument, age
             R                                       -   range
              Ḥ                                      -   double (vectorises)
               ’                                     -   increment
                  Ẏ€                                 - tighten €ach (from '|*' or '*|' pairs)
                       “| “|”                        - literal ["| ", "|"]
                    j@€                              - join (swap arguments) for €ach (add a little extra topping to the left, and add piping to the sides)
                             Z                       - transpose
                                 ⁾--                 - literal "--"
                              j@€                    - join (swap arguments) for €ach (add piping to the top and bottom edges)
                                    Z                - transpose (time to invest in a potters wheel!)
                                              ¦      - sparse application:
                                          0,1        - ...to indexes: [0,1] (both ends)
                                             ©       -   (copy that to the register)
                                         €           - ...of: for each:
                                        ¦            -   sparse application:
                                     ”+              -   ...of: '+' character
                                       ®             -   ...to indexes: recall from register (both ends)
                                                  -  - literal -1
                                                 ¥   - last two links as a dyad
                                                ṫ    -   tail from index (gets last two rows)
                                               ;     -   concatenate (repeats them underneath)
                                                   Y - join with newlines
                                                     - as a full program: implicit print
Jonathan Allan
fonte
1
Holy what +1 por bater Charcoal
somente ASCII
@ ASCII-only Desculpe, eu encontrei uma economia de 4 bytes ...
Neil
@Neil Bem, isso é muito bom, carvão vegetal é suposto ser bom em arte ASCII (melhor do que a geléia) depois de tudo: P
ASCII-only
1

Japonês , 94 bytes

/4½ c ÆYu ç +Um5-Yu)ÇV°<U?Q:Sø+(1+Yu)ç
"| {Ug ç}|"
Vd"|+ -"
[W¡"| {X}|"ÃVVWVW]c ·y rQ+S"*|" y

Experimente online!

Justin Mariner
fonte