Basado en esto: ¡Hazme un cuadrado!

Necesita dar salida a esto:

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

Donde "#" se reemplaza con la entrada.

Si ingresa "A", debería obtener

  AAAA
 A A A
AAA  A
A A A
AAAA

Si ingresa "&", debería obtener

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

Tabla de clasificación

Aquí hay un fragmento de pila para generar una tabla de clasificación regular y una descripción general de los ganadores por idioma.

/* Configuration */

var QUESTION_ID = 121651; // Obtain this from the url
// It will be like https://XYZ.stackexchange.com/questions/QUESTION_ID/... on any question page
var ANSWER_FILTER = "!t)IWYnsLAZle2tQ3KqrVveCRJfxcRLe";
var COMMENT_FILTER = "!)Q2B_A2kjfAiU78X(md6BoYk";
var OVERRIDE_USER = 48934; // This should be the user ID of the challenge author.

/* App */

var answers = [], answers_hash, answer_ids, answer_page = 1, more_answers = true, comment_page;

function answersUrl(index) {
  return "https://api.stackexchange.com/2.2/questions/" +  QUESTION_ID + "/answers?page=" + index + "&pagesize=100&order=desc&sort=creation&site=codegolf&filter=" + ANSWER_FILTER;
}

function commentUrl(index, answers) {
  return "https://api.stackexchange.com/2.2/answers/" + answers.join(';') + "/comments?page=" + index + "&pagesize=100&order=desc&sort=creation&site=codegolf&filter=" + COMMENT_FILTER;
}

function getAnswers() {
  jQuery.ajax({
    url: answersUrl(answer_page++),
    method: "get",
    dataType: "jsonp",
    crossDomain: true,
    success: function (data) {
      answers.push.apply(answers, data.items);
      answers_hash = [];
      answer_ids = [];
      data.items.forEach(function(a) {
        a.comments = [];
        var id = +a.share_link.match(/\d+/);
        answer_ids.push(id);
        answers_hash[id] = a;
      });
      if (!data.has_more) more_answers = false;
      comment_page = 1;
      getComments();
    }
  });
}

function getComments() {
  jQuery.ajax({
    url: commentUrl(comment_page++, answer_ids),
    method: "get",
    dataType: "jsonp",
    crossDomain: true,
    success: function (data) {
      data.items.forEach(function(c) {
        if (c.owner.user_id === OVERRIDE_USER)
          answers_hash[c.post_id].comments.push(c);
      });
      if (data.has_more) getComments();
      else if (more_answers) getAnswers();
      else process();
    }
  });  
}

getAnswers();

var SCORE_REG = /<h\d>\s*([^\n,]*[^\s,]),.*?(\d+)(?=[^\n\d<>]*(?:<(?:s>[^\n<>]*<\/s>|[^\n<>]+>)[^\n\d<>]*)*<\/h\d>)/;

var OVERRIDE_REG = /^Override\s*header:\s*/i;

function getAuthorName(a) {
  return a.owner.display_name;
}

function process() {
  var valid = [];
  
  answers.forEach(function(a) {
    var body = a.body;
    a.comments.forEach(function(c) {
      if(OVERRIDE_REG.test(c.body))
        body = '<h1>' + c.body.replace(OVERRIDE_REG, '') + '</h1>';
    });
    
    var match = body.match(SCORE_REG);
    if (match)
      valid.push({
        user: getAuthorName(a),
        size: +match[2],
        language: match[1],
        link: a.share_link,
      });
    
  });
  
  valid.sort(function (a, b) {
    var aB = a.size,
        bB = b.size;
    return aB - bB
  });

  var languages = {};
  var place = 1;
  var lastSize = null;
  var lastPlace = 1;
  valid.forEach(function (a) {
    if (a.size != lastSize)
      lastPlace = place;
    lastSize = a.size;
    ++place;
    
    var answer = jQuery("#answer-template").html();
    answer = answer.replace("{{PLACE}}", lastPlace + ".")
                   .replace("{{NAME}}", a.user)
                   .replace("{{LANGUAGE}}", a.language)
                   .replace("{{SIZE}}", a.size)
                   .replace("{{LINK}}", a.link);
    answer = jQuery(answer);
    jQuery("#answers").append(answer);

    var lang = a.language;
    if (/<a/.test(lang)) lang = jQuery(lang).text();
    
    languages[lang] = languages[lang] || {lang: a.language, user: a.user, size: a.size, link: a.link};
  });

  var langs = [];
  for (var lang in languages)
    if (languages.hasOwnProperty(lang))
      langs.push(languages[lang]);

  langs.sort(function (a, b) {
    if (a.lang > b.lang) return 1;
    if (a.lang < b.lang) return -1;
    return 0;
  });

  for (var i = 0; i < langs.length; ++i)
  {
    var language = jQuery("#language-template").html();
    var lang = langs[i];
    language = language.replace("{{LANGUAGE}}", lang.lang)
                       .replace("{{NAME}}", lang.user)
                       .replace("{{SIZE}}", lang.size)
                       .replace("{{LINK}}", lang.link);
    language = jQuery(language);
    jQuery("#languages").append(language);
  }

}

