Crea un programma che emetta una stringa di Hello World ("Hello world", "Hello, World" ecc.) E un codice sorgente. L'output viene scritto su stdout o equivalente. Hello world string è integrata nel codice sorgente.

Ad esempio, l'output per potrebbe essere

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

Quando l'output viene compilato o interpretato di nuovo, dovrebbe creare un output simile, ma la stringa di Hello World deve avere punteggiatura o maiuscole diverse. Ad esempio, l'esempio precedente potrebbe creare il seguente output

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

Ogni "(un po 'di codice sorgente qui)" in questi esempi può cambiare dopo ogni esecuzione, oppure può essere lo stesso.

L'output deve contenere una stringa world hello valida esattamente una volta. Può contenere qualsiasi numero di stringhe hello world non valide. Il codice sorgente può contenere qualsiasi quantità di commenti e la stringa ciao mondo può essere incorporata nei commenti. Il primo programma può avere zero o una stringa di ciao valida, ma non di più.

La seguente punteggiatura è valida:

hello, world
hello world
helloworld

Qualsiasi capitalizzazione è accettabile. Ad esempio, queste sono stringhe hello world valide:

Hello, world
hellO WORld
HELLoworlD

Queste stringhe non sono valide:

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

Il programma non riesce non appena viene soddisfatta una delle seguenti condizioni:

• Emette una stringa di Hello World che è stata emessa durante alcune precedenti esecuzioni,
• l'output non è più un codice sorgente valido nella stessa lingua, oppure
• l'output non contiene esattamente una stringa hello world valida.

Il tuo programma non è valido per questo concorso a meno che almeno due prime esecuzioni non abbiano esito positivo. Ciò significa che il terzo output può essere non valido. L'output del tuo programma potrebbe non essere casuale. La prima esecuzione dovrebbe sempre creare lo stesso secondo output, la seconda esecuzione dovrebbe sempre creare lo stesso terzo output, ecc.

Il punteggio viene calcolato come quantità di byte nel codice sorgente del programma iniziale. Il punteggio più basso vince.

Si applicano i seguenti bonus (fino al -60%):

• -5% * (N - 2), dove N è l'indice dell'esecuzione dopo il quale il programma produce un output non valido. Questo bonus arriva al -50%. Se il tuo programma ha successo almeno 12 volte, otterrai il bonus massimo.
• -10%, se i tuoi output (incluso il primo codice sorgente) includono tutte e tre le alternative di punteggiatura valide.

L'invio deve includere il primo codice sorgente e deve contenere anche gli output delle esecuzioni riuscite. Se il programma ha esito positivo più di 12 volte, aggiungi l'output per 12 esecuzioni.

Esempio

La riga successiva è il primo codice sorgente. Quando lo eseguiamo, è la prima esecuzione.

hello world(some source code here)

La riga successiva è l'output dal primo codice codice sorgente. È il primo output.

hello, world(some source code here) 

La riga successiva è l'output della seconda esecuzione. È la seconda uscita.

helloworld(some source code here)

Quando abbiamo eseguito il primo output, questo programma è diventato idoneo per il bonus del -10%. Ciò significa che abbiamo due uscite e un codice originale, che hanno tutti punteggiatura diversa. Inoltre, poiché il secondo output era valido, questo programma è idoneo per questo concorso.

La riga successiva è l'output della terza esecuzione. È la terza uscita.

Helloworld(some source code here)

La riga successiva è l'output della quarta esecuzione. È la quarta uscita.

hellworld(some source code here)

Questo output non è valido. L'indice dell'ultima esecuzione valida è stato 4. Questo programma è idoneo per il bonus -5% * (4 - 2) e il bonus del -10% dalla punteggiatura. Questo fa un totale di -20%. La lunghezza del primo codice sorgente ("ciao mondo (qualche codice sorgente qui)") era di 34 byte, quindi il punteggio finale è 27.2.

Pyth, 17 byte

Una soluzione Pyth diversa:

"r\"helloworld\"1

Produzione:

r"helloworld"1

Seconda uscita:

HELLOWORLD

Mathematica, 214-50% = 107 byte

