paiza Ruby学習ログ

変数名 = gets # 標準入力を変数に代入
puts 変数名 # 入力した標準入力を出力

gets.to_i # 標準入力を整数に変換

s = gets
puts s
s = gets
puts s

puts N.times.map {gets.chomp}

# 入力
hello
world

# 出力
hello
world

count = gets.to_i # 入力の1つ目を整数として取得

for i in 1..count # countに代入された整数の回数まで繰り返す
  s = gets # 2つ目の標準入力を取得すてlineに代入
  puts s 指定された回数まで入力の値を順に出力
end 

# 入力
3
hoge
fuga
piyo

# 出力
hoge
fuga
piyo

s = gets.chomp
puts s

# 入力を3つ用意してあげるだけ
s = gets.chomp
puts s
s = gets.chomp
puts s
s = gets.chomp
puts s

n = gets.chomp.to_i
n.times do
  s = gets.chomp
  puts s
end

s = gets.chomp
t = s.split
puts t[0]
puts t[1]
puts t[2]

n = gets.to_i
s = gets.chomp
t = s.split
n.times do |i|
  puts t[i]
end

s = gets.chomp
t = s.split(',')
puts t

n = gets.to_i
s = gets.chomp
t = s.split(',')
n.times do |i|
  puts t[i]
end

a b

0 ≦ a ≦ 100
0 ≦ b ≦ 100
# 自然数の範囲内での計算であることを示している。

# 自分で回答したコード
n = gets
t = n.split(" ")

a = t[0].to_i
b = t[1].to_i

puts a + b

# 回答例
a, b = gets.split.map(&:to_i)

puts a + b

puts "#{X} #{Y}" # 変数を文字列として扱い、1行・半角スペース区切りで表示する
puts X.to_s + " " + Y.to_s # 考え方は1つ目の例と同様（やや冗長）
print X,(" "),Y # printはputsと違い改行しない
puts [X, Y].join(' ') # joinで配列の要素を連結し、連結する要素の間に半角スペースを置く

A B C

n = gets.split.map(&:to_i)
a = n[0]
b = n[1]
c = n[2]

if a * b <= c
    puts "YES"
else
    puts "NO"
end

a, b, c = gets.split.map(&:to_i)

if a * b <= c
    puts "YES"
else
    puts "NO"
end

a, b, c = gets.split.map(&:to_i)

puts a * b <= c ? "YES" : "NO"

puts gets.split.map(&:to_i).then { |a, b, c| a * b <= c ? "YES" : "NO" }

n = gets.to_i

(1..n).each do |i|
    puts i
end

n = gets.to_i

1.upto(n) do |i|
  puts i
end

(1..100).each do |i| # 整数1〜100をeach文で回す
    if i % 15 == 0
        puts "FizzBuzz"
    elsif i % 5 == 0
        puts "Buzz"
    elsif i % 3 == 0
        puts "Fizz"
    else
        puts i
    end
end

100.times do |i|
  num = i + 1
  if num % 15 == 0
    puts "FizzBuzz"
  elsif num % 5 == 0
    puts "Buzz"
  elsif num % 3 == 0
    puts "Fizz"
  else
    puts num
  end
end

(1..10).each do |i|
  puts "#{i} " # 文字列として扱う形に変更している。#{}を用いているので''はNG！
end

puts (1..10).to_a.join(' ') #Rangeオブジェクトをto_aメソッドで配列に変換し、joinメソッドを用いて、半角スペースで要素を連結している
# 1 2 3 4 5 6 7 8 9 10

puts (1..1000).to_a.join(' ')

str = 10.times.map { gets.chomp }
puts str.join(' ')

n = gets.chomp

puts n.to_s.reverse.scan(/\d{3}/).join(',').reverse

n = gets.chomp
puts n.reverse.scan(/\d{1,3}/).join(',').reverse

nums = gets.split(" ")
puts "#{nums[0]} #{nums[1]} #{nums[2]}"
puts "#{nums[3]} #{nums[4]} #{nums[5]}"
puts "#{nums[6]} #{nums[7]} #{nums[8]}"
#  一応、回答としては正しいけどセンスない…笑😂

lines = 3.times.map { gets.chomp }
puts lines

n, m, o = 3.times.map { gets.to_i } 
puts n + m + o

puts gets.split(' ')
puts gets.split # splitメソッドは空白文字で区切るため(' ')は書かなくても良い

n = gets.to_i

if n >= 1000
    puts n - 100
