# Given a string, find its first non-repeating character

• Difficulty Level : Easy
• Last Updated : 23 Jun, 2022

Given a string, find the first non-repeating character in it. For example, if the input string is “GeeksforGeeks”, then the output should be ‘f’ and if the input string is “GeeksQuiz”, then the output should be ‘G’. Example:

```Input: "geeksforgeeks"
Explanation:
Step 1: Construct a character count array
from the input string.
....
count['e'] = 4
count['f'] = 1
count['g'] = 2
count['k'] = 2
……

Step 2: Get the first character who's
count is 1 ('f').```

Method #1:  HashMap and Two-string method traversals.

A character is said to be non-repeating if its frequency in the string is unit. Now for finding such characters, one needs to find the frequency of all characters in the string and check which character has unit frequency. This task could be done efficiently using a hash_map which will map the character to there respective frequencies and in which we can simultaneously update the frequency of any character we come across in constant time. The maximum distinct characters in the ASCII system are 256. So hash_map has a maximum size of 256. Now read the string again and the first character which we find has a frequency as unity is the answer.

Algorithm:

1. Make a hash_map which will map the character to there respective frequencies.
2. Traverse the given string using a pointer.
3. Increase the count of current character in the hash_map.
4. Now traverse the string again and check whether the current character hasfrequency=1.
5. If the frequency>1 continue the traversal.
6. Else break the loop and print the current character as the answer.

Pseudo Code :

```for ( i=0 to str.length())
hash_map[str[i]]++;

for(i=0 to str.length())
if(hash_map[str[i]]==1)
return str[i]```

Below is the implementation of the above approach:

## C++

 `// C++ program to find first` `// non-repeating character` `#include ` `using` `namespace` `std;` `#define NO_OF_CHARS 256`   `/* Returns an array of size 256 containing count` `of characters in the passed char array */` `int``* getCharCountArray(``char``* str)` `{` `    ``int``* count = (``int``*)``calloc``(``sizeof``(``int``), NO_OF_CHARS);` `    ``int` `i;` `    ``for` `(i = 0; *(str + i); i++)` `        ``count[*(str + i)]++;` `    ``return` `count;` `}`   `/* The function returns index of first` `non-repeating character in a string. If all` `characters are repeating then returns -1 */` `int` `firstNonRepeating(``char``* str)` `{` `    ``int``* count = getCharCountArray(str);` `    ``int` `index = -1, i;`   `    ``for` `(i = 0; *(str + i); i++) {` `        ``if` `(count[*(str + i)] == 1) {` `            ``index = i;` `            ``break``;` `        ``}` `    ``}`   `    ``// To avoid memory leak` `    ``free``(count);` `    ``return` `index;` `}`   `/* Driver program to test above function */` `int` `main()` `{` `    ``char` `str[] = ``"geeksforgeeks"``;` `    ``int` `index = firstNonRepeating(str);` `    ``if` `(index == -1)` `        ``cout << ``"Either all characters are repeating or "` `            ``"string is empty"``;` `    ``else` `        ``cout << ``"First non-repeating character is "``<<` `            ``str[index];` `    ``getchar``();` `    ``return` `0;` `}`   `// This code is contributed by shivanisinghss2110`

