CareerCup

geeksforgeeks.org/find-first-non-repeating-character-stream-characters/

Use hashmap to uniquely identify keys in place of repeated array.

Created a Dictionary to hold key/value for elements that occur only once, with the value being their index in the list which we need to determine which one is the first occurrence. The hashtable holds the elements that occur more than once and we ignore those. Algo goes 1x through the list ignoring a string that is in the Hashtable (multiple) already, inserting into to the Dictionary (single) if not present, and moving from single to multiple if this is a first repeat. Result is Dictionary of unique elements whose values are their indexes. Loop through the resulting dictionary returning the key for the smallest value.

Since the hashtable and dictionary lookups are 0(1), I think this algo is 0(2n) where n is the number of elements in the list. Would happily except correction here if my big O performance assessment is wrong :)

protected string GetFirstUnique(List<string> baseList)
    {
        Dictionary<string,int> single = new Dictionary<string,int>();
        Hashtable multiple = new Hashtable();
        string retVal = null;
        int minIndex = int.MaxValue;

        for (int index = 0; index < baseList.Count; index++)
        {
            string str = baseList[index];
            if (!multiple.ContainsKey(str))
            {
                if (single.ContainsKey(str))
                {
                    single.Remove(str);
                    multiple.Add(str, 0);
                }
                else
                {
                    single.Add(str, index);
                }
            }
        }
        
        foreach (var e in single)
        {
            if (e.Value < minIndex)
                retVal = e.Key;
        }
        return retVal;
    }

Python has a built in library for this, collections.Counter.

def firstUnique(numbers):
	numCounts = collections.Counter(numbers)
	for x in numbers:
		if numCounts[x] == 1:
			return x
	return None

This u can do easily by using 2 data structure.
1)DLL which maintain the order in which letter is coming and
2) Hash with the letter,to remove the element from DLL which are repeating.

Give little bit thought its simple

>>> a=['a','b','c','b','a','d']
>>> b=list(set(a))
>>> for i in b:
...   count=0
...   for j in a:
...     if i==j:
...       count=count+1
...     if count==2:
...       break
...   if count==1:
...     print i
...
c
d

Here is a HashMap Based solution

public String findDuplicate(String[] inputStrings){
        Map<String,Integer> inputMap = new HashMap<>();
        int count;
        String uniqueString="";
        for(String input : inputStrings){
            if(inputMap.containsKey(input)){
                count = inputMap.get(input).intValue();
                count++;
                inputMap.put(input, count);
            }else{
                inputMap.put(input, 1);
            }
        }
        for(String input : inputStrings){
            if(inputMap.containsKey(input) && inputMap.get(input).intValue() ==1){
                uniqueString = input;
                break;
            }
        }
        return uniqueString;
    }

Use LinkedHashMap<String, Integer> , key will be string and integer will number of occurrences. Complexity will be O(n)

Just traverse it in reverse order and save last uniq number (which is not in hashMap)

#!/usr/bin/perl

@list = (21, 2, 3, 4, 3, 21, 0, 1, 4);

foreach my $element (reverse @list)
{
if(not defined $hashMap{$element}) {
$first_uniq = $element;
$hashMap{$element} = 1;
}
}
print $first_uniq;

1. insert the stream of characters into hashset one by one
2. Before insertion, check the existence of the character stream
3. If already exists, remove the element from hashset
4. Print the first element of the hashset

package com.collection2;

import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;

public class UniqueElement {

	public static List<String> value;
	public static Map<String, Integer> MappedValues = new HashMap<String, Integer>();
	public static String uniqueval = null;
	public static String str = "";

	public UniqueElement() {
		value = new ArrayList<String>();
		value.add("BH");
		value.add("BH");
		value.add("F");
		value.add("AL");
		value.add("HJ");
		value.add("AL");
		value.add("HJ");
		value.add("PK");

		System.out.println(value);

	}

	protected String myVal(List<String> val) {

		for (int i = 0; i < val.size(); i++) {
			int count = 0;
			str = val.get(i);
			for (String key : val) {
				if (key == str) {
					count++;
					MappedValues.put(str, count);
					
				}
				MappedValues.put(str, count);
			}
		}

		for (String uniq : val) {
			if (MappedValues.containsKey(uniq)
					&& MappedValues.get(uniq).intValue() == 1) {
				uniqueval = uniq;
				break;
			}

		}
		return uniqueval;

	}

	public static void main(String[] args) {
		UniqueElement a = new UniqueElement();
		a.myVal(value);
		System.out.println(MappedValues);
		System.out.println(uniqueval);
	}

}

I would do it in the following way....

Step 1: Iterate through all the elements in the list
Step 2: Insert each element in a set if its not there, else remove from the set.
Step 3: once end of list occurs, Iterate through the set and print if any element, else "print no unique element"

I need the first unique element
my solution is :

1. Insert the elements of the list into hashmap as Key and a count as value.
2. Before insert check the key into hashmap
if the key is present make the value as negative
else insert into the hashmap and increase the count value

3. After iterating the whole list,search for the key whose value is least +ve value
and that is the answer.

if it's an ASCII character set ... you could just make an array[256] and while iterating through the string array[charAt(i)]++ ... then iterate through the array to find the element with count = 1

1. Iterate through list and put all elements in map with their count.
2. Iterate again through the list, check if the current element count in map is one, if so, return it.