Construisez-moi un escalier de château!

13

Vous recevrez une chaîne composée d'ASCII imprimable (sans retour à la ligne). Votre tâche est de construire un joli escalier pour mon château.

Comment construire un joli escalier?

  • Tout d'abord, vous devriez obtenir toutes les rotations de la chaîne. Par exemple, la chaîne abcda les rotations suivantes: abcd, bcda, cdab, dabc(chaque caractère est déplacé jusqu'à la fin jusqu'à ce que nous atteignions le dernier caractère).

  • Nous plaçons maintenant chaque rotation l'une sur l'autre:

    abcd
bcda
cdab
dabc

  • Nous ne pouvons pas vraiment grimper sur un mur droit, nous devons donc construire des escaliers. Cela signifie que vous devez ajouter un certain nombre d'espaces avant chaque rotation correspondant à son index dans la liste de rotation:

    abcd
 bcda
  cdab
   dabc

  • Vous avez également besoin d'un escalier qui relie à l'autre côté de mon château, vous devez donc en construire un comme ci-dessous, en inversant chaque rotation et en ajoutant un peu d'espacement:

    abcd      dcba
 bcda    adcb
  cdab  badc
   dabccbad

C'est le code-golf , donc le code le plus court en octets gagne et les règles standard pour la balise s'appliquent.

Cas de test

  • Entrée:, abcdSortie:

    abcd      dcba
 bcda    adcb
  cdab  badc
   dabccbad

  • Entrée:, aaaaSortie:

    aaaa      aaaa
 aaaa    aaaa
  aaaa  aaaa
   aaaaaaaa

  • Entrée:, Code golfSortie (notez les espaces):

    Code golf                flog edoC
 ode golfC              Cflog edo 
  de golfCo            oCflog ed  
   e golfCod          doCflog e   
     golfCode        edoCflog     
     golfCode        edoCflog     
      olfCode g    g edoCflo      
       lfCode go  og edoCfl       
        fCode gollog edoCf
code-golf  ascii-art 
— M. Xcoder
source
— M. Xcoder
L'escalier ne devrait-il pas commencer à monter, puis descendre, au lieu de descendre, puis de monter? : P
— Stephen
@StepHen Aux fins de ce défi, il ne devrait pas: p
— M. Xcoder
5
— James
dabc. -------
— Oliver Ni

Réponses:

3

Rétine , 47 octets

.
$.`$* $&$'$`$.'$* ¶
%(`^
$_¶
O$^`.(?=.*$)

¶

Essayez-le en ligne! Explication: La première étape crée l'escalier de gauche en considérant chaque caractère et en créant des espaces égaux à la position actuelle, puis le reste de la chaîne, puis le début de la chaîne, puis des espaces égaux au reste de la chaîne. Le reste du script s'exécute sur chaque ligne qui vient d'être générée à son tour. La ligne est d'abord dupliquée, puis les caractères du doublon sont inversés, puis la ligne et son doublon sont concaténés.

— Neil
source
3

Python 3 , 89 octets

x=input()
l=len(x)
for i in range(l):y=x[i:]+x[:i];j=' '*i;print(j+y+'  '*(l+~i)+y[::-1])

Essayez-le en ligne!

-1 octet grâce aux ovs

-1 octet grâce à Lynn

— HyperNeutrino
source
l-i-1peut être juste l+~icomme~i == -i-1
— ovs
' '*(l+~i)*2est égal à '  '*(l+~i), qui est un octet plus court!
— Lynn
2

Fusain , 23 21 20 octets

ＦＬθ«ＦＬθ§θ⁺κι↘ＭＬθ←»‖Ｃ

Essayez-le en ligne!

Peut probablement être joué plus, mais je poste depuis l'application mobile. Lien vers la version détaillée .

— Charlie
source
Oh btw si vous n'ajoutez pas d'explication, utilisez au moins -a flag pls
— ASCII uniquement
@ ASCII uniquement désolé, je pensais que la version verbeuse comptait comme explication.
— Charlie
Attendez ce que NVM n'a pas vu
— ASCII uniquement
Je ne pense pas que ce soit vrai à l'époque , mais ces jours -ci, vous pouvez remplir un polygone avec une chaîne arbitraire et obtenir exactement le résultat que vous avez besoin pour 9 octets: Ｇ→↘←Ｌθθ‖Ｃ.
— Neil
2

Haskell, 80 79 octets

(s:u)#t|q<-(t>>" ")++s:u++t++(u>>" ")=q++reverse q++'\n':u#(t++[s])
u#_=u
(#"")

Essayez-le en ligne!

Comment ça fonctionne

(#"")                      -- start with the input string and an empty accumulator

(s:u)#t                    -- let s be the first char and u the rest of the input
                           -- string, and t the accumulator
    |q<-                   -- let q be half of the current line, i.e.
        (t>>" ")++         --   length of t times spaces
        s:u++              --   s and u (aka the input string)
        t++                --   the accumulator
        (u>>" ")           --   length of u times spaces
    = q ++ reverse q ++    -- the current line is q and q reversed
        '\n' :             -- and a newline
        u#(t++[s])         -- and a recursive call with u as the new input
                           -- string and s put at the end of t
_#_=[]                     -- base case: stop if the input string is empty

Edit: Merci à @ Ørjan Johansen pour un octet.

— nimi
source
u#_=uenregistre un octet.
— Ørjan Johansen
@ ØrjanJohansen: J'ai d'abord eu une liste de chaînes et unlinesoù u#_=une tape pas check et plus tard je suis passé à la construction d'une seule chaîne ... Merci!
— nimi
1

Mathematica, 119 octets

b=StringRotateLeft;j=Table;Column@j[""<>{" "~j~i,b[s=#,i],j["  ",t-i],b[StringReverse@s,-i]},{i,0,t=StringLength@#-1}]&
— J42161217
source
1

PHP, 95 octets

for($e=strlen($s=$argn);$i<$e;$s.=$s[$i],$s[$i++]=" ")echo$t=str_pad($s,2*$e-1),strrev($t),"
";

Exécuter en tant que pipe avec -nRou l' essayer en ligne .

panne

for($e=strlen($s=$argn);    # import input
    $i<$e;                  # loop length times
    $s.=$s[$i],                 # 2. append current character
    $s[$i++]=" ")               # 3. set current character to space
    echo$t=str_pad($s,2*$e-1),  # 1. print string padded with length-1 spaces
        strrev($t),             #    print reverse
        "\n";                   #    print newline
— Titus
source
1

Japt , 22 octets


l
VÇç +UéZn)+´Vç)ê1÷

La nouvelle ligne de tête fait partie du programme.

Essayez-le en ligne!

Exécutez tous les cas de test à l' aide de mon WIP CodePen.

Explication

Implicite: U= chaîne d'entrée. La première ligne est vide pour ne pas écraser U.

La deuxième ligne affecte implicitement la longueur ( l) de Uà V.

Troisième ligne:

VÇç +UéZn)+´Vç)ê1÷
VoZ{Zç +UéZn)+--Vç)ê1} · Ungolfed
VoZ{                 }   Create array [0, V) and map by...
    Zç                      The current value (Z) times " "
       +UéZn)               Concatenated with U rotated Z times left
             +--Vç)         Concatenated with --V times " ". This decrements V
                   ê1       Palindromize with repeated last char
                       · Join with newlines and implicitly output
