Wsrtjtyk

Though to approach a solution I would suggest you to try and use a better data structure and not just string. Yet, you can simply modify your logic to delete already existing duplicates using an else as follows :

public static void uniqueCharacters(String test) {

        String temp = "";

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

            char ch = test.charAt(i);

            if (temp.indexOf(ch) == -1) {

                temp = temp + ch;

            } else {

                temp.replace(String.valueOf(ch),""); // added this to your existing code

            }

        }



        System.out.println(temp + " ");



    }

How about applying the KISS principle:

public static void uniqueCharacters(String test) {

    System.out.println(test.chars().distinct().mapToObj(c -> String.valueOf((char)c)).collect(Collectors.joining()));

}

The accepted answer will not pass all the test case for example

input -"aaabcdd"

desired output-"bc"

but the accepted answer will give -abc

because the character a present odd number of times.

Here I have used ConcurrentHasMap to store character and the number of occurrences of character then removed the character if the occurrences is more than one time.

import java.util.concurrent.ConcurrentHashMap;



public class RemoveConductive {



    public static void main(String args) {



        String s="aabcddkkbghff";



        String cvrtar=s.trim().split("");



        ConcurrentHashMap<String,Integer> hm=new ConcurrentHashMap<>();

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

            if(!hm.containsKey(cvrtar[i])){

                hm.put(cvrtar[i],1);

            }

            else{

                 hm.put(cvrtar[i],hm.get(cvrtar[i])+1);

            }

        }

        for(String ele:hm.keySet()){

            if(hm.get(ele)>1){

                hm.remove(ele);

            }

        }

        for(String key:hm.keySet()){

            System.out.print(key);

        }

    }  

}

This is an interview question. Find Out all the unique characters of a string.
Here is the complete solution. The code itself is self explanatory.

public class Test12 {

    public static void main(String args) {

        String a = "ProtijayiGiniGina";



        allunique(a);

    }



    private static void allunique(String a) {

        int count = new int[256];// taking count of characters

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

            char ch = a.charAt(i);

            count[ch]++;

        }



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

            char chh = a.charAt(i);

            // character which has arrived only one time in the string will be printed out

            if (count[chh] == 1) {

                System.out.println("index => " + i + " and unique character => " + a.charAt(i));



            }

        }



    }// unique



}

In Python :

def firstUniqChar(a):

    count = [0] *256

    for i in a: count[ord(i)] += 1

    element = ""



    for item in a:

        if (count[ord(item)] == 1):

            element = item;

            break;

    return element        





a = "GiniGinaProtijayi";

print(firstUniqChar(a)) # output is P

public static String input = "10 5 5 10 6 6 2 3 1 3 4 5 3";



public static void uniqueValue (String numbers) {

    String  str = input.split(" ");

    Set <String> unique = new HashSet <String> (Arrays.asList(str));

    System.out.println(unique);



    for (String value:unique) {

        int count = 0;

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

            if (value.equals(str[i])) {

                count++;

            }

        }

        System.out.println(value+"t"+count);

    }

}

public static void main(String  args) {

    uniqueValue(input);

}

I would store all the characters of the string in an array that you will loop through to check if the current characters appears there more than once. If it doesn't, then add it to temp.

public static void uniqueCharacters(String test) {

    String temp = "";

    char array = test.toCharArray();

    int count; //keep track of how many times the character exists in the string



    outerloop: for (int i = 0; i < test.length(); i++) {

        count = 0; //reset the count for every new letter

        for(int j = 0; j < array.length; j++) {

            if(test.charAt(i) == array[j])

                count++;

            if(count == 2){

                count = 0;

                continue outerloop; //move on to the next letter in the string; this will skip the next two lines below

            }

        }

        temp += test.charAt(i);

        System.out.println("Adding.");

    }    

    System.out.println(temp);

}

I have added comments for some more detail.

import java.util.*;

import java.lang.*;

class Demo

{

public static void main(String args)

{



Scanner sc=new Scanner(System.in);

System.out.println("Enter String");

String s1=sc.nextLine();

 try{

HashSet<Object> h=new HashSet<Object>();

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

{

h.add(s1.charAt(i));

}

Iterator<Object> itr=h.iterator();

  while(itr.hasNext()){

   System.out.println(itr.next());

    }

    }

    catch(Exception e)

    {

    System.out.println("error");

    }

}

}

If you don't want to use additional space:

    String abc="developer";



    System.out.println("The unique characters are-");



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

    {

        for(int j=i+1;j<abc.length();j++)

        {

            if(abc.charAt(i)==abc.charAt(j))

                abc=abc.replace(String.valueOf(abc.charAt(j))," ");

        }

    }   

    System.out.println(abc);

Time complexity O(n^2) and no space.

I use this way to get unique chars

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

    if(input.indexOf(input.charAt(i)) == input.lastIndexOf(input.charAt(i)))

        System.out.println(input.charAt(i) + "  is unique");

This String algorithm is used to print unique characters in a string.It runs in O(n) runtime where n is the length of the string.It supports ASCII characters only.

static String printUniqChar(String s) {

    StringBuilder buildUniq = new StringBuilder();

    boolean uniqCheck = new boolean[128];

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

        if (!uniqCheck[s.charAt(i)]) {

            uniqCheck[s.charAt(i)] = true;

            if (uniqCheck[s.charAt(i)])

                buildUniq.append(s.charAt(i));

        }

    }

public class UniqueCharactersInString {





 public static void main(String args){



    String input = "aabbcc";

    String output = uniqueString(input);



    System.out.println(output);

 }



 public static String uniqueString(String s){

     HashSet<Character> uniques = new HashSet<>();

     uniques.add(s.charAt(0));

     String out = "";

     out += s.charAt(0);



     for(int i =1; i < s.length(); i++){

         if(!uniques.contains(s.charAt(i))){

             uniques.add(s.charAt(i));

             out += s.charAt(i);

         }

     }

     return out;

 }

}

What would be the inneficiencies of this answer? How does it compare to other answers?

Based on your desired output you can replace each character already present with a blank character.

public static void uniqueCharacters(String test){

  String temp = "";

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

      if (temp.indexOf(test.charAt(i)) == - 1){

         temp = temp + test.charAt(i);

      } else {

         temp.replace(String.valueOf(temp.charAt(i)), "");

      }

 }



System.out.println(temp + " ");

}

public void uniq(String inputString) {

    String result = "";

    int inputStringLen = inputStr.length();

    int repeatedCharacters = new int[inputStringLen];

    char inputTmpChar;

    char tmpChar;



    for (int i = 0; i < inputStringLen; i++) {

        inputTmpChar = inputStr.charAt(i);

        for (int j = 0; j < inputStringLen; j++) {

            tmpChar = inputStr.charAt(j);

            if (inputTmpChar == tmpChar)

                repeatedCharacters[i]++;

        }

    }



    for (int k = 0; k < inputStringLen; k++) { 

        inputTmpChar = inputStr.charAt(k);

        if (repeatedCharacters[k] == 1)

            result = result + inputTmpChar + " ";

    }



    System.out.println ("Unique characters: " + result);

}

In first for loop I count the number of times the character repeats in the string.
In the second line I am looking for characters repetitive once.