Baseado nisso: tente fazer um quadrado!

Você precisa produzir isso:

  ####
 # # #
###  #
# # #
####

Onde "#" é substituído pela entrada.

Se você digitar "A", deverá obter

  AAAA
 A A A
AAA  A
A A A
AAAA

Se você digitar "&", deverá obter

  &&&&
 & & &
&&&  &
& & &
&&&&

Cenoura , 31 bytes

  ####
 # # #
###  #
# # #
####

#s são substituídos pela entrada.

Basicamente, uma porta desta resposta para este problema.

05AB1E , 16 15 bytes

ð‚•nxвΛ•2вèJ6ô»

Experimente online!

Explicação

ð‚                # push the list [<input>,<space>]
  •nxвΛ•          # push the number 816342339
        2в        # convert to list of base 2 digits
          è       # index into the the 2-char string with this list
           J      # join to string
            6ô    # split into pieces of length 6
              »   # join on newlines

Cubix , 62 bytes

./v<.o;.@?/;w.w;i:::::NrSs::SrSuUS::sN::rS:r:srNr:SrSsNs:::SSv

Experimente online! e Assista ao intérprete!

Isso se encaixa em um cubo 4:

        . / v <
        . o ; .
        @ ? / ;
        . . w ;
i : : : : : N r S s : : S r S u
U S : : s N : : r S : r : s r N
r : S r S s N s : : : S S v . .
. . . . . . . . . . . . . . . .
        . . . .
        . . . .
        . . . .
        . . . .

Eu não sou muito bom em manipular a direção do ponteiro de instruções, então continuarei tentando jogar isso. Tanto esta como a minha resposta aqui são baseadas no "Olá, mundo!" programa de exemplo usando./v.o;@?/ (em um cubo 3) para imprimir e exibir recursivamente os caracteres na pilha, para que o restante do código apenas coloque os caracteres na pilha na ordem correta.

Agora criei um cubo em um cubo para poder descansar (e fazer meu trabalho real).

SOGL , 13 10 bytes

Βū&⁵'r⁹‘6n

Explicação:

Βū&⁵'r⁹‘    push "  ŗŗŗŗ ŗ ŗ ŗŗŗŗ  ŗŗ ŗ ŗ ŗŗŗŗ", where "ŗ" is replaced with input
        6n  split into lines of length 6

MATL , 13 10 bytes

Agradeço a Conor O'Brien por remover 3 bytes e por me mostrar que os imprimíveis podem ser usados ​​no Octave.

O código contém caracteres não imprimíveis. Experimente online!

Explicação

'....'   % Push 5-char string (contains unprintables). Each char encodes a row
         % of the desired pattern
B        % Convert to binary. Gives a 5×6 binary matrix with the pattern
*        % Implicit input. Multiply element-wise (converts input to ASCII code)
c        % Convert to char. Implicitly display. Char 0 is shown as space

PHP, 52 bytes

