public int solution(String skill, String[] skill_trees) {
    char[] ch = skill.toCharArray();

    List<ArrayList<Skill>> l = new ArrayList<ArrayList<Skill>>();
    for (String element : skill_trees) {
        ArrayList<Skill> list = new ArrayList<Skill>();

        for (int i = 0; i < ch.length; i++) {
            Skill s = new Skill();
            s.skill = ch[i];
            s.index = element.indexOf(ch[i]);

            if (s.index != -1) {
                list.add(s);
            }
        }

        l.add(list);
    }

    int answer = 0;
    for (ArrayList<Skill> list : l) {
        Collections.sort(list, new Comparator<Skill>() {
            @Override
            public int compare(Skill o1, Skill o2) {
                return o1.getIndex().compareTo(o2.getIndex());
            }
        });

        StringBuilder sb = new StringBuilder();
        for (Skill s : list) {
            sb.append(s.getSkill());
        }

        if (skill.startsWith(sb.toString())) {
            answer++;
        }
    }

    return answer;
}

public class Skill {
    private int index;
    private char skill;

    public Integer getIndex() {
        return index;
    }
    public void setIndex(int index) {
        this.index = index;
    }
    public char getSkill() {
        return skill;
    }
    public void setSkill(char skill) {
        this.skill = skill;
    }
}

public int solution(String skill, String[] skill_trees) {
    int answer = 0;
    ArrayList<String> skillTrees = new ArrayList<String>(Arrays.asList(skill_trees));
    Iterator<String> it = skillTrees.iterator();

    while (it.hasNext()) {
        if (skill.indexOf(it.next().replaceAll("[^" + skill + "]", "")) != 0) {
            it.remove();
        }
    }
    answer = skillTrees.size();
    return answer;
}

assertEquals(3, test.solution("CBD", new String[] {"BACDE", "CBADF", "AECB", "BDA", "ASF", "BDF","CEFD"}));
assertEquals(4, test.solution("C", new String[] {"BACDE", "CBADF", "AECB", "BDA"}));
assertEquals(2, test.solution("CBD", new String[] {"C", "D", "CB", "BDA"}));
assertEquals(2, test.solution("AC", new String[] {"ABC", "CA", "ATEW", "SFCQTA"}));
assertEquals(2, test.solution("ACHQ", new String[] {"TWER", "FGCHQEA", "ATEW", "SFCQTA"}));
assertEquals(4, test.solution("CBDK", new String[] {"CB", "CXYB", "BD", "AECD", "ABC", "AEX", "CDB", "CBKD", "IJCB", "LMDK"}));

public int solution(String dartResult) {
	char[] charArray = dartResult.toCharArray();
	
	int[] scores = new int[3];
	int i = 0;
	StringBuilder sb = new StringBuilder();
	for (char ch : charArray) {
		switch (ch) {
		case 'S':
			scores[i++] = Integer.parseInt(sb.toString());
			
			sb.setLength(0);
			break;
		case 'D':
			int a = Integer.parseInt(sb.toString());
			scores[i++] = a * a;
			
			sb.setLength(0);
			break;
		case 'T':
			int b = Integer.parseInt(sb.toString());
			scores[i++] = b * b * b;
			
			sb.setLength(0);
			break;
		case '*':
			if (i > 1) {
				scores[i-2] = scores[i-2] * 2;
			}
			scores[i-1] = scores[i-1] * 2;
			break;
		case '#':
			scores[i-1] = scores[i-1] * -1;
			break;
		default:
			sb.append(ch);
			break;
		}
	}
	
	int answer = scores[0] + scores[1] + scores[2];
	return answer;
}

assertEquals(37, test.solution("1S2D*3T"));
assertEquals(9, test.solution("1D2S#10S"));
assertEquals(3, test.solution("1D2S0T"));
assertEquals(23, test.solution("1S*2T*3S"));
assertEquals(5, test.solution("1D#2S*3S"));
assertEquals(-4, test.solution("1T2D3D#"));
assertEquals(59, test.solution("1D2S3T*"));

