Dựa trên điều này: Hãy thử làm một hình vuông!

Bạn cần xuất kết quả này:

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

Trong đó "#" được thay thế bằng đầu vào.

Nếu bạn nhập "A", bạn sẽ nhận được

  AAAA
 A A A
AAA  A
A A A
AAAA

Nếu bạn nhập "&", bạn sẽ nhận được

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

Cà rốt , 31 byte

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

#s được thay thế bởi đầu vào.

Về cơ bản là một cổng của câu trả lời này , cho vấn đề này.

05AB1E , 16 15 byte

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

Hãy thử trực tuyến!

Giải trình

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

Khối , 62 byte

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

Hãy thử trực tuyến! và xem thông dịch viên!

Điều này phù hợp với một khối 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 . .
. . . . . . . . . . . . . . . .
        . . . .
        . . . .
        . . . .
        . . . .

Tôi không giỏi trong việc điều khiển hướng của con trỏ chỉ dẫn, vì vậy tôi sẽ tiếp tục thử và đánh gôn này. Cả câu trả lời này và câu trả lời của tôi ở đây đều dựa trên "Xin chào, Thế giới! ' chương trình ví dụ sử dụng ./v.o;@?/(trên 3 khối) để in đệ quy và bật các ký tự trên ngăn xếp, vì vậy phần còn lại của mã chỉ là đẩy các ký tự lên ngăn xếp theo đúng thứ tự.

Bây giờ tôi đã tạo ra một khối lập phương trên một khối lập phương, vì vậy tôi có thể nghỉ ngơi dễ dàng (và thực hiện công việc thực tế của mình).

SOGL , 13 10 byte

Βū&⁵'r⁹‘6n

Giải trình:

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

MATL , 13 10 byte

Cảm ơn Conor O'Brien vì đã xóa 3 byte và cho tôi thấy rằng không thể in được có thể được sử dụng trong Octave.

Mã chứa các ký tự không thể in. Hãy thử trực tuyến!

Giải trình

'....'   % 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 byte

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

Hãy thử trực tuyến!

Japt , 20 byte

"OUyj|"®c ¤Åd0S1U +R

Kiểm tra nó trực tuyến!

Không quá tệ đối với một ngôn ngữ không có nén tích hợp (tốt, ngoại trừ nén các chuỗi chữ cái viết thường) ...

Giải trình

Trong nhị phân, năm ký tự trong chuỗi là:

O 1001111
U 1010101
y 1111001
j 1101010
| 1111100

Cắt từng chữ cái ban đầu 1từ mỗi cái, và bạn có được mẫu cho khối lập phương.

"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 hội, mã máy 37 byte

Giả sử thiết bị I / O được ánh xạ bộ nhớ:

; KHÔNG VÀO MỘT KHÔNG GIAN hoặc nó sẽ đi vào không gian in vòng lặp vô hạn & dòng mới!

3A xx xx ld a, (đầu vào); nhận ký tự đầu vào
11 0A 20 ld de, 200ah; không gian & dòng mới
21 yy yy ld hl, đầu ra; lấy địa chỉ đầu ra
4F ld c, a; đặt nhân vật vào c
vòng:
72 ld (hl), d; không gian đầu ra * 2 | ký tự đầu ra * 2
72 ld (hl), d
77 ld (hl), a; ký tự đầu ra | ký tự đầu ra
71 ld (hl), c; ký tự đầu ra * 2 | không gian đầu ra * 2
71 ld (hl), c
77 ld (hl), a; ký tự đầu ra | ký tự đầu ra
73 ld (hl), e; đầu ra mới | đầu ra mới
72 ld (hl), d; không gian đầu ra | ký tự đầu ra
71 ld (hl), c; ký tự đầu ra | không gian đầu ra
72 ld (hl), d; không gian đầu ra | ký tự đầu ra
71 ld (hl), c; ký tự đầu ra | không gian đầu ra
72 ld (hl), d; không gian đầu ra | ký tự đầu ra
B9 cp c; đặt cờ không lần thứ 1 | xóa lần thứ 2
20 06 jr nz, kết thúc; bỏ qua để kết thúc
77 ld (hl), a; ký tự đầu ra
73 ld (hl), e; đầu ra mới
4A ld c, d; đặt không gian trong c
57 ld d, a; đặt nhân vật vào d
28 FB jr z, vòng lặp; lặp đến lần thứ 2
kết thúc:
73 ld (hl), e; đầu ra mới
77 ld (hl), a; ký tự đầu ra * 4
77 ld (hl), một
77 ld (hl), một
77 ld (hl), một
Tạm dừng 76; hoặc C9 ret

LOLCODE, 202 170 byte

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

Trong LOLCODE, không có nhiều để chơi gôn ...

Điều này đặt biến cvào đầu vào và tạo ra một chuỗi nối khổng lồ bao gồm cả các :)dòng mới. Đó là về nó.

Sed, 40 ký tự

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

Hầu như gian lận như mô tả thách thức chứa nó gần như theo nghĩa đen.

Chạy mẫu:

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

Hãy thử trực tuyến!

Python 2 , 61 byte

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

Hãy thử trực tuyến!

V , 27 byte

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

Hãy thử trực tuyến!

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 byte

Tôi đã tạo ra cái này chỉ để cho vui, vì đã có câu trả lời PHP tốt hơn.

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

Khối lập phương được vẽ bằng cách lấy giá trị nhị phân của 64349871, được nối bởi '00'.
Điều này trả về như sau:

0011110101011110011010101111

Mỗi ký tự thứ 6, tôi xuất ra một dòng mới, dẫn đến điều này:

001111
010101
111001
101010
1111

Và, thay vì hiển thị 0, nó sẽ hiển thị một khoảng trắng, trông sẽ như sau:

  1111
 1 1 1
111  1
1 1 1 
1111

Than , 17 16 byte

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

Hãy thử trực tuyến! Liên kết là phiên bản dài dòng của mã. Dài hơn tôi muốn, vì "khối" rộng hơn một chút so với chiều cao hoặc sâu. May mắn thay, một số nhân vật đa chiều hoạt động với PolygonHollow, giúp tôi tiết kiệm 3 byte. Chỉnh sửa: Đã lưu thêm một byte bằng cách sử dụng + thay vì T. Giải trình:

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

Tại thời điểm thử thách, qbiến không hoạt động ở chế độ dài, nếu không tôi có thể tạo phiên bản 14 byte này:

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

Hãy thử trực tuyến!

Xếp chồng , 31 byte

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

Hãy thử trực tuyến!

Đây là một 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#

Điều này chuyển đổi một mảng ký tự thành nhị phân, đệm mỗi hàng thành chiều dài 6và lập chỉ mục cho nó theo chuỗi' ' input +

Pyth, 25 22 21 20 byte

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

Thử nó!

21 byte

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

Thử đi!

Ngoài ra 21 byte:

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

Hãy thử điều đó!

JS (ES6), 64 60 52 byte

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

Điều này có thể được cải thiện:

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

C (gcc) , 90 84 byte

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

Hãy thử trực tuyến! Xác định một hàm fcó một ký tự g. Quá tệ mã hóa bảng trực tiếp là ngắn hơn ...

Phiên bản cũ, 90 byte

(Vẫn đang cố chơi cái này)

Cố gắng chỉ có một putchar, nhưng idk. Có những cái không thể in được, vì vậy đây là 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);}

Điều này mã hóa khối lập phương vào bảng tra cứu nhị phân, trong đó một 1bit đại diện cho đầu vào và một 0bit đại diện cho một khoảng trắng. Hãy thử trực tuyến!

Brain-Flak , 217 byte

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

Hãy thử trực tuyến!

Chờ đợi quá lâu.

Swift - 82 byte + Foundation (18 byte)?

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

Theo mặc định, các dự án Xcode-Swift có Whole-Module Optimization, do đó import Foundationkhông cần thiết cho chức năng giống như lambda đơn giản này. Tuy nhiên, chạy nó trong môi trường trực tuyến yêu cầu nó, có thể thêm 18 byte.

Kiểm tra nó ra!

Java 8, 55 byte

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

Hãy thử nó ở đây.

Java 7, 77 byte

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

Hãy thử nó ở đây.

CJam, 23 byte

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

Tôi cảm thấy như tôi vẫn có thể chơi golf này.

"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

đc , 70 byte

Mã hóa chuỗi khá trực tiếp, với tối ưu hóa nhỏ:

8224PdPdPdPdP10Pd8192+ddPPP10PdPdPdP8224PdP10Pd256*32+ddPPP10PdPdPdPdP

Hãy thử trực tuyến!

Được đưa đến mức cực cao (không phải là rất gôn), 145 byte:

27065671941896667324298575455432398417474802390765222440949482848513*56759961956005660143530475805610581704254588701249011343446231795984498688+P

Hãy thử trực tuyến!

Điều này tính toán A*x+B, trong đó Amã hóa các vị trí của ký tự đầu vào và Bmã hóa tất cả phần còn lại:

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 lệnh in số kết quả dưới dạng luồng byte.

C #, 53 byte

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

Lô Windows, 79 byte

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

Đặc biệt char. an toàn, 97 byte:

@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 byte

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