(Nota: esta es mi primera pregunta de código de golf, pero por lo que puedo decir, nadie más ha hecho exactamente esto, así que debería ser bueno).

Su tarea es hacer un programa o función que tome una cadena sy un número entero n, y devuelva o genere ese texto envuelto en varias líneas. Cada palabra debe estar totalmente en una línea; es decir, no hay palabras divididas en el medio. Cada línea puede tener una nlongitud máxima de caracteres y debe incluir tantas palabras como sea posible en cada línea.

Ejemplo:

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.

Su salida puede ser una matriz de cadenas o una sola cadena con saltos de línea. Además, puede asumir que las palabras no serán más largas que n, así que no se preocupe por tratar casos extraños.

Se aplican las reglas estándar de E / S y se prohíben las lagunas estándar. Se permiten espacios finales.

Como se trata de código de golf , gana la solución de shortes en bytes.

Aquí hay un programa de ejemplo en Python que funcionaría.

Python 2 , 26 bytes

from textwrap import*
fill

Pruébalo en línea!

Meh ... los complementos son aburridos ... en cambio, tenga una buena solución de 87 bytes aquí:

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

Pruébalo en línea!

Salidas de espacios finales.

PHP , 8 bytes

¡Es cierto que no es la solución más original, pero PHP tiene una función nativa que se adapta perfectamente a tus requisitos!

wordwrap:

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

Envuelve una cadena a un número dado de caracteres usando un carácter de salto de cadena.

Use así:

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

O Pruébelo en línea!

JavaScript (ES6),  75 73  72 bytes

Toma entrada como (string)(n).

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

Pruébalo en línea!

Variables

La salida formateada se almacena en (en verde a continuación).$o$

La línea actualizada se define como la concatenación de:$u$

• la línea actual (en negro debajo)$r$
• un espacio si no está vacío, o nada más (en naranja debajo)$r$
• la nueva palabra (en azul abajo)$w$

Hay que insertar un salto de línea cada vez que el carácter -ésimo de se establece (0 indexados, en rojo abajo).$n$$u$

Ejemplo

$n=16$ y = "LOREM ipsum dolor"$s$

Agregar "LOREM":

Agregar "IPSUM":

Agregar "DOLOR":

Perl 6 , 46 29 bytes

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

Pruébalo en línea!

Solución basada en expresiones regulares que toma la entrada curry, como f(n)(s)y devuelve una lista de líneas. Cada línea, excepto la última, tiene un espacio en blanco al final

Explicación:

{;*                         }   # 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 bytes / pulsaciones de teclas

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

¿Una pregunta de formato de texto? ¡Sé exactamente la herramienta para el trabajo! E incluso tiene mi nombre en las dos primeras pulsaciones: D

<C-r>significa ctrl-r.

Esto podría ser un poco más corto en V , pero prefiero responder en vainilla vim para obtener respuestas que realmente muestren cuán concisa puede ser vim para el desafío correcto. Y la diferencia es muy pequeña de todos modos.

Esto también podría ser lo siguiente para 15 bytes:

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

Pruébalo en línea!

R , 36 27 bytes

R tiene esto como un incorporado ( strwrap), devolvemos un vector de líneas divididas.

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

Pruébalo en línea!

Haskell , 70 bytes

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

Python 2 , 74 bytes

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

Pruébalo en línea!

Java (JDK) , 46 44 bytes

Básicamente, una solución de expresiones regulares puras en Java, casi seguramente la más corta que he escrito.

¡Saludos a Kevin por ayudar a reducir aún más los bytes en la expresión regular!

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

Pruébalo en línea!

Usando una lamdba al curry, crea una expresión regular para emparejar con avidez los ncaracteres seguidos de un espacio o un final de cadena. Luego reemplaza esos personajes con ellos mismos seguidos de una nueva línea.

Mathematica, 16 bytes

InsertLinebreaks

Función incorporada Toma una cadena y un entero como entrada y devuelve una cadena como salida.

InsertLinebreaks["string", n]
 inserta caracteres de nueva línea para que no haya más de n caracteres.

Powershell, 40 83 bytes

Caso de prueba con n=80agregado.

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

Script de prueba:

$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
}

Salida:

True
True

C (gcc) , 68 bytes

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

Pruébalo en línea!

Gracias a ceilingcat , ahorre 2 bytes moviendo global char*la parámetro.

Japt , 20 bytes

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

Pruébalo en línea!

Gracias a Bubbler y Shaggy por su ayuda.

Explicación:

¸                       #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 bytes

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

Pruébalo en línea! Toma sy nen líneas separadas. Explicación:

.+$
$*

Convierte na unario.

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

Haga coincidir espacios que no sean espacios en blanco, luego mire hacia adelante ny cuente como $#1. Luego regrese y use un grupo de equilibrio para hacer coincidir los ncaracteres seguidos de espacios en blanco.

