Paraskeva version 1.0 2R-WR-ONL

fun <K, V> getKey(hashMap: Map<K, V>, target: V): K {
    return hashMap.filter { target == it.value }.keys.first()
}

val roterOne = mapOf(
'A' to 'E',
'B' to 'K',
'C' to 'M',
'D' to 'F',
'E' to 'L',
'F' to 'G',
'G' to 'D',
'H' to 'Q',
'I' to 'V',
'J' to 'Z',
'K' to 'N',
'L' to 'T',
'M' to 'O',
'N' to 'W',
'O' to 'Y',
'P' to 'H',
'Q' to 'X',
'R' to 'U',
'S' to 'S',
'T' to 'P',
'U' to 'A',
'V' to 'I',
'W' to 'B',
'X' to 'R',
'Y' to 'C',
'Z' to ' ',
' ' to 'J')

val roterTwo = mapOf(
'A' to 'A',
'B' to 'J',
'C' to 'D',
'D' to 'K',
'E' to 'S',
'F' to 'I',
'G' to 'R',
'H' to 'U',
'I' to 'X',
'J' to 'B',
'K' to 'L',
'L' to 'H',
'M' to 'W',
'N' to 'T',
'O' to 'M',
'P' to 'C',
'Q' to 'Q',
'R' to 'G',
'S' to 'Z',
'T' to 'N',
'U' to 'P',
'V' to 'Y',
'W' to 'F',
'X' to 'V',
'Y' to 'O',
'Z' to ' ',
' ' to 'E')

val reflector = mapOf(
'A' to 'Y',
'B' to 'R',
'C' to 'U',
'D' to 'H',
'E' to 'Q',
'F' to 'S',
'G' to 'L',
'H' to 'D',
'I' to 'P',
'J' to 'X',
'K' to 'N',
'L' to 'G',
'M' to 'O',
'N' to 'K',
'O' to 'M',
'P' to 'I',
'Q' to 'E',
'R' to 'B',
'S' to 'F',
'T' to 'Z',
'U' to 'C',
'V' to 'W',
'W' to 'V',
'X' to 'J',
'Y' to 'A',
'Z' to 'T',
' ' to ' ')

val letterToInt = mapOf(
'A' to 0,
'B' to 1,
'C' to 2,
'D' to 3,
'E' to 4,
'F' to 5,
'G' to 6,
'H' to 7,
'I' to 8,
'J' to 9,
'K' to 10,
'L' to 11,
'M' to 12,
'N' to 13,
'O' to 14,
'P' to 15,
'Q' to 16,
'R' to 17,
'S' to 18,
'T' to 19,
'U' to 20,
'V' to 21,
'W' to 22,
'X' to 23,
'Y' to 24,
'Z' to 25,
' ' to 26)

class Paraskeva(settings: String, _stringToCode: String) {

    val firstLetter = settings[0]
    val secondLetter = settings[1]
    val firstLetterInt = letterToInt[firstLetter] // первая настройка
    val secondLetterInt = letterToInt[secondLetter] // вторая настройка

    var stringToCode = _stringToCode

    var stringToReturn: String = ""

    var stringAfterRoterOne: String = ""
    var stringAfterRoterTwo: String = ""
    var stringAfterReflector: String = ""
    var stringAfterRoterTwo2: String = ""
    var stringAfterRoterOne2: String = ""

    fun Coding( _stringToCode: String, firstLetterInt : Int, secondLetterInt : Int): String {

        var stringToCode: String = _stringToCode
        var int1: Int = firstLetterInt
        var int2: Int = secondLetterInt
        var letter: Int

        for(i in 1..stringToCode.length) {
//          первый ротор
            letter = letterToInt[stringToCode[i-1]]!!.toInt()
            stringAfterRoterOne += roterOne[getKey(letterToInt, (letter + int1) % 27)]

//          второй ротор
            letter = letterToInt[stringAfterRoterOne[i-1]]!!.toInt()
            stringAfterRoterTwo += roterTwo[getKey(letterToInt, (letter - int1 + int2 + 27) % 27)]

//          отражатель
            letter = letterToInt[stringAfterRoterTwo[i-1]]!!.toInt()
            stringAfterReflector += reflector[getKey(letterToInt, (letter - int2 + 27) % 27)]

//          обратный порядок
//          второй ротор
            letter = letterToInt[stringAfterReflector[i-1]]!!.toInt()
            stringAfterRoterTwo2 += getKey(roterTwo, getKey(letterToInt, (letter + int2) % 27))

//          первый ротор
            letter = letterToInt[stringAfterRoterTwo2[i-1]]!!.toInt()
            stringAfterRoterOne2 += getKey(roterOne, getKey(letterToInt, (letter - int2 + int1 + 27) % 27))

//          переводим в готовую строку
            letter = letterToInt[stringAfterRoterOne2[i-1]]!!.toInt()
            stringToReturn += getKey(letterToInt, (letter - int1 + 27) % 27)

//          сдвигаем роторы
            int1++
            if (int1 % 27 == 0) {
                int1 = 0
                int2++
            }
            if (int2 % 27 == 0) {
                int2 = 0
            }
        }

        return stringToReturn
    }

    fun CodingMain(): String {
        stringToReturn = Coding(stringToCode, firstLetterInt!!.toInt(), secondLetterInt!!.toInt())
        return stringToReturn
    }
}

fun main() {
//  Данная программа является аналогом Инигмы, реализация которой находится в классе Paraskeva.
//  Она имеет 2 ротора (словари roterOne, roterTwo), отражатель (словарь reflector),
//  умеет двигать роторы, что обеспечивает надёжность шифра, таким образом 2 одинаковые буквы будут каждый
//  раз кодироваться иначе.
//  Отражатель обеспечивает симметричность кодирования, если закодировать строку, то запустив заново алгоритм от
//  новой строки, получим исходную.

    val stringInput = "BC" // настройки роторов
    var stringToCode = "THERE ARE FIVE TYPES OF SCHOOLS IN THE US EDUCATIONAL SYSTEM THEY ARE KINDERGARTEN ELEMENTARY SCHOOL MIDDLE SCHOOL HIGH SCHOOL AND PRIVATE SCHOOL CHILDREN GO TO KINDERGARTEN WHEN THEY ARE FIVE YEARS" // строка для кодирования
    val exampleOne = Paraskeva(stringInput, stringToCode) // создаём класс
    stringToCode = exampleOne.CodingMain() // кодируем
    println(stringToCode) // выводим закодированную сроку
    val exampleTwo = Paraskeva(stringInput, stringToCode) // дешифровка
    println(exampleTwo.CodingMain()) // выводим дешифрованную сроку она должна быть равна исходной
}