(a = Characters[StringJoin["helloworl", "d"]]; b = Apply[StringJoin, Tuples[Transpose[{a, ToUpperCase[a]}]], {1}]; StringReplacePart[ToString[#0, InputForm], b[[FirstPosition[b, "helloworld"] + 1]], {180, 189}]) & 

Ho deciso di ottimizzare per il conteggio delle stringhe qui. Questo funziona per 1024 programmi senza interruzioni, passando attraverso ogni combinazione di lettere maiuscole e minuscole. L'esecuzione può essere vista qui .

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

Eh! Battilo! Probabilmente lo farai. : c

Prima uscita:

'0DV \ {25 ^ -V \}} {1+ rd3 * Z; helloworld
'Inizia a catturare come una stringa
 0DV Spingere 0 nello stack e impostarlo come variabile finale.
    \ Ripeti più volte l'elemento successivo. (1, 2, 3 ... sulle uscite.)
     {Ruota la pila verso sinistra.
      25 ^ Spingere 32 nello stack.
         - Sottrai l'elemento superiore da esso - questo renderà maiuscole le lettere minuscole.
          V \ Esegui i tempi variabili finali dell'elemento successivo.
            } Ruota la pila verso destra.
             } E di nuovo...
              1+ Aggiungi uno. Questo rende lo 0 in questo codice un 1, quindi 2 ...
                r Invertire la pila.
                 d3 * Ottieni il personaggio '
                    Z Stampa tutti gli oggetti nella pila.
                     ; Termina l'esecuzione.
                      helloworld String da manipolare.

Seconda uscita:

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

Terza uscita:

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

Quarta uscita:

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

Quinto risultato:

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

Sesta uscita:

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

Settima uscita:

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

Ottava uscita:

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

Nona uscita:

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

Decima uscita:

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

Undicesima uscita:

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

Questo è l'ultimo output, poiché provocherà un errore.

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

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

questo avvia la seguente catena:

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

dove l'ultimo non contiene più un "Hello, World" valido.

Provalo qui.

Spiegazione

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

Nota che il programma iniziale non contiene un "Hello, World" valido, ma che ci consente di andare avanti di un'iterazione.

CJam 69 % = 30

Sono ancora alle prime armi, per favore dimmi come giocare a golf in CJam.

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

È noioso stampare ogni iterazione, poiché sarà valido per 99 iterazioni.

Funziona enumerando la maiuscola della parola ciao. Il tedio è quello di dividere le stringhe in parti poiché sia ​​"ciao mondo" che il contatore devono essere aggiornati.

Spiegazione

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

NOTA: non leggo la risposta di Mathematica, mi spiace, penso che fosse originale

Con il riordino e le diverse maiuscole, perdo 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

Questa volta enumera anche la punteggiatura.

{`:Z6<"HELLOWORLD"0:AYbW%.{{eu}{el}?}`", ":B-_6<BA3%>@6>A)ZW%52<W%"_~"}_~
{`:Z                                                              "_~"}_~ e# Standard Quine Framework
    6<                                                                    e# take the first 6 character
      "HELLOWORLD"                                                        e# Hello, world
                  0:A                                                     e# Accumulator
                     YbW%.{{eu}{el}?}`                                    e# See above
                                      ", ":B                              e# Punctuation
                                            -                             e# Delete punctuation
                                             _6<                          e# "hello
                                                BA3%>                     e# punctuation
                                                     @6>                  e# world"
                                                        A)                e# incremented accumulator
                                                          ZW%52<W%        e# Remaining part

GolfScript, 35 byte - 50% = 17,5

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

Ho deciso di esagerare con il numero di esecuzioni prima di ripetere. Questo programma, con il suo output reinserito nell'interprete GolfScript, produrrà 890 stringhe Hello World distinte prima della prima ripetizione. Come breve esempio, ecco le prime 15 iterazioni:

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

Il modo in cui funziona è iterando attraverso la stringa, capovolgendo le maiuscole di ciascuna lettera (XORing il suo codice ASCII con 32) se la lettera precedente (dopo possibilmente capovolto il suo caso) è minuscola. La prima lettera verrà capovolta se il numero nel programma iniziale è 32 anziché 0 - e l'output del numero per la successiva iterazione sarà 32 ogni volta che l'ultima lettera della stringa è minuscola, causando così eventuali modifiche alla fine di la stringa da propagare all'inizio alla successiva iterazione.

(Questo particolare processo di feedback è stato ottenuto in un modo totalmente ad hoc . Inizialmente volevo solo eseguire un semplice contatore binario usando maiuscole e minuscole come bit, ma ci sono voluti troppi byte per implementare, quindi ho iniziato a modificarlo per trovare qualcosa di più corto ciò porterebbe comunque a una durata del ciclo abbastanza elevata. Dato che il massimo teorico, usando solo il capovolgimento, è 2 ¹⁰ = 1024, ottenere un ciclo di 890 iterazioni è piuttosto piacevole.)

Purtroppo, il bonus per le iterazioni aggiuntive è limitato al −50%; senza il limite, questo programma avrebbe un enorme bonus del -4440%. ;-)

