private static final int ASCII = 32;
private static final char EMPTY = ' ';

public int solution(int m, int n, String[] board) {
    int answer = 0;
    char[][] charBoard = convertStringArrayToCharArray(m, n, board);

    while (true) {
        boolean isEnd = box(charBoard);

        if (isEnd) {
            break;
        }

        answer += delete(charBoard);
    }

    return answer;
}

public char[][] convertStringArrayToCharArray(int m, int n, String[] board) {
    char[][] charBoard = new char[m][n];

    int i = 0;
    for (String str : board) {
        char[] toChar = str.toCharArray();
        charBoard[i] = toChar;
        ++i;
    }

    return charBoard;
}

public char toLowerCase(char value) {
    return (char) ((value >= 65 && value <= 90) ? (value + ASCII) : value);
}

public boolean box(char[][] charBoard) {
    boolean isEnd = true;

    for (int i = 0; i < charBoard.length; i++) {
        for (int j = 0; j < charBoard[i].length; j++) {
            if (validation(i, j, charBoard)) {
                char value = toLowerCase(charBoard[i][j]);
                charBoard[i][j] = value;
                charBoard[i][j+1] = value;
                charBoard[i+1][j] = value;
                charBoard[i+1][j+1] = value;

                isEnd = false;
            }
        }
    }

    return isEnd;
}

private boolean validation(int i, int j, char[][] charBoard) {
    if ((i + 1) == charBoard.length || (j + 1) == charBoard[0].length) {
        return false;
    }
    char position = toLowerCase(charBoard[i][j]);

    if (position == EMPTY) {
        return false;
    }

    char moveX = toLowerCase(charBoard[i][j+1]);
    char moveY = toLowerCase(charBoard[i+1][j]);
    char moveXY = toLowerCase(charBoard[i+1][j+1]);

    if (position != moveX) {
        return false;
    }

    if (position != moveY) {
        return false;
    }

    if (position != moveXY) {
        return false;
    }

    return true;
}

private int delete(char[][] charBoard) {
    int answer = 0;

    for (int i = 0; i < charBoard.length; i++) {
        for (int j = 0; j < charBoard[i].length; j++) {
            if (charBoard[i][j] == EMPTY) {
                continue;
            }

            if (charBoard[i][j] >= 97 && charBoard[i][j] <= 122) {
                if (i != 0) {
                    for (int k = i; k > 0; k--) {
                        charBoard[k][j] = charBoard[k-1][j];
                        charBoard[k-1][j] = EMPTY;
                    }
                } else {
                    charBoard[i][j] = EMPTY;
                }

                ++answer;
            }
        }
    }

    return answer;
}

assertEquals(14, test.solution(4,5, new String[] {"CCBDE", "AAADE", "AAABF", "CCBBF"}));
assertEquals(15, test.solution(6,6, new String[] {"TTTANT", "RRFACC", "RRRFCC", "TRRRAA", "TTMMMF", "TMMTTJ"}));
assertEquals(14, test.solution(4,5, new String[] {"AAAAA","AUUUA","AUUAA","AAAAA"}));
assertEquals(4, test.solution(2,2, new String[] {"AA","AA"}));
assertEquals(0, test.solution(2,2, new String[] {"AA","AB"}));
assertEquals(4, test.solution(3,2, new String[] {"AA","AA", "AB"}));
assertEquals(8, test.solution(4,2, new String[] {"CC","AA", "AA", "CC"}));
assertEquals(12, test.solution(6,2, new String[] {"DD", "CC", "AA", "AA", "CC", "DD"}));
assertEquals(8, test.solution(8,2, new String[] {"FF", "AA", "CC", "AA", "AA", "CC", "DD", "FF"}));
assertEquals(8, test.solution(6,2, new String[] {"AA", "AA", "CC", "AA", "AA", "DD"}));
assertEquals(8, test.solution(4,4, new String[] {"ABCD", "BACE", "BCDD", "BCDD"}));
assertEquals(27, test.solution(8,9, new String[] {"ABCDADFDA", "ABDFQWERF", "WKDNFNRIT", "AKAKWODCJ", "AKAKWODCJ", "KKKKKKKKK", "KKKKKKKKK", "KKKKKKKKK"}));
assertEquals(15, test.solution(4,5, new String[] {"AAAAA", "AAAAU", "AAAUU", "UUUUU"}));
assertEquals(24, test.solution(5,6, new String[] {"AAAAAA", "BBAATB", "BBAATB", "JJJTAA", "JJJTAA"}));
assertEquals(32, test.solution(6,6, new String[] {"AABBEE", "AAAEEE", "VAAEEV", "AABBEE", "AACCEE", "VVCCEE"}));

