Minimize hamming distance in Binary String by setting only one K size substring bits

Given two binary strings S and T of length N and a positive integer K. Initially, all characters of T are '0'. The task is to find the minimum Hamming distance after choosing a substring of size K and making all elements of string T as '1' only once.

Examples:

Input: S = "101", K = 2
Output: 1
Explanation: Initially string T = "000", one possible way is to change all 0s in range [0, 1] to 1. Thus string T becomes "110" and the hamming distance between S and T is 2 which is the minimum possible.

Input: S = "1100", K=3
Output: 1

Naive Approach: The simplest approach is to consider every substring of size K and make all the elements as 1 and then check the hamming distance with string, S. After checking all the substrings, print the minimum hamming distance.

Time Complexity: O(N×K)
Auxiliary Space: O(1)

Approach: This problem can be solved by creating a prefix array sum which stores the prefix sum of the count of ones in the string S. Follow the steps below to solve the problem:

• Create a prefix sum array pref[] of string S by initializing pref[0] as 0 updating pref[i] as pref[i-1] +(S[i] - '0') for every index i.
• Store the total count of ones in the string, S in a variable cnt.
• Initialize a variable ans as cnt to store the required result.
• Iterate in the range [0, N-K] using the variable i
  • Initialize a variable val as pref[i+K-1] - pref[i-1] to store the count of ones in the substring S[i, i+K-1].
  • Create two variables A and B to store the hamming distance outside the current substring and the hamming distance inside the current substring and initialize A with cnt - K and B with K - val.
  • Update the value of ans with the minimum of ans and (A + B).
• Print the value of ans as the result.

Below is the implementation of the above approach:

// C++ program for the above approach
#include <bits/stdc++.h>
using namespace std;

// Function to find minimum Hamming
// Distance after atmost one operation
int minimumHammingDistance(string S, int K)
{
    // Store the size of the string
    int n = S.size();

    // Store the prefix sum of 1s
    int pref[n];

    // Create Prefix Sum array
    pref[0] = S[0] - '0';
    for (int i = 1; i < n; i++)
        pref[i] = pref[i - 1] + (S[i] - '0');

    // Initialize cnt as number of ones
    // in string S
    int cnt = pref[n - 1];

    // Store the required result
    int ans = cnt;

    // Traverse the string, S
    for (int i = 0; i < n - K; i++) {

        // Store the number of 1s in the
        // substring S[i, i+K-1]
        int value = pref[i + K - 1]
                    - (i - 1 >= 0 ? pref[i - 1] : 0);

        // Update the answer
        ans = min(ans, cnt - value + (K - value));
    }

    // Return the result
    return ans;
}

// Driver Code
int main()
{

    // Given Input
    string s = "101";
    int K = 2;

    // Function Call
    cout << minimumHammingDistance(s, K);

    return 0;
}

// Java program for the above approach
public class GFG 
{

// Function to find minimum Hamming
// Distance after atmost one operation
static int minimumHammingDistance(String S, int K)
{
  
    // Store the size of the string
    int n = S.length();

    // Store the prefix sum of 1s
    int []pref =  new int [n];

    // Create Prefix Sum array
    pref[0] = S.charAt(0) - '0';
    for (int i = 1; i < n; i++)
        pref[i] = pref[i - 1] + (S.charAt(i) - '0');

    // Initialize cnt as number of ones
    // in string S
    int cnt = pref[n - 1];

    // Store the required result
    int ans = cnt;

    // Traverse the string, S
    for (int i = 0; i < n - K; i++) {

        // Store the number of 1s in the
        // substring S[i, i+K-1]
        int value = pref[i + K - 1] - (i - 1 >= 0 ? pref[i - 1] : 0);

        // Update the answer
        ans = Math.min(ans, cnt - value + (K - value));
    }

    // Return the result
    return ans;
}

// Driver Code
public static void main(String args[])
{
    // Given Input
    String s = "101";
    int K = 2;

    // Function Call
    System.out.println(minimumHammingDistance(s, K));
    }
}

