paizaラーニングレベルアップ問題集の【条件分岐メニュー】をやってみた。(4)

paizaラーニングレベルアップ問題集の【条件分岐メニュー】をやってみました。
- - -
##### 問題
###### けた数の測定
https://paiza.jp/works/mondai/conditions_branch/conditions_branch__complex_step1
###### 足したり引いたり
https://paiza.jp/works/mondai/conditions_branch/conditions_branch__complex_step2
###### 同値判定
https://paiza.jp/works/mondai/conditions_branch/conditions_branch__complex_step3
###### 終了判定
https://paiza.jp/works/mondai/conditions_branch/conditions_branch__complex_step4
###### 終了判定2
https://paiza.jp/works/mondai/conditions_branch/conditions_branch__complex_step5
- - -
##### 方針
###### けた数の測定
$N$を文字列として受け取って文字列長を出力するでもいいですが、今回は「条件分岐メニュー」ということで、
- $0$以上$9$以下ならば`1`
- $10$以上$99$以下ならば`2`
- $100$以上$999$以下ならば`3`

を出力します。
※サンプルコードでは、制約条件外の入力については考慮していません。
###### 足したり引いたり
$N+A+B$, $N+A-B$, $N-A+B$, $N-A-B$のいずれかが$0$なら`YES`、いずれも$0$でないなら`NO`を出力します。
言語によっては、この4つの値を配列にして`index`関数、`all`関数、`any`関数等で判定することもできます。
###### 同値判定
$A_i=B_i$を満たす$i$の個数をカウントします。言語によっては`filter`関数を用いることもできます。
###### 終了判定
$A_i$が偶数の間$A_i$を足し続け、$A_i$が奇数になったらループを脱出して答えを出力します。
###### 終了判定2
シフト演算と`while`使ったら、「条件分岐メニュー」の解答として❓なコードが出来てしまいました💦

