O desafio

Sua tarefa é criar um programa que aceite qualquer entrada de sequência de caracteres e produza a entrada em um formato quadrado. Cadeias vazias devem retornar uma cadeia vazia.

Exemplos

Dada a entrada:

golf

Seu programa deve gerar:

golf
o  l
l  o
flog

Entrada:

123

Saída:

123
2 2
321

Entrada:

a

Saída:

a

Entrada:

Hello, world!

Saída (observe o espaço entre, ew - a diferença não é apenas uma nova linha):

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

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

Pontuação

Isso é código-golfe , então a resposta mais curta em cada idioma vence.

Carvão , 7 5 bytes

θ‖Ｏ↙↘

Experimente online! Link é a versão detalhada do código. Editar: salvou 2 bytes graças a @CarlosAlejo. Explicação:

θ       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

(Várias direções para o comando Reflect são executadas consecutivamente e não simultaneamente.)

MATL , 20 16 11 bytes

otYTO6Lt&(c

Experimente no MATL online!

EDIT: O código funciona na versão 20.2.1, que antecede o desafio. O link usa essa versão. (No 20.2.2, o código seria mais curto, mas pós-datado o desafio).

Explicação

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

Geléia ,  29 22  17 bytes

Carvão irá marcar + d esta pontuação ...

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

Um link monádico recebendo e retornando uma lista de caracteres; ou um programa completo imprimindo o resultado.

Experimente online!

Quão?

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 bytes

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--);}

Experimente online!

Truques dignos de nota:

• Em vez de desperdiçar bytes strlen, simplesmente pegamos o comprimento da string enquanto imprimimos simultaneamente a primeira linha:

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

  Isso funciona porque printfretorna o número de bytes gravados.

• Para as linhas do meio, precisamos fazer um loop sobre a string, mas excluir o primeiro e o último caractere. Isso é alcançado com a condição

  1[++s]

  (que é mais curto que (++s)[1]), que pula o primeiro caractere devido à ++condição dele e pula o último, parando quando o personagem que está além do caractere atual está '\0'(em vez de parar em '\0' ).

• No corpo do primeiro loop,

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

  imprimimos o caractere atual e, em seguida, o caractere "espelhado" apropriado (acompanhando j, que entra nos negativos, resultando na situação ímpar de indexar em uma string com um número negativo) preenchido com um comprimento de iespaços (onde iestá convenientemente strlen(s) - 1).

• A impressão invertida na última linha é bastante direta; o único truque é o *s*~i--, que é a maneira mais curta de obter i+2iterações do corpo do loop (que não depende i; tudo o que ié usado é contar). O funk *s*parte garante que o laço não é executado se *sé '\0', que acontece no comprimento-1 de entrada.

Oitava, 40 bytes

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

Experimente online!

É a minha resposta, mas postada após a resposta @Luis MATL

Haskell , 84 78 bytes

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

Experimente online! Uso: f "test". Retorna uma lista de linhas.

Edit: -6 bytes graças a dianne!

Python 2 , 89 81 88 86 bytes

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

Experimente online!

R , 113 bytes

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,,'')}

Experimente online!

05AB1E , 17 16 15 19 bytes

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

Experimente online!

Explicação

Exemplo com 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

A correção para entrada de uma letra era bastante cara.
Sinto que uma abordagem diferente pode ser melhor agora.

Python 2 , 99 88 bytes

-4 bytes graças ao musicman523.

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

Experimente online!

Retorna uma lista de strings.

Mathematica, 128 bytes

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

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--]);}

Versão bônus (122 bytes):

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;}

Swift 3 , 215 199 bytes

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))}

Experimente online

Python 3, 88 bytes

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])

JavaScript (ES8), 108 112 bytes

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>

Menos golphed

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

Agradecemos a Justin Mariner por economizar muitos bytes, que se acostumaram a adicionar a verificação de zero ou único caractere necessária para cumprir o desafio. Você entende que :-(

PHP , 118 bytes

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");

Experimente online!

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 bytes

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

Com ⎕IO←0.

Experimente online!

Quão?

c←≢⍵ - comprimento da corda

r←⍳ - alcance

o←∘.⌈⍨ - produto exterior com um mínimo

123
223
333

o⌊⌽⊖- minimizar com ele próprio girado 180 ^o

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

× - multiplique com

x←∘....⍨r - produto externo da gama com

    ((c-1)=⍺⌈⍵)∨0=⍺⌊⍵ - o quadro da matriz

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

x+ - adicione o quadro

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

(' ',⍵)[...] - obtém pelo índice da string concatenada para o espaço

JavaScript (ES2017), 87 bytes

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

Versão ES6: 93 bytes

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

Menos golfe

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>

Java, 191 bytes

(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 Core) , 179 161 bytes

-18 bytes graças a TheLethalCoder

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;};

Experimente online!

Não tenho certeza sobre as regras, se isso for necessário para contagem de bytes ou não:

using System.Linq;

Alguém por favor me corrija sobre isso.

Ungolfed:

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;
};

Retina , 106 bytes

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

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

Experimente online! Explicação:

..+
$&¶$&

Se houver pelo menos dois caracteres, duplique a entrada.

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

Inverta a duplicata.

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

Transforme as cordas em triângulos. O triângulo superior começa com a entrada e remove o primeiro caractere de cada vez, enquanto o triângulo inferior começa com a primeira letra da entrada invertida e adiciona um caractere a cada vez.

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

Junte os triângulos, sobrepostos, para que o último caractere forme a /diagonal.

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

Mude todos os caracteres para espaços, se eles estiverem a pelo menos um caractere do final de cada lado.

G`.

Exclua as linhas em branco restantes.

Python 3, 85 bytes

Usando a entrada para a linha superior :)

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

Lua , 104 bytes

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())

Experimente online!

Python 3, 106 bytes

Uma versão funcional ...

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])

Python 2 , 100 bytes

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]]))

Experimente online!

Mathematica, 138 91 bytes

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

Você pode experimentá-lo online colando o seguinte na Wolfram Cloud Sandbox e clicando em "avaliar célula" ou pressionando Shift + Enter ou 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