Ich habe EX25 des AtCoder Programming Guide für Anfänger (APG4b) in Java geschrieben.

Einführung

Dieser Artikel befasst sich mit dem Inhalt von AtCoder

AtCoder Programming Guide for beginners (APG4b)

Ich habe versucht, die in EX25 --Assembly-Operation veröffentlichte Aufgabe zu schreiben, daher werde ich den Code als Memorandum veröffentlichen. Ich würde es begrüßen, wenn Sie es lesen könnten.

Wenn Sie Punkte haben, die schwer zu lesen sind, Fehler oder Eindrücke, lassen Sie es uns bitte in den Kommentaren wissen.

Verwenden wir den Bitoperator! Ich habe es direkt mit ganzzahligen Werten zu tun ... (Ich wünschte, ich hätte bitSet in C ++ implementiert. Gibt es ...?)

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;
		}
	}
	/**
	 *Gibt eine Reihe von Elementen zurück, die üblicherweise in A und B enthalten sind
	 * @param A
	 * @param B
	 * @return Ein Array allgemeiner Elemente
	 */
	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()]);
	}

	/**
	 *Gibt eine Reihe von Elementen zurück, die in mindestens einem von A und B enthalten sind
	 * @param A
	 * @param B
	 * @return Ein Array von Elementen, die in mindestens einem enthalten sind
	 */
	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()]);
	}

	/**
	 *Gibt eine Reihe von Elementen zurück, die nur in A und B enthalten sind
	 * @param A
	 * @param B
	 * @return Ein Array von Elementen, die nur in einem enthalten sind
	 */
	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()]);
	}

	/**
	 *Schließen Sie den Wert x von der Menge A aus
	 * @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()]);
	}

	/**
	 *Addiere 1 zu allen Elementen von 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()]);
	}

	/**
	 *Subtrahiere 1 von allen Elementen von 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()]);
	}

	/**
	 *Ergebnisausgabe
	 */
	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]);
	}
}