public class 마인크래프트 {
    public static void main(String[] args) throws IOException {
        try (BufferedReader br = new BufferedReader(new InputStreamReader(System.in))) {
            int[] nmb = convertStringArrayToIntegerArray(br.readLine().split(" "));

            int n = nmb[0];
            int m = nmb[1];

            int[][] ground = initGround(br, n, m);
            int[] minAndMax = getMinAndMax(ground);

            int[] timeAndHigh = getMinimumConstructionTime(ground, nmb[2], minAndMax[0], minAndMax[1]);

            System.out.println(timeAndHigh[0] + " " + timeAndHigh[1]);
        }
    }

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

        return array;
    }

    private static int[][] initGround(BufferedReader br, int n, int m) throws IOException {
        int[][] ground = new int[n][m];
        for (int i = 0; i < n; i++) {
            ground[i] = convertStringArrayToIntegerArray(br.readLine().split(" "));
        }

        return ground;
    }

    private static int[] getMinAndMax(int[][] ground) {
        int min = Integer.MAX_VALUE;
        int max = Integer.MIN_VALUE;

        for (int[] i : ground) {
            for (int j : i) {
                min = min > j ? j : min;
                max = max < j ? j : max;
            }
        }

        return new int[] {min, max};
    }

    private static int[] getMinimumConstructionTime(int[][] ground, int inventory, int min, int max) {
        int answerTime = Integer.MAX_VALUE;
        int answerHigh = 0;

        for (int currentHigh = min; currentHigh <= max; currentHigh++) {
            int up = 0;
            int down = 0;

            for (int i = 0; i < ground.length; i++) {
                for (int j = 0; j < ground[0].length; j++) {
                    int high = ground[i][j] - currentHigh;

                    if (high > 0) {
                        down += high;
                    } else if (high < 0) {
                        up -= high;
                    }
                }
            }

            if (down + inventory >= up) {
                int time = (down * 2) + up;

                if (answerTime >= time) {
                    answerTime = time;
                    answerHigh = currentHigh;
                }
            }
        }

        return new int[]{answerTime, answerHigh};
    }
}

package algorithm.baekjoon.class2.bruteforce;

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.ArrayList;
import java.util.LinkedList;
import java.util.List;
import java.util.Queue;

public class 마인크래프트 {
    public static void main(String[] args) throws IOException {
        try (BufferedReader br = new BufferedReader(new InputStreamReader(System.in))) {
            int[] nmb = convertStringArrayToIntegerArray(br.readLine().split(" "));

            int n = nmb[0];
            int m = nmb[1];

            int[][] ground = initGround(br, n, m);
            boolean[][] isPassed = new boolean[n][m];

            List<Block> blockList = getBlockList(n, m, ground, isPassed);

            int[] timeAndHigh = getMinimumConstructionTime(blockList, nmb[2]);

            System.out.println(timeAndHigh[0] + " " + timeAndHigh[1]);
        }
    }

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

