code1
stringlengths 16
427k
| code2
stringlengths 16
427k
| similar
int64 0
1
| pair_id
int64 2
178,025B
⌀ | question_pair_id
float64 27.1M
177,113B
⌀ | code1_group
int64 1
297
| code2_group
int64 1
297
|
|---|---|---|---|---|---|---|
N,M=list(map(int, input().split()))
if N==M:
print('Yes')
else:
print('No')
|
def main():
N, M = map(int, input().split())
if N == M:
print("Yes")
exit(0)
print("No")
if __name__ == "__main__":
main()
| 1 | 83,470,149,540,580 | null | 231 | 231 |
x = int(input())
j = 0
for i in range(360):
j += x
j %= 360
if j == 0:
print(i+1)
exit()
|
from math import factorial
n,m=map(int,input().split())
ans=0
if n>1:
ans+=factorial(n)//2//factorial(n-2)
if m>1:
ans+=factorial(m)//2//factorial(m-2)
print(ans)
| 0 | null | 29,484,301,474,220 | 125 | 189 |
mod = 10**9 + 7
X, Y = map(int, input().split())
if (X+Y) % 3 != 0:
print(0)
exit()
a = (2*Y-X)//3
b = (2*X-Y)//3
if a < 0 or b < 0:
print(0)
exit()
m = min(a, b)
ifact = 1
for i in range(2, m+1):
ifact = (ifact * i) % mod
ifact = pow(ifact, mod-2, mod)
fact = 1
for i in range(a+b, a+b-m, -1):
fact = (fact * i) % mod
print(fact*ifact % mod)
|
import sys
from sys import exit
from collections import deque
from bisect import bisect_left, bisect_right, insort_left, insort_right
from heapq import heapify, heappop, heappush
from itertools import product, permutations, combinations, combinations_with_replacement
from functools import reduce
from math import gcd, sin, cos, tan, asin, acos, atan, degrees, radians
sys.setrecursionlimit(10**6)
INF = 10**20
eps = 1.0e-20
MOD = 10**9+7
def lcm(x,y):
return x*y//gcd(x,y)
def lgcd(l):
return reduce(gcd,l)
def llcm(l):
return reduce(lcm,l)
def powmod(n,i,mod):
return pow(n,mod-1+i,mod) if i<0 else pow(n,i,mod)
def div2(x):
return x.bit_length()
def div10(x):
return len(str(x))-(x==0)
def intput():
return int(input())
def mint():
return map(int,input().split())
def lint():
return list(map(int,input().split()))
def ilint():
return int(input()), list(map(int,input().split()))
def judge(x, l=['Yes', 'No']):
print(l[0] if x else l[1])
def lprint(l, sep='\n'):
for x in l:
print(x, end=sep)
def ston(c, c0='a'):
return ord(c)-ord(c0)
def ntos(x, c0='a'):
return chr(x+ord(c0))
class counter(dict):
def __init__(self, *args):
super().__init__(args)
def add(self,x,d=1):
self.setdefault(x,0)
self[x] += d
def list(self):
l = []
for k in self:
l.extend([k]*self[k])
return l
class comb():
def __init__(self, n, mod=None):
self.l = [1]
self.n = n
self.mod = mod
def get(self,k):
l,n,mod = self.l, self.n, self.mod
k = n-k if k>n//2 else k
while len(l)<=k:
i = len(l)
l.append(l[i-1]*(n+1-i)//i if mod==None else (l[i-1]*(n+1-i)*powmod(i,-1,mod))%mod)
return l[k]
def pf(x):
C = counter()
p = 2
while x>1:
k = 0
while x%p==0:
x //= p
k += 1
if k>0:
C.add(p,k)
p = p+2-(p==2) if p*p<x else x
return C
X,Y=mint()
if (X+Y)%3!=0:
print(0)
exit()
k=abs(X-Y)
N=min(X,Y)-k
if N<0:
print(0)
exit()
n=2*(N//3)+k
C=comb(n,MOD)
print(C.get(N//3))
| 1 | 150,479,273,316,422 | null | 281 | 281 |
#!/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 = int(input())
C = input()
left = 0
right = N-1
count = 0
while left < right:
if C[left] == 'W' and C[right] == 'R':
count += 1
left += 1
right -= 1
if C[left] == 'R':
left += 1
if C[right] == 'W':
right -= 1
print(count)
|
import sys
sys.setrecursionlimit(10**7)
def input(): return sys.stdin.readline()[:-1]
mod = 10**9 + 7
def readInt():return int(input())
def readIntList():return list(map(int,input().split()))
def readStringList():return list(input())
def readStringListWithSpace():return list(input().split())
def readString():return input()
n = readInt()
text = readStringList()
import collections
c = collections.Counter(text)
if c['W'] == 0:
print("0")
exit()
i,j,count = 0,len(text)-1,0
while i <= j and i < len(text):
if text[i] == 'W':
while text[j] != 'R' and j > 0:
j -= 1
if i <= j and j > 0:
text[i],text[j] = text[j],text[i]
count += 1
i += 1
print(count)
| 1 | 6,262,846,477,580 | null | 98 | 98 |
n = list(map(int,list(input())))
if 7 in n:
print("Yes")
else:
print("No")
|
N=input()
i=0
while 1:
for a in N:
if a=="7":
print("Yes")
i=1
break
if i==1:
break
print("No")
break
| 1 | 34,497,103,898,400 | null | 172 | 172 |
N=str(input())
if '7' in N:
print("Yes")
else:
print("No")
|
n=list(map(int,input()))
if 7 in n:
print("Yes")
else:
print("No")
| 1 | 34,436,992,078,830 | null | 172 | 172 |
D = int(input())
c = [*map(int, input().split())]
s = [0] + [[*map(int, input().split())] for _ in range(D)]
t = [0] + [int(input()) for _ in range(D)]
v = 0
last = [0] * 26
for d in range(1, D+1):
select = t[d] - 1
v += s[d][select]
last[select] = d
v -= sum(c[i] * (d - last[i]) for i in range(26))
print(v)
|
d=int(input())
a=[0 for i in range(26)]
c=list(map(int,input().split()))
l=[]
for i in range(d):
l.append(list(map(int,input().split())))
#print(c.index(max(c))+1)
p=[0]
for i in range(1,d+1):
t=int(input())-1
a[t]=i
k=0
for j in range(26):
k+=c[j]*(i-a[j])
p.append(p[i-1]+l[i-1][t]-k)
print(*p[1:],sep='\n')
| 1 | 9,951,446,792,672 | null | 114 | 114 |
n=int(input())
p=list(map(int,input().split()))
ans=0
min_=p[0]
for pp in p:
min_=min(min_,pp)
if min_ ==pp:
ans+=1
print(ans)
|
n , m = (int(a) for a in input().split())
if n == m :
print("Yes")
else : print("No")
| 0 | null | 84,478,052,046,870 | 233 | 231 |
n = int(input())
x, y = divmod(n, 2)
print(x + y)
|
# String Palindrome
def is_palindrome(s):
res = s == s[::-1]
return res
S = input()
N = len(S)
ans = ['No', 'Yes'][is_palindrome(S) & is_palindrome(S[:((N-1)//2)]) & is_palindrome(S[((N+1)//2):])]
print(ans)
| 0 | null | 52,487,510,319,840 | 206 | 190 |
n,a,b = map(int,input().split())
if (a%2 + b%2) %2 == 0:
print(abs(a-b) // 2)
elif n - b < a - 1:
p = n-b+1
a += n-b
b = n
print(abs(a-b) // 2 + p)
else:
p = a
b -= a-1
a = 1
print(abs(a-b) // 2 + p)
|
n, a, b = map(int, input().split())
ans = 0
if (b - a) % 2 == 0:
ans = (b - a) // 2
else:
# ans += (b - a) // 2
# a += ans
# b -= ans
# ans += min(n - a, b - 1)
if a - 1 <= n - b:
ans += a
b -= a
a = 1
else:
ans += n - b + 1
a += n - b + 1
b = n
ans += (b - a) // 2
print(ans)
| 1 | 109,289,816,082,260 | null | 253 | 253 |
import sys, bisect, math, itertools, string, queue, copy
import numpy as np
import scipy
from collections import Counter,defaultdict,deque
from itertools import permutations, combinations
from heapq import heappop, heappush
# input = sys.stdin.readline
sys.setrecursionlimit(10**8)
mod = 10**9+7
def inp(): return int(input())
def inpm(): return map(int,input().split())
def inpl(): return list(map(int, input().split()))
def inpls(): return list(input().split())
def inplm(n): return list(int(input()) for _ in range(n))
def inplL(n): return [list(input()) for _ in range(n)]
def inplT(n): return [tuple(input()) for _ in range(n)]
def inpll(n): return [list(map(int, input().split())) for _ in range(n)]
def inplls(n): return sorted([list(map(int, input().split())) for _ in range(n)])
n = inp()
ans = 0
if n % 2 == 1:
ans = 0
else:
div = 10
while div <= n:
ans += n // div
div *= 5
print(ans)
|
n = int(input())
ans = 0
if n % 2 == 0:
for i in range(1, 36):
k = 5**i*2
ans += n//k
print(ans)
else:
print(ans)
| 1 | 115,853,844,039,780 | null | 258 | 258 |
# -*- coding: utf-8 -*-
"""
A - Can't Wait for Holiday
https://atcoder.jp/contests/abc146/tasks/abc146_a
"""
import sys
def solve(S):
return {'SUN': 7, 'MON': 6, 'TUE': 5, 'WED': 4, 'THU': 3, 'FRI': 2, 'SAT': 1}[S]
def main(args):
S = input()
ans = solve(S)
print(ans)
if __name__ == '__main__':
main(sys.argv[1:])
|
s = input()
if s == "SUN":
print(7)
if s == "MON":
print(6)
if s == "TUE":
print(5)
if s == "WED":
print(4)
if s == "THU":
print(3)
if s == "FRI":
print(2)
if s == "SAT":
print(1)
| 1 | 133,092,381,743,308 | null | 270 | 270 |
S = input()
mod2019 = [0]*len(S)
mod2019[-1] = int(S[-1])
keta_mod = 1
for i in range(len(S)-2,-1,-1):
keta_mod = (keta_mod*10)%2019
mod2019[i] = (mod2019[i+1] + int(S[i])*keta_mod)%2019
mod2019.extend([0])
answer = 0
count = [0 for _ in range(2020)]
for i in range(len(S)+1):
answer += count[mod2019[i]]
count[mod2019[i]] += 1
print(answer)
|
s = list(map(int,input()))
s.reverse()
t = len(s)
mod = 2019
arr = [0] * (t+1)
arr[-2] = s[0]
for i in range(1,t):
arr[t-i-1] = (arr[t-i] + s[i]*pow(10,i,mod)) % mod
from collections import Counter
arr = Counter(arr)
ans = 0
for i in arr:
ans += (arr[i] - 1) * arr[i] // 2
print(ans)
| 1 | 30,800,340,228,542 | null | 166 | 166 |
#!/usr/bin/env python3
from collections import Counter
def solve(N: int, A: "List[int]", Q: int, BC: "List[(int,int)]"):
A = Counter(A)
answers = []
ans = ans = sum((i * n for i, n in A.items()))
for b, c in BC:
if b != c:
ans += (c - b) * A[b]
A[c] += A[b]
del A[b]
answers.append(ans)
return answers
def main():
N = int(input()) # type: int
A = list(map(int, input().split()))
Q = int(input())
BC = [tuple(map(int, input().split())) for _ in range(Q)]
answer = solve(N, A, Q, BC)
for ans in answer:
print(ans)
if __name__ == "__main__":
main()
|
# -*- coding: utf-8 -*-
"""
Created on Mon Sep 7 17:36:58 2020
@author: liang
"""
"""
全探索
"""
N, M = map(int, input().split())
test = list()
for _ in range(M):
s,c = map(int,input().split())
test.append((s,c))
#print(test)
tmp = [0]*3
for i in range(10**N):
tmp[0] = i//100
tmp[1] = i//10%10
tmp[2] = i%10
#print(tmp)
for tup in test:
s, c = tup[0], tup[1]
if tmp[(3-N)+s-1] != c:
break
else:
#最上位の桁が0でないか
if tmp[-N] == 0 and N != 1:
continue
print(i)
break
else:
print(-1)
| 0 | null | 36,380,779,187,772 | 122 | 208 |
import string as st
string=[]
try:
while True:
s = input()#入力
string =list(string)#list変換
if not s :#空入力のときループぬける
break
string.extend(s)#list追加
string=map(str,string)
string="".join(string).lower()#str型変換と小文字
except EOFError:
for i in range(len(st.ascii_lowercase)):
print("{} : {}".format(st.ascii_lowercase[i],string.count(st.ascii_lowercase[i])))
|
def resolve():
'''
code here
'''
H, W = [int(item) for item in input().split()]
if H == 1 or W == 1:
res = 1
elif H % 2 == 1 and W % 2 == 1:
res = H * W // 2 +1
else:
res = H * W // 2
print(res)
if __name__ == "__main__":
resolve()
| 0 | null | 26,407,878,561,260 | 63 | 196 |
from math import gcd
k = int(input())
ans = 0
for i in range(1,k+1):
for j in range(1,k+1):
v = gcd(i,j)
for m in range(1,k+1):
ans += gcd(v,m)
print(ans)
|
from math import gcd
n = int(input())
ans = 0
for i in range(1,n+1):
for j in range(1,n+1):
x = gcd(i,j)
for k in range(1,n+1):
ans += gcd(x,k)
print(ans)
| 1 | 35,647,197,104,060 | null | 174 | 174 |
N = int(input())
As = list(map(int,input().split()))
Q = int(input())
count_array = [0]*(10**5+1)
for i in range(N):
count_array[As[i]] += 1
sum = 0
for i in range(len(As)):
sum += As[i]
for i in range(Q):
x,y = map(int,input().split())
sum += count_array[x]*(y-x)
print(sum)
count_array[y] += count_array[x]
count_array[x] = 0
|
import sys
input = sys.stdin.readline
N = int(input())
A = [int(i) for i in input().split()]
count = [0] * 10**5
for i in range(N):
count[A[i]-1] += 1
Q = int(input())
ans = sum(A)
for i in range(Q):
B, C = map(int, input().split())
ans += (C - B) * count[B-1]
print(ans)
count[C-1] += count[B-1]
count[B-1] = 0
| 1 | 12,144,003,602,390 | null | 122 | 122 |
import numpy as np
a, b, h, m = map(int, input().split())
def calc_rad(base, time):
try:
return 2 * np.pi * ((time) % base) / base
except ZeroDivisionError:
return 0
rad_a, rad_b = calc_rad(720, 60 * h + m), calc_rad(60, m)
ans = np.sqrt(a ** 2 + b ** 2 - 2 * a * b * np.cos(rad_a - rad_b))
print("{:.20f}".format(ans))
|
a, b, c = map(int, raw_input().split(' '))
num = 0
for i in range(a,b+1):
if c % i == 0:
num = num + 1
print(num)
| 0 | null | 10,358,964,896,760 | 144 | 44 |
n, k = map(int, input().split())
p_lst = list(map(int, input().split()))
p_lst = sorted(p_lst)
print(sum(p_lst[:k]))
|
A, B = map(int, input().split())
l = []
for i in range(1, 10000):
a = i * 0.08
b = i * 0.1
if a > A+1 and b > B+1:
break
elif A <= a < A+1 and B <= b < B+1:
l.append(i)
if len(l) == 0:
print(-1)
else:
print(min(l))
| 0 | null | 33,932,153,529,330 | 120 | 203 |
N, K = map(int, input().split())
MOD = 10**9+7
mx = [0]*(K+1)
ans = 0
for i in range(K, 0, -1):
mx[i] = pow(K//i, N, MOD)
for j in range(2*i, K+1, i):
mx[i] -= mx[j]
ans += i*mx[i]
print(ans%MOD)
|
N,K = list(map(int,input().split()))
MOD = 10**9+7
arr = [pow(K//i, N, MOD) for i in range(1,K+1)]
for i in range(K//2,0,-1):
arr[i-1] -= sum(arr[2*i-1:K:i]) % MOD
arr[i-1] %= MOD
arr = [(i+1)*j%MOD for i,j in enumerate(arr)]
print(sum(arr)%MOD)
| 1 | 36,885,623,484,028 | null | 176 | 176 |
#写経
#https://atcoder.jp/contests/abc171/submissions/14574647
from functools import reduce
def comb(n, max_k, mod):
"""
(n,k) := n個からk個選ぶ組み合わせ
k = 0~max_Kまでを計算して返す
"""
res = [1]*(max_k+1)
t = 1
for i in range(max_k+1):
res[i] *= t
t *= n-i
t %= mod
n = reduce(lambda x,y: (x*y)%mod, range(1,max_k+1), 1)
n = pow(n,-1, mod)
for i in reversed(range(max_k+1)):
res[i] *= n
res[i] %= mod
n *= i
n %= mod
return res
MOD = 10**9+7
def resolve():
K = int(input())
N = len(input())
res = 0
x = 1
com = comb(N+K, K , MOD)
for c in com:
res += x*c
res %= MOD
x *= 25
x %= MOD
print(res)
resolve()
|
k=int(input())
s,m,c,a=input(),10**9+7,1,1
for i in range(k):c*=25*(k+len(s)-i)*pow(i+1,m-2,m)%m;c%=m;a+=c
print(a%m)
| 1 | 12,708,484,783,092 | null | 124 | 124 |
string1 = input()
string2 = input()
n, m = len(string1), len(string2)
best = float("inf")
for i in range(n - m + 1):
current = string1[i:i+m]
differences = 0
for i in range(m):
if current[i] != string2[i]:
differences += 1
best = min(differences, best)
if best == float("inf"):
print(0)
else:
print(best)
|
#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,permutations,accumulate # (string,3) 3回
#from collections import deque
from collections import deque,defaultdict,Counter
import decimal
import re
#import bisect
#
# d = m - k[i] - k[j]
# if kk[bisect.bisect_right(kk,d) - 1] == d:
#
#
#
# pythonで無理なときは、pypyでやると正解するかも！！
#
#
# my_round_int = lambda x:np.round((x*2 + 1)//2)
# 四捨五入
import sys
sys.setrecursionlimit(10000000)
mod = 10**9 + 7
#mod = 9982443453
def readInts():
return list(map(int,input().split()))
def I():
return int(input())
NUM = [0] * 500000
for x in range(1,101):
for y in range(1,101):
for z in range(1,101):
nya = x**2 + y**2 + z**2 + x*y + y*z + z*x
NUM[nya] += 1
n = I()
for i in range(1,n+1):
print(NUM[i])
| 0 | null | 5,789,082,553,728 | 82 | 106 |
def read_int():
return int(input().strip())
def read_ints():
return list(map(int, input().strip().split(' ')))
def solve():
N = read_int()
D = read_ints()
S = sum(D)
answer = 0
for d in D:
S -= d
answer += d*S
return answer
if __name__ == '__main__':
print(solve())
|
# -*- coding:utf-8 -*-
def reac(H,W):
for i in range(H):
for l in range(W):
print('#',end='')
print('')
data = []
while True:
try:
di = input()
if di == '0 0':
break
data.append(di)
except:
break
for i in range(len(data)):
x = data[i]
h = x.split()
reac(int(h[0]),int(h[1]))
print('')
| 0 | null | 84,503,640,377,952 | 292 | 49 |
n,k=map(int,input().split())
a=list(map(int,input().split()))
cnt=0
for i in range(n-k):
if a[cnt]<a[cnt+k]:
print("Yes")
else:
print("No")
cnt+=1
|
H,W,*L = open(0).read().split()
H,W = map(int, (H,W))
dp = [[0]*W for i in range(H)]
for i in range(1,H):
if L[i][0]!=L[i-1][0]:
dp[i][0] = dp[i-1][0]+1
else:
dp[i][0] = dp[i-1][0]
for j in range(1,W):
if L[0][j]!=L[0][j-1]:
dp[0][j] = dp[0][j-1]+1
else:
dp[0][j] = dp[0][j-1]
for i in range(1,H):
for j in range(1,W):
if L[i][j]!=L[i-1][j] and L[i][j]!=L[i][j-1]:
dp[i][j] = min(dp[i-1][j],dp[i][j-1])+1
elif L[i][j]!=L[i-1][j]:
dp[i][j] = min(dp[i-1][j]+1,dp[i][j-1])
elif L[i][j]!=L[i][j-1]:
dp[i][j] = min(dp[i-1][j],dp[i][j-1]+1)
else:
dp[i][j] = min(dp[i-1][j],dp[i][j-1])
if L[0][0]=='.':
ans = (dp[H-1][W-1]+1)//2
else:
ans = (dp[H-1][W-1]+2)//2
print(ans)
| 0 | null | 28,142,809,876,960 | 102 | 194 |
a, b = input().split()
a = int(a)
b1, b2 = b.split('.')
b = int(b1 + b2)
print(a * b // 100)
|
from decimal import *
a,b = map(str,input().split())
a,b = Decimal(a),Decimal(b)
ans = a*b
print(int(ans))
| 1 | 16,584,466,257,352 | null | 135 | 135 |
N = int(input())
S = list(input())
r = S.count('R')
g = S.count('G')
b = S.count('B')
cnt = 0
for i in range(N-3):
if S[i] == 'R':
r -= 1
cnt += g * b
l = 1
while (i + 2 * l < N):
if (S[i+l] == 'G' and S[i+2*l] == 'B') or (S[i+l] == 'B' and S[i+2*l] == 'G'):
cnt -= 1
l += 1
if S[i] == 'G':
g -= 1
cnt += r * b
l = 1
while (i + 2 * l < N):
if (S[i+l] == 'R' and S[i+2*l] == 'B') or (S[i+l] == 'B' and S[i+2*l] == 'R'):
cnt -= 1
l += 1
if S[i] == 'B':
b -= 1
cnt += g * r
l = 1
while (i + 2 * l < N):
if (S[i+l] == 'G' and S[i+2*l] == 'R') or (S[i+l] == 'R' and S[i+2*l] == 'G'):
cnt -= 1
l += 1
print(cnt)
|
from collections import Counter
N=int(input())
S=input()
c=Counter(S+'RGB')
ans = (c['R']-1)*(c['G']-1)*(c['B']-1)
max_d = (N-3)//2+1
for d in range(1,max_d+1):
for i in range(N-2):
j = i+d
k = j+d
if k > N-1:break
if len(set([S[i],S[j],S[k]]))==3:
ans -= 1
print(ans)
| 1 | 36,060,274,554,752 | null | 175 | 175 |
days = ["SUN", 'MON', 'TUE', 'WED', 'THU', 'FRI', 'SAT']
days.reverse()
d = input()
print(days.index(d)+1)
|
# 入力
S = input('')
# 比較して出力
if S == str('SUN'):
print(7)
elif S == str('MON'):
print(6)
elif S == str('TUE'):
print(5)
elif S == str('WED'):
print(4)
elif S == str('THU'):
print(3)
elif S == str('FRI'):
print(2)
else:
print(1)
| 1 | 133,377,796,521,870 | null | 270 | 270 |
import sys, math
from collections import defaultdict, deque, Counter
from bisect import bisect_left, bisect_right
from itertools import combinations, permutations, product
from heapq import heappush, heappop
from functools import lru_cache
input = sys.stdin.readline
rs = lambda: input().strip()
ri = lambda: int(input())
rl = lambda: list(map(int, input().split()))
mat = lambda x, y, v: [[v]*y for _ in range(x)]
ten = lambda x, y, z, v: [mat(y, z, v) for _ in range(x)]
mod = 1000000007
sys.setrecursionlimit(1000000)
mod = 998244353
N, K = rl()
lr = []
for i in range(K):
l, r = rl()
lr.append((l,r))
lr.sort()
dp = [0] * (N+1)
dp[1] = 1
dp[2] = -1
ans = 0
s = 0
flags = [1] * K
for i in range(1, N+1):
s += dp[i]
s %= mod
for k in range(K):
if flags[k] == 0:
break
l, r = lr[k]
if i+l <= N:
dp[i+l] += s
if i+r+1 <= N:
dp[i+r+1] -= s
else:
ans += s
ans %= mod
break
else:
flags[k] = 0
break
print(ans)
|
mod = 998244353
n,k =map(int,input().split())
step =[0]*(n+1)
# step[0]=1
step[1]=1
stepsum=[0]*(n+1)
stepsum[1]=1
l=[0]*k
r=[0]*k
for i in range(k):
l[i],r[i]=map(int,input().split())
for i in range(2,n+1):
for j in range(k):
li = i - r[j]
ri = i - l[j]
if ri <= 0:
continue
# li = max(1,li)
step[i] += stepsum[ri] - stepsum[max(0,li-1)]
# step[i] %= mod
# print(step)
stepsum[i] = ( stepsum[i-1] + step[i] )%mod
print(step[n]%mod)
| 1 | 2,676,239,671,688 | null | 74 | 74 |
N = input()
check = False
for i in range(3):
if N[i] == "7":
check = True
print("Yes" if check else "No")
|
def main():
L, R, d = map(int, input().split())
ans = R//d - (L-1)//d
print(ans)
if __name__ == "__main__":
main()
| 0 | null | 20,792,975,859,172 | 172 | 104 |
import math
a, b = map(int, input().split())
for i in range(1251):
tax8 = math.floor(i * 0.08)
tax10 = math.floor(i * 0.1)
if (tax8, tax10) == (a, b):
print(i)
break
else:
print(-1)
|
a,b = map(int,input().split())
q = list()
for i in range(1009):
if int(i*0.08) == a and int(i*0.1) == b:
q.append(i)
if len(q) == 0:
print(-1)
exit()
print(min(q))
| 1 | 56,761,996,391,078 | null | 203 | 203 |
def resolve():
L = int(input())
a = L/3
print(a**3)
resolve()
|
import math
import sys
from collections import Counter
readline = sys.stdin.readline
def main():
l = int(readline().rstrip())
print((l/3)**3)
if __name__ == '__main__':
main()
| 1 | 47,260,040,941,168 | null | 191 | 191 |
mod = 10**9 + 7
def iip(listed = False):
ret = [int(i) for i in input().split()]
if len(ret) == 1 and not listed:
return ret[0]
return ret
def inv(n, mod):
return power(n, mod-2)
def conbination(n, r, mod, test=False):
if n <=0:
return 0
if r == 0:
return 1
if r < 0:
return 0
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}")
return ret
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
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
N, K = iip()
A = iip(listed=True)
A.sort(reverse=True)
def main():
plus = 0
minus = 0
a1Ck1 = conbination(N, K-1, mod) % mod
for i, Ai in enumerate(A):
if N-i < K:
break
a1Ck1 *= (N-K-i+1)
a1Ck1 *= inv(N-i, mod)
a1Ck1 %= mod
plus += a1Ck1 * Ai
A.sort(reverse=False)
a1Ck1 = conbination(N, K-1, mod) % mod
for i, Ai in enumerate(A):
if N-i < K:
break
a1Ck1 *= (N-K-i+1)
a1Ck1 *= inv(N-i, mod)
a1Ck1 %= mod
minus += a1Ck1 * Ai
ans = plus-minus
ans %= mod
print(ans)
main()
|
class mod_comb_k():
def __init__(self, MAX_N = 10**6, mod = 10**9+7):
self.fact = [1]
self.fact_inv = [0] * (MAX_N + 4)
self.mod = mod
for i in range(MAX_N + 3):
self.fact.append(self.fact[-1] * (i + 1) % self.mod)
self.fact_inv[-1] = pow(self.fact[-1], self.mod - 2, self.mod)
for i in range(MAX_N + 2, -1, -1):
self.fact_inv[i] = self.fact_inv[i + 1] * (i + 1) % self.mod
def comb(self, n, k):
if n < k:return 0
else:return self.fact[n] * self.fact_inv[k] % self.mod * self.fact_inv[n - k] % self.mod
c=mod_comb_k()
n,k=map(int,input().split())
a=sorted(list(map(int,input().split())))
ans=0
mod=10**9+7
for i,j in enumerate(a,1):
ans-=j*c.comb(n-i,k-1)
ans%=mod
for i,j in enumerate(a[::-1],1):
ans+=j*c.comb(n-i,k-1)
ans%=mod
print(ans)
| 1 | 95,680,112,669,120 | null | 242 | 242 |
import sys
input = sys.stdin.buffer.readline
MOD = 10**9 + 7
N, K = map(int, input().split())
A = list(map(int, (input().split())))
pos, neg = [], []
for a in A:
if a<0:
neg.append(a) # 負
else:
pos.append(a) # 0以上
if pos:
if N==K: # 全て選択で負の数が奇数ならfalse（正にできない）
ok = (len(neg)%2 == 0)
else:
ok = True
else:
ok = (K%2 == 0) # すべて負で奇数ならfalse（正にできない）
ans = 1
if ok == False: # false（正にできない）場合、絶対値が小さいものからk個かける
A.sort(key=abs)
for i in range(K):
ans *= A[i]
ans %= MOD
else:
pos.sort() # 後ろから取っていくので正は昇順
neg.sort(reverse=True) # 後ろから取っていくので負は降順
if K%2:
ans *= pos.pop() # kが奇数個なら1個は正を選ぶ
p = [] # 2個ずつかけた数を格納
while len(pos)>=2:
p.append(pos.pop() * pos.pop())
while len(neg)>=2: # 負を2回かけるのでxは正
p.append(neg.pop() * neg.pop())
p.sort(reverse=True)
for i in range(K//2): # 降順にk//2個見ていく
ans *= p[i]
ans %= MOD
print(ans)
|
import sys
from collections import deque
read = sys.stdin.read
readline = sys.stdin.readline
readlines = sys.stdin.readlines
sys.setrecursionlimit(10 ** 9)
INF = 1 << 60
MOD = 1000000007
def main():
N, K, *A = map(int, read().split())
pos = [a for a in A if a >= 0]
neg = [a for a in A if a < 0]
pos.sort()
neg.sort(reverse=True)
if N == K:
vec = A
elif N == len(neg):
if K & 1:
vec = neg[:K]
else:
vec = neg[-K:]
else:
ans_pos = []
ans_neg = []
for _ in range(K):
if not pos:
ans_neg.append(neg.pop())
elif not neg:
ans_pos.append(pos.pop())
elif pos[-1] > -neg[-1]:
ans_pos.append(pos.pop())
else:
ans_neg.append(neg.pop())
if (len(ans_neg) & 1) and ((not ans_pos) or (ans_pos[-1] != 0)):
if not pos or not ans_neg:
drop_pos = True
elif not neg or not ans_pos:
drop_pos = False
else:
drop_pos = pos[-1] * ans_pos[-1] < neg[-1] * ans_neg[-1]
if drop_pos:
ans_neg.append(neg.pop())
ans_pos.pop()
else:
ans_pos.append(pos.pop())
ans_neg.pop()
vec = ans_pos + ans_neg
ans = 1
for a in vec:
ans = ans * a % MOD
print(ans)
return
if __name__ == '__main__':
main()
| 1 | 9,507,017,782,220 | null | 112 | 112 |
N=int(input())
if N==1:
print("a")
exit()
from collections import deque
from collections import Counter
abc="abcdefghijklmnopqrstuvwxyz"
ans=["a"]
for i in range(1,N):
d=deque(ans)
ans=[]
while d:
temp=d.popleft()
temp2=list(temp)
cnt=Counter(temp2)
L=len(cnt)
for j in range(L+1):
ans.append(temp+abc[j])
for a in ans:
print(a)
|
n=int(input())
def dfs(s):
if len(s)==n:print(s)
else:
for i in range(97,ord(max(s))+1+1):
dfs(s+chr(i))
dfs("a")
| 1 | 52,472,986,380,802 | null | 198 | 198 |
while True:
N,X = map(int,input().split())
if N == 0 and X == 0:
break
ans = 0
for a in range(1,N+1):
for b in range(1,N+1):
if b <= a:
continue
c = X-(a+b)
if c > b and c <= N:
ans += 1
print("%d"%(ans))
|
import sys
from scipy.sparse.csgraph import floyd_warshall
import numpy as np
def solve():
infinity = 10 ** 10
n, m, le = map(int, input().split())
paths = np.full((n, n), infinity)
for i in range(n):
paths[i, i] = 0
for _ in range(m):
a, b, c = map(int, input().split())
paths[a - 1, b - 1] = paths[b - 1, a - 1] = c
paths = floyd_warshall(paths)
paths = floyd_warshall(paths <= le)
paths[np.isinf(paths)] = 0
q = int(input())
answer = []
for _ in range(q):
s, t = map(int, input().split())
answer.append(int(paths[s - 1][t - 1] - 1))
print(*answer, sep='\n')
#print("\n".join(map(str, answer)))
if __name__ == "__main__":
solve()
| 0 | null | 87,202,929,463,836 | 58 | 295 |
# import itertools
# import math
# import sys
# sys.setrecursionlimit(500*500)
# import numpy as np
N = int(input())
S = input()
# n, *a = map(int, open(0))
# N, M = map(int, input().split())
# A = list(map(int, input().split()))
# B = list(map(int, input().split()))
# tree = [[] for _ in range(N + 1)]
# B_C = [list(map(int,input().split())) for _ in range(M)]
# S = input()
# B_C = sorted(B_C, reverse=True, key=lambda x:x[1])
# all_cases = list(itertools.permutations(P))
# a = list(itertools.combinations_with_replacement(range(1, M + 1), N))
# itertools.product((0,1), repeat=n)
# A = np.array(A)
# cum_A = np.cumsum(A)
# cum_A = np.insert(cum_A, 0, 0)
# def dfs(tree, s):
# for l in tree[s]:
# if depth[l[0]] == -1:
# depth[l[0]] = depth[s] + l[1]
# dfs(tree, l[0])
# dfs(tree, 1)
all = S.count("R") * S.count("G") * S.count("B")
cnt = 0
for i in range(N):
for j in range(i, N):
k = 2 * j - i
if k >= N:
continue
if S[i] != S[j] and S[i] != S[k] and S[j] != S[k]:
cnt += 1
print(all - cnt)
|
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 d in range(1, n):
j = i + d
k = j + d
if k >= n:
break
if s[i] != s[j] and s[i] != s[k] and s[j] != s[k]:
ans -= 1
print(ans)
| 1 | 36,054,026,975,528 | null | 175 | 175 |
# 20-String-Shuffle.py
# ?????£?????????
# ???????????¢????????????????????????????????? n ???????????????????±±????????£?????????????????????
# 1???????????£???????????§??????????????? h ???????????????????????¨???????????????????????????????????£????????????????±±??????????????????????????????
# ?????????????±±?????\???????????????????????????????????§?????????????????????
# abcdeefab
# ?????????????????????????????????????????????????????????????????????????????????????????????????????????????????????
# ????????°???????????? h ??? 4 ??§?????£?????????????????¨????????????4?????? abcd ??????
# ??????????????? eefab ???????°??????£?????????????????§??\??????????????????????????????
# eefababcd
# ???????????£???????????????????????°??????????????????
# ?????????????±±???????????????????????????????????¨ h ???????????????????????????
# ?????????????????????????????????????????????????????°?????????????????????????????????
# Constraints
# ?????????????????????200????¶??????????
# ?????£?????????????????°???100????¶??????????
# Input
# ?????°??????????????????????????\?????¨?????????????????????????????????????????????????????\????????¢?????§?????????????????????
# ????????????????????¨????????????
# ?????£??????????????° m
# h1
# h2
# .
# .
# hm
# ????????????????????¨??????????????? "-" ?????¨?????\?????????????????¨????????????
# Output
# ??????????????????????????????????????????????????????????????????????????????????????????????????????
# Sample Input
# aabc
# 3
# 1
# 2
# 1
# vwxyz
# 2
# 3
# 4
# -
# Sample Output
# aabc
# xyzvw
card=[]
shuffle_times=[]
shuffle_num=[]
#??\???
while 1:
card.append( input() )
if card[-1]=="-":
break;
shuffle_times.append( int(input()) )
# print("shuffle_times",shuffle_times)
# print("shuffle_times[-1]",shuffle_times[-1])
temp=[]
for i in range(shuffle_times[-1]):
temp.append( int(input()) )
shuffle_num.append(temp)
#??\?????????
for i in range(len(card)-1):
for j in range(shuffle_times[i]):
card[i] = card[i][shuffle_num[i][j]:] + card[i][:shuffle_num[i][j]]
# ??????
print(card[i])
|
while True:
a = raw_input()
if a == '-':
break
m = input()
b = [input() for _ in range(m)]
for i in b:
a = a[i:]+a[0:i]
print a
| 1 | 1,907,063,626,810 | null | 66 | 66 |
N = int(input())
S = input()
if N<4:
print(0)
else:
a = [0] * N
R, G, B = 0, 0, 0
for i in range(N):
if S[i] == "R":
a[i] = 1
R += 1
if S[i] == "G":
a[i] = 2
G += 1
if S[i] == "B":
a[i] = 4
B += 1
rgb = R * G * B
cnt = 0
for i in range(N-2):
for d in range(1, (N-i-1) // 2+1):
if a[i] + a[i+d] + a[i+2*d] == 7:
cnt += 1
print(rgb -cnt)
|
n=int(input())
s=input()
R=[]
G={}
B=[]
for i in range(n):
if s[i]=='R':
R.append(i+1)
elif s[i]=='G':
G[i+1]=G.get(i+1,0)+1
else:
B.append(i+1)
res=len(R)*len(G)*len(B)
for i in R:
for j in B:
if ((i+j)%2==0 and G.get((i+j)//2,0)==1):
res-=1
if G.get(2*max(i,j)-min(i,j),0)==1:
res-=1
if G.get(2*min(i,j)-max(i,j),0)==1:
res-=1
print(res)
| 1 | 36,223,832,799,352 | null | 175 | 175 |
import bisect
n=int(input())
l=sorted(list(map(int,input().split())))
ans=0
for i in range(n-1):
for j in range(i+1,n):
index=bisect.bisect_left(l,l[i]+l[j])
if j<index:
ans+=index-j-1
print(ans)
|
from collections import deque
n, m = map(int, input().split())
room = [[] for i in range(n)]
for i in range(m):
a, b = map(int, input().split())
room[a-1].append(b)
room[b-1].append(a)
point = [0 for i in range(n)]
d = deque([0])
while len(d) > 0:
p = d.popleft()
for v in room[p]:
if point[v-1] == 0:
d.append(v-1)
point[v-1] = p+1
print('Yes')
for i in range(1, n):
print(point[i])
| 0 | null | 96,125,924,893,650 | 294 | 145 |
import sys
INF = 1 << 60
MOD = 10**9 + 7 # 998244353
sys.setrecursionlimit(2147483647)
input = lambda:sys.stdin.readline().rstrip()
def resolve():
n, k = map(int, input().split())
P = list(map(lambda x : int(x) - 1, input().split()))
C = list(map(int, input().split()))
# doubling table
nexts = [P]
vals = [C]
totals = [C]
for _ in range(60):
next, val, total = nexts[-1], vals[-1], totals[-1]
nnext, nval, ntotal = [0] * n, [0] * n, [0] * n
for i in range(n):
nnext[i] = next[next[i]]
nval[i] = val[i] + val[next[i]]
ntotal[i] = max(total[i], val[i] + total[next[i]])
nexts.append(nnext)
vals.append(nval)
totals.append(ntotal)
# answer
ans = -INF
for now in range(n):
score = 0
for d in range(59, -1, -1):
if k >> d & 1:
ans = max(ans, score + totals[d][now])
score += vals[d][now]
now = nexts[d][now]
print(ans)
resolve()
|
import pprint
N=int(input())
A=list(map(int,input().split()))
if N%2==0:#偶数なら1回まで2こ飛ばしで無茶できる
dp=[[-float("inf") for _ in range(2)] for _ in range(N+10)]#dpはj=0の時は無茶をしていない系列j=1の時は1回無茶をした系列である
if N==2:#2の時は個別
print(max(A[0],A[1]))
else:#それ以外の時は
for i in range(N):
if i==0: #i=0をとる時の任意の系列は無茶を確実にしていないのでdp[i][0]のみA[0]
dp[0][0]=A[0]
elif i==1: #i=1をとる時の任意の系列は一回無茶をして取っているはずである、よってdp[i][1]のみA[1]
dp[1][1]=A[1]
elif i==2: #i=2をとる時の任意の系列は一回も無茶せずに先頭からとっているのでdp[i][0]=A[0]+A[2]
dp[2][0]=A[0]+A[2]
else: #そのほかは再帰的に考える
for j in range(2):
if j==0: #無茶しない系列を生成する時
dp[i][0]=max(dp[i][0],dp[i-2][0]+A[i]) #そこまでの無茶しなかった系列に自らを足していけば良い
elif j==1: #一回無茶する系列を生成する時
dp[i][1]=max(dp[i][1],dp[i-2][1]+A[i],dp[i-3][0]+A[i]) #すでにある無茶した時の値(いらない？)と、前までの系列で無茶していて今回は無茶できないパターン、今回で無茶をするパターンのうち最大を用いて系列生成すれば良い
print(max(dp[N-1][1],dp[N-2][0])) #1回も飛ばさない時は後ろから二番目のdp値が相当することに注意
else:#奇数なら計2回まで無茶できる(2飛ばし×2、3飛ばし×1まで許容)
#print(A[0],A[1])
dp=[[-float("inf") for _ in range(3)] for _ in range(N+10)]#dpはj=0の時は無茶をしない系列j=1は1回無茶をした系列、j=2は2回無茶をしている系列
if N==3:#N=3の時は個別
print(max(A[0],A[1],A[2]))
else:#それ以外の時は
for i in range(N):
if i<4:
if i==0: #i=0をとる任意の系列は無茶を確実にしていないのでdp[i][0]のみA[0]
dp[0][0]=A[0]
if i==1: #i=1をとる任意の系列は確実に1回無茶をしているのでdp[i][1]のみA[1]
dp[1][1]=A[1]
if i==2: #i=2をとる時は2回分の無茶をしてA[2]を得る時(dp[i][2]=A[2])および1かいも無茶せずに撮っている時(dp[i][0]=A[2]+A[0])
dp[2][2]=A[2]
dp[2][0]=A[0]+A[2]
if i==3: #i=3をとる時は1回目で無茶をしてそのあと無茶していないパターン(dp[1][1]+A[3])といきなり1回無茶をしたパターン(dp[0][0]+A[3])があるのでその最大を
dp[3][1]=max(dp[1][1]+A[3],dp[0][0]+A[3])
else: #そのほかは再帰的に
for j in range(3):
if j==0: #無茶してない系列を生成する時、
dp[i][0]=max(dp[i][0],dp[i-2][0]+A[i]) #そこまでの無茶しなかった系列に自らを足していけば良い
elif j==1: #1回だけ無茶した系列を生成する時
dp[i][1]=max(dp[i][1],dp[i-2][1]+A[i],dp[i-3][0]+A[i]) #すでにある1回無茶した時の値(いらない？)と、前までの系列で1回無茶していて今回は無茶しないパターン、今回で初めて無茶をするパターンのうち最大を用いて系列生成すれば良い
else: #2回無茶した系列を生成する時
dp[i][2]=max(dp[i][2],dp[i-2][2]+A[i],dp[i-3][1]+A[i],dp[i-4][0]+A[i]) #すでにある2回無茶した時の値(いらない？)と、もう二回無茶していて無茶できないパターン、前までの系列で1回無茶していて今回も1回無茶するしないパターン、今回でいきなり2回無茶をするパターンのうち最大を用いて系列生成すれば良い
print(max(dp[N-1][2],dp[N-2][1],dp[N-3][0])) #1回も飛ばさない時は後ろから3番目が、1回だけ飛ばした時は後ろから2番目のdp値が相当することに注意
| 0 | null | 21,262,351,453,600 | 93 | 177 |
k = int(input())
ans = "ACL" * k
print(ans)
|
input = input()
L, R, d = [int(n) for n in input.split()]
count = 0
for n in range(L, R+1):
if n % d == 0:
count += 1
print(count)
| 0 | null | 4,921,129,088,242 | 69 | 104 |
three_num = input()
three_num = [int(i) for i in three_num.split(" ")]
a = three_num[0]
b = three_num[1]
c = three_num[2]
cnt = 0
for i in range(a, b + 1):
if c % i == 0:
cnt += 1
print(cnt)
|
import itertools
while True:
n,x=map(int,input().split())
if n==0 and x==0:
break
z=list(range(1,n+1))
a=list(itertools.combinations(z,3))
b=[]
for i in a:
b+=[sum(i)]
print(b.count(x))
| 0 | null | 923,289,733,058 | 44 | 58 |
n = int(input()) #
ns = list(map(int, input().split()))
ns.reverse()
print(*ns)
|
n = int(input())
x = input().split()
a = list(map(int, x))
b = []
for i in range(n):
b.append(a[n - 1 - i])
for output in b[:n - 1]:
print(output, end=' ')
print(b[n - 1])
| 1 | 968,605,699,772 | null | 53 | 53 |
def main():
import copy
from heapq import heappop, heapify, heappush
import math
N, K = map(int, input().split())
A = [int(i) for i in input().split()]
F = [int(i) for i in input().split()]
ans = 0
A.sort(reverse=True)
F.sort()
s = []
for i in range(N):
s.append([A[i]*F[i], A[i], F[i]])
s.sort(reverse=True, key=lambda x: x[0])
def f(S, T):
cur = 0
num = 0
while cur <= K:
if num == N:
break
a, b, c = S[num]
if a <= T:
break
cur += math.ceil((a - T)/c)
num += 1
if cur <= K:
return True
else:
return False
ok, ng = s[0][0], -1
while abs(ok-ng) > 1:
mid = (ok+ng)//2
if f(s, mid) == True:
ok = mid
else:
ng = mid
print(ok)
if __name__ == '__main__':
main()
|
def isok(t):
cnt = 0
for i in range(n):
cnt += max(a[i] - t // f[i], 0)
if cnt > k:
return False
return True
n,k = map(int,input().split())
a = list(map(int,input().split()))
f = list(map(int,input().split()))
a.sort(reverse = 1)
f.sort()
ok = a[0] * f[-1]
ng = -1
bool = True
while abs(ok - ng) > 1:
mid = (ok + ng) // 2
if isok(mid):
ok = mid
else:
ng = mid
#print(ng,mid,ok)
print(ok)
| 1 | 164,751,109,022,630 | null | 290 | 290 |
# coding: utf-8
def main():
n, m, l = map(int, raw_input().split())
mat_A = [] # (n, m)
mat_B = [] # (m, l)
for i in range(n):
mat_A.append(map(int, raw_input().split()))
for j in range(m):
mat_B.append(map(int, raw_input().split()))
for i in range(n):
c = [0 for g in range(l)]
for j in range(l):
for k in range(m):
# print "n:{}, m:{}, l:{}".format(i,k,j)
try:
c[j] += mat_A[i][k] * mat_B[k][j]
except:
print "n: {}, m: {}, l: {}".format(i,k,j)
print " ".join(map(str, c))
if __name__ == "__main__":
main()
|
n, m, l = map(int, input().split())
A = [list(map(int, input().split())) for _ in range(n)]
B = [list(map(int, input().split())) for _ in range(m)]
ans = []
for i in range(n):
new_row = []
for j in range(l):
tmp_ans = 0
for k in range(m):
tmp_ans += A[i][k] * B[k][j]
new_row.append(tmp_ans)
ans.append(new_row)
for i in range(n):
print(' '.join(str(x) for x in ans[i]))
| 1 | 1,441,095,295,090 | null | 60 | 60 |
import sys
sys.setrecursionlimit(2000)
def check_2(num):
if num % 2 != 0:
return 0
return check_2(num // 2) + 1
def check_5(num):
if num % 5 != 0:
return 0
return check_5(num // 5) + 1
def f_2(num):
if num < 2:
return 0
return f_2(num - 2) + check_2(num)
def f_5(num):
if num < 5:
return 0
return f_5(num - 2) + check_5(num)
N = int(input())
if N < 10:
print(0)
exit()
if N % 2 != 0:
print(0)
exit()
i = 1
ans = 0
while N // ((5 ** i) * 2) > 0:
ans += N // ((5 ** i) * 2)
i += 1
print(ans)
|
n = list(map(int, input()))
dp = (0, 1)
for i in n:
dp = (min(dp[0] + i, dp[1] + 10 - i), min(dp[0] + i + 1, dp[1] + 9 - i))
print(dp[0])
| 0 | null | 93,511,702,801,150 | 258 | 219 |
import math
def main():
N = int(input())
if N % 2 == 0:
print("{:.11f}".format((N / 2) / N))
else:
print("{:.11f}".format(math.ceil(N / 2) / N))
if __name__ == "__main__":
main()
|
n=int(input())
a=0
for i in range(1,n+1):
a+=(i%2)
print(a/n)
| 1 | 177,379,517,955,098 | null | 297 | 297 |
class Dice(object):
def __init__(self, s1, s2, s3, s4, s5, s6):
self.s1 = s1
self.s2 = s2
self.s3 = s3
self.s4 = s4
self.s5 = s5
self.s6 = s6
def east(self):
prev_s6 = self.s6
self.s6 = self.s3
self.s3 = self.s1
self.s1 = self.s4
self.s4 = prev_s6
def west(self):
prev_s6 = self.s6
self.s6 = self.s4
self.s4 = self.s1
self.s1 = self.s3
self.s3 = prev_s6
def north(self):
prev_s6 = self.s6
self.s6 = self.s5
self.s5 = self.s1
self.s1 = self.s2
self.s2 = prev_s6
def south(self):
prev_s6 = self.s6
self.s6 = self.s2
self.s2 = self.s1
self.s1 = self.s5
self.s5 = prev_s6
def rotate(self):
prev_s2 = self.s2
self.s2 = self.s4
self.s4 = self.s5
self.s5 = self.s3
self.s3 = prev_s2
def top(self):
return self.s1
def front(self):
return self.s2
def right(self):
return self.s3
s1, s2, s3, s4, s5, s6 = map(int, input().split())
dice = Dice(s1, s2, s3, s4, s5, s6)
q = int(input())
for i in range(q):
t, f = map(int, input().split())
flag = False
for j in range(6):
if j % 2 == 0:
dice.north()
else:
dice.west()
for k in range(4):
dice.rotate()
if dice.top() == t and dice.front() == f:
flag = True
break
if flag:
break
print(dice.right())
|
import sys
argvs = sys.argv
for x in sys.stdin:
print str(int(x)**3)
| 0 | null | 263,233,596,458 | 34 | 35 |
num,money=map(int,input().split())
if num*500>=money:
print("Yes")
else:
print("No")
|
k,x = [int(i) for i in input().split()]
ans=''
if k*500 >= x: ans = 'Yes'
else: ans='No'
print(ans)
| 1 | 97,770,896,519,072 | null | 244 | 244 |
#!/usr/bin/env python
# -*- coding: utf-8 -*-
"""
?¨??????????
n ????????????????????????????????§????????°???????????°???????¨?????????£??????
????????????????????????s1, s2 ... sn??¨????????¨??????????¨??????????????±???????????????°????????????????????????
??????????????????????????¨????????°????????£?±2?????\???????????§???????????????
?±2 = (???ni=1(si - m)2)/n
?????£?????£????????????????¨???????????±??¨?????????
"""
import math
while True:
num = int(input().strip())
if num == 0:
break
s = list(map(float,input().strip().split()))
# ?????????
m = 0
for i in range(num):
m += s[i]
m = m / num
# ?¨??????????
a2 = 0
for i in range(num):
a2 += (s[i] - m) ** 2
a = math.sqrt(a2 / num)
print(a)
|
import sys, bisect, math, itertools, string, queue, copy
# import numpy as np
# import scipy
# from collections import Counter,defaultdict,deque
# from itertools import permutations, combinations
# from heapq import heappop, heappush
# # input = sys.stdin.readline
# sys.setrecursionlimit(10**8)
# mod = 10**9+7
def inp(): return int(input())
def inpm(): return map(int,input().split())
def inpl(): return list(map(int, input().split()))
def inpls(): return list(input().split())
def inplm(n): return list(int(input()) for _ in range(n))
def inplL(n): return [list(input()) for _ in range(n)]
def inplT(n): return [tuple(input()) for _ in range(n)]
def inpll(n): return [list(map(int, input().split())) for _ in range(n)]
def inplls(n): return sorted([list(map(int, input().split())) for _ in range(n)])
n = inp()
S = input()
s1 = set()
s2 = set()
s3 = set()
for s in S:
for ss2 in s2:
s3.add(ss2+s)
for ss1 in s1:
s2.add(ss1+s)
s1.add(s)
print(len(s3))
| 0 | null | 64,463,274,640,202 | 31 | 267 |
def execute(N, A):
dst = 0
s = sum(A)
for v in A:
s -= v
dst += v * s
return dst % (10**9+7)
if __name__ == '__main__':
N = int(input())
A = list(map(int, input().split()))
print(execute(N, A))
|
n=int(input())
dp=[0]*(10**5+1)
dp[100]=1
dp[101]=1
dp[102]=1
dp[103]=1
dp[104]=1
dp[105]=1
for i in range(106,10**5+1):
if dp[i-100]==1:
dp[i]=1
elif dp[i-101]==1:
dp[i]=1
elif dp[i-102]==1:
dp[i]=1
elif dp[i-103]==1:
dp[i]=1
elif dp[i-104]==1:
dp[i]=1
elif dp[i-105]==1:
dp[i]=1
print(dp[n])
| 0 | null | 65,191,683,888,562 | 83 | 266 |
n = int(input())
for i in range(1, n + 1):
if i % 3 == 0 or str(i).find("3") != -1:
print(" {}".format(i), end = '')
print()
|
n=int(raw_input())
i = 1
print "",
while(i<=n):
x=i
if x%3 is 0:
print i,
else:
for j in xrange(0,4):
if (x/10**j)%10 is 3:
print i,
break
i = i+1
| 1 | 942,205,725,170 | null | 52 | 52 |
N, X, M = map(int, input().split())
NN = N
li = []
isused = [False] * M
while isused[X] == False and N != 0:
li.append(X)
isused[X] = True
X = (X ** 2) % M
N -= 1
if N == 0:
print(sum(li))
elif N != 0 and X in li:
l = len(li)
s = li.index(X)
T = l - s
q = (NN - s) // T
r = (NN - s) % T
print(sum(li) + sum(li[i] for i in range(s, len(li))) * (q-1) + sum(li[i] for i in range(s, s + r)))
|
n=int(input())
a=list(map(int,input().split()))
mod=10**9+7
x=sum(a)%mod
y=0
for i in range(n):
y+=a[i]**2
y%=mod
z=pow(2,mod-2,mod)
print(((x**2-y)*z)%mod)
| 0 | null | 3,322,406,861,398 | 75 | 83 |
xs = ["X"] + input().split(" ")
print(xs.index("0"))
|
x1, x2, x3, x4, x5 = map(int, input().split())
l = [x1, x2, x3, x4, x5]
print(l.index(0)+1)
| 1 | 13,377,664,418,436 | null | 126 | 126 |
a,b,c=map(int,raw_input().split())
if a+b >= c:
print "No"
else:
ans1 = 4 * a * b;
ans2 = (c - a - b) * (c - a - b)
if ans1 < ans2:
print "Yes"
else:
print "No"
|
from collections import deque
k = int(input())
lunlun = deque([1, 2, 3, 4, 5, 6, 7, 8, 9])
for i in range(k):
s = lunlun.popleft()
if s % 10 != 0:
lunlun.append(10 * s + s % 10 - 1)
lunlun.append(10 * s + s % 10)
if s % 10 != 9:
lunlun.append(10 * s + s % 10 + 1)
print(s)
| 0 | null | 45,940,177,319,036 | 197 | 181 |
import numpy as np
def main(A, B, V, W, T):
if abs(B-A) <= T*(V-W):
return "YES"
return "NO"
A, V = map(int, input().split())
B, W = map(int, input().split())
T = int(input())
print(main(A, B, V, W, T))
|
L = list(map(int,input().split()))
for i in range(5):
if L[i] != (i+1):
print(i+1)
| 0 | null | 14,157,434,399,556 | 131 | 126 |
from collections import Counter
from math import gcd
N=int(input())
def factorize(x):
i=2
ret=[]
while i*i<=x:
while x%i==0:
ret.append(i)
x//=i
i+=1
if x>1:
ret.append(x)
return Counter(ret)
ans=1
for v in factorize(N-1).values():
ans*=v+1
ans-=1
cnt=1
for v in factorize(gcd(N,N-1)).values():
cnt*=v+1
cnt-=1
ans-=cnt
k=2
while k*k<=N:
if N%k==0:
n=N//k
while n%k==0:
n//=k
if n%k==1:
ans+=1
k+=1
ans+=1
print(ans)
|
#!/usr/bin/env python3
import sys
import math
# from string import ascii_lowercase, ascii_upper_case, ascii_letters, digits, hexdigits
# import re # re.compile(pattern) => ptn obj; p.search(s), p.match(s), p.finditer(s) => match obj; p.sub(after, s)
# from operator import itemgetter # itemgetter(1), itemgetter('key')
# from collections import deque # deque class. deque(L): dq.append(x), dq.appendleft(x), dq.pop(), dq.popleft(), dq.rotate()
# from collections import defaultdict # subclass of dict. defaultdict(facroty)
# from collections import Counter # subclass of dict. Counter(iter): c.elements(), c.most_common(n), c.subtract(iter)
# from heapq import heapify, heappush, heappop # built-in list. heapify(L) changes list in-place to min-heap in O(n), heappush(heapL, x) and heappop(heapL) in O(lgn).
# from heapq import nlargest, nsmallest # nlargest(n, iter[, key]) returns k-largest-list in O(n+klgn).
# from itertools import count, cycle, repeat # count(start[,step]), cycle(iter), repeat(elm[,n])
# from itertools import groupby # [(k, list(g)) for k, g in groupby('000112')] returns [('0',['0','0','0']), ('1',['1','1']), ('2',['2'])]
from itertools import starmap # starmap(pow, [[2,5], [3,2]]) returns [32, 9]
from itertools import product, permutations # product(iter, repeat=n), permutations(iter[,r])
# from itertools import combinations, combinations_with_replacement
# from itertools import accumulate # accumulate(iter[, f])
# from functools import reduce # reduce(f, iter[, init])
# from functools import lru_cache # @lrucache ...arguments of functions should be able to be keys of dict (e.g. list is not allowed)
# from bisect import bisect_left, bisect_right # bisect_left(a, x, lo=0, hi=len(a)) returns i such that all(val<x for val in a[lo:i]) and all(val>-=x for val in a[i:hi]).
# from copy import deepcopy # to copy multi-dimentional matrix without reference
# from fractions import gcd # for Python 3.4 (previous contest @AtCoder)
def main():
mod = 1000000007 # 10^9+7
inf = float('inf') # sys.float_info.max = 1.79...e+308
# inf = 2 ** 64 - 1 # (for fast JIT compile in PyPy) 1.84...e+19
sys.setrecursionlimit(10**6) # 1000 -> 1000000
def input(): return sys.stdin.readline().rstrip()
def ii(): return int(input())
def mi(): return map(int, input().split())
def mi_0(): return map(lambda x: int(x)-1, input().split())
def lmi(): return list(map(int, input().split()))
def lmi_0(): return list(map(lambda x: int(x)-1, input().split()))
def li(): return list(input())
n = ii()
# naive, O(nlgn)
# cnt = 0
# for k in range(2, n + 1):
# tmp = n
# if tmp % k == 1:
# cnt += 1
# elif tmp % k == 0:
# while tmp >= k and tmp % k == 0:
# tmp //= k
# if tmp % k == 1:
# cnt += 1
# print(cnt)
class Eratos:
def __init__(self, num):
assert(num >= 1)
self.table_max = num
# self.table[i] は i が素数かどうかを示す (bool)
self.table = [False if i == 0 or i == 1 else True for i in range(num+1)]
for i in range(2, int(math.sqrt(num)) + 1):
if self.table[i]:
for j in range(i ** 2, num + 1, i): # i**2 からスタートすることで定数倍高速化できる
self.table[j] = False
# self.table_max 以下の素数を列挙したリスト
self.prime_numbers = [2] if self.table_max >= 2 else []
for i in range(3, self.table_max + 1, 2):
if self.table[i]:
self.prime_numbers.append(i)
def is_prime(self, num):
"""
>>> e = Eratos(100)
>>> [i for i in range(1, 101) if e.is_prime(i)]
[2, 3, 5, 7, 11, 13, 17, 19, 23, 29, 31, 37, 41, 43, 47, 53, 59, 61, 67, 71, 73, 79, 83, 89, 97]
"""
assert(num >= 1)
if num > self.table_max:
raise ValueError('Eratos.is_prime(): exceed table_max({}). got {}'.format(self.table_max, num))
return self.table[num]
def prime_factorize(self, num):
"""
>>> e = Eratos(10000)
>>> e.prime_factorize(6552)
{2: 3, 3: 2, 7: 1, 13: 1}
"""
assert(num >= 1)
if int(math.sqrt(num)) > self.table_max:
raise ValueError('Eratos.prime_factorize(): exceed prime table size. got {}'.format(num))
factorized_dict = dict() # 素因数分解の結果を記録する辞書
candidate_prime_numbers = [i for i in range(2, int(math.sqrt(num)) + 1) if self.is_prime(i)]
# n について、√n 以下の素数で割り続けると最後には 1 or 素数となる
# 背理法を考えれば自明 (残された数が √n より上の素数の積であると仮定。これは自明に n を超えるため矛盾)
for p in candidate_prime_numbers:
# これ以上調査は無意味
if num == 1:
break
while num % p == 0:
num //= p
try:
factorized_dict[p]
except KeyError:
factorized_dict[p] = 0
finally:
factorized_dict[p] += 1
if num != 1:
factorized_dict[num] = 1
return factorized_dict
eratos = Eratos(int(math.sqrt(n)))
d_1 = eratos.prime_factorize(n - 1)
# n = k + 1, 2k + 1, 3k + 1, ...
cnt = 0
tmp = 1
for _, v in d_1.items():
tmp *= (v + 1)
tmp -= 1
cnt += tmp
d_2 = eratos.prime_factorize(n)
# 全約数 x (除: 1) について (n // x) ≡ 1 (mod x) なら cnt += 1とすればいいのでは
# 約数の個数は高々 2√n 個なので間に合いそう？
L = [range(v + 1) for _, v in d_2.items()]
power_list = list(product(*L))
prime_list = list(d_2.keys())
for elm in power_list:
# elm は具体的な各素数の指数を指定したリストである
div = 1
for i in range(len(prime_list)):
div *= pow(prime_list[i], elm[i])
# print(f"div: {div}")
if div != 1:
assert(n % div == 0)
copy_n = n
while copy_n % div == 0:
copy_n //= div
if copy_n % div == 1:
cnt += 1
print(cnt)
if __name__ == "__main__":
main()
| 1 | 41,430,782,540,432 | null | 183 | 183 |
from queue import Queue
k = int(input())
q = Queue()
for i in range(1, 10):
q.put(i)
for i in range(k):
x = q.get()
if x % 10 != 0:
num = 10 * x + (x % 10) - 1
q.put(num)
num = 10 * x + (x % 10)
q.put(num)
if x % 10 != 9:
num = 10 * x + (x % 10) + 1
q.put(num)
print(x)
|
K = int(input())
# 10桁までやれば十分
runrun_table = [[0 for _ in range(10)] for _ in range(10)]
# i桁のルンルン数の種類 <= 3**(i-1)*9
for i in range(10):
runrun_table[0][i] = 1
for keta in range(1, 10):
for i in range(10):
if i == 0:
runrun_table[keta][i] = runrun_table[keta - 1][i] + \
runrun_table[keta - 1][i + 1]
elif i == 9:
runrun_table[keta][i] = runrun_table[keta - 1][i - 1] + \
runrun_table[keta - 1][i]
else:
runrun_table[keta][i] = runrun_table[keta - 1][i - 1] + \
runrun_table[keta - 1][i] + \
runrun_table[keta - 1][i + 1]
keta = 0
ans = ''
while sum(runrun_table[keta][1:]) < K:
K -= sum(runrun_table[keta][1:])
keta += 1
for piv in range(1, 10):
if runrun_table[keta][piv] >= K:
ans += str(piv)
keta -= 1
break
K -= runrun_table[keta][piv]
while keta >= 0:
if piv == 0:
piv_range = [0, 1]
elif piv == 9:
piv_range = [8, 9]
else:
piv_range = range(piv-1, piv+2)
for piv in piv_range:
if runrun_table[keta][piv] >= K:
ans += str(piv)
keta -= 1
break
K -= runrun_table[keta][piv]
print(ans)
| 1 | 39,944,280,984,256 | null | 181 | 181 |
n = int(input())
s = input()
sr = []
sg = []
sb = [0] * n
kcnt = 0
for i in range(n):
if s[i] == 'R':
sr.append(i)
elif s[i] == 'G':
sg.append(i)
else:
sb[i] = 1
kcnt += 1
ans = 0
for i in sr:
for j in sg:
nki = j*2 - i
nkj = i*2 - j
nkk = (j+i)
ans += kcnt
if 0<= nki < n and sb[nki] == 1:
ans -= 1
if 0<= nkj < n and sb[nkj] == 1:
ans -= 1
if nkk%2 == 0 and 0<= (nkk//2) < n and sb[nkk//2] == 1:
ans -= 1
print(ans)
|
N = int(input())
S = input()
rgb = [0]*3
for i in range(N):
if S[i] == "R":
rgb[0] += 1
elif S[i] == "G":
rgb[1] += 1
else:
rgb[2] += 1
ans = 0
for i in range(N):
for h in range(N):
j = i+h
k = i+2*h
if k >= N:
break
if S[i] != S[j] and S[j] != S[k] and S[k] != S[i]:
ans += 1
print(rgb[0]*rgb[1]*rgb[2]-ans)
| 1 | 36,358,025,555,072 | null | 175 | 175 |
s=raw_input()
t=[]
for x in s:
if x=='?':
t.append('D')
else:
t.append(x)
print "".join(t)
|
input = input()
print(input.replace('?','D'))
| 1 | 18,585,581,186,880 | null | 140 | 140 |
import sys
readline = sys.stdin.readline
import numpy as np
N = int(readline())
A = np.array(readline().split(),dtype=int)
DIV = 10 ** 9 + 7
# 各桁の1と0の数を数えて、((1の数) * (0の数)) * (2 ** i桁目(1桁目を0とする))を数える
K = max(A)
j = 0
ans = 0
while K:
bits = (A >> j) & 1
one = np.count_nonzero(bits)
ans += (one % DIV) * ((N - one) % DIV) * pow(2,j,DIV)
ans %= DIV
j += 1
K >>= 1
print(ans)
|
n = int(input())
Ai = list(map(int, input().split()))
sum_ans = sum(Ai)
ans = 0
mod = 1000000007
for i in range(n-1):
sum_ans -= Ai[i]
ans += sum_ans * Ai[i]
ans %= mod
print(ans)
| 0 | null | 63,152,605,243,938 | 263 | 83 |
import math
from decimal import Decimal, ROUND_HALF_UP
def resolve():
a, b, C = map(int, input().split())
x = math.radians(C)
h = b * math.sin(x)
S = Decimal((a * h) / 2).quantize(Decimal('0.00000001'), rounding=ROUND_HALF_UP)
c = Decimal(math.sqrt(a ** 2 + b ** 2 - 2 * a * b * math.cos(x))).quantize(Decimal('0.00000001'),
rounding=ROUND_HALF_UP)
L = Decimal(a + b + c).quantize(Decimal('0.00000001'), rounding=ROUND_HALF_UP)
print(S, L, h, sep="\n")
resolve()
|
from math import *
n,k=map(int,input().split())
a=list(map(int,input().split()))
a.sort()
def is_ok(arg):
tmp=0
for i in a:
tmp+=ceil(i/arg)-1
return tmp<=k
def meguru_bisect(ng, ok):
while (abs(ok - ng) > 1):
mid = (ok + ng) // 2
if is_ok(mid):
ok = mid
else:
ng = mid
return ok
print(meguru_bisect(0, max(a)))
| 0 | null | 3,351,820,807,008 | 30 | 99 |
from random import randint
import sys
input = sys.stdin.readline
INF = 9223372036854775808
def calc_score(D, C, S, T):
"""
開催日程Tを受け取ってそこまでのスコアを返す
コンテストi 0-indexed
d 0-indexed
"""
score = 0
last = [0]*26 # コンテストiを前回開催した日
for d, t in enumerate(T):
last[t] = d + 1
for i in range(26):
score -= (d + 1 - last[i]) * C[i]
score += S[d][t]
return score
def update_score(D, C, S, T, score, ct, ci):
"""
ct日目のコンテストをコンテストciに変更する
スコアを差分更新する
ct: change t 変更日 0-indexed
ci: change i 変更コンテスト 0-indexed
"""
last = [0]*26 # コンテストiを前回開催した日，0-indexed:1-indexed
for d in range(ct):
last[T[d]] = d + 1
prei = T[ct] # 変更前に開催する予定だったコンテストi
score -= S[ct][prei]
score += S[ct][ci]
return score
def evaluate(D, C, S, T, k):
"""
d日目終了時点での満足度を計算し，
d + k日目終了時点での満足度の減少も考慮する
"""
score = 0
last = [0]*26
for d, t in enumerate(T):
last[t] = d + 1
for i in range(26):
score -= (d + 1 - last[i]) * C[i]
score += S[d][t]
for d in range(len(T), min(len(T) + k, D)):
for i in range(26):
score -= (d + 1 - last[i]) * C[i]
return score
def greedy(D, C, S):
Ts = []
for k in range(5, 13):
T = [] # 0-indexed
max_score = -INF
for d in range(D):
# d+k日目終了時点で満足度が一番高くなるようなコンテストiを開催する
max_score = -INF
best_i = 0
for i in range(26):
T.append(i)
score = evaluate(D, C, S, T, k)
if max_score < score:
max_score = score
best_i = i
T.pop()
T.append(best_i)
Ts.append((max_score, T))
return max(Ts, key=lambda pair: pair[0])
def local_search(D, C, S, score, T):
for k in range(4000):
ct = randint(0, D-1)
ci = randint(0, 25)
ori = T[ct]
T[ct] = ci
new_score = calc_score(D, C, S, T)
# 差分更新がバグってそう
if score < new_score:
score = new_score
else:
T[ct] = ori
return T
if __name__ == '__main__':
D = int(input())
C = [int(i) for i in input().split()]
S = [[int(i) for i in input().split()] for j in range(D)]
init_score, T = greedy(D, C, S)
T = local_search(D, C, S, init_score, T)
for t in T:
print(t+1)
|
# -*- coding: utf-8 -*-
import sys
import math
from bisect import bisect_left
from bisect import bisect_right
from collections import defaultdict
from heapq import heappop, heappush
import itertools
import random
from decimal import *
input = sys.stdin.readline
def inputInt(): return int(input())
def inputMap(): return map(int, input().split())
def inputList(): return list(map(int, input().split()))
def inputStr(): return input()[:-1]
inf = float('inf')
mod = 1000000007
#-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-
#-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-
def main():
D = inputInt()
C = inputList()
S = []
for i in range(D):
s = inputList()
S.append(s)
ans1 = []
ans2 = []
ans3 = []
ans4 = []
for i in range(D):
bestSco1 = 0
bestSco2 = 0
bestSco3 = 0
bestSco4 = 0
bestI1 = 1
bestI2 = 1
bestI3 = 1
bestI4 = 1
for j,val in enumerate(S[i]):
if j == 0:
tmpAns = ans1 + [j+1]
tmpSco = findScore(tmpAns, S, C)
if bestSco1 < tmpSco:
bestSco4 = bestSco3
bestI4 = bestI3
bestSco3 = bestSco2
bestI3 = bestI2
bestSco2 = bestSco1
bestI2 = bestI1
bestSco1 = tmpSco
bestI1 = j+1
else:
tmpAns1 = ans1 + [j+1]
tmpAns2 = ans2 + [j+1]
tmpAns3 = ans3 + [j+1]
tmpAns4 = ans4 + [j+1]
tmpSco1 = findScore(tmpAns1, S, C)
tmpSco2 = findScore(tmpAns2, S, C)
tmpSco3 = findScore(tmpAns3, S, C)
tmpSco4 = findScore(tmpAns4, S, C)
if bestSco1 < tmpSco1:
bestSco1 = tmpSco1
bestI1 = j+1
if bestSco2 < tmpSco2:
bestSco2 = tmpSco2
bestI2 = j+1
if bestSco3 < tmpSco3:
bestSco3 = tmpSco3
bestI3 = j+1
if bestSco4 < tmpSco4:
bestSco4 = tmpSco4
bestI4 = j+1
ans1.append(bestI1)
ans2.append(bestI2)
ans3.append(bestI3)
ans4.append(bestI4)
aa = []
aa.append(bestSco1)
aa.append(bestSco2)
aa.append(bestSco3)
aa.append(bestSco4)
aa.sort()
aa = aa[::-1]
if aa[0] == bestSco1:
for i in ans1:
print(i)
elif aa[0] == bestSco2:
for i in ans2:
print(i)
elif aa[0] == bestSco3:
for i in ans3:
print(i)
elif aa[0] == bestSco4:
for i in ans4:
print(i)
def findScore(ans, S, C):
scezhu = [inf for i in range(26)]
sco = 0
for i,val in enumerate(ans):
tmp = S[i][val-1]
scezhu[val-1] = i
mins = 0
for j,vol in enumerate(C):
if scezhu[j] == inf:
mins = mins + (vol * (i+1))
else:
mins = mins + (vol * ((i+1)-(scezhu[j]+1)))
tmp -= mins
sco += tmp
return sco
#-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-
#-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-
if __name__ == "__main__":
main()
| 1 | 9,758,537,300,330 | null | 113 | 113 |
import sys
def main():
input = sys.stdin.readline
n, k = map(int, input().split())
a = [int(x) for x in input().split()]
f = [int(x) for x in input().split()]
a.sort(reverse=True)
f.sort()
l, r = -1, pow(10, 12)+1
while r-l > 1:
judge = (r+l)//2
sub = 0
for i in range(n):
if a[i]*f[i] <= judge:
continue
sub += a[i]-judge//f[i]
if sub <= k:
r = judge
else:
l = judge
print(r)
if __name__ == "__main__":
main()
|
n, k = map(int, input().split())
a = list(map(int, input().split()))
f = list(map(int, input().split()))
a.sort()
f.sort()
high = max(a)*max(f)
low = 0
while high > low:
mid = (high+low)//2
b = 0
for i in range(n):
b += max(a[i]-mid//f[n-i-1],0)
if b > k:
low = mid + (low==mid)
else:
high = mid - (high==mid)
mid = (high+low)//2
print(mid)
| 1 | 164,710,978,735,170 | null | 290 | 290 |
import sys
read = sys.stdin.read
readline = sys.stdin.readline
count = 0
l, r, d= [int(x) for x in readline().rstrip().split()]
#print(l,r,d)
for i in range(l,r+1):
if i % d == 0:
count += 1
print(count)
|
n, m = map(int, input().split())
if m > 0:
p, s = zip(* [input().split() for _ in range(m)])
else:
p = []
s = []
ac_dict = {str(i): False for i in range(1, n + 1)}
wa_dict = {str(i): 0 for i in range(1, n + 1)}
ac_num = 0
wa_num = 0
for p_i, s_i in zip(p, s):
if ac_dict[p_i] == False:
if s_i == 'AC':
ac_num += 1
wa_num += wa_dict[p_i]
ac_dict[p_i] = True
elif s_i == 'WA':
wa_dict[p_i] += 1
print('{} {}'.format(ac_num, wa_num))
| 0 | null | 50,690,281,575,808 | 104 | 240 |
a, b, c = list(map(int, input().split()))
if a == b == c:
print('No')
elif a == b:
print('Yes')
elif b == c:
print('Yes')
elif a == c:
print('Yes')
else:
print('No')
|
from collections import Counter
abc = Counter(input().split())
if len(abc) == 2:
print('Yes')
else:
print('No')
| 1 | 67,876,675,654,580 | null | 216 | 216 |
from math import sqrt
n = int(input())
x = list(map(int, input().split()))
y = list(map(int, input().split()))
p_1 = 0
p_2 = 0
p_3 = 0
p_inf = 0
for i, j in zip(x, y):
p_1 += abs(i - j)
p_2 += (i - j) ** 2
p_3 += abs((i - j)) ** 3
p_inf = max(p_inf, abs(i - j))
print(p_1)
print(sqrt(p_2))
print(p_3 ** (1 / 3))
print(p_inf)
|
s = input()
hitachi = ""
for i in range(5):
hitachi += "hi"
if s==hitachi:
print("Yes")
exit(0)
print("No")
| 0 | null | 26,664,108,921,396 | 32 | 199 |
A, B = map(int, input().split())
if A == 1 or B == 1:
print(1)
elif (A*B) % 2 == 0:
print(A*B//2)
else:
print(A*B//2+1)
|
import math
H,W=map(int,input().split())
if W==1:
print(1)
elif H==1:
print(1)
else:
A=math.ceil(H*W/2)
print(A)
| 1 | 50,521,588,421,250 | null | 196 | 196 |
if(int(input())== 1):
print(0)
exit()
print(1)
|
print('10'[int(input())])
| 1 | 2,937,495,900,582 | null | 76 | 76 |
import sys
sys.setrecursionlimit(10000000)
MOD = 10 ** 9 + 7
INF = 10 ** 15
N = int(input())
ans = []
const = 2*3**0.5
def korch_curve(Lx,Ly,Rx,Ry,i):
if i == 0:
ans.append((Lx,Ly))
return
third_y = (Ly*2 + Ry)/3
third_x = (Lx*2 + Rx)/3
korch_curve(Lx,Ly,third_x,third_y,i - 1)
middle_x = (Lx + Rx)/2 - (Ry - Ly)/const
middle_y = (Ly + Ry)/2 + (Rx - Lx)/const
korch_curve(third_x,third_y,middle_x,middle_y,i - 1)
third_second_x = (Lx + Rx*2)/3
third_second_y = (Ly + Ry*2)/3
korch_curve(middle_x,middle_y,third_second_x,third_second_y,i - 1)
korch_curve(third_second_x,third_second_y,Rx,Ry,i - 1)
korch_curve(0,0,100,0,N)
ans.append((100,0))
for a in ans:
print(*a)
|
from sys import stdin, stdout
n, m = map(int, stdin.readline().strip().split())
if m>=n:
print('unsafe')
else:
print('safe')
| 0 | null | 14,701,462,058,140 | 27 | 163 |
K = int(input())
S = input()
if len(S) <= K:
print(S)
else:
s = ""
for i in range(K):
s += S[i]
s += "..."
print(s)
|
def main():
H, W, M = (int(i) for i in input().split())
hc = [0]*(H+1)
wc = [0]*(W+1)
maps = set()
for _ in range(M):
h, w = (int(i) for i in input().split())
hc[h] += 1
wc[w] += 1
maps.add((h, w))
mah = max(hc)
maw = max(wc)
ans = mah+maw
hmaps = []
wmaps = []
for i, h in enumerate(hc):
if mah == h:
hmaps.append(i)
for i, w in enumerate(wc):
if maw == w:
wmaps.append(i)
if M < len(hmaps) * len(wmaps):
# 爆破対象の合計が最大になるマスがM個より多ければ，
# 必ず爆破対象がないマスに爆弾を置くことができる
# 逆にM個以下なら3*10^5のループにしかならないので
# このようにif文で分けなくても，必ずO(M)になるのでelse節のforを回してよい
print(ans)
else:
for h in hmaps:
for w in wmaps:
if (h, w) not in maps:
print(ans)
return
else:
print(ans-1)
if __name__ == '__main__':
main()
| 0 | null | 12,293,855,531,760 | 143 | 89 |
X,K,D = map(int, input().split())
X = abs(X)
if X//D > K:
print(X-(D*K))
exit()
if (K-X//D)%2:
print(D-X%D)
else:
print(X%D)
|
import sys
input = sys.stdin.readline
n, k = map(int, input().split())
print(min(n % k, k - (n % k)))
| 0 | null | 22,349,791,081,672 | 92 | 180 |
n = int(input())
for i in range(1, 50000):
if i * 108 // 100 == n:
print(i)
exit()
print(':(')
|
N = int(input())
a = int(N / 1.08) # min
b = int((N + 1) / 1.08) # max
ans = ':('
for i in range(a, b + 1):
if int(i * 1.08) == N:
ans = i
break
print(ans)
| 1 | 126,118,359,021,662 | null | 265 | 265 |
from collections import Counter
S=input()
rlist=[0]
for i in range(len(S)):
rlist.append((rlist[-1]+int(S[-i-1])*pow(10,i,2019))%2019)
c = Counter(rlist)
c[0] -= 1
def nC2(n):
return n*(n-1)//2
ans = c[0]
for k in c.keys():
if c[k] >= 2:
ans += nC2(c[k])
print(ans)
|
S = input()
N = len(S)
mod = 2019
cnt = [0 for _ in range(2019)]
S = S[::-1]
wk = 0
cnt[0] = 1
for i in range(0,N):
wk = (wk + int(S[i]) * pow(10,i,mod)) % mod
#print(i,wk)
cnt[wk] += 1
ans = 0
for i in range(2019):
m = cnt[i]
ans += m * (m-1) // 2
print(ans)
| 1 | 30,753,932,264,910 | null | 166 | 166 |
from collections import deque
n = int(input())
matrix= []
lis = [[] for i in range(n)]
ans = {}
for i in range(n):
ans[i] = {}
for i in range(n-1):
a,b = map(int, input().split())
a -= 1
b -= 1
matrix.append(sorted([a,b]))
lis[a].append(b)
lis[b].append(a)
color = [-1 for _ in range(n)]
queue = deque([0])
color[0] = 1001001001
maxc = 0
while len(queue) > 0:
now = queue.pop()
used = color[now]
tmp = 1
for i in lis[now]:
if color[i] == -1:
queue.append(i)
if tmp == used:
tmp += 1
color[i] = tmp
ans[now][i] = tmp
ans[i][now] = tmp
maxc = max(maxc, tmp)
tmp += 1
print(maxc)
for i in range(n-1):
root = matrix[i]
print(ans[root[0]][root[1]])
|
import math
#import numpy as np
import queue
from collections import deque,defaultdict
import heapq as hpq
from sys import stdin,setrecursionlimit
#from scipy.sparse.csgraph import dijkstra
#from scipy.sparse import csr_matrix
ipt = stdin.readline
setrecursionlimit(10**7)
def main():
n = int(ipt())
way = [[] for i in range(n+1)]
for i in range(n-1):
a,b = map(int,ipt().split())
way[a].append((b,i))
way[b].append((a,i))
q = queue.Queue()
q.put((1,-1,-1)) #nowplace,pastplace,hen
col = [-1]*(n-1)
while not q.empty():
np,pp,hen = q.get()
nc = 1
for i,wn in way[np]:
if i == pp:
continue
if nc == hen:
nc += 1
col[wn] = nc
q.put((i,np,nc))
nc += 1
print(max(col))
for i in col:
print(i)
return
if __name__ == '__main__':
main()
| 1 | 135,984,637,825,020 | null | 272 | 272 |
MOD = 10**9 + 7
INT_MAX = (1 << 63) - 1
if __name__ == "__main__":
# test_case_num = int(input())
# for _ in range(test_case_num):
m, n = map(int, input().split())
grid = [input().strip() for _ in range(m)]
dp = [float('inf')] * n
for i, row in enumerate(grid):
for j, val in enumerate(row):
if i == 0 and j == 0:
dp[j] = grid[0][0] == '#'
else:
temp = INT_MAX
if i > 0:
temp = min(dp[j] + (val == '#' != grid[i-1][j]), temp)
if j > 0:
temp = min(dp[j-1] + (val == '#' != grid[i][j-1]), temp)
dp[j] = temp
# print(dp)
print(dp[-1])
|
import sys
import collections
sys.setrecursionlimit(10 ** 8)
input = sys.stdin.readline
def main():
H, W = [int(x) for x in input().split()]
S = [list(input().strip()) for _ in range(H)]
dp = [[10 ** 9] * W for _ in range(H)]
dp[0][0] = int(S[0][0] == '#')
for j in range(H):
for i in range(W):
if j != H - 1:
dp[j + 1][i] = min(dp[j + 1][i], dp[j][i] + int(S[j + 1][i] == '#' and S[j][i] == '.'))
if i != W - 1:
dp[j][i + 1] = min(dp[j][i + 1], dp[j][i] + int(S[j][i + 1] == '#' and S[j][i] == '.'))
print(dp[-1][-1])
if __name__ == '__main__':
main()
| 1 | 49,236,102,254,848 | null | 194 | 194 |
import sys
def input(): return sys.stdin.readline().strip()
def mapint(): return map(int, input().split())
sys.setrecursionlimit(10**9)
N, K = mapint()
v = N//K
print(min(N-v*K, K-(N-v*K)))
|
n = int(input())
a = list(map(int, input().split()))
b = 0
c = 0
for i in range(n):
b = max(b,a[i])
c += (b-a[i])
print(c)
| 0 | null | 22,027,834,789,180 | 180 | 88 |
import math as mt
import sys, string
from collections import Counter, defaultdict
input = sys.stdin.readline
# input functions
I = lambda : int(input())
M = lambda : map(int, input().split())
ARR = lambda: list(map(int, input().split()))
n = I()
print(int(not n))
|
while True:
n,x=map(int,input().split())
a=0
if n==0 and x==0:break
for i in range(1,n+1):
for j in range(1,i):
for k in range(1,j):
if i+j+k==x:a+=1
print(a)
| 0 | null | 2,076,611,995,318 | 76 | 58 |
from collections import deque
infty = 10 ** 9
def BFS(graph, parent, u):
queue = deque()
queue.append(u)
visited = [False for k in range(len(parent))] #探索が始まったか否か
visited[u] = True
while queue:
v = queue.popleft()
for j in graph[v]:
if not visited[j]:
queue.append(j)
visited[j] = True
parent[j] = v
n, m = map(int, input().split())
graph = [[] for i in range(n)]
for i in range(m):
a, b = map(int, input().split())
graph[a-1].append(b-1)
graph[b-1].append(a-1)
parent = [-1 for i in range(n)]
BFS(graph, parent, 0)
if -1 in parent[1:]:
print("No")
else:
print("Yes")
for p in parent[1:]:
print(p+1)
|
from collections import deque
N, M = map(int, input().split())
Graph = [[]for _ in range(N + 1)]
for i in range(M):
a, b = map(int, input().split())
Graph[a].append(b)
Graph[b].append(a)
dist = [-1] * (N + 1)
dist[0] = 0
dist[1] = 0
pre = [-1] * (N + 1)
pre[0] = 0
pre[1] = 1
d = deque()
d.append(1)
while d:
v = d.popleft()
for i in Graph[v]:
if dist[i] != -1:
continue
dist[i] = dist[v] + 1
pre[i] = v
d.append(i)
ans = dist[0:]
print('Yes')
for j in range(2, len(pre)):
print(pre[j])
| 1 | 20,636,460,634,798 | null | 145 | 145 |
a, b = map(int, raw_input().split())
print("%d %d %f" %(int(a / b), a % b, float(a) / b))
|
N=int(input())
P=list(map(int,input().split()))
x=N+1
cnt=0
for i in range(N):
if P[i]<x:
cnt+=1
x=P[i]
print(cnt)
| 0 | null | 42,741,150,174,498 | 45 | 233 |
h,a=map(int,input().split())
i=0
while True:
i+=1
h-=a
if h<=0:
break
print(i)
|
str = input()
nums = str.split()
if nums[0] == "0" or nums[1] == "0":
print("error")
else:
turn = float(nums[0]) / float(nums[1]) + 0.9
if turn < 1:
turn = 1
print(int(turn))
| 1 | 76,589,843,378,970 | null | 225 | 225 |
def set_matrix (num,matrix):
for i in xrange(num):
x = map(int,raw_input().split(" "))
matrix.append(x)
n,m,l = map(int, raw_input().split())
a = []
b = []
set_matrix(n,a)
set_matrix(m,b)
b_t = list(map(list,zip(*b)))
for i in xrange(n):
result = []
for j in xrange(l):
result.append( sum([x*y for x,y in zip(a[i], b_t[j]) ]))
print " ".join(map(str,result))
|
n, m, l = map(int, input().split())
A, B = [], []
for _ in range(n):
A.append(list(map(int, input().split())))
for _ in range(m):
B.append(list(map(int, input().split())))
C = []
B_T = list(zip(*B))
for a_row in A:
C.append([sum(a * b for a, b, in zip(a_row, b_column)) for b_column in B_T])
for row in C:
print(' '.join(map(str, row)))
| 1 | 1,444,194,461,472 | null | 60 | 60 |
import sys
n=int(input())
a=[int(i) for i in sys.stdin.readline().split()]
temps=[a[0]]+[0]*n
mod=1000000007
ans=0
for i in range(1,n):
ans+=temps[i-1]*a[i]
ans%=mod
temps[i]=a[i]+temps[i-1]
print(ans)
|
N=int(input())
K=[int(n) for n in input().split()]
S=sum(K)
total=0
for i in range(N):
S-=K[i]
total+=K[i]*S
print(total %(10**9+7))
| 1 | 3,831,028,941,806 | null | 83 | 83 |
n=int(input())
print((n+999)//1000*1000-n)
|
n=int(input())
print(-n%1000)
| 1 | 8,500,790,728,860 | null | 108 | 108 |
import sys
import math
import itertools
import collections
import heapq
import re
import numpy as np
from functools import reduce
rr = lambda: sys.stdin.readline().rstrip()
rs = lambda: sys.stdin.readline().split()
ri = lambda: int(sys.stdin.readline())
rm = lambda: map(int, sys.stdin.readline().split())
rf = lambda: map(float, sys.stdin.readline().split())
rl = lambda: list(map(int, sys.stdin.readline().split()))
inf = float('inf')
mod = 10**9 + 7
a = [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(a[ri()-1])
|
import math
while True:
n = int(input())
if n == 0:
break
s = input().split(" ")
t = list(map(int,s))
goukei = 0
for i in range(n):
goukei += t[i]
m = goukei / n
sagoukei = 0
for i in range(n):
sagoukei += (t[i]-m)**2
a = math.sqrt(sagoukei/n)
print(a)
| 0 | null | 25,048,878,945,824 | 195 | 31 |
n, r = map(int, input().split())
print(r + 100 * max(0, (10 - n)))
|
def main():
inside_rate, outside_rate = map(int, input().split())
correction = 0
if inside_rate < 10:
correction = 100 * (10 - inside_rate)
print(outside_rate + correction)
main()
| 1 | 63,547,448,514,980 | null | 211 | 211 |
l = []
a,b,c = map(int,input().split())
for i in range(a,b+1):
if c % i == 0:
l.append(i)
ll = len(l)
print(str(ll))
|
n,m=map(int,input().split());print('YNeos'[n!=m::2])
| 0 | null | 41,706,425,458,020 | 44 | 231 |
n,m,x=map(int,input().split())
A=[list(map(int,input().split())) for _ in range(n)]
a=[]
ans=[]
for i in range(2**n):
b=bin(i)[2:].zfill(n)
a.append(b)
for bit in a:
Skills=[]
for i in range(1,1+m):
skill=0
for j in range(n):
if bit[j]=="1":
skill+=A[j][i]
Skills.append(skill)
cost=0
if min(Skills)>=x:
for j in range(n):
if bit[j]=="1":
cost+=A[j][0]
ans.append(cost)
if len(ans)==0:
ans.append(-1)
print(min(ans))
|
a=[input() for i in range(2)]
a1=int(a[0])
a2=[int(i) for i in a[1].split()]
money=1000
kabu=0
for i in range(a1-1):
if a2[i]<a2[i+1]:
kabu=int(money/a2[i])
money+=kabu*(a2[i+1]-a2[i])
print(money)
| 0 | null | 14,744,015,830,528 | 149 | 103 |
import sys
sr = lambda: sys.stdin.readline().rstrip()
ir = lambda: int(sr())
lr = lambda: list(map(int, sr().split()))
def resolve():
N, M = lr()
if N%2 == 1:
for i in range(0, M):
print(f'{2+i} {1+2*M-i}')
else:
k = N//4
for i in range(M):
if i < k:
print(f'{i+1} {N-i}')
else:
print(f'{i+2} {N-i}')
resolve()
|
N,M=map(int,input().split())
x=list(range(1,N+1,1))
if N%2==1:
for i in range(M):
print(x.pop(0),x.pop(-1))
else:
x_f=x[1:int(N/2+1)]
x_l=x[int(N/2+1):]
count=0
for i in range(M):
if len(x_f)>1:
print(x_f.pop(0),x_f.pop(-1))
count+=1
if count==M:
break
if len(x_l)>1:
print(x_l.pop(0),x_l.pop(-1))
count+=1
if count==M:
break
| 1 | 28,591,890,006,540 | null | 162 | 162 |
#
# abc165 c
#
import sys
from io import StringIO
import unittest
sys.setrecursionlimit(100000)
class TestClass(unittest.TestCase):
def assertIO(self, input, output):
stdout, stdin = sys.stdout, sys.stdin
sys.stdout, sys.stdin = StringIO(), StringIO(input)
resolve()
sys.stdout.seek(0)
out = sys.stdout.read()[:-1]
sys.stdout, sys.stdin = stdout, stdin
self.assertEqual(out, output)
def test_入力例_1(self):
input = """3 4 3
1 3 3 100
1 2 2 10
2 3 2 10"""
output = """110"""
self.assertIO(input, output)
def test_入力例_2(self):
input = """4 6 10
2 4 1 86568
1 4 0 90629
2 3 0 90310
3 4 1 29211
3 4 3 78537
3 4 2 8580
1 2 1 96263
1 4 2 2156
1 2 0 94325
1 4 3 94328"""
output = """357500"""
self.assertIO(input, output)
def test_入力例_3(self):
input = """10 10 1
1 10 9 1"""
output = """1"""
self.assertIO(input, output)
def resolve():
global N, M
N, M, Q = map(int, input().split())
ABCD = [list(map(int, input().split())) for _ in range(Q)]
T = []
func([1], T)
ans = 0
for t in T:
score = 0
for abcd in ABCD:
a, b, c, d = abcd
if t[b-1] - t[a-1] == c:
score += d
ans = max(ans, score)
print(ans)
def func(L, T):
if len(L) == N:
T.append(L)
return
for i in range(L[-1], M+1):
NL = L + [i]
func(NL, T)
if __name__ == "__main__":
# unittest.main()
resolve()
|
import itertools
import numpy as np
d_list = []
sum_d = 0
N, M, Q = map(int, input().split())
abcd = [list(map(int, input().split())) for i in range(Q)]
ans = 0
A = [1 for i in range(N)]
for A in itertools.combinations_with_replacement(range(1, M+1), N):
for i in range(Q):
if A[abcd[i][1]-1]-A[abcd[i][0]-1] == abcd[i][2]:
d_list.append(abcd[i][3])
if sum_d <= sum(d_list):
sum_d = sum(d_list)
d_list.clear()
print(sum_d)
| 1 | 27,460,130,071,792 | null | 160 | 160 |
import math
A = []
N = int(input())
count = 0
for n in range(N):
x = int(input())
if x == 2:
A.append(x)
count += 1
elif x % 2 == 0:
pass
elif x > 2:
for i in range(3, int(math.sqrt(x))+2, 2):
if x % i == 0:
break
else:
count += 1
A.append(x)
print(count)
|
c = 0
while True:
try:
n = int(input())
except EOFError:
break
c += 1
for i in range(2, int(n ** 0.5 + 1)):
if n % i == 0:
c -= 1
break
print(c)
| 1 | 10,311,544,240 | null | 12 | 12 |
x = 0
while x == 0:
m = map(int,raw_input().split())
if m[0] == 0 and m[1] == 0:
break
print "#" * m[1]
for i in xrange(m[0]-2):
print "#" + "." * (m[1]-2) + "#"
print "#" * m[1]
print ""
|
S = input()
count = 0
for a, b in zip(S, reversed(S)):
if a != b:
count += 1
print(count // 2)
| 0 | null | 60,360,757,533,360 | 50 | 261 |
import sys
def gcd(m, n):
if n > m:
m, n = n, m
if n == 0:
return m
else:
return gcd(n, m % n)
for line in sys.stdin:
try:
a, b = [int(i) for i in line.split()]
g = gcd(a, b)
l = a * b / g
print("%d %d" % (g, l))
except:
break
|
NML = input().split()
n = int(NML[0])
m = int(NML[1])
l = int(NML[2])
A = []
B = []
for i in range(n):
A.append([])
A_r = input().split()
for j in range(m):
A[i].append(int(A_r[j]))
for i in range(m):
B.append([])
B_r= input().split()
for j in range(l):
B[i].append(int(B_r[j]))
for i in range(n):
for j in range(l):
out=0
for k in range(m):
out +=A[i][k]*B[k][j]
print(str(out),end="")
if j != l-1:
print(" ",end="")
print("")
| 0 | null | 728,395,503,344 | 5 | 60 |
#K = input()
NR = list(map(int, input().split()))
#s = input().split()
#N = int(input())
if (NR[0] >= 10):
print(NR[1])
else:
print(NR[1] + 100 * (10 - NR[0]))
|
a, b, c = map(int, input().split())
l = []
for i in range(1, c+1):
if c%i==0:
l.append(i)
res = 0
for i in range(a, b+1):
if i in l:
res+=1
print(res)
| 0 | null | 31,996,327,206,712 | 211 | 44 |
import sys
stdin = sys.stdin
sys.setrecursionlimit(10**6)
ni = lambda: int(ns())
na = lambda: list(map(int, stdin.readline().split()))
nn = lambda: list(stdin.readline().split())
ns = lambda: stdin.readline().rstrip()
n,s = na()
a = na()
mod = 998244353
dp = [0]*(s+1)
dp[0] = 1
for i in range(n):
pd = [0]*(s+1)
for j in range(s+1):
if j+a[i] <= s:
pd[j+a[i]] += dp[j]
pd[j] += dp[j]*2%mod
dp = pd
print(dp[s]%mod)
|
import math
a, b, c = map(int, input().split())
d = math.ceil(a / b)
print(d * c)
| 0 | null | 11,046,182,670,780 | 138 | 86 |
X,N = map(int,input().split())
min = 100
if N !=0:
Plist = list(map(int,input().split()))
anslist = [i for i in range(102)]
anslist.append(-1)
#anslist.remove(0)
Plist = sorted(Plist)
#print (anslist)
for i in range(N):
anslist.remove(Plist[i])
temp =100
for i in range(len(anslist)):
if min >abs(anslist[i]-X) :
min = abs(anslist[i]-X)
temp = anslist[i]
print (temp)
else :
print (X)
|
n=int(input())
l=list(map(int,input().split()))
a=[]
for i in range(n):
a.append(0)
for i in range(n-1):
a[l[i]-1]+=1
for i in range(n):
print(a[i])
| 0 | null | 23,190,962,124,288 | 128 | 169 |
import sys
import math
import itertools
import collections
import heapq
import re
import numpy as np
rr = lambda: sys.stdin.readline().rstrip()
rs = lambda: sys.stdin.readline().split()
ri = lambda: int(sys.stdin.readline())
rm = lambda: map(int, sys.stdin.readline().split())
rl = lambda: list(map(int, sys.stdin.readline().split()))
inf = float('inf')
mod = 10**9 + 7
n, m, q = rm()
li = [rl() for _ in range(q)]
max_ = 0
for A in list(itertools.combinations_with_replacement(list(range(1, m+1)), n)):
score = 0
for abcd in li:
a, b, c, d = abcd
a -= 1
b -= 1
if A[b] - A[a] == c:
score += d
else:
max_ = max(score, max_)
print(max_)
|
number=list(map(int,input().split()))
n,m,q=number[0],number[1],number[2]
nums=[]
for i in range(q):
tmp=list(map(int,input().split()))
nums.append(tmp)
answer=0
mid=0
List1=[]
for i in range(m):
List1.append(i)
import itertools
for i in list(itertools.combinations_with_replacement(List1,n)):
mid=0
for j in range(q):
if i[nums[j][1]-1]-i[nums[j][0]-1]==nums[j][2]:
mid+=nums[j][3]
answer=max(mid,answer)
print(answer)
| 1 | 27,649,814,521,802 | null | 160 | 160 |
H1,M1,H2,M2,K=map(int, input().split())
M1 += H1*60
M2 += H2*60
print(M2-M1-K)
|
H1, M1, H2, M2, K = map(int, input().split())
ans = H2*60 + M2 - H1*60 - M1 - K
print(ans)
| 1 | 18,095,366,432,950 | null | 139 | 139 |
n = int(input())
l = sorted(list(map(int, input().split())))
ans = 0
import bisect
for i in range(n-2):
for j in range(i+1, n-1):
ab = l[i]+l[j]
idx = bisect.bisect_left(l, ab)
ans += max(0, idx-j-1)
print(ans)
|
import bisect
N = int(input())
L = list(map(int,input().split()))
L = sorted(L,reverse = False)
cnt = 0
# a の index
for a in range(len(L)):
# b の index
for b in range(a+1,len(L)):
# c が取りうる最大の index
c_idx = bisect.bisect_left(L,L[a]+L[b]) - 1
cnt += c_idx - b
print(cnt)
| 1 | 171,883,262,047,380 | null | 294 | 294 |
import sys
input = sys.stdin.readline
def I(): return int(input())
def MI(): return map(int, input().split())
def LI(): return list(map(int, input().split()))
def main():
mod=10**9+7
N,a,b=MI()
M=2*(10**5) + 5
def cmb(n, r):
if n - r < r: r = n - r
if r == 0: return 1
if r == 1: return n
numerator = [n - r + k + 1 for k in range(r)]
denominator = [k + 1 for k in range(r)]
for p in range(2,r+1):
pivot = denominator[p - 1]
if pivot > 1:
offset = (n - r) % p
for k in range(p-1,r,p):
numerator[k - offset] /= pivot
denominator[k] /= pivot
result = 1
for k in range(r):
if numerator[k] > 1:
result *= int(numerator[k])
result%=mod
return result
ans=pow(2,N,mod)-1
ans-=cmb(N,a)
ans-=cmb(N,b)
print(ans%mod)
main()
|
n, a, b = map(int, input().split())
MOD = 10 ** 9 + 7
def modinv(x, mod):
return pow(x, mod-2, mod)
modinv_table = [-1] * (b+1)
for i in range(1, b+1):
modinv_table[i] = modinv(i, MOD)
def comb(n, k, mod):
ans = 1
for i in range(k):
ans *= n-i
ans *= modinv_table[i + 1]
ans %= mod
return ans
ans = (pow(2, n, MOD) - comb(n, a, MOD) - comb(n, b, MOD)) % MOD - 1
print(ans)
| 1 | 66,201,934,512,032 | null | 214 | 214 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.