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

Пожалуйста, включите начальный источник, а также конечный источник в ваш пост, а также описание. Например, опишите, что (еще) делает ваша программа, язык, который вы использовали, вашу стратегию и т. Д.

правила

• Ваша программа должна остановиться через некоторое время после завершения модификации.
• Он должен фактически изменить свой собственный, в настоящее время работающий исходный код (не обязательно файл, который вы передали интерпретатору, он изменяет его инструкции), а не печатать новую программу или писать новый файл.
• Стандартные лазейки запрещены.

• Кратчайшая программа выигрывает.

• Если ваш язык может изменить свой собственный файл и выполнить новый процесс компилятора, но не может изменить свой собственный (в настоящее время работающий) исходный код, вы можете вместо этого написать такую ​​программу со штрафом + 20% байтов, округленным в большую сторону. Реальные самоизменяющиеся языки должны иметь преимущество.

Изменить : Если ваша программа останавливается с ошибками, пожалуйста, укажите его как таковой (и, возможно, сказать, что ошибки.)

/// , 1 байт

/

Программа находит /(начало группы замены шаблона) и удаляет ее при подготовке к замене. Затем он достигает EOF, поэтому он сдается и останавливается.

Лабиринт , 2 байта

>@

В >вращает источник , так что он становится

@>

Указатель инструкции теперь находится в тупике и поворачивается, чтобы ударить, @что завершает программу.

Конечно, <@тоже будет работать.

Python 2, 225 байт

import sys
from ctypes import*
c=sys._getframe().f_code.co_code
i=c_int
p=POINTER
class S(Structure):_fields_=zip("r"*9+"v",(i,c_void_p,i,c_char_p,i,p(i),i,c_long,i,c_char*len(c)))
cast(id(c),p(S)).contents.v=`len([])`*len(c)

Конечный исходный код представляет собой строку "0"s, длина которой равна числу байтов в исходном объекте скомпилированного кода.

Код находит работающий объект кода sys._getframe().f_code.co_codeи создает структуру, которая представляет объекты строки Python. Затем он получает память, которую фактически занимает код, и заменяет ее "0"*len(c).

При запуске программа завершается со следующей трассировкой:

XXX lineno: 7, opcode: 49
Traceback (most recent call last):
  File "main.py", line 7, in <module>
    cast(id(c),p(S)).contents.v=`1+1`*len(c)
SystemError: unknown opcode

Это показывает, что перезапись была успешной, и программа умирает, потому что 0не является действительным кодом операции.

Я удивлен, что это даже возможно в python, фреймы доступны только для чтения, я не могу создавать новые. Единственная сложная вещь, которую это делает, - это изменение неизменяемого объекта (строки).

зло , 1 байт

q

У зла есть несколько хранилищ памяти: один - это сам исходный код, а другой - колесо, представляющее собой круговую очередь, которая инициализируется одним нулем. qменяет местами исходный код и колесо, поэтому он заменяет исходный код нулевым байтом. Тем не менее, только строчные буквы являются действительными операторами зла, поэтому этот символ просто не используется, и программа завершается.

МСМ , 8 байт

'.qp.;.;

Преобразует исходный код в pqpqpqpq

МСМ оперирует списком строк. Команды берутся слева и обрабатывают правую сторону как стек. МСМ всегда работает на свой собственный источник.

Трассировка выполнения:

'.qp.;.;                       upon start the source is implicitly split into a
                               list of single char strings

' . q p . ; . ;                ' takes the next element and pushes it on the stack
    q p . ; . ; .              q is not a command so it's pushed
      p . ; . ; . q            same for p
        . ; . ; . q p          . concats the top and next to top element
          ; . ; . pq           ; duplicates the top element
            . ; . pq pq        concat
              ; . pqpq         dup
                . pqpq pqpq    concat
                  pqpqpqpq     MSM stops when there's only one element left      

Malbolge, 1 или 2 байта.

D

Язык Malbolge «шифрует» каждую инструкцию после ее выполнения, поэтому это письмо (Malbolge NOP) станет !(что также является nop), а затем завершится. По какой-то причине для использования интерпретатора Malbolge, который я использую, требуется два байта, что дает DC(оба из которых являются nops) ставшими !U(оба из которых также являются nops)

Редактирование: начальное состояние памяти Malbolge зависит от последних двух символов в коде, поэтому оно не является четко определенным для односимвольных программ. (Хотя этот код не заботится о начальном состоянии памяти)

x86 asm - 6 байт

не уверен, относится ли «до тех пор, пока каждый символ источника отличается от того, с которого он начинался», относится к каждому байту, каждому немоническому или общему изменению. если я неверный, я могу изменить xor на rep xor, чтобы каждый бит менял значения, но надеялся не делать этого, чтобы сохранить еще 6 байтов, чтобы они оставались хотя бы немного сравнимыми с этими специальными языками гольфа.

Все, что это делает, это изменяет c2 на c3 retn, получая действующий адрес eip и хоринг 5 байтов впереди.

58          | pop eax                        ; store addr of eip in eax
83 70 05 01 | xor dword ptr ds:[eax + 5], 1  ; c2 ^ 1 = c3 = RETN
c2          | retn                           ; leave

SMBF , 92 байта

Может быть в гольф, и я, вероятно, над этим поработаю позже.

>>+>>+>>+>>+>>+>>+[<-[>+<---]>+++++<<]>>>>>--[>-<++++++]>--->>++>+++++[>------<-]>->>++[<<]<

объяснение

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

[[-]<]          ASCII: 91 91 45 93 60 93

Создайте связку 91s с нулями (показано как _) между ними для использования в качестве временных значений.

