Crie um programa que produza uma sequência de hello world ("Olá, mundo", "Olá, mundo" etc.) e o código-fonte. A saída é gravada em stdout ou equivalente. A cadeia Hello world está incorporada no código fonte.

Por exemplo, a saída para pode ser

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

Quando a saída é compilada ou interpretada novamente, ela deve criar uma saída semelhante, mas a cadeia hello world deve ter uma pontuação ou capitalização diferentes. Por exemplo, o exemplo anterior pode criar a seguinte saída

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

Cada "(algum código-fonte aqui)" nesses exemplos pode mudar após cada execução ou pode ser a mesma.

Sua saída deve conter uma sequência válida de hello world exatamente uma vez. Pode conter qualquer quantidade de seqüências inválidas de hello world. O código-fonte pode conter qualquer quantidade de comentários e a string hello world pode ser incorporada nos comentários. O primeiro programa pode ter zero ou uma sequência de hello world válida, mas não mais.

A pontuação a seguir é válida:

hello, world
hello world
helloworld

Qualquer capitalização é aceitável. Por exemplo, estas são cadeias de caracteres hello world válidas:

Hello, world
hellO WORld
HELLoworlD

Essas strings não são válidas:

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

Seu programa falha assim que uma das seguintes condições é atendida:

• Ele gera uma string hello world que foi produzida durante alguma execução anterior,
• a saída não é mais um código fonte válido no mesmo idioma ou
• a saída não contém exatamente uma sequência válida de hello world.

Seu programa não é válido para este concurso, a menos que pelo menos duas primeiras execuções tenham êxito. Isso significa que a terceira saída pode ser inválida. A saída do seu programa pode não ser aleatória. A primeira execução deve sempre criar a mesma segunda saída, a segunda execução deve sempre criar a mesma terceira saída, etc.

A pontuação é calculada como a quantidade de bytes no código-fonte do programa inicial. Menor pontuação ganha.

Os seguintes bônus se aplicam (até -60%):

• -5% * (N - 2), em que N é o índice da execução após o qual o seu programa produz uma saída inválida. Esse bônus é limitado em -50%. Se o seu programa for bem-sucedido 12 vezes ou mais, você recebe o bônus máximo.
• -10%, se suas saídas (incluindo o primeiro código-fonte) incluírem todas as três alternativas de pontuação válidas.

Seu envio deve incluir o primeiro código-fonte e também deve conter os resultados das execuções bem-sucedidas. Se o seu programa tiver êxito mais de 12 vezes, adicione a saída para 12 execuções.

Exemplo

A próxima linha é o primeiro código fonte. Quando o executamos, é a primeira execução.

hello world(some source code here)

A próxima linha é a saída do primeiro código-fonte. É a primeira saída.

hello, world(some source code here) 

A próxima linha é a saída da segunda execução. É a segunda saída.

helloworld(some source code here)

Quando executamos a primeira saída, esse programa se tornou elegível ao bônus de -10%. Isso significa que temos duas saídas e um código original, todos com pontuação diferente. Além disso, como a segunda saída foi válida, este programa é elegível para este concurso.

A próxima linha é a saída da terceira execução. É a terceira saída.

Helloworld(some source code here)

A próxima linha é a saída da quarta execução. É a quarta saída.

hellworld(some source code here)

