String Stairs

Isenção de responsabilidade: Este é o primeiro desafio que proponho. Todo e qualquer feedback é bem-vindo. Se for uma duplicata, indique-a.

Aqui está um link para a postagem da sandbox.

Objetivo

O objetivo deste desafio é, dada uma sequência e um número inteiro, imprimi-la em blocos do tamanho desse número inteiro. Se uma palavra tiver mais caracteres que o tamanho de um bloco, imprima-a em um padrão descendente de "escada".

Regras

• O "padrão de escada" mencionado acima significa que, para cada bloco de uma mesma palavra, esse bloco deve começar exatamente onde termina o bloco acima. Verifique os casos de teste (ou pergunte) se tiver alguma dúvida.
• Se uma palavra é quebrada em vários blocos, a palavra a seguir deve ser impressa com um número adequado de espaços, ou seja, deve ser separada do bloco mais baixo da palavra anterior por exatamente um espaço em branco. Verifique os casos de teste (ou peça) para esclarecimentos.
• Você pode assumir que a sequência de entrada consistirá apenas em caracteres ASCII imprimíveis. Além disso, ele não terá vários espaços em branco seguidos.
• Você também pode assumir que o número inteiro sempre estará no intervalo [1, + ∞).
• Espaços em branco à direita ou novas linhas são permitidos.
• Você pode usar qualquer método razoável para E / S.
• Aplicam-se brechas padrão .
• Este é o código-golfe , e o código mais curto (em bytes, por idioma) vence. Depois de uma semana (mais ou menos), aceitarei a resposta mais curta geral.

Casos de teste

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

Carvão , 22 bytes

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

Experimente online! Link é a versão detalhada do código. Explicação:

  θ                      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

* Mais precisamente, "vá para o início da próxima linha duas vezes, mas como se a tela fosse girada". Edit: Entre este desafio ser definido e esta resposta ser aceita, o carvão vegetal realmente adquiriu um meio de dividir uma string em pares de caracteres, reduzindo o código em 16 bytes:
Ｆ⪪θ «↑⸿⸿Ｆ⪪ιＩη«κ↙ Experimente online! Link é a versão detalhada do código. Explicação:

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

Experimente aqui!

Eu implementei ‰enquanto fazia isso, mas a documentação já existia antes.

Explicação:

ā                            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 a leitura, adicionou alguns bytes no código e os removeu na contagem de bytes
• em vez de s = "", j = 0 eu fiz j = s = ""
• em vez de para (i in s) - regular para loop - removido 1 byte
• usando valores já gerados nos indexadores das matrizes - removidos 8 bytes
• usar já com o valor i = s.length (do primeiro loop) no eval - em vez do comprimento real da matriz - causa um espaço à direita permitido
• usando o mapa de S em vez de eval - reduz em 3 bytes
• usando fill em vez de inicializar array vazio - para que não seja necessário o loop no resultado do mapa
• poderia substituir || com | - reduzido em 2 bytes
• graças a Justin Mariner - substitua ocorrências == "" por <"!" reduz 2 bytes
• moveu as condições de a [I] para a outra instrução para reduzir um "u <"! "" - reduz 2 bytes
• em vez de (I + = 2, j = 0) - j =! (I + = 2) - redução de 1 byte
• "para de" em vez 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));

  Executar snippet de códigoOcultar resultados

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

Onde a cadeia é especificada por ie o tamanho é especificado por s .

Por exemplo

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

Basicamente, a primeira parte do Regex.Split usa espaços em branco para dividir a frase em palavras, e o Regex.Matches divide cada palavra em partes especificadas por s . O pedaço é gravado na posição do cursor (x, y), em que Y é definido como 0 para cada nova palavra ex é incrementado em 2 para o primeiro pedaço de uma palavra e subsequentemente (s-1) para cada pedaço.

x inicia sua vida útil em -2 para garantir que seu primeiro uso seja definido como 0.

Não sou conhecedor o suficiente em trivialidades em C # para poder diminuí-lo, mas suspeito que provavelmente possa ser.

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

Experimente online!

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: os \x1bsão ESCcaracteres literais , mas escaparam aqui para facilitar a copiar e colar.

Este script utiliza seqüências de escape ANSI e requer entrada através do -isinalizador que não é padrão. Se um desses itens não for aceitável, entre em contato e atualizarei.

Execuções de exemplo

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
                      !