body { text-align: left !important}

#answer-list {
  padding: 10px;
  width: 290px;
  float: left;
}

#language-list {
  padding: 10px;
  width: 290px;
  float: left;
}

table thead {
  font-weight: bold;
}

table td {
  padding: 5px;
}

<script src="https://ajax.googleapis.com/ajax/libs/jquery/2.1.1/jquery.min.js"></script>
<link rel="stylesheet" type="text/css" href="//cdn.sstatic.net/codegolf/all.css?v=83c949450c8b">
<div id="answer-list">
  <h2>Leaderboard</h2>
  <table class="answer-list">
    <thead>
      <tr><td></td><td>Author</td><td>Language</td><td>Size</td></tr>
    </thead>
    <tbody id="answers">

    </tbody>
  </table>
</div>
<div id="language-list">
  <h2>Winners by Language</h2>
  <table class="language-list">
    <thead>
      <tr><td>Language</td><td>User</td><td>Score</td></tr>
    </thead>
    <tbody id="languages">

    </tbody>
  </table>
</div>
<table style="display: none">
  <tbody id="answer-template">
    <tr><td>{{PLACE}}</td><td>{{NAME}}</td><td>{{LANGUAGE}}</td><td>{{SIZE}}</td><td><a href="{{LINK}}">Link</a></td></tr>
  </tbody>
</table>
<table style="display: none">
  <tbody id="language-template">
    <tr><td>{{LANGUAGE}}</td><td>{{NAME}}</td><td>{{SIZE}}</td><td><a href="{{LINK}}">Link</a></td></tr>
  </tbody>
</table>

Zanahoria , 31 bytes

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

#s son reemplazados por la entrada.

Básicamente un puerto de esta respuesta , a este problema.

05AB1E , 16 15 bytes

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

Pruébalo en línea!

Explicación

ð‚                # 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

Pruébalo en línea! y mira al intérprete!

Esto cabe en un cubo de 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 . .
. . . . . . . . . . . . . . . .
        . . . .
        . . . .
        . . . .
        . . . .

No soy muy bueno manipulando la dirección del puntero de instrucciones, por lo que continuaré intentando jugar golf. Tanto esto como mi respuesta aquí se basan en el "¡Hola, mundo!" programa de ejemplo que utiliza ./v.o;@?/(en un cubo de 3) para imprimir y reventar los caracteres en la pila de forma recursiva, de modo que el resto del código simplemente empuja los caracteres hacia la pila en el orden correcto.

Ahora he hecho un cubo sobre un cubo, así puedo descansar tranquilo (y hacer mi trabajo real).

SOGL , 13 10 bytes

Βū&⁵'r⁹‘6n

Explicación:

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

MATL , 13 10 bytes

Gracias a Conor O'Brien por eliminar 3 bytes y por mostrarme que no se pueden imprimir en Octave.

El código contiene caracteres no imprimibles. Pruébalo en línea!

Explicación

'....'   % 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);

Pruébalo en línea!

Japt , 20 bytes

"OUyj|"®c ¤Åd0S1U +R

¡Pruébalo en línea!

No está mal para un idioma sin compresión incorporada (bueno, excepto la compresión de cadenas de letras minúsculas) ...

Explicación

En binario, los cinco caracteres en la cadena son:

O 1001111
U 1010101
y 1111001
j 1101010
| 1111100

Corta la inicial 1de cada uno, y obtienes el patrón para el 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

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

En LOLCODE, no mucho para jugar golf ...

Esto establece la variable cen la entrada y crea una cadena concatenada gigante que incluye :)nuevas líneas. Eso es todo.

Sed, 40 caracteres

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

Casi haciendo trampa ya que la descripción del desafío lo contenía casi literalmente.

Ejecución de muestra:

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

Pruébalo en línea!

Python 2 , 61 bytes

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

Pruébalo en línea!

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

Suponga que un dispositivo de E / S mapeado en memoria:

; ¡NO INGRESE UN ESPACIO o entrará en espacios de impresión de bucle infinito y nuevas líneas!

