한번만 등장한 문자

문자열 s가 매개변수로 주어집니다. s에서 한 번만 등장하는 문자를 사전 순으로 정렬한 문자열을 return 하도록 solution 함수를 완성해보세요. 한 번만 등장하는 문자가 없을 경우 빈 문자열을 return 합니다.

---

제한사항

• 0 < s의 길이 < 1,000
• s는 소문자로만 이루어져 있습니다.

---

입출력 예

sresult

"abcabcadc"	"d"
"abdc"	"abcd"
"hello"	"eho"

---

입출력 예 설명

입출력 예 #1

• "abcabcadc"에서 하나만 등장하는 문자는 "d"입니다.

입출력 예 #2

• "abdc"에서 모든 문자가 한 번씩 등장하므로 사전 순으로 정렬한 "abcd"를 return 합니다.

입출력 예 #3

• "hello"에서 한 번씩 등장한 문자는 "heo"이고 이를 사전 순으로 정렬한 "eho"를 return 합니다.

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

class Solution {
    public String solution(String s) {
        return Arrays.stream(s.split(""))
                .collect(Collectors.groupingBy(s1 -> s1))
                .entrySet()
                .stream()
                .filter(entry -> entry.getValue().size() <= 1)
                .map(Map.Entry::getKey)
                .sorted()
                .collect(Collectors.joining());
    }
}

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

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

        HashMap<Character, Integer> searchMap = new HashMap<>();

        for (int i = 0; i < s.length(); i++) {
            searchMap.putIfAbsent(s.charAt(i), 0);
            searchMap.put(s.charAt(i), searchMap.get(s.charAt(i)) + 1);
        }

        List<Character> once = new ArrayList<>();
        searchMap.forEach((key, value) -> {
            if (value == 1)
                once.add(key);
        });
        Collections.sort(once);
        for (Character ch : once) {
            answer.append(ch.toString());
        }

        return answer.toString();
    }
}

for문을 돌면서 계속 value값을 증가시키는 구조,

 

import java.util.*;

class Solution {
    public String solution(String s) {

        HashSet<String> set = new HashSet<>();

        for (int i = 0; i < s.length(); i++) {
            String replace = s.replace(s.charAt(i) + "", "");
            if(s.length() - replace.length() == 1){
                set.add(s.charAt(i)+"");
            }
        }
        ArrayList<String> list = new ArrayList<>(set);
        Collections.sort(list);
        return String.join("", list);
    }
}

replace를 활용하여 지우는데 1개만 지워지는것만 뽑아내기

class Solution {
    public String solution(String s) {
        int[] alpha = new int[26];
        for(char c : s.toCharArray()){
            alpha[c - 'a']++;
        }

        StringBuilder answer = new StringBuilder();
        for(int i = 0; i < 26; i++){
            if(alpha[i] == 1){
                answer.append((char)(i + 'a'));
            }
        }
        return answer.toString();
    }
}

알파벳배열을 만들어서 특정알파벳의 인덱스를 뽑아내서 처리

 

import java.util.*;
import java.util.stream.Collectors;

class Solution {
    public String solution(String s) {
        Map<String, Integer> countMap = new HashMap<>();

        for(String string : s.split("")) {
            countMap.merge(string, 1, Integer::sum);
        }

        List<String> onceString = new ArrayList<>();
        for(String key : countMap.keySet()) {
            if(countMap.get(key) == 1) {
                onceString.add(key);
            }
        }

        return onceString.stream()
                .sorted()
                .collect(Collectors.joining());       
    }
}

Map의 merge함수로 간단히 밸류값을 누적하여 더하였다.

 

 

import java.util.*;
class Solution {
    public String solution(String s) {
        String answer = "";

        Map<String, Integer> map = new HashMap<>();
        List<String> strList = new ArrayList<>();

        Arrays.stream(s.split("")).forEach(x -> map.put(x, map.getOrDefault(x, 0)+1));

        map.keySet().stream().filter(x -> map.get(x)==1).forEach(strList::add);
        Collections.sort(strList);

        for(String x : strList) answer+=x;

        return answer;
    }
}

Map을 스트림을 통하여 누적합계 시킴.

 

출처:프로그래머스