private static final String ENTER = "Enter";
private static final String LEAVE = "Leave";
private static final String CHANGE = "Change";

private static final String MESSAGE_ENTER = "님이 들어왔습니다.";
private static final String MESSAGE_LEAVE = "님이 나갔습니다.";

public String[] solution(String[] record) {
    List<String[]> list = new ArrayList<>();
    Map<String, String> nickName = new HashMap<>();

    int returnArraySize = 0;
    for (String s : record) {
        String[] split = s.split(" ");
        String[] actionAndUid = new String[3];

        actionAndUid[0] = split[0];
        actionAndUid[1] = split[1];

        if (!CHANGE.equals(split[0])) {
            list.add(actionAndUid);
            returnArraySize++;
        }

        if (!LEAVE.equals(split[0])) {
            nickName.put(split[1], split[2]);
        }
    }

    String[] answer = new String[returnArraySize];
    int i = 0;
    for (String[] array : list) {
        switch (array[0]) {
            case ENTER :
                answer[i] = nickName.get(array[1]) + MESSAGE_ENTER;
                break;
            case LEAVE :
                answer[i] = nickName.get(array[1]) + MESSAGE_LEAVE;
                break;
        }

        i++;
    }

    return answer;
}

String[] actual = {"Enter uid1234 Muzi", "Enter uid4567 Prodo","Leave uid1234","Enter uid1234 Prodo","Change uid4567 Ryan"};
String[] expected ={"Prodo님이 들어왔습니다.", "Ryan님이 들어왔습니다.", "Prodo님이 나갔습니다.", "Prodo님이 들어왔습니다."};
assertArrayEquals(expected, test.solution(actual));

public int[][] solution(int[][] arr1, int[][] arr2) {
    int[][] answer = new int[arr1.length][arr2[0].length];

    for (int i = 0; i < arr1.length; i++) {
        for(int j = 0; j < arr2[0].length; j++){
            for (int k = 0; k < arr2.length; k++) {
                answer[i][j] += arr1[i][k] * arr2[k][j];
            }
        }
    }

    return answer;
}

assertArrayEquals(new int[][] {{15, 15}, {15, 15}, {15, 15}}, test.solution(new int[][] {{1, 4}, {3, 2}, {4, 1}}, new int[][] {{3, 3}, {3, 3}}));
assertArrayEquals(new int[][] {{22, 22, 11}, {36, 28, 18}, {29, 20, 14}}, test.solution(new int[][] {{2, 3, 2}, {4, 2, 4}, {3, 1, 4}}, new int[][] {{5, 4, 3}, {2, 4, 1}, {3, 1, 1}}));

int solution(int[][] land) {
    for (int i = land.length - 2; i >= 0; i--) {
        int rowIndex = i + 1;
        land[i][0] += max(land[rowIndex][1], max(land[rowIndex][2], land[rowIndex][3]));
        land[i][1] += max(land[rowIndex][0], max(land[rowIndex][2], land[rowIndex][3]));
        land[i][2] += max(land[rowIndex][0], max(land[rowIndex][1], land[rowIndex][3]));
        land[i][3] += max(land[rowIndex][0], max(land[rowIndex][1], land[rowIndex][2]));
    }

    int answer = max(land[0][0], max(land[0][1], max(land[0][2], land[0][3])));
    return answer;
}

