Tạo một chương trình, đưa ra chuỗi thế giới xin chào ("Hello world", "Hello, World", v.v.) và mã nguồn. Đầu ra được ghi vào thiết bị xuất chuẩn hoặc tương đương. Xin chào chuỗi thế giới được nhúng trong mã nguồn.

Ví dụ: đầu ra cho có thể là

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

Khi đầu ra được biên dịch hoặc giải thích lại, nó sẽ tạo ra một đầu ra tương tự, nhưng chuỗi hello world phải có dấu câu hoặc viết hoa khác nhau. Ví dụ, ví dụ trước có thể tạo đầu ra sau

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

Mỗi "(một số mã nguồn ở đây)" trong các ví dụ này có thể thay đổi sau mỗi lần thực hiện hoặc có thể giống nhau.

Đầu ra của bạn phải chứa một chuỗi hello world hợp lệ chính xác một lần. Nó có thể chứa bất kỳ số lượng chuỗi thế giới xin chào không hợp lệ. Mã nguồn có thể chứa bất kỳ số lượng bình luận nào và chuỗi hello world có thể được nhúng trong các bình luận. Chương trình đầu tiên có thể có 0 hoặc một chuỗi hello world hợp lệ, nhưng không còn nữa.

Các dấu câu sau đây là hợp lệ:

hello, world
hello world
helloworld

Bất kỳ viết hoa đều được chấp nhận. Ví dụ: đây là các chuỗi hello world hợp lệ:

Hello, world
hellO WORld
HELLoworlD

Các chuỗi này không hợp lệ:

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

Chương trình của bạn không thành công ngay khi một trong những điều kiện sau được đáp ứng:

• Nó xuất ra một chuỗi hello world đã được xuất ra trong một số lần thực hiện trước đó,
• đầu ra không còn là mã nguồn hợp lệ trong cùng một ngôn ngữ, hoặc
• đầu ra không chứa chính xác một chuỗi hello world hợp lệ.

Chương trình của bạn không hợp lệ cho cuộc thi này trừ khi ít nhất hai lần thực hiện đầu tiên thành công. Điều này có nghĩa là đầu ra thứ ba được phép không hợp lệ. Đầu ra của chương trình của bạn có thể không phải là ngẫu nhiên. Thực hiện đầu tiên phải luôn tạo cùng một đầu ra thứ hai, thực hiện thứ hai phải luôn tạo cùng một đầu ra thứ ba, v.v.

Điểm được tính bằng lượng byte trong mã nguồn của chương trình ban đầu. Điểm số thấp nhất chiến thắng.

Phần thưởng sau đây được áp dụng (tối đa -60%):

• -5% * (N - 2), trong đó N là chỉ số thực hiện mà sau đó chương trình của bạn tạo đầu ra không hợp lệ. Phần thưởng này giới hạn ở mức -50%. Nếu chương trình của bạn thành công 12 lần trở lên, bạn sẽ nhận được tiền thưởng tối đa.
• -10%, nếu kết quả đầu ra của bạn (bao gồm mã nguồn đầu tiên) bao gồm cả ba lựa chọn thay thế dấu câu hợp lệ.

Việc gửi của bạn nên bao gồm mã nguồn đầu tiên và nó cũng phải chứa các kết quả đầu ra của các lần thực hiện thành công. Nếu chương trình của bạn thành công hơn 12 lần, hãy thêm đầu ra cho 12 lần thực hiện.

Thí dụ

Dòng tiếp theo là mã nguồn đầu tiên. Khi chúng tôi thực hiện nó, đó là lần thực hiện đầu tiên.

hello world(some source code here)

Dòng tiếp theo là đầu ra từ mã mã nguồn đầu tiên. Đây là đầu ra đầu tiên.

hello, world(some source code here) 

Dòng tiếp theo là đầu ra từ lần thực hiện thứ hai. Đây là đầu ra thứ hai.

helloworld(some source code here)

Khi chúng tôi thực hiện đầu ra đầu tiên, chương trình này đã đủ điều kiện nhận phần thưởng -10%. Điều đó có nghĩa là chúng tôi có hai đầu ra và một mã gốc, tất cả đều có dấu câu khác nhau. Hơn nữa, vì đầu ra thứ hai là hợp lệ, chương trình này đủ điều kiện cho cuộc thi này.

