Schnur-Treppe

Haftungsausschluss: Dies ist die erste Herausforderung, die ich vorschlage. Jedes Feedback ist willkommen. Wenn dies ein Duplikat ist, weisen Sie darauf hin.

Hier ist ein Link zum Sandbox-Post.

Tor

Das Ziel dieser Herausforderung besteht darin, die Zeichenfolge anhand einer Zeichenfolge und einer Ganzzahl in Blöcke mit der Größe dieser Ganzzahl zu drucken. Wenn ein Wort mehr Zeichen als die Größe eines Blocks enthält, drucken Sie es in ein absteigendes "Treppenmuster".

Regeln

• Das oben erwähnte "Treppenmuster" bedeutet, dass dieser Block für jeden Block desselben Wortes genau dort beginnen muss, wo der Block darüber endet. Überprüfen Sie die Testfälle (oder fragen Sie), wenn Sie Fragen haben.
• Wenn ein Wort in mehrere Blöcke unterteilt ist, muss das folgende Wort mit einer ausreichenden Anzahl von Leerzeichen gedruckt werden, dh es muss genau ein Leerzeichen vom untersten Block des vorhergehenden Wortes entfernt sein. Überprüfen Sie die Testfälle (oder bitten Sie um Klärung).
• Sie können davon ausgehen, dass die Eingabezeichenfolge nur aus druckbaren ASCII-Zeichen besteht. Außerdem werden nicht mehrere Leerzeichen hintereinander angezeigt.
• Sie können auch davon ausgehen, dass die Ganzzahl immer im Bereich [1, + ∞) liegt.
• Nachgestellte Leerzeichen oder Zeilenumbrüche sind zulässig.
• Sie können für die E / A jede sinnvolle Methode verwenden .
• Es gelten Standard-Regelungslücken .
• Dies ist Code-Golf , also gewinnt der kürzeste Code (in Bytes pro Sprache). Nach einer Woche (oder so) akzeptiere ich die kürzeste Antwort.

Testfälle

(String, Integer) => (Output)

"This is a large string", 3 => Thi is a lar  str
                                 s        ge   ing

"This is an even larger string!", 2 => Th  is an ev  la   st
                                        is        en  rg   ri
                                                       er   ng
                                                             !
"Ooooh dear, what a big string you have!", 3 
=> Ooo  dea  wha a big str   you hav
     oh   r,   t         ing       e!

"Staphylococcus saprophyticus", 4 => Stap        sapr
                                        hylo        ophy
                                           cocc        ticu
                                              us          s

"I hope you find this challenge interesting", 2
=> I ho  yo fi  th  ch    in
      pe  u  nd  is  al    te
                      le    re
                       ng    st
                        e     in
                               g

"Well, this test case looks kinda pointless now doesn't it?", 15
=> Well, this test case looks kinda pointless now doesn't it?

"This one looks a lot more interesting!", 1 => T o l a l m i
                                               h n o   o o n
                                               i e o   t r t
                                               s   k     e e
                                                   s       r
                                                           e
                                                           s
                                                           t
                                                           i
                                                           n
                                                           g
                                                           !
"Keep in mind, people: 'Punctuation! Does! Matter!'", 2
=> Ke  in mi  pe   'P      Do  Ma
    ep     nd  op   un      es  tt
            ,   le   ct      !   er
                 :    ua          !'
                       ti
                        on
                         !

Holzkohle , 22 Bytes

Ｆ⪪θ «↑⸿⸿ＦＬι«Ｍ¬﹪κＩη↙§ικ

Probieren Sie es online! Link ist eine ausführliche Version des Codes. Erläuterung:

  θ                      First input
 ⪪                      Split on spaces
Ｆ   «                   Loop over each word
     ↑⸿⸿                Move the cursor to the top row and two columns right*
          ι             Current word
         Ｌ              Length
        Ｆ  «            Loop over implicit range
               κ        Current index
                 η      Second input
                Ｉ       Cast to integer
              ﹪         Modulo
             ¬          Logical not
            Ｍ     ↙     Move that many characters down and left
                    ι   Current word
                     κ  Current index
                   §    Index into word and implicitly print

