(Nota: questa è la mia prima domanda di golf in codice, ma per quanto ne so, nessun altro ha fatto esattamente questo, quindi dovrei essere buono.)

Il tuo compito è creare un programma o una funzione che includa una stringa se un numero intero ne restituisca o generi quel testo racchiuso in più righe. Ogni parola deve essere interamente su una riga; cioè nessuna parola divisa nel mezzo. Ogni riga non può essere più lunga dei ncaratteri e devi inserire quante più parole possibile su ciascuna riga.

Esempio:

s = "Lorem ipsum dolor sit amet, consectetur adipiscing elit. Sed eget erat lectus. Morbi mi mi, fringilla sed suscipit ullamcorper, tristique at mauris. Morbi non commodo nibh. Pellentesque habitant morbi tristique senectus et netus et malesuada fames ac turpis egestas. Sed at iaculis mauris. Praesent a sem augue. Nulla lectus sapien, auctor nec pharetra eu, tincidunt ac diam. Sed ligula arcu, aliquam quis velit aliquam, dictum varius erat." 
n = 50

output:
Lorem ipsum dolor sit amet, consectetur adipiscing
elit. Sed eget erat lectus. Morbi mi mi, fringilla
sed suscipit ullamcorper, tristique at mauris.
Morbi non commodo nibh. Pellentesque habitant
morbi tristique senectus et netus et malesuada
fames ac turpis egestas. Sed at iaculis mauris.
Praesent a sem augue. Nulla lectus sapien, auctor
nec pharetra eu, tincidunt ac diam. Sed ligula
arcu, aliquam quis velit aliquam, dictum varius
erat.

L'output può essere una matrice di stringhe o una singola stringa con interruzioni di riga. Inoltre, puoi presumere che nessuna parola sarà più lunga di n, quindi non preoccuparti di trattare casi strani.

Si applicano le regole I / O standard e sono vietate le scappatoie standard. Sono consentiti spazi finali.

Dato che si tratta di code-golf , vince la soluzione di short in byte.

Ecco un programma di esempio in Python che funzionerebbe.

Python 2 , 26 byte

from textwrap import*
fill

Provalo online!

Meh ... i built-in sono noiosi ... invece, hanno una bella soluzione da 87 byte qui:

s,n=input()
x=''
for i in s.split():c=n<len(x+i);exec'print x'*c;x=x*-~-c+i+' '
print x

Provalo online!

Emette spazi finali.

PHP , 8 byte

Certo non è la soluzione più originale, ma PHP ha una funzione nativa che soddisfa perfettamente le tue esigenze!

wordwrap:

string wordwrap ( string $str [, int $width = 75 [, string $break = "\n" [, bool $cut = FALSE ]]] )

Avvolge una stringa per un determinato numero di caratteri utilizzando un carattere di interruzione della stringa.

Usa così:

$str = "Lorem ipsum dolor sit amet, consectetur adipiscing elit. Sed eget erat lectus. Morbi mi mi, fringilla sed suscipit ullamcorper, tristique at mauris. Morbi non commodo nibh. Pellentesque habitant morbi tristique senectus et netus et malesuada fames ac turpis egestas. Sed at iaculis mauris. Praesent a sem augue. Nulla lectus sapien, auctor nec pharetra eu, tincidunt ac diam. Sed ligula arcu, aliquam quis velit aliquam, dictum varius erat.";
echo wordwrap($str, 50);

Oppure provalo online!

JavaScript (ES6),  75 73  72 byte

Accetta input come (string)(n).

s=>n=>s.split` `.map(w=>r=(u=r?r+' '+w:w)[n]?(o+=r+`
`,w):u,o=r='')&&o+r

Provalo online!

variabili

L'output formattato è memorizzato in $o$ (in verde sotto).

La riga aggiornata $u$ è definita come la concatenazione di:

• la riga corrente $r$ (in nero sotto)
• uno spazio se $r$ non è vuoto o nient'altro (in arancione sotto)
• la nuova parola $w$ (in blu sotto)

