Escaliers à cordes

Avertissement: c'est le premier défi que je propose. Tous les commentaires sont les bienvenus. S'il s'agit d'un doublon, veuillez le signaler.

Voici un lien vers le post sandbox.

Objectif

Le but de ce défi est d'imprimer, à l'aide d'une chaîne et d'un entier, la chaîne en blocs de la taille de cet entier. Si un mot a plus de caractères que la taille d'un bloc, imprimez-le dans un motif "d'escalier" descendant.

Règles

• Le "motif d'escalier" mentionné ci-dessus signifie que, pour chaque bloc d'un même mot, ce bloc doit commencer exactement là où se termine le bloc au-dessus. Vérifiez les cas de test (ou demandez) si vous avez des questions.
• Si un mot est divisé en plusieurs blocs, le mot suivant doit être imprimé avec un nombre suffisant d'espaces, c'est-à-dire qu'il doit être séparé du bloc le plus bas du mot précédent par exactement un espace. Vérifiez les cas de test (ou demandez) des éclaircissements.
• Vous pouvez supposer que la chaîne d'entrée ne sera composée que de caractères ASCII imprimables. De plus, il n'aura pas plusieurs espaces blancs consécutifs.
• Vous pouvez également supposer que l'entier sera toujours dans la plage [1, + ∞).
• Les espaces blancs de fin ou les nouvelles lignes sont autorisés.
• Vous pouvez utiliser n'importe quelle méthode raisonnable pour les E / S.
• Les échappatoires standard s'appliquent.
• C'est le code-golf , donc le code le plus court (en octets, par langue) gagne. Après une semaine (environ), j'accepterai la réponse globale la plus courte.

Cas de test

(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
                         !

Fusain , 22 octets

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

Essayez-le en ligne! Le lien est vers la version détaillée du code. Explication:

  θ                      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

* Plus précisément, "déplacez-vous deux fois au début de la ligne suivante, mais comme si le canevas avait été tourné". Edit: Entre ce défi posé et cette réponse acceptée, Charcoal a en fait acquis un moyen de diviser une chaîne en paires de caractères, réduisant le code de 16 octets:
Ｆ⪪θ «↑⸿⸿Ｆ⪪ιＩη«κ↙ Essayez-le en ligne! Le lien est vers la version détaillée du code. Explication:

  θ                 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 octets

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

Essayez-le ici!

J'ai mis ‰en œuvre tout en faisant cela, mais la documentation pour cela existait auparavant.

Explication:

ā                            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 octets

• pour la lisibilité, ajouté quelques octets dans le code et les a supprimés dans le nombre d'octets
• au lieu de s = "", j = 0 je l'ai fait j = s = ""
• au lieu de for (i in s) - normal for loop - supprimé 1 octet
• en utilisant des valeurs déjà générées dans les indexeurs des tableaux - supprimé 8 octets
• utiliser déjà avec la valeur i = s.length (de la première boucle) dans l'eval - au lieu de la longueur réelle du tableau - provoque un espace de fin qui est autorisé
• en utilisant la carte de S au lieu de eval - réduit de 3 octets
• en utilisant fill à la place lors de l'initialisation d'un tableau vide - il n'y a donc pas besoin de boucle dans le résultat de la carte
• pourrait remplacer || avec | - réduit de 2 octets
• merci à @Justin Mariner - remplacez les occurrences == "" par <"!" réduit 2 octets
• déplacé les conditions du a [I] vers l'autre instruction pour réduire un "u <"! "" - réduit 2 octets
• au lieu de (I + = 2, j = 0) - j =! (I + = 2) - réduit de 1 octet
• "pour de" au lieu de pour

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

  Exécuter l'extrait de codeMasquer les résultats

  Développer l'extrait

C #, 200 octets

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++;});});

Où la chaîne est spécifiée par i et la taille est spécifiée par s .

Par exemple

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++;});});

Fondamentalement, la première partie Regex.Split utilise des espaces blancs pour diviser la phrase en mots, et le Regex.Matches divise chaque mot en morceaux spécifiés par s . Le bloc est écrit à la position du curseur (x, y) où Y est défini sur 0 pour chaque nouveau mot, et x est incrémenté de 2 pour le premier bloc d'un mot et ensuite (s-1) pour chaque bloc.

x commence sa vie à -2 pour s'assurer que sa première utilisation est définie sur 0.

Je ne suis pas assez bien informé dans les anecdotes C # pour pouvoir le rendre plus petit, mais je pense qu'il peut probablement l'être.

Python 2 , 203 199 octets

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

Essayez-le en ligne!

Perl 5, 59 octets

55 octets code + 4 pour -ai.

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

Remarque: les \x1bs sont des ESCcaractères littéraux , mais échappés ici pour un copier-coller facile.

Ce script utilise des séquences d'échappement ANSI et nécessite une entrée via l' -iindicateur qui n'est pas standard. Si l'un ou l'autre n'est pas acceptable, veuillez m'en informer et je serai mis à jour.

Exemple d'exécutions

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
                      !