Fortsetzung meiner Es war nur ein Bug Challenge:

Eingang:

Eine Zeichenfolge, die aus druckbaren ASCII-Zeichen ohne Leerzeichen oder Zeilenumbrüche besteht.

Ausgabe:

Verwandeln Sie die Eingabe zunächst in ein Palindrom, indem Sie die Eingabe zurücksetzen und vor sich selbst hinzufügen, ohne das mittlere Zeichen (dh bei einer Eingabe 1234567890wird es 0987654321234567890).

Und dann diesen Text ausgeben:

0        9        8        7        6        5        4        3        2        1        2        3        4        5        6        7        8        9        0
         0       9       8       7       6       5       4       3       2       1       2       3       4       5       6       7       8       9       0
                  0      9      8      7      6      5      4      3      2      1      2      3      4      5      6      7      8      9      0
                           0     9     8     7     6     5     4     3     2     1     2     3     4     5     6     7     8     9     0
                                    0    9    8    7    6    5    4    3    2    1    2    3    4    5    6    7    8    9    0
                                             0   9   8   7   6   5   4   3   2   1   2   3   4   5   6   7   8   9   0
                                                      0  9  8  7  6  5  4  3  2  1  2  3  4  5  6  7  8  9  0
                                                               0 9 8 7 6 5 4 3 2 1 2 3 4 5 6 7 8 9 0
                                                                        0987654321234567890
                                                               0 9 8 7 6 5 4 3 2 1 2 3 4 5 6 7 8 9 0
                                                      0  9  8  7  6  5  4  3  2  1  2  3  4  5  6  7  8  9  0
                                             0   9   8   7   6   5   4   3   2   1   2   3   4   5   6   7   8   9   0
                                    0    9    8    7    6    5    4    3    2    1    2    3    4    5    6    7    8    9    0
                           0     9     8     7     6     5     4     3     2     1     2     3     4     5     6     7     8     9     0
                  0      9      8      7      6      5      4      3      2      1      2      3      4      5      6      7      8      9      0
         0       9       8       7       6       5       4       3       2       1       2       3       4       5       6       7       8       9       0
0        9        8        7        6        5        4        3        2        1        2        3        4        5        6        7        8        9        0

(Von der Mitte nach außen in beide Richtungen wird jedes Zeichen durch ein Leerzeichen mehr als in der vorherigen Zeile getrennt.)

Herausforderungsregeln:

• Sie müssen die doppelte Länge der Eingabe minus 3 Zeilen drucken. Bei der Eingabe 1234567890beträgt die oben angezeigte Ausgabe 17 Zeilen (Länge 10 * 2 - 3).
• Die Eingabe enthält nur druckbare ASCII-Zeichen (ohne Leerzeichen, Tabulatorzeichen und Zeilenumbrüche).
• Nachgestellte Leerzeichen sind optional.
• Eine einzelne nachgestellte neue Zeile ist optional.
• (Zusätzliche) führende Leerzeichen oder Zeilenumbrüche sind nicht zulässig.
• Sie können davon ausgehen, dass die Eingabe immer mindestens vier Zeichen lang ist.
• Anders als bei mir war es nur eine Bug- Herausforderung, sowohl die Eingabe- als auch die Ausgabeformate sind flexibel. Sie können das Ergebnis also als String-Array, String-Liste usw. ausgeben.

Allgemeine Regeln:

• Das ist Code-Golf , also gewinnt die kürzeste Antwort in Bytes.
  Lassen Sie sich von Code-Golf-Sprachen nicht davon abhalten, Antworten mit Nicht-Codegolf-Sprachen zu veröffentlichen. Versuchen Sie, für jede Programmiersprache eine möglichst kurze Antwort zu finden.
• Für Ihre Antwort gelten Standardregeln. Daher dürfen Sie STDIN / STDOUT, Funktionen / Methoden mit den richtigen Parametern und vollständige Programme vom Rückgabetyp verwenden. Ihr Anruf.
• Standardlücken sind verboten.
• Fügen Sie nach Möglichkeit einen Link mit einem Test für Ihren Code hinzu.
• Fügen Sie ggf. auch eine Erklärung hinzu.

