Гольф вам королева за велике благо!

204

Використовуючи вашу мову вибору, гольф- лас .

Куайн є непустою комп'ютерною програмою , яка не приймає вхідний сигнал і видає копію свого власного вихідного коду в якості єдиного виходу.

Ніякого обману - це означає, що ви не можете просто прочитати вихідний файл і роздрукувати його. Крім того, у багатьох мовах порожній файл також є лайкою: і це не вважається легітимним quine.

Немає помилок - вже існує окремий виклик для помилок.

Бали за:

  • Найменший код (у байтах)
  • Найбільш затуманене / незрозуміле рішення
  • Використання езотеричних / незрозумілих мов
  • Успішно використовуйте мови, на яких важко грати

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

Показати фрагмент коду

code-golf  quine 
— Рейф Кеттлер
джерело
4
Ви не маєте на увазі: "Гольф ти - це більше для добра!"
— Mateen Ulhaq
50
@muntoo це п'єса на тему "Навчися тебе Haskell для великого добра".
— Рейф Кеттлер

Відповіді:

106

Шестикутник , довжина сторони 17 16, 816 705 байт

180963109168843880558244491673953327577233938129339173058720504081484022549811402058271303887670710274969455065557883702369807148960608553223879503892017157337685576056512546932243594316638247597075423507937943819812664454190530214807032600083287129465751195839469777849740055584043374711363571711078781297231590606019313065042667406784753422844".".>.@.#.#.#.#.#.#.#.>.(...........................<.".......".".>./.4.Q.;.+.<.#.>...........................<.".....".".>.#.#.>.N.2.'.\.>.............=.=......._.<.".....".".>.>.;.'.=.:.\.>.......................<."...".".>.\.'.%.'.<.#.>..............._.....<."...".".>.#.#.>.<.#.>...............=.=.<.".".".>.#.\.'.R./.>.................<.".!.........../.>.

Спробуйте в Інтернеті!

Ось так виглядає розгорнуте:

                1 8 0 9 6 3 1 0 9 1 6 8 8 4 3 8
               8 0 5 5 8 2 4 4 4 9 1 6 7 3 9 5 3
              3 2 7 5 7 7 2 3 3 9 3 8 1 2 9 3 3 9
             1 7 3 0 5 8 7 2 0 5 0 4 0 8 1 4 8 4 0
            2 2 5 4 9 8 1 1 4 0 2 0 5 8 2 7 1 3 0 3
           8 8 7 6 7 0 7 1 0 2 7 4 9 6 9 4 5 5 0 6 5
          5 5 7 8 8 3 7 0 2 3 6 9 8 0 7 1 4 8 9 6 0 6
         0 8 5 5 3 2 2 3 8 7 9 5 0 3 8 9 2 0 1 7 1 5 7
        3 3 7 6 8 5 5 7 6 0 5 6 5 1 2 5 4 6 9 3 2 2 4 3
       5 9 4 3 1 6 6 3 8 2 4 7 5 9 7 0 7 5 4 2 3 5 0 7 9
      3 7 9 4 3 8 1 9 8 1 2 6 6 4 4 5 4 1 9 0 5 3 0 2 1 4
     8 0 7 0 3 2 6 0 0 0 8 3 2 8 7 1 2 9 4 6 5 7 5 1 1 9 5
    8 3 9 4 6 9 7 7 7 8 4 9 7 4 0 0 5 5 5 8 4 0 4 3 3 7 4 7
   1 1 3 6 3 5 7 1 7 1 1 0 7 8 7 8 1 2 9 7 2 3 1 5 9 0 6 0 6
  0 1 9 3 1 3 0 6 5 0 4 2 6 6 7 4 0 6 7 8 4 7 5 3 4 2 2 8 4 4
 " . " . > . @ . # . # . # . # . # . # . # . > . ( . . . . . .
  . . . . . . . . . . . . . . . . . . . . . < . " . . . . . .
   . " . " . > . / . 4 . Q . ; . + . < . # . > . . . . . . .
    . . . . . . . . . . . . . . . . . . . . < . " . . . . .
     " . " . > . # . # . > . N . 2 . ' . \ . > . . . . . .
      . . . . . . . = . = . . . . . . . _ . < . " . . . .
       . " . " . > . > . ; . ' . = . : . \ . > . . . . .
        . . . . . . . . . . . . . . . . . . < . " . . .
         " . " . > . \ . ' . % . ' . < . # . > . . . .
          . . . . . . . . . . . _ . . . . . < . " . .
           . " . " . > . # . # . > . < . # . > . . .
            . . . . . . . . . . . . = . = . < . " .
             " . " . > . # . \ . ' . R . / . > . .
              . . . . . . . . . . . . . . . < . "
               . ! . . . . . . . . . . . / . > .
                . . . . . . . . . . . . . . . .

Ну добре, це був цілком емоційний гірка ... Я перестав рахувати кількість разів, коли я перемикався між "ха-ха, це божевілля" і "чекай, якщо я це робити, це насправді має бути досить виконаним". Обмеження, накладені кодом правилами розміщення Гексагоні, були ... суворими.

Можливо, можливо зменшити бічну довжину на 1 або 2, не змінюючи загального підходу, але це буде важко (лише комірки з на #даний момент не використовуються та доступні для декодера). На даний момент у мене також абсолютно не залишилося ідей щодо більш ефективного підходу, але я впевнений, що такий існує. Я подумаю над цим протягом кількох наступних днів і, можливо, спробую розіграти гольф на одній стороні, перш ніж додати пояснення і все.

Принаймні, я довів, що це можливо ...

Деякі сценарії CJam для моєї власної майбутньої довідки:

— Мартін Ендер
джерело
51
Шановний Піте, що це?
— Conor O'Brien
2
Скільки часу знадобилося, щоб це зробити?
— Аднан
3
@AandN Я розмовляв із поняттями для загального "шаблону" з вчорашнього часу (тоді це не передбачало фактичного тестування ... просто набравши деякі матеріали в сітці 7x7 і побачивши, чи може це спрацювати .. . Я відкинув, мабуть, півдесятка підходів уже там). Дійсне кодування тоді зайняло цього вечора ... я б сказав, що 3 години.
— Мартін Ендер
10
Слова не можуть пояснити, як я здивований, бачачи це в дії з Езотеричним IDE крок за кроком ... Кому, можливо, захочеться це зрозуміти, цей шестикутник кодує частину "декодера" в ціле число, яке друкується разом із, !а потім - дзеркалом /на другому останньому рядку воно вводиться в декодер для друку коду декодера для завершення ланцюжка. Це чудове використання <і >який читає багаторядкова дуже велике ціле і побудував майданчик для зберігання декодера. Мені б дуже хотілося знати, про які "десятки підходів" розглядаються?
— Сонячний Пун
3
Пояснення? ---
— MD XF
77

MySQL, 167 символів

SELECT REPLACE(@v:='SELECT REPLACE(@v:=\'2\',1+1,REPLACE(REPLACE(@v,\'\\\\\',\'\\\\\\\\\'),\'\\\'\',\'\\\\\\\'\'));',1+1,REPLACE(REPLACE(@v,'\\','\\\\'),'\'','\\\''));

Це вірно. :-)

Я справді сам писав це. Спочатку було розміщено на моєму сайті .

— TehShrike
джерело
72

GolfScript, 2 байти

1

(зверніть увагу на зворотній новий рядок) Це висуває номер 1 на стек. В кінці програми GolfScript роздруковує всі елементи в стеку (без пробілів між ними), після чого друкує новий рядок.

Це справжня квітина (як зазначено у запитанні), оскільки вона фактично виконує код; він не просто "читає вихідний файл і друкує його" (на відміну від подання PHP).

Інший приклад, ось програма GolfScript для друку 12345678:

9,(;
  1. 9: натисніть 9 на стек
  2. ,: споживайте 9 як аргумент, натисніть масив [0 1 2 3 4 5 6 7 8]до стеку
  3. (: споживайте масив як аргумент, натискайте масив [1 2 3 4 5 6 7 8]та елемент 0на стек
  4. ;: відкиньте верхній елемент стеку

Стек тепер містить масив [1 2 3 4 5 6 7 8]. Це записується до стандартного виводу без пробілів між елементами, за яким слідує новий рядок.

— Кріс Єстер-Янг
джерело
18
Або PowerShell, або PHP :-)
— Джої
6
Ви не повернулися в часі і даєте винахіднику ідею винайти GolfScript, чи не так?
— Mateen Ulhaq
78
Технічно 1це не квинь в GolfScript: він виводить 1\n, де \nпозначає новий рядок. Однак двочарова програма 1\n - це квітка.
— Ільмарі Каронен
17
Одночарова програма, \nймовірно, також є?
— Лінн
10
@ Псевдонім quine - це буквально програма, яка друкує власне джерело. Я не думаю, що існують будь-які довільні обмеження щодо "структури".
— Hugo Zink
71

Brain-Flak , 9.8e580 1.3e562 9.3e516 12818 11024 4452 4332 4240 4200 4180 3852 3656 3616 3540 2485 + 3 = 2488 байт

Тепер підходить до спостережуваного Всесвіту!

(())(()()())(())(())(()()())(())(())(()()())(())(()()()()())(()())(()()()()())(())(()()())(())(()()()()())(())(())(())(())(()()()()())(())(())(()()())(())(())(()()())(())(()()()()())(()())(()()()()())(())(()()())(())(()()()()())(())(())(())(())(())(())(()())(())(())(())(()())(()()()())(())(()()()()())(()())(()())(()())(()()())(())(()())(())(()()()()())(()())(()()()()())(())(())(())(())(())(()())(())(())(())(()()()()())(())(())(()()()()())(())(())(()()()()())(())(())(()())(())(()())(())(()())(())(()())(())(()())(()())(()())(()())(()())(()())(()())(()())(())(()()()()())(())(())(()()())(())(())(()()())(())(()()()()())(()())(()()()()())(())(()()())(())(())(()()())(()())(())(()()()()())(())(())(()()())(())(())(()()())(())(()()()()())(()())(()()()()())(())(())(())(()()())(())(())(()()())(())(())(()()())(())(()()()()())(()())(()()()()())(()()())(())(()()())(())(())(())(()())(()()())(()())(())(()()()()())(()())(())(()()())(())(()()()()())(())(())(())(()()())(())(())(())(()())(())(()())(()()()())(())(())(()()()()())(()())(()())(())(()()())(())(())(())(())(()()())(()())(())(())(()()()()())(())(())(()()()()())(())(())(()()()()())(())(())(()())(())(()())(())(()())(())(()())(()())(()())(()())(())(()()()()())(()())(())(()()())(())(()()()()())(()()()()())(())(()()())(())(())(()())(())(()()()()())(())(()()()()())(())(())(())(()()()()())(())(())(()())(())(()())(())(()())(())(()())(())(()())(()())(()())(()())(())(()()()()())(()())(())(()()())(())(())(()())(())(()()()()())(()())(()()()()())(())(()()())(())(())(()()()()())(())(()()()()())(())(())(())(()())(())(()()()()())(())(())(()())(())(()())(())(()())(()())(()())(()())(())(()()()()())(()())(())(()()()()())(())(()()())(())(())(()())(())(()()()()())(()())(()()()()())(())(()()())(())(())(())(()())(()()()())(())(())(()())(())(()()()()())(())(())(()()()()())(())(())(()()()()())(())(())(()())(())(()())(())(()())(())(()())(())(()())(()())(()())(()())(()())(()())(())(()()())(())(())(()())(())(()()()()())(()())(()()()()())(()()())(())(())(()())(())(())(()()()()())(()()()())(()())(()())(()()())(())(()())(())(()()()()())(()())(()()()()())(())(())(())(()()()())(()()()())(()())([[]]){({}()<(([{}]())<{({}())<>(((((()()()()()){}){}){}())[()])<>{({}())<>{}({}(((()()()){}())){}{})<>{({}())<>({}(((()()()()()){})){}{}())<>{{}<>({}(((()()()()){}){}){})(<>)}}<>(({})[()()])<>}}{}<>({}(<()>)<><{({}<>)<>}<>>){({}<>)<>}{}(<>)<>{({}<>)<>}{}(((((((()()()()()){}){}){}))()))>){({}()<((({}[()])()))>)}{}<>{({}<>)<>}{}>)}{}<>{({}<>)<>}<>

Спробуйте в Інтернеті!

Пояснення

Ця Quine працює як і більшість Quines в езотеричних мовах; він має дві частини кодер і декодер. Кодер - це всі дужки на початку, а декодер є більш складною частиною на самому кінці.

Наївним способом кодування програми було б поставити значення ASCII кожного символу в декодері до стеку. Це не дуже гарна ідея, оскільки Brain-Flak використовує лише 8 символів ( ()<>[]{}), тож ви в кінцевому рахунку заплатите досить багато байт, щоб кодувати дуже мало інформації. Більш розумна ідея, яка використовувалася до цього часу, - присвоїти кожному з 8 дужок набагато меншу кількість (1-8) та перетворити їх у значення ASCII за допомогою нашого декодера. Це добре, тому що коштує не більше 18 байт для кодування символу на відміну від попередніх 252.

Однак ця програма не робить жодного. Він спирається на той факт, що програми Brain-Flak усі збалансовані для кодування 8 брекетів з числами до 5. Він кодує їх наступним чином.

(       -> 2
<       -> 3
[       -> 4
{       -> 5
),>,],} -> 1

Усі тісні дужки призначаються 1, оскільки ми можемо використовувати контекст, щоб визначити, який з них нам потрібно використовувати в конкретному сценарії. Це може здатися важким завданням для програми Brain-Flak, але насправді це не так. Візьмемо для прикладу наступні кодування з розшифрованими відкритими дужками, а закриті дужки замінені на .:

(.
((..
<([.{...

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

Пояснення низького рівня

Робота в процесі

— Сріотчілізм О'Заїк
джерело
25
Я думаю, ви виграєте за найдовше рішення проблеми з кодовим гольфом ...
— Mego
18
Щойно зробив найбільший одиночний гольф в історії PPCG Nope. 9.8e580 все ще вражає.
— Денніс
19
+1 за пристосування до спостережуваного Всесвіту. Також у TIO Nexus постійна посилання має відповідати відповіді. tio.run/nexus/…
— Dennis
3
... дуже великий гольф ...
— Зруйнований лимон
3
Я думаю, ви виграєте більшість байтів, відрізаних
— Крістофер,
68

Прелюдія , 5157 4514 2348 1761 1537 664 569 535 423 241 214 184 178 175 169 148 142 136 133 байт

Завдяки Sp3000 за збереження 3 байтів.

Це досить довго ... (гаразд, це ще довго ... принаймні, це побиття найкоротшого відомого Brainfuck C # quine на цьому виклику зараз), але це перша квин, яку я виявив сам (мої подання Луа та Джулія - ​​це справді лише переклади стандартні методики квіни іншими мовами), і наскільки я знаю, ніхто досі не написав квінку в Prelude, тому я насправді цим дуже пишаюся. :)

7( -^^^2+8+2-!( 6+ !
  ((#^#(1- )#)8(1-)8)#)4337435843475142584337433447514237963742423434123534455634423547524558455296969647344257)

Ця велика кількість цифр - це просто кодування основного коду, саме тому квітка така довга.

Цифри, що кодують quine, були створені за допомогою цього сценарію CJam .

Для цього потрібен стандартний сумісний перекладач, який друкує символи (використовуючи значення як коди символів). Отже, якщо ви використовуєте інтерпретатор Python, вам потрібно буде встановити NUMERIC_OUTPUT = False.

Пояснення

По-перше, кілька слів про Prelude: кожен рядок у Prelude - це окремий "голос", який маніпулює власною стекою. Ці стеки ініціалізуються до нескінченного числа 0. Програма виконується колонка за стовпцем, де всі команди в стовпці виконуються "одночасно" на основі попередніх станів стека. Цифри висуваються на стек окремо, тому 42натискатимемо a 4, потім a 2. Немає можливості прямо натиснути великі числа, вам доведеться їх додавати. Значення можна скопіювати з сусідніх стеків за допомогою vта ^. Петлі в стилі Brainfuck можна ввести в дужки. Додаткову інформацію див. За посиланням у заголовку.

Ось основна ідея quine: спочатку ми висуваємо набір цифр на стек, який кодує серцевину quine. Потім згадане ядро ​​бере ці цифри, розшифровує їх для друку, а потім роздруковує цифри, як вони з'являються в коді ).

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

Кодування

Оскільки код має лише два голоси, а і суміжність циклічна, ^і vє синонімічними. Це добре, тому vщо на сьогоднішній день найбільший код символів, тож уникаючи його завжди використовуючи, ^кодування спрощується. Зараз усі символьні коди знаходяться в діапазоні від 10 до 94 включно. Це означає, що я можу кодувати кожен символ точно двома десятковими цифрами. Однак існує одна проблема: деякі символи, зокрема передавач рядків, мають нульове позначення у десятковій формі. Це проблема, тому що нулі не можна легко відрізнити від нижньої частини стека. На щастя, є просте виправлення цього: ми компенсуємо коди символів на 2, тому у нас є діапазон від 12 до 96 включно, що все ще зручно вписується у дві десяткові цифри. Тепер усіх персонажів, які можуть з’явитися в програмі Prelude,0має 0 у своєму представленні (50), але нам насправді це зовсім не потрібно 0. Отже, це кодування, яке я використовую, натискаючи кожну цифру окремо.

Однак, оскільки ми працюємо зі стеком, уявлення висуваються у зворотному напрямку. Отже, якщо ви подивитеся на кінець кодування:

...9647344257

Розділіть на пари і оберніть, потім відніміть два, а потім знайдіть коди символів:

57 42 34 47 96
55 40 32 45 94
 7  (     -  ^

де 32відповідає пробілам. Ядро робить саме це перетворення, а потім друкує символів.

Ядро

Тож давайте подивимось, як насправді обробляються ці числа. По-перше, важливо зазначити, що відповідні дужки не повинні бути на одному рядку в Prelude. На один стовпчик може бути лише одна дужка, тому немає неоднозначності, які дужки належать разом. Зокрема, вертикальне положення дужок, що закриваються, завжди не має значення - стек, який перевіряється, щоб визначити, чи закінчується цикл (або повністю пропущений), завжди буде таким, який має (.

Ми хочемо запустити код рівно двічі - перший раз ми пропускаємо ядро ​​і натискаємо всі числа в кінці, вдруге запускаємо ядро. Насправді, після запуску ядра, ми знову натиснемо всі ці числа, але оскільки цикл згодом припиняється, це не має значення. Це дає такий скелет:

7(
  (                   )43... encoding ...57)

По-перше, ми натискаємо 7на перший голос - якщо ми цього не робимо, ми ніколи не входитимемо в цикл (для скелета важливо лише те, що це не нуль ... чому це конкретно 7ми побачимо пізніше) . Потім вводимо основну петлю. Тепер другий голос містить ще одну петлю. При першому проходженні цей цикл буде пропущений, оскільки другий стек порожній / містить лише 0. Тож ми переходимо прямо до кодування і натискаємо всі ці цифри на стек. 7Ми штовхнули на перший стек ще є, так що цикл повторюється.

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

Далі розглянемо перший цикл у фактичному ядрі. Робити речі одночасно з (або )досить цікаво. Тут я позначив тіло циклу =:

-^^^2+8+2-!
(#^#(1- )#)
 ==========

Це означає, що стовпець, що містить (, не вважається частиною циклу (символи там виконуються лише один раз, і навіть якщо цикл пропускається). Але стовпець, що містить, ) є частиною циклу і запускається один раз на кожній ітерації.

Отже, ми починаємо з синглу -, який перетворює 7перший стек у -7... знову, про це пізніше. Що стосується фактичного циклу ...

Цикл продовжується, поки стоп цифр не випорожнено. Він обробляє дві цифри одночасно. Мета цього циклу - розшифрувати кодування, надрукувати символ і одночасно перенести стопку цифр на перший голос. Отже, ця частина спочатку:

^^^
#^#

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

Тепер ми відновимо код символу з двох цифр:

2+8+2-!
(1- )#

Внизу - це невелика петля, яка просто зменшує 10-значне до нуля. Для кожної ітерації ми хочемо додати 10 зверху. Пам’ятайте, що перший 2не є частиною циклу, тому тіло циклу насправді +8+2додає 10 (використовуючи 2натиснуті раніше), а натискає ще 2. Отже, коли ми закінчимо цикл, перший стек насправді має базовий- 10 значення та ще 2. Ми віднімаємо цю 2 -для врахування зміщення в кодуванні та друкуємо символ із !. #Просто скидає в нуль на кінці нижньої петлі.

Після завершення цього циклу другий стек порожній, а перший стек містить усі цифри у зворотному порядку (і -7внизу). Решта досить проста:

( 6+ !
8(1-)8)#

Це друга петля ядра, яка тепер виводить назад усі цифри. Для цього нам потрібно 48 до кожної цифри, щоб отримати правильний код символу. Ми робимо це за допомогою простого циклу, який запускає 8рази та додає 6кожен раз. Результат друкується за допомогою, !а 8в кінці - для наступної ітерації.

Так що ж з -7? Так, 48 - 7 = 41код символу ). Магія!

Нарешті, коли ми закінчимося з цією петлею, ми відкидаємо 8щойно натиснуті нами #для того, щоб залишити зовнішній цикл на другому голосі. Знову натискаємо всі цифри і програма припиняється.

— Мартін Ендер
джерело
1
Слухати Hello World у Fugue зараз ... досить привабливо.
— Роберт Фрейзер
19
Мартіне, ти повинен кудись зупинитися.
— seequ
3
Мені подобається, що в цілому понад 5 000 байтів, а також підтвердження Sp3000 за збереження 3 з них.
— Каміль Дракарі
2
@KamilDrakari Це були останні 3 байти, тож це велика справа. ;)
— Мартін Ендер
57

Шестикутник , довжина сторони 11, 314 байт

164248894991581511673077637999211259627125600306858995725520485910920851569759793601722945695269172442124287874075294735023125483.....!/:;.........)%'=a':\....................\...................\..................\.................\................\...............\..............\..$@.........\$><>'?2='%.<\:;_;4Q

Спробуйте в Інтернеті!

Старіша версія:

Шестикутник , довжина сторони 11, 330 байт

362003511553420961423766261426252539048636523959468260999944549820033581478284471415809677091006384959302453627348235790194699306179..../:{;+'=1P'%'a{:..\.....................\...................\..................\.................\................\...............\..............\.............\!$><........\..@>{?2'%<......:;;4Q/

Спробуйте в Інтернеті!

Кодер: Спробуйте в Інтернеті!

Програма приблизно еквівалентна цьому коду Python: Спробуйте його в Інтернеті!

Розгорнутий код:

           3 6 2 0 0 3 5 1 1 5 5
          3 4 2 0 9 6 1 4 2 3 7 6
         6 2 6 1 4 2 6 2 5 2 5 3 9
        0 4 8 6 3 6 5 2 3 9 5 9 4 6
       8 2 6 0 9 9 9 9 4 4 5 4 9 8 2
      0 0 3 3 5 8 1 4 7 8 2 8 4 4 7 1
     4 1 5 8 0 9 6 7 7 0 9 1 0 0 6 3 8
    4 9 5 9 3 0 2 4 5 3 6 2 7 3 4 8 2 3
   5 7 9 0 1 9 4 6 9 9 3 0 6 1 7 9 . . .
  . / : { ; + ' = 1 P ' % ' a { : . . \ .
 . . . . . . . . . . . . . . . . . . . . \
  . . . . . . . . . . . . . . . . . . . \ 
   . . . . . . . . . . . . . . . . . . \  
    . . . . . . . . . . . . . . . . . \   
     . . . . . . . . . . . . . . . . \    
      . . . . . . . . . . . . . . . \     
       . . . . . . . . . . . . . . \      
        . . . . . . . . . . . . . \       
         ! $ > < . . . . . . . . \        
          . . @ > { ? 2 ' % < . .         
           . . . . : ; ; 4 Q / .

Два .s займає 1 біт. Будь-які інші символи мають 1 біт і основну цифру-97.

Пояснення

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

Частина даних

Замість складної структури, яка використовується в деяких інших відповідях (з <, "та в деяких інших речах), я просто пропускаю IP-адресу через нижню половину.

Дані

По-перше, IP-адреса працює через безліч номерів, без обмежень ( .) та дзеркал ( \). Кожна цифра додає число в пам'яті, тому в кінцевому підсумку значення пам'яті дорівнює числу на початку програми.

mem = 362003511...99306179

! друкує його,

stdout.write(str(mem))

і $стрибає через наступне >.

Починаючи з <. Якщо значення пам'яті memє хибним ( <= 0тобто умова mem > 0не виконується), ми зробили друк програми і повинні вийти. IP буде йти верхнім шляхом.

Вхід

(нехай IP працює по всьому світу близько 33 команд перед тим, як натиснути на @(що припиняє програму), оскільки розміщення його в будь-якому іншому місці має додаткові байти)

Якщо це правда, ми слідуємо нижньому шляху, переспрямовуємося кілька разів і виконуємо ще кілька команд, перш ніж натискати на інший умовний.

# Python                    # Hexagony
# go to memory cell (a)     # {
a = 2                       # ?2
# go to memory cell (b)     # '
b = mem % a                 # %

Тепер пам'ять виглядає так:

Mem1

Якщо значення truthy:

if b > 0:

виконується наступний код:

# Python                    # Hexagony
b = ord('Q')                # Q
b = b*10+4                  # 4
# Note: now b == ord('.')+256*3
stdout.write(chr(b%256))    # ;
stdout.write(chr(b%256))    # ;

Дивіться детальне пояснення відповіді Q4на HelloEnderWorld Hexagony MartinEnder . Коротше кажучи, цей код друкується .двічі.

Спочатку я планував це надрукувати .один раз. Коли я придумав це (надрукував .двічі) та здійснив його, було збережено близько 10 цифр.

Тоді,

b = mem // a                # :

Ось важливий факт, який я зрозумів, що врятувало мене близько 14 цифр: Вам не потрібно бути там, де ви почали.

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

Дано код

while a != 0:
    b, a = a * 2, 0
    a, b = b, 0
    print(a)

Якщо припустимо, що ми будемо aзначенням поточної комірки і bбути значенням правильної комірки, то прямим перекладом цього на BF є:

[             # while a != 0:
    [->++<]       # b, a = a * 2, 0
    >[-<+>]       # a, b = b, 0
    <.            # print(a)
]

Однак зауважте, що нам не потрібно постійно перебувати на одній позиції протягом програми. Ми можемо дозволити значенню aбути будь-яким, що ми є на початку кожної ітерації, тоді у нас є цей код:

[             # while a != 0:
    [->++<]       # b, a = a * 2, 0
                  # implicitly let (a) be at the position of (b) now
    .             # print(a)
]

що на кілька байт коротше.

Крім того, поведінка на кутовому обгортанні також рятує мене від \дзеркала там - без нього я не зміг би помістити цифри (+2 цифри для \себе та +2 цифри для непарного .праворуч від нього, не кажучи вже про прапори)

(подробиці:

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

)

Якщо значення (для операції mod 2 вище) є хибним (нульовим), то ми підемо цим шляхом:

# Python                 # Hexagony   # Memory visualization after execution
b = mem // a             # :          # click here
base = ord('a') # 97     # a
y = b % base             # '%
offset = 33              # P1
z = y + offset           # ='+
stdout.write(chr(z))     # ;          # click here
mem = b // base          # {:         # click here

Я не буду пояснювати тут занадто докладно, але зміщення насправді не зовсім 33, але відповідає 33модам 256. І chrмає неявне % 256.

— користувач202729
джерело
3
Людина, це дуже багато невдач
— Джо Кінг,
26
Я сміявся з "Щоб зрозуміти, про що я говорю, давайте мати [BrainFuck] аналогію". Тільки на PPCG ... :)
— Лінн
2
Я, як 3 рази, прокручував верх до відповіді, щоб підтвердити це, лише щоб дізнатися, що я це вже зробив ...
— NieDzejkob
2
310 байт , скориставшись новим простором для скорочення числа
— Джо Кінг,
2
308 байт , зайнявши ще більше місця
— Джо Кінг,
46

Vim, 11 байт

q"iq"qP<Esc>hqP
  • iq"qP<Esc>: Вручну вставити дублікат тексту, який повинен бути поза записом.
  • q"і hqP: Запишіть нутрощі безпосередньо в безіменний ""реєстр, щоб його можна було вставити посередині. hЄ єдиним репозиціонування потрібно; якщо помістити його всередину макросу, він буде вставлений в результат.

Редагувати

Примітка про запис за допомогою q": Безіменний реєстр ""- це смішна річ. Це насправді не справжній реєстр, як інші, оскільки текст там не зберігається. Це фактично вказівник на якийсь інший реєстр (як правило, "-для делетів без нового рядка, "0для yanks або "1для видалень з нового рядка). q"порушує правила; він насправді пише в "0. Якщо ваш ""уже вказував на якийсь інший реєстр "0, він q"буде перезаписаний, "0але залишиться ""без змін. Коли ви запускаєте свіжий Vim, ""автоматично вказує на "0, тож у цьому випадку ви все добре.

В основному, Вім дивний і баггі.

— udioica
джерело
зачекайте, чому це не працює для мене
— руйнуючий лимон
@DestructibleWatermelon Не можу сказати точно, але одне пояснення - це найімовірніше. Напевно, це повинно було бути раніше під час написання, оскільки це може скинути людей. Прочитайте правки.
— udioica
ви, напевно, повинні поставити щось про те, як натискання yчи щось перед запуском може допомогти
— Руйнуючий лимон
Чому ви не використовуєте ␛для показу клавіші <Esc>? Частина цього блоку Unicode "Control Pictures"
— mbomb007
4
@ mbomb007 <Esc>Позначення є стандартними для Vim :help <>mappings ( ), і саме для цього використовується vimgolf.com. Будь-який досвідчений вимгольфер буде використаний для його читання. Що стосується унікоду, я повинен коситись, щоб прочитати маленькі букви, і вони затьмарюють метод набору тексту та пошуку файлу довідки.
— udioica
44

Cubix , 20 байт

3434Qu$v@!<"OOw\o;/"

Майже отримав \o/ ...

Чистий :

    3 4
    3 4
Q u $ v @ ! < "
O O w \ o ; / "
    . .
    . .

Спробуйте в Інтернеті

Спробуйте тут !

Додаткові нотатки

Довідкова історія

Після враження, прочитавши цю чудову відповідь від @ ais523, я почав думати про подальше поводження з королевою. Зрештою, там було досить багато невдач, і це не було дуже стисло. Однак, оскільки методика його відповіді (і моя також) вимагає, щоб код охоплював цілі рядки, потрібно було економити щонайменше 12 байт. В його поясненні було одне зауваження, яке насправді змусило мене задуматися:

Що стосується гольфу внизу цієї квочки, [...] знадобиться [...] ще якийсь спосіб зобразити верхню частину куба [...]

Потім раптом, коли я встав і пішов подати щось випити, мене вразило: Що робити, якщо програма не використовує символьні коди, а цифри, щоб зобразити верхню частину обличчя? Це особливо коротко, якщо число, яке ми друкуємо, має 2 цифри. Cubix має 3 інструкції один байт для штовхання двозначних чисел: N, Sі Q, які штовхають 10, 32і , 34відповідно, так що це повинно бути досить golfy, подумав я.

Перше ускладнення цієї ідеї полягає в тому, що верхнє обличчя зараз заповнене марними цифрами, тому ми більше не можемо цим користуватися. Друге ускладнення полягає в тому, що верхня грань має розмір куба розміром у квадраті, і він повинен мати рівний розмір, інакше одне число також опиниться у вихідному положенні покажчика інструкції, що призведе до забрудненого стека. Через ці ускладнення мій код потребував розміщення на кубі розміром 2 (який може містити "лише" 24 байти, тож мені довелося гольфувати щонайменше 21 байт). Крім того, оскільки верхня та нижня грані непридатні, у мене було лише 16 ефективних байтів.

Тому я почав з вибору числа, яке стане половиною верхньої частини обличчя. Я почав з N(10), але це не зовсім вийшло через підхід, який я взяв до друку. У будь-якому випадку я почав заново і Sчомусь використовував (32). Це призвело до належної лайки, або я так подумав. Це все спрацювало дуже добре, але цитати не вистачало. Тоді мені сталося, що Q(34) буде справді корисним. Зрештою, 34 - це символьний код подвійної лапки, який дозволяє нам зберігати його у стеці, зберігаючи (2, у макеті, який я використовував тоді) дорогоцінні байти. Після того, як я трохи змінив IP-маршрут, все, що залишилося, - це вправа заповнити пробіли.

Як це працює

Код можна розділити на 5 частин. Я переходжу їх по черзі. Зауважте, що ми кодуємо середні грані в зворотному порядку, оскільки модель стека "перше-в-останнє".

Крок 1: Друк верхньої частини обличчя

Невідповідні інструкції були замінені no-ops ( .). IP починає третій рядок, ліворуч, вказуючи на схід. Стек (очевидно) порожній.

    . .
    . .
Q u . . . . . .
O O . . . . . .
    . .
    . .

IP закінчується в крайньому лівому положенні на четвертому рядку, вказуючи на захід, ось-ось обернеться до крайнього правого положення на тій же лінії. Виконуються інструкції (без символу потоку управління):

QOO
Q   # Push 34 (double quotes) to the stack
 OO # Output twice as number (the top face)

Стек містить всього 34, що представляє собою останній символ джерела.

Крок 2: Кодуйте четвертий рядок

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

Фактично, IP перемістив одну позицію вліво, і стек тепер містить представлення четвертого рядка в кодах символів і зворотному порядку.

Крок 3: Наведіть ще одну цитату

Нам потрібно просунути ще одну цитату, і який кращий спосіб, ніж переробляти програму Qна початку програми, підходячи до неї справа? Це має додатковий бонус, який IP безпосередньо впадає в цитату, що кодує третій рядок.

Ось чиста версія для цього кроку. Іррелевантні втручання знову були замінені no-ops, виконувані no-ops були замінені хештегами ( #) для ілюстрації, і IP починається з останнього символу в четвертому рядку.

    . .
    . .
Q u $ . . . . .
. . w \ . . / .
    . #
    . #

В першій інструкції IP закінчується на третьому рядку, який збирається завершити до кінця цієї лінії, оскільки він спрямований на захід. Викладені наступні інструкції (за винятком контрольного потоку):

$uQ
$u  # Don't do anthing
  Q # Push the double quote

Ця подвійна цитата являє собою кінець третього рядка.

Крок 4: Кодування третього рядка

Це працює точно так само, як крок 2, тому, будь ласка, знайдіть пояснення.

Крок 5: Роздрукуйте стек

Стек тепер містить четвертий та третій рядки, у зворотному порядку, тому все, що нам потрібно зробити зараз, це надрукувати. ІС починається з передостанньої інструкції на третьому рядку, рухаючись на захід. Ось відповідна частина куба (знову ж таки, невідповідні частини були замінені без опіків).

    . .
    . .
. . . v @ ! < .
. . . \ o ; / .
    . .
    . .

Це цикл, як ви, можливо, бачили / очікували. Основний корпус:

o;
o  # Print top of stack as character
 ; # Delete top of stack

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

— Лука
джерело
хотілося б, щоб я міг підтримати це більше
— MickyT
Баунті завжди вітаються ;-)
— Лука
42

Javascript ES6 - 21 байт

$=_=>`$=${$};$()`;$()

Я називаю цю королеву «Блінг-Квін».

Іноді, ти повинен гольф у стилі.

— Mama Fun Roll
джерело
Чи !$=_=>`!$=${$}()`()економить вас 2 байти?
— Пуховик
Invalid assignment left hand side. Бажаю, щоб це спрацювало :(
— Mama Fun Roll
1
@ TùxCräftîñg усунення дужок навколо літералів шаблону працює лише на нативних функціях прототипу, наприклад Array.prototype.join.
— Mama Fun Roll
2
Хм, не впевнений. Я писав це більше року тому (тоді він вважався дійсним), і я не слідкував за змінами правила квітні занадто близько. Однак додавання alertабо console.logпісля функції стрілки та загортання рядка шаблону в дужки буде працювати.
— Mama Fun Roll
3
Також якщо ви запускаєте це в конколе, він замінює $ (jQuery функцію) на цьому сайті, і функція оновлення більше не працюватиме. :)
— Стівен Палінкас
41

Brainf * ck (755 символів)

Це засновано на техніці, розробленій Еріком Босманом (ejbosman at cs.vu.nl). Зауважте, що "Королева ESultanik!" текст насправді необхідний для того, щоб він був королевою!

->++>+++>+>+>++>>+>+>+++>>+>+>++>+++>+++>+>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>+>+>++>>>+++>>>>>+++>+>>>>>>>>>>>>>>>>>>>>>>+++>>>>>>>++>+++>+++>+>>+++>>>+++>+>+++>+>++>+++>>>+>+>+>+>++>+++>+>+>>+++>>>>>>>+>+>>>+>+>++>+++>+++>+>>+++>+++>+>+++>+>++>+++>++>>+>+>++>+++>+>+>>+++>>>+++>+>>>++>+++>+++>+>>+++>>>+++>+>+++>+>>+++>>+++>>>+++++++++++++++>+++++++++++++>++++++>+++++++++++++++>++++++++++>+++>+++>++++>++++++++++++++>+++>++++++++++>++++>++++++>++>+++++>+++++++++++++++>++++++++>++++>++++++++++++>+++++++++++++++>>++++>++++++++++++++>+++>+++>++++>++++++>+++>+++++++++>++++>+>++++>++++++++++>++++>++++++++>++>++++++++++>+>+++++++++++++++>+++++++++++++
ESultanik's Quine!
+[[>>+[>]+>+[<]<-]>>[>]<+<+++[<]<<+]>>+[>]+++[++++++++++>++[-<++++++++++++++++>]<.<-<]
— ESultanik
джерело
13
Це розумний спосіб зробити це.
— Пітер Олсон
13
Як це працює?
— гордий haskeller
3
@proudhaskeller IIRC, частина перед цим ESultanik's Quine!налаштовує пам'ять як кодування стека ESultanik's Quine!і далі, з двома байтами пам'яті для кожного символу (значення ASCII зміщено від 0x1F). Заключний біт коду проходить через пам'ять, спочатку програмно відтворюючи ++>+++…коди для кожного символу, а потім фактично друкуючи символи.
— ESultanik
4
@CatsAreFluffy Вони вимагають, щоб це була королева! Хоча це правда, що їх можна було б видалити, також потрібно було б змінити попередній код, щоб підтримувати властивість quine.
— ESultanik
1
Це правда. Також необхідні нові рядки.
— CalculatorFeline
36

Шестикутник , довжина сторони 15 14 13 12, 616 533 456 383 байт

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

1845711724004994017660745324800783542810548755533855003470320302321248615173041097895645488030498537186418612923408209003405383437728326777573965676397524751468186829816614632962096935858"">./<$;-<.....>,.........==.........<"......."">'....>+'\.>.........==........<"......"">:>)<$=<..>..............$..<"...."">\'Q4;="/@>...............<"....."">P='%<.>.............<"..!'<.\=6,'/>

Спробуйте в Інтернеті!

Розгорнуто:

            1 8 4 5 7 1 1 7 2 4 0 0
           4 9 9 4 0 1 7 6 6 0 7 4 5
          3 2 4 8 0 0 7 8 3 5 4 2 8 1
         0 5 4 8 7 5 5 5 3 3 8 5 5 0 0
        3 4 7 0 3 2 0 3 0 2 3 2 1 2 4 8
       6 1 5 1 7 3 0 4 1 0 9 7 8 9 5 6 4
      5 4 8 8 0 3 0 4 9 8 5 3 7 1 8 6 4 1
     8 6 1 2 9 2 3 4 0 8 2 0 9 0 0 3 4 0 5
    3 8 3 4 3 7 7 2 8 3 2 6 7 7 7 5 7 3 9 6
   5 6 7 6 3 9 7 5 2 4 7 5 1 4 6 8 1 8 6 8 2
  9 8 1 6 6 1 4 6 3 2 9 6 2 0 9 6 9 3 5 8 5 8
 " " > . / < $ ; - < . . . . . > , . . . . . .
  . . . = = . . . . . . . . . < " . . . . . .
   . " " > ' . . . . > + ' \ . > . . . . . .
    . . . = = . . . . . . . . < " . . . . .
     . " " > : > ) < $ = < . . > . . . . .
      . . . . . . . . . $ . . < " . . . .
       " " > \ ' Q 4 ; = " / @ > . . . .
        . . . . . . . . . . . < " . . .
         . . " " > P = ' % < . > . . .
          . . . . . . . . . . < " . .
           ! ' < . \ = 6 , ' / > . .
            . . . . . . . . . . . .

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

Пояснення

Це перемагає попередню відповідь Гексагонії , кодуючи no-ops ( .) по-іншому. Хоча ця відповідь економить простір, роблячи кожен інший символ a ., мій кодує кількість відсутніх значень. Це також означає, що джерело не повинно бути таким обмеженим.

Тут я використовую базове кодування 80, де цифри нижче 16 вказують на пробіги, а цифри між 16 і 79 представляють діапазон від 32 ( !) до 95 ( _) (я тільки зараз розумію, що я переграв усе _з мого код лол). Кілька пітонічних псевдокодів:

i = absurdly long number
print(i)
base = 80
n = i%base
while n:
    if n < 16:
        print("."*(16-n))
    else:
        print(ASCII(n+16))
    i = i//base
    n = i%base

Цифра зашифрована в першій половині шестикутника з усіма знаками 

" " > 
 " " > 
  ... etc

з лівого боку та

 > ,
< "
 >
< "
... etc

праворуч перенаправляючи вказівник для кодування числа в одну комірку. Це взято з відповіді Мартіна Ендера (спасибі), оскільки я не міг знайти більш ефективний спосіб.

Потім він переходить у нижній розділ через ->:

       " " > \ ' Q 4 ; = " / @ > . . . .
        . . . . . . . . . . . < " . . .
         . . " " > P = ' % < . > . . .
          . . . . . . . . . . < " . .
     ->    ! ' < . \ = 6 , ' / > . .

!друкує число та 'переходить до правої комірки пам'яті перед запуском циклу. P='%модифікує поточне число на 80. Якщо результат 0, перейдіть до завершення @, інакше спустіться вниз і створіть комірку поруч з результатом моди зі значенням -16.

   . " " > ' . . . . > + ' \ . > . . . . . .
    . . . = = . . . . . . . . < " . . . . .
     . " " > : > ) < $ = < . . > . . . . .
      . . . . . . . . . $ . . < " . . . .
       " " > \ ' Q 4 ; = " / @ > . . . .
                      /
                     /

Встановіть комірку на (значення мода + -16). Якщо це значення негативне, перейдіть на розгалуження >+'\, інакше спустіться вниз.

Якщо значення додатне:

 " " > . / < $ ; - < . . . . . > , . . . . . .
  . . . = = . . . . . . . . . < " . . . . . .
   . " " > ' . . . . > + ' \ . > . . . . . .

Вказівник закінчується на тому, ;-<що встановлює клітинку (значення моди - -16) і друкує її.

Значення від’ємне:

   . " " > ' . . . . > + ' \ . > . . . . . .
    . . . = = . . . . . . . . < " . . . . .
     . " " > : > ) < $ = < . . > . . . . .

Перейдіть до > ) <розділу, в якому починається цикл. Тут він відокремлений:

     . . > ) < $ = < . .
      . . . . . . . . .
       \ ' Q 4 ; = " /

Котрий виконує код, 'Q4;="=який друкує .(ще раз спасибі Мартіну Ендеру, який написав програму для пошуку комбінацій букв-цифр для символів) і повертається назад до початкової комірки. Потім він збільшує ( )) модульну клітинку значення та знову циклізує, поки значення мода не буде позитивним.

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

 " " > . / < $ ; - < . . .
            \
             \

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

 " " > . / <--
  . . . = =
   . " " > ' 
    . . . = = 
     . " " > :
      . . . . .
       " " > \ ' . .
        . . . . . . .
         . . " " > P = ' % < . > . . .

Це виконує, ='=:'який ділить поточне число на 80 і переходить до потрібної комірки.

Стара версія (довжина сторони 13)

343492224739614249922260393321622160373961419962223434213460086222642247615159528192623434203460066247203920342162343419346017616112622045226041621962343418346002622192616220391962343417346001406218603959366061583947623434"">/':=<$;'<.....>(......................<"......"">....'...>=\..>.....................<"....."">....>)<.-...>...........==......<"...."">.."...'.../>.................<"..."">\Q4;3=/.@.>...............<".."".>c)='%<..>..!'<.\1*='/.\""

Спробуйте в Інтернеті!

Я, безумовно, можу гольф іншої довжини сторони від цього, але мені доведеться залишити його до завтра, тому що стає пізно. Виявляється, я нетерплячий і не можу дочекатися завтра. Можливо, ще одна сторона може бути в гольф? :( ahhhhhhhhh я це зробив!

Я навіть гольфував кілька додаткових цифр з базовим кодуванням 77, але це не має особливого значення, оскільки він має той самий рахунок.

— Джо Кінг
джерело
13
Це дивно. Ідея цього кодування гібридної довжини ходу справді акуратна. :) Нагадуй, щоб я тобі нагородив, якщо я забуду.
— Мартін Ендер
35

PostScript, 20 символів

Короткий і законний. 20 символів, включаючи прокладку нового рядка.

(dup == =)
dup == =
— KirarinSnow
джерело
33

Cubix , 45 байт

.....>...R$R....W..^".<R.!'.\)!'"R@>>o;?/o'u"

Ви можете протестувати цей код тут .

За цією програмою досить важко дотримуватися, але щоб мати шанс на це, нам потрібно почати, розклавши її на куб, як це робить перекладач Cubix:

      . . .
      . . >
      . . .
R $ R . . . . W . . ^ "
. < R . ! ' . \ ) ! ' "
R @ > > o ; ? / o ' u "
      . . .
      . . .
      . . .

Це квітка стилю Befunge, яка працює за допомогою обгортки, щоб змусити рядкові літерали "обернути" виконуваний код (лише з однією "позначкою код одночасно є і всередині, і поза цитатою, що стає можливим, коли у вас є програми, які є нелінійними та непланарними). Зауважимо, що це відповідає нашому визначенню належної квінки, оскільки дві подвійні лапки не кодують себе, а обчислюються пізніше за допомогою арифметики.

На відміну від Befunge, ми тут використовуємо чотири рядки, а не одну. Ось як їх натискають на стек;

  1. Програма починається у верхній частині лівого краю, йде вправо; вона повертається праворуч двічі ( R), змушуючи йти ліворуч уздовж третьої та останньої ліній, які обертаються навколо всього куба. Подвійна цитата відповідає самій собі, тому ми просуваємо весь третій рядок на стек назад. Потім виконання продовжується після подвійної цитати.

  2. uКоманда виконує розворот вправо, так що наступна річ , яку ми біжимо від '"року на середній лінії. Це натискає "на стек. Продовжуючи обгортати, ми вдаряємося по <лівій стороні куба і відскакуємо назад. Підходячи з цього напрямку, ми бачимо просту "команду, ні '", тому весь другий рядок висувається на стек назад над третім рядком і подвійний лапок.

  3. Почнемо, натискаючи !на стек ( '!) і збільшуючи його ( )); це створює подвійну цитату, не потребуючи подвійної цитати у нашому вихідному коді (що б припиняло рядок). Дзеркало ( \) відображає напрямок виконання вгору на північ; потім Wкоманда бічить вліво. Це дозволяє нам піднятися вгору на сьомий стовпчик, який, оскільки це куб, загортається вліво на третьому ряду, потім вниз на третьому стовпчику. Ми вдарили R, щоб повернути праворуч і піти ліворуч уздовж верхнього ряду; потім $пропускає програму, Rчерез яку ми вступили в програму, тому виконання завертаємо до "кінця рядка, і ми фіксуємо перший рядок у рядку так само, як і для другого та третього.

  4. ^Команда посилає нас на півночі до одинадцятої колонки, яка ( з урахуванням куба упаковки) в південному напрямку на п'ятому. Єдине, з чим ми стикаємось, це !(пропустити, якщо нульове; верхня частина стека справді не нульова), яка пропускає oкоманду, фактично роблячи п’яту колонку абсолютно порожньою. Таким чином, ми повертаємося до uкоманди, яка знову повертається на поворот, але цього разу ми залишаємося на остаточній колонці на південь, яка завертається до четвертої колони на північ. Однак ми потрапили в подвійну лапочку під час повороту, тому ми захоплюємо весь четвертий стовпець у рядку, знизу вгору. На відміну від більшості подвійних лапок у програмі, ця не закриває себе; скоріше, він закритий значком "у верхньому правому куті, це означає, що ми захоплюємо рядок дев'яти символів ...>......

Отже, макет стека зараз, зверху вниз: четвертий стовпець; верхній ряд; "; середній ряд; "; нижній ряд. Кожен з них представлений на стеку з першим символом, що знаходиться найближче до вершини стека (Cubix висуває рядки в зворотному порядку цього порядку, як це робить Befunge, але кожен раз, коли IP рухався у зворотному напрямку до природного напрямку читання, тому воно фактично переверталося двічі). Можна зауважити, що вміст стеку майже ідентичний вихідній програмі (адже четвертий стовпець та північна / верхня грань куба містять ті самі символи в тому ж порядку; очевидно, це було спроектовано таким чином навмисно).

Наступним кроком є ​​надрукування вмісту стека. Після всіх натискань IP йде на північ на четвертому стовпчику, тому він потрапляє >туди і вступає в тугий цикл >>o;?(тобто "поверніть на схід, поверніть на схід, виведіть як характер, поп, поверніть праворуч, якщо позитивне"). Оскільки сьомий рядок заповнений NOP-адресами, то ?він збирається повернутись до першого >, тому це ефективно виштовхує весь вміст стеку ( ?є неоперативним на порожній стек). Ми майже надрукували всю програму! На жаль, це ще не зовсім зроблено; ми пропускаємо подвійну цитату наприкінці.

Як тільки петля закінчується, ми відбиваємося до центральної лінії, рухаючись на захід, через пару дзеркал. (Раніше ми використовували "іншу сторону" \дзеркала; тепер ми використовуємо південно-західну сторону. /Дзеркало раніше не використовувалося.) Ми стикаємось '!, тому натискаємо знак оклику (тобто 33; ми використовуємо ASCII а Cubix не розрізняє цілі числа та символи) на стеку. (Зручно, це те саме, !що було використано для пропуску oкоманд раніше.) Ми зустрічаємо пару Rкоманд і використовуємо їх для створення "ручного" повороту (друга Rкоманда тут була використана раніше для досягнення першого рядок, тому здавалося, що найбільш природно розмістити Rпоруч іншу команду.Wкоманда, щоб пройти вліво зліва. Боковий крок врізається прямо в >команду другого рядка, відскакуючи виконання туди, куди воно було. Отже, ми знову проходимо вліво, але на цей раз ми йдемо на південь, тому наступною командою для виконання є )(приріст знака оклику до подвійної лапки), за якою слід o(для виведення його). Нарешті, виконання завершується по восьмому рядку до другого стовпця, де він знаходить a @для виходу з програми.

Прошу вибачення за бродячий апостроф на третьому рядку. У цій версії програми він нічого не робить; це було частиною попередньої ідеї, яку я мав, але яка виявилася не потрібною. Однак, як тільки я отримав робочу квинку, я просто хотів подати її, а не возитися з нею далі, тим більше, що видалення її не змінить кількість байтів. Щодо подальшого гольфу внизу цією королевою, мене не здивувало, якби це було можливо на 3 × 3 лише за допомогою перших п'яти рядків, але я не бачу очевидного способу зробити це, і це знадобиться ще жорсткіша упаковка всього контрольного потоку разом з яким-небудь іншим способом представити верхню грань куба (або ще модифікувати алгоритм, щоб він міг продовжувати використовувати четвертий стовпець, навіть якщо в ньому зараз буде десять-одинадцять символів) .

Приємна робота, це дійсно вражаючий бал. Мені подобається, як ти закодував верхнє обличчя. :)
— Мартін Ендер
Це просто неймовірно! Якщо це допоможе будь-яким, інший спосіб просунути "це Q.
— ETHproductions
1
Оце Так! Я ніколи не хотів би бачити кубічну квітку!
— FlipTack
3
Учора я не встиг прочитати пояснення, але тепер, коли я маю ... Просто ... WOW. Я не можу повірити, скільки символів використовується для двох, а то й трьох абсолютно різних цілей. Це, мабуть, найкрутіша програма Cubix, яку я коли-небудь бачив.
— ETHproductions
Гарне пояснення.
— Роберт Фрейзер
33

Python 2, 30 байт

_='_=%r;print _%%_';print _%_

Взято звідси

— гальвабо
джерело
1
+1, ти побив моє подібне рішення, тому я його видалив. Слід зазначити, що це працює лише в Python 2.
— nyuszika7h
2
Це дивно виглядає з назвою змінної як _, але читається краще, якщо призначити її будь-якій букві, тобто s:s='s=%r;print s%%s';print s%s
— Ehtesh Choudhury
5
Якщо це рішення не є вашим власним твором, вам слід зробити його Community Wiki. Також посилання мертва.
— mbomb007
1
Я трохи запізнююся на вечірку, але чи може хтось пояснити, як це працює?
— MadTux
9
Для цього потрібна остаточна передача рядків, щоб бути дійсною. Як і є, вихідний код не відповідає виводу.
— Денніс
32

Вім, 17 , 14 натискань клавіш

Хтось випадково відмовився від цього, тому я згадав, що воно існує. Коли я перечитав це, я подумав "Ей, я можу зробити краще!", Тому я відіграв два байти. Це все ще не найкоротше, але принаймні це покращення.

Тривалий час я цікавився, чи можлива vim quine. З одного боку, це має бути можливим, оскільки vim закінчується. Але, шукаючи вім-квине дуже довго, я не зміг його знайти. Я ж знайти цю PPCG проблему , але вона закрита і не зовсім про буквальних quines. Тому я вирішив зробити його, оскільки не зміг його знайти.

Я дуже пишаюся цією відповіддю через два перші :

  1. Це перша квітина, яку я коли-небудь робив, і

  2. Наскільки я знаю, це перша в світі vim-quine, яка коли-небудь була опублікована! Я можу помилитися з цього приводу, тому, якщо ви знаєте про це, будь ласка, повідомте мене про це.

Отже, після цього довгого вступу ось:

qqX"qpAq@q<esc>q@q

Спробуйте в Інтернеті!

Зауважте, що коли ви введете це повідомлення, воно відобразить <esc>натискання клавіші як ^[. Це все ще точно, оскільки ^[представляє 0x1B, що є бігом в ASCII , і спосіб vim внутрішньо представляє <esc>ключ.

Також зауважте, що тестування цього може бути невдалим, якщо ви завантажуєте існуючий сеанс vim. Я написав поради відповідь , пояснюючи , що тут , якщо ви хочете отримати більше інформації, але в основному вам потрібно запустити Vim з

vim -u NONE -N -i NONE

або введіть, qqqперш ніж це запустити.

Пояснення:

qq                  " Start recording into register 'q'
  X                 " Delete one character before the cursor (Once we play this back, it will delete the '@')
   "qp              " Paste register 'q'
      Aq@q<esc>     " Append 'q@q' to this line
               q    " Stop recording
                @q  " Playback register 'q'

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

— DJMcMayhem
джерело
1
2i2i<esc>так близько. Я відчуваю, що треба щось зробити, щоб зробити цю роботу.
— Zwei
@zwei Я знаю, це близько, боляче! Власне, <Esc>мається на увазі в V, так що це працює . На жаль, він також додає новий рядок, тому я ще не розмістив його.
— DJMcMayhem
q"iq"qbP<Esc>qbPє 11. Після того, як ви поставили це на reddit , я дослідив тут vimgolfing і вирішив зареєструватися. Це відповідь, яку я розмістив там.
— udioica
2
@udioica Чи можете ви надіслати це як відповідь?
— DJMcMayhem
28

Втрачено , 120 116 98 96 76 70 66 байт

Редагувати: так, до 100

Редагувати: Збережено купу байтів, перейшовши на всі /s в нижньому рядку

:2+52*95*2+>::1?:[:[[[[@^%?>([ "
////////////////////////////////

Спробуйте в Інтернеті! + перевірка детермінована для всіх можливих станів

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

Пояснення:

Усі /s в нижній лінії знаходяться там, щоб переконатися, що всі вказівники, які нерестуються у вертикальному напрямку або в нижній лінії, виходять у потрібне русло. Звідти вони опиняються в декількох різних місцях, але всі вони потрапляють прямо у

 ^%?>
 ////

Яке очищає всі ненульові числа в стеку. ([Після цього очищає будь-які додаткові 0s , а також.

В середині ясного поля він потрапляє на значення %, що вимикає "безпеку", що дозволяє програмі закінчуватися, коли вона потрапляє @(без цього програма могла б закінчитися негайно, якби вказівник запустився на @).

Звідси він робить досить простий двовимірний мовний quine, обертаючи рядковий літерал ( ") навколо першого рядка, висуваючи "символ, копіюючи пробіл ( :2+), а потім новий рядок ( 52*). Для другого рядка він створює /символ ( 95*2+) і дублює його з’єднанням ( >::1?:[:[[[[), перш ніж остаточно закінчується на @і друкує стек неявно. Потрібно ?1зупинити процес створення занадто багато 0, якщо вказівник вводиться рано, економивши на тому, щоб очистити їх пізніше.

Тут я зберег 20 байтів, зробивши останній рядок все тим же символом, тобто я міг перейти безпосередньо від процесу копіювання до кінця @.

Пояснення щодо процесу копіювання:

[- персонаж, відомий як «Двері». Якщо вказівник потрапляє на плоску сторону a [або a ], він відображається, інакше він проходить через неї. Кожен раз, коли вказівник взаємодіє з Двері, він переходить на протилежний тип. Використовуючи ці знання, ми можемо побудувати просту формулу, скільки разів буде виконуватися інструкція в >:[блоці.

Додайте початкову кількість інструкцій. До кожного [додайте ліворуч від нього кількість інструкцій. Для прикладу >::::[:[[[ми починаємо з 5 як початкової суми. Перша дверцята має 4 вказівки про дуп, тому ми додаємо 4 * 2 = 8 до 5, щоб отримати 13. Інші три Двері мають 5 дубів зліва, тому ми додаємо 3 * (5 * 2) = 30 до 13, щоб отримати 43 інструкції з дупу виконані і мають 44 >с на стеку. Цей же процес може бути застосований і до інших інструкцій, наприклад, (для виштовхування великої кількості елементів із стека в область застосування, або як використовується тут, для очищення елементів із стека.

Тут я використав трюк, щоб уникнути дублювання занадто багатьох 0 1?. Якщо символ дорівнює 0, ?не пропускає 1, а це означає, що він копіює 1 на залишок дупи. Це значно спрощує очищення стека згодом.

— Джо Кінг
джерело
25

Це дві найкоротші лайки Ruby від SO :

_="_=%p;puts _%%_";puts _%_

і

puts <<2*2,2
puts <<2*2,2
2

Не питайте мене, як працює друга ...

— Накілон
джерело
8
Другий використовує heredoc, <<2починає рядок у наступному рядку та *2повторює рядок
— Ming-Tang,
Для чого вам потрібні 2?
— CalculatorFeline
1
@CalculatorFeline Це термінатор рядка heredoc (який повинен з'являтися у власному рядку). Насправді це не має бути 2, хоча: tio.run/##KypNqvz/v6C0pFjBxsZAy0jHgAuFY8D1/z8A
— Мартін Ендер
25

Ділення , 6 байт

Здається, це зараз найкоротша «належна» лайка серед цих відповідей. 

'!+OR"

Пояснення

Контрольний потік починається Rз одного правого (1,0)атома. Він натискає "перемикання режиму друку, а потім обертається навколо рядка, друкуючи '!+ORперед тим, як "знову натиснути на той самий і вийти з режиму друку.

Це залишає "себе для друку. Найкоротший шлях - це '"O(коли '"встановлює масу атома код символу "та Oдрукує символ і знищує атом), але якби ми це зробили, це "заважало б режиму друку. Отже, замість цього ми встановлюємо значення атома на '!(на менше менше "), потім збільшуємо +і потім друкуємо результат за допомогою O.

Альтернативи

Ось пара альтернатив, які довші, але, можливо, їхні методи надихнуть когось знайти більш коротку версію, використовуючи їх (а може, вони будуть кориснішими у певних узагальнених лайках).

8 байт за допомогою Jump

' |R@JO"

Знову код починається з R. @Свопи маси і енергії , щоб дати (0,1). Тому Jзмушує атом перестрибувати Oпрямо на ". Тоді, як і раніше, всі, крім " "друкуються" в рядковому режимі. Після цього атом вдаряється, |щоб змінити свій напрямок, а потім проходить через '"Oдрук ". Простір трохи дратує, але це здається необхідним, бо в іншому випадку 'атом може ставитись до |символу замість дзеркала.

8 байт з використанням двох атомів

"'L;R@JO

У нього є два атоми, починаючи з лівого, Lа з правого - від R. Лівий атом отримує встановлене значення, за допомогою '"якого потім негайно друкується O(і атом знищується). Для правильного атома ми знову поміняємо масу та енергію, переходимо через, Oщоб надрукувати решту коду в режимі друку. Після цього його значення встановлюється значком, 'Lале це не має значення, тому що атом відкидається ;.

— Мартін Ендер
джерело
Технічно недійсні через відсутність поділу коду / даних у джерелі.
— CalculatorFeline
4
@CalculatorFeline '!+кодує ".
— Мартін Ендер
Я не знайомий з Fission, але |R@JO"'працював би , чи тобі все ще знадобиться цей простір після '?
— MildlyMilquetoast
1
@MistahFiggins Я думаю, що так, але важливіше, щоб ви надрукували 'перший.
— Мартін Ендер
24

Перехресний браузер JavaScript (41 символ)

Він працює в топ-5 веб-браузерах (IE> = 8, Mozilla Firefox, Google Chrome, Safari, Opera). Введіть його в консоль розробника в будь-якому з них:

eval(I="'eval(I='+JSON.stringify(I)+')'")

Це не "обман" - на відміну від однобайтової родини Кріса Єстер-Янга, оскільки його можна було легко змінити для використання alert()функції (вартістю 14 символів):

alert(eval(I="'alert(eval(I='+JSON.stringify(I)+'))'"))

Або перетворено на закладку (вартістю 22 символи):

javascript:eval(I="'javascript:eval(I='+JSON.stringify(I)+')'")
— Будь ласка
джерело
24

C, 64 60 байт

main(s){printf(s="main(s){printf(s=%c%s%1$c,34,s);}",34,s);}

Поки що це найкоротший відомий C quine. Там в розширеній Баунті , якщо ви знайдете більш короткий.

Це працює в GCC , Clang і TCC в POSIX середовищі. Це викликає надмірну кількість невизначеної поведінки з усіма ними.

Для задоволення, ось репо, яке містить усі C-лайки, про які я знаю. Не соромтеся роздвоюватися / PR, якщо ви знайдете або напишіть інший, який додасть щось нове та креативне над існуючим.

Зауважте, що він працює лише в середовищі ASCII . Це працює для EBCDIC , але все ж вимагає POSIX . Успіхів у пошуку середовища POSIX / EBCDIC все одно: P

Як це працює:

  1. main(s)зловживає mainаргументами, оголошуючи практично нетипізовану змінну s. (Зауважте, що sнасправді не типізовано, але оскільки перераховані компілятори автоматично передають його за необхідності, це може бути *.)
  2. printf(s="..."встановлює sподаний рядок і передає перший аргумент до printf.
  3. sвстановлено на main(s){printf(s=%c%s%1$c,34,s);}.
  4. %cВстановлено в ASCII 34, ". Це робить quine можливою. Тепер sвиглядає наступним чином :
    main(s){printf(s="%s%1$c,34,s);}.
  5. Це %sвстановлено для sсебе, що можливо завдяки №2. Тепер sвиглядає наступним чином :
    main(s){printf(s="main(s){printf(s=%c%s%1$c,34,s);}%1$c,34,s);}.
  6. Встановлено %1$cзначення ASCII 34 ", printfперший ** аргумент. Тепер sвиглядає так:
    main(s){printf(s="main(s){printf(s=%c%s%1$c,34,s);}",34,s);}
    ... що саме так буває оригінальним вихідним кодом.

* Приклад завдяки першому аргументу після специфікатора формату @Pavel
** - у цьому випадку s. Посилання на специфікатор формату неможливо.

Я думаю, що неможливо, що з тим самим підходом це стане коротшим. Якщо printfспецифікатор формату був доступний через $, це працювало б на 52 байти:

main(){printf("main(){printf(%c%0$s%1$c,34);}",34);}
— MD XF
джерело
Хоча це, звичайно, не слід вважати змагальним, переможець "Найгіршого зловживання правилами" з Міжнародного конкурсу закоханих кодів 1994 р. 1994_smr.c , безумовно, коротший.
— Рей
@Ray Це заборонено. Це не належна квітка за будь-яким визначенням. Правила quien були змінені через цю програму: P
— MD XF
Я погоджуюся повністю, але це досить цікавий хак, що варто згадати, коли хтось згадає про найменшу відому царину, хоч би лише з історичних причин.
— Рей
4
sмає тип int, а не "типізовану змінну".
— feersum
2
Ці компілятори, мабуть, дозволяють неявну конверсію вказівника до int. s=3очевидно, не буде працювати, тому що вам потрібно передати рядок двічі printf.
— feersum
24

Java, 528 байт:

Рішення Java з оригінальним підходом:

import java.math.*;class a{public static void main(String[]a){BigInteger b=new BigInteger("90ygts9hiey66o0uh2kqadro71r14x0ucr5v33k1pe27jqk7mywnd5m54uypfrnt6r8aks1g5e080mua80mgw3bybkp904cxfcf4whcz9ckkecz8kr3huuui5gbr27vpsw9vc0m36tadcg7uxsl8p9hfnphqgksttq1wlolm2c3he9fdd25v0gsqfcx9vl4002dil6a00bh7kqn0301cvq3ghdu7fhwf231r43aes2a6018svioyy0lz1gpm3ma5yrspbh2j85dhwdn5sem4d9nyswvx4wmx25ulwnd3drwatvbn6a4jb000gbh8e2lshp",36);int i=0;for(byte c:b.toByteArray()){if(++i==92)System.out.print(b.toString(36));System.out.print((char)c);}}}

у читаному вигляді:

import java.math.*;
class a
{
    public static void main (String [] a)
    {
        BigInteger b=new BigInteger ("90ygts9hiey66o0uh2kqadro71r14x0ucr5v33k1pe27jqk7mywnd5m54uypfrnt6r8aks1g5e080mua80mgw3bybkp904cxfcf4whcz9ckkecz8kr3huuui5gbr27vpsw9vc0m36tadcg7uxsl8p9hfnphqgksttq1wlolm2c3he9fdd25v0gsqfcx9vl4002dil6a00bh7kqn0301cvq3ghdu7fhwf231r43aes2a6018svioyy0lz1gpm3ma5yrspbh2j85dhwdn5sem4d9nyswvx4wmx25ulwnd3drwatvbn6a4jb000gbh8e2lshp", 36); 
        int i=0; 
        for (byte c:b.toByteArray ())
        {
            if (++i==92) 
                System.out.print (b.toString (36)); 
            System.out.print ((char) c);
        }
    }
}
— користувач невідомий
джерело
Як це працює?
— Loovjo
1
@Loovjo: Подібно до інших рішень, які розрізають код на дві частини і вставляють цілу Строку, яка знову репрезентує код всередині, але весь код не є просто String, а закодований як довге число в базі 36 (26 алфавітних символів + 10 цифр).
— користувач невідомий
1
Це можна скоротити, якщо покласти if(++i==92),
— tuskiomi
2
@tuskiomi: Спасибі, скорочено на два персонажі
— користувачеві невідомо
1
@userunknown Насправді, a*оскільки масив не виходить з Java, це C. Деякі інші частини для гольфу:, import java.math.*;class a{public static void main(String[]a){BigInteger b=new BigInteger("abc",36);int i=0;for(int c:b.toByteArray())System.out.printf("%s%c",++i==92?b.toString(36):"",c);}}де abcбуло б щойно обчислене магічне число String. У Java 8+ також можна змінити class a{public static void mainна interface a{static void main, а в Java 10+ також можна змінити import java.math.*;і BigInteger b=new BigInteger(на var b=new java.math.BigInteger(.
— Кевін Кройсейсен
23

Курка , 7

chicken

Ні, це прямо не перегукується :)

— Timtech
джерело
Чорт, ти мене до цього побив :)
— Taconut
Це не відлуння, це струна chicken!
— Ерік Аутгольфер
Немає коду / поділу даних, тому недійсне.
— CalculatorFeline
10
@CalculatorFeline Ви читали правила?
— Timtech
1
@JoKing Я не вважаю це недійсним, тому що правила виклику забороняють лише нульову довжину та обман (читання власного вихідного файлу). Єдине, що забороняє неправильні лайки - це стандартна лазівка, - за винятком випадків, коли стандартні лазівки зазвичай не застосовуються до відповідей, що передують їм.
— pppery
23

Сітківка , 20 14 9 7 байт

Перш ніж розпочати роботу, я хотів би зазначити тривіальне рішення файлу, який містить єдиний 0. У такому випадку Retina спробує підрахувати 0s в порожньому введенні, результат якого також є 0. Я б не вважав це належним королевою.

Отже, ось такий:

>\`
>\`

Спробуйте в Інтернеті!

Крім того, ми могли б використовувати ;замість цього >.

Пояснення

Програма складається з однієї заміни, яку ми друкуємо двічі.

У першому рядку `відокремлюється конфігурація від регулярного вираження, тому регулярний вираз є порожнім. Тому порожній рядок (тобто неіснуючий вхід) замінюється другим рядком, дослівно.

Щоб надрукувати результат двічі, ми загортаємо його на два вихідні етапи. Внутрішня \друкує результат за допомогою зворотного каналу, а зовнішня >- друкує його без жодної.

Якщо ви трохи знайомі з Retina, вам може бути цікаво, що сталося з неявним виходом Retina. Неявний вихід Retina працює, обертаючи завершальний етап програми на етапі виводу. Однак Retina цього не робить, якщо заключний етап вже є вихідним етапом. Причиною тому є те, що у звичайній програмі корисніше мати можливість замінити неявний вихідний етап на спеціальний, як-от-от, \або ;на один байт (замість того, щоб позбавлятись від неявного з .прапором). На жаль, така поведінка коштує нам двох байтів для лайки.

— Мартін Ендер
джерело
20

Javascript (36 char)

(function a(){alert("("+a+")()")})()

Це, AFAICT, найкоротший код, опублікований дотепер.

— Пітер Олсон
джерело
1
Це ... вражає. Ви повинні пояснити, як це працює для мене 8- |
— TehShrike
3
@TehShrike Підказка: ви можете переглянути вміст функції, примусивши її до рядка. Наприклад, якщо у вас є функція a, ви можете отримати доступ до її вмісту, зателефонувавши a.toString.
— Пітер Олсон
7
Щоб бути педантичним, це лише лайка, якщо ваша реалізація JavaScript строковує функцію aточно так само, як це було написано вище. Однак вихід цього коду, швидше за все, буде ланцюжком будь-якої реалізації JavaScript.
— Ільмарі Каронен
1
Ось той же Куайн, 1 байт коротше: !function a(){alert("!"+a+"()")}().
— Ісмаїл Мігель
1
(a=()=>alert(($ {a})))()
— Денніс C
19

GolfScript, 8 байт

Я завжди думав, що найкоротший (справжній) квінт GolfScript - 9 байт:

{'.~'}.~

Там, де необхідна передача ліній, тому що GolfScript друкує заздалегідь зворотну стрічку.

Але я щойно знайшов 8-байтову лайку, яка працює саме навколо цього обмеження на пряму передачу:

":n`":n`

Спробуйте в Інтернеті!

Таким чином, зло в тому, що GolfScript не друкує кінцеву лінію передачі рядків, а друкує вміст nу кінці програми. Це просто те, що nмістить стрічковий канал для початку. Отже, ідея полягає в тому, щоб замінити це на рядок ":n`", а потім зробити його послідовним, таким чином, щоб копія на стеку друкувалась цитатами та копія, що зберігається у nвідбитках без.

Як вказував Томас Ква, 7-байтну CJam quine також можна адаптувати до 8-байтового рішення:

".p"
.p

Знову ж, нам потрібна зворотна стрічка.

— Мартін Ендер
джерело
6
Гольфскрипт дивний.
— CalculatorFeline
19

Лабіринт , 124 110 53 байт

Спасибі Sp3000 за те, що я граю в 9 байт, що дозволило мені пограти ще в 7.

44660535853919556129637653276602333!
1
:_98
/8 %
@9_.

Спробуйте в Інтернеті!

Пояснення

Лабіринт 101:

  • Лабіринт - це двоскладова мова на основі стека. Стек є бездонним і заповненим нулями, тому вискакування з порожнього стека не є помилкою.
  • Виконання починається з першого дійсного символу (тут угорі зліва). На кожному з’єднанні, де є два або більше можливих шляхів для вказівника інструкції (IP), який слід пройти, верхня частина стека перевіряється, щоб визначити, куди йти далі. Негатив - поворот ліворуч, нуль - вперед, а позитив - поворот праворуч.
  • Цифри у вихідному коді не натискають відповідне число - натомість вони спливають верхню частину стека та натискають n*10 + <digit>. Це дозволяє легко нарощувати велику кількість. Щоб почати нове число, використовуйте _, яке натискає нуль.
  • " не є.

По-перше, я поясню трохи простішу версію, яка є байтом довше, але трохи менш магічною:

395852936437949826992796242020587432!
"
:_96
/6 %
@9_.

Спробуйте в Інтернеті!

Основна ідея - кодувати основне тіло джерела в єдине число, використовуючи якусь велику базу. Потім це число можна легко надрукувати назад, перш ніж його розшифрувати, щоб надрукувати решту вихідного коду. Розшифровка - це просто багаторазове застосування divmod base, де надрукуйте modі продовжуйте роботу з divдо нуля.

Уникаючи {}найвищого символьного коду, який нам знадобиться, є _(95) таким, що базової 96 є достатньою (утримуючи низьку базу, число на початку коротше). Отже, що ми хочемо кодувати:

!
"
:_96
/6 %
@9_.

Перетворивши ці символи в їхні кодові точки і трактуючи результат як число базової-96 (з найменш значущою цифрою, відповідною !і найзначнішою ., тому що це порядок, в якому ми будемо розбирати число), ми отримуємо

234785020242697299628949734639258593

Тепер код починається з досить прикольного трюку (якщо я можу так сказати), який дозволяє нам надрукувати кодування назад і зберегти ще одну копію для розшифровки з дуже невеликими накладними витратами: ми вводимо номер у код у зворотному порядку. Я обчислював результат за допомогою цього сценарію CJam, тож давайте перейдемо до фактичного коду. Ось початок:

395852936437949826992796242020587432!
"

IP починається у верхньому лівому куті, йде на схід. Поки він працює над цими цифрами, він просто збирає це число вгорі стека. Саме число є цілком безглуздим, бо це зворотне значення того, чого ми хочемо. Коли IP-адреса потрапляє на !, вискакує це число зі стека та друкує його. Це все, що відтворює кодування у висновку.

Але зараз ІС потрапила в глухий кут. Це означає, що він обертається і тепер рухається назад на захід (без !повторного виконання ). На цей раз, зручно, то IP зчитує номер від задньої до передньої, так що тепер число на вершині стека робить кодувати решту джерела.

Коли IP зараз знову потрапляє у верхній лівий кут, це не тупик, тому що IP може повернути ліворуч, так що він робить і тепер рухається на південь. Тут "не потрібно, щоб нам потрібно відокремити номер від основного циклу коду. Якщо говорити про це:

...
"
:_96
/6 %
@9_.

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

"
>>>v
^< v
 ^<<

Або викладені лінійно:

:_96%._96/

Причина, по якій вони роблять ці повороти, пов’язана з семантикою контрольного потоку в Лабіринті. Якщо в поточній комірці є щонайменше три сусіди, IP поверне ліворуч на від'ємне значення стека, продовжить нуль і поверне праворуч на позитивне значення стека. Якщо вибраний напрямок неможливий через стіну, IP замість цього буде приймати протилежний напрямок (саме тому в коді є два лівих витка, хоча верхня частина стека ніколи не є негативною).

Сам код циклу насправді досить простий (стиснення цього не було жорстким і не є головним внеском Sp3000):

:    # Duplicate the remaining encoding number N.
_96  # Push 96, the base.
%.   # Take modulo and print as a character.
_96  # Push 96 again.
/    # Divide N by 96 to move to the next digit.

Після досягнення Nнуля контроль потоку змінюється. Тепер ІР хотів би рухатися прямо після /(тобто на захід), але там є стіна. Тож замість того, якщо обертається (схід), виконується 6знову. Це робить верхню частину стека позитивною, тому IP повертає праворуч (на південь) і виконує 9. Верхня частина стека зараз 69, але все, що нам цікаво, це те, що вона позитивна. IP займає ще один правий поворот (на захід) і рухається на той, @який припиняє код.

Загалом, насправді досить просто.

Гаразд, тепер, як ми будемо голити цей додатковий байт. Зрозуміло, що безвідмовна робота здається марною, але нам потрібен додатковий рядок: якби цикл був сусіднім з номером, IP вже перемістився б туди, замість того, щоб пройти весь номер. Тож чи можемо ми зробити щось корисне з цим не-оп.

Ну, в принципі ми можемо використовувати це, щоб додати останню цифру до кодування. Кодування дійсно не повинно бути все на першому рядку ... !справедливе гарантує, що все , що там, також надруковане там.

Однак є улов, ми не можемо просто зробити це:

95852936437949826992796242020587432!
3
:_96
/6 %
@9_.

Проблема полягає в тому, що зараз ми змінили значення "на "а" 3, що також змінює фактичне число, яке ми хочемо мати. І напевно, що це число не закінчується 3. Оскільки число повністю визначається кодом, починаючи з цього, !ми не можемо багато з цим зробити.

Але, може, ми можемо вибрати іншу цифру? Нас не хвилює, чи є3 в цьому місці, якщо ми закінчимо число, яке правильно кодує джерело. Ну, на жаль, жодна з 10 цифр не дає кодування, чий найменш значимий показник відповідає вибраному. На щастя, в решті коду є деяка свобода, і ми можемо спробувати ще кілька кодувань, не збільшуючи кількість байтів. Я знайшов три варіанти:

  1. Ми можемо змінитися @на /. У цьому випадку ми можемо використовувати будь-яку цифру з1357 і отримати кодування, що відповідає. Однак це означатиме, що програма потім закінчується помилкою, яка дозволена, але не здається дуже чистою.
  2. Пробіли - не єдині "настінні" символи. Кожен невикористаний символ - це, зокрема, всі літери. Якщо ми використовуємо малі літери, то нам навіть не потрібно збільшувати базу для її розміщення (оскільки ці кодові точки знаходяться нижче _). 26 варіантів дає безліч можливостей. НапрA будь-яких непарних робіт. Це трохи приємніше, але все ще не здається настільки елегантним, оскільки ви ніколи не використовували б літеру в реальному коді.
  3. Ми можемо використовувати більшу базу. Поки ми не збільшимо основу, кількість десяткових цифр у кодуванні залишатиметься однаковою (конкретно, будь-яка база до 104 - це добре, хоча бази, що перевищують 99, насправді потребують додаткових символів у самому коді). На щастя, база 98 дає єдине відповідне рішення: коли ми використовуємо цифру 1, кодування також закінчується 1. Це єдине рішення серед баз 96, 97, 98, 99, тому це справді дуже щастить. І ось ми закінчуємо код у верхній частині цієї відповіді.
— Мартін Ендер
джерело
19

Втрачено , 293 262 249 байт

>:2+52*:6*:(84*+75*):>:::::[[[[[[[:[(52*)>::::[[[[[[:[84*+@>%?!<((((((((((([[[[[[[[[[[[[[ "
\#<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<
<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<\

Спробуйте в Інтернеті!

Пояснення

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

Чому Загублена Квіна така складна?

Як ви, можливо, знаєте, Lost - це 2D мова програмування, де місце початку та напрямок є повністю випадковими. Це робить написання будь-якої втраченої програми настільки ж складною, як написання коду, обтяженого радіацією. Ви повинні враховувати всі можливі місця та напрямки.

Але, як кажуть, існують деякі стандартні способи робити речі. Наприклад, ось стандартний спосіб друку рядка.

>%?"Stringv"(@
^<<<<<<<<<<<<<

У нижній частині цього потоку є колекція, яка захоплює більшість ips та перетягує їх до початкового місця. Як тільки вони дістаються до місця початку (ліворуч вгорі), ми їх саніруємо циклом, позбувшись усіх значень на стеку, після чого повернемо безпеку натискання струни та виходу. (безпека - це концепція, унікальна для програшеної програми; кожна програма повинна натиснути а %перед виходом; це запобігає можливості закінчення програми при запуску) Тепер моєю ідеєю було б поширити цю форму на повноцінну лайку.

Перше, що потрібно було зробити, це трохи переробити цикл, існуючий цикл був специфічним для формату String.

>%?!<"Stringv"(@
^<<<<<<<<<<<<<<<
^<<<<<<<<<<<<<<<

Нам потрібно додати другий потік, щоб уникнути можливості !перестрибування через потік і створення циклу.

Тепер ми хочемо змішати це зі стандартним форматом Quine. Оскільки "Втрата" дуже базується на Кляйна, я в основному вкрав позичену Квіен Квін у Мартіна Ендера .

:2+@>%?!< "
<<<<^<<<<<<
<<<<^<<<<<<

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

Ідея тут полягає у використанні дверей, щоб отримати потрібну кількість стрілок. Двері - це особливий тип дзеркала, який змінюється щоразу, коли його вдаряють. [відображає ips, що йдуть зліва і ]справа. Коли вони потрапляють на ip з будь-якої з цих сторін, орієнтація перемикача. Ми можемо зробити лінію цих дверей і статичний відбивач для багаторазового виконання операції.

>:[[[

Виступить :тричі. Таким чином, якщо ми натискаємо a <до стека перед рукою, ми можемо зробити їх багато з меншим числом байтів. Ми робимо 2 з них, по одному для кожного рядка, і між ними ми прокладаємо новий рядок, однак другий потрібно лише пройти, поки він не покриє !ми додали його, все інше можна залишити порожнім, заощадивши нам кілька байт. Гаразд, нам потрібно додати вертикальні стрілки до наших потоків. Тут відбувається ключова оптимізація. Замість того, щоб перенаправляти всі ips до "запуску" програми, ми будемо замість них перенаправляти їх в крайній лівий бік, тому що ми вже знаємо, що ips починаються вліво зліва повинніробота (або, принаймні, буде працювати в остаточній версії), ми також можемо просто перенаправити інші ips. Це не тільки робить її дешевшою в байтах, я вважаю, що саме ця оптимізація є можливою.

Однак є ще деякі проблеми, найважливішою з яких є ips, починаючи після >натискання, але перед тим, як ми починаємо робити його копії. Такі ips ввійдуть у копір та зроблять купу копій 0. Це погано, оскільки наш механізм очищення стека використовує нулі для визначення нижньої частини стека, залишаючи внизу цілу купу нулів. Нам потрібно додати більш сильний метод санітарії штабелів. Оскільки немає реального способу сказати, чи стек порожній, нам просто доведеться намагатися знищити якомога більше елементів на стеку. Тут ми ще раз використаємо метод дверей, описаний раніше. Ми додамо ((((((((((([[[[[[[[[[[[[[до кінця першого рядка відразу після санітора, щоб позбутися нулів.

Тепер є ще одна проблема, оскільки ми перенаправили наші потоки до верхнього лівого ips, починаючи з %і рухаючись вниз, вже вимкнули безпеку і вийдуть передчасно. Тому нам потрібно вимкнути безпеку. Ми робимо це, додаючи a #в потік, таким чином ips, що протікає через потік, буде вимкнено, але ips, які вже були дезінфіковані, не будуть. #Також повинні бути жорстко закодовані в першому рядку , а також.

Це все, сподіваємось, ви розумієте, як це працює зараз.

— Сріотчілізм О'Заїк
джерело
: / стільки помилок друку та відсутніх посилань
— лише ASCII
17

Так , 1165 879 606 561 540 522 498 + 7 = 505 байт

Потрібен -cheatпрапор, щоб дозволити визначення псевдонімів.

022222120211111102222122021121202222212021112202222110222212202112110222221202122212022222102222212021222120222221022222102222210222221202222110222211022222210222221022222210222212202222221022221102211110222221022221220222212202112120221111022212202211210222212022222102211120222122022111202222120212212021221202222221022111102221210222122022222102222120212212022221102211110222122022221102222120212212022112120221111022212202112120222212=%;0e-=<;0<-=>;:0~--=1;1>=2;0%{{>0<~{~>~<<}>>>]}>]}${<#}%{@}

Спробуйте в Інтернеті!

Пояснення

На це є дві частини (як у більшості лайків). Дані:

022222120211111102222122021121202222212021112202222110222212202112110222221202122212022222102222212021222120222221022222102222210222221202222110222211022222210222221022222210222212202222221022221102211110222221022221220222212202112120221111022212202211210222212022222102211120222122022111202222120212212021221202222221022111102221210222122022222102222120212212022221102211110222122022221102222120212212022112120221111022212202112120222212

І декодер:

=%;0e-=<;0<-=>;:0~--=1;1>=2;0%{{>0<~{~>~<<}>>>]}>]}${<#}%{@}

Дані - це просто двійкове кодування декодера (а точніше його зворотного). Кожен 0запускає новий символ, а 1s і 2s - 0- і 1-біти відповідно.

Зверніть увагу , що 0це стандартна команда Угу , яка штовхає до нуля, в той час як 1і 2не визначені в цій точці. Однак ми призначаємо всю частину даних команді %так, щоб 1і 2могла залишатися невизначеною, поки %фактично не використовується.

Далі ми визначаємо ще кілька команд:

0e-=<;
0<-=>;
:0~--=1;
1>=2;

<зменшує верхню частину стека, >збільшуючи її. 1(дещо ненавмисно) подвоює верхню частину стека. 2подвоює його, а потім збільшує. Завдяки цим визначенням щось подібне 0221111насправді залишить 48 (110000 у двійковій) на стеці.

Решта 32 байта роблять фактичне декодування з двох частин. Спочатку нам потрібно реконструювати рядок даних.

0%                ` Push a zero and then the data.
{                 ` For each value...
  {               `   Until that value is zero...
    >0<~{~>~<<}>  `   divmod 2. The div is the input to the next iteration,
                  `   the mod gives us the next bit.
    >>]           `   Increment twice (gives 2 or 3) and put at the bottom
                  `   of the stack.
  }
  >]              ` Increment the 0 and put it at the bottom as well.
}
$                 ` Reverse the entire stack.
{<#}              ` Decrement and print each number.

І нарешті, ми знову натискаємо дані та друкуємо кожне значення як символ:

%{@}

Для подальшої довідки ось сценарій CJam для кодування даних.

— Мартін Ендер
джерело
17

Фуе , 423 байт

Fueue - це езоланг на основі черги, в якому запущена програма є чергою.

)$$4255%%1(~):[)$$24%%0:<[~:)~)]~[$11~)~<[[+$4--498+*-:~-10)):])<~][)))~]<]](H-):~:[)[):~[)~:~~([:~)*[):~[$1(+48]):~+]-:~~)10)~~]/]+:5):]~:](106328966328112328136317639696111819119696281563139628116326221310190661962811611211962861109696289611619628116111612896281115421063633063961111116163963011632811111819159628151213262722151522061361613096119619190661966311961128966130281807072220060611612811961019070723232022060611

Спробуйте в Інтернеті!

Як це працює

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

Фейе-шпаргалка

Докладні відомості див. У статті Вікі esolang , зокрема про деякі функції, які не використовуються в цій програмі.

  • Початкова програма - це початковий стан черги, який може містити такі елементи:

    • Цілі літерали (можна обчислити лише негативні джерела, але негативні), виконуючи їх, друкує символ.
    • Вкладені квадратними дужками вкладені вкладені блоки, інертні (зберігаються неушкодженими, якщо на них не діє якась функція).
    • Функції, їх аргументи - це елементи, що слідують за ними відразу в черзі:
      • +*/-%: ціла арифметика ( -є одинарною, %логічне заперечення). Інертне, якщо не вказано число аргументів.
      • ()<: помістіть елемент у дужки, вийміть дужки з блоку, додайте кінцевий елемент до блоку. Останні два є інертними, якщо не супроводжується блоком.
      • ~:: поміняти, дублювати.
      • $: копія (займає число + елемент). Інерт перед номером.
      • H: програма зупинки.

    Зауважте, що в той час як []гніздо, ()не робіть - останні - це просто окремі функції.

Синтаксис сліду виконання

Білий простір необов’язковий у фуе, за винятком цифр. У наступних слідах виконання він буде використаний для пропонування структури програми, зокрема:

  • Коли функція виконується, вона та її аргументи будуть зміщені з навколишніх елементів пробілами. Якщо деякі аргументи є складними, між ними може бути пробіл.
  • Багато слідів виконання поділяються на "крапку затримки" зліва, відокремлену від частини праворуч, яка робить суттєві маніпуляції з даними. Дивіться наступний розділ.

Фігурні дужки {}(не використовуються у фуе) використовуються у слідах для відображення цілого результату математичних виразів. Сюди входять і негативні числа, оскільки Фуе має лише негативні літерали - -це функція заперечення.

Різні метавимінні назви і ...використовуються для позначення значень і скорочень.

Затримка тактики

Інтуїтивно, цикли виконання навколо черги, частково змінюючи те, через що вона проходить. Результати функції не можуть бути активовані знову до наступного циклу. Різні частини програми ефективно розвиваються паралельно до тих пір, поки вони не взаємодіють.

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

Ці тактики не завжди будуть окремо згадуватися нижче:

  • )[A]затримки Aциклу. (Мабуть, найпростіший і найчитабельніший метод.)
  • ~efпереставляє елементи eі fякий також затримує їх виконання. (Мабуть, найменш читабельна, але часто найкоротша для незначних затримок.)
  • $1eзатримує один елемент e.
  • -і %корисні для затримки чисел (останні для 0і 1.)
  • Затримуючи кілька рівних елементів підряд, :або $їх можна використовувати для створення з одного.
  • (nзагортання nв дужки, які згодом можна буде зручно зняти. Це особливо важливо для чисельних обчислень, оскільки числа є надто нестабільними, щоб навіть їх можна було скопіювати, не попередньо поставивши їх у блок.

Загальна структура

Решта пояснення розділена на сім частин, кожна для розділу запущеної програми. Більші цикли, після яких більшість із них повторюються, називатимуться "ітераціями", щоб відрізнити їх від "циклів" одиночних проходів по всій черзі.

Ось як поділяється початкова програма між ними:

A:  )$$4255%%1(~
B:  ):[)$$24%%0:<[~:)~)]~[$11~)~<[[+$4--498+*-:~-10)):])<~][)))~]<]]
C:  
D:  (H-
E:  
F:  
G:  ):~:[)[):~[)~:~~([:~)*[):~[$1(+48]):~+]-:~~)10)~~]/]+:5):]~:](106328966328112328136317639696111819119696281563139628116326221310190661962811611211962861109696289611619628116111612896281115421063633063961111116163963011632811111819159628151213262722151522061361613096119619190661966311961128966130281807072220060611612811961019070723232022060611

Велика цифра в кінці програми кодує решту в зворотному порядку, дві цифри на символ, з 30 віднімається від кожного значення ASCII (так, наприклад, 10кодує а (.)

На більш високому рівні ви можете вважати, що дані цієї програми (починаючи з бінтуму), як течуть справа наліво, але керують потоком зліва направо. Однак на нижчому рівні Fueue весь час заплутує розмежування коду та даних.

  • Розділ G декодує бінту на цифри ASCII (наприклад, цифру 0як ціле число 48), розділяючи спочатку найменш значущі цифри. Він виробляє одну цифру кожні 15 циклів.
  • Розділ F містить отримані цифри значень ASCII (кожне всередині блоку), поки розділ Е не зможе їх споживати.
  • Розділ Е обробляє отримані цифри по одній, поєднуючи їх у блоки форми [x[y]], також друкуючи закодований символ кожної пари.
  • Розділ D складається з глибоко вкладеного блоку, поступово побудованого з [x[y]]блоків таким чином, що після того, як він містить усі цифри, його можна запустити для друку всіх, а потім зупинити всю програму.
  • Розділ C займається побудовою секції D, а також відтворює ділянку E.
  • Розділ B відтворює розділ C, а також сам кожні 30 циклів.
  • Розділ А відраховує цикли до останньої ітерації інших розділів. Потім він перериває секцію B і запускає секцію D.

Розділ А

Розділ A займає планування кінця програми. Для зведення до однієї функції заміни потрібно 4258 циклів ~, які потім вносять коригування в секцію B, яка зупиняє її основний цикл і замість цього починає виконувати секцію D.

)$ $4255% %1 (~
)$%%%...%% %0 [~]
)$%%%...% %1 [~]
⋮
)$ %0 [~]
) $1[~]
)[~]
~
  • $Функція створює 4255 копії наступних в %той час як (обертає ~в дужках.
  • Кожен останній цикл %використовується для перемикання наступного числа між 0та 1.
  • Коли всі %s використовуються, $1створюється 1 копія [~](фактично NOP), а на наступному циклі )знімає дужки.

Розділ В

Секція B справляється з самою регенерацією, а також новою ітерацією розділу C кожні 30 циклів.

) : [)$$24%%0:<[~:)~)]~[$11~)~<[[+$4--498+*-:~-10)):])<~][)))~]<]]
) [)$$24%%0:<[~:)~)]~[$11~)~<[[+$4--498+*-:~-10)):])<~][)))~]<]]            [BkB]
)$ $24%     %0  :<  [~:)~)]    ~ [$11~)~<[[+$4--498+*-:~-10)):])<~][)))~]<] [BkB]
)$ %...%%% %1   < < [~:)~)] [BkB]   [$11~)~<[[+$4--498+*-:~-10)):])<~][)))~]<]
)$ %...%% %0      < [~:)~)[BkB]] [$11~)~<[[+$4--498+*-:~-10)):])<~][)))~]<]
)$ %...% %1         [~:)~)[BkB][$11~)~<[[+$4--498+*-:~-10)):])<~][)))~]<]]
⋮
) $1 [~:)~)[BkB][$11~)~<[[+$4--498+*-:~-10)):])<~][)))~]<]]
) [~:)~)[BkB][$11~)~<[[+$4--498+*-:~-10)):])<~][)))~]<]]                    (1)
~:) ~)[BkB]                 [$11~)~<[[+$4--498+*-:~-10)):])<~][)))~]<]
) : [BkB]                 ) [$11~)~<[[+$4--498+*-:~-10)):])<~][)))~]<]      (2)
) [BkB] [BkB]               $11~)~<[[+$4--498+*-:~-10)):])<~][)))~]<
  • :Дублює великий блок наступний (один екземпляр скорочено [BkB]), а потім )видаляє дужку з першої копії.
  • $$24%%0 налаштовує зворотний відлік, подібний до того, що в розділі А.
  • Поки це відлічується, :<перетворюється на <<та ~замінює два з блоків, оставляючи код нового розділу C останнім.
  • Дві <функції пакують два кінцевих блоки в перший - це зайве в звичайних ітераціях, але дозволить ~з розділу А виконати свою роботу в кінці.
  • (1) Коли відлік закінчується, )знімаються зовнішні дужки. Далі ~:)перетворюється на ):та ~)заміняє a )на початок розділу C кодом.
  • (2) Розділ B тепер повернувся до свого початкового циклу, тоді як a )збирається зняти дужки, щоб почати нову ітерацію розділу C.

