도전

당신의 작업은 주어진 문자열 입력을 취하고 입력을 제곱 형식으로 출력하는 프로그램을 만드는 것입니다. 빈 문자열은 빈 문자열을 반환해야합니다.

예

주어진 입력 :

golf

프로그램은 다음을 출력해야합니다 :

golf
o  l
l  o
flog

입력:

123

산출:

123
2 2
321

입력:

a

산출:

a

입력:

Hello, world!

출력 (와 w 사이의 간격에 주목하십시오-간격은 개행 문자가 아닙니다) :

Hello, world!
e           d
l           l
l           r
o           o
,           w

w           ,
o           o
r           l
l           l
d           e
!dlrow ,olleH

채점

이것은 code-golf 이므로 각 언어에서 가장 짧은 답변이 이깁니다.

숯 , 7 5 바이트

θ‖Ｏ↙↘

온라인으로 사용해보십시오! 링크는 자세한 버전의 코드입니다. 편집 : @CarlosAlejo 덕분에 2 바이트가 절약되었습니다. 설명:

θ       Print the input string, making the top row
 ‖Ｏ     Reflect with overlap...
   ↙    ... down and left, to create the left side
    ↘   ... down and right, to create the bottom and right sides

(반사 명령의 여러 방향은 동시에가 아니라 연속적으로 실행됩니다.)

MATL , 20 16 11 바이트

