public int solution(String[][] clothes) {
    Map<String, Integer> map = new HashMap<String, Integer>();

    for (String[] s : clothes) {
        int value = 1;
        String key = s[1];
        if (map.containsKey(key)) {
            value = map.get(key);
        }

        map.put(key, ++value);
    }

    int answer = 1;
    for (Map.Entry<String, Integer> entry : map.entrySet()) {
        answer *= entry.getValue();
    }

    return answer - 1;
}

public int solution(String[][] clothes) {
    return Arrays.stream(clothes)
            .collect(groupingBy(p -> p[1], mapping(p -> p[0], counting())))
            .values()
            .stream()
            .collect(reducing(1L, (x, y) -> x * (y + 1))).intValue() - 1;
}

assertEquals(5, test.solution(new String[][] {{"yellow_hat", "headgear"}, {"blue_sunglasses", "eyewear"}, {"green_turban", "headgear"}}));
assertEquals(3, test.solution(new String[][] {{"crow_mask", "face"}, {"blue_sunglasses", "face"}, {"green_turban", "face"}}));

public void upgardeLevels() {
   트랜잭션 스타트();

   주입받은 userService를 구현한 오브젝트(Impl).upgrardeLevels();

   commit() or rollback();
}

public boolean solution(String[] phone_book) {
    int length = phone_book.length;

    for (int i = 0; i < length; i++) {
        for (int j = 0; j < length; j++) {
            if (i == j) {
                continue;
            }

            if (phone_book[j].startsWith(phone_book[i])) {
                return false;
            }
        }
    }
    boolean answer = true;
    return answer;
}

assertFalse(test.solution(new String[] {"119", "97674223", "1195524421"} ));
assertTrue(test.solution(new String[] {"123","456","789"} ));
assertFalse(test.solution(new String[] {"12","123","1235","567","88"} ));

public int solution(int[] citations) {
    int answer = 0;
    int n = citations.length;

    Arrays.sort(citations);

    for (int i = 0; i <= citations[n - 1]; i++) {
        int high = 0;

        for (int j = 0; j < n; j++) {
            if (i <= citations[j]) {
                high++;
            }

            if (i <= high) {
                answer = i;
            }
        }
    }

    return answer;
}

public int solution(int[] citations) {
    Arrays.sort(citations);

    int max = 0;
    for(int i = citations.length-1; i > -1; i--){
        int min = (int)Math.min(citations[i], citations.length - i);
        if(max < min) max = min;
    }

    return max;
}

assertEquals(3, test.solution(new int[] {3,0,6,1,5}));
assertEquals(3, test.solution(new int[] {6,5,4,3,1,1,1,1,1}));
assertEquals(3, test.solution(new int[] {0, 1, 1, 1, 1, 3, 3, 4}));
assertEquals(3, test.solution(new int[] {5, 5, 5, 0}));
assertEquals(2, test.solution(new int[] {2,2,2,2,2}));
assertEquals(4, test.solution(new int[] {5, 5, 5, 5}));
assertEquals(5, test.solution(new int[] {5, 5, 5, 5, 5}));
assertEquals(1, test.solution(new int[] {7}));
assertEquals(3, test.solution(new int[] {4, 3, 3, 3, 3}));
assertEquals(0, test.solution(new int[] {0,0,0,0,0,0}));
assertEquals(3, test.solution(new int[] {6, 5, 3, 1, 0}));

public String solution(int[] numbers) {

    List<Numbers> list = new ArrayList<Numbers>();
    for (int i = 0; i < numbers.length; i++) {
        int number = numbers[i];

        char[] str = String.valueOf(number).toCharArray();
        StringBuilder fourDigitString = new StringBuilder();

        fourDigitString.append(str);
        if (str.length < 4) {

            for (int j = 0; j < 4 - str.length; j++) {
                fourDigitString.append(str[((j) % str.length)]);
            }
        }

        list.add(new Numbers(i, Integer.parseInt(fourDigitString.toString())));
    }

    Collections.sort(list, new Comparator<Numbers>() {

        @Override
        public int compare(Numbers o1, Numbers o2) {
            return o2.value.compareTo(o1.value);
        }
    });

    StringBuilder sb = new StringBuilder();
    int sum = 0;
    for (Numbers n : list) {
        sum += n.value;
        sb.append(numbers[n.postion]);
    }

    if (sum == 0) {
        sb.setLength(0);
        sb.append(0);
    }

    return sb.toString();
}

class Numbers {
    public Integer postion;
    public Integer value;

