競技プログラムの覚書

        var _x1 = (Math.cos(dth) * _x) - (Math.sin(dth) * _y) + cx;
        var _y1 = (Math.sin(dth) * _x) + (Math.cos(dth) * _y) + cy;

i < n ? " " : ""

        String[] strArray = {"Hello", "World"};

        Stream<Character> stream = Arrays.stream(strArray)
                .flatMap(str -> str.chars().mapToObj(c -> (char) c));

        var set = new HashSet<>();
        set.addAll(Arrays.stream(An).boxed().collect(Collectors.toList()));

        var An = new int[]{1,2,2,2,3,3,3,4,5,6};

        var map = Arrays.stream(An).boxed().collect(Collectors.groupingBy(
                i -> i,Collectors.counting()
        ));
        for(var entry : map.entrySet()){
            pw.println(entry.getKey() + ":" + entry.getValue());
        }

1:1
2:3
3:3
4:1
5:1
6:1

        var list = new LinkedList<Integer>();
        list.add(1);
        list.add(5);
        list.add(2);
        list.add(3);
        list.add(1);
        Collections.sort(list);
        Collections.binarySearch(list,3);

        var list2 = new LinkedList<Pair>();
        list2.add(new Pair(3, 2));
        list2.add(new Pair(5, -2));
        list2.add(new Pair(1, 0));
        list2.add(new Pair(5, 2));
        list2.add(new Pair(2, 8));

        Comparator<Pair> comparator = Comparator.comparingInt(p -> p.b);
        Collections.sort(list2, comparator);
        Collections.binarySearch(list2, new Pair(1, 0), comparator);

var comparator = Comparator.<Pair>comparingInt(p -> p.b).reversed().thenComparingInt(p -> p.a);

map.merge(key, msg, String::concat);
map.merge(key,valuew, Long::sum);

String s = in.next();
        if (s.matches("[A-Z][1-9][0-9]{5}[A-Z]")) {
            out.println("Yes");
        } else {
            out.println("No");
        }

        var N = fs.ni();
        var T = fs.ni();
        var cn = new int[N];
        var tn = new int[N];
        for (int i = 0; i < N; i++) {
            cn[i] = fs.ni();
            tn[i] = fs.ni();
        }
        var ans = IntStream.range(0,N).filter(i -> tn[i] <= T).map(i -> cn[i]).min();
        pw.println(ans.isPresent()?ans.getAsInt():"TLE");

        var N = fs.ni();
        var K = fs.ni();

        var ptn = 1;
        for (int i = 0; i < N; i++) {
            ptn *= K;
        }
        for (int i = 0; i < ptn; i++) {
            var t = i;
            for (int j = 0; j < N; j++) {
                var m = t % K; //j桁目の数値がm
                t /= K;
            }
        }

        var EPS = 1e-7;
        var dp = new double[N + 1][N + 1];
        for (int i = 0; i < N; i++) {
            Arrays.fill(dp[i], Double.MIN_VALUE);
        }
        dp[i + 1][j] = Math.max(dp[i][j], dp[i + 1][j] + EPS);

        var N = fs.ni();
        var M = fs.ni();

        var set = (1 << 31) - 1;
        for (int i = 0; i < N; i++) {
            var K = fs.ni();
            var bit = 0;
            for (int j = 0; j < K; j++) {
                var a = fs.ni();
                bit |= 1 << a;
            }
            set &= bit;
        }
        pw.println(Integer.bitCount(set));

Arrays.setAll(c,i->i);

        Arrays.sort(AB, Comparator.<int[]>comparingInt(i -> i[1]).thenComparingInt(i -> -i[0]));
        Arrays.sort(AB, 0, N - X, Comparator.<int[]>comparingInt(i -> i[2]).thenComparingInt(i -> -i[0]));
        Arrays.sort(AB, 0, N - (X + Y), Comparator.<int[]>comparingInt(i -> i[2] + i[1]).thenComparingInt(i -> -i[0]));
        Arrays.sort(AB, N  - (X + Y + Z ), N, Comparator.comparingInt(i -> i[0]));
        for (int i = N  - (X + Y + Z ); i < N; i++) {
            pw.println(AB[i][0]);
        }

        var end = 0;
        var ans = 0;
        for (int start = 0; start < N; start++) {
            while(end < N && An[end] - An[start] < M){
                end++;
            }
            ans = Math.max(ans,end -start);
        }

 var set = new HashSet<Pair>();

set.add(new Pair(a,b));
set.remove(new Pair(a,b));
set.contains(new Pair(a,b))

        var bit = 0;
        while(bit < (1 << M)){
            for (int i = 0; i < M; i++) {
                if(((bit >> i) & 1) == 1){
                }
            }

    private static void solve(PrintWriter pw, FastScanner fs) {
        //==================
        var R = fs.nl();
        var X = fs.nl();
        var Y = fs.nl();
        var DD = X * X + Y * Y;

        if (DD < R * R) {
            pw.println(2);
            return;
        }

        var ans = (long) Math.ceil(Math.sqrt(DD) / R);
        pw.println(ans);
    }

        var S = fs.n();
        var bit = new IntFenwickTree(S.length());
        var map = new HashMap<Character, Integer>();
        map.put('a', 1);
        map.put('t', 2);
        map.put('c', 3);
        map.put('o', 4);
        map.put('d', 5);
        map.put('e', 6);
        map.put('r', 7);

        var ans = 0;
        for (int i = 0; i < S.length(); i++) {
            var j = map.get(S.charAt(i));
            ans += i - bit.sum(j);
            bit.update(j, 1);
        }
        pw.println(ans);