CODEWITHSUNDEEP
javastring
Jonathan Bishop
Jonathan Bishop

Reputation: 167

Find the first non repeating character in a string

I m writing a method to find the first non repeating character in a string. I saw this method in a previous stackoverflow question 

public static char findFirstNonRepChar(String input){
 char currentChar = '\0';
 int len = input.length();
 for(int i=0;i<len;i++){
    currentChar = input.charAt(i);
    if((i!=0) && (currentChar!=input.charAt(i-1)) && (i==input.lastIndexOf(currentChar))){
        return currentChar;
    }
 }
 return currentChar;
}

I came up with a solution using a hashtable where I have two for loops (not nested) where I interate through the string in one loop writing down each occurance of a letter (for example in apple, a would have 1, p would have 2, etc.) then in the second loop I interate through the hashtable to see which one has a count of 1 first. What is the benefit to the above method over what I came up with? I am new to Java does having two loops (not nested) hinder time complexity. Both these algorithms should have O(n) right? Is there another faster, less space complexity algorithm for this question than these two solutions?

Upvotes: 5

Views: 46373

Answers (30)

maghalakshmi
maghalakshmi

Reputation: 1

package looping.concepts;

import java.util.Scanner;

public class Line {

    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        System.out.print("Enter name: ");
        String a = sc.nextLine();
        int i = 0;
        int j = 0;

        for (i = 0; i < a.length(); i++) {
            char ch = a.charAt(i);
            int counter = 0;
            // boolean repeat = false;
            for (j = 0; j < a.length(); j++) {
                if (ch == a.charAt(j)) {
                    counter++;
                }
            }
            if (counter == 1) {
                System.out.print(ch);
            }
            else
            {
                System.out.print("There is no non repeated character");
                break;
            }
        }
    }
}

Upvotes: 0

Ganesh Borde
Ganesh Borde

Reputation: 11

public static char NonReapitingCharacter(String str) {
        Set<Character> s = new HashSet();
        char ch = '\u0000';
        for (char c : str.toCharArray()) {
            if (s.add(c)) {
                
                if (c == ch) {
                    break;
                } else {
                    ch = c;
                }
            }
        }
        return ch;
    }

Upvotes: 1

Nitish Raj
Nitish Raj

Reputation: 147

public class FirstNonRepeatingChar {

    public static void main(String[] args) {
        String s = "hello world i am here";

        s.chars().boxed()
                .collect(Collectors.groupingBy(Function.identity(), LinkedHashMap::new, Collectors.counting()))
                .entrySet().stream().filter(e -> e.getValue() == 1).findFirst().ifPresent(e->System.out.println(e.getKey()));

    }

}

Upvotes: 0

ahmetyavuzoruc
ahmetyavuzoruc

Reputation: 155

For Java;

char firstNotRepeatingCharacter(String s) {
    
    HashSet<String> hs = new HashSet<>();
    StringBuilder sb =new StringBuilder(s);
    
    for (int i = 0; i<s.length(); i++){
        char c = sb.charAt(i);
        if(s.indexOf(c) == i && s.indexOf(c, i+1) == -1 ) {
            return c;
        }
    }

    return '_';
}

Upvotes: 0

Pravin Jadhav
Pravin Jadhav

Reputation: 1

You can achieve this in single traversal of String using LinkedHashSet as follows:

    public static Character getFirstNonRepeatingCharacter(String str) {
            Set<Character> result = new LinkedHashSet<>(256);
            for (int i = 0; i< str.length(); ++i) {
                if(!result.add(str.charAt(i))) {
                    result.remove(str.charAt(i));
                }
             }
            if(result.iterator().hasNext()) {
                return result.iterator().next();
             }
            return null;
        }

Upvotes: 0

DIA
DIA

Reputation: 9

Using Set with single for loop

public static Character firstNonRepeatedCharacter(String str) {

Character result = null;

if (str != null) {
  Set<Character> set = new HashSet<>();
  for (char c : str.toCharArray()) {
    if (set.add(c) && result == null) {
      result = c;
    } else if (result != null && c == result) {
      result = null;
    }
  }
}
return result;

}

Upvotes: 0

Bharat Gupta
Bharat Gupta

