Buat program, yang menghasilkan string halo dunia ("Halo dunia", "Halo, Dunia" dll.), Dan kode sumber. Output ditulis ke stdout atau setara. Halo string dunia tertanam dalam kode sumber.

Misalnya, output untuk mungkin

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

Ketika output dikompilasi atau ditafsirkan kembali, itu harus membuat output yang sama, tetapi string hello world harus memiliki tanda baca atau kapitalisasi yang berbeda. Sebagai contoh, contoh sebelumnya dapat membuat output berikut

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

Setiap "(beberapa kode sumber di sini)" dalam contoh-contoh ini dapat berubah setelah setiap eksekusi, atau bisa sama.

Output Anda harus mengandung string halo dunia yang valid tepat sekali. Ini mungkin mengandung jumlah string dunia hello yang tidak valid. Kode sumber dapat berisi jumlah komentar berapa pun, dan string halo dunia dapat disematkan dalam komentar. Program pertama dapat memiliki nol atau satu string hello world yang valid, tetapi tidak lebih.

Tanda baca berikut ini valid:

hello, world
hello world
helloworld

Kapitalisasi apa pun dapat diterima. Sebagai contoh, ini adalah string hello world yang valid:

Hello, world
hellO WORld
HELLoworlD

String ini tidak valid:

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

Program Anda gagal segera setelah salah satu dari kondisi berikut dipenuhi:

• Ini menghasilkan string halo dunia yang telah dikeluarkan selama beberapa eksekusi sebelumnya,
• output tidak lagi kode sumber yang valid dalam bahasa yang sama, atau
• output tidak mengandung tepat satu string hello world yang valid.

Program Anda tidak berlaku untuk kontes ini kecuali setidaknya dua eksekusi pertama berhasil. Ini berarti bahwa output ketiga diizinkan tidak valid. Output dari program Anda mungkin tidak acak. Eksekusi pertama harus selalu membuat output kedua yang sama, eksekusi kedua harus selalu membuat output ketiga yang sama, dll.

Skor dihitung sebagai jumlah byte dalam kode sumber program awal. Skor terendah menang.

Bonus berikut berlaku (hingga -60%):

• -5% * (N - 2), di mana N adalah indeks eksekusi setelah program Anda menghasilkan output yang tidak valid. Batas bonus ini sebesar -50%. Jika program Anda berhasil 12 kali atau lebih, Anda mendapatkan bonus maksimal.
• -10%, jika output Anda (termasuk kode sumber pertama) menyertakan ketiga alternatif tanda baca yang valid.

Kiriman Anda harus menyertakan kode sumber pertama, dan itu juga harus berisi output dari eksekusi yang berhasil. Jika program Anda berhasil lebih dari 12 kali, tambahkan output untuk 12 eksekusi.

Contoh

Baris berikutnya adalah kode sumber pertama. Saat kami mengeksekusinya, ini adalah eksekusi pertama.

hello world(some source code here)

Baris berikutnya adalah output dari kode kode sumber pertama. Ini adalah output pertama.

hello, world(some source code here) 

Baris berikutnya adalah output dari eksekusi kedua. Ini adalah output kedua.

helloworld(some source code here)

Ketika kami mengeksekusi output pertama, program ini menjadi memenuhi syarat untuk bonus -10%. Itu berarti kita memiliki dua keluaran, dan satu kode asli, yang semuanya memiliki tanda baca yang berbeda. Selain itu, karena output kedua valid, program ini memenuhi syarat untuk kontes ini.

Baris berikutnya adalah output dari eksekusi ketiga. Ini adalah output ketiga.

Helloworld(some source code here)

Baris berikutnya adalah output dari eksekusi keempat. Ini adalah output keempat.

hellworld(some source code here)

Output ini tidak valid. Indeks pelaksanaan terakhir yang valid adalah 4. Program ini memenuhi syarat untuk bonus -5% * (4 - 2) dan bonus -10% dari tanda baca. Ini membuat total -20%. Panjang kode sumber pertama ("hello world (beberapa kode sumber di sini)") adalah 34 byte, jadi skor akhirnya adalah 27,2.

Pyth, 17 byte

Solusi Pyth yang berbeda:

"r\"helloworld\"1

Keluaran:

r"helloworld"1

Output kedua:

HELLOWORLD

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

Saya memutuskan untuk mengoptimalkan jumlah string di sini. Ini berjalan untuk 1024 program tanpa henti, melalui setiap kombinasi huruf besar dan kecil. Eksekusinya bisa dilihat di sini .

Vitsy, 33 - 33 * .05 * (11-2) = 18.15 Bytes

