选择一个正好5个字长的引号或词组，例如Programming puzzles and code golf!。

编写一个程序，将其附加n次后，依次输出该短语的前n + 1个单词。

例如，如果您的程序代码为，MYPROG而短语为Programming puzzles and code golf!，则正在运行...

• MYPROG 应该输出 Programming
• MYPROGMYPROG 应该输出 Programming puzzles
• MYPROGMYPROGMYPROG 应该输出 Programming puzzles and
• MYPROGMYPROGMYPROGMYPROG 应该输出 Programming puzzles and code
• MYPROGMYPROGMYPROGMYPROGMYPROG 应该输出 Programming puzzles and code golf!

超过4次是不确定的，您的程序可以执行任何操作。

规则

• 您的短语必须是语法有意义的英语。理想情况下，应适当大写并标点符号。
• 你的短语可以是任意长度，但它的熵，通过计算公式http://www.shannonentropy.netmark.pl/，可能不小于3.5。
  （粘贴您的短语，点击“ 计算”并寻找最后一个H（X）。）
• 您的词组只能包含可打印的ASCII字符（20到7E十六进制）。您的代码只能包含可打印的ASCII以及制表符和换行符。
• 您的词组必须恰好包含5个唯一词和4个空格。所有非空格都算作单词的一部分。空格是单词边界。他们可能不在前面或后面；除了最后的话，应该还有一个。
• 输出也应在单词之间包含一个空格。每个附加步骤的输出可能包含尾随空格，但不包含前导空格。
• 输出到标准输出。没有输入。

计分

分数是初始未附加程序的字节长度。（例如，MYPROG得分6）

因为这是代码高尔夫球，所以最低分获胜。

果酱-24

"TheguywasnotI"Lm3<]S*:L

在http://cjam.aditsu.net/上尝试

说明：

Lm从“ TheguywasnotI”中删除L中包含的字母（最初为“”），
3<将前3个字母
]收集到数组中堆栈的内容中，并
S*使用空格作为分隔符
:L将数组加入数组，并将结果字符串分配给L（也将其保留在堆栈中）

旧版本（28个字节）：

"He is but a dog."S/W):W=]S*

说明：

S/按空间
W):W增量W 分割（最初为W = -1），
=得到第W个单词，
]收集数组中堆栈的内容，并
S*使用空格作为分隔符加入数组

彼得（荣誉答案）

蜿蜒向下，从右边穿过蓝色，然后从绿色重新进入。打印出“水果像香蕉一样飞”。

我使用了PietCreator进行制作，但您可以在此处尝试。重建Piet程序很痛苦，所以我以35x35开始，然后继续这种方式，这意味着我使用了比我需要的代码更多的代码。

实际尺寸版本

> <>（42）

鱼确实是最伟大的宠物。由于无法理解的缺乏逻辑，有些人将虫子当作宠物。该程序尽力与此类人员进行推理。

!v'?od gub yna nac tahW;'00p!
<<|ov!
voo <

请注意，该程序中没有尾随换行符。全部输出在第一行中反转；完整的短语是“任何错误都可以做什么？” （熵3.58418）。

完整说明：

这是我编写的更有趣的> <>程序之一，因为这是第一个使用反射的程序。第一行是程序的内容所在。

!v是空操作，因为!会导致下一条指令被跳过。

'?od gub yna nac tahW;' 将完整的短语存储在堆栈上（它是向后的，因为每个字母都按写入顺序推入堆栈，因此必须反转才能很好地弹出）。

00p才是真正的魔术开始发生的地方。请注意，它不仅存储了短语，还存储了;。00p将顶部字符插入堆栈中程序的位置（0，0），因此程序的第一个字符为;。

末尾!跳过该分号，并将光标移到上v，从而将程序流向下定向。

从这里开始，一切都只是打印例程。由于没有尾随换行符，因此程序的连续追加实际上仅添加了最后两行，因为第一行将位于的右侧voo <，因此将永远不会执行。

