【Ruby】今年中にRuby Goldを取得したいので勉強 ~ Part1 ~

どうもこんにちは。

最近、RubyGoldの勉強を全くできていなかったので、時間をとって勉強しました。

↓落ちた時の振り返りはこちら↓

https://qiita.com/PDC-Kurashinak/items/2a4279fae328bbc7937b

今回は、以下の模擬問題を解いてみることにします。（復讐がてらSilverの問題を解きました。）

https://github.com/ruby-association/prep-test/blob/version3/silver_ja.md

# Let's Go!!

## Q1. Rubyにおける真の値として正しいものをすべて選んでください。(2つ選択)

```rb
(a) ""  #=> ○
(b) 0   #=> ○
(c) false
(d) nil   #=> nilは真の値ではない
```

## Q2. Rubyの予約語として正しいものをすべて選んでください。(2つ選択)

```rb
(a) each   #=> ループ文のメソッドとして使用できるので、予約語ではない
(b) rand   #=> ランダムな値を生成するためのメソッドとして使用できるので、予約語ではない
(c) class  #=> ○
(d) send   #=> メソッドを呼び出すためのメソッドとして使用できるので、予約語ではない
(e) true   #=> ○
```

## Q3. Rubyの変数名として正しいものを選んでください。(1つ選択)

これでいう**変数**は、**ローカル変数**と解釈していいんだよね？と思いながら回答。

```rb
(a) 3y        #=> ローカル変数は数字で始められない
(b) false     #=> falseはローカル変数で使用できない（擬似変数という類には存在する by Ruby リファレンス）
(c) _9class   #=> ○
(d) xyz$      #=> ローカル変数に`$`を入れることはできない
```

### 補足Q3

(d)に関しては、原則にはできなくはないですが、エラーが出ます。場合によっては`$`以降がグローバル変数と認識されます。

```irb:例1
irb(main):001> xyz$ = 1
/Users/testuser/.rbenv/versions/3.2.2/lib/ruby/gems/3.2.0/gems/irb-1.13.1/exe/irb:9:in `<top (required)>': (irb):1: `$' without identifiers is not allowed as a global variable name (SyntaxError)
xyz$ = 1
   ^~
(irb):1: Can't assign to nil
xyz$ = 1
   ^~

	from /Users/testuser/.rbenv/versions/3.2.2/bin/irb:25:in `load'
	from /Users/testuser/.rbenv/versions/3.2.2/bin/irb:25:in `<main>'
 ```

 ```irb:例2
irb(main):003> xy$z = 2
(irb):3:in `<main>': undefined method `xy' for main:Object (NoMethodError)

xy$z = 2
^^
	from /Users/testuser/.rbenv/versions/3.2.2/lib/ruby/gems/3.2.0/gems/irb-1.13.1/exe/irb:9:in `<top (required)>'
	from /Users/testuser/.rbenv/versions/3.2.2/bin/irb:25:in `load'
	from /Users/testuser/.rbenv/versions/3.2.2/bin/irb:25:in `<main>'
irb(main):004> $z
=> 2
 ```

## Q4. 以下の実行結果を出力するコードがあります。 __(1)__に入る適切な記述を選択してください。(2つ選択)

```rb
$code = "CODE"
__(1)__

[出力]
i like writing CODE

---

(a) puts "i like writing #{$code}"   #=> ○
(b) puts "i like writing #$code"     #=> ○
(c) puts 'i like writing #{$code}'   #=> シングルクォーテーションでは文字列補間はできない
(d) puts 'i like writing #$code'     #=> シングルクォーテーションでは文字列補間はできない
```

ローカル変数の場合、文字列補間は`"#{変数}"`を使用して行いますが、グローバル変数の場合は、`"#{変数}"`と`"#変数"`を使用して行うことができます。

## Q5. 以下のコードがあります。実行結果として正しいものを選択してください。(1つ選択)

```rb
num = 025
puts num

---

(a) nil   #=> 値は入っているので×
(b) 025   #=> `0`から始まる数値型のデータは入らないので×
(c) 21    #=> ○
(d) 25    #=> Rubyで`0`から始まった数値を入力された場合、8進数と解釈されるため、`25`ではない
```

Rubyでは、`0`から始まった数値は8進数と解釈されます。8進数の25を10進数に直すと21になります。

## Q6. 以下のコードがあります。実行結果として正しいものを選択してください。(1つ選択)

```rb
x = "Hello"
y = x.empty? ? 1 : 2
p y

---

(a) 1        #=> `x.empty?`は`True`にならないので×
(b) 2        #=> ○
(c) "Hello"  #=> ×
(d) true     #=> ×
```