Esta saída foi inválida. O índice da última execução válida foi 4. Este programa é elegível para bônus de -5% * (4-2) e bônus de -10% da pontuação. Isso totaliza -20%. O comprimento do primeiro código fonte ("olá mundo (algum código fonte aqui)" foi de 34 bytes; portanto, a pontuação final é 27,2.

Pitão, 17 bytes

Uma solução Pyth diferente:

"r\"helloworld\"1

Resultado:

r"helloworld"1

Segunda saída:

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

Decidi otimizar a contagem de cadeias aqui. Isso funciona para 1024 programas sem parar, passando por todas as combinações de letras maiúsculas e minúsculas. A execução pode ser vista aqui .

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

Heh! Bata isso! Você provavelmente vai. : c

Primeira saída:

'0DV \ {25 ^ -V \}} 1+ {rd3 * Z; helloworld
Comece a capturar como uma sequência
 0DV Pressione 0 na pilha e defina-a como a variável final.
    \ Repita o próximo item várias vezes. (1, 2, 3 ... nas saídas.)
     {Gire a pilha para a esquerda.
      25 ^ Pressione 32 para a pilha.
         - Subtraia o item superior por ele - isso fará maiúsculas em minúsculas.
          V \ Faça o próximo item final vezes variáveis.
            } Gire a pilha para a direita.
             } E de novo...
              1+ Adicione um. Isso faz com que 0 neste código seja 1, depois 2 ...
                r Inverta a pilha.
                 d3 * Pegue o personagem '
                    Z Gera todos os itens da pilha.
                     ; Finalize a execução.
                      helloworld String para manipular.

Segunda saída:

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

Terceira saída:

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

Quarta saída:

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

Quinta saída:

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

Sexta saída:

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

Sétima saída:

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

Oitava saída:

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

Nona saída:

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

Décima saída:

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

Décima primeira saída:

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

Esta é a última saída, pois causará um erro.

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

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

isso inicia a seguinte cadeia:

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

onde o último não contém mais um "Olá, mundo" válido.

Teste aqui.

Explicação

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

Observe que o programa inicial não contém um "Olá, Mundo" válido, mas isso nos permite avançar uma iteração.

CJam 69 60 - 50% = 30

Eu ainda sou iniciante, por favor me diga como jogar golfe no CJam.

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

É entediante imprimir cada iteração, pois será válido por 99 iterações.

Ele funciona enumerando a capitalização da palavra hello. O tédio é dividir as cordas em partes, já que o "olá mundo" e o contador precisam ser atualizados.

Explicação

