ChatGPT×AtCoderでプログラミング言語の習得を爆速化する方法

# 0. はじめに
　本記事は2つ目以降のプログラミング言語を爆速で習得したい人に向けて書いたものです。ChatGPTに専門用語を交えて簡潔に上手く質問するためにも最低でも1つの言語を知っていることが望ましいからです。
　ChatGPTだけではなくAtCoderも活用することで習得を爆速化できると筆者は考えています。なぜならAtCoderには次のような特徴があるからです。

1. 環境構築不要
1. ジャッジシステム
1. 他人の提出したコード

　ジャッジシステムとは、提出したコードを自動採点してくれるシステムのことです。これによって正しくアウトプットできているか確認できます。
　当然のことではありますが、ChatGPTは正確な回答をしてくれるとは限りません。他人の提出したコードを読むことでこの問題を解決できます。また、コードを読むことで学びや気づきを得ることができるため習得の爆速化に繋がります。

# 1. AtCoderの問題集
　今回取り扱う問題の一覧です。今後、新たにプログラミング言語を習得する度に、この問題集を活用すると良いでしょう。
　プログラミングの基本的な知識が身につくように問題を選んでいます。特に数学的な考察を必要とする問題や問題文が長いものは排除しました。
|No. |身につく知識 |問題 |
|---|---|---|
|[**1**](#41-abc084a) |数値の計算 |[**ABC084A**](https://atcoder.jp/contests/abc084/tasks/abc084_a) |
|[**2**](#42-abc089a) |数値の計算 |[**ABC089A**](https://atcoder.jp/contests/abc089/tasks/abc089_a) |
|[**3**](#43-abc128a) |数値の計算 |[**ABC128A**](https://atcoder.jp/contests/abc128/tasks/abc128_a) |
|[**4**](#44-abc140a) |数値の計算 |[**ABC140A**](https://atcoder.jp/contests/abc140/tasks/abc140_a) |
|[**5**](#45-abc029a) |文字列の処理 |[**ABC029A**](https://atcoder.jp/contests/abc029/tasks/abc029_a) |
|[**6**](#46-abc068a) |文字列の処理 |[**ABC068A**](https://atcoder.jp/contests/abc068/tasks/abc068_a) |
|[**7**](#47-abc149a) |文字列の処理 |[**ABC149A**](https://atcoder.jp/contests/abc149/tasks/abc149_a) |
|[**8**](#48-abc041a) |配列 |[**ABC041A**](https://atcoder.jp/contests/abc041/tasks/abc041_a) |
|[**9**](#49-abc049a) |配列 |[**ABC049A**](https://atcoder.jp/contests/abc049/tasks/abc049_a) |
|[**10**](#410-abc098a) |配列 |[**ABC098A**](https://atcoder.jp/contests/abc098/tasks/abc098_a) |
|[**11**](#411-abc020a) |if文 |[**ABC020A**](https://atcoder.jp/contests/abc020/tasks/abc020_a) |
|[**12**](#412-abc038a) |if文 |[**ABC038A**](https://atcoder.jp/contests/abc038/tasks/abc038_a) |
|[**13**](#413-abc050a) |if文 |[**ABC050A**](https://atcoder.jp/contests/abc050/tasks/abc050_a) |
|[**14**](#414-abc061a) |if文 |[**ABC061A**](https://atcoder.jp/contests/abc061/tasks/abc061_a) |
|[**15**](#415-abc073b) |for文 |[**ABC073B**](https://atcoder.jp/contests/abc073/tasks/abc073_b) |
|[**16**](#416-abc087b) |for文 |[**ABC087B**](https://atcoder.jp/contests/abc087/tasks/abc087_b) |
|[**17**](#417-abc141b) |for文 |[**ABC141B**](https://atcoder.jp/contests/abc141/tasks/abc141_b) |
|[**18**](#418-abc081b) |while文 |[**ABC081B**](https://atcoder.jp/contests/abc081/tasks/abc081_b) |
|[**19**](#419-abc248b) |while文 |[**ABC248B**](https://atcoder.jp/contests/abc248/tasks/abc248_b) |
|[**20**](#420-abc063b) |Set |[**ABC063B**](https://atcoder.jp/contests/abc063/tasks/abc063_b) |
|[**21**](#421-abc144b) |Set |[**ABC144B**](https://atcoder.jp/contests/abc144/tasks/abc144_b) |
|[**22**](#422-abc164c) |Set |[**ABC164C**](https://atcoder.jp/contests/abc164/tasks/abc164_c) |


# 2. ChatGPTに聞いてみよう！
## 2.1. 最初に何を聞くか？
　AtCoderでは最初に入力が与えられています。そのため入力を受け取る方法を聞くのが最初の質問になるでしょう。言語によっては、入力が複雑なものもありますから最初からその意味を完璧に理解する必要はありません。筆者は三日前にPHPを学び始めたのでPHPの入力について質問してみます。

- 筆者：PHPの入力を教えてください。

```php
PHPで入力を取得する方法はいくつかあります。
一般的な方法は、ユーザーからの入力を受け取ることと、外部ソースからのデータを処理することです。

1. **ユーザーからの入力を受け取る：**
   
   a. **`fgets`関数を使用する方法：** これは標準入力からテキスト行を読み取る基本的な方法です。

   <?php
   echo "何か入力してください: ";
   $input = fgets(STDIN);
   echo "入力された内容: " . $input;
   ?>

   b. **`readline`関数を使用する方法 (PHP 7.1以降)：** より対話的な入力を受け付ける場合に便利です。

   <?php
   $input = readline("何か入力してください: ");
   echo "入力された内容: " . $input;
   ?>

2. **外部ソースからのデータを処理する：**

   a. **コマンドライン引数を受け取る：** PHPスクリプトをコマンドラインから実行すると、コマンドライン引数を受け取ることができます。

   <?php
   if ($argc > 1) {
       $input = $argv[1]; // 最初の引数を取得
       echo "引数として渡された内容: " . $input;
   } else {
       echo "引数が指定されていません。";
   }
   ?>

   b. **HTTP POSTまたはGETリクエストを処理する：** PHPはウェブアプリケーションで一般的に使用され、HTTP POSTまたはGETリクエストからデータを受け取ることができます。

   <?php
   if ($_SERVER['REQUEST_METHOD'] === 'POST') {
       $input = $_POST['input_field']; // POSTリクエストからデータを取得
       echo "POSTリクエストから受け取った内容: " . $input;
   } else {
       echo "POSTリクエストではありません。";
   }

   これらは一般的な入力方法のいくつかです。具体的な要件や状況に応じて、適切な入力方法を選択してください。
```

　ChatGPTによるとfgets(STDIN)やreadline()を使うことで入力を受け取れるようです。また、echoを使うと出力ができることも分かりますね。
　ところで、変数名の先頭に$が付いているようですがこれはPHPの言語仕様なのでしょうか。ふと気になったことは聞いてみましょう。

- 筆者：変数にドルマークが付いているようですがこれは何でしょうか？

```php
ドルマーク（$）は、PHPで変数を宣言および使用するための記号です。
PHPでは、変数は通常、ドルマークを接頭辞として使用して宣言および参照されます。
変数をドルマークで始めることによって、PHPはその名前が変数であることを認識し、変数の値を操作できるようになります。

例えば、以下のコードは変数を宣言して、それに値を代入しています。

$myVariable = 42;

この場合、`$myVariable`という変数が宣言され、整数値42が代入されました。
この変数は後で参照または変更できます。

PHPの変数は、変数名がドルマークで始まり、英数字とアンダースコア（_）の組み合わせで構成される必要があります。
また、PHPは大文字と小文字を区別するので、変数名は大文字と小文字が異なるものとして扱われます。

例えば、次のような変数名は有効です。

$myVariable
$counter
$_user

ドルマークを使用して変数を宣言し、それに値を割り当てることによって、PHPプログラム内でデータを保持し、操作することができます。
```
　ChatGPTによるとPHPでは変数として取り扱うために変数名の先頭に$を付ける必要があるようです。

# 3. AtCoderの問題に挑戦しよう！
　ChatGPTの回答を参考にPHPで[**ABC084**](https://atcoder.jp/contests/abc084/tasks/abc084_a)を解いてみましょう。

　問題文には次のように書かれています。
> 12月30日のM時から次の年になるまでは何時間か、求めてください。

　問題文から12月31日の24時間と12月30日の24 - M時間を足したものが答えだと分かりますね。
　PHPでは、入力を受け取るのにfgets(STDIN)を使い、変数名には$を付けることに注意して、コードを書くと次のようになるでしょう。

```php
<?php
// 入力を受け取る
$m = fgets(STDIN);
// 来年まで何時間あるか計算する
echo 24 + 24 - $m;
?>
```

　コードが完成したので提出してみます。結果はAC(正解)でした！間違っているときは結果にWAやTLEと表示されます。緑色であれば正解で、オレンジ色であれば不正解という認識で問題ありません。
![image.png](https://qiita-image-store.s3.ap-northeast-1.amazonaws.com/0/1923849/7220eb01-290d-b856-c6da-93fc7430bcd9.png)
 　このようにコードを書いていて困ったり分からないことがあったタイミングでChatGPTに聞き、試行錯誤することで[AtCoderの問題集](#1-atcoderの問題集)を解いていくと爆速でプログラミング言語を習得できます。

# 4. 問題集の解答例
　筆者が解いた[AtCoderの問題集](#1-atcoderの問題集)のコードをコメント付きで載せています。各問題に対してPythonとC++、PHP、Haskell、Javaのコードがあります。参考になれば幸いです。

## 4.1. [ABC084A](https://atcoder.jp/contests/abc084/tasks/abc084_a)
- Python
```python
m = input() # 入力を受け取る
m = int(m)  # 文字列を数値に変換する
print(24 + 24 - m) # 出力する
```

- C++
```c++
#include <iostream>
using namespace std;

int main () {
    int m;    // 変数宣言
    cin >> m; // 入力を受け取る
    cout << 24 + 24 - m << endl; // 出力する
}
```

- PHP
```php
<?php
$m = fgets(STDIN); // 入力を受け取る
echo 24 + 24 - $m; // 出力する
?>
```

- Haskell
```haskell
main :: IO()
main = do
    m <- readLn -- 入力を受け取る
    print (24 + 24 - m) -- 出力する
```

- Java
```java
import java.util.*;

public class Main {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        int m = sc.nextInt(); // 入力を受け取る
        System.out.println(24 + 24 - m); // 出力する
    }
}
```


## 4.2. [ABC089A](https://atcoder.jp/contests/abc089/tasks/abc089_a)
- Python
```python
n = input() # 入力を受け取る
n = int(n)  # 文字列を数値に変換する
print(n // 3) # 出力する
```

- C++
```c++
#include <iostream>
using namespace std;

int main () {
    int n;    // 変数宣言
    cin >> n; // 入力を受け取る
    cout << n / 3 << endl; // 出力する
}
```

- PHP
```php
<?php
$n = fgets(STDIN);  // 入力を受け取る
echo floor($n / 3); // floorで小数点以下を切り捨てて出力する
?>
```

- Haskell
```haskell
main :: IO()
main = do
    m <- readLn       -- 入力を受け取る
    print (m `div` 3) -- 出力する
```

- Java
```java
import java.util.*;

public class Main {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        int n = sc.nextInt();      // 入力を受け取る
        System.out.println(n / 3); // 出力する
    }
}
```

## 4.3. [ABC128A](https://atcoder.jp/contests/abc128/tasks/abc128_a)
- Python
```python
a, p = map(int, input().split()) # 入力を受け取る
chips_num = 3 * a + p # 用意可能なリンゴの欠片を数える
print(chips_num // 2) # 出力する
```

- C++
```c++
#include <iostream>
using namespace std;

int main () {
    int a, p;      // 変数宣言
    cin >> a >> p; // 入力を受け取る
    int chips_num = 3 * a + p;     // 用意可能なリンゴの欠片を数える
    cout << chips_num / 2 << endl; // 出力する
}
```

- PHP
```php
<?php
[$a, $p] = explode(' ', fgets(STDIN)); // 入力を受け取る
$chips_num = $a * 3 + $p;   // 用意可能なリンゴの欠片を数える
echo floor($chips_num / 2); // 出力する
?>
```

- Haskell
```haskell
main :: IO()
main = do
    [a, p] <- map read . words <$> getLine -- 入力を受け取る
    let chipsNum = a * 3 + p -- 用意可能なリンゴの欠片を数える
    print (chipsNum `div` 2) -- 出力する
```

- Java
```java
import java.util.*;

public class Main {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        int a = sc.nextInt(); // 入力を受け取る
        int p = sc.nextInt(); // 入力を受け取る
        int chipsNum = 3 * a + p; // 用意可能なリンゴの欠片を数える
        System.out.println(chipsNum / 2); // 出力する
    }
}
```


## 4.4. [ABC140A](https://atcoder.jp/contests/abc140/tasks/abc140_a)
- Python
```python
n = int(input()) # 入力を受け取る
print(n ** 3)    # 出力する
```

- C++
```c++
#include <iostream>
#include <cmath>
using namespace std;

int main () {
    int n;    // 変数宣言
    cin >> n; // 入力を受け取る
    cout << pow(n, 3) << endl; // 出力する
}
```

- PHP
```php
<?php
$n = fgets(STDIN); // 入力を受け取る
echo $n ** 3;      // 出力する
?>
```

- Haskell
```haskell
main :: IO()
main = do
    n <- readLn   -- 入力を受け取る
    print (n ^ 3) -- 出力する
```

- Java
```java
import java.util.*;

public class Main {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        int n = sc.nextInt(); // 入力を受け取る
        System.out.println((int)Math.pow(n, 3)); // 出力する
    }
}
```


## 4.5. [ABC029A](https://atcoder.jp/contests/abc029/tasks/abc029_a)
- Python
```python
print(input() + 's') # 入出力する
```

- C++
```c++
#include <iostream>
using namespace std;

int main () {
    string w; // 変数宣言
    cin >> w; // 入力を受け取る
    cout << w + "s" << endl; // 出力する
}
```

- PHP
```php
<?php
$w = trim(fgets(STDIN)); // 入力を受け取る(trimで改行を取り除く)
echo $w . "s\n"; // 出力する
?>
```

- Haskell
```haskell
main :: IO()
main = do
    w <- getLine -- 入力を受け取る
    putStrLn (w ++ "s") -- 出力する
```

- Java
```java
import java.util.*;

public class Main {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        String s = sc.next(); // 入力を受け取る
        System.out.println(s + 's'); // 出力する
    }
}
```


## 4.6. [ABC068A](https://atcoder.jp/contests/abc068/tasks/abc068_a)
- Python
```python
n = input()      # 入力を受け取る
print("ABC" + n) # 出力する
```

- C++
```c++
#include <iostream>
using namespace std;

int main () {
    string n; // 変数宣言
    cin >> n; // 入力を受け取る
    cout << "ABC" + n << endl; // 出力する
}
```

- PHP
```php
<?php
$n = fgets(STDIN); // 入力を受け取る
echo 'ABC' . $n;   // 出力する
?>
```

- Haskell
```haskell
main :: IO()
main = do
    n <- getLine -- 入力を受け取る
    putStrLn ("ABC" ++ n) -- 出力する
```

- Java
```java
import java.util.*;

public class Main {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        String n = sc.next(); // 入力を受け取る
        System.out.println("ABC" + n); // 出力する
    }
}
```


## 4.7. [ABC149A](https://atcoder.jp/contests/abc149/tasks/abc149_a)
- Python
```python
s, t = input().split() # 入力を分割して受け取る
print(t + s) # 出力する
```

- C++
```c++
#include <iostream>
using namespace std;

int main () {
    string s, t;   // 変数宣言
    cin >> s >> t; // 入力を受け取る
    cout << t + s << endl; // 出力する
}
```

- PHP
```php
<?php
[$s, $t] = explode(' ', trim(fgets(STDIN))); // 入力を受け取る
echo $t . $s; // 出力する
?>
```

- Haskell
```haskell
main :: IO()
main = do
    inputStr <- getLine -- 入力を受け取る
    let stList = words inputStr -- 分割する
    putStrLn (stList!!1 ++ stList!!0) -- 出力する
```

- Java
```java
import java.util.*;

public class Main {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        String s = sc.next();      // 入力を受け取る
        String t = sc.next();      // 入力を受け取る
        System.out.println(t + s); // 出力する
    }
}
```


## 4.8. [ABC041A](https://atcoder.jp/contests/abc041/tasks/abc041_a)
- Python
```python
s = input()      # 入力を受け取る
i = int(input()) # 入力を受け取る
print(s[i - 1])  # 出力する
```

- C++
```c++
#include <iostream>
using namespace std;

int main () {
    string s; // 変数宣言
    int i;    // 変数宣言
    cin >> s >> i; // 入力を受け取る
    cout << s[i - 1] << endl; // 出力する
}
```

- PHP
```php
<?php
$s = fgets(STDIN); // 入力を受け取る
$i = fgets(STDIN); // 入力を受け取る
echo $s[$i - 1];   // 出力する
?>
```

- Haskell
```haskell
main :: IO()
main = do
    s <- getLine -- 入力を受け取る
    i <- readLn  -- 入力を受け取る
    putStrLn ([s!!(i - 1)]) -- 出力する
```

- Java
```java
import java.util.*;

public class Main {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        String s = sc.next(); // 入力を受け取る
        int i = sc.nextInt(); // 入力を受け取る
        System.out.println(s.charAt(i - 1)); // 出力する
    }
}
```


## 4.9. [ABC049A](https://atcoder.jp/contests/abc049/tasks/abc049_a)
- Python
```python
c = input()      # 入力を受け取る
if c in "aiueo": # cが母音であるか？
    print("vowel")
else:
    print("consonant")
```

- C++
```c++
#include <iostream>
#include <vector>
using namespace std;

int main () {
    char c;   // 変数宣言
    cin >> c; // 入力を受け取る
    vector<char>vowel_char = {'a', 'i', 'u', 'e', 'o'}; // 配列を用意する
    bool is_exist = false; // 存在するか判定するための変数
    for (auto &str : vowel_char) {
        if(str == c) {
            is_exist = true; // 存在したとき
        }
    }
    if (is_exist) {
        cout << "vowel" << endl;
    } else {
        cout << "consonant" << endl;
    }
}
```

- PHP
```php
<?php
$c = fgets(STDIN); // 入力を受け取る
$result = preg_match("/[aiueo]/", $c); // 正規表現
if ($result) {
    echo 'vowel';
} else {
    echo 'consonant';
}
?>
```

- Haskell
```haskell
main :: IO()
main = do
    inputStr <- getLine   -- 入力を受け取る
    let c = head inputStr -- 先頭1文字を取得する
    let isVowel = any(== c) "aiueo" -- 母音が存在するか？
    if isVowel
    then putStrLn "vowel"
    else putStrLn "consonant"
```

- Java
```java
import java.util.*;

public class Main {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        char c = sc.next().charAt(0); // 入力を受け取る
        boolean isExist = false;      // 存在するか判定するための変数
        if (c == 'a' || c == 'i' || c == 'u' || c == 'e' || c == 'o') {
            isExist = true; // 存在したとき
        }
        System.out.println(isExist ? "vowel" : "consonant"); // 出力する
    }
}
```


## 4.10. [ABC098A](https://atcoder.jp/contests/abc098/tasks/abc098_a)
- Python
```python
a, b = map(int, input().split()) # 入力を受け取る
print(max(a + b, a - b, a * b)); # 出力する
```

- C++
```c++
#include <iostream>
#include <algorithm>
using namespace std;

int main () {
    int a, b;      // 変数宣言
    cin >> a >> b; // 入力を受け取る
    cout << max({a + b, a - b, a * b}) << endl; // 出力する
}
```

- PHP
```php
<?php
[$a, $b] = explode(' ', trim(fgets(STDIN))); // 入力を受け取る
echo max([$a + $b, $a - $b, $a * $b]); // 出力する
?>
```

- Haskell
```haskell
main :: IO()
main = do
    [a, b] <- map read . words <$> getLine -- 入力を受け取る
    print (maximum [a + b, a - b, a * b])  -- 出力する
```

- Java
```java
import java.util.*;

public class Main {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        int a = sc.nextInt(); // 入力を受け取る
        int b = sc.nextInt(); // 入力を受け取る
        int[] array = {a + b, a - b, a * b};
        Arrays.sort(array); // 昇順にソートする
        System.out.println(array[2]); // 出力する
    }
}
```


## 4.11. [ABC020A](https://atcoder.jp/contests/abc020/tasks/abc020_a)
- Python
```python
q = int(input()) # 入力を受け取る
result = ""
if q == 1:
    result = "ABC"
elif q == 2:
    result = "chokudai"
print(result); # 出力する
```

- C++
```c++
#include <iostream>
using namespace std;

int main () {
    int q;    // 変数宣言
    cin >> q; // 入力を受け取る
    string result = "";
    if (q == 1) {
        result = "ABC";
    } else if (q == 2) {
        result = "chokudai";
    }
    cout << result << endl; // 出力する
}
```

- PHP
```php
<?php
$q = trim(fgets(STDIN)); // 入力を受け取る
$result = '';
if ($q === '1') {
    $result = 'ABC';
} else if ($q === '2') {
    $result = 'chokudai';
}
echo $result . "\n"; // 出力する
?>
```

- Haskell
```haskell
main :: IO()
main = do
    q <- readLn -- 入力を受け取る
    putStrLn (getAns q)  -- 出力する

getAns :: Int -> String
getAns quizCode = if quizCode == 1
                  then "ABC"
                  else if quizCode == 2
                       then "chokudai"
                       else ""
```

- Java
```java
import java.util.*;

public class Main {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        int q = sc.nextInt(); // 入力を受け取る
        String result = "";
        if (q == 1) {
            result += "ABC";
        } else if (q == 2) {
            result += "chokudai";
        }
        System.out.println(result); // 出力する
    }
}
```


## 4.12. [ABC038A](https://atcoder.jp/contests/abc038/tasks/abc038_a)
- Python
```python
s = input() # 入力を受け取る
result = ""
if s[-1] == "T": # sの末尾はs[-1]で指定可能
    result = "YES"
else:
    result = "NO"
print(result); # 出力する
```

- C++
```c++
#include <iostream>
using namespace std;

int main () {
    string s; // 変数宣言
    cin >> s; // 入力を受け取る
    int index = s.length() - 1; // 末尾のインデックスを求める
    string result = "";
    if (s[index] == 'T') {
        result = "YES";
    } else {
        result = "NO";
    }
    cout << result << endl; // 出力する
}
```

- PHP
```php
<?php
$s = trim(fgets(STDIN)); // 入力を受け取る
$index = strlen($n) - 1; // 末尾のインデックスを求める
$result = '';
if ($s[$index] === 'T') {
    $result = 'YES';
} else {
    $result = 'NO';
}
echo $result; // 出力する
?>
```

- Haskell
```haskell
main :: IO()
main = do
    s <- getLine -- 入力を受け取る
    let c = s!!(length s - 1) -- 末尾の文字を取得する
    putStrLn (getAns c)  -- 出力する

getAns :: Char -> String
getAns tailChar = if tailChar == 'T'
                  then "YES"
                  else "NO"
```

- Java
```java
import java.util.*;

public class Main {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        String s = sc.next();       // 入力を受け取る
        int index = s.length() - 1; // 末尾のインデックスを求める
        String result = "";
        if (s.charAt(index) == 'T') {
            result += "YES";
        } else {
            result += "NO";
        }
        System.out.println(result); // 出力する
    }
}
```


## 4.13. [ABC050A](https://atcoder.jp/contests/abc050/tasks/abc050_a)
- Python
```python
a, op, b = input().split() # 入力を受け取る
a, b = int(a), int(b) # 文字列を数値に変換する
result = a - b
if op == "+":
    result = a + b
print(result); # 出力する
```

- C++
```c++
#include <iostream>
using namespace std;

int main () {
    int a, b; // 変数宣言
    char op;  // 変数宣言
    cin >> a >> op >> b; // 入力を受け取る
    int result = a - b;
    if (op == '+') {
        result = a + b;
    }
    cout << result << endl; // 出力する
}
```

- PHP
```php
<?php
[$a, $op, $b] = explode(' ', trim(fgets(STDIN))); // 入力を受け取る
$result = $a - $b;
if ($op === '+') {
    $result = $a + $b;
}
echo $result; // 出力する
?>
```

- Haskell
```haskell
main :: IO()
main = do
    inputStr <- getLine -- 入力を受け取る
    let aopbList = words inputStr -- 分割する
    print (getAns aopbList) -- 出力する

getAns :: [String] -> Int
getAns aList = if aList!!1 == "+"
               then a + b
               else a - b
    where a = read (aList!!0) -- 一時的な変数
          b = read (aList!!2) -- 一時的な変数
```

- Java
```java
import java.util.*;

public class Main {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        int a = sc.nextInt();  // 入力を受け取る
        String op = sc.next(); // 入力を受け取る
        int b = sc.nextInt();  // 入力を受け取る
        int result = a - b;
        if (op.equals("+")) {
            result = a + b;
        }
        System.out.println(result); // 出力する
    }
}
```


## 4.14. [ABC061A](https://atcoder.jp/contests/abc061/tasks/abc061_a)
- Python
```python
a, b, c = map(int, input().split())   # 入力を受け取る
print("Yes" if a <= c <= b else "No") # 出力する
```

- C++
```c++
#include <iostream>
using namespace std;

int main () {
    int a, b, c; // 変数宣言
    cin >> a >> b >> c; // 入力を受け取る
    string result = "";
    if (a <= c && c <= b) {
        result = "Yes";
    } else {
        result = "No";
    }
    cout << result << endl; // 出力する
}
```

- PHP
```php
<?php
[$a, $b, $c] = explode(' ', trim(fgets(STDIN))); // 入力を受け取る
$result = '';
if ($a <= $c and $c <= $b) {
    $result = 'Yes';
} else {
    $result = 'No';
}
echo $result; // 出力する
?>
```

- Haskell
```haskell
main :: IO()
main = do
    [a, b, c] <- map read . words <$> getLine -- 入力を受け取る
    putStrLn (getAns a b c) -- 出力する

getAns :: Int -> Int -> Int -> String
getAns a b c = if a <= c && c <= b
               then "Yes"
               else "No"
```

- Java
```java
import java.util.*;

public class Main {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        int a = sc.nextInt(); // 入力を受け取る
        int b = sc.nextInt(); // 入力を受け取る
        int c = sc.nextInt(); // 入力を受け取る
        System.out.println(a <= c && c <= b ? "Yes" : "No"); // 出力する
    }
}
```


## 4.15. [ABC073B](https://atcoder.jp/contests/abc073/tasks/abc073_b)
- Python
```python
n = int(input()) # 入力を受け取る
table = [False for _ in range(100001)] # 座席の状況を配列を用いて記録する
for i in range(n):
    l, r = map(int, input().split()) # 入力を受け取る
    for j in range(l, r + 1):
        table[j] = True # 座っている席を記録する
print(sum(table)) # 出力する
```

- C++
```c++
#include <iostream>
using namespace std;

int main () {
    int n;    // 変数宣言
    cin >> n; // 入力を受け取る
    int people_num = 0; // 座っている人数
    for (int i = 0; i < n; i++) {
        int l, r;      // 変数宣言
        cin >> l >> r; // 入力を受け取る
        people_num += r - l + 1; // 座っている人数を数える
    }
    cout << people_num << endl;  // 出力する
}
```

- PHP
```php
<?php
$n = fgets(STDIN); // 入力を受け取る
$people_num = 0;   // 座っている人数
for ($i = 0; $i < $n; $i++) {
    [$l, $r] = explode(' ', trim(fgets(STDIN))); // 入力を受け取る
    $people_num += $r - $l + 1; // 座っている人数を数える
}
echo $people_num; // 出力する
?>
```

- Haskell
```haskell
import Control.Monad (replicateM)

main :: IO()
main = do
    n <- readLn -- 入力を受け取る
    inputList <- replicateM n getLine -- 入力を受け取る
    let lrLists = map parseToIntList inputList -- 各文字列を数値のリストに変換
    let peopleCounts = getPeopleLists lrLists -- 各リストの人数を数える
    let totalPeople = sum peopleCounts
    print totalPeople -- 出力する

-- 文字列を数値のリストに変換
parseToIntList :: String -> [Int]
parseToIntList input = map read (words input)

-- 人数を数える
getPeopleLists :: [[Int]] -> [Int]
getPeopleLists aLists = map (\[x, y] -> y - x + 1) aLists
```

- Java
```java
import java.util.*;

public class Main {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        int n = sc.nextInt(); // 入力を受け取る
        int peopleNum = 0;    // 座っている人数
        for (int i = 0; i < n; i++) {
            int l = sc.nextInt();   // 入力を受け取る
            int r = sc.nextInt();   // 入力を受け取る
            peopleNum += r - l + 1; // 座っている人数を数える
        }
        System.out.println(peopleNum); // 出力する
    }
}
```


## 4.16. [ABC087B](https://atcoder.jp/contests/abc087/tasks/abc087_b)
- Python
```python
a = int(input()) # 入力を受け取る
b = int(input()) # 入力を受け取る
c = int(input()) # 入力を受け取る
x = int(input()) # 入力を受け取る
total_coin = 0;  # 条件を満たす組み合わせの総数
for i in range(a + 1):
    for j in range(b + 1):
        for k in range(c + 1):
            if 500 * i + 100 * j + 50 * k == x:
                total_coin += 1
print(total_coin) # 出力する
```

- C++
```c++
#include <iostream>
using namespace std;

int main () {
    int a, b, c, x;          // 変数宣言
    cin >> a >> b >> c >> x; // 入力を受け取る
    int total_coin = 0;      // 条件を満たす組み合わせの総数
    for (int i = 0; i <= a; i++) {
        for (int j = 0; j <= b; j++) {
            for (int k = 0; k <= c; k++) {
                if (500 * i + 100 * j + 50 * k == x) {
                    total_coin++;
                }
            }
        }
    }
    cout << total_coin << endl; // 出力する
}
```

- PHP
```php
<?php
$a = fgets(STDIN); // 入力を受け取る
$b = fgets(STDIN); // 入力を受け取る
$c = fgets(STDIN); // 入力を受け取る
$x = fgets(STDIN); // 入力を受け取る
$total_coin = 0;   // 条件を満たす組み合わせの総数
for ($i = 0; $i <= $a; $i++) {
    for ($j = 0; $j <= $b; $j++) {
        for ($k = 0; $k <= $c; $k++) {
            if(500 * $i + 100 * $j + 50 * $k === intval($x)) {
                $total_coin++;
            }
        }
    }
}
echo $total_coin; // 出力する
?>
```

- Haskell
```haskell
main :: IO()
main = do
    a <- readLn -- 入力を受け取る
    b <- readLn -- 入力を受け取る
    c <- readLn -- 入力を受け取る
    x <- readLn -- 入力を受け取る
    let combinationsList = tripleLoop [0 .. a] [0 .. b] [0 .. c]    -- 考えられる組み合わせを用意する
    let resultList = filter (isValidCombination x) combinationsList -- 金額の条件を満たすか計算する
    let totalCoin = length resultList -- 条件を満たす組み合わせを数える
    print totalCoin -- 出力する

-- 3重for文のような処理を実現
tripleLoop :: [Int] -> [Int] -> [Int] -> [(Int, Int, Int)]
tripleLoop xs ys zs = [(x, y, z) | x <- xs, y <- ys, z <- zs]

-- 金額の条件を満たすか判定する
isValidCombination :: Int -> (Int, Int, Int) -> Bool
isValidCombination target (x, y, z) = 500 * x + 100 * y + 50 * z == target
```

- Java
```java
import java.util.*;

public class Main {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        int a = sc.nextInt(); // 入力を受け取る
        int b = sc.nextInt(); // 入力を受け取る
        int c = sc.nextInt(); // 入力を受け取る
        int x = sc.nextInt(); // 入力を受け取る
        int totalCoin = 0;    // 条件を満たす組み合わせの総数
        for (int i = 0; i <= a; i++) {
            for (int j = 0; j <= b; j++) {
                for (int k = 0; k <= c; k++) {
                    if (500 * i + 100 * j + 50 * k == x) {
                        totalCoin++;
                    }
                }
            }
        }
        System.out.println(totalCoin); // 出力する
    }
}
```


## 4.17. [ABC141B](https://atcoder.jp/contests/abc141/tasks/abc141_b)
- Python
```python
s = input() # 入力を受け取る
n = len(s)  # 文字列の長さを取得する
result = "Yes"
for i in range(n):
    if i % 2 == 0:
        if s[i] in "RUD": # R, U, Dのいずれかであるか
            pass; # 何もしない
        else:
            result = "No"
            break; # for文の処理を終了する
    else:
        if s[i] in "LUD": # L, U, Dのいずれかであるか
            pass; # 何もしない
        else:
            result = "No"
            break; # for文の処理を終了する
print(result) # 出力する
```

- C++
```c++
#include <iostream>
using namespace std;

int main () {
    string s; // 変数宣言
    cin >> s; // 入力を受け取る
    int n = s.length(); // 文字列の長さを取得する
    string result = "Yes";
    for (int i = 0; i < n; i++) {
        if (i % 2 == 0) {
            if (s[i] == 'R' || s[i] == 'U' || s[i] == 'D') {
                ; // 何もしない
            } else {
                result = "No";
                break; // for文の処理を終了する
            }
        } else {
            if (s[i] == 'L' || s[i] == 'U' || s[i] == 'D') {
                ; // 何もしない
            } else {
                result = "No";
                break; // for文の処理を終了する
            }
        }
    }
    cout << result << endl; // 出力する
}
```

- PHP
```php
<?php
$s = trim(fgets(STDIN)); // 入力を受け取る
$n = strlen($s); // 文字列の長さを取得する
$result = 'Yes';
for ($i = 0; $i < $n; $i++) {
    if ($i % 2 == 0) {
        if ($s[$i] === 'R' || $s[$i] === 'U' || $s[$i] === 'D') {
            ; // 何もしない
        } else {
            $result = 'No';
            break; // for文の処理を終了する
        }
    } else {
        if ($s[$i] === 'L' || $s[$i] === 'U' || $s[$i] === 'D') {
            ; // 何もしない
        } else {
            $result = 'No';
            break; // for文の処理を終了する
        }
    }
}
echo $result; // 出力する
?>
```

- Haskell
```haskell
main :: IO()
main = do
    s <- getLine -- 入力を受け取る
    let resultList = all (\(i, c) -> isContainChar i c) (zip [0..] s) -- 特定の文字があるか
    let result = getAns resultList -- 与えられた文字列が条件を満たしていたか
    putStrLn result -- 出力する

-- 特定の文字があるか
isContainChar :: Int -> Char -> Bool
isContainChar i c
    | even i && c `elem` "RUD" = True
    | odd i && c `elem` "LUD" = True
    | otherwise = False

-- 与えられた文字列が条件を満たしていたか
getAns :: Bool -> String
getAns True = "Yes"
getAns False = "No"
```

- Java
```java
import java.util.*;

public class Main {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        String s = sc.next(); // 入力を受け取る
        int n = s.length();   // 文字列の長さを取得する
        String result = "Yes";
        for (int i = 0; i < n; i++) {
            if (i % 2 == 0) {
                if (s.charAt(i) == 'R' || s.charAt(i) == 'U' || s.charAt(i) == 'D') {
                    ; // 何もしない
                } else {
                    result = "No";
                    break; // for文の処理を終了する
                }
            } else {
                if (s.charAt(i) == 'L' || s.charAt(i) == 'U' || s.charAt(i) == 'D') {
                    ; // 何もしない
                } else {
                    result = "No";
                    break; // for文の処理を終了する
                }
            }
        }
        System.out.println(result); // 出力する
    }
}
```


## 4.18. [ABC081B](https://atcoder.jp/contests/abc081/tasks/abc081_b)
- Python
```python
n = int(input()) # 入力を受け取る
a = list(map(int, input().split())) # 入力を受け取る

# 関数を用意する(mapを活用することでコードをより簡潔にするため)
# 引数が2で何回割れるか返す関数
def count_div_by2(num):
    cnt = 0
    # 2で割り切れなくなるまで繰り返す
    while True:
        if num % 2 == 0:
            cnt += 1
            num //= 2
        else:
            break
    return cnt

result = min(map(count_div_by2, a)) # 関数を適用する
print(result) # 出力する
```

- C++
```c++
#include <iostream>
#include <vector>
using namespace std;

int main () {
    int n;    // 変数宣言
    cin >> n; // 入力を受け取る
    vector<int> a(n);
    for (int i = 0; i < n; i++) {
        cin >> a[i]; // 入力を受け取る
    }
    int cnt = 0; // 全体が2で割り切れる回数を数える
    while (true) {
        bool is_not_div = false;
        for (auto &num : a) {
            if (num % 2 == 0) {
                num /= 2;
            } else {
                is_not_div = true; // 割り切れないものがあったとき
                break;
            }
        }
        // 割り切れないときは終了
        if (is_not_div) {
            break;
        }
        cnt++;
    }
    cout << cnt << endl; // 出力する
}
```

- PHP
```php
<?php
$n = trim(fgets(STDIN)); // 入力を受け取る
$a = explode(' ', trim(fgets(STDIN))); // 入力を受け取る
$cnt = 0; // 全体が2で割り切れる回数を数える
while (true) {
    $is_not_div = false;
    for ($i = 0; $i < $n; $i++) {
        if ($a[$i] % 2 == 0) {
            $a[$i] /= 2;
        } else {
            $is_not_div = true; // 割り切れないものがあったとき
            break;
        }
    }
    // 割り切れないときは終了
    if ($is_not_div) {
        break;
    }
    $cnt++;
}
echo $cnt; // 出力する
?>
```

- Haskell
```haskell
import Control.Monad

main :: IO ()
main = do
    n <- readLn :: IO Int -- 入力を受け取る(使わない)
    inputStr <- getLine   -- 入力を受け取る
    let aList = map read (words inputStr) -- スペースで区切られた整数をリストに変換する
    let resultList = map (countDivBy2 0) aList
    print (minimum resultList) -- 出力する

-- 何回2で割り切れるか
countDivBy2 :: Int -> Int -> Int
countDivBy2 i n = if even n
              then countDivBy2 (i + 1) (n `div` 2)
              else i
```

- Java
```java
import java.util.*;

public class Main {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        int n = sc.nextInt(); // 入力を受け取る
        int[] a = new int[n];
        for (int i = 0; i < n; i++) {
            a[i] = sc.nextInt(); // 入力を受け取る
        }
        int cnt = 0; // 全体が2で割り切れる回数を数える
        while (true) {
            boolean isNotDiv = false;
            for (int i = 0; i < n; i++) {
                if (a[i] % 2 == 0) {
                    a[i] /= 2;
                } else {
                    isNotDiv = true; // 割り切れないものがあったとき
                    break;
                }
            }
            // 割り切れないときは終了
            if (isNotDiv) {
                break;
            }
            cnt++;
        }
        System.out.println(cnt); // 出力する
    }
}
```


## 4.19. [ABC248B](https://atcoder.jp/contests/abc248/tasks/abc248_b)
- Python
```python
a, b, k = map(int, input().split()) # 入力を受け取る
cnt_shout = 0 # 叫んだ回数
cnt_slime = a # スライムの個体数
while cnt_slime < b:
    cnt_shout += 1 # 叫ぶ
    cnt_slime *= k # スライムがk倍に増殖
print(cnt_shout)   # 出力する
```

- C++
```c++
#include <iostream>
using namespace std;

int main () {
    int a, b, k;        // 変数宣言
    cin >> a >> b >> k; // 入力を受け取る
    long cnt_shout = 0; // 叫んだ回数
    long cnt_slime = a; // スライムの個体数
    while (cnt_slime < b) {
        cnt_shout++;    // 叫ぶ
        cnt_slime *= k; // スライムがk倍に増殖
    }
    cout << cnt_shout << endl; // 出力する
}
```

- PHP
```php
<?php
[$a, $b, $k] = explode(' ', trim(fgets(STDIN))); // 入力を受け取る
$cnt_shout = 0;  // 叫んだ回数
$cnt_slime = $a; // スライムの個体数
while ($cnt_slime < $b) {
    $cnt_shout++;     // 叫ぶ
    $cnt_slime *= $k; // スライムがk倍に増殖
}
echo $cnt_shout; // 出力する
?>
```

- Haskell
```haskell
main :: IO ()
main = do
    [a, b, k] <- map read . words <$> getLine -- 入力を受け取る
    print (getAns a b k 0) -- 出力する

getAns :: Int -> Int -> Int -> Int -> Int
getAns a b k cntShout = if a < b
                        then getAns (a * k) b k (cntShout + 1) -- 叫ぶ
                        else cntShout -- 叫んだ回数を返す
```

- Java
```java
import java.util.*;

public class Main {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        long a = sc.nextLong(); // 入力を受け取る
        long b = sc.nextLong(); // 入力を受け取る
        long k = sc.nextLong(); // 入力を受け取る
        long cntShout = 0L;     // 叫んだ回数
        long cntSlime = a;      // スライムの個体数
        while (cntSlime < b) {
            cntShout++;    // 叫ぶ
            cntSlime *= k; // スライムがk倍に増殖
        }
        System.out.println(cntShout); // 出力する
    }
}
```


## 4.20. [ABC063B](https://atcoder.jp/contests/abc063/tasks/abc063_b)
- Python
```python
s = input() # 入力を受け取る
n = len(s)  # 文字列の長さを取得する
result = "yes"
# setのサイズが入力された文字数より少なければ重複がある
if len(set(s)) != n:
    result = "no"
print(result) # 出力する
```

- C++
```c++
#include <iostream>
#include <set>
using namespace std;

int main () {
    set<char> char_set; // set
    string s; // 変数宣言
    cin >> s; // 入力を受け取る
    int n = s.length();
    for (char c : s) {
        char_set.insert(c); // 要素を追加する
    }
    string result = "yes";
    // setのサイズが入力された文字数より少なければ重複がある
    if (char_set.size() != n) {
        result = "no";
    }
    cout << result << endl; // 出力する
}
```

- PHP
```php
<?php
$s = trim(fgets(STDIN)); // 入力を受け取る
$n = strlen($s); // 文字列の長さを取得する
$datas = array_count_values(str_split($s)); // 各文字の出現回数
$result = 'yes';
foreach ($datas as $key => $value) {
    if ($value !== 1) {
        $result = 'no';
        break; // 同じ文字があったときは終了
    }
}
echo $result; // 出力する
?>
```

- Haskell
```haskell
import Data.List

main :: IO ()
main = do
    s <- getLine -- 入力を受け取る
    putStrLn (getAllCharsUnique s) -- 出力する

-- 文字列の種類がすべて異なるか
getAllCharsUnique :: String -> String
getAllCharsUnique str = if length str == length (nub str)
                        then "yes"
                        else "no"
```

- Java
```java
import java.util.*;

public class Main {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        char[] s = sc.next().toCharArray(); // 入力を受け取る
        int n = s.length; // 文字列の長さを取得する
        String result = "yes";
        Set<Character> charSet = new HashSet<Character>(); // set
        for (char c : s) {
            charSet.add(c); // 要素を追加する
        }
        // setのサイズが入力された文字数より少なければ重複がある
        if (charSet.size() != n) {
            result = "no";
        }
        System.out.println(result); // 出力する
    }
}
```


## 4.21. [ABC144B](https://atcoder.jp/contests/abc144/tasks/abc144_b)
- Python
```python
n = int(input()) # 入力を受け取る
num_set = set()  # set
for x in range(1, 10):
    for y in range(1, 10):
        num_set.add(x * y) # 要素を追加する
print("Yes" if n in num_set else "No") # 出力する
```

- C++
```c++
#include <iostream>
#include <set>
using namespace std;

int main () {
    set<int> num_set; // set
    int n;    // 変数宣言
    cin >> n; // 入力を受け取る
    for (int x = 1; x < 10; x++) {
        for (int y = 1; y < 10; y++) {
            num_set.insert(x * y); // 要素を追加する
        }
    }
    string result = "";
    // setにnがあるか
    if (num_set.find(n) != num_set.end()) {
        result = "Yes";
    } else {
        result = "No";
    }
    cout << result << endl; // 出力する
}
```

- PHP
```php
<?php
$n = trim(fgets(STDIN)); // 入力を受け取る
$result = 'No';
// 全探索
for ($x = 1; $x < 10; $x++) {
    for ($y = 1; $y < 10; $y++) {
        if ($x * $y === intval($n)) {
            $result = 'Yes';
        }
    }
}
echo $result; // 出力する
?>
```

- Haskell
```haskell
main :: IO ()
main = do
    n <- readLn -- 入力を受け取る
    let nineNineTable = [x * y | x <- [1 .. 9], y <- [1 .. 9]] -- 九九の表を用意する
    let result = if n `elem` nineNineTable
                 then "Yes"
                 else "No"
    putStrLn result -- 出力する

```

- Java
```java
import java.util.*;

public class Main {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        int n = sc.nextInt(); // 入力を受け取る
        Set<Integer> numSet = new HashSet<Integer>(); // set
        for (int x = 1; x < 10; x++) {
            for (int y = 1; y < 10; y++) {
                numSet.add(x * y); // 要素を追加する
            }
        }
        String result = "No";
        // setにnがあるか
        if (numSet.contains(n)) {
            result = "Yes";
        }
        System.out.println(result); // 出力する
    }
}
```


## 4.22. [ABC164C](https://atcoder.jp/contests/abc164/tasks/abc164_c)
- Python
```python
n = int(input()) # 入力を受け取る
s = set(input() for _ in range(n)) # 入力を受け取る
print(len(s)) # 出力する
```

- C++
```c++
#include <iostream>
#include <set>
using namespace std;

int main () {
    set<string> str_set; // set
    int n;    // 変数宣言
    cin >> n; // 入力を受け取る
    for (int i = 0; i < n; i++) {
        string s; // 変数宣言
        cin >> s; // 入力を受け取る
        str_set.insert(s); // 要素を追加する
    }
    cout << str_set.size() << endl; // 出力する
}
```

- PHP
```php
<?php
$n = trim(fgets(STDIN)); // 入力を受け取る
$lines = [];
while ($line = fgets(STDIN)) {
    $lines[] = trim($line); // 入力を受け取る
}
$datas = array_count_values($lines);
echo count($datas); // 出力する
?>
```

- Haskell
```haskell
import qualified Data.Set as Set
import Control.Monad (replicateM)

main :: IO ()
main = do
    n <- readLn -- 入力を受け取る
    inputStr <- replicateM n getLine      -- 入力を受け取る
    let uniqueSet = Set.fromList inputStr -- 文字列のリストをセットに変換して重複を取り除く
    let result = Set.size uniqueSet       -- セットの要素数を数える
    print result -- 出力する
```

- Java
```java
import java.util.*;

public class Main {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        int n = sc.nextInt(); // 入力を受け取る
        Set<String> strSet = new HashSet<String>(); // set
        for (int i = 0; i < n; i++) {
            strSet.add(sc.next()); // 入力を受け取り、その要素を追加する
        }
        System.out.println(strSet.size()); // 出力する
    }
}
```


# 5. さいごに
　お疲れ様でした！プログラミングの基礎が身についたら、次はその言語について書かれた技術書を読んで更なるステップアップを目指しましょう！
　最後にChatGPTに感謝の気持ちを伝えて締めくくりたいと思います。

- 筆者：ありがとうございます！！
```
どういたしまして！お役に立ててうれしいです。
もし他に質問があれば、どんどん聞いてください。
お力になれることを願っています！
```