Reputation: 1

   public static void firstNonRepeatFirstChar(String str) {

    System.out.println("The given string is: " + str);
    for (int i = 0; i < str.length(); i++) {
        boolean unique = true;
        for (int j = 0; j < str.length(); j++) {
            if (i != j && str.charAt(i) == str.charAt(j)) {
                unique = false;
                break;
            }
        }
        if (unique) {
            System.out.println("The first non repeated character in String is: " + str.charAt(i));
            break;
        }
    }
}

Upvotes: 0

LutfiTekin
LutfiTekin

Reputation: 471

In Kotlin

 fun firstNonRepeating(string: String): Char?{
    //Get a copy of the string
    var copy = string
    //Slice string into chars then convert them to string
    string.map { it.toString() }.forEach {
        //Replace first occurrance of that character and check if it still has it
        if (copy.replaceFirst(it,"").contains(it))
        //If it has the given character remove it
            copy = copy.replace(it,"")
    }
    //Return null if there is no non-repeating character
    if (copy.isEmpty())
        return null
    //Get the first character from what left of that string
    return copy.first()
}

https://pl.kotl.in/KzL-veYNZ

Upvotes: 0

Ndm
Ndm

Reputation: 11

In this coding i use length of string to find the first non repeating letter.

 package com.string.assingment3;
    import java.util.Scanner;
   public class FirstNonRepetedChar {
    public static void main(String[] args) {
        Scanner in = new Scanner(System.in);
        System.out.println("Enter a String : ");
        String str = in.next();
        char[] ch = str.toCharArray();
        int length = ch.length;
        int x = length;
        for(int i=0;i<length;i++) {
            x = length-i;
            for(int j=i+1;j<length;j++) {
                if(ch[i]!=ch[j]) {
                    x--;
                }//if
            }//inner for
            if(x==1) {
            System.out.println(ch[i]);
                break;
            }
            else {
                    continue;
            }
        }//outer for
    }
}// develope by NDM

Upvotes: 0

Keshav Gera
Keshav Gera

Reputation: 11244

Non Repeated Character String in Java

public class NonRepeatedCharacter {
     public static void main(String[] args) {
        String s = "ffeeddbbaaclck";
        for (int i = 0; i < s.length(); i++) {
             boolean unique = true;
             for (int j = 0; j < s.length(); j++) {
                 if (i != j && s.charAt(i) == s.charAt(j)) {
                     unique = false;
                     break;
                 }
              }
             if (unique) {
                 System.out.println("First non repeated characted in String \""
                 + s + "\" is:" + s.charAt(i));
                 break;
             }
         }
     }
}
Output:
First non repeated characted in String "ffeeddbbaaclck" is:l

For More Details

Upvotes: 0

Shivam Bharadwaj
Shivam Bharadwaj

Reputation: 2296

public class GFG {
public static void main(String[] args) {
    String s = "mmjjjjmmn";
    for (char c : s.toCharArray()) {
        if (s.indexOf(c) == s.lastIndexOf(c)) {
            System.out.println("First non repeated is:" + c);
            break;
        }
    }
}

output = n

Upvotes: 0

Akshil Savalia
Akshil Savalia

Reputation: 1

  import java.util.*;
public class Main {
 public static void main(String[] args) {
  String str1 = "gibblegabbler";
  System.out.println("The given string is: " + str1);
  for (int i = 0; i < str1.length(); i++) {
   boolean unique = true;
   for (int j = 0; j < str1.length(); j++) {
    if (i != j && str1.charAt(i) == str1.charAt(j)) {
     unique = false;
     break;
    }
   }
   if (unique) {
    System.out.println("The first non repeated character in String is: " + str1.charAt(i));
    break;
   }
  }
 }
}

Upvotes: 0

STaefi
STaefi

Reputation: 4377

As you asked if your code is from O(n) or not, I think it's not, because in the for loop, you are calling lastIndexOf and it's worst case is O(n). So it is from O(n^2).

About your second question: having two loops which are not nested, also makes it from O(n).

If assuming non unicode characters in your input String, and Uppercase or Lowercase characters are assumed to be different, the following would do it with o(n) and supports all ASCII codes from 0 to 255:

public static Character getFirstNotRepeatedChar(String input) {

    byte[] flags = new byte[256]; //all is initialized by 0 

    for (int i = 0; i < input.length(); i++) { // O(n)
        flags[(int)input.charAt(i)]++ ;
    }

    for (int i = 0; i < input.length(); i++) { // O(n)
        if(flags[(int)input.charAt(i)] > 0)
            return input.charAt(i);
    }

    return null;
}

Thanks to Konstantinos Chalkias hint about the overflow, if your input string has more than 127 occurrence of a certain character, you can change the type of flags array from byte[] to int[] or long[] to prevent the overflow of byte type.

Hope it would be helpful.

Upvotes: 9

Jayaraj Chevery
Jayaraj Chevery

Reputation: 121

public class FirstNonRepeatCharFromString {

