Erstellen Sie ein Programm, das einen Hallo-Welt-String ("Hallo-Welt", "Hallo-Welt" usw.) und Quellcode ausgibt. Die Ausgabe wird auf stdout oder ein gleichwertiges Format geschrieben. Hallo Weltzeichenfolge ist in den Quellcode eingebettet.

Beispielsweise könnte die Ausgabe für sein

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

Wenn die Ausgabe erneut kompiliert oder interpretiert wird, sollte sie eine ähnliche Ausgabe erzeugen, aber die Hello World-Zeichenfolge muss eine andere Interpunktion oder Großschreibung haben. Im vorherigen Beispiel könnte beispielsweise die folgende Ausgabe erstellt werden

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

Jedes "(hier etwas Quellcode)" in diesen Beispielen kann sich nach jeder Ausführung ändern oder es kann dasselbe sein.

Ihre Ausgabe muss genau einmal eine gültige Hallo-Welt-Zeichenfolge enthalten. Es kann eine beliebige Anzahl ungültiger Hallo-Welt-Zeichenfolgen enthalten. Der Quellcode kann eine beliebige Anzahl von Kommentaren enthalten, und der Hallo-Welt-String kann in Kommentare eingebettet sein. Das erste Programm kann entweder null oder eine gültige Hallo-Welt-Zeichenfolge haben, aber nicht mehr.

Folgende Interpunktion ist gültig:

hello, world
hello world
helloworld

Jede Großschreibung ist akzeptabel. Dies sind beispielsweise gültige Hallo-Welt-Zeichenfolgen:

Hello, world
hellO WORld
HELLoworlD

Diese Zeichenfolgen sind ungültig:

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

Ihr Programm schlägt fehl, sobald eine der folgenden Bedingungen erfüllt ist:

• Es gibt einen Hallo-Welt-String aus, der während einer früheren Ausführung ausgegeben wurde.
• Ausgabe ist nicht mehr gültiger Quellcode in derselben Sprache oder
• Die Ausgabe enthält nicht genau einen gültigen Hallo-Welt-String.

Ihr Programm ist für diesen Wettbewerb nur gültig, wenn mindestens zwei erste Ausführungen erfolgreich sind. Dies bedeutet, dass die dritte Ausgabe ungültig sein darf. Die Ausgabe Ihres Programms kann nicht zufällig sein. Die erste Ausführung sollte immer die gleiche zweite Ausgabe erzeugen, die zweite Ausführung sollte immer die gleiche dritte Ausgabe erzeugen usw.

Die Bewertung wird als Anzahl von Bytes im Quellcode des ursprünglichen Programms berechnet. Die niedrigste Punktzahl gewinnt.

Es gelten folgende Boni (bis zu -60%):

• -5% * (N - 2), wobei N der Index der Ausführung ist, nach dem Ihr Programm eine ungültige Ausgabe erzeugt. Dieser Bonus ist auf -50% begrenzt. Wenn Ihr Programm 12 Mal oder mehr erfolgreich ist, erhalten Sie den maximalen Bonus.
• -10%, wenn Ihre Ausgaben (einschließlich des ersten Quellcodes) alle drei gültigen Interpunktionsalternativen enthalten.

Ihre Einreichung sollte den ersten Quellcode und die Ausgaben der erfolgreichen Ausführungen enthalten. Wenn Ihr Programm mehr als 12 Mal erfolgreich ist, fügen Sie die Ausgabe für 12 Ausführungen hinzu.

Beispiel

Nächste Zeile ist der erste Quellcode. Wenn wir es ausführen, ist es die erste Ausführung.

hello world(some source code here)

In der nächsten Zeile wird der erste Quellcode ausgegeben. Es ist die erste Ausgabe.

hello, world(some source code here) 

Nächste Zeile ist die Ausgabe der zweiten Ausführung. Es ist die zweite Ausgabe.

helloworld(some source code here)

