그냥 코딩하는 사람의 블로그

https://programmers.co.kr/learn/courses/30/lessons/42746?language=java 

풀이 과정

1. 핵심은 정렬하기 전에 숫자를 반복해서 4자리로 맞추어주는 것이다. 맞추어주지 않고 정렬한다면 값 자체로 큰 값 순서대로 정렬이 되기 때문이다.
   • 1 -> 1111, 2 -> 2222, 10 -> 1010, ...
2. 따라서, 반복해서 만들어 준 숫자, 실제 숫자를 저장하는 클래스를 만들어 준 다음, 입력받은 numbers의 값들을 클래스로 매핑해서 리스트로 저장한다.
3. 다음으로 반복해서 만들어 준 숫자 기준으로 내림차순 정렬한다.
4. 정렬된 리스트를 기준으로, 하나씩 실제 숫자를 꺼내서 정답 문자열에 붙여준다. 단, 이 때 맨 앞자리가 0인 경우는 0을 출력시켜 주면 된다.
   1. 0이 3번 나온 경우 000 리턴이 아닌 0 리턴임에 유의!!

소스 코드

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

class Element {
    int value;
    int realValue;

    public Element(int realValue, int value) {
        this.realValue = realValue;
        this.value = value;
    }
}

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

        List<Element> elementList = Arrays.stream(numbers)
                .mapToObj(n -> {
                    String numStr = Integer.toString(n);
                    int idx = 0;
                    int value = 0;
                    while (idx < 4) {
                        value *= 10;
                        value += (Character.digit(numStr.charAt((idx++) % numStr.length()), 10));
                    }
                    return new Element(n, value);
                })
                .collect(Collectors.toList());

        elementList.sort((p1, p2) -> {
            return -Integer.compare(p1.value, p2.value);
        });

        for (Element e : elementList) {
            answer += e.realValue;
        }

        if (answer.charAt(0) == '0')
            return "0";
        return answer;
    }
}

https://programmers.co.kr/learn/courses/30/lessons/64065?language=java 

풀이 과정

1. 우선 주어진 문자열의 양쪽 중괄호를 제거한다.
2. 정규 표현식을 사용하여 {} 내부의 값들로만 이루어진 Set 리스트를 만들어 준다.
   1. "{" 나 "}" 를 정규 표현식을 사용하여 표시하기 위해서는 "\\{", "\\}"로 표시해주면 된다.
   2. 정규 표현식으로 괄호를 포함한 문자열을 추출했다면, 괄호를 제거한 다음 "," 를 기준으로 split 해준 다음 Set을 만들어준다.
3. Set 리스트를 길이 순으로 오름차순 정렬한다.
4. 튜플을 구해준다.
   1. 남아있는 집합중 길이가 가장 짧은 Set을 가져온 다음, 여지껏 방문했던 집합을 빼준다.
   2. 빼주게 되면, 하나의 요소가 남는데 해당 요소가 튜플의 요소이므로 튜플에 추가한다.

소스 코드

import java.util.*;
import java.util.regex.Matcher;
import java.util.regex.Pattern;

class Solution {

    public ArrayList<String> extractSetList(String s) {
        String regex = "\\{[0-9|,]+\\}";
        Pattern pattern = Pattern.compile(regex);
        Matcher matcher = pattern.matcher(s);
        String target = s.substring(1, s.length()-1);
        ArrayList<String> setList = new ArrayList<String>();
        while (matcher.find()) {
            setList.add(matcher.group());
        }
        return setList;
    }

    public Set<String>[] extract(String s) {
        ArrayList<String> setList = extractSetList(s);
        return setList.stream()
                .map(p -> {
                    p = p.substring(1, p.length()-1);
                    String[] setInformation = p.split(",");
                    return new HashSet(Arrays.asList(setInformation));
                })
                .toArray(i -> new HashSet[i]);
    }

    public int[] solution(String s) {
        List<String> answer = new ArrayList<String>();
        Set<String> currentSet = new HashSet<>();

        Set<String>[] sets = extract(s);

        Arrays.sort(sets, (p1, p2) -> {
           return Integer.compare(p1.size(), p2.size());
        });

        for (Set<String> targetSet : sets) {
            targetSet.removeAll(currentSet);
            String targetElement = targetSet.iterator().next();
            answer.add(targetElement);
            currentSet.addAll(targetSet);
        }

        return answer.stream()
                .mapToInt(i -> Integer.parseInt(i))
                .toArray();
    }


}

https://programmers.co.kr/learn/courses/30/lessons/12973?language=java 

풀이 과정

1. Java에서는 Python과 다르게 문자열 다루기가 조금 난해한거 같다..ㅜ
   1. 문자열의 toCharArray 메서드를 사용하거나 아니면 int[] 배열 형식으로 문자들을 처리하는 방식이 가장 좋아보이는 것 같음.
2. 문제의 내용을 살펴보면, 두가지 과정을 반복해서 진행하면 된다.
   1. 스택의 맨 위의 값이 이번에 넣으려는 문자와 같다면, 스택에 있는 값을 빼주고 다음 문자로 넘어감.
   2. 스택의 맨 위 값과 이번에 넣으려는 문자와 다르면, 그냥 스택에 문자를 넣어준다.
3. 마지막으로, 스택이 비어있는지 여부를 확인한 다음 스택이 비어있다면 1, 비어있지 않다면 0을 출력한다.

소스 코드

import java.util.Stack;

class Solution
{
    public int solution(String s)
    {
        Stack<Integer> stack = new Stack<>();
        int[] targetChars = s.chars()
                .map(i -> i - '0')
                .toArray();

        for (int ch : targetChars) {
            if (!stack.isEmpty() && stack.peek() == ch) {
                stack.pop();
                continue;
            }
            stack.add(ch);
        }

        if (stack.isEmpty()) {
            return 1;
        }
        return 0;
    }
}

