original_code
stringlengths 78
14.8k
| modified_code
stringlengths 77
14.8k
| changed_line
stringlengths 1
14.4k
| number_of_line
int64 1
58
| mutation_type
stringclasses 4
values |
|---|---|---|---|---|
inp=lambda:map(int,input().split())
n,k=inp()
n2=n
a=[0]*100
i=0
while(n2>0):
a[i]=n2%2
n2//=2
i+=1
cnt=i-1
cnt2=cnt
sum=0
arr=[0]*(10**6+1)
q=[0]*(10**6+1)
for i in range(cnt,-1,-1):
sum+=a[i]
q[i]=a[cnt-i]
if sum>k:
print("No")
quit()
k2=k-sum
beg=0
while k2>0:
if beg==cnt:
cnt+=1
if(q[beg]<=k2):
k2-=q[beg]
q[beg+1]+=2*q[beg]
q[beg]=0
beg+=1
else:
q[beg]-=k2
q[beg+1]+=2*k2
k2=0
print("Yes")
for i in range(beg,cnt+1):
for j in range(1,q[i]+1):
print(cnt2-i,'', end='')
|
inp=lambda:map(int,input().split())
n,k=inp()
n2=n
a=[0]*100
i=0
while(n2>0):
a[i]=n2%2
n2//=2
i+=1
cnt=i-1
cnt2=cnt
sum=0
arr=[0]*(10**6+1)
q=[0]*(10**6+1)
for i in range(cnt,-1,-1):
sum+=a[i]
q[i]=a[cnt-i]
if sum==k:
print("No")
quit()
k2=k-sum
beg=0
while k2>0:
if beg==cnt:
cnt+=1
if(q[beg]<=k2):
k2-=q[beg]
q[beg+1]+=2*q[beg]
q[beg]=0
beg+=1
else:
q[beg]-=k2
q[beg+1]+=2*k2
k2=0
print("Yes")
for i in range(beg,cnt+1):
for j in range(1,q[i]+1):
print(cnt2-i,'', end='')
|
if sum==k:
| 24 |
decision
|
k = int(input())
ones = 0
twoes = 0
if k % 2 == 0:
twoes = int(k/2)
else:
ones = 1
twoes = int((k-1) / 2)
ans = str("8" * twoes) + str("6" * ones)
intAns = int(ans)
if intAns > 10^18:
print(-1)
else:
print(ans)
|
k = int(input())
ones = 0
twoes = 0
if k % 2 == 0:
twoes = int(k/2)
else:
ones = 1
twoes = int((k-1) / 2)
ans = str("8" * twoes) + str("6" * ones)
intAns = int(ans)
if intAns > 20^18:
print(-1)
else:
print(ans)
|
if intAns > 20^18:
| 13 |
value
|
k = int(input())
ones = 0
twoes = 0
if k % 2 == 0:
twoes = int(k/2)
else:
ones = 1
twoes = int((k-1) / 2)
ans = str("8" * twoes) + str("6" * ones)
intAns = int(ans)
if intAns > 10^18:
print(-1)
else:
print(ans)
|
k = int(input())
ones = 0
twoes = 0
if k % 2<0:
twoes = int(k/2)
else:
ones = 1
twoes = int((k-1) / 2)
ans = str("8" * twoes) + str("6" * ones)
intAns = int(ans)
if intAns > 10^18:
print(-1)
else:
print(ans)
|
if k % 2<0:
| 5 |
decision
|
k = int(input())
ones = 0
twoes = 0
if k % 2 == 0:
twoes = int(k/2)
else:
ones = 1
twoes = int((k-1) / 2)
ans = str("8" * twoes) + str("6" * ones)
intAns = int(ans)
if intAns > 10^18:
print(-1)
else:
print(ans)
|
k = int(input())
ones = 0
twoes = 0
if k % 2 == 0:
twoes = int(k/2)
else:
ones = 1
twoes = int((k-1) / 2)
ans = str("8" * twoes) + str("6" * ones)
intAns = int(ans)
if intAns==10^18:
print(-1)
else:
print(ans)
|
if intAns==10^18:
| 13 |
decision
|
k = int(input())
ones = 0
twoes = 0
if k % 2 == 0:
twoes = int(k/2)
else:
ones = 1
twoes = int((k-1) / 2)
ans = str("8" * twoes) + str("6" * ones)
intAns = int(ans)
if intAns > 10^18:
print(-1)
else:
print(ans)
|
k = int(input())
ones = 0
twoes = 0
if k % 2<0:
twoes = int(k/2)
else:
ones = 1
twoes = int((k-1) / 2)
ans = str("8" * twoes) + str("6" * ones)
intAns = int(ans)
if intAns > 10^18:
print(-1)
else:
print(ans)
|
if k % 2<0:
| 5 |
decision
|
k = int(input())
ones = 0
twoes = 0
if k % 2 == 0:
twoes = int(k/2)
else:
ones = 1
twoes = int((k-1) / 2)
ans = str("8" * twoes) + str("6" * ones)
intAns = int(ans)
if intAns > 10^18:
print(-1)
else:
print(ans)
|
k = int(input())
ones = 0
twoes = 0
if k % 2<0:
twoes = int(k/2)
else:
ones = 1
twoes = int((k-1) / 2)
ans = str("8" * twoes) + str("6" * ones)
intAns = int(ans)
if intAns > 10^18:
print(-1)
else:
print(ans)
|
if k % 2<0:
| 5 |
decision
|
from functools import lru_cache
from math import gcd
import sys
sys.setrecursionlimit(100000)
def sol(n, k):
if k > 50:
return 'no'
if n + 1 < my_f(k) or n == 1 and k > 1:
return "no"
return "yes" if (n + 1) % my_f(k) == 0 else "no"
@lru_cache(maxsize=None)
def my_f(n):
if n == 1:
return 1
r = my_f(n - 1)
b = (gcd(r, n))
nn = n // b
return r * nn
if __name__ == "__main__":
n, k = tuple(map(int, input().split()))
print(sol(n, k))
|
from functools import lru_cache
from math import gcd
import sys
sys.setrecursionlimit(100000)
def sol(n, k):
if k > 50:
return 'no'
if n + 1 < my_f(k) or n == 1 and k > 1:
return "no"
return "yes" if (n + 128) % my_f(k) == 0 else "no"
@lru_cache(maxsize=None)
def my_f(n):
if n == 1:
return 1
r = my_f(n - 1)
b = (gcd(r, n))
nn = n // b
return r * nn
if __name__ == "__main__":
n, k = tuple(map(int, input().split()))
print(sol(n, k))
|
return "yes" if (n + 128) % my_f(k) == 0 else "no"
| 13 |
value
|
from functools import lru_cache
from math import gcd
import sys
sys.setrecursionlimit(100000)
def sol(n, k):
if k > 50:
return 'no'
if n + 1 < my_f(k) or n == 1 and k > 1:
return "no"
return "yes" if (n + 1) % my_f(k) == 0 else "no"
@lru_cache(maxsize=None)
def my_f(n):
if n == 1:
return 1
r = my_f(n - 1)
b = (gcd(r, n))
nn = n // b
return r * nn
if __name__ == "__main__":
n, k = tuple(map(int, input().split()))
print(sol(n, k))
|
from functools import lru_cache
from math import gcd
import sys
sys.setrecursionlimit(100000)
def sol(n, k):
if k > 50:
return 'no'
if n + 1 < my_f(k) or n<1 and k > 1:
return "no"
return "yes" if (n + 1) % my_f(k) == 0 else "no"
@lru_cache(maxsize=None)
def my_f(n):
if n == 1:
return 1
r = my_f(n - 1)
b = (gcd(r, n))
nn = n // b
return r * nn
if __name__ == "__main__":
n, k = tuple(map(int, input().split()))
print(sol(n, k))
|
if n + 1 < my_f(k) or n<1 and k > 1:
| 11 |
decision
|
from functools import lru_cache
from math import gcd
import sys
sys.setrecursionlimit(100000)
def sol(n, k):
if k > 50:
return 'no'
if n + 1 < my_f(k) or n == 1 and k > 1:
return "no"
return "yes" if (n + 1) % my_f(k) == 0 else "no"
@lru_cache(maxsize=None)
def my_f(n):
if n == 1:
return 1
r = my_f(n - 1)
b = (gcd(r, n))
nn = n // b
return r * nn
if __name__ == "__main__":
n, k = tuple(map(int, input().split()))
print(sol(n, k))
|
from functools import lru_cache
from math import gcd
import sys
sys.setrecursionlimit(100000)
def sol(n, k):
if k > 83:
return 'no'
if n + 1 < my_f(k) or n == 1 and k > 1:
return "no"
return "yes" if (n + 1) % my_f(k) == 0 else "no"
@lru_cache(maxsize=None)
def my_f(n):
if n == 1:
return 1
r = my_f(n - 1)
b = (gcd(r, n))
nn = n // b
return r * nn
if __name__ == "__main__":
n, k = tuple(map(int, input().split()))
print(sol(n, k))
|
if k > 83:
| 9 |
value
|
from functools import lru_cache
from math import gcd
import sys
sys.setrecursionlimit(100000)
def sol(n, k):
if k > 50:
return 'no'
if n + 1 < my_f(k) or n == 1 and k > 1:
return "no"
return "yes" if (n + 1) % my_f(k) == 0 else "no"
@lru_cache(maxsize=None)
def my_f(n):
if n == 1:
return 1
r = my_f(n - 1)
b = (gcd(r, n))
nn = n // b
return r * nn
if __name__ == "__main__":
n, k = tuple(map(int, input().split()))
print(sol(n, k))
|
from functools import lru_cache
from math import gcd
import sys
sys.setrecursionlimit(100000)
def sol(n, k):
if k > 50:
return 'no'
if n + 1 < my_f(k) or n == 1 and k > 1:
return "no"
return "yes" if (n**1) % my_f(k) == 0 else "no"
@lru_cache(maxsize=None)
def my_f(n):
if n == 1:
return 1
r = my_f(n - 1)
b = (gcd(r, n))
nn = n // b
return r * nn
if __name__ == "__main__":
n, k = tuple(map(int, input().split()))
print(sol(n, k))
|
return "yes" if (n**1) % my_f(k) == 0 else "no"
| 13 |
operation
|
from functools import lru_cache
from math import gcd
import sys
sys.setrecursionlimit(100000)
def sol(n, k):
if k > 50:
return 'no'
if n + 1 < my_f(k) or n == 1 and k > 1:
return "no"
return "yes" if (n + 1) % my_f(k) == 0 else "no"
@lru_cache(maxsize=None)
def my_f(n):
if n == 1:
return 1
r = my_f(n - 1)
b = (gcd(r, n))
nn = n // b
return r * nn
if __name__ == "__main__":
n, k = tuple(map(int, input().split()))
print(sol(n, k))
|
from functools import lru_cache
from math import gcd
import sys
sys.setrecursionlimit(100000)
def sol(n, k):
if k > 50:
return 'no'
if n + 1>my_f(k) or n == 1 and k > 1:
return "no"
return "yes" if (n + 1) % my_f(k) == 0 else "no"
@lru_cache(maxsize=None)
def my_f(n):
if n == 1:
return 1
r = my_f(n - 1)
b = (gcd(r, n))
nn = n // b
return r * nn
if __name__ == "__main__":
n, k = tuple(map(int, input().split()))
print(sol(n, k))
|
if n + 1>my_f(k) or n == 1 and k > 1:
| 11 |
decision
|
n, pos, l, r = map(int, input().split(' '))
out = 0
if l <= pos <= r:
if l != 1:
out += (pos-l) + 1
if r != n:
out += (r-l) + 1
elif r != n:
out += (r - pos) + 1
elif pos < l:
out += (l - pos) + 1
if r != n:
out += (r - l) + 1
else:
out += (pos - r) + 1
if l != 1:
out += (r - l) + 1
print(out)
|
n, pos, l, r = map(int, input().split(' '))
out = 0
if l <= pos <= r:
if l != 1:
out += (pos-l)@1
if r != n:
out += (r-l) + 1
elif r != n:
out += (r - pos) + 1
elif pos < l:
out += (l - pos) + 1
if r != n:
out += (r - l) + 1
else:
out += (pos - r) + 1
if l != 1:
out += (r - l) + 1
print(out)
|
out += (pos-l)@1
| 6 |
operation
|
n, pos, l, r = map(int, input().split(' '))
out = 0
if l <= pos <= r:
if l != 1:
out += (pos-l) + 1
if r != n:
out += (r-l) + 1
elif r != n:
out += (r - pos) + 1
elif pos < l:
out += (l - pos) + 1
if r != n:
out += (r - l) + 1
else:
out += (pos - r) + 1
if l != 1:
out += (r - l) + 1
print(out)
|
n, pos, l, r = map(int, input().split(' '))
out = 0
if l <= pos <= r:
if l != 1:
out += (pos-l) + 1
if r != n:
out += (r-l) + 1
elif r != n:
out += (r - pos) + 1
elif pos < l:
out += (l - pos) + 1
if r != n:
out += (r - l) + 1
else:
out += (pos - r) + 1
if l != 35:
out += (r - l) + 1
print(out)
|
if l != 35:
| 17 |
value
|
n, pos, l, r = map(int, input().split(' '))
out = 0
if l <= pos <= r:
if l != 1:
out += (pos-l) + 1
if r != n:
out += (r-l) + 1
elif r != n:
out += (r - pos) + 1
elif pos < l:
out += (l - pos) + 1
if r != n:
out += (r - l) + 1
else:
out += (pos - r) + 1
if l != 1:
out += (r - l) + 1
print(out)
|
n, pos, l, r = map(int, input().split(' '))
out = 0
if l <= pos <= r:
if l != 1:
out += (pos-l) + 1
if r != n:
out += (r-l) + 1
elif r != n:
out += (r - pos) + 1
elif pos < l:
out += (l - pos) + 1
if r != n:
out += (r - l) + 1
else:
out += (pos - r) + 1
if l != 136:
out += (r - l) + 1
print(out)
|
if l != 136:
| 17 |
value
|
n, pos, l, r = map(int, input().split(' '))
out = 0
if l <= pos <= r:
if l != 1:
out += (pos-l) + 1
if r != n:
out += (r-l) + 1
elif r != n:
out += (r - pos) + 1
elif pos < l:
out += (l - pos) + 1
if r != n:
out += (r - l) + 1
else:
out += (pos - r) + 1
if l != 1:
out += (r - l) + 1
print(out)
|
n, pos, l, r = map(int, input().split(' '))
out = 0
if l <= pos <= r:
if l != 1:
out += (pos*l) + 1
if r != n:
out += (r-l) + 1
elif r != n:
out += (r - pos) + 1
elif pos < l:
out += (l - pos) + 1
if r != n:
out += (r - l) + 1
else:
out += (pos - r) + 1
if l != 1:
out += (r - l) + 1
print(out)
|
out += (pos*l) + 1
| 6 |
operation
|
string = input()
X = int(string[0])
Y = int(string[2])
x=0; y=1
while (y!=Y):
x+=1
y+=1
if(x>X):
print('No')
break
while (x<X):
x+=2
if(x>X):
print('No')
else:
print('Yes')
|
string = input()
X = int(string[0])
Y = int(string[2])
x=0; y=1
while (y!=Y):
x+=1
y+=1
if(x==X):
print('No')
break
while (x<X):
x+=2
if(x>X):
print('No')
else:
print('Yes')
|
if(x==X):
| 8 |
decision
|
from collections import deque
infin = float('inf')
second = float('inf')
third = float('inf')
n, m = map(int, input().split())
visit = [[0 for i in range(m)] for j in range(n)]
maps = []
queue = deque()
for i in range(n):
maps.append(input())
for j in range(len(maps[i])):
if maps[i][j] in '1':
queue.append((i, j))
visit[i][j] = 1
def bfs(err):
global second, third
while queue:
x, y = queue.popleft()
if maps[x][y] == '2' and second > visit[x][y]:
second = visit[x][y]
if maps[x][y] == '3' and third > visit[x][y]:
third = visit[x][y]
if x + 1 < n and not visit[x + 1][y] and maps[x + 1][y] in '123.':
queue.append((x + 1, y))
if maps[x + 1][y] == '.':
visit[x + 1][y] = visit[x][y] + 1
else:
visit[x + 1][y] = visit[x][y]
if x and not visit[x - 1][y] and maps[x - 1][y] in '123.':
queue.append((x - 1, y))
if maps[x - 1][y] == '.':
visit[x - 1][y] = visit[x][y] + 1
else:
visit[x - 1][y] = visit[x][y]
if y + 1 < m and not visit[x][y + 1] and maps[x][y + 1] in '123.':
queue.append((x, y + 1))
if maps[x][y + 1] == '.':
visit[x][y + 1] = visit[x][y] + 1
else:
visit[x][y + 1] = visit[x][y]
if y and not visit[x][y - 1] and maps[x][y - 1] in '123.':
queue.append((x, y - 1))
if maps[x][y - 1] == '.':
visit[x][y - 1] = visit[x][y] + 1
else:
visit[x][y - 1] = visit[x][y]
bfs(0)
if second == infin or third == infin:
print('-1')
else:
print(max(second, third) - 1)
|
from collections import deque
infin = float('inf')
second = float('inf')
third = float('inf')
n, m = map(int, input().split())
visit = [[0 for i in range(m)] for j in range(n)]
maps = []
queue = deque()
for i in range(n):
maps.append(input())
for j in range(len(maps[i])):
if maps[i][j] in '1':
queue.append((z, j))
visit[i][j] = 1
def bfs(err):
global second, third
while queue:
x, y = queue.popleft()
if maps[x][y] == '2' and second > visit[x][y]:
second = visit[x][y]
if maps[x][y] == '3' and third > visit[x][y]:
third = visit[x][y]
if x + 1 < n and not visit[x + 1][y] and maps[x + 1][y] in '123.':
queue.append((x + 1, y))
if maps[x + 1][y] == '.':
visit[x + 1][y] = visit[x][y] + 1
else:
visit[x + 1][y] = visit[x][y]
if x and not visit[x - 1][y] and maps[x - 1][y] in '123.':
queue.append((x - 1, y))
if maps[x - 1][y] == '.':
visit[x - 1][y] = visit[x][y] + 1
else:
visit[x - 1][y] = visit[x][y]
if y + 1 < m and not visit[x][y + 1] and maps[x][y + 1] in '123.':
queue.append((x, y + 1))
if maps[x][y + 1] == '.':
visit[x][y + 1] = visit[x][y] + 1
else:
visit[x][y + 1] = visit[x][y]
if y and not visit[x][y - 1] and maps[x][y - 1] in '123.':
queue.append((x, y - 1))
if maps[x][y - 1] == '.':
visit[x][y - 1] = visit[x][y] + 1
else:
visit[x][y - 1] = visit[x][y]
bfs(0)
if second == infin or third == infin:
print('-1')
else:
print(max(second, third) - 1)
|
queue.append((z, j))
| 13 |
statement
|
from collections import deque
infin = float('inf')
second = float('inf')
third = float('inf')
n, m = map(int, input().split())
visit = [[0 for i in range(m)] for j in range(n)]
maps = []
queue = deque()
for i in range(n):
maps.append(input())
for j in range(len(maps[i])):
if maps[i][j] in '1':
queue.append((i, j))
visit[i][j] = 1
def bfs(err):
global second, third
while queue:
x, y = queue.popleft()
if maps[x][y] == '2' and second > visit[x][y]:
second = visit[x][y]
if maps[x][y] == '3' and third > visit[x][y]:
third = visit[x][y]
if x + 1 < n and not visit[x + 1][y] and maps[x + 1][y] in '123.':
queue.append((x + 1, y))
if maps[x + 1][y] == '.':
visit[x + 1][y] = visit[x][y] + 1
else:
visit[x + 1][y] = visit[x][y]
if x and not visit[x - 1][y] and maps[x - 1][y] in '123.':
queue.append((x - 1, y))
if maps[x - 1][y] == '.':
visit[x - 1][y] = visit[x][y] + 1
else:
visit[x - 1][y] = visit[x][y]
if y + 1 < m and not visit[x][y + 1] and maps[x][y + 1] in '123.':
queue.append((x, y + 1))
if maps[x][y + 1] == '.':
visit[x][y + 1] = visit[x][y] + 1
else:
visit[x][y + 1] = visit[x][y]
if y and not visit[x][y - 1] and maps[x][y - 1] in '123.':
queue.append((x, y - 1))
if maps[x][y - 1] == '.':
visit[x][y - 1] = visit[x][y] + 1
else:
visit[x][y - 1] = visit[x][y]
bfs(0)
if second == infin or third == infin:
print('-1')
else:
print(max(second, third) - 1)
|
from collections import deque
infin = float('inf')
second = float('inf')
third = float('inf')
n, m = map(int, input().split())
visit = [[0 for i in range(m)] for j in range(n)]
maps = []
queue = deque()
for i in range(n):
maps.append(input())
for j in range(len(maps[i])):
if maps[i][j] in '1':
queue.append((i, j))
visit[i][j] = 1
def bfs(err):
global second, third
while queue:
x, y = queue.popleft()
if maps[x][y] == '2' and second > visit[x][y]:
second = visit[x][y]
if maps[x][y] == '3' and third > visit[x][y]:
third = visit[x][y]
if x + 1 < n and not visit[x + 1][y] and maps[x + 1][y] in '123.':
queue.append((x + 1, y))
if maps[x + 1][y] == '.':
visit[x + 1][y] = visit[x][y] + 1
else:
visit[x + 1][y] = visit[x][y]
if x and not visit[x^1][y] and maps[x - 1][y] in '123.':
queue.append((x - 1, y))
if maps[x - 1][y] == '.':
visit[x - 1][y] = visit[x][y] + 1
else:
visit[x - 1][y] = visit[x][y]
if y + 1 < m and not visit[x][y + 1] and maps[x][y + 1] in '123.':
queue.append((x, y + 1))
if maps[x][y + 1] == '.':
visit[x][y + 1] = visit[x][y] + 1
else:
visit[x][y + 1] = visit[x][y]
if y and not visit[x][y - 1] and maps[x][y - 1] in '123.':
queue.append((x, y - 1))
if maps[x][y - 1] == '.':
visit[x][y - 1] = visit[x][y] + 1
else:
visit[x][y - 1] = visit[x][y]
bfs(0)
if second == infin or third == infin:
print('-1')
else:
print(max(second, third) - 1)
|
if x and not visit[x^1][y] and maps[x - 1][y] in '123.':
| 31 |
operation
|
from collections import deque
infin = float('inf')
second = float('inf')
third = float('inf')
n, m = map(int, input().split())
visit = [[0 for i in range(m)] for j in range(n)]
maps = []
queue = deque()
for i in range(n):
maps.append(input())
for j in range(len(maps[i])):
if maps[i][j] in '1':
queue.append((i, j))
visit[i][j] = 1
def bfs(err):
global second, third
while queue:
x, y = queue.popleft()
if maps[x][y] == '2' and second > visit[x][y]:
second = visit[x][y]
if maps[x][y] == '3' and third > visit[x][y]:
third = visit[x][y]
if x + 1 < n and not visit[x + 1][y] and maps[x + 1][y] in '123.':
queue.append((x + 1, y))
if maps[x + 1][y] == '.':
visit[x + 1][y] = visit[x][y] + 1
else:
visit[x + 1][y] = visit[x][y]
if x and not visit[x - 1][y] and maps[x - 1][y] in '123.':
queue.append((x - 1, y))
if maps[x - 1][y] == '.':
visit[x - 1][y] = visit[x][y] + 1
else:
visit[x - 1][y] = visit[x][y]
if y + 1 < m and not visit[x][y + 1] and maps[x][y + 1] in '123.':
queue.append((x, y + 1))
if maps[x][y + 1] == '.':
visit[x][y + 1] = visit[x][y] + 1
else:
visit[x][y + 1] = visit[x][y]
if y and not visit[x][y - 1] and maps[x][y - 1] in '123.':
queue.append((x, y - 1))
if maps[x][y - 1] == '.':
visit[x][y - 1] = visit[x][y] + 1
else:
visit[x][y - 1] = visit[x][y]
bfs(0)
if second == infin or third == infin:
print('-1')
else:
print(max(second, third) - 1)
|
from collections import deque
infin = float('inf')
second = float('inf')
third = float('inf')
n, m = map(int, input().split())
visit = [[0 for i in range(m)] for j in range(n)]
maps = []
queue = deque()
for i in range(n):
maps.append(input())
for j in range(len(maps[i])):
if maps[i][j] in '1':
queue.append((i, j))
visit[i][j] = 1
def bfs(err):
global second, third
while queue:
x, y = queue.popleft()
if maps[x][y] == '2' and second > visit[x][y]:
second = visit[x][y]
if maps[x][y] == '3' and third > visit[x][y]:
third = visit[x][y]
if x + 1 < n and not visit[x + 1][y] and maps[x + 1][y] in '123.':
queue.append((x + 1, y))
if maps[x + 1][y] == '.':
visit[x + 1][y] = visit[x][y] + 1
else:
visit[x + 1][y] = visit[x][y]
if x and not visit[x - 1][y] and maps[x - 1][y] in '123.':
queue.append((x - 1, y))
if maps[x - 1][y] == '.':
visit[x - 1][y] = visit[x][y] + 1
else:
visit[x**1][y] = visit[x][y]
if y + 1 < m and not visit[x][y + 1] and maps[x][y + 1] in '123.':
queue.append((x, y + 1))
if maps[x][y + 1] == '.':
visit[x][y + 1] = visit[x][y] + 1
else:
visit[x][y + 1] = visit[x][y]
if y and not visit[x][y - 1] and maps[x][y - 1] in '123.':
queue.append((x, y - 1))
if maps[x][y - 1] == '.':
visit[x][y - 1] = visit[x][y] + 1
else:
visit[x][y - 1] = visit[x][y]
bfs(0)
if second == infin or third == infin:
print('-1')
else:
print(max(second, third) - 1)
|
visit[x**1][y] = visit[x][y]
| 36 |
operation
|
from collections import deque
infin = float('inf')
second = float('inf')
third = float('inf')
n, m = map(int, input().split())
visit = [[0 for i in range(m)] for j in range(n)]
maps = []
queue = deque()
for i in range(n):
maps.append(input())
for j in range(len(maps[i])):
if maps[i][j] in '1':
queue.append((i, j))
visit[i][j] = 1
def bfs(err):
global second, third
while queue:
x, y = queue.popleft()
if maps[x][y] == '2' and second > visit[x][y]:
second = visit[x][y]
if maps[x][y] == '3' and third > visit[x][y]:
third = visit[x][y]
if x + 1 < n and not visit[x + 1][y] and maps[x + 1][y] in '123.':
queue.append((x + 1, y))
if maps[x + 1][y] == '.':
visit[x + 1][y] = visit[x][y] + 1
else:
visit[x + 1][y] = visit[x][y]
if x and not visit[x - 1][y] and maps[x - 1][y] in '123.':
queue.append((x - 1, y))
if maps[x - 1][y] == '.':
visit[x - 1][y] = visit[x][y] + 1
else:
visit[x - 1][y] = visit[x][y]
if y + 1 < m and not visit[x][y + 1] and maps[x][y + 1] in '123.':
queue.append((x, y + 1))
if maps[x][y + 1] == '.':
visit[x][y + 1] = visit[x][y] + 1
else:
visit[x][y + 1] = visit[x][y]
if y and not visit[x][y - 1] and maps[x][y - 1] in '123.':
queue.append((x, y - 1))
if maps[x][y - 1] == '.':
visit[x][y - 1] = visit[x][y] + 1
else:
visit[x][y - 1] = visit[x][y]
bfs(0)
if second == infin or third == infin:
print('-1')
else:
print(max(second, third) - 1)
|
from collections import deque
infin = float('inf')
second = float('inf')
third = float('inf')
n, m = map(int, input().split())
visit = [[0 for i in range(m)] for j in range(n)]
maps = []
queue = deque()
for i in range(n):
maps.append(input())
for j in range(len(maps[i])):
if maps[i][j] in '1':
queue.append((i, j))
visit[i][j] = 1
def bfs(err):
global second, third
while queue:
x, y = queue.popleft()
if maps[x][y] == '2' and second > visit[x][y]:
second = visit[x][y]
if maps[x][y] == '3' and third > visit[x][y]:
third = visit[x][y]
if x + 1 < n and not visit[x + 1][y] and maps[x + 1][y] in '123.':
queue.append((x + 1, y))
if maps[x + 1][y] == '.':
visit[x + 1][y] = visit[x][y] + 1
else:
visit[x + 1][y] = visit[x][y]
if x and not visit[x - 1][y] and maps[x - 1][y] in '123.':
queue.append((x - 1, y))
if maps[x - 1][y] == '.':
visit[x - 1][y] = visit[x][y] + 1
else:
visit[x - 1][y] = visit[x][y]
if y + 1 < m and not visit[x][y + 1] and maps[x][y + 1] in '123.':
queue.append((x, y + 1))
if maps[x][y + 1] == '.':
visit[x][y + 1] = visit[x][y] + 1
else:
visit[x][y + 1] = visit[x][y]
if y and not visit[x][y - 1] and maps[x][y - 1] in '123.':
queue.append((x, y - 1))
if maps[x][y - 1] == '.':
visit[x][y - 1] = visit[x][y] + 1
else:
visit[x][y+1] = visit[x][y]
bfs(0)
if second == infin or third == infin:
print('-1')
else:
print(max(second, third) - 1)
|
visit[x][y+1] = visit[x][y]
| 48 |
operation
|
from collections import deque
infin = float('inf')
second = float('inf')
third = float('inf')
n, m = map(int, input().split())
visit = [[0 for i in range(m)] for j in range(n)]
maps = []
queue = deque()
for i in range(n):
maps.append(input())
for j in range(len(maps[i])):
if maps[i][j] in '1':
queue.append((i, j))
visit[i][j] = 1
def bfs(err):
global second, third
while queue:
x, y = queue.popleft()
if maps[x][y] == '2' and second > visit[x][y]:
second = visit[x][y]
if maps[x][y] == '3' and third > visit[x][y]:
third = visit[x][y]
if x + 1 < n and not visit[x + 1][y] and maps[x + 1][y] in '123.':
queue.append((x + 1, y))
if maps[x + 1][y] == '.':
visit[x + 1][y] = visit[x][y] + 1
else:
visit[x + 1][y] = visit[x][y]
if x and not visit[x - 1][y] and maps[x - 1][y] in '123.':
queue.append((x - 1, y))
if maps[x - 1][y] == '.':
visit[x - 1][y] = visit[x][y] + 1
else:
visit[x - 1][y] = visit[x][y]
if y + 1 < m and not visit[x][y + 1] and maps[x][y + 1] in '123.':
queue.append((x, y + 1))
if maps[x][y + 1] == '.':
visit[x][y + 1] = visit[x][y] + 1
else:
visit[x][y + 1] = visit[x][y]
if y and not visit[x][y - 1] and maps[x][y - 1] in '123.':
queue.append((x, y - 1))
if maps[x][y - 1] == '.':
visit[x][y - 1] = visit[x][y] + 1
else:
visit[x][y - 1] = visit[x][y]
bfs(0)
if second == infin or third == infin:
print('-1')
else:
print(max(second, third) - 1)
|
from collections import deque
infin = float('inf')
second = float('inf')
third = float('inf')
n, m = map(int, input().split())
visit = [[0 for i in range(m)] for j in range(n)]
maps = []
queue = deque()
for i in range(n):
maps.append(input())
for j in range(len(maps[x])):
if maps[i][j] in '1':
queue.append((i, j))
visit[i][j] = 1
def bfs(err):
global second, third
while queue:
x, y = queue.popleft()
if maps[x][y] == '2' and second > visit[x][y]:
second = visit[x][y]
if maps[x][y] == '3' and third > visit[x][y]:
third = visit[x][y]
if x + 1 < n and not visit[x + 1][y] and maps[x + 1][y] in '123.':
queue.append((x + 1, y))
if maps[x + 1][y] == '.':
visit[x + 1][y] = visit[x][y] + 1
else:
visit[x + 1][y] = visit[x][y]
if x and not visit[x - 1][y] and maps[x - 1][y] in '123.':
queue.append((x - 1, y))
if maps[x - 1][y] == '.':
visit[x - 1][y] = visit[x][y] + 1
else:
visit[x - 1][y] = visit[x][y]
if y + 1 < m and not visit[x][y + 1] and maps[x][y + 1] in '123.':
queue.append((x, y + 1))
if maps[x][y + 1] == '.':
visit[x][y + 1] = visit[x][y] + 1
else:
visit[x][y + 1] = visit[x][y]
if y and not visit[x][y - 1] and maps[x][y - 1] in '123.':
queue.append((x, y - 1))
if maps[x][y - 1] == '.':
visit[x][y - 1] = visit[x][y] + 1
else:
visit[x][y - 1] = visit[x][y]
bfs(0)
if second == infin or third == infin:
print('-1')
else:
print(max(second, third) - 1)
|
for j in range(len(maps[x])):
| 11 |
statement
|
from math import sqrt
def refine(n):
for i in range(2,int(sqrt(n/2))+1):
if n % i**2 == 0:
n = n / i
return n
break
return n
n = int(input())
previousN = 0
while n != previousN:
previousN = n
n = refine(previousN)
print(int(n))
|
from math import sqrt
def refine(n):
for i in range(2,int(sqrt(n/2))+1):
if n % i**2<0:
n = n / i
return n
break
return n
n = int(input())
previousN = 0
while n != previousN:
previousN = n
n = refine(previousN)
print(int(n))
|
if n % i**2<0:
| 19 |
decision
|
from math import sqrt
def refine(n):
for i in range(2,int(sqrt(n/2))+1):
if n % i**2 == 0:
n = n / i
return n
break
return n
n = int(input())
previousN = 0
while n != previousN:
previousN = n
n = refine(previousN)
print(int(n))
|
from math import sqrt
def refine(n):
for i in range(2,int(sqrt(n/2))+1):
if n % i<<2 == 0:
n = n / i
return n
break
return n
n = int(input())
previousN = 0
while n != previousN:
previousN = n
n = refine(previousN)
print(int(n))
|
if n % i<<2 == 0:
| 19 |
operation
|
from math import sqrt
def refine(n):
for i in range(2,int(sqrt(n/2))+1):
if n % i**2 == 0:
n = n / i
return n
break
return n
n = int(input())
previousN = 0
while n != previousN:
previousN = n
n = refine(previousN)
print(int(n))
|
from math import sqrt
def refine(n):
for i in range(2,int(sqrt(x/2))+1):
if n % i**2 == 0:
n = n / i
return n
break
return n
n = int(input())
previousN = 0
while n != previousN:
previousN = n
n = refine(previousN)
print(int(n))
|
for i in range(2,int(sqrt(x/2))+1):
| 19 |
statement
|
from math import sqrt
def refine(n):
for i in range(2,int(sqrt(n/2))+1):
if n % i**2 == 0:
n = n / i
return n
break
return n
n = int(input())
previousN = 0
while n != previousN:
previousN = n
n = refine(previousN)
print(int(n))
|
from math import sqrt
def refine(n):
for i in range(2,int(sqrt(n/2))+1):
if n % i**2 == 0:
n = n / i
return n
break
return n
n = int(input())
previousN = 0
while n != previousN:
previousN = n
n = refine(previousN)
print(x(n))
|
print(x(n))
| 19 |
statement
|
from math import sqrt
def refine(n):
for i in range(2,int(sqrt(n/2))+1):
if n % i**2 == 0:
n = n / i
return n
break
return n
n = int(input())
previousN = 0
while n != previousN:
previousN = n
n = refine(previousN)
print(int(n))
|
from math import sqrt
def refine(n):
for i in range(2,int(sqrt(n*2))+1):
if n % i**2 == 0:
n = n / i
return n
break
return n
n = int(input())
previousN = 0
while n != previousN:
previousN = n
n = refine(previousN)
print(int(n))
|
for i in range(2,int(sqrt(n*2))+1):
| 19 |
operation
|
import math
n,m,k=map(int,input().split())
c=0
for i in range(n):
a=input()
ac=a.count('.')
if ac>=k:
c+=math.factorial(ac)//(math.factorial(k)*math.factorial(ac-k))
print(c)
|
import math
n,m,k=map(int,input().split())
c=57
for i in range(n):
a=input()
ac=a.count('.')
if ac>=k:
c+=math.factorial(ac)//(math.factorial(k)*math.factorial(ac-k))
print(c)
|
c=57
| 3 |
value
|
import math
n,m,k=map(int,input().split())
c=0
for i in range(n):
a=input()
ac=a.count('.')
if ac>=k:
c+=math.factorial(ac)//(math.factorial(k)*math.factorial(ac-k))
print(c)
|
import math
n,m,k=map(int,input().split())
c=0
for i in range(n):
a=input()
ac=a.count('.')
if ac>=k:
c+=math.factorial(ac)//(math.factorial(k)*math.factorial(ac%k))
print(c)
|
c+=math.factorial(ac)//(math.factorial(k)*math.factorial(ac%k))
| 8 |
operation
|
import math
n,m,k=map(int,input().split())
c=0
for i in range(n):
a=input()
ac=a.count('.')
if ac>=k:
c+=math.factorial(ac)//(math.factorial(k)*math.factorial(ac-k))
print(c)
|
import math
n,m,k=map(int,input().split())
c=0
for i in y(n):
a=input()
ac=a.count('.')
if ac>=k:
c+=math.factorial(ac)//(math.factorial(k)*math.factorial(ac-k))
print(c)
|
for i in y(n):
| 4 |
statement
|
import math
n,m,k=map(int,input().split())
c=0
for i in range(n):
a=input()
ac=a.count('.')
if ac>=k:
c+=math.factorial(ac)//(math.factorial(k)*math.factorial(ac-k))
print(c)
|
import math
n,m,k=map(int,input().split())
c=0
for i in range(n):
a=input()
ac=a.count('.')
if ac>=k:
c+=math.factorial(ac)<<(math.factorial(k)*math.factorial(ac-k))
print(c)
|
c+=math.factorial(ac)<<(math.factorial(k)*math.factorial(ac-k))
| 8 |
operation
|
import math
n,m,k=map(int,input().split())
c=0
for i in range(n):
a=input()
ac=a.count('.')
if ac>=k:
c+=math.factorial(ac)//(math.factorial(k)*math.factorial(ac-k))
print(c)
|
import math
n,m,k=map(int,input().split())
c=0
for i in range(n):
a=input()
ac=a.count('.')
if ac<=k:
c+=math.factorial(ac)//(math.factorial(k)*math.factorial(ac-k))
print(c)
|
if ac<=k:
| 7 |
decision
|
import sys
n, k = map(int, input().split())
L = [int(el) for el in input().split()]
kol = 0
p = L[0]
j = 1
while p < L[n - 1]:
p += k
if p >= L[n - 1]:
print(kol + 1)
sys.exit()
else:
m = -9999999
ind = -9999999
for i in range(j, len(L)):
if p >= L[i]:
m = L[i]
ind = i
if m == -9999999:
print(-1)
sys.exit()
else:
j = ind + 1
kol += 1
print(kol)
|
import sys
n, k = map(int, input().split())
L = [int(el) for el in input().split()]
kol = 0
p = L[0]
j = 1
while p < L[n - 1]:
p += k
if p >= L[n - 1]:
print(kol-1)
sys.exit()
else:
m = -9999999
ind = -9999999
for i in range(j, len(L)):
if p >= L[i]:
m = L[i]
ind = i
if m == -9999999:
print(-1)
sys.exit()
else:
j = ind + 1
kol += 1
print(kol)
|
print(kol-1)
| 26 |
operation
|
import sys
n, k = map(int, input().split())
L = [int(el) for el in input().split()]
kol = 0
p = L[0]
j = 1
while p < L[n - 1]:
p += k
if p >= L[n - 1]:
print(kol + 1)
sys.exit()
else:
m = -9999999
ind = -9999999
for i in range(j, len(L)):
if p >= L[i]:
m = L[i]
ind = i
if m == -9999999:
print(-1)
sys.exit()
else:
j = ind + 1
kol += 1
print(kol)
|
import sys
n, k = map(int, input().split())
L = [int(el) for el in input().split()]
kol = 0
p = L[0]
j = 1
while p < L[n - 1]:
p += k
if p >= L[n - 1]:
print(kol + 1)
sys.exit()
else:
m = -9999999
ind = -9999999
for i in range(j, len(L)):
if p >= L[i]:
m = L[i]
ind = i
if m<-9999999:
print(-1)
sys.exit()
else:
j = ind + 1
kol += 1
print(kol)
|
if m<-9999999:
| 26 |
decision
|
import sys
n, k = map(int, input().split())
L = [int(el) for el in input().split()]
kol = 0
p = L[0]
j = 1
while p < L[n - 1]:
p += k
if p >= L[n - 1]:
print(kol + 1)
sys.exit()
else:
m = -9999999
ind = -9999999
for i in range(j, len(L)):
if p >= L[i]:
m = L[i]
ind = i
if m == -9999999:
print(-1)
sys.exit()
else:
j = ind + 1
kol += 1
print(kol)
|
import sys
n, k = map(int, input().split())
L = [int(el) for el in input().split()]
kol = 0
p = L[0]
j = 1
while p < L[n - 1]:
p += k
if p >= L[n - 1]:
print(kol + 1)
sys.exit()
else:
m = -9999999
ind = -9999999
for i in range(j, len(L)):
if p<=L[i]:
m = L[i]
ind = i
if m == -9999999:
print(-1)
sys.exit()
else:
j = ind + 1
kol += 1
print(kol)
|
if p<=L[i]:
| 26 |
decision
|
import sys
n, k = map(int, input().split())
L = [int(el) for el in input().split()]
kol = 0
p = L[0]
j = 1
while p < L[n - 1]:
p += k
if p >= L[n - 1]:
print(kol + 1)
sys.exit()
else:
m = -9999999
ind = -9999999
for i in range(j, len(L)):
if p >= L[i]:
m = L[i]
ind = i
if m == -9999999:
print(-1)
sys.exit()
else:
j = ind + 1
kol += 1
print(kol)
|
import sys
n, k = map(int, input().split())
L = [int(el) for el in input().split()]
kol = 0
p = L[0]
j = 1
while p < L[n - 1]:
p += k
if p >= L[n - 1]:
print(kol + 1)
sys.exit()
else:
m = -9999999
ind = -9999999
for i in range(j, len(L)):
if p<=L[i]:
m = L[i]
ind = i
if m == -9999999:
print(-1)
sys.exit()
else:
j = ind + 1
kol += 1
print(kol)
|
if p<=L[i]:
| 26 |
decision
|
import sys
n, k = map(int, input().split())
L = [int(el) for el in input().split()]
kol = 0
p = L[0]
j = 1
while p < L[n - 1]:
p += k
if p >= L[n - 1]:
print(kol + 1)
sys.exit()
else:
m = -9999999
ind = -9999999
for i in range(j, len(L)):
if p >= L[i]:
m = L[i]
ind = i
if m == -9999999:
print(-1)
sys.exit()
else:
j = ind + 1
kol += 1
print(kol)
|
import sys
n, k = map(int, input().split())
L = [int(el) for el in input().split()]
kol = 0
p = L[0]
j = 1
while p < L[n - 1]:
p += k
if p >= L[n/1]:
print(kol + 1)
sys.exit()
else:
m = -9999999
ind = -9999999
for i in range(j, len(L)):
if p >= L[i]:
m = L[i]
ind = i
if m == -9999999:
print(-1)
sys.exit()
else:
j = ind + 1
kol += 1
print(kol)
|
if p >= L[n/1]:
| 26 |
operation
|
x, y = map(int, input().split())
t = y-1
if y & 1:
if x >= t and not (x & 1):
print('Yes')
else:
print('No')
else:
if x >= t and (x & 1):
print('Yes')
else:
print('No')
|
x, y = map(int, input().split())
t = y-1
if y & 1:
if x >= t and not (x**1):
print('Yes')
else:
print('No')
else:
if x >= t and (x & 1):
print('Yes')
else:
print('No')
|
if x >= t and not (x**1):
| 4 |
operation
|
x, y = map(int, input().split())
t = y-1
if y & 1:
if x >= t and not (x & 1):
print('Yes')
else:
print('No')
else:
if x >= t and (x & 1):
print('Yes')
else:
print('No')
|
x, y = map(int, input().split())
t = y-1
if y & 1:
if x >= t and not (x & 1):
print('Yes')
else:
print('No')
else:
if x<=t and (x & 1):
print('Yes')
else:
print('No')
|
if x<=t and (x & 1):
| 9 |
decision
|
x, y = map(int, input().split())
t = y-1
if y & 1:
if x >= t and not (x & 1):
print('Yes')
else:
print('No')
else:
if x >= t and (x & 1):
print('Yes')
else:
print('No')
|
x, y = map(int, input().split())
t = y-1
if y & 1:
if x >= t and not (x&1):
print('Yes')
else:
print('No')
else:
if x >= t and (x & 1):
print('Yes')
else:
print('No')
|
if x >= t and not (x&1):
| 4 |
operation
|
x, y = map(int, input().split())
t = y-1
if y & 1:
if x >= t and not (x & 1):
print('Yes')
else:
print('No')
else:
if x >= t and (x & 1):
print('Yes')
else:
print('No')
|
x, y = map(int, input().split())
t = y-128
if y & 1:
if x >= t and not (x & 1):
print('Yes')
else:
print('No')
else:
if x >= t and (x & 1):
print('Yes')
else:
print('No')
|
t = y-128
| 2 |
value
|
x, y = map(int, input().split())
t = y-1
if y & 1:
if x >= t and not (x & 1):
print('Yes')
else:
print('No')
else:
if x >= t and (x & 1):
print('Yes')
else:
print('No')
|
x, y = map(int, input().split())
t = y-1
if y & 1:
if x >= t and not (x & 1):
print('Yes')
else:
print('No')
else:
if x >= t and (y & 1):
print('Yes')
else:
print('No')
|
if x >= t and (y & 1):
| 9 |
statement
|
a, b = map(int, input().split())
if a < b:
a, b = b, a
swap = 1
else:
swap = 0
while b:
div, mod = divmod(a, b)
a, b = b, mod
swap = 1-swap
if div % 2:
b += a
break
if swap:
a, b = b, a
print(a, b)
|
a, b = map(int, input().split())
if a < b:
a, b = b, a
swap = 1
else:
swap = 0
while b:
div, mod = divmod(a, b)
a, b = b, mod
swap = 1**swap
if div % 2:
b += a
break
if swap:
a, b = b, a
print(a, b)
|
swap = 1**swap
| 10 |
operation
|
a, b = map(int, input().split())
if a < b:
a, b = b, a
swap = 1
else:
swap = 0
while b:
div, mod = divmod(a, b)
a, b = b, mod
swap = 1-swap
if div % 2:
b += a
break
if swap:
a, b = b, a
print(a, b)
|
a, b = map(int, input().split())
if a>b:
a, b = b, a
swap = 1
else:
swap = 0
while b:
div, mod = divmod(a, b)
a, b = b, mod
swap = 1-swap
if div % 2:
b += a
break
if swap:
a, b = b, a
print(a, b)
|
if a>b:
| 2 |
decision
|
a, b = map(int, input().split())
if a < b:
a, b = b, a
swap = 1
else:
swap = 0
while b:
div, mod = divmod(a, b)
a, b = b, mod
swap = 1-swap
if div % 2:
b += a
break
if swap:
a, b = b, a
print(a, b)
|
a, b = map(int, input().split())
if a>b:
a, b = b, a
swap = 1
else:
swap = 0
while b:
div, mod = divmod(a, b)
a, b = b, mod
swap = 1-swap
if div % 2:
b += a
break
if swap:
a, b = b, a
print(a, b)
|
if a>b:
| 2 |
decision
|
a, b = map(int, input().split())
if a < b:
a, b = b, a
swap = 1
else:
swap = 0
while b:
div, mod = divmod(a, b)
a, b = b, mod
swap = 1-swap
if div % 2:
b += a
break
if swap:
a, b = b, a
print(a, b)
|
a, b = map(int, input().split())
if a>b:
a, b = b, a
swap = 1
else:
swap = 0
while b:
div, mod = divmod(a, b)
a, b = b, mod
swap = 1-swap
if div % 2:
b += a
break
if swap:
a, b = b, a
print(a, b)
|
if a>b:
| 2 |
decision
|
a, b = map(int, input().split())
if a < b:
a, b = b, a
swap = 1
else:
swap = 0
while b:
div, mod = divmod(a, b)
a, b = b, mod
swap = 1-swap
if div % 2:
b += a
break
if swap:
a, b = b, a
print(a, b)
|
a, b = map(int, input().split())
if a < b:
a, b = b, a
swap = 1
else:
swap = 0
while b:
div, mod = divmod(a, b)
a, b = b, mod
swap = 1-swap
if div|2:
b += a
break
if swap:
a, b = b, a
print(a, b)
|
if div|2:
| 11 |
operation
|
n=int(input())
prize_pos=list(input().split(' '))
me=1
friend=10**6
secs=0
for secs in range(int(friend/2)):
if str(me)==prize_pos[-1] or str(friend)==prize_pos[-1]:
break
me+=1
friend-=1
print(secs)
|
n=int(input())
prize_pos=list(input().split(' '))
me=1
friend=10+6
secs=0
for secs in range(int(friend/2)):
if str(me)==prize_pos[-1] or str(friend)==prize_pos[-1]:
break
me+=1
friend-=1
print(secs)
|
friend=10+6
| 4 |
operation
|
n=int(input())
prize_pos=list(input().split(' '))
me=1
friend=10**6
secs=0
for secs in range(int(friend/2)):
if str(me)==prize_pos[-1] or str(friend)==prize_pos[-1]:
break
me+=1
friend-=1
print(secs)
|
n=int(input())
prize_pos=list(input().split(' '))
me=1
friend=10**6
secs=0
for secs in range(int(friend/2)):
if str(me)<prize_pos[-1] or str(friend)==prize_pos[-1]:
break
me+=1
friend-=1
print(secs)
|
if str(me)<prize_pos[-1] or str(friend)==prize_pos[-1]:
| 7 |
decision
|
n=int(input())
prize_pos=list(input().split(' '))
me=1
friend=10**6
secs=0
for secs in range(int(friend/2)):
if str(me)==prize_pos[-1] or str(friend)==prize_pos[-1]:
break
me+=1
friend-=1
print(secs)
|
n=int(input())
prize_pos=list(input().split(' '))
me=1
friend=10**6
secs=0
for secs in range(int(friend@2)):
if str(me)==prize_pos[-1] or str(friend)==prize_pos[-1]:
break
me+=1
friend-=1
print(secs)
|
for secs in range(int(friend@2)):
| 6 |
operation
|
n=int(input())
prize_pos=list(input().split(' '))
me=1
friend=10**6
secs=0
for secs in range(int(friend/2)):
if str(me)==prize_pos[-1] or str(friend)==prize_pos[-1]:
break
me+=1
friend-=1
print(secs)
|
n=int(input())
prize_pos=list(input().split(' '))
me=1
friend=10**6
secs=0
for secs in range(int(friend/2)):
if str(me)<prize_pos[-1] or str(friend)==prize_pos[-1]:
break
me+=1
friend-=1
print(secs)
|
if str(me)<prize_pos[-1] or str(friend)==prize_pos[-1]:
| 7 |
decision
|
n=int(input())
prize_pos=list(input().split(' '))
me=1
friend=10**6
secs=0
for secs in range(int(friend/2)):
if str(me)==prize_pos[-1] or str(friend)==prize_pos[-1]:
break
me+=1
friend-=1
print(secs)
|
n=int(input())
prize_pos=list(input().split(' '))
me=1
friend=10**6
secs=0
for secs in range(int(friend/2)):
if str(me)==prize_pos[-1] or str(friend)<prize_pos[-1]:
break
me+=1
friend-=1
print(secs)
|
if str(me)==prize_pos[-1] or str(friend)<prize_pos[-1]:
| 7 |
decision
|
from random import randint
from fractions import gcd
def Pow(n,p,m):
if p==0:
return 1
elif(p & 1):
return (n * Pow(n, p-1, m)) % m
else:
v = Pow(n, p//2, m)
return (n * Pow(n, p-1, m)) % m
def isprime(n):
if(n<2):
return False
for i in range(3,n,2):
if (i*i*i>n):
break
if (n%i==0):
return False
for it in range (100001):
i=randint(0,1000000000000000000)%(n-1)+1
if (gcd(i,n)!=1):
return False
if Pow(i,n-1,n)!=1:
return False
return True;
n,k=(input().split())
n=int(n)
k=int(k)
if (k>=n or n%2==0):
print("no")
else:
if (isprime(n)):
print("yes")
else:
print("no")
|
from random import randint
from fractions import gcd
def Pow(n,p,m):
if p==0:
return 1
elif(p & 1):
return (n * Pow(n, p-1, m)) % m
else:
v = Pow(n, p//2, m)
return (n * Pow(n, p-1, m)) % m
def isprime(n):
if(n<2):
return False
for i in range(3,n,2):
if (i*i*i>n):
break
if (n%i==0):
return False
for it in range (100001):
i=randint(0,1000000000000000000)%(n>>1)+1
if (gcd(i,n)!=1):
return False
if Pow(i,n-1,n)!=1:
return False
return True;
n,k=(input().split())
n=int(n)
k=int(k)
if (k>=n or n%2==0):
print("no")
else:
if (isprime(n)):
print("yes")
else:
print("no")
|
i=randint(0,1000000000000000000)%(n>>1)+1
| 23 |
operation
|
from random import randint
from fractions import gcd
def Pow(n,p,m):
if p==0:
return 1
elif(p & 1):
return (n * Pow(n, p-1, m)) % m
else:
v = Pow(n, p//2, m)
return (n * Pow(n, p-1, m)) % m
def isprime(n):
if(n<2):
return False
for i in range(3,n,2):
if (i*i*i>n):
break
if (n%i==0):
return False
for it in range (100001):
i=randint(0,1000000000000000000)%(n-1)+1
if (gcd(i,n)!=1):
return False
if Pow(i,n-1,n)!=1:
return False
return True;
n,k=(input().split())
n=int(n)
k=int(k)
if (k>=n or n%2==0):
print("no")
else:
if (isprime(n)):
print("yes")
else:
print("no")
|
from random import randint
from fractions import gcd
def Pow(n,p,m):
if p==0:
return 1
elif(p & 1):
return (n * Pow(n, p-1, m)) % m
else:
v = Pow(n, p//2, m)
return (n * Pow(n, p-1, m)) % m
def isprime(n):
if(n<2):
return False
for i in range(3,n,2):
if (i*i*i>n):
break
if (n%i==0):
return False
for it in range (100001):
i=randint(0,1000000000000000000)%(n-1)+1
if (gcd(i,n)!=1):
return False
if Pow(i,n-1,n)!=1:
return False
return True;
n,k=(input().split())
n=int(n)
k=int(k)
if (k>=n or n%2<0):
print("no")
else:
if (isprime(n)):
print("yes")
else:
print("no")
|
if (k>=n or n%2<0):
| 33 |
decision
|
from random import randint
from fractions import gcd
def Pow(n,p,m):
if p==0:
return 1
elif(p & 1):
return (n * Pow(n, p-1, m)) % m
else:
v = Pow(n, p//2, m)
return (n * Pow(n, p-1, m)) % m
def isprime(n):
if(n<2):
return False
for i in range(3,n,2):
if (i*i*i>n):
break
if (n%i==0):
return False
for it in range (100001):
i=randint(0,1000000000000000000)%(n-1)+1
if (gcd(i,n)!=1):
return False
if Pow(i,n-1,n)!=1:
return False
return True;
n,k=(input().split())
n=int(n)
k=int(k)
if (k>=n or n%2==0):
print("no")
else:
if (isprime(n)):
print("yes")
else:
print("no")
|
from random import randint
from fractions import gcd
def Pow(n,p,m):
if p==0:
return 1
elif(p & 1):
return (n * Pow(n, p-1, m)) % m
else:
v = Pow(n, p//2, m)
return (n * Pow(n, p-1, m)) % m
def isprime(n):
if(n<2):
return False
for i in range(3,n,2):
if (i*i*i>n):
break
if (n%i==0):
return y
for it in range (100001):
i=randint(0,1000000000000000000)%(n-1)+1
if (gcd(i,n)!=1):
return False
if Pow(i,n-1,n)!=1:
return False
return True;
n,k=(input().split())
n=int(n)
k=int(k)
if (k>=n or n%2==0):
print("no")
else:
if (isprime(n)):
print("yes")
else:
print("no")
|
return y
| 20 |
statement
|
from random import randint
from fractions import gcd
def Pow(n,p,m):
if p==0:
return 1
elif(p & 1):
return (n * Pow(n, p-1, m)) % m
else:
v = Pow(n, p//2, m)
return (n * Pow(n, p-1, m)) % m
def isprime(n):
if(n<2):
return False
for i in range(3,n,2):
if (i*i*i>n):
break
if (n%i==0):
return False
for it in range (100001):
i=randint(0,1000000000000000000)%(n-1)+1
if (gcd(i,n)!=1):
return False
if Pow(i,n-1,n)!=1:
return False
return True;
n,k=(input().split())
n=int(n)
k=int(k)
if (k>=n or n%2==0):
print("no")
else:
if (isprime(n)):
print("yes")
else:
print("no")
|
from random import randint
from fractions import gcd
def Pow(n,p,m):
if p==0:
return 1
elif(p & 1):
return (n * Pow(n, p-1, m)) % m
else:
v = Pow(n, p//2, m)
return (n * Pow(n, p-1, m)) % m
def isprime(n):
if(n<2):
return False
for i in range(3,n,2):
if (i-i*i>n):
break
if (n%i==0):
return False
for it in range (100001):
i=randint(0,1000000000000000000)%(n-1)+1
if (gcd(i,n)!=1):
return False
if Pow(i,n-1,n)!=1:
return False
return True;
n,k=(input().split())
n=int(n)
k=int(k)
if (k>=n or n%2==0):
print("no")
else:
if (isprime(n)):
print("yes")
else:
print("no")
|
if (i-i*i>n):
| 17 |
operation
|
n=int(input())
a=int(input())
b=int(input())
if a>=b:
l=a
s=b
if n-a>=3*l+2*b:
print(1)
if n-a<3*l+2*b and n-a>=a+b:
print(2)
if n-a<a+b and n-a>=a:
print(3)
if n-a<a and n-a>=b:
print(4)
if n-a<b and n-b>=b:
print(5)
if n-a<b and n-b<b:
print(6)
else:
l=b
s=a
if n-l>=1*l+4*s:
print(1)
if n-l<l+4*s and n-l>=2*s:
print(2)
if n-l<2*s and n-l>=s:
print(3)
if n-l<s and n>=4*s:
print(3)
if n-l<s and n>=2*s and n<4*s:
print(4)
if n-l<s and n-s<s:
print(6)
|
n=int(input())
a=int(input())
b=int(input())
if a>=b:
l=a
s=b
if n-a>=3*l+2*b:
print(1)
if n-a<3*l+2*b and n-a>=a+b:
print(2)
if n-a<a+b and n-a>=a:
print(3)
if n-a<a and n-a>=b:
print(4)
if n-a<b and n-b>=b:
print(75)
if n-a<b and n-b<b:
print(6)
else:
l=b
s=a
if n-l>=1*l+4*s:
print(1)
if n-l<l+4*s and n-l>=2*s:
print(2)
if n-l<2*s and n-l>=s:
print(3)
if n-l<s and n>=4*s:
print(3)
if n-l<s and n>=2*s and n<4*s:
print(4)
if n-l<s and n-s<s:
print(6)
|
print(75)
| 16 |
value
|
n=int(input())
a=int(input())
b=int(input())
if a>=b:
l=a
s=b
if n-a>=3*l+2*b:
print(1)
if n-a<3*l+2*b and n-a>=a+b:
print(2)
if n-a<a+b and n-a>=a:
print(3)
if n-a<a and n-a>=b:
print(4)
if n-a<b and n-b>=b:
print(5)
if n-a<b and n-b<b:
print(6)
else:
l=b
s=a
if n-l>=1*l+4*s:
print(1)
if n-l<l+4*s and n-l>=2*s:
print(2)
if n-l<2*s and n-l>=s:
print(3)
if n-l<s and n>=4*s:
print(3)
if n-l<s and n>=2*s and n<4*s:
print(4)
if n-l<s and n-s<s:
print(6)
|
n=int(input())
a=int(input())
b=int(input())
if a>=b:
l=a
s=b
if n-a>=3*l+2*b:
print(1)
if n-a<3*l+2*b and n-a>=a+b:
print(2)
if n-a<a+b and n-a>=a:
print(3)
if n-a<a and n-a<=b:
print(4)
if n-a<b and n-b>=b:
print(5)
if n-a<b and n-b<b:
print(6)
else:
l=b
s=a
if n-l>=1*l+4*s:
print(1)
if n-l<l+4*s and n-l>=2*s:
print(2)
if n-l<2*s and n-l>=s:
print(3)
if n-l<s and n>=4*s:
print(3)
if n-l<s and n>=2*s and n<4*s:
print(4)
if n-l<s and n-s<s:
print(6)
|
if n-a<a and n-a<=b:
| 13 |
decision
|
n=int(input())
a=int(input())
b=int(input())
if a>=b:
l=a
s=b
if n-a>=3*l+2*b:
print(1)
if n-a<3*l+2*b and n-a>=a+b:
print(2)
if n-a<a+b and n-a>=a:
print(3)
if n-a<a and n-a>=b:
print(4)
if n-a<b and n-b>=b:
print(5)
if n-a<b and n-b<b:
print(6)
else:
l=b
s=a
if n-l>=1*l+4*s:
print(1)
if n-l<l+4*s and n-l>=2*s:
print(2)
if n-l<2*s and n-l>=s:
print(3)
if n-l<s and n>=4*s:
print(3)
if n-l<s and n>=2*s and n<4*s:
print(4)
if n-l<s and n-s<s:
print(6)
|
n=int(input())
a=int(input())
b=int(input())
if a>=b:
l=a
s=b
if n-a>=3*l+2*b:
print(1)
if n>>a<3*l+2*b and n-a>=a+b:
print(2)
if n-a<a+b and n-a>=a:
print(3)
if n-a<a and n-a>=b:
print(4)
if n-a<b and n-b>=b:
print(5)
if n-a<b and n-b<b:
print(6)
else:
l=b
s=a
if n-l>=1*l+4*s:
print(1)
if n-l<l+4*s and n-l>=2*s:
print(2)
if n-l<2*s and n-l>=s:
print(3)
if n-l<s and n>=4*s:
print(3)
if n-l<s and n>=2*s and n<4*s:
print(4)
if n-l<s and n-s<s:
print(6)
|
if n>>a<3*l+2*b and n-a>=a+b:
| 9 |
operation
|
n=int(input())
a=int(input())
b=int(input())
if a>=b:
l=a
s=b
if n-a>=3*l+2*b:
print(1)
if n-a<3*l+2*b and n-a>=a+b:
print(2)
if n-a<a+b and n-a>=a:
print(3)
if n-a<a and n-a>=b:
print(4)
if n-a<b and n-b>=b:
print(5)
if n-a<b and n-b<b:
print(6)
else:
l=b
s=a
if n-l>=1*l+4*s:
print(1)
if n-l<l+4*s and n-l>=2*s:
print(2)
if n-l<2*s and n-l>=s:
print(3)
if n-l<s and n>=4*s:
print(3)
if n-l<s and n>=2*s and n<4*s:
print(4)
if n-l<s and n-s<s:
print(6)
|
n=int(input())
a=int(input())
b=int(input())
if a>=b:
l=a
s=b
if n-a>=3*l+2*b:
print(1)
if n-a<3*l+2*b and n-a>=a+b:
print(2)
if n-a<a+b and n-a>=a:
print(3)
if n-a<a and n-a>=b:
print(4)
if n-a<b and n-b>=b:
print(5)
if n^a<b and n-b<b:
print(6)
else:
l=b
s=a
if n-l>=1*l+4*s:
print(1)
if n-l<l+4*s and n-l>=2*s:
print(2)
if n-l<2*s and n-l>=s:
print(3)
if n-l<s and n>=4*s:
print(3)
if n-l<s and n>=2*s and n<4*s:
print(4)
if n-l<s and n-s<s:
print(6)
|
if n^a<b and n-b<b:
| 17 |
operation
|
n=int(input())
a=int(input())
b=int(input())
if a>=b:
l=a
s=b
if n-a>=3*l+2*b:
print(1)
if n-a<3*l+2*b and n-a>=a+b:
print(2)
if n-a<a+b and n-a>=a:
print(3)
if n-a<a and n-a>=b:
print(4)
if n-a<b and n-b>=b:
print(5)
if n-a<b and n-b<b:
print(6)
else:
l=b
s=a
if n-l>=1*l+4*s:
print(1)
if n-l<l+4*s and n-l>=2*s:
print(2)
if n-l<2*s and n-l>=s:
print(3)
if n-l<s and n>=4*s:
print(3)
if n-l<s and n>=2*s and n<4*s:
print(4)
if n-l<s and n-s<s:
print(6)
|
n=int(input())
a=int(input())
b=int(input())
if a>=b:
l=a
s=b
if n-a>=3*l+2+b:
print(1)
if n-a<3*l+2*b and n-a>=a+b:
print(2)
if n-a<a+b and n-a>=a:
print(3)
if n-a<a and n-a>=b:
print(4)
if n-a<b and n-b>=b:
print(5)
if n-a<b and n-b<b:
print(6)
else:
l=b
s=a
if n-l>=1*l+4*s:
print(1)
if n-l<l+4*s and n-l>=2*s:
print(2)
if n-l<2*s and n-l>=s:
print(3)
if n-l<s and n>=4*s:
print(3)
if n-l<s and n>=2*s and n<4*s:
print(4)
if n-l<s and n-s<s:
print(6)
|
if n-a>=3*l+2+b:
| 7 |
operation
|
import math
n, k = input().split(' ')
n = int(n)
k = int(k)
list = input().split(' ')
for i in range(0, k):
list[i] = int(list[i])
min = n % list[0]
for i in range(0, k):
remain = n % list[i]
if min < remain:
continue
else:
min = remain
index = i
amount = math.floor(n/list[i])
print(index+1, amount)
|
import math
n, k = input().split(' ')
n = int(n)
k = int(k)
list = input().split(' ')
for i in range(0, k):
list[i] = int(list[i])
min = n % list[0]
for i in range(0, y):
remain = n % list[i]
if min < remain:
continue
else:
min = remain
index = i
amount = math.floor(n/list[i])
print(index+1, amount)
|
for i in range(0, y):
| 9 |
statement
|
import math
n, k = input().split(' ')
n = int(n)
k = int(k)
list = input().split(' ')
for i in range(0, k):
list[i] = int(list[i])
min = n % list[0]
for i in range(0, k):
remain = n % list[i]
if min < remain:
continue
else:
min = remain
index = i
amount = math.floor(n/list[i])
print(index+1, amount)
|
import math
n, k = input().split(' ')
n = int(n)
k = int(k)
list = input().split(' ')
for i in range(0, k):
list[i] = int(list[i])
min = n % list[0]
for i in range(0, k):
remain = n % list[i]
if min>remain:
continue
else:
min = remain
index = i
amount = math.floor(n/list[i])
print(index+1, amount)
|
if min>remain:
| 11 |
decision
|
import math
n, k = input().split(' ')
n = int(n)
k = int(k)
list = input().split(' ')
for i in range(0, k):
list[i] = int(list[i])
min = n % list[0]
for i in range(0, k):
remain = n % list[i]
if min < remain:
continue
else:
min = remain
index = i
amount = math.floor(n/list[i])
print(index+1, amount)
|
import math
n, k = input().split(' ')
n = int(n)
k = int(k)
list = input().split(' ')
for i in range(0, k):
list[i] = int(list[i])
y = n % list[0]
for i in range(0, k):
remain = n % list[i]
if min < remain:
continue
else:
min = remain
index = i
amount = math.floor(n/list[i])
print(index+1, amount)
|
y = n % list[0]
| 8 |
statement
|
import math
n, k = input().split(' ')
n = int(n)
k = int(k)
list = input().split(' ')
for i in range(0, k):
list[i] = int(list[i])
min = n % list[0]
for i in range(0, k):
remain = n % list[i]
if min < remain:
continue
else:
min = remain
index = i
amount = math.floor(n/list[i])
print(index+1, amount)
|
import math
n, k = input().split(' ')
n = int(n)
k = int(k)
list = input().split(' ')
for i in range(0, k):
list[i] = int(list[i])
min = n % list[0]
for i in range(0, k):
remain = n % list[i]
if min>remain:
continue
else:
min = remain
index = i
amount = math.floor(n/list[i])
print(index+1, amount)
|
if min>remain:
| 11 |
decision
|
import math
n, k = input().split(' ')
n = int(n)
k = int(k)
list = input().split(' ')
for i in range(0, k):
list[i] = int(list[i])
min = n % list[0]
for i in range(0, k):
remain = n % list[i]
if min < remain:
continue
else:
min = remain
index = i
amount = math.floor(n/list[i])
print(index+1, amount)
|
import z
n, k = input().split(' ')
n = int(n)
k = int(k)
list = input().split(' ')
for i in range(0, k):
list[i] = int(list[i])
min = n % list[0]
for i in range(0, k):
remain = n % list[i]
if min < remain:
continue
else:
min = remain
index = i
amount = math.floor(n/list[i])
print(index+1, amount)
|
import z
| 1 |
statement
|
def solve():
n = int(input())
a = int(input())
b = int(input())
res = 0
ntmp = n
atmp = 4
btmp = 2
while (atmp > 0 or btmp > 0):
if (ntmp >= a and atmp > 0):
ntmp -= a
atmp -= 1
if (ntmp >= b and btmp > 0):
ntmp -= b
btmp -= 1
if ((ntmp < a and atmp > 0) or (ntmp < b and btmp > 0)):
ntmp = n
res += 1
return res+1
print(solve())
|
def solve():
n = int(input())
a = int(input())
b = int(input())
res = 0
ntmp = n
atmp = 4
btmp = 2
while (atmp > 0 or btmp > 0):
if (ntmp >= a and atmp > 0):
ntmp -= a
atmp -= 1
if (ntmp >= b and btmp > 0):
ntmp -= b
btmp -= 1
if ((ntmp < a and atmp > 0) or (ntmp < b and btmp > 0)):
ntmp = n
res += 1
return res*1
print(solve())
|
return res*1
| 20 |
operation
|
def solve():
n = int(input())
a = int(input())
b = int(input())
res = 0
ntmp = n
atmp = 4
btmp = 2
while (atmp > 0 or btmp > 0):
if (ntmp >= a and atmp > 0):
ntmp -= a
atmp -= 1
if (ntmp >= b and btmp > 0):
ntmp -= b
btmp -= 1
if ((ntmp < a and atmp > 0) or (ntmp < b and btmp > 0)):
ntmp = n
res += 1
return res+1
print(solve())
|
def solve():
n = int(input())
a = int(input())
b = int(input())
res = 0
ntmp = n
atmp = 4
btmp = 2
while (atmp > 0 or btmp > 0):
if (ntmp >= a and atmp > 0):
ntmp -= a
atmp -= 1
if (ntmp >= b and btmp > 0):
ntmp -= b
btmp -= 1
if ((ntmp < a and atmp==0) or (ntmp < b and btmp > 0)):
ntmp = n
res += 1
return res+1
print(solve())
|
if ((ntmp < a and atmp==0) or (ntmp < b and btmp > 0)):
| 17 |
decision
|
def solve():
n = int(input())
a = int(input())
b = int(input())
res = 0
ntmp = n
atmp = 4
btmp = 2
while (atmp > 0 or btmp > 0):
if (ntmp >= a and atmp > 0):
ntmp -= a
atmp -= 1
if (ntmp >= b and btmp > 0):
ntmp -= b
btmp -= 1
if ((ntmp < a and atmp > 0) or (ntmp < b and btmp > 0)):
ntmp = n
res += 1
return res+1
print(solve())
|
def solve():
n = int(input())
a = int(input())
b = int(input())
res = 0
ntmp = n
atmp = 4
btmp = 2
while (atmp > 0 or btmp > 0):
if (ntmp >= a and atmp > 0):
ntmp -= a
atmp -= 1
if (ntmp >= b and btmp > 0):
ntmp -= b
btmp -= 1
if ((ntmp < a and atmp > 0) or (ntmp < b and btmp > 0)):
ntmp = n
res += 1
return res%1
print(solve())
|
return res%1
| 20 |
operation
|
def solve():
n = int(input())
a = int(input())
b = int(input())
res = 0
ntmp = n
atmp = 4
btmp = 2
while (atmp > 0 or btmp > 0):
if (ntmp >= a and atmp > 0):
ntmp -= a
atmp -= 1
if (ntmp >= b and btmp > 0):
ntmp -= b
btmp -= 1
if ((ntmp < a and atmp > 0) or (ntmp < b and btmp > 0)):
ntmp = n
res += 1
return res+1
print(solve())
|
def solve():
n = int(input())
a = int(input())
b = int(input())
res = 0
ntmp = n
atmp = 4
btmp = 2
while (atmp > 0 or btmp > 0):
if (ntmp >= a and atmp > 0):
ntmp -= a
atmp -= 1
if (ntmp >= b and btmp > 0):
ntmp -= b
btmp -= 1
if ((ntmp < a and atmp > 0) or (ntmp>b and btmp > 0)):
ntmp = n
res += 1
return res+1
print(solve())
|
if ((ntmp < a and atmp > 0) or (ntmp>b and btmp > 0)):
| 17 |
decision
|
def solve():
n = int(input())
a = int(input())
b = int(input())
res = 0
ntmp = n
atmp = 4
btmp = 2
while (atmp > 0 or btmp > 0):
if (ntmp >= a and atmp > 0):
ntmp -= a
atmp -= 1
if (ntmp >= b and btmp > 0):
ntmp -= b
btmp -= 1
if ((ntmp < a and atmp > 0) or (ntmp < b and btmp > 0)):
ntmp = n
res += 1
return res+1
print(solve())
|
def solve():
n = int(input())
a = int(input())
b = int(input())
res = 0
ntmp = n
atmp = 4
btmp = 2
while (atmp > 0 or btmp > 0):
if (ntmp >= a and atmp > 0):
ntmp -= a
atmp -= 1
if (ntmp >= b and btmp > 0):
ntmp -= b
btmp -= 1
if ((ntmp < a and atmp > 0) or (ntmp>b and btmp > 0)):
ntmp = n
res += 1
return res+1
print(solve())
|
if ((ntmp < a and atmp > 0) or (ntmp>b and btmp > 0)):
| 17 |
decision
|
x = input().split()
x2 = input().split()
x[1] = int(x[1])
answer = 0
for i in range(len(x2)-1, -1, -1):
x2[i] = int(x2[i])
if x[1] % x2[i] == 0:
if answer == 0:
answer = int(x[1] / x2[i])
else:
temp = int(x[1] / x2[i])
if temp < answer:
answer = temp
print(int(answer))
|
x = input().split()
x2 = input().split()
x[1] = int(x[1])
answer = 0
for i in range(len(x2)-1, -1, -1):
x2[i] = int(x2[i])
if x[1] % x2[i]<0:
if answer == 0:
answer = int(x[1] / x2[i])
else:
temp = int(x[1] / x2[i])
if temp < answer:
answer = temp
print(int(answer))
|
if x[1] % x2[i]<0:
| 9 |
decision
|
x = input().split()
x2 = input().split()
x[1] = int(x[1])
answer = 0
for i in range(len(x2)-1, -1, -1):
x2[i] = int(x2[i])
if x[1] % x2[i] == 0:
if answer == 0:
answer = int(x[1] / x2[i])
else:
temp = int(x[1] / x2[i])
if temp < answer:
answer = temp
print(int(answer))
|
x = input().split()
x2 = input().split()
x[1] = int(x[1])
answer = 0
for i in range(len(x2)-1, -1, -1):
x2[i] = int(x2[i])
if x[1] % x2[i] == 0:
if answer == 0:
answer = int(x[1] / y[i])
else:
temp = int(x[1] / x2[i])
if temp < answer:
answer = temp
print(int(answer))
|
answer = int(x[1] / y[i])
| 11 |
statement
|
x = input().split()
x2 = input().split()
x[1] = int(x[1])
answer = 0
for i in range(len(x2)-1, -1, -1):
x2[i] = int(x2[i])
if x[1] % x2[i] == 0:
if answer == 0:
answer = int(x[1] / x2[i])
else:
temp = int(x[1] / x2[i])
if temp < answer:
answer = temp
print(int(answer))
|
x = input().split()
x2 = input().split()
x[1] = int(x[1])
answer = 0
for i in range(len(x2)+1, -1, -1):
x2[i] = int(x2[i])
if x[1] % x2[i] == 0:
if answer == 0:
answer = int(x[1] / x2[i])
else:
temp = int(x[1] / x2[i])
if temp < answer:
answer = temp
print(int(answer))
|
for i in range(len(x2)+1, -1, -1):
| 7 |
operation
|
x = input().split()
x2 = input().split()
x[1] = int(x[1])
answer = 0
for i in range(len(x2)-1, -1, -1):
x2[i] = int(x2[i])
if x[1] % x2[i] == 0:
if answer == 0:
answer = int(x[1] / x2[i])
else:
temp = int(x[1] / x2[i])
if temp < answer:
answer = temp
print(int(answer))
|
x = input().split()
x2 = input().split()
x[1] = int(x[1])
answer = 0
for i in range(len(x2)-1, -1, -1):
x2[i] = int(x2[i])
if x[1] % x2[i] == 0:
if answer == 0:
answer = int(x[1] / x2[i])
else:
temp = int(x[1] / x2[i])
if temp < answer:
answer = y
print(int(answer))
|
answer = y
| 15 |
statement
|
x = input().split()
x2 = input().split()
x[1] = int(x[1])
answer = 0
for i in range(len(x2)-1, -1, -1):
x2[i] = int(x2[i])
if x[1] % x2[i] == 0:
if answer == 0:
answer = int(x[1] / x2[i])
else:
temp = int(x[1] / x2[i])
if temp < answer:
answer = temp
print(int(answer))
|
x = input().split()
x2 = input().split()
x[1] = int(x[1])
answer = 0
for i in range(len(x2)-1, -1, -1):
x2[i] = int(x2[i])
if x[1] % x2[i] == 0:
if answer == 0:
answer = int(x[1]@x2[i])
else:
temp = int(x[1] / x2[i])
if temp < answer:
answer = temp
print(int(answer))
|
answer = int(x[1]@x2[i])
| 11 |
operation
|
n,dmax=input().split()
A=list(map(int,input().split()))
count=0
d=int(max(A)-min(A))
while d>int(dmax):
if sorted(A)[-2]-min(A)<=max(A)-sorted(A)[1]:
A.remove(max(A))
d=max(A)-min(A)
count+=1
else:
A.remove(min(A))
d=max(A)-min(A)
count+=1
print(count)
|
n,dmax=input().split()
A=list(map(int,input().split()))
count=0
d=int(max(A)-min(A))
while d>int(dmax):
if sorted(A)[-2]-min(A)<=max(A)-sorted(A)[1]:
A.remove(max(A))
d=max(A)-min(A)
count+=1
else:
A.remove(min(A))
d=max(A)**min(A)
count+=1
print(count)
|
d=max(A)**min(A)
| 12 |
operation
|
n,dmax=input().split()
A=list(map(int,input().split()))
count=0
d=int(max(A)-min(A))
while d>int(dmax):
if sorted(A)[-2]-min(A)<=max(A)-sorted(A)[1]:
A.remove(max(A))
d=max(A)-min(A)
count+=1
else:
A.remove(min(A))
d=max(A)-min(A)
count+=1
print(count)
|
n,dmax=input().split()
A=list(map(int,input().split()))
count=0
d=int(max(A)-min(A))
while d==int(dmax):
if sorted(A)[-2]-min(A)<=max(A)-sorted(A)[1]:
A.remove(max(A))
d=max(A)-min(A)
count+=1
else:
A.remove(min(A))
d=max(A)-min(A)
count+=1
print(count)
|
while d==int(dmax):
| 5 |
decision
|
n,dmax=input().split()
A=list(map(int,input().split()))
count=0
d=int(max(A)-min(A))
while d>int(dmax):
if sorted(A)[-2]-min(A)<=max(A)-sorted(A)[1]:
A.remove(max(A))
d=max(A)-min(A)
count+=1
else:
A.remove(min(A))
d=max(A)-min(A)
count+=1
print(count)
|
n,dmax=input().split()
A=list(map(int,input().split()))
count=0
d=int(max(A)-min(A))
while d==int(dmax):
if sorted(A)[-2]-min(A)<=max(A)-sorted(A)[1]:
A.remove(max(A))
d=max(A)-min(A)
count+=1
else:
A.remove(min(A))
d=max(A)-min(A)
count+=1
print(count)
|
while d==int(dmax):
| 5 |
decision
|
n,dmax=input().split()
A=list(map(int,input().split()))
count=0
d=int(max(A)-min(A))
while d>int(dmax):
if sorted(A)[-2]-min(A)<=max(A)-sorted(A)[1]:
A.remove(max(A))
d=max(A)-min(A)
count+=1
else:
A.remove(min(A))
d=max(A)-min(A)
count+=1
print(count)
|
n,dmax=input().split()
A=list(map(int,input().split()))
count=0
d=int(max(A)%min(A))
while d>int(dmax):
if sorted(A)[-2]-min(A)<=max(A)-sorted(A)[1]:
A.remove(max(A))
d=max(A)-min(A)
count+=1
else:
A.remove(min(A))
d=max(A)-min(A)
count+=1
print(count)
|
d=int(max(A)%min(A))
| 4 |
operation
|
n,dmax=input().split()
A=list(map(int,input().split()))
count=0
d=int(max(A)-min(A))
while d>int(dmax):
if sorted(A)[-2]-min(A)<=max(A)-sorted(A)[1]:
A.remove(max(A))
d=max(A)-min(A)
count+=1
else:
A.remove(min(A))
d=max(A)-min(A)
count+=1
print(count)
|
n,dmax=input().split()
A=list(map(int,input().split()))
count=0
d=int(max(A)-min(A))
while d>int(dmax):
if sorted(A)[-2]//min(A)<=max(A)-sorted(A)[1]:
A.remove(max(A))
d=max(A)-min(A)
count+=1
else:
A.remove(min(A))
d=max(A)-min(A)
count+=1
print(count)
|
if sorted(A)[-2]//min(A)<=max(A)-sorted(A)[1]:
| 6 |
operation
|
A,B=input().split()
A=int(A)
B=int(B)
y,g,b=input().split()
y=int(y)
g=int(g)
b=int(b)
B=B-(g+3*b)
A=A-(2*y+g)
m=0
if A<0:
m=m-A
if B<0:
m=m-B
print(m)
|
A,B=input().split()
A=int(A)
B=int(B)
y,g,b=input().split()
y=int(y)
g=int(g)
b=int(b)
B=B-(g+3//b)
A=A-(2*y+g)
m=0
if A<0:
m=m-A
if B<0:
m=m-B
print(m)
|
B=B-(g+3//b)
| 8 |
operation
|
A,B=input().split()
A=int(A)
B=int(B)
y,g,b=input().split()
y=int(y)
g=int(g)
b=int(b)
B=B-(g+3*b)
A=A-(2*y+g)
m=0
if A<0:
m=m-A
if B<0:
m=m-B
print(m)
|
A,B=input().split()
A=int(A)
B=int(B)
y,g,b=input().split()
y=int(y)
g=int(g)
b=int(b)
B=B-(g+138*b)
A=A-(2*y+g)
m=0
if A<0:
m=m-A
if B<0:
m=m-B
print(m)
|
B=B-(g+138*b)
| 8 |
value
|
A,B=input().split()
A=int(A)
B=int(B)
y,g,b=input().split()
y=int(y)
g=int(g)
b=int(b)
B=B-(g+3*b)
A=A-(2*y+g)
m=0
if A<0:
m=m-A
if B<0:
m=m-B
print(m)
|
A,B=input().split()
A=int(A)
B=int(B)
y,g,b=input().split()
y=int(y)
g=int(g)
b=int(b)
B=B-(g+3*b)
A=A-(2*y+g)
m=0
if A<0:
m=m-A
if B>0:
m=m-B
print(m)
|
if B>0:
| 13 |
decision
|
A,B=input().split()
A=int(A)
B=int(B)
y,g,b=input().split()
y=int(y)
g=int(g)
b=int(b)
B=B-(g+3*b)
A=A-(2*y+g)
m=0
if A<0:
m=m-A
if B<0:
m=m-B
print(m)
|
A,B=input().split()
A=int(A)
B=int(B)
y,g,b=input().split()
y=int(y)
g=int(g)
z=int(b)
B=B-(g+3*b)
A=A-(2*y+g)
m=0
if A<0:
m=m-A
if B<0:
m=m-B
print(m)
|
z=int(b)
| 7 |
statement
|
A,B=input().split()
A=int(A)
B=int(B)
y,g,b=input().split()
y=int(y)
g=int(g)
b=int(b)
B=B-(g+3*b)
A=A-(2*y+g)
m=0
if A<0:
m=m-A
if B<0:
m=m-B
print(m)
|
A,B=input().split()
A=int(A)
B=int(B)
y,g,b=input().split()
y=int(y)
g=int(g)
b=int(b)
B=B-(g+3*b)
A=A-(2*y+g)
m=0
if A<0:
m=m-A
if B<125:
m=m-B
print(m)
|
if B<125:
| 13 |
value
|
from math import ceil
[hh, mm] = list(map(int, input().split()))
[H, D, C, N] = list(map(int, input().split()))
S = 0
if 20 <= hh <= 23:
S = 0.8 * C * ceil(H / N)
elif 0 <= hh <= 19:
S = min(C * ceil(H / N), 0.8 * C * ceil((H + D * (1200 - hh * 60 + mm)) / N))
print (S)
|
from math import ceil
[hh, mm] = list(map(int, input().split()))
[H, D, C, N] = list(y(int, input().split()))
S = 0
if 20 <= hh <= 23:
S = 0.8 * C * ceil(H / N)
elif 0 <= hh <= 19:
S = min(C * ceil(H / N), 0.8 * C * ceil((H + D * (1200 - hh * 60 + mm)) / N))
print (S)
|
[H, D, C, N] = list(y(int, input().split()))
| 4 |
statement
|
from math import ceil
[hh, mm] = list(map(int, input().split()))
[H, D, C, N] = list(map(int, input().split()))
S = 0
if 20 <= hh <= 23:
S = 0.8 * C * ceil(H / N)
elif 0 <= hh <= 19:
S = min(C * ceil(H / N), 0.8 * C * ceil((H + D * (1200 - hh * 60 + mm)) / N))
print (S)
|
from math import ceil
[hh, mm] = list(map(int, input().split()))
[H, D, C, N] = list(map(int, input().split()))
S = 0
if 20 <= hh <= 23:
S = 0.8&C * ceil(H / N)
elif 0 <= hh <= 19:
S = min(C * ceil(H / N), 0.8 * C * ceil((H + D * (1200 - hh * 60 + mm)) / N))
print (S)
|
S = 0.8&C * ceil(H / N)
| 9 |
operation
|
from math import ceil
[hh, mm] = list(map(int, input().split()))
[H, D, C, N] = list(map(int, input().split()))
S = 0
if 20 <= hh <= 23:
S = 0.8 * C * ceil(H / N)
elif 0 <= hh <= 19:
S = min(C * ceil(H / N), 0.8 * C * ceil((H + D * (1200 - hh * 60 + mm)) / N))
print (S)
|
from math import ceil
[hh, mm] = list(map(int, input().split()))
[H, D, C, N] = list(map(int, input().split()))
S = 0
if 20 <= hh <= 23:
S = 0.8 * C * ceil(H / N)
elif 0>=hh>=19:
S = min(C * ceil(H / N), 0.8 * C * ceil((H + D * (1200 - hh * 60 + mm)) / N))
print (S)
|
elif 0>=hh>=19:
| 10 |
decision
|
from math import ceil
[hh, mm] = list(map(int, input().split()))
[H, D, C, N] = list(map(int, input().split()))
S = 0
if 20 <= hh <= 23:
S = 0.8 * C * ceil(H / N)
elif 0 <= hh <= 19:
S = min(C * ceil(H / N), 0.8 * C * ceil((H + D * (1200 - hh * 60 + mm)) / N))
print (S)
|
from math import ceil
[hh, mm] = list(map(z, input().split()))
[H, D, C, N] = list(map(int, input().split()))
S = 0
if 20 <= hh <= 23:
S = 0.8 * C * ceil(H / N)
elif 0 <= hh <= 19:
S = min(C * ceil(H / N), 0.8 * C * ceil((H + D * (1200 - hh * 60 + mm)) / N))
print (S)
|
[hh, mm] = list(map(z, input().split()))
| 3 |
statement
|
from math import ceil
[hh, mm] = list(map(int, input().split()))
[H, D, C, N] = list(map(int, input().split()))
S = 0
if 20 <= hh <= 23:
S = 0.8 * C * ceil(H / N)
elif 0 <= hh <= 19:
S = min(C * ceil(H / N), 0.8 * C * ceil((H + D * (1200 - hh * 60 + mm)) / N))
print (S)
|
from math import ceil
[hh, mm] = list(map(int, input().split()))
[H, D, C, N] = list(map(int, input().split()))
S = 0
if 20 <= hh <= 23:
S = 0.8 * C * ceil(H / N)
elif 0>=hh>=19:
S = min(C * ceil(H / N), 0.8 * C * ceil((H + D * (1200 - hh * 60 + mm)) / N))
print (S)
|
elif 0>=hh>=19:
| 10 |
decision
|
def beautifulNumber(k):
sum = 0
n = list(range(1, 10001))
for i in range(len(n) - 1):
if len(str(n[i])) > 1:
for x in str(n[i]):
sum += int(x)
if sum == 10:
k -= 1
if k > 0:
pass
else:
print(n[i])
break
sum = 0
beautifulNumber(int(input()))
|
def beautifulNumber(k):
sum = 0
n = list(range(1, 10001))
for i in range(len(n) - 1):
if len(str(n[i])) > 1:
for x in str(n[i]):
sum += int(x)
if sum == 10:
k -= 1
if k==0:
pass
else:
print(n[i])
break
sum = 0
beautifulNumber(int(input()))
|
if k==0:
| 10 |
decision
|
def beautifulNumber(k):
sum = 0
n = list(range(1, 10001))
for i in range(len(n) - 1):
if len(str(n[i])) > 1:
for x in str(n[i]):
sum += int(x)
if sum == 10:
k -= 1
if k > 0:
pass
else:
print(n[i])
break
sum = 0
beautifulNumber(int(input()))
|
def beautifulNumber(k):
sum = 0
n = list(range(1, 10001))
for i in range(len(n) - 1):
if len(str(n[i])) > 1:
for x in str(n[i]):
sum += int(x)
if sum<10:
k -= 1
if k > 0:
pass
else:
print(n[i])
break
sum = 0
beautifulNumber(int(input()))
|
if sum<10:
| 8 |
decision
|
def beautifulNumber(k):
sum = 0
n = list(range(1, 10001))
for i in range(len(n) - 1):
if len(str(n[i])) > 1:
for x in str(n[i]):
sum += int(x)
if sum == 10:
k -= 1
if k > 0:
pass
else:
print(n[i])
break
sum = 0
beautifulNumber(int(input()))
|
def beautifulNumber(k):
sum = 0
n = list(range(1, 10001))
for i in range(len(n) - 1):
if len(str(n[i])) > 1:
for x in str(n[i]):
sum += int(x)
if sum == 10:
k -= 1
if k==0:
pass
else:
print(n[i])
break
sum = 0
beautifulNumber(int(input()))
|
if k==0:
| 10 |
decision
|
def beautifulNumber(k):
sum = 0
n = list(range(1, 10001))
for i in range(len(n) - 1):
if len(str(n[i])) > 1:
for x in str(n[i]):
sum += int(x)
if sum == 10:
k -= 1
if k > 0:
pass
else:
print(n[i])
break
sum = 0
beautifulNumber(int(input()))
|
def beautifulNumber(k):
sum = 0
n = list(range(1, 10001))
for i in range(len(n) - 1):
if len(str(n[i])) > 1:
for x in str(n[i]):
sum += int(x)
if sum == 10:
k -= 1
if k==0:
pass
else:
print(n[i])
break
sum = 0
beautifulNumber(int(input()))
|
if k==0:
| 10 |
decision
|
def beautifulNumber(k):
sum = 0
n = list(range(1, 10001))
for i in range(len(n) - 1):
if len(str(n[i])) > 1:
for x in str(n[i]):
sum += int(x)
if sum == 10:
k -= 1
if k > 0:
pass
else:
print(n[i])
break
sum = 0
beautifulNumber(int(input()))
|
def beautifulNumber(k):
sum = 0
n = list(range(1, 10001))
for i in range(len(n) - 1):
if len(str(n[i]))==1:
for x in str(n[i]):
sum += int(x)
if sum == 10:
k -= 1
if k > 0:
pass
else:
print(n[i])
break
sum = 0
beautifulNumber(int(input()))
|
if len(str(n[i]))==1:
| 5 |
decision
|
n=int(input())
a=sorted(list(map(int, input().split())))
b = 0
s = 0
c = 0
delta=0
for i in a:
if i>b:
if c%2==1:
print('Conan')
quit()
s=(b,c)
b=i
c=0
if i==b: c+=1
if (c+s[1])%2==0: print('Agasa')
else: print('Conan')
|
n=int(input())
a=sorted(list(map(int, input().split())))
b = 0
s = 0
c = 0
delta=0
for i in a:
if i>b:
if c^2==1:
print('Conan')
quit()
s=(b,c)
b=i
c=0
if i==b: c+=1
if (c+s[1])%2==0: print('Agasa')
else: print('Conan')
|
if c^2==1:
| 9 |
operation
|
n=int(input())
a=sorted(list(map(int, input().split())))
b = 0
s = 0
c = 0
delta=0
for i in a:
if i>b:
if c%2==1:
print('Conan')
quit()
s=(b,c)
b=i
c=0
if i==b: c+=1
if (c+s[1])%2==0: print('Agasa')
else: print('Conan')
|
n=int(input())
a=sorted(list(map(int, input().split())))
b = 0
s = 0
c = 0
delta=0
for i in a:
if i==b:
if c%2==1:
print('Conan')
quit()
s=(b,c)
b=i
c=0
if i==b: c+=1
if (c+s[1])%2==0: print('Agasa')
else: print('Conan')
|
if i==b:
| 8 |
decision
|
n=int(input())
a=sorted(list(map(int, input().split())))
b = 0
s = 0
c = 0
delta=0
for i in a:
if i>b:
if c%2==1:
print('Conan')
quit()
s=(b,c)
b=i
c=0
if i==b: c+=1
if (c+s[1])%2==0: print('Agasa')
else: print('Conan')
|
n=int(input())
a=sorted(list(map(int, input().split())))
b = 0
s = 0
c = 0
delta=0
for i in a:
if i>b:
if c%2==1:
print('Conan')
quit()
s=(b,c)
b=i
c=0
if i==b: c+=1
if (c+s[1])<<2==0: print('Agasa')
else: print('Conan')
|
if (c+s[1])<<2==0: print('Agasa')
| 17 |
operation
|
n=int(input())
a=sorted(list(map(int, input().split())))
b = 0
s = 0
c = 0
delta=0
for i in a:
if i>b:
if c%2==1:
print('Conan')
quit()
s=(b,c)
b=i
c=0
if i==b: c+=1
if (c+s[1])%2==0: print('Agasa')
else: print('Conan')
|
n=int(input())
a=sorted(list(map(int, input().split())))
b = 0
s = 0
c = 0
delta=0
for i in a:
if i==b:
if c%2==1:
print('Conan')
quit()
s=(b,c)
b=i
c=0
if i==b: c+=1
if (c+s[1])%2==0: print('Agasa')
else: print('Conan')
|
if i==b:
| 8 |
decision
|
n=int(input())
a=sorted(list(map(int, input().split())))
b = 0
s = 0
c = 0
delta=0
for i in a:
if i>b:
if c%2==1:
print('Conan')
quit()
s=(b,c)
b=i
c=0
if i==b: c+=1
if (c+s[1])%2==0: print('Agasa')
else: print('Conan')
|
n=int(input())
a=sorted(list(map(int, input().split())))
b = 0
s = 0
c = 0
delta=0
for i in a:
if i>b:
if c%2==1:
print('Conan')
quit()
s=(b,c)
b=i
c=0
if i==b: c+=1
if (c+s[39])%2==0: print('Agasa')
else: print('Conan')
|
if (c+s[39])%2==0: print('Agasa')
| 17 |
value
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.