public String solution(String m, String[] musicinfos) {
    String answer = "(None)";

    m = getSharpReplace(m);

    int maxPlayTime = 0;

    for (String music : musicinfos) {
        String[] info = music.split(",");

        int playTimeToMinute = getPlayTime(info[0], info[1]);
        String melody = getMelody(playTimeToMinute, info[3]);

        if (melody.contains(m)) {
            if (maxPlayTime < playTimeToMinute) {
                answer = info[2];
                maxPlayTime = playTimeToMinute;
            }
        }
    }

    return answer;
}

private String getSharpReplace(String arg) {
    return arg.replace("C#", "1")
            .replace("D#", "2")
            .replace("E#", "3")
            .replace("F#", "4")
            .replace("G#", "5")
            .replace("A#", "6");
}

private int getPlayTime(String start, String end) {
    LocalTime startTime = convertLocalTime(start);
    LocalTime endTime = convertLocalTime(end);

    LocalTime playTime = endTime.minusHours(startTime.getHour()).minusMinutes(startTime.getMinute());

    return playTime.getHour() * 60 + playTime.getMinute();
}

private LocalTime convertLocalTime(String time) {
    String[] hourAndMinute = time.split(":");

    return LocalTime.of(Integer.parseInt(hourAndMinute[0]), Integer.parseInt(hourAndMinute[1]), 0);
}

private String getMelody(int playtime, String melody) {
    String sharpReplaceMelody = getSharpReplace(melody);
    StringBuilder sb = new StringBuilder();

    char[] array = sharpReplaceMelody.toCharArray();
    for (int i = 0; i < playtime; i++) {
        sb.append(array[i % sharpReplaceMelody.length()]);
    }

    return sb.toString();
}

assertEquals("HELLO", test.solution("ABCDEFG", new String[] {"12:00,12:14,HELLO,CDEFGAB", "13:00,13:05,WORLD,ABCDEF"}));
assertEquals("FOO", test.solution("CC#BCC#BCC#BCC#B", new String[] {"03:00,03:30,FOO,CC#B", "04:00,04:08,BAR,CC#BCC#BCC#B"}));
assertEquals("WORLD", test.solution("ABC", new String[] {"12:00,12:14,HELLO,C#DEFGAB", "13:00,13:05,WORLD,ABCDEF"}));
assertEquals("(None)", test.solution("CDEFGAC", new String[] {"12:00,12:06,HELLO,CDEFGA"}));
assertEquals("FOO", test.solution("CCB", new String[] {"03:00,03:10,FOO,CCB#CCB", "04:00,04:08,BAR,ABC"}));

public String[] solution(String[] files) {

    List<File> fileList = new ArrayList<>();
    for (int i = 0; i < files.length; i++) {
        char[] array = files[i].toCharArray();

        String originName = files[i];
        String head = "";
        Integer number = 0;

        boolean isString = true;
        int numberStartIndex = 0;
        for (int j = 0; j < array.length; j++) {
            if (isString && isNumber(array[j])) {
                head = new String(array, 0, j).toUpperCase();
                numberStartIndex = j;
                isString = false;
                continue;
            }

            if (!isString && !isNumber(array[j])) {
                number = Integer.parseInt(new String(array, numberStartIndex, j - numberStartIndex));
                isString = true;
                break;
            }
        }

        if (!isString) {
            number = Integer.parseInt(new String(array, numberStartIndex, array.length - numberStartIndex));
        }

        fileList.add(new File(originName, head, number, i));
    }

    sort(fileList);

    return fileList.stream()
            .map(File::getOriginName)
            .toArray(String[]::new);
}

private void sort(List<File> fileList) {
    fileList.sort((f1, f2) -> {
        if (f1.head.compareTo(f2.head) != 0) {
            return f1.head.compareTo(f2.head);
        } else if (f1.number.compareTo(f2.number) != 0) {
            return f1.number.compareTo(f2.number);
        } else {
            return f1.index.compareTo(f2.index);
        }
    });
}

private boolean isNumber(char ch) {
    return (48 <= ch && ch <= 57);
}

static class File {
    private final String originName;
    private final String head;
    private final Integer number;
    private final Integer index;

    public File(String originName, String head, Integer number, Integer index) {
        this.originName = originName;
        this.head = head;
        this.number = number;
        this.index = index;
    }

    public String getOriginName() {
        return this.originName;
    }

    public String getHead() {
        return this.head;
    }

    public Integer getNumber() {
        return this.number;
    }

    public Integer getIndex() {
        return this.index;
    }
}

return fileList.stream()
        .sorted(Comparator.comparing(File::getHead)
        .thenComparing(Comparator.comparing(File::getNumber)
        .thenComparing(File::getIndex)))
        .map(File::getOriginName)
        .toArray(String[]::new);

assertArrayEquals(new String[] {"img1.png", "IMG01.GIF", "img02.png", "img2.JPG", "img10.png", "img12.png"}, test.solution(new String[] {"img12.png", "img10.png", "img02.png", "img1.png", "IMG01.GIF", "img2.JPG"}));
assertArrayEquals(new String[] {"A-10 Thunderbolt II", "B-50 Superfortress", "F-5 Freedom Fighter", "F-14 Tomcat"}, test.solution(new String[] {"F-5 Freedom Fighter", "B-50 Superfortress", "A-10 Thunderbolt II", "F-14 Tomcat"}));
assertArrayEquals(new String[] {"img100.p2ng", "img202.png123"}, test.solution(new String[] {"img202.png123", "img100.p2ng"}));
assertArrayEquals(new String[] {"foo010bar020.zip", "foo010bar030.zip"}, test.solution(new String[] {"foo010bar020.zip", "foo010bar030.zip"}));
assertArrayEquals(new String[] {"F-15", "F-17", "F-22"}, test.solution(new String[] {"F-22", "F-17", "F-15"}));

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

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

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