Dòng tiếp theo là đầu ra từ lần thực hiện thứ ba. Đây là đầu ra thứ ba.

Helloworld(some source code here)

Dòng tiếp theo là đầu ra từ lần thực hiện thứ tư. Đây là đầu ra thứ tư.

hellworld(some source code here)

Đầu ra này không hợp lệ. Chỉ số của lần thực hiện hợp lệ cuối cùng là 4. Chương trình này đủ điều kiện nhận phần thưởng -5% * (4 - 2) và phần thưởng -10% từ dấu câu. Điều này làm cho tổng số -20%. Độ dài của mã nguồn đầu tiên ("hello world (một số mã nguồn ở đây)") là 34 byte, vì vậy điểm số cuối cùng là 27,2.

Bình thường, 17 byte

Một giải pháp Pyth khác nhau:

"r\"helloworld\"1

Đầu ra:

r"helloworld"1

Đầu ra thứ hai:

HELLOWORLD

Toán học, 214 - 50% = 107 byte

(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}]) & 

Tôi quyết định tối ưu hóa cho chuỗi đếm ở đây. Điều này chạy cho 1024 chương trình mà không dừng lại, đi qua mọi sự kết hợp của chữ hoa và chữ thường. Việc thực hiện có thể được nhìn thấy ở đây .

Vitsy, 33 - 33 * .05 * (11-2) = 18,15 byte

Heh! Đánh bại mà! Bạn có thể sẽ. : c

Đầu ra đầu tiên:

'0DV \ {25 ^ -V \}} 1+ {rd3 * Z; hellowworld
'Bắt đầu chụp như một chuỗi
 0DV Đẩy 0 vào ngăn xếp và đặt nó làm biến cuối cùng.
    \ Lặp lại mục tiếp theo này nhiều lần. (1, 2, 3 ... trên đầu ra.)
     {Xoay ngăn xếp sang trái.
      25 ^ Đẩy 32 vào ngăn xếp.
         - Trừ mục trên cùng của nó - điều này sẽ làm chữ hoa viết thường.
          V \ Làm mục tiếp theo lần cuối biến.
            } Xoay ngăn xếp sang phải.
             } Và một lần nữa...
              1+ Thêm một. Điều này làm cho 0 trong mã này là 1, sau đó 2 ...
                r Đảo ngược ngăn xếp.
                 d3 * Nhận nhân vật '
                    Z Xuất tất cả các mục trong ngăn xếp.
                     ; Kết thúc thực hiện.
                      Chuỗi hellowworld để thao tác.

Đầu ra thứ hai:

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

Đầu ra thứ ba:

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

Đầu ra thứ tư:

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

Đầu ra thứ năm:

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

Đầu ra thứ sáu:

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

Đầu ra thứ bảy:

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

Đầu ra thứ tám:

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

Đầu ra thứ chín:

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

Sản lượng thứ mười:

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

Đầu ra thứ mười một:

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

Đây là đầu ra cuối cùng, vì nó sẽ gây ra lỗi.

CJam, N = 3 4, 28 byte - 10% - 10% = 22,4

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

điều này bắt đầu chuỗi sau:

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

trong đó cái cuối cùng không còn chứa "Xin chào, Thế giới" hợp lệ.

Kiểm tra nó ở đây.

Giải trình

{`     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.  
}_~

Lưu ý rằng chương trình ban đầu không chứa "Xin chào, Thế giới" hợp lệ, nhưng điều đó cho phép chúng tôi tiếp tục lặp lại.

CJam 69 60 - 50% = 30

Tôi vẫn là người mới bắt đầu, Xin vui lòng cho tôi biết cách chơi gôn ở CJam.

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

Thật tẻ nhạt khi in mỗi lần lặp, vì nó sẽ hợp lệ cho 99 lần lặp.

Nó hoạt động bằng cách liệt kê cách viết hoa của từ xin chào. Tedium là chia chuỗi thành nhiều phần vì cả "hello world" và bộ đếm phải được cập nhật.

Giải trình

{`_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
"_~"}_~