Heh! Kalahkan itu! Anda mungkin akan melakukannya. : c

Output pertama:

'0DV \ {25 ^ -V \}} 1+ {rd3 * Z; helloworld
'Mulai menangkap sebagai string
 0DV Tekan 0 ke tumpukan dan atur sebagai variabel terakhir.
    \ Ulangi item berikutnya berkali-kali. (1, 2, 3 ... pada keluaran.)
     {Putar tumpukan ke kiri.
      25 ^ Dorong 32 ke tumpukan.
         - Kurangi item teratas dengan itu - ini akan membuat huruf kecil.
          V \ Lakukan item berikutnya kali variabel akhir.
            ► Putar tumpukan ke kanan.
             } Dan lagi...
              1+ Tambahkan satu. Ini membuat 0 dalam kode ini menjadi 1, kemudian 2 ...
                r Membalik tumpukan.
                 d3 * Dapatkan karakter '
                    Z Keluarkan semua item dalam tumpukan.
                     ; Akhiri eksekusi.
                      helloworld String untuk memanipulasi.

Output kedua:

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

Keluaran ketiga:

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

Output keempat:

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

Output kelima:

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

Output keenam:

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

Output ketujuh:

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

Output kedelapan:

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

Keluaran kesembilan:

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

Output kesepuluh:

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

Output kesebelas:

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

Ini adalah keluaran terakhir, karena akan menyebabkan kesalahan.

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

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

ini memulai rantai berikut:

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

di mana yang terakhir tidak lagi berisi "Halo, Dunia" yang valid.

Uji di sini.

Penjelasan

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

Perhatikan bahwa program awal tidak mengandung "Hello, World" yang valid, tetapi itu memungkinkan kita untuk melanjutkan satu iterasi lebih lanjut.

CJam 69 60 - 50% = 30

Saya masih pemula, Tolong beritahu saya cara bermain golf di CJam.

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

Sangat membosankan untuk mencetak setiap iterasi, karena itu akan berlaku untuk 99 iterasi.

Ini bekerja dengan menghitung kapitalisasi kata hello. Kebosanan adalah untuk memisahkan string menjadi beberapa bagian karena "halo dunia" dan penghitung harus diperbarui.

Penjelasan

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

CATATAN: Saya tidak membaca jawaban Mathematica, maaf, saya pikir itu asli

Dengan penataan ulang, dan kapitalisasi yang berbeda, saya kehilangan 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

Kali ini juga menyebutkan tanda baca.

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

Saya memutuskan untuk melakukan terlalu banyak jumlah eksekusi sebelum pengulangan. Program ini, dengan outputnya dimasukkan kembali ke dalam juru bahasa GolfScript, akan menghasilkan 890 string Hello World yang berbeda sebelum pengulangan yang pertama. Sebagai contoh singkat, berikut adalah 15 iterasi pertama:

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

Cara kerjanya adalah dengan melakukan iterasi melalui string, membalik kapitalisasi setiap huruf (dengan XORing kode ASCII dengan 32) jika huruf sebelumnya (setelah kemungkinan kasusnya dibalik) huruf kecil. Huruf pertama akan dibalik kasusnya jika angka pada program awal adalah 32 daripada 0 - dan nomor output untuk iterasi berikutnya akan menjadi 32 setiap kali huruf terakhir dari string huruf kecil, sehingga menyebabkan perubahan pada akhir string untuk merambat kembali ke awal pada iterasi berikutnya.

(Proses umpan balik khusus ini diperoleh dengan cara yang benar-benar ad hoc . Saya awalnya ingin menjalankan penghitung biner sederhana menggunakan huruf besar dan kecil, tetapi itu membutuhkan terlalu banyak byte untuk diterapkan, jadi saya mulai men-tweak untuk menemukan sesuatu yang lebih pendek. yang masih akan menghasilkan panjang siklus yang cukup tinggi. Karena maksimum teoritis, hanya menggunakan case-flipping, adalah 2 ¹⁰ = 1024, mendapatkan siklus iterasi 890 cukup bagus.)

Sayangnya, bonus untuk iterasi tambahan dibatasi pada −50%; tanpa batas, program ini akan memiliki opping4440% bonus kekalahan. ;-)

Pyth, 18 byte

"-\"hello world\"d

Yang mengembalikan:

-"hello world"d

Yang pada gilirannya mencetak:

helloworld

Saya punya solusi yang melakukan ketiga ejaan, tetapi lebih lama bahkan dengan bonus.

Simplex , 21 byte.

Inilah tujuan lahirnya Simplex . Saya pasti bisa lebih jauh dengan ini.