三項演算子の問題ですね。

## Q7. 以下のコードがあります。実行結果として正しいものを選択してください。(1つ選択)

```rb
amount = 120

size = case amount
  when 1..120; "S"
  when 120..170; "M"
  when 170..200; "L"
  else "XL"
end

p size

---

(a) "S"   #=> ○
(b) "M"   #=> `case`文は上から実行されるため、`when 120..170;`まで到達しない
(c) "L"   #=> ×
(d) "XL"  #=> ×
```

`when 1..120;`だったら`"S"`が出力され、`when 1...120;`だったら`"M"`が出力されますね。

## Q8. 以下のコードがあります。実行結果として正しいものを選択してください。(1つ選択)

```ruby
item = "apple"

["banana", "carrot", "daikon"].each do |item|
  puts item
end

puts item

---

(a) 文法エラーが発生する  #=> ×
(b) 例外が発生する       #=> ×
(c) banana             #=> each文の外側で定義された変数と中で定義された変数はスコープが異なる。
    carrot
    daikon
    daikon
(d) banana            #=> ○
    carrot
    daikon
    apple
```

each文の中の`puts item`が`item`変数を探したときに、最初に見つけるのがeach文の中で定義された`item`変数なので、each文の中の`puts item`は`["banana", "carrot", "daikon"]`を順番に出力する。

each文の外側で定義された`item`変数は、更新されていないのでそのまま`apple`が出力される。

## Q9. 以下のコードがあります。実行結果として正しいものを選択してください。(1つ選択)

```ruby
x = 0

4.times do |i|
  x += i
end

p x

---

(a) 0                  #=> 今回は`x`は更新されているので`0`ではない
(b) 4                  #=> `i`は`1`ではない。
(c) 6                  #=> ○
(d) 文法エラーが発生する  #=> ×
```

今回の繰り返し文では、4回ループがされます。

```
一周目: i=0
二周目: i=1
三周目: i=2
四周目: i=3
```

これを足していくと、`0+0+1+2+3=6`になります。

## Q10. 以下のコードがあります。実行結果として正しいものを選択してください。(1つ選択)

```rb
s = "abcde"
p s.each_char.map { |i|
  i * 2
}

---

(a) [97, 98, 99, 100, 101]           #=> `each_char`メソッドは数値は返さない
(b) [194, 196, 198, 200, 202]        #=> `each_char`メソッドは数値は返さない
(c) ["a", "b", "c", "d", "e"]        #=> `i * 2`してなければ正解
(d) ["aa", "bb", "cc", "dd", "ee"]   #=> ○
(e) 実行時にエラーになる                #=> 文字列の四則演算はできます。
```

`each_char`メソッドは、文字列内の各文字に対してブロックを実行するために使用されます。

```rb:簡単な例
"hello".each_char do |char|
  puts char
end

---
# 出力結果
h
e
l
l
o
```

## Q11. 以下のコードがあります。実行結果として正しいものを選択してください。(1つ選択)

```rb
p "cocoa".chars.tally

---

(a) {99=>2, 111=>2, 97=>1}     #=> `chars`メソッドは文字を数値に置き換えるメソッドではない
(b) {?c=>2, ?o=>2, ?a=>1}      #=> ×
(c) {"c"=>2, "o"=>2, "a"=>1}   #=> ○
(d) 実行時にエラーになる          #=> 配列に対して`tally`メソッドを実行しているのでエラーは出ない
```

`chars`メソッドは、文字列を配列に置き換えます。

```irb
irb(main):013> "cocoa".chars
=> ["c", "o", "c", "o", "a"]
```

`tally`メソッドは、配列の要素の数を数えてハッシュ形式で返すメソッドです。（多数決やる感じ。）
なので、(c)が答え。

## Q12. 以下の実行結果を出力するコードがあります。 __(1)__に入る適切な記述を選択してください。(1つ選択)

```rb
puts "blah blah blah".__(1)__(/blah/, "yay")

[出力]
yay yay yay

---

(a) sub           #=> 一致する最初の要素しか変換しないので×
(b) gsub          #=> ○
(c) replace       #=> pythonの`replace`と違い、部分的に置き換えることは不可
(d) replace_all   #=> Rubyに`replace_all`というメソッドはない
```

## Q13. 以下のコードがあります。実行結果として正しいものを選択してください。(1つ選択)

```ruby
s = "pear"

if s.empty?
  puts "blank"
elsif s.length < 5
  puts "short"
else
  puts "long"
end

---

(a) blank        #=> `s`変数には値が入っているので、×
(b) short        #=> ○
(c) long         #=> `elsif s.length < 5`が先に`True`になってしまうので×
(d) 例外が発生する  #=> エラーは出ない
```

