Создайте программу, которая выводит строку hello world («Hello world», «Hello, World» и т. Д.) И исходный код. Вывод записывается в стандартный вывод или эквивалентный. Строка Hello World встроена в исходный код.

Например, вывод для может быть

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

Когда выходные данные компилируются или интерпретируются снова, они должны создавать аналогичные выходные данные, но строка hello world должна иметь другую пунктуацию или заглавные буквы. Например, предыдущий пример может создать следующий вывод

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

Каждое «(некоторый исходный код здесь)» в этих примерах может меняться после каждого выполнения или может быть одинаковым.

Ваш вывод должен содержать правильную строку hello world ровно один раз. Может содержать любое количество недопустимых строк hello world. Исходный код может содержать любое количество комментариев, а строка hello world может быть встроена в комментарии. Первая программа может иметь либо ноль, либо одну допустимую строку hello world, но не более.

Действительна следующая пунктуация:

hello, world
hello world
helloworld

Любая капитализация приемлема. Например, это допустимые строки hello world:

Hello, world
hellO WORld
HELLoworlD

Эти строки не действительны:

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

Ваша программа завершается ошибкой, как только выполняется одно из следующих условий:

• Он выводит строку приветствия, которая была выведена во время более раннего выполнения,
• вывод больше не является допустимым исходным кодом на том же языке, или
• вывод не содержит ровно одну действительную строку hello world.

Ваша программа не подходит для этого конкурса, если по крайней мере два первых исполнения не будут успешными. Это означает, что третий вывод может быть недействительным. Вывод вашей программы может быть не случайным. Первое выполнение всегда должно создавать один и тот же второй вывод, второе выполнение всегда должно создавать один и тот же третий вывод и т. Д.

Оценка рассчитывается как количество байтов в исходном коде исходной программы. Самый низкий балл побеждает.

Применяются следующие бонусы (до -60%):

• -5% * (N - 2), где N - индекс выполнения, после которого ваша программа выдает неверный вывод. Этот бонус ограничен на -50%. Если ваша программа будет выполнена 12 или более раз, вы получите максимальный бонус.
• -10%, если ваши выходные данные (включая первый исходный код) включают все три допустимых варианта пунктуации.

Ваша заявка должна содержать первый исходный код, и он также должен содержать результаты успешных выполнений. Если ваша программа выполняется более 12 раз, добавьте вывод для 12 выполнений.

пример

Следующая строка - первый исходный код. Когда мы выполняем это, это первое исполнение.

hello world(some source code here)

Следующая строка - это вывод из первого исходного кода. Это первый выход.

hello, world(some source code here) 

Следующая строка - это выход из второго выполнения. Это второй выход.

helloworld(some source code here)

Когда мы выполнили первый вывод, эта программа получила право на бонус -10%. Это означает, что у нас есть два выхода и один оригинальный код, каждый из которых имеет различную пунктуацию. Более того, поскольку второй вывод был действительным, эта программа подходит для этого конкурса.

Следующая строка - вывод из третьего исполнения. Это третий выход.

Helloworld(some source code here)

Следующая строка - результат четвертого выполнения. Это четвертый выход.

hellworld(some source code here)

Этот вывод был недействительным. Индекс последнего действительного выполнения был 4. Эта программа имеет право на бонус -5% * (4 - 2) и бонус -10% от пунктуации. Это составляет всего -20%. Длина первого исходного кода («Привет, мир (здесь немного исходного кода)») составляла 34 байта, поэтому итоговая оценка составляет 27,2.

Pyth, 17 байт

Другое решение Pyth:

"r\"helloworld\"1

Выход:

r"helloworld"1

Второй выход:

HELLOWORLD

Mathematica, 214 - 50% = 107 байт

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

Я решил оптимизировать количество строк здесь. Это работает для 1024 программ без остановки, проходя все комбинации прописных и строчных букв. Казнь можно увидеть здесь .

Витси, 33 - 33 * 0,05 * (11-2) = 18,15 байт

Хех! Бить это! Вы, вероятно, будете. : с

Первый вывод:

