Bài tập

Cho một ký tự không phải khoảng trắng, tạo một hình vuông 3x3 của đầu vào đó. Ví dụ: nếu đầu vào là #, thì đầu ra là:

###
# #
###

Quy tắc

• Các định dạng đầu ra là nghiêm ngặt, mặc dù một dòng mới được cho phép. Điều đó có nghĩa là không gian ở giữa là bắt buộc và hai ký tự dòng mới tách ba dòng được yêu cầu.

Tủ thử

Đầu vào: #

Đầu ra:

###
# #
###

Đầu vào: A

Đầu ra:

AAA
A A
AAA

Đầu vào: 0

Đầu ra:

000
0 0
000

Chấm điểm

Đây là mã golf . Câu trả lời ngắn nhất trong byte thắng.

Than , 5 3 byte

Ｂ³Ｓ

Hãy thử trực tuyến! Chỉnh sửa: Đã lưu 40% nhờ @carusocomputing. Giải trình:

Ｂ   Draw a box
³   3×3 (second dimension is implicit if omitted)
Ｓ   Using the input character

Cà rốt , 11 byte

###
# #
###

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

Chương trình ở chế độ caret, trong đó #s được thay thế bằng đầu vào.

Python 2 , 32 byte

lambda s:s+s.join(s+'\n \n'+s)+s

Hãy thử trực tuyến!
Vì s='a': phần giữa s+'\n \n'+stạo a\n \navà s.joinbiến nó thành (chữ đậm là những phần được thêm vào), bởi vì chấp nhận một chuỗi dưới dạng lặp, sau đó nó được bao quanh với hai ký tự bị thiếuaa\na a\naaa.join.join

MATL , 5 byte

3Y6*c

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

Giải trình

3Y6   % Push predefined literal: [true true true; true false true; true true true]
*     % Implicitly input a character. Multiply element-wise by its code point
c     % Convert to char. Implicitly display. Char 0 is displayed as space

05AB1E , 8 byte

4×ð«û3ô»

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

INPUT    # ['R']                 | Implicit Input: 'R'
---------#-----------------------+-------------------------------
4×       # ['RRRR']              | Repeat string 4 times.     
  ð      # ['RRRR',' ']          | Push space onto top of stack.
   «     # ['RRRR ']             | Concatenate last 2 items.
    û    # ['RRRR RRRR']         | Palindromize.
     3ô  # [['RRR','R R','RRR']] | Split into 3 pieces.
       » # ['RRR\nR R\nRRR']     | Join with newlines
---------#-----------------------+-------------------------------
OUTPUT   # RRR                   | Implicitly print the top
         # R R                   | of the stack on exit.
         # RRR                   |

Ý tưởng ban đầu sử dụng 30 làm số nhị phân (chưa hoàn thành, một người khác thử điều này trong một lang khác):

05AB1E , 12 byte

30bûTIð«‡3ô»

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

Python 3.6 , 33 byte

lambda c:f'{3*c}\n{c} {c}\n{3*c}'

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

RPL (Reverse Ba Lan Lisp) , 60 ký tự

→STR 1 4 START DUP NEXT " " + SWAP + 4 ROLLD + + SWAP 2 PICK

(Lưu ý rằng "→" là một ký tự đơn trên HP48 và các máy tính tương thích)

Trực quan sẽ đại diện cho những gì bạn muốn bằng cách có ba mục trên ngăn xếp:

3.: "###"
2.: "# #"
1.: "###"

Nếu bạn khăng khăng trả lại nó dưới dạng một chuỗi, người ta cũng phải thêm các ký tự dòng mới và kết hợp các chuỗi, còn lại dưới dạng bài tập cho người kiểm tra tiếp theo.

Giải trình:

• →STR: Tạo đối tượng cuối cùng trong ngăn xếp thành một chuỗi. (Vì vậy, đầu vào có thể là bất cứ điều gì, ví dụ như một số.)
• 1 4: Đẩy số 1và4 vào ngăn xếp.
• START [...] NEXT: Giống như một vòng lặp for nhưng không có quyền truy cập vào biến đếm. Lấy hai số từ ngăn xếp (ở đây, chúng ta vừa đẩy 1và 4) và thực thi mã[...] lần tương ứng (ở đây, bốn lần).
• DUP: Sao y mục cuối cùng trong ngăn xếp.
• " ": Đẩy chuỗi (tức là chuỗi có một khoảng trắng) vào ngăn xếp.
• +: Lấy hai đối tượng từ ngăn xếp và trả chúng lại với nhau, cho các chuỗi: Nối.
• 4: Đẩy số 4vào ngăn xếp.
• ROLLD: Lấy phần tử cuối cùng (ở đây: 4 mà chúng ta vừa đẩy) từ ngăn xếp và cuộn phần tử tiếp theo xuống càng xa ngăn xếp như số chúng ta vừa lấy từ ngăn xếp chỉ định.
• SWAP: Hoán đổi hai phần tử ngăn xếp cuối cùng.
• 2: Đẩy 2 vào ngăn xếp.
• PICK: Lấy một phần tử (ở đây: 2Chúng ta vừa đẩy vào ngăn xếp), diễn giải nó thành một số n và sao chép phần tử thứ n từ ngăn xếp.