## Q14: 以下のコードがあります。実行結果として正しいものを選択してください。(1つ選択)

```rb
["foo: abc", "bar: 100"].each do |i|
  p i.slice(/[0-9]+/)&.to_i
end

---

(a) 0                  #=> `i.slice(/[0-9]+/)`では`nil`が返り、`&`がついているため`to_i`は実行されない。（`&`がついていなかったら`0`が返ります。）
    100
(b) nil                #=> ○
    100
(c) false              #=> `i.slice(/[0-9]+/)&.to_i`では`false`は返らない
    100
(d) 文法エラーが発生する  #=> エラーにはならない
(e) 実行時にエラーになる  #=> エラーにはならない
```

`&`はセーフナビゲータというものです。
`&`以前のコードが`nil`だった場合、以降のコードは実行されません。

## Q15: 以下のコードがあります。実行結果として正しいものを選択してください。(1つ選択)

```rb
def foo(x: 1, y: 2, z: 3)
  p [x, y, z]
end

foo(y: 4, z: 5)

---

(a) [1, 2, 3]          #=> `y`,`z`に値が渡されているので、`2`,`3`が出力されることはない
(b) [1, 4, 5]          #=> ○
(c) 文法エラーが発生する  #=> エラーは発生しない
(d) 実行時にエラーになる  #=> エラーは発生しない
```

## Q16: 以下の実行結果を出力するコードがあります。 __(1)__に入る適切な記述を選択してください。(1つ選択)

```rb
def foo(x:, y:, z:)
  p [x, y, z]
end

h = {x: 1, y: 2, z: 3}
__(1)__
[出力]
[1, 2, 3]

---

(a) foo(*h)   #=> 君は可変長引数
(b) foo(**h)  #=> ○
(c) foo(&h)   #=> 君は`Proc`オブジェクトが使用されるときに使うので×
(d) foo(^h)   #=> ×
```

## Q17. "Ruby"または"ruby"のいずれかの文字列のみにマッチする正規表現をすべて選択してください。(2つ選択)

```rb
(a) /\A[Rr]uby\z/        #=> ○ （先頭は`R`または`r`で、末尾が`uby`にマッチする。）
(b) /\ARuby|ruby\z/      #=> × （先頭が`Ruby`である文字列、または末尾が`ruby`である文字列。`RubyGold`とかもマッチする。）
(c) /\A[Rr][u][b][y]\z/  #=> ○ （先頭は`R`または`r`で、`[u]`,`[b]`,`[y]`はそれぞれ `"u"`,`"b"`,`"y"`にマッチする。）
(d) /\AR|ruby\z/         #=> × （先頭が`R`である文字列、または末尾が`ruby`である文字列。`RubyGold`とかもマッチする。）
```

## Q18.以下のコードがあります。実行結果として正しいものを選択してください。(1つ選択)

```rb
MSG = 42
MSG += 5
p MSG

---

(a) 警告なしで47が表示される。                         #=> 定数の書き換えは警告が表示されるので×
(b) MSGは定数なのでエラーが発生する。                   #=> 定数の書き換えは警告が表示されるので×
(c) MSGは定数なので42が表示される。                    #=> 定数の書き換えは警告が表示されるが書き換えはできるので×
(d) MSGは定数なので警告が表示されるが、47が表示される。    #=> ○
```

## Q19. 以下のコードがあります。実行結果として正しいものを選択してください。(1つ選択)

```rb
MSG = "hello"
MSG.upcase!
p MSG

---

(a) MSGは定数なのでエラーが発生する。                   #=> 定数の書き換えでエラーは発生しないので×
(b) 警告なしでHELLOが表示される。                      #=> ○（定数の「破壊的な書き換え」は警告が発生しない）
(c) MSGは定数なので警告が表示されるが、HELLOが表示される。 #=> 定数の「破壊的な書き換え」は警告が発生しないので×
(d) MSGは定数なのでhelloが表示される。                  #=> ×
```

## Q20. 以下の説明のうち正しいものをすべて選択してください。(2つ選択)

```rb
(a) ローカル変数は小文字ではじまり、2文字以上の長さである。 #=> ×
(b) グローバル変数は$ではじまる。                       #=> ○
(c) インスタンス変数は*ではじまる。                     #=> ×
(d) クラス変数は$ではじまる。                          #=> ×
(e) 定数は大文字ではじまる。                           #=> ○
```

## Q21. 以下のコードがあります。実行結果として正しいものを選択してください。(1つ選択)