Dobbiamo inserire un'interruzione di riga ogni volta che viene impostato l' $n$ -esimo carattere di $u$ (0-indicizzato, in rosso sotto).

Esempio

$n=16$ and$s$ = "LOREM IPSUM DOLOR"

Aggiunta di "LOREM":

Aggiunta di "IPSUM":

Aggiunta di "DOLOR":

Perl 6 , 46 29 byte

{;*.comb(/.**{1..$_}[\s|$]/)}

Provalo online!

Soluzione basata su Regex che accetta input al curry, come f(n)(s)e restituisce un elenco di righe. Ogni riga tranne l'ultima ha uno spazio bianco finale

Spiegazione:

{;*                         }   # Anonymous code block that returns a Whatever lambda
   .comb(/                /)    # Split the string by
          .**{1..$_}            # Up to n characters
                    [\s|$]      # Terminated by a whitespace char or the end of the string

Vim, 15 byte / sequenze di tasti

DJ:se tw=<C-r>"
gq_

Una domanda di formattazione del testo? Conosco solo lo strumento per il lavoro! E ha anche il mio nome nelle prime due battute: D

<C-r> si intende ctrl-r .

Questo potrebbe mai leggermente più breve in V , ma preferisco rispondere in vaniglia vim per risposte che mostrino davvero quanto può essere conciso vim per la giusta sfida. E la differenza è comunque così piccola.

Questo potrebbe anche essere il seguente per 15 byte:

:se tw=<C-r><C-w>
ddgq_

Provalo online!

R , 36 27 byte

R ha questo come built-in ( strwrap), restituiamo un vettore di linee di divisione.

function(s,n)strwrap(s,n+1)

Provalo online!

Haskell , 70 byte

s!n|length s<=n=[s]|(t,_:d)<-splitAt(until((<'!').(s!!))pred n)s=t:d!n

Python 2 , 74 byte

s,n=input()
while s:i=n;exec"i-=' '<(s+' '*n)[i];"*n;print s[:i];s=s[i+1:]

Provalo online!

Java (JDK) , 46 44 byte

Fondamentalmente una soluzione regex pura in Java, quasi sicuramente la più breve che abbia mai scritto.

Saluti a Kevin per aver contribuito a ridurre ulteriormente i byte nella regex!

n->s->s.replaceAll(".{1,"+n+"}( |$)","$0\n")

Provalo online!

Usando un lamdba al curry, crea una regex per abbinare avidamente fino a ncaratteri seguiti da uno spazio o una fine della stringa. Sostituisce quindi quei personaggi con se stessi seguiti da una nuova riga.

Mathematica, 16 byte

InsertLinebreaks

Funzione integrata. Accetta una stringa e un numero intero come input e restituisce una stringa come output.

InsertLinebreaks["string", n]
 inserisce i caratteri di nuova riga per rendere non più lunga di n caratteri.

Powershell, 40 83 byte

Caso di prova con n=80aggiunta.

param($s,$n)$s-split' '|%{if(($o+$_|% le*)-lt$n){$o+=' '*!!$o+$_}else{$o;$o=$_}}
$o

Script di prova:

$f = {

param($s,$n)$s-split' '|%{if(($o+$_|% le*)-lt$n){$o+=' '*!!$o+$_}else{$o;$o=$_}}
$o

}

