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

Мета - написати програму будь-якою мовою, яка робить все, що завгодно. Проблема полягає в тому, що програма повинна бути дійсною після будь-якого кругового переміщення символів.

Круговий зсув символів дуже схожий на круговий зсув . Деякі приклади моїх зрозумілих речей.

Для програми 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

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

Ідею можна було б поширити для створення будь-якої програми довільної складності.

Brainf * ck

Виберіть правильний інструмент для роботи - приказка, яка ніколи не була більш актуальною, ніж ця робота тут!

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

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

Commodore 64 BASIC

?скорочено 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:

тощо ...

Гольфскрипт

Ця програма друкує кілька цифр, які завжди дорівнюють 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

x86 16-бітний двійковий

Створено вручну за допомогою цих ( 1 2 ) таблиць, насма та 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?

Скала

Вкладені цитати:

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

C ++ / Java / C # / Scala

Коментар:

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

Порожня команда:

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

Баш

Прокоментуйте, комбінація Whitespace та Shellвбудована:

#

:

Сед

Автономні дійсні команди:

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││       │
│└───┘│       │
└─────┴───────┘

dc

Програми постійного струму легко дійсні в будь-якому обертанні. Наприклад:

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

Машинний код

Як щодо машинного коду Z80 / Intel 8051 для NOP .

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

І я не згоден з відповіддю Рубі вище - я думаю, що один байт 00h коротший, ніж Ruby p.

к

.""

Оцінює порожній рядок

"."

Повертає символ періоду

"".

Повертає часткове застосування '.' (діанічна форма) до порожнього списку символів.

ш, баш

cc
cc: no input files

скло обертається знову куб.см, але це не дуже дружньо, якщо його називають таким голим.

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

дк debhelper не надто кооперативна теж, в той час як шістнадцяткові просто чекає введення.

gs
sg 

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

І ось сценарій пошуку кандидатів у такі програми:

#!/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