Cree un programa que genere una cadena hello world ("Hello world", "Hello, World", etc.) y el código fuente. La salida se escribe en stdout o equivalente. La cadena Hello World está incrustada en el código fuente.

Por ejemplo, la salida para podría ser

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

Cuando la salida se compila o se vuelve a interpretar, debe crear una salida similar, pero la cadena hello world debe tener una puntuación o mayúscula diferente. Por ejemplo, el ejemplo anterior podría crear el siguiente resultado

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

Cada "(algún código fuente aquí)" en estos ejemplos puede cambiar después de cada ejecución, o puede ser el mismo.

Su salida debe contener una cadena válida de hello world exactamente una vez. Puede contener cualquier cantidad de cadenas inválidas de hello world. El código fuente puede contener cualquier cantidad de comentarios, y la cadena hello world puede estar incrustada en los comentarios. El primer programa puede tener cero o una cadena válida de hello world, pero no más.

La siguiente puntuación es válida:

hello, world
hello world
helloworld

Cualquier capitalización es aceptable. Por ejemplo, estas son cadenas válidas de hello world:

Hello, world
hellO WORld
HELLoworlD

Estas cadenas no son válidas:

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

Su programa falla tan pronto como se cumpla una de las siguientes condiciones:

• Produce una cadena hello world que se ha generado durante alguna ejecución anterior,
• la salida ya no es código fuente válido en el mismo idioma, o
• la salida no contiene exactamente una cadena válida de hello world.

Su programa no es válido para este concurso a menos que al menos dos primeras ejecuciones sean exitosas. Esto significa que la tercera salida puede ser inválida. La salida de su programa puede no ser aleatoria. La primera ejecución siempre debe crear la misma segunda salida, la segunda ejecución siempre debe crear la misma tercera salida, etc.

La puntuación se calcula como la cantidad de bytes en el código fuente del programa inicial. La puntuación más baja gana.

Se aplican los siguientes bonos (hasta -60%):

• -5% * (N - 2), donde N es el índice de la ejecución después de la cual su programa produce resultados no válidos. Este bono se limita a -50%. Si su programa tiene éxito 12 veces o más, obtendrá el bono máximo.
• -10%, si sus salidas (incluido el primer código fuente) incluyen las tres alternativas de puntuación válidas.

Su envío debe incluir el primer código fuente, y también debe contener los resultados de las ejecuciones exitosas. Si su programa tiene éxito más de 12 veces, agregue la salida para 12 ejecuciones.

Ejemplo

La siguiente línea es el primer código fuente. Cuando lo ejecutamos, es la primera ejecución.

hello world(some source code here)

La siguiente línea es la salida del primer código de código fuente. Es la primera salida.

hello, world(some source code here) 

La siguiente línea es la salida de la segunda ejecución. Es la segunda salida.

helloworld(some source code here)

Cuando ejecutamos la primera salida, este programa se convirtió en elegible para el bono de -10%. Eso significa que tenemos dos salidas y un código original, que tienen diferentes puntuaciones. Además, debido a que la segunda salida fue válida, este programa es elegible para este concurso.

La siguiente línea es la salida de la tercera ejecución. Es la tercera salida.

Helloworld(some source code here)

La siguiente línea es la salida de la cuarta ejecución. Es la cuarta salida.

hellworld(some source code here)

Esta salida fue inválida. El índice de la última ejecución válida fue 4. Este programa es elegible para un bono de -5% * (4 - 2) y un bono de -10% de la puntuación. Esto hace un total de -20%. La longitud del primer código fuente ("hola mundo (aquí está el código fuente)") fue de 34 bytes, por lo que el puntaje final es 27.2.

Pyth, 17 bytes

Una solución diferente de Pyth:

"r\"helloworld\"1

Salida:

r"helloworld"1

Segunda salida:

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

Decidí optimizar el recuento de cadenas aquí. Esto se ejecuta para 1024 programas sin parar, pasando por cada combinación de letras mayúsculas y minúsculas. La ejecución se puede ver aquí .

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

Je! ¡Supera eso! Probablemente lo hagas. :C

