Utwórz program, który generuje ciąg hello world („Hello world”, „Hello, World” itp.) I kod źródłowy. Dane wyjściowe są zapisywane na standardowym lub równoważnym. Łańcuch Hello world jest osadzony w kodzie źródłowym.

Na przykład wynikiem może być

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

Kiedy dane wyjściowe zostaną ponownie skompilowane lub zinterpretowane, powinny utworzyć podobne dane wyjściowe, ale ciąg znaków hello world musi mieć inną interpunkcję lub wielkie litery. Na przykład w poprzednim przykładzie można utworzyć następujące dane wyjściowe

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

Każdy „(tutaj trochę kodu źródłowego)” w tych przykładach może ulec zmianie po każdym wykonaniu lub może być taki sam.

Twoje dane wyjściowe muszą zawierać prawidłowy ciąg hello world dokładnie raz. Może zawierać dowolną liczbę niepoprawnych ciągów hello world. Kod źródłowy może zawierać dowolną liczbę komentarzy, a ciąg hello world może być osadzony w komentarzach. Pierwszy program może mieć zero lub jeden prawidłowy ciąg znaków hello world, ale nie więcej.

Ważna jest następująca interpunkcja:

hello, world
hello world
helloworld

Wszelkie wielkie litery są dopuszczalne. Na przykład są to poprawne ciągi znaków hello world:

Hello, world
hellO WORld
HELLoworlD

Te ciągi są nieprawidłowe:

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

Twój program kończy się niepowodzeniem, gdy zostanie spełniony jeden z następujących warunków:

• Wyświetla ciąg znaków hello world, który został wygenerowany podczas wcześniejszego wykonania,
• wynik nie jest już poprawnym kodem źródłowym w tym samym języku lub
• dane wyjściowe nie zawierają dokładnie jednego prawidłowego ciągu hello world.

Twój program nie jest ważny w tym konkursie, chyba że co najmniej dwa pierwsze wykonania zakończą się powodzeniem. Oznacza to, że trzecie wyjście może być nieprawidłowe. Dane wyjściowe Twojego programu mogą nie być losowe. Pierwsze wykonanie powinno zawsze tworzyć takie same drugie wyjście, drugie wykonanie powinno zawsze tworzyć takie samo trzecie wyjście itp.

Wynik jest obliczany jako ilość bajtów w kodzie źródłowym programu początkowego. Najniższy wynik wygrywa.

Obowiązują następujące bonusy (do -60%):

• -5% * (N - 2), gdzie N jest indeksem wykonania, po którym program wygeneruje nieprawidłowe dane wyjściowe. Ten bonus ogranicza się do -50%. Jeśli Twój program odniesie 12 lub więcej sukcesów, otrzymasz maksymalną premię.
• -10%, jeśli twoje dane wyjściowe (w tym pierwszy kod źródłowy) zawierają wszystkie trzy prawidłowe alternatywy interpunkcyjne.

Twoje zgłoszenie powinno zawierać pierwszy kod źródłowy, a także zawierać wyniki pomyślnych wykonań. Jeśli twój program odniesie sukces więcej niż 12 razy, dodaj wynik dla 12 wykonań.

Przykład

Następny wiersz to pierwszy kod źródłowy. Kiedy go wykonujemy, jest to pierwsze wykonanie.

hello world(some source code here)

Następny wiersz to wynik pierwszego kodu źródłowego. To jest pierwsze wyjście.

hello, world(some source code here) 

Następny wiersz to wynik drugiego wykonania. To drugie wyjście.

helloworld(some source code here)

Kiedy wykonaliśmy pierwsze wyjście, program ten kwalifikował się do premii -10%. Oznacza to, że mamy dwa wyjścia i jeden oryginalny kod, z których każdy ma inną interpunkcję. Ponadto, ponieważ drugie wyjście było ważne, ten program kwalifikuje się do tego konkursu.

Następny wiersz to wynik trzeciego wykonania. To trzecie wyjście.

Helloworld(some source code here)

Następny wiersz to wynik czwartego wykonania. To czwarte wyjście.

hellworld(some source code here)

To wyjście było nieprawidłowe. Indeks ostatniego ważnego wykonania wynosił 4. Ten program kwalifikuje się do premii -5% * (4 - 2) i -10% premii za interpunkcję. To daje w sumie -20%. Długość pierwszego kodu źródłowego („witaj świecie (tutaj trochę kodu źródłowego)”) wynosiła 34 bajty, więc końcowy wynik to 27,2.

Pyth, 17 bajtów

Inne rozwiązanie Pyth:

"r\"helloworld\"1

Wynik:

r"helloworld"1

Drugie wyjście:

HELLOWORLD

Mathematica, 214 - 50% = 107 bajtów

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