assertEquals(16, test.solution(new int[][] {{1,2,3,5},{5,6,7,8},{4,3,2,1}}));
assertEquals(20, test.solution(new int[][] {{4, 3, 2, 1}, {2, 2, 2, 1}, {6, 6, 6, 4}, {8, 7, 6, 5}}));
assertEquals(115, test.solution(new int[][] {{1, 2, 3, 5}, {5, 6, 7, 8}, {4, 3, 2, 1}, {100, 0, 9, 8}}));
assertEquals(33, test.solution(new int[][] {{1, 2, 3, 5}, {10, 11, 12, 11}, {16, 15, 13, 13}}));
assertEquals(409, test.solution(new int[][] {{1, 100, 15, 3}, {1, 2, 3, 4}, {100, 99, 98, 97}, {97, 98, 99, 100}, {4, 3, 2, 1}, {100, 100, 100, 100}, {1, 1, 1, 1}}));
assertEquals(16, test.solution(new int[][] {{1, 2, 3, 4}, {5, 6, 7, 9}, {4, 3, 2, 1}}));
assertEquals(125, test.solution(new int[][] {{9, 5, 2, 3}, {9, 8, 6, 7}, {8, 9, 7, 1}, {100, 9, 8, 1}}));
assertEquals(20, test.solution(new int[][] {{4, 3, 2, 1}, {2, 2, 2, 1}, {6, 6, 6, 4}, {8, 7, 6, 5}}));

private static final char PLUS = '+';
private static final char MINUS = '-';
private static final char MULTIPLICATION = '*';

public long solution(String expression) {
    char[] chars = expression.toCharArray();

    Object[] numberAndOperator = getNumbersAndOperatorSet(chars);
    List<Long> numberList = (List<Long>) numberAndOperator[0];
    List<Character> operatorList = (List<Character>) numberAndOperator[1];

    char[] operators = getExpressionIncludeOperators(operatorList);
    List<String> operatorSetList = getOperatorSetList(operators);

    return getMax(numberList, operatorList, operatorSetList);
}

private Object[] getNumbersAndOperatorSet(char[] expression) {
    List<Long> numberList = new ArrayList<>();
    List<Character> operatorList = new ArrayList<>();

    StringBuilder sb = new StringBuilder();
    for (char c : expression) {
        switch (c) {
            case PLUS:
            case MINUS:
            case MULTIPLICATION:
                numberList.add(Long.valueOf(sb.toString()));
                operatorList.add(c);

                sb.setLength(0);
                break;
            default:
                sb.append(c);
                break;
        }
    }

    numberList.add(Long.valueOf(sb.toString()));

    return new Object[] {numberList, operatorList};
}

private char[] getExpressionIncludeOperators(List<Character> operatorList) {
    Set<Character> set = new HashSet<>();
    List<Character> list = new ArrayList<>();

    for (char c : operatorList) {
        if (set.add(c)) {
            list.add(c);
        }
    }

    char[] operators = new char[list.size()];
    int i = 0;
    for (char c : list) {
        operators[i++] = c;
    }

    return operators;
}


private List<String> getOperatorSetList(char[] chars) {
    List<String> operatorSetList = new ArrayList<>();
    Set<String> set = new HashSet<>();

    for (int i = 1; i <= chars.length; i++) {
        perm(chars, 0, i, operatorSetList, set);
    }

    return operatorSetList;
}

private void perm(char[] array, int depth, int length, List<String> operatorList, Set<String> set) {
    if (depth == length) {

        StringBuilder sb = new StringBuilder();
        for (char c : array) {
            sb.append(c);
        }

        if (set.add(sb.toString())) {
            operatorList.add(sb.toString());
        }

        return;
    }

    for (int i = depth; i < array.length; i++) {
        swap(array, i, depth);
        perm(array, depth + 1, length, operatorList, set);
        swap(array, i, depth);
    }
}

private void swap(char[] arrary, int i, int j) {
    char temp = arrary[i];
    arrary[i] = arrary[j];
    arrary[j] = temp;
}

private Long getMax(List<Long> numberList, List<Character> operatorList, List<String> operatorSetList) {
    long max = 0;

    for (String operatorSet : operatorSetList) {
        char[] operators = operatorSet.toCharArray();

        LinkedList<Long> numberQueue = new LinkedList<>(numberList);
        LinkedList<Character> operatorQueue = new LinkedList<>(operatorList);

        for (char operatorToCalculate : operators) {
            Stack<Long> numberStack = new Stack<>();
            Stack<Character> operatorStack = new Stack<>();

            long first = numberQueue.poll();
            numberStack.push(first);
            numberQueue.offer(first);

            Stack[] stacks = new Stack[] {numberStack, operatorStack};
            LinkedList[] queues = new LinkedList[] {numberQueue, operatorQueue};

            calculatePriority(stacks, queues, operatorToCalculate);
        }

        max = (max > Math.abs(numberQueue.peek())) ? max : Math.abs(numberQueue.poll());
    }

    return max;
}

