(Nota: esta é a minha primeira pergunta de código de golfe, mas, até onde eu sei, ninguém mais fez exatamente isso, por isso devo ser bom.)

Sua tarefa é criar um programa ou função que inclua uma sequência de caracteres se um número inteiro ne retorne ou produza esse texto agrupado em várias linhas. Cada palavra deve estar totalmente em uma linha; ou seja, não há palavras divididas no meio. Cada linha não pode ter mais que ncaracteres, e você deve ajustar o máximo de palavras possível em cada linha.

Exemplo:

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.

Sua saída pode ser uma matriz de seqüências de caracteres ou uma única sequência com quebras de linha. Além disso, você pode assumir que nenhuma palavra terá mais do que nisso; portanto, não se preocupe em lidar com casos estranhos.

Aplicam-se as regras de E / S padrão e as brechas padrão são proibidas. Espaços à direita são permitidos.

Como se trata de código-golfe , a solução de shortes em bytes vence.

Aqui está um exemplo de programa em Python que funcionaria.

Python 2 , 26 bytes

from textwrap import*
fill

Experimente online!

Meh ... os internos são chatos ... em vez disso, tenha uma boa solução de 87 bytes aqui:

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

Experimente online!

Produz espaços à direita.

PHP , 8 bytes

É certo que não é a solução mais original, mas o PHP tem uma função nativa que atende perfeitamente aos seus requisitos!

wordwrap:

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

Agrupa uma sequência em um determinado número de caracteres usando um caractere de quebra de sequência.

Use assim:

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

Ou Experimente online!

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

Experimente online!

Variáveis

A saída formatada é armazenada em $o$ (em verde abaixo).

A linha atualizada $u$ é definida como a concatenação de:

• a linha atual $r$ (em preto abaixo)
• um espaço se $r$ não estiver vazio ou nada mais (em laranja abaixo)
• a nova palavra $w$ (em azul abaixo)

Precisamos inserir uma quebra de linha sempre que o $n$ ésimo caractere de $u$ for definido (indexado 0, em vermelho abaixo).

Exemplo

$n=16$ e$s$ = "Lorem Ipsum DOLOR"

Adicionando "LOREM":

Adicionando "IPSUM":

Adicionando "DOLOR":

Perl 6 , 46 29 bytes

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

Experimente online!

Solução baseada em Regex que recebe entrada com curry, gosta f(n)(s)e retorna uma lista de linhas. Cada linha, exceto a última, possui um espaço em branco à direita

Explicação:

{;*                         }   # 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 / pressionamentos de tecla

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

Uma pergunta sobre formatação de texto? Eu sei exatamente a ferramenta para o trabalho! E ainda tem meu nome nas duas primeiras teclas: D

<C-r>meios ctrl-r.

Isso pode ser um pouco mais curto no V , mas eu prefiro responder no vanilla vim para obter respostas que realmente mostrem como o vim conciso pode ser o desafio certo. E a diferença é tão pequena de qualquer maneira.

Também pode ser o seguinte para 15 bytes:

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

Experimente online!

R , 36 27 bytes

R tem isso como um built-in ( strwrap), retornamos um vetor de linhas de divisão.

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

Experimente online!

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

Experimente online!

Java (JDK) , 46 44 bytes

Basicamente, uma solução de regex pura em Java, quase certamente a mais curta que já escrevi.

Um brinde a Kevin por ajudar a reduzir ainda mais os bytes no regex!

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

Experimente online!

Usando um lamdba com caril, ele cria uma regex para corresponder avidamente a ncaracteres seguidos por um espaço ou final de sequência. Em seguida, substitui esses caracteres por si mesmos, seguidos por uma nova linha.

Mathematica, 16 bytes

InsertLinebreaks

Função incorporada. Pega uma string e um número inteiro como entrada e retorna uma string como saída.

InsertLinebreaks["string", n]
 insere caracteres de nova linha para não deixar mais que n caracteres.

Powershell, 40 83 bytes

Caso de teste n=80adicionado.

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

Script de teste:

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

Saída:

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

Experimente online!

Graças ao ceilingcat , salve 2 bytes movendo global char*lpara o parâmetro

Japonês , 20 bytes

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

Experimente online!

Obrigado a Bubbler e Shaggy pela ajuda

Explicação:

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

Experimente online! Toma se nem linhas separadas. Explicação:

.+$
$*

Converta npara unário.

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

Combine os espaços não em branco e, em seguida, olhe para a frente ne conte-os como $#1. Em seguida, volte e use um grupo de equilíbrio para corresponder aos ncaracteres seguidos por espaços em branco.

