"Hallo Welt", die ein anderes "Hallo Welt" -Programm erstellt

19

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.


quelle
1
Gelten die üblichen Quine-Regeln oder darf das Programm seine eigene Quelldatei lesen?
Martin Ender
1
Es gelten die üblichen Regeln für Quine.
Zählt der ursprüngliche Code für die Boni? Muss der ursprüngliche Code ebenfalls einen gültigen enthalten hello world?
Martin Ender
1
Der Originalcode zählt für Boni. Der Originalcode muss keine gültige Hallo-Welt enthalten.
Sind Sie sicher, dass sich die Regeln zuletzt geändert haben? Zusammen mit "Das erste Programm muss keine gültige Hallo-Welt-Zeichenfolge enthalten, oder es kann mehrere gültige Hallo-Welt-Zeichenfolgen enthalten." Ich könnte die fehlenden Variationen als Kommentar zum ursprünglichen Quellcode hinzufügen, um den Bonus zu erhalten (wahrscheinlich nicht wert in den meisten Fällen, sieht aber immer noch wie eine Lücke aus)
Fabian Schmengler

Antworten:

8

Pyth, 17 Bytes

Eine andere Pyth-Lösung:

"r\"helloworld\"1

Ausgabe:

r"helloworld"1

Zweiter Ausgang:

HELLOWORLD
Fabian Schmengler
quelle
Die aktuellen Regeln lauten "Ihr Programm schlägt fehl, sobald eine der folgenden Bedingungen erfüllt ist: Die Ausgabe ist nicht mehr in derselben Sprache gültig." Und "Ihr Programm ist für diesen Wettbewerb nur gültig, wenn mindestens drei erste Ausführungen erfolgreich sind." . Ist HELLOWORLD ein gültiges Programm in Pyth? Wenn ja, posten Sie bitte auch die Ausgabe oder erklären Sie, was es tut. Wenn nicht, denke ich, dass dieses Programm ungültig ist.
Außerdem möchte ich klarstellen, dass dieses Programm nicht gegen Regeln zur Wiederholung derselben Zeichenfolge verstößt. Diese Lösung wiederholt "helloworld", das im ersten Quellcode war. Regeln verbieten nur das Wiederholen einer Zeichenfolge, die in den vorherigen Ausgaben enthalten war. Wenn die zweite Ausgabe ein gültiges Pyth-Programm ist, ist diese Lösung vollkommen gültig.
Zum Zeitpunkt der Beantwortung lauteten die Regeln "Ihr Programm ist für diesen Wettbewerb nur gültig, wenn mindestens zwei erste Hinrichtungen erfolgreich sind"
Fabian Schmengler
Oh, du hast recht. Ich bin mir nicht sicher, warum ich das geändert habe, da in meinem Beispiel im ersten Beitrag angegeben ist, dass zwei Ausgaben = gültige Lösung sind. Ich werde die Regeln korrigieren, um dies widerzuspiegeln. Ihre Lösung ist also gültig. Es ist im Moment auch die beste gültige Lösung.
9

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 .

LegionMammal978
quelle
1
Schade, dass man in Mathematica-Quines kein Leerzeichen ausgeben und keine Präfix- und Infix-Notation verwenden kann, oder? ;) (Dies könnte lang genug sein, damit der umgekehrte quine-Ansatz funktioniert, bei dem Sie den Code in einer Zeichenfolge speichern sund mit auswerten ToExpression.)
Martin Ender,
6

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.

Addison Crump
quelle
1
o_o Simplex kämpfte sich auf 21 runter. Ich werde jedoch daran arbeiten, 18.15 zu schlagen!
Conor O'Brien
@ CᴏɴᴏʀO'Bʀɪᴇɴ Vitsy wurde praktisch entwickelt, um seinen eigenen Quellcode zu bearbeiten und grundlegende Zeichenfolgenmanipulationen durchzuführen. XD Ich denke, das kann man aber besser spielen.
Addison Crump
Ich dachte, Simplex wäre großartig, da es eine äußere Programmfunktion hat, aber nein, das würde als ein Programm gelten. le sigh
Conor O'Brien
+1 für das Schlagen (oder fast Schlagen) der "klassischen"
Golfsprachen
@ ev3commander Ich hätte sie geschlagen, wenn der Iterationsbonus höher gewesen wäre. : c
Addison Crump
5

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.

