Basierend darauf: Versuche ein Quadrat zu machen!

Sie müssen dies ausgeben:

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

Wobei "#" durch die Eingabe ersetzt wird.

Wenn Sie "A" eingeben, sollten Sie erhalten

  AAAA
 A A A
AAA  A
A A A
AAAA

Wenn Sie "&" eingeben, sollten Sie erhalten

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

Karotte , 31 Bytes

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

#s werden durch die Eingabe ersetzt.

Grundsätzlich eine Portierung dieser Antwort auf dieses Problem.

05AB1E , 16 15 Bytes

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

Probieren Sie es online!

Erläuterung

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

Probieren Sie es online! und Beobachte den Dolmetscher!

Das passt auf einen 4-Würfel:

        . / 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 . .
. . . . . . . . . . . . . . . .
        . . . .
        . . . .
        . . . .
        . . . .

Ich bin nicht sehr gut darin, die Richtung des Anweisungszeigers zu manipulieren, daher werde ich weiterhin versuchen, dies zu tun. Sowohl dies als auch meine Antwort hier basieren auf dem "Hallo, Welt!" Beispielprogramm, das ./v.o;@?/(auf einem 3-Würfel) verwendet, um die Zeichen auf dem Stapel rekursiv zu drucken und einzufügen, sodass der Rest des Codes nur die Zeichen in der richtigen Reihenfolge auf den Stapel schiebt.

Ich habe jetzt einen Würfel auf einen Würfel gelegt, damit ich mich einfach ausruhen kann (und meine eigentliche Arbeit erledige).

SOGL , 13 10 Bytes

Βū&⁵'r⁹‘6n

Erläuterung:

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

MATL , 13 10 Bytes

Vielen Dank an Conor O'Brien, der 3 Bytes entfernt und mir gezeigt hat, dass Unprintables in Octave verwendet werden können.

Der Code enthält nicht druckbare Zeichen. Probieren Sie es online!

Erläuterung

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

Probieren Sie es online!

Japt , 20 Bytes

"OUyj|"®c ¤Åd0S1U +R

Online testen!

Nicht schlecht für eine Sprache ohne eingebaute Komprimierung (naja, außer das Komprimieren von Zeichenfolgen aus Kleinbuchstaben) ...

Erläuterung

In der Binärdatei sind die fünf Zeichen in der Zeichenfolge:

O 1001111
U 1010101
y 1111001
j 1101010
| 1111100

Schneiden Sie die Initialen 1von jedem ab und Sie erhalten das Muster für den Würfel.

"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

Z80-Baugruppe, 37 Byte Maschinencode

Angenommen, ein speicherzugeordnetes E / A-Gerät:

; KEIN LEERZEICHEN EINGEBEN, da sonst Leerzeichen und Zeilenumbrüche in Endlosschleifen gedruckt werden!

3A xx xx ld a, (Eingabe); Eingabezeichen holen
11 0A 20 ld de, 200ah; Leerzeichen & Zeilenumbruch
21 yy yy ld hl, Ausgabe; Ausgabeadresse abrufen
4F ld c, a; Zeichen in c setzen
Schleife:
72 ld (hl), d; Ausgaberaum * 2 | Ausgabezeichen * 2
72 ld (hl), d
77 ld (hl), a; Ausgabezeichen | Ausgabezeichen
71 ld (hl), c; Ausgabezeichen * 2 | Ausgaberaum * 2
71 ld (hl), c
77 ld (hl), a; Ausgabezeichen | Ausgabezeichen
73 ld (hl), e; Ausgabe Newline | Ausgabe Newline
72 ld (hl), d; Ausgaberaum | Ausgabezeichen
71 ld (hl), c; Ausgabezeichen | Ausgaberaum
72 ld (hl), d; Ausgaberaum | Ausgabezeichen
71 ld (hl), c; Ausgabezeichen | Ausgaberaum
72 ld (hl), d; Ausgaberaum | Ausgabezeichen
B9 cp c; Null setzen Flag 1. Mal | klar 2. Mal
20 06 jr nz, end; zum Ende springen
77 ld (hl), a; Ausgabezeichen
73 ld (hl), e; Ausgabe Newline
4A ld c, d; Platz in c setzen
57 ld d, a; Zeichen in d setzen
28 FB jr z, Schleife; Schleife zum 2. Mal
Ende:
73 ld (hl), e; Ausgabe Newline
77 ld (hl), a; Ausgabezeichen * 4
77 ld (hl), a
77 ld (hl), a
77 ld (hl), a
76 halt; oder 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

