Декодер | замена текста. Опции

[FREEON]

Можно ли на базе пилота сделать скрипт который бы заменял текст в файле на нужный?
К примеру есть текстовый документ test.txt, в нем находится набор символов которые нечитаемы, но разделены к примеру запятой(или пробелом или ещё каким символом).

Код

1,2,3,4,5,11,27

Мы знаем и делаем условие что 1 это привет, 2 допустим имя Максим и так далее. Нужно чтобы пилот сканировал текст и менял символы на нужные слова и результат сохронял в нужном месте.
Примеры, готовые скрипты:

qwerty перевод на русский: Hfcrkflrf -> Раскладка

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

$GfHjKm$_Dfvgbh >>> ;ПаРоЛь;_Вампир

Код

--lua
-- Скрипт для перевода английской раскладки в русскую
-- Hfcrkflrf -> Раскладка
local file= io.open([[C:\123.txt]], "r")          -- файл с текстом
local result_file = io.open([[C:\456.txt]], "w")  -- куда сохранить результат

local t={}
t["a"]="ф"  t["b"]="и"  t["c"]="с"  t["d"]="в"  t["e"]="у"  t["f"]="а"
t["g"]="п"  t["h"]="р"  t["i"]="ш"  t["j"]="о"  t["k"]="л"  t["l"]="д"
t["m"]="ь"  t["n"]="т"  t["o"]="щ"  t["p"]="з"  t["q"]="й"  t["r"]="к"
t["s"]="ы"  t["t"]="е"  t["u"]="г"  t["v"]="м"  t["w"]="ц"  t["x"]="ч"
t["y"]="н"  t["z"]="я"  t["`"]="ё"  t["["]="х"  t["]"]="ъ"  t[";"]="ж"
t["'"]="э"  t[","]="б"  t["."]="ю"  t["/"]="."  t["A"]="Ф"  t["B"]="И"
t["C"]="С"  t["D"]="В"  t["E"]="У"  t["F"]="А"  t["G"]="П"  t["H"]="Р"
t["I"]="Ш"  t["J"]="О"  t["K"]="Л"  t["L"]="Д"  t["M"]="Ь"  t["N"]="Т"
t["O"]="Щ"  t["P"]="З"  t["Q"]="Й"  t["R"]="К"  t["S"]="Ы"  t["T"]="Е"
t["U"]="Г"  t["V"]="М"  t["W"]="Ц"  t["X"]="Ч"  t["Y"]="Н"  t["Z"]="Я"
t["{"]="Х"  t["}"]="Ъ"  t[":"]="Ж"  t['"']="Э"  t["<"]="Б"  t[">"]="Ю"
t["?"]=","  t["~"]="Ё"  t["@"]='"'  t["#"]="№"  t["$"]=";"  t["^"]=":"
t["&"]="?"

if file and result_file then     -- если файлы открылись
    for v in file:lines() do
        result_file:write(string.gsub(v, ".", t).."\r\n")  -- поиск и замена текста из таблицы 't'
    end

    file:close()
    result_file:close()
else
    log ("Файлы отсутствуют или недоступны для чтения/записи")
end

URL-decoder(декодер): %D0%A2%D0%B5%D0%BA%D1%81%D1%82 -> Текст

URL применяется всеми и везде и стал неотъемлемой частью Интернета и является идентификации ресурсов(сайтов) в браузерах. Стандарт URL использует набор символов US-ASCII. И имеет серьёзный недостаток, поскольку можно использовать лишь латинские буквы, цифры и несколько знаков пунктуации. Все другие символы необходимо перекодировать. Скрипт размещенный ниже, это, инструмент и поможет раскодировать строку, закодированную подобным алгоритмом.
Пример:

%D0%9A%D1%83%D0%BF%D0%B8%D1%82%D1%8C >>> Купить

Код

--lua
log "clear"   log "mode compact"

local s="Вставить свой код URL"   -- << Для декодирования вставить url-код между ""
log(s)

