（注意：这是我有史以来第一个关于高尔夫的代码问题，但是据我所知，没有人能完全做到这一点，所以我应该很好。）

您的任务是制作一个程序或函数，该程序或函数接受一个字符串s和一个整数n，并返回或输出包装成多行的文本。每个单词必须全部在一行上；即中间没有字。每行的n字符长度不能超过字符，并且每行中必须包含尽可能多的单词。

例：

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.

您的输出可以是字符串数组或带换行符的单个字符串。此外，您可以假设所有单词的长度n都不能超过，因此不必担心处理奇怪的情况。

适用标准I / O规则，禁止出现标准漏洞。允许尾随空格。

由于这是代码高尔夫球，因此以字节为单位的短裤解决方案将获胜。

这是一个可以运行的Python示例程序。

Python 2，26个字节

from textwrap import*
fill

在线尝试！

嗯...内置程序很无聊...相反，这里有一个不错的87字节解决方案：

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

在线尝试！

输出尾随空格。

PHP，8字节

诚然，这不是最原始的解决方案，但是PHP具有与您的要求完全匹配的本机功能！

wordwrap：

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

使用换行符将字符串包装为给定数量的字符。

像这样使用：

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

或在线尝试！

JavaScript（ES6）， 75 73  72字节

将输入作为(string)(n)。

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

在线尝试！

变数

格式化后的输出存储在$o$（以下绿色）。

更新的行$u$定义为以下内容的串联：

• 当前行$r$（下方黑色）
• 如果$r$不为空，则为一个空格，否则为空（下面的橙色）
• 新单词$w$（下面的蓝色）

每当设置u的第$n$个字符（索引为0，在下面的红色为红色）时，我们都需要插入换行符。$u$

例

$n=16$和$s$ =“ LOREM IPSUM DOLOR”

添加“ LOREM”：

添加“ IPSUM”：

添加“ DOLOR”：

Perl 6的，46 29个字节

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

在线尝试！

基于正则表达式的解决方案，采用咖喱输入法，f(n)(s)并返回行列表。除最后一行外，每行都有尾随空格

说明：

{;*                         }   # 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个字节/击键

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

文本格式问题？我只知道这份工作的工具！在前两次按键中它甚至都有我的名字：D

<C-r>意味着ctrl-r。

这可能曾经在V SO略短，但我更喜欢香草VIM回答的答案，真正炫耀如何简洁Vim可以为右挑战。而且无论如何差异都很小。

对于15个字节，也可能是以下内容：

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

在线尝试！

R，36 27字节

R将其作为内置（strwrap），我们返回分割线的向量。

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

在线尝试！

Haskell，70个字节

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

Python 2，74个字节

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

在线尝试！

Java（JDK），46 44字节

基本上，这是Java中的纯正则表达式解决方案，几乎可以肯定是我写的最短的正则表达式解决方案。

感谢Kevin帮助进一步减少正则表达式中的字节！

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

在线尝试！

使用咖喱的lamdba，它创建一个正则表达式来贪婪地匹配n字符，后跟空格或字符串结尾。然后，将其替换为这些字符，然后再换行。

Mathematica，16个字节

InsertLinebreaks

内置功能。接受一个字符串和一个整数作为输入，并返回一个字符串作为输出。

InsertLinebreaks["string", n]
 插入换行符，以使行的长度不能超过n个字符。

Powershell，40 83字节

n=80添加了测试用例。

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

测试脚本：

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

输出：

True
True

C（gcc），68个字节

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

在线尝试！

多亏了ceilingcat，通过将global char*l移至参数可以节省2个字节。

Japt，20字节

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

在线尝试！

感谢Bubbler和Shaggy的帮助

说明：

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

视网膜0.8.2，37字节

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

在线尝试！注意到s和n在单独的行。说明：

.+$
$*

转换n为一元。

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

匹配非空格，然后向前看n并算作$#1。然后返回并使用一个平衡组来匹配最多n字符，后跟空格。