## C

 `// C program to find first` `// non-repeating character` `#include ` `#include ` `#define NO_OF_CHARS 256`   `/* Returns an array of size 256 containing count` `   ``of characters in the passed char array */` `int``* getCharCountArray(``char``* str)` `{` `    ``int``* count = (``int``*)``calloc``(``sizeof``(``int``), NO_OF_CHARS);` `    ``int` `i;` `    ``for` `(i = 0; *(str + i); i++)` `        ``count[*(str + i)]++;` `    ``return` `count;` `}`   `/* The function returns index of first` `   ``non-repeating character in a string. If all` `   ``characters are repeating then returns -1 */` `int` `firstNonRepeating(``char``* str)` `{` `    ``int``* count = getCharCountArray(str);` `    ``int` `index = -1, i;`   `    ``for` `(i = 0; *(str + i); i++) {` `        ``if` `(count[*(str + i)] == 1) {` `            ``index = i;` `            ``break``;` `        ``}` `    ``}`   `    ``// To avoid memory leak` `    ``free``(count);` `    ``return` `index;` `}`   `/* Driver program to test above function */` `int` `main()` `{` `    ``char` `str[] = ``"geeksforgeeks"``;` `    ``int` `index = firstNonRepeating(str);` `    ``if` `(index == -1)` `        ``printf``(``"Either all characters are repeating or "` `               ``"string is empty"``);` `    ``else` `        ``printf``(``"First non-repeating character is %c"``,` `               ``str[index]);` `    ``getchar``();` `    ``return` `0;` `}`

## Java

 `// Java program to find first` `// non-repeating character` `class` `GFG {` `    ``static` `final` `int` `NO_OF_CHARS = ``256``;` `    ``static` `char` `count[] = ``new` `char``[NO_OF_CHARS];`   `    ``/* calculate count of characters ` `       ``in the passed string */` `    ``static` `void` `getCharCountArray(String str)` `    ``{` `        ``for` `(``int` `i = ``0``; i < str.length(); i++)` `            ``count[str.charAt(i)]++;` `    ``}`   `    ``/* The method returns index of first non-repeating` `       ``character in a string. If all characters are repeating ` `       ``then returns -1 */` `    ``static` `int` `firstNonRepeating(String str)` `    ``{` `        ``getCharCountArray(str);` `        ``int` `index = -``1``, i;`   `        ``for` `(i = ``0``; i < str.length(); i++) {` `            ``if` `(count[str.charAt(i)] == ``1``) {` `                ``index = i;` `                ``break``;` `            ``}` `        ``}`   `        ``return` `index;` `    ``}`   `    ``// Driver method` `    ``public` `static` `void` `main(String[] args)` `    ``{` `        ``String str = ``"geeksforgeeks"``;` `        ``int` `index = firstNonRepeating(str);`   `        ``System.out.println(` `            ``index == -``1` `                ``? ``"Either all characters are repeating or string "` `                      ``+ ``"is empty"` `                ``: ``"First non-repeating character is "` `                      ``+ str.charAt(index));` `    ``}` `}`

## Python3

 `# Python program to print the first non-repeating character` `NO_OF_CHARS ``=` `256`   `# Returns an array of size 256 containing count` `# of characters in the passed char array` `def` `getCharCountArray(string):` `    ``count ``=` `[``0``] ``*` `NO_OF_CHARS` `    ``for` `i ``in` `string:` `        ``count[``ord``(i)]``+``=` `1` `    ``return` `count`   `# The function returns index of first non-repeating` `# character in a string. If all characters are repeating` `# then returns -1` `def` `firstNonRepeating(string):` `    ``count ``=` `getCharCountArray(string)` `    ``index ``=` `-``1` `    ``k ``=` `0`   `    ``for` `i ``in` `string:` `        ``if` `count[``ord``(i)] ``=``=` `1``:` `            ``index ``=` `k` `            ``break` `        ``k ``+``=` `1`   `    ``return` `index`   `# Driver program to test above function` `string ``=` `"geeksforgeeks"` `index ``=` `firstNonRepeating(string)` `if` `index ``=``=` `1``:` `    ``print` `(``"Either all characters are repeating or string is empty"``)` `else``:` `    ``print` `(``"First non-repeating character is"` `, string[index])`   `# This code is contributed by Bhavya Jain`