Primera salida:

'0DV \ {25 ^ -V \}} 1+ {rd3 * Z; helloworld
'Comience a capturar como una cadena
 0DV Empuje 0 a la pila y configúrelo como la variable final.
    \ Repita el siguiente elemento varias veces. (1, 2, 3 ... en las salidas).
     {Gire la pila hacia la izquierda.
      25 ^ Empuje 32 a la pila.
         - Reste el elemento superior por él, esto hará minúsculas mayúsculas.
          V \ Hacer el siguiente elemento veces variables finales.
            } Gire la pila hacia la derecha.
             } Y otra vez...
              1+ Añadir uno. Esto hace que el 0 en este código sea 1, luego 2 ...
                r Invierta la pila.
                 d3 * Obtener el personaje '
                    Z Muestra todos los artículos en la pila.
                     ; Fin de la ejecución.
                      cadena de helloworld para manipular.

Segunda salida:

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

Tercera salida:

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

Cuarta salida:

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

Quinta salida:

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

Sexta salida:

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

Séptimo resultado:

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

Octava salida:

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

Novena salida:

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

Décima salida:

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

Undécimo resultado:

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

Esta es la última salida, ya que causará un error.

CJam, N = 3 4, 28 bytes - 10% - 10% = 22.4

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

Esto inicia la siguiente cadena:

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

donde el último ya no contiene un "Hola Mundo" válido.

Pruébalo aquí.

Explicación

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

Tenga en cuenta que el programa inicial no contiene un "Hello, World" válido, pero eso nos permite ir una iteración más allá.

CJam 69 60 - 50% = 30

Todavía soy principiante, por favor dime cómo jugar golf en CJam.

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

Es tedioso imprimir cada iteración, ya que será válido por 99 iteraciones.

Funciona enumerando la capitalización de hola palabra. El tedio es dividir las cadenas en partes, ya que tanto "hello world" como el contador deben actualizarse.

Explicación

