สร้างโปรแกรมที่ส่งสตริงสวัสดีโลก ("Hello world", "Hello, World" ฯลฯ ) และซอร์สโค้ด เอาต์พุตถูกเขียนไปยัง stdout หรือเทียบเท่า Hello world string ถูกฝังอยู่ในซอร์สโค้ด

ตัวอย่างเช่นผลลัพธ์สำหรับอาจเป็น

(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
helloworld

การใช้อักษรตัวพิมพ์ใหญ่ใด ๆ เป็นที่ยอมรับ ตัวอย่างเช่นเหล่านี้เป็นสตริงสวัสดีโลกที่ถูกต้อง:

Hello, world
hellO WORld
HELLoworlD

สตริงเหล่านี้ไม่ถูกต้อง:

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

โปรแกรมของคุณล้มเหลวทันทีที่ตรงตามเงื่อนไขข้อใดข้อหนึ่งต่อไปนี้:

• มันแสดงผลสตริงสวัสดีโลกที่ได้รับการส่งออกในช่วงการดำเนินการก่อนหน้านี้บางส่วน
• เอาท์พุทไม่ถูกต้องรหัสแหล่งที่มาในภาษาเดียวกันหรือ
• เอาต์พุตไม่มีสตริง 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% ความยาวของซอร์สโค้ดแรก ("สวัสดีโลก (บางซอร์สโค้ดที่นี่)") มีขนาด 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 ไบต์

หึ! เอาชนะที่! คุณอาจจะ :ค

ผลลัพธ์แรก:

'0DV \ {25 ^ -V \}} {1+ rd3 * Z; HelloWorld
'เริ่มการจับภาพเป็นสตริง
 0DV กด 0 ไปที่สแต็กและตั้งเป็นตัวแปรสุดท้าย
    ทำซ้ำรายการถัดไปหลายครั้ง (1, 2, 3 ... บนเอาต์พุต)
     {หมุนสแต็กไปทางซ้าย
      25 ^ กด 32 ไปที่สแต็ก
         - ลบรายการด้านบนโดยมันจะทำให้ตัวพิมพ์เล็กเป็นตัวพิมพ์ใหญ่
          V \ ทำรายการตัวแปรสุดท้ายครั้งสุดท้าย
            } หมุนสแต็กไปทางขวา
             } และอีกครั้ง...
              1+ เพิ่ม ทำให้ 0 ในรหัสนี้เป็น 1 จากนั้น 2 ...
                ย้อนกลับกองซ้อน
                 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" ที่ถูกต้อง แต่นั่นทำให้เราสามารถทำซ้ำได้อีกครั้ง

CJam 69 60 - 50% = 30

ฉันยังเพิ่งเริ่มต้นโปรดบอกฉันเกี่ยวกับการเล่นกอล์ฟใน CJam

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

มันน่าเบื่อที่จะพิมพ์ซ้ำแต่ละครั้งเพราะมันจะถูกต้องสำหรับ 99 ซ้ำ

มันทำงานโดยระบุตัวพิมพ์ใหญ่ของคำสวัสดี ความน่าเบื่อคือการแยกสตริงออกเป็นส่วน ๆ เนื่องจากทั้ง "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
"_~"}_~

หมายเหตุ: ฉันไม่ได้อ่านคำตอบทางคณิตศาสตร์, ฉันคิดว่ามันเป็นต้นฉบับ

ด้วยการจัดลำดับใหม่และการใช้อักษรตัวพิมพ์ใหญ่ต่างกันฉันจะสูญเสีย 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