```rb
x = [1,2,3,4,5,6,7,8]
y = x
x.reject! { |e| e.even? }
p x
p y

---

(a) [1, 3, 5, 7]              #=> 引っかかりやすいけどこれは×
    [1, 2, 3, 4, 5, 6, 7, 8]

(b) [1, 2, 3, 4, 5, 6, 7, 8]  #=> `reject!`メソッドが意味をなしていない結果なので×
    [1, 2, 3, 4, 5, 6, 7, 8]

(c) [1, 3, 5, 7]              #=> ○
    [1, 3, 5, 7]

(d) [1, 3, 5, 7]              #=> 要素を抽出しているわけではないので×
    [2, 4, 6, 8]
```

`reject`メソッドは、**配列から要素を削除する**メソッドです。
`even?`メソッドは、**要素が偶数か判定する**メソッドです。
つまり、`x.reject! { |e| e.even? }`では、**要素`e`が偶数だった場合、配列`x`から削除する**という動作をしていることがわかると思います。（この時点で選択肢(d)は外れますね。）

また、`reject!`は破壊的メソッドなので、配列`x`は破壊的に変更されます。つまり、配列`x`は`[1, 3, 5, 7]`となります。

:::note info
`reject!`ではなく`reject`であれば、`p x`の結果は`[1, 2, 3, 4, 5, 6, 7, 8]`です。
:::

あとは`y`がどのように変化するかです。
`x`も`y`も同じオブジェクトを参照しているため、`x.reject! { |e| e.even? }`が実行されたときに`y`も同じように変更されます。よって答えは(c)です。

:::note info
`x`とは独立したオブジェクトとして配列を`y`に格納したい場合、`y = x`ではなく`y = x.dup`や`y = x.clone`を使用する必要があります。
:::

## Q22. 以下のコードがあります。実行結果として正しいものを選択してください。(1つ選択)

```rb
a = [ 2, 4, 6, 8, 10 ]
a.shift
a.pop
a.push(12)
p a

---

(a) [2, 4, 6, 8, 10, 12]   #=> ×
(b) [2, 4, 6, 8, 10]       #=> ×
(c) [4, 6, 8, 12]          #=> ○
(d) [4, 6, 8]              #=> ✖️
```

`shift`メソッドは、**配列の最初の要素を削除する**メソッドです。
`pop`メソッドは、**配列の最後の要素を削除する**メソッドです。
`push`メソッドは、**配列の最後に要素を追加する**メソッドです。
`unshift`メソッドは、**配列の最初に要素を追加する**メソッドです。

## Q23. 以下の実行結果を出力するコードがあります。 __(1)__に入る適切な記述を選択してください。(1つ選択)

```rb
x = true
x __(1)__ exit(1)
puts("succeeded!")

[出力]
succeeded!

---

(a) |   #=> 右辺が評価されてしまうため×
(b) ||  #=> ○ （左辺がTrueであれば右辺は評価されない）
(c) &   #=> 右辺が評価されてしまうため×
(d) &&  #=> 左辺がTrueだと右辺が評価されてしまうため×
```

## Q24. 以下のコードがあります。実行結果として正しいものを選択してください。(1つ選択)

```rb
m = true
m or n = true
p n

---

(a) true              #=> ×
(b) false             #=> ×
(c) nil               #=> ○
(d) 文法エラーが発生する  #=> ×
```

`or`は、`||`とほぼ同じ意味です。しかし、`or`は**弱い**ということを覚えておく必要があります。なので、上のコードを無理やり書き換えると以下のようになります。

```rb
m = true
m or ( n = true )
p n
```

こうするとわかりやすいですね。`or`演算子の評価時には`m`がtrueなので右辺は評価されません。
そのため、`n`に`true`は代入されません。しかし、オブジェクトとして`n`は定義されたことになります。

よって、答えは(c)です。

## Q25. 以下の実行結果を出力するコードがあります。 __(1)__に入る適切な記述を選択してください。(2つ選択)

```rb
x = [ 9, 7, 5, 3, 1 ]
p __(1)__

[出力]
[7, 5, 3]

---

(a) x[1, 3]    #=> 配列番号`1`から`3つ`という意味なので○
(b) x[1..-1]   #=> 配列番号`1`から`-1`という意味なので×（配列番号`-1`は`1`のこと。）
(c) x[-3..-1]  #=> 配列番号`-3`から`-1`という意味なので×（配列番号`-3`は`5`のこと。）
(d) x[-4..-2]  #=> 配列番号`-4`から`-2`という意味なので○
```

配列番号はマイナスで表記されていた場合、配列の末尾が「`-1`」です。