Під час остаточної ітерації в ~розділі A з'являється точка (1) вище:

~ ) [~:)~)[BkB][$11~)~<[[+$4--498+*-:~-10)):])<~][)))~]<]]                  (1)
[~:)~)[BkB][$11~)~<[[+$4--498+*-:~-10)):])<~][)))~]<]]              )

У ~свопи )через блок і в секції С, запобігаючи розділ В від бути знову запустити.

Розділ С

Розділ C обробляє об'єднання нових знакових пар символів у блок розділу D, а також створює нові ітерації розділу E.

Нижче показано типову ітерацію кодів ASCII цифр xта їх yпредставлення. У першій ітерації вхідні елементи "D" та "E" є початковими [H]і -замість цього, як і жоден попередній розділ E, не було виконано для створення жодних пар символів.

C                                               D             E
$11~ )  ~<[[+$4--498+*-:~-10)):])<~]  [)))~]  < [)))~[...]]   [x[y]]
~~~ ~~~ ~~~ ~~) [[+$4--498+*-:~-10)):])<~]  < [)))~] [)))~[...][x[y]]]
~~~ ~~~     )  ~ [[+$4--498+*-:~-10)):])<~] [)))~[)))~[...][x[y]]]]
~~~       ~ )   [)))~[....]]                                  [[+$4--498+*-:~-10)):])<~]
                                              ~~[)))~[....]] )[[+$4--498+*-:~-10)):])<~]
                                                [)))~[....]]  ~[+$4--498+*-:~-10)):])<~
  • Для цього використовується інший метод синхронізації, який я виявив для цієї відповіді. Якщо у вас є кілька функцій підміни ~підряд, рядок скорочуватиметься приблизно до 2/3 кожного циклу (оскільки один ~підміняє два наступні), але періодично з залишком ~s, що спричиняє хаос, ретельно маніпулює подальшим .
  • $11~виробляє такий ряд. Наступний ~поміняє місцями <на наступний блок. Інший <в кінці додає новий блок парного числа (цифри x і y як коди ASCII) до блоку розділу D.
  • У наступному циклі ~рядок має ~~залишок, який заміняє ~на наступне ). Інший <додає розділ D до [)))~]блоку.
  • Далі ~сам своп замінює наступний блок новим кодом розділу E через блок D розділу. Потім новий залишок ~міняється )поперек, і, нарешті, останній ~~у ~рядку поміняє одну з них на секцію E так само, як )вилучив дужки.