@(
,(50, "Lorem ipsum dolor sit amet, consectetur adipiscing elit. Sed eget erat lectus. Morbi mi mi, fringilla sed suscipit ullamcorper, tristique at mauris. Morbi non commodo nibh. Pellentesque habitant morbi tristique senectus et netus et malesuada fames ac turpis egestas. Sed at iaculis mauris. Praesent a sem augue. Nulla lectus sapien, auctor nec pharetra eu, tincidunt ac diam. Sed ligula arcu, aliquam quis velit aliquam, dictum varius erat.",
"Lorem ipsum dolor sit amet, consectetur adipiscing",
"elit. Sed eget erat lectus. Morbi mi mi, fringilla",
"sed suscipit ullamcorper, tristique at mauris.",
"Morbi non commodo nibh. Pellentesque habitant",
"morbi tristique senectus et netus et malesuada",
"fames ac turpis egestas. Sed at iaculis mauris.",
"Praesent a sem augue. Nulla lectus sapien, auctor",
"nec pharetra eu, tincidunt ac diam. Sed ligula",
"arcu, aliquam quis velit aliquam, dictum varius",
"erat.")
,(80, "Lorem ipsum dolor sit amet, consectetur adipiscing elit. Sed eget erat lectus. Morbi mi mi, fringilla sed suscipit ullamcorper, tristique at mauris. Morbi non commodo nibh. Pellentesque habitant morbi tristique senectus et netus et malesuada fames ac turpis egestas. Sed at iaculis mauris. Praesent a sem augue. Nulla lectus sapien, auctor nec pharetra eu, tincidunt ac diam. Sed ligula arcu, aliquam quis velit aliquam, dictum varius erat.",
"Lorem ipsum dolor sit amet, consectetur adipiscing elit. Sed eget erat lectus.",
"Morbi mi mi, fringilla sed suscipit ullamcorper, tristique at mauris. Morbi non",
"commodo nibh. Pellentesque habitant morbi tristique senectus et netus et",
"malesuada fames ac turpis egestas. Sed at iaculis mauris. Praesent a sem augue.",
"Nulla lectus sapien, auctor nec pharetra eu, tincidunt ac diam. Sed ligula arcu,",
"aliquam quis velit aliquam, dictum varius erat.")
) | %{
    $n,$s,$expected = $_
    $result = &$f $s $n
    "$result"-eq"$expected"
    # $result   # uncomment this line to dispaly a result
}

Produzione:

True
True

C (gcc) , 68 byte

i;b(s,n,l)char*s,*l;{for(i=n;*++s;i--||(i=l-s+n,*l=10))l=*s-32?l:s;}

Provalo online!

Grazie a ceilingcat , risparmia 2 byte spostando globale char*lsu parametro.

Japt , 20 byte

¸rÈ+Yi[X·ÌY]¸Ê>V?R:S

Provalo online!

Grazie a Bubbler e Shaggy per il loro aiuto

Spiegazione:

¸                       #Split into words
 r                      #For each word, add them to the output in this way:
     i                  # Choose a character using this process:
       X·Ì              #  Get the last line of the output
          Y             #  And the current word
      [    ]¸           #  Join them with a space
             Ê>V?       #  If the resulting line is greater than the allowed length:
                ?R      #   Choose "/n" (newline)
                  :S    #  Otherwise choose " " (space)
     i                  # Add the chosen character to the output
  È+Y                   # Add the current word to the output

Retina 0.8.2 , 37 byte

.+$
$*
!`(?=\S.*¶(1)+)(?<-1>.)+(?=\s)

Provalo online! Prende se nsu linee separate. Spiegazione:

.+$
$*

Converti nin unario.

(?=\S.*¶(1)+)(?<-1>.)+(?=\s)

Abbina gli spazi non bianchi, quindi guarda avanti ne contalo come $#1. Quindi tornare indietro e utilizzare un gruppo di bilanciamento per abbinare i ncaratteri seguiti da spazi bianchi.

!`

Emetti le partite come un elenco di righe.

Carbone , 19 byte

Ｎθ←Ｆ⪪Ｓ «¿‹⁺ＬιⅈθＭ→⸿ι

Provalo online! Il collegamento è alla versione dettagliata del codice. Accetta input di ne ssu righe separate. Spiegazione:

Ｎθ

Input n.

←

Spostare il cursore a sinistra di un quadrato per bilanciare il movimento destro dalla prima iterazione del loop.

Ｆ⪪Ｓ «

Dividi la stringa negli spazi e passa sopra le parole.

