#format gfm

# プログラミング講習基本的な文法の簡易版
この文章はこれまでのプログラミング講習の基本的な文法の内容を縮小してまとめたものです。

# はじめに
1. プログラムの書き方
2. irbについて

この文書を読み始める前に、必ず自分のPCにRubyとお好きなテキストエディタ(ここではAtomを使って説明しています)をインストールしてください。


インストールの仕方は https://wiki.mma.club.uec.ac.jp/benevolent0505/2016ProgrammingSeminar1 の`環境構築`の項を見てください。


また、この文章で作成する作業用のフォルダ(ディレクトリ)も作成してください。ここではWindowsの場合は`C:\develop`を,MacやUnix系OSでは`~/develop`を作業用のフォルダにすることを推奨しています。


この文章でのコマンドやプログラムの表記を説明しておきます。
まず、コマンドを表記するときは次のように書きます。


**ターミナル**
```
$ ruby hello.rb
Hello, world!
```

ここで言っているターミナルとはMac での「ターミナル」だったり、 Windows での「コマンドプロンプト」や「PowerShell」のようなコマンドを入力する画面のことを 指します。このあたりの説明は別の資料に譲るとして、ここではコマンドを入力できるものと思ってください。

先頭に`$`の記号が書かれている場合はターミナル上で実行するコマンドです。`$`の記号はコマンドを入力する時には関係がありません。間違えて入力しないようにしましょう。`$`の記号がない部分は、そのプログラムやコマンドの出力の部分であることを意味します。この部分も、間違えて入力しないようにしましょう。


次にプログラムについて以下のように表記します。

**hello.rb**
```ruby
puts 'Hello, world!'
```

プログラムの前に`ファイル名`を書いて、その下の背景が違う色になっているものがプログラム部分になります。


## プログラムの書き方
この節ではどういうことを行っていって、プログラムを書いて動かすのかを説明します。