最后，将光标移到程序的左下角，然后回绕到左上角，该;位置早先插入到该位置，从而结束了该程序。

Python 66

i='i'in dir()and i+1;print("Tfpcfhaialetgny"[i::5],end=" ."[i>3]);

熵：3.61635

输出：

The fat pig can fly.

感谢@JasonS和@grc提供了缩短变量检测部分的提示。

更新：请参阅JasonS的答案，了解一个邪恶的环绕技巧，将其压缩到55个字节。:)

Python 3，55（奖金67）

# 55 bytes, H(X)=3.72, Based on bitpwner's 66. "Mix dog and cat fur."
i=0;print("Mdacfionauxgdtr"[i::5],end=" ."[i>3]);i+=1;i

# 67 bytes, H(X)=4.28. "Thanks for supporting Python development."
q=b"qx!%%0077C";a,b,*q=q;print((str(credits)*2)[49:][a:b],end='');q

# 60 bytes, H(X) = 3.51. "Fix the bed old pal"
s="Fixthebedoldpal";a,b,c,*s=s;print(a+b+c,end='. '[s>[]]);s

你的意思是它环绕吗？

好，关于＃2（扰流板）的一些解释

• credits是python内置的，包含我想使用的文本。它是一种特殊的格式，repr因此您可以在交互式解释器中键入它，然后看到不错的输出，所以我必须这样str()做。我花了很多时间在此方面查看内置函数，而“感谢支持Python开发”这句话太好了而无法通过。

• 由于文本很多，我只想输入5个字，因此我想存储每个子字符串的开始和结束位置。那是在开始的字节。bytes当您在python3上使用序列运算时，它们的作用类似于整数数组。

• 但是代码只能包含可打印的字符，因此我必须找到一个偏移量（49），该偏移量可使我所有的位置值都可打印为字符。

• “谢谢”在字符串的开头附近，而其他单词则在​​结尾附近，这意味着我的位置值相距太远，无法全部位于可打印范围内。将字符串乘以2将使另一个词“ Thanks”更接近其他词。

• [49:]与对a和b都加上49相比，获取字符串的切片要少一个源字节。

• 这三个答案中使用的构造为x=<value>;dostuff and increment;x。尾随x根本不执行任何操作，但是当与下一个代码副本结合使用时，它会变成xx=<value>可防止x计数器被覆盖的代码。

• a,b,*q=q 是完全正常的Python 3序列解压缩。

的Python 2（37）

莎拉（Sarah）担任当地Mensa分会会长后，她成为了寻找聪明伴侣的男人的浪漫关注焦点。在每个约会中，莎拉都会尝试建立个人关系，但是男人们只会在严肃的哲学问题上探究她。她大惊失色，没有人关心她的情感面，她惊呼...

i=4;print"mniIMeosQy!t"[i::5],;i-=1;i

输出：

My
My IQ
My IQ is
My IQ is not
My IQ is not me!

熵是H(x)=3.5准确的。

归功于Jason S.，我的回答基本上是批发。在ii环绕诀窍是美妙的。

C-65

评论滥用:)

char*z="Ah, \0the \0good \0ol' \0times!";
for(printf(z);*z++;);//

因此，新行很重要，应将代码附加如下：

char *z="Ah, \0the \0good \0ol' \0times!";
for(printf(z);*z++;);//char *z="Ah, \0the \0good \0ol' \0times!";
for(printf(z);*z++;);//...

CJam，24个字节

"LwOtmiaKoezs"W):W>5%]S*

如果运行五次，它会打印Liz对我来说还可以。不包括标点符号，对不起。

怎么运行的

"LwOtmiaKoezs"  " Push that string. ";
W):W            " Push W (initially -1), increment and save the result in W. ";
>               " Shift that many characters from the string. ";
5%              " Select every fifth character, starting with the first. ";
]S*             " Wrap the stack in an array and join its strings using spaces. ";

