创建一个程序，该程序输出一个hello world字符串（“ Hello world”，“ Hello，World”等）和源代码。输出被写入标准输出或等效输出。Hello world字符串嵌入在源代码中。

例如，的输出可能是

(some source code here)hello world(some source code here)

再次编译或解释输出时，它应该创建类似的输出，但是hello world字符串必须具有不同的标点符号或大写字母。例如，上一个示例可以创建以下输出

(some source code here)hello, wORld(some source code here)

这些示例中的每个“（此处有一些源代码）”可以在每次执行后更改，也可以相同。

您的输出必须只包含一次有效的hello world字符串。它可能包含任意数量的无效的hello world字符串。源代码可以包含任意数量的注释，并且hello world字符串可以嵌入注释中。第一个程序可以有零个或一个有效的hello world字符串，但不能再有。

以下标点符号有效：

hello, world
hello world
helloworld

任何大写字母都可以接受。例如，以下是有效的hello world字符串：

Hello, world
hellO WORld
HELLoworlD

这些字符串无效：

Hello     world
Hello(newline)world
Hello,world
Hello, Steve

一旦满足以下条件之一，您的程序就会失败：

• 它输出一个Hello World字符串，该字符串在较早的执行过程中已经输出，
• 输出不再是使用相同语言的有效源代码，或者
• 输出不完全包含一个有效的hello world字符串。

除非至少有两次成功执行，否则您的程序对该竞赛无效。这意味着允许第三输出无效。程序的输出可能不是随机的。第一次执行应始终创建相同的第二输出，第二次执行应始终创建相同的第三输出，依此类推。

分数计算为初始程序源代码中的字节数。最低分获胜。

确实有以下奖金（最高-60％）：

• -5％*（N-2），其中N是执行的索引，之后程序将产生无效输出。此奖金上限为-50％。如果您的程序成功执行12次或以上，您将获得最高奖励。
• -10％（如果您的输出（包括第一个源代码）包括所有三个有效的标点符号替代项）。

您的提交应包含第一个源代码，并且还应包含成功执行的输出。如果您的程序成功执行12次以上，请添加输出以执行12次。

例

下一行是第一个源代码。当我们执行它时，它是第一次执行。

hello world(some source code here)

下一行是第一个源代码的输出。这是第一个输出。

hello, world(some source code here) 

下一行是第二次执行的输出。这是第二个输出。

helloworld(some source code here)

当我们执行第一个输出时，此程序有资格获得-10％的奖金。这意味着我们有两个输出和一个原始代码，它们都有不同的标点符号。此外，由于第二个输出有效，因此该程序有资格参加此竞赛。

下一行是第三次执行的输出。这是第三输出。

Helloworld(some source code here)

下一行是第四次执行的输出。这是第四输出。

hellworld(some source code here)

此输出无效。上次有效执行的索引为4。该程序的标点符号资格为-5％*（4-2）和-10％。这总计-20％。第一个源代码（“ hello world（此处为某些源代码）”）的长度为34个字节，因此最终得分为27.2。

Pyth，17个字节

不同的Pyth解决方案：

"r\"helloworld\"1

输出：

r"helloworld"1

第二个输出：

HELLOWORLD

Mathematica，214-50％= 107字节

