Open In App
Related Articles

Check if a character is only occurring as one single contiguous substring or not

Improve
Improve
Improve
Like Article
Like
Save Article
Save
Report issue
Report

Given string str of length N. The task is to determine whether a character is only occurring as a single contiguous substring or not i.e., there should not exist any other alphabet characters in between two same alphabets in the string.

Examples:

Input: “aAa”
Output: False
Explanation: There exists ‘A’ in between ‘a’ and ‘a’. Hence “aa” becomes discontinuous.

Input: “aaAAbbBB”
Output: True
Explanation: Different segments formed from the given input are “aa”, “AA”, “bb” and “BB” are all continuous and have no hurdles in between.

Approach: To solve the given problem use the following idea:

Store the last occurrence of each character in Hash-Map so that it can be compared with its previous occurrence and find the distance between them. If this distance comes to be more than 1 then it is discontinuous else continuous.

Follow the given steps to solve the given problem:

  • Traverse string str (say i).
  • If str[i] is present in the map
    • If the difference between the last occurrence and (i + 1) is equal to 1 then update the last occurrence of the i-th character.
    • Else return false.
  • Else update the last occurrence of i-th character in the Hash map as (i + 1).
  • Return True after the loop is over.

Below is the implementation for the above approach: 

C++14

// C++ code for the above approach
#include <bits/stdc++.h>
using namespace std;
 
bool isContinuous(string& temp)
{
    // Creating Hashmap to store the
    // last position of a character
    unordered_map<char, int> last_Pos;
 
    for (int i = 0; i < temp.length(); i++) {
        // if character is already
        // present in Hashmap
        if (last_Pos[temp[i]]) {
            // if the last position of the
            // character is previous index
            // update last position
            if (i - last_Pos[temp[i]] + 1 <= 1) {
                last_Pos[temp[i]] = i + 1;
            }
            else {
                return 0;
            }
        }
        else {
            last_Pos[temp[i]] = i + 1;
        }
    }
    return 1;
}
 
// Driver code
int main()
{
    string str = "aaAAbbBB";
    if (isContinuous(str)) {
        cout << "True";
    }
    else {
        cout << "False";
    }
    return 0;
}
// this code is contributed by prophet1999

                    

Java

// Java code for the above approach
import java.io.*;
import java.util.*;
 
class GFG {
 
  static boolean isContinuous(String temp)
  {
 
    // Creating Hashmap to store the last position of a
    // character
    HashMap<Character, Integer> last_Pos
      = new HashMap<Character, Integer>();
 
    for (int i = 0; i < temp.length(); i++)
    {
 
      // if character is already present in Hashmap
      if (last_Pos.containsKey(temp.charAt(i)))
      {
 
        // if the last position of the character is
        // previous index update last position
        if (i - last_Pos.get(temp.charAt(i)) + 1
            <= 1) {
          last_Pos.put(temp.charAt(i), i + 1);
        }
        else {
          return false;
        }
      }
      else {
        last_Pos.put(temp.charAt(i), i + 1);
      }
    }
    return true;
  }
 
  public static void main(String[] args)
  {
    String str = "aaAAbbBB";
    if (isContinuous(str)) {
      System.out.print("True");
    }
    else {
      System.out.print("False");
    }
  }
}
 
// This code is contributed by lokeshmvs21.

                    

Python3

# Python3 code for the above approach
def isContinuous(temp) :
 
    # Creating Hashmap to store the
    # last position of a character
    last_Pos = dict.fromkeys(temp,0);
 
    for i in range(len(temp)) :
         
        # if character is already
        # present in Hashmap
        if (last_Pos[temp[i]]) :
            # if the last position of the
            # character is previous index
            # update last position
            if (i - last_Pos[temp[i]] + 1 <= 1) :
                last_Pos[temp[i]] = i + 1;
             
            else :
                return 0;
             
        else :
            last_Pos[temp[i]] = i + 1;
         
    return 1;
 
# Driver code
if __name__ == "__main__" :
 
    string = "aaAAbbBB";
     
    if (isContinuous(string)) :
        print("True");
     
    else :
        print("False");
 
    # This code is contributed by AnkThon

                    

C#

// Include namespace system
using System;
using System.Collections.Generic;
using System.Collections;
 
public class GFG
{
  public static bool isContinuous(String temp)
  {
    // Creating Hashmap to store the last position of a
    // character
    var last_Pos = new Dictionary<char, int>();
    for (int i = 0; i < temp.Length; i++)
    {
      // if character is already present in Hashmap
      if (last_Pos.ContainsKey(temp[i]))
      {
        // if the last position of the character is
        // previous index update last position
        if (i - last_Pos[temp[i]] + 1 <= 1)
        {
          last_Pos[temp[i]] = i + 1;
        }
        else
        {
          return false;
        }
      }
      else
      {
        last_Pos[temp[i]] = i + 1;
      }
    }
    return true;
  }
  public static void Main(String[] args)
  {
    var str = "aaAAbbBB";
    if (GFG.isContinuous(str))
    {
      Console.Write("True");
    }
    else
    {
      Console.Write("False");
    }
  }
}
 
// This code is contributed by adityapburujwale

                    

Javascript

<script>
// Javascript code for the above approach
 
 
function isContinuous(temp) {
    // Creating Hashmap to store the
    // last position of a character
    let last_Pos = new Map();
 
    for (let i = 0; i < temp.length; i++) {
        // if character is already
        // present in Hashmap
        if (last_Pos.get(temp[i])) {
            // if the last position of the
            // character is previous index
            // update last position
            if (i - last_Pos.get(temp[i]) + 1 <= 1) {
                last_Pos.set(temp[i], i + 1);
            }
            else {
                return 0;
            }
        }
        else {
            last_Pos.set(temp[i], i + 1);
        }
    }
    return 1;
}
 
// Driver code
 
let str = "aaAAbbBB";
if (isContinuous(str)) {
    document.write("True");
}
else {
    document.write("False");
}
 
// this code is contributed by Saurabh Jaiswal
</script>

                    

Output
True

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



Last Updated : 13 Mar, 2023
Like Article
Save Article
Previous
Next
Share your thoughts in the comments
Similar Reads