Baue mir eine Schlosstreppe!

13

Sie erhalten einen String bestehend aus druckbarem ASCII (ohne Zeilenvorschub). Ihre Aufgabe ist es, eine schöne Treppe für mein Schloss zu bauen.

Wie baue ich eine schöne Treppe?

  • Zunächst sollten Sie alle Drehungen der Zeichenfolge abrufen. Beispielsweise hat der String abcddie folgenden Rotationen: abcd, bcda, cdab, dabc(Jedes Zeichen wird an das Ende verschoben, bis das letzte Zeichen erreicht ist.)

  • Wir legen nun jede Umdrehung übereinander:

    abcd
bcda
cdab
dabc

  • Wir können nicht wirklich auf eine gerade Wand klettern, also müssen wir Treppen bauen. Das bedeutet, dass Sie vor jeder Drehung eine Anzahl von Leerzeichen hinzufügen sollten, die ihrem Index in der Rotationsliste entsprechen:

    abcd
 bcda
  cdab
   dabc

  • Du brauchst auch eine Treppe, die mit der anderen Seite meines Schlosses verbunden ist, also solltest du eine wie unten bauen, jede Umdrehung umkehren und etwas Abstand hinzufügen:

    abcd      dcba
 bcda    adcb
  cdab  badc
   dabccbad

Dies ist Code-Golf , daher gewinnt der kürzeste Code in Bytes und es gelten die Standardregeln für das Tag.

Testfälle

  • Eingabe:, abcdAusgabe:

    abcd      dcba
 bcda    adcb
  cdab  badc
   dabccbad

  • Eingabe:, aaaaAusgabe:

    aaaa      aaaa
 aaaa    aaaa
  aaaa  aaaa
   aaaaaaaa

  • Eingabe:, Code golfAusgabe (Beachten Sie die Leerzeichen):

    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
quelle
— Mr. Xcoder
Sollte die Treppe nicht anfangen hoch und dann runter zu gehen, anstatt runter und dann rauf zu gehen? : P
— Stephen
@StepHen Zum Zweck dieser Herausforderung sollte es nicht: p
— Mr. Xcoder
5
— DJMcMayhem
dabc. -------
— Oliver Ni

Antworten:

8

05AB1E , 12 Bytes

Code:

vDNúsÀ}\».B∞

Verwendet die 05AB1E- Codierung. Probieren Sie es online!

Erläuterung:

v     }        # Length input times, do.. (N = iteration count)
 DNú           #   Duplicate and prepend N spaces
    sÀ         #   Swap and rotate one to the left
       \       # Discard the top of the stack
        »      # Join the stack by newlines
         .B    # Pad with spaces into a rectangle
           ∞   # Mirror the string
— Adnan
quelle
1
— Ergebnisse
3

Netzhaut , 47 Bytes

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

¶

Probieren Sie es online! Erläuterung: In der ersten Stufe wird die linke Treppe erstellt, indem jedes Zeichen berücksichtigt und Leerzeichen entsprechend der aktuellen Position, dann der Rest der Zeichenfolge, dann der Anfang der Zeichenfolge und dann Leerzeichen entsprechend dem Rest der Zeichenfolge erstellt werden. Der Rest des Skripts durchläuft jede gerade erzeugte Zeile. Zuerst wird die Zeile dupliziert, dann werden die Zeichen im Duplikat umgekehrt, dann werden die Zeile und ihr Duplikat verkettet.

— Neil
quelle
2

Holzkohle , 23 21 20 Bytes

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

Probieren Sie es online!

Kann wahrscheinlich mehr Golf gespielt werden, aber ich poste von der mobilen App. Link zur ausführlichen Version .

— Charlie
quelle
Übrigens, wenn Sie keine Erklärung hinzufügen, verwenden Sie mindestens -a flag pls
— ASCII
@ ASCII-only sorry, ich dachte die ausführliche Version wäre eine Erklärung.
— Charlie
Warten Sie, was NVM nicht gesehen hat
— ASCII-
Ich glaube nicht , dass es an der Zeit wahr war , aber in diesen Tagen können Sie ein Polygon mit einer beliebigen Zeichenkette füllen und erhalten genau das Ergebnis , das Sie für 9 Bytes benötigen: Ｇ→↘←Ｌθθ‖Ｃ.
— Neil
2

Haskell, 80 79 Bytes

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

Probieren Sie es online!

Wie es funktioniert

(#"")                      -- 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: Danke an @ Ørjan Johansen für ein Byte.

— nimi
quelle
u#_=uSpeichert ein Byte.
— Ørjan Johansen
@ ØrjanJohansen: Ich hatte zuerst eine Liste mit Strings und unlineswo u#_=unicht check und später wechselte ich zum Erstellen eines einzelnen Strings ... Danke!
— 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
quelle
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),"
";

Lauf als Pipe mit -nRoder versuche es online .

Nervenzusammenbruch

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

Japt , 22 Bytes


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

Führende Newline ist Teil des Programms.

Probieren Sie es online!

Führen Sie alle Testfälle aus mit meinem WIP-CodePen aus.

Erläuterung

Implizit: U= Eingabezeichenfolge. Erste Zeile ist leer, um nicht zu überschreibenU .

Die zweite Zeile weist implizit die Länge ( l) von Ubis zuV .

Dritte Zeile:

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

Beispielcode-Snippet:

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>
Erweitern Sie das Snippet

— Herman L
quelle
1

Python 2 , 85 83 Bytes

  • Danke an @ovs für 2 Bytes: l+~iund habe mir geholfen, einen unerwünschten Platz zu finden
x=input()
l=len(x)
for i in range(l):r=i*' '+x[i:]+x[:i]+(l+~i)*' ';print r+r[::-1]

Probieren Sie es online!

— officialaimm
quelle
1
l-1-ikann nur sein l+~ias~i == -i-1
— ovs
1

8. , 173 168 Bytes

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

Ungolfed-Version mit Kommentaren

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

Verwendung und Beispiele

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

Oder klarer

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
quelle
Durch die Nutzung unserer Website bestätigen Sie, dass Sie unsere Cookie-Richtlinie und Datenschutzrichtlinie gelesen und verstanden haben.
Licensed under cc by-sa 3.0 with attribution required.