(Saya terus menekan Ctrl + Enter, maaf! Saya salahkan pada keyboard tablet)

Percobaan 3, v.0.8 +, 31 -5% = 29.45 byte (metode UTF-8)

Emote di tengah mengekspresikan diri saya. Semacam. Mengapa saya melakukan ini lagi? ._.

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

Output 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 output:

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

Hasil akhir:

HelloworlD

Percobaan 2, v.0.8 +, 21 byte (UTF-8, saya pikir)

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

Keluaran:

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

Hasil akhir:

helloworld

Percobaan 1, v.0.7 + 28 26 byte

Saya tidak yakin apakah ini memenuhi syarat untuk bonus pertama ...

"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

Output pertama:

"HELLOWORLD"g

Program luar dievaluasi pada akhir eksekusi (melakukannya untuk y; seperti inilah tampilan program luar:

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

Hasil akhir:

HELLOWORLD

Ruby, 81 - 50% = 40.5

Kode asli:

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

Output berturut-turut:

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

Saya pikir ini dianggap sebagai 50% penuh? Bisa mati satu per satu. Juga, mungkin ada solusi non-bonus dengan skor yang lebih baik di Ruby.

Kode asli tidak mengandung "helloworld", tetapi membangun quine yang menggantikan huruf kapital pertama dalam kode sumbernya dengan versi huruf kecil. Jadi setiap menjalankan quine menghasilkan satu huruf kapital yang lebih sedikit.

Kuncinya di sini adalah dengan menggunakan string format untuk menginterpolasi baik string itu sendiri, untuk quining, dan string Hello World, sehingga hanya muncul sekali.

PHP, 297 - 40% = 178,2 byte

Tidak terlalu kompetitif tetapi menyenangkan untuk menulis

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

Ini variasi dari quine ini:

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

tetapi juga menambahkan "helloworld" ke output dan menggantikannya 0dengan 0+1(dalam iterasi berikutnya 1dengan 1+1dan seterusnya). Menggunakansubstr output "helloworld" yang ada akan dihapus sebelum "helloworld" baru ditambahkan.

Untuk mendapatkan hasil yang berbeda, satu huruf "helloworld" dikapitalisasi (ditentukan oleh angka yang bertambah). Ini adalah kode yang relevan:

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

Tantangannya adalah tidak menggunakan nomor apa pun kecuali di sini dan untuk penggantian nomor

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

Di sana Anda sudah melihat bahwa +1disadari sebagai +(int)true.

Untuk argumen substring yang saya butuhkan 0, 146:

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

String non-kosong "i" akan dipaksa truedan dinegasi. falseadalah argumen integer yang valid dan diperlakukan seperti 0. ord(I)adalah nilai ASCII dari "I": 73

Output (iterasi 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

Output (iterasi ke-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

Output (iterasi ke-10):

Ini adalah output yang valid terakhir tetapi bukan program yang valid lagi

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

Gulir jauh ke kanan untuk menemukan string "Halo dunia"!

Pip, 48 - 50% = 24

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

yang berkembang sebagai berikut:

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"

dengan output terakhir menjadi tidak valid karena HELLOWORLDbelum berubah. (Koreksi saya jika saya belum melakukan bonus dengan benar.)

Berkat pertanyaan ini, saya baru saja menemukan teknik quine baru! Quine dasar adalah 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

Kode tambahan kami memodifikasi string di y, sebelum mengarangnya, sebagai berikut:

• Ganti helloworld saat ini dengan yang paling kiri 0 karakter adalah huruf besar;
• Ganti semua kejadian 0dengan o+0(di mana oadalah variabel bawaan yang sama dengan 1).

Waktu berikutnya di sekitar nomor dalam kode 1bukan 0, dan sebagainya.

Javascript, 52 byte

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

Uji

=>

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

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

<= 'helloworld'

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

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

Cobalah online!

Output pertama:

/ //hello world

Output kedua:

helloworld

BBC BASIC, 56 byte

Saya punya celah di ini sebelum saya menyadari betapa terlambatnya permainan saya. Untuk apa nilainya, inilah versi saya dan upaya pertama saya di StackExchange code golf.

Di sini, V. menggemakan karakter yang diberikan oleh kode ASCII dalam daftar yang dipisahkan koma berikut dan P. adalah singkatan untuk dicetak. Saya menggunakan karakter backspace untuk menimpa string 'helloworld' yang ada.

Kode input:

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

Output pertama:

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

Output Kedua:

helloworLD

Itu dapat diuji secara online di https://bbc.godbolt.org/