AtCoder Programming Guide for beginners (APG4b)のEX25をjavaで書いてみた。

はじめに

この記事は、AtCoder内コンテンツの

AtCoder Programming Guide for beginners (APG4b)

で掲載されている課題EX25 - 集合の操作をJavaで記述してみたので、備忘録としてコードを公開するものです。ご一読いただけたら幸いです。

読みづらい点、間違い、感想等ありましたらコメントにてお伝えいただけると嬉しいです。

尚、bit演算子を用いよう！という気概無く、整数値を直接扱っています...(C++でいうところのbitSetが実装されていればよかったのですが。ありますかね…？)

コード

Main.java

import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collections;
import java.util.Comparator;
import java.util.List;
import java.util.Scanner;
import java.util.Set;
import java.util.TreeSet;

public class Main {

    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        int N = sc.nextInt();
        Integer[] A = new Integer[N];
        for(int i = 0;i < N;i++) {
            A[i] = sc.nextInt();
        }
        int M = sc.nextInt();
        Integer[] B = new Integer[M];
        for(int i = 0;i < M;i++) {
            B[i] = sc.nextInt();
        }
        String command = sc.next();
        int x = 0;
        if(command.equals("subtract")) {
            x = sc.nextInt();
        }
        sc.close();
        switch(command) {
        case "intersection":
            printResult(intersection(A, B));
            break;
        case "union_set":
            printResult(unionset(A, B));
            break;
        case "symmetric_diff":
            printResult(symmetricdiff(A, B));
            break;
        case "subtract":
            printResult(subtract(A, x));
            break;
        case "increment":
            printResult(increment(A));
            break;
        case "decrement":
            printResult(decrement(A));
            break;
        default:
            break;
        }
    }
    /**
     * AとBに共通して含まれる要素からなる集合を返す
     * @param A
     * @param B
     * @return 共通要素の配列
     */
    private static Integer[] intersection(Integer[] A,Integer[] B) {
        List<Integer> Alist = Arrays.asList(A);
        List<Integer> Blist = Arrays.asList(B);
        List<Integer> result = new ArrayList<>();
        for(Integer i : Alist) {
            if(Blist.contains(i)) {
                result.add(i);
            }
        }
        if(result.size()==0) return null;
        Collections.sort(result);
        return  result.toArray(new Integer[result.size()]);
    }

    /**
     * AとBのうち少なくとも一方に含まれる要素からなる集合を返す
     * @param A
     * @param B
     * @return 少なくとも一方に含まれる要素の配列
     */
    private static Integer[] unionset(Integer[] A,Integer[] B) {
        Set<Integer> result = new TreeSet<>(Comparator.naturalOrder());
        for(Integer i : A) result.add(i);
        for(Integer i : B) result.add(i);
        return result.size()==0 ? null : result.toArray(new Integer[result.size()]);
    }

    /**
     * AとBのうちどちらか一方にだけ含まれる要素からなる集合を返す
     * @param A
     * @param B
     * @return 一方にのみ含まれる要素の配列
     */
    private static Integer[] symmetricdiff(Integer[] A,Integer[] B) {
        List<Integer> intersection = Arrays.asList(intersection(A, B));
        List<Integer> union = Arrays.asList(unionset(A, B));
        List<Integer> result = new ArrayList<>();
        for(Integer i : union) {
            if(union.contains(i) && !intersection.contains(i)) {
                result.add(i);
            }
        }
        if(result.size()==0) return null;
        Collections.sort(result);
        return result.toArray(new Integer[result.size()]);
    }

    /**
     * 集合Aから値xを除く
     * @param A
     * @param x
     * @return
     */
    private static Integer[] subtract(Integer[] A, int x) {
        List<Integer> list = Arrays.asList(A);
        List<Integer> result = new ArrayList<>();
        for(Integer i : list) {
            if(i != x) {
                result.add(i);
            }
        }
        if(result.size()==0) return null;
        Collections.sort(result);
        return result.toArray(new Integer[result.size()]);
    }

    /**
     * Aの要素すべてに１を加える。
     */
    private static Integer[] increment(Integer[] A) {
        List<Integer> result = new ArrayList<>();
        for(Integer i : A) {
            i++;
            if(i.equals(50)) {
                i = 0;
            }
            result.add(i);
        }
        if(result.size()==0) return null;
        Collections.sort(result);
        return result.toArray(new Integer[result.size()]);
    }

    /**
     * Aの要素すべてから１を引く。
     */
    private static Integer[] decrement(Integer[] A) {
        List<Integer> result = new ArrayList<>();
        for(Integer i : A) {
            i--;
            if(i.equals(-1)) {
                i = 49;
            }
            result.add(i);
        }
        if(result.size()==0) return null;
        Collections.sort(result);
        return result.toArray(new Integer[result.size()]);
    }

    /**
     * 結果出力
     */
    private static void printResult(Integer[] result) {
        if(result==null) {
            System.out.println("");
            return;
        }
        if(result.length > 1) {
            for(int i = 0;i < result.length-1;i++) {
                System.out.print(result[i] + " ");
            }
        }
        System.out.println(result[result.length-1]);
    }
}