    public Numbers(Integer postion, Integer value) {
        this.postion = postion;
        this.value = value;
    }
}

public String solution(int[] numbers) {
    String answer = "";

    List<Integer> list = new ArrayList<>();
    for(int i = 0; i < numbers.length; i++) {
        list.add(numbers[i]);
    }
    Collections.sort(list, (a, b) -> {
        String as = String.valueOf(a), bs = String.valueOf(b);
        return -Integer.compare(Integer.parseInt(as + bs), Integer.parseInt(bs + as));
    });
    StringBuilder sb = new StringBuilder();
    for(Integer i : list) {
        sb.append(i);
    }
    answer = sb.toString();
    if(answer.charAt(0) == '0') {
        return "0";
    }else {
        return answer;
    }
}

assertEquals("6210", test.solution(new int[] {6, 10, 2}));
assertEquals("9534330", test.solution(new int[] {3, 30, 34, 5, 9}));
assertEquals("220200", test.solution(new int[] {2,200,20}));
assertEquals("2200", test.solution(new int[] {2,0,20}));
assertEquals("0", test.solution(new int[] {0,0,0}));
assertEquals("21212", test.solution(new int[] {12, 212}));
assertEquals("21221", test.solution(new int[] {212, 21}));
assertEquals("7000", test.solution(new int[] {0, 0, 70}));
assertEquals("1000000", test.solution(new int[] {0, 0, 0, 1000}));

There was an unexpected error (type=Unsupported Media Type, status=415).
Content type 'application/x-www-form-urlencoded;charset=UTF-8' not supported
org.springframework.web.HttpMediaTypeNotSupportedException: Content type 'application/x-www-form-urlencoded;charset=UTF-8' not supported
 at org.springframework.web.servlet.mvc.method.annotation.AbstractMessageConverterMethodArgumentResolver.readWithMessageConverters(AbstractMessageConverterMethodArgumentResolver.java:225)
 at org.springframework.web.servlet.mvc.method.annotation.RequestResponseBodyMethodProcessor.readWithMessageConverters(RequestResponseBodyMethodProcessor.java:158)
 at org.springframework.web.servlet.mvc.method.annotation.RequestResponseBodyMethodProcessor.resolveArgument(RequestResponseBodyMethodProcessor.java:131)
 at org.springframework.web.method.support.
    HandlerMethodArgumentResolverComposite.resolveArgument(HandlerMethodArgumentResolverComposite.java:121)
 at org.springframework.web.method.support.InvocableHandlerMethod.getMethodArgumentValues(InvocableHandlerMethod.java:167)
...

@PostMapping(value="/reset/password", produces = "application/json")
@ResponseBody
public String processResetPasswordForm(@RequestBody User user) throws JsonProcessingException {
    String tempPassword = userService.setTempPassWord(user);
    String msg = "임시 비밀번호 : " + tempPassword;

    System.out.println(msg);
    ObjectMapper objMapper = getObjectMapperConfig();
    return objMapper.writeValueAsString(msg);
}

public int solution(String s) {
    int stringLength = s.length();

    StringBuilder result = new StringBuilder();
    String origin = new String();
    char[] tochar = s.toCharArray();
    int min = Integer.MAX_VALUE;

    for (int i = 1; i <= stringLength / 2; i++) {
        int compression = 1;
        result.setLength(0);
        origin = new String(tochar, 0, i);

        String nextWord = new String();
        for (int j = i; j < stringLength; j+=i) {
            if (j + i > stringLength) {
                nextWord = s.substring(j, stringLength);
            } else {
                nextWord = new String(tochar, j , i);
            }

            if (origin.equals(nextWord)) {
                ++compression;
            } else {
                if (compression != 1) {
                    result.append(compression);
                }

                result.append(origin);

                origin = nextWord.toString();
                compression = 1;
            }
        }

        if (compression != 1) {
            result.append(compression);
        }

        result.append(origin);

        if (min > result.length()) {
            min = result.length();
        }
    }

    int answer = min > stringLength ? stringLength : min;
    return answer;

assertEquals(7, test.solution("aabbaccc"));
assertEquals(9, test.solution("ababcdcdababcdcd"));
assertEquals(8, test.solution("abcabcdede"));
assertEquals(14, test.solution("abcabcabcabcdededededede"));
assertEquals(17, test.solution("xababcdcdababcdcd"));
assertEquals(1, test.solution("a"));
assertEquals(2, test.solution("aaaaa"));
assertEquals(3, test.solution("aaaaaaaaaa"));