Queries on substring palindrome formation

<script>
// Javascript program to Queries on substring
// palindrome formation.
    
     // Query type 1: update string
    // position i with character x.
    function qType1(l,x,str1)
    {
        str1[l - 1] = x;
    }
    
    // Print "Yes" if range [L..R] can form
    // palindrome, else print "No".
    function qType2(l,r,str1)
    {
        let freq = new Array(27);
        for(let i=0;i<27;i++)
        {
            freq[i]=0;
        }
  
        // Find the frequency of each
        // character in S[L...R].
        for (let i = l - 1; i <= r - 1; i++) {
        
            freq[str1[i].charCodeAt(0) - 'a'.charCodeAt(0)]++;
        }
  
        // Checking if more than one character
        // have frequency greater than 1.
        let count = 0;
        for (let j = 0; j < 26; j++) {
            if (freq[j] % 2 != 0) {
                count++;
            }
        }
        if (count <= 1) {
            document.write("Yes<br>");
        }
        else {
            document.write("No<br>");
        }
    }
    
    // Driven code
    let str="geeksforgeeks".split("");
    let n = str.length;
    qType1(4, 'g', str);
    qType2(1, 4, str);
    qType2(2, 3, str);
    qType1(10, 't', str);
    qType2(10, 11, str);
    

// This code is contributed by patel2127
</script>

<script>

// Javascript program to Queries
// on substring palindrome
// formation.
    
    let max = 1000;
    // Return the frequency of the character in the
    // i-th prefix.
    function getFrequency(tree,idx,i)
    {
        let sum = 0;
 
        while (idx > 0) {
            sum += tree[idx][i];
            idx -= (idx & -idx);
        }
 
        return sum;
    }
    
    // Updating the BIT
    function update(tree,idx,val,i)
    {
        while (idx <= max) {
            tree[idx][i] += val;
            idx += (idx & -idx);
        }
    }
    
    // Query to update the character in the string.
    function qType1(tree,l,x,str)
    {
        // Adding -1 at L position
        update(tree, l, -1, 
        str[l - 1].charCodeAt(0) - 97 + 1);
 
        // Updating the character
        str[l - 1] = x;
 
        // Adding +1 at R position
        update(tree, l, 1, 
        str[l - 1].charCodeAt(0) - 97 + 1);
    }
    
    // Query to find if rearrangement 
    // of character in range
    // L...R can form palindrome
    function qType2(tree,l,r,str)
    {
        let count = 0;
 
        for (let i = 1; i <= 26; i++) {
            // Checking on the first character
            // of the string S.
            if (l == 1) {
                if (getFrequency(tree, r, i) % 2 == 1)
                    count++;
            }
            else {
                // Checking if frequency of 
                // character is even or odd.
                if ((getFrequency(tree, r, i) - 
                getFrequency(tree, l - 1, i)) % 2 == 1)
                    count++;
            }
        }
 
        if (count <= 1)
            document.write("Yes<br>");
        else
            document.write("No<br>");
    }
    
    // Creating the Binary Index Tree of all alphabet
    function buildBIT(tree,str,n)
    {
        for (let i = 0; i < n; i++)
            update(tree, i + 1, 1, 
            str[i].charCodeAt(0) - 97 + 1);
    }
    
    // Driver code
    let str="geeksforgeeks".split("");
    let n = str.length;
    let tree=new Array(max);
    for(let i=0;i<tree.length;i++)
    {
        tree[i]=new Array(27);
        for(let j=0;j<tree[i].length;j++)
        {
            tree[i][j]=0;
        }
    }
    
    buildBIT(tree, str, n);
 
    qType1(tree, 4, 'g', str);
    qType2(tree, 1, 4, str);
    qType2(tree, 2, 3, str);
    qType1(tree, 10, 't', str);
    qType2(tree, 10, 11, str);
    

// This code is contributed by unknown2108

</script>