public int[] solution(int N, int[] stages) {
    int[] failUsers = new int[N+2];
    for (int stage : stages) {
        failUsers[stage] += 1;
    }

    Map<Integer, Double> map = new HashMap<Integer, Double>();
    double userCount = stages.length;
    for (int i = 1; i <= N; i++) {
        double value = 0.0;
        if (failUsers[i] != 0 && userCount != 0) {
            value = (failUsers[i] / userCount) * 100;
            userCount -= failUsers[i];
        }
        map.put(i, value);
    }

    List<Integer> list = new ArrayList<Integer>(map.keySet());
    Collections.sort(list, new Comparator<Integer>() {

        @Override
        public int compare(Integer o1, Integer o2) {
            return map.get(o2).compareTo(map.get(o1));
        }
    });

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

assertArrayEquals(new int[] {3,4,2,1,5}, test.solution(5, new int[] {2, 1, 2, 6, 2, 4, 3, 3}));
assertArrayEquals(new int[] {4,1,2,3}, test.solution(4, new int[] {4,4,4,4,4}));
assertArrayEquals(new int[] {2,1,3,4}, test.solution(4, new int[] {1,1,1,1,2}));
assertArrayEquals(new int[] {4,2,3,1}, test.solution(4, new int[] {3,2,5,4,2}));
assertArrayEquals(new int[] {7,6,2,3,5,4,1}, test.solution(7, new int[] {2, 1, 2, 6, 2, 4, 3, 3,7,5}));
assertArrayEquals(new int[] {1,2,3,4,5}, test.solution(5, new int[] {}));

public int solution(int[][] board, int[] moves) {
    int[] tops = setTop(board);
    
    Stack<Integer> stack = new Stack<Integer>();
    int answer = 0;
    for (int i = 0; i < moves.length; i++) {
        int move = moves[i] - 1;
        int top = tops[move];
        if (top == 0) {
            continue;
        }
        
        int height = board.length - top;
        int value = board[height][move];
        tops[move] = tops[move] - 1;
        
        if (!stack.isEmpty() && (stack.peek() == value)) {
            stack.pop();
            answer += 2;
        } else {
            stack.push(value);
        }
    }
    
    return answer;
}

private int[] setTop(int[][] board) {
    int height = board.length;
    int width = board[0].length;
    int[] tops = new int[width];
    
    for (int i = 0; i < height; i++) {
        for (int j = 0; j < width; j++) {
            if (tops[j] == 0 && board[i][j] != 0) {
                tops[j] = height - i;
            }
        }
    }
    
    return tops;
}

public int[] solution(int n, int m) {
    int big = n > m ? n : m;
    int small = n < m ? n : m;
    
    while (m != 0) {
        int r = n % m;
        n = m;
        m = r;
    }
    
    return new int[] {n, n * (big / n) * (small / n)};
}

public int[] solution(long n) {
    List<Long> list = new ArrayList<Long>();
    while (n > 0) {
        list.add(n % 10);
        n /= 10;
    }

    return list.stream().mapToInt(i -> (int) (long) i).toArray();
}

public int[] solution(long n) {
    int[] arrays = new int[String.valueOf(n).length()];
    int i = 0;
    while (n > 0) {
        arrays[i++] = (int) (n % 10);
        n /= 10;
    }

    return arrays;
}

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

    prime[0] = true;
    prime[1] = true;

    for (int i = 2; (i * i) <= n; i++) {
        if (!prime[i]) {
            for (int j = i * 2; j <= n; j += i) {
                prime[j] = true;
            }
        }
    }

    int answer = 0;
    for (boolean is : prime) {
        if (!is) {
            answer++;
        }
    }

    return answer;
}

for (int i = 2; (i * i) <= n; i++)

for (int j = i * 2; j <= n; j += i)

public static int solution(int n, int[] times) {
    Arrays.sort(times);
    
    int answer = 0;
    for (int i = 0; i < times.length; i++) {
        answer += times[i] * (n-i);
    }
    
    return answer;
}