Skip to content
Related Articles

Related Articles

Improve Article

Group consecutive characters of same type in a string

  • Difficulty Level : Easy
  • Last Updated : 27 May, 2021

Given a string str consisting of upper case alphabets, numeric digits and arithmetic operators, the task is to group them into continuous sub-strings of same type.
Examples: 
 

Input: str = “G E E K S 1 2 3 4 5” 
Output: GEEKS 12345 
All contiguous upper case characters can be grouped together 
and all the numeric characters can be grouped together in a separate group.
Input: str = “DEGFT +- * 5 6 7” 
Output: DEGFT +-* 567 
 

 

Approach: Remove all the spaces from string. After removing all the white spaces, traverse the string one by one and group the characters according to their ASCII values.
Below is the implementation of the above approach:
 

C++




// C++ implementation of the approach
#include <bits/stdc++.h>
using namespace std;
 
// Function to return the modified string
string groupCharacters(string s, int len)
{
 
    // Store original string
    string temp = "";
 
    // Remove all white spaces
    for (int i = 0; i < len; i++)
        if (s[i] != ' ')
            temp = temp + s[i];
 
    len = temp.length();
 
    // To store the resultant string
    string ans = "";
    int i = 0;
 
    // Traverse the string
    while (i < len) {
 
        // Group upper case characters
        if (int(temp[i]) >= int('A')
            && int(temp[i]) <= int('Z')) {
            while (i < len && int(temp[i]) >= int('A')
                   && int(temp[i]) <= int('Z')) {
                ans = ans + temp[i];
                i++;
            }
            ans = ans + " ";
        }
 
        // Group numeric characters
        else if (int(temp[i]) >= int('0')
                 && int(temp[i]) <= int('9')) {
            while (i < len && int(temp[i]) >= int('0')
                   && int(temp[i]) <= int('9')) {
                ans = ans + temp[i];
                i++;
            }
            ans = ans + " ";
        }
 
        // Group arithmetic operators
        else {
            while (i < len && int(temp[i]) >= int('*')
                   && int(temp[i]) <= int('/')) {
                ans = ans + temp[i];
                i++;
            }
            ans = ans + " ";
        }
    }
 
    // Return the resultant string
    return ans;
}
 
// Driver code
int main()
{
    string s = "34FTG234+ +- *";
    int len = s.length();
    cout << groupCharacters(s, len);
    return 0;
}
Java



// Java implementation of the approach
class GFG {
 
  
// Function to return the modified String
static String groupCharacters(char []s, int len)
{
  
    // Store original String
    String temp = "";
  
    // Remove all white spaces
    for (int i = 0; i < len; i++)
        if (s[i] != ' ')
            temp = temp + s[i];
  
    len = temp.length();
  
    // To store the resultant String
    String ans = "";
    int i = 0;
  
    // Traverse the String
    while (i < len) {
  
        // Group upper case characters
        if (temp.charAt(i) >= ('A')
            && temp.charAt(i) <= ('Z')) {
            while (i < len && temp.charAt(i) >= ('A')
                   && temp.charAt(i) <= ('Z')) {
                ans = ans + temp.charAt(i);
                i++;
            }
            ans = ans + " ";
        }
  
        // Group numeric characters
        else if (temp.charAt(i) >= ('0')
                 && temp.charAt(i) <= ('9')) {
            while (i < len && temp.charAt(i) >= ('0')
                   && temp.charAt(i) <= ('9')) {
                ans = ans + temp.charAt(i);
                i++;
            }
            ans = ans + " ";
        }
  
        // Group arithmetic operators
        else {
            while (i < len && temp.charAt(i) >= ('*')
                   && temp.charAt(i) <= ('/')) {
                ans = ans + temp.charAt(i);
                i++;
            }
            ans = ans + " ";
        }
    }
  
    // Return the resultant String
    return ans;
}
  
// Driver code
public static void main(String[] args) {
   String s = "34FTG234+ +- *";
    int len = s.length();
    System.out.print(groupCharacters(s.toCharArray(), len));
    }
}
// This code contributed by Rajput-Ji
Python 3



# Python 3 implementation of the approach
 
