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
|
|---|---|---|---|---|---|---|
a,b=map(int,input().split())
lst={0:0,1:300000,2:200000,3:100000}
if a>3:
x=0
else:
x=a
if b>3:
y=0
else:
y=b
if x==1 and y==1:
ans=1000000
else :
ans=lst[x]+lst[y]
print(ans) | nn = input()
n = str(input())
if len(n) % 2 == 1:
print('No')
else:
a = n[0 : len(n)//2]
b = n[len(n)//2 : len(n)]
if a == b:
print('Yes')
else:
print('No') | 0 | null | 144,018,943,203,500 | 275 | 279 |
n=input()
t=h=0
for i in range(n):
x,y=map(str,raw_input().split())
if x==y:
t+=1
h+=1
elif x<y:
h+=3
else:
t+=3
print t,h | #coding: utf-8
p = [0,0]
n = int(input())
for i in range(n):
c1 = input().split(" ")
c2 = sorted(c1)
if c1[0] == c1[1]:
p[0] += 1
p[1] += 1
elif c1[0] == c2[0]:
p[1] += 3
else:
p[0] += 3
print(str(p[0]) + " " + str(p[1]))
| 1 | 1,991,104,636,330 | null | 67 | 67 |
a=[input() for i in range(2)]
a1=[int(i) for i in a[0].split()]
a2=[int(i) for i in a[1].split()]
k=a1[1]
for i in range(a1[0]-a1[1]):
if a2[i]<a2[i+k]:
print("Yes")
else:
print("No") | # -*- coding: utf-8 -*-
import sys
def main():
N,K = list(map(int, sys.stdin.readline().split()))
A_list = list(map(int, sys.stdin.readline().split()))
for i in range(K, len(A_list)):
if A_list[i] > A_list[i-K]:
print("Yes")
else:
print("No")
if __name__ == "__main__":
main()
| 1 | 7,051,378,787,560 | null | 102 | 102 |
import sys
count = 0
def insertionSort(A, n, g):
global count
for i in range(n):
v = A[i]
j = i - g
while j >= 0 and A[j] > v:
A[j+g] = A[j]
j = j - g
count += 1
A[j+g] = v
return A
def shellSort(A, n):
for i in range(m):
insertionSort(A, n, G[i])
return A
n = int(input())
A = []
for i in range(n):
A.append(int(input()))
G = [1]
m = 1
while True:
x = 3 * G[m-1] + 1
if x >= n: break
G.append(x)
m += 1
G = G[::-1]
shellSort(A, n)
print(m)
print(' '.join([str(i) for i in G]))
print(count)
for i in A:
print(i) | d=list(map(int,input().split()))
q=int(input())
class dice(object):
def __init__(self, d):
self.d = d
def roll(self,com):
a1,a2,a3,a4,a5,a6=self.d
if com=="E":
self.d = [a4,a2,a1,a6,a5,a3]
elif com=="W":
self.d = [a3,a2,a6,a1,a5,a4]
elif com=="S":
self.d = [a5,a1,a3,a4,a6,a2]
elif com=="N":
self.d = [a2,a6,a3,a4,a1,a5]
dice1=dice(d)
l=[]
for i in range(q):
l.append(list(map(int,input().split())))
c=["E","W","S","N"]
import random
for i in l:
while 1:
if dice1.d[0]==i[0] and dice1.d[1]==i[1]:
break
else:
dice1.roll(c[random.randint(1,2)])
print(dice1.d[2]) | 0 | null | 149,896,647,980 | 17 | 34 |
N = int(input())
edge = [[] for _ in range(N+1)]
d = [0] * (N+1)
f = [0] * (N+1)
for i in range(N):
t = list(map(int, input().split()))
for j in range(t[1]):
edge[t[0]].append(t[j+2])
#print(1)
def dfs(v, t):
if d[v] == 0:
d[v] = t
t += 1
else:
return t
for nv in edge[v]:
t = dfs(nv, t)
if f[v] == 0:
f[v] = t
t += 1
return t
t = 1
for i in range(1,1+N):
if d[i] == 0:
t = dfs(i, t)
for i in range(1,1+N):
print(i, d[i], f[i])
| def main():
a, b, k = map(int, input().split())
if k >= a and b >= k-a:
print(0, b-(k-a))
elif k >= a and b < k-a:
print(0, 0)
else:
print(a-k, b)
if __name__ == '__main__':
main()
| 0 | null | 52,437,074,549,828 | 8 | 249 |
import math
N = int(input())
Prime = []
ans = 0
def func(n):
while n % 2 == 0:
n = n // 2
Prime.append(2)
for i in range(3, int(math.sqrt(n)) + 1, 2):
while n % i == 0:
n = n //i
Prime.append(i)
if n > 2:
Prime.append(n)
func(N)
for i in set(Prime):
c = i
while N % c == 0:
N = N // c
ans += 1
c = c * i
print(ans) | import math
from collections import defaultdict
from itertools import accumulate
N=int(input())
data=defaultdict(int)
result=0
for i in range(2,int(math.sqrt(N))+1):
while N%i==0:
N//=i
data[i]+=1
if N!=1:
data[N]+=1
cumsum=list(accumulate(range(1,10**6*2)))
for value in data.values():
for i in range(10**6*2):
if value<cumsum[i]:
result+=i
break
if result==0:
if N!=1:
result=1
print(result) | 1 | 16,911,130,678,510 | null | 136 | 136 |
import math
def div(x, y): #x>y
A = 1
for i in range(1, int(math.sqrt(x))+1):
if x % i == 0 and y % i == 0:
A = max(A, i)
j = int(x/i)
if x % j == 0 and y % j == 0:
A = max(A, j)
return A
x, y = map(int, input().split(" "))
print(div(x,y))
| import sys
from decimal import Decimal as D, ROUND_FLOOR
def resolve(in_):
x = D(next(in_))
year = 0
deposit = D('100')
rate = D('1.01')
a = D('1.')
while deposit < x:
year += 1
deposit *= rate
deposit = deposit.quantize(a, rounding=ROUND_FLOOR)
return year
def main():
answer = resolve(sys.stdin)
print(answer)
if __name__ == '__main__':
main() | 0 | null | 13,425,333,043,232 | 11 | 159 |
def selectionSort(A, N):
for i in range(N):
minj = i
for j in range(i, N):
if A[j][1:] < A[minj][1:]:
minj = j
if i != minj:
tmp = A[i]
A[i] = A[minj]
A[minj] = tmp
return A
def bubbleSort(A, N):
for i in range(N):
for j in range(N - 1, i, -1):
if A[j][1:] < A[j - 1][1:]:
tmp = A[j]
A[j] = A[j - 1]
A[j - 1] = tmp
return A
if __name__ == '__main__':
n = int(input())
R = list(map(str, input().split()))
C = R[:]
SR = selectionSort(R, n)
BR = bubbleSort(C, n)
fStable = SR == BR
print(" ".join(map(str, BR)))
print("Stable")
print(" ".join(map(str, SR)))
if (fStable == True):
print("Stable")
else:
print("Not stable") | import copy
class Card:
def __init__(self, suit, number):
self.suit = suit
self.number = number
self.view = self.suit + str(self.number)
def bubble_sort(A):
count = 0
while True:
swapped = False
for i in range(len(A)-1):
if A[i+1].number < A[i].number:
A[i+1], A[i] = A[i], A[i+1]
count += 1
swapped = True
if not swapped:
return count
def selection_sort(A):
count = 0
for i in range(len(A)):
min_value = A[i].number
min_value_index = i
# print('- i:', i, 'A[i]', A[i], '-')
for j in range(i, len(A)):
# print('j:', j, 'A[j]:', A[j])
if A[j].number < min_value:
min_value = A[j].number
min_value_index = j
# print('min_value', min_value, 'min_value_index', min_value_index)
if i != min_value_index:
count += 1
A[i], A[min_value_index] = A[min_value_index], A[i]
# print('swap!', A)
return count
n = int(input())
A = []
for row in input().split():
suit, number = list(row)
A.append(Card(suit, int(number)))
def is_stable(A, B):
N = len(A)
for i_A in range(N-1):
for j_A in range(i_A+1, N):
for i_B in range(N-1):
for j_B in range(i_B+1, N):
if A[i_A].number == A[j_A].number and A[i_A].view == B[j_B].view and A[j_A].view == B[i_B].view:
return False
return B
bubble_sort_A = copy.deepcopy(A)
selection_sort_A = copy.deepcopy(A)
bubble_sort(bubble_sort_A)
print(*[elem.view for elem in bubble_sort_A])
if is_stable(A, bubble_sort_A):
print('Stable')
else:
print('Not stable')
selection_sort(selection_sort_A)
print(*[elem.view for elem in selection_sort_A])
if is_stable(A, selection_sort_A):
print('Stable')
else:
print('Not stable')
| 1 | 27,476,081,860 | null | 16 | 16 |
import numpy as np
n = int(input())
li_a = list(map(int, input().split()))
A = [0]*(10**5)
s = sum(li_a)
li_a = list(map(lambda x: x-1, li_a))
for a in li_a:
A[a] += 1
q = int(input())
for i in range(q):
b, c = map(int, input().split())
if A[b-1]>0:
A[c-1] += A[b-1]
s -= b * A[b-1]
s += c * A[b-1]
A[b-1] = 0
print(s)
else:
print(s) | n=list(input())
N=len(n)
k=int(input())
dp1=[[0 for i in range(k+1)] for j in range(N+1)]
dp2=[[0 for i in range(k+1)] for j in range(N+1)]
dp1[0][0]=1
for i in range(1,N+1):
x=int(n[i-1])
if i!=N and x!=0:
for j in range(k+1):
if j==0:
dp2[i][j]=dp1[i-1][j]+dp2[i-1][j]
else:
dp1[i][j]=dp1[i-1][j-1]
dp2[i][j]=dp1[i-1][j]+dp1[i-1][j-1]*(x-1)+dp2[i-1][j]+dp2[i-1][j-1]*9
elif i!=N and x==0:
for j in range(k+1):
if j==0:
dp1[i][j]=dp1[i-1][j]
dp2[i][j]=dp2[i-1][j]
else:
dp1[i][j]=dp1[i-1][j]
dp2[i][j]=dp2[i-1][j]+dp2[i-1][j-1]*9
elif i==N and x!=0:
for j in range(k+1):
if j==0:
dp2[i][j]=dp1[i-1][j]+dp2[i-1][j]
else:
dp2[i][j]=dp1[i-1][j]+dp1[i-1][j-1]*x+dp2[i-1][j]+dp2[i-1][j-1]*9
else:
for j in range(k+1):
if j==0:
dp2[i][j]=dp2[i-1][j]
else:
dp2[i][j]=dp1[i-1][j]+dp2[i-1][j]+dp2[i-1][j-1]*9
print(dp2[N][k]) | 0 | null | 43,942,306,900,398 | 122 | 224 |
n = int(input())
print(n//2 + (n % 2)*1)
| from sys import stdin, setrecursionlimit
def main():
input = stdin.buffer.readline
n, r = map(int, input().split())
if n >= 10:
print(r)
else:
print(r + 100 * (10 - n))
if __name__ == "__main__":
setrecursionlimit(10000)
main()
| 0 | null | 61,216,070,528,020 | 206 | 211 |
import sys
from collections import deque
input = sys.stdin.readline
def dfs(N):
alphabet = "abcdefghij"
stack = deque(["a"])
while stack:
s = stack.pop()
if len(s) == N:
print(s)
continue
for suffix in reversed(alphabet[:len(set(s)) + 1]):
stack.append("".join((s, suffix)))
def main():
N = int(input())
dfs(N)
if __name__ == "__main__":
main()
| N = int(input())
A = [0]*N
B = [0]*N
for i in range(N): A[i],B[i] = map(int,input().split())
A.sort()
B.sort()
sorted_A = A
sorted_B = B
if N % 2 != 0:
center_A = sorted_A[N//2]
center_B = sorted_B[N//2]
print(center_B - center_A + 1)
else:
center_A = (sorted_A[N//2-1] + sorted_A[N//2]) / 2
center_B = (sorted_B[N//2-1] + sorted_B[N//2]) / 2
print(int((center_B - center_A)*2 + 1)) | 0 | null | 34,969,954,675,670 | 198 | 137 |
X,K,D = map(int,input().split())
X = abs(X)
if X - D * K >= 0:
print(X - D * K)
else:
n = X // D
X -= n * D
if (K - n) % 2 == 0:
print(X)
else:
print(abs(X - D)) | import sys
#import numpy as np
import math
#from fractions import Fraction
#import itertools
#from collections import deque
#import heapq
#from fractions import gcd
input=sys.stdin.readline
n=int(input())
a=list(map(int,input().split()))
mod=10**9+7
ans=1
d={x:0 for x in range(n)}
for i in range(n):
if a[i]==0:
d[0]+=1
else:
m=a[i]
ans=(ans*(d[m-1]-d[m]))%mod
if ans<=0:
print(0)
exit()
d[m]+=1
if d[a[i]]>3:
print(0)
exit()
if d[0]==1:
print(ans*3%mod)
elif d[0]==2:
print(ans*6%mod)
elif d[0]==3:
print(ans*6%mod) | 0 | null | 67,752,402,349,500 | 92 | 268 |
n = input()
dic = set([])
for i in xrange(n):
order = raw_input().split()
if order[0][0] == 'i':
dic.add(order[1])
else:
print "yes" if order[1] in dic else "no" | def f1(s,a,b):
print(s[a:b+1])
return s
def f2(s,a,b):
temp = s[a:b+1]
return s[:a] + temp[::-1] + s[b+1:]
def f3(s,a,b,p):
return s[:a] + p + s[b+1:]
data = input()
q = int(input())
functions = {'print':f1, 'reverse':f2, 'replace':f3}
for i in range(q):
temp = [s if s.isalpha() else int(s) for s in input().split(' ')]
f = temp.pop(0)
data = functions[f](data,*temp) | 0 | null | 1,099,874,425,078 | 23 | 68 |
from collections import Counter
s=input()[::-1]
DP=[0]
num,point=0,1
for i in s:
num +=int(i)*point
num %=2019
DP.append(num)
point *=10
point %=2019
ans=0
DP=Counter(DP)
for v,m in DP.items():
if m>=2:
ans +=m*(m-1)//2
print(ans) | s = input()
s = s[::-1]
m = [0] * 2019
m[0] = 1
a = 0
d = 1
ans = 0
for si in s:
a = (a + int(si) * d) % 2019
d = (d * 10) % 2019
ans += m[a]
m[a] += 1
print(ans)
| 1 | 30,659,467,735,740 | null | 166 | 166 |
a = int(raw_input())
print a*a*a | #!/usr/bin/env python3
n, r = map(int, input().split())
print(r + 100 * (10 - n) * (10 > n))
| 0 | null | 31,665,350,493,216 | 35 | 211 |
from math import sqrt, floor
def is_prime(p):
for i in range(2, floor(sqrt(p)) + 1):
if not p % i:
return False
return True
n = int(input())
print(sum(is_prime(int(input())) for _ in range(n))) | N,K = map(int,input().split())
H = list(map(int,input().split()))
print(sum(K<=h for h in H)) | 0 | null | 89,044,321,112,228 | 12 | 298 |
import math,string,itertools,fractions,heapq,collections,re,array,bisect,sys,random,time, copy,bisect
#from operator import itemgetter
#from heapq import heappush, heappop
#import numpy as np
#from scipy.sparse.csgraph import breadth_first_order, depth_first_order, shortest_path, floyd_warshall, dijkstra, bellman_ford, johnson
#from scipy.sparse import csr_matrix
#from decimal import Decimal, ROUND_HALF_UP, ROUND_HALF_EVEN
import sys
sys.setrecursionlimit(10**7)
inf = 10**20
mod = 10**9 + 7
stdin = sys.stdin
ni = lambda: int(ns())
nf = lambda: float(ns())
na = lambda: list(map(int, stdin.readline().split()))
nb = lambda: list(map(float, stdin.readline().split()))
ns = lambda: stdin.readline().rstrip() # ignore trailing spaces
from decimal import Decimal
a, b = map(Decimal, input().split())
print(int(a*b)) | from decimal import Decimal
import sys
A,B = map(Decimal,input().split())
ans = int(A*B)
print(ans) | 1 | 16,638,351,195,200 | null | 135 | 135 |
N, K =map(int,input().split())
p = list(map(int,input().split()))
for i in range(N):
for n in range(N-1):
if p[n]>p[n+1]:
tmp = p[n]
p[n] = p[n+1]
p[n+1] = tmp
ans =0
for i in range(K):
ans += p[i]
print(ans) | n,k=map(int,input().split())
price=list(map(int,input().split()))
s_price=sorted(price)
mysum=0
for i in range(k):
mysum+=s_price[i]
print(mysum) | 1 | 11,648,455,054,912 | null | 120 | 120 |
import sys, bisect, math, itertools, heapq, collections
from operator import itemgetter
# a.sort(key=itemgetter(i)) # i番目要素でsort
from functools import lru_cache
# @lru_cache(maxsize=None)
sys.setrecursionlimit(10**8)
input = sys.stdin.readline
INF = float('inf')
mod = 10**9 + 7
eps = 10**-7
def inp():
'''
一つの整数
'''
return int(input())
def inpl():
'''
一行に複数の整数
'''
return list(map(int, input().split()))
class combination():
def __init__(self, mod):
'''
modを指定して初期化
'''
self.mod = mod
self.fac = [1, 1] # 階乗テーブル
self.ifac = [1, 1] # 階乗の逆元テーブル
self.inv = [0, 1] # 逆元計算用
def calc(self, n, k):
'''
nCk%modを計算する
'''
if k < 0 or n < k:
return 0
self.make_tables(n) # テーブル作成
k = min(k, n - k)
return self.fac[n] * (self.ifac[k] * self.ifac[n - k] %
self.mod) % self.mod
def make_tables(self, n):
'''
階乗テーブル・階乗の逆元テーブルを作成
'''
for i in range(len(self.fac), n + 1):
self.fac.append((self.fac[-1] * i) % self.mod)
self.inv.append(
(-self.inv[self.mod % i] * (self.mod // i)) % self.mod)
self.ifac.append((self.ifac[-1] * self.inv[-1]) % self.mod)
comb = combination(mod)
n, k = inpl()
ans = 0
# m個の0人の部屋を作る
for m in range(min(n, k + 1)):
# n個の部屋からm個の0人の部屋を選ぶ
a = comb.calc(n, m) % mod
# n個の部屋にm人を自由に割り当てる
b = comb.calc(n - 1, n - m - 1) % mod
ans += a * b % mod
print(ans % mod)
| # coding: utf-8
def main():
N = int(input())
tmp = 200001
ans = 0
A = list(map(int, input().split()))
for a in A:
if a < tmp:
ans += 1
tmp = a
print(ans)
if __name__ == "__main__":
main()
| 0 | null | 76,210,764,853,312 | 215 | 233 |
import numpy as np
n = int(input())
mod = 10**9 + 7
a = np.array(list(map(int, input().split())))
ans = 0
for i in range(len(bin(max(a)))):
num_1 = np.count_nonzero((a>>i)&1)
num_0 = n - num_1
ans += (2**i)*(num_1*num_0) % mod
ans %= mod
print(ans) | import numpy as np
n=int(input())
a=np.array(list(map(int,input().split())))
mod=10**9+7
s=0
for i in range(60):
bit = np.count_nonzero(a & 1)
s += bit*(n-bit)*(2**i)
a >>= 1
print(s % mod) | 1 | 122,914,040,838,052 | null | 263 | 263 |
import sys
input = sys.stdin.readline
from collections import *
def bfs(s):
q = deque([s])
dist = [-1]*N
dist[s] = 0
leaf = set()
while q:
v = q.popleft()
flag = True
for nv in G[v]:
if dist[nv]==-1:
dist[nv] = dist[v]+1
q.append(nv)
flag = False
if flag:
leaf.add(v)
return dist, leaf
N, u, v = map(int, input().split())
G = [[] for _ in range(N)]
for _ in range(N-1):
A, B = map(int, input().split())
G[A-1].append(B-1)
G[B-1].append(A-1)
d1, _ = bfs(u-1)
d2, leaf = bfs(v-1)
ans = 0
for i in range(N):
if i not in leaf and d1[i]<=d2[i]:
ans = max(ans, d2[i])
print(ans) | def minko_n(x,y,n):
D = 0
for i in range(len(x)):
D += (abs(x[i]-y[i]))**n
return D**(1/n)
def minko_f(x,y):
l = []
for i in range(len(x)):
l.append(abs(x[i]-y[i]))
return max(l)
n = int(input())
x = list(map(int,input().split()))
y = list(map(int,input().split()))
print(minko_n(x,y,1))
print(minko_n(x,y,2))
print(minko_n(x,y,3))
print(minko_f(x,y))
| 0 | null | 58,606,895,236,540 | 259 | 32 |
N = int(input())
lst = "abcdefghijklmnopqrstuvwxyz"
ans = ""
while N > 0:
ans = lst[(N-1)%26] + ans
N = (N-1)//26
print(ans) | import sys
input = sys.stdin.readline
N = int(input())
A = list(map(int, input().split()))
mass = [0]*(N+1)
for i in range(N):
mass[i+1] = mass[i] + A[i]
answer = 0
for i in range(N-1):
answer += (A[i]*(mass[N]-mass[i+1]))
print(answer % (10**9 + 7)) | 0 | null | 7,780,431,738,130 | 121 | 83 |
from collections import deque
n = int(input())
d = deque()
for _i in range(n):
line = input().split()
order = line[0]
if order in ('insert', 'delete'):
key = line[1]
if order == 'insert':
d.appendleft(key)
elif order == 'delete':
try:
d.remove(key)
except ValueError:
pass
elif order == 'deleteFirst':
d.popleft()
elif order == 'deleteLast':
d.pop()
else:
raise ValueError('Invalid order: {order}')
print(' '.join(d))
| from collections import deque
n = int(input())
dll = deque()
for i in range(n):
command = input().split()
if command[0] == 'insert':
dll.appendleft(command[1])
elif command[0] == 'delete':
try:
dll.remove(command[1])
except:
pass
elif command[0] == 'deleteFirst':
dll.popleft()
else:
dll.pop()
print(*dll) | 1 | 52,454,246,878 | null | 20 | 20 |
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) | a, b, c = (int(x) for x in input().split())
if a < b and b < c:
print('Yes')
else:
print('No')
| 0 | null | 15,547,805,146,770 | 166 | 39 |
import math
def print_list(a):
out = ''
for ai in a:
out += str(ai) + ' '
else:
out = out[:-1]
print(out)
def insertion_sort(a, n, g):
cnt = 0
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
return cnt
def shell_sort(a, n):
cnt = 0
m = 0
g = []
h = 1
while True:
if h > n:
break
m += 1
g.append(h)
h = 3 * h + 1
g.reverse()
for i in range(m):
cnt += insertion_sort(a, n, g[i])
print(m)
print_list(g)
print(cnt)
for i in a:
print(i)
n = int(input())
a = [0] * n
for i in range(n):
a[i] = int(input())
shell_sort(a, n)
| def insertion_sort(A, n, g, cnt):
for i in range(g, n):
v = A[i]
j = i - g
while j >= 0 and v < A[j]:
A[j+g] = A[j]
j -= g
cnt += 1
A[j+g] = v
return cnt
def shell_sort(A, n):
cnt = 0
h = 1
g = []
while h <= n:
g.append(h)
h = 3*h + 1
g.reverse()
m = len(g)
for i in range(m):
cnt = insertion_sort(A, n, g[i], cnt)
show(n, m, g, A, cnt)
def show(n, m, G, A, cnt):
print(m)
for i in range(m):
if i != m-1:
print(G[i], end = " ")
else:
print(G[i])
print(cnt)
for i in range(n):
print(A[i])
if "__main__" == __name__:
n = int(input())
data = []
for i in range(n):
data.append(int(input()))
shell_sort(data, n)
| 1 | 31,113,238,820 | null | 17 | 17 |
n=int(input())
cnt=0
Arm=[]
for i in range(n):
x,l=map(int,input().split())
Arm.append([x+l,x-l])
Arm.sort()
dis=-float('inf')
for i in range(n):
if dis<=Arm[i][1]:
cnt+=1
dis=Arm[i][0]
print(cnt)
| from enum import IntEnum
class Direction(IntEnum):
NORTH = 0
EAST = 1
SOUTH = 2
WEST = 3
class Dice:
"""Dice class implements the structure of a dice
having six faces.
"""
def __init__(self, v1, v2, v3, v4, v5, v6):
self.top = 1
self.heading = Direction.NORTH
self.values = [v1, v2, v3, v4, v5, v6]
def to_dice_axis(self, d):
return (d - self.heading) % 4
def to_plain_axis(self, d):
return (self.heading + d) % 4
def roll(self, d):
faces = [[(2, Direction.NORTH), (6, Direction.NORTH),
(6, Direction.WEST), (6, Direction.EAST),
(6, Direction.SOUTH), (5, Direction.SOUTH)],
[(4, Direction.EAST), (4, Direction.NORTH),
(2, Direction.NORTH), (5, Direction.NORTH),
(3, Direction.NORTH), (4, Direction.WEST)],
[(5, Direction.SOUTH), (1, Direction.NORTH),
(1, Direction.EAST), (1, Direction.WEST),
(1, Direction.SOUTH), (2, Direction.NORTH)],
[(3, Direction.WEST), (3, Direction.NORTH),
(5, Direction.NORTH), (2, Direction.NORTH),
(4, Direction.NORTH), (3, Direction.EAST)]]
f, nd = faces[self.to_dice_axis(d)][self.top-1]
self.top = f
self.heading = self.to_plain_axis(nd)
def value(self):
return self.values[self.top-1]
def run():
values = [int(v) for v in input().split()]
dice = Dice(*values)
for d in input():
if d == 'N':
dice.roll(Direction.NORTH)
if d == 'E':
dice.roll(Direction.EAST)
if d == 'S':
dice.roll(Direction.SOUTH)
if d == 'W':
dice.roll(Direction.WEST)
print(dice.value())
if __name__ == '__main__':
run()
| 0 | null | 45,055,187,083,268 | 237 | 33 |
def main():
# a,b,k = map(int,input().split())
# n,k = map(int,input().split())
s = int(input())
# a = list(map(int,input().split()))
# rsp = list(str(input()))
# l = [list(map(int, input().split())) for _ in range(n-1)]
# s = list(s)
print(int(s**2))
if __name__ == '__main__':
main() | n,m=map(int,input().split())
a=list(map(int,input().split()))
a.sort(reverse=True)
total=0
for i in range(m):
if a[i]>=(sum(a)/(4*m)):
total+=1
if total==m:
print("Yes")
else:
print("No") | 0 | null | 91,993,102,611,190 | 278 | 179 |
a, b, c, k = map(int, input().split())
count = 0
if a < k:
count += a
if a+b < k:
count -= k-a-b
else:
count = k
print(count) | l,r,d = map(int, input().split())
var=l//d
var1=r//d
ans=var1-var
if l%d==0:
ans+=1
print(ans)
| 0 | null | 14,779,696,260,512 | 148 | 104 |
import sys
def input():
return sys.stdin.readline().rstrip('\n')
def calc(X, K, D):
X = abs(X)
n = X // D
if K <= n:
return abs(X - K * D)
if (K - n) % 2 == 0:
return abs(X - n * D)
else:
return abs(X - (n + 1) * D)
(X, K, D) = tuple([int(s) for s in input().split()])
print(calc(X, K, D)) | #Is it Right Triangre?
n = int(input())
for i in range(n):
set = input(). split()
set = [int(a) for a in set] #int?????????
set.sort()
if set[0] ** 2 + set[1] ** 2 == set[2] ** 2:
print("YES")
else:
print("NO") | 0 | null | 2,591,232,878,542 | 92 | 4 |
import bisect,collections,copy,heapq,itertools,math,string
import numpy as np
import sys
sys.setrecursionlimit(10**7)
def _S(): return sys.stdin.readline().rstrip()
def I(): return int(sys.stdin.readline().rstrip())
def LI(): return list(map(int,sys.stdin.readline().rstrip().split()))
def LS(): return list(sys.stdin.readline().rstrip().split())
N = I()
L = LI()
# L = np.array(_L)
#C = np.zeros(N + 1)
# def test(a,b,c):
# if a<b+c and b<c+a and c<a+b:
# return True
# return False
# count = 0
# for pair in itertools.combinations(L, 3):
# # print(pair)
# if test(*pair):
# count += 1
# print(count)
# for i in range(N):
# for j in range(i+1,N):
from numba import njit
@njit
def f(A):
count = 0
for i in range(N):
for j in range(i + 1, N):
for k in range(j + 1, N):
count += (A[k] < A[i] + A[j])
return count
A = np.array(L)
A.sort()
print(f(A))
| import math
from functools import reduce
def lcm_base(x, y):
return (x * y) // math.gcd(x, y)
def lcm(*numbers):
return reduce(lcm_base, numbers, 1)
N,M = map(int,input().split())
a = list(map(lambda a: int(a)//2, input().split()))
g = lcm(*a)
if any([g // item % 2 == 0 for item in a]):
print(0)
else:
ans = M//g
ans = max(math.ceil(ans/2),0)
print(ans) | 0 | null | 137,047,249,515,588 | 294 | 247 |
import sys
sys.setrecursionlimit(10**7)
def dfs(G,v):
global ptr
first_order[v] = ptr
ptr += 1
seen[v] = True
for next in G[v]:
if seen[next]:
continue
dfs(G,next)
last_order[v] = ptr
ptr+=1
n = int(input())
G = [[] for _ in range(n)]
for _ in range(n):
a = list(map(int, input().split()))
u = a[0]
k = a[1]
v = a[2:]
for i in v:
G[u-1].append(i-1)
seen = [False]*n
first_order = [0]*n
last_order = [0]*n
ptr = 0
for i in range(n):
if seen[i]:
continue
dfs(G,i)
for i in range(n):
print('{} {} {}'.format(i+1,first_order[i]+1,last_order[i]+1))
| N = list(map(int, input().split()))
if sum(N) % 9: print('No')
else: print('Yes') | 0 | null | 2,212,103,660,700 | 8 | 87 |
import sys
from collections import deque
n = int(sys.stdin.readline().strip())
edges = [[] for _ in range(n)]
for _ in range(n):
tmp = list(map(int, sys.stdin.readline().strip().split(" ")))
for node in tmp[2:]:
edges[tmp[0] - 1].append(node-1)
# print(edges)
distance = [0] * n
q = deque()
q.append((0, 0))
visited = set()
while q:
node, d = q.popleft()
# print(node, d)
if node in visited:
continue
distance[node] = d
visited.add(node)
for next in edges[node]:
# print("next", next)
q.append((next, d + 1))
for i, d in enumerate(distance):
if i == 0:
print(1, 0)
else:
print(i + 1, d if d > 0 else -1)
| from sys import stdin
from collections import deque
n = int(stdin.readline())
d = [-1] * (n + 1)
def bfs(G):
d[1] = 0
dq = deque([1])
while len(dq) > 0:
v = dq.popleft()
for c in G[v]:
if d[c] < 0:
d[c] = d[v] + 1
dq.append(c)
for i, x in enumerate(d[1:], start=1):
print(i, x)
G = [0]
for i in range(n):
G.append(list(map(int, stdin.readline().split()[2:])))
bfs(G) | 1 | 4,796,953,778 | null | 9 | 9 |
import heapq
from sys import stdin
input = stdin.readline
#入力
# s = input()
n = int(input())
# n,m = map(int, input().split())
# a = list(map(int,input().split()))
# a = [int(input()) for i in range()]
xl=[]
for i in range(n):
x,l = map(int, input().split())
xl.append((x,l))
def main():
p = []
for x,l in xl:
p.append([x-l,x+l])
p = sorted(p, key=lambda x:x[1])
ans = 0
mx = -10**10
for st in p:
s,t = st[0],st[1]
if s>=mx:
ans+=1
mx=t
print(ans)
if __name__ == '__main__':
main() | import heapq
def main():
N, M = list(map(int, input().split(' ')))
S = input()
# 最短手数のdpテーブルを作る
T = S[::-1] # ゴールから逆順にたどる（最後に逆にする）
dp = [-1] * (N + 1)
que = [0] * M
for i, t in enumerate(T):
if i == 0:
dp[0] = 0
continue
if len(que) == 0:
print(-1)
return
index = heapq.heappop(que)
if t == '1':
continue
dp[i] = 1 + dp[index]
while len(que) < M:
heapq.heappush(que, i)
dp.reverse()
# 細切れに進んでいく
path = list()
target = dp[0] - 1
cnt = 0
for i in range(N + 1):
if dp[i] != target:
cnt += 1
else:
path.append(cnt)
cnt = 1
target -= 1
print(' '.join(map(str, path)))
if __name__ == '__main__':
main()
| 0 | null | 114,518,268,645,872 | 237 | 274 |
if __name__ == "__main__":
a, b, c = map( int, input().split() )
if a < b < c:
print("Yes")
else:
print("No") | def isIncremental(a, b, c):
"""
a: int
b: int
c: int
returns "Yes" if a < b < c, otherwise "No"
>>> isIncremental(1, 3, 8)
'Yes'
>>> isIncremental(3, 8, 1)
'No'
>>> isIncremental(1, 1, 1)
'No'
"""
if a >= b:
return "No"
elif b >= c:
return "No"
else:
return "Yes"
if __name__ == '__main__':
# import doctest
# doctest.testmod()
ival = input().split(' ')
print(isIncremental(int(ival[0]), int(ival[1]), int(ival[2]))) | 1 | 390,379,241,682 | null | 39 | 39 |
# 高橋君と青木君がモンスターを闘わせます。
# 高橋君体力 A 攻撃力 B です。
# 青木君体力 C 攻撃力 D です。
# 高橋君→青木君→高橋君→青木君→... の順に攻撃を行います。
# このことをどちらかのモンスターの体力が 0 以下になるまで続けたとき、
# 先に自分のモンスターの体力が 0 以下になった方の負け、そうでない方の勝ちです。
# 高橋君が勝つなら Yes、負けるなら No を出力してくださ
a, b, c, d = list(map(int, input(). split()))#10 9 10 10
while True:
c -= b
if c <= 0:
print("Yes")
break
a -= d
if a <= 0:
print("No")
break
| A,B,C,D = map(int,input().split())
while A>=0 or C>=0:
C=C-B
if C <= 0:
print('Yes')
exit()
A=A-D
if A <=0:
print('No')
exit() | 1 | 29,699,645,714,882 | null | 164 | 164 |
from itertools import groupby
s=input()
if s[0]=='>':
s='<'+s
g=groupby(s)
a=[]
for i,j in g:
a.append(len(list(j)))
def sum(n):
return n*(n+1)//2
x=0
if len(a)%2==1:
a+=[1]
for i in range(0,len(a),2):
x+=sum(min(a[i],a[i+1])-1)
x+=sum(max(a[i],a[i+1]))
print(x)
| import math
a,b,C = map(float,input().split())
C_rad=math.pi*C/180
print("{0:.8f}".format(math.sin(C_rad)*a*b/2))
print("{0:.8f}".format(a+b+math.sqrt(a**2+b**2-2*a*b*math.cos(C_rad))))
print("{0:.8f}".format(b*math.sin(C_rad))) | 0 | null | 78,298,390,515,460 | 285 | 30 |
N, K, C = map(int, input().split())
S = input()
s = []
count = 0
for i in range(N):
if len(s) == K:
break
if count == 0:
if S[i] == 'x':
continue
else:
count = C
s.append(i+1)
else:
count -= 1
s2 = []
count = 0
for i in range(N-1, -1, -1):
if len(s2) == K:
break
if count == 0:
if S[i] == 'x':
continue
else:
s2.append(i+1)
count = C
else:
count -= 1
for a, b in zip(s, s2[::-1]):
if a == b:
print(a)
| X,N = map(int,input().split())
p = [int(i) for i in input().split()]
if N==0:
print(X)
else:
pN=[]
for j in range(N):
pj = p[j]-X
pN.append(pj)
pN.sort()
p0 = pN[0]-1
p1 = pN[N-1]+1
list_p = list(range(p0,p1+1,1))
result = list(set(list_p)-set(pN))
k0 = abs(result[0])
for k in result:
k1 = abs(k)
if k1<k0:
k0 = k1
cnt = 0
for l in result:
if l == (-1)*k0:
cnt+=1
if cnt==0:
print(X+k0)
else:
print(X-k0) | 0 | null | 27,389,357,651,824 | 182 | 128 |
x,y,z= map(str, input().split())
print(z,x,y, sep=' ') | import sys
if __name__ == '__main__':
a, b, c = map(int, input().split())
print(c, a, b)
| 1 | 37,837,820,518,464 | null | 178 | 178 |
N, X, T = list(map(int,input().split()))
if (N%X!=0):
ans = (N//X + 1) * T
else:
ans = (N//X) * T
print(ans)
| pi = 3.141592653589
r = float(input())
c = pi*r**2
s = 2*pi*r
print('%.5f %.5f' % (c,s)) | 0 | null | 2,440,204,998,432 | 86 | 46 |
all_ele = []
sum_ele = []
h,w = [int(x) for x in input().split()]
for ele in range(h):
all_ele.append([int(x) for x in input().split()])
all_ele[ele].append(sum(all_ele[ele]))
all_ele.append([int(x) for x in range(w+1)])
for a in range(len(all_ele[0])):
for b in range(h):
sum_ele.append(all_ele[b][a])
all_ele[h][a] = sum(sum_ele)
sum_ele = []
for out1 in all_ele:
print(' '.join(map(str,out1)))
| r, c = map(int, input().split())
x = []
for _ in range(r):
x.append(list(map(int, input().split())))
c_line_sum = []
for i in range(c): # 列の総和の計算
t = []
for j in range(r):
t.append(x[j][i])
c_line_sum.append(sum(t))
for i in range(r): # 行の総和の計算
x[i].append(sum(x[i]))
c_line_sum.append(sum(c_line_sum))
x.append(c_line_sum)
for m in x:
print(*m)
| 1 | 1,362,333,766,828 | null | 59 | 59 |
n, m = map(int, input().split())
a = list(map(int, input().split()))
a.sort(reverse=True)
if len(list(filter(lambda v: v * 4 * m >= sum(a), a[:m]))) == m:
print("Yes")
else:
print("No")
| a,b,m = map(int, input().split())
aprice = list(map(int, input().split()))
bprice = list(map(int, input().split()))
c = sorted(aprice)
d = sorted(bprice)
e = c[0]+d[0]
f =0
for i in range(m):
x,y,k = map(int, input().split())
f =aprice[x-1]+bprice[y-1]-k
if(e>f):
e = f
print(e) | 0 | null | 46,228,977,550,900 | 179 | 200 |
def main():
n = list(input())
k = int(input())
N = len(n)
for i in range(N):
n[i] = int(n[i])
dp1 = [[0 for _ in range(k+1)] for _ in range(N+1)]
dp2 = [[0 for _ in range(k+1)] for _ in range(N+1)]
dp1[0][0] = 1
for i in range(N):
for j in range(k+1):
dp2[i+1][j] += dp2[i][j]
if j < k:
dp2[i+1][j+1] += dp2[i][j]*9
if n[i]:
dp2[i+1][j] += dp1[i][j]
if j == k:
continue
dp1[i+1][j+1] += dp1[i][j]
dp2[i+1][j+1] += dp1[i][j] * (n[i]-1)
else:
dp1[i+1][j] += dp1[i][j]
print(dp1[N][k]+dp2[N][k])
if __name__ == "__main__":
main() | print(["No","Yes"]["7" in input()]) | 0 | null | 55,351,759,502,068 | 224 | 172 |
ma = lambda :map(int,input().split())
ni = lambda:int(input())
import collections
import math
import itertools
import fractions
gcd = fractions.gcd
a,b = ma()
print(a*b//gcd(a,b))
| a, b = map(int, input().split())
if a < b:
a, b = b, a
c = a
d = b
r = c // d
m = c % d
while True:
if m == 0:
break
else:
c = d
d = m
m = c % d
print(int(a * b / d)) | 1 | 113,330,522,212,340 | null | 256 | 256 |
N = int(input())
A = list(map(int, input().split()))
A = sorted(A)
MAX_A = 1000001
dp = [0]*MAX_A
for i in A:
if dp[i] == 0:
for j in range(i, MAX_A,i):
dp[j] += 1
else:
dp[i] += 1
c = 0
for i in A:
if dp[i] == 1:
c += 1
print(c) | # 問題文誤読して30分経過してた
# ソートしたとき「自分より小さいいずれの値も自分の素因数に含まれない」
# これはなんか実装しにくいので、A<10^6を利用して、調和級数的なノリでやってみる
n = int(input())
a = sorted(list(map(int, input().split())))
t = {}
for av in a:
if av not in t:
t[av] = 1
else:
t[av] += 1
limit = a[-1]
d = [True] * (limit + 1)
for av in a:
start = av
# 複数あった場合は自分自身も粛清の対象になる
if t[av] == 1:
start *= 2
for i in range(start, limit + 1, av):
d[i] = False
ans = 0
for av in a:
if d[av]:
ans += 1
print(ans) | 1 | 14,447,564,659,268 | null | 129 | 129 |
#!/usr/bin/env python3
def main():
s = input()
t = input()
ans = float("inf")
add = 0
for j in range(len(s) - len(t) + 1):
tans = 0
for i in range(len(t)):
if s[i + add] == t[i]:
pass
else:
tans += 1
add += 1
ans = min(ans, tans)
print(ans)
main()
| S=input()
T=input()
s=len(S)
t=len(T)
A=[]
for i in range(s-t+1):
word=S[i:i+t]
a=0
for j in range(t):
if word[j]==T[j]:
a+=1
else:
a+=0
A.append(t-a)
print(min(A)) | 1 | 3,691,934,269,308 | null | 82 | 82 |
X, K, D = map(int, input().split())
X = abs(X)
if X - K*D >= 0:
print(X - K*D)
else:
M = X // D
K -= M
X -= M*D
if K % 2:
X -= D
print(abs(X))
| x = int(input())
h500 = x // 500
h5 = (x%500) //5
print(h500 * 1000 + h5* 5) | 0 | null | 23,965,054,545,818 | 92 | 185 |
S = input()
print(S[:3]) | import math
a, b, x = map(int, input().split())
theta = math.atan((-2) * x / (a ** 3) + 2 * b / a)
if a * math.tan(theta) > b:
theta = math.atan2(a * b * b, 2 * x)
print(math.degrees(theta)) | 0 | null | 88,712,901,684,450 | 130 | 289 |
# -*- config: utf-8 -*-
if __name__ == '__main__':
hills = []
for i in range(10):
tmp = raw_input()
hills.append(int(tmp))
hills.sort(reverse=True)
for i in range(3):
print hills[i] | A, B, M = map(int, input().split())
a = list(map(int, input().split()))
b = list(map(int, input().split()))
ans = 10**9
for i in range(M):
x, y, c = map(int, input().split())
if ans > a[x-1] + b[y-1] - c:
ans = a[x-1] + b[y-1] - c
if min(a) + min(b) < ans:
ans = min(a) + min(b)
print(ans)
| 0 | null | 27,097,323,151,734 | 2 | 200 |
s = input()
ans = 0
a = []
for i in s:
if i == 'R':
ans += 1
else :
ans = 0
a.append(ans)
print(max(a)) | S = str(input())
count = 0
result = 0
for i in S:
if i == 'R':
count+=1
if count>result:
result = count
else:
count=0
print(result)
| 1 | 4,806,825,245,790 | null | 90 | 90 |
import sys
def I(): return int(sys.stdin.readline().rstrip())
N = I()
for i in range(int(N**.5),0,-1):
if N % i == 0:
print(i+(N//i)-2)
exit()
| # -*- 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 | 83,670,087,873,540 | 288 | 96 |
a,b=map(int,input().split())
print('Yes') if a==b else print('No') | def main():
a, b = map(int, input().split())
if a == b:
print("Yes")
else:
print("No")
if __name__ == "__main__":
main() | 1 | 82,825,553,799,030 | null | 231 | 231 |
N=int(input())
A=[int(i) for i in input().split()]
C=0
for i in range(N):
minj=i
for j in range(i,N):
if A[j]<A[minj]:
minj=j
if i!=minj:
t=A[i]
A[i]=A[minj]
A[minj]=t
C+=1
# print(minj)
for i in range(N):
A[i]=str(A[i])
print(" ".join(A))
print(C) | # coding: utf-8
s, w = map(int, input().split())
print("unsafe") if s <= w else print("safe") | 0 | null | 14,693,683,535,872 | 15 | 163 |
INF = 10000000000
def merge(A, left, mid, right):
global num
leftA = A[left:mid]
rightA = A[mid:right]
leftA.append(INF)
rightA.append(INF)
l = 0
r = 0
for i in range(left, right):
num += 1
if leftA[l] <= rightA[r]:
A[i] = leftA[l]
l += 1
else:
A[i] = rightA[r]
r += 1
def mergeSort(A, left, right):
if right - left < 2:
return
mid = left + (right - left) // 2
mergeSort(A, left, mid)
mergeSort(A, mid, right)
merge(A, left, mid, right)
if __name__ == "__main__":
n = int(input())
S = list(map(int, input().split()))
num = 0
mergeSort(S, 0, len(S))
print(" ".join(map(str, S)))
print(num) | X, Y = map(int, input().split())
mod = 10**9 + 7
def permute(n, m):
ret = 1
while n >= m:
ret *= n
# ret %= mod
n -= 1
return ret
def count_combinations(n, m):
fact = [1] * (n + 1)
inv = [i for i in range(n+1)]
fact_inv = [1] * (n + 1)
for i in range(2, n+1):
fact[i] = fact[i-1] * i % mod
inv[i] = (-inv[mod%i]*(mod//i))%mod
# inv[i] = mod - inv[mod % i] * (mod // i) % mod
fact_inv[i] = fact_inv[i-1] * inv[i] % mod
ret = (fact[n] * fact_inv[m] * fact_inv[n-m]) % mod
return ret
def count_comb2(n, m):
fact = [1, 1] # fact[n] = (n! mod p)
factinv = [1, 1] # factinv[n] = ((n!)^(-1) mod p)
inv = [0, 1] # factinv 計算用
for i in range(2, n + 1):
fact.append((fact[-1] * i) % mod)
inv.append((-inv[mod % i] * (mod // i)) % mod)
factinv.append((factinv[-1] * inv[-1]) % mod)
if (m < 0) or (n < m):
return 0
m = min(m, n - m)
return fact[n] * factinv[m] * factinv[n-m] % mod
ret = 0
if (X+Y)%3 == 0:
m = (2*X - Y) // 3
n = (2*Y - X) // 3
if m >= 0 and n >= 0:
ret = count_combinations(n+m, m)
# ret = count_comb2(n+m, m)
print(ret)
| 0 | null | 75,103,967,278,080 | 26 | 281 |
def insertion_sort(numbers, n, g):
"""insertion sort method
(only elements whose distance is larger than g are the target)
Args:
numbers: list of elements to be sorted
n: len(numbers)
g: distance
Returns:
partially sorted list, counter
"""
counter = 0
copied_instance = []
for data in numbers:
copied_instance.append(data)
for i in range(g, n):
target = copied_instance[i]
j = i - g
while j >= 0 and target < copied_instance[j]:
copied_instance[j + g] = copied_instance[j]
j -= g
counter += 1
copied_instance[j + g] = target
return copied_instance, counter
def shell_sort(numbers, n, key=lambda x: x):
"""shell sort method
Args:
numbers: list of elements to be sorted
n: len(numbers)
Returns:
sorted numbers, used G, swapped number
"""
counter = 0
copied_instance = []
for data in numbers:
copied_instance.append(data)
G = [1]
g = 4
while g < len(numbers):
G.append(g)
g = g * 3 + 1
G = G[::-1]
for g in G:
copied_instance, num = insertion_sort(copied_instance, n, g)
counter += num
return copied_instance, G, counter
length = int(raw_input())
numbers = []
counter = 0
while counter < length:
numbers.append(int(raw_input()))
counter += 1
numbers, G, counter = shell_sort(numbers, length)
print(len(G))
print(" ".join([str(x) for x in G]))
print(counter)
for n in numbers:
print(str(n)) | import math
cnt = 0
def insertionSort(A,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]
cnt += 1
j -= g
A[j+g] = v
def shellSort(A, n):
g = int(n/2) + 1
G = []
while g > 0:
G.append(g)
insertionSort(A, n, g)
g = int(g/2)
return G
n = int(input())
A = []
for _ in range(n):
A.append(int(input()))
G = shellSort(A,n)
print(len(G))
print(" ".join(map(str, G)))
print(cnt)
for i in A:
print(i)
| 1 | 28,911,856,008 | null | 17 | 17 |
x, y = map(int, input().split())
ans = 0
if x + y == 2:
ans += 400000
ans += ((4-min(4, x)) + (4-min(4, y))) * 100000
print(ans) | x, y = input().split()
prizes = {'1': 300000, '2': 200000, '3': 100000}
ans = prizes.get(x, 0) + prizes.get(y, 0)
if x == y == '1':
ans += 400000
print(ans)
| 1 | 140,946,341,455,782 | null | 275 | 275 |
n,k=map(int,input().split())
n=list(map(int,input().split()))
a=0
for i in n:
if i>=k:
a+=1
print(a)
| mem_num, over_height = map(int, input().split())
members_hgt = list(map(int, input().split()))
cnt = 0
for i in members_hgt:
if i >= over_height:
cnt += 1
print(cnt) | 1 | 179,668,287,085,342 | null | 298 | 298 |
N, M = map(int, input().split())
AB = [list(map(int, input().split())) for _ in range(M)]
class UnionFind(object):
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]
uf = UnionFind(N)
for a, b in AB:
uf.union(a - 1, b - 1)
max_ = 0
roots = uf.roots()
for r in roots:
max_ = max(max_, uf.size(r))
print(max_)
| N,X,Y = (int(x) for x in input().split())
A = [0]*(N)
for i in range(1,N):
for j in range(i+1,N+1):
if j <= X or i >= Y:
A[j-i] += 1
else:
A[min((j-i),(abs(i-X)+abs(j-Y)+1))] += 1
for i in range(1,N):
print(A[i])
| 0 | null | 24,074,111,379,162 | 84 | 187 |
import sys
read = sys.stdin.buffer.read
readline = sys.stdin.buffer.readline
readlines = sys.stdin.buffer.readlines
sys.setrecursionlimit(10 ** 7)
s = list(readline().rstrip().decode())
k = int(read())
if len(set(s)) == 1:
print(len(s) * k // 2)
exit()
ans = 0
memo = 0
flag = True
for i, (bf, af) in enumerate(zip(s, s[1:])):
if s[0] == af and flag:
memo += 1
else:
flag = False
if bf == af:
ans += 1
s[i + 1] = '?'
ans *= k
if s[-1] == s[0] and memo % 2 == 0:
ans += k - 1
print(ans)
| S=list(input())
K=int(input())
cnt=cnt2=0
s=S*2
if len(set(S))==1:
print(len(S)*K//2);exit()
for i in range(len(S)-1):
if S[i+1]==S[i]:
cnt+=1
S[i+1]="#"
for i in range(len(s)-1):
if s[i+1]==s[i]:
cnt2+=1
s[i+1]="#"
print(cnt+(cnt2-cnt)*(K-1)) | 1 | 175,139,674,448,662 | null | 296 | 296 |
from math import sqrt
a,b,c,d=map(float,input().split())
e=sqrt((c-a)**2+(d-b)**2)
print(e)
| import math
x1,y1,x2,y2 = map(float,raw_input().split(' '))
x = abs(x1-x2);
y = abs(y1-y2);
a = math.sqrt(x**2 + y**2)
print a | 1 | 159,495,471,392 | null | 29 | 29 |
#dp
#dp[T] T分での最大幸福 幸福度B、時間A
N,T = map(int,input().split())
li = [list(map(int,input().split())) for _ in range(N)]
li = sorted(li,key=lambda x: x[0])
dp = [0]*T
counter = 0
for i in range(N-1):
A,B = li[i]
counter = max(counter,max(dp)+B)
if A>T-1:
continue
for t in range(T-A-1,-1,-1):
dp[t+A]=max(dp[t]+B,dp[t+A])
print(max(max(dp)+li[N-1][1],counter))
| n = int(input())
Building = [[[0 for r in range(11)] for f in range(4)] for b in range(5)]
for i in range(n):
b, f, r, v = map(int, input().split())
Building[b][f][r] += v
for b in range(1, 5):
for f in range(1, 4):
for r in range(1, 11):
print(" " + str(Building[b][f][r]), end = "")
print()
if b != 4:
print("####################") | 0 | null | 76,577,957,694,592 | 282 | 55 |
import sys
sys.setrecursionlimit(10**7)
INTMAX = 9223372036854775807
INTMIN = -9223372036854775808
DVSR = 1000000007
def POW(x, y): return pow(x, y, DVSR)
def INV(x, d=DVSR): return pow(x, d - 2, d)
def DIV(x, y, d=DVSR): return (x * INV(y, d)) % d
def LI(): return [int(x) for x in input().split()]
def LF(): return [float(x) for x in input().split()]
def LS(): return input().split()
def II(): return int(input())
N,P=LI()
S=input()
if P == 2 or P == 5:
res = 0
for i in range(N):
if int(S[i])%P == 0:
res += i+1
print(res)
else:
RESTS=[0]*(P+1)
RESTS[0] = 1
POWS=[0]*(N+1)
POWS[0]=1
res = 0
for i in range(N): POWS[i+1] = (POWS[i]*10)%P
cur = 0
for i in range(N):
cur += (int(S[N-1-i])*POWS[i])
cur %= P
res += RESTS[cur]
RESTS[cur] += 1
print(res)
| N, P = map(int, input().split())
S = input()
if P == 2:
ans = 0
for i, d in enumerate(map(int, S)):
if d % 2 == 0:
ans += i+1
print(ans)
elif P == 5:
ans = 0
for i, d in enumerate(map(int, S)):
if d % 5 == 0:
ans += i+1
print(ans)
else:
mods = [0] * P
mods[0] = 1
cur_mod = 0
for i, digit in enumerate(map(int, S)):
cur_mod += pow(10, N-i-1, P) * digit
cur_mod %= P
mods[cur_mod] += 1
ans = 0
for count in mods:
ans += count * (count - 1) // 2
print(ans) | 1 | 58,399,236,063,594 | null | 205 | 205 |
def havediv( target, elm):
s = target / elm
if target == s*elm:
return True
else:
return False
if __name__ == "__main__":
v = map( int, raw_input().split())
ct = 0
i = v[0]
while i <= v[1]:
if havediv( v[2], i):
ct += 1
i += 1
print ct | ins = input().split()
a = int(ins[0])
b = int(ins[1])
c = int(ins[2])
print(len([x for x in list(range(a, b + 1)) if c % x == 0])) | 1 | 562,407,922,598 | null | 44 | 44 |
import numpy as np
N = input()
K = int(input())
dp = np.zeros((len(N)+1, K+1), np.int64)
dp[1, 1] = 1
for d in range(1, len(N)):
dp[d+1] = dp[d]
dp[d+1, 1:] += dp[d, :-1]
ans = 0
for i, c in enumerate(N):
n = len(N)-i
if c != '0':
ans += np.sum(dp[:n, K]) * (9 ** K)
ans += dp[n, K] * (int(c) - 1) * (9 ** (K-1))
K -= 1
if K == 0:
ans += 1
break
print(ans) | #coding:utf-8
import sys,os
from collections import defaultdict, deque
from fractions import gcd
from math import ceil, floor
sys.setrecursionlimit(10**6)
write = sys.stdout.write
dbg = (lambda *something: print(*something)) if 'TERM_PROGRAM' in os.environ else lambda *x: 0
def main(given=sys.stdin.readline):
input = lambda: given().rstrip()
LMIIS = lambda: list(map(int,input().split()))
II = lambda: int(input())
XLMIIS = lambda x: [LMIIS() for _ in range(x)]
YN = lambda c : print('Yes') if c else print('No')
MOD = 10**9+7
list_N = list(map(int,list(input())))
len_N = len(list_N)
list_N = [0] + list_N
K = II()
dp0 = []
dp1 = []
for i in range(len_N+1):
dp0.append([0]*(K+1))
dp1.append([0]*(K+1))
for i in range(1,len_N+1):
dp0[i][0] = 1
dp0[1][1] = max(list_N[1]-1,0)
dp1[1][1] = 1
for i in range(2,len_N+1):
dp1[i][0] = dp1[i-1][0]
for j in range(1,K+1):
num = list_N[i]
if num > 0:
dp0[i][j] = dp0[i-1][j-1] * 9 + dp0[i-1][j] + dp1[i-1][j-1] * (num-1) + dp1[i-1][j]
dp1[i][j] = dp1[i-1][j-1]
else:
dp0[i][j] = dp0[i-1][j-1] * 9 + dp0[i-1][j]
dp1[i][j] = dp1[i-1][j]
print(dp0[len_N][K]+dp1[len_N][K])
dbg(dp0[len_N][K],dp1[len_N][K])
if __name__ == '__main__':
main() | 1 | 76,171,521,372,540 | null | 224 | 224 |
import queue
N = int(input())
ab = []
deg = [0 for i in range(N)]
child = [[] for _ in range(N)]
edge = {}
color = [0 for _ in range(N-1)]
for i in range(N-1):
tmp = list(map(int, input().split()))
deg[tmp[0]-1] += 1
deg[tmp[1]-1] += 1
child[tmp[0]-1].append(tmp[1]-1)
child[tmp[1]-1].append(tmp[0]-1)
tmp = [tmp[0]-1, tmp[1]-1]
edge[tuple(tmp)] = i
q = queue.Queue()
q.put([None, 0, None])
used = [0]
# parent, self, color
while not q.empty():
current = q.get()
if current[0] is not None:
cnt = 1
for c in child[current[1]]:
# if c in used:
# continue
used.append(c)
if cnt == current[2]:
cnt += 1
q.put([current[1], c, cnt])
ind = [current[1], c] if current[1] < c else [c, current[1]]
color[edge[tuple(ind)]] = cnt
child[c].remove(current[1])
cnt += 1
else:
for i, c in enumerate(child[current[1]]):
used.append(c)
q.put([current[1], c, i+1])
ind = [current[1], c] if current[1] < c else [c, current[1]]
#print(edge[tuple(ind)], i+1)
color[edge[tuple(ind)]] = i+1
child[c].remove(current[1])
print(max(deg))
for c in color:
print(c) | n=int(input())
ki=[[] for _ in range(n)]
hen=[tuple(map(int,input().split())) for i in range(n-1)]
color={(hen[i][0]-1,hen[i][1]-1):0 for i in range(n-1)}
for i in range(n-1):
a,b=hen[i][0],hen[i][1]
ki[a-1].append(b-1)
ki[b-1].append(a-1)
mcol=0
ne=0
for i in range(n):
if len(ki[i])>mcol:
mcol=len(ki[i])
ne=i
print(mcol)
from collections import deque
d=deque()
d.append(ne)
visited=[False]*n
visited[ne]=True
col=[0]*n
while d:
g=d.popleft()
for i in ki[g]:
if visited[i]:
continue
d.append(i)
visited[i]=True
if g>i:
x,y=i,g
else:
x,y=g,i
color[(x,y)]=col[g]%mcol+1
col[g],col[i]=color[(x,y)],color[(x,y)]
for i in hen:
print(color[(i[0]-1,i[1]-1)]) | 1 | 136,260,034,875,380 | null | 272 | 272 |
# -*- coding: utf-8 -*-
str = raw_input()
s = []
for c in str:
s.append(c.lower() if c.isupper() else c.upper())
print ''.join(s) | def main():
X = int(input())
c = 600
k = 8
while True:
if X < c:
print(k)
break
c += 200
k -= 1
if __name__ == '__main__':
main() | 0 | null | 4,062,924,177,432 | 61 | 100 |
import math
while True:
ins = input().split()
x = int(ins[0])
op = ins[1]
y = int(ins[2])
if op == "+":
print(x + y)
elif op == "-":
print(x - y)
elif op == "/":
print(math.floor(x / y))
elif op == "*":
print(x * y)
elif op == "?":
break
else:
break | import sys
sys.setrecursionlimit(10**9)
n = int(input())
mod = 10**9 + 7
# 再帰だとなんか通らん
# dp = {}
# def rec(i, zero, nine):
# if (i, zero, nine) in dp:
# return dp[(i, zero, nine)]
# if i == n:
# return 1 if (zero and nine) else 0
# ret = 0
# for j in range(10):
# if j == 0:
# ret += rec(i + 1, True, nine)
# elif j == 9:
# ret += rec(i + 1, zero, True)
# else:
# ret += rec(i + 1, zero, nine)
# ret %= mod
# dp[(i, zero, nine)] = ret
# return ret
# print(rec(0, False, False))
dp = [[[0 for _ in range(2)] for _ in range(2)] for _ in range(10**6 + 10101)]
dp[0][0][0] = 1 # どういう意味なのかは不明
for i in range(n):
for j in range(2):
for k in range(2):
for m in range(10):
if m == 0:
dp[i + 1][1][k] += dp[i][j][k]
dp[i + 1][1][k] %= mod
elif m == 9:
dp[i + 1][j][1] += dp[i][j][k]
dp[i + 1][j][1] %= mod
else:
dp[i + 1][j][k] += dp[i][j][k]
dp[i + 1][j][k] %= mod
print(dp[n][1][1])
# 869121
# 2511445
| 0 | null | 1,957,545,508,358 | 47 | 78 |
#!/usr/bin/env python3
import sys
S = input()
if S[-1] == "s":
print(S+"es")
else:
print(S+"s") | import sys
sys.setrecursionlimit(10**7)
def I(): return int(sys.stdin.readline().rstrip())
def MI(): return map(int,sys.stdin.readline().rstrip().split())
def LI(): return list(map(int,sys.stdin.readline().rstrip().split())) #空白あり
def LI2(): return list(map(int,sys.stdin.readline().rstrip())) #空白なし
def S(): return sys.stdin.readline().rstrip()
def LS(): return list(sys.stdin.readline().rstrip().split()) #空白あり
def LS2(): return list(sys.stdin.readline().rstrip()) #空白なし
N,M = MI()
if N == 1:
ans = -1
for i in range(M):
s,c = MI()
if ans == -1:
ans = c
elif c != ans:
print(-1)
break
else:
if M != 0:
print(ans)
else:
print(0)
exit()
ANS = [-1]*N
for i in range(M):
s,c = MI()
if ANS[s-1] == -1:
ANS[s-1] = c
elif ANS[s-1] != c:
print(-1)
exit()
for i in range(N):
if i == 0 and ANS[i] == 0:
print(-1)
exit()
elif i == 0 and ANS[i] == -1:
ANS[i] = '1'
elif ANS[i] == -1:
ANS[i] = '0'
else:
ANS[i] = str(ANS[i])
print(''.join(ANS))
| 0 | null | 31,559,294,359,600 | 71 | 208 |
import bisect
N = int(input())
Kaijo = [1 for _ in range(N)]
for i in range(2,N+1):
Kaijo[-i] = Kaijo[1-i]*i
#print(Kaijo)
L = [i+1 for i in range(N)]
P = list(map(int,input().split()))
PN = 0
for i in range(N-1):
k = bisect.bisect_left(L, P[i])
L.remove(P[i])
PN += k*Kaijo[i+1]
#print(PN)
L = [i+1 for i in range(N)]
Q = list(map(int,input().split()))
QN = 0
for i in range(N-1):
k = bisect.bisect_left(L, Q[i])
L.remove(Q[i])
QN += k*Kaijo[i+1]
ans = abs(PN-QN)
print(ans) | from itertools import permutations
N = int(input())
P = tuple(map(int, input().split()))
Q = tuple(map(int, input().split()))
p = sorted(list(permutations(P)))
q = sorted(list(permutations(Q)))
print(abs(p.index(P) - q.index(Q)))
| 1 | 100,246,052,237,882 | null | 246 | 246 |
# coding: utf-8
s = list(input().rstrip())
ht = []
ponds=[]
for i, ch in enumerate(s):
if ch == "\\":
ht.append(i)
elif ch == "/":
if ht:
b = ht.pop()
ap = i - b
if not ponds:
ponds.append([b, ap])
else:
while ponds:
p = ponds.pop()
if p[0] > b:
ap += p[1]
else:
ponds.append([p[0],p[1]])
break
ponds.append([b,ap])
else:
pass
ans = ""
area = 0
for point, ar in ponds:
area += ar
ans += " "
ans += str(ar)
print(area)
print(str(len(ponds)) + ans)
| S = input()
l1 = []
l2 = []
total_area = 0
for i, j in enumerate(S):
if j == '\\':
l1.append(i)
elif j == '/' and l1:
i_p = l1.pop()
v = i -i_p
total_area += v
while l2 and l2[-1][0] > i_p:
v += l2.pop()[1]
l2.append([i_p, v])
ans = [str(len(l2))] + [str(k[1]) for k in l2]
print(total_area)
print(' '.join(ans))
| 1 | 58,524,538,256 | null | 21 | 21 |
import sys
from collections import defaultdict
#+++++
def main():
n, k = map(int, input().split())
aal = list(map(int, input().split()))
sss = [0]*(n+1)
si=0
for i, a in enumerate(aal):
si+=a-1
sss[i+1]=si%k
count=0
mkl_dict=defaultdict(lambda :0)
for j in range(n+1):
sj=sss[j]
if j-k >= 0:
mkl_dict[sss[j-k]]-=1
count += mkl_dict[sj]
mkl_dict[sj] += 1
print(count)
#+++++
isTest=False
def pa(v):
if isTest:
print(v)
if __name__ == "__main__":
if sys.platform =='ios':
sys.stdin=open('inputFile.txt')
isTest=True
else:
pass
#input = sys.stdin.readline
ret = main()
if ret is not None:
print(ret) | #!usr/bin/env python3
from collections import defaultdict, deque, Counter, OrderedDict
from bisect import bisect_left, bisect_right
from functools import reduce, lru_cache
from heapq import heappush, heappop, heapify
import itertools
import math, fractions
import sys, copy
def L(): return sys.stdin.readline().split()
def I(): return int(sys.stdin.readline().rstrip())
def SL(): return list(sys.stdin.readline().rstrip())
def LI(): return [int(x) for x in sys.stdin.readline().split()]
def LI1(): return [int(x) - 1 for x in sys.stdin.readline().split()]
def LS(): return [list(x) for x in sys.stdin.readline().split()]
def IR(n): return [I() for _ in range(n)]
def LIR(n): return [LI() for _ in range(n)]
def LIR1(n): return [LI1() for _ in range(n)]
def SR(n): return [SL() for _ in range(n)]
def LSR(n): return [LS() for _ in range(n)]
def LR(n): return [L() for _ in range(n)]
def perm(n, r): return math.factorial(n) // math.factorial(r)
def comb(n, r): return math.factorial(n) // (math.factorial(r) * math.factorial(n-r))
def make_list(n, *args, default=0): return [make_list(*args, default=default) for _ in range(n)] if len(args) > 0 else [default for _ in range(n)]
alphabets = "abcdefghijklmnopqrstuvwxyz"
ALPHABETS = "ABCDEFGHIJKLMNOPQRSTUVWXYZ"
sys.setrecursionlimit(1000000)
dire = [[1, 0], [0, 1], [-1, 0], [0, -1]]
dire8 = [[1, 0], [1, 1], [0, 1], [-1, 1], [-1, 0], [-1, -1], [0, -1], [1, -1]]
MOD = 1000000007
INF = float("inf")
def main():
N, K = LI()
A = LI()
S = list(itertools.accumulate(A))
keep = defaultdict(int)
keep[0] += 1
ans = 0
for i in range(1, N+1):
v = (S[i-1] - i) % K
if i == K:
keep[0] -= 1
if i - K > 0:
w = (S[i-K-1] - (i - K)) % K
keep[w] -= 1
ans += keep[v]
keep[v] += 1
print(ans)
if __name__ == '__main__':
main() | 1 | 138,089,272,557,082 | null | 273 | 273 |
w = int(input())
h = w // 3600
m = (w % 3600) // 60
s = w % 60
print(f"{h}:{m}:{s}")
| n = input()
print str(n/3600)+":"+str((n%3600)/60)+":"+str(n%60) | 1 | 322,618,281,450 | null | 37 | 37 |
import math
n = input()
m = 100000
for i in range(n):
m *= 1.05
m = math.ceil(m/1000)*1000
print int(m) | l = list(map(int, input().split()))
for i in range(5):
if l[i] == 0:
print(i + 1)
| 0 | null | 6,663,388,290,340 | 6 | 126 |
import math
n,d = map(int,input().split())
x = [list(map(int,input().split()))for _ in range(n)]
ans = 0
for i in range(n):
r = math.sqrt(x[i][0]**2+x[i][1]**2)
if r <= d:
ans += 1
print(ans) | n,d = map(int,input().split())
ans = 0
for i in range(n):
x1,y1 = map(int,input().split())
if(d*d >= x1*x1+y1*y1):
ans += 1
print(ans)
| 1 | 5,980,715,959,900 | null | 96 | 96 |
s = input()
n = int(input())
ans = ''
i = 0
while i < n:
order = list(map(str, input().split(' ')))
if order[0] == 'print':
ans += s[int(order[1]):int(order[2])+1] + '\n'
elif order[0] == 'reverse':
i1 = int(order[1])
i2 = int(order[2])
s0 = s[:i1]
j = 0
while j < (i2 - i1 + 1):
s0 += s[i2 - j]
j += 1
s0 += s[i2+1:]
s = s0
else:
i1 = int(order[1])
i2 = int(order[2])
s = s[:i1] + order[3] + s[i2+1:]
i += 1
print(ans[:-1])
| #!/usr/bin/env python
from __future__ import division, print_function
from sys import stdin
def bubble(cards):
for i in range(len(cards)):
for j in range(len(cards)-1, i, -1):
if cards[j][1] < cards[j-1][1]:
cards[j], cards[j-1] = cards[j-1], cards[j]
def selection(cards):
for i in range(len(cards)):
mini = i
for j in range(i, len(cards)):
if cards[j][1] < cards[mini][1]:
mini = j
cards[i], cards[mini] = cards[mini], cards[i]
def stable_test(orders, cards):
for order in orders:
n = -1
for c in order:
p = n
n = cards.index(c)
if p > n:
return False
return True
stdin.readline()
data1 = stdin.readline().split()
data2 = data1[:]
orders = [[c for c in data1 if c.endswith(str(i))] for i in range(1, 10)]
orders = [o for o in orders if len(c) > 1]
bubble(data1)
print(*data1)
print('Stable' if stable_test(orders, data1) else 'Not stable')
selection(data2)
print(*data2)
print('Stable' if stable_test(orders, data2) else 'Not stable') | 0 | null | 1,060,965,784,320 | 68 | 16 |
s, t = map(str, input().split())
w = "{}{}".format(t,s)
print(w) | n,m,k=map(int,input().split())
BAD=[0 for i in range(n+1)]
E=[]
for inp in range(m):
a,b=map(int,input().split())
E.append((a,b))
BAD[a]-=1
BAD[b]-=1
B=[]
for inp in range(k):
a,b=map(int,input().split())
B.append((a,b))
uf=[i for i in range(n+1)]
def uf_find(x,uf=uf):
while uf[x]!=x:
x=uf[x]
return x
res=[]
for ele in E:
if uf_find(ele[0]) == uf_find(ele[1]):
continue
else:
res.append((ele[0],ele[1])) #write result
if uf_find(ele[0])>uf_find(ele[1]):
uf[uf_find(ele[0])]=uf_find(ele[1])
else:
uf[uf_find(ele[1])]=uf_find(ele[0])
SCO=[0 for i in range(n+1)]
for i in range(1,n+1):
SCO[uf_find(i)]+=1
for bl in B:
if uf_find(bl[0])==uf_find(bl[1]):
BAD[bl[0]]-=1
BAD[bl[1]]-=1
ANS=[str(SCO[uf_find(i)] + BAD[i] -1) for i in range(1,n+1)]
print(" ".join(ANS))
| 0 | null | 82,764,653,778,210 | 248 | 209 |
X, K, D = map(int,input().split())
res = 0
X = abs(X)
if X >= K * D:
res = X - K * D
else:
i = X // D
j = K - i
if j % 2 == 0:
res = X - D * i
else:
res = X - D * (i + 1)
print(abs(res)) | X,K,D = map(int,input().split())
X = abs(X)
ans = 0
if (X // D) >= K:
ans = X - (K * D)
elif (X // D) % 2 == 0:
if K % 2 == 0:
ans = X % D
else:
ans = abs((X % D) - D)
else:
if K % 2 ==1:
ans = X % D
else:
ans = abs((X % D) - D)
print(ans) | 1 | 5,213,259,406,432 | null | 92 | 92 |
N=int(input())
d=[]
for x in range(N):
S=input()
d.append(S)
print(len(set(d))) | n=int(input())
s=input()
if n==1:
print("No")
else:
h = int(n/2)
a = s[0:h]
b = s[h:]
if a == b:
print("Yes")
else:
print("No") | 0 | null | 88,833,016,339,230 | 165 | 279 |
n=int(input())
change=1000-n%1000
if change==1000:
print(0)
else:
print(change) | n = int(input())
r = n % 1000
if r == 0:
print("0")
else:
otu = 1000 - r
print(otu) | 1 | 8,533,828,290,900 | null | 108 | 108 |
a,b=map(int,input().split())
c,d=map(int,input().split())
t=int(input())
if abs(a-c)<=(b-d)*t:
print('YES')
else:
print('NO')
| # -*- coding: utf-8 -*-
list = map(int, raw_input().split())
W = list[0]
H = list[1]
x = list[2]
y = list[3]
r = list[4]
if (x-r) >= 0 and (y-r) >= 0 and (x+r) <= W and (y+r) <= H:
print "Yes"
else:
print "No" | 0 | null | 7,823,893,918,800 | 131 | 41 |
n = int(input())
dp = [1, 1]
for i in range(2, n + 1):
dp = [dp[-1], dp[-2] + dp[-1]]
print(dp[-1])
| n=int(input())
a1=1
a=1
i=1
while i<n:
a1,a=a,a1+a
i+=1
print(a)
| 1 | 1,744,562,558 | null | 7 | 7 |
class UnionFind():
def __init__(self,n):
self.n=n
self.root=[-1]*(n+1)
self.rank=[0]*(n+1)
def FindRoot(self,x):
if self.root[x]<0:
return x
else:
self.root[x]=self.FindRoot(self.root[x])
return self.root[x]
def Unite(self,x,y):
x=self.FindRoot(x)
y=self.FindRoot(y)
if x==y:
return
else:
if self.rank[x]>self.rank[y]:
self.root[x]+=self.root[y]
self.root[y]=x
elif self.rank[x]<=self.rank[y]:
self.root[y]+=self.root[x]
self.root[x]=y
if self.rank[x]==self.rank[y]:
self.rank[y]+=1
def isSameGroup(self,x,y):
return self.FindRoot(x)==self.FindRoot(y)
def Count(self,x):
return -self.root[self.FindRoot(x)]
n,m=map(int,input().split())
uf=UnionFind(n+1)
for _ in range(m):
a,b=map(int,input().split())
uf.Unite(a,b)
s=set()
for i in range(1,n+1):
s.add(uf.FindRoot(i))
print(len(s)-1) | t=input()
h=t/3600
m=(t%3600)/60
s=t%60
print "%d:%d:%d" %(h,m,s) | 0 | null | 1,283,261,722,108 | 70 | 37 |
n,k,s = map(int, input().split())
if s < 10**9:
ans = [s+1] * n
else:
ans = [1]*n
ans[:k] = [s]*k
print(" ".join(map(str,ans))) | import sys
input = lambda: sys.stdin.readline().rstrip()
n = int(input())
s = []
for _ in range(n):
s.append(input())
inc = []
zeros = []
dec = []
for i, j in enumerate(s):
minimum = 0
now = 0
for k in j:
if k == "(":
now += 1
else:
now -= 1
minimum = min(minimum, now)
if now > 0:
inc.append([minimum, i])
elif now < 0:
dec.append([minimum - now, i])
else:
zeros.append([minimum, i])
inc.sort(reverse=True)
dec.sort()
now = 0
for i, j in inc:
for k in s[j]:
if k == "(":
now += 1
else:
now -= 1
if now < 0:
print("No")
sys.exit()
for i, j in zeros:
for k in s[j]:
if k == "(":
now += 1
else:
now -= 1
if now < 0:
print("No")
sys.exit()
for i, j in dec:
for k in s[j]:
if k == "(":
now += 1
else:
now -= 1
if now < 0:
print("No")
sys.exit()
ans = "Yes" if now == 0 else "No"
print(ans)
| 0 | null | 57,238,095,355,800 | 238 | 152 |
while True:
n = int(input())
if n == 0: break
s = list(map(float, input().split()))
m = sum(s) / n
a = (sum((s[i] - m) ** 2 for i in range(n)) / n) ** 0.5
print(a) | import statistics
def main():
while True:
try:
N = int(input())
S = tuple(map(int, input().split()))
print(statistics.pstdev(S))
except EOFError:
break
main() | 1 | 190,345,373,860 | null | 31 | 31 |
from collections import Counter
S = input()
S = S[::-1]
# 1桁のmod2019, 2桁の2019, ...
# 0桁のmod2019=0と定めると都合が良いので入れておく
l = [0]
num = 0
for i in range(len(S)):
# 繰り返し二乗法で累乗の部分を高速化
# 自分で書かなくてもpow()で既に実装されている
# 一つ前のmodを利用するとPythonで通せた、それをしなくてもPyPyなら通る
num += int(S[i]) * pow(10,i,2019)
l.append(num % 2019)
# print(l)
ans = 0
c = Counter(l)
for v in c.values():
ans += v*(v-1)//2
print(ans)
| N = str(input())
n,mods = 0,[1]+[0]*2018
d = 1
for i in reversed(N):
n = (n+int(i)*d)%2019
mods[n] += 1
d = (d*10)%2019
print(sum([i*(i-1)//2 for i in mods])) | 1 | 31,029,289,896,290 | null | 166 | 166 |
H = [[[0 for x in xrange(10)] for j in xrange(3)] for i in xrange(4)]
n = input()
for x in range(n):
b,f,r,v = map(int, raw_input().split())
H[b-1][f-1][r-1] += v
for b in range(4):
for f in range(3):
print(' '+' '.join(map(str,H[b][f])))
if b != 3:
print ('#'*20) | from collections import deque
n = int(input())
l = deque()
for _ in range (n):
cmd = input().split(' ')
if cmd[0]=='insert':
l.appendleft(cmd[1])
if cmd[0]=='delete':
try:l.remove(cmd[1])
except :pass
if cmd[0]=='deleteFirst':
l.popleft()
if cmd[0]=='deleteLast':
l.pop()
print(*l)
| 0 | null | 579,298,167,100 | 55 | 20 |
n = int(input())
dna = set()
for i in range(n):
command = input().split()
if command[0] == 'insert':
dna.add(command[1])
else:
print('yes' if command[1] in dna else 'no') | import sys
d={}
input()
for e in sys.stdin:
c,g=e.split()
if'i'==c[0]:d[g]=0
else:print(['no','yes'][g in d])
| 1 | 77,002,567,598 | null | 23 | 23 |
INF = 10 ** 20
n, m = map(int, input().split())
c_lst = list(map(int, input().split()))
dp = [INF for _ in range(n + 1)]
dp[0] = 0
for coin in c_lst:
for price in range(coin, n + 1):
dp[price] = min(dp[price], dp[price - coin] + 1)
print(dp[n])
| def solve(a, op, b):
if op == '+':
return a + b
elif op == '-':
return a - b
elif op == '*':
return a * b
elif op == '/':
return a // b
return None
if __name__ == '__main__':
while True:
a, op, b = input().split()
if op == '?': break
print(solve(int(a), op, int(b))) | 0 | null | 405,943,559,742 | 28 | 47 |
import sys
nums = [ int( val ) for val in sys.stdin.readline().split( " " ) ]
if nums[0] < nums[1]:
print( "a < b" )
elif nums[0] > nums[1]:
print( "a > b" )
else:
print( "a == b" ) | def cmb(n, r, mod):
if ( r<0 or r>n ):
return 0
r = min(r, n-r)
return g1[n] * g2[r] * g2[n-r] % mod
mod = 10**9+7
N = 10**6
g1 = [1, 1]
g2 = [1, 1]
inverse = [0, 1]
for i in range( 2, N + 1 ):
g1.append( ( g1[-1] * i ) % mod )
inverse.append( ( -inverse[mod % i] * (mod//i) ) % mod )
g2.append( (g2[-1] * inverse[-1]) % mod )
X,Y = list(map(int,input().split()))
if (X+Y)%3 != 0:
print(0)
exit()
N = (X+Y)//3
K = min(2*N-X,X-N)
print(cmb(N,K,mod)) | 0 | null | 74,943,535,969,952 | 38 | 281 |
N, M = map(int, input().split())
ans = 0
N, M = map(int, input().split())
if M==1:
ans=1
print(ans)
#print(*ans, sep='/n') | def dist(x,y,p):
d = 0
for i in range(len(x)):
d += abs(x[i]-y[i])**p
d = d**(1/p)
return d
n = int(input())
x = list(map(int,input().split()))
y = list(map(int,input().split()))
print('{0:.6f}'.format(dist(x,y,1)))
print('{0:.6f}'.format(dist(x,y,2)))
print('{0:.6f}'.format(dist(x,y,3)))
print('{}'.format(max([abs(x[i]-y[i])for i in range(n)])))
| 0 | null | 62,579,813,421,912 | 264 | 32 |
def main():
global s,ide_ele,num,seg
n = int(input())
s = list(input())
for i in range(n):
s[i] = ord(s[i])-97
ide_ele = 0
num = 2**(n-1).bit_length()
seg = [[ide_ele for _ in range(2*num)] for _ in range(26)]
for i in range(n):
seg[s[i]][i+num-1] = 1
for a in range(26):
for i in range(num-2,-1,-1) :
seg[a][i] = max(seg[a][2*i+1],seg[a][2*i+2])
q = int(input())
for _ in range(q):
QUERY = list(input().split())
QUERY[0], QUERY[1] = int(QUERY[0]), int(QUERY[1])
if QUERY[0] == 1:
x = ord(QUERY[2])-97
k = QUERY[1]-1
pre = s[k]
s[k] = x
k += num-1
seg[pre][k] = 0
seg[x][k] = 1
while k:
k = (k-1)//2
seg[pre][k] = max(seg[pre][k*2+1],seg[pre][k*2+2])
seg[x][k] = max(seg[x][k*2+1],seg[x][k*2+2])
if QUERY[0] == 2:
P, Q = QUERY[1]-1, int(QUERY[2])
if Q <= P:
print(ide_ele)
break
P += num-1
Q += num-2
ans = ide_ele
for i in range(26):
res = ide_ele
p,q = P,Q
while q-p > 1:
if p&1 == 0:
res = max(res,seg[i][p])
if q&1 == 1:
res = max(res,seg[i][q])
q -= 1
p = p//2
q = (q-1)//2
if p == q:
res = max(res,seg[i][p])
else:
res = max(max(res,seg[i][p]),seg[i][q])
ans += res
print(ans)
if __name__ == "__main__":
main() | #!/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)
| 1 | 62,363,289,192,350 | null | 210 | 210 |
import sys
input = sys.stdin.readline
#n = int(input())
#l = list(map(int, input().split()))
'''
a=[]
b=[]
for i in range():
A, B = map(int, input().split())
a.append(A)
b.append(B)'''
k=int(input())
if k%2==0:
print("-1")
sys.exit()
flg=False
cnt=0
a=7
for i in range(k):
cnt+=1
a%=k
if a%k==0:
print(cnt)
sys.exit()
a*=10
a+=7
if not flg:
print(-1) | ###2分探索
import sys
N,K = map(int,input().split())
A = list(map(int,input().split()))
p = 0###無理（そこまで小さくできない）
q = max(A)###可能
if K == 0:
print(q)
sys.exit(0)
while q-p > 1:
r = (p+q)//2
count = 0
for i in range(N):
if A[i]/r == A[i]//r:
count += A[i]//r - 1
else:
count += A[i]//r
if count > K:
p = r
else:
q = r
#print(p,q)
print(q) | 0 | null | 6,340,118,638,750 | 97 | 99 |
N = int(input())
hen = []
hen = list(int(x) for x in input().split())
hen.sort()
#print(hen)
#hen_u = set(hen)
#print(hen_u)
tri = 0
for a in hen:
for b in hen:
if(a == b)or (a > b):
continue
for c in hen:
if(a == c)or(b == c) or (a > c) or (b > c):
continue
if(a+b >c)and(b+c >a)and(c+a >b):
tri += 1
print(tri) | n = int(input())
arr = 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 arr[i] != arr[j] and arr[i] != arr[k] and arr[j] != arr[k]:
if (arr[i] + arr[j]) > arr[k] and (arr[i] + arr[k]) > arr[j] and (arr[j] + arr[k]) > arr[i]:
ans += 1
print(ans)
| 1 | 5,028,713,720,108 | null | 91 | 91 |
#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, product # (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)
# 四捨五入g
import sys
sys.setrecursionlimit(10000000)
mod = 10**9 + 7
#mod = 9982443453
def readInts():
return list(map(int,input().split()))
def I():
return int(input())
H = I()
def monster(n):
if n == 1:
return 1
return 1 + 2*(monster(n//2))
print(monster(H))
| H = int(input())
cnt = 1
while(H > 0):
cnt *= 2
H //= 2
print(cnt - 1) | 1 | 80,140,980,819,900 | null | 228 | 228 |
N = int(input())
AB = [[int(i) for i in input().split()] for _ in range(N)]
A, B = map(list, zip(*AB))
A.sort()
B.sort()
if N % 2 == 0 :
print(B[N//2] + B[N//2-1] - A[N//2] - A[N//2-1] + 1)
else :
print(B[N//2] - A[N//2] + 1) | a,b,c,k=map(int,input().split())
if(k<=a):
print(k)
else:
print(a-(k-a-b)) | 0 | null | 19,612,851,822,752 | 137 | 148 |
mod_val = 10**9+7
n, k = map(int, input().split())
factorials = [1]*(n+1) # values 0 to n
for i in range(2, n+1):
factorials[i] = (factorials[i-1]*i)%mod_val
def mod_binomial(a, b):
numerator = factorials[a]
denominator = (factorials[b]*factorials[a-b])%mod_val
invert = pow(denominator, mod_val-2, mod_val)
return (numerator*invert)%mod_val
partial = 0
# m is number of rooms with no people
for m in range(min(k+1, n)):
# m places within n to place the 'no people' rooms
# put n-(n-m) people in n-m rooms (n-m) must be placed to be non-empty
partial = (partial + (mod_binomial(n, m) * mod_binomial(n-1, m))%mod_val)%mod_val
print(partial) | MOD=10**9+7
def facinv(N):
fac,finv,inv=[0]*(N+1),[0]*(N+1),[0]*(N+1)#階乗テーブル、逆元テーブル、逆元
fac[0]=1;fac[1]=1;finv[0]=1;finv[1]=1;inv[1]=1
for i in range(2,N+1):
fac[i]=fac[i-1]*i%MOD
inv[i]=MOD-inv[MOD%i]*(MOD//i)%MOD
finv[i]=finv[i-1]*inv[i]%MOD
return fac,finv,inv
def COM(n,r):
if n<r or r<0:
return 0
else:
return ((fac[n]*finv[r])%MOD*finv[n-r])%MOD
n,k=map(int,input().split())
fac,finv,inv=facinv(2*n)
if k>=n-1:
print(COM(2*n-1,n-1))
else:
ans=COM(2*n-1,n-1)
for i in range(1,n-k):
ans=(ans-COM(n,i)*COM(n-1,i-1)%MOD+MOD)%MOD
print(ans%MOD) | 1 | 66,978,016,516,378 | null | 215 | 215 |
n = int(input())
a = list(map(int, input().split()))
def bubbleSort(a, n):
flag = 1
i = 0
count = 0
while flag:
flag = 0
for j in range(n-1, i, -1):
if a[j] < a[j-1]:
a[j],a[j-1] = a[j-1],a[j]
flag = 1
count += 1
i += 1
print(*a)
print(count)
bubbleSort(a,n) | import sys
lines = sys.stdin.readlines()
N = lines[0]
A = lines[1].strip().split(" ")
flag = 1
c = 0
i = 0
while flag == 1:
flag = 0
for j in reversed(range(i+1,len(A))):
if int(A[j]) < int(A[j-1]):
a = A[j]
b = A[j-1]
A[j] = b
A[j-1] = a
flag = 1
c += 1
i += 1
print " ".join(A)
print c | 1 | 18,350,549,128 | null | 14 | 14 |
from itertools import accumulate, repeat, takewhile
(lambda n:
(lambda include3:
print('',
*filter(None,
map(lambda i: i if i % 3 == 0 else include3(i),
range(1, n+1)))))(
(lambda x:
next(map(lambda _: x,
filter(lambda d: d % 10 == 3,
takewhile(bool,
accumulate(repeat(x),
lambda a, _: a // 10)))),
None))))(int(input())) | def word():
K = int(input())
S = str(input())
A = ""
if len(S) <= K:
print(S)
return
else:
for i in range(K):
A = A + S[i]
A = A + "..."
print(A)
return
word()
| 0 | null | 10,212,794,162,260 | 52 | 143 |
T1, T2 = map(int, input().split())
A1, A2 = map(int, input().split())
B1, B2 = map(int, input().split())
d1 = (A1 - B1) * T1
d2 = d1 + (A2 - B2) * T2
if (d1 > 0 and d2 > 0) or (d1 < 0 and d2 < 0):
print(0)
exit()
if d2 == 0:
print('infinity')
exit()
d1 = abs(d1)
d2 = abs(d2)
if d1 % d2 == 0:
print(d1 // d2 * 2)
else:
print(1 + d1 // d2 * 2)
| n,d=map(int, input().split())
xy=[]
ans = 0
for i in range(n):
x,y = map(int, input().split())
xy.append([x,y])
if d**2>=x**2+y**2:
ans += 1
print(ans)
| 0 | null | 69,019,923,226,728 | 269 | 96 |
n = input()
for e in n:
if e == '7':
print('Yes')
break
else:
print('No')
| N = int(input())
A = list(map(int, input().split()))
if N == 0 and A[0] != 1: # N=0なら葉は1
ans = -1
elif N != 0 and A[0] != 0: # N>0ならd=0の葉は0
ans = -1
else:
ans = 1 # 頂点合計
node = 1 # 深さdの頂点
lateFolia = sum(A) # 残りの葉
preFolia = 0 # 深さd-1の葉
for d in range(1, N+1): # d=0は初期値固定なのでd=1以降の計算
folia = A[d] # 深さdの葉
node = min((node-preFolia)*2, lateFolia) # 深さdの頂点の上界 (以下の条件を満たすもの)
# ・深さd-1の頂点のうち葉ではないものの個数の2倍
# ・残りの葉の数 (*深さdも含む)
if node < folia: # 頂点<葉はありえない
ans = -1
break
ans += node # 頂点合計を更新
lateFolia -= folia # 残りの葉の数を更新
preFolia = folia # 深さd-1の葉を記憶
print(ans)
| 0 | null | 26,369,504,235,702 | 172 | 141 |
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() | import sys
readline = sys.stdin.readline
N,K = map(int,readline().split())
A = list(map(int,readline().split()))
F = list(map(int,readline().split()))
A.sort()
F.sort(reverse=True)
ng = -1
ok = 10**12+100
while ok - ng > 1:
mid = (ok + ng) // 2
if sum(max(0,a-mid//f) for a,f in zip(A,F)) <= K:
ok = mid
else:
ng = mid
print(ok)
| 1 | 164,745,418,823,172 | null | 290 | 290 |
Subsets and Splits
No saved queries yet
Save your SQL queries to embed, download, and access them later. Queries will appear here once saved.