Find repeated character present first in a string (original) (raw)

Last Updated : 13 Apr, 2023

Given a string, find the repeated character present first in the string.
(Not the first repeated character, found here.)

Examples:

Input : geeksforgeeks Output : g (mind that it will be g, not e.)

Asked in: Goldman Sachs internship

Simple Solution using O(N^2) complexity: The solution is to loop through the string for each character and search for the same in the rest of the string. This would need two loops and thus not optimal.

Implementation:

Try It Yourself

C++ `

// C++ program to find the first // character that is repeated #include <bits/stdc++.h> #include <string.h>

using namespace std; int findRepeatFirstN2(char* s) { // this is O(N^2) method int p = -1, i, j; for (i = 0; i < strlen(s); i++) { for (j = i + 1; j < strlen(s); j++) { if (s[i] == s[j]) { p = i; break; } } if (p != -1) break; }

return p;

}

// Driver code int main() { char str[] = "geeksforgeeks"; int pos = findRepeatFirstN2(str); if (pos == -1) cout << "Not found"; else cout << str[pos]; return 0; }

// This code is contributed // by Akanksha Rai

C

// C program to find the first character that // is repeated #include <stdio.h> #include <string.h>

int findRepeatFirstN2(char* s) { // this is O(N^2) method int p = -1, i, j; for (i = 0; i < strlen(s); i++) { for (j = i + 1; j < strlen(s); j++) { if (s[i] == s[j]) { p = i; break; } } if (p != -1) break; }

return p;

}

// Driver code int main() { char str[] = "geeksforgeeks"; int pos = findRepeatFirstN2(str); if (pos == -1) printf("Not found"); else printf("%c", str[pos]); return 0; }

Java

// Java program to find the first character // that is repeated import java.io.; import java.util.;

class GFG {

static int findRepeatFirstN2(String s)
{
    
    // this is O(N^2) method
    int p = -1, i, j;
    for (i = 0; i < s.length(); i++)
    {
        for (j = i + 1; j < s.length(); j++)
        {
            if (s.charAt(i) == s.charAt(j))
            {
                p = i;
                break;
            }
        }
        if (p != -1)
            break;
    }

    return p;
}

// Driver code
static public void main (String[] args)
{
    String str = "geeksforgeeks";
    int pos = findRepeatFirstN2(str);
    
    if (pos == -1)
        System.out.println("Not found");
    else
    System.out.println( str.charAt(pos));
}

}

// This code is contributed by anuj_67.

Python3

Python3 program to find the first

character that is repeated

def findRepeatFirstN2(s):

# this is O(N^2) method
p = -1
for i in range(len(s)):

    for j in range (i + 1, len(s)):
    
        if (s[i] == s[j]):
            p = i
            break
        
    if (p != -1):
        break

return p

Driver code

if name == "main":

str = "geeksforgeeks"
pos = findRepeatFirstN2(str)
if (pos == -1):
    print ("Not found")
else:
    print (str[pos])

This code is contributed

by ChitraNayal

C#

// C# program to find the first character // that is repeated using System;

class GFG {

static int findRepeatFirstN2(string s)
{
    
    // this is O(N^2) method
    int p = -1, i, j;
    for (i = 0; i < s.Length; i++)
    {
        for (j = i + 1; j < s.Length; j++)
        {
            if (s[i] == s[j])
            {
                p = i;
                break;
            }
        }
        if (p != -1)
            break;
    }

    return p;
}

// Driver code
static public void Main ()
{
    string str = "geeksforgeeks";
    int pos = findRepeatFirstN2(str);
    
    if (pos == -1)
        Console.WriteLine("Not found");
    else
    Console.WriteLine( str[pos]);
}

}

// This code is contributed by anuj_67.

PHP

i<strlen(i < strlen(i<strlen(s); $i++) { for ($j = ($i + 1); j<strlen(j < strlen(j<strlen(s); $j++) { if ($s[$i] == s[s[s[j]) { p=p = p=i; break; } } if ($p != -1) break; } return $p; } // Driver code $str = "geeksforgeeks"; pos=findRepeatFirstN2(pos = findRepeatFirstN2(pos=findRepeatFirstN2(str); if ($pos == -1) echo ("Not found"); else echo ($str[$pos]); // This code is contributed by jit_t ?>

JavaScript

Space complexity :- O(1)

Optimization by counting occurrences

This solution is optimized by using the following techniques:

We loop through the string and hash the characters using ASCII codes. Store 1 if found and store 2 if found again. Also, store the position of the letter first found in.
We run a loop on the hash array and now we find the minimum position of any character repeated.

Implementation:

C++ `