Als wir die erste Ausgabe ausführten, wurde dieses Programm für den Bonus von -10% qualifiziert. Das heißt, wir haben zwei Ausgaben und einen Originalcode, die alle unterschiedliche Interpunktion haben. Da die zweite Ausgabe gültig war, ist dieses Programm für diesen Wettbewerb berechtigt.

Nächste Zeile ist die Ausgabe der dritten Ausführung. Es ist die dritte Ausgabe.

Helloworld(some source code here)

Nächste Zeile ist die Ausgabe der vierten Ausführung. Es ist die vierte Ausgabe.

hellworld(some source code here)

Diese Ausgabe war ungültig. Index der letzten gültigen Ausführung war 4. Für dieses Programm werden -5% * (4 - 2) Bonus und -10% Bonus auf die Zeichensetzung gewährt. Das sind insgesamt -20%. Die Länge des ersten Quellcodes ("Hallo Welt (etwas Quellcode hier)") betrug 34 Bytes, das Endergebnis ist also 27,2.

Pyth, 17 Bytes

Eine andere Pyth-Lösung:

"r\"helloworld\"1

Ausgabe:

r"helloworld"1

Zweiter Ausgang:

HELLOWORLD

Mathematica, 214 - 50% = 107 Bytes

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

Ich habe mich entschlossen, die Anzahl der Zeichenfolgen hier zu optimieren. Dies läuft für 1024 Programme ohne anzuhalten und durchläuft jede Kombination von Groß- und Kleinbuchstaben. Die Ausführung ist zu sehen, hier .

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

Heh! Schlag das! Das wirst du wahrscheinlich. : c

Erste Ausgabe:

'0DV \ {25 ^ -V \}} 1+ {rd3 * Z; helloworld
'Fang an, als Zeichenfolge zu erfassen
 0DV 0 in den Stapel schieben und als letzte Variable festlegen.
    \ Wiederholen Sie den nächsten Eintrag so oft. (1, 2, 3 ... an den Ausgängen.)
     {Drehen Sie den Stapel nach links.
      25 ^ 32 zum Stapel schieben.
         - Subtrahieren Sie das oberste Element, um Kleinbuchstaben in Großbuchstaben umzuwandeln.
          V \ Führe den nächsten Punkt mit variablen Endzeiten aus.
            } Drehen Sie den Stapel nach rechts.
             } Und wieder...
              1+ Fügen Sie eine hinzu. Dies macht die 0 in diesem Code eine 1, dann 2 ...
                r Drehen Sie den Stapel um.
                 d3 * Hole den Charakter '
                    Z Alle Elemente im Stapel ausgeben.
                     ; Ausführung beenden.
                      helloworld String zum manipulieren.

Zweiter Ausgang:

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

Dritte Ausgabe:

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

Vierte Ausgabe:

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

Fünfte Ausgabe:

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

Sechste Ausgabe:

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

Siebte Ausgabe:

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

Achte Ausgabe:

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

Neunte Ausgabe:

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

Zehnte Ausgabe:

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

Elfte Ausgabe:

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

Dies ist die letzte Ausgabe, da sie einen Fehler verursacht.

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

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

Dies startet die folgende Kette:

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

wobei der letzte kein gültiges "Hallo Welt" mehr enthält.

Teste es hier.

Erläuterung

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

Beachten Sie, dass das anfängliche Programm kein gültiges "Hallo Welt" enthält, dass es uns jedoch ermöglicht, eine Iteration weiterzugehen.

CJam 69 60 - 50% = 30

Ich bin noch Anfänger, bitte sag mir, wie man in CJam Golf spielt.

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

Es ist mühsam, jede Iteration zu drucken, da sie für 99 Iterationen gültig ist.

Es funktioniert durch Aufzählen der Großschreibung von Hallo Wort. Die Mühe besteht darin, die Strings in Teile aufzuteilen, da sowohl "Hallo Welt" als auch der Zähler aktualisiert werden müssen.

Erläuterung

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

