paizaラーニング解答: 標準出力メニュー[Ruby]

# 標準出力メニュー
https://paiza.jp/works/mondai/stdout_primer/problem_index?language_uid=ruby
## STEP: 1 1 行の出力
```ruby
puts 813
```

## STEP: 2 2 行の出力
```ruby
puts 8
puts 13
```

## STEP: 3 3 行の出力
```ruby
puts 8
puts 1
puts 3
```

## STEP: 4 10 行の出力
```ruby
puts %w[813 1 2 923874 23648 782356 3256 2342 24324 112]
```
%w記法を使うことで配列にできます。
## FINAL問題 【改行あり出力】1,000 行の出力
```ruby
(1..1000).each do |i|
    puts i
end
```

## STEP: 1 2 つの数値を出力
```ruby
puts "1 1"
```

## STEP: 2 3 つの数値を出力
```ruby
puts "8 1 3"
```

## STEP: 3 10 個の数値を出力 (末尾に半角スペース有)
```ruby
(1..10).each do |i|
    print i
    print " "
end
```
printメソッドは改行しないため、繰り返し処理後に数字を一行で出力できます。
## STEP: 4 10 個の数値を出力
```ruby
puts (1..10).to_a.join(' ')
```
to_aメソッドで配列にして、joinメソッドの引数に半角スペースを入れることによって、数字を半角スペースで区切って出力できます。
## FINAL問題 【半角スペース区切りの出力】1,000 個の数値を出力
```ruby
puts (1..1000).to_a.join(' ')
```

## STEP: 1 1 つの文字列を出力
```ruby
puts "paiza"
```

## STEP: 2 2 つの文字列を出力
```ruby
puts "paiza learning"
```

## STEP: 3 入力された 2 つの文字列を出力
```ruby
s = gets.chomp
t = gets.chomp
puts s
puts t
```

## STEP: 4 入力された 10 個の文字列を出力
```ruby
a = []
10.times { a << gets.chomp }
puts a.join(' ')
```

## FINAL問題 【文字列の出力】入力された 10 個の文字列を出力
```ruby
a = gets.chomp.split
puts a
```

## STEP: 1 1 行または 2 行の出力
```ruby
n = gets.to_i
if n == 1
    puts 1
else
    puts 1
    puts 2
end
```

## STEP: 2 数行の出力
```ruby
n = gets.to_i
(1..n).each { |i| puts i }
```

## STEP: 3 10 行以内の出力
```ruby
n = gets.to_i
(1..n).each { |i| puts i }
```

## FINAL問題 【n 行の出力】1,000 行以内の出力
```ruby
n = gets.to_i
(1..n).each { |i| puts i }
```

## STEP: 1 カンマ区切りで 2 つ出力
```ruby
a = gets.split.map(&:to_i)
puts a.join(',')
```

## STEP: 2 バーティカルライン区切りで 3 つの文字列を出力
```ruby
s = []
3.times { s << gets.chomp }
puts s.join('|')

```

## STEP: 3 カンマ区切りで 10 個出力 1
```ruby
n = gets.split.map(&:to_i)
n.each do |i|
    print "#{i},"
end
```

## STEP: 4 カンマ区切りで 10 個出力 2
```ruby
n = gets.split.map(&:to_i)
puts n.join(',')
```

## STEP: 5 半角スペースとバーティカルライン区切りで 10 個出力
```ruby
n = []
10.times { n << gets.to_i }
puts n.join(' | ')
```

## STEP: 6 大きな数値を 3 けたごとにカンマ区切りで出力
```ruby
n = gets.chomp
(0...n.length).each do |i|
    if i % 3 == 0 && i != 0
        print ","
    end
    print n[i]
end
```
nは文字列として扱い、3桁毎に,を出力します。

## FINAL問題 【特定の文字で区切り 1 行で出力】大きな数値を 3 けたごとにカンマ区切りで出力 2
```ruby
n = gets.chomp
n.reverse!
m = ""
(0...n.length).each do |i|
    if i % 3 == 0 && i != 0
        m += ","
    end
    m += n[i]
end
puts m.reverse
```
reverse!メソッドで反転することで低い桁から3桁毎に,を追加。新しい文字列mに追加していく。
最後に再度反転して出力。
## STEP: 1 2 * 2 の出力
```ruby
puts "0 8"
puts "1 3"
```

## STEP: 2 3 * 3 の出力
```ruby
n = gets.split.map(&:to_i)
(0..8).each do |i|
    if i % 3 == 2
        puts n[i]
    else
        print "#{n[i]} "
    end
end
```

## STEP: 3 九九表の出力
```ruby
(1..9).each do |i|
    (1..9).each do |j|
        if j == 9
            puts i * j
        else
            print "#{i * j} "
        end
    end
end
```

