La sfida

Il tuo compito è quello di creare un programma che prenda un dato input di stringa e generi l'input in un formato quadrato. Le stringhe vuote dovrebbero restituire una stringa vuota.

Esempi

Dato l'input:

golf

Il tuo programma dovrebbe produrre:

golf
o  l
l  o
flog

Ingresso:

123

Produzione:

123
2 2
321

Ingresso:

a

Produzione:

a

Ingresso:

Hello, world!

Output (notare lo spazio tra, ew - il divario non è solo una nuova riga):

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

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

punteggio

Questo è code-golf , quindi vince la risposta più breve in ogni lingua.

Carbone , 7 5 byte

θ‖Ｏ↙↘

Provalo online! Il collegamento è alla versione dettagliata del codice. Modifica: salvato 2 byte grazie a @CarlosAlejo. Spiegazione:

θ       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

(Le direzioni multiple per il comando Reflect vengono eseguite consecutivamente anziché simultaneamente.)

MATL , 20 16 11 byte

otYTO6Lt&(c

Provalo su MATL online!

EDIT: il codice funziona nella versione 20.2.1, che precede la sfida. Il collegamento utilizza quella versione. (In 20.2.2 il codice sarebbe più breve, ma postdaterà la sfida).

Spiegazione

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

Gelatina ,  29 22  17 byte

Carbone sarà trounce + d questo punteggio ...

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

Un collegamento monadico che prende e restituisce un elenco di personaggi; o un programma completo che stampa il risultato.

Provalo online!

Come?

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 byte

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

Provalo online!

Trucchi degni di nota:

• Invece di sprecare byte strlen, prendiamo semplicemente la lunghezza della stringa mentre stampiamo contemporaneamente la prima riga:

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

  Questo funziona perché printfrestituisce il numero di byte scritti.

• Per le linee di mezzo, dobbiamo passare sopra la stringa ma escludiamo sia il primo che l'ultimo carattere. Questo si ottiene con la condizione

  1[++s]

  (che è più breve di (++s)[1]), che salta il primo personaggio a causa ++della condizione nella condizione e salta l'ultimo fermandosi quando il personaggio oltre il personaggio attuale è '\0'(piuttosto che fermarsi a '\0' ).

• Nel corpo del primo ciclo,

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

  stampiamo il carattere corrente, quindi il carattere "speculare" appropriato (tenendo traccia di j, che va in negativo, risultando nella strana situazione dell'indicizzazione in una stringa con un numero negativo) riempito con una lunghezza di ispazi (dove iè convenientemente strlen(s) - 1).

• La stampa invertita sull'ultima riga è piuttosto semplice; l'unico trucco è il *s*~i--, che è il modo più breve per ottenere i+2iterazioni del corpo del loop (che non dipende da i; tutto ciò che iserve è contare). La *s*parte funky si assicura che il loop non funzioni se lo *sè '\0', cosa che accade sull'input di lunghezza 1.

Ottava, 40 byte

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

Provalo online!

È la mia risposta ma postata dopo la risposta @Luis MATL

Haskell , 84 78 byte

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

Provalo online! Uso:f "test" . Restituisce un elenco di righe.

Modifica: -6 byte grazie a dianne!

Python 2 , 89 81 88 86 byte

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

Provalo online!

R , 113 byte

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

Provalo online!

05AB1E , 17 16 15 19 byte

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

Provalo online!

Spiegazione

Esempio 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 correzione per l'inserimento di una lettera era piuttosto costosa.
Sento che un approccio diverso potrebbe essere migliore ora.

Python 2 , 99 88 byte

-4 byte grazie 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

Provalo online!

Restituisce un elenco di stringhe.

Mathematica, 128 byte

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

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

Versione bonus (122 byte):

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 byte

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

Provalo online

Python 3, 88 byte

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 byte

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>

Meno goloso

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

Grazie a Justin Mariner per aver salvato un sacco di byte, che poi sono stati tutti esauriti aggiungendo lo zero o il controllo del singolo carattere necessario per soddisfare la sfida. Lo ottieni :-(

PHP , 118 byte

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

Provalo 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 byte

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

Con ⎕IO←0 .

Provalo online!

Come?

c←≢⍵ - lunghezza della stringa

r←⍳ - gamma

o←∘.⌈⍨ - prodotto esterno con il minimo

123
223
333

o⌊⌽⊖- minimizzare con se stesso ruotato di 180 ^o

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

× - moltiplicare con

x←∘....⍨r - prodotto esterno della gamma con

    ((c-1)=⍺⌈⍵)∨0=⍺⌊⍵ - la cornice della matrice

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

x+ - aggiungi la cornice

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

(' ',⍵)[...] - ottiene per indice dalla stringa concatenata allo spazio

JavaScript (ES2017), 87 byte

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

Versione ES6: 93 byte

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

Meno 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 byte

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

-18 byte grazie 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;};

Provalo online!

Non sono sicuro delle regole, se questo è necessario per contare i byte o meno:

using System.Linq;

Qualcuno, per favore, mi corregga al riguardo.

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 byte

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

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

Provalo online! Spiegazione:

..+
$&¶$&

Se sono presenti almeno due caratteri, duplicare l'input.

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

Invertire il duplicato.

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

Trasforma le stringhe in triangoli. Il triangolo superiore inizia con l'input e rimuove ogni volta il primo carattere, mentre il triangolo inferiore inizia con la prima lettera dell'input invertito e aggiunge un carattere ogni volta.

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

Unisci i triangoli insieme, sovrapponendoli in modo che l'ultimo carattere formi la /diagonale.

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

Cambia tutti i personaggi in spazi, se sono almeno un personaggio lontano dalla fine su ogni lato.

G`.

Elimina tutte le righe vuote rimaste.

Python 3, 85 byte

Utilizzo dell'input per la riga superiore :)

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

Try it online!

Python 3, 106 bytes

A functional version...

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

Try it online!

Mathematica, 138 91 bytes

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

You can try it online with by pasting the following at the Wolfram Cloud Sandbox and clicking "evaluate cell" or hitting Shift+Enter or 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