[JAVA] ABC - 027 - A & B & C.

AtCoder ABC 027 A&B&C AtCoder - 027

Ein Problem

―― Von den drei Zahlen sind zwei gleich, aber eine ist unterschiedlich. Finde einen anderen. ――Ich möchte zwei spielen, um eins zu machen ――Wenn Sie XOR verwenden, bleiben Dinge übrig, die nicht storniert werden konnten

	private void solveA() {
		int wk = IntStream.range(0, 3).map(i -> nextInt()).reduce(0, (sum, i) -> sum ^ i);
		out.println(wk);
	}

Problem A: Zwangsstrom

»Etwas Bimyo --An erster Stelle

• Ist es in Ordnung, mit collect die Werte abzurufen, die den Bedingungen auf der Karte entsprechen? ――Da ist es in Ordnung, findFirst () zu verwenden, da garantiert ist, dass nur eine Bedingung mit diesem Muster erfüllt ist?

Stream schwierig

	private void solveA2() {
		int[] wk = IntStream.range(0, 3).map(i -> nextInt()).toArray();
		Map<Integer, Long> resA = Arrays.stream(wk).mapToObj(i -> new Integer(i))
				.collect(Collectors.groupingBy(i -> i, Collectors.counting()));

		List<Entry<Integer, Long>> res = resA.entrySet().stream().filter(i -> i.getValue() != 2)
				.collect(Collectors.toList());
		//		Optional<Entry<Integer, Long>> res = resA.entrySet().stream().filter(i -> i.getValue() != 2).findFirst();
		out.println(res.get(0).getKey());
	}

B Problem

• Ich habe sowohl die kumulative Summe als auch die einfache Implementierung versucht

• Einer ist auskommentiert

• Bild von Menschen, die fließen

―― Ob eine Brücke notwendig ist oder nicht, wird nur danach beurteilt, ob die Anzahl der Personen auf einer Seite dem Durchschnitt der Insel x entspricht oder nicht.

• Wenn es viele gibt, wird eine Brücke benötigt, um die Anzahl der Menschen auf dieser Insel zu verringern
• Wenn nur wenige, brauchen Sie eine Brücke, um Menschen auf die Insel zu schicken

――In der folgenden Abbildung wurde 1-3 zum Durchschnitt, wenn Sie eine Brücke zwischen 1-3 bauen.

――In diesem Beispiel müssen Sie auch eine Brücke für 4-5 bauen. ――Wenn Sie von der 4-5-Brücke nach links schauen, ist dies (3 × 4 ―― 9! = 0).

	private void solveB() {
		int numN = nextInt();
		int[] wk = IntStream.range(0, numN).map(i -> nextInt()).toArray();
		int sum = Arrays.stream(wk).sum();
		if (sum == 0) {
			out.println(0);
			return;
		}
		if (sum % numN != 0) {
			out.println(-1);
			return;
		}

		int avg = sum / numN;
		int cnt = 0;

		/*Bis zu diesem Punkt ist jede Implementierungsmethode dieselbe*/

		//------------------------------------------------------------------------
		/*
		 *Kumulative Summenversion
		 */
		int[] forW = new int[numN];
		for (int i = 0; i < numN; i++) {
			if (i == 0) {
				forW[i] = wk[i];
			} else {
				forW[i] += forW[i - 1] + wk[i];
			}

		}
		/*
		 *Anfangs 0(i-1)Von 1(i)Benötigen Sie eine Brücke?
		 * 　->Beginnen Sie also mit 1. Der Maximalwert der Brücke ist N.-1 so 0(or N)Beides ist nicht anwendbar
		 *notwendig-> 0(i-1)Die Bevölkerung am Punkt unterscheidet sich vom Durchschnittswert (es spielt keine Rolle, ob es groß oder klein ist)
		 *Nicht notwendig-> 0(i-1)Die Bevölkerung am Punkt entspricht dem Durchschnittswert
		 *
		 * i-Ob eine Brücke von 1 bis i benötigt wird
		 *notwendig-> sum(i-1)Wann,(i-1)*Der Durchschnittswert ist unterschiedlich (es spielt keine Rolle, ob er mehr oder weniger ist)
		 *Nicht notwendig-> sum(i-1)Wann,(i-1)*Gleicher Durchschnittswert
		 */
		for (int i = 1; i < numN; i++) {
			if (forW[i - 1] != i * avg) {
				cnt++;
			}
		}
		//------------------------------------------------------------------------
		/*
		 *Dumme Implementierungsversion
		 */
		//		for (int i = 1; i < numN; i++) {
		//			int sumLeft = 0;
		//			for (int j = 0; j < i; j++) {
		//				sumLeft += wk[j];
		//			}
		//			int sumRight = 0;
		//			for (int j = i; j < numN; j++) {
		//				sumRight += wk[j];
		//			}
		//			if (sumLeft != i * avg || sumRight != (numN - i) * avg) {
		//				cnt++;
		//			}
		//		}
		//------------------------------------------------------------------------
		out.println(cnt);
	}

C Problem

――Ich konnte nicht verstehen, ohne die Lösung zu sehen. Ich weiß es immer noch nur irgendwie. ――Ich kann es veranschaulichen, aber ich kann es nicht in Worten erklären. .. ..

• Lösung: S.16 ~

	private void solveC() {
		long numN = nextLong();

		/*
		 *Untersuche die Tiefe
		 */
		int depthCnt = 0;
		for (long n = numN; n > 0; n >>= 1) {
			depthCnt++;
		}

		long cnt = 1;

		/*
		 *Wenn die Tiefe gerade ist[ 2*n ]Beginne am
		 *Wenn die Tiefe ungerade ist[ 2*n+1 ]Beginne am
		 */
		int adjust = depthCnt % 2;
		/*
		 *Aoki gewinnt, wenn die erste Zahl nicht gezählt werden kann
		 *Danach,
		 *Takahashi gewinnt, wenn Aoki nicht zählen kann
		 *Aoki gewinnt, wenn Takahashi nicht zählen kann
		 *Wiederholen, bis Sie abwechselnd gewinnen.
		 *Vielleicht sollte ich MAX of Long wiederholen, aber ich bin mir nicht sicher
		 */
		boolean who = true;
		while (true) {
			cnt = 2 * cnt + adjust;
			if (cnt > numN) {
				out.println(who ? "Aoki" : "Takahashi");
				return;
			}
			who = !who;
			adjust = 1 - adjust;

		}

	}