«0DV \ {25 ^ -V \}} {1+ RD3 * Z; HelloWorld
«Начать захват в виде строки
 0DV Вставьте 0 в стек и установите его в качестве последней переменной.
    \ Повторите следующий пункт много раз. (1, 2, 3 ... на выходах.)
     {Поверните стопку влево.
      25 ^ толчок 32 в стек.
         - Вычтите верхний элемент из него - это сделает строчные буквы в верхнем регистре.
          V \ Сделать следующий элемент окончательной переменной раз.
            } Поверните стопку вправо.
             } И опять...
              1+ Добавить один. Это делает 0 в этом коде 1, затем 2 ...
                • Переверните стек.
                 d3 * Получить персонажа
                    Z Вывести все предметы в стеке.
                     ; Конец казни.
                      helloworld Строка для манипулирования.

Второй выход:

«1DV \ {25 ^ -V \}} {1+ RD3 * Z; HelloWorld

Третий выход:

«2DV \ {25 ^ -V \}} {1+ RD3 * Z; HelloWorld

Четвертый вывод:

«3DV \ {25 ^ -V \}} {1+ RD3 * Z; HelloWorld

Пятый выход:

«4DV \ {25 ^ -V \}} {1+ RD3 * Z; HelloWorld

Шестой вывод:

«5DV \ {25 ^ -V \}} {1+ RD3 * Z; HelloWorld

Седьмой выход:

«6DV \ {25 ^ -V \}} {1+ RD3 * Z; HelloWorld

Восьмой выход:

«7DV \ {25 ^ -V \}} {1+ RD3 * Z; HelloWorld

Девятый вывод:

«8DV \ {25 ^ -V \}} {1+ RD3 * Z; HelloWorld

Десятый выход:

«9DV \ {25 ^ -V \}} {1+ RD3 * Z; HelloWorld

Одиннадцатый вывод:

«: DV \ {25 ^ -V \}} {1+ RD3 * Z; HelloWorld

Это последний вывод, так как это приведет к ошибке.

CJam, N = 3 4, 28 байт - 10% - 10% = 22,4

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

это запускает следующую цепочку:

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

где последний больше не содержит действительный «Hello, World».

Проверьте это здесь.

объяснение

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

Обратите внимание, что исходная программа не содержит допустимого «Hello, World», но это позволяет нам продвинуться еще на одну итерацию.

CJam 69 60 - 50% = 30

Я все еще новичок, пожалуйста, скажите мне, как играть в гольф в CJam.

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

Распечатывать каждую итерацию утомительно, так как она будет действительна в течение 99 итераций.

Он работает путем перечисления заглавных букв привет слова. Скука состоит в том, чтобы разбить строки на части, так как «привет мир» и счетчик должны быть обновлены.

объяснение

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

ПРИМЕЧАНИЕ: я не читаю ответ Mathematica, извините, я думаю, что он был оригинальным

При переупорядочении и различной капитализации я теряю 9 байт.

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

На этот раз также перечислю пунктуацию.

{`: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 байт - 50% = 17,5

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

Я решил пойти на излишнее количество казней, прежде чем повторить. Эта программа с выводом обратно в интерпретатор GolfScript произведет перед первым повторением 890 различных строк Hello World. В качестве краткого примера, вот первые 15 итераций:

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

Это работает путем итерации по строке, переворачивая заглавные буквы каждой буквы (путем XORing ASCII-кода с 32), если предыдущая буква (после возможного переворачивания регистра) строчная. Первая буква будет перевернута в случае, если число в начальной программе равно 32, а не 0 - и число, выведенное для следующей итерации, будет равно 32, когда последняя буква строки будет строчной, что приведет к любым изменениям в конце строка для распространения обратно в начало на следующей итерации.

(Этот конкретный процесс обратной связи был получен совершенно нерегулярным способом. Первоначально я хотел просто запустить простой двоичный счетчик, используя прописные и строчные буквы в качестве битов, но для его реализации потребовалось слишком много байтов, поэтому я начал настраивать его, чтобы найти что-то более короткое это все равно дало бы довольно большую длину цикла. Так как теоретический максимум, использующий только переключение регистра, равен 2 ¹⁰ = 1024, получение цикла с 890 итерациями довольно неплохо.)

Увы, бонус за дополнительные итерации ограничен −50%; без кепки эта программа имела бы колоссальный бонус -4440%. ;-)

Pyth, 18 байт

"-\"hello world\"d

Который возвращает:

-"hello world"d

Который в свою очередь печатает:

helloworld

У меня было решение, которое выполнило все три написания, но оно дольше даже с бонусом.

Симплекс , 21 байт.

Для этого и родился Симплекс . Я определенно могу пойти дальше с этим.

(Продолжаю нажимать Ctrl + Enter, извините! Я виню в этом клавиатуру планшета)

Попытка 3, v.0.8 +, 31 -5% = 29,45 байта (метки UTF-8)

Эта эмоция в середине выражает себя. Вроде. Почему я сделал это снова? ._.

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

2-й выход:

"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-й выход:

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

Окончательный вывод:

HelloworlD

Попытка 2, v.0.8 +, 21 байт (UTF-8, я думаю)

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

Выход:

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

Окончательный вывод:

helloworld

Попытка 1, v.0.7 + 28 26 байт

Я не уверен, имеет ли это право на первый бонус ...

"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

Первый вывод:

"HELLOWORLD"g

Внешняя программа оценивается в конце выполнения (она делает это для y; вот как выглядит внешняя программа:

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

Окончательный вывод:

HELLOWORLD

Рубин, 81 - 50% = 40,5

Оригинальный код:

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

Последовательные результаты:

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

Я думаю, что это считается полными 50%? Может быть, один. Кроме того, в Ruby, вероятно, есть лучшее решение для получения бонусов.

Исходный код не содержит «helloworld», но он создает квин, который заменяет первую заглавную букву в исходном коде на строчную версию. Таким образом, каждый последующий цикл quine выводит на одну букву меньше заглавной буквы.

Хитрость здесь в том, чтобы использовать строку формата для интерполяции как самой строки, для квинтинга, так и строки Hello World, чтобы она появлялась только один раз.

PHP, 297 - 40% = 178,2 байта

Не очень конкурентоспособно, но было весело писать

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

Это вариация этой квинны:

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

но он также добавляет «helloworld» к выводу и заменяет его 0на 0+1(в следующей итерации 1с 1+1и так далее). Использование substrлюбого существующего вывода "helloworld" удаляется до добавления нового "helloworld".

Чтобы получить различный вывод, одна буква «helloworld» становится заглавной (определяется возрастающим числом). Это соответствующий код:

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

Задача состояла в том, чтобы не использовать какие-либо номера, кроме как здесь, и для замены номера

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

Там вы уже видите, что +1реализовано как +(int)true.

Для аргументов подстроки мне понадобилось 0, 146:

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

Непустая строка «i» приводится к значению trueи отменяется. falseявляется допустимым целочисленным аргументом и рассматривается как 0. ord(I)значение ASCII для «I»: 73

Выход (1-я итерация):

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

Выход (2-я итерация):

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

Выход (10-я итерация):

Это последний действительный вывод, но больше не действительная программа

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

Прокрутите вправо, чтобы найти строки «Hello world»!

Пип, 48 - 50% = 24

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

который развивается следующим образом:

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"

с последним выводом, являющимся недействительным, потому что HELLOWORLD не изменился. (Поправьте меня, если я не сделал бонус правильно.)

Благодаря этому вопросу, я только что открыл новую технику квина! Базовая квиния 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

Наш дополнительный код изменяет строку yперед ее повторением следующим образом:

• Замените текущий helloworld на тот, в котором самый левый 0 символы находятся в верхнем регистре;
• Заменить все вхождения 0с o+0(где oвстроенная переменная, равная 1).

В следующий раз 1вместо числа в коде вместо 0, и так далее.

Javascript, 52 байта

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

Тестовое задание

=>

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

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

<= 'helloworld'

///, 23 байта - 10% = 20,7?

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

Попробуйте онлайн!

Первый вывод:

/ //hello world

Второй выход:

helloworld

BBC BASIC, 56 байт

У меня была трещина в этом, прежде чем я понял, как поздно я до игры. Для чего это стоит, вот моя версия и моя первая попытка игры в гольф StackExchange.

Здесь V. выводит символы, заданные кодами ASCII в следующем списке, разделенном запятыми, а P. - сокращение для печати. Я использую символ Backspace, чтобы перезаписать существующую строку 'helloworld'.

Введите код:

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

Первый вывод:

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

Второй вывод:

helloworLD

Его можно протестировать онлайн на https://bbc.godbolt.org/