JavaScript Program to Find i’th Index Character in a Binary String Obtained After n Iterations

// Javascript Program to find ith
// character in a binary String.

let s = "";

// Function to store binary Representation
function binary_conversion(m) {
    while (m !== 0) {
        let tmp = m % 2;
        s += tmp.toString();
        m = Math.floor(m / 2);
    }

    s = s.split("").reverse().join("");
}

// Function to find ith character
function find_character(n, m, i) {
    // Function to change decimal to binary
    binary_conversion(m);

    let s1 = "";

    for (let x = 0; x < n; x++) {
        let temp = "";

        for (let y = 0; y < s.length; y++) {
            temp += s[y] === '1' ? "10" : "01";
        }

        // Assign temp String in s String
        s = temp;
    }

    return s[i] === '1' ? 1 : 0;
}
let m = 5, n = 2, i = 8;
console.log(find_character(n, m, i));

// Javascript program to find ith
// Index character in a binary
// string obtained after n iterations

// Function to find
// the i-th character
function KthCharacter(m, n, k) {

    // Distance between two
    // consecutive elements
    // after N iterations
    let distance = Math.pow(2, n);
    let Block_number = Math.floor(k / distance);
    let remaining = k % distance;

    let s = new Array(32).fill(0);
    let x = 0;

    // Binary representation of M using a while loop
    while (m > 0) {
        s[x] = m % 2;
        m = Math.floor(m / 2);
        x++;
    }

    // kth digit will be
    // derived from root
    // for sure
    let root = s[x - 1 -
        Block_number];

    if (remaining == 0) {
        console.log(root);
        return;
    }

    // Check whether there is
    // need to flip root or not
    let flip = true;
    while (remaining > 1) {
        if ((remaining & 1) > 0) {
            flip = !flip;
        }
        remaining = remaining >> 1;
    }

    if (flip) {
        console.log((root > 0) ? 0 : 1);
    }
    else {
        console.log(root);
    }
}
let m = 5, k = 5, n = 3;
KthCharacter(m, n, k);

function getIthCharacter(m, n, i) {
    // Function to convert decimal to binary and store as a string
    function toBinaryString(m) {
        return m.toString(2);
    }

    // Recursive function to find the ith character after n iterations
    function findIthChar(binaryStr, n, i) {
        if (n == 0) {
            // Base case: if no iterations left, return the character at position i
            return binaryStr[i];
        }

        let length = Math.pow(2, n); // Length of the string after n iterations
        let mid = length / 2;

        if (i < mid) {
            // If i is in the first half, it corresponds to the same position in the previous iteration
            return findIthChar(binaryStr, n - 1, i);
        } else {
            // If i is in the second half, it corresponds to the complement of the position in the first half
            return findIthChar(binaryStr, n - 1, i - mid) == '0' ? '1' : '0';
        }
    }

    let binaryStr = toBinaryString(m); // Convert m to binary
    return findIthChar(binaryStr, n, i);
}

// Example usage:
let m = 5, n = 2, i = 3;
console.log(getIthCharacter(m, n, i)); // Output: 1

m = 3, n = 3, i = 6;
console.log(getIthCharacter(m, n, i)); // Output: 1

function getIthCharacter(m, n, i) {
    function toBinaryString(m) {
        return m.toString(2);
    }
    function findIthChar(binaryStr, n, i) {
        while (n > 0) {
            let length = Math.pow(2, n);
            let mid = length / 2;

            if (i < mid) { 
            } else {
                i -= mid;
                binaryStr = binaryStr.split('').map(char => char === '0' ? '1' : '0').join(''); // Complement the binary string
            }
            n--;
        }
        return binaryStr[i];
    }

    let binaryStr = toBinaryString(m);
    return findIthChar(binaryStr, n, i);
}

let m = 5, n = 2, i = 3;
console.log(getIthCharacter(m, n, i))

m = 3, n = 3, i = 6;
console.log(getIthCharacter(m, n, i))