HINWEIS: Ich habe die Mathematica-Antwort nicht gelesen. Tut mir leid, ich denke, sie war originell

Bei Neuordnung und unterschiedlicher Groß- und Kleinschreibung verliere ich 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

Zählen Sie diesmal auch die Interpunktion auf.

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

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

Ich beschloss, die Anzahl der Hinrichtungen vor einer Wiederholung zu übertreiben. Dieses Programm, dessen Ausgabe in den GolfScript-Interpreter zurückgeführt wird, erzeugt vor der ersten Wiederholung 890 verschiedene Hello World-Strings. Als kurzes Beispiel sind hier die ersten 15 Iterationen:

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

Die Arbeitsweise besteht darin, die Zeichenfolge zu durchlaufen und die Groß- und Kleinschreibung jedes Buchstabens umzukehren (indem der ASCII-Code mit 32 XOR-verknüpft wird), wenn der vorherige Buchstabe (nachdem möglicherweise die Groß- und Kleinschreibung umgedreht wurde) klein geschrieben ist. Die Groß- und Kleinschreibung des ersten Buchstabens wird umgedreht, wenn die Zahl am Anfang des Programms 32 und nicht 0 ist. Die Zahl für die nächste Iteration wird immer dann 32 sein, wenn der letzte Buchstabe des Strings in Kleinbuchstaben geschrieben ist Die Zeichenfolge, die bei der nächsten Iteration an den Anfang zurückgegeben werden soll.

(Dieser spezielle Rückkopplungsprozess wurde vollständig erhalten spontan durchgeführt. Eigentlich wollte ich nur einen einfachen Binärzähler mit Groß- und Kleinbuchstaben als Bits ausführen, aber die Implementierung dauerte zu viele Bytes, und so fing ich an, ihn zu optimieren, um etwas Kürzeres zu finden das würde immer noch eine ziemlich hohe Zykluslänge ergeben. Da das theoretische Maximum, wenn nur die Groß- / Kleinschreibung verwendet wird, 2 ¹⁰ = 1024 ist, ist es ziemlich schön, einen 890-Iterationszyklus zu erhalten.)

Leider ist der Bonus für zusätzliche Iterationen auf -50% begrenzt. Ohne die Obergrenze hätte dieses Programm einen unglaublichen Bonus von −4440%. ;-)

Pyth, 18 Bytes

"-\"hello world\"d

Welches gibt zurück:

-"hello world"d

Was wiederum druckt:

helloworld

Ich hatte eine Lösung, die alle drei Schreibweisen beherrschte, aber es ist sogar mit dem Bonus länger.

Simplex , 21 Bytes.

Dafür wurde Simplex geboren . Damit kann ich definitiv weitermachen.

(Ich drücke weiterhin Strg + Eingabetaste. Tut mir leid. Ich beschuldige die Tablett-Tastatur.)

Versuch 3, v.0.8 +, 31 -5% = 29.45 Bytes (UTF-8-Methoden)

Das Emote in der Mitte drückt mich aus. Art von. Warum habe ich das nochmal gemacht? ._.

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

2. Ausgabe:

"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. Ausgabe:

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

Endgültige Ausgabe:

HelloworlD

Versuch 2, v.0.8 +, 21 Bytes (UTF-8, denke ich)

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

Ausgabe:

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

Endgültige Ausgabe:

helloworld

Versuch 1, v.0.7 + 28 26 Bytes

Ich bin mir nicht sicher, ob dies für den ersten Bonus qualifiziert ist ...

"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

Erste Ausgabe:

"HELLOWORLD"g