!`

Produza as correspondências como uma lista de linhas.

Carvão , 19 bytes

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

Experimente online! Link é a versão detalhada do código. Recebe entrada de ne sem linhas separadas. Explicação:

Ｎθ

Entrada n.

←

Mova o cursor para a esquerda um quadrado para equilibrar o movimento certo desde a primeira iteração do loop.

Ｆ⪪Ｓ «

Divida a string em espaços e faça um loop sobre as palavras.

¿‹⁺Ｌιⅈθ

Calcule se a próxima palavra alcançará a borda direita.

Ｍ→

Caso contrário, mova um quadrado para a direita.

⸿

Se ele iniciar uma nova linha.

ι

Saída a palavra.

Vermelho , 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]

Experimente online!

05AB1E , 18 bytes

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

Experimente online.

Explicação:

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

Experimente online.

Explicação:

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

Experimente online!

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

Função Infix; argumento da esquerda é n, argumento da direita é n.

⎕CY'dfns'⋄wrap

Experimente online!

⎕CY c op y na biblioteca dfns

⋄ então

wrap^[c]  usar o envoltório ^[n] função

^[c]  código dessa função
^[n]  notas para essa função

Versão golfada de wrap, 59 bytes ^SBCS

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

Experimente online!

{... } dfn; ⍺é argumento à esquerda (largura), ⍵é argumento à direita (string)

 ≢⍵ registro (número de caracteres) da sequência

 ⍺≥… : Se a largura for maior ou igual a isso, então:

  ⍵ retornar a string

 ⋄ de outra forma:

  ' '=⍵ Máscara booleana em que os espaços em branco são iguais à string

  b← armazenar em b(para b lanks)

  (… )↑ Use o seguinte número de elementos:

   ⍺+1 um a mais que a largura

  ⍸ i ndices onde a verdadeira

  g← armazenar em g(para g aps)

  ⍺≥ Máscara booleana em que a largura é maior ou igual à

  g/⍨ filtrar os índices de gap por esse

  ⍺, acrescente isso à largura

  ⊃⌽ escolha o último elemento disso (lit. escolha o primeiro dos invertidos)

  t← loja em t(para t ake)

  b⊃⍨ use isso para escolher um elemento da máscara de b lanks

  t+ adicione isso a t

  ⍵↓⍨ solte muitos caracteres da string

  ⍺∇ recaia sobre isso com o mesmo argumento à esquerda

  ⎕TC, acréscimo que à lista de t erminal c ontrolo caracteres (8: HT, 10: NL, 13: CR)

  2↓ elimine os dois primeiros caracteres (deixando apenas 13: CR)

  (… ), Anexa isso ao seguinte:

   t↑⍵ os primeiros tcaracteres da string

Graças a @Erik the Outgolfer, uma versão para golfe:

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

Experimente online!

# 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

Experimente online!

Versão não tão golfe ...

JavaScript + HTML + CSS, 117 64 bytes

-53 bytes, cortesia 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)

Gelatina , 12 bytes

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

Experimente online!

Infelizmente, é muito lento para trabalhar no caso de teste fornecido em menos de um minuto no 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");}}

Essa função usa um regex que corresponde ao espaço em branco mais próximo que fica perto do enésimo ou múltiplo de enésimo caractere e divide a sequência com base nele.

Experimente online!

O link TIO é um programa completo e a função possui uma palavra-chave estática para que a função possa ser chamada de main.

Regex de teste

C # (compilador interativo do Visual C #) , 78 bytes

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

Experimente online!

O crédito vai para @LukeStevens por ter apresentado a versão Java ... Aparentemente, o .NET faz com que você importe o RegularExpressionsnamespace para fazer uma substituição :(

Aqui está minha versão original que se divide no caractere de espaço e usa o LINQ para juntá-los novamente:

C # (compilador interativo do Visual C #) , 91 bytes

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

Experimente online!

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

Experimente online!

APL (NARS), 48 caracteres, 96 bytes

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

teste:

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

A função deste exercício b (a, n) quebraria a linha "a", como o exercício disse, de forma a não alterar seu comprimento (se vemos o resultado como uma sequência), porque alteramos alguns espaços em \ n ou nova linha em Lugar, colocar. A string de entrada "a" também não deve ter nenhum caractere \ n para a função b () (poderia ter \ n na string de entrada para bs ())

A função b (a, n) seria aceitável apenas porque a restrição deste exercício, que impõe cada palavra de "a", tem comprimento <n se isso não for verdade, essa função pode ir
para um loop infinito ... (muito errado no meu modo de ver, então eu copio também a função mais boa porque nesse caso retornaria -1 e não iria para um loop infinito; é bs (a, n) abaixo) não excluo ambas as funções estão com erros .. .

#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 () passado em uma função que adiciona comprimento de linha a cada linha

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]