private void calculatePriority(Stack[] staks, LinkedList[] queues, char operatorToCalculate) {
    Stack<Long> numberStack = staks[0];
    Stack<Character> operatorStack = staks[1];

    LinkedList<Long> numberQueue = queues[0];
    LinkedList<Character> operatorQueue = queues[1];

    int limit = operatorQueue.size();
    for (int i = 0; i < limit; i++) {
        long currentNumber = numberQueue.poll();
        numberStack.push(currentNumber);

        Character currentOperator = operatorQueue.poll();
        operatorStack.push(currentOperator);

        if (operatorStack.peek() == operatorToCalculate) {
            long n1 = numberStack.pop();
            long n2 = numberStack.pop();
            char op = operatorStack.pop();

            long sum = sum(n2, n1, op);
            numberStack.push(sum);

            numberQueue.pollLast();
            numberQueue.offer(sum);
        } else {
            numberQueue.offer(currentNumber);
            operatorQueue.offer(currentOperator);
        }
    }
}

private Long sum(long n2, long n1, char op) {
    long sum = 0;

    switch (op) {
        case '*' :
            sum = n2 * n1;
            break;
        case '+' :
            sum = n2 + n1;
            break;
        case '-' :
            sum = n2 - n1;
            break;
    }

    return sum;
}

LinkedList<Long> numberQueue = new LinkedList<>(numberList);
LinkedList<Character> operatorQueue = new LinkedList<>(operatorList);

long first = numberQueue.poll();
numberStack.push(first);
numberQueue.offer(first);

for (int i = 0; i < limit; i++) {
    long currentNumber = numberQueue.poll();
    numberStack.push(currentNumber);

    Character currentOperator = operatorQueue.poll();
    operatorStack.push(currentOperator);

    if (operatorStack.peek() == operatorToCalculate) {
        long n1 = numberStack.pop();
        long n2 = numberStack.pop();
        char op = operatorStack.pop();

        long sum = sum(n2, n1, op);
        numberStack.push(sum);

        numberQueue.pollLast();
        numberQueue.offer(sum);
    } else {
        numberQueue.offer(currentNumber);
        operatorQueue.offer(currentOperator);
    }
}

assertEquals(60420, test.solution("100-200*300-500+20"));
assertEquals(300, test.solution("50*6-3*2"));

@ExtendWith(SpringExtension.class)
@DataJpaTest
@TestPropertySource("classpath:application-test.properties")
class WordRepositoryTest {
    ...
}

@BeforeEach
void setUp() {
    user = new User();
    user.setUsername("jgji");
    user.setPassword("qwe123");

    userRepository.save(this.user);

    user1 = new User();
    user.setUsername("haha");
    user.setPassword("qwe123");

    userRepository.save(this.user1);

    List<Word> givenWordList = getWordGiven();
    this.word = givenWordList.get(0);
    this.word1 = givenWordList.get(1);
}

public int[] solution(String s) {
    String[] strArray = getStringArray(s);
    List<Integer[]> list = convertStringArrayToIntegerArrayList(strArray);
    sortByArraylength(list);

    List<Integer> tuple = getTuple(list);
    int[] answer = convertIntegerArrayToIntArray(tuple);

    return answer;
}

private String[] getStringArray(String s) {
    String[] array = s.substring(2, s.length()-2).replace("},{", "@").split("@");

    return array;
}

private List<Integer[]> convertStringArrayToIntegerArrayList(String[] strArray) {
    List<Integer[]> list = new ArrayList<>();
    for (String str : strArray) {
        String[] stringNumbers = str.split(",");
        Integer[] array = convertStringArrayToIntegerArray(stringNumbers);

        list.add(array);
    }

    return list;
}

private Integer[] convertStringArrayToIntegerArray(String[] stringNumbers) {
    Integer[] array = new Integer[stringNumbers.length];
    int i = 0;
    for (String str2 : stringNumbers) {
        array[i++] = Integer.parseInt(str2);
    }

    return array;
}

private void sortByArraylength(List<Integer[]> list) {
    Collections.sort(list, new Comparator<Integer[]>() {
        @Override
        public int compare(Integer[] o1, Integer[] o2) {
            return o1.length - o2.length;
        }
    });
}

private List<Integer> getTuple(List<Integer[]> list) {
    List<Integer> tuple = new ArrayList<>();

    for (int i = 0; i < list.size(); i++) {
        Integer[] elements = list.get(i);

        for (Integer element : elements) {
            if (!tuple.contains(element)) {
                tuple.add(element);
            }
        }
    }

    return tuple;
}

private int[] convertIntegerArrayToIntArray(List<Integer> list) {
    int[] answer = new int[list.size()];
    int j = 0;
    for (int i : list) {
        answer[j++] = i;
    }

    return answer;
}

public int[] solution(String s) {
    Set<String> set = new HashSet<>();
    String[] arr = s.replaceAll("[{]", " ").replaceAll("[}]", " ").trim().split(" , ");
    Arrays.sort(arr, (a, b)->{return a.length() - b.length();});
    int[] answer = new int[arr.length];
    int idx = 0;
    for(String s1 : arr) {
        for(String s2 : s1.split(",")) {
            if(set.add(s2)) answer[idx++] = Integer.parseInt(s2);
        }
    }
    return answer;
}

assertArrayEquals(new int[]{2,1,3,4}, test.solution("{{2},{2,1},{2,1,3},{2,1,3,4}}"));
assertArrayEquals(new int[]{2,1,3,4}, test.solution("{{1,2,3},{2,1},{1,2,4,3},{2}}"));
assertArrayEquals(new int[]{111,20}, test.solution("{{20,111},{111}}"));
assertArrayEquals(new int[]{123}, test.solution("{{123}}"));
assertArrayEquals(new int[]{3,2,4,1}, test.solution("{{4,2,3},{3},{2,3,4,1},{2,3}}"));
assertArrayEquals(new int[]{3,2,4,1,100}, test.solution("{{4,2,3},{3},{2,3,4,1},{2,3},{2,3,4,1,100}}"));
assertArrayEquals(new int[]{3,2,4,1,100}, test.solution("{{4,2,3},{3},{2,3,4,1},{2,3},{2,3,4,1,100}}"));

public int solution(int n) {
    int answer = 0;
    int[] sumArray = new int[n + 1];

    Queue<Integer> queue = initQueue(n);

    int sum = 0;
    for (int i = 1; i < n + 1; i++) {
        sum += i;
        sumArray[i] = sum;

        if (sum == n) {
            ++answer;

            int nextValue = i+1;

            while (!queue.isEmpty()) {
                int sumValue = sumArray[queue.peek()];

                if (nextValue <= sumValue) {
                    i = queue.peek();
                    sum = 0;
                    break;
                }

                queue.poll();
            }
        } else if (sum > n) {
            int value = sum - n;

            while (!queue.isEmpty()) {
                int sumValue = sumArray[queue.peek()];

                if (value <= sumValue) {
                    i = queue.poll();
                    sum = 0;
                    break;
                }

                queue.poll();
            }
        }
    }

    return answer;
}

public int solution(int n) {
    int answer = 0;

    for(int i = 1; i <= (n / 2) ; i++) {
        int sum = 0;
        int index = i;

        while (sum < n) {
            sum += index;
            ++index;
        }

        if (sum == n) {
            ++answer;
        }
    }

    return answer + 1;
}