>>+>>+>>+>>+>>+>>+[<-[>+<---]>+++++<<]

code__91_91_91_91_91_91_
   ^

Отрегулируйте значения по различиям

>>>>>--[>-<++++++]>---  Sub 46
>>++                    Add 2
>+++++[>------<-]>-     Sub 31
>>++                    Add 2
[<<]<                   Shift left to the code
code__[_[_-_]_<_]_      Zero out the code
   ^

Лента после выполнения будет иметь все нули, за исключением сгенерированного кода [_[_-_]_<_].

Замечания:

Эта программа дала мне понять, что мой интерпретатор Python для SMBF имеет одну или две ошибки, и я еще не нашел исправления. Это исправлено сейчас.

Emacs Lisp 22 байта

(defun a()(defun a()))

Запустить из REPL:

ELISP> (defun a()(defun a()))
a
ELISP> (symbol-function 'a)
(lambda nil
  (defun a nil))

ELISP> (a)
a
ELISP> (symbol-function 'a)
(lambda nil nil)

Функция теперь оценивается как nil.

Поочередно (отвязать себя) 30 байтов

(defun a()(fmakunbound 'a)(a))

Оцените и ошибки как void-function. Функция существовала до запуска.

Redcode , 7 байт, 1 инструкция (просто пример. Не конкурирует)

Это тривиальный пример.

Перемещает следующую ячейку памяти на себя, затем останавливает (потому что инициализируется вся память DAT 0 0, что останавливает программу при выполнении.)

MOV 1 0

Powershell 65 байт

function a{si -pat:function:a -va:([scriptblock]::create($null))}

Определите функцию, которая переписывает себя в нуль.

Оцените это один раз, и оно само себя устраняет.

Поочередно (удаляет себя из памяти) 36 байт

function a{remove-item function:a;a}

Вызов его сначала удаляет, а затем пытается рекурсивно оценить. Ошибка как неизвестная команда.

MIXAL, 6 байт (считая 2 вкладки)

    STZ    0

Программа запускается в ячейке памяти 0, а затем записывает 0 в ячейку памяти 0, тем самым стирая себя. Машина останавливается автоматически.

Это язык ассемблера для гипотетического компьютера MIX Дональда Кнута, который может быть собран и запущен с использованием комплекта разработки GNU MIX ( https://www.gnu.org/software/mdk/ ).

> <> , 40 34 30 байт

0&00a6*0&1+:&060"c"l=?!.~~r >p

Попробуй это здесь!

Объяснение:

0&          Adds 0 to the registry
00a6*       Adds "0,0,<" to the stack; coords followed by a character
------------loop start (for clarity)
0           0 added to stack
&1+:&       Registry retrieved, increased by 1, duplicated, one put back in registry
0           ASCII character 0 added to stack (just a 0 but will be converted to that character when inserted in the code)
60          6 and 0 added to stack
"c"         The number 99 added to stack (length of code + 1 * 3)
l=?         Code length added to stack, checks if it is equal to 111

!.          If false, pointer jumps back to character (9,0) (loop start position)
~~r >p      If true, removes the 0 and 9, reverses stack, then loops the p command setting
all the characters to a "<" character and the 2nd character to a " "

По сути, это помещает в стек набор из 3-х символьных блоков следующим образом: (ypos, xpos, ASCII символ), который в конце переворачивается, поэтому последняя команда 'p' читает (символ, xpos, ypos) и устанавливает эту позицию в код для этого символа. Первый символ вручную устанавливается как «<», так что код заканчивается в конце как «> p <» для цикла команды. Затем каждый другой символ перезаписывается как '', включая символ p. '' На самом деле является "ASCII CHAR 0", который НЕ является NOP и выдаст ошибку при чтении.

Кроме того, перед командой «p» должно быть нечетное (?) Количество символов, иначе оно не будет возвращено в последний раз и перезаписано.

Пакет, 11 байт

@echo>%0&&*

Изменяет исходный код ECHO is on.

@           - don't echo the command.
 echo       - print ECHO is on.
     >%0    - write to own file.
        &&* - execute * command after the above is done, * doesn't exist so program halts.

Это @есть, поэтому команда не отображается, но в основном так, чтобы эти две echoстроки не совпадали.

Джольф, 4 байта, неконкурентный

₯S₯C

Это ₯Sустанавливает ₯Cзначение элемента ode на вход, так undefinedкак ни один не указан. Попробуй это здесь!

(Файловая система) Befunge 98, 46 байт

ff*:1100'aof0'ai
               21f0'ai@

Обратите внимание, что эта программа создает и манипулирует файлом с именем a. Как это устроено:

1. Код создает файл с именем, aсодержащим весь код (до 256 символов в каждом измерении), смещенный на один пробел вверх и на два влево.
2. Затем эта программа считывает файл, названный aодной строкой, заменяя всю первую строку содержимым aфайла.
3. Вторая строка, которая была скопирована перед IP, выполняется
4. Который читает aфайл во вторую строку, сдвинув два места вправо.

Как побочный эффект, конечный исходный код даже не действует Befunge! (потому что он содержит новые строки в виде данных в одной строке)

Python 2, 238 байт + 20% = 285,6

# coding: utf-8
import codecs
with codecs.open(__file__,'r') as f:
    t = f.read()
n="utf-8" if t.startswith("# coding: ascii") else "ascii"
with codecs.open(__file__,'w', encoding=n) as f:
    f.write(t[0]+" coding: "+n+t[t.find("\n"):])

По сути, это переключает текущую кодировку файла источника Python между asciiи utf-8, таким образом, существенно изменяя каждый символ источника!