paizaラーニング解答: 配列メニュー[Ruby]

# 配列メニュー
https://paiza.jp/works/mondai/array_primer/problem_index?language_uid=ruby
## STEP: 1 要素数の出力
```ruby
a = %w[5 1 3 4 5 12 6 8 1 3]
puts a.length
```
%wで[]内を配列にできます。
## STEP: 2 全要素の出力
```ruby
puts %w[5 1 3 4 5 12 6 8 1 3]
```

## STEP: 3 i 番目の出力
```ruby
a = %w[5 1 3 4 5 12 6 8 1 3]
puts a[3]
```

## STEP: 4 配列の入力 1
```ruby
puts %w[8 1 3 3 8 1 1 3 8 8]
```

## STEP: 5 配列の入力 2
```ruby
a = gets.split.map(&:to_i)
puts a
```

## STEP: 6 配列の入力 3
```ruby
n = gets.to_i
a = gets.split.map(&:to_i)
puts a
```

## STEP: 7 i番目の出力 1
```ruby
a = %w[1 3 5 4 6 2 1 7 1 5]
k = gets.to_i
puts a[k - 1]
```

## STEP: 8 i番目の出力 2
```ruby
k = gets.to_i
a = gets.split.map(&:to_i)
puts a[k - 1]
```

## FINAL問題 【次元配列の入出力】i番目の出力 Boss
```ruby
n, k = gets.split.map(&:to_i)
a = gets.split.map(&:to_i)
puts a[k - 1]
```

## STEP: 1 要素数の出力
```ruby
a = [%w[1 2 3 4 5 6], %w[8 1 3 3 1 8]]
puts a.flatten.length
```

## STEP: 2 全要素の出力
```ruby
a = [%w[6 5 4 3 2 1], %w[3 1 8 8 1 3]]
puts a[0].join(' ')
puts a[1].join(' ')
```

## STEP: 3 行数の出力
```ruby
a = [%w[1 2 3], %w[4 5 6], %w[8 1 3]]
puts a.length
```

## STEP: 4 列数の出力
```ruby
a = [%w[1 2 3 4], %w[6 5 4 3], %w[3 1 8 1]]
puts a[0].length
```

## STEP: 5 各行の要素数の出力
```ruby
a = [%w[1], %w[2 3], %w[4 5 6]]
puts a[0].length
puts a[1].length
puts a[2].length
```

## STEP: 6 i 行目 j 列目の出力
```ruby
a = [%w[1 2 3], %w[8 1 3], %[w10 100 1]]
puts a[1][2]
```

## STEP: 7 二次元配列の入力 1
```ruby
a = [%w[1 3 5 7], %w[8 1 3 8]]
puts a[0].join(' ')
puts a[1].join(' ')
```

## STEP: 8 二次元配列の入力 2
```ruby
m = gets.to_i
5.times do
    a = gets.split.map(&:to_i)
    puts a.join(' ')
end
```
二次元配列にしなくても解答できます。
## STEP: 9 二次元配列の入力 3
```ruby
n = gets.to_i
a = []
n.times do |i|
    a << gets.split.map(&:to_i)
    puts a[i].join(' ')
end
```
一応二次元配列にしてみました。
## STEP: 10 二次元配列の入力 4
```ruby
n, m = gets.split.map(&:to_i)
a = []
n.times do
    a << gets.split.map(&:to_i)
end
n.times do |i|
    puts a[i].join(' ')
end
```
問題の意図に沿って二次元配列にしてから改めて出力してます。
## STEP: 11 i番目の出力 1
```ruby
k, l = gets.split.map(&:to_i)
a = [
%w[1 2 3 4],
%w[10 100 0 5],
%w[8 1 3 8],
%w[15 34 94 25]
]
puts a[k - 1][l - 1]
```

## STEP: 12 i番目の出力 2
```ruby
k, l = gets.split.map(&:to_i)
a = []
3.times { a << gets.split.map(&:to_i) }
puts a[k - 1][l - 1]
```

## FINAL問題 【二次元配列の入出力】i番目の出力 Boss
```ruby
n, m, k, l = gets.split.map(&:to_i)
a = []
n.times { a << gets.split.map(&:to_i) }
puts a[k - 1][l - 1]
```