## FINAL問題 【n * n の 2 次元配列の表示】N * N の九九表の出力
```ruby
n = gets.to_i
(1..n).each do |i|
    (1..n).each do |j|
        if j == n
            puts i * j
        else
            print "#{i * j} "
        end
    end
end
```

## STEP: 1 N 個の文字を半分ずつ出力
```ruby
n = gets.to_i
(1..n).each do |i|
    if i == n / 2 || i == n
        puts i
    else
        print "#{i} "
    end
end
```

## STEP: 2 数値を異なる長さで 2 行出力
```ruby
n, m = gets.split.map(&:to_i)
a = []
b = []
(1..n).each {|i| a << i }
(1..m).each {|i| b << i }
puts a.join(' ')
puts b.join(' ')
```

## STEP: 3 直角三角形の出力
```ruby
n = gets.to_i
(1..n).each do |i|
    a = []
    (1..i).each do |j|
        a << j
    end
    puts a.join(' ')
end
```

## STEP: 4 すべての行の長さが不定な 2 次元配列の出力
```ruby
n = gets.to_i
m = gets.split.map(&:to_i)
(0...n).each do |i|
    a = []
    (1..m[i]).each do |j|
        a << j
    end
    puts a.join(' ')
end
```

## FINAL問題 【行によって長さが違う二次元配列の表示】すべての行の長さと値が不定な 2 次元配列の出力
```ruby
n, m = gets.split.map(&:to_i)
a = gets.split.map(&:to_i)
b = gets.split.map(&:to_i)
(0...m).each do |i|
    puts a.slice!(0..b[i]-1).join(' ')
end
```
slice!メソッドで配列aの先頭から取り出しています。
## STEP: 1 1 つの実数を出力
```ruby
n = gets.chomp
puts n
```

## STEP: 2 1 つの実数を出力 2
```ruby
n = gets.chomp
puts n
```

## STEP: 3 1 つの実数を出力 3
```ruby
n = gets.to_f
puts "%.3f" % n.round(3)
```

## STEP: 4 1 つの実数を出力 4
```ruby
n, m = gets.split.map(&:to_f)
m = m.to_i
puts "%.#{m}f" % n.round(m)
```

## FINAL問題 【実数をフォーマット指定して出力】複数の実数を出力
```ruby
q = gets.to_i
q.times do
    n, m = gets.split.map(&:to_f)
    m = m.to_i
    puts "%.#{m}f" % n.round(m)
end
```

## STEP: 1 数値を半角スペース埋めで出力
```ruby
n = gets.to_i
puts "%3d" % n
```

## STEP: 2 数値をゼロ埋めで出力
```ruby
n = gets.to_i
puts "%03d" % n
```

## STEP: 3 複数の数値を半角スペース埋めで出力
```ruby
n = gets.to_i
n.times do
    m = gets.to_i
    puts "%3d" % m
end
```

## STEP: 4 数値を M けた半角スペース埋めで出力
```ruby
n, m = gets.split.map(&:to_i)
puts "%#{m}d" % n
```

## FINAL問題 【出力幅を指定して出力】N 個の数値を M けた半角スペース埋めで出力
```ruby
n, m = gets.split.map(&:to_i)
n.times do
    i = gets.to_i
    puts "%#{m}d" % i
end
```

## STEP: 1 2 つの文字列を出力
```ruby
s = gets.chomp
t = gets.chomp
puts "#{s} + #{t} = #{s + t}"
```

## STEP: 2 文字列と N 個の整数の出力
```ruby
n, a, b = gets.split.map(&:to_i)
array = []
n.times do
    array << "(#{a}, #{b})"
end
puts array.join(', ')
```

## STEP: 3 九九表を罫線入りで出力
```ruby
(1..9).each do |i|
    a = []
    (1..9).each do |j|
        a << "%#2d" % (i * j)
    end
    puts a.join(' | ')
    if i < 9
        # 2文字 * 9個 + 3文字 * 8個
        puts "=" * 42
    end
end
```

## STEP: 4 ペアの数値の入った表を罫線入りで出力
```ruby
h, w, a, b = gets.split.map(&:to_i)
array = ["(#{a}, #{b})"] * w
(1..h).each do |i|
    puts array.join(' | ')
    if i < h
        puts "=" * (6 * w + 3 * (w - 1))
    end
end
```

## FINAL問題 【出力形式を指定して出力】ペアの数値の入った表を罫線入りで出力 2
```ruby
h, w, a, b = gets.split.map(&:to_i)
array = ["(#{"%9d"% a}, #{"%9d"% b})"] * w
(1..h).each do |i|
    puts array.join(' | ')
    if i < h
        puts "=" * (22 * w + 3 * (w - 1))
    end
end
```