// C++ program to find the first character that // is repeated #include<bits/stdc++.h>

using namespace std; // 256 is taken just to ensure nothing is left, // actual max ASCII limit is 128 #define MAX_CHAR 256

int findRepeatFirst(char* s) { // this is optimized method int p = -1, i, k;

// initialized counts of occurrences of
// elements as zero
int hash[MAX_CHAR] = { 0 };

// initialized positions
int pos[MAX_CHAR];

for (i = 0; i < strlen(s); i++) {
    k = (int)s[i];
    if (hash[k] == 0) {
        hash[k]++;
        pos[k] = i;
    } else if (hash[k] == 1)
        hash[k]++;
}

for (i = 0; i < MAX_CHAR; i++) {
    if (hash[i] == 2) {
        if (p == -1) // base case
            p = pos[i];
        else if (p > pos[i])
            p = pos[i];
    }
}

return p;

}

// Driver code int main() { char str[] = "geeksforgeeks"; int pos = findRepeatFirst(str); if (pos == -1) cout << "Not found"; else cout << str[pos]; return 0; }

// This code is contributed // by Akanksha Rai

C

// C program to find the first character that // is repeated #include <stdio.h> #include <string.h>

// 256 is taken just to ensure nothing is left, // actual max ASCII limit is 128 #define MAX_CHAR 256

int findRepeatFirst(char* s) { // this is optimized method int p = -1, i, k;

// initialized counts of occurrences of
// elements as zero
int hash[MAX_CHAR] = { 0 };

// initialized positions
int pos[MAX_CHAR];

for (i = 0; i < strlen(s); i++) {
    k = (int)s[i];
    if (hash[k] == 0) {
        hash[k]++;
        pos[k] = i;
    } else if (hash[k] == 1)
        hash[k]++;
}

for (i = 0; i < MAX_CHAR; i++) {
    if (hash[i] == 2) {
        if (p == -1) // base case
            p = pos[i];
        else if (p > pos[i])
            p = pos[i];
    }
}

return p;

}

// Driver code int main() { char str[] = "geeksforgeeks"; int pos = findRepeatFirst(str); if (pos == -1) printf("Not found"); else printf("%c", str[pos]); return 0; }

Java

// Java Program to find the first character
// that is repeated

import java.util.; import java.lang.;

public class GFG { public static int findRepeatFirst(String s) { // this is optimized method int p = -1, i, k;

    // initialized counts of occurrences of
    // elements as zero
    int MAX_CHAR = 256;
    int hash[] = new int[MAX_CHAR];

    // initialized positions
    int pos[] = new int[MAX_CHAR];

    for (i = 0; i < s.length(); i++)
    {
        k = (int)s.charAt(i);
        if (hash[k] == 0)
        {
            hash[k]++;
            pos[k] = i;
        }
        else if (hash[k] == 1)
            hash[k]++;
    }

    for (i = 0; i < MAX_CHAR; i++)
    {
        if (hash[i] == 2)
        {
            if (p == -1) // base case
                p = pos[i];
            else if (p > pos[i])
                p = pos[i];
        }
    }