        return array;
    }

    private static int[][] initGround(BufferedReader br, int n, int m) throws IOException {
        int[][] ground = new int[n][m];
        for (int i = 0; i < n; i++) {
            ground[i]= convertStringArrayToIntegerArray(br.readLine().split(" "));
        }

        return ground;
    }

    private static List<Block> getBlockList(int n, int m, int[][] ground, boolean[][] isPassed) {
        List<Block> list = new ArrayList<>();
        for (int i = 0; i < n; i++) {
            for (int j = 0; j < m; j++) {
                if (isPassed[i][j]) {
                    continue;
                }

                int count = breadthFirstSearch(i, j, ground, isPassed);

                list.add(new Block(ground[i][j], count));
            }
        }

        return list;
    }

    private static int breadthFirstSearch(int x, int y, int[][] picture, boolean[][] isPassed) {
        final int[] xAround = new int[]{1, -1, 0, 0};
        final int[] yAround = new int[]{0, 0, 1, -1};

        int areaRange = 1;

        Queue<Position> queue = new LinkedList<>();

        setPassedArea(isPassed, queue, x, y);

        while (!queue.isEmpty()) {
            Position currentPosition = queue.poll();

            for (int i = 0; i < xAround.length; i++) {
                int moveX = xAround[i] + currentPosition.x;
                int moveY = yAround[i] + currentPosition.y;

                if (!isSameAreaValidation(moveX, moveY, picture, isPassed, currentPosition)) {
                    continue;
                }

                setPassedArea(isPassed, queue, moveX, moveY);
                ++areaRange;
            }
        }

        return areaRange;
    }

    private static void setPassedArea(boolean[][] isPassed, Queue<Position> queue, int x, int y) {
        isPassed[x][y] = true;
        queue.offer(new Position(x, y));
    }

    private static boolean isSameAreaValidation(int moveX, int moveY, int[][] picture, boolean[][] isPassed, Position currentPosition) {
        if (isOutOfPicture(moveX, moveY, picture)) {
            return false;
        }

        if (isPassed[moveX][moveY]) {
            return false;
        }

        if (picture[currentPosition.x][currentPosition.y] != picture[moveX][moveY]) {
            return false;
        }

        return true;
    }

    private static boolean isOutOfPicture(int moveX, int moveY, int[][] picture) {
        if (moveX < 0 || moveY < 0) {
            return true;
        }

        if (picture.length <= moveX || picture[0].length <= moveY) {
            return true;
        }

        return false;
    }

    private static int[] getMinimumConstructionTime(List<Block> blockList, int inventory) {
        int answerTime = Integer.MAX_VALUE;
        int answerHigh = 0;

        for (Block currentBlock : blockList) {
            int currentHigh = currentBlock.high;

            int up = 0;
            int down = 0;

            for (Block loopBlock : blockList) {
                int loopHigh = loopBlock.high;
                int loopCount = loopBlock.count;

                if (currentHigh > loopHigh) {
                    up += (currentHigh - loopHigh) * loopCount;
                } else if (currentHigh < loopHigh) {
                    down += (loopHigh - currentHigh) * loopCount;
                }
            }

            if (down + inventory >= up) {
                int time = (down * 2) + up;

                if (answerTime > time) {
                    answerTime = time;
                    answerHigh = currentBlock.high;
                }
            }
        }

        return new int[]{answerTime, answerHigh};
    }

    static class Block {
        private Integer high;
        private Integer count;

        public Block(Integer high, Integer count) {
            this.high = high;
            this.count = count;
        }
    }

    static class Position {
        private int x;
        private int y;

        public Position(int x, int y) {
            this.x = x;
            this.y = y;
        }
    }
}

public class 나무_자르기 {
    public static void main(String[] args) throws IOException {
        try(BufferedReader br = new BufferedReader(new InputStreamReader(System.in))) {
            long[] nm = convertStringArrayToLongArray(br.readLine().split(" "));

            long m = nm[1];

            long[] trees = convertStringArrayToLongArray(br.readLine().split(" "));

            long answer = solution(trees, m);

            System.out.println(answer);
        }
    }

    private static long[] convertStringArrayToLongArray(String[] args) {
        long[] array = new long[args.length];
        int i = 0;
        for (String str : args) {
            array[i++] = Integer.parseInt(str);
        }

        return array;
    }

    public static long solution(long[] trees, long m) {
        Arrays.sort(trees);

        long low = 0;
        long high = trees[trees.length - 1];

        long answer = 0;

        while (low <= high) {
            long mid = (low + high) >>> 1;
            long sum = getTrees(trees, mid);

            if (sum < m) {
                high = mid - 1;
            } else {
                answer = Math.max(answer, mid);
                low = mid + 1;
            }
        }

        return answer;
    }

    private static long getTrees(long[] trees, long mid) {
        long sum = 0;
        for (int i = 0; i < trees.length; i++) {
            sum += trees[i] > mid ? trees[i] - mid : 0;
        }

        return sum;
    }
}

assertEquals(15, test.solution(new long[] {20, 15, 10, 17}, 7));
assertEquals(3, test.solution(new long[] {6, 6}, 5));
assertEquals(4, test.solution(new long[] {6, 6, 6, 6}, 6));
assertEquals(500000000, test.solution(new long[] {900000000, 900000000, 900000000, 900000000, 900000000}, 2000000000));
assertEquals(19, test.solution(new long[] {20, 15, 10, 17}, 1));
assertEquals(0, test.solution(new long[] {2, 2}, 3));
assertEquals(21, test.solution(new long[] {13, 23, 21, 32}, 12));
assertEquals(2, test.solution(new long[] {1,4,5,7}, 10));
assertEquals(1, test.solution(new long[] {51, 1}, 50));
assertEquals(999999999, test.solution(new long[] {1000000000}, 1));
assertEquals(0, test.solution(new long[] {2, 2,2,2}, 8));

