Потенциально очень сложно, но я видел некоторые удивительные вещи, которые появились на этом сайте.

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

Циклический сдвиг символов очень похож на циклический сдвиг . Некоторые примеры моей ясности.

Для программы int main() { return 0; }

сдвиг влево на 6 символов дает: in() { return 0; }int ma

сдвиг влево на 1 символ дает: nt main() { return 0; }i

сдвиг вправо на 10 символов дает: eturn 0; }int main() { r

Однако эта программа явно не соответствует правилам.

правила

• Любой язык
• Победитель определяется путем подсчета голосов
• Решения, которые делают то же самое, или совершенно разные вещи для каждой ротации, получат 100 виртуальных голосов за свой счет.

ОБНОВЛЕНИЕ Я думаю, что это продолжалось достаточно долго. Победителем, получившим наибольшее количество голосов (включая виртуальные), стал Марк Байерс. Отлично сработано!

Используйте правильный язык для задачи. В данном случае это Befunge .

Этот язык, естественно, допускает ротацию, потому что:

• Все команды являются одним символом.
• Элемент управления оборачивается, когда достигает конца программы, начиная снова с начала.

Эта программа Befunge печатает точно такой же вывод («Hello») независимо от того, сколько «круговых сдвигов символов» вы используете:

86*01p75*1-02p447**1-03p439**04p439**05p455**1+06p662**07p75*1-08p645**2-09p69*4+019+p57*029+p59*1-039+p555**1-049+p88*059+p86*01p75*1-02p447**1-03p439**04p439**05p455**1+06p662**07p75*1-08p645**2-09p69*4+019+p57*029+p59*1-039+p555**1-049+p88*059+p645**2-00p645**2-00p

Это работает на Befungee . Требуется увеличить доску (не 80 символов по умолчанию). Это можно запустить так:

python befungee.py -w400 hello.bef

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

Идея может быть расширена для создания любой программы произвольной сложности.

Brainf * ск

Выберите правильный инструмент для работы - поговорка, которая никогда не была более актуальной, чем эта работа прямо здесь!

+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
++++++++++++++++++.>+++++++++++++++++++++++++++++++++++++++++++++
+++++++++++++++++++++++++++.+.>++++++++++++++++++++++++++++++++++
++++++++++++++++++++++++++++++++++++.++++++++++++++.>++++++++++.+

Нешифрованная программа, которую вы видите здесь, просто печатает SHIFT(плюс перевод строки). Абсолютно круговые сдвиги будут производить различные другие выходные данные, хотя он всегда будет выводить шесть символов ASCII.

Коммодор 64 Бейсик

?является сокращением PRINTи :является разделителем операторов, поэтому:

?1:?2:?3:          // prints 1, 2, and 3
:?1:?2:?3          // prints 1, 2, and 3
3:?1:?2:?          // adds a program line 3 :PRINT1:PRINT2:PRINT
?3:?1:?2:          // prints 3, 1, and 2
:?3:?1:?2          // prints 3, 1, and 2
2:?3:?1:?          // adds a program line 2 :PRINT3:PRINT1:PRINT
?2:?3:?1:          // prints 2, 3, and 1
:?2:?3:?1          // prints 2, 3, and 1
1:?2:?3:?          // adds a program line 1 :PRINT2:PRINT3:PRINT

Конечно, возможны более длинные вариации:

?1:?2:?3:?4:?5:?6:?7:?8:?9:?10:?11:

и т.д...

Golfscript

Эта программа печатает некоторые цифры, которые всегда составляют до 2, независимо от того, как программа сдвинута:

10 2 base
0 2 base1
 2 base10
2 base10 
 base10 2
base10 2 
ase10 2 b
se10 2 ba
e10 2 bas

Первая строка печатается 1010(10 в двоичном виде), вторая строка печатается 02и все остальные строки печатаются 2.

Обновить:

Программу можно протестировать здесь . Обратите внимание, что я добавил ns в конце каждой строки только для форматирования вывода; их можно удалить, и программа все еще работает.

Ruby, вероятно, одно из кратчайших возможных решений:

p

И еще немного длиннее и интереснее:

;;p";p;";p

16-битный двоичный файл x86

Сконструированы вручную с помощью этих ( 1 2 ) таблиц nasm и ndisasm. Это всегда будет возвращаться без сбоя или бесконечного цикла, потому что ни один байт не является переходом или изменяет стек, и он заполнен NOP, чтобы retв любом случае завершиться однобайтовой инструкцией.

В большинстве случаев это будет вывод FOOили подстрока этого. Если AXсломан, это будет вызывать случайный int 10 (это изменило скорость мигания курсора в одном из моих тестов), но обычно это не приводит к сбою.

Чтобы попробовать, поместите hexdump в файл и используйте xxd -r foo.hex > foo.com , затем запустите в среде dos (я использовал dosbox).

Вот шестнадцатеричный дамп этого файла:

0000000: b846 0d90 90fe c490 9090 bb05 0090 9043  .F.............C
0000010: 43cd 1090 b84f 0d90 90fe c490 9090 bb05  C....O..........
0000020: 0090 9043 43cd 1090 b84f 0d90 90fe c490  ...CC....O......
0000030: 9090 bb05 0090 9043 43cd 1090 9090 c3    .......CC......

И несколько интересных разобранных смещений:

+0

00000000  B8420D            mov ax,0xd42
00000003  90                nop
00000004  90                nop
00000005  FEC4              inc ah
00000007  90                nop
00000008  90                nop
00000009  90                nop
0000000A  BB0500            mov bx,0x5
0000000D  90                nop
0000000E  90                nop
0000000F  43                inc bx
00000010  43                inc bx
00000011  CD10              int 0x10
00000013  90                nop
00000014  B84F0D            mov ax,0xd4f
00000017  90                nop
00000018  90                nop
00000019  FEC4              inc ah
0000001B  90                nop
0000001C  90                nop
0000001D  90                nop
0000001E  BB0500            mov bx,0x5
00000021  90                nop
00000022  90                nop
00000023  43                inc bx
00000024  43                inc bx
00000025  CD10              int 0x10
00000027  90                nop
00000028  B84F0D            mov ax,0xd4f
0000002B  90                nop
0000002C  90                nop
0000002D  FEC4              inc ah
0000002F  90                nop
00000030  90                nop 
00000031  90                nop
00000032  BB0500            mov bx,0x5
00000035  90                nop
00000036  90                nop
00000037  43                inc bx
00000038  43                inc bx
00000039  CD10              int 0x10
0000003B  90                nop
0000003C  90                nop
0000003D  90                nop
0000003E  C3                ret

(для примеров ниже, остальная часть двоичного файла все еще действительна)

+1

00000000  42                inc dx
00000001  0D9090            or ax,0x9090
00000004  FEC4              inc ah
00000006  90                nop

+2

00000001  0D9090            or ax,0x9090
00000004  FEC4              inc ah
00000006  90                nop

+6

00000000  C4909090          les dx,[bx+si-0x6f70]
00000004  BB0500            mov bx,0x5
00000007  90                nop
00000008  90                nop
00000009  43                inc bx
0000000A  43                inc bx
0000000B  CD10              int 0x10

+11

00000000  050090            add ax,0x9000
00000003  90                nop
00000004  43                inc bx
00000005  43                inc bx
00000006  CD10              int 0x10

+12

00000000  00909043          add [bx+si+0x4390],dl
00000004  43                inc bx
00000005  CD10              int 0x10

+18

00000000  1090B84F          adc [bx+si+0x4fb8],dl
00000004  0D9090            or ax,0x9090
00000007  FEC4              inc ah
00000009  90                nop

(другие смещения - просто повторения вышеупомянутого)

+58

00000000  10909090          adc [bx+si-0x6f70],dl
00000004  C3                ret

Унарный ответ:

000000 ... 00000

^ 44391 Нули

Кошачья программа. Независимо от того, как вы вращаете, это одна и та же программа.

PHP

Вот, пожалуйста, действующая PHP-программа:

Is this still funny?

Scala

Вложенные цитаты:

""""""""""""""""""""""""""""""""

C ++ / Java / C # / Scala

Комментарий:

///////////////////////////////////

Пустая команда:

;;;;;;;;;;;;;;;

удар

Комбинация комментариев, пробелов и оболочки:

#

:

Sed

Автономные действующие команды:

p P n N g G d D h H

Сочетание вышеперечисленного:

p;P;n;N;g;G;d;D;h;H;

AWK

Чтобы напечатать каждую строку файла:

1

или

//

Не печатайте ничего:

0

Perl

abcd

J

Во-первых, скрипт для проверки правильности вращения программы s:

check =: 3 :'((<;(". :: (''Err''"_)))@:(y |.~]))"0 i.#y'

Например, программа +/1 5(сумма 1 и 5) дает:

 check '+/1 5'
┌───────┬───┐
│┌─────┐│6  │
││+/1 5││   │
│└─────┘│   │
├───────┼───┤
│┌─────┐│Err│
││/1 5+││   │
│└─────┘│   │
├───────┼───┤
│┌─────┐│Err│
││1 5+/││   │
│└─────┘│   │
├───────┼───┤
│┌─────┐│6  │
││ 5+/1││   │
│└─────┘│   │
├───────┼───┤
│┌─────┐│6  │
││5+/1 ││   │
│└─────┘│   │
└───────┴───┘

Тогда скучная, действительная программа:

check '1x1'
┌─────┬───────┐
│┌───┐│2.71828│ NB. e^1
││1x1││       │
│└───┘│       │
├─────┼───────┤
│┌───┐│       │ NB. Value of variable x11
││x11││       │ 
│└───┘│       │
├─────┼───────┤
│┌───┐│11     │ NB. Arbitrary precision integer
││11x││       │
│└───┘│       │
└─────┴───────┘

Округ Колумбия

Программы постоянного тока легко действуют в любой ротации. Например:

4 8 * 2 + p  # 34
8 * 2 + p 4  # stack empty / 10
...

Машинный код

Как насчет машинного кода Z80 / Intel 8051 для NOP .

Конечно, он не выполняет никаких операций, но он занимает один или два цикла ... вы можете иметь их столько, сколько захотите.

И я не согласен с ответом Ruby выше - я думаю, что один байт 00h короче, чем Ruby p.

К

.""

Оценивает пустую строку

"."

Возвращает символ периода

"".

Возвращает частичное применение '.' (дианическая форма) в пустой список символов.

ш, баш

cc
cc: no input files

cc rotated - это снова cc, но это не очень дружелюбно, если его так назвать голым.

dh 
dh: cannot read debian/control: No such file or directory
hd 

dh debhelper тоже не очень помогает , в то время как hexdump просто ждет ввода.

gs
sg 

Ghostscript запускает интерактивный режим, в то время как группа переключателей отображает сообщение об использовании - правильное решение и здесь, imho.

А вот и скрипт для поиска кандидатов на такие программы:

#!/bin/bash
for name in /sbin/* /usr/sbin/* /bin/* /usr/bin/*
do 
    len=${#name}
    # len=3 => 1:2 0:1, 2:1 0:2
    # len=4 => 1:3 0:1, 2:2 0:2, 3:1 0:3
    for n in $(seq 1 $((len-1)))
    do
        init=${name:n:len-n}
        rest=${name:0:n}
        # echo $init$rest
        which /usr/bin/$init$rest 2>/dev/null >/dev/null && echo $name $init$rest $n
    done 
done

Если также находит более длинные последовательности, такие как (arj, jar) или (luatex, texlua), которые недействительны после каждой смены, но только после некоторых определенных смен, которые я неправильно прочитал в начале, но их немного, так что это легко отфильтровать их вручную.

Тривиальный пример Python:

"a""b""c""d""e""f""g""h""i""j""k""l""m""n""o""p""q""r""s""t""u""v""w""x""y""z""";print

Может быть смещено три символа повторно, чтобы раскрыть все больше и больше алфавита.

питон

123456789.0

Просто оцените некоторые цифры

dc уже используется, но следующая программа всегда выдает одно и то же , независимо от поворота: D

d

Выходы

dc: stack empty