otYTO6Lt&(c

MATL 온라인 에서 사용해보십시오 !

편집 : 코드는 릴리스 20.2.1에서 작동하며 문제가 있습니다. 링크는 해당 릴리스를 사용합니다. (20.2.2에서는 코드가 짧아 지지만 도전 과제를 게시합니다).

설명

o     % Implicitly input a string. Convert chars to ASCII codes
t     % Duplicate
YT    % 2-input Toeplitz matrix
O     % Push 0
6L    % Push predefined literal [2, -1+1j]. When used as an index, this is
      % interpreted as 2:end-1 (indexing is 1-based)
t     % Duplicate
&(    % 4-input assignment indexing. This writes 0 at the square formed by
      % rows 2:end-1 and columns 2:end-1 
c     % Convert to char. Char 0 is shown as space. Implicitly display

젤리 ,  29 22  17 바이트

숯 은 이 점수를 깎아 내고

J⁶ẋa0,1¦"ṚṚ;$ṖŒḌY

문자 목록을 가져오고 리턴하는 모나드 링크; 또는 결과를 인쇄하는 전체 프로그램.

온라인으로 사용해보십시오!

어떻게?

J⁶ẋa0,1¦"ṚṚ;$ṖŒḌY - Link: list of characters, w     e.g. "whole"
 ⁶                - literal space character              ' '
J                 - range(length(w))                     [1,2,3,4,5]
  ẋ               - repeat                               [" ","  ","   ","    ","     "]
         Ṛ        - reverse w                            "elohw"
        "         - zip with:
       ¦          -   sparse application of:
   a              -     and (vectorises)
    0,1           -     to indexes: [0,1] (last and 1st) ["e","ll","o o","h  h","w   w"]
            $     - last two links as a monad:
          Ṛ       -   reverse                            ["w   w","h  h","o o","ll","e"]
           ;      -   concatenate                        ["w   w","h  h","o o","ll","e","e","ll","o o","h  h","w   w"]
             Ṗ    - pop (remove last entry)              ["w   w","h  h","o o","ll","e","e","ll","o o","h  h"]
              ŒḌ  - reconstruct matrix from diagonals    ["whole","h   l","o   o","l   h","elohw"]
                Y - join with newlines                   "whole\nh   l\no   o\nl   h\nelohw"
                  - if running as a full program implicit print

C, 109 바이트

i,j;f(char*s){for(i=j=printf("%s\n",s)-2;1[++s];)printf("%c%*c\n",*s,i,s[j-=2]);for(;*s*~i--;)putchar(*s--);}

온라인으로 사용해보십시오!

주목할만한 트릭 :

• 바이트를 낭비하는 대신 strlen첫 번째 줄을 인쇄하면서 동시에 문자열의 길이를 가져옵니다.

  i=j=printf("%s\n",s)-2

  printf작성된 바이트 수를 반환 하기 때문에 작동 합니다.

• 가운데 줄의 경우 문자열을 반복해야하지만 첫 번째 문자와 마지막 문자를 모두 제외해야합니다. 이것은 조건으로 달성됩니다

  1[++s]

  (보다 짧은 (++s)[1]) ++는 조건에 있기 때문에 첫 번째 문자를 건너 뛰고 현재 문자를 지나는 문자가 '\0'( 에서 멈추는 대신) 중지하면 마지막 문자를 건너 뜁니다 '\0'.

• 첫 번째 루프의 본문에서

  printf("%c%*c\n",*s,i,s[j-=2])

  우리는 그 다음의 현재 글자 "미러"적당한 인쇄 (함께 추적하는 자 j, 네거티브 들어가는 음극 번호 문자열에 대한 인덱스의 홀수 상황을 초래 않는다)의 길이에 덧붙여 i여기서 (공백 i이고 편리하게 strlen(s) - 1).

• 마지막 줄의 반전 인쇄는 매우 간단합니다. 유일한 트릭은 루프 본문의 반복 *s*~i--을 얻는 가장 짧은 방법입니다 i+2(의지하지 않습니다 i; 모두 i사용되는 것입니다). 펑키 *s*부분은 길이가 1 인 입력에서 발생 하는 *sis is '\0'인 경우 루프가 실행되지 않도록합니다 .

옥타브, 40 바이트

@(s,t=toeplitz(s),u=t(x=2:end-1,x)=32)t;

온라인으로 사용해보십시오!

내 대답이지만 @Luis MATL 답변 후에 게시되었습니다.

하스켈 , 84 78 바이트

f s@(_:x)|_:y<-r x=s:[a:(y>>" ")++[b]|(a,b)<-zip x y]++[r s];f s=[s]
r=reverse

온라인으로 사용해보십시오! 사용법 : f "test". 줄 목록을 반환합니다.

편집 : dianne 덕분에 -6 바이트!

파이썬 2 , 89 81 88 86 바이트

i=input();n=k=len(i)-2
print i
exec'print i[~k]+" "*n+i[k];k-=1;'*n
if~k:print i[::-1]

온라인으로 사용해보십시오!

R , 113 바이트

function(s){n=length(s<-strsplit(s,'')[[1]])
m=matrix(' ',n,n)
m[n,n:1]=m[,1]=m[1,]=m[n:1,n]=s
write(m,'',n,,'')}

온라인으로 사용해보십시오!

05AB1E , 17 16 15 19 바이트

ÂDÂø¦¨Dgú€Ás)˜»Igi¨

온라인으로 사용해보십시오!

설명

예 input = golf

ÂDÂ                  # bifurcate, duplicate, bifurcate
                     # STACK: 'golf', 'flog', 'flog', 'golf'
   ø                 # zip the top 2 items
                     # STACK: 'golf', 'flog', ['fg', 'lo', 'ol', 'gf']
    ¦¨               # remove the first and last element
                     # STACK: 'golf', 'flog', ['lo', 'ol']
      Dg             # get the length of the list
                     # STACK: 'golf', 'flog', ['lo', 'ol'], 2
        ú            # prepend that many spaces to each element
                     # STACK: 'golf', 'flog', ['  lo', '  ol']
         €Á          # rotate each right
                     # STACK: 'golf', 'flog', ['o  l', 'l  o']
           s         # swap the top 2 items
                     # STACK: 'golf', ['o  l', 'l  o'], 'flog'
            )˜       # wrap in a flattened list
                     # STACK: ['golf', 'o  l', 'l  o', 'flog']
              »      # join on newline
               Igi¨  # if input is length 1, remove last char

1 글자 입력에 대한 수정은 상당히 비쌌습니다.
다른 접근법이 더 나을 것 같습니다.

파이썬 2 , 99 88 바이트

musicman523 덕분에 -4 바이트.

lambda s:s[1:]and[s]+[s[i]+' '*(len(s)-2)+s[~i]for i in range(1,len(s)-1)]+[s[::-1]]or s

온라인으로 사용해보십시오!

문자열 목록을 반환합니다.

수학, 128 바이트