```rb:配列の各要素に対応する配列番号（インデックス）の値
 x  [ 9,   7,   5,    3,    1]
 i    0    1    2     3     4
-i   -5   -4   -3    -2    -1
```

## Q26. 以下の実行結果を出力するコードがあります。 __(1)__に入る適切な記述を選択してください。(2つ選択)

```rb
ary = [ 1, 2, 3, 4, 5 ]
p ary.__(1)__ { |i| i.odd? }

[出力]
[1, 3, 5]

---

(a) collect      #=> `odd?`メソッドの判定結果が返ってくるので×
(b) select       #=> ○
(c) map          #=> `odd?`メソッドの判定結果が返ってくるので×
(d) filter       #=> ○
(e) filter_map   #=> `odd?`メソッドの判定結果が返ってくるので×
```

`collect`メソッドと`map`メソッドは、ブロック内の結果を返します。
`filter_map`メソッドは、ブロック内の結果が`true`のものの結果を返します。
`select`メソッドと`filter`メソッドは、ブロック内の結果がtrueのものの要素を返します。

## Q27. 以下のコードがあります。実行結果として正しいものを選択してください。(1つ選択)

```rb
puts "42A7".to_i

---

(a) 42                 #=> ○
(b) 42A7               #=> `A`は10進数ではありえないため×
(c) 17063              #=> `to_i`メソッドで16進数を指定していないため×
(d) 実行時にエラーになる   #=> エラーにはならない
```

`to_i`メソッドはデフォルトで「10進数→10進数」を返します。
16進数や8進数の文字列を10進数の数値に直して、値を返したい場合は`to_i`メソッドの引数にメソッドの前にある要素が何進数なのか指定してあげれば良いです。

```rb
puts "42A7".to_i(16)   # 16進数→10進数 という意味
#=> 17063
```

## Q28. 次のメソッドのうち`:c`がハッシュのキーとして存在するかどうかを「返さない」ものを選択してください。(1つ選択)

```rb
h = {a: 2, b: 4, c: 6, d: 8, e: 10}

---

(a) p h.has_key?(:c)
(b) p h.contain?(:c)   #=> Hashクラスに`contain?`メソッドは存在しないので○
(c) p h.include?(:c)
(d) p h.key?(:c)
(e) p h.member?(:c)
```

`has_key?`,`include?`,`key?`,`member?`はすべて同じ動作をします。

## Q29. "以下の実行結果を出力するコードがあります。 __(1)__に入る適切な記述を選択してください。(2つ選択)

```rb
a = [120, 40, 20, 80, 160, 60, 180]
a.__(1)__
p a

[出力]
[120, 80, 160, 180]

---

(a) reject! {|i| i < 80}      #=> ○
(b) slice {|i| i < 80 }       #=> `slice`メソッドは引数にブロックを取らないため×
(c) slice! {|i| i < 80}       #=> `slice`メソッドは引数にブロックを取らないため×
(d) delete_if! {|i| i < 80}   #=> `delete_if`メソッドは`!`がついていない状態でも破壊的な動作をするメソッドなので`delete_if!`は存在しない。よって×
(e) delete_if {|i| i < 80}    #=> ○
(f) reject {|i| i < 80}       #=> `reject`は配列から条件に合った要素を削除するメソッドだが、非破壊的メソッドなので×
```

## Q30. 以下の実行結果を出力するコードがあります。 __(1)__に入る適切な記述を選択してください。(1つ選択)

```rb
p ["apple", "banana"] __(1)__ ["banana", "carrot"]

[出力]
["apple", "banana", "carrot"]

---

(a) .concat   #=> `concat`メソッドは、配列に配列を破壊的に連結するメソッドなので×
(b) &         #=> `&`を使用した場合、["banana"] が出力されるので×
(c) |         #=> ○
(d) ||        #=> trueが出力されるので×
```

## Q31. 以下のコードがあります。

```rb
p %i(x1 x2 x3)
実行結果として正しいものを選択してください。(1つ選択)

---

(a) "x1 x2 x3"          #=> ×
(b) [1, 2, 3]           #=> ×
(c) ["x1", "x2", "x3"]  #=> ×（`%w`だったらこれ）
(d) [:x1, :x2, :x3]     #=> `%i`は要素がシンボルの配列を作成するため、○
```

## Q32. 以下のコードがあります。実行結果として正しいものを選択してください。(1つ選択)