public static void main(String[] args) throws IOException {
    try(BufferedReader br = new BufferedReader(new InputStreamReader(System.in))) {
        br.readLine();
        int[] array1 = convertStringArrayToIntegerArray(br.readLine().split(" "));

        br.readLine();
        int[] array2 = convertStringArrayToIntegerArray(br.readLine().split(" "));

        int[] answer = solution(array1, array2);

        for (int i : answer) {
            System.out.println(i);
        }
    }
}

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

    return array;
}

public static int[] solution(int[] array1, int[] array2) {
    Arrays.sort(array1);

    int[] answer = new int[array2.length];

    int index = 0;
    for (int i : array2) {
        answer[index++] = Arrays.binarySearch(array1, i) < 0 ? 0 : 1;
    }

    return answer;
}

public static int binarySearch(int[] a, int key) {
    return binarySearch0(a, 0, a.length, key);
}

// Like public version, but without range checks.
private static int binarySearch0(int[] a, int fromIndex, int toIndex,
                                    int key) {
    int low = fromIndex;
    int high = toIndex - 1;

    while (low <= high) {
        int mid = (low + high) >>> 1;
        int midVal = a[mid];

        if (midVal < key)
            low = mid + 1;
        else if (midVal > key)
            high = mid - 1;
        else
            return mid; // key found
    }
    return -(low + 1);  // key not found.
}

assertArrayEquals(new int[] {1, 1, 0, 1, 0, 0, 1, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, 0}, test.solution(new int[] {1, 3, 4, 6, 9, 13, 18}, new int[] {3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20}));
assertArrayEquals(new int[] {1, 1, 0, 0, 1}, test.solution(new int[] {4, 1, 5, 2, 3}, new int[] {1, 3, 7, 9, 5}));
assertArrayEquals(new int[] {1}, test.solution(new int[] {1,2}, new int[] {2}));
assertArrayEquals(new int[] {0,1,0,1,0,1,0,1,0,1}, test.solution(new int[] {2,4,6,8,10}, new int[] {1,2,3,4,5,6,7,8,9,10}));

public class 달팽이는_올라가고_싶다 {
    public static void main(String[] args) throws IOException {
        String[] input = getInputData(System.in).split(" ");
        int[] abv = convertStringArrayToIntegerArray(input);

        System.out.println(solution(abv));
    }

    public static String getInputData(InputStream in) throws IOException {
        try (BufferedReader br = new BufferedReader(new InputStreamReader(in))) {

            return br.readLine();
        }
    }

    private static int[] convertStringArrayToIntegerArray(String[] args) {
        int[] array = new int[args.length];
        int i = 0;

        for (String str : args) {
            array[i++] = Integer.parseInt(str);
        }

        return array;
    }

    public static int solution(int[] abv) {
        return (abv[2] - abv[1] - 1) / (abv[0] - abv[1]) + 1;
    }
}

assertEquals(4, test.solution(new int[] {2,1,5}));
assertEquals(2, test.solution(new int[] {5,1,6}));
assertEquals(999999901, test.solution(new int[] {100,99,1000000000}));
assertEquals(1, test.solution(new int[] {5,0,5}));
assertEquals(4, test.solution(new int[] {3,2,6}));
assertEquals(2, test.solution(new int[] {100,1,101}));
assertEquals(3, test.solution(new int[] {3,1,6}));

private static final int CAPITAL_A = 65;
private static final Character LAST_INIT_ALPHABET = 'Z';

public int[] solution(String msg) {
    int[] answer = getDictionaryIndex(msg.toCharArray(), initIndexMap());

    return answer;
}

private Map<String, Integer> initIndexMap() {
    Map<String, Integer> indexMap = new HashMap<>();

    Character start = CAPITAL_A;
    int i = 1;

    while (start <= LAST_INIT_ALPHABET) {

        indexMap.put(String.valueOf(start), i);

        ++start;
        ++i;
    }

    return indexMap;
}