JavaScript, 28 byte

c=>c+c+c+`
${c} ${c}
`+c+c+c

Thử nó

f=
c=>c+c+c+`
${c} ${c}
`+c+c+c
o.innerText=f(i.value="#")
i.oninput=_=>o.innerText=f(i.value)

<input id=i maxlength=1><pre id=o>

Thạch , 8 byte

1 byte nhờ Erik the Outgolfer.

x4,`Ks3Y

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

Java 7, 56 55 byte

-1 Cảm ơn Leaky Nun vì đã chỉ ra khoảng trống mà tôi đã bỏ lỡ

String a(char s){return"...\n. .\n...".replace('.',s);}

Chỉ cần thay thế các dấu chấm bằng ký tự đã cho, cho đầu vào #:

...       ###
. .  =>   # #
...       ###

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

PHP, 32 byte

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

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

sed, 28 18 byte

s:.:&&&\n& &\n&&&:

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

Brain-Flak , 76 70 + 1 = 71 byte

Yêu cầu -ccờ

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

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

Bình thường, 7 byte

jc3.[9d

Hãy thử trực tuyến này.

Giải trình:

jc3.[9d Expects quoted input.
  3     3
     9  9
      d ' '
        Q (eval'd input) as implicit argument
   .[   Pad B on both sides with C until its length is a multiple of A
 c      Split B to chunks of length A, last chunk may be shorter
j       Join A on newlines

Brain-Flak , 61 , 59 byte

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

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

Đây là 58 byte byte mã +1cho-c cờ cho phép nhập và xuất ASCII.

Giải trình:

(((
   (
    (
     (

      #Duplicate the input 3 times
      ((({})))

#Push 10 (newline)
<([][][]())>

     #Push the input again
     )

#Push 32 (space)
<(([][][]()){})>

    #Push the input again
    )

#Push 10 (newline)
<([]()()())>)

#Push input 3 times
)))

C (gcc) , 49 47 byte

Đã lưu 2 byte nhờ 2501!

j;f(i){for(j=12;j;)putchar(--j%4?j-6?i:32:10);}

Hãy thử trực tuyến! có một dòng mới

Python 3 , 34 byte

lambda s:s*3+"\n"+s+" "+s+"\n"+s*3

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

Octave , 36 byte

x=repmat(input(0),3);x(5)=32;disp(x)

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

Giải trình

Điều này tạo ra một ma trận char 3x3 với char đầu vào được lặp lại và đặt mục nhập thứ 5 của nó theo thứ tự chính cột (tức là trung tâm của nó) thành 32(ASCII cho không gian).

Pyke , 5 byte

dQA.X

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

Ruby , 27 25 byte

Đã lưu 2 byte nhờ Level River St

->x{[s=x*3,x+" "+x,s]*$/}

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

Brainfuck, 40 byte

+++++[->++<<++++++>],...>.<.<++.>.>.<...

Hãy thử trực tuyến! Yêu cầu thực hiện có thể truy cập bên trái của vị trí bắt đầu.

Xem thêm: Câu trả lời cân não của Graviton có cách tiếp cận khác (nhưng dài hơn).

Giải trình:

Brainfuck có thể thực hiện nhiều thủ thuật hay với bộ hướng dẫn giới hạn của nó. Thật không may, câu trả lời này không sử dụng bất kỳ câu hỏi nào trong số đó, vì nó rẻ hơn (tính theo byte) để chỉ mã hóa mọi thứ.

+++++[->++<<++++++>]                         Sets the cells to |5*6|>0<|5*2|
,                   Takes input character into the middle cell | 30|>#<| 10|
...                                Print the top of the square | 30|>#<| 10| ###
>.                                   Print a newline character | 30| # |>10|    \n
<.                               Print another input character | 30|>#<| 10| #
<++.                  Add 30+2 for a space character and print |>32| # | 10|  _
>.                   And just print the 5 remaining characters | 32|>#<| 10|   #
>.                                                             | 32| # |>10|    \n
<...                                                           | 32|>#<| 10| ###

# = ký tự đầu vào, _ = dấu cách (ASCII 32), \ n = dòng mới (ASCII 10)

Kết quả trong hộp đẹp này (cho đầu vào '+'):

+++
+ +
+++

05AB1E , 7 6 byte

-1 byte nhờ tính toán carusocomputing.

ж¹ðJû

Giải trình:

         # Implicit input                  # ['R']
 Ð       # Repeat string three times       # ['R', 'R', 'R']
  ¶      # Push newline character          # ['R', 'R', 'R', '\n']
   ¹     # Push first input                # ['R', 'R', 'R', '\n', 'R']
    ð    # Push space                      # ['R', 'R', 'R', '\n', 'R', ' ']
     J   # Join stack                      # ['RRR\nR ']
      û  # Palindromize ("abc" -> "abcba") # ['RRR\nR R\nRRR']
         # Implicit output                 # []

Sử dụng mã hóa CP-1252 . Hãy thử trực tuyến!

Bình thường , 11 byte

jc++K*z4dK3

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

Giải trình:

jc++K*z4dK3    expects a single char as input

j              joins on new line
 c        3    chops array into 3 sized pieces
  +            joins +K*z4d and K
   +           joins K*z4 and d
    K          initialize variable K as *z4
     *z4       duplicate the input 4 times
        d      variable initialized to string " "
         K     calls variable K, in this case *z4

> <> , 24 23 byte

i:o:o:oao:o84*o:a0!.<o$

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

Swift3, 50 byte

[1,2,3].map{$0==2 ? print(c+" "+c) : print(c+c+c)}

Điều này sử dụng toán tử ternary để in các chuỗi khác nhau, tùy thuộc vào hàng.

Dùng thử trực tuyến

V , 8 byte

x3p2Ùlr 

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

C #, 50 byte

a=>Console.Write(a+a+a+"\n"+a+" "+a+"\n"+a+a+a);

Trường hợp thử nghiệm:

var f = new Action<string>(
a=>Console.Write(a+a+a+"\n"+a+" "+a+"\n"+a+a+a);
);
f("#");

Vim, 9 tổ hợp phím

Giả sử char đầu vào có mặt trong bộ đệm, vim làm cho điều này trở nên đơn giản

x3pY2plr<space>

Có lẽ có một số lệnh vim ma thuật sử dụng ở đây (dường như luôn luôn có một số) vì vậy đề xuất cải tiến được hoan nghênh. Chỉ có một tổ hợp phím phía sau V!

Z80 hoặc 8080 hội, mã máy 21 byte

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

              Z80 8080
3A xx xx ld a, (đầu vào) lda đầu vào; nhận ký tự đầu vào
11 0A 20 ld de, 200ah lxi d, 200ah; không gian & dòng mới
21 yy yy ld hl, đầu ra lxi h, đầu ra; lấy địa chỉ đầu ra
77 ld (hl), a Mov m, a; ký tự đầu ra * 3
77 ld (hl), một m m, một
77 ld (hl), một m m, một
73 ld (hl), e di động, e; đầu ra mới
77 ld (hl), a Mov m, a; ký tự đầu ra
72 ld (hl), d Mov m, d; không gian đầu ra
77 ld (hl), a Mov m, a; ký tự đầu ra
73 ld (hl), e di động, e; đầu ra mới
77 ld (hl), a Mov m, a; ký tự đầu ra * 3
77 ld (hl), một m m, một
77 ld (hl), một m m, một
76 tạm dừng; hoặc C9 ret

Không cần thông dịch viên!

Hexdump:

0000: 3A 00 FF 11 0A 20 21 01 FF 77 77 77 73 77 72 77
0010: 73 77 77 77 76

trong đó địa chỉ đầu vào là FF00h và địa chỉ đầu ra được ánh xạ ở FF01h. Các địa chỉ thực tế sẽ phụ thuộc vào phần cứng thực tế. Tất nhiên, điều này giả sử I / O là ánh xạ bộ nhớ. Nếu nó được ánh xạ I / O, nó sẽ mất thêm vài byte vì các lệnh I / O của Z80 & 8080 là hai byte mỗi. Điều này cũng giả sử thiết bị đầu ra diễn giải 0AH là một dòng mới và không yêu cầu CR (0Dh) sẽ thêm 4 byte vào chương trình.

J-uby , 22 20 byte

-2 byte nhờ @Jordan

:tr&"...
. .
..."&?.

Giải trình

String#trlà phương pháp thay thế nhân vật của Ruby. Cái đầu tiên &liên kết :trvới "...\n. .\n...", và cái thứ hai áp dụng '.'cho nó. Có hiệu quả, đây là->s{"...\n. .\n...".tr('.',s)}