<?=strtr("  0000
 0 0 0
000  0
0 0 0
0000",0,$argn);

Experimente online!

Japonês , 20 bytes

"OUyj|"®c ¤Åd0S1U +R

Teste online!

Nada mal para um idioma sem compactação incorporada (bem, exceto comprimir cadeias de letras minúsculas) ...

Explicação

Em binário, os cinco caracteres na sequência são:

O 1001111
U 1010101
y 1111001
j 1101010
| 1111100

Corte a inicial 1de cada uma e você obterá o padrão para o cubo.

"OUyj|"®   c ¤  Å  d0S1U +R
"OUyj|"mZ{Zc s2 s1 d0S1U +R}  // Expanded
                              // Implicit: U = input string
"OUyj|"mZ{                 }  // Replace each character Z in this string with this function:
          Zc                  //   Take the char-code of Z.
             s2               //   Convert to a binary string.
                s1            //   Slice off the first character (always a "1").
                   d0S1U      //   Replace "0"s with spaces and "1"s with the input.
                         +R   //   Append a newline.
                              // Implicit: output result of last expression

Montagem Z80, código de máquina de 37 bytes

Suponha um dispositivo de E / S mapeado para memória:

; NÃO introduza um espaço, pois ele entrará em espaços de impressão com loop infinito e novas linhas!

3A xx xx ld a, (entrada); obter caractere de entrada
11 0A 20 ld, 200ah; espaço e nova linha
21 yy yy ld hl, output; obter endereço de saída
4F ld c, a; colocar caractere em c
ciclo:
72 ld (hl), d; espaço de saída * 2 | caractere de saída * 2
72 ld (hl), d
77 ld (hl), a; caractere de saída | caractere de saída
71 ld (hl), c; caractere de saída * 2 | espaço de saída * 2
71 ld (hl), c
77 ld (hl), a; caractere de saída | caractere de saída
73 ld (hl), e; nova linha de saída | nova linha de saída
72 ld (hl), d; espaço de saída | caractere de saída
71 ld (hl), c; caractere de saída | espaço de saída
72 ld (hl), d; espaço de saída | caractere de saída
71 ld (hl), c; caractere de saída | espaço de saída
72 ld (hl), d; espaço de saída | caractere de saída
B9 cp c; definir zero sinalizador primeira vez | limpar a segunda vez
20 06 jr nz, fim; pule para o fim
77 ld (hl), a; caractere de saída
73 ld (hl), e; nova linha de saída
4A ld c, d; colocar espaço em c
57 dd, a; colocar caractere em d
28 FB jr z, laço; loop para a segunda vez
fim:
73 ld (hl), e; nova linha de saída
77 ld (hl), a; caractere de saída * 4
77 ld (hl), um
77 ld (hl), um
77 ld (hl), um
76 paradas; ou C9 ret

LOLCODE, 202 170 bytes

I HAS A c
GIMMEH c
VISIBLE"  "AN c AN c AN c AN c AN":) "AN c AN" "AN c AN" "AN c AN":)"AN c AN c AN c AN"  "AN c AN":)"AN c AN" "AN c AN" "AN c AN":)"AN c AN c AN c AN c

Em LOLCODE, não há muito para jogar golfe ...

Isso define a variável cna entrada e cria uma string concatenada gigante, incluindo :)novas linhas. É sobre isso.

Sed, 40 caracteres

s/./  &&&&\
 & & &\
&&&  &\
& & &\
&&&&/

Quase trapacear como a descrição do desafio continha quase literalmente.

Exemplo de execução:

bash-4.4$ sed 's/./  &&&&\
 & & &\
&&&  &\
& & &\
&&&&/' <<< 'C'
  CCCC
 C C C
CCC  C
C C C
CCCC

Experimente online!

Python 2 , 61 bytes

lambda c:"""  ####
 # # #
###  #
# # #
####""".replace('#',c)

Experimente online!

V , 27 bytes

4äl2>>Äyvho3pÄÙ3älWx<<3Îd^

Experimente online!

Hexdump:

00000000: 34e4 6c32 3e3e c479 7668 6f1b 3370 c4d9  4.l2>>.yvho.3p..
00000010: 33e4 6c57 783c 3c33 ce64 5e              3.lWx<<3.d^

PHP, 72 bytes

Eu fiz este apenas por diversão, já que já existe uma resposta PHP melhor.

for($i=0;$i<27;)echo('00'.decbin(64349871))[$i]?$argn:' ',++$i%6?'':'
';

O cubo é desenhado obtendo o valor binário de 64349871, concatenado por '00'.
Isso retorna o seguinte:

0011110101011110011010101111

A cada 6 caracteres, estou lançando uma nova linha, resultando no seguinte:

001111
010101
111001
101010
1111

E, em vez de exibir 0, ele exibe um espaço, que se parecerá com:

  1111
 1 1 1
111  1
1 1 1 
1111

Carvão , 17 16 bytes

ＳβＧＨ7+↗→³β→Ｇ↓↙³β

