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

paizaラーニングレベルアップ問題集の【条件分岐メニュー】をやってみました。
- - -
##### 問題
###### AND
https://paiza.jp/works/mondai/conditions_branch/conditions_branch__bool_step1
###### 大文字判定
https://paiza.jp/works/mondai/conditions_branch/conditions_branch__bool_step2
###### OR
https://paiza.jp/works/mondai/conditions_branch/conditions_branch__bool_step3
###### NOT
https://paiza.jp/works/mondai/conditions_branch/conditions_branch__bool_step4
###### AND+NOT
https://paiza.jp/works/mondai/conditions_branch/conditions_branch__bool_step5
###### AND+OR
https://paiza.jp/works/mondai/conditions_branch/conditions_branch__bool_boss
- - -
大文字判定は、
- 文字$c$が`A`以上`Z`以下か
つまり
- 文字$c$が`A`以上、かつ、文字$c$が`Z`以下

と書くことができます（一部言語では明示的に文字コードに変換する必要あり）。
- - -
##### C
###### AND
```c
#include <stdio.h>

int main() {
	int a, b;
	scanf("%d %d", &a, &b);
	if (a >= 10 && b >= 10) {
		puts("YES");
	} else {
		puts("NO");
	}
	return 0;
}
```
```c
#include <stdio.h>

int main() {
	int a, b;
	scanf("%d %d", &a, &b);
	puts(a >= 10 && b >= 10 ? "YES" : "NO");
	return 0;
}
```
###### 大文字判定
```c
#include <stdio.h>

int main() {
	char c;
	scanf("%c", &c);
	if ('A' <= c && c <= 'Z') {
		puts("YES");
	} else {
		puts("NO");
	}
	return 0;
}
```
```c
#include <stdio.h>
#include <ctype.h>

int main() {
	puts(isupper(getchar()) ? "YES" : "NO");
	return 0;
}
```
###### OR
```c
#include <stdio.h>

int main() {
	int a, b;
	scanf("%d %d", &a, &b);
	if (a >= 10 || b >= 10) {
		puts("YES");
	} else {
		puts("NO");
	}
	return 0;
}
```
```c
#include <stdio.h>

int main() {
	int a, b;
	scanf("%d %d", &a, &b);
	puts(a >= 10 || b >= 10 ? "YES" : "NO");
	return 0;
}
```
###### NOT
```c
#include <stdio.h>

int main() {
	int x;
	scanf("%d", &x);
	if (!(x >= 10)) {
		puts("YES");
	} else {
		puts("NO");
	}
	return 0;
}
```
```c
#include <stdio.h>

int main() {
	int x;
	scanf("%d", &x);
	puts(!(x >= 10) ? "YES" : "NO");
	return 0;
}
```
###### AND+NOT
```c
#include <stdio.h>

int main() {
	int a, b;
	scanf("%d %d", &a, &b);
	if (a >= 10 && !(b >= 10)) {
		puts("YES");
	} else {
		puts("NO");
	}
	return 0;
}
```
```c
#include <stdio.h>

int main() {
	int a, b;
	scanf("%d %d", &a, &b);
	puts(a >= 10 && !(b >= 10) ? "YES" : "NO");
	return 0;
}
```
###### AND+OR
```c
#include <stdio.h>

int main() {
	int x, y, z;
	scanf("%d %d %d", &x, &y, &z);
	if (x >= 10 && y >= 10 || z >= 10) {
		puts("YES");
	} else {
		puts("NO");
	}
	return 0;
}
```
```c
#include <stdio.h>

int main() {
	int x, y, z;
	scanf("%d %d %d", &x, &y, &z);
	puts(x >= 10 && y >= 10 || z >= 10 ? "YES" : "NO");
	return 0;
}
```
- - -
##### C++
###### AND
```cpp
#include <iostream>
using namespace std;

int main() {
	int a, b;
	cin >> a >> b;
	if (a >= 10 && b >= 10) {
		cout << "YES" << endl;
	} else {
		cout << "NO" << endl;
	}
	return 0;
}
```
```cpp
#include <iostream>
using namespace std;

int main() {
	int a, b;
	cin >> a >> b;
	cout << (a >= 10 && b >= 10 ? "YES" : "NO") << endl;
	return 0;
}
```
###### 大文字判定
```cpp
#include <iostream>
using namespace std;

int main() {
	char c;
	cin >> c;
	if ('A' <= c && c <= 'Z') {
		cout << "YES" << endl;
	} else {
		cout << "NO" << endl;
	}
	return 0;
}
```
```cpp
#include <iostream>
using namespace std;

int main() {
	char c;
	cin >> c;
	cout << (isupper(c) ? "YES" : "NO") << endl;
	return 0;
}
```
###### OR
```cpp
#include <iostream>
using namespace std;

int main() {
	int a, b;
	cin >> a >> b;
	if (a >= 10 || b >= 10) {
		cout << "YES" << endl;
	} else {
		cout << "NO" << endl;
	}
	return 0;
}
```
```cpp
#include <iostream>
using namespace std;

int main() {
	int a, b;
	cin >> a >> b;
	cout << (a >= 10 || b >= 10 ? "YES" : "NO") << endl;
	return 0;
}
```
###### NOT
```cpp
#include <iostream>
using namespace std;

int main() {
	int x;
	cin >> x;
	if (!(x >= 10)) {
		cout << "YES" << endl;
	} else {
		cout << "NO" << endl;
	}
	return 0;
}
```
```cpp
#include <iostream>
using namespace std;

int main() {
	int x;
	cin >> x;
	cout << (!(x >= 10) ? "YES" : "NO") << endl;
	return 0;
}
```
###### AND+NOT
```cpp
#include <iostream>
using namespace std;

int main() {
	int a, b;
	cin >> a >> b;
	if (a >= 10 && !(b >= 10)) {
		cout << "YES" << endl;
	} else {
		cout << "NO" << endl;
	}
	return 0;
}
```
```cpp
#include <iostream>
using namespace std;

int main() {
	int a, b;
	cin >> a >> b;
	cout << (a >= 10 && !(b >= 10) ? "YES" : "NO") << endl;
	return 0;
}
```
###### AND+OR
```cpp
#include <iostream>
using namespace std;

int main() {
	int x, y, z;
	cin >> x >> y >> z;
	if (x >= 10 && y >= 10 || z >= 10) {
		cout << "YES" << endl;
	} else {
		cout << "NO" << endl;
	}
	return 0;
}
```
```cpp
#include <iostream>
using namespace std;

int main() {
	int x, y, z;
	cin >> x >> y >> z;
	cout << (x >= 10 && y >= 10 || z >= 10 ? "YES" : "NO") << endl;
	return 0;
}
```
- - -
##### C#
###### AND
```cs
using System;

class Program
{
	public static void Main()
	{
		int[] ab = Array.ConvertAll(Console.ReadLine().Split(), int.Parse);
		int a = ab[0];
		int b = ab[1];
		if (a >= 10 && b >= 10) {
			Console.WriteLine("YES");
		} else {
			Console.WriteLine("NO");
		}
	}
}
```
```cs
using System;

class Program
{
	public static void Main()
	{
		int[] ab = Array.ConvertAll(Console.ReadLine().Split(), int.Parse);
		int a = ab[0];
		int b = ab[1];
		Console.WriteLine(a >= 10 && b >= 10 ? "YES" : "NO");
	}
}
```
###### 大文字判定
```cs
using System;

class Program
{
	public static void Main()
	{
		char c = Console.ReadLine()[0];
		if ('A' <= c && c <= 'Z') {
			Console.WriteLine("YES");
		} else {
			Console.WriteLine("NO");
		}
	}
}
```
```cs
using System;

class Program
{
	public static void Main()
	{
		Console.WriteLine(char.IsUpper(Console.ReadLine()[0]) ? "YES" : "NO");
	}
}
```
###### OR
```cs
using System;

class Program
{
	public static void Main()
	{
		int[] ab = Array.ConvertAll(Console.ReadLine().Split(), int.Parse);
		int a = ab[0];
		int b = ab[1];
		if (a >= 10 || b >= 10) {
			Console.WriteLine("YES");
		} else {
			Console.WriteLine("NO");
		}
	}
}
```
```cs
using System;

class Program
{
	public static void Main()
	{
		int[] ab = Array.ConvertAll(Console.ReadLine().Split(), int.Parse);
		int a = ab[0];
		int b = ab[1];
		Console.WriteLine(a >= 10 || b >= 10 ? "YES" : "NO");
	}
}
```
###### NOT
```cs
using System;

class Program
{
	public static void Main()
	{
		int x = int.Parse(Console.ReadLine());
		if (!(x >= 10)) {
			Console.WriteLine("YES");
		} else {
			Console.WriteLine("NO");
		}
	}
}
```
```cs
using System;

class Program
{
	public static void Main()
	{
		Console.WriteLine(!(int.Parse(Console.ReadLine()) >= 10) ? "YES" : "NO");
	}
}
```
###### AND+NOT
```cs
using System;

class Program
{
	public static void Main()
	{
		int[] ab = Array.ConvertAll(Console.ReadLine().Split(), int.Parse);
		int a = ab[0];
		int b = ab[1];
		if (a >= 10 && !(b >= 10)) {
			Console.WriteLine("YES");
		} else {
			Console.WriteLine("NO");
		}
	}
}
```
```cs
using System;

class Program
{
	public static void Main()
	{
		int[] ab = Array.ConvertAll(Console.ReadLine().Split(), int.Parse);
		int a = ab[0];
		int b = ab[1];
		Console.WriteLine(a >= 10 && !(b >= 10) ? "YES" : "NO");
	}
}
```
###### AND+OR
```cs
using System;

class Program
{
	public static void Main()
	{
		int[] xyz = Array.ConvertAll(Console.ReadLine().Split(), int.Parse);
		int x = xyz[0];
		int y = xyz[1];
		int z = xyz[2];
		if (x >= 10 && y >= 10 || z >= 10) {
			Console.WriteLine("YES");
		} else {
			Console.WriteLine("NO");
		}
	}
}
```
```cs
using System;

class Program
{
	public static void Main()
	{
		int[] xyz = Array.ConvertAll(Console.ReadLine().Split(), int.Parse);
		int x = xyz[0];
		int y = xyz[1];
		int z = xyz[2];
		Console.WriteLine(x >= 10 && y >= 10 || z >= 10 ? "YES" : "NO");
	}
}
```
- - -
##### Go
###### AND
```go
package main
import "fmt"

func main() {
	var a, b int
	fmt.Scan(&a, &b)
	if a >= 10 && b >= 10 {
		fmt.Println("YES")
	} else {
		fmt.Println("NO")
	}
}
```
###### 大文字判定
```go
package main
import "fmt"

func main() {
	var c rune
	fmt.Scanf("%c", &c)
	if 'A' <= c && c <= 'Z' {
		fmt.Println("YES")
	} else {
		fmt.Println("NO")
	}
}
```
```go
package main

import (
	"fmt"
	"unicode"
)

func main() {
	var c rune
	fmt.Scanf("%c", &c)
	if unicode.IsUpper(c) {
		fmt.Println("YES")
	} else {
		fmt.Println("NO")
	}
}
```
###### OR
```go
package main
import "fmt"

func main() {
	var a, b int
	fmt.Scan(&a, &b)
	if a >= 10 || b >= 10 {
		fmt.Println("YES")
	} else {
		fmt.Println("NO")
	}
}
```
###### NOT
```go
package main
import "fmt"

func main() {
	var x int
	fmt.Scan(&x)
	if !(x >= 10) {
		fmt.Println("YES")
	} else {
		fmt.Println("NO")
	}
}
```
###### AND+NOT
```go
package main
import "fmt"

func main() {
	var a, b int
	fmt.Scan(&a, &b)
	if a >= 10 && !(b >= 10) {
		fmt.Println("YES")
	} else {
		fmt.Println("NO")
	}
}
```
###### AND+OR
```go
package main
import "fmt"

func main() {
	var x, y, z int
	fmt.Scan(&x, &y, &z)
	if x >= 10 && y >= 10 || z >= 10 {
		fmt.Println("YES")
	} else {
		fmt.Println("NO")
	}
}
```
- - -
##### Java
###### AND
```java
import java.util.*;

public class Main {
	public static void main(String[] args) {
		Scanner sc = new Scanner(System.in);
		int a = sc.nextInt();
		int b = sc.nextInt();
		sc.close();
		if (a >= 10 && b >= 10) {
			System.out.println("YES");
		} else {
			System.out.println("NO");
		}
	}
}
```
```java
import java.util.*;

public class Main {
	public static void main(String[] args) {
		Scanner sc = new Scanner(System.in);
		int a = sc.nextInt();
		int b = sc.nextInt();
		sc.close();
		System.out.println(a >= 10 && b >= 10 ? "YES" : "NO");
	}
}
```
###### 大文字判定
```java
public class Main {
	public static void main(String[] args) throws java.io.IOException {
		char c = (char)System.in.read();
		if ('A' <= c && c <= 'Z') {
			System.out.println("YES");
		} else {
			System.out.println("NO");
		}
	}
}
```
```java
public class Main {
	public static void main(String[] args) throws java.io.IOException {
		System.out.println(Character.isUpperCase((char)System.in.read()) ? "YES" : "NO");
	}
}
```
###### OR
```java
import java.util.*;

public class Main {
	public static void main(String[] args) {
		Scanner sc = new Scanner(System.in);
		int a = sc.nextInt();
		int b = sc.nextInt();
		sc.close();
		if (a >= 10 || b >= 10) {
			System.out.println("YES");
		} else {
			System.out.println("NO");
		}
	}
}
```
```java
import java.util.*;

public class Main {
	public static void main(String[] args) {
		Scanner sc = new Scanner(System.in);
		int a = sc.nextInt();
		int b = sc.nextInt();
		sc.close();
		System.out.println(a >= 10 || b >= 10 ? "YES" : "NO");
	}
}
```
###### NOT
```java
import java.util.*;

public class Main {
	public static void main(String[] args) {
		Scanner sc = new Scanner(System.in);
		int x = sc.nextInt();
		sc.close();
		if (!(x >= 10)) {
			System.out.println("YES");
		} else {
			System.out.println("NO");
		}
	}
}
```
```java
import java.util.*;

public class Main {
	public static void main(String[] args) {
		Scanner sc = new Scanner(System.in);
		System.out.println(!(sc.nextInt() >= 10) ? "YES" : "NO");
		sc.close();
	}
}
```
###### AND+NOT
```java
import java.util.*;

public class Main {
	public static void main(String[] args) {
		Scanner sc = new Scanner(System.in);
		int a = sc.nextInt();
		int b = sc.nextInt();
		sc.close();
		if (a >= 10 && !(b >= 10)) {
			System.out.println("YES");
		} else {
			System.out.println("NO");
		}
	}
}
```
```java
import java.util.*;

public class Main {
	public static void main(String[] args) {
		Scanner sc = new Scanner(System.in);
		int a = sc.nextInt();
		int b = sc.nextInt();
		sc.close();
		System.out.println(a >= 10 && !(b >= 10) ? "YES" : "NO");
		sc.close();
	}
}
```
###### AND+OR
```java
import java.util.*;

public class Main {
	public static void main(String[] args) {
		Scanner sc = new Scanner(System.in);
		int x = sc.nextInt();
		int y = sc.nextInt();
		int z = sc.nextInt();
		sc.close();
		if (x >= 10 && y >= 10 || z >= 10) {
			System.out.println("YES");
		} else {
			System.out.println("NO");
		}
	}
}
```
```java
import java.util.*;

public class Main {
	public static void main(String[] args) {
		Scanner sc = new Scanner(System.in);
		int x = sc.nextInt();
		int y = sc.nextInt();
		int z = sc.nextInt();
		sc.close();
		System.out.println(x >= 10 && y >= 10 || z >= 10 ? "YES" : "NO");
	}
}
```
- - -
##### JavaScript
###### AND
```js
const [a, b] = require("fs").readFileSync("/dev/stdin", "utf8").split(' ').map(Number);
if (a >= 10 && b >= 10) {
	console.log("YES");
} else {
	console.log("NO");
}
```
```js
const [a, b] = require("fs").readFileSync("/dev/stdin", "utf8").split(' ').map(Number);
console.log(a >= 10 && b >= 10 ? "YES" : "NO");
```
###### 大文字判定
```js
const c = require("fs").readFileSync("/dev/stdin", "utf8")[0];
if ('A' <= c && c <= 'Z') {
	console.log("YES");
} else {
	console.log("NO");
}
```
###### OR
```js
const [a, b] = require("fs").readFileSync("/dev/stdin", "utf8").split(' ').map(Number);
if (a >= 10 || b >= 10) {
	console.log("YES");
} else {
	console.log("NO");
}
```
```js
const [a, b] = require("fs").readFileSync("/dev/stdin", "utf8").split(' ').map(Number);
console.log(a >= 10 || b >= 10 ? "YES" : "NO");
```
###### NOT
```js
const x = Number(require("fs").readFileSync("/dev/stdin", "utf8"));
if (!(x >= 10)) {
	console.log("YES");
} else {
	console.log("NO");
}
```
```js
console.log(!(Number(require("fs").readFileSync("/dev/stdin", "utf8")) >= 10) ? "YES" : "NO");
```
###### AND+NOT
```js
const [a, b] = require("fs").readFileSync("/dev/stdin", "utf8").split(' ').map(Number);
if (a >= 10 && !(b >= 10)) {
	console.log("YES");
} else {
	console.log("NO");
}
```
```js
const [a, b] = require("fs").readFileSync("/dev/stdin", "utf8").split(' ').map(Number);
console.log(a >= 10 && !(b >= 10) ? "YES" : "NO");
```
###### AND+OR
```js
const [x, y, z] = require("fs").readFileSync("/dev/stdin", "utf8").split(' ').map(Number);
if (x >= 10 && y >= 10 || z >= 10) {
	console.log("YES");
} else {
	console.log("NO");
}
```
```js
const [x, y, z] = require("fs").readFileSync("/dev/stdin", "utf8").split(' ').map(Number);
console.log(x >= 10 && y >= 10 || z >= 10 ? "YES" : "NO");
```
- - -
##### Kotlin
###### AND
```kotlin
fun main() {
	val (a, b) = readLine()!!.split(' ').map { it.toInt() }
	if (a >= 10 && b >= 10) {
		println("YES")
	} else {
		println("NO")
	}
}
```
```kotlin
fun main() {
	val (a, b) = readLine()!!.split(' ').map { it.toInt() }
	println(if (a >= 10 && b >= 10) "YES" else "NO")
}
```
###### 大文字判定
```kotlin
fun main() {
	val c = readLine()!![0]
	if ('A' <= c && c <= 'Z') {
		println("YES")
	} else {
		println("NO")
	}
}
```
```kotlin
fun main() {
	println(if (System.`in`.read().toChar().isUpperCase()) "YES" else "NO")
}
```
###### OR
```kotlin
fun main() {
	val (a, b) = readLine()!!.split(' ').map { it.toInt() }
	if (a >= 10 || b >= 10) {
		println("YES")
	} else {
		println("NO")
	}
}
```
```kotlin
fun main() {
	val (a, b) = readLine()!!.split(' ').map { it.toInt() }
	println(if (a >= 10 || b >= 10) "YES" else "NO")
}
```
###### NOT
```kotlin
fun main() {
	val a = readLine()!!.toInt()
	if (!(a >= 10)) {
		println("YES")
	} else {
		println("NO")
	}
}
```
```kotlin
import java.util.*

fun main() {
	val sc = Scanner(System.`in`)
	println(if (!(sc.nextInt() >= 10)) "YES" else "NO")
	sc.close()
}
```
###### AND+NOT
```kotlin
fun main() {
	val (a, b) = readLine()!!.split(' ').map { it.toInt() }
	if (a >= 10 && !(b >= 10)) {
		println("YES")
	} else {
		println("NO")
	}
}
```
```kotlin
fun main() {
	val (a, b) = readLine()!!.split(' ').map { it.toInt() }
	println(if (a >= 10 && !(b >= 10)) "YES" else "NO")
}
```
###### AND+OR
```kotlin
fun main() {
	val (x, y, z) = readLine()!!.split(' ').map { it.toInt() }
	if (x >= 10 && y >= 10 || z >= 10) {
		println("YES")
	} else {
		println("NO")
	}
}
```
```kotlin
fun main() {
	val (x, y, z) = readLine()!!.split(' ').map { it.toInt() }
	println(if (x >= 10 && y >= 10 || z >= 10) "YES" else "NO")
}
```
- - -
##### PHP
###### AND
```php
<?php
	[$a, $b] = array_map("intval", explode(' ', fgets(STDIN)));
	if ($a >= 10 && $b >= 10) {
		echo "YES";
	} else {
		echo "NO";
	}
	echo PHP_EOL;
?>
```
```php
<?php
	[$a, $b] = array_map("intval", explode(' ', fgets(STDIN)));
	echo $a >= 10 && $b >= 10 ? "YES" : "NO", PHP_EOL;
?>
```
###### 大文字判定
```php
<?php
	$c = fgets(STDIN)[0];
	if ('A' <= $c && $c <= 'Z') {
		echo "YES";
	} else {
		echo "NO";
	}
	echo PHP_EOL;
?>
```
```php
<?php
	echo ctype_upper(fgets(STDIN)[0]) ? "YES" : "NO", PHP_EOL;
?>
```
###### OR
```php
<?php
	[$a, $b] = array_map("intval", explode(' ', fgets(STDIN)));
	if ($a >= 10 || $b >= 10) {
		echo "YES";
	} else {
		echo "NO";
	}
	echo PHP_EOL;
?>
```
```php
<?php
	[$a, $b] = array_map("intval", explode(' ', fgets(STDIN)));
	echo $a >= 10 || $b >= 10 ? "YES" : "NO", PHP_EOL;
?>
```
###### NOT
```php
<?php
	$x = intval(fgets(STDIN));
	if (!($x >= 10)) {
		echo "YES";
	} else {
		echo "NO";
	}
	echo PHP_EOL;
?>
```
```php
<?php
	echo !(intval(fgets(STDIN)) >= 10) ? "YES" : "NO", PHP_EOL;
?>
```
###### AND+NOT
```php
<?php
	[$a, $b] = array_map("intval", explode(' ', fgets(STDIN)));
	if ($a >= 10 && !($b >= 10)) {
		echo "YES";
	} else {
		echo "NO";
	}
	echo PHP_EOL;
?>
```
```php
<?php
	[$a, $b] = array_map("intval", explode(' ', fgets(STDIN)));
	echo $a >= 10 && !($b >= 10) ? "YES" : "NO", PHP_EOL;
?>
```
###### AND+OR
```php
<?php
	[$x, $y, $z] = array_map("intval", explode(' ', fgets(STDIN)));
	if ($x >= 10 && $y >= 10 || $z >= 10) {
		echo "YES";
	} else {
		echo "NO";
	}
	echo PHP_EOL;
?>
```
```php
<?php
	[$x, $y, $z] = array_map("intval", explode(' ', fgets(STDIN)));
	echo $x >= 10 && $y >= 10 || $z >= 10 ? "YES" : "NO", PHP_EOL;
?>
```
- - -
##### Perl
###### AND
```pl
my ($a, $b) = map { int($_) } split ' ', <STDIN>;
if ($a >= 10 && $b >= 10) {
	print "YES$/";
} else {
	print "NO$/";
}
```
```pl
my ($a, $b) = map { int($_) } split ' ', <STDIN>;
print $a >= 10 && $b >= 10 ? "YES" : "NO", $/;
```
###### 大文字判定
```pl
my $c = getc();
if ('A' le $c && $c le 'Z') {
	print "YES$/";
} else {
	print "NO$/";
}
```
```pl
print getc(STDIN) =~ /[A-Z]/ ? "YES" : "NO", $/;
```
###### OR
```pl
my ($a, $b) = map { int($_) } split ' ', <STDIN>;
if ($a >= 10 || $b >= 10) {
	print "YES$/";
} else {
	print "NO$/";
}
```
```pl
my ($a, $b) = map { int($_) } split ' ', <STDIN>;
print $a >= 10 || $b >= 10 ? "YES" : "NO", $/;
```
###### NOT
```pl
my $x = int(<STDIN>);
if (!($x >= 10)) {
	print "YES$/";
} else {
	print "NO$/";
}
```
```pl
print !(int(<STDIN>) >= 10) ? "YES" : "NO", $/;
```
###### AND+NOT
```pl
my ($a, $b) = map { int($_) } split ' ', <STDIN>;
if ($a >= 10 && !($b >= 10)) {
	print "YES$/";
} else {
	print "NO$/";
}
```
```pl
my ($a, $b) = map { int($_) } split ' ', <STDIN>;
print $a >= 10 && !($b >= 10) ? "YES" : "NO", $/;
```
###### AND+OR
```pl
my ($x, $y, $z) = map { int($_) } split ' ', <STDIN>;
if ($x >= 10 && $y >= 10 || $z >= 10) {
	print "YES$/";
} else {
	print "NO$/";
}
```
```pl
my ($x, $y, $z) = map { int($_) } split ' ', <STDIN>;
print $x >= 10 && $y >= 10 || $z >= 10 ? "YES" : "NO", $/;
```
- - -
##### Python3
###### AND
```py
a, b = map(int, input().split())
if a >= 10 and b >= 10:
	print("YES")
else:
	print("NO")
```
```py
a, b = map(int, input().split())
print("YES" if a >= 10 and b >= 10 else "NO")
```
###### 大文字判定
```py
c = input()[0]
if 'A' <= c and c <= 'Z':
	print("YES")
else:
	print("NO")
```
```py
print("YES" if input().isupper() else "NO")
```
###### OR
```py
a, b = map(int, input().split())
if a >= 10 or b >= 10:
	print("YES")
else:
	print("NO")
```
```py
a, b = map(int, input().split())
print("YES" if a >= 10 or b >= 10 else "NO")
```
###### NOT
```py
x = int(input())
if not x >= 10:
	print("YES")
else:
	print("NO")
```
```py
print("YES" if not int(input()) >= 10 else "NO")
```
###### AND+NOT
```py
a, b = map(int, input().split())
if a >= 10 and not b >= 10:
	print("YES")
else:
	print("NO")
```
```py
a, b = map(int, input().split())
print("YES" if a >= 10 and not b >= 10 else "NO")
```
###### AND+OR
```py
x, y, z = map(int, input().split())
if x >= 10 and y >= 10 or z >= 10:
	print("YES")
else:
	print("NO")
```
```py
x, y, z = map(int, input().split())
print("YES" if x >= 10 and y >= 10 or z >= 10 else "NO")
```
- - -
##### Ruby
###### AND
```rb
a, b = gets.split.map(&:to_i)
if a >= 10 && b >= 10
	puts "YES"
else
	puts "NO"
end
```
```rb
a, b = gets.split.map(&:to_i)
puts a >= 10 && b >= 10 ? "YES" : "NO"
```
###### 大文字判定
```rb
c = gets.chomp
if 'A' <= c && c <= 'Z'
	puts "YES"
else
	puts "NO"
end
```
```rb
puts gets.chomp =~ /[A-Z]/ ? "YES" : "NO"
```
###### OR
```rb
a, b = gets.split.map(&:to_i)
if a >= 10 || b >= 10
	puts "YES"
else
	puts "NO"
end
```
```rb
a, b = gets.split.map(&:to_i)
puts a >= 10 || b >= 10 ? "YES" : "NO"
```
###### NOT
```rb
x = gets.to_i
if !(x >= 10)
	puts "YES"
else
	puts "NO"
end
```
```rb
puts !(gets.to_i >= 10) ? "YES" : "NO"
```
###### AND+NOT
```rb
a, b = gets.split.map(&:to_i)
if a >= 10 && !(b >= 10)
	puts "YES"
else
	puts "NO"
end
```
```rb
a, b = gets.split.map(&:to_i)
puts a >= 10 && !(b >= 10) ? "YES" : "NO"
```
###### AND+OR
```rb
x, y, z = gets.split.map(&:to_i)
if x >= 10 && y >= 10 || z >= 10
	puts "YES"
else
	puts "NO"
end
```
```rb
x, y, z = gets.split.map(&:to_i)
puts x >= 10 && y >= 10 || z >= 10 ? "YES" : "NO"
```
- - -
##### Scala
###### AND
```scala
import scala.io.StdIn._

object Main extends App{
	val Array(a, b) = readLine().split(' ').map { _.toInt }
	if (a >= 10 && b >= 10) {
		println("YES")
	} else {
		println("NO")
	}
}
```
```scala
import scala.io.StdIn._

object Main extends App{
	val Array(a, b) = readLine().split(' ').map { _.toInt }
	println(if (a >= 10 && b >= 10) "YES" else "NO")
}
```
###### 大文字判定
```scala
import scala.io.StdIn._

object Main extends App{
	val c = readLine()(0)
	if ('A' <= c && c <= 'Z') {
		println("YES")
	} else {
		println("NO")
	}
}
```
```scala
object Main extends App{
	println(if (System.in.read().toChar.isUpper) "YES" else "NO")
}
```
###### OR
```scala
import scala.io.StdIn._

object Main extends App{
	val Array(a, b) = readLine().split(' ').map { _.toInt }
	if (a >= 10 || b >= 10) {
		println("YES")
	} else {
		println("NO")
	}
}
```
```scala
import scala.io.StdIn._

object Main extends App{
	val Array(a, b) = readLine().split(' ').map { _.toInt }
	println(if (a >= 10 || b >= 10) "YES" else "NO")
}
```
###### NOT
```scala
import scala.io.StdIn._

object Main extends App{
	val x = readInt()
	if (!(x >= 10)) {
		println("YES")
	} else {
		println("NO")
	}
}
```
```scala
import scala.io.StdIn._

object Main extends App{
	println(if (!(readInt() >= 10)) "YES" else "NO")
}
```
###### AND+NOT
```scala
import scala.io.StdIn._

object Main extends App{
	val Array(a, b) = readLine().split(' ').map { _.toInt }
	if (a >= 10 && !(b >= 10)) {
		println("YES")
	} else {
		println("NO")
	}
}
```
```scala
import scala.io.StdIn._

object Main extends App{
	val Array(a, b) = readLine().split(' ').map { _.toInt }
	println(if (a >= 10 && !(b >= 10)) "YES" else "NO")
}
```
###### AND+OR
```scala
import scala.io.StdIn._

object Main extends App{
	val Array(x, y, z) = readLine().split(' ').map { _.toInt }
	if (x >= 10 && y >= 10 || z >= 10) {
		println("YES")
	} else {
		println("NO")
	}
}
```
```scala
import scala.io.StdIn._

object Main extends App{
	val Array(x, y, z) = readLine().split(' ').map { _.toInt }
	println(if (x >= 10 && y >= 10 || z >= 10) "YES" else "NO")
}
```
- - -
##### Swift
###### AND
```swift
let ab = readLine()!.split(separator: " ").compactMap { Int($0) }
let (a, b) = (ab[0], ab[1])
if a >= 10 && b >= 10 {
	print("YES")
} else {
	print("NO")
}
```
```swift
let ab = readLine()!.split(separator: " ").compactMap { Int($0) }
let (a, b) = (ab[0], ab[1])
print(a >= 10 && b >= 10 ? "YES" : "NO")
```
###### 大文字判定
```swift
let c = Character(readLine()!)
if "A" <= c && c <= "Z" {
	print("YES")
} else {
	print("NO")
}
```
```swift
print(Character(readLine()!).isUppercase ? "YES" : "NO")
```
###### OR
```swift
let ab = readLine()!.split(separator: " ").compactMap { Int($0) }
let (a, b) = (ab[0], ab[1])
if a >= 10 || b >= 10 {
	print("YES")
} else {
	print("NO")
}
```
```swift
let ab = readLine()!.split(separator: " ").compactMap { Int($0) }
let (a, b) = (ab[0], ab[1])
print(a >= 10 || b >= 10 ? "YES" : "NO")
```
###### NOT
```swift
let x = Int(readLine()!)!
if !(x >= 10) {
	print("YES")
} else {
	print("NO")
}
```
```swift
print(!(Int(readLine()!)! >= 10) ? "YES" : "NO")
```
###### AND+NOT
```swift
let ab = readLine()!.split(separator: " ").compactMap { Int($0) }
let (a, b) = (ab[0], ab[1])
if a >= 10 && !(b >= 10) {
	print("YES")
} else {
	print("NO")
}
```
```swift
let ab = readLine()!.split(separator: " ").compactMap { Int($0) }
let (a, b) = (ab[0], ab[1])
print(a >= 10 && !(b >= 10) ? "YES" : "NO")
```
###### AND+OR
```swift
let xyz = readLine()!.split(separator: " ").compactMap { Int($0) }
let (x, y, z) = (xyz[0], xyz[1], xyz[2])
if x >= 10 && y >= 10 || z >= 10 {
	print("YES")
} else {
	print("NO")
}
```
```swift
let xyz = readLine()!.split(separator: " ").compactMap { Int($0) }
let (x, y, z) = (xyz[0], xyz[1], xyz[2])
print(x >= 10 && y >= 10 || z >= 10 ? "YES" : "NO")
```