local t={}
t["%D0%90"]="А" t["%D0%91"]="Б" t["%D0%92"]="В" t["%D0%93"]="Г" t["%D0%94"]="Д" t["%D0%95"]="Е" t["%D0%81"]="Ё" t["%D0%96"]="Ж" t["%D0%97"]="З" t["%D0%98"]="И" t["%D0%99"]="Й"
t["%D0%9A"]="К" t["%D0%9B"]="Л" t["%D0%9C"]="М" t["%D0%9D"]="Н" t["%D0%9E"]="О" t["%D0%9F"]="П" t["%D0%A0"]="Р" t["%D0%A1"]="С" t["%D0%A2"]="Т" t["%D0%A3"]="У" t["%D0%A4"]="Ф"
t["%D0%A5"]="Х" t["%D0%A6"]="Ц" t["%D0%A7"]="Ч" t["%D0%A8"]="Ш" t["%D0%A9"]="Щ" t["%D0%AA"]="Ъ" t["%D0%AB"]="Ы" t["%D0%AC"]="Ь" t["%D0%AD"]="Э" t["%D0%AE"]="Ю" t["%D0%AF"]="Я"
t["%D0%B0"]="а" t["%D0%B1"]="б" t["%D0%B2"]="в" t["%D0%B3"]="г" t["%D0%B4"]="д" t["%D0%B5"]="е" t["%D1%91"]="ё" t["%D0%B6"]="ж" t["%D0%B7"]="з" t["%D0%B8"]="и" t["%D0%B9"]="й"
t["%D0%BA"]="к" t["%D0%BB"]="л" t["%D0%BC"]="м" t["%D0%BD"]="н" t["%D0%BE"]="о" t["%D0%BF"]="п" t["%D1%80"]="р" t["%D1%81"]="с" t["%D1%82"]="т" t["%D1%83"]="у" t["%D1%84"]="ф"
t["%D1%85"]="х" t["%D1%86"]="ц" t["%D1%87"]="ч" t["%D1%88"]="ш" t["%D1%89"]="щ" t["%D1%8A"]="ъ" t["%D1%8B"]="ы" t["%D1%8C"]="ь" t["%D1%8D"]="э" t["%D1%8E"]="ю" t["%D1%8F"]="я"

for v in pairs(t) do   -- добавление ключей в таблицу, если был "%D0%9A", то добавляется "%d0%9a"
    t[v:lower()]=t[v]
end

for i=32, 127 do t["%" .. string.format("%X", i)]=string.char(i) end   -- добавление ключей в таблицу, все символы ascii с 32 по 127

s=s:gsub("%%[Dd][01]%%%x%x", t)   -- замена кириллицы
s=s:gsub("%%..", t)               -- замена спецсимволов
log(s)                            -- результат

Текст задом наперед. Reverser : Зеркальный код. -> .док йыньлакреЗ

Зеркальный код использовал да Винчи в эпоху Возрождения, он в зеркальном стиле писал свои заметки, а также картины. Возможно он подсмотрел эту технику у арабов...кто знает (IMG:style_emoticons/default/smile.gif)
Данный скрипт позволяет отзеркалить текст в одну или в обратную сторону.
Пример:

Не только Леонардо да Винчи пишет задом наперед! >>> !дерепан модаз тешип ичниВ ад одраноеЛ окьлот еН

Код

--lua
log "clear"  log "mode compact"
local s="Текст который нужно отзеркалить."
log (s)
log (s:reverse())

Азбука морзе: Morse to text -> -- --- .-. ... . - --- - . -..- -

Код Морзе, «Морзянка» — способ кодирования букв алфавита, цифр, знаков препинания и других символов при помощи длинных и коротких сигналов, так называемых «точек» и «тире».
Конвертирует латиницу в код морзе и обратно. Пример:

Text <<->> - . -..- -

Код

--lua
log "clear"  log "mode compact"
-- Скрипт для конвертерования текста(ЛАТИНИЦА)в Азбуку Морзе или наоборот.
local text=[[Text or - . -..- -]]-- << Введите исходный текст на латинице или код Морзе и запустите скрипт.

log(text)