Experimente online! Link é a versão detalhada do código. Mais longo do que eu queria, porque o "cubo" é um pouco mais largo do que alto ou profundo. Felizmente, alguns dos caracteres multidirecionais funcionam com PolygonHollow, o que me salva em 3 bytes. Editar: salvou um byte adicional usando + em vez de T ↑. Explicação:

Ｓβ          Input the character
ＧＨ7+↗→³β    Draw the left half. 7 becomes ←↙ and + becomes →↓←↑.
→           Move right one character.
Ｇ↓↙³β       Draw the right half.

No momento do desafio, a qvariável não funcionava no modo detalhado, caso contrário, eu poderia ter criado esta versão de 14 bytes:

ＧＨ7+↗→³θ→Ｇ↓↙³θ

Experimente online!

Empilhados , 31 bytes

' '\+$'9*<'#.2 tb[6 dpad]map#

Experimente online!

Aqui está um hexdump:

λ xxd try-to-make-a-cube.stk
00000000: 2720 275c 2b24 270f 1539 2a3c 2723 2e32  ' '\+$'..9*<'#.2
00000010: 2074 625b 3620 6470 6164 5d6d 6170 23     tb[6 dpad]map#

Isso converte uma matriz de caracteres em binário, preenche cada linha no comprimento 6e a indexa de acordo com a sequência' ' input +

Pitão, 25 22 21 20 bytes

jcsm?d\ zjC"0¨eC"2 6

Tente!

21 bytes

t::." \"o½MËñ"\!bNw

Tente isso!

Também 21 bytes:

:jbct." \" ±¢î
"6Nw

Tente isso!

JS (ES6), 64 60 52 bytes