珀斯 32

p?kqZ4d@P"It is by a rope."dZ~Z1

短语：“是用绳子绑起来的。”

熵3.5

怎么运行的：

p 表示使用指定的分隔符打印。

第一个参数?kqZ4d给出分隔符。?kqZ4d意味着k if Z==4 else d。k是''，d而是' '。

第二个参数，即要打印的值，是通过P在空格（d）上分割（）并在处索引到该列表（@）生成的Z。

最后，Z自动初始化为0的，将增加1（~Z1）。

Golfscript，53岁

这个很有趣。

{'1'-print}:puts;.'You; are; not; a; duck.'';'/\,=\1+

短语：“你不是鸭子。” （完全正确；熵3.5110854081804286）

说明：

堆栈将从''第一个“运行”开始（因为未提供STDIN）。'1's附加到此以表示代码已粘贴多少次。

{'1'-print}:puts;             # Hacky stuff (see below)
.                             # Stack: '' ''
'You; are; not; a; duck.'';'/ # Initialize the array of words
\,                            # Get the length of the string of '1's (0)
                              # Stack: '' [words] 0
=                             # Stack: '' 'You'
\1+                           # Stack: 'You' '1'

现在在第二次运行中会发生什么：

{'1'-print}:puts;             # Hacky stuff (see below)
.                             # Stack: 'You' '1' '1'
'You; are; not; a; duck.'';'/ # Initialize the array of words
\,                            # Get the length of the string of '1's (1)
                              # Stack: 'You' '1' [words] 1
=                             # Stack: 'You' '1' ' are'
\1+                           # Stack: 'You' ' are' '11'

等等。

“但是，”您在想，“如何获得不输出的1？” 啊，那是有趣的hacky部分。Golfscript实现puts（在程序结束时调用），如下所示：

{print n print}:puts;

我只是将其更改为

{'1'-print}:puts;

从而1从最终输出中抑制s。

J-42个字符

我可以简短地说一下，但是为什么呢？这不是我的最爱。