private int[] getDictionaryIndex(char[] charArray, Map<String, Integer> indexMap) {
    int i = 0;
    int arrayLength = charArray.length;
    int lastIndex = indexMap.get(String.valueOf(LAST_INIT_ALPHABET));

    List<Integer> answer = new ArrayList<>();

    while (i < arrayLength) {
        StringBuilder sb = new StringBuilder();

        int value = 0;
        int jump = 0;
        for (int j = i; j < arrayLength; j++) {
            sb.append(charArray[j]);

            String key = sb.toString();
            if (indexMap.containsKey(key)) {
                value = indexMap.get(key);
                jump++;

                if (j +1 == arrayLength) {
                    answer.add(value);
                    i += jump;
                }

                continue;
            }

            answer.add(value);
            i += jump;
            break;
        }

        if (!indexMap.containsKey(sb.toString())) {
            indexMap.put(sb.toString(), ++lastIndex);
        }

        sb.setLength(0);
    }

    return answer.stream().mapToInt(index -> index).toArray();
}

assertArrayEquals(new int[] {11, 1, 27, 15}, test.solution("KAKAO"));
assertArrayEquals(new int[] {20, 15, 2, 5, 15, 18, 14, 15, 20, 27, 29, 31, 36, 30, 32, 34}, test.solution("TOBEORNOTTOBEORTOBEORNOT"));
assertArrayEquals(new int[] {1, 2, 27, 29, 28, 31, 30}, test.solution("ABABABABABABABAB"));
assertArrayEquals(new int[] {20, 8, 1, 20, 27, 29, 9, 19, 33, 31, 30, 28, 20, 33, 14, 15, 39, 19, 41, 43, 36, 9, 39, 46, 38, 47, 34, 19, 36, 52, 45, 40, 42, 35, 38, 48, 62, 54, 51, 61, 53, 55, 66, 57, 44, 59, 64, 32, 49, 60, 29, 52, 76, 37, 32, 71, 43, 70, 47, 75, 73, 80, 43, 79, 56, 72, 84, 61, 86, 68, 81, 90, 69, 92, 72, 85, 63, 96, 89, 87, 91, 83, 101, 94, 103, 65, 97, 106, 99, 108, 50, 74, 111, 77, 66, 98, 81, 70, 93, 118, 117, 88, 33, 122, 116, 58, 127, 62, 127, 78, 114, 123, 100, 133, 95, 112, 105, 104, 132, 145, 87, 134, 130, 129, 137, 131, 82, 79, 148, 151, 150, 144, 153, 159, 102, 135, 121, 156, 159, 125, 75, 162, 113, 158, 124, 109, 126, 149, 67, 142, 146, 166, 155, 158, 174, 171, 140, 119, 128, 175, 120, 138, 152, 161, 174, 181, 139, 154, 141, 187, 143, 176, 165, 172, 167, 191, 164, 182, 194, 184, 136, 170, 193, 147, 86}, test.solution("THATTHATISISTHATTHATISNOTISNOTISTHATITITISTHATTHATISISTHATTHATISNOTISNOTISTHATITITISTHATTHATISISTHATTHATISNOTISNOTISTHATITITISTHATTHATISISTHATTHATISNOTISNOTISTHATITITISTHATTHATISISTHATTHATISNOTISNOTISTHATITITISTHATTHATISISTHATTHATISNOTISNOTISTHATITITISTHATTHATISISTHATTHATISNOTISNOTISTHATITITISTHATTHATISISTHATTHATISNOTISNOTISTHATITITISTHATTHATISISTHATTHATISNOTISNOTISTHATITITISTHATTHATISISTHATTHATISNOTISNOTISTHATITITISTHATTHATISISTHATTHATISNOTISNOTISTHATITITISTHATTHATISISTHATTHATISNOTISNOTISTHATITITISTHATTHATISISTHATTHATISNOTISNOTISTHATITITISTHATTHATISISTHATTHATISNOTISNOTISTHATITITISTHATTHATISISTHATTHATISNOTISNOTISTHATITITISTHATTHATISISTHATTHATISNOTISNOTISTHATITITISTHATTHATISISTHATTHATISNOTISNOTISTHATITITISTHATTHATISISTHATTHATISNOTISNOTISTHATITITISTHATTHATISISTHATTHATISNOTISNOTISTHATITITISTHATTHATISISTHATTHATISNOTISNOTISTHATITITISTHATTHATISISTHATTHATISNOTISNOTISTHATITITISTHATTHATISISTHATTHATISNOTISNOTISTHATITITISTHATTHATISISTHATTHATISNOTISNOTISTHATITITIS"));