## C#

 `// C# program to find first non-repeating character` `using` `System;` `using` `System.Globalization;`   `class` `GFG {`   `    ``static` `int` `NO_OF_CHARS = 256;` `    ``static` `char``[] count = ``new` `char``[NO_OF_CHARS];`   `    ``/* calculate count of characters ` `    ``in the passed string */` `    ``static` `void` `getCharCountArray(``string` `str)` `    ``{` `        ``for` `(``int` `i = 0; i < str.Length; i++)` `            ``count[str[i]]++;` `    ``}`   `    ``/* The method returns index of first non-repeating` `    ``character in a string. If all characters are ` `    ``repeating then returns -1 */` `    ``static` `int` `firstNonRepeating(``string` `str)` `    ``{` `        ``getCharCountArray(str);` `        ``int` `index = -1, i;`   `        ``for` `(i = 0; i < str.Length; i++) {` `            ``if` `(count[str[i]] == 1) {` `                ``index = i;` `                ``break``;` `            ``}` `        ``}`   `        ``return` `index;` `    ``}`   `    ``// Driver code` `    ``public` `static` `void` `Main()` `    ``{` `        ``string` `str = ``"geeksforgeeks"``;` `        ``int` `index = firstNonRepeating(str);`   `        ``Console.WriteLine(index == -1 ? ``"Either "` `                                            ``+ ``"all characters are repeating or string "` `                                            ``+ ``"is empty"` `                                      ``: ``"First non-repeating character"` `                                            ``+ ``" is "` `+ str[index]);` `    ``}` `}`   `// This code is contributed by Sam007`

## PHP

 ``

Output

`First non-repeating character is f`

Can this be done by traversing the string only once?
The above approach takes O(n) time, but in practice, it can be improved. The first part of the algorithm runs through the string to construct the count array (in O(n) time). This is reasonable. But the second part about running through the string again just to find the first non-repeater is not a good practice.
In real situations, the string is expected to be much larger than your alphabet. Take DNA sequences, for example, they could be millions of letters long with an alphabet of just 4 letters. What happens if the non-repeater is at the end of the string? Then we would have to scan for a long time (again).

Method #2: HashMap and single string traversal

Make a count array instead of hash_map of maximum number of characters(256). We can augment the count array by storing not just counts but also the index of the first time you encountered the character e.g. (3, 26) for ‘a’ meaning that ‘a’ got counted 3 times and the first time it was seen is at position 26. So when it comes to finding the first non-repeater, we just have to scan the count array, instead of the string. Thanks to Ben for suggesting this approach.

Algorithm :

1. Make a count_array which will have two fields namely frequency, first occurrence of a character.
2. The size of count_array is ‘256’.
3. Traverse the given string using a pointer.
4. Increase the count of current character and update the occurrence.
5. Now here’s a catch, the array will contain valid first occurrence of the character which has frequency has unity otherwise the first occurrence keeps updating.
6. Now traverse the count_array and find the character which has least value of first occurrence and frequency value as unity.
7. Return the character

Pseudo Code :

```for ( i=0 to str.length())
count_arr[str[i]].first++;
count_arr[str[i]].second=i;

int res=INT_MAX;
for(i=0 to count_arr.size())
if(count_arr[str[i]].first==1)
res=min(min, count_arr[str[i]].second)

return res```

Implementation:

## C++

 `// CPP program to find first non-repeating` `// character` `#include ` `using` `namespace` `std;` `#define NO_OF_CHARS 256`   `/* The function returns index of the first` `   ``non-repeating character in a string. If` `   ``all characters are repeating then` `   ``returns INT_MAX */` `int` `firstNonRepeating(``char``* str)` `{` `    ``pair<``int``, ``int``> arr[NO_OF_CHARS];`   `    ``for` `(``int` `i = 0; str[i]; i++) {` `        ``(arr[str[i]].first)++;` `        ``arr[str[i]].second = i;` `    ``}`   `    ``int` `res = INT_MAX;` `    ``for` `(``int` `i = 0; i < NO_OF_CHARS; i++)`   `        ``// If this character occurs only` `        ``// once and appears before the` `        ``// current result, then update the` `        ``// result` `        ``if` `(arr[i].first == 1)` `            ``res = min(res, arr[i].second);`   `    ``return` `res;` `}`   `/* Driver program to test above function */` `int` `main()` `{` `    ``char` `str[] = ``"geeksforgeeks"``;` `    ``int` `index = firstNonRepeating(str);` `    ``if` `(index == INT_MAX)` `        ``printf``(``"Either all characters are "` `               ``"repeating or string is empty"``);` `    ``else` `        ``printf``(``"First non-repeating character"` `               ``" is %c"``,` `               ``str[index]);` `    ``return` `0;` `}`