Testfälle:

Input: 1234567890
Output:
0        9        8        7        6        5        4        3        2        1        2        3        4        5        6        7        8        9        0
         0       9       8       7       6       5       4       3       2       1       2       3       4       5       6       7       8       9       0
                  0      9      8      7      6      5      4      3      2      1      2      3      4      5      6      7      8      9      0
                           0     9     8     7     6     5     4     3     2     1     2     3     4     5     6     7     8     9     0
                                    0    9    8    7    6    5    4    3    2    1    2    3    4    5    6    7    8    9    0
                                             0   9   8   7   6   5   4   3   2   1   2   3   4   5   6   7   8   9   0
                                                      0  9  8  7  6  5  4  3  2  1  2  3  4  5  6  7  8  9  0
                                                               0 9 8 7 6 5 4 3 2 1 2 3 4 5 6 7 8 9 0
                                                                        0987654321234567890
                                                               0 9 8 7 6 5 4 3 2 1 2 3 4 5 6 7 8 9 0
                                                      0  9  8  7  6  5  4  3  2  1  2  3  4  5  6  7  8  9  0
                                             0   9   8   7   6   5   4   3   2   1   2   3   4   5   6   7   8   9   0
                                    0    9    8    7    6    5    4    3    2    1    2    3    4    5    6    7    8    9    0
                           0     9     8     7     6     5     4     3     2     1     2     3     4     5     6     7     8     9     0
                  0      9      8      7      6      5      4      3      2      1      2      3      4      5      6      7      8      9      0
         0       9       8       7       6       5       4       3       2       1       2       3       4       5       6       7       8       9       0
0        9        8        7        6        5        4        3        2        1        2        3        4        5        6        7        8        9        0

Input: ABCD
Output:
D  C  B  A  B  C  D 
   D C B A B C D
      DCBABCD
   D C B A B C D
D  C  B  A  B  C  D

Input: =>)}]
Output:
]   }   )   >   =   >   )   }   ]
    ]  }  )  >  =  >  )  }  ]
        ] } ) > = > ) } ]
            ]})>=>)}]
        ] } ) > = > ) } ]
    ]  }  )  >  =  >  )  }  ]
]   }   )   >   =   >   )   }   ]

Input: XXxxXX
Output:
X    X    x    x    X    X    X    x    x    X    X
     X   X   x   x   X   X   X   x   x   X   X
          X  X  x  x  X  X  X  x  x  X  X
               X X x x X X X x x X X
                    XXxxXXXxxXX
               X X x x X X X x x X X
          X  X  x  x  X  X  X  x  x  X  X
     X   X   x   x   X   X   X   x   x   X   X
X    X    x    x    X    X    X    x    x    X   X

Holzkohle , 14 Bytes

Ｅ⁻Ｌθ¹⪫θ× ι‖Ｏ←↑

Probieren Sie es online!

AST:

Program
├Print
│└Ｅ: Map
│ ├⁻: Difference
│ │├Ｌ: Length
│ ││└θ: Identifier θ
│ │└1: Number 1
│ └⪫: Join
│  ├θ: Identifier θ
│  └×: Product
│   ├' ': String ' '
│   └ι: Identifier ι
└‖Ｏ: Reflect overlap
 └Multidirectional
  ├←: Left
  └↑: Up

Japt , 22 21 Bytes

¬Å£¬qYîÃy w ê y w ê ·

Online testen!

Erläuterung

Die ersten 8 Bytes erzeugen den rechten unteren Quadranten des Musters:

 ¬ Å  £    ¬ qYîÃ
Uq s1 mXY{Uq qYî} 

Uq                 : Split the input into characters.
   s1              : Slice off the first.
      mXY{      }  : Map each item X and index Y to
          Uq       :   the input split into chars,
             q     :   joined with
              Yî   :     Y spaces.

An dieser Stelle haben wir eine Reihe von z ["ABCD", "A B C D", "A B C D"]. Leider dauert es 13 Bytes, um dies zu quadrieren:

y w ê y w ê ·
y w ê y w ê qR
y                : Pad each line to the same length with spaces and transpose.
  w              : Reverse the array, and
    ê            : palindromize. Now we have the bottom half of the output transposed.
      y          : Transpose back.
        w ê      : Reverse and palindromize again, giving the full output.
            qR   : Join with newlines.
                 : Implicit: output result of last expression

05AB1E , 17 Bytes

g<F¹RSðN×ýû})Rû.c

Probieren Sie es online!

-1 dank kalsowerus .

JavaScript (ES6) , 159 136 129 127 Byte

f=(i,x=1-(l=i.length-1),y=x<0?-x:x,[,...b]=i)=>l>x?''.padEnd(l*(l+~y))+[...b.reverse(),...i].join(''.padEnd(y))+`
`+f(i,x+1):''

Probieren Sie es online! Erklärung unten

// This is a recursive function
// First, inputs and various variable initializations
// by using defaults
let func = (
  // Text input, will not be modified through recursion
  input,

  // Current line, for the first function call we start from -lines to +lines
  // It's roughly equivalent to lines*2 but this helps us computing the spacing
  // Also computing the total amount of lines
  currentLine = 1 - (totalLines = input.length - 1),

  // Getting the absolute value of the current line (like Math.floor)
  absCurrentLine = currentLine < 0 ? -currentLine : currentLine,

  // Getting the input without it's first letter, useful for the palidrome of the input
  [,...slicedInput] = input

// Base case, stopping the recursion if the current line
// is still below the total amount of lines
) => totalLines > currentLine

  // Leading spacing
  ? ''.padEnd(totalLines * (totalLines + ~absCurrentLine)) + 

  // Putting together the palindrome version and adding spaces between the chars
    [...slicedInput.reverse(), ...input].join(''.padEnd(absCurrentLine)) + `

  // Line return + recursion call
` + f(input, currentLine + 1)
  : ''

Bei der ersten Teilnahme am Codegolf entschuldige ich mich im Voraus für offensichtliche Fehler.

Vielen Dank an Justin Mariner für das Speichern von 23 Bytes! Vielen Dank an Craig Ayre für das Speichern von 11 Bytes und für den Fehlerbericht.

SOGL V0.12 , 22 18 Bytes

ā,⁄H{,čFH@*∑Κ}▓±╬-

Probieren Sie es hier aus!

Erläuterung:

ā                   push an empty array - canvas
 ,⁄H{        }      input length-1 times do
     ,                push the input
      č               chop it into chars
       FH@*           get the current iteration-1 amount of spaces
           ∑          join the chopped input with the spaces
            Κ         prepend it to the array
              ▓     space to a square
               ±    reverse each string in that list
                ╬-  quad-palindromize with 1 X and 1 Y overlap and without swapping characters

Python 3 , 149 141 95 Bytes

def f(s):l=len(s)-1;[print((' '*abs(i)).join(s[:0:-1]+s).center(2*l*l+1))for i in range(1-l,l)]

Probieren Sie es online!

Vielen Dank an @KevinCruijssen und @ETHproductions für das Speichern einiger Bytes

Besonderer Dank geht an @notjagan für die Einsparung von 46 Bytes!

PHP, 145 131 Bytes

Es bedurfte einiger Überlegungen, um dieses zusätzliche Byte zu spielen. aber das war es wert.