Під час остаточної ітерації розділ A ~поміняв )поперек розділу B і на розділ C. Однак, розділ C настільки короткочасний, що вже зник, і )закінчується на початку розділу D.

Розділ D

Розділ D обробляє друк остаточної великої цифри та зупиняє програму. Під час більшості запуску програми це інертний блок, який розділи B – G співпрацюють над побудовою.

    (H -
    [H]-
    ⋮
    [)))~[H-]]                  After one iteration of section C
    ⋮
    [)))~[)))~[H-][49[49]]]]    Second iteration, after E has also run
    ⋮
)   [)))~[...]]     [49[48]]    Final printing starts as ) is swapped in
    ))) ~[...][49[48]]
    )) )[49[48]] [...]
    )) 49 [48][...]             Print first 1
    ) )[48] [...]
    ) 48 [...]                  Print 0
    )[...]                      Recurse to inner block
    ...
    ⋮
    )[H-]                       Innermost block reached
    H -                         Program halts
  • У першому циклі програми (функція зупинки загортається Hв дужки. -Наступним чином , він буде використовуватися як фіктивний елемент для першої ітерації замість цифр пари.
  • Перша об'єднана реальна пара цифр - це [49[49]]відповідна фіналу 11в числівнику.
  • Сама остання пара цифр [49[48]](що відповідає 10початку на числівнику) насправді не включена до блоку, але це не має різниці як )[A[B]]і )[A][B]є рівнозначними, як перетворюються на A[B].

