Scale a corde

Disclaimer: questa è la prima sfida che propongo. Qualsiasi feedback è il benvenuto. Se si tratta di un duplicato, segnalalo.

Ecco un link al post sandbox.

Obbiettivo

L'obiettivo di questa sfida è, data una stringa e un numero intero, stampare la stringa in blocchi delle dimensioni di quel numero intero. Se una parola ha più caratteri della dimensione di un blocco, stampala secondo uno schema a "scala" decrescente.

Regole

• Lo "schema delle scale" sopra menzionato significa che, per ogni blocco di una stessa parola, quel blocco deve iniziare esattamente dove termina il blocco sopra di esso. Controlla i casi di test (o chiedi) se hai domande.
• Se una parola è spezzata in più blocchi, la parola seguente deve essere stampata con un numero adeguato di spazi, cioè deve essere separata dal blocco più basso della parola precedente da esattamente uno spazio bianco. Controllare i casi di test (o chiedere) per chiarimenti.
• Si può presumere che la stringa di input consisterà solo di caratteri ASCII stampabili. Inoltre, non avrà più spazi bianchi di fila.
• Puoi anche supporre che l'intero sarà sempre compreso nell'intervallo [1, + ∞).
• Sono consentiti spazi vuoti finali o nuove righe.
• È possibile utilizzare qualsiasi metodo ragionevole per l'I / O.
• Si applicano scappatoie standard .
• Questo è code-golf , quindi vince il codice più breve (in byte, per lingua). Dopo una settimana (o giù di lì), accetterò la risposta più breve complessiva.

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

Carbone , 22 byte

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

Provalo online! Il collegamento è alla versione dettagliata del codice. Spiegazione:

  θ                      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

* Più precisamente, "passa due volte all'inizio della riga successiva, ma come se la tela fosse ruotata". Modifica: tra questa sfida impostata e la risposta accettata, Charcoal ha effettivamente acquisito un mezzo per dividere una stringa in coppie di caratteri, riducendo il codice di 16 byte:
Ｆ⪪θ «↑⸿⸿Ｆ⪪ιＩη«κ↙ provalo online! Il collegamento è alla versione dettagliata del codice. Spiegazione:

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

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

Provalo qui!

L'ho realizzato ‰mentre lo facevo , ma la documentazione esisteva prima.

Spiegazione:

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

• per leggibilità aggiunto alcuni byte nel codice e rimossi nel conteggio dei byte
• invece di s = "", j = 0 ho fatto j = s = ""
• anziché per (i in s) - normale per loop - rimosso 1 byte
• utilizzando valori già generati negli indicizzatori degli array - rimossi 8 byte
• l'utilizzo già con il valore i = s.length (dal primo loop) in eval - anziché la lunghezza reale dell'array - causa lo spazio finale consentito
• usando la mappa di S invece di eval - si riduce di 3 byte
• usando fill invece sull'inizializzazione dell'array vuoto, quindi non è necessario il loop nel risultato della mappa
• potrebbe sostituire || con | - ridotto di 2 byte
• grazie a @Justin Mariner - sostituisci occorrenze == "" con <"!" riduce 2 byte
• spostato le condizioni da a [I] all'altra istruzione per ridurre uno "u <"! "" - riduce 2 byte
• anziché (I + = 2, j = 0) - j =! (I + = 2) - 1 byte ridotto
• "per di" anziché per

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

  Esegui snippet di codiceNascondi risultati

  Espandi frammento

C #, 200 byte

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

Dove la stringa è specificata da i e la dimensione è specificata da s .

Per esempio

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

Fondamentalmente, la prima parte Regex.Split utilizza spazi bianchi per dividere la frase in parole e Regex.Matches divide ogni parola in blocchi specificati da s . Il blocco viene scritto nella posizione del cursore (x, y) dove Y è impostato su 0 per ogni nuova parola e x viene incrementato di 2 per il primo blocco di una parola e successivamente (s-1) per ogni blocco.

x inizia la sua durata a -2 per assicurarsi che il suo primo utilizzo sia impostato su 0.

Non sono abbastanza informato nelle curiosità di C # per essere in grado di renderlo più piccolo, ma sospetto che probabilmente possa esserlo.

Python 2 , 203 199 byte

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

Provalo online!

Perl 5, 59 byte

55 byte codice + 4 per -ai.

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

Nota: gli \x1bs sono ESCcaratteri letterali , ma sono sfuggiti qui per un facile copia e incolla.

Questo script utilizza sequenze di escape ANSI e richiede un input tramite -iflag non standard. Se uno di questi non è accettabile, per favore fatemelo sapere e ti aggiornerò.

L'esempio funziona

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
                      !