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

Якщо ви опублікуєте тріщину, яка виявилася недійсною, слід видалити її і не має права публікувати чергову спробу проти тієї ж відповіді.

Оцінка балів

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

Перемішання, Ліам Норонха

cinpush

main:
    gte Hans 1s Leopold
    jnz Leopold done

    mov 1s Hans

    gte Gertrude Hans Leopold
    jnz Leopold done

    mov Gertrude ShabbySam
    mov Hans Gertrude
    mov ShabbySam Hans

    gte Alberto Gertrude Leopold
    jnz Leopold done

    mov Alberto ShabbySam
    mov Gertrude Alberto
    mov ShabbySam Gertrude

    done:

    mov 10 ShabbySam

    gte 1s ShabbySam Leopold
    jz Leopold undo_u

    mov 30 ShabbySam
    gte 1s ShabbySam Leopold
    jz Leopold undo_d

    undo_r:

        POP!! 1

        "shuffle" f
        "shuffle" f
        "shuffle" b
        "shuffle" b
        "shuffle" l
        "shuffle" f
        "shuffle" f
        "shuffle" b
        "shuffle" b

        jmp end

    undo_u:

        POP!! 1

        "shuffle" f
        "shuffle" f
        "shuffle" f
        "shuffle" b
        "shuffle" b
        "shuffle" b
        "shuffle" l
        "shuffle" l
        "shuffle" l
        "shuffle" f
        "shuffle" b

        jmp end

    undo_d:

        POP!! 1

        "shuffle" f
        "shuffle" b
        "shuffle" l
        "shuffle" f
        "shuffle" f
        "shuffle" f
        "shuffle" b
        "shuffle" b
        "shuffle" b

    end:
    jnz 1s main

print Hans
done!

Це було справді чудово весело, дякую Ліам! :)

Завдяки Sp3000 за незначне, але необхідне натискання в потрібному напрямку.

Як?

Два слова: кишеньковий кубик .

Виявляється, стеки відповідають граням куба Рубіка 2x2x2 таким чином:

           ____ ____
          |    |    |
          | 19 | 17 |
          |____U____|
          |    |    |
          | 20 | 18 |
 _________|____|____|____ ____ ____ ____
|    |    |    |    |    |    |    |    |
| 13 | 14 |  1 |  2 |  9 | 10 |  6 |  5 |
|____L____|____F____|____R____|____B____|
|    |    |    |    |    |    |    |    |
| 15 | 16 |  3 |  4 | 11 | 12 |  8 |  7 |
|____|____|____|____|____|____|____|____|
          |    |    |
          | 22 | 24 |
          |____D____|
          |    |    |
          | 21 | 23 |
          |____|____|

Де ULFRBDвказати, яке обличчя відповідає вгору, ліворуч, спереду, праворуч, назад, вниз при правильному складенні куба.

Перестановки відповідають обертанню будь-якої сторони на 90 градусів (де назви, на щастя, збігаються). Виявляється, що f, rі dє по годинниковою стрілкою обертання (якщо дивитися на обличчя) і r, lі uце проти годинникової стрілки обертання (якщо дивитися на обличчя).

