code1
stringlengths 16
24.5k
| code2
stringlengths 16
24.5k
| similar
int64 0
1
| pair_id
int64 2
181,637B
⌀ | question_pair_id
float64 3.71M
180,628B
⌀ | code1_group
int64 1
299
| code2_group
int64 1
299
|
---|---|---|---|---|---|---|
s = list(input())
if s.count('A') == 3 or s.count('B') == 3:
print('No')
else:
print('Yes')
|
S=input()
a=S.count("A")
b=S.count("B")
if a==3 or b==3:
print("No")
else:
print("Yes")
| 1 | 55,029,790,602,512 | null | 201 | 201 |
def solve():
s=input()
if(len(s)%2==0):
print("No")
return
else :
n=len(s)//2
str1=s[:n]
str2=s[n+1:]
# print(str1,str2)
if(str1==str2):
print("Yes")
else:
print("No")
if __name__ == "__main__":
solve()
|
S = input()
N = len(S)
ans = 'No'
# 文字列strの反転は、str[::-1]
if S == S[::-1] and S[:(N-1)//2] == S[:(N-1)//2][::-1] and S[(N+1)//2:] == S[(N+1)//2:][::-1]:
ans = 'Yes'
print(ans)
| 1 | 46,096,442,764,778 | null | 190 | 190 |
s = "hi"
S = input()
flag = False
for i in range(5):
if S==s:
flag=True
break
s = s+"hi"
if flag:
print("Yes")
else:
print("No")
|
from math import gcd as g
a, b = map(int, input().split())
print((a*b)//g(a,b))
| 0 | null | 83,332,033,393,210 | 199 | 256 |
while True:
a, b = map(int, input().split())
if a == b == 0:
break
for i in range(a):
if i == 0 or i == a - 1:
print('#' * b)
continue
print('#', '.' * (b - 2), '#', sep = '')
print()
|
n, t = map(int,input().split())
ab = [list(map(int,input().split())) for i in range(n)]
ab = sorted(ab, key=lambda x:(x[0]))
t -= 1
dp = [[0]*(t+1) for i in range(n+1)]
for i in range(1, n+1):
ca, cb = ab[i-1][0], ab[i-1][1]
for j in range(1, t+1):
if j - ca >= 0:
dp[i][j] = max(dp[i-1][j], dp[i-1][j-ca] + cb)
else:
dp[i][j] = dp[i-1][j]
b_max = [0]
tmp = 0
for i in range(n-1, -1, -1):
tmp = max(tmp, ab[i][1])
b_max = [tmp] + b_max
ans = 0
for i in range(n+1):
ans = max(ans, dp[i][t] + b_max[i])
# print(dp[i][t] + b_max[i])
print(ans)
| 0 | null | 75,864,341,486,258 | 50 | 282 |
a,b,c,d = map(int, input().split())
i = 0
while a > 0 and c > 0:
if i%2 == 0:
c -= b
else:
a -= d
i += 1
if a > c:
print('Yes')
else:
print('No')
|
import math
A,B,C,D = map(int, input().split())
Taka=A/D
Aoki=C/B
if math.ceil(Taka)>=math.ceil(Aoki):
print("Yes")
else:
print("No")
| 1 | 29,763,013,703,490 | null | 164 | 164 |
import sys
tscore = hscore = 0
n = int( sys.stdin.readline() )
for i in range( n ):
tcard, hcard = sys.stdin.readline().rstrip().split( " " )
if tcard < hcard:
hscore += 3
elif hcard < tcard:
tscore += 3
else:
hscore += 1
tscore += 1
print( "{:d} {:d}".format( tscore, hscore ) )
|
a, b, c, k = map(int, input().split())
ans = 0
if a >= k:
ans = k * 1
else:
ans = a * 1 + max(0, (k - a)) * 0 + max(0, (k - a - b)) * (-1)
print(ans)
| 0 | null | 11,899,994,758,080 | 67 | 148 |
n = int(input())
a = [int(x) for x in input().split()]
print(*a)
for i in range(1, n):
k, j = a[i], i-1
while j >= 0 and a[j] > k:
a[j+1], j = a[j], j-1
a[j+1] = k
print(*a)
|
N = int(input())
A = list(map(int,input().split()))
for i in range(N):
v = A[i]
j = i - 1
while j >= 0 and A[j] > v:
A[j+1] = A[j]
j -= 1
A[j+1] = v
print(" ".join(map(str, A)))
| 1 | 5,663,861,688 | null | 10 | 10 |
f=lambda:map(int,input().split())
n,st,sa=f()
g=[set() for _ in range(n)]
for _ in range(n-1):
a,b=f()
g[a-1].add(b-1)
g[b-1].add(a-1)
def bfs(s):
l=[-1]*n; l[s]=0; q=[s]
while q:
v=q.pop(); d=l[v]+1
for c in g[v]:
if l[c]<0: l[c]=d; q+=[c]
return l
lt=bfs(st-1)
la=bfs(sa-1)
print(max(la[i] for i in range(n) if lt[i]<la[i])-1)
|
#!/usr/bin/env python
# -*- coding: utf-8 -*-
import sys
sys.setrecursionlimit(10**7)
from pprint import pprint as pp
from pprint import pformat as pf
# @pysnooper.snoop()
#import pysnooper # debug
import math
#from sortedcontainers import SortedList, SortedDict, SortedSet # no in atcoder
import bisect
from fractions import Fraction
from collections import defaultdict
def is_same_sign(a, b):
if a > 0 and b > 0:
return True
if a < 0 and b < 0:
return True
return False
def fraction_taple(a, b):
g = math.gcd(a, b)
if is_same_sign(a, b):
s = 1
else:
s = -1
a = abs(a) // g
b = abs(b) // g
return (s, a, b)
def mode(a, b):
# retrun dict_key, arr_key
if a == 0 and b == 0:
return 0, 0
if a == 0:
return 'ab', 0
if b == 0:
return 'ab', 1
x = fraction_taple(a, b)
y = fraction_taple(-1 * b, a)
if x > y:
return x, 0
else:
return y, 1
MOD = 1000000007
if __name__ == '__main__':
n = int(input())
d = defaultdict(lambda: [0, 0])
zero = 0
for _ in range(n):
a, b = list(map(int, input().split()))
dkey, akey = mode(a, b)
if dkey == 0:
zero += 1
else:
d[dkey][akey] += 1
#print('d') # debug
#pp(d) # debug
ans = 1
for pair in d.values():
tmp = pow(2, pair[0], MOD) - 1 + pow(2, pair[1], MOD) - 1 + 1
ans *= tmp
ans += zero - 1
ans %= MOD
#print('ans') # debug
print(ans)
#print('\33[32m' + 'end' + '\033[0m') # debug
| 0 | null | 69,389,330,364,072 | 259 | 146 |
# -*- coding: utf-8 -*-
a = [int(raw_input()) for _ in range(10)]
#print a
b = sorted(a, reverse=True)
#print b
for c in b[0:3]:
print c
|
inputNum = []
for i in range(0, 10):
inputNum.append(int(raw_input()))
inputNum.sort(reverse=True)
for i in range(0, 3):
print inputNum[i]
| 1 | 17,239,792 | null | 2 | 2 |
from math import floor,ceil,sqrt,factorial,log
from collections import Counter, deque
from functools import reduce
import numpy as np
import itertools
def S(): return input()
def I(): return int(input())
def MS(): return map(str,input().split())
def MI(): return map(int,input().split())
def FLI(): return [int(i) for i in input().split()]
def LS(): return list(MS())
def LI(): return list(MI())
def LLS(): return [list(map(str, l.split() )) for l in input()]
def LLI(): return [list(map(int, l.split() )) for l in input()]
def LLSN(n: int): return [LS() for _ in range(n)]
def LLIN(n: int): return [LI() for _ in range(n)]
s = S()
cnt = 0
max = 0
for i in s:
if i == "R":
cnt += 1
else:
if max < cnt:
max = cnt
cnt = 0
if max < cnt:
max = cnt
print(max)
|
#abc17a
s=input()
if 'RRR' in s:
print(3)
elif 'RR' in s:
print(2)
elif 'R' in s:
print(1)
else:
print(0)
| 1 | 4,859,878,120,672 | null | 90 | 90 |
s=input()
if s=="SUN":print(7)
elif s=="MON":print(6)
elif s=="TUE":print(5)
elif s=="WED":print(4)
elif s=="THU":print(3)
elif s=="FRI":print(2)
elif s=="SAT":print(1)
|
#!/usr/bin/env python3
s = input()
l = ['MON', 'TUE', 'WED', 'THU', 'FRI', 'SAT', 'SUN']
if s == 'SUN':
print(7)
else:
print(6 - l.index(s))
| 1 | 133,560,284,577,020 | null | 270 | 270 |
"""
Template written to be used by Python Programmers.
Use at your own risk!!!!
Owned by enraged(rating - 5 star at CodeChef and Specialist at Codeforces).
"""
import sys
import bisect
import heapq
# from math import *
from collections import defaultdict as dd # defaultdict(<datatype>) Free of KeyError.
from collections import deque # deque(list) append(), appendleft(), pop(), popleft() - O(1)
from collections import Counter as c # Counter(list) return a dict with {key: count}
from itertools import combinations as comb
from bisect import bisect_left as bl, bisect_right as br, bisect
# sys.setrecursionlimit(2*pow(10, 6))
# sys.stdin = open("input.txt", "r")
# sys.stdout = open("output.txt", "w")
mod = pow(10, 9) + 7
mod2 = 998244353
def data(): return sys.stdin.readline().strip()
def out(var): sys.stdout.write(var)
def l(): return list(map(int, data().split()))
def sl(): return list(map(str, data().split()))
def sp(): return map(int, data().split())
def ssp(): return map(str, data().split())
def l1d(n, val=0): return [val for i in range(n)]
def l2d(n, m, val=0): return [[val for i in range(n)] for j in range(m)]
n, p = sp()
s = data()
answer = 0
if p == 2:
for i in range(n):
if (ord(s[i])-ord('0')) % 2 == 0:
answer += (i+1)
elif p == 5:
for i in range(n):
if int(s[i]) % 5 == 0:
answer += (i+1)
else:
dp = dd(int)
dp[0] += 1
a, tens = 0, 1
for i in range(n-1, -1, -1):
a = (a + int(s[i]) * tens) % p
answer += dp[a]
dp[a] += 1
tens = (tens * 10) % p
out(str(answer))
exit(0)
|
N, P = map(int, input().split())
S = input()
if P == 2:
ans = 0
for i, d in enumerate(map(int, S)):
if d % 2 == 0:
ans += i+1
print(ans)
elif P == 5:
ans = 0
for i, d in enumerate(map(int, S)):
if d % 5 == 0:
ans += i+1
print(ans)
else:
mods = [0] * P
mods[0] = 1
cur_mod = 0
for i, digit in enumerate(map(int, S)):
cur_mod += pow(10, N-i-1, P) * digit
cur_mod %= P
mods[cur_mod] += 1
ans = 0
for count in mods:
ans += count * (count - 1) // 2
print(ans)
| 1 | 58,203,421,786,902 | null | 205 | 205 |
H, W = map(int, input().split())
if (H==1 or W==1):
print(1)
elif (H%2==0):
H /=2
print(int(H*W))
else:
H //= 2
if(W%2==0):
print(int(H*W+(W/2)))
else:
print(int(H*W+(W//2+1)))
|
H, W = map(int, input().split())
total = H*W
if H == 1 or W == 1:
ans = 1
elif total % 2 == 0:
ans = total//2
else:
total += 1
ans = total//2
print(ans)
| 1 | 50,728,512,004,156 | null | 196 | 196 |
N=input()
N=int(N)
q1, mod = divmod(N,2)
if mod == 0:
print(q1)
else:
print(q1 + 1)
|
S = int(input())
a = (S // 2) + (S % 2)
print(int(a))
| 1 | 59,202,521,715,052 | null | 206 | 206 |
R = int(input())
import math
nagasa = R*2 * math.pi
print(nagasa)
|
R=int(input())
print(2*3.14159265*R)
| 1 | 31,458,670,450,918 | null | 167 | 167 |
def readinput():
n=int(input())
a=list(map(int,input().split()))
return n,a
def main(n,a):
aa=[]
for i in range(n):
aa.append((i+1,a[i]))
aa.sort(key=lambda x:x[1])
b=[]
for i in range(n):
b.append(aa[i][0])
return b
if __name__=='__main__':
n,a=readinput()
ans=main(n,a)
print(' '.join(map(str,ans)))
|
n=int(input())
s=list(map(int,input().split()))
p=[0]*n
for i in range(n):
p[s[i]-1]=i+1
print(*p)
| 1 | 180,723,399,840,612 | null | 299 | 299 |
import bisect
n = int(input())
l = list(map(int, input().split()))
l = sorted(l)
cnt = 0
for i in range(n):
for j in range(i+1, n):
x = bisect.bisect_left(l, l[i]+l[j])
cnt += x-j-1
print(cnt)
|
n=int(input())
a=[]
while n>26:
n=n-1
a.append(chr(ord('a') + n%26))
n=n//26
n=n-1
a.append(chr(ord('a') + n%26))
a.reverse()
print("".join(a))
| 0 | null | 91,969,557,007,858 | 294 | 121 |
s,t = map(int,input().split())
if t >= s:
print("unsafe")
else:
print("safe")
|
import copy
def main():
h, o = map(int, input().split(' '))
if h <= o:
print('unsafe')
else:
print('safe')
main()
| 1 | 29,196,947,489,840 | null | 163 | 163 |
def main():
M1, D1 = map(int, input().split())
M2, D2 = map(int, input().split())
print(int(M1 != M2))
if __name__ == '__main__':
main()
|
m1,d1=map(int,input().split())
m2,d2=map(int,input().split())
if (m1+1)%13==m2:
if d2==1:
print(1)
exit()
print(0)
| 1 | 123,822,308,902,160 | null | 264 | 264 |
# D - Road to Millionaire
def million(n, a):
wallet = 1000
i = 0
while i < n - 1:
highest_price = a[i]
cheapest_price = a[i]
# 直近の最高値と最安値を取得する
for j in range(i + 1, n):
if highest_price > a[j]:
break
if highest_price < a[j]:
highest_price = a[j]
if cheapest_price > a[j]:
cheapest_price = a[j]
if highest_price > cheapest_price:
# 取引する
stock = wallet // cheapest_price
wallet = wallet - stock * cheapest_price
wallet = wallet + stock * highest_price
i = j
else:
i += 1
return wallet
if __name__ == "__main__":
n = int(input())
a = list(map(int, input().split()))
print(million(n, a))
|
n = int(input())
a = list(map(int, input().split()))
cash = 1000
for buy, sell in zip(a, a[1:]):
if buy >= sell:
continue
stock, cash = divmod(cash, buy)
cash += stock * sell
print(cash)
| 1 | 7,341,605,629,380 | null | 103 | 103 |
# -*- coding: utf-8 -*-
import sys
import os
import math
a, b = list(map(int, input().split()))
# a?????§?????????????????????
if b > a:
a, b = b, a
def gcd(a, b):
if b == 0:
return a
else:
return gcd(b, a % b)
result = gcd(a, b)
print(result)
|
#! python3
# greatest_common_divisor.py
def greatest_common_divisor(x, y):
r = None
if x >= y:
r = x%y
if r == 0: return y
else:
r = y%x
if r == 0: return x
return greatest_common_divisor(y, r)
x, y = [int(n) for n in input().split(' ')]
print(greatest_common_divisor(x, y))
| 1 | 7,346,662,190 | null | 11 | 11 |
def skip_num(num_digits:list, compare_digit):
compare_upper_digit = num_digits[compare_digit]
compare_lower_digit = num_digits[compare_digit + 1]
if compare_upper_digit > compare_lower_digit:
num_digits[compare_digit + 1] = compare_lower_digit + 1
if compare_digit + 2 > len(num_digits):
num_digits[compare_digit + 2:] = [0] * (len(num_digits) - compare_digit - 2)
else: # compare_upper_digit < compare_lower_digit
num_digits[compare_digit] = compare_upper_digit + 1
num_digits[compare_digit + 1:] = [0] * (len(num_digits) - compare_digit - 1)
return int("".join([str(i) for i in num_digits]))
K = int(input())
lunlun_count = 0
num = 0
while True:
num += 1
if num < 10:
lunlun_count += 1
else:
num_digits = list(map(int, str(num)))
is_lunlun = True
for i in range(len(num_digits) - 1):
if abs(num_digits[i] - num_digits[i + 1]) > 1:
is_lunlun = False
num = skip_num(num_digits, i) - 1
break
if is_lunlun:
lunlun_count += 1
if lunlun_count >= K:
break
print(num)
|
k = int(input())
lun = [str(i) for i in range(1, 10)]
L = [str(i) for i in range(1, 10)]
nL = []
while len(lun) < 10 ** 5:
for num in L:
l = num[-1]
lm = int(l) - 1
lp = int(l) + 1
nL.append(num + l)
if lm >= 0:
nL.append(num + str(lm))
if lp < 10:
nL.append(num + str(lp))
lun.extend(nL)
L = nL
nL = []
lunlun = [int(x) for x in lun]
lunlun.sort()
print(lunlun[k-1])
| 1 | 40,205,237,828,052 | null | 181 | 181 |
#!/usr/bin/env python3
from collections import defaultdict, Counter
from itertools import product, groupby, count, permutations, combinations
from math import pi, sqrt
from collections import deque
from bisect import bisect, bisect_left, bisect_right
from string import ascii_lowercase
from functools import lru_cache
import sys
sys.setrecursionlimit(10000)
INF = float("inf")
YES, Yes, yes, NO, No, no = "YES", "Yes", "yes", "NO", "No", "no"
dy4, dx4 = [0, 1, 0, -1], [1, 0, -1, 0]
dy8, dx8 = [0, -1, 0, 1, 1, -1, -1, 1], [1, 0, -1, 0, 1, 1, -1, -1]
def inside(y, x, H, W):
return 0 <= y < H and 0 <= x < W
def ceil(a, b):
return (a + b - 1) // b
def sum_of_arithmetic_progression(s, d, n):
return n * (2 * s + (n - 1) * d) // 2
def gcd(a, b):
if b == 0:
return a
return gcd(b, a % b)
def lcm(a, b):
g = gcd(a, b)
return a / g * b
def solve():
N = int(input())
d = defaultdict(int)
maxi = 0
for _ in range(N):
S = input()
d[S] += 1
maxi = max(maxi, d[S])
ans = []
for k, v in d.items():
if v == maxi:
ans.append(k)
for a in sorted(ans):
print(a)
def main():
solve()
if __name__ == '__main__':
main()
|
import collections
N = int(input())
S = [input() for _ in range(N)]
c = collections.Counter(S)
max_num = max(c.values())
l = []
for item in c.items():
k = item[0]
v = item[1]
if v == max_num:
l.append(k)
l.sort()
for li in l:
print(li)
| 1 | 69,720,192,732,612 | null | 218 | 218 |
n,m=map(int,input().split())
h=list(map(int,input().split()))
c=0
d=[0]*n
for i in range(m):
a,b=map(int,input().split())
d[a-1]=max(d[a-1],h[b-1])
d[b-1]=max(d[b-1],h[a-1])
for i in range(n):
if h[i]>d[i]:
c+=1
print(c)
|
n,m = list(map(int, input("").split()))
h = list(map(int, input("").split()))
p = [1] * n
for i in range(m):
a,b = map(int, input().split())
if h[a-1] <= h[b-1]:
p[a-1]=0
if h[a-1] >= h[b-1]:
p[b-1]=0
print(sum(p))
| 1 | 24,987,261,045,800 | null | 155 | 155 |
n,k = map(int, input().split())
for i in range(50):
if n < pow(k,i):
print(i)
exit()
|
import math
N, K = map(int, input().split())
if N != 1:
res = math.log(N, K)
else:
res = 1
print(math.ceil(res))
| 1 | 64,418,075,048,858 | null | 212 | 212 |
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()
|
from sys import stdin
import collections
input = stdin.readline
Y, X, M = map(int, input().split())
bomb = set([tuple(map(int,inp.split())) for inp in stdin.read().splitlines()])
cx = collections.defaultdict(int)
cy = collections.defaultdict(int)
for y,x in bomb:
cx[x] += 1
cy[y] += 1
mx = max(cx.values())
my = max(cy.values())
candidateX = [x for (x,v) in cx.items() if v == mx]
candidateY = [y for (y,v) in cy.items() if v == my]
res = mx + my -1
for x in candidateX:
for y in candidateY:
if (y,x) not in bomb:
res += 1
break
else:
continue
break
print(res)
| 1 | 4,750,089,285,760 | null | 89 | 89 |
from collections import Counter
n=int(input())
A=list(map(int,input().split()))
c=Counter(A)
s=0
for v in c.values():
s+=v*(v-1)//2
for i in range(n):
ans=s-(c[A[i]])+1
print(ans)
|
from collections import Counter
import math
def combinations_count(n, r):
return math.factorial(n) // (math.factorial(n - r) * math.factorial(r))
N = int(input())
A_lst = list(map(int,input().split()))
S = Counter(A_lst)
sums = 0
#for i in S.keys():
# if S[i] > 1:
# sums += combinations_count(S[i], 2)
for c, i in S.items():
sums += i*(i-1)//2
for j in range(1, N + 1):
if S[A_lst[j-1]] == 2:
print(sums - 1)
elif S[A_lst[j-1]] > 2:
print(int(sums - S[A_lst[j-1]] * (S[A_lst[j-1]]-1) * 0.5 + (S[A_lst[j-1]] - 1) * (S[A_lst[j-1]] - 2) * 0.5))
else:
print(sums)
| 1 | 48,010,034,291,492 | null | 192 | 192 |
import math
def koch(n,p1,p2):
sx = 2/3 * p1[0] + 1/3 * p2[0]
sy = 2/3 * p1[1] + 1/3 * p2[1]
s = (sx,sy)
tx = 1/3 * p1[0] + 2/3 * p2[0]
ty = 1/3 * p1[1] + 2/3 * p2[1]
t = (tx,ty)
theta = math.radians(60)
ux = (tx - sx)*math.cos(theta) - (ty - sy)*math.sin(theta) + sx
uy = (tx - sx)*math.sin(theta) + (ty - sy)*math.cos(theta) + sy
u = (ux,uy)
if n>0:
koch(n-1,p1,s)
print(*s)
koch(n-1,s,u)
print(*u)
koch(n-1,u,t)
print(*t)
koch(n-1,t,p2)
else: return
n = int(input())
a = [0.00000000,0.00000000]
b = [100.00000000,0.00000000]
print(*map(float,a))
koch(n,a,b)
print(*map(float,b))
|
ss = str(input())
while (ss != '-'):
slist = []
for s in ss:
slist.append(s)
m = int(input())
for i in range(m):
n = int(input())
for k in range(n):
slist.append(slist[k])
for k in range(n):
del slist[0]
for i in range(len(slist)):
print(slist[i], end = '')
print()
ss = str(input())
| 0 | null | 1,025,861,009,678 | 27 | 66 |
N,P=map(int,input().split())
S=input()
list=[0 for _ in range(P)]
list[0]=1
now=0
a=0
if P==2 or P==5:
M=len(S)
S=reversed(S)
l=0
for s in S:
if int(s)%P==0:
a+=M-l
l+=1
else:
l+=1
print(a)
else:
b=1
h=0
for s in reversed(S):
h=h+b*int(s)
list[h%P]+=1
b=b*10%P
c=0
for i in range(len(list)):
c+=list[i]*(list[i]-1)/2
print(int(c))
|
import sys
sys.setrecursionlimit(10 ** 5 + 10)
def input(): return sys.stdin.readline().strip()
def resolve():
N, P = map(int, input().split())
S = str(input())
def main():
if P == 2:
res = 0
for i in range(N):
if int(S[N - 1 - i]) % 2 == 0:
res += N - i
elif P == 5:
res = 0
for i in range(N):
if int(S[N - 1 - i]) == 0 or int(S[N - 1 - i]) == 5:
res += N - i
else:
mods = [0] * P # mods[i]はPで割ったあまりがiである連続部分列の個数
tenfactor = 1
mod = 0
mods[mod] += 1
for i in range(N):
mod = (mod + int(S[N - i - 1]) * tenfactor) % P
tenfactor = (tenfactor * 10) % P
mods[mod] += 1
res = 0
for p in range(P):
res += mods[p] * (mods[p] - 1) // 2
return res
print(main())
resolve()
| 1 | 58,126,813,124,088 | null | 205 | 205 |
a, b = map(int, input().split())
print(a*b)
|
from collections import defaultdict, deque
V, E = map(int, input().split())
graph = defaultdict(dict)
for _ in range(E):
a, b = map(int, input().split())
graph[a][b] = True
graph[b][a] = True
components = [] # list of components
visited = set()
for i in range(1, V+1):
if i in visited:
continue
# do bfs starting from i
current_component = set()
queue = deque([i])
visited.add(i)
while queue:
x = queue.popleft()
current_component.add(x)
for nbr in graph[x]:
if nbr not in visited:
queue.append(nbr)
visited.add(nbr)
components.append(current_component)
print(max(map(len, components)))
| 0 | null | 9,816,665,117,238 | 133 | 84 |
import sys
while True:
h, w = [ int( val ) for val in sys.stdin.readline().split( " " ) ]
if 0 ==h and 0 == w:
break
pa = [ "#", "." ]
d = 0
ouput = []
for i in range( h ):
d = i%2
for j in range( w ):
ouput.append( pa[d] )
d = not d
ouput.append( "\n" )
print( "".join( ouput ) )
|
h,w = [],[]
while True:
(h,w) = [int(x) for x in input().split()]
if h == w == 0:
break
for x in range(h):
for y in range(w):
if (x + y) % 2 == 0:
print('#', end='')
else:
print('.', end='')
print()
print()
| 1 | 877,865,027,522 | null | 51 | 51 |
n,k,c=map(int,input().split())
s=input()
INF=float("inf")
left=[0]*(n+1)
right=[0]*(n+1)
mleft=0
last=-c-1
for i in range(n):
if s[i]=="o" and i-last>c:
mleft+=1
last=i
left[i+1]=mleft
mright=0
last=-c-1
t=s[::-1]
for i in range(n):
if t[i]=="o" and i-last>c:
mright+=1
last=i
right[i+1]=mright
for i in range(n):
left[i+1]=max(left[i+1],left[i])
right[i + 1] = max(right[i + 1], right[i])
left.remove(left[0])
right.remove(right[0])
right=right[::-1]
left.append(0)
right.append(0)
ans=[]
for i in range(1,n+1):
if s[i-1]=="o":
if left[i-2]+right[i]<k:
ans.append(i)
for i in range(len(ans)):
print(ans[i])
|
X, N = map(int, input().split())
if N == 0:
print(X)
else:
P = list(map(int, input().split()))
A = [0]
for i in range(1, 102):
if (i in P) == False:
A.append(i)
c = 101
for j in range(len(A)):
if abs(X - A[len(A)-int(j)-1]) <= abs(X - c):
c = A[len(A)-int(j)-1]
else:
c = c
print(c)
| 0 | null | 27,326,906,711,400 | 182 | 128 |
n = str(input())
p = int(input())
keta = len(n)
Dp = [[[0 for _ in range(2)] for _ in range(keta+1)]for _ in range(keta+1)]
Dp[0][0][1] = 1
10
for i in range(keta):
for j in range(i+1):
for k in range(10):
if k == 0:
if k < int(n[i]):
Dp[i+1][j][0] += Dp[i][j][0]
Dp[i+1][j][0] += Dp[i][j][1]
elif k == int(n[i]):
Dp[i+1][j][1] += Dp[i][j][1]
Dp[i+1][j][0] += Dp[i][j][0]
else:
Dp[i+1][j][0] += Dp[i][j][0]
else:
if k < int(n[i]):
Dp[i+1][j+1][0] += Dp[i][j][0]
Dp[i+1][j+1][0] += Dp[i][j][1]
elif k == int(n[i]):
Dp[i+1][j+1][1] += Dp[i][j][1]
Dp[i+1][j+1][0] += Dp[i][j][0]
else:
Dp[i+1][j+1][0] += Dp[i][j][0]
if p > keta:
print(0)
else:
print(sum(Dp[-1][p]))
|
S = list(map(str,input()))
if S[0] != S[1] or S[1] != S[2]:
print("Yes")
else:
print("No")
| 0 | null | 65,554,068,107,840 | 224 | 201 |
print(*[''.join(str(i)+'x'+str(j)+'='+str(i*j)) for i in range(1,10) for j in range(1,10)], sep='\n')
|
while True:
data = input()
if(data == "-"):break
m = int(input())
tmp = []
for i in range(m):
num = int(input())
if(len(tmp) == 0):
tmp = data[num:] + data[:num]
data = ""
else:
data = tmp[num:] + tmp[:num]
tmp = ""
if(data): print(data)
else: print(tmp)
| 0 | null | 944,942,541,620 | 1 | 66 |
DP = [False]*100001
DP[0] = True
for TN in range(0,100001):
if TN>=100 and DP[TN-100]:
DP[TN] = True
continue
if TN>=101 and DP[TN-101]:
DP[TN] = True
continue
if TN>=102 and DP[TN-102]:
DP[TN] = True
continue
if TN>=103 and DP[TN-103]:
DP[TN] = True
continue
if TN>=104 and DP[TN-104]:
DP[TN] = True
continue
if TN>=105 and DP[TN-105]:
DP[TN] = True
continue
print([0,1][DP[int(input())]])
|
X=int(input())
maisu_max=X//100
if X<100:
print(0)
exit()
else:
X=str(X)
X=int(X[-2:])
if X==0:
print(1)
exit()
ans=100
for i in range(2):
for j in range(2):
for k in range(2):
for l in range(2):
for m in range(20):
tmp=i+j*2+k*3+l*4+m*5
if tmp==X:
if i+j+k+l+m<ans:
ans=i+j+k+l+m
if maisu_max>=ans:
print(1)
else:
print(0)
| 1 | 126,913,562,186,946 | null | 266 | 266 |
n = int(input())
x = 0
while True:
if n % 1000 == 0:
break
n += 1
x += 1
print(x)
|
print('No') if int(input())%9 else print('Yes')
| 0 | null | 6,367,915,437,500 | 108 | 87 |
a, b = map(int, input().split())
c = list(map(int,input().split()[:a]))
d = 0
for i in c:
if i>=b:
d+=1
print(d)
|
import sys
N,K = map(int,input().split())
array_hight = list(map(int,input().split()))
if not ( 1 <= N <= 10**5 and 1 <= K <= 500 ): sys.exit()
count = 0
for I in array_hight:
if not ( 1 <= I <= 500): sys.exit()
if I >= K:
count += 1
print(count)
| 1 | 179,277,431,386,080 | null | 298 | 298 |
import math
r = float(input())
s = r ** 2 * math.pi
l = 2 * r * math.pi
print("{:.6f}".format(s), "{:.6f}".format(l))
|
a,b,c,d=map(int,input().split())
x=[]*4
x.append(a*c)
x.append(b*c)
x.append(a*d)
x.append(b*d)
x.sort()
print(x[-1])
| 0 | null | 1,857,176,974,508 | 46 | 77 |
#E
H,N=map(int,input().split())
A=[]
B=[]
DP=[0]+[float('Inf')]*(2*10**4)
for i in range(N):
a,b=map(int,input().split())
A.append(a)
B.append(b)
for j in range(10**4):
for i in range(N):
DP[j+A[i]]=min(B[i]+DP[j],DP[j+A[i]])
print(min(DP[H:]))
|
H, N = list(map(int,input().split()))
A = []
B = []
for i in range(N):
in1, in2 = list(map(int,input().split()))
A.append(in1)
B.append(in2)
# dp[i]: モンスターの体力がiのときの最適値
INF = 10 ** 9 + 7
dp = [INF for _ in range(H + 1)]
dp[0] = 0
for i in range(1, H + 1):
for j in range(N):
dp[i] = min(dp[i], dp[max(0, i - A[j])] + B[j])
print(dp[H])
| 1 | 80,997,340,161,468 | null | 229 | 229 |
counter=0
while True:
counter+=1
x=int(input())
if x==0:
break
print("Case "+str(counter)+": "+str(x))
|
import itertools
for i in itertools.count ( 1 ):
d = int ( input ( ) )
if d == 0:
break
print ( "Case %s: %s" % ( i, d ) )
| 1 | 485,066,254,398 | null | 42 | 42 |
def solve():
N, K, C = map(int, input().split())
workable = [i for i, s in enumerate(input(), 1) if s=="o"]
if len(workable) == K:
return workable
latest = set()
prev = workable[-1]+C+1
for x in reversed(workable):
if prev - x > C:
latest.add(x)
prev = x
if len(latest) > K:
return []
def ans():
prev = -C-1
for x in workable:
if x - prev > C:
if x in latest:
yield x
prev = x
return ans()
print("\n".join(map(str, solve())))
|
k,n = map(int,input().split())
a = list(map(int,input().split()))
b = []
for i in range(1,n):
b.append(a[i] - a[i-1])
b.append(k - a[n-1] + a[0])
b = sorted(b)
print(sum(b[:-1]))
| 0 | null | 42,197,984,993,760 | 182 | 186 |
class UnionFind:
def __init__(self, n):
self.par = [i for i in range(n+1)]
self.rank = [0] * (n+1)
# 検索
def find(self, x):
if self.par[x] == x:
return x
else:
self.par[x] = self.find(self.par[x])
return self.par[x]
# 併合
def union(self, x, y):
x = self.find(x)
y = self.find(y)
if self.rank[x] < self.rank[y]:
self.par[x] = y
else:
self.par[y] = x
if self.rank[x] == self.rank[y]:
self.rank[x] += 1
# 同じ集合に属するか判定
def same_check(self, x, y):
return self.find(x) == self.find(y)
n,m = map(int,input().split())
u = UnionFind(n)
for _ in range(m):
ai,bi = map(int,input().split())
u.union(ai,bi)
s = [0 for _ in range(n+1)]
for i in range(1,n+1):
s[u.find(i)] = 1
print(sum(s)-1)
|
a=input()
if(a=="RSS")|(a=="SRS")|(a=="SSR")|(a=="RSR"):
print(1)
elif(a=="SRR")|(a=="RRS"):
print(2)
elif(a=="RRR"):
print(3)
else:
print(0)
| 0 | null | 3,640,070,859,460 | 70 | 90 |
import sys
I=sys.stdin.readlines()
N,M,L=map(int,I[0].split())
a,b,c=0,0,0
D=[[L+1]*N for i in range(N)]
for i in range(M):
a,b,c=map(int,I[i+1].split())
a,b=a-1,b-1
D[a][b]=c
D[b][a]=c
for i in range(N):
D[i][i]=0
for k in range(N):
for i in range(N):
for j in range(N):
D[i][j]=min(D[i][j],D[i][k]+D[k][j])
D2=[[N*N+2]*N for i in range(N)]
for i in range(N):
D2[i][i]=0
for j in range(N):
if D[i][j]<=L:
D2[i][j]=1
for k in range(N):
for i in range(N):
for j in range(N):
D2[i][j]=min(D2[i][j],D2[i][k]+D2[k][j])
Q=int(I[M+1])
for i in range(Q):
a,b=map(int,I[i+2+M].split())
if N<D2[a-1][b-1]:
print(-1)
else:
print(D2[a-1][b-1]-1)
|
import sys
input = sys.stdin.readline
n,m,l = map(int,input().split())
town = [list(map(int,input().split())) for _ in range(m)]
q = int(input())
query = [list(map(int,input().split())) for _ in range(q)]
inf = (l+1)*n
d = [[inf]*n for _ in range(n)]
for i in range(n):
d[i][i] = 0
for a,b,c in town:
a -= 1
b -= 1
d[a][b] = c
d[b][a] = c
def warshall_floyd(d,n):
for k in range(n):
for j in range(n):
for i in range(n):
d[i][j] = min(d[i][j],d[i][k]+d[k][j])
warshall_floyd(d,n)
d2 = [None]*n
for i,row in enumerate(d):
d2[i] = [1 if val<=l else inf for val in row]
d2[i][i] = 0
warshall_floyd(d2,n)
for s,t in query:
s -= 1
t -= 1
count = (d2[s][t]%inf)-1
print(count)
| 1 | 173,353,569,730,582 | null | 295 | 295 |
import math
s=int(input())
# b=input()
# c=[]
# for i in range(b):
# c.append(a[i])
#a = list(map(int,input().split()))
#b = list(map(int,input().split()))
print(math.ceil(s/2))
|
n = int(input())
a = list(map(int, input().split()))
total = 0
sub = 0
for i in a:
total += i
sub += i * i
print((((total * total) - sub) // 2) % (10 ** 9 + 7))
| 0 | null | 31,205,865,365,590 | 206 | 83 |
N,S=int(input()),input()
r,g,b=0,0,0
for i in list(S):
if i=='R':r+=1
if i=='G':g+=1
if i=='B':b+=1
ans=r*g*b
for i in range(N-2):
for j in range(i+1,N-1):
if j-i>N-j-1:break
if S[i]!=S[j]and S[j]!=S[2*j-i]and S[2*j-i]!=S[i]:
ans-=1
print(ans)
|
N = int(input())
S = input()
r = S.count('R')
g = S.count('G')
b = S.count('B')
ans = r*g*b
for i in range(0,N):
for j in range(i,N):
k = 2*j - i
if j < k <= N-1:
if S[i] != S[j] and S[i] != S[k] and S[j] != S[k]:
ans -= 1
print(ans)
| 1 | 36,113,820,154,830 | null | 175 | 175 |
n = int(input())
l = list(map(int,input().split()))
min_sum = 10**9
for i in range(min(l),max(l)+1):
min_sum = min(min_sum,sum([(j-i)**2 for j in l]))
print(min_sum)
|
from collections import defaultdict
def main():
d = defaultdict(int)
d2 = defaultdict(int)
N = int(input())
A = list(map(int, input().split()))
for i in range(N):
d[i + 1 + A[i]] += 1
d2[max(0, (i + 1) - A[i])] += 1
ans = 0
for k,v in d.items():
if k == 0:continue
ans += v * d2[k]
print(ans)
if __name__ == '__main__':
main()
| 0 | null | 45,466,621,125,972 | 213 | 157 |
from math import ceil
n=int(input())
money=100000
for i in range(n):
money=ceil(money*1.05/1000)*1000
print(money)
|
def inserrtionsort(l,n):
for i in range(1,n):
print(" ".join(l))
v=l[i]
j=i-1
while int(v)<int(l[j]) and j>=0:
l[j+1]=l[j]
j-=1
l[j+1]=v
print(" ".join(l))
m=int(input())
n=list(input().split())
inserrtionsort(n,m)
| 0 | null | 3,418,702,490 | 6 | 10 |
from collections import deque
n = int(input())
l = deque()
for _ in range(n):
command = input().split()
if command[0] == "insert":
l.appendleft(command[1])
elif command[0] == "delete":
try:
ind = l.remove(command[1])
except ValueError:
pass
elif command[0] == "deleteFirst":
l.popleft()
elif command[0] == "deleteLast":
l.pop()
print (" ".join(l))
|
from collections import deque
x = deque()
for i in range(int(input())):
com = input()
if com == "deleteFirst":
x.popleft()
elif com == "deleteLast":
x.pop()
else:
com,n = com.split()
if com == "insert":
x.appendleft(n)
elif com == "delete":
try:
x.remove(n)
except:
pass
print(*x)
| 1 | 52,555,159,932 | null | 20 | 20 |
from decimal import Decimal
a, b = input().split()
a = Decimal(a)
b = Decimal(b)
print(int(a*b))
|
n,m=map(int,raw_input().split())
a=[]
for i in range(n):
a.append([int(v) for v in raw_input().split()])
b=[]
for i in range(m):
b.append(int(raw_input()))
for i in range(n):
ans=0
for j in range(m):
ans+=a[i][j]*b[j]
print ans
| 0 | null | 8,800,174,879,232 | 135 | 56 |
x, k, d = map(int, input().split())
x = abs(x)
if x//d >= k:
print(x-k*d)
else:
k -= x//d
x -= d*(x//d)
if k%2==0:
print(abs(x))
else:
print(abs(x-d))
|
n = input()
print(n.replace(n,'x'*len(n)))
| 0 | null | 39,163,396,686,722 | 92 | 221 |
# coding: utf-8
import sys
from collections import deque
n, q = map(int, input().split())
total_time = 0
tasks = deque(map(lambda x: x.split(), sys.stdin.readlines()))
for task in tasks:
task[1] = int(task[1])
while tasks:
t = tasks.popleft()
if t[1] <= q:
total_time += t[1]
print(t[0], total_time)
else:
t[1] -= q
total_time += q
tasks.append(t)
|
if __name__ == "__main__":
S = (input()).split()
n = int(S[0])
q = int(S[1])
head = 0
tail = n-1
que = []
runtime = 0
fin = []
for i in range(0, n):
que.append((input()).split())
while head <= tail:
nowjob = que[head]
jobtime = int(nowjob[1])
if jobtime > q :
jobtime = jobtime -q
jobname = nowjob[0]
que.append([jobname, jobtime])
runtime = runtime + q
head = head + 1
tail = tail + 1
else :
runtime = runtime + jobtime
fin.append([(que[head])[0], runtime])
head = head + 1
for i in range(0,n):
print("{} {}".format((fin[i])[0], (fin[i])[1]))
| 1 | 42,573,836,320 | null | 19 | 19 |
N = int(input())
A = list(map(int,input().split()))
a = {}
for i in A:
if i in a:
a[i] += 1
else:
a[i] = 1
Q = int(input())
ans = sum(A)
for i in range(Q):
B,C = map(int,input().split())
if B in a:
ans += (C-B) * a[B]
if C in a:
a[C] += a[B]
else:
a[C] = a[B]
a[B] = 0
print(ans)
|
N, X, M = map(int, input().split())
"""
id[X] Xを何番目に訪問したか。-1で無ければ訪問済み。
Xをメモ A[i+1] = (A[i] * A[i]) % M
length = ループが終わるまでの長さ
"""
id = [-1] * M
A = [] # 訪問したものをメモ
length = 0
total = 0
while id[X] == -1:
A.append(X)
id[X] = length
length += 1
total += X
X = (X * X) % M
syuki = length - id[X]
syukisum = sum(A[id[X] : length])
# for i in range(id[X], length):
# syukisum += A[i]
ans = 0
if N <= length:
ans = sum(A[:N])
else:
ans += total
N -= length
loop, res = divmod(N, syuki)
ans += syukisum * loop
ans += sum(A[id[X] : id[X] + res])
print(ans)
| 0 | null | 7,552,398,314,460 | 122 | 75 |
# encoding=utf-8
n = int(raw_input())
min = int(raw_input())
keep = int(raw_input())
diff = keep - min
if keep > min:
keep = min
n = n - 2
for i in range(n):
v = int(raw_input())
if v - keep > diff:
diff = v - keep
min = keep
elif keep > v:
keep = v
print diff
|
a, b = input().split()
a = int(a)
b = int(round(float(b)*100))
ans = a*b // 100
print(int(ans))
| 0 | null | 8,322,612,801,130 | 13 | 135 |
mod = pow(10,9)+7
N,K = map(int,input().split())
A = sorted(list(map(int,input().split())))
B = A[::-1]
n= N
fac = [1]*(n+1)
inv = [1]*(n+1)
for i in range(1,n+1):
fac[i] = (fac[i-1]*i) % mod
inv[n] = pow(fac[n], mod-2, mod)
for i in range(n, 0, -1):
inv[i-1] = (inv[i]*i) % mod
def nCr(n,r):
if r < 1:
return 1
return (((fac[n] * inv[r])%mod) * inv[n-r]) % mod
counter_min=0
counter_max=0
for i in range(N-K+1): #i=0 1 2
counter_max += A[N-1-i] * nCr(N-1-i,K-1)
counter_min += B[N-1-i] * nCr(N-1-i,K-1)
print((counter_max-counter_min)%mod)
|
N = int(input())
ans = [0]*10050
for i in range(1,105):
for j in range(1,105):
for k in range(1,105):
v = (i+j+k)**2-(i*j+i*k+j*k)
if v < len(ans):
ans[v] += 1
for x in range(1,N+1):
print(ans[x])
| 0 | null | 52,113,179,982,568 | 242 | 106 |
#!/usr/bin python3
# -*- coding: utf-8 -*-
import sys
input = sys.stdin.readline
def main():
N, A, B = map(int, input().split())
if abs(A-B)%2==0:
ret = abs(A-B)//2
else:
A, B = min(A, B), max(A, B)
ret = min(B-(B-A+1)//2, N-(B-A-1)//2-A)
print(ret)
if __name__ == '__main__':
main()
|
import sys
def LI():
return list(map(int, input().split()))
N, A, B = LI()
if (B-A) % 2 == 0:
print((B-A)//2)
sys.exit()
a = 1
b = B-A
L = A+(b-a)//2
b = N
R = N-B+1
a = A+R
R += (b-a)//2
print(min(R, L))
| 1 | 109,372,215,884,482 | null | 253 | 253 |
#!usr/bin/env python3
import sys
import re
def main():
s = sys.stdin.readline() # haystack
p = sys.stdin.readline() # needle
s = s.strip('\n') * 2
p = p.strip('\n')
if len(re.findall((p), s)) > 0:
print('Yes')
else:
print('No')
if __name__ == '__main__':
main()
|
words = input()
makeword = input()
words = words + words
if makeword in words:
print('Yes')
else:
print('No')
| 1 | 1,728,381,696,900 | null | 64 | 64 |
list=map(int,raw_input().split())
list.sort()
for i in range(len(list)):
print '%d'%(list[i]),
|
while True:
c=input()
if c=="-":
break
cards=list(c)
m=int(input())
for i in range(m):
h=int(input())
for i in range(h):
s=cards.pop(0)
cards+=s
print("".join(cards))
| 0 | null | 1,162,518,217,920 | 40 | 66 |
# -*- coding: utf-8 -*-
N, K = map(int, input().split())
kukan = list()
for i in range(K):
l, r = map(int, input().split())
kukan.append((l, r))
dp = [0] * (N+1)
dp[1] = 1
dp_sum = [0] * (N+1)
dp_sum[1] = 1
for i in range(0, N+1):
for j in range(K):
from_l = i - kukan[j][1]
from_r = i - kukan[j][0]
if from_r < 0:
continue
else:
from_l = max(1, from_l)
dp[i] += dp_sum[from_r] - dp_sum[from_l - 1]
dp[i] %= 998244353
dp_sum[i] = dp[i] + dp_sum[i-1]
print(dp[N] % 998244353)
|
n = int(input())
s = input()
ans = 'No'
if n%2 == 0:
mid = int(n/2)
if s[:mid] == s[mid:]:
ans = 'Yes'
print(ans)
| 0 | null | 74,557,344,375,072 | 74 | 279 |
n=int(input())
lista=[0 for i in range(n)]
lista=input().split()
n2=int(input())
listb=[0 for i in range(n2)]
listb=input().split()
cnt=0
for i in range(n2):
x=0
for j in range(n):
if listb[i]==lista[j] and x==0:
x=1
cnt+=1
print(cnt)
|
import sys
input = sys.stdin.readline
def main():
N = int(input())
c = input()
cnt_r = 0
cnt_w = 0
for i in c:
if i == 'R':
cnt_r += 1
else:
cnt_w += 1
w_left = 0
r_right = cnt_r
ans = N
for i in range(N):
ans = min(ans, max(w_left, r_right))
if c[i] == 'W':
w_left += 1
else:
r_right -= 1
print(min(ans, max(w_left, r_right)))
main()
| 0 | null | 3,156,159,432,848 | 22 | 98 |
from math import ceil
t1,t2 = map(int,input().split())
a1,a2 = map(int,input().split())
b1,b2 = map(int,input().split())
a1 -= b1
a2 -= b2
a1 *= t1
a2 *= t2
if a1 + a2 == 0:
print("infinity")
exit()
if a1*(a1+a2) > 0:
print(0)
exit()
x = -a1/(a1+a2)
n = ceil(x)
if n == x:
print(2*n)
else:
print(2*n-1)
|
t1, t2 = map(int, input().split())
a1,a2 = map(int, input().split())
b1, b2 = map(int, input().split())
#t1で生まれる差
P = (a1 - b1) * t1
#t2で生まれる差
Q = (a2 - b2) * t2
#P < 0 のことを仮定する
if P > 0:
P *= -1
Q *= -1
if P + Q < 0:
print(0)
elif P + Q == 0:
print("infinity")
else:
#つぎのPを足したときに、負にいくかどうか?
i = P * (-1)
if i % (P + Q) == 0:
print(2 * (i // (P + Q)))
else:
print(2 * (i // (P + Q)) + 1)
| 1 | 131,737,105,060,558 | null | 269 | 269 |
import numpy as np
import numba
from numba import njit, b1, i4, i8, f8
@njit((i8,i8,i8[:],i8[:]), cache=True)
def main(H,N,A,B):
INF = 1<<30
dp = np.full(H+1,INF,np.int64)
dp[0] = 0
for i in range(N):
for h in range(A[i],H):
dp[h] = min(dp[h],dp[h-A[i]]+B[i])
dp[H] = min(dp[H],min(dp[H-A[i]:H]+B[i]))
ans = dp[-1]
return ans
H, N = map(int, input().split())
A = np.zeros(N,np.int64)
B = np.zeros(N,np.int64)
for i in range(N):
A[i],B[i] = map(int, input().split())
print(main(H,N,A,B))
|
HP, n = map(int, input().split())
AB = [list(map(int,input().split())) for _ in range(n)]
# DP
## DP[i]は、モンスターにダメージ量iを与えるのに必要な魔力の最小コスト
## DPの初期化
DP = [float('inf')] * (HP+1); DP[0] = 0
## HP分だけDPを回す.
for now_hp in range(HP):
## 全ての魔法について以下を試す.
for damage, cost in AB:
### 与えるダメージは、現在のダメージ量+魔法のダメージか体力の小さい方
next_hp = min(now_hp+damage, HP)
### 今の魔法で与えるダメージ量に必要な最小コストは、->
####->現在わかっている値か今のHPまでの最小コスト+今の魔法コストの小さい方
DP[next_hp] = min(DP[next_hp], DP[now_hp]+cost)
print(DP[-1])
| 1 | 81,061,299,271,200 | null | 229 | 229 |
A, B = map(int,input().split())
for i in range(max(A,B),0,-1):
if A%i==0 and B%i==0:
print(A*B//i)
break
|
a,b=map(int,input().split())
def factorization(n):
arr = []
tmp = n
for i in range(2, int(n**0.5//1)+1):
if tmp%i==0:
cnt = 0
while tmp%i==0:
cnt+=1
tmp//=i
arr.append([i,cnt])
if tmp!=1:
arr.append([tmp,1])
if arr==[]:
arr.append([n,1])
return arr
a_arr = factorization(a)
b_arr = factorization(b)
a_map = {str(arr[0]):arr[1] for arr in a_arr}
b_map = {str(arr[0]):arr[1] for arr in b_arr}
factor = set(list(a_map.keys())+list(b_map.keys()))
ans = 1
for i in factor:
if str(i) in a_map.keys():
a_num = a_map[str(i)]
else:
a_num = 0
if str(i) in b_map.keys():
b_num = b_map[str(i)]
else:
b_num = 0
ans *= int(i)**(max(a_num,b_num))
print(ans)
| 1 | 113,454,555,439,450 | null | 256 | 256 |
a1=list(map(int,input().split()))
a2=list(map(int,input().split()))
a3=list(map(int,input().split()))
n=int(input())
for i in range (n):
num=int(input())
if num in a1:
a1[a1.index(num)]='O'
if num in a2:
a2[a2.index(num)]='O'
if num in a3:
a3[a3.index(num)]='O'
if a1[0] == 'O' and a1[1] == 'O' and a1[2] == 'O':
print('Yes')
elif a2[0] == 'O' and a2[1] == 'O' and a2[2] == 'O':
print('Yes')
elif a3[0] == 'O' and a3[1] == 'O' and a3[2] == 'O':
print('Yes')
elif a1[0] == 'O' and a2[0] == 'O' and a3[0] == 'O':
print('Yes')
elif a1[1] == 'O' and a2[1] == 'O' and a3[1] == 'O':
print('Yes')
elif a1[2] == 'O' and a2[2] == 'O' and a3[2] == 'O':
print('Yes')
elif a1[0] == 'O' and a2[1] == 'O' and a3[2] == 'O':
print('Yes')
elif a1[2] == 'O' and a2[1] == 'O' and a3[0] == 'O':
print('Yes')
else:
print('No')
|
def II(): return int(input())
def MI(): return map(int, input().split())
def LI(): return list(map(int, input().split()))
N=II()
A=LI()
#A.sort()
SA=sum(A)
#print(SA)
AccA=[A[0]]
for i in range(1,N):
AccA.append(AccA[-1]+A[i])
#AccA.reverse()
ans=0
for i in range(N-1):
ans+=A[i]*(SA-AccA[i])
ans=ans%(10**9+7)
print(ans)
| 0 | null | 31,695,684,107,040 | 207 | 83 |
import itertools
N = int(input())
S = input()
RGB = {"R":[0]*N, "G":[0]*N, "B":[0]*N}
for i in range(N):
if S[i] == "R":
RGB["R"][i] = 1
elif S[i] == "G":
RGB["G"][i] = 1
else:
RGB["B"][i] = 1
for k in RGB.keys():
RGB[k] = list(itertools.accumulate(RGB[k]))
ans = 0
for i in range(N-2):
l_i = S[i]
for j in range(i+1, N-1):
l_j = S[j]
d = {"R", "G", "B"}
if l_i != l_j:
d.remove(l_i)
d.remove(l_j)
l_k = d.pop()
ans += RGB[l_k][N-1] - RGB[l_k][j]
if j*2 - i <= N-1:
if S[j*2 - i] == l_k:
ans -= 1
print(ans)
|
import sys
input_methods=['clipboard','file','key']
using_method=0
input_method=input_methods[using_method]
IN=lambda : map(int, input().split())
mod=1000000007
#+++++
def main_b():
s = input()
pp=0
na=0
for i, c in enumerate(s[::-1]):
cc=na+int(c)
na=0
if cc <= 4:
pp+=cc
else:
na = 1
if i==len(s)-1:
pp+=1
pp+=10-cc
print(pp)
def main():
s = input()
pmin=1000
mmin=0
s='0'+s
for c in s[::-1]:
v = int(c)
npmin = min(pmin + 10 - (v+1), mmin + 10 - v)
nmmin = min(pmin + v + 1, mmin + v)
pmin = npmin
mmin = nmmin
return min(pmin, mmin)
#+++++
isTest=False
def pa(v):
if isTest:
print(v)
def input_clipboard():
import clipboard
input_text=clipboard.get()
input_l=input_text.splitlines()
for l in input_l:
yield l
if __name__ == "__main__":
if sys.platform =='ios':
if input_method==input_methods[0]:
ic=input_clipboard()
input = lambda : ic.__next__()
elif input_method==input_methods[1]:
sys.stdin=open('inputFile.txt')
else:
pass
isTest=True
else:
pass
#input = sys.stdin.readline
ret = main()
if ret is not None:
print(ret)
| 0 | null | 53,629,538,839,420 | 175 | 219 |
import math
def main():
n,m = map(int,input().split())
a = list(map(int,input().strip().split()))
if n >= sum(a):
print(n-sum(a))
return
else:
print(-1)
return
main()
|
import sys
def main():
input = sys.stdin.buffer.readline
n, m = map(int, input().split())
a_list = list(map(int, input().split()))
for a in a_list:
n -= a
if n < 0:
break
print(n if n >= 0 else -1)
if __name__ == '__main__':
main()
| 1 | 32,046,086,566,830 | null | 168 | 168 |
x = int(input())
k = 1
while k*x%360:
k += 1
print(k)
|
def gcd(a, b):
if a==0:
return b
else:
return gcd(b%a, a)
X = int(input())
LCM = X*360/gcd(360, X)
print(int(LCM/X))
#a, b = map(int, input().split())
#print(gcd(a, b))
| 1 | 13,068,116,010,020 | null | 125 | 125 |
n = int(input())
s = str(input())
if n % 2 == 1:
print("No")
exit()
if s[:n // 2] == s[n // 2:]:
print("Yes")
exit()
print("No")
|
n = int(input())
s = input()
t = ""
for i in range(n // 2):
t += s[i]
if s == (t + t):
print('Yes')
else:
print('No')
| 1 | 146,688,676,563,132 | null | 279 | 279 |
n = input()
mark = ['S', 'H', 'C', 'D']
cards = ["{} {}".format(mark[i], j+1) for i in range(4) for j in range(13)]
for i in range(n):
cards.remove(raw_input())
while len(cards) != 0:
print cards.pop(0)
|
import string
n = int(input())
s = ''
lowCase = string.ascii_lowercase
while n > 0:
n -= 1
s += lowCase[int(n % 26)]
n //= 26
print(s[::-1])
| 0 | null | 6,412,393,752,802 | 54 | 121 |
import sys
while 1:
H,W = map(int,sys.stdin.readline().split())
if H == W == 0:
break
print(('#'*W + '\n')*H)
|
b = []
c = []
while True:
a = input().split()
a[0] = int(a[0])
a[1] = int(a[1])
if a[0] == 0 and a[1] == 0:
break
else:
b.append("#"*a[1])
c.append(a[0])
for i in range(len(c)):
for j in range(c[i]):
print(b[i])
print("\n",end="")
| 1 | 783,671,438,330 | null | 49 | 49 |
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)
|
# coding:UTF-8
import sys
from math import factorial
MOD = 10 ** 9 + 7
INF = float('inf')
N, K = list(map(int, input().split())) # スペース区切り連続数字
A = list(map(int, input().split())) # スペース区切り連続数字
for i in range(K, N):
r = i - K
l = i
if A[r] >= A[l]:
print("No")
else:
print("Yes")
| 0 | null | 41,119,313,518,152 | 223 | 102 |
a=map(int,raw_input().split())
a.sort()
while a[1]%a[0]!=0:
a[0],a[1]=a[1]%a[0],a[0]
print(a[0])
|
x,y = map(int,raw_input().split())
if x==y:
print x
else:
if y>x:
tmp = x
x = y
y = tmp
i=2
ans = 1
al = []
while i*i<=x:
if x % i ==0:
if y % i==0:
al.append(i)
x = x/i
y = y/i
continue
i+=1
if len(al)==0:
pass
else:
for j in al:
ans *= j
print ans
| 1 | 8,720,080,380 | null | 11 | 11 |
import bisect
n=int(input())
l=[int(x) for x in input().rstrip().split()]
l.sort()
ans=0
comb=[]
ans=0
for i in range(n):
for j in range(i+1,n):
now=l[i]+l[j]
ind=bisect.bisect_left(l,now)
ans+=max(0,ind-j-1)
print(ans)
|
S = input()
T = input()
i=0
j=0
for i in range (len(S)):
if S[i] != T[i]:
j += 1
print(j)
| 0 | null | 91,098,341,467,588 | 294 | 116 |
S=input().split()
print(S.index("0")+1)
|
def find(x):
if par[x] == x:
return x
else:
par[x] = find(par[x]) #経路圧縮
return par[x]
def same(x,y):
return find(x) == find(y)
def unite(x,y):
x = find(x)
y = find(y)
if x == y:
return 0
par[x] = y
size[y] = size[x] + size[y]
size[x] = 0
N,M = map(int,input().split())
par = [ i for i in range(N+1)]
size = [1 for _ in range(N+1)]
for _ in range(M):
a,b = map(int,input().split())
unite(a,b)
A = size.count(0)
print(N-A-1)
| 0 | null | 7,894,168,243,612 | 126 | 70 |
# coding:utf-8
def insertionSort(A, N):
for i in range(1, N):
v = A[i]
j = i - 1
while j >= 0 and A[j] > v:
A[j + 1] = A[j]
j -= 1
A[j + 1] = v
for i in A:
print i,
else:
print
N = input()
A = map(int, raw_input().split())
for i in A:
print i,
else:
print
insertionSort(A,N)
|
# -*- coding: utf-8 -*-
import sys
# sys.setrecursionlimit(10**6)
# buff_readline = sys.stdin.buffer.readline
buff_readline = sys.stdin.readline
readline = sys.stdin.readline
INF = 2**62-1
def read_int():
return int(buff_readline())
def read_int_n():
return list(map(int, buff_readline().split()))
def read_float():
return float(buff_readline())
def read_float_n():
return list(map(float, buff_readline().split()))
def read_str():
return readline().strip()
def read_str_n():
return readline().strip().split()
def error_print(*args):
print(*args, file=sys.stderr)
def mt(f):
import time
def wrap(*args, **kwargs):
s = time.time()
ret = f(*args, **kwargs)
e = time.time()
error_print(e - s, 'sec')
return ret
return wrap
class Mod:
def __init__(self, m):
self.m = m
def add(self, a, b):
return (a + b) % self.m
def sub(self, a, b):
return (a - b) % self.m
def mul(self, a, b):
return ((a % self.m) * (b % self.m)) % self.m
def div(self, a, b):
return self.mul(a, pow(b, self.m-2, self.m))
def pow(self, a, b):
return pow(a, b, self.m)
class Bisect:
def __init__(self, func):
self.__func = func
def bisect_left(self, x, lo, hi):
while lo < hi:
mid = (lo+hi)//2
if self.__func(mid) < x:
lo = mid+1
else:
hi = mid
return lo
def bisect_right(self, x, lo, hi):
while lo < hi:
mid = (lo+hi)//2
if x < self.__func(mid):
hi = mid
else:
lo = mid+1
return lo
def f(n):
r = 1
for i in range(1, n+1):
r *= i
return r
@mt
def slv(N, K, A, F):
A.sort()
F.sort(reverse=True)
def f(x):
y = 0
for a, f in zip(A, F):
b = a - x//f
if b > 0:
y += b
if y <= K:
return 1
return 0
return Bisect(f).bisect_left(1, 0, 10**18)
def main():
N, K = read_int_n()
A = read_int_n()
F = read_int_n()
print(slv(N, K, A, F))
if __name__ == '__main__':
main()
| 0 | null | 82,492,261,114,564 | 10 | 290 |
s = input()
l = [0,'SAT','FRI','THU','WED','TUE','MON','SUN']
print(l.index(s))
|
#!/usr/bin/env python3
from collections import defaultdict, Counter
from itertools import product, groupby, count, permutations, combinations
from math import pi, sqrt
from collections import deque
from bisect import bisect, bisect_left, bisect_right
from string import ascii_lowercase
from functools import lru_cache
import sys
sys.setrecursionlimit(10000)
INF = float("inf")
YES, Yes, yes, NO, No, no = "YES", "Yes", "yes", "NO", "No", "no"
dy4, dx4 = [0, 1, 0, -1], [1, 0, -1, 0]
dy8, dx8 = [0, -1, 0, 1, 1, -1, -1, 1], [1, 0, -1, 0, 1, 1, -1, -1]
def inside(y, x, H, W):
return 0 <= y < H and 0 <= x < W
def ceil(a, b):
return (a + b - 1) // b
def sum_of_arithmetic_progression(s, d, n):
return n * (2 * s + (n - 1) * d) // 2
def gcd(a, b):
if b == 0:
return a
return gcd(b, a % b)
def lcm(a, b):
g = gcd(a, b)
return a / g * b
def solve():
N = int(input())
C = input()
num_r = C.count("R")
num_w = C.count("W")
ans = min(num_r, num_w)
left_r = 0
left_w = 0
for i in range(N):
left_r += C[i] == 'R'
left_w += C[i] == 'W'
right_r = num_r - left_r
right_w = num_w - left_w
ans = min(ans, min(left_w, right_r) + abs(left_w - right_r))
print(ans)
def main():
solve()
if __name__ == '__main__':
main()
| 0 | null | 69,831,181,956,568 | 270 | 98 |
list = [int(x) for x in input().split()]
list.sort()
print(list[0], list[1], list[2])
|
l = map (int, raw_input().split())
if l[0] > l[1]:
s = l[0]
l[0] = l[1]
l[1] = s
if l[2] > l[0]:
if l[2] < l[1]:
s = l[1]
l[1] = l[2]
l[2] = s
else:
s = l[2]
l[2] = l[1]
l[1] = l[0]
l[0] = s
print l[0], l[1], l[2]
| 1 | 418,235,521,030 | null | 40 | 40 |
n = int(input())
arr = list(map(int, input().split()))
cnt = 1
for x in arr:
if cnt == x:
cnt = cnt + 1
if cnt == 1:
print(-1)
else:
print(n-cnt+1)
|
a,b=map(int, input().split())
if a == 1 or b == 1:
print(1)
if a != 1 and b != 1 and a*b%2== 0:
print(a*b//2)
if a != 1 and b != 1 and a*b%2!= 0:
print(a*b//2+1)
| 0 | null | 82,551,797,182,020 | 257 | 196 |
x = input().split()
s = int(x[0])
w = int(x[1])
if s > w:
print('safe')
else:
print('unsafe')
|
n, k = list(map(int, input().split()))
mod = 1000000007
fac = [1]
inv = [1]
for i in range(n * 2):
fac.append(fac[-1] * (i + 1) % mod)
inv.append(pow(fac[-1], mod - 2, mod))
def cmb(n, k):
if k < 0 or k > n:
return 0
return ((fac[n] * inv[k]) % mod * inv[n - k]) % mod
ret = 0
for m in range(min(k + 1, n)):
ret = (ret + (cmb(n, m) * cmb(n - 1, n - m - 1)) % mod) % mod
print(ret)
| 0 | null | 48,081,268,400,620 | 163 | 215 |
s = input()
t = input()
count = 0
for i in range(len(s)):
if s[i] != t[i]:
count = count + 1
print(count)
|
print(sum(s!=t for s,t in zip(*open(0))))
| 1 | 10,456,355,082,808 | null | 116 | 116 |
X = int(input())
A = 100
for i in range(10**5):
A = A*101//100
if X <= A:
break
print(i+1)
|
x = int(input())
n = 100
ans = 0
while (x > n):
n += (n//100)
ans += 1
print(ans)
| 1 | 27,061,756,757,490 | null | 159 | 159 |
import queue
n = int(input())
alp = "abcdefghijklmn"
q = queue.Queue()
q.put("a")
while not q.empty():
qi = q.get()
if len(qi) == n:
print(qi)
elif len(qi) < n:
idx = alp.index(max(qi))
for i in range(idx+2):
q.put(qi+alp[i])
|
import math
A,B,H,M=map(int,input().split())
M_rad = math.radians(M*6)
H_rad = math.radians(H*30+M*0.5)
rad = M_rad - H_rad
ans = math.sqrt(A**2+B**2-2*A*B*math.cos(rad))
print(ans)
| 0 | null | 36,094,506,283,208 | 198 | 144 |
from numpy import zeros, maximum
N, T, *AB = map(int, open(0).read().split())
dp = zeros(6010, int)
for w, v in sorted(zip(*[iter(AB)] * 2)):
dp[w:T + w] = maximum(dp[w:T + w], dp[:T] + v)
print(dp.max())
|
def main():
n = int(input())
Ss = [input() for _ in range(n)]
U = [[0, 0] for _ in range(n)]
for i in range(n):
for c in Ss[i]:
if c == "(":
U[i][1] += 1
else:
if U[i][1] == 0:
U[i][0] += 1
else:
U[i][1] -= 1
L, R = 0, 0
P = []
for i in range(n):
if U[i][0] == 0 and U[i][1] > 0:
L += U[i][1]
elif U[i][0] > 0 and U[i][1] == 0:
R += U[i][0]
elif U[i][0] > 0 and U[i][1] > 0:
P.append([U[i][0], U[i][1]])
P.sort(key=lambda x: (x[0]-x[1], x[0], -x[1]))
if L == 0 and R == 0 and len(P) == 0:
print("Yes")
elif (L == 0 or R == 0) and len(P) > 0:
print("No")
else:
f = True
for i in range(len(P)):
L -= P[i][0]
if L < 0:
f = False
break
L += P[i][1]
if L == R and f:
print("Yes")
else:
print("No")
if __name__ == "__main__":
main()
| 0 | null | 87,412,764,302,292 | 282 | 152 |
from sys import stdin, setrecursionlimit
#input = stdin.buffer.readline
setrecursionlimit(10 ** 7)
from heapq import heappush, heappop
from bisect import bisect_left, bisect_right
from collections import deque, defaultdict, Counter
from itertools import combinations, permutations, combinations_with_replacement
from itertools import accumulate
from math import ceil, sqrt, pi, radians, sin, cos
MOD = 10 ** 9 + 7
INF = 10 ** 18
N = int(input())
#N, M = map(int, input().split())
#A = list(map(int, input().split()))
#A = [int(input()) for _ in range(N)]
#ABC = [list(map(int, input().split())) for _ in range(N)]
#S = input()
#S = [input() for _ in range(N)]
print(1 - N)
|
num = int(input())
print(0 if num == 1 else 1)
| 1 | 2,916,342,912,022 | null | 76 | 76 |
n, k = map(int, input().split())
R, S, P = map(int, input().split())
t = input()
prev = {}
ans = 0
for i in range(k):
if t[i] == 'r':
ans += P
prev[i] = 'p'
elif t[i] == 's':
ans += R
prev[i] = 'r'
elif t[i] == 'p':
ans += S
prev[i] = 's'
for i in range(k, n):
a = i % k
if t[i] == 'r':
if prev[a] != 'p':
ans += P
prev[a] = 'p'
else:
if i + k < n and t[i + k] != 's':
prev[a] = 'r'
else:
prev[a] = 's'
elif t[i] == 's':
if prev[a] != 'r':
ans += R
prev[a] = 'r'
else:
if i + k < n and t[i + k] != 'p':
prev[a] = 's'
else:
prev[a] = 'p'
elif t[i] == 'p':
if prev[a] != 's':
prev[a] = 's'
ans += S
else:
if i + k < n and t[i + k] != 'r':
prev[a] = 'p'
else:
prev[a] = 'r'
print(ans)
|
r = float(input())
pi = 3.141592653589793
print(pi*r**2, 2*pi*r)
| 0 | null | 53,459,001,320,330 | 251 | 46 |
from sys import exit
def main():
N = int(input())
S = input()
middle = int(N / 2)
if middle == 0 or N % 2 != 0:
print('No')
exit()
for i in range(middle):
if S[i] != S[i + middle]:
print('No')
exit()
print('Yes')
main()
|
from collections import defaultdict
d=defaultdict(int)
n=int(input())
a=list(map(int,input().split()))
ans=1
mod=10**9+7
d[-1]=3
for i in a:
ans*=d[i-1]
ans%=mod
d[i-1]-=1
d[i]+=1
print(ans)
| 0 | null | 139,005,131,915,428 | 279 | 268 |
nums = [int(e) for e in input().split()]
if (nums[2]+nums[4])<=nums[0] and (nums[3]+nums[4])<=nums[1] and (nums[2]-nums[4])>=0 and (nums[3]-nums[4])>=0:
print("Yes")
else:
print("No")
|
W,H,x,y,r = (int(i) for i in input().split())
if W-(x+r) >=0 and H-(y+r) >= 0:
if x-r >= 0 and y-r >= 0:
print("Yes")
else:
print("No")
else:
print("No")
| 1 | 446,305,652,548 | null | 41 | 41 |
import collections
a=int(input())
b=list(map(int,input().split()))
c=collections.Counter(b)
n,m=zip(*c.most_common())
n,m=list(n),list(m)
result=0
for i in range(len(m)):
result+=(m[i]*(m[i]-1))//2
for i in b:
print(result-c[i]+1)
|
import collections
N = int(input())
A = [int(_) for _ in input().split()]
C = collections.Counter(A)
d = sum([C[i] * (C[i] - 1) // 2 for i in range(N + 1)])
for a in A:
print(d - C[a] + 1)
| 1 | 47,589,364,030,650 | null | 192 | 192 |
H=int(input())
Q=[]
import math
for i in range(10000):
if H>1:
H=H//2
Q.append(H)
elif H==1:
break
Q.sort()
S=0
a=1
for i in range(len(Q)):
a=2*a+1
print(a)
|
L,R,d = list(map(int, input().split()))
print(R//d - (L-1)//d)
| 0 | null | 43,587,109,766,242 | 228 | 104 |
import sys
input = sys.stdin.readline
def main():
n,a,b = [int(i) for i in input().strip().split()]
if (b-a) % 2 == 0:
print(abs(b - a) // 2)
else:
ans = min(a - 1, n - b) + 1 + (b - a - 1) // 2
print(ans)
return
if __name__ == "__main__":
main()
|
N,A,B = map(int,input().split())
if (B-A)%2 == 0:
ans = [N-A,(B-A)//2,B-1]
print(min(ans))
else:
ans = [N-A,B-1,((B-A-1)//2)+(N-B+1),((B-A-1)//2)+A]
print(min(ans))
| 1 | 109,402,599,216,012 | null | 253 | 253 |
s = input().strip()
if s[-1]=='s':
s += 'es'
else:
s += 's'
print(s)
|
t = input()
ans = ""
if t[len(t)-1] == "s":
ans = t + "es"
else:
ans = t + "s"
print(ans)
| 1 | 2,370,291,800,820 | null | 71 | 71 |
n=int(input())
ans=0
for i in range(n):
if (i+1)%3==0 and (i+1)%5==0:
continue
elif (i+1)%3==0:
continue
elif (i+1)%5==0:
continue
else:
ans+=i+1
print(ans)
|
ans=0
N=int(input())
for x in range(1,N+1):
if x%3==0 or x%5==0:
pass
else:
ans += x
print(ans)
| 1 | 34,897,180,354,052 | null | 173 | 173 |
A,B = map(int,input().split())
print([A-2*B,0][A<=2*B])
|
n, m = map(int, input().split())
h = list(map(int, input().split()))
to = [[] for i in range(n)]
for i in range(m):
a, b = map(int, input().split())
to[a - 1] += [b - 1]
to[b - 1] += [a - 1]
print(sum(to[j] == [] or h[j] > max(h[i] for i in to[j]) for j in range(n)))
| 0 | null | 95,521,576,910,848 | 291 | 155 |
N,K = map(int,input().split())
count = 0
for i in range(K,N+2):
min_1 = i*(i-1)//2
max_1 = (2*N-i+1)*i//2
num = max_1-min_1+1
count += num
print(count%(10**9+7))
|
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,166,661,496,388 | null | 170 | 170 |
i = 1
while True:
n = input()
if n != 0:
print 'Case %s: %s' % (str(i), str(n))
i = i + 1
else:
break
|
import sys
i = 1
while(True):
x = int(sys.stdin.readline())
if(x == 0):
break
print("Case %d: %d" % (i, x))
i += 1
| 1 | 470,570,370,334 | null | 42 | 42 |
sec_in = int(input())
hour = sec_in // 3600
minute = (sec_in % 3600) // 60
sec = sec_in % 60
print('{0}:{1}:{2}'.format(hour,minute,sec))
|
from math import *
PI = 3.1415926535898
while True:
try:
t = input()
ans = ""
ans += str(t/(60*60))
t %= 60*60
ans += ":"
ans += str(t/60)
t %= 60
ans += ":"
ans += str(t)
print ans
except EOFError:
break
| 1 | 336,489,027,038 | null | 37 | 37 |
import sys
from collections import deque
sys.setrecursionlimit(10**7)
input = sys.stdin.readline
n,x,y = map(int, input().split())
g = [[] for _ in range(n)]
for i in range(1, n):
a = i - 1
b = i
g[a].append(b)
g[b].append(a)
x -= 1
y -= 1
g[x].append(y)
g[y].append(x)
ans = [0] * n
for i in range(n):
stack = deque()
dis = [0] * n
seen = [False] * n
stack = deque()
stack.append(i)
seen[i] = True
while stack:
v = stack.popleft()
for nv in g[v]:
if seen[nv]:
continue
dis[nv] = dis[v] + 1
seen[nv] = True
stack.append(nv)
for j in range(n):
ans[dis[j]] += 1
for i in range(1, n):
print(ans[i] // 2)
|
import sys, re
from collections import deque, defaultdict, Counter
from math import ceil, sqrt, hypot, factorial, pi, sin, cos, tan, asin, acos, atan, radians, degrees, log2, gcd
from itertools import accumulate, permutations, combinations, combinations_with_replacement, product, groupby
from operator import itemgetter, mul
from copy import deepcopy
from string import ascii_lowercase, ascii_uppercase, digits
from bisect import bisect, bisect_left, insort, insort_left
from heapq import heappush, heappop
from functools import reduce
def input(): return sys.stdin.readline().strip()
def INT(): return int(input())
def MAP(): return map(int, input().split())
def LIST(): return list(map(int, input().split()))
def ZIP(n): return zip(*(MAP() for _ in range(n)))
sys.setrecursionlimit(10 ** 9)
INF = float('inf')
mod = 10 ** 9 + 7
#import numpy as np
#from decimal import *
N, X, Y = MAP()
graph = [[] for _ in range(N)]
for i in range(N-1):
graph[i].append(i+1)
graph[i+1].append(i)
graph[X-1].append(Y-1)
graph[Y-1].append(X-1)
dic = defaultdict(int)
for i in range(N):
q = deque([i])
dist = [-1]*N
dist[i] = 0
while q:
n = q.popleft()
for node in graph[n]:
if dist[node] == -1:
dist[node] = dist[n] + 1
q.append(node)
for i in range(N):
dic[dist[i]] += 1
for k in range(1, N):
print(dic[k]//2)
| 1 | 44,163,360,559,580 | null | 187 | 187 |
n = int(input())
s = input()
num = n
for i in range(n-1,0,-1):
if s[i]==s[i-1]:
s = s[:i] + s[i+1:]
print(len(s))
|
n = int(input())
s = list(input())
ans = 1
for i in range(1, n):
if s[i-1] != s[i]:
ans += 1
print(ans)
| 1 | 170,211,251,265,200 | null | 293 | 293 |
N, M = map(int, input().split())
An = [int(i) for i in input().split()]
total = sum(An)
if total > N:
print('-1')
else:
print(N - total)
|
# -*- coding: utf-8 -*-
import sys
import math
import os
import itertools
import string
import heapq
import _collections
from collections import Counter
from collections import defaultdict
from collections import deque
from functools import lru_cache
import bisect
import re
import queue
import copy
import decimal
class Scanner():
@staticmethod
def int():
return int(sys.stdin.readline().rstrip())
@staticmethod
def string():
return sys.stdin.readline().rstrip()
@staticmethod
def map_int():
return [int(x) for x in Scanner.string().split()]
@staticmethod
def string_list(n):
return [Scanner.string() for i in range(n)]
@staticmethod
def int_list_list(n):
return [Scanner.map_int() for i in range(n)]
@staticmethod
def int_cols_list(n):
return [Scanner.int() for i in range(n)]
def solve():
N, K = Scanner.map_int()
A = Scanner.map_int()
for i in range(K, N):
if A[i - K] < A[i]:
print('Yes')
else:
print('No')
def main():
# sys.setrecursionlimit(1000000)
# sys.stdin = open("sample.txt")
solve()
if __name__ == "__main__":
main()
| 0 | null | 19,430,901,294,838 | 168 | 102 |
import sys,math,collections
from collections import defaultdict
#from itertools import permutations,combinations
def file():
sys.stdin = open('input.py', 'r')
sys.stdout = open('output.py', 'w')
def get_array():
l=list(map(int, input().split()))
return l
def get_2_ints():
a,b=map(int, input().split())
return a,b
def get_3_ints():
a,b,c=map(int, input().split())
return a,b,c
def sod(n):
n,c=str(n),0
for i in n:
c+=int(i)
return c
def getFloor(A, x):
(left, right) = (0, len(A) - 1)
floor = -1
while left <= right:
mid = (left + right) // 2
if A[mid] == x:
return A[mid]
elif x < A[mid]:
right = mid - 1
else:
floor = A[mid]
left = mid + 1
return floor
#file()
def main():
n=int(input())
l=get_array()
c=0
for i in range(0,n,2):
if(l[i]&1):
c+=1
print(c)
if __name__ == '__main__':
main()
|
n=int(input())
a=list(map(int,input().split()))
a.insert(0,0)
ans=0
for i in range(1,n+1, 2):
if a[i]%2==1:
ans+=1
print(ans)
| 1 | 7,773,973,769,628 | null | 105 | 105 |
#import sys
#import numpy as np
import math
#from fractions import Fraction
import itertools
from collections import deque
from collections import Counter
import heapq
from fractions import gcd
#input=sys.stdin.readline
#import bisect
n,m=map(int,input().split())
a=list(map(int,input().split()))
def lcm(a,b):
g=math.gcd(a,b)
return b*(a//g)
l=a[0]//2
for i in range(n):
r=a[i]//2
l=lcm(l,r)
for i in range(n):
if (l//(a[i]//2))%2==0:
print(0)
exit()
res=m//l
print((res+1)//2)
|
n=int(input())
def make(floor,kind,name): #floor=何階層目か,kind=何種類使ってるか
if floor==n+1:
print(name)
return
num=min(floor,kind+1)
for i in range(num):
use=0 #新しい文字使ってるか
if kind-1<i:
use=1
make(floor+1,kind+use,name+chr(i+97))
make(1,0,"")
| 0 | null | 77,049,799,296,580 | 247 | 198 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.