(Remarque: il s'agit de ma première question de golf par code, mais pour autant que je sache, personne d'autre n'a fait exactement cela, donc je devrais être bon.)

Votre tâche consiste à créer un programme ou une fonction qui accepte une chaîne set un entier n, et renvoie ou génère ce texte encapsulé sur plusieurs lignes. Chaque mot doit être entièrement sur une ligne; c'est-à-dire aucun mot divisé au milieu. Chaque ligne ne peut pas dépasser plus de ncaractères et vous devez insérer autant de mots que possible sur chaque ligne.

Exemple:

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.

Votre sortie peut être un tableau de chaînes ou une seule chaîne avec des sauts de ligne. En outre, vous pouvez supposer qu'aucun mot ne sera plus long que n, alors ne vous inquiétez pas de traiter des cas étranges.

Les règles d'E / S standard s'appliquent et les failles standard sont interdites. Les espaces de fin sont autorisés.

Puisqu'il s'agit de code-golf , la solution de shortes en octets l'emporte.

Voici un exemple de programme en Python qui fonctionnerait.

Python 2 , 26 octets

from textwrap import*
fill

Essayez-le en ligne!

Meh ... les intégrés sont ennuyeux ... à la place, ayez une belle solution de 87 octets ici:

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

Essayez-le en ligne!

Génère des espaces de fin.

PHP , 8 octets

Certes pas la solution la plus originale, mais PHP a une fonction native qui correspond parfaitement à vos besoins!

wordwrap:

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

Encapsule une chaîne dans un nombre donné de caractères à l'aide d'un caractère de rupture de chaîne.

Utilisez comme ça:

$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 essayez-le en ligne!

JavaScript (ES6),  75 73  72 octets

Prend l'entrée comme (string)(n).

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

Essayez-le en ligne!

Variables

La sortie formatée est stockée dans $o$ (en vert ci-dessous).

La ligne $u$ mise à jour est définie comme la concaténation de:

• la ligne actuelle $r$ (en noir ci-dessous)
• un espace si $r$ n'est pas vide, ou rien d'autre (en orange ci-dessous)
• le nouveau mot $w$ (en bleu ci-dessous)

Nous devons insérer un saut de ligne à chaque fois que le $n$ caractère -ème de $u$ est défini (0 indexées, en rouge ci - dessous).

Exemple

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

Ajout de "LOREM":

Ajout "IPSUM":

Ajout de "DOLOR":

Perl 6 , 46 29 octets

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

Essayez-le en ligne!

Solution basée sur Regex qui prend les entrées au curry, comme f(n)(s)et renvoie une liste de lignes. Chaque ligne sauf la dernière a un espace de fin

Explication:

{;*                         }   # 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 octets / touches

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

Une question de mise en forme du texte? Je connais juste l'outil pour le travail! Et il a même mon nom dans les deux premières touches: D

<C-r>signifie ctrl-r.

Cela pourrait être un peu plus court en V , mais je préfère répondre en vanilla vim pour des réponses qui montrent vraiment à quel point vim peut être concis pour le bon défi. Et la différence est si petite de toute façon.

Cela pourrait également être le cas pour 15 octets également:

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

Essayez-le en ligne!

R , 36 27 octets

R a ceci comme intégré ( strwrap), nous retournons un vecteur de lignes divisées.

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

Essayez-le en ligne!

Haskell , 70 octets

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

Python 2 , 74 octets

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

Essayez-le en ligne!

Java (JDK) , 46 44 octets

Fondamentalement, une solution regex pure en Java, presque certainement la plus courte que j'ai écrite.

Bravo à Kevin pour avoir aidé à réduire encore plus les octets dans l'expression régulière!

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

Essayez-le en ligne!

En utilisant un lamdba au curry, il crée une expression régulière pour correspondre avec avidité aux ncaractères suivis d'un espace ou d'une fin de chaîne. Il remplace ensuite ces caractères par eux-mêmes suivis d'une nouvelle ligne.

Mathematica, 16 octets

InsertLinebreaks

Fonction intégrée. Prend une chaîne et un entier en entrée et renvoie une chaîne en sortie.

InsertLinebreaks["string", n]
 insère des caractères de nouvelle ligne pour ne pas faire plus de ligne que n caractères.

Powershell, 40 83 octets

Cas de test avec n=80ajout.

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

Script de test:

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

Sortie:

True
True

C (gcc) , 68 octets

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

Essayez-le en ligne!

Grâce à plafondcat , économisez 2 octets en déplaçant globalement char*lsur paramètre.

Japt , 20 octets

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

Essayez-le en ligne!

Merci à Bubbler et Shaggy pour leur aide

Explication:

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

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

Essayez-le en ligne! Prend set nsur des lignes séparées. Explication:

.+$
$*

Convertissez nen unaire.

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

Faites correspondre les espaces non blancs, puis regardez en avant net comptez comme $#1. Revenez ensuite en arrière et utilisez un groupe d'équilibrage pour faire correspondre les ncaractères suivis d'espaces.

!`

Sortez les correspondances sous forme de liste de lignes.

Fusain , 19 octets

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

Essayez-le en ligne! Le lien est vers la version détaillée du code. Prend l'entrée de net ssur des lignes distinctes. Explication:

Ｎθ

Entrée n.

←

Déplacez le curseur vers la gauche d'un carré pour équilibrer le mouvement de droite à partir de la première itération de la boucle.

Ｆ⪪Ｓ «

Divisez la chaîne sur les espaces et faites une boucle sur les mots.

¿‹⁺Ｌιⅈθ

Calculez si le mot suivant atteindra le bord droit.

Ｍ→

Si ce n'est pas le cas, déplacez-vous d'un carré vers la droite.

⸿

S'il démarre alors une nouvelle ligne.

ι

Sortez le mot.

Rouge , 125, 117, 114 112 octets

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]

Essayez-le en ligne!

05AB1E , 18 octets

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

Essayez-le en ligne.

Explication:

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

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

Essayez-le en ligne.

Explication:

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 octets

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

Essayez-le en ligne!

APL (Dyalog Unicode) , 14 octets ^SBCS

Fonction Infix; l'argument de gauche est n, l'argument de droite est n.

⎕CY'dfns'⋄wrap

Essayez-le en ligne!

⎕CY c op y dans la bibliothèque dfns

⋄ puis

wrap^[c]  utiliser l'enveloppe ^[n] fonction

^[c]  code de cette fonction
^[n]  notes pour cette fonction

Version golfée de wrap, 59 octets ^SBCS

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

Essayez-le en ligne!

{… } Dfn; ⍺est l'argument gauche (largeur), ⍵est l'argument droit (chaîne)

 ≢⍵ décompte (nombre de caractères) de la chaîne

 ⍺≥… : Si la largeur est supérieure ou égale à celle-ci, alors:

  ⍵ retourner la chaîne

 ⋄ autrement:

  ' '=⍵ Masque booléen où les blancs sont égaux à la chaîne

  b← stocker dans b(pour b lanks)

  (… En )↑ tirer le nombre d'éléments suivant:

   ⍺+1 un de plus que la largeur

  ⍸ i ndices où vrai

  g← stocker dans g(pour g aps)

  ⍺≥ Masque booléen dont la largeur est supérieure ou égale à celle

  g/⍨ filtrer les indices d'écart par ce

  ⍺, ajouter cela à la largeur

  ⊃⌽ choisissez le dernier élément de cela (lit. choisissez le premier de l'inverse)

  t← stocker t(pour t ake)

  b⊃⍨ utilisez-le pour choisir un élément du masque des bords b

  t+ ajouter cela à t

  ⍵↓⍨ supprimer autant de caractères de la chaîne

  ⍺∇ recurse sur cela avec le même argument gauche gauche

  ⎕TC, Ajout qui a la liste des t erminal c ontrol caractères (8: HT, 10: NL, 13: CR)

  2↓ enlevez les deux premiers caractères de cela (en laissant juste un 13: CR)

  (… ), Joignez cela à ce qui suit:

   t↑⍵ les premiers tcaractères de la chaîne

Merci à @Erik the Outgolfer, une version golfée:

Python 3 , 94 octets

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

Essayez-le en ligne!

# Python 3 , 130 octets

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

Essayez-le en ligne!

Version pas si golfée ...

JavaScript + HTML + CSS, 117 64 octets

-53 octets avec l'aimable autorisation 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)

Gelée , 12 octets

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

Essayez-le en ligne!

Malheureusement, cela est trop lent pour fonctionner pour le cas de test fourni en moins d'une minute sur TIO.

C # (.NET Core) , 162 octets

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

Cette fonction utilise une expression régulière qui correspond à l'espace blanc le plus proche qui est proche du nième ou multiple du nième caractère et fractionne la chaîne en fonction de celui-ci.

Essayez-le en ligne!

Le lien TIO est un programme complet, et la fonction a un mot-clé statique afin que la fonction puisse être appelée à partir de main.

Test Regex

C # (Visual C # Interactive Compiler) , 78 octets

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

Essayez-le en ligne!

Nous remercions @LukeStevens d'avoir proposé la version Java ... Apparemment .NET vous fait importer l' RegularExpressionsespace de noms afin de faire un remplacement :(

Voici ma version originale qui se divise sur le caractère espace et utilise LINQ pour les réunir à nouveau:

C # (Visual C # Interactive Compiler) , 91 octets

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

Essayez-le en ligne!

Fléchette , 112 octets

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

Essayez-le en ligne!

APL (NARS), 48 caractères, 96 octets

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

tester:

  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 octets

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

La fonction de cet exercice b (a, n) romprait la ligne "a" comme dit l'exercice, de la même manière que sa longueur ne changerait pas (si nous voyons le résultat comme une chaîne) car changer certains espaces dans \ n ou une nouvelle ligne dans endroit. La chaîne d'entrée "a" ne devrait pas avoir de caractère \ n également pour la fonction b () (elle pourrait avoir \ n dans la chaîne d'entrée pour bs ())

La fonction b (a, n) ne serait correcte que parce que la restriction de cet exercice, qui impose que chaque mot d'une chaîne "a" a une longueur <n si ce n'est pas vrai, cette fonction peut aller
à une boucle infinie ... (très mal dans ma façon de voir donc je copie aussi la fonction plus bien car dans ce cas retournerait -1 et non irait à une boucle infinie; c'est bs (a, n) ci-dessous) je n'exclus pas les deux fonctions sont buggées .. .

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

résultat de b () passé sur une fonction qui ajoute la longueur de ligne à chaque ligne

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]