paizaラーニング解答:  条件分岐メニュー[Ruby]

# 条件分岐メニュー
https://paiza.jp/works/mondai/conditions_branch/problem_index?language_uid=ruby
## STEP: 1 単純な条件分岐
```ruby
s = gets.chomp
puts s == "paiza" ? "YES" : "NO"
```

## STEP: 2 数値の分岐
```ruby
n = gets.to_i
puts n <= 100 ? "YES" : "NO"
```

## STEP: 3 数値演算結果で分岐
```ruby
a, b, c = gets.split.map(&:to_i)
puts a * b <= c ? "YES" : "NO"
```

## STEP: 4 ゼロ以外
```ruby
n = gets.to_i
puts n.nonzero? ? "YES" : "NO"
```

## FINAL問題 0 が含まれていないか判定
```ruby
n = gets.to_i
a = n.times.map { gets.to_i }
puts a.include?(0) ? "NO" : "YES"
```

## STEP: 1 AND
```ruby
a, b = gets.split.map(&:to_i)
puts a >= 10 && b >= 10 ? "YES" : "NO"
```

## STEP: 2 大文字判定
```ruby
c = gets.chomp
puts c == c.upcase ? "YES" : "NO"
```
cをupcaseで大文字にしたものと元のcが同じであれば、それは大文字。
## STEP: 3 OR
```ruby
a, b = gets.split.map(&:to_i)
puts a >= 10 || b >= 10 ? "YES" : "NO"
```

## STEP: 4 NOT
```ruby
x = gets.to_i
puts !(x >= 10) ? "YES" : "NO"
```

## STEP: 5 AND+NOT
```ruby
a, b = gets.split.map(&:to_i)
puts a >= 10 && !(b >= 10) ? "YES" : "NO"
```

## FINAL問題 AND+OR
```ruby
x, y, z = gets.split.map(&:to_i)
puts (x >= 10 && y >= 10) || z >= 10 ? "YES" : "NO"
```

## STEP: 1 3 の倍数判定
```ruby
n = gets.to_i
puts n % 3 == 0 ? "YES" : "NO"
```

## STEP: 2 2 つの倍数判定
```ruby
n = gets.to_i
puts n % 15 == 0 ? "YES" : "NO"
```

## STEP: 3 偶奇の判定
```ruby
n = gets.to_i
a = gets.split.map(&:to_i)
even = 0
odd = 0
a.each { |i| i.even? ? even += 1 : odd += 1 }
puts "#{even} #{odd}"
```

## STEP: 4 曜日の判定
```ruby
n = gets.to_i
week = ["Sat", "Sun", "Mon", "Tue", "Wed", "Thu", "Fri"]
puts week[n % 7]
```

## FINAL問題 FizzBuzz
```ruby
n = gets.to_i
if n % 15 == 0
    puts "FizzBuzz"
elsif n % 3 == 0
    puts "Fizz"
elsif n % 5 == 0
    puts "Buzz"
else
    puts n
end
```
FizzBuzz問題はpaizaラーニングの講座で詳しく取り上げられています。講座内で使用するプログラミング言語は違いますが、説明に沿って取り組めば問題ありません。

https://paiza.jp/works/algorithm/primer/algorithm1
## STEP: 1 けた数の測定
```ruby
n = gets.chomp
puts n.length
```

## STEP: 2 足したり引いたり
```ruby
n, a, b = gets.split.map(&:to_i)
if n + a + b == 0
    puts "YES"
elsif n + a - b == 0
    puts "YES"
elsif n - a + b == 0
    puts "YES"
elsif n - a - b == 0
    puts "YES"
else
    puts "NO"
end
```
nが0になる4パターンの足し引きを検証する愚直な条件分岐が模範回答でした。
## STEP: 3 同値判定
```ruby
n = gets.to_i
a = gets.split.map(&:to_i)
b = gets.split.map(&:to_i)
ans = 0
n.times do |i|
    if a[i] == b[i]
        ans += 1
    end
end
puts ans
```

## STEP: 4 終了判定
```ruby
n = gets.to_i
a = gets.split.map(&:to_i)
ans = 0
a.each do |i|
    if i.odd?
        break
    end
    ans += i
end
puts ans
```

## STEP: 5 終了判定 2
```ruby
n, k = gets.split.map(&:to_i)
ans = 0
while n < k
    n *= 2
    ans += 1
end
puts ans
```

## STEP: 6 池の周回
```ruby
n, k, t = gets.split.map(&:to_i)
puts k * t % n == 0 ? "YES" : "NO"
```

## STEP: 7 崖に落ちるか判定
```ruby
n, k, t = gets.split.map(&:to_i)
puts n * k <= t ? "YES" : "NO"
```
条件よりn, k, tは整数なので問題文の0.1については無視して<=で大丈夫です。
## STEP: 8 タイルの敷き詰め
```ruby
h, w = gets.split.map(&:to_i)
puts h.nonzero? && w.nonzero? && h.even? && w.even? ? "YES" : "NO"
```
even?は0でもtrueを返すので、nonzero?で0をfalseにする必要があります。
## FINAL問題 積の最小化
```ruby
a, b = gets.split.map(&:to_i)
# AからBの間に 0 が含まれている場合Aが負の値、Bが正の値なので A * B が答え
if a <= 0 && b >= 0
    puts a * b
# A、B両方とも正の整数の場合 A * A が答え
elsif a > 0 
    puts a * a
# A、B両方とも負の整数の場合 B * B が答え
else
    puts b * b
end
```