Pyth, 18 byte

"-\"hello world\"d

Che ritorna:

-"hello world"d

Che a sua volta stampa:

helloworld

Ho avuto una soluzione che ha fatto tutte e tre le ortografie, ma è più lunga anche con il bonus.

Simplex , 21 byte.

Questo è il motivo per cui Simplex è nato . Posso decisamente andare oltre con questo.

(Continuo a premere Ctrl + Invio, scusa! Lo biasimo sulla tastiera del tablet)

Tentativo 3, v.0.8 +, 31-5% = 29,45 byte (methink UTF-8)

Quell'emote nel mezzo mi esprime. Una specie di. Perché l'ho fatto di nuovo? ._.

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

2a uscita:

"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

3a uscita:

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

Uscita finale:

HelloworlD

Tentativo 2, v.0.8 +, 21 byte (UTF-8, credo)

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

Produzione:

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

Uscita finale:

helloworld

Tentativo 1, v.0.7 + 28 26 byte

Non sono sicuro se questo si qualifica per il primo bonus ...

"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

Prima uscita:

"HELLOWORLD"g

Il programma esterno viene valutato alla fine dell'esecuzione (lo fa per y; ecco come appare il programma esterno:

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

Uscita finale:

HELLOWORLD

Rubino, 81-50% = 40,5

Codice originale:

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

Risultati successivi:

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

Penso che questo conti come l'intero 50%? Potrebbe essere spento da uno. Inoltre, c'è probabilmente una soluzione non bonus con il punteggio migliore in Ruby.

Il codice originale non contiene "helloworld", ma crea un quine che sostituisce la prima lettera maiuscola nel suo codice sorgente con la versione minuscola. Quindi ogni sequenza successiva del quine produce una lettera maiuscola in meno.

Il trucco qui è usare una stringa di formato per interpolare sia la stringa stessa, per quining, sia la stringa Hello World, in modo che appaia solo una volta.

PHP, 297 - 40% = 178,2 byte

Non molto competitivo ma è stato divertente scrivere

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

È una variante di questo quine:

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

ma aggiunge anche "helloworld" all'output e lo sostituisce 0con 0+1(nella prossima iterazione 1con 1+1e così via). L'utilizzo di substrqualsiasi output "helloworld" esistente viene rimosso prima che venga aggiunto il nuovo "helloworld".

Per ottenere risultati diversi, una lettera di "mondo" viene maiuscola (determinata dal numero crescente). Questo è il codice pertinente:

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

Una sfida era quella di non utilizzare alcun numero tranne qui e per la sostituzione dei numeri

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

Lì già vedi che +1è realizzato come +(int)true.

Per gli argomenti della sottostringa avevo bisogno di 0, 146:

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

La stringa non vuota "i" viene forzata truee negata. falseè un argomento intero valido ed è trattato come 0. ord(I)è il valore ASCII di "I": 73

Output (prima iterazione):

<?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 (seconda iterazione):

<?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 (decima iterazione):

Questo è l'ultimo output valido ma non è più un programma valido

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

Scorri fino a destra per trovare le stringhe "Hello world"!

Pip, 48-50% = 24

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

che si evolve come segue:

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"

con l'ultimo output non valido perché HELLOWORLDnon è stato modificato. (Correggimi se non ho fatto bene il bonus.)

Grazie a questa domanda, ho appena scoperto una nuova tecnica di quine! Il quine di base è 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

Il nostro codice aggiuntivo modifica la stringa y, prima di riproporla, come segue:

• Sostituisci l'attuale mondo con uno in cui i 0caratteri più a sinistra sono maiuscoli;
• Sostituisci tutte le occorrenze di 0con o+0(dove oè una variabile incorporata uguale a 1).

La prossima volta il numero nel codice è 1invece di 0e così via.

Javascript, 52 byte

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

Test

=>

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

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

<= 'helloworld'

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

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

Provalo online!

Prima uscita:

/ //hello world

Seconda uscita:

helloworld

BBC BASIC, 56 byte

Ho avuto una crisi prima di rendermi conto di quanto sono in ritardo al gioco. Per quello che vale, ecco la mia versione e il mio primo tentativo di codice StackExchange golf.

Qui, V. fa eco ai caratteri forniti dai codici ASCII nel seguente elenco separato da virgole e P. è una scorciatoia per la stampa. Uso il carattere backspace per sovrascrivere la stringa "helloworld" esistente.

Codice di input:

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

Prima uscita:

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

Seconda uscita:

helloworLD

Può essere testato online all'indirizzo https://bbc.godbolt.org/