Escaleras de cuerda

Descargo de responsabilidad: este es el primer desafío que propongo. Cualquiera y todos los comentarios son bienvenidos. Si se trata de un duplicado, indíquelo.

Aquí hay un enlace a la publicación de sandbox.

Gol

El objetivo de este desafío es, dada una cadena y un número entero, imprimir la cadena en bloques del tamaño de ese número entero. Si una palabra tiene más caracteres que el tamaño de un bloque, imprímala en un patrón descendente de "escalera".

Reglas

• El "patrón de escalera" mencionado anteriormente significa que, por cada bloque de una misma palabra, ese bloque debe comenzar exactamente donde termina el bloque que está encima. Verifique los casos de prueba (o pregunte) si tiene alguna pregunta.
• Si una palabra se divide en varios bloques, la siguiente palabra debe imprimirse con un número adecuado de espacios, es decir, debe separarse del bloque inferior de la palabra anterior exactamente por un espacio en blanco. Verifique los casos de prueba (o solicite) una aclaración.
• Puede suponer que la cadena de entrada consistirá solo en caracteres ASCII imprimibles. Además, no tendrá múltiples espacios en blanco seguidos.
• También puede suponer que el entero siempre estará en el rango [1, + ∞).
• Se permiten espacios en blanco al final o nuevas líneas.
• Puede usar cualquier método razonable para E / S.
• Se aplican lagunas estándar .
• Este es el código de golf , por lo que gana el código más corto (en bytes, por idioma). Después de una semana (más o menos), aceptaré la respuesta más corta en general.

Casos de prueba

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

Carbón de leña , 22 bytes

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

Pruébalo en línea! El enlace es a la versión detallada del código. Explicación:

  θ                      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

* Más precisamente, "muévete al inicio de la siguiente línea dos veces, pero como si el lienzo estuviera rotado". Editar: En medio de este desafío que se estableció y se aceptó esta respuesta, Charcoal realmente adquirió un medio de dividir una cadena en pares de caracteres, reduciendo el código 16 bytes: ¡
Ｆ⪪θ «↑⸿⸿Ｆ⪪ιＩη«κ↙ Pruébelo en línea! El enlace es a la versión detallada del código. Explicación:

  θ                 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ž}┼

Pruébalo aquí!

Implementé ‰mientras hacía esto, pero la documentación para ello existía antes.

Explicación:

ā                            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

• para facilitar la lectura, se agregaron algunos bytes en el código y se eliminaron en el recuento de bytes
• en lugar de s = "", j = 0 hice j = s = ""
• en lugar de for (i in s) - regular for loop - eliminado 1 byte
• utilizando valores ya generados en los indexadores de las matrices - eliminado 8 bytes
• el uso ya con el valor i = s.length (desde el primer bucle) en la evaluación, en lugar de la longitud real de la matriz, provoca el espacio final permitido
• usando el mapa de S en lugar de eval - reduce en 3 bytes
• usando el relleno en lugar de inicializar una matriz vacía, por lo que no hay necesidad del bucle en el resultado del mapa
• podría reemplazar || con | - reducido en 2 bytes
• gracias a @Justin Mariner - reemplace las ocurrencias == "" con <"!" reduce 2 bytes
• movió las condiciones de la a [I] a la otra instrucción para reducir una "u <"! "" - reduce 2 bytes
• en lugar de (I + = 2, j = 0) - j =! (I + = 2) - reducido 1 byte
• "para de" en lugar de para

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

  Ejecutar fragmento de códigoOcultar resultados

  Expandir fragmento

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

Donde la cadena se especifica por i y el tamaño se especifica por s .

P.ej

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

Básicamente, la primera parte Regex.Split utiliza espacios en blanco para dividir la oración en palabras, y Regex.Matches divide cada palabra en fragmentos especificados por s . El fragmento se escribe en la posición del cursor (x, y) donde Y se establece en 0 para cada palabra nueva, y x se incrementa en 2 para el primer fragmento de una palabra y posteriormente (s-1) para cada fragmento.

x comienza su vida útil en -2 para garantizar que su primer uso se establezca en 0.

No conozco lo suficiente en curiosidades de C # para poder hacerlo más pequeño, pero sospecho que probablemente pueda serlo.

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

Pruébalo en línea!

Perl 5, 59 bytes

Código de 55 bytes + 4 para -ai.

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

Nota: los \x1bs son ESCcaracteres literales , pero se escaparon aquí para copiar y pegar fácilmente.

Este script utiliza secuencias de escape ANSI y requiere la entrada a través del -iindicador que no es estándar. Si alguno de estos no es aceptable, avíseme y lo actualizaré.

Ejecuciones de ejemplo

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
                      !