— Justin Mariner
source
1

Javascript (ES6), 118 octets

s=>[...s].map((_,y)=>Array(l=(j=s.length)*4-2).fill().map((_,x)=>(x=x<l/2?x:l-x-1)>=y&y+j>x?s[x%j]:" ").join``).join`
`

Exemple d'extrait de code:

f=
s=>[...s].map((_,y)=>Array(l=(j=s.length)*4-2).fill().map((_,x)=>(x=x<l/2?x:l-x-1)>=y&y+j>x?s[x%j]:" ").join``).join`
`
o.innerText=f("Code golf")
<pre id=o>
Développer l'extrait

— Herman L
source
1

Python 2 , 85 83 octets

  • Merci @ovs pour 2 octets: l+~iet m'a aidé à repérer un espace indésirable
x=input()
l=len(x)
for i in range(l):r=i*' '+x[i:]+x[:i]+(l+~i)*' ';print r+r[::-1]

Essayez-le en ligne!

— officialaimm
source
1
l-1-i peut juste être l+~i comme~i == -i-1
— ovs
1

8e , 173 168 octets

Code

s:len n:1- ( >r dup s:len n:1- "" ( " " s:+ ) rot times dup 0 r@ s:slice -rot r> -1 s:slice s:+ s:+ dup s:rev swap . . cr null s:/ a:shift a:push "" a:join ) 0 rot loop

Version non golfée avec commentaires

: shifter \ s -- s
  null s:/     \ convert string into array
  a:shift      \ remove the first item in the array and put it on TOS
  a:push       \ append the former 1st item to array
  "" a:join    \ convert array into string
;

: stairway \ s -- s
  s:len n:1-
  (
    >r                       \ save loop index
    dup                      \ duplicate input string 
    s:len n:1-               \ get string length
    "" ( " " s:+ ) rot times \ make filler
    dup                      \ duplicate filler 
    0 r@ s:slice             \ make left filler
    -rot                     \ put left filler at proper position
    r> -1 s:slice            \ make right filler
    s:+ s:+                  \ build string ( 1st half of stairway )
    dup s:rev                \ build 2nd half 
    swap . . cr              \ print it
    shifter                  \ shift rotate 1st character
  ) 0 rot loop               \ loop from 0 to len(string)-1
;

Utilisation et exemples

ok> "abcd" s:len n:1- ( >r dup s:len n:1- "" ( " " s:+ ) rot times dup 0 r@ s:slice -rot r> -1 s:slice s:+ s:+ dup s:rev swap . . cr null s:/ a:shift a:push "" a:join ) 0 rot loop
abcd      dcba
 bcda    adcb 
  cdab  badc  
   dabccbad

Ou plus clairement

ok> "Code golf" stairway
Code golf                flog edoC
 ode golfC              Cflog edo 
  de golfCo            oCflog ed  
   e golfCod          doCflog e   
     golfCode        edoCflog     
     golfCode        edoCflog     
      olfCode g    g edoCflo      
       lfCode go  og edoCfl       
        fCode gollog edoCf
— Manoir du Chaos
source
En utilisant notre site, vous reconnaissez avoir lu et compris notre politique liée aux cookies et notre politique de confidentialité.
Licensed under cc by-sa 3.0 with attribution required.