## STEP: 1 配列に含まれている? 1
```ruby
a = %w[10 13 21 1 6 51 10 8 15 6].map(&:to_i)
puts a.include?(6) ? "Yes" : "No"
```
%w[]だと要素は文字列になるので.map(&:to_i)で要素を整数にしています。
最初から[10, 13, 21, ... 15, 6]と,を付ければ済むって話ですが、問題文から配列をコピペする度に,をつける方が面倒に感じてしまって・・・。
## STEP: 2 配列に含まれている? 2
```ruby
n = gets.to_i
a = %w[5 12 6 84 14 25 44 3 7 20].map(&:to_i)
puts a.include?(n) ? "Yes" : "No"

```

## STEP: 3 配列に含まれている? 3
```ruby
n, m = gets.split.map(&:to_i)
a = gets.split.map(&:to_i)
puts a.include?(m) ? "Yes" : "No"

```

## STEP: 4 何番目にある? 1
```ruby
a = %w[1 10 2 9 3 8 4 7 5 6].map(&:to_i)
puts a.index(8) + 1
```

## STEP: 5 何番目にある? 2
```ruby
n = gets.to_i
a = %w[1 5 9 7 3 2 4 8 6 10].map(&:to_i)
puts a.index(n) + 1
```

## STEP: 6 何番目にある? 3
```ruby
n, m = gets.split.map(&:to_i)
a = gets.split.map(&:to_i)
puts a.index(n) + 1
```

## STEP: 7 何個ある? 1
```ruby
a = %w[1 2 2 1 2 1 2 1 1 1].map(&:to_i)
puts a.count(1)
```

## STEP: 8 何個ある? 2
```ruby
n = gets.to_i
a = %w[1 2 5 1 4 3 2 5 1 4].map(&:to_i)
puts a.count(n)
```

## FINAL問題 【配列の検索】何個ある? Boss
```ruby
n, m = gets.split.map(&:to_i)
a = gets.split.map(&:to_i)
puts a.count(n)
```

## STEP: 1 配列の書き換え
```ruby
a, b, n = gets.split.map(&:to_i)
array = gets.split.map(&:to_i)
n.times do |i|
    if array[i] == a
        array[i] = b
    end
end
puts array
```

## STEP: 2 2 変数の入れ替え
```ruby
a, b = gets.split.map(&:to_i)
b, a = a, b
puts "#{a} #{b}"
```

## STEP: 3 配列の要素の入れ替え
```ruby
a, b, n = gets.split.map(&:to_i)
array = gets.split.map(&:to_i)
array[a - 1], array[b - 1] = array[b - 1], array[a - 1]
puts array
```

## STEP: 4 部分配列
```ruby
a, b, n = gets.split.map(&:to_i)
array = gets.split.map(&:to_i)
puts array[a - 1..b - 1]
```

## STEP: 5 配列の連結
```ruby
n, m = gets.split.map(&:to_i)
a = gets.split.map(&:to_i)
b = gets.split.map(&:to_i)
puts a + b
```

## STEP: 6 配列のソート
```ruby
n = gets.to_i
a = gets.split.map(&:to_i)
puts a.sort
```

## STEP: 7 配列の反転
```ruby
n = gets.to_i
a = gets.split.map(&:to_i)
puts a.reverse
```

## STEP: 8 要素のカウント
```ruby
n, m = gets.split.map(&:to_i)
a = gets.split.map(&:to_i)
puts a.count(m)
```

## STEP: 9 配列末尾への追加
```ruby
n, m = gets.split.map(&:to_i)
a = gets.split.map(&:to_i)
puts a << m
```

## STEP: 10 要素の削除
```ruby
n, m = gets.split.map(&:to_i)
a = gets.split.map(&:to_i)
a.delete_at(m - 1)
puts a
```
配列.delete_at(削除位置)
## STEP: 11 要素の挿入
```ruby
n, m, k = gets.split.map(&:to_i)
a = gets.split.map(&:to_i)
a.insert(m - 1, k)
puts a
```
配列.insert(挿入位置, 挿入する要素)
## STEP: 12 要素数の出力
```ruby
a = ["Hello", "paiza", "1234", "pa13"]
puts a.length
```