else
    puts n
end

n = gets.to_i

puts n >= 1000 ? n - 100 : n

n = gets.to_i # 入力された値がマイナスの値でも、正の値が返される
puts n.abs

n = gets.to_i
puts n % 2 == 0 ? "even" : "odd"

n = gets.to_i
puts n.even? ? "even" : "odd" # even?メソッドを使用

n = gets.to_i
n.times do
  a = gets.to_i
  puts a
end

n = gets.to_i
n.times {puts gets.to_i}

n = gets.to_i
(1..n).each {puts gets.to_i}

input = gets.chomp.split.map(&:to_i) # 入力を半角スペース区切りで配列に格納し、整数に変換
n = input.shift # 先頭の要素Nを取り除く
input.each do |a| # 残った整数 a_1, ..., a_N を改行区切りで出力する
  puts a
end

input = gets.chomp.split.map(&:to_i)
n = input.shift
input.each { |a| puts a } # より簡潔な記述

[1, 2, 3].map { |n| n + 10 } # => [11, 12, 13]

["1", "2", "3"].map(&:to_i) # => [1, 2, 3]

["1", "2", "3"].map { |s| s.to_i } # => [1, 2, 3]

input = gets.chomp.split.map(&:to_i) # "1 2 3" を入力すると [1, 2, 3] が得られる

[1, 2, 3].each do |element|
  puts element
end
# 配列の各要素を出力する

3.times do |i|
  puts i
end
# 0から始まって2までの数値（合計で3回）を出力する

N
a_1 b_1
...
a_N b_N

a_1 b_1
...
a_N b_N

n = gets.to_i # 入力1行目の整数Nをnに代入

n.times { puts gets.chomp } # 入力2行目〜N行目までの値を文字列として出力する作業をn回繰り返す

# 上記を省略しない場合
n.times do
  puts gets.chomp
end

n = gets.to_i

# 配列を持った2つの変数を用意する
a = Array.new(n) # n個のnilを持った配列を変数aに代入する
b = Array.new(n) # n個のnilを持った配列を変数bに代入する

n.times { |i| a[i], b[i] = gets.split(' ').map(&:to_i) }

n.times { |i| puts a[i].to_s + ' ' + b[i].to_s }

n = gets.to_i

a = Array.new(n)
b = Array.new(n)

n.times do |i|
  input = gets.split.map(&:to_i)
  a[i] = input[0]
  b[i] = input[1]
end

n.times do |i|
  puts a[i].to_s + ' ' + b[i].to_s
end

n = gets.to_i

a = [] # 配列が空のため、後の処理で配列のサイズが動的に成長する
b = [] # 配列が空のため、後の処理で配列のサイズが動的に成長する

n.times do |i|
  input = gets.split.map(&:to_i)
  a[i] = input[0]
  b[i] = input[1]
end

n.times do |i|
  puts a[i].to_s + ' ' + b[i].to_s
end

N
a_1 b_1
...
a_N b_N

a_8 b_8

# 1行目の標準入力を受け取り、変数nに代入する
# 2行目以降の標準入力(a_1 b_1 ~）を、配列として変数に格納する
# 8行目のみを出力する

n = gets.to_i
lines = []

n.times { lines << gets.chomp }

puts lines[7]

n = gets.to_i

a = Array.new(n)
b = Array.new(n)
n.times { |i| a[i], b[i] = gets.split(' ').map(&:to_i) }

puts a[7].to_s + ' ' + b[7].to_s

n = gets.to_i # 1行目の整数Nをnに代入

a = Array.new(n) # 配列を格納する変数aを用意
b = Array.new(n) # 配列を格納する変数bを用意

n.times { |i| a[i], b[i] = gets.chomp.split } # a, bに文字列として半角文字の前後をそれぞれ格納

n.times { |i| puts a[i] + ' ' + b[i].to_s } # bの値を整数に変更 ※やらなくても要件は満たせるし、結局文字列に変換してるから意味なくね？

n = gets.to_i

s = Array.new(n)
a = Array.new(n)
n.times do |i|
  s[i], a[i] =
    gets.split(' ').map.with_index { |val, j| j == 1 ? val.to_i : val } # 先に型変換をしている（文字列として扱うか、整数として扱うか）
end
# |val, j|は、valが配列の要素、jがそのインデックス
# j == 1 ? val.to_i : valは三項演算子で、インデックスjが1のとき（つまり二番目の要素、整数が来るべき場所）、その要素を整数に変換し（val.to_i）、それ以外の場合（文字列）はそのままvalを使う

