J'ai écrit EX25 du guide de programmation AtCoder pour les débutants (APG4b) en java.

introduction

Cet article concerne le contenu d'AtCoder

AtCoder Programming Guide for beginners (APG4b)

J'ai essayé d'écrire la tâche EX25 - Opération d'assemblage publiée, donc je publierai le code sous forme de mémorandum. Je vous serais reconnaissant si vous pouviez le lire.

Si vous avez des points difficiles à lire, des erreurs ou des impressions, veuillez nous en informer dans les commentaires.

Utilisons l'opérateur bit! Je traite directement des valeurs entières ... (j'aurais aimé avoir implémenté bitSet en C ++. Y a-t-il ...?)

code

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;
		}
	}
	/**
	 *Renvoie un ensemble d'éléments couramment contenus dans A et B
	 * @param A
	 * @param B
	 * @return Un tableau d'éléments communs
	 */
	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()]);
	}

	/**
	 *Renvoie un ensemble d'éléments contenus dans au moins l'un des éléments A et B
	 * @param A
	 * @param B
	 * @return Un tableau d'éléments contenus dans au moins un
	 */
	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()]);
	}

	/**
	 *Renvoie un ensemble d'éléments contenus dans un seul des éléments A et B
	 * @param A
	 * @param B
	 * @return Un tableau d'éléments contenus dans un seul
	 */
	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()]);
	}

	/**
	 *Exclure la valeur x de l'ensemble A
	 * @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()]);
	}

	/**
	 *Ajoutez 1 à tous les éléments de 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()]);
	}

	/**
	 *Soustrayez 1 de tous les éléments de 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()]);
	}

	/**
	 *Sortie de résultat
	 */
	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]);
	}
}