https://programmers.co.kr/learn/courses/30/lessons/1832

풀이 과정

1. 4방향 모두 이동가능 하다면 DP로 풀이할 수 없지만 문제에서 오른쪽과 아래로만 이동 가능하다고 하였으므로 DP로 풀이 가능
2. 좌회전 / 우회전 금지가 없는 경우의 DP 점화식은 다음과 같다.
   1. DP[i][j] = DP[i][j-1] + DP[i-1][j]
3. 좌회전 / 우회전 금지가 존재하므로 해당 부분은 따로 처리해주어야 한다.
   1. 연속적으로 푯말이 있는 경우가 있으므로 해당 경우는 따로 처리해주어야 한다. 
   2. [i][j-1]에 금지 푯말이 있는 경우는 금지 푯말이 없을때까지 왼쪽으로 올라가보아야 함
   3. [i-1][j]에 금지 푯말이 있는 경우는 금지 푯말이 없을때까지 위로 올라가보아야 함
4. 경우의 수가 커질수도 있으므로 매순간 값을 구해준 다음 20170805의 나머지를 구해준다.
5. dp[m-1][n-1]을 리턴시켜 준다.

소스 코드

class Solution {
    int MOD = 20170805;

    public void calculateRowCell(int i, int j, int[][] cityMap, int[][] dp) {
        if (cityMap[i-1][j] == 2) {
            int dest = i-2;
            while (dest >= 0 && cityMap[dest][j] == 2)
                dest -= 1;
            if (dest >= 0)
                dp[i][j] += dp[dest][j];

        } else {
            dp[i][j] += dp[i-1][j];
        }
    }

    public void calculateColCell(int i, int j, int[][] cityMap, int[][] dp) {
        if (cityMap[i][j-1] == 2) {
            int dest = j-2;
            while (dest >= 0 && cityMap[i][dest] == 2)
                dest -= 1;
            if (dest >= 0)
                dp[i][j] += dp[i][dest];
        } else {
            dp[i][j] += dp[i][j - 1];
        }
    }

    public int solution(int m, int n, int[][] cityMap) {
        int answer = 0;
        int dp[][] = new int[m][n];
        dp[0][0] = 1;

        for (int i = 0; i < m; i++) {
            for (int j = 0; j < n; j++) {
                if (cityMap[i][j] == 1)
                    continue;
                if (i-1 >= 0) {
                    calculateRowCell(i, j, cityMap, dp);
                }
                if (j-1 >= 0) {
                    calculateColCell(i, j, cityMap, dp);
                }
                dp[i][j] %= MOD;
            }
        }
        answer = dp[m-1][n-1];
        return answer;
    }
}

https://programmers.co.kr/learn/courses/30/lessons/1835

풀이 과정

Python을 사용할 수 없어 Java로 풀이함!!

1. 주어진 data을 각각 인원1, 인원2, 연산, 거리 형식의 Op 클래스로 치환한다.
2. Op 클래스에서는 거리가 주어졌을 때, 연산 결과가 반환되는 operate 메소드를 만들어 둔다.
3. 최대 인원수가 8명이므로 가능한 모든 순열을 Recursion으로 만들어 준다.
   
   1. Set 자료구조로는 현재 순열에 어떤 인원이 포함되어 있는지 체크
   2. Map 자료구조로는 현재 인원의 위치를 저장
   3. 이후 Op 클래스의 operate 메소드를 호출할 때 Map 자료구조를 넘겨줌으로써 빠르게 거리계산이 가능하도록 한다.
4. 각각의 순열에 대해서 모든 Op클래스의 operate 메소드가 True가 나온다면 카운팅 해주고, 하나라도 False가 나온다면 카운팅 해주지 않는다.
5. 카운팅 개수를 리턴해주면 끝

소스 코드

import java.util.HashSet;
import java.util.HashMap;
import java.util.Arrays;

class Op{
    private char from;
    private char to;
    private char operation;
    private int dist;

    public Op(String data) {
        this.from = data.charAt(0);
        this.to = data.charAt(2);
        this.operation = data.charAt(3);
        this.dist = data.charAt(4) - '0';
    }
    
    public void print() {
         System.out.println(this.from + "//" + this.to);
    }

    public boolean execute(HashMap<Character, Integer> pos) {
        int distance = Math.abs(pos.get(from) - pos.get(to)) - 1;
        if (operation == '=') {
            return distance == dist;
        }
        if (operation == '>') {
            return distance > dist;
        }
        if (operation == '<') {
            return distance < dist;
        }
        return false;
    }
}

class Solution {
    private HashMap<Character, Integer> characterPos = new HashMap<>();
    private HashSet<Character> character = new HashSet<>();
    private static final Character[] CHARACTER = {'A', 'C', 'F', 'J', 'M', 'N', 'R', 'T'};
    private int caseCount = 0;
    private Op[] operations;

    public void solve(int index) {
        if (index == 9) {
            if (check(characterPos)) {
                caseCount++;
            }
            return;
        }

        for (int i = 0; i < CHARACTER.length; i++) {
            if (!character.contains(CHARACTER[i])) {
                character.add(CHARACTER[i]);
                characterPos.put(CHARACTER[i], index);
                solve(index + 1);
                character.remove(CHARACTER[i]);
            }
        }
    }

    public boolean check(HashMap<Character, Integer> pos) {
        for (Op operation : operations) {
            if (!operation.execute(pos)) {
                return false;
            }
        }
        return true;
    }

    public int solution(int n, String[] data) {
        operations = Arrays.stream(data)
                .map(op -> new Op(op))
                .toArray(size -> new Op[size]);
        solve(1);
        return caseCount;
    }
}