n.times { |i| puts s[i] + ' ' + a[i].to_s }

["a", "b", "c"].each.with_index do |item, index|
  puts "#{index}: #{item}"
end

0: a
1: b
2: c

result = ["a", "b", "c"].map.with_index do |item, index| 
  [item, index]
end

# result => [["a", 0], ["b", 1], ["c", 2]]

a_{1,1} a_{1,2} a_{1,3}
a_{2,1} a_{2,2} a_{2,3}
a_{3,1} a_{3,2} a_{3,3}

a_{1,1} a_{1,2} a_{1,3}
a_{2,1} a_{2,2} a_{2,3}
a_{3,1} a_{3,2} a_{3,3}

# 標準入力が3行とわかっていて、形も変更する必要がないと判断
# timesメソッドを使用して、3回出力を繰り返す

3.times {puts gets.chomp}

a = Array.new(3).map { Array.new(3) }

3.times do |i|
  row = gets.split(' ').map(&:to_i)
  3.times { |j| a[i][j] = row[j] }
end

a.each { |row| puts row.join(' ') }

a = Array.new(3).map { Array.new(3) }

p aの実行結果 => [[nil, nil, nil], [nil, nil, nil], [nil, nil, nil]]

# 2次元配列を初期化している。
# Array.new(3)は要素が3つの新しい配列を作成し、その各要素に対してブロック { Array.new(3) }を実行する。
ブロック内のArray.new(3)は、再び要素が3つの新しい配列を作成する。
結果として、3x3の2次元配列ができる（全ての要素は nil で初期化される）。
# 2次元配列：表（マトリックス）のような構造を持つデータ構造のこと

1  2  3
4  5  6
7  8  9
# 2次元配列で表現すると↓
[
  [1, 2, 3],
  [4, 5, 6],
  [7, 8, 9]
]

a = Array.new(3, Array.new(3))
a[0][0] = 1
a[1][1] = 2
a[2][2] = 3
p a  # => [[1, 2, 3], [1, 2, 3], [1, 2, 3]]

3.times do |i|
  row = gets.split(' ').map(&:to_i) # 受け取った入力（文字列）を整数に変換している
  # => [8, 1, 3]
  # => [1, 2, 3]
  # => [3, 1, 8]

  3.times { |j| a[i][j] = row[j] }
  # rowは入力された行（i）の数値が格納された1次元配列
  # rowの列データ（配列に入った各要素）を示すのがj
  # row配列の各要素（列データ）を、ループ外の2次元配列aの i 番目の行の j 番目の列へと代入処理している
end

a.each { |row| puts row.join(' ') } # 2次元配列aをeach文で回す（空白文字で結合して出力）

n = gets.to_i

a = Array.new(n).map { Array.new(3) } # # 列は3行と明示されているので注意

n.times do |i|
  row = gets.split.map(&:to_i)
  3.times { |j| a[i][j] = row[j] } # 列は3行と明示されているので3.timesで指定
end

a.each { |b| puts b.join(' ') }

m = gets.to_i

a = Array.new(3).map { Array.new(m) } # 行は3と明示されているので注意

3.times do |i| # 行は3と明示されているので、3.timesで指定
  row = gets.split.map(&:to_i)
  m.times { |j| a[i][j] = row[j] }
end

a.each { |b| puts b.join(' ') }

n, m = gets.split.map(&:to_i) # 1行目の標準入力で"N M"が与えられているのでそれぞれ変数に代入

a = Array.new(n).map { Array.new(m) }

n.times do |i|
  row = gets.split.map(&:to_i)
  m.times { |j| a[i][j] = row[j] }
end

a.each { |b| puts b.join(' ') }

n = gets.to_i

n.times do
  input = gets.split.map(&:to_i)
  input.shift
  puts input.join(' ')
end

n = gets.to_i

n.times do
  line = gets.split.map(&:to_i)

  values = line.drop(1) # 配列から先頭の要素を除外した新しい配列を作成
  
  puts values.join(' ') # 新しい配列の要素をスペース区切りで出力
end

s = gets.chomp
puts s[0,3] # s[開始位置, 長さ]
puts s.slice(0, 3) # s.slice(開始位置, 長さ)
puts s.chars[0, 3].join # s.chars[開始位置, 長さ]で、["p", "a", "i"]という配列を作り、joinメソッドで結合

a = Array.new(9).map { Array.new(9) }