i=>`  ####
 # # #
###  #
# # #
####`.replace(/#/g,i)

Isso pode ser melhorado:

i=>`  ${y=i+i+i+i}
 # # #
###  #
# # #
${y}`.replace(/#/g,i)

C (gcc) , 90 84 bytes

i;v;f(g){for(i=32;i--;)putchar((v="####*@#@#@#*#@@###*#@#@#@*####@@"[i])&1?g:v-32);}

Experimente online! Define uma função fque leva um caractere g. Pena a codificação direta da tabela é mais curta ...

Versão antiga, 90 bytes

(Ainda tentando jogar golfe)

Tentando ter apenas um único putchar, mas idk. Existem imprimíveis, então aqui está o hexdump:

λ xxd try-to-make-a-cube.c
00000000: 693b 6a3b 6628 6729 7b63 6861 722a 6b3d  i;j;f(g){char*k=
00000010: 220f 1539 2a3c 223b 666f 7228 693d 303b  "..9*<";for(i=0;
00000020: 693c 353b 7075 7463 6861 7228 3130 292c  i<5;putchar(10),
00000030: 692b 2b29 666f 7228 6a3d 3332 3b6a 3b6a  i++)for(j=32;j;j
00000040: 2f3d 3229 7075 7463 6861 7228 6b5b 695d  /=2)putchar(k[i]
00000050: 266a 3f67 3a33 3229 3b7d                 &j?g:32);}

Isso codifica o cubo em uma tabela de pesquisa binária, em que um 1bit representa a entrada e um 0bit representa um espaço. Experimente online!

Flak cerebral , 217 bytes

(((((((((((((((((({}))))<([][]()())>)<(([][])[]{}())>)<(([][]){})>)<([])>)<(((()
())[][]{}()()))>)))<((()()()()()){})>)<(((()()()){}){}()[])>)<(((()()())()){}{}[
])>)<(((()()())){}{}[])((()()()()()){})>))))(([]()()()))

Experimente online!

Waaaaay por muito tempo.

Swift - 82 bytes + Fundação (18 bytes)?

var f={"  ####\n # # #\n###  #\n# # #\n####".replacingOccurrences(of:"#",with:$0)}

Por padrão, os projetos Xcode-Swift possuem Whole-Module Optimization, de modo que import Foundationnão é necessário para esta função simples semelhante a lambda. No entanto, é necessário executá-lo em ambientes online, o que pode adicionar 18 bytes.

Confira!

Java 8, 55 bytes

c->"  ####\n # # #\n###  #\n# # #\n####".replace('#',c) 

Experimente aqui.

Java 7, 77 bytes

String c(char c){return"  ####\n # # #\n###  #\n# # #\n####".replace('#',c);}

Experimente aqui.

CJam, 23 bytes

"pjFUC"{i2b(;}%rS+ff=N*

Eu sinto que ainda posso jogar isso.

"pjFUC" e# String literal:          │ "pjFUC"
{       e# For each:                │ 'p
  i     e#   Get code point:        │ 112
  2b    e#   To binary:             │ [1 1 1 0 0 0 0]
  (;    e#   Delete first:          │ [1 1 0 0 0 0]
}%      e# End                      │ [[1 1 0 0 0 0] [1 0 1 0 1 0] [0 0 0 1 1 0] [0 1 0 1 0 1] [0 0 0 0 1 1]]
r       e# Read token:              │ [[1 1 0 0 0 0] [1 0 1 0 1 0] [0 0 0 1 1 0] [0 1 0 1 0 1] [0 0 0 0 1 1]] "&"
S       e# Push space:              │ [[1 1 0 0 0 0] [1 0 1 0 1 0] [0 0 0 1 1 0] [0 1 0 1 0 1] [0 0 0 0 1 1]] "&" " "
+       e# Concatenate:             │ [[1 1 0 0 0 0] [1 0 1 0 1 0] [0 0 0 1 1 0] [0 1 0 1 0 1] [0 0 0 0 1 1]] "& "
ff=     e# Vectorized array lookup: │ ["  &&&&" " & & &" "&&&  &" "& & & " "&&&&  "]
N*      e# Join with newlines       │ "  &&&&
        e#                          │   & & &
        e#                          │  &&&  &
        e#                          │  & & & 
        e#                          │  &&&&  "
e# Implicit output

dc , 70 bytes

Codifica a sequência diretamente, com otimização menor:

8224PdPdPdPdP10Pd8192+ddPPP10PdPdPdP8224PdP10Pd256*32+ddPPP10PdPdPdPdP

Experimente online!

Levado para um extremo (não muito golfista), 145 bytes:

27065671941896667324298575455432398417474802390765222440949482848513*56759961956005660143530475805610581704254588701249011343446231795984498688+P

Experimente online!

Isso calcula A*x+B, onde Acodifica as posições do caractere de entrada e Bcodifica todo o resto:

A = 256 ⁰ + 256 ¹ + 256 ² + 256 ³ + 256 ⁵ + 256 ⁷ + 256 ⁹ + 256 ¹¹ + 256 ¹⁴ + 256 ¹⁵ + 256 ¹⁶ + 256 ¹⁸ + 256 ²⁰ + 256 ²² + 256 ²⁵ + 256 ²⁶ + 256 ²⁷ + 256 ²⁸

B = 10 × 256 ⁴ + 32 × 256 ⁶ + 32 × 256 ⁸ + 10 × 256 ¹⁰ + 32 × 256 ¹² + 32 × 256 ¹³ + 10 × 256 ¹⁷ + 32 × 256 ¹⁹ + 32 × 256 ²¹ + 32 × 256 ²³ + 10 × 256 ²⁴ + 32 × 256 ²⁹ + 32 × 256 ³⁰

P O comando imprime o número resultante como um fluxo de bytes.

C #, 53 bytes

c=>@"  ####
 # # #
###  #
# # #
####".Replace('#',c);

Lote do Windows, 79 bytes

@echo   %1%1%1%1
@echo  %1 %1 %1
@echo %1%1%1  %1
@echo %1 %1 %1
@echo %1%1%1%1

Caractere especial. seguro, 97 bytes:

@echo   ^%1^%1^%1^%1
@echo  ^%1 ^%1 ^%1
@echo ^%1^%1^%1  ^%1
@echo ^%1 ^%1 ^%1
@echo ^%1^%1^%1^%1

Tcl, 60 bytes

proc c x {regsub . $x "  &&&&\n & & &\n&&&  &\n& & &\n&&&&"}