Data Structure
Networking
RDBMS
Operating System
Java
MS Excel
iOS
HTML
CSS
Android
Python
C Programming
C++
C#
MongoDB
MySQL
Javascript
PHP
Physics
Chemistry
Biology
Mathematics
English
Economics
Psychology
Social Studies
Fashion Studies
Legal Studies
- Selected Reading
- UPSC IAS Exams Notes
- Developer's Best Practices
- Questions and Answers
- Effective Resume Writing
- HR Interview Questions
- Computer Glossary
- Who is Who
Modify string by inserting characters such that every K-length substring consists of unique characters only
A common task when working with strings is to make sure that a string adheres to certain conditions. One of these conditions could be to ensure that every substring of length K in the string contains unique characters only. This is a frequent requirement in problems related to data encoding, string manipulation, and cryptography.
Problem Statement
The problem we are trying to solve can be stated as follows −
Given a string str and an integer K, modify the string by inserting characters such that every substring of length K in the string contains unique characters only.
Proposed Solution
We can tackle this problem by using a sliding window technique, which is a method for efficiently checking properties of contiguous subarrays or substrings in a larger array or string.
Let's detail the steps of the algorithm −
Initialize an empty unordered_map (hashmap) to keep track of the frequency of characters in the current substring.
Iterate over the characters in the string using a sliding window of size K.
If a character is already in the hashmap, insert new characters until we get a unique character or the size of the sliding window is K.
Move the sliding window by one character and repeat the process until we reach the end of the string.
The time complexity of this algorithm is O(n), where n is the length of the string. This is because we are traversing each character in the string once.
Example
Let's look at the C++ code implementing the above algorithm −
#include<bits/stdc++.h>
using namespace std;
string modifyString(string str, int K) {
int n = str.size();
string result = "";
for(int i = 0; i < n; i++) {
unordered_map<char, int> freq;
int j = i;
while(j < n && j < i + K) {
while(j < n && freq[str[j]]) {
result += 'a' + (rand() % 26); // insert a random character
}
freq[str[j++]]++;
result += str[j];
}
i = j - 1;
}
return result;
}
int main() {
string str = "abcabc";
int K = 3;
cout << modifyString(str, K) << endl;
return 0;
}
Output
bcabc
This code will insert a random lowercase English letter when it encounters a repeating character.
Testcase Example
Let's take an example to understand this better.
Consider the string str = "abcabc" and K = 3.
After running the code, you may get a result like abcxyzabc. The three-character substrings are abc, bcx, cxy, xyz, yza, zab, abc, which all contain unique characters.
Note − The result may vary because we are inserting random characters.
Conclusion
In conclusion, this algorithm provides a way to modify a string to ensure that every K-length substring has unique characters. It's an efficient solution, leveraging the power of the sliding window technique and the flexibility of C++. We encourage you to experiment with different strings and values of K to fully grasp the concept.
79 Views