    public static void main(String[] args) {

        String s = "java";
        for(Character ch:s.toCharArray()) {
            if(s.indexOf(ch) == s.lastIndexOf(ch)) {
                System.out.println("First non repeat character = " + ch);
                break;
            }
        }
    }
}

Upvotes: 12

Dmitry Ionash
Dmitry Ionash

Reputation: 821

I accumulated all possible methods with string length 25'500 symbols:

private static String getFirstUniqueChar(String line) {
    String result1 = null, result2 = null, result3 = null, result4 = null, result5 = null;
    int length = line.length();

    long start = System.currentTimeMillis();
    Map<Character, Integer> chars = new LinkedHashMap<Character, Integer>();
    char[] charArray1 = line.toCharArray();
    for (int i = 0; i < length; i++) {
        char currentChar = charArray1[i];
        chars.put(currentChar, chars.containsKey(currentChar) ? chars.get(currentChar) + 1 : 1);
    }
    for (Map.Entry<Character, Integer> entry : chars.entrySet()) {
        if (entry.getValue() == 1) {
            result1 = entry.getKey().toString();
            break;
        }
    }
    long end = System.currentTimeMillis();
    System.out.println("1st test:\n    result: " + result1 + "\n    time: " + (end - start));

    start = System.currentTimeMillis();
    for (int i = 0; i < length; i++) {
        String current = Character.toString(line.charAt(i));
        String left = line.substring(0, i);
        if (!left.contains(current)) {
            String right = line.substring(i + 1);
            if (!right.contains(current)) {
                result2 = current;
                break;
            }
        }
    }
    end = System.currentTimeMillis();
    System.out.println("2nd test:\n    result: " + result2 + "\n    time: " + (end - start));

    start = System.currentTimeMillis();
    for (int i = 0; i < length; i++) {
        char currentChar = line.charAt(i);
        if (line.indexOf(currentChar) == line.lastIndexOf(currentChar)) {
            result3 = Character.toString(currentChar);
            break;
        }
    }
    end = System.currentTimeMillis();
    System.out.println("3rd test:\n    result: " + result3 + "\n    time: " + (end - start));

    start = System.currentTimeMillis();
    char[] charArray4 = line.toCharArray();
    for (int i = 0; i < length; i++) {
        char currentChar = charArray4[i];
        int count = 0;
        for (int j = 0; j < length; j++) {
            if (currentChar == charArray4[j] && i != j) {
                count++;
                break;
            }
        }
        if (count == 0) {
            result4 = Character.toString(currentChar);
            break;
        }
    }
    end = System.currentTimeMillis();
    System.out.println("4th test:\n    result: " + result4 + "\n    time: " + (end - start));

    start = System.currentTimeMillis();
    for (int i = 0; i < length; i++) {
        char currentChar = line.charAt(i);
        int count = 0;
        for (int j = 0; j < length; j++) {
            if (currentChar == line.charAt(j) && i != j) {
                count++;
                break;
            }
        }
        if (count == 0) {
            result5 = Character.toString(currentChar);
            break;
        }
    }
    end = System.currentTimeMillis();
    System.out.println("5th test:\n    result: " + result5 + "\n    time: " + (end - start));

    return result1;
}

And time results (5 times):

1st test:
    result: g
    time: 13, 12, 12, 12, 14
2nd test:
    result: g
    time: 55, 56, 59, 70, 59
3rd test:
    result: g
    time: 2, 3, 2, 2, 3
4th test:
    result: g
    time: 3, 3, 2, 3, 3
5th test:
    result: g
    time: 6, 5, 5, 5, 6

Upvotes: 1

Girish Gupta
Girish Gupta

Reputation: 1293

This is solution in python:

input_str = "interesting"
#input_str = "aabbcc"
#input_str = "aaaapaabbcccq"


def firstNonRepeating(param):
    counts = {}        
    for i in range(0, len(param)):

    # Store count and index repectively
        if param[i] in counts:
            counts[param[i]][0] += 1
        else:
            counts[param[i]] = [1, i]

