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
|
|---|---|---|---|---|---|---|
n = int(input())
s = input()
r = s.count('R')
g = s.count('G')
b = s.count('B')
cnt = 0
for i in range(n):
j = 1
while i + 2*j <= n-1:
# if s[i] != s[i+j] and s[i+j] != s[i+2*j] and s[i+2*j] != s[i]:
if len({s[i], s[i+j], s[i+2*j]}) == 3:
cnt += 1
j += 1
print(r*g*b-cnt) | n = int(input())
print((n+2-1)//2)
| 0 | null | 47,682,766,334,630 | 175 | 206 |
s = input()
print('Yes' if (s[2] == s[3]) and (s[4] == s[5]) else 'No')
| # coding : utf-8
lst = []
while True:
h, w = map(int, input().split())
lst.append([h, w])
if h == 0 and w == 0:
break
for l in lst:
H = l[0]
W = l[1]
for i in range(H):
for j in range(W):
if (i + j) % 2 == 0:
print ('#', end = '')
else:
print ('.', end = '')
print ('')
if i == H-1:
print ('')
| 0 | null | 21,545,109,140,440 | 184 | 51 |
n=int(input())
li=list(map(int,input().split()))
dic={}
ans=0
for i in range(n):
val=dic.get(li[i],-1)
if val==-1:
dic[li[i]]=1
else:
dic[li[i]]=val+1
ans+=li[i]
q=int(input())
for i in range(q):
a,b=map(int,input().split())
val=dic.get(a,-1)
if val==-1 or val==0:
print(ans)
else:
nb=dic.get(b,-1)
if nb==-1:
dic[b]=val
else:
dic[b]=val+nb
ans+=(b-a)*val
dic[a]=0
print(ans)
| import numpy as np
from collections import defaultdict
N = int(input())
A = tuple(map(int, input().split()))
Q = int(input())
BC= [list(map(int,input().split())) for _ in range(Q)]
counter = defaultdict(int)
for x in A:
counter[x] += 1
total = sum(A)
for b, c in BC:
total += (c - b) * counter[b]
counter[c] += counter[b]
counter[b] = 0
print(total)
| 1 | 12,159,802,119,652 | null | 122 | 122 |
from collections import deque
import sys
def bfs(graph, N, start):
visited = [0] * N
visited[start] = 1
que = deque([start])
while que:
node = que.popleft()
for n in graph[node]:
if not visited[n]:
visited[n] = node + 1
que.append(n)
return visited
input = sys.stdin.readline
def main():
N, M = map(int, input().split())
graph = [[] for _ in range(N)]
for i in range(M):
A, B = map(lambda n: int(n) - 1, input().split())
graph[A].append(B)
graph[B].append(A)
visited = bfs(graph, N, 0)[1:]
if all(visited):
print("Yes")
print(*visited, sep="\n")
else:
print("No")
main() | # import math
# import statistics
a=int(input())
#b,c=int(input()),int(input())
# c=[]
# for i in a:
# c.append(i)
# e1,e2 = map(int,input().split())
f = list(map(int,input().split()))
#g = [input() for _ in range(a)]
f.sort()
count=1
ans=[0 for i in range(a)]
for i in range(len(f)-1):
if f[i]==f[i+1]:
count+=1
else:
ans[f[i]-1]=count
count=1
if count>=1:
ans[f[-1]-1]=count
for i in ans:
print(i) | 0 | null | 26,446,524,059,140 | 145 | 169 |
def main():
x, n = map(int, input().split())
arr = set(list(map(int, input().split())))
for d in range(0, 1000):
for m in range(-1, 2, 2):
y = x + m * d
if y not in arr:
print(y)
return
main() | N = int(input())
C = input()
T = 'R' * C.count('R') + 'W' * C.count('W')
ans = sum([1 for a, b in zip(C, T) if a != b]) // 2
print(ans) | 0 | null | 10,254,049,566,670 | 128 | 98 |
import sys
N = int(input())
A = tuple(map(int, input().split()))
count = [0] * (10 ** 5 + 1)
for a in A:
count[a] += 1
s = sum(A)
Q = int(input())
for _ in range(Q):
b, c = map(int, sys.stdin.readline().split())
s -= count[b] * b
s += count[b] * c
count[c] += count[b]
count[b] = 0
print(s) | n = int(input())
li_a = list(map(int, input().split()))
dic_a = {}
for a in li_a:
dic_a[a] = dic_a.get(a, 0) + 1
q = int(input())
li_bc = list()
for i in range(q):
li_bc.append(tuple(map(int, input().split())))
answer = sum(li_a)
for l in li_bc:
b = l[0]
c = l[1]
diff = (c - b) * dic_a.get(b, 0)
if b in dic_a.keys():
dic_a[c] = dic_a.get(c, 0) + dic_a.get(b, 0)
dic_a[b] = 0
answer += diff
else:
pass
print(answer)
| 1 | 12,206,306,809,980 | null | 122 | 122 |
N=int(input())
s=input()
A=[]
for i in range(N):
A.append(s[i])
cntW=0
for i in range(N):
if A[i]=="W":
cntW+=1
cntR=N-cntW
changeW=0
changeR=0
for i in range(cntR):
if A[i]=="W":
changeW+=1
for i in range(cntR,N):
if A[i]=="R":
changeR+=1
if changeR==changeW:
ans=changeW
else:
#minN=min(changeW,changeR)
maxN=max(changeR,changeW)
ans=maxN
print(ans) | n = int(input())
c = input()
cntR = c.count('R')
print(c[:cntR].count('W')) | 1 | 6,233,229,129,942 | null | 98 | 98 |
s = input() * 2
p = input()
if s.find(p) == -1:
print('No')
else:
print('Yes') | def search(pat, s):
"""find a pattern 'pat' in a ring shaped text 's'
len(s) >= len(p) and both s and p consists of lowercase characters.
>>> search('a', 'a')
True
>>> search('advance', 'vanceknowledgetoad')
True
>>> search('advanced', 'vanceknowledgetoad')
False
"""
return pat in s + s
def run():
s1 = input()
s2 = input()
if search(s2, s1):
print("Yes")
else:
print("No")
if __name__ == '__main__':
run()
| 1 | 1,734,704,112,502 | null | 64 | 64 |
def roll(l, command):
'''
return rolled list
l : string list
command: string
'''
res = []
i = -1
if command =='N':
res = [l[i+2], l[i+6], l[i+3], l[i+4], l[i+1], l[i+5]]
if command =='S':
res = [l[i+5], l[i+1], l[i+3], l[i+4], l[i+6], l[i+2]]
if command =='E':
res = [l[i+4], l[i+2], l[i+1], l[i+6], l[i+5], l[i+3]]
if command =='W':
res = [l[i+3], l[i+2], l[i+6], l[i+1], l[i+5], l[i+4]]
return res
faces = input().split()
commands = list(input())
for command in commands:
faces = roll(faces, command)
print(faces[0])
| class dice:
directions = ['S', 'E', 'N', 'W']
def __init__(self, strlabels):
label = strlabels.split()
self.top = label[0]
self.side = label[1:5]
self.side[2], self.side[3] = self.side[3], self.side[2]
self.down = label[5]
#print(self.top, self.side, self.down)
def roll(self, direction):
tmp = self.top
self.top = self.side[(self.directions.index(direction)+2)%4]
self.side[(self.directions.index(direction)+2)%4] = self.down
self.down = self.side[self.directions.index(direction)]
self.side[self.directions.index(direction)] = tmp
#print(self.top, self.side, self.down)
def pFace(self, initial):
if initial == 'u':
print(self.top)
elif initial == 'd':
print(self.down)
else:
print(self.side[directions.index(direction)])
dice1 = dice(input())
for direction in input():
dice1.roll(direction)
dice1.pFace('u') | 1 | 232,293,190,780 | null | 33 | 33 |
N=int(input())
f=0
for i in range(N):
a,b=map(int,input().split())
if a==b:
f+=1
else:
f=0
if f==3:
print('Yes')
break
else:
print('No') | n,k=[int(s) for s in input().split()]
h=[int(s) for s in input().split()]
count=0
for i in h:
if i>=k:
count+=1
print(count)
# a.append(
#a.append(23)
#for
#print(*range(x-k+1,x+k)) | 0 | null | 90,647,390,698,252 | 72 | 298 |
sum = 0
num = [0] * (10 ** 5 + 1)
N = int(input())
A = [int(a) for a in input().split()]
for i in range(0, N):
sum += A[i]
num[A[i]] += 1
Q = int(input())
for i in range(0, Q):
B, C = (int(x) for x in input().split())
sum += (C - B) * num[B]
num[C] += num[B]
num[B] = 0
print(sum) | from math import ceil,floor,factorial,gcd,sqrt,log2,cos,sin,tan,acos,asin,atan,degrees,radians,pi,inf,comb
from itertools import accumulate,groupby,permutations,combinations,product,combinations_with_replacement
from collections import deque,defaultdict,Counter
from bisect import bisect_left,bisect_right
from operator import itemgetter
from heapq import heapify,heappop,heappush
from queue import Queue,LifoQueue,PriorityQueue
from copy import deepcopy
from time import time
from functools import reduce
import string
import sys
sys.setrecursionlimit(10 ** 7)
def input() : return sys.stdin.readline().strip()
def INT() : return int(input())
def MAP() : return map(int,input().split())
def LIST() : return list(MAP())
n = INT()
a = LIST()
q = INT()
count = [0]*(10**5+1)
for x in a:
count[x] += 1
ans = 0
for i in range(10**5+1):
ans += i * count[i]
for i in range(q):
b, c = MAP()
ans += (c - b) * count[b]
count[c] += count[b]
count[b] = 0
print(ans) | 1 | 12,125,934,549,758 | null | 122 | 122 |
X = int(input())
h = (X // 500) * 1000
X = X % 500
h += (X // 5) * 5
print(h)
| n, m, l = map(int, input().split())
A = []
B = []
C = [[] for i in range(n)]
for i in range(n):
tmp_row = list(map(int, input().split()))
A.append(tmp_row)
for i in range(m):
tmp_row = list(map(int, input().split()))
B.append(tmp_row)
for i in range(n):
for bj in zip(*B):
c = sum(aik * bjk for aik, bjk in zip(A[i], bj))
C[i].append(c)
for i in C:
print(*i) | 0 | null | 22,058,539,177,250 | 185 | 60 |
n, k = map(int,input().split())
a = list(map(int, input().split()))
flg = [True] * n
dst = [1]
twn = 0
for _ in range(k):
if flg[twn]:
dst.append(a[twn])
flg[twn] = False
twn = a[twn] - 1
else:
index = dst.index(a[twn])
ld = len(dst[:index])
cyc = len(dst[index:])
print(dst[(ld - 1) + (k + 1 - ld) % cyc] if (k + 1 - ld) % cyc != 0 else dst[-1])
exit()
print(dst[-1]) | import sys
def input(): return sys.stdin.readline().strip()
def main():
N, T = map(int, input().split())
cv = [tuple(map(int, input().split())) for _ in range(N)]
cv = sorted(cv, key=lambda x : x[0])
dp = [[0]*(T+1) for _ in range(N+1)]
dp_ext = [[0]*(T+1) for _ in range(N+1)]
values = [v for c, v in cv]
max_values = [max(values[i:]) for i in range(N)]
# 貰うdp
for i in range(N):
cost, value = cv[i]
for now in range(cost, T+1):
old = now - cost
dp[i+1][now] = max(dp[i][now], dp[i][old] + value)
for j in range(1, T+1):
dp[i+1][j] = max(dp[i+1][j], dp[i+1][j-1])
for j in range(1, T+1):
dp_ext[i+1][j] = max(dp[i+1][j], dp[i][j-1] + max_values[i], dp_ext[i][j])
print(dp_ext[N][T])
if __name__ == "__main__":
main() | 0 | null | 87,009,106,202,810 | 150 | 282 |
s,t = map(str, input().split())
a,b = map(int, input().split())
u = input()
print(a-1 if s==u else a, b if s==u else b-1) | n, m = map(int, input().split())
a = list (map(int, input().split()))
b = sum(a)
if n >= b:
print( n - b )
if n < b:
print( -1 ) | 0 | null | 51,957,158,524,060 | 220 | 168 |
x = int(input())
print('Yes' if x>= 30 else 'No')
| X = input()
X = int(X)
if X < -40 or X > 40:
print("invalid number 'X'")
elif X >= 30:
print("Yes")
else:
print("No")
| 1 | 5,773,388,934,728 | null | 95 | 95 |
n , k = map(int,input().split())
a = list(map(int,input().split()))
f = list(map(int,input().split()))
a.sort()
f.sort(reverse=True)
lef = -1
rig = 10**13
while rig - lef != 1:
now = (rig + lef) //2
cou = 0
for i in range(n):
t = now // f[i]
cou += max(0,a[i]-t)
if cou <= k:
rig = now
elif cou > k:
lef = now
print(rig) | N, K = map(int, input().split())
*A, = map(int, input().split())
*F, = map(int, input().split())
A, F = sorted(A), sorted(F, reverse=True)
def cond(x):
k = 0
for a, f in zip(A, F): k += max(a - (x // f), 0)
return True if k <= K else False
MIN = -1
MAX = 10**12 + 1
left, right = MIN, MAX # search range
while right - left > 1:
mid = (left + right) // 2
if cond(mid): right = mid
else: left = mid
print(right) | 1 | 164,750,785,300,790 | null | 290 | 290 |
x = int(input())
if 400 <= x <= 599:
print(8)
if 600 <= x <= 799:
print(7)
if 800 <= x <= 999:
print(6)
if 1000 <= x <= 1199:
print(5)
if 1200 <= x <= 1399:
print(4)
if 1400 <= x <= 1599:
print(3)
if 1600 <= x <= 1799:
print(2)
if 1800 <= x <= 1999:
print(1) | x = int(input())
y = x - 400
print(8 - y//200) | 1 | 6,712,661,854,232 | null | 100 | 100 |
while True:
h, w = map(int, input().split())
if(w == h == 0): break
for i in range(h):
for j in range(w):
if i == 0 or i == h - 1:
print('#', end = '')
else:
if j == 0 or j == w - 1:
print('#', end = '')
else:
print('.', end = '')
print('')
print('')
| while True:
H, W = list(map(int, input().split()))
if H == 0 and W == 0:
break
else:
for i in range(H):
if i == 0 or i == (H-1):
print('#'*W)
else:
print('#'+'.'*(W-2)+'#')
print() | 1 | 823,030,052,032 | null | 50 | 50 |
import sys
input = sys.stdin.readline
N = int(input())
AB = [[int(i) for i in input().split()] for _ in range(N)]
AB.sort()
ans = 0
if N & 1:
l = AB[N//2][0]
AB.sort(key=lambda x: x[1])
ans = AB[N // 2][1] - l + 1
else:
l = (AB[N // 2][0], AB[N // 2 - 1][0])
AB.sort(key=lambda x: x[1])
r = (AB[N // 2][1], AB[N // 2 - 1][1])
ans = sum(r) - sum(l) + 1
print(ans) | n = int(input())
ans = 'No'
for i in range(1,10):
for j in range(i,10):
if i*j == n:
ans = 'Yes'
print(ans) | 0 | null | 88,382,283,869,828 | 137 | 287 |
N=int(input())
S,T=map(str,input().split())
l=[]
a,b=0,0
for i in range(N*2):
if (i+1)%2!=0:
l.append(S[a])
a+=1
else:
l.append(T[b])
b+=1
print(''.join(l)) | N=int(input())
S,T=input().split()
for i in range(N):
print(S[i],T[i],sep='',end='')
print()
| 1 | 112,056,306,144,420 | null | 255 | 255 |
import math
N = int(input())
max_D = int(2 + math.sqrt(N))
count = []
ans = 1
for i in range(2, max_D):
if N % i == 0:
count.append(0)
while N % i == 0:
N = N // i
count[-1] += 1
if N < i:
ans = 0
break
l = len(count)
for i in range(l):
E = 2*count[i]
j = 0
while j * (j + 1) <= E:
j += 1
ans += j - 1
print(ans) | N = int(input())
n = min(N, 10**6)
is_Prime = [True] * (n + 1)
is_Prime[0] = False
is_Prime[1] = False
for i in range(2, int(n**(1/2)+1)):
for j in range(2*i, n+1, i):
if j % i == 0:
is_Prime[j] = False
P = [i for i in range(n+1) if is_Prime[i]]
count = 0
for p in P:
count_p = 0
while N % p == 0:
count_p += 1
N /= p
count += int((-1+(1+8*count_p)**(1/2))/2)
if p == P[-1] and N != 1:
count += 1
print(count) | 1 | 16,935,993,071,960 | null | 136 | 136 |
A = int(input())
B = int(input())
for i in range(1, 4):
if i in [A, B]:
continue
else:
print(i)
break | def main():
A = int(input())
B = int(input())
ans = 6 - A - B
print(ans)
if __name__ == "__main__":
main()
| 1 | 110,800,749,998,972 | null | 254 | 254 |
A, B, m = map(int, input().split())
a = list(map(int, input().split()))
b = list(map(int, input().split()))
ans = min(a) + min(b)
for _ in range(m):
x, y, c = map(int, input().split())
x -= 1
y -= 1
ans = min(ans, a[x] + b[y] - c)
print(ans)
| A,B,M=map(int,input().split())
a=list(map(int,input().split()))
b=list(map(int,input().split()))
D=[]
for i in range(M):
D.append(list(map(int,input().split())))
S=min(a)+min(b)
P=[]
for i in range(M):
P.append(a[D[i][0]-1]+b[D[i][1]-1]-D[i][2])
P.append(S)
print(min(P)) | 1 | 53,865,332,844,950 | null | 200 | 200 |
print((lambda x : x**3)(int(input()))) | A,B,C = list(map(int,input().split(" ")))
print(C,A,B) | 0 | null | 19,005,818,207,840 | 35 | 178 |
def setFact(n, mod):
global fact
global ifact
fact = [0]*(n+1)
fact[0] = 1
ifact = [0] * (n+1)
for i in range(1, n+1):
fact[i] = (fact[i-1]*i)%mod
ifact[n] = pow(fact[n], mod-2, mod)
for i in range(1, n+1):
ifact[n-i] = ifact[n-i+1]*(n-i+1)%mod
def combination(n, k, mod):
global fact
global ifact
if k < 0 or k > n:
return 0
else:
return fact[n]*ifact[n-k]*ifact[k]%mod
k = int(input())
s = input()
n = len(s)
mod = 10**9 + 7
ans = 0
setFact(n+k, mod)
for i in range(k+1):
now = 1
now *= pow(26, i, mod)
now %= mod
now *= pow(25, k-i, mod)
now %= mod
now *= combination(k-i+n-1,n-1 , mod)
now %= mod
ans += now
ans %= mod
print(ans) | class cmbs(object):
def __init__(self, mod):
self.mod = mod
self.g1 = [1, 1]
self.g2 = [1, 1]
inverse = [0, 1]
for i in range(2, 2 * (10 ** 6) + 1):
self.g1.append((self.g1[-1] * i) % mod)
inverse.append((-inverse[mod % i] * (mod // i)) % mod)
self.g2.append((self.g2[-1] * inverse[-1]) % mod)
def cmb(self, n, r):
if n > 2 * (10 ** 6):
return self.cmbl(n, r)
return self.cmbr(n, r)
def cmbr(self, n, r):
if r < 0 or r > n:
return 0
r = min(r, n - r)
return self.g1[n] * self.g2[r] * self.g2[n-r] % self.mod
def cmbl(self, n, r):
t = 1
r = min(r, n-r)
for i in range(n - r + 1, n + 1):
t = t * i % self.mod
return t * self.g2[r] % self.mod
def main():
K = int(input())
S = input()
l = len(S)
mod = 10**9 + 7
c = cmbs(mod)
r = 0
x25 = 1
x26 = pow(26, K, mod)
inv26 = pow(26, mod-2, mod)
for i in range(K+1):
r = (r + c.cmb(l+i-1, i) * x25 * x26) % mod
x25 = x25 * 25 % mod
x26 = x26 * inv26 % mod
return r % mod
print(main())
| 1 | 12,834,735,104,740 | null | 124 | 124 |
# coding: utf-8
from math import sqrt
def isPrime(n):
if n == 2:
return True
elif n < 2 or n % 2 == 0:
return False
else:
i = 3
while i <= sqrt(n):
if n % i == 0:
return False
i += 2
return True
def main():
n = input()
print sum([1 if isPrime(x) else 0 for x in [input() for _ in xrange(n)]])
if __name__ == '__main__':
main() | N,M=map(int ,input().split())
A=input().split()
s=0
for i in range(M):
s+=int(A[i])
ans=N-s
if ans>=0:
print(ans)
else:
print("-1") | 0 | null | 15,877,029,470,012 | 12 | 168 |
#!/usr/bin/env python3
from itertools import count, takewhile
def prime():
prime = []
def _isPrime(n):
for d in takewhile(lambda x: x * x <= n, prime):
if n % d == 0:
return False
return True
for i in count(2):
if _isPrime(i):
prime.append(i)
yield(i)
def is_prime(primes, i):
for p in takewhile(lambda x: x * x <= i, sorted(primes)):
if i % p == 0:
return False
return True
primes = list(takewhile(lambda x: x < 10000, prime()))
n = int(input())
c = 0
for _ in range(n):
i = int(input())
if is_prime(primes, i):
c += 1
print(c) | import math
def isPrime(x):
if(x == 1 ):
return False
n = int(math.sqrt(x))
for i in range(2,n+1):
if(x % i == 0):
return False
return True
n = int(input())
dataset = []
while (n > 0):
dataset.append(int(input()))
n -=1
prime_number = 0
for x in dataset:
if(isPrime(x)):
prime_number += 1
print(prime_number) | 1 | 9,694,280,160 | null | 12 | 12 |
n, m = (int(i) for i in input().split())
tot = sum(int(i) for i in input().split())
if tot > n:
print(-1)
else:
print(n - tot)
| import sys
read = sys.stdin.read
readlines = sys.stdin.readlines
def main():
n, m, *a = map(int, read().split())
suma = sum(a)
if n < suma:
print(-1)
else:
print(n - suma)
if __name__ == '__main__':
main()
| 1 | 31,865,251,459,742 | null | 168 | 168 |
# from sys import stdin
# input = stdin.readline
from collections import Counter
MOD = 10**9 + 7
MAX = 2000001
def solve():
k = int(input())
s = input().strip()
ns = len(s)
res = 0
fac = [1,1] + [0] * MAX
inv = [1,1] + [0] * MAX
for i in range(2,MAX+1):
fac[i] = fac[i-1] * i % MOD
inv[MAX] = pow(fac[MAX],MOD-2,MOD)
for i in range(MAX-1,1,-1):
inv[i] = inv[i+1]*(i+1)%MOD
def c(a,b):
return fac[b]*inv[a]*inv[b-a] % MOD
for left in range(0,k+1):
right = k - left
temp = pow(25,left,MOD) * pow(26,right,MOD)
temp *= c(ns - 1, left + ns -1)
temp %= MOD
res += temp
res %= MOD
print(res)
if __name__ == '__main__':
solve()
| MOD = 10**9+7
k = int(input())
s = input()
n = len(s)
U = n+k
fact = [0]*(U+1)
fact[0] = 1
for i in range(1, U+1):
fact[i] = fact[i-1]*i % MOD
invfact = [0]*(U+1)
invfact[U] = pow(fact[U], MOD-2, MOD)
for i in reversed(range(U)):
invfact[i] = invfact[i+1]*(i+1) % MOD
def nCr(n, r):
if r < 0 or n < r:
return 0
return fact[n]*invfact[r]*invfact[n-r]
ans = 0
for x in range(k+1):
ans += pow(26, x, MOD)*nCr(n+k-x-1, n-1)*pow(25, k-x, MOD)
ans %= MOD
print(ans) | 1 | 12,830,602,846,130 | null | 124 | 124 |
def main():
from bisect import bisect_left as bl
from itertools import accumulate as ac
n, m = map(int, input().split())
a = list(map(int, input().split()))
a.sort()
aa = [0]+list(ac(a))
an = aa[n]
ok = 0
ng = 10**10
while abs(ok-ng) > 1:
mid = (ok+ng)//2
if sum([n-bl(a, mid-a[i]) for i in range(n)]) >= m:
ok = mid
else:
ng = mid
c = -m+sum([n-bl(a, ok-a[i]) for i in range(n)])
ans = -c*ok
for i in range(n):
d = bl(a, ok-a[i])
ans += an-aa[d]+(n-d)*a[i]
print(ans)
main() | a,b,c = map(int,raw_input().split())
count = 0
if a == b :
if c % a == 0:
count += 1
else:
for i in range(a,b+1):
if c % i == 0:
count += 1
print count | 0 | null | 54,028,120,637,742 | 252 | 44 |
from collections import deque
import sys
n = int(sys.stdin.readline())
#lines = sys.stdin.readlines()
lines = [input() for i in range(n)]
deq = deque()
for i in range(n):
o = lines[i].split()
if o[0] == 'insert':
deq.appendleft(o[1])
elif o[0] == 'delete':
try:
deq.remove(o[1])
except:
continue
elif o[0] == 'deleteFirst':
deq.popleft()
elif o[0] == 'deleteLast':
deq.pop()
print(' '.join(deq))
| from sys import stdin
class Node:
def __init__(self, value: int):
self.value = value
self.previous_node = None
self.next_node = None
class LinkedList():
def __init__(self):
self.first = None
self.last = None
def delete_node(self, node: Node):
if node.next_node != None:
node.next_node.previous_node = node.previous_node
if node.previous_node != None:
node.previous_node.next_node = node.next_node
if node == self.first:
self.first = node.next_node
if node == self.last:
self.last = node.previous_node
def value_generator(self):
node = self.first
while node != None:
yield node.value
node = node.next_node
def insert(self, x: int):
node = Node(x)
node.next_node = self.first
if self.first != None:
self.first.previous_node = node
self.first = node
if self.last == None:
self.last = node
def delete(self, x: int):
target_node = self.first
while target_node != None and target_node.value != x:
target_node = target_node.next_node
if target_node != None:
self.delete_node(target_node)
def main():
linked_list = LinkedList()
insert,delete,delete_node = linked_list.insert,linked_list.delete,linked_list.delete_node
_ = int(stdin.readline())
for line in (line.split() for line in stdin.readlines()):
command = line[0]
if command == "insert":
insert(int(line[1]))
elif command == "delete":
delete(int(line[1]))
elif command == "deleteFirst":
delete_node(linked_list.first)
elif command == "deleteLast":
delete_node(linked_list.last)
print(*linked_list.value_generator())
main()
| 1 | 52,378,713,550 | null | 20 | 20 |
N = int(input()) - 1
rst = ''
for i in range(1, 10 ** 15):
if N >= 26 ** i:
N -= 26 ** i
continue
for j in range(i):
rst += chr(ord('a') + N % 26)
N //= 26
print(rst[::-1])
break | # import sys
# sys.setrecursionlimit(10 ** 6)
# import bisect
# from collections import deque
# from decorator import stop_watch
#
#
# @stop_watch
def solve(N):
alp = 'abcdefghijklmnopqrstuvwxyz'
number27 = []
cnt = 26
digit = 1
while N > 0:
if N <= cnt:
break
else:
N -= cnt
cnt *= 26
digit += 1
ans = list('a' * digit)
N -= 1
tmp = -1
while N > 0:
N, mod = divmod(N, 26)
ans[tmp] = alp[mod]
tmp -= 1
print(''.join(ans))
if __name__ == '__main__':
# S = input()
N = int(input())
# N, M = map(int, input().split())
# As = [int(i) for i in input().split()]
# Bs = [int(i) for i in input().split()]
solve(N)
# for i in range(1, 100):
# # print(i)
# solve(i)
| 1 | 11,882,209,318,430 | null | 121 | 121 |
import math
import numpy as np
n,k=(int(x) for x in input().split())
a = [int(x) for x in input().split()]
for _ in range(k):
new_a = np.zeros(n+1,dtype=int)
np.add.at(new_a, np.maximum(0,np.arange(0, n)-a), 1)
np.add.at(new_a, np.minimum(n,np.arange(0, n)+a+1), -1)
a = new_a.cumsum()[:-1]
if np.all(a==n):
break
print(" ".join([str(x) for x in a])) | N = int(input())
A = list(map(int, input().split()))
m = 1000
k = 0
for i in range(N-1):
if A[i] > A[i+1]:
m += k * A[i]
k = 0
elif A[i] < A[i+1]:
m += k * A[i]
k = m // A[i]
m -= k * A[i]
else:
pass
m += (k * A[-1])
print(m)
| 0 | null | 11,375,285,853,372 | 132 | 103 |
mod=10**9+7
n,k=map(int,input().split())
cnt=[0]*k
for i in range(k,0,-1):
cnt[i-1]=pow(k//i,n,mod)
for j in range(i*2,k+1,i):
cnt[i-1]-=cnt[j-1]
cnt[i-1]%=mod
ans=0
for i in range(k):
ans+=cnt[i]*(i+1)%mod
print(ans%mod) | def f(x):
return sum([(i-1)//x for i in a])<=k
def main():
l,r=0,10**9
while r-l>1:
m=(l+r)//2
if f(m): r=m;
else: l=m;
print(r)
if __name__=='__main__':
n,k=map(int,input().split())
a=list(map(int,input().split()))
main() | 0 | null | 21,496,557,162,652 | 176 | 99 |
S = input()
list = []
for i in S:
list.append(i)
if list[2]==list[3] and list[4]==list[5]:
print("Yes")
else:
print("No") | s = input()
n = []
for i in s:
n.append(i)
if n[2] == n[3] and n[4] == n[5]:
print('Yes')
else:
print('No') | 1 | 42,008,336,521,878 | null | 184 | 184 |
s = [x for x in input()]
t = [y for y in input()]
count = 0
for _ in range(len(s)):
if s[_] != t[_]:
count+=1
print(count) | n = int(input())
s = list(input())
c = 0
for i in range(1000) :
num_1 = i // 100
num_2 = (i - num_1*100) // 10
num_3 = (i - num_1*100 - num_2*10) % 100
if str(num_1) not in s :
continue
if str(num_2) not in s :
continue
if str(num_3) not in s :
continue
for j in range(n-2) :
if int(s[j]) == num_1 :
for k in range(j+1,n-1) :
if int(s[k]) == num_2 :
for l in range(k+1,n) :
if int(s[l]) == num_3 :
c += 1
break
break
break
print(c)
| 0 | null | 69,490,476,438,652 | 116 | 267 |
N = int(input())
alpha = [chr(ord("a") + i) for i in range(26)]
def dfs(n, s):
if len(s) == n:
print(s)
return
cnt = len(set(s))
cnt += 1
for a in alpha[:cnt]:
ns = s + a
dfs(n, ns)
dfs(N, "")
| # import sys
# sys.setrecursionlimit(10 ** 6)
# import bisect
# from collections import deque
# from decorator import stop_watch
#
#
# @stop_watch
def solve(N, As):
ans = 0
i = 1
for A in As:
if A == i:
i += 1
else:
ans += 1
ans = -1 if ans == N else ans
print(ans)
if __name__ == '__main__':
# S = input()
N = int(input())
# N, M = map(int, input().split())
As = [int(i) for i in input().split()]
# Bs = [int(i) for i in input().split()]
solve(N, As)
| 0 | null | 83,192,761,909,792 | 198 | 257 |
from fractions import gcd
def lcm(*args):
ans = 1
for x in args:
ans = ans * x // gcd(ans, x)
return ans
n, m = map(int, input().split())
a = [int(x) for x in input().split()]
def log(x):
ans = 0
while x % 2 == 0:
ans += 1
x //= 2
return ans
def solve(a):
tmp = None
for ta in a:
if tmp is None:
tmp = log(ta)
else:
if tmp == log(ta):
continue
else:
print(0)
return
l = lcm(*a)
print(m // (l//2) - m // l)
solve(a) | N, M = map(int, input().split())
A = list(set(map(lambda x : int(x)//2, input().split())))
def _gcd(a, b):
return a if b == 0 else _gcd(b, a%b)
def _lcm(a,b):
return (a*b) // _gcd(a,b)
lcm = A[0]
for ai in A[1:]:
lcm = _lcm(lcm, ai)
ret = (M//lcm + 1)//2
for ai in A[1:]:
if (lcm // ai) % 2 == 0:
ret = 0
break
print(ret)
| 1 | 101,915,084,588,532 | null | 247 | 247 |
inp=input()
num = [int(x) for x in inp.split(" ")]
print(num[0]*num[1]) | n = int(raw_input())
dp = [1, 1]
for i in range(50):
dp += [dp[-1] + dp[-2]]
print dp[n]
| 0 | null | 7,936,408,187,824 | 133 | 7 |
x,y = map(int,input().split())
if y % 2 != 0:
print('No')
elif x * 2 <= y <= x * 4:
print('Yes')
else:
print('No') | X, Y = list(map(int, input().split()))
judge = 0
for a in range(X + 1):
if (Y - a*2 - (X-a)*4 ) == 0:
print("Yes")
judge = 1
break
if judge == 0:
print("No") | 1 | 13,676,996,622,690 | null | 127 | 127 |
x = int(input())
y = x - 400
print(8 - y//200) | while True:
H, W = map(int, input().split())
if H == 0 and W == 0:
break
for i in range(H):
if i % 2 == 0:
print("#."*(W//2)+"#"*(W%2))
else:
print(".#"*(W//2)+"."*(W%2))
print() | 0 | null | 3,849,818,191,880 | 100 | 51 |
#!/usr/bin/env python
# -*- coding: utf-8 -*-
def print_array(a):
print(" ".join(map(str, a)))
def bubblesort(a, n):
swap = 0
flag = True
while flag:
flag = False
for j in range(n - 1, 0, -1):
if a[j] < a[j - 1]:
(a[j], a[j - 1]) = (a[j - 1], a[j])
swap += 1
flag = True
return (a, swap)
def main():
n = int(input())
a = list(map(int, input().split()))
(b, swap) = bubblesort(a, n)
print_array(b)
print(swap)
if __name__ == "__main__":
main() | # -*- coding:utf-8 -*-
def bubble_sort(num_list):
swap_count = 0
for i in range(len(num_list)):
for j in range(len(num_list)-1, i , -1):
if num_list[j] < num_list[j-1]:
num_list[j], num_list[j-1] = num_list[j-1], num_list[j]
swap_count = swap_count + 1
return num_list, swap_count
def show_list(list):
i = 0;
while(i < len(list)-1):
print(list[i], end=" ")
i = i + 1
print(list[i])
num = int(input())
num_list = [int(x) for i, x in enumerate(input().split()) if i < num]
num_list, swap_count = bubble_sort(num_list)
show_list(num_list)
print(swap_count) | 1 | 17,831,569,184 | null | 14 | 14 |
n, m = map(int, input().split())
*A, = map(int, input().split())
A.sort()
# Aの累積和を求めておく
S = [0]
x = 0
for a in A:
x += a
S.append(x)
def lower(x):
# A[i]<xなるiの個数
left = -1
right = n
while right-left > 1:
mid = (left+right)//2
if A[mid] < x:
left = mid
else:
right = mid
return right
def lower_pair(x):
# A[i]+A[j]<xなる(i,j)の個数
cnt = 0
for a in A:
cnt += lower(x-a)
return cnt
# A[i]+A[j]のm番目に大きい値を求める
# lower_pair(x)<n**2-mなる最大のxを求めればよい
left = 2*min(A)
right = 2*max(A)
while right-left > 1:
mid = (left+right)//2
if lower_pair(mid) < n**2-m:
left = mid
else:
right = mid
x = left
# A[i]+A[j]>=xとなる(i,j)の個数とA[i]+A[j]の総和を求める
k = n**2-lower_pair(x)
s = 0
for a in A:
cnt = lower(x-a)
s += (n-cnt)*a+S[n]-S[cnt]
print(s-(k-m)*x)
| a,b = (input().split())
print(int(a)*int(b)) | 0 | null | 62,314,505,686,810 | 252 | 133 |
import collections
# 素因数分解の結果を返す
def prime_factorize(n):
a = []
while n % 2 == 0:
a.append(2)
n //= 2
f = 3
while f * f <= n:
if n % f == 0:
a.append(f)
n //= f
else:
f += 2
if n != 1:
a.append(n)
return a
N = int(input())
res = collections.Counter(prime_factorize(N)) # Counter({2: 4, 3: 1})
keys = list(res.keys()) # [2, 3]
length = len(keys)
ans = 0
# 因数に関する処理
for i in range(length):
num = keys[i] # 因数
beki = res[num] # 因数numの個数
temp = 1
while(beki >= temp):
beki -= temp
ans += 1
temp += 1
print(ans) | import math
Max = 1000001
prime = Max*[1]
def sieve():
prime[0] = 0
prime[1] = 0
for i in range(2,Max):
if prime[i]==1:
j = 2*i
while j < Max:
prime[j] = 0
j += i
def Howmany(x):
res = 1
while x>=res:
x -= res
res += 1
return res-1
N = int(input())
sieve()
ans = 0
R = int(math.sqrt(N))
for i in range(2, R):
if prime[i]==1 and N%i==0:
cnt = 0
while N%i==0:
N //= i
cnt+=1
ans += Howmany(cnt)
if N!=1:
ans += 1
print(ans)
| 1 | 16,786,570,097,330 | null | 136 | 136 |
import sys
read = sys.stdin.buffer.read
readline = sys.stdin.buffer.readline
readlines = sys.stdin.buffer.readlines
import numpy as np
from numba import njit
MOD = 10**9 + 7
N = int(readline())
S = np.array(list(read().rstrip()), np.int8)
R = np.sum(S == ord('R'))
B = np.sum(S == ord('B'))
G = np.sum(S == ord('G'))
@njit
def f(S):
N = len(S)
ret = 0
for i in range(N):
for j in range(i + 1, N):
k = j + j - i
if k >= N:
break
if S[i] != S[j] and S[i] != S[k] and S[j] != S[k]:
ret += 1
return ret
answer = R * B * G - f(S)
print(answer) | n = int(input())
s = input()
sr = []
sg = []
sb = [0] * n
kcnt = 0
for i in range(n):
if s[i] == 'R':
sr.append(i)
elif s[i] == 'G':
sg.append(i)
else:
sb[i] = 1
kcnt += 1
ans = 0
for i in sr:
for j in sg:
nki = j*2 - i
nkj = i*2 - j
nkk = (j+i)
ans += kcnt
if 0<= nki < n and sb[nki] == 1:
ans -= 1
if 0<= nkj < n and sb[nkj] == 1:
ans -= 1
if nkk%2 == 0 and 0<= (nkk//2) < n and sb[nkk//2] == 1:
ans -= 1
print(ans) | 1 | 36,235,805,763,562 | null | 175 | 175 |
import math
from decimal import Decimal, ROUND_HALF_UP
def resolve():
x1, y1, x2, y2 = map(float, input().split())
a = Decimal(math.sqrt((x2 - x1) ** 2 + (y2 - y1) ** 2)).quantize(Decimal('0.0001'), rounding=ROUND_HALF_UP)
print(a)
resolve()
| n, q = map(int, raw_input().split())
A = [[0, 0] for i in range(n)]
for i in range(n):
temp = raw_input().split()
A[i][0] = temp[0]
A[i][1] = int(temp[1])
time = 0
while A != []:
if A[0][1] - q > 0:
A[0][1] = A[0][1] - q
time = time + q
A.append(A.pop(0))
else:
print A[0][0],
print time + A[0][1]
time = time + A[0][1]
A.pop(0) | 0 | null | 105,193,625,890 | 29 | 19 |
N = int(input())
arr = list(map(int, input().split()))
if N == 0:
print(1 if arr[0]==1 else -1)
exit()
elif arr[0] != 0:
print(-1)
exit()
# 末端の葉の数で初期化
sum_arr = [arr[-1]]*N
for i in range(1,N):
# 深さi+1での頂点数 + 深さiでの葉の数
sum_arr[i] = sum_arr[i-1]+arr[N-i]
# 本来の順番に反転
sum_arr = sum_arr[::-1]
# 二分木の根から見ていく
ans = [1]*(N+1)
for i in range(1,N+1):
if ans[i-1]-arr[i-1] < 0:
print(-1)
exit()
tmp = min((ans[i-1]-arr[i-1])*2,sum_arr[i-1])
ans[i] = tmp
# for i in range(min(25,N+1)):
# if ans[i] > 2**i:
# print(-1)
# exit()
if ans[N] != arr[-1]:
print(-1)
exit()
print(sum(ans))
| import math
def solve():
N = int(input())
A = list(map(int, input().split()))
if(N == 0 and A[0] == 1):
print(1)
return
leaf_list = [0] * (N+1)
for d in range(N, -1 , -1):
if(d == N):
leaf_list[d] = (A[d],A[d])
else:
Min = math.ceil(leaf_list[d+1][0]/2) + A[d]
Max = leaf_list[d+1][1] + A[d]
leaf_list[d] = (Min,Max)
if(not(leaf_list[0][0] <= 1 and leaf_list[0][1] >= 1)):
print(-1)
return
node_list = [0] * (N+1)
node_list[0] = 1
for d in range(1, N+1):
node_list[d] = min((node_list[d-1] - A[d-1]) * 2, leaf_list[d][1])
print(sum(node_list))
solve() | 1 | 18,873,789,046,200 | null | 141 | 141 |
def merge(left, mid, right):
L = S[left:mid]
R = S[mid:right]
lp, rp, xp = 0, 0, 0
a, b = L[0], R[0]
c = right - left
x = [0] * c
flg = True
while flg:
while flg and a <= b:
x[xp] = a
lp += 1
xp += 1
try:
a = L[lp]
except:
for e in R[rp:]:
x[xp] = e
xp += 1
flg = False
while flg and a >= b:
x[xp] = b
rp += 1
xp += 1
try:
b = R[rp]
except:
for e in L[lp:]:
x[xp] = e
xp += 1
flg = False
S[left:right] = x
return c
def mergesort(left, right):
c = 0
if left + 1 < right:
mid = (left + right)/2
c += mergesort(left, mid)
c += mergesort(mid, right)
c += merge(left, mid, right)
return c
global S
n = int(raw_input())
S = map(int, raw_input().split())
c = mergesort(0, n)
print " ".join(map(str,S))
print c | #!/usr/bin/env python
def solve(A: int, B: int, C: int, K: int):
if A >= K:
return K
K -= A
if B >= K:
return A
K -= B
return A - K
def main():
A, B, C, K = map(int, input().split())
answer = solve(A, B, C, K)
print(answer)
if __name__ == "__main__":
main()
| 0 | null | 10,897,307,503,092 | 26 | 148 |
class SegTree:
def __init__(self, init_val, segfunc, ide_ele):
n = len(init_val)
self.segfunc = segfunc
self.ide_ele = ide_ele
self.num = 1 << (n - 1).bit_length()
self.tree = [ide_ele] * 2 * self.num
# 配列の値を葉にセット
for i in range(n):
self.tree[self.num + i] = init_val[i]
# 構築していく
for i in range(self.num - 1, 0, -1):
self.tree[i] = self.segfunc(self.tree[2 * i], self.tree[2 * i + 1])
def update(self, k, x):
k += self.num
self.tree[k] = x
while k > 1:
self.tree[k >> 1] = self.segfunc(self.tree[k], self.tree[k ^ 1])
k >>= 1
def query(self, l, r):
res = self.ide_ele
l += self.num
r += self.num
while l < r:
if l & 1:
res = self.segfunc(res, self.tree[l])
l += 1
if r & 1:
res = self.segfunc(res, self.tree[r - 1])
l >>= 1
r >>= 1
return res
ide_ele=0
def segfunc(x,y):
return x|y
def popcount(x):
x = x - ((x >> 1) & 0x55555555)
x = (x & 0x33333333) + ((x >> 2) & 0x33333333)
x = (x + (x >> 4)) & 0x0f0f0f0f
x = x + (x >> 8)
x = x + (x >> 16)
return x & 0x0000007f
import sys
input=sys.stdin.readline
N=int(input())
S=input().rstrip()
init_val=[1<<(ord(S[i])-97) for i in range(N)]
test=SegTree(init_val,segfunc,ide_ele)
for _ in range(int(input())):
t,l,r=input().split()
t,l=int(t),int(l)
if t==1:
val=ord(r)-97
test.update(l-1,1<<val)
else:
r=int(r)
res=test.query(l-1,r)
print(popcount(res))
| import math
x_1,y_1,x_2,y_2 = map(float,input().split())
print(math.sqrt((x_1-x_2)**2+(y_1-y_2)**2))
| 0 | null | 31,543,012,855,772 | 210 | 29 |
n=int(input())
l=[0]*(n+1)
for i in range(1,101):
for j in range(1,101):
for k in range(1,101):
s=i**2+j**2+k**2+i*k+i*j+j*k
if(s<=n):
l[s]+=1
for i in range(1,n+1):
print(l[i])
| n = int(input())
ans = [0]*(n+1)
r = range(1, int(n**0.5)+1)
for x in r:
for y in r:
for z in r:
a = x**2 + y**2 + z**2 + x*y + y*z + z*x
if a<=n:
ans[a] += 1
for i in ans[1:]:
print(i) | 1 | 7,990,261,339,610 | null | 106 | 106 |
A = input()
if A[2]==A[3] and A[4]==A[5]:
print('Yes')
else:
print('No') | s = raw_input()#,k = map(int, raw_input().split(' '))
print 'Yes ' if len(s) >= 6 and s[2] == s[3] and s[4] == s[5] else 'No' #f(n,k)
| 1 | 41,805,151,394,126 | null | 184 | 184 |
from sys import stdin
h, w = [int(x) for x in stdin.readline().strip().split()]
if(h == 1 or w == 1):
print(1)
else:
print((h//2)*(w//2)+((h+1)//2)*((w+1)//2)) | n,m = map(int,input().split())
ans = 0
if n > 1:
ans += n * (n -1) / 2
if m > 1:
ans += m *(m - 1) / 2
print(int(ans)) | 0 | null | 48,345,307,836,060 | 196 | 189 |
x,y=map(int,input().split())
t=2*y-4*x
c=y-t
if t<0 or c<0 or t%4!=0 or c%2!=0:
print("No")
else:
print("Yes")
| x, y = map(int, input().split())
if y in range(x*2, x*4+1, 2):
print("Yes")
else:
print("No") | 1 | 13,864,737,678,880 | null | 127 | 127 |
import sys
input=sys.stdin.readline
import math
from collections import defaultdict,deque
from itertools import permutations
ml=lambda:map(int,input().split())
ll=lambda:list(map(int,input().split()))
ii=lambda:int(input())
ip=lambda:list(input())
ips=lambda:input().split()
"""========main code==============="""
t,k=ml()
n=ll()
ans=0
lol=0
for i in range(t):
if(i>=k):
lol+=((n[i]*(n[i]+1))//2)/n[i]
lol-=((n[i-k]*(n[i-k]+1))//2)/n[i-k]
else:
lol+=((n[i]*(n[i]+1))//2)/n[i]
ans=max(ans,lol)
print(ans) | n,k,c = list(map(int, input().split()))
s = list(input())
l = []
r = []
i = 0
while i < n and len(l) <= k:
if s[i] == "o":
l.append(i)
i += (c + 1)
else:
i += 1
i = n-1
while i >= 0 and len(r) <= k:
if s[i] == "o":
r.append(i)
i -= (c+1)
else:
i -= 1
i = 0
while i < k:
if l[i] == r[k-1-i]:
print(l[i]+1)
i += 1
| 0 | null | 57,767,498,573,892 | 223 | 182 |
N,M,K = map(int, input().split())
A = [0] + list(map(int, input().split()))
B = [0] + list(map(int, input().split()))
for i in range(1, N+1):
A[i] += A[i-1]
for i in range(1, M+1):
B[i] += B[i-1]
ans = 0
j = M
for i in range(N+1):
if A[i] > K:
break
while A[i] + B[j] > K:
j -= 1
ans = max(ans, i + j)
print(ans) | from itertools import accumulate
from bisect import bisect
n, m, k = map(int, input().split())
a = [0] + list(map(int, input().split()))
b = [0] + list(map(int, input().split()))
a = list(accumulate(a))
b = list(accumulate(b))
ans = 0
for i in range(n+1):
if a[i] > k:
break
ans = max(ans, i+bisect(b, k-a[i])-1)
print(ans) | 1 | 10,624,397,233,520 | null | 117 | 117 |
s = input()
sa = s[:len(s)//2]
if len(s)%2 == 0:
sb = s[len(s)//2:]
if len(s)%2 == 1:
sb = s[len(s)//2+1:]
sbr = sb[::-1]
cnt = 0
for i in range(len(sa)):
if sa[i] != sbr[i]:
cnt+=1
print(cnt) | S = input()
n = len(S)
c = 0
for i in range(n // 2):
if S[i] != S[n - i - 1]:
c += 1
print(c) | 1 | 119,984,924,106,948 | null | 261 | 261 |
import numpy as np
pi = np.pi
a = int(input())
print(2 * a * pi) | def Yes():
print('Yes')
exit()
def No():
print('No')
exit()
def parse(s):
ret = [0, 0]
for c in s:
if c == ')':
if ret[0]:
ret[0] -= 1
else:
ret[1] -= 1
else:
ret[0] += 1
return ret
N = int(input())
S = [parse(input()) for _ in range(N)]
S.sort(key=lambda a: -a[0] - a[1])
S1 = []
S2 = []
for s in S:
if s[0] + s[1] >= 0:
S1 += [s]
else:
S2 += [s]
S1.sort(key=lambda a: -a[1])
S2.sort(key=lambda a: -a[0])
cnt = 0
for s in S1:
cnt += s[1]
if cnt < 0:
No()
cnt += s[0]
for s in S2:
cnt += s[1]
if cnt < 0:
No()
cnt += s[0]
if cnt:
No()
Yes()
| 0 | null | 27,411,605,294,668 | 167 | 152 |
n=int(input())
s,t=input().split()
l=[]
for i in range(2*n):
if i%2==0:
l.append(s[i//2])
else:
l.append(t[(i-1)//2])
l=''.join(l)
print(l) | 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)
| 0 | null | 101,202,646,933,440 | 255 | 237 |
xyz=list(map(int,input().split()))
xyz[0],xyz[1]=xyz[1],xyz[0]
xyz[0],xyz[2]=xyz[2],xyz[0]
print(xyz[0],xyz[1],xyz[2]) | x, y, z = map(int, input().split())
print(z, end='')
print(" ", end='')
print(x, end='')
print(" ", end='')
print(y, end='') | 1 | 38,203,390,695,306 | null | 178 | 178 |
import sys
def LI(): return list(map(int, sys.stdin.buffer.readline().split()))
def I(): return int(sys.stdin.buffer.readline())
def LS(): return sys.stdin.buffer.readline().rstrip().decode('utf-8').split()
def S(): return sys.stdin.buffer.readline().rstrip().decode('utf-8')
def IR(n): return [I() for i in range(n)]
def LIR(n): return [LI() for i in range(n)]
def SR(n): return [S() for i in range(n)]
def LSR(n): return [LS() for i in range(n)]
def SRL(n): return [list(S()) for i in range(n)]
def MSRL(n): return [[int(j) for j in list(S())] for i in range(n)]
mod = 10 ** 9 + 7
k, n = LI()
a = LI()
# 一周kメートルの円形湖があり、n軒の家がある。
# i番目のいえは北端から時計回りにAメートルのところにある。
# いずれかの家から出発してn件すべての家に尋ねるための最短移動距離を求めよ
# 円形で考えるからややこしい
# 一番距離が長い家と家の区間を除外した直線状と考えればよいのでは。
far = []
for i in range(0,n):
if i == 0:
d = a[0] + k - a[-1]
else:
d = a[i] - a[i-1]
far.append(d)
longest = 0
for i in range(n):
if far[i] > longest:
longest = far[i]
longest_i = i
del far[longest_i]
print(sum(far)) | from collections import defaultdict
import math
def P(n, r):
return math.factorial(n)//math.factorial(n-r)
def C(n, r):
return P(n, r)//math.factorial(r)
S = input()[::-1]
N = len(S)
cnt = [0]*N
tmp = 0
d = defaultdict(int)
d[0] += 1
for i in range(N):
tmp += int(S[i])*pow(10,i,2019)
tmp %= 2019
d[tmp] += 1
ans = 0
for v in d.values():
if v >= 2:
ans += C(v,2)
print(ans) | 0 | null | 37,285,632,207,492 | 186 | 166 |
import bisect
def main():
n = int(input())
l = sorted(list(int(i) for i in input().split()))
cnt = 0
for i in range(n - 2):
a = l[i]
for j in range(i + 1, n-1):
b = l[j]
cnt += bisect.bisect_left(l, a+b)-(j+1)
print(cnt)
if __name__ == "__main__":
main()
| import numpy as np
a, b, x = map(int, input().split())
ans = 0
if (a*a*b/2) <= x:
ans = np.rad2deg(np.arctan((2*(a*a*b-x))/(a*a*a)))
else:
ans = np.rad2deg(np.arctan((a*b*b)/(2*x)))
print('{:.10f}'.format(ans))
| 0 | null | 167,437,590,478,508 | 294 | 289 |
n = int(input())
s = input()
if n % 2 == 1:
print('No')
exit()
n2 = n // 2
for i in range(n2):
if s[i] != s[i+n2]:
print('No')
exit()
print('Yes') | N = int(input())
S = input()
if len(S) % 2 == 0 :
for i in range(len(S)//2) :
if S[i] != S[i+len(S)//2] :
print("No")
exit()
print("Yes")
exit()
print("No") | 1 | 146,825,975,865,472 | null | 279 | 279 |
from math import ceil,floor,factorial,gcd,sqrt,log2,cos,sin,tan,acos,asin,atan,degrees,radians,pi,inf,comb
from itertools import accumulate,groupby,permutations,combinations,product,combinations_with_replacement
from collections import deque,defaultdict,Counter
from bisect import bisect_left,bisect_right
from operator import itemgetter
from heapq import heapify,heappop,heappush
from queue import Queue,LifoQueue,PriorityQueue
from copy import deepcopy
from time import time
from functools import reduce
import string
import sys
sys.setrecursionlimit(10 ** 7)
def input() : return sys.stdin.readline().strip()
def INT() : return int(input())
def MAP() : return map(int,input().split())
def LIST() : return list(MAP())
def prime_factorize(n):
a = []
while n % 2 == 0:
a.append(2)
n //= 2
f = 3
while f * f <= n:
if n % f == 0:
a.append(f)
n //= f
else:
f += 2
if n != 1:
a.append(n)
return a
n = INT()
c = Counter(prime_factorize(n))
ans = 0
for x in c.values():
ans += int(-1+sqrt(1+8*x))//2
print(ans) | import sys
input = sys.stdin.readline
INF = 1001001001
from collections import deque
def linput(ty=int, cvt=list):
return cvt(map(ty,input().split()))
def pad(mxy, wall="#"):
w = len(mxy[0])
gp = wall*(w+2)
re = [gp,]
re_app = re.append
for vx in mxy:
re_app(wall+vx+wall)
re_app(gp)
return re
vD = [(0,1),(1,0),(0,-1),(-1,0)]
vQ = deque([])
vQ_app, vQ_popl = vQ.append, vQ.popleft
def main():
H,W = linput()
mM = [input().rstrip() for _ in [0,]*H]
mM = pad(mM)
res = 0
cnt = 0
for sr in range(1,H+1):
for sc in range(1,W+1):
if mM[sr][sc]=="#":
continue
mV = [[INF,]*(W+2) for _ in [INF,]*(H+2)]
mV[sr][sc] = 0
vQ_app((sr,sc))
while vQ:
r,c = vQ_popl()
now_cost = mV[r][c]
for dr,dc in vD:
nr,nc = r+dr, c+dc
if mM[nr][nc]=="#":
continue
if now_cost + 1 < mV[nr][nc]:
vQ_app((nr,nc))
mV[nr][nc] = now_cost + 1
res = max(now_cost+1, res)
cnt += 1
#print(res,cnt,X,Y,H)
if cnt>999999: break
print(res)
if __name__ == "__main__":
main()
| 0 | null | 55,847,399,498,460 | 136 | 241 |
h, w = map(int, input().split())
mat = [[] for _ in range(h)]
for i in range(h):
mat[i] = input()
dp = [[float("inf")] * w for _ in range(h)]
if mat[0][0] == "#":
dp[0][0] = 1
else:
dp[0][0] = 0
for i in range(h):
for j in range(w):
if mat[i][j - 1] != mat[i][j]:
left = dp[i][j - 1] + 1
else:
left = dp[i][j - 1]
if mat[i - 1][j] != mat[i][j]:
top = dp[i - 1][j] + 1
else:
top = dp[i - 1][j]
dp[i][j] = min(dp[i][j], left, top)
print((dp[h - 1][w - 1] + 1) // 2) | H, W = map(int, input().split())
dp = [[H*W for __ in range(W)] for _ in range(H)]
dh = [1, 0]
dw = [0, 1]
S = []
for i in range(H):
s = input()
S.append(s)
if (S[0][0] == '#'):
dp[0][0] = 1
else:
dp[0][0] = 0
for i in range(H):
for j in range(W):
for k in range(2):
nh = i + dh[k]
nw = j + dw[k]
if nh >= H or nw >= W:
continue
add = 0
if (S[nh][nw] == "#" and S[i][j] == "."):
add = 1
dp[nh][nw] = min(dp[nh][nw], dp[i][j] + add)
print(dp[H-1][W-1])
| 1 | 49,521,084,749,352 | null | 194 | 194 |
n = int(input())
root = int(n**0.5)
a = 0
for i in range(root, 0, -1):
if n % i == 0:
a = i
break
b = n // a
print(a+b - 2)
| import sys
read = sys.stdin.read
readline = sys.stdin.readline
readlines = sys.stdin.readlines
sys.setrecursionlimit(10 ** 9)
INF = 1 << 60
MOD = 1000000007
def main():
N, K = map(int, readline().split())
point = list(map(int, readline().split()))
T = readline().strip()
T = list(map(int, T.translate(str.maketrans('rsp', '012'))))
hand = [0] * N
ans = 0
for i, h in enumerate(T):
win = (h - 1) % 3
if i >= K and win == hand[i - K]:
hand[i] = -1
else:
hand[i] = win
ans += point[win]
print(ans)
return
if __name__ == '__main__':
main()
| 0 | null | 134,286,955,308,080 | 288 | 251 |
N = int(input())
A = list(map(int,input().split()))
A.insert(0,0)
C = {i:0 for i in range(1,N+1)}
for i in range(1,N+1):
C[A[i]] += 1
tot = 0
for i in range(1,N+1):
tot += (C[i]*(C[i]-1))//2
for i in range(1,N+1):
c = C[A[i]]-1
ans = tot-(C[A[i]]*(C[A[i]]-1))//2+(c*(c-1))//2
print(ans) | import bisect, collections, copy, heapq, itertools, math, string
import sys
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 S(): return sys.stdin.readline().rstrip()
def LS(): return list(sys.stdin.readline().rstrip().split())
N = I()
A = LI()
c = collections.Counter(A)
cnt = 0
for _ in c:
cnt += c[_] * (c[_] - 1) // 2
for i in range(N):
a = c[A[i]]
print(cnt - (a - 1))
| 1 | 47,796,176,175,136 | null | 192 | 192 |
X,Y= map(int,input().split())
a = Y/2-X
b = X*2-Y/2
if Y%2 ==0:
if a >= 0 and b >= 0:
print('Yes')
else:
print('No')
else:
print('No') | N = int(input())
dp = [True] * 10**6
count = 0
if N % 2 == 0:
times = 0
while(N % 2 == 0):
times += 1
N //= 2
i = 1
while(times-i >= 0):
times -= i
i += 1
count += 1
f = 3
while f**2 < N:
if N % f == 0:
times = 0
while(N % f == 0):
times += 1
N //= f
i = 1
while(times-i >= 0):
times -= i
i += 1
count += 1
else:
f += 2
if N != 1:
count += 1
print(count) | 0 | null | 15,277,412,475,318 | 127 | 136 |
#!/usr/bin/env python
import sys
input = sys.stdin.buffer.readline
sys.setrecursionlimit(10**6)
def main():
S = input().decode().rstrip()
print(S[0:3])
if __name__ == "__main__":
main() | full = input()
num = 0
for i in full:
if num < 3:
num += 1
print(i, end="") | 1 | 14,781,193,887,670 | null | 130 | 130 |
# -*- coding: utf-8 -*-
n = int(input())
a = [int(i) for i in input().split()]
su = [0 for _ in range(n)] #鉄の棒の切れ目の座標
for i in range(n):
su[i] = su[i-1] + a[i]
#print(su)
tmp = 2 * pow(10, 10) + 1
for i in su:
#if abs(i - su[-1]/2) < tmp:
# tmp = abs(i - su[-1]/2)
tmp = min(tmp, abs(i - su[-1]/2))
#print(su[-1]/2, tmp)
"""
#中心に一番近い鉄の棒の切れ目と中心との距離の差
l = 0
r = n-1
while (l - r) >= 1:
c = (l + r) // 2
#print(l, r, c)
if su[c] < su[-1] / 2:
l = c
elif su[c] > su[-1] / 2:
r = c
#print(su[l], su[r])
tmp = min(abs(su[l] - su[-1]/2), abs(su[r] - su[-1]/2))
print(tmp)
"""
ans = 2 * tmp
print(int(ans))
| n = int(input())
a = list(map(int, input().split()))
L = sum(a)
l = 0
i = 0
while l < L / 2:
l += a[i]
i += 1
print(min(abs(sum(a[:i - 1]) - sum(a[i - 1:])), abs(sum(a[:i]) - sum(a[i:]))))
| 1 | 141,664,246,461,952 | null | 276 | 276 |
# PDF参考
# スタックS1
S1 = []
# スタックS2
S2 = []
tmp_total = 0
counter = 0
upper = 0
# 総面積
total_layer = 0
for i,symbol in enumerate(input()):
if (symbol == '\\'):
S1.append(i)
elif (symbol == '/') and S1:
i_p = S1.pop()
total_layer = i - i_p
if S2 :
while S2 and S2[-1][0] > i_p:
cal = S2.pop()
total_layer += cal[1]
S2.append((i, total_layer))
print(sum([j[1] for j in S2]))
if (len(S2) != 0):
print(str(len(S2)) + ' ' + ' '.join([str(i[1]) for i in S2]))
else:
print(str(len(S2)))
|
if __name__ == '__main__':
# ??????????????\???
S_size = int(input())
S = set([int(x) for x in input().split(' ')])
T_size = int(input())
T = set([int(x) for x in input().split(' ')])
# S = [1, 2, 3, 4, 5, 1]
# T = set([3, 4, 1])
# ????????????
U = S.intersection(T)
# ???????????????
print('{0}'.format(len(U))) | 0 | null | 60,010,932,090 | 21 | 22 |
def main():
""""ここに今までのコード"""
N, K = map(int, input().split())
dice_list = list(map(int, input().split()))
max, s = 0, 0
for i in range(K):
s += (dice_list[i] + 1) / 2
max = s
for i in range(N-K):
s -= (dice_list[i] + 1) / 2
s += (dice_list[i+K] + 1) / 2
if s > max:
max = s
print(max)
if __name__ == '__main__':
main() | from sys import stdin
import sys
import math
from functools import reduce
import functools
import itertools
from collections import deque
n,k = [int(x) for x in stdin.readline().rstrip().split()]
p = [(int(x)+1)/2 for x in stdin.readline().rstrip().split()]
m = sum(p[0:k])
maxm = m
for i in range(1,n-k+1):
m = m - p[i-1] + p[i+k-1]
maxm = max([maxm,m])
print(maxm)
| 1 | 74,902,188,301,450 | null | 223 | 223 |
s_ = int(input())
print("%d:%d:%d" % (s_//3600, s_//60%60, s_%60)) | def f(point):
k = K
for i in range(N):
a = A[i]
f = F[i]
if a*f > point:
k -= a - point//f
if k < 0:
return False
# print(point, k)
return True
N, K = map(int, input().split())
A = list(map(int, input().split()))
F = list(map(int, input().split()))
A.sort()
F.sort(reverse=True)
l = -1
r = 10**18+1
while (r-l) > 1:
mid = (r+l)//2
if f(mid):
r = mid
else:
l = mid
print(r)
| 0 | null | 82,460,682,987,040 | 37 | 290 |
n, k = map(int, input().split())
ans = 0
for i in range(k, n + 2):
l = int(i * (i - 1) / 2)
r = n * i - l
ans += r - l + 1
ans %= 10 ** 9 + 7
print(ans) | N, K = map(int, input().split())
mod = 1000000007
ans = 0
for i in range(K, N+1+1):
num_min = i*(i-1)//2
num_max = i*(N+N-i+1)//2
# print(num_min, num_max)
ans += (num_max - num_min + 1)%mod
print(ans%mod) | 1 | 32,905,935,408,960 | null | 170 | 170 |
A= int(input())
l=[[0]*10 for _ in range(10)]
for i in range(1,A+1):
n=str(i)
if n[0] == "0" or n[-1] == "0":
continue
l[int(n[0])][int(n[-1])]+=1
ans=0
for i in range(1,10):
for j in range(1,10):
ans+=l[i][j] * l[j][i]
print(ans) | n = int(input())
a = [[0 for j in range(10)] for i in range(10)]
for i in range(1, n+1):
if i >= 10**5:
tmp1 = i//10**5
elif i >= 10**4:
tmp1 = i//10**4
elif i >= 10**3:
tmp1 = i//10**3
elif i >= 10**2:
tmp1 = i//10**2
elif i >= 10:
tmp1 = i//10
else :
tmp1 = i
tmp2 = i % 10
a[tmp1][tmp2] += 1
cnt = 0
for i in range(1, 10):
for j in range(1, 10):
cnt += a[i][j] * a[j][i]
print(cnt)
| 1 | 86,861,003,029,570 | null | 234 | 234 |
def bubbleSort(a, n):
count = 0
flag = 1
while flag:
flag = 0
for j in range(n - 1, 0, -1):
if a[j] < a[j - 1]:
a[j], a[j - 1] = a[j - 1], a[j]
count += 1
flag = 1
return count
def main():
n = int(input())
a = [int(x) for x in input().split(' ')]
count = bubbleSort(a, n)
print(' '.join([str(x) for x in a]))
print(count)
if __name__ == '__main__':
main() | #coding: utf-8
#ALDS1_2A
def pnt(s):
for i in xrange(len(s)):
print s[i],
print
n=int(raw_input())
a=map(int,raw_input().split())
sw=0
flag=True
while flag:
flag=False
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=True
sw+=1
pnt(a)
print sw | 1 | 18,063,929,870 | null | 14 | 14 |
from math import gcd
from collections import defaultdict
N = int(input())
d = {}
MOD = 10**9+7
zall = 0
for _ in range(N):
A, B = map(int, input().split())
if A==0 and B==0:
zall += 1
else:
if A and B:
if A<0 and B<0:
A *= -1
B *= -1
elif A<0 and B>0:
A *= -1
B *= -1
g = gcd(A, B)
A //= g
B //= g
elif A==0:
B = 1
elif B==0:
A = 1
if (A, B) in d:
d[(A, B)] += 1
else:
d[(A, B)] = 1
ans = 1
used = defaultdict(int)
for (i, j), v in d.items():
if used[(i, j)]:continue
used[(i, j)] = 1
buf = 0
if j>0:
if (j, -i) in d:
used[(j, -i)] = 1
buf = d[(j, -i)]
else:
buf = 0
else:
if (-j, i) in d:
used[(-j, i)] = 1
buf = d[(-j, i)]
else:
buf = 0
ans *= (pow(2, buf, MOD)+pow(2, v, MOD)-1)
ans %= MOD
print((ans+zall-1)%MOD)
| import sys
input = sys.stdin.readline
import collections
import fractions
from collections import defaultdict
import math
n=int(input())
a= [list(map(int, input().split())) for i in range(n)]
b=defaultdict(int)
c=defaultdict(int)
b0=0
c0=0
mod=1000000007
ans=1
cnt=0
for i,j in a:
if i!=0 and j!=0:
x=i
y=j
i //= math.gcd(x, y)
j //= math.gcd(x, y)
i=abs(i)
j=abs(j)
if x*y>0:
b[(i,j,0)]+=1
c[(j,i,1)]+=1
else:
b[(i,j,1)]+=1
c[(j,i,0)]+=1
elif i==0 and j!=0:
b0+=1
elif i!=0 and j==0:
c0+=1
else:
cnt+=1
w=[]
if c0!=0 or b0!=0:
ans*=pow(2,c0+b0)-((pow(2,c0,mod)-1)*(pow(2,b0,mod)-1))
for k,v in b.items():
if c[k]!=0:
ans*=(pow(2,c[k]+v,mod)-(pow(2,c[k],mod)-1)*(pow(2,v,mod)-1))
w.append((pow(2,c[k]+v,mod)-(pow(2,c[k],mod)-1)*(pow(2,v,mod)-1)))
ans%=mod
else:
ans*=pow(2,v,mod)
ans%=mod
w=collections.Counter(w)
w=list(w.most_common())
for i,j in w:
for k in range(j//2):
ans*=pow(i,mod-2,mod)
ans+=cnt-1
print(int(ans%mod)) | 1 | 20,929,374,850,938 | null | 146 | 146 |
#!/usr/bin/env python3
import sys
sys.setrecursionlimit(1000000)
from collections import deque
# 整数の入力
a = int(input())
print(a+a**2+a**3) | import math
n, M= map(int,input().split())
#AB=[]
#N = int(input())
#C = input()
parents = [-1] * n
def find( x):
if parents[x] < 0:
return x
else:
parents[x] = find(parents[x])
return parents[x]
def union(x, y):
x = find(x)
y = find(y)
if x == y:
return
if parents[x] > parents[y]:
x, y = y, x
parents[x] += parents[y]
parents[y] = x
def size( x):
return -parents[find(x)]
def same( x, y):
return find(x) == find(y)
def members( x):
root = find(x)
return [i for i in range(n) if find(i) == root]
def roots():
return [i for i, x in enumerate(parents) if x < 0]
def group_count():
return len(roots())
def all_group_members():
return {r: members(r) for r in roots()}
def __str__():
return '\n'.join('{}: {}'.format(r, members(r)) for r in roots())
C = []
for i in range(M):
A, B = map(int,input().split())
union(A-1,B-1)
'''
c = 0
for p in C:
if A in p:
c = 1
p.add(B)
elif B in p:
c = 1
p.add(A)
if c != 1:
C.append(set([A,B]))
'''
print(group_count()-1)
| 0 | null | 6,316,471,044,872 | 115 | 70 |
a, b = list(map(int, input().split()))
my_result = a * (a - 1) + b * (b - 1)
print(int(my_result / 2)) | n, m = list(map(int, input().split()))
nC2 = (n * (n - 1)) // 2
mC2 = (m * (m - 1)) // 2
print(nC2 + mC2) | 1 | 45,648,295,483,648 | null | 189 | 189 |
import sys
import math
from math import ceil
input = sys.stdin.readline
print(ceil(int(input()) / 2)) | n = int(input())
ans = (n//2) + (n%2)
print (ans) | 1 | 58,941,445,213,658 | null | 206 | 206 |
def II(): return int(input())
def LII(): return list(map(int, input().split()))
n=II()
town=[LII() for _ in range(n)]
distance=0
for i in range(n-1):
for j in range(i+1,n):
[xi,yi]=town[i]
[xj,yj]=town[j]
distance += ((xi-xj)**2+(yi-yj)**2)**0.5
print(distance*2/n) | N=int(input())
xy=[list(map(int,input().split())) for _ in range(N)]
ans=0
for i in range(N):
for j in range(i+1,N):
d=((xy[i][0]-xy[j][0])**2+(xy[i][1]-xy[j][1])**2)**0.5
ans+=2*d
print(ans/N)
| 1 | 148,149,746,333,780 | null | 280 | 280 |
import sys
from collections import Counter
n = int(input())
a_ls = [int(i) for i in sys.stdin.readline().split()]
minus_a_ct = Counter([-a-i for i,a in enumerate(a_ls)])
a_ct = Counter([a-i for i,a in enumerate(a_ls)])
_sum = 0
for k, v in a_ct.items():
_sum += v * minus_a_ct[k]
print(_sum) | #B問題
#ABSの定石使うとなぜかRE
#今回はPython解説サイト参照
#①入力を文字列で受け取る→②一文字ずつ整数に変換して、forループで回しながら足し算する
N = input()
cur = 0
for i in N:
cur += int(i)
if cur % 9 == 0:
print("Yes")
else:
print("No") | 0 | null | 15,091,159,218,732 | 157 | 87 |
s = input()
l = len(s)
a = s[0:(l-1)//2]
b = len(a)
print("Yes" if s == s[::-1] and a == a[::-1] else "No") | N = int(input())
str_dict= {}
for i in range(N):
a = input().split()
if a[0] == "insert":
str_dict[a[1]] = i
else:
if a[1] in str_dict.keys():
print("yes")
else:
print("no")
| 0 | null | 23,213,669,834,560 | 190 | 23 |
x=int(input())
y=x**3
print(y)
| n = int(input())
lst = list(map(int,input().split()))
c = 0
for i in range(n):
if (lst[i]%2 == 0):
if (lst[i]%3 != 0 and lst[i]%5 != 0):
c = 1
if (c == 0):
print("APPROVED")
else:
print("DENIED")
| 0 | null | 34,641,376,941,248 | 35 | 217 |
INF = float('inf')
H, W = map(int, input().split())
Sss = ['#'*(W+2)] + ['#'+input()+'#' for _ in range(H)] + ['#'*(W+2)]
def convGrid2Graph(Sss):
dxys = [(-1,0), (1,0), (0,-1), (0,1)]
sizeX, sizeY = len(Sss)-2, len(Sss[0])-2
numV = sizeX * sizeY
adjL = [[] for _ in range(numV)]
for x in range(1, sizeX+1):
for y in range(1, sizeY+1):
if Sss[x][y] != '.': continue
z = (x-1)*sizeY + (y-1)
for dx, dy in dxys:
x2, y2 = x+dx, y+dy
if Sss[x2][y2] != '.': continue
z2 = (x2-1)*sizeY + (y2-1)
adjL[z].append(z2)
return adjL
def WarshallFloyd(adjList, INF):
numV = len(adjList)
D = [[INF]*numV for _ in range(numV)]
for u, adj in enumerate(adjList):
for v in adj:
D[u][v] = 1
D[u][u] = 0
for k in range(numV):
Dk = D[k]
for i in range(numV):
Di = D[i]
Dik = Di[k]
for j in range(numV):
D2 = Dik + Dk[j]
if D2 < Di[j]:
D[i][j] = D2
return D
adjL = convGrid2Graph(Sss)
distss = WarshallFloyd(adjL, INF)
ans = 0
for i in range(H*W):
for j in range(H*W):
if distss[i][j] != INF:
ans = max(ans, distss[i][j])
print(ans)
| from sys import stdin
nii=lambda:map(int,stdin.readline().split())
lnii=lambda:list(map(int,stdin.readline().split()))
from copy import deepcopy
from collections import deque
h,w=nii()
s=[list(input()) for i in range(h)]
def dfs(cs,i,j):
que=deque()
que.append([i,j])
cs[i][j]='#'
dist=[[-1 for a in range(w)] for b in range(h)]
dist[i][j]=0
while que:
y,x=que.popleft()
for dy,dx in [[1,0],[-1,0],[0,1],[0,-1]]:
ny=y+dy
nx=x+dx
if 0<=ny<h and 0<=nx<w and cs[ny][nx]=='.':
que.append([ny,nx])
cs[ny][nx]='#'
dist[ny][nx]=dist[y][x]+1
t_ans=0
for a in dist:
t_ans=max(t_ans,max(a))
return t_ans
ans=0
for i in range(h):
for j in range(w):
if s[i][j]=='.':
cs=deepcopy(s)
dist=dfs(cs,i,j)
ans=max(ans,dist)
print(ans) | 1 | 94,663,793,412,092 | null | 241 | 241 |
input = int(input().strip())
hour = input // 3600
min = (input - 3600*hour) // 60
sec = input - 3600 * hour - 60 * min
print (":".join([str(hour), str(min), str(sec)])) | s = int(raw_input())
print "%d:%d:%d" % (s / 3600, s / 60 % 60, s % 60) | 1 | 339,144,217,380 | null | 37 | 37 |
while True:
n, x = map(int, raw_input().split())
if(n == 0 and x == 0):
break
count = 0
for i in range(1, n - 1):
for j in range(i + 1, n):
for k in range(j + 1, n + 1):
if(i + j + k == x):
count += 1
print(count) | data = []
while True:
in_line = raw_input().split()
n = int(in_line[0])
x = int(in_line[1])
if n == 0 and x == 0:
break
data.append([n,x])
for n in data:
count = 0
for i in range(1,n[0]+1):
for j in range(i+1,n[0]+1):
for k in range(j+1,n[0]+1):
if i+j+k == n[1]:
count += 1
print count | 1 | 1,286,253,700,640 | null | 58 | 58 |
import sys
import math
from decimal import Decimal, ROUND_HALF_UP, ROUND_HALF_EVEN
from collections import deque
from bisect import bisect_left
from itertools import product
def I(): return int(sys.stdin.readline())
def MI(): return map(int, sys.stdin.readline().split())
def LI(): return list(map(int, sys.stdin.readline().split()))
def LI2(N): return [list(map(int, sys.stdin.readline().split())) for i in range(N)]
#文字列を一文字ずつ数字に変換、'5678'を[5,6,7,8]とできる
def LSI(): return list(map(int, list(sys.stdin.readline().rstrip())))
def LSI2(N): return [list(map(int, list(sys.stdin.readline().rstrip()))) for i in range(N)]
#文字列として取得
def ST(): return sys.stdin.readline().rstrip()
def LST(): return sys.stdin.readline().rstrip().split()
def LST2(N): return [sys.stdin.readline().rstrip().split() for i in range(N)]
def FILL(i,h): return [i for j in range(h)]
def FILL2(i,h,w): return [FILL(i,w) for j in range(h)]
def FILL3(i,h,w,d): return [FILL2(i,w,d) for j in range(h)]
def FILL4(i,h,w,d,d2): return [FILL3(i,w,d,d2) for j in range(h)]
def sisha(num,digit): return Decimal(str(num)).quantize(Decimal(digit),rounding=ROUND_HALF_UP)
#'0.01'や'1E1'などで指定、整数に戻すならintをかます
MOD = 1000000007
INF = float("inf")
sys.setrecursionlimit(10**6+10)
N = LSI()
dp = [[INF]*2 for _ in range(len(N)+1)] #dp[i][0]が下からi桁めをぴったり払う最低枚数
dp[0][0] = 0
for i in range(len(N)):
d = N[-(i+1)]
dp[i+1][0] = min(dp[i][0] + d, dp[i][1] + d + 1)
dp[i+1][1] = min(dp[i][0] + (10-d), dp[i][1] + (10-d) - 1)
print(min(dp[-1][0], dp[-1][1]+1))
| n=int(input())
result=0
for i in range(n+1):
if (i%3)!=0 and (i%5)!=0:
result+=i
print(result) | 0 | null | 53,109,444,897,014 | 219 | 173 |
import math
A, B, N = list(map(int,input().split()))
def f(x):
return math.floor(A * x / B) - A * math.floor(x / B)
if B - 1 <= N:
ans = f(B - 1)
else:
ans = f(N)
print(ans) | import collections
a = collections.deque()
for i in range(int(input())):
b = input()
# 命令がinsertだった場合、
if b[0] == 'i':
# キーxを先頭に追加(数字は文字列bの7文字目以降にある)
a.appendleft(b[7:])
# 命令がdeleteだった場合
elif b[6] == ' ':
# 命令のキーが含まれる場合そのキーのデータを消すが、なければ何もしない
try:
a.remove(b[7:])
except:
pass
# 命令がdeleteFirstだった場合
elif len(b) > 10:
a.popleft()
# 命令がdeleteLastだった場合
elif len(b) > 6:
a.pop()
print(*a)
| 0 | null | 14,069,044,718,680 | 161 | 20 |
n=int(input())
a=[int(i) for i in input().split(" ")]
x=0
flg=1
while flg:
flg=0
for i in range(n-1,0,-1):
if a[i-1] > a[i]:
a[i],a[i-1] = a[i-1],a[i]
x+=1
flg=1
print(" ".join([str(i) for i in a]))
print(x) | def bubbleSort(A,N):
count = 0
flag = 1
while flag:
flag = 0
for i in range(1,N):
if A[N-i] < A[N-i-1]:
A[N-i] , A[N-i-1] = A[N-i-1] , A[N-i]
flag = 1
count += 1
return (count)
n = int(input())
data = [int(i) for i in input().split()]
a = bubbleSort(data,n)
print(" ".join(map(str,data)))
print(a) | 1 | 15,059,087,680 | null | 14 | 14 |
from math import ceil
from bisect import bisect_right
n, d, a = map(int, input().split())
l = []
l2 = []
l3 = []
l4 = [0 for i in range(n+1)]
l5 = [0 for i in range(n+1)]
ans = 0
for i in range(n):
x, h = map(int, input().split())
l.append([x, h])
l2.append(x + 2 * d)
l3.append(x)
l.sort(key=lambda x: x[0])
l2.sort()
l3.sort()
for i in range(n):
cnt = ceil((l[i][1] - l4[i] * a) / a)
if cnt > 0:
ans += cnt
ind = bisect_right(l3, l2[i])
l5[ind] += cnt
l4[i] += cnt
l4[i+1] = l4[i] - l5[i+1]
print(ans) | import sys
import bisect
from math import ceil
from itertools import accumulate
n, d, a = [int(i) for i in sys.stdin.readline().split()]
monsters = []
max_x = 0
for i in range(n):
x, h = [int(i) for i in sys.stdin.readline().split()]
max_x = max(x, max_x)
monsters.append([x, h])
monsters.sort(key=lambda x:x[0])
x, h = zip(*monsters)
x_ls = []
for i, (_x, _h) in enumerate(zip(x, h)):
ind = bisect.bisect_right(x, _x + 2 * d)
x_ls.append([i, ind, _h])
h = list(h) + [0]
ls = [0 for i in range(n+1)]
cur = 0
res = 0
for i, ind, _h in x_ls:
if h[i] > 0:
cur -= ls[i]
h[i] -= cur
if h[i] > 0:
hoge = ceil(h[i] / a)
res += hoge
cur += hoge * a
ls[ind] += hoge * a
print(res)
| 1 | 82,348,838,870,620 | null | 230 | 230 |
X, Y, A, B, C = map(int, input().split())
P = [[] for _ in range(3)]
for p in map(int, input().split()):
P[0].append((p,0))
for p in map(int, input().split()):
P[1].append((p,1))
for p in map(int, input().split()):
P[2].append((p,2))
P[0].sort(reverse=True)
P[1].sort(reverse=True)
P[2].sort()
P[0] = P[0][:X]
P[1] = P[1][:Y]
data = P[0] + P[1]
data.sort(reverse=True)
num = [A,B]
res = sum(map(lambda x: x[0], data))
while True:
p, i = data.pop()
q, _ = P[2].pop()
if p >= q:
break
if num[i] - 1 >= 0:
num[i] -= 1
res += q - p
if sum(num) == 0:
break
if len(P[2]) == 0:
break
print(res)
| import sys
read = sys.stdin.buffer.read
input = sys.stdin.readline
input = sys.stdin.buffer.readline
#sys.setrecursionlimit(10**9)
#from functools import lru_cache
def RD(): return sys.stdin.read()
def II(): return int(input())
def MI(): return map(int,input().split())
def MF(): return map(float,input().split())
def LI(): return list(map(int,input().split()))
def LF(): return list(map(float,input().split()))
def TI(): return tuple(map(int,input().split()))
# rstrip().decode('utf-8')
#2325
#import numpy as np
import math
def main():
a,b,x=MI()
k=0
if b/2<=x/a**2:
k=2/a*(b-x/a**2)
else:
k=a*b**2/(2*x)
print(math.degrees(math.atan(k)))
if __name__ == "__main__":
main() | 0 | null | 104,296,215,127,050 | 188 | 289 |
M=10**9+7
n,k=map(int,input().split())
l=[0]*(k+1)
a=0
for i in range(k,0,-1):
l[i]=pow(k//i,n,M)
for j in range(i*2,k+1,i):
l[i]-=l[j]
a+=i*l[i]
print(a%M)
| MOD = 1000000007
def fast_power(base, power):
"""
Returns the result of a^b i.e. a**b
We assume that a >= 1 and b >= 0
Remember two things!
- Divide power by 2 and multiply base to itself (if the power is even)
- Decrement power by 1 to make it even and then follow the first step
"""
result = 1
while power > 0:
# If power is odd
if power % 2 == 1:
result = (result * base) % MOD
# Divide the power by 2
power = power // 2
# Multiply base to itself
base = (base * base) % MOD
return result
n,k = [int(j) for j in input().split()]
d = dict()
ans = k
d[k] = 1
sum_so_far = 1
for i in range(k-1, 0, -1):
d[i] = fast_power(k//(i),n)
for mul in range(i*2, k+1, i):
d[i]-=d[mul]
# d[i] = max(1, d[i])
ans+=(i*d[i])%MOD
# if d[i]>1:
# sum_so_far += d[i]
print(ans%MOD)
| 1 | 36,695,083,533,500 | null | 176 | 176 |
def main():
a,b,c=map(int,input().split())
k = int(input())
for i in range(k):
if a < b < c:
break
elif a >= b:
b *= 2
elif b >= c:
c *= 2
if a < b < c:
print('Yes')
else:
print('No')
main() | i = 0
while True :
x = int(input())
if(x == 0) :
break
else :
i += 1
print("Case ", i, ": ", x, sep = "")
| 0 | null | 3,720,488,192,850 | 101 | 42 |
import math
a, b, c = map(float,input().split())
e = b*math.sin(math.radians(c))
print(a*e/2)
print(((a-b*math.cos(math.radians(c)))**2+e**2)**0.5+a+b)
print(e)
| N = int(input())
for i in range(1,int(N**(1/2)) + 1)[::-1]:
if N%i == 0:
print(i + N//i - 2)
exit() | 0 | null | 81,228,690,872,350 | 30 | 288 |
import sys
def main():
# input = sys.stdin.read()
# data = list(map(int, input.split()))
s = input()
p = input()
cnt = 0
for i in range(len(s) - len(p)+1):
mx = 0
for j in range(len(p)):
if s[i+j] == p[j]:
mx += 1
# print(i, mx)
cnt = max(cnt, mx)
# print(p,cnt)
print(len(p)-cnt)
if __name__ == '__main__':
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,670,908,220,058 | null | 82 | 82 |
N = int(input())
l = []
for _ in range(N):
A, B = map(int, input().split())
l.append((A, B))
t = N//2
tl = sorted(l)
tr = sorted(l, key=lambda x:-x[1])
if N%2:
print(tr[t][1]-tl[t][0]+1)
else:
a1, a2 = tl[t-1][0], tr[t][1]
a3, a4 = tl[t][0], tr[t-1][1]
print(a4-a3+a2-a1+1)
| import sys
input = sys.stdin.readline
N = int(input())
AB = [[int(i) for i in input().split()] for _ in range(N)]
AB.sort()
ans = 0
if N & 1:
l = AB[N//2][0]
AB.sort(key=lambda x: x[1])
ans = AB[N // 2][1] - l + 1
else:
l = (AB[N // 2][0], AB[N // 2 - 1][0])
AB.sort(key=lambda x: x[1])
r = (AB[N // 2][1], AB[N // 2 - 1][1])
ans = sum(r) - sum(l) + 1
print(ans) | 1 | 17,279,831,764,888 | null | 137 | 137 |
import sys
def input(): return sys.stdin.readline().strip()
def mapint(): return map(int, input().split())
sys.setrecursionlimit(10**9)
X = int(input())
big_coin, amari = divmod(X, 500)
print(big_coin*1000+(amari//5)*5) | A,B,C = map(int, input().split())
K = int(input())
for i in range(K):
if B >= C or A >= C:
C *= 2
else:
if A >= B:
B *= 2
if C > B and B > A:
print("Yes")
else:
print("No") | 0 | null | 24,787,394,402,316 | 185 | 101 |
S=input()
N=len(S)
A=S[:(N-1)//2]
B=S[(N+3)//2-1:]
if S!=S[::-1] or A!=A[::-1] or B!=B[::-1]:
print("No")
else:
print("Yes") | S=input();
if(S=="hi" or S=="hihi" or S=="hihihi" or S=="hihihihi" or S=="hihihihihi"):
print("Yes");
else:
print("No"); | 0 | null | 49,810,681,680,518 | 190 | 199 |
N = int(input())
S, T = input().split()
mix = []
for i in range(N):
mix.append(S[i])
mix.append(T[i])
print(*mix, sep='') | #!/usr/bin/env python
# -*- coding: utf-8 -*-
m = []
for i in range(0,10):
m.append(int(input()))
for i in range(0,3):
print(list(reversed(sorted(m)))[i]) | 0 | null | 55,948,994,930,620 | 255 | 2 |
a,n=0,int(input())
for i in range(2,int(n**0.5+1)):
x=0
while(n%i==0):n//=i;x+=1
j=1
while(x>=j):a+=1;x-=j;j+=1
print(a+(n>1)) | i = 1
while True:
n = input()
if n == 0:
break
else:
print "Case %d: %d" % (i, n)
i = i + 1 | 0 | null | 8,733,748,621,748 | 136 | 42 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.