El reto

Su tarea es crear un programa que tome cualquier entrada de cadena dada y la envíe en formato cuadrado. Las cadenas vacías deberían devolver una cadena vacía.

Ejemplos

Dada la entrada:

golf

Su programa debería generar:

golf
o  l
l  o
flog

Entrada:

123

Salida:

123
2 2
321

Entrada:

a

Salida:

a

Entrada:

Hello, world!

Salida (observe el espacio entre, y w - la brecha no es solo una nueva línea):

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

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

Tanteo

Este es el código de golf , por lo que gana la respuesta más corta en cada idioma.

Carbón , 7 5 bytes

θ‖Ｏ↙↘

Pruébalo en línea! El enlace es a la versión detallada del código. Editar: Guardado 2 bytes gracias a @CarlosAlejo. Explicación:

θ       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

(Múltiples direcciones al comando Reflect se ejecutan consecutivamente en lugar de simultáneamente).

MATL , 20 16 11 bytes

otYTO6Lt&(c

Pruébalo en MATL en línea!

EDITAR: el código funciona en la versión 20.2.1, que es anterior al desafío. El enlace usa esa versión. (En 20.2.2 el código sería más corto, pero es posterior al desafío).

Explicación

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

Jalea ,  29 22  17 bytes

Carbón de leña será derrotar a + d esta partitura ...

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

Un enlace monádico que toma y devuelve una lista de personajes; o un programa completo imprimiendo el resultado.

Pruébalo en línea!

¿Cómo?

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

Pruébalo en línea!

Trucos notables:

• En lugar de perder bytes strlen, simplemente tomamos la longitud de la cadena mientras imprimimos simultáneamente la primera línea:

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

  Esto funciona porque printfdevuelve el número de bytes escritos.

• Para las líneas intermedias, necesitamos recorrer la cadena pero excluir tanto el primer como el último carácter. Esto se logra con la condición

  1[++s]

  (que es más corto que (++s)[1]), que omite el primer carácter debido a que ++está en la condición y omite el último deteniéndose cuando el personaje pasa el carácter actual '\0'(en lugar de detenerse en '\0' ).

• En el cuerpo del primer bucle,

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

  imprimimos el carácter actual, luego el carácter "reflejado" apropiado (haciendo un seguimiento j, que entra en los negativos, lo que resulta en una situación extraña de indexación en una cadena con un número negativo) acolchado a una longitud de iespacios (donde iestá convenientemente strlen(s) - 1).

• La impresión invertida en la última línea es bastante sencilla; El único truco es el *s*~i--, que es la forma más corta de obtener i+2iteraciones del cuerpo del bucle (que no depende de i; todo lo que ise utiliza es contar). La *s*parte funky se asegura de que el ciclo no se ejecute si *ses así '\0', lo que sucede en la entrada de longitud 1.

Octava, 40 bytes

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

Pruébalo en línea!

Es mi respuesta, pero publicado después de @Luis MATL answer

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

Pruébalo en línea! Uso: f "test". Devuelve una lista de líneas.

Editar: -6 bytes gracias 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]

Pruébalo en línea!

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

Pruébalo en línea!

05AB1E , 17 16 15 19 bytes

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

Pruébalo en línea!

Explicación

Ejemplo con 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

La solución para la entrada de 1 letra era bastante costosa.
Siento que un enfoque diferente podría ser mejor ahora.

Python 2 , 99 88 bytes

-4 bytes gracias a 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

Pruébalo en línea!

Devuelve una lista de cadenas.

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

Versión de bonificación (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))}

Pruébalo en línea

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 golfo

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

Gracias a Justin Mariner por guardar muchos bytes, que luego se agotaron agregando la comprobación de caracteres cero o individual necesaria para cumplir con el desafío. Tu consigues eso :-(

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

Pruébalo en línea!

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←≢⍵]}

Con ⎕IO←0 .

Pruébalo en línea!

¿Cómo?

c←≢⍵ - longitud de la cuerda

r←⍳ - distancia

o←∘.⌈⍨ - producto exterior con mínimo

123
223
333

o⌊⌽⊖- minimizar con sí mismo cumplió 180 ^o

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

× - multiplicar con

x←∘....⍨r - producto exterior de la gama con

    ((c-1)=⍺⌈⍵)∨0=⍺⌊⍵ - el marco de la matriz

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

x+ - agregar el marco

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

(' ',⍵)[...] - obtener por índice de la cadena concatenada al espacio

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`
`

Versión 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 golf

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) , 179161 bytes

-18 bytes gracias 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;};

Pruébalo en línea!

No estoy seguro de las reglas, si esto es necesario para contar los bytes o no:

using System.Linq;

Alguien por favor corrígeme sobre esto.

Sin golf:

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`.

Pruébalo en línea! Explicación:

..+
$&¶$&

Si hay al menos dos caracteres, duplique la entrada.

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

Invierta el duplicado.

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

Convierte las cuerdas en triángulos. El triángulo superior comienza con la entrada y elimina el primer carácter cada vez, mientras que el triángulo inferior comienza con la primera letra de la entrada invertida y agrega un carácter cada vez.

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

Une los triángulos juntos, superpuestos para que el último personaje forme la /diagonal.

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

Cambia todos los personajes a espacios, si están al menos a un personaje del final en cada lado.

G`.

Elimine las líneas en blanco sobrantes.

Python 3, 85 bytes

Usando la entrada para la fila 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())

Pruébalo en línea!

Python 3, 106 bytes

Una versión 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]]))

Pruébalo en línea!

Mathematica, 138 91 bytes

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

Puede probarlo en línea pegando lo siguiente en Wolfram Cloud Sandbox y haciendo clic en "evaluar celda" o presionando Shift + Enter o 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