Given a string S of length N where (N ? 1). The task is to check whether by removing at most one character from the given string it can be divided into two same sub-strings or not return YES or NO for possibilities.
Examples:
Input: N = 5, S = abzab
Output: YES
Explanation: Character ‘z’ at index 3 can be removed so that the remaining S will be “abab”. Which consists of two same sub-strings “ab” and “ab”. Therefore the output is YES.Input: N = 4, S = abcd
Output: NO
Explanation: It can be verified that a given string can’t be divided into two sub-strings by removing at most one character from it.
Approach: Follow the below observations to solve the problem:
Concept of approach:
The problem is observation based and can be divided into followings parts:
- If S has length equal to 1:
- In this case it is impossible to make two equal strings.
- If S has even length:
- It should be noted that removing one character from even length will make the S string’s length equal to odd, Then we can’t divide odd length string S into two strings having the same length. Formally, only even length S can be divided into two strings. Therefore, We can’t remove any character from even length String.
- Just divide the string into two halves and compare them using in-built function String. equals(String a, String b) of String class.
- If S has odd length:
- It is possible to make two sub-strings of equal length from odd length. For example, S = “ababd”, Then it can be divided into two strings of odd and even lengths as {“ab”, “bd”}, {“aba”, “abd”} respectively by removing one or zero character.
- Then just check for both parity sub-strings separately, If they differs by at most one character or not.
Follow the below steps to solve the above approach:
- If the input String has a length equal to 1.
- Then it is not possible to make two equal strings.
- If the input string has an even length
- Then divide the input string into two halves and check if they both are the same or not using the in-built String.equals(a, b) function.
- If the input string has an odd length
- Then divide the input string into two odd and two even parts and compare if there is at most one different character, Then it is possible else not possible.
Below is the Implementation of the above approach:
C++
#include <iostream>#include <string>using namespace std;
// Function to check if there is at most// different character in strings given// as two argumentsbool check(string a, string b)
{ int l = 0;
int k = 0;
int countdiff = 0;
while (l < a.length()) {
if (k < b.length() && a[l] == b[k]) {
l++;
k++;
}
else {
l++;
countdiff++;
}
}
return countdiff <= 1;
}int main()
{ // Input N
int N = 5;
// Input String
string s = "ababz";
// If length of string is 1
if (s.length() == 1) {
cout << "NO" << endl;
}
// If length of string is even
else if (s.length() % 2 == 0) {
// First half sub-string
string fir = s.substr(0, (s.length() / 2));
// Second half sub-string
string sec = s.substr((s.length() / 2));
// If first and second are equals
// then printing YES
if (fir == sec) {
cout << "YES" << endl;
}
// Else printing NO
else {
cout << "NO" << endl;
}
}
// If length of string is odd
else {
// Four sub-strings as discussed
// in concept of approach section
string fir = s.substr(0, s.length() / 2 + 1);
string sec = s.substr(s.length() / 2 + 1);
string third = s.substr(s.length() / 2);
string fourth = s.substr(0, s.length() / 2);
// Checking using user-defined
// function that sub-strings differs
// by at most one characters or not.
if (check(fir, sec) || check(third, fourth)) {
cout << "YES" << endl;
}
else {
cout << "NO" << endl;
}
}
return 0;
} |
Java
// Java code to implement the approachimport java.io.*;
import java.math.*;
import java.util.*;
public class GFG {
// Function to check if there is at most
// different character in strings given
// as two arguments
public static boolean check(String a, String b)
{
int l = 0;
int k = 0;
int countdiff = 0;
while (l < a.length()) {
if (k < b.length()
&& a.charAt(l) == b.charAt(k)) {
l++;
k++;
}
else {
l++;
countdiff++;
}
}
return countdiff <= 1;
}
// Driver function
public static void main(String args[])
{
// Input N
int N = 5;
// Input String
String s = "ababz";
// If length of string is 1
if (s.length() == 1) {
System.out.println("NO");
}
// If length of string is even
else if (s.length() % 2 == 0) {
// First half sub-string
String fir = s.substring(0, (s.length() / 2));
// Seconf half sub-string
String sec = s.substring((s.length() / 2));
// If first and second are equals
// then printing YES
if (fir.equals(sec)) {
System.out.println("YES");
}
// Else printing NO
else {
System.out.println("NO");
}
}
// If length of string is odd
else {
// Four sub-strings as discussed
// in concept of approach section
String fir = s.substring(0, s.length() / 2 + 1);
String sec = s.substring(s.length() / 2 + 1);
String third = s.substring(s.length() / 2);
String fourth = s.substring(0, s.length() / 2);
// Checking using user-defined
// function that sub-strings differs
// by at most one characters or not.
if (check(fir, sec) || check(third, fourth)) {
System.out.println("YES");
}
else {
System.out.println("NO");
}
}
}
} |
Python3
def check(a: str, b: str) -> bool:
l = 0
k = 0
countdiff = 0
while l < len(a):
if k < len(b) and a[l] == b[k]:
l += 1
k += 1
else:
l += 1
countdiff += 1
return countdiff <= 1
def main():
# Input N
N = 5
# Input String
s = "ababz"
# If length of string is 1
if len(s) == 1:
print("NO")
# If length of string is even
elif len(s) % 2 == 0:
# First half sub-string
fir = s[0:len(s) // 2]
# Second half sub-string
sec = s[len(s) // 2:]
# If first and second are equals
# then printing YES
if fir == sec:
print("YES")
# Else printing NO
else:
print("NO")
# If length of string is odd
else:
# Four sub-strings as discussed
# in concept of approach section
fir = s[0:len(s) // 2 + 1]
sec = s[len(s) // 2 + 1:]
third = s[len(s) // 2:]
fourth = s[0:len(s) // 2]
# Checking using user-defined
# function that sub-strings differs
# by at most one characters or not.
if check(fir, sec) or check(third, fourth):
print("YES")
else:
print("NO")
if __name__ == "__main__":
main()
# This code is contributed by divya_p123.
|
C#
// C# code to implement the approachusing System;
using System.Linq;
public class GFG {
// Function to check if there is at most
// different character in strings given
// as two arguments
public static bool Check(string a, string b)
{
int l = 0;
int k = 0;
int countdiff = 0;
while (l < a.Length) {
if (k < b.Length && a[l] == b[k]) {
l++;
k++;
}
else {
l++;
countdiff++;
}
}
return countdiff <= 1;
}
static public void Main()
{
// Code
// Input N
int N = 5;
// Input String
string s = "ababz";
// If length of string is 1
if (s.Length == 1) {
Console.WriteLine("NO");
}
// If length of string is even
else if (s.Length % 2 == 0) {
// First half sub-string
string fir = s.Substring(0, s.Length / 2);
// Second half sub-string
string sec = s.Substring(s.Length / 2);
// If first and second are equals
// then printing YES
if (fir.Equals(sec)) {
Console.WriteLine("YES");
}
// Else printing NO
else {
Console.WriteLine("NO");
}
}
// If length of string is odd
else {
// Four sub-strings as discussed
// in concept of approach section
string fir = s.Substring(0, s.Length / 2 + 1);
string sec = s.Substring(s.Length / 2 + 1);
string third = s.Substring(s.Length / 2);
string fourth = s.Substring(0, s.Length / 2);
// Checking using user-defined
// function that sub-strings differs
// by at most one characters or not.
if (Check(fir, sec) || Check(third, fourth)) {
Console.WriteLine("YES");
}
else {
Console.WriteLine("NO");
}
}
}
}// This code is contributed by lokesh. |
Javascript
// Javascript code to implement the approach// Function to check if there is at most// different character in lets given// as two argumentsfunction Check(a, b)
{ let l = 0;
let k = 0;
let countdiff = 0;
while (l < a.length) {
if (k < b.length && a[l] == b[k]) {
l++;
k++;
}
else {
l++;
countdiff++;
}
}
return countdiff <= 1;
}function Main()
{ // Code
// Input N
let N = 5;
// Input String
let s = "ababz";
// If length of let is 1
if (s.length == 1) {
console.log("NO");
}
// If length of let is even
else if (s.length % 2 == 0) {
// First half sub-let
let fir = s.substring(0, s.Length / 2);
// Second half sub-let
let sec = s.substring(s.Length / 2);
// If first and second are equals
// then printing YES
if (fir.localeCompare(sec)) {
console.log("YES");
}
// Else printing NO
else {
console.log("NO");
}
}
// If length of let is odd
else {
// Four sub-lets as discussed
// in concept of approach section
let fir = s.substring(0, s.Length / 2 + 1);
let sec = s.substring(s.Length / 2 + 1);
let third = s.substring(s.Length / 2);
let fourth = s.substring(0, s.Length / 2);
// Checking using user-defined
// function that sub-lets differs
// by at most one characters or not.
if (Check(fir, sec) || Check(third, fourth)) {
console.log("YES");
}
else {
console.log("NO");
}
}
}Main()// This code is contributed by Shubham Singh. |
Output
YES
Time Complexity: O(N)
Auxiliary Space: O(1)
Related Articles: