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

AtCoder ABC 027 A&B&C AtCoder - 027

Un problème

«Des trois nombres, deux sont identiques mais un est différent. Trouvez-en un autre. ――Je veux jouer à deux pour en faire un ――Lorsque vous XOR, les choses qui n'ont pas pu être annulées restent

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

Problème A: flux forcé

―― Quelque chose de Bimyo ――En premier lieu

• Est-il acceptable d'utiliser collect pour récupérer les valeurs qui correspondent aux conditions de la carte? ―― Puisqu'il est garanti qu'une seule condition est remplie avec ce modèle, est-il acceptable d'utiliser findFirst ()?

Diffusion difficile

	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());
	}

Problème B

• J'ai essayé à la fois la somme cumulative et une mise en œuvre simple --Un est commenté

--Image de personnes qui coulent

«La nécessité ou non d'un pont est jugée uniquement par« si le nombre de personnes d'un côté est le même que la moyenne de l'île x ».

• S'il y en a beaucoup, un pont est nécessaire pour réduire le nombre de personnes sur cette île
• Si peu, vous avez besoin d'un pont pour envoyer des gens sur l'île

Dans la figure ci-dessous, si vous construisez un pont entre 1 et 3, 1 à 3 est devenu la moyenne.

Dans cet exemple, vous devez également construire un pont pour 4-5. ――Lorsque vous regardez à gauche du pont 4-5, c'est (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;

		/*Jusqu'à présent, les deux méthodes de mise en œuvre sont les mêmes*/

		//------------------------------------------------------------------------
		/*
		 *Version de somme cumulée
		 */
		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];
			}

		}
		/*
		 *Initialement 0(i-1)À partir de 1(i)Avez-vous besoin d'un pont?
		 * 　->Alors, partez de 1. La valeur maximale du pont est N-1 donc 0(or N)L'un ou l'autre n'est pas applicable
		 *nécessaire-> 0(i-1)La population au point est différente de la valeur moyenne (peu importe qu'elle soit grande ou petite)
		 *Inutile-> 0(i-1)La population au point est la même que la valeur moyenne
		 *
		 * i-Si un pont est nécessaire de 1 à i
		 *nécessaire-> sum(i-1)Quand,(i-1)*La valeur moyenne est différente (peu importe si elle est plus ou moins)
		 *Inutile-> sum(i-1)Quand,(i-1)*Même valeur moyenne
		 */
		for (int i = 1; i < numN; i++) {
			if (forW[i - 1] != i * avg) {
				cnt++;
			}
		}
		//------------------------------------------------------------------------
		/*
		 *Version d'implémentation stupide
		 */
		//		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);
	}

Problème C

«Je ne pourrais pas comprendre sans voir la solution. Je ne sais toujours que d'une manière ou d'une autre. «Je peux l'illustrer, mais je ne peux pas l'expliquer avec des mots. .. ..

• Solution: P.16 ~

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

		/*
		 *Examiner la profondeur
		 */
		int depthCnt = 0;
		for (long n = numN; n > 0; n >>= 1) {
			depthCnt++;
		}

		long cnt = 1;

		/*
		 *Si la profondeur est égale[ 2*n ]Commencer à partir de
		 *Si la profondeur est bizarre[ 2*n+1 ]Commencer à partir de
		 */
		int adjust = depthCnt % 2;
		/*
		 *Aoki gagne si le premier numéro ne peut pas être compté
		 *Après ça,
		 *Takahashi gagne si Aoki ne peut pas compter
		 *Aoki gagne si Takahashi ne peut pas compter
		 *Répétez jusqu'à ce que vous gagniez en alternance.
		 *Peut-être que je devrais répéter à MAX of Long, mais je ne suis pas sûr
		 */
		boolean who = true;
		while (true) {
			cnt = 2 * cnt + adjust;
			if (cnt > numN) {
				out.println(who ? "Aoki" : "Takahashi");
				return;
			}
			who = !who;
			adjust = 1 - adjust;

		}

	}