## C

 `#include ` `#include ` `#include ` `#define NO_OF_CHARS 256`   `// Structure to store count of a` `// character and index of the first` `// occurrence in the input string` `struct` `countIndex {` `    ``int` `count;` `    ``int` `index;` `};`   `/* Returns an array of above ` `structure type. The size of` `array is NO_OF_CHARS */` `struct` `countIndex* getCharCountArray(``char``* str)` `{` `    ``struct` `countIndex* count = (``struct` `countIndex*)``calloc``(` `        ``sizeof``(``struct` `countIndex), NO_OF_CHARS);` `    ``int` `i;` `    ``for` `(i = 0; *(str + i); i++) {` `        ``(count[*(str + i)].count)++;`   `        ``// If it's first occurrence,` `        ``// then store the index` `        ``if` `(count[*(str + i)].count == 1)` `            ``count[*(str + i)].index = i;` `    ``}` `    ``return` `count;` `}`   `/* The function returns index of the ` `    ``first non-repeating character in ` `    ``a string. If all characters are ` `    ``repeating then returns INT_MAX */` `int` `firstNonRepeating(``char``* str)` `{` `    ``struct` `countIndex* count` `        ``= getCharCountArray(str);` `    ``int` `result = INT_MAX, i;`   `    ``for` `(i = 0; i < NO_OF_CHARS; i++) {` `        ``// If this character occurs` `        ``// only once and appears` `        ``// before the current result,` `        ``// then update the result` `        ``if` `(count[i].count == 1` `            ``&& result > count[i].index)` `            ``result = count[i].index;` `    ``}`   `    ``// To avoid memory leak` `    ``free``(count);` `    ``return` `result;` `}`   `/* Driver program to test above function */` `int` `main()` `{` `    ``char` `str[] = ``"geeksforgeeks"``;` `    ``int` `index = firstNonRepeating(str);` `    ``if` `(index == INT_MAX)` `        ``printf``(``"Either all characters are"` `               ``" repeating or string is empty"``);` `    ``else` `        ``printf``(``"First non-repeating character"` `               ``" is %c"``,` `               ``str[index]);` `    ``getchar``();` `    ``return` `0;` `}`