* Genauer gesagt: "Gehe zweimal zum Anfang der nächsten Zeile, aber als ob die Leinwand gedreht worden wäre." Bearbeiten: Zwischen dieser Herausforderung und der Annahme dieser Antwort hat Charcoal tatsächlich ein Mittel erlangt, um eine Zeichenfolge in Zeichenpaare aufzuteilen und den Code um 16 Byte zu reduzieren:
Ｆ⪪θ «↑⸿⸿Ｆ⪪ιＩη«κ↙ Probieren Sie es online aus! Link ist eine ausführliche Version des Codes. Erläuterung:

  θ                 First input
 ⪪                  Split on spaces
Ｆ   «               Loop over each word
     ↑⸿⸿            Move the cursor to the top row and two columns right
          ι         Current wordＩη
            η       Second input
           Ｉ        Cast to integer
         ⪪          Split into substrings of that length
        Ｆ    «      Loop over each substring
              κ     Print the substring
               ↙    Move the cursor down and left

SOGL V0.12 , 28 27 26 Bytes

ā,θ{0Eā;{ēb÷eb‰⁴bH*+I;Iž}┼

Probieren Sie es hier aus!

Ich habe dies implementiert ‰, aber die Dokumentation dafür existierte schon vorher.

Erläuterung:

ā                            push an empty array - the main canvas
 ,                           push the first input
  θ{                         for each word (pushing the word each time)
    0E                         set the variable E to 0
      ā;                       below the current word place an empty array - current word canvas
        {               }      for each character of the word
         ēb÷                     push (E++ // B) - note that E is incremented after being used
            eb‰                  push E positive modulo B - like regular modulo but in the 0 output case it gives B
               ⁴                 duplicate the item below ToS
                bH               push B-1
                  *              multiply [(E++ // B) and B-1]
                   +             add [that multiplication to E‰B] - current letters X position
                    I            increase the X position to have one leading space row
                     ;           swap top 2 items - current X position and (E++ // B)
                      I          increase to create current letters Y position
                       ž         in those positions insert the current letter in the current words canvas
                         ┼     append to main canvas current word canvas horizontally

Javascript ES6, 187 183 174 166 163 148 145 143 141 140 138 Bytes

• Zur besseren Lesbarkeit wurden dem Code einige Bytes hinzugefügt und in der Byteanzahl entfernt
• anstelle von s = "", j = 0 habe ich j = s = ""
• anstelle von for (i in s) - regular for loop - wurde 1 Byte entfernt
• Verwendung bereits generierter Werte in den Indexern der Arrays - 8 Bytes entfernt
• Die Verwendung von bereits mit dem Wert i = s.length (von der ersten Schleife) in der Auswertung - anstelle der tatsächlichen Array-Länge - führt zu einem zulässigen nachgestellten Speicherplatz
• Verwenden der Karte von S anstelle von eval - um 3 Byte reduziert
• Verwenden Sie stattdessen fill, um ein leeres Array zu initialisieren. Daher ist die Schleife im Kartenergebnis nicht erforderlich
• könnte ersetzen || mit | - um 2 Bytes reduziert
• danke an @Justin Mariner - Ersetze Vorkommen == "" durch <"!" reduziert 2 Bytes
• Die Bedingungen wurden von a [I] in die andere Anweisung verschoben, um ein "u <"! "" zu reduzieren. Reduziert 2 Bytes
• anstelle von (I + = 2, j = 0) - j =! (I + = 2) - 1 Byte reduziert
• "für von" statt für

  F=(s,n)=>{R=[I=j=i=0]
  for(u of s)
  a=R[z=u<"!"?j=!(I+=2):(j%n&&I++,j++/n|0)]=R[z]||[...s].fill` `,a[I]=u
  return R.map(x=>x.join``).join`
  `}
  console.log(F("This is a large string", 3));
  console.log(F("This is an even larger string!", 2));
  console.log(F("Ooooh dear, what a big string you have!", 3));
  console.log(F("Staphylococcus saprophyticus", 4));
  console.log(F("I hope you find this challenge interesting", 2));
  console.log(F("Well, this test case looks kinda pointless now doesn't it?", 15));
  console.log(F("This one looks a lot more interesting!", 1))
  console.log(F("Keep in mind, people: 'Punctuation! Does! Matter!'", 2));

  Führen Sie das Code-Snippet ausErgebnisse ausblenden

  Erweitern Sie das Snippet

C #, 200 Bytes

int x=-2,y=0;Regex.Split(i,@"\s+").ToList().ForEach(w =>{y=0;Regex.Matches(w,".{0,"+s+"}").Cast<Match>().ToList().ForEach(c=>{x+=(y==0?2:s-1);Console.SetCursorPosition(x,y);Console.Write(c);y++;});});

Wobei die Zeichenfolge durch i und die Größe durch s angegeben wird .

Z.B

string i = "Staphylococcus saprophyticus";
int s = 2;    
int x=-2,y=0;Regex.Split(i,@"\s+").ToList().ForEach(w =>{y=0;Regex.Matches(w,".{0,"+s+"}").Cast<Match>().ToList().ForEach(c=>{x+=(y==0?2:s-1);Console.SetCursorPosition(x,y);Console.Write(c);y++;});});

Grundsätzlich werden im ersten Teil von Regex.Split Leerzeichen verwendet, um den Satz in Wörter aufzuteilen , und die Regex.Matches teilen jedes Wort in Abschnitte auf, die durch s angegeben werden . Der Block wird an die Cursorposition (x, y) geschrieben, wobei Y für jedes neue Wort auf 0 gesetzt wird und x für den ersten Block eines Wortes um 2 erhöht wird und anschließend für jeden Block (s-1).

x startet seine Lebensdauer bei -2, um sicherzustellen, dass die erste Verwendung auf 0 gesetzt ist.

Ich kenne mich in C # nicht gut genug aus, um es kleiner machen zu können, aber ich vermute, dass es wahrscheinlich sein kann.

Python 2 , 203 199 Bytes

s,l=input()
S=s.split()
x=[]
for w in S:L=len(w);W=[i/l*~-l*' '+w[i:i+l]for i in range(0,L,l)];x+=[[c.ljust(L/l*~-l+L%l)for c in W+['']*len(s)]]
for l in zip(*x):
 L=' '.join(l)
 if L.strip():print L

Probieren Sie es online!

Perl 5, 59 Bytes

55 Byte Code + 4 für -ai.

$-=s/.{$^I}\K(?=.)/\x1b[1B\x1b[1D/g,print$_,"\x1b[1A"x$-,$"for@F

Hinweis: Die \x1bs sind wörtliche ESCZeichen, die hier jedoch zum einfachen Kopieren und Einfügen ausgeblendet werden.

Dieses Skript verwendet ANSI-Escape-Sequenzen und erfordert Eingaben über das -inicht standardmäßige Flag. Wenn einer dieser Punkte nicht akzeptabel ist, lassen Sie es mich bitte wissen und ich werde aktualisiert.

Beispiel läuft

perl -ai3 string-stairs.pl <<< 'This is a large string' 2>/dev/null
Thi is a lar  str   
  s        ge   ing

perl -ai2 string-stairs.pl <<< 'This is an even larger string!' 2>/dev/null
Th  is an ev  la   st   
 is        en  rg   ri
                er   ng
                      !

perl -ai3 string-stairs.pl <<< 'Ooooh dear, what a big string you have!' 2>/dev/null
Ooo  dea  wha a big str   you hav  
  oh   r,   t         ing       e!

perl -ai4 string-stairs.pl <<< 'Staphylococcus saprophyticus' 2>/dev/null
Stap        sapr       
   hylo        ophy
      cocc        ticu
         us          s

perl -ai2 string-stairs.pl <<< 'I hope you find this challenge interesting' 2>/dev/null
I ho  yo fi  th  ch    in     
   pe  u  nd  is  al    te
                   le    re
                    ng    st
                     e     in
                            g

perl -ai15 string-stairs.pl <<< "Well, this test case looks kinda pointless now doesn't it?" 2>/dev/null
Well, this test case looks kinda pointless now doesn't it? 

perl -ai1 string-stairs.pl <<< 'This one looks a lot more interesting!' 2>/dev/null
T o l a l m i 
h n o   o o n
i e o   t r t
s   k     e e
    s       r
            e
            s
            t
            i
            n
            g
            !

perl -ai2 string-stairs.pl <<< "Keep in mind, people: 'Punctuation! Does! Matter!'" 2>/dev/null
Ke  in mi  pe   'P       Do   Ma    
 ep     nd  op   un       es   tt
         ,   le   ct       !    er
              :    ua            !'
                    ti
                     on
                      !