(#~1=6|#\)&.;: :,'You multiplied 6 by 9. '

之所以如此是因为J的monad / dyad对偶性：每个动词都可以作为monad调用（在其右侧带有一个自变量），也可以作为dyad调用，在左侧带有一个自变量，右侧带有另一个自变量。

考虑与J REPL进行以下会话：

   'You multiplied 6 by 9. '
You multiplied 6 by 9.
   'You multiplied 6 by 9. ' , 'You multiplied 6 by 9. '
You multiplied 6 by 9. You multiplied 6 by 9.
   ;: 'You multiplied 6 by 9. ' , 'You multiplied 6 by 9. '   NB. break into words
+---+----------+-+--+--+---+----------+-+--+--+
|You|multiplied|6|by|9.|You|multiplied|6|by|9.|
+---+----------+-+--+--+---+----------+-+--+--+
   (#\) ;: 'You multiplied 6 by 9. ' , 'You multiplied 6 by 9. '             NB. count off
1 2 3 4 5 6 7 8 9 10
   (6 | #\) ;: 'You multiplied 6 by 9. ' , 'You multiplied 6 by 9. '         NB. mod 6
1 2 3 4 5 0 1 2 3 4
   (1 = 6 | #\) ;: 'You multiplied 6 by 9. ' , 'You multiplied 6 by 9. '
1 0 0 0 0 0 1 0 0 0
   (#~ 1 = 6 | #\) ;: 'You multiplied 6 by 9. ' , 'You multiplied 6 by 9. '  NB. select
+---+----------+
|You|multiplied|
+---+----------+
   (#~ 1 = 6 | #\)&.;: 'You multiplied 6 by 9. ' , 'You multiplied 6 by 9. ' NB. undo ;:
You multiplied

在那里，,被视为二元组，因为它在两个自变量之间，而(#~1=6|#\)&.;:由于它没有左自变量，所以被视为单子。因此，如果我们有一个动词可以像,二进和(#~1=6|#\)&.;:单动时一样，我们就会被设定。

您可能已经猜到了，这样的连接存在并且看起来像:。Monadic f :g等效于f，并且等效于gdyadic。这样就解决了问题。

示例，您可以在tryj.tk上尝试：

   (#~1=6|#\)&.;: :,'You multiplied 6 by 9. '
You
   (#~1=6|#\)&.;: :,'You multiplied 6 by 9. '(#~1=6|#\)&.;: :,'You multiplied 6 by 9. '
You multiplied
   (#~1=6|#\)&.;: :,'You multiplied 6 by 9. '(#~1=6|#\)&.;: :,'You multiplied 6 by 9. '(#~1=6|#\)&.;: :,'You multiplied 6 by 9. '
You multiplied 6
   (#~1=6|#\)&.;: :,'You multiplied 6 by 9. '(#~1=6|#\)&.;: :,'You multiplied 6 by 9. '(#~1=6|#\)&.;: :,'You multiplied 6 by 9. '(#~1=6|#\)&.;: :,'You multiplied 6 by 9. '
You multiplied 6 by
   (#~1=6|#\)&.;: :,'You multiplied 6 by 9. '(#~1=6|#\)&.;: :,'You multiplied 6 by 9. '(#~1=6|#\)&.;: :,'You multiplied 6 by 9. '(#~1=6|#\)&.;: :,'You multiplied 6 by 9. '(#~1=6|#\)&.;: :,'You multiplied 6 by 9. '
You multiplied 6 by 9.

是的，逆的性质;:使得它没有尾随空格。

^{将其It is by a rope.用作短语可获得35个字符：(#~1=6|#\)&.;: :,'It is by a rope.'。出于神秘;:的原因，我们不需要像我的句子那样使用尾随空格。}

BBC基础版40

包括一个换行符。如果关键字可以被认为是标记化而不是ASCII，则将为30。

我发现女友和送奶工一起睡觉，于是我抛弃了她，为了报仇又和姐姐一起睡觉。As my ex do I!（五个带有两个字符的两个字母的单词，带有唯一字符）还不够熵，因此我在结尾处添加了张开嘴的笑脸，以使熵恰好为3.5。毕竟，实际上我过着正常的生活，而不是一些奇怪的肥皂剧情节。

  READa$:PRINTa$;" ";
  DATAAs,my,ex,do,I:-P

重复执行5次程序

  READa$:PRINTa$;" ";
  DATAAs,my,ex,do,I:-P
  READa$:PRINTa$;" ";
  DATAAs,my,ex,do,I:-P
  READa$:PRINTa$;" ";
  DATAAs,my,ex,do,I:-P
  READa$:PRINTa$;" ";
  DATAAs,my,ex,do,I:-P
  READa$:PRINTa$;" ";
  DATAAs,my,ex,do,I:-P

仅执行5条READ语句，并且从第一条DATA语句中读取数据的前5条。其余数据是多余的。输出：

  (once)
  As 
  (5 times)
  As my ex do I:-P 

红宝石，50岁

puts'The fat pig can fly.'[0..File.size($0)/12-1]#

这使用自己的长度来确定要打印多少个单词。否则，其重复将以注释字符结束而被忽略#。从bitpwner借用的短语：在每个单词中都包含一个短短语且字母数相同的单词非常方便。

由于每个单词和结尾都是4个字符，因此该公式将是例如56个长度的程序：(File.size($0)/56)*4 - 1，但是我可以提前除以56/4 = 14，从而File.size($0)/14 - 1节省几个字符。50不是的倍数4，但12足够接近所需的范围。

芯片，165 + 3 = 168字节

国旗为+3 -w

| ,z `Z`Z  `Z
| |ZZZ>Z>ZZZ>ZZZZ
>((((((((((((((((
|)-)))-)-)))-))))g
|)d)xx-x-)xx-))x)e
||b+))-x-x))-x)xc
|`v))xa(-x(x-((^d
|*`.))d| b | b
|Z~<b( |~Zf|
>~T| | |   |

“我赢了一套红色西装”（3.5）（我实际上还没有赢过这样的东西）（...至今）

请注意尾随换行符，因此串联的副本将显示在现有代码的下方。

在线尝试！（原始）
在线尝试！（原件，加上所有四份副本）

这有点混乱。事实证明，最棘手的位是终止条件。（我的第一次迭代打印了单词，然后是无尽的空字节流...）。

怎么运行的

第一个词组：
12个唯一字符+ 4个空格=正好是3.5个熵。

代码：
每个副本打印第一个单词，然后告诉下面的副本打印下一个单词。如果只有一个实例，则不会有第二个副本，因此除了第一个单词以外，不会打印任何内容。

如果有两个副本，则两个副本将同时打印第一个单词（将字节进行“或”运算，这样就可以了），然后只有第二个副本将打印第二个单词。

如果存在全部五个副本，则所有副本都会打印第一个单词等，而第五个副本将单独打印最后一个单词。

一旦未主动打印所有副本，终止电路将终止程序。

Ruby，63岁

+1;puts"See Dick and Jane run!"[/(.*?( |!)){#$.}/]if($.+=1)==$.

Perl，37岁

print qw(My IQ is not me!)[$i++].' ';

与comperendinous相似，但是利用了perl的qw来保存更多字符。

Rebmu邮件长度+ 27

我们是否选择“我的智商不是我！” 那将是43。但是我支持以下消息：

uV?'s[S[{The}{rebellion}{against}{software}{complexity.}]]proTKsPROsp

等效Rebol /红色：

unless value? 's [
    s: [{The}{rebellion}{against}{software}{complexity.}]
]

print/only take s
print/only space

Rebol具有3个基本条件：IF，EITHER和UNLESS。除非等同于“不是”，否则等同于“但不是”，但可以更清楚地说明：“除非满足此条件，否则始终进行以下操作。”

在这种情况下，我们测试的条件是查看符号S在当前上下文中是否已被赋予值。我们必须在其上使用引号，因为尝试在条件表达式中使用未引号的S会对其求值，并且可能会引发错误。 （value?默认情况下不引用其参数，因为您可能希望将要检查的符号放在变量中，例如，sym: 's然后if value? sym [...]实际检查是否定义了S，而不是SYM）

仅程序的第一个粘贴将把字符串序列分配给S。连续粘贴将从序列的开头获取一个字符串，并将其传递给PRINT / ONLY，后者将打印其参数而无需添加换行符。

（注意：建议使用PRINT / ONLY代替PRIN，在Rebol 3和Red中考虑使用PRIN；现在正在Rebmu中测试打印替代品。）

AHK，44字节

i++
Send % SubStr("He is an OK ex",i*3-2,3)

注意最后的换行符。唯一聪明的地方是字符串全是3个字母的单词，因此我们不必拆分任何内容。相反，我们只是基于提取一个子字符串i。输出到活动屏幕，就像在键盘上键入一样。

Javascript（53）

我从aittsu那里获取了文本，因为我对文本没有任何幻想，因此所选单词与解决方案无关（字节数除外）。

var i=i|0;alert("He 0is 0but 0a 0dog".split(0)[i++]);

请问alert在这种情况下算？编辑：阅读规则可能不行，因为我没有用空格连接字符串。我将添加空格以使其公平。

还要注意，var在这种情况下，昂贵实际上是相关的。

佩尔（43）56

print substr'Mine was not Red 5!',4*$i++,4;

我接受我无法赢得这一奖项。我最初的尝试解释了原因：

@a=('This',' code',' is',' too',' long.');print$a[$i++];

罗阿（77）

一个非常简单的解决方案：

i=(i or 0)+1;io.write((i==1 and""or" ")..("Thebigfoxwasup."):sub(3*i-2,3*i))

（H（X）= 4.23）

Javascript，138

g=this;clearTimeout(g.t);g.i|=0;i++;g.t=setTimeout(
    function(){console.log(["I'll","sleep","when","I'm","dead."].slice(0,i).join(' '))},0);

（添加的新行仅出于可读性考虑）

印刷品I'll sleep when I'm dead。使用计时器确保输出仅打印一次

纯Bash，51个字节

a=(All you need is Love!)
printf "${i:+ }${a[i++]}"

高（X）= 3.59447

偷猎一个较短的词组可以使这更多一些，但是我很高兴坚持笛卡尔的列侬最著名的报价。（对不起@Descartes，但所有单词都必须是唯一的）。

输出：

$ ./phrase.sh 
All$ cat phrase.sh phrase.sh phrase.sh > phrase3.sh
$ chmod +x phrase3.sh 
$ ./phrase3.sh 
All you need$ 
$ cat phrase.sh phrase.sh phrase.sh phrase.sh phrase.sh > phrase.sh
$ chmod +x phrase5.sh 
$ ./phrase5.sh 
All you need is Love!$ 

注意在单词之间插入空格，但不要在前导或尾随空格。

依赖于以下事实：在bash中，未定义的变量在扩展为字符串时具有值“”，而在算术扩展时具有值0。

PHP 89 78个字符

它有点冗长，而且绝对肯定不会赢，但是还是很有趣。这是我想出的

短语：

code golf is pretty fun

熵= 3.82791

码：

<?
$i=(isset($i)?$i+1:0);
$w=["code","golf","is","really","fun"];
echo $w[$i].";

打高尔夫球：

<?$i=(isset($i)?$i+1:0);$w=["code","golf","is","really","fun"];echo $w[$i].

Python3-122字节

打开吊舱门[HAL]

我想我会用这个赚一些书呆子。如果仅这个问题允许再说一个话...

我的程序要做的是获取文件名（p.py是基本名称）并检查基本名称的迭代次数。然后，它从一串n时间中获取切片。n是p文件名中s 的数量。

import sys,re
for i in range(len(re.findall(re.compile('p'),sys.argv[0]))):print('Otpbdphoaoeedyon   r    s'[i::5],end='')

~ $ python p.py
Open

~ $ python pp.py
Open the

~ $ python ppp.py
Open the pod

~ $ python pppp.py
Open the pod bay

~ $ python ppppp.py
Open the pod bay doors

regex的好处在于，您可以随意调用该程序，并且该程序仍然可以运行（只要您更改代码中的基本名称）：我的原始程序称为golfed.py。

05AB1E，21字节（非竞争）

“€Œ‰‹€‡Øš‹É.“ª#¾è¼?ð?

在线尝试！

用途：

This works for literally anything. 
H(x) = 4.02086

说明

“€Œ‰‹€‡Øš‹É.“ª#¾è¼?ð?
“€Œ‰‹€‡Øš‹É.“ª        # Pushes "This works for literally anything."
              #       # Split on spaces
               ¾è     # get element at index of counter_variable (default 0)
                 ¼    # Increment the counter_variable
                  ?   # Print the selected element
                   ð? # Prints a space

Stax，24

`nH+~mJp@Z_Iy.5!`j|d:/dJ

运行并调试

Quote：有些动物更平等。

SmileBASIC，54个字节

DATA"Does"," anybody"," have"," a"," key?
READ W$?W$;

我本来希望“可以吃沙子”。但这使熵测试失败。当然，我可以选择一个简短的短语，但这很无聊。

的READ关键字读取的值DATA在变量，并将其存储。READ再次使用将获得下一个项目，依此类推。

Pyth，27个字节

p+@c"Andso,themanis."3Zd=hZ

一次，两次，三次，四次和五次。在此之后添加将开始重复该短语。