Open In App

Repeated Character Whose First Appearance is Leftmost

Improve
Improve
Like Article
Like
Save
Share
Report

Given a string, find the repeated character present first in the string.
 

Examples: 

Input: geeksforgeeks
Output: g

Input: abcdabcd
Output: a

Input: abcd
Output: -1

Brute Force Approach:

The brute force approach to solve this problem is to consider each character in the string and then check whether it appears again in the remaining part of the string. If it does, then we have found the first repeating character.

Steps that were to follow the above approach:

  • Start by iterating through each character in the string.
  • For each character, iterate through the remaining characters in the string to check if there is a repeating character.
  • If a repeating character is found, return the index of the first occurrence of that character.
  • If no repeating character is found, return -1 to indicate that all characters in the string are distinct.

Below is the code to implement the above steps:

C++




// CPP program to find first repeating
// character
#include <bits/stdc++.h>
using namespace std;
 
/* The function returns index of the first
repeating character in a string. If
all characters are repeating then
returns -1 */
int firstRepeating(string& str)
{
    int n = str.length();
 
    // Consider each character
    for (int i = 0; i < n; i++) {
 
        // Check if this character appears again
        for (int j = i + 1; j < n; j++) {
 
            if (str[i] == str[j]) {
                return i;
            }
        }
    }
 
    // If no repeating character found
    return -1;
}
 
/* Driver program to test above function */
int main()
{
    string str = "geeksforgeeks";
    int index = firstRepeating(str);
 
    if (index == -1)
        printf("Either all characters are "
               "distinct or string is empty");
    else
        printf("First Repeating character"
               " is %c",
               str[index]);
 
    return 0;
}


Java




// Java program implementation to find first repeating
// character
import java.util.*;
 
public class Main {
 
    // The function returns index of the first
    // repeating character in a string. If all
    // characters are repeating then returns -1
    public static int firstRepeating(String str) {
        int n = str.length();
 
        // Consider each character
        for (int i = 0; i < n; i++) {
 
            // Check if this character appears again
            for (int j = i + 1; j < n; j++) {
 
                if (str.charAt(i) == str.charAt(j)) {
                    return i;
                }
            }
        }
 
        // If no repeating character found
        return -1;
    }
 
    // Driver code
    public static void main(String[] args) {
        String str = "geeksforgeeks";
        int index = firstRepeating(str);
 
        if (index == -1)
            System.out.println("Either all characters are distinct or string is empty");
        else
            System.out.println("First Repeating character is " + str.charAt(index));
    }
}


Python3




def first_repeating(str):
    n = len(str)
 
    # Consider each character
    for i in range(n):
        # Check if this character appears again
        for j in range(i + 1, n):
            if str[i] == str[j]:
                return i
 
    # If no repeating character found
    return -1
 
# Driver program to test above function
str = "geeksforgeeks"
index = first_repeating(str)
 
if index == -1:
    print("Either all characters are distinct or string is empty")
else:
    print(f"First Repeating character is {str[index]}")


C#




using System;
 
class Program
{
    /* The function returns index of the first
    repeating character in a string. If
    all characters are repeating then
    returns -1 */
    static int FirstRepeating(string str)
    {
        int n = str.Length;
 
        // Consider each character
        for (int i = 0; i < n; i++)
        {
            // Check if this character appears again
            for (int j = i + 1; j < n; j++)
            {
                if (str[i] == str[j])
                {
                    return i;
                }
            }
        }
 
        // If no repeating character found
        return -1;
    }
 
    /* Driver program to test above function */
    static void Main(string[] args)
    {
        string str = "geeksforgeeks";
        int index = FirstRepeating(str);
 
        if (index == -1)
        {
            Console.WriteLine("Either all characters are distinct or string is empty");
        }
        else
        {
            Console.WriteLine("First Repeating character is " + str[index]);
        }
    }
}


Javascript




function firstRepeating(str) {
    let n = str.length;
 
    // Consider each character
    for (let i = 0; i < n; i++) {
 
        // Check if this character appears again
        for (let j = i + 1; j < n; j++) {
 
            if (str[i] === str[j]) {
                return i;
            }
        }
    }
 
    // If no repeating character found
    return -1;
}
 
// Driver program to test above function
let str = "geeksforgeeks";
let index = firstRepeating(str);
 
if (index === -1)
    console.log("Either all characters are distinct or string is empty");
else
    console.log("First Repeating character is " + str[index]);


Output

First Repeating character is g


Time Complexity: O(N^2)
Auxiliary Space: O(1)

Repeated Character Whose First Appearance is Leftmost by Tracking First Occurrence:

The idea is to keep track of first occurrence of every character and whenever a character repeats check whether it is first repeated character or not.

Follow the steps to solve the problem:

  • Initialise an array firstIndex of size 256 which keeps track of the first occurrence of every character in the string.
  • Traverse string from left to right and If a character repeats, compare its leftmost index with the current result
  • Update the result if the result is greater.

Below is the implementation of the above approach:

C++




// CPP program to find first repeating
// character
#include <bits/stdc++.h>
using namespace std;
#define NO_OF_CHARS 256
 
/* The function returns index of the first
repeating character in a string. If
all characters are repeating then
returns -1 */
int firstRepeating(string& str)
{
    // Initialize leftmost index of every
    // character as -1.
    int firstIndex[NO_OF_CHARS];
    for (int i = 0; i < NO_OF_CHARS; i++)
        firstIndex[i] = -1;
 
    // Traverse from left and update result
    // if we see a repeating character whose
    // first index is smaller than current
    // result.
    int res = INT_MAX;
    for (int i = 0; i < str.length(); i++) {
        if (firstIndex[str[i]] == -1)
           firstIndex[str[i]] = i;
        else
           res = min(res, firstIndex[str[i]]);
    }
 
    return (res == INT_MAX) ? -1 : res;
}
 
/* Driver program to test above function */
int main()
{
    string str = "geeksforgeeks";
    int index = firstRepeating(str);
    if (index == -1)
        printf("Either all characters are "
               "distinct or string is empty");
    else
        printf("First Repeating character"
               " is %c",
               str[index]);
    return 0;
}


Java




// Java program to find first repeating
// character
 
class GFG
{
 
    static int NO_OF_CHARS = 256;
 
    /* The function returns index of the first
    repeating character in a string. If
    all characters are repeating then
    returns -1 */
    static int firstRepeating(char[] str)
    {
        // Initialize leftmost index of every
        // character as -1.
        int[] firstIndex = new int[NO_OF_CHARS];
        for (int i = 0; i < NO_OF_CHARS; i++)
        {
            firstIndex[i] = -1;
        }
 
        // Traverse from left and update result
        // if we see a repeating character whose
        // first index is smaller than current
        // result.
        int res = Integer.MAX_VALUE;
        for (int i = 0; i < str.length; i++)
        {
            if (firstIndex[str[i]] == -1)
            {
                firstIndex[str[i]] = i;
            }
            else
            {
                res = Math.min(res, firstIndex[str[i]]);
            }
        }
 
        return (res == Integer.MAX_VALUE) ? -1 : res;
    }
 
    /* Driver code */
    public static void main(String[] args)
    {
        char[] str = "geeksforgeeks".toCharArray();
        int index = firstRepeating(str);
        if (index == -1)
        {
            System.out.printf("Either all characters are "
                    + "distinct or string is empty");
        }
        else
        {
            System.out.printf("First Repeating character"
                    + " is %c", str[index]);
        }
    }
}
 
// This code has been contributed by 29AjayKumar


Python3




# Python 3 program to find first repeating
# character
import sys
 
NO_OF_CHARS = 256
 
# The function returns index of the first
# repeating character in a string. If
# all characters are repeating then
# returns -1 */
def firstRepeating(str):
     
    # Initialize leftmost index of every
    # character as -1.
    firstIndex = [0 for i in range(NO_OF_CHARS)]
    for i in range(NO_OF_CHARS):
        firstIndex[i] = -1
 
    # Traverse from left and update result
    # if we see a repeating character whose
    # first index is smaller than current
    # result.
    res = sys.maxsize
    for i in range(len(str)):
        if (firstIndex[ord(str[i])] == -1):
            firstIndex[ord(str[i])] = i
        else:
            res = min(res, firstIndex[ord(str[i])])
 
    if res == sys.maxsize:
        return -1
    else:
        return res
 
# Driver function
if __name__ == '__main__':
    str = "geeksforgeeks"
    index = firstRepeating(str)
    if (index == -1):
        print("Either all characters are distinct or string is empty")
    else:
        print("First Repeating character is",str[index])
         
# This code is contributed by
# Surendra_Gangwar


C#




// C# program to find first repeating
// character
using System;
using System.Collections.Generic;
     
class GFG
{
 
    static int NO_OF_CHARS = 256;
 
    /* The function returns index of the first
    repeating character in a string. If
    all characters are repeating then
    returns -1 */
    static int firstRepeating(char[] str)
    {
        // Initialize leftmost index of every
        // character as -1.
        int[] firstIndex = new int[NO_OF_CHARS];
        for (int i = 0; i < NO_OF_CHARS; i++)
        {
            firstIndex[i] = -1;
        }
 
        // Traverse from left and update result
        // if we see a repeating character whose
        // first index is smaller than current
        // result.
        int res = int.MaxValue;
        for (int i = 0; i < str.Length; i++)
        {
            if (firstIndex[str[i]] == -1)
            {
                firstIndex[str[i]] = i;
            }
            else
            {
                res = Math.Min(res, firstIndex[str[i]]);
            }
        }
 
        return (res == int.MaxValue) ? -1 : res;
    }
 
    /* Driver code */
    public static void Main(String[] args)
    {
        char[] str = "geeksforgeeks".ToCharArray();
        int index = firstRepeating(str);
        if (index == -1)
        {
            Console.Write("Either all characters are "
                    + "distinct or string is empty");
        }
        else
        {
            Console.Write("First Repeating character"
                    + " is {0}", str[index]);
        }
    }
}
 
// This code is contributed by Princi Singh


Javascript




<script>
    // Javascript program to find first repeating character
     
    let NO_OF_CHARS = 256;
   
    /* The function returns index of the first
    repeating character in a string. If
    all characters are repeating then
    returns -1 */
    function firstRepeating(str)
    {
        // Initialize leftmost index of every
        // character as -1.
        let firstIndex = new Array(NO_OF_CHARS);
        for (let i = 0; i < NO_OF_CHARS; i++)
        {
            firstIndex[i] = -1;
        }
   
        // Traverse from left and update result
        // if we see a repeating character whose
        // first index is smaller than current
        // result.
        let res = Number.MAX_VALUE;
        for (let i = 0; i < str.length; i++)
        {
            if (firstIndex[str[i].charCodeAt()] == -1)
            {
                firstIndex[str[i].charCodeAt()] = i;
            }
            else
            {
                res = Math.min(res, firstIndex[str[i].charCodeAt()]);
            }
        }
   
        return (res == Number.MAX_VALUE) ? -1 : res;
    }
     
    let str = "geeksforgeeks".split('');
    let index = firstRepeating(str);
    if (index == -1)
    {
      document.write("Either all characters are "
                    + "distinct or string is empty");
    }
    else
    {
      document.write("First Repeating character is " + str[index]);
    }
     
    // This code is contributed by decode2207.
</script>


Output

First Repeating character is g


Time Complexity: O(N). Traversing string one time
Auxiliary Space: O(1)

Repeated Character Whose First Appearance is Leftmost by Reverse Traversal:

The idea is to track the characters which have encountered while traversing from right to left. Whenever a character is already repeated then take that index to our answer.

Follow the steps to solve the problem:

  • Initialise an array visited of size 256 which keeps track of characters that have been encountered.
  • Traverse string from right to left and If a character repeats, add that index to the result.

Below is the implementation of the above approach:
 

C++




// CPP program to find first repeating
// character
#include <bits/stdc++.h>
using namespace std;
#define NO_OF_CHARS 256
 
/* The function returns index of the first
repeating character in a string. If
all characters are repeating then
returns -1 */
int firstRepeating(string& str)
{
    // Mark all characters as not visited
    bool visited[NO_OF_CHARS];
    for (int i = 0; i < NO_OF_CHARS; i++)
        visited[i] = false;
 
    // Traverse from right and update res as soon
    // as we see a visited character.
    int res = -1;
    for (int i = str.length() - 1; i >= 0; i--) {
        if (visited[str[i]] == false)
            visited[str[i]] = true;
        else
            res = i;
    }
 
    return res;
}
 
/* Driver program to test above function */
int main()
{
    string str = "geeksforgeeks";
    int index = firstRepeating(str);
    if (index == -1)
        printf("Either all characters are "
               "distinct or string is empty");
    else
        printf("First Repeating character"
               " is %c",
               str[index]);
    return 0;
}


Java




// Java program to find first repeating
// character
import java.util.*;
 
class GFG
{
 
static int NO_OF_CHARS= 256;
 
/* The function returns index of the first
repeating character in a string. If
all characters are repeating then
returns -1 */
static int firstRepeating(String str)
{
    // Mark all characters as not visited
    boolean []visited = new boolean[NO_OF_CHARS];
    for (int i = 0; i < NO_OF_CHARS; i++)
        visited[i] = false;
 
    // Traverse from right and update res as soon
    // as we see a visited character.
    int res = -1;
    for (int i = str.length() - 1; i >= 0; i--)
    {
        if (visited[str.charAt(i)] == false)
            visited[str.charAt(i)] = true;
        else
            res = i;
    }
 
    return res;
}
 
/* Driver code */
public static void main(String[] args)
{
    String str = "geeksforgeeks";
    int index = firstRepeating(str);
    if (index == -1)
        System.out.printf("Either all characters are "
            +"distinct or string is empty");
    else
        System.out.printf("First Repeating character"
            +" is %c",
            str.charAt(index));
}
}
 
// This code contributed by Rajput-Ji


Python3




# Python3 program to find first
# repeating character
 
NO_OF_CHARS = 256
 
""" The function returns index of the first
repeating character in a string. If
all characters are repeating then
returns -1 """
 
def firstRepeating(string) :
     
    # Mark all characters as not visited
    visited = [False] * NO_OF_CHARS;
     
    for i in range(NO_OF_CHARS) :
        visited[i] = False;
         
    # Traverse from right and update res as soon
    # as we see a visited character.
    res = -1;
    for i in range(len(string)-1, -1 , -1) :
        if (visited[string.index(string[i])] == False):
            visited[string.index(string[i])] = True;
         
        else:
            res = i;
     
    return res;
     
     
# Driver program to test above function
if __name__ == "__main__" :
 
    string = "geeksforgeeks";
    index = firstRepeating(string);
     
    if (index == -1) :
        print("Either all characters are" ,
        "distinct or string is empty");
    else :
        print("First Repeating character is:", string[index]);
         
# This code is contributed by AnkitRai01


C#




// C# program to find first repeating
// character
using System;
     
class GFG
{
 
static int NO_OF_CHARS = 256;
 
/* The function returns index of the first
repeating character in a string. If
all characters are repeating then
returns -1 */
static int firstRepeating(String str)
{
    // Mark all characters as not visited
    Boolean []visited = new Boolean[NO_OF_CHARS];
    for (int i = 0; i < NO_OF_CHARS; i++)
        visited[i] = false;
 
    // Traverse from right and update res as soon
    // as we see a visited character.
    int res = -1;
    for (int i = str.Length - 1; i >= 0; i--)
    {
        if (visited[str[i]] == false)
            visited[str[i]] = true;
        else
            res = i;
    }
 
    return res;
}
 
// Driver Code
public static void Main(String[] args)
{
    String str = "geeksforgeeks";
    int index = firstRepeating(str);
    if (index == -1)
        Console.Write("Either all characters are " +
                      "distinct or string is empty");
    else
        Console.Write("First Repeating character" +
                      " is {0}", str[index]);
}
}
 
// This code is contributed by PrinciRaj1992


Javascript




<script>
    // Javascript program to find first repeating character
     
    let NO_OF_CHARS = 256;
  
    /* The function returns index of the first
    repeating character in a string. If
    all characters are repeating then
    returns -1 */
    function firstRepeating(str)
    {
        // Mark all characters as not visited
        let visited = new Array(NO_OF_CHARS);
        for (let i = 0; i < NO_OF_CHARS; i++)
            visited[i] = false;
 
        // Traverse from right and update res as soon
        // as we see a visited character.
        let res = -1;
        for (let i = str.length - 1; i >= 0; i--)
        {
            if (visited[str[i].charCodeAt()] == false)
                visited[str[i].charCodeAt()] = true;
            else
                res = i;
        }
 
        return res;
    }
     
    let str = "geeksforgeeks";
    let index = firstRepeating(str);
    if (index == -1)
        document.write("Either all characters are " +
                      "distinct or string is empty");
    else
        document.write("First Repeating character" +
                      " is " + str[index]);
 
// This code is contributed by divyeshrabadiya07.
</script>


Output

First Repeating character is g


Time Complexity: O(N). Traversing string one time
Auxiliary Space: O(1)

Discussed more approaches in Find repeated character present first in a string.  



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