Görev

Beyaz olmayan bir yazdırılabilir karakter verildiğinde, bu girişin 3x3 kare gösterimini yapın. Örneğin, giriş ise #, çıkış:

###
# #
###

kurallar

• Çıktı formatı kesindir, ancak takip eden bir yeni satıra izin verilir. Bu, ortadaki boşluğun gerekli olduğu ve ayrıca üç çizgiyi ayıran iki yeni satır karakterinin gerekli olduğu anlamına gelir.

testcases

Giriş: #

Çıktı:

###
# #
###

Giriş: A

Çıktı:

AAA
A A
AAA

Giriş: 0

Çıktı:

000
0 0
000

puanlama

Bu kod golfü . Bayt cinsinden en kısa cevap kazanır.

Kömür , 5 3 bayt

Ｂ³Ｓ

Çevrimiçi deneyin! Düzenleme: @carusocomputing sayesinde% 40 tasarruf sağladı. Açıklama:

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

Havuç , 11 bayt

###
# #
###

Çevrimiçi deneyin!

Program, #s'nin girişle değiştirildiği caret modundadır .

Python 2,32 bayt

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

Çevrimiçi deneyin!
For s='a': orta s+'\n \n'+soluşturur a\n \nave s.joindöndürüraa\na a\naa (kalın aler olanlardır .join, çünkü ekler) .joinbir iterable olarak bir dize kabul, o zaman iki kayıp karakterleri ile çevrilidir

MATL , 5 bayt

3Y6*c

Çevrimiçi deneyin!

açıklama

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 bayt

4×ð«û3ô»

Çevrimiçi deneyin!

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                   |

İkili sayı olarak 30 kullanan orijinal fikir (bitmemiş, başka birisi bunu başka bir dilde deneyebilir):

05AB1E , 12 bayt

30bûTIð«‡3ô»

Çevrimiçi deneyin!

Python 3.6 , 33 bayt

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

Çevrimiçi deneyin!

RPL (Ters Lehçe Lisp) , 60 karakter

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

("→" nın HP48 ve uyumlu hesap makinelerinde tek bir karakter olduğunu unutmayın)

Yığında üç öğe bulunduğunu görsel olarak istediğini temsil ederdi:

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

Onu bir dize olarak döndürmek için ısrar ederseniz, yeni satır karakterlerini de eklemek ve bir sonraki test cihazına egzersiz olarak bırakılan dizeleri birleştirmek gerekir.

Açıklama:

• →STR: Yığındaki son nesneyi bir dizgeye dönüştürün. (Yani giriş herhangi bir şey olabilir, örneğin bir sayı.)
• 1 4: Numarayı 1ve 4yığına basın.
• START [...] NEXT: Bir for döngüsü gibi ancak sayaç değişkenine erişmeden. Yığından iki sayı alır (burada, sadece ittik 1ve 4) ve kodu [...]ilgili zamanlara (burada dört kez) uygular .
• DUP: Yığındaki son girişi çoğalt.
• " ": Dizeye (örneğin bir boşluklu dize) yığına basın.
• +: Yığından iki nesneyi alın ve dizeler için bunları bir araya getirerek döndürün: Birleştirilmiş.
• 4: Sayıyı 4yığına itin .
• ROLLD: Son elemanı alır (burada: 4 yığından alır sadece ittiğimiz) yığından alır ve bir sonraki öğeyi yığının az önce belirttiği sayı kadar alır.
• SWAP: Son iki yığın öğesini değiştirir.
• 2: Yığına itin 2.
• PICK: Bir elementi alır (burada: 2Yığına ilerledik), onu n sayısı olarak yorumlar ve nth öğesini yığından kopyalar.

JavaScript, 28 bayt

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

Dene

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>

Jöle , 8 bayt

Outgolfer Erik'e 1 bayt teşekkürler.

