Related Articles

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

• Difficulty Level : Medium
• Last Updated : 10 Aug, 2021

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 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++

 `// C++ program for the above approach``#include ``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 = S - ``'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

 `// 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`

## Python3

 `# 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#

 `// 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 = (``int``)S - 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.`

## Javascript

 ``
Output
`2`

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

Attention reader! Don’t stop learning now. Get hold of all the important DSA concepts with the DSA Self Paced Course at a student-friendly price and become industry ready.  To complete your preparation from learning a language to DS Algo and many more,  please refer Complete Interview Preparation Course.

In case you wish to attend live classes with experts, please refer DSA Live Classes for Working Professionals and Competitive Programming Live for Students.

My Personal Notes arrow_drop_up