private static final String[] ABCDEF = new String[] {"A","B","C","D","E","F"};
public String solution(int n, int t, int m, int p) {

    int limit = t * m;
    String speakString = make(n, limit);

    char[] toChar = speakString.toCharArray();

    StringBuilder answer = new StringBuilder();

    int index = p - 1;
    for (int i = 0; i < t; i++) {
        answer.append(toChar[index]);
        index += m;
    }

    return answer.toString();
}

public String make(int n, int limit) {
    StringBuilder sb = new StringBuilder().append(0);

    for (int i = 1; i < limit; i++) {
        sb.append(changeDecimal(i, n));
    }

    return sb.toString();
}

public char[] changeDecimal(int currentNumber, int n) {
    StringBuilder sb = new StringBuilder();
    while(currentNumber > 0) {
        int remain = currentNumber % n;
        sb.append(remain >= 10 ? ABCDEF[remain-10] : remain);
        currentNumber /= n;
    }

    return sb.reverse().toString().toCharArray();
}

assertEquals("0111", test.solution(2,4,2,1));
assertEquals("02468ACE11111111", test.solution(16,16,2,1));
assertEquals("13579BDF01234567", test.solution(16,16,2,2));

private static final int MISS_RUN_TIME = 5;
public int solution(int cacheSize, String[] cities) {
    if (cacheSize == 0) {
        return cities.length * MISS_RUN_TIME;
    }

    Map<String, Integer> lru = new LinkedHashMap<String, Integer>(cacheSize, 1, true){
        @Override
        public boolean removeEldestEntry(Map.Entry<String, Integer> eldest) {
            return size() > cacheSize;
        }
    };

    int answer = 0;
    for(String key : cities) {
        key = key.toLowerCase();

        if(lru.containsKey(key)) {
            lru.get(key);
            answer += 1;
        } else {
            lru.put(key, 0);
            answer += MISS_RUN_TIME;
        }
    }

    return answer;
}

assertEquals(42, test.solution(3, new String[]{"Jeju", "Pangyo", "Jeju", "NewYork", "LA", "Jeju", "Pangyo", "Seoul", "NewYork", "LA"}));
assertEquals(50, test.solution(3, new String[]{"Jeju", "Pangyo", "Seoul", "NewYork", "LA", "Jeju", "Pangyo", "Seoul", "NewYork", "LA"}));
assertEquals(21, test.solution(3, new String[]{"Jeju", "Pangyo", "Seoul", "Jeju", "Pangyo", "Seoul", "Jeju", "Pangyo", "Seoul"}));
assertEquals(60, test.solution(2, new String[]{"Jeju", "Pangyo", "Seoul", "NewYork", "LA", "SanFrancisco", "Seoul", "Rome", "Paris", "Jeju", "NewYork", "Rome"}));
assertEquals(52, test.solution(5, new String[]{"Jeju", "Pangyo", "Seoul", "NewYork", "LA", "SanFrancisco", "Seoul", "Rome", "Paris", "Jeju", "NewYork", "Rome"}));
assertEquals(16, test.solution(2, new String[]{"Jeju", "Pangyo", "NewYork", "newyork"}));
assertEquals(25, test.solution(0, new String[]{"Jeju", "Pangyo", "Seoul", "NewYork", "LA"}));
assertEquals(18, test.solution(1, new String[]{"LA", "LA", "LA", "LA", "LA", "LA", "LA", "LA", "LA", "LA", "LA", "LA", "LA", "LA"}));

public int[] solution(int brown, int yellow) {
    int sum = brown + yellow;
    int[] answer = new int[2];

    for (int i = 2; i < sum; i++) {
        if (sum % i == 0) {
            int x = ((sum / i) * 2) + ((i * 2) - 4);
            int y = sum - x;

            if (brown == x && yellow == y) {
                answer = new int[] {sum / i, i};
                break;
            }
        }
    }
    return answer;
}

assertArrayEquals(new int[]{4, 3}, test.solution(10, 2));
assertArrayEquals(new int[]{3, 3}, test.solution(8, 1));
assertArrayEquals(new int[]{8, 6}, test.solution(24, 24));

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));