9.times do |i|
  9.times { |j| a[i][j] = (i + 1) * (j + 1) }
  # 最初に初期化した変数aの2次元配列の、i行目のj列の値を上書きする処理を繰り返す
  # aの配列インデックスにアクセスするためには0~8で指定する必要があるため+1している
  # 9.times { |j| a[i - 1][j - 1] = (i) * (j) }
end

a.each { |row| puts row.join(' ') }

a = Array.new(9).map { Array.new(9) }

(0..8).each do |i|
  (0..8).each { |j| a[i][j] = (i + 1) * (j + 1) }
  # 9.times { |j| a[i][j] = (i + 1) * (j + 1) }でも可
end

a.each { |row| puts row.join(' ') }

(1..9).each do |i|
  row = (1..9).map { |j| i * j }
  puts row.join(' ')
end

# ここでの標準入力は「3」とする
n = gets.to_i # 標準入力「3」を受け取り、nに代入

(1..n).each do |i| # 外側のループ：1〜3を繰り返す
  row = (1..n).map { |j| i * j } # 内側のループ：計算結果をrowに代入
  # 外側1回目のループ（i = 1）：1 * 1, 1 * 2, 1 * 3の計算結果を、mapメソッドで配列化
  # 外側2回目のループ（i = 2）：2 * 1, 2 * 2, 2 * 3の計算結果を、mapメソッドで配列化
  # 外側3回目のループ（i = 3）：3 * 1, 3 * 2, 3 * 3の計算結果を、mapメソッドで配列化
  puts row.join(' ') # 半角スペースで結合して出力
end

N M
A_1 A_2 A_3 ... A_N
B_1 B_2 B_3 ... B_M

A_1 ... A_{B_1}
A_{B_1+1} ... A_{B_1+B_2-1}
A_{B_1+B_2} ... A_{B_1+B_2+B_3-1}
...
A_{B_1+...+B_{M-1}} ... A_{B_1+B_2+...+B_M}

10 4
1 2 3 4 5 6 7 8 9 10
2 6 1 1

1 2
3 4 5 6 7 8
9
10

n, m = gets.split.map(&:to_i)
a = gets.split.map(&:to_i)
b = gets.split.map(&:to_i)

start = 0 # aの開始位置を初期化

b.each do |i|
  puts a[start, i].join(' ') # a[開始位置, 要素の数]
  start += i # putsの実行後に開始位置にiを加算
end

# 処理イメージ
a = [1, 2, 3, 4, 5, 6, 7, 8]
b = [3, 2, 3]
の場合、ループは以下のように動作する。

1回目のループ：i = 3、start = 0、aから [1, 2, 3] を取り出して出力
2回目のループ：i = 2、start = 3（前回のループで更新）、aから[4, 5]を取り出して出力
3回目のループ：i = 3、start = 5（前回のループで更新）、aから [6, 7, 8] を取り出して出力

# 標準入力：0.5362
n =gets.to_f
puts n #=> 0.5362
puts n.round #=> #=> 1
puts n.round(1) #=> 0.5：小数点第2位を四捨五入
puts n.round(2) #=> 0.54：小数点第3位を四捨五入

kuku = Array.new(9) { Array.new(9) }

(0..8).each do |i|
    kuku[i] = (0..8).map { |j| sprintf('%2d', (i + 1) * (j + 1)) }.join(' | ')
end

kuku.each_with_index do |row, index|
  puts row
  puts '=' * row.length if index < 8
end

n = gets.to_i

sum = n * (n + 1) / 2

puts sum

n = gets.to_i

sum = (1..n).reduce(:+) 

puts sum

h, w, a, b = gets.split.map(&:to_i)

row = Array.new(w, "(#{a}, #{b})").join(' | ')

eq_line = '=' * row.length

h.times do |i|
    puts row
    puts eq_line unless i == h - 1
end

(割る値).divmod(割られる値)

n = gets.to_i

human = 0

n.times do |i|
  human += (1 * (i + 1)) # i（カウンタ変数）は0から始まるので+ 1とする
end

puts human

n = gets.to_i
total_people = (n * (n + 1)) / 2
puts total_people

1段目: 1人
2段目: 2人
3段目: 3人

s = gets.chomp
puts s == .upcase ? "YES" : "NO"

s = gets.chomp
i, j = gets.split.map(&:to_i)

puts s[i - 1..j - 1] # [開始位置, 終了位置]

puts s[i - 1, j - 1] # [開始位置, 長さ]