- - -
##### C
###### けた数の測定
```c
#include <stdio.h>

int main() {
	int n;
	scanf("%d", &n);
	if (n < 10) printf("%d\n", 1);
	else if (n < 100) printf("%d\n", 2);
	else printf("%d\n", 3);
	return 0;
}
```
###### 足したり引いたり
```c
#include <stdio.h>

int main() {
	int n, a, b;
	scanf("%d %d %d", &n, &a, &b);
	puts(n + a + b && n + a - b && n - a + b && n - a - b ? "NO" : "YES");
	return 0;
}
```
###### 同値判定
```c
#include <stdio.h>

int main() {
	int n;
	scanf("%d", &n);
	int A[n];
	for (int i = 0; i < n; i++) scanf("%d", &A[i]);
	int B[n];
	for (int i = 0; i < n; i++) scanf("%d", &B[i]);
	int c = 0;
	for (int i = 0; i < n; i++) c += A[i] == B[i];
	printf("%d\n", c);
	return 0;
}
```
###### 終了判定
```c
#include <stdio.h>

int main() {
	int n;
	scanf("%d", &n);
	int A[n];
	for (int i = 0; i < n; i++) scanf("%d", &A[i]);
	int s = 0;
	for (int i = 0; i < n; i++) {
		if (A[i] % 2 != 0) break;
		s += A[i];
	}
	printf("%d\n", s);
	return 0;
}
```
###### 終了判定2
```c
#include <stdio.h>

int main() {
	int n, k;
	scanf("%d %d", &n, &k);
	int m = 0;
	while ((n << m) < k) m++;
	printf("%d\n", m);
	return 0;
}
```
- - -
##### C++
###### けた数の測定
```cpp
#include <iostream>
using namespace std;

int main() {
	int n;
	cin >> n;
	if (n < 10) cout << 1 << endl;
	else if (n < 100) cout << 2 << endl;
	else cout << 3 << endl;
	return 0;
}
```
###### 足したり引いたり
```cpp
#include <iostream>
using namespace std;

int main() {
	int n, a, b;
	cin >> n >> a >> b;
	cout << (n + a + b && n + a - b && n - a + b && n - a - b ? "NO" : "YES") << endl;
	return 0;
}
```
###### 同値判定
```cpp
#include <iostream>
using namespace std;

int main() {
	int n;
	cin >> n;
	int A[n];
	for (int i = 0; i < n; i++) cin >> A[i];
	int B[n];
	for (int i = 0; i < n; i++) cin >> B[i];
	int c = 0;
	for (int i = 0; i < n; i++) c += A[i] == B[i];
	cout << c << endl;
	return 0;
}
```
###### 終了判定
```cpp
#include <iostream>
using namespace std;

int main() {
	int n;
	cin >> n;
	int A[n];
	for (int i = 0; i < n; i++) cin >> A[i];
	int s = 0;
	for (int i = 0; i < n; i++) {
		if (A[i] % 2 != 0) break;
		s += A[i];
	}
	cout << s << endl;
	return 0;
}
```
###### 終了判定2
```cpp
#include <iostream>
using namespace std;

int main() {
	int n, k;
	cin >> n >> k;
	int m = 0;
	while ((n << m) < k) m++;
	cout << m << endl;
	return 0;
}
```
- - -
##### C#
###### けた数の測定
```cs
using System;

class Program
{
	public static void Main()
	{
		int n = int.Parse(Console.ReadLine());
		if (n < 10) Console.WriteLine(1);
		else if (n < 100) Console.WriteLine(2);
		else Console.WriteLine(3);
	}
}
```
###### 足したり引いたり
```cs
using System;
using System.Linq;

class Program
{
	public static void Main()
	{
		int[] nab = Array.ConvertAll(Console.ReadLine().Split(), int.Parse);
		int n = nab[0];
		int a = nab[1];
		int b = nab[2];
		Console.WriteLine(new int[] {n + a + b, n + a - b, n - a + b, n - a - b}.Any(_ => _ == 0) ? "YES" : "NO");
	}
}
```
###### 同値判定
```cs
using System;
using System.Linq;

class Program
{
	public static void Main()
	{
		int n = int.Parse(Console.ReadLine());
		int[] A = Array.ConvertAll(Console.ReadLine().Split(), int.Parse);
		int[] B = Array.ConvertAll(Console.ReadLine().Split(), int.Parse);
		Console.WriteLine(Enumerable.Range(0, n).Where(i => A[i] == B[i]).Count());
	}
}
```
###### 終了判定
```cs
using System;

class Program
{
	public static void Main()
	{
		int n = int.Parse(Console.ReadLine());
		int[] A = Array.ConvertAll(Console.ReadLine().Split(), int.Parse);
		int s = 0;
		for (int i = 0; i < n; i++) {
			if (A[i] % 2 != 0) break;
			s += A[i];
		}
		Console.WriteLine(s);
	}
}
```
###### 終了判定2
```cs
using System;

class Program
{
	public static void Main()
	{
		int[] nk = Array.ConvertAll(Console.ReadLine().Split(), int.Parse);
		int n = nk[0];
		int k = nk[1];
		int m = 0;
		while ((n << m) < k) m++;
		Console.WriteLine(m);
	}
}
```
- - -
##### Go
###### けた数の測定
```go
package main
import "fmt"

func main() {
	var n int
	fmt.Scan(&n)
	if n < 10 {
		fmt.Println(1)
	} else if n < 100 {
		fmt.Println(2)
	} else {
		fmt.Println(3)
	}
}
```
###### 足したり引いたり
```go
package main
import "fmt"

func main() {
	var n, a, b int
	fmt.Scan(&n, &a, &b)
	if n + a + b == 0 || n + a - b == 0 || n - a + b == 0 || n - a - b == 0 {
		fmt.Println("YES")
	} else {
		fmt.Println("NO")
	}
}
```
###### 同値判定
```go
package main
import "fmt"

func main() {
	var n int
	fmt.Scan(&n)
	A := make([]int, n)
	for i := 0; i < n; i++ {
		fmt.Scan(&A[i])
	}
	B := make([]int, n)
	for i := 0; i < n; i++ {
		fmt.Scan(&B[i])
	}
	c := 0
	for i := 0; i < n; i++ {
		if A[i] == B[i] {
			c++
		}
	}
	fmt.Println(c)
}
```
###### 終了判定
```go
package main
import "fmt"

func main() {
	var n int
	fmt.Scan(&n)
	A := make([]int, n)
	for i := 0; i < n; i++ {
		fmt.Scan(&A[i])
	}
	s := 0
	for i := 0; i < n; i++ {
		if A[i] % 2 != 0 {
			break
		}
		s += A[i]
	}	
	fmt.Println(s)
}
```
###### 終了判定2
```go
package main
import "fmt"

func main() {
	var n, k int
	fmt.Scan(&n, &k)
	m := 0
	for (n << m) < k {m++}
	fmt.Println(m)
}
```
- - -
##### Java
###### けた数の測定
```java
import java.util.*;

public class Main {
	public static void main(String[] args) {
		Scanner sc = new Scanner(System.in);
		int n = sc.nextInt();
		sc.close();
		if (n < 10) System.out.println(1);
		else if (n < 100) System.out.println(2);
		else System.out.println(3);
	}
}
```
###### 足したり引いたり
```java
import java.util.*;

public class Main {
	public static void main(String[] args) {
		Scanner sc = new Scanner(System.in);
		int n = sc.nextInt();
		int a = sc.nextInt();
		int b = sc.nextInt();
		System.out.println(Arrays.stream(new int[] {n + a + b, n + a - b, n - a + b, n - a - b}).anyMatch(x -> x == 0) ? "YES" : "NO");
		sc.close();
	}
}
```
###### 同値判定
```java
import java.util.*;
import java.util.stream.*;

public class Main {
	public static void main(String[] args) {
		Scanner sc = new Scanner(System.in);
		int n = Integer.parseInt(sc.nextLine());
		int[] A = Arrays.stream(sc.nextLine().split(" ")).mapToInt(Integer::parseInt).toArray();
		int[] B = Arrays.stream(sc.nextLine().split(" ")).mapToInt(Integer::parseInt).toArray();
		sc.close();
		System.out.println(IntStream.range(0, n).filter(i -> A[i] == B[i]).count());
	}
}
```
###### 終了判定
```java
import java.util.*;

public class Main {
	public static void main(String[] args) {
		Scanner sc = new Scanner(System.in);
		int n = Integer.parseInt(sc.nextLine());
		int[] A = Arrays.stream(sc.nextLine().split(" ")).mapToInt(Integer::parseInt).toArray();
		sc.close();
		int s = 0;
		for (int i = 0; i < n; i++) {
			if (A[i] % 2 != 0) break;
			s += A[i];
		}
		System.out.println(s);
	}
}
```
###### 終了判定2
```java
import java.util.*;

public class Main {
	public static void main(String[] args) {
		Scanner sc = new Scanner(System.in);
		int n = sc.nextInt();
		int k = sc.nextInt();
		sc.close();
		int m = 0;
		while ((n << m) < k) m++;
		System.out.println(m);
	}
}
```
- - -
##### JavaScript
###### けた数の測定
```js
const n = Number(require("fs").readFileSync("/dev/stdin", "utf8"));
if (n < 10) console.log(1);
else if (n < 100) console.log(2);
else console.log(3);
```
###### 足したり引いたり
```js
const [n, a, b] = require("fs").readFileSync("/dev/stdin", "utf8").split(' ').map(Number);
console.log([n + a + b, n + a - b, n - a + b, n - a - b].every(_ => _) ? "NO" : "YES");
```
###### 同値判定
```js
const [N, A, B] = require("fs").readFileSync("/dev/stdin", "utf8").trim().split('\n').map(s => s.split(' ').map(Number));
const n = N[0];
console.log(Array(n).fill(0).filter((_, i) => A[i] === B[i]).length);
```
###### 終了判定
```js
const [N, A] = require("fs").readFileSync("/dev/stdin", "utf8").trim().split('\n').map(s => s.split(' ').map(Number));
const n = N[0];
let s = 0;
for (var i = 0; i < n; i++) {
	if (A[i] % 2 !== 0) break;
	s += A[i];
}
console.log(s);
```
###### 終了判定2
```js
const [n, k] = require("fs").readFileSync("/dev/stdin", "utf8").split(' ').map(Number);
let m = 0;
while ((n << m) < k) m++;
console.log(m);
```
- - -
##### Kotlin
###### けた数の測定
```kotlin
fun main() {
	val n = readLine()!!.toInt()
	if (n < 10) println(1)
	else if (n < 100) println(2)
	else println(3)
}
```
###### 足したり引いたり
```kotlin
fun main() {
	val (n, a, b) = readLine()!!.split(' ').map { it.toInt() }
	println(if (arrayOf(n + a + b, n + a - b, n - a + b, n - a - b).any { it == 0 }) "YES" else "NO")
}
```
###### 同値判定
```kotlin
fun main() {
	val n = readLine()!!.toInt()
	val A = readLine()!!.split(' ').map { it.toInt() }
	val B = readLine()!!.split(' ').map { it.toInt() }
	println((0 until n).filter { A[it] == B[it] }.count())
}
```
###### 終了判定
```kotlin
fun main() {
	val n = readLine()!!.toInt()
	val A = readLine()!!.split(' ').map { it.toInt() }
	var s = 0
	for (i in 0 until n) {
		if (A[i] % 2 != 0) break
		s += A[i]
	}
	println(s)
}
```
###### 終了判定2
```kotlin
fun main() {
	val (n, k) = readLine()!!.split(' ').map { it.toInt() }
	var m = 0
	while ((n shl m) < k) m++
	println(m)
}
```
- - -
##### PHP
###### けた数の測定
```php
<?php
	$n = intval(fgets(STDIN));
	if ($n < 10) echo 1, PHP_EOL;
	elseif ($n < 100) echo 2, PHP_EOL;
	else echo 3, PHP_EOL;
?>
```
###### 足したり引いたり
```php
<?php
	[$n, $a, $b] = array_map("intval", explode(' ', fgets(STDIN)));
	echo $n + $a + $b && $n + $a - $b && $n - $a + $b && $n - $a - $b ? "NO" : "YES", PHP_EOL;
?>
```
###### 同値判定
```php
<?php
	$n = intval(fgets(STDIN));
	$A = array_map("intval", explode(' ', fgets(STDIN)));
	$B = array_map("intval", explode(' ', fgets(STDIN)));
	echo count(array_filter(range(0, $n - 1), fn($i) => $A[$i] === $B[$i])), PHP_EOL;
?>
```
###### 終了判定
```php
<?php
	$n = intval(fgets(STDIN));
	$A = array_map("intval", explode(' ', fgets(STDIN)));
	$s = 0;
	for ($i = 0; $i < $n; $i++) {
		if ($A[$i] % 2 !== 0) break;
		$s += $A[$i];
	}
	echo $s, PHP_EOL;
?>
```
###### 終了判定2
```php
<?php
	[$n, $k] = array_map("intval", explode(' ', fgets(STDIN)));
	$m = 0;
	while (($n << $m) < $k) $m++;
	echo $m, PHP_EOL;
?>
```
- - -
##### Perl
###### けた数の測定
```pl
my $n = int(<STDIN>);
if ($n < 10) {
    print 1, $/;
} elsif ($n < 100) {
    print 2, $/;
} else {
    print 3, $/;
}
```
###### 足したり引いたり
```pl
my ($n, $a, $b) = map { int($_) } split ' ', <STDIN>;
print $n + $a + $b && $n + $a - $b && $n - $a + $b && $n - $a - $b ? "NO" : "YES", $/;
```
###### 同値判定
```pl
my $n = int(<STDIN>);
my @A = map { int($_) } split ' ', <STDIN>;
my @B = map { int($_) } split ' ', <STDIN>;
my $c = 0;
for (my $i = 0; $i < $n; $i++) {
	$c++ if $A[$i] == $B[$i];
}
print "$c$/";
```
###### 終了判定
```pl
my $n = int(<STDIN>);
my @A = map { int($_) } split ' ', <STDIN>;
my $s = 0;
for (my $i = 0; $i < $n; $i++) {
	last if $A[$i] % 2;
	$s += $A[$i];
}
print "$s$/";
```
###### 終了判定2
```pl
my ($n, $k) = map { int($_) } split ' ', <STDIN>;
my $m = 0;
while (($n << $m) < $k) {
	$m++;
}
print "$m$/";
```
- - -
##### Python3
###### けた数の測定
```py
n = int(input())
if n < 10:
	print(1)
elif n < 100:
	print(2)
else:
	print(3)
```
###### 足したり引いたり
```py
n, a, b = map(int, input().split())
print("NO" if all([n + a + b, n + a - b, n - a + b, n - a - b]) else "YES")
```
###### 同値判定
```py
n = int(input())
A = list(map(int, input().split()))
B = list(map(int, input().split()))
print(sum(a == b for a, b in zip(A, B)))
```
###### 終了判定
```py
n = int(input())
A = list(map(int, input().split()))
s = 0
for i in range(n):
	if A[i] % 2:
		break
	s += A[i]
print(s)
```
###### 終了判定2
```py
n, k = map(int, input().split())
m = 0
while (n << m) < k:
	m += 1
print(m)
```
- - -
##### Ruby
###### けた数の測定
```rb
N = gets.to_i
if N < 10
	p 1
elsif N < 100
	p 2
else
	p 3
end
```
###### 足したり引いたり
```rb
n, a, b = gets.split.map(&:to_i)
puts [n + a + b, n + a - b, n - a + b, n - a - b].any? { |x| x == 0 } ? "YES" : "NO"
```
###### 同値判定
```rb
N = gets.to_i
A = gets.split.map(&:to_i)
B = gets.split.map(&:to_i)
p N.times.filter { |i| A[i] == B[i] }.size
```
###### 終了判定
```rb
N = gets.to_i
A = gets.split.map(&:to_i)
s = 0
N.times do |i|
	if A[i] % 2 != 0
		break
	end
	s += A[i]
end
p s
```
###### 終了判定2
```rb
N, K = gets.split.map(&:to_i)
m = 0
while (N << m) < K do
	m += 1
end
p m
```
- - -
##### Scala
###### けた数の測定
```scala
import scala.io.StdIn._

object Main extends App{
	val n = readInt()
	if (n < 10) println(1)
	else if (n < 100) println(2)
	else println(3)
}
```
###### 足したり引いたり
```scala
import scala.io.StdIn._

object Main extends App{
	val Array(n, a, b) = readLine().split(' ').map { _.toInt }
	println(if (Array(n + a + b, n + a - b, n - a + b, n - a - b).exists(_ == 0)) "YES" else "NO")
}
```
###### 同値判定
```scala
import scala.io.StdIn._

object Main extends App{
	val n = readInt()
	val A = readLine().split(' ').map { _.toInt }
	val B = readLine().split(' ').map { _.toInt }
	println((0 until n).count(i => A(i) == B(i)))
}
```
###### 終了判定
```scala
import scala.io.StdIn._

object Main extends App{
	val n = readInt()
	val A = readLine().split(' ').map { _.toInt }
	var s = 0
	var i = 0
	while (i < n && A(i) % 2 == 0){
		s += A(i)
		i += 1
	}
	println(s)
}
```
###### 終了判定2
```scala
import scala.io.StdIn._

object Main extends App{
	val Array(n, k) = readLine().split(' ').map { _.toInt }
	var m = 0
	while ((n << m) < k) m += 1
	println(m)
}
```
- - -
##### Swift
###### けた数の測定
```swift
let n = Int(readLine()!)!
if n < 10 {
	print(1)
} else if n < 100 {
	print(2)
} else {
	print(3)
}
```
###### 足したり引いたり
```swift
let nab = readLine()!.split(separator: " ").compactMap { Int($0) }
let (n, a, b) = (nab[0], nab[1], nab[2])
print([n + a + b, n + a - b, n - a + b, n - a - b].contains(0) ? "YES" : "NO")
```
###### 同値判定
```swift
let n = Int(readLine()!)!
let A = readLine()!.split(separator: " ").compactMap { Int($0) }
let B = readLine()!.split(separator: " ").compactMap { Int($0) }
print((0..<n).filter { A[$0] == B[$0] }.count)
```
###### 終了判定
```swift
let n = Int(readLine()!)!
let A = readLine()!.split(separator: " ").compactMap { Int($0) }
var s = 0
for i in 0..<n {
	if A[i] % 2 != 0 {
		break
	}
	s += A[i]
}
print(s)
```
###### 終了判定2
```swift
let nk = readLine()!.split(separator: " ").compactMap { Int($0) }
let (n, k) = (nk[0], nk[1])
var m = 0
while (n << m) < k {
	m += 1
}
print(m)
```