AtCoderで始めるPython入門

# はじめに

<B>[AtCoder](https://atcoder.jp/)</B> では <B>AtCoder Beginner Contest</B>（<B>ABC</B>）が開催されており、<B>ABC-A問題</B> は <B>Python</B> の実装方法を知っていれば解ける問題が多くあります。ABC-A問題を解けるようになるために、本記事では実装方法を整理しました。

# 本記事について

本記事について説明します。

## 目的

本記事の目的は下記です。

:::note info
<B>Python</B> で <B>ABC-A問題</B> を概ね解けるようになる。
:::

## 注意事項

本記事の注意事項は下記の通りです。ご理解の程をよろしくお願い致します。

:::note warn
* 本記事は個人で作成した記事であり、AtCoder株式会社は作成に関与していません。
* ABC-A問題をすべて解けるようになる記事ではありません。
* 一部のマイナーバージョンで本記事とは異なる仕様があります。
* 体系的な Python を学習する記事ではありません。
:::

## 構成

各章は下記の構成です。

|章|章名|内容|
|:-:|:--|:--|
|第1章|[入出力処理](#第1章-入出力処理)|入出力処理を学べる|
|第2章|[演算](#第2章-演算)|演算を学べる|
|第3章|[代入文](#第3章-代入文)|代入文を学べる|
|第4章|[制御構文](#第4章-制御構文)|制御構文を学べる|
|第5章|[組み込み型](#第5章-組み込み型)|組み込み型を学べる|
|第6章|[組み込み関数](#第6章-組み込み関数)|組み込み関数を学べる|
|第7章|[関数定義](#第7章-関数定義)|関数定義を学べる|
|-|[付録](#付録)|Python の学習を深める情報を学べる|

各節項は下記の構成です。

|項目|内容|
|:--|:--|
|サンプルコード|問題から得られた知見と検証によって得られた知見を整理したコード|
|入力|サンプルコードの入力例|
|実行結果|サンプルコードの実行結果|
|解答例|AtCoder で <font color="#449d44"><B>AC</B></font> になったコード|

## バージョン / 言語

サンプルコードは Python の下記バージョンで動作することを確認しました。

```text
Python 3.11.4
```

解答例は AtCoder の下記言語で <font color="#449d44"><B>AC</B></font> になることを確認しました。

```text
Python (CPython 3.11.4)
```

## コーディングスタイル

本記事のコードは [pycodestyle](https://pypi.org/project/pycodestyle/) の下記バージョンでコーディングスタイルを確認しました。

```text
pycodestyle 2.13.0
```

## コードリポジトリ

本記事のコードは下記のリポジトリで公開しています。

* [GitHub - KoyanagiHitoshi/AtCoder-Python-Introduction](https://github.com/KoyanagiHitoshi/AtCoder-Python-Introduction)

## 参考

本記事は下記を参考にしました。

* [Python入門 AtCoder Programming Guide for beginners (APG4bPython) - AtCoder](https://atcoder.jp/contests/APG4bpython)
* [C++入門 AtCoder Programming Guide for beginners (APG4b) - AtCoder](https://atcoder.jp/contests/APG4b)
* [AtCoderに登録したら解くべき精選過去問10問をPythonで解いてみた](https://qiita.com/KoyanagiHitoshi/items/c5e82841b8d0f750851d)
* [AtCoderの問題を分類しました](https://zenn.dev/koyanagihitoshi?tab=books)

# 最後に

サービスを提供しているAtCoder株式会社と、交流している競技プログラマの方々に感謝を致します。

# 第1章 入出力処理

第1章では入出力処理について説明します。

## 1.1 出力

<b>キーポイント</b>

* 標準出力は`print`関数で出力する。
* 数値の出力は`print(数値)`で出力する。
* 変数の出力は`print(変数)`で出力する。
* 文字列の出力は`print("文字列")`で出力する。
* 文字列の出力/定義は文字列をダブルクォーテーション`"`、またはシングルクォーテーション`'`で囲う。
* print関数の区切り文字は`print(出力データ, sep="区切り文字")`で指定する。
* print関数の区切り文字を指定しない場合`print(出力データ)`、区切り文字は <b>半角スペース</b> となる。
* print関数の末尾文字は`print(出力データ, end="末尾文字")`で指定する。
* print関数の末尾文字を指定しない場合`print(出力データ)`、末尾文字は <b>改行</b> となる。

### 整数（int）

* **整数を出力する**

整数を出力する場合、`print(整数)`で出力する。

```python:サンプルコード：sample_1-1-1.py
print(10)
```

```text:実行結果
10
```

* **整数を変数に格納して出力する**

整数を変数に格納して出力する場合、`変数 = 整数`で変数を定義し、`print(変数)`で出力する。

```python:サンプルコード：sample_1-1-2.py
x = 20
print(x)
```

```text:実行結果
20
```

### 浮動小数点数（float）

* **浮動小数点数を出力する**

浮動小数点数を出力する場合、`print(浮動小数点数)`で出力する。

```python:サンプルコード：sample_1-1-3.py
print(2.9)
```

```text:実行結果
2.9
```

* **浮動小数点数を変数に格納して出力する**

浮動小数点数を変数に格納して出力する場合、`変数 = 浮動小数点数`で変数を定義し、`print(変数)`で出力する。

```python:サンプルコード：sample_1-1-4.py
x = 3.5
print(x)
```

```text:実行結果
3.5
```

### 文字列（str）

文字列の出力/定義は文字列をダブルクォーテーション`"`、またはシングルクォーテーション`'`で囲う。

* **文字列を出力する**

文字列を出力する場合、`print("文字列")` または `print('文字列')` で出力する。

```python:サンプルコード：sample_1-1-5.py
print("Hello World!")
```

```text:実行結果
Hello World!
```

* **文字列を変数に格納して出力する**

文字列を変数に格納して出力する場合、`変数 = "文字列"`で変数を定義し、`print(変数)`で出力する。

```python:サンプルコード：sample_1-1-6.py
x = "Hello World!"
print(x)
```

```text:実行結果
Hello World!
```

* **文字列を変数に格納し、変数のインデックスを指定して文字を出力する**

文字列を変数に格納し、変数のインデックスを指定して文字を出力する場合、`print(変数[インデックス])`で出力する。

```python:サンプルコード：sample_1-1-7.py
x = "Hello World!"
print(x[0])
```

```text:実行結果
H
```

```python:サンプルコード：sample_1-1-8.py
x = "Hello World!"
print(x[11])
```

```text:実行結果
!
```

### リスト（list）

* **1次元リストを出力する**

1次元リストを出力する場合、`print(リスト)`で出力する。

```python:サンプルコード：sample_1-1-9.py
x = [1, 2, 3, 4, 5]
print(x)
```

```text:実行結果
[1, 2, 3, 4, 5]
```

* **1次元リストの各要素を出力する**

1次元リストの各要素を出力する場合、`for 変数 in リスト:`でループ処理し、`print(変数)`で出力する。

```python:サンプルコード：sample_1-1-10.py
x = [1, 2, 3, 4, 5]
for i in x:
    print(i)
```

```text:実行結果
1
2
3
4
5
```

* **1次元リストのインデックス指定して各要素を出力する**

1次元リストのインデックス指定して各要素を出力する場合、`for 変数 in range(リストの長さ):`でループ処理し、`print(リスト[変数])`で出力する。

```python:サンプルコード：sample_1-1-11.py
x = [1, 2, 3, 4, 5]
for i in range(5):
    print(x[i])
```

```text:実行結果
1
2
3
4
5
```

* **2次元リストを出力する**

2次元リストを出力する場合、`print(リスト)`で出力する。

```python:サンプルコード：sample_1-1-12.py
x = [[1, 2, 3], [4, 5, 6]]
print(x)
```

```text:実行結果
[[1, 2, 3], [4, 5, 6]]
```

* **2次元リストの各行を出力する**

2次元リストの各行を出力する場合、`for 1次元リスト in 2次元リスト:`でループ処理し、`print(1次元リスト)`で出力する。

```python:サンプルコード：sample_1-1-13.py
x = [[1, 2, 3], [4, 5, 6]]
for rows in x:
    print(rows)
```

```text:実行結果
[1, 2, 3]
[4, 5, 6]
```

* **2次元リストの各要素を出力する**

2次元リストの各要素を出力する場合、`for 1次元リスト in 2次元リスト:`でループ処理し、さらに`for 変数 in 1次元リスト:`でネストし、`print(変数)`で出力する。

```python:サンプルコード：sample_1-1-14.py
x = [[1, 2, 3], [4, 5, 6]]
for rows in x:
    for columns in rows:
        print(columns)
```

```text:実行結果
1
2
3
4
5
6
```

* **2次元リストの各要素をインデックス指定して出力する**

2次元リストの各要素をインデックス指定して出力する場合、`for 変数A in range(2次元リストの長さ):`でループ処理し、さらに`for 変数B in range(1次元リストの長さ):`でネストし、`print(リスト[変数A][変数B])`で出力する。

```python:サンプルコード：sample_1-1-15.py
x = [[1, 2, 3], [4, 5, 6]]
for i in range(2):
    for j in range(3):
        print(x[i][j])
```

```text:実行結果
1
2
3
4
5
6
```

### 区切り文字の指定

print関数の区切り文字は`print(出力データ, sep="区切り文字")`で指定する。

* **区切り文字を指定しない**

区切り文字を指定しない場合`print(出力データ)`、区切り文字が <b>半角スペース</b>` `で出力される。

```python:サンプルコード：sample_1-1-16.py
x = 1
y = 2
z = 3
print(x, y, z)
```

```text:実行結果
1 2 3
```

* **カンマを指定する**

カンマ`,`を指定する場合、`print(出力データ, sep=",")`で出力する。

```python:サンプルコード：sample_1-1-17.py
x = 1
y = 2
z = 3
print(x, y, z, sep=",")
```

```text:実行結果
1,2,3
```

* **区切り文字なしを指定する**

区切り文字なしを指定する場合、`print(出力データ, sep="")`で出力する。

```python:サンプルコード：sample_1-1-18.py
x = 1
y = 2
z = 3
print(x, y, z, sep="")
```

```text:実行結果
123
```

* **改行を指定する**

改行`\n`を指定する場合、`print(出力データ, sep="\n")`で出力する。

```python:サンプルコード：sample_1-1-19.py
x = 1
y = 2
z = 3
print(x, y, z, sep="\n")
```

```text:実行結果
1
2
3
```

### 末尾文字の指定

print関数の末尾文字は`print(出力データ, end="末尾文字")`で指定する。

* **末尾文字を指定しない**

末尾文字を指定しない場合`print(出力データ)`、末尾文字が <b>改行</b>`\n`で出力される。

```python:サンプルコード：sample_1-1-20.py
print("x")
print("y")
print("z")
```

```text:実行結果
x
y
z
```

* **末尾文字なしを指定する**

末尾文字なしを指定する場合、`print(出力データ, end="")`で出力する。

```python:サンプルコード：sample_1-1-21.py
print("x", end="")
print("y", end="")
print("z", end="")
```

```text:実行結果
xyz
```

* **半角スペースを指定する**

半角スペース` `を指定する場合、`print(出力データ, end=" ")`で出力する。

```python:サンプルコード：sample_1-1-22.py
print("x", end=" ")
print("y", end=" ")
print("z", end=" ")
```

```text:実行結果
x y z
```

### アンパック

* **アンパックを利用して文字を出力する**

アンパック`*`を利用して、文字列から各文字を半角スペース` `で区切り、出力することができる。出力する場合、`print(*文字列)`で出力する。

```python:サンプルコード：sample_1-1-23.py
x = "ABC"
print(*x)
```

```text:実行結果
A B C
```

[ABC329 A - Spread](https://atcoder.jp/contests/abc329/tasks/abc329_a) ｜ [提出結果](https://atcoder.jp/contests/abc329/submissions/48176461)

```python:解答例：answer_1-1-1.py
S = input()
print(*S)
```

* **アンパックを利用して1次元リストの要素を出力する**

アンパック`*`を利用して、1次元リストの要素を出力することができる。出力する場合、`print(*リスト)`で出力する。要素は半角スペース` `で区切られる。

```python:サンプルコード：sample_1-1-24.py
x = [1, 2, 3, 4, 5]
print(*x)
```

```text:実行結果
1 2 3 4 5
```

* **アンパックの区切り文字としてカンマを指定する**

アンパックの区切り文字としてカンマ`,`を指定する場合、`print(*出力データ, sep=",")`で出力する。

```python:サンプルコード：sample_1-1-25.py
x = "ABC"
print(*x, sep=",")
```

```text:実行結果
A,B,C
```

```python:サンプルコード：sample_1-1-26.py
x = [1, 2, 3, 4, 5]
print(*x, sep=",")
```

```text:実行結果
1,2,3,4,5
```

* **アンパックの区切り文字として改行を指定する**

アンパックの区切り文字として改行`\n`を指定する場合、`print(*出力データ, sep="\n")`で出力する。

```python:サンプルコード：sample_1-1-27.py
x = "ABC"
print(*x, sep="\n")
```

```text:実行結果
A
B
C
```

```python:サンプルコード：sample_1-1-28.py
x = [1, 2, 3, 4, 5]
print(*x, sep="\n")
```

```text:実行結果
1
2
3
4
5
```

## 1.2 コメントアウト

<b>キーポイント</b>

* 処理を実行しない場合やコメントを入れる場合などはコメントアウトを使用する。
* 1行のコメントアウトは`#`（シャープ1つ）を使用する。
* 複数行のコメントアウトは`"""`（ダブルクォーテーション3つ）または`'''`（シングルクォーテーション3つ）を使用する。

### 1行

1行のコメントアウトは`#`（シャープ1つ）を使用する。`#`より後ろの処理は実行されなくなる。

```python:サンプルコード：sample_1-2-1.py
print(10)
# print(20)
# print(30)
print(40)  # 行の途中からでもコメントアウトを使用できる。
```

```text:実行結果
10
40
```

### 複数行

複数行のコメントアウトは`"""`（ダブルクォーテーション3つ）または`'''`（シングルクォーテーション3つ）を使用する。コメントアウトする処理を`"""`または`'''`で囲む。囲まれた処理は実行されなくなる。

```python:サンプルコード：sample_1-2-2.py
print(10)
"""
print(20)
print(30)
print(40)
"""
print(50)
```

```text:実行結果
10
50
```

## 1.3 入力

<b>キーポイント</b>

* 標準入力は`input`関数で入力する（文字列(str)型で入力される）。
* 標準入力から整数を得たい場合、整数(int)型`int(input())`に変換する。
* 標準入力から浮動小数点数を得たい場合、浮動小数点数(float)型`float(input())`に変換する。
* 標準入力から得た文字列を区切りたい場合、split関数を用いて`input().split("区切り文字")`と使用する。
* split関数で区切り文字を指定しない場合`input().split()`、<b>半角スペース</b> で区切られる。
* 複数列の整数の標準入力を複数の変数に格納する場合、map関数を用いて`map(int, input().split())`と使用する。
* 複数列の整数の標準入力をリストに格納する場合、map関数を用いて`list(map(int, input().split()))`と使用する。
* 複数行の整数の標準入力をリストに格納する場合、リスト内包表記で`[int(input()) for 変数 in range(入力行数)]`と使用する。

### 1行 / 1列

* **整数を変数に格納する**

整数を変数に格納する場合、`変数 = int(input())`で格納する。

```text:入力
10
```

```python:サンプルコード：sample_1-3-1.py
x = int(input())
print(x)
```

```text:実行結果
10
```

* **文字列を1つの変数に格納する**

文字列を1つの変数に格納する場合、`変数 = input()`で格納する。

```text:入力
Hello world!
```

```python:サンプルコード：sample_1-3-2.py
x = input()
print(x)
```

```text:実行結果
Hello world!
```

* **文字列を複数の変数に格納する**

文字列を複数の変数に格納する場合、`変数A, 変数B, 変数C = input()`で格納する。

```text:入力
123
```

```python:サンプルコード：sample_1-3-3.py
x, y, z = input()  # 123を整数(int)型ではなく、文字列(str)型で変数に格納する
print(x, y, z)
```

```text:実行結果
1 2 3
```

```text:入力
abc
```

```python:サンプルコード：sample_1-3-4.py
x, y, z = input()
print(x, y, z)
```

```text:実行結果
a b c
```

### 1行 / 複数列

* **整数を複数の変数に格納する**

整数を複数の変数に格納する場合、`変数A, 変数B = map(int, input().split())`で格納する。

```text:入力
1 2
```

```python:サンプルコード：sample_1-3-5.py
x, y = map(int, input().split())
print(x)
print(y)
```

```text:実行結果
1
2
```

[ABC012 A - スワップ](https://atcoder.jp/contests/abc012/tasks/abc012_1) ｜ [提出結果](https://atcoder.jp/contests/abc012/submissions/45485245)

```python:解答例：answer_1-3-1.py
A, B = map(int, input().split())
print(B, A)
```

[ABC161 A - ABC Swap](https://atcoder.jp/contests/abc161/tasks/abc161_a) ｜ [提出結果](https://atcoder.jp/contests/abc161/submissions/45485282)

```python:解答例：answer_1-3-2.py
X, Y, Z = map(int, input().split())
print(Z, X, Y)
```

* **文字列を複数の変数に格納する**

文字列を複数の変数に格納する場合、`変数A, 変数B = input().split()`で格納する。

```text:入力
Hello world!
```

```python:サンプルコード：sample_1-3-6.py
x, y = input().split()
print(x)
print(y)
```

```text:実行結果
Hello
world!
```

[ABC012 A - スワップ](https://atcoder.jp/contests/abc012/tasks/abc012_1) ｜ [提出結果](https://atcoder.jp/contests/abc012/submissions/45485312)

```python:解答例：answer_1-3-3.py
A, B = input().split()
print(B, A)
```

[ABC161 A - ABC Swap](https://atcoder.jp/contests/abc161/tasks/abc161_a) ｜ [提出結果](https://atcoder.jp/contests/abc161/submissions/45485346)

```python:解答例：answer_1-3-4.py
X, Y, Z = input().split()
print(Z, X, Y)
```

[ABC051 A - Haiku](https://atcoder.jp/contests/abc051/tasks/abc051_a) ｜ [提出結果](https://atcoder.jp/contests/abc051/submissions/45485376)

```python:解答例：answer_1-3-5.py
s1, s2, s3 = input().split(",")
print(s1, s2, s3)
```

[ABC325 A - Takahashi san](https://atcoder.jp/contests/abc325/tasks/abc325_a) ｜ [提出結果](https://atcoder.jp/contests/abc325/submissions/46876252)

```python:解答例：answer_1-3-6.py
S, T = input().split()
print(S, "san")
```

* **整数をリストに格納する**

整数をリストに格納する場合、`リスト = list(map(int, input().split()))`で格納する。

```text:入力
1 2 3 4 5
```

```python:サンプルコード：sample_1-3-7.py
x = list(map(int, input().split()))
print(x)
```

```text:実行結果
[1, 2, 3, 4, 5]
```

* **文字列をリストに格納する**

文字列をリストに格納する場合、`リスト = input().split()`で格納する。

```text:入力
Hello world !
```

```python:サンプルコード：sample_1-3-8.py
x = input().split()
print(x)
```

```text:実行結果
['Hello', 'world', '!']
```

### 複数行 / 1列

* **整数を複数の変数に格納する**

整数を複数の変数に格納する場合、`変数 = int(input())`を複数行で格納する。

```text:入力
1
2
```

```python:サンプルコード：sample_1-3-9.py
x = int(input())
y = int(input())
print(x, y)
```

```text:実行結果
1 2
```

整数を複数の変数に格納する場合、`変数A, 変数B = [int(input()) for 変数 in range(変数の数)]`で格納する。

```text:入力
1
2
```

```python:サンプルコード：sample_1-3-10.py
x, y = [int(input()) for i in range(2)]
print(x, y)
```

```text:実行結果
1 2
```

* **整数をリストに格納する**

整数をリストに格納する場合、`リスト = [int(input()) for 変数 in range(変数の数)]`で格納する。

```text:入力
1
2
3
```

```python:サンプルコード：sample_1-3-11.py
x = [int(input()) for i in range(3)]
print(x)
```

```text:実行結果
[1, 2, 3]
```

* **入力行数が指定され、整数をリストに格納する**

入力行数（N = 3）が指定され、整数をリストに格納する場合、`変数 = int(input())`で入力行数を格納し、`リスト = [int(input()) for 変数 in range(変数)]`でリストに格納する。

```text:入力
3
1
2
3
```

```python:サンプルコード：sample_1-3-12.py
N = int(input())
x = [int(input()) for i in range(N)]
print(x)
```

```text:実行結果
[1, 2, 3]
```

* **文字列をリストに格納する**

文字列をリストに格納する場合、`リスト = [input() for 変数 in range(変数の数)]`で格納する。

```text:入力
a
b
c
```

```python:サンプルコード：sample_1-3-13.py
x = [input() for i in range(3)]
print(x)
```

```text:実行結果
['a', 'b', 'c']
```

* **入力行数が指定され、文字列をリストに格納する**

入力行数（N = 3）が指定され、文字列をリストに格納する場合、`変数 = int(input())`で入力行数を格納し、`リスト = [input() for 変数 in range(変数)]`でリストに格納する。

```text:入力
3
a
b
c
```

```python:サンプルコード：sample_1-3-14.py
N = int(input())
x = [input() for i in range(N)]
print(x)
```

```text:実行結果
['a', 'b', 'c']
```

### 複数行 / 複数列

* **整数をリストに格納する**

整数をリストに格納する場合、`リスト = [list(map(int, input().split())) for 変数 in range(入力行数)]`となる。

```text:入力
1 2 3
4 5 6
7 8 9
```

```python:サンプルコード：sample_1-3-15.py
x = [list(map(int, input().split())) for i in range(3)]
print(x)
```

```text:実行結果
[[1, 2, 3], [4, 5, 6], [7, 8, 9]]
```

* **入力行数が指定され、整数をリストに格納する**

入力行数（N = 3）が指定され、整数をリストに格納する場合、`変数 = int(input())`で入力行数を格納し、`リスト = [list(map(int, input().split())) for 変数 in range(変数)]`でリストに格納する。

```text:入力
3
1 2 3
4 5 6
7 8 9
```

```python:サンプルコード：sample_1-3-16.py
N = int(input())
x = [list(map(int, input().split())) for i in range(N)]
print(x)
```

```text:実行結果
[[1, 2, 3], [4, 5, 6], [7, 8, 9]]
```

* **文字列をリストに格納する**

文字列をリストに格納する場合、`リスト = [input().split() for 変数 in range(入力行数)]`となる。

```text:入力
a b c
d e f
g h i
```

```python:サンプルコード：sample_1-3-17.py
x = [input().split() for i in range(3)]
print(x)
```

```text:実行結果
[['a', 'b', 'c'], ['d', 'e', 'f'], ['g', 'h', 'i']]
```

* **入力行数が指定され、文字列をリストに格納する**

入力行数（N = 3）が指定され、文字列をリストに格納する場合、`変数 = int(input())`で入力行数を格納し、`リスト = [input() for 変数 in range(変数)]`でリストに格納する。

```text:入力
3
a b c
d e f
g h i
```

```python:サンプルコード：sample_1-3-18.py
N = int(input())
x = [input().split() for i in range(N)]
print(x)
```

```text:実行結果
[['a', 'b', 'c'], ['d', 'e', 'f'], ['g', 'h', 'i']]
```

# 第2章 演算

第2章では演算について説明します。

## 2.1 演算子の優先順位

演算子の優先順位は Python ドキュメントに記載されています。

* [演算子の優先順位](https://docs.python.org/ja/3/reference/expressions.html#operator-precedence)

## 2.2 算術演算

<b>キーポイント</b>

* 各演算は下記表の演算子を使用する。
* 「除算」の結果は <b>浮動小数点数</b> となる。
* 「切り捨て除算」の結果は <b>整数</b> となる。（整数除算）

|演算子|記述例|意味|
|:-:|:-:|:-:|
|+|a + b|加算|
|-|a - b|減算|
|*|a * b|乗算|
|**|a ** b|べき乗 / べき根|
|/|a / b|除算|
|//|a // b|切り捨て除算|
|%|a % b|剰余|

### 加算

加算は`+`演算子を使用する。

* 数値を足す

```python:サンプルコード：sample_2-2-1.py
print(1+2)
```

```text:実行結果
3
```

* 変数に格納する

```python:サンプルコード：sample_2-2-2.py
x = 2+3
print(x)
```

```text:実行結果
5
```

* 変数で足す

```python:サンプルコード：sample_2-2-3.py
x = 3
y = 4
print(x+y)
```

```text:実行結果
7
```

### 減算

減算は`-`演算子を使用する。

* 数値を引く

```python:サンプルコード：sample_2-2-4.py
print(2-1)
```

```text:実行結果
1
```

* 変数に格納する

```python:サンプルコード：sample_2-2-5.py
x = 4-2
print(x)
```

```text:実行結果
2
```

* 変数で引く

```python:サンプルコード：sample_2-2-6.py
x = 3
y = 6
print(x-y)
```

```text:実行結果
-3
```

[ABC001 A - 積雪深差](https://atcoder.jp/contests/abc001/tasks/abc001_1) ｜ [提出結果](https://atcoder.jp/contests/abc001/submissions/45485416)

```python:解答例：answer_2-2-1.py
H1 = int(input())
H2 = int(input())
print(H1-H2)
```

[ABC180 A - box](https://atcoder.jp/contests/abc180/tasks/abc180_a) ｜ [提出結果](https://atcoder.jp/contests/abc180/submissions/45485450)

```python:解答例：answer_2-2-2.py
N, A, B = map(int, input().split())
print(N-A+B)
```

[ABC007 A - 植木算](https://atcoder.jp/contests/abc007/tasks/abc007_1) ｜ [提出結果](https://atcoder.jp/contests/abc007/submissions/45485479)

```python:解答例：answer_2-2-3.py
n = int(input())
print(n-1)
```

[ABC084 A - New Year](https://atcoder.jp/contests/abc084/tasks/abc084_a) ｜ [提出結果](https://atcoder.jp/contests/abc084/submissions/45485524)

```python:解答例：answer_2-2-4.py
M = int(input())
print(48-M)
```

[ABC008 A - アルバム](https://atcoder.jp/contests/abc008/tasks/abc008_1) ｜ [提出結果](https://atcoder.jp/contests/abc008/submissions/45485555)

```python:解答例：answer_2-2-5.py
S, T = map(int, input().split())
print(T-S+1)
```

[ABC107 A - Train](https://atcoder.jp/contests/abc107/tasks/abc107_a) ｜ [提出結果](https://atcoder.jp/contests/abc107/submissions/45485605)

```python:解答例：answer_2-2-6.py
N, i = map(int, input().split())
print(N-i+1)
```

[ABC202 A - Three Dice](https://atcoder.jp/contests/abc202/tasks/abc202_a) ｜ [提出結果](https://atcoder.jp/contests/abc202/submissions/45485640)

```python:解答例：answer_2-2-7.py
a, b, c = map(int, input().split())
print(21-(a+b+c))
```

[ABC196 A - Difference Max](https://atcoder.jp/contests/abc196/tasks/abc196_a) ｜ [提出結果](https://atcoder.jp/contests/abc196/submissions/45485674)

```python:解答例：answer_2-2-8.py
a, b = map(int, input().split())
c, d = map(int, input().split())
print(b-c)
```

[ABC198 A - Div](https://atcoder.jp/contests/abc198/tasks/abc198_a) ｜ [提出結果](https://atcoder.jp/contests/abc198/submissions/45485716)

```python:解答例：answer_2-2-9.py
N = int(input())
print(N-1)
```

### 乗算

乗算は`*`演算子を使用する。

* 数値で掛ける

```python:サンプルコード：sample_2-2-7.py
print(2*3)
```

```text:実行結果
6
```

* 変数に格納する

```python:サンプルコード：sample_2-2-8.py
x = 3*4
print(x)
```

```text:実行結果
12
```

* 変数で掛ける

```python:サンプルコード：sample_2-2-9.py
x = 5
y = 6
print(x*y)
```

```text:実行結果
30
```

[ABC169 A - Multiplication 1](https://atcoder.jp/contests/abc169/tasks/abc169_a) ｜ [提出結果](https://atcoder.jp/contests/abc169/submissions/45485759)

```python:解答例：answer_2-2-10.py
A, B = map(int, input().split())
print(A*B)
```

[ABC004 A - 流行](https://atcoder.jp/contests/abc004/tasks/abc004_1) ｜ [提出結果](https://atcoder.jp/contests/abc004/submissions/45485803)

```python:解答例：answer_2-2-11.py
N = int(input())
print(2*N)
```

[ABC232 A - QQ solver](https://atcoder.jp/contests/abc232/tasks/abc232_a) ｜ [提出結果](https://atcoder.jp/contests/abc232/submissions/62090148)

```python:解答例：answer_2-2-12.py
a, b = map(int, input().split("x"))
print(a*b)
```

[ABC389 A - 9x9](https://atcoder.jp/contests/abc389/tasks/abc389_a) ｜ [提出結果](https://atcoder.jp/contests/abc389/submissions/62091363)

```python:解答例：answer_2-2-13.py
a, b = map(int, input().split("x"))
print(a*b)
```

[ABC184 A - Determinant](https://atcoder.jp/contests/abc184/tasks/abc184_a) ｜ [提出結果](https://atcoder.jp/contests/abc184/submissions/45485823)

```python:解答例：answer_2-2-14.py
a, b = map(int, input().split())
c, d = map(int, input().split())
print(a*d-b*c)
```

[ABC269 A - Anyway Takahashi](https://atcoder.jp/contests/abc269/tasks/abc269_a) ｜ [提出結果](https://atcoder.jp/contests/abc269/submissions/45485868)

```python:解答例：answer_2-2-15.py
a, b, c, d = map(int, input().split())
print((a+b)*(c-d))
print("Takahashi")
```

[ABC163 A - Circle Pond](https://atcoder.jp/contests/abc163/tasks/abc163_a) ｜ [提出結果](https://atcoder.jp/contests/abc163/submissions/45485909)

```python:解答例：answer_2-2-16.py
R = int(input())
print(2*3.14*R)
```

[ABC039 A - 高橋直体](https://atcoder.jp/contests/abc039/tasks/abc039_a) ｜ [提出結果](https://atcoder.jp/contests/abc039/submissions/45485950)

```python:解答例：answer_2-2-17.py
A, B, C = map(int, input().split())
print(2*(A*B+B*C+C*A))
```

[ABC074 A - Bichrome Cells](https://atcoder.jp/contests/abc074/tasks/abc074_a) ｜ [提出結果](https://atcoder.jp/contests/abc074/submissions/45485993)

```python:解答例：answer_2-2-18.py
N = int(input())
A = int(input())
print(N*N-A)
```

[ABC069 A - K-City](https://atcoder.jp/contests/abc069/tasks/abc069_a) ｜ [提出結果](https://atcoder.jp/contests/abc069/submissions/45486030)

```python:解答例：answer_2-2-19.py
n, m = map(int, input().split())
print((n-1)*(m-1))
```

[ABC106 A - Garden](https://atcoder.jp/contests/abc106/tasks/abc106_a) ｜ [提出結果](https://atcoder.jp/contests/abc106/submissions/45486069)

```python:解答例：answer_2-2-20.py
A, B = map(int, input().split())
print(A*B-(A+B-1))
```

[ABC121 A - White Cells](https://atcoder.jp/contests/abc121/tasks/abc121_a) ｜ [提出結果](https://atcoder.jp/contests/abc121/submissions/45486113)

```python:解答例：answer_2-2-21.py
H, W = map(int, input().split())
h, w = map(int, input().split())
print((H-h)*(W-w))
```

[ABC076 A - Rating Goal](https://atcoder.jp/contests/abc076/tasks/abc076_a) ｜ [提出結果](https://atcoder.jp/contests/abc076/submissions/45486154)

```python:解答例：answer_2-2-22.py
R = int(input())
G = int(input())
print(2*G-R)
```

[ABC182 A - twiblr](https://atcoder.jp/contests/abc182/tasks/abc182_a) ｜ [提出結果](https://atcoder.jp/contests/abc182/submissions/45486226)

```python:解答例：answer_2-2-23.py
A, B = map(int, input().split())
print((2*A+100)-B)
```

#### 階乗

階乗は`import math`で math モジュールをインポートし、`math.factorial(整数)`となる。

```python:サンプルコード：sample_2-2-10.py
import math
print(math.factorial(5))  # 120 = 5*4*3*2*1
```

```text:実行結果
120
```

[ABC273 A - A Recursive Function](https://atcoder.jp/contests/abc273/tasks/abc273_a) ｜ [提出結果](https://atcoder.jp/contests/abc273/submissions/45486287)

```python:解答例：answer_2-2-24.py
import math
N = int(input())
print(math.factorial(N))
```

### べき乗

べき乗は`**`演算子を使用する。演算は`底**指数`となる。

* 数値でべき乗する

```python:サンプルコード：sample_2-2-11.py
print(2**3)
```

```text:実行結果
8
```

```python:サンプルコード：sample_2-2-12.py
print(10**9+7)
```

```text:実行結果
1000000007
```

* 変数に格納する

```python:サンプルコード：sample_2-2-13.py
x = 3**2
print(x)
```

```text:実行結果
9
```

* 変数でべき乗する

```python:サンプルコード：sample_2-2-14.py
x = 4
y = 2
print(x**y)
```

```text:実行結果
16
```

[ABC256 A - 2^N](https://atcoder.jp/contests/abc256/tasks/abc256_a) ｜ [提出結果](https://atcoder.jp/contests/abc256/submissions/45486348)

```python:解答例：answer_2-2-25.py
N = int(input())
print(2**N)
```

[ABC283 A - Power](https://atcoder.jp/contests/abc283/tasks/abc283_a) ｜ [提出結果](https://atcoder.jp/contests/abc283/submissions/45486404)

```python:解答例：answer_2-2-26.py
A, B = map(int, input().split())
print(A**B)
```

[ABC320 A - Leyland Number](https://atcoder.jp/contests/abc320/tasks/abc320_a) ｜ [提出結果](https://atcoder.jp/contests/abc320/submissions/45729848)

```python:解答例：answer_2-2-27.py
A, B = map(int, input().split())
print(A**B+B**A)
```

[ABC387 A - Happy New Year 2025](https://atcoder.jp/contests/abc387/tasks/abc387_a) ｜ [提出結果](https://atcoder.jp/contests/abc387/submissions/62016034)

```python:解答例：answer_2-2-28.py
A, B = map(int, input().split())
print((A+B)**2)
```

[ABC172 A - Calc](https://atcoder.jp/contests/abc172/tasks/abc172_a) ｜ [提出結果](https://atcoder.jp/contests/abc172/submissions/45486442)

```python:解答例：answer_2-2-29.py
a = int(input())
print(a+a**2+a**3)
```

[ABC134 A - Dodecagon](https://atcoder.jp/contests/abc134/tasks/abc134_a) ｜ [提出結果](https://atcoder.jp/contests/abc134/submissions/45486486)

```python:解答例：answer_2-2-30.py
r = int(input())
print(3*(r**2))
```

[ABC145 A - Circle](https://atcoder.jp/contests/abc145/tasks/abc145_a) ｜ [提出結果](https://atcoder.jp/contests/abc145/submissions/45486527)

```python:解答例：answer_2-2-31.py
r = int(input())
print(r**2)
```

[ABC221 A - Seismic magnitude scales](https://atcoder.jp/contests/abc221/tasks/abc221_a) ｜ [提出結果](https://atcoder.jp/contests/abc221/submissions/45486576)

```python:解答例：answer_2-2-32.py
A, B = map(int, input().split())
print(32**(A-B))
```

[ABC140 A - Password](https://atcoder.jp/contests/abc140/tasks/abc140_a) ｜ [提出結果](https://atcoder.jp/contests/abc140/submissions/45486631)

```python:解答例：answer_2-2-33.py
N = int(input())
print(N**3)
```

### べき根

べき根は`**`演算子を使用し、`底**指数`となる。計算結果は <b>浮動小数点数</b> となる。

* 数値でべき根を取る

```python:サンプルコード：sample_2-2-15.py
print(9**(1/2))
```

```text:実行結果
3.0
```

```python:サンプルコード：sample_2-2-16.py
print(9**0.5)
```

```text:実行結果
3.0
```

* 変数に格納する

```python:サンプルコード：sample_2-2-17.py
x = 8**(1/3)
print(x)
```

```text:実行結果
2.0
```

* 変数でべき根を取る

```python:サンプルコード：sample_2-2-18.py
x = 8
y = 1/3
print(x**y)
```

```text:実行結果
2.0
```

[ABC239 A - Horizon](https://atcoder.jp/contests/abc239/tasks/abc239_a) ｜ [提出結果](https://atcoder.jp/contests/abc239/submissions/45486689) ｜ [提出結果](https://atcoder.jp/contests/abc239/submissions/45486735)

```python:解答例：answer_2-2-34.py
H = int(input())
print((H*(12800000+H))**(1/2))
```

```python:解答例：answer_2-2-35.py
H = int(input())
print((H*(12800000+H))**0.5)
```

### 除算

除算は`/`演算子を使用する。除算の結果は <b>浮動小数点数</b> となる。ゼロ除算はエラーとなる。

* 数値で割る

```python:サンプルコード：sample_2-2-19.py
print(5/3)
```

```text:実行結果
1.6666666666666667
```

* 変数に格納する

```python:サンプルコード：sample_2-2-20.py
x = 6/3
print(x)
```

```text:実行結果
2.0
```

* 変数で割る

```python:サンプルコード：sample_2-2-21.py
x = 7
y = 3
print(x/y)
```

```text:実行結果
2.3333333333333335
```

* ゼロ除算はエラーとなる

```python:サンプルコード：sample_2-2-22.py
print(1/0)
```

```text:実行結果
ZeroDivisionError: division by zero
```

[ABC231 A - Water Pressure](https://atcoder.jp/contests/abc231/tasks/abc231_a) ｜ [提出結果](https://atcoder.jp/contests/abc231/submissions/45486776)

```python:解答例：answer_2-2-36.py
D = int(input())
print(D/100)
```

[ABC211 A - Blood Pressure](https://atcoder.jp/contests/abc211/tasks/abc211_a) ｜ [提出結果](https://atcoder.jp/contests/abc211/submissions/45486815)

```python:解答例：answer_2-2-37.py
A, B = map(int, input().split())
print((A-B)/3+B)
```

[ABC117 A - Entrance Examination](https://atcoder.jp/contests/abc117/tasks/abc117_a) ｜ [提出結果](https://atcoder.jp/contests/abc117/submissions/45486870)

```python:解答例：answer_2-2-38.py
T, X = map(int, input().split())
print(T/X)
```

[ABC205 A - kcal](https://atcoder.jp/contests/abc205/tasks/abc205_a) ｜ [提出結果](https://atcoder.jp/contests/abc205/submissions/45486908)

```python:解答例：answer_2-2-39.py
A, B = map(int, input().split())
print(A*B/100)
```

[ABC193 A - Discount](https://atcoder.jp/contests/abc193/tasks/abc193_a) ｜ [提出結果](https://atcoder.jp/contests/abc193/submissions/45486947)

```python:解答例：answer_2-2-40.py
A, B = map(int, input().split())
print((1-B/A)*100)
```

#### 切り捨て除算

切り捨て除算は`//`演算子を使用する。切り捨て除算の結果は小さい方に丸め込まれ、<b>整数</b> となる。

```python:サンプルコード：sample_2-2-23.py
print(5/3)
print(5//3)
```

```text:実行結果
1.6666666666666667
1
```

```python:サンプルコード：sample_2-2-24.py
print(6/3)
print(6//3)
```

```text:実行結果
2.0
2
```

```python:サンプルコード：sample_2-2-25.py
print(7/3)
print(7//3)
```

```text:実行結果
2.3333333333333335
2
```

```python:サンプルコード：sample_2-2-26.py
print(-5/3)
print(-5//3)
```

```text:実行結果
-1.6666666666666667
-2
```

```python:サンプルコード：sample_2-2-27.py
print(-6/3)
print(-6//3)
```

```text:実行結果
-2.0
-2
```

```python:サンプルコード：sample_2-2-28.py
print(-7/3)
print(-7//3)
```

```text:実行結果
-2.3333333333333335
-3
```

[ABC116 A - Right Triangle](https://atcoder.jp/contests/abc116/tasks/abc116_a) ｜ [提出結果](https://atcoder.jp/contests/abc116/submissions/45486982)

```python:解答例：answer_2-2-41.py
AB, BC, CA = map(int, input().split())
print(AB*BC//2)
```

[ABC045 A - 台形](https://atcoder.jp/contests/abc045/tasks/abc045_a) ｜ [提出結果](https://atcoder.jp/contests/abc045/submissions/45487023)

```python:解答例：answer_2-2-42.py
a, b, h = [int(input()) for i in range(3)]
print((a+b)*h//2)
```

[ABC113 A - Discount Fare](https://atcoder.jp/contests/abc113/tasks/abc113_a) ｜ [提出結果](https://atcoder.jp/contests/abc113/submissions/45487069)

```python:解答例：answer_2-2-43.py
X, Y = map(int, input().split())
print(X+Y//2)
```

[ABC017 A - プロコン](https://atcoder.jp/contests/abc017/tasks/abc017_1) ｜ [提出結果](https://atcoder.jp/contests/abc017/submissions/45487114)

```python:解答例：answer_2-2-44.py
s1, e1 = map(int, input().split())
s2, e2 = map(int, input().split())
s3, e3 = map(int, input().split())
print((s1*e1+s2*e2+s3*e3)//10)
```

[ABC055 A - Restaurant](https://atcoder.jp/contests/abc055/tasks/abc055_a) ｜ [提出結果](https://atcoder.jp/contests/abc055/submissions/45487152)

```python:解答例：answer_2-2-45.py
N = int(input())
print(N*800-N//15*200)
```

[ABC200 A - Century](https://atcoder.jp/contests/abc200/tasks/abc200_a) ｜ [提出結果](https://atcoder.jp/contests/abc200/submissions/45487203)

```python:解答例：answer_2-2-46.py
N = int(input())
print((N+99)//100)
```

[ABC186 A - Brick](https://atcoder.jp/contests/abc186/tasks/abc186_a) ｜ [提出結果](https://atcoder.jp/contests/abc186/submissions/45487252)

```python:解答例：answer_2-2-47.py
N, W = map(int, input().split())
print(N//W)
```

[ABC005 A - おいしいたこ焼きの作り方](https://atcoder.jp/contests/abc005/tasks/abc005_1) ｜ [提出結果](https://atcoder.jp/contests/abc005/submissions/45487295)

```python:解答例：answer_2-2-48.py
x, y = map(int, input().split())
print(y//x)
```

[ABC089 A - Grouping 2](https://atcoder.jp/contests/abc089/tasks/abc089_a) ｜ [提出結果](https://atcoder.jp/contests/abc089/submissions/45487348)

```python:解答例：answer_2-2-49.py
N = int(input())
print(N//3)
```

[ABC128 A - Apple Pie](https://atcoder.jp/contests/abc128/tasks/abc128_a) ｜ [提出結果](https://atcoder.jp/contests/abc128/submissions/45487391)

```python:解答例：answer_2-2-50.py
A, P = map(int, input().split())
print((3*A+P)//2)
```

[ABC239 B - Integer Division](https://atcoder.jp/contests/abc239/tasks/abc239_b) ｜ [提出結果](https://atcoder.jp/contests/abc239/submissions/45487442)

```python:解答例：answer_2-2-51.py
X = int(input())
print(X//10)
```

[ABC407 A - Approximation](https://atcoder.jp/contests/abc407/tasks/abc407_a) ｜ [提出結果](https://atcoder.jp/contests/abc407/submissions/66166341)

```python:解答例：answer_2-2-52.py
A, B = map(int, input().split())
print((2*A+B)//(2*B))
```

#### 切り上げ除算

切り上げ除算は`import math`で math モジュールをインポートし、`math.ceil(数値)`となる。切り上げ除算の結果は大きい方に丸め込まれる。

```python:サンプルコード：sample_2-2-29.py
import math
print(5/3)
print(math.ceil(5/3))
```

```text:実行結果
1.6666666666666667
2
```

```python:サンプルコード：sample_2-2-30.py
import math
print(6/3)
print(math.ceil(6/3))
```

```text:実行結果
2.0
2
```

```python:サンプルコード：sample_2-2-31.py
import math
print(7/3)
print(math.ceil(7/3))
```

```text:実行結果
2.3333333333333335
3
```

```python:サンプルコード：sample_2-2-32.py
import math
print(-5/3)
print(math.ceil(-5/3))
```

```text:実行結果
-1.6666666666666667
-1
```

```python:サンプルコード：sample_2-2-33.py
import math
print(-6/3)
print(math.ceil(-6/3))
```

```text:実行結果
-2.0
-2
```

```python:サンプルコード：sample_2-2-34.py
import math
print(-7/3)
print(math.ceil(-7/3))
```

```text:実行結果
-2.3333333333333335
-2
```

[ABC082 A - Round Up the Mean](https://atcoder.jp/contests/abc082/tasks/abc082_a) ｜ [提出結果](https://atcoder.jp/contests/abc082/submissions/45487488)

```python:解答例：answer_2-2-53.py
import math
a, b = map(int, input().split())
print(math.ceil((a+b)/2))
```

[ABC157 A - Duplex Printing](https://atcoder.jp/contests/abc157/tasks/abc157_a) ｜ [提出結果](https://atcoder.jp/contests/abc157/submissions/45487534)

```python:解答例：answer_2-2-54.py
import math
N = int(input())
print(math.ceil(N/2))
```

[ABC009 A - 引越し作業](https://atcoder.jp/contests/abc009/tasks/abc009_1) ｜ [提出結果](https://atcoder.jp/contests/abc009/submissions/45487590)

```python:解答例：answer_2-2-55.py
import math
N = int(input())
print(math.ceil(N/2))
```

[ABC036 A - お茶](https://atcoder.jp/contests/abc036/tasks/abc036_a) ｜ [提出結果](https://atcoder.jp/contests/abc036/submissions/45487642)

```python:解答例：answer_2-2-56.py
import math
A, B = map(int, input().split())
print(math.ceil(B/A))
```

### 剰余

剰余は`%`演算子を使用する。ゼロ剰余はエラーとなる。

```python:サンプルコード：sample_2-2-35.py
print(6 % 3)
```

```text:実行結果
0
```

```python:サンプルコード：sample_2-2-36.py
print(7 % 3)
```

```text:実行結果
1
```

```python:サンプルコード：sample_2-2-37.py
print(8 % 3)
```

```text:実行結果
2
```

```python:サンプルコード：sample_2-2-38.py
print(-6 % 3)
```

```text:実行結果
0
```

```python:サンプルコード：sample_2-2-39.py
print(-7 % 3)
```

```text:実行結果
2
```

```python:サンプルコード：sample_2-2-40.py
print(-8 % 3)
```

```text:実行結果
1
```

ゼロ剰余はエラーとなる。

```python:サンプルコード：sample_2-2-41.py
print(1 % 0)
```

```text:実行結果
ZeroDivisionError: integer division or modulo by zero
```

[ABC011 A - 来月は何月？](https://atcoder.jp/contests/abc011/tasks/abc011_1) ｜ [提出結果](https://atcoder.jp/contests/abc011/submissions/45487678)

```python:解答例：answer_2-2-57.py
N = int(input())
print((N % 12)+1)
```

[ABC057 A - Remaining Time](https://atcoder.jp/contests/abc057/tasks/abc057_a) ｜ [提出結果](https://atcoder.jp/contests/abc057/submissions/45487722)

```python:解答例：answer_2-2-58.py
A, B = map(int, input().split())
print((A+B) % 24)
```

[ABC087 A - Buying Sweets](https://atcoder.jp/contests/abc087/tasks/abc087_a) ｜ [提出結果](https://atcoder.jp/contests/abc087/submissions/45487767)

```python:解答例：answer_2-2-59.py
X, A, B = [int(input()) for i in range(3)]
print((X-A) % B)
```

[ABC192 A - Star](https://atcoder.jp/contests/abc192/tasks/abc192_a) ｜ [提出結果](https://atcoder.jp/contests/abc192/submissions/45487808)

```python:解答例：answer_2-2-60.py
X = int(input())
print(100-(X % 100))
```

[ABC363 A - Piling Up](https://atcoder.jp/contests/abc363/tasks/abc363_a) ｜ [提出結果](https://atcoder.jp/contests/abc363/submissions/55977939)

```python:解答例：answer_2-2-61.py
R = int(input())
print(100-(R % 100))
```

[ABC227 A - Last Card](https://atcoder.jp/contests/abc227/tasks/abc227_a) ｜ [提出結果](https://atcoder.jp/contests/abc227/submissions/45487850)

```python:解答例：answer_2-2-62.py
N, K, A = map(int, input().split())
print(((A+K-2) % N)+1)
```

[ABC041 B - 直方体](https://atcoder.jp/contests/abc041/tasks/abc041_b) ｜ [提出結果](https://atcoder.jp/contests/abc041/submissions/45487884)

```python:解答例：answer_2-2-63.py
A, B, C = map(int, input().split())
print((A*B*C) % (10**9+7))
```

[ABC266 B - Modulo Number](https://atcoder.jp/contests/abc266/tasks/abc266_b) ｜ [提出結果](https://atcoder.jp/contests/abc266/submissions/45487927)

```python:解答例：answer_2-2-64.py
N = int(input())
print(N % 998244353)
```

## 2.3 論理演算

論理演算は下記の表の通りとなる。

|演算子|記述例|意味|
|:-:|:-:|:--|
|and|a and b|a と b が真であれば真|
|or|a or b|a または b が真であれば真|
|not|not a|a が偽であれば真|

```python:サンプルコード：sample_2-3-1.py
print(True and True)
```

```text:実行結果
True
```

```python:サンプルコード：sample_2-3-2.py
print(True and False)
```

```text:実行結果
False
```

```python:サンプルコード：sample_2-3-3.py
print(False and False)
```

```text:実行結果
False
```

```python:サンプルコード：sample_2-3-4.py
print(True or True)
```

```text:実行結果
True
```

```python:サンプルコード：sample_2-3-5.py
print(True or False)
```

```text:実行結果
True
```

```python:サンプルコード：sample_2-3-6.py
print(False or False)
```

```text:実行結果
False
```

```python:サンプルコード：sample_2-3-7.py
print(not True)
```

```text:実行結果
False
```

```python:サンプルコード：sample_2-3-8.py
print(not False)
```

```text:実行結果
True
```

## 2.4 比較演算

比較演算は下記の表の通りとなる。

|演算子|記述例|意味|
|:-:|:-:|:--|
|==|a == b|a が b と等しい|
|!=|a != b|a が b と等しくない|
|>|a > b|a が b より大きい|
|>=|a >= b|a が b 以上|
|<|a < b|a が b より小さい|
|<=|a <= b|a が b 以下|

### 数値

```python:サンプルコード：sample_2-4-1.py
print(10 == 10)
```

```text:実行結果
True
```

```python:サンプルコード：sample_2-4-2.py
print(10 == 20)
```

```text:実行結果
False
```

```python:サンプルコード：sample_2-4-3.py
print(10 != 20)
```

```text:実行結果
True
```

```python:サンプルコード：sample_2-4-4.py
print(10 != 10)
```

```text:実行結果
False
```

```python:サンプルコード：sample_2-4-5.py
print(20 > 10)
```

```text:実行結果
True
```

```python:サンプルコード：sample_2-4-6.py
print(10 > 20)
```

```text:実行結果
False
```

```python:サンプルコード：sample_2-4-7.py
print(10 >= 10)
```

```text:実行結果
True
```

```python:サンプルコード：sample_2-4-8.py
print(10 >= 20)
```

```text:実行結果
False
```

```python:サンプルコード：sample_2-4-9.py
print(10 < 20)
```

```text:実行結果
True
```

```python:サンプルコード：sample_2-4-10.py
print(20 < 10)
```

```text:実行結果
False
```

```python:サンプルコード：sample_2-4-11.py
print(10 <= 10)
```

```text:実行結果
True
```

```python:サンプルコード：sample_2-4-12.py
print(20 <= 10)
```

```text:実行結果
False
```

### 文字列

```python:サンプルコード：sample_2-4-13.py
print("a" == "a")
```

```text:実行結果
True
```

```python:サンプルコード：sample_2-4-14.py
print("a" == "b")
```

```text:実行結果
False
```

```python:サンプルコード：sample_2-4-15.py
print("a" != "b")
```

```text:実行結果
True
```

```python:サンプルコード：sample_2-4-16.py
print("a" != "a")
```

```text:実行結果
False
```

```python:サンプルコード：sample_2-4-17.py
print("b" > "a")
```

```text:実行結果
True
```

```python:サンプルコード：sample_2-4-18.py
print("a" > "b")
```

```text:実行結果
False
```

```python:サンプルコード：sample_2-4-19.py
print("a" >= "a")
```

```text:実行結果
True
```

```python:サンプルコード：sample_2-4-20.py
print("a" >= "b")
```

```text:実行結果
False
```

```python:サンプルコード：sample_2-4-21.py
print("a" < "b")
```

```text:実行結果
True
```

```python:サンプルコード：sample_2-4-22.py
print("b" < "a")
```

```text:実行結果
False
```

```python:サンプルコード：sample_2-4-23.py
print("a" <= "a")
```

```text:実行結果
True
```

```python:サンプルコード：sample_2-4-24.py
print("b" <= "a")
```

```text:実行結果
False
```

## 2.5 所属検査演算（in演算）

所属検査演算（in演算）は下記の表の通りとなる。

|演算子|記述例|意味|
|:-:|:-:|:--|
|in|a in b|a が b に含まれる|
|not in|a not in b|a が b に含まれない|

### 文字列

部分文字列の所属を評価する。

```python:サンプルコード：sample_2-5-1.py
print("a" in "abc")
```

```text:実行結果
True
```

```python:サンプルコード：sample_2-5-2.py
print("z" in "abc")
```

```text:実行結果
False
```

```python:サンプルコード：sample_2-5-3.py
print("ab" in "abc")
```

```text:実行結果
True
```

```python:サンプルコード：sample_2-5-4.py
print("ac" in "abc")
```

```text:実行結果
False
```

```python:サンプルコード：sample_2-5-5.py
print("abc" in "abc")
```

```text:実行結果
True
```

```python:サンプルコード：sample_2-5-6.py
print("abcd" in "abc")
```

```text:実行結果
False
```

```python:サンプルコード：sample_2-5-7.py
print("z" not in "abc")
```

```text:実行結果
True
```

### リスト

要素の所属を評価する。

```python:サンプルコード：sample_2-5-8.py
print("a" in ["a", "b", "c"])
```

```text:実行結果
True
```

```python:サンプルコード：sample_2-5-9.py
print("z" in ["a", "b", "c"])
```

```text:実行結果
False
```

```python:サンプルコード：sample_2-5-10.py
print("ab" in ["a", "b", "c"])
```

```text:実行結果
False
```

```python:サンプルコード：sample_2-5-11.py
print("z" not in ["a", "b", "c"])
```

```text:実行結果
True
```

```python:サンプルコード：sample_2-5-12.py
print(10 in [10, 20, 30])
```

```text:実行結果
True
```

```python:サンプルコード：sample_2-5-13.py
print(90 not in [10, 20, 30])
```

```text:実行結果
True
```

### 集合

要素の所属を評価する。

```python:サンプルコード：sample_2-5-14.py
print("a" in {"a", "b", "c"})
```

```text:実行結果
True
```

```python:サンプルコード：sample_2-5-15.py
print("z" in {"a", "b", "c"})
```

```text:実行結果
False
```

```python:サンプルコード：sample_2-5-16.py
print("ab" in {"a", "b", "c"})
```

```text:実行結果
False
```

```python:サンプルコード：sample_2-5-17.py
print("z" not in {"a", "b", "c"})
```

```text:実行結果
True
```

```python:サンプルコード：sample_2-5-18.py
print(10 in {10, 20, 30})
```

```text:実行結果
True
```

```python:サンプルコード：sample_2-5-19.py
print(90 not in {10, 20, 30})
```

```text:実行結果
True
```

## 2.6 ビット演算

ビット演算は下記の表の通りとなる。

|演算子|記述例|意味|
|:-:|:-:|:--|
|&|a & b|a と b のビット単位の論理積（AND）|
|&#x7C;|a &#x7C; b|a と b のビット単位の論理和（OR）|
|^|a ^ b|a と b のビット単位の排他的論理和（XOR）|

### 論理積（AND）

ビット単位の論理積は`&`を使用する。

```python:サンプルコード：sample_2-6-1.py
print(1 & 1)  # 1 = 0b0001 = 0b0001 & 0b0001
```

```text:実行結果
1
```

```python:サンプルコード：sample_2-6-2.py
print(1 & 2)  # 0 = 0b0000 = 0b0001 & 0b0010
```

```text:実行結果
0
```

```python:サンプルコード：sample_2-6-3.py
print(2 & 3)  # 2 = 0b0010 = 0b0010 & 0b0011
```

```text:実行結果
2
```

### 論理和（OR）

ビット単位の論理和は`|`を使用する。

```python:サンプルコード：sample_2-6-4.py
print(1 | 2)  # 3 = 0b0011 = 0b0001 | 0b0010
```

```text:実行結果
3
```

```python:サンプルコード：sample_2-6-5.py
print(1 | 2 | 4)  # 7 = 0b0111 = 0b0001 | 0b0010 | 0b0100
```

```text:実行結果
7
```

```python:サンプルコード：sample_2-6-6.py
print(1 | 2 | 4 | 8)  # 15 = 0b1111 = 0b0001 | 0b0010 | 0b0100 | 0b1000
```

```text:実行結果
15
```

[ABC270 A - 1-2-4 Test](https://atcoder.jp/contests/abc270/tasks/abc270_a) ｜ [提出結果](https://atcoder.jp/contests/abc270/submissions/45487963)

```python:解答例：answer_2-6-1.py
a, b = map(int, input().split())
print(a | b)
```

### 排他的論理和（XOR）

ビット単位の排他的論理和は`^`を使用する。

```python:サンプルコード：sample_2-6-7.py
print(1 ^ 1)  # 0 = 0b0000 = 0b0001 ^ 0b0001
```

```text:実行結果
0
```

```python:サンプルコード：sample_2-6-8.py
print(1 ^ 1 ^ 2)  # 2 = 0b0010 = 0b0001 ^ 0b0001 ^ 0b0010
```

```text:実行結果
2
```

```python:サンプルコード：sample_2-6-9.py
print(1 ^ 1 ^ 2 ^ 2)  # 0 = 0b0000 = 0b0001 ^ 0b0001 ^ 0b0010 ^ 0b0010
```

```text:実行結果
0
```

```python:サンプルコード：sample_2-6-10.py
print(1 ^ 2)  # 3 = 0b0011 = 0b0001 ^ 0b0010
```

```text:実行結果
3
```

```python:サンプルコード：sample_2-6-11.py
print(1 ^ 2 ^ 4)  # 7 = 0b0111 = 0b0001 ^ 0b0010 ^ 0b0100
```

```text:実行結果
7
```

```python:サンプルコード：sample_2-6-12.py
print(1 ^ 2 ^ 4 ^ 8)  # 15 = 0b1111 = 0b0001 ^ 0b0010 ^ 0b0100 ^ 0b1000
```

```text:実行結果
15
```

[ABC075 A - One out of Three](https://atcoder.jp/contests/abc075/tasks/abc075_a) ｜ [提出結果](https://atcoder.jp/contests/abc075/submissions/45488008)

```python:解答例：answer_2-6-2.py
A, B, C = map(int, input().split())
print(A ^ B ^ C)
```

[ABC027 A - 長方形](https://atcoder.jp/contests/abc027/tasks/abc027_a) ｜ [提出結果](https://atcoder.jp/contests/abc027/submissions/45488050)

```python:解答例：answer_2-6-3.py
l1, l2, l3 = map(int, input().split())
print(l1 ^ l2 ^ l3)
```

[ABC246 A - Four Points](https://atcoder.jp/contests/abc246/tasks/abc246_a) ｜ [提出結果](https://atcoder.jp/contests/abc246/submissions/45488092)

```python:解答例：answer_2-6-4.py
x1, y1 = map(int, input().split())
x2, y2 = map(int, input().split())
x3, y3 = map(int, input().split())
print(x1 ^ x2 ^ x3, y1 ^ y2 ^ y3)
```

[ABC148 A - Round One](https://atcoder.jp/contests/abc148/tasks/abc148_a) ｜ [提出結果](https://atcoder.jp/contests/abc148/submissions/45488149)

```python:解答例：answer_2-6-5.py
A = int(input())
B = int(input())
print(A ^ B)
```

[ABC213 A - Bitwise Exclusive Or](https://atcoder.jp/contests/abc213/tasks/abc213_a) ｜ [提出結果](https://atcoder.jp/contests/abc213/submissions/45488212)

```python:解答例：answer_2-6-6.py
A, B = map(int, input().split())
print(A ^ B)
```

# 第3章 代入文

第3章では代入文について説明します。

## 3.1 代入文

代入文は下記の通りに記述することができる。

```python:サンプルコード：sample_3-1-1.py
x, y = 1, 2
print(x, y)
```

```text:実行結果
1 2
```

```python:サンプルコード：sample_3-1-2.py
x, y = 1, 2
x, y = y, x
print(x, y)
```

```text:実行結果
2 1
```

[ABC012 A - スワップ](https://atcoder.jp/contests/abc012/tasks/abc012_1) ｜ [提出結果](https://atcoder.jp/contests/abc012/submissions/45488255)

```python:解答例：answer_3-1-1.py
A, B = map(int, input().split())
A, B = B, A
print(A, B)
```

[ABC161 A - ABC Swap](https://atcoder.jp/contests/abc161/tasks/abc161_a) ｜ [提出結果](https://atcoder.jp/contests/abc161/submissions/45488302) ｜ [提出結果](https://atcoder.jp/contests/abc161/submissions/45488343)

```python:解答例：answer_3-1-2.py
X, Y, Z = map(int, input().split())
A, B, C = X, Y, Z
A, B = B, A
A, C = C, A
print(A, B, C)
```

```python:解答例：answer_3-1-3.py
X, Y, Z = map(int, input().split())
A, B, C = X, Y, Z
A, B, C = C, A, B
print(A, B, C)
```

## 3.2 累算代入文

累算代入文は下記の表の通りとなる。

|演算子|記述例|等式|
|:-:|:-:|:-:|
|+=|a += b|a = a + b|
|-=|a -= b|a = a - b|
|*=|a *= b|a = a * b|
|**=|a **= b|a = a ** b|
|/=|a /= b|a = a / b|
|//=|a //= b|a = a // b|
|%=|a %= b|a = a % b|

```python:サンプルコード：sample_3-2-1.py
x = 2
x += 1  # x = x+1
print(x)
```

```text:実行結果
3
```

```python:サンプルコード：sample_3-2-2.py
x = 2
x -= 1  # x = x-1
print(x)
```

```text:実行結果
1
```

```python:サンプルコード：sample_3-2-3.py
x = 2
x *= 3  # x = x*3
print(x)
```

```text:実行結果
6
```

```python:サンプルコード：sample_3-2-4.py
x = 2
x **= 3  # x = x**3
print(x)
```

```text:実行結果
8
```

```python:サンプルコード：sample_3-2-5.py
x = 6
x /= 3  # x = x/3
print(x)
```

```text:実行結果
2.0
```

```python:サンプルコード：sample_3-2-6.py
x = 6
x //= 3  # x = x//3
print(x)
```

```text:実行結果
2
```

```python:サンプルコード：sample_3-2-7.py
x = 5
x %= 3  # x = x % 3
print(x)
```

```text:実行結果
2
```

# 第4章 制御構文

第4章では制御構文について説明します。

## 4.1 分岐処理

<b>キーポイント</b>

* 分岐処理は「if文」を使用する。
* 特定の文字列、数値が含まれているかを評価する場合は`in`演算子を使用する。
* 条件式を複数組み合わせることができる。

### if文

#### 数値

```python:サンプルコード：sample_4-1-1.py
x = 10
if x == 10:
    print("x == 10")
if x == 20:
    print("x == 20")
```

```text:実行結果
x == 10
```

```python:サンプルコード：sample_4-1-2.py
x = 20
if x == 10:
    print("x == 10")
if x == 20:
    print("x == 20")
```

```text:実行結果
x == 20
```

[ABC020 A - クイズ](https://atcoder.jp/contests/abc020/tasks/abc020_a) ｜ [提出結果](https://atcoder.jp/contests/abc020/submissions/45488391)

```python:解答例：answer_4-1-1.py
Q = int(input())
if Q == 1:
    print("ABC")
if Q == 2:
    print("chokudai")
```

[ABC178 A - Not](https://atcoder.jp/contests/abc178/tasks/abc178_a) ｜ [提出結果](https://atcoder.jp/contests/abc178/submissions/45488481)

```python:解答例：answer_4-1-2.py
x = int(input())
if x == 0:
    print(1)
if x == 1:
    print(0)
```

[ABC112 A - Programming Education](https://atcoder.jp/contests/abc112/tasks/abc112_a) ｜ [提出結果](https://atcoder.jp/contests/abc112/submissions/45488704)

```python:解答例：answer_4-1-3.py
N = int(input())
if N == 1:
    print("Hello World")
if N == 2:
    A = int(input())
    B = int(input())
    print(A+B)
```

[ABC204 A - Rock-paper-scissors](https://atcoder.jp/contests/abc204/tasks/abc204_a) ｜ [提出結果](https://atcoder.jp/contests/abc204/submissions/45490435)

```python:解答例：answer_4-1-4.py
x, y = map(int, input().split())
if x == 0 and y == 0:
    print(0)
if x == 0 and y == 1:
    print(2)
if x == 0 and y == 2:
    print(1)
if x == 1 and y == 0:
    print(2)
if x == 1 and y == 1:
    print(1)
if x == 1 and y == 2:
    print(0)
if x == 2 and y == 0:
    print(1)
if x == 2 and y == 1:
    print(0)
if x == 2 and y == 2:
    print(2)
```

[ABC355 A - Who Ate the Cake?](https://atcoder.jp/contests/abc355/tasks/abc355_a) ｜ [提出結果](https://atcoder.jp/contests/abc355/submissions/55088465)

```python:解答例：answer_4-1-5.py
A, B = map(int, input().split())
if A == B:
    print(-1)
if A == 1 and B == 2:
    print(3)
if A == 1 and B == 3:
    print(2)
if A == 2 and B == 1:
    print(3)
if A == 2 and B == 3:
    print(1)
if A == 3 and B == 1:
    print(2)
if A == 3 and B == 2:
    print(1)
```

[ABC250 A - Adjacent Squares](https://atcoder.jp/contests/abc250/tasks/abc250_a) ｜ [提出結果](https://atcoder.jp/contests/abc250/submissions/53029585) ｜ [提出結果](https://atcoder.jp/contests/abc250/submissions/53029561)

```python:解答例：answer_4-1-6.py
H, W = map(int, input().split())
R, C = map(int, input().split())
count = 4
if C == 1:
    count -= 1
if C == W:
    count -= 1
if R == 1:
    count -= 1
if R == H:
    count -= 1
print(count)
```

```python:解答例：answer_4-1-7.py
H, W = map(int, input().split())
R, C = map(int, input().split())
count = 0
if C != 1:
    count += 1
if C != W:
    count += 1
if R != 1:
    count += 1
if R != H:
    count += 1
print(count)
```

#### 文字列

```python:サンプルコード：sample_4-1-3.py
x = "a"
if x == "a":
    print("x == a")
if x == "b":
    print("x == b")
```

```text:実行結果
x == a
```

```python:サンプルコード：sample_4-1-4.py
x = "b"
if x == "a":
    print("x == a")
if x == "b":
    print("x == b")
```

```text:実行結果
x == b
```

[ABC166 A - A?C](https://atcoder.jp/contests/abc166/tasks/abc166_a) ｜ [提出結果](https://atcoder.jp/contests/abc166/submissions/52944426)

```python:解答例：answer_4-1-8.py
S = input()
if S == "ABC":
    print("ARC")
if S == "ARC":
    print("ABC")
```

[ABC122 A - Double Helix](https://atcoder.jp/contests/abc122/tasks/abc122_a) ｜ [提出結果](https://atcoder.jp/contests/abc122/submissions/45491177)

```python:解答例：answer_4-1-9.py
b = input()
if b == "A":
    print("T")
if b == "T":
    print("A")
if b == "C":
    print("G")
if b == "G":
    print("C")
```

[ABC393 A - Poisonous Oyster](https://atcoder.jp/contests/abc393/tasks/abc393_a) ｜ [提出結果](https://atcoder.jp/contests/abc393/submissions/63074167)

```python:解答例：answer_4-1-10.py
t, a = input().split()
if t == "sick" and a == "sick":
    print(1)
if t == "sick" and a == "fine":
    print(2)
if t == "fine" and a == "sick":
    print(3)
if t == "fine" and a == "fine":
    print(4)
```

[ABC056 A - HonestOrDishonest](https://atcoder.jp/contests/abc056/tasks/abc056_a) ｜ [提出結果](https://atcoder.jp/contests/abc056/submissions/45491303)

```python:解答例：answer_4-1-11.py
a, b = input().split()
if a == "H" and b == "H":
    print("H")
if a == "H" and b == "D":
    print("D")
if a == "D" and b == "H":
    print("D")
if a == "D" and b == "D":
    print("H")
```

### if文 / elif節 / else節

if文は`if 条件式:`で条件文を書く。条件式が`True`の場合、条件文の中の処理がされる。条件式を2つ以上記載する場合、`elif 条件式:`で条件文を書く。どの条件式も`True`でない場合、`else:`の処理がされる。

#### 数値

```python:サンプルコード：sample_4-1-5.py
x = 10
if x == 10:
    print("x == 10")
else:
    print("else")
```

```text:実行結果
x == 10
```

```python:サンプルコード：sample_4-1-6.py
x = 20
if x == 10:
    print("x == 10")
else:
    print("else")
```

```text:実行結果
else
```

```python:サンプルコード：sample_4-1-7.py
x = 10
if x == 10:
    print("x == 10")
elif x == 20:
    print("x == 20")
else:
    print("else")
```

```text:実行結果
x == 10
```

```python:サンプルコード：sample_4-1-8.py
x = 20
if x == 10:
    print("x == 10")
elif x == 20:
    print("x == 20")
else:
    print("else")
```

```text:実行結果
x == 20
```

```python:サンプルコード：sample_4-1-9.py
x = 30
if x == 10:
    print("x == 10")
elif x == 20:
    print("x == 20")
else:
    print("else")
```

```text:実行結果
else
```

```python:サンプルコード：sample_4-1-10.py
x = 10
y = 20
if x < y:
    print("x < y")
elif x == y:
    print("x == y")
else:
    print("else")
```

```text:実行結果
x < y
```

```python:サンプルコード：sample_4-1-11.py
x = 20
y = 20
if x < y:
    print("x < y")
elif x == y:
    print("x == y")
else:
    print("else")
```

```text:実行結果
x == y
```

```python:サンプルコード：sample_4-1-12.py
x = 20
y = 10
if x < y:
    print("x < y")
elif x == y:
    print("x == y")
else:
    print("else")
```

```text:実行結果
else
```

[ABC020 A - クイズ](https://atcoder.jp/contests/abc020/tasks/abc020_a) ｜ [提出結果](https://atcoder.jp/contests/abc020/submissions/45488435)

```python:解答例：answer_4-1-12.py
Q = int(input())
if Q == 1:
    print("ABC")
else:
    print("chokudai")
```

[ABC178 A - Not](https://atcoder.jp/contests/abc178/tasks/abc178_a) ｜ [提出結果](https://atcoder.jp/contests/abc178/submissions/45488520)

```python:解答例：answer_4-1-13.py
x = int(input())
if x == 0:
    print(1)
else:
    print(0)
```

[ABC053 A - ABC/ARC](https://atcoder.jp/contests/abc053/tasks/abc053_a) ｜ [提出結果](https://atcoder.jp/contests/abc053/submissions/45488555)

```python:解答例：answer_4-1-14.py
x = int(input())
if x < 1200:
    print("ABC")
else:
    print("ARC")
```

[ABC099 A - ABD](https://atcoder.jp/contests/abc099/tasks/abc099_a) ｜ [提出結果](https://atcoder.jp/contests/abc099/submissions/45488603)

```python:解答例：answer_4-1-15.py
N = int(input())
if N < 1000:
    print("ABC")
else:
    print("ABD")
```

[ABC174 A - Air Conditioner](https://atcoder.jp/contests/abc174/tasks/abc174_a) ｜ [提出結果](https://atcoder.jp/contests/abc174/submissions/45488649)

```python:解答例：answer_4-1-16.py
X = int(input())
if X >= 30:
    print("Yes")
else:
    print("No")
```

[ABC138 A - Red or Not](https://atcoder.jp/contests/abc138/tasks/abc138_a) ｜ [提出結果](https://atcoder.jp/contests/abc138/submissions/45488678)

```python:解答例：answer_4-1-17.py
a = int(input())
s = input()
if a >= 3200:
    print(s)
else:
    print("red")
```

[ABC112 A - Programming Education](https://atcoder.jp/contests/abc112/tasks/abc112_a)　｜ [提出結果](https://atcoder.jp/contests/abc112/submissions/45488757)

```python:解答例：answer_4-1-18.py
N = int(input())
if N == 1:
    print("Hello World")
else:
    A = int(input())
    B = int(input())
    print(A+B)
```

[ABC334 A - Christmas Present](https://atcoder.jp/contests/abc334/tasks/abc334_a) ｜ [提出結果](https://atcoder.jp/contests/abc334/submissions/48804662)

```python:解答例：answer_4-1-19.py
B, G = map(int, input().split())
if B > G:
    print("Bat")
else:
    print("Glove")
```

[ABC034 A - テスト](https://atcoder.jp/contests/abc034/tasks/abc034_a) ｜ [提出結果](https://atcoder.jp/contests/abc034/submissions/45488801)

```python:解答例：answer_4-1-20.py
x, y = map(int, input().split())
if x < y:
    print("Better")
else:
    print("Worse")
```

[ABC130 A - Rounding](https://atcoder.jp/contests/abc130/tasks/abc130_a) ｜ [提出結果](https://atcoder.jp/contests/abc130/submissions/45488844)

```python:解答例：answer_4-1-21.py
X, A = map(int, input().split())
if X < A:
    print(0)
else:
    print(10)
```

[ABC164 A - Sheep and Wolves](https://atcoder.jp/contests/abc164/tasks/abc164_a) ｜ [提出結果](https://atcoder.jp/contests/abc164/submissions/45488889)

```python:解答例：answer_4-1-22.py
S, W = map(int, input().split())
if W >= S:
    print("unsafe")
else:
    print("safe")
```

[ABC063 A - Restricted](https://atcoder.jp/contests/abc063/tasks/abc063_a) ｜ [提出結果](https://atcoder.jp/contests/abc063/submissions/45488940)

```python:解答例：answer_4-1-23.py
A, B = map(int, input().split())
if A+B < 10:
    print(A+B)
else:
    print("error")
```

[ABC091 A - Two Coins](https://atcoder.jp/contests/abc091/tasks/abc091_a) ｜ [提出結果](https://atcoder.jp/contests/abc091/submissions/45488979)

```python:解答例：answer_4-1-24.py
A, B, C = map(int, input().split())
if A+B >= C:
    print("Yes")
else:
    print("No")
```

[ABC058 A - ι⊥l](https://atcoder.jp/contests/abc058/tasks/abc058_a) ｜ [提出結果](https://atcoder.jp/contests/abc058/submissions/45489020)

```python:解答例：answer_4-1-25.py
a, b, c = map(int, input().split())
if b-a == c-b:
    print("YES")
else:
    print("NO")
```

[ABC150 A - 500 Yen Coins](https://atcoder.jp/contests/abc150/tasks/abc150_a) ｜ [提出結果](https://atcoder.jp/contests/abc150/submissions/45489062)

```python:解答例：answer_4-1-26.py
K, X = map(int, input().split())
if 500*K >= X:
    print("Yes")
else:
    print("No")
```

[ABC199 A - Square Inequality](https://atcoder.jp/contests/abc199/tasks/abc199_a) ｜ [提出結果](https://atcoder.jp/contests/abc199/submissions/45489102)

```python:解答例：answer_4-1-27.py
A, B, C = map(int, input().split())
if A**2+B**2 < C**2:
    print("Yes")
else:
    print("No")
```

[ABC177 A - Don't be late](https://atcoder.jp/contests/abc177/tasks/abc177_a) ｜ [提出結果](https://atcoder.jp/contests/abc177/submissions/45489142)

```python:解答例：answer_4-1-28.py
D, T, S = map(int, input().split())
if D <= S*T:
    print("Yes")
else:
    print("No")
```

[ABC152 A - AC or WA](https://atcoder.jp/contests/abc152/tasks/abc152_a) ｜ [提出結果](https://atcoder.jp/contests/abc152/submissions/45489178)

```python:解答例：answer_4-1-29.py
N, M = map(int, input().split())
if N == M:
    print("Yes")
else:
    print("No")
```

[ABC100 A - Happy Birthday!](https://atcoder.jp/contests/abc100/tasks/abc100_a) ｜ [提出結果](https://atcoder.jp/contests/abc100/submissions/45489214)

```python:解答例：answer_4-1-30.py
A, B = map(int, input().split())
if A <= 8 and B <= 8:
    print("Yay!")
else:
    print(":(")
```

[ABC343 A - Wrong Answer](https://atcoder.jp/contests/abc343/tasks/abc343_a) ｜ [提出結果](https://atcoder.jp/contests/abc343/submissions/50863460)

```python:解答例：answer_4-1-31.py
A, B = map(int, input().split())
if A+B == 0:
    print(1)
else:
    print(0)
```

[ABC096 A - Day of Takahashi](https://atcoder.jp/contests/abc096/tasks/abc096_a) ｜ [提出結果](https://atcoder.jp/contests/abc096/submissions/45489265)

```python:解答例：answer_4-1-32.py
a, b = map(int, input().split())
if a > b:
    print(a-1)
else:
    print(a)
```

[ABC104 A - Rated for Me](https://atcoder.jp/contests/abc104/tasks/abc104_a) ｜ [提出結果](https://atcoder.jp/contests/abc104/submissions/45489306)

```python:解答例：answer_4-1-33.py
R = int(input())
if R < 1200:
    print("ABC")
elif R < 2800:
    print("ARC")
else:
    print("AGC")
```

[ABC028 A - テスト評価](https://atcoder.jp/contests/abc028/tasks/abc028_a) ｜ [提出結果](https://atcoder.jp/contests/abc028/submissions/45489342)

```python:解答例：answer_4-1-34.py
N = int(input())
if N < 60:
    print("Bad")
elif N < 90:
    print("Good")
elif N < 100:
    print("Great")
else:
    print("Perfect")
```

[ABC214 A - New Generation ABC](https://atcoder.jp/contests/abc214/tasks/abc214_a) ｜ [提出結果](https://atcoder.jp/contests/abc214/submissions/45489381)

```python:解答例：answer_4-1-35.py
N = int(input())
if N <= 125:
    print(4)
elif N <= 211:
    print(6)
else:
    print(8)
```

[ABC219 A - AtCoder Quiz 2](https://atcoder.jp/contests/abc219/tasks/abc219_a) ｜ [提出結果](https://atcoder.jp/contests/abc219/submissions/45489406)

```python:解答例：answer_4-1-36.py
X = int(input())
if X < 40:
    print(40-X)
elif X < 70:
    print(70-X)
elif X < 90:
    print(90-X)
else:
    print("expert")
```

[ABC363 A - Piling Up](https://atcoder.jp/contests/abc363/tasks/abc363_a) ｜ [提出結果](https://atcoder.jp/contests/abc363/submissions/55978014)

```python:解答例：answer_4-1-37.py
R = int(input())
if R < 100:
    print(100-R)
elif R < 200:
    print(200-R)
else:
    print(300-R)
```

[ABC127 A - Ferris Wheel](https://atcoder.jp/contests/abc127/tasks/abc127_a) ｜ [提出結果](https://atcoder.jp/contests/abc127/submissions/45489445)

```python:解答例：answer_4-1-38.py
a, b = map(int, input().split())
if 12 < a:
    print(b)
elif 5 < a:
    print(b//2)
else:
    print(0)
```

[ABC212 A - Alloy](https://atcoder.jp/contests/abc212/tasks/abc212_a) ｜ [提出結果](https://atcoder.jp/contests/abc212/submissions/45489476)

```python:解答例：answer_4-1-39.py
A, B = map(int, input().split())
if B == 0:
    print("Gold")
elif A == 0:
    print("Silver")
else:
    print("Alloy")
```

[ABC030 A - 勝率計算](https://atcoder.jp/contests/abc030/tasks/abc030_a) ｜ [提出結果](https://atcoder.jp/contests/abc030/submissions/45489508)

```python:解答例：answer_4-1-40.py
A, B, C, D = map(int, input().split())
if B/A > D/C:
    print("TAKAHASHI")
elif B/A < D/C:
    print("AOKI")
else:
    print("DRAW")
```

[ABC366 A - Election 2](https://atcoder.jp/contests/abc366/tasks/abc366_a) ｜ [提出結果](https://atcoder.jp/contests/abc366/submissions/56765268)

```python:解答例：answer_4-1-41.py
N, T, A = map(int, input().split())
if T > N/2 or A > N/2:
    print("Yes")
else:
    print("No")
```

[ABC083 A - Libra](https://atcoder.jp/contests/abc083/tasks/abc083_a) ｜ [提出結果](https://atcoder.jp/contests/abc083/submissions/45489539)

```python:解答例：answer_4-1-42.py
A, B, C, D = map(int, input().split())
if A+B > C+D:
    print("Left")
elif A+B == C+D:
    print("Balanced")
else:
    print("Right")
```

[ABC392 A - Shuffled Equation](https://atcoder.jp/contests/abc392/tasks/abc392_a) ｜ [提出結果](https://atcoder.jp/contests/abc392/submissions/63074292)

```python:解答例：answer_4-1-43.py
a, b, c = map(int, input().split())
if a*b == c or b*c == a or c*a == b:
    print("Yes")
else:
    print("No")
```

[ABC370 A - Raise Both Hands](https://atcoder.jp/contests/abc370/tasks/abc370_a) ｜ [提出結果](https://atcoder.jp/contests/abc370/submissions/57701638)

```python:解答例：answer_4-1-44.py
L, R = map(int, input().split())
if L == 1 and R == 0:
    print("Yes")
elif L == 0 and R == 1:
    print("No")
else:
    print("Invalid")
```

[ABC065 A - Expired?](https://atcoder.jp/contests/abc065/tasks/abc065_a) ｜ [提出結果](https://atcoder.jp/contests/abc065/submissions/45489576)

```python:解答例：answer_4-1-45.py
X, A, B = map(int, input().split())
if X < B-A:
    print("dangerous")
elif A < B:
    print("safe")
else:
    print("delicious")
```

[ABC369 A - 369](https://atcoder.jp/contests/abc369/tasks/abc369_a) ｜ [提出結果](https://atcoder.jp/contests/abc369/submissions/57334215)

```python:解答例：answer_4-1-46.py
A, B = map(int, input().split())
if A == B:
    print(1)
elif (A-B) % 2 == 1:
    print(2)
else:
    print(3)
```

[ABC190 A - Very Very Primitive Game](https://atcoder.jp/contests/abc190/tasks/abc190_a) ｜ [提出結果](https://atcoder.jp/contests/abc190/submissions/45489615)

```python:解答例：answer_4-1-47.py
A, B, C = map(int, input().split())
if A < B:
    print("Aoki")
elif A > B:
    print("Takahashi")
elif C == 0:
    print("Aoki")
else:
    print("Takahashi")
```

[ABC245 A - Good morning](https://atcoder.jp/contests/abc245/tasks/abc245_a) ｜ [提出結果](https://atcoder.jp/contests/abc245/submissions/45489663)

```python:解答例：answer_4-1-48.py
A, B, C, D = map(int, input().split())
if A < C:
    print("Takahashi")
elif A > C:
    print("Aoki")
elif B <= D:
    print("Takahashi")
else:
    print("Aoki")
```

[ABC242 A - T-shirt](https://atcoder.jp/contests/abc242/tasks/abc242_a) ｜ [提出結果](https://atcoder.jp/contests/abc242/submissions/45489702)

```python:解答例：answer_4-1-49.py
A, B, C, X = map(int, input().split())
if X <= A:
    print(1)
elif X > B:
    print(0)
else:
    print(C/(B-A))
```

[ABC194 A - I Scream](https://atcoder.jp/contests/abc194/tasks/abc194_a) ｜ [提出結果](https://atcoder.jp/contests/abc194/submissions/45489744)

```python:解答例：answer_4-1-50.py
A, B = map(int, input().split())
if A+B >= 15 and B >= 8:
    print(1)
elif A+B >= 10 and B >= 3:
    print(2)
elif A+B >= 3:
    print(3)
else:
    print(4)
```

[ABC075 A - One out of Three](https://atcoder.jp/contests/abc075/tasks/abc075_a) ｜ [提出結果](https://atcoder.jp/contests/abc075/submissions/45489788)

```python:解答例：answer_4-1-51.py
A, B, C = map(int, input().split())
if A == B:
    print(C)
elif B == C:
    print(A)
elif C == A:
    print(B)
```

[ABC203 A - Chinchirorin](https://atcoder.jp/contests/abc203/tasks/abc203_a) ｜ [提出結果](https://atcoder.jp/contests/abc203/submissions/45489831)

```python:解答例：answer_4-1-52.py
a, b, c = map(int, input().split())
if a == b:
    print(c)
elif b == c:
    print(a)
elif c == a:
    print(b)
else:
    print(0)
```

[ABC209 A - Counting](https://atcoder.jp/contests/abc209/tasks/abc209_a) ｜ [提出結果](https://atcoder.jp/contests/abc209/submissions/45489874)

```python:解答例：answer_4-1-53.py
A, B = map(int, input().split())
if B-A+1 > 0:
    print(B-A+1)
else:
    print(0)
```

[ABC183 A - ReLU](https://atcoder.jp/contests/abc183/tasks/abc183_a) ｜ [提出結果](https://atcoder.jp/contests/abc183/submissions/45489916)

```python:解答例：answer_4-1-54.py
x = int(input())
if x > 0:
    print(x)
else:
    print(0)
```

[ABC072 A - Sandglass2](https://atcoder.jp/contests/abc072/tasks/abc072_a) ｜ [提出結果](https://atcoder.jp/contests/abc072/submissions/45489961)

```python:解答例：answer_4-1-55.py
X, t = map(int, input().split())
if X-t > 0:
    print(X-t)
else:
    print(0)
```

[ABC143 A - Curtain](https://atcoder.jp/contests/abc143/tasks/abc143_a) ｜ [提出結果](https://atcoder.jp/contests/abc143/submissions/45490007)

```python:解答例：answer_4-1-56.py
A, B = map(int, input().split())
if A-2*B > 0:
    print(A-2*B)
else:
    print(0)
```

[ABC136 A - Transfer](https://atcoder.jp/contests/abc136/tasks/abc136_a) ｜ [提出結果](https://atcoder.jp/contests/abc136/submissions/45490052)

```python:解答例：answer_4-1-57.py
A, B, C = map(int, input().split())
water = C-(A-B)
if water > 0:
    print(water)
else:
    print(0)
```

[ABC233 A - 10yen Stamp](https://atcoder.jp/contests/abc233/tasks/abc233_a) ｜ [提出結果](https://atcoder.jp/contests/abc233/submissions/45490091)

```python:解答例：answer_4-1-58.py
import math
X, Y = map(int, input().split())
if Y-X > 0:
    print(math.ceil((Y-X)/10))
else:
    print(0)
```

[ABC156 A - Beginner](https://atcoder.jp/contests/abc156/tasks/abc156_a) ｜ [提出結果](https://atcoder.jp/contests/abc156/submissions/45490132)

```python:解答例：answer_4-1-59.py
N, R = map(int, input().split())
if N >= 10:
    print(R)
else:
    print(R+100*(10-N))
```

[ABC024 A - 動物園](https://atcoder.jp/contests/abc024/tasks/abc024_a) ｜ [提出結果](https://atcoder.jp/contests/abc024/submissions/45490182)

```python:解答例：answer_4-1-60.py
A, B, C, K = map(int, input().split())
S, T = map(int, input().split())
if S+T < K:
    print(A*S+B*T)
else:
    print(A*S+B*T-(S+T)*C)
```

[ABC044 A - 高橋君とホテルイージー](https://atcoder.jp/contests/abc044/tasks/abc044_a) ｜ [提出結果](https://atcoder.jp/contests/abc044/submissions/45490232)

```python:解答例：answer_4-1-61.py
N, K, X, Y = [int(input()) for i in range(4)]
if N <= K:
    print(N*X)
else:
    print(K*X+(N-K)*Y)
```

[ABC210 A - Cabbages](https://atcoder.jp/contests/abc210/tasks/abc210_a) ｜ [提出結果](https://atcoder.jp/contests/abc210/submissions/45490277)

```python:解答例：answer_4-1-62.py
N, A, X, Y = map(int, input().split())
if N < A:
    print(N*X)
else:
    print(A*X+(N-A)*Y)
```

[ABC259 A - Growth Record](https://atcoder.jp/contests/abc259/tasks/abc259_a) ｜ [提出結果](https://atcoder.jp/contests/abc259/submissions/45490316)

```python:解答例：answer_4-1-63.py
N, M, X, T, D = map(int, input().split())
if M >= X:
    print(T)
else:
    print(T-(X-M)*D)
```

[ABC240 A - Edge Checker](https://atcoder.jp/contests/abc240/tasks/abc240_a) ｜ [提出結果](https://atcoder.jp/contests/abc240/submissions/45490348) ｜ [提出結果](https://atcoder.jp/contests/abc240/submissions/45490374)

```python:解答例：answer_4-1-64.py
a, b = map(int, input().split())
if (a == b-1) or (a == 1 and b == 10):
    print("Yes")
else:
    print("No")
```

```python:解答例：answer_4-1-65.py
a, b = map(int, input().split())
if b-a == 1 or b-a == 9:
    print("Yes")
else:
    print("No")
```

[ABC238 A - Exponential or Quadratic](https://atcoder.jp/contests/abc238/tasks/abc238_a) ｜ [提出結果](https://atcoder.jp/contests/abc238/submissions/45490404)

```python:解答例：answer_4-1-66.py
n = int(input())
if n == 2 or n == 3 or n == 4:
    print("No")
else:
    print("Yes")
```

[ABC406 A - Not Acceptable](https://atcoder.jp/contests/abc406/tasks/abc406_a) ｜ [提出結果](https://atcoder.jp/contests/abc406/submissions/66165582)

```python:解答例：answer_4-1-67.py
A, B, C, D = map(int, input().split())
if (C < A) or (C == A and D < B):
    print("Yes")
else:
    print("No")
```

[ABC331 A - Tomorrow](https://atcoder.jp/contests/abc331/tasks/abc331_a) ｜ [提出結果](https://atcoder.jp/contests/abc331/submissions/48176170)

```python:解答例：answer_4-1-68.py
M, D = map(int, input().split())
y, m, d = map(int, input().split())
if d == D and m == M:
    print(y+1, 1, 1)
elif d == D:
    print(y, m+1, 1)
else:
    print(y, m, d+1)
```

[ABC086 A - Product](https://atcoder.jp/contests/abc086/tasks/abc086_a) ｜ [提出結果](https://atcoder.jp/contests/abc086/submissions/45490535)

```python:解答例：answer_4-1-69.py
a, b = map(int, input().split())
if a*b % 2 == 0:
    print("Even")
else:
    print("Odd")
```

[ABC400 A - ABC400 Party](https://atcoder.jp/contests/abc400/tasks/abc400_a) ｜ [提出結果](https://atcoder.jp/contests/abc400/submissions/65292371)

```python:解答例：answer_4-1-70.py
A = int(input())
if 400 % A == 0:
    print(400//A)
else:
    print(-1)
```

[ABC102 A - Multiple of 2 and N](https://atcoder.jp/contests/abc102/tasks/abc102_a) ｜ [提出結果](https://atcoder.jp/contests/abc102/submissions/45490569)

```python:解答例：answer_4-1-71.py
N = int(input())
if N % 2 == 0:
    print(N)
else:
    print(N*2)
```

[ABC135 A - Harmony](https://atcoder.jp/contests/abc135/tasks/abc135_a) ｜ [提出結果](https://atcoder.jp/contests/abc135/submissions/45490590)

```python:解答例：answer_4-1-72.py
A, B = map(int, input().split())
if (A+B) % 2 == 0:
    print((A+B)//2)
else:
    print("IMPOSSIBLE")
```

[ABC181 A - Heavy Rotation](https://atcoder.jp/contests/abc181/tasks/abc181_a) ｜ [提出結果](https://atcoder.jp/contests/abc181/submissions/45490635)

```python:解答例：answer_4-1-73.py
N = int(input())
if N % 2 == 0:
    print("White")
else:
    print("Black")
```

[ABC118 A - B +/- A](https://atcoder.jp/contests/abc118/tasks/abc118_a) ｜ [提出結果](https://atcoder.jp/contests/abc118/submissions/45490666)

```python:解答例：answer_4-1-74.py
A, B = map(int, input().split())
if B % A == 0:
    print(A+B)
else:
    print(B-A)
```

[ABC195 A - Health M Death](https://atcoder.jp/contests/abc195/tasks/abc195_a) ｜ [提出結果](https://atcoder.jp/contests/abc195/submissions/45490687)

```python:解答例：answer_4-1-75.py
M, H = map(int, input().split())
if H % M == 0:
    print("Yes")
else:
    print("No")
```

[ABC016 A - 12月6日](https://atcoder.jp/contests/abc016/tasks/abc016_1) ｜ [提出結果](https://atcoder.jp/contests/abc016/submissions/45490712)

```python:解答例：answer_4-1-76.py
M, D = map(int, input().split())
if M % D == 0:
    print("YES")
else:
    print("NO")
```

[ABC088 A - Infinite Coins](https://atcoder.jp/contests/abc088/tasks/abc088_a) ｜ [提出結果](https://atcoder.jp/contests/abc088/submissions/45490740)

```python:解答例：answer_4-1-77.py
N = int(input())
A = int(input())
if N % 500 <= A:
    print("Yes")
else:
    print("No")
```

[ABC035 A - テレビ](https://atcoder.jp/contests/abc035/tasks/abc035_a) ｜ [提出結果](https://atcoder.jp/contests/abc035/submissions/45490766)

```python:解答例：answer_4-1-78.py
W, H = map(int, input().split())
if W*H % 144 == 0:
    print("16:9")
else:
    print("4:3")
```

[ABC105 A - AtCoder Crackers](https://atcoder.jp/contests/abc105/tasks/abc105_a) ｜ [提出結果](https://atcoder.jp/contests/abc105/submissions/45490796)

```python:解答例：answer_4-1-79.py
N, K = map(int, input().split())
if N % K == 0:
    print(0)
else:
    print(1)
```

[ABC142 A - Odds of Oddness](https://atcoder.jp/contests/abc142/tasks/abc142_a) ｜ [提出結果](https://atcoder.jp/contests/abc142/submissions/45490819)

```python:解答例：answer_4-1-80.py
N = int(input())
if N % 2 == 0:
    print(0.5)
else:
    print(((N//2)+1)/N)
```

[ABC302 A - Attack](https://atcoder.jp/contests/abc302/tasks/abc302_a) ｜ [提出結果](https://atcoder.jp/contests/abc302/submissions/45490847)

```python:解答例：answer_4-1-81.py
A, B = map(int, input().split())
if A % B == 0:
    print(A//B)
else:
    print(A//B+1)
```

[ABC153 A - Serval vs Monster](https://atcoder.jp/contests/abc153/tasks/abc153_a) ｜ [提出結果](https://atcoder.jp/contests/abc153/submissions/45490873)

```python:解答例：answer_4-1-82.py
H, A = map(int, input().split())
if H % A == 0:
    print(H//A)
else:
    print(H//A+1)
```

[ABC176 A - Takoyaki](https://atcoder.jp/contests/abc176/tasks/abc176_a) ｜ [提出結果](https://atcoder.jp/contests/abc176/submissions/45490907)

```python:解答例：answer_4-1-83.py
N, X, T = map(int, input().split())
if N % X == 0:
    print(T*(N//X))
else:
    print(T*(N//X+1))
```

[ABC067 A - Sharing Cookies](https://atcoder.jp/contests/abc067/tasks/abc067_a) ｜ [提出結果](https://atcoder.jp/contests/abc067/submissions/45490924)

```python:解答例：answer_4-1-84.py
A, B = map(int, input().split())
if A % 3 == 0 or B % 3 == 0 or (A+B) % 3 == 0:
    print("Possible")
else:
    print("Impossible")
```

[ABC262 A - World Cup](https://atcoder.jp/contests/abc262/tasks/abc262_a) ｜ [提出結果](https://atcoder.jp/contests/abc262/submissions/45490943)

```python:解答例：answer_4-1-85.py
Y = int(input())
if Y % 4 == 0:
    print(Y+2)
elif Y % 4 == 1:
    print(Y+1)
elif Y % 4 == 2:
    print(Y)
else:
    print(Y+3)
```

[ABC365 A - Leap Year](https://atcoder.jp/contests/abc365/tasks/abc365_a) ｜ [提出結果](https://atcoder.jp/contests/abc365/submissions/56764821)

```python:解答例：answer_4-1-86.py
Y = int(input())
if Y % 4 != 0:
    print(365)
elif Y % 4 == 0 and Y % 100 != 0:
    print(366)
elif Y % 100 == 0 and Y % 400 != 0:
    print(365)
elif Y % 400 == 0:
    print(366)
```

[ABC054 A - One Card Poker](https://atcoder.jp/contests/abc054/tasks/abc054_a) ｜ [提出結果](https://atcoder.jp/contests/abc054/submissions/45490964)

```python:解答例：answer_4-1-87.py
A, B = map(int, input().split())
if A == B:
    print("Draw")
elif (A+13) % 15 < (B+13) % 15:
    print("Bob")
else:
    print("Alice")
```

[ABC223 A - Exact Price](https://atcoder.jp/contests/abc223/tasks/abc223_a) ｜ [提出結果](https://atcoder.jp/contests/abc223/submissions/45490988)

```python:解答例：answer_4-1-88.py
X = int(input())
if X % 100 == 0 and X != 0:
    print("Yes")
else:
    print("No")
```

[ABC173 A - Payment](https://atcoder.jp/contests/abc173/tasks/abc173_a) ｜ [提出結果](https://atcoder.jp/contests/abc173/submissions/45491007)

```python:解答例：answer_4-1-89.py
N = int(input())
if N % 1000 == 0:
    print(0)
else:
    print(1000-(N % 1000))
```

[ABC265 A - Apple](https://atcoder.jp/contests/abc265/tasks/abc265_a) ｜ [提出結果](https://atcoder.jp/contests/abc265/submissions/45491030)

```python:解答例：answer_4-1-90.py
X, Y, N = map(int, input().split())
if X < Y/3:
    print(X*N)
else:
    print(Y*(N//3)+X*(N % 3))
```

[ABC367 A - Shout Everyday](https://atcoder.jp/contests/abc367/tasks/abc367_a) ｜ [提出結果](https://atcoder.jp/contests/abc367/submissions/57028276)

```python:解答例：answer_4-1-91.py
A, B, C = map(int, input().split())
if (B < C and not B < A < C) or (C < B and C < A < B):
    print("Yes")
else:
    print("No")
```

[ABC220 A - Find Multiple](https://atcoder.jp/contests/abc220/tasks/abc220_a) ｜ [提出結果](https://atcoder.jp/contests/abc220/submissions/45491061)

```python:解答例：answer_4-1-92.py
A, B, C = map(int, input().split())
mod = B-(B % C)
if A <= mod:
    print(mod)
else:
    print(-1)
```

[ABC243 A - Shampoo](https://atcoder.jp/contests/abc243/tasks/abc243_a) ｜ [提出結果](https://atcoder.jp/contests/abc243/submissions/45491080)

```python:解答例：answer_4-1-93.py
V, A, B, C = map(int, input().split())
V = V % (A+B+C)
if V-A < 0:
    print("F")
elif V-(A+B) < 0:
    print("M")
else:
    print("T")
```

[ABC014 A - けんしょう先生のお菓子配り](https://atcoder.jp/contests/abc014/tasks/abc014_1) ｜ [提出結果](https://atcoder.jp/contests/abc014/submissions/45491108)

```python:解答例：answer_4-1-94.py
a = int(input())
b = int(input())
if a % b != 0:
    print(b-(a % b))
else:
    print(0)
```

#### 文字列

```python:サンプルコード：sample_4-1-13.py
x = "a"
if x == "a":
    print("x == a")
else:
    print("else")
```

```text:実行結果
x == a
```

```python:サンプルコード：sample_4-1-14.py
x = "b"
if x == "a":
    print("x == a")
else:
    print("else")
```

```text:実行結果
else
```

```python:サンプルコード：sample_4-1-15.py
x = "a"
if x == "a":
    print("x == a")
elif x == "b":
    print("x == b")
else:
    print("else")
```

```text:実行結果
x == a
```

```python:サンプルコード：sample_4-1-16.py
x = "b"
if x == "a":
    print("x == a")
elif x == "b":
    print("x == b")
else:
    print("else")
```

```text:実行結果
x == b
```

```python:サンプルコード：sample_4-1-17.py
x = "c"
if x == "a":
    print("x == a")
elif x == "b":
    print("x == b")
else:
    print("else")
```

```text:実行結果
else
```

```python:サンプルコード：sample_4-1-18.py
x = "a"
y = "b"
if x < y:
    print("x < y")
elif x == y:
    print("x == y")
else:
    print("else")
```

```text:実行結果
x < y
```

```python:サンプルコード：sample_4-1-19.py
x = "a"
y = "a"
if x < y:
    print("x < y")
elif x == y:
    print("x == y")
else:
    print("else")
```

```text:実行結果
x == y
```

```python:サンプルコード：sample_4-1-20.py
x = "b"
y = "a"
if x < y:
    print("x < y")
elif x == y:
    print("x == y")
else:
    print("else")
```

```text:実行結果
else
```

[ABC215 A - Your First Judge](https://atcoder.jp/contests/abc215/tasks/abc215_a) ｜ [提出結果](https://atcoder.jp/contests/abc215/submissions/45491125)

```python:解答例：answer_4-1-95.py
S = input()
if S == "Hello,World!":
    print("AC")
else:
    print("WA")
```

[ABC166 A - A?C](https://atcoder.jp/contests/abc166/tasks/abc166_a) ｜ [提出結果](https://atcoder.jp/contests/abc166/submissions/45491155)

```python:解答例：answer_4-1-96.py
S = input()
if S == "ARC":
    print("ABC")
else:
    print("ARC")
```

[ABC122 A - Double Helix](https://atcoder.jp/contests/abc122/tasks/abc122_a) ｜ [提出結果](https://atcoder.jp/contests/abc122/submissions/45491193)

```python:解答例：answer_4-1-97.py
b = input()
if b == "A":
    print("T")
elif b == "T":
    print("A")
elif b == "C":
    print("G")
else:
    print("C")
```

[ABC358 A - Welcome to AtCoder Land](https://atcoder.jp/contests/abc358/tasks/abc358_a) ｜ [提出結果](https://atcoder.jp/contests/abc358/submissions/55100035) ｜ [提出結果](https://atcoder.jp/contests/abc358/submissions/55100128)

```python:解答例：answer_4-1-98.py
S, T = input().split()
if S == "AtCoder" and T == "Land":
    print("Yes")
else:
    print("No")
```

```python:解答例：answer_4-1-99.py
ST = input()
if ST == "AtCoder Land":
    print("Yes")
else:
    print("No")
```

[ABC393 A - Poisonous Oyster](https://atcoder.jp/contests/abc393/tasks/abc393_a) ｜ [提出結果](https://atcoder.jp/contests/abc393/submissions/63073496)

```python:解答例：answer_4-1-100.py
t, a = input().split()
if t == "sick" and a == "sick":
    print(1)
elif t == "sick":
    print(2)
elif a == "sick":
    print(3)
else:
    print(4)
```

[ABC078 A - HEX](https://atcoder.jp/contests/abc078/tasks/abc078_a) ｜ [提出結果](https://atcoder.jp/contests/abc078/submissions/45491229)

```python:解答例：answer_4-1-101.py
X, Y = input().split()
if X < Y:
    print("<")
elif X == Y:
    print("=")
else:
    print(">")
```

[ABC217 A - Lexicographic Order](https://atcoder.jp/contests/abc217/tasks/abc217_a) ｜ [提出結果](https://atcoder.jp/contests/abc217/submissions/45491251)

```python:解答例：answer_4-1-102.py
S, T = input().split()
if S < T:
    print("Yes")
else:
    print("No")
```

[ABC119 A - Still TBD](https://atcoder.jp/contests/abc119/tasks/abc119_a) ｜ [提出結果](https://atcoder.jp/contests/abc119/submissions/45491267)

```python:解答例：answer_4-1-103.py
S = input()
if S <= "2019/04/30":
    print("Heisei")
else:
    print("TBD")
```

[ABC154 A - Remaining Balls](https://atcoder.jp/contests/abc154/tasks/abc154_a) ｜ [提出結果](https://atcoder.jp/contests/abc154/submissions/45491285)

```python:解答例：answer_4-1-104.py
S, T = input().split()
A, B = map(int, input().split())
U = input()
if S == U:
    print(A-1, B)
else:
    print(A, B-1)
```

[ABC160 A - Coffee](https://atcoder.jp/contests/abc160/tasks/abc160_a) ｜ [提出結果](https://atcoder.jp/contests/abc160/submissions/52924658)

```python:解答例：answer_4-1-105.py
a, b, c, d, e, f = input()
if c == d and e == f:
    print("Yes")
else:
    print("No")
```

[ABC070 A - Palindromic Number](https://atcoder.jp/contests/abc070/tasks/abc070_a) ｜ [提出結果](https://atcoder.jp/contests/abc070/submissions/52924567)

```python:解答例：answer_4-1-106.py
a, b, c = input()
if a == c:
    print("Yes")
else:
    print("No")
```

[ABC371 A - Jiro](https://atcoder.jp/contests/abc371/tasks/abc371_a) ｜ [提出結果](https://atcoder.jp/contests/abc371/submissions/57792533)

```python:解答例：answer_4-1-107.py
AB, AC, BC = input().split()
if (AB == ">" and AC == "<") or (AC == ">" and AB == "<"):
    print("A")
elif (AB == "<" and BC == "<") or (BC == ">" and AB == ">"):
    print("B")
else:
    print("C")
```

[ABC056 A - HonestOrDishonest](https://atcoder.jp/contests/abc056/tasks/abc056_a) ｜ [提出結果](https://atcoder.jp/contests/abc056/submissions/45491324)

```python:解答例：answer_4-1-108.py
a, b = input().split()
if a == "H" and b == "H":
    print("H")
elif a == "H" and b == "D":
    print("D")
elif a == "D" and b == "H":
    print("D")
else:
    print("H")
```

[ABC229 A - First Grid](https://atcoder.jp/contests/abc229/tasks/abc229_a) ｜ [提出結果](https://atcoder.jp/contests/abc229/submissions/45491341)

```python:解答例：answer_4-1-109.py
S1 = input()
S2 = input()
if (S1 == "#." and S2 == ".#") or (S1 == ".#" and S2 == "#."):
    print("No")
else:
    print("Yes")
```

### if文 / in演算

文字列や要素の所属を評価する場合、`in`演算子を使用する。`if 探すデータ in 探されるデータ`となる。

#### 文字列

```python:サンプルコード：sample_4-1-21.py
if "a" in "abc":
    print("a in abc")
else:
    print("else")
```

```text:実行結果
a in abc
```

```python:サンプルコード：sample_4-1-22.py
if "ab" in "abc":
    print("ab in abc")
else:
    print("else")
```

```text:実行結果
ab in abc
```

```python:サンプルコード：sample_4-1-23.py
if "z" in "abc":
    print("z in abc")
else:
    print("else")
```

```text:実行結果
else
```

[ABC049 A - 居合を終え、青い絵を覆う](https://atcoder.jp/contests/abc049/tasks/abc049_a) ｜ [提出結果](https://atcoder.jp/contests/abc049/submissions/45491362)

```python:解答例：answer_4-1-110.py
c = input()
if c in "aiueo":
    print("vowel")
else:
    print("consonant")
```

[ABC114 A - 753](https://atcoder.jp/contests/abc114/tasks/abc114_a) ｜ [提出結果](https://atcoder.jp/contests/abc114/submissions/45491385)

```python:解答例：answer_4-1-111.py
X = input()
if X in "753":
    print("YES")
else:
    print("NO")
```

[ABC162 A - Lucky 7](https://atcoder.jp/contests/abc162/tasks/abc162_a) ｜ [提出結果](https://atcoder.jp/contests/abc162/submissions/45491404)

```python:解答例：answer_4-1-112.py
N = input()
if "7" in N:
    print("Yes")
else:
    print("No")
```

[ABC073 A - September 9](https://atcoder.jp/contests/abc073/tasks/abc073_a) ｜ [提出結果](https://atcoder.jp/contests/abc073/submissions/45491426)

```python:解答例：answer_4-1-113.py
N = input()
if "9" in N:
    print("Yes")
else:
    print("No")
```

[ABC006 A - 世界のFizzBuzz](https://atcoder.jp/contests/abc006/tasks/abc006_1) ｜ [提出結果](https://atcoder.jp/contests/abc006/submissions/45491448)

```python:解答例：answer_4-1-114.py
N = input()
if N in "369":
    print("YES")
else:
    print("NO")
```

[ABC171 A - αlphabet](https://atcoder.jp/contests/abc171/tasks/abc171_a) ｜ [提出結果](https://atcoder.jp/contests/abc171/submissions/45491468) ｜ [提出結果](https://atcoder.jp/contests/abc171/submissions/45491488)

```python:解答例：answer_4-1-115.py
a = input()
if a in "abcdefghijklmnopqrstuvwxyz":
    print("a")
else:
    print("A")
```

```python:解答例：answer_4-1-116.py
a = input()
if a in "ABCDEFGHIJKLMNOPQRSTUVWXYZ":
    print("A")
else:
    print("a")
```

[ABC327 A - ab](https://atcoder.jp/contests/abc327/tasks/abc327_a) ｜ [提出結果](https://atcoder.jp/contests/abc327/submissions/47315026)

```python:解答例：answer_4-1-117.py
N = int(input())
S = input()
if "ab" in S or "ba" in S:
    print("Yes")
else:
    print("No")
```

[ABC298 A - Job Interview](https://atcoder.jp/contests/abc298/tasks/abc298_a) ｜ [提出結果](https://atcoder.jp/contests/abc298/submissions/45491506)

```python:解答例：answer_4-1-118.py
N = int(input())
S = input()
if "o" in S and "x" not in S:
    print("Yes")
else:
    print("No")
```

[ABC296 A - Alternately](https://atcoder.jp/contests/abc296/tasks/abc296_a) ｜ [提出結果](https://atcoder.jp/contests/abc296/submissions/45491522)

```python:解答例：answer_4-1-119.py
N = int(input())
S = input()
if "MM" in S or "FF" in S:
    print("No")
else:
    print("Yes")
```

[ABC109 A - ABC333](https://atcoder.jp/contests/abc109/tasks/abc109_a) ｜ [提出結果](https://atcoder.jp/contests/abc109/submissions/45491539) ｜ [提出結果](https://atcoder.jp/contests/abc109/submissions/45491562)

```python:解答例：answer_4-1-120.py
A, B = input().split()
if "2" in A or "2" in B:
    print("No")
else:
    print("Yes")
```

```python:解答例：answer_4-1-121.py
AB = input()
if "2" in AB:
    print("No")
else:
    print("Yes")
```

#### リスト

```python:サンプルコード：sample_4-1-24.py
if "a" in ["a", "b", "c"]:
    print("a in list")
else:
    print("else")
```

```text:実行結果
a in list
```

```python:サンプルコード：sample_4-1-25.py
if "ab" in ["a", "b", "c"]:
    print("ab in list")
else:
    print("else")
```

```text:実行結果
else
```

```python:サンプルコード：sample_4-1-26.py
if 10 in [10, 20, 30]:
    print("10 in list")
else:
    print("else")
```

```text:実行結果
10 in list
```

[ABC312 A - Chord](https://atcoder.jp/contests/abc312/tasks/abc312_a) ｜ [提出結果](https://atcoder.jp/contests/abc312/submissions/45491578)

```python:解答例：answer_4-1-122.py
S = input()
if S in ["ACE", "BDF", "CEG", "DFA", "EGB", "FAC", "GBD"]:
    print("Yes")
else:
    print("No")
```

[ABC377 A - Rearranging ABC](https://atcoder.jp/contests/abc377/tasks/abc377_a) ｜ [提出結果](https://atcoder.jp/contests/abc377/submissions/59666170)

```python:解答例：answer_4-1-123.py
S = input()
if S in ["ABC", "ACB", "BAC", "BCA", "CAB", "CBA"]:
    print("Yes")
else:
    print("No")
```

[ABC309 A - Nine](https://atcoder.jp/contests/abc309/tasks/abc309_a) ｜ [提出結果](https://atcoder.jp/contests/abc309/submissions/45491633)

```python:解答例：answer_4-1-124.py
A, B = map(int, input().split())
X = [[1, 2], [2, 3], [4, 5], [5, 6], [7, 8], [8, 9]]
if [A, B] in X:
    print("Yes")
else:
    print("No")
```

[ABC390 A - 12435](https://atcoder.jp/contests/abc390/tasks/abc390_a) ｜ [提出結果](https://atcoder.jp/contests/abc390/submissions/62101799)

```python:解答例：answer_4-1-125.py
A = list(map(int, input().split()))
if A in [[2, 1, 3, 4, 5], [1, 3, 2, 4, 5], [1, 2, 4, 3, 5], [1, 2, 3, 5, 4]]:
    print("Yes")
else:
    print("No")
```

[ABC285 A - Edge Checker 2](https://atcoder.jp/contests/abc285/tasks/abc285_a) ｜ [提出結果](https://atcoder.jp/contests/abc285/submissions/45491677)

```python:解答例：answer_4-1-126.py
a, b = map(int, input().split())
graph = [[1, 2], [1, 3], [2, 4], [2, 5], [3, 6], [3, 7], [4, 8],
         [4, 9], [5, 10], [5, 11], [6, 12], [6, 13], [7, 14], [7, 15]]
if [a, b] in graph:
    print("Yes")
else:
    print("No")
```

#### 集合

```python:サンプルコード：sample_4-1-27.py
if "a" in {"a", "b", "c"}:
    print("a in set")
else:
    print("else")
```

```text:実行結果
a in set
```

```python:サンプルコード：sample_4-1-28.py
if "ab" in {"a", "b", "c"}:
    print("ab in set")
else:
    print("else")
```

```text:実行結果
else
```

```python:サンプルコード：sample_4-1-29.py
if 10 in {10, 20, 30}:
    print("10 in set")
else:
    print("else")
```

```text:実行結果
10 in set
```

[ABC309 A - Nine](https://atcoder.jp/contests/abc309/tasks/abc309_a) ｜ [提出結果](https://atcoder.jp/contests/abc309/submissions/45491655)

```python:解答例：answer_4-1-127.py
A, B = map(int, input().split())
X = {(1, 2), (2, 3), (4, 5), (5, 6), (7, 8), (8, 9)}
if (A, B) in X:
    print("Yes")
else:
    print("No")
```

[ABC285 A - Edge Checker 2](https://atcoder.jp/contests/abc285/tasks/abc285_a) ｜ [提出結果](https://atcoder.jp/contests/abc285/submissions/45491701)

```python:解答例：answer_4-1-128.py
a, b = map(int, input().split())
graph = {(1, 2), (1, 3), (2, 4), (2, 5), (3, 6), (3, 7), (4, 8),
         (4, 9), (5, 10), (5, 11), (6, 12), (6, 13), (7, 14), (7, 15)}
if (a, b) in graph:
    print("Yes")
else:
    print("No")
```

### 複数条件式

条件式を複数組み合わせることができる。

#### 数値

```python:サンプルコード：sample_4-1-30.py
x = 10
y = 10
z = 10
if x == y == z:
    print("x == y == z")
else:
    print("else")
```

```text:実行結果
x == y == z
```

```python:サンプルコード：sample_4-1-31.py
x = 10
y = 20
z = 30
if x < y < z:
    print("x < y < z")
else:
    print("else")
```

```text:実行結果
x < y < z
```

[ABC401 A - Status Code](https://atcoder.jp/contests/abc401/tasks/abc401_a) ｜ [提出結果](https://atcoder.jp/contests/abc401/submissions/65292764)

```python:解答例：answer_4-1-129.py
S = int(input())
if 200 <= S <= 299:
    print("Success")
else:
    print("Failure")
```

[ABC061 A - Between Two Integers](https://atcoder.jp/contests/abc061/tasks/abc061_a) ｜ [提出結果](https://atcoder.jp/contests/abc061/submissions/45491719)

```python:解答例：answer_4-1-130.py
A, B, C = map(int, input().split())
if A <= C <= B:
    print("Yes")
else:
    print("No")
```

[ABC237 A - Not Overflow](https://atcoder.jp/contests/abc237/tasks/abc237_a) ｜ [提出結果](https://atcoder.jp/contests/abc237/submissions/45491739)

```python:解答例：answer_4-1-131.py
N = int(input())
if -2**31 <= N < 2**31:
    print("Yes")
else:
    print("No")
```

[ABC326 A - 2UP3DOWN](https://atcoder.jp/contests/abc326/tasks/abc326_a) ｜ [提出結果](https://atcoder.jp/contests/abc326/submissions/47074068)

```python:解答例：answer_4-1-132.py
X, Y = map(int, input().split())
if -3 <= Y-X <= 2:
    print("Yes")
else:
    print("No")
```

[ABC253 A - Median?](https://atcoder.jp/contests/abc253/tasks/abc253_a) ｜ [提出結果](https://atcoder.jp/contests/abc253/submissions/45491756)

```python:解答例：answer_4-1-133.py
a, b, c = map(int, input().split())
if a <= b <= c or c <= b <= a:
    print("Yes")
else:
    print("No")
```

[ABC352 A - AtCoder Line](https://atcoder.jp/contests/abc352/tasks/abc352_a) ｜ [提出結果](https://atcoder.jp/contests/abc352/submissions/53248582)

```python:解答例：answer_4-1-134.py
N, X, Y, Z = map(int, input().split())
if X < Z < Y or X > Z > Y:
    print("Yes")
else:
    print("No")
```

[ABC219 A - AtCoder Quiz 2](https://atcoder.jp/contests/abc219/tasks/abc219_a) ｜ [提出結果](https://atcoder.jp/contests/abc219/submissions/45491777)

```python:解答例：answer_4-1-135.py
X = int(input())
if 0 <= X < 40:
    print(40-X)
elif 40 <= X < 70:
    print(70-X)
elif 70 <= X < 90:
    print(90-X)
else:
    print("expert")
```

[ABC079 A - Good Integer](https://atcoder.jp/contests/abc079/tasks/abc079_a) ｜ [提出結果](https://atcoder.jp/contests/abc079/submissions/52924212)

```python:解答例：answer_4-1-136.py
a, b, c, d = map(int, input())
if a == b == c or b == c == d:
    print("Yes")
else:
    print("No")
```

[ABC131 A - Security](https://atcoder.jp/contests/abc131/tasks/abc131_a) ｜ [提出結果](https://atcoder.jp/contests/abc131/submissions/52923986)

```python:解答例：answer_4-1-137.py
a, b, c, d = map(int, input())
if a != b != c != d:
    print("Good")
else:
    print("Bad")
```

[ABC208 A - Rolling Dice](https://atcoder.jp/contests/abc208/tasks/abc208_a) ｜ [提出結果](https://atcoder.jp/contests/abc208/submissions/45491847)

```python:解答例：answer_4-1-138.py
A, B = map(int, input().split())
if A <= B <= 6*A:
    print("Yes")
else:
    print("No")
```

[ABC144 A - 9x9](https://atcoder.jp/contests/abc144/tasks/abc144_a) ｜ [提出結果](https://atcoder.jp/contests/abc144/submissions/45491870)

```python:解答例：answer_4-1-139.py
A, B = map(int, input().split())
if 1 <= A <= 9 and 1 <= B <= 9:
    print(A*B)
else:
    print(-1)
```

[ABC191 A - Vanishing Pitch](https://atcoder.jp/contests/abc191/tasks/abc191_a) ｜ [提出結果](https://atcoder.jp/contests/abc191/submissions/45491888)

```python:解答例：answer_4-1-140.py
V, T, S, D = map(int, input().split())
if V*T <= D <= V*S:
    print("No")
else:
    print("Yes")
```

[ABC094 A - Cats and Dogs](https://atcoder.jp/contests/abc094/tasks/abc094_a) ｜ [提出結果](https://atcoder.jp/contests/abc094/submissions/45491902) ｜ [提出結果](https://atcoder.jp/contests/abc094/submissions/45491921)

```python:解答例：answer_4-1-141.py
A, B, X = map(int, input().split())
if A <= X <= A+B:
    print("YES")
else:
    print("NO")
```

```python:解答例：answer_4-1-142.py
A, B, X = map(int, input().split())
if 0 <= X-A <= B:
    print("YES")
else:
    print("NO")
```

[ABC405 A - Is it rated?](https://atcoder.jp/contests/abc405/tasks/abc405_a) ｜ [提出結果](https://atcoder.jp/contests/abc405/submissions/66165069)

```python:解答例：answer_4-1-143.py
R, X = map(int, input().split())
if (X == 1 and 1600 <= R <= 2999) or (X == 2 and 1200 <= R <= 2399):
    print("Yes")
else:
    print("No")
```

[ABC228 A - On and Off](https://atcoder.jp/contests/abc228/tasks/abc228_a) ｜ [提出結果](https://atcoder.jp/contests/abc228/submissions/45491944)

```python:解答例：answer_4-1-144.py
S, T, X = map(int, input().split())
if S < T:
    if S <= X < T:
        print("Yes")
    else:
        print("No")
else:
    if X < T or S <= X:
        print("Yes")
    else:
        print("No")
```

[ABC238 A - Exponential or Quadratic](https://atcoder.jp/contests/abc238/tasks/abc238_a) ｜ [提出結果](https://atcoder.jp/contests/abc238/submissions/45491965)

```python:解答例：answer_4-1-145.py
n = int(input())
if 2 <= n <= 4:
    print("No")
else:
    print("Yes")
```

#### 文字列

```python:サンプルコード：sample_4-1-32.py
x = "abc"
y = "abc"
z = "abc"
if x == y == z:
    print("x == y == z")
else:
    print("else")
```

```text:実行結果
x == y == z
```

```python:サンプルコード：sample_4-1-33.py
x = "a"
y = "b"
z = "c"
if x < y < z:
    print("x < y < z")
else:
    print("else")
```

```text:実行結果
x < y < z
```

[ABC189 A - Slot](https://atcoder.jp/contests/abc189/tasks/abc189_a) ｜ [提出結果](https://atcoder.jp/contests/abc189/submissions/52924719)

```python:解答例：answer_4-1-146.py
a, b, c = input()
if a == b == c:
    print("Won")
else:
    print("Lost")
```

[ABC079 A - Good Integer](https://atcoder.jp/contests/abc079/tasks/abc079_a) ｜ [提出結果](https://atcoder.jp/contests/abc079/submissions/45491800)

```python:解答例：answer_4-1-147.py
a, b, c, d = input()
if a == b == c or b == c == d:
    print("Yes")
else:
    print("No")
```

[ABC350 A - Past ABCs](https://atcoder.jp/contests/abc350/tasks/abc350_a) ｜ [提出結果](https://atcoder.jp/contests/abc350/submissions/52692413)

```python:解答例：answer_4-1-148.py
S = input()
if "ABC001" <= S <= "ABC349" and S != "ABC316":
    print("Yes")
else:
    print("No")
```

[ABC131 A - Security](https://atcoder.jp/contests/abc131/tasks/abc131_a) ｜ [提出結果](https://atcoder.jp/contests/abc131/submissions/45491822)

```python:解答例：answer_4-1-149.py
a, b, c, d = input()
if a != b != c != d:
    print("Good")
else:
    print("Bad")
```

## 4.2 反復処理

<b>キーポイント</b>

* 反復処理は「for文」と「while文」がある。
* `in`演算を使った「for文」は`for 変数 in リスト:`となる。
* range関数を使った「for文」は`for 変数 in range(初期値, 終了値):`となる。初期値を指定しない場合、変数は **0** から始まる。
* 「for文」で`else`節を使用することができる。
* 「while文」は`while 条件式:`となる。条件式が`True`の場合、while文の中の処理を続ける。

### for文 / in演算

#### リスト

`in`演算を使ったfor文は`for 変数 in リスト:`となる。

```python:サンプルコード：sample_4-2-1.py
x = [1, 2, 3]
for i in x:
    print(i)
```

```text:実行結果
1
2
3
```

```python:サンプルコード：sample_4-2-2.py
x = ["a", "b", "c"]
for i in x:
    print(i)
```

```text:実行結果
a
b
c
```

[ABC272 A - Integer Sum](https://atcoder.jp/contests/abc272/tasks/abc272_a) ｜ [提出結果](https://atcoder.jp/contests/abc272/submissions/45491981)

```python:解答例：answer_4-2-1.py
N = int(input())
A = list(map(int, input().split()))
total = 0
for a in A:
    total += a
print(total)
```

[ABC202 A - Three Dice](https://atcoder.jp/contests/abc202/tasks/abc202_a) ｜ [提出結果](https://atcoder.jp/contests/abc202/submissions/45491998)

```python:解答例：answer_4-2-2.py
abc = list(map(int, input().split()))
total = 0
for dice in abc:
    total += 7-dice
print(total)
```

[ABC147 A - Blackjack](https://atcoder.jp/contests/abc147/tasks/abc147_a) ｜ [提出結果](https://atcoder.jp/contests/abc147/submissions/45492055)

```python:解答例：answer_4-2-3.py
A = list(map(int, input().split()))
total = 0
for a in A:
    total += a
if total >= 22:
    print("bust")
else:
    print("win")
```

[ABC330 A - Counting Passes](https://atcoder.jp/contests/abc330/tasks/abc330_a) ｜ [提出結果](https://atcoder.jp/contests/abc330/submissions/48176347)

```python:解答例：answer_4-2-4.py
N, L = map(int, input().split())
A = list(map(int, input().split()))
count = 0
for a in A:
    if a >= L:
        count += 1
print(count)
```

[ABC328 A - Not Too Hard](https://atcoder.jp/contests/abc328/tasks/abc328_a) ｜ [提出結果](https://atcoder.jp/contests/abc328/submissions/48176926)

```python:解答例：answer_4-2-5.py
N, X = map(int, input().split())
S = list(map(int, input().split()))
total = 0
for s in S:
    if s <= X:
        total += s
print(total)
```

[ABC300 A - N-choice question](https://atcoder.jp/contests/abc300/tasks/abc300_a) ｜ [提出結果](https://atcoder.jp/contests/abc300/submissions/45492035)

```python:解答例：answer_4-2-6.py
N, A, B = map(int, input().split())
C = list(map(int, input().split()))
idx = 1
for c in C:
    if A+B == c:
        print(idx)
    else:
        idx += 1
```

[ABC294 A - Filter](https://atcoder.jp/contests/abc294/tasks/abc294_a) ｜ [提出結果](https://atcoder.jp/contests/abc294/submissions/45492081)

```python:解答例：answer_4-2-7.py
N = int(input())
A = list(map(int, input().split()))
for a in A:
    if a % 2 == 0:
        print(a, end=" ")
```

[ABC347 A - Divisible](https://atcoder.jp/contests/abc347/tasks/abc347_a) ｜ [提出結果](https://atcoder.jp/contests/abc347/submissions/51921156)

```python:解答例：answer_4-2-8.py
N, K = map(int, input().split())
A = list(map(int, input().split()))
for a in A:
    if a % K == 0:
        print(a//K, end=" ")
```

#### 文字列

```python:サンプルコード：sample_4-2-3.py
x = "abc"
for i in x:
    print(i)
```

```text:実行結果
a
b
c
```

```python:サンプルコード：sample_4-2-4.py
x = "012"
for i in x:
    print(i)
```

```text:実行結果
0
1
2
```

[ABC329 A - Spread](https://atcoder.jp/contests/abc329/tasks/abc329_a) ｜ [提出結果](https://atcoder.jp/contests/abc329/submissions/48176583)

```python:解答例：answer_4-2-9.py
S = input()
for s in S:
    print(s, end=" ")
```

[ABC382 A - Daily Cookie](https://atcoder.jp/contests/abc382/tasks/abc382_a) ｜ [提出結果](https://atcoder.jp/contests/abc382/submissions/61012286)

```python:解答例：answer_4-2-10.py
N, D = map(int, input().split())
S = input()
a = 0
for s in S:
    if s == "@":
        a += 1
print(N-a+D)
```

[ABC279 A - wwwvvvvvv](https://atcoder.jp/contests/abc279/tasks/abc279_a) ｜ [提出結果](https://atcoder.jp/contests/abc279/submissions/50517191)

```python:解答例：answer_4-2-11.py
S = input()
count = 0
for s in S:
    if s == "v":
        count += 1
    if s == "w":
        count += 2
print(count)
```

### for文 / range関数

range関数を使ったfor文は`for 変数 in range(初期値, 終了値, ステップ数):`となる。初期値を指定しない場合、変数は **0** から始まる。

```python:サンプルコード：sample_4-2-5.py
for i in range(5):
    print(i)
```

```text:実行結果
0
1
2
3
4
```

```python:サンプルコード：sample_4-2-6.py
for i in range(2, 5):
    print(i)
```

```text:実行結果
2
3
4
```

```python:サンプルコード：sample_4-2-7.py
for i in range(2, 5, 2):
    print(i)
```

```text:実行結果
2
4
```

```python:サンプルコード：sample_4-2-8.py
for i in range(3, -1, -1):
    print(i)
```

```text:実行結果
3
2
1
0
```

[ABC288 A - Many A+B Problems](https://atcoder.jp/contests/abc288/tasks/abc288_a) ｜ [提出結果](https://atcoder.jp/contests/abc288/submissions/45492101)

```python:解答例：answer_4-2-12.py
N = int(input())
for i in range(N):
    A, B = map(int, input().split())
    print(A+B)
```

[ABC008 A - アルバム](https://atcoder.jp/contests/abc008/tasks/abc008_1) ｜ [提出結果](https://atcoder.jp/contests/abc008/submissions/45492114)

```python:解答例：answer_4-2-13.py
S, T = map(int, input().split())
picture = 0
for i in range(S, T+1):
    picture += 1
print(picture)
```

[ABC043 A - キャンディーとN人の子供イージー](https://atcoder.jp/contests/abc043/tasks/abc043_a) ｜ [提出結果](https://atcoder.jp/contests/abc043/submissions/45492139)

```python:解答例：answer_4-2-14.py
N = int(input())
candy = 0
for i in range(1, N+1):
    candy += i
print(candy)
```

[ABC281 A - Count Down](https://atcoder.jp/contests/abc281/tasks/abc281_a) ｜ [提出結果](https://atcoder.jp/contests/abc281/submissions/45492175) ｜ [提出結果](https://atcoder.jp/contests/abc281/submissions/45492196)

```python:解答例：answer_4-2-15.py
N = int(input())
for i in range(N+1):
    print(N-i)
```

```python:解答例：answer_4-2-16.py
N = int(input())
for i in range(N, -1, -1):
    print(i)
```

[ABC340 A - Arithmetic Progression](https://atcoder.jp/contests/abc340/tasks/abc340_a) ｜ [提出結果](https://atcoder.jp/contests/abc340/submissions/50291459)

```python:解答例：answer_4-2-17.py
A, B, D = map(int, input().split())
for i in range(A, B+1, D):
    print(i, end=" ")
```

[ABC021 A - 足し算](https://atcoder.jp/contests/abc021/tasks/abc021_a) ｜ [提出結果](https://atcoder.jp/contests/abc021/submissions/45492222)

```python:解答例：answer_4-2-18.py
N = int(input())
print(N)
for i in range(N):
    print(1)
```

[ABC332 A - Online Shopping](https://atcoder.jp/contests/abc332/tasks/abc332_a) ｜ [提出結果](https://atcoder.jp/contests/abc332/submissions/48598219)

```python:解答例：answer_4-2-19.py
N, S, K = map(int, input().split())
total = 0
for i in range(N):
    P, Q = map(int, input().split())
    total += P*Q
if total >= S:
    print(total)
else:
    print(total+K)
```

[ABC337 A - Scoreboard](https://atcoder.jp/contests/abc337/tasks/abc337_a) ｜ [提出結果](https://atcoder.jp/contests/abc337/submissions/50516519)

```python:解答例：answer_4-2-20.py
N = int(input())
takahashi, aoki = 0, 0
for i in range(N):
    X, Y = map(int, input().split())
    takahashi += X
    aoki += Y
if takahashi > aoki:
    print("Takahashi")
elif takahashi < aoki:
    print("Aoki")
else:
    print("Draw")
```

[ABC300 A - N-choice question](https://atcoder.jp/contests/abc300/tasks/abc300_a) ｜ [提出結果](https://atcoder.jp/contests/abc300/submissions/45492253)

```python:解答例：answer_4-2-21.py
N, A, B = map(int, input().split())
C = list(map(int, input().split()))
for i in range(N):
    if A+B == C[i]:
        print(i+1)
```

[ABC277 A - ^{-1}](https://atcoder.jp/contests/abc277/tasks/abc277_a) ｜ [提出結果](https://atcoder.jp/contests/abc277/submissions/45492236)

```python:解答例：answer_4-2-22.py
N, X = map(int, input().split())
P = list(map(int, input().split()))
for i in range(N):
    if P[i] == X:
        print(i+1)
```

[ABC317 A - Potions](https://atcoder.jp/contests/abc317/tasks/abc317_a) ｜ [提出結果](https://atcoder.jp/contests/abc317/submissions/45492275)

```python:解答例：answer_4-2-23.py
N, H, X = map(int, input().split())
P = list(map(int, input().split()))
for i in range(N):
    if H+P[i] >= X:
        print(i+1)
        break
```

[ABC318 A - Full Moon](https://atcoder.jp/contests/abc318/tasks/abc318_a) ｜ [提出結果](https://atcoder.jp/contests/abc318/submissions/45492263)

```python:解答例：answer_4-2-24.py
N, M, P = map(int, input().split())
count = 0
for i in range(N):
    if M <= N:
        count += 1
        M += P
print(count)
```

[ABC357 A - Sanitize Hands](https://atcoder.jp/contests/abc357/tasks/abc357_a) ｜ [提出結果](https://atcoder.jp/contests/abc357/submissions/55099593)

```python:解答例：answer_4-2-25.py
N, M = map(int, input().split())
H = list(map(int, input().split()))
count = 0
for i in range(N):
    M -= H[i]
    if M < 0:
        break
    else:
        count += 1
print(count)
```

[ABC022 A - Best Body](https://atcoder.jp/contests/abc022/tasks/abc022_a) ｜ [提出結果](https://atcoder.jp/contests/abc022/submissions/45492291)

```python:解答例：answer_4-2-26.py
N, S, T = map(int, input().split())
W = int(input())
day = 0
if S <= W <= T:
    day += 1
for i in range(N-1):
    A = int(input())
    W += A
    if S <= W <= T:
        day += 1
print(day)
```

[ABC003 A - AtCoder社の給料](https://atcoder.jp/contests/abc003/tasks/abc003_1) ｜ [提出結果](https://atcoder.jp/contests/abc003/submissions/45492159)

```python:解答例：answer_4-2-27.py
N = int(input())
salary = 0
for i in range(1, N+1):
    salary += i*10000*(1/N)
print(salary)
```

[ABC249 A - Jogging](https://atcoder.jp/contests/abc249/tasks/abc249_a) ｜ [提出結果](https://atcoder.jp/contests/abc249/submissions/45492310)

```python:解答例：answer_4-2-28.py
A, B, C, D, E, F, X = map(int, input().split())
takahashi = 0
aoki = 0
for i in range(X):
    if i % (A+C) < A:
        takahashi += B
    if i % (D+F) < D:
        aoki += E
if takahashi > aoki:
    print("Takahashi")
elif takahashi < aoki:
    print("Aoki")
else:
    print("Draw")
```

### for文 / else節

for文で`else`節を使用することができる。for文で反復処理を`break`せずに終了した場合、`else`節が実行される。

```python:サンプルコード：sample_4-2-9.py
x = False
for i in range(5):
    if x:
        print(True)
        break
else:
    print(False)
```

```text:実行結果
False
```

[ABC396 A - Triple Four](https://atcoder.jp/contests/abc396/tasks/abc396_a) ｜ [提出結果](https://atcoder.jp/contests/abc396/submissions/64344106)

```python:解答例：answer_4-2-29.py
N = int(input())
A = list(map(int, input().split()))
for i in range(N-2):
    if A[i] == A[i+1] == A[i+2]:
        print("Yes")
        break
else:
    print("No")
```

[ABC220 A - Find Multiple](https://atcoder.jp/contests/abc220/tasks/abc220_a) ｜ [提出結果](https://atcoder.jp/contests/abc220/submissions/45492342)

```python:解答例：answer_4-2-30.py
A, B, C = map(int, input().split())
for i in range(A, B+1):
    if i % C == 0:
        print(i)
        break
else:
    print(-1)
```

[ABC165 A - We Love Golf](https://atcoder.jp/contests/abc165/tasks/abc165_a) ｜ [提出結果](https://atcoder.jp/contests/abc165/submissions/45492329)

```python:解答例：answer_4-2-31.py
K = int(input())
A, B = map(int, input().split())
for i in range(A, B+1):
    if i % K == 0:
        print("OK")
        break
else:
    print("NG")
```

[ABC295 A - Probably English](https://atcoder.jp/contests/abc295/tasks/abc295_a) ｜ [提出結果](https://atcoder.jp/contests/abc295/submissions/45492355)

```python:解答例：answer_4-2-32.py
N = int(input())
W = input().split()
S = {"and", "not", "that", "the", "you"}
for w in W:
    if w in S:
        print("Yes")
        break
else:
    print("No")
```

[ABC296 A - Alternately](https://atcoder.jp/contests/abc296/tasks/abc296_a) ｜ [提出結果](https://atcoder.jp/contests/abc296/submissions/50518243) ｜ [提出結果](https://atcoder.jp/contests/abc296/submissions/45492375)

```python:解答例：answer_4-2-33.py
N = int(input())
S = input()
for i in range(N-1):
    if S[i] != S[i+1]:
        continue
    else:
        print("No")
        break
else:
    print("Yes")
```

```python:解答例：answer_4-2-34.py
N = int(input())
S = input()
for i in range(N-1):
    if S[i] == S[i+1]:
        print("No")
        break
else:
    print("Yes")
```

[ABC395 A - Strictly Increasing?](https://atcoder.jp/contests/abc395/tasks/abc395_a) ｜ [提出結果](https://atcoder.jp/contests/abc395/submissions/64341937) ｜ [提出結果](https://atcoder.jp/contests/abc395/submissions/64342581)

```python:解答例：answer_4-2-35.py
N = int(input())
A = list(map(int, input().split()))
for i in range(N-1):
    if A[i] < A[i+1]:
        continue
    else:
        print("No")
        break
else:
    print("Yes")
```

```python:解答例：answer_4-2-36.py
N = int(input())
A = list(map(int, input().split()))
for i in range(N-1):
    if A[i] >= A[i+1]:
        print("No")
        break
else:
    print("Yes")
```

[ABC321 A - 321-like Checker](https://atcoder.jp/contests/abc321/tasks/abc321_a) ｜ [提出結果](https://atcoder.jp/contests/abc321/submissions/50518398) ｜ [提出結果](https://atcoder.jp/contests/abc321/submissions/45924311)

```python:解答例：answer_4-2-37.py
N = input()
for i in range(len(N)-1):
    if N[i] > N[i+1]:
        continue
    else:
        print("No")
        break
else:
    print("Yes")
```

```python:解答例：answer_4-2-38.py
N = input()
for i in range(len(N)-1):
    if N[i] <= N[i+1]:
        print("No")
        break
else:
    print("Yes")
```

[ABC323 A - Weak Beats](https://atcoder.jp/contests/abc323/tasks/abc323_a) ｜ [提出結果](https://atcoder.jp/contests/abc323/submissions/46358350) ｜ [提出結果](https://atcoder.jp/contests/abc323/submissions/46358377)

```python:解答例：answer_4-2-39.py
S = input()
for i in range(1, 16, 2):
    if S[i] == "0":
        continue
    else:
        print("No")
        break
else:
    print("Yes")
```

```python:解答例：answer_4-2-40.py
S = input()
for i in range(1, 16, 2):
    if S[i] != "0":
        print("No")
        break
else:
    print("Yes")
```

### while文

while文は`while 条件式:`となる。条件式が`True`の場合、while文の中の処理を続ける。

```python:サンプルコード：sample_4-2-10.py
i = 0
while i < 5:
    print(i)
    i += 1
```

```text:実行結果
0
1
2
3
4
```

[ABC281 A - Count Down](https://atcoder.jp/contests/abc281/tasks/abc281_a) ｜ [提出結果](https://atcoder.jp/contests/abc281/submissions/45492420)

```python:解答例：answer_4-2-41.py
N = int(input())
while N >= 0:
    print(N)
    N -= 1
```

[ABC340 A - Arithmetic Progression](https://atcoder.jp/contests/abc340/tasks/abc340_a) ｜ [提出結果](https://atcoder.jp/contests/abc340/submissions/50291533)

```python:解答例：answer_4-2-42.py
A, B, D = map(int, input().split())
while A <= B:
    print(A, end=" ")
    A += D
```

[ABC318 A - Full Moon](https://atcoder.jp/contests/abc318/tasks/abc318_a) ｜ [提出結果](https://atcoder.jp/contests/abc318/submissions/45492483)

```python:解答例：answer_4-2-43.py
N, M, P = map(int, input().split())
count = 0
while M <= N:
    count += 1
    M += P
print(count)
```

[ABC354 A - Exponential Plant](https://atcoder.jp/contests/abc354/tasks/abc354_a) ｜ [提出結果](https://atcoder.jp/contests/abc354/submissions/55093603)

```python:解答例：answer_4-2-44.py
H = int(input())
now = 0
day = 0
while now <= H:
    now += 2**day
    day += 1
print(day)
```

[ABC032 A - 高橋君と青木君の好きな数](https://atcoder.jp/contests/abc032/tasks/abc032_a) ｜ [提出結果](https://atcoder.jp/contests/abc032/submissions/45492440) ｜ [提出結果](https://atcoder.jp/contests/abc032/submissions/45492460)

```python:解答例：answer_4-2-45.py
a, b, n = [int(input()) for i in range(3)]
while n % a != 0 or n % b != 0:
    n += 1
print(n)
```

```python:解答例：answer_4-2-46.py
a, b, n = [int(input()) for i in range(3)]
while not (n % a == 0 and n % b == 0):
    n += 1
print(n)
```

# 第5章 組み込み型

第5章では組み込み型について説明します。

## 5.1 整数（int）

### 整数への変換

整数への変換は`int(数値)`で整数に変換される。

```python:サンプルコード：sample_5-1-1.py
print(int(2.9))
```

```text:実行結果
2
```

```python:サンプルコード：sample_5-1-2.py
print(int(3.0))
```

```text:実行結果
3
```

```python:サンプルコード：sample_5-1-3.py
print(int(3.1))
```

```text:実行結果
3
```

```python:サンプルコード：sample_5-1-4.py
x = -2.9
print(int(x))
```

```text:実行結果
-2
```

```python:サンプルコード：sample_5-1-5.py
x = -3.0
print(int(x))
```

```text:実行結果
-3
```

```python:サンプルコード：sample_5-1-6.py
x = -3.1
print(int(x))
```

```text:実行結果
-3
```

```python:サンプルコード：sample_5-1-7.py
x = "10"
print(int(x))
```

```text:実行結果
10
```

```python:サンプルコード：sample_5-1-8.py
x = "010"
print(int(x))
```

```text:実行結果
10
```

[ABC232 A - QQ solver](https://atcoder.jp/contests/abc232/tasks/abc232_a) ｜ [提出結果](https://atcoder.jp/contests/abc232/submissions/45492495)

```python:解答例：answer_5-1-1.py
a, x, b = input()
print(int(a)*int(b))
```

[ABC389 A - 9x9](https://atcoder.jp/contests/abc389/tasks/abc389_a) ｜ [提出結果](https://atcoder.jp/contests/abc389/submissions/62089080)

```python:解答例：answer_5-1-2.py
a, x, b = input()
print(int(a)*int(b))
```

[ABC050 A - Addition and Subtraction Easy](https://atcoder.jp/contests/abc050/tasks/abc050_a) ｜ [提出結果](https://atcoder.jp/contests/abc050/submissions/45492508) ｜ [提出結果](https://atcoder.jp/contests/abc050/submissions/45492525)

```python:解答例：answer_5-1-3.py
A, op, B = input().split()
A = int(A)
B = int(B)
if op == "+":
    print(A+B)
if op == "-":
    print(A-B)
```

```python:解答例：answer_5-1-4.py
A, op, B = input().split()
if op == "+":
    print(int(A)+int(B))
if op == "-":
    print(int(A)-int(B))
```

[ABC125 A - Biscuit Generator](https://atcoder.jp/contests/abc125/tasks/abc125_a) ｜ [提出結果](https://atcoder.jp/contests/abc125/submissions/45492537)

```python:解答例：answer_5-1-5.py
A, B, T = map(int, input().split())
print(int(B*((T+0.5)//A)))
```

[ABC206 A - Maxi-Buying](https://atcoder.jp/contests/abc206/tasks/abc206_a) ｜ [提出結果](https://atcoder.jp/contests/abc206/submissions/45492557)

```python:解答例：answer_5-1-6.py
N = int(input())
if int(1.08*N) < 206:
    print("Yay!")
elif int(1.08*N) == 206:
    print("so-so")
else:
    print(":(")
```

[ABC039 B - エージェント高橋君](https://atcoder.jp/contests/abc039/tasks/abc039_b) ｜ [提出結果](https://atcoder.jp/contests/abc039/submissions/45492567)

```python:解答例：answer_5-1-7.py
X = int(input())
print(int(X**(1/4)))
```

## 5.2 浮動小数点数（float）

### 浮動小数点数への変換

浮動小数点数への変換は`float(数値)`で浮動小数点数に変換される。

```python:サンプルコード：sample_5-2-1.py
x = 10
print(float(x))
```

```text:実行結果
10.0
```

```python:サンプルコード：sample_5-2-2.py
x = "10"
print(float(x))
```

```text:実行結果
10.0
```

[ABC397 A - Thermometer](https://atcoder.jp/contests/abc397/tasks/abc397_a) ｜ [提出結果](https://atcoder.jp/contests/abc397/submissions/64345399)

```python:解答例：answer_5-2-1.py
X = float(input())
if 38.0 <= X:
    print(1)
elif 37.5 <= X < 38.0:
    print(2)
else:
    print(3)
```

[ABC226 A - Round decimals](https://atcoder.jp/contests/abc226/tasks/abc226_a) ｜ [提出結果](https://atcoder.jp/contests/abc226/submissions/45492585)

```python:解答例：answer_5-2-2.py
X = float(input())
print(int(X+0.5))
```

## 5.3 文字列（str）

<b>キーポイント</b>

* 文字列の定義は文字列をダブルクォーテーション`"`、またはシングルクォーテーション`'`で囲う。
* 文字列への変換は`str(データ)`で文字列に変換される。
* 文字列の連結は`+`演算子を使用する。
* 文字列の繰り返しは`*`演算子を使用する。
* 文字列の参照は`文字列[インデックス]`となる。
* 文字列の探索は`index`メソッドを使用する。
* 文字列を前方から検索する場合は`find`メソッドを使用する。
* 文字列を後方から検索する場合は`rfind`メソッドを使用する。
* 文字列のカウントは`count`メソッドを使用する。
* 文字列のスライスは`文字列[開始のインデックス:終了のインデックス:ステップ数]`となる。
* 文字列の逆順は`文字列[::-1]`となる。
* 文字列の置換は`replace`メソッドを使用する。
* 文字列の大文字変換は`upper`メソッドを使用する。
* 文字列の小文字変換は`lower`メソッドを使用する。
* 文字列の大文字判定は`isupper`メソッドを使用する。
* 文字列の小文字判定は`islower`メソッドを使用する。
* 文字列のゼロ埋めは`zfill`メソッドを使用する。
* 文字列のフォーマットはフォーマット済み文字列リテラルを使用する。

### 文字列の定義

文字列の定義は文字列をダブルクォーテーション`"`、またはシングルクォーテーション`'`で囲う。

```python:サンプルコード：sample_5-3-1.py
print("Hello World!")
```

```text:実行結果
Hello World!
```

```python:サンプルコード：sample_5-3-2.py
x = "Hello World!"
print(x)
```

```text:実行結果
Hello World!
```

### 文字列への変換

文字列への変換は`str(データ)`で文字列に変換される。

```python:サンプルコード：sample_5-3-3.py
x = 10
print(str(x))
```

```text:実行結果
10
```

[ABC248 A - Lacked Number](https://atcoder.jp/contests/abc248/tasks/abc248_a) ｜ [提出結果](https://atcoder.jp/contests/abc248/submissions/45492601)

```python:解答例：answer_5-3-1.py
S = input()
for i in range(10):
    if str(i) not in S:
        print(i)
        break
```

### 文字列の連結

文字列の連結は`+`演算子を使用する。

```python:サンプルコード：sample_5-3-4.py
print("Hello"+"World")
```

```text:実行結果
HelloWorld
```

```python:サンプルコード：sample_5-3-5.py
x = "Hello"
y = "World"
print(x+y)
```

```text:実行結果
HelloWorld
```

[ABC029 A - 複数形](https://atcoder.jp/contests/abc029/tasks/abc029_a) ｜ [提出結果](https://atcoder.jp/contests/abc029/submissions/45492610)

```python:解答例：answer_5-3-2.py
W = input()
print(W+"s")
```

[ABC010 A - ハンドルネーム](https://atcoder.jp/contests/abc010/tasks/abc010_1) ｜ [提出結果](https://atcoder.jp/contests/abc010/submissions/45492626)

```python:解答例：answer_5-3-3.py
S = input()
print(S+"pp")
```

[ABC068 A - ABCxxx](https://atcoder.jp/contests/abc068/tasks/abc068_a) ｜ [提出結果](https://atcoder.jp/contests/abc068/submissions/45492633)

```python:解答例：answer_5-3-4.py
N = input()
print("ABC"+N)
```

[ABC149 A - Strings](https://atcoder.jp/contests/abc149/tasks/abc149_a) ｜ [提出結果](https://atcoder.jp/contests/abc149/submissions/45492640)

```python:解答例：answer_5-3-5.py
S, T = input().split()
print(T+S)
```

[ABC325 A - Takahashi san](https://atcoder.jp/contests/abc325/tasks/abc325_a) ｜ [提出結果](https://atcoder.jp/contests/abc325/submissions/46876324)

```python:解答例：answer_5-3-6.py
S, T = input().split()
print(S+" san")
```

[ABC344 A - Spoiler](https://atcoder.jp/contests/abc344/tasks/abc344_a) ｜ [提出結果](https://atcoder.jp/contests/abc344/submissions/51099365)

```python:解答例：answer_5-3-7.py
a, b, c = input().split("|")
print(a+c)
```

[ABC216 A - Signed Difficulty](https://atcoder.jp/contests/abc216/tasks/abc216_a) ｜ [提出結果](https://atcoder.jp/contests/abc216/submissions/45492654)

```python:解答例：answer_5-3-8.py
X, Y = input().split(".")
if 0 <= int(Y) <= 2:
    print(X+"-")
if 3 <= int(Y) <= 6:
    print(X)
if 7 <= int(Y) <= 9:
    print(X+"+")
```

[ABC230 A - AtCoder Quiz 3](https://atcoder.jp/contests/abc230/tasks/abc230_a) ｜ [提出結果](https://atcoder.jp/contests/abc230/submissions/45492669)

```python:解答例：answer_5-3-9.py
N = int(input())
if N <= 9:
    print("AGC00"+str(N))
elif N <= 41:
    print("AGC0"+str(N))
else:
    print("AGC0"+str(N+1))
```

[ABC258 A - When?](https://atcoder.jp/contests/abc258/tasks/abc258_a) ｜ [提出結果](https://atcoder.jp/contests/abc258/submissions/45492679)

```python:解答例：answer_5-3-10.py
K = int(input())
if K < 60:
    if K < 10:
        print("21:0"+str(K))
    else:
        print("21:"+str(K))
else:
    if K-60 < 10:
        print("22:0"+str(K-60))
    else:
        print("22:"+str(K-60))
```

[ABC379 A - Cyclic](https://atcoder.jp/contests/abc379/tasks/abc379_a) ｜ [提出結果](https://atcoder.jp/contests/abc379/submissions/60156408)

```python:解答例：answer_5-3-11.py
a, b, c = input()
print(b+c+a, c+a+b)
```

[ABC235 A - Rotate](https://atcoder.jp/contests/abc235/tasks/abc235_a) ｜ [提出結果](https://atcoder.jp/contests/abc235/submissions/45492688)

```python:解答例：answer_5-3-12.py
a, b, c = input()
abc = a+b+c
bca = b+c+a
cab = c+a+b
print(int(abc)+int(bca)+int(cab))
```

[ABC064 A - RGB Cards](https://atcoder.jp/contests/abc064/tasks/abc064_a) ｜ [提出結果](https://atcoder.jp/contests/abc064/submissions/45492696)

```python:解答例：answer_5-3-13.py
r, g, b = input().split()
if int(r+g+b) % 4 == 0:
    print("YES")
else:
    print("NO")
```

[ABC306 A - Echo](https://atcoder.jp/contests/abc306/tasks/abc306_a) ｜ [提出結果](https://atcoder.jp/contests/abc306/submissions/45492709)

```python:解答例：answer_5-3-14.py
N = int(input())
S = input()
ans = ""
for s in S:
    ans += s+s
print(ans)
```

[ABC372 A - delete .](https://atcoder.jp/contests/abc372/tasks/abc372_a) ｜ [提出結果](https://atcoder.jp/contests/abc372/submissions/57999936)

```python:解答例：answer_5-3-15.py
S = input()
ans = ""
for s in S:
    if s != ".":
        ans += s
print(ans)
```

[ABC348 A - Penalty Kick](https://atcoder.jp/contests/abc348/tasks/abc348_a) ｜ [提出結果](https://atcoder.jp/contests/abc348/submissions/52375826)

```python:解答例：answer_5-3-16.py
N = int(input())
s = ""
for i in range(1, N+1):
    if i % 3 == 0:
        s += "x"
    else:
        s += "o"
print(s)
```

[ABC384 A - aaaadaa](https://atcoder.jp/contests/abc384/tasks/abc384_a) ｜ [提出結果](https://atcoder.jp/contests/abc384/submissions/61234974) ｜ [提出結果](https://atcoder.jp/contests/abc384/submissions/61235063)

```python:解答例：answer_5-3-17.py
N, c1, c2 = input().split()
S = input()
ans = ""
for s in S:
    if s != c1:
        ans += c2
    else:
        ans += c1
print(ans)
```

```python:解答例：answer_5-3-18.py
N, c1, c2 = input().split()
N = int(N)
S = input()
ans = ""
for i in range(N):
    if S[i] != c1:
        ans += c2
    else:
        ans += c1
print(ans)
```

### 文字列の繰り返し

文字列の繰り返しは`*`演算子を使用する。

```python:サンプルコード：sample_5-3-6.py
print("HelloWorld!"*2)
```

```text:実行結果
HelloWorld!HelloWorld!
```

```python:サンプルコード：sample_5-3-7.py
print("1"*5)
```

```text:実行結果
11111
```

[ABC336 A - Long Loong](https://atcoder.jp/contests/abc336/tasks/abc336_a) ｜ [提出結果](https://atcoder.jp/contests/abc336/submissions/49316705)

```python:解答例：answer_5-3-19.py
N = int(input())
print("L"+"o"*N+"ng")
```

[ABC341 A - Print 341](https://atcoder.jp/contests/abc341/tasks/abc341_a) ｜ [提出結果](https://atcoder.jp/contests/abc341/submissions/50518675) ｜ [提出結果](https://atcoder.jp/contests/abc341/submissions/50499534)

```python:解答例：answer_5-3-20.py
N = int(input())
print("1"+"01"*N)
```

```python:解答例：answer_5-3-21.py
N = int(input())
print("10"*N+"1")
```

[ABC333 A - Three Threes](https://atcoder.jp/contests/abc333/tasks/abc333_a) ｜ [提出結果](https://atcoder.jp/contests/abc333/submissions/48597565) ｜ [提出結果](https://atcoder.jp/contests/abc333/submissions/48787790)

```python:解答例：answer_5-3-22.py
N = input()
print(N*int(N))
```

```python:解答例：answer_5-3-23.py
N = int(input())
print(str(N)*N)
```

[ABC115 A - Christmas Eve Eve Eve](https://atcoder.jp/contests/abc115/tasks/abc115_a) ｜ [提出結果](https://atcoder.jp/contests/abc115/submissions/45492720)

```python:解答例：answer_5-3-24.py
D = int(input())
print("Christmas"+" Eve"*(25-D))
```

[ABC398 A - Doors in the Center](https://atcoder.jp/contests/abc398/tasks/abc398_a) ｜ [提出結果](https://atcoder.jp/contests/abc398/submissions/64346118)

```python:解答例：answer_5-3-25.py
N = int(input())
if N % 2 == 0:
    print("-"*(N//2-1)+"=="+"-"*(N//2-1))
else:
    print("-"*(N//2)+"="+"-"*(N//2))
```

[ABC296 A - Alternately](https://atcoder.jp/contests/abc296/tasks/abc296_a) ｜ [提出結果](https://atcoder.jp/contests/abc296/submissions/45492731)

```python:解答例：answer_5-3-26.py
N = int(input())
S = input()
if S in "MF"*51:
    print("Yes")
else:
    print("No")
```

[ABC381 A - 11/22 String](https://atcoder.jp/contests/abc381/tasks/abc381_a) ｜ [提出結果](https://atcoder.jp/contests/abc381/submissions/60160557)

```python:解答例：answer_5-3-27.py
N = int(input())
S = input()
if S == "1"*(N//2)+"/"+"2"*(N//2):
    print("Yes")
else:
    print("No")
```

### 文字列の参照

文字列の参照は`文字列[インデックス]`となる。範囲外の参照は`IndexError`が返却される。

```python:サンプルコード：sample_5-3-8.py
x = "abc"
print(x[0], x[1], x[2])
```

```text:実行結果
a b c
```

```python:サンプルコード：sample_5-3-9.py
x = "abc"
print(x[-1], x[-2], x[-3])
```

```text:実行結果
c b a
```

```python:サンプルコード：sample_5-3-10.py
x = "abc"
print(x[3])
```

```text:実行結果
IndexError: string index out of range
```

[ABC232 A - QQ solver](https://atcoder.jp/contests/abc232/tasks/abc232_a) ｜ [提出結果](https://atcoder.jp/contests/abc232/submissions/45492745)

```python:解答例：answer_5-3-28.py
S = input()
print(int(S[0])*int(S[2]))
```

[ABC389 A - 9x9](https://atcoder.jp/contests/abc389/tasks/abc389_a) ｜ [提出結果](https://atcoder.jp/contests/abc389/submissions/62082491)

```python:解答例：answer_5-3-29.py
S = input()
print(int(S[0])*int(S[2]))
```

[ABC388 A - ?UPC](https://atcoder.jp/contests/abc388/tasks/abc388_a) ｜ [提出結果](https://atcoder.jp/contests/abc388/submissions/62016101)

```python:解答例：answer_5-3-30.py
S = input()
print(S[0]+"UPC")
```

[ABC048 A - AtCoder *** Contest](https://atcoder.jp/contests/abc048/tasks/abc048_a) ｜ [提出結果](https://atcoder.jp/contests/abc048/submissions/45492760)

```python:解答例：answer_5-3-31.py
s = input()
print("A"+s[8]+"C")
```

[ABC090 A - Diagonal String](https://atcoder.jp/contests/abc090/tasks/abc090_a) ｜ [提出結果](https://atcoder.jp/contests/abc090/submissions/45492775) ｜ [提出結果](https://atcoder.jp/contests/abc090/submissions/45492786)

```python:解答例：answer_5-3-32.py
c1 = input()
c2 = input()
c3 = input()
print(c1[0]+c2[1]+c3[2])
```

```python:解答例：answer_5-3-33.py
c1 = input()[0]
c2 = input()[1]
c3 = input()[2]
print(c1+c2+c3)
```

[ABC041 A - 添字](https://atcoder.jp/contests/abc041/tasks/abc041_a) ｜ [提出結果](https://atcoder.jp/contests/abc041/submissions/45492799)

```python:解答例：answer_5-3-34.py
s = input()
i = int(input())
print(s[i-1])
```

[ABC218 A - Weather Forecast](https://atcoder.jp/contests/abc218/tasks/abc218_a) ｜ [提出結果](https://atcoder.jp/contests/abc218/submissions/45492809)

```python:解答例：answer_5-3-35.py
N = int(input())
S = input()
if S[N-1] == "o":
    print("Yes")
else:
    print("No")
```

[ABC244 A - Last Letter](https://atcoder.jp/contests/abc244/tasks/abc244_a) ｜ [提出結果](https://atcoder.jp/contests/abc244/submissions/45492818) ｜ [提出結果](https://atcoder.jp/contests/abc244/submissions/45492825)

```python:解答例：answer_5-3-36.py
N = int(input())
S = input()
print(S[N-1])
```

```python:解答例：answer_5-3-37.py
N = int(input())
S = input()
print(S[-1])
```

[ABC038 A - お茶](https://atcoder.jp/contests/abc038/tasks/abc038_a) ｜ [提出結果](https://atcoder.jp/contests/abc038/submissions/45492834)

```python:解答例：answer_5-3-38.py
S = input()
if S[-1] == "T":
    print("YES")
else:
    print("NO")
```

[ABC179 A - Plural Form](https://atcoder.jp/contests/abc179/tasks/abc179_a) ｜ [提出結果](https://atcoder.jp/contests/abc179/submissions/45492845)

```python:解答例：answer_5-3-39.py
S = input()
if S[-1] != "s":
    print(S+"s")
else:
    print(S+"es")
```

[ABC060 A - Shiritori](https://atcoder.jp/contests/abc060/tasks/abc060_a) ｜ [提出結果](https://atcoder.jp/contests/abc060/submissions/45492854)

```python:解答例：answer_5-3-40.py
A, B, C = input().split()
if A[-1] == B[0] and B[-1] == C[0]:
    print("YES")
else:
    print("NO")
```

[ABC189 A - Slot](https://atcoder.jp/contests/abc189/tasks/abc189_a) ｜ [提出結果](https://atcoder.jp/contests/abc189/submissions/45492866)

```python:解答例：answer_5-3-41.py
C = input()
if C[0] == C[1] == C[2]:
    print("Won")
else:
    print("Lost")
```

[ABC033 A - 暗証番号](https://atcoder.jp/contests/abc033/tasks/abc033_a) ｜ [提出結果](https://atcoder.jp/contests/abc033/submissions/45492880)

```python:解答例：answer_5-3-42.py
N = input()
if N[0] == N[1] == N[2] == N[3]:
    print("SAME")
else:
    print("DIFFERENT")
```

[ABC160 A - Coffee](https://atcoder.jp/contests/abc160/tasks/abc160_a) ｜ [提出結果](https://atcoder.jp/contests/abc160/submissions/45492895)

```python:解答例：answer_5-3-43.py
S = input()
if S[2] == S[3] and S[4] == S[5]:
    print("Yes")
else:
    print("No")
```

[ABC079 A - Good Integer](https://atcoder.jp/contests/abc079/tasks/abc079_a) ｜ [提出結果](https://atcoder.jp/contests/abc079/submissions/45492902)

```python:解答例：answer_5-3-44.py
N = input()
if N[0] == N[1] == N[2] or N[1] == N[2] == N[3]:
    print("Yes")
else:
    print("No")
```

[ABC131 A - Security](https://atcoder.jp/contests/abc131/tasks/abc131_a) ｜ [提出結果](https://atcoder.jp/contests/abc131/submissions/45492914) ｜ [提出結果](https://atcoder.jp/contests/abc131/submissions/45492925)

```python:解答例：answer_5-3-45.py
S = input()
if S[0] != S[1] and S[1] != S[2] and S[2] != S[3]:
    print("Good")
else:
    print("Bad")
```

```python:解答例：answer_5-3-46.py
S = input()
if S[0] != S[1] != S[2] != S[3]:
    print("Good")
else:
    print("Bad")
```

[ABC070 A - Palindromic Number](https://atcoder.jp/contests/abc070/tasks/abc070_a) ｜ [提出結果](https://atcoder.jp/contests/abc070/submissions/45492931)

```python:解答例：answer_5-3-47.py
N = input()
if N[0] == N[2]:
    print("Yes")
else:
    print("No")
```

[ABC226 A - Round decimals](https://atcoder.jp/contests/abc226/tasks/abc226_a) ｜ [提出結果](https://atcoder.jp/contests/abc226/submissions/45492945)

```python:解答例：answer_5-3-48.py
a, b = input().split(".")
if int(b[0]) < 5:
    print(int(a))
else:
    print(int(a)+1)
```

[ABC139 A - Tenki](https://atcoder.jp/contests/abc139/tasks/abc139_a) ｜ [提出結果](https://atcoder.jp/contests/abc139/submissions/53029791)

```python:解答例：answer_5-3-49.py
S = input()
T = input()
count = 0
if S[0] == T[0]:
    count += 1
if S[1] == T[1]:
    count += 1
if S[2] == T[2]:
    count += 1
print(count)
```

[ABC375 A - Seats](https://atcoder.jp/contests/abc375/tasks/abc375_a) ｜ [提出結果](https://atcoder.jp/contests/abc375/submissions/58775141)

```python:解答例：answer_5-3-50.py
N = int(input())
S = input()
count = 0
for i in range(1, N-1):
    if S[i-1] == "#" and S[i] == "." and S[i+1] == "#":
        count += 1
print(count)
```

[ABC062 A - Grouping](https://atcoder.jp/contests/abc062/tasks/abc062_a) ｜ [提出結果](https://atcoder.jp/contests/abc062/submissions/45492967)

```python:解答例：answer_5-3-51.py
S = "XACABABAABABA"
x, y = map(int, input().split())
if S[x] == S[y]:
    print("Yes")
else:
    print("No")
```

[ABC025 A - 25個の文字列](https://atcoder.jp/contests/abc025/tasks/abc025_a) ｜ [提出結果](https://atcoder.jp/contests/abc025/submissions/45492980)

```python:解答例：answer_5-3-52.py
S = input()
N = int(input())-1
print(S[N//5]+S[N % 5])
```

### 文字列の探索

文字列の探索は`index`メソッドを使用する。`探索される文字列.index(探索する文字列)`で探索する。`探索する文字列`が含まれる場合は最小のインデックスが返却され、`探索する文字列`が含まれない場合は`ValueError`が返却される。

```python:サンプルコード：sample_5-3-11.py
x = "abcdef"
print(x.index("c"))
```

```text:実行結果
2
```

```python:サンプルコード：sample_5-3-12.py
x = "abcdcc"
print(x.index("c"))
```

```text:実行結果
2
```

```python:サンプルコード：sample_5-3-13.py
x = "12345"
print(x.index("3"))
```

```text:実行結果
2
```

```python:サンプルコード：sample_5-3-14.py
x = "abc"
print(x.index("z"))
```

```text:実行結果
ValueError: substring not found
```

[ABC013 A - A](https://atcoder.jp/contests/abc013/tasks/abc013_1) ｜ [提出結果](https://atcoder.jp/contests/abc013/submissions/45492987) ｜ [提出結果](https://atcoder.jp/contests/abc013/submissions/45492998)

```python:解答例：answer_5-3-53.py
X = input()
print("ABCDE".index(X)+1)
```

```python:解答例：answer_5-3-54.py
X = input()
print("0ABCDE".index(X))
```

[ABC151 A - Next Alphabet](https://atcoder.jp/contests/abc151/tasks/abc151_a) ｜ [提出結果](https://atcoder.jp/contests/abc151/submissions/45493005)

```python:解答例：answer_5-3-55.py
C = input()
letters = "abcdefghijklmnopqrstuvwxyz"
print(letters[letters.index(C)+1])
```

[ABC360 A - A Healthy Breakfast](https://atcoder.jp/contests/abc360/tasks/abc360_a) ｜ [提出結果](https://atcoder.jp/contests/abc360/submissions/55101084)

```python:解答例：answer_5-3-56.py
S = input()
if S.index("R") < S.index("M"):
    print("Yes")
else:
    print("No")
```

[ABC322 A - First ABC 2](https://atcoder.jp/contests/abc322/tasks/abc322_a) ｜ [提出結果](https://atcoder.jp/contests/abc322/submissions/46143259)

```python:解答例：answer_5-3-57.py
N = int(input())
S = input()
if "ABC" in S:
    print(S.index("ABC")+1)
else:
    print(-1)
```

### 文字列を前方から検索

文字列を前方から検索する場合は`find`メソッドを使用する。`検索される文字列.find(検索する文字列)`で検索する。`検索する文字列`が含まれる場合は最小のインデックスが返却され、`検索する文字列`が含まれない場合は`-1`が返却される。

```python:サンプルコード：sample_5-3-15.py
x = "abcabc"
print(x.find("b"))
```

```text:実行結果
1
```

```python:サンプルコード：sample_5-3-16.py
x = "abcabc"
print(x.find("z"))
```

```text:実行結果
-1
```

[ABC013 A - A](https://atcoder.jp/contests/abc013/tasks/abc013_1) ｜ [提出結果](https://atcoder.jp/contests/abc013/submissions/45493016) ｜ [提出結果](https://atcoder.jp/contests/abc013/submissions/45493020)

```python:解答例：answer_5-3-58.py
X = input()
print("ABCDE".find(X)+1)
```

```python:解答例：answer_5-3-59.py
X = input()
print("0ABCDE".find(X))
```

[ABC151 A - Next Alphabet](https://atcoder.jp/contests/abc151/tasks/abc151_a) ｜ [提出結果](https://atcoder.jp/contests/abc151/submissions/45493028)

```python:解答例：answer_5-3-60.py
C = input()
letters = "abcdefghijklmnopqrstuvwxyz"
print(letters[letters.find(C)+1])
```

[ABC360 A - A Healthy Breakfast](https://atcoder.jp/contests/abc360/tasks/abc360_a) ｜ [提出結果](https://atcoder.jp/contests/abc360/submissions/55101035)

```python:解答例：answer_5-3-61.py
S = input()
if S.find("R") < S.find("M"):
    print("Yes")
else:
    print("No")
```

[ABC322 A - First ABC 2](https://atcoder.jp/contests/abc322/tasks/abc322_a) ｜ [提出結果](https://atcoder.jp/contests/abc322/submissions/46143342)

```python:解答例：answer_5-3-62.py
N = int(input())
S = input()
if "ABC" in S:
    print(S.find("ABC")+1)
else:
    print(-1)
```

### 文字列を後方から検索

文字列を後方から検索する場合は`rfind`メソッドを使用する。`検索される文字列.rfind(検索する文字列)`で検索する。`検索する文字列`が含まれる場合は最大のインデックスが返却され、`検索する文字列`が含まれない場合は`-1`が返却される。

```python:サンプルコード：sample_5-3-17.py
x = "abcabc"
print(x.rfind("b"))
```

```text:実行結果
4
```

```python:サンプルコード：sample_5-3-18.py
x = "abcabc"
print(x.rfind("z"))
```

```text:実行結果
-1
```

[ABC276 A - Rightmost](https://atcoder.jp/contests/abc276/tasks/abc276_a) ｜ [提出結果](https://atcoder.jp/contests/abc276/submissions/45493038)

```python:解答例：answer_5-3-63.py
S = input()
idx = S.rfind("a")
if idx != -1:
    print(idx+1)
else:
    print(-1)
```

[ABC299 A - Treasure Chest](https://atcoder.jp/contests/abc299/tasks/abc299_a) ｜ [提出結果](https://atcoder.jp/contests/abc299/submissions/45493046)

```python:解答例：answer_5-3-64.py
N = int(input())
S = input()
if S.find("|") < S.find("*") < S.rfind("|"):
    print("in")
else:
    print("out")
```

### 文字列のカウント

文字列のカウントは`count`メソッドを使用する。`カウントされる文字列.count(カウントする文字列)`でカウント数が返却される。

```python:サンプルコード：sample_5-3-19.py
x = "abbccc"
print(x.count("c"))
```

```text:実行結果
3
```

```python:サンプルコード：sample_5-3-20.py
x = "abbccc"
print(x.count("d"))
```

```text:実行結果
0
```

```python:サンプルコード：sample_5-3-21.py
x = "123435"
print(x.count("3"))
```

```text:実行結果
2
```

[ABC081 A - Placing Marbles](https://atcoder.jp/contests/abc081/tasks/abc081_a) ｜ [提出結果](https://atcoder.jp/contests/abc081/submissions/45493058)

```python:解答例：answer_5-3-65.py
s = input()
print(s.count("1"))
```

[ABC279 A - wwwvvvvvv](https://atcoder.jp/contests/abc279/tasks/abc279_a) ｜ [提出結果](https://atcoder.jp/contests/abc279/submissions/45493064)

```python:解答例：answer_5-3-66.py
S = input()
print(S.count("v")+2*S.count("w"))
```

[ABC394 A - 22222](https://atcoder.jp/contests/abc394/tasks/abc394_a) ｜ [提出結果](https://atcoder.jp/contests/abc394/submissions/63073329)

```python:解答例：answer_5-3-67.py
S = input()
print("2"*S.count("2"))
```

[ABC101 A - Eating Symbols Easy](https://atcoder.jp/contests/abc101/tasks/abc101_a) ｜ [提出結果](https://atcoder.jp/contests/abc101/submissions/45493069)

```python:解答例：answer_5-3-68.py
S = input()
print(S.count("+")-S.count("-"))
```

[ABC095 A - Something on It](https://atcoder.jp/contests/abc095/tasks/abc095_a) ｜ [提出結果](https://atcoder.jp/contests/abc095/submissions/45493075)

```python:解答例：answer_5-3-69.py
S = input()
print(700+100*S.count("o"))
```

[ABC382 A - Daily Cookie](https://atcoder.jp/contests/abc382/tasks/abc382_a) ｜ [提出結果](https://atcoder.jp/contests/abc382/submissions/61012190) ｜ [提出結果](https://atcoder.jp/contests/abc382/submissions/61012255)

```python:解答例：answer_5-3-70.py
N, D = map(int, input().split())
S = input()
print(S.count(".")+D)
```

```python:解答例：answer_5-3-71.py
N, D = map(int, input().split())
S = input()
print(N-S.count("@")+D)
```

[ABC162 A - Lucky 7](https://atcoder.jp/contests/abc162/tasks/abc162_a) ｜ [提出結果](https://atcoder.jp/contests/abc162/submissions/45493082)

```python:解答例：answer_5-3-72.py
N = input()
if N.count("7") > 0:
    print("Yes")
else:
    print("No")
```

[ABC377 A - Rearranging ABC](https://atcoder.jp/contests/abc377/tasks/abc377_a) ｜ [提出結果](https://atcoder.jp/contests/abc377/submissions/60095482)

```python:解答例：answer_5-3-73.py
S = input()
if S.count("A") == 1 and S.count("B") == 1 and S.count("C") == 1:
    print("Yes")
else:
    print("No")
```

[ABC380 A - 123233](https://atcoder.jp/contests/abc380/tasks/abc380_a) ｜ [提出結果](https://atcoder.jp/contests/abc380/submissions/60157292)

```python:解答例：answer_5-3-74.py
N = input()
if N.count("1") == 1 and N.count("2") == 2 and N.count("3") == 3:
    print("Yes")
else:
    print("No")
```

[ABC175 A - Rainy Season](https://atcoder.jp/contests/abc175/tasks/abc175_a) ｜ [提出結果](https://atcoder.jp/contests/abc175/submissions/45493087)

```python:解答例：answer_5-3-75.py
S = input()
if S.count("R") != 2:
    print(S.count("R"))
elif S[1] == "R":
    print(2)
else:
    print(1)
```

[ABC298 A - Job Interview](https://atcoder.jp/contests/abc298/tasks/abc298_a) ｜ [提出結果](https://atcoder.jp/contests/abc298/submissions/45493091)

```python:解答例：answer_5-3-76.py
N = int(input())
S = input()
if S.count("o") >= 1 and S.count("x") == 0:
    print("Yes")
else:
    print("No")
```

[ABC301 A - Overall Winner](https://atcoder.jp/contests/abc301/tasks/abc301_a) ｜ [提出結果](https://atcoder.jp/contests/abc301/submissions/45493098)

```python:解答例：answer_5-3-77.py
N = int(input())
S = input()
T = S.count("T")
A = S.count("A")
if T > A:
    print("T")
elif T < A:
    print("A")
else:
    if S[-1] == "A":
        print("T")
    else:
        print("A")
```

[ABC345 A - Leftrightarrow](https://atcoder.jp/contests/abc345/tasks/abc345_a) ｜ [提出結果](https://atcoder.jp/contests/abc345/submissions/51367843)

```python:解答例：answer_5-3-78.py
S = input()
if S[0] == "<" and S.count("<") == 1 and S[-1] == ">" and S.count(">") == 1:
    print("Yes")
else:
    print("No")
```

[ABC280 A - Pawn on a Grid](https://atcoder.jp/contests/abc280/tasks/abc280_a) ｜ [提出結果](https://atcoder.jp/contests/abc280/submissions/45493111)

```python:解答例：answer_5-3-79.py
H, W = map(int, input().split())
S = [input() for i in range(H)]
ans = 0
for s in S:
    ans += s.count("#")
print(ans)
```

### 文字列のスライス

文字列のスライスは`文字列[開始のインデックス:終了のインデックス:ステップ数]`となる。

```python:サンプルコード：sample_5-3-22.py
x = "012345"
print(x[1:4])
```

```text:実行結果
123
```

```python:サンプルコード：sample_5-3-23.py
x = "012345"
print(x[1:4:2])
```

```text:実行結果
13
```

```python:サンプルコード：sample_5-3-24.py
x = "012345"
print(x[:3])
```

```text:実行結果
012
```

```python:サンプルコード：sample_5-3-25.py
x = "012345"
print(x[3:])
```

```text:実行結果
34
```

```python:サンプルコード：sample_5-3-26.py
x = "012345"
print(x[:-1])
```

```text:実行結果
01234
```

```python:サンプルコード：sample_5-3-27.py
x = "012345"
print(x[-1:])
```

```text:実行結果
5
```

```python:サンプルコード：sample_5-3-28.py
x = "012345"
print(x[::2])
```

```text:実行結果
024
```

```python:サンプルコード：sample_5-3-29.py
x = "012345"
print(x[1::2])
```

```text:実行結果
135
```

[ABC254 A - Last Two Digits](https://atcoder.jp/contests/abc254/tasks/abc254_a) ｜ [提出結果](https://atcoder.jp/contests/abc254/submissions/45493128)

```python:解答例：answer_5-3-80.py
N = input()
print(N[1:])
```

[ABC314 A - 3.14](https://atcoder.jp/contests/abc314/tasks/abc314_a) ｜ [提出結果](https://atcoder.jp/contests/abc314/submissions/45493136)

```python:解答例：answer_5-3-81.py
N = int(input())
pi = "3.1415926535897932384626433832795028841971693993751"\
     "058209749445923078164062862089986280348253421170679"
print(pi[:N+2])
```

[ABC085 A - Already 2018](https://atcoder.jp/contests/abc085/tasks/abc085_a) ｜ [提出結果](https://atcoder.jp/contests/abc085/submissions/45493141)

```python:解答例：answer_5-3-82.py
S = input()
print("2018"+S[4:])
```

[ABC247 A - Move Right](https://atcoder.jp/contests/abc247/tasks/abc247_a) ｜ [提出結果](https://atcoder.jp/contests/abc247/submissions/45493148)

```python:解答例：answer_5-3-83.py
S = input()
print("0"+S[:3])
```

[ABC282 A - Generalized ABC](https://atcoder.jp/contests/abc282/tasks/abc282_a) ｜ [提出結果](https://atcoder.jp/contests/abc282/submissions/45493153)

```python:解答例：answer_5-3-84.py
K = int(input())
letters = "ABCDEFGHIJKLMNOPQRSTUVWXYZ"
print(letters[:K])
```

[ABC264 A - "atcoder".substr()](https://atcoder.jp/contests/abc264/tasks/abc264_a) ｜ [提出結果](https://atcoder.jp/contests/abc264/submissions/45493163)

```python:解答例：answer_5-3-85.py
L, R = map(int, input().split())
print("atcoder"[L-1:R])
```

[ABC335 A - 202\<s\>3\<\/s\>](https://atcoder.jp/contests/abc335/tasks/abc335_a) ｜ [提出結果](https://atcoder.jp/contests/abc335/submissions/49238196)

```python:解答例：answer_5-3-86.py
S = input()
print(S[:-1]+"4")
```

[ABC197 A - Rotate](https://atcoder.jp/contests/abc197/tasks/abc197_a) ｜ [提出結果](https://atcoder.jp/contests/abc197/submissions/45493167)

```python:解答例：answer_5-3-87.py
S = input()
print(S[1:]+S[0])
```

[ABC236 A - chukodai](https://atcoder.jp/contests/abc236/tasks/abc236_a) ｜ [提出結果](https://atcoder.jp/contests/abc236/submissions/45493174)

```python:解答例：answer_5-3-88.py
S = input()
a, b = map(int, input().split())
print(S[:a-1]+S[b-1]+S[a:b-1]+S[a-1]+S[b:])
```

[ABC339 A - TLD](https://atcoder.jp/contests/abc339/tasks/abc339_a) ｜ [提出結果](https://atcoder.jp/contests/abc339/submissions/49978719)

```python:解答例：answer_5-3-89.py
S = input()
dot = S.rfind(".")
print(S[dot+1:])
```

[ABC251 A - Six Characters](https://atcoder.jp/contests/abc251/tasks/abc251_a) ｜ [提出結果](https://atcoder.jp/contests/abc251/submissions/45493179)

```python:解答例：answer_5-3-90.py
S = input()
print((S*6)[:6])
```

[ABC348 A - Penalty Kick](https://atcoder.jp/contests/abc348/tasks/abc348_a) ｜ [提出結果](https://atcoder.jp/contests/abc348/submissions/52375866)

```python:解答例：answer_5-3-91.py
N = int(input())
S = "oox"*34
print(S[:N])
```

[ABC167 A - Registration](https://atcoder.jp/contests/abc167/tasks/abc167_a) ｜ [提出結果](https://atcoder.jp/contests/abc167/submissions/45493188)

```python:解答例：answer_5-3-92.py
S = input()
T = input()
if S == T[:-1]:
    print("Yes")
else:
    print("No")
```

[ABC374 A - Takahashi san 2](https://atcoder.jp/contests/abc374/tasks/abc374_a) ｜ [提出結果](https://atcoder.jp/contests/abc374/submissions/58774087)

```python:解答例：answer_5-3-93.py
S = input()
if S[-3:] == "san":
    print("Yes")
else:
    print("No")
```

[ABC224 A - Tires](https://atcoder.jp/contests/abc224/tasks/abc224_a) ｜ [提出結果](https://atcoder.jp/contests/abc224/submissions/45493195)

```python:解答例：answer_5-3-94.py
S = input()
if S[-2:] == "er":
    print("er")
else:
    print("ist")
```

[ABC375 A - Seats](https://atcoder.jp/contests/abc375/tasks/abc375_a) ｜ [提出結果](https://atcoder.jp/contests/abc375/submissions/58775412)

```python:解答例：answer_5-3-95.py
N = int(input())
S = input()
count = 0
for i in range(1, N-1):
    if S[i-1:i+2] == "#.#":
        count += 1
print(count)
```

[ABC072 B - OddString](https://atcoder.jp/contests/abc072/tasks/abc072_b) ｜ [提出結果](https://atcoder.jp/contests/abc072/submissions/45493200)

```python:解答例：answer_5-3-96.py
s = input()
print(s[::2])
```

### 文字列の逆順

文字列の逆順は`文字列[::-1]`となる。

```python:サンプルコード：sample_5-3-30.py
x = "Hello World"
print(x[::-1])
```

```text:実行結果
dlroW olleH
```

[ABC070 A - Palindromic Number](https://atcoder.jp/contests/abc070/tasks/abc070_a) ｜ [提出結果](https://atcoder.jp/contests/abc070/submissions/45493207)

```python:解答例：answer_5-3-97.py
N = input()
if N == N[::-1]:
    print("Yes")
else:
    print("No")
```

[ABC077 A - Rotation](https://atcoder.jp/contests/abc077/tasks/abc077_a) ｜ [提出結果](https://atcoder.jp/contests/abc077/submissions/45493213)

```python:解答例：answer_5-3-98.py
c1 = input()
c2 = input()
if c1 == c2[::-1]:
    print("YES")
else:
    print("NO")
```

[ABC339 A - TLD](https://atcoder.jp/contests/abc339/tasks/abc339_a) ｜ [提出結果](https://atcoder.jp/contests/abc339/submissions/49978930)

```python:解答例：answer_5-3-99.py
S = input()
ans = ""
for s in S[::-1]:
    if s == ".":
        break
    else:
        ans += s
print(ans[::-1])
```

### 文字列の置換

文字列の置換は`replace`メソッドを使用する。`文字列.replace("置換前文字列","置換後文字列")`で置換する。

```python:サンプルコード：sample_5-3-31.py
x = "abcabcabc"
print(x.replace("b", "p"))
```

```text:実行結果
apcapcapc
```

[ABC372 A - delete .](https://atcoder.jp/contests/abc372/tasks/abc372_a) ｜ [提出結果](https://atcoder.jp/contests/abc372/submissions/57999837)

```python:解答例：answer_5-3-100.py
S = input()
print(S.replace(".", ""))
```

[ABC289 A - flip](https://atcoder.jp/contests/abc289/tasks/abc289_a) ｜ [提出結果](https://atcoder.jp/contests/abc289/submissions/45493218)

```python:解答例：answer_5-3-101.py
s = input()
print(s.replace("0", "x").replace("1", "0").replace("x", "1"))
```

[ABC111 A - AtCoder Beginner Contest 999](https://atcoder.jp/contests/abc111/tasks/abc111_a) ｜ [提出結果](https://atcoder.jp/contests/abc111/submissions/45493225)

```python:解答例：answer_5-3-102.py
n = input()
print(n.replace("1", "x").replace("9", "1").replace("x", "9"))
```

[ABC315 A - tcdr](https://atcoder.jp/contests/abc315/tasks/abc315_a) ｜ [提出結果](https://atcoder.jp/contests/abc315/submissions/45493230)

```python:解答例：answer_5-3-103.py
S = input()
print(S.replace("a", "")
      .replace("e", "")
      .replace("i", "")
      .replace("o", "")
      .replace("u", ""))
```

[ABC299 A - Treasure Chest](https://atcoder.jp/contests/abc299/tasks/abc299_a) ｜ [提出結果](https://atcoder.jp/contests/abc299/submissions/45493234)

```python:解答例：answer_5-3-104.py
N = int(input())
S = input()
if S.replace(".", "") == "|*|":
    print("in")
else:
    print("out")
```

[ABC303 A - Similar String](https://atcoder.jp/contests/abc303/tasks/abc303_a) ｜ [提出結果](https://atcoder.jp/contests/abc303/submissions/45493244)

```python:解答例：answer_5-3-105.py
N = int(input())
S = input().replace("1", "l").replace("0", "o")
T = input().replace("1", "l").replace("0", "o")
if S == T:
    print("Yes")
else:
    print("No")
```

### 文字列の大文字/小文字変換

文字列の大文字変換は`upper`メソッド、小文字変換は`lower`メソッドを使用する。

```python:サンプルコード：sample_5-3-32.py
x = "Hello World!"
print(x.upper())
```

```text:実行結果
HELLO WORLD!
```

```python:サンプルコード：sample_5-3-33.py
x = "Hello World!"
print(x.lower())
```

```text:実行結果
hello world!
```

[ABC292 A - CAPS LOCK](https://atcoder.jp/contests/abc292/tasks/abc292_a) ｜ [提出結果](https://atcoder.jp/contests/abc292/submissions/45493246)

```python:解答例：answer_5-3-106.py
S = input()
T = S.upper()
print(T)
```

[ABC059 A - Three-letter acronym](https://atcoder.jp/contests/abc059/tasks/abc059_a) ｜ [提出結果](https://atcoder.jp/contests/abc059/submissions/45493256) ｜ [提出結果](https://atcoder.jp/contests/abc059/submissions/45493267)

```python:解答例：answer_5-3-107.py
s1, s2, s3 = input().split()
print((s1[0]+s2[0]+s3[0]).upper())
```

```python:解答例：answer_5-3-108.py
S = input().split()
for s in S:
    print(s[0].upper(), end="")
```

[ABC126 A - Changing a Character](https://atcoder.jp/contests/abc126/tasks/abc126_a) ｜ [提出結果](https://atcoder.jp/contests/abc126/submissions/45493273)

```python:解答例：answer_5-3-109.py
N, K = map(int, input().split())
S = input()
print(S[:K-1]+S[K-1:K].lower()+S[K:])
```

[ABC338 A - Capitalized?](https://atcoder.jp/contests/abc338/tasks/abc338_a) ｜ [提出結果](https://atcoder.jp/contests/abc338/submissions/49979116)

```python:解答例：answer_5-3-110.py
S = input()
if S == S[0].upper()+S[1:].lower():
    print("Yes")
else:
    print("No")
```

### 文字列の大文字/小文字判定

文字列の大文字判定は`isupper`メソッド、小文字判定は`islower`メソッドを使用する。

```python:サンプルコード：sample_5-3-34.py
x = "ABC"
print(x.isupper())
```

```text:実行結果
True
```

```python:サンプルコード：sample_5-3-35.py
x = "abc"
print(x.islower())
```

```text:実行結果
True
```

[ABC402 A - CBC](https://atcoder.jp/contests/abc402/tasks/abc402_a) ｜ [提出結果](https://atcoder.jp/contests/abc402/submissions/65293156)

```python:解答例：answer_5-3-111.py
S = input()
ans = ""
for s in S:
    if s.isupper():
        ans += s
print(ans)
```

[ABC291 A - camel Case](https://atcoder.jp/contests/abc291/tasks/abc291_a) ｜ [提出結果](https://atcoder.jp/contests/abc291/submissions/45493280)

```python:解答例：answer_5-3-112.py
S = input()
idx = 1
for s in S:
    if s.isupper():
        break
    else:
        idx += 1
print(idx)
```

### 文字列のゼロ埋め

文字列のゼロ埋めは`zfill`メソッドを使用する。引数では`0`で埋める桁数を指定する。

```python:サンプルコード：sample_5-3-36.py
x = "12"
print(x.zfill(4))
```

```text:実行結果
0012
```

```python:サンプルコード：sample_5-3-37.py
x = "12"
print("ABC"+x.zfill(3))
```

```text:実行結果
ABC012
```

```python:サンプルコード：sample_5-3-38.py
x = "5"
print("12:"+x.zfill(2))
```

```text:実行結果
12:05
```

[ABC222 A - Four Digits](https://atcoder.jp/contests/abc222/tasks/abc222_a) ｜ [提出結果](https://atcoder.jp/contests/abc222/submissions/45493285)

```python:解答例：answer_5-3-113.py
N = input()
print(N.zfill(4))
```

[ABC230 A - AtCoder Quiz 3](https://atcoder.jp/contests/abc230/tasks/abc230_a) ｜ [提出結果](https://atcoder.jp/contests/abc230/submissions/45493295)

```python:解答例：answer_5-3-114.py
N = int(input())
if N < 42:
    print("AGC"+str(N).zfill(3))
else:
    print("AGC"+str(N+1).zfill(3))
```

### 文字列のフォーマット

文字列のフォーマットはフォーマット済み文字列リテラルを使用する。

#### ゼロ埋め

ゼロ埋めは`f"{変数または式:0ゼロ埋めする桁数}"`で指定する。

```python:サンプルコード：sample_5-3-39.py
x = 12
print(f"{x:04}")
```

```text:実行結果
0012
```

```python:サンプルコード：sample_5-3-40.py
x = 12
print(f"ABC{x:03}")
```

```text:実行結果
ABC012
```

```python:サンプルコード：sample_5-3-41.py
x = 5
print(f"12:{x:02}")
```

```text:実行結果
12:05
```

[ABC222 A - Four Digits](https://atcoder.jp/contests/abc222/tasks/abc222_a) ｜ [提出結果](https://atcoder.jp/contests/abc222/submissions/45493304)

```python:解答例：answer_5-3-115.py
N = int(input())
print(f"{N:04}")
```

[ABC230 A - AtCoder Quiz 3](https://atcoder.jp/contests/abc230/tasks/abc230_a) ｜ [提出結果](https://atcoder.jp/contests/abc230/submissions/45493313)

```python:解答例：answer_5-3-116.py
N = int(input())
if N < 42:
    print(f"AGC{N:03}")
else:
    print(f"AGC{N+1:03}")
```

#### 小数点桁数

小数点桁数は`f"{変数または式:.小数点桁数f}"`で指定する。

```python:サンプルコード：sample_5-3-42.py
x = 1.23456
print(f"{x:.0f}")
print(f"{x:.1f}")
print(f"{x:.2f}")
print(f"{x:.3f}")
print(f"{x:.4f}")
```

```text:実行結果
1
1.2
1.23
1.235
1.2346
```

[ABC274 A - Batting Average](https://atcoder.jp/contests/abc274/tasks/abc274_a) ｜ [提出結果](https://atcoder.jp/contests/abc274/submissions/45493321)

```python:解答例：answer_5-3-117.py
A, B = map(int, input().split())
print(f"{B/A:.3f}")
```

#### 進数

進数は`f"{変数または式:進数の変換型}"`で指定する。進数の変換型は下記の表の通りとなる。

|変換|意味|
|:-:|:--|
|`b`|2進数|
|`o`|8進数|
|`d`|10進数|
|`x`|16進数小文字|
|`X`|16進数大文字|

```python:サンプルコード：sample_5-3-43.py
num = 10
print(f"bin(b):{num:b}")
print(f"oct(o):{num:o}")
print(f"dec(d):{num:d}")
print(f"hex(x):{num:x}")
print(f"HEX(X):{num:X}")
```

```text:実行結果
bin(b):1010
oct(o):12
dec(d):10
hex(x):a
HEX(X):A
```

[ABC271 A - 484558](https://atcoder.jp/contests/abc271/tasks/abc271_a) ｜ [提出結果](https://atcoder.jp/contests/abc271/submissions/45493326)

```python:解答例：answer_5-3-118.py
N = int(input())
print(f"{N:02X}")
```

## 5.4 リスト（list）

<b>キーポイント</b>

* 要素の参照は`リスト[インデックス]`となる。
* 数値の要素に算術演算を使用することができる。
* 文字列の要素の連結は`+`演算子を使用する。
* リストの連結は`+`演算子を使用する。
* リストの繰り返しは`*`演算子を使用する。
* 要素の探索は`index`メソッドを使用する。
* 要素のカウントは`count`メソッドを使用する。
* 要素の追加は`append`メソッドを使用する。
* 要素の挿入は`insert`メソッドを使用する。
* 要素の取り出しは`pop`メソッドを使用する。
* 要素のユニーク化はリスト`list`型から集合`set`型に変換することにより、要素がユニークとなる。ただし、<b>要素の順序は保たれない。</b>
* 要素のスライスは`リスト[開始のインデックス:終了のインデックス:ステップ数]`となる。

### 要素の参照

要素の参照は`リスト[インデックス]`となる。範囲外の参照は`IndexError`が返却される。

```python:サンプルコード：sample_5-4-1.py
x = [1, 2, 3]
print(x[0], x[1], x[2])
```

```text:実行結果
1 2 3
```

```python:サンプルコード：sample_5-4-2.py
x = [1, 2, 3]
print(x[-1], x[-2], x[-3])
```

```text:実行結果
3 2 1
```

```python:サンプルコード：sample_5-4-3.py
x = ["a", "b", "c"]
print(x[0], x[1], x[2])
```

```text:実行結果
a b c
```

```python:サンプルコード：sample_5-4-4.py
x = ["a", "b", "c"]
print(x[-1], x[-2], x[-3])
```

```text:実行結果
c b a
```

```python:サンプルコード：sample_5-4-5.py
x = ["a", "b", "c"]
print(x[3])
```

```text:実行結果
IndexError: list index out of range
```

[ABC255 A - You should output ARC, though this is ABC.](https://atcoder.jp/contests/abc255/tasks/abc255_a) ｜ [提出結果](https://atcoder.jp/contests/abc255/submissions/45493340)

```python:解答例：answer_5-4-1.py
R, C = map(int, input().split())
A = [input().split() for i in range(2)]
print(A[R-1][C-1])
```

[ABC241 A - Digit Machine](https://atcoder.jp/contests/abc241/tasks/abc241_a) ｜ [提出結果](https://atcoder.jp/contests/abc241/submissions/45493347) ｜ [提出結果](https://atcoder.jp/contests/abc241/submissions/45493355)

```python:解答例：answer_5-4-2.py
a = list(map(int, input().split()))
print(a[a[a[0]]])
```

```python:解答例：answer_5-4-3.py
a = list(map(int, input().split()))
idx = 0
for i in range(2):
    idx = a[idx]
print(a[idx])
```

[ABC339 A - TLD](https://atcoder.jp/contests/abc339/tasks/abc339_a) ｜ [提出結果](https://atcoder.jp/contests/abc339/submissions/49978367)

```python:解答例：answer_5-4-4.py
S = input()
print(S.split(".")[-1])
```

[ABC168 A - ∴ (Therefore)](https://atcoder.jp/contests/abc168/tasks/abc168_a) ｜ [提出結果](https://atcoder.jp/contests/abc168/submissions/45493377)

```python:解答例：answer_5-4-5.py
N = input()
book = ["pon", "pon", "hon", "bon", "hon", "hon", "pon", "hon", "pon", "hon"]
print(book[int(N[-1])])
```

[ABC284 A - Sequence of Strings](https://atcoder.jp/contests/abc284/tasks/abc284_a) ｜ [提出結果](https://atcoder.jp/contests/abc284/submissions/45493386) ｜ [提出結果](https://atcoder.jp/contests/abc284/submissions/45493393)

```python:解答例：answer_5-4-6.py
N = int(input())
S = [input() for i in range(N)]
for i in range(N):
    print(S[N-i-1])
```

```python:解答例：answer_5-4-7.py
N = int(input())
S = [input() for i in range(N)]
for i in range(N-1, -1, -1):
    print(S[i])
```

[ABC399 A - Hamming Distance](https://atcoder.jp/contests/abc399/tasks/abc399_a) ｜ [提出結果](https://atcoder.jp/contests/abc399/submissions/64346845)

```python:解答例：answer_5-4-8.py
N = int(input())
S = input()
T = input()
ans = 0
for i in range(N):
    if S[i] != T[i]:
        ans += 1
print(ans)
```

[ABC403 A - Odd Position Sum](https://atcoder.jp/contests/abc403/tasks/abc403_a) ｜ [提出結果](https://atcoder.jp/contests/abc403/submissions/65293873)

```python:解答例：answer_5-4-9.py
N = int(input())
A = list(map(int, input().split()))
ans = 0
for i in range(N):
    if i % 2 == 0:
        ans += A[i]
print(ans)
```

[ABC353 A - Buildings](https://atcoder.jp/contests/abc353/tasks/abc353_a) ｜ [提出結果](https://atcoder.jp/contests/abc353/submissions/53400205)

```python:解答例：answer_5-4-10.py
N = int(input())
H = list(map(int, input().split()))
for i in range(1, N):
    if H[0] < H[i]:
        print(i+1)
        break
else:
    print(-1)
```

[ABC364 A - Glutton Takahashi](https://atcoder.jp/contests/abc364/tasks/abc364_a) ｜ [提出結果](https://atcoder.jp/contests/abc364/submissions/56064448)

```python:解答例：answer_5-4-11.py
N = int(input())
S = [input() for i in range(N)]
for i in range(N-2):
    if S[i] == "sweet" and S[i+1] == "sweet":
        print("No")
        break
else:
    print("Yes")
```

[ABC376 A - Candy Button](https://atcoder.jp/contests/abc376/tasks/abc376_a) ｜ [提出結果](https://atcoder.jp/contests/abc376/submissions/59665952)

```python:解答例：answer_5-4-12.py
N, C = map(int, input().split())
T = list(map(int, input().split()))
count = 1
before = T[0]
for t in T:
    if t-before >= C:
        count += 1
        before = t
print(count)
```

[ABC308 A - New Scheme](https://atcoder.jp/contests/abc308/tasks/abc308_a) ｜ [提出結果](https://atcoder.jp/contests/abc308/submissions/45493407)

```python:解答例：answer_5-4-13.py
S = list(map(int, input().split()))
flag = True
for i in range(7):
    if S[i] <= S[i+1]:
        continue
    else:
        flag = False
for s in S:
    if 100 <= s <= 675 and s % 25 == 0:
        continue
    else:
        flag = False
print("Yes" if flag else "No")
```

### 要素の算術演算

* 数値の要素に算術演算を使用することができる。

```python:サンプルコード：sample_5-4-6.py
x = [1, 2, 3]
print(x[0]+x[1])
```

```text:実行結果
3
```

```python:サンプルコード：sample_5-4-7.py
x = [1, 2, 3]
print(x[-1]*x[-2])
```

```text:実行結果
6
```

[ABC346 A - Adjacent Product](https://atcoder.jp/contests/abc346/tasks/abc346_a) ｜ [提出結果](https://atcoder.jp/contests/abc346/submissions/51728913)

```python:解答例：answer_5-4-14.py
N = int(input())
A = list(map(int, input().split()))
for i in range(N-1):
    print(A[i]*A[i+1], end=" ")
```

[ABC272 A - Integer Sum](https://atcoder.jp/contests/abc272/tasks/abc272_a) ｜ [提出結果](https://atcoder.jp/contests/abc272/submissions/45493359)

```python:解答例：answer_5-4-15.py
N = int(input())
A = list(map(int, input().split()))
total = 0
for i in range(N):
    total += A[i]
print(total)
```

[ABC290 A - Contest Result](https://atcoder.jp/contests/abc290/tasks/abc290_a) ｜ [提出結果](https://atcoder.jp/contests/abc290/submissions/45493364) ｜ [提出結果](https://atcoder.jp/contests/abc290/submissions/45493368)

```python:解答例：answer_5-4-16.py
N, M = map(int, input().split())
A = list(map(int, input().split()))
B = list(map(int, input().split()))
total = 0
for b in B:
    total += A[b-1]
print(total)
```

```python:解答例：answer_5-4-17.py
N, M = map(int, input().split())
A = list(map(int, input().split()))
B = list(map(int, input().split()))
total = 0
for i in range(M):
    total += A[B[i]-1]
print(total)
```

[ABC297 A - Double Click](https://atcoder.jp/contests/abc297/tasks/abc297_a) ｜ [提出結果](https://atcoder.jp/contests/abc297/submissions/45493399)

```python:解答例：answer_5-4-18.py
N, D = map(int, input().split())
T = list(map(int, input().split()))
for i in range(N-1):
    if T[i+1]-T[i] <= D:
        print(T[i+1])
        break
else:
    print(-1)
```

[ABC378 A - Pairing](https://atcoder.jp/contests/abc378/tasks/abc378_a) ｜ [提出結果](https://atcoder.jp/contests/abc378/submissions/60096784)

```python:解答例：answer_5-4-19.py
A = list(map(int, input().split()))
color = [0, 0, 0, 0]
for a in A:
    color[a-1] += 1
count = 0
for num in color:
    if num == 4:
        count += 2
    elif num in [2, 3]:
        count += 1
print(count)
```

### 要素の連結

* 文字列の要素の連結は`+`演算子を使用する。

```python:サンプルコード：sample_5-4-8.py
x = ["Hello", "World", "!"]
print(x[0]+x[1])
```

```text:実行結果
HelloWorld
```

```python:サンプルコード：sample_5-4-9.py
x = ["Hello", "World", "!"]
print(x[0]+x[-1])
```

```text:実行結果
Hello!
```

[ABC344 A - Spoiler](https://atcoder.jp/contests/abc344/tasks/abc344_a) ｜ [提出結果](https://atcoder.jp/contests/abc344/submissions/51099185)

```python:解答例：answer_5-4-20.py
S = input().split("|")
print(S[0]+S[2])
```

### リストの連結

* リストの連結は`+`演算子を使用する。

```python:サンプルコード：sample_5-4-10.py
x = ["Hello"]
y = ["World"]
print(x+y)
```

```text:実行結果
['Hello', 'World']
```

```python:サンプルコード：sample_5-4-11.py
x = [3, 4]
y = [1, 2, 3]
print(x+y)
```

```text:実行結果
[3, 4, 1, 2, 3]
```

### リストの繰り返し

* リストの繰り返しは`*`演算子を使用する。

```python:サンプルコード：sample_5-4-12.py
x = ["Hello", "World"]
print(x*2)
```

```text:実行結果
['Hello', 'World', 'Hello', 'World']
```

```python:サンプルコード：sample_5-4-13.py
x = [1, 2, 3]
print(x*3)
```

```text:実行結果
[1, 2, 3, 1, 2, 3, 1, 2, 3]
```

### 要素の探索

要素の探索は`index`メソッドを使用する。`探索されるリスト.index(探索する要素)`で探索する。`探索する要素`が含まれる場合は最小のインデックスが返却され、`探索する要素`が含まれない場合は`ValueError`が返却される。

```python:サンプルコード：sample_5-4-14.py
x = [1, 2, 3, 4, 5]
print(x.index(3))
```

```text:実行結果
2
```

```python:サンプルコード：sample_5-4-15.py
x = ["a", "b", "c", "d", "e", "f"]
print(x.index("c"))
```

```text:実行結果
2
```

```python:サンプルコード：sample_5-4-16.py
x = ["a", "b", "c", "d", "c", "c"]
print(x.index("c"))
```

```text:実行結果
2
```

```python:サンプルコード：sample_5-4-17.py
x = ["a", "b", "c"]
print(x.index("z"))
```

```text:実行結果
ValueError: 'z' is not in list
```

[ABC013 A - A](https://atcoder.jp/contests/abc013/tasks/abc013_1) ｜ [提出結果](https://atcoder.jp/contests/abc013/submissions/45493418) ｜ [提出結果](https://atcoder.jp/contests/abc013/submissions/45493426)

```python:解答例：answer_5-4-21.py
X = input()
print(["A", "B", "C", "D", "E"].index(X)+1)
```

```python:解答例：answer_5-4-22.py
X = input()
print(["0", "A", "B", "C", "D", "E"].index(X))
```

[ABC170 A - Five Variables](https://atcoder.jp/contests/abc170/tasks/abc170_a) ｜ [提出結果](https://atcoder.jp/contests/abc170/submissions/45493435) ｜ [提出結果](https://atcoder.jp/contests/abc170/submissions/45493443)

```python:解答例：answer_5-4-23.py
x = list(map(int, input().split()))
print(x.index(0)+1)
```

```python:解答例：answer_5-4-24.py
x = input().split()
print(x.index("0")+1)
```

[ABC277 A - ^{-1}](https://atcoder.jp/contests/abc277/tasks/abc277_a) ｜ [提出結果](https://atcoder.jp/contests/abc277/submissions/45493446) ｜ [提出結果](https://atcoder.jp/contests/abc277/submissions/45493454)

```python:解答例：answer_5-4-25.py
N, X = map(int, input().split())
P = list(map(int, input().split()))
print(P.index(X)+1)
```

```python:解答例：answer_5-4-26.py
N, X = input().split()
P = input().split()
print(P.index(X)+1)
```

[ABC300 A - N-choice question](https://atcoder.jp/contests/abc300/tasks/abc300_a) ｜ [提出結果](https://atcoder.jp/contests/abc300/submissions/45493460)

```python:解答例：answer_5-4-27.py
N, A, B = map(int, input().split())
C = list(map(int, input().split()))
print(C.index(A+B)+1)
```

[ABC146 A - Can't Wait for Holiday](https://atcoder.jp/contests/abc146/tasks/abc146_a) ｜ [提出結果](https://atcoder.jp/contests/abc146/submissions/45493466) ｜ [提出結果](https://atcoder.jp/contests/abc146/submissions/45493475)

```python:解答例：answer_5-4-28.py
S = input()
week = ["SUN", "MON", "TUE", "WED", "THU", "FRI", "SAT"]
print(7-week.index(S))
```

```python:解答例：answer_5-4-29.py
S = input()
week = ["0", "SAT", "FRI", "THU", "WED", "TUE", "MON", "SUN"]
print(week.index(S))
```

[ABC267 A - Saturday](https://atcoder.jp/contests/abc267/tasks/abc267_a) ｜ [提出結果](https://atcoder.jp/contests/abc267/submissions/45493485) ｜ [提出結果](https://atcoder.jp/contests/abc267/submissions/45493491)

```python:解答例：answer_5-4-30.py
S = input()
week = ["Monday", "Tuesday", "Wednesday", "Thursday", "Friday"]
print(5-week.index(S))
```

```python:解答例：answer_5-4-31.py
S = input()
week = ["0", "Friday", "Thursday", "Wednesday", "Tuesday", "Monday"]
print(week.index(S))
```

[ABC141 A - Weather Prediction](https://atcoder.jp/contests/abc141/tasks/abc141_a) ｜ [提出結果](https://atcoder.jp/contests/abc141/submissions/45493499) ｜ [提出結果](https://atcoder.jp/contests/abc141/submissions/45493507)

```python:解答例：answer_5-4-32.py
S = input()
weather = ["Sunny", "Cloudy", "Rainy", "Sunny"]
print(weather[(weather.index(S)+1)])
```

```python:解答例：answer_5-4-33.py
S = input()
weather = ["Sunny", "Cloudy", "Rainy"]
print(weather[(weather.index(S)+1) % 3])
```

[ABC275 A - Find Takahashi](https://atcoder.jp/contests/abc275/tasks/abc275_a) ｜ [提出結果](https://atcoder.jp/contests/abc275/submissions/45493516)

```python:解答例：answer_5-4-34.py
N = int(input())
H = list(map(int, input().split()))
bridge = 0
for h in H:
    if h > bridge:
        bridge = h
print(H.index(bridge)+1)
```

[ABC391 A - Lucky Direction](https://atcoder.jp/contests/abc391/tasks/abc391_a) ｜ [提出結果](https://atcoder.jp/contests/abc391/submissions/63074531)

```python:解答例：answer_5-4-35.py
D = input()
d = ["N", "NE", "E", "SE", "S", "SW", "W", "NW"]
print(d[d.index(D)-4])
```

### 要素のカウント

要素のカウントは`count`メソッドを使用する。`カウントされるリスト.count(カウントする要素)`でカウント数が返却される。

```python:サンプルコード：sample_5-4-18.py
x = [1, 2, 3, 4, 3, 5]
print(x.count(3))
```

```text:実行結果
2
```

```python:サンプルコード：sample_5-4-19.py
x = ["a", "b", "b", "c", "c", "c"]
print(x.count("c"))
```

```text:実行結果
3
```

```python:サンプルコード：sample_5-4-20.py
x = ["a", "b", "b", "c", "c", "c"]
print(x.count("d"))
```

```text:実行結果
0
```

[ABC359 A - Count Takahashi](https://atcoder.jp/contests/abc359/tasks/abc359_a) ｜ [提出結果](https://atcoder.jp/contests/abc359/submissions/55100693)

```python:解答例：answer_5-4-36.py
N = int(input())
S = [input() for i in range(N)]
print(S.count("Takahashi"))
```

[ABC042 A - 和風いろはちゃんイージー](https://atcoder.jp/contests/abc042/tasks/abc042_a) ｜ [提出結果](https://atcoder.jp/contests/abc042/submissions/45493524) ｜ [提出結果](https://atcoder.jp/contests/abc042/submissions/45493531)

```python:解答例：answer_5-4-37.py
ABC = list(map(int, input().split()))
if ABC.count(5) == 2 and ABC.count(7) == 1:
    print("YES")
else:
    print("NO")
```

```python:解答例：answer_5-4-38.py
ABC = input().split()
if ABC.count("5") == 2 and ABC.count("7") == 1:
    print("YES")
else:
    print("NO")
```

[ABC287 A - Majority](https://atcoder.jp/contests/abc287/tasks/abc287_a) ｜ [提出結果](https://atcoder.jp/contests/abc287/submissions/45493540)

```python:解答例：answer_5-4-39.py
N = int(input())
S = [input() for i in range(N)]
if S.count("For") > N/2:
    print("Yes")
else:
    print("No")
```

### 要素の追加

要素の追加は`append`メソッドを使用する。`リスト.append(要素)`でリストの最後に要素が追加される。

```python:サンプルコード：sample_5-4-21.py
x = ["a", "b", "c"]
x.append("d")
print(x)
```

```text:実行結果
['a', 'b', 'c', 'd']
```

```python:サンプルコード：sample_5-4-22.py
x = [0, 1, 2]
x.append(3)
print(x)
```

```text:実行結果
[0, 1, 2, 3]
```

### 要素の挿入

要素の挿入は`insert`メソッドを使用する。`リスト.insert(挿入先のインデックス, 要素)`でリストに要素が挿入される。

```python:サンプルコード：sample_5-4-23.py
x = ["a", "b", "c"]
x.insert(1, "z")
print(x)
```

```text:実行結果
['a', 'z', 'b', 'c']
```

[ABC361 A - Insert](https://atcoder.jp/contests/abc361/tasks/abc361_a) ｜ [提出結果](https://atcoder.jp/contests/abc361/submissions/55978772)

```python:解答例：answer_5-4-40.py
N, K, X = map(int, input().split())
A = list(map(int, input().split()))
A.insert(K, X)
print(*A)
```

### 要素の取り出し

要素の取り出しは`pop`メソッドを使用する。`リスト.pop(インデックス)`でインデックスの要素が取り出される。インデックスを指定しない場合`リスト.pop()`、リストの最後の要素が取り出される。

```python:サンプルコード：sample_5-4-24.py
x = ["a", "b", "c"]
print(x.pop(0))
print(x)
```

```text:実行結果
a
['b', 'c']
```

```python:サンプルコード：sample_5-4-25.py
x = [1, 2, 3]
print(x.pop(1))
print(x)
```

```text:実行結果
2
[1, 3]
```

```python:サンプルコード：sample_5-4-26.py
x = [1, 2, 3]
print(x.pop())
print(x)
```

```text:実行結果
3
[1, 2]
```

```python:サンプルコード：sample_5-4-27.py
x = [1, 2, 3]
print(x.pop(3))
print(x)
```

```text:実行結果
IndexError: pop index out of range
```

```python:サンプルコード：sample_5-4-28.py
x = []
print(x.pop())
```

```text:実行結果
IndexError: pop from empty list
```

[ABC278 A - Shift](https://atcoder.jp/contests/abc278/tasks/abc278_a) ｜ [提出結果](https://atcoder.jp/contests/abc278/submissions/45493554)

```python:解答例：answer_5-4-41.py
N, K = map(int, input().split())
A = list(map(int, input().split()))
for i in range(K):
    A.pop(0)
    A.append(0)
print(*A)
```

### 要素のユニーク化

要素のユニーク化はリスト`list`型から集合`set`型に変換することにより、要素がユニークとなる。ただし、<b>要素の順序は保たれない。</b>また、集合`set`型からリスト`list`型に変換することもできる。

```python:サンプルコード：sample_5-4-29.py
x = [1, 2, 3, 2, 1, 3]
print(list(set(x)))
```

```text:実行結果
[1, 2, 3]
```

```python:サンプルコード：sample_5-4-30.py
x = ["b", "a", "c", "a", "b"]
print(list(set(x)))
```

```text:実行結果
['b', 'c', 'a']
```

### 要素のスライス

要素のスライスは`リスト[開始のインデックス:終了のインデックス:ステップ数]`となる。

```python:サンプルコード：sample_5-4-31.py
x = ["0", "1", "2", "3", "4", "5"]
print(x[1:4])
```

```text:実行結果
['1', '2', '3']
```

```python:サンプルコード：sample_5-4-32.py
x = ["0", "1", "2", "3", "4", "5"]
print(x[1:4:2])
```

```text:実行結果
['1', '3']
```

```python:サンプルコード：sample_5-4-33.py
x = ["0", "1", "2", "3", "4", "5"]
print(x[:3])
```

```text:実行結果
['0', '1', '2']
```

```python:サンプルコード：sample_5-4-34.py
x = ["0", "1", "2", "3", "4", "5"]
print(x[3:])
```

```text:実行結果
['3', '4', '5']
```

```python:サンプルコード：sample_5-4-35.py
x = ["0", "1", "2", "3", "4", "5"]
print(x[:-1])
```

```text:実行結果
['0', '1', '2', '3', '4']
```

```python:サンプルコード：sample_5-4-36.py
x = ["0", "1", "2", "3", "4", "5"]
print(x[-1:])
```

```text:実行結果
['5']
```

```python:サンプルコード：sample_5-4-37.py
x = ["0", "1", "2", "3", "4", "5"]
print(x[::2])
```

```text:実行結果
['0', '2', '4']
```

```python:サンプルコード：sample_5-4-38.py
x = ["0", "1", "2", "3", "4", "5"]
print(x[1::2])
```

```text:実行結果
['1', '3', '5']
```

```python:サンプルコード：sample_5-4-39.py
x = ["0", "1", "2", "3", "4", "5"]
print(x[::-1])
```

```text:実行結果
['5', '4', '3', '2', '1', '0']
```

```python:サンプルコード：sample_5-4-40.py
x = ["0", "1", "2", "3", "4", "5"]
print(x[::-2])
```

```text:実行結果
['5', '3', '1']
```

[ABC284 A - Sequence of Strings](https://atcoder.jp/contests/abc284/tasks/abc284_a) ｜ [提出結果](https://atcoder.jp/contests/abc284/submissions/54183286)

```python:解答例：answer_5-4-42.py
N = int(input())
S = [input() for i in range(N)]
print(*S[::-1], sep="\n")
```

[ABC286 A - Range Swap](https://atcoder.jp/contests/abc286/tasks/abc286_a) ｜ [提出結果](https://atcoder.jp/contests/abc286/submissions/45493562) ｜ [提出結果](https://atcoder.jp/contests/abc286/submissions/45493567)

```python:解答例：answer_5-4-43.py
N, P, Q, R, S = map(int, input().split())
A = list(map(int, input().split()))
A[P-1:Q], A[R-1:S] = A[R-1:S], A[P-1:Q]
print(*A)
```

```python:解答例：answer_5-4-44.py
N, P, Q, R, S = map(int, input().split())
A = input().split()
A[P-1:Q], A[R-1:S] = A[R-1:S], A[P-1:Q]
print(*A)
```

[ABC356 A - Subsegment Reverse](https://atcoder.jp/contests/abc356/tasks/abc356_a) ｜ [提出結果](https://atcoder.jp/contests/abc356/submissions/54182443)

```python:解答例：answer_5-4-45.py
N, L, R = map(int, input().split())
A = list(range(1, N+1))
A[L-1:R] = A[L-1:R][::-1]
print(*A)
```

[ABC368 A - Cut](https://atcoder.jp/contests/abc368/tasks/abc368_a) ｜ [提出結果](https://atcoder.jp/contests/abc368/submissions/57114320)

```python:解答例：answer_5-4-46.py
N, K = map(int, input().split())
A = list(map(int, input().split()))
print(*A[-K:]+A[:N-K])
```

[ABC304 A - First Player](https://atcoder.jp/contests/abc304/tasks/abc304_a) ｜ [提出結果](https://atcoder.jp/contests/abc304/submissions/45493587)

```python:解答例：answer_5-4-47.py
N = int(input())
S = []
A = []
for i in range(N):
    s, a = input().split()
    S.append(s)
    A.append(int(a))
idx = A.index(min(A))
print(*S[idx:]+S[:idx], sep="\n")
```

## 5.5 集合（set）

<b>キーポイント</b>

* 集合への変換は`set(データ)`で集合に変換される。
* 集合の和は`|`を使用する。
* 集合の差は`-`を使用する。
* 集合の積は`&`を使用する。
* 集合の対称差は`^`を使用する。
* 部分集合は不等式を使用する。
* 要素の追加は`add`メソッドを使用する。
* 要素の取り出しは`pop`メソッドを使用する。
* 要素の取り除きは`discard`メソッドを使用する。

### 集合への変換

集合への変換は`set(データ)`で集合に変換される。

```python:サンプルコード：sample_5-5-1.py
x = "abcabc"
print(set(x))
```

```text:実行結果
{'b', 'c', 'a'}
```

```python:サンプルコード：sample_5-5-2.py
x = ["a", "b", "c", "a", "b", "c"]
print(set(x))
```

```text:実行結果
{'c', 'a', 'b'}
```

### 集合の和

集合の和は`|`を使用する。

```python:サンプルコード：sample_5-5-3.py
print({"a", "b", "c"} | {"c", "d", "e"})
```

```text:実行結果
{'a', 'b', 'd', 'e', 'c'}
```

### 集合の差

集合の差は`-`を使用する。

```python:サンプルコード：sample_5-5-4.py
print({"a", "b", "c"} - {"c", "d", "e"})
```

```text:実行結果
{'a', 'b'}
```

[ABC148 A - Round One](https://atcoder.jp/contests/abc148/tasks/abc148_a) ｜ [提出結果](https://atcoder.jp/contests/abc148/submissions/45493595)

```python:解答例：answer_5-5-1.py
U = {1, 2, 3}
AB = set(int(input()) for i in range(2))
print(list(U-AB)[0])
```

[ABC248 A - Lacked Number](https://atcoder.jp/contests/abc248/tasks/abc248_a) ｜ [提出結果](https://atcoder.jp/contests/abc248/submissions/45493605) ｜ [提出結果](https://atcoder.jp/contests/abc248/submissions/45493614)

```python:解答例：answer_5-5-2.py
U = {"0", "1", "2", "3", "4", "5", "6", "7", "8", "9"}
S = set(input())
print(list(U-S)[0])
```

```python:解答例：answer_5-5-3.py
U = {0, 1, 2, 3, 4, 5, 6, 7, 8, 9}
S = set(map(int, input()))
print(list(U-S)[0])
```

### 集合の積

集合の積は`&`を使用する。

```python:サンプルコード：sample_5-5-5.py
print({"a", "b", "c"} & {"c", "d", "e"})
```

```text:実行結果
{'c'}
```

[ABC295 A - Probably English](https://atcoder.jp/contests/abc295/tasks/abc295_a) ｜ [提出結果](https://atcoder.jp/contests/abc295/submissions/53029939)

```python:解答例：answer_5-5-4.py
N = int(input())
W = set(input().split())
S = {"and", "not", "that", "the", "you"}
if S & W:
    print("Yes")
else:
    print("No")
```

### 集合の対称差

集合の対称差は`^`を使用する。

```python:サンプルコード：sample_5-5-6.py
print({"a", "b", "c"} ^ {"c", "d", "e"})
```

```text:実行結果
{'a', 'b', 'e', 'd'}
```

### 部分集合

部分集合は不等式を使用する。

```python:サンプルコード：sample_5-5-7.py
print({"a", "b"} <= {"a", "b", "c"})
```

```text:実行結果
True
```

```python:サンプルコード：sample_5-5-8.py
print({"a", "z"} <= {"a", "b", "c"})
```

```text:実行結果
False
```

```python:サンプルコード：sample_5-5-9.py
print({"a", "b", "c"} >= {"a", "b"})
```

```text:実行結果
True
```

```python:サンプルコード：sample_5-5-10.py
print({"a", "b", "c"} >= {"a", "z"})
```

```text:実行結果
False
```

[ABC062 A - Grouping](https://atcoder.jp/contests/abc062/tasks/abc062_a) ｜ [提出結果](https://atcoder.jp/contests/abc062/submissions/45493635) ｜ [提出結果](https://atcoder.jp/contests/abc062/submissions/45493651)

```python:解答例：answer_5-5-5.py
x, y = map(int, input().split())
group1 = {1, 3, 5, 7, 8, 10, 12}
group2 = {4, 6, 9, 11}
if {x, y} <= group1 or {x, y} <= group2:
    print("Yes")
else:
    print("No")
```

```python:解答例：answer_5-5-6.py
x, y = input().split()
group1 = {"1", "3", "5", "7", "8", "10", "12"}
group2 = {"4", "6", "9", "11"}
if {x, y} <= group1 or {x, y} <= group2:
    print("Yes")
else:
    print("No")
```

### 要素の追加

要素の追加は`add`メソッドを使用する。

```python:サンプルコード：sample_5-5-11.py
x = set()
x.add("a")
print(x)
```

```text:実行結果
{'a'}
```

```python:サンプルコード：sample_5-5-12.py
x = set()
x.add(1)
print(x)
```

```text:実行結果
{1}
```

### 要素の取り出し

要素の取り出しは`pop`メソッドを使用する。

```python:サンプルコード：sample_5-5-13.py
x = {"a"}
print(x.pop())
```

```text:実行結果
a
```

[ABC148 A - Round One](https://atcoder.jp/contests/abc148/tasks/abc148_a) ｜ [提出結果](https://atcoder.jp/contests/abc148/submissions/45493659)

```python:解答例：answer_5-5-7.py
U = {1, 2, 3}
AB = set(int(input()) for i in range(2))
print((U-AB).pop())
```

[ABC248 A - Lacked Number](https://atcoder.jp/contests/abc248/tasks/abc248_a) ｜ [提出結果](https://atcoder.jp/contests/abc248/submissions/45493668) ｜ [提出結果](https://atcoder.jp/contests/abc248/submissions/45493674)

```python:解答例：answer_5-5-8.py
U = {"0", "1", "2", "3", "4", "5", "6", "7", "8", "9"}
S = set(input())
print((U-S).pop())
```

```python:解答例：answer_5-5-9.py
U = {0, 1, 2, 3, 4, 5, 6, 7, 8, 9}
S = set(map(int, input()))
print((U-S).pop())
```

### 要素の取り除き

要素の取り除きは`discard`メソッドを使用する。

```python:サンプルコード：sample_5-5-14.py
x = {"a", "b", "c"}
x.discard("a")
print(x)
```

```text:実行結果
{'c', 'b'}
```

```python:サンプルコード：sample_5-5-15.py
x = {"a", "b", "c"}
x.discard("z")
print(x)
```

```text:実行結果
{'b', 'a', 'c'}
```

[ABC355 A - Who Ate the Cake?](https://atcoder.jp/contests/abc355/tasks/abc355_a) ｜ [提出結果](https://atcoder.jp/contests/abc355/submissions/55086912)

```python:解答例：answer_5-5-10.py
A, B = map(int, input().split())
s = {1, 2, 3}
s.discard(A)
s.discard(B)
if A == B:
    print(-1)
else:
    print(s.pop())
```

## 5.6 辞書（dict）

<b>キーポイント</b>

* 値の参照は`辞書[キー]`となる。

### 値の参照

値の参照は`辞書[キー]`となる。

```python:サンプルコード：sample_5-6-1.py
x = {"a": 1, "b": 2, "c": 3}
print(x["a"])
```

```text:実行結果
1
```

```python:サンプルコード：sample_5-6-2.py
x = {1: "a", 2: "b", 3: "c"}
print(x[2])
```

```text:実行結果
b
```

[ABC013 A - A](https://atcoder.jp/contests/abc013/tasks/abc013_1) ｜ [提出結果](https://atcoder.jp/contests/abc013/submissions/45493683)

```python:解答例：answer_5-6-1.py
X = input()
alphabet = {"A": 1, "B": 2, "C": 3, "D": 4, "E": 5}
print(alphabet[X])
```

[ABC141 A - Weather Prediction](https://atcoder.jp/contests/abc141/tasks/abc141_a) ｜ [提出結果](https://atcoder.jp/contests/abc141/submissions/45493689)

```python:解答例：answer_5-6-2.py
S = input()
weather = {"Sunny": "Cloudy", "Cloudy": "Rainy", "Rainy": "Sunny"}
print(weather[S])
```

[ABC391 A - Lucky Direction](https://atcoder.jp/contests/abc391/tasks/abc391_a) ｜ [提出結果](https://atcoder.jp/contests/abc391/submissions/63074629)

```python:解答例：answer_5-6-3.py
D = input()
d = {"N": "S", "NE": "SW", "E": "W", "SE": "NW",
     "S": "N", "SW": "NE", "W": "E", "NW": "SE"}
print(d[D])
```

[ABC146 A - Can't Wait for Holiday](https://atcoder.jp/contests/abc146/tasks/abc146_a) ｜ [提出結果](https://atcoder.jp/contests/abc146/submissions/45493698)

```python:解答例：answer_5-6-4.py
S = input()
week = {"SUN": 7, "MON": 6, "TUE": 5, "WED": 4, "THU": 3, "FRI": 2, "SAT": 1}
print(week[S])
```

[ABC267 A - Saturday](https://atcoder.jp/contests/abc267/tasks/abc267_a) ｜ [提出結果](https://atcoder.jp/contests/abc267/submissions/45493705)

```python:解答例：answer_5-6-5.py
S = input()
week = {"Monday": 5, "Tuesday": 4, "Wednesday": 3, "Thursday": 2, "Friday": 1}
print(week[S])
```

[ABC319 A - Legendary Players](https://atcoder.jp/contests/abc319/tasks/abc319_a) ｜ [提出結果](https://atcoder.jp/contests/abc319/submissions/45493712)

```python:解答例：answer_5-6-6.py
rate = {
    "tourist": 3858,
    "ksun48": 3679,
    "Benq": 3658,
    "Um_nik": 3648,
    "apiad": 3638,
    "Stonefeang": 3630,
    "ecnerwala": 3613,
    "mnbvmar": 3555,
    "newbiedmy": 3516,
    "semiexp": 3481
}
S = input()
print(rate[S])
```

[ABC168 A - ∴ (Therefore)](https://atcoder.jp/contests/abc168/tasks/abc168_a) ｜ [提出結果](https://atcoder.jp/contests/abc168/submissions/45493719)

```python:解答例：answer_5-6-7.py
N = input()
book = {"0": "pon", "1": "pon", "2": "hon", "3": "bon", "4": "hon",
        "5": "hon", "6": "pon", "7": "hon", "8": "pon", "9": "hon"}
print(book[N[-1]])
```

# 第6章 組み込み関数

第6章では組み込み関数について説明します。

## 6.1 長さ（len）

<b>キーポイント</b>

* 文字列とリストの長さを得る場合、`len`関数を使用する。

### 文字列の長さ

文字列の長さを得る場合、`len(文字列)`となる。

```python:サンプルコード：sample_6-1-1.py
x = "Hello"
print(len(x))
```

```text:実行結果
5
```

[ABC015 A - 高橋くんの研修](https://atcoder.jp/contests/abc015/tasks/abc015_1) ｜ [提出結果](https://atcoder.jp/contests/abc015/submissions/45493729)

```python:解答例：answer_6-1-1.py
A = input()
B = input()
if len(A) > len(B):
    print(A)
else:
    print(B)
```

[ABC266 A - Middle Letter](https://atcoder.jp/contests/abc266/tasks/abc266_a) ｜ [提出結果](https://atcoder.jp/contests/abc266/submissions/45493737)

```python:解答例：answer_6-1-2.py
S = input()
print(S[len(S)//2])
```

[ABC222 A - Four Digits](https://atcoder.jp/contests/abc222/tasks/abc222_a) ｜ [提出結果](https://atcoder.jp/contests/abc222/submissions/45493744)

```python:解答例：answer_6-1-3.py
N = input()
print("0"*(4-len(N))+N)
```

[ABC033 A - 暗証番号](https://atcoder.jp/contests/abc033/tasks/abc033_a) ｜ [提出結果](https://atcoder.jp/contests/abc033/submissions/45493753)

```python:解答例：answer_6-1-4.py
N = input()
if len(set(N)) == 1:
    print("SAME")
else:
    print("DIFFERENT")
```

[ABC189 A - Slot](https://atcoder.jp/contests/abc189/tasks/abc189_a) ｜ [提出結果](https://atcoder.jp/contests/abc189/submissions/45493764)

```python:解答例：answer_6-1-5.py
C = input()
if len(set(C)) == 1:
    print("Won")
else:
    print("Lost")
```

[ABC093 A - abc of ABC](https://atcoder.jp/contests/abc093/tasks/abc093_a) ｜ [提出結果](https://atcoder.jp/contests/abc093/submissions/45493772)

```python:解答例：answer_6-1-6.py
S = input()
if len(set(S)) == 3:
    print("Yes")
else:
    print("No")
```

[ABC158 A - Station and Bus](https://atcoder.jp/contests/abc158/tasks/abc158_a) ｜ [提出結果](https://atcoder.jp/contests/abc158/submissions/45493777)

```python:解答例：answer_6-1-7.py
S = input()
if len(set(S)) != 1:
    print("Yes")
else:
    print("No")
```

[ABC225 A - Distinct Strings](https://atcoder.jp/contests/abc225/tasks/abc225_a) ｜ [提出結果](https://atcoder.jp/contests/abc225/submissions/45493789)

```python:解答例：answer_6-1-8.py
S = input()
kind = len(set(S))
if kind == 1:
    print(1)
elif kind == 2:
    print(3)
else:
    print(6)
```

[ABC373 A - September](https://atcoder.jp/contests/abc373/tasks/abc373_a) ｜ [提出結果](https://atcoder.jp/contests/abc373/submissions/58772802)

```python:解答例：answer_6-1-9.py
S = [input() for _ in range(12)]
count = 0
for i in range(12):
    if len(S[i]) == i+1:
        count += 1
print(count)
```

[ABC293 A - Swap Odd and Even](https://atcoder.jp/contests/abc293/tasks/abc293_a) ｜ [提出結果](https://atcoder.jp/contests/abc293/submissions/45493796)

```python:解答例：answer_6-1-10.py
S = input()
for i in range(0, len(S), 2):
    print(S[i+1]+S[i], end="")
```

[ABC345 A - Leftrightarrow](https://atcoder.jp/contests/abc345/tasks/abc345_a) ｜ [提出結果](https://atcoder.jp/contests/abc345/submissions/51367722)

```python:解答例：answer_6-1-11.py
S = input()
flag = True
if S[0] != "<" or S[-1] != ">":
    flag = False
for i in range(1, len(S)-1):
    if S[i] != "=":
        flag = False
if flag:
    print("Yes")
else:
    print("No")
```

[ABC342 A - Yay!](https://atcoder.jp/contests/abc342/tasks/abc342_a) ｜ [提出結果](https://atcoder.jp/contests/abc342/submissions/50634295)

```python:解答例：answer_6-1-12.py
S = input()
if S[0] == S[1]:
    majority = S[0]
else:
    majority = S[2]
for i in range(len(S)):
    if S[i] != majority:
        print(i+1)
        break
```

### リストの長さ

リストの長さを得る場合、`len(リスト)`となる。

```python:サンプルコード：sample_6-1-2.py
x = ["a", "b", "c", "a"]
print(len(x))
```

```text:実行結果
4
```

```python:サンプルコード：sample_6-1-3.py
x = [0, 1, 2]
print(len(x))
```

```text:実行結果
3
```

[ABC046 A - AtCoDeerくんとペンキ](https://atcoder.jp/contests/abc046/tasks/abc046_a) ｜ [提出結果](https://atcoder.jp/contests/abc046/submissions/45493803) ｜ [提出結果](https://atcoder.jp/contests/abc046/submissions/45493812)

```python:解答例：answer_6-1-13.py
abc = input().split()
print(len(set(abc)))
```

```python:解答例：answer_6-1-14.py
abc = list(map(int, input().split()))
print(len(set(abc)))
```

[ABC268 A - Five Integers](https://atcoder.jp/contests/abc268/tasks/abc268_a) ｜ [提出結果](https://atcoder.jp/contests/abc268/submissions/45493821) ｜ [提出結果](https://atcoder.jp/contests/abc268/submissions/45493826)

```python:解答例：answer_6-1-15.py
ABCDE = input().split()
print(len(set(ABCDE)))
```

```python:解答例：answer_6-1-16.py
ABCDE = list(map(int, input().split()))
print(len(set(ABCDE)))
```

[ABC324 A - Same](https://atcoder.jp/contests/abc324/tasks/abc324_a) ｜ [提出結果](https://atcoder.jp/contests/abc324/submissions/46671894)

```python:解答例：answer_6-1-17.py
N = int(input())
A = list(map(int, input().split()))
if len(set(A)) == 1:
    print("Yes")
else:
    print("No")
```

[ABC155 A - Poor](https://atcoder.jp/contests/abc155/tasks/abc155_a) ｜ [提出結果](https://atcoder.jp/contests/abc155/submissions/45493836)

```python:解答例：answer_6-1-18.py
ABC = input().split()
if len(set(ABC)) == 2:
    print("Yes")
else:
    print("No")
```

[ABC132 A - Fifty-Fifty](https://atcoder.jp/contests/abc132/tasks/abc132_a) ｜ [提出結果](https://atcoder.jp/contests/abc132/submissions/45493849)

```python:解答例：answer_6-1-19.py
S = input()
c = list(set(S))
if len(c) == 2 and S.count(c[0]) == S.count(c[1]) == 2:
    print("Yes")
else:
    print("No")
```

## 6.2 ソート（sorted）

<b>キーポイント</b>

* ソートをする場合、`sorted`関数を使用する。
* ソートは昇順で行われる。
* ソートを降順にする場合、`sorted(データ)[::-1]`となる。

### 昇順

ソートをする場合、`sorted`関数を使用する。ソートは昇順で行われる。

```python:サンプルコード：sample_6-2-1.py
x = [2, 1, 3]
print(sorted(x))
```

```text:実行結果
[1, 2, 3]
```

[ABC019 A - 高橋くんと年齢](https://atcoder.jp/contests/abc019/tasks/abc019_1) ｜ [提出結果](https://atcoder.jp/contests/abc019/submissions/45493858)

```python:解答例：answer_6-2-1.py
abc = map(int, input().split())
print(sorted(abc)[1])
```

[ABC066 A - ringring](https://atcoder.jp/contests/abc066/tasks/abc066_a) ｜ [提出結果](https://atcoder.jp/contests/abc066/submissions/45493868)

```python:解答例：answer_6-2-2.py
a, b, c = sorted(map(int, input().split()))
print(a+b)
```

[ABC207 A - Repression](https://atcoder.jp/contests/abc207/tasks/abc207_a) ｜ [提出結果](https://atcoder.jp/contests/abc207/submissions/45493876)

```python:解答例：answer_6-2-3.py
x, y, z = sorted(map(int, input().split()))
print(y+z)
```

[ABC103 A - Task Scheduling Problem](https://atcoder.jp/contests/abc103/tasks/abc103_a) ｜ [提出結果](https://atcoder.jp/contests/abc103/submissions/45493884) ｜ [提出結果](https://atcoder.jp/contests/abc103/submissions/45493891)

```python:解答例：answer_6-2-4.py
A1, A2, A3 = sorted(map(int, input().split()))
print(A3-A1)
```

```python:解答例：answer_6-2-5.py
A = sorted(map(int, input().split()))
print(A[-1]-A[0])
```

[ABC110 A - Maximize the Formula](https://atcoder.jp/contests/abc110/tasks/abc110_a) ｜ [提出結果](https://atcoder.jp/contests/abc110/submissions/45493897)

```python:解答例：answer_6-2-6.py
A, B, C = sorted(input().split())
print(int(C+B)+int(A))
```

[ABC201 A - Tiny Arithmetic Sequence](https://atcoder.jp/contests/abc201/tasks/abc201_a) ｜ [提出結果](https://atcoder.jp/contests/abc201/submissions/45493907) ｜ [提出結果](https://atcoder.jp/contests/abc201/submissions/45493917)

```python:解答例：answer_6-2-7.py
A1, A2, A3 = sorted(map(int, input().split()))
if A3-A2 == A2-A1:
    print("Yes")
else:
    print("No")
```

```python:解答例：answer_6-2-8.py
A = sorted(map(int, input().split()))
if A[2]-A[1] == A[1]-A[0]:
    print("Yes")
else:
    print("No")
```

[ABC392 A - Shuffled Equation](https://atcoder.jp/contests/abc392/tasks/abc392_a) ｜ [提出結果](https://atcoder.jp/contests/abc392/submissions/63074246)

```python:解答例：answer_6-2-9.py
a, b, c = sorted(map(int, input().split()))
if a*b == c:
    print("Yes")
else:
    print("No")
```

[ABC047 A - キャンディーと2人の子供](https://atcoder.jp/contests/abc047/tasks/abc047_a) ｜ [提出結果](https://atcoder.jp/contests/abc047/submissions/45493923)

```python:解答例：answer_6-2-10.py
a, b, c = sorted(map(int, input().split()))
if a+b == c:
    print("Yes")
else:
    print("No")
```

[ABC385 A - Equally](https://atcoder.jp/contests/abc385/tasks/abc385_a) ｜ [提出結果](https://atcoder.jp/contests/abc385/submissions/61235214)

```python:解答例：answer_6-2-11.py
A, B, C = sorted(map(int, input().split()))
if A == B == C or A+B == C:
    print("Yes")
else:
    print("No")
```

[ABC377 A - Rearranging ABC](https://atcoder.jp/contests/abc377/tasks/abc377_a) ｜ [提出結果](https://atcoder.jp/contests/abc377/submissions/60159875)

```python:解答例：answer_6-2-12.py
S = input()
if sorted(S) == list("ABC"):
    print("Yes")
else:
    print("No")
```

[ABC380 A - 123233](https://atcoder.jp/contests/abc380/tasks/abc380_a) ｜ [提出結果](https://atcoder.jp/contests/abc380/submissions/60158984)

```python:解答例：answer_6-2-13.py
N = input()
if sorted(N) == list("122333"):
    print("Yes")
else:
    print("No")
```

[ABC395 A - Strictly Increasing?](https://atcoder.jp/contests/abc395/tasks/abc395_a) ｜ [提出結果](https://atcoder.jp/contests/abc395/submissions/64343123)

```python:解答例：answer_6-2-14.py
N = int(input())
A = list(map(int, input().split()))
if A == sorted(set(A)):
    print("Yes")
else:
    print("No")
```

[ABC263 A - Full House](https://atcoder.jp/contests/abc263/tasks/abc263_a) ｜ [提出結果](https://atcoder.jp/contests/abc263/submissions/45493930) ｜ [提出結果](https://atcoder.jp/contests/abc263/submissions/45493939)

```python:解答例：answer_6-2-15.py
A, B, C, D, E = sorted(input().split())
if (A == B == C and D == E) or (A == B and C == D == E):
    print("Yes")
else:
    print("No")
```

```python:解答例：answer_6-2-16.py
A, B, C, D, E = sorted(map(int, input().split()))
if (A == B == C and D == E) or (A == B and C == D == E):
    print("Yes")
else:
    print("No")
```


[ABC260 A - A Unique Letter](https://atcoder.jp/contests/abc260/tasks/abc260_a) ｜ [提出結果](https://atcoder.jp/contests/abc260/submissions/45493943)

```python:解答例：answer_6-2-17.py
a, b, c = sorted(input())
if a != b:
    print(a)
elif b != c:
    print(c)
else:
    print(-1)
```

[ABC342 A - Yay!](https://atcoder.jp/contests/abc342/tasks/abc342_a) ｜ [提出結果](https://atcoder.jp/contests/abc342/submissions/50634620)

```python:解答例：answer_6-2-18.py
S = input()
d = sorted(S)
if d[0] != d[1]:
    print(S.index(d[0])+1)
else:
    print(S.index(d[-1])+1)
```

### 降順

ソートを降順にする場合、`sorted(データ)[::-1]`となる。

```python:サンプルコード：sample_6-2-2.py
x = [2, 1, 3]
print(sorted(x)[::-1])
```

```text:実行結果
[3, 2, 1]
```

[ABC207 A - Repression](https://atcoder.jp/contests/abc207/tasks/abc207_a) ｜ [提出結果](https://atcoder.jp/contests/abc207/submissions/45493952)

```python:解答例：answer_6-2-19.py
x, y, z = sorted(map(int, input().split()))[::-1]
print(x+y)
```

[ABC110 A - Maximize the Formula](https://atcoder.jp/contests/abc110/tasks/abc110_a) ｜ [提出結果](https://atcoder.jp/contests/abc110/submissions/45493960)

```python:解答例：answer_6-2-20.py
A, B, C = sorted(input().split())[::-1]
print(int(A+B)+int(C))
```

[ABC018 A - 豆まき](https://atcoder.jp/contests/abc018/tasks/abc018_1) ｜ [提出結果](https://atcoder.jp/contests/abc018/submissions/45493970)

```python:解答例：answer_6-2-21.py
ABC = [int(input()) for i in range(3)]
sorted_ABC = sorted(ABC)[::-1]
for idx in ABC:
    print(sorted_ABC.index(idx)+1)
```

## 6.3 最大値（max）

<b>キーポイント</b>

* 最大値を得る場合、`max`関数を使用する。

整数の場合、`max(整数A, 整数B, 整数C)`となる。

```python:サンプルコード：sample_6-3-1.py
print(max(1, 2, 3))
```

```text:実行結果
3
```

変数の場合、`max(変数A, 変数B, 変数C)`となる。

```python:サンプルコード：sample_6-3-2.py
x = 1
y = 2
z = 3
print(max(x, y, z))
```

```text:実行結果
3
```

リストの場合、`max(リスト)`となる。

```python:サンプルコード：sample_6-3-3.py
x = [1, 2, 3]
print(max(x))
```

```text:実行結果
3
```

[ABC002 A - 正直者](https://atcoder.jp/contests/abc002/tasks/abc002_1) ｜ [提出結果](https://atcoder.jp/contests/abc002/submissions/45493980)

```python:解答例：answer_6-3-1.py
X, Y = map(int, input().split())
print(max(X, Y))
```

[ABC098 A - Add Sub Mul](https://atcoder.jp/contests/abc098/tasks/abc098_a) ｜ [提出結果](https://atcoder.jp/contests/abc098/submissions/45493984)

```python:解答例：answer_6-3-2.py
A, B = map(int, input().split())
print(max(A+B, A-B, A*B))
```

[ABC137 A - +-x](https://atcoder.jp/contests/abc137/tasks/abc137_a) ｜ [提出結果](https://atcoder.jp/contests/abc137/submissions/45493992)

```python:解答例：answer_6-3-3.py
A, B = map(int, input().split())
print(max(A+B, A-B, A*B))
```

[ABC052 A - Two Rectangles](https://atcoder.jp/contests/abc052/tasks/abc052_a) ｜ [提出結果](https://atcoder.jp/contests/abc052/submissions/45494002)

```python:解答例：answer_6-3-4.py
A, B, C, D = map(int, input().split())
print(max(A*B, C*D))
```

[ABC037 A - 饅頭](https://atcoder.jp/contests/abc037/tasks/abc037_a) ｜ [提出結果](https://atcoder.jp/contests/abc037/submissions/45494012)

```python:解答例：answer_6-3-5.py
A, B, C = map(int, input().split())
print(max(C//A, C//B))
```

[ABC207 A - Repression](https://atcoder.jp/contests/abc207/tasks/abc207_a) ｜ [提出結果](https://atcoder.jp/contests/abc207/submissions/45494021)

```python:解答例：answer_6-3-6.py
A, B, C = map(int, input().split())
print(max(A+B, B+C, C+A))
```

[ABC124 A - Buttons](https://atcoder.jp/contests/abc124/tasks/abc124_a) ｜ [提出結果](https://atcoder.jp/contests/abc124/submissions/45494037)

```python:解答例：answer_6-3-7.py
A, B = map(int, input().split())
print(max(A+(A-1), B+(B-1), A+B))
```

[ABC031 A - ゲーム](https://atcoder.jp/contests/abc031/tasks/abc031_a) ｜ [提出結果](https://atcoder.jp/contests/abc031/submissions/45494054)

```python:解答例：answer_6-3-8.py
A, D = map(int, input().split())
print(max((A+1)*D, A*(D+1)))
```

[ABC209 A - Counting](https://atcoder.jp/contests/abc209/tasks/abc209_a) ｜ [提出結果](https://atcoder.jp/contests/abc209/submissions/45494066)

```python:解答例：answer_6-3-9.py
A, B = map(int, input().split())
print(max(0, B-A+1))
```

[ABC183 A - ReLU](https://atcoder.jp/contests/abc183/tasks/abc183_a) ｜ [提出結果](https://atcoder.jp/contests/abc183/submissions/45494081)

```python:解答例：answer_6-3-10.py
x = int(input())
print(max(0, x))
```

[ABC072 A - Sandglass2](https://atcoder.jp/contests/abc072/tasks/abc072_a) ｜ [提出結果](https://atcoder.jp/contests/abc072/submissions/45494088)

```python:解答例：answer_6-3-11.py
X, t = map(int, input().split())
print(max(0, X-t))
```

[ABC143 A - Curtain](https://atcoder.jp/contests/abc143/tasks/abc143_a) ｜ [提出結果](https://atcoder.jp/contests/abc143/submissions/45494095)

```python:解答例：answer_6-3-12.py
A, B = map(int, input().split())
print(max(0, A-2*B))
```

[ABC136 A - Transfer](https://atcoder.jp/contests/abc136/tasks/abc136_a) ｜ [提出結果](https://atcoder.jp/contests/abc136/submissions/45494105)

```python:解答例：answer_6-3-13.py
A, B, C = map(int, input().split())
print(max(0, C-(A-B)))
```

[ABC233 A - 10yen Stamp](https://atcoder.jp/contests/abc233/tasks/abc233_a) ｜ [提出結果](https://atcoder.jp/contests/abc233/submissions/45494116)

```python:解答例：answer_6-3-14.py
import math
X, Y = map(int, input().split())
print(max(0, math.ceil((Y-X)/10)))
```

[ABC318 A - Full Moon](https://atcoder.jp/contests/abc318/tasks/abc318_a) ｜ [提出結果](https://atcoder.jp/contests/abc318/submissions/45494126)

```python:解答例：answer_6-3-15.py
import math
N, M, P = map(int, input().split())
print(max(0, math.ceil((N-M+1)/P)))
```

[ABC100 A - Happy Birthday!](https://atcoder.jp/contests/abc100/tasks/abc100_a) ｜ [提出結果](https://atcoder.jp/contests/abc100/submissions/45494137)

```python:解答例：answer_6-3-16.py
A, B = map(int, input().split())
if max(A, B) <= 8:
    print("Yay!")
else:
    print(":(")
```

[ABC275 A - Find Takahashi](https://atcoder.jp/contests/abc275/tasks/abc275_a) ｜ [提出結果](https://atcoder.jp/contests/abc275/submissions/45494146)

```python:解答例：answer_6-3-17.py
N = int(input())
H = list(map(int, input().split()))
print(H.index(max(H))+1)
```

[ABC311 A - First ABC](https://atcoder.jp/contests/abc311/tasks/abc311_a) ｜ [提出結果](https://atcoder.jp/contests/abc311/submissions/45494159)

```python:解答例：answer_6-3-18.py
N = int(input())
S = "0"+input()
print(max(S.find("A"), S.find("B"), S.find("C")))
```

[ABC026 A - 掛け算の最大値](https://atcoder.jp/contests/abc026/tasks/abc026_a) ｜ [提出結果](https://atcoder.jp/contests/abc026/submissions/45494175)

```python:解答例：answer_6-3-19.py
A = int(input())
ans = 0
for x in range(1, A+1):
    y = A-x
    ans = max(ans, x*y)
print(ans)
```

[ABC383 A - Humidifier 1](https://atcoder.jp/contests/abc383/tasks/abc383_a) ｜ [提出結果](https://atcoder.jp/contests/abc383/submissions/61234785)

```python:解答例：answer_6-3-20.py
N = int(input())
t, v = 0, 0
for _ in range(N):
    T, V = map(int, input().split())
    t, v = T, max(0, v-(T-t))+V
print(v)
```

[ABC313 A - To Be Saikyo](https://atcoder.jp/contests/abc313/tasks/abc313_a) ｜ [提出結果](https://atcoder.jp/contests/abc313/submissions/45494185)

```python:解答例：answer_6-3-21.py
N = int(input())
P = list(map(int, input().split()))
x = 0
for i in range(1, N):
    x = max(x, P[i])
if P[0] > x:
    print(0)
else:
    print(x-P[0]+1)
```

## 6.4 最小値（min）

<b>キーポイント</b>

* 最小値を得る場合、`min`関数を使用する。

整数の場合、`min(整数A, 整数B, 整数C)`となる。

```python:サンプルコード：sample_6-4-1.py
print(min(1, 2, 3))
```

```text:実行結果
1
```

変数の場合、`min(変数A, 変数B, 変数C)`となる。

```python:サンプルコード：sample_6-4-2.py
x = 1
y = 2
z = 3
print(min(x, y, z))
```

```text:実行結果
1
```

リストの場合、`min(リスト)`となる。

```python:サンプルコード：sample_6-4-3.py
x = [1, 2, 3]
print(min(x))
```

```text:実行結果
1
```

[ABC080 A - Parking](https://atcoder.jp/contests/abc080/tasks/abc080_a) ｜ [提出結果](https://atcoder.jp/contests/abc080/submissions/45494205)

```python:解答例：answer_6-4-1.py
N, A, B = map(int, input().split())
print(min(A*N, B))
```

[ABC133 A - T or T](https://atcoder.jp/contests/abc133/tasks/abc133_a) ｜ [提出結果](https://atcoder.jp/contests/abc133/submissions/45494221)

```python:解答例：answer_6-4-2.py
N, A, B = map(int, input().split())
print(min(N*A, B))
```

[ABC066 A - ringring](https://atcoder.jp/contests/abc066/tasks/abc066_a) ｜ [提出結果](https://atcoder.jp/contests/abc066/submissions/45494230)

```python:解答例：answer_6-4-3.py
a, b, c = map(int, input().split())
print(min(a+b, b+c, c+a))
```

[ABC129 A - Airplane](https://atcoder.jp/contests/abc129/tasks/abc129_a) ｜ [提出結果](https://atcoder.jp/contests/abc129/submissions/45494246)

```python:解答例：answer_6-4-4.py
P, Q, R = map(int, input().split())
print(min(P+Q, Q+R, R+P))
```

[ABC092 A - Traveling Budget](https://atcoder.jp/contests/abc092/tasks/abc092_a) ｜ [提出結果](https://atcoder.jp/contests/abc092/submissions/45494261)

```python:解答例：answer_6-4-5.py
A, B, C, D = [int(input()) for i in range(4)]
print(min(A, B)+min(C, D))
```

[ABC120 A - Favorite Sound](https://atcoder.jp/contests/abc120/tasks/abc120_a) ｜ [提出結果](https://atcoder.jp/contests/abc120/submissions/45494278)

```python:解答例：answer_6-4-6.py
A, B, C = map(int, input().split())
print(min(C, B//A))
```

[ABC040 A - 赤赤赤赤青](https://atcoder.jp/contests/abc040/tasks/abc040_a) ｜ [提出結果](https://atcoder.jp/contests/abc040/submissions/45494293)

```python:解答例：answer_6-4-7.py
n, x = map(int, input().split())
print(min(x-1, n-x))
```

[ABC185 A - ABC Preparation](https://atcoder.jp/contests/abc185/tasks/abc185_a) ｜ [提出結果](https://atcoder.jp/contests/abc185/submissions/45494306)

```python:解答例：answer_6-4-8.py
A = list(map(int, input().split()))
print(min(A))
```

[ABC103 A - Task Scheduling Problem](https://atcoder.jp/contests/abc103/tasks/abc103_a) ｜ [提出結果](https://atcoder.jp/contests/abc103/submissions/45494314)

```python:解答例：answer_6-4-9.py
A = list(map(int, input().split()))
print(max(A)-min(A))
```

[ABC310 A - Order Something Else](https://atcoder.jp/contests/abc310/tasks/abc310_a) ｜ [提出結果](https://atcoder.jp/contests/abc310/submissions/45494323)

```python:解答例：answer_6-4-10.py
N, P, Q = map(int, input().split())
D = list(map(int, input().split()))
print(min(P, Q+min(D)))
```

[ABC362 A - Buy a Pen](https://atcoder.jp/contests/abc362/tasks/abc362_a) ｜ [提出結果](https://atcoder.jp/contests/abc362/submissions/55978387)

```python:解答例：answer_6-4-11.py
R, G, B = map(int, input().split())
C = input()
if C == "Red":
    print(min(G, B))
if C == "Green":
    print(min(R, B))
if C == "Blue":
    print(min(R, G))
```

[ABC261 A - Intersection](https://atcoder.jp/contests/abc261/tasks/abc261_a) ｜ [提出結果](https://atcoder.jp/contests/abc261/submissions/45494333)

```python:解答例：answer_6-4-12.py
L1, R1, L2, R2 = map(int, input().split())
print(max(0, min(R1, R2)-max(L1, L2)))
```

## 6.5 合計値（sum）

<b>キーポイント</b>

* 合計値を得る場合、`sum`関数を使用する。

リストの要素の合計値を得る場合、`sum(リスト)`となる。

```python:サンプルコード：sample_6-5-1.py
x = [1, 2, 3]
print(sum(x))
```

```text:実行結果
6
```

[ABC272 A - Integer Sum](https://atcoder.jp/contests/abc272/tasks/abc272_a) ｜ [提出結果](https://atcoder.jp/contests/abc272/submissions/45494348)

```python:解答例：answer_6-5-1.py
N = int(input())
A = list(map(int, input().split()))
print(sum(A))
```

[ABC147 A - Blackjack](https://atcoder.jp/contests/abc147/tasks/abc147_a) ｜ [提出結果](https://atcoder.jp/contests/abc147/submissions/45494362)

```python:解答例：answer_6-5-2.py
A = list(map(int, input().split()))
if sum(A) >= 22:
    print("bust")
else:
    print("win")
```

[ABC202 A - Three Dice](https://atcoder.jp/contests/abc202/tasks/abc202_a) ｜ [提出結果](https://atcoder.jp/contests/abc202/submissions/45494371)

```python:解答例：answer_6-5-3.py
abc = list(map(int, input().split()))
print(21-sum(abc))
```

[ABC351 A - The bottom of the ninth](https://atcoder.jp/contests/abc351/tasks/abc351_a) ｜ [提出結果](https://atcoder.jp/contests/abc351/submissions/53248857)

```python:解答例：answer_6-5-4.py
A = list(map(int, input().split()))
B = list(map(int, input().split()))
print(sum(A)-sum(B)+1)
```

[ABC349 A - Zero Sum Game](https://atcoder.jp/contests/abc349/tasks/abc349_a) ｜ [提出結果](https://atcoder.jp/contests/abc349/submissions/52375936)

```python:解答例：answer_6-5-5.py
N = int(input())
A = list(map(int, input().split()))
print(0-sum(A))
```

[ABC066 A - ringring](https://atcoder.jp/contests/abc066/tasks/abc066_a) ｜ [提出結果](https://atcoder.jp/contests/abc066/submissions/45494382)

```python:解答例：answer_6-5-6.py
abc = list(map(int, input().split()))
print(sum(sorted(abc)[:2]))
```

[ABC403 A - Odd Position Sum](https://atcoder.jp/contests/abc403/tasks/abc403_a) ｜ [提出結果](https://atcoder.jp/contests/abc403/submissions/65293676)

```python:解答例：answer_6-5-7.py
N = int(input())
A = list(map(int, input().split()))
print(sum(A[::2]))
```

[ABC307 A - Weekly Records](https://atcoder.jp/contests/abc307/tasks/abc307_a) ｜ [提出結果](https://atcoder.jp/contests/abc307/submissions/45494388)

```python:解答例：answer_6-5-8.py
N = int(input())
A = list(map(int, input().split()))
for i in range(N):
    print(sum(A[i*7:(i+1)*7]), end=" ")
```

### 数字和

`map`関数を使用して、`sum(map(int, 整数の文字列データ))`で数字和を求めることができる。

```python:サンプルコード：sample_6-5-2.py
x = 1234
print(sum(map(int, str(x))))
```

```text:実行結果
10
```

```python:サンプルコード：sample_6-5-3.py
x = "1234"
print(sum(map(int, x)))
```

```text:実行結果
10
```

[ABC023 A - 加算王](https://atcoder.jp/contests/abc023/tasks/abc023_a) ｜ [提出結果](https://atcoder.jp/contests/abc023/submissions/45494399)

```python:解答例：answer_6-5-9.py
X = input()
print(sum(map(int, X)))
```

[ABC187 A - Large Digits](https://atcoder.jp/contests/abc187/tasks/abc187_a) ｜ [提出結果](https://atcoder.jp/contests/abc187/submissions/45494410)

```python:解答例：answer_6-5-10.py
A, B = input().split()
a = sum(map(int, A))
b = sum(map(int, B))
if a > b:
    print(a)
else:
    print(b)
```

[ABC248 A - Lacked Number](https://atcoder.jp/contests/abc248/tasks/abc248_a) ｜ [提出結果](https://atcoder.jp/contests/abc248/submissions/45494424)

```python:解答例：answer_6-5-11.py
S = input()
print(45-sum(map(int, S)))
```

## 6.6 絶対値（abs）

<b>キーポイント</b>

* 絶対値を得る場合、`abs`関数を使用する。

絶対値を得る場合、`abs(数値)`となる。

```python:サンプルコード：sample_6-6-1.py
x = -1
print(abs(x))
```

```text:実行結果
1
```

```python:サンプルコード：sample_6-6-2.py
x = -1.1
print(abs(x))
```

```text:実行結果
1.1
```

[ABC071 A - Meal Delivery](https://atcoder.jp/contests/abc071/tasks/abc071_a) ｜ [提出結果](https://atcoder.jp/contests/abc071/submissions/45494438)

```python:解答例：answer_6-6-1.py
x, a, b = map(int, input().split())
if abs(a-x) < abs(b-x):
    print("A")
else:
    print("B")
```

[ABC188 A - Three-Point Shot](https://atcoder.jp/contests/abc188/tasks/abc188_a) ｜ [提出結果](https://atcoder.jp/contests/abc188/submissions/45494449)

```python:解答例：answer_6-6-2.py
X, Y = map(int, input().split())
if abs(X-Y) < 3:
    print("Yes")
else:
    print("No")
```

[ABC123 A - Five Antennas](https://atcoder.jp/contests/abc123/tasks/abc123_a) ｜ [提出結果](https://atcoder.jp/contests/abc123/submissions/45494469)

```python:解答例：answer_6-6-3.py
a, b, c, d, e, k = [int(input()) for i in range(6)]
if abs(a-e) <= k:
    print("Yay!")
else:
    print(":(")
```

[ABC097 A - Colorful Transceivers](https://atcoder.jp/contests/abc097/tasks/abc097_a) ｜ [提出結果](https://atcoder.jp/contests/abc097/submissions/45494484)

```python:解答例：answer_6-6-4.py
a, b, c, d = map(int, input().split())
if abs(a-c) <= d or (abs(a-b) <= d and abs(b-c) <= d):
    print("Yes")
else:
    print("No")
```

[ABC305 A - Water Station](https://atcoder.jp/contests/abc305/tasks/abc305_a) ｜ [提出結果](https://atcoder.jp/contests/abc305/submissions/45494503)

```python:解答例：answer_6-6-5.py
N = int(input())
dist = 100
for i in range(0, 101, 5):
    if abs(N-dist) > abs(N-i):
        dist = i
print(dist)
```

## 6.7 文字（ord/chr）

<b>キーポイント</b>

* 文字の Unicode コードポイントを得る場合、`ord`関数を使用する。
* Unicode コードポイントの文字を得る場合、`chr`関数を使用する。

文字の Unicode コードポイントを得る場合、`ord(文字)`となる。Unicode コードポイントの文字を得る場合、`chr(整数)`となる。

```python:サンプルコード：sample_6-7-1.py
x = "a"
print(ord(x))
```

```text:実行結果
97
```

```python:サンプルコード：sample_6-7-2.py
x = 97
print(chr(x))
```

```text:実行結果
a
```

```python:サンプルコード：sample_6-7-3.py
x = "A"
print(ord(x))
```

```text:実行結果
65
```

```python:サンプルコード：sample_6-7-4.py
x = 65
print(chr(x))
```

```text:実行結果
A
```

[ABC252 A - ASCII code](https://atcoder.jp/contests/abc252/tasks/abc252_a) ｜ [提出結果](https://atcoder.jp/contests/abc252/submissions/45494522)

```python:解答例：answer_6-7-1.py
N = int(input())
print(chr(N))
```

[ABC151 A - Next Alphabet](https://atcoder.jp/contests/abc151/tasks/abc151_a) ｜ [提出結果](https://atcoder.jp/contests/abc151/submissions/45494543)

```python:解答例：answer_6-7-2.py
C = input()
print(chr(ord(C)+1))
```

[ABC402 A - CBC](https://atcoder.jp/contests/abc402/tasks/abc402_a) ｜ [提出結果](https://atcoder.jp/contests/abc402/submissions/65293437)

```python:解答例：answer_6-7-3.py
S = input()
ans = ""
for s in S:
    if ord("A") <= ord(s) <= ord("Z"):
        ans += s
print(ans)
```

[ABC282 A - Generalized ABC](https://atcoder.jp/contests/abc282/tasks/abc282_a) ｜ [提出結果](https://atcoder.jp/contests/abc282/submissions/45494561)

```python:解答例：answer_6-7-4.py
K = int(input())
s = ""
for i in range(K):
    s += chr(ord("A")+i)
print(s)
```

[ABC404 A - Not Found](https://atcoder.jp/contests/abc404/tasks/abc404_a) ｜ [提出結果](https://atcoder.jp/contests/abc404/submissions/66164410)

```python:解答例：answer_6-7-5.py
S = input()
for i in range(26):
    if chr(i+ord("a")) not in S:
        print(chr(i+ord("a")))
        break
```

[ABC257 A - A to Z String 2](https://atcoder.jp/contests/abc257/tasks/abc257_a) ｜ [提出結果](https://atcoder.jp/contests/abc257/submissions/45494572) ｜ [提出結果](https://atcoder.jp/contests/abc257/submissions/45494576)

```python:解答例：answer_6-7-6.py
N, X = map(int, input().split())
print(chr(ord("A")+(X-1)//N))
```

```python:解答例：answer_6-7-7.py
N, X = map(int, input().split())
string = ""
for i in range(26):
    for j in range(N):
        string += chr(ord("A")+i)
print(string[X-1])
```

# 第7章 関数定義

第7章では関数定義について説明します。

## 7.1 関数定義

<b>キーポイント</b>

* 関数は`def`で定義する。
* `def`文で関数名と引数名を指定する。
* 返り値（戻り値）は`return`文で指定する。
* `return`文を指定しない場合、`None`が返る。

関数は`def`で定義する。`def`文で関数名と引数名を指定する。返り値（戻り値）は`return`文で指定する。

```python:サンプルコード：sample_7-1-1.py
def add(a, b):
    return a+b


print(add(1, 2))
```

```text:実行結果
3
```

[ABC234 A - Weird Function](https://atcoder.jp/contests/abc234/tasks/abc234_a) ｜ [提出結果](https://atcoder.jp/contests/abc234/submissions/45494584)

```python:解答例：answer_7-1-1.py
def f(x):
    return x**2+2*x+3


t = int(input())
print(f(f(f(t)+t)+f(f(t))))
```

`return`文を指定しない場合、`None`が返る。

```python:サンプルコード：sample_7-1-2.py
def add(a, b):
    print(a+b)


print(add(1, 2))
```

```text:実行結果
3
None
```

```python:サンプルコード：sample_7-1-3.py
def add(a, b):
    print(a+b)


add(1, 2)
```

```text:実行結果
3
```

## 7.2 再帰関数

再帰関数は下記のように記述することできる。

```python:サンプルコード：sample_7-2-1.py
def factorial(N):
    if N == 0:
        return 1
    else:
        return N*factorial(N-1)


print(factorial(4))
```

```text:実行結果
24
```

```python:サンプルコード：sample_7-2-2.py
def fibonacci(N):
    if N == 0:
        return 0
    elif N == 1:
        return 1
    else:
        return fibonacci(N-1)+fibonacci(N-2)


print(fibonacci(10))
```

```text:実行結果
55
```

[ABC273 A - A Recursive Function](https://atcoder.jp/contests/abc273/tasks/abc273_a) ｜ [提出結果](https://atcoder.jp/contests/abc273/submissions/57270551)

```python:解答例：answer_7-2-1.py
def f(x):
    if x == 0:
        return 1
    else:
        return x*f(x-1)


N = int(input())
print(f(N))
```

<!--

# HTML：非表示
# Markdown：表示

# 未掲載
[ABC108 A - Pair](https://atcoder.jp/contests/abc108/tasks/abc108_a)
[ABC159 A - The Number of Even Pairs](https://atcoder.jp/contests/abc159/tasks/abc159_a)

# 欠番
ABC316

-->

# 付録

付録では Python の学習を深める情報について説明します。

## オブジェクトの型を確認する

オブジェクトの型を確認する場合、`type`関数を使用する。

```python:サンプルコード：appendix_1-1.py
x = 10
print(x)
print(type(x))
```

```text:実行結果
10
<class 'int'>
```

```python:サンプルコード：appendix_1-2.py
x = 20.5
print(x)
print(type(x))
```

```text:実行結果
20.5
<class 'float'>
```

```python:サンプルコード：appendix_1-3.py
x = "Hello world!"
print(x)
print(type(x))
```

```text:実行結果
Hello world!
<class 'str'>
```

```python:サンプルコード：appendix_1-4.py
x = [1, 2, 3, 4, 5]
print(x)
print(type(x))
```

```text:実行結果
[1, 2, 3, 4, 5]
<class 'list'>
```

```python:サンプルコード：appendix_1-5.py
x = (1, 2, 3, 4, 5)
print(x)
print(type(x))
```

```text:実行結果
(1, 2, 3, 4, 5)
<class 'tuple'>
```

```python:サンプルコード：appendix_1-6.py
x = {1, 2, 3, 4, 5}
print(x)
print(type(x))
```

```text:実行結果
{1, 2, 3, 4, 5}
<class 'set'>
```

```python:サンプルコード：appendix_1-7.py
x = {"one": 1, "two": 2, "three": 3}
print(x)
print(type(x))
```

```text:実行結果
{'one': 1, 'two': 2, 'three': 3}
<class 'dict'>
```

## エラーの例

エラーの例を紹介します。

* 全角スペースがある

```python:サンプルコード：appendix_2-1.py
print(　)  # 全角スペースを出力している
```

```text:実行結果
    print(　)  # 全角スペースを出力している
          ^
SyntaxError: invalid non-printable character U+3000
```

* 括弧を閉じていない

```python:サンプルコード：appendix_2-2.py
print(
```

```text:実行結果
    print(
         ^
SyntaxError: '(' was never closed
```

* ダブルクォーテーション（またはシングルクォーテーション）を閉じていない

```python:サンプルコード：appendix_2-3.py
x = "a
```

```text:実行結果
    x = "a
        ^
SyntaxError: unterminated string literal (detected at line X)
```

* コロンがない

```python:サンプルコード：appendix_2-4.py
if True
    print()
```

```text:実行結果
    if True
           ^
SyntaxError: expected ':'
```

* インデントを間違える

```python:サンプルコード：appendix_2-5.py
print()
 print()
```

```text:実行結果
    print()
IndentationError: unexpected indent
```

* スペルを間違える

```python:サンプルコード：appendix_2-6.py
pirnt()
```

```text:実行結果
    pirnt()
    ^^^^^
NameError: name 'pirnt' is not defined. Did you mean: 'print'?
```

* ゼロで割る

```python:サンプルコード：appendix_2-7.py
print(1/0)
```

```text:実行結果
    print(1/0)
          ~^~
ZeroDivisionError: division by zero
```

* ゼロで余りを求める

```python:サンプルコード：appendix_2-8.py
print(1 % 0)
```

```text:実行結果
    print(1 % 0)
          ~~^~~
ZeroDivisionError: integer modulo by zero
```

* 範囲外を参照する

```python:サンプルコード：appendix_2-9.py
x = ["a"]
print(x[1])
```

```text:実行結果
    print(x[1])
          ~^^^
IndexError: list index out of range
```

```python:サンプルコード：appendix_2-10.py
x = "a"
print(x[1])
```

```text:実行結果
    print(x[1])
          ~^^^
IndexError: string index out of range
```

```python:サンプルコード：appendix_2-11.py
x = ["a"]
print(x.pop(1))
```

```text:実行結果
    print(x.pop(1))
          ^^^^^^^^
IndexError: pop index out of range
```

* 存在しない要素を探索する

```python:サンプルコード：appendix_2-12.py
x = ["a"]
print(x.index("b"))
```

```text:実行結果
    print(x.index("b"))
          ^^^^^^^^^^^^
ValueError: 'b' is not in list
```

* 存在しない文字列を探索する

```python:サンプルコード：appendix_2-13.py
x = "a"
print(x.index("b"))
```

```text:実行結果
    print(x.index("b"))
          ^^^^^^^^^^^^
ValueError: substring not found
```

* 辞書に登録されていないキーを参照する

```python:サンプルコード：appendix_2-13.py
x = {"a": 0}
print(x["b"])
```

```text:実行結果
    print(x["b"])
          ~^^^^^
KeyError: 'b'
```

* 空のオブジェクトから要素を取り出す

```python:サンプルコード：appendix_2-14.py
x = []
print(x.pop())
```

```text:実行結果
    print(x.pop())
          ^^^^^^^
IndexError: pop from empty list
```

```python:サンプルコード：appendix_2-15.py
x = set()
print(x.pop())
```

```text:実行結果
    print(x.pop())
          ^^^^^^^
KeyError: 'pop from an empty set'
```