local t, t1, temp = {}, {}, {}
t["A"]=".-"     t["B"]="-..."   t["C"]="-.-."   t["D"]="-.."    t["E"]="."      t["F"]="..-."   t["G"]="--."
t["H"]="...."   t["I"]=".."     t["J"]=".---"   t["K"]="-.-"    t["L"]=".-.."   t["M"]="--"     t["N"]="-."
t["O"]="---"    t["P"]=".--."   t["Q"]="--.-"   t["R"]=".-."    t["S"]="..."    t["T"]="-"      t["U"]="..-"
t["V"]="...-"   t["W"]=".--"    t["X"]="-..-"   t["Y"]="-.--"   t["Z"]="--.."
for v in pairs(t) do temp[string_lower(v)]=t[v] end
for v in pairs(temp) do t[v]=temp[v] end
t["1"]=".----"  t["2"]="..---"  t["3"]="...--"  t["4"]="....-"  t["5"]="....."  t["6"]="-...."  t["7"]="--..."
t["8"]="---.."  t["9"]="----."  t["0"]="-----"  t["."]="......" t[":"]="---..." t[";"]="-.-.-." t["("]="-.--.-"
t[")"]="-.--.-" t["'"]=".----." t['"']=".-..-." t["-"]="-....-" t["/"]="-..-."  t["?"]="..--.." t["!"]="--..--"
t[","]=".-.-.-"
for v in pairs(t) do t1[t[v]]=v end   -- таблица для дешифровки, копия 't' только ключи и значения ключей поменяны местами

local x=0
for v in text:gmatch("[%.%- ]") do x=x+1 end  -- подсчёт точек, тире и слешей в строке

if x > #text*50/100 then   -- если их больше 50%, считаем что передана шифрованная строка
    text=string.gsub((text .. " "):gsub("(.-) ", t1), "  ", " ")    -- дешифруем
else
    text=string.gsub(text:gsub("(.)", "%1 "), "[^ ]", t)  -- иначе шифруем
end
log (text)

Конвертирует кириллицу в код морзе и обратно. Пример:

Текст<<->> - . -.- ... -

Код

--lua
log "clear"  log "mode compact"

-- Скрипт для конвертирования текста(КИРИЛЛИЦА)в Азбуку Морзе или наоборот.
local text=[[Текст или - . -.- ... -]]-- << Введите исходный текст на кириллице или код Морзе и запустите скрипт.

log(text)

local t, t1, temp = {}, {}, {}
t["А"]=".-"     t["Б"]="-..."   t["В"]=".--"    t["Г"]="--."    t["Д"]="-.."    t["Е"]="."    t["Ё"]="."
t["Ж"]="...-"   t["З"]="--.."   t["И"]=".."     t["Й"]=".---"   t["К"]="-.-"    t["Л"]=".-.." t["М"]="--"
t["Н"]="-."     t["О"]="---"    t["П"]=".--."   t["Р"]=".-."    t["С"]="..."    t["Т"]="-"    t["У"]="..-"
t["Ф"]="..-."   t["Х"]="...."   t["Ц"]="-.-."   t["Ч"]="---."   t["Ш"]="----"   t["Щ"]="--.-" t["Ь"]="-..-"
t["Ъ"]="-..-"   t["Ы"]="-.--"   t["Э"]="..-.."  t["Ю"]="..--"   t["Я"]=".-.-"
for v in pairs(t) do temp[string_lower(v)]=t[v] end
for v in pairs(temp) do t[v]=temp[v] end
t["1"]=".----"  t["2"]="..---"  t["3"]="...--"  t["4"]="....-"  t["5"]="....."  t["6"]="-...."  t["7"]="--..."
t["8"]="---.."  t["9"]="----."  t["0"]="-----"  t["."]="......" t[":"]="---..." t[";"]="-.-.-." t["("]="-.--.-"
t[")"]="-.--.-" t["'"]=".----." t['"']=".-..-." t["-"]="-....-" t["/"]="-..-."  t["?"]="..--.." t["!"]="--..--"
t[","]=".-.-.-"
for v in pairs(t) do t1[t[v]]=v end   -- таблица для дешифровки, копия 't' только ключи и значения ключей поменяны местами

local x=0
for v in text:gmatch("[%.%- ]") do x=x+1 end  -- подсчёт точек, тире и слешей в строке

if x > #text*50/100 then   -- если их больше 50%, считаем что передана шифрованная строка
    text=string.gsub((text .. " "):gsub("(.-) ", t1), "  ", " ")    -- дешифруем
