Le défi

Votre tâche consiste à créer un programme qui prend une entrée de chaîne donnée et la sort au format carré. Les chaînes vides doivent renvoyer une chaîne vide.

Exemples

Compte tenu de l'entrée:

golf

Votre programme devrait générer:

golf
o  l
l  o
flog

Contribution:

123

Sortie:

123
2 2
321

Contribution:

a

Sortie:

a

Contribution:

Hello, world!

Sortie (remarquez l’espace entre, et w - l’écart n’est pas simplement une nouvelle ligne):

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

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

Notation

C'est du code-golf , donc la réponse la plus courte dans chaque langue est gagnante.

Charbon de bois , 7 à 5 octets

θ‖Ｏ↙↘

Essayez-le en ligne! Le lien est vers la version verbeuse du code. Edit: 2 octets enregistrés grâce à @CarlosAlejo. Explication:

θ       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

(Plusieurs directions de la commande Reflect s'exécutent consécutivement plutôt que simultanément.)

MATL , 20 16 11 octets

otYTO6Lt&(c

Essayez-le sur MATL en ligne!

EDIT: le code fonctionne dans la version 20.2.1, antérieure au challenge. Le lien utilise cette version. (Dans 20.2.2, le code serait plus court, mais il retarde le défi).

Explication

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

Jelly ,  29 22  17 bytes

Charbon de bois sera trounce + d ce score ...

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

Un lien monadique prenant et renvoyant une liste de caractères; ou un programme complet imprimant le résultat.

Essayez-le en ligne!

Comment?

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 octets

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

Essayez-le en ligne!

Trucs remarquables:

• Au lieu de gaspiller des octets strlen, nous saisissons simplement la longueur de la chaîne tout en imprimant simultanément la première ligne:

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

  Cela fonctionne car printfrenvoie le nombre d'octets écrits.

• Pour les lignes du milieu, nous devons boucler la chaîne mais exclure le premier et le dernier caractère. Ceci est réalisé avec la condition

  1[++s]

  (qui est plus court que (++s)[1]), qui saute le premier caractère car il ++est dans la condition et saute le dernier en s'arrêtant lorsque le caractère passé le caractère actuel est '\0'(plutôt que de s'arrêter à '\0' ).

• Dans le corps de la première boucle,

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

  nous imprimons le caractère actuel, puis le caractère "en miroir" approprié (garder la trace de j, ce qui entre dans les négatifs, ce qui crée une situation étrange d’indexation dans une chaîne avec un nombre négatif), complétée par une longueur iavec des espaces (où iest commodément strlen(s) - 1).

• L'impression inversée sur la dernière ligne est assez simple. le seul truc est le *s*~i--, qui est le moyen le plus court pour obtenir des i+2itérations du corps de la boucle (qui ne dépend pas de i, tout iest utilisé pour compter). La *s*partie funky veille à ce que la boucle ne s'exécute pas si *sest '\0', ce qui se produit lors d'une entrée de longueur 1.

Octave, 40 octets

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

Essayez-le en ligne!

C’est ma réponse mais postée après la réponse de @Luis MATL

Haskell , 84 78 octets

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

Essayez-le en ligne! Utilisation: f "test". Retourne une liste de lignes.

Edit: -6 octets grâce à dianne!

Python 2 , 89 81 88 86 octets

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

Essayez-le en ligne!

R , 113 octets

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

Essayez-le en ligne!

05AB1E , 17 16 15 19 octets

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

Essayez-le en ligne!

Explication

Exemple avec 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

Le correctif pour la saisie d'une lettre était assez coûteux.
Je me sens comme une approche différente pourrait être mieux maintenant.

Python 2 , 99 88 octets

-4 octets grâce à 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

Essayez-le en ligne!

Retourne une liste de chaînes.

Mathematica, 128 octets

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

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

Version bonus (122 octets):

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

Rapide 3 , 215 199 octets

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

Essayez-le en ligne

Python 3, 88 octets

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 octets

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>

Moins golphé

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

Merci à Justin Mariner d’avoir économisé de nombreux octets, qui ont tous été utilisés en ajoutant la vérification du caractère zéro ou un caractère nécessaire pour relever le défi. Tu comprends :-(

PHP , 118 octets

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

Essayez-le en ligne!

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 octets

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

Avec ⎕IO←0.

Essayez-le en ligne!

Comment?

c←≢⍵ - longueur de la ficelle

r←⍳ - intervalle

o←∘.⌈⍨ - produit extérieur avec minimum

123
223
333

o⌊⌽⊖- minimiser avec lui-même tourné à 180 ^o

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

× - multiplier avec

x←∘....⍨r - produit extérieur de la gamme avec

    ((c-1)=⍺⌈⍵)∨0=⍺⌊⍵ - le cadre de la matrice

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

x+ - ajouter le cadre

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

(' ',⍵)[...] - récupère l'index de la chaîne concaténée à l'espace

JavaScript (ES2017), 87 octets

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

Version ES6: 93 octets

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

Moins joué au 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 octets

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

-18 octets grâce à 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;};

Essayez-le en ligne!

Je ne suis pas sûr des règles, si cela est nécessaire pour compter les octets ou non:

using System.Linq;

Quelqu'un s'il vous plaît corrigez-moi à ce sujet.

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 octets

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

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

Essayez-le en ligne! Explication:

..+
$&¶$&

S'il y a au moins deux caractères, dupliquez l'entrée.

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

Inverser le doublon.

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

Turn the strings into triangles. The top triangle starts with the input and removes the first character each time, while the bottom triangle starts with the first letter of the reversed input and adds a character each time.

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

Join the triangles together, overlapping so that the last character forms the / diagonal.

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

Change all the characters to spaces, if they are at least one character away from the end on every side.

G`.

Delete any left-over blank lines.

Python 3, 85 bytes

Using the input for the top row :)

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