public String solution(String number, int k) {
    char[] toCharArray = number.toCharArray();

    StringBuilder answer = new StringBuilder();

    int idx = 0;
    for(int i = 0; i < number.length() - k; i++) {
        int max = 0;

        for(int j = idx; j <= k + i; j++) {
            int ch = toCharArray[j] - '0';
            if(max < ch) {
                max = ch;
                idx = j + 1;
            }
        }

        answer.append(max);
    }

    return answer.toString();
}

assertEquals("23", test.solution("123", 2));
assertEquals("34", test.solution("1234", 2));
assertEquals("94", test.solution("1924", 2));
assertEquals("3234", test.solution("1231234", 3));
assertEquals("775841", test.solution("4177252841", 4));
assertEquals("9", test.solution("9999999999", 9));
assertEquals("93231357719", test.solution("9312131357719", 5));

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

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

public int solution(int bridge_length, int weight, int[] truck_weights) {
    LinkedList<Truck> queue = new LinkedList<Truck>();

    for (int i = 0; i < truck_weights.length; i++) {
        queue.offer(new Truck(bridge_length, truck_weights[i]));
    }

    int answer = 1;
    int bridgeOnTruck = 0;
    while (!queue.isEmpty()) {

        int totalWeight = 0;
        for (int i = 0; i < bridgeOnTruck; i++) {
            totalWeight += queue.get(i).weight;
        }

        int nextWeight = 0;
        if (queue.size() > bridgeOnTruck) {
            nextWeight = queue.get(bridgeOnTruck).weight;
        }

        if (totalWeight + nextWeight <= weight) {
            if (queue.size() > bridgeOnTruck) {
                ++bridgeOnTruck;
            }
        }

        for (int i = 0; i < bridgeOnTruck; i++) {
            Truck truck = queue.get(i);
            truck.position = truck.position - 1;
        }

        if (queue.peek().position == 0) {
            queue.poll();
            --bridgeOnTruck;
        }

        ++answer;
    }

    return answer;
}

class Truck {
    public int position;
    public int weight;

    public Truck(int position, int weight) {
        this.position = position;
        this.weight = weight;
    }
}

assertEquals(8, test.solution(2, 10, new int[] {7,4,5,6}));
assertEquals(101, test.solution(100, 100, new int[] {10}));
assertEquals(110, test.solution(100, 100, new int[] {10,10,10,10,10,10,10,10,10,10}));

public long solution(long w,long h) {
    long big = w > h ? w : h;
    long small = w > h ? h : w;

    while (small != 0) {
        long r = big % small;
        big = small;
        small = r;
    }

    return (w * h) - (w + h - big);
}

assertEquals(80, test.solution(8, 12));
assertEquals(12, test.solution(5, 4));
assertEquals(40, test.solution(10, 5));
assertEquals(352, test.solution(17, 23));
assertEquals(30467460, test.solution(3, 15233730));

public int solution(int[] priorities, int location) {
    int answer = 0;

    LinkedList<Integer> queue = new LinkedList<Integer>();
    for (int i = 0; i < priorities.length; i++) {
        queue.offer(priorities[i]);
    }

    while (queue.size() != 0) {
        for (int i = 1; i < queue.size(); i++) {
            if (queue.peek() < queue.get(i)) {
                queue.offer(queue.poll());

                if (location == 0) {
                    location = queue.size() - 1;
                } else {
                    --location;
                }

                i = 0;
            }
        }

        answer++;
        if (location == 0) {
            break;
        }

        --location;
        queue.poll();
    }

    return answer;
}

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

public int[] solution(int[] progresses, int[] speeds) {
    int start = 0;
    List<Integer> list = new ArrayList<Integer>();
    while (start != progresses.length) {
        int deploy = 0;
        for (int i = start; i < progresses.length; i++) {
            progresses[i] += speeds[i];
        }

        for (int i = start; i < progresses.length; i++) {
            if (progresses[start] < 100) {
                break;
            }

            if (progresses[i] >= 100) {
                ++start;
                ++deploy;
            }
        }

        if (deploy != 0) {
            list.add(deploy);
        }
    }

    int[] answer = list.stream().mapToInt(i -> i).toArray();
    return answer;
}

public int[] solution(int[] progresses, int[] speeds) {
    int[] dayOfend = new int[100];
    int day = -1;
    for(int i=0; i<progresses.length; i++) {
        while(progresses[i] + (day*speeds[i]) < 100) {
            day++;
        }
        dayOfend[day]++;
    }
    return Arrays.stream(dayOfend).filter(i -> i!=0).toArray();
}

assertArrayEquals(new int[] {2,1}, test.solution(new int[] {93, 30, 55}, new int[] {1, 30, 5}));
assertArrayEquals(new int[] {3}, test.solution(new int[] {0, 30, 55}, new int[] {1, 99, 99}));
assertArrayEquals(new int[] {1,1,1}, test.solution(new int[] {3, 2, 1}, new int[] {1, 1, 1}));