else
    text=string.gsub(text:gsub("(.)", "%1 "), "[^ ]", t)  -- иначе шифруем
end
log (text)

Выражаю огромную благодарность в написании скриптов нашему великому гуру cirus .

[cirus]

Ну так добавляйте в правила выше:

Нужно регулярку менять, там разделитель запятая. Это уже другое условие, посимвольная замена.

qwerty в йцукен

Код

--lua
local file= io.open([[C:\123.txt]], "r")          -- файл с текстом
local result_file = io.open([[C:\456.txt]], "w")  -- куда сохранить результат

local t={}
t["q"]="й"          -- все 'q' заменит на 'й'
t["w"]="ц"          
t["e"]="у"
t["r-"]="к"

if file and result_file then     -- если файлы открылись
    for v in file:lines() do
        result_file:write(string.gsub(v, ".", t).."\r\n")  -- поиск и замена текста из таблицы 't'
    end

    file:close()
    result_file:close()
else
    log ("Файлы отсутствуют или недоступны для чтения/записи")
end

или же к примеру в морзянку:

Пример нужен. Как символы отличать?
.- = А - 2 символа
-... = Б - 4 символа
.--... - если это АБ, то В тут тоже можно найти .--
Тогда уж они должны быть 1 длины.

[FREEON]

Пример нужен. Как символы отличать?
.- = А - 2 символа
-... = Б - 4 символа
.--... - если это АБ, то В тут тоже можно найти .--
Тогда уж они должны быть 1 длины.

Понял, поищу покамись.

Правила кодирования

Здесь можно легко и просто закодировать текст в Азбуку Морзе, да не просто в обычные точки и тире, а ещё и в бинарный код!

Правила кодирования

Кодирование азбуки Морзе в бинарный код -- это просто замена точек и тире на единицы и нули, но по определённым правилам: •"Точка" кодируется цифрой 1
•"Тире" кодируется тремя единицами (ведь тире по длительности равно трём точкам)
•Между точкой и тире используется разделитель: цифра 0
•Между каждым символом используется два нуля, так можно будет отличить, что начался следующий символ

php скамуниздил

Код

<?php
/**
 * Created by PhpStorm.
 * User: karamush
 * Date: 13.07.2018
 * Time: 23:08
 */

class MorseCoder_Class {

    public $MORSE_CHAR_DELIMITER = ' ';            // разделитель между символами в обычной морзянке
    public $UNKNOWN_CHAR = '?';                    // это если перевести не удалось. неизвестный символ
    public $MORSE_DOT = '.';                       // точка
    public $MORSE_DASH = '-';                      // тире
    public $MORSE_BIN_DOT = '1';                   // бинарная точка
    public $MORSE_BIN_DASH ='111';                 // бинарное тире
    public $MORSE_BIN_DELIMITER = '0';             // разделитель между знаками одного символа
    public $MORSE_BIN_CHAR_DELIMITER = '00';       // разделитель между символами
    public $MORSE_BIN_WORD_DELIMITER = '000';      // разделитель между словами (эм. пробел?)

    const MORSE_TYPE_SIMPLE = 0;
    const MORSE_TYPE_BINARY = 1;
    const MORSE_LANGUAGE_LATIN = 1;
    const MORSE_LANGUAGE_CYRILLIC = 0;

    public $morse_type = self::MORSE_TYPE_BINARY;
    public $morse_language = self::MORSE_LANGUAGE_CYRILLIC;
    public $morse_capital = true;

    // символы и цифры
    private $codes_symbols = [
        '1' => '.----',
        '2' => '..---',
        '3' => '...--',
        '4' => '....-',
        '5' => '.....',
        '6' => '-....',
        '7' => '--...',
        '8' => '---..',
        '9' => '----.',
        '0' => '-----',
        '.' => '......',
        ',' => '.-.-.-',
        ':' => '---...',
        ';' => '-.-.-.',
        '(' => '-.--.-',
        ')' => '-.--..', // TODO: использовал собственный символ для закрывающей скобки. опасно :)
        '\'' => '.----.',
        '`' => '.----.',
        '"' => '.-..-.',
        '-' => '-....-',
        '/' => '-..-.',
        '?' => '..--..',
        '!' => '--..--',
        ' ' => '-...-', // знак раздела, пробел, короче, WTF?!
        "\n" => '-.-..',    // TODO: ещё один добавленный символ. Символ переноса строки!
        "\r" => '-.-..-',   // TODO: ай-ай-ай!
        '@' => '.--.-.',
        '[END]' => '..-.-'
    ];