CJam 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 จะสร้างสตริง Hello World 890 ที่แตกต่างกันก่อนที่จะทำซ้ำครั้งแรก ในตัวอย่างสั้น ๆ นี่คือการทำซ้ำ 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&\}%`@".~"}.~

วิธีการทำงานคือการวนซ้ำผ่านสายอักขระการพลิกตัวพิมพ์ใหญ่ของตัวอักษรแต่ละตัว (โดย XORing รหัส ASCII ของมันด้วย 32) ถ้าตัวอักษรก่อนหน้า (หลังจากอาจพลิกตัวพิมพ์เล็ก) เป็นตัวพิมพ์เล็ก ตัวอักษรตัวแรกจะมีตัวพิมพ์เล็กหมุนถ้าตัวเลขที่โปรแกรมเริ่มต้นเป็น 32 แทนที่จะเป็น 0 - และจำนวนผลลัพธ์สำหรับการวนซ้ำครั้งถัดไปจะเป็น 32 เมื่อตัวอักษรตัวสุดท้ายของสตริงเป็นตัวพิมพ์เล็กจึงทำให้เกิดการเปลี่ยนแปลงเมื่อสิ้นสุด สตริงที่จะเผยแพร่กลับไปที่จุดเริ่มต้นในการทำซ้ำครั้งถัดไป

(กระบวนการความคิดเห็นนี้โดยเฉพาะอย่างยิ่งที่ได้รับในทั้งหมดเฉพาะกิจลักษณะ. ฉันอยากจะเพียงแค่เรียกใช้เคาน์เตอร์ไบนารีง่ายโดยใช้ตัวพิมพ์ใหญ่และพิมพ์เล็กเป็นบิต แต่ที่เอาไบต์มากเกินไปในการดำเนินการดังนั้นผมจึงเริ่มปรับเปลี่ยนมันเพื่อหาบางสิ่งบางอย่างที่สั้นกว่า ที่จะยังคงให้ความยาววงจรค่อนข้างสูงเนื่องจากค่าสูงสุดเชิงทฤษฎีโดยใช้ case-flipping เท่านั้นคือ 2 ¹⁰ = 1024 การได้รอบ 890-iteration นั้นค่อนข้างดีทีเดียว)

อนิจจาโบนัสสำหรับการทำซ้ำเพิ่มเติมถูก จำกัด ไว้ที่ −50%; โปรแกรมนี้จะมีโบนัสมากถึง 4440% ;-)

Pyth, 18 ไบต์

"-\"hello world\"d

ผลตอบแทนใด:

-"hello world"d

ซึ่งจะพิมพ์:

helloworld

ฉันมีวิธีแก้ปัญหาที่ทำการสะกดทั้งสามครั้ง แต่นานกว่านั้นด้วยโบนัส

เริม , 21 ไบต์

นี่คือสิ่งที่ Simplex ถือกำเนิดขึ้นมาเพื่อ ฉันไปได้ไกลกว่านี้แน่นอน

(ฉันกดปุ่ม Ctrl + Enter ต่อไปขออภัยฉันโทษมันบนแป้นพิมพ์แท็บเล็ต)

พยายาม 3, v.0.8 +, 31 -5% = 29.45 ไบต์ (UTF-8 methinks)

emote ที่อยู่ตรงกลางแสดงออกถึงตัวเอง เรียงจาก ทำไมฉันถึงทำเช่นนี้อีกครั้ง? ._

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

เอาท์พุทที่ 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

เอาท์พุทที่ 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

ผลลัพธ์สุดท้าย:

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" แต่สร้างควินแทนตัวอักษรตัวใหญ่ตัวแรกในรหัสที่มาด้วยตัวพิมพ์เล็ก ดังนั้นการรันควินต่อเนื่องแต่ละตัวจะส่งออกตัวอักษรตัวพิมพ์ใหญ่หนึ่งตัวที่น้อยลง

เคล็ดลับที่นี่คือการใช้สตริงรูปแบบเพื่อสอดแทรกทั้งสตริงตัวเองสำหรับการ quining และสตริง 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และลบล้างfalse0เป็นจำนวนเต็มค่าที่ถูกต้องและได้รับการปฏิบัติเช่น ord(I)คือค่า ASCII ของ "I": 73

เอาต์พุต (การวนซ้ำครั้งที่ 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

เอาท์พุท (ซ้ำ 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

เอาท์พุท (ซ้ำ 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"!

Pip, 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ตัวละครเป็นตัวพิมพ์ใหญ่;
• แทนที่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เป็นแบบย่อสำหรับการพิมพ์ ฉันใช้ประโยชน์จากอักขระ backspace เพื่อเขียนทับสตริง '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/