Die Herausforderung

Ihre Aufgabe ist es, ein Programm zu erstellen, das beliebige Zeichenfolgeneingaben akzeptiert und diese in einem quadratischen Format ausgibt. Leere Zeichenfolgen sollten eine leere Zeichenfolge zurückgeben.

Beispiele

Angesichts der Eingabe:

golf

Ihr Programm sollte folgendes ausgeben:

golf
o  l
l  o
flog

Eingang:

123

Ausgabe:

123
2 2
321

Eingang:

a

Ausgabe:

a

Eingang:

Hello, world!

Ausgabe (beachten Sie den Abstand zwischen, und w - die Lücke ist nicht nur ein Zeilenumbruch):

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

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

Wertung

Das ist Code-Golf , also gewinnt die kürzeste Antwort in jeder Sprache.

Kohle , 7 5 Bytes

θ‖Ｏ↙↘

Probieren Sie es online! Link ist eine ausführliche Version des Codes. Bearbeiten: 2 Bytes dank @CarlosAlejo gespeichert. Erläuterung:

θ       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

(Mehrere Richtungen zum Reflect-Befehl werden nicht gleichzeitig, sondern nacheinander ausgeführt.)

MATL , 20 16 11 Bytes

otYTO6Lt&(c

Probieren Sie es bei MATL online!

BEARBEITEN: Der Code funktioniert in Version 20.2.1, die der Herausforderung vorausgeht. Der Link verwendet diese Version. (In 20.2.2 wäre der Code kürzer, aber er datiert die Herausforderung nach).

Erläuterung

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

Holzkohle wird + d diese Punktzahl abprallen ...

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

Ein monadischer Link, der eine Liste von Zeichen aufnimmt und zurückgibt. oder ein vollständiges Programm, das das Ergebnis druckt.

Probieren Sie es online!

Wie?

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

Probieren Sie es online!

Bemerkenswerte Tricks:

• Anstatt Bytes zu verschwenden strlen, nehmen wir einfach die Länge des Strings und drucken gleichzeitig die erste Zeile:

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

  Dies funktioniert, weil printfdie Anzahl der geschriebenen Bytes zurückgegeben wird.

• Für die mittleren Zeilen müssen wir die Zeichenfolge durchlaufen, aber sowohl das erste als auch das letzte Zeichen ausschließen. Dies wird mit der Bedingung erreicht

  1[++s]

  (was kürzer ist als (++s)[1]), wodurch das erste Zeichen übersprungen wird, weil ++es sich in der Bedingung befindet, und das letzte Zeichen übersprungen wird, indem angehalten wird, wenn das Zeichen hinter dem aktuellen Zeichen liegt '\0'(anstatt angehalten zu werden '\0' ).

• Im Körper der ersten Schleife,

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

  Wir drucken das aktuelle Zeichen und dann das entsprechende "gespiegelte" Zeichen (verfolgen j, was in die Negative geht, was zu der merkwürdigen Situation des Indizierens in eine Zeichenkette mit einer negativen Zahl führt), das auf eine Länge imit Leerzeichen aufgefüllt ist (wo iist das ?) bequem strlen(s) - 1).

• Der umgekehrte Ausdruck in der letzten Zeile ist ziemlich einfach. Der einzige Trick ist der *s*~i--, der der kürzeste Weg ist, um i+2Iterationen des Schleifenkörpers zu erhalten (was nicht davon abhängt i; alles, wofür iverwendet wird, ist zu zählen). Der funky- *s*Teil stellt sicher, dass die Schleife nicht ausgeführt *swird '\0', wenn dies der Fall ist , was bei Eingabe von Länge 1 der Fall ist .

Oktave, 40 Bytes

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

Probieren Sie es online!

Es ist meine Antwort, aber gepostet nach @ Luis MATL Antwort

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

Probieren Sie es online! Verbrauch: f "test". Gibt eine Liste von Zeilen zurück.

Edit: -6 Bytes dank 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]

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

Probieren Sie es online!

05AB1E , 17 16 15 19 Bytes

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

Probieren Sie es online!

Erläuterung

Beispiel mit 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

Der Fix für 1-Buchstaben-Eingabe war ziemlich teuer.
Ich denke, ein anderer Ansatz könnte jetzt besser sein.

Python 2 , 99 88 Bytes

-4 Bytes dank 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

Probieren Sie es online!

Gibt eine Liste von Zeichenfolgen zurück.

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

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

Probieren Sie es online aus

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>

Weniger 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

Vielen Dank an Justin Mariner für das Speichern vieler Bytes, die dann alle aufgebraucht waren und die Null- oder Einzelzeichenprüfung hinzugefügt haben, die zur Erfüllung der Herausforderung erforderlich war. Du bekommst das :-(

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

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

Mit ⎕IO←0.

Probieren Sie es online!

Wie?

c←≢⍵ - Länge der Zeichenfolge

r←⍳ - Reichweite

o←∘.⌈⍨ - äußeres Produkt mit Minimum

123
223
333

o⌊⌽⊖- Mit sich selbst um 180 ^{o minimieren}

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

× - multiplizieren mit

x←∘....⍨r - Außenprodukt des Sortiments mit

    ((c-1)=⍺⌈⍵)∨0=⍺⌊⍵ - der Rahmen der Matrix

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

x+ - füge den Rahmen hinzu

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

(' ',⍵)[...] - Holen Sie sich durch Index von der Zeichenfolge zu Leerzeichen verkettet

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

ES6-Version: 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`
`

Weniger golfen

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

Probieren Sie es online!

Ich bin mir nicht sicher über die Regeln, ob dies benötigt wird, um Bytes zu zählen oder nicht:

using System.Linq;

Bitte korrigiert mich jemand.

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

Netzhaut , 106 Bytes

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

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

Probieren Sie es online! Erläuterung:

..+
$&¶$&

Wenn mindestens zwei Zeichen vorhanden sind, duplizieren Sie die Eingabe.

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

Kehre das Duplikat um.

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

Drehen Sie die Saiten in Dreiecke. Das obere Dreieck beginnt mit der Eingabe und entfernt jedes Mal das erste Zeichen, während das untere Dreieck mit dem ersten Buchstaben der umgekehrten Eingabe beginnt und jedes Mal ein Zeichen hinzufügt.

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

Verbinden Sie die Dreiecke so, dass das letzte Zeichen die /Diagonale bildet .

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

Ändern Sie alle Zeichen in Leerzeichen, wenn sie auf jeder Seite mindestens ein Zeichen vom Ende entfernt sind.

G`.

Löschen Sie alle verbleibenden Leerzeilen.

Python 3, 85 Bytes

Verwendung der Eingabe für die obere Reihe :)

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

Probieren Sie es online!

Python 3, 106 Bytes

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

Probieren Sie es online!

Mathematica, 138 91 Bytes

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

Sie können es online ausprobieren, indem Sie Folgendes in die Wolfram Cloud Sandbox einfügen und auf "Zelle auswerten" klicken oder Umschalt + Eingabetaste oder Ziffernblock-Eingabetaste drücken:

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