```rb
class SomeError < StandardError; end
class SomeOtherError < SomeError; end

def meth1
  raise SomeOtherError.new("error")
end

begin
  meth1
rescue SomeError
  print "SomeError"
rescue SomeOtherError
  print "SomeOtherError"
end

---

(a) A syntax error           #=> 文法的なエラーはないため×
(b) SomeError                #=> ○
(c) SomeErrorSomeOtherError  #=> ×
(d) SomeOtherError           #=> `rescue SomeError`が先に実行されてしまうため×
```

これは難しい問題ですよね。
ポイントは、**SomeOtherErrorがSomeErrorのサブクラス**であることです。

`meth1`メソッドが実行されると、`SomeOtherError`のインスタンスが作成されて例外処理が発火します。例外処理が発火したら`rescue`を上から順に探索するので、最初に`rescue SomeError`の探索がされます。すると、`SomeOtherError`の親クラスが`SomeError`なので、`rescue SomeError`が実行されます。よって、答えは(b)となります。

:::note info
`rescue SomeError`と`rescue SomeOtherError`の順番が逆だったら、答えは(d)でした。
:::

## Q33. 以下のコードがあります。実行結果として正しいものを選択してください。(1つ選択)

```rb
begin
  ans = 100/0
  puts ans
rescue ZeroDivisionError
  puts "Error: ZeroDivisionError"
  exit 1
ensure
  puts "DONE!"
end

---

(a) 0                         #=> `100/0`の結果は0ではないので×
    DONE!
(b) Error: ZeroDivisionError  #=> `ensure`節が実行されていないので×
(c) Error: ZeroDivisionError  #=> ○
    DONE!
(d) Error: ZeroDivisionError  #=> `ensure`節で出力されるのは`0`ではないので×
    0
```

Rubyで**0で割る**処理が実行されたら、`ZeroDivisionError`が返ってきます。そのため、`rescue ZeroDivisionError`が実行されます。また、`ensure`節は何があっても実行されるので、`puts "DONE!"`は実行されます。よって、答えは(c)。

## Q34. Rubyのクラスの説明として正しいものを選択してください。(1つ選択)

```rb
クラスのスーパークラスを明示的に指定しなかった場合、

(a) 例外UndefinedParentClassErrorが発生する  #=> UndefinedParentClassErrorなんてものはないので×
(b) 文法エラーが発生する                      #=> ×
(c) Moduleクラスがスーパークラスになる          #=> ×
(d) スーパークラスのないクラスが作成される        #=> ×
(e) Objectクラスがスーパークラスになる          #=> ○
```

基本的に、クラスを定義した場合、そのクラスは`Object`クラスを継承します。

## Q35. 以下のコードがあります。実行結果として正しいものを選択してください。(1つ選択)

```rb
class Object
  def moo
    puts "MOO!"
  end
end

"Cow".moo

---

(a) 何も出力されない     #=> ×
(b) 実行時にエラーになる  #=> ×
(c) MOO!              #=> ○
(d) nil               #=> ×
```

わかりづらいですが、`"Cow".moo`は**Stringクラスのmooメソッド**を呼び出しています。
そのため、**Cowクラスを定義していないからエラーだ！** と考えてはいけません。

流れを説明します。
お察しの通り、**Stringクラスにmooメソッドは存在しない**ので、`String`クラスの継承元の **`Object`クラスのmooメソッド**を探しに行きます。それは定義されているので、**`Object`クラスのmooメソッド**が実行されることになります。よって、答えは(c)。

## Q36. 以下の実行結果を出力するコードがあります。 __(1)__に入る適切な記述を選択してください。(1つ選択)

```rb
class Shouter
  def __(1)__(message)
    @message = message
  end

  def greet
    puts @message.upcase
  end
end

g = Shouter.new("Hello, world!")
g.greet

[出力]
HELLO, WORLD!

---

(a) Shouter      #=> ×
(b) new          #=> ×
(c) initialize   #=> ○
(d) __init__     #=> ×
```

Rubyの`initialize`メソッドは特殊で、クラスのインスタンスが作成されるときに自動で実行されます。
そのため、`Shouter.new`が実行されると、そのインスタンスに対して`initialize`メソッドが実行されます。

## Q37. 以下の実行結果を出力するコードがあります。 __(1)__に入る適切な記述を選択してください。(1つ選択)

```rb
class Shouter
  def initialize(message)
    @message = message
  end

  def greet
    puts @message.upcase
  end
end

g = __(1)__("Hello, world!")
g.greet

[出力]
HELLO, WORLD!

---

(a) Shouter       #=> ×
(b) #Shouter      #=> ×
(c) new Shouter   #=> ×
(d) Shouter.new   #=> ○
```

前の問題と同じです。

## Q38. 以下のコードがあります。実行結果として正しいものを選択してください。(1つ選択)

