¡Construyeme una escalera de castillo!

13

Se le dará una Cadena que consiste en ASCII imprimible (sin líneas nuevas). Tu tarea es construir una bonita escalera para mi castillo.

¿Cómo construir una bonita escalera?

  • En primer lugar, debe obtener todas las rotaciones de la cadena. Por ejemplo, la cadena abcdtiene las siguientes rotaciones: abcd, bcda, cdab, dabc(cada carácter se mueve hasta el final hasta llegar al último carácter).

  • Ahora colocamos cada rotación una encima de la otra:

    abcd
bcda
cdab
dabc

  • Realmente no podemos subir a una pared recta, por lo que debemos construir escaleras. Eso significa que debe agregar una cantidad de espacios antes de cada rotación correspondiente a su índice en la lista de rotación:

    abcd
 bcda
  cdab
   dabc

  • También necesitas una escalera que se una al otro lado de mi castillo, por lo que debes construir una como la siguiente, invirtiendo cada rotación y agregando algo de espacio:

    abcd      dcba
 bcda    adcb
  cdab  badc
   dabccbad

Este es el código de golf , por lo tanto, el código más corto en bytes gana y se aplican las reglas estándar para la etiqueta.

Casos de prueba

  • Entrada: abcdSalida:

    abcd      dcba
 bcda    adcb
  cdab  badc
   dabccbad

  • Entrada: aaaaSalida:

    aaaa      aaaa
 aaaa    aaaa
  aaaa  aaaa
   aaaaaaaa

  • Entrada: Code golfSalida (Observe los espacios):

    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 
— Sr. Xcoder
fuente
— Mr. Xcoder
¿No debería la escalera comenzar a subir, y luego bajar, en lugar de bajar, luego subir? : P
— Stephen
@StepHen Para el propósito de este desafío, no debería: p
— Sr. Xcoder
55
— James
dabC. -------
— Oliver Ni

Respuestas:

3

Retina , 47 bytes

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

¶

Pruébalo en línea! Explicación: La primera etapa crea la escalera izquierda al considerar cada carácter y crear espacios iguales a la posición actual, luego el resto de la cadena, luego el inicio de la cadena, luego espacios iguales al resto de la cadena. El resto de la secuencia de comandos se ejecuta sobre cada línea recién generada a su vez. Primero se duplica la línea, luego los caracteres del duplicado se invierten, luego la línea y su duplicado se concatenan.

— Neil
fuente
3

Python 3 , 89 bytes

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

Pruébalo en línea!

-1 byte gracias a ovs

-1 byte gracias a Lynn

— Hiperneutrino
fuente
l-i-1puede ser l+~itan~i == -i-1
— ovs
' '*(l+~i)*2igual '  '*(l+~i), que es un byte más corto!
— Lynn
2

Carbón , 23 21 20 bytes

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

Pruébalo en línea!

Probablemente se pueda jugar más, pero estoy publicando desde la aplicación móvil. Enlace a la versión detallada .

— Charlie
fuente
Ah, por cierto, si no agrega una explicación, al menos use -a flag pls
— solo ASCII
@ Solo ASCII lo siento, pensé que la versión detallada contaba como una explicación.
— Charlie
Espere lo que nvm no vio eso
— solo ASCII
Creo que no era cierto en el momento, pero en estos días se puede rellenar un polígono con una cadena arbitraria y obtener exactamente el resultado que necesita para 9 bytes: Ｇ→↘←Ｌθθ‖Ｃ.
— Neil
2

Haskell, 80 79 bytes

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

Pruébalo en línea!

Cómo funciona

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

Editar: Gracias a @ Ørjan Johansen por un byte.

— nimi
fuente
u#_=uGuarda un byte.
— Ørjan Johansen
@ ØrjanJohansen: Primero tuve una lista de cadenas y unlinesdónde u#_=uno escribe check y luego cambié a construir una sola cadena ... ¡Gracias!
— nimi
1

Mathematica, 119 bytes

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

PHP, 95 bytes

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

Ejecutar como tubería -nRo probarlo en línea .

Descompostura

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

Japt , 22 bytes


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

La nueva línea principal es parte del programa.

Pruébalo en línea!

Ejecute todos los casos de prueba con mi WIP CodePen.

Explicación

Implícito: U= cadena de entrada. La primera línea está en blanco para no sobrescribirU .

La segunda línea asigna implícitamente la longitud ( l) de Ua V.

Tercera línea:

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

Javascript (ES6), 118 bytes

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

Fragmento de código de ejemplo:

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>
Expandir fragmento

— Herman L
fuente
1

Python 2 , 85 83 bytes

  • Gracias @ovs por 2 bytes: l+~iy me ayudó a detectar un espacio no deseado
x=input()
l=len(x)
for i in range(l):r=i*' '+x[i:]+x[:i]+(l+~i)*' ';print r+r[::-1]

Pruébalo en línea!

— officialaimm
fuente
1
l-1-ipuede ser l+~itan~i == -i-1
— ovs
1

8vo , 173168 bytes

Código

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

Versión sin golf con comentarios

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

Uso y ejemplos

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 más claramente

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
fuente
Al usar nuestro sitio, usted reconoce que ha leído y comprende nuestra Política de Cookies y Política de Privacidad.
Licensed under cc by-sa 3.0 with attribution required.