# Find repeated character present first in a string

• Difficulty Level : Easy
• Last Updated : 06 Oct, 2022

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.)```

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:

## C++

 `// C++ program to find the first``// character that is repeated``#include ``#include ` `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 ``#include ` `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

 ``

## Javascript

 ``

Output

`g`

Optimization by counting occurrences

This solution is optimized by using the following techniques:

1. 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.
2. 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` `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 ``#include ` `// 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

 ``

Output

`g`

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

#### 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:

## 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`

Output

`g`

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

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

Algorithm :

1. Traverse the string from left to right.
2. If current character is not present in hash map, Then push this character along with its Index.
3. 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.
4. 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

## 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 map``      ``= ``new` `HashMap();``    ``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

 ``

Output

`b`

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

This article is contributed by Suprotik Dey. 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.

My Personal Notes arrow_drop_up