LƯU Ý: Tôi không đọc câu trả lời Mathicala, xin lỗi, tôi nghĩ đó là bản gốc

Với việc sắp xếp lại và viết hoa khác nhau, tôi mất 9 byte.

{`_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

CJam 73 - 60% = 29,2

Lần này cũng liệt kê dấu chấm câu.

{`: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 byte - 50% = 17,5

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

Tôi quyết định thực hiện quá mức số lần thực hiện trước khi lặp lại. Chương trình này, với đầu ra được đưa trở lại vào trình thông dịch GolfScript, sẽ tạo ra 890 chuỗi Hello World riêng biệt trước khi lặp lại lần đầu tiên. Dưới đây là một mẫu ngắn gọn, đây là 15 lần lặp đầu tiên:

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&\}%`@".~"}.~

Cách thức hoạt động của nó là bằng cách lặp qua chuỗi, lật viết hoa của mỗi chữ cái (bằng cách XOR mã ASCII của nó với 32) nếu chữ cái trước đó (sau khi có thể bị lật) là chữ thường. Chữ cái đầu tiên sẽ được lật trường hợp của nó nếu số ở chương trình đầu là 32 chứ không phải 0 - và đầu ra số cho lần lặp tiếp theo sẽ là 32 bất cứ khi nào chữ cái cuối của chuỗi là chữ thường, do đó gây ra bất kỳ thay đổi nào ở cuối chuỗi để truyền trở lại từ đầu trong lần lặp tiếp theo.

(Quá trình phản hồi cụ thể này thu được theo cách hoàn toàn đặc biệt . Ban đầu tôi chỉ muốn chạy một bộ đếm nhị phân đơn giản sử dụng chữ hoa và chữ thường làm bit, nhưng phải mất quá nhiều byte để thực hiện, vì vậy tôi bắt đầu điều chỉnh nó để tìm ra thứ gì đó ngắn hơn điều đó vẫn mang lại độ dài chu kỳ khá cao. Vì mức tối đa theo lý thuyết, chỉ sử dụng lật trường hợp, là 2 ¹⁰ = 1024, nhận được chu kỳ lặp 890 là khá tốt.)

Than ôi, phần thưởng cho các lần lặp bổ sung được giới hạn ở mức −50%; không có giới hạn, chương trình này sẽ có phần thưởng −4440%. ;-)

Bình thường, 18 byte

"-\"hello world\"d

Trả về:

-"hello world"d

Lần lượt in:

helloworld

Tôi đã có một giải pháp thực hiện cả ba cách viết, nhưng nó còn dài hơn với phần thưởng.

Đơn giản , 21 byte.

Đây là những gì Simplex được sinh ra cho. Tôi chắc chắn có thể đi xa hơn với điều này.

(Tôi tiếp tục nhấn Ctrl + Enter, xin lỗi! Tôi đổ lỗi cho bàn phím máy tính bảng)

Cố gắng 3, v.0.8 +, 31 -5% = 29,45 byte (methinks UTF-8)

Điều đó emote ở giữa thể hiện bản thân mình. Sắp xếp Tại sao tôi lại làm điều này một lần nữa? ._.

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

Đầu ra thứ 2:

"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

Đầu ra thứ 3:

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

Đầu ra cuối cùng:

HelloworlD

Cố gắng 2, v.0.8 +, 21 byte (UTF-8, tôi nghĩ vậy)

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

Đầu ra:

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

Đầu ra cuối cùng:

helloworld

Cố gắng 1, v.0.7 + 28 26 byte

Tôi không chắc điều này có đủ điều kiện nhận phần thưởng đầu tiên hay không

"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

Đầu ra đầu tiên:

"HELLOWORLD"g

Chương trình bên ngoài được đánh giá khi kết thúc thực hiện (nó thực hiện cho y; đây là chương trình bên ngoài trông như sau:

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

Đầu ra cuối cùng:

HELLOWORLD

Hồng ngọc, 81 - 50% = 40,5

Mã gốc:

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

Đầu ra liên tiếp:

_="_=%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)

Tôi nghĩ rằng điều này được tính là 50% đầy đủ? Có thể được tắt bởi một. Ngoài ra, có lẽ có một giải pháp không thưởng cao hơn trong Ruby.

Mã ban đầu không chứa "hellowworld", nhưng nó xây dựng một quine thay thế chữ in hoa đầu tiên trong mã nguồn của nó bằng phiên bản chữ thường. Vì vậy, mỗi lần chạy liên tiếp của quine tạo ra một chữ cái viết hoa ít hơn.

Mẹo ở đây là sử dụng một chuỗi định dạng để nội suy cả chuỗi đó, để tạo chuỗi và chuỗi Hello World, để nó chỉ xuất hiện một lần.

PHP, 297 - 40% = 178,2 byte

Không thực sự cạnh tranh nhưng thật vui khi viết

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

Đây là một biến thể của câu hỏi này:

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

nhưng nó cũng thêm "hellowworld" vào đầu ra và thay thế 0bằng 0+1(trong lần lặp tiếp theo 1với 1+1và v.v.). Sử dụng substrbất kỳ đầu ra "hellowworld" hiện tại nào sẽ bị xóa trước khi "hellowworld" mới được thêm vào.

Để có được đầu ra khác nhau, một chữ cái của "hellowworld" được viết hoa (được xác định bằng số tăng). Đây là mã có liên quan:

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

Một thách thức là không sử dụng bất kỳ số nào ngoại trừ ở đây và để thay thế số

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

Ở đó bạn đã thấy rằng +1được nhận ra là +(int)true.

Đối với các đối số chuỗi con tôi cần 0, 146:

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

Chuỗi "i" không trống bị ép buộc truevà bị phủ định. falselà một đối số nguyên hợp lệ và được xử lý như thế nào 0. ord(I)là giá trị ASCII của "I": 73

Đầu ra (lần lặp thứ 1):

<?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

Đầu ra (lần lặp thứ 2):

<?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

Đầu ra (lần lặp thứ 10):

Đây là đầu ra hợp lệ cuối cùng nhưng không phải là một chương trình hợp lệ nữa

<?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

Di chuyển sang bên phải để tìm chuỗi "Hello world"!

Pip, 48 - 50% = 24

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

phát triển như sau:

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"

với đầu ra cuối cùng không hợp lệ vì HELLOWORLDkhông thay đổi. (Chỉnh sửa cho tôi nếu tôi không thực hiện đúng phần thưởng.)

Nhờ câu hỏi này, tôi mới phát hiện ra một kỹ thuật quine mới! Nguyên tắc cơ bản là 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

Mã bổ sung của chúng tôi sửa đổi chuỗi trong y, trước khi lặp lại chuỗi đó, như sau:

• Thay thế hellowworld hiện tại bằng một trong đó ngoài cùng bên trái 0 ký tự ngoài được đặt phía trên;
• Thay thế tất cả các lần xuất hiện 0bằng o+0(trong đó omột biến dựng sẵn bằng 1).

Lần sau, số trong mã là 1thay vì 0, v.v.

Javascript, 52 byte

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

Kiểm tra

=>

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

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

<= 'helloworld'

///, 23 byte - 10% = 20,7?

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

Hãy thử trực tuyến!

Đầu ra đầu tiên:

/ //hello world

Đầu ra thứ hai:

helloworld

BBC BASIC, 56 byte

Tôi đã có một vết nứt tại đây trước khi tôi nhận ra rằng tôi đến muộn như thế nào. Để biết giá trị của nó, đây là phiên bản của tôi và nỗ lực đầu tiên của tôi tại sân golf mã StackExchange.

Tại đây, V. lặp lại các ký tự được cung cấp bởi mã ASCII trong danh sách được phân tách bằng dấu phẩy và P. là viết tắt để in. Tôi sử dụng ký tự backspace để ghi đè chuỗi 'hellowworld' hiện có.

Mã đầu vào:

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

Đầu ra đầu tiên:

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

Đầu ra thứ hai:

helloworLD

Nó có thể được thử nghiệm trực tuyến tại https://bbc.godbolt.org/