// This code is contributed by SoumikMondal

# Py program for the above approach

# Function to find minimum Hamming
# Distance after atmost one operation
def minimumHammingDistance(S, K):
    # Store the size of the string
    n = len(S)

    # Store the prefix sum of 1s
    pref = [0] * n

    # Create Prefix Sum array
    pref[0] = ord(S[0]) - ord('0')
    for i in range(1,n):
        pref[i] = pref[i - 1] + (ord(S[i]) - ord('0'))

    # Initialize cnt as number of ones
    # in string S
    cnt = pref[n - 1]

    # Store the required result
    ans = cnt

    # Traverse the string, S
    for i in range(n - K):
      
        # Store the number of 1s in the
        # substring S[i, i+K-1]
        value = pref[i + K - 1] - (pref[i-1] if (i - 1) >= 0 else 0)

        # Update the answer
        ans = min(ans, cnt - value + (K - value))

    # Return the result
    return ans

# Driver Code
if __name__ == '__main__':

    # Given Input
    s = "101"
    K = 2

    # Function Call
    print (minimumHammingDistance(s, K))

# This code is contributed by mohit kumar 29.

// C# program for the above approach
using System;
using System.Collections.Generic;

class GFG 
{

// Function to find minimum Hamming
// Distance after atmost one operation
static int minimumHammingDistance(string S, int K)
{
  
    // Store the size of the string
    int n = S.Length;

    // Store the prefix sum of 1s
    int []pref =  new int [n];

    // Create Prefix Sum array
    pref[0] = (int)S[0] - 48;
    for (int i = 1; i < n; i++)
        pref[i] = pref[i - 1] + ((int)S[i] - 48);

    // Initialize cnt as number of ones
    // in string S
    int cnt = pref[n - 1];

    // Store the required result
    int ans = cnt;

    // Traverse the string, S
    for (int i = 0; i < n - K; i++) {

        // Store the number of 1s in the
        // substring S[i, i+K-1]
        int value = pref[i + K - 1] - (i - 1 >= 0 ? pref[i - 1] : 0);

        // Update the answer
        ans = Math.Min(ans, cnt - value + (K - value));
    }

    // Return the result
    return ans;
}

// Driver Code
public static void Main()
{
    // Given Input
    string s = "101";
    int K = 2;

    // Function Call
     Console.Write(minimumHammingDistance(s, K));
    }
}

// This code is contributed by SURENDRA_GANGWAR.

<script>
  
// JavaScript program for the above approach

// Function to find minimum Hamming
// Distance after atmost one operation
function minimumHammingDistance(S, K)
{
  
    // Store the size of the string
    let n = S.length;

    // Store the prefix sum of 1s
    let pref =  new Array(n);

    // Create Prefix Sum array
    pref[0] = S[0] - '0';
    for (let i = 1; i < n; i++)
        pref[i] = pref[i - 1] + (S[i] - '0');

    // Initialize cnt as number of ones
    // in string S
    let cnt = pref[n - 1];

    // Store the required result
    let ans = cnt;

    // Traverse the string, S
    for (let i = 0; i < n - K; i++) {

        // Store the number of 1s in the
        // substring S[i, i+K-1]
        let value = pref[i + K - 1] - (i - 1 >= 0 ? pref[i - 1] : 0);

        // Update the answer
        ans = Math.min(ans, cnt - value + (K - value));
    }

    // Return the result
    return ans;
}

// Driver Code

    // Given Input
    let s = "101";
    let K = 2;

    // Function Call
    document.write(minimumHammingDistance(s, K));
        
</script>

2

Time Complexity: O(N)
Auxiliary Space: O(N)

huzaifa0602

Follow

Improve

Article Tags :

• Strings
• Bit Magic
• Tree
• C++
• DSA
• prefix-sum
• binary-string
• substring

+4 More

Practice Tags :

• CPP
• Bit Magic
• prefix-sum
• Strings
• Tree

+1 More