!`

Salida de las coincidencias como una lista de líneas.

Carbón de leña , 19 bytes

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

Pruébalo en línea! El enlace es a la versión detallada del código. Toma entrada de ny sen líneas separadas. Explicación:

Ｎθ

Entrada n.

←

Mueva el cursor un cuadrado hacia la izquierda para equilibrar el movimiento derecho desde la primera iteración del bucle.

Ｆ⪪Ｓ «

Divida la cadena en espacios y repita sobre las palabras.

¿‹⁺Ｌιⅈθ

Calcule si la siguiente palabra llegará al borde derecho.

Ｍ→

Si no lo hace, mueva un cuadrado a la derecha.

⸿

Si entonces comenzará una nueva línea.

ι

Salida de la palabra.

Rojo , 125, 117, 114 112 bytes

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]

Pruébalo en línea!

05AB1E , 18 bytes

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

Pruébalo en línea.

Explicación:

õ                   # 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 bytes

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

Pruébalo en línea.

Explicación:

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 bytes

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

Pruébalo en línea!

APL (Dyalog Unicode) , ^{SBCS de} 14 bytes

Función de infijo; argumento izquierdo es n, argumento derecho es n.

⎕CY'dfns'⋄wrap

Pruébalo en línea!

⎕CY c op y en la biblioteca dfns

⋄ luego

wrap^[c]  usar la envoltura ^[n] función

^[c]  código de esa función
^[n]  notas para esa función

Versión de golf de ^{SBCS de}wrap 59 bytes

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

Pruébalo en línea!

{... } dfn; ⍺es argumento izquierdo (ancho), ⍵es argumento derecho (cadena)

 ≢⍵ cuenta (número de caracteres) de cadena

 ⍺≥... : si el ancho es mayor o igual que eso, entonces:

  ⍵ devolver la cadena

 ⋄ de otra manera:

  ' '=⍵ Máscara booleana donde los espacios en blanco son iguales a la cadena

  b← almacenar en b(para b lanks)

  (... )↑ tome el siguiente número de elementos de eso:

   ⍺+1 uno más que el ancho

  ⍸ y dónde es verdad

  g← almacenar en g(para g aps)

  ⍺≥ Máscara booleana donde el ancho es mayor o igual que

  g/⍨ filtrar los índices de brecha por eso

  ⍺, añadir eso al ancho

  ⊃⌽ elige el último elemento de eso (iluminado, elige el primero de los invertidos)

  t← tienda en t(para t ake)

  b⊃⍨úsalo  para elegir un elemento de la máscara de b lanks

  t+ agregue eso a t

  ⍵↓⍨ soltar tantos caracteres de la cadena

  ⍺∇ recurse a eso con el mismo argumento izquierdo izquierdo

  ⎕TC, append que a la lista de t ERMINAL c ontrol caracteres (8: HT, 10: NL, 13: CR)

  2↓ suelte los dos primeros caracteres de eso (dejando solo un 13: CR principal)

  (… ), Agregue eso a lo siguiente:

   t↑⍵ los primeros tcaracteres de la cadena

Gracias a @Erik the Outgolfer, una versión de golf:

Python 3 , 94 bytes

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:]

Pruébalo en línea!

# Python 3 , 130 bytes

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

Pruébalo en línea!

Versión no tan golfista ...

JavaScript + HTML + CSS, 117 64 bytes

-53 bytes cortesía de @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)

Jalea , 12 bytes

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

Pruébalo en línea!

Desafortunadamente, esto es demasiado lento para funcionar para el caso de prueba proporcionado en menos de un minuto sobre TIO.

C # (.NET Core) , 162 bytes

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

Esta función utiliza una expresión regular que coincide con el espacio en blanco más cercano que está cerca del enésimo o múltiple del enésimo carácter y divide la cadena en función de él.

Pruébalo en línea!

El enlace TIO es un programa completo, y la función tiene una palabra clave estática, por lo que se puede llamar a la función desde main.

Test Regex

C # (compilador interactivo de Visual C #) , 78 bytes

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

Pruébalo en línea!

El crédito va a @LukeStevens por proponer la versión de Java ... Aparentemente .NET te hace importar el RegularExpressionsespacio de nombres para reemplazarlo :(

Aquí está mi versión original que se divide en el carácter espacial y usa LINQ para unirlos nuevamente:

C # (compilador interactivo de Visual C #) , 91 bytes

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

Pruébalo en línea!

Dart , 112 bytes

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

Pruébalo en línea!

APL (NARS), 48 caracteres, 96 bytes

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

prueba:

  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 bytes

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

La función de este ejercicio b (a, n) rompería la línea "a" como se dijo en el ejercicio, en la forma en que no cambia su longitud (si vemos el resultado como una cadena) porque cambia algunos espacios en \ n o una nueva línea en lugar. La cadena de entrada "a" no debería tener ningún carácter \ n para la función b () (podría tener \ n en la cadena de entrada para bs ())

La función b (a, n) estaría bien solo porque la restricción de este ejercicio, que impone cada palabra de la cadena "a" tiene una longitud <n si esto no es cierto, esa función puede ir
a un bucle infinito ... (muy mal en mi forma de ver, así que copié también la función más buena porque en ese caso devolvería -1 y no iría a un bucle infinito; es bs (a, n) a continuación) No excluyo que ambas funciones tengan errores ... .

#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;
    }
}

resultado de b () pasado en una función que agrega longitud de línea a cada línea

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]