¿‹⁺Ｌιⅈθ

Calcola se la parola successiva raggiungerà il bordo destro.

Ｍ→

Se non si sposta quindi di un quadrato a destra.

⸿

Se inizierà quindi una nuova linea.

ι

Emetti la parola.

Rosso , 125, 117, 114 112 byte

func[s n][d: 0 parse s[any[to" "p:" "opt[[to" "| to end]q:(if(-1 - d + index? q)> n[p/1: #"^/"d: index? p])]]]s]

Provalo online!

05AB1E , 18 byte

õs#vDy«g²›i,}yðJ}?

Provalo online.

Spiegazione:

õ                   # Push an empty string "" to the stack
 s                  # Swap to take the (implicit) string input
  #                 # Split it by spaces
   v            }   # For-each `y` over the words:
    D               #  Duplicate the top of the stack
                    #  (which is the empty string in the very first iteration)
     y«             #  Append the current word `y`
       g            #  Get its length
        ²›i }       #  If its lengthy is larger than the second input:
           ,        #   Pop and output the current duplicated value with trailing newline
             yð     #  Push the word `y` and a space " "
               J    #  Join the entire stack together
                 ?  # After the loop, output the last part as well (without newline)

Java 8, 135 byte

n->s->{String r="",S[]=s.split(" "),t=r;for(int i=0;i<S.length;)if((t+S[i]).length()>n){r+=t+"\n";t="";}else t+=S[i++]+" ";return r+t;}

Provalo online.

Spiegazione:

n->s->{                      // Method with integer & String parameters and String return
  String r="",               //  Result-String, starting empty
         S[]=s.split(" "),   //  Input-String split by spaces
         t=r;                //  Temp-String, starting empty as well
  for(int i=0;i<S.length;)   //  Loop `i` in the range [0, amount_of_words):
    if((t+S[i]).length()>n){ //   If `t` and the word are larger than the integer input:
      r+=t+"\n";             //    Add `t` and a newline to the result
      t="";}                 //    And reset `t` to an empty String
     else                    //   Else:
       t+=S[i++]+" ";        //    Append the word and a space to `t`
                             //    (and then increase `i` by 1 with `i++` for the next word
                             //     of the next iteration)
  return r+t;}               //  Return the result-String appended with `t` as result

JavaScript, 40 byte

s=>n=>eval(`s.match(/.{1,${n}}( |$)/g)`)

Provalo online!

APL (Dyalog Unicode) , ^{SBCS da} 14 byte

Funzione Infix; l'argomento left è n, l'argomento right è n.

⎕CY'dfns'⋄wrap

Provalo online!

⎕CY c op y nella libreria dfns

⋄ poi

wrap^[c]  usano la pellicola ^[n] la funzione

^[c]  codice di quella funzione
^[n]  note per quella funzione

Versione golfizzata di ^{SBCS da}wrap 59 byte

{⍺≥≢⍵:⍵⋄(t↑⍵),2↓⎕TC,⍺∇⍵↓⍨t+b⊃⍨t←⊃⌽⍺,g/⍨⍺≥g←⍸(⍺+1)↑b←' '=⍵}

Provalo online!

{... } dfn; ⍺è argomento a sinistra (larghezza), ⍵è argomento a destra (stringa)

 ≢⍵ riscontro (numero di caratteri) della stringa

 ⍺≥... : se la larghezza è maggiore o uguale a quella, allora:

  ⍵ restituisce la stringa

 ⋄ altrimenti:

  ' '=⍵ Maschera booleana in cui gli spazi vuoti sono uguali alla stringa

  b← conservare in b(per b lanks)

  (... )↑ prendi il seguente numero di elementi da quello:

   ⍺+1 uno in più rispetto alla larghezza

  ⍸ I ndices dove la vera

  g← conservare in g(per g aps)

  ⍺≥ Maschera booleana in cui la larghezza è maggiore o uguale a quella

  g/⍨ filtrare gli indici di gap da quello

  ⍺, aggiungilo alla larghezza

  ⊃⌽ scegli l'ultimo elemento di quello (lett. scegli il primo dell'inverso)

  t← conservare in t(per t ake)

  b⊃⍨usalo  per scegliere un elemento dalla maschera di b lanks

  t+ aggiungilo a t

  ⍵↓⍨ lascia cadere tanti caratteri dalla stringa

  ⍺∇ fare affidamento su quello con lo stesso argomento a sinistra

  ⎕TC, accodamento che alla lista dei t erminal c ontrollo caratteri (8: HT, 10: NL, 13: CR)

  2↓ rilasciare i primi due personaggi da quello (lasciando solo un 13: CR iniziale)

  (... ), aggiungilo a quanto segue:

   t↑⍵ i primi tcaratteri della stringa

Grazie a @Erik the Outgolfer, una versione giocata a golf:

Python 3 , 94 byte

def f(t,n):
 while t:i=n+(t[min(len(t)-1,n)]==" "or-t[n-1::-1].find(' '));print(t[:i]);t=t[i:]

Provalo online!

# Python 3 , 130 byte

def f(t,n):
 l=[]
 while len(t):
  i=(n-t[:n][::-1].find(' '),n+1)[t[min(len(t)-1,n)]==" "]
  l.append(t[:i])
  t=t[i::]
 return l

Provalo online!

Versione non tanto giocata a golf ...

JavaScript + HTML + CSS, 117 64 byte

-53 byte per gentile concessione di @Neil

n=50
s="Lorem ipsum dolor sit amet, consectetur adipiscing elit. Sed eget erat lectus. Morbi mi mi, fringilla sed suscipit ullamcorper, tristique at mauris. Morbi non commodo nibh. Pellentesque habitant morbi tristique senectus et netus et malesuada fames ac turpis egestas. Sed at iaculis mauris. Praesent a sem augue. Nulla lectus sapien, auctor nec pharetra eu, tincidunt ac diam. Sed ligula arcu, aliquam quis velit aliquam, dictum varius erat."
f=(n,s)=>document.body.innerHTML+=`<tt><p style=width:${n}ch>${s}`
f(n,s)

Gelatina , 12 byte

ḲŒṖK€€ḣ€ƑƇṪY

Provalo online!

Sfortunatamente, questo è troppo lento per funzionare per il test case fornito in meno di un minuto su TIO.

C # (.NET Core) , 162 byte

string[]t(string n,int a){var g="";for(int i=0;i++<Math.Floor((double)n.Length/a);)g+=$"^.{{{i*a-1}}}|";return Regex.Split(n,$@"(?n)(?<=({g.Trim('|')})\S*)\s");}}

Questa funzione usa una regex che corrisponde allo spazio bianco più vicino vicino all'ennesimo o multiplo dell'ennesimo carattere e divide la stringa in base ad essa.

Provalo online!

Il collegamento TIO è un programma completo e la funzione ha una parola chiave statica, quindi la funzione può essere chiamata dal principale.

Test Regex

C # (compilatore interattivo Visual C #) , 78 byte

s=>n=>System.Text.RegularExpressions.Regex.Replace(s,".{1,"+n+"}( |$)","$0\n")

Provalo online!

Il merito va a @LukeStevens per aver inventato la versione Java ... Apparentemente .NET ti fa importare RegularExpressions spazio nomi per fare un rimpiazzo :(

Ecco la mia versione originale che si divide sul personaggio spaziale e usa LINQ per unirli di nuovo:

C # (compilatore interattivo Visual C #) , 91 byte

s=>n=>s.Split(' ').Aggregate((a,w)=>a+(a.Length-a.LastIndexOf('\n')+w.Length>n?'\n':' ')+w)

Provalo online!

Dardo , 112 byte

f(s,n){var l=[''];s.split(' ').forEach((w){if((l.last+w).length<=n)l.last+=w+' ';else l.add(w+' ');});return l;}

Provalo online!

APL (NARS), 48 caratteri, 96 byte

{⊃⍵{⍺≥≢⍵:⊂⍵⋄k←1+⍺-' '⍳⍨⌽r←⍺↑⍵⋄(⊂k↑r),⍺∇k↓⍵}⍨⍺+1}

test:

  f←{⊃⍵{⍺≥≢⍵:⊂⍵⋄k←1+⍺-' '⍳⍨⌽r←⍺↑⍵⋄(⊂k↑r),⍺∇k↓⍵}⍨⍺+1}
  s←"Lorem ipsum dolor sit amet, consectetur adipiscing elit. Sed eget erat lectus. Morbi mi mi, fringilla sed suscipit ullamcorper, tristique at mauris. Morbi non commodo nibh. Pellentesque habitant morbi tristique senectus et netus et malesuada fames ac turpis egestas. Sed at iaculis mauris. Praesent a sem augue. Nulla lectus sapien, auctor nec pharetra eu, tincidunt ac diam. Sed ligula arcu, aliquam quis velit aliquam, dictum varius erat."
  50 f s
Lorem ipsum dolor sit amet, consectetur adipiscing 
elit. Sed eget erat lectus. Morbi mi mi, fringilla 
sed suscipit ullamcorper, tristique at mauris.     
Morbi non commodo nibh. Pellentesque habitant      
morbi tristique senectus et netus et malesuada     
fames ac turpis egestas. Sed at iaculis mauris.    
Praesent a sem augue. Nulla lectus sapien, auctor  
nec pharetra eu, tincidunt ac diam. Sed ligula     
arcu, aliquam quis velit aliquam, dictum varius    
erat.                                              

C, 63 byte

b(a,n)char*a;{while(strlen(a)>n){for(a+=n;*a-32;--a);*a++=10;}}

La funzione di questo esercizio b (a, n) spezzerebbe la linea "a" come detto esercizio, nel modo in cui non cambierebbe la sua lunghezza (se vediamo il risultato come una stringa) perché cambierà alcuni spazi in \ n o la nuova linea in posto. La stringa di input "a" non dovrebbe contenere anche un carattere \ n per la funzione b () (potrebbe avere \ n nella stringa di input per bs ())

La funzione b (a, n) sarebbe ok solo perché la restrizione di questo esercizio, che impone ogni parola di una stringa "a" ha lunghezza <n se ciò non è vero, quella funzione può andare
in un ciclo infinito ... (molto sbagliato nel mio modo di vedere, quindi copio anche la funzione più bene perché in quel caso restituirebbe -1 e non andrebbe in un ciclo infinito; è bs (a, n) di seguito) Non escludo che entrambe le funzioni siano infastidite .. .

#define R(x,y) if(x)return y
#define U unsigned
U bs(char*a,U n)
{U c,q,r=1,i,j;
 R(!a||n<1||n++>0xFFFF,-1);
 for(j=c=i=0;;++i,++c)
    {R(i==-1,-1);q=a[i];
     if(q==10)goto l;
     if(c>=n){R(i-j>n,-1);a[i=j]=10;l:c=-1;++r;}
     R(!q,r);
     if(q==32)j=i;
    }
}

il risultato di b () ha passato una funzione che aggiunge la lunghezza di ogni riga

Lorem ipsum dolor sit amet, consectetur adipiscing [50]
elit. Sed eget erat lectus. Morbi mi mi, fringilla [50]
sed suscipit ullamcorper, tristique at mauris. [46]
Morbi non commodo nibh. Pellentesque habitant [45]
morbi tristique senectus et netus et malesuada [46]
fames ac turpis egestas. Sed at iaculis mauris. [47]
Praesent a sem augue. Nulla lectus sapien, auctor [49]
nec pharetra eu, tincidunt ac diam. Sed ligula [46]
arcu, aliquam quis velit aliquam, dictum varius [47]
erat. [5]