code1
stringlengths 16
427k
| code2
stringlengths 16
427k
| similar
int64 0
1
| pair_id
int64 6.82M
181,637B
⌀ | question_pair_id
float64 101M
180,471B
⌀ | code1_group
int64 2
299
| code2_group
int64 2
299
|
|---|---|---|---|---|---|---|
h,w=map(int,input().split())
grid=[[1 if s=='#' else 0 for s in list(input())] for i in range(h)]
#print(grid)
maxi=10**5
from collections import deque
visited=[[maxi]*w for _ in range(h)]
def bfs(s):
q=deque()
q.append(s)
visited[s[0]][s[1]]=grid[s[0]][s[1]]
for r in range(h):
for c in range(w):
if r>=1:
visited[r][c]=min(visited[r][c],visited[r-1][c]+grid[r][c])
if grid[r-1][c]==1:
visited[r][c]=min(visited[r][c],visited[r-1][c])
if c>=1:
visited[r][c]=min(visited[r][c],visited[r][c-1]+grid[r][c])
if grid[r][c-1]==1:
visited[r][c]=min(visited[r][c],visited[r][c-1])
bfs([0,0])
print(visited[-1][-1]) | N, S = map(int, input().split())
MOD = 998244353
A = list(map(int, input().split()))
dp = [[0]*(S+1) for i in range(N+1)]
dp[0][0] = 1
for i, a in enumerate(A, 1):
for s in range(S+1):
dp[i][s] = 2*dp[i-1][s]
if a <= s:
dp[i][s] += dp[i-1][s-a]
dp[i][s] %= MOD
print(dp[-1][-1]) | 0 | null | 33,762,230,078,938 | 194 | 138 |
n,k,c = map(int,input().split())
s = list(input())
L = []
R = []
i = -1
j = n
for ki in range(k):
while i < n:
i += 1
if s[i] == 'o':
L += [i]
i += c
break
for ki in range(k):
while 0 <= j:
j -= 1
if s[j] == 'o':
R += [j]
j -= c
break
for i in range(k):
if L[i] == R[-i-1] :
print(L[i]+1) | a,b,c,d=map(int,input().split())
A=a*c
B=a*d
C=b*c
D=b*d
N=[A,B,C,D]
print(max(N)) | 0 | null | 21,799,646,296,946 | 182 | 77 |
def main():
X = int(input())
if X == 2:
print(2)
exit()
if X % 2 == 0:
X += 1
while True:
flag = True
for i in range(3, X, 2):
if X % i == 0:
flag = False
break
if flag is True:
print(X)
break
else:
X += 2
if __name__ == '__main__':
main()
| N = int(input())
def prime_check(num):
for i in range(2, num):
if num % i == 0:
return False
return True
for x in range(N, 1000000):
if prime_check(x):
print(x)
exit() | 1 | 106,068,949,544,798 | null | 250 | 250 |
S = input()[::-1]
S_mod = [0] * (len(S)+1)
S_mod[0] = int(S[0])
d = 10
for i in range(len(S)-1):
S_mod[i + 1] = (S_mod[i] + int(S[i+1])*d)%2019
d = d * 10 % 2019
mod_count = [0] * 2019
for i in range(len(S_mod)):
mod_count[S_mod[i]] += 1
count = 0
for i in range(2019):
count += mod_count[i] * (mod_count[i] - 1) / 2
print(int(count)) | #https://atcoder.jp/contests/abc148/tasks/abc148_b
N = int(input())
a,b = map(str,input().split())
moji = ""
for i in range(N):
moji += a[i]+b[i]
print(moji) | 0 | null | 71,611,085,589,262 | 166 | 255 |
from sys import stdin
input = stdin.readline
a,b,n = map(int,input().split())
maxpoint = 0
if b > n :
tmp = int((a * n) / b) - a * int(n/b)
maxpoint = max(tmp,maxpoint)
else:
k = int(n/b)*b -1
maxpoint = int((a * k) / b) - a * int(k/b)
if b == 1:
maxpoint = 0
print(maxpoint) | import sys
import math
def resolve(in_):
a, b, n = map(int, next(in_).split())
x = min(b - 1, n)
return math.floor(a * x / b) - a * math.floor(x / b)
def main():
answer = resolve(sys.stdin.buffer)
print(answer)
if __name__ == '__main__':
main()
| 1 | 28,110,830,709,628 | null | 161 | 161 |
a, b, m = map(int, input().strip().split())
as_ = list(map(int, input().strip().split()))
bs = list(map(int, input().strip().split()))
xyc = [list(map(int, input().strip().split())) for _ in range(m)]
min_no_discount = min(as_) + min(bs)
min_discount = 1e20
for x, y, c in xyc:
min_discount = min(min_discount, as_[x - 1] + bs[y - 1] - c)
print(min(min_discount, min_no_discount))
| a,b,c,d = map(int,input().split())
cnt = d-a
if cnt > 0:
num = 1*a
cnt -=b
if cnt > 0:
num = a + (d-a-b)*(-1)
else:
num = 1*d
print(num) | 0 | null | 37,994,895,836,230 | 200 | 148 |
N,A,B = map(int,input().split())
a = N//(A+B)
b = N%(A+B)
if b>A:
print(a*A+A)
else:
print(a*A+b) | n, a, b = map(int, input().split())
c = a + b
div = n // c
mod = n % c
if mod > a:
mod = a
ans = div * a + mod
print(ans)
| 1 | 55,300,912,047,260 | null | 202 | 202 |
from operator import itemgetter
n=int(input())
xl=[list(map(int,input().split()))for i in range(n)]
R=[(xl[i][0]-xl[i][1],xl[i][0]+xl[i][1]) for i in range(n)]
r=sorted([(R[i][0],R[i][1]) for i in range(n)],key=itemgetter(1))
s=r[0][1]
ans=1
for i in range(n-1):
if r[i+1][0]>=s:
s=r[i+1][1]
ans+=1
print(ans) | #!/usr/bin/env python3
(n, ), *r = [[*map(int, i.split())] for i in open(0)]
s = sorted([[x + l, x - l] for x, l in r])
c = 1
p = s[0][0]
for i in s[1:]:
if i[1] >= p:
c += 1
p = i[0]
print(c)
| 1 | 89,390,821,040,418 | null | 237 | 237 |
import sys
#from collections import defaultdict, deque, Counter
#import bisect
#import heapq
#import math
#from itertools import accumulate
#from itertools import permutations as perm
#from itertools import combinations as comb
#from itertools import combinations_with_replacement as combr
#from fractions import gcd
#import numpy as np
stdin = sys.stdin
sys.setrecursionlimit(10 ** 7)
MIN = -10 ** 9
MOD = 10 ** 9 + 7
INF = float("inf")
IINF = 10 ** 18
def main():
#n = int(stdin.readline().rstrip())
h1,m1,h2,m2,k = map(int, stdin.readline().rstrip().split())
#l = list(map(int, stdin.readline().rstrip().split()))
#numbers = [[int(c) for c in l.strip().split()] for l in sys.stdin]
#word = [stdin.readline().rstrip() for _ in range(n)]
#number = [[int(c) for c in stdin.readline().rstrip()] for _ in range(n)]
#zeros = [[0] * w for i in range(h)]
wake = (h2-h1)*60 + m2-m1
ans = wake - k
print(ans)
main()
| def ok(p,w,k):
track= 1
weight= 0
flag= True
for i in w:
if i > p:
flag=False
break
elif weight+ i> p:
weight= i
track+= 1
else:
weight+= i
if track<=k and flag:
return True
else:
return False
n,k= map(int, input().split())
w=[]
for i in range(n):
w.append(int(input()))
l=0
h=10**11
while l+1 < h:
p= (l+h)//2
if ok(p,w,k):
h= p
else:
l= p
print(h)
| 0 | null | 9,104,659,078,550 | 139 | 24 |
n = int(input())
s = [str(input()) for i in range(n)]
a = s.count(('AC'))
b = s.count(('WA'))
c = s.count(('TLE'))
d = s.count(('RE'))
print("AC x {}".format(a))
print("WA x {}".format(b))
print("TLE x {}".format(c))
print("RE x {}".format(d))
| import sys
read = sys.stdin.buffer.read
s = read().decode("utf-8")
H = s[:(len(s) - 1) // 2]
B = s[(len(s) - 1) // 2 + 1:-1]
if s[:-1] == s[:-1][::-1] and H == H[::-1] and B == B[::-1]:
print("Yes")
else:
print("No") | 0 | null | 27,662,726,755,482 | 109 | 190 |
S = input()
N = len(S)
ans = 0
i = 0
while i < N and S[i]=='>':
i += 1
ans += i*(i+1)//2
arr = [i]
while i < N:
while i < N and S[i]=='<':
i += 1
arr.append(i)
if i==N: break
while i < N and S[i]=='>':
i += 1
arr.append(i)
arr = [b-a for a,b in zip(arr,arr[1:])]
for a,b in zip(arr[::2],arr[1::2]):
if a<b: a,b = b,a
ans += a*(a+1)//2
ans += b*(b-1)//2
if len(arr)%2:
ans += arr[-1]*(arr[-1]+1)//2
print(ans) | n = int(raw_input())
a = [int(x) for x in raw_input().split()]
q = int(raw_input())
op = []
for _ in xrange(q):
v = raw_input().split()
op.append([int(x) for x in v])
d = {}
total = 0
for v in a:
d[v] = d.get(v, 0) + 1
total += v
for src, dest in op:
c = d.pop(src, 0)
d[dest] = d.get(dest, 0) + c
total += c * (dest - src)
print total | 0 | null | 84,541,745,586,100 | 285 | 122 |
def make_divisors(n):
divisors = []
for i in range(1, int(n**0.5)+1):
tmp = []
if n % i == 0:
tmp.append(i)
tmp.append(n//i)
if(len(tmp)>0):
divisors.append(sum(tmp))
return divisors
def main5():
n = int(input())
k = make_divisors(n)
print(min(k)-2)
if __name__ == '__main__':
main5()
| h1, m1, h2, m2, k = list(map(int, input().split()))
#n, m = list(map(int, input().split()))
# a = list(map(int, input().split()))
# data = [list(map(int, input().split())) for i in range(n)]
# k = int(input())
# a = list(map(int, input().split()))
# ab_sorted = sorted(ab, key=lambda x: x[0])
#py = [list(map(int, input().split())) for i in range(m)]
# b = list(map(int, input().split()))
total = (h2-h1)*60
if m1 <= m2:
total += (m2-m1)
else:
if m2 == 0:
total += 60-m1
total -= 60
else:
#total += (m1-m2)
total -= (m1-m2)
ans = total - k
print(ans)
| 0 | null | 89,606,492,784,442 | 288 | 139 |
num_of_squares = int(input())
written_values = [i for i in input().split(" ")]
flag = 0
for i in range(num_of_squares):
if ((i + 1) % 2 != 0) & (int(written_values[i]) % 2 != 0):
flag += 1
print(flag)
| choise = {1, 2, 3}
for i in range(2):
choise.remove(int(input()))
print(list(choise)[0]) | 0 | null | 59,071,873,241,472 | 105 | 254 |
# n, m, l = map(int, input().split())
# list_n = list(map(int, input().split()))
# n = input()
# list = [input() for i in range(N)
# list = [[i for i in range(N)] for _ in range(M)]
import sys
input = sys.stdin.readline
A, B, M = map(int, input().split())
List_A = list(map(int, input().split()))
List_B = list(map(int, input().split()))
List_discount = [list(map(int, input().split())) for i in range(M)]
# print(List_discount)
ans = 2 * 10**5
for d in List_discount:
# print(d)
p = List_A[d[0]-1] + List_B[d[1]-1] - d[2]
ans = min(ans, p)
no_discount = min(List_A) + min(List_B)
ans = min(ans, no_discount)
print(ans)
| n = int(input())
s = input()
for i in s:
i = ord(i) + n
if (i > 90):
d = i - 90
print(chr(64+d),end = '')
else:
print(chr(i),end = '') | 0 | null | 94,539,460,884,620 | 200 | 271 |
x=int(input())
a=x
i=0
j=0
if 500<= x:
while i*500<x:
i+=1
i-=1
x-=500*i
if 5<=x:
while j*5<x:
j+=1
j-=1
if i==0 and j==0:
print(0)
elif a%500==0:
print(a//500 * 1000)
else:
print(1000*i+5*j)
| # coding: utf-8
x = int(input())
ans = x // 500
x = x - ans * 500
ans = ans * 1000
ans += (x // 5 * 5)
print(ans) | 1 | 42,937,495,638,148 | null | 185 | 185 |
n = int(input())
a = list(map(int, input().split()))
a = a + [0]
state = a[0]
money = 1000
stock = 0
for i in range(1, n+1):
if state < a[i] and stock == 0:
stock += (money // state)
money %= state
elif state > a[i] and stock > 0:
money += (stock * state)
stock = 0
state = a[i]
print(money)
| import sys
def input(): return sys.stdin.readline().strip()
def mapint(): return map(int, input().split())
sys.setrecursionlimit(10**9)
T1, T2 = mapint()
A1, A2 = mapint()
B1, B2 = mapint()
if not (A1-B1)*(A2-B2)<0:
print(0)
else:
if A1<B1:
A1, B1 = B1, A1
A2, B2 = B2, A2
if A1*T1+A2*T2==B1*T1+B2*T2:
print('infinity')
exit(0)
rest = (A1-B1)*T1
come = (B2-A2)*T2
if come<rest:
print(0)
else:
ans = come//(come-rest)
last = 1 if come%(come-rest)==0 else 0
print(ans*2-1-last) | 0 | null | 69,457,421,708,350 | 103 | 269 |
def main():
num=map(int,input().split())
print(" ".join([str(x) for x in sorted(num)]))
if __name__=='__main__':
main()
| list = []
a, b, c = map(list.append, raw_input().split())
list = sorted(list)
for i in range(3):
print list[i], | 1 | 423,998,192,700 | null | 40 | 40 |
N,K = map(int,input().split())
A = list(map(int,input().split()))
MOD = 10**9+7
if all(a>=0 for a in A):
A.sort()
ans = 1
for _ in range(K):
ans *= A.pop()
ans %= MOD
print(ans)
exit()
if all(a<0 for a in A):
A.sort(reverse=K%2==0)
ans = 1
for _ in range(K):
ans *= A.pop()
ans %= MOD
print(ans)
exit()
if N==K:
ans = 1
for a in A:
ans *= a
ans %= MOD
print(ans)
exit()
arr = []
for a in A:
if a < 0:
arr.append((-a,1))
else:
arr.append((a,0))
arr.sort()
pz = []
ng = []
ans = 1
for _ in range(K):
v,s = arr.pop()
if s:
ng.append(v)
else:
pz.append(v)
for v in ng:
ans *= v
ans %= MOD
for v in pz:
ans *= v
ans %= MOD
if len(ng)%2 == 0:
print(ans)
exit()
b = pz[-1] if pz else None
c = ng[-1] if ng else None
a = d = None
while arr and (a is None or d is None):
v,s = arr.pop()
if s:
if a is None:
a = v
else:
if d is None:
d = v
if (a is None or b is None) and (c is None or d is None):
assert False
if a is None or b is None:
ans *= d * pow(c,-1,MOD)
elif c is None or d is None:
ans *= a * pow(b,-1,MOD)
else:
if a*c > b*d:
ans *= a * pow(b,-1,MOD)
else:
ans *= d * pow(c,-1,MOD)
ans %= MOD
print(ans) | import sys
input = sys.stdin.readline
from collections import defaultdict, deque
n, s, res, MOD = int(input()), list(map(int, input().split())), 0, int(1e9) + 7
for i in range(61):
x, c = int(pow(2, i, MOD)), [0, 0]
for j in range(n): c[1 if s[j] & 1 << i else 0] += 1
x = (x * c[0]) % MOD; x = (x * c[1]) % MOD; res = (res + x) % MOD
print(res) | 0 | null | 66,068,617,588,556 | 112 | 263 |
n, k = map(int, input().split())
p = list(map(int, input().split()))
c = list(map(int, input().split()))
p.insert(0, 0)
c.insert(0, 0)
visit = [0] * (n + 1)
cyclelist = []
for i in range(1, n + 1):
if visit[i] == 0:
a = [c[i]]
visit[i] = 1
while visit[p[i]] == 0:
i = p[i]
visit[i] = 1
a.append(c[i])
cyclelist.append(a)
ans = -1145141919810
for cycle in cyclelist:
s = sum(cycle)
l = len(cycle)
a = 0
if l < k and s > 0:
a = s * ((k - 1) // l)
now = 0
x = k % l
if x == 0:
x = l
for i in range(min(k, l)):
now += cycle[i]
for j in range(l):
now += cycle[(i + j + 1) % l] - cycle[j]
if i < x:
ans = max(ans, a + now)
else:
ans = max(ans, now)
print(ans) | #!/usr/bin/env python3
# input
n, k = map(int, input().split())
p = list(map(int, input().split()))
c = list(map(int, input().split()))
for i in range(n):
p[i] -= 1
# calc
ans = -int(1e18)
for si in range(n):
x = si
s = []
opscore = 0
while True:
x = p[x]
opscore += c[x]
s.append(c[x])
if x == si:
break
oplen = len(s)
t = 0
for i in range(oplen):
t += s[i]
if i+1 > k:
break
now = t
if opscore > 0:
e = (k-(i+1))//oplen
now += opscore * e
ans = max(ans, now)
print(ans)
| 1 | 5,300,833,128,150 | null | 93 | 93 |
import sys
read = sys.stdin.buffer.read
readline = sys.stdin.buffer.readline
readlines = sys.stdin.buffer.readlines
S = readline().decode().rstrip()
if S == 'ABC':
print('ARC')
else:
print('ABC') | s = int(input())
print(s**2)
| 0 | null | 84,220,316,980,360 | 153 | 278 |
import math
x = int(input())
y = 360
lcm = x * y // math.gcd(x, y)
print(lcm//x)
| import sys
sys.setrecursionlimit(10**7)
input = sys.stdin.readline
INF = 10**9
# 個数制限なしナップザック問題
h,n = map(int, input().split())
# 二次元配列で
a,b = [],[]
for i in range(n):
x, y = map(int, input().split())
a.append(x)
b.append(y)
dp = [[INF] * (h + 1) for _ in range(n + 1)]
dp[0][0] = 0
for i in range(n):
for j in range(h + 1):
if j <= a[i]:
dp[i + 1][j] = min(dp[i][j], b[i])
else:
dp[i + 1][j] = min(dp[i][j], dp[i + 1][j - a[i]] + b[i])
print(dp[n][h])
# 一次元配列で
# dp = [INF]*(h+1)
# dp[0] = 0
# for i in range(n):
# a,b = map(int, input().split())
# for j in range(h):
# nj = min(a+j, h)
# dp[nj] = min(dp[nj], dp[j]+b)
# print(dp[-1])
| 0 | null | 46,987,681,492,090 | 125 | 229 |
lst = []
for i in range(10):
lst.append(int(input()))
for j in range(3):
print max(lst)
lst.remove(max(lst)) | A = [int(input()) for i in range(10)]
for i in sorted(A)[:-4:-1]:
print(i)
| 1 | 26,139,558 | null | 2 | 2 |
c = input()
list = ['a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i', 'j', 'k',
'l', 'm', 'n', 'o', 'p', 'q', 'r', 's', 't', 'u', 'v', 'w', 'x', 'y', 'z']
if c in list:
print(list[list.index(c) + 1]) | import sys
input = lambda : sys.stdin.readline().rstrip()
sys.setrecursionlimit(max(1000, 10**9))
write = lambda x: sys.stdout.write(x+"\n")
c = input()
c = chr(ord(c)+1)
print(c) | 1 | 92,432,262,334,100 | null | 239 | 239 |
from collections import defaultdict
N,p = map(int,input().split())
S = input()
S = S[::-1]
d = defaultdict(lambda:0)
r = 0
for i in range(N):
r += int(S[i])*pow(10,i,p)
r %= p
d[r] += 1
ans = 0
for r in d:
ans += d[r]*(d[r]-1)//2
ans += d[0]
if p==2 or p==5:
S = S[::-1]
ans = 0
for i in range(N):
if int(S[i])%p==0:
ans += i+1
print(ans) | def main():
from string import ascii_lowercase
dic = {i: s for i, s in enumerate(ascii_lowercase)}
N = int(input())
ans = []
def dfs(s, mx):
if len(s) == N:
print(s)
return
else:
for i in range(mx+2):
v = s + dic[i]
mx = max(mx, i)
dfs(v, mx)
dfs("a", 0)
if __name__ == '__main__':
main()
| 0 | null | 54,988,586,385,660 | 205 | 198 |
n = int(input())
s = input()
a = s[:n//2]
b = s[n//2:]
if a == b:
print('Yes')
else:
print('No') | N = int(input())
S = input()
n = int(N/2)
print('Yes' if N > 1 and S[:n] == S[n:] else 'No') | 1 | 147,004,290,555,882 | null | 279 | 279 |
num = input().split()
nums = []
for i in num:
nums.append(int(i))
#print(nums)
price = [300000, 200000, 100000]
result = []
#2 3 4 5 6
for i in nums:
if int(i) > 3:
result.append(0)
else:
result.append(price[i-1])
value = result[0] + result[1]
if value == 600000:
print("1000000")
else:
print(value) | N,M=[int(i) for i in input().split()]
ans=0
for i in [N,M]:
if i==1:
ans += 3
elif i==2:
ans += 2
elif i==3:
ans+=1
if N==1 and M==1:
ans+=4
print(ans*100000) | 1 | 140,312,922,650,380 | null | 275 | 275 |
n = input()
ans = ""
for i in range(1, n + 1) :
if (i % 3 == 0 or str(i).count('3')) :
ans += (" " + str(i))
print("%s" % ans) | def func(n):
x = []
for i in range(1,n+1):
num = i
if i % 3 == 0:
x.append(i)
else:
while num:
if int(num % 10) == 3:
x.append(i)
break
num = int(num / 10)
return x
if __name__ == '__main__':
N = int(input())
rlt = func(N)
print(" ", end='')
for i in range(len(rlt)):
if rlt[i] == rlt[-1]:
print(rlt[i], end='')
else:
print(rlt[i], end=' ')
print() | 1 | 932,236,800,120 | null | 52 | 52 |
N, P = map(int, input().split())
S = input()
if 10 % P == 0:
ans = 0
for r in range(N):
if int(S[r]) % P == 0:
ans += r + 1
print(ans)
exit()
d = [0] * (N + 1)
ten = 1
for i in range(N - 1, -1, -1):
a = int(S[i]) * ten % P
d[i] = (d[i + 1] + a) % P
ten *= 10
ten %= P
cnt = [0] * P
ans = 0
for i in range(N, -1, -1):
ans += cnt[d[i]]
cnt[d[i]] += 1
print(ans) | n,p = map(int,input().split())
s = list(map(int, list(input()))) # 数値のリストにしておく
def solve():
if p in [2,5]: # 例外的な処理
ret = 0
for i in range(n): # 文字位置: i: 左から, n-1-i:右から (0 基準)
lsd = s[n-1-i] # 最下位桁
if lsd % p == 0: ret += n - i # LSD が割り切れたら LSD から右の桁数分加算
return ret
ten = 1 # S[l,r) のときの 10^r, init r=0 -> 10^0 = 1
cnt = [0]*p # 余りで仕分けして個数を集計
r = 0 # 左からの文字数 0 のときの余り
cnt[r] += 1 # 余りが同じものをカウント
for i in range(n): # 文字位置: i: 左から, n-1-i:右から (0 基準)
msd = s[n-1-i] # 最上位桁
r = (msd * ten + r) % p # r: 今回の余り
ten = ten * 10 % p # N≦2*10^5 桁 なので剰余計算忘れずに！
cnt[r] += 1 # 余りが同じものをカウント
ret = 0
for r in range(p): # 余り r の個数から組み合わせを計算
ret += cnt[r] * (cnt[r] - 1) // 2 # nCr(n=i,r=2)= n(n-1)/2
return ret
print(solve())
| 1 | 58,356,621,804,180 | null | 205 | 205 |
import numpy as np
n = int(input())
cnt = 0
for k in range(1,n+1):
d = n//k
if d == 1:
cnt += (k+n)*(n-k+1)//2
break
cnt += k*d*(d+1)//2
print(cnt) | # Contest No.: ABC173
# Problem No.: E
# Solver: JEMINI
# Date: 20200705
import sys
import heapq
def main():
modVal = 10 ** 9 + 7
# parsing
n, k = map(int, sys.stdin.readline().split())
nums = list(map(int, sys.stdin.readline().split()))
# edge case; n == k
if n == k:
ans = 1
for i in nums:
ans *= i % modVal
ans %= modVal
print(ans % modVal)
return
# edge case; all neg
if max(nums) < 0:
nums.sort()
ans = 1
# odd k
if k % 2:
for i in range(k):
ans *= nums[-i - 1] % modVal
ans %= modVal
# even k
else:
for i in range(k):
ans *= nums[i] % modVal
ans %= modVal
print(ans % modVal)
return
# convert to absolute value & count zeros
absNums = []
zeroCnt = 0
for i in nums:
if i == 0:
zeroCnt += 1
else:
absNums.append([abs(i), i])
absNums.sort() # sorted by absolute value
# edge case; non-zero cnt is less than k
if len(absNums) < k:
print(0)
return
# separate non-zero int to 4 sorted lists; all values are absolute value
posOverK = []
negOverK = []
posLessK = []
negLessK = []
for _ in range(k):
temp = absNums.pop()
if temp[1] > 0:
posOverK.append(temp[0])
else:
negOverK.append(temp[0])
while absNums:
temp = absNums.pop()
if temp[1] > 0:
posLessK.append(temp[0])
else:
negLessK.append(temp[0])
posOverK.sort()
negOverK.sort()
posLessK.sort()
negLessK.sort()
# odd negative numbers; if able, change to even
if len(negOverK) % 2:
minNeg = None
minPos = None
maxNeg = None
maxPos = None
if posOverK:
minPos = posOverK[0]
if negOverK:
minNeg = negOverK[0]
if posLessK:
maxPos = posLessK[-1]
if negLessK:
maxNeg = negLessK[-1]
# both case available; pos -> neg or neg -> pos
if (minNeg and maxPos) and (minPos and maxNeg):
# compare ratio
if maxPos * minPos > maxNeg * minNeg:
negOverK[0] = maxPos
else:
posOverK[0] = maxNeg
# one case available
elif not (minNeg and maxPos) and (minPos and maxNeg):
posOverK[0] = maxNeg
elif (minNeg and maxPos) and not (minPos and maxNeg):
negOverK[0] = maxPos
# unchangable, zero exists
elif zeroCnt > 0:
print(0)
return
# answer building
ans = 1
for i in posOverK:
ans *= i % modVal
ans = ans % modVal
for i in negOverK:
ans *= i % modVal
ans = ans % modVal
print(ans % modVal)
return
if __name__ == "__main__":
main() | 0 | null | 10,317,267,077,652 | 118 | 112 |
import Queue
import sys
class Proc:
def __init__(self, name, time):
self.time = time
self.name = name
def main():
array = map(lambda x: int(x), sys.stdin.readline().strip().split(" "))
p_num = array[0]
q_time = array[1]
p_queue = Queue.Queue()
for i in range(0, p_num):
array = sys.stdin.readline().strip().split(" ")
p_queue.put(Proc(array[0], int(array[1])))
t = 0
while not p_queue.empty():
p = p_queue.get()
if p.time > q_time:
p.time = p.time - q_time
p_queue.put(p)
t += q_time
else:
t += p.time
print p.name + " " + str(t)
if __name__ == "__main__":
main() | N = int(input())
A=list(map(int,input().split()))
sumxor=0
for i in range(N):
sumxor=sumxor^A[i]
for i in range(N):
print(sumxor^A[i],"",end='')
print() | 0 | null | 6,280,583,015,106 | 19 | 123 |
print raw_input().swapcase() | s=input()
res=""
for t in s:
if t.islower()==True:
res+=t.upper()
else:
res+=t.lower()
print(res)
| 1 | 1,486,372,020,868 | null | 61 | 61 |
from collections import defaultdict
S = input()
kTarget = 2019
mod2cnt = defaultdict(int)
mod2cnt[0] += 1
ord_z = ord('0')
res = 0
for i in range(len(S)-1, -1, -1):
d = ord(S[i]) - ord_z
res = (res+d*pow(10, len(S)-1-i, kTarget))%kTarget
mod2cnt[res] += 1
ans = 0
for cnt in mod2cnt.values():
ans += cnt*(cnt-1)
print(ans//2) | from collections import defaultdict
import math
def P(n, r):
return math.factorial(n)//math.factorial(n-r)
def C(n, r):
return P(n, r)//math.factorial(r)
S = input()[::-1]
N = len(S)
cnt = [0]*N
tmp = 0
d = defaultdict(int)
d[0] += 1
for i in range(N):
tmp += int(S[i])*pow(10,i,2019)
tmp %= 2019
d[tmp] += 1
ans = 0
for v in d.values():
if v >= 2:
ans += C(v,2)
print(ans) | 1 | 30,741,044,625,388 | null | 166 | 166 |
def main4():
N = int(input())
S = input()
R = set()
G = set()
B = set()
for i in range(len(S)):
if S[i] == "R":
R.add(i)
elif S[i] == "G":
G.add(i)
elif S[i] == "B":
B.add(i)
ans = 0
for r in R:
for g in G:
a, b = sorted([r, g])
tmp = len(B)
if ((b + a) % 2 == 0) and ((b + a) // 2) in B:
tmp -= 1
if (2*a - b) in B:
tmp -= 1
if (2*b - a) in B:
tmp -= 1
ans += tmp
print(ans)
if __name__ == "__main__":
main4() | N = int(input())
S = input()
r = S.count("R")
g = S.count("G")
b = S.count("B")
ans = r * g * b
for i in range(N):
for j in range(i + 1, N):
k = 2 * j - i
if k < N:
if sorted(S[i] + S[j] + S[k]) == ['B', 'G', 'R']:
ans -= 1
print(ans) | 1 | 36,242,263,025,728 | null | 175 | 175 |
X = list(map(int,input().split()))
for i in [0,1]:
if X.count(X[i]) == 2:
print('Yes')
exit()
print('No')
| def compare_cards(a, b):
return a[1] < b[1]
def bubble(C):
for i in range(len(C)):
for j in range(len(C) - 1, i, -1):
if compare_cards(C[j], C[j - 1]):
C[j], C[j - 1] = C[j -1], C[j]
def selection(C):
for i in range(len(C)):
mini = i
for j in range(i, len(C)):
if compare_cards(C[j], C[mini]):
mini = j
C[i], C[mini] = C[mini], C[i]
def check_stable(originC, sortedC):
for i in range(len(originC) - 1):
if not compare_cards(sortedC[i], sortedC[i + 1]):
if originC.index(sortedC[i]) > originC.index(sortedC[i + 1]):
return 'Not stable'
return 'Stable'
N = int(input())
C = input().split()
bubbleC = list(C)
selectionC = list(C)
bubble(bubbleC)
selection(selectionC)
print(*bubbleC)
print(check_stable(C, bubbleC))
print(*selectionC)
print(check_stable(C, selectionC)) | 0 | null | 34,119,488,201,800 | 216 | 16 |
N, K = map(int, input().split())
A = [0] + list(map(int, input().split()))
B = [-1 for i in range(N+1)]
B[1] = 0
n = 1
m = 0
while 1:
n = A[n]
m += 1
if m == K:
print(n)
break
if B[n] == -1:
B[n] = m
else:
a = (K - m) % (m - B[n])
for i in range(a):
n = A[n]
print(n)
break | n, k = map(int, input().split())
a = list(map(lambda x: int(x) - 1, input().split()))
ls = [-1] * n
now = 0
cnt = 0
path = []
while 1:
if ls[now] != -1:
b = ls[now]
break
ls[now] = cnt
path.append(now)
now = a[now]
cnt += 1
loop = path[b:]
if k <= b:
print(path[k] + 1)
else:
print(loop[(k - b) % len(loop)] + 1)
| 1 | 22,936,518,816,420 | null | 150 | 150 |
if __name__ == '__main__':
n = int(input())
print(n + n * n + n * n * n )
| a = int(input())
out = a + a**2 + a**3
print(out) | 1 | 10,157,548,093,316 | null | 115 | 115 |
import math
h = int(input())
num = math.log(h,2)
num = int(num)
ans = 0
for i in range(num+1):
ans += 2**i
print(ans) | (a,b) = map(int,raw_input().split())
if a<b : print "a < b"
elif a>b : print "a > b"
else : print "a == b" | 0 | null | 40,278,691,528,288 | 228 | 38 |
h,n = map(int,input().split())
ab_input = [list(map(int,input().split())) for i in range(n)]
max_d = max(a for a,b in ab_input)
dp =[0]*(h+max_d)
for i in range(1,h+max_d):#dp[i-a]でi-a<0のとき影響がでないようにmax_dを足す
dp[i]=min(dp[i-a]+b for a,b in ab_input)#モンスターの体力を i 減らすため消耗する魔力の最小値
print(dp[h]) | import sys
def main(args):
h, n = map(int,input().split())
magic = [0]*n
maxim = 0
for i in range(n):
dam, mp = map(int,input().split())
magic[i] = (dam, mp)
maxim = max(maxim, dam)
damage = [float('inf')]*(2*10**4)
damage[0] = 0
for i in range(max(2*h, 2*maxim)):
for m in magic:
dam, mp = m
damage[i] = min(damage[i-dam]+mp, damage[i])
print(min(damage[h:]))
if __name__ == '__main__':
main(sys.argv[1:]) | 1 | 81,277,068,238,058 | null | 229 | 229 |
import collections
from math import gcd
def main():
n=int(input())
c=collections.Counter()
mod=10**9+7
for _ in range(n):
a,b=map(int,input().split())
g=abs(gcd(a,b))
if g==0:
g=1
a//=g
b//=g
c[(a,b)]+=1
ans=1
s=set()
for i,j in c:
if (i,j)==(0,0):
continue
if (i,j) not in s:
s.add((i,j))
s.add((-i,-j))
s.add((-j,i))
s.add((j,-i))
ans*=(pow(2,c[(i,j)]+c[(-i,-j)],mod)+pow(2,c[(j,-i)]+c[(-j,i)],mod)-1)%mod
print((ans-1+c[(0,0)])%mod)
if __name__ == "__main__":
main()
| import math
N = int(input())
T = []
for i in range(N):
a = list(map(int, input().split()))
T.append(a)
mod = 10**9+7
A = {}
c_zero = 0
a_zero = 0
b_zero = 0
for i in range(N):
if T[i][0] == 0 and T[i][1] == 0:
c_zero += 1
elif T[i][0] == 0:
a_zero += 1
elif T[i][1] == 0:
b_zero += 1
else:
t = math.gcd(abs(T[i][0]),abs(T[i][1]))
c = 0
if T[i][0] < 0:
T[i][0] *= -1
c += 1
if T[i][1] < 0:
T[i][1] *= -1
c += 1
if (T[i][0]//t,T[i][1]//t,c%2) in A:
A[T[i][0]//t,T[i][1]//t,c%2] += 1
else:
A[T[i][0]//t,T[i][1]//t,c%2] = 1
used = {}
for i in A.keys():
used[i] = 0
ans = 1
for k,v in A.items():
if used[k] == 0:
if k[2] == 1:
p = A.get((k[1],k[0],0),0)
if p != 0:
used[(k[1],k[0],0)] = 1
else:
p = A.get((k[1],k[0],1),0)
if p != 0:
used[(k[1],k[0],1)] = 1
ans *= ( pow(2,v,mod)+pow(2,p,mod) - 1 )
ans %= mod
ans *= ( pow(2,a_zero,mod)+pow(2,b_zero,mod) - 1 )
ans += c_zero
ans -= 1
print(ans%mod) | 1 | 20,975,522,517,082 | null | 146 | 146 |
import sys
sys.setrecursionlimit(10 ** 7)
f_inf = float('inf')
mod = 998244353
def resolve():
n = int(input())
D = list(map(int, input().split()))
MAX_L = max(D) + 1
cnt = [0] * MAX_L
for d in D:
cnt[d] += 1
if cnt[0] != 1 or D[0] != 0:
print(0)
exit()
res = 1
for i in range(1, MAX_L):
if cnt[i] == 0:
print(0)
break
res *= pow(cnt[i - 1], cnt[i], mod)
res %= mod
else:
print(res)
if __name__ == '__main__':
resolve()
| n=int(input())
x=list(map(int,input().split()))
x.sort()
m=10000000000
for i in range(x[0],x[n-1]+1):
ans=0
for j in range(n):
ans+=(i-x[j])**2
m=min(m,ans)
print(m) | 0 | null | 110,141,518,648,536 | 284 | 213 |
#計算ミスあり最終スコアがtesterと異なる
import random
import time
def search(day, schedule, c, s, satisfy):
score = 0
date = [0] * 26
for d in range(day):
tmp = 0
contest = 0
nmax = -float('inf')
for i in range(26):
tmp += c[i] * (d + 1 - date[i])
for i in range(26):
tmp2 = s[d][i] - tmp + c[i] * (d + 1 - date[i])
if nmax < tmp2:
nmax = tmp2
contest = i
date[contest] = d + 1
satisfy.append(tmp - c[contest] * (d + 1 - date[contest]))
schedule.append(contest)
score += s[d][contest] - satisfy[d]
return score
# def decrease(day, schedule, c, s, satisfy):
# ret = 0
# date = [0] * 26
# for d in range(day):
# now = schedule[d] + 1
# date[now - 1] = d + 1
# tmp = 0
# for i in range(26):
# tmp += c[i] * (d+1 - date[i])
# ret += tmp
# satisfy.append(tmp)
# return ret
def change(_from, _to, schedule, c, s, satisfy):
ret = 0
date = [0] * 26
for d in range(_to):
now = schedule[d] + 1
date[now - 1] = d + 1
if d < _from:
ret += satisfy[d]
continue
tmp = 0
for i in range(26):
tmp += c[i] * (d+1 - date[i])
ret += tmp
satisfy[d] = tmp
return ret
def Main():
D = int(input())
c = list(map(int, input().split()))
s = [list(map(int, input().split())) for _ in range(D)]
dissatisfy=[]
schedule = []
ans = search(D, schedule, c, s, dissatisfy)
for i in range(D):
print(schedule[i] + 1)
if __name__ == "__main__":
Main() | import os
import sys
import numpy as np
def solve(inp):
def bitree_sum(bit, t, i):
s = 0
while i > 0:
s += bit[t, i]
i ^= i & -i
return s
def bitree_add(bit, n, t, i, x):
while i <= n:
bit[t, i] += x
i += i & -i
def bitree_lower_bound(bit, n, d, t, x):
sum_ = 0
pos = 0
for i in range(d, -1, -1):
k = pos + (1 << i)
if k <= n and sum_ + bit[t, k] < x:
sum_ += bit[t, k]
pos += 1 << i
return pos + 1
def initial_score(d, ccc, sss):
bit_n = d + 3
bit = np.zeros((26, bit_n), dtype=np.int64)
INF = 10 ** 18
for t in range(26):
bitree_add(bit, bit_n, t, bit_n - 1, INF)
ttt = np.zeros(d, dtype=np.int64)
last = np.full(26, -1, dtype=np.int64)
score = 0
for i in range(d):
best_t = 0
best_diff = -INF
costs = ccc * (i - last)
costs_sum = costs.sum()
for t in range(26):
tmp_diff = sss[i, t] - costs_sum + costs[t]
if best_diff < tmp_diff:
best_t = t
best_diff = tmp_diff
ttt[i] = best_t
last[best_t] = i
score += best_diff
bitree_add(bit, bit_n, best_t, i + 2, 1)
return bit, score, ttt
def calculate_score(d, ccc, sss, ttt):
last = np.full(26, -1, dtype=np.int64)
score = 0
for i in range(d):
t = ttt[i]
last[t] = i
score += sss[i, t] - (ccc * (i - last)).sum()
return score
def pinpoint_change(bit, bit_n, bit_d, d, ccc, sss, ttt, permissible):
cd = np.random.randint(0, d)
ct = np.random.randint(0, 26)
while ttt[cd] == ct:
ct = np.random.randint(0, 26)
diff = 0
t = ttt[cd]
k = bitree_sum(bit, t, cd + 2)
c = bitree_lower_bound(bit, bit_n, bit_d, t, k - 1) - 2
e = bitree_lower_bound(bit, bit_n, bit_d, t, k + 1) - 2
b = ccc[t]
diff -= b * (cd - c) * (e - cd)
diff -= sss[cd, t]
k = bitree_sum(bit, ct, cd + 2)
c = bitree_lower_bound(bit, bit_n, bit_d, ct, k) - 2
e = bitree_lower_bound(bit, bit_n, bit_d, ct, k + 1) - 2
b = ccc[ct]
diff += b * (cd - c) * (e - cd)
diff += sss[cd, ct]
if diff > permissible:
bitree_add(bit, bit_n, t, cd + 2, -1)
bitree_add(bit, bit_n, ct, cd + 2, 1)
ttt[cd] = ct
else:
diff = 0
return diff
def swap_change(bit, bit_n, bit_d, d, ccc, sss, ttt, permissible):
dd = np.random.randint(1, 14)
cd1 = np.random.randint(0, d - dd)
cd2 = cd1 + dd
ct1 = ttt[cd1]
ct2 = ttt[cd2]
if ct1 == ct2:
return 0
diff = 0
k = bitree_sum(bit, ct1, cd1 + 2)
c = bitree_lower_bound(bit, bit_n, bit_d, ct1, k - 1) - 2
e = bitree_lower_bound(bit, bit_n, bit_d, ct1, k + 1) - 2
diff += ccc[ct1] * (e + c - cd1 - cd2)
k = bitree_sum(bit, ct2, cd2 + 2)
c = bitree_lower_bound(bit, bit_n, bit_d, ct2, k - 1) - 2
e = bitree_lower_bound(bit, bit_n, bit_d, ct2, k + 1) - 2
diff -= ccc[ct2] * (e + c - cd1 - cd2)
diff -= sss[cd1, ct1] + sss[cd2, ct2]
diff += sss[cd1, ct2] + sss[cd2, ct1]
if diff > permissible:
bitree_add(bit, bit_n, ct1, cd1 + 2, -1)
bitree_add(bit, bit_n, ct1, cd2 + 2, 1)
bitree_add(bit, bit_n, ct2, cd1 + 2, 1)
bitree_add(bit, bit_n, ct2, cd2 + 2, -1)
ttt[cd1] = ct2
ttt[cd2] = ct1
else:
diff = 0
return diff
d = inp[0]
ccc = inp[1:27]
sss = np.zeros((d, 26), dtype=np.int64)
for r in range(d):
sss[r] = inp[27 + r * 26:27 + (r + 1) * 26]
bit, score, ttt = initial_score(d, ccc, sss)
bit_n = d + 3
bit_d = int(np.log2(bit_n))
loop = 5 * 10 ** 6
permissible_min = -2000.0
method_border = 0.8
best_score = score
best_ttt = ttt.copy()
for lp in range(loop):
permissible = (1 - lp / loop) * permissible_min
if np.random.random() < method_border:
diff = pinpoint_change(bit, bit_n, bit_d, d, ccc, sss, ttt, permissible)
else:
diff = swap_change(bit, bit_n, bit_d, d, ccc, sss, ttt, permissible)
score += diff
# print(lp, score, calculate_score(d, ccc, sss, ttt))
if score > best_score:
best_score = score
best_ttt = ttt.copy()
return best_ttt + 1
if sys.argv[-1] == 'ONLINE_JUDGE':
from numba.pycc import CC
cc = CC('my_module')
cc.export('solve', '(i8[:],)')(solve)
cc.compile()
exit()
if os.name == 'posix':
# noinspection PyUnresolvedReferences
from my_module import solve
else:
from numba import njit
solve = njit('(i8[:],)', cache=True)(solve)
print('compiled', file=sys.stderr)
inp = np.fromstring(sys.stdin.read(), dtype=np.int64, sep=' ')
ans = solve(inp)
print('\n'.join(map(str, ans)))
| 1 | 9,720,690,596,110 | null | 113 | 113 |
"""
制約の小ささから見て全探索
"""
from itertools import product, accumulate
from bisect import *
import sys
input = sys.stdin.readline
H, W, K = map(int, input().split())
S = []
T = []
for i in range(H):
S.append(list(map(int, input().strip())))
T.append(list(accumulate([0] + S[-1])))
cnt_list = []
for a in product((0,1),repeat=H):
past_a = a[0]
T2 = [[0]*(W+1)]
for i in range(H):
if a[i] == past_a:
for j, t in enumerate(T[i]):
T2[-1][j] += t
else:
T2.append(T[i].copy())
past_a = a[i]
cnt = len(T2) - 1
l = 0
flg = False
while True:
temp = []
for s in T2:
temp.append(bisect_right(s[l+1:], K + s[l]) + l)
if min(temp) == 0:
flg = True
break
else:
l = min(temp)
if l >= W:
break
else:
cnt += 1
if not flg:
cnt_list.append(cnt)
print(min(cnt_list))
| small = []
large = []
while True:
input_a, input_b = map(int, raw_input().split())
if input_a == 0 and input_b == 0:
break
else:
if input_a < input_b:
small.append(input_a)
large.append(input_b)
else:
small.append(input_b)
large.append(input_a)
for (n, m) in zip(small, large):
print n, m | 0 | null | 24,627,601,715,596 | 193 | 43 |
import sys
i = 1
while(1):
a = raw_input()
if('0'==a):
break
else:
print "Case %d: %s" % (i, a)
i += 1 | c=1
while 1:
n=input()
if n:print'Case %d: %d'%(c,n)
else:break
c+=1 | 1 | 489,122,755,440 | null | 42 | 42 |
a,b,c=[int(i) for i in input().split()]
if((a+b+c)>=22):
print('bust')
else:
print('win') | U = 2 * 10 ** 5
mod = 10 ** 9 + 7
class Combination:
"""
SIZEが10^6程度以下の二項係数を何回も呼び出したいときに使う
使い方:
comb = Combination(SIZE, MOD)
comb(10, 3) => 120
"""
def __init__(self, N, MOD=10 ** 9 + 7):
self.MOD = MOD
self.fact, self.inv = self._make_factorial_list(N)
def __call__(self, n, k):
if k < 0 or k > n:
return 0
res = self.fact[n] * self.inv[k] % self.MOD
res = res * self.inv[n - k] % self.MOD
return res
def _make_factorial_list(self, N):
fact = [1] * (N + 1)
inv = [1] * (N + 1)
MOD = self.MOD
for i in range(1, N + 1):
fact[i] = (fact[i - 1] * i) % MOD
inv[N] = pow(fact[N], MOD - 2, MOD)
for i in range(N, 0, -1):
inv[i - 1] = (inv[i] * i) % MOD
return fact, inv
if __name__ == "__main__":
N, K = map(int, input().split())
comb = Combination(U + 5, mod)
ans = 1
for i in range(1, min(K + 1, N)):
vacant = comb(N, i)
person = comb(N - 1, i)
ans = (ans + vacant * person % mod) % mod
print(ans) | 0 | null | 93,326,152,029,628 | 260 | 215 |
#!/usr/bin/env python3
import sys
read = sys.stdin.buffer.read
readline = sys.stdin.buffer.readline
readlines = sys.stdin.buffer.readlines
sys.setrecursionlimit(10 ** 7)
N, K = map(int, input().split())
A = list(map(int, input().split()))
ng = 0
ok = 10 ** 9
# able(X) を、すべての丸太を X 以下の長さに切れる場合 1 , そうでない場合 0 を返す関数とする
# 二分探索によって、able(X) が 1 に切り替わる X 点を見つける
def able(x):
count = 0
for i in range(N):
if A[i] % x:
count += A[i] // x
else:
count += A[i] // x - 1
if count <= K:
return True
else:
return False
while ok - ng > 1:
mid = ng + (ok - ng) // 2
if able(mid):
ok = mid
else:
ng = mid
print(ok)
| #!/usr/bin python3
# -*- coding: utf-8 -*-
import bisect
n,k = map(int, input().split())
a = sorted(list(map(int, input().split())))
def cnt(x):
ret = 0
for ai in a:
ret += (ai+(x-1))//x - 1
return ret
ok, ng = a[-1], 0
while ok - ng > 1:
nw = (ok + ng) // 2
if cnt(nw)<=k:
ok = nw
else:
ng = nw
print(ok)
| 1 | 6,454,722,574,260 | null | 99 | 99 |
n=int(input())
l = [int(x) for x in input().split()]
p = int(sum(l)/n + 0.5)
ans = 0
for i in range(n):
ans += (p-l[i])**2
print(ans) | N = int(input())
X = list(map(int, input().split()))
INF = 10**6 + 1
mintotal = INF
for p in range(1, 101):
total = 0
for x in X:
total += (x-p)**2
mintotal = min(mintotal, total)
print(mintotal) | 1 | 65,272,681,383,268 | null | 213 | 213 |
import sys
input = sys.stdin.readline
def main():
n,a,b = [int(i) for i in input().strip().split()]
if (b-a) % 2 == 0:
print(abs(b - a) // 2)
else:
ans = min(a - 1, n - b) + 1 + (b - a - 1) // 2
print(ans)
return
if __name__ == "__main__":
main() | a,b = list(map(int, input().split()))
c = 2 * (a+ b)
d = a * b
print(str(d) + " " + str(c)) | 0 | null | 54,657,218,826,718 | 253 | 36 |
import queue
h,w = map(int,input().split())
v = [(1, 0), (0, 1), (-1, 0), (0, -1)]
s = [input() for i in range(h)]
ans = 0
que = queue.Queue()
for i in range(h * w):
c = 0
d = [[h*w] * w for i in range(h)]
p = (i//w, i%w)
if s[p[0]][p[1]] == '#':
continue
d[p[0]][p[1]] = 0
que.put(p)
while not que.empty():
y,x = que.get()
c = d[y][x]
for dy, dx in v:
yy = y + dy
xx = x + dx
if yy < 0 or xx < 0 or h <= yy or w <= xx:
continue
if s[yy][xx] == '#':
continue
if d[yy][xx] < h*w:
continue
que.put((yy, xx))
d[yy][xx] = c + 1
ans = max(ans, c)
print(ans) | h, w = map(int,input().split())
s = [input() for i in range(h)]
def f(i, j):
t = [[-1]*w for j in range(h)]
t[i][j] = 0
q = [(i,j)]
while q:
y, x = q.pop(0)
if y - 1 >= 0 and s[y-1][x] != "#" and t[y-1][x] == -1:
t[y-1][x] = t[y][x] + 1
q.append((y-1,x))
if y + 1 < h and s[y+1][x] != "#" and t[y+1][x] == -1:
t[y+1][x] = t[y][x]+1
q.append((y+1,x))
if x - 1 >= 0 and s[y][x-1] != "#" and t[y][x-1] == -1:
t[y][x-1] = t[y][x] + 1
q.append((y,x-1))
if x + 1 < w and s[y][x+1] != "#" and t[y][x+1] == -1:
t[y][x+1] = t[y][x] + 1
q.append((y,x+1))
return max(max(tt) for tt in t)
result = 0
for i in range(h):
for j in range(w):
if s[i][j] != "#":
result = max(result,f(i,j))
print(result)
| 1 | 94,761,922,165,768 | null | 241 | 241 |
n = int(input())
S = list(map(int, input().split()))
q = int(input())
T = list(map(int, input().split()))
C = []
for s in S:
for t in T:
if s == t and not s in C: C.append(s)
print(len(C)) | r = float(input())
pi = 3.1415
print(r * 2 * pi) | 0 | null | 15,624,443,306,960 | 22 | 167 |
class dice:
def __init__(self,A):
self.side = {
"TOP":A[0],
"S":A[1],
"E":A[2],
"W":A[3],
"N":A[4],
"BOT":A[5],
}
self.reverse = {
"E":"W",
"W":"E",
"S":"N",
"N":"S"}
def main(self,A):
for s in A:
var = int(self.side[s])
self.side[s] = self.side["TOP"]
self.side["TOP"] = self.side[self.reverse[s]]
self.side[self.reverse[s]] = self.side["BOT"]
self.side["BOT"] = var
print("{}".format(self.side["TOP"]))
var = dice(list(map(int,input().split())))
var.main(input())
| class Dice(object):
def __init__(self, n):
self.n = n
def move(self, to):
if to == 'N':
self.n[0], self.n[1], self.n[4], self.n[5] = self.n[1], self.n[5], self.n[0], self.n[4]
elif to == 'E':
self.n[0], self.n[2], self.n[3], self.n[5] = self.n[3], self.n[0], self.n[5], self.n[2]
elif to == 'S':
self.n[0], self.n[1], self.n[4], self.n[5] = self.n[4], self.n[0], self.n[5], self.n[1]
elif to == 'W':
self.n[0], self.n[2], self.n[3], self.n[5] = self.n[2], self.n[5], self.n[0], self.n[3]
def top(self):
return self.n[0]
dice = Dice([int(i) for i in input().split()])
move = input()
for m in move:
dice.move(m)
print(dice.top())
| 1 | 239,358,361,088 | null | 33 | 33 |
xy = list(map(int,input().split()))
prise = 0
for i in xy:
if i == 1:
prise += 300000
elif i == 2:
prise += 200000
elif i == 3:
prise += 100000
if sum(xy) == 2:
prise += 400000
print(prise) | def main():
n, m = map(int, input().split())
qry = [list(map(int, input().split())) for _ in range(m)]
ans = -1
for v in range(0, 1000):
s = str(v)
if len(s) != n:
continue
f = True
for p, x in qry:
if s[p-1] != str(x):
f = False
break
if f:
ans = v
break
print(ans)
if __name__ == "__main__":
main() | 0 | null | 100,648,375,703,682 | 275 | 208 |
x, y, a, b, c = map(int, input().split())
list_A = list(map(int, input().split()))
list_B = list(map(int, input().split()))
list_C = list(map(int, input().split()))
list_A.sort(reverse=True)
list_B.sort(reverse=True)
list_C.sort(reverse=True)
list_N = list_A[:x] + list_B[:y] + list_C[:min(c, x + y)]
list_N.sort(reverse=True)
print(sum(list_N[:x+y])) | while(True):
n=int(input())
if(n==0):
break
val=list(map(int, input().split()))
sum=0
for i in val:
sum+=i
mean=sum/n
disp=0
for i in val:
disp+=(i-mean)**2
disp=disp/n
print(disp**0.5)
| 0 | null | 22,489,382,788,410 | 188 | 31 |
import math
import string
def readints():
return list(map(int, input().split()))
def nCr(n, r):
return math.factorial(n)//(math.factorial(n-r)*math.factorial(r))
def has_duplicates2(seq):
seen = []
for item in seq:
if not(item in seen):
seen.append(item)
return len(seq) != len(seen)
def divisor(n):
divisor = []
for i in range(1, n+1):
if n % i == 0:
divisor.append(i)
return divisor
l = [1, 1, 1, 2, 1, 2, 1, 5, 2, 2, 1, 5, 1, 2, 1, 14, 1, 5, 1, 5, 2, 2, 1, 15, 2, 2, 5, 4, 1, 4, 1, 51]
k = int(input())
print(l[k-1])
| i = 0
x = int(input())
while x != 0:
i += 1
print("Case ", i, ": ", x, sep="")
x = int(input()) | 0 | null | 25,241,233,006,458 | 195 | 42 |
n, m, x = map(int, input().split())
ca = []
for _ in range(n):
ca.append(list(map(int, input().split())))
cost_max = 12 * (10 ** 5)
book_list = []
flag = 0
for i in range(2**n):
book_num = 0
book_list = []
if i == 0:
continue
for j in range(n):
if (i >> j) & 1:
book_list.append(ca[j])
book_num += 1
for j in range(m):
skill_revel = 0
for k in range(book_num):
skill_revel += book_list[k][j+1]
if skill_revel >= x:
if j == (m-1) and k == (book_num-1):
cost = 0
for l in range(book_num):
cost += book_list[l][0]
if cost <= cost_max:
flag = 1
cost_max = cost
continue
else:
break
if flag == 0:
print(-1)
else:
print(cost_max) | n, m = map(int, input().split())
a = list(map(int, input().split()))
print('Yes' if len([ai for ai in a[:] if ai >= sum(a) / (4*m)]) >= m else 'No') | 0 | null | 30,722,571,843,936 | 149 | 179 |
n = int(input())
count=0
for i in range(1,n//2+1):
j = n - i
if i != j:
count += 1
print(count) | N = int(input())
print(N // 2 - 1 if N % 2 == 0 else (N-1) // 2) | 1 | 153,661,496,228,480 | null | 283 | 283 |
n = int(input())
*x, = map(int, input().split())
ans = float('inf')
for i in range(min(x), max(x)+1):
tmp = 0
for j in x:
tmp += (j - i)*(j - i)
ans = min(ans, tmp)
print(ans) | N = int(input())
L = []
for i in range(N):
s, t = input().split()
L.append((s, int(t)))
X = input()
ans = 0
f = False
for s, t in L:
if f:
ans += t
if s == X:
f = True
print(ans)
| 0 | null | 80,816,582,094,740 | 213 | 243 |
x,y=map(int,input().split())
k=[1,2,3]
l=[0,300000,200000,100000]
p=0
if x in k:
p+=l[x]
if y in k:
p+=l[y]
if x==1 and y==1:
p+=400000
print(p)
| N = int(input())
A = list(map(int, input().split(' ')))
uniqu_a = list(set(A))
if N == len(uniqu_a):
print('YES')
else:
print('NO') | 0 | null | 107,814,869,545,878 | 275 | 222 |
a1 = list(map(int, input().split()))
a2 = list(map(int, input().split()))
a3 = list(map(int, input().split()))
n = int(input())
flag = 0
for _ in range(n):
b = int(input())
for i in range(3):
if b == a1[i]:
a1[i] = 0
elif b == a2[i]:
a2[i] = 0
elif b == a3[i]:
a3[i] = 0
for i in range(3):
if a1[i] == a2[i] == a3[i]:
flag = 1
if sum(a1) == 0:
flag = 1
if sum(a2) == 0:
flag = 1
if sum(a3) == 0:
flag = 1
if a1[0] == a2[1] == a3[2]:
flag = 1
if a1[2] == a2[1] == a3[0]:
flag = 1
if flag == 1:
print("Yes")
break
if flag == 0:
print("No") | import sys
import decimal # 10進法に変換，正確な計算
def input():
return sys.stdin.readline().strip()
def main():
a, b = map(int, input().split())
c = a - b*2
if c < 0:
print(0)
return
print(c)
main()
| 0 | null | 112,664,085,914,460 | 207 | 291 |
X,N = map(int, input().split())
if N == 0:
print(X)
exit()
P = list(map(int, input().split()))
P.sort(reverse=True)
for i in range(105):
if X - i not in P:
print(X - i)
break
if X + i not in P:
print(X + i)
break | x, n = list(map(int, input().split()))
if n == 0:
inputs = []
else:
inputs = list(map(int, input().split()))
nums = [0] * 201
diff = 1000
n = 100
for i in inputs:
nums[i] = 1
for i in range(0, 201):
d = abs(i - x)
if nums[i] == 1:
continue
if d < diff:
diff = d
n = i
print(n)
| 1 | 14,171,271,939,388 | null | 128 | 128 |
class BalancingTree:
"""平衡二分木のクラス
Pivotを使った実装.
0以上2^n - 2以下の整数を扱う
"""
def __init__(self, n):
"""
2の指数nで初期化
"""
self.N = n
self.root = self.node(1<<n, 1<<n)
def debug(self):
"""デバッグ用の関数"""
def debug_info(nd_):
return (nd_.value - 1, nd_.pivot - 1, nd_.left.value - 1 if nd_.left else -1, nd_.right.value - 1 if nd_.right else -1)
def debug_node(nd):
re = []
if nd.left:
re += debug_node(nd.left)
if nd.value: re.append(debug_info(nd))
if nd.right:
re += debug_node(nd.right)
return re
print("Debug - root =", self.root.value - 1, debug_node(self.root)[:50])
def append(self, v):
"""
v を追加（その時点で v はない前提）
"""
v += 1
nd = self.root
while True:
if v == nd.value:
# v がすでに存在する場合に何か処理が必要ならここに書く
return 0
else:
mi, ma = min(v, nd.value), max(v, nd.value)
if mi < nd.pivot:
nd.value = ma
if nd.left:
nd = nd.left
v = mi
else:
p = nd.pivot
nd.left = self.node(mi, p - (p&-p)//2)
break
else:
nd.value = mi
if nd.right:
nd = nd.right
v = ma
else:
p = nd.pivot
nd.right = self.node(ma, p + (p&-p)//2)
break
def leftmost(self, nd):
if nd.left: return self.leftmost(nd.left)
return nd
def rightmost(self, nd):
if nd.right: return self.rightmost(nd.right)
return nd
def find_l(self, v):
"""
vより真に小さいやつの中での最大値（なければ-1）
"""
v += 1
nd = self.root
prev = 0
if nd.value < v: prev = nd.value
while True:
if v <= nd.value:
if nd.left:
nd = nd.left
else:
return prev - 1
else:
prev = nd.value
if nd.right:
nd = nd.right
else:
return prev - 1
def find_r(self, v):
"""
vより真に大きいやつの中での最小値（なければRoot）
"""
v += 1
nd = self.root
prev = 0
if nd.value > v: prev = nd.value
while True:
if v < nd.value:
prev = nd.value
if nd.left:
nd = nd.left
else:
return prev - 1
else:
if nd.right:
nd = nd.right
else:
return prev - 1
@property
def max(self):
"""最大値の属性"""
return self.find_l((1<<self.N)-1)
@property
def min(self):
"""最小値の属性"""
return self.find_r(-1)
def delete(self, v, nd = None, prev = None):
"""
値がvのノードがあれば削除（なければ何もしない）
"""
v += 1
if not nd: nd = self.root
if not prev: prev = nd
while v != nd.value:
prev = nd
if v <= nd.value:
if nd.left:
nd = nd.left
else:
return
else:
if nd.right:
nd = nd.right
else:
return
if (not nd.left) and (not nd.right):
if nd.value < prev.value:
prev.left = None
else:
prev.right = None
elif not nd.left:
if nd.value < prev.value:
prev.left = nd.right
else:
prev.right = nd.right
elif not nd.right:
if nd.value < prev.value:
prev.left = nd.left
else:
prev.right = nd.left
else:
nd.value = self.leftmost(nd.right).value
self.delete(nd.value - 1, nd.right, nd)
def __contains__(self, v: int) -> bool:
return self.find_r(v - 1) == v
class node:
"""ノードをあらわすクラス
v: 値
p: ピボット値
で初期化
"""
def __init__(self, v, p):
self.value = v
self.pivot = p
self.left = None
self.right = None
Trees = [BalancingTree(50) for _ in range(26)]
N = int(input())
S = input()
Q = int(input())
alphabets = list("abcdefghijklmnopqrstuvwxyz")
c2n = {c: i for i, c in enumerate(alphabets)}
for i in range(N):
Trees[c2n[S[i]]].append(i+1)
S = list(S)
for _ in range(Q):
tmp = list(input().split())
if tmp[0] == "1":
_, i, c = tmp
i = int(i)
bef = S[i-1]
if bef == c:
continue
Trees[c2n[bef]].delete(i)
Trees[c2n[c]].append(i)
S[i-1] = c
else:
_, l, r = tmp
l = int(l)
r = int(r)
ans = 0
for char in range(26):
res = Trees[char].find_r(l-1)
if l <= res <= r:
ans += 1
print(ans) | # encoding: utf-8
import sys
import math
_input = sys.stdin.readlines()
depth = int(_input[0])
sin_60, cos_60 = math.sin(math.pi / 3), math.cos(math.pi / 3)
class Point(object):
def __init__(self, x=0.0, y=0.0):
"""
initialize the point
"""
self.x = float(x)
self.y = float(y)
def koch_curve(d, p1, p2):
if not d:
# print('end')
return None
# s, t, u = Point(), Point, Point()
s = Point()
t = Point()
u = Point()
s.x = (2 * p1.x + p2.x) / 3
s.y = (2 * p1.y + p2.y) / 3
t.x = (p1.x + 2 * p2.x) / 3
t.y = (p1.y + 2 * p2.y) / 3
u.x = (t.x - s.x) * cos_60 - (t.y - s.y) * sin_60 + s.x
u.y = (t.x - s.x) * sin_60 + (t.y - s.y) * cos_60 + s.y
koch_curve(d - 1, p1, s)
print(format(s.x, '.8f'), format(s.y, '.8f'))
koch_curve(d - 1, s, u)
print(format(u.x, '.8f'), format(u.y, '.8f'))
koch_curve(d - 1, u, t)
print(format(t.x, '.8f'), format(t.y, '.8f'))
koch_curve(d - 1, t, p2)
if __name__ == '__main__':
p1_start, p2_end = Point(x=0, y=0), Point(x=100, y=0)
print(format(p1_start.x, '.8f'), '', format(p1_start.y, '.8f'))
koch_curve(depth, p1_start, p2_end)
print(format(p2_end.x, '.8f'), '', format(p2_end.y, '.8f')) | 0 | null | 31,484,312,397,654 | 210 | 27 |
# C gacha
N = int(input())
goods = set()
cnt = 0
for i in range(N):
S = input()
if S not in goods:
goods.add(S)
cnt += 1
print(cnt) | D=int(input())
c=list(map(int,input().split()))
s=[list(map(int,input().split())) for i in range(D)]
test=[int(input()) for i in range(D)]
lastday=[0 for j in range(26)]
points=[0 for i in range(D)]
lastday=[lastday[i]+1 for i in range(26)]
lastday[test[0]-1]=0
minus=sum([x*y for (x,y) in zip(c,lastday)])
points[0]=s[0][test[0]-1]-minus
for i in range(1,D):
lastday=[lastday[i]+1 for i in range(26)]
lastday[test[i]-1]=0
minus=sum([x*y for (x,y) in zip(c,lastday)])
points[i]=points[i-1]+s[i][test[i]-1]-minus
for ps in points:
print(ps) | 0 | null | 20,033,808,926,560 | 165 | 114 |
X,Y=map(int, input().split())
v1 = [300000, 200000, 100000]
v2 = [300000, 200000, 100000]
x = 0
y = 0
if X <= 3:
x = int(v1[X-1])
if Y <= 3:
y = int(v2[Y-1])
if ((X==1) & (Y==1)):
print(int(x + y + 400000))
else:
print(int(x + y)) | def main():
x, y = map(int, input().split())
money = 0
if x == 3:
money += 100000
elif x == 2:
money += 200000
elif x == 1:
money += 300000
if y == 3:
money += 100000
elif y == 2:
money += 200000
elif y == 1:
money += 300000
if x == 1 and y == 1:
money += 400000
print(money)
if __name__ == "__main__":
main()
| 1 | 140,414,726,891,030 | null | 275 | 275 |
N = int(input())
primes = {}
for num in range(2, int(N**0.5)+1):
while N%num == 0:
if num in primes:
primes[num] += 1
else:
primes[num] = 1
N //= num
ans = 0
for p in primes.values():
n = 1
while n*(n+1)//2 <= p:
n += 1
ans += n-1
if N > 1:
ans += 1
print(ans) | import math
N = int(input())
A_max = int(math.sqrt(N) + 1)
A = list(range(2, A_max))
prime_check = [0] * (A_max + 1)
multi_list = []
def multi_x(X, n):
i = 1
result = 0
while X % (n**i) == 0:
result = i
i += 1
return result
for a in A:
if prime_check[a] == 0:
i = 2
x = multi_x(N, a)
if x != 0:
multi_list.append(x)
N = N // a**x
while a * i <= A_max:
prime_check[a * i] = 1
i += 1
if N > A_max:
ans = 1
else:
ans = 0
for m in multi_list:
i = 1
buf = m
while buf >= i:
buf -= i
i += 1
ans += 1
print(ans)
| 1 | 16,878,405,489,708 | null | 136 | 136 |
n = int(input())
h = [[[0 for i in range(10)] for j in range(3)] for k in range(4)]
for _ in range(n):
b, f, r, v = [int(e) for e in input().split()]
h[b-1][f-1][r-1] += v
for i, b in enumerate(h):
if i != 0:
print('#'*20)
for f in b:
print(' ', end='')
print(*f) | n = int(input())
data = [list(map(int, input().split())) for _ in range(n)]
nums = [[[0 for i in range(10)] for i in range(3)] for i in range(4)]
for d in data:
nums[d[0] - 1][d[1] - 1][d[2] - 1] += d[3]
for i in range(4):
for j in range(3):
for k in range(10):
print(' ' + str(nums[i][j][k]), end='')
print('')
if i != 3:
print('#' * 20) | 1 | 1,088,322,919,840 | null | 55 | 55 |
NM=list(map(int,input().strip().split()))
N=NM[0]
M=NM[1]
if N==M:
print("Yes")
else:
print("No")
| n,m = map(int, raw_input().split(' '))
print 'Yes' if m == n else 'No' | 1 | 83,343,691,272,648 | null | 231 | 231 |
from collections import *
import copy
N,K=map(int,input().split())
A=list(map(int,input().split()))
lst=[0]
for i in range(0,N):
lst.append((A[i]%K+lst[i])%K)
for i in range(len(lst)):
lst[i]-=i
lst[i]%=K
dic={}
count=0
for i in range(0,len(lst)):
if lst[i] in dic:
count+=dic[lst[i]]
dic[lst[i]]+=1
else:
dic.update({lst[i]:1})
a=i-K+1
if a>=0:
dic[lst[a]]-=1
print(count)
| A, B = map(int, input().split())
if A == B:
print('Yes')
else:
print('No') | 0 | null | 110,066,340,547,810 | 273 | 231 |
import sys
input = lambda : sys.stdin.readline().rstrip()
sys.setrecursionlimit(max(1000, 10**9))
write = lambda x: sys.stdout.write(x+"\n")
n = int(input())
d = list(map(int, input().split()))
ans = (sum(d)**2 - sum(item**2 for item in d))//2
print(ans) | n=int(input())
l=list(map(int,input().split()))
prod=0
for i in range(n):
for j in range(i+1,n):
prod=prod+(l[i]*l[j])
print(prod)
| 1 | 168,510,465,624,170 | null | 292 | 292 |
# kurimu_usamaro様のメソッドを拝借しています。
class Combi():
def __init__(self, N, mod):
self.power = [1 for _ in range(N+1)]
self.rev = [1 for _ in range(N+1)]
self.mod = mod
for i in range(2, N+1):
self.power[i] = (self.power[i-1]*i) % self.mod
self.rev[N] = pow(self.power[N], self.mod-2, self.mod)
for j in range(N, 0, -1):
self.rev[j-1] = (self.rev[j]*j) % self.mod
def com(self, K, R):
if K < R:
return 0
else:
return ((self.power[K])*(self.rev[K-R])*(self.rev[R])) % self.mod
def pom(self, K, R):
if K < R:
return 0
else:
return (self.power[K])*(self.rev[K-R]) % self.mod
def main():
mod = 10**9+7
N,K = map(int,input().split())
A = list(map(int,input().split()))
A.sort()
c = Combi(N,mod)
ans = 0
if K == 1:
print(0)
else:
for i, a in enumerate(A):
ans += c.com(i, K-1)*a
ans -= c.com(N-1-i, K-1)*a
ans %= mod
print(ans%mod)
if __name__ == "__main__":
main() | import sys
input_methods=['clipboard','file','key']
using_method=0
input_method=input_methods[using_method]
tin=lambda : map(int, input().split())
lin=lambda : list(tin())
mod=1000000007
#+++++
def modinv(a,m):
b=m
u=1
v=0
while b > 0:
t = a //b
a = a - (t * b)
a,b = b,a
u = u - (t * v)
u,v=v,u
u = u % m
if u < 0:
u+=m
return u
size_l=(10**5)+5
kaijoy=[1]*(size_l)
inv = [0]*(size_l)
pre=1
for i,v in enumerate(kaijoy[1:], 1):
pre *= i
pre %= mod
kaijoy[i]=pre
inv[-1] = modinv(kaijoy[-1], mod)
pre = inv[-1]
#print(pre*24)
for i, v in enumerate(inv[1:],1):
pre *= (size_l-i)
pre %= mod
inv[-i-1]=pre
#print(kaijoy)
#print(inv)
#print([(v*s)%mod for v, s in zip(kaijoy, inv)])
def conv(n, k):
if n < k:
return 0
global kaijoy
global inv
ret = kaijoy[n]
ret *= inv[n-k]
ret *= inv[k]
return ret
def main():
# = int(input())
n, k = tin()
#s = input()
al = lin()
al.sort()
ret = 0
for i in range(n-k+1):
d= (al[-i-1] - al[i])*conv(n-i-1, k-1)
#pa((d,kaijoy[max(0,n-i-1)],inv[k-1]))
ret += d
ret %= mod
return ret
#+++++
isTest=False
def pa(v):
if isTest:
print(v)
def input_clipboard():
import clipboard
input_text=clipboard.get()
input_l=input_text.splitlines()
for l in input_l:
yield l
if __name__ == "__main__":
if sys.platform =='ios':
if input_method==input_methods[0]:
ic=input_clipboard()
input = lambda : ic.__next__()
elif input_method==input_methods[1]:
sys.stdin=open('inputFile.txt')
else:
pass
isTest=True
else:
pass
#input = sys.stdin.readline
ret = main()
if ret is not None:
print(ret) | 1 | 95,601,310,612,072 | null | 242 | 242 |
digits = [int(i) for i in list(input())]
Sum = 0
for i in digits:
Sum += i
if Sum%9 == 0:
print("Yes")
else:
print("No") | from sys import stdin
n = int(stdin.readline().strip())
a_lst = [int(x) for x in stdin.readline().strip().split()]
pos = len(a_lst) // 2
min_diff = 10000000000000000000
while(True):
left = sum(a_lst[:pos])
right = sum(a_lst[pos:])
diff = right - left
if min_diff > abs(diff): min_diff = abs(diff)
else: break
if diff > 0: pos += 1
elif diff < 0: pos -= 1
print(min_diff) | 0 | null | 73,032,349,111,900 | 87 | 276 |
N = int(input())
# Nを 1以上 9以下の 2つの整数の積として表すことができるなら Yes を、できないなら No を出力せよ。
for i in range(1, 9+1):
for j in range(1, 9+1):
if i * j == N:
print("Yes")
exit()
else:
print("No") | def resolve():
import math
from math import gcd
MOD=10**9+7
n=int(input())
zero=0
cnt={}
for i in range(n):
a,b=map(int,input().split())
if a==0 and b==0:
zero+=1
continue
g=gcd(a,b)
a//=g
b//=g
if b<0:
a*=-1
b*=-1
if b==0 and a<0:
a*=-1
if a<=0:
a,b=b,-a
if (a,b) in cnt:
cnt[(a,b)][0]+=1
else:
cnt[(a,b)]=[1,0]
else:
if (a,b) in cnt:
cnt[(a,b)][1]+=1
else:
cnt[(a,b)]=[0,1]
ans=1
for i,v in cnt.items():
ans*=pow(2,v[0],MOD)+pow(2,v[1],MOD)-1
ans%=MOD
print((zero-1+ans)%MOD)
if __name__ == '__main__':
resolve() | 0 | null | 90,387,480,595,048 | 287 | 146 |
X = int(input())
k = 0
res = 100
for i in range (1, 4200):
res += res // 100
if res >= X:
k = i
break
print(k) | #!/usr/bin/env python3
from collections import defaultdict, Counter
from itertools import product, groupby, count, permutations, combinations
from math import pi, sqrt
from collections import deque
from bisect import bisect, bisect_left, bisect_right
from string import ascii_lowercase
from functools import lru_cache
import sys
sys.setrecursionlimit(10000)
INF = float("inf")
YES, Yes, yes, NO, No, no = "YES", "Yes", "yes", "NO", "No", "no"
dy4, dx4 = [0, 1, 0, -1], [1, 0, -1, 0]
dy8, dx8 = [0, -1, 0, 1, 1, -1, -1, 1], [1, 0, -1, 0, 1, 1, -1, -1]
def inside(y, x, H, W):
return 0 <= y < H and 0 <= x < W
def ceil(a, b):
return (a + b - 1) // b
def sum_of_arithmetic_progression(s, d, n):
return n * (2 * s + (n - 1) * d) // 2
def gcd(a, b):
if b == 0:
return a
return gcd(b, a % b)
def lcm(a, b):
g = gcd(a, b)
return a / g * b
def solve():
H, W, K = map(int, input().split())
f = []
for i in range(H):
f.append(input())
ans = 0
for b1 in range(2**H):
for b2 in range(2**W):
c = 0
for i in range(H):
for j in range(W):
if (b1 >> i) & 1 or (b2 >> j) & 1:
continue
else:
c += f[i][j] == '#'
if c == K:
ans += 1
print(ans)
def main():
solve()
if __name__ == '__main__':
main()
| 0 | null | 17,850,103,462,788 | 159 | 110 |
import math
X=list()
Y=list()
s=0
N=int(input())
for i in range(N):
x,y=map(int,input().split())
X.append(x)
Y.append(y)
for i in range(N):
for j in range(N):
s+=math.sqrt(((X[i]-X[j])**2)+((Y[i]-Y[j])**2))
print(s*(1/N)) | cnt = 0
def merge(array, left, middle, right):
n1 = middle - left
n2 = right - middle
L = array[left:left + n1] + [float("inf")]
R = array[middle:middle + n2] + [float("inf")]
i = 0
j = 0
for k in range(left, right):
global cnt
cnt += 1
if L[i] <= R[j]:
array[k] = L[i]
i += 1
else:
array[k] = R[j]
j += 1
def mergeSort(array, left, right):
if left + 1 < right:
middle = int((left + right) / 2.)
mergeSort(array, left, middle)
mergeSort(array, middle, right)
merge(array, left, middle, right)
n = int(input())
array = [int(x) for x in input().split()]
mergeSort(array, 0, len(array))
print(*array)
print(cnt)
| 0 | null | 74,096,564,138,092 | 280 | 26 |
import sys
import re
from math import ceil, floor, sqrt, pi, factorial, gcd
from copy import deepcopy
from collections import Counter, deque
from heapq import heapify, heappop, heappush
from itertools import accumulate, product, combinations, combinations_with_replacement
from bisect import bisect, bisect_left, bisect_right
from functools import reduce
from decimal import Decimal, getcontext
# input = sys.stdin.readline
def i_input(): return int(input())
def i_map(): return map(int, input().split())
def i_list(): return list(i_map())
def i_row(N): return [i_input() for _ in range(N)]
def i_row_list(N): return [i_list() for _ in range(N)]
def s_input(): return input()
def s_map(): return input().split()
def s_list(): return list(s_map())
def s_row(N): return [s_input for _ in range(N)]
def s_row_str(N): return [s_list() for _ in range(N)]
def s_row_list(N): return [list(s_input()) for _ in range(N)]
def lcm(a, b): return a * b // gcd(a, b)
sys.setrecursionlimit(10 ** 6)
INF = float('inf')
MOD = 10 ** 9 + 7
num_list = []
str_list = []
def main():
X,K,D = i_map()
if X<=0:
X = -X
tmp1 = X//D
tmp2 = X-(tmp1 * D)
if(tmp1 < K):
if((K-tmp1)%2 == 0):
print(tmp2)
else:
print(D-tmp2)
else:
print(X - K * D)
return
if __name__ == '__main__':
main()
| import math
X, K, D = map(int,input().split())
X = math.fabs(X)
ans = 0
E = X//D
if E > K:
ans = X - K * D
elif K%2 == E%2:
ans = X-E*D
else:
ans = -X+(E+1)*D
print(int(ans)) | 1 | 5,173,227,447,332 | null | 92 | 92 |
X = int(input())
for a in range(-1000, 1000):
for b in range(-1000, 1000):
if a ** 5 - b ** 5 == X:
print(a, b)
break
else:
continue
break
| def divisor(n):
result = []
i = 1
while True:
if i * i > n:
break
if n % i == 0:
result.append(i)
if i != int(n / i):
result.append(int(n / i))
i += 1
return result
def calc(a, b):
return a * a * a * a * a - b * b * b * b * b
MX = 100000
INF = int(MX**6)
def main():
X = int(input())
drs = divisor(X)
for dr in drs:
right = MX - dr
left = -MX
while right - left > 8:
bp = int(left + (right - left) / 3)
bq = int(left + 2 * (right - left) / 3)
cp = calc(bp + dr, bp)
cq = calc(bq + dr, bq)
if cp > cq:
left = bp
else:
right = bq
mn = INF
mnb = -2 * MX
for bi in range(left - 64, right + 64):
c = calc(bi + dr, bi)
if mn > c:
mnb = bi
mn = c
left = mnb
right = MX - dr
while left <= right:
b = int((left + right) / 2)
c = calc(b + dr, b)
if c == X:
print(b + dr, b)
return
elif c < X:
left = b + 1
else:
right = b - 1
left = -MX
right = mnb
while left <= right:
b = int((left + right) / 2)
c = calc(b + dr, b)
if c == X:
print(b + dr, b)
return
elif c < X:
left = b + 1
else:
right = b - 1
main()
| 1 | 25,453,835,243,760 | null | 156 | 156 |
n = int(input())
a = list(map(int, input().split()))
que = [-1, -1, -1]
ans = 1
for i in range(n):
if que[0]+1 == a[i]:
if que[0] == que[1] and que[0] == que[2]:
ans *= 3
ans %= (10**9 + 7)
elif que[0] == que[1]:
ans *= 2
ans %= (10**9 + 7)
que[0] = a[i]
elif que[1]+1 == a[i]:
if que[1] == que[2]:
ans *= 2
ans %= (10**9 + 7)
que[1] = a[i]
elif que[2]+1 == a[i]:
que[2] = a[i]
else:
ans = 0
break
print(ans)
| mod = 10**9+7
n = int(input())
res = 1
l = [0]*(n+1)
l[0] = 3
for a in list(map(int, input().split())):
if l[a]<l[a+1]:
print(0)
exit()
res = (res*(l[a] - l[a+1]))%mod
l[a+1] += 1
print(res) | 1 | 129,929,847,873,600 | null | 268 | 268 |
T1,T2 = map(int,input().split())
A1,A2 = map(int,input().split())
B1,B2 = map(int,input().split())
dis1 = (A1 - B1) * T1
dis2 = (A2 - B2) * T2
if dis1 > 0:
dis1 = -dis1
dis2 = -dis2
"""
if dis1 + dis2 <0:
print(0)
elif dis1 == -dis2:
print("infinity")
"""
if dis1 + dis2 == 0:
print("infinity")
elif dis1+dis2 < 0:
print(0)
else:
S = dis1//(dis1+dis2)
R = dis1%(dis1+dis2)
if R == 0:
ans = S*2
else:
ans = S*2 + 1
print(abs(ans)) | T = [int(t) for t in input().split()]
A = [int(t) for t in input().split()]
B = [int(t) for t in input().split()]
d1 = T[0]*(A[0]-B[0])
d2 = d1 + T[1]*(A[1]-B[1])
if d2 == 0:
ans = "infinity"
elif d1 > 0 and d2 > 0:
ans = 0
elif d1 < 0 and d2 < 0:
ans = 0
else:
d1 = abs(d1)
d2 = abs(d2)
ans = d1 // d2 * 2
if d1%d2 != 0:
ans += 1
print(ans) | 1 | 131,565,565,245,408 | null | 269 | 269 |
n,r=map(int,input().split())
inn=0
if n<10:
inn=100*(10-n)
print(r+inn)
else:
print(r) | n,r = [int(x) for x in input().split()]
if n > 10:
print(r)
else:
print(r + 100 * (10 - n)) | 1 | 63,334,030,892,650 | null | 211 | 211 |
N = int(input())
S = [input() for n in range(N)]
assert len(S) == N
counts = {'AC': 0, 'WA': 0, 'TLE': 0, 'RE': 0}
for s in S:
counts[s] += 1
for key in ['AC', 'WA', 'TLE', 'RE']:
print('{} x {}'.format(key, counts[key])) | n, x, y = map(int, input().split())
x -= 1
y -= 1
dist = [0]*(n-1)
for start in range(n):
for end in range(start+1, n):
dst = min(end-start, abs(x-start) + abs(end-y) + 1)
dist[dst-1] += 1
for d in dist:
print(d) | 0 | null | 26,448,427,688,890 | 109 | 187 |
import math
from collections import deque
N, D, A = list(map(int, input().split()))
data = []
for _ in range(N):
x, h = list(map(int, input().split()))
data.append((x, math.ceil(h/A)))
data = sorted(data, key=lambda x: x[0])
c = 0
damage_que = deque()
attack = 0 # 有効なダメージ合計
for i in range(N):
x, h = data[i]
# 爆破範囲が届いていなければ削除していく
while damage_que and x > damage_que[0][0]:
_, a = damage_que.popleft()
attack -= a
# 有効な過去の爆破攻撃を受ける
remain = max(h - attack, 0)
# 0になるまで爆破
attack += remain
c += remain
# 爆破回数追加
damage_que.append([x+2*D, remain])
print(c) | import queue
H, W = map(int, input().split())
s = [list(input()) for _ in range(H)]
ini = 0
if s[0][0] == '#':
ini = 1
dist = [[ini for _ in range(W)] for _ in range(H)]
start = (0,0)
qq = queue.Queue()
for i in range(H):
for j in range(W):
tgt = []
if j == 0:
pass
else:
if s[i][j-1] == '.' and s[i][j] == '#':
tgt.append(dist[i][j-1] + 1)
else:
tgt.append(dist[i][j-1])
if i == 0:
pass
else:
if s[i-1][j] == '.' and s[i][j] == "#":
tgt.append(dist[i-1][j] + 1)
else:
tgt.append(dist[i-1][j])
if i + j == 0:
continue
dist[i][j] = min(tgt)
print(dist[H-1][W-1])
| 0 | null | 65,784,326,579,910 | 230 | 194 |
n = int(input())
lx = list(map(int,input().split()))
lc=[]
for i in range(1,101):
c = 0
for x in lx:
c += (i-x)**2
lc.append(c)
print(min(lc))
| N = int(input())
X = list(map(int, input().split()))
HP = []
for p in range(1, 101, 1):
P = [p] * len(X)
delta = sum([(i - j) ** 2 for (i, j) in zip(X, P)])
HP.append(delta)
print(min(HP))
| 1 | 65,217,675,789,112 | null | 213 | 213 |
# 解説AC
mod = 10 ** 9 + 7
n, k = map(int, input().split())
dp = [-1] * (k + 1)
ans = 0
for i in range(k, 0, -1):
dp[i] = pow(k // i, n, mod)
t = 0
t += 2 * i
while t <= k:
dp[i] -= dp[t]
dp[i] %= mod
t += i
ans += i * dp[i]
ans %= mod
print(ans)
| import sys
input = sys.stdin.readline
N,K=map(int,input().split())
mod=10**9+7
L=[i for i in range(K+1)]
for i in range(1,K):
for j in range(i*2,K+1,i):
L[j]-=L[i]
ANS=0
for i in range(1,K+1):
ANS=(ANS+pow(K//i,N,mod)*L[i])%mod
print(ANS) | 1 | 36,996,382,314,278 | null | 176 | 176 |
a, b = (int(x) for x in input().split())
ans=0
if a==b:
for i in range(a):
ans+=a*pow(10,i)
elif a>b:
for i in range(a):
ans+=b*pow(10,i)
else:
for i in range(b):
ans+=a*pow(10,i)
print(ans) | A, B = map(str, input().split())
A_ans=''
B_ans=''
if min(A,B) == A:
for a in range(int(B)):
A_ans += A
print(A_ans)
else:
for b in range(int(A)):
B_ans += B
print(B_ans)
| 1 | 84,507,146,268,480 | null | 232 | 232 |
def solve(m, f, r):
if (m == -1 or f == -1) or m + f < 30:
return "F"
for a, b in ((80, "A"), (65, "B"), (50, "C")):
if m + f >= a:
return b
if r >= 50:
return "C"
return "D"
while True:
m, f, r = map(int, input().split())
if m == f == r == -1:
break
print(solve(m, f, r))
| N = int(input())
arr = [0]*(N+1)
ans =0
for i in range(1,N+1):
for j in range(i,N+1,i):
arr[j] += 1
ans += i*arr[i]
print(ans) | 0 | null | 6,099,907,512,360 | 57 | 118 |
#from statistics import median
#import collections
#aa = collections.Counter(a) # list to list || .most_common(2)で最大の2個とりだせるお a[0][0]
#from fractions import gcd
#from itertools import combinations # (string,3) 3回
#from collections import deque
#from collections import defaultdict
#import bisect
#
# d = m - k[i] - k[j]
# if kk[bisect.bisect_right(kk,d) - 1] == d:
#
#
#
# pythonで無理なときは、pypyでやると正解するかも！！
#
#
import sys
sys.setrecursionlimit(10000000)
mod = 10**9 + 7
#mod = 9982443453
def readInts():
return list(map(int,input().split()))
def I():
return int(input())
H,W,K = readInts()
cake = [input() for _ in range(H)]
ans = []
no = 0
cnt = 0
for h in range(H):
if cake[h] == "."*W:
no += 1
continue
else:
cnt += 1
same = []
arrived = False
for w in range(W):
if cake[h][w] == "#":
if not arrived:
arrived = True
else:
cnt += 1
same.append(cnt)
for _ in range(no+1):
ans.append(same)
no = 0
for _ in range(no):
ans.append(ans[-1])
for a in ans:
print(*a,sep=" ")
| n = int(input())
a = sorted(list(map(int, input().split())))
ans = 1
for i in a:
ans *= i
if ans > 10**18:
print("-1")
break
else:
print(ans) | 0 | null | 79,686,577,752,646 | 277 | 134 |
import sys
read = sys.stdin.read
readline = sys.stdin.readline
readlines = sys.stdin.readlines
sys.setrecursionlimit(10 ** 9)
INF = 1 << 60
MOD = 1000000007
def main():
C = readline().strip()
print(chr(ord(C) + 1))
return
if __name__ == '__main__':
main()
| C = input()
word = 'abcdefghijklmnopqrstuvwxyz'
i = word.find(C)
print(word[i+1]) | 1 | 91,753,892,426,080 | null | 239 | 239 |
N=int(input())
A=list(map(int,input().split()))
count=[0 for i in range(N)]
for i in A:
count[i-1]+=1
def chose(n):
return int(n*(n-1)/2)
total=0
for i in count:
total+=chose(i)
for i in range(N):
ans=total
ans-=chose(count[A[i]-1])
count[A[i]-1]-=1
ans+=chose(count[A[i]-1])
count[A[i]-1]+=1
print(ans) | N = int(input())
A = input().split()
num_list = [0] * N
def combination(n):
C = [0]
for i in range(2,n+1):
C.append(int(i*(i-1)/2))
return C
com = combination(N)
sum_com = 0
for i in range(N):
num_list[int(A[i])-1] += 1
for i in range(N):
if num_list[i] == 0:
continue
else:
sum_com += com[num_list[i]-1]
for i in range(N):
print(sum_com - num_list[int(A[i])-1] + 1)
| 1 | 47,621,663,390,522 | null | 192 | 192 |
from sys import stdin, stdout
import math
import bisect
import re
n, k, c = map(int, stdin.readline().strip().split())
s = stdin.readline().strip()
arr1 = [-1] * 200005
arr2 = [-1] * 200005
cnt = 1
day = 0
while day<len(s):
if s[day] == 'o':
arr1[day] = cnt
cnt += 1
day+=c
if cnt > k:
break
day+=1
cnt = k
day = len(s) - 1
while day>=0:
if s[day] == 'o':
arr2[day]=cnt
cnt-=1
day-=c
if cnt <= 0:
break
day-=1
for i in range(len(s)):
if arr1[i]==arr2[i] and arr1[i]!=-1:
stdout.writelines('%d\n' % (i+1)) | n,k,c=map(int,input().split())
s=input()
l=[]
r=[]
i=0
j=0
while len(l)<k and i<n:
if s[i]=='o':
l.append(i+1)
i+=c+1
else: i+=1
while len(r)<k and j<n:
if s[-j-1]=='o':
r.append(n-j)
j+=c+1
else: j+=1
for n in range(k):
if l[n]==r[-n-1]:
print(l[n]) | 1 | 40,887,740,697,060 | null | 182 | 182 |
import sys
import decimal # 10進法に変換，正確な計算
def input():
return sys.stdin.readline().strip()
def main():
n, k = map(int, input().split())
h = list(map(int, input().split()))
count = 0
for i in h:
if i >= k:
count += 1
print(count)
main() | import sys
input = lambda : sys.stdin.readline().rstrip()
sys.setrecursionlimit(max(1000, 10**9))
write = lambda x: sys.stdout.write(x+"\n")
n,k = list(map(int, input().split()))
h = list(map(int, input().split()))
ans = sum(item>=k for item in h)
print(ans) | 1 | 178,960,356,545,330 | null | 298 | 298 |
import math
a, b, C = map(int, input().split())
rad_C = math.radians(C)
c = math.sqrt(a ** 2 + b ** 2 - 2 * a * b * math.cos(rad_C))
h = b * math.sin(rad_C)
L = a + b + c
s = a * h / 2
print(s)
print(L)
print(h) | import math
a,b,x=map(float, input().split())
h=b*math.sin(math.pi*x/180)
c=(a**2+b**2-2*a*b*math.cos(math.pi*x/180))**0.5
print(a*h*0.5)
print(a+b+c)
print(h) | 1 | 170,087,806,660 | null | 30 | 30 |
# -*- coding: utf-8 -*-
X = int(input())
# A**5 - (A-1)**5 = X = 10**9(Xの最大) となるAが
# Aの最大値となる(それ以上Aが大きくなると、Xは上限値を超える)
# → 最大となるAは120
for A in range(-120, 120 + 1):
for B in range(-120, 120):
if A**5 - B**5 == X:
print("{} {}".format(A, B))
exit() | def main():
x = int(input())
for b in range(-200, 200):
for a in range(b + 1, 200):
if a ** 5 - b ** 5 == x:
print(a, b)
exit()
if __name__ == "__main__":
main()
| 1 | 25,560,207,631,840 | null | 156 | 156 |
s = int(input())
m = 10**9+7
a = [1,0,0,1]
if s < 4:
print(a[s])
exit()
for i in range(4,s+1):
a.append((a[3]+a[1])%m)
a.pop(0)
print(a[3]) | n = int(input())
R = [int(input()) for i in range(n)]
profit= R[1] - R[0]
mn = R[0]
R.pop(0)
for i in R:
if profit < i - mn:
profit = i - mn
if 0 > i - mn:
mn = i
elif mn > i:
mn = i
print(profit) | 0 | null | 1,674,952,728,820 | 79 | 13 |
N,K = map(int,input().split())
p=list(map(int,input().split()))
p.sort()
sum = 0
for i in range(K):
sum += p[i]
print(sum) | (w, h, x, y, r) = input().rstrip().split(' ')
w = int(w)
h = int(h)
x = int(x)
y = int(y)
r = int(r)
if 0 + r <= x <= w - r and 0 + r <= y <= h - r:
print('Yes')
else:
print('No') | 0 | null | 6,027,003,947,756 | 120 | 41 |
def main():
h,w = map(int,input().split(" "))
s = [list(input()) for i in range(h)]
dp = [[0]*w for i in range(h)]
dp[0][0] = 1 if s[0][0]=="#" else 0
for i in range(1,h):
sgmdown = 1 if s[i][0]=="#" and s[i-1][0]=="." else 0
dp[i][0] = dp[i-1][0] + sgmdown
for j in range(1,w):
sgmright = 1 if s[0][j]=="#" and s[0][j-1]=="." else 0
dp[0][j] = dp[0][j-1] + sgmright
for i in range(1,h):
for j in range(1,w):
sgmdown = 1 if s[i][j]=="#" and s[i-1][j]=="." else 0
sgmright = 1 if s[i][j]=="#" and s[i][j-1]=="." else 0
dp[i][j] = min(dp[i-1][j]+sgmdown, dp[i][j-1]+sgmright)
print(dp[h-1][w-1])
main() | import math,string,itertools,fractions,heapq,collections,re,array,bisect,sys,copy,functools
import time,random
sys.setrecursionlimit(10**7)
inf = 10**20
eps = 1.0 / 10**10
mod = 10**9+7
mod2 = 998244353
dd = [(-1,0),(0,1),(1,0),(0,-1)]
ddn = [(-1,0),(-1,1),(0,1),(1,1),(1,0),(1,-1),(0,-1),(-1,-1)]
def LI(): return list(map(int, sys.stdin.readline().split()))
def LLI(): return [list(map(int, l.split())) for l in sys.stdin.readlines()]
def LI_(): return [int(x)-1 for x in sys.stdin.readline().split()]
def LF(): return [float(x) for x in sys.stdin.readline().split()]
def LS(): return sys.stdin.readline().split()
def I(): return int(sys.stdin.readline())
def F(): return float(sys.stdin.readline())
def S(): return input()
def pf(s): return print(s, flush=True)
def pe(s): return print(str(s), file=sys.stderr)
def JA(a, sep): return sep.join(map(str, a))
def JAA(a, s, t): return s.join(t.join(map(str, b)) for b in a)
def main():
h,w = LI()
aa = [[0 if c == '.' else 1 for c in S()] for _ in range(h)]
dp = [[[inf]*2 for _ in range(w)] for __ in range(h)]
dp[0][0][aa[0][0]] = aa[0][0]
for i in range(h):
for j in range(w):
k = aa[i][j]
if i > 0:
dp[i][j][k] = min(dp[i][j][k], dp[i-1][j][k])
dp[i][j][k] = min(dp[i][j][k], dp[i-1][j][1-k]+1)
if j > 0:
dp[i][j][k] = min(dp[i][j][k], dp[i][j-1][k])
dp[i][j][k] = min(dp[i][j][k], dp[i][j-1][1-k]+1)
return min(dp[-1][-1][0] + 1, dp[-1][-1][1] + 2) // 2
print(main())
| 1 | 49,348,457,612,600 | null | 194 | 194 |
S = str(input())
le = len(S)
s = []
for i in range(le):
s.append(S[i])
r = s.count("R")
if r == 0:
print(0)
elif r == 1:
print(1)
elif r == 2:
if s[1] == "S":
print(1)
else:
print(2)
elif r == 3:
print(3)
| from collections import deque
H, W = map(int, input().split())
L = []
for _ in range(H):
s = input()
a = []
for i in range(len(s)):
a.append(s[i])
L.append(a)
dx = [-1, 0, 1, 0]
dy = [0, -1, 0, 1]
def bfs(x, y):
dp = [[10000000] * W for _ in range(H)]
dp[y][x] = 0
if L[y][x] == '#':
return dp
else:
d = deque()
d.append([x, y])
while len(d) > 0:
s = d.popleft()
for i in range(4):
if (s[1] +
dy[i] >= 0 and s[1] +
dy[i] < H and s[0] +
dx[i] >= 0 and s[0] +
dx[i] < W):
if L[s[1] +
dy[i]][s[0] +
dx[i]] == '.' and dp[s[1] +
dy[i]][s[0] +
dx[i]] == 10000000:
d.append([s[0] + dx[i], s[1] + dy[i]])
dp[s[1] + dy[i]][s[0] + dx[i]] = dp[s[1]][s[0]] + 1
return dp
max_num = 0
for i in range(H):
for j in range(W):
dp = bfs(j, i)
for k in dp:
for p in k:
if (p == 10000000):
continue
max_num = max(max_num, p)
print(max_num) | 0 | null | 49,671,802,854,174 | 90 | 241 |
n = int(input())
a = list(map(int, input().split()))
b = a[0]
for v in a[1:]:
b ^= v
print(*map(lambda x: x ^ b, a))
| N=int(input())
A=list(map(int,input().split()))
mlt=0
for a in A:
mlt^=a
for i in range(N):
print(mlt^A[i],end=" ") | 1 | 12,531,510,108,530 | null | 123 | 123 |
n = int(input())
a = list(map(int, input().split()))
lists = [0] * n
for i in range(n):
lists[a[i] - 1] = i + 1
for i in lists:
print(i , end =' ') | n = int(input())
a = list(map(int,input().split()))
d = {}
ans = ''
for i in range(0,n):
d[a[i]] = i+1
d_sorted = sorted(d.items(), key=lambda x:x[0])
for i in range(n):
if ans != '':
ans = ans + ' '
ans = ans + str(d_sorted[i][1])
print(ans) | 1 | 180,482,045,376,832 | null | 299 | 299 |
k = int(input())
s = input()
if k>=len(s):
print(s)
else: print(s[:k] + "...") | K = int(input())
S = input()
if K >= len(S):
print(S)
elif K < len(S):
print(S[:K] + "...")
| 1 | 19,657,224,074,672 | null | 143 | 143 |
N=int(input())
A=list(map(int,input().split()))
A.sort(reverse=True)
if N%2==0:
x=A[0]
x+=sum(A[1:N//2])*2
print(x)
else:
x=A[0]
x+=sum(A[1:(N-1)//2])*2
x+=A[(N-1)//2]
print(x)
| import math
N = int(input())
A = list(map(int,input().split()))
A.sort(reverse=True)
comfortPoint = A[0]
for i in range(N-1)[1::]:
comfortPoint += A[math.ceil(i/2)]
print(comfortPoint)
| 1 | 9,108,976,791,040 | null | 111 | 111 |
n = int(input())
a = list(map(int, input().split()))
try:
idx = a.index(0)
print(0)
except ValueError:
ans = a[0]
for i in range(1, len(a)):
ans *= a[i]
if ans > 10**18:
print('-1')
exit()
print(ans) | N=int(input())
S=["a"]*N
T=[0]*N
for i in range(N):
S[i],T[i]=input().split()
X=input()
flag=0
x=0
for i in range(N):
if flag==1:
x+=int(T[i])
elif X==S[i]:
flag=1
print(x)
| 0 | null | 56,839,586,749,020 | 134 | 243 |
def main():
n = int(input())
a_list = list(map(int, input().split()))
a_set = set(a_list)
if len(a_set) == n:
print("YES")
else:
print("NO")
if __name__ == "__main__":
main()
| #154_C
def has_duplicates(seq):
return len(seq) != len(set(seq))
n = int(input())
a = list(map(int, input().split()))
if has_duplicates(a):
print('NO')
else:
print('YES') | 1 | 74,028,765,924,622 | null | 222 | 222 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.