Martin Ender
quelle
Ist dies für den Bonus von -10% qualifiziert? Die Ausgaben enthalten nur zwei der drei gültigen Interpunktionsformen.
Mike Bufardeci
@ MikeBufardeci Oh, gute Frage ... Ich nahm an, dass der ursprüngliche Code ein Teil davon war.
Martin Ender
1
Ich habe Regeln klargestellt, damit der ursprüngliche Code für den Bonus gezählt wird. Obwohl ich zugeben muss, dass ich nicht wusste, dass es so einfach ist, -10% zu bekommen.
5

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
Akangka
quelle
Sie haben eine andere Sprache und eine kürzere Antwort, so dass es nichts auszusetzen gibt, wenn Sie den gleichen Ansatz wie die Mathematica-Antwort verwenden.
Beachten Sie, dass wir nach der niedrigsten Punktzahl suchen, nicht nach dem schnellsten Poster oder dem neuesten Algorithmus.
@ Ville-ValtteriTiittanen Trotzdem ist Martin Büttners Antwort immer noch niedriger als ich
Akangka
@ChristianIrwan Yours ist interessant, weil es zwar unterschiedliche Groß- und Kleinschreibung erzeugt (und ich bin sicher, es ist gut, in meine Nähe zu kommen oder es sogar zu schlagen, aber ich habe momentan keine Zeit, es mir genauer anzusehen).
Martin Ender
4

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 10 = 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%. ;-)

Ilmari Karonen
quelle
3

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.

Mike Bufardeci
quelle
Beachten Sie, dass diese Antwort für kurze Zeit ungültig war, bis die Regeln auf zwei statt drei Iterationen zurückgesetzt wurden. Es ist jetzt aber wieder gültig.
DLosc
3

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
Conor O'Brien
quelle
Ist dieses Programm für den Bonus von -50% berechtigt? Es sieht so aus, als ob es möglich wäre, aber Sie haben keine Ausgaben veröffentlicht.
@ Ville-ValtteriTiittanen Es läuft nur zweimal. Ich arbeite gerade an Boni.
Conor O'Brien
2

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.

Histokrat
quelle
1

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!

Fabian Schmengler
quelle
habe gerade gemerkt, dass ich (int)truezu `` !! i` wechseln und 12 Bytes sparen kann. Ich werde versuchen, etwas später Golf zu spielen
Fabian Schmengler,
1

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.

DLosc
quelle
1

Javascript, 52 Bytes

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

Prüfung

=>

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

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

<= 'helloworld'

Fuzzyzilla
quelle
1

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

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

Probieren Sie es online!

Erste Ausgabe:

/ //hello world

Zweiter Ausgang:

helloworld
Schütze
quelle
Der Bonus ist für mehr als zwei Iterationen, so dass Ihre Punktzahl immer noch 23 Bytes beträgt
Jo King
1

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.

Andrew Paul
quelle
Ich habe BBC BASIC definitiv noch nie benutzt, aber wie kann das getestet werden? Wenn ich dies in den verknüpften Emulator einfüge, scheint die letzte Zeile für mich "Fehler" auszugeben.
Mein Pronomen ist monicareinstate
Ich bearbeite meine Antwort aus Gründen der Klarheit. Es ist nur die erste Zeile, die eingefügt werden muss. Die zweite, generierte Zeile kann im Emulator mithilfe des PC-Cursors und der Ende-Tasten kopiert und ausgeführt werden. Die dritte Zeile darf nach den Regeln ungültig sein.
Andrew Paul