!`

将匹配项输出为行列表。

木炭，19字节

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

在线尝试！链接是详细版本的代码。分别输入n和的输入s。说明：

Ｎθ

输入n。

←

将光标向左移动一个正方形，以平衡循环第一次迭代后的向右移动。

Ｆ⪪Ｓ «

在空格处分割字符串，然后在单词上循环。

¿‹⁺Ｌιⅈθ

计算下一个单词是否会到达右边缘。

Ｍ→

如果不会，则向右移动一个正方形。

⸿

如果它将开始新的一行。

ι

输出单词。

红色，125，117，114112字节

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]

在线尝试！

05AB1E，18 个字节

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

在线尝试。

说明：

õ                   # 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字节

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

在线尝试。

说明：

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个字节

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

在线尝试！

APL（Dyalog Unicode），14 字节^SBCS

中缀功能；左参数是n，右参数是n。

⎕CY'dfns'⋄wrap

在线尝试！

⎕CY dfns库中的c op y

⋄ 然后

wrap^[c]  使用wrap ^[n]函数

^[c]  该功能的代码
^[n]  该功能的注意事项

的高尔夫版本wrap，59 字节^SBCS

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

在线尝试！

{… } dfn；⍺是左参数（宽度），⍵是右参数（字符串）

 ≢⍵ 字符串计数（字符数）

 ⍺≥… : 如果宽度大于或等于该宽度，则：

  ⍵ 返回字符串

 ⋄ 除此以外：

  ' '=⍵ 布尔掩码，其中空格等于字符串

  b← 存储在b（对于b lanks）

  (… )↑ 从中选择以下元素：

   ⍺+1 比宽度多一

  ⍸ 我发现真正的地方

  g← 储存在g（用于g aps）

  ⍺≥ 宽度大于或等于该宽度的布尔蒙版

  g/⍨ 以此过滤间隙指数

  ⍺, 附加到宽度

  ⊃⌽ 选择该元素的最后一个元素（点亮。选择反转的第一个元素）

  t← 存储在t（对于吨 AKE）

  b⊃⍨ 用它来从该掩模选择一个元素b lanks

  t+ 加上 t

  ⍵↓⍨ 从字符串中删除那么多字符

  ⍺∇ 用相同的left-left参数递归

  ⎕TC, 追加，为的列表吨端子Ç ONTROL字符（8：HT，10：NL，13：CR）

  2↓ 从中删除前两个字符（仅保留前导13：CR）

  (… ), 追加到以下内容：

   t↑⍵t字符串 的第一个字符

感谢@Erik the Outgolfer，一个高尔夫版本：

Python 3，94个字节

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

在线尝试！

＃Python 3中，130个字节

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

在线尝试！

不太高尔夫版本...

JavaScript + HTML + CSS，117 64字节

-53字节@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)

果冻，12字节

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

在线尝试！

不幸的是，对于在TIO不到一分钟的时间内提供的测试用例，这太慢了。

C＃（.NET Core），162字节

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

此函数使用一个正则表达式，该正则表达式与最接近第n个字符或第n个字符的倍数的空格匹配，并根据该字符串分割字符串。

在线尝试！

TIO链接是一个完整程序，该函数具有静态关键字，因此可以从main调用该函数。

测试正则表达式

C＃（Visual C＃交互式编译器），78字节

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

在线尝试！

感谢@LukeStevens提出Java版本...显然.NET使您导入RegularExpressions名称空间以进行替换:(

这是我的原始版本，该版本拆分空格字符并使用LINQ将它们重新结合在一起：

C＃（Visual C＃交互式编译器），91字节

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

在线尝试！

飞镖，112字节

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

在线尝试！

APL（NARS），48个字符，96个字节

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

测试：

  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字节

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

练习b（a，n）的功能将按照练习中的说明打断“ a”行，因为不会更改其长度（如果我们将结果视为一个字符串），因为更改了\ n中的某些空格或其中的新行地点。对于b（）函数，输入字符串“ a”中也不应包含\ n字符（对于bs（），输入字符串中也可能包含\ n）

b（a，n）函数之所以可行，仅是因为此练习的局限性，即强加“ a”字符串的每个单词的长度<n，如果不正确，则该函数可以进入
一个无限循环...（非常我的看法是错误的，所以我也复制了更好的函数，因为在那种情况下将返回-1并且不会进入一个无限循环;下面是bs（a，n））我不排除两个函数都被窃听了。 。

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

b（）在传递给每行加长行的一个函数上的结果

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]