code1
stringlengths 17
427k
| code2
stringlengths 17
427k
| similar
int64 0
1
| pair_id
int64 2
181,637B
⌀ | question_pair_id
float64 3.7M
180,677B
⌀ | code1_group
int64 1
299
| code2_group
int64 1
299
|
|---|---|---|---|---|---|---|
def main():
a = map(int, input().split(" "))
print("bust" if sum(a) >= 22 else "win")
main()
|
from sys import stdin,stdout
def INPUT():return list(int(i) for i in stdin.readline().split())
def inp():return stdin.readline()
def out(x):return stdout.write(x)
import math
import random
J=998244353
########################################################
n,k=INPUT()
A=[]
for i in range(k):
x,y=INPUT()
A.append([x,y])
A.sort()
s,e=-1,-1
S=[]
for i in range(len(A)):
if i==0:
S.append([A[i][0],A[i][1]])
else:
if A[i][0]>S[-1][1]:
S.append([A[i][0],A[i][1]])
else:
S[-1][1]=A[i][1]
cum=[0]*(n+1)
dp=[0]*(n+1)
dp[1]=1
cum[1]=1
for i in range(2,n+1):
for ele in S:
x=ele[0]
y=ele[1]
dp[i]=(dp[i]+cum[max(i-x,0)]-cum[max(0,i-y-1)])%J
cum[i]=(cum[i-1]+dp[i])%J
print(dp[n])
| 0 | null | 60,971,015,266,480 | 260 | 74 |
n = [int(i) for i in input().split()]
print(max(n[0] - 2*n[1], 0))
|
a,b = map(int,input().split())
ans = a-b*2
if ans<=0:
print(0);exit()
else:
print(ans)
| 1 | 166,306,370,037,080 | null | 291 | 291 |
a,b = map(int,input().split())
print(a*b if a<=9 and b<=9 else -1)
|
# 与えられた数値の桁数と桁値の総和を計算する.
def calc_digit_sum(num):
digits = sums = 0
while num > 0:
digits += 1
sums += num % 10
num //= 10
return digits, sums
a, b = map(int, input().split())
if 1 <= a <= 9 and 1 <= b <= 9:
print(a * b)
exit()
print(-1)
| 1 | 158,487,687,146,970 | null | 286 | 286 |
import sys
import numba as nb
import numpy as np
input = sys.stdin.readline
@nb.njit("i8(i8[:], i8)", cache=True)
def binary_search(a, key):
"""Meguru type binary search"""
ng = -1
ok = len(a)
while (abs(ok - ng) > 1):
mid = (ok + ng) // 2
if a[mid] >= key:
ok = mid
else:
ng = mid
return ok
@nb.njit("i8(i8, i8[:])", cache=True)
def solve(N, L):
L.sort()
ans = 0
for a in range(N - 2):
for b in range(a + 1, N - 1):
c = binary_search(L, L[a] + L[b]) - 1
ans += c - b
return ans
def main():
N = int(input())
L = np.array(input().split(), dtype=np.int64)
ans = solve(N, L)
print(ans)
if __name__ == "__main__":
main()
|
def main():
num = int(input())
print(1-((int(num/2)/num)))
main()
| 0 | null | 174,832,611,366,512 | 294 | 297 |
for i in sorted([input() for _ in xrange(10)])[:-4:-1]: print i
|
high=[0 for i in range(10)]
for i in range(10):
high[i]=int(input())
ans=[0 for i in range(3)]
for i in range(3):
ans[i]=max(high)
high.remove(ans[i])
print(ans[i])
| 1 | 23,190,272 | null | 2 | 2 |
n = int(input())
def dfs(s, mx):
if len(s) == n:
print(s)
return
for c in range(ord("a"), mx+2):
dfs(s+chr(c), max(mx, c))
dfs("", ord("a")-1)
|
N = int(input())
# 最後の数字+1以下じゃないとだめ
# abc -> 次はa,b,c,d
dic = ["a","b","c","d","e","f","g","h","i","j"]
strs = ["a"]
cnt = 1
while cnt < N:
tmps = []
for s in strs:
for i,d in enumerate(dic[::-1]):
if d in s:
ind = len(dic)-i-1
break
# print(s,ind,dic[i])
for i in range(ind+2):
tmps.append(s+dic[i])
cnt += 1
strs = tmps[:]
for s in strs:
print(s)
| 1 | 52,457,311,983,622 | null | 198 | 198 |
L,R,d=map(int,input().split())
count=0
for num in range(L,R+1):
if num%d==0:
count+=1
print(count)
|
L, R, d = map(int, input().split())
count = 0
if ((L and R and d >=1) and (L and R and d <= 100) ):
for L in range(L, R+1):
if (L%d == 0):
count +=1
print(count)
| 1 | 7,456,420,614,500 | null | 104 | 104 |
import sys
k = int(input())
a =7%k
if a == 0:
print(1)
sys.exit()
for i in range(2,10**7):
a = (10*a+7) % k
if a == 0:
print(i)
sys.exit()
print(-1)
|
K = int(input())
a = [0]*1000001
ans = -1
a[1] = 7%K
for i in range(2,K+1):
a[i] = (10*a[i-1]+7)%K
for i in range(1,K+1):
if a[i] == 0:
ans = i
print(i)
break
if ans == -1:
print(-1)
| 1 | 6,129,086,739,650 | null | 97 | 97 |
i=1
x = int(input())
while x != 0 :
print("Case {0}: {1}".format(i, x))
x = int(input())
i=i+1
|
case = 1
x = input()
while(x!=0):
print "Case %d: %d" % (case, x)
x = input()
case += 1
| 1 | 476,672,417,600 | null | 42 | 42 |
def ABC_145_A():
r = int(input())
print(r*r)
if __name__ == '__main__':
ABC_145_A()
|
r=int(input())
print(int(pow(r,2)))
| 1 | 145,117,571,639,676 | null | 278 | 278 |
import sys, bisect
N = int(input())
L = list(map(int, sys.stdin.readline().rsplit()))
L.sort()
res = 0
for i in reversed(range(1, N)):
for j in reversed(range(i)):
l = bisect.bisect_left(L, L[i] + L[j])
# r = bisect.bisect_right(L, abs(L[i] - L[j]))
res += l - 1 - i
print(res)
|
from sys import stdin
from itertools import product
suits = ['S', 'H', 'C', 'D']
suits_priority = {
'S': 1,
'H': 2,
'C': 3,
'D': 4
}
ranks = list(range(1, 14))
original_deck = set(product(suits, ranks))
if __name__ == '__main__':
n = int(stdin.readline().rstrip())
deck = set()
for _ in range(n):
suit, rank = stdin.readline().rstrip().split()
deck.add((suit, int(rank)))
diff = list(original_deck - deck)
diff.sort(key=lambda x: x[1])
diff.sort(key=lambda x: suits_priority[x[0]])
for card in diff:
print("{} {}".format(*card))
| 0 | null | 86,360,380,172,192 | 294 | 54 |
def main():
name = list(map(str,input().split()))
num = list(map(int,input().split()))
n = input()
if n==name[0]:
print(num[0]-1,num[1])
else:
print(num[0],num[1]-1)
main()
|
def solve():
S,T = input().split()
A,B = [int(i) for i in input().split()]
U = input()
if U == S:
print(A-1, B)
else:
print(A, B-1)
if __name__ == "__main__":
solve()
| 1 | 71,733,710,743,774 | null | 220 | 220 |
n = int(input())
a = list(map(int, input().split()))
a.sort(reverse=True)
if 0 in a:
print(0)
exit()
ans = 1
for i in a:
ans *= i
if ans > 10**18:
print(-1)
exit()
print(ans)
|
def main():
N = int(input())
A = list(map(int,input().split()))
if 0 in A:
return 0
ans = 1
for i in A:
ans*=i
if ans > 10**18:
return -1
return ans
print(main())
| 1 | 16,292,262,033,930 | null | 134 | 134 |
while True:
n=int(input())
if n==0:break
s=list(map(float,input().split()))
print((sum(map(lambda x: x*x,s))/n-(sum(s)/n)**2)**.5)
|
import math
result = []
n = int(input())
while n != 0:
d = list(map(int, input().split()))
mean = sum(d) / n
var = [(i - mean) ** 2 for i in d]
var = math.sqrt(sum(var) / n)
result.append(var)
n = int(input())
for i in result:
print(i)
| 1 | 195,506,880,306 | null | 31 | 31 |
import copy
class Dice(object):
def __init__(self,List):
self.face=List
def n_spin(self,a_list):
List=copy.copy(a_list)
temp=List[0]
List[0]=List[1]
List[1]=List[5]
List[5]=List[4]
List[4]=temp
return List
def s_spin(self,a_list):
List=copy.copy(a_list)
temp=List[0]
List[0]=List[4]
List[4]=List[5]
List[5]=List[1]
List[1]=temp
return List
def e_spin(self,a_list):
List=copy.copy(a_list)
temp=List[0]
List[0]=List[3]
List[3]=List[5]
List[5]=List[2]
List[2]=temp
return List
def w_spin(self,a_list):
List = copy.copy(a_list)
temp=List[0]
List[0]=List[2]
List[2]=List[5]
List[5]=List[3]
List[3]=temp
return List
dice=Dice(map(int,raw_input().split()))
emer=copy.copy(dice.face)
face_storage=[]
face_storage.append(emer)
q=input()
for a in range(q):
question=map(int,raw_input().split())
for a in range(24):
face_storage.append(dice.n_spin(face_storage[a]))
face_storage.append(dice.s_spin(face_storage[a]))
face_storage.append(dice.e_spin(face_storage[a]))
face_storage.append(dice.w_spin(face_storage[a]))
for c in face_storage:
if c[0]==question[0] and c[1]==question[1]:
print(c[2])
break
|
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())
| 1 | 247,771,229,660 | null | 34 | 34 |
import sys
input = sys.stdin.readline
a, b = map(int, input().split())
print(abs(a * b) // __import__('math').gcd(a, b))
|
import sys
def input(): return sys.stdin.readline().strip()
def mapint(): return map(int, input().split())
sys.setrecursionlimit(10**9)
A, B = mapint()
from math import gcd
print(A*B//gcd(A, B))
| 1 | 113,348,170,388,710 | null | 256 | 256 |
#11_A
import random
class Dice:
def __init__(self):
self.dice=[i for i in range(6)]
self.workspace=[i for i in range(6)]
self.top=self.dice=[0]
def set(self,numbers):
self.dice=[i for i in numbers]
self.workspace=[i for i in numbers]
def rotate(self,command):
if command == "W":
self.workspace=[self.dice[2], self.dice[1], self.dice[5], self.dice[0], self.dice[4], self.dice[3]]
self.dice=self.workspace
elif command == "E":
self.workspace=[self.dice[3], self.dice[1], self.dice[0], self.dice[5], self.dice[4], self.dice[2]]
self.dice = self.workspace
if command == "S":
self.workspace=[self.dice[4], self.dice[0], self.dice[2], self.dice[3], self.dice[5], self.dice[1]]
self.dice=self.workspace
elif command == "N":
self.workspace=[self.dice[1], self.dice[5], self.dice[2], self.dice[3], self.dice[0], self.dice[4]]
self.dice=self.workspace
def get_top(self):
self.top=self.dice[0]
print(self.top)
def predict(self, num):
for i in range(num):
top, front = map(int, input().split())
while(True):
if top == self.dice[0] and front == self.dice[1]:
break
command_num=random.randint(1,4)
if command_num == 1:
self.rotate("W")
elif command_num == 2:
self.rotate("E")
elif command_num == 3:
self.rotate("S")
elif command_num == 4:
self.rotate("N")
print(self.dice[2])
def getter(self):
return self.dice[0], self.dice[1], self.dice[2]
def predict_same(self, top, front, right):
for n in range(30):
if top ==self.dice[0] and front== self.dice[1] and right ==self.dice[2]:
print("Yes")
break
command_num=random.randint(1,4)
if command_num == 1:
self.rotate("W")
elif command_num == 2:
self.rotate("E")
elif command_num == 3:
self.rotate("S")
elif command_num == 4:
self.rotate("N")
if top!=self.dice[0] or front!=self.dice[1] or front!=self.dice[2]:
print("No")
numbers=list(map(int,input().split()))
dice=Dice()
dice.set(numbers)
# commands=input()
# for i in range(len(commands)):
# dice.rotate(commands[i])
# dice.get_top()
q=int(input())
dice.predict(q)
|
from sys import stdin
from copy import deepcopy
import queue
class Dice:
def __init__(self, nums):
self.labels = [None] + [ nums[i] for i in range(6) ]
self.pos = {
"E" : 3,
"W" : 4,
"S" : 2,
"N" : 5,
"T" : 1,
"B" : 6
}
def rolled(dice, queries):
d = deepcopy(dice)
for q in queries:
if q == "E":
d.pos["T"], d.pos["E"], d.pos["B"], d.pos["W"] = d.pos["W"], d.pos["T"], d.pos["E"], d.pos["B"]
elif q == "W":
d.pos["T"], d.pos["E"], d.pos["B"], d.pos["W"] = d.pos["E"], d.pos["B"], d.pos["W"], d.pos["T"]
elif q == "S":
d.pos["T"], d.pos["S"], d.pos["B"], d.pos["N"] = d.pos["N"], d.pos["T"], d.pos["S"], d.pos["B"]
elif q == "N":
d.pos["T"], d.pos["S"], d.pos["B"], d.pos["N"] = d.pos["S"], d.pos["B"], d.pos["N"], d.pos["T"]
else:
return d
nums = [int(x) for x in stdin.readline().rstrip().split()]
q = int(stdin.readline().rstrip())
dice = Dice(nums)
# TとSに対応するクエリを記憶し, resをすぐに呼び出せるようにする
memo = [[False] * 7 for i in range(7)]
memo[dice.pos["T"]][dice.pos["S"]] = ""
# クエリとさいころの東面を記憶
res = { "" : dice.labels[dice.pos["E"]] }
# BFSで探索, 解を求めたらreturn Trueで抜け出す
# diceの中身をいじってはならない
def solve(T, S):
que = queue.Queue()
que.put(dice)
sol_q = ["E", "N", "S", "W"]
while not que.empty():
d = que.get()
if d.pos["T"] == T and d.pos["S"] == S:
break
else:
for i in sol_q:
d_next = Dice.rolled(d, i)
que.put(d_next)
memo[d_next.pos["T"]][d_next.pos["S"]] = memo[d.pos["T"]][d.pos["S"]] + i
res[memo[d_next.pos["T"]][d_next.pos["S"]]] = d_next.labels[d_next.pos["E"]]
else:
return memo[T][S]
for i in range(q):
ts = [int(x) for x in stdin.readline().rstrip().split()]
T = dice.labels.index(ts[0])
S = dice.labels.index(ts[1])
if solve(T, S) != False:
print(res[memo[T][S]])
| 1 | 260,530,754,306 | null | 34 | 34 |
kx=input().rstrip().split(" ")
k=int(kx[0])
x=int(kx[1])
if 500*k>=x:
print("Yes")
else:
print("No")
|
n, m = map(int, input().split(" "))
if n <= 9:
print(m + (100 * (10 - n)))
else:
print(m)
| 0 | null | 80,633,106,561,700 | 244 | 211 |
def LI():
return list(map(int,input().split()))
h,n=LI()
a=[]
b=[]
for _ in range(n):
x,y=LI()
a.append(x)
b.append(y)
INF=10**15
dp=[INF]*(h+max(a)+10)
dp[0]=0
for i in range(0,h+1):
for j,k in zip(a,b):
dp[i+j]=min(dp[i+j],dp[i]+k)
ans=INF
for i in dp[h:]:
ans=min(ans,i)
print(ans)
|
N, M = map(int, input().split())
A = list(map(int, input().split()))
dp = [[1<<60]*(N+1) for _ in range(M+1)]
dp[0][0] = 0
for i in range(M):
for j in range(N+1):
if A[i] <= j:
dp[i+1][j] = min(dp[i][j], dp[i+1][j-A[i]] + 1)
else:
dp[i + 1][j] = dp[i][j]
print(dp[M][N])
| 0 | null | 40,556,846,983,212 | 229 | 28 |
import math
k = int(input())
sum_gcd = 0
for a in range(1,k+1):
for b in range(1,k+1):
for c in range(1,k+1):
sum_gcd += math.gcd(math.gcd(a,b) , c)
print(sum_gcd)
|
#!/usr/bin/python3
import bisect
n = int(input())
s = input()
q = int(input())
idxs = [ [] for i in range(26) ]
sl = [ s[i] for i in range(n) ]
for i in range(n):
idxs[ord(s[i]) - ord('a')].append(i + 1)
#print(idxs)
qs = []
for i in range(q):
qs.append(input())
for qi in qs:
(op, x, y) = qi.split()
if op == '1':
j = int(x)
c = y
oc = sl[j - 1]
if oc != c:
sl[j - 1] = c
idx = bisect.bisect_left(idxs[ord(oc) - ord('a')], j)
del idxs[ord(oc) - ord('a')][idx]
idx = bisect.bisect_left(idxs[ord(c) - ord('a')], j)
idxs[ord(c) - ord('a')].insert(idx, j)
elif op == '2':
l = int(x)
r = int(y)
c = 0
for i in range(26):
il = bisect.bisect_left(idxs[i], l)
ir = bisect.bisect_right(idxs[i], r)
if il < ir:
c += 1
print(c)
| 0 | null | 49,134,618,473,462 | 174 | 210 |
#coding: UTF-8
def Sort(a,b,c):
box = 0
if a > b:
box = b
b = a
a = box
if b > c:
box = c
c = b
b = box
if a > b:
box = b
b = a
a = box
return a,b,c
if __name__=="__main__":
a = input().split(" ")
a,b,c = Sort(int(a[0]),int(a[1]),int(a[2]))
print(str(a)+" "+str(b)+" "+str(c))
|
def f(nums, K, w):
h=len(nums)
counter=[nums[x][0] for x in range(h)]
if max(counter)>K:
return float('inf')
out=0
for i in range(1, w):
for x in range(h):
counter[x]+=nums[x][i]
if max(counter)>K:
out+=1
counter=[nums[x][i] for x in range(h)]
return out
H, W, K=map(int, input().split())
S=[input() for _ in range(H)]
S=[[int(S[i][j]) for j in range(W)] for i in range(H)]
ans=float('inf')
for p in range(2**(H-1)):
q='0'+format(p, '0'+str(H-1)+'b')+'1'
i=0
c=0
nums=[]
while i<H:
j=1
while i+j<H and q[i+j]=='0':
j+=1
tmp=S[i:i+j]
nums.append([sum([tmp[y][x] for y in range(j)]) for x in range(W)])
i+=j
cand=f(nums, K, W)+q.count('1')-1
if ans>cand:
ans=cand
print(ans)
| 0 | null | 24,615,509,799,520 | 40 | 193 |
S = int(input())
h = S // (60 * 60)
m = (S % (60*60)) // 60
s = S % 60
# セパレータ(sep)は":" を用いる
print(h, m, s, sep=":")
|
import sys
S = int(sys.stdin.readline())
h = S / 3600
m = (S - h*3600)/60
s = S - h*3600 - m*60
print("%d:%d:%d" % (h,m,s))
| 1 | 331,392,997,390 | null | 37 | 37 |
s,w = map(int, input().split())
ans = ['unsafe' if w >= s else 'safe']
print(ans[0])
|
# -*- coding: utf-8 -*-
"""
Created on Mon Aug 24 12:23:05 2020
@author: vivek
"""
n,d=[int(i) for i in input().strip().split(" ")]
ans=0
for _ in range(n):
x,y=[int(i) for i in input().strip().split(" ")]
if x*x+y*y<=d*d:
ans+=1
print(ans)
| 0 | null | 17,520,507,156,320 | 163 | 96 |
from collections import deque
def init_tree(x, par):
for i in range(x + 1):
par[i] = i
def find(x, par):
q = deque()
q.append(x)
while len(q) > 0:
v = q.pop()
if v == par[v]:
return v
q.append(par[v])
def union(x, y, par, rank):
px, py = find(x, par), find(y, par)
if px == py:
return
if rank[px] < rank[py]:
par[px] = py
return
elif rank[px] == rank[py]:
rank[px] += 1
par[py] = px
n, m, k = map(int, input().split())
par = [0] * (n + 1)
rank = [0] * (n + 1)
init_tree(n, par)
eg = [[] for _ in range(n + 1)]
for _ in range(m):
a, b = map(int, input().split())
union(a, b, par, rank)
eg[a].append(b)
eg[b].append(a)
for _ in range(k):
a, b = map(int, input().split())
eg[a].append(b)
eg[b].append(a)
xs = [0] * (n + 1)
ys = [0] * (n + 1)
for i in range(1, n + 1):
p = find(i, par)
xs[p] += 1
for v in eg[i]:
if p == find(v, par):
ys[i] += 1
ans = [-1] * (n + 1)
for i in range(1, n + 1):
ans[i] += xs[find(i, par)] - ys[i]
print(*ans[1:])
|
from functools import reduce
from math import gcd, sqrt,ceil
n = int(input())
a = list(map(int,input().split()))
m = 10**6
a_gcd = reduce(gcd,a)
if a_gcd != 1:
print("not coprime")
exit(0)
isset = a_gcd == 1
hurui = [i for i in range(m+1)]
for i in range(2,ceil(sqrt(m))+1):
for j in range(2,ceil(sqrt(i))+1):
if i==2:
continue
if i%j == 0:
break
else:
for k in range(i+i,m,i):
if hurui[k] != k:
continue
hurui[k] = i
continue
s = set()
p_f = True
for ai in a:
t = set()
while(ai > 1):
t.add(hurui[ai])
ai //= hurui[ai]
for ti in t:
if ti in s:
print("setwise coprime")
exit(0)
else:
s.add(ti)
print("pairwise coprime")
| 0 | null | 32,647,827,876,498 | 209 | 85 |
# -*-coding:utf-8
def main():
n, m, l = map(int, input().split())
A = []
B = []
for i in range(n):
A.append(list(map(int, input().split())))
for i in range(m):
B.append(list(map(int, input().split())))
Ans = []
for i in range(n):
row = []
for j in range(l):
rowSum = 0
for k in range(m):
rowSum += A[i][k] * B[k][j]
row.append(rowSum)
Ans.append(row)
for i in range(n):
print(' '.join([str(a) for a in Ans[i]]))
if __name__ == '__main__':
main()
|
x, n = map(int,input().split())
L = list(map(int,input().split()))
if n == 0 or x not in L:
print(x)
exit()
for i in range(102):
if (x-i) not in L:
print(x-i)
break
elif (x+i) not in L:
print(x+i)
break
| 0 | null | 7,713,469,149,148 | 60 | 128 |
# import sys
# import math
# import itertools
# from collections import deque
# from collections import defaultdict
# import heapq
# import copy
# import bisect
# import numpy as np
# from scipy.special import comb
# def my_input(): return sys.stdin.readline().rstrip()
# sys.setrecursionlimit(100000)
# INF = 1001001001001
# MOD = 1000000007
class UnionFind():
def __init__(self, n):
self.n = n
self.parents = [-1] * n
def find(self, x):
if self.parents[x] < 0:
return x
else:
self.parents[x] = self.find(self.parents[x])
return self.parents[x]
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
def size(self, x):
return -self.parents[self.find(x)]
def same(self, x, y):
return self.find(x) == self.find(y)
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())
def main():
N, M, K = map(int, input().split())
uf = UnionFind(N)
friends = [set() for _ in range(N)]
for _ in range(M):
a, b = map(int, input().split())
a, b = a - 1, b - 1
uf.union(a, b)
friends[a] |= set([b])
friends[b] |= set([a])
blocks = [set() for _ in range(N)]
for _ in range(K):
c, d = map(int, input().split())
c, d = c - 1, d - 1
if uf.same(c, d):
blocks[c] |= set([d])
blocks[d] |= set([c])
# print(uf)
# print(friends)
# print(blocks)
for i in range(N - 1):
ans = uf.size(i) - 1 - len(friends[i]) - len(blocks[i])
print(str(ans) + " ", end="")
ans = uf.size(N - 1) - 1 - len(friends[N - 1]) - len(blocks[N - 1])
print(ans)
if __name__ == '__main__':
main()
|
for i in range(1,10):
for z in range(1,10):
a = i * z
print(str(i) + "x" + str(z) + "=" + str(a))
| 0 | null | 30,867,540,252,708 | 209 | 1 |
class UnionFind():
def __init__(self, n):
self.n = n
self.parents = [-1] * n
def find(self, x):
if self.parents[x] < 0:
return x
else:
self.parents[x] = self.find(self.parents[x])
return self.parents[x]
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
def size(self, x):
return -self.parents[self.find(x)]
def same(self, x, y):
return self.find(x) == self.find(y)
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())
N,M,K=map(int,input().split())
uf = UnionFind(N+1)
remove = [0]*(N+1)
for i in range(M):
A,B=map(int,input().split())
uf.union(A,B)
remove[A] +=1
remove[B] +=1
for i in range(K):
A,B=map(int,input().split())
if uf.same(A,B):
remove[A] +=1
remove[B] +=1
ANS = [0]*(N+1)
for i in range(0,N+1):
ANS[i] = uf.size(i) - remove[i] - 1
ANS.pop(0)
print(*ANS)
|
class UnionFind:
def __init__(self, n):
self.n = n
self.parents = [-1] * n
def find(self, x):
if self.parents[x] < 0:
return x
else:
self.parents[x] = self.find(self.parents[x])
return self.parents[x]
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
def size(self, x):
return -self.parents[self.find(x)]
def same(self, x, y):
return self.find(x) == self.find(y)
n, m, k = map(int, input().split())
u = UnionFind(n + 1)
already = [0] * (n + 1)
for i in range(m):
a, b = map(int, input().split())
u.union(a, b)
already[a] += 1
already[b] += 1
for i in range(k):
c, d = map(int, input().split())
if u.same(c, d):
already[c] += 1
already[d] += 1
for i in range(1, n + 1):
print(u.size(i) - already[i] - 1)
| 1 | 61,461,184,154,260 | null | 209 | 209 |
n = int(input())
A = list(map(int, input().split()))
A.sort()
freq = [0] * (10**6+1)
for a in A:
freq[a] += 1
m = A[-1]
ans = n
for i in range(n):
a = A[i]
if freq[a] > 1:
ans -= freq[a]
freq[a] = 0
for j in range(2 * a, m+1, a):
if freq[j] > 0 and j % a == 0:
ans -= freq[j]
freq[j] = 0
print (ans)
|
while 1:
n = int(input())
if n == 0:
break
L = list(map(int, input().split()))
mean = sum(L) / len(L)
V = sum((s - mean) ** 2 for s in L) / len(L)
print(V ** 0.5)
| 0 | null | 7,340,339,091,108 | 129 | 31 |
import math, itertools
n = int(input())
X = list(list(map(int,input().split())) for _ in range(n))
L = list(itertools.permutations(range(n),n))
ans = 0
for l in L:
dist = 0
for i in range(n-1):
s,t = l[i],l[i+1]
vx = X[s][0] - X[t][0]
vy = X[s][1] - X[t][1]
dist += math.sqrt(vx**2 + vy**2)
ans += dist
print(ans/len(L))
|
import sys
import math
import itertools
from collections import defaultdict, deque
from copy import deepcopy
input = sys.stdin.readline
def RD(): return input().rstrip()
def F(): return float(input().rstrip())
def I(): return int(input().rstrip())
def MI(): return map(int, input().split())
def MF(): return map(float,input().split())
def LI(): return tuple(map(int, input().split()))
def LF(): return list(map(float,input().split()))
def Init(H, W, num): return [[num for i in range(W)] for j in range(H)]
def main():
N = I()
mylist = [LI() for i in range(N)]
dist = [[0 for i in range(N)] for i in range(N)]
for index1, num1 in enumerate(mylist):
for index2, num2 in enumerate(mylist):
dist[index1][index2] = math.sqrt((num1[0]-num2[0])**2 + (num1[1]-num2[1])**2)
result = 0
index = 0
seq = [i for i in range(N)]
for i in itertools.permutations(seq):
index += 1
past = i[0]
for num in i[1:]:
result += dist[past][num]
past = num
print(result/index)
if __name__ == "__main__":
main()
| 1 | 148,589,434,177,542 | null | 280 | 280 |
from sys import stdin
input = stdin.readline
def main():
N, K = list(map(int, input().split()))
R, S, P = list(map(int, input().split()))
T = input()[:-1]
mem = []
hand_map = {'r': 'p', 's': 'r', 'p': 's'}
score_map = {'r': P, 's': R, 'p': S}
score = 0
for i in range(K):
mem.append(hand_map[T[i]])
score += score_map[T[i]]
for i in range(K, N):
if not mem[i-K] == hand_map[T[i]]:
mem.append(hand_map[T[i]])
score += score_map[T[i]]
continue
cand = ['r', 's', 'p']
# print(mem[i-K])
cand.remove(mem[i-K])
if i+K < N and not(mem[i-K] == hand_map[T[i+K]]):
cand.remove(hand_map[T[i+K]])
mem.append(cand[0])
print(score)
if(__name__ == '__main__'):
main()
|
S = int(input())
print(S // 3600, S // 60 % 60, S % 60, sep = ':')
| 0 | null | 53,544,559,359,984 | 251 | 37 |
n = int(input())
A = list(map(int,input().split()))
UA = set(A)
print('YES' if len(A) == len(UA) else 'NO')
|
n=int(input())
b=list(map(int,input().split()))
b.sort()
for i in range(n-1):
if b[i]==b[i+1]:
print("NO")
break
if i==n-2:
print("YES")
| 1 | 74,021,974,613,808 | null | 222 | 222 |
a,b = map(str,input().split())
ans = ''
if int(a) > int(b):
for _ in range(int(a)):
ans += b
else:
for _ in range(int(b)):
ans += a
print(ans)
|
from collections import defaultdict
def main():
d = defaultdict(int)
d2 = defaultdict(int)
N = int(input())
A = list(map(int, input().split()))
for i in range(N):
d[i + 1 + A[i]] += 1
d2[max(0, (i + 1) - A[i])] += 1
ans = 0
for k,v in d.items():
if k == 0:continue
ans += v * d2[k]
print(ans)
if __name__ == '__main__':
main()
| 0 | null | 54,956,063,009,740 | 232 | 157 |
n = int(raw_input())
a = map(int, raw_input().split())
print "%d %d %d" % (min(a), max(a), sum(a))
|
sum = 0
n = input()
num = sorted(list(map(int, input().split())))
for i in range(int(n)):
sum += num[i]
print("{} {} {}".format(num[0], num[-1], sum))
| 1 | 723,277,644,112 | null | 48 | 48 |
#distance
import math
x1,y1,x2,y2=map(float,input().split())
distance = math.sqrt((x2-x1)**2+(y2-y1)**2)
print(distance)
|
import math
x1,y1,x2,y2=map(float,input().split())
z = (x2-x1)**2 + (y2-y1)**2
kyori = math.sqrt(z)
print(kyori)
| 1 | 162,203,871,610 | null | 29 | 29 |
X,Y=sorted(list(map(int,input().split())))
#移動方法を(i+1,j),(i,j+1)となるようにどうにかする
if (X-abs(Y-X))%3!=0 or X*2<Y:
print(0)
exit(0)
n=(X-abs(Y-X))//3
X=n+abs(Y-X)
Y=n
mod=10**9+7
a=1
for i in range(1,X+Y+1):
a*=i
a%=mod
b=1
for i in range(1,X+1):
b*=i
b%=mod
c=1
for i in range(1,Y+1):
c*=i
c%=mod
print(a*pow(b,-1,mod)*pow(c,-1,mod)%mod)
|
X, Y = map(int, input().split())
m, r = divmod(2*Y-X, 3)
if r != 0:
print(0)
exit()
n = Y - 2*m
if n < 0 or m < 0:
print(0)
exit()
def modinv(a, mod=10**9+7):
return pow(a, mod-2, mod)
def combination(n, r, mod=10**9+7):
r = min(r, n-r)
res = 1
for i in range(r):
res = res * (n-i) * modinv(i+1, mod) % mod
return res
print(combination(n+m, n))
| 1 | 149,668,085,334,532 | null | 281 | 281 |
import sys
def input(): return sys.stdin.readline().rstrip()
class UnionFind():
def __init__(self, n):
self.n=n
self.parents=[-1]*n # 親(uf.find()で経路圧縮して根)の番号。根の場合は-(そのグループの要素数)
def find(self,x):
#グループの根を返す
if self.parents[x]<0:return x
else:
self.parents[x]=self.find(self.parents[x])
return self.parents[x]
def unite(self,x,y):
#要素x,yのグループを併合
x,y=self.find(x),self.find(y)
if x==y:return
if self.parents[x]>self.parents[y]:#要素数の大きい方をxに
x,y=y,x
self.parents[x]+=self.parents[y]
self.parents[y]=x #要素数が大きい方に併合
def size(self,x):
#xが属するグループの要素数
return -self.parents[self.find(x)]
def same(self,x,y):
#xとyが同じグループ？
return self.find(x)==self.find(y)
def members(self,x):
#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 all_group_members_list(self):
#各ルート要素のグループに含まれる要素のリストのリスト
#[[0, 2], [1, 3, 4, 5]]
return list(self.all_group_members().values())
def __str__(self):
#各ルート要素のグループに含まれる要素のリストをprint()
return '\n'.join('{}: {}'.format(r,self.members(r)) for r in self.roots())
def main():
n,m,k=map(int,input().split())
AB=[tuple(map(int,input().split())) for i in range(m)]
CD=[tuple(map(int,input().split())) for i in range(k)]
un=UnionFind(n)
friend=[[] for _ in range(n)]
for a,b in AB:
un.unite(a-1,b-1)
friend[a-1].append(b-1)
friend[b-1].append(a-1)
blockc=[0]*n
for c,d in CD:
if un.same(c-1,d-1):
blockc[c-1]+=1
blockc[d-1]+=1
for i in range(n):
print(un.size(i)-1-blockc[i]-len(friend[i]))
if __name__=='__main__':
main()
|
# coding: utf-8
# Here your code !
S = int(input())
N = list(map(int,input().split()))
count=0
def bubblesort(n,s):
global count
flag = 1
while flag:
flag = 0
for i in range(s-1,0,-1):
key = n[i]
if n[i]<n[i-1]:
n[i]=n[i-1]
n[i-1]=key
count+=1
flag=1
print(" ".join(list(map(str,n))))
print(count)
bubblesort(N,S)
| 0 | null | 30,928,434,672,800 | 209 | 14 |
import math
a, b, C = map(int, input().split())
C = C / 180 * math.pi
S = a * b * math.sin(C) / 2
print(S)
print(a + b + math.sqrt(a**2 + b**2 - 2*a*b*math.cos(C)))
print(2 * S / a)
|
import math
a, b, C = map(int,input().split());
c = math.radians(C)
print((1/2)*a*b*math.sin(c));
print(a+b+math.sqrt(a**2+b**2-2*a*b*math.cos(c)));
print(b*math.sin(c));
| 1 | 172,192,065,952 | null | 30 | 30 |
a = 1; b = c = 0
for _ in range(int(input()) - 2):
a, b, c = b, c, (a + c) % (10**9 + 7)
print(c)
|
import math
c = 0
n = int(input())
for _ in range(n):
t = int(input())
for i in range(2,int(math.sqrt(t)+1)):
if t%i==0:
break
else:
c+=1
print(c)
| 0 | null | 1,638,222,805,252 | 79 | 12 |
x = int(input())
print(8 - ((x - 400) // 200))
|
A,B=map(int,input().split())
if A==0 or A>=10 or B==0 or B>=10:
print(-1)
else:
print(A*B)
| 0 | null | 82,361,978,651,108 | 100 | 286 |
from functools import reduce
n, m = map(int, input().split())
a = list(map(int, input().split()))
def gcd(a, b):
while b:
a, b = b, a % b
return a
def lcm(a, b):
return a * b // gcd(a, b)
def count(n):
cnt = 0
while n % 2 == 0:
n //= 2
cnt += 1
return cnt
A = [count(i) for i in a]
if len(set(A)) != 1:
print(0)
exit()
aa = [i // 2 for i in a]
LCM = reduce(lcm, aa)
res = m // LCM
if res % 2 == 0:
print(res // 2)
else:
print(res // 2 + 1)
|
import sys
from functools import reduce
def gcd(a, b): return gcd(b, a % b) if b else abs(a)
def lcm(a, b): return abs(a // gcd(a, b) * b)
n, m, *a = map(int, sys.stdin.read().split())
def main():
for i in range(n):
a[i] //= 2
b = set()
for x in a:
cnt = 0
while x % 2 == 0:
x //= 2
cnt += 1
b.add(cnt)
if len(b) == 2: print(0); return
l = reduce(lcm, a, 1)
res = (m // l + 1) // 2
print(res)
if __name__ == '__main__':
main()
| 1 | 101,523,851,503,802 | null | 247 | 247 |
A = raw_input().split()
S = []
for x in A:
if x in ['+', '-', '*']:
b = int(S.pop())
a = int(S.pop())
if x == '+':
S.append(a + b)
elif x == '-':
S.append(a - b)
else:
S.append(a * b)
else:
S.append(x)
print S.pop()
|
A = int(input())
B = int(input())
print(*(set([1,2,3])-set([A,B])))
| 0 | null | 55,067,891,634,212 | 18 | 254 |
N = int(input())
A,B=map(int,input().split())
Na = N
while N <= 1000:
if A <= N and N <= B:
print("OK")
break
N = N+Na
if N>1000:
print("NG")
|
a = int(input())
res = 0
if a%2 ==0:
res = int(a/2)
else:
a +=1
res = int(a/2)
print(res)
| 0 | null | 42,777,283,342,144 | 158 | 206 |
a, b = [int(a) for a in input().split()]
print("unsafe" if a <= b else "safe")
|
x,y,z = map(int,input().split())
tmp = x
x = y
y = tmp
tmp = x
x = z
z = tmp
print(x,y,z)
| 0 | null | 33,526,214,206,352 | 163 | 178 |
N, M = map(int, input().split())
parent = [-1] * N
def get_group_root(x):
if parent[x] < 0:
return x
return get_group_root(parent[x])
for i in range(0, M):
A, B = map(int, input().split())
A -= 1
B -= 1
groupA = get_group_root(A)
groupB = get_group_root(B)
if groupA == groupB:
continue
elif parent[groupA] < parent[groupB]:
parent[groupB] = A
parent[groupA] -= 1
else:
parent[groupA] = B
parent[groupB] -= 1
def check(x):
return x < 0
print(sum(list(map(check, parent))) - 1)
|
N,M=map(int,input().split())
#brr=[list(map(int,input().split())) for i in range(M)]
arr=[[] for i in range(N)]
check=[0]*N
ans=[]
for i in range(M):
a,b=map(int,input().split())
arr[a-1].append(b-1)
arr[b-1].append(a-1)
q=[]
cnt=0
for i in range(N):
if check[i]==0:
cnt+=1
q.append(i)
#print(cnt,q)
while q:
x=q.pop()
if check[x]==0:
check[x]=1
for j in arr[x]:
q.append(j)
print(cnt-1)
| 1 | 2,268,630,673,852 | null | 70 | 70 |
N,K = map(int,input().split())
P = list(map(lambda x:int(x)-1,input().split()))
C = list(map(int,input().split()))
ans = -float('inf')
for i in range(N):
visited = set()
tmp = 0
for k in range(K):
if P[i] in visited: break
tmp += C[P[i]]
i = P[i]
visited.add(i)
ans = max(ans, tmp)
if tmp < 0: continue
l = len(visited)
rem = K-l
d,m = divmod(rem,l)
if m==0 and d > 0:
m = l
d -= 1
tmp *= (d+1)
for k in range(m):
tmp += C[P[i]]
i = P[i]
ans = max(ans, tmp)
print(ans)
|
def run():
X, N = [int(v) for v in input().rstrip().split()]
p = []
if N > 0:
p = [int(v) for v in input().rstrip().split()]
i = -1
try:
i = p.index(X)
except ValueError:
pass
if i == -1:
# not contained
return X
d1 = {}
for k in range(0, 102):
d1[k] = k
for v in p:
del d1[v]
l2 = sorted(list(d1.keys()))
l2.append(X)
l2.sort()
i = l2.index(X)
r = 0
if i == 0:
r = l2[1]
elif (i + 1) == len(l2):
r = l2[-2]
else:
v1 = l2[i + 1] - X
v2 = X - l2[i - 1]
if v1 < v2 :
r = l2[i + 1]
elif v1 > v2 :
r = l2[i - 1]
else:
# v1 == v2
r = l2[i - 1]
return r
r = run()
print(r)
| 0 | null | 9,641,401,283,228 | 93 | 128 |
n,k=map(int,input().split())
a=list(map(int,input().split()))
l,r=10**9,0
while l-r>1:
t=(l+r)//2
if sum((i-1)//t for i in a)>k:
r=t
else:
l=t
print(l)
|
def main():
n = int(input())
plus = []
minus = []
for _ in range(n):
x, y = map(int, input().split())
plus.append(x + y)
minus.append(x - y)
plus_max = max(plus)
plus_min = min(plus)
minus_max = max(minus)
minus_min = min(minus)
print(max(plus_max - plus_min, minus_max - minus_min))
if __name__ == "__main__":
main()
| 0 | null | 4,897,448,436,132 | 99 | 80 |
b, c = map(int, input().split())
print(b * c)
|
import sys
import numpy as np
sr = lambda: sys.stdin.readline().rstrip()
ir = lambda: int(sr())
lr = lambda: list(map(int, sr().split()))
# 二分探索、浮き沈みの沈みに注意
N, K = lr()
A = np.array(lr()); A.sort()
F = np.array(lr()); F.sort(); F = F[::-1]
def check(x):
cost = np.maximum(0, A - (x // F)).sum()
return cost <= K
ok = 10 ** 15; ng = -1
while abs(ng-ok) > 1:
mid = (ok+ng) // 2
if check(mid):
ok = mid
else:
ng = mid
print(ok)
| 0 | null | 89,979,954,388,920 | 133 | 290 |
class UnionFind:
def __init__(self, n):
self.n = n
self.parents = [-1] * n
def find(self, x):
if self.parents[x] < 0:
return x
else:
self.parents[x] = self.find(self.parents[x])
return self.parents[x]
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
def size(self, x):
return -self.parents[self.find(x)]
def same(self, x, y):
return self.find(x) == self.find(y)
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())
def main():
N, M = list(map(int, input().split()))
paths = [list(map(int, input().split())) for _ in range(M)]
result = solve(N, paths)
print(result)
def solve(N, paths) -> int:
uf = UnionFind(N)
for x, y in paths:
uf.union(x - 1, y - 1)
return uf.group_count() - 1
if __name__ == '__main__':
main()
|
n,m = map(int,input().split())
par = [i for i in range(n+1)]
root = [i for i in range(n+1)]
par[0] = 1
def find(x):
if par[x] == x:
return x
else:
par[x] = find(par[x]) #経路圧縮
return par[x]
def same(x,y):
return find(x) == find(y)
def unite(x,y):
x = find(x)
y = find(y)
if x == y:
return 0
par[x] = y
for i in range(m):
a,b = map(int,input().split())
unite(a,b)
for i in range(n+1):
root[i] = find(i)
print(len(set(root))-1)
| 1 | 2,296,967,435,840 | null | 70 | 70 |
A, V = map(int, input().split())
B, W = map(int, input().split())
T = int(input())
d = abs(A-B)
if d-(V-W)*T<=0:
print("YES")
else:
print("NO")
|
import bisect
n, m, k = map(int, input().split())
a = list(map(int, input().split()))
b = list(map(int, input().split()))
max_books = 0
sum_a = []
sum_b = []
total = 0
for i in range(n):
total += a[i]
sum_a.append(total)
total = 0
for j in range(m):
total += b[j]
sum_b.append(total)
sum_a.insert(0, 0)
sum_b.insert(0, 0)
for i in range(n+1):
r = k - sum_a[i]
if r == 0:
books = i
elif r < 0:
books = 0
else:
book_b = bisect.bisect_right(sum_b, r)
books = i + book_b - 1
if books >= max_books:
max_books = books
print(max_books)
| 0 | null | 12,917,452,031,242 | 131 | 117 |
h, n = map(int,input().split())
a = list(map(int,input().split()))
atack = sum(a)
can = h <= atack
print("Yes" if can else "No")
|
H, N = map(int, input().split())
special_move = input().split()
def answer(H: int, N: int, special_move: list) -> str:
damage = 0
for i in range(0, N):
damage += int(special_move[i])
if damage >= H:
return 'Yes'
else:
return 'No'
print(answer(H, N, special_move))
| 1 | 77,965,203,319,342 | null | 226 | 226 |
K = int(input())
A, B = map(int, input().split(" "))
if B//K - ((A-1)//K)>0:
print('OK')
else:
print('NG')
|
n,p = map(int,input().split())
s = list(map(int, list(input())))
def solve():
total = 0
if 10%p == 0:
for i in range(n):
if s[i] % p == 0: total += i + 1
return total
cnt = [0]*p
r = 0
ten = 1
for i in range(n-1, 0-1, -1):
cnt[r] += 1
r = (r + s[i]*ten) % p
total += cnt[r]
ten = ten * 10 % p
return total
print(solve())
| 0 | null | 42,599,116,142,958 | 158 | 205 |
#!/usr/bin/env python3
import sys
def solve(N: int, A: "List[int]"):
if N == 0:
if A == [0]:
print('0')
elif A == [1]:
print('1')
else:
print('-1')
return
if N == 1:
if A == [0, 1]:
print('2')
elif A == [0, 2]:
print('3')
else:
print('-1')
return
if A[0] != 0:
print('-1')
return
f = [0 for i in range(N)]
f[0] = 1
count = sum(A) - 1
for d in range(1, N):
f[d] = 2 * min(f[d - 1], count) - A[d] + min(max(f[d - 1] - count, 0), f[d - 1])
count -= min(f[d - 1], count)
if f[d] <= 0:
print('-1')
return
if A[-1] > 2 * f[N-1]:
print('-1')
return
print(sum(f) + sum(A))
return
# Generated by 1.1.7.1 https://github.com/kyuridenamida/atcoder-tools (tips: You use the default template now. You can remove this line by using your custom template)
def main():
def iterate_tokens():
for line in sys.stdin:
for word in line.split():
yield word
tokens = iterate_tokens()
N = int(next(tokens)) # type: int
A = [int(next(tokens)) for _ in range(N - 0 + 1)] # type: "List[int]"
solve(N, A)
if __name__ == '__main__':
main()
|
N = int(input())
A = list(map(int,input().split()))
SUM = sum(A)
ans = 0
node = 1
for i,leaf in enumerate(A):
if i == 0:
non_leaf = 1 - leaf
ans += 1
if non_leaf <0:
print(-1)
exit()
else:
left,right = non_leaf,non_leaf*2
if SUM < left or non_leaf <= 0:
print(-1)
exit()
node = min(right,SUM)
ans += node
non_leaf = node - leaf
SUM -= leaf
if non_leaf < 0:
print(-1)
exit()
print(ans)
| 1 | 18,885,817,927,746 | null | 141 | 141 |
def selection_sort(numbers, n, key=lambda x: x):
"""selection sort method
Args:
numbers: a list of numbers to be sorted
n: len(numbers)
key: sort key
Returns:
sorted numberd, number of swapped times
"""
x = []
for data in numbers:
x.append(data)
counter = 0
for i in range(0, n):
min_j = i
for j in range(i, n):
if key(x[j]) < key(x[min_j]):
min_j = j
if min_j != i:
x[min_j], x[i] = x[i], x[min_j]
counter += 1
return x, counter
def bubble_sort(numbers, n, key=lambda x: x):
"""bubble sort method
Args:
numbers: a list of numbers to be sorted by bubble sort
n: len(list)
key: sort key
Returns:
sorted list
"""
x = []
for data in numbers:
x.append(data)
flag = True
counter = 0
while flag:
flag = False
for index in range(n - 1, 0, -1):
if key(x[index]) < key(x[index - 1]):
x[index], x[index - 1] = x[index - 1], x[index]
flag = True
counter += 1
return x, counter
def insertion_sort(numbers, n, key=lambda x: x):
"""insertion sort method
Args:
numbers: a list of numbers to be sorted
n: len(numbers)
Returns:
sorted list
"""
for i in range(1, n):
target = numbers[i]
index = i - 1
while index >= 0 and target < numbers[index]:
numbers[index + 1] = numbers[index]
index -= 1
numbers[index + 1] = target
return numbers
def is_stable(list1, list2):
"""check stablity of sorting method used in list2
Args:
list1: sorted list(bubble sort)
list2: sorted list(some sort)
Returns:
bool
"""
flag = True
for index, data in enumerate(list1):
if list2[index] != data:
flag = False
break
return flag
length = int(raw_input())
cards = raw_input().split()
bubble_sorted_card, bubble_swapped = bubble_sort(numbers=cards, n=length, key=lambda x: int(x[1]))
selection_sorted_card, selection_swapped = selection_sort(numbers=cards, n=length, key=lambda x: int(x[1]))
print(" ".join(bubble_sorted_card))
print("Stable")
print(" ".join(selection_sorted_card))
if is_stable(bubble_sorted_card, selection_sorted_card):
print("Stable")
else:
print("Not stable")
|
n,k=map(int,input().split())
p=list(map(int,input().split()))
c=list(map(int,input().split()))
ans=-10**10
for i in range(n):
loop=[0]
now=i
while True:
now=p[now]-1
loop.append(loop[-1]+c[now])
if now==i:
break
L=len(loop)-1
if k<=L:
score=max(loop[1:k+1])
ans=max(score,ans)
else:
score=max(loop[-1],0)*(k//L-1)
ans=max(ans,score)
for j in range(k%L+L):
score+=loop[j%L+1]-loop[j%L]
ans=max(score,ans)
print(ans)
| 0 | null | 2,744,770,554,010 | 16 | 93 |
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())
rl = lambda: list(map(int, sys.stdin.readline().split()))
inf = float('inf')
mod = 10**9 + 7
a, b, x = rm()
x /= a
if a*b / 2 >= x:
a = 2*x / b
print(90 - math.degrees(math.atan(a/b)))
else:
x = a*b - x
b = 2*x / a
print(math.degrees(math.atan(b/a)))
|
N,D = map(int,input().split())
ans = 0
for i in range(N):
X1,Y1 = map(int,input().split())
if X1*X1+Y1*Y1 <= D*D:
ans += 1
print(ans)
| 0 | null | 84,225,052,355,990 | 289 | 96 |
import math
import collections
import fractions
import itertools
import functools
import operator
import bisect
def solve():
n = int(input())
l = list(map(int, input().split()))
l.sort()
res = 0
for i in range(n):
for j in range(i+1, n):
k = bisect.bisect_left(l, l[i]+l[j])
res += max(k-(j+1), 0)
print(res)
return 0
if __name__ == "__main__":
solve()
|
import itertools, bisect
N = int(input())
L = list(map(int, input().split()))
L.sort()
ans = 0
for i in range(N):
for j in range(i+1, N):
cindex = bisect.bisect_left(L, int(L[i]) + int(L[j]))
ans += cindex-1 - j
print(ans)
| 1 | 171,935,588,844,402 | null | 294 | 294 |
def main():
n, k = map(int, input().split())
lr = [list(map(int, input().split())) for _ in range(k)]
dp = [0] * (n + 1)
dp[1] = 1
dpsum = [0] * (n + 1)
dpsum[1] = 1
mod = 998244353
for i in range(2, n + 1):
for j in range(k):
li = max(i - lr[j][1], 1)
ri = i - lr[j][0]
if ri < 0:
continue
dp[i] = (dp[i] + dpsum[ri] - dpsum[li - 1]) % mod
dpsum[i] = dpsum[i - 1] + dp[i]
print(dp[-1] % mod)
if __name__ == "__main__":
main()
|
n,m,x=map(int,input().split())
c=[list(map(int,input().split())) for _ in range(n)]
ans=float('inf')
for i in range(2**n):
data=[0]*(m+1)
for j in range(n):
if i&(1<<j):
for k in range(m+1):
data[k]+=c[j][k]
cnt=0
for l in range(1,m+1):
if data[l]>=x:
cnt+=1
if cnt==m:
ans=min(ans,data[0])
if ans==float('inf'):
print(-1)
exit()
print(ans)
| 0 | null | 12,552,827,935,930 | 74 | 149 |
n = int(input())
a = [int(x) for x in input().split()]
m = [0]*(max(a)+1)
lm = len(m)
cnt = 0
for i in a:
j = 1
while i*j < lm:
m[i*j] += 1
j += 1
for i in a:
if m[i] == 1:
cnt += 1
print(cnt)
|
#coding:utf-8
#1_1_B
def gcd(x, y):
while x%y != 0:
x, y = y, x%y
return y
x, y = map(int, input().split())
print(gcd(x, y))
| 0 | null | 7,235,221,348,720 | 129 | 11 |
def main():
a,b,c = map(int, input().split())
ab = [i for i in range(a, b + 1)]
cnt = 0 #count
for x in range(len(ab)):
if c % ab[x] == 0:
cnt += 1
else:
pass
print(cnt)
if __name__ == "__main__":
main()
|
a,b,c=list(map(int,input().split()))
y=0
for x in range(a,b+1):
if c%x==0:
y+=1
print(y)
| 1 | 573,181,877,978 | null | 44 | 44 |
s = int(input())
n = (s/3)
print(n*n*n)
|
# coding=utf-8
class Dice(object):
def __init__(self, label):
self.label = label
def _rotateS(self):
s1, s2, s3, s4, s5, s6 = self.label
self.label = [s5, s1, s3, s4, s6, s2]
def _rotateN(self):
s1, s2, s3, s4, s5, s6 = self.label
self.label = [s2, s6, s3, s4, s1, s5]
def _rotateE(self):
s1, s2, s3, s4, s5, s6 = self.label
self.label = [s4, s2, s1, s6, s5, s3]
def _rotateW(self):
s1, s2, s3, s4, s5, s6 = self.label
self.label = [s3, s2, s6, s1, s5, s4]
def _spinPos(self):
s1, s2, s3, s4, s5, s6 = self.label
self.label = [s1, s4, s2, s5, s3, s6]
def _spinNeg(self):
s1, s2, s3, s4, s5, s6 = self.label
self.label = [s1, s3, s5, s2, s4, s6]
def rotate(self, r):
if r == 'S':
self._rotateS()
elif r == 'N':
self._rotateN()
elif r == 'E':
self._rotateE()
elif r == 'W':
self._rotateW()
elif r == 'SP':
self._spinPos()
elif r == 'SN':
self._spinNeg()
elif r == '2S':
self._rotateS()
self._rotateS()
elif r == '2SP':
self._spinPos()
self._spinPos()
def getLabel(self, i):
return self.label[i - 1]
def match(self, top, front):
iTop = self.label.index(top) + 1
topRot = {1: '', 2: 'N', 3: 'W', 4: 'E', 5: 'S', 6: '2S'}
self.rotate(topRot[iTop])
iFront = self.label.index(front) + 1
frontRot = {2: '', 3: 'SN', 4: 'SP', 5: '2SP'}
self.rotate(frontRot[iFront])
def main():
d = Dice(map(int, raw_input().split()))
n = input()
for _ in xrange(n):
top, front = map(int, raw_input().split())
d.match(top, front)
print d.getLabel(3)
if __name__ == '__main__':
main()
| 0 | null | 23,667,913,701,432 | 191 | 34 |
n = int(input())
s = list(map(int, input().strip().split(' ')))
t = n // 2
for i in range(0, n // 2):
s[i], s[n - i - 1] = s[n - i - 1], s[i]
for i in range(0, len(s)):
if i != len(s) - 1:
print(s[i], end=" ")
else:
print(s[i])
|
x = 0
y = 0
for i in range(1,10):
x += 1
y = 0
for j in range(1,10):
y += 1
print("{}x{}={}".format(x,y,x*y))
| 0 | null | 493,414,533,108 | 53 | 1 |
x = int(input())
n=100
tes = [0]
for i in range(-250,250):
for j in range(-250,250):
if pow(i,5) - pow(j,5) == x:
print(str(i)+" "+str(j))
exit()
|
#!/usr/bin/env python3
import sys
x = int(input())
for i in range(-10 ** 3, 10 ** 3):
for j in range(-10 **3, 10 ** 3):
if (i ** 5) - (j ** 5) == x:
print(i, j)
sys.exit()
| 1 | 25,576,830,870,180 | null | 156 | 156 |
def main():
n,m = map(int, input().split())
a = sorted(list(map(int, input().split())),reverse = True)
all = sum(a)
cnt = 0
for i in(a):
if(i * 4 * m >= all and cnt < m):
cnt += 1
if cnt >= m:
print('Yes')
else:
print('No')
main()
|
n,m = map(int,input().split())
alist = list(map(int,input().split()))
alist.sort(reverse=True)
allvote = sum(alist)
count = 0
for i in range(n):
if alist[i] >= allvote/(4*m):
count+=1
if count >= m:
print("Yes")
else:
print("No")
| 1 | 38,767,745,852,150 | null | 179 | 179 |
#!/usr/bin/env python
# -*- coding: utf-8 -*-
a, b, c = map(int, input().split())
ret = [i for i in range(a, b+1) if c%i == 0]
print(len(ret))
|
def main():
n = int(input())
s = [list(input()) for _ in range(n)]
L_cnt = []
R_cnt = []
LR_cnt = []
min_l,min_r = 10**6,10**6
for i in range(n):
t = s[i]
flag = 0
l = 0
r = 0
for j in range(len(t)):
if not flag and t[j] == ')':
r += 1
elif t[j] == '(':
flag = 1
l += 1
else:
l -= 1
if l == 0:
flag = 0
if r == 0 and l == 0:
continue
if r == 0:
L_cnt.append(l)
elif l == 0:
R_cnt.append(r)
else:
LR_cnt.append([l,r])
min_l = min(min_l,l)
min_r = min(min_r,r)
L,R = sum(L_cnt),sum(R_cnt)
if not LR_cnt:
if L == R:
print('Yes')
return
else:
print('No')
return
if not (L_cnt and R_cnt):
print('No')
return
box1 = []
box2 = []
for i in range(len(LR_cnt)):
if L >= LR_cnt[i][1] and LR_cnt[i][1] <= LR_cnt[i][0]:
L += LR_cnt[i][0] - LR_cnt[i][1]
elif LR_cnt[i][1] <= LR_cnt[i][0]:
box1.append(LR_cnt[i])
else:
box2.append(LR_cnt[i])
for i in range(len(box1)):
L -= box1[i][1]
if L < 0:
print('No')
return
L += box1[i][0]
for i in range(len(box2)):
L -= box2[i][1]
if L < 0:
print('No')
return
L += box2[i][0]
if L == R:
print('Yes')
else:
print('No')
if __name__ == "__main__":
main()
| 0 | null | 12,064,095,893,110 | 44 | 152 |
while 1:
l=map(str,raw_input().split())
answer = 0
if l[1] == '+':
answer = int (l[0]) + int (l[2])
if l[1] == '-':
answer = int (l[0]) - int (l[2])
if l[1] == '*':
answer = int (l[0]) * int (l[2])
if l[1] == '/':
answer = int (l[0]) / int (l[2])
if l[1] == '?':
break;
print answer
|
def main():
N, M, K = map(int, input().split())
A = list(map(int, input().split()))
B = list(map(int, input().split()))
total_T_in_A = [0] * (N+1)
total_T_in_B = [0] * (M+1)
for i in range(1, N+1):
total_T_in_A[i] = total_T_in_A[i-1] + A[i-1]
for i in range(1, M+1):
total_T_in_B[i] = total_T_in_B[i-1] + B[i-1]
result = 0
for i in range(N+1):
# A から i 冊読むときにかかる時間
i_A_T = total_T_in_A[i]
if K < i_A_T:
continue
if K == i_A_T:
result = max(result, i)
continue
rem_T = K - i_A_T
# total_T_in_B は累積和を格納した、ソート済の配列
# B_i <= rem_T < B_i+1 となるような B_i を二分探索によって探す
first = total_T_in_B[1]
last = total_T_in_B[M]
if rem_T < first:
result = max(result, i)
continue
if last <= rem_T:
result = max(result, i + M)
continue
# assume that first <= rem_T <= last
first = 1
last = M
while first < last:
if abs(last - first) <= 1:
break
mid = (first + last) // 2
if rem_T < total_T_in_B[mid]:
last = mid
else:
first = mid
result = max(result, i + first)
print(result)
main()
| 0 | null | 5,772,566,089,642 | 47 | 117 |
N=int(input())
ls={}
max_ch=0
for i in range(N):
ch=input()
if not ch in ls:
ls[ch]=1
else:
ls[ch]+=1
if max_ch<ls[ch]:
max_ch=ls[ch]
S=[]
for j in ls:
if max_ch==ls[j]:
S.append(j)
S=sorted(S)
for i in S:
print(i)
|
n=int(input())
A=[]
for i in range(n):
a=str(input())
A.append(a)
import collections
c = collections.Counter(A)
ma= c.most_common()[0][1]
C=[i[0] for i in c.items() if i[1] >=ma ]
C.sort(reverse=False)
for j in range(len(C)):
print(C[j])
| 1 | 69,973,404,269,822 | null | 218 | 218 |
from math import gcd
N = int(input())
A = list(map(int, input().split()))
prime = list(range(max(A) + 1))
for i in range(2, len(prime)):
if prime[i] != i:
continue
for j in range(i, len(prime), i):
if prime[j] != j:
continue
prime[j] = i
used = set()
pc = True
for a in A:
used_this = set()
while a != 1:
div = prime[a]
if div in used:
pc = False
break
used_this.add(div)
a //= div
used.update(used_this)
if pc:
print('pairwise coprime')
exit()
buf = A[0]
for a in A[1:]:
buf = gcd(buf, a)
if buf == 1:
print('setwise coprime')
else:
print('not coprime')
|
#AIsing2020 d
def f(n):
cnt = 0
while n:
cnt+= 1
n = n%bin(n).count('1')
return cnt
def main():
N = int(input())
X = input()
X10 = int(X,2)
X10_num1 = X.count('1')
X10_pulse = X10%(X10_num1+1)
X10_ninus = X10%(X10_num1-1) if X10_num1 >1 else 0
for i in range(N,0,-1):
if (X10>>(i-1) & 1) and X10_num1 >1:
mod = X10_num1-1
amari = (X10_ninus - pow(2,i-1,mod))%(mod)
elif (X10>>(i-1) & 1) and X10_num1 ==1:
print(0)
continue
else:
mod = X10_num1+1
amari = (X10_pulse + pow(2,i-1,mod))%(mod)
print(1+f(amari))
main()
| 0 | null | 6,153,487,872,832 | 85 | 107 |
import collections
N = int(input())
a = list(map(int, input().split()))
l = [0]* N
for i in range(N-1):
#print(i, a[i]-1)
l[a[i]-1] += 1
#print(l)
for j in range(N):
print(l[j])
|
#!/usr/bin/env python3
# Generated by https://github.com/kyuridenamida/atcoder-tools
from typing import *
import itertools
import math
import sys
INF = float('inf')
def solve(K: int, S: str):
return S[:K] + ['...', ''][len(S) <= K]
def main():
sys.setrecursionlimit(10 ** 6)
def iterate_tokens():
for line in sys.stdin:
for word in line.split():
yield word
tokens = iterate_tokens()
K = int(next(tokens)) # type: int
S = next(tokens) # type: str
print(solve(K, S))
if __name__ == '__main__':
main()
| 0 | null | 25,953,732,832,380 | 169 | 143 |
import itertools
N, K = map(int, input().split())
p = list(map(int, input().split()))
pos = [(p[i]+1)/2 for i in range(N)]
pos_acum = list(itertools.accumulate(pos))
ans = pos_acum[K-1]
for i in range(N-K):
ans = max(ans, pos_acum[K+i]-pos_acum[i])
print(ans)
|
import sys
input = sys.stdin.readline
(n, k), s, res, sm = map(int, input().split()), list(map(lambda x: (int(x) + 1) / 2, input().split())), 0, 0
for i in range(n):
if i < k: sm += s[i]
else: sm += s[i]; sm -= s[i-k]
res = max(res, sm)
print(f'{res:.10f}')
# print(f'{max([sum(s[i:i+k]) for i in range(n - k + 1)]):.10f}')
| 1 | 74,847,880,358,810 | null | 223 | 223 |
s=0
t=0
for i in range(9):
s+=1
for j in range(9):
if t==9:
t=1
else:
t+=1
print(f'{s}x{t}={s*t}')
|
N = int(input())
*A, = map(int, input().split())
dic = {}
ans = 0
for i in range(N):
if A[i] + i in dic:
dic[A[i] + i] += 1
if A[i] + i not in dic:
dic[A[i] + i] = 1
if i - A[i] in dic:
ans += dic[i - A[i]]
print(ans)
| 0 | null | 13,079,202,443,324 | 1 | 157 |
n,k=map(int,input().split())
h=list(map(int,input().split()))
h.append(k)
print(len(h[sorted(h).index(k)+1:]))
|
# B - Roller Coaster
def main():
cnt = 0
n, k = map(int, input().split())
h = list(map(int, input().split()))
print(sum([cnt+1 for v in h if v >= k]))
if __name__ == "__main__":
main()
| 1 | 179,079,217,826,550 | null | 298 | 298 |
#abc175b
n=int(input())
l=list(map(int,input().split()))
l.sort()
cnt=0
for i in range(n):
for j in range(i):
for k in range(j):
if l[k]!=l[j] and l[i]!=l[j] and l[k]+l[j]>l[i]:
cnt+=1
print(cnt)
|
n = int(input())
l =list(map(int, input().split()))
ans = 0
for i in range(n):
for j in range(i+1, n):
for k in range(j+1, n):
if j > n-2 or k > n-1:
continue
if l[i] == l[j] or l[j] == l[k] or l[k] == l[i]:
continue
if abs(l[j] - l[k]) < l[i] < l[j] + l[k]:
ans += 1
print(ans)
| 1 | 5,051,143,675,072 | null | 91 | 91 |
n,k =list(map(int,input().split()))
mod = 10**9+7
ans = 1%mod
left_combination = 1
right_combination = 1
for i in range(1,min(k,n-1)+1):
left_combination = (left_combination*(n+1-i)*pow(i,mod-2,mod))%mod
right_combination = (right_combination*(n-i)*pow(i,mod-2,mod))%mod
ans = (ans + (left_combination*right_combination)%mod)%mod
print(ans)
|
n, m, l = [int(s) for s in input().split()]
A = []
B = []
C = [[0 for i in range(l)] for i in range(n)]
for i in range(n):
A.append([int(s) for s in input().split()])
for i in range(m):
B.append([int(s) for s in input().split()])
for i,row in enumerate(C):
for j in range(len(row)):
for k in range(m):
C[i][j] += A[i][k] * B[k][j]
for row in C:
print(' '.join([str(i) for i in row]))
| 0 | null | 34,461,221,445,532 | 215 | 60 |
a,b=input().split(' ')
if int(a)<=100 and int(b)<=100:
print(int(a)*int(b))
else:
pass
|
n = int(input())
A = [[] for i in range(n)]
for i in range(n):
A[i] = list(map(int, input().split()))
B = [[0 for i in range(2)] for j in range(n)]
order = []
time = 0
def dfs(n, num):
global time
while time < 2*n:
a = num
time += 1
if B[num-1][0] == 0: # まだ発見していないとき
if A[num-1][1] != 0: # 次の頂点があるとき
order.append(A[num-1][0]) # 発見したことを記録する
B[num-1][0] = time # 発見時刻を記録する
A[num-1][1] -= 1 # 次の頂点数を１減らす
if B[A[num-1][2]-1][0] == 0: # 次の頂点がまだ発見されていないとき
num = A[num-1].pop(2) # 次の頂点に移動
else: # 次の頂点が発見済みのとき
del A[num-1][2] # 次の頂点をルートから削除
else: # 次の頂点がないとき
l = len(order) # これまで経由した頂点数
order.append(A[num-1][0]) # 発見したことを記録する
order.append(A[num-1][0]) # 調べ終えたことを記録する
B[num-1][0] = time # 発見時刻を記録する
time += 1 # 時刻を１進める
B[num-1][1] = time # 調査終了時刻を記録する
num = order[l-1] # １つ前の頂点に戻る
elif B[num-1][1] == 0: # 発見しているが、調べ終えていないとき
if A[num-1][1] == 0: # 次の頂点がないとき
order.append(A[num-1][0]) # 調べ終えたことを記録する
B[num-1][1] = time # 調査終了時刻を記録する
m = order.index(num) # 発見した順番を調べる
num = order[m-1] # 発見する前の頂点に移動
else: # 次の頂点があるとき
A[num-1][1] -= 1 # 次の頂点数を１減らす
order.append(A[num-1][0]) # 経由したことを記録する
if B[A[num-1][2]-1][0] == 0: # 次の頂点がまだ発見されていないとき
num = A[num-1].pop(2) # 次の頂点に移動
else: # 次の頂点が発見済みのとき
del A[num-1][2] # つぎの頂点をルートから削除
time -= 1 # 時刻を戻す
else: # すでに調査終了した頂点に移動したとき
l = len(order) # これまで経由した頂点数
num = order[l-1] # １つ前の頂点に戻る
time -= 1 # 時刻を戻す
if num == a:
break
for i in range(n):
if B[i][0] == 0:
dfs(n, A[i][0])
for i in range(n):
print(str(i+1) + " ", end="")
print(" ".join(map(str, B[i])))
| 0 | null | 7,924,842,933,942 | 133 | 8 |
n,s = map(int,input().split())
A = list(map(int,input().split()))
mod = 998244353
dp = [[0 for i in range(s+1)] for j in range(n+1)]
dp[0][0] = 1
for i in range(n):
for j in range(s+1):
if j - A[i] >= 0:
dp[i+1][j]=(dp[i][j]*2+dp[i][j-A[i]])%mod
else:
dp[i+1][j]=(dp[i][j]*2)%mod
print(dp[n][s])
|
k = int(input())
a,b = map(int,input().split())
if b//k - (a-1)//k > 0:
print("OK")
else:
print("NG")
| 0 | null | 21,971,401,560,192 | 138 | 158 |
import re
s = input()
if s == "hi" or s=="hihi" or s=="hihihi" or s=="hihihihi" or s== "hihihihihi":
print("Yes")
else:
print("No")
|
t1,t2 = map(int,input().split())
a1,a2 = map(int,input().split())
b1,b2 = map(int,input().split())
if a1*t1 + a2*t2 == b1*t1 + b2*t2:
print("infinity")
else:
A = a1*t1 + a2*t2
B = b1*t1 + b2*t2
M1,m1 = max(a1*t1,b1*t1),min(a1*t1,b1*t1)
M2,m2 = max(A,B),min(A,B)
gap1,gap2 = M1-m1,M2-m2
Mv,mv = max(a1,b1),min(a1,b1)
vgap = Mv-mv
possible = vgap*t1
count = possible//gap2
if possible%gap2 == 0:
pitta = 1
else:
pitta = 0
if (a1*t1 > b1*t1 and A > B) or (a1*t1 < b1*t1 and A < B):
print(0)
elif (a1*t1 > b1*t1 and A < B) or (a1*t1 < b1*t1 and A > B):
if pitta == 1:
print(1+count*2-1)
else:
print(1+count*2)
| 0 | null | 92,568,188,117,120 | 199 | 269 |
def main():
n, k = map(int, input().split())
a = 1
b = 0
while True:
a *= k
if a > n:
break
b += 1
ans = b + 1
print(ans)
if __name__ == "__main__":
main()
|
N = int(input())
memolist = [-1]*(N+1)
def fib(x):
if memolist[x] == -1:
if x == 0 or x == 1:
memolist[x] = 1
else:
memolist[x] = fib(x - 1) + fib(x - 2)
return memolist[x]
print(fib(N))
| 0 | null | 32,167,629,964,252 | 212 | 7 |
def main():
s = int(input())
mod = 10**9 + 7
dp = [0] * (s+1)
dp[0] = 1
for i in range(1, s+1):
for j in range(0, (i-3)+1):
dp[i] += dp[j]
dp[i] %= mod
print(dp[-1])
if __name__ == "__main__":
main()
|
s=int(input())
a=1
mod=10**9+7
x=s//3
y=s%3
ans=0
while x>=1:
xx=1
for i in range(1,x):
xx*=i
xx%=mod
yy=1
for j in range(1,1+y):
yy*=j
yy%=mod
fx=pow(xx,mod-2,mod)
fy=pow(yy,mod-2,mod)
xxyy=1
for k in range(1,x+y):
xxyy*=k
xxyy%=mod
ans+=(xxyy*fx*fy)%mod
x-=1
y+=3
print(ans%mod)
| 1 | 3,330,120,500,080 | null | 79 | 79 |
def gcd(a, b):
"""calculate the greatest common divisor of a, b
>>> gcd(54, 20)
2
>>> gcd(147, 105)
21
>>> gcd(100000002, 39273000)
114
"""
if a > b:
a, b = b, a
if a == 0:
return b
return gcd(b % a, a)
def run():
a, b = [int(i) for i in input().split()]
print(gcd(a, b))
if __name__ == '__main__':
run()
|
n = int(input())
a = list(map(int, input().split()))
order = [0] * (n + 1)
for i in range(n):
order[a[i]] = i + 1
print(*order[1:])
| 0 | null | 90,752,443,307,028 | 11 | 299 |
def gcds(*numbers):
from math import gcd
from functools import reduce
return reduce(gcd, numbers)
def resolve():
K = int(input())
ans = 0
import itertools
for i, j, k in itertools.combinations_with_replacement(range(1, K+1), 3):
l = len(set([i, j, k]))
mu = 1
if l == 3:
mu = 6
elif l == 2:
mu = 3
ans += gcds(i, j, k) * mu
print(ans)
if '__main__' == __name__:
resolve()
|
import math
K = int(input())
ans = []
bc = [math.gcd(b, c) for b in range(1, K+1) for c in range(1, K+1)]
for a in range(1, K+1):
for i in bc:
x = math.gcd(a, i)
ans.append(x)
print(sum(ans))
| 1 | 35,455,235,880,468 | null | 174 | 174 |
import sys
sys.setrecursionlimit(10**6)
a,b = map(int, input().split())
if a < 10 and b < 10:
print(a*b)
else:
print(-1)
|
A, B = map(int, input().split())
print(A * B if A < 10 and B < 10 else '-1')
| 1 | 158,383,150,125,958 | null | 286 | 286 |
n = int(input())
memo = [[0] * (n+1) for x in range(n+1)]
def gcd(x,y):
if y == 0:
return x
if not memo[x][y] == 0:
return memo[x][y]
memo[x][y] = gcd(y,x % y)
return gcd(y,x % y)
res = 0
for i in range(1,n+1):
for j in range(1,n+1):
q = gcd(i,j)
if q == 1:
res += n
else:
for k in range(1,n+1):
p = gcd(q,k)
res += p
print(res)
|
def gcds(*numbers):
from math import gcd
from functools import reduce
return reduce(gcd, numbers)
def resolve():
K = int(input())
ans = 0
import itertools
for i, j, k in itertools.combinations_with_replacement(range(1, K+1), 3):
l = len(set([i, j, k]))
mu = 1
if l == 3:
mu = 6
elif l == 2:
mu = 3
ans += gcds(i, j, k) * mu
print(ans)
if '__main__' == __name__:
resolve()
| 1 | 35,273,833,156,640 | null | 174 | 174 |
N=int(input())
D=[map(int, input().split()) for i in range(N)]
x, y = [list(i) for i in zip(*D)]
s=0
l=[]
for i in range(N):
if x[i]==y[i]:
s+=1
if i==N-1:
l.append(s)
elif x[i]!=y[i]:
l.append(s)
s=0
if max(l)>=3:
print("Yes")
else:
print("No")
|
n=int(input())
count=0
maxs=0
for _ in range(n):
d1,d2=map(int,input().split())
if d1==d2:
count+=1
else:
maxs=max(maxs,count)
count=0
maxs=max(count,maxs)
if maxs>=3:
print("Yes")
else:
print("No")
| 1 | 2,489,463,207,932 | null | 72 | 72 |
#もらうDP + 累積和
n, k = map(int, input().split())
mod = 998244353
li = []
for _ in range(k):
l, r = map(int, input().split())
li.append((l, r))
li.sort()
dp = [0]*(2*n+1)
s = [0] * (2*n+1)
dp[1] = 1
s[1] = 1
for i in range(2, n+1):
for t in li:
l, r = t
dp[i] += s[max(i-l, 0)]
dp[i] -= s[max(i-r-1, 0)]
dp[i] %= mod
s[i] = s[i-1] + dp[i]
s[i] %= mod
print(dp[i]%mod)
|
import itertools
import sys
read = sys.stdin.buffer.read
readline = sys.stdin.buffer.readline
readlines = sys.stdin.buffer.readlines
def score(A):
res = 0
for a, b, c, d in abcd:
if A[b - 1] - A[a - 1] == c:
res += d
return res
def main(n, m, abcd):
p = itertools.combinations_with_replacement(range(1, m+1), n)
L = list(p)
ans = 0
for A in L:
ans = max(ans, score(list(A)))
return ans
n, m, q = map(int, readline().split())
abcd = [list(map(int, readline().split())) for _ in range(q)]
print(main(n, m, abcd))
| 0 | null | 15,241,273,422,092 | 74 | 160 |
N = int(input())
A = [int(x) for x in input().split()]
c = 0
p = 0
for a in A:
if p < a:
p = a
else:
c += p - a
p = max(p, a)
print(c)
|
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)
| 1 | 4,592,693,068,700 | null | 88 | 88 |
if len(set(input().split())) == 1:
print('Yes')
else:
print('No')
|
n , m = (int(a) for a in input().split())
if n == m :
print("Yes")
else : print("No")
| 1 | 83,419,440,406,080 | null | 231 | 231 |
N = int(input())
ans = 0
if N % 2 == 0:
ans += N//10
ans += N//50
N //= 50
while N > 0:
N //= 5
ans += N
print(ans)
|
string = list(map(str, input()))
ans =[]
for char in string:
if char.islower():
ans.append(char.upper())
elif char.isupper():
ans.append(char.lower())
else:
ans.append(char)
print(ans[-1], end="")
print()
| 0 | null | 58,713,424,751,216 | 258 | 61 |
#!/usr/bin/env python3
import sys, math, itertools, heapq, collections, bisect
input = lambda: sys.stdin.buffer.readline().rstrip().decode('utf-8')
sys.setrecursionlimit(10**8)
inf = float('inf')
ans = count = 0
A=list(map(int,input().split()))
for ai in A:
if ai==1:
ans+=300000
elif ai==2:
ans+=200000
elif ai==3:
ans+=100000
if A[0]==1 and A[1]==1:
ans+=400000
print(ans)
|
import itertools
n = int(input())
s = list(map(int, input().split(' ')))
t = list(map(int, input().split(' ')))
hoge = list(itertools.permutations(range(1, n+1)))
p = 0
q = 0
for i in range(len(hoge)):
if list(hoge[i]) == s:
p = i
if list(hoge[i]) == t:
q = i
print(abs(p - q))
| 0 | null | 121,059,852,470,560 | 275 | 246 |
a,b = map(str,input().split())
c = list(a)
d = list(b)
if len(c) == 1 and len(d) == 1:
print(int(a)*int(b))
else:
print(-1)
|
#!/usr/bin/python3
cmdvar_numlist=input()
cmdvar_spritd=cmdvar_numlist.split()
D,T,S=list(map(int,cmdvar_spritd))
if D/S<=T:
print("Yes")
else:
print("No")
| 0 | null | 80,596,829,448,318 | 286 | 81 |
a = input()
if a == "RSR":
print(1)
else :
print(a.count("R"))
|
W = input()
if W.count("R") > 0:
if W == "RRR":
print(3)
elif "RR" in W:
print(2)
else:
print(1)
else:
print(0)
| 1 | 4,861,608,508,348 | null | 90 | 90 |
n = int(input())
a = list(map(int,input().split()))
count = 0
for i in range(n):
minij =i
for j in range(i,n):
if a[j] < a[minij]:
minij = j
if a[i] > a[minij]:
count+=1
a[i],a[minij] = a[minij],a[i]
print(' '.join(map(str,a)))
print(count)
|
N = int(input())
line = list(map(int, input().split()))
cnt = 0
for i in range(N):
minj = i
for j in range(i+1, N):
if line[j] < line[minj]:
minj = j
if minj != i:
tmp = line[i]
line[i] = line[minj]
line[minj] = tmp
cnt += 1
print(' '.join(list(map(str, line))))
print(cnt)
| 1 | 21,004,887,520 | null | 15 | 15 |
N=int(input())
A=list(map(int, input().split()))
flag = 1
for i in range(len(A)):
if A[i] % 2 == 0:
if A[i] % 3 != 0 and A[i] % 5 != 0:
flag = 0
break
print(['DENIED', 'APPROVED'][flag])
|
def main():
input_name = input()
print(input_name[0:3])
if __name__=='__main__':
main()
| 0 | null | 42,087,074,700,650 | 217 | 130 |
h, w = map(int, input().split())
h_odd = (h+1)//2
h_even = h//2
w_odd = (w+1)//2
w_even = w//2
if h == 1 or w ==1:
print(1)
else:
ans = h_odd * w_odd + h_even *w_even
print(ans)
|
from sys import stdin
from copy import deepcopy
input = stdin.readline
N = int(input())
A = [int(input()) for _ in range(N)]
B = deepcopy(A)
S = deepcopy(A)
def p(N):
for i in range(len(N)):
if i == len(N) - 1:
print(N[i])
else:
print(N[i], end=" ")
cnt = 0
def insertionsort(n, g):
global cnt
for i in range(g, N):
v = A[i]
j = i - g
while j >= 0 and A[j] > v:
A[j + g] = A[j]
j = j - g
cnt += 1
A[j + g] = v
def shellsort(n):
h = 1
G = []
while h <= n:
G.append(h)
h = 3 * h + 1
G.reverse()
m = len(G)
print(m)
p(G)
for i in range(0, m):
insertionsort(n, G[i])
shellsort(N)
print(cnt)
for a in A:
print(a)
| 0 | null | 25,271,053,914,390 | 196 | 17 |
n, m = map(int, input().split())
ans = [0]*(n)
for i in range(m):
a = list(map(int, input().split()))
if n>=2:
if a[0] == 1:
if a[1] == 0:
print("-1")
exit()
a[0] -= 1
if ans[a[0]] == 0 or ans[a[0]] == a[1]:
ans[a[0]] = a[1]
else:
print("-1")
exit()
if n>=2:
for i in range(n):
if ans[0] == 0:
ans[0] = 1
print(ans[i],end="")
else:
print(ans[i],end="")
else:
print(ans[0])
|
#k = int(input())
#s = input()
#a, b = map(int, input().split())
#s, t = map(str, input().split())
#l = list(map(int, input().split()))
n = int(input())
s = input()
if (n % 2 != 0):
print("No")
exit()
for i in range(n//2):
if (s[i] != s[n//2 + i]):
print("No")
exit()
print("Yes")
| 0 | null | 103,490,728,095,018 | 208 | 279 |
n, m = map(int, input().split())
if n % 2 == 1:
a = [i for i in range(1, m+1)]
b = [i for i in reversed(range(m+1, 2*m+1))]
ab = [(x, y) for x, y in zip(a, b)]
else:
ab = []
x, y = (n-1)//2, n//2
if x % 2 != 0:
x, y = y, x
evenl = 1
evenr = x
while evenl < evenr:
ab.append((evenl, evenr))
evenl += 1
evenr -= 1
oddl = x+1
oddr = n-1
while oddl < oddr:
ab.append((oddl, oddr))
oddl += 1
oddr -= 1
ab = ab[:m]
for a, b in ab:
print(a, b)
|
def main():
n, m = map(int, input().split())
left = 1
right = n
is_shift = False
ans = []
while left < right:
if right - left <= n // 2 and not is_shift and n % 2 == 0:
left += 1
is_shift = True
ans.append([left, right])
left += 1
right -= 1
for l in range(m):
print(*ans[l])
if __name__ == "__main__":
main()
| 1 | 28,747,468,445,312 | null | 162 | 162 |
a, b = map(int, raw_input().split())
d = a // b
r = a % b
f = round(float(a)/float(b), 6)
print d,r,f
|
L = raw_input().split()
a = int(L[0])
b = int(L[1])
d = int(0)
r = int(0)
f = float(0)
d = a / b
r = a % b
f = float(a) / float(b)
print "{0} {1} {2:f}".format(d,r,f)
| 1 | 607,748,940,702 | null | 45 | 45 |
#import numpy as np
#import math
#from decimal import *
#from numba import njit
#@njit
def main():
X = int(input())
p = []
def pow5(n):
nonlocal p
if len(p) > n:
return p[n]
ans = pow(n,5)
p += ans,
return ans
a = 0
b = 0
while True:
if abs(X) + pow5(b) == pow5(a) or abs(X) - pow5(b) == pow5(a) :
a5 = pow5(a)
b5 = pow5(b)
if X == a5 - b5:
print(a,b)
elif X == a5 + b5:
print(a, -b)
elif X == -a5 - b5:
print(-a, b)
else:
print(-a, -b)
return
while abs(X) + pow5(b) > pow5(a):
a += 1
if abs(X) + pow5(b) == pow5(a) or abs(X) - pow5(b) == pow5(a) :
a5 = pow5(a)
b5 = pow5(b)
if X == a5 - b5:
print(a,b)
elif X == a5 + b5:
print(a, -b)
elif X == -a5 - b5:
print(-a, b)
else:
print(-a, -b)
return
a = 0
b += 1
main()
|
N, R = map(int, input().split())
# min()でまとめて書ける
print(R + 100 * (10-min(10, N)))
| 0 | null | 44,395,092,493,948 | 156 | 211 |
N,K = map(int,input().split())
res = [0]*(K+1)
ans = 0
MOD = 10**9+7
def make_divisors(n):
divisors = []
for i in range(1, int(n**0.5)+1):
if n % i == 0:
divisors.append(i)
if i != n // i:
divisors.append(n//i)
return divisors
for k in range(K,0,-1):
y = make_divisors(k)
s = K//k
tmp = pow(s, N, MOD)
val = tmp-res[k]
ans += k*val
for yy in y:
res[yy] += val
print(ans%MOD)
|
n,k=map(int,input().split())
mod=pow(10,9)+7
ans=[0]*(k+1)
# gcdがkiとなる数列。すべてがkiの倍数でかつ少なくとも一つkiを含む
for ki in range(k,0,-1):
a=k//ki
ans[ki]=pow(a,n,mod)
i=2
while i*ki<=k:
ans[ki]-=ans[i*ki]
i+=1
b=0
for ki in range(1,k+1):
b+=(ans[ki]*ki)%mod
b%=mod
print(b)
| 1 | 36,643,117,130,850 | null | 176 | 176 |
N=int(input())
A=list(map(int,input().split()))
ans=0
tree=1
node=sum(A)
flag=0
for i in A:
ans+=i
node-=i
if i>tree:
ans=-1
break
tree-=i
if tree<node:
ans+=tree
else:
ans+=node
tree=2*tree
print(ans)
|
[A,B] = list(map(int,input().split()))
nokori = A - B*2
if nokori>=0:
print(nokori)
else:
print(0)
| 0 | null | 93,128,942,597,498 | 141 | 291 |
import math
h,w=map(int,input().split())
if h>2 and w>1:
print(math.ceil(h*w/2))
if h==1 or w==1:
print(1)
|
dice = {v: k for k, v in enumerate(list(map(int, input().split())))}
adjacent = {k: v for k, v in enumerate(sorted(dice.keys()))}
q = int(input())
p = [(-1,2,4,1,3,-1),(3,-1,0,5,-1,2),(1,5,-1,-1,0,4),(4,0,-1,-1,5,1),(2,-1,5,0,-1,3),(-1,3,1,4,2,-1)]
for _ in range(q):
top, front = map(int, input().split())
x = dice[top]
y = dice[front]
print(adjacent[p[x][y]])
| 0 | null | 25,612,457,555,018 | 196 | 34 |
n, m, q = map(int, input().split())
abcd = []
for _ in range(q):
abcd.append(tuple(map(int, input().split())))
ans = 0
from itertools import combinations_with_replacement
for A in combinations_with_replacement(list(range(1, m+1)), n):
suma = 0
for a,b,c,d in abcd:
if A[b-1] - A[a-1] == c:
suma += d
ans = max(ans, suma)
print(ans)
|
from itertools import accumulate
n,m,k = map(int,input().split())
deskA = list(map(int,input().split()))
deskB = list(map(int,input().split()))
cumA = [0] + list(accumulate(deskA))
cumB = [0] + list(accumulate(deskB))
ans = 0
j = m
for i in range(n+1):
if cumA[i] > k:
continue
while cumA[i] + cumB[j] > k:
j -= 1
ans = max(i+j,ans)
print(ans)
| 0 | null | 19,335,451,427,032 | 160 | 117 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.