Maximum consecutive repeating character in string

Given a string, the task is to find the maximum consecutive repeating character in a string.
Note: We do not need to consider the overall count, but the count of repeating that appears in one place.
Examples:

Input : str = "geeekk"
Output : e
Input : str = "aaaabbcbbb"
Output : a

The simple solution to this problem is to use two for loops. The outer loop considers the current character, the inner loop counts occurrences of the current character. If the count goes beyond the current maximum count, we update the result. 

C++

// C++ program to find the maximum consecutive
// repeating character in given string
#include<bits/stdc++.h>
using namespace std;

// function to find out the maximum repeating
// character in given string
char maxRepeating(string str)
{
    int len = str.length();
    int count = 0;

    // Find the maximum repeating character
    // starting from str[i]
    char res = str[0];
    for (int i=0; i<len; i++)
    {
        int cur_count = 1;
        for (int j=i+1; j<len; j++)
        {
            if (str[i] != str[j])
                break;
            cur_count++;
        }

        // Update result if required
        if (cur_count > count)
        {
            count = cur_count;
            res = str[i];
        }
    }
    return res;
}

// Driver code
int main()
{

    string str = "aaaabbaaccde";
    cout << maxRepeating(str);
    return 0;
}

Java

// Java program to find the maximum consecutive
// repeating character in given string
public class GFG {

    // function to find out the maximum repeating
    // character in given string
    static char maxRepeating(String str)
    {
        int len = str.length();
        int count = 0;

        // Find the maximum repeating character
        // starting from str[i]
        char res = str.charAt(0);
        for (int i=0; i<len; i++)
        {
            int cur_count = 1;
            for (int j=i+1; j<len; j++)
            {
                if (str.charAt(i) != str.charAt(j))
                    break;
                cur_count++;
            }

            // Update result if required
            if (cur_count > count)
            {
                count = cur_count;
                res = str.charAt(i);
            }
        }
        return res;
    }

    // Driver code
    public static void main(String args[])
    {

        String str = "aaaabbaaccde";
        System.out.println(maxRepeating(str));
    }
}
// This code is contributed by Sumit Ghosh

Python 3

# Python 3 program to find the
# maximum consecutive repeating
# character in given string

# function to find out the maximum
# repeating character in given string
def maxRepeating(str):

    l = len(str)
    count = 0

    # Find the maximum repeating
    # character starting from str[i]
    res = str[0]
    for i in range(l):

        cur_count = 1
        for j in range(i + 1, l):

            if (str[i] != str[j]):
                break
            cur_count += 1

        # Update result if required
        if cur_count > count :
            count = cur_count
            res = str[i]
    return res

# Driver code
if __name__ == "__main__":

    str = "aaaabbaaccde"
    print(maxRepeating(str))

# This code is contributed
# by ChitraNayal

C#

// C# program to find the maximum
// consecutive repeating character
// in given string
using System;

class GFG
{

// function to find out the maximum
// repeating character in given string
static char maxRepeating(string str)
{
    int len = str.Length;
    int count = 0;
    char res = str[0];

    // Find the maximum repeating
    // character starting from str[i]
    for (int i = 0; i < len; i++)
    {
        int cur_count = 1;
        for (int j = i + 1; j < len; j++)
        {
            if (str[i] != str[j])
                break;
            cur_count++;
        }

        // Update result if required
        if (cur_count > count)
        {
            count = cur_count;
            res = str[i];
        }
    }
    return res;
}

// Driver code
public static void Main()
{
    string str = "aaaabbaaccde";
    Console.Write(maxRepeating(str));
}
}

// This code is contributed
// by ChitraNayal

Javascript

<script>

