Hamming

"use srict"
//используются 8-битные кодовые слова, соответственно переходящие в 12-битный код
//возможно кодировать и декодировать сообщения любой длины

function Encode(message) {
    let binaryRepresentation = GetBinaryStringRepresentationASCII(message);
    const wordLength = 8;
    let words = SplitMessageIntoWords(binaryRepresentation, wordLength);
    let encodedWords = [];

    for (let i = 0; i < words.length; i++) {
        let wordWithZeroControlBits = InsertZeroControlBitsIntoWord(words[i]);
        encodedWords.push(CalculateControlBitsInWord(wordWithZeroControlBits));
    }
    return encodedWords.join("");
}


function Decode(message) {
    const wordLength = 12;
    let words = SplitMessageIntoWords(message, wordLength);
    let decodedWords = []

    for (let i = 0; i < words.length; i++) {
        let wordToDecode = words[i];
        let mistakePosition = GetSingleMistakePosition(wordToDecode);
        if (mistakePosition != 0) wordToDecode = CorrectSingleMistake(wordToDecode, mistakePosition - 1);
        decodedWords.push(DecodeWord(wordToDecode));
    }
    return decodedWords.join("");
}


function DecodeWord(word) {
    let binaryMessageWord = DeleteControlBits(word);
    let binaryASCIIcode = DeleteLeadingZeros(binaryMessageWord);
    let decimalASCIIcode = parseInt(binaryASCIIcode.join(""), 2);
    let messageWord = String.fromCharCode(decimalASCIIcode);
    return messageWord;
}


function GetSingleMistakePosition(word) {
    let syndromMatrix = CalculateControlBitsSequence(word);
    let mistakePositionBinaryWithZeros = syndromMatrix.reverse();
    let mistakePositionBinary = DeleteLeadingZeros(mistakePositionBinaryWithZeros);
    return mistakePositionBinary === undefined ? 0 : parseInt(mistakePositionBinary.join(""), 2);
}


function CorrectSingleMistake(word, mistakePosition) {
    let beforeMistake = word.slice(0, mistakePosition);
    let correctedMistake = (word[mistakePosition] == 1 ? 0 : 1)
    let afterMistake = word.slice(mistakePosition + 1, word.length);
    return (beforeMistake.concat(correctedMistake)).concat(afterMistake);
}


function InsertZeroControlBitsIntoWord(word) {
    let result = [];
    for (let i = 1, k = 0; k < word.length; i++) {
        if (CanNumberBePowerOfTwo(i)) {
            result.push(0);
        } else {
            result.push(word[k]);
            k++;
        }
    }
    return result;
}


function CalculateControlBitsSequence(word) {
    let controlBitsSequence = [];
    let transformationMatrix = GetTransformationMartix(word.length);

    for (let i = 1; i < word.length + 1; i++) {
        if (CanNumberBePowerOfTwo(i)) {
            let controlBit = 0;
            for (let k = 0; k < word.length; k++) {
                controlBit += word[k] * transformationMatrix[k][Log2(i)];
            }
            controlBitsSequence.push(controlBit % 2);
        }
    }
    return controlBitsSequence;
}


function DeleteControlBits(word) {
    let result = [];
    for (let i = 0; i < word.length; i++) {
        if (CanNumberBePowerOfTwo(i + 1)) {
            continue;
        } else {
            result.push(word[i]);
        }
    }
    return result;
}


function DeleteLeadingZeros(word) {
    for (let i = 0; i < word.length; i++) {
        if (word[i] == 0) continue;
        return word.slice(i, word.length);
    }
}


function CalculateControlBitsInWord(word) {
    let result = [];
    let controlBitsSequence = CalculateControlBitsSequence(word)

    for (let i = 1, k = 0; i < word.length + 1; i++) {
        if (CanNumberBePowerOfTwo(i)) {
            result.push(String(controlBitsSequence[k]));
            k++;
        } else {
            result.push(String(word[i - 1]));
        }
    }

    return result.join("");
}


function GetTransformationMartix(wordLength) {
    let result = [];
    for (let i = 1; i < wordLength + 1; i++) {
        let binaryIndex = GetNumberInBinaryNumberSystem(i, 4);
        result.push(GetArrayFromString(binaryIndex).reverse());
    }
    return result;
}


function GetBinaryStringRepresentationASCII(string) {
    let result = "";
    let amountOfDigits = 8;
    for (let i = 0 ; i < string.length; i++) {
        let charCode = string.charCodeAt(i);
        result += GetNumberInBinaryNumberSystem(charCode, amountOfDigits);
    }
    return result;
}


function SplitMessageIntoWords(message, wordLength) {
    let result = [];
    for (let i = 0; i < message.length; i += wordLength) {
        let word = message.slice(i, i + wordLength);
        result.push(GetArrayFromString(word));
    }
    return result;
}


function GetArrayFromString(string) {
    result = [];
    for (let i = 0; i < string.length; i++) {
        result.push(+string[i]);
    }
    return result;
}


function CanNumberBePowerOfTwo(number) {
    for (let i = 0; ; i++) {
        if (number == 2**i) return true;
        if (number < 2**i) return false;
    }
}


function Log2(x) {
    for (let i = 0; ; i++) {
        if (x == 2**i) return i;
    }
}


function GetNumberInBinaryNumberSystem(number, amountOfDigits) {
    let binary = number.toString(2);
    return binary.length < amountOfDigits ?
            MultiplyString("0", amountOfDigits - binary.length) + binary :
            binary;
}


function MultiplyString(string, times) {
    let result = "";
    for (let i = 0; i < times; i++) {
        result += string;
    }
    return result;
}


test();
function test() {
    let test = "k"; //"100111011011"
    let testEncodedFull = Encode(test);
    let testDecodedFull = Decode(testEncodedFull);
    let testDecodeWithSingleMistake = Decode("000111011011")
}