code1
stringlengths 16
24.5k
| code2
stringlengths 16
24.5k
| similar
int64 0
1
| pair_id
int64 2
181,637B
⌀ | question_pair_id
float64 3.71M
180,628B
⌀ | code1_group
int64 1
299
| code2_group
int64 1
299
|
|---|---|---|---|---|---|---|
print(input()[0:3]) | while True:
n, x = map(int, input().split())
if n == x == 0:
break
count = 0
for i in range(1,n+1):
for j in range(1,n+1):
for k in range(1,n+1):
if (i < j < k):
if i+j+k == x:
count += 1
print(count) | 0 | null | 8,018,400,015,570 | 130 | 58 |
n = int(input())
sum = 0
for num in range(1,n+1):
if num%3 !=0 and num%5 != 0:
sum += num
print(sum) | n = int(input())
s = input()
if n % 2 != 0:
print('No')
elif s[:n//2] == s[n//2:]:
print("Yes")
else:
print("No")
| 0 | null | 90,679,635,469,170 | 173 | 279 |
from sys import stdin, setrecursionlimit
def main():
input = stdin.buffer.readline
x, y, a, b, c = map(int, input().split())
pqr = []
p = list(map(int, input().split()))
q = list(map(int, input().split()))
r = list(map(int, input().split()))
for i in range(a):
pqr.append([p[i], 1])
for i in range(b):
pqr.append([q[i], 2])
for i in range(c):
pqr.append([r[i], 0])
pqr.sort(reverse=True)
ans = 0
c_a = 0
c_b = 0
c_c = 0
for v, k in pqr:
if k == 1 and c_a < x:
ans += v
c_a += 1
elif k == 2 and c_b < y:
ans += v
c_b += 1
elif k == 0 and c_a + c_b + c_c < x + y:
ans += v
c_c += 1
if c_a + c_b + c_c == x + y:
print(ans)
exit()
if __name__ == "__main__":
setrecursionlimit(10000)
main()
| # ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
# . ' Udit Gupta @luctivud ,
# ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
## ## ####### # # ######
## ## ## ## ### ##
## ## ## # # # ##
######### ####### # # ##
# ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
# ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
import sys
import math
# sys.setrecursionlimit(10**6)
def get_ints(): return map(int, sys.stdin.readline().strip().split())
def get_array(): return list(map(int, sys.stdin.readline().strip().split()))
def printwsp(*args): return print(*args, end="")
def printsp(*args): return print(*args, end=" ")
def printchk(*args): return print(*args, end="tst, ")
MODPRIME = int(1e9+7); BABYMOD = 998244353;
# ################################ HELPER PROGRAMS USED ###################################
# ################################## MAIN STARTS HERE #####################################
# for _testcases_ in range(int(input())):
x, y, a, b, c = get_ints()
la = get_array()
lb = get_array()
lc = get_array()
la.sort(reverse = True)
lb.sort(reverse = True)
for i in range(x):
lc.append(la[i])
for i in range(y):
lc.append(lb[i])
lc.sort(reverse = True)
sum = 0
for i in range(x+y):
sum += lc[i]
print(sum)
# #########################################################################################
'''
THE LOGIC AND APPROACH IS BY ME @luctivud.
SOME PARTS OF THE CODE HAS BEEN TAKEN FROM WEBSITES LIKE::
(I Own the code if no link is provided here or I may have missed mentioning it)
: DO NOT PLAGIARISE.
''' | 1 | 44,968,573,533,368 | null | 188 | 188 |
N = int(input())
S = input()
if N % 2 != 0:
print('No')
else:
for i in range(int(N/2)):
if S[i] != S[i + int(N/2)]:
print('No')
break
else:
print('Yes') | def numba_compile(numba_config):
import os, sys
if sys.argv[-1] == "ONLINE_JUDGE":
from numba import njit
from numba.pycc import CC
cc = CC("my_module")
for func, signature in numba_config:
globals()[func.__name__] = njit(signature)(func)
cc.export(func.__name__, signature)(func)
cc.compile()
exit()
elif os.name == "posix":
exec(f"from my_module import {','.join(func.__name__ for func, _ in numba_config)}")
for func, _ in numba_config:
globals()[func.__name__] = vars()[func.__name__]
else:
from numba import njit
for func, signature in numba_config:
globals()[func.__name__] = njit(signature, cache=True)(func)
print("compiled!", file=sys.stderr)
import numpy as np
def solve(N, A):
# dp[n][k] := n 人目まで見て左に k 人送ったときの最大値
A_order = np.argsort(-A)
dp = np.zeros((N+2, N+2), dtype=np.int64)
for n in range(1, N+1):
idx_A = A_order[n-1]
a = A[idx_A]
for k in range(n+1):
dp[n, k] = max(
dp[n-1, k-1] + a * abs(idx_A-(k-1)) if k>0 else 0, # 左に送る
dp[n-1, k] + a * abs(idx_A-(N-n+k)) if k<n else 0, # 右に送る
)
return dp[N].max()
numba_compile([
[solve, "i8(i8,i8[:])"],
])
N = int(input())
A = np.array(input().split(), dtype=np.int64)
ans = solve(N, A)
print(ans)
| 0 | null | 90,565,765,471,620 | 279 | 171 |
a,b,c,d=(int(x) for x in input().split())
l=[a*c,a*d,b*c,b*d]
print(max(l)) | a,b,c,d = map(int,input().split())
s = max(max(a*c,a*d),max(b*c,b*d))
print(s) | 1 | 3,051,735,664,350 | null | 77 | 77 |
N = int(input())
Alist = list(map(int, input().split()))
Alist = [[idx+1, a] for (idx, a) in enumerate(Alist)]
Alist.sort(key=lambda x:x[1])
ans = [str(a) for a, _ in Alist]
print(" ".join(ans)) | n, k = [int(x) for x in input().strip().split()]
arr = [int(x) for x in input().strip().split()]
last = 0
for i in range(k):
last += arr[i]
for i in range(k, len(arr)):
curr = (last + arr[i]) - arr[i-k]
if curr>last:
print('Yes')
else:
print('No')
last= curr
| 0 | null | 93,474,012,962,660 | 299 | 102 |
N = int(input())
A = list(map(int, input().split()))
temp = 0
for a in A:
temp ^= a
ans =[]
for a in A:
ans.append(temp^a)
print(*ans) | N = int(input())
A = list(map(int,input().split()))
def insertionSort(A,N):
for i in range(1,N):
v = A[i]
j = i -1
while j >= 0 and A[j] > v:
A[j+1] = A[j]
j -= 1
A[j+1] = v
outputNum(A)
def outputNum(A):
tmp = map(str,A)
text = " ".join(tmp)
print(text)
outputNum(A)
insertionSort(A,N)
| 0 | null | 6,263,519,990,752 | 123 | 10 |
n=input()
ans=0
if n=="0":
print("Yes")
else:
for i in n:
ans+=int(i)
if ans%9==0:
print("Yes")
else:
print("No") | n = input()
s = 0
for i in range(len(n)):
s += int(n[i])
if s % 3 == 0:
print('Yes')
else:
print('No')
| 1 | 4,380,388,526,260 | null | 87 | 87 |
from math import sqrt
a,b,c,d = map(float,input().split())
print(sqrt((c-a)**2+(d-b)**2)) | import math
x1,y1,x2,y2=map(float,input().split())
A=abs(y1-y2)
B=abs(x1-x2)
C=math.sqrt(A**2+B**2)
print(f'{C:.8f}')
| 1 | 158,350,224,460 | null | 29 | 29 |
n,u,v=map(int,input().split())
tree=[[]for _ in range(n)]
for i in range(n-1):
a,b = map(int,input().split())
tree[a-1].append(b-1)
tree[b-1].append(a-1)
va=[-1]*n
q=[v-1]
va[v-1]=0
while q:
x=q.pop()
for j in tree[x]:
if va[j]==-1:
q.append(j)
va[j]=va[x]+1
q=[u-1]
vt=[-1]*n
vt[u-1]=0
ans=0
while q:
x=q.pop()
ans=max(ans,va[x])
for j in tree[x]:
if vt[j]==-1:
if vt[x]+1<va[j]:
q.append(j)
vt[j]=vt[x]+1
elif vt[x]+1==va[j]:
vt[j]=vt[x]+1
print(ans-1) | import math
def prime(x):
p = {}
last = math.floor(x ** 0.5)
if x % 2 == 0:
cnt = 1
x //= 2
while x & 1 == 0:
x //= 2
cnt += 1
p[2] = cnt
for i in range(3, last + 1, 2):
if x % i == 0:
x //= i
cnt = 1
while x % i == 0:
cnt += 1
x //= i
p[i] = cnt
if x != 1:
p[x] = 1
return p
N = int(input())
P = prime(N - 1)
if N == 2:
print(1)
exit()
ans = 1
for i in P.keys():
ans *= P[i] + 1
ans -= 1
P = prime(N)
D = [1]
for i in P.keys():
L = len(D)
n = i
for j in range(P[i]):
for k in range(L):
D.append(D[k] * n)
n *= i
for i in D:
if i == 1: continue
t = N
while (t / i == t // i):
t //= i
t -= 1
if t / i == t // i:
ans += 1
print(ans)
| 0 | null | 79,724,316,810,920 | 259 | 183 |
n = int(input())
t_score = 0
h_score = 0
for i in range(n):
t_card, h_card = input().split()
if t_card < h_card:
h_score += 3
elif t_card > h_card:
t_score += 3
else:
h_score += 1
t_score += 1
print(t_score, h_score)
| tarop = hanakop = 0
for i in range(int(input())):
taro, hanako = input().split()
if taro > hanako:
tarop += 3
elif taro < hanako:
hanakop += 3
else:
tarop += 1
hanakop += 1
print(tarop, hanakop) | 1 | 2,003,521,571,132 | null | 67 | 67 |
#!/usr/bin/env python3
import sys
input = sys.stdin.readline
MOD = 10**9 + 7
MAX_N = 2 * 10**6 + 10
# Construct factorial table
fac = [1] + [0] * MAX_N
for i in range(1, MAX_N+1):
fac[i] = fac[i-1] * (i) % MOD
fac_inv = [1] + [0] * MAX_N
# Femrmat's little theorem says a**(p-1) mod p == 1
# then, a * a**(p-2) mod p == 1
# it means that a**(p-2) is the inverse element
# Here, Get 1 / n! first
fac_inv[MAX_N] = pow(fac[MAX_N], MOD-2, MOD)
for i in range(MAX_N, 1, -1):
fac_inv[i-1] = fac_inv[i] * i % MOD
def mod_nCr(n, r):
if n < r or n < 0 or r < 0:
return 0
tmp = fac_inv[n-r] * fac_inv[r] % MOD
return tmp * fac[n] % MOD
k = int(input())
s = input().rstrip()
n = len(s)
ans = 0
for i in range(n, k + n + 1):
ret = mod_nCr(i-1, n-1) * pow(25, i - n, MOD) * pow(26, k + n - i, MOD)
ans += ret
ans %= MOD
print(ans) | K = int(input())
s = input()
n=len(s)
def find_power(n,mod=10**9+7):
powlist=[0]*(n+1)
powlist[0]=1
powlist[1]=1
for i in range(2,n+1):
powlist[i]=powlist[i-1]*i%(mod)
return powlist
def find_inv_power(n,mod=10**9+7):
powlist=find_power(n)
check=powlist[-1]
first=1
uselist=[0]*(n+1)
secondlist=[0]*30
secondlist[0]=check
secondlist[1]=check**2
for i in range(28):
secondlist[i+2]=(secondlist[i+1]**2)%(10**9+7)
a=format(10**9+5,"b")
for j in range(30):
if a[29-j]=="1":
first=(first*secondlist[j])%(10**9+7)
uselist[n]=first
for i in range(n,0,-1):
uselist[i-1]=(uselist[i]*i)%(10**9+7)
return uselist
mod = 10**9+7
NUM = (2*10**6)+100
p_lis=find_power(NUM,mod)
ip_lis=find_inv_power(NUM,mod)
def comb(n,r,mod=10**9+7):
if n<r:
return 0
elif n>=r:
return (p_lis[n]*ip_lis[r]*ip_lis[n-r])%(mod)
ans=0
for k in range(K+1):
ans+=(comb(n-1+K-k,n-1)* pow(25,K-k,mod)* pow(26,k,mod))
print(ans%mod) | 1 | 12,674,548,339,050 | null | 124 | 124 |
import numpy as np
n = int(input())
a = list(map(int,input().split()))
mod = 10**9+7
ans = 0
a=np.array(a)
for i in range(60):
keta = a>>i & 1
num1 = int(keta.sum())
num0 = n - num1
ans+= ((2**i)%mod)*(num1*num0)
ans%=mod
print(ans) | n=int(input())
ans = n
for i in range(1,int(n**0.5)+2):
if n % i == 0:
ans = min(ans,(i-1)+(n//i-1))
print(ans) | 0 | null | 142,930,644,658,162 | 263 | 288 |
# coding:UTF-8
import sys
from math import factorial
MOD = 10 ** 9 + 7
INF = float('inf')
N = int(input()) # 数字
A = list(map(int, input().split())) # スペース区切り連続数字
m = max(A)
num = [0] * (m + 1)
for a in A:
num[a] += 1
for a in A:
if num[a] > 1:
num[a] = 0
i = 2
while a * i <= m:
num[a * i] = 0
i += 1
res = 0
for n in num:
if n != 0:
res += 1
print("{}".format(res))
| import sys
read = sys.stdin.read
readlines = sys.stdin.readlines
def main():
n, *a = map(int, read().split())
a.sort()
a = tuple(a)
TorF = [0] * (a[-1] + 1)
for ae in a:
TorF[ae] = 1
for i1 in range(n - 1):
a1 = a[i1]
if TorF[a1]:
m = a[-1] // a1 + 1
for i2 in range(2, m):
TorF[a1 * i2] = 0
if a[i1 + 1] == a[i1]:
TorF[a[i1]] = 0
r = sum(TorF)
print(r)
if __name__ == '__main__':
main() | 1 | 14,287,789,036,612 | null | 129 | 129 |
def min_item_num(weights, num_item, num_vehicle, capacity):
item_idx = 0
for _ in range(num_vehicle):
load = 0
while load + weights[item_idx] <= capacity:
load += weights[item_idx]
item_idx += 1
if item_idx == num_item:
return num_item
return item_idx
def main():
num_item, num_vehicle = list(map(int, input().split(" ")))
weights = [int(input()) for _ in range(num_item)]
left = 0
right = 10000 * 100000
while right - left > 1:
center = (left + right) // 2
min_item = min_item_num(weights, num_item, num_vehicle, center)
if num_item <= min_item:
right = center
else: # min_vehicle > num_item:
left = center
print(right)
if __name__ == "__main__":
main()
| from decimal import Decimal
def com_interest(n: int) -> int:
saving = 100
interest_per = 0.01
years = 0
while True:
years += 1
saving = int(saving * Decimal('1.01'))
if saving >= n:
break
return years
print(com_interest(int(input()))) | 0 | null | 13,646,958,999,320 | 24 | 159 |
t=int(input())
taro=0
hanako=0
for i in range(t):
S=input().split()
if S[0]==S[1]:
taro+=1
hanako+=1
elif S[0]>S[1]:
taro+=3
else:
hanako+=3
print(taro,hanako) | N = int(input())
print(N // 2 - 1 if N % 2 == 0 else (N-1) // 2) | 0 | null | 77,954,638,971,332 | 67 | 283 |
from scipy.special import comb
from collections import Counter
N = int(input())
A = list(map(int, input().split()))
C = Counter(A)
x = 0
for c in C.values():
x += comb(c, 2, exact=True)
for i in range(N):
y = x - comb(C[A[i]], 2, exact=True) + comb(C[A[i]] - 1, 2, exact=True)
print(y)
| N = int(input())
A = list(map(int, input().split()))
D = {a:0 for a in set(A)}
for a in A:
D[a] += 1
S = 0
for v in D.values():
if v>=2:
S += v*(v-1)//2
for a in A:
d = D[a]
if d==1:
print(S)
else:
print(S-d*(d-1)//2+(d-1)*(d-2)//2) | 1 | 47,547,300,693,860 | null | 192 | 192 |
from math import ceil
n = int(input())
ans = 0
for i in range(1, n):
for j in range(1, n // i + 1):
if i * j != n:
#print(i, j, n - i * j)
ans += 1
print(ans) | def main3():
N = int(input())
ans = 0
for a in range(1, N):
ans += (N-1)//a
print(ans)
if __name__ == "__main__":
main3() | 1 | 2,563,421,301,100 | null | 73 | 73 |
# coding: utf-8
def solve(*args: str) -> str:
n, m, k = map(int, args[0].split())
mod = 998244353
if m == 1 and n-1 == k:
return str(1)
ncr = 1
p = m*pow(m-1, n-1, mod) % mod
ret = p
iR = [1]*(k+1)
im = pow(m-1, mod-2, mod)
for i in range(1, k+1):
iR[i] = max(1, (-(mod//i) * iR[mod % i]) % mod)
ncr = (ncr * (n-i)*iR[i]) % mod
p = (p*im) % mod
ret += p*ncr % mod
return str(ret % mod)
if __name__ == "__main__":
print(solve(*(open(0).read().splitlines())))
| N = int(input())
A = list(map(int,input().split()))
sum_A = sum(A)
mod = 10**9+7
ans = 0
for i in range(N-1):
a = A[i]
sum_A-=a
ans+=a*sum_A
print(ans%mod) | 0 | null | 13,531,969,396,990 | 151 | 83 |
x=list(map(int,input().split()))
print(sum([1,2,3,4,5])-sum(x)) | from sys import stdin
mod = 10**9+7
N,K = [int(x) for x in stdin.readline().rstrip().split()]
A = [int(x) for x in stdin.readline().rstrip().split()]
maxn = 2*10**6
fac = [0 for _ in range(maxn)]
finv = [0 for _ in range(maxn)]
inv = [0 for _ in range(maxn)]
fac[0] = fac[1] = 1
finv[0] = finv[1] = 1
inv[1] = 1
for i in range(2,maxn):
fac[i] = fac[i-1] * i % mod
inv[i] = mod - inv[mod%i] * (mod // i) % mod
finv[i] = finv[i-1] * inv[i] % mod
def combinations(n,k):
if n < k:
return 0
if n < 0 or k < 0:
return 0
return fac[n] * (finv[k] * finv[n-k] % mod) % mod
ans = 0
A.sort()
for ind,a in enumerate(A):
ans -= a*combinations(N-ind-1,K-1) % mod
ans %= mod
A.reverse()
for ind,a in enumerate(A):
ans += a*combinations(N-ind-1,K-1) % mod
ans %= mod
print(ans%mod) | 0 | null | 54,567,882,048,160 | 126 | 242 |
select = list(range(1, 4))
a = int(input())
b = int(input())
ans = next(s for s in select if s != a and s != b)
print(ans) | from collections import deque
n = int(input())
dlist = deque()
for i in range(n):
code = input().split()
if code[0] == "insert":
dlist.insert(0,code[1])
if code[0] == "delete":
try:
dlist.remove(code[1])
except:
continue
if code[0] == "deleteFirst":
dlist.popleft()
if code[0] == "deleteLast":
dlist.pop()
print(*dlist,sep=" ") | 0 | null | 55,302,406,427,520 | 254 | 20 |
#!usr/bin/env python3
import sys
def main():
s = sys.stdin.readline().strip('\n')
q = int(sys.stdin.readline().strip('\n'))
for instruction in range(q):
words = [word for word in sys.stdin.readline().strip('\n').split()]
if words[0] == 'replace':
s = s[:int(words[1])] + words[3] + s[int(words[2])+1:]
elif words[0] == 'reverse':
s = s[:int(words[1])] \
+ ''.join(reversed(s[int(words[1]):int(words[2])+1])) \
+ s[int(words[2])+1:]
elif words[0] == 'print':
print(s[int(words[1]):int(words[2])+1])
if __name__ == '__main__':
main() | #!/usr/bin/python3
# -*- coding: utf-8 -*-
import sys
in_str = sys.stdin.readline().strip()
q = int(sys.stdin.readline())
for i in range(q):
command = sys.stdin.readline().split()
pos_a = int(command[1])
pos_b = int(command[2])
if command[0] == 'print':
print(in_str[pos_a:pos_b+1])
elif command[0] == 'reverse':
if pos_a == 0: to_pos = None
else: to_pos = pos_a - 1
in_str = in_str[:pos_a] + in_str[pos_b:to_pos:-1] + in_str[pos_b+1:]
elif command[0] == 'replace':
in_str = in_str[:pos_a] + command[3] + in_str[pos_b+1:]
else:
raise ValueError
| 1 | 2,098,190,512,890 | null | 68 | 68 |
MOD = 10 ** 9 + 7
MAX = 60
n = int(input())
a = list(map(int, input().split()))
cnt = [0 for i in range(MAX)]
for i in range(n):
bit = bin(a[i])[2:].zfill(MAX)
for j in range(MAX):
cnt[j] += int(bit[j])
ans = 0
for i in range(MAX):
ans += cnt[MAX - i - 1] * (n - cnt[MAX - i - 1]) * 2 ** i
ans %= MOD
print(ans)
| 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():
N, *A = map(int, read().split())
ans = 0
p = 1
for _ in range(60):
n = 0
for i in range(N):
A[i], d = A[i] // 2, A[i] % 2
n += d
ans = (ans + n * (N - n) * p) % MOD
p = p * 2 % MOD
print(ans)
return
if __name__ == '__main__':
main()
| 1 | 123,170,837,275,752 | null | 263 | 263 |
A,B=map(int,input().split())
print(0 if A-(B*2)<1 else A-(B*2)) | import sys
sys.setrecursionlimit(10 ** 5 + 10)
def input(): return sys.stdin.readline().strip()
def resolve():
a,b= map(int,input().split())
print(0 if a-b*2<0 else a-b*2)
resolve() | 1 | 166,976,105,185,760 | null | 291 | 291 |
str=input()
n=int(input())
for i in range(n):
s=input().split()
a=int(s[1])
b=int(s[2])
if s[0] == 'replace':
str=str[:a]+s[3]+str[b+1:]
elif s[0] == 'reverse':
str=str[:a]+str[a:b+1][::-1]+str[b+1:]
else:
print(str[a:b+1]) | # -*- coding: utf-8 -*-
"""
Created on Mon Sep 7 22:04:16 2020
@author: liang
"""
N = int(input())
A = [int(x) for x in input().split()]
d = [0]*N
for a in A:
d[a-1] += 1
#print(d)
score = 0
for a in d:
score += a*(a-1)//2
#print(score)
for a in A:
print(score - d[a-1] + 1)
| 0 | null | 24,937,252,171,412 | 68 | 192 |
a = input()
if a == "RSR":
print(1)
else :
print(a.count("R"))
| while True:
(n, x) = [int(i) for i in input().split()]
if n == x == 0:
break
count = 0
for a in range(1, n + 1):
for b in range(a + 1, n + 1):
for c in range(b + 1, n + 1):
if sum([a,b,c]) == x:
count += 1
print(count) | 0 | null | 3,057,749,946,566 | 90 | 58 |
#それゆけにぶたんまん
#python3.8.2のTLEの壁に阻まれました
n = int(input())
l = sorted(list(map(int,input().split())))
ans = 0
for i in range(n):
for j in range(i+1,n):
#jより大きい整数kでl[k]<l[i]+l[j]を満たす最大のk
le = j
ri = n
while ri-le>1:
m = (ri+le)//2
if l[m]<l[i]+l[j]:
le = m
else:
ri = m
ans += le-j
print(ans)
| def fun(d):
cnt = 0
for i in d:
cnt+= i*d[i]
return cnt
from collections import defaultdict
d = defaultdict(int)
n = int(input())
A = list(map(int,input().split()))
for i in range(n):
d[A[i]]+=1
q = int(input())
cnt = sum(A)
for i in range(q):
b,c = map(int,input().split())
if b in d:
cnt+=(-b*d[b] + c*d[b])
d[c]+=d[b]
d[b]=0
#print(cnt,d)
print(cnt)
| 0 | null | 92,373,680,801,720 | 294 | 122 |
import sys
import numpy as np
import math as mt
read = sys.stdin.buffer.read
readline = sys.stdin.buffer.readline
readlines = sys.stdin.buffer.readlines
n = int(readline())
cnt = 1
while n != 1:
n = n//2
cnt += 1
print(sum(2**i for i in range(cnt)))
| import itertools
import collections
class PrimeFactorize:
def __init__(self, n):
self.prime_factor_table = self.create_prime_factor_table(n)
# O(NloglogN)
def create_prime_factor_table(self, n):
self.table = [0] * (n + 1)
for i in range(2, n + 1):
if self.table[i] == 0:
for j in range(i + i, n + 1, i):
self.table[j] = i
return self.table
def prime_factor(self, n):
prime_count = collections.Counter()
while self.prime_factor_table[n] != 0:
prime_count[self.prime_factor_table[n]] += 1
n //= self.prime_factor_table[n]
prime_count[n] += 1
return prime_count
N = int(input())
pf = PrimeFactorize(10**5+5)
for i in range(N,10**5+5):
if pf.prime_factor_table[i]==0:
print(i)
break | 0 | null | 92,795,862,907,000 | 228 | 250 |
import sys
read = sys.stdin.buffer.read
readline = sys.stdin.buffer.readline
readlines = sys.stdin.buffer.readlines
N, *A=map(int,read().split())
bound = [0]*(N+1)
bound[0] = 1
#Nが0のとき
if N == 0:
if A[0] == 1:
print(1)
else:
print(-1)
sys.exit()
#Nが0以外のとき
#上から
for i in range(1,N+1):
bound[i] = (bound[i-1]-A[i-1]) *2
if bound[i] < A[i]:
print(-1)
sys.exit()
#下からのと最小値を取る
cum_sum = 0
for i in range(N,-1,-1):
cum_sum += A[i]
bound[i] = min(bound[i],cum_sum)
print(sum(bound))
| n, m = map(int, input().split())
c = list(map(int, input().split()))
# dp[i][j] = i 番目までを使用して総和がj になる組み合わせ
INF = 5 * 10 ** 4
dp = [[INF] * (n + 1) for _ in range(m + 1)]
dp[0][0] = 0
for i in range(1, m + 1):
for j in range(n + 1):
if j >= c[i - 1]:
dp[i][j] = min(
dp[i - 1][j], dp[i - 1][j - c[i - 1]] + 1, dp[i][j - c[i - 1]] + 1
)# dp[i - 1][j - c[i - 1]] だと、複数回 コインを使う場合に対応していない
else:
dp[i][j] = dp[i - 1][j]
print(dp[m][n])
| 0 | null | 9,456,326,858,300 | 141 | 28 |
# -*- coding: utf-8 -*-
import numpy as np
import sys
from collections import deque
from collections import defaultdict
import heapq
import collections
import itertools
import bisect
from scipy.special import comb
import copy
sys.setrecursionlimit(10**6)
def zz():
return list(map(int, sys.stdin.readline().split()))
def z():
return int(sys.stdin.readline())
def S():
return sys.stdin.readline()[:-1]
def C(line):
return [sys.stdin.readline() for _ in range(line)]
N = z()
S = S()
after_lis = [set() for _ in range(N+1)]
i = N-1
for s in reversed(S):
after_lis[i] = (after_lis[i] | after_lis[i+1])
after_lis[i].add(int(s))
i -= 1
left_index = {}
for i, s in enumerate(S):
if s not in left_index:
left_index[s] = i
ans_lis = np.zeros([10, 10, 10], dtype=np.int32)
for char in left_index:
s_100 = int(char)
for i_10 in range(left_index[char]+1, N-1):
# print("s_10")
s_10 = int(S[i_10])
ans_lis[s_100, s_10, list(after_lis[i_10+1])] = 1
# sは暗証番号の一番左
# print(ans_lis)
print(np.sum(ans_lis))
| import collections
N = int(input())
S = [input() for _ in range(N)]
c = collections.Counter(S)
print(len(c.keys())) | 0 | null | 79,725,972,268,254 | 267 | 165 |
from math import inf
n = int(input())
A = list(map(int, input().split()))
dp = [[-inf] * 3 for _ in range(n + 1)]
k = 1 + n % 2
dp[0][0] = 0
for i in range(n):
for j in range(k + 1):
if j < k:
dp[i + 1][j + 1] = dp[i][j]
now = dp[i][j]
if (i + j) % 2 == 0:
now += A[i]
dp[i + 1][j] = max(dp[i + 1][j], now)
print(dp[n][k])
| string = 2 * raw_input()
search = raw_input()
print 'Yes' if string.count(search) > 0 else 'No' | 0 | null | 19,664,170,698,108 | 177 | 64 |
from sys import stdin
import sys
import math
from functools import reduce
import functools
import itertools
from collections import deque,Counter,defaultdict
from operator import mul
import copy
# ! /usr/bin/env python
# -*- coding: utf-8 -*-
import heapq
sys.setrecursionlimit(10**6)
# INF = float("inf")
INF = 10**18
import bisect
import statistics
mod = 10**9+7
# mod = 998244353
A, B = map(int, input().split())
# リストのlcm
def lcm_base(x, y):
return (x * y) // math.gcd(x, y)
print(lcm_base(A, B)) | def gcd(a,b):
while True:
# print(a,b)
if a >= b:
x = a
y = b
else:
x = b
y = a
mod = x%y
if mod == 0:
return y
else:
a = y
b = mod
A,B = list(map(int,input().split()))
ans = int(A*B / gcd(A,B))
print(ans) | 1 | 113,268,528,435,490 | null | 256 | 256 |
from math import pi
x=float(input())
ans=2*pi*x
print(ans) | import math
x = math.pi
r = int(input())
x = 2*x*r
print(x) | 1 | 31,223,836,727,082 | null | 167 | 167 |
def calc_divisor(x):
divisor = []
for i in range(1, int(x ** 0.5) + 1):
if x % i == 0:
divisor.append(i)
if i != x // i:
divisor.append(x // i)
return divisor
N = int(input())
ans = len(calc_divisor(N - 1)) - 1
cand = sorted(calc_divisor(N))[1:]
for k in cand:
x = N
while x % k == 0:
x //= k
if x % k == 1:
ans += 1
print(ans)
| N = int(input())
if N == 2:
print(1)
exit()
def factorization(n):
arr = []
temp = n
for i in range(2, int(-(-n**0.5//1))+100):
if i > temp / i:
break
if i * i == temp:
arr.append(i)
break
if temp % i == 0:
arr.append(i)
arr.append(temp // i)
arr.append(n)
return arr
N_div = factorization(N)
N_1_div = factorization(N-1)
ans = len(N_1_div)
for K in N_div:
temp = N
while temp % K == 0:
temp = temp // K
if temp % K == 1:
ans += 1
print(ans)
| 1 | 41,405,797,069,828 | null | 183 | 183 |
num=int(input())
num2=[10, 9 ,8]
def multi(x):
y=x**num
return y
a, b, c=map(multi, num2)
print((a-2*b+c)%(int(1e9+7))) | def abc178c():
n = int(input())
print((pow(10, n) - pow(9, n) - pow(9, n) + pow(8, n)) % (pow(10, 9) + 7))
abc178c() | 1 | 3,179,920,343,352 | null | 78 | 78 |
from math import gcd
def lcm(a,b):return (a*b)//(gcd(a,b))
def f(x):
cnt=0
while(x%2==0):
cnt+=1
x=x//2
return cnt
n,m=map(int,input().split())
a=list(map(int,input().split()))
a=list(map(lambda x: x//2,a))
t=f(a[0])
for i in range(n):
if(f(a[i])!=t):
print(0)
exit()
a[i]=a[i]//(2**t)
m=m//(2**t)
l=1
for i in range(n):
l=lcm(l,a[i])
if(l>m):
print(0)
exit()
m=m//l
print((m+1)//2) | import math
from functools import reduce
n, m = input().split()
a = list(map(int, input().split()))
b =[0]*int(n)
for i in range(len(a)):
b[i] = a[i]//2
def lcm_base(x, y):
return (x * y) // math.gcd(x, y)
def lcm_list(numbers):
return reduce(lcm_base, numbers, 1)
c = 0
x = lcm_list(b)
for i in range(int(n)):
if (x // b[i]) % 2 == 0:
c = -1
break
else:
continue
if c == -1:
print(0)
else:
print(math.floor(((int(m)/x)+1)/2))
| 1 | 101,964,606,194,880 | null | 247 | 247 |
N = int(input())
ab = [list(map(int,input().split())) for i in range(N-1)]
graph = [[] for _ in range(N+1)]
for a,b in ab:
graph[a].append(b)
graph[b].append(a)
from collections import deque
todo = deque([1])
seen = deque([])
parent = [0] * (N+1)
# 親と子の関係を作る
while todo:
x = todo.popleft()
seen.append(x)
for y in graph[x]:
if y == parent[x]:
continue
parent[y] = x
todo.append(y)
# 根以外の頂点は、唯一の親を持つことから、
# vの親がpであるとき → color[v] に辺 pvの色を持たせると定めて色を管理
color = [-1] * (N+1)
for x in seen:
ng = color[x]
c = 1
for y in graph[x]:
if y == parent[x]:
continue
if c == ng:
c += 1
color[y] = c
c += 1
ans = []
for a,b in ab:
ans.append(color[b])
print(max(ans))
for i in ans:
print(i)
| class UnionFind:
def __init__(self, n=1):
self.parent = [i for i in range(n)]
self.rank = [0] * n
def find(self, x):
if self.parent[x] == x:
return x
else:
self.parent[x] = self.find(self.parent[x])
return self.parent[x]
def union(self, x, y):
x = self.find(x)
y = self.find(y)
if x != y:
if self.rank[x] < self.rank[y]:
x, y = y, x
if self.rank[x] == self.rank[y]:
self.rank[x] += 1
self.parent[y] = x
def is_same(self, x, y):
return self.find(x) == self.find(y)
N, M = map(int, input().split())
uf = UnionFind(N)
for i in range(M):
a, b = map(int, input().split())
uf.union(a-1, b-1)
for i in range(N):
uf.find(i)
print(len(set([uf.find(i) for i in range(N)])) - 1) | 0 | null | 69,503,813,509,340 | 272 | 70 |
from collections import deque
N, M = map(int, input().split())
G = [[] for _ in range(N+1)]
for _ in range(M):
a, b = map(int, input().split())
G[a].append(b)
G[b].append(a)
q = deque([1])
closed = [False] * (N+1)
closed[1] = True
Ans = [0] * (N+1)
while q:
v = q.popleft()
for u in G[v]:
if not closed[u]:
closed[u] = True
q.append(u)
Ans[u] = v
print("Yes")
print("\n".join(map(str, Ans[2:])))
| def build_combinations_counter(N=10**5, p=10**9+7):
fact = [1, 1] # fact[n] = (n! mod p)
factinv = [1, 1] # factinv[n] = ((n!)^(-1) mod p)
inv = [0, 1] # mod p におけるnの逆元 n^(-1)
for i in range(2, N + 1):
fact.append((fact[-1] * i) % p)
inv.append((-inv[p % i] * (p // i)) % p)
factinv.append((factinv[-1] * inv[-1]) % p)
def cmb(n, r, p, fact, factinv):
if (r < 0) or (n < r):
return 0
r = min(r, n - r)
return fact[n] * factinv[r] * factinv[n-r] % p
import functools
return functools.partial(cmb, p=p, fact=fact, factinv=factinv)
def resolve():
n, k = list(map(int, input().split()))
MOD = 10**9+7
counter = build_combinations_counter(2*10**5, 10**9+7)
ans = 0
for i in range(min(n, k+1)):
ans += counter(n, i) * counter(n-1, n-i-1)
ans %= MOD
print(ans)
if __name__ == "__main__":
resolve()
| 0 | null | 43,688,869,502,432 | 145 | 215 |
import math
import sys
# sys.setrecursionlimit(100000)
def input():
return sys.stdin.readline().strip()
def input_int():
return int(input())
def input_int_list():
return [int(i) for i in input().split()]
def main():
n = input_int()
_x = []
_y = []
for _ in range(n):
x, y = input_int_list()
# 座標系を45度回転させて考える
_x.append(x - y)
_y.append(x + y)
ans = max(max(_x) - min(_x), max(_y) - min(_y))
print(ans)
return
if __name__ == "__main__":
main()
| N = int(input())
#https://img.atcoder.jp/abc178/editorial-E-phcdiydzyqa.pdf
z_list = list()
w_list = list()
for i in range(N):
x,y = map(int, input().split())
z_list.append(x + y)
w_list.append(x - y)
print(max(max(z_list)-min(z_list),max(w_list)-min(w_list))) | 1 | 3,404,114,495,812 | null | 80 | 80 |
N = int(input())
A = list(map(int, input().split()))
ans = [0] * N
for i, a in enumerate(A):
ans[a-1] = i + 1
print(' '.join(map(str, ans)))
| def COMinit():
fac[0] = fac[1] = 1
finv[0] = finv[1] = 1
inv[1] = 1
for i in range(2,max):
fac[i] = fac[i-1]*i%mod
inv[i] = mod - inv[mod%i]*(mod//i)%mod
finv[i] = finv[i-1]*inv[i]%mod
def COM(n,k):
if n < k:
return 0
if n < 0 or k < 0:
return 0
return fac[n] * (finv[k]*finv[n-k]%mod)%mod
mod = 10**9+7
X, Y = map(int,input().split())
a = X%2 #1の数
b = X//2 #2の数
for i in range(b+1):
if a*2 + b*1 == Y:
break
a += 2
b -= 1
if a*2 + b*1 != Y:
print(0)
else:
max = a+b+1
fac = [0] * max
finv = [0] * max
inv = [0] * max
COMinit()
print(COM(a+b,a))
| 0 | null | 165,239,649,743,450 | 299 | 281 |
n, m, l = list(map(int, input().split()))
a = [[int(j) for j in input().split()] for i in range(n)]
b = [[int(j) for j in input().split()] for i in range(m)]
c = [[0 for j in range(l)] for i in range(n)]
for i in range(n):
for j in range(l):
value = 0
for k in range(m):
value = value + a[i][k] * b[k][j]
c[i][j] = value
for i in c:
print(*i)
| #!/usr/bin/env python
# -*- coding: utf-8 -*-
"""
????????????
"""
inp = input().strip().split(" ")
n = int(inp[0])
m = int(inp[1])
l = int(inp[2])
# ?????????????????????????¢????
# A[n][m] B[m][l] C[n][l]
A = [[0 for i in range(m)] for j in range(n)]
B = [[0 for i in range(l)] for j in range(m)]
C = [[0 for i in range(l)] for j in range(n)]
# A???????????°??????????????????
for i in range(n):
inp = input().strip().split(" ")
for j in range(m):
A[i][j] = int(inp[j])
# B???????????°??????????????????
for i in range(m):
inp = input().strip().split(" ")
for j in range(l):
B[i][j] = int(inp[j])
# A x B
for i in range(n):
for j in range(l):
for k in range(m):
C[i][j] += A[i][k] * B[k][j]
print(" ".join(map(str,C[i]))) | 1 | 1,421,375,097,440 | null | 60 | 60 |
a, b, c = map(int, input().split())
k = int(input())
while a >= b and k > 0:
b *= 2
k -= 1
while b >= c and k > 0:
c *= 2
k -= 1
print('Yes' if a < b < c else 'No') | a,b,c=map(int,input().split())
k=int(input())
while k>0:
if a<b:
break
b*=2
k-=1
while k>0:
if b<c:
break
c*=2
k-=1
if a<b<c:
print('Yes')
else:
print('No') | 1 | 6,958,775,378,010 | null | 101 | 101 |
s=list(input())
t=[]
for i in range(3):
t.append(s[i])
r=''.join(t)
print(r)
| X = input()
print("".join(list(X)[0:3])) | 1 | 14,753,486,786,686 | null | 130 | 130 |
#!/usr/bin/env python3
# encoding:utf-8
import copy
import random
import bisect #bisect_left これで二部探索の大小検索が行える
import fractions #最小公倍数などはこっち
import math
import sys
import collections
from decimal import Decimal # 10進数で考慮できる
mod = 10**9+7
sys.setrecursionlimit(mod) # 再帰回数上限はでdefault1000
d = collections.deque()
def LI(): return list(map(int, sys.stdin.readline().split()))
S, W = LI()
if S <= W:
print("unsafe")
else:
print("safe") | import itertools
while True:
n, x = map(int, input().split())
if n == x == 0:
break
ans = 0
for t in list(itertools.combinations([i + 1 for i in range(n)], 3)):
if sum(t) == x:
ans += 1
print(ans) | 0 | null | 15,188,315,900,784 | 163 | 58 |
def func(D,T,S):
actualTime = D / S
if actualTime <= T:
return "Yes"
else:
return "No"
if __name__ == "__main__":
inputStr = input().split(' ')
D = int(inputStr[0])
T = int(inputStr[1])
S = int(inputStr[2])
print(func(D,T,S)) | S = input()
T = input()
if len(S)+1 == len(T) and S == T[:-1]:
print("Yes")
else:
print("No") | 0 | null | 12,479,481,716,520 | 81 | 147 |
n = int(input())
buffer = []
i = 0
while i<n:
b,f,r,v = map(int,input().split())
buffer.append([b,f,r,v])
i = i + 1
room = []
for h in range(15):
if h == 3 or h == 7 or h == 11:
room.append(['**']*10)
else:
room.append([0]*10)
for y in range(n):
if buffer[y][0] == 1:
room[buffer[y][1]-1][buffer[y][2]-1] = buffer[y][3] + room[buffer[y][1]-1][buffer[y][2]-1]
elif buffer[y][0] == 2:
room[buffer[y][1]-1+4][buffer[y][2]-1] = buffer[y][3] + room[buffer[y][1]-1+4][buffer[y][2]-1]
elif buffer[y][0] == 3:
room[buffer[y][1]-1+8][buffer[y][2]-1] = buffer[y][3] + room[buffer[y][1]-1+8][buffer[y][2]-1]
elif buffer[y][0] == 4:
room[buffer[y][1]-1+12][buffer[y][2]-1] = buffer[y][3] + room[buffer[y][1]-1+12][buffer[y][2]-1]
for x in range(15):
if x == 3 or x == 7 or x == 11:
print("####################")
else:
for y in range(10):
print(" "+str(room[x][y]), end = "")
print()
| while True:
x = map(int,list(raw_input()))
if 0 != x[0]:
print sum(x)
else:
break | 0 | null | 1,344,845,913,958 | 55 | 62 |
N = int(input())
array = list(map(int, input().split()))
cnt = 0
for i in range(N):
minij = i
for j in range(i, N):
if array[j] < array[minij]:
minij = j
if minij != i:
array[i], array[minij] = array[minij], array[i]
cnt += 1
print(' '.join(map(str, array)))
print( "%d" % (cnt))
| n, k = map(int, input().split())
g = [1] * k
mod = 10 ** 9 + 7
for i in range(k, 0, -1):
x = k // i
m = n
while m > 0:
if m & 1:
g[i-1] = g[i-1] * x % mod
x = x * x % mod
m >>= 1
y = 2
while i * y <= k:
g[i-1] -= g[i*y-1]
y += 1
ans = 0
for i in range(k):
ans = (ans + g[i] * (i + 1)) % mod
print(ans)
| 0 | null | 18,530,167,158,240 | 15 | 176 |
_ = input()
x = list(map(int, input().split()))
y = [str(i) for i in reversed(x)]
print(' '.join(y))
| # -*- coding: utf-8 -*-
'import sys'
input()
a=[int(i) for i in input().split()]
a.reverse()
f=0
for i in range(len(a)):
if f: print(" ",end="")
print("{}".format(a[i]),end="")
f=1
print("") | 1 | 1,003,405,385,300 | null | 53 | 53 |
import math
loan = 100000
n = int(input())
for i in range(n):
interest = math.ceil(loan * 0.05 / 1000) * 1000
loan += interest
print(loan) | weatherS = input()
serial = 0
dayBefore = ''
for x in weatherS:
if dayBefore != 'R':
if x == 'R':
serial = 1
else:
if x == 'R':
serial += 1
dayBefore = x
print(serial) | 0 | null | 2,404,601,651,762 | 6 | 90 |
mod = 10**9 + 7
_factorial = [1]
def fact(n):
''' n! % mod '''
if n >= mod:
return 0
_size = len(_factorial)
if _size < n+1:
for i in range(_size, n+1):
_factorial.append(_factorial[i-1]*i % mod)
return _factorial[n]
_factorial_inv = [1]
def fact_inv(n):
''' n!^-1 % mod '''
if n >= mod:
raise ValueError('Modinv is not exist! arg={}'.format(n))
_size = len(_factorial)
if _size < n+1:
for i in range(_size, n+1):
_factorial.append(_factorial[i-1]*i % mod)
_size_inv = len(_factorial_inv)
if _size_inv < n+1:
for i in range(_size_inv, n+1):
_factorial_inv.append(modinv(_factorial[i]))
return _factorial_inv[n]
def comb(n, r):
''' nCr % mod '''
if r > n:
return 0
t = fact(n) * modinv(fact(n-r)) % mod
t = t * modinv(fact(r)) % mod
return t
def xgcd(a, b):
x0, x1, y0, y1 = 0, 1, 1, 0
while a != 0:
(q, a), b = divmod(b, a), a
y0, y1 = y1, y0 - q * y1
x0, x1 = x1, x0 - q * x1
return b, x0, y0
def modinv(n):
g, x, _ = xgcd(n, mod)
if g != 1:
raise ValueError('Modinv is not exist! arg={}'.format(n))
return x % mod
x, y = sorted(map(int, input().split()))
q, r = divmod(x+y, 3)
if r != 0:
print(0)
else:
print(comb(q, y-q))
| class Combination:
"""階乗とその逆元のテーブルをO(N)で事前作成し、組み合わせの計算をO(1)で行う"""
def __init__(self, n, mod):
self.fact = [1]
for i in range(1, n + 1):
self.fact.append(self.fact[-1] * i % mod)
self.inv_fact = [0] * (n + 1)
self.inv_fact[n] = pow(self.fact[n], mod - 2, mod)
for i in reversed(range(n)):
self.inv_fact[i] = self.inv_fact[i + 1] * (i + 1) % mod
self.mod = mod
def factorial(self, k):
"""k!を求める O(1)"""
return self.fact[k]
def inverse_factorial(self, k):
"""k!の逆元を求める O(1)"""
return self.inv_fact[k]
def permutation(self, k, r):
"""kPrを求める O(1)"""
if k < r:
return 0
return (self.fact[k] * self.inv_fact[k - r]) % self.mod
def combination(self, k, r):
"""kCrを求める O(1)"""
if k < r:
return 0
return (self.fact[k] * self.inv_fact[k - r] * self.inv_fact[r]) % self.mod
def combination_large(self, k, r):
"""kCrを求める O(r) kが大きいが、r <= nを満たしているときに使用"""
if k < r:
return 0
res = 1
for l in range(r):
res *= (k - l)
res %= self.mod
return (res * self.inv_fact[r]) % self.mod
x, y = map(int, input().split())
mod = 10**9 + 7
comb = Combination(10**6,mod)
if (x+y)%3 != 0:
print(0)
exit(0)
i = (2*x-y)//3
j = (2*y-x)//3
n = i+j
r = i
if not 0 <= r <= n:
print(0)
exit(0)
print(comb.combination(n, r))
| 1 | 149,833,248,396,120 | null | 281 | 281 |
n = int(input())
a = 0
while(a < n):
a += 1000
print(a - n) | x = int(input())
print((1000 - x % 1000) % 1000) | 1 | 8,405,083,191,950 | null | 108 | 108 |
n = int(input())
fib = []
fib.append(1)
fib.append(1)
for _ in range(n - 1):
fib.append(fib[-2] + fib[-1])
print(fib[-1])
| from sys import stdin
def main():
#入力
readline=stdin.readline
n=int(readline())
dp=[0]*(n+1)
for i in range(n+1):
if i==0 or i==1:
dp[i]=1
else:
dp[i]=dp[i-1]+dp[i-2]
print(dp[n])
if __name__=="__main__":
main()
| 1 | 2,169,582,690 | null | 7 | 7 |
num = int(input())
print(0 if num == 1 else 1) | A,B,C,K=map(int,input().split())
if A>=K:
print(K)
elif B>=K-A:
print(A)
else:
print(A-1*(K-A-B))
| 0 | null | 12,308,571,086,112 | 76 | 148 |
d,t,s=map(int, input().split())
if d/s<=t:
print("Yes")
else:
print("No") | a,b,c = map(int, input().split())
print("Yes") if b * c >= a else print("No") | 1 | 3,555,966,568,268 | null | 81 | 81 |
l = map(int, raw_input().split())
a, b, c = sorted(l)
print a, b, c | a,b,c = map (int,input().split())
if b < a :
a , b = b , a
if c < a :
a , c = c , a
if c < b :
b , c = c , b
print(a,b,c)
| 1 | 417,481,406,200 | null | 40 | 40 |
ma = lambda :map(int,input().split())
lma = lambda :list(map(int,input().split()))
tma = lambda :tuple(map(int,input().split()))
ni = lambda:int(input())
yn = lambda fl:print("Yes") if fl else print("No")
import collections
import math
import itertools
import heapq as hq
n,m = ma()
s = input()
dp = [-1]*(n+1) #dp[i]:: i番目にたどり着く最小コスト
dp[0]=0
r=0
while r<=n-1:
l=0
tmp=0
while l+1<=m and r+l+1<=n:
l+=1
if s[r+l]=="0":
tmp=l
dp[r+l]=dp[r]+1
r+=tmp
#if r==n:break
if tmp==0:
print(-1)
exit()
d = dp[-1]
rt = []
dp = dp[::-1]
r=0
while r<=n-1:
l=0
tmp=0
while l+1<=m and r+l+1<=n:
l+=1
if dp[r+l]==d-1:
tmp=l
rt.append(tmp)
d-=1
r+=tmp
print(*reversed(rt))
| from decimal import Decimal
a, b = map(str, input().split())
a = int(a)
b = Decimal(b)
print(int(a * b)) | 0 | null | 77,605,491,675,228 | 274 | 135 |
n, x = int(input()), list(map(int, input().split()))
px = 0
a = 100 ** 100
for i in range(100):
s = 0
for j in x:
s += (i-j) ** 2
if a > s:
a = s
print(a) | import math
N = int(input())
lst = list(map(int, input().split()))
X = math.floor(sum(lst)/N + 0.5)
ans = 0
for i in lst:
ans = ans + (X - i)**2
print(ans) | 1 | 65,327,714,324,224 | null | 213 | 213 |
if __name__ == "__main__":
input_num = input()
while input_num != "0":
sum_of_digits = 0
for d in input_num:
sum_of_digits = sum_of_digits + int(d)
print(sum_of_digits)
input_num = input()
| import math
H, W = map(int, input().split(' '))
if H == 1 or W == 1:
print(1)
exit()
res = math.ceil((H*W)/2)
print(res)
| 0 | null | 26,200,991,881,812 | 62 | 196 |
s=input()
p=input()
s=s+s
a=s.find(p)
if a==-1:
print('No')
else:
print('Yes')
| s=input()
p=input()
print('Yes' if p in s+s else 'No') | 1 | 1,729,157,339,466 | null | 64 | 64 |
from math import sqrt
def distance2(x, y, p='infinite'):
if p == 'infinite':
return max([abs(dx - dy) for dx, dy in zip(x,y)])
else:
return sum([(abs(dx - dy)**p) for dx, dy in zip(x, y)])**(1/p)
if __name__ == '__main__':
n = int(input())
x = list(map(int, input().split()))[0:n]
y = list(map(int, input().split()))[0:n]
print(distance2(x, y, 1))
print(distance2(x, y, 2))
print(distance2(x, y, 3))
print(distance2(x, y))
| import math
x1, y1, x2, y2 = map(float, input().split())
dx = x1 - x2
dy = y1 - y2
d = math.hypot(dx, dy)
print(d) | 0 | null | 183,034,713,728 | 32 | 29 |
import sys
import numpy as np
from collections import Counter
# 全探索なら、 2**6 * 2**6 （4000）
# > 4000 * (6**2)
# bit全探索でOK
# ------------------------------------------
h, w, num = map(int, input().split())
data = []
for _ in range(h):
# 一文字ずつListへ格納
temp = list(input())
data.append(temp)
#data = [input() for _ in range(h)]
# print(data)
'''
count = Counter(data)
most = count.most_common()
print(most)
'''
ans = 0
# 縦の全Loop
for i in range(2 ** h):
for j in range(2 ** w):
#print(i, j)
*temp, = data
temp = np.array(temp)
for k in range(h):
if (i >> k & 1):
temp[k, :] = 'aa'
for l in range(w):
if (j >> l & 1):
temp[:, l] = 'aa'
count = np.where(temp == '#')[0]
#print(count, len(count))
if (len(count) == num):
# print('add')
ans += 1
else:
pass
print(ans)
|
import queue
WHITE = 0
GRAY = 1
BLACK = 2
NIL = -1
INF = 1000000000
def bfs(u):
global Q
Q.put(u)
for i in range(n):
d[i] = NIL
d[u] = 0
while not Q.empty():
u = Q.get()
for v in range(n):
if (m[u][v] == 1) and (d[v] == NIL):
d[v] = d[u] + 1
Q.put(v)
n = int(input())
m = [[0 for i in range(n + 1)] for j in range(n + 1)]
vid = [0] * n
d = [0] * n
f = [0] * n
Q = queue.Queue()
color = [WHITE] * n
time = 0
nt = [0] * n
tmp = []
for i in range(n):
nums=list(map(int,input().split()))
tmp.append(nums)
vid[i] = nums[0]
for i in range(n):
for j in range(tmp[i][1]):
m[i][vid.index(tmp[i][j + 2])] = 1
bfs(0)
for i in range(n):
print(vid[i], d[i])
| 0 | null | 4,511,465,326,760 | 110 | 9 |
n, k = map(int, input().split())
li_a = list(map(int, input().split()))
for idx, v in enumerate(li_a):
if idx <= (k - 1):
pass
else:
if v > li_a[idx - k]:
print('Yes')
else:
print('No')
| def main():
N, K = (int(x) for x in input().split())
scores = [int(x) for x in input().split()]
first, last = 0, K-1
while last < N-1:
last += 1
if scores[first] < scores[last]: print('Yes')
else: print('No')
first += 1
if __name__ == '__main__':
main() | 1 | 7,144,283,964,960 | null | 102 | 102 |
n = int(input())
a = list(map(int, input().split()))
#print(a)
a.reverse()
print(*a)
| input()
list = input().split()
list.reverse()
print (' '.join(list)) | 1 | 988,491,607,360 | null | 53 | 53 |
s=raw_input()
target=raw_input()
ring=s+s[0:len(target)]
f=0
for i in range(len(s)):
if ring[i:i+len(target)]==target:
f=1
break
if f==1:
print "Yes"
else:
print "No" | s = input()
p = input()
s = s + s
if p in s:
print('Yes')
else:
print('No')
| 1 | 1,712,047,589,820 | null | 64 | 64 |
import math
import sys
if __name__ == '__main__':
for line in sys.stdin:
a,b = map(int,line.split())
print(math.gcd(a,b),(a*b) // math.gcd(a,b))
| import sys
import fractions
def lcm(a,b):
return int(a*b/fractions.gcd(a,b))
if __name__ == '__main__':
for line in sys.stdin:
a,b = map(int,line.split())
print(int(fractions.gcd(a,b)),lcm(a,b)) | 1 | 509,602,720 | null | 5 | 5 |
N = int(input())
mod = 10**9+7
ans = pow(10, N, mod) - ((pow(9, N, mod) * 2) - pow(8, N, mod))
ans %= mod
print(ans)
| import sys
stdin = sys.stdin
inf = 1 << 60
mod = 1000000007
sys.setrecursionlimit(10**7)
ni = lambda: int(ns())
nin = lambda y: [ni() for _ in range(y)]
na = lambda: list(map(int, stdin.readline().split()))
nan = lambda y: [na() for _ in range(y)]
nf = lambda: float(ns())
nfn = lambda y: [nf() for _ in range(y)]
nfa = lambda: list(map(float, stdin.readline().split()))
nfan = lambda y: [nfa() for _ in range(y)]
ns = lambda: stdin.readline().rstrip()
nsn = lambda y: [ns() for _ in range(y)]
ncl = lambda y: [list(ns()) for _ in range(y)]
nas = lambda: stdin.readline().split()
def modpow(n, p, m):
if p == 0:
return 1
if p % 2 == 0:
t = modpow(n, p // 2, m)
return t * t % m
return n * modpow(n, p - 1, m) % m
n = ni()
A = modpow(9, n, mod)
B = A
C = modpow(8, n, mod)
D = modpow(10, n, mod)
ans = (D - A - B + C) % mod
print(ans) | 1 | 3,173,758,746,912 | null | 78 | 78 |
A,B = map(int,input().split())
print(A*B if A<= 9 and B <=9 else "-1")
| S=input()
P=input()
I=S*2
if P in I:
print('Yes')
else:
print('No')
| 0 | null | 79,717,321,933,132 | 286 | 64 |
N,M=map(int,input().split())
H=list(map(int,input().split()))
G={i+1 for i in range(N)}
for _ in range(M):
a,b=map(int,input().split())
if H[a-1]>H[b-1]:
G-={b}
elif H[b-1]>H[a-1]:
G-={a}
else:
G-={a,b}
print(len(G)) | N, M = map(int, input().split())
H = list(map(int, input().split()))
ans = M
counted = []
appeared = set()
for i in range(M):
a, b = map(int, input().split())
if H[a-1] < H[b-1]:
appeared.add(a)
elif H[a-1] > H[b-1]:
appeared.add(b)
else:
appeared.add(a)
appeared.add(b)
ans = len(H) - len(appeared)
print(ans)
| 1 | 24,906,590,440,030 | null | 155 | 155 |
import sys
sys.setrecursionlimit(10**9)
def mi(): return map(int,input().split())
def ii(): return int(input())
def isp(): return input().split()
def deb(text): print("-------\n{}\n-------".format(text))
INF=10**20
def main():
X=ii()
i = 1
yen = 100
while yen < X:
r = yen // 100
yen += r
i += 1
print(i-1)
if __name__ == "__main__":
main() | X = int(input())
ans = 0
Y = 100
while Y < X:
Y += Y // 100
ans += 1
print(ans)
| 1 | 27,037,558,355,840 | null | 159 | 159 |
S = [s for s in input()]
stack1 = []
stack2 = []
for i in range(len(S)):
if S[i] == '\\':
stack1.append(i)
elif S[i] == '/':
if len(stack1) != 0:
pos = stack1.pop()
area = i - pos
while len(stack2) != 0:
pair = stack2.pop()
if pos < pair[0]:
area += pair[1]
else:
stack2.append(pair)
break
stack2.append((pos, area))
print(sum([s[1] for s in stack2]))
print(len(stack2), *[s[1] for s in stack2])
| S = list(input())
T = list(input())
L = len(S)
i = 0
cn = 0
N = 200000
while i < L:
if S[i] != T[i]:
i = i + 1
cn = cn + 1
else:
i = i + 1
print(cn) | 0 | null | 5,277,039,899,676 | 21 | 116 |
def main():
n, k = map(int, input().split())
h_lst = list(map(int, input().split()))
ans = 0
for h in h_lst:
if h >= k:
ans += 1
print(ans)
if __name__ == "__main__":
main()
| def some():
n, k = map(int, input().split(" "))
h = map(int, input().split(" "))
print(len([i for i in h if i >= k]))
some() | 1 | 178,731,259,867,000 | null | 298 | 298 |
import sys
array = [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]
print(array[int(sys.stdin.readline()) - 1]) | N = list(map(int, "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".split(", ")))
n = int(input())
print(N[n-1]) | 1 | 49,876,289,095,424 | null | 195 | 195 |
s = input()
if len(s) % 2 == 1:
print('No')
else:
ans = "Yes"
for i in range(len(s)):
if i % 2 == 0 and s[i] != 'h':
ans = "No"
break
if i % 2 == 1 and s[i] != 'i':
ans = "No"
break
print(ans) | K = int(input())
x = 7
for i in range(K):
if x % K == 0:
print(i+1)
exit()
else:
x = (10*x + 7) % K
print(-1) | 0 | null | 29,771,086,307,964 | 199 | 97 |
MOD = 10 ** 9 + 7
X, Y = map(int, input().split())
if (X + Y) % 3 or Y > 2 * X or Y < X // 2:
print(0)
exit()
n = (X + Y) // 3
r = X - (X + Y) // 3
num, den = 1, 1
if n - r < r:
r = n - r
for i in range(1, r + 1):
num *= n - i + 1
num %= MOD
den *= i
den %= MOD
print((num * pow(den, MOD - 2, MOD)) % MOD) | for i in range(1, 100000):
num = int(input())
if num == 0:
break
print('Case ' + str(i) + ':', num) | 0 | null | 75,255,831,175,282 | 281 | 42 |
li =list(map(int,input().split()))
n =li[0]
m =li[1]
k =li[2]
count =0
for i in range(n,m+1):
if i%k ==0:
count +=1
print(count)
| m,n,p = map(int, input().split())
l=[]
for i in range(m,n+1):
if i % p == 0:
l.append(i)
print(len(l)) | 1 | 7,613,295,994,940 | null | 104 | 104 |
n = input()
ans = 0
for nn in n:
ans += int(nn)
print('Yes') if ans%9 == 0 else print('No') | while True:
h,w=map(int,input().split())
if h==0 and w==0:
break
for i in range(h):
for j in range(w):
if i==0 or j==0 or i==h-1 or j==w-1:
print("#",end="")
else:
print(".",end="")
print("")
print("")
| 0 | null | 2,620,564,412,352 | 87 | 50 |
h, n = map(int, input().split())
a = list(map(int, input().split()))
a_sum = sum(a)
if h <= a_sum:
print('Yes')
else:
print('No')
| N = int(input())
A = list(map(int, input().split()))
sm=0
mod=10**9+7
s=sum(A)
for i in A:
s-=i
sm+=i*s
sm%=mod
print(sm) | 0 | null | 41,050,215,695,398 | 226 | 83 |
import collections
n = int(input())
s_ls = []
dic = collections.defaultdict(int)
for i in range(n):
[s,t] = [j for j in input().split()]
s_ls.append(s)
dic[s] = int(t)
x = input()
f = 0
ans = 0
for i in range(n):
if f:
ans += dic[s_ls[i]]
if x == s_ls[i]:
f = 1
print(ans)
| print('bust' if sum(list(map(int, input().split()))) >= 22 else 'win') | 0 | null | 108,221,819,164,768 | 243 | 260 |
while 1:
x, y = map(int, input().split())
if x == 0 and y == 0:
break
if x >= y:
print("{0} {1}".format(y, x))
else:
print("{0} {1}".format(x, y)) | s=input()
if s[-1]!='s':print(s+'s')
else:print(s+'es') | 0 | null | 1,451,824,525,550 | 43 | 71 |
N,K = map(int,input().split())
A = list(map(int,input().split()))
A = sorted(A)
mod = 10**9+7
def p(m,n):
a = 1
for i in range(n):
a = a*(m-i)
return a
def p_mod(m,n,mod):
a = 1
for i in range(n):
a = a*(m-i) % mod
return a
def c(m,n):
return p(m,n) // p(n,n)
def c_mod(m,n,mod):
return (p_mod(m,n,mod)*pow(p_mod(n,n,mod),mod-2,mod)) % mod
C = [0]*(N-K+1) #C[i] = (N-i-1)C_(K-1),予め二項係数を計算しておく
for i in range(N-K+1):
if i == 0:
C[i] = c_mod(N-1,K-1,mod)
else:
C[i] = (C[i-1]*(N-K-i+1)*pow(N-i,mod-2,mod)) % mod
#各Aの元が何回max,minに採用されるかを考える
ans = 0
for i in range(N-K+1):
ans -= (A[i]*C[i]) % mod
A.reverse()
for i in range(N-K+1):
ans += (A[i]*C[i]) % mod
print(ans % mod) | # D - Caracal vs Monster
H = int(input())
def rec(x):
if x==1:
return 1
else:
return 2*rec(x//2)+1
print(rec(H)) | 0 | null | 87,835,634,081,152 | 242 | 228 |
s = input()
K = int(input())
n =len(s)
dp = [[[0] * 2 for _ in range(4)] for _ in range(101)]
dp[0][0][0]=1
for i in range(n):
for j in range(4):
for k in range(2):
nd = int(s[i])
for d in range(10):
ni = i+1; nj = j; nk = k
if d != 0 :nj+=1
if nj > K:continue
if k==0:
if d > nd:continue
if d < nd:nk =1
dp[ni][nj][nk] += dp[i][j][k]
# print(d,k)
# print(i,j,k,dp[i][j][k])
# print(ni,nj,nk,dp[ni][nj][nk])
# [print(i) for i in dp]
ans=dp[n][K][0] + dp[n][K][1]
print(ans)
# [print(i) for i in dp] | dicpos = {}
dicneg = {}
N = int(input())
for i in range(N):
buf = [0]
for s in input():
if s=="(":
buf.append(buf[-1] + 1)
else:
buf.append(buf[-1] - 1)
low = min(buf)
last = buf[-1]
if last>0:
if low in dicpos:
dicpos[low].append(last)
else:
dicpos[low] = [last]
else:
if low-last in dicneg:
dicneg[low-last].append(-last)
else:
dicneg[low-last] = [-last]
neg_sorted = sorted(dicneg.items(), key=lambda x:x[0], reverse=True)
pos_sorted = sorted(dicpos.items(), key=lambda x:x[0], reverse=True)
#print(neg_sorted)
#print(pos_sorted)
summ = 0
flag = 0
for i in pos_sorted:
if flag == 1:
break
for j in i[1]:
if summ + i[0] < 0:
flag = 1
print("No")
break
summ += j
summ2 = 0
if flag == 0:
for i in neg_sorted:
if flag == 1:
break
for j in i[1]:
if summ2 + i[0] < 0:
flag = 1
print("No")
break
summ2 += j
if flag == 0:
if summ == summ2:
print("Yes")
else:
print("No") | 0 | null | 49,959,258,128,900 | 224 | 152 |
mod = 10**9 + 7
from collections import deque
def main():
N = iip(False)
K = iip(False)
ret = solve(N, K)
print(ret)
def solve(N, K):
strn = str(N)
A = []
B = []
for i in range(len(strn), 0, -1):
if strn[len(strn)-i] != "0":
A.append(int(strn[len(strn)-i]))
B.append(i)
if K == 1:
return 9*(B[0]-1) + A[0]
if K == 2:
if len(strn) < 2:
return 0
ret = 0
ret += (B[0]-1) * (B[0]-2) // 2 * (9**2) #桁数がmaxじゃない場合
ret += (A[0]-1) * 9 * (B[0]-1) #桁数がmaxで先頭桁がmax以外の場合
if len(B) >= 2 and len(A) >= 2:
ret += (B[1]-1) * 9 + A[1] #先頭桁がmaxの場合
return ret
ret = 0
ret += (B[0] - 1) * (B[0] - 2) * (B[0] - 3) // 6 * 9**3 #桁数がmaxじゃない場合
ret += (A[0] - 1) * (B[0] - 1) * (B[0] - 2) // 2 * 9**2 #桁数がmaxで先頭桁がmaxじゃない場合
#以下、桁数はmaxで先頭桁はmaxとする
if len(strn) < 3:
return 0
if len(B) >= 2:
ret += (B[1]-1) * (B[1]-2) // 2 * 9**2 #有効2桁目の桁数がmaxじゃない場合
if len(B) >= 2 and len(A) >= 2:
ret += (A[1] - 1) * (B[1]-1) * 9 #有効2桁目の桁数がmaxで数字がmaxじゃない場合
if len(B) >= 3 and len(A) >= 3:
ret += (B[2] - 1) * 9 + A[2] #有効2桁目,3桁目がmaxの場合
return ret
#####################################################ライブラリ集ここから
def split_print_space(s):
print(" ".join([str(i) for i in s]))
def split_print_enter(s):
print("\n".join([str(i) for i in s]))
def searchsorted(sorted_list, n, side):
if side not in ["right", "left"]:
raise Exception("sideはrightかleftで指定してください")
l = 0
r = len(sorted_list)
if n > sorted_list[-1]:
#print(sorted_list)
return len(sorted_list)
if n < sorted_list[0]:
return 0
while r-l > 1:
x = (l+r)//2
if sorted_list[x] > n:
r = x
elif sorted_list[x] < n:
l = x
else:
if side == "left":
r = x
elif side == "right":
l = x
if side == "left":
if sorted_list[l] == n:
return r - 1
else:
return r
if side == "right":
if sorted_list[l] == n:
return l + 1
else:
return l
def iip(listed):
ret = [int(i) for i in input().split()]
if len(ret) == 1 and not listed:
return ret[0]
return ret
def soinsuu_bunkai(n):
ret = []
for i in range(2, int(n**0.5)+1):
while n % i == 0:
n //= i
ret.append(i)
if i > n:
break
if n != 1:
ret.append(n)
return ret
def conbination(n, r, mod, test=False):
if n <=0:
return 0
if r == 0:
return 1
if r < 0:
return 0
if r == 1:
return n
ret = 1
for i in range(n-r+1, n+1):
ret *= i
ret = ret % mod
bunbo = 1
for i in range(1, r+1):
bunbo *= i
bunbo = bunbo % mod
ret = (ret * inv(bunbo, mod)) % mod
if test:
#print(f"{n}C{r} = {ret}")
pass
return ret
def inv(n, mod):
return power(n, mod-2)
def power(n, p):
if p == 0:
return 1
if p % 2 == 0:
return (power(n, p//2) ** 2) % mod
if p % 2 == 1:
return (n * power(n, p-1)) % mod
if __name__ == "__main__":
main() | def nCk(n, k):
if k > n or min(n, k) < 0:
return 0
res = 1
for i in range(1, k + 1):
res = res * (n - i + 1) // i
return res
def solveSmaller():
return 9 ** k * nCk(n - 1, k)
def solveDp():
global k
dp = [[[0 for _ in range(2)] for _ in range(k + 1)] for _ in range(n)] # i, used k, smaller
dp[0][1][0] = 1
dp[0][1][1] = int(s[0]) - 1
cnt = 1
for i in range(1, n):
cnt += s[i] != '0'
for k in range(1, k + 1):
dp[i][k][0] = cnt == k
dp[i][k][1] = dp[i - 1][k][1] + \
(dp[i - 1][k][0] if s[i] != '0' else 0) + \
dp[i - 1][k - 1][1] * 9 + \
dp[i - 1][k - 1][0] * max(0, int(s[i]) - 1)
return dp[n - 1][k][0] + dp[n - 1][k][1]
s = input()
k = int(input())
n = len(s)
print(solveSmaller() + solveDp()) | 1 | 75,625,906,072,652 | null | 224 | 224 |
n=int(input())
s,t = map(str, input().split())
print(''.join([s[i] + t[i] for i in range(0,n)])) | import sys
input = sys.stdin.readline
n, (s, t) = int(input()), input()[:-1].split()
print(''.join(s[i] + t[i] for i in range(n))) | 1 | 111,652,438,463,102 | null | 255 | 255 |
S=input()
N=len(S)
M=(N-1)//2
def iskaibun(T):
K=len(T)
for i in range(K):
if T[i]==T[-i-1]:
pass
else:
return False
return True
if iskaibun(S) and iskaibun(S[:M]) and iskaibun(S[M+1:]):
print("Yes")
else:
print("No")
| s=list(input())
n=len(s)
if list(s[::-1])==list(s[:]) and list(s[(n-1)//2-1::-1])==list(s[:(n-1)//2]) and list(s[:(n+3)//2-2:-1])==list(s[(n+3)//2-1:]):
print("Yes")
else:
print("No") | 1 | 46,132,798,014,368 | null | 190 | 190 |
value = int(input())
print(value ** 3) | if __name__ == "__main__":
n = int(raw_input())
print n * n * n | 1 | 280,834,189,020 | null | 35 | 35 |
n,k = map(int,input().split())
a = abs(n-k*(n//k))
b = abs(n-k*(-(-n//k)))
print(min(a,b)) | from math import gcd
N,K=map(int,input().split())
mod=10**9+7
A=[0]*K
for i in range(K,0,-1):
a=K//i
b=pow(a,N,mod)
A[i-1]=b
for i in range(K,0,-1):
for j in range(K//i-1):
c=i*(j+2)
A[i-1]-=A[c-1]
A[i-1]%=mod
s=0
for i in range(K):
s+=A[i]*(i+1)
s%=mod
print(s)
| 0 | null | 37,796,275,109,468 | 180 | 176 |
N = int(input())
D = list(map(int, input().split(" ")))
mod = 998244353
count = [0 for i in range(N)]
for i in range(N):
count[D[i]] += 1
max_dist = max(D)
ans = count[0]
for i in range(1, max_dist + 1):
ans *= (count[i - 1] ** count[i]) % mod
ans %= mod
if count[0] > 1 or D[0] != 0:
ans = 0
print(ans % 998244353) | mod = 998244353
n = int(input())
d = list(map(int,input().split()))
if d[0]!=0 or d[1:].count(0)!=0:
print(0)
exit()
l = [0 for i in range(n)]
for i in d:
l[i] += 1
cou = 1
if 0 in l:
a = l.index(0)
if sum(l[a:])!=0:
print(0)
exit()
for i in range(n-2):
if l[i+1]!=0:
a = l[i]
b = l[i+1]
cou *= (a**b)%mod
print(cou%mod) | 1 | 155,102,613,725,950 | null | 284 | 284 |
A,B,M = [int(hoge) for hoge in input().split()]
A = [int(hoge) for hoge in input().split()]
B = [int(hoge) for hoge in input().split()]
ans = min(A) + min(B)
for i in range(M):
x,y,c = [int(hoge) for hoge in input().split()]
ans = min(ans,A[x-1]+B[y-1]-c)
print(ans) | import string
N = int(input())
alph = string.ascii_lowercase
ans = []
A = [0]
def search():
if len(A) == N:
ans.append(tuple(A))
return
mx = max(A)
for i in range(mx + 2):
A.append(i)
search()
A.pop()
return
search()
for a in ans:
print(''.join(alph[i] for i in a))
| 0 | null | 53,261,192,494,546 | 200 | 198 |
r=input();p=3.141592653589793;print "%.9f"%(p*r*r),r*2*p | n = int(input())
a = list(map(int, input().split()))
print(len(list(filter(lambda x: x % 2 == 1, a[::2]))))
| 0 | null | 4,173,941,767,960 | 46 | 105 |
a, b = map(int, input().replace(".","").split())
print(a*b//100) | import decimal
a,b=map(str,input().split())
RES = decimal.Decimal(a)*decimal.Decimal(b)
res = int(RES)
print(res) | 1 | 16,571,104,762,830 | null | 135 | 135 |
A, B = map(int, input().split())
ans = A*B
if A > 9 or B > 9:
ans = -1
print(ans) | a,b=map(int,input().split(' '))
count=0
if (a<=9 and a>=1) and (b<=9 and b>=1) :
print(a*b)
else:
print("-1")
| 1 | 157,526,581,294,572 | null | 286 | 286 |
N, K = map(int, input().split())
p = list(map(int, input().split()))
s = sum(p[:K])
ss = []
ss.append(s)
for i in range(N - K):
s = s - p[i] + p[i+K]
ss.append(s)
print(K + (max(ss) - K) / 2) | N, K = map(int, input().split())
expectation = list(map(lambda x: (x+1) / 2, map(int, input().split())))
cur_expectation = sum(expectation[:K])
max_expectation = cur_expectation
for i in range(N - K):
cur_expectation -= expectation[i]
cur_expectation += expectation[i + K]
if cur_expectation > max_expectation:
max_expectation = cur_expectation
print(max_expectation)
| 1 | 74,864,649,145,416 | null | 223 | 223 |
import sys
sys.setrecursionlimit(10 ** 9)
N, M = map(int, input().split())
root = [-1] * N
def r(x):
if root[x] < 0:
return x
else:
root[x] = r(root[x])
return root[x]
def unite(x, y):
x = r(x)
y = r(y)
if x == y:
return
root[x] += root[y]
root[y] = x
def size(x):
return -r(x)
for i in range(M):
a, b = map(int, input().split())
a -= 1
b -= 1
unite(a, b)
max_size = -min(root)
print(max_size)
| import sys
import itertools
sys.setrecursionlimit(1000000000)
from heapq import heapify,heappop,heappush,heappushpop
import math
import collections
import copy
INF = 10**9
"""
UnionFind
要素を素集合(互いに素)に分割して管理するデータ構造
O(α)<O(log)
逆アッカーマン関数
"""
class UnionFind():
def __init__(self,n):
self.n = n
self.parents = [-1]*n #各要素の親要素の番号を格納するリスト
#要素xが属するグループの根を返す
def find(self,x):
if self.parents[x]<0:
return x
else:
self.parents[x] = self.find(self.parents[x])
return self.parents[x]
#要素xと要素yが属するグループを併合する
def union(self,x,y):
x = self.find(x)
y = self.find(y)
if x == y:
return
if self.parents[x]>self.parents[y]:
x,y = y,x
self.parents[x] += self.parents[y]
self.parents[y] = x
#要素xが属するグループのサイズを返す
def size(self,x):
return -self.parents[self.find(x)]
#要素x,yが同じグループかどうかを返す
def same(self,x,y):
return self.find(x) == self.find(y)
#要素xと同じグループのメンバーを返す
def members(self,x):
root = self.find(x)
return [i for i in range(self.n) if self.find(i) == root]
#すべての根の要素を返す
def roots(self):
return [i for i,x in enumerate(self.parents) if x<0]
#グループの数を返す
def group_count(self):
return len(self.roots())
def all_group_members(self):
return {r: self.members(r) for r in self.roots()}
def __str__(self):
return "\n".join("{}: {}".format(r,self.members(r)) for r in self.roots())
if __name__ == "__main__":
n,m = map(int,input().split())
uf = UnionFind(n)
for i in range(m):
a,b = map(int,input().split())
a-=1
b-=1
uf.union(a,b)
ans = 0
for i in range(n):
c = uf.size(i)
ans = max(ans,c)
print(ans) | 1 | 3,985,097,053,710 | null | 84 | 84 |
#設定
import sys
input = sys.stdin.buffer.readline
#ライブラリインポート
from collections import defaultdict
con = 10 ** 9 + 7
#入力受け取り
def getlist():
return list(map(int, input().split()))
class Combination(object):
def __init__(self, N, con):
self.fac = [0] * (N + 1)
self.inv = [0] * (N + 1)
self.finv = [0] * (N + 1)
self.fac[0], self.fac[1] = 1, 1
self.inv[1] = 1
self.finv[0], self.finv[1] = 1, 1
# 前計算
for i in range(2, N + 1):
self.fac[i] = self.fac[i - 1] * i % con
self.inv[i] = self.inv[con % i] * (con - (con // i)) % con
self.finv[i] = self.finv[i - 1] * self.inv[i] % con
def com(self, N, k):
return (self.fac[N] * self.finv[k] * self.finv[N - k]) % con
#処理内容
def main():
N, K = getlist()
if K >= N:
Com = Combination(2 * N - 1, con)
ans = Com.com(2 * N - 1, N)
print(ans)
else:
Com1 = Combination(N, con)
Com2 = Combination(N - 1, con)
ans = 0
for i in range(1, K + 1):
ans += Com1.com(N, i) * Com2.com(N - 1, i)
ans %= con
ans = (ans + 1) % con
print(ans)
if __name__ == '__main__':
main() | import heapq
import sys
input = sys.stdin.readline
def dijkstra_heap(s,edge,n):
#始点sから各頂点への最短距離
d = [10**20] * n
used = [True] * n #True:未確定
d[s] = 0
used[s] = False
edgelist = []
for a,b in edge[s]:
heapq.heappush(edgelist,a*(10**6)+b)
while len(edgelist):
minedge = heapq.heappop(edgelist)
#まだ使われてない頂点の中から最小の距離のものを探す
if not used[minedge%(10**6)]:
continue
v = minedge%(10**6)
d[v] = minedge//(10**6)
used[v] = False
for e in edge[v]:
if used[e[1]]:
heapq.heappush(edgelist,(e[0]+d[v])*(10**6)+e[1])
return d
def main():
N, u, v = map(int, input().split())
u -= 1
v -= 1
edge = [[] for i in range(N)]
for _ in range(N-1):
A, B = map(int, input().split())
A -= 1
B -= 1
edge[A].append([1,B])
edge[B].append([1,A])
d1 = dijkstra_heap(u,edge, N)
d2 = dijkstra_heap(v,edge, N)
ans = 0
for i in range(N):
if d1[i] < d2[i]:
ans = max(ans, d2[i]-1)
print(ans)
if __name__ == "__main__":
main() | 0 | null | 92,157,170,897,090 | 215 | 259 |
from collections import deque
n=int(input())
g=[[] for _ in range(n+1)]
e=[]
for i in range(n-1):
a,b=map(int,input().split())
g[a-1].append(b-1)
e.append(b-1)
q=deque([0])
color=[0 for _ in range(n)]
while(len(q)>0):
ei=q.popleft()
c=1
for x in g[ei]:
if c == color[ei]:
c+=1
color[x]=c
c+=1
q.append(x)
print(max(color))
for i in e:
print(color[i]) | from collections import deque, defaultdict
N = int(input())
ab = [list(map(int, input().split())) for _ in range(N - 1)]
d = [0] * (N + 1)
G = [[] for _ in range(N + 1)]
for a, b in ab:
d[a] += 1
d[b] += 1
G[a].append(b)
G[b].append(a)
print(max(d))
color = defaultdict(int)
q = deque([[1, 0]])
seen = [0] * (N + 1)
while q:
v, c = q.popleft()
seen[v] = 1
tem = 1
for u in G[v]:
if seen[u]:
continue
if tem == c:
tem += 1
q.append([u, tem])
i, j = min(v, u), max(v, u)
color[(i, j)] = tem
tem += 1
for a, b in ab:
i, j = min(a, b), max(a, b)
print(color[(i, j)])
| 1 | 136,084,571,092,900 | null | 272 | 272 |
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)
| n = int(input())
a = 0
l = list(map(int, input().split()))
for i in range(n):
if i % 2 == 0:
if l[i] % 2 != 0:
a = a + 1
print(a) | 1 | 7,801,443,449,732 | null | 105 | 105 |
# ()の問題は折れ線で捉えると良い
N = int(input())
ls = [] # 増減が正のもの(0を含む)
rs = [] # 増減が負のもの
tot = 0
for i in range(N):
s = input()
h = 0
b = 0
for c in s:
if c == "(":
h += 1
else:
h -= 1
b = min(b, h)
if h >= 0:
# 折れ線に対して上っていく奴ら
ls.append([b, h])
else:
# 折れ線に対して下っていく奴ら
# 右から(hから見るので、最下点は-hする)
rs.append([b-h, -h])
tot += h
ls.sort(key = lambda x:x[0], reverse=True)
rs.sort(key = lambda x:x[0], reverse=True)
def check(s):
h = 0
for p in s:
if h+p[0] < 0:
return False
h += p[1]
return True
if check(ls) and check(rs) and tot == 0:
print("Yes")
else:
print("No") | import sys
input = sys.stdin.readline
def main():
N = int( input())
S = [input().strip() for _ in range(N)]
Up = []
Down = []
for s in S:
now = 0
m = 0
for t in s:
if t == "(":
now += 1
else:
now -= 1
if now < m:
m = now
# print(t, now)
if now >= 0:
Up.append((m,now))
else:
Down.append((m-now,-now))
up = 0
Up.sort(reverse=True)
for m, inc in Up:
if up+m < 0:
print("No")
return
up += inc
down = 0
Down.sort(reverse=True)
# print(Up, Down)
for m, dec in Down:
if down+m < 0:
print("No")
return
down += dec
if up != down:
print("No")
return
print("Yes")
if __name__ == '__main__':
main()
| 1 | 23,754,716,132,608 | null | 152 | 152 |
# coding: utf-8
# Your code here!
n=int(input())
flag=0
for i in range(1,10):
if n%i==0:
if 10>n/i:
flag=1
if flag:
print('Yes')
else:
print('No') | N = int(input())
D = list(map(int, input().split(" ")))
mod = 998244353
count = [0 for i in range(N)]
for i in range(N):
count[D[i]] += 1
max_dist = max(D)
ans = count[0]
for i in range(1, max_dist + 1):
ans *= (count[i - 1] ** count[i]) % mod
ans %= mod
if count[0] > 1 or D[0] != 0:
ans = 0
print(ans % 998244353) | 0 | null | 157,239,475,918,530 | 287 | 284 |
# -*- coding: utf-8 -*-
k, n = map(int, input().split())
a = list(map(int, input().split()))
fst = a[0]
a.append(k+fst)
dis= []
for i in range(n):
dis.append(a[i+1]-a[i])
print(sum(dis)-max(dis)) | K,N = map(int,input().split())
cc = list(map(int,input().split()))
min_length = max(cc)-min(cc)
for i in range(1,N):
Length = K-cc[i]+cc[i-1]
min_length = min(min_length,Length)
print(min_length) | 1 | 43,666,921,895,832 | null | 186 | 186 |
A, B = input().split()
B = B.replace('.', '')
A, B = list(map(int, [A, B]))
ans_b = A*B
print(int(ans_b//100))
| x = int(input())
def f():
for i in range(x, 10**10):
c = 0
for j in range(2, i):
if i%j != 0:
c += 1
if c == i-2:
return i
else:
break
if x == 2:
print(2)
else:
print(f()) | 0 | null | 61,167,353,763,270 | 135 | 250 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.