[알고리즘문제풀기] 한 번만 등장한 문자

문제

내가 작성한 정답

import java.util.*;

class Solution {
    public String solution(String s) {
        String answer = "";

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

            if(s.indexOf(c)==s.lastIndexOf(c)){
                answer += c;
            }
        }
				char[] chars = answer.toCharArray();
        Arrays.sort(chars);

        return new String(chars);
    }
}

String을 char배열로 바꾸기

// 1
char[] chars = new char[answer.length()];
for(int i =0; i<answer.length(); i++){
    chars[i] = answer.charAt(i);

// 2
char[] chars = answer.toCharArray();

다른 사람들의 정답

class Solution {
    public String solution(String s) {
		    // 알파벳 문자를 세기 위한 배열 생성 -> 알파벳 26개
		    
		    // 각 문자의 출현횟수 세기
        int[] alpha = new int[26];
        for(char c : s.toCharArray()){
        // 현재 문자의 ASCII 값을 이용하여 해당 문자의 출현 횟수를 증가시킨다.
        // 'a'는 0, 'b'는 1, ... 'z'는 25로 인덱스가 매핑된다.
            alpha[c - 'a']++; // 해당하는 문자의 인덱스를 증가시킴
        }

        StringBuilder answer = new StringBuilder();
        for(int i = 0; i < 26; i++){
		        // 출현 횟수가 1인 문자만 결과에 추가
            if(alpha[i] == 1){
                answer.append((char)(i + 'a'));
            }
        }
        // 알파벳 순서로 인덱스가 정해져서 정렬을 따로 할 필요가 없다.
        return answer.toString();
    }
}

import java.util.*;
class Solution {
    public String solution(String s) {
        char[] chars = s.toCharArray();
        Map<Character, Integer> charMap = new HashMap();
        for(char c : chars){
			      // value값으로 (값이 있으면 값을 가져오고 값이 없다면 0을 가져와) 1을 더한다.
            charMap.put(c, charMap.getOrDefault(c, 0) +1);
        }

        StringBuilder sb = new StringBuilder();
        for(char c : charMap.keySet()){
            if( charMap.get(c) == 1){
                sb.append(c);
            }
        }
        char[] charArr = sb.toString().toCharArray();
        Arrays.sort(charArr);
        return new String(charArr);
    }
}

StreamAPI

import java.util.Arrays;
import java.util.Map;
import java.util.stream.Collectors;

class Solution {
    public String solution(String s) {
		    // String을 쪼개면 배열 -> stream에 던진다
        return Arrays.stream(s.split(""))
				        // 이 과정에서 결과는 Map<String, List<String>> 형태가 됩니다. 즉, 키는 문자이고, 값은 해당 문자가 등장한 횟수만큼의 리스트입니다.
                .collect(Collectors.groupingBy(s1 -> s1))
                // Map.Entry 형태의 집합으로 변환 (엔트리는 문자와 해당 문자 리스트의 쌍)
                .entrySet()
                .stream()
                // 각 엔트리의 값(리스트)의 크기가 1 이하인 경우만 필터링
                .filter(entry -> entry.getValue().size() <= 1)
                // 필터링된 엔트리에서 문자(키)만 추출
                .map(Map.Entry::getKey)
                .sorted()
                .collect(Collectors.joining());
    }
}

Collectors.groupingBy(s1 -> s1)
	: s1 -> s1는 각 문자를 그대로 자신의 키로 사용
	이 메서드는 문자들을 그룹화하여 Map<String, List<String>> 형태의 결과를 생성합니다.
	예를 들어, 입력 문자열이 "abacc"라면, 결과는 다음과 같은 형태의 맵이 된다.
	{
	    "a" -> ["a", "a"],
	    "b" -> ["b"],
	    "c" -> ["c", "c"]
	}
	
.entrySet()
	: 맵의 모든 엔트리(키와 값의 쌍)를 반환
	
		Set<Map.Entry<String, List<String>>> entrySet = {
	    Entry("a", ["a", "a"]),
	    Entry("b", ["b"]),
	    Entry("c", ["c", "c"])
	}