Postanowiłem zoptymalizować tutaj liczbę ciągów. Działa to dla 1024 programów bez zatrzymywania, przechodząc przez każdą kombinację wielkich i małych liter. Wykonanie można zobaczyć tutaj .

Vitsy, 33–33 * .05 * (11–2) = 18,15 bajtów

Heh! Pobij to! Prawdopodobnie będziesz. :do

Pierwsze wyjście:

„0DV \ {25 ^ -V \}} 1+ {rd3 * Z; helloworld
Rozpocznij przechwytywanie jako ciąg
 0DV Wciśnij 0 do stosu i ustaw jako ostatnią zmienną.
    \ Powtórz tę czynność wiele razy. (1, 2, 3 ... na wyjściach.)
     {Obróć stos w lewo.
      25 ^ Naciśnij 32 na stos.
         - Odejmij górny element - spowoduje to, że małe litery będą wielkie.
          V \ Wykonaj następny element zmiennej zmiennej razy.
            } Obróć stos w prawo.
             } I ponownie...
              1+ Dodaj jeden. To powoduje, że 0 w tym kodzie to 1, a następnie 2 ...
                r Odwróć stos.
                 d3 * Zdobądź postać
                    Z Wyjście wszystkich elementów ze stosu.
                     ; Zakończ wykonywanie.
                      helloworld Ciąg do manipulowania.

Drugie wyjście:

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

Trzeci wynik:

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

Czwarta moc wyjściowa:

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

Piąte wyjście:

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

Szósty wynik:

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

Siódma produkcja:

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

Ósma moc wyjściowa:

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

Dziewiąte wyjście:

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

Dziesiąta moc wyjściowa:

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

Jedenaste wyjście:

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

To jest ostatnie wyjście, ponieważ spowoduje błąd.

CJam, n = 3 4 bajty 28 - 10% - 10% = 22,4

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

uruchamia to następujący łańcuch:

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

gdzie ostatni nie zawiera już ważnego „Hello, World”.

Sprawdź to tutaj.

Wyjaśnienie

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

Zauważ, że początkowy program nie zawiera poprawnego „Hello, World”, ale to pozwala nam przejść o jedną iterację dalej.

CJam 69 60-50 % = 30

Nadal jestem początkujący, powiedz mi, jak grać w golfa w CJam.

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

Drukowanie każdej iteracji jest uciążliwe, ponieważ będzie obowiązywać przez 99 iteracji.

Działa poprzez wyliczenie wielkich liter słowa „witaj”. Tedium polega na dzieleniu łańcuchów na części, ponieważ zarówno „witaj świecie”, jak i licznik należy zaktualizować.

Wyjaśnienie

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

UWAGA: Nie czytam odpowiedzi Mathematica, przepraszam, myślę, że była oryginalna

Po zmianie kolejności i różnej wielkości liter tracę 9 bajtów.

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

Tym razem wylicz także interpunkcję.

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

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

Zdecydowałem się na przesadną liczbę egzekucji przed powtórzeniem. Ten program, którego dane wyjściowe zostaną przesłane z powrotem do interpretera GolfScript, wygeneruje 890 różnych ciągów Hello World przed pierwszym powtórzeniem. Oto krótkie 15 pierwszych iteracji:

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

Działa to poprzez iterację ciągu, odwracanie wielkich liter każdej litery (przez XOR kod ASCII z 32), jeśli poprzednia litera (po ewentualnym odwróceniu wielkości liter) ma małe litery. Pierwsza litera zostanie odwrócona, jeśli liczba na początku programu wynosi 32 zamiast 0 - a liczba wyjściowa dla następnej iteracji będzie wynosić 32 za każdym razem, gdy ostatnia litera łańcucha jest mała, co powoduje zmiany na końcu ciąg do propagacji z powrotem na początek podczas następnej iteracji.

(Ten szczególny proces sprzężenia zwrotnego został uzyskany całkowicie ad hoc . Początkowo chciałem po prostu uruchomić prosty licznik binarny, używając wielkich i małych liter jako bitów, ale jego wdrożenie zajęło zbyt wiele bajtów, więc zacząłem go poprawiać, aby znaleźć coś krótszego to wciąż dawałoby dość wysoką długość cyklu. Ponieważ teoretyczne maksimum, przy użyciu tylko przerzucania wielkości liter, wynosi 2 ¹⁰ = 1024, uzyskanie cyklu iteracji 890 jest całkiem niezłe).

Niestety, premia za dodatkowe iteracje jest ograniczona do -50%; bez ograniczenia program ten miałby ogromną premię -4440%. ;-)

Pyth, 18 bajtów

"-\"hello world\"d

Które zwraca:

-"hello world"d

Co z kolei drukuje:

helloworld

Miałem rozwiązanie, które wykonało wszystkie trzy pisowni, ale jest dłuższe nawet z premią.

Simplex , 21 bajtów.

To co Simplex był urodzony na. Zdecydowanie mogę z tym pójść dalej.

(Wciąż wciskam Ctrl + Enter, przepraszam! Obwiniam to na klawiaturze tabletu)

Próba 3, wer. 0,8 +, 31 -5% = 29,45 bajtów (metinks UTF-8)

Ta emotka pośrodku wyraża mnie. Raczej. Dlaczego znowu to zrobiłem? ._.

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

2. wyjście:

"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. wyjście:

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

Końcowe wyjście:

HelloworlD

Próba 2, wer. 0.8 +, 21 bajtów (chyba UTF-8)

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

Wynik:

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

Końcowe wyjście:

helloworld

Próba 1, wersja 0. + 28 26 bajtów

Nie jestem pewien, czy to kwalifikuje się do pierwszego bonusu…

"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

Pierwsze wyjście:

"HELLOWORLD"g

Program zewnętrzny jest oceniany pod koniec wykonywania (robi to dla y; tak wygląda program zewnętrzny:

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

Końcowe wyjście:

HELLOWORLD

Rubinowy, 81-50% = 40,5

Oryginalny kod:

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

Kolejne wyniki:

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

Myślę, że liczy się to jako pełne 50%? Może być wyłączony o jeden. Poza tym w Ruby jest prawdopodobnie lepsze rozwiązanie bez premii.

Oryginalny kod nie zawiera „helloworld”, ale tworzy quine, która zastępuje pierwszą wielką literę w kodzie źródłowym wersją pisaną małymi literami. Tak więc z każdym kolejnym uruchomieniem quine wyprowadzana jest jedna litera mniej.

Sztuczka polega na tym, aby użyć łańcucha formatu do interpolacji zarówno samego łańcucha, do quitingu, jak i łańcucha Hello World, aby pojawiał się tylko raz.

PHP, 297 - 40% = 178,2 bajtów

Nie bardzo konkurencyjny, ale pisanie było fajne

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

To odmiana tego quine:

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

ale dodaje również „helloworld” do wyniku i zastępuje 0go 0+1(w następnej iteracji 1z1+1 i tak dalej). Korzystanie z substristniejącego wyjścia „helloworld” zostaje usunięte przed dodaniem nowego „helloworld”.

Aby uzyskać inny wynik, jedna litera „helloworld” jest pisana wielkimi literami (określana przez liczbę rosnącą). To jest odpowiedni kod:

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

Wyzwanie polegało na tym, aby nie używać żadnych numerów oprócz tutaj i do wymiany numerów

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

Tam już widzisz, że +1jest to realizowane jako+(int)true .

Do argumentów podciągu potrzebowałem 0, 146:

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

Zmusza się niepusty łańcuch „i” true i zanegowany. falsejest poprawnym argumentem liczby całkowitej i jest traktowany jak 0.ord(I)to wartość ASCII „I”: 73

Wyjście (pierwsza iteracja):

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

Wyjście (2. iteracja):

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

Wyjście (10. iteracja):

To jest ostatnie prawidłowe wyjście, ale już nie jest to poprawny program

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

Przewiń daleko w prawo, aby znaleźć ciągi „Hello world”!

Pip, 48-50% = 24

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

który rozwija się następująco:

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"

ostatnie wyjście jest niepoprawne, ponieważ HELLOWORLD nie uległo zmianie. (Popraw mnie, jeśli nie zrobiłem dobrze bonusu.)

Dzięki temu pytaniu właśnie odkryłem nową technikę quine! Podstawowy quine to 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

Nasz dodatkowy kod modyfikuje ciąg yprzed ponownym przetworzeniem w następujący sposób:

• Zastąp obecny świat piekielny światem, w którym skrajnie lewy 0 znaki znajdujące się są wielkie;
• Wymienić wszystkie wystąpienia 0z o+0(jeśli ojest zmienna wbudowane równa 1).

Następnym razem wokół numeru w kodzie jest 1zamiast 0, i tak dalej.

JavaScript, 52 bajty

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

Test

=>

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

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

<= 'helloworld'

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

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

Wypróbuj online!

Pierwsze wyjście:

/ //hello world

Drugie wyjście:

helloworld

BBC BASIC, 56 bajtów

Zrozumiałem to, zanim zdałem sobie sprawę, jak późno jestem w grze. Oto, co warto, oto moja wersja i moja pierwsza próba kodu golfowego StackExchange.

Tutaj V. przypomina znaki podane przez kody ASCII na poniższej liście oddzielonej przecinkami, a P. jest skrótem do wydrukowania. Korzystam z znaku backspace, aby zastąpić istniejący ciąg „helloworld”.

Kod wejściowy:

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

Pierwsze wyjście:

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

Drugi wynik:

helloworLD

Można to przetestować online na https://bbc.godbolt.org/