任务

给定一个非空白可打印字符，对该输入进行3x3正方形表示。例如，如果输入为#，则输出为：

###
# #
###

规则

• 输出格式是严格的，尽管允许使用尾随换行符。这意味着中间需要空格，并且需要分隔三行的两个换行符。

测试用例

输入： #

输出：

###
# #
###

输入： A

输出：

AAA
A A
AAA

输入： 0

输出：

000
0 0
000

计分

这是代码高尔夫球。以字节为单位的最短答案将获胜。

木炭，5 3字节

Ｂ³Ｓ

在线尝试！编辑：由于@carusocomputing，节省了40％。说明：

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

胡萝卜，11个字节

###
# #
###

在线尝试！

程序处于插入符号模式，其中#s被输入替换。

Python 2，32字节

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

在线尝试！
对于s='a'：中间s+'\n \n'+s生成a\n \na并s.join上交它（加粗的是s ），因为接受一个字符串作为可迭代的字符串，所以它被两个缺少的字符包围aa\na a\naaa.join.join

MATL，5个字节

3Y6*c

在线尝试！

说明

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个字节

4×ð«û3ô»

在线尝试！

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                   |

最初的想法使用30作为二进制数（未完成，其他人在另一个lang中尝试这样做）：

05AB1E，12个字节

30bûTIð«‡3ô»

在线尝试！

Python 3.6，33个字节

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

在线尝试！

RPL（反向波兰语Lisp），60个字符

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

（请注意，“→”是HP48和兼容计算器上的单个字符）

通过在堆栈上放置三个项目，直观地表示您想要的内容：

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

如果您坚持将其作为一个字符串返回，则还必须添加换行符并将这些字符串组合在一起，作为练习留给下一个测试人员。

说明：

• →STR：使堆栈中的最后一个对象成为字符串。（因此输入可以是任何东西，例如数字。）
• 1 4：按数量1和4堆栈。
• START [...] NEXT：类似于for循环，但无法访问counter变量。从堆栈中获取两个数字（在这里，我们刚刚按下了1和4），并[...]在相应的时间执行了代码（这里是四次）。
• DUP：复制堆栈中的最后一个条目。
• " "：将字符串（即带有一个空格的字符串）推入堆栈。
• +：从堆栈中取出两个对象，然后将它们加在一起返回给字符串：串联的。
• 4：将号码推4入堆栈。
• ROLLD：4从堆栈中获取最后一个元素（这里是我们刚刚推送的元素），然后将下一个元素向下滚动到堆栈中，直到我们从堆栈中获取的编号指定为止。
• SWAP：交换最后两个堆栈元素。
• 2：推2入堆栈。
• PICK：获取一个元素（在这里：2我们刚刚压入堆栈的元素），将其解释为数字n，然后从堆栈中复制第n个元素。

JavaScript，28个字节

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

试试吧

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>

果冻，8字节

1个字节，感谢Outgolfer的Erik。

x4,`Ks3Y

在线尝试！

Java 7，56 55字节

-1感谢Leaky Nun指出我错过的空间

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

对于输入＃，只需用给定字符替换句点：

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

在线尝试！

PHP，32字节

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

在线尝试！

sed，28 18字节

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

在线尝试！

Brain-Flak，76 70 +1 = 71字节

需要-c标志

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

在线尝试！

Pyth，7个字节

jc3.[9d

在线尝试。

说明：

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

脑高射炮，61，59个字节

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

在线尝试！

这是58个字节的代码+1字节，用于-c标志，可启用ASCII输入和输出。

说明：

(((
   (
    (
     (

      #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字节

由于2501，节省了2个字节！

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

在线尝试！尾随换行符

Python 3，34个字节

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

在线尝试！

八度，36字节

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

在线尝试！

说明

这将创建一个3x3的char矩阵，并重复输入char，然后将其第5个条目按列的主要顺序（即其中心）设置为32（ASCII为空格）。

派克（Pyke），5个字节

dQA.X

在线尝试！

红宝石，27 25字节

由于Level River St节省了2个字节

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

在线尝试！

Brainfuck，40个字节

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

在线尝试！ 需要可以访问起始位置左侧的实现。

另请参见：Graviton的脑力激荡答案采用了不同的方法（但更长）。

说明：

Brainfuck的有限指令集可以完成许多很酷的技巧。不幸的是，此答​​案没有使用它们中的任何一个，因为仅对所有内容进行硬编码比较便宜（就字节而言）。

+++++[->++<<++++++>]                         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| ###

＃=输入字符，_ =空格（ASCII 32），\ n =换行符（ASCII 10）

结果显示在此漂亮的框中（用于输入“ +”）：

+++
+ +
+++

05AB1E，7 6字节

-1字节归功于carusocomputing。

ж¹ðJû

说明：

         # 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                 # []

使用CP-1252编码。在线尝试！

Pyth，11个字节

jc++K*z4dK3

在线尝试！

说明：

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字节

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

在线尝试！

Swift3，50个字节

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

这使用三元运算符来打印不同的字符串，具体取决于行。

在线尝试

V，8字节

x3p2Ùlr 

在线尝试！

C＃，50个字节

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

测试用例：

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

Vim，9击键

假设输入的char存在于缓冲区中，vim使其变得简单明了

x3pY2plr<space>

这里可能使用了一些魔术vim命令（似乎总是有一些），因此欢迎提出改进建议。V后面只有一个按键！

Z80或8080汇编，21字节机器代码

假定一个内存映射的I / O设备：

              Z80 8080
3A xx xx ld a，（输入）lda输入; 获取输入字符
11 0A 20 ld de，200ah lxi d，200ah; 空格和换行符
21 yy y ld hl，输出lxi h，输出；获取输出地址
77 ld（hl），运动m，a；输出字符* 3
77 ld（hl），运动m，
77 ld（hl），运动m，
73 ld（hl），e mov m，e；输出换行符
77 ld（hl），运动m，a；输出字符
72 ld（hl），d mov m，d; 输出空间
77 ld（hl），运动m，a；输出字符
73 ld（hl），e mov m，e；输出换行符
77 ld（hl），运动m，a；输出字符* 3
77 ld（hl），运动m，
77 ld（hl），运动m，
76停止了; 或C9 ret

无需翻译！

十六进制转储：

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

其中输入地址为FF00h，输出地址映射为FF01h。实际地址将取决于实际硬件。当然，这假设I / O是内存映射的。如果它是I / O映射的，则将花费几个额外的字节，因为Z80和8080 I / O指令每个都是两个字节。这也假定输出设备将0Ah解释为换行符，并且不需要CR（0Dh），而CR（0Dh）会在程序中增加4个字节。

J-uby，22 20字节

-2个字节，感谢@Jordan

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

说明

String#tr是Ruby的按字符替换方法。第一个&绑定:tr到"...\n. .\n..."，第二个部分应用于'.'它。实际上，这是->s{"...\n. .\n...".tr('.',s)}