// Javascript program to find the maximum consecutive
// repeating character in given string

    // function to find out the maximum repeating
    // character in given string
    function maxRepeating(str)
    {
        let len = str.length;
        let count = 0;

        // Find the maximum repeating character
        // starting from str[i]
        let res = str[0];
        for (let i=0; i<len; i++)
        {
            let cur_count = 1;
            for (let j=i+1; j<len; j++)
            {
                if (str[i] != str[j])
                    break;
                cur_count++;
            }

            // Update result if required
            if (cur_count > count)
            {
                count = cur_count;
                res = str[i];
            }
        }
        return res;
    }

    // Driver code
    let str = "aaaabbaaccde";
    document.write(maxRepeating(str));

    // This code is contributed by rag2127

</script>

PHP

<?php
//PHP program to find the maximum consecutive
// repeating character in given string

// function to find out the maximum repeating
// character in given string
function  maxRepeating( $str)
{
     $len = strlen($str);
    $count = 0;

    // Find the maximum repeating character
    // starting from str[i]
     $res = $str[0];
    for ($i = 0; $i < $len; $i++)
    {
         $cur_count = 1;
        for ($j = $i+1; $j < $len; $j++)
        {
            if ($str[$i] != $str[$j])
                break;
            $cur_count++;
        }

        // Update result if required
        if ($cur_count > $count)
        {
            $count = $cur_count;
            $res = $str[$i];
        }
    }
    return $res;
}

// Driver code
    $str = "aaaabbaaccde";
    echo  maxRepeating($str);

// This code is contributed by ajit
?>

Output:

a

Time Complexity : O(n^2) 
Space Complexity : O(1)
An efficient solution is to run only one loop. The idea is to reset the count as 1 as soon as we find a character not matching with the previous. 

C++

// C++ program to find the maximum consecutive
// repeating character in given string
#include<bits/stdc++.h>
using namespace std;

// Returns the maximum repeating character in a
// given string
char maxRepeating(string str)
{
    int n = str.length();
    int count = 0;
    char res = str[0];
    int cur_count = 1;

    // Traverse string except last character
    for (int i=0; i<n; i++)
    {
        // If current character matches with next
        if (i < n-1 && str[i] == str[i+1])
            cur_count++;

        // If doesn't match, update result
        // (if required) and reset count
        else
        {
            if (cur_count > count)
            {
                count = cur_count;
                res = str[i];
            }
            cur_count = 1;
        }
    }

    return res;
}

// Driver code
int main()
{
    string str = "aaaabbaaccde";
    cout << maxRepeating(str);
    return 0;
}

Java

// Java program to find the maximum consecutive
// repeating character in given string
class GFG {

    // function to find out the maximum repeating
    // character in given string
    static char maxRepeating(String str)
    {
        int n = str.length();
        int count = 0;
        char res = str.charAt(0);
        int cur_count = 1;

        // Traverse string except last character
        for (int i = 0; i < n; i++)
        {
            // If current character matches with next
            if (i < n - 1 && str.charAt(i) == str.charAt(i + 1))
                cur_count++;

            // If doesn't match, update result
            // (if required) and reset count
            else
            {
                if (cur_count > count)
                {
                    count = cur_count;
                    res = str.charAt(i);
                }
                cur_count = 1;
            }
        }
        return res;
    }

    // Driver code
    public static void main(String args[])
    {
        String str = "aaaabbaaccde";
        System.out.println(maxRepeating(str));
    }
}

// This code is contributed by Sudeep Mukherjee

Python 3

# Python 3 program to find the
# maximum consecutive repeating
# character in given string

# Returns the maximum repeating
# character in a given string
def maxRepeating(str):

    n = len(str)
    count = 0
    res = str[0]
    cur_count = 1

    # Traverse string except
    # last character
    for i in range(n):

        # If current character
        # matches with next
        if (i < n - 1 and
            str[i] == str[i + 1]):
            cur_count += 1

        # If doesn't match, update result
        # (if required) and reset count
        else:
            if cur_count > count:
                count = cur_count
                res = str[i]
            cur_count = 1
    return res

# Driver code
if __name__ == "__main__":
    str = "aaaabbaaccde"
    print(maxRepeating(str))

# This code is contributed
# by ChitraNayal

C#

// C# program to find the maximum
// consecutive repeating character
// in given string
using System;

class GFG
{

// function to find out the
// maximum repeating character
// in given string
static char maxRepeating(string str)
{
    int n = str.Length;
    int count = 0;
    char res = str[0];
    int cur_count = 1;

    // Traverse string except
    // last character
    for (int i = 0; i < n; i++)
    {
        // If current character
        // matches with next
        if (i < n - 1 &&
            str[i] == str[i + 1])
            cur_count++;

        // If doesn't match, update result
        // (if required) and reset count
        else
        {
            if (cur_count > count)
            {
                count = cur_count;
                res = str[i];
            }
            cur_count = 1;
        }
    }
    return res;
}

// Driver code
public static void Main()
{
    string str = "aaaabbaaccde";
    Console.Write(maxRepeating(str));
}
}

// This code is contributed
// by ChitraNayal

Javascript

<script>

// JavaScript program to find the maximum consecutive
// repeating character in given string

  // function to find out the maximum repeating
  // character in given string
function maxRepeating( str)
{
    var n = str.length;
    var count = 0;
    var res = str[0];
    var cur_count = 1;

    // Traverse string except last character
    for (var i=0; i<n; i++)
    {
        // If current character matches with next
        if (i < n-1 && str[i] == str[i+1])
            cur_count++;

        // If doesn't match, update result
        // (if required) and reset count
        else
        {
            if (cur_count > count)
            {
                count = cur_count;
                res = str[i];
            }
            cur_count = 1;
        }
    }

    return res;
}

var str = "aaaabbaaccde";
    document.write( maxRepeating(str));

</script>

PHP

<?php
// PHP program to find the maximum
// consecutive repeating character
// in given string

// Returns the maximum repeating
// character in a given string
function maxRepeating($str)
{
    $n = strlen($str);
    $count = 0;
    $res = $str[0];
    $cur_count = 1;

    // Traverse string except
    // last character
    for ($i = 0; $i < $n; $i++)
    {
        // If current character
        // matches with next
        if ($i < $n - 1 &&
            $str[$i] == $str[$i + 1])
            $cur_count++;

        // If doesn't match, update result
        // (if required) and reset count
        else
        {
            if ($cur_count > $count)
            {
                $count = $cur_count;
                $res = $str[$i];
            }
            $cur_count = 1;
        }
    }

    return $res;
}

// Driver code
$str = "aaaabbaaccde";
echo maxRepeating($str);

// This code is contributed
// by ChitraNayal
?>

Output:

a

Time Complexity : O(n) 
Space Complexity : O(1)

Another Approach:

1. Start by including the required header files and using the standard namespace.
2. Define a function maxRepeating that takes a string as input and returns a character as output.
3. Get the length of the input string and initialize two variables maxCount and curCount to 0 and 1 respectively. Also, initialize the variable res with the first character of the string.
4. Traverse the string starting from the second character (index 1) to the end using a for loop.
5. Check if the current character is the same as the previous character (i.e., str[i] == str[i-1]).
6. If the current character is the same as the previous character, increment the curCount variable.
7. If the current character is not the same as the previous character, compare the curCount variable with the maxCount variable to see if it is greater.
8. If the curCount variable is greater than the maxCount variable, update the maxCount variable with the value of curCount and set the res variable to the previous character (i.e., str[i-1]).
9. Reset the curCount variable to 1.
10. After the loop, check if the curCount variable is greater than the maxCount variable for the last character.
11. If the curCount variable is greater than the maxCount variable, update the maxCount variable with the value of curCount and set the res variable to the last character (i.e., str[n-1]).
12. Return the res variable.
13. In the main function, define a string variable str with the input string and call the maxRepeating function with str as argument.
14. Print the output of the maxRepeating function.
15. End of program.

C++

#include <iostream>
using namespace std;

char maxRepeating(string str) {
    int n = str.length();
    int maxCount = 0, curCount = 1;
    char res = str[0];
    for (int i = 1; i < n; i++) {
        if (str[i] == str[i - 1]) {
            curCount++;
        } else {
            if (curCount > maxCount) {
                maxCount = curCount;
                res = str[i - 1];
            }
            curCount = 1;
        }
    }
    // check for the last character
    if (curCount > maxCount) {
        maxCount = curCount;
        res = str[n - 1];
    }
    return res;
}

int main() {
    string str = "aaaabbcbbb";
    cout << maxRepeating(str); // output: a
    return 0;
}

Java

import java.util.*;

public class Main {
public static char maxRepeating(String str) {
int n = str.length();
int maxCount = 0, curCount = 1;
char res = str.charAt(0);
for (int i = 1; i < n; i++) {
if (str.charAt(i) == str.charAt(i - 1)) {
curCount++;
} else {
if (curCount > maxCount) {
maxCount = curCount;
res = str.charAt(i - 1);
}
curCount = 1;
}
}
// check for the last character
if (curCount > maxCount) {
maxCount = curCount;
res = str.charAt(n - 1);
}
return res;
}
  public static void main(String[] args) {
    String str = "aaaabbcbbb";
    System.out.println(maxRepeating(str)); // output: a
}

}

Python3

def max_repeating(string):
    n = len(string)  # length of the string
    max_count = 0  # maximum count of repeating characters
    cur_count = 1  # current count of repeating characters
    res = string[0]  # result character
    for i in range(1, n):
        if string[i] == string[i - 1]:  # if current character is same as previous character
            cur_count += 1  # increment current count
        else:
            if cur_count > max_count:  # if current count is greater than maximum count
                max_count = cur_count  # update maximum count
                res = string[i - 1]  # update result character
            cur_count = 1  # reset current count
    # check for the last character
    if cur_count > max_count:
        max_count = cur_count
        res = string[n - 1]
    return res


string = "aaaabbcbbb"
print(max_repeating(string))  # output: a

C#

using System;

class Program
{
    // Function to find the character with the maximum consecutive repetitions
    static char MaxRepeating(string str)
    {
        int n = str.Length;
        int maxCount = 0, curCount = 1;
        char res = str[0];

        // Loop through the string
        for (int i = 1; i < n; i++)
        {
            // If the current character is the same as the previous character
            if (str[i] == str[i - 1])
            {
                curCount++;
            }
            else
            {
                // If the current count is greater than the maximum count so far
                if (curCount > maxCount)
                {
                    maxCount = curCount;
                    res = str[i - 1];
                }
                curCount = 1;
            }
        }

        // Check for the last character
        if (curCount > maxCount)
        {
            maxCount = curCount;
            res = str[n - 1];
        }

        return res;
    }

    static void Main()
    {
        string str = "aaaabbcbbb";
        Console.WriteLine(MaxRepeating(str)); // Output: a
    }
}

Javascript

function maxRepeating(str) {
    const n = str.length;
    let maxCount = 0, curCount = 1;
    let res = str[0];

    for (let i = 1; i < n; i++) {
        if (str[i] === str[i - 1]) {
            curCount++;
        } else {
            if (curCount > maxCount) {
                maxCount = curCount;
                res = str[i - 1];
            }
            curCount = 1;
        }
    }

    // Check for the last character
    if (curCount > maxCount) {
        maxCount = curCount;
        res = str[n - 1];
    }

    return res;
}

const str = "aaaabbcbbb";
console.log(maxRepeating(str)); // Output: a

Output

a

Time complexity: O(n)

Auxiliary Space: O(1)

If you like GeeksforGeeks and would like to contribute, you can also write an article using write.geeksforgeeks.org or mail your article to review-team@geeksforgeeks.org. See your article appearing on the GeeksforGeeks main page and help other Geeks.
Please write comments if you find anything incorrect, or you want to share more information about the topic discussed above.