## Java

 `// Java program to find first` `// non-repeating character` `// Note : hashmap is used`   `import` `java.util.*;`   `class` `CountIndex {` `    ``int` `count, index;`   `    ``// constructor for first occurrence` `    ``public` `CountIndex(``int` `index)` `    ``{` `        ``this``.count = ``1``;` `        ``this``.index = index;` `    ``}`   `    ``// method for updating count` `    ``public` `void` `incCount()` `    ``{` `        ``this``.count++;` `    ``}` `}` `class` `GFG {` `    ``static` `final` `int` `NO_OF_CHARS = ``256``;`   `    ``static` `HashMap hm` `        ``= ``new` `HashMap(NO_OF_CHARS);`   `    ``/* calculate count of characters ` `       ``in the passed string */` `    ``static` `void` `getCharCountArray(String str)` `    ``{` `        ``for` `(``int` `i = ``0``; i < str.length(); i++) {` `            ``// If character already occurred,` `            ``if` `(hm.containsKey(str.charAt(i))) {` `                ``// updating count` `                ``hm.get(str.charAt(i)).incCount();` `            ``}`   `            ``// If it's first occurrence, then store` `            ``// the index and count = 1` `            ``else` `{` `                ``hm.put(str.charAt(i), ``new` `CountIndex(i));` `            ``}` `        ``}` `    ``}`   `    ``/* The method returns index of first non-repeating` `       ``character in a string. If all characters are repeating ` `       ``then returns -1 */` `    ``static` `int` `firstNonRepeating(String str)` `    ``{` `        ``getCharCountArray(str);` `        ``int` `result = Integer.MAX_VALUE, i;` `        ``for` `(Map.Entry entry : hm.entrySet())` `        ``{` `            ``int` `c=entry.getValue().count;` `            ``int` `ind=entry.getValue().index;` `            ``if``(c==``1` `&& ind < result)` `            ``{` `                ``result=ind;` `            ``}` `        ``}` `      `    `        ``return` `result;` `    ``}`   `    ``// Driver method` `    ``public` `static` `void` `main(String[] args)` `    ``{` `        ``String str = ``"geeksforgeeks"``;` `        ``int` `index = firstNonRepeating(str);`   `        ``System.out.println(` `            ``index == Integer.MAX_VALUE` `                ``? ``"Either all characters are repeating "` `                      ``+ ``" or string is empty"` `                ``: ``"First non-repeating character is "` `                      ``+ str.charAt(index));` `    ``}` `}`

## Python3

 `# Python3 program to find first non-repeating` `# character` `import` `sys`   `NO_OF_CHARS ``=` `256`   `#    The function returns index of the first` `#    non-repeating character in a string. If` `#    all characters are repeating then` `#    returns sys.maxsize :` `def` `firstNonRepeating(``Str``):`   `    ``arr ``=` `[[] ``for` `i ``in` `range``(NO_OF_CHARS)]` `    ``for` `i ``in` `range``(NO_OF_CHARS):` `        ``arr[i] ``=` `[``0``,``0``]`   `    ``for` `i ``in` `range``(``len``(``Str``)):` `        ``arr[``ord``(``Str``[i])][``0``] ``+``=` `1` `        ``arr[``ord``(``Str``[i])][``1``]``=` `i`     `    ``res ``=` `sys.maxsize` `    ``for` `i ``in` `range``(NO_OF_CHARS):`   `        ``# If this character occurs only` `        ``# once and appears before the` `        ``# current result, then update the` `        ``# result` `        ``if` `(arr[i][``0``] ``=``=` `1``):` `            ``res ``=` `min``(res, arr[i][``1``])`   `    ``return` `res`   `# Driver program to test above functionS` `Str` `=` `"geeksforgeeks"` `index ``=` `firstNonRepeating(``Str``)` `if` `(index ``=``=` `sys.maxsize):` `    ``print``(``"Either all characters are repeating or string is empty"``)` `else``:` `    ``print``(``"First non-repeating character is "``,``Str``[index])` `    `  `# This code is contributed by shinjanpatra`