## STEP: 13 全要素の出力
```ruby
a = ["good", "morning", "paiza", "813", "pa13"]
puts a
```

## STEP: 14 i 番目の出力
```ruby
a = ["good", "morning", "paiza", "813", "pa13"]
puts a[2]
```

## STEP: 15 文字列の配列の入力 1
```ruby
a = %w[eight one three paiza pa13 813]
puts a
```

## STEP: 16 文字列の配列の入力 2
```ruby
a = gets.chomp.split
puts a
```

## STEP: 17 文字列の配列の入力 3
```ruby
n = gets.to_i
a = gets.chomp.split
puts a
```

## STEP: 18 i 番目の出力 1
```ruby
n = gets.to_i
a = ["good", "morning", "paiza", "813", "pa13"]
puts a[n - 1]
```

## STEP: 19 i 番目の出力 2
```ruby
n = gets.to_i
a = gets.chomp.split
puts a[n - 1]
```

## STEP: 20 i 番目の出力 3
```ruby
n, m = gets.split.map(&:to_i)
a = gets.chomp.split
puts a[n - 1]
```

## STEP: 21 i 番目の出力 4
```ruby
n, m, l = gets.split.map(&:to_i)
a = gets.chomp.split
puts a[n - 1][l - 1]
```

## STEP: 22 辞書順に出力 1
```ruby
a = %w[zaipa izapa paiza]
puts a.sort
```

## STEP: 23 辞書順に出力 2
```ruby
a = gets.chomp.split
puts a.sort
```

## STEP: 24 辞書順に出力 3
```ruby
n = gets.to_i
a = gets.chomp.split
puts a.sort
```

## FINAL問題 【文字列の配列】辞書順に出力 Boss
```ruby
n, k = gets.split.map(&:to_i)
a = gets.chomp.split
puts a.sort[k - 1]
```

## STEP: 1 重複の削除
```ruby
a = %w[1 3 5 1 2 3 6 6 5 1 4]
puts a.uniq.sort
```

## STEP: 2 配列の最大最小
```ruby
n = gets.to_i
a = gets.split.map(&:to_i)
a.sort!
puts "#{a[-1]} #{a[0]}"

# puts "#{a.max} #{a.min}"
# 上記のようにmax,minメソッドを使うと簡単ですが
# 整数を大きい順や小さい順に並び替える操作ではありません
```

## STEP: 3 ある数以上以下の要素の列挙 1
```ruby
n = gets.to_i
a = gets.split.map(&:to_i)
a.each do |i|
    if i >= 5
        puts i
    end
end
```

## STEP: 4 ある数以上以下の要素の列挙 2
```ruby
n, k = gets.split.map(&:to_i)
a = gets.split.map(&:to_i)
a.each do |i|
    if i >= k
        puts i
    end
end
```

## STEP: 5 ある数以上以下の要素の列挙 3
```ruby
n = gets.to_i
a = gets.split.map(&:to_i)
average = a.sum.fdiv(n)
a.each do |i|
    if i >= average
        puts i
    end
end
```
単に配列内を足して/で割ると小数点以下は切り捨てられてしまいます。
そのため.sum.fdiv()で平均値を求めました。小数点以下も結果に含むことができます。

## STEP: 6 二点間の距離 1
```ruby
n = gets.to_i
n.times do
    x, y = gets.split.map(&:to_i)
    puts (x - 2).abs + (y - 3).abs
end
```

## STEP: 7 二点間の距離 2
```ruby
n, a, b = gets.split.map(&:to_i)
x_array = []
y_array = []

n.times do
    x, y = gets.split.map(&:to_i)
    x_array << x
    y_array << y
end

puts (x_array[a - 1] - x_array[b - 1]).abs + (y_array[a - 1] - y_array[b - 1]).abs
```

## FINAL問題 フィボナッチ数
```ruby
n = gets.to_i
fibo = 0
fibo_0 = 0
fibo_1 = 1
n.times do
    fibo += fibo_0
    puts fibo
    fibo_0 = fibo_1
    fibo_1 = fibo
end
```
フィボナッチ数についてはpaizaラーニングの講座で詳しくされています。
使うプログラミング言語は違いますが、動画に従っていけば問題ありません。

https://paiza.jp/works/algorithm/primer/algorithm1