ИИ готовится писать программу
Примеры ИИ запросов
Поскольку STP=0, ротации нет — все символы работают в своём исходном режиме.
Нам нужно вывести строку "Mission Oflameron" посимвольно, используя оператор mX.
План кодирования:
Вычисляем ASCII-коды символов строки:
M = 77
i = 105
s = 115
s = 115
i = 105
o = 111
n = 110
= 32
O = 79
f = 102
l = 108
a = 97
m = 109
e = 101
r = 114
o = 111
n = 110
Нормализуем их через функцию normalize(num):
Если число > 127, вычитаем 127, пока не войдёт в диапазон 0–127.
Все наши коды уже в диапазоне 32–115, поэтому нормализация их не меняет.
Представим каждый код через константы языка Oflameron:
Константы:
a=0, b=1, c=3, d=5, e=7, p=19, t=23, v=43, w=73
Например:
77 = w(73) + d(5) = gwd
105 = w(73) + v(43) - p(19) - b(1) - b(1) = gwvipbb (это слишком сложно, лучше разбить иначе)
Но проще: мы можем вычислять коды в переменной h через операции, а потом делать mh.
Выбор подхода:
Можно для каждого символа вычислять код через f/g/i и класть в h, затем делать mh.
Но это удлиняет код.
Если STP=0, можно просто заранее вычислить каждый код как комбинацию констант и записать mX, где X — это переменная или константа, дающая нужное число после normalize().
Например, для 77: w=73, нужно +4. Но 4 нет среди констант.
Значит, нужно вычислять.
Упрощённый подход:
Будем для каждого символа вычислять его код в h, потом выводить mh.
Для вычислений будем использовать g (сложение) и i (вычитание).
Например:
77 = 73 + 4 > но 4 = d(5) - b(1) = idb
Тогда: g w (idb) — но так нельзя, потому что idb это три символа, а g ожидает два параметра-значения.
Значит, нужно сначала положить 4 в h или q, потом использовать.
Это становится громоздким, поэтому лучше сразу формировать числовые значения в h через серию операций, но т.к. после каждой операции h меняется, нужно аккуратно.
Практичный способ:
Используем g для сложения констант, начиная с 0.
Например, чтобы получить 77:
g a w > h = 0+73 = 73
g h d > h = 73+5 = 78 (но это уже 78, а не 77)
Значит, нужно подобрать точнее.
Проще написать небольшую программу-помощник для подбора, но вручную можно обойтись.
Пример для первых символов:
Пусть начальное h=0.
M (77):
g a w > h = 73
g h d > h = 78
i h b > h = |78-1| = 77
Итого: g a w g h d i h b
Теперь h=77, делаем m h > mh
Но mh — это два символа, m и h, где h — параметр (переменная h).
Получается последовательность:
text
gaw ghd ihb mh
Это уже 12 символов очищенного кода.
Учитываем, что h постоянно меняется:
После mh нужно снова вычислить следующий символ в h.
То есть цепочка будет:
text
gaw ghd ihb mh [вычислим i=105] gib ... mh [вычислим s=115] ...
Становится длинно, но это нормально — нам потом добавим балласт.
Я составлю код посимвольно:
Будем вычислять каждый код в h с нуля, чтобы не зависеть от предыдущего значения.
Символ 1: M (77)
77 = 73 + 5 - 1 = w + d - b
Код: gaw ghd ihb mh
Символ 2: i (105)
105 = 73 + 43 - 19 + 5 + 3 = w + v - p + d + c
Код: gaw g hv i hp g hd g hc mh
Это уже слишком долго. Лучше использовать промежуточные переменные q, l, k?
Но они тоже изначально 0, и их надо вычислять.
Альтернатива: использовать оператор lX для чтения "заранее закодированных" значений из самого кода.
Если в очищенном коде записать где-то нужные числа как константы, можно lX прочитать символ оттуда, получить его код в l, потом скопировать в h и вывести.
Например, пусть в позиции k+20 в очищенной строке лежит символ w (код 73).
Тогда lX, где X = 20, прочитает w и запишет в l число 119 (ASCII 'w'), а нам нужно 77… Не очень удобно.
Самый простой способ для STP=0:
Так как ротации нет, можно просто подобрать для каждого символа строки такое выражение X, что normalize(X) = нужный ASCII-код, и написать mX.
Но X может быть только одной буквой (константа или переменная).
Константы у нас ограничены: 0,1,3,5,7,19,23,43,73.
Ни одна не даёт 77, 105 и т.д.
Значит, X может быть переменной (h, q, l, k), но её значение надо вычислить.
Итоговый подход:
Для каждого символа:
Вычисляем его код в h через операции с константами.
Делаем mh.
Переходим к следующему символу, вычисляем заново.
Пример для "Mi":
M (77):
text
gaw // h = 0+73 = 73
ghd // h = 73+5 = 78
ihb // h = |78-1| = 77
mh // вывод 'M'
i (105):
Сбрасываем h? Не надо, просто вычисляем новое значение поверх старого.
105 = 73+43-19+5+3
text
gaw // h = 77+73=150 > normalize(150)=23? СТОП! Это проблема.
Нужно сначала обнулить h. Как? h = |h-h| через i h h > ihh даст 0.
Тогда:
text
ihh // h = |77-77| = 0
gaw // h = 0+73 = 73
ghv // h = 73+43 = 116
ihp // h = |116-19| = 97
ghd // h = 97+5 = 102
ghc // h = 102+3 = 105
mh // вывод 'i'
Вижу, что это очень длинно.
Может, использовать переменную q как аккумулятор для некоторых промежуточных вычислений?
Но это не сократит сильно.
Предлагаю упрощённый финальный вариант:
Закодируем так: для каждого символа делаем ровно две операции:
g a <константа1> (или другая операция) — чтобы получить близкое к нужному число.
g h <константа2> или i h <константа3> — подгоняем до точного значения.
mh
Например, для 'M' (77):
73 + 5 - 1 > gaw ghd ihb mh (4 операции)
Для 'i' (105):
73 + 43 - 19 + 5 + 3 > gaw ghv ihp ghd ghc mh (6 операций)
И так далее.
Но если продолжать в таком духе, очищенный код будет огромным.
Поскольку задание просит добавить балласт, чтобы скрыть код, длина не страшна.
Читаем далее...
Там всё получилось
Comments
Post a Comment