Промпт-"компилятор"
Примеры ИИ запросов
Сначала описание запроса. Задача - в последних строках документа.
Запрос на составление программы на языке Oflameron версии 1.50
Программа на языке Oflameron при выполнении в Интерпретаторе в качестве результата выдаёт текст (текст, текстовый скрипт, листинг кода какого-то языка), заданный пользователем.
Описание для преобразования заданного пользователем текста в код программы. Текст для кодирования будет задан в конце запроса.
Код программы на языке Oflameron представляет собой текстовую строку, которая просматривается Интерпретатором строго слева направо.
Код программы всегда начинается с оператора.
Код программы на языке Oflameron представляет собой строку из констант, операторов, индексов, управляющих и балластных символов.
Полный набор символов, используемый в языке Oflameron версии 1.50 - a, b, c, d, e, p, t, v, w, h, q, l, k, f, g, i, m, n, s, x. Все остальные символы не имеют никаких функций в языке Oflameron и просто пропускаются (это балластные символы, которые добавляются для сокрытия кода программы).
Константы: a=0, b=1, c=3, d=5, e=7, p=19, t=23, v=43, w=73
Переменные: h, q, l, k (Начальные значения =0)
Операторы: f, g, i, l, m, n
Управляющие символы (фактически - тоже операторы): s, x. Символы s и x пока не используются (зарезервированы), но не считаются балластными.
Балластные символы: все остальные символы, кроме указанных выше a, b, c, d, e, p, t, v, w, h, q, l, k, f, g, i, m, n, s, x. Балластные символы просто пропускаются транслятором.
В преобразовании символов заданного текста используется функция нормализации. На JavaScript это реализуется так:
Нормализация чисел:
javascript
function normalize(num) {
while (num > 127) num -= 127;
if (num < 0) num = Math.abs(num);
return Math.floor(num);
}
Применяется после КАЖДОЙ математической операции к её результату. Это делается для того, чтобы в работе программы использовались только коды символов в диапазоне 0-127
Длина констант, переменных, операторов и управляющих символов:
* Важно. Символ l может выступать в двух ролях:
Как оператор lX (когда встречается в позиции оператора) — читает символ из кода и сохраняет его ASCII-код в переменную l.
Как переменная l (когда встречается в качестве параметра других операторов) — хранит числовое значение.
Контекст использования определяет роль символа.
** Если в коде программы l встречается на позициии оператора f, g, i, m, n то в этом случае l - переменная. Например: fal или gcl или ml... Если l встречается после оператора с параметрами - то l в этом случае оператор с длиной два символа. Например: fbcle или gcale и т.д.
- константы используются в составе операторов в качестве параметров. Константы занимают в коде программы 1 символ
- переменные используются в составе операторов в качестве параметров. Переменные занимают в коде программы 1 символ
- операторы f, g, i занимают в строке кода программы 3 символа (символ оператора f, g или i и два параметра - переменных или констант)
- операторы m, l и n занимают в коде программы два символа (символ оператора m, l или n и один параметр)
- управляющие символы s и x имеют длину 2 символа
В JavaScript используется внутренняя переменная SYMBOL_ORDER = ['a','b','c','d','e','p','t','v','w','h','q','l','k','f','g','i','m','n','s','x'] определяющая порядок констант, переменных, операторов и управляющих символов.
Если считать SYMBOL_ORDER массивом с индексом от1 до 20, то:
Позиции 1-9 в SYMBOL_ORDER занимают константы.
Позиции 10-13 в SYMBOL_ORDER занимают переменные
Позиции 14-18 в SYMBOL_ORDER занимают операторы
Позиции 19-20 в SYMBOL_ORDER занимают управляющие символы
Это важно для правильной ротации функциональности. Функциональность символа однозначно определяется позицией в массиве SYMBOL_ORDER
Ротация функциональности определяется значением STP - внутренней переменной JavaScript
Если явно не задано значение, то по умолчанию STP=1
Т.е. если рассматривать SYMBOL_ORDER как массив, то перед началом выполнения кода программы каждой позиции в массиве назначается своя функциональность (которые описаны далее):
SYMBOL_ORDER(0) = 'a' - константа
SYMBOL_ORDER(1) = 'b' - константа
SYMBOL_ORDER(2) = 'c' - константа
SYMBOL_ORDER(3) = 'd' - константа
SYMBOL_ORDER(4) = 'e' - константа
SYMBOL_ORDER(5) = 'p' - константа
SYMBOL_ORDER(6) = 't' - константа
SYMBOL_ORDER(7) = 'v' - константа
SYMBOL_ORDER(8) = 'w' - константа
SYMBOL_ORDER(9) = 'h' - переменная
SYMBOL_ORDER(10) = 'q' - переменная
SYMBOL_ORDER(11) = 'l' - переменная
SYMBOL_ORDER(12) = 'k' - переменная
SYMBOL_ORDER(13) = 'f' - оператор
SYMBOL_ORDER(14) = 'g' - оператор
SYMBOL_ORDER(15) = 'i' - оператор
SYMBOL_ORDER(16) = 'm' - оператор
SYMBOL_ORDER(17) = 'n' - оператор
При ротации значения элементов массива SYMBOL_ORDER (буквы) будут меняться (сдвигаться), но функциональность постоянно назначена в соответствии с индексом элемента в массиве.
Ротация символов:
Принцип: Циклический сдвиг функций символов вправо по списку на STP позиций.
Сдвиг выполняется ПОСЛЕ каждого выполненного оператора.
Алгоритм выполнения для каждого оператора:
1. Определить текущую функциональность символов (с учётом всех предыдущих сдвигов).
2. Выполнить оператор, используя его текущую функциональность.
3. Увеличить указатель k на длину оператора (2 или 3).
4. Выполнить ротацию: циклически сдвинуть функциональность всех символов на STP позиций вправо.
5. Перейти к следующему оператору (новое значение k определяет его позицию).
Когда выполнять ротацию: Ротация выполняется после (после!) выполнения КАЖДОГО оператора (f,g,i,l,m,n).
Т.е. сначала выполнить оператор в текущем функционале. Затем выполнить сдвиг вправо по коду программы на 2 или 3 символа (в зависимости от длины оператора) - перейти к следующему оператору, затем выполнить ротацию (сдвиг функциональности), определить новую функциональность оператора и начать выполнять этот оператор.
Механика ротации (примеры) для STP=1:
a получает функцию b (значение 1)
b получает функцию c (значение 3)
...
n получает функцию a (значение 0)
Т.е. если рассматривать SYMBOL_ORDER как массив, то после первого сдвига станет:
SYMBOL_ORDER(0) = 'b' - константа
SYMBOL_ORDER(1) = 'c' - константа
SYMBOL_ORDER(2) = 'd' - константа
SYMBOL_ORDER(3) = 'e' - константа
SYMBOL_ORDER(4) = 'p' - константа
SYMBOL_ORDER(5) = 't' - константа
SYMBOL_ORDER(6) = 'v' - константа
SYMBOL_ORDER(7) = 'w' - константа
SYMBOL_ORDER(8) = 'h' - константа
SYMBOL_ORDER(9) = 'q' - переменная
SYMBOL_ORDER(10) = 'l' - переменная
SYMBOL_ORDER(11) = 'k' - переменная
SYMBOL_ORDER(12) = 'f' - переменная
SYMBOL_ORDER(13) = 'g' - оператор
SYMBOL_ORDER(14) = 'i' - оператор
SYMBOL_ORDER(15) = 'm' - оператор
SYMBOL_ORDER(16) = 'n' - оператор
SYMBOL_ORDER(17) = 'a' - оператор
Правила ротации функциональности констант, переменных, операторов, управляющих символов:
Когда выполнять ротацию: Ротация выполняется после (после!) выполнения КАЖДОГО оператора (f,g,i,l,m,n).
Если значение переменной STP не равно нулю, то после каждого исполнения любого оператора выполняется сдвиг функциональности в соответствии с следующей таблицей
Столбцы таблицы показывают, как меняется функции каждого символа в SYMBOL_ORDER для каждого значения STR
STP= 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19
------------------------------------------------------------------------------------------------------------------- Какие функции выполняет --------------------------------------------------------------------------------------------------------------------
Константа a a b c d e p t v w h q l k f g i m n s x
Константа b b c d e p t v w h q l k f g i m n s x a
Константа c c d e p t v w h q l k f g i m n s x a b
Константа d d e p t v w h q l k f g i m n s x a b c
Константа e e p t v w h q l k f g i m n s x a b c d
Константа p p t v w h q l k f g i m n s x a b c d e
Константа t t v w h q l k f g i m n s x a b c d e p
Константа v v w h q l k f g i m n s x a b c d e p t
Константа w w h q l k f g i m n s x a b c d e p t v
Переменная h h q l k f g i m n s x a b c d e p t v w
Переменная q q l k f g i m n s x a b c d e p t v w h
Переменная l l k f g i m n s x a b c d e p t v w h q
Переменная k k f g i m n s x a b c d e p t v w h q l
Оператор f f g i m n s x a b c d e p t v w h q l k
Оператор g g i m n s x a b c d e p t v w h q l k f
Оператор i i m n s x a b c d e p t v w h q l k f g
Оператор m m n s x a b c d e p t v w h q l k f g i
Оператор n n s x a b c d e p t v w h q l k f g i m
Символ s s x a b c d e p t v w h q l k f g i m n
Символ x x a b c d e p t v w h q l k f g i m n s
Как это работает. Примеры сдвига функциональности символов:
Например, если STP=1 и в тексте кода программы встречается символ m, то выбираем пересечение строки "Оператор m" и колонки "STP=1" - получаем, что символ m будет выполнять функцию оператора n
Пример, если STP=3 и в тексте кода программы встречается символ m, то выбираем перемечение строки "Оператор m" и колонки "STP=3" - получаем, что символ m будет выполнять функцию оператора x.
Причём, управляющий символ x изначально имеет другую длину ("x" имеет длину 2 символа - собственно "x" и параметр), нежели оператор "m" (3 символа - собственно "m" и два параметра). В этом случае запись в коде "mcb" должна исполнять функцию "xc" (оставшийся символ "b" отбрасывается как ошибочный, т.к. функционал изначального "x" не предусматривает второго параметра).
Сдвиг функциональности выполняется после выполнения каждого оператора. При этом указатель k увеличивается на длину выполненного оператора. Т.е. запись кода fcdgbemc... надо рассматривать как fcd (k+3, сдвиг) gbe (k+3, сдвиг) mc (k+2, сдвиг)...
Ошибки: Если после ротации оператор получает несоответствующую арность (количество параметров) - операция пропускается.
Например:
1. Если оператор f ожидает 2 параметра, а после ротации он стал l (1 параметр), то используется только один (первый параметр), а второй параметр, оставшийся от f пропускаем, т.к. для l он лишний (ошибочный). Т.к. выполняется уже новый оператор l, то k+2. Но там остался еще один параметр от f, он будет рассматриваться как ошибка и должен быть пропущен. Мы должны обработать этот символ как ошибку (k+1) и перейти дальше.
2. Если оператор l (1 параметр) стал f (2 параметра), а в коде после него только один символ, то получившийся оператор f оказывается с неверным форматом (не хватает ещё одного параметра) и должен быть просто пропущен.
Период: При STP=1 период ротации для языка Oflameron версии 1.50 = 20 операторов. Т.е. при STP=20 функциональность символов никак не изменится.
Пример 1 (STP=1):
Пример для STP=1, выполняем код "fbcgde":
- Начальное состояние: SYMBOL_ORDER = ['a','b','c','d','e','p','t','v','w','h','q','l','k','f','g','i','m','n']
- Шаг 1: оператор fbc (позиция k=0) выполняется как умножение (1*3=3, h=3). k+=3 → k=3.
- Шаг 2: ротация: SYMBOL_ORDER = ['b','c','d','e','p','t','v','w','h','q','l','k','f','g','i','m','n','a']
- Шаг 3: оператор gde (позиция k=3) теперь выполняется как вычитание (|5-7|=2, h=2). k+=3 → k=6.
- Шаг 4: ротация: SYMBOL_ORDER = ['c','d','e','p','t','v','w','h','q','l','k','f','g','i','m','n','a','b']
Пример 2 (STP=2):
Выполняем код: fbcfbc...
Шаг 1: fbc выполняется как умножение (1*3=3, h=3)
Шаг 2: Ротация: сдвиг функциональности на 2 позиции
Т.е. вместо SYMBOL_ORDER = ['a','b','c','d','e','p','t','v','w','h','q','l','k','f','g','i','m','n']
надо рассматривать SYMBOL_ORDER = ['c','d','e','p','t','v','w','h','q','l','k','f','g','i','m','n','a','b']
Шаг 3: Теперь: f ->i(вычитание). Далее, смотрим параметры для вычитания. Формат iXY. Длина - 3 символа.
символ b теперь не константа, а выполняет функцию оператора n - это оператор редактирования кода. В формате f не может быть параметром другой оператор. Ошибка. Пропускаем k+3
Операторы (до ротации):
fXY - умножение: h = normalize(X * Y). После выполнения k увеличивается на 3.
Размер оператора = 3 символа.
gXY - сложение: h = normalize(X + Y). После выполнения k увеличивается на 3.
Размер оператора = 3 символа.
iXY - вычитание: h = normalize(|X - Y|). После выполнения k увеличивается на 3.
Размер оператора = 3 символа.
lX - чтение символа: в переменную l записывается ASCII-код символа,
находящегося в очищенной строке программы на позиции k + normalize(X).
После выполнения k увеличивается на 2. Размер оператора = 2 символа.
mX - вывод символа: на экран выводится символ с ASCII-кодом normalize(X).
После выполнения k увеличивается на 2. Размер оператора = 2 символа.
nX - замена символа: символ в очищенной строке программы на позиции
k + normalize(X) заменяется на символ с ASCII-кодом normalize(h).
После выполнения k увеличивается на 2. Размер оператора = 2 символа.
Общие правила:
Исполнение строго слева направо
k (указатель позиции в строке кода программы на Oflameron) - только увеличивается от 0 до конца строки программы
Движение по коду:
f,g,i: k+3
l,m,n,q: k+2
Ошибка/неизвестный символ: k+1 (просто сдвинуться вправо на одну позицию в строке программы)
Ошибка: если ожидается операнд, но символ недопустим > k+1
Неизвестные символы: пропускаются (k+1)
Самомодификация: через оператор nX
Пояснения:
Текст кода программы на языке Oflameron может быть "разбавлен" любыми символами, не входящими в список SYMBOL_ORDER = ['a','b','c','d','e','p','t','v','w','h','q','l','k','f','g','i','m','n','s','x'].
Все остальные символы - "балластные" и перед выполнением кода в Трансляторе такой "разбавленный" код программы "очищается" (удаляются балластные символы).
Пример:
1. код программы fcdfhdghdihbmhghdghdghdghdghcmhghcghcmhihdihdihbmhghcghcghcghcmhihdihcmhgheghdghbmhihcmhihbmh
2. можно записать в другом виде f(cdfhdghd)*ihbm.hgh/dghdgh=dghdgh12cmhghc-ghcmh**ihdih{dihbmhghcghc}ghcg-hc#mhihdi$$hcmhghe&ghdghbmhihcmhihbmh
Это просто один из вариантов обфускации.
Если Транслятор "очистит" текст 2 от лишних символов, получится тот же самый код программы 1 на языке Oflameron.
При составлении программы все действия операторов (извлечение символа или замена символа в строке) выполняются с "очищенным" кодом. "Разбавление" кода балластными символами выполняется уже в полностью готовой строке программы. Такая обфускация - это последнее действие.
Теперь задача:
Закодируй на языке Oflameron текст "Mission Oflameron" - назовём его КОД1. Значение STP=0 Затем напиши на Python программу с циклами и функциями, которая печатает на экран текст нашего КОД1.
Comments
Post a Comment