In LOLCODE nicht viel zum Golfen ...

Dadurch wird die Variable cin die Eingabe :)eingefügt und eine riesige verkettete Zeichenfolge mit Zeilenumbrüchen erstellt. Das ist alles.

Sed, 40 Zeichen

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

Fast betrogen, wie die Beschreibung der Herausforderung es fast wörtlich enthielt.

Probelauf:

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

Probieren Sie es online!

Python 2 , 61 Bytes

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

Probieren Sie es online!

V , 27 Bytes

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

Probieren Sie es 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

Ich habe dies nur zum Spaß gemacht, da es bereits eine bessere PHP-Antwort gibt.

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

Der Würfel wird gezeichnet, indem der Binärwert von 64349871, verkettet durch, abgerufen wird '00'.
Dies gibt Folgendes zurück:

0011110101011110011010101111

Jedes sechste Zeichen gebe ich eine neue Zeile aus, was dazu führt:

001111
010101
111001
101010
1111

Und anstatt anzuzeigen 0, wird ein Leerzeichen angezeigt, das wie folgt aussieht:

  1111
 1 1 1
111  1
1 1 1 
1111

Kohle , 17 16 Bytes

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

Probieren Sie es online! Link ist eine ausführliche Version des Codes. Länger als ich wollte, weil der "Würfel" etwas breiter als hoch oder tief ist. Glücklicherweise funktionieren einige der multidirektionalen Zeichen mit PolygonHollow, was mir 3 Bytes erspart. Bearbeiten: Speichert ein weiteres Byte mit + anstelle von T ↑. Erläuterung:

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

Zum Zeitpunkt der qAbfrage funktionierte die Variable nicht im ausführlichen Modus. Andernfalls hätte ich diese 14-Byte-Version erstellen können:

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

Probieren Sie es online!

Gestapelt , 31 Bytes

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

Probieren Sie es online!

Hier ist ein 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#

Dadurch wird ein Zeichenarray in ein Binär-Array konvertiert, jede Zeile auf Länge 6aufgefüllt und gemäß der Zeichenfolge indiziert' ' input +

Pyth, 25 22 21 20 Bytes

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

Versuch es!

21 Bytes

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

Versuche dies!

Auch 21 Bytes:

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

Versuch das!

JS (ES6), 64 60 52 Bytes

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

Kann dies verbessert werden:

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

Probieren Sie es online! Definiert eine Funktion f, die ein Zeichen annimmt g. Schade das die Tabelle direkt codiert ist kürzer ...

Alte Version, 90 Bytes

(Ich versuche immer noch Golf zu spielen)

Ich versuche nur eine einzige zu haben putchar, aber Idk. Es gibt nicht druckbare Dateien. Hier ist der 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);}

Dies codiert den Würfel in eine binäre Nachschlagetabelle, wobei ein 1Bit die Eingabe und ein 0Bit ein Leerzeichen darstellt. Probieren Sie es online!

Brain-Flak , 217 Bytes

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

Probieren Sie es online!

Waaaaay zu lang.

Swift - 82 Bytes + Foundation (18 Bytes)?

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

Standardmäßig haben Xcode-Swift-Projekte Whole-Module Optimization, so dass import Foundationfür diese einfache Lambda-ähnliche Funktion nicht erforderlich ist. Für die Ausführung in Online-Umgebungen ist dies jedoch erforderlich, wodurch möglicherweise 18 Byte hinzugefügt werden.

Hör zu!

Java 8, 55 Bytes

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

Probieren Sie es hier aus.

Java 7, 77 Bytes

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

Probieren Sie es hier aus.

CJam, 23 Bytes

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

Ich habe das Gefühl, dass ich trotzdem Golf spielen kann.

"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

Gleichstrom , 70 Bytes

Kodiert die Sequenz eher direkt mit geringfügiger Optimierung:

8224PdPdPdPdP10Pd8192+ddPPP10PdPdPdP8224PdP10Pd256*32+ddPPP10PdPdPdPdP

Probieren Sie es online!

Auf ein (nicht sehr golferisches) Extrem gebracht, 145 Bytes:

27065671941896667324298575455432398417474802390765222440949482848513*56759961956005660143530475805610581704254588701249011343446231795984498688+P

Probieren Sie es online!

Dabei wird berechnet A*x+B, wo Adie Positionen des Eingabezeichens und Bder Rest codiert werden:

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 Befehl druckt die resultierende Nummer als Byte-Stream.

C #, 53 Bytes

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

Windows Batch, 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

Sonderzeichen sicher, 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&&&&"}