assertEquals(4, test.solution(15));
assertEquals(2, test.solution(20));
assertEquals(4, test.solution(30));
assertEquals(2, test.solution(106));
assertEquals(2, test.solution(1567));
assertEquals(1, test.solution(16));
assertEquals(4, test.solution(782));
assertEquals(5, test.solution(10000));
assertEquals(12, test.solution(9999));
assertEquals(4, test.solution(7787));
assertEquals(8, test.solution(4578));
assertEquals(2, test.solution(1234));
assertEquals(1, test.solution(1));
assertEquals(2, test.solution(5));
assertEquals(3, test.solution(49));

private static final int DIVIDE_NUMBER = 1234567;

public int solution(int n) {
    int[] cache = new int[n+1];

    cache[1] = 1;

    for (int i = 2; i < n+1; i++) {
        cache[i] = ((cache[i-1]) % DIVIDE_NUMBER + (cache[i-2]) % DIVIDE_NUMBER) % DIVIDE_NUMBER;
    }

    int answer = cache[n];
    return answer;
}

assertEquals(2, test.solution(3));
assertEquals(5, test.solution(5));
assertEquals(987, test.solution(16));
assertEquals(256379, test.solution(1234156));
assertEquals(473509, test.solution(100001));
assertEquals(1168141, test.solution(100000));
assertEquals(547662, test.solution(124126347));

public int solution(String[][] relation) {

    int columnCount = relation[0].length;
    int rowCount = relation.length;

    List<Integer> list = new ArrayList<Integer>();
    for (int i = 1; i < (1 << columnCount); i++) {
        if (!isUniqueness(relation, i, columnCount, rowCount)) {
            continue;
        }

        if (!isMinimality(i, list)) {
            continue;
        }

        list.add(i);
    }

    return list.size();
}

private boolean isUniqueness(String[][] relation, int set, int columnCount, int rowCount) {
    ArrayList<Integer> columnIndexList = getColumnIndex(set, columnCount);

    HashSet<String> hashSet = new HashSet<>();
    for (int row = 0; row < rowCount; row++) {
        StringBuilder sb = new StringBuilder();

        for (int column : columnIndexList) {
            sb.append(relation[row][column]);
        }

        hashSet.add(sb.toString());
    }

    return hashSet.size() == rowCount;
}

private ArrayList<Integer> getColumnIndex(int set, int colSize) {
    ArrayList<Integer> result = new ArrayList<>();
    for (int i = 0; i < colSize; i++) {
        if (((set >> i) & 1) == 1) {
            result.add(i);
        }
    }

    return result;
}

private boolean isMinimality(int set, List<Integer> list) {
    boolean isMinimality = true;

    for (int i : list) {
        if ((set & i) == i) {
            isMinimality = false;
            break;
        }
    }

    return isMinimality;
}

for (int i = 1; i < (1 << columnCount); i++) {
    ...
}

private ArrayList<Integer> getColumnIndex(int set, int colSize) {
    ArrayList<Integer> result = new ArrayList<>();
    for (int i = 0; i < colSize; i++) {
        if (((set >> i) & 1) == 1) {
            result.add(i);
        }
    }

    return result;
}

private boolean isUniqueness(String[][] relation, int set, int columnCount, int rowCount) {
    ArrayList<Integer> columnIndexList = getColumnIndex(set, columnCount);

    HashSet<String> hashSet = new HashSet<>();
    for (int row = 0; row < rowCount; row++) {
        StringBuilder sb = new StringBuilder();

        for (int column : columnIndexList) {
            sb.append(relation[row][column]);
        }

        hashSet.add(sb.toString());
    }

    return hashSet.size() == rowCount;
}

private boolean isMinimality(int set, List<Integer> list) {
    boolean isMinimality = true;

    for (int i : list) {
        if ((set & i) == i) {
            isMinimality = false;
            break;
        }
    }

    return isMinimality;
}

String[][] args = new String[][] {{"100","ryan","music","2"},{"200","apeach","math","2"},{"300","tube","computer","3"},{"400","con","computer","4"},{"500","muzi","music","3"},{"600","apeach","music","2"}};
assertEquals(2, test.solution(args));