Після остаточної ітерації, )поміняється вправо з розділу B, і блок D розділу блокується. На )))~початку кожного підблоку переконайтеся, що всі частини виконані в правильному порядку. Нарешті, найпотужніший блок містить програму, що Hзупиняє.

Розділ Е

Розділ E обробляє комбіновані пари цифр ASCII, отримані секцією G, і обидві друкує відповідний закодований символ і надсилає блок з комбінованою парою вліво до розділів C і D.

Знову нижче показано типову ітерацію кодів ASCII цифр xта їх yпредставлення.

E                                                   F
~ [+$4--498+*-:~-10)):] )              <  ~         [y] [x]
) [+$4--498+*-:~-10)):]                   < [x] [y]
+ $4-  - 498  +*- :~ -10 ) )              : [x[y]]
+---  -{-498} +*- ~~{-10} )       ) [x[y]]  [x[y]]
+--    - 498  +*   -{-10}       ~ ) x  [y]  [x[y]]
+-    -{-498} +               * 10 x  )[y]  [x[y]]
+      - 498                    + {10*x} y  [x[y]]
                         + {-498} {10*x+y}  [x[y]]
{10*x+y-498}  [x[y]]
[x[y]]
  • Блоки, що надходять, поміняються місцями, потім блок y додається до блоку x, а весь парний блок копіюється. Один примірник залишиться до кінця для розділів C і D.
  • Інша копія знову розблоковується, потім застосовується послідовність арифметичних функцій для обчислення 10*x+y-498значення ASCII кодованого символу. 498 = 10*48+48-30, 48s скасовує кодування ASCII xі yпри цьому 30змінює кодування з 00–99на 30–129, що включає в себе всі друковані ASCII.
  • Потім отримане число залишається для виконання, яке друкує його характер.

Розділ F

Розділ F складається з інертних блоків, що містять коди ASCII цифр. Для більшості запуску програми тут буде не більше двох, оскільки розділ E споживає їх з тією ж швидкістю, з якою виробляє їх G. Однак на завершальній фазі друку 0тут будуть зібрані кілька зайвих цифр.

[y] [x] ...

Розділ G

Розділ G обробляє розподіл великої кількості наприкінці програми, спочатку найменш значущих цифр, та надсилає блоки з кодами ASCII зліва в інші розділи.

Оскільки у нього немає перевірки зупинки, вона фактично продовжить видавати 0цифри, коли число знизиться до 0, поки розділ D не зупинить всю програму з Hфункцією.

[BkG] скорочується копія великого блоку стартового коду, який використовується для самовідтворення для запуску нових ітерацій.

Ініціалізація на перших циклах:

) :~  : [)[):~[)~:~~([:~)*[):~[$1(+48]):~+]-:~~)10)~~]/]+:5):]~:]  ( 106328966328112328136317639696111819119696281563139628116326221310190661962811611211962861109696289611619628116111612896281115421063633063961111116163963011632811111819159628151213262722151522061361613096119619190661966311961128966130281807072220060611612811961019070723232022060611
)  ~ ~ [)[):~[)~:~~([:~)*[):~[$1(+48]):~+]-:~~)10)~~]/]+:5):]~:]  [BkG] [10...11]
) [)[):~[)~:~~([:~)*[):~[$1(+48]):~+]-:~~)10)~~]/]+:5):]~:]     ~ [BkG] [10...11]
) [):~[)~:~~([:~)*[):~[$1(+48]):~+]-:~~)10)~~]/]+:5):]       ~ : [10...11]  [BkG]