```rb
class Foo
  attr_reader :var
  def initialize
    @var = "apple"
  end
end

class Bar < Foo
  def initialize
    @var = "banana"
    super
  end
end

bar = Bar.new
puts bar.var

---

(a) apple              #=> ○
(b) banana             #=> ×
(c) 何も出力されない      #=> ×
(d) 実行時にエラーになる   #=> ×
```

この問題でのポイントは、**`Bar`クラスが`Foo`クラスを継承しているということ**と、**`super`が使用されているということ**です。

流れを説明します。
まず、`Bar.new`でインスタンスが生成されます。自動で`initialize`メソッドが実行されるので、`@var`には`"banana"`が格納されます。

さらに、`initialize`メソッド内で`super`が実行されます。`super`の動作は、**親クラスに存在する同名のメソッドを呼び出す**というものです。要するに、**`Bar`クラスの親クラス（`Foo`クラス）の`initialize`メソッド** が実行されます。`Foo`クラスの`initialize`メソッドメソッドでは、`@var`には`"apple"`が格納されます。これで`bar = Bar.new`が実行された時の処理は終わりです。

最後に`bar.var`が実行されるので、最後に格納された`apple`が出力されます。

## Q39. 以下の実行結果を出力するコードがあります。 __(1)__に入る適切な記述を選択してください。(1つ選択)

```rb
puts "$foo$".__(1)__("$")

[出力]
foo$

---

(a) sub             #=> `sub`メソッドは引数を2つ必要とするため×
(b) chop            #=> `chop`メソッドは引数を必要としないため×
(c) delete          #=> `delete`メソッドは一致する全ての文字列を削除した文字列を返すため×
(d) delete_prefix   #=> `delete_prefix`メソッドは文字列の最初の文字列が引数と一致した場合に文字列を削除するので○
```

```irb:delete_prefixの動作
irb(main):071> p "foo$".delete_prefix("$")
=> "foo$"   # 文字列の先頭に"$"がないため、そのまま
irb(main):072> p "$foo$".delete_prefix("$")
=> "foo$"   # 文字列の先頭に"$"があるため、削除される
irb(main):073> "foo$".delete_prefix!("$")
=> nil      # 文字列の先頭に"$"がない場合に破壊的メソッドとして実行すると`nil`が返ってくる
```

## Q40. 以下の実行結果を出力するコードがあります。 __(1)__に入る適切な記述を選択してください。(1つ選択)

```rb
r = "a".."e"
p r.__(1)__

[出力]
["a", "b", "c", "d", "e"]

---

(a) array     #=> ×
(b) to_ary    #=> ×
(c) to_a      #=> ○
(d) to_array  #=> ×
```

## Q41. 以下のコードがあります。実行結果として正しいものを選択してください。(1つ選択)

```rb
p [0,1,2,3,4,5].find {|x| x < 3}

---

(a) [0, 1, 2]     #=> ×（`find_all`だったら○）
(b) 0             #=> `find`メソッドは条件に一致する最初の要素のみを返すため、○
(c) [0, 1, 2, 3]  #=> ×
(d) true          #=> ×
```

## Q42. 以下の実行結果を出力するコードがあります。 __(1)__に入る適切な記述を選択してください。(2つ選択)

```rb
p [1,16,8,4,2].__(1)__

[出力]
[16, 8, 4, 2, 1]

---

(a) sort_by { |x| -x }  #=> ○
(b) sort_reverse        #=> `sort_reverse`メソッドは存在しないので×
(c) sort.reverse        #=> ○
(d) reverse.sort        #=> 最後に`sort`メソッドが実行されるので、昇順になってしまうため×
```

`sort_by`メソッドは、配列の順番をブロック内の条件に合わせて並び替えるメソッドです。
また、`sort_by`メソッドのブロック内で使用できる変数は1つです。

## Q43. 配列を降順にソートするコードがあります。 __(1)__に入る適切な記述を選択してください。(1つ選択)

```rb
ary = [2,4,8,1,16]
p ary.__(1)__

[出力]
[16, 8, 4, 2, 1]

---

(a) sort { |i,j| -i <= -j }   #=> ×
(b) sort { |i,j| -i <=> -j }  #=> ○
(c) sort { |i,j| i >= j }     #=> ×
(d) sort{ |i,j| i <=> j }     #=> ×
```

`sort`メソッドは、二つの要素をUFO演算子で比較して要素を並び替えるメソッドです。
`<=>`演算子については、理解を深める必要があったため、他の記事で解説をしています。

https://qiita.com/PDC-Kurashinak/private/b81c10b4ecba9fe05ed7

## Q44. 以下のコードがあります。実行結果として正しいものを選択してください。(1つ選択)

