paizaラーニング解答: Cランクレベルアップメニュー[Ruby]

# Cランクレベルアップメニュー
https://paiza.jp/works/mondai/c_rank_level_up_problems/problem_index?language_uid=ruby

paiza側の模範解答とは違う解法の解答が含まれます。
## STEP: 1 単純な入出力
```ruby
s = gets.chomp
puts s
```

## STEP: 2 複数行にわたる出力
```ruby
n = gets.to_i
n.times { puts "paiza" }
```

## STEP: 3 複数行にわたる入力
```ruby
n = gets.to_i
n.times { puts gets.to_i }
```

## STEP: 4 入力の配列による保持
```ruby
n = gets.to_i
ans = 0
n.times { ans = [gets.to_i, ans].max }
puts ans
```

## STEP: 5 半角スペース区切りでの出力
```ruby
n = gets.to_i
ans = ["paiza"] * n
puts ans.join(' ')
```

## STEP: 6 改行区切りでの出力
```ruby
n = gets.to_i
a = gets.split.map(&:to_i)
puts a
```
## FINAL問題 標準入出力
```ruby
n = gets.to_i
n.times do
    a = gets.chomp.split
    puts "#{a[0]} #{a[1].to_i + 1}"
end
```

## STEP: 1 整数と文字列
```ruby
n = gets.to_i
n.times do
    a = gets.chomp
    puts a.length
end
```

## STEP: 2 部分文字列
```ruby
a = gets.chomp
s = gets.chomp
puts s.include?(a) ? "YES" : "NO"
```

## STEP: 3 数字の文字列操作（基本）
```ruby
s = gets.chomp
a = s[0].to_i + s[3].to_i
b = s[1].to_i + s[2].to_i
puts a.to_s + b.to_s
```

## STEP: 4 数字の文字列操作（0埋め）
```ruby
n = gets.to_i
puts "%03d" % n
```
%は出力フォーマットととして使用していて、0で3行埋めるの意味。
dは十進数のこと。
## STEP: 5 数字の文字列操作（時刻1）
```ruby
s = gets.split(':').map(&:to_i)
puts s[0].to_i
puts s[1].to_i
```
## STEP: 6 数字の文字列操作（時刻2）
```ruby
h, m = gets.split(':').map(&:to_i)
m += 30
if m > 59
    h += 1
    m -= 60
end
puts "#{"%02d" % h}:#{"%02d" % m}"
```

## FINAL問題 文字列
```ruby
n = gets.to_i
n.times do
    h, m, add_h, add_m = gets.split(/[: ]/).map(&:to_i)
    h += add_h
    m += add_m
    if m > 59
        h += 1
        m -= 60
    end
    if h > 23
        h -= 24
    end
    puts "#{"%02d" % h}:#{"%02d" % m}"
end
```
splitメソッドは正規表現も利用可能。
端にある/は正規表現の開始と終わり
[]内にあるどれかにマッチ
:と半角スペースで切り分けて保存できます。
## STEP: 1 3の倍数のカウント
```ruby
n = gets.to_i
a = gets.split.map(&:to_i)
count = 0
a.each do |i|
    count += 1 if i % 3 == 0
end
puts count
```

## STEP: 2 フラグ管理
```ruby
n = gets.to_i
a = n.times.map { gets.to_i }
puts a.include?(7) ? "YES" : "NO"
```

## STEP: 3 インデックス取得
```ruby
n = gets.to_i
a = n.times.map { gets.to_i }
k = gets.to_i
puts a.index(k) + 1
```

## STEP: 4 多重ループ
```ruby
m = gets.to_i
c = m.times.map { gets.chomp }
n = gets.to_i
s = n.times.map { gets.chomp }
c.each do |i|
    s.each do |j|
        puts j.include?(i) ? "YES" : "NO"
    end
end
```
## FINAL問題 forループ
```ruby
n, m, k = gets.split.map(&:to_i)
a = n.times.map { gets.split.map(&:to_i) }
for i in 0...n
    point = 0
    for j in 0...m
        point += 1 if a[i][j] == k
    end
    puts point
end
```
for inループで答えてみました。
問題のタイトルは「forループ」なのにpaiza側の模範解答がeachループなのはなぜ？
## STEP: 1 昇順ソート
```ruby
n = gets.to_i
a = n.times.map { gets.to_i }
puts a.sort
```

## STEP: 2 降順ソート
```ruby
n = gets.to_i
a = n.times.map { gets.to_i }
puts a.sort.reverse
```

## STEP: 3 辞書式ソート
```ruby
n = gets.to_i
a = n.times.map { gets.split.map(&:to_i) }
a.sort!.reverse!
a.each do |i|
    puts i.join(' ')
end
```

## FINAL問題 ソート
```ruby
n = gets.to_i
a = n.times.map { gets.split.map(&:to_i).reverse }
a.sort!.reverse!
a.each do |i|
    puts "#{i[1]} #{i[0]}"
end
```

## STEP: 1 辞書の基本
```ruby
n = gets.to_i
hash = Hash.new
n.times do
    s, a = gets.chomp.split
    hash[s] = a
end
q = gets.chomp
puts hash[q]
```

## STEP: 2 辞書のデータ更新
```ruby
n = gets.to_i
hash = Hash.new
n.times do
    s = gets.chomp
    hash[s] = 0
end
m = gets.to_i
m.times do
    s, a = gets.chomp.split
    hash[s] += a.to_i
end
q = gets.chomp
puts hash[q]
```

## STEP: 3 辞書データの順序
```ruby
n = gets.to_i
dmg = {}
n.times do
    s = gets.chomp
    dmg[s] = 0
end
m = gets.to_i
m.times do
    s, atk = gets.split
    dmg[s] += atk.to_i
end
sd = dmg.sort
sd.each do |_, d|
    puts d
end
```

## FINAL問題 辞書
```ruby
p, q, r = gets.split.map(&:to_i)
ab = p.times.map { gets.split.map(&:to_i) }
bc = q.times.map { gets.split.map(&:to_i) }
ab.sort!
ab.each do |a, b|
    q.times do |i|
        if b == bc[i][0]
            c = bc[i][1]
            puts "#{a} #{c}"
            break
        end
    end
end
```
思いついたのはこちらのコードでした。
辞書（ハッシュ）を使う方法はpaizaの模範解答にあります。
## STEP: 1 条件を満たす最小の自然数
```ruby
ans = 10000
while ans % 13 != 0
    ans += 1
end
puts ans
```

## STEP: 2 シミュレーションの練習
```ruby
n = gets.to_i
a, b = gets.split.map(&:to_i)
paiza = 1
kyoko = 1
count = 0 
while kyoko <= n
    kyoko += paiza * a
    paiza += kyoko % b
    count += 1
end
puts count
```

## FINAL問題 シミュレーション
```ruby
h = gets.to_i
paiza = [0, 1, 1]
monster = [0, 1, 1]
h -= 2
turn = 2
while h > 0
    monster[0] = monster[1]
    monster[1] = monster[2]
    paiza[0] = paiza[1]
    paiza[1] = paiza[2]
    monster[2] = paiza[1] + paiza[0]
    paiza[2] = monster[1] * 2 + monster[0]
    h -= paiza[2]
    turn += 1
end
puts turn
```