Типова ітерація - Nпозначає число, яке потрібно розділити:

) [):~[)~:~~([:~)*[):~[$1(+48]):~+]-:~~)10)~~]/]+:5):]        ~ : [N]  [BkG]
) :~ [)~:~~([:~)*[):~[$1(+48]):~+]-:~~)10)~~]/]+ :5 )         : [N]  : [BkG]
)  ~ ~ [)~:~~([:~)*[):~[$1(+48]):~+]-:~~)10)~~]/]  +5 5     ) [N]  [N] [BkG] [BkG]
) [)~:~~([:~)*[):~[$1(+48]):~+]-:~~)10)~~]/]               ~ 10 N  [N] [BkG] [BkG]
) ~:~  ~ ( [:~)*[):~[$1(+48]):~+]-:~~)10)~~]               / N 10  [N] [BkG] [BkG]
)  ~ : [:~)*[):~[$1(+48]):~+]-:~~)10)~~]                 ( {N/10}  [N] [BkG] [BkG]
) [:~)*[):~[$1(+48]):~+]-:~~)10)~~]                    : [{N/10}]  [N] [BkG] [BkG]
:~ )*[):~[$1(+48]):~+]- :~ ~)10 )           ~ ~ [{N/10}]  [{N/10}] [N] [BkG] [BkG]
~~) *[):~[$1(+48]):~+]- ~~10 )             ) [{N/10}]  ~ [{N/10}] [N]  [BkG] [BkG]
)  ~ * [):~[$1(+48]):~+]  -10            ~ ) {N/10}  [N] [{N/10}] [BkG] [BkG]
) [):~[$1(+48]):~+]               * {-10} {N/10}  ) [N]  [{N/10}] [BkG] [BkG]
) :~ [$1(+48]) :~                 + {-10*(N/10)} N  [{N/10}] [BkG] [BkG]
)  ~ ~ [$1(+48]  )                 ~ ~ {N%10}  [{N/10}] [BkG] [BkG]
) [$1(+48]                 ~ ) {N%10}  ~ [{N/10}] [BkG]  [BkG]
$1(                     + 48 {N%10}    ) [BkG]  [{N/10}] [BkG]
                        ( {48+N%10}   BkG [{N/10}] [BkG]            New iteration starts
                        [{48+N%10}]   ....
  • Затримка краплі тут особливо волохата. Однак єдиним новим трюком затримки є використання +:5замість --10затримки 10двох циклів. На жаль, 10у цьому допомогла лише одна з програм.
  • [N]І [BkG]блоки дублюються, то один екземпляр Nділиться 10.
  • [{N/10}]дублюються, то більше арифметичних функції використовуються для обчислення ASCII коду останньої цифри , Nяк 48+((-10)*(N/10)+N). Блок з цим кодом ASCII залишається для розділу F.
  • Інша копія [{N/10}]файлу поміняється між [BkG]блоками для встановлення початку нової ітерації.

Бонусна квінка (540 байт)

)$$3371%%1[~!~~!)!]):[)$$20%%0[):]~)~~[)$$12%%0[<$$7%~~0):~[+----48+*-~~10))]<]<~!:~)~~[40~[:~))~:~[)~(~~/[+--48):]~10]+30])):]]][)[H]](11(06(06(21(21(25(19(07(07(19(61(96(03(96(96(03(11(03(63(11(28(61(11(06(06(20(18(07(07(18(61(11(28(63(96(11(96(96(61(11(06(06(19(20(07(07(18(61(30(06(06(25(07(96(96(18(11(28(96(61(13(15(15(15(15(22(26(13(12(15(96(96(19(18(11(11(63(30(63(30(96(03(28(96(11(96(96(61(22(18(96(61(28(96(11(11(96(28(96(61(11(96(10(96(96(17(61(13(15(15(22(26(11(28(63(96(19(18(63(13(21(18(63(11(11(28(63(63(63(61(11(61(42(63(63

Спробуйте в Інтернеті!

Оскільки я не знав, який метод буде найкоротшим, спершу спробував кодувати символи у вигляді двоцифрових чисел, розділених (s. Основний код трохи коротший, але на 50% більше представлення даних компенсує це. Не такий гольф, як інший, як я зупинився, коли зрозумів, що це не переможе. Вона має одну перевагу: вона не потребує реалізації з підтримкою bignum.

Його загальна структура дещо схожа на основну. Розділ G відсутній, оскільки представлення даних безпосередньо заповнює розділ F. Однак у розділі E слід здійснити аналогічний обчислення даних, щоб відновити цифри двоцифрових чисел.

— Ørjan Johansen
джерело
1
Слід пояснити пояснення XD
— VFDan
1
)$n[)](є байтом коротшим для лічильника затримки.
— jimmy23013
15

Желе, 3 байти

”ṘṘ

Спробуйте в Інтернеті!

Перевірка

$ echo $LANG
en_US
$ xxd -g 1 quine.jelly
0000000: ff cc cc                                         ...
$ ./jelly f quine.jelly | xxd -g 1
0000000: ff cc cc                                         ...

Як це працює

”ṘṘ    Main link. No input.

”Ṙ     Set the return value to the character 'Ṙ'.
  Ṙ    Print a string representation of the return value.
       This prints: ”Ṙ
       (implicit) Print the return value.
       This prints: Ṙ
— Денніс
джерело
Яку версію перекладача використовує це? Коли я тестую це, він виводить у UTF-8, навіть якщо вхід знаходиться у кодовій сторінці Jelly (і зміна кодування зробить його не-a-quine).
1
Кодування виходу залежить від налаштувань вашого терміналу: якщо для нього встановлено UTF-x, він використовує це; якщо встановлено щось інше, він використовує кодову сторінку Jelly. В Linux LANG=en_USдосягає саме цього. tio.run/nexus/bash#@@/…
— Денніс
Використовуючи наш веб-сайт, ви визнаєте, що прочитали та зрозуміли наші Політику щодо файлів cookie та Політику конфіденційності.
Licensed under cc by-sa 3.0 with attribution required.