    return p;
}

// Driver code public static void main(String[] args) { String str = "geeksforgeeks"; int pos = findRepeatFirst(str); if (pos == -1) System.out.println("Not found"); else System.out.println(str.charAt(pos)); } }

// Code Contributed by Mohit Gupta_OMG

Python3

Python 3 program to find the first

character that is repeated

256 is taken just to ensure nothing

is left, actual max ASCII limit is 128

MAX_CHAR = 256

def findRepeatFirst(s):

# this is optimized method
p = -1

# initialized counts of occurrences 
# of elements as zero
hash = [0 for i in range(MAX_CHAR)] 

# initialized positions
pos = [0 for i in range(MAX_CHAR)]

for i in range(len(s)):
    k = ord(s[i])
    if (hash[k] == 0):
        hash[k] += 1
        pos[k] = i
    elif(hash[k] == 1):
        hash[k] += 1

for i in range(MAX_CHAR):
    if (hash[i] == 2):
        if (p == -1): # base case
            p = pos[i]
        elif(p > pos[i]):
            p = pos[i]
return p

Driver code

if name == 'main': str = "geeksforgeeks" pos = findRepeatFirst(str); if (pos == -1): print("Not found") else: print(str[pos])

This code is contributed by

Shashank_Sharma

C#

// C# Program to find the first character
// that is repeated using System; public class GFG { public static int findRepeatFirst(string s) { // this is optimized method int p = -1, i, k;

    // initialized counts of occurrences of
    // elements as zero
    int MAX_CHAR = 256;
    int []hash = new int[MAX_CHAR];

    // initialized positions
    int []pos = new int[MAX_CHAR];

    for (i = 0; i < s.Length; i++)
    {
        k = (int)s[i];
        if (hash[k] == 0)
        {
            hash[k]++;
            pos[k] = i;
        }
        else if (hash[k] == 1)
            hash[k]++;
    }

    for (i = 0; i < MAX_CHAR; i++)
    {
        if (hash[i] == 2)
        {
            if (p == -1) // base case
                p = pos[i];
            else if (p > pos[i])
                p = pos[i];
        }
    }

    return p;
}

// Driver code
public static void Main()
{
    string str = "geeksforgeeks";
    int pos = findRepeatFirst(str);
    if (pos == -1)
        Console.Write("Not found");
    else
        Console.Write(str[pos]);
}

}

// This code is contributed by nitin mittal.

JavaScript

Time Complexity: O(N)
Auxiliary space: O(1)

Method #3:Using Built-in Python Functions:

Approach:

Calculate all frequencies of all characters using Counter() function.
Traverse the string and check if any element has frequency greater than 1.
Print the character and break the loop

Below is the implementation:

C++ `

#include #include #include

using namespace std;

// Function which repeats // first repeating character void printrepeated(string str) {

// Calculating frequencies
// using unordered_map
unordered_map<char, int> freq;
for (char c : str) {
    freq[c]++;
}

// Traverse the string
for (char c : str) {
    if (freq[c] > 1) {
        cout << c << endl;
        break;
    }
}

}

// Driver code int main() { string str = "geeksforgeeks";

// passing string to printrepeated function
printrepeated(str);

return 0;

}

Java

import java.util.HashMap;

public class Main { // Function which repeats // first repeating character static void printrepeated(String str) {

    // Calculating frequencies
    // using HashMap
    HashMap<Character, Integer> freq
        = new HashMap<Character, Integer>();
    for (int i = 0; i < str.length(); i++) {
        char c = str.charAt(i);
        freq.put(c, freq.getOrDefault(c, 0) + 1);
    }

    // Traverse the string
    for (int i = 0; i < str.length(); i++) {
        char c = str.charAt(i);
        if (freq.get(c) > 1) {
            System.out.println(c);
            break;
        }
    }
}

// Driver code
public static void main(String[] args)
{
    String str = "geeksforgeeks";
    printrepeated(str);
}

}

Python3

Python implementation

from collections import Counter

Function which repeats

first repeating character

def printrepeated(string):

# Calculating frequencies 
# using Counter function
freq = Counter(string)

# Traverse the string
for i in string:
    if(freq[i] > 1):
        print(i)
        break

Driver code

string = "geeksforgeeks"

passing string to printrepeated function

printrepeated(string)

this code is contributed by vikkycirus

C#

using System; using System.Collections.Generic;

class Program {

// Function which repeats // first repeating character static void PrintRepeated(string str) {

// Calculating frequencies
// using Dictionary
Dictionary<char, int> freq
  = new Dictionary<char, int>();
foreach(char c in str)
{
  if (freq.ContainsKey(c)) {
    freq[c]++;
  }
  else {
    freq[c] = 1;
  }
}

// Traverse the string
foreach(char c in str)
{
  if (freq[c] > 1) {
    Console.WriteLine(c);
    break;
  }
}

}

// Driver code static void Main() { string str = "geeksforgeeks";

// passing string to PrintRepeated function
PrintRepeated(str);

Console.ReadLine();

} }

// This code is contributed by user_dtewbxkn77n

JavaScript

// JavaScript implementation // Function which repeats // first repeating character function printrepeated(string) {

// Calculating frequencies 
// using an object to store character counts
let freq = {};
for (let i = 0; i < string.length; i++) {
    if (string[i] in freq) {
        freq[string[i]] += 1;
    } else {
        freq[string[i]] = 1;
    }
}

// Traverse the string
for (let i = 0; i < string.length; i++) {
    if (freq[string[i]] > 1) {
        console.log(string[i]);
        break;
    }
}

}

// Driver code let string = "geeksforgeeks";

// passing string to printrepeated function printrepeated(string);

// this code is contributed by princekumaras

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

Method #4: Solving just by single traversal of the given string.

Algorithm :

Traverse the string from left to right.

If current character is not present in hash map, Then push this character along with its Index.

If the current character is already present in hash map, Then get the index of current character ( from hash map ) and compare it with the index of the previously found repeating character.

If the current index is smaller, then update the index.

C++ `