## C#

 `// C# program to find first` `// non-repeating character` `// Note : hashmap is used` `using` `System;` `using` `System.Collections.Generic;`   `class` `CountIndex {` `    ``public` `int` `count, index;`   `    ``// constructor for first occurrence` `    ``public` `CountIndex(``int` `index)` `    ``{` `        ``this``.count = 1;` `        ``this``.index = index;` `    ``}`   `    ``// method for updating count` `    ``public` `virtual` `void` `incCount()` `    ``{` `        ``this``.count++;` `    ``}` `}`   `class` `GFG {` `    ``public` `const` `int` `NO_OF_CHARS = 256;`   `    ``public` `static` `Dictionary<``char``,` `                             ``CountIndex>` `        ``hm = ``new` `Dictionary<``char``,` `                            ``CountIndex>(NO_OF_CHARS);`   `    ``/* calculate count of characters ` `    ``in the passed string */` `    ``public` `static` `void` `getCharCountArray(``string` `str)` `    ``{` `        ``for` `(``int` `i = 0; i < str.Length; i++) {` `            ``// If character already occurred,` `            ``if` `(hm.ContainsKey(str[i])) {` `                ``// updating count` `                ``hm[str[i]].incCount();` `            ``}`   `            ``// If it's first occurrence, then` `            ``// store the index and count = 1` `            ``else` `{` `                ``hm[str[i]] = ``new` `CountIndex(i);` `            ``}` `        ``}` `    ``}`   `    ``/* The method returns index of first ` `    ``non-repeating character in a string. ` `    ``If all characters are repeating then` `    ``returns -1 */` `    ``internal` `static` `int` `firstNonRepeating(``string` `str)` `    ``{` `        ``getCharCountArray(str);` `        ``int` `result = ``int``.MaxValue, i;`   `        ``for` `(i = 0; i < str.Length; i++) {` `            ``// If this character occurs only` `            ``// once and appears before the` `            ``// current result, then update the result` `            ``if` `(hm[str[i]].count == 1 && result > hm[str[i]].index) {` `                ``result = hm[str[i]].index;` `            ``}` `        ``}`   `        ``return` `result;` `    ``}`   `    ``// Driver Code` `    ``public` `static` `void` `Main(``string``[] args)` `    ``{` `        ``string` `str = ``"geeksforgeeks"``;` `        ``int` `index = firstNonRepeating(str);`   `        ``Console.WriteLine(` `            ``index == ``int``.MaxValue` `                ``? ``"Either all characters are repeating "` `                      ``+ ``" or string is empty"` `                ``: ``"First non-repeating character is "` `                      ``+ str[index]);` `    ``}` `}`   `// This code is contributed by Shrikant13`

## Javascript

 ``

Output

`First non-repeating character is f`

Complexity Analysis:

• Time Complexity: O(n).
As the string need to be traversed at-least once.
• Auxiliary Space: O(1).
Space is occupied by the use of count_array/hash_map to keep track of frequency.

Method #3: Count array and single string traversal:

Approach: Make a count array of maximum number of characters(256). We can initialize all the elements in this array to -1. And then loop through our string character by character and check if the array element with this character as index is -1 or not. If it is -1 then change it to i and if it not -1 then this means that this character already appeared before, so change it to -2.

In the end all the repeating characters will be changed to -2 and all non-repeating characters will contain the index where they occur. Now we can just loop through all the non-repeating characters and find the minimum index or the first index.

Implementation:

## C++

 `// CPP program to find first non-repeating` `// character` `# include` `# include`   `using` `namespace` `std;`   `// this function return the index of first non-repeating ` `// character if found, or else it returns -1` `int` `firstNonRepeating(string str) {` `    ``int` `fi; ``// array to store First Index`   `    ``// initializing all elements to -1` `    ``for``(``int` `i = 0; i<256; i++) ` `        ``fi[i] = -1;`   `    ``// sets all repeating characters to -2 and non-repeating characters` `      ``// contain the index where they occur` `    ``for``(``int` `i = 0; i= 0) ` `            ``res = min(res, fi[i]);` `    ``}` `    `  `    ``// if res remains INT_MAX, it means there are no ` `    ``// characters that repeat only once or the string is empty` `    ``if``(res == INT_MAX) ``return` `-1;` `    ``else` `return` `res;` `}`   `int` `main(){` `    ``string str;` `      ``str = ``"geeksforgeeks"``;` `    ``int` `firstIndex = firstNonRepeating(str);` `    ``if` `(firstIndex == -1)` `        ``cout<<``"Either all characters are repeating or string is empty"``;` `    ``else` `        ``cout<<``"First non-repeating character is "``<< str[firstIndex];` `    `  `    ``return` `0;` `}`

