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
|
|---|---|---|---|---|---|---|
X,N=map(int,input().split())
if N>0:
P=list(map(int,input().split()))
for i in range(N+1):
if X-i not in P:
print(X-i)
break
elif X+i not in P:
print(X+i)
break
else:
print(X)
|
X,N = map(int,input().split())
p = list(map(int,input().split()))
diff = 1
if(X not in p):
print(X)
exit()
while(diff < 200):
if(X-diff not in p):
print(X-diff)
exit()
elif(X+diff not in p):
print(X+diff)
exit()
diff += 1
| 1 | 14,116,022,789,532 | null | 128 | 128 |
from math import factorial
N, M = map(int, input().split())
if N <= 1:
combN = 0
else:
combN = factorial(N) // (factorial(N - 2) * factorial(2))
if M <= 1:
combM = 0
else:
combM = factorial(M) // (factorial(M - 2) * factorial(2))
print(combN + combM)
|
N,R = map(int,input().split(" "))
if N>10:
print(R)
else:
print(R+100*(10-N))
| 0 | null | 54,411,313,831,840 | 189 | 211 |
import bisect
n = int(input())
s = list(input())
q = int(input())
pos = [[] for i in range(26)]
alp = "abcdefghijklmnopqrstuvwxyz"
atoi = {}
for i in range(26):
atoi[alp[i]] = i
for i in range(n):
pos[atoi[s[i]]].append(i)
for i in range(q):
a, b, c = input().split()
if a == "1":
b = int(b)-1
if c == s[b]:
continue
index = bisect.bisect_left(pos[atoi[s[b]]], b)
del pos[atoi[s[b]]][index]
bisect.insort_left(pos[atoi[c]], b)
s[b] = c
else:
l, r = int(b)-1, int(c)
ans = 0
for i in range(26):
cnt = bisect.bisect_left(pos[i], r) - bisect.bisect_left(pos[i], l)
if cnt > 0:
ans += 1
print(ans)
|
def main():
import sys
n,s,_,*t=sys.stdin.buffer.read().split()
n=int(n)
d=[0]*n+[1<<c-97for c in s]
for i in range(n-1,0,-1):d[i]=d[i+i]|d[i-~i]
for q,a,b in zip(*[iter(t)]*3):
i,s=int(a)+n-1,0
if q<b'2':
d[i]=1<<b[0]-97
while i>1:
i//=2
d[i]=d[i+i]|d[i-~i]
continue
j=int(b)+n
while i<j:
if i&1:
s|=d[i]
i+=1
if j&1:
j-=1
s|=d[j]
i//=2
j//=2
print(bin(s).count('1'),flush=False)
main()
| 1 | 62,485,824,148,290 | null | 210 | 210 |
alpha = "abcdefghijklmnopqrstuvwxyz"
A = [0]*26
while True :
try :
n = input()
for i in range(len(n)) :
if n[i] in alpha or n[i].lower() in alpha :
A[alpha.index(n[i].lower())] += 1
except :
break
for j in range(len(A)) :
print(alpha[j], ":", A[j])
|
import sys
s = sys.stdin.read()
s = s.lower()
alp = "qazxswedcvfrtgbnhyujmkiolp"
alp = sorted(alp)
for c in alp:
print('{} : {}'.format(c,s.count(c)))
| 1 | 1,652,204,016,188 | null | 63 | 63 |
# D - Redistribution
S = int(input())
MOD = 10**9+7
# dp[i]: 3 以上の数字で i を作る組み合わせ
dp = [0]*(S+1)
if S <= 2:
print(0)
elif S <= 5:
print(1)
else:
# 初期条件
dp[3],dp[4],dp[5] = 1,1,1
# i を作る組合わせ
for i in range(6,S+1):
dp[i] = dp[i-2] + dp[i-3] + dp[i-4]
ans = (dp[S])%MOD
print(ans)
|
mod = 10 ** 9 + 7
s = int(input())
dp = []
for i in range(s):
v = 0
if i >= 2:
v += 1
v += sum(dp[:i - 2])
v %= mod
dp.append(v)
print(dp[-1])
| 1 | 3,265,266,398,550 | null | 79 | 79 |
N = int(input())
res = int(N / 2)
if N % 2 != 0:
res += 1
print(res)
|
n=int(input())
if n%2==0:print(n//2)
else:print(n//2+1)
| 1 | 58,895,766,271,398 | null | 206 | 206 |
import math
a, b, x = map(int, input().split())
theta = math.atan((-2) * x / (a ** 3) + 2 * b / a)
if a * math.tan(theta) > b:
theta = math.atan2(a * b * b, 2 * x)
print(math.degrees(theta))
|
# https://atcoder.jp/contests/abc144/tasks/abc144_d
import math
a, b, x = list(map(int, input().split()))
if a * a * b * (1/2) <= x:
tmp = 2 * (a*a*b-x) / (a*a*a)
print(math.degrees(math.atan(tmp)))
else:
tmp = a*b*b / (2*x)
print(math.degrees(math.atan(tmp)))
| 1 | 163,143,272,344,522 | null | 289 | 289 |
import sys
readline = sys.stdin.readline
MOD = 10 ** 9 + 7
INF = float('INF')
sys.setrecursionlimit(10 ** 5)
def main():
S = set(map(int, readline().split()))
if len(S) == 2:
print("Yes")
else:
print("No")
if __name__ == '__main__':
main()
|
import collections
n= int(input())
g=[]
for _ in range(n):
v,k,*varray= map(int,input().split())
g.append(varray)
d= [-1]* (n+10)
d[0]=0
q= collections.deque()
q.append(0)
while len(q)> 0:
cur = q.popleft()
for next in g[cur]:
if d[next-1]== -1:
d[next-1]= d[cur]+1
q.append(next-1)
for i in range(n):
print(i+1,d[i])
| 0 | null | 34,011,261,726,488 | 216 | 9 |
import random
class Dice:
def __init__(self):
self.u=1
self.w=2
self.s=3
self.e=4
self.n=5
self.d=6
self.dic={"W":0,"S":1,"E":2,"N":3}
def __init__(self,u,w,s,e,n,d):
self.u=u
self.w=w
self.s=s
self.e=e
self.n=n
self.d=d
self.dic={"W":0,"S":1,"E":2,"N":3}
def rot(self,way):
if isinstance(way,str):
way=self.dic[way]
if way==0:
c=self.u
self.u=self.e
self.e=self.d
self.d=self.w
self.w=c
elif way==1:
c=self.u
self.u=self.n
self.n=self.d
self.d=self.s
self.s=c
elif way==2:
c=self.u
self.u=self.w
self.w=self.d
self.d=self.e
self.e=c
else :
c=self.u
self.u=self.s
self.s=self.d
self.d=self.n
self.n=c
lst=["W","S","E","N"]
u,s,e,w,n,d=map(int,input().split())
N=int(input())
dice=Dice(u,w,s,e,n,d)
for i in range(N):
top,front=map(int,input().split())
while True:
if dice.u==top and dice.w==front:
break
else:
dice.rot(random.choice(lst))
print(dice.s)
|
import copy
def bit_list(x: int, n: int) -> list:
'''
xのn乗のbit配列を返す
'''
ans = []
for i in range(x ** n):
num = i
j = 0
table = [0 for _ in range(n)]
while num:
table[j] = num % x
num = num // x
j += 1
ans.append(table)
return ans
H, W, K = map(int, input().split())
M = [list(input()) for _ in range(H)]
ans = 0
bits = bit_list(2, H + W)
for bit in bits:
tmp_M = copy.deepcopy(M)
for i in range(H + W):
if i < H and bit[i] == 1:
for j in range(W):
tmp_M[i][j] = "R"
if i >= H and bit[i] == 1:
for j in range(H):
tmp_M[j][i - H] = "R"
count = 0
for i in range(H):
for j in range(W):
if tmp_M[i][j] == '#':
count += 1
if count == K:
ans += 1
print(ans)
| 0 | null | 4,574,013,741,848 | 34 | 110 |
if __name__ == "__main__":
inp = input()
a = []
ans = []
total = 0
for i in range(len(inp)):
if inp[i] == "\\":
a.append(i)
elif inp[i] == "/":
if len(a) != 0:
x = a.pop()
d = i - x
total += d
while len(ans) != 0 and ans[-1][0] > x:
d += ans[-1][1]
ans.pop()
ans.append([x, d])
print(total)
if total == 0:
print(0)
else:
print(str(len(ans))+" "+(" ".join(map(str, [x[1] for x in ans]))))
|
def to_fizzbuzz(number):
if number % 15 == 0:
return 'FizzBuzz'
if number % 3 == 0:
return 'Fizz'
if number % 5 == 0:
return 'Buzz'
else:
return str(number)
# return i
def main():
N = int(input())
# this list concludes "FizzBuzz", "Fizz" or "Buzz"
fblist = []
for number in range(1, 10**6):
result = to_fizzbuzz(number)
fblist.append(result)
# the list up to N
n_list = fblist[0:N]
# this list contains only numbers and up to N
n_numlist = []
for s in n_list:
if s.isdigit() == True:
n_numlist.append(int(s))
print(sum(n_numlist))
main()
| 0 | null | 17,632,428,437,348 | 21 | 173 |
n,m=map(int,input().split())
sc=sorted([list(map(int,input().split())) for i in range(m)])
ans=[0 for i in range(n)]
res=True
for i in range(m):
if (i>0 and sc[i][0]==sc[i-1][0] and sc[i][1]!=sc[i-1][1]) or (n>1 and sc[i][0]==1 and sc[i][1]==0):
res=False
break
else:
ans[sc[i][0]-1]=sc[i][1]
if n>1 and ans[0]==0:
ans[0]=1
ans2=int("".join([str(i) for i in ans])) if res else -1
print(ans2)
|
while 1:
l=map(str,raw_input().split())
answer = 0
if l[1] == '+':
answer = int (l[0]) + int (l[2])
if l[1] == '-':
answer = int (l[0]) - int (l[2])
if l[1] == '*':
answer = int (l[0]) * int (l[2])
if l[1] == '/':
answer = int (l[0]) / int (l[2])
if l[1] == '?':
break;
print answer
| 0 | null | 30,559,207,609,870 | 208 | 47 |
n = int(input())
ls = list(map(int, input().split()))
count = 0
flag = 1
while flag:
flag = 0
for i in range(len(ls)-1, 0, -1):
if ls[i] < ls[i-1]:
ls[i], ls[i-1] = ls[i-1], ls[i]
count += 1
flag = 1
print(' '.join(map(str, ls)))
print(count)
|
n,m = list(map(int, input().split()))
parents = [-1] * (n + 1)
def find(x):
if parents[x] < 0:
return x
else:
parents[x] = find(parents[x])
return parents[x]
def union(x, y):
x = find(x)
y = find(y)
if x == y:
return
if parents[x] > parents[y]:
x, y = y, x
parents[x] += parents[y]
parents[y] = x
def same(x, y):
return find(x) == find(y)
for _ in range(m):
a,b = list(map(int, input().split()))
union(a,b)
print(-min(parents[1:]))
| 0 | null | 1,974,750,326,418 | 14 | 84 |
a = input()
if a[2] != a[3]:
print("No")
elif a[4] != a[5]:
print("No")
else:
print("Yes")
|
n,k = map(int,input().split())
li = list(map(int,input().split()))
licsum = [0]
for i in range(n):
licsum.append(licsum[i] + li[i])
lia = []
for i in range(n-k+1):
a = licsum[k+i] - licsum[i] + k
lia.append(float(a)/2)
print(max(lia))
| 0 | null | 58,621,407,363,190 | 184 | 223 |
import sys
def insertionSort(A, N):
for n in range(N-1):
print (A[n], end=" ")
print(A[N-1])
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 = j - 1
A[j + 1] = v
for n in range(N-1):
print (A[n], end=" ")
print(A[N-1])
return A
N = int(input())
A = input()
A = A.split(" ")
for i in range(N):
A[i] = int(A[i])
val = insertionSort(A, N)
|
def cycle_getter(N, start):
"""
:param N: 移動回数
:param start: 初期条件
:return front: cycleまでの要素のリスト
cycle: cycle内の要素のリスト
end: cycle後の余った部分の要素のリスト
cnt: cycle回数
"""
p = start
front, cycle, end = [], [], []
cnt = 0
visit = {p:0}
L, R = N, -1
P = [p]
for i in range(1,N):
p = lift(p)
if p in visit:
"""
(L, R) = (サイクルに入るまでに移動した回数, サイクルの終端に着くまでに移動した回数)
[6,2,3,4,0,1,2] ⇒ (L, R) = (1, 6)
"""
L, R = visit[p], i
period = R-L
break
visit[p] = i
P.append(p)
front = P[:L]
if L != N:
cycle, end = P[L:R], P[L:L+(N-L)%period]
cnt = (N-L)//period
return front, cycle, end, cnt
################################################################################
import sys
input = sys.stdin.readline
def lift(x): return pow(x,2,M)
N, X, M = map(int, input().split())
front, cycle, end, cnt = cycle_getter(N,X)
# print(front, cycle, end, cnt)
print(sum(front)+sum(cycle)*cnt+sum(end))
| 0 | null | 1,389,937,143,100 | 10 | 75 |
import math
a,b,x = map(int,input().split())
if x > a*a*b/2:
tan = 2*(a*a*b - x)/(a*a*a)
elif x <= a*a*b/2:
tan = a*b*b/(2*x)
print(math.degrees(math.atan(tan)))
|
#template
def inputlist(): return [int(j) for j in input().split()]
#template
N = int(input())
lis = ['0']*N
time = [0]*N
for i in range(N):
lis[i],time[i] = input().split()
sing = input()
index = -1
for i in range(N):
if lis[i] == sing:
index = i
break
ans = 0
for i in range(index+1,N):
ans += int(time[i])
print(ans)
| 0 | null | 129,481,790,762,468 | 289 | 243 |
from statistics import median
n=int(input())
A,B=[],[]
for _ in range(n):
a,b=map(int,input().split())
A.append(a*2)
B.append(b*2)
ma,mb = int(median(A)),int(median(B))
#print(ma,mb)
if n%2 == 0:
print(mb-ma+1)
else:
print((mb-ma)//2+1)
|
import collections
N = int(input())
A = [0] * N
B = [0] * N
for i in range(N):
a, b = map(int, input().split())
A[i] = a
B[i] = b
A.sort()
B.sort()
N_q, N_mod = divmod(N, 2)
if N_mod == 1:
ans = B[N_q] - A[N_q] + 1
else:
ans = B[N_q - 1] - A[N_q - 1] + B[N_q] - A[N_q] + 1
print(ans)
| 1 | 17,258,029,116,534 | null | 137 | 137 |
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)
apples = p[:x] + q[:y] + r
apples.sort(reverse=True)
print(sum(apples[:x+y]))
|
n = int(input())
print((n - (n+1)%2)//2)
| 0 | null | 99,347,570,392,892 | 188 | 283 |
x=int(input())
next=[]
now=[1,2,3,4,5,6,7,8,9]
for _ in range(11):
if x<=len(now):
print(now[x-1])
exit()
else:
x-=len(now)
next=now
now=[]
for i in next:
i=str(i)
if i[-1]=='0':
j=i+'0'
k=i+'1'
now+=[j]
now+=[k]
elif i[-1]=='9':
j=i+'8'
k=i+'9'
now+=[j]
now+=[k]
else:
j=i+str(int(i[-1])-1)
k=i+str(int(i[-1]))
l=i+str(int(i[-1])+1)
now+=[j]
now+=[k]
now+=[l]
|
a, b = map(int, input().split())
c, d = map(int, input().split())
print(1 if c != a else 0)
| 0 | null | 82,259,291,025,600 | 181 | 264 |
import sys
def readint():
for line in sys.stdin:
yield map(int,line.split())
def gcd(x,y):
[x,y] = [max(x,y),min(x,y)]
while 1:
z = x % y
if z == 0:
break
[x,y] = [y,z]
return y
for [x,y] in readint():
GCD = gcd(x,y)
mx = x/GCD
print GCD,mx*y
|
def gcd(a, b):
return gcd(b, a%b) if b else a
while True:
try:
a, b = map(int, raw_input().split())
ans = gcd(a, b)
print ans, a*b//ans
except EOFError:
break
| 1 | 521,904,292 | null | 5 | 5 |
from collections import deque
N, K = map(int, input().split())
P = list(map(int, input().split()))
C = list(map(int, input().split()))
A = -(1e9 + 5)
for i in range(N):
x = i
S = deque()
s = 0
while True:
x = P[x] - 1
S.append(C[x])
s += C[x]
if x == i:
break
l = len(S)
a = 0
for i in range(l):
a += S[i]
if i + 1 > K:
break
An = a
if s > 0:
An += s * ((K - i - 1) // l)
A = max(A, An)
print(A)
|
N,K=map(int,input().split())
P=list(map(int,input().split()))
P=list(map(lambda x:x-1,P))
C=list(map(int,input().split()))
ans=-float("inf")
for i in range(N):
st=i
tmp=0
for j in range(K):
st=P[st]
tmp+=C[st]
ans=max(ans,tmp)
if i==st:
break
s,v=divmod(K,j+1)
if s>1 and v==0:
s-=1
v=j+1
tmp*=s
ans=max(ans,tmp)
for j in range(v):
st=P[st]
tmp+=C[st]
ans=max(ans,tmp)
print(ans)
| 1 | 5,430,099,093,032 | null | 93 | 93 |
MOD = 10 ** 9 + 7
MAX = 60
n = int(input())
a = list(map(int, input().split()))
cnt = [0 for i in range(MAX)]
for i in range(n):
bit = bin(a[i])[2:].zfill(MAX)
for j in range(MAX):
cnt[j] += int(bit[j])
ans = 0
for i in range(MAX):
ans += cnt[MAX - i - 1] * (n - cnt[MAX - i - 1]) * 2 ** i
ans %= MOD
print(ans)
|
# coding: UTF-8
from collections import deque
#入力値の整理
n = int(input())
adj={}
visited={}
d={}
f={}
t=0
visited=set()
for i in range(n):
raw=list(map(int,input().split()))
u = raw.pop(0)
k = raw.pop(0)
raw.sort()
q = deque(raw)
adj[u] = q
d[u] = -1
f[u] = -1
next = 1
v = next
d[next] = t + 1
stack = deque()
visited.add(v)
while True:
t = t+1
clear = True
while adj[v]:
cand = adj[v].popleft()
if cand not in visited:
next = cand
d[next] = t + 1
visited.add(next)
clear = False
break
if clear:
f[v] = t + 1
if stack:
next = stack.pop()
v = next
else:
end = True
for i in range(n):
if i+1 not in visited:
next = i+1
end = False
break
if end:
break
else:
t = t+1
v = next
d[next] = t + 1
visited.add(v)
else:
stack.append(v)
v = next
#print
i = 0
for j in range(n):
i += 1
print(str(i) + " " + str(d[i]) + " " + str(f[i]))
#return d,f
| 0 | null | 61,584,287,339,180 | 263 | 8 |
class common_function():
"""
1. よく使いそうで予め用意してあるものをまとめた
2. よく使いそうな関数群をまとめた
"""
def __init__(self):
"""
1. 英字の一覧をリストに格納しておいた変数
"""
self.sletter = ['a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i', 'j', 'k', 'l', 'm', 'n', 'o', 'p', 'q', 'r', 's', 't', 'u', 'v', 'w', 'x', 'y', 'z']
self.bletter = ['A', 'B', 'C', 'D', 'E', 'F', 'G', 'H', 'I', 'J', 'K', 'L', 'M', 'N', 'O', 'P', 'Q', 'R', 'S', 'T', 'U', 'V', 'W', 'X', 'Y', 'Z']
def combi(self, n:int, k:int, MOD=pow(10, 9) + 7):
"""
mod の下での combination nCk を高速に求めるメソッド
n が大きい場合(10^6)に使用する.
1回 nCk を求めるのに O(k) かかる.
"""
k = min(k, n-k)
numer = 1
for i in range(n, n-k, -1):
numer *= i
numer %= MOD
denom = 1
for j in range(k, 0, -1):
denom *= j
denom %= MOD
return (numer*(pow(denom, MOD-2, MOD)))%MOD
def main():
common = common_function()
X, Y = map(int, input().split())
if X <= 0 or Y <= 0 or (X + Y) % 3 != 0:
print(0)
return
if Y > 2*X or X > 2*Y:
print(0)
return
for i in range(X):
two = i
one = X-2*i
if two + one*2 == Y:
break
ans = common.combi(two+one, one)
print(ans)
if __name__ == "__main__":
main()
|
while True:
H, W = map(int, input().split())
if (H == W == 0):
break
else:
for j in range(H):
if (j % 2 == 0):
for i in range(W):
if(i % 2 == 0):
print("#", end='')
else:
print(".", end='')
else:
for f in range(W):
if(f % 2 == 0):
print(".", end='')
else:
print("#", end='')
print()
print()
| 0 | null | 75,298,495,842,412 | 281 | 51 |
pi = 3.14159265358979
r = float(raw_input())
print '%.6f %.6f'%(pi*r*r, 2*pi*r)
|
n = int(input())
s = list(input())
cnt = 0
if n % 2 != 0 :
print('No')
exit()
for i in range(n//2):
if s[i] != s[i + n // 2]:
print('No')
exit()
print('Yes')
| 0 | null | 73,792,474,900,740 | 46 | 279 |
h, a = map(int, input().split())
x=h/a
intx=int(x)
if intx==x:
print(intx)
else:
print(intx+1)
|
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 | 111,449,842,990,432 | 225 | 279 |
#!/usr/bin/env python3
import sys
import collections as cl
def II(): return int(sys.stdin.readline())
def MI(): return map(int, sys.stdin.readline().split())
def LI(): return list(map(int, sys.stdin.readline().split()))
def main():
N,A,B = MI()
oneset = A + B
rep = N // oneset
print(rep * A + min(N % oneset,A))
main()
|
H1,M1,H2,M2,K = map (int, input ().split ())
S = H1*60+M1
G = H2*60+M2
p = G-S
if p-K < 0:
print (0)
else:
print (p-K)
| 0 | null | 36,786,673,016,358 | 202 | 139 |
N,M,L = map(int,input().split())
A = [list(map(int,input().split()))for i in range(N)]
B = [list(map(int,input().split()))for i in range(M)]
ANS = [[0]*L for i in range(N)]
for x in range(N):
for y in range(L):
for z in range(M):
ANS[x][y]+=B[z][y]*A[x][z]
for row in range(N):
print("%d"%ANS[row][0],end="")
for col in range(1,L):
print(" %d"%(ANS[row][col]),end="")
print()
|
# coding:utf-8
n,m,l = map(int, raw_input().split())
a = [[0 for i in range(m)] for j in range(n)]
b = [[0 for i in range(l)] for j in range(m)]
c = [[0 for i in range(l)] for j in range(n)]
for i in range(n):
a[i] = map(int, raw_input().split())
for i in range(m):
b[i] = map(int, raw_input().split())
for i in range(len(a)):
for j in range(len(b[0])):
for k in range(len(b)):
c[i][j] += a[i][k] * b[k][j]
else:
print c[i][j],
else:
print
| 1 | 1,415,430,904,602 | null | 60 | 60 |
n, k = map(int, input().split())
A = list(map(int, input().split()))
bottom, top = 0, max(A)
def cut(x):
cnt = 0
for Length in A:
if Length % x == 0:
cnt += Length // x
else:
cnt += Length // x + 1
cnt -= 1
return cnt <= k
while top - bottom > 1:
middle = (top + bottom) // 2
if cut(middle):
top = middle
else:
bottom = middle
print(top)
|
str=input()
n=int(input())
for i in range(n):
s=input().split()
a=int(s[1])
b=int(s[2])
if s[0] == 'replace':
str=str[:a]+s[3]+str[b+1:]
elif s[0] == 'reverse':
str=str[:a]+str[a:b+1][::-1]+str[b+1:]
else:
print(str[a:b+1])
| 0 | null | 4,287,478,126,512 | 99 | 68 |
num = int(input())
table = list(map(int, input().split()))
table2 = []
for i in range(num):
table2.append(0)
for j in range(len(table)):
table2[table[j]-1] += 1
for k in table2:
print(k)
|
import math
r = float(input())
print("%.6f %.6f" % (math.pi * r**2, 2 * math.pi * r))
| 0 | null | 16,539,615,556,380 | 169 | 46 |
n, k = map(int,input().split())
a = list(map(int,input().split()))
l = [0]*n
i=0
cnt=0
while l[i]==0:
l[i] = a[i]
i = a[i]-1
cnt += 1
start = i+1
i = 0
pre = 0
while i+1!=start:
i = a[i]-1
pre += 1
loop = cnt-pre
if pre+loop<k:
k=(k-pre)%loop+pre
i = 0
for _ in range(k):
i = a[i]-1
print(i+1)
|
N, K = map(int,input().split())
As = list(map(int,input().split()))
visited = [0] * N
path = []
now_town = 1
while(True):
visited[now_town-1] = 1
path.append(now_town)
now_town = As[now_town-1]
if visited[now_town-1] == 1:
break
index = path.index(now_town)
loop = path[index:len(path)]
loop_len = len(loop)
if index < K:
k = K - index
r = k % loop_len
print(loop[r])
else:
print(path[K])
| 1 | 22,751,138,047,040 | null | 150 | 150 |
n, m = map(int, input().split())
l = list(map(int, input().split()))
l.sort()
import bisect
def func(x):
C = 0
for p in l:
q = x -p
j = bisect.bisect_left(l, q)
C += n-j
if C >= m:
return True
else:
return False
l_ = 0
r_ = 2*10**5 +1
while l_+1 < r_:
c_ = (l_+r_)//2
if func(c_):
l_ = c_
else:
r_ = c_
ans = 0
cnt = 0
lr = sorted(l, reverse=True)
from itertools import accumulate
cum = [0] + list(accumulate(lr))
for i in lr:
j = bisect.bisect_left(l, l_-i)
ans += i*(n-j) + cum[n-j]
cnt += n -j
ans -= (cnt-m)*l_
print(ans)
|
from sys import stdin
input = stdin.buffer.readline
n, k = map(int, input().split())
*a, = map(int, input().split())
for i in range(k, n):
if a[i] > a[i - k]:
print('Yes')
else:
print('No')
| 0 | null | 57,761,727,218,400 | 252 | 102 |
n = int(input())
a = list(map(int, input().split()))
INF = 10 ** 18
if n % 2:
dp = [[[-INF,-INF,-INF] for i in range(2)] for i in range(n+1)]
dp[0][0][0] = 0
# 初期化条件考える
for i,v in enumerate(a):
for j in range(2):
if j:
dp[i+1][0][0] = max(dp[i+1][0][0],dp[i][1][0])
dp[i+1][0][1] = max(dp[i+1][0][1],dp[i][1][1])
dp[i+1][0][2] = max(dp[i+1][0][2],dp[i][1][2])
else:
dp[i+1][1][0] = max(dp[i+1][1][0],dp[i][0][0] + v)
dp[i+1][0][1] = max(dp[i+1][0][1],dp[i][0][0])
dp[i+1][1][1] = max(dp[i+1][1][1],dp[i][0][1] + v)
dp[i+1][0][2] = max(dp[i+1][0][2],dp[i][0][1])
dp[i+1][1][2] = max(dp[i+1][1][2],dp[i][0][2] + v)
print(max(max(dp[n][0]),max(dp[n][1][1:])))
else:
odd_sum,even_sum = 0,0
cumsum = []
for k,v in enumerate(a):
if k % 2:
odd_sum += v
cumsum.append(odd_sum)
else:
even_sum += v
cumsum.append(even_sum)
ans = max(cumsum[n-2],cumsum[n-1])
for i in range(2,n,2):
ans = max(ans, cumsum[i-2]+cumsum[n-1]-cumsum[i-1])
print(ans)
|
def main():
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])
if __name__ == '__main__':
main()
| 0 | null | 43,624,260,842,002 | 177 | 195 |
count = 0
n, m = map(int, input().split())
a = list(map(int, input().split()))
for i in range(n):
if a[i] >= sum(a)/4/m:
count += 1
if count >= m:
print("Yes")
else:
print("No")
|
n,m = [int(x) for x in input().split()]
a = [int(x) for x in input().split()]
a.sort(reverse = True)
s = sum(a)
res = "Yes"
for i in range(m):
if a[i] * 4 * m < s:
res = "No"
print(res)
| 1 | 38,796,108,097,906 | null | 179 | 179 |
import sys, os, math, bisect, itertools, collections, heapq, queue, copy, array
# from scipy.sparse.csgraph import csgraph_from_dense, floyd_warshall
# from decimal import Decimal
# from collections import defaultdict, deque
sys.setrecursionlimit(10000000)
ii = lambda: int(sys.stdin.buffer.readline().rstrip())
il = lambda: list(map(int, sys.stdin.buffer.readline().split()))
fl = lambda: list(map(float, sys.stdin.buffer.readline().split()))
iln = lambda n: [int(sys.stdin.buffer.readline().rstrip()) for _ in range(n)]
iss = lambda: sys.stdin.buffer.readline().decode().rstrip()
sl = lambda: list(map(str, sys.stdin.buffer.readline().decode().split()))
isn = lambda n: [sys.stdin.buffer.readline().decode().rstrip() for _ in range(n)]
lcm = lambda x, y: (x * y) // math.gcd(x, y)
MOD = 10 ** 9 + 7
INF = float('inf')
def main():
if os.getenv("LOCAL"):
sys.stdin = open("input.txt", "r")
N = ii()
ans = 0
for x in range(1, N + 1):
n = N // x # Nのうちにxがいくつ含まれるか（等差数列の項数）
ans += (n * (2 * x + (n - 1) * x)) // 2 # 初項と公差がxでn項の等差数列の和
print(ans)
if __name__ == '__main__':
main()
|
n = int(input())
t = [0]*(n+1)
for i in range(1,n+1):
for j in range(i,n+1,i):
t[j] += j
print(sum(t))
| 1 | 11,011,799,497,140 | null | 118 | 118 |
n = int(input())
s = input()
rs = [0]*n
gs = [0]*n
bs = [0]*n
for i in reversed(range(n)):
if s[i] == 'R':
rs[i] += 1
elif s[i] == 'G':
gs[i] += 1
else:
bs[i] += 1
for i in reversed(range(n-1)):
rs[i] += rs[i+1]
gs[i] += gs[i+1]
bs[i] += bs[i+1]
res = 0
for i in range(n):
for j in range(i+1,n-1):
if s[i] == s[j]:
continue
if s[i]!='B' and s[j]!='B':
res += bs[j+1]
if j-i+j < n:
if s[j-i+j] == 'B':
res -=1
elif s[i]!='G' and s[j]!='G':
res += gs[j+1]
if j - i + j < n:
if s[j-i+j] == 'G':
res -=1
else:
res += rs[j+1]
if j - i + j < n:
if s[j-i+j] == 'R':
res -= 1
print(res)
|
while True:
a=[int(x) for x in input().split()]
if a[0]==a[1]==0:
break
else:
for i in range(a[0]):
print("#"*a[1])
print("")
| 0 | null | 18,532,543,017,040 | 175 | 49 |
n=int(input())
while 1:
for i in range(2,int(n**0.5)+1):
if n%i<1: break
else: print(n); break
n+=1
|
X = int(input())
if X == 2:
print(2)
exit()
count = 0
if X % 2 == 0:
X += 1
while True:
now = X + count
k = 3
while k*k <= now:
if now % k == 0:
count += 2
break
else:
k += 2
continue
if k*k > now:
break
print(now)
| 1 | 105,169,648,459,448 | null | 250 | 250 |
def havediv( target, elm):
s = target / elm
if target == s*elm:
return True
else:
return False
if __name__ == "__main__":
v = map( int, raw_input().split())
ct = 0
i = v[0]
while i <= v[1]:
if havediv( v[2], i):
ct += 1
i += 1
print ct
|
N, K = map(int,input().split())
a = []
n = 1
while n <= N:
a = a + [n]
n += 1
for i in range(K):
d = int(input())
A = list(map(int,input().split()))
for j in range(d):
if A[j] in a:
a.remove(A[j])
ans = len(a)
print(ans)
| 0 | null | 12,669,220,136,628 | 44 | 154 |
N = int(input())
if N % 2 == 0:
ans = int(N / 2) - 1
else:
ans = int(N / 2)
print('{}'.format(ans))
|
#!/usr/bin/env python3
n = int(input())
print(int((n - 1) / 2) if n % 2 == 1 else int(n / 2) - 1)
| 1 | 153,504,159,522,370 | null | 283 | 283 |
N, K = [int(s) for s in raw_input().split()]
ws = [int(raw_input()) for _ in xrange(N)]
lo, hi = max(ws) - 1, sum(ws)
while hi - lo > 1:
p = P = (lo + hi) / 2
k = 1
for w in ws:
if w > p:
p = P
k += 1
p -= w
if k <= K:
hi = P
else:
lo = P
print hi
|
# coding: utf-8
# Your code here!
def check(P):
i = 0
for j in range(k):
s = 0
while s + T[i] <= P:
s += T[i]
i += 1
if i == n:
return n
return i
def solve():
left = 0
right = 100000 * 10000
mid = 0
while right - left > 1:
mid = (left + right) // 2
v = check(mid)
if v >= n:
right = mid
else:
left = mid
return right
tmp = list(map(int, input().split()))
n = tmp[0]
k = tmp[1]
T = []
for i in range(n):
T.append(int(input()))
ans = solve()
print(ans)
| 1 | 87,025,864,882 | null | 24 | 24 |
n,k,*l=map(int,open(0).read().split())
for _ in range(k):
s=[0]*(n+1)
for i in range(n):
s[max(i-l[i],0)]+=1
s[min(i+l[i]+1,n)]-=1
s[0]=min(s[0],n)
for i in range(1,n):
s[i]=min(s[i-1]+s[i],n)
s.pop()
if s==l: break
l=s
print(*l)
|
from itertools import accumulate
n, k = map(int, input().split())
a = list(map(int, input().split()))
for i in range(k):
b = [0] * (n + 1)
for j in range(n):
b[max(0, j - a[j])] += 1
b[min(n, j + a[j] + 1)] -= 1
a = list(accumulate(b))
if sum(a) == n ** 2:
a.pop()
print(*a)
exit()
a.pop()
print(*a)
| 1 | 15,465,435,857,472 | null | 132 | 132 |
def merge(A,left,mid,right):
L=A[left:mid]+[10**9]
R=A[mid:right]+[10**9]
i = 0
j = 0
c = 0
for k in range(left,right):
c += 1
if L[i] <= R[j]:
A[k] = L[i]
i+=1
else:
A[k] = R[j]
j+=1
return c
def merge_sort(A,left,right):
if left+1 < right:
mid = (left+right) // 2
cL=merge_sort(A,left,mid)
cR=merge_sort(A,mid,right)
return(merge(A,left,mid,right) + cL + cR)
return 0
c=0
n = int(input())
A = [int(i) for i in input().split()]
c=merge_sort(A,0,n)
print(*A)
print(c)
|
#! /usr/lib/python3
import fractions
while True:
try:
a, b=map(int, input().split())
s=fractions.gcd(a,b)
print("{0} {1:.0f}".format(s,a*b/s))
except:
break
| 0 | null | 56,102,506,332 | 26 | 5 |
input()
print ' '.join(raw_input().split()[::-1])
|
n = int(raw_input())
a = map(int,raw_input().split())
a.reverse()
for x in a:
print x,
| 1 | 976,218,793,638 | null | 53 | 53 |
class UnionFind():
# 作りたい要素数nで初期化
# 使用するインスタンス変数の初期化
def __init__(self, n):
self.n = n
self.parents = [-1] * n
def find(self, x):
# ノードxのrootノードを見つける
if self.parents[x] < 0:
return x
else:
self.parents[x] = self.find(self.parents[x])
return self.parents[x]
def unite(self, x, y):
# 木の併合、入力は併合したい各ノード⇒(a,b)
x = self.find(x)
y = self.find(y)
if x == y:
return
if self.parents[x] > self.parents[y]:
x, y = y, x
self.parents[x] += self.parents[y]
self.parents[y] = x
def size(self, x):
# ノードxが属する木のサイズを返す
return -self.parents[self.find(x)]
def same(self, x, y):
# 入力ノード(x,y)が同じグループに属するかを返す
return self.find(x) == self.find(y)
def members(self, x):
#ノードxが属するメンバーをリスト形式で返す
root = self.find(x)
return [i for i in range(self.n) if self.find(i) == root]
def roots(self):
#親全てをリスト形式で返す
return [i for i, x in enumerate(self.parents) if x < 0]
def group_count(self):
#グループ数の合計を返す
return len(self.roots())
import sys
sys.setrecursionlimit(10**9)
input = sys.stdin.readline
n,m=map(int,input().split())
u=UnionFind(n)
for i in range(m):
a,b=map(int,input().split())
a-=1
b-=1
u.unite(a,b)
ans=u.roots()
print(len(ans)-1)
|
from collections import defaultdict
class UnionFind:
def __init__(self, n):
class KeyDict(dict):
# 辞書にないときの対応
def __missing__(self,key):
self[key] = key
return key
self.parent = KeyDict()
self.rank = defaultdict(int)
self.weight = defaultdict(int)
# 根を探す
def find(self, x):
if self.parent[x] == x:
return x
else:
# 経路圧縮
# 自分自身じゃない場合は、上にさかのぼって検索(再帰的に)
y = self.find(self.parent[x])
self.weight[x] += self.weight[self.parent[x]] #圧縮時にweightを更新(和)
self.parent[x] = y #親の置き換え(圧縮)
return self.parent[x]
# 結合
def union(self, x, y):
x = self.find(x)
y = self.find(y)
# 低い方を高い方につなげる(親のランクによる)
if self.rank[x] < self.rank[y]:
self.parent[x] = y
else:
self.parent[y] = x
if self.rank[x] == self.rank[y]:
self.rank[x] += 1
### 重み付き
def weighted_union(self, x, y, w):
# print("unite",x,y,w,self.weight)
px = self.find(x)
py = self.find(y)
# 低い方を高い方につなげる(親のランクによる)
# if px == py: return 0
if self.rank[px] < self.rank[py]:
self.parent[px] = py
self.weight[px] = - w - self.weight[x] + self.weight[y]
else:
self.parent[py] = px
self.weight[py] = w + self.weight[x] - self.weight[y]
if self.rank[px] == self.rank[py]:
self.rank[px] += 1
return 0
# 判定
def judge(self, x, y):
return self.find(x) == self.find(y)
n, m = map(int, input().split())
uf = UnionFind(n)
for i in range(m):
a,b = map(int, input().split())
a -= 1
b -= 1
if not uf.judge(a,b):
uf.union(a,b)
d = defaultdict(int)
for i in range(n):
d[uf.find(i)] += 1
print(len(d)-1)
| 1 | 2,276,796,431,730 | null | 70 | 70 |
n=input()
s=input()
ans=0
for i in range(1000):
i=str(i).zfill(3)
a=s.find(i[0])
if a!=-1:
b=s.find(i[1],a+1)
if b!=-1:
if s.find(i[2],b+1)!=-1:ans+=1
print(ans)
|
import collections
k = int(input())
Q = collections.deque([int(i) for i in range(1, 10)])
chk = False
for i in range(k):
x = Q.popleft()
if i + len(Q) > k:
chk = True
if chk:
continue
else:
if x%10:
Q.append(10*x + x%10 - 1)
Q.append(10*x + x%10)
if x%10 != 9:
Q.append(10*x + x%10 + 1)
print(x)
| 0 | null | 84,460,146,425,500 | 267 | 181 |
print(list(map(int,input().split())).index(0) + 1)
|
x = list(map(int, input().split()))
if x[0] == 0:
print('1')
elif x[1] == 0:
print('2')
elif x[2] == 0:
print('3')
elif x[3] == 0:
print('4')
else:
print('5')
| 1 | 13,488,703,715,860 | null | 126 | 126 |
str = input()
A = str
print(str[0]+str[1]+str[2])
|
import numpy as np
n, t = map(int, input().split())
ab = [list(map(int, input().split())) for _ in range(n)]
ab.sort()
dp = np.zeros(t, dtype=np.int64)
ans = 0
for a, b in ab:
ans = max(ans, dp[-1] + b)
np.maximum(dp[a:], dp[:-a] + b, out=dp[a:])
print(ans)
| 0 | null | 83,346,791,161,152 | 130 | 282 |
for i in range(1, 10):
for j in range(1, 10):
print('%dx%d=%d' % (i, j, i*j))
|
for j in range(1,10,1):
for k in range(1,10,1):
print("{}x{}={}".format(j,k,j*k))
| 1 | 2,065,100 | null | 1 | 1 |
n,m=input().split()
if(n==m):
print("Yes\n")
else:
print("No\n")
|
def merge(a, left, mid, right):
x = 0
l = a[left:mid] + [float("inf")]
r = a[mid:right] + [float("inf")]
i = 0
j = 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
x += 1
return x
def mergeSort(a, left, right,x):
if left+1 < right:
mid = int((left + right)/2)
mergeSort(a, left, mid,x)
mergeSort(a, mid, right,x)
x[0] += merge(a, left, mid, right)
n = int(input())
s = list(map(int,input().split()))
x = [0]
mergeSort(s,0,n,x)
print(*s)
print(x[0])
| 0 | null | 41,739,498,250,130 | 231 | 26 |
x = int(input())
while x == 0:
x += 1
print(x)
exit(0)
while x == 1:
x -= 1
print(x)
exit(0)
|
if __name__ == '__main__':
x = int(input())
print((x + 1) % 2)
| 1 | 2,924,364,001,600 | null | 76 | 76 |
S = input()
l_s = len(S)
cnt = 0
for i in range(0,l_s//2):
if S[i] != S[-i-1]:
cnt += 1
print(cnt)
|
import sys
S = sys.stdin.readline().strip()
ls = len(S)
ans = 0
h = ls // 2
for i in range(h):
if S[i] != S[ls - 1 - i]:
ans += 1
print(ans)
| 1 | 120,243,045,256,150 | null | 261 | 261 |
import math
n, a, b = list(map(int, input().split()))
MOD = int(1e9) + 7
s = pow(2, n, MOD)-1
def cbn(n, a, MOD):
x = 1
for i in range(a):
x = (x * (n-i)) % MOD
y = math.factorial(a) % MOD
return x * pow(y, MOD-2, MOD) %MOD
s = (s- cbn(n, a, MOD)) %MOD
s = (s- cbn(n, b, MOD)) %MOD
print(s)
|
N = int(input())
originalN = 0 +N
if N == 2:
print(1)
exit()
ans = 0
primenum = [2]
count = [0 for _ in range(int(N**0.5)+2)]
for k in range(3, len(count), 2):
if count[k] == 0:
primenum.append(k)
for j in range(k, len(count), k):
count[j] = 1
def factorization(n):
lis = []
k = 0
while primenum[k] <= n:
if n%primenum[k] == 0:
c = 0
while n%primenum[k] == 0:
n //= primenum[k]
c += 1
lis.append([primenum[k], c])
else:
k += 1
if k > len(primenum)-1:
break
if n > 1:
lis.append([n, 1])
return lis
list1 = factorization(N-1)
#print(factorization(N-1))
ans1 = 1
for k in range(len(list1)):
ans1*= list1[k][1]+1
ans1 -= 1
ans += ans1
#print(ans1)
def operation(K):
N = originalN
while N%K == 0:
N //= K
if N%K == 1:
return True
else:
return False
list2 = factorization(N)
#print(list2)
factorlist = [1]
for l in range(len(list2)):
list3 = []
for j in range(list2[l][1]):
for k in range(len(factorlist)):
list3.append(factorlist[k]*list2[l][0]**(j+1))
factorlist += list3
factorlist = factorlist[1:-1]
#print(factorlist)
ans2 = 1
for item in factorlist:
if operation(item):
#print(item)
ans2 +=1
ans += ans2
#print(ans2)
print(ans)
| 0 | null | 53,511,447,678,910 | 214 | 183 |
a,b,k = map(int,input().split())
if a == k :
print(0,b)
elif a > k :
print(a-k,b)
elif a < k :
c = b - (k-a)
if c >= 0 :
print(0,c)
else :
print(0,0)
|
a, b, k = map(int, input().split())
n = min(a,k)
k -= n
print(a-n, max(0,b-k))
| 1 | 104,200,101,339,620 | null | 249 | 249 |
x,_ = list(map(int,input().split()))
p = list(map(int,input().split()))
x_l = x
x_u = x
while(True):
if(not x_l in p):
print(x_l)
break
if(not x_u in p):
print(x_u)
break
x_l -= 1
x_u += 1
|
X, N = map(int, input().split())
p = list(map(int, input().split()))
ans = None
diff = 1000
if X not in p:
ans = X
else:
for i in range(-1, max(max(p), X)+2):
if i in p:continue
if abs(X - i) < diff:
diff = abs(X - i)
ans = i
print(ans)
| 1 | 14,117,114,494,970 | null | 128 | 128 |
def main():
N = int(input())
m = float("inf")
ans = 0
for i in [int(j) for j in input().split()]:
if i < m:
m = i
ans += 1
print(ans)
if __name__ == '__main__':
main()
|
n=int(input())
ct=0
for i in range(n):
a,b=map(int,input().split())
if a==b:
ct+=1
if ct==3:
print("Yes")
break
else:
ct=0
else:
print("No")
| 0 | null | 44,012,371,262,688 | 233 | 72 |
import sys
readline = sys.stdin.readline
INF = 10 ** 8
def main():
H, N = map(int, readline().rstrip().split())
dp = [INF] * (H + 1) # HPを減らすのに必要な最小のMP
dp[0] = 0
for _ in range(N):
hp, mp = map(int, readline().rstrip().split())
for i in range(H):
j = min(i+hp, H)
dp[j] = min(dp[j], dp[i] + mp)
print(dp[-1])
if __name__ == '__main__':
main()
|
H,N = map(int,input().split())
Q = []
for _ in range(N):
a,b = map(int,input().split())
Q.append((a,b))
INF = float("inf")
dp = [INF]*(H+1)
dp[0] = 0
for i in range(H+1):
for a,b in Q:
if i+a>=H:
dp[H] = min(dp[H],dp[i]+b)
else:
dp[i+a] = min(dp[i+a],dp[i]+b)
print(dp[-1])
| 1 | 81,440,145,061,498 | null | 229 | 229 |
import math
from functools import reduce
def gcd(*numbers):
return reduce(math.gcd, numbers)
total = 0
N = int(input())
for i in range(1,N+1):
for j in range(1,N+1):
for k in range(1,N+1):
total += gcd(i, j, k)
print(total)
|
l=[1,9,30,76,141,267,400,624,885,1249,1590,2208,2689,3411,4248,5248,6081,7485,8530,10248,11889,13687,15228,17988,20053,22569,25242,28588,31053,35463,38284,42540,46581,50893,55362,61824,65857,71247,76884,84388,89349,97881,103342,111528,120141,128047,134580,146316,154177,164817,174438,185836,194157,207927,218812,233268,245277,257857,268182,288216,299257,313635,330204,347836,362973,383709,397042,416448,434025,456967,471948,499740,515581,536073,559758,583960,604833,633651,652216,683712,709065,734233,754734,793188,818917,846603,874512,909496,933081,977145,1006126,1041504,1073385,1106467,1138536,1187112,1215145,1255101,1295142,1342852,1373253,1422195,1453816,1502376,1553361,1595437,1629570,1691292,1726717,1782111,1827492,1887772,1925853,1986837,2033674,2089776,2145333,2197483,2246640,2332104,2379085,2434833,2490534,2554600,2609625,2693919,2742052,2813988,2875245,2952085,3003306,3096024,3157249,3224511,3306240,3388576,3444609,3533637,3591322,3693924,3767085,3842623,3912324,4027884,4102093,4181949,4270422,4361548,4427853,4548003,4616104,4718640,4812789,4918561,5003286,5131848,5205481,5299011,5392008,5521384,5610705,5739009,5818390,5930196,6052893,6156139,6239472,6402720,6493681,6623853,6741078,6864016,6953457,7094451,7215016,7359936,7475145,7593865,7689630,7886244,7984165,8130747,8253888,8403448,8523897,8684853,8802826,8949612,9105537,9267595,9376656,9574704,9686065,9827097,9997134,10174780,10290813,10493367,10611772,10813692]
print(l[int(input())-1])
| 1 | 35,653,342,179,068 | null | 174 | 174 |
import sys
while True:
height, width = map(int, raw_input().split())
if height == 0 and width == 0:
break
for i in range(height):
for j in range(width):
if j % 2 == 0 and i % 2 == 0: #even n, even n
sys.stdout.write("#")
elif j % 2 != 0 and i % 2 == 0: #even n, odd n
sys.stdout.write(".")
elif j % 2 == 0 and i % 2 != 0: #odd n, even n
sys.stdout.write(".")
elif j % 2 != 0 and i % 2 != 0: #odd n, odd n
sys.stdout.write("#")
print
print
|
N=int(input())
A=list(map(int,input().split()))
h=0
for i in range(1,N):
if A[i-1]<=A[i]:
h+=0
if A[i-1]>A[i]:
h+=A[i-1]-A[i]
A[i]=A[i-1]
print(h)
| 0 | null | 2,742,599,111,952 | 51 | 88 |
N = int(input())
E = [[] for _ in range(N+1)]
for _ in range(N):
tmp = list(map(int, input().split()))
if tmp[1] == 0:
continue
E[tmp[0]] = tmp[2:]
cnt = [0 for _ in range(N+1)]
q = [1]
while q:
cp = q.pop(0)
for np in E[cp]:
if cnt[np] != 0:
continue
cnt[np] = cnt[cp] + 1
q.append(np)
for ind, cost in enumerate(cnt):
if ind == 0:
continue
if ind == 1:
print(ind, 0)
else:
if cost == 0:
print(ind, -1)
else:
print(ind, cost)
|
N, K = [int(x) for x in input().split()]
l = []
while N > 0:
l.insert(0, N % K)
N = N // K
print(len(l))
| 0 | null | 32,035,224,509,948 | 9 | 212 |
N = int(input())
print(1/2 if N%2==0 else (N+1)/(2*N))
|
#!/usr/bin/env python3
n=int(input())
print((n-n//2)/n)
| 1 | 176,646,598,223,900 | null | 297 | 297 |
def fun(d):
cnt = 0
for i in d:
cnt+= i*d[i]
return cnt
from collections import defaultdict
d = defaultdict(int)
n = int(input())
A = list(map(int,input().split()))
for i in range(n):
d[A[i]]+=1
q = int(input())
cnt = sum(A)
for i in range(q):
b,c = map(int,input().split())
if b in d:
cnt+=(-b*d[b] + c*d[b])
d[c]+=d[b]
d[b]=0
#print(cnt,d)
print(cnt)
|
N = int(input())
n = input().split()
a = []
for i in range(N):
a.append(int(n[i]))
a = sorted(a)
print('{0} {1} {2}'.format(a[0], a[-1], sum(a)))
| 0 | null | 6,441,572,951,520 | 122 | 48 |
import sys
a, b = map(int, sys.stdin.readline().split())
if a <= 9 and b <= 9:
print(a*b)
else:
print(-1)
|
a, b = map(int, input().split())
if a > 0 and a < 10:
if b > 0 and b < 10:
print(a * b)
else:
print(-1)
else:
print(-1)
| 1 | 158,847,685,268,260 | null | 286 | 286 |
A1=input()
A2=input()
A3=input()
#N=int(N)
list1 = A1.split()
list1 = [int(i) for i in list1]
list2 = A2.split()
list2 = [int(i) for i in list2]
list3 = A3.split()
list3 = [int(i) for i in list3]
N = input()
N=int(N)
num=[]
for i in range(N):
num.append(int(input()))
T1 = all([(i in num ) for i in list1])
T2 = all([(i in num ) for i in list2])
T3 = all([(i in num ) for i in list3])
T4 = all([(list1[0] in num),(list2[0] in num),(list3[0] in num)])
T5 = all([(list1[1] in num),(list2[1] in num),(list3[1] in num)])
T6 = all([(list1[2] in num),(list2[2] in num),(list3[2] in num)])
T7 = all([(list1[0] in num),(list2[1] in num),(list3[2] in num)])
T8 = all([(list1[2] in num),(list2[1] in num),(list3[0] in num)])
if (any([T1,T2,T3,T4,T5,T6,T7,T8])) == True:
print("Yes")
else:
print("No")
|
n = input()
vals = list(map(int, input().split()))
print(min(vals), max(vals), sum(vals))
| 0 | null | 30,425,139,224,496 | 207 | 48 |
s = input().split(" ")
st = []
for i in range(len(s)):
if s[i] == "+":
a = st.pop()
b = st.pop()
st.append(a+b)
elif s[i] == "-":
a = st.pop()
b = st.pop()
st.append(b-a)
elif s[i] == "*":
a = st.pop()
b = st.pop()
st.append(a*b)
else:
st.append(int(s[i]))
print(st[0])
|
def resolve():
S, W = list(map(int, input().split()))
print("unsafe" if S <= W else "safe")
if '__main__' == __name__:
resolve()
| 0 | null | 14,740,022,557,082 | 18 | 163 |
X = int(input())
Y = X ** 3
print(Y)
|
x = int(input(''))
print("{0}".format(x*x*x))
| 1 | 279,472,118,760 | null | 35 | 35 |
import re
def bubble_sort(C, N):
for i in range(N):
for j in reversed(range(1, N)):
if C[j][1] < C[j-1][1]:
# 1???????????????????°????????????°??????
C[j], C[j-1] = C[j-1], C[j]
return C
def selection_sort(C, N):
for i in range(N):
# i ?????????????????¨????????????
minj = i
for j in range(i, N):
# ?????????????????¨??????????°???????????????????
if C[j][1] < C[minj][1]:
minj = j
# ??????????????¨??????????°????????????????????????\????????????
C[i], C[minj] = C[minj], C[i]
return C
def is_stable(C, sorted):
# ????????°???????????????????¨???????????????????????´???????????????????
c_container = []
s_container = []
for i in range(len(C)):
# C ??§ i ????????\?????????????????§????????°????????????????????¢???
for j in range(len(C)):
# ????????°???????????????????????£?????´???
if C[i][1] == C[j][1]:
# C ????????????????¨?????????????
c_container.append(C[j][0])
# ????????°???????????????????????¨????????´???
if len(c_container) >= 2:
# C ??§ i ???????????????????????°?????¨????????°????????????????????¢???
for k in range(len(sorted)):
# ????±??????????????????°?????¨????????°???????¨?????????????????????????????????????????????????????´?
if sorted[k][1] == C[i][1]:
s_container.append(sorted[k][0])
# ??????????????´?????????????????£?????´???
if c_container != s_container:
# Not Stable
return False
# ?????????????????????
c_container = []
s_container = []
return True
if __name__ == '__main__':
N = int(input())
# ??????????????????????????????????????¨?????¨??°?????¨?????????????????????????´?
cards = input().split()
C = [[] for i in range(N)]
for i in range(N):
# ??????????¨??????¨??°????????????
symbol_and_num = re.findall(r'(\d+|\D+)', cards[i])
C[i] = [symbol_and_num[0], int(symbol_and_num[1])]
# ??????????????????????????????
bubble_sorted = bubble_sort(C.copy(), N)
# ?¨??????¨???????????????
bubble_sorted_cards = [val[0] + str(val[1]) for val in bubble_sorted]
# ?????????????????????
print(' '.join(bubble_sorted_cards))
# stable or not stable
print('Stable' if is_stable(C, bubble_sorted) else 'Not stable')
# ?????????????????????
selection_sorted = selection_sort(C.copy(), N)
# ?¨??????¨???????????????
selection_sorted_cards = [val[0] + str(val[1]) for val in selection_sorted]
# ?????????????????????
print(' '.join(selection_sorted_cards))
# stable or not stable
print('Stable' if is_stable(C, selection_sorted) else 'Not stable')
|
# coding: utf-8
# Here your code !
n=int(input())
cards=input().split()
def bubble_sort(cards_b,n):
for i in range(n):
for j in range(-1,-n,-1):
a=int(cards_b[j][1])
b=int(cards_b[j-1][1])
if a<b:
cards_b[j],cards_b[j-1]=cards_b[j-1],cards_b[j]
return cards_b
def selection_sort(cards_s,n):
for i in range(n):
minv=i
for j in range(i,n):
a=int(cards_s[minv][1])
b=int(cards_s[j][1])
if a>b:
minv=j
cards_s[minv],cards_s[i]=cards_s[i],cards_s[minv]
return cards_s
dummy=cards.copy()
ans_1=bubble_sort(cards,n)
ans_2=selection_sort(dummy,n)
print(*ans_1)
print("Stable")
print(*ans_2)
if ans_1!=ans_2:
print("Not stable")
else:
print("Stable")
| 1 | 25,351,864,638 | null | 16 | 16 |
N = int(input())
P = [p for p in map(int,input().split())]
ans = 0
min_p = P[0]
for p in P:
if min_p >= p:
min_p = p
ans += 1
print(ans)
|
N = int(input())
P = list(map(int,input().split()))
P_min = []
a = 200000
ans = 0
for i in range(N):
if a >= P[i]:
ans += 1
a = P[i]
print(ans)
| 1 | 85,031,740,366,272 | null | 233 | 233 |
A = str(input())
B = str(input())
sum=0
for i in range(len(A)):
if A[i]!=B[i]:
sum+=1
print(sum)
|
S = input()
T = input()
count = 0
for i in range(len(S)):
if S[i] != T[i]:
count += 1
else:
pass
print(count)
| 1 | 10,439,160,821,510 | null | 116 | 116 |
s=list(input())
t=list(input())
x=0
for i in range(len(s)):
if s[i]!=t[i]:
x+=1
else:
pass
print(x)
|
k = int(input())
ans = "ACL" * k
print(ans)
| 0 | null | 6,367,399,996,818 | 116 | 69 |
from sys import stdin
n = int(stdin.readline().rstrip())
print(n ** 3)
|
num = int(input())
print("{0}".format(num**3))
| 1 | 280,497,230,968 | null | 35 | 35 |
n = int(input())
lx = list(map(int,input().split()))
lc=[]
for i in range(1,101):
c = 0
for x in lx:
c += (i-x)**2
lc.append(c)
print(min(lc))
|
x=int(input())
if x in range(400,600):
p=8
elif x in range(600,800):
p=7
elif x in range(800,1000):
p=6
elif x in range(1000,1200):
p=5
elif x in range(1200,1400):
p=4
elif x in range(1400,1600):
p=3
elif x in range(1600,1800):
p=2
elif x in range(1800,2000):
p=1
print(p)
| 0 | null | 35,804,890,495,880 | 213 | 100 |
S = input().strip()
K = int(input())
if K==1 or S[0]!=S[-1]:
x = list(S)
cnt = 0
for i in range(1,len(x)):
if x[i]==x[i-1]:
x[i]=0
cnt += 1
print(cnt*K)
else:
x = list(S+S)
cnt = 0
for i in range(1,len(x)):
if x[i]==x[i-1]:
x[i]=0
cnt += 1
k1 = len(x)
x = x+list(S)
d1 = 0
for i in range(k1,len(x)):
if x[i]==x[i-1]:
x[i]=0
d1 += 1
k2 = len(x)
x += list(S)
d2 = d1
for i in range(k2,len(x)):
if x[i]==x[i-1]:
x[i]=0
d2 += 1
if K==2:
print(cnt)
elif K%2==0:
print(cnt+d2*(K//2-1))
else:
print(cnt+d2*(K//2-1)+d1)
|
# A - Connection and Disconnection
def count(s, c):
count_ = s.count(c*2)
while c*3 in s:
s = s.replace(c*3, c+'_'+c)
while c*2 in s:
s = s.replace(c*2, c+'_')
return min(count_, s.count('_'))
def get_startswith(s, c):
key = c
while s.startswith(key+c):
key += c
return len(key)
def get_endswith(s, c):
key = c
while s.endswith(key+c):
key += c
return len(key)
import string
S = input()
K = int(input())
lower = string.ascii_lowercase
ans = 0
if S[0] == S[-1:]:
start = get_startswith(S, S[0])
end = get_endswith(S, S[0])
if start == end == len(S):
print(len(S) * K // 2)
else:
ans = 0
ans += start // 2
ans += end // 2
ans += ((start + end) // 2) * (K - 1)
for c in lower:
ans += count(S[start:len(S)-end], c) * K
print(ans)
else:
for c in lower:
ans += count(S, c)
print(ans * K)
| 1 | 175,986,945,324,938 | null | 296 | 296 |
import itertools
n, m, x = map(int, input().split())
A = []
for _ in range(n):
A.append(list(map(int, input().split())))
c = [ (0, 1) for _ in range(n)]
min_price = float('inf')
for cc in itertools.product(*c):
xx = [0] * m
price = 0
for i, ccc in enumerate(cc):
if ccc==1:
price += A[i][0]
xx = [a +b for a, b in zip(xx, A[i][1:])]
if min(xx) >= x:
min_price = min(min_price, price)
if min_price==float('inf'):
print(-1)
else:
print(min_price)
|
from itertools import product as prod
N,M,X=map(int,input().split())
B=[list(map(int,input().split())) for _ in range(N)]
ans=float('INF')
for v in prod(range(2),repeat=N):
scores=[0]*M
cost=0
for i in range(N):
if v[i]==1:
cost+=B[i][0]
for j in range(M):
scores[j]+=B[i][1+j]
if min(scores)>=X:
ans=min(ans,cost)
print(ans if ans!=float('INF') else -1)
| 1 | 22,297,811,365,470 | null | 149 | 149 |
from sys import stdin
n = int(stdin.readline())
M = [0] + [list(map(int, stdin.readline().split()[2:])) for i in range(n)]
sndf = [0] + [[False, i] for i in range(1, n + 1)]
tt = 0
def dfs(u):
global tt
sndf[u][0] = True
tt += 1
sndf[u].append(tt)
for v in M[u]:
if not sndf[v][0]:
dfs(v)
tt += 1
sndf[u].append(tt)
for i in range(1, n + 1):
if not sndf[i][0]:
dfs(i)
print(*sndf[i][1:])
|
n = int(input())
Adj = [[0]]
for _ in range(n):
Adj.append(list(map(int, input().split()))[2:])
visited = [False]*(n+1)
s = [0]*(n+1)
f = [0]*(n+1)
time = 0
def dfs(i):
global time
time += 1
s[i] = time
visited[i] = True
for j in Adj[i]:
if not visited[j]:
dfs(j)
time += 1
f[i] = time
while not all(visited[1:]):
i = visited[1:].index(False) + 1
dfs(i)
for i in range(1, n+1):
print(i,s[i], f[i])
| 1 | 2,933,754,080 | null | 8 | 8 |
# -*- coding: utf-8 -*-
def main():
N = int(input())
d = list(map(int, input().split()))
ans = 0
for i in range(N - 1):
for j in range(i + 1, N):
ans += d[i] * d[j]
print(ans)
if __name__ == "__main__":
main()
|
def readInt():
return int(input())
def readList():
return list(map(int,input().split()))
def readMap():
return map(int,input().split())
def readStr():
return input()
inf=float('inf')
mod = 10**9+7
import math
def solve(N,X,M):
seen=set()
order_seen=[]
while X not in seen:
seen.add(X)
order_seen.append(X)
X=f(X,M)
pos=order_seen.index(X) # Find position of when the cycle begins
if pos>N: # If position is greater than N, then we know we are not going to include any values from the cycle.
return sum(order_seen[:N])
terms_before_cycle=order_seen[:pos]
sum_terms_before_cycle=sum(terms_before_cycle)
ans=sum_terms_before_cycle
terms_in_cycle=order_seen[pos:]
sum_cycle=sum(terms_in_cycle)
length_cycle=len(terms_in_cycle)
number_remaining_terms=N-pos
mult_factor=(number_remaining_terms)//length_cycle
ans+=(sum_cycle*mult_factor)
numb_remain=(number_remaining_terms)%length_cycle
ans+=sum(terms_in_cycle[:numb_remain])
return ans
# The function for the recurrence relation. A_n+1=A_n^2%M
def f(A,M):
return pow(A,2,M)
N,X,M=readMap()
print(solve(N,X,M))
| 0 | null | 85,168,666,114,972 | 292 | 75 |
N, *A = map(int, open(0).read().split())
mod = 10 ** 9 + 7
ans = 0
for bit in range(60):
ctr = [0, 0]
for i in range(N):
ctr[A[i] >> bit & 1] += 1
ans += (1 << bit) * (ctr[0] * ctr[1])
ans %=mod
print(ans)
|
#!/usr/bin/env python3
n, *a = map(int, open(0).read().split())
b = [0] * 60
c = [0] * 60
ans = 0
for i in range(n):
for j in range(60):
c[j] += i - b[j] if a[i] >> j & 1 else b[j]
b[j] += a[i] >> j & 1
for j in range(60):
ans += c[j] << j
print(ans % (10**9 + 7))
| 1 | 122,997,986,493,568 | null | 263 | 263 |
n,k=map(int,input().split())
A=list(map(int,input().split()))
C=[n for _ in range(n)]
for loop in range(k):
B=[0 for _ in range(n)]
for i in range(n):
l,r=max(0,i-A[i]),i+A[i]+1
B[l] +=1
if r<n:B[r] -=1
for i in range(n-1):
B[i+1]=B[i]+B[i+1]
A=B
if A==C:break
print(*A)
|
N,K=map(int,input().split())
A=[0]+list(map(int,input().split()))+[0]
p=50
if K<=p:
for i in range(K):
B=[0]+[0]*N+[0]
for j in range(1,N+1):
left = max(0,j-A[j])
right = min(N+1,j+A[j]+1)
B[left] += 1
B[right] -= 1
A[0]=B[0]
for k in range(1,N+1):
A[k]=A[k-1]+B[k]
else:
A=[N]*(N+2)
print(*A[1:N+1])
| 1 | 15,453,309,203,992 | null | 132 | 132 |
import sys
s = input()
k = int(input())
n = len(s)
if n==1:
print(k//2)
sys.exit()
if n==2:
print(k if s[0]==s[1] else 0)
sys.exit()
i = 1
change = [0, 0]
same = True
while i<n:
if s[i-1]==s[i]:
if i==n-1:
same = False
change[0] += 1
i += 1
i += 1
if s[0]!=s[-1]:
same = False
if not same:
print(change[0]*k)
sys.exit()
i = 2
change[1] = 1
same = True
while i<n:
if s[i-1]==s[i]:
if i==n-1:
same = False
change[1] += 1
i += 1
i += 1
if same:
print(change[0]+change[1]*(k-1))
else:
print(change[0]*((k+1)//2)+change[1]*(k//2))
|
import math
foo = []
while True:
n = int(input())
if n == 0:
break
a = [int(x) for x in input().split()]
ave = sum(a)/len(a)
hoge = 0
for i in a:
hoge += (i - ave) ** 2
hoge /= len(a)
foo += [math.sqrt(hoge)]
for i in foo:
print(i)
| 0 | null | 87,463,308,225,920 | 296 | 31 |
ab=list(map(int,input().split()))
a=ab[0]
b=ab[1]
if a<10 and b<10:
print(a*b)
else:
print(-1)
|
k, a, b = map(int, open(0).read().split())
print("OK" if b // k * k >= a else "NG")
| 0 | null | 92,599,598,801,750 | 286 | 158 |
_=input()
arr=list(map(int, input().split()))
odd=[n for (n,y) in enumerate(arr,1) if n%2 > 0 and y%2 > 0]
print (len(odd))
|
#ライブラリの読み込み
import math
#入力値を格納
n,m = map(int,input().split())
#判定
if n == m:
text = "Yes"
else:
text = "No"
#結果を表示
print(text)
| 0 | null | 45,761,266,830,722 | 105 | 231 |
# Original Submission At: https://atcoder.jp/contests/abc149/submissions/16823042
x= int(input())
def prime_check(num,count):
while True:
while num % count == 0:
num = num + 1
count = 2
if num <= count**2:
print(num)
break
else:
count = count + 1
if x==2 :
print (2)
else:
prime_check(x,2)
|
A,B,C=map(int,input().split())
result=0
if A == B:
if A != C and B != C:
result+=1
elif A == C:
if A != B and B != C:
result+=1
elif B == A:
if B != A and C != B:
result+=1
elif B ==C:
if B != A and A != C:
result+=1
elif C == A:
if C != B and A == B:
result+=1
elif C == B:
if C != A and A == B:
result+=1
if result==1:
print('Yes')
else:
print('No')
| 0 | null | 86,790,799,845,600 | 250 | 216 |
N,K = map(int,input().split())
H = [int(x) for x in input().split()]
H_sort = sorted(H,reverse=True)
print(sum(H_sort[K:]))
|
def resolve():
N, K = map(int, input().split())
H = list(map(int, input().split()))
h = sorted(H)[::-1]
ans = h[K:]
print(sum(ans))
resolve()
| 1 | 78,980,223,433,124 | null | 227 | 227 |
N = int(input())
X = list(map(int, input().split()))
p = 0
s = sum(X)
for n in range(N):
s -= X[n]
s = s % (10**9 + 7)
p += s * X[n]
p = p % (10**9 + 7)
print(p)
|
from copy import copy
import random
import math
import sys
input = sys.stdin.readline
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 k in range(1,37001):
na = copy(ans)
x = random.randint(1,365)
y = random.randint(1,365)
z = random.randint(min(x,y),max(x,y))
if x == y:
continue
na[x-1],na[y-1] = na[y-1],na[x-1]
na[x-1],na[z-1] = na[z-1],na[z-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 k%100 == 1:
T = 300-(298*k/37000)
p = pow(math.e,-abs(ns-score)/T)
if ns > score or random.random() < p:
ans = na
score = ns
for a in ans:
print(a)
| 0 | null | 6,740,172,695,902 | 83 | 113 |
N=int(input())
A=list(map(int,input().split()))
h=0
for i in range(1,N):
if A[i-1]<=A[i]:
h+=0
if A[i-1]>A[i]:
h+=A[i-1]-A[i]
A[i]=A[i-1]
print(h)
|
while 1:
try:
line = raw_input()
except EOFError:
break
arr = map((lambda x: int(x)), line.split())
print len(str(arr[0]+arr[1]))
| 0 | null | 2,302,654,595,042 | 88 | 3 |
s = input()
cnt = [1] if s[0] == "<" else [0, 1]
bc = s[0]
for i in range(1, len(s)):
if s[i] == bc:
cnt[-1] += 1
else:
cnt.append(1)
bc = s[i]
if len(cnt) % 2 == 1:
cnt.append(0)
ans = 0
for i in range(0, len(cnt), 2):
ma = max(cnt[i], cnt[i + 1])
mi = min(cnt[i], cnt[i + 1])
ans += max(0, ma * (ma + 1) // 2)
ans += max(0, (mi - 1) * mi // 2)
print(ans)
|
# coding: utf-8
# hello worldと表示する
#dpでできないかな？
import sys
input = sys.stdin.readline
sys.setrecursionlimit(10**7)
from collections import Counter, deque
from collections import defaultdict
from itertools import combinations, permutations, accumulate, groupby, product
from bisect import bisect_left,bisect_right
from heapq import heapify, heappop, heappush
from math import floor, ceil,pi
from operator import itemgetter
def I(): return int(input())
def MI(): return map(int, input().split())
def LI(): return list(map(int, input().split()))
def LI2(): return [int(input()) for i in range(n)]
def MXI(): return [[LI()]for i in range(n)]
def SI(): return input().rstrip()
def printns(x): print('\n'.join(x))
def printni(x): print('\n'.join(list(map(str,x))))
inf = 10**17
mod = 10**9 + 7
s=SI()
if s[0]!="<":
s="<"+s
if s[-1]!=">":
s=s+">"
#print(s)
state="<"
strs=[]
count=0
for i in range(len(s)):
if state=="<":
if s[i]=="<":
count+=1
else:
strs.append(count)
count=1
state=">"
else:
if s[i]==">":
count+=1
else:
strs.append(count)
count=1
state="<"
strs.append(count)
#print(strs)
ans=0
for i in range(len(strs)//2):
u=min(strs[2*i],strs[2*i+1])
v=max(strs[2*i],strs[2*i+1])
ans+=(u-1)*u//2+v*(v+1)//2
print(ans)
| 1 | 156,706,792,692,758 | null | 285 | 285 |
while True:
H, W = map(int, input().split())
if not(H or W):
break
for i in range(H):
print('#', end='')
for j in range(W-2):
if i > 0 and i < H - 1:
print('.', end='')
else:
print('#', end='')
print('#')
print()
|
while True:
line = input()
data = line.split()
h = int(data[0])
w = int(data[1])
if h == 0 and w == 0:
break
for i in range(h):
for j in range(w):
if i == 0 or i == h -1:
print("#", end="")
else:
if j == 0 or j == w -1:
print("#", end="")
else:
print(".", end="")
print("")
print("")
| 1 | 831,054,535,948 | null | 50 | 50 |
num = int(input())
s = list(map(int, input().split()))
cnt = 0
def merge(A, left, mid, right):
global cnt
L = A[left:mid] + [10**9 + 1]
R = A[mid:right] + [10**9 + 1]
i = 0
j = 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
cnt += right - left
def merge_sort(A, left, right):
if (left + 1) < right:
mid = (left + right) // 2
merge_sort(A, left, mid)
merge_sort(A, mid, right)
merge(A, left, mid, right)
merge_sort(s, 0, num)
print(*s)
print(cnt)
|
N = int(input())
result = [0] * (N + 1)
for i in list(map(int, input().split())):
result[i] += 1
result.pop(0)
for r in result:
print(r)
| 0 | null | 16,408,256,116,152 | 26 | 169 |
N = int(input())
li = list(map(int, input().split()))
minL = 2 * (10**6)
count = 0
for l in li:
if (minL >= l):
count += 1
minL = l
print(count)
|
import sys
read = sys.stdin.read
readlines = sys.stdin.readlines
def main():
n, *a = map(int, read().split())
r = 0
minp = a[0]
for i1 in range(n):
if minp >= a[i1]:
r += 1
minp = a[i1]
print(r)
if __name__ == '__main__':
main()
| 1 | 85,669,478,622,012 | null | 233 | 233 |
#もらうDP + 累積和
n, k = map(int, input().split())
mod = 998244353
li = []
for _ in range(k):
l, r = map(int, input().split())
li.append((l, r))
li.sort()
dp = [0]*(2*n+1)
s = [0] * (2*n+1)
dp[1] = 1
s[1] = 1
for i in range(2, n+1):
for t in li:
l, r = t
dp[i] += s[max(i-l, 0)]
dp[i] -= s[max(i-r-1, 0)]
dp[i] %= mod
s[i] = s[i-1] + dp[i]
s[i] %= mod
print(dp[i]%mod)
|
# coding=utf-8
from math import floor, ceil, sqrt, factorial, log, gcd
from itertools import accumulate, permutations, combinations, product, combinations_with_replacement
from bisect import bisect_left, bisect_right
from collections import Counter, defaultdict, deque
from heapq import heappop, heappush, heappushpop, heapify
import copy
import sys
INF = float('inf')
mod = 10**9+7
sys.setrecursionlimit(10 ** 6)
def lcm(a, b): return a * b / gcd(a, b)
# 1 2 3
# a, b, c = LI()
def LI(): return list(map(int, sys.stdin.buffer.readline().split()))
# a = I()
def I(): return int(sys.stdin.buffer.readline())
# abc def
# a, b = LS()
def LS(): return sys.stdin.buffer.readline().rstrip().decode('utf-8').split()
# a = S()
def S(): return sys.stdin.buffer.readline().rstrip().decode('utf-8')
# 2
# 1
# 2
# [1, 2]
def IR(n): return [I() for i in range(n)]
# 2
# 1 2 3
# 4 5 6
# [[1,2,3], [4,5,6]]
def LIR(n): return [LI() for i in range(n)]
# 2
# abc
# def
# [abc, def]
def SR(n): return [S() for i in range(n)]
# 2
# abc def
# ghi jkl
# [[abc,def], [ghi,jkl]]
def LSR(n): return [LS() for i in range(n)]
# 2
# abcd
# efgh
# [[a,b,c,d], [e,f,g,h]]
def SRL(n): return [list(S()) for i in range(n)]
# n, k = LI()
# s = set()
# for i in range(k):
# l, r = LI()
# s |= set(range(l, r + 1))
# # a = len(s)
# dp = [0] * (n + 1)
# dp[1] = 1
# for i in range(1, n+1):
# for j in range(1, i):
# if i-j in s:
# dp[i] += dp[j] % 998244353
# # dp[i] += dp[j]
# print(dp[n] % 998244353)
# 配るDP
n, k = map(int, input().split())
lr = []
for _ in range(k):
l, r = map(int, input().split())
lr.append((l, r))
mod = 998244353
dp = [0]*(2*n+1)
dp[0] = 1
dp[1] = -1
now = 1
for i in range(n-1):
for l, r in lr:
# 始点に足して終点は引く
# imos法というらしい
dp[i+l] += now
dp[i+r+1] -= now
now += dp[i+1]
now %= mod
print(now)
| 1 | 2,703,611,753,450 | null | 74 | 74 |
#import pysnooper
#import os,re,sys,operator,math,heapq,string
from collections import Counter,deque
#from operator import itemgetter
#from itertools import accumulate,combinations,groupby,combinations_with_replacement
from sys import stdin,setrecursionlimit
#from copy import deepcopy
setrecursionlimit(10**6)
input=stdin.readline
n=int(input().rstrip())
gragh=[[] for _ in range(n)]
q=deque()
for i in range(n):
u=list(map(int,input().rstrip().split()))
for j in u[2:]:
gragh[u[0]-1].append(j-1)
#print(gragh)
dis=[-1]*n
dis[0]=0
q.append(0)
while len(q)!=0:
v=q.popleft()
for i in gragh[v]:
if dis[i]!=-1:
continue
dis[i]=dis[v]+1
q.append(i)
for i,j in enumerate(dis,1):
print(i,j)
|
from collections import deque
n = int(input())
u = [[] for i in range(n+1)] #隣接リスト
for i in range(n):
v = list(map(int, input().split()))
u[v[0]] = v[1:] #v = [次数, 頂点...]
d = [-1] * (n+1)
visited = [False] * (n+1)
d[1] = 0
visited[1] = True
que = deque([1])
while len(que) > 0:
c = que.popleft()
for i in range(1, u[c][0]+1):
if not visited[u[c][i]]:
que.append(u[c][i])
visited[u[c][i]] = True
d[u[c][i]] = d[c] + 1
for i in range(1, n+1):
print(i, d[i])
| 1 | 3,647,105,840 | null | 9 | 9 |
import math
A, B = [i for i in input().split()]
A = int(A)
tmp = B.split('.')
B = 100 * int(tmp[0]) + int(tmp[1])
print((A*B)//100)
|
a, b = map(float, input().split())
print(int(a)*int(b*100+0.5)//100)
| 1 | 16,504,613,536,128 | null | 135 | 135 |
MOD = (int) (1e9+7)
def power(a,n):
if a == 0: return 0
if n == 0: return 1
res = 1
while n > 0:
if n % 2 == 1: res = res * a % MOD
a = a * a % MOD
n //= 2
return res
def inverse(n):
return power(n, MOD-2)
N, K = map(int,input().split())
A = list(map(int,input().split()))
B = []
pos, neg = 0, 0
for a in A:
if a > 0:
B.append([a,1])
pos += 1
if a < 0:
B.append([-a,-1])
neg += 1
if a == 0:
B.append([0,0])
B.sort(reverse=True)
ans, sign = 1, 1
if N == neg and K % 2 == 1:
for i in range(K):
ans *= B[N-1-i][0]
ans %= MOD
print(-ans % MOD)
exit()
for i in range(K):
ans *= B[i][0]
ans %= MOD
sign *= B[i][1]
if N == K:
if sign >= 0: print(ans)
else: print(-ans % MOD)
exit()
if sign < 0:
out_neg, out_pos = 0, 0
in_pos, in_neg = 0, 0
for i in range(K):
if B[K-1-i][1] < 0:
out_neg = B[K-1-i][0]
break
for i in range(K):
if B[K-1-i][1] > 0:
out_pos = B[K-1-i][0]
break
for i in range(N-K):
if B[K+i][1] > 0:
in_pos = B[K+i][0]
break
for i in range(N-K):
if B[K+i][1] < 0:
in_neg = B[K+i][0]
break
if in_neg == 0 or out_pos == 0:
ans = (ans * in_pos % MOD) * inverse(out_neg) % MOD
elif in_pos == 0 or out_neg == 0:
ans = (ans * in_neg % MOD) * inverse(out_pos) % MOD
else:
if out_pos * in_pos < out_neg * in_neg:
ans = (ans * in_neg % MOD) * inverse(out_pos) % MOD
else:
ans = (ans * in_pos % MOD) * inverse(out_neg) % MOD
print(ans)
|
#!/usr/bin/env python3
# encoding:utf-8
import copy
import random
import bisect #bisect_left これで二部探索の大小検索が行える
import fractions #最小公倍数などはこっち
import math
import sys
import collections
from decimal import Decimal # 10進数で考慮できる
mod = 10**9+7
sys.setrecursionlimit(mod) # 再帰回数上限はでdefault1000
d = collections.deque()
def LI(): return list(map(int, sys.stdin.readline().split()))
"""
N, K = LI()
A = LI()
def abssort(A):
return sorted(A, key = lambda x:abs(x), reverse= True)
tmps = []
A_abs = abssort(A)
cnt = 0
while len(tmps) > K:
# for i in range(K):
if A_abs[cnt] != 0:
tmps.append(A_abs[i])
cnt += 1
cnt = 0
for i in range(K):
if tmps[i] < 0:
cnt += 1
if cnt % 2 == 0:
ans = 1
for i in range(K):
ans *= tmps[i]
ans = ans % mod
print(ans)
sys.exit()
else:
tmp_1 = copy.deepcopy(tmps)
tmp_2 = copy.deepcopy(tmps)
tmp_1.reverse()
tmp_2.reverse()
tmp_2_ = 0
tmp_1_ = 0
# -を一つ消す
for i in range(K):
if tmp_1[i] < 0:
tmp_1.remove(tmp_1[i])
break
# + を一つたす
for i in range(K, N):
if A_abs[i] > 0:
tmp_1.append(A_abs[i])
tmp_1_ = 1
break
else:
# +がなかった時
tmp_1 = []
tmp_1_ = -1
A_abs.reverse()
for i in range(K):
tmp_1.append(A_abs[i])
# +を消して-を追加
cnt = 0
for i in range(K):
if tmp_2[i] > 0:
tmp_2.remove(tmp_2[i])
cnt += 1
break
if cnt == 1:
for i in range(K, N):
if A_abs[i] < 0:
tmp_2.append(A_abs[i])
tmp_2_ = 1
break
else:
tmp_2_ = 0
else:
tmp_2_ = -1
# print(tmp_1, tmp_2)
tmp_1_m = 1
tmp_2_m = 1
for i in range(K):
tmp_1_m *= tmp_1[i]
tmp_1_m = tmp_1_m % mod
if tmp_2_ == 0:
pass
else:
for i in range(K):
tmp_2_m *= tmp_2[i]
tmp_2_m = tmp_2_m % mod
# print(tmp_1_, tmp_2_)
if tmp_2_ == 0:
print(tmp_1_m)
elif tmp_1_ == 1 and tmp_2_ == -1:
print(tmp_1_m)
elif tmp_1_ == -1 and tmp_2_ == 1:
print(tmp_2_m)
elif tmp_1_ == 1 and tmp_2_ == 1:
for i in range(K):
if tmp_1[i] == tmp_2[i]:
pass
elif abs(tmp_1[i]) > abs(tmp_2[i]):
print(tmp_2_m)
sys.exit()
else:
print(tmp_1_m)
sys.exit()
else:
print(tmp_1_m)
# for i in range(K):
# if tmp_1[i] == tmp_2[i]:
# pass
# elif abs(tmp_1[i]) > abs(tmp_2[i]):
# print(tmp_2_m)
# sys.exit()
# else:
# print(tmp_1_m)
# sys.exit()
"""
N,K = list(map(int, input().split()))
A = list(map(int, input().split()))
# 正負に関係なくsort
A_abs = sorted(A, key = lambda x:abs(x))
A_p = [] # plusを入れる
A_n = [] # -を入れる
for i in range(N):
if A[i] < 0:
A_n.append(A[i])
else:
A_p.append(A[i])
A_n.sort()
A_p.sort(reverse = True)
ok = True
if len(A_p) > 0:
# 正の数が存在している
if N == K:
# 選択肢がない時
ok = (len(A_n) % 2 == 0)
# 負の数が偶数個
else:
ok = True
else:
ok = (K % 2 == 0)
ans = 1
if ok == False:
for i in range(K):
ans *= A_abs[i]
ans = ans % mod
else:
if K % 2 == 1:
# 奇数個選ぶ
ans *= A_p[0]
ans = ans % mod
A_p = A_p[1:]
position = 0
pairs = []
cnt_p = len(A_p)
cnt_n = len(A_n)
while cnt_p - position > 1:
pairs.append(A_p[position] * A_p[position + 1])
position += 2
position = 0
while cnt_n - position > 1:
pairs.append(A_n[position] * A_n[position + 1])
position += 2
pairs.sort(reverse=True)
for i in range(K // 2):
ans *= pairs[i]
ans = ans % mod
print(ans)
| 1 | 9,446,101,514,048 | null | 112 | 112 |
n = int(input())
A = []
g =[[] for _ in range(n+1)]
ans = {}
for _ in range(n-1):
a,b = map(int,input().split())
g[a].append(b)
A.append([a,b])
from collections import deque
q = deque()
q.append(1)
color = [-1]*(n+1)
color[1] = 0
cnt = 0
while q:
v = q.popleft()
p = 1
for u in g[v]:
if p==color[v]:
p += 1
color[u] = p
ans[v,u] = p
q.append(u)
cnt = max(cnt,p)
p += 1
print(cnt)
for i in range(n-1):
tmp = (A[i][0],A[i][1])
print(ans[tmp])
|
import sys
def solve():
readline = sys.stdin.buffer.readline
mod = 10 ** 9 + 7
h, w, k = list(map(int, readline().split()))
s = [list(str(readline().rstrip().decode('utf-8'))) for _ in range(h)]
cnt = 0
ls = []
lsd = -1
for i in range(h):
if s[i].count("#") != 0:
lsd = i
is_f = True
cnt += 1
for j in range(w):
if s[i][j] == "#":
if is_f:
is_f = False
else:
cnt += 1
s[i][j] = cnt
while ls:
ti = ls.pop()
for j in range(w):
s[ti][j] = s[i][j]
else:
ls.append(i)
if i == h - 1:
while ls:
ti = ls.pop()
for j in range(w):
s[ti][j] = s[lsd][j]
for i in range(len(s)):
print(*s[i])
if __name__ == '__main__':
solve()
| 0 | null | 139,942,719,901,318 | 272 | 277 |
from heapq import heappush, heappop, heapify
from collections import deque, defaultdict, Counter
import itertools
from itertools import permutations, combinations, accumulate, product, combinations_with_replacement
import sys
import bisect
import string
import math
import time
def I(): return int(input())
def S(): return input()
def MI(): return map(int, input().split())
def MS(): return map(str, input().split())
def LI(): return [int(i) for i in input().split()]
def LI_(): return [int(i)-1 for i in input().split()]
def StoI(): return [ord(i)-97 for i in input()]
def ItoS(nn): return chr(nn+97)
def input(): return sys.stdin.readline().rstrip()
def list2d(a, b, c): return [[c] * b for i in range(a)]
def list3d(a, b, c, d): return [[[d] * c for j in range(b)] for i in range(a)]
def list4d(a, b, c, d, e): return [[[[e] * d for j in range(c)] for j in range(b)] for i in range(a)]
def print_matrix(mat):
for i in range(len(mat)):
print(*['IINF' if v == IINF else "{:0=4}".format(v) for v in mat[i]])
yn = {False: 'No', True: 'Yes'}
YN = {False: 'NO', True: 'YES'}
MOD = 10**9+7
inf = float('inf')
IINF = 10**19
l_alp = string.ascii_lowercase
u_alp = string.ascii_uppercase
ts = time.time()
sys.setrecursionlimit(10**6)
nums = ['1', '2', '3', '4', '5', '6', '7', '8', '9', '10']
show_flg = False
# show_flg = True
def gcd(a, b):
if b == 0:
return a
return gcd(b, a % b)
def main():
N = I()
zero = 0
cnts = defaultdict(int)
used = set()
for i in range(N):
a, b = MI()
if a == 0 and b == 0:
zero += 1
continue
g = gcd(abs(a), abs(b))
a = a // g
b = b // g
if b < 0:
a = -a
b = -b
cnts[(a, b)] += 1
# print(cnts)
ans = 1
for key, c in cnts.items():
if key in used:
continue
a, b = key
if a > 0:
rev = (-b, a)
else:
rev = (b, -a)
if rev in cnts:
# keyの集合から一個以上選ぶ + revの集合から一個以上選ぶ + どれも選ばない
ans *= (pow(2, cnts[key], MOD) - 1) + (pow(2, cnts[rev], MOD) - 1) + 1
# print(key, rev, ans)
ans %= MOD
used.add(rev)
else:
ans *= pow(2, cnts[key], MOD)
ans += zero
ans -= 1
print(ans % MOD)
if __name__ == '__main__':
main()
|
from math import floor
from fractions import Fraction
a,b = input().split()
a = int(a)
b = Fraction(b)
print(floor(a*b))
| 0 | null | 18,724,845,605,394 | 146 | 135 |
n=int(input())
now=0
for i in range(1,n+1):
now+=(i+(i*(n//i)))*(n//i)//2
print(now)
|
import math
def S(i):
return ((i * (i+1)) // 2)
N = int(input())
ans = 0
sqrt_N = math.floor(math.sqrt(N))
for K in range(1, N+1, 1):
if((N // K) < sqrt_N):
break
# 個別に足す
ans += S(N // K) * K
for NdivK in range(1, sqrt_N, 1):
# [N // K]が等しいKの区間を求める
Kbegin = N // (NdivK + 1)
Kend = N // NdivK
ans += (S(NdivK) * (S(Kend) - S(Kbegin)))
print(ans)
| 1 | 10,944,529,656,192 | null | 118 | 118 |
import sys, re
from math import ceil, sqrt, hypot, factorial, pi, sin, cos, tan, asin, acos, atan, radians, degrees#, log2
from collections import deque, defaultdict, Counter
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
from fractions import gcd
from heapq import heappush, heappop, heapify
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
class UnionFind():
def __init__(self, n):
self.n = n
# parents[i]: 要素iの親要素の番号
# 要素iが根の場合、parents[i] = -(そのグループの要素数)
self.parents = [-1] * n
def find(self, x):
if 0 > self.parents[x]:
return x
else:
self.parents[x] = self.find(self.parents[x])
return self.parents[x]
def union(self, x, y):
x = self.find(x)
y = self.find(y)
if x == y:
return
if self.parents[x] > self.parents[y]:
x, y = y, x
self.parents[x] += self.parents[y]
self.parents[y] = x
# 要素xが属するグループの要素数を返す
def size(self, x):
return -self.parents[self.find(x)]
def same(self, x, y):
return self.find(x) == self.find(y)
# 要素xが属するグループに属する要素をリストで返す
def members(self, x):
root = self.find(x)
return [i for i in range(self.n) if self.find(i) == root]
# 全ての根の要素をリストで返す
def roots(self):
return [i for i, x in enumerate(self.parents) if 0 > x]
# グループの数を返す
def group_count(self):
return len(self.roots())
# 辞書{根の要素: [そのグループに含まれる要素のリスト], ...}を返す
def all_group_members(self):
return {r: self.members(r) for r in self.roots()}
# print()での表示用
# all_group_members()をprintする
def __str__(self):
return '\n'.join('{}: {}'.format(r, self.members(r)) for r in self.roots())
N, M, K = MAP()
tree = UnionFind(N)
friends = [[] for _ in range(N)]
for _ in range(M):
A, B = MAP()
tree.union(A-1, B-1)
friends[A-1].append(B-1)
friends[B-1].append(A-1)
blocks = [[] for _ in range(N)]
for _ in range(K):
C, D = MAP()
blocks[C-1].append(D-1)
blocks[D-1].append(C-1)
for i in range(N):
blocks_cnt = sum([tree.same(i, j) for j in blocks[i]])
print(tree.size(i) - len(friends[i]) - 1 - blocks_cnt, end=" ")
print()
|
from collections import Counter
class union_find():
def __init__(self,n):
self.n=n
##親要素のノード番号を格納。par[x]==xのときそのノードは根
##親とはその上にノードなし！！
self.par=[-1 for i in range(n)]
self.rank=[0]*(n)
def find(self,x):
if self.par[x]<0:
return x
else:
self.par[x]=self.find(self.par[x])
return self.par[x]
def union(self,x,y):
x=self.find(x)
y=self.find(y)
##木の高さを比較し、低い方から高い方へ辺をはる
if x==y:
return
if self.par[x]>self.par[y]:
x,y=y,x
self.par[x]+=self.par[y]
self.par[y]=x
def same(self,x,y):
return self.find(x) == self.find(y)
def size(self,x):
return -self.par[self.find(x)]
def members(self,x):
root=self.find(x)
return [i for i in range(self.n) if self.find(i)==root]
def roots(self):
return [i for i, x in enumerate(self.par) if x<0]
def all_group_member(self):
return {r:self.members(r) for r in self.roots()}
n,m,k=map(int,input().split())
uf=union_find(n)
good=[0 for _ in range(n)]
for _ in range(m):
a,b=map(int,input().split())
uf.union(a-1,b-1)
good[a-1]+=1
good[b-1]+=1
ans=[0 for _ in range(n)]
bad=[0 for _ in range(n)]
for _ in range(k):
p,q=map(int,input().split())
if uf.same(p-1,q-1):
bad[p-1]+=1
bad[q-1]+=1
ans1=[]
for u in range(n):
C=uf.size(u)
ans1.append(str(C-1-bad[u]-good[u]))
print(' '.join(ans1))
| 1 | 61,523,266,251,538 | null | 209 | 209 |
from collections import Counter
N = int(input())
*D, = map(int, input().split())
mod = 998244353
c = Counter(D)
v = max(D)
if c[0]!=1 or D[0]!=0:
print(0)
else:
ans = 1
for i in range(1, v+1):
ans *= pow(c[i-1], c[i], mod)
ans %= mod
print(ans)
|
n = int(input())
d = {}
mod = 998244353
max_v = 0
lis = list(map(int, input().split()))
# 先頭はかならず0
if lis[0] != 0:
print(0)
exit()
for v in lis:
if v not in d:
d[v] = 1
else:
d[v] += 1
max_v = max(max_v, v)
# 0はひとつだけ
if 0 not in d or d[0] > 1:
print(0)
exit()
ans = 1
# 木を作ることができるならば1~max_vまでの数字がそれぞれ1つ以上存在する
for i in range(1, max_v + 1):
if i not in d or i - 1 not in d:
ans *= 0
else:
ans *= pow(d[i - 1], d[i], mod)
ans %= mod
print(ans)
| 1 | 154,209,604,782,000 | null | 284 | 284 |
def read_input():
h, n = map(int, input().split())
magic = {}
for i in range(n):
a, b = map(int, input().split())
magic[i] = (a, b)
return h, n, magic
def submit():
h, n, magic = read_input()
dp = [float('inf') for _ in range(h + 1)]
dp[h] = 0
for i in reversed(range(1, h + 1)):
for a, b in magic.values():
# 更新する
# max(0, i - a)のHPにより少ない魔力消費量で行き着ければ更新する
rest = max(0, i - a)
if dp[rest] > dp[i] + b:
dp[rest] = dp[i] + b
print(dp[0])
submit()
|
import sys
read = sys.stdin.buffer.read
INF = 1 << 60
def main():
H, N, *AB = map(int, read().split())
dp = [INF] * (H + 1)
dp[0] = 0
for a, b in zip(*[iter(AB)] * 2):
for i in range(H + 1):
if dp[i] > dp[max(i - a, 0)] + b:
dp[i] = dp[max(i - a, 0)] + b
print(dp[H])
return
if __name__ == '__main__':
main()
| 1 | 81,287,491,669,088 | null | 229 | 229 |
n,m=map(int,input().split())
height=list(map(int,input().split()))
hoge=[1 for i in range(n)]
#print(hoge)
for i in range(m):
a,b=map(int,input().split())
#print(a,b,height[a-1],height[b-1])
if(height[a-1]>height[b-1]):
hoge[b-1]=0
elif(height[a-1]<height[b-1]):
hoge[a-1]=0
else:
hoge[a-1],hoge[b-1]=0,0
print(sum(hoge))
|
N, M = list(map(lambda x: int(x), input().split(" ")))
H = list(map(lambda h: int(h), input().split(" ")))
dest = [[] for i in range(N)]
for i in range(M):
tmp = input().split(" ")
dest[int(tmp[0]) - 1].append(int(tmp[1]) - 1)
dest[int(tmp[1]) - 1].append(int(tmp[0]) - 1)
good = 0
for i in range(len(dest)):
d = dest[i]
if len(list(filter(lambda j: H[i] - H[j] <= 0, d))) == 0:
good += 1
print(good)
| 1 | 25,163,805,711,814 | null | 155 | 155 |
from bisect import bisect_left
class score:
def __init__(self,t) -> None:
self.t = t
score = 0
last = [[] for i in range(26)]
for i,ti in enumerate(t):
score += s[i][ti-1]
last[ti-1].append(i+1)
for tj in range(26):
if last[tj-1] == []:
score -= c[tj-1]*(i+1)
else:
#print(last)
score -= c[tj-1]*((i+1)-last[tj-1][-1])
print(score)
self.score = score
def a__init__(self,t) -> None:
score = 0
last = [[] for i in range(26)]
for i,ti in enumerate(t):
# 開催分を加算
score += s[i][ti-1]
# 減らす
if last[ti-1] == []:
score -= c[i]*i+1
else:
score -= c[i]*((i+1)-last[ti-1][-1])
last[ti-1].append(i+1)
print(score)
for i in range(26):
if last[i] == []:
score -= c[i]*D
else:
score -= c[i]*(D-last[i][-1])
self.score = score
self.t = t
D = int(input())
c = list(map(int,input().split()))
s = [list(map(int,input().split())) for i in range(D)]
t = [int(input()) for i in range(D)]
sc = score(t)
#print(sc.score)
|
s=input()
p=input()
s=s+s
a=s.find(p)
if a==-1:
print('No')
else:
print('Yes')
| 0 | null | 5,826,764,368,128 | 114 | 64 |
square = []
while True:
data = [int(e) for e in input().split()]
if data[0]==0 and data[1]==0:
break
square.append(data)
for i in range(len(square)):
for j in range(square[i][0]):
for k in range(square[i][1]):
print("#", end="")
print()
print()
|
while True:
h, w = map(int, input().split())
if h == w == 0:
break
print(('#' * w + '\n') * h)
| 1 | 769,613,719,134 | null | 49 | 49 |
while True:
h, w = map(int, input().split())
if h == w == 0:
break
print(('#' * w + '\n') * h)
|
import sys
while 1:
H, W = map(int, raw_input().split())
if H == 0 and W == 0:
break
else:
for h in range(0, H):
for w in range(0, W):
sys.stdout.write("#")
print ""
print ""
| 1 | 781,244,393,180 | null | 49 | 49 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.