3A xx xx ld a, (entrada); obtener el carácter de entrada
11 0A 20 ld de, 200ah; espacio y nueva línea
21 aa aa ld hl, salida; obtener dirección de salida
4F ld c, a; poner carácter en c
lazo:
72 ld (hl), d; espacio de salida * 2 | carácter de salida * 2
72 ld (hl), d
77 ld (hl), a; carácter de salida | carácter de salida
71 ld (hl), c; carácter de salida * 2 | espacio de salida * 2
71 ld (hl), c
77 ld (hl), a; carácter de salida | carácter de salida
73 ld (hl), e; salida nueva línea | salida nueva línea
72 ld (hl), d; espacio de salida | carácter de salida
71 ld (hl), c; carácter de salida | espacio de salida
72 ld (hl), d; espacio de salida | carácter de salida
71 ld (hl), c; carácter de salida | espacio de salida
72 ld (hl), d; espacio de salida | carácter de salida
B9 cp c; establecer cero bandera primera vez | claro segunda vez
20 06 jr nz, fin; saltar al final
77 ld (hl), a; carácter de salida
73 ld (hl), e; salida nueva línea
4A ld c, d; poner espacio en c
57 dd, a; poner carácter en d
28 FB jr z, bucle; bucle a la segunda vez
final:
73 ld (hl), e; salida nueva línea
77 ld (hl), a; carácter de salida * 4
77 ld (hl), a
77 ld (hl), a
77 ld (hl), a
76 alto; o C9 ret

V , 27 bytes

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

Pruébalo en línea!

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

Hice este solo por diversión, ya que ya hay una mejor respuesta de PHP.

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

El cubo se dibuja obteniendo el valor binario de 64349871, concatenado por '00'.
Esto devuelve lo siguiente:

0011110101011110011010101111

Cada sexto carácter, estoy generando una nueva línea, lo que resulta en esto:

001111
010101
111001
101010
1111

Y, en lugar de mostrar 0, muestra un espacio, que se verá así:

  1111
 1 1 1
111  1
1 1 1 
1111

Carbón , 17 16 bytes

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

Pruébalo en línea! El enlace es a la versión detallada del código. Más largo de lo que quería, porque el "cubo" es un poco más ancho que alto o profundo. Afortunadamente, algunos de los caracteres multidireccionales funcionan con PolygonHollow, lo que me ahorra 3 bytes. Editar: guardado un byte adicional usando + en lugar de T ↑. Explicación:

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

En el momento del desafío, la qvariable no funcionaba en modo detallado, de lo contrario podría haber creado esta versión de 14 bytes:

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

Pruébalo en línea!

Apilado , 31 bytes

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

Pruébalo en línea!

Aquí hay un 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#

Esto convierte una matriz de caracteres en binario, rellena cada fila a la longitud 6y la indexa de acuerdo con la cadena' ' input +

Pyth, 25 22 21 20 bytes

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

¡Intentalo!

21 bytes

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

¡Prueba esto!

También 21 bytes:

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

¡Trata eso!

JS (ES6), 64 60 52 bytes

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

¿Se puede mejorar esto?

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);}

Pruébalo en línea! Define una función fque toma un personaje g. Lástima que codificar la tabla directamente es más corto ...

Versión anterior, 90 bytes

(Todavía estoy tratando de jugar golf)

Tratando de tener solo uno putchar, pero idk. Hay no imprimibles, así que aquí está el 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);}

Esto codifica el cubo en una tabla de búsqueda binaria, donde un 1bit representa la entrada y un 0bit representa un espacio. Pruébalo en línea!

Brain-Flak , 217 bytes

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

Pruébalo en línea!

Waaaaay demasiado tiempo.

Swift - 82 bytes + Foundation (18 bytes)?

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

De forma predeterminada, los proyectos Xcode-Swift sí lo tienen Whole-Module Optimization, por lo que import Foundationno es necesario para esta sencilla función tipo lambda. Sin embargo, ejecutarlo en entornos en línea lo requiere, lo que puede agregar 18 bytes.

¡Echale un vistazo!

Java 8, 55 bytes

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

Pruébalo aquí.

Java 7, 77 bytes

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

Pruébalo aquí.

CJam, 23 bytes

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

Siento que todavía puedo jugar golf esto.

"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 la secuencia de forma bastante directa, con una optimización menor:

8224PdPdPdPdP10Pd8192+ddPPP10PdPdPdP8224PdP10Pd256*32+ddPPP10PdPdPdPdP

Pruébalo en línea!

Llevado a un extremo (no muy golfista), 145 bytes:

27065671941896667324298575455432398417474802390765222440949482848513*56759961956005660143530475805610581704254588701249011343446231795984498688+P

Pruébalo en línea!

Esto calcula A*x+B, donde Acodifica las posiciones del carácter de entrada y Bcodifica todo el 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 El comando imprime el número resultante como una secuencia de bytes.

C #, 53 bytes

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

Lote de 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

Char 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&&&&"}