Costruiscimi una scalinata del castello!

13

Ti verrà data una stringa composta da ASCII stampabile (senza nuove righe). Il tuo compito è costruire una bella scalinata per il mio castello.

Come costruire una bella scalinata?

  • Prima di tutto, dovresti ottenere tutte le rotazioni della stringa. Ad esempio, la stringa abcdha le seguenti rotazioni: abcd, bcda, cdab, dabc(ogni carattere viene spostato alla fine fino a quando non raggiungiamo l'ultimo carattere).

  • Ora posizioniamo ciascuna rotazione l'una sopra l'altra:

    abcd
bcda
cdab
dabc

  • Non possiamo davvero arrampicarci su una parete diritta, quindi dobbiamo costruire le scale. Ciò significa che è necessario aggiungere un numero di spazi prima di ogni rotazione corrispondente al suo indice nell'elenco di rotazione:

    abcd
 bcda
  cdab
   dabc

  • Hai anche bisogno di una scala che si collega all'altro lato del mio castello, quindi dovresti costruirne uno come di seguito, invertendo ogni rotazione e aggiungendo un po 'di spazio:

    abcd      dcba
 bcda    adcb
  cdab  badc
   dabccbad

Questo è code-golf , quindi vince il codice più breve in byte e si applicano le regole standard per il tag.

Casi test

  • Ingresso:, abcdUscita:

    abcd      dcba
 bcda    adcb
  cdab  badc
   dabccbad

  • Ingresso:, aaaaUscita:

    aaaa      aaaa
 aaaa    aaaa
  aaaa  aaaa
   aaaaaaaa

  • Input:, Code golfOutput (notare gli spazi):

    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 
— Mr. Xcoder
fonte
— Mr. Xcoder,
La scala non dovrebbe iniziare a salire e poi a scendere, anziché a scendere, poi a salire? : P
— Stephen,
@StepHen Ai fini di questa sfida, non dovrebbe: p
— Mr. Xcoder
5
— James,
dabc. -------
— Oliver Ni il

Risposte:

3

Retina , 47 byte

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

¶

Provalo online! Spiegazione: Il primo stadio crea la scala a sinistra considerando ogni carattere e creando spazi uguali alla posizione corrente, quindi il resto della stringa, quindi l'inizio della stringa, quindi spazi uguali al resto della stringa. Il resto dello script viene eseguito su ogni riga appena generata a sua volta. Prima la linea viene duplicata, quindi i caratteri nel duplicato vengono invertiti, quindi la linea e il suo duplicato vengono concatenati.

— Neil
fonte
3

Python 3 , 89 byte

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

Provalo online!

-1 byte grazie a ovs

-1 byte grazie a Lynn

— HyperNeutrino
fonte
l-i-1può essere solo l+~icome~i == -i-1
— ovs
' '*(l+~i)*2uguale a '  '*(l+~i), che è più corto di un byte!
— Lynn,
2

Carbone , 23 21 20 byte

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

Provalo online!

Probabilmente si può giocare a golf di più, ma sto postando dall'app mobile. Link alla versione dettagliata .

— Charlie
fonte
Oh btw se non aggiungi almeno una spiegazione usa -a flag pls
— ASCII-solo il
@ Mi dispiace solo per ASCII, pensavo che la versione dettagliata fosse considerata una spiegazione.
— Charlie,
Aspetta cosa nvm non ha visto quello
— solo ASCII il
Non credo che fosse vero al momento, ma in questi giorni si può riempire un poligono con una stringa arbitraria e ottenere esattamente il risultato che serve per 9 byte: Ｇ→↘←Ｌθθ‖Ｃ.
— Neil,
2

Haskell, 80 79 byte

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

Provalo online!

Come funziona

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

Modifica: grazie a @ Ørjan Johansen per un byte.

— Nome del modello
fonte
u#_=usalva un byte.
— Ørjan Johansen,
@ ØrjanJohansen: ho prima avuto un elenco di stringhe e unlinesdove u#_=unon digitare check e successivamente sono passato alla creazione di una singola stringa ... Grazie!
— nimi,
1

Mathematica, 119 byte

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

PHP, 95 byte

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

Esegui come pipe -nRo provalo online .

abbattersi

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
fonte
1

Japt , 22 byte


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

Newline leader fa parte del programma.

Provalo online!

Esegui tutti i casi di test usando la mia CodePen WIP.

Spiegazione

Implicito: U= stringa di input. La prima riga è vuota per non sovrascrivereU .

La seconda riga assegna implicitamente la lunghezza ( l) di Ua V.

Terza riga:

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
fonte
1

Javascript (ES6), 118 byte

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

Esempio di frammento di codice:

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>
Espandi frammento

— Herman L
fonte
1

Python 2 , 85 83 byte

  • Grazie @ovs per 2 byte: l+~ie mi ha aiutato a individuare uno spazio indesiderato
x=input()
l=len(x)
for i in range(l):r=i*' '+x[i:]+x[:i]+(l+~i)*' ';print r+r[::-1]

Provalo online!

— officialaimm
fonte
1
l-1-ipuò essere solo l+~icome~i == -i-1
— ovs
1

8 ° , 173 168 byte

Codice

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

Versione non golfata con commenti

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

Utilizzo ed esempi

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

O più chiaramente

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
— Chaos Manor
fonte
Utilizzando il nostro sito, riconosci di aver letto e compreso le nostre Informativa sui cookie e Informativa sulla privacy.
Licensed under cc by-sa 3.0 with attribution required.