Question

我正在编写一个程序，用于打印字符串中的唯一字符（通过扫描仪输入）。我创建了一个尝试实现此目的的方法，但我不断获得不重复的字符，而不是字符串唯一的字符（或字符）。我只想要这些独特的字母。

这是我的代码：

import java.util.Scanner;
public class Sameness{
   public static void main (String[]args){
   Scanner kb = new Scanner (System.in); 
     String word = "";

     System.out.println("Enter a word: ");
     word = kb.nextLine();

     uniqueCharacters(word); 
}

    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);
         }
      }

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

   }
}

这里的示例输出带有上面的代码：

Enter a word: 
nreena
nrea

预期输出为：ra

Answer 1

根据您所需的输出，您必须替换最初在稍后重复时添加的字符，因此：

public static void uniqueCharacters(String test){
    String temp = "";
    for (int i = 0; i < test.length(); i++){
        char current = test.charAt(i);
        if (temp.indexOf(current) < 0){
            temp = temp + current;
        } else {
            temp = temp.replace(String.valueOf(current), "");
        }
    }

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

}

Answer 2

如何应用KISS原则：

public static void uniqueCharacters(String test) {
    System.out.println(test.chars().distinct().mapToObj(c -> String.valueOf((char)c)).collect(Collectors.joining()));
}

Answer 3

虽然要接近解决方案，但我建议您尝试使用更好的数据结构，而不仅仅是字符串。但是，您可以使用else修改逻辑以删除现有的重复项，如下所示：

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 + " ");

    }

Answer 4

接受的答案不会通过所有测试用例，例如

输入 - "aaabcdd"

期望的输出 - "bc"
但接受的答案将给出-abc

因为该字符存在奇数次。

这里我使用ConcurrentHasMap存储字符和字符出现次数，如果出现的次数超过一次则删除字符。

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);
        }
    }  
}

Answer 5

这是一个面试问题。找出字符串的所有唯一字符。这是完整的解决方案。代码本身是不言自明的。

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

}

在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

Answer 6

第1步：：要查找字符串中的唯一字符，我首先从用户处获取了该字符串。 步骤2：使用Java中的内置函数将输入字符串转换为charArray。 第3步：考虑了两个HashSet（set1用于存储所有字符，即使重复出现也是如此），set2仅用于存储唯一字符。 Step4：：遍历数组，并检查是否set1中没有特定字符，然后将其添加到set1和set2中。如果该特定字符已经在set1中存在，则将其再次添加到set1中，但将其从set2中删除。（当特定字符重复奇数次时，此其他部分很有用）。 第5步：：现在set2仅具有唯一字符。因此，只需打印该set2。

public static void main(String[] args)
{
    Scanner input = new Scanner(System.in);
    String str = input.next();
    char arr[] = str.toCharArray();
    
    HashSet<Character> set1=new HashSet<Character>();
    HashSet<Character> set2=new HashSet<Character>();

    
    for(char i:arr)
    {
        if(set1.contains(i))
        {
            set1.add(i);
            set2.remove(i);
            
        }
        else
        {
            
            set1.add(i);
            set2.add(i);
        }
    }
    
    System.out.println(set2); 

}

Answer 7

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);
}

Answer 8

我用这种方式获得独特的字符

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");

Answer 9

此String算法用于在字符串中打印唯一字符。它在O（n）运行时运行，其中n是字符串的长度。它仅支持ASCII字符。

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));
        }
    }

Answer 10

如果您不想使用额外的空间：

    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);

时间复杂度O（n ^ 2）且没有空格。

Answer 11

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");
    }
}
}

Answer 12

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;
 }
}

此答案的无效之处是什么？与其他答案相比如何？

Answer 13

根据所需的输出，您可以将现有的每个字符替换为空白字符。

public protocol MyProtocol {}

}

Answer 14

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);
}

在第一个for循环中，我计算字符在字符串中重复的次数。
在第二行中，我寻找一次重复的字符。

Answer 15


package extra;

public class TempClass {

    public static void main(String[] args) {
        // TODO Auto-generated method stub
        String abcString="hsfj'pwue2hsu38bf74sa';fwe'rwe34hrfafnosdfoasq7433qweid";
        char[] myCharArray=abcString.toCharArray();
        TempClass mClass=new TempClass();

        mClass.countUnique(myCharArray);
        mClass.countEach(myCharArray);
    }
    /**
     * This is the program to find unique characters in array.
     * @add This is nice.
     * */
    public void countUnique(char[] myCharArray) {
        int arrayLength=myCharArray.length;
        System.out.println("Array Length is: "+arrayLength);
        char[] uniqueValues=new char[myCharArray.length];
        int uniqueValueIndex=0;
        int count=0;
        for(int i=0;i<arrayLength;i++) {
            for(int j=0;j<arrayLength;j++) {
                if (myCharArray[i]==myCharArray[j] && i!=j) {
                    count=count+1;
                }
            }
            if (count==0) {
                uniqueValues[uniqueValueIndex]=myCharArray[i];
                uniqueValueIndex=uniqueValueIndex+1;
                count=0;
            }
            count=0;
        }
        for(char a:uniqueValues) {
            System.out.println(a);
        }
    }
    /**
     * This is the program to find count each characters in array.
     * @add This is nice.
     * */
    public void countEach(char[] myCharArray) {

    }
}

Answer 16

str 将是您查找唯一字符的字符串。

function getUniqueChars(str){
let uniqueChars = '';
for(let i = 0; i< str.length; i++){
  for(let j= 0; j< str.length; j++) {
    if(str.indexOf(str[i]) === str.lastIndexOf(str[j])) {
       uniqueChars += str[i];
     }
   }
 }
 return uniqueChars;

}

Answer 17

我会将字符串中的所有字符存储在一个数组中，您将遍历该数组以检查当前字符是否出现多次。如果没有，则将其添加到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);
}

我添加了一些更详细的评论。

Answer 18

public static void main(String[] args) {
    String s = "aaabcdd";
    char a[] = s.toCharArray();
    List duplicates = new ArrayList();
    List uniqueElements = new ArrayList();
    for (int i = 0; i < a.length; i++) {
        uniqueElements.add(a[i]);
        for (int j = i + 1; j < a.length; j++) {
            if (a[i] == a[j]) {
                duplicates.add(a[i]);
                break;
            }
        }
    }
    uniqueElements.removeAll(duplicates);
    System.out.println(uniqueElements);
    System.out.println("First Unique : "+uniqueElements.get(0));

}

输出： [b, c] 第一个唯一：b

Java：在字符串中打印一个唯一的字符

18 个答案: