Створіть програму, яка виводить привіт світовий рядок ("Hello world", "Hello, World" тощо) та вихідний код. Вихідні дані записуються в stdout або еквівалент. Привіт світовий рядок вбудований у вихідний код.

Наприклад, висновок для може бути

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

Коли результат складається знову або інтерпретується, він повинен створити подібний вихід, але привіт загальносвітовий рядок повинен мати інший розділовий знак або велику літери. Наприклад, попередній приклад може створити наступний результат

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

Кожен "(деякий вихідний код тут)" у цих прикладах може змінюватися після кожного виконання, або він може бути однаковим.

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

Діє наступний розділовий знак:

hello, world
hello world
helloworld

Будь-яка капіталізація є прийнятною. Наприклад, це дійсні привітні світові рядки:

Hello, world
hellO WORld
HELLoworlD

Ці рядки недійсні:

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

Програма не працює, як тільки виконується одна з наступних умов:

• Він виводить привіт світовий рядок, який був виведений під час попереднього виконання,
• вихідний код більше не є дійсним вихідним кодом на тій же мові, або
• висновок не містить точно однієї дійсної привітної світової рядки.

Ваша програма не є дійсною для цього конкурсу, якщо успішні принаймні два перші виконання. Це означає, що третій вихід може бути недійсним. Вихід програми може бути не випадковим. Перше виконання завжди має створювати той самий другий вихід, друге виконання завжди має створювати той самий третій результат тощо.

Оцінка обчислюється як кількість байтів у вихідному коді початкової програми. Виграє найнижчий рахунок.

Застосовуються наступні бонуси (до -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.

Піт, 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 * .05 * (11-2) = 18,15 байт

Хе! Бий це! Ви, мабуть, будете. : c

Перший вихід:

'0DV \ {25 ^ -V \}} 1+ {rd3 * Z; helloworld
'Почніть захоплювати як рядок
 0DV Натисніть 0 на стек і встановіть його як кінцеву змінну.
    \ Повторіть наступний пункт багато разів. (1, 2, 3 ... на виходах.)
     {Поверніть стек вліво.
      25 ^ Натисніть 32 на стек.
         - Відніміть верхню частину по ній - це зробить малі регістри.
          V \ Виконайте наступний пункт остаточного змінного часу.
            } Поверніть стек вправо.
             } І знову...
              1+ Додати. Це робить 0 у цьому коді 1, потім 2 ...
                r Переверніть стек.
                 d3 * Отримати символ '
                    Z Виведіть усі елементи в стеку.
                     ; Закінчення виконання.
                      helloworld String маніпулювати.

Другий вихід:

'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; пеклоOWORLD

Восьмий вихід:

'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<}_~

де останній більше не містить дійсного "Привіт, світ".

Перевірте це тут.

Пояснення

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

Зауважте, що початкова програма не містить дійсного "Привіт, світ", але це дозволяє нам пройти ще одну ітерацію.

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% бонус. ;-)

Піт, 18 байт

"-\"hello world\"d

Що повертає:

-"hello world"d

Що в свою чергу друкує:

helloworld

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

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

Саме для цього народився Simplex . Я точно можу піти далі з цим.

(Я продовжую натискати 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, і рядка 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

Вихід (перша ітерація):

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

Прокрутіть далеко вправо, щоб знайти рядки "Привіт, світ"!

Піп, 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він не змінився. (Виправте мене, якщо я ще не зробив бонус правильно.)

Завдяки цьому питанню я щойно відкрив для себе нову техніку 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

Наш додатковий код змінює рядок y, перш ніж передрукувати його, наступним чином:

• Замініть поточний верховий світ тим, у якому лівий крайній 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 golf.

Тут В. повторює символи, задані кодами ASCII, у наступному списку, розділеному комами, та P. - це стенограма для друку. Я використовую символ зворотної області, щоб перезаписати існуючий рядок '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/