problem_id
stringlengths 6
6
| buggy_code
stringlengths 8
526k
| fixed_code
stringlengths 12
526k
| labels
listlengths 0
15
⌀ | buggy_submission_id
int64 1
1.54M
| fixed_submission_id
int64 2
1.54M
| user_id
stringlengths 10
10
| language
stringclasses 8
values |
|---|---|---|---|---|---|---|---|
p02811
|
k,x = gets.chomp.split(' ').map(&:to_i)
if (500 * x) > y
print 'Yes'
else
print 'No'
end
|
k,x = gets.chomp.split(' ').map(&:to_i)
if (500 * k) >= x
print 'Yes'
else
print 'No'
end
|
[
"control_flow.branch.if.condition.change",
"expression.operation.binary.remove"
] | 610,417
| 610,415
|
u305811972
|
ruby
|
p02811
|
def gli
gets.split.map(&:to_i)
end
A, N = gli
puts (A * 500 >= N) ? :YES : :NO
|
def gli
gets.split.map(&:to_i)
end
A, N = gli
puts (A * 500 >= N) ? :Yes : :No
|
[
"call.arguments.change"
] | 610,842
| 610,843
|
u056083754
|
ruby
|
p02811
|
a,b=gets.split.map(&:to_i)
if 500*a >= b
'Yes'
else
'No'
end
|
a,b=gets.split.map(&:to_i)
puts 500*a >= b ? 'Yes': 'No'
|
[
"call.arguments.change"
] | 610,864
| 610,865
|
u049159332
|
ruby
|
p02811
|
a,b=gets.split.map(&:to_i)
if 500*a >= b
'Yes'
else
'No'
end
|
a,b=gets.split.map(&:to_i)
if 500*a >= b
puts 'Yes'
else
puts 'No'
end
|
[
"io.output.change",
"call.add"
] | 610,864
| 610,866
|
u049159332
|
ruby
|
p02811
|
K,X = gets.chomp.split.map(&:to_i)
totalprice = K * 500
if totalprice >= X
puts 'YES'
else puts 'NO'
end
|
K,X = gets.chomp.split.map(&:to_i)
totalprice = K * 500
if totalprice >= X
puts 'Yes'
else
puts 'No'
end
|
[
"literal.string.change",
"literal.string.case.change",
"call.arguments.change"
] | 610,877
| 610,878
|
u395458577
|
ruby
|
p02811
|
K,X = gets.chomp.split.map(&:to_s)
totalprice = K * 500
if totalprice >= X
puts 'YES'
else puts 'NO'
end
|
K,X = gets.chomp.split.map(&:to_i)
totalprice = K * 500
if totalprice >= X
puts 'Yes'
else
puts 'No'
end
|
[
"assignment.value.change",
"call.arguments.change",
"literal.string.change",
"literal.string.case.change"
] | 610,879
| 610,878
|
u395458577
|
ruby
|
p02811
|
k, x = gets.strip.split.map { |v| v.to_i }
if k * 500 >= x
puts 'YES'
else
puts 'NO'
end
|
k, x = gets.strip.split.map { |v| v.to_i }
if k * 500 >= x
puts 'Yes'
else
puts 'No'
end
|
[
"literal.string.change",
"literal.string.case.change",
"call.arguments.change"
] | 611,152
| 611,153
|
u768135881
|
ruby
|
p02811
|
k, x = gets.split.map &:to_i
p k*500 >= x ? "Yes" : "No"
|
k, x = gets.split.map &:to_i
puts k*500 >= x ? "Yes" : "No"
|
[
"call.function.change",
"io.output.change"
] | 611,196
| 611,197
|
u212567766
|
ruby
|
p02811
|
k,x = gets.chomp.split(" ").map(&:to_i)
if k*500 >= x then
print("yes")
else
print("no")
end
|
k,x = gets.chomp.split(" ").map(&:to_i)
if k*500 >= x then
print("Yes")
else
print("No")
end
|
[
"literal.string.change",
"literal.string.case.change",
"call.arguments.change"
] | 611,286
| 611,287
|
u096860578
|
ruby
|
p02811
|
n, m = gets.split.map(&:to_i)
puts n*500>m ? :Yes : :No
|
n, m = gets.split.map(&:to_i)
puts n*500>=m ? :Yes : :No
|
[
"expression.operator.compare.change",
"control_flow.branch.if.condition.change"
] | 611,464
| 611,465
|
u510556034
|
ruby
|
p02811
|
K, X = gets.split
if (500*X.to_i >= K.to_i)
puts "Yes"
else
puts "No"
end
|
K, X = gets.split
if (500*K.to_i >= X.to_i)
puts "Yes"
else
puts "No"
end
|
[
"control_flow.branch.if.condition.change"
] | 611,794
| 611,795
|
u331086044
|
ruby
|
p02811
|
K, X = gets.split
if (500*X.to_i >= K.to_i)
puts "yes"
else
puts "no"
end
|
K, X = gets.split
if (500*K.to_i >= X.to_i)
puts "Yes"
else
puts "No"
end
|
[
"control_flow.branch.if.condition.change",
"literal.string.change",
"literal.string.case.change",
"call.arguments.change"
] | 611,796
| 611,795
|
u331086044
|
ruby
|
p02811
|
k,x=gets.split.map(&:to_i)
puts 500*k>=x ? 'yes' : 'no'
|
k,x=gets.split.map(&:to_i)
puts 500*k>=x ? 'Yes' : 'No'
|
[
"literal.string.change",
"literal.string.case.change",
"call.arguments.change"
] | 611,814
| 611,815
|
u503270460
|
ruby
|
p02811
|
num, amount = gets.chomp.split(" ").map(&:to_i)
puts "Yes" if amount >= num * 500
puts "No" if amount < num * 500
|
num, amount = gets.chomp.split(" ").map(&:to_i)
puts "Yes" if amount <= num * 500
puts "No" if amount > num * 500
|
[
"misc.opposites",
"expression.operator.compare.change",
"control_flow.branch.if.condition.change"
] | 612,031
| 612,032
|
u647061136
|
ruby
|
p02811
|
K, X = gets.to_i
kK = K.to_i
xX = X.to_i
if kK*500 >= xX
puts "Yes"
else
puts "No"
end
|
K, X = gets.chomp.split
kK = K.to_i
xX = X.to_i
if kK*500 >= xX
puts "Yes"
else
puts "No"
end
|
[
"assignment.value.change",
"identifier.change",
"call.add"
] | 612,080
| 612,081
|
u000424950
|
ruby
|
p02811
|
coin_num, condition = gets.chomp.split('').map(&:to_i)
price = 500 * coin_num
if(price >= condition)
puts 'Yes'
else
puts 'No'
end
|
coin_num, condition = gets.chomp.split(' ').map(&:to_i)
price = 500 * coin_num
if(price >= condition)
puts 'Yes'
else
puts 'No'
end
|
[
"literal.string.change",
"assignment.value.change",
"call.arguments.change"
] | 612,236
| 612,237
|
u608949838
|
ruby
|
p02811
|
line = gets.split(' ').map(&:to_i)
if line[0]*500>line[1] then
puts "Yes"
else
puts "No"
end
|
line = gets.split(' ').map(&:to_i)
if line[0]*500>=line[1] then
puts "Yes"
else
puts "No"
end
|
[
"expression.operator.compare.change",
"control_flow.branch.if.condition.change"
] | 612,410
| 612,411
|
u413184068
|
ruby
|
p02811
|
k,x=gets.chomp.split(" ").map{|s| s.to_i}
if 500*k>=x
puts "Yes"
else
puts "N0"
end
|
k,x=gets.chomp.split(" ").map{|s| s.to_i}
if 500*k>=x
puts "Yes"
else
puts "No"
end
|
[
"literal.string.change",
"call.arguments.change"
] | 612,421
| 612,422
|
u087165202
|
ruby
|
p02811
|
k, x =gets.split;
k = k.to_i;
x = x.to_i;
if (k * 500) >= x
puts "yes"
else
puts "no"
end
|
k, x =gets.split;
k = k.to_i;
x = x.to_i;
if (k * 500) >= x
puts "Yes"
else
puts "No"
end
|
[
"literal.string.change",
"literal.string.case.change",
"call.arguments.change"
] | 612,485
| 612,486
|
u879611390
|
ruby
|
p02812
|
s=gets
p (0...s.size).count{|i|s[i,3]=="ABC"}
|
gets
s=gets
p (0...s.size).count{|i|s[i,3]=="ABC"}
|
[] | 613,451
| 613,452
|
u657913472
|
ruby
|
p02812
|
input = readlines()
n = input.shift.chomp.to_i
s = input.shift.chomp
cnt = 0
list = s.split('')
list.each_with_index do |c, i|
if c == 'c' && i >= 2
cnt += 1 if s[i - 1] == 'b' && s[i - 2] == 'a'
end
end
puts cnt
|
input = readlines()
n = input.shift.chomp.to_i
s = input.shift.chomp
cnt = 0
list = s.split('')
list.each_with_index do |c, i|
if c == 'C' && i >= 2
cnt += 1 if s[i - 1] == 'B' && s[i - 2] == 'A'
end
end
puts cnt
|
[
"misc.typo",
"literal.string.change",
"literal.string.case.change",
"control_flow.branch.if.condition.change"
] | 613,496
| 613,497
|
u810199299
|
ruby
|
p02812
|
n = gets.to_i
s = gets.chomp
p s.split("ABC").length - 1
|
n = gets.to_i
s = gets.chomp
p s.split("ABC", -1).length - 1
|
[
"call.arguments.add"
] | 613,609
| 613,610
|
u354261726
|
ruby
|
p02812
|
n = gets.to_i
s = gets.chomp
puts (s.split("ABC").length) - 1
|
n = gets.to_i
s = gets
puts (s.split("ABC").length) - 1
|
[
"call.remove"
] | 613,683
| 613,684
|
u012110567
|
ruby
|
p02812
|
n = gets.to_i
s = get.chomp
puts (s.split("ABC").length) - 1
|
n = gets.to_i
s = gets
puts (s.split("ABC").length) - 1
|
[
"assignment.value.change",
"call.remove"
] | 613,685
| 613,684
|
u012110567
|
ruby
|
p02812
|
N=gets.to_i
S=gets.chomp
p (S.split("ABC").length) - 1
|
N=gets.to_i
S=gets
p (S.split("ABC").length) - 1
|
[
"call.remove"
] | 613,720
| 613,721
|
u224392861
|
ruby
|
p02812
|
#######################################
def csi(s=gets,spst=" ")
if s==nil
return 0
end
return s.chomp.split(spst).map(&:to_i)
end
def css(s=gets,spst=" ")
if s == nil
raise "nil!"
end
return s.chomp.split(spst).map(&:to_s)
end
def ml(n,datatype=:int)
t = []
case datatype
when :int
n.times do
t.push(gets.to_i)
end
when :str
n.times do
t.push(gets.chomp.to_s)
end
else
raise "n!"
end
end
#######################################
N,S = gets.to_i , gets.chomp
S.scan('ABC').length
|
#######################################
def csi(s=gets,spst=" ")
if s==nil
return 0
end
return s.chomp.split(spst).map(&:to_i)
end
def css(s=gets,spst=" ")
if s == nil
raise "nil!"
end
return s.chomp.split(spst).map(&:to_s)
end
def ml(n,datatype=:int)
t = []
case datatype
when :int
n.times do
t.push(gets.to_i)
end
when :str
n.times do
t.push(gets.chomp.to_s)
end
else
raise "n!"
end
end
#######################################
N,S = gets.to_i , gets.chomp
puts S.scan('ABC').length
|
[
"io.output.change",
"call.add"
] | 613,854
| 613,855
|
u891258088
|
ruby
|
p02812
|
count = gets.to_i
moziretu = gets.to_s
p moziretu.scan('abc').length
|
count = gets.to_i
moziretu = gets.to_s
puts moziretu.scan('ABC').length
|
[
"call.function.change",
"io.output.change",
"literal.string.change",
"literal.string.case.change",
"call.arguments.change"
] | 614,756
| 614,757
|
u223948509
|
ruby
|
p02812
|
gets
p gets.scan(/(ABC)+/).size
|
gets
p gets.scan(/ABC/).size
|
[
"call.arguments.change"
] | 614,938
| 614,939
|
u720281401
|
ruby
|
p02812
|
def main(argv)
n = gets.chomp.to_i
s = gets.chomp
c = 0
(n - 3).times do |i|
if s[i..(i+2)] == 'ABC' then
c += 1
end
end
puts c.to_s
end
if self.to_s == 'main' then
main(ARGV)
end
|
def main(argv)
n = gets.chomp.to_i
s = gets.chomp
c = 0
(n - 2).times do |i|
if s[i..(i+2)] == 'ABC' then
c += 1
end
end
puts c.to_s
end
if self.to_s == 'main' then
main(ARGV)
end
|
[
"literal.number.integer.change",
"expression.operation.binary.change"
] | 615,203
| 615,204
|
u198355306
|
ruby
|
p02812
|
n = gets
s = gets.chomp
puts s.split("ABC").size - 1
|
n = gets
s = gets.chomp
puts s.split("ABC", -1).size - 1
|
[
"call.arguments.add"
] | 615,279
| 615,280
|
u874414087
|
ruby
|
p02813
|
n=gets.to_i
sam1=Array.new(n)
sam2=Array.new(n)
sam1=gets.split.map!(&:to_i)
sam2=gets.split.map!(&:to_i)
kot1=1
kot2=1
kazu1=n
for i in 0..n-2
ans1=1
for j in 1..kazu1
ans1*=j
end
kot1+=ans1/kazu1*(sam1[i]-1)
kazu1-=1
for k in 0..n-1
if sam1[k]>sam1[i]
sam1[k]-=-1
end
end
end
kazu1=n
for i in 0..n-2
ans1=1
for j in 1..kazu1
ans1*=j
end
kot2+=ans1/kazu1*(sam2[i]-1)
kazu1-=1
for k in 0..n-1
if sam2[k]>sam2[i]
sam2[k]-=-1
end
end
end
puts (kot1-kot2).abs
|
n=gets.to_i
sam1=Array.new(n)
sam2=Array.new(n)
sam1=gets.split.map!(&:to_i)
sam2=gets.split.map!(&:to_i)
kot1=1
kot2=1
kazu1=n
for i in 0..n-2
ans1=1
for j in 1..kazu1
ans1*=j
end
kot1+=ans1/kazu1*(sam1[i]-1)
kazu1-=1
for k in 0..n-1
if sam1[k]>sam1[i]
sam1[k]-=1
end
end
end
kazu1=n
for i in 0..n-2
ans1=1
for j in 1..kazu1
ans1*=j
end
kot2+=ans1/kazu1*(sam2[i]-1)
kazu1-=1
for k in 0..n-1
if sam2[k]>sam2[i]
sam2[k]-=1
end
end
end
puts (kot1-kot2).abs
|
[
"expression.operation.unary.arithmetic.remove"
] | 615,456
| 615,457
|
u977506075
|
ruby
|
p02813
|
n=gets.to_i
sam1=Array.new(n)
sam2=Array.new(n)
sam1=gets.split.map!(&:to_i)
sam2=gets.split.map!(&:to_i)
#数列をint型に変更
kot1=1#sam1
kot2=1#sam2
wai1=0
wai2=0
kazu1=n
kazu2=n
for i in 0..n-2
ans1=1
for j in 1..kazu1
ans1=ans1*j
end#ans1=nの階上
kot1+=ans1/kazu1*(sam1[i]-1)#ans1にnの階上を入力 ２の階上で終了にする
kazu1=kazu1-1
for k in 0..n-1
if sam1[k]>sam1[i]
sam1[k]=sam1[k]-1#大きい数を1小さくする
end
end
end
puts kot1
for i in 0..n-2
ans2=1
for j in 1..kazu2
ans2=ans2*j
end#ans1=nの階上
kot2+=ans2/kazu2*(sam2[i]-1)#ans1にnの階上を入力 ２の階上で終了にする
kazu2=kazu2-1
for k in 0..n-1
if sam2[k]>sam2[i]
sam2[k]=sam2[k]-1#大きい数を1小さくする
end
end
end
puts kot2
puts (kot1-kot2).abs
|
n=gets.to_i
sam1=Array.new(n)
sam2=Array.new(n)
sam1=gets.split.map!(&:to_i)
sam2=gets.split.map!(&:to_i)
#数列をint型に変更
kot1=1#sam1
kot2=1#sam2
wai1=0
wai2=0
kazu1=n
kazu2=n
for i in 0..n-2
ans1=1
for j in 1..kazu1
ans1=ans1*j
end#ans1=nの階上
kot1+=ans1/kazu1*(sam1[i]-1)#ans1にnの階上を入力 ２の階上で終了にする
kazu1=kazu1-1
for k in 0..n-1
if sam1[k]>sam1[i]
sam1[k]=sam1[k]-1#大きい数を1小さくする
end
end
end
for i in 0..n-2
ans2=1
for j in 1..kazu2
ans2=ans2*j
end#ans1=nの階上
kot2+=ans2/kazu2*(sam2[i]-1)#ans1にnの階上を入力 ２の階上で終了にする
kazu2=kazu2-1
for k in 0..n-1
if sam2[k]>sam2[i]
sam2[k]=sam2[k]-1#大きい数を1小さくする
end
end
end
puts (kot1-kot2).abs
|
[
"call.remove"
] | 615,458
| 615,459
|
u977506075
|
ruby
|
p02813
|
n = gets.to_i
a = [*1..n].permutation.map(&:join)
p = gets.split.map(&:to_i).join
q = gets.split.map(&:to_i).join
puts (a.find_index(p) - a.find_index(q)).ab
|
n = gets.to_i
a = [*1..n].permutation.map(&:join)
p = gets.split.map(&:to_i).join
q = gets.split.map(&:to_i).join
puts (a.find_index(p) - a.find_index(q)).abs
|
[
"identifier.change",
"call.arguments.change",
"io.output.change"
] | 615,863
| 615,864
|
u889326464
|
ruby
|
p02813
|
# matrixの基本操作
def same_el(array_)
if array_.kind_of?(Array)
output = []
for i in 0..(array_.count-1)
output.push(array_[i])
end
end
return output
end
# ---------------------------------------------
def replace(n)
sgn=[]
remain=[]
output=[] #n!個の要素を持つ配列を返す
for i in 0..n
sgn << i
remain << i
end
output << []
for i in 0..n
output[0] << i
end
while true
remain_act = same_el(remain)
remain_act.delete(0)
for i in 1..n-1
judge_order = true
for j in i+1..n-1
sgn[j]<sgn[j+1] && judge_order = false
end
judge_order && break
remain_act.delete(sgn[i])
end
singular = i
remain_act.sort!
for i in 0..n-(singular-2)
if sgn[singular] == remain_act[i]
sgn[singular] = remain_act[i+1]
break
end
end
remain_act.delete(sgn[singular])
for i in singular+1..n
sgn[i] = remain_act[i-(singular+1)]
end
inp =same_el(sgn)
output << inp
lastmat=true
for i in 1..n
sgn[i] != n+1-i && lastmat=false
end
lastmat && break
end
for i in 0..output.count-1
output[i].delete(0)
end
output
end
# ---------------------------------------------
def signal(replaces)
output = Array.new
index = Array.new
replace.size.times do |i|
for j in 0..replaces.size-1
index[j] = j+1
end
i_op = i.clone
while true
j = 0
nimotu = index[0]
sgn_part = -1
while true
if i_op[j] == nimotu
else
end
end
end
output << sgn
end
end
# ---------------------------------------------
class Matrix
attr_accessor :matrix
def initialize(matrix)
@matrix = matrix
end
def self.times(matA,matB)
if !matA.kind_of?(Matrix) || !matB.kind_of?(Matrix)
return nil
end
if matA.size_mat[0] != matB.size_mat[1]
return nil
end
sumcount = matA.size_mat[1]
output =[]
for i in 0 .. matA.size_mat[0]-1
output.push([])
end
for i in 0 .. matA.size_mat[0]-1
for j in 0 .. matB.size_mat[1]-1
sum = 0
for k in 0 .. sumcount-1
sum += matA.matrix[i][k] * matB.matrix[k][j]
end
output[i].push(sum)
end
end
return self.new(output)
end
def size_mat
return [self.matrix.length,self.matrix[0].length]
end
def display
digits_max = 1
for i in 0..self.matrix.length-1
for j in 0..self.matrix[i].length-1
if self.matrix[i][j]!=0
digits = Math.log10(self.matrix[i][j].abs).to_i+1
else
digits=1
end
if digits_max < digits
digits_max = digits
end
end
end
for i in 0..self.matrix.length-1
digits = 0
for j in 0..self.matrix[i].length-1
if j != self.matrix[i].length-1
if self.matrix[i][j]!=0
digits = Math.log10(self.matrix[i][j].abs).to_i+1
else
digits=1
end
print "#{self.matrix[i][j]} "+" "*(digits_max - digits)
else
print "#{self.matrix[i][j]}\n"
end
end
end
end
end
N=gets.to_i
ar=replace(n)
ps=gets.split.map(&:to_i)
qs=gets.split.map(&:to_i)
p (ar.index(ps)-ar.index(qs)).abs
|
# matrixの基本操作
def same_el(array_)
if array_.kind_of?(Array)
output = []
for i in 0..(array_.count-1)
output.push(array_[i])
end
end
return output
end
# ---------------------------------------------
def replace(n)
sgn=[]
remain=[]
output=[] #n!個の要素を持つ配列を返す
for i in 0..n
sgn << i
remain << i
end
output << []
for i in 0..n
output[0] << i
end
while true
remain_act = same_el(remain)
remain_act.delete(0)
for i in 1..n-1
judge_order = true
for j in i+1..n-1
sgn[j]<sgn[j+1] && judge_order = false
end
judge_order && break
remain_act.delete(sgn[i])
end
singular = i
remain_act.sort!
for i in 0..n-(singular-2)
if sgn[singular] == remain_act[i]
sgn[singular] = remain_act[i+1]
break
end
end
remain_act.delete(sgn[singular])
for i in singular+1..n
sgn[i] = remain_act[i-(singular+1)]
end
inp =same_el(sgn)
output << inp
lastmat=true
for i in 1..n
sgn[i] != n+1-i && lastmat=false
end
lastmat && break
end
for i in 0..output.count-1
output[i].delete(0)
end
output
end
# ---------------------------------------------
def signal(replaces)
output = Array.new
index = Array.new
replace.size.times do |i|
for j in 0..replaces.size-1
index[j] = j+1
end
i_op = i.clone
while true
j = 0
nimotu = index[0]
sgn_part = -1
while true
if i_op[j] == nimotu
else
end
end
end
output << sgn
end
end
# ---------------------------------------------
class Matrix
attr_accessor :matrix
def initialize(matrix)
@matrix = matrix
end
def self.times(matA,matB)
if !matA.kind_of?(Matrix) || !matB.kind_of?(Matrix)
return nil
end
if matA.size_mat[0] != matB.size_mat[1]
return nil
end
sumcount = matA.size_mat[1]
output =[]
for i in 0 .. matA.size_mat[0]-1
output.push([])
end
for i in 0 .. matA.size_mat[0]-1
for j in 0 .. matB.size_mat[1]-1
sum = 0
for k in 0 .. sumcount-1
sum += matA.matrix[i][k] * matB.matrix[k][j]
end
output[i].push(sum)
end
end
return self.new(output)
end
def size_mat
return [self.matrix.length,self.matrix[0].length]
end
def display
digits_max = 1
for i in 0..self.matrix.length-1
for j in 0..self.matrix[i].length-1
if self.matrix[i][j]!=0
digits = Math.log10(self.matrix[i][j].abs).to_i+1
else
digits=1
end
if digits_max < digits
digits_max = digits
end
end
end
for i in 0..self.matrix.length-1
digits = 0
for j in 0..self.matrix[i].length-1
if j != self.matrix[i].length-1
if self.matrix[i][j]!=0
digits = Math.log10(self.matrix[i][j].abs).to_i+1
else
digits=1
end
print "#{self.matrix[i][j]} "+" "*(digits_max - digits)
else
print "#{self.matrix[i][j]}\n"
end
end
end
end
end
N=gets.to_i
ar=replace(N)
ps=gets.split.map(&:to_i)
qs=gets.split.map(&:to_i)
p (ar.index(ps)-ar.index(qs)).abs
|
[
"assignment.value.change",
"call.arguments.change"
] | 615,914
| 615,915
|
u926099741
|
ruby
|
p02812
|
a=gets.chomp.to_i
b=gets.chomp
c=b.scan("ABC")
puts c
|
a=gets.chomp.to_i
b=gets.chomp
c=b.scan("ABC")
puts c.length
|
[
"call.add"
] | 616,047
| 616,048
|
u175113369
|
ruby
|
p02812
|
num = gets
character = gets
p character.count("ABC")
|
num = gets
character = gets
p character.scan("ABC").length
|
[
"identifier.change",
"call.arguments.change",
"call.add"
] | 616,121
| 616,122
|
u201441274
|
ruby
|
p02813
|
n = gets.to_i
p = gets.split.map(&:to_i)
q = gets.split.map(&:to_i)
i = 0
p_i,q_i = nil,nil
ary = (1..n).to_a.permutation(n)
ary.each_with_index do |item,i|
p_i = i if item == p
q_i = i if item == q
end
puts (pi-qi).abs
|
n = gets.to_i
p = gets.split.map(&:to_i)
q = gets.split.map(&:to_i)
i = 0
p_i,q_i = nil,nil
ary = (1..n).to_a.permutation(n)
ary.each_with_index do |item,i|
p_i = i if item == p
q_i = i if item == q
end
puts (p_i-q_i).abs
|
[
"identifier.change",
"call.arguments.change",
"expression.operation.binary.change",
"io.output.change"
] | 616,160
| 616,161
|
u585819925
|
ruby
|
p02813
|
n = gets.to_i;
p_array = gets.split.map{|n| n.to_i };
q_array = gets.split.map{|n| n.to_i };
junretu_before = []
ans = 0
count = 0
(1..n).each do |x|
junretu_before.push(x.to_i)
end
junretu_before.permutation do |x|
count+=1
if p_array == x
a = count
end
if q_array == x
b = count
end
end
ans = (a -b).abs
puts ans
|
n = gets.to_i;
p_array = gets.split.map{|n| n.to_i };
q_array = gets.split.map{|n| n.to_i };
junretu_before = []
a = 0
b = 0
ans = 0
count = 0
(1..n).each do |x|
junretu_before.push(x.to_i)
end
junretu_before.permutation do |x|
count+=1
if p_array == x
a = count
end
if q_array == x
b = count
end
end
ans = (a -b).abs
puts ans
|
[
"assignment.add"
] | 616,320
| 616,321
|
u879611390
|
ruby
|
p02814
|
def solve(lscm,m)
# least semi common multiple
return ( m / lscm + 1 ) / 2
end
n, m = gets.split.map(&:to_i)
a = gets.split.map(&:to_i)
b = a.map do |k|
res = 0
while k.even?
k /= 2
res += 1
end
# p res
end
# p a
# p b
ans = 0
if b.uniq.size == 1
lscm = a.map{|k| k/2}.inject(:lcm)
# p lscm
# p a
# p b
ans = solve(lscm, m)
end
puts ans
# a/2 * (2p+1)
|
def solve(lscm,m)
# least semi common multiple
return ( m / lscm + 1 ) / 2
end
n, m = gets.split.map(&:to_i)
a = gets.split.map(&:to_i)
b = a.map do |k|
res = 0
while k.even?
k /= 2
res += 1
end
res
end
# p a
# p b
ans = 0
if b.uniq.size == 1
lscm = a.map{|k| k/2}.inject(:lcm)
# p lscm
# p a
# p b
ans = solve(lscm, m)
end
puts ans
# a/2 * (2p+1)
|
[] | 616,625
| 616,626
|
u693378622
|
ruby
|
p02814
|
def solve(lscm,m)
# least semi common multiple
return ( m / lscm + 1 ) / 2
end
n, m = gets.split.map(&:to_i)
a = gets.split.map(&:to_i)
b = a.map do |k|
res = 0
if k.even?
k /= 2
res += 1
end
end
ans = 0
if b.uniq.size == 1
lscm = a.map{|k| k/2}.inject(:lcm)
ans = solve(lscm, m)
end
puts ans
# a/2 * (2p+1)
|
def solve(lscm,m)
# least semi common multiple
return ( m / lscm + 1 ) / 2
end
n, m = gets.split.map(&:to_i)
a = gets.split.map(&:to_i)
b = a.map do |k|
res = 0
while k.even?
k /= 2
res += 1
end
res
end
# p a
# p b
ans = 0
if b.uniq.size == 1
lscm = a.map{|k| k/2}.inject(:lcm)
# p lscm
# p a
# p b
ans = solve(lscm, m)
end
puts ans
# a/2 * (2p+1)
|
[
"control_flow.branch.while.replace.add",
"control_flow.loop.if.replace.remove"
] | 616,627
| 616,626
|
u693378622
|
ruby
|
p02814
|
require 'prime'
class Array
def lcm
inject(:lcm)
end
def gcd
inject(:gcd)
end
end
N, M = gets.split(' ').map(&:to_i)
nums = gets.split(' ').map(&:to_i).uniq
# p nums
prm = Prime.prime_division(nums[0])[0][1]
nums.each do |num|
if prm != Prime.prime_division(num)[0][1]
puts 0
exit
end
end
lcm = nums.lcm
puts lcm
puts (M-lcm.div(2)).div(lcm)+1
|
require 'prime'
class Array
def lcm
inject(:lcm)
end
def gcd
inject(:gcd)
end
end
N, M = gets.split(' ').map(&:to_i)
nums = gets.split(' ').map(&:to_i).uniq
# p nums
prm = Prime.prime_division(nums[0])[0][1]
nums.each do |num|
if prm != Prime.prime_division(num)[0][1]
puts 0
exit
end
end
lcm = nums.lcm
# puts lcm
puts (M-lcm.div(2)).div(lcm)+1
|
[
"call.remove"
] | 617,166
| 617,167
|
u808757777
|
ruby
|
p02814
|
_, m = gets.split.map(&:to_i)
a = gets.split.map(&:to_i).uniq.map { |x| x / 2 }
x = a.inject(&:lcm)
unless a.all? { |i| (x / i).even? }
puts 0
exit 0
end
count = (m >= x ? 1 : 0) + (m - x) / (2 * x)
puts count < 0 ? 0 : count
|
_, m = gets.split.map(&:to_i)
a = gets.split.map(&:to_i).uniq.map { |x| x / 2 }
x = a.inject(&:lcm)
if a.any? { |i| (x / i).even? }
puts 0
exit 0
end
count = (m >= x ? 1 : 0) + (m - x) / (2 * x)
puts count < 0 ? 0 : count
|
[
"identifier.change"
] | 617,537
| 617,538
|
u604352408
|
ruby
|
p02814
|
n,m = gets.split.map(&:to_i)
a = gets.split.map(&:to_i)
mul = 1
while a.index{|v| v.odd?}.nil?
a.map!{|v| v/2}
mul *= 2
end
if a.all?{|v| v.odd?}
minX = mul / 2
a.each do |v|
minX = minX.lcm(v)
if minX > m
p 0
exit
end
end
ans = (m / minX + 1) / 2
p ans
else
p 0
end
|
n,m = gets.split.map(&:to_i)
a = gets.split.map(&:to_i)
mul = 1
while a.index{|v| v.odd?}.nil?
a.map!{|v| v/2}
mul *= 2
end
if mul > 1 && a.all?{|v| v.odd?}
minX = mul / 2
a.each do |v|
minX = minX.lcm(v)
if minX > m
p 0
exit
end
end
ans = (m / minX + 1) / 2
p ans
else
p 0
end
|
[
"control_flow.branch.if.condition.change"
] | 617,643
| 617,644
|
u123276241
|
ruby
|
p02817
|
puts gets.split.join
|
puts gets.split.reverse.join
|
[
"call.add"
] | 618,036
| 618,037
|
u358554431
|
ruby
|
p02817
|
p gets.split.join
|
puts gets.split.reverse.join
|
[
"call.function.change",
"io.output.change",
"call.add"
] | 618,038
| 618,037
|
u358554431
|
ruby
|
p02817
|
S,T = gets.strip.split.map(&:to_s)
puts S+T
|
S,T = gets.strip.split.map(&:to_s)
puts T+S
|
[
"expression.operation.binary.remove"
] | 618,073
| 618,074
|
u313103408
|
ruby
|
p02817
|
p gets.split("\s").reverse.join
|
puts gets.split("\s").reverse.join
|
[
"call.function.change",
"io.output.change"
] | 618,429
| 618,430
|
u458429268
|
ruby
|
p02817
|
puts gets.chomp.split(" ").join
|
puts gets.chomp.split(" ").reverse.join
|
[
"call.add"
] | 618,444
| 618,445
|
u409390792
|
ruby
|
p02817
|
a,b = gets.strip.split.map(&:to_s)
p b + a
|
a,b = gets.strip.split.map(&:to_s)
puts b + a
|
[
"call.function.change",
"io.output.change"
] | 618,446
| 618,447
|
u811445854
|
ruby
|
p02817
|
s, t = gets.chomp.split
puts s + t
|
s, t = gets.chomp.split
puts t + s
|
[
"expression.operation.binary.remove"
] | 618,551
| 618,552
|
u641383521
|
ruby
|
p02817
|
s, t = gets.split
puts s + t
|
s, t = gets.chomp.split
puts t + s
|
[
"call.add",
"expression.operation.binary.remove"
] | 618,553
| 618,552
|
u641383521
|
ruby
|
p02817
|
s, t = gets.split
puts s + t
|
s, t = gets.chomp.split
puts t + s
|
[
"call.add",
"expression.operation.binary.remove"
] | 618,553
| 618,554
|
u641383521
|
ruby
|
p02817
|
s, t = gets.split
puts s + t
|
s, t = gets.split
puts t + s
|
[
"expression.operation.binary.remove"
] | 618,553
| 618,555
|
u641383521
|
ruby
|
p02817
|
a=gets.chomp.split
puts "#{a[1]} #{a[0]}"
|
a=gets.chomp.split
puts "#{a[1]}#{a[0]}"
|
[
"literal.string.change",
"call.arguments.change"
] | 618,784
| 618,785
|
u175113369
|
ruby
|
p02817
|
S, T = gets.chomp.split.map(&:to_s)
puts S + T
|
S, T = gets.chomp.split.map(&:to_s)
puts T + S
|
[
"expression.operation.binary.remove"
] | 618,834
| 618,835
|
u395458577
|
ruby
|
p02817
|
s,t = gets.chomp.split
puts s + t
|
s,t = gets.chomp.split
puts (t + s)
|
[
"call.arguments.change",
"expression.operation.binary.change"
] | 618,840
| 618,841
|
u895926909
|
ruby
|
p02817
|
s, t = gets.split(" ").map(&:to_s)
puts s + t
|
s, t = gets.split(" ").map(&:to_s)
puts t + s
|
[
"expression.operation.binary.remove"
] | 618,954
| 618,955
|
u928941036
|
ruby
|
p02817
|
p gets.strip.split.reverse.join
|
puts gets.strip.split.reverse.join
|
[
"call.function.change",
"io.output.change"
] | 619,035
| 619,036
|
u784751818
|
ruby
|
p02816
|
ARG_N = gets.to_i
ARG_a = gets.split.map(&:to_i)
ARG_b = gets.split.map(&:to_i)
xa, xb = Array.new(ARG_N), Array.new(ARG_N)
i = 0
OVER = 2**31
while i < ARG_N do
xa[i] = ARG_a[i] ^ ARG_a[i-1]
xb[i] = ARG_b[i] ^ ARG_b[i-1]
i+=1
end
xa += xa
results = []
def kmp_table arr
result = Array.new(arr.length)
result[0] = 0
j = 0
1.upto(arr.length-1) do |i|
result[i] = j
if arr[i] == arr[j]
j+=1
else
j= 0
end
end
result[arr.length] = j
result
end
table = kmp_table(xb)
# p xb
# p table
i = 1
j = 0
while i < ARG_N * 2 do
# p [i,j]
if xa[i] == xb[j]
i+=1
j+=1
elsif j == 0
i+=1
else
j = table[j]
end
if j == ARG_N
r = (i-j) % ARG_N
results.push([r, ARG_a[r]^ARG_b[0]])
j = table[j]
end
end
results.each do |re|
puts "#{re[0]} #{re[1]}"
end
|
ARG_N = gets.to_i
ARG_a = gets.split.map(&:to_i)
ARG_b = gets.split.map(&:to_i)
xa, xb = Array.new(ARG_N), Array.new(ARG_N)
i = 0
OVER = 2**31
while i < ARG_N do
xa[i] = ARG_a[i] ^ ARG_a[i-1]
xb[i] = ARG_b[i] ^ ARG_b[i-1]
i+=1
end
xa += xa
results = []
def kmp_table arr
result = Array.new(arr.length)
result[0] = 0
j = 0
1.upto(arr.length-1) do |i|
result[i] = j
if arr[i] == arr[j]
j+=1
else
j= 0
end
end
result[arr.length] = j
result
end
table = kmp_table(xb)
# p xb
# p table
i = 0
j = 0
while i < (ARG_N * 2) -1 do
# p [i,j]
if xa[i] == xb[j]
i+=1
j+=1
elsif j == 0
i+=1
else
j = table[j]
end
if j == ARG_N
r = (i-j) % ARG_N
results.push([r, ARG_a[r]^ARG_b[0]])
j = table[j]
end
end
results.each do |re|
puts "#{re[0]} #{re[1]}"
end
|
[
"literal.number.integer.change",
"assignment.value.change"
] | 619,094
| 619,095
|
u299761130
|
ruby
|
p02817
|
s,t = gets.split.chomp
puts t+s
|
#!/usr/bin/ruby
s,t = gets.split
puts t+s
|
[
"call.remove"
] | 619,381
| 619,382
|
u998741086
|
ruby
|
p02817
|
s,t = $stdin.gets.split
p "#{t}#{s}"
|
s,t = gets.split
puts "#{t}#{s}"
|
[
"call.remove",
"call.function.change",
"io.output.change"
] | 619,602
| 619,603
|
u727493827
|
ruby
|
p02817
|
S, T = gets.split
puts S + T
|
S, T = gets.split
puts T + S
|
[
"expression.operation.binary.remove"
] | 619,922
| 619,923
|
u112504572
|
ruby
|
p02817
|
i = gets.split
put i.reverse.join("")
|
i = gets.split
puts i.reverse.join("")
|
[
"misc.typo",
"identifier.change"
] | 619,957
| 619,958
|
u393913844
|
ruby
|
p02817
|
line = gets.split(' ')
puts line.join
|
line = gets.split(' ')
line.reverse!
puts line.join
|
[
"call.add"
] | 620,239
| 620,240
|
u413184068
|
ruby
|
p02817
|
s, t = gets.split(' ')
puts "#{s}#{t}"
|
s, t = gets.split(' ')
puts "#{t}#{s}"
|
[
"literal.string.change",
"call.arguments.change"
] | 620,312
| 620,313
|
u866325115
|
ruby
|
p02817
|
s, t = gets.split
puts "#{s}#{t}"
|
s, t = gets.split(' ')
puts "#{t}#{s}"
|
[
"call.arguments.add",
"literal.string.change",
"call.arguments.change"
] | 620,314
| 620,313
|
u866325115
|
ruby
|
p02818
|
a,b,c=gets.split.map(&:to_i)
if a<c
c-=a
a=0
p c
if b<c
b=0
else
b-=c
end
else
a-=c
end
puts [a,b].join ' '
|
a,b,c=gets.split.map(&:to_i)
if a<c
c-=a
a=0
if b<c
b=0
else
b-=c
end
else
a-=c
end
puts [a,b].join ' '
|
[
"call.remove"
] | 620,652
| 620,653
|
u966810027
|
ruby
|
p02818
|
a,b,c=gets.split.map(&:to_i)
if a<c
a=0
c-=a
if b<c
b=0
else
b-=c
end
else
a-=c
end
puts [a,b].join ' '
|
a,b,c=gets.split.map(&:to_i)
if a<c
c-=a
a=0
if b<c
b=0
else
b-=c
end
else
a-=c
end
puts [a,b].join ' '
|
[
"assignment.remove",
"assignment.add"
] | 620,654
| 620,653
|
u966810027
|
ruby
|
p02818
|
def abc_149_bb
a,b,k = gets.chomp.split(/\s/).map{|x| x.to_i}
if a >= k
a -= k
k = 0
else
k -= a
a = 0
end
if b >= k
b -= k
else
b -= (k - b)
end
print "#{a} #{b}\n"
end
abc_149_bb
|
def abc_149_bb
a,b,k = gets.chomp.split(/\s/).map{|x| x.to_i}
if a >= k
a -= k
k = 0
else
k -= a
a = 0
end
if b >= k
b -= k
else
#b -= (k - b)
b = 0
end
print "#{a} #{b}\n"
end
abc_149_bb
|
[] | 620,804
| 620,805
|
u510887956
|
ruby
|
p02818
|
def abc_149_bb
a,b,k = gets.chomp.split(/\s/).map{|x| x.to_i}
if a >= k
a -= k
k = 0
else
k -= a
a = 0
end
if b >= k
b -= k
end
print "#{a} #{b}\n"
end
abc_149_bb
|
def abc_149_bb
a,b,k = gets.chomp.split(/\s/).map{|x| x.to_i}
if a >= k
a -= k
k = 0
else
k -= a
a = 0
end
if b >= k
b -= k
else
#b -= (k - b)
b = 0
end
print "#{a} #{b}\n"
end
abc_149_bb
|
[
"assignment.add"
] | 620,806
| 620,805
|
u510887956
|
ruby
|
p02818
|
a, b, c = gets.chomp.split(" ").map(&:to_i)
a2 = 0
b2 = 0
if a >= c
a2 = c - a
print a2
print " "
puts b
elsif a < c
if b <= c - a
print a2
print " "
puts b2
else
b2 = b - (c - a)
print a2
print " "
puts b2
end
end
|
a, b, c = gets.chomp.split(" ").map(&:to_i)
a2 = 0
b2 = 0
if a >= c
a2 = a - c
print a2
print " "
puts b
elsif a < c
if b <= c - a
print a2
print " "
puts b2
else
b2 = b - (c - a)
print a2
print " "
puts b2
end
end
|
[
"expression.operation.binary.remove"
] | 620,911
| 620,912
|
u096381099
|
ruby
|
p02818
|
a, b, c = gets.chomp.split(" ").map(&:to_i)
a2 = 0
b2 = 0
if a >= c
a2 = c - a
print a2
print " "
puts b
elsif a < c
if b < c - a
print a2
print " "
puts b2
else
b2 = b - (c - a)
print a2
print " "
puts b2
end
end
|
a, b, c = gets.chomp.split(" ").map(&:to_i)
a2 = 0
b2 = 0
if a >= c
a2 = a - c
print a2
print " "
puts b
elsif a < c
if b <= c - a
print a2
print " "
puts b2
else
b2 = b - (c - a)
print a2
print " "
puts b2
end
end
|
[
"expression.operation.binary.remove",
"expression.operator.compare.change",
"control_flow.branch.if.condition.change"
] | 620,913
| 620,912
|
u096381099
|
ruby
|
p02818
|
def get_i() #空白区切の入力を数値(整数)の配列で返す
return gets.chomp.split(" ").map(&:to_i)
end
def get_f() #空白区切の入力を数値(実数)の配列で返す
return gets.chomp.split(" ").map(&:to_f)
end
def get() #空白区切の入力を文字列の配列で返す
return gets.chomp.split(" ")
end
def get_nsp() #入力されたものを一文字ずつに区切った文字列の配列で返す
return gets.chomp.split("")
end
def yn_judge(bool,y="Yes",n="No") #boolに真偽を投げることで、trueならy、falseならnの値を出力する
return bool ? y : n
end
def array(size1,init=nil,size2=-1) #size2に二次元配列時の最初の要素数、size1に次の配列の大きさ、initに初期値を投げることでその配列を返す
if size2==-1
return Array.new(size1){init}
else
return Array.new(size2){Array.new(size1){init}}
end
end
a,b,k=get_i
if a-k<0
k-=a
a=0
b-=k
end
b=0 if b<0
puts [a,b].join(" ")
|
def get_i() #空白区切の入力を数値(整数)の配列で返す
return gets.chomp.split(" ").map(&:to_i)
end
def get_f() #空白区切の入力を数値(実数)の配列で返す
return gets.chomp.split(" ").map(&:to_f)
end
def get() #空白区切の入力を文字列の配列で返す
return gets.chomp.split(" ")
end
def get_nsp() #入力されたものを一文字ずつに区切った文字列の配列で返す
return gets.chomp.split("")
end
def yn_judge(bool,y="Yes",n="No") #boolに真偽を投げることで、trueならy、falseならnの値を出力する
return bool ? y : n
end
def array(size1,init=nil,size2=-1) #size2に二次元配列時の最初の要素数、size1に次の配列の大きさ、initに初期値を投げることでその配列を返す
if size2==-1
return Array.new(size1){init}
else
return Array.new(size2){Array.new(size1){init}}
end
end
a,b,k=get_i
if a-k<0
k-=a
a=0
b-=k
else
a-=k
end
b=0 if b<0
puts [a,b].join(" ")
|
[] | 621,050
| 621,051
|
u415400221
|
ruby
|
p02818
|
a, b, k = gets.split.map(&:to_i)
if k <= a
puts "#{a - k} b"
elsif k <= a + b
puts "0 #{b + a - k}"
else
puts '0 0'
end
|
a, b, k = gets.split.map(&:to_i)
if k <= a
puts "#{a - k} #{b}"
elsif k <= a + b
puts "0 #{b + a - k}"
else
puts '0 0'
end
|
[
"literal.string.change",
"call.arguments.change"
] | 621,330
| 621,331
|
u183175308
|
ruby
|
p02818
|
a0, b0, k = gets.split(' ').map(&:to_i)
if a0 >= k
a = a0 - k
k = 0
else
a = 0
k = k - a0
end
if k > 0
b = b0 - k
end
b = 0 if b < 0
puts "#{a} #{b}"
|
a0, b0, k = gets.split(' ').map(&:to_i)
if a0 >= k
a = a0 - k
k = 0
else
a = 0
k = k - a0
end
b = b0 - k
b = 0 if b < 0
puts "#{a} #{b}"
|
[] | 621,910
| 621,911
|
u110341137
|
ruby
|
p02818
|
a,b,c=gets.split.map(&:to_i)
if c<=a
puts [a-c,b].join(" ")
else
puts [0,[b-a+c,0].max].join(" ")
end
|
a,b,c=gets.split.map(&:to_i)
if c<=a
puts [a-c,b].join(" ")
else
puts [0,[b-c+a,0].max].join(" ")
end
|
[
"expression.operation.binary.remove"
] | 622,054
| 622,055
|
u926099741
|
ruby
|
p02818
|
a,b,k=gets.split.map &:to_i
resa=a
resb=b
if a <= k
resb=b+(a-k)
resa=0
resb=0 if resb < 0
elsif a+1 > k
rsea=a-k
end
puts [resa,resb].join(' ')
|
a,b,k=gets.split.map &:to_i
resa=a
resb=b
if a <= k
resb=b+(a-k)
resa=0
resb=0 if resb < 0
elsif a+1 > k
resa=a-k
end
puts [resa,resb].join(' ')
|
[
"assignment.variable.change",
"identifier.change"
] | 622,571
| 622,573
|
u630043039
|
ruby
|
p02818
|
a, b, k = gets.split.map(&:to_i)
if a >= k
puts "#{k-a} #{b}"
else
if a+b >= k
puts "0 #{b-k+a}"
else
puts "0 0"
end
end
|
a, b, k = gets.split.map(&:to_i)
if a >= k
puts "#{a-k} #{b}"
else
if a+b >= k
puts "0 #{b-k+a}"
else
puts "0 0"
end
end
|
[
"literal.string.change",
"call.arguments.change"
] | 623,021
| 623,022
|
u326891688
|
ruby
|
p02819
|
require 'prime'
target=gets.to_i
puts Prime.find {|p| p > target }
|
require 'prime'
target=gets.to_i
puts Prime.find {|p| p >= target }
|
[
"expression.operator.compare.change",
"call.arguments.change",
"expression.operation.binary.change",
"io.output.change"
] | 624,063
| 624,064
|
u562148988
|
ruby
|
p02819
|
input = gets.chomp.to_i
ans = 0
#2の倍数かどうかのフラグ
isBinary = false
while true do
#素数の確認は半分で良い
#素数かどうかのフラグ
flag = true
(Math.sqrt(input) + 1).times do |i|
next if i <= 1
if input != i && input % i == 0
#素数でない場合
flag = false
break
end
end
if flag
ans = input
break
end
#isBinaryがtrueの場合は１つ飛ばしにする
if isBinary
input += 2
next
end
if input % 2 == 0
input += 1
isBinary = true
next
end
input += 1
end
puts ans
|
input = gets.chomp.to_i
ans = 0
#2の倍数かどうかのフラグ
isBinary = false
while true do
#素数の確認は半分で良い
#素数かどうかのフラグ
flag = true
(Math.sqrt(input).to_i + 1).times do |i|
next if i <= 1
if input != i && input % i == 0
#素数でない場合
flag = false
break
end
end
if flag
ans = input
break
end
#isBinaryがtrueの場合は１つ飛ばしにする
if isBinary
input += 2
next
end
if input % 2 == 0
input += 1
isBinary = true
next
end
input += 1
end
puts ans
|
[
"call.add"
] | 624,200
| 624,201
|
u541032448
|
ruby
|
p02819
|
N=gets.to_i
(N+1).upto(100003) do |i|
ri=i**(1/2.0)
flag=true
2.upto(ri) do |j|
flag=false if i%j==0
end
if flag
puts i
exit
end
end
|
N=gets.to_i
(N).upto(100003) do |i|
ri=i**(1/2.0)
flag=true
2.upto(ri) do |j|
flag=false if i%j==0
end
if flag
puts i
exit
end
end
|
[
"expression.operation.binary.remove"
] | 624,238
| 624,239
|
u926099741
|
ruby
|
p02819
|
# coding: utf-8
X = gets.to_i
require 'prime'
ptbl = []
Prime.each(10e5) do |e|
ptbl.push e
end
i = ptbl.bsearch_index {|e| e > X}
puts ptbl[i]
|
# coding: utf-8
X = gets.to_i
require 'prime'
ptbl = []
Prime.each(10e5) do |e|
ptbl.push e
end
i = ptbl.bsearch_index {|e| e >= X}
puts ptbl[i]
|
[
"expression.operator.compare.change",
"assignment.value.change",
"expression.operation.binary.change"
] | 624,318
| 624,319
|
u810246563
|
ruby
|
p02819
|
require 'prime'
line = gets.chomp.to_i
Prime.find {|p| p >= line }
|
require 'prime'
line = gets.chomp.to_i
puts Prime.find {|p| p >= line }
|
[
"io.output.change",
"call.add"
] | 624,728
| 624,729
|
u413184068
|
ruby
|
p02820
|
N, K = gets.split.map!(&:to_i)
R, S, P = gets.split.map!(&:to_i)
T = gets.chomp.codepoints
GU = 114 # r
CHOKI = 115 # s
PA = 112 # p
def katite(t)
if t == GU
PA
elsif t == CHOKI
GU
else
CHOKI
end
end
ans = 0
result = []
T.each_with_index do |t, i|
k = katite(t)
if i < K || k != result[i - K]
result[i] = k
ans += if k == GU
R
elsif k == CHOKI
S
else
P
end
else
cadets = [GU, CHOKI, PA]
cadets -= [katite(i+K)] if i + K < N
cadets -= [result[i - K]] if i >= K
result[i] = cadets[0]
end
end
puts ans
|
N, K = gets.split.map!(&:to_i)
R, S, P = gets.split.map!(&:to_i)
T = gets.chomp.codepoints
GU = 114 # r
CHOKI = 115 # s
PA = 112 # p
def katite(t)
if t == GU
PA
elsif t == CHOKI
GU
else
CHOKI
end
end
ans = 0
result = []
T.each_with_index do |t, i|
k = katite(t)
if i < K || k != result[i - K]
result[i] = k
ans += if k == GU
R
elsif k == CHOKI
S
else
P
end
else
cadets = [GU, CHOKI, PA]
cadets -= [katite(T[i + K])] if i + K < N
cadets -= [result[i - K]] if i >= K
result[i] = cadets[0]
end
end
puts ans
|
[
"call.arguments.change"
] | 625,289
| 625,290
|
u638516820
|
ruby
|
p02820
|
n, k = gets.chomp.split().map(&:to_i)
r, s, p = gets.chomp.split().map(&:to_i)
predicts = gets.chomp.chars
score = 0
wins = {r: p, s: r, p: s}
memo = Array.new(n, true)
n.times do |i|
now = predicts[i]
if i > k && predicts[ i - k ] === now && memo[i - k]
#相手がk回前と同じ手を出した時は負ける、奇数回目なら勝てる
memo[i] = false
next
end
score += wins[now.to_sym]
end
puts score
|
n, k = gets.chomp.split().map(&:to_i)
r, s, p = gets.chomp.split().map(&:to_i)
predicts = gets.chomp.chars
score = 0
wins = {r: p, s: r, p: s}
memo = Array.new(n, true)
n.times do |i|
now = predicts[i]
if i > k - 1 && predicts[ i - k ] === now && memo[i - k]
#相手がk回前と同じ手を出した時は負ける、奇数回目なら勝てる
memo[i] = false
next
end
score += wins[now.to_sym]
end
puts score
|
[
"control_flow.branch.if.condition.change"
] | 625,318
| 625,319
|
u541032448
|
ruby
|
p02820
|
n,k=gets.split.map &:to_i
r,s,p=gets.split.map &:to_i
t=gets.chomp.chars
res=0
rec=[]
t.each_with_index do |e,i|
case e
when "r"
if rec.size < k
rec << "p"
res += p
elsif rec.size >= k
if rec[i-k] != "p"
rec << "p"
res += p
else
rec << "r"
res += 0
end
end
when "s"
if rec.size < k
rec << "r"
res += r
elsif rec.size >= k
if rec[i-k] != "r"
rec << "r"
res += r
else
rec << "s"
res += 0
end
end
when "p"
if rec.size < k
rec << "s"
res += s
elsif rec.size >= k
if rec[i-k] != "s"
rec << "s"
res += s
else
rec << "p"
res += 0
end
end
end
end
puts res
|
n,k=gets.split.map &:to_i
r,s,p=gets.split.map &:to_i
t=gets.chomp.chars
res=0
rec=[]
t.each_with_index do |e,i|
case e
when "r"
if rec.size < k
rec << "p"
res += p
elsif rec.size >= k
if rec[i-k] != "p"
rec << "p"
res += p
else
rec << "."
res += 0
end
end
when "s"
if rec.size < k
rec << "r"
res += r
elsif rec.size >= k
if rec[i-k] != "r"
rec << "r"
res += r
else
rec << "."
res += 0
end
end
when "p"
if rec.size < k
rec << "s"
res += s
elsif rec.size >= k
if rec[i-k] != "s"
rec << "s"
res += s
else
rec << "."
res += 0
end
end
end
end
puts res
|
[
"literal.string.change",
"expression.operation.binary.change"
] | 625,442
| 625,443
|
u630043039
|
ruby
|
p02820
|
N, K = gets.chomp.split(" ").map(&:to_i)
R, S, P = gets.chomp.split(" ").map(&:to_i)
T = gets.chomp
def choice(i, t, v, win, lose, even)
ret = 0
if i >= K && t[-K] == win then
if i + K < N && T[i + K] == win.downcase then
t.concat(even)
else
t.concat(lose)
end
else
ret = v
t.concat(win)
end
ret
end
ans = 0
t = ""
N.times{|i|
case T[i]
when 'r' then
ans += choice(i, t, P, 'P', 'S', 'R')
when 's' then
ans += choice(i, t, R, 'R', 'P', 'S')
when 'p' then
ans += choice(i, t, P, 'S', 'R', 'P')
end
}
puts ans
|
N, K = gets.chomp.split(" ").map(&:to_i)
R, S, P = gets.chomp.split(" ").map(&:to_i)
T = gets.chomp
def choice(i, t, v, win, lose, even)
ret = 0
if i >= K && t[-K] == win then
if i + K < N && T[i + K] == win.downcase then
t.concat(even)
else
t.concat(lose)
end
else
ret = v
t.concat(win)
end
ret
end
ans = 0
t = ""
N.times{|i|
case T[i]
when 'r' then
ans += choice(i, t, P, 'P', 'S', 'R')
when 's' then
ans += choice(i, t, R, 'R', 'P', 'S')
when 'p' then
ans += choice(i, t, S, 'S', 'R', 'P')
end
}
puts ans
|
[
"call.arguments.change"
] | 625,530
| 625,531
|
u276517671
|
ruby
|
p02820
|
n, k = gets.split(' ').map(&:to_i)
r, s, p = gets.split(' ').map(&:to_i)
t = gets.chomp
points = 0
hands = []
0.upto(t.length - 1) do |i|
if t[i]=='r'
if i - k < 0
points += p
hands << 'p'
elsif hands[i-k] != 'p'
points += p
hands << 'p'
else
hands << 'r'
end
elsif t[i]=='s'
if i - k < 0
points += r
hands << 'r'
elsif hands[i-k] != 'r'
points += r
hands << 'r'
else
hands << 's'
end
else
if i - k < 0
points += s
hands << 's'
elsif hands[i-k] != 's'
points += s
hands << 's'
else
hands << 'p'
end
end
end
puts points
|
n, k = gets.split(' ').map(&:to_i)
r, s, p = gets.split(' ').map(&:to_i)
t = gets.chomp
points = 0
hands = []
0.upto(n - 1) do |i|
if t[i]=='r'
if i - k < 0
points += p
hands << 'p'
elsif hands[i-k] != 'p'
points += p
hands << 'p'
else
hands << ''
end
elsif t[i]=='s'
if i - k < 0
points += r
hands << 'r'
elsif hands[i-k] != 'r'
points += r
hands << 'r'
else
hands << ''
end
else
if i - k < 0
points += s
hands << 's'
elsif hands[i-k] != 's'
points += s
hands << 's'
else
hands << ''
end
end
end
puts points
|
[
"call.arguments.change",
"expression.operation.binary.change",
"call.remove",
"literal.string.change"
] | 625,620
| 625,621
|
u543466827
|
ruby
|
p02820
|
n, k = gets.split.map(&:to_i)
r, s, p = gets.split.map(&:to_i)
t = gets.chomp.split("")
a = t.map.with_index.group_by {|v, i| i % k}
score = {"r" => p, "s" => r, "p" => s}
ans = 0
prev = ""
a.each do |k, aa|
aa.each do |aaa|
if prev != aaa[0]
ans += score[aaa[0]]
prev = aaa[0]
else
prev = ""
end
end
end
p ans
|
n, k = gets.split.map(&:to_i)
r, s, p = gets.split.map(&:to_i)
t = gets.chomp.split("")
a = t.map.with_index.group_by {|v, i| i % k}
score = {"r" => p, "s" => r, "p" => s}
ans = 0
prev = ""
a.each do |k, aa|
aa.each do |aaa|
if prev != aaa[0]
ans += score[aaa[0]]
prev = aaa[0]
else
prev = ""
end
end
prev = ""
end
p ans
|
[
"assignment.add"
] | 626,332
| 626,333
|
u354261726
|
ruby
|
p02823
|
n,a,b = gets.split.map(&:to_i)
d = b - a
if d.even?
puts d / 2
else
puts [b-1, n-a].min + 1 + (b-a-1) / 2
end
|
n,a,b = gets.split.map(&:to_i)
d = b - a
if d.even?
puts d / 2
else
puts [a-1, n-b].min + 1 + (b-a-1) / 2
end
|
[
"identifier.change",
"call.arguments.change",
"expression.operation.binary.change",
"io.output.change"
] | 626,698
| 626,699
|
u173515518
|
ruby
|
p02823
|
n, a, b = gets.split.map(&:to_i)
if (b - a).even?
puts (b - a) / 2
else
if a - 1 < n - b
puts (a - 1) + 1 + (b - a - 1) / 2
else
puts (n - b) + 1 + (n - (n - b + 1)) / 2
end
end
|
n, a, b = gets.split.map(&:to_i)
if (b - a).even?
puts (b - a) / 2
else
if a - 1 < n - b
puts (a - 1) + 1 + (b - a - 1) / 2
else
puts (n - b) + 1 + (n - (a + (n - b + 1))) / 2
end
end
|
[
"call.arguments.change"
] | 627,037
| 627,038
|
u392423112
|
ruby
|
p02823
|
def get_i() #空白区切の入力を数値(整数)の配列で返す
return gets.chomp.split(" ").map(&:to_i)
end
def get_f() #空白区切の入力を数値(実数)の配列で返す
return gets.chomp.split(" ").map(&:to_f)
end
def get() #空白区切の入力を文字列の配列で返す
return gets.chomp.split(" ")
end
def get_nsp() #入力されたものを一文字ずつに区切った文字列の配列で返す
return gets.chomp.split("")
end
def yn_judge(bool,y="Yes",n="No") #boolに真偽を投げることで、trueならy、falseならnの値を出力する
return bool ? y : n
end
def array(size1,init=nil,size2=-1) #size2に二次元配列時の最初の要素数、size1に次の配列の大きさ、initに初期値を投げることでその配列を返す
if size2==-1
return Array.new(size1){init}
else
return Array.new(size2){Array.new(size1){init}}
end
end
def min(a,b)
return a>b ? b : a
end
N,A,B=get_i
if (B-A).even?
puts (B-A)/2
else
puts min(min(N-A,B-1),min(A+(B-A-1)/2,N-B+1+(A-B-1)/2))
end
|
def get_i() #空白区切の入力を数値(整数)の配列で返す
return gets.chomp.split(" ").map(&:to_i)
end
def get_f() #空白区切の入力を数値(実数)の配列で返す
return gets.chomp.split(" ").map(&:to_f)
end
def get() #空白区切の入力を文字列の配列で返す
return gets.chomp.split(" ")
end
def get_nsp() #入力されたものを一文字ずつに区切った文字列の配列で返す
return gets.chomp.split("")
end
def yn_judge(bool,y="Yes",n="No") #boolに真偽を投げることで、trueならy、falseならnの値を出力する
return bool ? y : n
end
def array(size1,init=nil,size2=-1) #size2に二次元配列時の最初の要素数、size1に次の配列の大きさ、initに初期値を投げることでその配列を返す
if size2==-1
return Array.new(size1){init}
else
return Array.new(size2){Array.new(size1){init}}
end
end
def min(a,b)
return a>b ? b : a
end
N,A,B=get_i
if (B-A).even?
puts (B-A)/2
else
puts min(min(N-A,B-1),min(A+(B-A-1)/2,N-B+1+(B-A-1)/2))
end
|
[
"expression.operation.binary.remove"
] | 627,091
| 627,092
|
u415400221
|
ruby
|
p02823
|
N, A, B = gets.split.map(&:to_i)
p(B&1 == A&1 ?
(B-A)/2 :
[[A+B,N-A+N-B+1].min/2, [B,N-A].min-1].min
)
|
N, A, B = gets.split.map(&:to_i)
p(B&1 == A&1 ?
(B-A)/2 :
[[A+B,N-A+N-B+1].min/2, [B-1,N-A].min].min
)
|
[
"expression.operation.binary.remove"
] | 628,280
| 628,281
|
u977697682
|
ruby
|
p02823
|
N, A, B = gets.split.map(&:to_i)
p(B&1 == A&1 ?
(B-A)/2 :
[[A+B,N-A+N-B].min/2, [B,N-A].min-1].min
)
|
N, A, B = gets.split.map(&:to_i)
p(B&1 == A&1 ?
(B-A)/2 :
[[A+B,N-A+N-B+1].min/2, [B-1,N-A].min].min
)
|
[
"expression.operation.binary.remove"
] | 628,282
| 628,281
|
u977697682
|
ruby
|
p02823
|
n, tmpa, tmpb = gets.split.map(&:to_i)
a, b = [tmpa, tmpb].sort
cnt = 0
# 奇数だけ離れていると、一番上か下に行く必要がある
if (a - b).odd?
# a のほうが端っこに近い場合
if a - 1 < n - b
p (b + a + 1) / 2
else
p (2*n - a - b + 1) / 2
end
else
# 偶数の場合、真ん中で落ち合えば良い
p (b - a) / 2
end
|
n, tmpa, tmpb = gets.split.map(&:to_i)
a, b = [tmpa, tmpb].sort
cnt = 0
# 奇数だけ離れていると、一番上か下に行く必要がある
if (a - b).odd?
# a のほうが端っこに近い場合
if a - 1 < n - b
p (b + a - 1) / 2
else
p (2*n - a - b + 1) / 2
end
else
# 偶数の場合、真ん中で落ち合えば良い
p (b - a) / 2
end
|
[
"misc.opposites",
"expression.operator.arithmetic.change",
"call.arguments.change",
"expression.operation.binary.change"
] | 628,386
| 628,387
|
u084335038
|
ruby
|
p02824
|
N,M,V,P = gets.split(' ').map(&:to_i)
A = gets.split(' ').map(&:to_i).sort
require 'pp'
PP.pp [N,M,V,P], STDERR
PP.pp A, STDERR
def check a
return true if a >= A[-P]
return false if A[-P] > a + M
if V <= P
return A[-P] <= a + M
end
point = (V-P) * M
skip_self = false
A[0,A.size - P].each do |aa|
if aa == a && !skip_self
skip_self = true
next
end
if aa <= a
point -= M
elsif aa > a && (a+M) > aa
point -= (a+M-aa)
end
return true if point <= 0
end
return true if point <= 0
return point <= 0
end
line = A.bsearch{|a| check a }
puts A.find_all{|a| a >= line}.size
|
N,M,V,P = gets.split(' ').map(&:to_i)
A = gets.split(' ').map(&:to_i).sort
require 'pp'
PP.pp [N,M,V,P], STDERR
PP.pp A, STDERR
def check a
return true if a >= A[-P]
return false if A[-P] > a + M
if V <= P
return A[-P] <= a + M
end
point = (V-P) * M
skip_self = false
A[0,A.size - (P - 1)].each do |aa|
if aa == a && !skip_self
skip_self = true
next
end
if aa <= a
point -= M
elsif aa > a && (a+M) > aa
point -= (a+M-aa)
end
return true if point <= 0
end
return true if point <= 0
return point <= 0
end
line = A.bsearch{|a| check a }
puts A.find_all{|a| a >= line}.size
|
[] | 628,846
| 628,847
|
u299761130
|
ruby
|
p02824
|
N, M, V, P = gets.split.map(&:to_i)
A = gets.split.map(&:to_i).sort.reverse
start, last = 0, A.size - 1
head = -1
while start < last do
x = (start + last) / 2
if A[x] >= A[P - 1]
head = x
start = x + 1
next
elsif A[x] + M < A[P - 1]
last = x - 1
next
end
barriers = A[P - 1, x - (P - 1)]
a_x = A[x] + M
acceptable_vote_num = barriers.map { |a| a_x - a }.inject(:+)
if M * (barriers.size - (N - V)) <= acceptable_vote_num
head = x
start = x + 1
else
last = x - 1
end
end
p head + 1
|
N, M, V, P = gets.split.map(&:to_i)
A = gets.split.map(&:to_i).sort.reverse
start, last = 0, A.size - 1
head = -1
while start <= last do
x = (start + last) / 2
if A[x] >= A[P - 1]
head = x
start = x + 1
next
elsif A[x] + M < A[P - 1]
last = x - 1
next
end
barriers = A[P - 1, x - (P - 1)]
a_x = A[x] + M
acceptable_vote_num = barriers.map { |a| a_x - a }.inject(:+)
if M * (barriers.size - (N - V)) <= acceptable_vote_num
head = x
start = x + 1
else
last = x - 1
end
end
p head + 1
|
[
"expression.operator.compare.change",
"expression.operation.binary.change"
] | 628,946
| 628,947
|
u199924561
|
ruby
|
p02824
|
N, M, V, P = gets.split.map(&:to_i)
A = gets.split.map(&:to_i).sort.reverse
start, last = 0, A.size - 1
head = -1
# p A
while start < last do
x = (start + last) / 2
# p "x: #{x}, start: #{start}, last: #{last}"
if A[x] >= A[P - 1]
head = x
start = x + 1
next
elsif A[x] + M < A[P - 1]
last = x - 1
next
end
# Ap-1とAxの間にある値（越えるべき壁）
barriers = A[P - 1, x - (P - 1)]
a_x = A[x] + M
# barriersがギリギリa_xを越えない獲得票の総数
acceptable_vote_num = barriers.map { |a| a_x - a }.sum
# 入ってもいい票数と実際に入る票数を比較
if M * (barriers.size - (N - V)) <= acceptable_vote_num
head = x
start = x + 1
else
last = x - 1
end
end
p head + 1
|
N, M, V, P = gets.split.map(&:to_i)
A = gets.split.map(&:to_i).sort.reverse
start, last = 0, A.size - 1
head = -1
while start <= last do
x = (start + last) / 2
if A[x] >= A[P - 1]
head = x
start = x + 1
next
elsif A[x] + M < A[P - 1]
last = x - 1
next
end
barriers = A[P - 1, x - (P - 1)]
a_x = A[x] + M
acceptable_vote_num = barriers.map { |a| a_x - a }.inject(:+)
if M * (barriers.size - (N - V)) <= acceptable_vote_num
head = x
start = x + 1
else
last = x - 1
end
end
p head + 1
|
[
"expression.operator.compare.change",
"expression.operation.binary.change",
"assignment.value.change",
"identifier.change",
"call.arguments.add"
] | 628,948
| 628,947
|
u199924561
|
ruby
|
p02829
|
A, B = gets.chomp, gets
p "123".delete(A).delete(B)
|
A, B = gets.chomp, gets
puts "123".delete(A).delete(B)
|
[
"call.function.change",
"io.output.change"
] | 629,557
| 629,558
|
u091810847
|
ruby
|
p02829
|
a = gets.chomp
b = gets.chomp
puts [1,2,3].reject{|e| (e == a || e == b)}[0]
|
a = gets.to_i
b = gets.to_i
puts [1,2,3].reject{|e| (e == a || e == b)}[0]
|
[
"assignment.value.change",
"identifier.change"
] | 629,615
| 629,616
|
u812649035
|
ruby
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.