    // латинский алфавит
    private $codes_latin = [
        'A' => '.-',
        'B' => '-...',
        'C' => '-.-.',
        'D' => '-..',
        'E' => '.',
        'F' => '..-.',
        'G' => '--.',
        'H' => '....',
        'I' => '..',
        'J' => '.---',
        'K' => '-.-',
        'L' => '.-..',
        'M' => '--',
        'N' => '-.',
        'O' => '---',
        'P' => '.--.',
        'Q' => '--.-',
        'R' => '.-.',
        'S' => '...',
        'T' => '-',
        'U' => '..-',
        'W' => '.--',
        'X' => '-..-',
        'Y' => '-.--',
        'Z' => '--..',
        'V' => '...-',
        'CH' => '---.',
        'SH' => '----',
        'Ñ' => '-..-',
        'É' => '..-..',
        'Ü' => '..--',
        'Ä' => '.-.-'
    ];

    // кириллический алфавит
    private $codes_cyrillic = [
        'А' => '.-',
        'Б' => '-...',
        'В' => '.--',
        'Г' => '--.',
        'Д' => '-..',
        'Е' => '.',     'Ё' => '.',
        'Ж' => '...-',
        'З' => '--..',
        'И' => '..',
        'Й' => '.---',
        'К' => '-.-',
        'Л' => '.-..',
        'М' => '--',
        'Н' => '-.',
        'О' => '---',
        'П' => '.--.',
        'Р' => '.-.',
        'С' => '...',
        'Т' => '-',
        'У' => '..-',
        'Ф' => '..-.',
        'Х' => '....',
        'Ц' => '-.-.',
        'Ч' => '---.',
        'Ш' => '----',
        'Щ' => '--.-',
        'Ь' => '-..-',  'Ъ' => '-..-',
        'Ы' => '-.--',
        'Э' => '..-..',
        'Ю' => '..--',
        'Я' => '.-.-',
    ];

    public function __construct() {

    }

    /**
     * Получить текущий полный алфавит, но с приоритетом языка,
     * чтоб в первую очередь шифровалось или дешифровалось на текущем языке,
     * но отсутствующие символы чтобы тоже были. Плюс цифры и другие символы.
     *
     * @return array
     */
    private function get_current_full_alphabet() {
        $alphabet = ($this->morse_language == self::MORSE_LANGUAGE_CYRILLIC) ? array_merge($this->codes_cyrillic, $this->codes_latin) : array_merge($this->codes_latin, $this->codes_cyrillic);
        return array_merge($alphabet, $this->codes_symbols);
    }

    /**
     * Переводит обычный символ в его Морзе-символ
     * @param $char
     *
     * @return mixed|string
     */
    function char_to_morse($char) {
        $char = mb_strtoupper($char);
        return array_key_exists($char, $this->get_current_full_alphabet()) ? $this->get_current_full_alphabet()[$char] : $this->UNKNOWN_CHAR;
    }

    /**
     * Приводит строку с морзянкой к общему формату, заменяя звёздочки на точки и т.д.
     * @param $morse_text
     *
     * @return string
     */
    function prepare_morse_text($morse_text) {
        $morse_text = str_replace('*', '.', $morse_text);
        $morse_text = str_replace('_', '-', $morse_text);
        return $morse_text;
    }

    function mbStringToArray($string, $encoding = 'UTF-8') {
        $strlen = mb_strlen($string);
        $str_array = [];
        while ($strlen) {
            $str_array[] = mb_substr($string, 0, 1, $encoding);
            $string = mb_substr($string, 1, $strlen, $encoding);
            $strlen = mb_strlen($string, $encoding);
        }
        return $str_array;
    }

    /**
     * Переводит Морзе-код символа в его обычный символ
     * @param $morse_char
     *
     * @return string
     */
    function morse_to_char($morse_char) {
        // сначала к единому формату тире и точек привести нужно символ
        $morse_char = $this->prepare_morse_text($morse_char);
        return in_array($morse_char, $this->get_current_full_alphabet()) ? array_search($morse_char, $this->get_current_full_alphabet()) : $this->UNKNOWN_CHAR;
    }

    /**
     * Переводит строку обычного текста в морзянку, ставя также разделитель после каждого символа.
     * @param $plain_text
     *
     * @return string
     */
    function text_to_morse($plain_text) {
        $plain_text = $this->mbStringToArray(mb_strtoupper($plain_text));
        $result = '';
        foreach ($plain_text as $char) {
            $result .= $this->char_to_morse($char) . $this->MORSE_CHAR_DELIMITER;
        }
        return $result;
    }

    /**
     * Переводит морзянку в обычный человеческий текст.
     *
     * @param      $morse_text
     *
     * @return string
     */
    function morse_to_text($morse_text) {
        $morse_chars = explode($this->MORSE_CHAR_DELIMITER, $morse_text);
        $result = '';
        foreach($morse_chars as $char) {
            $result .= $this->morse_to_char($char);
        }

        return $this->morse_capital ? $result : mb_strtolower($result);
    }

    /**
     * Переводит бинарную морзянку в морзянку обычную.
     * @param $morse_bin_text
     *
     * @return string
     */
    function morse_bin_to_morse($morse_bin_text) {
        $result = '';
        $bin_morse_chars = explode($this->MORSE_BIN_CHAR_DELIMITER, $morse_bin_text);
        foreach ($bin_morse_chars as $bin_morse_char) {
            $bin_morse_char = str_replace($this->MORSE_BIN_DASH, $this->MORSE_DASH, $bin_morse_char);
            $bin_morse_char = str_replace($this->MORSE_BIN_DOT, $this->MORSE_DOT, $bin_morse_char);
            $bin_morse_char = str_replace($this->MORSE_BIN_DELIMITER, '', $bin_morse_char);
            $result .= $bin_morse_char . $this->MORSE_CHAR_DELIMITER;
        }
        return rtrim($result, $this->MORSE_CHAR_DELIMITER);
    }

    /**
     * Переводит морзянку в бинарную морзянку.
     * @param $morse_text
     *
     * @return string
     */
    function morse_to_morse_bin($morse_text) {
        $result = '';
        $morse_text = $this->prepare_morse_text($morse_text);
        for($i=0; $i<strlen($morse_text);$i++) {
            switch ($morse_text[$i]) {
                case $this->MORSE_DOT: $result .= $this->MORSE_BIN_DOT . $this->MORSE_BIN_DELIMITER; break;
                case $this->MORSE_DASH: $result .= $this->MORSE_BIN_DASH . $this->MORSE_BIN_DELIMITER; break;
                case $this->MORSE_CHAR_DELIMITER: $result .= $this->MORSE_BIN_DELIMITER; break; // добавляем ещё один нолик, а не два нуля. Потому что с предыдущего символа нолик ещё есть
            }
        }
        return $result;
    }

    /**
     * Текст в бинарную морзянку
     * @param $plaint_text
     *
     * @return string
     */
    function text_to_morse_bin($plaint_text) {
        return $this->morse_to_morse_bin($this->text_to_morse($plaint_text));
    }

    /**
     * Бинарную морзянку в текст
     *
     * @param      $morse_bin
     *
     * @return string
     */
    function morse_bin_to_text($morse_bin) {
        return $this->morse_to_text($this->morse_bin_to_morse($morse_bin));
    }

    /**
     * Закодировать открытый текст в бинарную морзянку или в обычную
     * (зависит от параметра morse_type)
     * @param $plain_text
     *
     * @return string
     */
    function morse_encode($plain_text) {
        return ($this->morse_type == self::MORSE_TYPE_BINARY) ? $this->text_to_morse_bin($plain_text) : $this->text_to_morse($plain_text);
    }

    /**
     * Раскодировать закодированный текст из бинарной морзянки или из обычной
     * (зависит от параметра morse_type)
     * @param $encoded_text
     *
     * @return string
     */
    function morse_decode($encoded_text) {
        return ($this->morse_type == self::MORSE_TYPE_BINARY) ? $this->morse_bin_to_text($encoded_text) : $this->morse_to_text($encoded_text);
    }


}