x4,`Ks3Y

Çevrimiçi deneyin!

Java 7, 56 55 bayt

-1 Kaçırdığım alanı işaret ettiği için Leaky Nun'a teşekkürler.

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

Basitçe #, giriş için belirtilen karakterlerle dönemleri değiştirir:

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

Çevrimiçi deneyin!

PHP, 32 Bayt

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

Çevrimiçi deneyin!

sed, 28 18 bayt

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

Çevrimiçi deneyin!

Brain-Flak , 76 70 + 1 = 71 bayt

-cBayrak gerektirir

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

Çevrimiçi deneyin!

Pyth, 7 bytes

jc3.[9d

Try this online.

Explanation:

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 bytes

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

Try it online!

This is 58 bytes of code +1 byte for the -c flag which enables ASCII input and output.

Explanation:

(((
   (
    (
     (

      #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 bytes

Saved 2 bytes thanks to 2501!

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

Try it online! has a trailing newline

Python 3, 34 bytes

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

Try it online!

Octave, 36 bytes

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

Try it online!

Explanation

This creates a 3x3 char matrix with the input char repeated, and sets its 5th entry in column-major order (i.e. its center) to 32 (ASCII for space).

Pyke, 5 bytes

dQA.X

Try it online!

Ruby, 27 25 bytes

Saved 2 bytes thanks to Level River St

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

Try it online!

Brainfuck, 40 bytes

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

Try it online! Requires an implementation that can access left of the starting position.

Also see: Graviton's brainfuck answer which takes a different approach (but is longer).

Explanation:

Brainfuck can do a lot of cool tricks with its limited instruction set. Unfortunately, this answer doesn't use any of them, because it's cheaper (in terms of bytes) to just hardcode everything.

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

# = input character, _ = space (ASCII 32), \n = newline (ASCII 10)

Results in this beautiful box (for input '+'):

+++
+ +
+++

05AB1E, 7 6 bytes

-1 byte thanks to carusocomputing.

ж¹ðJû

Explanation:

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

Uses the CP-1252 encoding. Try it online!

Pyth, 11 bytes

jc++K*z4dK3

Try it online!

Explanation:

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 bytes

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

Try it online!

Swift3, 50 bytes

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

This uses the ternary operator to print different strings, depending on the row.

Try it online

V, 8 bytes

x3p2Ùlr 

Try it online!

C#,50 bytes

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

Test Case:

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

Vim, 9 keystrokes

Assuming the input char is present in a buffer, vim makes this straightforward

x3pY2plr<space>

There is probably some magic vim commands of use here (there always seem to be some) so improvement suggestions are welcome. Only one keystroke behind V!

Z80 or 8080 Assembly, 21 bytes machine code

Assume a memory mapped I/O device:

              Z80                  8080
3A xx xx    ld  a, (input)      lda  input       ; get input character
11 0A 20    ld  de, 200ah       lxi  d, 200ah   ; space & newline
21 yy yy    ld  hl, output      lxi  h, output  ; get output address
77          ld  (hl), a         mov  m, a       ; output character * 3
77          ld  (hl), a         mov  m, a
77          ld  (hl), a         mov  m, a
73          ld  (hl), e         mov  m, e       ; output newline
77          ld  (hl), a         mov  m, a       ; output character
72          ld  (hl), d         mov  m, d       ; output space
77          ld  (hl), a         mov  m, a       ; output character
73          ld  (hl), e         mov  m, e       ; output newline
77          ld  (hl), a         mov  m, a       ; output character * 3
77          ld  (hl), a         mov  m, a
77          ld  (hl), a         mov  m, a
76          halt                hlt             ; or C9 ret

No interpreter needed!

Hexdump:

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

where the input address is at FF00h and the output address is mapped at FF01h. The actual addresses will depend on the actual hardware. Of course this assumes the I/O is memory mapped. If it is I/O mapped, it would take several extra bytes because Z80 & 8080 I/O instructions are two bytes each. This also assumes the output device interprets 0Ah as a newline and doesn't require a CR (0Dh) which would add an extra 4 bytes to the program.

J-uby, 22 20 bytes

-2 bytes thanks to @Jordan

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

Explanation

String#tr is Ruby's character-wise replace method. The first & binds :tr to "...\n. .\n...", and the second partially applies '.' to it. Effectively, this is ->s{"...\n. .\n...".tr('.',s)}