"Halo dunia" yang menciptakan program "Halo dunia" yang berbeda

19

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.

code-golf string quine hello-world
sumber
1
Apakah aturan quine yang biasa berlaku atau apakah program diizinkan untuk membaca file sumbernya sendiri?
Martin Ender
1
Aturan quine biasa memang berlaku.
Apakah kode asli diperhitungkan terhadap bonus? Demikian juga, apakah kode asli harus mengandung yang valid hello world?
Martin Ender
1
Kode asli diperhitungkan terhadap bonus. Kode asli tidak harus mengandung hello world yang valid.
Apakah Anda yakin tentang perubahan aturan terbaru? Bersama dengan "Program pertama tidak harus mengandung string halo dunia yang valid, atau mungkin berisi beberapa string halo dunia yang valid." Saya dapat menambahkan variasi yang hilang sebagai komentar pada kode sumber asli untuk mendapatkan bonus (mungkin tidak sepadan dalam kebanyakan kasus tetapi masih terlihat seperti celah)
Fabian Schmengler

Jawaban:

8

Pyth, 17 byte

Solusi Pyth yang berbeda:

"r\"helloworld\"1

Keluaran:

r"helloworld"1

Output kedua:

HELLOWORLD
Fabian Schmengler
sumber
Aturan saat ini menyatakan "Program Anda gagal segera setelah salah satu dari kondisi berikut terpenuhi: output tidak lagi kode sumber dalam bahasa yang sama" dan "Program Anda tidak valid untuk kontes ini kecuali setidaknya tiga eksekusi pertama berhasil." . Apakah HELLOWORLD program yang valid di Pyth? Jika ya, silakan posting hasilnya juga atau jelaskan apa fungsinya. Jika tidak, saya pikir program ini tidak valid.
Selain itu, saya ingin menjelaskan bahwa program ini tidak melanggar aturan tentang pengulangan string yang sama. Solusi ini mengulangi "helloworld" yang ada di kode sumber pertama. Aturan hanya melarang pengulangan string yang telah di output sebelumnya. Jika output kedua adalah program Pyth yang valid, maka solusi ini sangat valid.
Pada saat menjawab, aturannya adalah "Program Anda tidak valid untuk kontes ini kecuali setidaknya dua eksekusi pertama berhasil"
Fabian Schmengler
Oh kamu benar Saya tidak yakin mengapa saya mengubahnya karena contoh saya di posting pertama menyatakan bahwa dua output = solusi yang valid. Saya akan memperbaiki aturan untuk mencerminkan hal ini. Jadi solusi Anda valid. Ini juga merupakan solusi valid terbaik saat ini.
9

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 .

LegionMammal978
sumber
1
Sayang sekali Anda tidak bisa bermain golf spasi putih dan menggunakan notasi awalan dan infiks di Mathematica quines, bukan? ;) (Ini mungkin cukup lama untuk pendekatan quine yang berlawanan untuk bekerja, di mana Anda menyimpan kode dalam sebuah string s, dan mengevaluasinya dengan ToExpression.)
Martin Ender
6

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.

Addison Crump
sumber
1
o_o Simplex berjuang ke 21. Aku akan berusaha mengalahkan 18.15!
Conor O'Brien
@ CᴏɴᴏʀO'Bʀɪᴇɴ Vitsy praktis dibangun untuk mengedit kode sumbernya sendiri dan melakukan manipulasi string dasar. XD Saya pikir ini bisa diturunkan lebih banyak.
Addison Crump
Saya pikir simplex akan luar biasa, karena ia memiliki fungsi program luar, tetapi tidak ada yang akan dihitung sebagai satu program. le sigh
Conor O'Brien
+1 untuk mengalahkan (atau hampir mengalahkan) bahasa golf "klasik"
ev3commander
@ ev3commander saya akan mengalahkan mereka jika bonus iterasi lebih tinggi. : c
Addison Crump
5

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.

Martin Ender
sumber
Apakah ini memenuhi syarat untuk bonus -10%? Keluaran hanya berisi dua dari tiga formulir tanda baca yang valid.
Mike Bufardeci
@ MikeBufardeci Oh pertanyaan bagus ... Saya kira menganggap kode asli adalah bagian dari itu.
Martin Ender
1
Saya mengklarifikasi aturan sehingga kode asli dihitung untuk bonus. Meskipun saya harus mengakui bahwa saya tidak menyadari ini mudah untuk mendapatkan -10%.
5

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
Akangka
sumber
Anda memiliki bahasa yang berbeda dan jawaban yang lebih pendek, jadi tidak ada salahnya menggunakan pendekatan yang sama dengan jawaban Mathematica.
Perhatikan bahwa kami mencari skor terendah, bukan poster tercepat atau algoritma paling baru.
@ Ville-ValtteriTiittanen Tetap saja, jawaban Martin Büttner masih lebih rendah dari saya
Akangka
@ChristianIrwan Milikmu menarik karena menghasilkan kapitalisasi yang berbeda (dan aku yakin golf bisa dekat denganku atau bahkan mungkin mengalahkannya, tapi aku tidak punya waktu untuk melihatnya secara detail sekarang).
Martin Ender
4

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 10 = 1024, mendapatkan siklus iterasi 890 cukup bagus.)

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

Ilmari Karonen
sumber
3

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.

Mike Bufardeci
sumber
Perhatikan bahwa jawaban ini tidak valid secara singkat sampai aturan dikembalikan ke yang membutuhkan dua iterasi daripada tiga. Namun sekarang valid lagi.
DLosc
3

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
Conor O'Brien
sumber
Apakah program ini memenuhi syarat untuk bonus -50%? Sepertinya bisa, tetapi Anda tidak memposting output apa pun.
@ Ville-ValtteriTiittanen Hanya berjalan dua kali. Saya sedang mengerjakan bonus saat ini.
Conor O'Brien
2

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.

histokrat
sumber
1

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"!

Fabian Schmengler
sumber
baru menyadari bahwa saya dapat mengubah (int)trueke `` !! i` dan menyimpan 12 byte. Akan mencoba untuk bermain golf sedikit lebih lambat
Fabian Schmengler 5'15
1

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.

DLosc
sumber
1

Javascript, 52 byte

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

Uji

=>

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

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

<= 'helloworld'

Fuzzyzilla
sumber
1

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

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

Cobalah online!

Output pertama:

/ //hello world

Output kedua:

helloworld
Sagittarius
sumber
Bonus untuk lebih dari dua iterasi, sehingga skor Anda masih 23 byte
Jo King
1

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/

Andrew Paul
sumber
Saya pasti tidak pernah menggunakan BBC BASIC, tetapi bagaimana ini bisa diuji? Jika saya menempelkan ini ke emulator yang terhubung, baris terakhir sepertinya menghasilkan "Kesalahan" untuk saya.
kata ganti saya adalah monicareinstate
Saya akan mengedit jawaban saya untuk kejelasan. Itu hanya baris pertama yang perlu ditempel. Baris kedua, yang dihasilkan dapat disalin dan dieksekusi dalam emulator dengan menggunakan kursor PC dan tombol 'ujung'. Baris ketiga diizinkan tidak valid sesuai aturan.
Andrew Paul