Poursuivre mon C'était juste un défi de bug :

Contribution:

Une chaîne composée de caractères ASCII imprimables sans espaces blancs ni nouvelles lignes.

Production:

Transformez d'abord l'entrée en un palindrome en inversant l'entrée et en l'ajoutant avant elle-même, en excluant le caractère du milieu (c'est-à-dire avec une entrée 1234567890, elle deviendra 0987654321234567890).

Et puis affichez ce texte:

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

(Du milieu vers l'extérieur dans les deux directions, chaque caractère est séparé par un espace de plus que la ligne précédente.)

Règles du défi:

• Vous devez imprimer deux fois la longueur de l'entrée, moins 3 lignes. Ainsi, avec l'entrée 1234567890, la sortie affichée ci-dessus est de 17 lignes (longueur 10 * 2 - 3).
• L'entrée ne contiendra que de l'ASCII imprimable (hors espace, tabulation et nouvelle ligne).
• Les espaces de fin sont facultatifs.
• Une seule nouvelle ligne de fin est facultative.
• Les espaces de début (supplémentaires) ou les nouvelles lignes de début ne sont pas autorisés.
• Vous pouvez supposer que l'entrée comportera toujours au moins quatre caractères.
• Contrairement à mon C'était juste un défi de bogue , les formats d'entrée et de sortie sont flexibles. Vous êtes donc autorisé à générer le résultat sous forme de tableau de chaînes, de liste de chaînes, etc.

Règles générales:

• C'est le code-golf , donc la réponse la plus courte en octets l'emporte.
  Ne laissez pas les langues de golf de code vous décourager de publier des réponses avec des langues autres que le golf de code. Essayez de trouver une réponse aussi courte que possible pour «n'importe quel» langage de programmation.
• Des règles standard s'appliquent à votre réponse, vous êtes donc autorisé à utiliser STDIN / STDOUT, fonctions / méthode avec les paramètres appropriés et des programmes complets de type retour. Ton appel.
• Les failles par défaut sont interdites.
• Si possible, veuillez ajouter un lien avec un test pour votre code.
• Veuillez également ajouter une explication si nécessaire.

Cas de test:

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

Fusain , 14 octets

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

Essayez-le en ligne!

AST:

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

Japt , 22 21 octets

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

Testez-le en ligne!

Explication

Les 8 premiers octets génèrent le quadrant inférieur droit du motif:

 ¬ Å  £    ¬ 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.

À ce stade, nous avons un tableau d'ex ["ABCD", "A B C D", "A B C D"]. Malheureusement, il faut 13 octets pour mettre cela au carré:

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 octets

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

Essayez-le en ligne!

-1 grâce à kalsowerus .

JavaScript (ES6) , 159 136 129 127 octets

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):''

Essayez-le en ligne!Explication ci-dessous

// 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)
  : ''

Première entrée sur codegolf, je m'excuse à l'avance pour toute erreur évidente.

Merci à Justin Mariner pour avoir économisé 23 octets! Merci à Craig Ayre pour avoir économisé 11 octets et pour le rapport de bogue.

SOGL V0.12 , 22 18 octets

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

Essayez-le ici!

Explication:

ā                   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 95 octets

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

Essayez-le en ligne!

Merci à @KevinCruijssen et @ETHproductions pour avoir économisé quelques octets

Un merci spécial à @notjagan pour avoir économisé 46 octets!

PHP, 145 131 octets

Il a fallu un peu de réflexion pour jouer au golf cet octet supplémentaire; mais ça en valait la peine.

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

imprime une nouvelle ligne de premier plan. Exécuter en tant que pipe avec -nRou l' essayer en ligne .

panne

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

solution alternative , même longueur:

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 octets

Requiert ⎕IO←0ce qui est par défaut sur de nombreux systèmes.

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

{… } Fonction anonyme où l'argument est représenté par ⍵

 (… )↑¨¨⊂⍵ Pour chacun ( ¨) des nombres suivants, prenez ( ↑) autant de caractères de chacun ( ¨) de l' ⊂argument entier ( ), en remplissant avec des espaces si nécessaire:

  ≢w le nombre de caractères dans l'argument

  d← stocker cela en d

  ⍳ autant de ɩ ndices (0… d - 1)

  1↓ déposer un (le zéro)

 ∊¨ ε nlist (aplatir) chaque

 ↑ augmenter le rang (convertir la liste des listes en matrice)

 (m←… ) Appliquer la fonction tacite m suivante , définie comme:

  ⊖ l'argument à l'envers

  ⍪ au dessus de

  1 une rangée]

  ↓ est tombé de

  ⊢ l'argument

 ⍉ transposer

 (… )↓ Baisse:

  2-d = - ( d - 2), c'est-à-dire d - 2 rangées à partir du bas

 m appliquer m

 ⍉ transposer

Essayez-le en ligne!

Java (OpenJDK 8) , 201 196 octets

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

Essayez-le en ligne!

C'est la même idée que celle que j'ai utilisée pour le défi précédent , sauf que la chaîne du générateur est maintenant un peu plus longue et avec des cas plus difficiles à gérer.

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

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

Essayez-le en ligne!

Premier message sur PPCG après avoir été tapi pendant un moment. Vous cherchez des suggestions / conseils!

Merci à @LyricLy et @ Łukasz Rogalski pour les améliorations!

Haskell, 177 163 octets

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]

La fonction f est la fonction de défi et renvoie une liste de chaînes ( [String]), en utilisant unlinessur elle devrait fournir la même sortie visuelle que les cas de test (main = putStr $ unlines $ f "test string" pour la compiler).

Essayez-le en ligne!

-14 octets grâce à @nimi

Mathematica, 141 octets

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