code1
stringlengths 16
24.5k
| code2
stringlengths 16
24.5k
| similar
int64 0
1
| pair_id
int64 2
181,637B
⌀ | question_pair_id
float64 3.71M
180,628B
⌀ | code1_group
int64 1
299
| code2_group
int64 1
299
|
|---|---|---|---|---|---|---|
s = input()
output = s.islower()
if output == True:
print("a")
else:
print("A")
|
a=input()
if str.isupper(a):
print('A')
else :
print('a')
| 1 | 11,385,491,724,100 | null | 119 | 119 |
import math,string,itertools,fractions,heapq,collections,re,array,bisect,sys,random,time,copy,functools
from collections import deque
sys.setrecursionlimit(10**7)
inf = 10**20
mod = 10**9 + 7
DR = [1, -1, 0, 0]
DC = [0, 0, 1, -1]
def LI(): return [int(x) for x in sys.stdin.readline().split()]
def LI_(): return [int(x)-1 for x in sys.stdin.readline().split()]
def LF(): return [float(x) for x in sys.stdin.readline().split()]
def LS(): return sys.stdin.readline().split()
def I(): return int(sys.stdin.readline())
def F(): return float(sys.stdin.readline())
def S(): return input()
def main():
N = I()
ans = 0
for a in range(1, 10**3+1):
if a ** 2 >= N:
continue
b_num = N // a - a
if a * (N // a) == N:
b_num -= 1
ans += b_num
ans *= 2
ans += int(math.sqrt(N))
if int(math.sqrt(N)) ** 2 == N:
ans -= 1
print(ans)
main()
|
n = int(input())
ans = 0
for a in range (1,n):
for b in range(1, n):
if n <= a * b:
break
ans += 1
print(ans)
| 1 | 2,585,071,467,132 | null | 73 | 73 |
input()
print(' '.join(reversed(input().split())))
|
_ = input()
x = list(map(int, input().split()))
y = [str(i) for i in reversed(x)]
print(' '.join(y))
| 1 | 978,594,534,018 | null | 53 | 53 |
import numpy
N, K = map(int, input().split())
print(len(numpy.base_repr(N, K)))
|
a,b=map(int,raw_input().split())
men=a*b
syuu=(a+b)*2
print men,syuu
| 0 | null | 32,509,323,685,610 | 212 | 36 |
def comb(n, r):
p, q = 1, 1
for i in range(r):
p = p * (n - i) % mod
q = q * (i + 1) % mod
return p * pow(q, mod - 2, mod) % mod
X, Y = map(int, input().split())
mod = 10 ** 9 + 7
if (X + Y) % 3:
print(0)
else:
if 2 * Y - X < 0 or 2 * X - Y < 0:
print(0)
else:
n = (X + Y) // 3
r = (2 * Y - X) // 3
print(comb(n, r))
|
class common_function():
"""
1. よく使いそうで予め用意してあるものをまとめた
2. よく使いそうな関数群をまとめた
"""
def __init__(self):
"""
1. 英字の一覧をリストに格納しておいた変数
"""
self.sletter = ['a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i', 'j', 'k', 'l', 'm', 'n', 'o', 'p', 'q', 'r', 's', 't', 'u', 'v', 'w', 'x', 'y', 'z']
self.bletter = ['A', 'B', 'C', 'D', 'E', 'F', 'G', 'H', 'I', 'J', 'K', 'L', 'M', 'N', 'O', 'P', 'Q', 'R', 'S', 'T', 'U', 'V', 'W', 'X', 'Y', 'Z']
def combi(self, n:int, k:int, MOD=pow(10, 9) + 7):
"""
mod の下での combination nCk を高速に求めるメソッド
n が大きい場合(10^6)に使用する.
1回 nCk を求めるのに O(k) かかる.
"""
k = min(k, n-k)
numer = 1
for i in range(n, n-k, -1):
numer *= i
numer %= MOD
denom = 1
for j in range(k, 0, -1):
denom *= j
denom %= MOD
return (numer*(pow(denom, MOD-2, MOD)))%MOD
def main():
common = common_function()
X, Y = map(int, input().split())
if X <= 0 or Y <= 0 or (X + Y) % 3 != 0:
print(0)
return
if Y > 2*X or X > 2*Y:
print(0)
return
for i in range(X):
two = i
one = X-2*i
if two + one*2 == Y:
break
ans = common.combi(two+one, one)
print(ans)
if __name__ == "__main__":
main()
| 1 | 149,561,568,883,272 | null | 281 | 281 |
X = int(input())
prime = []
for n in range(3, X, 2):
lim = int(n ** 0.5)
f = True
for p in prime:
if p > lim:
break
if n % p == 0:
f = False
break
if f:
prime.append(n)
if X >= 3:
prime = [2] + prime
for n in range(X, X+10**5):
for p in prime:
if n % p == 0:
break
else:
print(n)
break
|
def so(x):
xx = int(x ** 0.5) + 1
for i in range(2, xx):
if x % i == 0:
return True
return False
x = int(input())
while(so(x)):
x += 1
print(x)
| 1 | 105,760,379,766,078 | null | 250 | 250 |
import math
a,b,c,d = map(int,input().split())
def death_time(hp,atack):
if hp%atack == 0:
return hp/atack
else:
return hp//atack + 1
takahashi_death = death_time(a,d)
aoki_death = death_time(c,b)
if aoki_death<=takahashi_death:
print("Yes")
else:
print("No")
|
w = raw_input().lower()
sum = 0
while True:
t = raw_input().split()
if t[0] == "END_OF_TEXT":
break
else:
for ti in t:
if ti.lower() == w:
sum += 1
print sum
| 0 | null | 15,891,112,239,918 | 164 | 65 |
def getN():
return int(input())
def getNM():
return map(int, input().split())
def getList():
return list(map(int, input().split()))
def getArray(intn):
return [int(input()) for i in range(intn)]
def input():
return sys.stdin.readline().rstrip()
def rand_N(ran1, ran2):
return random.randint(ran1, ran2)
def rand_List(ran1, ran2, rantime):
return [random.randint(ran1, ran2) for i in range(rantime)]
def rand_ints_nodup(ran1, ran2, rantime):
ns = []
while len(ns) < rantime:
n = random.randint(ran1, ran2)
if not n in ns:
ns.append(n)
return sorted(ns)
def rand_query(ran1, ran2, rantime):
r_query = []
while len(r_query) < rantime:
n_q = rand_ints_nodup(ran1, ran2, 2)
if not n_q in r_query:
r_query.append(n_q)
return sorted(r_query)
from collections import defaultdict, deque, Counter
from sys import exit
from decimal import *
import heapq
import math
from fractions import gcd
import random
import string
import copy
from itertools import permutations
from operator import mul
from functools import reduce
from bisect import bisect_left, bisect_right
import sys
sys.setrecursionlimit(1000000000)
mod = 10 ** 9 + 7
#############
# Main Code #
#############
N = getN()
next = [
[0, 1],
[0, 1, 2],
[1, 2, 3],
[2, 3, 4],
[3, 4, 5],
[4, 5, 6],
[5, 6, 7],
[6, 7, 8],
[7, 8, 9],
[8, 9]
]
ans = []
def dfs(s):
global ans
if len(s) >= 11:
return
# 上限を超えない範囲で実行
else:
ans.append(int(s))
# dfs
s_last = int(s[-1])
for i in next[s_last]:
dfs(s + str(i))
# 始点は1~9
for i in range(1, 10):
dfs(str(i))
ans.sort()
print(ans[N - 1])
|
n = int(raw_input())
a = map(int, raw_input().split())
def print_list(list):
for i in range(len(list)-1):
print(list[i]),
print(list[len(list)-1])
#print("")
print_list(a)
for i in range(1,n):
v = a[i]
j = i - 1
while j >= 0 and a[j] > v:
a[j+1] = a[j]
j -= 1
a[j+1] = v
print_list(a)
| 0 | null | 20,164,383,223,488 | 181 | 10 |
from bisect import bisect_left
n, m = map(int, input().split())
A = list(map(int, input().split()))
A.sort()
A_r = sorted(A, reverse = True)
cumsumA = [0]
total = 0
for i in range(n):
total += A_r[i]
cumsumA.append(total)
def func(x):
ans = 0
for i in range(n):
kazu = x - A[i]
idx = bisect_left(A, kazu)
cou = n - idx
ans += cou
if ans >= m:
return True
else:
return False
mi = 0
ma = 2 * 10 ** 5 + 1
while ma - mi > 1:
mid = (mi + ma) // 2
if func(mid):
mi = mid
else:
ma = mid
ans = 0
count = 0
for ai in A_r:
idx = bisect_left(A, mi - ai)
ans += ai * (n - idx) + cumsumA[n - idx]
count += n - idx
print(ans - (count-m) * mi)
|
A,B,C = map(int,input().split())
if A==B and B==C and A==C:
print ("No")
elif A!=B and B!=C and A!=C:
print ("No")
else :
print ("Yes")
| 0 | null | 88,065,812,765,120 | 252 | 216 |
n = int(input())
total = 0
for i in range(n):
a,b = map(int, input().split())
if a == b:
total += 1
if total == 3:
break
else:
total = 0
if total == 3:
print('Yes')
else:
print('No')
|
n = int(input())
count = 0
ans = 'No'
for i in range(n):
a , b = map(int,input().split(' '))
if a!=b:
count = 0
else:
count += 1
if count == 3:
ans = 'Yes'
print(ans)
| 1 | 2,445,280,843,132 | null | 72 | 72 |
X,Y,Z = map(int,input().split())
temp = Y
Y = X
X = temp
temp = Z
Z = X
X = temp
print ("{} {} {}".format(X,Y,Z))
|
def resolve():
x, y, z = list(map(int, input().split()))
print(f'{z} {x} {y}')
resolve()
| 1 | 37,827,234,562,598 | null | 178 | 178 |
def bubblesort(A):
tot = 0
flag = 1
N = len(A)
while flag:
flag = 0
for j in xrange(N-1,0,-1):
if A[j] < A[j-1]:
A[j],A[j-1] = A[j-1],A[j]
flag = 1
tot += 1
return A,tot
while True:
try:
N = int(raw_input())
except EOFError:
break
A = map(int,raw_input().split())
A,tot = bubblesort(A)
print ' '.join(map(str,A))
print tot
|
n = int(input())
ls = list(map(int, input().split()))
count = 0
flag = 1
while flag:
flag = 0
for i in range(len(ls)-1, 0, -1):
if ls[i] < ls[i-1]:
ls[i], ls[i-1] = ls[i-1], ls[i]
count += 1
flag = 1
print(' '.join(map(str, ls)))
print(count)
| 1 | 15,587,311,090 | null | 14 | 14 |
import sys
sys.setrecursionlimit(10**7)
readline = sys.stdin.buffer.readline
def readstr():return readline().rstrip().decode()
def readstrs():return list(readline().decode().split())
def readint():return int(readline())
def readints():return list(map(int,readline().split()))
def printrows(x):print('\n'.join(map(str,x)))
def printline(x):print(' '.join(map(str,x)))
from itertools import accumulate
n,k = readints()
a = readints()
for _ in range(k):
b = [0]*(n+1)
for i in range(n):
b[max(0,i-a[i])]+=1
b[min(n,i+a[i]+1)]-=1
a = list(accumulate(b))[:-1]
if min(a)==n:
break
printline(a)
|
N = int(input())
A = list(map(int,input().split()))
B = []
B_val = 0
ans = 0
for i in A[::-1]:
B.append(B_val)
B_val += i
for i in range(N):
ans += ( A[i] * B[-i-1] ) % (1000000000 + 7 )
print(ans % (1000000000 + 7 ) )
| 0 | null | 9,586,841,015,022 | 132 | 83 |
import collections
q = collections.deque()
n = int(input())
for i in range(n):
com = input().split()
if com[0] == 'insert':
q.appendleft(int(com[1]))
elif com[0] == 'delete':
try:
q.remove(int(com[1]))
except:
pass
elif com[0] == 'deleteFirst':
q.popleft()
elif com[0] == 'deleteLast':
q.pop()
print(*q)
|
from collections import deque
DLL = deque()
n = int(input())
for i in range(n):
Line = input().split()
if Line[0] == "insert":
DLL.appendleft(Line[1])
elif Line[0] == "delete":
try:
DLL.remove(Line[1])
except ValueError:
None
elif Line[0] == "deleteFirst":
DLL.popleft()
elif Line[0] == "deleteLast":
DLL.pop()
print(" ".join(DLL))
| 1 | 52,296,142,192 | null | 20 | 20 |
#!/usr/bin/env python3
import sys
from collections import deque
sys.setrecursionlimit(1000000)
class UnionFind:
def __init__(self, num):
self.par = list(range(1,num+1))
self.size = [1]*num
def root(self, n):
if self.par[n-1] != n:
self.par[n-1] = self.root(self.par[n-1])
return self.par[n-1]
def unite(self, a, b):
a=self.root(a)
b=self.root(b)
if a!=b:
self.par[b-1]=a
self.size[a-1] += self.size[b-1]
return
def get_size(self, n):
return self.size[self.root(n)-1]
def solve(N: int, M: int, K: int, A: "List[int]", B: "List[int]", C: "List[int]", D: "List[int]"):
fris = [0]*N
blos = [0]*N
union = UnionFind(N)
for ai, bi in zip(A, B):
union.unite(ai,bi)
fris[ai-1]+=1
fris[bi-1]+=1
for ci, di in zip(C, D):
if union.root(ci) == union.root(di):
blos[ci-1]+=1
blos[di-1]+=1
ans = [0]*N
for i in range(1,N+1):
s = union.get_size(i)
s -= fris[i-1]
s -= blos[i-1]
s -= 1
ans[i-1] = s
print(*ans)
return
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
M = int(next(tokens)) # type: int
K = int(next(tokens)) # type: int
A = [int()] * (M) # type: "List[int]"
B = [int()] * (M) # type: "List[int]"
for i in range(M):
A[i] = int(next(tokens))
B[i] = int(next(tokens))
C = [int()] * (K) # type: "List[int]"
D = [int()] * (K) # type: "List[int]"
for i in range(K):
C[i] = int(next(tokens))
D[i] = int(next(tokens))
solve(N, M, K, A, B, C, D)
if __name__ == '__main__':
main()
|
def cube(x):
return x**3
def main():
x = int(input())
ans = cube(x)
print(ans)
if __name__=='__main__':
main()
| 0 | null | 30,849,174,519,800 | 209 | 35 |
import sys
stdin = sys.stdin
def main():
N = int(stdin.readline().rstrip())
A = list(map(int,stdin.readline().split()))
mod = 10**9+7
ans = 0
for i in range(61):
bits = 0
for x in A:
if (x>>i)&1:
bits += 1
ans += ((bits*(N-bits))* 2**i) %mod
ans %= mod
print(ans)
main()
|
from collections import defaultdict
iim = lambda: map(int, input().rstrip().split())
def resolve():
N = int(input())
A = list(iim())
ans = 0
dp = [0]*N
for i, ai in enumerate(A):
x = i + ai
if x < N:
dp[x] += 1
x = i - ai
if x >= 0:
ans += dp[x]
print(ans)
resolve()
| 0 | null | 74,301,985,205,852 | 263 | 157 |
import sys, math
from pprint import pprint
input = sys.stdin.readline
rs = lambda: input().strip()
ri = lambda: int(input())
rl = lambda: list(map(int, input().split()))
mod = 10**9 + 7
A = rl()
if sum(A) >= 22:
print('bust')
else:
print('win')
|
def main():
a = list(map(int, input().split()))
if sum(a[:]) >= 22:
print('bust')
else:
print('win')
if __name__ == "__main__":
main()
| 1 | 118,291,643,372,980 | null | 260 | 260 |
n,k=map(int,input().split())
a=list(map(int,input().split()))
l=0;r=10**10
while r-l>1:
x=(l+r)//2
ct=0
for i in range(n):
ct+=(a[i]-1)//x
if ct<=k:
r=x
else:
l=x
print(r)
|
N,K = list(map(int,input().split()))
A = list(map(int,input().split()))
NG=0
OK=max(A)+1
while OK-NG>1:
mid = (OK+NG)//2
cur=0
for x in A:
cur += (x-1)//mid
if cur > K:
NG=mid
else:
OK=mid
print(OK)
| 1 | 6,522,607,635,908 | null | 99 | 99 |
S = input()
a = [0] * (len(S) + 1)
for i in range(len(S)):
if S[i] == "<":
a[i + 1] = a[i] + 1
for i in list(range(len(S)))[::-1]:
if S[i] == ">" and a[i + 1] >= a[i]:
a[i] = a[i + 1] + 1
print(sum(a))
|
N,K = map(int,input().split())
height = list(map(int,input().split()))
chibi = [1] * N
for i in range (N):
if height[i] >= K:
chibi[i] = 0
print(N-sum(chibi))
| 0 | null | 167,098,513,526,218 | 285 | 298 |
import sys
n=int(input())
d=list(map(int,input().split()))
if d[0]!=0:
print(0)
sys.exit(0)
if n==1:
print(1)
sys.exit(0)
for i in range(1,n):
if d[i]==0:
print(0)
sys.exit(0)
dist=[0]*(n)
for i in range(1,n):
dist[d[i]]+=1
if dist[1]==0:
print(0)
sys.exit(0)
ans=1
mod=998244353
bef=dist[1]
total=dist[1]+1
for i in range(2,n):
for j in range(dist[i]):
ans=ans*bef
ans=ans%mod
total+=dist[i]
bef=dist[i]
if total==n:
break
if ans==0:
break
print(ans)
#print(dist)
|
H,A=map(int,input().split())
AP=0
for i in range(10001):
AP=A*i
if AP>=H:
print(i)
break
| 0 | null | 115,918,486,409,336 | 284 | 225 |
while True:
m,f,r=map(int,input().split())
if (m,f,r)==(-1,-1,-1):
break
h=m+f
if m == -1 or f == -1:
print('F')
elif h >= 80:
print('A')
elif h>=65 and h<80:
print('B')
elif h>=50 and h<65:
print('C')
elif h>=30 and h<50 and r>=50:
print('C')
elif h>=30 and h<50 and r<50:
print('D')
else:
print('F')
|
while 1:
(a,b,c) = map(int,raw_input().split())
if a == -1 and b == -1 and c == -1:
break
if a == -1 or b == -1:
print 'F'
elif a+b >= 80:
print 'A'
elif a+b >= 65:
print 'B'
elif a+b >= 50:
print 'C'
elif a+b >= 30:
if c >= 50:
print 'C'
else:
print 'D'
else:
print 'F'
| 1 | 1,196,663,511,292 | null | 57 | 57 |
def main():
print("ACL" * int(input()))
if __name__ == '__main__':
main()
|
N = int(input())
s = "ACL"
ans = ""
for i in range(N):
ans += s
print(ans)
| 1 | 2,188,668,191,580 | null | 69 | 69 |
x, k, d = map(int, input().split())
x = abs(x)
num = x // d
if num >= k:
ans = x - k*d
else:
if (k-num)%2 == 0:
ans = x - num*d
else:
ans = min(abs(x - num*d - d), abs(x - num*d + d))
print(ans)
|
X = int(input())
print("YNeos"[not(X>=30)::2])
| 0 | null | 5,419,531,969,572 | 92 | 95 |
N=input()
n=int(N)
k=int(n%1000)
if k==0:
print(0)
else:
print(1000-k)
|
number = int(input())
list1,list2 = input().split(" ")
str=""
for i in range(number):
str=str+list1[i]+list2[i]
print(str)
| 0 | null | 60,378,726,135,938 | 108 | 255 |
N,X,Y=map(int,input().split())
#i<X<Y<j
#このときはX->を通るほうが良い
#X<=i<j<=Y
#このときはループのどちらかを通れば良い
#X<=i<=Y<j
#このときはiとYの最短距離+Yとjの最短距離
#i<X<=j<=Y
#同上
#i<j<X
#パスは1通りしか無い
def dist(i,j):
if i>j:
return dist(j,i)
if i==j:
return 0
if i<X:
if j<X:
return j-i
if X<=j and j<=Y:
return min(j-i,(X-i)+1+(Y-j))
if Y<j:
return (X-i)+1+(j-Y)
if X<=i and i<=Y:
if j<=Y:
return min(j-i,(i-X)+1+(Y-j))
if Y<j:
return min((i-X)+1+(j-Y),j-i)
if Y<i:
return (j-i)
ans=[0 for i in range(N)]
for i in range(1,N+1):
for j in range(i+1,N+1):
ans[dist(i,j)]+=1
for k in range(1,N):
print(ans[k])
|
from collections import Counter
from itertools import combinations
N, X, Y = map(int, input().split(' '))
c = Counter()
for i, j in combinations(range(1, N + 1), r=2):
c[min(j - i, abs(X - i) + 1 + abs(j - Y))] += 1
for n in range(1, N):
print(c[n])
| 1 | 43,960,633,768,672 | null | 187 | 187 |
from copy import deepcopy
h,w,k = map(int, input().split())
strawberry_count = [0 for i in range(h)]
cakes = []
for i in range(h):
cakes.append(list(input()))
strawberry_count[i] = cakes[i].count('#')
ans = []
first_index = 10000
use_number = 0
for i in range(h):
append_array = []
if strawberry_count[i] >= 2:
first_index = min(first_index,i)
use_number += 1
first = True
for j in range(w):
if cakes[i][j] == '#':
if first:
first = False
else:
use_number += 1
append_array.append(use_number)
elif strawberry_count[i] == 1:
use_number += 1
first_index = min(first_index,i)
append_array = [use_number for i in range(w)]
else:
append_array = []
ans.append(append_array)
print_count = 0
pre_array = []
for i in range(h):
if len(ans[i]) == 0:
if print_count > 0:
print(" ".join(map(str,pre_array)))
else:
print(" ".join(map(str,ans[first_index])))
pre_array = ans[first_index]
print_count += 1
else:
print(" ".join(map(str, ans[i])))
pre_array = ans[i]
print_count += 1
|
N = int(input())
MOD = 10**9+7
ans = ((10**N%MOD - 9**N%MOD*2%MOD)%MOD + 8**N%MOD)%MOD
print(ans)
| 0 | null | 73,516,401,790,172 | 277 | 78 |
iterator = [["NS", "S"], ["NT", "T"]]
var = {}
for i, j in iterator:
var[i] = int(input())
var[j] = [int(k) for k in input().split()]
res = 0
for T in var["T"]:
if T in var["S"]:
res += 1
print(res)
|
n1 = int(input())
a1 = [int(x) for x in input().split()]
n2 = int(input())
a2 = [int(x) for x in input().split()]
res = set()
cnt = 0
for i in range(n1) :
for j in range(n2) :
if a1[i] == a2[j] :
res.add(a1[i])
print(len(res))
| 1 | 63,259,285,100 | null | 22 | 22 |
# 問題文誤読して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)
|
N,A,B=map(int,input().split())
D=B-A
if D%2:
a=A-1
b=N-B
print(min(a,b)+1+(D-1)//2)
else:
print(D//2)
| 0 | null | 62,046,834,698,400 | 129 | 253 |
#!/usr/bin/env python3
n = int(input())
s = input()
s = [int(i) for i in s]
c = 0
for i in range(10):
for j in range(10):
if i in s:
t = s[s.index(i) + 1:]
if j in t:
c += len(set(t[t.index(j) + 1:]))
print(c)
|
n = int(input())
s = list(map(int, list(input())))
f = [0]*1000
rnum = [0]*10
lnum = [0]*10
for i in s:
rnum[i] += 1
rnum[s[0]] -= 1
lnum[s[0]] += 1
for i in range(1, n-1):
rnum[s[i]] -= 1
for j in range(10):
for k in range(10):
if lnum[j] >= 1 and rnum[k] >= 1:
f[j*100+s[i]*10+k] = 1
lnum[s[i]] += 1
cnt = 0
for i in f:
if i == 1:
cnt += 1
print(cnt)
| 1 | 128,528,726,653,190 | null | 267 | 267 |
def gcd(a, b):
if b == 0: return a
else: return gcd(b, a % b)
def lcm(a, m):
return a * b / gcd(a, b);
while True:
try:
a, b = map(int, raw_input().split())
print gcd(a, b), lcm(a, b)
except (EOFError):
break
|
import sys
for s in sys.stdin:
a = list(map(int, s.split()))
b = a[0]
c = a[1]
while c != 0:
b, c = c, b%c
d = a[0] * a[1] / b
print(int(b), int(d))
| 1 | 637,547,820 | null | 5 | 5 |
S,T = input().split()
T+=S
print(T)
|
S, T = input().split(' ')
print(T + S)
| 1 | 103,087,039,054,538 | null | 248 | 248 |
from sys import stdin
while True:
h, w = (int(n) for n in stdin.readline().rstrip().split())
if h == w == 0:
break
for cnt in range(h):
print(('#.' * ((w + 2) // 2))[cnt % 2: w + cnt % 2])
print()
|
def judge():
if m == -1 or f == -1:
print("F")
elif m + f >= 80:
print("A")
elif m + f >= 65:
print("B")
elif m + f >= 50:
print("C")
elif m + f >= 30:
if r >= 50:
print("C")
else:
print("D")
else:
print("F")
while True:
m, f, r = map(int, input().split())
if m == f == r == -1:
break
judge()
| 0 | null | 1,036,952,399,830 | 51 | 57 |
n=int(input())
li=[input() for i in range(n)]
ans=[0,0,0,0]
for i in range(n):
if li[i]=="AC":
ans[0]+=1
elif li[i]=="WA":
ans[1]+=1
elif li[i]=="TLE":
ans[2]+=1
elif li[i]=="RE":
ans[3]+=1
print("AC x " + str(ans[0]))
print("WA x "+ str(ans[1]))
print("TLE x "+str(ans[2]))
print("RE x "+str(ans[3]))
|
S: str = input()
n = len(S)
if not S == S[::-1]:
print('No')
exit()
end = (n-1)//2
SS = S[:end]
if not SS == SS[::-1]:
print('No')
exit()
start = (n+3)//2 - 1
SSS = S[start:n]
if not SSS == SSS[::-1]:
print('No')
exit()
print('Yes')
| 0 | null | 27,498,618,486,300 | 109 | 190 |
s = list(input())
if s.count('R') == 3:
print(3)
elif s.count('R') == 1:
print(1)
elif s.count('R') == 0:
print(0)
else:
if s[1] == 'R':
print(2)
else:
print(1)
|
x,y=map(int,input().split())
c=0
d=0
if x==1:
c=300000
elif x==2:
c=200000
elif x==3:
c=100000
if y==1:
d=300000
elif y==2:
d=200000
elif y==3:
d=100000
print(c+d if c+d!=600000 else 1000000)
| 0 | null | 72,460,576,780,530 | 90 | 275 |
N = int(input())
A = list(map(int, input().split()))
all_fav_num_xor = 0
for a in A:
all_fav_num_xor ^= a
l = [all_fav_num_xor ^ a for a in A]
print(*l)
|
N = int(input())
A = list(map(int,input().split()))
B = [0 for _ in range(N//2)]
for i in range(0,N,2):
B[i//2] = A[i]^A[i+1]
tot = 0
for i in range(N//2):
tot = tot^B[i]
X = [0 for _ in range(N)]
for i in range(N//2):
y = tot^B[i]
X[2*i]=A[2*i+1]^y
X[2*i+1]=A[2*i]^y
print(*X)
| 1 | 12,633,500,973,742 | null | 123 | 123 |
import bisect
def resolve():
n = int(input())
l = sorted(list(map(int,input().split())))
ans = 0
for a in range(n):
for b in range(a+1,n):
c = bisect.bisect_left(l,l[a]+l[b])
if c > b:
ans += c-b-1
else:
pass
print(ans)
resolve()
|
x, y = map(int, input().split())
answer = 0
for a in [x, y]:
if a == 3:
answer += 100000
elif a == 2:
answer += 200000
elif a == 1:
answer += 300000
else:
pass
if x == 1 and y == 1:
answer += 400000
print(answer)
| 0 | null | 155,556,343,024,200 | 294 | 275 |
N = int(input())
A = [int(i) for i in input().split()]
S = []
e = 0
for i in A:
e += i
S.append(e)
ans = 0
for i in range(N-1):
ans += A[i]%(10**9+7)*((S[N-1] - S[i])%(10**9+7))
print(ans%(10**9+7))
|
import sys
sys.setrecursionlimit(10 ** 8)
ini = lambda: int(sys.stdin.readline())
inm = lambda: map(int, sys.stdin.readline().split())
inl = lambda: list(inm())
ins = lambda: sys.stdin.readline().rstrip()
debug = lambda *a, **kw: print("\033[33m", *a, "\033[0m", **dict(file=sys.stderr, **kw))
ss, st = ins().split()
a, b = inm()
su = ins()
def solve():
if su == ss:
return (a - 1), b
else:
return a, (b - 1)
print(*solve())
| 0 | null | 38,128,310,312,378 | 83 | 220 |
def resolve():
n=int(input())
print((n-1)//2)
resolve()
|
#!/usr/bin/env python3
S = input()
total = 0
for i in range(len(S)):
if "R" * (i + 1) in S:
total = i + 1
ans = total
print(ans)
| 0 | null | 78,663,492,899,088 | 283 | 90 |
s = input()
if len(s) % 2 == 1:
print('No')
else:
ans = "Yes"
for i in range(len(s)):
if i % 2 == 0 and s[i] != 'h':
ans = "No"
break
if i % 2 == 1 and s[i] != 'i':
ans = "No"
break
print(ans)
|
X = int(input())
if X >= 30:
print('Yes')
else:
print('No')
| 0 | null | 29,644,901,486,172 | 199 | 95 |
n = int(input())
lst = []
for i in range(n):
x, l = map(int, input().split())
lst.append((x + l, x - l))
sorted_lst = sorted(lst)
num = 0
ans = n
while True:
tmp = sorted_lst[num][0]
for i in range(num + 1, n):
if tmp > sorted_lst[i][1]:
ans -= 1
else:
num = i
break
if i == n - 1:
num = i
break
if num == n - 1:
break
print(ans)
|
n=int(input())
xl=[list(map(int, input().split())) for _ in range(n)]
rl=[]
for x,l in xl:
right=x-l
left=x+l
rl.append([right,left])
rl.sort(key=lambda x: x[1])
# print(rl)
cnt=0
pos=-float('inf')
for i in range(n):
if rl[i][0]>=pos:
pos=rl[i][1]
cnt+=1
print(cnt)
| 1 | 89,879,111,598,948 | null | 237 | 237 |
def main():
a, b = map(int, input().split())
if 10 > a and 10 > b:
print(a*b)
else:
print("-1")
if __name__ == '__main__':
main()
|
m1,_ = input().split()
m2,_ = input().split()
ans = 0
if m1 != m2:
ans = 1
print(ans)
| 0 | null | 140,929,235,934,048 | 286 | 264 |
min2 = lambda x,y: x if x < y else y
H,N = map(int,input().split())
dp = [float('inf')]*(H+1)
dp[0] = 0
for _ in range(N):
a,b = map(int,input().split())
for i,v in enumerate(dp):
j = min2(H,i+a)
dp[j] = min2(dp[j],v+b)
print(dp[-1])
|
import bisect
def main():
N,D,A=map(int,input().split())
XH=[list(map(int,input().split())) for _ in range(N)]
XH.sort()
for i in range(N):
XH[i][1]=-(-XH[i][1]//A)
X=[x for x,a in XH]
far=[0]*N
for i in range(N):
far[i]=bisect.bisect_right(X,X[i]+2*D)-1
ans=0
carry=0
outrange=[0]*(N+1)
for i in range(N):
x=XH[i][0]
hp=XH[i][1]
carry-=outrange[i]
if carry>=hp:
continue
outrange[bisect.bisect_right(X,X[i]+2*D)]+=hp-carry
ans+=hp-carry
carry+=hp-carry
print(ans)
if __name__ == '__main__':
main()
| 0 | null | 81,337,586,688,450 | 229 | 230 |
#!/usr/bin/env python3
# vim: set fileencoding=utf-8
# pylint: disable=unused-import, invalid-name, missing-docstring, bad-continuation
"""Module docstring
"""
import functools
import heapq
import itertools
import logging
import math
import random
import string
import sys
from argparse import ArgumentParser
from collections import defaultdict, deque
from copy import deepcopy
from typing import Dict, List, Optional, Set, Tuple
def solve(values: List[int], nb: int) -> int:
s_values = sorted(((v, i) for i, v in enumerate(values)), reverse=True)
dp = [[0 for _ in range(nb + 1)] for _ in range(nb + 1)]
for i, (v, p) in enumerate(s_values, start=1):
for x in range(i + 1):
y = i - x
if y == 0:
dp[x][y] = dp[x - 1][0] + abs(p - x + 1) * v
continue
if x == 0:
dp[x][y] = dp[x][y - 1] + abs(nb - y - p) * v
continue
dp[x][y] = max(
dp[x - 1][y] + abs(p - x + 1) * v, dp[x][y - 1] + abs(nb - y - p) * v
)
return max(dp[i][nb - i] for i in range(nb + 1))
def do_job():
"Do the work"
LOG.debug("Start working")
# first line is number of test cases
N = int(input())
values = list(map(int, input().split()))
# values = []
# for _ in range(N):
# values.append(input().split())
result = solve(values, N)
print(result)
def print_output(testcase: int, result) -> None:
"Formats and print result"
if result is None:
result = "IMPOSSIBLE"
print("Case #{}: {}".format(testcase + 1, result))
# 6 digits float precision {:.6f} (6 is the default value)
# print("Case #{}: {:f}".format(testcase + 1, result))
def configure_log(log_file: Optional[str] = None) -> None:
"Configure the log output"
log_formatter = logging.Formatter(
"%(asctime)s - %(filename)s:%(lineno)d - " "%(levelname)s - %(message)s"
)
if log_file:
handler = logging.FileHandler(filename=log_file)
else:
handler = logging.StreamHandler(sys.stdout)
handler.setFormatter(log_formatter)
LOG.addHandler(handler)
LOG = None
# for interactive call: do not add multiple times the handler
if not LOG:
LOG = logging.getLogger("template")
configure_log()
def main(argv=None):
"Program wrapper."
if argv is None:
argv = sys.argv[1:]
parser = ArgumentParser()
parser.add_argument(
"-v",
"--verbose",
dest="verbose",
action="store_true",
default=False,
help="run as verbose mode",
)
args = parser.parse_args(argv)
if args.verbose:
LOG.setLevel(logging.DEBUG)
do_job()
return 0
if __name__ == "__main__":
import doctest
doctest.testmod()
sys.exit(main())
class memoized:
"""Decorator that caches a function's return value each time it is called.
If called later with the same arguments, the cached value is returned, and
not re-evaluated.
"""
def __init__(self, func):
self.func = func
self.cache = {}
def __call__(self, *args):
try:
return self.cache[args]
except KeyError:
value = self.func(*args)
self.cache[args] = value
return value
except TypeError:
# uncachable -- for instance, passing a list as an argument.
# Better to not cache than to blow up entirely.
return self.func(*args)
def __repr__(self):
"""Return the function's docstring."""
return self.func.__doc__
def __get__(self, obj, objtype):
"""Support instance methods."""
return functools.partial(self.__call__, obj)
|
n = int(input())
a = list(map(int, input().split()))
l = sorted(zip(a, range(0, n)), reverse=True)
p = [0] * n
for i in range(n):
p[i] = l[i][1]
a.sort(reverse=True)
dp = [[0] * (n + 1) for _ in range(n + 1)]
for i in range(1, n + 1):
for j in range(i + 1):
k = i - j
if j == 0:
dp[j][k] = dp[j][k - 1] + abs(n - k - p[i - 1]) * a[i - 1]
elif k == 0:
dp[j][k] = dp[j - 1][k] + abs(j - 1 - p[i - 1]) * a[i - 1]
else:
dp[j][k] = max(dp[j][k - 1] + abs(n - k - p[i - 1]) * a[i - 1],
dp[j - 1][k] + abs(j - 1 - p[i - 1]) * a[i - 1])
ans = 0
for i in range(n):
ans = max(ans, dp[n - i][i])
print(ans)
| 1 | 33,651,067,028,502 | null | 171 | 171 |
N=int(input())
A=list(map(int,input().split()))
Subordinate=[[] for i in range(N)]
for i in range(len(A)):
A_i=A[i]
Subordinate[A_i-1].append(A_i)
for i in Subordinate:
print(len(i))
|
from collections import Counter
n=int(input())
a=list(map(int,input().split()))
c=Counter(a)
for i in range(1,n+1):
print(c[i])
| 1 | 32,575,197,654,450 | null | 169 | 169 |
N = int(input())
s = {}
t = []
for i in range(N):
st = input().split()
s[st[0]] = i
t.append(int(st[1]))
X = input()
print(sum(t[s[X]+1:]))
|
n = int(input())
s = []
t = []
for i in range(n):
a,b = input().split()
s.append(a)
t.append(int(b))
x = s.index(input())
ans = 0
for i in range(x+1,n):
ans += t[i]
print(ans)
| 1 | 96,747,569,476,272 | null | 243 | 243 |
import sys
from collections import Counter
input = sys.stdin.readline
N = int(input())
ans = 1
mod = 998244353
D = list(map(int, input().split()))
if D[0] != 0:
print(0)
exit()
D = sorted(Counter(D).items())
tmp = D[0][1]
stream = 0
for n, i in D:
if stream != n:
print(0)
exit()
if n == 0 and i == 1:
stream += 1
continue
elif n==0:
print(0)
exit()
ans *= pow(tmp, i)
ans %= mod
tmp = i
stream += 1
print(ans)
|
# -*- coding: utf-8 -*-
a = [int(raw_input()) for _ in range(10)]
#print a
b = sorted(a, reverse=True)
#print b
for c in b[0:3]:
print c
| 0 | null | 77,488,581,405,940 | 284 | 2 |
#!python3
import sys
iim = lambda: map(int, sys.stdin.readline().rstrip().split())
def resolve():
K = int(input())
s = input()
ls = len(s) - 1
mod = 10**9+7
N = ls + K
N1 = N + 1
fact = [1] * N1
inv = [1] * N1
for i in range(2, N1):
fact[i] = fact[i-1] * i % mod
inv[N] = pow(fact[N], mod-2, mod)
for i in range(N-1, 1, -1):
inv[i] = inv[i+1]*(i+1) % mod
def cmb(a, b):
return fact[a] * inv[b] % mod * inv[a-b] % mod
ans = 0
p25 = 1
p26 = pow(26, K, mod)
p26inv = 576923081 #pow(26, mod-2, mod)
for i in range(K+1):
ans = (ans + cmb(ls+i, ls) * p25 % mod * p26 % mod) % mod
p25 = p25 * 25 % mod
p26 = p26 * p26inv % mod
print(ans)
if __name__ == "__main__":
resolve()
|
def qsort(l):
if l == []: return []
else:
pv = l[0]
left = []
right = []
for i in range(1, len(l)):
if l[i] > pv:
left.append(l[i])
else:
right.append(l[i])
left = qsort(left)
right = qsort(right)
left.append(pv)
return left + right
def main():
lst = []
for i in range(0, 10):
lst.append(int(raw_input()))
lst = qsort(lst)
for i in range(0, 3):
print(lst[i])
main()
| 0 | null | 6,456,689,427,972 | 124 | 2 |
import math
N= int(input())
if 360%N==0:
print(int(360/N))
elif 360%N!=0:
a = math.gcd(360,N)
print(int(360/a))
|
import collections
def searchRoot(n):
par = parList[n]
if n == par:
if len(q) > 0:
rootIn(q,n)
return n
else:
q.append(n)
return(searchRoot(par))
def rootIn(q,root):
while len(q) > 0:
parList[q.popleft()] = root
n,m = list(map(int,input().split()))
q = collections.deque()
parList = [i for i in range(n+1)]
for i in range(m):
a,b = list(map(int,input().split()))
aRoot = searchRoot(a)
bRoot = searchRoot(b)
if aRoot != bRoot:
parList[max(aRoot,bRoot)] = min(aRoot,bRoot)
#print(parList)
ansDic = dict()
rootSet = set()
for i in range(1,n+1):
root = searchRoot(i)
if root in rootSet:
ansDic[root] += 1
else:
rootSet.add(root)
ansDic[root] = 1
ans = 1
for i in rootSet:
if ansDic[i] > ans:
ans = ansDic[i]
print(ans)
| 0 | null | 8,466,430,596,236 | 125 | 84 |
from collections import defaultdict
N = int(input())
if N == 1:
print(0)
exit()
p = defaultdict(int)
while N % 2 == 0:
p[2] += 1
N //= 2
f = 3
while f * f <= N:
if N % f == 0:
p[f] += 1
N //= f
else:
f += 2
if N != 1:
p[N] += 1
ans = 0
for v in p.values():
n = 1
i = 1
while n <= v:
ans += 1
i += 1
n += i
print(ans)
|
import math
N = int(input())
def bunkai(n):
factor={}
tmp = int(math.sqrt(n)) + 1
for num in range(2, tmp):
while n%num == 0:
n /= num
try:
factor[num] += 1
except:
factor[num] = 1
if int(n) != 1:
factor[int(n)] = 1
return factor
bunchan = bunkai(N)
ans = 0
for k in bunchan.keys():
cnt = 1
while bunchan[k] - cnt >= 0 :
bunchan[k] -= cnt
cnt += 1
ans += 1
print(ans)
| 1 | 16,777,880,673,060 | null | 136 | 136 |
# -*- coding: utf-8 -*-
def merge(A, left, mid, right):
global cnt
n1 = mid - left
n2 = right - mid
L = [None]*(n1+1)
R = [None]*(n2+1)
L[:n1] = A[left:left+n1]
R[:n2] = A[mid:mid+n2]
L[n1] = float('inf')
R[n2] = float('inf')
i = 0
j = 0
for k in range(left, right):
cnt += 1
if L[i] <= R[j]:
A[k] = L[i]
i += 1
else:
A[k] = R[j]
j += 1
def mergeSort(A, left, right):
if left + 1 < right:
mid = (left + right) // 2
mergeSort(A, left, mid)
mergeSort(A, mid, right)
merge(A, left, mid, right)
if __name__ == '__main__':
n = int(input())
S = [int(s) for s in input().split(" ")]
cnt = 0
mergeSort(S, 0, n)
print(" ".join(map(str, S)))
print(cnt)
|
cnt = 0
def merge(A, left, mid, right):
global cnt
L = A[left:mid]
R = A[mid:right]
L.append(float("inf"))
R.append(float("inf"))
i, j = 0, 0
for k in range(left, right):
cnt += 1
if L[i] <= R[j]:
A[k] = L[i]
i += 1
else:
A[k] = R[j]
j += 1
def mergeSort(A, left, right):
if left + 1 < right:
mid = (left+right)//2
mergeSort(A, left, mid)
mergeSort(A, mid, right)
merge(A, left, mid, right)
def solve(A):
left = 0
right = len(A)
mergeSort(A, left, right)
def resolve():
n = int(input())
A = [int(i) for i in input().split()]
solve(A)
print(*A)
print(cnt)
resolve()
| 1 | 112,858,222,062 | null | 26 | 26 |
X, Y = map(int, input().split())
ans = "No"
for i in range(101) :
for j in range(101) :
if(i + j != X) :
continue
if(2*i + 4*j != Y) :
continue
ans = "Yes"
break
print(ans)
|
def main():
N = int(input())
cnt = 0
for _ in range(N):
d1, d2 = map(int, input().split())
if d1 == d2:
cnt += 1
else:
cnt = 0
if cnt >= 3:
print("Yes")
return
print("No")
if __name__ == "__main__":
main()
| 0 | null | 8,086,243,828,608 | 127 | 72 |
import math
from functools import reduce
"""[summary]
全体：10^N
0が含まれない：9^N
9が含まれない：9^N
0,9の両方が含まれない：8^N
0,9のどちらか一方が含まれない：9^N + 9^N - 8^N
"""
N = int(input())
mod = (10 ** 9) + 7
calc = (10**N - 9**N - 9**N + 8**N) % mod
print(calc)
|
def main():
a, b = input().split()
a = int(a)
b = round(float(b) * 100)
print(int(a * b // 100))
if __name__ == "__main__":
main()
| 0 | null | 9,877,519,622,810 | 78 | 135 |
import bisect
n = int(input())
s = list(input())
q = int(input())
pos = [[] for i in range(26)]
alp = "abcdefghijklmnopqrstuvwxyz"
atoi = {}
for i in range(26):
atoi[alp[i]] = i
for i in range(n):
pos[atoi[s[i]]].append(i)
for i in range(q):
a, b, c = input().split()
if a == "1":
b = int(b)-1
if c == s[b]:
continue
index = bisect.bisect_left(pos[atoi[s[b]]], b)
del pos[atoi[s[b]]][index]
bisect.insort_left(pos[atoi[c]], b)
s[b] = c
else:
l, r = int(b)-1, int(c)
ans = 0
for i in range(26):
cnt = bisect.bisect_left(pos[i], r) - bisect.bisect_left(pos[i], l)
if cnt > 0:
ans += 1
print(ans)
|
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 SegmentTree():
def __init__(self, init_val, N):
"""
Parameters
----------
init_val:int
identity element
N:int
the number of nodes
"""
self.init_val=init_val
# Range Minimum Query
self.N0 = 2**(N-1).bit_length()
# 0-indexedで管理
self.data = [self.init_val] * (2 * self.N0)
def _segfunc(self, left, right):
res= left | right
return res
def update(self,k, x):
"""
Parameters
----------
k:int
target index(0-index)
x:any
target value
"""
k += self.N0-1
self.data[k] = x
while k > 0:
k = (k - 1) // 2
self.data[k] = self._segfunc(self.data[2*k+1], self.data[2*k+2])
def query(self, l, r):
"""
Parameters
----------
l,r:int
target range [l,r)
Return
----------
res:any
val
"""
L = l + self.N0
R = r + self.N0
s = self.init_val
while L < R:
if R & 1:
R -= 1
s = self._segfunc(s, self.data[R-1])
if L & 1:
s = self._segfunc(s,self.data[L-1])
L += 1
L >>= 1; R >>= 1
return s
n=inp()
s=input()
st = SegmentTree(0,n)
for i in range(n):
st.update(i,1<<(int.from_bytes(s[i].encode(),'little')-int.from_bytes('a'.encode(),'little')))
q = inp()
ans = []
for i in range(q):
mode, first, second = input().split()
if mode == "1":
st.update(int(first)-1,1<<(int.from_bytes(second.encode(),'little')-int.from_bytes('a'.encode(),'little')))
else:
ans.append(bin(st.query(int(first) - 1, int(second))).count("1"))
for i in ans:
print(i)
| 1 | 62,396,249,274,150 | null | 210 | 210 |
N = input()
K = int(input())
m = len(N)
dp = [[[0] * (K+1) for _ in range(2)] for _ in range(m+1)]
dp[0][0][0] = 1
for i in range(1,m+1):
l = int(N[i-1])
for k in range(K+1):
if k-1>=0:
if l!=0:
dp[i][0][k]=dp[i-1][0][k-1]
dp[i][1][k] = dp[i-1][1][k] + 9 * dp[i-1][1][k-1]+dp[i-1][0][k] + (l-1) * dp[i-1][0][k-1]
else:
dp[i][0][k] = dp[i-1][0][k]
dp[i][1][k] = dp[i-1][1][k] + 9 * dp[i-1][1][k-1]
else:
dp[i][0][k] = 0
dp[i][1][k] = 1
print(dp[m][0][K] + dp[m][1][K])
|
word, num = input(), 0
while True:
sentence = input()
if sentence=="END_OF_TEXT":
break
word_list = sentence.lower().replace(".", " ").split()
for i in word_list:
if word==i:
num += 1
print(num)
| 0 | null | 38,735,479,970,500 | 224 | 65 |
n, k = map(int,input().split())
num = []
for i in range(k):
j = int(input())
list_1 = list(map(int,input().split()))
for l in range(j):
num.append(list_1[l])
ans = set(num)
print(n - len(ans))
|
n, k = map(int, input().split())
A = []
A_dup = []
cnt = 0
for i in range(k):
input()
# A.append(list(map(int, input().split())))
A_dup += list(map(int, input().split()))
A_eldup = list(set(A_dup))
for i in range(1, n+1):
if i not in A_eldup:
cnt += 1
print(cnt)
| 1 | 24,781,070,473,120 | null | 154 | 154 |
from typing import List
class Dice:
def __init__(self, s: List[int]):
self.s = s
def get_s(self) -> int:
return self.s[0]
def invoke_method(self, mkey: str) -> None:
if mkey == 'S':
self.S()
return None
if mkey == 'N':
self.N()
return None
if mkey == 'E':
self.E()
return None
if mkey == 'W':
self.W()
return None
raise ValueError(f'This method does not exist. : {mkey}')
def set_s(self, s0, s1, s2, s3, s4, s5) -> None:
self.s[0] = s0
self.s[1] = s1
self.s[2] = s2
self.s[3] = s3
self.s[4] = s4
self.s[5] = s5
def S(self) -> None:
self.set_s(self.s[4], self.s[0], self.s[2], self.s[3], self.s[5],
self.s[1])
def N(self) -> None:
self.set_s(self.s[1], self.s[5], self.s[2], self.s[3], self.s[0],
self.s[4])
def E(self) -> None:
self.set_s(self.s[3], self.s[1], self.s[0], self.s[5], self.s[4],
self.s[2])
def W(self) -> None:
self.set_s(self.s[2], self.s[1], self.s[5], self.s[0], self.s[4],
self.s[3])
# 提出用
data = [int(i) for i in input().split()]
order = list(input())
# # 動作確認用
# data = [int(i) for i in '1 2 4 8 16 32'.split()]
# order = list('SE')
dice = Dice(data)
for o in order:
dice.invoke_method(o)
print(dice.get_s())
|
# coding: utf-8
class Dice(object):
def __init__(self, num_list):
self.num = num_list
def west(self):
num = list(self.num)
before = [5, 2, 0, 3]
after = [2, 0, 3, 5]
for i in range(4):
self.num[after[i]] = num[before[i]]
return self.num[5]
def east(self):
num = list(self.num)
before = [5, 2, 0, 3]
after = [3, 5, 2, 0]
for i in range(4):
self.num[after[i]] = num[before[i]]
return self.num[5]
def north(self):
num = list(self.num)
before = [0, 1, 5, 4]
after = [4, 0, 1, 5]
for i in range(4):
self.num[after[i]] = num[before[i]]
return self.num[5]
def south(self):
num = list(self.num)
before = [0, 1, 5, 4]
after = [1, 5, 4, 0]
for i in range(4):
self.num[after[i]] = num[before[i]]
return self.num[5]
if __name__ == "__main__":
num_list = [int(i) for i in raw_input().split()]
dice = Dice(num_list)
for order in raw_input():
if order == "E": dice.east()
elif order == "W": dice.west()
elif order == "S": dice.south()
elif order == "N": dice.north()
print dice.num[0]
| 1 | 233,932,274,810 | null | 33 | 33 |
from collections import Counter
N = int(input())
A = list(map(int, input().split()))
c = Counter(A)
key = c.keys()
comb = 0
for i in key:
comb += (c[i]) * (c[i]-1) // 2
for i in A:
ans = comb - (c[i]-1)
print(ans)
|
n = int(input())
lst = [int(i) for i in input().split()]
dic = {}
for i in range(n):
if lst[i] not in dic:
dic[lst[i]] = [1, 0, 0]
else:
dic[lst[i]][0] += 1
dic[lst[i]][1] = dic[lst[i]][0] * (dic[lst[i]][0] - 1) // 2
dic[lst[i]][2] = (dic[lst[i]][0] - 1) * (dic[lst[i]][0] - 2) // 2
#print(dic)
count = 0
for value in dic.values():
count += value[1]
for i in range(n):
m = lst[i]
count -= dic[m][1]
count += dic[m][2]
print(count)
count += dic[m][1]
count -= dic[m][2]
| 1 | 47,990,194,921,372 | null | 192 | 192 |
S=input()
Sa=len(S)
a="x"*Sa
print(a)
|
n=int(input())
s=list(input())
ans=0
for i in range(10):
if str(i) in s:
first=s.index(str(i))
ss=s[first+1:]
for j in range(10):
if str(j) in ss:
sec=ss.index(str(j))
for k in range(10):
if str(k) in ss[sec+1:]:
ans+=1
print(ans)
| 0 | null | 101,001,495,048,612 | 221 | 267 |
import sys
input = sys.stdin.readline
def log(*args):
print(*args, file=sys.stderr)
def main():
n = int(input().rstrip())
ans = [0 for _ in range(n)]
for x in range(1, 101):
for y in range(1, 101):
for z in range(1, 101):
tmp = pow(x, 2) + pow(y, 2) + pow(z, 2) + x * y + y * z + z * x
if tmp > n:
break
# if x == y == z:
# ans[tmp - 1] = 1
# elif x == y or y == z or z == x:
# ans[tmp - 1] = 3
# else:
# ans[tmp - 1] = 6
ans[tmp - 1] += 1
for v in ans:
print(v)
if __name__ == '__main__':
main()
|
import sys
lines = [line for line in sys.stdin]
gs =['S','H','C','D']
js = list(map(str,range(1,14)))
all=[g + " " +j for g in gs for j in js]
for g in lines[1:]:
g=g.strip()
all.remove(g)
for g in all:
print(g)
| 0 | null | 4,450,999,830,258 | 106 | 54 |
def DFS(word,N):
if len(word)==n:print(word)
else:
for i in range(N+1):
DFS(word+chr(97+i),N+1 if i==N else N)
n=int(input())
DFS("",0)
|
while True:
a = list(map(lambda x : int(x), input().split(" ")))
if a[0] == 0 and a[1] == 0:
break
for i in range(a[0]):
for j in range(a[1]):
print("#", end="")
print()
print()
| 0 | null | 26,728,074,858,342 | 198 | 49 |
a,b=map(int,input().split())
m=min(a,b)
kouyakusuu=1
for i in range(1,m+1):
if a%i==0 and b%i==0:
kouyakusuu=i
print(a*b//kouyakusuu)
|
n = int(input())
def count_ab(start, end):
l = len(str(n))
if start == 0:
return 0
if l == 1:
if start == end:
if n >= start:
return 1
else:
return 0
else:
return 0
else:
if start == end:
cnt = 1
else:
cnt = 0
if int(str(n)[0]) > start:
for i in range(1, l):
cnt += 10 ** i // 10
if int(str(n)[0]) == start:
for i in range(1, l - 1):
cnt += 10 ** i //10
cnt += int(str(n)[1:]) // 10
if int(str(n)[-1]) >= end:
cnt += 1
if int(str(n)[0]) < start:
for i in range(1, l - 1):
cnt += 10 ** i //10
return cnt
ans = 0
for i in range(10):
for j in range(10):
A = count_ab(i, j)
B = count_ab(j, i)
ans += A * B
print(ans)
| 0 | null | 99,841,438,000,382 | 256 | 234 |
N = int(input())
E = [[] for _ in range(N+1)]
for _ in range(N):
tmp = list(map(int, input().split()))
if tmp[1] == 0:
continue
E[tmp[0]] = tmp[2:]
cnt = [0 for _ in range(N+1)]
q = [1]
while q:
cp = q.pop(0)
for np in E[cp]:
if cnt[np] != 0:
continue
cnt[np] = cnt[cp] + 1
q.append(np)
for ind, cost in enumerate(cnt):
if ind == 0:
continue
if ind == 1:
print(ind, 0)
else:
if cost == 0:
print(ind, -1)
else:
print(ind, cost)
|
from collections import deque
# リストでグラフを表現する
n = int(input())
G = [input().split()[2:] for _ in range(n)]
# 頂点1から各頂点への距離を-1 (頂点1からたどり着けない)で初期化する
d = [-1] * n
que = deque() # 訪問予定の頂点を格納する
# 初期状態をキューに入れる
que.append(0)
d[0] = 0
while que:
p = que.popleft() # FIFOでキューの要素を取り出し、その頂点を訪ねる。
for v in G[p]:
v = int(v) - 1
if d[v] < 0: # まだ訪れたことがない
que.append(v)
# 距離を記録する
d[v] = d[p] + 1
for i in range(n):
print(i+1, d[i])
| 1 | 4,136,525,120 | null | 9 | 9 |
n = input()
n = n.split()
k = int(n[1])
n = int(n[0])
c = [0]
for f in range(n-1):
c.append(0)
for b in range(k):
d = int(input())
a = input()
a = a.split()
for e in range(d):
c[int(a[e])-1] = 1
h = 0
for g in range(n):
if c[g] == 0:
h = h + 1
print(h)
|
d, t, s = map(int, input().split())
print('Yes') if d / s <= t else print('No')
| 0 | null | 14,118,167,786,518 | 154 | 81 |
import sys
while 1:
H,W = map(int, raw_input().split())
if H == 0 and W == 0:
break
for i in range(H):
for j in range(W):
if i%2 == 0:
if j%2 == 0:
sys.stdout.write("#")
else:
sys.stdout.write(".")
if i%2 != 0:
if j%2 != 0:
sys.stdout.write("#")
else:
sys.stdout.write(".")
if j == W-1:
print ""
print ""
|
while True:
H,W = [int(i) for i in input().split()]
if H == 0 and W == 0:
break
else:
for line in list(range(1,H+1,1)):
for column in list(range(1,W+1,1)):
if line%2 == 1:
if column%2 == 1:
if column == W:
print("#")
else:
print("#", end = "")
else:
if column == W:
print(".")
else:
print(".", end = "")
else:
if column%2 == 1:
if column == W:
print(".")
else:
print(".", end = "")
else:
if column == W:
print("#")
else:
print("#", end = "")
print("")
| 1 | 875,139,921,180 | null | 51 | 51 |
l = list(map(int, input().split()))
for i in range(5):
if l[i] == 0:
print(i + 1)
|
A = list(map(int, input().split()))
#print(A)
def hantei(list):
for a in range(len(list)):
if list[a] == 0:
return a+1
print(hantei(A))
| 1 | 13,362,675,068,390 | null | 126 | 126 |
A,B = list(input().split())
A = int(A)
B = int((float(B)+0.005)*100)
print(A*B//100)
|
import math
# 素数か否かを判定する関数
def is_prime(n):
for i in range(2, int(math.sqrt(n))+1):
if n%i == 0:
return False
return True
# nまでの素数を返す関数（エラトステネスの篩）
def getPrime(n):
n_sqrt = int(math.sqrt(n))
array = [True]*(n_sqrt+1)
result = []
for i in range(2, n_sqrt+1):
if array[i]:
array[i] = False
result.append(i)
for j in range(i*2, n_sqrt+1, i):
array[j] = False
return result
N = int(input())
n = N
prime = getPrime(n)
prime_exp = []
# print(prime)
for p in prime:
cnt = 0
while n%p == 0:
n = int(n/p)
# print(n)
cnt += 1
if cnt != 0:
prime_exp.append([p, cnt])
if is_prime(n) and n != 1:
prime_exp.append([n, 1])
ans = 0
for pe in prime_exp:
ans += int((-1+math.sqrt(1+8*pe[1]))/2)
print(ans)
| 0 | null | 16,746,946,810,420 | 135 | 136 |
import itertools
N = int(input())
A = [int(x) for x in input().split()]
Acum = list(itertools.accumulate(A))
reg=10**12
for i in range(N):
reg = min(reg,
abs(Acum[-1] - Acum[i] * 2))
print(reg)
|
N=int(input())
alist=list(map(int,input().split()))
slist=[0]
for a in alist:
slist.append(slist[-1]+a)
#print(slist)
answer=float("inf")
for i in range(N+1):
s1=slist[i]
s2=slist[-1]-s1
answer=min(answer,abs(s1-s2))
print(answer)
| 1 | 141,818,329,575,718 | null | 276 | 276 |
import math
x1,y1,x2,y2=input().split()
x1=float(x1)
y1=float(y1)
x2=float(x2)
y2=float(y2)
r=math.sqrt((x1-x2)*(x1-x2)+(y1-y2)*(y1-y2))
print(r)
|
import sys
for line in sys.stdin:
a, b = map(int, line.split())
A, B = min(a, b), max(a, b)
while True:
mod = B % A
if mod == 0:
gcd = A
break
else:
A, B = mod, A
lcm = gcd * (a / gcd) * (b / gcd)
print '%d %d' % (gcd, lcm)
| 0 | null | 78,165,247,292 | 29 | 5 |
import sys
input = sys.stdin.readline
from collections import deque
def main():
N, D, A = map(int, input().split())
monsters = sorted([list(map(int, input().split())) for _ in range(N)])
for i in range(N):
monsters[i][1] = (monsters[i][1] + A - 1) // A
attacks = deque([]) # [(有効範囲, 攻撃回数)]
ans = 0
atk = 0
for i in range(N):
atk_this = monsters[i][1]
while attacks and monsters[i][0] > attacks[0][0]:
_, atk_ = attacks.popleft()
atk -= atk_
if atk_this - atk > 0:
ans += atk_this - atk
attacks.append((monsters[i][0]+2*D, atk_this-atk))
atk += atk_this - atk
print(ans)
if __name__ == '__main__':
main()
|
def A():
n, x, t = map(int, input().split())
print(t * ((n+x-1)//x))
def B():
n = list(input())
s = 0
for e in n:
s += int(e)
print("Yes" if s % 9 == 0 else "No")
def C():
int(input())
a = list(map(int, input().split()))
l = 0
ans = 0
for e in a:
if e < l: ans += l - e
l = max(l, e)
print(ans)
def E():
h, w, m = map(int, input().split())
row = [0] * h
col = [0] * w
exist = set([])
th = 1000000000
for i in range(m):
x, y = map(int, input().split())
x -= 1
y -= 1
row[x] += 1
col[y] += 1
exist.add(x*th + y)
max_row = max(row)
max_col = max(col)
candi_row = []
candi_col = []
for i in range(h):
if row[i] == max_row: candi_row.append(i)
for i in range(w):
if col[i] == max_col: candi_col.append(i)
ans = max_row + max_col
for x in candi_row:
for y in candi_col:
if x*th + y in exist: continue
print(ans)
return
print(ans - 1)
E()
| 0 | null | 43,406,304,033,888 | 230 | 89 |
def gcd(a,b):
if a > b:
x = a
y = b
else:
x = b
y = a
while y > 0:
r = x % y
x = y
y = r
return x
def lcm(a,b,c):
return int(a*b/c)
while 1:
try:
a,b = [int(x) for x in input().split()]
res_gcd = gcd(a,b)
res_lcm = lcm(a,b,res_gcd)
print('{} {}'.format(res_gcd,res_lcm))
except:
break
|
import fractions
while True:
try:
x,y = map(int,raw_input().split())
print '%d %d' % (fractions.gcd(x,y),x/fractions.gcd(x,y)*y)
except EOFError:
break
| 1 | 573,102,208 | null | 5 | 5 |
N=int(input())
A=list(map(int,input().split()))
#B=[]
#C=[]
D=[0]*1000000
E=[0]*1000000
ans=0
for i in range(N):
if A[i]<500000:
#B.append(A[i]+i+1)
#C.append(-A[i]+i+1)
#if -A[i]+i>=0:
D[A[i]+i]+=1
E[-A[i]+i]+=1
#print(E[-A[i]+i],-A[i]+i)
for i in range(1000000):
#ans+=C.count(i)
ans+=D[i]*E[i]
print(ans)
|
from collections import defaultdict
from collections import deque
from collections import Counter
import math
def readInt():
return int(input())
def readInts():
return list(map(int, input().split()))
def readChar():
return input()
def readChars():
return input().split()
k = readInt()
n = 7
for i in range(10**6):
if n%k==0:
print(i+1)
exit()
else:
n = (n*10+7)%k
print(-1)
| 0 | null | 16,099,029,435,800 | 157 | 97 |
import math
import statistics
a=int(input())
#b=int(input())
# c=[]
# for i in b:
# c.append(i)
# e1,e2 = map(int,input().split())
f = list(map(int,input().split()))
#j = [input() for _ in range(3)]
# h = []
# for i in range(e1):
# h.append(list(map(int,input().split())))
ans=0
count=0
for i in range(a):
if ans+1 == f[i]:
ans=f[i]
count+=1
if count>0:
print(len(f)-count)
else:
print(-1)
|
import sys
input = sys.stdin.readline
mod = 10**9 + 7
n = int(input())
ab = [[int(x) for x in input().split()] for _ in range(n)]
from collections import defaultdict, Counter
import math
double_zero_cnt = 0
a_zero_cnt = 0
b_zero_cnt = 0
d = defaultdict(list) # [a, b] ngのそれぞれの個数
a_b = []
for a, b in ab:
if a == 0 and b == 0:
double_zero_cnt += 1
continue
elif a == 0:
a_zero_cnt += 1
continue
elif b == 0:
b_zero_cnt += 1
continue
g = math.gcd(a, b)
a //= g
b //= g
if b < 0:
b *= (-1)
a *= (-1) # 必ずbは正
a_b.append((a, b))
c = Counter(a_b)
key_list = list(c.keys())
for key in key_list:
a, b = key
if a < 0:
a_ = a*(-1)
b_ = b*(-1)
else:
a_ = a
b_ = b
if d[(-b_, a_)] != []:
continue
if c[(-b_, a_)] != 0:
d[(a, b)] = [c[(a, b)], c[(-b_, a_)]]
ans = 1
used_cnt = double_zero_cnt
for key in d.keys():
if d[key] == []:
continue
x, y = d[key]
used_cnt += (x + y)
mul = (pow(2, x, mod) + pow(2, y, mod) - 1) % mod
ans *= mul
ans %= mod
if a_zero_cnt > 0 and b_zero_cnt > 0:
ans *= (pow(2, a_zero_cnt, mod) + pow(2, b_zero_cnt, mod) - 1)
ans %= mod
used_cnt += a_zero_cnt + b_zero_cnt
elif a_zero_cnt > 0:
ans *= pow(2, a_zero_cnt, mod)
ans %= mod
used_cnt += a_zero_cnt
elif b_zero_cnt > 0:
ans *= pow(2, b_zero_cnt, mod)
ans %= mod
used_cnt += b_zero_cnt
ans *= pow(2, n - (used_cnt), mod)
ans %= mod
ans -= 1
ans += double_zero_cnt
ans %= mod
print(ans)
| 0 | null | 67,527,038,724,068 | 257 | 146 |
str1, str2 = input()*2, input()
if str2 in str1:
print("Yes")
else:
print("No")
|
s = input()
p = input()
ring = s * 2
if p in ring:
print("Yes")
else:
print("No")
| 1 | 1,768,391,725,888 | null | 64 | 64 |
n, k, c = map(int, input().split())
s = input()
l = []
tmp = 0
cnt = 0
while (tmp < n):
if s[tmp] == "o":
l.append(tmp)
tmp += c + 1
cnt += 1
else:
tmp += 1
if cnt > k:
exit()
l2 = []
tmp2 = n - 1
cnt2 = 0
while (tmp2 >= 0):
if s[tmp2] == "o":
l2.append(tmp2)
tmp2 -= c + 1
cnt2 += 1
else:
tmp2 -= 1
if cnt2 > k:
exit()
for i in range(k):
if l[i] == l2[k - 1 - i]:
print(l[i]+1)
|
def main():
N, K, C = map(int, input().split())
S = input()
# greedy
head, tail = [-C - 1] * (K + 1), [N + C + 1] * (K + 1)
idx = 0
for i in range(N):
if S[i] == 'o' and i - head[idx] > C:
idx += 1
head[idx] = i
if idx == K:
break
idx = K
for i in range(N - 1, -1, -1):
if S[i] == 'o' and tail[idx] - i > C:
idx -= 1
tail[idx] = i
if idx == 0:
break
# ans
for i in range(K):
if head[i + 1] == tail[i]:
print(tail[i] + 1)
if __name__ == '__main__':
main()
| 1 | 40,675,139,040,320 | null | 182 | 182 |
user_input = int(input())
print(user_input + user_input**2 + user_input**3)
|
import sys
if __name__ == "__main__":
n,m = map(int,input().split())
c = list(map(int,input().split()))
INF = 10**18
dp = [INF]*(n+1)
dp[0] = 0
for i in c:
for j in range(i,n+1):
dp[j] = min(dp[j],dp[j-i]+1)
print(dp[-1])
| 0 | null | 5,185,945,286,742 | 115 | 28 |
from collections import Counter
N = int(input())
S = [input() for _ in range(N)]
cnt = Counter(S)
M = max(list(cnt.values()))
ans = []
for k, v in cnt.items():
if v==M:
ans.append(k)
ans.sort()
for ans_i in ans:
print(ans_i)
|
a = list(input())
b = list(input())
num = len(a)
S = 0
for i in range(num):
if a[i] != b[i]:
S += 1
print(S)
| 0 | null | 40,188,754,166,610 | 218 | 116 |
a,b = input().split()
x = int(a) * b
y = int(b) * a
l = []
l.append(x)
l.append(y)
l = sorted(l)
print(min(l))
|
# Comparing Strings
a, b = map(int, input().split())
a, b = min(a, b), max(a, b)
ans = ''.join([str(a) for e in range(b)])
print(ans)
| 1 | 84,325,422,993,980 | null | 232 | 232 |
import sys
BIG_NUM = 2000000000
MOD = 1000000007
EPS = 0.000000001
NUM = 20005
table = [""]*NUM
while True:
T = str(input())
if T == '-':
break
left = 0
right = 0
#長い配列にパターン文字列を転記
for i in range(len(T)):
# print(T[right])
table[left+right] = T[right]
right += 1
num_suffle = int(input())
for loop in range(num_suffle):
pick_num = int(input())
#先頭からpick_num文字を末尾に転記し、論理削除
for i in range(pick_num):
table[right+i] = table[left+i]
left += pick_num
right += pick_num
for i in range(left,right):
print("%s"%(table[i]),end = "")
print()
|
while True :
str = input()
if str == '-' : exit()
times = int(input())
for i in range(times) :
h = int(input())
s_f = str[:h]
s_l = str[h:]
str = s_l + s_f
print(str)
| 1 | 1,883,866,289,970 | null | 66 | 66 |
N=int(input())
A=[]
B=[]
for i in range(N):
a,b=map(int,input().split())
A.append(a)
B.append(b)
A.sort()
B.sort()
if N%2!=0:
n=(N+1)//2
ans=B[n-1]-A[n-1]+1
else:
n=N//2
ans1=(A[n-1]+A[n])/2
ans2=(B[n-1]+B[n])/2
ans=(ans2-ans1)*2+1
print(int(ans))
|
n=int(input())
A=[]
B=[]
for i in range(n):
a,b=map(int,input().split())
A.append(a)
B.append(b)
A.sort()
B.sort()
if n%2==1:
print(B[n//2]-A[n//2]+1)
else:
print(int(((B[n//2]+B[n//2-1])/2-(A[n//2]+A[n//2-1])/2)*2+1))
| 1 | 17,412,501,715,168 | null | 137 | 137 |
N=int(input())
*A,=map(int,input().split())
total=0
for i in range(N):
total ^= A[i]
print(*[total^A[i] for i in range(N)])
|
n = int(input())
ab = []
for i in range(n-1):
a, b = map(int,input().split())
ab.append([a, b])
graph = [[] for _ in range(n+1)]
for a,b in ab:
graph[a].append(b)
graph[b].append(a)
root = 1
parent = [0] * (n+1)
order = []
stack = [root]
while stack:
x = stack.pop()
order.append(x)
for y in graph[x]:
if y == parent[x]:
continue
parent[y] = x
stack.append(y)
color = [-1] * (n+1)
for x in order:
ng = color[x]
c = 1
for y in graph[x]:
if y == parent[x]:
continue # 子に対応させる
if c == ng:
c += 1
color[y] = c
c += 1
print(max(color))
for a,b in ab:
if parent[a] == b:
print(color[a])
else:
print(color[b])
| 0 | null | 74,118,891,516,842 | 123 | 272 |
import bisect
import sys
input=sys.stdin.readline
n,d,a=map(int,input().split())
l=[list(map(int,input().split())) for i in range(n)]
l.sort()
data0=[0]*(n+1)
data1=[0]*(n+1)
def _add(data,k,x):
while k<=n:
data[k]+=x
k+=k&-k
def add(l,r,x):
_add(data0,l,-x*(l-1))
_add(data0,r,x*(r-1))
_add(data1,l,x)
_add(data1,r,-x)
def _get(data,k):
s=0
while k:
s+=data[k]
k-=k&-k
return s
def query(l,r):
return _get(data1,r-1)*(r-1)+_get(data0,r-1)-_get(data1,l-1)*(l-1)-_get(data0,l-1)
x=[]
for i in range(n):
x.append(l[i][0])
add(i+1,i+2,l[i][1])
Right=[]
for i in range(n):
Right.append(bisect.bisect_right(x,x[i]+2*d))
p=0
ans=0
while p<n:
Q=query(p+1,p+2)
add(p+1,Right[p]+1,-((Q+a-1)//a)*a)
ans+=(Q+a-1)//a
p=min(p+1,n-1)
while query(p+1,p+2)<=0:
p+=1
if p==n:
break
print(ans)
|
import sys
from collections import deque
from bisect import bisect_right
from math import ceil
def input(): return sys.stdin.readline().strip()
N, D, A = map(int, input().split())
monsters = [(-1, -1)]
for _ in range(N):
x, h = map(int, input().split())
monsters.append((x, h))
monsters.sort()
#print("monsters = {}".format(monsters))
"""
どうせ左端のモンスターはいつか倒さないといけない（かつ爆弾投下順は不問）ので、
左端のモンスターから順に、なるべく爆弾を右に寄せて落としていけば良い。
別解としてBITでも殴ってみた
"""
class BIT:
"""
https://tjkendev.github.io/procon-library/python/range_query/bit.html
Binary index treeの実装
配列[a1, a2,...,an]に対して以下のクエリをO(logn)で行う:
1. aiにxを加える
2. 区間和 ai + a(i+1) + ... + aj の和を求める
"""
def __init__(self, n):
"""
添字は1スタート
"""
self.n = n
self.data = [0] * (n + 1)
self.el = [0] * (n + 1)
def add(self, i, x):
"""
i>0に対してaiにxを加算(x < 0でもOK)
"""
if i <= 0 or self.n < i:
print("i should be within 1 to n")
else:
self.el[i] += x
while i <= self.n:
self.data[i] += x
i += i & -i
def sum(self, i):
"""
添字1からiまでの累積和を求める
"""
s = 0
while i > 0:
s += self.data[i]
i -= i & -i
return s
def get(self, i, j=None):
"""
添字iからjまでの累積和を求める
j=Noneの場合はaiの値を返す
"""
if j is None:
return self.el[i]
return self.sum(j) - self.sum(i - 1)
"""
BITで区間に対する加算をする場合はimos法を利用することに注意する
"""
Damage = BIT(N)
ans = 0
for i in range(1, N + 1):
x, h = monsters[i]
d = Damage.sum(i) # モンスターiに入っているダメージ
if d < h:
times = ceil((h - d) / A)
ans += times
new_damage = times * A
#print("ans+={} for monster {}".format(times, i))
idx = bisect_right(monsters, (monsters[i][0] + 2 * D, 10**10))
Damage.add(i, new_damage)
if idx != N + 1:
Damage.add(idx, -new_damage)
print(ans)
| 1 | 82,141,625,189,312 | null | 230 | 230 |
def divisor(n):
ret=[]
for i in range(1,int(n**0.5)+1):
if n%i==0:
a,b=i,n//i
if a!=b:
ret+=a,
ret+=b,
else:
ret+=a,
return sorted(ret)
def f(n):
return divisor(n)[1:]
def solve(n):
ans=f(n-1)
for k in f(n):
N=n
while N>=k:
if N%k==0:N=N//k
else:N=N%k
if N==1:ans+=k,
print(len(ans))
return 0
solve(int(input()))
|
# coding: utf-8
def check_divide(n):
max_v = int(n ** (1/2))
divide_nums = []
for i in range(1,max_v + 1):
if n % i == 0:
divide_nums.append(i)
return divide_nums
def check_divide2(n):
divide_nums = []
for K in range(2,n+1):
tmp = n
while True:
if tmp % K ==0:
tmp = tmp // K
else:break
if tmp % K == 1:
divide_nums.append(K)
return divide_nums
if __name__ == '__main__':
N = int(input())
tmp1 = check_divide(N-1)
if tmp1[-1] ** 2 == N-1:
tmp1 = len(tmp1) * 2 - 2
else:
tmp1 = len(tmp1) * 2 - 1
candidates = check_divide(N)[1:]
tmp2 = [N]
for val in candidates:
N_ = N
while True:
if N_ % val == 0:
N_ = N_ / val
else:break
if N_ % val == 1:
tmp2.append(val)
tmp2 = len(tmp2)
print(tmp1 + tmp2)
| 1 | 41,322,505,222,880 | null | 183 | 183 |
import math
r = float(input())
S = math.pi * (r**2)
l = 2 * math.pi * r
print("{} {}".format(S, l))
|
from math import atan, degrees
def is_divisible(a):
return 'Yes' if any(int(a/x) == a/x and a/x <= 9 for x in range(1,10)) and a <= 81 else 'No'
print(is_divisible(int(input())))
| 0 | null | 79,852,301,409,858 | 46 | 287 |
N=input()
L=len(N)
ans=[[0 for e in range(2)] for f in range(L)]
ans[0][0]=int(N[L-1])
ans[0][1]=10-int(N[L-1])
if L>1:
for i in range(1,L):
ans[i][0]=min(ans[i-1][0]+int(N[L-1-i]),ans[i-1][1]+int(N[L-1-i])+1)
ans[i][1]=min(ans[i-1][0]+10-int(N[L-1-i]),ans[i-1][1]+10-int(N[L-1-i])-1)
print(min(ans[L-1][0],ans[L-1][1]+1))
|
n = input()[::-1]
dp = [[0, 0] for i in range(len(n) + 1)]
dp[0][1] = 1
for i in range(len(n)):
dp[i + 1][0] = min(dp[i][0] + int(n[i]), dp[i][1] - int(n[i]) + 10)
dp[i + 1][1] = min(dp[i][0] + int(n[i]) + 1, dp[i][1] - int(n[i]) + 9)
print(dp[len(n)][0])
| 1 | 70,659,148,138,172 | null | 219 | 219 |
#
import sys
input=sys.stdin.readline
def main():
N,K=map(int,input().split())
A=list(map(lambda x: int(x)-1,input().split()))
latest=[-1]*N
latest[0]=0
now=0
while(K>0):
K-=1
to=A[now]
if latest[A[now]]!=-1:
K%=latest[now]-latest[A[now]]+1
latest[A[now]]=latest[now]+1
now=to
print(now+1)
if __name__=="__main__":
main()
|
n, m = map(int, input().split())
A = list(map(int, input().split()))
A.sort()
import bisect
def is_ok(x):
cnt = 0
for i, a in enumerate(A):
j = bisect.bisect_left(A, x-a)
cnt += n-j
if cnt >= m:
return True
else:
return False
l = 0
r = 2*10**5+1
while l+1 < r:
c = (l+r)//2
if is_ok(c):
l = c
else:
r = c
from itertools import accumulate
B = [0]+A
B = list(accumulate(B))
ans = 0
cnt = 0
for a in A:
j = bisect.bisect_left(A, l-a)
cnt += (n-j)
ans += B[-1]-B[j]+a*(n-j)
ans -= (cnt-m)*l
print(ans)
| 0 | null | 65,536,041,680,620 | 150 | 252 |
n = int(input())
print(int(n/2+0.9))
|
n = int(input())
ans = (n//2) + (n%2)
print (ans)
| 1 | 58,975,771,669,178 | null | 206 | 206 |
# -*- coding: utf-8 -*-
import sys
N=input()
bit=[ [ 0 for _ in range(N+1) ] for __ in range(27) ]
def add(i,a,w):
while a<=N:
bit[i][a]+=w
a+=a&-a
def sum(i,a):
ret=0
while 0<a:
ret+=bit[i][a]
a-=a&-a
return ret
S=sys.stdin.readline().strip()
S=[None]+list(S) #1-indexed
for j,x in enumerate(S):
if j==0: continue
i=ord(x)-96
add(i,j,1)
Q=input()
for _ in range(Q):
q1,q2,q3=sys.stdin.readline().split()
if q1=="1":
q1=int(q1)
q2=int(q2)
current_s=q3
former_s=S[q2]
former_s=ord(former_s)-96 #1-indexed
S[q2]=current_s #文字列で更新された1文字を置き換える
current_s=ord(current_s)-96
add(current_s,q2,1)
add(former_s,q2,-1)
if q1=="2":
q2=int(q2)
q3=int(q3)
begin,end=q2,q3
cnt=0
for i in range(1,27):
if 0<sum(i,end)-sum(i,begin-1):
cnt+=1
print cnt
|
alpha = str(input())
if alpha.isupper():
ans = 'A'
else:
ans = 'a'
print(ans)
| 0 | null | 37,013,703,946,138 | 210 | 119 |
import sys
readline = sys.stdin.readline
MOD = 10 ** 9 + 7
INF = float('INF')
sys.setrecursionlimit(10 ** 5)
def main():
S = input()
l = len(S)
print("x" * l)
if __name__ == '__main__':
main()
|
S=input()
lis=['SUN','MON','TUE','WED','THU','FRI','SAT']
i=lis.index(S)
if S=='SUN':
print(7)
else:
for j in range(1,8):
if lis[i-j]=='SUN':
print(7-j)
break
| 0 | null | 102,847,473,798,588 | 221 | 270 |
class UnionFind:
def __init__(self, n):
self.par = [i for i in range(n+1)]
self.rank = [0] * (n+1)
self.size = [1] * (n+1)
# 検索
def find(self, x):
if self.par[x] == x:
return x
else:
self.par[x] = self.find(self.par[x])
return self.par[x]
# 併合
def union(self, x, y):
x = self.find(x)
y = self.find(y)
if x == y:
return
if self.rank[x] < self.rank[y]:
self.par[x] = y
self.size[y] += self.size[x]
else:
self.par[y] = x
self.size[x] += self.size[y]
if self.rank[x] == self.rank[y]:
self.rank[x] += 1
# 同じ集合に属するか判定
def same_check(self, x, y):
return self.find(x) == self.find(y)
n,m = map(int,input().split())
uf = UnionFind(n)
for i in range(m):
a,b = map(int,input().split())
uf.union(a,b)
print(max(uf.size))
|
n, m = map(int, input().split())
class UnionFind():
def __init__(self, n):
self.n = n
self.parent = [int(x) for x in range(n)]
self.tree_size = [1 for _ in range(n)]
def unite(self, x, y):
x_root = self.find(x)
y_root = self.find(y)
if self.same(x_root, y_root):
return
if self.size(x_root) >= self.size(y_root):
self.parent[y_root] = x_root
self.tree_size[x_root] += self.tree_size[y_root]
else:
self.parent[x_root] = y_root
self.tree_size[y_root] += self.tree_size[x_root]
def find(self, x):
if self.parent[x] == x:
return x
else:
next = self.find(self.parent[x])
self.parent[x] = next
return next
def size(self, x):
return self.tree_size[self.find(x)]
def same(self, x, y):
if self.find(x) == self.find(y):
return True
else:
return False
uf = UnionFind(n)
for _ in range(m):
a, b = map(int, input().split())
uf.unite(a-1, b-1)
# print([uf.size(i) for i in range(n)])
print(max([uf.size(i) for i in range(n)]))
| 1 | 4,004,564,684,920 | null | 84 | 84 |
k=int(input())
q=["1","2","3","4","5","6","7","8","9"]
x=9
for i in q:
if x>100000:
break
x+=1
a=i[-1]
for j in ([-1,0,1]):
bb=int(a)+j
if bb<10 and bb>=0:
q.append(i+str(bb))
print(q[k-1])
|
def draft(A, K, N):
for _ in range(1, K+1):# 2 * 10**5
tmp = [0]*(N+1)
for i in range(N):# 2 * 10**5
L = max(0, i - A[i])
R = min(N, i + A[i]+1)
tmp[L] += 1
tmp[R] -= 1
f = True
for i in range(N):
tmp[i+1] += tmp[i]
A[i] = tmp[i]
if A[i] != N:
f = False
if f:
break
for i in range(N):
print(A[i], end=" ")
def main():
N, K = map(int, input().split())
A = list(map(int, input().split()))
draft(A, K, N)
if __name__ == "__main__":
main()
| 0 | null | 27,600,235,467,012 | 181 | 132 |
H,N=map(int,input().split())
L=[0]*N
for i in range(N):
a,b=map(int,input().split())
L[i]=(a,b)
DP=[float("inf")]*(H+1)
DP[0]=0
for (A,B) in L:
for k in range(1,H+1):
if k>=A:
DP[k]=min(DP[k],DP[k-A]+B)
else:
DP[k]=min(DP[k],B)
print(DP[-1])
|
from bisect import bisect
N, M, K = map(int, input().split())
A = list(map(int, input().split()))
B = list(map(int, input().split()))
SA = [0] * (N + 1)
SB = [0] * (M + 1)
for i in range(N):
SA[i+1] = SA[i] + A[i]
for i in range(M):
SB[i+1] = SB[i] + B[i]
result = 0
for x in range(N+1):
if SA[x] > K:
break
y = bisect(SB, K - SA[x]) - 1
result = max(result, x + y)
print(result)
| 0 | null | 45,967,803,740,340 | 229 | 117 |
def main():
s = input()
t = input()
ans = 0
for i, char in enumerate(s):
if char != t[i]:
ans += 1
print(ans)
if __name__ == '__main__':
main()
|
d,t,s=map(int, input().split())
if d/s<=t:
print("Yes")
else:
print("No")
| 0 | null | 7,061,319,101,056 | 116 | 81 |
n = int(input())
A = list(map(int, input().split()))
SWAP = 0
def conquer(A, left, mid, right):
L, R = A[left:mid], A[mid:right]
# L, Rの末尾にINFTYを入れないと、L[-1] or R[-1]が評価されない
INFTY = 2 ** 30
L.append(INFTY)
R.append(INFTY)
# i : position in L, j : position in R
i, j = 0, 0
swap_times = 0
# 元のArrayを変えたいため、kを生成
for k in range(left, right):
# print(i, j, L, R, A)
if L[i] <= R[j]:
A[k] = L[i]
i = i + 1
else:
A[k] = R[j]
j = j + 1
swap_times += 1
return swap_times
def divide(A, left, right):
# print(left, right)
# A[right-left]が2つ以上の場合に
if left+1 < right:
mid = (left+right)//2
countL = divide(A, left, mid)
countR = divide(A, mid, right)
return conquer(A, left, mid, right) + countL + countR
return 0
def mergeSort(A):
return divide(A, 0, len(A))
swap = mergeSort(A)
print(" ".join([ str(i) for i in A]))
print(swap)
|
import networkx as nx
H, W = map(int, input().split())
maze = [input() for _ in range(H)]
G = nx.Graph()
# 辺を加えていく
for h in range(H):
for w in range(W - 1):
if maze[h][w] == maze[h][w + 1] == '.':
G.add_edge((h, w), (h, w + 1))
for h in range(H - 1):
for w in range(W):
if maze[h][w] == maze[h + 1][w] == '.':
G.add_edge((h, w), (h + 1, w))
def bfs(sy, sx):
d = dict()
d[(sy, sx)] = 0
for coordinate_from, coordinate_to in nx.bfs_edges(G, (sy, sx)):
d[coordinate_to] = d[coordinate_from] + 1
return max(d.values())
ans = 0
for y in range(H):
for x in range(W):
if maze[y][x] == '.':
ans = max(ans, bfs(y, x))
print(ans)
| 0 | null | 47,566,867,503,948 | 26 | 241 |
def solve():
n = int(input())
if n % 2 == 0:
print(0.5)
else:
print(((n+1)//2) / n)
if __name__ == '__main__':
solve()
|
N = int(input())
ans = 0
for i in range(N):
j = i + 1
if j % 3 != 0 and j % 5 != 0:
ans += j
print(ans)
| 0 | null | 105,761,181,667,480 | 297 | 173 |
#!/usr/bin/env python3
def _f(H, W, S):
'''
>>> f = _f(3, 3, [[1, 0, 0], [1, 0, 1], [0, 1, 1]])
>>> f(0, 0, 1, 1)
1
>>> f(0, 0, 3, 0)
0
>>> f(0, 0, 3, 1)
2
>>> f(1, 1, 3, 3)
3
>>> f(0, 0, 3, 3)
5
>>> f(2, 0, 3, 3)
2
'''
acc = [[0] * (W + 1) for _ in range(H+1)]
for h in range(1, H+1):
for w in range(1, W+1):
acc[h][w] = acc[h][w-1] + acc[h-1][w] - acc[h-1][w-1] + S[h-1][w-1]
def f(sh, sw, eh, ew):
return acc[eh][ew] + acc[sh][sw] - acc[sh][ew] - acc[eh][sw]
return f
def _solve(H, W, K, S, c, f):
#print(H, W, K, S, c, f)
sw = 0
cut = 0
for ew in range(1, W+1):
#print([(((sh, sw), (eh, ew)), f(sh, sw, eh, ew)) for sh, eh in c])
if any(f(sh, ew-1, eh, ew) > K for sh, eh in c):
return float('inf')
if any(f(sh, sw, eh, ew) > K for sh, eh in c):
cut += 1
sw = ew - 1
return cut
def solve(H, W, K, S):
from itertools import product, compress
f = _f(H, W, S)
ans = float('inf')
for flag in product(range(2), repeat=H-1):
t = (0,) + tuple(compress(range(1,H), flag)) + (H,)
c = tuple(zip(t, t[1:]))
ans = min(ans, _solve(H, W, K, S, c, f)+sum(flag))
return ans
# Generated by 1.1.6 https://github.com/kyuridenamida/atcoder-tools
def main():
H, W, K = list(map(int, input().split()))
S = [list(map(int, input())) for _ in range(H)]
print(solve(H, W, K, S))
def test():
import doctest
doctest.testmod()
if __name__ == '__main__':
#test()
main()
|
def main():
H, W, K = map(int, input().split())
g = [input() for _ in range(H)]
ans = 1 << 100
for i in range(1 << H - 1):
need = bin(i).count("1")
sz = need + 1
cnt = [0] * sz
f = 1
for j in range(W):
c = 0
for k in range(H):
cnt[c] += g[k][j] == "1"
if cnt[c] > K:
break
c += (i >> k) & 1
else:
continue
cnt = [0] * sz
need += 1
if need > ans:
f = 0
break
c = 0
for k in range(H):
cnt[c] += g[k][j] == "1"
if cnt[c] > K:
break
c += (i >> k) & 1
else:
continue
f = 0
break
if f:
ans = min(ans, need)
print(ans)
if __name__ == '__main__':
main()
| 1 | 48,456,074,496,208 | null | 193 | 193 |
def main():
n = int(input())
s = input()
if n < 4:
print(0)
return
ans = s.count("R") * s.count("G") * s.count("B")
for i, si in enumerate(s[:-2]):
for j, sj in enumerate(s[i+1:-1]):
if si == sj:
continue
if i + 2*j+2 < n and si != s[i + 2*j+2] != sj:
ans -= 1
print(ans)
if __name__ == '__main__':
main()
|
x,y=list(map(int,raw_input().split()))
w=x
h=y
if x==1 or y==1:
print("1")
exit(0)
ans=x//2 * (h//2 + (h+1)//2)
if x%2==1:
ans+=(h+1)//2
print(ans)
| 0 | null | 43,339,168,089,052 | 175 | 196 |
n = int(input())
c = 0
for i in range(1,n):
if (i%2==1):
c+=1
print("{0:.10f}".format(1-(c/n)))
|
N = int(input())
ans = (N + N%2)/(2*N)
print(ans)
| 1 | 177,206,558,510,980 | null | 297 | 297 |
s = input()
if s == 'RRR':
print(3)
elif s[:2] == "RR" or s[1:] == "RR":
print(2)
elif 'R' in s:
print(1)
else:
print(0)
|
a,b = [int(num) for num in input().split()]
print(a*b)
| 0 | null | 10,369,668,224,032 | 90 | 133 |
import itertools
import bisect
N = int(input())
LS = list(map(int,input().split()))
LS.sort()
ans = 0
for a,b in itertools.combinations(LS,2):
a,b = min(a,b),max(a,b)
lo = b - a
up = a + b
cnt = bisect.bisect_left(LS,up) - bisect.bisect_right(LS,lo) - 1
if lo < a:
cnt -= 1
if cnt <= 0:
continue
ans += cnt
print(ans // 3)
|
import bisect
N = int(input())
L = list(map(int,input().split()))
L = sorted(L,reverse = False)
cnt = 0
# a の index
for a in range(len(L)):
# b の index
for b in range(a+1,len(L)):
# c が取りうる最大の index
c_idx = bisect.bisect_left(L,L[a]+L[b]) - 1
cnt += c_idx - b
print(cnt)
| 1 | 171,743,451,554,268 | null | 294 | 294 |
a=int(input())
b=a//3
c=a//5
d=a//15
z=0
y=0
w=0
v=0
for x in range(a+1):
z=z+x
for x in range(b+1):
y=y+x*3
for x in range(c+1):
w=w+x*5
for x in range(d+1):
v=v+x*15
print(z-y-w+v)
|
def main():
N, P = (int(i) for i in input().split())
L = [int(s) for s in input()][::-1]
ans = 0
if P == 2 or P == 5:
for i, e in enumerate(L):
if e % P == 0:
ans += N-i
else:
A = [0]*N
d = 1
for i, e in enumerate(L):
A[i] = (e*d) % P
d *= 10
d %= P
S = [0]*(N+1)
for i in range(N):
S[i+1] = S[i] + A[i]
S[i+1] %= P
from collections import Counter
c = Counter(S)
for v in c.values():
ans += v*(v-1)//2
print(ans)
if __name__ == '__main__':
main()
| 0 | null | 46,452,862,622,852 | 173 | 205 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.