«Привет мир», который создает другую программу «Привет мир»

19

Создайте программу, которая выводит строку 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.

code-golf string quine hello-world
источник
1
Применяются ли обычные правила quine или программе разрешено читать собственный исходный файл?
Мартин Эндер
1
Обычные правила Quine применяются.
Считается ли оригинальный код в бонусах? Аналогично, должен ли оригинальный код содержать действительный код hello world?
Мартин Эндер
1
Оригинальный код засчитывается в бонусы. Оригинальный код не должен содержать действительный мир приветствия.
Вы уверены в этом последнем изменении правила? Вместе с «Первая программа не должна содержать допустимую строку hello world, или она может содержать несколько допустимых строк hello world». Я мог бы добавить недостающие варианты в качестве комментария к исходному исходному коду, чтобы получить бонус (вероятно, в большинстве случаев он того не стоит, но все еще выглядит как лазейка)
Фабиан Шменглер,

Ответы:

8

Pyth, 17 байт

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

"r\"helloworld\"1

Выход:

r"helloworld"1

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

HELLOWORLD
Фабиан Шменглер
источник
В настоящее время правила гласят: «Ваша программа завершается ошибкой, как только выполняется одно из следующих условий: вывод больше не является допустимым исходным кодом на том же языке» и «Ваша программа недействительна для этого конкурса, если не выполнено хотя бы три первых выполнения». , Является ли HELLOWORLD действительной программой на Pyth? Если да, пожалуйста, опубликуйте его вывод или объясните, что он делает. Если нет, я думаю, что эта программа недействительна.
Кроме того, я хочу уточнить, что эта программа не нарушает правила повторения одной и той же строки. Это решение повторяет «helloworld», который был в первом исходном коде. Правила только запрещают повторять строку, которая была в предыдущих выходных данных. Если вторым выводом является действительная программа Pyth, то это решение совершенно корректно.
На момент ответа правила звучали так: «Ваша программа не подходит для этого конкурса, если по крайней мере два первых исполнения не будут успешными»
Фабиан Шменглер,
О, ты прав. Я не уверен, почему я изменил это, потому что мой пример в первом посте утверждает, что два выхода = правильное решение. Я исправлю правила, чтобы отразить это. Так что ваше решение действительно. Это также лучшее действующее решение на данный момент.
9

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 программ без остановки, проходя все комбинации прописных и строчных букв. Казнь можно увидеть здесь .

LegionMammal978
источник
1
Жаль, что вы не можете выкинуть пустое пространство и использовать префикс и инфиксную нотацию в кавычках Mathematica, не так ли? ;) (Этого может быть достаточно для того, чтобы сработал подход противоположного квина, когда вы сохраняете код в строке sи оцениваете его с помощью ToExpression.)
Мартин Эндер,
6

Витси, 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

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

Аддисон Крамп
источник
1
о_о Симплекс боролся до 21. Я буду работать над победой 18.15, хотя!
Конор О'Брайен
@ CᴏɴᴏʀO'Bʀɪᴇɴ Vitsy практически создан для редактирования собственного исходного кода и выполнения основных операций со строками. XD Я думаю, что это может быть больше в гольфе, хотя.
Эддисон Крамп
Я думал, что симплекс будет крутым, так как он имеет внешнюю программную функцию, но не может считаться одной программой. ле вздох
Конор О'Брайен
+1 за избиение (или почти избиение) «классических» языков игры в гольф
ev3commander
@ ev3commander Я бы побил их, если бы бонус за итерацию был выше. : c
Эддисон Крамп
5

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», но это позволяет нам продвинуться еще на одну итерацию.

Мартин Эндер
источник
Имеет ли это право на бонус -10%? Выходные данные содержат только две из трех допустимых форм пунктуации.
Майк Буфардеси
@MikeBufardeci О, хороший вопрос ... Я предположил, что оригинальный код был частью этого.
Мартин Эндер
1
Я уточнил правила, чтобы исходный код учитывался для бонуса. Хотя я должен признать, что не понимал, что так легко получить -10%.
5

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
Akangka
источник
У вас другой язык и более короткий ответ, поэтому нет ничего плохого в использовании того же подхода, что и в ответе Mathematica.
Обратите внимание, что мы ищем самый низкий балл, а не самый быстрый постер или самый новый алгоритм.
@ Ville-ValtteriTiittanen Тем не менее, ответ Мартина Бюттнера все еще ниже, чем у меня
Akangka
@ChristianIrwan Ваш интерес интересен тем, что он производит разные заглавные буквы (и я уверен, что можно приблизиться к моему или даже побить его, но у меня нет времени, чтобы рассмотреть это подробно прямо сейчас).
Мартин Эндер
4

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 10 = 1024, получение цикла с 890 итерациями довольно неплохо.)

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

Илмари Каронен
источник
3

Pyth, 18 байт

"-\"hello world\"d

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

-"hello world"d

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

helloworld

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

Майк Буфардечи
источник
Обратите внимание, что этот ответ недействителен, пока правила не были возвращены к требованию двух итераций, а не трех. Это теперь действительно снова, хотя.
DLosc
3

Симплекс , 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
Конор О'Брайен
источник
Эта программа имеет право на бонус -50%? Похоже, что это может быть, но вы не опубликовали какие-либо выводы.
@ Ville-ValtteriTiittanen Работает только дважды. Я работаю над бонусами в данный момент.
Конор О'Брайен
2

Рубин, 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, чтобы она появлялась только один раз.

histocrat
источник
1

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»!

Фабиан Шменглер
источник
только что понял, что могу поменять (int)trueна `` !! i` и сохранить 12 байтов. Попробую
поиграть
1

Пип, 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, и так далее.

DLosc
источник
1

Javascript, 52 байта

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

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

=>

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

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

<= 'helloworld'

Fuzzyzilla
источник
1

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

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

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

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

/ //hello world

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

helloworld
Стрелец
источник
Бонус предоставляется более чем за две итерации, поэтому ваш счет по-прежнему составляет 23 байта
Джо Кинг,
1

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/

Андрей Пол
источник
Я определенно никогда не использовал BBC BASIC, но как это можно проверить? Если я вставлю это в связанный эмулятор, последняя строка, похоже, выдаст «Ошибка» для меня.
мое местоимение monicareinstate
Я отредактирую свой ответ для ясности. Это просто первая строка, которую нужно вставить. Вторую сгенерированную строку можно скопировать и выполнить в эмуляторе с помощью курсора ПК и клавиш «конец». Третья строка может быть недействительной в соответствии с правилами.
Андрей Пол