# Function to return the modified string
def groupCharacters(s, l):
 
    # Store original string
    temp = ""
 
    # Remove all white spaces
    for i in range(l):
        if (s[i] != ' '):
            temp = temp + s[i]
 
    l = len(temp)
 
    # To store the resultant string
    ans = ""
    i = 0
 
    # Traverse the string
    while (i < l):
 
        # Group upper case characters
        if (ord(temp[i]) >= ord('A')
            and ord(temp[i]) <= ord('Z')):
            while (i < l and ord(temp[i]) >= ord('A')
                and ord(temp[i]) <= ord('Z')) :
                ans = ans + temp[i]
                i += 1
     
            ans = ans + " "
 
        # Group numeric characters
        elif (ord(temp[i]) >= ord('0')
                and ord(temp[i]) <= ord('9')):
            while (i < l and ord(temp[i]) >= ord('0')
                and ord(temp[i]) <= ord('9')):
                ans = ans + temp[i]
                i += 1
            ans = ans + " "
 
        # Group arithmetic operators
        else :
            while (i < l and ord(temp[i]) >= ord('*')
                and ord(temp[i]) <= ord('/')):
                ans = ans + temp[i]
                i += 1
            ans = ans + " "
 
    # Return the resultant string
    return ans
 
# Driver code
if __name__ == "__main__":
     
    s = "34FTG234+ +- *"
    l = len(s)
    print(groupCharacters(s, l))
 
# This code is contributed by Ita_c
C#



// C# implementation of the approach
using System;
 
class GFG
{
 
    // Function to return the modified String
    static String groupCharacters(char []s, int len)
    {
     
        // Store original String
        string temp = "";
     
        // Remove all white spaces
        for (int j = 0; j < len; j++)
            if (s[j] != ' ')
                temp = temp + s[j];
     
        len = temp.Length;
     
        // To store the resultant String
        string ans = "";
        int i = 0;
     
        // Traverse the String
        while (i < len)
        {
     
            // Group upper case characters
            if (temp[i] >= ('A')
                && temp[i] <= ('Z'))
            {
                while (i < len && temp[i] >= ('A')
                    && temp[i] <= ('Z'))
                {
                    ans = ans + temp[i];
                    i++;
                }
                ans = ans + " ";
            }
     
            // Group numeric characters
            else if (temp[i] >= ('0')
                    && temp[i] <= ('9'))
            {
                while (i < len && temp[i] >= ('0')
                    && temp[i] <= ('9'))
                {
                    ans = ans + temp[i];
                    i++;
                }
                ans = ans + " ";
            }
     
            // Group arithmetic operators
            else
            {
                while (i < len && temp[i] >= ('*')
                    && temp[i] <= ('/'))
                {
                    ans = ans + temp[i];
                    i++;
                }
                ans = ans + " ";
            }
        }
     
        // Return the resultant String
        return ans;
    }
     
    // Driver code
    public static void Main()
    {
        string s = "34FTG234+ +- *";
        int len = s.Length;
        Console.WriteLine(groupCharacters(s.ToCharArray(), len));
    }
}
 
// This code contributed by Ryuga
PHP



<?php
// PHP implementation of the approach
 
// Function to return the modified string
function groupCharacters($s, $len)
{
 
    // Store original string
    $temp = "";
 
    // Remove all white spaces
    for ($i = 0; $i < $len; $i++)
        if ($s[$i] != ' ')
            $temp = $temp.$s[$i];
 
    $len = strlen($temp);
 
    // To store the resultant string
    $ans = "";
    $i = 0;
 
    // Traverse the string
    while ($i < $len)
    {
 
        // Group upper case characters
        if (ord($temp[$i]) >= ord('A') &&
            ord($temp[$i]) <= ord('Z'))
        {
            while ($i < $len && ord($temp[$i]) >= ord('A') &&
                                ord($temp[$i]) <= ord('Z'))
            {
                $ans = $ans.$temp[$i];
                $i++;
            }
            $ans = $ans . " ";
        }
 
        // Group numeric characters
        else if (ord($temp[$i]) >= ord('0') &&
                 ord($temp[$i]) <= ord('9'))
        {
            while ($i < $len && ord($temp[$i]) >= ord('0') &&
                                ord($temp[$i]) <= ord('9'))
            {
                $ans = $ans.$temp[$i];
                $i++;
            }
            $ans = $ans . " ";
        }
 
        // Group arithmetic operators
        else
        {
            while ($i < $len && ord($temp[$i]) >= ord('*') &&
                                ord($temp[$i]) <= ord('/'))
            {
                $ans = $ans.$temp[$i];
                $i++;
            }
            $ans = $ans . " ";
        }
    }
 
    // Return the resultant string
    return $ans;
}
 