## Java

 `// JAVA program to find first non-repeating` `// character` `public` `class` `GFG {` `    `  `// this function return the index of first non-repeating ` `// character if found, or else it returns -1` `public` `static` `int` `firstNonRepeating(String str) {` `    ``int``[] fi = ``new` `int` `[``256``]; ``// array to store First Index`   `    ``// initializing all elements to -1` `    ``for``(``int` `i = ``0``; i<``256``; i++) ` `        ``fi[i] = -``1``;`   `    ``// sets all repeating characters to -2 and non-repeating characters` `      ``// contain the index where they occur` `    ``for``(``int` `i = ``0``; i= ``0``) ` `            ``res = Math.min(res, fi[i]);` `    ``}` `    `  `    ``// if res remains  Integer.MAX_VALUE, it means there are no ` `    ``// characters that repeat only once or the string is empty` `    ``if``(res ==  Integer.MAX_VALUE) ``return` `-``1``;` `    ``else` `return` `res;` `}`   `public` `static` `void` `main(String args[]){` `    ``String str;` `    ``str = ``"geeksforgeeks"``;` `    ``int` `firstIndex = firstNonRepeating(str);` `    ``if` `(firstIndex == -``1``)` `       ``System.out.println(``"Either all characters are repeating or string is empty"``);` `    ``else` `       ``System.out.println(``"First non-repeating character is "``+ str.charAt(firstIndex));` `    ``}` `}` `//This code is contributed by SoumikMondal`

## Python3

 `# this function return the index of first non-repeating` `# character if found, or else it returns -1` `import` `sys`   `def` `firstNonRepeating(``Str``):` `    ``fi ``=` `[``-``1` `for` `i ``in` `range``(``256``)]` `    `  `    ``# sets all repeating characters to -2 and non-repeating characters` `    ``# contain the index where they occur` `    ``for` `i ``in` `range``(``len``(``Str``)):` `    `  `        ``if``(fi[``ord``(``Str``[i])] ``=``=``-``1``):` `            ``fi[``ord``(``Str``[i])] ``=` `i` `        ``else``:` `            ``fi[``ord``(``Str``[i])] ``=` `-``2` `        `  `    ``res ``=` `sys.maxsize`   `    ``for` `i ``in` `range``(``256``):`   `        ``# If this character is not -1 or -2 then it` `        ``# means that this character occurred only once` `        ``# so find the min index of all characters that` `        ``# occur only once, that's our first index` `        ``if``(fi[i] >``=` `0``):` `            ``res ``=` `min``(res, fi[i])` `    `  `    ``# if res remains INT_MAX, it means there are no` `    ``# characters that repeat only once or the string is empty` `    ``if``(res ``=``=` `sys.maxsize):` `        ``return` `-``1` `    ``else``:` `        ``return` `res`   `Str` `=` `"geeksforgeeks"` `firstIndex ``=` `firstNonRepeating(``Str``)`   `if` `(firstIndex ``=``=` `-``1``):` `    ``print``(``"Either all characters are repeating or string is empty"``)` `else``:` `    ``print``(``"First non-repeating character is "``+` `str``(``Str``[firstIndex]))` `    `  `# This code is contributed by shinjanpatra`