while($y<=2*$e=strlen($a=$argn)-1)echo($p=str_pad)("
",$e*($e-$d=abs($y++-$e))+1),chunk_split($a.substr(strrev($a),1),1,$p("",$d));

druckt eine führende Newline. Laufen Sie als Pipe mit -nRoder probieren Sie es online aus .

Nervenzusammenbruch

while($y<=2*$e=strlen($a=$argn)-1)  # $e=length-1, loop through rows
                                        # 1. print linebreak and left padding
    echo($p=str_pad)("\n",$e*($e-$d=abs($y++-$e))+1),
        chunk_split(
            $a.substr(strrev($a),1)     # 2. palindromize input
            ,1,$p("",$d));              # 3. insert $e..0..$e spaces between characters

Alternativlösung , gleiche Länge:

for($d=-$e=strlen($a=$argn)-1;$d<$e;)echo($p=str_pad)("
",$e*($e-$b=abs($d++))+1),chunk_split($a.substr(strrev($a),1),1,$p("",$b));

APL (Dyalog) , 37 Bytes

Benötigt, ⎕IO←0was auf vielen Systemen Standard ist.

{⍉m(2-d)↓⍉(m←⊖⍪1↓⊢)↑∊¨(1↓⍳d←≢⍵)↑¨¨⊂⍵}

{… } Anonyme Funktion, bei der das Argument durch ⍵ dargestellt wird

 (… )↑¨¨⊂⍵ Für jede ( ¨) der folgenden Zahlen nehmen ( ↑) so viele Zeichen aus jedem ( ¨) des gesamten ( ⊂) Arguments, wie erforderlich mit Leerzeichen aufgefüllt:

  ≢w die Anzahl der Zeichen im Argument

  d← Speichern Sie das in d

  ⍳ so viele Indexe (0… d - 1)

  1↓ fall eins (die null)

 ∊¨ ϵ jeweils nlisten (abflachen)

 ↑ Erhöhen Sie den Rang (konvertieren Sie die Liste der Listen in eine Matrix)

 (m←… ) Wenden die folgende implizite Funktion m an , definiert als:

  ⊖ das verkehrte Argument

  ⍪ auf

  1 eine Reihe]

  ↓ heruntergefallen von

  ⊢ das Argument

 ⍉ transponieren

 (… )↓ Fallen lassen:

  2-d = - ( d - 2), dh d - 2 Zeilen von unten

 mm  anwenden

 ⍉ transponieren

Probieren Sie es online!

Java (OpenJDK 8) , 201 196 Bytes

s->{for(int l=s.length()-1,i=-l,x=0;++i<l;x+=i<0?l:-l)System.out.printf("%1$"+(x<1?"":x)+"s"+s.join("%1$"+(i<0?-i:i>0?i:"")+"s",(new StringBuffer(s.substring(1)).reverse()+s).split(""))+"%n","");}

Probieren Sie es online!

Es ist die gleiche Idee wie bei der vorherigen Herausforderung , nur dass der Generatorstring jetzt ein bisschen länger und schwieriger zu handhaben ist.

%1$Ns0%1$Ns9%1$Ns8%1$Ns7%1$Ns6%1$Ns5%1$Ns4%1$Ns3%1$Ns2%1$Ns1%1$Ns2%1$Ns3%1$Ns4%1$Ns5%1$Ns6%1$Ns7%1$Ns8%1$Ns9%1$Ns0%n

Python 3 , 134 124 Bytes

f=lambda s:'\n'.join([' '*(len(s)-1)*abs(len(s)-abs(i)-2)+(' '*abs(i)).join(s[::-1]+s[1:]) for i in range(2-len(s),len(s)-1)])

Probieren Sie es online!

Erster Beitrag zu PPCG nach einer Weile lauern. Suche nach Anregungen / Ratschlägen!

Vielen Dank an @LyricLy und @ Łukasz Rogalski für die Verbesserungen!

Haskell, 177 163 Bytes

import Data.List
k n=[1..n]>>" "
f s=let n=length s in map(\x->(k(((n-1)*(n-(abs x)))))++(intercalate (k(abs x))$map(\z->[z])$((++)=<<reverse.tail) s))[n,n-1.. -n]

Die Funktion fist die Challenge-Funktion und gibt eine Liste von Strings ( [String]) mit zurückunlines die gleiche visuelle Ausgabe liefern sollte wie die Testfälle (main = putStr $ unlines $ f "test string" um sie zu kompilieren).

Probieren Sie es online!

-14 Bytes dank @nimi

Mathematica, 141 Bytes

Column[Join[Reverse@(s=Row/@Table[Riffle[Reverse@Rest@b~Join~b,""<>Table[" ",i]],{i,0,Length[b=Characters@#]-1}]),Rest@s],Alignment->Center]&