// Driver code
$s = "34FTG234+ +- *";
$len = strlen($s);
print(groupCharacters($s, $len));
     
// This code is contributed by mits
?>
Javascript



<script>
// Javascript implementation of the approach
 
// Function to return the modified String
function groupCharacters(s,len)
{
    // Store original String
    let temp = "";
    
    // Remove all white spaces
    for (let i = 0; i < len; i++)
        if (s[i] != ' ')
            temp = temp + s[i];
    
    len = temp.length;
    
    // To store the resultant String
    let ans = "";
    let i = 0;
    
    // Traverse the String
    while (i < len) {
    
        // Group upper case characters
        if (temp[i] >= ('A')
            && temp[i] <= ('Z')) {
            while (i < len && temp[i] >= ('A')
                   && temp[i] <= ('Z')) {
                ans = ans + temp[i];
                i++;
            }
            ans = ans + " ";
        }
    
        // Group numeric characters
        else if (temp[i] >= ('0')
                 && temp[i] <= ('9')) {
            while (i < len && temp[i] >= ('0')
                   && temp[i] <= ('9')) {
                ans = ans + temp[i];
                i++;
            }
            ans = ans + " ";
        }
    
        // Group arithmetic operators
        else {
            while (i < len && temp[i] >= ('*')
                   && temp[i] <= ('/')) {
                ans = ans + temp[i];
                i++;
            }
            ans = ans + " ";
        }
    }
    
    // Return the resultant String
    return ans;
}
 
// Driver code
let s = "34FTG234+ +- *";
let len = s.length;
document.write(groupCharacters(s.split(""), len));
 
 
         
// This code is contributed by rag2127
</script>
Output: 
34 FTG 234 ++-*
 
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
Previous
Scala | Tuple
Next

atd command in Linux with examples
Recommended Articles
Page :
Check If every group of a's is followed by a group of b's of same length
06, Dec 18
Minimum characters that are to be inserted such that no three consecutive characters are same
30, Sep 19
Modify characters of a string by adding integer values of same-indexed characters from another given string
01, Mar 21
Rearrange string such that no pair of adjacent characters are of the same type
21, Sep 20
Minimum Cost of deletions such that string does not contains same consecutive characters
27, Apr 20
Group words with same set of characters
18, Mar 17
Rearrange the characters of the string such that no two adjacent characters are consecutive English alphabets
25, Jul 19
Min flips of continuous characters to make all characters same in a string
12, Jul 17
String with k distinct characters and no same characters adjacent
25, Oct 17
Make all characters of a string same by minimum number of increments or decrements of ASCII values of characters
10, Feb 21
Minimize swaps of pairs of characters required such that no two adjacent characters in the string are same
09, Jul 21
Rearrange characters in a sorted string such that no pair of adjacent characters are the same
23, Jul 21
Longest substring such that no three consecutive characters are same
17, Sep 19
Strings formed from given characters without any consecutive repeating characters
18, Mar 20
Check if given strings can be made same by swapping two characters of same or different strings
07, Dec 20
Check whether two strings contain same characters in same order
31, May 19
Minimum characters to be replaced to make frequency of all characters same
30, Apr 20
Minimize swaps of same-indexed characters to make sum of ASCII value of characters of both the strings odd
10, Feb 21
Generate a Binary String without any consecutive 0's and at most K consecutive 1's
29, Jul 20
Check if a string can be made palindromic by swapping pairs of characters from indices having unequal characters in a Binary String
31, Mar 21
Longest Common Subsequence (LCS) by repeatedly swapping characters of a string with characters of another string
22, Mar 21
Check if a binary string contains consecutive same or not
25, Jan 19
Check if a string can be converted to another by swapping of adjacent characters of given type
01, Sep 20
Minimum Group Flips to Make Binary Array Elements Same
23, May 20
Article Contributed By :
https://media.geeksforgeeks.org/auth/avatar.png
Sairahul Jella
@Sairahul Jella
Vote for difficulty
Current difficulty :
Easy





Improved By :
Article Tags :
Practice Tags :
Report Issue

We use cookies to ensure you have the best browsing experience on our website. By using our site, you
acknowledge that you have read and understood our
Cookie Policy &
        Privacy Policy

Lightbox