#include #include #define INT_MAX 2147483647 using namespace std;

// Function to find left most repeating character. char firstRep (string s) { unordered_map<char,int> map; char c='#'; int index=INT_MAX;

    // single traversal of string.
    for(int i=0;i<s.size();i++)
    {
        char p=s[i];
        
        if(map.find(p)==map.end())map.insert({p,i});
        else
        {
            if(map[p]<index)
            {
                index=map[p];
                c=p;
            }
        }
        
    }
    
    
    return c;
}

// Main function. int main() {

// Input string.
string s="abccdbd";
cout<<firstRep(s)<<endl;

return 0;

}

// This code is contributed // by rohan007

Java

// Java code to find the first repeating character in a // string import java.util.*;

public class GFG { public static int INT_MAX = 2147483647;

// Function to find left most repeating character. public static char firstRep(String s) { HashMap<Character, Integer> map = new HashMap<Character, Integer>(); char c = '#'; int index = INT_MAX;

// single traversal of string.
for (int i = 0; i < s.length(); i++) {
  char p = s.charAt(i);

  if (!map.containsKey(p)) {
    map.put(p, i);
  }
  else {
    if (map.get(p) < index) {
      index = map.get(p);
      c = p;
    }
  }
}

return c;

}

// Main function. public static void main(String[] args) {

// Input string.
String s = "abccdbd";
System.out.print(firstRep(s));
System.out.print("\n");

} }

// This code is contributed by Aarti_Rathi

Python3

Python3 code to find the first repeating character in a

string

INT_MAX = 2147483647

Function to find left most repeating character.

def firstRep(s): map = dict() c = '#' index = INT_MAX

# single traversal of string.
i = 0
while (i < len(s)):
    p = s[i]
    if (not (p in map.keys())):
        map[p] = i
    else:
        if (map.get(p) < index):
            index = map.get(p)
            c = p
    i += 1
return c

if name == "main":

# Input string.
s = "abccdbd"
print(firstRep(s), end="")
print("\n", end="")

This code is contributed by Aarti_Rathi

C#

// C# code to find the first repeating character in a string using System; using System.Collections.Generic;

public static class GFG { static int INT_MAX = 2147483647;

// Function to find left most repeating character. public static char firstRep(string s) { Dictionary<char, int> map = new Dictionary<char, int>(); char c = '#'; int index = INT_MAX;

// single traversal of string.
for (int i = 0; i < s.Length; i++) {
  char p = s[i];

  if (!map.ContainsKey(p)) {
    map[p] = i;
  }
  else {
    if (map[p] < index) {
      index = map[p];
      c = p;
    }
  }
}

return c;

}

// Main function. public static void Main() {

// Input string.
string s = "abccdbd";
Console.Write(firstRep(s));
Console.Write("\n");

} }

// This code is contributed by Aarti_Rathi

JavaScript

Time complexity: O(N)
Auxiliary Space: O(1), as there will be a constant number of characters present in the string.

More optimized Solution Repeated Character Whose First Appearance is Leftmost