pb , 240 bytes
<[8]^w[Y!14]{w[X!24]{>[8]b[124]^b[124]v}vw[X!-8]{b[45]<}vv}>[12]^[12]b[49]>[12]w[T!8]{<[4]b[T+50]^<w[X%8!6]{b[65+T*3+X%8%3]>}>[10]vw[B!124]{<[24]vvv}t[T+1]}<[4]b[42]>[8]b[48]>[8]b[35]^[4]>w[B!0]{b[B+2]<}b[87]w[X!2]{<[5]w[B!0]{b[B+1]<}}b[80]
(Este programa solicitará a entrada na versão atual do pbi, porque vai para Y = -1 e a Bvariável tenta se atualizar. Mesmo se você digitar a entrada, nada será interrompido. É irritante, mas é melhor que a versão antiga que solicitou entrada, não importa o quê.)
pb é uma linguagem que trata o tratamento do terminal como uma tela 2D. Para produzir, você deve mover o "pincel" (um ponto representado pelos valores atuais das variáveis X e Y) para onde deseja que esse caractere vá e o coloque lá. É complicado para coisas como imprimir uma palavra, mas para a arte geralmente é conveniente.
Na verdade, este programa não desenha exatamente o que a pergunta especifica. (Espere, não me diminua ainda! Deixe-me explicar!)
Desenhar caixas com loops é muito fácil, mas há um problema. Se você repetir a seguinte forma:
--------
|
|
Você recebe caixas, mas as da direita e da parte inferior estarão abertas. Você pode desenhar manualmente os lados extras, mas isso custa bytes. Para contornar isso, meu programa realmente desenha isso, com as bordas abertas à esquerda e em cima:
| | | |
| | | |
--------------------------------
| | ABC | DEF |
| 1 | 2 | 3 |
--------------------------------
| GHI | JKL | MNO |
| 4 | 5 | 6 |
--------------------------------
| PQRS | TUV | WXYZ |
| 7 | 8 | 9 |
--------------------------------
| | | |
| * | 0 | # |
--------------------------------
Mas monotrilho! Não é isso que a especificação diz! Você não pode simplesmente desenhar outra coisa, porque é mais fácil e você sente vontade! Além disso, enquanto eu tenho sua atenção, você é muito inteligente e fofa.
Shh, shh, está tudo bem. O pb permite "escrever" em um ponto da tela com um ou mais valores negativos em suas coordenadas. O valor é armazenado enquanto o programa é executado, mas apenas os pontos onde X e Y são> = 0 são gravados na tela. Este programa posiciona o pincel para que as áreas coloridas nesta imagem tenham um X ou Y negativo:
Embora linhas extras sejam "desenhadas", elas nunca são impressas.
Depois de percorrer e criar a grade, este programa preenche as nove caixas principais. O primeiro é codificado, um 1 é gravado e o programa segue em frente. Os outros oito são gerados programaticamente. Ignorando o código para ir para a próxima caixa, notando quando a linha está vazia etc. (suponha que o pincel sempre comece na linha inferior da caixa e na coluna do meio), é o que é executado oito vezes:
b[T+50]
^<w[X%8!6]{b[65+T*3+X%8%3]>}
t[T+1]
Mesmo sabendo que esse bé o comando para escrever um caractere, ^v<>mova o pincel e w[a!b]{}execute o código entre chaves até que a != bisso seja difícil de seguir. A primeira coisa importante a se notar é que você não pode definir variáveis em pb. Existem seis em todos os programas e você precisa aprender a conviver com eles. Segundo, Té a única variável que você pode realmente usar da maneira que está acostumado a usar variáveis; atribuir um valor e depois lê-lo. Cada outra variável ou não pode ser definido e apenas diz-lhe algo sobre o ponto da tela que você está jogando, ou só pode ser definida de forma indireta e com efeitos secundários ( ^v<>mudança Xe Y, que também altera o local pincel. cSets Pa(P+1)%8, que também altera a cor de saída). Manter um contador para qual número precisa ser escrito e quais letras são simplesmente impossíveis. Em vez disso, esse código apenas rastreia o número e descobre as letras com base nele. Aqui está como:
b[T+50] # We start printing at box 2 with T==0, 0+50=='2'
^< # Go up and to the left of the number
w[X%8!6]{ # Take the X coordinate mod 8 so it's like we're in
# the leftmost box. Until hitting the sixth cell:
b[ # Write this character:
65 # 'A'
+ T * 3 # Number of current box - 2 (letters start at
# 2) * 3 (3 letters per box)
+ X % 8 % 3 # X % 8 makes every box behave like it's on the
# left, % 3 puts 0 at the point where the first
# letter goes, then 1, then 2. This is how each
# letter is made different in a box.
]
> # Move to the right
}
t[T+1] # Box is done, increase counter
Isso é imperfeito, pois apenas 3 letras são colocadas nas caixas 7 e 9. Portanto, depois de preencher a linha inferior (codificação simples), cada letra na caixa 9 é aumentada em 2 e o W é colocado manualmente. Da mesma forma, todas as letras nas caixas 7 e 8 são aumentadas em 1 e o P é colocado manualmente.
Ungolfed:
<[8]^ # Go to (-8, -1)
w[Y!14]{ # While the brush is not on Y=14:
w[X!24]{ # While the brush is not on X=24:
>[8] # Go right 8
b[124]^b[124]v # Draw a pipe at the current location and above it
}
vw[X!-8]{b[45]<} # Go down and draw hyphens all the way until X=-8
vv # Go down by 2 to start drawing next row
}
>[12]^[12]b[49] # Write a 1 in the first box
>[12] # Go to the bottom pipe on the right of box 2
w[T!8]{ # While T is not 8:
<[4] # Go to center cell of the box
b[T+50] # Write the number that belongs there
^<w[X%8!6]{b[65+T*3+X%8%3]>} # Write the letters
>[10]v # Go to the next box
w[B!124]{ # If the next box isn't there:
<[24]vvv # Go down a row
}
t[T+1] # Increase counter
}
<[4]b[42]>[8]b[48]>[8]b[35] # Put the asterisk, 0 and hash in their boxes
^[4]>w[B!0]{b[B+2]<} # Increase all letters in the 9th box by 2
b[87] # Put a W in the 9th box
w[X!2]{<[5]w[B!0]{b[B+1]<}} # Increase all letters in the 7th/8th box by 1
b[80] # Put a P in the 7th box