String[][] args1 = new String[][] {
        {"4", "4", "사랑", "2020-07-03 오전 12:00:00", "love"}
        , {"5", "4", "같은, 좋은, 와 비슷한", "2020-07-03 오전 12:00:00", "like"}
        , {"6", "4", "사과,대도시", "2020-07-03 오전 12:00:00", "apple"}
        , {"7", "4", "빌다,기도하다,에게 간청하다", "2020-07-03 오전 12:00:00", "pray"}
        , {"8", "3", "빌다,기도하다,에게 간청하다", "2020-06-27 오전 12:00:00", "pray"}
        , {"9", "4", "안녕", "2020-07-03 오전 12:00:00", "hi"}
        , {"10", "3", "같은, 좋은", "2020-06-29 오전 12:00:00", "like"}
        , {"11", "2", "나는 모자를 벗는다", "2020-06-27 오전 12:00:00", "I take off my hat"}};

assertEquals(5, test.solution(args1));

String[][] args2 = new String[][] {
        {"4", "4", "사랑", "2020-07-03 오전 12:00:00", "love"}
        , {"5", "4", "같은, 좋은, 와 비슷한", "2020-07-03 오전 12:00:00", "like"}
        , {"6", "4", "사과,대도시", "2020-07-03 오전 12:00:00", "apple"}
        , {"7", "4", "빌다,기도하다,에게 간청하다", "2020-07-03 오전 12:00:00", "pray"}
        , {"8", "4", "빌다,기도하다,에게 간청하다", "2020-06-27 오전 12:00:00", "pray"}
        , {"9", "4", "안녕", "2020-07-03 오전 12:00:00", "hi"}
        , {"10", "3", "같은, 좋은", "2020-06-29 오전 12:00:00", "like"}
        , {"11", "2", "나는 모자를 벗는다", "2020-06-27 오전 12:00:00", "I take off my hat"}};

assertEquals(3, test.solution(args2));

private static final int PEOPLE_COUNT = 8;
private static final String[] PEOPLE_NAMES = {"A", "C", "F", "J", "M", "N", "R", "T"};

private static int answer;
public int solution(int n, String[] data) {
    answer = 0;
    perm("", 0, new boolean[8], data);

    return this.answer;
}

private void perm(String perm, int depth, boolean[] isVisit, String[] data) {
    if (depth == PEOPLE_COUNT) {

        if (isCondition(perm, data)) {
            answer++;
        }
    }

    for (int i = 0; i < PEOPLE_COUNT; i++) {
        if (!isVisit[i]) {
            isVisit[i] = true;
            perm(perm + PEOPLE_NAMES[i], depth + 1, isVisit, data);
            isVisit[i] = false;
        }
    }
}

private boolean isCondition(String perm, String[] data) {
    boolean isCondition = true;

    for (int i = 0; i < data.length; i++) {
        char[] tochar = data[i].toCharArray();
        int people1 = perm.indexOf(tochar[0]);
        int people2 = perm.indexOf(tochar[2]);

        int interval = people1 > people2 ? people1 - people2 - 1 : people2 - people1 - 1;

        int requestInterval = tochar[4] - '0';
        if (tochar[3] == '=' && interval != requestInterval) {
            isCondition = false;
            break;
        }

        if (tochar[3] == '<' && interval >= requestInterval) {
            isCondition = false;
            break;
        }

        if (tochar[3] == '>' && interval <= requestInterval) {
            isCondition = false;
            break;
        }
    }

    return isCondition;
}

for (int i = 0; i < PEOPLE_COUNT; i++) {
    if (!isVisit[i]) {
        isVisit[i] = true;
        perm(perm + PEOPLE_NAMES[i], depth + 1, isVisit, data);
        isVisit[i] = false;
    }
}

assertEquals(3648, test.solution(2, new String[] {"N~F=0", "R~T>2"}));
assertEquals(0, test.solution(2, new String[] {"M~C<2", "C~M>1"}));