Das äußere Programm wird am Ende der Ausführung ausgewertet (es tut es für y; so sieht das äußere Programm aus:

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

Endgültige Ausgabe:

HELLOWORLD

Rubin, 81 - 50% = 40,5

Originalcode:

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

Aufeinanderfolgende Ausgaben:

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

Ich denke das zählt als die vollen 50%? Könnte um eins abgehen. Außerdem gibt es in Ruby wahrscheinlich eine besser bewertete Nicht-Bonus-Lösung.

Der Originalcode enthält nicht "helloworld", sondern ein Quine, das den ersten Großbuchstaben im Quellcode durch die Kleinbuchstaben ersetzt. So wird bei jedem Durchlauf des Quines ein Großbuchstabe weniger ausgegeben.

Der Trick dabei ist, eine Formatzeichenfolge zu verwenden, um sowohl die Zeichenfolge selbst zum Quinieren als auch die Hello World-Zeichenfolge so zu interpolieren, dass sie nur einmal angezeigt wird.

PHP, 297 - 40% = 178,2 Byte

Nicht wirklich konkurrenzfähig, aber es hat Spaß gemacht zu schreiben

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

Es ist eine Variation dieser Quine:

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

es fügt aber auch "helloworld" zur Ausgabe hinzu und ersetzt 0mit 0+1(in der nächsten Iteration 1mit 1+1und so weiter). Die Verwendung substreiner vorhandenen "helloworld" -Ausgabe wird entfernt, bevor die neue "helloworld" hinzugefügt wird.

Um eine andere Ausgabe zu erhalten, wird ein Buchstabe von "helloworld" großgeschrieben (bestimmt durch die inkrementelle Zahl). Dies ist der relevante Code:

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

Eine Herausforderung bestand darin, außer hier und für die Nummernersetzung keine Nummern zu verwenden

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

Da siehst du schon, dass +1das realisiert wird als +(int)true.

Für die Teilstring-Argumente brauchte ich 0, 146:

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

Die nicht leere Zeichenfolge "i" wird erzwungen trueund negiert. falseist ein gültiges ganzzahliges Argument und wird wie folgt behandelt 0. ord(I)ist der ASCII-Wert von "I": 73

Ausgabe (1. Iteration):

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

Ausgabe (2. Iteration):

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

Ausgabe (10. Iteration):

Dies ist die letzte gültige Ausgabe, aber kein gültiges Programm mehr

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

Scrolle ganz nach rechts, um die "Hallo Welt" -Strings zu finden!

Pip, 48 - 50% = 24

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

was sich wie folgt entwickelt:

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"

Die letzte Ausgabe ist ungültig, da sich die HELLOWORLDnicht geändert hat. (Korrigieren Sie mich, wenn ich den Bonus nicht richtig gemacht habe.)

Dank dieser Frage habe ich gerade eine neue Quine-Technik entdeckt! Die Grundquine ist 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

Unser zusätzlicher Code ändert die Zeichenfolge yvor dem erneuten Darstellen wie folgt:

• Ersetzen Sie die aktuelle Welt durch eine Welt ganz links 0 Zeichen ganz in Großbuchstaben geschrieben sind.
• Ersetzen Sie alle Vorkommen von 0durch o+0(wobei oeine eingebaute Variable gleich 1 ist).

Das nächste Mal um die Nummer im Code ist 1statt 0, und so weiter.

Javascript, 52 Bytes

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

Prüfung

=>

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

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

<= 'helloworld'

///, 23 Bytes - 10% = 20,7 & le;

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

Probieren Sie es online!

Erste Ausgabe:

/ //hello world

Zweiter Ausgang:

helloworld

BBC BASIC, 56 Bytes

Ich hatte einen Riss, bevor mir klar wurde, wie spät ich zum Spiel bin. Hier ist meine Version und mein erster Versuch, StackExchange Code Golf zu spielen.

Hier gibt V. die Zeichen aus, die durch die ASCII-Codes in der folgenden durch Kommas getrennten Liste angegeben sind, und P. ist eine Kurzform für den Ausdruck. Ich benutze das Backspace-Zeichen, um die vorhandene 'helloworld'-Zeichenfolge zu überschreiben.

Gebe den Code ein:

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

Erste Ausgabe:

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

Zweiter Ausgang:

helloworLD

Es kann online unter https://bbc.godbolt.org/ getestet werden.