始めにプログラムの書き方について説明をします。Rubyにおけるプログラムはただのテキストファイルです。コンピュータにおいてのファイルについて詳しく知りたい人は[ここ](http://e-words.jp/w/%E3%83%95%E3%82%A1%E3%82%A4%E3%83%AB.html)を読んでみるとよいですが、今は詳しく知る必要はありません。イメージが出来ていない人は、テキストエディタで何かを書いて保存したものと思ってください。


ではファイルの作り方を説明します。ターミナルを開いて、自分が作った作業用ディレクトリに移動しましょう。
移動したら`atom hello.rb`と打ち込みます。

**ターミナル**
```
$ atom hello.rb
```

少し時間がかかるかもしれませんが`Atom`が起動します。この状態で既に`hello.rb`というファイルを編集している状態です。ではここに次のプログラムを書いて、ファイルを保存しましょう。


**hello.rb**
```ruby
puts "Hello, world!"
```

保存の仕方は、Atomのウィンドウの上部にあるメニューバーから、`File`->`Save`とすると編集した内容が保存されます。これでRubyのプログラムのファイルが完成しました。ちなみにこのプログラムは、`'Hello, world!'`という文字を表示するプログラムです。

次にこのプログラムのファイルの、動かし方について説明をします。ターミナルに戻って次のコマンドを打ち込んでみましょう。

**ターミナル**
```
$ ruby hello.rb
Hello, world!
```

`Hello, world!`という文字が表示されたと思います。ここでは`ruby`というコマンドに`hello.rb`というファイルを渡しています。「コマンドに何かを渡す」という言い回しは「何かがコマンドの引数である」という意味ですが、コマンド操作やプログラミングの時にはよく出てくる表現ですので慣れてください。

さて、`ruby`コマンドについて説明します。`ruby`コマンドは渡されたRubyのプログラムファイルを読み込んで、そのプログラムの処理を実行するコマンドです。今`hello.rb`には`Hello, world!`という文字を表示する処理が書かれているので、この処理が実行されて`Hello, world!`が表示されています。

ちなみに`hello.rb`のファイルの`.rb`とはRubyのプログラムであることを表わす[拡張子](http://e-words.jp/w/%E6%8B%A1%E5%BC%B5%E5%AD%90.html)です。

これまでの流れが、プログラムを書いて動かすまでの流れになります。一般的にプログラミングをすると言うときはこの流れのことを指すことが多いと思います。


## irbについて
前のプログラムの書き方で手一杯だという人はこの節は読み飛ばしてかまいません。次の章に書いてある内容はこの節を読まなくても取り組める内容になっています。

ここでは`irb`というコマンドについて説明をします。まずは自分のターミナル上で`irb`と打ってみましょう。

**ターミナル**
```
$ irb
irb(main):001:0>
```

REPL(Read Eval Print Loop)


# プログラムを書こう
この章では様々なプログラムを書きながら、Rubyの基本的な文法を知ることが目標です。

この章のプログラムを写したり自分で書いたプログラムを書いて実行をすると、書き間違いなどによるプログラムのミスのために、エラーの表示が出ることがあります。そのときはエラーの原因はしっかりとエラー文に書かれているので、エラー文を読むようにしましょう。詳しくは[Rubyの基本的な文法](https://wiki.mma.club.uec.ac.jp/benevolent0505/ProgrammingSeminar2016/basic-grammar)の`エラーについて`の項を見てください。


## 文字を表示する (`hello.rb`)
まずは文字を表示するプログラムから始めていきましょう。プログラムの書き方でも例にした、`hello.rb`のプログラムを見てください。

**hello.rb**
```ruby
puts "Hello, world!"
```

これは`Hello, world!`という文字を表示するプログラムです。Rubyで文字を表示するには`puts`というメソッドを使います。Rubyではプログラムに対する命令をメソッドと言います。

`puts`の使い方はメソッドの後にスペースをはさんで、表示したい文字列をダブルクウォーテーションマーク`""`で囲みます。hello.rbで表示する文字は`Hello, world!`なので、`"Hello, world!"`と囲んであります。


では`puts`を使う練習をしてみましょう。プログラムの書き方でやったように、Atomを開いて`use_puts.rb`を作ってみましょう。


**ターミナル**
```
$ atom use_puts.rb
```

**use_puts.rb**
```ruby
puts "Hello, world!"
puts "Hello, Ruby"
puts "What's your name?"
```

プログラムが作成できたら実行してみてください。

**ターミナル**
```
$ ruby use_puts.rb
Hello, world!
Hello, Ruby
What's your name?
```

このように`puts`は文字を表示することができます。`puts`はよく使うメソッドなので使い慣れておきましょう。


## プログラムに計算をさせてみる (`calc.rb`)
さて、文字を表示させるプログラムを作ることを覚えましたが、これだけではあまり面白くありません。コンピュータは計算機とも呼ぶので、四則演算をするプログラム、`calc.rb`を作ってみましょう。

まずはRubyで四則演算をする方法を説明します。ひとまず次のプログラムを書いて動かしてみましょう。

**calc.rb**
```ruby
1 + 1
puts 5 + 3
puts 5 - 3
puts 5 * 3
puts 5 / 3
```

上から`足し算`、`引き算`、`かけ算`、`割り算`の順です。大体のプログラミング言語ではかけ算や割り算は`×`や`÷`の記号の代わりに`*`と`/`を使います。

**ターミナル**
```
$ ruby calc.rb
8
2
15
1
```

まず`puts`は文字だけでなく数値も表示します。一番最初に書いてある`1 + 1`が表示されていないのは、計算自体はされていますが、計算した結果を表示するように書いていないからです。このように`puts`は何か計算した結果を表示するのにも使います。


さて、大体の計算結果は思った通りの結果だっと思いますが、一つだけ違うものがあります。最後の余りの計算を見てみましょう。覚えのある計算結果は`5 / 3 = 1 ・・・ 2`だと思います。Rubyだけではなく、一般的なプログラミング言語では割り算の結果は商だけを求めて余りは求めません。

余りを求めるには記号を使う必要があります。余りを求めるには`%`の記号を使います。`%`を使った計算を`calc.rb`に追記して、実行してみましょう。

**calc.rb**
```ruby
puts 5 + 3
puts 5 - 3
puts 5 * 3
puts 5 / 3
puts 5 % 3
```

**ターミナル**
```
$ ruby calc.rb
8
2
15
1
2
```

追記した`puts 5 % 3`の分、`2`の表示が増えていますね。

Rubyではこのようにして数値の計算をします。この`+`や`-`の記号のことを`演算子(式)`と呼びます。

今回の`calc.rb`は四則演算をするだけですが、この先の節でもっと色々なことができるようにプログラムを改良します。その際もここでやって計算のことは出てくるので覚えておくようにしましょう。


## 変数を使って`hello.rb`と`calc.rb`を良くする
さて、`変数`というものを使ってこれまで書いてきた`hello.rb`と`calc.rb`を改善していきましょう。

まずこれまでのプログラムでは何を改善する必要があるのかを説明します。次のプログラムを見てみましょう。このプログラムは名前を表示して、2つの挨拶を表示するプログラムです。

**greeting.rb**
```ruby
puts "benevolent0505"
puts "Hello, " + "benevolent0505"
puts "Goodbye, " +  "benevolent0505"
```

**ターミナル**
```
$ ruby greeting.rb
benevolent0505
Hello, benevolent0505
Goodbye, benevolent0505
```

Rubyでは`+`の演算子は足し算の計算以外にも文字をつなぐためにも使えます。この`+`の使い方もRubyではよく使うので慣れておきましょう。

さて、このプログラムの名前の部分を変更したくなったとしましょう。そうなると名前の部分を全て変更するのは少し面倒です。このプログラムだけだと3箇所の変更だけですが、もっと多くの箇所を変更しないといけないときはやる気が起きなくなります。

`変数`を使うとこの面倒を解消できます。変数とは`benevolent0505`や`1`などの値に名前を付けたものです。変数の作り方は下の様に`変数名 = 値`というように書きます。これを「変数名に値を代入する」と言います。例えば`name = "benevolent0505"`とすると`name`が`"benevolent0505"`の代わりになります。

では変数を使って`greeting.rb`を改良してみましょう。

**greeting.rb**
```ruby
name = "benevolent0505"
puts name
puts "Hello, " + name
puts "Goodbye, " + name
```

**ターミナル**
```
$ ruby greeting.rb
benevolent0505
Hello, benevolent0505
Goodbye, benevolent0505
```

このように、変数に値を入れることができます。

さて、変数を使う練習をしてみましょう。まずは`hello.rb`を変数を使って改良してみましょう。今まで`puts`で直接表示していた文字を変数に代入して、それを表示させてみましょう。

**hello.rb**
```ruby
message = "Hello, world!"
puts message
```

次に`calc.rb`を変数を使って改良をしてみましょう。今までは数値を直接計算させていましたが、その数値を変数に代入して計算をさせてみましょう。

**calc.rb**
```ruby
x = 5
y = 3

puts x + y
puts x - y
puts x * y
puts x / y
puts x % y
```

このように変数を使うことでプログラムを変更に強くできます。変数はプログラミングでは必ず必要になることなので、覚えるようにしましょう。

## getsメソッドを使って入力を受け取る
今までは`puts`で表示したり`+`演算子で計算をさせる値はプログラムに既に記述されたものだけでした。実際のプログラムではユーザからの`入力`を受け取って表示をさせたり、計算をしたりします。ここではユーザからの入力を受け取る方法の一つの`gets`というメソッドを使った方法を説明します。

`gets`メソッドはプログラム外からの入力を一行受け取るメソッドです。早速`gets`を使ったプログラムを書いてみましょう。

**use_gets.rb**
```ruby
name = gets
puts "Your name is " + name
```

**ターミナル**
```
$ ruby use_gets.rb
benevolent0505
Your name is benevolent0505
```

これは入力された文字を`Your name is `という文字とともに表示するプログラムです。`gets`で受け取った文字を変数`name`に代入しています。

実行例にある`benevolent0505`の文字がユーザ(ここでは僕が)入力した文字です。`gets`は一行を読み込んで受け取るメソッドなので、入力の終わりを示すために`Return(Enter)キー`を押して改行をする必要があります。また、ここで打ち込む文字を`MMA`にすると、次の行には`Your name is MMA`と表示されます。他にも色々な文字を打ち込んで試してみましょう。

ちなみにこのプログラムだと、実行した直後にいきなり文字を入力しなくてはいけないので少し不便です。文字を入力させる前には、`Please input your name.`など、何か表示をして、名前を入力をしてほしいことを明示しておくと親切です。

**use_gets.rb**
```ruby
puts "Please input your name."
name = gets
puts "Your name is " + name
```

では`gets`を使って`hello.rb`を改良してみましょう。ここでは改良の例を一つ提示しておきます。`gets`を使うことで表示できるメッセージを自由に入力できるようにしました。(オウム返ししてるだけとも言う)

**hello.rb**
```ruby
puts "Please input hello message."
message = gets
puts message
```

次に`calc.rb`を`gets`を使って改良してみましょう。けれどいきなり`calc.rb`に手を加える前に、次のプログラムを見てください。

**add.rb**
```ruby
puts "Please input x value."
x = gets
puts "Please input y value."
y = gets

answer = x + y

puts "x + y = " + answer
```

**ターミナル**
```
Please input x value.
9
Please input y value.
1
x + y = 9
1
```

`9`と`1`はユーザが入力した値です。さて、思ったような結果と違っていたと思います。この結果になる理由を説明するのに、まず`gets`が入力に対してどんな値を受け取るのかを知る必要があります。

`gets`は一行読み込んで、読み込んだ文字を`文字列`にして受け取ります。今まで`文字列`という言葉を使ってきませんでしたが、言葉通り「`""`の記号で囲まれた文字の列」のことです。ただ、`"a"`や`"1"`などの一文字のものも文字列と呼ぶので注意しましょう。

`gets`の入力に`Hello, world!`と打ち込んであげると、`gets`は`"Hello, world!\n"`という文字列を受け取ります。最後にある`\n`は`改行文字`といい、文字列中の改行を表す特殊な文字です。改行文字の動作を確認するために、次のプログラムを見てみましょう。このように改行文字のところで文字列が改行されて表示されていることがわかります。

**newline.rb**
```ruby
puts "Hello\nworld!"
```

**ターミナル**
```
$ ruby newline.rb
Hello
world
```

`gets`で読み込んだ文字列の最後に改行文字が入る理由は、一行の終わりを示すために`Enter(Return)キー`を入力しました。この`Enter(Return)キー`によって改行文字が入力されたのです。

今度は`gets`の入力に数字を与えてみましょう。`9`を打ち込んだときは`gets`は`"9\n"`という文字列を、`1`を打ち込んだときは`"1\n"`を受け取ります。この改行文字を取り除くのに、`chomp`というメソッドが使えます。`chomp`は文字列の最後の改行文字を取り除いたものを返してくれるメソッドです。`chomp`は次のプログラムのようにして使います。

**use_chomp.rb**
```ruby
message = "Hello\n".chomp
puts message
```

**ターミナル**
```
$ ruby use_chomp.rb
Hello
```

`"Hello\n".chomp`という書き方は初めて出てきましたが、`chomp`は文字列に対して動作をするメソッドなのでこのように書きます。また、`gets`と一緒に使う時は`gets.chomp`という形で使うと、文字列を受け取ってすぐに改行文字を削除できるので便利です。

さて、`gets`を使って`add.rb`を正しく動作するようにしてみましょう。

**add.rb**
```ruby
puts "Please input x value."
x = gets.chomp
puts "Please input y value."
y = gets.chomp

answer = x + y

puts "x + y = " + answer
```

**ターミナル**
```
$ ruby add.rb
Please input x value.
9
Please input y value.
1
x + y = 91
```

改行はなくなりましたが、また思っていた結果とは違ったと思います。前の節で、`+`の演算子を文字列で使うと文字列をつなげることが出来ると説明しました。`gets`が受け取るものは全て文字列なので、`9`や`1`は文字列です。なので`"9" + "1"`は文字列同士をつなげることになるので`"91"`という結果になります。

`gets`で受け取った数字(文字列)を使って計算をするには、受け取った数字を数値に変換する必要があります。数字を数値に変換するためには、`to_i`というメソッドを使います。次のプログラムを見てみましょう。`to_i`も文字列に対して動作するメソッドなので、`x.to_i`のように書きます。

**convert_to_number_value.rb**
```ruby
x = "10"
puts x
puts x.to_i
```

**ターミナル**
```
$ ruby convert_to_number_value.rb
10
10
```

表示の上では違いがわかりませんが、上の10は数字(文字列)の10を表示していて、下の10は数値を表示しています。

これで`add.rb`を正しく動作させることができます。

**add.rb**
```ruby
puts "Please input x value."
x = gets.chomp.to_i
puts "Please input y value."
y = gets.chomp.to_i

answer = x + y

puts "x + y = " + answer
```

**ターミナル**
```
$ ruby add.rb
Please input x value.
9
Please input y value.
1
x + y = 10
```

`x = gets.chomp.to_i`の部分で混乱するかもしれませんが、意味としては`gets`で入力`9`を受け取って得た`"9\n"`を、`chomp`で一番後ろの文字を取り除いて`"9"`にしたものを、`to_i`を使って`9`にして、それを変数`x`に代入しているといった感じです。一つづつ考えていけば、今まで見てきたものの組み合わせなので理解できると思います。

さて、本来の目的である`calc.rb`を改良しましょう。

**calc.rb**
```ruby
puts "Please input x value."
x = gets.chomp.to_i
puts "Please input y value."
y = gets.chomp.to_i

puts x + y
puts x - y
puts x * y
puts x / y
puts x % y
```

**ターミナル**
```
$ ruby calc.rb
Please input x value.
9
Please input y value.
1
10
8
9
9
0
```

このようにして`gets`を使ってユーザからの入力を受け取ることができます。その受け取った値を扱う際には、改行文字や値は文字列であることなどの注意をするべき点があるので、気を付けるようにしましょう。

## ifを使って成績表示プログラムを作る (`grade.rb`)
この節では条件に応じて行う処理を変える方法を学び、簡単な成績表示プログラムを作ります。

これまでの学んだことでも、割と色々なプログラムが書けますが、プログラムを一番始めから最後の行までの全てを実行することしか出来ません。実際のプログラムでは例えば数値を比較した結果や、入力された文字によって処理を変えたりといったことをします。

この条件に応じて処理を変えるには`if`というものを使います。次のプログラムを見てみましょう。これは`a`, `b`2つの変数に格納された数値を比較して、`a < b`だったらメッセージを表示するプログラムです。

**comp_two_number.rb**
```ruby
a = 3
b = 5

puts "a = " + a.to_s + ", b = " + b.to_s
if a < b
  puts "b is bigger than a."
end
```

**ターミナル**
```
$ ruby comp_two_number.rb
b is bigger than a.
```
`a`と`b`の後に`to_s`というメソッドがありますが、これは数値を文字列に変換するメソッドです。`+`演算子は文字列と数値をつなげることが出来ないので、数値を文字列に変換してから結合しています。

`if`の書き方は`if`の後にスペースを一つ空けて条件となる処理を書き、その条件が成り立っている時に実行してほしい処理を`if`の下に書いていき、処理の終わりになったら`end`を書きます。このプログラムでは条件が`a < b`で、これが成り立っているときに実行してほしい処理が`puts "b is bigger than a."`なので、これを書いて終わりに`end`を書きます。今`a = 3`, `b = 5`で、`3 < 5`なのでメッセージが表示されています。では、変数の中身を変更して`a = 5`, `b = 3`にしてみたら、どうなるでしょうか。

**comp_two_number.rb**
```ruby
a = 5
b = 3

puts "a = " + a.to_s + ", b = " + b.to_s
if a < b
  puts "b is bigger than a."
end
```

**ターミナル**
```
$ ruby comp_two_number.rb
```

今度は何も表示されませんでした。`if`は後に続く条件が成り立っているときに`end`までの処理を実行します。今は`a < b`は`5 < 3`なので成り立っていません。そのためメッセージは表示されなかったということになります。

このプログラムでは条件が成り立っているときにしか実行されませんが、「条件が成り立っているときはAの処理を、成り立っていないときにはBの処理を実行したい」ときがあります。このような場合は`else`というキーワードを使って書くことができます。次のプログラムを見てみましょう。

**comp_two_number.rb**
```ruby
a = 5
b = 3

puts "a = " + a.to_s + ", b = " + b.to_s
if a < b
  puts "b is bigger than a."
else
  puts "a is bigger than b."
end
```

**ターミナル**
```
$ ruby comp_two_number.rb
a = 5, b = 3
a is bigger than b.
```

`if`の条件が成り立っているときの処理のあとに`else`というキーワードを書いて、条件が成り立っていないときの処理を記述します。今は`a < b`は`5 < 3`で条件が成り立っていないので`else`の下に書いた処理が実行されます。

`if`の条件が成り立っていないときに、「条件1が成り立っているときはAの処理を、条件2が成り立っているときはBの処理を、それ以外の場合（条件1も2も成り立っていないとき）はCの処理を実行したい」ときもあります。このような場合は`elsif`というキーワードを使って書くことができます。これを使って、`comp_two_number.rb`の`if`の処理をもっと細かくしてみましょう。

**comp_two_number.rb**
```ruby
a = 5
b = 5

puts "a = " + a.to_s + ", b = " + b.to_s
if a < b
  puts "b is bigger than a."
elsif a == b
  puts "a equals b."
else
  puts "a is bigger than b."
end
```

**ターミナル**
```
$ ruby comp_two_number.rb
a = 5, b = 5
a equals b.
```

書き方は`if`の条件が成り立っているときの処理のあとに、`elsif`と書いて新たに条件を書きます。その下に条件が成り立っているときの処理を書いていきます。ここでは`elsif`の条件が`a == b`で、これが成り立っているときの処理が`puts a equals b.`となります。今は`a = 5`, `b = 5`なので、`a < b`は成り立たず`a == b`の条件をみます。`a == b`は成り立っているので、その処理が実行された形になります。`a`や`b`の値を変えてみて、このプログラムの処理がどのように変化するかを試してみましょう。

`<`や`==`の記号を比較演算子といいます。比較演算子には様々な種類があるので覚えるようにしましょう。

| 演算子記号 | 意味 | 使い方 |
|:--:|:-----:|:---------:|
| == | 等しい | a == b |
| != | 等しくない | a != b |
| >  | 大なり | a > b |
| >= | 大なりイコール | a >= b |
| <  | 小なり | a < b |
| <= | 小なりイコール | a <= b |

また比較演算子を用いた条件を組み合わせた処理を作ることもできます。これらの記号は論理演算子といいます。これらも使えるようにしましょう。

| 演算子記号 | 意味 | 使い方 |
|:--------:|:---:|:------:|
| && | かつ(∩)| a < b && x < y |
| &#124;&#124; | または(∪) | a < b &#124;&#124; x < y |
| ! | 否定(¬) | !(a < b) |

さて、これらのことを使って、簡単な成績表示プログラムを作りましょう。このプログラムは名前とテストの点数を入力してもらって、その点数から成績を判定するプログラムになります。

**grade.rb**
```ruby
puts "Please input your name."
name = gets.chomp
puts "Please input your test score."
score = gets.chomp.to_i

puts name + "'s Grade is ..."
if score >= 90
  puts "秀"
elsif score >= 80
  puts "優"
elsif score >= 70
  puts "良"
elsif score >= 60
  puts "可"
else
  puts "不可"
end
```

**ターミナル**
```
$ ruby grade.rb
Please input your name.
benevolent0505
Please input your test score.
70
benevolent0505's Grade is ...
良
```

`if`を使って条件に応じて処理を分けることを`条件分岐`または`条件判断`といいます。条件分岐もプログラムを組む上では必ず必要になってくることなので出来るようにしましょう。

## 配列を使ってデータをまとめる (`grade.rb`)
今までは文字列や数値の値(データ)を単体で扱ってきましたが、これらを一つにまとめる配列というものについて説明します。

`配列`とはいくつかのデータを順に並べたものです。配列の中のデータのことを普通は`(配列の)要素`と呼んだりします。次のプログラムを見てみましょう。

**use_array.rb**
```ruby
numbers = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
colors = ["red", "blue", "green", "orange", "pink", "light blue", "purple"]

puts numbers[0]
puts numbers[4]

puts colors[1]
puts colors[5]
```

**ターミナル**
```
$ ruby use_array.rb
1
5
blue
light blue
```

配列の作り方は`[]`で囲んだものの中に要素をカンマ`,`区切りで書いていきます。配列の要素を取りだすときは`配列名[取り出す要素の位置の数値]`で取り出します。このとき注意しなくてはいけないのは、配列の順番`1`からではなく`0`から数えていきます。なので配列の一番始めの要素を取り出したいときは`配列名[0]`で取り出します。

あとから配列の要素を追加することもできます。`配列[要素を追加したい位置] = 追加したい値`で配列に値を追加することができます。

**add_array_element.rb**
```ruby
arr = []

puts arr
arr[0] = "M"
arr[1] = "M"
arr[2] = "A"

puts arr
```

**ターミナル**
```
$ ruby add_array_element.rb
M
M
A
```

また、配列の要素の数(大きさ)を知りたいときは`size`というメソッドを使います。`size`は配列についてのメソッドなので`配列.size`というように使います。

**array_size.rb**
```ruby
numbers = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
colors = ["red", "blue", "green", "orange", "pink", "light blue", "purple"]

puts "numbers size is"
puts numbers.size

puts "colors size is"
puts colors.size
```

**ターミナル**
```
$ ruby array_size.rb
numbers size is
10
colors size is
7
```

さて、この配列を`grade.rb`を改良してみましょう。今までは1人分の名前と成績しか判定していませんでしたが、 3人の名前と成績を管理するようにしてみましょう。

**grade.rb**
```ruby
names = []
scores = []

puts "Please input 1st person name."
names[0] = gets.chomp
puts "Please input 1st person test score."
scores[0] = gets.chomp.to_i

puts "Please input 2nd person name."
names[1] = gets.chomp
puts "Please input 2nd person test score."
scores[1] = gets.chomp.to_i

puts "Please input 3rd person name."
names[2] = gets.chomp
puts "Please input 3rd person test score."
scores[2] = gets.chomp.to_i

puts names[0] + "'s Grade is ..."
if scores[0] >= 90
  puts "秀"
elsif scores[0] >= 80
  puts "優"
elsif scores[0] >= 70
  puts "良"
elsif scores[0] >= 60
  puts "可"
else
  puts "不可"
end

puts names[1] + "'s Grade is ..."
if scores[1] >= 90
  puts "秀"
elsif scores[1] >= 80
  puts "優"
elsif scores[1] >= 70
  puts "良"
elsif scores[1] >= 60
  puts "可"
else
  puts "不可"
end

puts names[2] + "'s Grade is ..."
if scores[2] >= 90
  puts "秀"
elsif scores[2] >= 80
  puts "優"
elsif scores[2] >= 70
  puts "良"
elsif scores[2] >= 60
  puts "可"
else
  puts "不可"
end
```

**ターミナル**
```
$ ruby grade.rb
Please input 1st person name.
benevolent0505
Please input 1st person test score.
50
Please input 2nd person name.
MMA
Please input 2nd person test score.
100
Please input 3rd person name.
UEC
Please input 3rd person test score.
60
benevolent0505's Grade is ...
不可
MMA's Grade is ...
秀
UEC's Grade is ...
可
```

これで3人分の名前と成績を表示するプログラムができました。このように配列は複数の値を一つにまとめて扱うことができます。配列も実際のプログラムでは当たり前のように使われるものなので、覚えておくようにしましょう。

## whileを使って`grade.rb`を良くする
前の節で、配列を使うことで複数の値をまとめて扱うことができるようになりました。しかし、同じような処理を何度も書いていて読むのも書くのも少し面倒です。同じような処理が何度も続くときに有効な手段の一つとして`while`などを使った繰り返し処理があります。

次のプログラムを見てください。このプログラムは、`Hello`という文字を5回表示するプログラムです。何回目の表示かわかりやすいように、Helloの後ろに回数も表示するようにしています。

**use_while.rb**
```ruby
i = 0

while i < 5
  puts "Hello, " + i.to_s
  i = i + 1
end
```

**ターミナル**
```
$ ruby use_while.rb
Hello, 0
Hello, 1
Hello, 2
Hello, 3
Hello, 4
```

`while`は「条件を指定し、その条件が成り立っている間は処理を繰り返す」といったことをします。`while`の使い方はスペースを空けてその後に繰り返しの条件を書き、その条件が成り立っている間繰り返してほしい処理をその下に書いていき、処理の終わりになったら`end`を書きます。ここでは、繰り返しの条件が`i < 5`、この条件が成り立っている間に繰り返してほしい処理が`puts "Hello, " + i.to_s`、` i = i + 1`になります。

`use_while.rb`のプログラムの実行される流れを追っていきましょう。まず一行目で変数`i`に`0`を代入しています。そして3行目の`while`から繰り返しの記述が始まります。繰り返しの条件である`i < 5`は`i`の値が`0`なので、`0 < 5`という意味になります。この条件は成り立っているため、繰り返しの処理に入ります。

繰り返し処理の中身である4行目で`"Hello, " + i.to_s`と表示し、5行目で変数`i`に`i`に`1`を足した値を代入します。今`i`は`0`なので`0 + 1`を`i`に代入することになり、`i`の値は`1`になります。`i = i + 1`という書き方は今まで見たことがない書き方だと思いますし、もしかしたら数学のイメージが強くて、違和感を感じるかもしれません。馴染みにくい書き方ですが、変数は値に名前を付けただけのものなので、右辺の`i`は`0`を指しているもの、左辺の`i`は新しい値が代入される`i`と考えるといいと思います。

繰り返し処理の中身が終わり`end`のところまで来ると`while`はまた繰り返しの条件をみます。今`i`は`1`なので条件は`1 < 5`という意味になります。この条件は成り立っているので、また繰り返しの処理に入ります。

あとは言葉通り繰り返し処理の中身が繰り返されます。さっきの流れと違う点は`i`の値が次は`2`になることです。

繰り返し処理がどんどん実行されて、`i`の値が`5`になると条件は`5 < 5`となり、条件が成り立たなくなります。そうすると`while`は繰り返し処理の中身を実行せず、プログラムは`while`の後の記述を実行していきます(このプログラムでは`while`の後には何も記述されていないので、このプログラムはここで終わります)。

このように`while`は繰り返しの条件を変数で指定し、その変数の値を繰り返される処理の中身で更新していき、一定の条件になると繰り返し処理が終わるという書き方をします。繰り返し処理は、始めは処理の流れがよくわからず混乱しますが、一行一行処理を追っていき、整理をしていくと分かるようになります。また紙に処理を書き出してみて理解することもいいかもしれません。


さて、`while`を使うことで`grade.rb`のプログラムの見通しがかなりよくなります。`while`を使って書き直したプログラムを見てみましょう。

**grade.rb**
```ruby
names = []
scores = []
i = 0
j = 0

while i < 3
  puts "Please input person " + (i + 1).to_s + " name."
  names[i] = gets.chomp
  puts "Please input person " + (i + 1).to_s + " test score."
  scores[i] = gets.chomp.to_i

  i = i + 1
end

while j < 3
  puts names[j] + "'s Grade is ..."
  if scores[j] >= 90
    puts "秀"
  elsif scores[j] >= 80
    puts "優"
  elsif scores[j] >= 70
    puts "良"
  elsif scores[j] >= 60
    puts "可"
  else
    puts "不可"
  end

  j = j + 1
end
```

**ターミナル**
```
$ ruby grade.rb
Please input person 1 name.
benevolent0505
Please input person 1 test score.
100
Please input person 2 name.
MMA
Please input person 2 test score.
90
Please input person 3 name.
UEC
Please input person 3 test score.
50
benevolent0505's Grade is ...
秀
MMA's Grade is ...
秀
UEC's Grade is ...
不可
```

`while`を使うことで`grade.rb`の見通しがかなり良くなりました。`grade.rb`でも使われているように、繰り返し処理は配列と一緒に用いるととても相性がいいです。実際のプログラムでも繰り返し処理と配列は同時に使われることが多いです。この2つが組み合わさると慣れていない人にとってはプログラムが複雑に見えてしまうかもしれませんが、一つづつ処理を追っていけば理解できるので慣れていくようにしましょう。


## これまで覚えたことで練習問題を幾つか解いてみる
ではここに書いてある内容で練習問題のプログラムを作成していきましょう。

### 3つの数を入力させて、それを足し算した結果を表示するプログラム
まずはどのような動作をするのかを見ていきましょう。

**ターミナル**
```
$ ruby input_three_num.rb
1
2
3
a = 1, b = 2, c = 3
a + b + c = 6
```

このプログラムでは3つの数を受け取って、その数を足し合せた数を表示します。

まずは3つの数の入力を受け取り、それを表示する部分までを作ってみましょう。ユーザからの入力を受け取るの`gets`メソッドを使いました。そして、そこで受け取った値は`変数`というものに代入しました。文字や数値を表示するのに`puts`メソッドを使いました。これらを組み合せて作ってみましょう。

**input_three_num.rb**
```ruby
a = gets.chomp.to_i
b = gets.chomp.to_i
c = gets.chomp.to_i

puts "a = " + a.to_s + ", b = " + b.to_s + ", c = " + c.to_s
```

**ターミナル**
```
$ ruby input_three_num.rb
1
2
3
a = 1, b = 2, c = 3
```

`gets`で取得した文字列の最後には改行文字が含まれているため、それを取り除くために`chomp`メソッドを使いました。また`gets`は文字列を取得するので入力された数字(文字列)を数値に変換する必要があります。それをしてくれるメソッドが`to_i`でした。


では次に取得した値の足し算をしてみましょう。足し算をするには`+`演算子を使いました。
**input_three_num.rb**
```ruby
a = gets.chomp.to_i
b = gets.chomp.to_i
c = gets.chomp.to_i

puts "a = " + a.to_s + ", b = " + b.to_s + ", c = " + c.to_s

ans = a + b + c
puts "a + b + c = " + ans.to_s
```

**ターミナル**
```
$ ruby input_three_num.rb
1
2
3
a = 1, b = 2, c = 3
a + b + c = 6
```

各変数に代入した値を`+`演算子を使って足し合せています。またプログラムの見通しを良くするために、計算した結果を変数に代入しています。最後に`puts`を使って計算結果を表示しています。


### 文字列と整数を入力させて、文字列を指定された整数回繰りかえして表示するプログラム

* 文字列と数値の入力を受け取ろう
* whileの繰り返しを書いてみよう
  * 繰り返しの条件を考えてみよう
  * whileの中の処理を考えてみよう

### 西暦の値が与えられた時、閏年かどうかを判定するプログラム。閏年の条件は次の3つになります。

* 西暦の入力を受け取ろう
* 条件について考えてみよう
* 条件分岐を書いてみよう

# 最後に
これまでのことでプログラムを書く流れをなんとなく理解できたかと思います。もしこれまでの内容でわからないところがあれば質問をしてください。

一通り理解することができたら、[Rubyの基本的な文法](https://wiki.mma.club.uec.ac.jp/benevolent0505/ProgrammingSeminar2016/basic-grammar)の方を読むようにしてください。ここに書いてある内容よりも複雑なことが書いてありますが、ここまで理解できたならわかるはずです。それに基本的な文法以降の内容はRubyの基本的な文法の内容を理解できていることを前提の内容を書くつもりです。先に進む前にこの内容をおさえておくようにしてください。

また練習問題についてですが、ここに書いてある内容だけで全てを解けるようにはしてありますが、[Rubyの基本的な文法](https://wiki.mma.club.uec.ac.jp/benevolent0505/ProgrammingSeminar2016/basic-grammar)の内容を使うと、もっと見通しがよくかけると思います。