Créez un programme, qui génère une chaîne hello world ("Hello world", "Hello, World" etc.) et le code source. La sortie est écrite sur stdout ou équivalent. La chaîne Hello world est intégrée au code source.

Par exemple, la sortie de pourrait être

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

Lorsque la sortie est à nouveau compilée ou interprétée, elle doit créer une sortie similaire, mais la chaîne hello world doit avoir une ponctuation ou une capitalisation différente. Par exemple, l'exemple précédent pourrait créer la sortie suivante

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

Chaque "(un code source ici)" dans ces exemples peut changer après chaque exécution, ou il peut être le même.

Votre sortie doit contenir une chaîne hello world valide exactement une fois. Il peut contenir n'importe quelle quantité de chaînes hello world invalides. Le code source peut contenir n'importe quelle quantité de commentaires et la chaîne hello world peut être incorporée dans les commentaires. Le premier programme peut avoir zéro ou une chaîne hello world valide, mais pas plus.

La ponctuation suivante est valide:

hello, world
hello world
helloworld

Toute capitalisation est acceptable. Par exemple, ce sont des chaînes Hello World valides:

Hello, world
hellO WORld
HELLoworlD

Ces chaînes ne sont pas valides:

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

Votre programme échoue dès que l'une des conditions suivantes est remplie:

• Il génère une chaîne hello world qui a été générée lors d'une exécution antérieure,
• la sortie n'est plus du code source valide dans la même langue, ou
• la sortie ne contient pas exactement une chaîne hello world valide.

Votre programme n'est valable pour ce concours que si au moins deux premières exécutions ont réussi. Cela signifie que la troisième sortie peut être invalide. La sortie de votre programme peut ne pas être aléatoire. La première exécution doit toujours créer la même deuxième sortie, la deuxième exécution doit toujours créer la même troisième sortie, etc.

Le score est calculé comme la quantité d'octets dans le code source du programme initial. Le score le plus bas l'emporte.

Les bonus suivants s'appliquent (jusqu'à -60%):

• -5% * (N - 2), où N est l'index de l'exécution après quoi votre programme produit une sortie non valide. Ce bonus plafonne à -50%. Si votre programme réussit 12 fois ou plus, vous obtenez le bonus maximum.
• -10%, si vos sorties (y compris le premier code source) incluent les trois alternatives de ponctuation valides.

Votre soumission doit inclure le premier code source et doit également contenir les résultats des exécutions réussies. Si votre programme réussit plus de 12 fois, ajoutez une sortie pour 12 exécutions.

Exemple

La ligne suivante est le premier code source. Lorsque nous l'exécutons, c'est la première exécution.

hello world(some source code here)

La ligne suivante est la sortie du premier code source. C'est la première sortie.

hello, world(some source code here) 

La ligne suivante est la sortie de la deuxième exécution. C'est la deuxième sortie.

helloworld(some source code here)

Lorsque nous avons exécuté la première sortie, ce programme est devenu éligible au bonus de -10%. Cela signifie que nous avons deux sorties et un code original, qui ont tous une ponctuation différente. De plus, la deuxième sortie étant valide, ce programme est éligible à ce concours.

La ligne suivante est la sortie de la troisième exécution. C'est la troisième sortie.

Helloworld(some source code here)

La ligne suivante est la sortie de la quatrième exécution. Il s'agit de la quatrième sortie.

hellworld(some source code here)

Cette sortie n'était pas valide. L'indice de la dernière exécution valide était de 4. Ce programme est éligible pour -5% * (4 - 2) bonus et -10% bonus à partir de la ponctuation. Cela fait un total de -20%. La longueur du premier code source ("bonjour le monde (du code source ici)") était de 34 octets, donc le score final est de 27,2.

Pyth, 17 octets

Une solution Pyth différente:

"r\"helloworld\"1

Production:

r"helloworld"1

Deuxième sortie:

HELLOWORLD

Mathematica, 214 - 50% = 107 octets

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

J'ai décidé d'optimiser le nombre de chaînes ici. Cela fonctionne pour 1024 programmes sans s'arrêter, en passant par toutes les combinaisons de lettres majuscules et minuscules. L'exécution peut être vue ici .

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

Il h! Bas ça! Vous le ferez probablement. : c

Première sortie:

'0DV \ {25 ^ -V \}} 1+ {rd3 * Z; helloworld
'Commencer la capture sous forme de chaîne
 0DV Poussez 0 sur la pile et définissez-la comme variable finale.
    \ Répétez l'élément suivant autant de fois. (1, 2, 3 ... sur les sorties.)
     {Faites pivoter la pile vers la gauche.
      25 ^ Poussez 32 dans la pile.
         - Soustrayez l'élément supérieur par celui-ci - cela rendra les minuscules en majuscules.
          V \ Faites le temps variable final de l'élément suivant.
            } Faites pivoter la pile vers la droite.
             } Et encore...
              1+ Ajoutez-en un. Cela rend le 0 dans ce code un 1, puis 2 ...
                r Inversez la pile.
                 d3 * Obtenez le personnage '
                    Z Sortez tous les éléments de la pile.
                     ; Fin de l'exécution.
                      helloworld String à manipuler.

Deuxième sortie:

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

Troisième sortie:

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

Quatrième sortie:

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

Cinquième sortie:

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

Sixième sortie:

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

Septième sortie:

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

Huitième sortie:

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

Neuvième sortie:

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

Dixième sortie:

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

Onzième sortie:

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

Il s'agit de la dernière sortie, car elle entraînera une erreur.

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

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

cela démarre la chaîne suivante:

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

où le dernier ne contient plus de "Hello, World" valide.

Testez-le ici.

Explication

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

Notez que le programme initial ne contient pas de "Hello, World" valide, mais cela nous permet d'aller une itération plus loin.

CJam 69 60 - 50% = 30

Je suis encore débutant, dites-moi comment jouer au golf à CJam.

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

Il est fastidieux d'imprimer chaque itération, car elle sera valable pour 99 itérations.

Il fonctionne en énumérant la capitalisation du mot bonjour. L'ennui est de diviser les cordes en parties, car "bonjour le monde" et le compteur doivent être mis à jour.

Explication

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

REMARQUE: je ne lis pas la réponse Mathematica, désolé, je pense qu'elle était originale

Avec la réorganisation et la capitalisation différente, je perds 9 octets.

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

Cette fois aussi, énumérez la ponctuation.

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

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

J'ai décidé d'aller trop loin sur le nombre d'exécutions avant de recommencer. Ce programme, avec sa sortie réinjectée dans l'interpréteur GolfScript, produira 890 chaînes Hello World distinctes avant la première répétition. En bref, voici les 15 premières itérations:

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

La façon dont cela fonctionne est en itérant dans la chaîne, en inversant la capitalisation de chaque lettre (en XORant son code ASCII avec 32) si la lettre précédente (après avoir éventuellement retourné sa casse) est en minuscules. La première lettre aura sa casse inversée si le nombre au début du programme est 32 plutôt que 0 - et le numéro de sortie pour la prochaine itération sera 32 chaque fois que la dernière lettre de la chaîne est en minuscule, provoquant ainsi des changements à la fin de la chaîne à propager au début à la prochaine itération.

(Ce processus de rétroaction particulier a été obtenu de manière totalement ad hoc . À l'origine, je voulais simplement exécuter un simple compteur binaire en utilisant les majuscules et les minuscules comme bits, mais cela prenait trop d'octets à mettre en œuvre, alors j'ai commencé à le peaufiner pour trouver quelque chose de plus court cela donnerait quand même une durée de cycle assez élevée. Puisque le maximum théorique, en utilisant uniquement le retournement de casse, est de 2 ¹⁰ = 1024, obtenir un cycle de 890 itérations est plutôt agréable.)

Hélas, le bonus pour les itérations supplémentaires est plafonné à −50%; sans le plafond, ce programme aurait un énorme bonus de -4440%. ;-)

Pyth, 18 octets

"-\"hello world\"d

Qui retourne:

-"hello world"d

Qui à son tour imprime:

helloworld

J'avais une solution qui faisait les trois orthographes, mais elle est plus longue même avec le bonus.

Simplex , 21 octets.

C'est pour cela que Simplex est né . Je peux certainement aller plus loin avec cela.

(Je continue d'appuyer sur Ctrl + Entrée, désolé! Je le blâme sur le clavier de la tablette)

Tentative 3, v.0.8 +, 31-5% = 29,45 octets (méthinks UTF-8)

Cette emote au milieu m'exprime. Sorte de. Pourquoi ai-je recommencé? ._.

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

2e sortie:

"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

3e sortie:

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

Sortie finale:

HelloworlD

Tentative 2, v.0.8 +, 21 octets (UTF-8, je pense)

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

Production:

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

Sortie finale:

helloworld

Tentative 1, v.0.7 + 28 26 octets

Je ne sais pas si cela se qualifie pour le premier 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

Première sortie:

"HELLOWORLD"g

Le programme externe est évalué à la fin de l'exécution (il le fait pour y; voici à quoi ressemble le programme externe:

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

Sortie finale:

HELLOWORLD

Rubis, 81 - 50% = 40,5

Code d'origine:

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

Sorties successives:

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

Je pense que cela compte pour 50%? Pourrait être hors tension par un. De plus, il existe probablement une solution sans bonus plus performante dans Ruby.

Le code d'origine ne contient pas "helloworld", mais il construit un quine qui remplace la première lettre majuscule de son code source par la version minuscule. Ainsi, chaque exécution successive du quine génère une lettre en majuscule de moins.

L'astuce consiste à utiliser une chaîne de format pour interpoler à la fois la chaîne elle-même, pour le quining, et la chaîne Hello World, afin qu'elle n'apparaisse qu'une seule fois.

PHP, 297 - 40% = 178,2 octets

Pas vraiment compétitif mais c'était amusant d'écrire

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

C'est une variation de cette quine:

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

mais il ajoute également "helloworld" à la sortie et le remplace 0par 0+1(dans la prochaine itération 1avec 1+1et ainsi de suite). L'utilisation de substrtoute sortie "helloworld" existante est supprimée avant l'ajout du nouveau "helloworld".

Pour obtenir une sortie différente, une lettre de "helloworld" est mise en majuscule (déterminée par le nombre incrémentiel). Voici le code pertinent:

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

Un défi était de ne pas utiliser de numéros sauf ici et pour le remplacement du numéro

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

Là, vous voyez déjà que cela +1se réalise +(int)true.

Pour les arguments de sous-chaîne dont j'avais besoin 0, 146:

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

La chaîne non vide "i" est contrainte trueet annulée. falseest un argument entier valide et est traité comme 0. ord(I)est la valeur ASCII de "I": 73

Sortie (1ère itération):

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

Sortie (2ème itération):

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

Sortie (10e itération):

Ceci est la dernière sortie valide mais ce n'est plus un programme valide

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

Faites défiler vers la droite pour trouver les chaînes "Hello world"!

Pip, 48 - 50% = 24

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

qui évolue comme suit:

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"

avec la dernière sortie invalide car la HELLOWORLDn'a pas changé. (Corrigez-moi si je n'ai pas fait le bon bonus.)

Grâce à cette question, je viens de découvrir une nouvelle technique de quine! Le quine de base est 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

Notre code supplémentaire modifie la chaîne y, avant de la reproduire, comme suit:

• Remplacez le helloworld actuel par celui dans lequel les 0caractères les plus à gauche sont en majuscules;
• Remplacez toutes les occurrences de 0par o+0(où oest une variable intégrée égale à 1).

La prochaine fois que le nombre dans le code est 1au lieu de 0, et ainsi de suite.

Javascript, 52 octets

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

Tester

=>

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

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

<= 'helloworld'

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

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

Essayez-le en ligne!

Première sortie:

/ //hello world

Deuxième sortie:

helloworld

BBC BASIC, 56 octets

J'ai eu une fissure avant de réaliser à quel point je suis en retard. Pour ce que ça vaut, voici ma version et ma première tentative de golf de code StackExchange.

Ici, V. fait écho aux caractères donnés par les codes ASCII dans la liste séparée par des virgules suivante et P. est un raccourci pour l'impression. J'utilise le caractère de retour arrière pour remplacer la chaîne "helloworld" existante.

Code d'entrée:

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

Première sortie:

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

Deuxième sortie:

helloworLD

Il peut être testé en ligne sur https://bbc.godbolt.org/