{`_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: Não li a resposta do Mathematica, desculpe, acho que era original

Com a reordenação e com letras maiúsculas diferentes, perco 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

Desta vez, também enumere a pontuação.

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

Decidi exagerar no número de execuções antes de repetir. Este programa, com sua saída retornada ao intérprete GolfScript, produzirá 890 seqüências distintas do Hello World antes da primeira repetição. Como uma breve amostra, aqui estão as 15 primeiras iterações:

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

A maneira como funciona é iterando a string, invertendo a capitalização de cada letra (XORing seu código ASCII com 32) se a letra anterior (depois de possivelmente ter seu caso invertido) estiver em minúscula. A primeira letra terá sua caixa invertida se o número no programa inicial for 32 em vez de 0 - e o número de saída para a próxima iteração será 32 sempre que a última letra da string for minúscula, causando alterações no final de a sequência a propagar de volta ao início na próxima iteração.

(Esse processo de feedback em particular foi obtido de uma maneira totalmente ad hoc . Inicialmente, eu queria apenas executar um contador binário simples usando maiúsculas e minúsculas como bits, mas isso levou muitos bytes para implementar, então comecei a ajustá-lo para encontrar algo mais curto isso ainda produziria um comprimento de ciclo bastante alto. Como o máximo teórico, usando apenas inversão de maiúsculas e minúsculas, é 2 ¹⁰ = 1024, é muito bom obter um ciclo de 890 iterações.)

Infelizmente, o bônus para iterações adicionais é limitado em -50%; sem o limite, este programa teria um enorme bônus de -4440%. ;-)

Pitão, 18 bytes

"-\"hello world\"d

Que retorna:

-"hello world"d

Por sua vez, imprime:

helloworld

Eu tive uma solução que fez todas as três grafias, mas é mais longa, mesmo com o bônus.

Simplex , 21 bytes.

Foi para isso que nasceu a Simplex . Definitivamente, posso ir mais longe com isso.

(Continuo pressionando Ctrl + Enter, desculpe! Eu culpo o teclado do tablet)

Tentativa 3, v.0.8 +, 31 -5% = 29.45 bytes (métodos UTF-8)

Aquele emote no meio me expressa. Tipo de. Por que eu fiz isso de novo? ._.

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

2ª saída:

"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ª saída:

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

Saída final:

HelloworlD

Tentativa 2, v.0.8 +, 21 bytes (UTF-8, eu acho)

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

Resultado:

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

Saída final:

helloworld

Tentativa 1, v.0.7 + 28 26 bytes

Não tenho certeza se isso se qualifica para o primeiro bônus ...

"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

Primeira saída:

"HELLOWORLD"g

O programa externo é avaliado no final da execução (ele faz isso por y; é assim que o programa externo se parece:

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

Saída final:

HELLOWORLD

Rubi, 81 - 50% = 40,5

Código original:

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

Saídas sucessivas:

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

Eu acho que isso conta como os 50% completos? Pode estar fora de um. Além disso, provavelmente existe uma solução sem bônus com melhor pontuação no Ruby.

O código original não contém "helloworld", mas cria um quine que substitui a primeira letra maiúscula em seu código-fonte pela versão em minúscula. Assim, cada execução sucessiva do quine produz uma letra menos maiúscula.

O truque aqui é usar uma string de formato para interpolar a própria string, para quining, e a string Hello World, para que apareça apenas uma vez.

PHP, 297 - 40% = 178,2 bytes

Não é realmente competitivo, mas foi divertido escrever

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

É uma variação deste quine:

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

mas também adiciona "helloworld" à saída e substitui 0por 0+1(na próxima iteração 1por 1+1e assim por diante). O uso de substrqualquer saída "helloworld" existente é removido antes que o novo "helloworld" seja adicionado.

Para obter resultados diferentes, uma letra de "helloworld" é maiúscula (determinada pelo número crescente). Este é o código relevante:

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

Um desafio era não usar nenhum número, exceto aqui e para a substituição do número

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

Lá você já vê que +1é realizado como +(int)true.

Para os argumentos de substring, eu precisava 0, 146:

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

A cadeia não vazia "i" é coagida truee negada. falseé um argumento inteiro válido e é tratado como 0. ord(I)é o valor ASCII de "I": 73

Saída (1ª iteração):

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

Saída (2ª iteração):

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

Saída (10ª iteração):

Esta é a última saída válida, mas não é mais um 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

Role para a direita para encontrar as seqüências "Hello world"!

Pip, 48 - 50% = 24

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

que evolui da seguinte maneira:

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"

com a última saída inválida porque HELLOWORLDnão foi alterada. (Corrija-me se eu não tiver feito o bônus corretamente.)

Graças a esta pergunta, acabei de descobrir uma nova técnica de quine! A base quine é 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

Nosso código extra modifica a string yantes de reproduzi-la da seguinte maneira:

• Substitua o mundo hellow atual por um em que os 0caracteres mais à esquerda estejam em maiúsculas;
• Substitua todas as ocorrências de 0por o+0(onde oé uma variável interna que é igual a 1).

A próxima vez em que o número no código for em 1vez de 0, e assim por diante.

Javascript, 52 bytes

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

Teste

=>

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

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

<= 'helloworld'

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

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

Experimente online!

Primeira saída:

/ //hello world

Segunda saída:

helloworld

BBC BASIC, 56 bytes

Eu tive um problema nisso antes de perceber o quão atrasado para o jogo eu estou. Pelo que vale, aqui está minha versão e minha primeira tentativa no código de golfe StackExchange.

Aqui, V. ecoa os caracteres fornecidos pelos códigos ASCII na seguinte lista separada por vírgulas e P. é uma abreviação de impressão. Utilizo o caractere backspace para substituir a string 'helloworld' existente.

Código de entrada:

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

Primeira saída:

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

Segunda saída:

helloworLD

Pode ser testado online em https://bbc.godbolt.org/