Тепер cinpushкоманда працює таким чином, що вона застосовує одне з обертань u, dабо r(залежно від заданого значення), а потім висуває вхідне значення на стек у позиції 1. (А потім він повторює це для кожного елемента вхідних даних.) Це означає, що ми можемо змінити цей процес (щоб переконатися, що ми закінчимо правильний порядок стеків, не розв'язуючи довільний кубік Рубіка), повторюючи огляд стека в позиція 1, скасовуючи відповідну перестановку і вискакуючи значення цього стека (так що наступного разу, коли ми побачимо стек, отримаємо значення під ним).

Як ми скасовуємо обертання? На щастя, у нас є fі bв нашому розпорядженні. Якщо застосувати їх обоє, ми обертаємо весь куб на 90 градусів. Це означає , що ми можемо рухатися ураженої сторони ( U, Rабо D) , щоб L, скасувати обертання з допомогою одного або трьох lз ( в залежності від відносного напрямку lі обертання виконується під час введення), а потім повернути куб назад до його попередньої орієнтації з використанням fі bзнову.

Зокрема, кожне з обертань, здійснених під час введення, може бути скасоване таким чином:

u --> fffbbblllfb
r --> ffbblffbb
d --> fblfffbbb

Я побачу, чи зможу я створити якісь анімації, щоб показати, що це працює.

Тепер це дає нам можливість перетворити весь вхід один раз. Але, маючи 5 регістрів, це все, що нам потрібно:

• Alberto - максимальне значення, що зустрічається до цих пір.
• Gertrude - це 2-е найбільше значення, що зустрічається до цих пір.
• Hans - це 3-те найбільше значення, що зустрічається до цих пір.

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

В кінці процесу ми просто надрукуємо вміст Hans, який вже буде містити третє за величиною значення.

TKDYNS Сем Капплман-Лайнс

Це, мабуть, не оптимально, але я думаю, що це робить трюк ...

cvcvc>v>^>>^^>>v>vvvvvvvv<<<^<<^<<^^>^<^cvc>v<cvcvcvc^>>vv<<c
>>^>>v>>>^^^^^^^^<^<<vv<<v<^<^^>cv<>^
>>^>>v>>>^^^^^^^^<^<<vv<<v<^<^^>vc^v<>^
>>^>>v>>>^^^^^^^^<^<<vv<<v<^c<^>^
>>^>>v>>>^^^^^^^^<^<<vv<<v<c^<^>^
>>^^<<^^>^c^^<^>^
>>^^<<^^>c<^>^^<^>^
>>^^<^c^<^>^^<^>^
>>^^<c<^^^>^^<^>^
>^cv>^>^<<<^^^>^^<^>^
>c>^>^<<<^^^>^^<^>^
>>^>>v>>>^^^^^^^^<^<<vv<<v<^<^^>>cv^
>>^>>v>>>^^^^^^^^<^<<<v<c^
>>^>>v>>>^^^^^^^^<^<<vv<<c^^
>>^>>v>>>^^^^^^^^<^<<vv<<vcv>>>^<^<<^^
>>^^<<^^>>^c>>>^<^<<^^
>>^^<<^^>>c<^>>>>^<^<<^^
>>^>>v>>^<^^<<<c^<^>>>>^<^<<^^
>>^^c>vv>^^^<<^<^>>>>^<^<<^^
>>^c^>vv>^^^<<^<^>>>>^<^<<^^
>>c^^>vv>^^^<<^<^>>>>^<^<<^^
>>^>>v>>>^^^^^^^^<^<<<c<>
>>^>>v>>>^^^^^^^^<^<<<vc^<>
>>^>>v>>>^^^^^^^^<^<<vv<c^^
>>^>>v>>>^^^^^^^^<^<<vv<vc^^^
>>^^<<^^>>>^c^^^^
>>^^<<^^>>>c^^^^^
>>^>>v>>^<^^<<c^^^^^^
>>^>^c<^^<^>^^^>^
>>^>c^<^^<^>^^^>^
>>>c^^<^^<^>^^^>^
>>^>>v>>>^^^^^^^^<^<<c<<>>
>>^>>v>>>^^^^^^^^<^<<vc<^>
>>^>>v>>>^^^^^^^^<^<<vvc>^<<^>
>>^>>v>>>^^^^^^^^<^<<vv<v>c>^^<<^>
>>^>>v>>>^^^^^^^^<^<<vv<v>>v<c^>^^<<^>
>>^^<<^^>>>>cv<^<^^>^>>^<<^>
>>^>>v>>^<^^<c<^<^^>^>>^<<^>
>>^>>v>>^<^^<vc>^^<v<^<^^>^>>^<<^>
>>^>>c>^^^<v<^<^^>^>>^<<^>
>>^>>vc<<^^>^^<^^>^>>^<<^>
>>^>>v>>>^^^^^^^^<^<cv^
>>^>>v>>>^^^^^^^^<<c^
>>^>>v>>>^^^^^^^^<^<<vv>c<^>^
>>^>>v>>>^^^^^^^^<^<<vv<v>>c<^^>^
>>^>>v>>>^^^^^^^^<^<<vv<v>>vc^<^^>^
>>^>>v>>^<^^^c^^<^^>^
>>^>>v>>^<^^c>v>>^>^<^^^<^<<^
>>^>>v>>^<^c^>v>>^>^<^^^<^<<^
>>^>>v>>^<c^^>v>>^>^<^^^<^<<^
>>^>>v>c^^^>v>>^>^<^^^<^<<^
>>^>>v>>>^^^^^^^^<^c<v^>
>>^>>v>>>^^^^^^^^<c<^>
>>^>>v>>>^^^^^^^^<^<<vv<v>>>^c<vv<<v<^^<^<^^>>>>>>
>>^>>v>>>^^^^^^^^<^<<vv<v>>>c>^<<vv<<v<^^<^<^^>>>>>>
>>^>>v>>>^^^^^^^^<^<<vv<v>>v>c^>^<<vv<<v<^^<^<^^>>>>>>
>>^>>v>>>^^^^<c^^>^<<vv<<v<^^<^<^^>>>>>>
>>^>>v>>^<^^>c<v<v>>v>^>v>^^<^^^^<^<<vv<<v<^^<^<^^>>>>>>
>>^>>v>>^<^^>vc^<v<v>>v>^>v>^^<^^^^<^<<vv<<v<^^<^<^^>>>>>>
>>^>>v>>^cv>^>v>^^<^^^^<^<<vv<<v<^^<^<^^>>>>>>
>>^>>v>>c>^>v>^^<^^^^<^<<vv<<v<^^<^<^^>>>>>>
>>^>>v>>>^^^^^^^^<^>c><
>>^>>v>>>^^^^^^^^c>^<
>>^>>v>>>^^^^^^^c^>^<
>>^>>v>>>^^^^^^c>^<^>^<
>>^>>v>>>^^^^^c^>^<^>^<
>>^>>v>>>^^^^c^^>^<^>^<
>>^>>v>>>^^^c>^^<^>^<^>^<
>>^>>v>>>^^c^>^^<^>^<^>^<
>>^>>v>>>^cv>^^<^>^^<^>^<^>^<
>>^>>v>>>c>^^<^>^^<^>^<^>^<
>>^>>v>>>^^^^^^^^>^c<>
>>^>>v>>>^^^^^^^^>c^<>
>>^>>v>>>^^^^^^^>cv<vvv>v<<^^^^^^>>^
>>^>>v>>>^^^^^^^>vc<vvv>v<<^^^^^^>>^
>>^>>v>>>^^^>^^c^<vvv>v<<^^^^^^>>^
>>^>>v>>>^^^>^c^^<vvv>v<<^^^^^^>>^
>>^>>v>>>^^^>cv<<^^^^^^>>^
>>^>>v>>>^^^>vc<<^^^^^^>>^
>>^>>v>>>^>cv<<<^<<<^>>>>^^^^^^>>^
>>^>>v>>>^>vc<<<^<<<^>>>>^^^^^^>>^
>>^>>v>>>^^^^^^^^>^>cv^
>>^>>v>>>^^^^^^^>>^c^
>>^>>v>>>^^^^^^^>>c^^
>>^>>v>>>^^^>^^>^c^^^
>>^>>v>>>^^^>^^>cvv<^^^^^^>
>>^>>v>>>^^^>^^>vcv<^^^^^^>
>>^>>v>>>^^^>>c<^^^^^^>
>>^>>v>>>^>v>^^cvv<<^<^^>^>^^^^^>
>>^>>v>>>^>v>^cv<<^<^^>^>^^^^^>
>>^>>v>>>^>v>c<<^<^^>^>^^^^^>
cvc<v>cvcvc<v>cvc^<vv>c>>v<v<^cvc
>^>^<<<^^^>^>^>^^<cv^
>^>^<<<^^^>^>^^c^
>^>^<<<^^^>^>^c^^
>^>^<<<^^^>^>cv>>>^<^<<^^
>^>^<^^^c>>>^<^<<^^
>^>^<^^c<^>>>>^<^<<^^
>^>^<^c^<^>>>>^<^<<^^
>^>^<c>vv>^^^<<^<^>>>>^<^<<^^
>^c^>vv>^^^<<^<^>>>>^<^<<^^
>c^^>vv>^^^<<^<^>>>>^<^<<^^
>^>^<<<^^^>^>^>^^c<<>>
>^>^<<<^^^>^>^>^c^<<>>
>^>^<<<^^^>^>^>c^^<<>>
>^>^<<<^^^>^>>c^^^
>^>^<^^^>c^^^^
>^>^<^^>c^^^^^
>^>^<^>c^^^^^^
>^>^c<^^<^>^^^>^
>^>c^<^^<^>^^^>^
>^>>v<c^^<^^<^>^^^>^
>^>^<<<^^^>^>^>^^>c<v<>^>
>^>^<<<^^^>^>^>^^>vc<^>
>^>^<<<^^^>^>^>^^>>>>v<vv<<^c>^<<^>
>^>^<<<^^^>^>^>^^>>>>v<vv<<c>^^<<^>
>^>^<^^^>>c^>^^<<^>
>^>^<^>>^cv<^<^^>^>>^<<^>
>^>^<^>>c<^<^^>^>>^<<^>
>^>^<^>>vc>^^<v<^<^^>^>>^<<^>
>^>>c>^^^<v<^<^^>^>>^<<^>
>^>>vc<<^^>^^<^^>^>>^<<^>
>^>^<<<^^^>^>^>^^>>cv^
>^>^<<<^^^>^>^>^^>>>>v<<c^
>^>^<<<^^^>^>^>^^>>>>v<v<c<^>^
>^>^<<<^^^>^>^>^^>>>>v<vv<c<^^>^
>^>^<<<^^^>^>^>^^>>>>v<v>>v<v<<c^<^^>^
>^>^<<<^^^>^>^>^^>>>>v<v>>v<v<<vc^^<^^>^
>^>^<^>>v>^c>v>>^>^<^^^<^<<^
>^>^<^>>v>c^>v>>^>^<^^^<^<<^
>^>^<^>>v>vc^^>v>>^>^<^^^<^<<^
>^>^<^>>v>vvc^^^>v>>^>^<^^^<^<<^
>^>^<<<^^^>^>^>^^>>>c<v^>
>^>^<<<^^^>^>^>^^>>>>v<c<^>
>^>^<<<^^^>^>^>^^>>>>v<vc<vv<<v<^^<^<^^>>>>>>
>^>^<<<^^^>^>^>^^>>>>v<vvc>^<<vv<<v<^^<^<^^>>>>>>
>^>^<<<^^^>^>^>^^>>>>v<v>>v<v<c^>^<<vv<<v<^^<^<^^>>>>>>
>^>^<^>>v>>>>^<<^c^^>^<<vv<<v<^^<^<^^>>>>>>
>^>^<^>>v>>>>^<<c<v<v>>v>^>v>^^<^^^^<^<<vv<<v<^^<^<^^>>>>>>
>^>^<^>>v>>c^<v<v>>v>^>v>^^<^^^^<^<<vv<<v<^^<^<^^>>>>>>
>^>^<^>>v>>vcv>^>v>^^<^^^^<^<<vv<<v<^^<^<^^>>>>>>
>^>^<^>>v>vv>c>^>v>^^<^^^^<^<<vv<<v<^^<^<^^>>>>>>
>^>^<<<^^^>^>^>^^>>>>c<v^>
>^>^<<<^^^>^>^>^^>>>>vc>^<
>^>^<<<^^^>^>^>^^>>>>v<v>c^>^<
>^>^<<<^^^>^>^>^^>>>>v<v>>v<c>^<^>^<
>^>^<<<^^^>^>^>^^>>>>v<v>>v<vc^>^<^>^<
>^>^<<<^^^>^>^>^^>>>>v<v>>vvv<c^^>^<^>^<
>^>^<^>>v>>>>^<c>^^<^>^<^>^<
>^>^<^>>v>>>c^>^^<^>^<^>^<
>^>^<^>>v>>>vcv>^^<^>^^<^>^<^>^<
>^>^<^>>v>vv>>c>^^<^>^^<^>^<^>^<
>^>^<<<^^^>^>^>^^>>>>>cv^
>^>^<<<^^^>^>^>^^>>>>v>c^
>^>^<<<^^^>^>^>^^>>>>v<v>>cv<vvv>v<<^^^^^^>>^
>^>^<<<^^^>^>^>^^>>>>v<v>>vc<vvv>v<<^^^^^^>>^
>^>^<<<^^^>^>^>^^>>>>v<v>>vvc^<vvv>v<<^^^^^^>>^
>^>^<<<^^^>^>^>^^>>>>v<v>>vvvc^^<vvv>v<<^^^^^^>>^
>^>^<^>>v>>>>^cv<<^^^^^^>>^
>^>^<^>>v>>>>c<<^^^^^^>>^
>^>^<^>>v>>>v>cv<<<^<<<^>>>>^^^^^^>>^
>^>^<^>>v>>>v>>v<c<<<^<<<^>>>>^^^^^^>>^
>^>^<<<^^^>^>^>^^>>>>>>c<v^>
>^>^<<<^^^>^>^>^^>>>>>>vc^<v^>
>^>^<<<^^^>^>^>^^>>>>v<v>>v>^c^^
>^>^<<<^^^>^>^>^^>>>>v<v>>v>c^^^
>^>^<<<^^^>^>^>^^>>>>v<v>>vvv>^cvv<^^^^^^>
>^>^<<<^^^>^>^>^^>>>>v<v>>vvv>cv<^^^^^^>
>^>^<<<^^^>^>^>^^>>>>v<v>>vvv>vc<^^^^^^>
>^>^<<<^^^>^>^>^^>>>>v<v>>vvv>vvcvv<<^<^^>^>^^^^^>
>^>^<^>>v>>>v>>cv<<^<^^>^>^^^^^>
>^>^<^>>v>>>v>>vc<<^<^^>^>^^^^^>
cvcvc>>v>v<<<^cvc<v>cvc>>vvv<^^<cvcvc
^^>vv>>^^^^>^>^>^<^<<^<<c<>
^^>vv>>^^^^>^>^>^<^<<^<<vc^<>
^^>vv>^^^<<^<^>>>>^<^<c^^
^^>vv>^^^<<^<^>>>>^<^<vc^^^
^^>vv>^^^<<^<^>>c^^^^
^^>vv>^^^<^c^^^^^
^^>vv>^^^<c^^^^^^
^^>c<^^<^>^^^>^
^^>vc^<^^<^>^^^>^
^^>vvc^^<^^<^>^^^>^
^^>vv>>^^^^>^>^>^<^<<^<c<<>>
^^>vv>^^^<<^<^>>>>^<^^c<^>
^^>vv>^^^<<^<^>>>>^<^c>^<<^>
^^>vv>^^^<<^<^>>>>^<c>^^<<^>
^^>vv>^^^<<^<^>>>c^>^^<<^>
^^>vv>^^^<<^<^>>>vcv<^<^^>^>>^<<^>
^^>vv>^^^c<^<^^>^>>^<<^>
^^>vv>^^c>^^<v<^<^^>^>>^<<^>
^^>vv>^c>^^^<v<^<^^>^>>^<<^>
^^>vv>c<<^^>^^<^^>^>>^<<^>
^^>vv>>^^^^>^>^>^<^<<^cv<>^
^^>vv>>^^^^>^>^>^<^<<c^v<>^
^^>vv>^^^<<^<^>>>>^>^<c<^>^
^^>vv>^^^<<^<^>>>>^c<^^>^
^^>vv>^^^<<^<^>>>>c^<^^>^
^^>vv>>^^^^c^^<^^>^
^^>vv>>^^^c>v>>^>^<^^^<^<<^
^^>vv>>^^c^>v>>^>^<^^^<^<<^
^^>vv>>^c^^>v>>^>^<^^^<^<<^
^^>vv>>c^^^>v>>^>^<^^^<^<<^
^^>vv>>^^^^>^>^>^<^<<^>c<<<<>>>>
^^>vv>>^^^^>^>^>^<^<c<^><<<<>>>>
^^>vv>^^^<<^<^>>>>^>^c<vv<<v<^^<^<^^>>>>>>
^^>vv>^^^<<^<^>>>>^>c>^<<vv<<v<^^<^<^^>>>>>>
^^>vv>>^^^^>^c^>^<<vv<<v<^^<^<^^>>>>>>
^^>vv>>^^^^>c^^>^<<vv<<v<^^<^<^^>>>>>>
^^>vv>>^^^^>>>v<<c<v<v>>v>^>v>^^<^^^^<^<<vv<<v<^^<^<^^>>>>>>
^^>vv>>>>^<^c^<v<v>>v>^>v>^^<^^^^<^<<vv<<v<^^<^<^^>>>>>>
^^>vv>>>>^<cv>^>v>^^<^^^^<^<<vv<<v<^^<^<^^>>>>>>
^^>vv>>>c>^>v>^^<^^^^<^<<vv<<v<^^<^<^^>>>>>>
^^>vv>>^^^^>^>^>^<^<<^>>c><
^^>vv>>^^^^>^>^>^<^c>^<
^^>vv>>^^^^>^>^>^<c^>^<
^^>vv>>^^^^>^>^c>^<^>^<
^^>vv>>^^^^>^>c^>^<^>^<
^^>vv>>^^^^>>c^^>^<^>^<
^^>vv>>^^^^>>>v<c>^^<^>^<^>^<
^^>vv>>>>^<^>c^>^^<^>^<^>^<
^^>vv>>>>^cv>^^<^>^^<^>^<^>^<
^^>vv>>>>c>^^<^>^^<^>^<^>^<
^^>vv>>^^^^>^>^>^^^c<>
^^>vv>>^^^^>^>^>^^c^<>
^^>vv>>^^^^>^>^>^cv<vvv>v<<^^^^^^>>^
^^>vv>>^^^^>^>^>c<vvv>v<<^^^^^^>>^
^^>vv>>^^^^>>>>^<c^<vvv>v<<^^^^^^>>^
^^>vv>>^^^^>>>c^^<vvv>v<<^^^^^^>>^
^^>vv>>^^^^>>>vcv<<^^^^^^>>^
^^>vv>>>>^<^>>c<<^^^^^^>>^
^^>vv>>>>>>^<cv<<<^<<<^>>>>^^^^^^>>^
^^>vv>>>>>c<<<^<<<^>>>>^^^^^^>>^
^^>vv>>^^^^>^>^>^^>^c<>
^^>vv>>^^^^>^>^>^^>c^<>
^^>vv>>^^^^>^>^>^^>vc^^<>
^^>vv>>^^^^>^>^>>c^^^
^^>vv>>^^^^>>>>^cvv<^^^^^^>
^^>vv>>^^^^>>>>cv<^^^^^^>
^^>vv>>^^^^>>>>vc<^^^^^^>
^^>vv>>>>>>^^cvv<<^<^^>^>^^^^^>
^^>vv>>>>>>^cv<<^<^^>^>^^^^^>
^^>vv>>>>>>c<<^<^^>^>^^^^^>
cvcvcvcvcvcvc^^^^^<vvv<v>vv>cvcvc
^^<^^<^>^^^>>^c<>
^^<^^<^>^^^>>c<^>
^^<^^<^>^^^>v>c>^<<^>
^^<^^<^>^^^>vv>c>^^<<^>
^^<^^<^>^^^>vv>vc^>^^<<^>
^^<^^<^>^^^>vvvvv>^cv<^<^^>^>>^<<^>
^^<^^<^>^^^>vvvvv>c<^<^^>^>>^<<^>
^^<^^<^>^^^>vvvvv>vc>^^<v<^<^^>^>>^<<^>
^^<^^<^>^^^>vvvvv>v>v<c>^^^<v<^<^^>^>>^<<^>
^^<^^<^>^^^>vvvvv>v>vv<c<<^^>^^<^^>^>>^<<^>
^^<^^<^>^^^>>^>cv^
^^<^^<^>^^^>>>c^
^^<^^<^>^^^>v>>c<^>^
^^<^^<^>^^^>vv>>c<^^>^
^^<^^<^>^^^>vv>v>c^<^^>^
^^<^^<^>^^^>vvvvv>^>c^^<^^>^
^^<^^<^>^^^>vvvvv>>c>v>>^>^<^^^<^<<^
^^<^^<^>^^^>vvvvv>v>c^>v>>^>^<^^^<^<<^
^^<^^<^>^^^>vvvvv>v>vc^^>v>>^>^<^^^<^<<^
^^<^^<^>^^^>vvvvv>v>vvc^^^>v>>^>^<^^^<^<<^
^^<^^<^>^^^>>>>>>^<<c>><<
^^<^^<^>^^^>>>>c<^>
^^<^^<^>^^^>vv>>>^c<vv<<v<^^<^<^^>>>>>>
^^<^^<^>^^^>vv>>>c>^<<vv<<v<^^<^<^^>>>>>>
^^<^^<^>^^^>vv>>>vc^>^<<vv<<v<^^<^<^^>>>>>>
^^<^^<^>^^^>vvvvv>v>v>>>^^<^<c^^>^<<vv<<v<^^<^<^^>>>>>>
^^<^^<^>^^^>vvvvv>v>v>>>^^<<c<v<v>>v>^>v>^^<^^^^<^<<vv<<v<^^<^<^^>>>>>>
^^<^^<^>^^^>vvvvv>v>>c^<v<v>>v>^>v>^^<^^^^<^<<vv<<v<^^<^<^^>>>>>>
^^<^^<^>^^^>vvvvv>v>v>cv>^>v>^^<^^^^<^<<vv<<v<^^<^<^^>>>>>>
^^<^^<^>^^^>vvvvv>v>vv>c>^>v>^^<^^^^<^<<vv<<v<^^<^<^^>>>>>>
^^<^^<^>^^^>>>>>>^<c<<>>
^^<^^<^>^^^>>>>>c>^<<<>>
^^<^^<^>^^^>vv>>>^>c^>^<
^^<^^<^>^^^>vv>>>>c>^<^>^<
^^<^^<^>^^^>vvvvv>v>v>>>^^<^^c^>^<^>^<
^^<^^<^>^^^>vvvvv>v>v>>>^^<^c^^>^<^>^<
^^<^^<^>^^^>vvvvv>v>v>>>^^<c>^^<^>^<^>^<
^^<^^<^>^^^>vvvvv>v>v>>^c^>^^<^>^<^>^<
^^<^^<^>^^^>vvvvv>v>v>>cv>^^<^>^^<^>^<^>^<
^^<^^<^>^^^>vvvvv>v>v>>vc>^^<^>^^<^>^<^>^<
^^<^^<^>^^^>>>>>>^cv><^
^^<^^<^>^^^>>>>>>c^v><^
^^<^^<^>^^^>>>>>>^>vv<cv<vvv>v<<^^^^^^>>^
^^<^^<^>^^^>vv>>>>>c<vvv>v<<^^^^^^>>^
^^<^^<^>^^^>vvvvv>v>v>>>^^^^c^<vvv>v<<^^^^^^>>^
^^<^^<^>^^^>vvvvv>v>v>>>^^^c^^<vvv>v<<^^^^^^>>^
^^<^^<^>^^^>vvvvv>v>v>>>^^cv<<^^^^^^>>^
^^<^^<^>^^^>vvvvv>v>v>>>^c<<^^^^^^>>^
^^<^^<^>^^^>vvvvv>v>v>>>cv<<<^<<<^>>>>^^^^^^>>^
^^<^^<^>^^^>vvvvv>v>v>>>vc<<<^<<<^>>>>^^^^^^>>^
^^<^^<^>^^^>>>>>>^>cvvv^^^
^^<^^<^>^^^>>>>>>^>vc^vvv^^^
^^<^^<^>^^^>>>>>>^>vvc^^vvv^^^
^^<^^<^>^^^>vvvvv>v>v>>>^^^^>^c^^^
^^<^^<^>^^^>vvvvv>v>v>>>^^^^>cvv<^^^^^^>
^^<^^<^>^^^>vvvvv>v>v>>>^>^^cv<^^^^^^>
^^<^^<^>^^^>vvvvv>v>v>>>^>^c<^^^^^^>
^^<^^<^>^^^>vvvvv>v>v>>>^>cvv<<^<^^>^>^^^^^>
^^<^^<^>^^^>vvvvv>v>v>>>v>^cv<<^<^^>^>^^^^^>
^^<^^<^>^^^>vvvvv>v>v>>>v>c<<^<^^>^>^^^^^>
c<v>c>v<c>v<cvc^>^<<v<vv>v>^cvc^>vv<c>v<c>^^^<v<v<vv>>c
<<^^>^^<^^>^>>^^c<>
<<^^>^^<^^>^>>^c^<>
<<^^>^^<^^>^>>c<^>^
<<^^>^^<^^>^>>vc<^^>^
<<^^>^^<^^>^>>vvc^<^^>^
<<^^>^>^>c^^<^^>^
<<^^>^>^>vc>v>>^>^<^^^<^<<^
<<^^>^>^>vvc^>v>>^>^<^^^<^<<^
<<^^>^>^>vvvc^^>v>>^>^<^^^<^<<^
<<^^>^>^>vvvvc^^^>v>>^>^<^^^<^<<^
<<^^>^^<^^>^>>^^>c<<>>
<<^^>^^<^^>^>>^>c<^><<>>
<<^^>^^<^^>^>>>c<vv<<v<^^<^<^^>>>>>>
<<^^>^^<^^>^>>vv>^c>^<<vv<<v<^^<^<^^>>>>>>
<<^^>^^<^^>^>>vv>c^>^<<vv<<v<^^<^<^^>>>>>>
<<^^>^^<^^>^>>vv>vc^^>^<<vv<<v<^^<^<^^>>>>>>
<<^^>^>^>vv>^c<v<v>>v>^>v>^^<^^^^<^<<vv<<v<^^<^<^^>>>>>>
<<^^>^>^>vv>c^<v<v>>v>^>v>^^<^^^^<^<<vv<<v<^^<^<^^>>>>>>
<<^^>^>^>vv>vcv>^>v>^^<^^^^<^<<vv<<v<^^<^<^^>>>>>>
<<^^>^>^>vv>v>v<c>^>v>^^<^^^^<^<<vv<<v<^^<^<^^>>>>>>
<<^^>^^<^^>^>>^^>>c>v^<
<<^^>^^<^^>^>>>>^c>^<
<<^^>^^<^^>^>>>>c^>^<
<<^^>^>^>vv>^>^>^^<c>^<^>^<
<<^^>^>^>vv>^>^>^^<vc^>^<^>^<
<<^^>^>^>vv>^>^c^^>^<^>^<
<<^^>^>^>vv>^>c>^^<^>^<^>^<
<<^^>^>^>vv>>c^>^^<^>^<^>^<
<<^^>^>^>vv>v>cv>^^<^>^^<^>^<^>^<
<<^^>^>^>vv>v>vc>^^<^>^^<^>^<^>^<
<<^^>^^<^^>^>>^^>>>cv^
<<^^>^>^>vv>^>^>^^^^c^
<<^^>^>^>vv>^>^>^^^cv<vvv>v<<^^^^^^>>^
<<^^>^>^>vv>^>^>^^c<vvv>v<<^^^^^^>>^
<<^^>^>^>vv>^>^>^c^<vvv>v<<^^^^^^>>^
<<^^>^>^>vv>^>^>c^^<vvv>v<<^^^^^^>>^
<<^^>^>^>vv>^>^>vcv<<^^^^^^>>^
<<^^>^>^>vv>^>^>vvc<<^^^^^^>>^
<<^^>^>^>vv>^>^>vvvcv<<<^<<<^>>>>^^^^^^>>^
<<^^>^>^>vv>v>v>c<<<^<<<^>>>>^^^^^^>>^
<<^^>^>^>vv>^>^>^^^>^^c<>
<<^^>^>^>vv>^>^>^^^>^c^<>
<<^^>^>^>vv>^>^>^^^>c^^<>
<<^^>^>^>vv>^>^>^^>c^^^
<<^^>^>^>vv>^>^>>^cvv<^^^^^^>
<<^^>^>^>vv>^>^>>cv<^^^^^^>
<<^^>^>^>vv>^>^>>vc<^^^^^^>
<<^^>^>^>vv>^>^>>vvcvv<<^<^^>^>^^^^^>
<<^^>^>^>vv>^>^>vvv>cv<<^<^^>^>^^^^^>
<<^^>^>^>vv>v>v>>c<<^<^^>^>^^^^^>
cvc<v>c<v>cvcvc^^<^^>>>v>vvv>v<v<<^<cvcvcvc
^^^>v>>^>^<^^^<^<^c<>
^^^>v>>^>^<^^^<^<c<^>
^^^>v>>^>^<^^^<<c<vv<<v<^^<^<^^>>>>>>
^^^>v>>^>^<^^^<v<c>^<<vv<<v<^^<^<^^>>>>>>
^^^>v>>^>^<^^^<vv<c^>^<<vv<<v<^^<^<^^>>>>>>
^^^>v>>^>^<^^^<^<<<vv>vv>c^^>^<<vv<<v<^^<^<^^>>>>>>
^^^>c<v<v>>v>^>v>^^<^^^^<^<<vv<<v<^^<^<^^>>>>>>
^^^>vc^<v<v>>v>^>v>^^<^^^^<^<<vv<<v<^^<^<^^>>>>>>
^>cv>^>v>^^<^^^^<^<<vv<<v<^^<^<^^>>>>>>
>c>^>v>^^<^^^^<^<<vv<<v<^^<^<^^>>>>>>
^^^>v>>^>^<^^^<^<^>c><
^^^>v>>^>^<^^^<^c>^<
^^^>v>>^>^<^^^<c^>^<
^^^>v>>^>^<^^^<vc>^<^>^<
^^^>v>>^>^<^^^<vvc^>^<^>^<
^^^>v>>^>^<^^^<^<<<vv>vv>>c^^>^<^>^<
^^^>v>>^<c>^^<^>^<^>^<
^^^>v>c^>^^<^>^<^>^<
^>>cv>^^<^>^^<^>^<^>^<
^^^>v>>>vv<<c>^^<^>^^<^>^<^>^<
^^^>v>>^>^<^^^<^>>^<c<>
^^^>v>>^>^<^^^<^>c^
^^^>v>>^>^<^^^cv<vvv>v<<^^^^^^>>^
^^^>v>>^>^<^^c<vvv>v<<^^^^^^>>^
^^^>v>>^>^<^c^<vvv>v<<^^^^^^>>^
^^^>v>>^>^<c^^<vvv>v<<^^^^^^>>^
^^^>v>>^cv<<^^^^^^>>^
^^^>v>>c<<^^^^^^>>^
^^^>v>>vcv<<<^<<<^>>>>^^^^^^>>^
^^^>v>>>vv<c<<<^<<<^>>>>^^^^^^>>^
^^^>v>>^>^<^^^<^>>^c<<>>
^^^>v>>^>^<^^^<^>>c^<<>>
^^^>v>>^>^<^^^>c^^
^^^>v>>^>^<^^>c^^^
^^^>v>>^>^<^>cvv<^^^^^^>
^^^>v>>^>^cv<^^^^^^>
^^^>v>>^>c<^^^^^^>
^^^>v>>>cvv<<^<^^>^>^^^^^>
^^^>v>>>vcv<<^<^^>^>^^^^^>
^^^>v>>>vvc<<^<^^>^>^^^^^>
c<v>c<^<<<<<vv>v>vv>^>>^^>c>v<cvcvc^^>>vvvv>vv<^<v<^<<^>^>cvc^<v<v>>cvc
>^>v>^^<^^^^<^<<vv<<v<^^<^<^^>>>>>>>c><
>^>v>^^<^^^^<^<<vv<<v<^^<^<^^>>>>>v>>c>^<
>^>v>^^<^^^^<^c^>^<
>^>v>^^<^^^^<c>^<^>^<
>^>v>^^<^^^<c^>^<^>^<
>^>v>^^<^^<c^^>^<^>^<
^<<^>^>>c>^^<^>^<^>^<
^<<^>^>>vc^>^^<^>^<^>^<
>^cv>^^<^>^^<^>^<^>^<
>c>^^<^>^^<^>^<^>^<
>^>v>^^<^^^^<^<<vv<<v<^^<^<^^>>>>>v>>>^c<>
>^>v>^^<^^^^<^<<vv<<v<^^<^<^^>>>>>v>>>c^<>
>^>v>^^<^^^^^cv<vvv>v<<^^^^^^>>^
>^>v>^^<^^^^c<vvv>v<<^^^^^^>>^
>^>v>^^<^^^c^<vvv>v<<^^^^^^>>^
>^>v>^^<^^c^^<vvv>v<<^^^^^^>>^
>^>v>^^<^cv<<^^^^^^>>^
>^>v>^^<c<<^^^^^^>>^
>^>cv<<<^<<<^>>>>^^^^^^>>^
>^>vc<<<^<<<^>>>>^^^^^^>>^
>^>v>^^<^^^^<^<<vv<<v<^^<^<^^>>>>>v>>>^>cv^
>^>v>^^<^^^^<^<<vv<<v<^^<^<^^>>>>>v>>>>c^
>^>v>^^<^^^^<^<<vv<<v<^^<^<^^>>>>>v>>>>vc^^
>^>v>^^<^^^^>c^^^
>^>v>^^<^^>^cvv<^^^^^^>
>^>v>^^<^^>cv<^^^^^^>
>^>v>^^<^^>vc<^^^^^^>
>^>v>^^cvv<<^<^^>^>^^^^^>
>^>v>^cv<<^<^^>^>^^^^^>
>^>v>c<<^<^^>^>^^^^^>
c>v<cvc>v<cvcvc^>vv<cvc>vv<^cvc
>^^<^>^^<^>^<^>^cv><^
>^^<^>^^<^>^<^>c^v><^
>^^<^>^^<^>^cv<vvv>v<<^^^^^^>>^
>^^<^>^^<^>c<vvv>v<<^^^^^^>>^
>^^<^>^^c^<vvv>v<<^^^^^^>>^
>^^<^>^c^^<vvv>v<<^^^^^^>>^
>^^<^>cv<<^^^^^^>>^
>^^c<<^^^^^^>>^
>^cv<<<^<<<^>>>>^^^^^^>>^
>c<<<^<<<^>>>>^^^^^^>>^
>^^<^>^^<^>^>^^c<>
>^^<^>^^<^>^>^c^<>
>^^<^>^^<^>^>c^^<>
>^^<^>^^<^>>c^^^
>^^<^>^^>cvv<^^^^^^>
>^>^^^cv<^^^^^^>
>^>^^c<^^^^^^>
>^>^cvv<<^<^^>^>^^^^^>
>^>cv<<^<^^>^>^^^^^>
>^>vc<<^<^^>^>^^^^^>
cvc<<vvvvvv>>^<^^^>^cvcvcvc^^<vvv>cvc<<<<<<v>>>v>>>^cvc
<<<^<<<^>>>>^^^^^^>>>^c<>
<<<^<<<^>>>>^^^^^^>>>c^<>
<<<^<<<^>>>>^^^^^^>>>vc^^<>
<<<^<<<^>>>>>>^<^^^>v>^c^^^
<<<^<<<^>>>>>>^<^^^>v>cvv<^^^^^^>
<<<^<<<^>>>>>>^>^cv<^^^^^^>
<<<^<<<^>>>>>>^>c<^^^^^^>
<<<^<<<^>>>>>>^>vcvv<<^<^^>^>^^^^^>
^>cv<<^<^^>^>^^^^^>
>c<<^<^^>^>^^^^^>
cvcvcvc^^^<vvvvvv>^^cvcvc<^<v<vv>v>>^^cvcvc

Це може стати несподіванкою, але я не написав це вручну ... код генерувався наступною програмою Mathematica:

layouts = Graph /@ {Labeled[DirectedEdge[#, #2], #3] & @@@ {{0, 1, ">"}, ... };
path[layout_, a_, b_] := 
 StringJoin[
  PropertyValue[{layouts[[layout + 1]], #}, EdgeLabels] & /@ 
   DirectedEdge @@@ 
    Partition[FindShortestPath[layouts[[layout + 1]], a, b], 2, 1]]
safetyCheck[layout_, target_] = "";
safetyCheck[0, 1] = safetyCheck[0, 11] = "v<>^";
safetyCheck[0, 2] = "v^";
safetyCheck[0, 3] = safetyCheck[0, 13] = "<>";
safetyCheck[0, 4] = "<<>>";
safetyCheck[0, 5] = "v^";
safetyCheck[0, 6] = "<v^>";
safetyCheck[0, 7] = "><";
safetyCheck[0, 8] = safetyCheck[0, 18] = "<>";
safetyCheck[0, 9] = "v^";
safetyCheck[1, 2] = "v^";
safetyCheck[1, 3] = safetyCheck[1, 13] = safetyCheck[1, 23] = "<<>>";
safetyCheck[1, 4] = "<v<>^>";
safetyCheck[1, 5] = "v^";
safetyCheck[1, 6] = "<v^>";
safetyCheck[1, 7] = "<v^>";
safetyCheck[1, 8] = "v^";
safetyCheck[1, 9] = safetyCheck[1, 19] = "<v^>";
safetyCheck[2, 3] = safetyCheck[2, 13] = "<>";
safetyCheck[2, 4] = "<<>>";
safetyCheck[2, 5] = safetyCheck[2, 15] = "v<>^";
safetyCheck[2, 6] = safetyCheck[2, 16] = "<<<<>>>>";
safetyCheck[2, 7] = "><";
safetyCheck[2, 8] = safetyCheck[2, 18] = "<>";
safetyCheck[2, 9] = safetyCheck[2, 19] = safetyCheck[2, 29] = "<>";
safetyCheck[3, 4] = "<>";
safetyCheck[3, 5] = "v^";
safetyCheck[3, 6] = ">><<";
safetyCheck[3, 7] = safetyCheck[3, 17] = "<<>>";
safetyCheck[3, 8] = safetyCheck[3, 18] = "v><^";
safetyCheck[3, 9] = safetyCheck[3, 19] = safetyCheck[3, 29] = "vvv^^^";
safetyCheck[4, 5] = safetyCheck[4, 15] = "<>";
safetyCheck[4, 6] = safetyCheck[4, 16] = "<<>>";
safetyCheck[4, 7] = ">v^<";
safetyCheck[4, 8] = "v^";
safetyCheck[4, 9] = safetyCheck[4, 19] = safetyCheck[4, 29] = "<>";
safetyCheck[5, 6] = "<>";
safetyCheck[5, 7] = "><";
safetyCheck[5, 8] = "<>";
safetyCheck[5, 9] = safetyCheck[5, 19] = "<<>>";
safetyCheck[6, 7] = "><";
safetyCheck[6, 8] = safetyCheck[6, 18] = "<>";
safetyCheck[6, 9] = "v^";
safetyCheck[7, 8] = safetyCheck[7, 18] = "v><^";
safetyCheck[7, 9] = safetyCheck[7, 19] = safetyCheck[7, 29] = "<>";
safetyCheck[8, 9] = safetyCheck[8, 19] = safetyCheck[8, 29] = "<>";

minions = {};
For[i = 0, i < 10, ++i,
  collector = "c";
  For[j = i, j < 90, j += 10,
   collector = collector <> path[i, j, j + 10] <> "c"
   ];
  AppendTo[minions, collector];
  For[newI = i + 1, newI < 10, ++newI,
   For[k = 0, k < 10, ++k,
    AppendTo[minions, 
     path[i, j, 10 k + newI] <> "c" <> path[newI, 10 k + newI, newI] <>
       safetyCheck[i, 10 k + newI]]
    ]
   ]
  ];
StringRiffle[minions, "\n"]

Я фактично написав усі ці safetyCheckрядки вручну. Але перший рядок цього коду Mathematica насправді складає близько 28000 символів і сам був генерований наступним кодом CJam:

'{o
q~]{-1:W;
2b200Te[W%2/{W):W;~\{
  "{"W+","W)++",\">\"}"+
  "{"W)+","W++",\"<\"}"+
  @
}*{
  "{"W+","WA+++",\"v\"}"+
  "{"WA++","W++",\"^\"}"+
}*}%", "*"Labeled[DirectedEdge[#,#2],#3]&@@@{ }"S/\*

]o',oNoNo}/'}

(Котрий приймає 10 макетів, жорстко закодованих в інтерпретатор. Ви можете запустити код в Інтернеті. )

Генерація коду-ception!

Пояснення

Для початку перегляньте цей сценарій CJam, щоб побачити, як виглядають лабіринти.

Моє рішення ґрунтується на одному важливому спостереженні: доки ми збираємо елементи вздовж одного стовпця, ми не будемо змінюватись між макетами, незалежно від того, заповнені клітини чи ні. Зокрема, поки ми рухатимемося по лівій лівій колонці, ми залишатимемося у макеті 0. Поки ми рухатимемося по наступній колонці, ми залишатимемося у макеті 1.

Складний біт полягає в тому, як переконатися, що ми змінилися між макетами, тому що ми не знаємо, у яких комірках стовпця 1є елементи на них (якщо такі є!).

Отже ось алгоритм (починаючи з комірки 0в макеті 0):

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

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

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

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

3. Зараз ми успішно перейшли до верхньої частини наступного стовпця, який містить принаймні один елемент. Поверніться до кроку 1.

Ви можете помітити, що структура розчину така:

Line with 10 "c"s
90 lines with 1 "c"
Line with 10 "c"s
80 lines with 1 "c"
Line with 10 "c"s
70 lines with 1 "c"
Line with 10 "c"s
60 lines with 1 "c"
...
Line with 10 "c"s
10 lines with 1 "c"
Line with 10 "c"s

Що стосується коду Mathematica, то safetyCheckрядки - це ті рушійні рухи, які гарантують, що ми дійшли до нового макета. Перший параметр пошуку - це макет, з якого ми починаємо, а другий - клітина, яку ми намагалися. Будь-які комбінації, які прямо не вказані, просто дають порожню перевірку безпеки (тому що жодна не потрібна).

На додаток до цього, я просто встановлюю 10 лабіринтів як Graphоб'єкти, де є два спрямовані краї між будь-якими сусідніми (і з'єднаними) клітинками, де кожен край позначається з переміщенням, необхідним для проходження краю. Маючи це на місці, я можу просто знайти шляхи, використовуючи, FindShortestPathа потім витягнути відповідні позначки краю PropertyValue[..., EdgeLabels].

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

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

HPR, за Zgarb

Кодекс:

#(*#(!(-)(#(-)()))()!(-)(-)#(!(-)(#(-)()))())(!(-)(#(-)()))#(!(#(!(#(!(-)(#(-)())*#(!(-)(#(-)()))())(!(-)(#(-)()))#(!(-)(#(-)()))())(!(!(-)(#(-)())#(!(-)(#(-)()))())(!(!(-)(#(-)())#(!(-)(#(-)()))())(!(!(-)(#(-)())#(!(-)(#(-)()))())(!(-)(!(!(-)(#(-)())#(!(-)(#(-)()))())(!(!(-)(#(-)())#(!(-)(#(-)()))())(!(!(-)(#(-)())#(!(-)(#(-)()))())(!(!(-)(#(-)())#(!(-)(#(-)()))())(#(*)()#(!(-)(#(-)()))()))))#(!(-)(#(-)()))())#(!(-)(#(-)()))())))!(-)(#(-)()))#(!(-)(#(-)()))())(!(#(!(-)(#(-)())*#(!(-)(#(-)()))())(!(-)(#(-)()))!(-)(#(-)()))(!(!(-)(#(-)())#(!(-)(#(-)()))())(!(!(-)(#(-)())#(!(-)(#(-)()))())(!(!(-)(#(-)())#(!(-)(#(-)()))())(!(-)(!(!(-)(#(-)())#(!(-)(#(-)()))())(!(!(-)(#(-)())#(!(-)(#(-)()))())(!(!(-)(#(-)())#(!(-)(#(-)()))())(!(!(-)(#(-)())#(!(-)(#(-)()))())(#(*)()#(!(-)(#(-)()))()))))#(!(-)(#(-)()))())#(!(-)(#(-)()))())))#(!(-)(#(-)()))())!(-)(#(-)()))#(#(!(-)(#(-)()))())(*!(-)(#(-)())))(#(*)())#(!(-)(#(-)()))())(!(-)(#(-)()))!($)(!(!(-)(#(-)())#(!(-)(#(-)()))())(!(!(-)(#(-)())#(!(-)(#(-)()))())(#(*)()#(!(-)(#(-)()))())))#(#(!(-)(#(-)()))())(*!(-)(#(-)()))#(*#(!(-)(#(-)()))()!(-)(-)#(!(-)(#(-)()))())(!(-)(#(-)()))#(!(#(!(#(!(-)(#(-)())*#(!(-)(#(-)()))())(!(-)(#(-)()))#(!(-)(#(-)()))())(!(!(-)(#(-)())#(!(-)(#(-)()))())(!(!(-)(#(-)())#(!(-)(#(-)()))())(!(!(-)(#(-)())#(!(-)(#(-)()))())(!(-)(!(!(-)(#(-)())#(!(-)(#(-)()))())(!(!(-)(#(-)())#(!(-)(#(-)()))())(!(!(-)(#(-)())#(!(-)(#(-)()))())(!(!(-)(#(-)())#(!(-)(#(-)()))())(#(*)()#(!(-)(#(-)()))()))))#(!(-)(#(-)()))())#(!(-)(#(-)()))())))!(-)(#(-)()))#(!(-)(#(-)()))())(!(#(!(-)(#(-)())*#(!(-)(#(-)()))())(!(-)(#(-)()))!(-)(#(-)()))(!(!(-)(#(-)())#(!(-)(#(-)()))())(!(!(-)(#(-)())#(!(-)(#(-)()))())(!(!(-)(#(-)())#(!(-)(#(-)()))())(!(-)(!(!(-)(#(-)())#(!(-)(#(-)()))())(!(!(-)(#(-)())#(!(-)(#(-)()))())(!(!(-)(#(-)())#(!(-)(#(-)()))())(!(!(-)(#(-)())#(!(-)(#(-)()))())(#(*)()#(!(-)(#(-)()))()))))#(!(-)(#(-)()))())#(!(-)(#(-)()))())))#(!(-)(#(-)()))())!(-)(#(-)()))#(#(!(-)(#(-)()))())(*!(-)(#(-)())))(#(*)())#(!(-)(#(-)()))())(!(-)(#(-)()))!($)(!(!(-)(#(-)())#(!(-)(#(-)()))())(!(!(-)(#(-)())#(!(-)(#(-)()))())(#(*)()#(!(-)(#(-)()))())))#(#(!(-)(#(-)()))())(*!(-)(#(-)()))#(*#(!(-)(#(-)()))()!(-)(-)#(!(-)(#(-)()))())(!(-)(#(-)()))#(!(#(!(#(!(-)(#(-)())*#(!(-)(#(-)()))())(!(-)(#(-)()))#(!(-)(#(-)()))())(!(!(-)(#(-)())#(!(-)(#(-)()))())(!(!(-)(#(-)())#(!(-)(#(-)()))())(!(!(-)(#(-)())#(!(-)(#(-)()))())(!(-)(!(!(-)(#(-)())#(!(-)(#(-)()))())(!(!(-)(#(-)())#(!(-)(#(-)()))())(!(!(-)(#(-)())#(!(-)(#(-)()))())(!(!(-)(#(-)())#(!(-)(#(-)()))())(#(*)()#(!(-)(#(-)()))()))))#(!(-)(#(-)()))())#(!(-)(#(-)()))())))!(-)(#(-)()))#(!(-)(#(-)()))())(!(#(!(-)(#(-)())*#(!(-)(#(-)()))())(!(-)(#(-)()))!(-)(#(-)()))(!(!(-)(#(-)())#(!(-)(#(-)()))())(!(!(-)(#(-)())#(!(-)(#(-)()))())(!(!(-)(#(-)())#(!(-)(#(-)()))())(!(-)(!(!(-)(#(-)())#(!(-)(#(-)()))())(!(!(-)(#(-)())#(!(-)(#(-)()))())(!(!(-)(#(-)())#(!(-)(#(-)()))())(!(!(-)(#(-)())#(!(-)(#(-)()))())(#(*)()#(!(-)(#(-)()))()))))#(!(-)(#(-)()))())#(!(-)(#(-)()))())))#(!(-)(#(-)()))())!(-)(#(-)()))#(#(!(-)(#(-)()))())(*!(-)(#(-)())))(#(*)())#(!(-)(#(-)()))())(!(-)(#(-)()))!($)(!(!(-)(#(-)())#(!(-)(#(-)()))())(!(!(-)(#(-)())#(!(-)(#(-)()))())(#(*)()#(!(-)(#(-)()))())))!(#(*#(!(-)(#(-)()))())(!(-)(#(-)()))-)(#(#(*#(!(-)(#(-)()))())(!(-)(#(-)()))-)())#(!(-)(#(-)()))()

Перш за все ... код був створений, а не написаний від руки (або набраний).

Факти про мову:

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

Програма використовує такий psuedocode:

global item
global list = input()

biggest()
remove()
biggest()
remove()
biggest()
print()

def remove():
    while item != list[0]:
        rotate_list
    list.remove(0)
def print():
    rotate_list until item == list[0]
    do until no change:
        list.pop()
        subtract
    removeList()
def biggest():
    item = 0
    while hasListWithElements():
        if item < list1[0]:
            item = list1[0]
        list.remove(0)
    restore list

Середовище майже завжди містить лише 1 список та 1 ціле число.

Для того, щоб вирішити це, я створив невеликий макромотор для цієї мови. Це також дозволяє коментувати. Ось макро-движок:

import sys

code = {}


filename = sys.argv[1]
f = open(filename, 'r')
prog = f.read()
f.close()

def c(prog):
    for n in prog.splitlines():
        if n.startswith('def'):
            parts = n[4:].split(' ', 2)
            code[parts[0]] = int(parts[1]) ,parts[2]
            prog = prog.replace(n, '', 1)
        elif n.strip().startswith('//'):
            prog = prog.replace(n, '', 1)
    return compile(prog)

def compile(prog):
    ret = ''
    while prog:
        n = prog[0]
        if n == '<':
            name = prog[1:prog.find('>')]
            args_count, formatter = code[name]
            if args_count == 0:
                prog = prog[prog.find('>') + 1:]
                ret += compile(formatter)[0]
                continue;
            prog = prog[prog.find('>') + 2:]
            args = []
            for n in range(args_count):
                arg, prog = compile(prog)
                if n == args_count - 1:
                    arg = arg[:-1]
                args.append(arg)
            ret += compile(formatter.format(*args))[0]
        elif n == ')':
            return ret + ')', prog[1:]
        elif n == ',':
            return ret, prog[1:]
        elif n == '(':
            c, prog = compile(prog[1:])
            ret += '(' + c
        else:
            ret += n
            prog = prog[1:]
    return ret.replace('\n','').replace(' ',''), prog

print(c(prog)[0]) #Use pipes to put into file.

Після того, як я створив макро-движок, я повільно створив корисні функції для цієї мови. Ось код, який двигун обробив для створення програми:

//While loop
def w 2 !({1})({0})

//Detects changes
def c 1 #({0})()

//Do while it changes:
def wc 1 <w>(<c>({0}), {0})

//Remove all items:
def rint 0 <wc>(-)

//Contains list:
def clist 0 <rint>

//Remove all lists:
def rlist 0 #(<rint>)()

//Contains item:
def cint 0 <rlist>

//False (empty environment):
def false 0 <rint><rlist>

//Not:
def not 1 !(<false>)({0})

//Bool (if expression does not evaluate to an empty environment,
// restore the environment to its previous state.
def bool 1 <not>(<not>({0}))

//And
def and 2 <bool>({0}){1}

//Or
def or 2 <not>(<and>(<not>({0}), <not>({1})))

//Combine parts (takes the integer parts of first argument and 
//combines them with the list parts of second argument):
def p 2 #({0}<rlist>)({1}<rint>)

//If, executes an expression if condition evalutates to true. Only works in standard environment.
def if 2 <p>(!({1}<rlist>)(<and>({0}, <rint>)),!({1}<rint>)(<and>({0}, <rlist>)))

//equal (compares item to list[0]) for equality:
def eq 0 <not>(#(*)()<rlist>)

//list.remove(0), does not change item:
def listr 0 <p>(, *)

//remove, removes item from list, goes into infinite loop if list does not contain item.
def remove 0 <w>(<not>(<eq>), $)<listr>

//Greater than or equal, item >= list[0]: 
def ge 0 <w>(<and>(<not>(<eq>), <rlist>), -)<rlist>

//Less than, item < list[0]:
def lt 0 <not>(<ge>)

//Zero, sets item to zero:
def zero 0 <p>(*<rlist>!(-)(-), )

//Biggest, puts biggest item in the list into item:
def biggest 0 <zero><p>(<w>(<c>(*), <if>(<lt>, <p>(<rint>*, ))<listr>), )

//print item, item must be somewhere on list.
def print 0 <w>(<not>(<eq>), $)<wc>(<p>(*, )-)<rlist>

//The actual program!!!!
<biggest>
<remove>
<biggest>
<remove>
<biggest>
<print>

Брайан і Чак Мартіна Бюттнера

Наступна програма Python 2.7 видає мою програму Brian & Chuck, переклавши програму brainfuck в Brian & Chuck (за винятком того, що .завжди друкується 1, оскільки це єдиний символ, який нам потрібен для виведення).

Контрольний потік працює за допомогою магії, коли Брайан виписує на команди стрічки Чака, щоб переслати Брайана до правильної позиції в коді.

Зауважте, що пробіли та []s, додані до програми B&C, є лише декоративними.

def brainfuck_to_brianchuck(code):
    # find biggest jump needed
    biggest_jump = 0
    idx = 0
    while idx < len(code):
        if code[idx] == '[':
            end = matching_bracket(code,idx)
            jump = sum(c == '[' for c in code[idx:end])
            if jump > biggest_jump:
                biggest_jump = jump
            idx = end
        idx += 1
    block_size = biggest_jump*4 + 4

    fragments = []
    depth = 0
    for idx,c in enumerate(code):
        if c in '<>':
            fragments.append(block_size*c)
        elif c == '[':
            end = matching_bracket(code,idx)
            jump = sum(c == '[' for c in code[idx:end])
            fragments.append('\n' + '  '*depth)
            fragments.append('[ ' + open_while(jump))
            depth += 1
            fragments.append('\n' + '  '*depth)
        elif c == ']':
            start = matching_bracket(code,idx)
            jump = sum(c == '[' for c in code[start:idx])
            depth -= 1
            fragments.append('\n' + '  '*depth)
            fragments.append('] ' + close_while(jump))
            fragments.append('\n' + '  '*depth)
        elif c == '.':
            fragments.append('>' + write('0>.?',True) + '<<<?1<<<' + write('0>.?',False) + '<<<<')
        elif c in ',+-':
            fragments.append(c)
    return ''.join(fragments) + '\n```'


def open_while(jump):
    fragments = []

    right = '0' + '}>}>'*jump + '?'
    fragments.append('>' + write(right,True))
    r = len(right)-1
    fragments.append('<'*r + '?' + '_0')

    left = '{<{<'*jump + '>>?'
    l = len(left)-1
    fragments.append('<'*l)
    fragments.append(write(left,False))
    fragments.append('<'*l + '<')

    return ''.join(fragments)

def close_while(jump):
    fragments = []

    right = '0' + '}>}>'*jump + '?'
    fragments.append('>' + write(right,True))
    r = len(right)-1
    fragments.append('_0' + '<'*r)
    fragments.append(write(right,False))
    fragments.append('<'*r)

    left = '{<{<'*jump + '>>?'
    l = len(left)-1
    fragments.append(write(left,True))
    fragments.append('<'*l + '<' + '?>')
    fragments.append(write(left,False))
    fragments.append('<'*l + '<')

    return ''.join(fragments)

# returns the code to write s, or erase it if increment is False
def write(s,increment):
    c = '+' if increment else '-'
    return '>'.join(c*ord(a) for a in s)

def matching_bracket(code, idx):
    bracket = code[idx]
    other_bracket = ']' if bracket == '[' else '['
    direction = 1 if bracket == '[' else -1
    idx += direction
    while code[idx] != other_bracket:
        if code[idx] == bracket:
            idx = matching_bracket(code, idx)
        idx += direction
    return idx

print brainfuck_to_brianchuck('''
-
>,------------------------------------------------[
    ,------------------------------------------------[
        ->+>>>[>+<<<<->>>-]<[>+<<<->>-]<[>+<<->-]>>>[<+>-]<<<<[>+<-]
        >>>>>,------------------------------------------------
    ]
    <+[-<<<<<<+]-
    >,------------------------------------------------
]
>>>>[.>>>>>>].
''')

Firetype, автор kirbyfan64sos

Робочий, коментований код:

_ Beginning of the loop where one iteration reads one unary number.
- Decrement to cancel the next +, which is part of the loop.
+ Increment... this is executed once for each 1 we read.
, Read a character.
^ "eval"
# Negate.
* Double three times to get -8 if we read a 1 and 0 otherwise.
*
*
% If we read a 1, jump back to the +. Otherwise, continue.
# Negate the resulting number to reverse the sort order later.
` Duplicate...
~ Logical NOT twice, to turn non-zero results into 1 (zeroes remain zeroes).
~
* Double, double, square, double, negate, to get -32 if the last number
* we read was non-zero. The double-0 at the end of the input leads to a
| zero being read as a unary number, which we use as the termination
* condition. When this is the case, the current cell will be 0 instead  
# of -32. The next lines are padding to get the jump right...












% So... if the unary number was not 0, jump back to the _.
\ Sort the list... the sort is descending, but we negated all the values...
< That means the largest value next to the pointer now, just with a minus
< sign. We move to the left three times to find the place where the third
< largest value is.
# Negate to get its positive value again.
` Duplicate to ensure we've got a cell to the left of the result.
< Move left to the other copy.
~ Logical NOT twice, to turn it into a 1.
~
> Move right to the result.
! This moves the pointer to the left (onto the 1) and executes "." (print)
. "result" times, printing the result in unary. Yay!

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

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

Acc !, від DLosc

Цей мовний ланцюг має жахливу підтримку порівняння.

Count b while 0 {
}
Count c while 0 {
}
Count a while N-48 {
    Count q while N-48 {
    }
    Count a while _ {
        _ - 1
    }
    a - (q + 1)
    Count z while (z-(10^6+1)) * (_ - z) {
    }
    Count x while (_ - z) {
       b
       Count c while _ {
           _ - 1
       }
       a
       Count b while _ {
           _ - 1
       }
       q
       Count a while _ {
           _ - 1
       }
       z
    }
    z-((10^6)+1)
    Count x while _ {
        b - (q + 1)
        Count f while (f-(10^6+1)) * (_ - f) {
        }
        Count x while (_ - f) {
            b
            Count c while _ {
                _ - 1
            }
            q
            Count b while _ {
                _ - 1
            }
            f
        }
        f-((10^6)+1)
        Count x while _ {
            c - (q + 1)
            Count k while (k-(10^6+1)) * (_ - k) {
            }
            Count x while (_ - k) {
                q
                Count c while _ {
                    _ - 1
                }
                k
            }
            0
        }
        0
    }
    0
    Count j while (a - _) {
        _ + 1
    }
}
c
Write 49
Count h while _ {
    Write 49
    _ - 1
}

У count [varname] while 0заяві на початку повинні оголосити змінний , що містять найбільшу кількість, друге по величині числа, треті по величині числа, і так далі. Порівняння здійснюється шляхом віднімання двох чисел, а потім перевірки, чи результат негативний, перевіряючи, чи є це число меншим від цього 10^6.

Цинк, автор kirbyfan64sos

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

let
+=cut
in {d:{c:({b:{a:S^((#S)-_)-1}^_})+0$#c}^_=2}

Пояснення

У першій і другій рядків, я визначити +, є cutоперація. Решта - це встановлені розуміння. Візьмемо вклад 101011101100як приклад і почнемо з найглибшого:

{a:S^((#S)-_)-1}

Це бере ті елементи aз набору входів S = {1,0,1,0,1,1,1,0,1,1,0,0}, індекс яких не є len(S)-1, тому всі, крім останнього. Я помітив, що це також перевертає набір, тому результат є A = {0,1,1,0,1,1,1,0,1,0,1}. Далі розуміння

{b:A^_}

бере всі елементи, Aкрім першого, і перевертає його знову, в результаті чого B = {1,0,1,0,1,1,1,0,1,1}. Потім ми розділилися Bна 0s (це призводить до {1,1,{1,1,1},{1,1}}або його відміни, я не перевіряв, який з них), і сортуємо результат за довжиною. Набори синглтон сплющені, але всі вони 1s, тому їх довжина все ще 1. Ось код:

{c:(B)+0$#c}

Результатом цього є C = {{1,1,1},{1,1},1,1}. Нарешті, ми фільтруємо все, крім елемента в індексі 2, по

{d:C^_=2}

Це призводить до набору D = {1}в нашому випадку. Взагалі він може мати форму {{1,1,..,1}}, але це не має значення, оскільки 1друкуються лише s.

Суп з компасом, BMac

Це було весело.

Редагувати: для роботи над інтерпретатором BMac ця програма повинна бути попередньо створена новим рядком. Я не можу отримати новий рядок у блоці коду.

!p#eXj0sXj0sp#exj#ss
   n Apw   w  n   w
s                  w
     s    w s         w   s    w         s    w           e s
eXj0seXj0sn ep0Yp+yXj0nYp#exj+sneXp exj#seXj+snep+eXj#sxj+nseXp exj#ss
n   w    ej#ns                e n   n   w    e n  n   w         n   w
                          n                                w         
s                                                                    w
             e          s
    y
s                     Yw
eXj+np yjCs       C    n
          ejBs    B pC n
                e A pB n
             ej0n 0 pA n
s                       w
              e s
exj#s X   eXj#nsejCsp1s
n   w     n        w  w
               w
@>
#

Програма поділена на 4 секції виконання.

Перший, у рядку 1, додає a #до кінця вводу шляхом пошуку 00та заміни 2-го 0на #. Він також змінює всі 1s на As, оскільки я хотів мати якомога менше 1s у вихідному коді.

Другий розділ, у рядку 5, отримує друге число у введенні та ставить його нижче першого числа у вигляді рядка +s. Наприклад, якщо вхід є 11011101100, то це призведе до наступного:

#AA00000AA0#
#+++

Третій розділ у рядку 12 поєднує рядок +s з першим числом: кожен 0над a +стає A, Aстає B, Bстає Cі Cзалишається незмінним. Після цього ми повертаємось до другого розділу, щоб отримати наступний номер.

Після того, як всі числа об’єднані таким чином, ми дістаємося до останнього розділу в рядку 18. Кількість Cs - це наш бажаний вихід, тому ми змінимо їх на 1s, пропустивши перше, Cтому що 1в вихідному коді є одне, яке друкується уздовж з виходом.