{`_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: No leo la respuesta de Mathematica, lo siento, creo que fue original

Con el reordenamiento y las diferentes mayúsculas, pierdo 9 bytes.

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

Esta vez también enumera la puntuación.

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

Decidí exagerar el número de ejecuciones antes de repetir. Este programa, con su salida realimentada en el intérprete de GolfScript, producirá 890 cadenas Hello World distintas antes de la primera repetición. Como breve muestra, aquí están las primeras 15 iteraciones:

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 forma en que funciona es iterando a través de la cadena, volteando las mayúsculas de cada letra (haciendo XOR con su código ASCII con 32) si la letra anterior (después de posiblemente cambiar su mayúscula y minúscula) está en minúscula. La primera letra cambiará de mayúsculas y minúsculas si el número al comienzo del programa es 32 en lugar de 0, y el número de salida para la siguiente iteración será 32 siempre que la última letra de la cadena esté en minúscula, causando cambios al final de la cadena para propagarse al principio en la próxima iteración.

(Este proceso de retroalimentación en particular se obtuvo de una manera totalmente ad hoc . Originalmente quería ejecutar un contador binario simple usando mayúsculas y minúsculas como bits, pero eso tomó demasiados bytes para implementar, así que comencé a ajustarlo para encontrar algo más corto eso todavía produciría una duración de ciclo bastante alta. Dado que el máximo teórico, usando solo mayúsculas y minúsculas, es 2 ¹⁰ = 1024, obtener un ciclo de 890 iteraciones es bastante bueno).

Por desgracia, la bonificación por iteraciones adicionales tiene un límite de −50%; sin el límite, este programa tendría una enorme bonificación de −4440%. ;-)

Pyth, 18 bytes

"-\"hello world\"d

Que devuelve:

-"hello world"d

Que a su vez imprime:

helloworld

Tenía una solución que hacía las tres ortografías, pero es más larga incluso con la bonificación.

Simplex , 21 bytes.

Esto es lo que era Simplex nació . Definitivamente puedo ir más lejos con esto.

(Sigo presionando Ctrl + Enter, lo siento, lo culpo en el teclado de la tableta)

Intento 3, v.0.8 +, 31-5% = 29.45 bytes (me parece que UTF-8)

Ese gesto en el medio se expresa. Algo así como. ¿Por qué hice esto otra vez? ._.

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

2da salida:

"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

3ra salida:

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

Salida final:

HelloworlD

Intento 2, v.0.8 +, 21 bytes (UTF-8, creo)

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

Salida:

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

Salida final:

helloworld

Intento 1, v.0.7 + 28 26 bytes

No estoy seguro de si esto califica para el primer bono ...

"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

Primera salida:

"HELLOWORLD"g

El programa externo se evalúa al final de la ejecución (lo hace por y; así es como se ve el programa externo:

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

Salida final:

HELLOWORLD

Rubí, 81 - 50% = 40.5

Código original:

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

Productos sucesivos:

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

Creo que esto cuenta como el 50% completo? Podría estar fuera por uno. Además, probablemente haya una solución sin bonificación con mejor puntuación en Ruby.

El código original no contiene "helloworld", pero construye un quine que reemplaza la primera letra mayúscula en su código fuente con la versión en minúscula. Por lo tanto, cada ejecución sucesiva del quine genera una letra minúscula menos.

El truco aquí es usar una cadena de formato para interpolar tanto la cadena en sí, para el quining, como la cadena Hello World, para que solo aparezca una vez.

PHP, 297 - 40% = 178.2 bytes

No es realmente competitivo pero fue divertido escribir

<?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 una variación de esta quine:

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

pero también agrega "helloworld" a la salida y reemplaza 0con 0+1(en la próxima iteración 1con 1+1y así sucesivamente). Utilizandosubstr cualquier salida "helloworld" existente se elimina antes de que se agregue el nuevo "helloworld".

Para obtener una salida diferente, una letra de "helloworld" se escribe con mayúscula (determinada por el número creciente). Este es el código relevante:

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

Un desafío era no usar ningún número excepto aquí y para el reemplazo del número

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

Ahí ya ves que +1se realiza como +(int)true.

Para los argumentos de la subcadena que necesitaba 0, 146:

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

La cadena no vacía "i" se coacciona truey se niega. falsees un argumento entero válido y se trata como 0. ord(I)es el valor ASCII de "I": 73

Salida (primera iteración):

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

Salida (segunda iteración):

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

Salida (10ª iteración):

Esta es la última salida válida pero ya no es un programa válido

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

¡Desplácese hacia la derecha para encontrar las cadenas "Hola mundo"!

Pip, 48 - 50% = 24

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

que evoluciona de la siguiente manera:

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 la última salida no válida porque HELLOWORLDno ha cambiado. (Corrígeme si no he hecho bien la bonificación).

Gracias a esta pregunta, ¡acabo de descubrir una nueva técnica de quine! La base quine es 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

Nuestro código adicional modifica la cadena en y , antes de reproducirla, de la siguiente manera:

• Reemplace el mundo hellow actual con uno en el que el extremo izquierdo 0 caracteres estén en mayúsculas;
• Reemplace todas las apariciones de 0con o+0(dondeo es una variable integrada que equivale a 1).

La próxima vez alrededor del número en el código es en 1lugar de 0, y así sucesivamente.

Javascript, 52 bytes

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

Prueba

=>

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

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

<= 'helloworld'

///, 23 bytes - 10% = 20.7?

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

Pruébalo en línea!

Primera salida:

/ //hello world

Segunda salida:

helloworld

BBC BASIC, 56 bytes

Tuve una grieta en esto antes de darme cuenta de lo tarde que llegaba al juego. Para lo que vale, aquí está mi versión y mi primer intento en StackExchange code golf.

Aquí, V. repite los caracteres dados por los códigos ASCII en la siguiente lista separada por comas y P. es la abreviatura para imprimir. Hago uso del carácter de retroceso para sobrescribir la cadena existente 'helloworld'.

Codigo de entrada:

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

Primera salida:

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

Segunda salida:

helloworLD

Se puede probar en línea en https://bbc.godbolt.org/