code1
stringlengths 16
427k
| code2
stringlengths 16
427k
| similar
int64 0
1
| pair_id
int64 2
178,025B
⌀ | question_pair_id
float64 27.1M
177,113B
⌀ | code1_group
int64 1
297
| code2_group
int64 1
297
|
|---|---|---|---|---|---|---|
s = input()
t = input()
cnt = 0
ans = 0
while cnt < len(s) - len(t) + 1:
chk = 0
for i, j in zip(range(cnt,cnt+len(t)),range(len(t))):
if s[i] == t[j]:
chk += 1
ans = max(ans,chk)
cnt += 1
print(len(t) - ans)
|
s = input()
q = []
for i in s:
q.append(int(i))
if sum(q)%9 == 0:
print('Yes')
else:print('No')
| 0 | null | 4,040,593,262,570 | 82 | 87 |
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)
|
a, b, c = (int(i) for i in input().split())
divisor = 0
for i in range(a, b + 1):
if c % i == 0:
divisor += 1
print(str(divisor))
| 0 | null | 10,355,979,405,340 | 144 | 44 |
n, k = map(int, input().split())
a = list(map(int, input().split()))
a_pos = sorted([i for i in a if i >= 0])
a_neg = sorted([i for i in a if i < 0], reverse=True)
mod = 10 ** 9 + 7
ans = 1
if len(a_pos) == 0 and k % 2:
for i in a_neg[:k]:
ans = ans * i % mod
print(ans)
exit()
while k > 0:
if k == 1 or len(a_neg) <= 1:
if len(a_pos) == 0:
ans *= a_neg.pop()
elif len(a_pos) > 0:
ans *= a_pos.pop()
k -= 1
elif len(a_pos) <= 1:
ans *= a_neg.pop() * a_neg.pop()
k -= 2
elif a_pos[-1] * a_pos[-2] > a_neg[-1] * a_neg[-2]:
ans *= a_pos.pop()
k -= 1
elif a_pos[0] * a_pos[1] <= a_neg[-1] * a_neg[-2]:
ans *= a_neg.pop() * a_neg.pop()
k -= 2
ans %= mod
print(ans)
|
# Contest No.: ABC173
# Problem No.: E
# Solver: JEMINI
# Date: 20200705
import sys
import heapq
def main():
modVal = 10 ** 9 + 7
# parsing
n, k = map(int, sys.stdin.readline().split())
nums = list(map(int, sys.stdin.readline().split()))
# edge case; n == k
if n == k:
ans = 1
for i in nums:
ans *= i % modVal
ans %= modVal
print(ans % modVal)
return
# edge case; all neg
if max(nums) < 0:
nums.sort()
ans = 1
# odd k
if k % 2:
for i in range(k):
ans *= nums[-i - 1] % modVal
ans %= modVal
# even k
else:
for i in range(k):
ans *= nums[i] % modVal
ans %= modVal
print(ans % modVal)
return
# convert to absolute value & count zeros
absNums = []
zeroCnt = 0
for i in nums:
if i == 0:
zeroCnt += 1
else:
absNums.append([abs(i), i])
absNums.sort() # sorted by absolute value
# edge case; non-zero cnt is less than k
if len(absNums) < k:
print(0)
return
# separate non-zero int to 4 sorted lists; all values are absolute value
posOverK = []
negOverK = []
posLessK = []
negLessK = []
for _ in range(k):
temp = absNums.pop()
if temp[1] > 0:
posOverK.append(temp[0])
else:
negOverK.append(temp[0])
while absNums:
temp = absNums.pop()
if temp[1] > 0:
posLessK.append(temp[0])
else:
negLessK.append(temp[0])
posOverK.sort()
negOverK.sort()
posLessK.sort()
negLessK.sort()
# odd negative numbers; if able, change to even
if len(negOverK) % 2:
minNeg = None
minPos = None
maxNeg = None
maxPos = None
if posOverK:
minPos = posOverK[0]
if negOverK:
minNeg = negOverK[0]
if posLessK:
maxPos = posLessK[-1]
if negLessK:
maxNeg = negLessK[-1]
# both case available; pos -> neg or neg -> pos
if (minNeg and maxPos) and (minPos and maxNeg):
# compare ratio
if maxPos * minPos > maxNeg * minNeg:
negOverK[0] = maxPos
else:
posOverK[0] = maxNeg
# one case available
elif not (minNeg and maxPos) and (minPos and maxNeg):
posOverK[0] = maxNeg
elif (minNeg and maxPos) and not (minPos and maxNeg):
negOverK[0] = maxPos
# unchangable, zero exists
elif zeroCnt > 0:
print(0)
return
# answer building
ans = 1
for i in posOverK:
ans *= i % modVal
ans = ans % modVal
for i in negOverK:
ans *= i % modVal
ans = ans % modVal
print(ans % modVal)
return
if __name__ == "__main__":
main()
| 1 | 9,470,590,086,480 | null | 112 | 112 |
h,w,k=map(int,input().split())
board=[list(input()) for _ in range(h)]
acum=[[0]*w for _ in range(h)]
def count(x1,y1,x2,y2): #事前に求めた2次元累積和を用いて左上の点が(x1,y1)、右下の点(x2,y2)の長方形に含まれる1の個数を数える
ret=acum[y2][x2]
if x1!=0:
ret-=acum[y2][x1-1]
if y1!=0:
ret-=acum[y1-1][x2]
if x1!=0 and y1!=0:
ret+=acum[y1-1][x1-1]
return ret
for i in range(h): #2次元累積和により左上の点が(0,0)、右下の点が(j,i)の長方形に含まれる1の個数を数える
for j in range(w):
if board[i][j] == '1':
acum[i][j]+=1
if i!=0:
acum[i][j]+=acum[i-1][j]
if j!=0:
acum[i][j]+=acum[i][j-1]
if i!=0 and j!=0:
acum[i][j]-=acum[i-1][j-1]
ans = 10**18
for i in range(2**(h-1)):
cnt = 0
list = []
flag = format(i,'b')[::-1] # '1'と'10'と'100'の区別のために必要
#print(flag)
for j in range(len(flag)):
if flag[j] == '1': # ''をつける！
cnt += 1
list.append(j)
list.append(h-1)
#print(list)
x1 = 0
for x2 in range(w-1): #x1(最初は0)とx1+1の間からx=w-1とx=wの間までの区切り方をそれぞれ確かめる
y1 = 0
for y2 in list: #長方形のブロックの右下の点のy座標の候補をすべて試す
if count(x1,y1,x2,y2) > k: #ある横の区切り方の下で、どのように縦を区切ってもブロックに含まれる1の個数がKより大きくなるとき、条件を満たす切り分け方は存在しない
cnt += 10**18
if count(x1,y1,x2,y2) <= k and count(x1,y1,x2+1,y2) > k: #ある位置でブロックを区切ると1の個数がK以下になるが、区切る位置を1つ進めると1の個数がKより大きくなるとき、その位置で区切る必要がある
cnt += 1
x1 = x2+1 #ある位置x2で区切ったとき、次からはx2+1を長方形のブロックの左上の点のx座標として見ればよい
break
y1 = y2+1 #(いま見ているブロックの右下の点のy座標)+1が次に見るブロックの左上の点のy座標に等しくなる
y1 = 0
for y2 in list:
if count(x1,y1,w-1,y2) > k: #最後に縦で区切った位置以降で、あるブロックに含まれる1の個数がKより大きくなるとき、条件を満たすような区切り方は存在しない
cnt += 10**18
break
y1 = y2+1
ans = min(ans,cnt)
print(ans)
|
'''
'''
INF = float('inf')
def main():
H, W, K = map(int, input().split())
S = [input() for _ in range(H)]
S = [''.join(S[row][col] for row in range(H)) for col in range(W)]
ans = INF
for b in range(0, 2**H, 2):
sections = [(0, H)]
for shift in range(1, H):
if (1<<shift) & b:
sections.append((sections.pop()[0], shift))
sections.append((shift, H))
t_ans = len(sections) - 1
count = {(l, r): 0 for l, r in sections}
for col in range(W):
if any(count[(l, r)] + S[col][l:r].count('1') > K for l, r in sections):
for key in count.keys():
count[key] = 0
t_ans += 1
for l, r in sections:
count[(l, r)] += S[col][l:r].count('1')
if max(count.values()) > K:
t_ans = INF
break
ans = min(ans, t_ans)
print(ans)
main()
| 1 | 48,662,247,060,570 | null | 193 | 193 |
# -*- 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 functools import lru_cache
import bisect
import re
import queue
from decimal import *
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 [input() 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 [int(input()) for i in range(n)]
class Math():
@staticmethod
def gcd(a, b):
if b == 0:
return a
return Math.gcd(b, a % b)
@staticmethod
def lcm(a, b):
return (a * b) // Math.gcd(a, b)
@staticmethod
def divisor(n):
res = []
i = 1
for i in range(1, int(n ** 0.5) + 1):
if n % i == 0:
res.append(i)
if i != n // i:
res.append(n // i)
return res
@staticmethod
def round_up(a, b):
return -(-a // b)
@staticmethod
def is_prime(n):
if n < 2:
return False
if n == 2:
return True
if n % 2 == 0:
return False
d = int(n ** 0.5) + 1
for i in range(3, d + 1, 2):
if n % i == 0:
return False
return True
def pop_count(x):
x = x - ((x >> 1) & 0x5555555555555555)
x = (x & 0x3333333333333333) + ((x >> 2) & 0x3333333333333333)
x = (x + (x >> 4)) & 0x0f0f0f0f0f0f0f0f
x = x + (x >> 8)
x = x + (x >> 16)
x = x + (x >> 32)
return x & 0x0000007f
MOD = int(1e09) + 7
INF = int(1e15)
def solve():
H, W, K = Scanner.map_int()
S = Scanner.string_list(H)
ans = [[0 for _ in range(W)] for _ in range(H)]
vec = []
for h in range(H):
if S[h].count('#') > 0:
vec.append(h)
for i in range(len(vec)):
v1, v2 = 0, H - 1
if i > 0:
v1 = vec[i - 1] + 1
if i < len(vec) - 1:
v2 = vec[i]
vec2 = []
for w in range(W):
cnt = 0
for h in range(v1, v2 + 1):
if S[h][w] == '#':
cnt += 1
if cnt > 0:
vec2.append(w)
for j in range(len(vec2)):
w1, w2 = 0, W - 1
if j > 0:
w1 = vec2[j - 1] + 1
if j < len(vec2) - 1:
w2 = vec2[j]
for h in range(v1, v2 + 1):
for w in range(w1, w2 + 1):
ans[h][w] = K
K -= 1
for a in ans:
print(*a)
def main():
# sys.stdin = open("sample.txt")
solve()
if __name__ == "__main__":
main()
|
import sys
n=int(input())
l=n//100
d=n%100
for i in range(5, 0, -1):
if d // i > 0:
l = l - (d // i)
d = d - i * (d // i)
if d == 0 and l >= 0:
print(1)
sys.exit()
if l < 0:
break
print(0)
| 0 | null | 135,673,512,087,370 | 277 | 266 |
X, Y, a, b, c = map(int, input().split())
p = list(map(int, input().split()))
q = list(map(int, input().split()))
r = list(map(int, input().split()))
p.sort(reverse=True)
q.sort(reverse=True)
r.sort(reverse=True)
p_sum = [0]*(a+1)
q_sum = [0]*(b+1)
for i in range(a):
p_sum[i+1] = p_sum[i] + p[i]
for i in range(b):
q_sum[i+1] = q_sum[i] + q[i]
#print(p_sum)
#print(q_sum)
ans = [0]*(c+1)
ans[0] = p_sum[X] + q_sum[Y]
x, y = X, Y
flag = True
for i in range(c):
if x > 0 and y > 0:
ans[i+1] = max(ans[i]-p[x-1]+r[i], ans[i]-q[y-1]+r[i], ans[i])
if ans[i+1] == ans[i]-p[x-1]+r[i]:
x -= 1
elif ans[i+1] == ans[i]-q[y-1]+r[i]:
y -= 1
elif ans[i+1] == ans[i]:
break
elif x == 0:
ans[i+1] = max(ans[i]-q[y-1]+r[i], ans[i])
if ans[i+1] == ans[i]:
break
else:
y -= 1
elif y == 0:
ans[i+1] = max(ans[i]-p[x-1]+r[i], ans[i])
if ans[i+1] == ans[i]:
break
else:
x -= 1
elif x == 0 and y == 0:
flag = False
if flag:
print(max(ans))
else:
print(sum(r[:x+y-1]))
|
#!/usr/bin/env python3
# -*- coding: utf-8 -*-
def main():
while True:
try:
num = eval(input().replace(" ","+"))
except:
return
else:
print(len(str(num)))
if __name__ == '__main__':
main()
| 0 | null | 22,535,747,326,192 | 188 | 3 |
k=int(input())
a=0
cnt=-1
for i in range(1,k+1):
a=(10*a+7)%k
if a==0:
cnt=i
break
print(cnt)
|
x,k,d = map(int,input().split())
if x < 0:
x *= -1
m = x // d
if k <= m:
print(x - k*d)
else:
x %= d
y = abs(x-d)
print([x,y][(k-m)%2])
| 0 | null | 5,701,161,368,060 | 97 | 92 |
import sys
input = sys.stdin.readline
from collections import deque
N = int(input())
#A = list(map(int, input().split()))
A = [(a, i) for i, a in enumerate(map(int, input().split()))]
A = sorted(A, reverse=True)
values = []
num_indcies = {}
for i, a in enumerate(A):
if not a in num_indcies:
num_indcies[a] = [i]
values.append(a)
else:
num_indcies[a].append(i)
values = sorted(values, reverse=True)
ans = 0
# indexの配列
dp_indices = []
for v in values:
dp_indices.extend(num_indcies[v])
dp = [[0] * (N+1) for _ in range(N+1)]
for no, (a, pos) in enumerate(A):
for i in range(no+1):
j = no - i
#k = dp_indices[i+j-2]
#a = A[k]
dp[i+1][j] = max(dp[i+1][j], dp[i][j] + a * (pos -i))
dp[i][j+1] = max(dp[i][j+1], dp[i][j] + a * abs(pos - (N-1-j)))
ans = 0
for i in range(1, N+1):
ans = max(ans, dp[i][N-i])
print(ans)
|
terms = '1, 1, 1, 2, 1, 2, 1, 5, 2, 2, 1, 5, 1, 2, 1, 14, 1, 5, 1, 5, 2, 2, 1, 15, 2, 2, 5, 4, 1, 4, 1, 51'.split(', ')
print(terms[int(input()) - 1])
| 0 | null | 41,650,513,207,280 | 171 | 195 |
import math
A, B, N = map(int, input().split())
ans = []
if B-1<N:
sahen = math.floor(A*(B-1)//B)
uhen = math.floor((B-1)//B)
uhen = uhen*A
ans.append(sahen-uhen)
sahen = math.floor(A*N//B)
uhen = math.floor(N//B)
uhen = uhen*A
ans.append(sahen-uhen)
print(max(ans))
|
S, T = map(str, input().split())
print('{}{}'.format(T, S))
| 0 | null | 65,659,923,311,218 | 161 | 248 |
s = input()
if s.isupper():
print("A")
else:
print("a")
|
S=input()
print("{}{}{}".format(S[0],'B' if S[1]!='B' else 'R',S[-1]))
| 0 | null | 17,687,466,019,132 | 119 | 153 |
import math
N = int(input())
num = list(map(int, input().split()))
#N = 10**6
#num = list(range(1, N+1))
MAXX = 10**6 + 1
MAXZ = int(math.sqrt(MAXX)+2)
furui = [[] for _ in range(MAXX)]
furui[1].append(1)
count = [0]*MAXX
for i in range(2, MAXX):
if len(furui[i]) == 0:
for k in range(i, MAXX, i):
furui[k].append(i)
setwise = True
pairwise = True
for i in range(N):
if not setwise and not pairwise: break
for fu in furui[num[i]]:
count[fu] += 1
if fu > 1 and count[fu] >= N:
setwise = False
pairwise = False
break
elif fu > 1 and count[fu] > 1:
pairwise = False
if pairwise:
print('pairwise coprime')
elif setwise:
print('setwise coprime')
else:
print('not coprime')
|
# -*- coding: utf-8 -*-
"""
Created on Fri Sep 18 00:26:07 2020
@author: liang
"""
"""
コーナーケース１:
重複があるとき not coprime(※これが誤り)
ただし、1の重複は除く
コーナーケース:
重複があるとき pairwise coprime ではない
setwise coprimeの可能性はある
ただし、１の重複は
"""
import math
C = 10**6
#T = int(math.sqrt(C)*10**3)+1
N = int(input())
judge = [0]+[False]*C
A =list()
f = True
for a in input().split():
if judge[int(a)] == True and int(a) != 1:
f = False
judge[int(a)]=True
A.append(int(a))
d = [False]+[True]*C
#print(judge[:10])
def solve(f):
flag = True
#エラトステネスの篩 O(N log N)
for i in range(2,C+1):
count = 0
if d[i] == True:
for j in range(i,C+1,i):
if judge[j] == True:
count += 1
if count == 2:
flag = False
break
d[j] = False
if not flag:
break
if flag == True and f == True:
return "pairwise coprime"
ans = A[0]
#線形探索 O(N)
for i in range(N):
ans = math.gcd(ans,A[i])
#print("ans",a)
if ans == 1:
return "setwise coprime"
return "not coprime"
print(solve(f))
#print(len(A))
| 1 | 4,078,912,204,406 | null | 85 | 85 |
import math
while True:
n=int(input())
if n==0:
break
s=list(map(int,input().split()))
m=sum(s)/n
aa=0
for i in s:
aa+= (i-m)**2
a=math.sqrt((aa)/n)
print(f'{a:.08f}')
|
#65
import math
while True:
n=int(input())
if n==0:
break
s=list(map(int,input().split()))
m=sum(s)/n
a=0
for i in range(n):
a+=(s[i]-m)**2
b=math.sqrt(a/n)
print(b)
| 1 | 190,989,220,290 | null | 31 | 31 |
n,m,k = map(int,input().split())
A = [[] for i in range(n+1)]
for i in range(m):
a,b = map(int,input().split())
A[a].append(b)
A[b].append(a)
C = [[] for i in range(n+1)]
for i in range(k):
c,d = map(int,input().split())
C[c].append(d)
C[d].append(c)
from collections import deque
reach = [0]*(n+1)
for i in range(1,n+1):
if reach[i] != 0:
pass
else:
reach[i] = i
q = deque([])
q.append(i)
while q:
x = q.popleft()
for s in A[x]:
if reach[s] == 0:
q.append(s)
reach[s] = i
dis_count = [0]*(n+1)
for i,C0 in enumerate(C):
for CC in C0:
if reach[CC] == reach[i]:
dis_count[i] += 1
import collections
D = collections.Counter(reach)
for i in range(1,n+1):
print(D[reach[i]]-len(A[i])-dis_count[i]-1,end="")
print(" ",end="")
print("")
|
n,m,k=map(int,input().split())
class UnionFind:
def __init__(self,n):
self.ps = [-1]*(n+1)
def find(self,x):
if self.ps[x]<0:
return x
else:
self.ps[x]=self.find(self.ps[x])
return self.ps[x]
def unite(self,x,y):
x=self.find(x)
y=self.find(y)
if x==y:
return False
if self.ps[x]>self.ps[y]:
x,y = y,x
self.ps[x] += self.ps[y]
self.ps[y] = x
return True
def same(self,x,y):
return self.find(x)==self.find(y)
def size(self,x):
x = self.find(x)
return -self.ps[x]
all1 = [0]*(n)
uf = UnionFind(n)
for i in range(m):
a,b = map(int,input().split())
uf.unite(a,b)
a,b = a-1,b-1
all1[a] +=1
all1[b] +=1
#print(all1)
ans = [uf.size(x)-1-all1[x-1] for x in range(1,n+1)]
#print(ans)
for i in range(k):
a,b = map(int,input().split())
if uf.same(a,b):
a,b = a-1,b-1
ans[a] -=1
ans[b] -=1
print(*ans)
| 1 | 61,561,124,923,962 | null | 209 | 209 |
n = input()
print '',
for i in xrange(1, n+1):
x = i
if x % 3 == 0:
print i,
else:
while x:
if x % 10 == 3:
print i,
break
x /= 10
|
num = input()
print "",
for x in xrange(1,num+1):
if x%3==0:
print x,
elif "3" in str(x):
print x,
else:
pass
| 1 | 930,975,461,500 | null | 52 | 52 |
# E - Colorful Blocks
import sys
sys.setrecursionlimit(10**8)
MOD = 998244353
N,M,K = map(int,input().split())
inv_M = pow(M-1,-1,MOD) if M>1 else 0
ans = 0
tmp = pow(M-1,N-1,MOD) if M>1 else 0
comb = 1
for i in range(K+1):
ans = (ans+M*comb*tmp)%MOD
if i==K:
break
tmp = (tmp*inv_M)%MOD
comb = (comb*(N-1-i)*pow(i+1,-1,MOD))%MOD
if M==1 and K==N-1:
ans += 1
print(ans)
|
import math
mod = 998244353
import numpy as np
def create_modC(n, mod):
if n == 0:
return (lambda r: 1)
b = int(math.log(mod-2, 2)) + 1
fac = np.zeros((b, n+1), dtype=np.int64)
#print(fac.shape)
inv = np.ones(n+1, dtype=np.int64)
fac[0, 0], fac[0, 1] = 1, 1
for i in range(2, n+1):
fac[0, i] = (fac[0, i-1] * i) % mod
for i in range(1, b):
fac[i, :] = (fac[i-1, :] ** 2) % mod
indice = []
N = mod - 2
i = 0
while N > 0:
if N % 2 == 1:
indice.append(i)
N = N >> 1
i += 1
for i in indice:
inv *= fac[i,:]
inv %= mod
fac = fac[0,:]
def _modC(r):
if r == 0 or r == n:
return 1
result = fac[n] * inv[n-r]
result %= mod
result *= inv[r] % mod
result %= mod
return result
return _modC
def mod_factorial(mod):
cache = [1,1,2]
def _factorial(n):
nonlocal cache
if n == 0:
return 1
length = len(cache)
v = cache[-1]
while n >= length:
v *= length
v %= mod
cache.append(v)
length +=1
return cache[n]
return _factorial
def mod_pow(x, mod):
xx = [1, x]
def _pow(y, x=x):
nonlocal xx
if y == 0:
return 1
while len(xx) <= math.log(y, 2)+1:
v = xx[-1] * xx[-1]
v %= mod
xx.append(v)
i = 1
result = 1
while y > 0:
if y % 2 == 1:
result *= xx[i]
result %= mod
y = y >> 1
i += 1
return result
return _pow
def test():
N, M, K = 3,2,1
answer = 6
v = resolve(N, M, K)
print(f"N={N} M={M} K={K} {v}={answer}")
N, M, K = 100,100,0
answer = 73074801
v = resolve(N, M, K)
print(f"N={N} M={M} K={K} {v}={answer}")
N, M, K = 60522,114575,7559
answer = 479519525
v = resolve(N, M, K)
print(f"N={N} M={M} K={K} {v}={answer}")
N, M, K = 200000,190000,190000
v = resolve(N, M, K)
print(f"N={N} M={M} K={K} {v}")
N, M, K = 1,1,0
print(f"N={N} M={M} K={K}")
v = resolve(N, M, K)
print(f"N={N} M={M} K={K} {v}")
N, M, K = 200000,200000,190000
v = resolve(N, M, K)
print(f"N={N} M={M} K={K} {v}")
for i in range(100):
N, M = np.random.randint(200000), np.random.randint(200000)
K = np.random.randint(N-1)
v = resolve(N, M, K)
print(f"N={N} M={M} K={K} {v}")
def main():
#test()
N, M, K = map(int, input().split())
v = resolve(N, M, K)
print(v)
def resolve(N, M, K):
from datetime import datetime
result = 0
m1pow = mod_pow(M-1, mod)
modC = create_modC(N-1, mod)
for k in range(K+1):
b = m1pow(N-1-k)
c = modC(k)
v = b
v *= c
v %= mod
#if k < 10:
# print(f"b={b} c={c} k={k} {v}")
result += v
result %= mod
result *= M
result %= mod
result = int(result)
return result
if __name__ == '__main__':
main()
| 1 | 23,060,337,784,860 | null | 151 | 151 |
a = int(input())
print(a//2-(a%2==0))
|
N, K, S = map(int, input().split())
ans = []
for _ in range(K):
ans.append(str(S))
for _ in range(N - K):
ans.append(str(abs(S - 10**9 + 1)))
print(" ".join(ans))
| 0 | null | 122,068,198,906,328 | 283 | 238 |
A,B,N=map(int,input().split())
def func(t):
return int(t)
#NはBより大きいかもしれないし小さいかもしれない
#B-1が最高だが、NがB-1より小さいとどうしようもない
x=min(B-1,N)
print(func(A*x/B)-A*func(x/B))
|
import math
a, b, n = map(int, input().split())
if n < b:
c = math.floor(a * n / b)
print(c)
else:
c = math.floor(a * (b-1)/ b)
print(c)
| 1 | 28,077,545,927,798 | null | 161 | 161 |
S = int(input())
h = S // (60 * 60)
m = (S % (60*60)) // 60
s = S % 60
# セパレータ(sep)は":" を用いる
print(h, m, s, sep=":")
|
# B - I miss you...
# S
S = input()
answer = '0'
for i in range(0, len(S)):
answer += 'x'
print(answer[1:len(S) + 1])
| 0 | null | 36,742,764,148,458 | 37 | 221 |
N, K = map(int, input().split())
A = list(map(int, input().split()))
F = list(map(int, input().split()))
A.sort()
F.sort(reverse=True)
ok = 10**12
ng = -1
def check(time):
shugyou = 0
for i in range(N):
if A[i]*F[i] > time:
shugyou += A[i] - (time//F[i])
return shugyou <= K
while ok - ng > 1:
mid = (ok + ng)//2
if check(mid):
ok = mid
else:
ng = mid
print(ok)
|
n, k = map(int, input().split())
a = sorted(map(int, input().split()))
f = sorted(map(int, input().split()))[::-1]
# 成績 Σ{i=1~n}a[i]*f[i]
# a[i]小さいの、f[i]でかいの組み合わせるとよい(交換しても悪化しない)
def c(x):
need = 0
for i in range(n):
if a[i] * f[i] > x:
# f[i]を何回減らしてx以下にできるか
diff = a[i] * f[i] - x
need += 0 - - diff // f[i]
return need <= k
l = 0
r = 1 << 60
while r != l:
mid = (l + r) >> 1
if c(mid):
r = mid
else:
l = mid + 1
print(l)
| 1 | 164,489,577,239,808 | null | 290 | 290 |
from sys import stdin
r = int(stdin.readline().rstrip())
print(r**2)
|
n=int(input())
a=list(map(int,input().split()))
q=int(input())
b=[0]*q
c=[0]*q
for i in range(q):
b[i],c[i]=map(int,input().split())
N=[0]*(10**5)
s=0
for i in range(n):
N[a[i]-1]+=1
s+=a[i]
for i in range(q):
s+=(c[i]-b[i])*N[b[i]-1]
N[c[i]-1]+=N[b[i]-1]
N[b[i]-1]=0
print(s)
| 0 | null | 78,847,337,329,112 | 278 | 122 |
n,m,l = map(int,input().split())
A = list()
B = list()
for i in range(n):
A.append(list(map(int,input().split())))
for i in range(m):
B.append(list(map(int,input().split())))
for i in range(n):
C = list()
for j in range(l):
sum = 0
for k in range(m):
sum += A[i][k] * B[k][j]
C.append(sum)
print(" ".join(list(map(str,C))))
|
#設定
import sys
input = sys.stdin.buffer.readline
#ライブラリインポート
from collections import defaultdict
con = 10 ** 9 + 7
#入力受け取り
def getlist():
return list(map(int, input().split()))
class Combination(object):
def __init__(self, N, con):
self.fac = [0] * (N + 1)
self.inv = [0] * (N + 1)
self.finv = [0] * (N + 1)
self.fac[0], self.fac[1] = 1, 1
self.inv[1] = 1
self.finv[0], self.finv[1] = 1, 1
# 前計算
for i in range(2, N + 1):
self.fac[i] = self.fac[i - 1] * i % con
self.inv[i] = self.inv[con % i] * (con - (con // i)) % con
self.finv[i] = self.finv[i - 1] * self.inv[i] % con
def com(self, N, k):
return (self.fac[N] * self.finv[k] * self.finv[N - k]) % con
#処理内容
def main():
N, K = getlist()
if K >= N:
Com = Combination(2 * N - 1, con)
ans = Com.com(2 * N - 1, N)
print(ans)
else:
Com1 = Combination(N, con)
Com2 = Combination(N - 1, con)
ans = 0
for i in range(1, K + 1):
ans += Com1.com(N, i) * Com2.com(N - 1, i)
ans %= con
ans = (ans + 1) % con
print(ans)
if __name__ == '__main__':
main()
| 0 | null | 34,074,688,863,390 | 60 | 215 |
h,n = map(int,input().split())
Mag = []
for i in range(n):
AB = list(map(int,input().split()))
Mag.append(AB)
dp = [[float("inf")]*(h+1) for i in range(n+1)]
dp[0][0] = 0
for i in range(n):
for j in range(h+1):
dp[i+1][j] = min(dp[i+1][j],dp[i][j])
dp[i+1][min(j+Mag[i][0],h)] = min(dp[i+1][min(j+Mag[i][0],h)],dp[i+1][j]+Mag[i][1])
print(dp[n][h])
|
N,A,B=map(int,input().split())
if (B-A)%2==0:
ans =(B-A)//2
else:
if A-1 > N-B:
ans = N-B+1
A+=ans
ans+=(N-A)//2
else:
ans =A
B-=ans
ans+=(B-1)//2
print(ans)
| 0 | null | 95,314,955,426,742 | 229 | 253 |
def resolve():
X = list(map(int, input().split()))
print(X.index(0)+1)
if '__main__' == __name__:
resolve()
|
S: str = input()
n = len(S)
if not S == S[::-1]:
print('No')
exit()
end = (n-1)//2
SS = S[:end]
if not SS == SS[::-1]:
print('No')
exit()
start = (n+3)//2 - 1
SSS = S[start:n]
if not SSS == SSS[::-1]:
print('No')
exit()
print('Yes')
| 0 | null | 29,871,946,145,020 | 126 | 190 |
D = int(input())
C = [int(T) for T in input().split()]
S = [[] for TD in range(0,D)]
for TD in range(0,D):
S[TD] = [int(T) for T in input().split()]
for TD in range(0,D):
print(S[TD].index(max(S[TD]))+1)
|
#!python3
from time import perf_counter
limit = 1.92
tick = perf_counter()
import sys
iim = lambda: map(int, sys.stdin.readline().rstrip().split())
from random import randrange
from bisect import bisect
def resolve():
G = 26
it = map(int, sys.stdin.read().split())
D = next(it)
C = [next(it) for i in range(G)]
S = [[next(it) for i in range(G)] for i in range(D)]
L = [[-1] for i in range(G)]
T = [0] * D
def update(di, qi):
score = 0
t0 = T[di]
score += S[di][qi]-S[di][t0]
a1 = li = L[t0][:]
ii = li.index(di)
la = D if len(li)-1 == ii else li[ii+1]
score -= C[t0] * (di-li[ii-1])*(la-di)
li.pop(ii)
a2 = li = L[qi][:]
ii = bisect(li, di)
li.insert(ii, di)
la = D if len(li)-1 == ii else li[ii+1]
score += C[qi] * (di-li[ii-1])*(la-di)
return score, (a1, a2)
U = 7
def calc(i, j):
score = S[i][j]
for k in range(G):
u = k - L[k][-1]
score -= C[k] * (u + u + U) * U // 2
score += C[k] * U * (i-L[j][-1])
return score
def dswap(di, dj):
qi, qj = T[di], T[dj]
swap0 = (L[qi], L[qj])
score, swap1 = update(di, qj)
T[di] = qj
L[qi], L[qj] = swap1
diff, swap2 = update(dj, qi)
score += diff
if score > 0:
T[dj] = qi
L[qj], L[qi] = swap2
else:
score = 0
T[di], T[dj] = qi, qj
L[qi], L[qj] = swap0
return score
def fullscore():
score = 0
last = [-1] * 26
for i, ti in enumerate(T):
score += S[i][ti]
last[ti] = i
for ci, la in zip(C, last):
score -= ci * (i-la)
return score
for di in range(D):
i, score = 0, calc(di, 0)
for qi in range(1, G):
x = calc(di, qi)
if x > score:
i, score = qi, x
T[di] = i
L[i].append(di)
print(*(i+1 for i in T), sep="\n")
if __name__ == "__main__":
resolve()
| 1 | 9,704,301,986,288 | null | 113 | 113 |
import os, sys, re, math
S = input()
dow = ['SUN', 'MON', 'TUE', 'WED', 'THU', 'FRI', 'SAT']
print(7 - dow.index(S))
|
from collections import deque
s=deque(input())
q=int(input())
qq=[list(input().split()) for i in range(q)]
rl=1
fleft=deque()
fright=deque()
for i in qq:
if i[0]=='1':
rl*=-1
else:
if i[1]=='1':
if rl==1:
fleft.appendleft(i[2])
else:
fright.append(i[2])
else:
if rl==1:
fright.append(i[2])
else:
fleft.appendleft(i[2])
fleft.reverse()
s.extendleft(fleft)
s.extend(fright)
if rl==-1:
s.reverse()
print(''.join(s))
| 0 | null | 95,253,632,249,508 | 270 | 204 |
def main():
C = input()
ans = chr(ord(C) + 1)
print(ans)
if __name__ == "__main__":
main()
|
N = input()
print(chr(ord(N)+1))
| 1 | 92,212,881,527,012 | null | 239 | 239 |
N = int(input())
P = list(map(int, input().split()))
mmin = P[0]
ans = 0
for i in range(N):
if mmin < P[i]:
continue
else:
mmin = P[i]
ans += 1
print(ans)
|
import math
a = [int(s) for s in input().split()]
b = int(max([a[0], a[1]]))
c = int(min([a[0], a[1]]))
d = 0.5 * (a[2] * 60 + a[3])
e = 6 * a[3]
f = abs(d - int(e))
if f >= 180:
f = 360 - f
if f != 0 and f!= 180:
print(math.sqrt(a[0] ** 2 + a[1] ** 2 - 2 * a[0] * a[1] * math.cos(math.radians(f))))
elif f == 0:
print(b-c)
else:
print(b+c)
| 0 | null | 53,025,201,139,848 | 233 | 144 |
n = int(input())
s = 0
for i in range(1,n+1):
if i!=3 and i!=5 and i%3!=0 and i%5!=0:
s+=i
print(s)
|
N = int(input())
Count = 0
for T in range(1,N+1):
if not (T%3==0 or T%5==0):
Count = Count+T
print(Count)
| 1 | 34,647,436,129,500 | null | 173 | 173 |
import math
import collections
n = int(input())
iwashi = []
sub_ans = 0
for i in range(n):
a, b = map(int, input().split())
if a == 0 and b == 0:
sub_ans += 1
else:
if b == 0:
iwashi.append('1/0')
elif b > 0:
c = math.gcd(a, b)
iwashi.append('{}/{}'.format(a//c, b//c))
else:
c = math.gcd(a, b)
iwashi.append('{}/{}'.format(-a//c, -b//c))
# print(iwashi)
iwashi = collections.Counter(iwashi)
k_list = list(iwashi.keys())
v = list(iwashi.values())
# k_list.sort(key=lambda x: -x)
mod = 1000000007
ans = 1
for k in k_list:
a = iwashi[k]
if k == '1/0':
anti_k = '0/1'
elif k == '0/1':
anti_k = '1/0'
else:
c, d = k.split('/')
if int(c) < 0:
anti_k = '{}/{}'.format(d, -int(c))
else:
anti_k = '{}/{}'.format(-int(d), c)
b = iwashi[anti_k]
if a*b != 0:
ans *= (pow(2, a, mod) + pow(2, b, mod) -1)
else:
ans *= pow(2, a, mod)
iwashi[k] = 0
iwashi[anti_k] = 0
# print(k, anti_k ,a, b, ans)
ans %= mod
print((ans+sub_ans-1)%mod)
|
import sys
S = input()
if not ( len(S) == 6 and S.islower() ): sys.exit()
print('Yes') if S[2] == S[3] and S[4] == S[5] else print('No')
| 0 | null | 31,494,275,688,414 | 146 | 184 |
N,M=map(int,input().split())
class UnionFind():
def __init__(self,n): #n:要素数
self.n=n
self.parents = [-1]*n
#parents:各要素の親要素番号を格納
#要素が根である場合、-(そのグループの要素数)を格納する
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のグループ|
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)]
uf=UnionFind(N)
for i in range(M):
a,b=map(lambda x:int(x)-1,input().split())
uf.union(a,b)
ans=0
for i in range(N):
if uf.size(i) > ans:
ans=uf.size(i)
print(ans)
|
#D - Friends
N,M = map(int,input().split())
par = [i for i in range(N)]
rank = [1] * (N)
def find(x):
if par[x] == x:
return x
else:
par[x] = find(par[x]) #経路圧縮
return par[x]
def size(x):
return par.count(find(x))
def unite(x,y):
x = find(x)
y = find(y)
if x == y : return 0
if par[x] > par[y]:
x,y = y,x
par[y] = x
# par[x] = x
if par[x] == par[y]:
rank[x] += rank[y]
# rank[y] += rank[x]
#print(par)
#print(rank)
for i in range(M):
a,b = map(int,input().split())
a -= 1
b -= 1
unite(a,b)
# print(par)
# print(rank)
group_count = 0
group_count = max(rank)
# 出力
print(group_count)
| 1 | 3,952,144,352,884 | null | 84 | 84 |
k = "a",
for _ in range(int(input()) - 1):
k = {a + b for a in k for b in a + chr(ord(max(a)) + 1)}
print(*sorted(k))
|
#!/usr/bin/env python3
import sys
input = sys.stdin.readline
a = [1, 1, 1, 2, 1, 2, 1, 5, 2, 2, 1, 5, 1, 2, 1, 14, 1, 5, 1, 5, 2, 2, 1, 15, 2, 2, 5, 4, 1, 4, 1, 51]
k = int(input())
print(a[k-1])
| 0 | null | 51,025,700,084,000 | 198 | 195 |
s = input()
n = len(s)
l1 = int((n-1)/2)
l2 = int((n+3)/2)
if s == s[::-1] and s[:l1] == s[l2-1:n] :
print('Yes')
else :
print('No')
|
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)
| 0 | null | 23,115,866,791,720 | 190 | 15 |
import sys
input=sys.stdin.readline
count=0
res=""
str=input()
list=[]
for i in range(len(str)):
list.append(str[i])
for i in range(len(str)):
if str[i]=="?":
if i==0:
if list[1]=="D":
list[0]="P"
else:
list[0]="D"
elif i+1==len(str):
list[i]="D"
else:
if list[i-1]=="P":
list[i]="D"
else:
if list[i+1]=="D" or list[i+1]=="?":
list[i]="P"
else:
list[i]="D"
for i in range(len(str)):
res+=list[i]
print(res)
|
s = list(input())
q = int(input())
l1 = []
l2 = []
rev = False
for i in range(q):
inp = input()
if inp[0] == "1":
if rev:
rev = False
else:
rev = True
elif inp[2] == "1":
a = inp[4]
if rev:
l2.append(a)
else:
l1.append(a)
else:
a = inp[4]
if rev:
l1.append(a)
else:
l2.append(a)
l1.reverse()
ans = l1 + s + l2
if rev:
ans.reverse()
print("".join(ans))
| 0 | null | 37,803,827,990,620 | 140 | 204 |
import math
def at(x):
return math.degrees(math.atan(x))
a, b, x = map(int, input().split())
print(at(a*b*b/(2*x)) if 2*x < a*a*b else at(2*(a*a*b-x)/(a**3)))
|
from decimal import Decimal
import math
a, b, x = list(map(Decimal, input().split()))
if a * a * b > 2 * x:
tri = x / a
c = tri * Decimal(2) / b
d = (c ** 2 + b ** 2) ** Decimal("0.5")
cos_a = (b ** 2 + d ** 2 - c ** 2) / (2*b*d)
print(90 - math.degrees(math.acos(cos_a)))
else:
tri = (a * a * b - x) / a
e = tri * Decimal(2) / a
f = (a ** 2 + e ** 2) ** Decimal("0.5")
cos_e = (f ** 2 + a ** 2 - e ** 2) / (2*f*a)
print(math.degrees(math.acos(cos_e)))
#print(cosin)
| 1 | 163,459,296,168,818 | null | 289 | 289 |
N, M, K = map(int, input().split())
A = list(map(int, input().split()))
B = list(map(int, input().split()))
ruiseki_A = [0]
ruiseki_B = [0]
for i in range(len(A)):
ruiseki_A.append(ruiseki_A[i]+A[i])
for i in range(len(B)):
ruiseki_B.append(ruiseki_B[i]+B[i])
#print(ruiseki_A)
ans = 0
for i in range(len(ruiseki_A)):
tmp = K - ruiseki_A[i]
if tmp < 0:
continue
r = len(ruiseki_B)
l = 0
while r-l > 1:
mid = (r + l) // 2
if ruiseki_B[mid] <= tmp:
l = mid
else:
r = mid
ans = max(ans, i+l)
print(ans)
|
import itertools
import bisect
n,m,k=map(int,input().split())
a=list(map(int,input().split()))
b=list(map(int,input().split()))
sum_a=list(itertools.accumulate(a))
sum_b=list(itertools.accumulate(b))
result=bisect.bisect_right(sum_b,k)
for i in range(n):
if sum_a[i]<=k:
result=max(result,i+1+bisect.bisect_right(sum_b,k-sum_a[i]))
print(result)
| 1 | 10,756,886,810,738 | null | 117 | 117 |
import sys
sys.setrecursionlimit(10**9)
n = int(input())
neighbors = [[] for i in range(n+1)]
ab = []
for i in range(n-1):
line = list(map(int, input().split()))
neighbors[line[0]].append(line[1])
neighbors[line[1]].append(line[0])
ab.append((line[0], line[1]))
maximum = 0
neighbors_max = 0
for i in range(n):
if maximum < len(neighbors[i]):
neighbors_max = i
maximum = len(neighbors[i])
edgecolors = {}
reached = {neighbors_max}
def make_other_colors(c, m):
res = []
if c > m:
res += [i+1 for i in range(m)]
else:
res += [i+1 for i in range(c-1)]
res += [maximum-i for i in range(m-c+1)]
return res
def coloring(v, c):
if c == 0:
reached.add(v)
for i in range(len(neighbors[v])):
edgecolors[(v, neighbors[v][i])] = i + 1
edgecolors[(neighbors[v][i], v)] = i + 1
reached.add(neighbors[v][i])
coloring(neighbors[v][i], i+1)
return
l = len(neighbors[v])
if l == 1 and neighbors[v][0] in reached:
reached.add(v)
return
other_colors = make_other_colors(c, l-1)
i = 0
j = 0
while i < l:
if neighbors[v][i] in reached:
i += 1
continue
edgecolors[(v, neighbors[v][i])] = other_colors[j]
edgecolors[(neighbors[v][i], v)] = other_colors[j]
reached.add(neighbors[v][i])
coloring(neighbors[v][i], other_colors[j])
i += 1
j += 1
coloring(neighbors_max, 0)
print(maximum)
for i in ab:
print(edgecolors[i])
|
l,r,d = map(int, input().split())
var=l//d
var1=r//d
ans=var1-var
if l%d==0:
ans+=1
print(ans)
| 0 | null | 71,849,377,230,592 | 272 | 104 |
N = int(input())
A = [int(i) for i in input().split()]
A1 = 1
if 0 in A:
print(0)
else:
for j in range(N):
A1 *= A[j]
if A1>10**18:
print(-1)
break
else:
print(A1)
|
def readinput():
n,k=map(int,input().split())
lr=[]
for _ in range(k):
l,r=map(int,input().split())
lr.append((l,r))
return n,k,lr
def main(n,k,lr):
lrs=sorted(lr,key=lambda x:x[0])
MOD=998244353
dp=[0]*(n+1)
dp[1]=1
for i in range(1,n):
#print(i)
if dp[i]==0:
continue
skip=False
for l,r in lrs:
for j in range(l,r+1):
#print('i+j: {}'.format(i+j))
if i+j>n:
skip=True
break
dp[i+j]=(dp[i+j]+dp[i])%MOD
#print(dp)
if skip:
break
return dp[n]
def main2(n,k,lr):
lrs=sorted(lr,key=lambda x:x[0])
MOD=998244353
dp=[0]*(n+1)
ruiseki=[0]*(n+1)
dp[1]=1
ruiseki[1]=1
for i in range(2,n+1):
for l,r in lrs:
if i-l<1:
break
dp[i]+=ruiseki[i-l]-ruiseki[max(1,i-r)-1]
dp[i]=dp[i]%MOD
ruiseki[i]=(ruiseki[i-1]+dp[i])%MOD
return dp[n]
if __name__=='__main__':
n,k,lr=readinput()
ans=main2(n,k,lr)
print(ans)
| 0 | null | 9,497,464,718,776 | 134 | 74 |
from math import gcd
import sys
N, M = map(int, input().split())
A = list(map(int, input().split()))
lcm = 1
for a in A:
gcd_ = gcd(lcm, a//2)
lcm = lcm * (a // 2 // gcd_)
for a in A:
if (lcm // (a // 2)) % 2 == 0:
print(0)
sys.exit()
print(M // lcm - M // (2 * lcm))
|
# ABC150D
import sys
input=sys.stdin.readline
from math import gcd,ceil
def main():
N,M=map(int,input().split())
A=list(map(lambda x: int(x)//2,input().split()))
lcm=A[0]
for i in range(1,N):
lcm=lcm*A[i]//gcd(lcm,A[i])
allo=1
for i in range(N):
allo&=(lcm//A[i])%2
if allo:
print(ceil(int(M//lcm)/2))
else:
print(0)
if __name__=="__main__":
main()
| 1 | 101,853,596,428,470 | null | 247 | 247 |
N, M = [int(n) for n in input().split()]
solved = {}
result = {}
for i in range(M):
p, S = input().split()
status = result.setdefault(p, [])
if len(status)==0:
result[p] = []
solved[p] = False
if S == 'AC':
solved[p] = True
result[p].append(S)
ans = 0
wa = 0
for k, v in solved.items():
if v:
ans += 1
wa += result[k].index('AC')
print(ans , wa)
|
N = int(input())
A = list(map(int, input().split()))
money = 1000
kabu = 0
for i in range(N-1):
if kabu > 0:
money += kabu*A[i]
kabu = 0
if A[i] < A[i+1]:
kabu = money//A[i]
money -= kabu*A[i]
if kabu > 0:
money += kabu*A[-1]
print(money)
| 0 | null | 50,109,155,829,800 | 240 | 103 |
C = input()
a = 'abcdefghijklmnopqrstuvwxyz'
print(a[a.index(C) + 1 ])
|
n=int(input())
s=100000
for _ in range(n):
s*=1.05
if s%1000!=0:
s+=1000-s%1000
print(int(s))
| 0 | null | 46,018,010,667,872 | 239 | 6 |
S = raw_input()
n = int(raw_input())
for i in range(n):
command = (raw_input()).split(" ")
if command[0] == "print":
a = int(command[1])
b = int(command[2])
print S[a:b+1]
elif command[0] == "reverse":
a = int(command[1])
b = int(command[2])
T = S[a:b+1]
S = S[0:a] + T[::-1] + S[b+1:]
else:
a = int(command[1])
b = int(command[2])
S = S[0:a] + command[3] + S[b+1:]
|
n, m = map(int, input().split())
s = input()
s = ''.join(reversed(s))
ans = []
index = 0
while index < n:
next_index = -1
for j in range(min(index + m, n), index, -1):
if s[j] == '0':
next_index = j
break
if next_index == -1:
ans = [-1]
break
ans.append(next_index - index)
index = next_index
print(' '.join(list(map(str, list(reversed(ans))))))
| 0 | null | 70,476,542,342,208 | 68 | 274 |
import math
print(int(math.ceil(int(input())/2)-1))
|
import sys
from functools import lru_cache
from collections import defaultdict
inf = float('inf')
readline = sys.stdin.buffer.readline
readlines = sys.stdin.buffer.readlines
sys.setrecursionlimit(10**6)
def input(): return sys.stdin.readline().rstrip()
def read():
return int(readline())
def reads():
return map(int, readline().split())
a,b,n=reads()
x=min(b-1,n)
print(int((a*x)/b))
| 0 | null | 90,839,087,749,410 | 283 | 161 |
S = input()
T = input()
ans = ''
if len(T) != len(S) + 1:
ans = 'No'
else:
ans = 'Yes'
for i in range(len(S)):
if S[i] != T[i]:
ans = 'No'
print(ans)
|
S=input()
T=input()
S=list(S)
T=list(T)
b=0
for i in range(0,len(S)):
if not S[i]==T[i]:
b+=1
if len(T)==len(S)+1 and b==0:
print("Yes")
else:
print("No")
| 1 | 21,437,234,176,938 | null | 147 | 147 |
# ある行について、
# 最初のイチゴが出てから、次のイチゴの手前までを一つの番号とする
# それ以降は、次のイチゴが出る手前までを次の番号とする
# イチゴがない行があったら、となりの行の結果をコピーする
import sys
readline = sys.stdin.readline
H,W,K = map(int,readline().split())
A = [readline().rstrip() for i in range(H)]
ans = [[0] * W for i in range(H)]
exist_straw = [True] * H
num = 0 # 次の番号
for i in range(H):
# イチゴがない行はいったん後回し
if "#" not in A[i]:
exist_straw[i] = False
continue
num += 1
# イチゴが出たらnumを1増やしてから更新 ただし最初のイチゴは無視
first = True
for j in range(W):
if A[i][j] == "#":
if first:
first = False
else:
num += 1
ans[i][j] = num
# 行を上から順に見て、ある行にはイチゴが存在して、次の行には存在しない場合、行をコピーする
# それを逆順も実行すると全ての行が埋まる
for i in range(H - 1):
if exist_straw[i] and not exist_straw[i + 1]:
ans[i + 1] = ans[i]
exist_straw[i + 1] = True
for i in range(H - 1,0,-1):
if exist_straw[i] and not exist_straw[i - 1]:
ans[i - 1] = ans[i]
exist_straw[i - 1] = True
for a in ans:
print(*a)
|
from collections import deque
def BFS():
color=["white" for _ in range(h)]
D=[-1 for _ in range(h)]
M=[[] for _ in range(h)]
for i in range(h-1):
M[i].append(i+1)
M[i+1].append(i)
queue=deque([])
for i in line:
queue.append(i)
D[i]=i
color[i]="gray"
while len(queue)>0:
u=queue.popleft()
for i in M[u]:
if D[i]==-1 and color[i]=="white":
D[i]=D[u]
color[i]="gray"
queue.append(i)
return D
h,w,k=map(int,input().split())
S=[list(input()) for _ in range(h)]
M=[[0 for _ in range(w)] for _ in range(h)]
num,line=0,[]
for i in range(h):
if S[i].count("#")!=0:
p=num
for j in range(w):
if S[i][j]=="#":
num +=1
elif num==p:
M[i][j]=num+1
continue
M[i][j]=num
line.append(i)
D=BFS()
for i in range(h):
M[i]=M[D[i]]
for i in range(h):
print(*M[i])
| 1 | 144,419,134,645,268 | null | 277 | 277 |
A = set(map(int,input().split()))
print("Yes" if len(A)==2 else "No")
|
# 155 A
a, b, c = input().split()
if a == b == c or (a != b and b != c and c != a):
print("No")
else:
print("Yes")
| 1 | 67,867,108,641,500 | null | 216 | 216 |
n = input()
a = map(int,raw_input().split())
s = 0
m = a[0]
M = a[0]
for i in range(0,n):
s = s + a[i]
if m > a[i]:
m = a[i]
if M < a[i]:
M = a[i]
print m,M,s
|
import sys
import math
from collections import deque
n,m = map(int, input().split())
q = [0]*(n+1)
graph = [[] for _ in range(n+1)]
for i in range(m):
a, b = map(int, input().split())
graph[a].append(b)
graph[b].append(a)
dist = [-1] * (n+1)
dist[0] = 0
dist[1] = 0
# if m == 0:
# print(1)
# exit()
d = deque()
a = 0
for l,j in enumerate(q):
b = set()
if j == 0:
d.append(l)
while d:
v = d.popleft()
b.add(v)
q[v] = -1
for i in graph[v]:
b.add(i)
q[i] = -1
if dist[i] != -1:
continue
dist[i] = dist[v] + 1
d.append(i)
a = max(a,len(b))
print(a)
| 0 | null | 2,334,810,772,800 | 48 | 84 |
N = int(input())
A = list(map(int,input().split()))
Q = int(input())
S = [list(map(int, input().split())) for l in range(Q)]
l = [0] * 10**6
tot = 0
for i in range(N) :
l[A[i]]+=1
tot += A[i]
for i in range(Q):
s0 = S[i][0]
s1 = S[i][1]
tot += s1 * (l[s0] + l[s1]) - (s0 * l[s0] + s1*l[s1])
l[s1] += l[s0]
l[s0] = 0
print(tot)
|
N, X, T = map(int, input().split())
print(T*-(-N//X))
| 0 | null | 8,194,132,373,152 | 122 | 86 |
def readinput():
n=int(input())
return n
def main(n):
ans=0
for i in range(1,n+1):
if i%3==0 or i%5==0:
continue
else:
ans+=i
return ans
if __name__=='__main__':
n=readinput()
ans=main(n)
print(ans)
|
import numpy as np
N = int(input())
ans = 0
for i in range(1, N + 1):
if ((i % 3) != 0) & ((i % 5) != 0):
ans += i
print(ans)
| 1 | 35,020,600,317,430 | null | 173 | 173 |
import numba
@numba.njit
def main(N):
x = 0
for i in range(1,N+1):
for j in range(i,N+1,i):
x += j
return x
N = int(input())
print(main(N))
|
# Problem D - Sum of Divisors
# input
N = int(input())
# initialization
count = 0
# count
for j in range(1, N+1):
M = N // j
count += j * ((M * (M+1)) // 2)
# output
print(count)
| 1 | 11,028,998,053,710 | null | 118 | 118 |
from collections import defaultdict
import math
mod = 1000000007
pos = defaultdict(int)
neg = defaultdict(int)
zero = 0
n = int(input())
for _ in range(n):
a, b = list(map(int, input().split()))
if a == b == 0:
zero += 1
elif a == 0:
pos[(0, 1)] += 1
elif b == 0:
neg[(0, 1)] += 1
else:
c = a * b
g = math.gcd(a, b)
a, b = abs(a // g), abs(b // g)
if c > 0:
pos[(a, b)] += 1
elif c < 0:
neg[(b, a)] += 1
cnt = 1
for x in pos.keys():
if x in neg.keys():
cnt = (cnt * (pow(2, pos[x], mod) + pow(2, neg[x], mod) - 1)) % mod
del neg[x]
else:
cnt = (cnt * pow(2, pos[x], mod)) % mod
for x in neg.keys():
cnt = (cnt * pow(2, neg[x], mod)) % mod
print((zero + cnt - 1) % mod)
|
import sys
sys.setrecursionlimit(300000)
from fractions import gcd
from collections import defaultdict
def I(): return int(sys.stdin.readline())
def MI(): return map(int, sys.stdin.readline().split())
def LMI(): return list(map(int, sys.stdin.readline().split()))
MOD = 10 ** 9 + 7
INF = float('inf')
N = I()
d = defaultdict(int)
zero = 0
for i in range(N):
a, b = MI()
if a == 0 and b == 0:
zero += 1
continue
g = gcd(a, b)
a, b = a // g, b // g
minus = (-1) ** ((a < 0) + (b < 0))
d[(minus * abs(a), abs(b))] += 1
ans = 1
seen = set()
for a, b in d:
if (a, b) not in seen:
if (a, b) in [(1, 0), (0, 1)]:
ainv, binv = b, a
else:
ainv, binv = b * (1 if a < 0 else -1), abs(a)
lans = (2 ** d[(a, b)] - 1)
lans += (2 ** d[(ainv, binv)] - 1) if d.get((ainv, binv)) is not None else 0
lans += 1
ans = ans * lans % MOD
seen.add((a, b))
seen.add((ainv, binv))
ans = (ans + zero) % MOD
print((ans + MOD - 1) % MOD)
| 1 | 20,827,691,111,150 | null | 146 | 146 |
from math import pi # 円周率
# 浮動小数点数で読む
r = float(input())
area = r * r * pi
cir =(r+r) * pi
print(f'{(area):.6f} {(cir):.6f}')
|
l='#.'*999
while 1:
h,w=map(int,raw_input().split());s=""
if h==0:break
for i in range(h):s+=l[i%2:w+i%2]+"\n"
print s
| 0 | null | 751,597,916,900 | 46 | 51 |
N = int(input())
MOD = 10**9 + 7
print((pow(10, N, MOD) - ( (pow(9, N, MOD)*2)%MOD - pow(8, N, MOD) )%MOD )%MOD)
|
import sys
from collections import defaultdict
readline = sys.stdin.buffer.readline
#sys.setrecursionlimit(10**8)
def geta(fn=lambda s: s.decode()):
return map(fn, readline().split())
def gete(fn=lambda s: s.decode()):
return fn(readline().rstrip())
def main():
n = gete(int)
d = tuple(geta(int))
print(((sum(d)**2 - sum([di**2 for di in d]))) // 2)
if __name__ == "__main__":
main()
| 0 | null | 85,852,700,535,940 | 78 | 292 |
h,w,k=map(int, input().split())
s=[list(input()) for _ in range(h)]
ans=[[0]*w for i in range(h)]
cnt=1
for i in range(h):
for j in range(w):
if s[i][j]=="#":
ans[i][j]=cnt
cnt+=1
for i in range(h):
for j in range(w):
if ans[i][j]==0:
if j!=0:
ans[i][j]=ans[i][j-1]
for i in range(h):
for j in range(w-1, -1, -1):
if ans[i][j]==0:
if j!=(w-1):
ans[i][j]=ans[i][j+1]
# for i in range(h):
# print(*ans[i])
# print()
for i in range(h):
for j in range(w):
if ans[i][j]==0:
if i!=0:
ans[i][j]=ans[i-1][j]
for i in range(h-1, -1, -1):
for j in range(w):
if ans[i][j]==0:
if i!=(h-1):
ans[i][j]=ans[i+1][j]
for i in range(h):
print(*ans[i])
|
import sys
input = sys.stdin.readline
from bisect import *
H, W, K = map(int, input().split())
S = [input()[:-1] for _ in range(H)]
ans = [[-1]*W for _ in range(H)]
now = 1
l = []
for i in range(H):
cnt = 0
for j in range(W):
if S[i][j]=='#':
cnt += 1
if cnt==0:
continue
l.append(i)
c = 0
for j in range(W):
ans[i][j] = now
if S[i][j]=='#':
c += 1
if c<cnt:
now += 1
now += 1
for i in range(H):
if '#' not in S[i]:
j = bisect_left(l, i)
if j==len(l):
for k in range(W):
ans[i][k] = ans[l[-1]][k]
else:
for k in range(W):
ans[i][k] = ans[l[j]][k]
for ans_i in ans:
print(*ans_i)
| 1 | 143,407,272,599,750 | null | 277 | 277 |
a, b, k = map(int, input().split())
if (a >= k):
aa = a - k
bb = b
else:
aa = 0
bb = max(0, b - (k - a))
print(aa, bb)
|
N, K = list(map(int, input().split()))
A = list(map(int, input().split()))
dp = [0] * (N + 1)
for k in range(K):
sta = [max(i-A[i], 0) for i in range(N)]
end = [min(i+A[i]+1, N) for i in range(N)]
for s in sta:
dp[s] += 1
for e in end:
dp[e] -= 1
for i in range(1, len(dp)-1):
dp[i] += dp[i-1]
B = dp[:-1]
if A == B:
break
A = B
dp = [0] * (N + 1)
print(' '.join(map(str, A)))
| 0 | null | 60,005,940,848,672 | 249 | 132 |
import math
s=input()
count=0
for i in range(0,math.floor(len(s)/2)):
if s[i]!=s[len(s)-i-1]:
count=count+1
print(count)
|
MOD=10**9+7
def facinv(N):
fac,finv,inv=[0]*(N+1),[0]*(N+1),[0]*(N+1)#階乗テーブル、逆元テーブル、逆元
fac[0]=1;fac[1]=1;finv[0]=1;finv[1]=1;inv[1]=1
for i in range(2,N+1):
fac[i]=fac[i-1]*i%MOD
inv[i]=MOD-inv[MOD%i]*(MOD//i)%MOD
finv[i]=finv[i-1]*inv[i]%MOD
return fac,finv,inv
def COM(n,r):
if n<r or r<0:
return 0
else:
return ((fac[n]*finv[r])%MOD*finv[n-r])%MOD
n,k=map(int,input().split())
fac,finv,inv=facinv(2*n)
if k>=n-1:
print(COM(2*n-1,n-1))
else:
ans=COM(2*n-1,n-1)
for i in range(1,n-k):
ans=(ans-COM(n,i)*COM(n-1,i-1)%MOD+MOD)%MOD
print(ans%MOD)
| 0 | null | 93,702,653,496,188 | 261 | 215 |
#!python3
LI = lambda: list(map(int, input().split()))
# input
K = int(input())
S = input()
MOD = 10 ** 9 + 7
MAX = 2 * (10 ** 6) + 1
p25, p26 = [None] * MAX, [None] * MAX
fac, finv, inv = [None] * MAX, [None] * MAX, [None] * MAX
def comb_init():
fac[0] = fac[1] = 1
finv[0] = finv[1] = 1
inv[1] = 1
for i in range(2, MAX):
fac[i] = fac[i - 1] * i % MOD
inv[i] = -inv[MOD%i] * int(MOD / i) % MOD
finv[i] = finv[i - 1] * inv[i] % MOD
def comb(n, k):
if n < k or n < 0 or k < 0:
return 0
return fac[n] * (finv[k] * finv[n - k] % MOD) % MOD
def power_init():
p25[0] = 1
p26[0] = 1
for i in range(1, MAX):
p25[i] = p25[i - 1] * 25 % MOD
p26[i] = p26[i - 1] * 26 % MOD
def main():
comb_init()
power_init()
n = len(S)
ans = 0
for i in range(K + 1):
x = p25[i] * comb(i + n - 1, n - 1) % MOD * p26[K - i] % MOD
ans = (ans + x) % MOD
print(ans)
if __name__ == "__main__":
main()
|
import sys
sys.setrecursionlimit(10**7)
K=int(input())
S=input()
M=len(S)
N=K+M
mod=10**9+7
ans=pow(26,N,mod)
class Data():
def __init__(self):
self.power=1
self.rev=1
class Combi():
def __init__(self,N,mod):
self.lists=[Data() for _ in range(N+1)]
self.mod=mod
for i in range(2,N+1):
self.lists[i].power=((self.lists[i-1].power)*i)%self.mod
self.lists[N].rev=pow(self.lists[N].power,self.mod-2,self.mod)
for j in range(N,0,-1):
self.lists[j-1].rev=((self.lists[j].rev)*j)%self.mod
def combi(self,K,R):
if K<R:
return 0
else:
return ((self.lists[K].power)*(self.lists[K-R].rev)*(self.lists[R].rev))%self.mod
c=Combi(2*10**6+10000,mod)
for i in range(M):
ans-=c.combi(N,i)*pow(25,N-i,mod)
ans%=mod
print(ans%mod)
| 1 | 12,787,302,056,960 | null | 124 | 124 |
import math
sentinel = 1e9 + 1
counter = 0
def merge(a, left, mid, right):
global counter
L = a[left:mid] + [sentinel]
R = a[mid:right] + [sentinel]
i,j = 0,0
for k in range(left, right):
if(L[i] <= R[j]):
a[k] = L[i]
i += 1
else:
a[k] = R[j]
j += 1
counter += right - left
def mergeSort(a, left, right):
if left+1 < right:
mid = (left + right) // 2
mergeSort(a, left, mid)
mergeSort(a, mid, right)
merge(a, left, mid, right)
n = int(input())
a = list(map(int, input().split()))
mergeSort(a, 0, n)
print(*a)
print(counter)
|
def resolve():
n=int(input())
a=list(map(int,input().split()))
q=int(input())
m=list(map(int,input().split()))
sa=[0]*100000
for i in range(2**n):
s=0
for j in range(n):
if i>>j&1:
s+=a[j]
sa[s]=1
for i in m:
if sa[i]==0:
print('no')
else:
print('yes')
if __name__ == '__main__':
resolve()
| 0 | null | 106,071,032,544 | 26 | 25 |
from collections import deque
n = int(input())
Q = deque()
for _ in range(n):
query = input()
if query=='deleteFirst':
Q.popleft()
elif query=='deleteLast':
Q.pop()
else:
q, x = query.split()
if q=='insert':
Q.appendleft(x)
else:
try:
Q.remove(x)
except ValueError:
pass
print(' '.join(Q))
|
import collections
a = collections.deque()
for i in range(int(input())):
b = input()
# 命令がinsertだった場合、
if b[0] == 'i':
# キーxを先頭に追加(数字は文字列bの7文字目以降にある)
a.appendleft(b[7:])
# 命令がdeleteだった場合
elif b[6] == ' ':
# 命令のキーが含まれる場合そのキーのデータを消すが、なければ何もしない
try:
a.remove(b[7:])
except:
pass
# 命令がdeleteFirstだった場合
elif len(b) > 10:
a.popleft()
# 命令がdeleteLastだった場合
elif len(b) > 6:
a.pop()
print(*a)
| 1 | 50,535,403,776 | null | 20 | 20 |
L, R, d = map(int, input().split())
print(R // d - L // d + (L % d == 0))
|
if __name__ == '__main__':
N, M = map(int, input().split())
A = list(map(int, input().split()))
A = sorted(A)[::-1]
s = sum(A)
cnt = 0
for i in range(M):
if s<=4*M*A[i]:
cnt += 1
if cnt==M:
print("Yes")
else:
print("No")
| 0 | null | 23,081,750,133,280 | 104 | 179 |
X, Y, A, B, C = [int(x) for x in input().split()]
p = sorted([int(x) for x in input().split()], reverse=True)[:X]
q = sorted([int(x) for x in input().split()], reverse=True)[:Y]
r = sorted([int(x) for x in input().split()], reverse=True)[:X + Y]
s = sorted(p + q + r, reverse=True)
ans = sum(s[:X + Y])
print(ans)
|
D, T, S = map(float, input().split())
if D / S <= T:
print("Yes")
else:
print("No")
| 0 | null | 24,261,341,096,520 | 188 | 81 |
N = int(input())
c = list(str(input()))
r = c.count('R')
w = 0
for i in range(r):
if c[i] == 'W':
w += 1
print(w)
|
s = input()
ans = s[0:3]
print(ans)
| 0 | null | 10,538,287,579,132 | 98 | 130 |
X , Y = map(int,input().split())
a = 0
ans = "No"
for a in range(0,X+1):
if (a * 2)+((X-a) * 4)==Y:
ans = "Yes"
print(ans)
|
x,y = map(int,input().split())
A =(-y+4.0*x)/2.0
B = (y-2.0*x)/2.0
if A>=0 and B>=0 and A.is_integer() and B.is_integer():
print("Yes")
else:
print("No")
| 1 | 13,798,631,276,732 | null | 127 | 127 |
import sys
read = sys.stdin.read
def main():
N, K = map(int, read().split())
dp1 = [0] * (K + 1)
dp2 = [0] * (K + 1)
dp1[0] = 1
for x in map(int, str(N)):
dp1, dp1_prev = [0] * (K + 1), dp1
dp2, dp2_prev = [0] * (K + 1), dp2
for j in range(K, -1, -1):
if j > 0:
dp2[j] = dp2_prev[j - 1] * 9
if x != 0:
dp2[j] += dp1_prev[j - 1] * (x - 1)
dp2[j] += dp2_prev[j]
if x != 0:
dp2[j] += dp1_prev[j]
if x != 0:
if j > 0:
dp1[j] = dp1_prev[j - 1]
else:
dp1[j] = dp1_prev[j]
print(dp1[K] + dp2[K])
return
if __name__ == '__main__':
main()
|
def main():
N = input()
len_N = len(N)
K = int(input())
dp = [[[0] * 2 for _ in range(K + 5)] for _ in range(len_N + 5)]
dp[0][0][0] = 1
for i in range(len_N):
tmp = int(N[i])
for j in range(K+1):
# l : 1 => N より小さいことが確定
for l in range(2):
for x in range(10):
if l == 0:
if x > tmp:
continue
elif x == tmp:
if x == 0:
dp[i+1][j][0] += dp[i][j][0]
else:
dp[i+1][j+1][0] += dp[i][j][0]
else:
if x == 0:
dp[i+1][j][1] += dp[i][j][0]
else:
dp[i+1][j+1][1] += dp[i][j][0]
if l == 1:
if x == 0:
dp[i+1][j][1] += dp[i][j][1]
else:
dp[i+1][j+1][1] += dp[i][j][1]
print(dp[len_N][K][0] + dp[len_N][K][1])
if __name__ == "__main__":
main()
| 1 | 76,154,472,635,240 | null | 224 | 224 |
from collections import deque
def init_tree(x, par):
for i in range(x + 1):
par[i] = i
def find(x, par):
q = deque()
q.append(x)
while len(q) > 0:
v = q.pop()
if v == par[v]:
return v
q.append(par[v])
def union(x, y, par, rank):
px, py = find(x, par), find(y, par)
if px == py:
return
if rank[px] < rank[py]:
par[px] = py
return
elif rank[px] == rank[py]:
rank[px] += 1
par[py] = px
n, m, k = map(int, input().split())
par = [0] * (n + 1)
rank = [0] * (n + 1)
init_tree(n, par)
eg = [[] for _ in range(n + 1)]
for _ in range(m):
a, b = map(int, input().split())
union(a, b, par, rank)
eg[a].append(b)
eg[b].append(a)
for _ in range(k):
a, b = map(int, input().split())
eg[a].append(b)
eg[b].append(a)
xs = [0] * (n + 1)
ys = [0] * (n + 1)
for i in range(1, n + 1):
p = find(i, par)
xs[p] += 1
for v in eg[i]:
if p == find(v, par):
ys[i] += 1
ans = [-1] * (n + 1)
for i in range(1, n + 1):
ans[i] += xs[find(i, par)] - ys[i]
print(*ans[1:])
|
n,m = map(int, input().split())
A = list(map(int, input().split()))
rank = sum(A) / (4*m)
cnt =0
for a in A:
cnt += rank <= a
if cnt >= m:
print('Yes')
else:
print('No')
| 0 | null | 50,019,518,746,770 | 209 | 179 |
n=int(input())
A=list(map(int,input().split()) )
A.sort()
furui = [0] * (max(A) + 1)
for i in A:
if furui[i] >= 2:
continue
for j in range(i,len(furui),i):
furui[j] += 1
ans=0
for i in A:
if furui[i]==1:
ans+=1
print(ans)
|
from sys import stdin
input = stdin.readline
def main():
N = int(input())
A = sorted(list(map(int, input().split())))
not_divisible = [False]*(10**6+1)
for i in range(N):
not_divisible[A[i]] = True
prev = 0
for i in range(N):
if not_divisible[A[i]]:
j = A[i] + A[i]
while j <= A[-1]:
not_divisible[j] = False
j += A[i]
if prev == A[i]:
not_divisible[A[i]] = False
prev = A[i]
cnt = 0
for i in range(N):
if not_divisible[A[i]]:
cnt += 1
print(cnt)
if(__name__ == '__main__'):
main()
| 1 | 14,369,179,025,664 | null | 129 | 129 |
n,m=[int(x) for x in input().split()]
h=[int(x) for x in input().split()]
t=[[]for i in range(n)]
ans=0
for i in range(m):
a,b=[int(x) for x in input().split()]
t[a-1].append(b-1)
t[b-1].append(a-1)
for i in range(n):
if t[i]==[]:
ans+=1
else:
c=[]
for j in t[i]:
if h[i]<=h[j]:
c.append(False)
if c==[]:
ans+=1
print(ans)
|
import bisect,copy,heapq,itertools,string
from collections import *
from math import *
import sys
def input() : return sys.stdin.readline().strip()
def INT() : return int(input())
def MAP() : return map(int,input().split())
def LIST() : return list(MAP())
n, k, s = MAP()
ans = [0]*n
for i in range(n):
if(i < k):
ans[i] = s
else:
if(s == 1e9):
ans[i] = 1
else:
ans[i] = s + 1
print(*ans)
| 0 | null | 58,068,879,702,340 | 155 | 238 |
n = int(input())
A = list(map(int,input().split()))
ans = 0
t = 0
for e,(i , j) in enumerate(zip(A,A[1:])):
if i + t > j :
ans += t + i-j
t= t + i-j
else:t = 0
# print(t,ans)
print(ans)
|
X,Y = map(int, input().split())
if X * 2 > Y:
print('No')
elif X * 4 < Y:
print('No')
else:
for i in range(0,X+1):
if Y == (X * 2) + (i * 2):
print('Yes')
break
else:
print('No')
| 0 | null | 9,240,425,425,710 | 88 | 127 |
while True:
string = input().strip()
if string == '0': break
print(sum([int(c) for c in string]))
|
# -*- coding: utf-8 -*-
while True:
n = int(raw_input())
if n == 0:
break
else:
sum = 0
while n > 0:
sum += n%10
n /= 10
print sum
| 1 | 1,597,925,547,990 | null | 62 | 62 |
def readinput():
n=int(input())
return n
def main(n):
x7=int(n/1.07)+1
x9=int(n/1.09)-1
n100=n*100
for x in range(max(1,x9),x7+1):
xx=x*108//100
#print(x,xx)
if xx==n:
print(x)
break
else:
print(':(')
if __name__=='__main__':
n=readinput()
main(n)
|
n = int(input())
ans = int(n/1.08)
for i in range(2):
if int(ans*1.08) == n:
print(ans)
exit()
ans += 1
print(":(")
| 1 | 125,724,134,965,210 | null | 265 | 265 |
import sys
import collections
input = sys.stdin.readline
s, t = map(str,input().split())
a, b = map(int, input().split())
u = input().strip()
if u == s:
print(a - 1, b)
else:
print(a, b - 1)
|
import numpy as np
n = int(input())
cnt = 0
for k in range(1,n+1):
d = n//k
if d == 1:
cnt += (k+n)*(n-k+1)//2
break
cnt += k*d*(d+1)//2
print(cnt)
| 0 | null | 41,594,986,774,612 | 220 | 118 |
# -*- coding: utf-8 -*-
def main():
from collections import deque
import sys
input = sys.stdin.readline
n, x, y = map(int, input().split())
x -= 1
y -= 1
inf = 10 ** 7
ans = [0 for _ in range(n)]
# See:
# https://www.youtube.com/watch?v=zG1L4vYuGrg&feature=youtu.be
# KeyInsight:
# △: 全探索 + 深さ優先探索
# ×: どのように実装すればいいか、見当がつかなかった
for i in range(n):
# グラフを陽に持たない場合
# 始点からの距離を管理
dist = [inf for _ in range(n)] # 距離無限大で初期化
dist[i] = 0
# キューを用意して、頂点を管理
d = deque()
d.append(i)
# BFS
while d:
v = d.popleft() # 最も左側の内容(=最初に突っ込んだ値)を取り出す
dj = dist[v]
# 場合分け
# 範囲外参照を回避しながら、次の頂点に移動したときの距離を計算
if v - 1 >= 0 and dist[v - 1] == inf:
dist[v - 1] = dj + 1
# 次の頂点をキューに突っ込む
d.append(v - 1)
if v + 1 < n and dist[v + 1] == inf:
dist[v + 1] = dj + 1
d.append(v + 1)
if v == x and dist[y] == inf:
dist[y] = dj + 1
d.append(y)
if v == y and dist[x] == inf:
dist[x] = dj + 1
d.append(x)
# 距離ごとの個数を計算
for j in range(n):
ans[dist[j]] += 1
# 始点と終点を区別
for k in range(n):
ans[k] //= 2
# 答えを出力
for ii in range(1, n):
print(ans[ii])
if __name__ == '__main__':
main()
|
#!/usr/bin/env python3
import sys
input = sys.stdin.readline
import cmath
pi = cmath.pi
exp = cmath.exp
def fft(a, inverse=False):
n = len(a)
h = n.bit_length() - 1
# Swap
for i in range(n):
j = 0
for k in range(h):
j |= (i >> k & 1) << (h - 1 - k)
if i < j:
a[i], a[j] = a[j], a[i]
# Butterfly calculation
if inverse:
sign = 1.0
else:
sign = -1.0
b = 1
while b < n:
for j in range(b):
w = exp(sign * 2.0j * pi / (2.0 * b) * j)
for k in range(0, n, b*2):
s = a[j + k]
t = a[j + k + b] * w
a[j + k] = s + t
a[j + k + b] = s - t
b *= 2
if inverse:
for i in range(n):
a[i] /= n
return a
def ifft(a):
return fft(a, inverse=True)
def convolve(f, g):
n = 2**((len(f) + len(g) - 1).bit_length())
f += [0] * (n - len(f))
g += [0] * (n - len(g))
F = fft(f)
G = fft(g)
FG = [Fi * Gi for Fi, Gi in zip(F, G)]
fg = [int(item.real + 0.5) for item in ifft(FG)]
return fg
if __name__ == "__main__":
n, m = map(int, input().split())
a = [int(item) for item in input().split()]
max_a = max(a)
freq = [0] * (max_a + 1)
for item in a:
freq[item] += 1
f = freq[:]; g = freq[:]
fg = convolve(f, g)
total = sum(a) * n * 2
cnt = n * n - m
for i, item in enumerate(fg):
use = min(cnt, item)
total -= i * use
cnt -= use
if cnt == 0:
break
print(total)
| 0 | null | 76,192,414,636,090 | 187 | 252 |
n = int(input())
print("ACL" * n)
|
from collections import deque
n = int(input())
dq = deque()
for _ in range(n):
query = input()
if query == "deleteFirst":
dq.popleft()
elif query == "deleteLast":
dq.pop()
else:
op, arg = query.split()
if op == "insert":
dq.appendleft(arg)
else:
tmp = deque()
while dq:
item = dq.popleft()
if item == arg:
break
else:
tmp.append(item)
while tmp:
dq.appendleft(tmp.pop())
print(*dq)
| 0 | null | 1,120,782,929,122 | 69 | 20 |
ri = lambda S: [int(v) for v in S.split()]
def rii(): return ri(input())
S, T = input().split()
A, B = rii()
U = input()
D = {S:A, T:B}
D[U] -= 1
print(D[S], D[T])
|
S, T = [s for s in input().split(' ')]
A, B = [int(s) for s in input().split(' ')]
U = input()
d = {S:A,T:B}
d[U] = d[U] - 1
print('%d %d' % (d[S], d[T]))
| 1 | 71,857,766,533,370 | null | 220 | 220 |
from itertools import combinations
N = int(input())
L = list(map(int, input().split()))
count = 0
for C in combinations(L, 3):
l_list = list(C)
l_list.sort()
if l_list[2] > l_list[1] and l_list[1] > l_list[0]:
if l_list[2] < l_list[1] + l_list[0]:
count += 1
print(count)
|
from collections import defaultdict, deque, Counter
from heapq import heappush, heappop, heapify
from bisect import bisect_right, bisect_left
import random
from itertools import permutations, accumulate, combinations, product
import sys
import string
from bisect import bisect_left, bisect_right
from math import factorial, ceil, floor, gamma, log
from operator import mul
from functools import reduce
from copy import deepcopy
sys.setrecursionlimit(2147483647)
INF = 10 ** 20
def LI(): return list(map(int, sys.stdin.buffer.readline().split()))
def I(): return int(sys.stdin.buffer.readline())
def LS(): return sys.stdin.buffer.readline().rstrip().decode('utf-8').split()
def S(): return sys.stdin.buffer.readline().rstrip().decode('utf-8')
def IR(n): return [I() for i in range(n)]
def LIR(n): return [LI() for i in range(n)]
def SR(n): return [S() for i in range(n)]
def LSR(n): return [LS() for i in range(n)]
def SRL(n): return [list(S()) for i in range(n)]
def MSRL(n): return [[int(j) for j in list(S())] for i in range(n)]
mod = 10 ** 9 + 7
n = I()
def make_divisors(n):
divisors = set()
for i in range(1, int(n**0.5) + 1):
if n % i == 0:
divisors.add(i)
divisors.add(n // i)
return divisors # sortしたリストで欲しい時はsorted(divisors)
ret = 0
a = make_divisors(n)
for k in a:
if k == 1:
continue
m = n
while m % k == 0:
m //= k
if m % k == 1:
ret += 1
s = make_divisors(n - 1)
s.discard(1)
print(ret + len(s))
| 0 | null | 23,065,163,059,040 | 91 | 183 |
n = int(input())
A = list(map(int,input().split()))
val1 = sum(A)//n
val2 = val1+1
ans1 = 0
ans2 = 0
for a in A:
ans1 += (a-val1)**2
ans2 += (a-val2)**2
print(min(ans1,ans2))
|
n=int(input())
x=list(map(int,input().split()))
avex=sum(x)//n
ansl=0
ansr=0
for i in x:
ansl+=(avex-i)**2
ansr+=(avex+1-i)**2
print(min(ansl,ansr))
| 1 | 65,213,979,756,770 | null | 213 | 213 |
n = list(input())
n1 = list(input())
i = 0
cou = 0
while i != len(n):
if n[i] != n1[i]:
cou += 1
i += 1
print(cou)
|
S = input()
list_S = list(S)
T = input()
list_T = list(T)
count = 0
for i in range(len(list_S)):
if S[i] != T[i]:
count +=1
print(count)
| 1 | 10,455,485,389,052 | null | 116 | 116 |
S = list(input())
K = int(input())
L = len(S)
if len(set(S)) == 1:
print(L*K // 2)
exit()
def n_changes(s):
sc = s.copy()
count = 0
for i in range(1, len(sc)):
if sc[i] == sc[i-1]:
sc[i] = "X"
count += 1
return count
print(n_changes(S) + (K-1) * (n_changes(2*S) - n_changes(S)))
|
n,K = map(int, input().split())
mod = 10**9 + 7
def modcomb(n,a,mod):
cnt = 1
for i in range(a):
cnt *= (n-i)
cnt *= pow(i+1,mod-2,mod)
cnt %= mod
# print(cnt)
return cnt
def modconb(n,mod):
# テーブルを作る
fac = [0]*(n+1)
finv = [0]*(n+1)
inv = [0]*(n+1)
fac[0] = fac[1] = 1
finv[0] = finv[1] = 1
inv[1] = 1
for i in range(2,n+1):
fac[i] = fac[i-1]*i % mod
inv[i] = mod - inv[mod%i] * (mod//i) % mod
finv[i] = finv[i-1] * inv[i] %mod
return fac,finv
# return(fac[n]*(finv[k]*finv[n-k]%mod)%mod)
cnt = 0
if n-1 >= K:
fac1,finv1 = modconb(n,mod)
for k in range(K+1):
c1 = fac1[n]*(finv1[k]*finv1[n-k]%mod)%mod
c2 = fac1[n-1]*(finv1[k]*finv1[n-1-k]%mod)%mod
cnt += c1*c2
cnt %= mod
print(cnt%mod)
else:
cnt1 = modcomb(2*(n-1),n-1,mod)
cnt2 = modcomb(2*(n-1),n,mod)
ans = (cnt1+cnt2)%mod
print(ans)
| 0 | null | 120,982,873,413,020 | 296 | 215 |
# coding: utf-8
from itertools import combinations as combs
H,W,K = list(map(int, input().split()))
arr = []
for i in range(H):
arr.append(list(map(int, list(input()))))
def cut_sum(arr, x1, x2, y):
ret = 0
for i in range(x1, x2):
ret += arr[i][y]
return ret
row_idxes = list(range(1,H))
min_val = float('inf')
for n_rows in range(H):
for row_set in combs(row_idxes, n_rows):
count = len(row_set)
row_lines = [0] + list(row_set)+ [H]
col1, col2 = 0, 1
sums = [0] * (len(row_lines) - 1)
while col2 <= W:
row1 = 0
for box, row2 in enumerate(row_lines[1:]):
sums[box] += cut_sum(arr, row1, row2, col2-1)
if sums[box] > K:
if (col2 - col1) == 1:
count = float('inf')
break
count += 1
col1 = col2 - 1
col2 -= 1
sums = [0] * (len(row_lines) - 1)
break
row1 = row2
if count >= min_val:
break
col2 += 1
if min_val > count:
min_val = count
print(min_val)
|
n=int(input())
d=list(map(int,input().split()))
sum1=sum(d)
sum2=0
for i in d:
sum2+=i**2
print((sum1**2-sum2)//2)
| 0 | null | 108,825,306,289,252 | 193 | 292 |
a, b = eval(input().replace(' ', ','))
print("a {} b".format("<" if a < b else ">" if a > b else "=="))
|
length = raw_input()
a, b = length.split()
a = int(a)
b = int(b)
if a < b:
print "a < b"
elif a == b:
print "a == b"
elif a > b:
print "a > b"
| 1 | 348,053,845,092 | null | 38 | 38 |
import math
A, B = map(int, input().split())
answer = -1
for x in range(10000):
if math.floor(x * 0.08) == A and math.floor(x * 0.10) == B:
answer = x
break
print(answer)
|
for a in range(1,10):
for b in range(1,10):
ans = a*b
print("%dx%d=%d" % (a, b, ans))
| 0 | null | 28,420,095,420,052 | 203 | 1 |
import sys
import numpy as np
read = sys.stdin.buffer.read
readline = sys.stdin.buffer.readline
readlines = sys.stdin.buffer.readlines
n, k = map(int, readline().split())
p = list(map(int, readline().split()))
l = [i for i in range(1, 1001)]
av = np.cumsum(l) / l
tmp = [av[i - 1] for i in p]
cs = list(np.cumsum(tmp))
if n == k:
print(cs[-1])
exit()
ans = 0
for i in range(n - k):
ans = max(ans, cs[i + k] - cs[i])
print(ans)
|
n = int(input())
x = list(map(int, input().split()))
ans = 1000000
for i in range(1, 101):
s = 0
for j in range(n):
s += (x[j] - i)*(x[j] - i)
ans = min(ans, s)
print(str(ans))
| 0 | null | 70,263,917,140,364 | 223 | 213 |
a,b,c,k=map(int,input().split())
if a>=k:
print(k)
elif (k>a) and (a+b>=k):
print(a)
elif (a+b<k):
print(a-(k-(a+b)))
|
a,b,c,k = list(map(int,input().split()))
ans = 0
for x, y in zip([a,b,c], [1,0,-1]):
if k <= 0:
break
ans += min(x,k) * y
k -= min(x,k)
print(ans)
| 1 | 21,972,417,233,300 | null | 148 | 148 |
n = int(input())
s = input()
abc = 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' * 2
ans = ''
for i in s:
ans += abc[abc.index(i)+n]
print(ans)
|
N,M=map(int,input().split())
H=list(map(int,input().split()))
cnt=[1 for _ in range(N)]
for _ in range(M):
A,B=map(int,input().split())
A-=1
B-=1
if H[A]>H[B]:
cnt[B]=0
elif H[A]<H[B]:
cnt[A]=0
else:
cnt[A]=0
cnt[B]=0
print(cnt.count(1))
| 0 | null | 79,732,292,290,300 | 271 | 155 |
dataset = []
while True:
h, w = map(int, input().split())
if (h >= 1 and h <= 300) and (w >= 1 and w <= 300):
listed = []
listed.append(h)
listed.append(w)
dataset.append(listed)
elif h != 0 and w != 0:
break
else:
break
for listed in dataset:
h = listed[0]
w = listed[1]
for i in range(h):
if i % 2 == 0:
for j in range(w):
if j % 2 == 0:
print("#", end="")
elif j % 2 == 1:
print(".", end="")
print()
elif i % 2 == 1:
for j in range(w):
if j % 2 == 0:
print(".", end="")
elif j % 2 == 1:
print("#", end="")
print()
print()
|
while True:
H, W = map(int, raw_input().split())
if H == 0 and W == 0:
break
s1 = ""
s2 = ""
for i in range(W):
if i % 2 == 0:
s1 += "#"
s2 += "."
else:
s1 += "."
s2 += "#"
count = True
for i in range(H):
if count:
print(s1)
else:
print(s2)
count = not count
print("")
| 1 | 879,517,489,168 | null | 51 | 51 |
# coding: utf-8
def main():
N = input()
X = list(map(int, input().split()))
ans = 1000001
for i in range(1, 101):
tmp = sum([(x - i) ** 2 for x in X])
if tmp < ans:
ans = tmp
print(ans)
if __name__ == "__main__":
main()
|
N=int(input())
#people
li = list(map(int, input().split()))
Ave1=sum(li)//N
Ave2=sum(li)//N+1
S1=0
S2=0
for i in range(N):
S1=S1+(Ave1-li[i])**2
for i in range(N):
S2=S2+(Ave2-li[i])**2
if S1>S2:
print(S2)
else:
print(S1)
| 1 | 65,070,470,648,296 | null | 213 | 213 |
import sys
from collections import Counter
inint = lambda: int(sys.stdin.readline())
inintm = lambda: map(int, sys.stdin.readline().split())
inintl = lambda: list(inintm())
instrm = lambda: map(str, sys.stdin.readline().split())
instrl = lambda: list(instrm())
class UnionFind():
def __init__(self, n):
self.n = n # 要素数(初期頂点数)
self.root = [i for i in range(n)] # 根
self.rank = [0] * n # 深さ
self.sizes = [1] * n # 要素数(木)
def find(self, x): # 根を返す
if self.root[x] == x:
return x
self.root[x] = self.find(self.root[x]) # 経路圧縮
return self.root[x]
def unite(self, x, y):
x = self.find(x)
y = self.find(y)
if x == y:
return
if self.rank[x] < self.rank[y]: # 浅い方を深い方につなげる
self.root[x] = y
self.sizes[y] += self.sizes[x]
else:
self.root[y] = x
self.sizes[x] += self.sizes[y]
if self.rank[x] == self.rank[y]:
self.rank[x] += 1
def same(self, x, y): # 同じ集合かどうかの真偽を返す
return self.find(x) == self.find(y)
def roots(self):
return {i for i, num in enumerate(self.root) if i == num}
def size(self, x):
return self.sizes[self.find(x)]
n, m = inintm()
uf = UnionFind(n)
for i in range(m):
a, b = inintm()
uf.unite(a-1, b-1)
ans = 0
r = uf.roots()
for i in r:
if uf.size(i) > ans:
ans = uf.size(i)
print(ans)
|
N, K = map(int, input().split())
R, S, P = map(int, input().split())
T = input()
point = [0]*K
flag = ["a"]*K
k = -1
#K本のリストを用意する 剰余系の中で、同じ手が連続するとき、１、３、５、...は別の手に変える
for i in range(N):
k = (k+1)%K #mod
if T[i] == "r":
if flag[k] == "r":
flag[k] = "a"
else:
flag[k] = "r"
point[k] += P
elif T[i] == "s":
if flag[k] == "s":
flag[k] = "a"
else:
flag[k] = "s"
point[k] += R
if T[i] == "p":
if flag[k] == "p":
flag[k] = "a"
else:
flag[k] = "p"
point[k] += S
print(sum(point))
| 0 | null | 55,719,643,557,728 | 84 | 251 |
S = input().split("S")
S_len = [len(S_each) for S_each in S]
print(max(S_len))
|
a, b, c, d = map(int,input().split())
inf = -10**9
ans = max(a*c, a*d)
ans = max(ans, b*c)
ans = max(ans, b*d)
print(ans)
| 0 | null | 3,949,058,321,330 | 90 | 77 |
l= list(input().split())
a,b = map(int,input().split())
u = input()
if u == l[0]:
a -= 1
else:
b -= 1
print(a,b)
|
s,t = list(map(str,input().split()))
a,b = list(map(int,input().split()))
u = str(input())
if s == u:
print(a - 1,b)
elif t == u:
print(a,b - 1)
| 1 | 71,831,538,668,194 | null | 220 | 220 |
import sys
def gcd(a,b):
r= b % a
while r != 0:
a,b = r,a
r = b % a
return a
def lcm(a,b):
return int(a*b/gcd(a,b))
for line in sys.stdin:
a,b = sorted(map(int, line.rstrip().split(' ')))
print("{} {}".format(gcd(a,b),lcm(a,b)))
|
def gcd(a,b):
while b: a,b=b,a%b
return a
while True:
try:
a,b = map(int,input().split())
print(gcd(a,b),a*b//gcd(a,b))
except:
break;
| 1 | 776,832,878 | null | 5 | 5 |
import itertools as itl
n = int(input())
A = list(map(int, input().split()))
q = int(input())
M = list(map(int, input().split()))
S = []
for i in range(n):
cmb = list(itl.combinations(A, i+1))
for j in cmb:
S.append(sum(j))
for m in M:
flg = False
for s in S:
if s == m:
flg = True
break
if flg:
print("yes")
else:
print("no")
|
n = int(input())
ary = [int(_) for _ in input().split()]
q = int(input())
qs = [int(_) for _ in input().split()]
def search_rec(ind, s, q):
if ind == n:
return False
else:
tmp = ary[ind]
if s + tmp == q:
return True
else:
return search(ind + 1, s, q) or search(ind + 1, s + tmp, q)
def search(q):
sum_ary = [0]
for i in ary:
for s in sum_ary:
if s + i == q:
return True
sum_ary += [i + _ for _ in sum_ary]
else:
return False
for q in qs:
if search(q):
print('yes')
else:
print('no')
| 1 | 96,656,636,930 | null | 25 | 25 |
N, M = map(int, input().split())
S = ['a'] * (N+1)
for i in range(M):
s, c = list(map(int, input().split()))
if S[s] != 'a' and S[s] != str(c):
print(-1)
exit()
S[s] = str(c)
if S[1] == '0' and N > 1:
print(-1)
exit()
for i in range(1, N+1):
if S[i] == 'a':
if i == 1 and N > 1:
S[i] = '1'
else:
S[i] = '0'
print(int(''.join(S[1:])))
|
S = input()
array = list(S)
N = len(array)
a = (N-2)//2
b = (N+2)//2
if array[0:a+1] == array[b:N]:
print('Yes')
else:
print('No')
| 0 | null | 53,790,697,151,858 | 208 | 190 |
# coding=utf-8
def insertionSort(A, N):
print ' '.join(map(str, A))
for i in range(1, N):
v = A[i]
j = i - 1
while j >= 0 and A[j] > v:
A[j + 1] = A[j]
j -= 1
A[j + 1] = v
print ' '.join(map(str, A))
return A
n = int(raw_input().rstrip())
a = map(int, raw_input().rstrip().split())
insertionSort(a, n)
|
n,m=map(int,input().split())
sc=[list(map(int,input().split())) for _ in range(m)]
for i in range(10**n):
ans=str(i)
if len(ans)==n and all(ans[s-1]==str(c) for s,c in sc):
print(ans)
exit()
print(-1)
| 0 | null | 30,470,568,146,238 | 10 | 208 |
from copy import copy
import random
D = int(input())
c = list(map(int,input().split()))
s = [list(map(int,input().split())) for _ in range(D)]
last = [0]*26
ans = [0]*D
score = 0
for i in range(D):
ps = [0]*26
for j in range(26):
pl = copy(last)
pl[j] = i+1
ps[j] += s[i][j]
for k in range(26):
ps[j] -= c[k]*(i+1-pl[k])
idx = ps.index(max(ps))
last[idx] = i+1
ans[i] = idx+1
score += max(ps)
for i in range(40000):
na = copy(ans)
x = random.randint(1,365)
y = random.randint(1,365)
if x == y:
continue
na[x-1],na[y-1] = na[y-1],na[x-1]
last = [0]*26
ns = 0
for i in range(D):
last[na[i]-1] = i+1
ns += s[i][na[i]-1]
for j in range(26):
ns -= c[j]*(i+1-last[j])
if ns > score:
ans = na
score = ns
for a in ans:
print(a)
|
input()
print(*reversed([int(e) for e in input().split()]))
| 0 | null | 5,302,120,496,540 | 113 | 53 |
n,m =map(int,input().split())
a = list(map(int,input().split()))
cnt=0;s=0;
for i in range(n):
s += a[i]
for i in a:
if i *4*m>=s: cnt +=1
if cnt >= m:
print("Yes")
break
else:
print("No")
|
H, W = map(int, input().split())
ans = 0
x = H * W
if H == 1 or W == 1:
ans = 1
elif x % 2 == 0:
ans = x // 2
else:
ans = (x // 2) + 1
print(ans)
| 0 | null | 45,106,591,802,028 | 179 | 196 |
N = input()
A, a = 0, 0
for i in range(65, 91):
if i==ord(N):
A += 1
for i in range(97, 123):
if i==ord(N):
a += 1
if A==1:
print('A')
if a==1:
print('a')
|
a1 = input()
if a1.isupper()==True:
print('A')
else:
print('a')
| 1 | 11,341,559,305,160 | null | 119 | 119 |
h, w, k = map(int, input().split())
s = [list(map(int, list(input()))) for _ in range(h)]
result = []
if h*w<=k:
result.append(0)
else:
for i in range(2**(h-1)):
checker, num, p = 0, i ,[0]
for _ in range(h):
p.append(p[-1]+num%2)
checker += num%2
num >>= 1
x = 0
c = [0 for _ in range(checker+1)]
for j in range(w):
num = i
nex = [0 for _ in range(checker+1)]
for m in range(h):
nex[p[m]] += s[m][j]
if max(nex) > k:
x = float('inf')
break
for m in range(checker+1):
c[m] += nex[m]
if c[m]>k:
c = nex
x += 1
break
result.append(checker+x)
print(min(result))
|
k = int(input())
if k % 2 == 0 or k % 5 == 0:
x = -1
else:
m = 7
n = 7
x = 1
while n % k != 0:
m = (m * 10) % k
n += m
x += 1
print(x)
| 0 | null | 27,245,696,036,480 | 193 | 97 |
k = int(input())
from collections import deque
d = deque()
c = 0
for i in range(1, 10):
d.append(i)
while True:
tmp = d.popleft()
c += 1
if c == k:
ans = tmp
break
if tmp % 10 != 0:
d.append(tmp * 10 + (tmp % 10 - 1))
d.append(tmp * 10 + tmp % 10)
if tmp % 10 != 9:
d.append(tmp * 10 + (tmp % 10 + 1))
print(ans)
|
n = int(input())
list_a = [i for i in range(1,n+1) if i % 3 ==0]
list_b = []
for i in range (1,n+1):
j = i
while True:
if j == 0:
break
elif j % 10 == 3:
list_b.append(i)
break
j = j // 10
a = set(list_a)
b = set(list_b)
c =list(a | b)
c.sort()
print(" " + " ".join(map(str,c)))
| 0 | null | 20,507,203,594,432 | 181 | 52 |
import sys
sys.setrecursionlimit(300000)
from math import sqrt, ceil
from collections import defaultdict
def I(): return int(sys.stdin.readline())
def MI(): return map(int, sys.stdin.readline().split())
def MI0(): return map(lambda s: int(s) - 1, sys.stdin.readline().split())
def LMI(): return list(map(int, sys.stdin.readline().split()))
def LMI0(): return list(map(lambda s: int(s) - 1, sys.stdin.readline().split()))
MOD = 10 ** 9 + 7
INF = float('inf')
N = I()
n = ceil(sqrt(N))
d = defaultdict(int)
for x in range(1, n + 1):
for y in range(1, n + 1):
for z in range(1, n + 1):
a = x ** 2 + y ** 2 + z ** 2 + x * y + y * z + z * x
if a <= N:
d[a] += 1
for i in range(1, N + 1):
print(d[i])
|
n,k = map(int, input().split())
setn = {x for x in range(1,n+1)}
setd = set()
for i in range(k):
d = int(input())
setd |= set(map(int, input().split()))
print(len(setn - setd))
| 0 | null | 16,158,433,663,988 | 106 | 154 |
k = int(input())
a = [7 % k]
if a[0] == 0:
print(1)
exit()
for i in range(1, k):
a.append((10*a[i - 1] + 7) % k)
if a[i] % k == 0:
print(i + 1)
exit()
print(-1)
|
from sys import stdin, stdout # only need for big input
def solve():
s = input()
left = 0
right = len(s) - 1
count = 0
while left < right:
count += (s[left] != s[right])
left += 1
right -= 1
print(count)
def main():
solve()
if __name__ == "__main__":
main()
| 0 | null | 63,373,968,533,692 | 97 | 261 |
import math
A,B = map(int,input().split())
ans = 0
AT = 0.08
BT = 0.1
a = A/AT
b = B/BT
aPlus = (A+1)/AT
bPlus = (B+1)/BT
if a == b :
ans = a
elif a < b :
if aPlus <= b :
ans = -1
else :
ans = b
elif b < a :
if bPlus <= a :
ans = -1
else :
ans = a
# print(a,b)
# print(aPlus,bPlus)
print(math.ceil(ans))
|
def DFS(adj, start):
n = len(adj)
d = [0] * n
f = [0] * n
flag = [0] * n
S = []
time = 1
S.append(start)
flag[start] = 1
d[start] = time
time = time + 1
while flag.count(2) != n: # ??¨????????????????????¢?´¢????????????????????§
if len(S) != 0:
u = S.pop()
v = next(adj, u)
v = [i for i in v if flag[i] == 0] # v <= ??£??\???????????????????????¢?´¢??????????????????
if len(v) != 0:
S.append(u)
S.append(v[0])
flag[v[0]] = 1
d[v[0]] = time
time = time + 1
else:
#??£??\??????????????¨????¨??????????
flag[u] = 2
f[u] = time
time = time + 1
else:
u = flag.index(0)
S.append(u)
flag[u] = 1
d[u] = time
time = time + 1
return d, f
def next(adj, u):
"""
u?????£??\??????????????????????????????????????????
"""
return [i for i, x in enumerate(adj[u]) if x == 1]
def main():
n = int(input())
adj = [[0 for i in range(n)] for j in range(n)]
for i in range(n):
tmp = list(map(int, input().split()))
u = tmp[0]
u = u -1
k = tmp[1]
v = tmp[2:]
for j in range(k):
adj[u][v[j]-1] = 1
d, f = DFS(adj, 0)
for i in range(n):
print(i+1, d[i], f[i])
if __name__ == "__main__":
main()
| 0 | null | 28,206,680,120,958 | 203 | 8 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.