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
|
|---|---|---|---|---|---|---|
#ABC156B
n,k = map(int,input().split())
ans = 0
while n > 0 :
n = n // k
ans = ans + 1
print(ans) | N,K=map(int,input().split())
a=0
while N>0:
a+=1
N=N//K
print(a) | 1 | 64,042,344,249,540 | null | 212 | 212 |
a,b,h,m = map(int,input().split())
import math
C = abs(360 / 60 * m - 360 / 12 * h - 360 / 12 / 60 * m)
if C > 180:
C = 360 - C
#print(C)
cosC = math.cos(math.radians(C))
#print(cosC)
print(math.sqrt(a ** 2 + b ** 2 - 2 * a * b * cosC)) | ABC = list(map(int,input().split()))
red = ABC[0]
green = ABC[1]
blue = ABC[2]
K = int(input())
for i in range(K):
if green <= red:
green *= 2
continue
elif blue <= green:
blue *= 2
if green > red and blue > green:
print('Yes')
else:
print('No') | 0 | null | 13,366,578,388,014 | 144 | 101 |
X = int(input())
if ((2000-X)%200) == 0:
print((2000-X)//200)
else:
print((2000-X)//200+1) | #B
N=int(input())
C=[input() for i in range(N)]
AC=C.count('AC')
WA=C.count('WA')
TLE=C.count('TLE')
RE=C.count('RE')
print('AC x {}\nWA x {}\nTLE x {}\nRE x {}'.format(AC, WA, TLE, RE)) | 0 | null | 7,700,446,616,350 | 100 | 109 |
def getList():
return list(map(int, input().split()))
a, b = getList()
if a > 9 or b > 9:
print(-1)
else:
print(a*b) | H = int(input())
W = int(input())
N = int(input())
X = max(H, W)
print((N + X - 1) // X)
| 0 | null | 123,902,585,879,424 | 286 | 236 |
def main():
s = input()
n = int(input())
for i in range(n):
cmds = input().split(' ')
if 'reverse' == cmds[0]:
a = int(cmds[1])
b = int(cmds[2])+1
s = s[:a]+''.join(reversed(s[a:b]))+s[b:]
if 'replace' == cmds[0]:
a = int(cmds[1])
b = int(cmds[2])+1
res = cmds[3]
s = s[:a]+res+s[b:]
if 'print' == cmds[0]:
a = int(cmds[1])
b = int(cmds[2])+1
print(s[a:b])
if __name__ == '__main__': main() | #!usr/bin/env python3
import sys
def main():
s = sys.stdin.readline().strip('\n')
q = int(sys.stdin.readline().strip('\n'))
for instruction in range(q):
words = [word for word in sys.stdin.readline().strip('\n').split()]
if words[0] == 'replace':
s = s[:int(words[1])] + words[3] + s[int(words[2])+1:]
elif words[0] == 'reverse':
s = s[:int(words[1])] \
+ ''.join(reversed(s[int(words[1]):int(words[2])+1])) \
+ s[int(words[2])+1:]
elif words[0] == 'print':
print(s[int(words[1]):int(words[2])+1])
if __name__ == '__main__':
main() | 1 | 2,081,484,381,420 | null | 68 | 68 |
s = input()
if s[len(s)-1] == 's':
s = s + 'es'
elif s[len(s)-1] != 's':
s = s + 's'
print(s)
| class Main:
S = input()
if S[-1] == 's':
print(S+'es')
else :
print(S+'s') | 1 | 2,373,431,201,502 | null | 71 | 71 |
N, K, C = list(map(int, input().split()))
S = input()
work_day_min = []
work_day_max = []
for i in range(N):
if S[i] == 'o':
if i > 0 and len(work_day_min) > 0:
if i - work_day_min[-1] <= C:
continue
work_day_min.append(i)
if len(work_day_min) == K:
break
for i in range(N):
if S[N - i - 1] == 'o':
if i > 0 and len(work_day_max) > 0:
if work_day_max[-1] - (N - i - 1) <= C:
continue
work_day_max.append(N - i - 1)
if len(work_day_max) == K:
break
for i in range(K):
if work_day_min[i] == work_day_max[K-i-1]:
print(work_day_min[i]+1) | N, K, C = map(int, input().split())
S = input()
left = []
right = []
i, j = 0, N-1
while len(left) <= K-1:
if S[i] == "o":
left.append(i)
i += C+1
else:
i += 1
while len(right) <= K-1:
if S[j] == "o":
right.append(j)
j -= C+1
else:
j -= 1
right.sort()
for n in range(K):
if left[n] == right[n]:
print(left[n] + 1) | 1 | 40,963,981,252,448 | null | 182 | 182 |
import numpy as np
def min_steps_v2(n, a, b):
n = np.int64(n)
a = np.int64(a)
b = np.int64(b)
if (b - a) % 2 == 0:
return np.int64(int(b - a) // 2)
# odd case
a_diff = a - 1
b_diff = n - b
if a_diff > b_diff:
steps_to_even = n - b + 1
remain_steps = min_steps_v2(n, a + (n - b) + 1, n)
else:
steps_to_even = a
remain_steps = min_steps_v2(n, 1, b - a)
return steps_to_even + remain_steps
numbers = input().split(' ')
n = int(numbers[0])
a = int(numbers[1])
b = int(numbers[2])
print(min_steps_v2(n, a, b))
| def lu(n):
L.append(n)
a=n%10
if len(str(n))>11:
return 1
if a==0:
lu(n*10+1)
lu(n*10)
elif a==9:
lu(n*10+9)
lu(n*10+8)
else:
lu(n*10+1+a)
lu(n*10+a-1)
lu(n*10+a)
L=list()
lu(1)
lu(2)
lu(3)
lu(4)
lu(5)
lu(6)
lu(7)
lu(8)
lu(9)
L=sorted(set(L))
k=int(input())
print(L[k-1]) | 0 | null | 74,732,212,091,808 | 253 | 181 |
s = int(input())
if s == 1:
print(0)
elif s == 0:
print(1) | x = int(input())
if(x==0):
print("1")
elif(x==1):
print("0") | 1 | 2,934,829,645,258 | null | 76 | 76 |
from sys import stdin
def main():
_in = [_.rstrip() for _ in stdin.readlines()]
N, X, M = list(map(int, _in[0].split(' '))) # type:list(int)
# vvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvv
ans = 0
A = X
head_list = []
head = set()
repeat = set()
for i in range(N):
if A in head:
ind = head_list.index(A)
repeat = head_list[ind:]
head = head_list[:ind]
break
else:
head.add(A)
head_list.append(A)
A = pow(A, 2, M)
if len(repeat) == 0:
ans = sum(head)
else:
repeat_time = (N - len(head)) // len(repeat)
tail_len = N - len(head) - repeat_time * len(repeat)
ans = sum(head) + sum(repeat) * repeat_time + sum(repeat[:tail_len])
# ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
print(ans)
if __name__ == "__main__":
main()
| #DISCO presents ディスカバリーチャンネル コードコンテス a
def get_money(num):
if num==3:
return 100000
elif num==2:
return 200000
elif num==1:
return 300000
else:
return 0
x,y=map(int,input().split())
money=get_money(x)+get_money(y)
if x==y and x==1:
money+=400000
print(money) | 0 | null | 71,826,566,819,620 | 75 | 275 |
from collections import defaultdict
def readInt():
return int(input())
def readInts():
return list(map(int, input().split()))
def readChar():
return input()
def readChars():
return input().split()
x = readInt()
for i in range(int(x//105),int(x//100)+2):
t = x-100*i
if 0<=t and t<=5*i:
print(1)
exit()
print(0) | from itertools import permutations
from bisect import bisect
n = int(input())
p = tuple(map(int, input().split()))
q = tuple(map(int, input().split()))
l = tuple(permutations(range(1, n + 1), n))
print(abs(bisect(l, p) - bisect(l, q))) | 0 | null | 113,844,072,563,350 | 266 | 246 |
print "\n".join(map(str, sorted([input() for _ in xrange(10)])[:-4:-1])) | m = []
while True:
try:
m.append(int(raw_input()))
except EOFError:
break
m.sort()
m.reverse()
for h in m[0:3]:
print h | 1 | 29,752,778 | null | 2 | 2 |
INFTY=1000000000
n=int(input())
A=list(map(int,input().split()))
def merge(A,left,mid,right):
cnt=0
n1=mid-left
n2=right-mid
L=[A[left+i] for i in range(n1)]
R=[A[mid+i] for i in range(n2)]
L.append(INFTY)
R.append(INFTY)
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
return cnt
def mergeSort(A,left,right):
if left+1<right:
mid=(left+right)//2
cnt1=mergeSort(A,left,mid)
cnt2=mergeSort(A,mid,right)
return merge(A,left,mid,right)+cnt1+cnt2
return 0
cnt=mergeSort(A,0,n)
print(' '.join(map(str,A)))
print(cnt)
| #http://judge.u-aizu.ac.jp/onlinejudge/description.jsp?id=ALDS1_5_B&lang=jp
def merge(target_list, left_index, right_index):
global count
mid_index = (left_index + right_index) // 2
l = target_list[left_index:mid_index] + [pow(10,9) + 1]
r = target_list[mid_index:right_index] + [pow(10,9) + 1]
l_target = 0
r_target = 0
#print(left_index, right_index, mid_index, l,r)
for k in range(left_index, right_index):
count += 1
if l[l_target] < r[r_target]:
target_list[k] = l[l_target]
l_target += 1
else:
target_list[k] = r[r_target]
r_target += 1
#print(target_list)
def merge_sort(target_list, left_index, right_index):
if left_index + 1 < right_index:
mid_index = (left_index + right_index) // 2
merge_sort(target_list, left_index, mid_index)
merge_sort(target_list, mid_index, right_index)
merge(target_list, left_index, right_index)
if __name__ == "__main__":
l = input()
target_list = [int(a) for a in input().split()]
global count
count = 0
merge_sort(target_list, 0, len(target_list))
print(" ".join([str(n) for n in target_list]))
print(count) | 1 | 117,464,906,780 | null | 26 | 26 |
k=int(input())
a,b=map(int,input().split(' '))
flag=0
for i in range(a,b+1):
if i%k==0:
flag=1
if flag==1:
print('OK')
else:
print('NG')
| K = int(input())
A, B = map(int, input().split())
flag = 0
for n in range(A, B+1):
if n % K == 0:
flag = 1
break
if flag == 0:
print("NG")
else:
print("OK") | 1 | 26,459,548,918,190 | null | 158 | 158 |
#!/usr/bin/env python3
import sys
def solve(A: int, B: int):
print(A*B)
# Generated by 1.1.7.1 https://github.com/kyuridenamida/atcoder-tools (tips: You use the default template now. You can remove this line by using your custom template)
def main():
def iterate_tokens():
for line in sys.stdin:
for word in line.split():
yield word
tokens = iterate_tokens()
A = int(next(tokens)) # type: int
B = int(next(tokens)) # type: int
solve(A, B)
if __name__ == '__main__':
main()
| n = int(input())
odd = 0
even = 0
for i in range(1,n+1):
if i % 2 == 0:
even += 1
else:
odd += 1
print(odd/n) | 0 | null | 96,082,541,005,440 | 133 | 297 |
import sys
readline = sys.stdin.readline
sys.setrecursionlimit(10**8)
mod = 10**9+7
#mod = 998244353
INF = 10**18
eps = 10**-7
N = int(readline())
a = list(map(int,readline().split()))
s = 0
for ai in a:
s = s^ai
ans = []
for ai in a:
ans.append(s^ai)
print(' '.join(map(str,ans)))
| N = int(input())
L = sorted([int(i) for i in input().split()])
count = 0
from bisect import bisect_left as bi
for j in range(N):
for k in range(j + 1,N - 1):
right = L[j] + L[k]
ite_right = bi(L,right)
count = count + (ite_right - k - 1)
print(count) | 0 | null | 92,334,201,604,160 | 123 | 294 |
from collections import Counter
n = int(input())
a_input = list(map(int,input().split()))
a_count = Counter(a_input)
score_dic={}
exclude_dic={}
for k,v in a_count.items():
score_dic[k]=v*(v-1)//2
exclude_dic[k]=(v-1)*(v-2)//2
score_sum = sum(score_dic.values())
for i in range(n):
print(score_sum-score_dic[a_input[i]]+exclude_dic[a_input[i]])
| print(sum(i%2for i in map(int,[*open(0)][1].split()[::2]))) | 0 | null | 27,638,679,638,052 | 192 | 105 |
import sys
read = sys.stdin.buffer.read
readline = sys.stdin.buffer.readline
readlines = sys.stdin.buffer.readlines
n,m,k = map(int, readline().split())
a = list(map(int, readline().split()))
b = list(map(int, readline().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]
isb=m
ans = 0
for isa in range(n+1):
if sa[isa]>k:
break
#while isb>0 and sa[isa]+sb[isb]>k:
while sa[isa]+sb[isb]>k:
isb-=1
ans = max(ans, isa+isb)
print(ans) | N, M, K = map(int, input().split())
A = list(map(int, input().split()))
B = list(map(int, input().split()))
max_num = 0
j = 0
j_max = M
A_sums=[0]
B_sums=[0]
for i in range(N):
A_sums.append(A_sums[i]+A[i])
for i in range(M):
B_sums.append(B_sums[i]+B[i])
for i in range(N + 1):
j = 0
if A_sums[i]>K:
break
while A_sums[i]+B_sums[j_max] > K:
j_max -=1
max_num = max(max_num, i + j_max)
print(max_num)
| 1 | 10,754,980,962,772 | null | 117 | 117 |
import re
num = list(map(int, re.split('\s+', input())))
print(num[0] * num[1], end=" ")
print((num[0] + num[1]) * 2) | num = input().split();
a = int(num[0]);
b = int(num[1]);
print(a * b , a * 2 + b * 2); | 1 | 298,991,518,788 | null | 36 | 36 |
N = int(input())
a = N % 10
if a == 0 or a == 1 or a == 6 or a == 8:
print("pon")
elif a == 3:
print("bon")
else:
print("hon") | # -*- coding: utf-8 -*-
def main():
dictionary = {}
input_num = int(raw_input())
counter = 0
while counter < input_num:
command, key = raw_input().split(' ')
if command == 'insert':
dictionary[key] = True
else:
if key in dictionary:
print 'yes'
else:
print 'no'
counter += 1
if __name__ == '__main__':
main() | 0 | null | 9,593,211,954,346 | 142 | 23 |
c = []
def listcreate():
global c
c = []
for y in range(a[0]):
b = []
for x in range(a[1]):
if y == 0 or y == a[0]-1 or x == 0 or x == a[1]-1:
b.append("#")
else:
b.append(".")
c.append(b)
return
def listdraw():
global c
for y in range(len(c)):
for x in range(len(c[0])):
print(c[y][x], end='')
print()
return
for i in range(10000):
a = list(map(int,input().split()))
if sum(a)==0:
break
listcreate()
listdraw()
print()
| def solve(h, w):
print('#'*w,end='')
print(('\n#'+'.'*(w-2)+'#')*(h-2))
print('#'*w)
print()
if __name__ == '__main__':
while True:
h, w = [int(i) for i in input().split()]
if h == w == 0: break
solve(h, w) | 1 | 822,092,425,870 | null | 50 | 50 |
word = input()
num = int(input())
for index in range(num):
code = input().split()
instruction = code[0]
start, end = int(code[1]), int(code[2])
if instruction == "replace":
word = word[:start] + code[3] + word[end+1:]
elif instruction == "reverse":
reversed_ch = "".join(reversed(word[start:end+1]))
word = word[:start] + reversed_ch + word[end+1:]
else:
print(word[start:end+1])
| N = int(input())
xyp = []
xym = []
for _ in range(N):
x, y = map(int, input().split())
xyp.append(x+y)
xym.append(x-y)
xyp.sort()
xym.sort()
print(max(xyp[-1] - xyp[0], xym[-1] - xym[0])) | 0 | null | 2,708,395,667,740 | 68 | 80 |
a = list(input().split())
print("Yes" if len(set(a)) == 2 else "No") | l = list(map(int,input().split()))
#print(l)
if l[0]==l[1]!=l[2]:
print('Yes')
elif l[0]!=l[1]==l[2]:
print('Yes')
elif l[0]==l[2]!=l[1]:
print('Yes')
else:
print('No') | 1 | 68,273,763,052,112 | null | 216 | 216 |
import math
input()
xl = [int(s) for s in input().split()]
yl = [int(s) for s in input().split()]
m1 = 0
m2 = 0
m3 = 0
m4 = 0
for x, y in zip(xl, yl):
fabs = math.fabs(x - y)
m1 += fabs
m2 += fabs ** 2
m3 += fabs ** 3
m4 = max(fabs, m4)
print(m1)
print(math.pow(m2, 1/2))
print(math.pow(m3, 1/3))
print(m4) | from functools import lru_cache
@lru_cache(maxsize=None)
def fib(n):
if n <= 1:
return 1
else:
return fib(n - 1) + fib(n - 2)
n = int(input())
ans = fib(n)
print(ans) | 0 | null | 109,404,227,650 | 32 | 7 |
import sys
from collections import deque
N = int(input())
edge = [[] for _ in range(N)]
for i, s in enumerate(sys.stdin.readlines()):
a, b = map(int, s.split())
a -= 1; b -= 1
edge[a].append((b, i))
edge[b].append((a, i))
path = [None] * (N - 1)
q = deque()
q.append((0, 0))
while q:
v, pc = q.popleft()
c = 1
for nv, i in edge[v]:
if path[i] is None:
c = c + 1 if c == pc else c
path[i] = c
q.append((nv, c))
c += 1
print(max(path))
print(*path, sep='\n')
| H, _ = map(int, input().split())
A = list(map(int, input().split()))
if H <= sum(A):
print('Yes')
else:
print('No') | 0 | null | 107,241,987,523,284 | 272 | 226 |
#!/usr/bin/env python3
# Generated by https://github.com/kyuridenamida/atcoder-tools
from typing import *
import collections
import functools as fts
import itertools as its
import math
import sys
INF = float('inf')
def solve(A: int, B: int):
return max(A-2*B, 0)
def main():
sys.setrecursionlimit(10 ** 6)
def iterate_tokens():
for line in sys.stdin:
for word in line.split():
yield word
tokens = iterate_tokens()
A = int(next(tokens)) # type: int
B = int(next(tokens)) # type: int
print(f'{solve(A, B)}')
if __name__ == '__main__':
main()
| x1, y1, x2, y2 = map(float, input().split())
X = (x2 - x1)**2
Y = (y2 - y1)**2
distance = (X + Y)**(1/2)
print("%.8f" % (float(distance))) | 0 | null | 83,361,039,617,040 | 291 | 29 |
N = int(input())
L = []
for i in range(N):
s, t = input().split()
L.append((s, int(t)))
X = input()
ans = 0
f = False
for s, t in L:
if f:
ans += t
if s == X:
f = True
print(ans)
| N = int(input())
music = []
for i in range(N):
music.append(input().split())
X = (input())
Time = 0
kama = False
for s,t in music:
if kama:
Time += int(t)
if s == X:
kama = True
print(Time) | 1 | 96,863,290,992,004 | null | 243 | 243 |
n = int(input())
a = list(map(int, input().split()))
assert(len(a) == n)
ans = 0
for i in range(n):
if not i % 2 and a[i] % 2:
ans += 1
print(ans)
| k = int(input())
def rec(d, n, array):
array.append(n)
if d == 10:
return
for i in [-1, 0, 1]:
add = n % 10 + i
if 0 <= add <= 9:
rec(d + 1, 10 * n + add, array)
array = []
for i in range(1, 10):
rec(1, i, array)
s_array = sorted(array)
ans = s_array[k - 1]
print(ans) | 0 | null | 23,755,598,060,370 | 105 | 181 |
from sys import stdin
import math
import re
import queue
input = stdin.readline
MOD = 1000000007
INF = 122337203685477580
def solve():
A,B,M = map(int, input().split())
v1 =list(map(int, input().split()))
v2 =list(map(int, input().split()))
res = INF
for i in range(M):
X,Y,C = map(int, input().split())
res = min(res,v1[X-1] + v2[Y-1] - C)
res = min(res,min(v1) + min(v2))
res = max(0,res)
print(res)
if __name__ == '__main__':
solve()
| X,N = map(int,input().split())
N_List = list(map(int,input().split()))
ct = 0
pos = 0
while True:
if pos == 0:
if X not in N_List:
ans = X
break
else:
pos += 1
elif pos > 0:
if X-pos not in N_List:
ans = X - pos
break
elif X + pos not in N_List:
ans = X + pos
break
else:
pos += 1
print(ans) | 0 | null | 34,226,020,243,548 | 200 | 128 |
i = map(int, raw_input().split())
i.sort()
print "%d %d %d" %(i[0],i[1],i[2]) | a = map(int, raw_input().split())
a.sort()
for i in range(len(a)):
print a[i], | 1 | 415,834,611,296 | null | 40 | 40 |
mod = 10**9+7
n,k = map(int,input().split())
ans = 0
for i in range(k,n+2):
ans += (i*n-i*(i-1)+1)%mod
ans %=mod
print(ans) | n, k = map(int, input().split())
mod = 10**9 + 7
s = [0]*(n+1)
s[0] = n + 1
for i in range(1, n+1):
s[i] = (s[i-1] + n - 2 * i) % mod
ans = 0
for i in range(k-1, n+1):
ans += s[i]
ans %= mod
print(ans)
| 1 | 33,098,516,370,108 | null | 170 | 170 |
lst = []
for i in range(10):
lst.append(int(input()))
for j in range(3):
print max(lst)
lst.remove(max(lst)) | # coding: utf-8
list = []
for i in range(10):
list.append(int(input()))
slist = sorted(list)
for i in range(3):
print(slist[9-i]) | 1 | 30,887,408 | null | 2 | 2 |
x, y = map(int,input().split())
min = 2 * x
gap = y - min
if gap < 0 or gap > min:
print("No")
else:
if gap % 2 == 0:
print("Yes")
else:
print("No")
| x, y = map(int,input().split())
leg = 2*x
if y==leg:
print('Yes')
exit()
for i in range(1,x+1):
leg += 2
if y==leg:
print('Yes')
exit()
print('No') | 1 | 13,712,648,698,680 | null | 127 | 127 |
import sys
n = sys.stdin.readline()
s = sys.stdin.readline().split()
q = sys.stdin.readline()
t = sys.stdin.readline().split()
cnt = 0
for i in t:
if i in s:
cnt += 1
print(cnt) | def linearSearch(t):
i=0
s=S[:]+[t]
while s[i]!=t:
i+=1
if i==n:
return 0
return 1
n=int(input())
S=list(map(int,input().split()))
q=int(input())
T=list(map(int,input().split()))
C=0
for t in T:
C+=linearSearch(t)
print(C) | 1 | 64,133,495,370 | null | 22 | 22 |
a,b,c,d=map(int,input().split())
maxxy=max(a*c,a*d,b*c,b*d)
print(maxxy) | def calc_number_of_coin(sum, coins):
dp = [999999999]*(sum+1)
dp[0] = 0
for i in range(len(coins)):
for j in range(coins[i], sum+1):
dp[j] = min(dp[j], dp[j-coins[i]]+1)
return dp[sum]
if __name__ == '__main__':
# ??????????????\???
# f = open('input.txt')
# sum, _ = [int(x) for x in f.readline().strip().split(' ')]
# coins = [int(x) for x in f.readline().strip().split(' ')]
sum, _ = [int(x) for x in input().strip().split(' ')]
coins = [int(x) for x in input().strip().split(' ')]
# ???????????????
result = calc_number_of_coin(sum, coins)
# ???????????¨???
print(result) | 0 | null | 1,587,009,392,658 | 77 | 28 |
'''
Created on 2020/08/29
@author: harurun
'''
def main():
import sys
pin=sys.stdin.readline
pout=sys.stdout.write
perr=sys.stderr.write
A,B,N=map(int,pin().split())
x=min(B-1,N)
ans=int(A*x/B)-A*int(x/B)
print(ans)
return
main()
#解説AC | a,b,n = map(int,input().split())
i = min(b-1,n)
calc = (a*i)//b - (a * (i//b))
print(calc)
| 1 | 28,141,661,535,712 | null | 161 | 161 |
N = int(input())
senter = N // 1.08
for i in range(1000):
if int((senter-100+i) * 1.08) == N:
print(int(senter-100+i))
break
else:
print(":(")
| N, K = map(int, input().split())
A = [-1] * (N+1)
for i in range(K):
d_list = int(input())
B = input().split()
B = [int(x) for x in B]
for i in range(1, N+1):
if i in B:
A[i] = 1
count = 0
for i in range(1, N+1):
if A[i] == -1:
count += 1
print(count) | 0 | null | 75,346,909,076,880 | 265 | 154 |
N = int(input())
X = input()
pc = X.count("1")
if pc == 1:
if X[-1] == "0":
for i, s in enumerate(X):
if i == N - 1:
print(2)
elif s == "0":
print(1)
else:
print(0)
else:
ans = [2] * (N - 1) + [0]
print(*ans, sep="\n")
exit()
m01 = 0
m10 = 0
for i, s in enumerate(X[::-1]):
if s == "1":
m01 += pow(2, i, pc + 1)
m01 %= pc + 1
m10 += pow(2, i, pc - 1)
m10 %= pc - 1
memo = [-1] * 200005
def pop_count(T):
T = (T & 0x55555555) + ((T >> 1) & 0x55555555)
T = (T & 0x33333333) + ((T >> 2) & 0x33333333)
T = (T & 0x0F0F0F0F) + ((T >> 4) & 0x0F0F0F0F)
T = (T & 0x00FF00FF) + ((T >> 8) & 0x00FF00FF)
T = (T & 0x0000FFFF) + ((T >> 16) & 0x0000FFFF)
return T
def F(n):
if memo[n] != -1:
return memo[n]
if n == 0:
return 0
memo[n] = F(n % pop_count(n)) + 1
return memo[n]
ans = [0] * N
for i, s in enumerate(X[::-1]):
if s == "0":
m = m01
m += pow(2, i, pc+1)
m %= pc + 1
else:
m = m10
m -= pow(2, i, pc-1)
m %= pc - 1
ans[i] = F(m) + 1
print(*ans[::-1], sep="\n")
| def readinput():
n=int(input())
x=input()
return n,x
poptbl=[0]*(2*10**5+1)
def popcount(x):
global poptbl
#if poptbl[x]!=0:
# return poptbl[x]
poptbl[x]=bin(x).count('1')
return poptbl[x]
ftbl=[0]*(2*10**5+1)
def f(x):
global ftbl
#if ftbl[x]!=0:
# return ftbl[x]
#print('f(x), x: {}'.format(x))
if x==0:
return 0
else:
ans=f(x%popcount(x))+1
#print(ans)
ftbl[x]=ans
return ans
def main():
n=int(input())
x=input()
m=x.count('1')
#print('m: {}'.format(m))
xint=int(x,2)
#print('xint: {}'.format(xint))
if m!=1:
xmodm1=xint%(m-1)
else:
xmodm1=1
xmodp1=xint%(m+1)
pow2mod1=[0]*n
pow2mod2=[0]*n
pow2mod1[0]=1
pow2mod2[0]=1
for i in range(1,n):
if m!=1:
pow2mod1[i]=pow2mod1[i-1]*2 % (m-1)
pow2mod2[i]=pow2mod2[i-1]*2 % (m+1)
ans=[]
#b=2**(n-1)
for i in range(n):
if x[i]=='1':
if m==1:
a=0
ans.append(a)
else:
xx=( xmodm1 + (m-1) -pow2mod1[n-i-1] )%(m-1)
#ans.append(f(xx)+1)
a=f(xx)+1
ans.append(a)
else:
xx=( xmodp1 + pow2mod2[n-i-1] )%(m+1)
#ans.append(f(xx)+1)
a=f(xx)+1
ans.append(a)
#b=b//2
print(a)
return ans
if __name__=='__main__':
#n,x=readinput()
ans=main()
#for a in ans:
# print(a)
| 1 | 8,201,244,073,660 | null | 107 | 107 |
S, T = input().split(' ')
print(T + S)
| import sys
d = -float('inf')
n = int(input())
l = int(input())
for s in sys.stdin:
r = int(s)
d = max(d, r-l)
l = min(l, r)
print(d)
| 0 | null | 51,764,177,684,700 | 248 | 13 |
# Forbidden List
X, N = [int(i) for i in input().split()]
pi = [int(i) for i in input().split()]
pl = []
pu = []
for i in pi:
if i <= X:
pl.append(i)
if X <= X:
pu.append(i)
pl.sort(reverse=True)
pu.sort()
nl = X
for i in pl:
if i == nl:
nl -= 1
nu = X
for i in pu:
if i == nu:
nu += 1
if X - nl <= nu - X:
print(nl)
else:
print(nu)
| from bisect import bisect_left
X, N = list(map(int, input().split()))
P = list(map(int, input().split()))
P.sort()
S = set(P)
if N == 0:
print(X)
exit()
def bisectsearch_left(L, a):
i = bisect_left(L, a)
return(i)
k = bisectsearch_left(P, X)
if X != P[k]:
print(X)
else:
ct = 0
while True:
ct += 1
if X-ct not in S:
print(X-ct)
break
elif X+ct not in S:
print(X+ct)
break | 1 | 14,164,722,145,120 | null | 128 | 128 |
n,m,k = map(int, input().split())
g = [[] for i in range(n+1)]
f = [0]*(n+1)
b = []
for i in range(m):
u, v = map(int, input().split())
g[u].append(v)
g[v].append(u)
f[u] += 1
f[v] += 1
for i in range(k):
b.append(map(int, input().split()))
count = 0
renketu_list = [-1]*(n+1)
renketu_size = [0]
stack = []
for i in range(1, n+1):
if renketu_list[i] == -1:
count += 1
renketu_list[i] = count
renketu_size.append(1)
while len(g[i]) > 0:
stack.append(g[i].pop())
while len(stack) > 0:
v=stack.pop()
if renketu_list[v] == -1:
renketu_list[v] = count
renketu_size[count] += 1
while len(g[v])>0:
stack.append(g[v].pop())
s = [0] * (n+1)
for i in range(1, n+1):
s[i] += renketu_size[renketu_list[i]] - f[i] - 1
for i in range(k):
u, v = b[i]
if renketu_list[u] == renketu_list[v]:
s[u] -= 1
s[v] -= 1
print(" ".join(list(map(str, s[1:]))))
| import sys
sys.setrecursionlimit(10 ** 7)
input = sys.stdin.readline
f_inf = float('inf')
mod = 10 ** 9 + 7
def resolve():
T1, T2 = map(int, input().split())
A1, A2 = map(int, input().split())
B1, B2 = map(int, input().split())
P = (A1 - B1) * T1
Q = (A2 - B2) * T2
if P > 0:
P *= -1
Q *= -1
if P + Q < 0:
print(0)
elif P + Q == 0:
print("infinity")
else:
S = (-P) // (P + Q)
T = (-P) % (P + Q)
if T != 0:
print(S * 2 + 1)
else:
print(S * 2)
if __name__ == '__main__':
resolve()
| 0 | null | 96,644,893,568,420 | 209 | 269 |
n = int(input())
s = input()
# 3桁の番号を作るにあたり、文字列から抽出して作るのではなく、000〜999までの組み合わせが存在するかを確認する。
ans = 0
for i in range(10):
a = s.find(str(i))
for j in range(10):
b = s.find(str(j), a+1) # aの取得位置の次から検索を行う
for k in range(10):
c = s.find(str(k), b+1) # bの取得位置の次から検索を行う
if a == -1 or b == -1 or c == -1: continue
else: ans += 1
print(ans) | n,k = map(int,input().split())
A = [0]
A.extend(list(map(int,input().split())))
town = 1
once = [0]*(n+1)
for i in range(n):
if once[town]==0:
once[town] = 1
else:
break
town = A[town]
rt = A[town]
roop = 1
while rt != town:
rt = A[rt]
roop += 1
rt = 1
bf = 0
while rt != town:
rt = A[rt]
bf += 1
if bf<k:
K = (k-bf)%roop + bf
else:
K = k
town = 1
for _ in range(K):
town = A[town]
print(town) | 0 | null | 75,436,195,691,388 | 267 | 150 |
# nikkei2019-2-qualA - Sum of Two Integers
def main():
N = int(input())
ans = (N - 1) // 2
print(ans)
if __name__ == "__main__":
main() | while True:
(n, x) = [int(i) for i in input().split()]
if n == x == 0:
break
count = 0
for a in range(1, n + 1):
for b in range(a + 1, n + 1):
for c in range(b + 1, n + 1):
if sum([a,b,c]) == x:
count += 1
print(count) | 0 | null | 76,955,431,462,546 | 283 | 58 |
N = list(map(int, list(input())))
L = len(N)
K = int(input())
dp = [[[0] * (K+1) for j in range(2)] for i in range(L+1)]
dp[0][0][0] = 1
for i in range(L):
ni = N[i]
if ni == 0:
for j in range(K):
dp[i+1][1][j+1] += dp[i][1][j] * 9
for j in range(K+1):
dp[i+1][0][j] += dp[i][0][j]
else:
for j in range(K+1):
dp[i+1][1][j] += dp[i][0][j]
for j in range(K):
dp[i+1][1][j+1] += (dp[i][0][j] * (ni-1) + dp[i][1][j] * 9)
dp[i+1][0][j+1] += dp[i][0][j]
for j in range(K+1):
dp[i+1][1][j] += dp[i][1][j]
print(dp[L][0][K]+dp[L][1][K]) | from statistics import median
N = int(input())
A = []
B = []
for n in range(N):
a, b = map(int, input().split())
A.append(a)
B.append(b)
#AB = sorted(AB, key=lambda x: x[0])
#print(AB)
cenA = median(A)
cenB = median(B)
if N % 2 == 1:
print(int(cenB - cenA + 1))
elif N % 2 == 0:
print(int((cenB - cenA)*2 + 1))
else:
print('RE') | 0 | null | 46,857,173,066,340 | 224 | 137 |
z = input()
a = list(map(int, z.split()))
cnt = 0
for i in range(a[0], a[1] + 1, 1):
if a[2] % i == 0:
cnt += 1
print(cnt) | n = int(input())
MOD = 10**9+7
from math import gcd
zero = 0
cnt = {}
for i in range(n):
a,b = map(int,input().split())
if a ==0 and b==0:
zero += 1
continue
g = gcd(a,b)
a//=g
b//=g
if b<0:
a*=-1
b*=-1
if b==0 and a<0:
a *= -1
if a<=0:
a,b = b,-a
if (a,b) in cnt:
cnt[(a,b)][0] += 1
else:
cnt[(a,b)] = [1,0]
else:
if (a,b) in cnt:
cnt[(a,b)][1] += 1
else:
cnt[(a,b)] = [0,1]
ans = 1
for i,v in cnt.items():
ans *= 1 + pow(2,v[0],MOD)-1 + pow(2,v[1],MOD)-1
ans %= MOD
print((zero-1+ans)%MOD) | 0 | null | 10,756,513,297,892 | 44 | 146 |
N, K = list(map(int, input().split()))
RSP = list(map(int, input().split()))
D = {'r': 0, 's': 1, 'p': 2}
T = input()
M = N//K
dp = [[[0]*3 for _ in range(M+(i < (N % K)))] for i in range(K)]
# print(dp)
def wins(i, s):
j = D[s]
return i % 3 == (j-1) % 3
ans = 0
for i in range(K):
L = dp[i]
for k in range(3):
L[0][k] = RSP[k]*wins(k, T[i])
for j in range(1, len(L)):
for k in range(3):
L[j][k] = max(L[j-1][l] + RSP[k]*wins(k, T[i+j*K])
for l in range(3) if k != l)
# print(L)
ans += max(L[-1][k] for k in range(3))
print(ans)
| def main():
N, K = map(int, input().split())
R, S, P = map(int, input().split())
d = {'r': R, 's': S, 'p': P}
T = input()
scores = []
for t in T:
if t == 'r':
scores.append('p')
elif t == 's':
scores.append('r')
else:
scores.append('s')
for i in range(N-K):
if scores[i] == scores[i+K]:
scores[i+K] = 0
print(sum([d[v] for v in scores if v in ['p', 'r', 's']]))
if __name__ == '__main__':
main()
| 1 | 106,739,661,415,200 | null | 251 | 251 |
def main():
n,*d=map(int,open(0).read().split())
e=[0]*n
for i in d:e[i]+=1
a=1if d[0]<1else 0
for i in d[1:]:a=a*e[i-1]%998244353
print(a)
main() | N, K = map(int, input().split())
A = tuple(map(int, input().split()))
T = input()
bestmove = {'r':2, 's':0, 'p':1}
ans = 0
for k in range(K):
t = T[k::K]
prev = -1
for opp in t:
me = bestmove[opp]
if prev != me:
prev = me
ans += A[me]
else:
prev = -1
print(ans)
| 0 | null | 131,052,711,585,824 | 284 | 251 |
n = int(input())
li_a = list(map(int, input().split()))
answer = 0
for idx, v in enumerate(li_a, start=1):
if idx %2 != 0 and v %2 != 0:
answer += 1
print(answer)
| # -*- coding: utf-8 -*-
import sys
import os
import math
n = int(input())
A = list(map(int, input().split()))
cnt = 0
def merge(A, left, mid, right):
global cnt
S = A[left:mid]
T = A[mid:right]
S.append(float('inf'))
T.append(float('inf'))
s_i = 0
t_i = 0
for i in range(right - left):
cnt += 1
if S[s_i] < T[t_i]:
A[left + i] = S[s_i]
s_i += 1
else:
A[left + i] = T[t_i]
t_i += 1
def merge_sort(A, left, right):
if left + 1 == right:
# ???????????????
return
else:
# ??????????????????
mid = (left + right) // 2
merge_sort(A, left, mid)
merge_sort(A, mid, right)
merge(A, left, mid, right)
merge_sort(A, 0, len(A))
print(*A)
print(cnt) | 0 | null | 3,892,493,139,880 | 105 | 26 |
n,k = map(int,input().split())
a = list(map(int,input().split()))
temp,i = sum(a[:k]),k
for _ in range(n-k):
score = temp+a[i]-a[i-k]
print("Yes" if score>temp else "No")
temp = score
i+=1 | N,K=map(int,input().split())
A=list(map(int,input().split()))
hyoutei=[0]*(N+1)
for i in range(K,N):#K+1-N
if A[i]/A[i-K]>1:
print("Yes")
else:
print("No")
| 1 | 7,066,036,098,652 | null | 102 | 102 |
N,K = map(int,input().split())
if N % K >= abs(N % K - K):
print(abs(N % K - K))
else:
print(N % K) | score = list(map(int,input().split()))
amari = score[0] % score[1]
kouho = score[1] - amari
if amari < kouho:
print(amari)
else:
print(kouho) | 1 | 39,219,793,588,822 | null | 180 | 180 |
import sys
MOD = 10**9 + 7
def sum_from_to(fr, to):
return (to - fr + 1) * (fr + to) // 2 % MOD
def main():
input = sys.stdin.buffer.readline
n, k = map(int, input().split())
ans = 0
for i in range(k, n + 2):
ans += sum_from_to(n - i + 1, n) - sum_from_to(0, i - 1) + 1
ans %= MOD
print(ans)
if __name__ == '__main__':
main()
| from itertools import combinations
def f(s):
n, x = list(map(int, s.split()))
return len(tuple(filter(lambda it: sum(it) == x,
combinations(range(1, n+1), 3))))
while True:
s = input()
if s == "0 0":
break
print(f(s)) | 0 | null | 17,330,624,445,280 | 170 | 58 |
x=int(input())
k=1
while k*x%360:k+=1
print(k) | N,M,K=map(int, input().split())
MOD=998244353
ans=0
temp2=1
#temp4=(M-1)**(N-1)%MOD
def getInvs(n, MOD):
invs = [1] * (n+1)
for x in range(2, n+1):
invs[x] = (-(MOD//x) * invs[MOD%x]) % MOD
return invs
invs = getInvs(max(N+3,M-1), MOD)
Vec=[0]*N
#inv=1
#for i in range(MOD-2):
# inv*=M-1
# inv%=MOD
'''
for i in range(K+1):
if i == 0:
temp1=M
temp1*=(M-1)**(N-1)%MOD
temp1%=MOD
ans+=temp1*temp2%MOD
#print(cmb)
else:
temp1*=invs[M-1]%MOD
temp2*=(N-i)*invs[i]
temp2%=MOD
ans+=temp1*temp2%MOD
cmb=cmb*(N-i-1)*i*invs[i]%MOD
#print(cmb)
'''
for i in range(N):
if i == 0:
temp1=M
Vec[N-i-1]=temp1
else:
temp1*=(M-1)*(N-i)
temp1*=invs[i]
temp1%=MOD
Vec[N-i-1]=temp1
ans=sum(Vec[:K+1])
print(ans%MOD)
| 0 | null | 18,308,695,431,168 | 125 | 151 |
class UnionFind():
def __init__(self, n):
self.n = n
self.parents = [-1] * n
def find(self, x):
"""
要素xが属するグループの根を返す
"""
if self.parents[x] < 0:
return x
else:
self.parents[x] = self.find(self.parents[x])
return self.parents[x]
def union(self, x, y):
"""
要素xが属するグループと要素yが属するグループとを併合する
"""
x = self.find(x)
y = self.find(y)
if x == y:
return
if self.parents[x] > self.parents[y]:
x, y = y, x
self.parents[x] += self.parents[y]
self.parents[y] = x
def size(self, x):
"""
要素xが属するグループのサイズ（要素数）を返す
"""
return -self.parents[self.find(x)]
def same(self, x, y):
"""
要素x, yが同じグループに属するかどうかを返す
"""
return self.find(x) == self.find(y)
def members(self, x):
"""
要素xが属するグループに属する要素をリストで返す
"""
root = self.find(x)
return [i for i in range(self.n) if self.find(i) == root]
def roots(self):
"""
すべての根の要素をリストで返す
"""
return [i for i, x in enumerate(self.parents) if x < 0]
def group_count(self):
"""
グループの数を返す
"""
return len(self.roots())
def all_group_members(self):
"""
{ルート要素: [そのグループに含まれる要素のリスト], ...}の辞書を返す
"""
return {r: self.members(r) for r in self.roots()}
def __str__(self):
return '\n'.join('{}: {}'.format(r, self.members(r)) for r in self.roots())
def main():
N, M = map(int, input().split())
A_B = [list(map(int, input().split())) for i in range(M)]
uf = UnionFind(N)
for i in range(M):
x = A_B[i][0] - 1
y = A_B[i][1] - 1
uf.union(x, y)
ans = 1
for i in range(N):
ans = max(ans, uf.size(i))
print(ans)
return
if __name__ == '__main__':
main() | def main():
H, W, M = map(int, input().split())
cnth = [[0, i] for i in range(H)]
cntw = [[0, i] for i in range(W)]
L = set()
for _ in range(M):
h, w = map(lambda x: int(x) - 1, input().split())
cnth[h][0] += 1
cntw[w][0] += 1
L.add((h, w))
cnth.sort(reverse=True)
cntw.sort(reverse=True)
mh = set()
ph = cnth[0]
for h in cnth:
if ph[0] == h[0]:
mh.add(h[1])
else:
break
ph = h
mw = set()
pw = cntw[0]
for w in cntw:
if pw[0] == w[0]:
mw.add(w[1])
else:
break
pw = w
maxans = cnth[0][0] + cntw[0][0]
for h in mh:
for w in mw:
if not ((h, w) in L):
print(maxans)
break
else:
continue
break
else:
print(maxans - 1)
if __name__ == "__main__":
main() | 0 | null | 4,310,416,321,260 | 84 | 89 |
s = input()
n = len(s)
dp = [0 for _ in range(n)]
dp[-1] = int(s[-1])
cnt_dic = {}
tmp = 1
ans = 0
cnt_dic[0] = 1
cnt_dic[dp[-1]] = 1
for i in range(n-2, -1, -1):
dp[i] = (dp[i+1] + int(s[i]) * pow(10, n-i-1, 2019)) % 2019
if not dp[i] in cnt_dic:
cnt_dic[dp[i]] = 0
ans += cnt_dic[dp[i]]
cnt_dic[dp[i]] += 1
print(ans) | def some():
n, k = map(int, input().split(" "))
h = map(int, input().split(" "))
print(len([i for i in h if i >= k]))
some() | 0 | null | 104,948,319,886,860 | 166 | 298 |
def main():
s, t = input().split(' ')
print(t, end='')
print(s)
if __name__ == '__main__':
main()
| MOD = 10 ** 9 + 7
# https://qiita.com/drken/items/3b4fdf0a78e7a138cd9a#3-1-mod-p-%E3%81%AE%E4%B8%96%E7%95%8C%E3%81%AB%E3%81%8A%E3%81%91%E3%82%8B%E5%89%B2%E3%82%8A%E7%AE%97%E3%81%A8%E3%81%AF
def modinv(a):
b = MOD
u = 1
v = 0
while b != 0:
t = a // b
a -= t * b
a, b = b, a
u -= t * v
u, v = v, u
u %= MOD
if u < 0:
u += MOD
return u
n, k = list(map(int, input().split()))
a = list(map(int, input().split()))
# a = [e for e in a if e != 0]
# if len(a) < k:
# print(0)
# exit()
a.sort(key=lambda x: abs(x), reverse=True)
b = a[:k]
c = a[k:]
n = 0
pro_abs_b = 1
for e in b:
if e < 0:
n += 1
pro_abs_b *= abs(e)
pro_abs_b %= MOD
pro_b = (-1)**n * pro_abs_b % MOD
n_ = 0
pro_abs_ = 1
for e in a[len(a) - k:]:
if e < 0:
n_ += 1
pro_abs_ *= abs(e)
pro_abs_ %= MOD
pro_ = (-1) ** n_ * pro_abs_ % MOD
if n % 2 == 0:
print(pro_b)
exit()
anses = []
last_posinb = None
last_neginb = None
for e in b:
if e > 0:
last_posinb = e
if e < 0:
last_neginb = e
first_posinc = None
first_neginc = None
for e in reversed(c):
if e > 0:
first_posinc = e
if e < 0:
first_neginc = e
# print(last_posinb, last_neginb)
# print(first_posinc, first_neginc)
if last_posinb is not None and first_neginc is not None:
anses.append((-first_neginc / last_posinb, pro_b *
modinv(last_posinb) * first_neginc % MOD))
if last_neginb is not None and first_posinc is not None:
anses.append((-first_posinc / last_neginb, pro_b *
modinv(last_neginb) * first_posinc % MOD))
if len(anses) != 0:
print(max(anses)[1])
else:
print(pro_)
| 0 | null | 56,277,079,378,378 | 248 | 112 |
h, n = map(int, input().split())
a, b = [], []
for _ in range(n):
A, B = map(int, input().split())
a.append(A)
b.append(B)
a_max = max(a)
dp = [0]*(h+a_max)
for i in range(h+a_max):
dp[i] = min(dp[i-a] + b for a, b in zip(a, b))
print(min(dp[h-1:])) | #!/usr/bin/env python3
wd = "SUN MON TUE WED THU FRI SAT".split()
wd = list(reversed(wd))
def solve(S: str):
idx = wd.index(S)
return idx+1
def main():
S = input().strip()
answer = solve(S)
print(answer)
if __name__ == '__main__':
main()
| 0 | null | 107,205,833,715,058 | 229 | 270 |
h1, m1, h2, m2, k = [int(i) for i in input().split()]
m1 += h1 * 60
m2 += h2 * 60
m = 0
if m1 == m2:
m = 24 * 60
elif m1 < m2:
m = m2 - m1
else:
m = 24 * 60 - (m1 - m2)
print(m - k) | #!/usr/bin/python3
# -*- coding: utf-8 -*-
import sys
while True:
s = sys.stdin.readline().strip()
if s == '0':
break
total = 0
for c in s:
total += int(c)
print(total)
| 0 | null | 9,774,417,616,480 | 139 | 62 |
N,K=map(int,input().split())
H=list(map(int,input().split()))
ans=0
for h in H:
if K<=h:
ans=ans+1
print(ans)
| n, k = list(map(int, input().split(' ')))
print(sum([tall >= k for tall in list(map(int, input().split(' ')))])) | 1 | 179,133,585,936,252 | null | 298 | 298 |
a = [input() for i in range(2)]
b = [int(s) for s in a]
print(6 - sum(b)) | A = int(input())
B = int(input())
for x in range(1, 4):
if x not in [A, B]:
print(x)
break
| 1 | 110,830,568,541,250 | null | 254 | 254 |
# coding: utf-8
def main():
N, A, B = map(int, input().split())
ans = (B - A) // 2 if (B - A) % 2 == 0 else min(A - 1, N - B) + 1 + (B - A - 1) // 2
print(ans)
if __name__ == "__main__":
main()
| import numpy as np
def min_steps_v2(n, a, b):
n = np.int64(n)
a = np.int64(a)
b = np.int64(b)
if (b - a) % 2 == 0:
return np.int64(int(b - a) // 2)
# odd case
a_diff = a - 1
b_diff = n - b
if a_diff > b_diff:
steps_to_even = n - b + 1
remain_steps = min_steps_v2(n, a + (n - b) + 1, n)
else:
steps_to_even = a
remain_steps = min_steps_v2(n, 1, b - a)
return steps_to_even + remain_steps
numbers = input().split(' ')
n = int(numbers[0])
a = int(numbers[1])
b = int(numbers[2])
print(min_steps_v2(n, a, b))
| 1 | 109,173,269,042,240 | null | 253 | 253 |
n,m=list(map(int, input("").split()))
h=list(map(int, input("").split()))
o=[]
for i in range(n):
o.append(1)
for i in range(m):
a,b=list(map(int, input("").split()))
if h[a-1] <=h[b-1]:
o[a-1]=0
if h[a-1] >=h[b-1]:
o[b-1]=0
print(sum(o)) | from collections import defaultdict
d=defaultdict(list)
n ,m =list(map(int,input().split()))
h=list(map(int,input().split()))
for i in range(m):
a,b=list(map(int,input().split()))
d[a].append(b)
d[b].append(a)
s=0
for c in d:
k=0
for v in d[c]:
if h[c-1]<=h[v-1]:
k=1
break
#print(c,k,d)
if k==0:
s+=1
s+=n-len(d)
print(s) | 1 | 25,003,546,106,170 | null | 155 | 155 |
def solve():
h, a = map(int, input().split())
print(-(-h//a))
if __name__ == '__main__':
solve()
| n,a,b=map(int,input().split())
MOD=10**9+7
def inv(a):
return pow(a,MOD-2,MOD)
def choose(n,r):
if r==0 or r==n:
return 1
else:
A=B=1
for i in range(r):
A=A*(n-i)%MOD
B=B*(i+1)%MOD
return A*inv(B)%MOD
print((pow(2,n,MOD)-1-choose(n,a)-choose(n,b))%MOD) | 0 | null | 71,520,040,861,402 | 225 | 214 |
s = input()
n = len(s)
kotae = "x"*n
print(kotae) | import sys
sys.setrecursionlimit(10**7)
input = sys.stdin.readline
s = input().rstrip()
n = len(s)
print('x'*n)
| 1 | 72,674,178,222,740 | null | 221 | 221 |
x = input().split(" ")
if int(x[2]) - int(x[4]) >= 0 and int(x[3]) - int(x[4]) >= 0 and int(x[2]) + int(x[4]) <= int(x[0]) and int(x[3]) + int(x[4]) <= int(x[1]) :
print("Yes")
else:
print("No")
| if __name__ == "__main__":
N = int(input())
mod = N % 1000
q = N // 1000
if mod != 0:
q += 1
ans = 1000 * q - N
print(ans) | 0 | null | 4,470,522,463,870 | 41 | 108 |
import math
A, B, H, M = map(int, input().split())
c = math.cos(math.radians(360 - abs(30 * H + 0.5 * M - 6 * M)))
X_2 = A ** 2 + B ** 2 - 2 * A * B * c
X = math.sqrt(X_2)
print(X) | """
○ 角速度 = θ / t [rad/s]
・時針
ω = θ / t
= math.radians(360) / (12 * 60 * 60) [rad/s]
・分針
ω = θ / t
= math.radians(360) / (60 * 60) [rad/s]
"""
import math
def colon():
# 入力
A, B, H, M = map(int, input().split())
# 時針と分針の角速度
angular_velocity_h = math.radians(360) / (12 * 60 * 60)
angular_velocity_m = math.radians(360) / (60 * 60)
# 0時を基準に時針が何度傾いたか
radian_h = angular_velocity_h * ((H * 60 * 60) + (M * 60))
# 0時を基準に分針が何度傾いたか
radian_m = angular_velocity_m * (M * 60)
# 時針と分針の間の角度
radian_hm = abs(radian_h - radian_m)
if radian_hm > math.pi:
radian_hm = 2 * math.pi - radian_hm
elif radian_hm == math.pi:
return A + B
elif math.pi > radian_hm:
pass
# 端点の距離
distance = math.sqrt((A**2 + B**2) - (2 * A * B * math.cos(radian_hm)))
# 戻り値
return distance
result = colon()
print(result) | 1 | 20,068,923,242,972 | null | 144 | 144 |
def flg(s):
le = len(s) // 2
return s[:le] == s[::-1][:le]
s = input()
le1 = len(s) // 2
t = s[:le1]
print(["No", "Yes"][flg(s) and flg(t)]) | def input_int():
return map(int, input().split())
def one_int():
return int(input())
def one_str():
return input()
def many_int():
return list(map(int, input().split()))
import math
from decimal import Decimal
A, B = input().split()
# A=int(A)
# B=float(B)
temp = Decimal(A)*Decimal(B)
print(int(math.floor(temp))) | 0 | null | 31,400,829,059,556 | 190 | 135 |
# Problem B - Common Raccoon vs Monster
# input
H, N = map(int, input().split())
a_nums = list(map(int, input().split()))
# initialization
a_sum = sum(a_nums)
# output
if a_sum>=H:
print("Yes")
else:
print("No")
| a,b,c=map(int,input().split())
if a==b==c or (a!=b!=c and a!=c!=b):
print("No")
else:
print("Yes")
| 0 | null | 73,341,692,731,820 | 226 | 216 |
n, k = map(int, input().split())
r, s, p = map(int, input().split())
t = input()
dict = {'s': r, 'p': s, 'r': p}
cnt, ans = set(), 0
for i, ti in enumerate(t):
if (i - k in cnt) and ti == t[i - k]:
continue
ans += dict[ti]
cnt.add(i)
print(ans)
| import math
N = int(input())
X = list(map(int, input().split()))
def average(a):
return sum(a) / len(a)
avg = average(X)
res = 0
if avg - int(avg) >= 0.5:
for i in X:
res += (i - math.ceil(avg)) **2
else:
for i in X:
res += (i - math.floor(avg)) ** 2
print(res) | 0 | null | 86,438,888,364,828 | 251 | 213 |
from collections import deque
n = int(input())
dll = deque()
for i in range(n):
input_line = input().split()
if input_line[0] == "insert":
dll.appendleft(input_line[1])
elif len(dll) == 0:
continue
elif input_line[0] == "delete":
try:
dll.remove(input_line[1])
except:
pass
elif input_line[0] == "deleteFirst":
dll.popleft()
else:
dll.pop()
print(*dll) | class Node(object):
def __init__(self, num, prv = None, nxt = None):
self.num = num
self.prv = prv
self.nxt = nxt
class DoublyLinkedList(object):
def __init__(self):
self.start = self.last = None
def insert(self, num):
new_elem = Node(num)
if self.start is None:
self.start = self.last = new_elem
else:
new_elem.nxt = self.start
self.start.prv = new_elem
self.start = new_elem
def delete_num(self, target):
it = self.start
while it is not None:
if it.num == target:
if it.prv is None and it.nxt is None:
self.start = self.last = None
else:
if it.prv is not None:
it.prv.nxt = it.nxt
else:
self.start = self.start.nxt
if it.nxt is not None:
it.nxt.prv = it.prv
else:
self.last = self.last.prv
break
it = it.nxt
def delete_start(self):
if self.start is self.last:
self.start = self.last = None
else:
self.start.nxt.prv = None
self.start = self.start.nxt
def delete_last(self):
if self.start is self.last:
self.start = self.last = None
else:
self.last.prv.nxt = None
self.last = self.last.prv
def get_content(self):
ret = []
it = self.start
while it is not None:
ret.append(it.num)
it = it.nxt
return ' '.join(ret)
def _main():
from sys import stdin
n = int(input())
lst = DoublyLinkedList()
for _ in range(n):
cmd = stdin.readline().strip().split()
if cmd[0] == 'insert':
lst.insert(cmd[1])
elif cmd[0] == 'delete':
lst.delete_num(cmd[1])
elif cmd[0] == 'deleteFirst':
lst.delete_start()
elif cmd[0] == 'deleteLast':
lst.delete_last()
print(lst.get_content())
if __name__ == '__main__':
_main()
| 1 | 50,798,451,898 | null | 20 | 20 |
n=int(input())
a=list(map(int,input().split()))
sum_a=sum(a)
x=0
i=0
while x<sum_a/2:
x+=a[i]
i+=1
if n%2==0:
print(min(x-(sum_a-x),sum_a-(x-a[i-1])*2))
else:
print(x-(sum_a-x)) | import sys
def selection_sort(x):
count = 0
for i in range(0,len(l)-1):
mini = i
for j in range(i+1,len(l)):
if(x[j] < x[mini]):
mini = j
if(mini != i):
count += 1
temp = x[i]
x[i] = x[mini]
x[mini] = temp
for data in x:
print data,
print
print count
l = []
for input in sys.stdin:
l.append(input)
l = l[1:]
l = l[0].split()
for i in range(0,len(l)):
l[i] = int(l[i])
selection_sort(l)
| 0 | null | 71,374,659,999,228 | 276 | 15 |
def main():
N = int(input())
digits = []
while N != 0:
digits.append(N % 26)
if digits[-1] == 0:
digits[-1] = 26
N //= 26
N -= 1
else:
N //= 26
digits.reverse()
for d in digits:
print(chr(96 + d), end='')
print() # 改行
if __name__ == '__main__':
main()
| from itertools import accumulate
a=[]
for i in range(12):
a.append(26**i)
b=list(accumulate(a))
alpha=['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']
N=int(input())
num=0
for i in range(12):
if N < b[i] :
num=i
break
M=N-b[num-1]
r=M
for i in range(num):
q=r//26**(num-i-1)
r=r%26**(num-i-1)
print(alpha[q],end='') | 1 | 11,862,567,645,052 | null | 121 | 121 |
N = int(input())
A = list(map(int, input().split()))
t = 0
for c in A:
t ^= c
ans = []
for b in A:
ans.append(t^b)
print(*ans) | n,k=map(int,input().split())
mod=10**9+7
U = 4*10**5+1
MOD = 10**9+7
fact = [1]*(U+1)
fact_inv = [1]*(U+1)
for i in range(1,U+1):
fact[i] = (fact[i-1]*i)%MOD
fact_inv[U] = pow(fact[U],MOD-2,MOD)
for i in range(U,0,-1):
fact_inv[i-1] = (fact_inv[i]*i)%MOD
def comb(n,k):
if k < 0 or k > n:
return 0
x = fact[n]
x *= fact_inv[k]
x %= MOD
x *= fact_inv[n-k]
x %= MOD
return x
if n-1<=k:
print(comb(2*n-1,n-1))
else:
ans=0
for i in range(1+k):
ans+=comb(n,i)*comb(n-1,n-i-1)
ans%=mod
print(ans)
| 0 | null | 39,937,549,504,816 | 123 | 215 |
if __name__ == '__main__':
# ??????????????\???
my_cards = [] # ????????¶?????\??????????????????????????§
card_num = int(input())
for i in range(card_num):
data = [x for x in input().split(' ')]
suit = data[0]
rank = int(data[1])
my_cards.append((suit, rank))
full_cards = [] # 52?????¨????????£??????????????????
for r in range(1, 13+1):
full_cards.append(('S', r))
full_cards.append(('H', r))
full_cards.append(('D', r))
full_cards.append(('C', r))
# ??????????????¨???????¶??????????????¢???????????????°??????????????????
missing_cards = set(my_cards) ^ set(full_cards)
missing_spades = [x for x in missing_cards if x[0]=='S']
missing_hearts = [x for x in missing_cards if x[0] == 'H']
missing_clubs = [x for x in missing_cards if x[0] == 'C']
missing_diamonds = [x for x in missing_cards if x[0] == 'D']
missing_spades.sort(key=lambda x: x[1])
missing_hearts.sort(key=lambda x: x[1])
missing_clubs.sort(key=lambda x: x[1])
missing_diamonds.sort(key=lambda x: x[1])
# ????¶???????????????¨???
for s, r in missing_spades:
print('{0} {1}'.format(s, r))
for s, r in missing_hearts:
print('{0} {1}'.format(s, r))
for s, r in missing_clubs:
print('{0} {1}'.format(s, r))
for s, r in missing_diamonds:
print('{0} {1}'.format(s, r)) | n = int(input())
full_set=set([1,2,3,4,5,6,7,8,9,10,11,12,13])
S=[]
H=[]
C=[]
D=[]
for i in range(n):
suit,num = input().split()
if suit=="S": S.append(int(num))
elif suit=="H": H.append(int(num))
elif suit=="C": C.append(int(num))
elif suit=="D": D.append(int(num))
S_set=set(S)
H_set=set(H)
C_set=set(C)
D_set=set(D)
for (suit,suit_set) in zip(["S","H","C","D"],[S_set,H_set,C_set,D_set]):
for num in sorted(list(full_set - suit_set)): print(suit,num) | 1 | 1,048,653,562,678 | null | 54 | 54 |
a, b, c = list(map(int, input().split()))
if a == b == c:
print('No')
elif a == b:
print('Yes')
elif b == c:
print('Yes')
elif a == c:
print('Yes')
else:
print('No')
| a, b, c = map(int, input().split())
ret = "No"
if (a == b and a != c) or (b == c and c != a) or (c == a and a != b):
ret = "Yes"
print("{}".format(ret)) | 1 | 68,059,694,927,992 | null | 216 | 216 |
import sys
import math
a = []
for line in sys.stdin:
a.append(line)
for n in a:
inl=n.split()
num1=int(inl[0])
check=1
list=[]
while check<=math.sqrt(num1):
if num1%check==0:
list.append(check)
list.append(num1/check)
check+=1
list.sort()
list.reverse()
num2=int(inl[1])
for i in list:
if num2%i==0:
gud=i
break
lcm=num1*num2/gud
print gud,lcm | import sys
for l in sys.stdin:
x,y=map(int, l.split())
m=x*y
while x%y:x,y=y,x%y
print "%d %d"%(y,m/y) | 1 | 718,360,972 | null | 5 | 5 |
S=input()
S2=S[:(len(S)-1)//2]
S3=S[(len(S)+3)//2-1:]
if S==S[::-1] and S2==S2[::-1] and S3==S3[::-1]:
print("Yes")
else:
print("No") | def flg(s):
le = len(s) // 2
return s[:le] == s[::-1][:le]
s = input()
le1 = len(s) // 2
t = s[:le1]
print(["No", "Yes"][flg(s) and flg(t)]) | 1 | 46,093,885,213,248 | null | 190 | 190 |
n = int(input())
A = input().split(' ')
count = 0
for i in range(0, n):
minj = i
for j in range(i, n):
if int(A[j]) < int(A[minj]):
minj = j
if i != minj:
(A[i], A[minj]) = (A[minj], A[i])
count += 1
print(" ".join(A))
print(count) | if(str(input()).islower()):
print("a")
else:
print("A") | 0 | null | 5,620,912,752,448 | 15 | 119 |
from math import ceil,floor,factorial,gcd,sqrt,log2,cos,sin,tan,acos,asin,atan,degrees,radians,pi,inf
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 MAP1() : return map(lambda x:int(x)-1,input().split())
def LIST() : return list(MAP())
class UnionFind():
def __init__(self, n):
self.n = n
self.parents = [-1] * n
def find(self, x):
if self.parents[x] < 0:
return x
else:
self.parents[x] = self.find(self.parents[x])
return self.parents[x]
def union(self, x, y):
x = self.find(x)
y = self.find(y)
if x == y:
return
if self.parents[x] > self.parents[y]:
x, y = y, x
self.parents[x] += self.parents[y]
self.parents[y] = x
def size(self, x):
return -self.parents[self.find(x)]
def same(self, x, y):
return self.find(x) == self.find(y)
def members(self, x):
root = self.find(x)
return [i for i in range(self.n) if self.find(i) == root]
def roots(self):
return [i for i, x in enumerate(self.parents) if x < 0]
def group_count(self):
return len(self.roots())
def all_group_members(self):
return {r: self.members(r) for r in self.roots()}
def __str__(self):
return '\n'.join('{}: {}'.format(r, self.members(r)) for r in self.roots())
def solve():
N, M, K = MAP()
F = [[] for _ in range(N)]
B = [[] for _ in range(N)]
uf = UnionFind(N) # 初期化
for i in range(M):
a, b = MAP()
F[a-1].append(b-1)
F[b-1].append(a-1)
uf.union(a-1, b-1) # グループを併合
for i in range(K):
c, d = MAP()
B[c-1].append(d-1)
B[d-1].append(c-1)
for i in range(N):
ans = uf.size(i) - len(F[i]) - 1
for x in B[i]:
if uf.same(i, x):
ans -= 1
print(ans)
if __name__ == '__main__':
solve() | N,M,K=map(int,input().split())
par=[0]*(N+1)
num=[0]*(N+1)
group = [1]*(N+1)
for i in range(1,N+1): par[i]=i
def root(x):
if par[x]==x: return x
return root(par[x])
def union(x,y):
rx = root(x)
ry = root(y)
if rx==ry: return
par[max(rx,ry)] = min(rx,ry)
group[min(rx,ry)] += group[max(rx,ry)]
def same(x,y):
return root(x)==root(y)
for _ in range(M):
a,b=map(int,input().split())
union(a,b)
num[a]+=1
num[b]+=1
for _ in range(K):
c,d=map(int,input().split())
if same(c,d):
num[c]+=1
num[d]+=1
for i in range(1,N+1):
print(group[root(i)]-num[i]-1,end=" ") | 1 | 61,587,993,917,280 | null | 209 | 209 |
n, p = map(int, input().split())
s = [int(i) for i in input()]
p_cnt = 0
if p == 2 or p == 5:
for i in range(n):
if s[i] % p == 0:
p_cnt += i+1
else:
s = s[::-1]
div_dic = dict(zip(range(p), [0] * p))
tmp = 0
for i in range(n):
tmp += s[i] * pow(10, i, p)
tmp %= p
div_dic[tmp] += 1
for v in div_dic.values():
p_cnt += v * (v - 1)
p_cnt //= 2
p_cnt += div_dic.get(0)
print(p_cnt) | from collections import Counter
n,p = map(int,input().split())
S = input()
dp = [0]
mod = p
if p==2:
ans =0
for i in reversed(range(n)):
if int(S[i])%2==0:
ans += i+1
print(ans);exit()
elif p==5:
ans =0
for i in reversed(range(n)):
if int(S[i])%5==0:
ans += i+1
print(ans);exit()
for i in reversed(range(n)):
dp.append(dp[-1]%mod + pow(10,n-1-i,mod)*int(S[i]))
dp[-1]%=mod
count = Counter(dp)
ans = 0
for key,val in count.items():
if val>=2:
ans += val*(val-1)//2
print(ans) | 1 | 57,999,128,440,638 | null | 205 | 205 |
n, m, l = map(int,input().split())
a = list()
for i in range(n):
a.append(list(map(int,input().split())))
b = list()
for i in range(m):
b.append(list(map(int,input().split())))
for i in range(n):
line = list()
for j in range(l):
c = 0
for k in range(m):
c += a[i][k] * b[k][j]
line.append(str(c))
print(' '.join(line))
| n, m, l = list(map(int, input().split()))
a = [[int(j) for j in input().split()] for i in range(n)]
b = [[int(j) for j in input().split()] for i in range(m)]
c = [[0 for j in range(l)] for i in range(n)]
for i in range(n):
for j in range(l):
value = 0
for k in range(m):
value = value + a[i][k] * b[k][j]
c[i][j] = value
for i in c:
print(*i)
| 1 | 1,417,082,362,940 | null | 60 | 60 |
import sys
import itertools
# import numpy as np
import time
import math
sys.setrecursionlimit(10 ** 7)
from collections import defaultdict
read = sys.stdin.buffer.read
readline = sys.stdin.buffer.readline
readlines = sys.stdin.buffer.readlines
N = int(input())
c = [[0 for i in range(10)] for _ in range(10)]
def f(n):
x = 0
while n > 0:
n //= 10
x +=1
return x
for i in range(1, N + 1):
d = f(i)
front = i // (10 ** (d - 1))
back = i % 10
c[front][back] += 1
ans = 0
for i in range(1, 10):
for j in range(1, 10):
ans += c[i][j] * c[j][i]
print(ans)
| import string
ab = string.ascii_lowercase
bc = ab[1:] + 'a'
c = input()
for a, b in zip(ab, bc):
if a == c:
print(b)
| 0 | null | 89,019,489,927,620 | 234 | 239 |
N = int(input())
for i in range(1, 10):
for k in range(1, 10):
if(i*k == N):
print('Yes')
exit(0)
print('No')
| n = int(input())
def binary_search(l, target):
left = 0
right = len(l)
while left<right:
mid = (left+right)//2
if target == l[mid]:
return True
elif target < l[mid]:
right = mid
else:
left = mid+1
return False
seki = [i*j for i in range(1, 10) for j in range(1, 10)]
seki.sort()
if binary_search(seki, n):
print('Yes')
else:
print('No') | 1 | 160,059,416,335,340 | null | 287 | 287 |
n=int(input())
N=10**4+20;M=103
a=[0 for _ in range(N)]
for x in range(1,M):
for y in range(1,M):
for z in range(1,M):
res=x*x+y*y+z*z+x*y+y*z+z*x;
if res<N:a[res]+=1
for i in range(n):
print(a[i+1]) | # ans
N = int(input())
ans = [0] * (N + 1)
for x in range(1, 101):
for y in range(1, 101):
for z in range(1, 101):
n = x * x + y * y + z * z + x * y + y * z + z * x
if n <= N:
ans[n] += 1
for i in range(1, len(ans)):
print(ans[i]) | 1 | 8,013,620,414,590 | null | 106 | 106 |
a=input()
b=input()
c=a*2
if b in c:
print("Yes")
else:
print("No")
| s = input()
p = input()
for e, i in enumerate(s):
if i == p[0]:
temp = s[e:] + s[:e]
if p in temp:
print('Yes')
break
else:
print('No') | 1 | 1,727,546,900,520 | null | 64 | 64 |
n, k = map(int, input().split())
MOD = 1000000007
def combinations(n, r, MOD):
if (r < 0) or (n < r):
return 0
r = min(r, n - r)
return fact[n] * fact_inv[r] * fact_inv[n - r] % MOD
fact = [1, 1]
fact_inv = [1, 1]
inv = [0, 1]
for i in range(2, n + 1):
fact.append((fact[-1] * i) % MOD)
inv.append((-inv[MOD % i] * (MOD // i)) % MOD)
fact_inv.append((fact_inv[-1] * inv[-1]) % MOD)
s = 0
for num_zero in range(min(k + 1, n)):
# nCz
x = combinations(n, num_zero, MOD)
# n-zCx
y = combinations(n - 1, n - num_zero - 1, MOD)
s += (x * y) % MOD
print(s % MOD)
| #nの約数を列挙する関数
import math
def n_div(n):
div_list = []
import math
for i in range(1, math.ceil(math.sqrt(n))+1):
if n % i ==0:
div_list.append(i)
if i*i ==n:
continue
div_list.append(n//i)
div_list.sort()
return div_list
n = int(input())
lr = n_div(n)
#print(lr)
if len(lr) % 2==0:
a = len(lr)/2
a = int(a)
ans = lr[a]+lr[a-1]-2
else:
a = math.floor(len(lr)/2)
#print(a)
ans = lr[a]*2 -2
print(ans) | 0 | null | 114,503,748,835,308 | 215 | 288 |
n = int(input())
songs = []
for i in range(n):
s,t = map(str,input().split())
t = int(t)
songs.append([s,t])
x = input()
number = 0
for i in range(n):
if songs[i][0] == x:
number = i + 1
#print("number: " + str(number))
ans = 0
for j in range(number,n):
ans += songs[j][1]
print(ans)
| #coding: UTF-8
import math
def PF(a):
for k in range(len(a)):
area = ""
H = int(a[k].split(" ")[0])
W = int(a[k].split(" ")[1])
if H == 0 and W == 0:
break
for j in range(H):
if j == 0 or j == (H-1):
for i in range(W):
area += "#"
else:
area = "#"
for i in range(1,W-1):
area += "."
area += "#"
print(area)
area = ""
print("")
if __name__=="__main__":
a = []
for i in range(300):
a.append(input())
if a[i] == "0 0":
break
PF(a) | 0 | null | 48,688,507,370,160 | 243 | 50 |
import sys
input = sys.stdin.readline
N = int(input())
S = input()
ans = S.count("R") * S.count("G") * S.count("B")
for i in range(N-2):
for j in range(i+1, N-1):
k = 2 * j - i
if k < N:
A, B, C = S[i], S[j], S[k]
if A != B and B != C and C != A: ans -= 1
print(ans)
| N = int(input())
S = str(input())
r_cnt = S.count('R')
g_cnt = S.count('G')
b_cnt = S.count('B')
ans = r_cnt*g_cnt*b_cnt
for i in range(N):
for d in range(1, N):
j = i + d
k = j + d
if k >= N:break
if S[i]!=S[j] and S[i]!=S[k] and S[j]!=S[k]:
ans -= 1
print(ans) | 1 | 35,928,316,169,820 | null | 175 | 175 |
from collections import defaultdict
from itertools import groupby, accumulate, product, permutations, combinations
from bisect import *
def solve():
ans = 0
N = int(input())
S = input()
d = defaultdict(lambda: [])
for i,s in enumerate(S):
d[int(s)].append(i)
for p in product(range(10),repeat=3):
if not len(d[p[0]]):
continue
ind1 = d[p[0]][0]
ind2 = bisect_right(d[p[1]],ind1)
if ind2==len(d[p[1]]):
continue
ind2 = d[p[1]][ind2]
ind3 = bisect_right(d[p[2]],ind2)
if ind3==len(d[p[2]]):
continue
ans += 1
return ans
print(solve()) | n=int(input())
s=input()
ans=0
for i in range(1000):
cs=str(i).zfill(3)
p=0
for c in cs:
p=s.find(c,p)
if p==-1:
break
p+=1
else:
ans+=1
print(ans) | 1 | 129,165,126,129,500 | null | 267 | 267 |
a = input()
alp = [chr(i) for i in range(ord('a'),ord('z')+1)]
if a in alp:
print('a')
else:
print('A') | a = input()
print('a' if a.islower() else 'A') | 1 | 11,312,854,370,690 | null | 119 | 119 |
N, K = map(int ,input().split())
A = [int(x) for x in input().split()]
checked = [False] * N
root=[0]
idx = 0
checked[0]=True
for k in range(K):
root.append(A[idx]-1)
idx = A[idx]-1
if (checked[idx]):
break
checked[idx]=True
else:
print(idx+1)
exit(0)
for i, r in enumerate(root):
if r == root[-1]:
break
root2=root[i:]
l = len(root2)-1
idx = root2[(K-i)%(l)]
print(idx+1)
| "TLE"
N, K = map(int, input().split())
A_list = list(map(int, input().split()))
A_dir_list = []
A_visit_list = [-1 for i in range(N)]
dir = 0
while True:
A_dir_list.append(dir)
A_visit_list[dir] = 1
if A_visit_list[A_list[dir]-1] == -1:
dir = A_list[dir]-1
else:
cycle_pos = A_dir_list.index(A_list[dir]-1)
break
if K < cycle_pos:
print(A_dir_list[K]+1)
else:
cnt = (K-cycle_pos)%(len(A_dir_list)-cycle_pos)
print(A_dir_list[cnt+cycle_pos]+1)
| 1 | 22,898,435,427,454 | null | 150 | 150 |
a,b=map(int,input().split())
c=0
d=0
if a<b:
c=a
else:
c=b
for i in range(1,c+1):
if a%i==0 and b%i==0:
d=i
print(a*b//d) | a,b=map(int,input().split())
import fractions
r=(a*b)//fractions.gcd(a,b)
print(r) | 1 | 113,622,673,230,260 | null | 256 | 256 |
N, K = (int(x) for x in input().split())
listN = [1] * N
# N is population / K is candy
for i in range(K):
d = int(input())
tmp = map(int, input().split())
for j in tmp:
listN[j-1] = 0
print(sum(listN))
| N, K = map(int, input().split())
have_sweets = []
for i in range(K):
d = int(input())
have_sweets += list(map(int, input().split()))
have_sweets = set(have_sweets)
print(len(list(set([i for i in range(1, N+1)])-have_sweets)))
| 1 | 24,729,768,899,592 | null | 154 | 154 |
x=int(input())
X=x
k=1
while X%360!=0:
k+=1
X+=x
print(k) | import collections
N,*S = open(0).read().split()
C = collections.Counter(S)
i = C.most_common()[0][1]
print(*sorted([k for k,v in C.most_common() if v == i]), sep='\n') | 0 | null | 41,400,328,454,286 | 125 | 218 |
N = int(input())
a = list(map(int, input().split()))
n = 1
C = 0
for ai in a:
if ai != n:
C += 1
else:
n += 1
if n == 1:
print('-1')
else:
print(C) | import sys
import math
from heapq import *
import fractions
from collections import defaultdict
stdin = sys.stdin
ns = lambda: stdin.readline().rstrip()
ni = lambda: int(stdin.readline().rstrip())
nm = lambda: map(int, stdin.readline().split())
nl = lambda: list(map(int, stdin.readline().split()))
N=int(input())
n_l=[[0]*10 for i in range(10)]#col matu row sentou
for i in range(1,N+1):
if(1<=i and i<10):
n_l[i][i]+=1
elif(10<i and i<10**2):
n_l[i%10][i//10]+=1
elif(10**2<i and i<10**3):
n_l[i%10][i//100]+=1
elif(10**3<i and i<10**4):
n_l[i%10][i//1000]+=1
elif(10**4<i and i<10**5):
n_l[i%10][i//10000]+=1
elif(10**5<i):
n_l[i%10][i//100000]+=1
ans=0
for i in range(1,10):
for k in range(1,10):
if(i!=k):
ans+=(n_l[i][k])*((n_l[k][i]))
for i in range(1,10):
ans+=(n_l[i][i])*((n_l[i][i]))
print(ans)
| 0 | null | 100,252,709,382,154 | 257 | 234 |
contests = ['ABC', 'ARC']
before_contest = input()
print(contests[0] if before_contest == contests[1] else contests[1]) | X,Y = map(int,input().split())
turtle_leg = 4
crane_leg = 2
for i in range(X+1):
if Y == turtle_leg*i+crane_leg*(X-i):
print ("Yes")
break
if i==X:
print ("No")
break | 0 | null | 18,929,045,553,070 | 153 | 127 |
N = int(input())
if N == 2:
print(1)
exit()
ans = 0
def factorization(n):
lis = []
if n % 2 == 0:
c = 0
while n%2 == 0:
n //= 2
c += 1
lis.append([2, c])
k = 3
while k*k <= n:
if n%k == 0:
c = 0
while n%k == 0:
n //= k
c += 1
lis.append([k, c])
else:
k += 2
if n > 1:
lis.append([n, 1])
return lis
list1 = factorization(N-1)
ans1 = 1
for k in range(len(list1)):
ans1 *= list1[k][1]+1
ans += ans1-1
def operation(K):
n = N
while n%K == 0:
n //= K
if n%K == 1:
return True
else:
return False
list2 = factorization(N)
factorlist = [1]
for l in range(len(list2)):
list3 = []
for j in range(list2[l][1]):
for k in range(len(factorlist)):
list3.append(factorlist[k]*list2[l][0]**(j+1))
factorlist += list3
factorlist = factorlist[1:-1]
ans += 1
for item in factorlist:
if operation(item):
ans +=1
print(ans) | def make_divisors(n):
lower_divisors , upper_divisors = [], []
i = 1
while i*i <= n:
if n % i == 0:
lower_divisors.append(i)
if i != n // i:
upper_divisors.append(n//i)
i += 1
return lower_divisors + upper_divisors[::-1]
n = int(input())
l = make_divisors(n - 1)
l2 = make_divisors(n)
del l2[0]
ans = len(l) - 1
for i in l2:
k2 = n
while True:
if k2 % i == 1:
ans += 1
k2 /= i
if k2 % 1 != 0:
break
print(ans) | 1 | 41,367,477,698,100 | null | 183 | 183 |
A,B = list(map(int,input().split()))
print(int(A*B)) | import sys
input = sys.stdin.readline
ins = lambda: input().rstrip()
ini = lambda: int(input().rstrip())
inm = lambda: map(int, input().split())
inl = lambda: list(map(int, input().split()))
a, b = inm()
print(a * b) | 1 | 15,792,127,194,602 | null | 133 | 133 |
N = int(input())
X = list(map(int, input().split()))
MOD = 10 ** 9 + 7
ans = 0
for b in range(61):
ctr = [0, 0]
for i in range(N):
ctr[X[i] >> b & 1] += 1
ans += (1 << b) * ctr[0] * ctr[1]
ans %= MOD
print(ans)
| from string import ascii_lowercase
a = input()
if a in ascii_lowercase:
print("a")
else:
print("A") | 0 | null | 66,855,162,255,108 | 263 | 119 |
n=int(input())
if n%2!=0:
print(0)
else:
ans=0
t=10
while True:
ans=ans+n//t
t=t*5
if n//t==0:
break
print(ans) | 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 = int(readline())
if N % 2:
print(0)
return
ans = 0
N //= 2
while N:
N //= 5
ans += N
print(ans)
return
if __name__ == '__main__':
main()
| 1 | 115,858,437,286,082 | null | 258 | 258 |
import itertools
n,m = map(int, input().split())
ball = [2*i for i in range(1,n+1)] + [(2*j)-1 for j in range(1,m+1)]
cnt = 0
for c in itertools.combinations(ball,2):
cnt += sum(c)%2 == 0
print(cnt) | N , M = map(int,input().split())
ans = 0
ans += N * (N - 1) // 2
ans += M * (M - 1) // 2
print( ans ) | 1 | 45,328,049,917,712 | null | 189 | 189 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.