    result_index = len(param) - 1
    for x in counts:
        if counts[x][0] == 1 and result_index > counts[x][1]:
            result_index = counts[x][1]
    return result_index

result_index = firstNonRepeating(input_str)
if result_index == len(input_str)-1:
    print("no such character found")
else:
    print("first non repeating charater found: " + input_str[result_index])

Output:

first non repeating charater found: r

Upvotes: 0

Rakesh Chaudhari
Rakesh Chaudhari

Reputation: 3502

String a = "sampapl";
    char ar[] = a.toCharArray();

    int dya[] = new int[256];
    for (int i = 0; i < dya.length; i++) {
        dya[i] = -1;
    }

    for (int i = 0; i < ar.length; i++) {

        if (dya[ar[i]] != -1) {
            System.out.println(ar[i]);
           break;
        } else {
            dya[ar[i]] = ar[i];
        }
    }

Upvotes: 0

Houston Salgado
Houston Salgado

Reputation: 1

char firstNotRepeatingCharacter(String s) {
    for(int i=0; i< s.length(); i++){
        if(i == s.lastIndexOf(s.charAt(i)) && i == s.indexOf(s.charAt(i))){
            return s.charAt(i);
        }
    }
    return '_';
}

Upvotes: 0

Duy Tran
Duy Tran

Reputation: 110

Constraint for this solution:

O(n) time complexity. My solution is O(2n), follow Time Complexity analysis,O(2n) => O(n)

import java.util.HashMap;

public class FindFirstNonDuplicateCharacter {
    public static void main(String args[]) {
    System.out.println(findFirstNonDuplicateCharacter("abacbcefd"));
    }

    private static char findFirstNonDuplicateCharacter(String s) {
    HashMap<Character, Integer> chDupCount = new HashMap<Character, Integer>();
    char[] charArr = s.toCharArray();
    for (char ch: charArr) { //first loop, make the tables and counted duplication by key O(n)
      if (!chDupCount.containsKey(ch)) {
        chDupCount.put(ch,1);
        continue;
      }
      int dupCount = chDupCount.get(ch)+1;
      chDupCount.replace(ch, dupCount);
    }

    char res = '-';
    for(char ch: charArr) { //second loop, get the first duplicate by count number, O(2n)
      // System.out.println("key: " + ch+", value: " + chDupCount.get(ch));
      if (chDupCount.get(ch) == 1) {
        res = ch;
        break;
      }
    }

    return res;
    } 
}

Hope it help

Upvotes: 0

Karthi Murugan
Karthi Murugan

Reputation: 57

Few lines of code, works for me.

public class FirstNonRepeatingCharacter {

    final static String string = "cascade";

    public static void main(String[] args) {

        char[] charArr = string.toCharArray();

        for (int i = 0; charArr.length > i; i++) {
            int count = 0;
            for (int j = 0; charArr.length > j; j++) {
                if (charArr[i] == charArr[j]) {
                    count++;
                }
            }
            if (count == 1){
                System.out.println("First Non Repeating Character is: " + charArr[i]);
                break;
            }
        }

    }
}

Upvotes: 0

Painy James
Painy James

Reputation: 824

Since LinkedHashMap keeps the order of insertion

package com.company;

import java.util.LinkedHashMap;
import java.util.Map;
import java.util.Scanner;

public class Main {
    public static void main(String[] argh) {
        Scanner sc = new Scanner(System.in);
        String l = sc.nextLine();
        System.out.println(firstCharNoRepeated(l));
    }

    private static String firstCharNoRepeated(String l) {
        Map<String, Integer> chars = new LinkedHashMap();
        for(int i=0; i < l.length(); i++) {
            String c = String.valueOf(l.charAt(i));
            if(!chars.containsKey(c)){
                chars.put(c, i);
            } else {
                chars.remove(c);
            }
        }
        return chars.keySet().iterator().next();
    }
}

Upvotes: 0

Ravi chinnamanaidu
Ravi chinnamanaidu

Reputation: 11

package com.test.util;

public class StringNoRepeat {