```rb
File.write("test", "hellorubyworld\n")
File.open("test") do |file|
  file.seek(5)
  print file.gets
end

---

(a) hello       #=> ×
(b) rubyworld   #=> ○
(c) hellor      #=> ×
(d) rubyw       #=> ×
(e) orubyworld  #=> ×
```

`seek`メソッドは、ポインタをファイルの先頭（0）から指定されたバイトオフセットに移動するメソッドです。
この問題では、指定されたバイトオフセットは5なので、`o`と`r`の間にポインタがセットされます。
`gets`メソッドは、現在のポインタからファイルの最後までを読み込むメソッドです。
よって、`rubyworld\n`が読み込まれるため、(b)が答えです。

## Q45. 以下のコードではopenメソッドの第2引数を省略してファイルを開いています。このケースで暗黙的に第2引数として指定されるものを選択してください。

```rb
file = open("sample.txt")

---

(a) r   #=> デフォルトでは一番安全な`ファイルの先頭から読み込みのみ`が設定されるため、これが○
(b) r+  #=> ×
(c) a   #=> ×
(d) a+  #=> ×
(e) w   #=> ×
(f) w+  #=> ×
```

| モード | 説明 |
| --- | --- |
| "r" | ファイルの先頭から読み込みのみ(デフォルトのモード) |
| "r+" | ファイルの先頭から読み書き可能 |
| "w" | 既存のファイルを0バイトに切り詰めるか新しくファイルを作成し、書き込みのみ |
| "w+" | 既存のファイルを0バイトに切り詰めるか新しくファイルを作成し、読み書き可能 |
| "a" | 存在しなければ新しくファイルを作成し、ファイル末尾に追記。書き込みのみ |
| "a+" | 存在しなければ新しくファイルを作成し、ファイル末尾に追記。読み書き可能 |

## Q46: test_one.txtの内容をtest_two.txtにコピーするコードがあります。 __(1)__に入る適切な記述を選択してください。test_two.txtがすでに存在する場合、このコードは最初にファイルサイズを0にし、先頭から内容を上書きするものとします。(2つ選択)

```rb
open("test_one.txt") {|source|
  open("test_two.txt", "__(1)__") {|dest|
    dest.write(source.read)
  }
}

---

(a) r+  #=> ×
(b) a   #=> ×
(c) a+  #=> ×
(d) w   #=> ○
(e) w+  #=> ○
```

## Q47: Dirクラスに存在しないクラスメソッドを選択してください。(2つ選択)

```rb
(a) Dir.pwd        #=> 存在するので×
(b) Dir.rename     #=> 存在しないので○
(c) Dir.basename   #=> 存在しないので○
(d) Dir.chdir      #=> 存在するので×
(e) Dir.delete     #=> 存在するので×
```

irbでは以下のように確認できます。

```irb
irb(main):100> Dir.methods
=> # メソッド一覧が表示されます。
irb(main):101> Dir.methods.include?('rename')
=> false
```

## Q48. 以下のコードがあります。実行結果として正しいものを選択してください。(1つ選択)

```rb
p "hello ruby world"[6,4]

---

(a) "hello "           #=> ×
(b) "ruby"             #=> ○
(c) " world"           #=> ×
(d) 実行時にエラーになる   #=> ×
```

文字列にもインデックスが存在します。
まず、インデックスが6の文字列は`r`となります。次に`4`が意味しているものですが、これは文字数を表しています。つまり、`r`から4文字なので、`ruby`となります。よって、答えは(b)。

## Q49: 以下のコードがあります。実行結果として正しいものを選択してください。(1つ選択)

```rb
str = "bat"
str[1,1] = "o"
p str

---

(a) "boo"   #=> ×
(b) "bot"   #=> 文字列インデックスが`1`から1文字分を`o`に変えると`bot`となるので○
(c) "oat"   #=> ×
(d) "o"     #=> ×
```

## Q50. 以下のコードがあります。実行結果として正しいものを選択してください。(1つ選択)

```rb
puts 5 * "hi"

---

(a) "hihihihihi"       #=> ×（`"hi" * 5`であれば○）
(b) 実行時にエラーになる  #=> ○
(c) "5hi"              #=> ×（足し算なら○）
(d) "5*hi"             #=> ×
```

数値と文字列の掛け算は、**文字列をかけられる数**、**数値をかける数**とする必要があります。

# まとめ

Silver部分で点数を落とすとしたら、**クラスの継承**、**`File`,`Dir`,`IO`** クラスかなぁと思います。あとは序盤のややこしい系問題で点数を落とさないようにしましょう。

以上