## C#

 `// C# program to find first non-repeating` `// character` `using` `System;` `public` `class` `GFG {`   `    ``// this function return the index of first non-repeating` `    ``// character if found, or else it returns -1` `    ``public` `static` `int` `firstNonRepeating(``string` `str)` `    ``{` `        ``int``[] fi` `            ``= ``new` `int``; ``// array to store First Index`   `        ``// initializing all elements to -1` `        ``for` `(``int` `i = 0; i < 256; i++)` `            ``fi[i] = -1;`   `        ``// sets all repeating characters to -2 and` `        ``// non-repeating characters contain the index where` `        ``// they occur` `        ``for` `(``int` `i = 0; i < str.Length; i++) {` `            ``if` `(fi[str[i]] == -1) {` `                ``fi[str[i]] = i;` `            ``}` `            ``else` `{` `                ``fi[str[i]] = -2;` `            ``}` `        ``}`   `        ``int` `res = Int32.MaxValue;`   `        ``for` `(``int` `i = 0; i < 256; i++) {`   `            ``// If this character is not -1 or -2 then it` `            ``// means that this character occurred only once` `            ``// so find the min index of all characters that` `            ``// occur only once, that's our first index` `            ``if` `(fi[i] >= 0)` `                ``res = Math.Min(res, fi[i]);` `        ``}`   `        ``// if res remains  Integer.MAX_VALUE, it means there` `        ``// are no characters that repeat only once or the` `        ``// string is empty` `        ``if` `(res == Int32.MaxValue)` `            ``return` `-1;` `        ``else` `            ``return` `res;` `    ``}`   `    ``public` `static` `void` `Main()` `    ``{` `        ``string` `str;` `        ``str = ``"geeksforgeeks"``;` `        ``int` `firstIndex = firstNonRepeating(str);` `        ``if` `(firstIndex == -1)` `            ``Console.WriteLine(` `                ``"Either all characters are repeating or string is empty"``);` `        ``else` `            ``Console.WriteLine(` `                ``"First non-repeating character is "` `                ``+ str[firstIndex]);` `    ``}` `}`   `// This code is contributed by ukasp.`

## Javascript

 ``

Output

`First non-repeating character is f`

Complexity Analysis:

• Time Complexity: O(n).
As the string need to be traversed once
• Auxiliary Space: O(1).
Space is occupied by the use of count-array to keep track of frequency.

Method #4: Using Built-in Python Functions:

Approach:

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

Below is the implementation:

## Python3

 `# Python implementation` `from` `collections ``import` `Counter`   `# Function which repeats` `# first Nonrepeating character` `def` `printNonrepeated(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 printNonrepeated function` `printNonrepeated(string)`   `# this code is contributed by vikkycirus`

Output

`f`

Time Complexity: O(n). As the string need to be traversed at-least once.
Auxiliary Space: O(n).

Using string function find():

Approach: Search every letter after its current position. should it return -1, it means the letter has just one occurrence that is the current index.

Implementation:

## C++

 `// C++ implementation`   `#include` `using` `namespace` `std;`   `void` `FirstNonRepeat(string s){`   `   ``for``(``int` `i = 0; i < s.length(); i++)` `   ``{`   `       ``if` `(s.find(s[i] ,s.find(s[i])+1) == string::npos)` `       ``{` `           ``cout<

## Python3

 `# python3 implementation`   `def` `FirstNonRepeat(s):`   `   ``for` `i ``in` `s:`   `       ``if` `(s.find(i,(s.find(i)``+``1``))) ``=``=` `-``1``:`   `           ``print``(i)`   `           ``break`   `   ``return`   `#__main__`   `s ``=` `'geeksforgeeks'`   `FirstNonRepeat(s)`

## C#

 `// C# program to find first non-repeating` `// character` `using` `System;`   `public` `static` `class` `GFG` `{`   `  ``// Function which repeats` `  ``// first Nonrepeating character` `  ``public` `static` `void` `FirstNonRepeat(``string` `s)` `  ``{`   `    ``for` `(``int` `i = 0; i < s.Length; i++) {`   `      ``if` `(s.IndexOf(s[i], s.IndexOf(s[i]) + 1)` `          ``== -1) {` `        ``Console.Write(s[i]);`   `        ``break``;` `      ``}` `    ``}` `    ``return``;` `  ``}`   `  ``// driver code` `  ``internal` `static` `void` `Main()` `  ``{`   `    ``string` `s = ``"geeksforgeeks"``;` `    ``FirstNonRepeat(s);` `  ``}` `}`   `// This code is contributed by Aarti_Rathi`

## Javascript

 ``

Output

`f`

Time Complexity: O(n^2)
Auxiliary Space: O(1).

Related Problem: K’th Non-repeating Character
Please suggest if someone has a better solution which is more efficient in terms of space and time.