    public static void main(String args[]) {
        String st = "234123nljnsdfsdf41l";
        String strOrig=st;
        int i=0;
        int j=0;
        String st1="";
        Character ch=' ';
        boolean fnd=false;
        for (i=0;i<strOrig.length(); i++) {


            ch=strOrig.charAt(i);
            st1 = ch.toString();

            if (i==0)
                st = strOrig.substring(1,strOrig.length());
            else if (i == strOrig.length()-1)
            st=strOrig.substring(0, strOrig.length()-1);
            else 
                st=strOrig.substring(0, i)+strOrig.substring(i+1,strOrig.length());
            if (st.indexOf(st1) == -1) {
                fnd=true;
              j=i;
                break;  
            }
        }
        if (!fnd)
            System.out.println("The first no non repeated character");
        else
            System.out.println("The first non repeated character is " +strOrig.charAt(j));


    }

}

Upvotes: -1

vishal Mishra
vishal Mishra

Reputation: 1

public char firstNonRepeatedChar(String input) {
    char out = 0;
    int length = input.length();
    for (int i = 0; i < length; i++) {
        String sub1 = input.substring(0, i);
        String sub2 = input.substring(i + 1);
        if (!(sub1.contains(input.charAt(i) + "") || sub2.contains(input
                .charAt(i) + ""))) {
            out = input.charAt(i);
            break;
        }
    }
    return out;
}

Upvotes: 0

Olivier Gr&#233;goire
Olivier Gr&#233;goire

Reputation: 35427

The algorithm you showed is slow: it looks for each character in the string, it basically means that for each character you spend your time checking the string twice!! Huge time loss.

The best naive O(n) solution basically holds all the characters in order of insertion (so the first can be found) and maps a mutable integer to them. When we're done, analyzing, we go through all the entries and return the first character that was registered and has a count of 1.

There are no restrictions on the characters you can use. And AtomicInteger is available with import java.util.concurrent.atomic.AtomicInteger.

Using Java 8:

public static char findFirstNonRepChar(String string) {
    Map<Integer,Long> characters = string.chars().boxed()
            .collect(Collectors.groupingBy(Function.identity(), LinkedHashMap::new, Collectors.counting()));
    return (char)(int)characters.entrySet().stream()
            .filter(e -> e.getValue() == 1L)
            .findFirst()
            .map(Map.Entry::getKey)
            .orElseThrow(() -> new RuntimeException("No unrepeated character"));
}

Non Java 8 equivalent:

public static char findFirstNonRepChar(String string) {
  Map<Character, AtomicInteger> characters = new LinkedHashMap<>(); // preserves order of insertion.
  for (int i = 0; i < string.length(); i++) {
    char c = string.charAt(i);
    AtomicInteger n = characters.get(c);
    if (n == null) {
      n = new AtomicInteger(0);
      characters.put(c, n);
    }
    n.incrementAndGet();
  }
  for (Map.Entry<Character, AtomicInteger> entry: characters.entries()) {
    if (entry.getValue().get() == 1) {
      return entry.getKey();
    }
  }
  throw new RuntimeException("No unrepeated character");
}

Upvotes: 7

Zok
Zok

Reputation: 365

import java.util.LinkedHashMap;
import java.util.Map;

public class getFirstNonRep {

public static char get(String s) throws Exception {
    if (s.length() == 0) {
        System.out.println("Fail");
        System.exit(0);
    } else {
        Map<Character, Integer> m = new LinkedHashMap<Character, Integer>();

        for (int i = 0; i < s.length(); i++) {
            if (m.containsKey(s.charAt(i))) {
                m.put(s.charAt(i), m.get(s.charAt(i)) + 1);
            } else {
                m.put(s.charAt(i), 1);
            }
        }
        for (Map.Entry<Character, Integer> hm : m.entrySet()) {
            if (hm.getValue() == 1) {
                return hm.getKey();
            }
        }
    }
    return 0;
}

public static void main(String[] args) throws Exception {

    System.out.print(get("Youssef Zaky"));

    }

 }

This solution takes less space and less time, since we iterate the string only one time.

Upvotes: 4

Karan Khanna
Karan Khanna

Reputation: 2137

In case of two loops (not nested) the time complexity would be O(n).

The second solution mentioned in the question can be implemented as:

We can use string characters as keys to a map and maintain their count. Following is the algorithm.

1.Scan the string from left to right and construct the count map.

2.Again, scan the string from left to right and check for count of each character from the map, if you find an element who’s count is 1, return it.

package com.java.teasers.samples;  
import java.util.Map;  
import java.util.HashMap;  
public class NonRepeatCharacter {  
    public static void main(String[] args) {  
        String yourString = "Hi this is javateasers";//change it with your string  
        Map<Character, Integer> characterMap = new HashMap<Character, Integer>();  
        //Step 1 of the Algorithm  
        for (int i = 0; i < yourString.length(); i++) {  
            Character character = yourString.charAt(i);  
            //check if character is already present  
            if(null != characterMap.get(character)){  
                //in case it is already there increment the count by 1.  
                characterMap.put(character, characterMap.get(character) + 1);  
            }  
            //in case it is for the first time. Put 1 to the count  
            else  
                characterMap.put(character, 1);  
        }  
        //Step 2 of the Algorithm  
        for (int i = 0; i < yourString.length(); i++) {  
            Character character = yourString.charAt(i);  
            int count = characterMap.get(character);  
            if(count == 1){  
                System.out.println("character is:" + character);  
                break;  
            }  
        }  
    }  
}

Upvotes: 0

Shiva Sagan
Shiva Sagan

Reputation: 31

import java.util.Scanner;

public class NonRepaeated1
{
  public static void main(String args[])
  {
    String str;
    char non_repeat=0;
    int len,i,j,count=0;

    Scanner s = new Scanner(System.in);
    str = s.nextLine();

    len = str.length();

    for(i=0;i<len;i++) 
    { 
      non_repeat=str.charAt(i); 
      count=1; 

      for(j=0;j<len;j++) 
      { 
        if(i!=j) 
        { 
          if(str.charAt(i) == str.charAt(j)) 
          { 
            count=0; 
            break; 
          } 
        } 
      } 

      if(count==1) 
        break; 
    } 
if(count == 1) 
System.out.print("The non repeated character is  : " + non_repeat); 

  }
}

Upvotes: -1

JamesJ30t
JamesJ30t

Reputation: 11

Works for any type of characters.

String charHolder;  // Holds 
String testString = "8uiuiti080t8xt8t";
char   testChar = ' ';
int count = 0;  

for (int i=0; i <= testString.length()-1; i++) {
    testChar = testString.charAt(i);

    for (int j=0; j < testString.length()-1; j++) {
        if (testChar == testString.charAt(j)) {
           count++;
        }
    }
    if (count == 1) { break; };
       count = 0;
}

System.out.println("The first not repeating character is " + testChar);

Upvotes: 1

Kostas Kryptos
Kostas Kryptos

Reputation: 4111

If you are only interested for characters in the range a-z (lowercase as OP requested in comments), you can use this method that requires a minimum extra storage of two bits per character Vs a HashMap approach.

/*
 * It works for lowercase a-z
 * you can scale it to add more characters
 * eg use 128 Vs 26 for ASCII or 256 for extended ASCII 
 */
public static char getFirstNotRepeatedChar(String input) {

    boolean[] charsExist = new boolean[26];
    boolean[] charsNonUnique = new boolean[26];

    for (int i = 0; i < input.length(); i++) {
        int index = 'z' - input.charAt(i);
        if (!charsExist[index]) {
            charsExist[index] = true;
        } else {
            charsNonUnique[index] = true;
        }
    }

    for (int i = 0; i < input.length(); i++) {
        if (!charsNonUnique['z' - input.charAt(i)])
            return input.charAt(i);
    }

    return '?'; //example return of no character found
}

Upvotes: 0

Hatefiend
Hatefiend

Reputation: 3596

Okay I misread the question initially so here's a new solution. I believe is this O(n). The contains(Object) of HashSet is O(1), so we can take advantage of that and avoid a second loop. Essentially if we've never seen a specific char before, we add it to the validChars as a potential candidate to be returned. The second we see it again however, we add it to the trash can of invalidChars. This prevents that char from being added again. At the end of the loop (you have to loop at least once no matter what you do), you'll have a validChars hashset with n amount of elements. If none are there, then it will return null from the Character class. This has a distinct advantage as the char class has no good way to return a 'bad' result so to speak.

public static Character findNonRepeatingChar(String x)
{
    HashSet<Character> validChars = new HashSet<>();
    HashSet<Character> invalidChars = new HashSet<>(); 

    char[] array = x.toCharArray();
    for (char c : array)
    {
        if (validChars.contains(c))
        {
            validChars.remove(c);
            invalidChars.add(c);
        }
        else if (!validChars.contains(c) && !invalidChars.contains(c))
        {
            validChars.add(c);
        }
    }

    return (!validChars.isEmpty() ? validChars.iterator().next() : null);
}

Upvotes: 0

Related Questions