(a = Characters[StringJoin["helloworl", "d"]]; b = Apply[StringJoin, Tuples[Transpose[{a, ToUpperCase[a]}]], {1}]; StringReplacePart[ToString[#0, InputForm], b[[FirstPosition[b, "helloworld"] + 1]], {180, 189}]) & 

我决定在这里优化字符串计数。它可以不停地运行1024个程序，并通过大写和小写字母的每种组合进行操作。执行可以在这里看到。

Vitsy，33-33 * .05 *（11-2）= 18.15字节

h！打败那个！你可能会的。：C

第一输出：

'0DV \ {25 ^ -V \}} 1+ {rd3 * Z; helloworld
'开始捕获为字符串
 0DV将0压入堆栈并将其设置为最终变量。
    \重复下一个项目多次。（在输出上有1，2，3 ...）
     {向左旋转纸叠。
      25 ^将32推入堆栈。
         -用它减去顶项-这将使小写大写。
          V \执行下一项最终变量时间。
            }向右旋转堆栈。
             } 然后再次...
              1+加一个。这使得该代码中的0变为1，然后变为2 ...
                r反转堆栈。
                 d3 *获取字符“
                    Z输出堆栈中的所有项目。
                     ; 结束执行。
                      helloworld要操作的字符串。

第二个输出：

'1DV \ {25 ^ -V \}} 1+ {rd3 * Z; helloworlD

第三输出：

'2DV \ {25 ^ -V \}} 1+ {rd3 * Z; helloworLD

第四项输出：

'3DV \ {25 ^ -V \}} 1+ {rd3 * Z; hellowoRLD

第五输出：

'4DV \ {25 ^ -V \}} 1+ {rd3 * Z; hellowORLD

第六输出：

'5DV \ {25 ^ -V \}} 1+ {rd3 * Z; helloWORLD

第七输出：

'6DV \ {25 ^ -V \}} 1+ {rd3 * Z; hellOWORLD

第八输出：

'7DV \ {25 ^ -V \}} 1+ {rd3 * Z; helLOWORLD

第九个输出：

'8DV \ {25 ^ -V \}} 1+ {rd3 * Z; heLLOWORLD

第十输出：

'9DV \ {25 ^ -V \}} 1+ {rd3 * Z; hELLOWORLD

第十一输出：

'：DV \ {25 ^ -V \}} 1+ {rd3 * Z; HELLOWORLD

这是最后的输出，因为它将导致错误。

CJam，N = 3 4，28 字节-10％-10％= 22.4

{`_E=-"_~Hello!, World"2<}_~

这将启动以下链：

{`_E=-"_~Hello, World"2<}_~
{`_E=-"_~Hello World"2<}_~
{`_E=-"_~HelloWorld"2<}_~
{`_E=-"_~Helloorld"2<}_~

最后一个不再包含有效的“ Hello，World”。

在这里测试。

说明

{`     e# Quine framework. Leaves a string representation of the block on the stack.
  _E=  e# Make a copy and get the 14th element, which is the character of the first 'o'.
  -    e# Remove that character from the string.
  "_~Hello!, World" e# Push this string, so the "Hello, World!" is part of the code.
  2<   e# Truncate to just "_~" to get the output right.  
}_~

请注意，初始程序没有包含有效的“ Hello，World”，但是这使我们可以进一步迭代。

果酱69 60-50 ％= 30

我仍然是初学者，请告诉我如何在CJam打高尔夫球。

{`_40>\40<_38>~)`2Te[\25<"helloworld"00YbATe[.{{el}{eu}?}`+]W%"_~"}_~

打印每次迭代非常繁琐，因为它将对99次迭代有效。

它通过枚举hello word的大写来起作用。繁琐的工作是将字符串拆分为多个部分，因为“ hello world”和计数器都必须更新。

说明

{`_40>\40<_38>~)`2Te[\25<"helloworld"00YbATe[.{{el}{eu}?}`+]W%"_~"}_~
{`                                                                      e# standard quine framework. Thanks for Dennis.
  _40>                                                                  e# get the Yb11..
      \40<                                                              e# get those that not included in top
          _38>~)`2Te[                                                   e# get the accumulator and increment it
                     \25<                                               e# get those before "hello world"
                         "helloworld"                                   e# the Hello World
                                     00                                 e# accumulator
                                        YbATe[                          e# convert to binary and align right.
                                              .{{el}{eu}?}              e# Uppercase if the corresponding bit is 0
                                                          `             e# add quote
                                                           +]W%         e# reorder stack
"_~"}_~

注意：我没有阅读Mathematica的答案，对不起，我认为它是原始的

通过重新排序和不同的大小写，我丢失了9个字节。

{`_6<\"helloworld"01YbW%.{{eu}{el}?}`\I>_2<~)`2Te[\2>"_~"}_~
{`                                                   "_~"}_~ e# Standard quine framework
  _6<\                                                       e# Get "{~_6<\"
      "helloworld"                                            e# The helloworld
                  01                                          e# The accumulator
                    Yb                                        e# Convert to base 2
                      W%                                      e# Reverse the binary
                        .{{eu}{el}?}                          e# Convert to uppercase while the corresponding bit is 1.
                                    `                         e# Add quote
                                     _2<                      e# Get accumulator
                                        ~)`2Te[               e# Increment the accumulator
                                               \2>            e# get the rest

果酱73-60％= 29.2

这次还列举了标点符号。

{`:Z6<"HELLOWORLD"0:AYbW%.{{eu}{el}?}`", ":B-_6<BA3%>@6>A)ZW%52<W%"_~"}_~
{`:Z                                                              "_~"}_~ e# Standard Quine Framework
    6<                                                                    e# take the first 6 character
      "HELLOWORLD"                                                        e# Hello, world
                  0:A                                                     e# Accumulator
                     YbW%.{{eu}{el}?}`                                    e# See above
                                      ", ":B                              e# Punctuation
                                            -                             e# Delete punctuation
                                             _6<                          e# "hello
                                                BA3%>                     e# punctuation
                                                     @6>                  e# world"
                                                        A)                e# incremented accumulator
                                                          ZW%52<W%        e# Remaining part

GolfScript，35个字节-50％= 17.5

0"HelloWorld"{@@{^.32&\}%`@".~"}.~

我决定在重复之前对执行的数量大加估量。该程序的输出反馈到GolfScript解释器中，在第一次重复之前将产生890个不同的Hello World字符串。作为一个简单的示例，这是前15个迭代：

0"HelloWorld"{@@{^.32&\}%`@".~"}.~
0"HeLlOWoRlD"{@@{^.32&\}%`@".~"}.~
0"HelLOWorLD"{@@{^.32&\}%`@".~"}.~
0"HeLLOWoRLD"{@@{^.32&\}%`@".~"}.~
0"HellowORLD"{@@{^.32&\}%`@".~"}.~
32"HeLlOworld"{@@{^.32&\}%`@".~"}.~
0"hELloWoRlD"{@@{^.32&\}%`@".~"}.~
32"helLowORld"{@@{^.32&\}%`@".~"}.~
0"HeLLoWORlD"{@@{^.32&\}%`@".~"}.~
32"HellOWORld"{@@{^.32&\}%`@".~"}.~
0"hElLOWORlD"{@@{^.32&\}%`@".~"}.~
32"heLLOWORld"{@@{^.32&\}%`@".~"}.~
32"HelloworLd"{@@{^.32&\}%`@".~"}.~
32"hElLoWoRLd"{@@{^.32&\}%`@".~"}.~
0"HEllOWorlD"{@@{^.32&\}%`@".~"}.~

它的工作方式是遍历字符串，如果前一个字母（可能会翻转其大小写）为小写，则翻转每个字母的大小写（通过将其ASCII码与32进行XOR）。如果开始程序的数字是32而不是0，则首字母的大小写将翻转—每当字符串的最后一个字母为小写时，下一个迭代的数字输出将为32，从而导致结尾处的任何更改该字符串将在下一次迭代时传播回开头。

（这个特定的反馈过程是完全临时性的。我最初只是想运行一个简单的二进制计数器，使用大写和小写作为位，但是要实现的字节太多，所以我开始对其进行调整以查找较短的东西仍然会产生相当长的循环长度。由于理论上的最大值（仅使用大小写翻转）为2 ¹⁰ = 1024，因此获得890迭代的循环非常好。）

additional，额外迭代的奖励上限为−50％；如果没有上限，该计划将获得-4440％的巨额奖金。;-)

Pyth，18个字节

"-\"hello world\"d

哪个返回：

-"hello world"d

依次打印：

helloworld

我有一个解决方案，可以同时完成所有三个拼写，但即使有奖金，也要更长一些。

Simplex，21个字节。

这就是Simplex 诞生的原因。我绝对可以走得更远。

（我一直按Ctrl + Enter，对不起！我将其归咎于平板电脑键盘）

尝试3，v.0.8 +，31 -5％= 29.45字节（UTF-8方法）

中间的表情表达了自己。有点。为什么我又要这样做？._。

"\"f[helloworld]-:D-``\"§R'Hg"g
"                            "  ~~ write that string
 \"f[helloworld]-:D-``\"§R'Hg   ~~ escaped quotes
                              g ~~ output that string

第二输出：

"f[helloworld]-:D-``"§R'Hg
"                   "      ~~ write that string
 f[helloworld]-:D-``       ~~ string to be written
                     §R    ~~ go to second cell
                       'H  ~~ set it to H charcode
                         g ~~ output that string

第三输出：

f[Helloworld]-:D-``
f                   ~~ turns off safety mode (heck yeah error suppression!)
 [          ]-      ~~ write inside to outer program
  H                 ~~ sort strip
   e                ~~ write e = 2.718281828459045... to the strip
    ll              ~~ writes 1 twice to the cell
      o             ~~ outputs 1
       wo           ~~ apply o backwards through the strip (outputs 1)
         r          ~~ error! tries to access register for modification. nope!
          l         ~~ write 1 to to the current cell
           d        ~~ reverse the strip (NOP)
              :     ~~ removes last char of outer program
               D    ~~ double the current byte (2)
                -   ~~ writes previous char to outer program
                 `` ~~ suppress outer program evaluation and instead output it

最终输出：

HelloworlD

尝试2，v.0.8 +，21个字节（我认为是UTF-8）

"\"helloworld\"§'Hg"g
"                  "  ~~ write that string
 \"helloworld\"§'Hg   ~~ escaped quotes
                    g ~~ output that string

输出：

"helloworld"§'Hg
"          "     ~~ write that string
 helloworld      ~~ string to be written
            §    ~~ go to first cell
             'H  ~~ set it to H charcode
               g ~~ output that string

最终输出：

helloworld

尝试1，v.0.7 + 28 26字节

我不确定这是否有资格获得第一笔奖金...

"BhelloworldB"t[s32S;]'gs;
"            "             ~~ write that string
 BhelloworldB              ~~ the string
              t[     ]     ~~ apply the inner from left to right
                s          ~~ output as character
                 32S       ~~ subtract 32 ("capitalize")
                    ;      ~~ add the current byte's char to the outer program
                      'g;s ~~ add g to the outer program

第一输出：

"HELLOWORLD"g

外部程序在执行结束时进行评估（它对y执行；这是外部程序的外观：

"HELLOWORLD"g
"          "  ~~ write that string
            g ~~ output that string as string characters

最终输出：

HELLOWORLD

红宝石，81-50％= 40.5

原始代码：

_='_=%p;puts (_%%[_,%p]).sub(/[[:upper:]]/,&:swapcase)';puts _%[_,'HELLOWORL'+?D]

连续输出：

_="_=%p;puts (_%%[_,%p]).sub(/[[:upper:]]/,&:swapcase)";puts (_%[_,"HELLOWORLD"]).sub(/[[:upper:]]/,&:swapcase)

_="_=%p;puts (_%%[_,%p]).sub(/[[:upper:]]/,&:swapcase)";puts (_%[_,"hELLOWORLD"]).sub(/[[:upper:]]/,&:swapcase)

_="_=%p;puts (_%%[_,%p]).sub(/[[:upper:]]/,&:swapcase)";puts (_%[_,"heLLOWORLD"]).sub(/[[:upper:]]/,&:swapcase)

_="_=%p;puts (_%%[_,%p]).sub(/[[:upper:]]/,&:swapcase)";puts (_%[_,"helLOWORLD"]).sub(/[[:upper:]]/,&:swapcase)

_="_=%p;puts (_%%[_,%p]).sub(/[[:upper:]]/,&:swapcase)";puts (_%[_,"hellOWORLD"]).sub(/[[:upper:]]/,&:swapcase)

_="_=%p;puts (_%%[_,%p]).sub(/[[:upper:]]/,&:swapcase)";puts (_%[_,"helloWORLD"]).sub(/[[:upper:]]/,&:swapcase)

_="_=%p;puts (_%%[_,%p]).sub(/[[:upper:]]/,&:swapcase)";puts (_%[_,"hellowORLD"]).sub(/[[:upper:]]/,&:swapcase)

_="_=%p;puts (_%%[_,%p]).sub(/[[:upper:]]/,&:swapcase)";puts (_%[_,"hellowoRLD"]).sub(/[[:upper:]]/,&:swapcase)

_="_=%p;puts (_%%[_,%p]).sub(/[[:upper:]]/,&:swapcase)";puts (_%[_,"helloworLD"]).sub(/[[:upper:]]/,&:swapcase)

_="_=%p;puts (_%%[_,%p]).sub(/[[:upper:]]/,&:swapcase)";puts (_%[_,"helloworlD"]).sub(/[[:upper:]]/,&:swapcase)

_="_=%p;puts (_%%[_,%p]).sub(/[[:upper:]]/,&:swapcase)";puts (_%[_,"helloworld"]).sub(/[[:upper:]]/,&:swapcase)

我认为这算是全部50％？可能会被一。而且，Ruby中可能有一个得分更高的非奖励解决方案。

原始代码不包含“ helloworld”，但它构建了一个quine，用小写版本替换了源代码中的第一个大写字母。因此，每行连续的藜输出少一个大写字母。

这里的技巧是使用格式字符串对字符串本身（用于奎因）和Hello World字符串进行插值，以使其仅出现一次。

PHP，297-40％= 178.2字节

没有真正的竞争力，但是写起来很有趣

<?ob_start(function($s){$s=substr(str_replace(0,0+(int)true,$s),!i,ord(I)+ord(I));$h=hello.world;$h[0]=$h[0]^' ';return "<"."?".$s."?".">".$s.$h;});?>ob_start(function($s){$s=substr(str_replace(0,0+(int)true,$s),!i,ord(I)+ord(I));$h=hello.world;$h[0]=$h[0]^' ';return "<"."?".$s."?".">".$s.$h;});

这是这种方法的一种变体：

<?
ob_start(function($b){ return "<"."?\n$b?".">\n$b"; });?>
ob_start(function($b){ return "<"."?\n$b?".">\n$b"; });

但它也增加了的“HelloWorld”的输出，并取代0与0+1（下一次迭代中1与1+1等）。使用substr在添加新的“ helloworld”之前，将删除任何现有的“ helloworld”输出。

为了获得不同的输出，“ helloworld”的一个字母大写（由递增的数字确定）。这是相关代码：

$h=hello.world;$h[0]=$h[0]^' '

面临的挑战是，除了此处以及用于替换号码之外，不要使用其他任何号码

str_replace(0,0+(int)true,$s)

在那里，您已经看到+1实现为+(int)true。

对于子字符串参数，我需要0, 146：

!i, ord(I)+ord(I)

非空字符串“ i”被强制转换为 true并取反。false是有效的整数参数，并被视为0。ord(I)是“ I”的ASCII值：73

输出（第一次迭代）：

<?ob_start(function($s){$s=substr(str_replace(1,1+(int)true,$s),!i,ord(I)+ord(I));$h=hello.world;$h[1]=$h[1]^' ';return "<"."?".$s."?".">".$s.$h;});?>ob_start(function($s){$s=substr(str_replace(1,1+(int)true,$s),!i,ord(I)+ord(I));$h=hello.world;$h[1]=$h[1]^' ';return "<"."?".$s."?".">".$s.$h;});Helloworld

输出（第二次迭代）：

<?ob_start(function($s){$s=substr(str_replace(2,2+(int)true,$s),!i,ord(I)+ord(I));$h=hello.world;$h[2]=$h[2]^' ';return "<"."?".$s."?".">".$s.$h;});?>ob_start(function($s){$s=substr(str_replace(2,2+(int)true,$s),!i,ord(I)+ord(I));$h=hello.world;$h[2]=$h[2]^' ';return "<"."?".$s."?".">".$s.$h;});hElloworld

输出（第10次迭代）：

这是最后一个有效的输出，但不再是有效的程序

<?ob_start(function($s){$s=substr(str_replace(10,10+(int)true,$s),!i,ord(I)+ord(I));$h=hello.world;$h[10]=$h[10]^' ';return "<"."?".$s."?".">".$s.$h?>ob_start(function($s){$s=substr(str_replace(10,10+(int)true,$s),!i,ord(I)+ord(I));$h=hello.world;$h[10]=$h[10]^' ';return "<"."?".$s."?".">".$s.$hhelloworlD

向右滚动，找到“ Hello world”字符串！

点子，48-50％= 24

V Y"`V Y`.RPyRh:ST`helloworld`UCh@<0.h@>0R0o+0"

演变如下：

V Y"`V Y`.RPyRh:ST`helloworld`UCh@<1.h@>1R1o+1"
V Y"`V Y`.RPyRh:ST`Helloworld`UCh@<2.h@>2R2o+2"
V Y"`V Y`.RPyRh:ST`HElloworld`UCh@<3.h@>3R3o+3"
V Y"`V Y`.RPyRh:ST`HELloworld`UCh@<4.h@>4R4o+4"
V Y"`V Y`.RPyRh:ST`HELLoworld`UCh@<5.h@>5R5o+5"
V Y"`V Y`.RPyRh:ST`HELLOworld`UCh@<6.h@>6R6o+6"
V Y"`V Y`.RPyRh:ST`HELLOWorld`UCh@<7.h@>7R7o+7"
V Y"`V Y`.RPyRh:ST`HELLOWOrld`UCh@<8.h@>8R8o+8"
V Y"`V Y`.RPyRh:ST`HELLOWORld`UCh@<9.h@>9R9o+9"
V Y"`V Y`.RPyRh:ST`HELLOWORLd`UCh@<10.h@>10R10o+10"
V Y"`V Y`.RPyRh:ST`HELLOWORLD`UCh@<11.h@>11R11o+11"
V Y"`V Y`.RPyRh:ST`HELLOWORLD`UCh@<12.h@>12R12o+12"

最后一个输出无效，因为HELLOWORLD尚未更改。（如果我还没有完成红利权利，请更正我。）

由于这个问题，我刚刚发现了一种新的奎因技术！基本奎因是V Y"`V Y`.RPy"：

  Y"         "  Yank that string into the variable y
V               Evaluate it as a Pip expression:
          RPy   y wrapped in double quotes (repr)
    `V Y`.      Prepend that regex pattern
                When this is evaluated, it returns a pattern object, which is
                auto-printed--conveniently, without the `` delimiters

我们的额外代码会在重新定义y之前修改字符串，如下所示：

• 将当前helloworld替换为其中最左0字符大写的helloworld ；
• 替换的所有出现0与o+0（其中o是一个内置的变量，等于1）。

周围的代码数量下次是1不是0，等等。

Javascript，52个字节

function(){return '("hello world").replace(" ","")'}

测试

=>

<='("hello world").replace(" ","")'

=> eval('("hello world").replace(" ","")')

<= 'helloworld'

///，23个字节-10％= 20.7？

/,//\/ \/\/hello, world

在线尝试！

第一输出：

/ //hello world

第二个输出：

helloworld

BBC BASIC，56个字节

在意识到自己对游戏有多迟之前，我对此有所了解。物有所值，这是我的版本，也是我第一次尝试StackExchange代码高尔夫。

在此，V。回显以下逗号分隔列表中由ASCII码指定的字符，而P.是打印的简写。我利用退格字符覆盖现有的'helloworld'字符串。

输入代码：

V.80,46,34:P."helloworld";:V.8,68,34,59:P.":V.8,8,76,68"

第一输出：

P."helloworlD";:V.8,8,76,68

第二输出：

helloworLD

可以在https://bbc.godbolt.org/在线进行测试。