(c=Column;g=Length[x=Characters@#]-1;If[g==0,#,c@{#,c@Table[""<>{x[[i]],""<>Table[" ",g-1],x[[-i]]},{i,2,g}],StringReverse@#}])&

C, 96 바이트

i,l;f(char*s){for(i=l=puts(s)-2;--i;)printf("%c%*c\n",s[l-i],l,s[i]);for(;l+1;)putchar(s[l--]);}

보너스 버전 (122 바이트) :

x,y,i,l;f(char*s){for(i=l=puts(s)-1;++i<l*-~l;putchar(x==l?10:x%~-l*(y%~-l)?32:s[(x*y?l+l-2-x-y:x+y)%l]))x=i%-~l,y=i/-~l;}

스위프트 3 , 215 199 바이트

let s=readLine()!,c=s.characters,r:[Character]=c.reversed(),b=c.count
print(s)
if b>1{for i in 0..<b-2{print("\(r.reversed()[i+1])\(String.init(repeating:" ",count:b-2))\(r[i+1])")};print(String(r))}

온라인으로 사용해보십시오

파이썬 3, 88 바이트

w=input();p=print;l=len(w)-2
[p(w[n+1]+' '*l+w[l-n])for n in range(l)]
l+1and p(w[::-1])

자바 스크립트 (ES8) 108 112 바이트

let f = 

s=>(n=s.length)<2?s:(r=[...s].reverse()).slice(1,-1).reduce((a,v,i)=>a+`
`+s[i+1].padEnd(n-1)+v,s)+`
`+r.join``

o.innerHTML = f("hello folks!")

<pre id="o"></pre>

덜 골핑

s=>
   (n=s.length) < 2 ?    // record and check length
   s :                   // s has 0 or 1 char, else
   (r=[...s].reverse())  // reverse characters,
   .slice(1,-1)          // exclude 1st and last
   .reduce((a,v,i)=>     // append inner lines
      a +'\n' +s[i+1].padEnd(n-1) + v
    ,s)                  // to first line
    + '\n' +r.join("")   // append characters reversed

많은 바이트를 절약 해 준 Justin Mariner에게 감사의 말을 전했습니다. 당신은 그것을 얻는다 :-(

PHP , 118 바이트

echo $s=$argv[1];$l=strlen($r=strrev($s))-1;for($i=$l-1;$l&&$i;)echo "\n".str_pad($r[$i],$l).$s[$i].(--$i?"":"\n$r");

온라인으로 사용해보십시오!

echo $s = $argv[1];
$l = strlen($r = strrev($s)) - 1;

for ($i = $l - 1; $l && $i;)
    echo "\n" . str_pad($r[$i], $l) . $s[$i] . (--$i ? "" : "\n$r");

APL , 58 바이트

{(' ',⍵)[x+(x←∘.{((c-1)=⍺⌈⍵)∨0=⍺⌊⍵}⍨r)×o⌊⌽⊖o←∘.⌈⍨r←⍳c←≢⍵]}

로 ⎕IO←0.

온라인으로 사용해보십시오!

어떻게?

c←≢⍵ -끈의 길이

r←⍳ -범위

o←∘.⌈⍨ -최소 외부 제품

123
223
333

o⌊⌽⊖- 자체 minimalize 180 턴 ^O를

123  ⌊  333  =  123
223  ⌊  322  =  222
333  ⌊  321  =  321

× -곱하기

x←∘....⍨r -범위의 외부 제품

    ((c-1)=⍺⌈⍵)∨0=⍺⌊⍵ -행렬의 프레임

111  ×  123  =  123
101  ×  222  =  202
111  ×  321  =  321

x+ -프레임을 추가

111  +  123  =  234
101  +  202  =  303
111  +  321  =  432

(' ',⍵)[...] -공간에 연결된 문자열에서 색인으로 가져 오기

JavaScript (ES2017), 87 바이트

s=>[...s].reverse(l=s.length-1).map((c,i,z)=>i?l-i?s[i].padEnd(l)+c:z.join``:s).join`
`

ES6 버전 : 93 바이트

s=>[...s].reverse(l=s.length-1).map((c,i,z)=>i?l-i?s[i]+' '.repeat(l-1)+c:z.join``:s).join`
`

덜 골프

s => (
  l = s.length-1,
  [...s].reverse().map( // scan string backwards
     (c, i, z) => 
     i != 0 // check if top row
     ? l-i != 0 // check if bottom row
       ? s[i].padEnd(l) + c // any middle row
       : z.join`` // bottom row: string reversed
     :s // top row: original string
  ).join`\n`
)

F=
s=>[...s].reverse(l=s.length-1).map((c,i,z)=>i?l-i?s[i].padEnd(l)+c:z.join``:s).join`
`

function update() {
  O.textContent = F(I.value)
}

update()

<input id=I value='Hello, world!' oninput='update()'>
<pre id=O></pre>

자바, 191 바이트

(s)->{PrintStream o=System.out;int l=s.lenght();o.println(s);for(int i=0;i<l;i++){o.printf("%"+"s%"+(l-1)+"s%n",s.charAt(i),s.charAt(l-1-i));for(int i=0;i<l;i++){o.print(s.charAt(l-1-i));}}};

C # (. NET 코어) , 179161 바이트

TheLethalCoder 덕분에 -18 바이트

using System.Linq;
s=>{int l=s.Length-1,i=1;var d=s.Reverse().ToArray();while(i<l)s+="\n"+s[i]+new string(' ',l-1)+d[i++];if(l>1)s+="\n"+new string(d);return s;};

온라인으로 사용해보십시오!

바이트 수를 계산 해야하는지 여부에 관계없이 규칙에 대해 잘 모르겠습니다.

using System.Linq;

누군가이 문제를 해결해주세요.

언 골프 드 :

s =>
{
    int l = s.Length - 1, i = 1;
    var d = s.Reverse().ToArray();
    while (i < l)
        s += "\n" + s[i] + new string(' ', l - 1) + d[i++];
    if (l > 1)
        s += "\n" + new string(d);
    return s;
};

망막 , 106 바이트

..+
$&¶$&
O$^`.(?=.*$)

\G.
$&$%'¶
r`.\G
¶$%`$&
+`(.+)¶¶((.*¶)*).(.*)
¶¶$1$4$2
T`p` `(?<=.¶.).*(?=.¶.)
G`.

온라인으로 사용해보십시오! 설명:

..+
$&¶$&

두 개 이상의 문자가 있으면 입력을 복제하십시오.

O$^`.(?=.*$)

복제본을 뒤집습니다.

\G.
$&$%'¶
r`.\G
¶$%`$&

끈을 삼각형으로 바꿉니다. 맨 위 삼각형은 입력으로 시작하여 매번 첫 문자를 제거하고 맨 아래 삼각형은 반전 된 입력의 첫 문자로 시작하여 매번 문자를 추가합니다.

+`(.+)¶¶((.*¶)*).(.*)
¶¶$1$4$2

마지막 문자가 /대각선을 이루도록 삼각형을 겹쳐서 결합하십시오 .

T`p` `(?<=.¶.).*(?=.¶.)

모든면의 끝에서 하나 이상의 문자가 떨어져 있으면 모든 문자를 공백으로 변경하십시오.

G`.

남은 빈 줄을 삭제하십시오.

파이썬 3, 85 바이트

상단 행에 대한 입력 사용 :)

a=input()
b=len(a)
for i in range(b-2):print(a[1+i]+" "*(b-2)+a[-2-i])
print(a[::-1])

루아 , 104 바이트

print(s);for a=2,#s-1 do print(s:sub(a,a)..(" "):rep(#s-2)..s:sub(#s-a+1,#s-a+1)) end;print(s:reverse())

온라인으로 사용해보십시오!

파이썬 3, 106 바이트

기능적인 버전 ...

w=input();p=print;l=len(w)-2
def f(k):p(w[k]+' '*l+w[-k-1]);l-k>0and f(k+1)
l<0 or f(1)or l<1or p(w[::-1])

파이썬 2 , 100 바이트

lambda a:'\n'.join([a]+(len(a)>1)*([a[i]+(len(a)-2)*' '+a[~i]for i in range(1,len(a)-1)]+[a[::-1]]))

온라인으로 사용해보십시오!

매스 매 티카, 138 91 바이트

(b=Outer[" "&,#,#];Do[l={{1,k},{k,1}};b=ReplacePart[b,Join[l,-l]->#[[k]]],{k,Length@#}];b)&

Wolfram Cloud Sandbox에 다음을 붙여넣고 "셀 평가"를 클릭하거나 Shift + Enter 또는 Numpad Enter를 누르면 온라인으로 시도 할 수 있습니다 .

(b=Outer[" "&,#,#];Do[l={{1,k},{k,1}};b=ReplacePart[b,Join[l,-l]->#[[k]]],{k,Length@#}];b)&@{"g","o","l","f","y"}//MatrixForm