code1
stringlengths 16
24.5k
| code2
stringlengths 16
24.5k
| similar
int64 0
1
| pair_id
int64 2
181,637B
⌀ | question_pair_id
float64 3.71M
180,628B
⌀ | code1_group
int64 1
299
| code2_group
int64 1
299
|
|---|---|---|---|---|---|---|
n=int(input())
x=list(input())
def str2int(z):
flag=1
a=0
for i in reversed(x):
if i=='1':a+=flag
flag*=2
return a
popc=x.count('1')
z=str2int(x)
if popc-1!=0:
fl_1=z%(popc-1)
fl_0=z%(popc+1)
for i in range(n):
if x[i]=='1':
if popc-1==0:
print(0)
continue
mod=(fl_1-pow(2,n-1-i,popc-1))%(popc-1)
else:mod=(fl_0+pow(2,n-1-i,popc+1))%(popc+1)
#print('mod : %s'%mod)
cnt=1
while mod!=0:
pp=bin(mod).count("1")
mod%=pp
cnt+=1
print(cnt)
|
# -*- coding: utf-8 -*-
def main():
import sys
input = sys.stdin.readline
a, b, c = map(int, input().split())
k = int(input())
count = 0
while True:
if a >= b:
b *= 2
count += 1
else:
break
while True:
if b >= c:
c *= 2
count += 1
else:
break
if count <= k:
print('Yes')
else:
print('No')
if __name__ == '__main__':
main()
| 0 | null | 7,595,578,298,568 | 107 | 101 |
N,K=list(map(int,input().split()))
A=sorted(list(map(int,input().split())))
mod=10**9+7
def modinv(x):
return pow(x,mod-2,mod)
comb=1
ans=0
for i in range(N-K+1):
ans+=comb*A[K-1+i]
ans-=comb*A[N-K-i]
ans%=mod
comb*=(K+i)*modinv(i+1)
comb%=mod
print(ans)
|
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 | 80,027,615,846,400 | 242 | 212 |
num = list(map(int,input().split()))
num.sort()
print("%d %d %d" %(num[0],num[1],num[2]))
|
print(*sorted(input().split()))
| 1 | 422,797,324,418 | null | 40 | 40 |
import sys
def I(): return int(sys.stdin.readline())
def MI(): return map(int, sys.stdin.readline().split())
def LI(): return list(map(int, sys.stdin.readline().split()))
def main():
n = I()
A = LI()
sub = [0]*n
for a in A:
sub[a-1] += 1
for s in sub:
print(s)
if __name__ == '__main__':
main()
|
from collections import Counter
N=int(input())
A=list(map(int, input().split()))
C=Counter(A)
for i in range(1,N+1):
print(C[i])
| 1 | 32,559,760,721,702 | null | 169 | 169 |
N = int(input())
result = {}
result["AC"] = 0
result["WA"] = 0
result["TLE"] = 0
result["RE"] = 0
for i in range(N):
judge = input()
result[judge] += 1
for key, value in result.items():
print(f"{key} x {value}")
|
cards = {
'S': [0 for _ in range( 13)],
'H': [0 for _ in range( 13)],
'C': [0 for _ in range( 13)],
'D': [0 for _ in range( 13)],
}
n = int( input())
for _ in range( n):
(s, r) = input().split()
r = int(r)
cards[s][r - 1] = r
for s in ( 'S', 'H', 'C', 'D'):
for r in range( 13):
if cards[s][r] == 0:
print( '{0:s} {1:d}'.format( s, r+1))
| 0 | null | 4,834,809,738,394 | 109 | 54 |
n,k=map(int,input().split())
while n>k:
n=n%k
if n>k//2:
n=abs(n-k)
print(n)
|
import sys
sys.setrecursionlimit(10**9)
def mi(): return map(int,input().split())
def ii(): return int(input())
def isp(): return input().split()
def deb(text): print("-------\n{}\n-------".format(text))
INF=10**20
def main():
N,K=mi()
n = N//K
ans = INF
for m in [n-1,n,n+1]:
ans = min(ans,abs(N-K*m))
print(ans)
if __name__ == "__main__":
main()
| 1 | 39,104,184,201,720 | null | 180 | 180 |
tmp = 0
while True:
i = raw_input().strip().split()
a = int(i[0])
b = int(i[1])
if a == 0 and b == 0:
break
if a > b:
tmp = a
a = b
b = tmp
print a,b
|
while True:
x,y = input().split()
x = int(x)
y = int(y)
if x==0 and y==0:
break
elif x<y:
print(x,y)
elif x>=y:
print(y,x)
| 1 | 518,102,760,802 | null | 43 | 43 |
n, a, b = map(int, input().split())
mod = 10 ** 9 + 7
ans = pow(2, n, mod) - 1
for i in [a, b]:
num = 1
den = 1
for p in range(n, n-i, -1):
num = num * p % mod
for q in range(1, i+1):
den = den * q % mod
cmb = num * pow(den, mod-2, mod) % mod
ans -= cmb
ans %= mod
print(ans)
|
from collections import Counter,defaultdict,deque
from heapq import heappop,heappush,heapify
import sys,bisect,math,itertools,fractions,pprint
sys.setrecursionlimit(10**8)
mod = 10**9+7
INF = float('inf')
def inp(): return int(sys.stdin.readline())
def inpl(): return list(map(int, sys.stdin.readline().split()))
n,m = inpl()
s = list(input())[::-1]
res = []
now = 0
while now != n:
nex = min(now + m, n)
while s[nex] == '1':
nex -= 1
if nex == now:
print(-1)
quit()
res += [nex - now]
now = nex
print(*res[::-1])
| 0 | null | 102,922,466,535,062 | 214 | 274 |
from collections import deque
class SegmentTree():
def __init__(self,n,ide_ele,merge_func,init_val):
self.n=n
self.ide_ele=ide_ele
self.merge_func=merge_func
self.val=[0 for i in range(1<<n)]
self.merge=[0 for i in range(1<<n)]
self.parent=[-1 for i in range(1<<n)]
deq=deque([1<<(n-1)])
res=[]
while deq:
v=deq.popleft()
res.append(v)
if not v&1:
gap=(v&-v)//2
self.parent[v-gap]=v
deq.append(v-gap)
self.parent[v+gap]=v
deq.append(v+gap)
for v in res[::-1]:
if v-1<len(init_val):
self.val[v-1]=init_val[v-1]
self.merge[v-1]=self.val[v-1]
if not v&1:
gap=(v&-v)//2
self.merge[v-1]=self.merge_func(self.merge[v-1],self.merge[v-gap-1],self.merge[v+gap-1])
def update(self,id,x):
self.val[id]=x
pos=id+1
while pos!=-1:
if pos&1:
self.merge[pos-1]=self.val[pos-1]
else:
gap=(pos&-pos)//2
self.merge[pos-1]=self.merge_func(self.val[pos-1],self.merge[pos+gap-1],self.merge[pos-gap-1])
pos=self.parent[pos]
def cnt(self,k):
lsb=(k)&(-k)
return (lsb<<1)-1
def lower_kth_merge(self,nd,k):
res=self.ide_ele
id=nd
if k==-1:
return res
while True:
if not id%2:
gap=((id)&(-id))//2
l=id-gap
r=id+gap
cnt=self.cnt(l)
if cnt<k:
k-=cnt+1
res=self.merge_func(res,self.val[id-1],self.merge[l-1])
id=r
elif cnt==k:
res=self.merge_func(res,self.val[id-1],self.merge[l-1])
return res
else:
id=l
else:
res=self.merge_func(res,self.val[id-1])
return res
def upper_kth_merge(self,nd,k):
res=self.ide_ele
id=nd
if k==-1:
return res
while True:
if not id%2:
gap=((id)&(-id))//2
l=id-gap
r=id+gap
cnt=self.cnt(r)
if cnt<k:
k-=cnt+1
res=self.merge_func(res,self.val[id-1],self.merge[r-1])
id=l
elif cnt==k:
res=self.merge_func(res,self.val[id-1],self.merge[r-1])
return res
else:
id=r
else:
res=self.merge_func(res,self.val[id-1])
return res
def query(self,l,r):
id=1<<(self.n-1)
while True:
if id-1<l:
id+=((id)&(-id))//2
elif id-1>r:
id-=((id)&(-id))//2
else:
res=self.val[id-1]
if id%2:
return res
gap=((id)&(-id))//2
L,R=id-gap,id+gap
#print(l,r,id,L,R)
left=self.upper_kth_merge(L,id-1-l-1)
right=self.lower_kth_merge(R,r-id)
return self.merge_func(res,left,right)
ide_ele=0
def seg_func(*args):
res=ide_ele
for val in args:
res|=val
return res
def popcount(x):
x = x - ((x >> 1) & 0x55555555)
x = (x & 0x33333333) + ((x >> 2) & 0x33333333)
x = (x + (x >> 4)) & 0x0f0f0f0f
x = x + (x >> 8)
x = x + (x >> 16)
return x & 0x0000007f
import sys
input=sys.stdin.readline
N=int(input())
S=input().rstrip()
init_val=[1<<(ord(S[i])-97) for i in range(N)]
test=SegmentTree(19,ide_ele,seg_func,init_val)
for _ in range(int(input())):
t,l,r=input().split()
t,l=int(t),int(l)
if t==1:
val=ord(r)-97
test.update(l-1,1<<val)
else:
r=int(r)
res=test.query(l-1,r-1)
print(popcount(res))
|
import sys
input = lambda: sys.stdin.readline().rstrip()
class SegTree:
def __init__(self, init_val, segfunc, ide_ele):
n = len(init_val)
self.ide_ele = ide_ele
self.segfunc = segfunc
self.num = 2**(n - 1).bit_length()
self.seg = [self.ide_ele] * 2 * self.num
for i in range(n):
self.seg[i + self.num - 1] = init_val[i]
for i in range(self.num - 2, -1, -1):
self.seg[i] = self.segfunc(self.seg[2 * i + 1], self.seg[2 * i + 2])
def update(self, k, x):
k += self.num - 1
self.seg[k] = x
while k:
k = (k - 1) // 2
self.seg[k] = self.segfunc(self.seg[k * 2 + 1], self.seg[k * 2 + 2])
def query(self, p, q):
if q <= p:
return self.ide_ele
p += self.num - 1
q += self.num - 2
res = self.ide_ele
while q - p > 1:
if p & 1 == 0:
res = self.segfunc(res, self.seg[p])
if q & 1 == 1:
res = self.segfunc(res, self.seg[q])
q -= 1
p = p // 2
q = (q - 1) // 2
if p == q:
res = self.segfunc(res, self.seg[p])
else:
res = self.segfunc(self.segfunc(res, self.seg[p]), self.seg[q])
return res
def solve():
N = int(input())
S = list(input())
Q = int(input())
seg = [1 << (ord(s) - ord('a')) for s in S]
segtree = []
segfunc = lambda a, b: a | b
segtree = SegTree(seg, segfunc, 0)
ans = []
for i in range(Q):
a, b, c = input().split()
a = int(a)
if a == 1:
b = int(b) - 1
al = ord(c) - ord('a')
segtree.update(b, 1 << al)
elif a == 2:
b, c = int(b) - 1, int(c)
res = segtree.query(b, c)
res = sum(list(map(int, bin(res)[2:])))
ans.append(res)
print('\n'.join(map(str, ans)))
if __name__ == '__main__':
solve()
| 1 | 62,532,597,614,480 | null | 210 | 210 |
n = int(input())
ans = (n+2-1)//2
print(ans)
|
n = int(input())
abc="abcdefghijklmnopqrstuvwxyz"
ans = ""
while True:
n -= 1
m = n % 26
ans += abc[m]
n = n // 26
if n == 0:
break
print(ans[::-1])
| 0 | null | 35,453,564,840,050 | 206 | 121 |
import math
class coordinate:
def __init__(self, x, y):
self.x = x
self.y = y
def koch(n, p1, p2):
if n == 0:
return str(p2.x) + " " + str(p2.y)
else:
s = coordinate((2*p1.x + p2.x)/3, (2*p1.y + p2.y)/3)
t = coordinate((p1.x + 2*p2.x)/3, (p1.y + 2*p2.y)/3)
u = coordinate((t.x-s.x)/2-(t.y-s.y)/2*math.sqrt(3)+s.x, (t.x-s.x)/2*math.sqrt(3)+(t.y-s.y)/2+s.y)
print(koch(n-1, p1, s))
print(koch(n-1, s, u))
print(koch(n-1, u, t))
return(koch(n-1, t, p2))
q1 = coordinate(0.00000000, 0.00000000)
q2 = coordinate(100.00000000, 0.00000000)
print(str(q1.x) + " " + str(q1.y))
print(koch(int(input()), q1, q2))
|
n,m = map(int,input().split())
if(n % 2 == 0):
d = n // 2 - 1
c = 0
i = 1
while(d > 0):
print(i,i+d)
d -= 2
i += 1
c += 1
if(c == m):exit()
d = n // 2 - 2
i = n // 2 + 1
while(d > 0):
print(i,i+d)
d -= 2
i += 1
c += 1
if(c == m):exit()
else:
for i in range(m):
print(i+1,n-i)
| 0 | null | 14,422,009,347,680 | 27 | 162 |
# coding: utf-8
import sys
def gcd(a, b):
m = a % b
if m == 0:
return b
return gcd(b, m)
for l in sys.stdin:
x, y = map(int, l.split())
g = gcd(x, y)
l = x * y / g
print g, l
|
while True:
try:
a, b = map(int, input().split(" "))
if a < b:
key = a
a = b
b = key
A = a
B = b
while a % b != 0:
key = a % b
a = b
b = key
key = int(A * B / b)
print(b, key)
except:
break
| 1 | 527,897,018 | null | 5 | 5 |
import bisect
n, m = map(int, input().split())
a = list(map(int, input().split()))
a.sort()
a_cum = [0 for _ in range(n+1)]
for i in range(n):
a_cum[i+1] = a_cum[i] + a[i]
l, r = 0, 10 ** 6
while r - l > 1:
x = (l + r) // 2
cnt = 0
for i in range(n):
idx = bisect.bisect_left(a, x-a[i])
cnt += n - idx
if cnt >= m:
l = x
else:
r = x
ans = 0
cnt = 0
for i in range(n):
idx = bisect.bisect_left(a, l-a[i])
cnt += n - idx
ans += a_cum[n] - a_cum[idx]
ans += a[i] * (n - idx)
if cnt > m:
ans -= l * (cnt - m)
print(ans)
|
n = int(input())
a = list(map(int,input().split()))
b = [0]*n
for i in range(n-1):
if(a[i] < a[i+1]):
#if(b[i-1] < 1):
b[i] = 1
#else:
# b[i] = 2
if(a[i] > a[i+1]):
#if(b[i-1] > -1):
b[i] = -1
#else:
# b[i] = -2
#else:
#if(b[i-1] > 0):
# b[i] = 2
# else:
# b[i] = -2
b[-1] = -1
#print(b)
h = [1000,0]
for i in range(n):
if(b[i] == 1):
h[1] += h[0]//a[i]
h[0] %= a[i]
elif(b[i] == -1):
h[0] += h[1]*a[i]
h[1] *= 0
#print(h)
print(h[0])
| 0 | null | 57,876,194,580,512 | 252 | 103 |
n,m,k=[int(i) for i in input().split()]
a=[int(i) for i in input().split()]
b=[int(i) for i in input().split()]
def make_sumlist(book_list):
sumnum=0
container=[0]
for i in book_list:
container.append(sumnum+i)
sumnum+=i
return container
total_a=make_sumlist(a)
total_b=make_sumlist(b)
# print(n,m,k)
# print(total_a)
# print(total_b)
#r個読めるか
def readable(r):
#全部読んでも無理
if r>n+m:
return False
if r==0:
return True
max_book=100000000000
for a_n in range(max(0,r-m),min(n,r)+1):
b_n=r-a_n
# print(a_n,b_n)
book_sum=total_a[a_n]+total_b[b_n]
# print(book_sum)
max_book=min(max_book,book_sum)
if max_book<=k:
return True
return False
def nibuntansaku(start,end):
if start==end:
return start
middle=(start+end)//2+1
if readable(middle):
start=middle
else:
end=middle-1
return nibuntansaku(start,end)
print(nibuntansaku(0,k))
|
n = int(input())
"""
6:3
3141:13
314159265358:9
"""
#約分
def make_divisors(n):
divisors = []
for i in range(1, int(n**0.5)+1):
if n % i == 0:
divisors.append(i)
if i != n // i:
divisors.append(n//i)
# divisors.sort()
return divisors
r = len(make_divisors(n-1)) - 1
w = make_divisors(n)
for wi in w:
if wi == 1:
continue
i = 1
while n % (wi**i) == 0:
i += 1
if (n / (wi**(i-1))) % wi == 1:
r += 1
print(r)
| 0 | null | 26,190,053,277,568 | 117 | 183 |
def check_weather(weathers: str) -> int:
count = weathers.count('R')
return 1 if weathers[1] == 'S' and count == 2 else count
if __name__=='__main__':
print(check_weather(input()))
|
h,a = [int(i) for i in input().split()]
cont=0
while h > 0:
h-=a
cont+=1
print(cont)
| 0 | null | 40,801,461,914,932 | 90 | 225 |
### ----------------
### ここから
### ----------------
import sys
from io import StringIO
import unittest
def yn(b):
print("Yes" if b==1 else "No")
return
def resolve():
readline=sys.stdin.readline
n,x,y=map(int, readline().rstrip().split())
ans = [0] * (n-1)
for i in range(1,n+1):
for j in range(i+1,n+1):
d1 = abs(i-x) + abs(j-y) + 1
d2 = abs(i-y) + abs(j-x) + 1
d3 = abs(i-j)
d=min(d1,d2,d3)
ans[d-1]+=1
for a in ans:
print(a)
return
if 'doTest' not in globals():
resolve()
sys.exit()
### ----------------
### ここまで
### ----------------
|
N,X,Y=map(int,input().split())
d=[0]*N
for i in range(N):
for j in range(N):
if not i<j:
continue
dist=min([j-i,abs((X-1)-i)+1+abs(j-(Y-1))])
d[dist]+=1
print(*d[1:],sep='\n')
| 1 | 44,293,402,602,040 | null | 187 | 187 |
# coding: utf-8
def areas_calc(strings):
stack1 = []
stack2 = []
total_m = 0
for i, s in enumerate(strings):
if s == "\\":
stack1.append(i)
elif s == "_":
continue
elif s == '/':
if len(stack1) > 0:
previous_i = stack1.pop()
m = i - previous_i
total_m += m
while len(stack2) > 0:
stacked_i, stacked_m = stack2.pop()
if previous_i < stacked_i:
m += stacked_m
else:
stack2.append((stacked_i, stacked_m))
stack2.append((previous_i, m))
break
else:
stack2.append((previous_i, m))
print(total_m)
k = len(stack2)
for_output = [str(k)] + [str(m) for i, m in stack2]
print(' '.join(for_output))
if __name__ == "__main__":
areas_calc(input())
|
import sys
from collections import deque,defaultdict
I=sys.stdin.readline
def ii():
return int(I().strip())
def li():
return list(map(int,I().strip().split()))
def mi():
return map(int,I().strip().split())
def main():
n=ii()
arr=li()
p=1000
for i in range(n-1):
if arr[i]==arr[i+1]:
pass
elif arr[i]<arr[i+1]:
buy=p//arr[i]
p+=(arr[i+1]-arr[i])*buy
print(p)
if __name__ == '__main__':
main()
| 0 | null | 3,715,634,284,100 | 21 | 103 |
s, t = input().split()
d = {}
d[s] , d[t] = map(int, input().split())
d[input()]-=1
for i in d.values(): print(i, end = ' ')
|
import sys
from collections import Counter
N = int(sys.stdin.readline().rstrip())
D = list(map(int, sys.stdin.readline().rstrip().split()))
mod = 998244353
if D[0] != 0 or 0 in D[1:]:
print(0)
exit()
d_cnt = sorted(Counter(D).items())
ans = 1
par = 1
prev = 0
for k, v in d_cnt:
if k > 0:
if prev + 1 == k:
ans *= pow(par, v, mod)
ans %= mod
par = v
prev = k
else:
print(0)
exit()
print(ans)
| 0 | null | 113,710,496,058,542 | 220 | 284 |
n=int(input())
s=[]
t=[]
for i in range(9):
s.append([])
for i in range(100):
t.append([[],[]])
for i in range(1,n+1):
a=str(i)
b=max(int(a[0]),int(a[len(a)-1]))
c=min(int(a[0]),int(a[len(a)-1]))
if b!=0 and c!=0:
if b==c:
s[b-1].append(i)
elif int(a[0])<int(a[len(a)-1]):
t[b*9+c][0].append(i)
else:
t[b*9+c][1].append(i)
ans=0
for i in range(9):
x=len(s[i])
ans+=x**2
for i in range(100):
x=len(t[i][0])
y=len(t[i][1])
ans+=2*x*y
print(ans)
|
MOD=10**9+7
def powmod(a,n,m): #a^n mod m
ans=1
while n!=0:
if n&1: ans=ans*a%m
a=a*a%m
n>>=1
return ans%m
def fact(a,b):
ans=1
for i in range(a,b+1): ans=ans*i%MOD
return ans
n,a,b=map(int,input().split())
ans=powmod(2,n,MOD)-1
ta1=fact(n-a+1,n)
tb1=fact(n-b+1,n)
ta2=pow(fact(1,a),MOD-2,MOD)
tb2=pow(fact(1,b),MOD-2,MOD)
a=ta1*ta2%MOD
b=tb1*tb2%MOD
print((ans-a-b)%MOD)
| 0 | null | 76,255,108,135,910 | 234 | 214 |
n = input()
taro = 0
hanako = 0
for i in xrange(n):
t_card, h_card = raw_input().split(" ")
if t_card < h_card:
hanako += 3
elif t_card > h_card:
taro += 3
elif t_card == h_card:
taro += 1
hanako += 1
print taro, hanako
|
# -*- coding: utf-8 -*-
"""
Created on Mon Sep 7 15:49:02 2020
@author: liang
"""
N, X, Y = map(int, input().split())
ans = [0]*(N-1)
for i in range(1,N+1):
for j in range(i+1, N+1):
#print(i,j)
res = min(abs(i-j), abs(X-i) + 1 + abs(Y-j))
#print(i, j, res)
ans[res-1] += 1
for i in ans:
print(i)
| 0 | null | 23,119,463,280,638 | 67 | 187 |
input()
x=list(map(int,input().split()))
r=10**10
for i in range(min(x),max(x)+1):
s=0
for j in x:
s+=(i-j)**2
r=min(r,s)
print(r)
|
class Queue():
def __init__(self):
self.el = []
def add(self, el):
self.el.append(el)
def delete(self):
return self.el.pop(0)
def action(self):
self.el[0]['time'] -= q
tmp = self.delete()
self.el.append(tmp)
n, q = map(int, raw_input().split())
qu = Queue()
for i in range(n):
name, time = raw_input().split()
time = int(time)
qu.add({'name':name, 'time':time})
time = 0
while qu.el:
#print qu.el
if qu.el[0]['time'] > q:
qu.action()
time += q
else:
time += qu.el[0]['time']
print qu.el[0]['name'], time
qu.delete()
| 0 | null | 32,797,123,389,960 | 213 | 19 |
N=int(input())
A=list(map(int,input().split()))
S=A[0]
B=[0 for i in range(N)]
for i in range(1,N):
S=S^A[i]
for i in range(N):
B[i]=S^A[i]
print(*B)
|
n,*a = map(int,open(0).read().split())
all = 0
for i in a:
all^=i
print(*[all^i for i in a])
| 1 | 12,559,841,097,478 | null | 123 | 123 |
x=list(map(int,input().split()))
print(sum([1,2,3,4,5])-sum(x))
|
def main():
n, m = list(map(int, input().split(" ")))
ans = 0
ans += n*(n-1)/2
ans += m*(m-1)/2
print(int(ans))
if __name__ == "__main__":
main()
| 0 | null | 29,583,577,894,718 | 126 | 189 |
from collections import deque
def main():
n = int(input())
adj = [[]for i in range(n+1)]
ab = [list(map(int, input().split())) for i in range(n-1)]
for a, b in ab:
adj[a].append(b)
adj[b].append(a)
# dequeを使ったスタックによるDFS
# 子をindexで、親ノードを要素で
# 今回は彩色のためにどんな順番でpopされたかも保持しておく
order = []
parent = [0] * (n+1)
visited = [0] * (n+1)
visited[1] = 1
q = deque([1])
while q:
par = q.popleft()
order.append(par)
for chl in adj[par]:
if visited[chl]:
continue
# 行ったことなかったら1へ
visited[chl] = 1
parent[chl] = par
q.append(chl)
# 彩色
# 親と同じにならないように若い番号を割り当てて行く
cl = [None] * (n+1)
for par in order:
# 親の色
pc = cl[par]
# 彩色は1以上k以下
color = 1
for chl in adj[par]:
# 隣接リストの親は無視
if chl == parent[par]:
continue
# 親の色と同じなら色を変える
if pc == color:
color += 1
# カラーリストに子indexにcolorを入れる
cl[chl] = color
# 他の子は色を変える必要がある
color += 1
# 木グラフなので単純に次数最大で考えて問題ない
g = max([len(i) for i in adj])
print(g)
for a, b in ab:
# 親子関係が逆転しない出力ならこれでいいがそうとも限らない
if parent[a] != b:
print(cl[b])
else:
print(cl[a])
if __name__ == '__main__':
main()
|
import queue
N = int(input())
tree = [[]for _ in range(N+1)]
for i in range(1,N):
a,b = map(int,input().split())
tree[a].append( [b,i])
tree[b].append([a,i])
que = queue.Queue()
node = [-1]*(N+1)
edge = [-1]*N
que.put(1)
node[1] = 1
maxi = 1
start = 0
color = [[] for _ in range(N+1)]
node[1] = 0
while(True):
if que.empty():
break
before = start
start = que.get()
col =1
for i in tree[start]:
if node[i[0]] == -1 :
que.put(i[0])
if edge[i[1]] == -1:
if col == node[start]:
col += 1
edge[i[1]] = col
node[i[0]] = col
if col > maxi:
maxi = col
col +=1
print(maxi)
for i in edge[1:]:
print(i)
| 1 | 135,919,737,289,870 | null | 272 | 272 |
N=int(input())
ans=[]
for i in range(1,99):
if N>26**i:
N-=26**i
else:
N-=1
for l in range(i):
key=(chr(ord("a")+(N%26)))
N=int(N/26)
ans.append(key)
break
ans.reverse()
for i in range(len(ans)):
print(ans[i],end="")
|
N = int(input())
S = ""
while 0<N:
N-=1
S+=chr(97+N%26)
N//=26
print(S[::-1])
| 1 | 11,945,223,546,670 | null | 121 | 121 |
a,b =map(str, input().split())
print(str(b+a))
|
a=[int(input()) for i in range(10)]
a.sort()
a.reverse()
print(a[0])
print(a[1])
print(a[2])
| 0 | null | 51,661,736,605,438 | 248 | 2 |
n = int(input())
ret = 0
b = 1
while n > 0:
ret += b
n //= 2
b *= 2
print(ret)
|
H = int(input())
ans = 0
attack_cnt = 0
while H > 0:
ans += 2 ** attack_cnt
attack_cnt += 1
H //= 2
print(ans)
| 1 | 80,088,054,056,232 | null | 228 | 228 |
# import itertools
# import math
# import sys
# sys.setrecursionlimit(500*500)
# import numpy as np
# N = int(input())
# S = input()
# n, *a = map(int, open(0))
N, X, Y = map(int, input().split())
# A = list(map(int, input().split()))
# B = list(map(int, input().split()))
# tree = [[] for _ in range(N + 1)]
# B_C = [list(map(int,input().split())) for _ in range(M)]
# S = input()
# B_C = sorted(B_C, reverse=True, key=lambda x:x[1])
# all_cases = list(itertools.permutations(P))
# a = list(itertools.combinations_with_replacement(range(1, M + 1), N))
# itertools.product((0,1), repeat=n)
# A = np.array(A)
# cum_A = np.cumsum(A)
# cum_A = np.insert(cum_A, 0, 0)
# def dfs(tree, s):
# for l in tree[s]:
# if depth[l[0]] == -1:
# depth[l[0]] = depth[s] + l[1]
# dfs(tree, l[0])
# dfs(tree, 1)
# def factorization(n):
# arr = []
# temp = n
# for i in range(2, int(-(-n**0.5//1))+1):
# if temp%i==0:
# cnt=0
# while temp%i==0:
# cnt+=1
# temp //= i
# arr.append([i, cnt])
# if temp!=1:
# arr.append([temp, 1])
# if arr==[]:
# arr.append([n, 1])
# return arr
cnt = [0] * N
for i in range(1, N + 1):
for j in range(i + 1, N + 1):
k = min([j - i, abs(X - i) + abs(Y - j) + 1, abs(Y - i) + abs(X - j) + 1])
cnt[k] += 1
for i in range(1, N):
print(cnt[i])
|
#!/usr/bin/env python3
import sys
from itertools import chain
def gcd(a, b):
"""最大公約数
"""
while b:
a, b = b, a % b
return a
def lcm(a, b):
"""最小公倍数
"""
return a * b // gcd(a, b)
def solve(A: int, B: int):
answer = lcm(A, B)
return answer
def main():
A, B = map(int, input().split())
answer = solve(A, B)
print(answer)
if __name__ == "__main__":
main()
| 0 | null | 78,879,620,907,360 | 187 | 256 |
MOD = 10 ** 9 + 7
N, K = map(int, input().split())
d = [0] * (K + 1)
for i in range(1, K + 1):
d[i] = pow(K // i, N, MOD)
for i in reversed(range(1, K + 1)):
for j in range(2 * i, K + 1, i):
d[i] -= d[j]
d[i] %= MOD
ans = 0
for i in range(1, K + 1):
ans += d[i] * i
ans %= MOD
print(ans)
|
import numpy as np
import itertools
N = int(input())
info = []
for i in range(N):
A = int(input())
for _ in range(A):
x,y = map(int,input().split())
info.append((i,x-1,y))
A = np.array(list(itertools.product([0,1],repeat=N)),np.bool)
for i,x,y in info:
bl = (~A[:,i]) | (A[:,x] == bool(y))
A = A[bl]
answer = A.sum(axis = 1).max()
print(answer)
| 0 | null | 78,960,799,702,500 | 176 | 262 |
# DPL_1_A - コイン問題
import sys
N, M = map(int, sys.stdin.readline().strip().split()) # N払う コイン種類M 枚
c = list(map(int, sys.stdin.readline().strip().split()))
# dp 初期化
dp = [[float('inf')] * (N + 1) for _ in range(M + 1)]
for i in range(len(dp)):
dp[i][0] = 0
for m in range(M):
for n in range(N + 1):
dp[m + 1][n] = min(dp[m + 1][n], dp[m][n])
next_n = n + c[m]
if next_n <= N:
dp[m + 1][next_n] = min(dp[m + 1][n] + 1, dp[m][next_n])
# for i in range(len(dp)):
# print(dp[i])
print(dp[-1][-1])
|
s = input()
ans = s
if s[-1] == "s":
ans += "e"
print(ans+"s")
| 0 | null | 1,268,564,598,422 | 28 | 71 |
N = int(input())
ans = [0]*10050
for i in range(N+1):
ans.append(0)
for x in range(1,105):
for y in range(1,105):
for z in range(1,105):
tmp = x**2 + y**2 + z**2 + x*y + y*z + z*x
if tmp < 10050:
ans[tmp] += 1
for i in range(N):
print(ans[i+1])
|
S = input()
T = input()
count = 0
for i in range(len(S)):
if S[i] != T[i]:
count += 1
else:
pass
print(count)
| 0 | null | 9,172,740,422,350 | 106 | 116 |
while True:
a, b = map(int, input().split())
if a == 0 and b == 0:
break;
for i in range(0, a):
if i % 2 == 0:
print(("#." * int((b + 1) / 2))[:b])
else:
print((".#" * int((b + 1) / 2))[:b])
print("")
|
N=int(input())
ans=[0]*(N+1)
for x in range(1,101):
for y in range(1,101):
for z in range(1,101):
fn=x**2+y**2+z**2+x*y+y*z+z*x
if fn>N:
break
else:
ans[fn]=ans[fn]+1
for n in range(1,N+1):
print(ans[n])
| 0 | null | 4,388,110,634,348 | 51 | 106 |
T = [int(t) for t in input().split()]
A = [int(t) for t in input().split()]
B = [int(t) for t in input().split()]
d1 = T[0]*(A[0]-B[0])
d2 = d1 + T[1]*(A[1]-B[1])
if d2 == 0:
ans = "infinity"
elif d1 > 0 and d2 > 0:
ans = 0
elif d1 < 0 and d2 < 0:
ans = 0
else:
d1 = abs(d1)
d2 = abs(d2)
ans = d1 // d2 * 2
if d1%d2 != 0:
ans += 1
print(ans)
|
def solve(n):
return (n+1)//2
n = int(input())
print(solve(n))
| 0 | null | 95,327,669,057,248 | 269 | 206 |
from itertools import permutations
n=int(input())
p=tuple(map(int,input().split()))
q=tuple(map(int,input().split()))
P=sorted(list(permutations(range(1,n+1),n)))
print(abs(P.index(p)-P.index(q)))
|
X = int(input())
# dp[i]:= ちょうどi円となる買い物が存在するorしない
dp = [0] * (X+1)
dp[0] = 1
for i in range(X):
if dp[i] == 1:
for next in [100,101,102,103,104,105]:
if i+next<=X:
dp[i+next] = 1
print(dp[X])
| 0 | null | 113,508,429,387,848 | 246 | 266 |
def main():
N = int(input())
count = 0
for a in range(N) :
a += 1
for b in range(N):
b += 1
c = N - a * b
if c <= 0 :
break
else :
count += 1
print(count)
if __name__ == '__main__':
main()
|
#!/usr/bin/env python3
import sys
import numpy as np
import numba
from numba import njit, b1, i4, i8, f8
input = sys.stdin.readline
def I():
return int(input())
@njit((i8,), cache=True)
def main(n):
table = np.zeros(n, np.int64)
for i in range(1, n):
table[::i] += 1
ans = 0
for n in table[1:]:
q, r = divmod(n, 2)
ans += q * 2 + 1 * r
return ans
N = I()
print(int(main(N)))
| 1 | 2,590,487,866,668 | null | 73 | 73 |
n=int(input())
a=0
b=0
while n!=0:
n=n//2
a+=2**b
b+=1
print(a)
|
import itertools
n=int(input())
p=[int(i) for i in input().split()]
q=[int(i) for i in input().split()]
t=[int(i) for i in range(1,n+1)]
a=b=0
for i,j in enumerate(list(itertools.permutations(t,n))):
w=[1,1]
for x,y in enumerate(j):
if p[x]!=y: w[0]=0
if q[x]!=y: w[1]=0
if w[0]: a=i
if w[1]: b=i
print(abs(a-b))
| 0 | null | 90,143,045,492,950 | 228 | 246 |
h=int(input())
res=1
ans=0
while h>1:
h=int(h/2)
ans+=res
res*=2
print(ans+res)
|
H = int(input())
i = len(bin(H))-2
print(2**i-1)
| 1 | 80,080,631,830,238 | null | 228 | 228 |
class Comb():
def __init__(self, n, p):
# O(n)
fct, inv = [1, 1], [1, 1]
a, b = 1, 1
for i in range(2, n + 1):
a = (a * i) % p
b = (b * pow(i, p - 2, p)) % p
fct.append(a)
inv.append(b)
self.fct = fct
self.inv = inv
self.n = n
self.p = p
def calc(self, n, r):
fct, inv = self.fct, self.inv
if (r < 0 or n < r):
return 0
else:
return fct[n] * inv[r] * inv[n - r] % p
N, K = map(int, input().split())
A = list(map(int, input().split()))
A.sort()
B = A[::-1]
p = 10 ** 9 + 7
cmb = Comb(N, p)
ans = 0
for n in range(N - K + 1):
c = cmb.calc(N - n - 1, K-1)
ans -= A[n] * c % p
ans += B[n] * c % p
print(ans % p)
|
def power(a,n):
x=1
L=list(format(n,'b'))
l=len(L)
for i in range(l):
if int(L[l-i-1])==1:
x=(x*a)%(10**9+7)
a=(a*a)%(10**9+7)
return x
N,K=map(int,input().split())
A=list(map(int,input().split()))
b=sorted(A)
c=sorted(A,reverse=True)
D=[]
M=0
x=1
y=1
for l in range(K-1):
x=(x*(N-l-1))%(10**9+7)
y=(y*(l+1))%(10**9+7)
y=power(y,10**9+5)
M+=(x*y*(c[0]-b[0]))%(10**9+7)
for i in range(1,N-K+1):
y1=power(N-i,10**9+5)
x=(x*y1)%(10**9+7)
x=(x*(N-K-i+1))%(10**9+7)
m=(x*y*(c[i]-b[i]))
if m>0:
m=m%(10**9+7)
M+=m
M%(10**9+7)
print(M%(10**9+7))
| 1 | 95,965,212,939,572 | null | 242 | 242 |
h, w, n = map(int, [input() for _ in range(3)])
print((n-1)//max(h, w)+1)
|
import sys
H = int(sys.stdin.readline())
W = int(sys.stdin.readline())
N = int(sys.stdin.readline())
print((N - 1) // max(H, W) + 1)
| 1 | 89,171,966,269,540 | null | 236 | 236 |
N, K = map(int, input().split())
A = list(map(int, input().split()))
F = list(map(int, input().split()))
A.sort()
F.sort(reverse=True)
ub = 10 ** 12 + 10
lb = 0
while ub - lb > 1:
mid = (ub + lb) // 2
cnt = 0
for x, y in zip(A, F):
res = max(0, x * y - mid)
cnt += -(-res // y)
if cnt <= K:
ub = mid
else:
lb = mid
if sum(A) <= K:
print(0)
else:
print(ub)
|
import fileinput
if __name__ == '__main__':
for line in fileinput.input():
tokens = line.strip().split()
a, b = int(tokens[0]), int(tokens[1])
c = a+b
print(len(str(c)))
| 0 | null | 82,233,480,129,272 | 290 | 3 |
import sys
sys.setrecursionlimit(10 ** 7)
f_inf = float('inf')
mod = 10 ** 9 + 7
def resolve():
n = int(input())
res = 0
for i in range(1, (n + 1) // 2):
if i != n - i:
res += 1
print(res)
if __name__ == '__main__':
resolve()
|
from math import ceil
n = int(input())
print(ceil(n/2) - 1)
| 1 | 153,466,463,732,156 | null | 283 | 283 |
S=input()
S == "ABC" or "ARC"
if S == "ABC":
print("ARC")
else:
print("ABC")
|
List=list(input())
if List[2]==List[3] and List[4]==List[5]:
print("Yes")
else:print("No")
| 0 | null | 33,025,856,267,040 | 153 | 184 |
class Dice:
def __init__(self, labels):
self._top = labels[0]
self._front = labels[1]
self._right = labels[2]
self._left = labels[3]
self._back = labels[4]
self._bottom = labels[5]
def top(self):
return self._top
def front(self):
return self._front
def right(self):
return self._right
def left(self):
return self._left
def back(self):
return self._back
def bottom(self):
return self._bottom
def role(self, directions):
for d in directions:
self._role1(d)
def _role1(self, d):
if d == "N":
self._top, self._front, self._bottom, self._back = \
self._front, self._bottom, self._back, self._top
elif d == "E":
self._top, self._left, self._bottom, self._right = \
self._left, self._bottom, self._right, self._top
elif d == "S":
self._top, self._back, self._bottom, self._front = \
self._back, self._bottom, self._front, self._top
else:
self._top, self._right, self._bottom, self._left = \
self._right, self._bottom, self._left, self._top
xs = list(map(int, input().split()))
directions = input()
dice = Dice(xs)
dice.role(directions)
print(dice.top())
|
import math
def abc173a_payment():
n = int(input())
print(math.ceil(n/1000)*1000 - n)
abc173a_payment()
| 0 | null | 4,388,159,936,508 | 33 | 108 |
N = int(input())
a = list(map(int, input().split()))
ans = 0
i = 1
for num in a:
if num != i:
ans += 1
else:
i += 1
print(ans if ans < len(a) else -1)
|
n=int(input())
lst={}
for i in range(n):
lst[input()]=1
print(len(lst))
| 0 | null | 72,425,928,987,700 | 257 | 165 |
n, m = map(int, input().split())
a = list(map(int, input().split()))
def cumsum(s):
n = len(s)
cs = [0] * (n+1)
for i in range(n):
cs[i+1] = cs[i] + s[i]
return cs
def bs_list(a, f):
l, r = -1, len(a)
while r - l > 1:
x = (l + r) // 2
if f(a[x]): r = x
else: l = x
return None if r == len(a) else r
a.sort()
ca = cumsum(a)
def detect(x):
num = 0
for b in a[::-1]:
res = bs_list(a, lambda y: y >= x - b)
if res is None: break
num += n - res
return num <= m
l, r = -1, 10**5*2+10
while r - l > 1:
x = (l+r) // 2
if detect(x): r = x
else: l = x
s, c = 0, 0
for b in a[::-1]:
res = bs_list(a, lambda x: x >= r - b)
if res is None: break
c += (n - res)
s += b * (n - res) + (ca[n] - ca[res])
print(s + (m - c) * l)
|
N = int(input())
S = input()
ans = 0
for x in range(10):
for y in range(10):
for z in range(10):
for i in range(N):
if x != int(S[i]):
continue
for j in range(i+1, N):
if y != int(S[j]):
continue
for k in range(j+1, N):
if z != int(S[k]):
continue
ans += z == int(S[k])
break
break
break
print(ans)
| 0 | null | 118,749,238,350,818 | 252 | 267 |
a, b, c = map(int, input().split())
DivisorCount = 0
DivideNum = a
for var in range(a, b+1):
if c % DivideNum == 0:
DivisorCount += 1
DivideNum += 1
print(DivisorCount)
|
k=map(int, raw_input().split())
a=k[0]
b=k[1]
c=k[2]
count=0
for i in range(a,b+1):
if c%i==0:
count=count+1
print count
| 1 | 543,566,770,940 | null | 44 | 44 |
def f():return map(int,raw_input().split())
n,m = f()
A = [f() for _ in [0]*n]
B = [input() for _ in [0]*m]
for i in range(n):
print sum([A[i][j]*B[j] for j in range(m)])
|
l = input().split()
n = int(l[0])
m = int(l[1])
a = []
for i in range(n):
a.append(list(map(int, input().split())))
b = []
for i in range(m):
b.append(int(input()))
c = [[] for i in range(n)]
for i in range(n):
for j in range(m):
c[i].append(a[i][j] * b[j])
print(sum(c[i]))
| 1 | 1,166,264,640,310 | null | 56 | 56 |
import collections
import itertools
N = int(input())
A = list(map(int, input().split()))
ac = collections.Counter(A)
dp = [0] * (N+1)
dp2 = [0] * (N+1)
total = 0
for no, num in ac.items():
dp[no] = int(num*(num-1)/2)
dp2[no] = dp[no] - (num-1)
total += dp[no]
for k in range(1,N+1):
no = A[k-1]
print(int(total - dp[no] + dp2[no]))
|
from collections import Counter
N = int(input())
A = tuple(map(int, input().split(' ')))
counter = Counter(A)
patterns = 0
for value in counter.values():
if value >= 2:
patterns += value * (value - 1) // 2
for a in A:
ans = patterns
if counter[a] >= 2:
ans -= counter[a] * (counter[a] - 1) // 2
if counter[a] >= 3:
ans += (counter[a] - 1) * (counter[a] - 2) // 2
print(ans)
| 1 | 47,763,304,617,470 | null | 192 | 192 |
def resolve():
N,K = map(int,input().split())
A = list(map(int,input().split()))
F= list(map(int,input().split()))
A.sort()
F.sort(reverse = True)
AF = list(zip(A,F))
if sum(A)<=K:
print(0)
return
l = 0
r = max([i*j for i,j in AF])
center =0
while l < r-1:
center = (l+r)//2
score =sum([max(0,a-center//f) for a,f in AF])
if score > K:
l = center
else:
r = center
print(r)
if __name__ == "__main__":
resolve()
|
import sys
def solve():
input = sys.stdin.readline
N, K = map(int, input().split())
A = [int(a) for a in input().split()]
F = [int(f) for f in input().split()]
A.sort(reverse = True)
F.sort()
low, high = -1, 10 ** 13
while high - low > 1:
mid = (low + high) // 2
count = 0
for i in range(N):
counterF = mid // F[i]
if counterF < A[i]: count += A[i] - counterF
if count <= K: high = mid
else: low = mid
print(high)
return 0
if __name__ == "__main__":
solve()
| 1 | 164,973,079,197,992 | null | 290 | 290 |
def main():
n = int(input())
s = input()
ans = s.count('R') * s.count('G') * s.count('B')
for i in range(n-2):
for j in range(i+1, n-1):
if j - i > n - j - 1:
break
if s[i] != s[j] and s[j] != s[2*j-i] and s[2*j-i] != s[i]:
ans -= 1
print(ans)
if __name__ == '__main__':
main()
|
N = int(input())
S = input()
count = 0
RGBlist = [[S.count('R')],[S.count('G')],[S.count('B')]]
for i in range(1,N):
RGBlist[0].append(RGBlist[0][-1] - (S[i-1] == 'R'))
RGBlist[1].append(RGBlist[1][-1] - (S[i-1] == 'G'))
RGBlist[2].append(RGBlist[2][-1] - (S[i-1] == 'B'))
for i in range(N-2):
si = S[i]
for j in range(i+1,N-1):
sj = S[j]
if si==sj:
continue
else:
RGB = set(['R','G','B'])
RGB -= set([si,sj])
k=j+1
kji=j-i
if RGB == {'R'}:
rgb = 0
elif RGB =={'G'}:
rgb = 1
else:
rgb = 2
if k+kji-1 < len(S):
count += RGBlist[rgb][k] - ({S[k+kji-1]} == RGB)
else:
count += RGBlist[rgb][k]
print(count)
| 1 | 36,023,070,396,962 | null | 175 | 175 |
H,N=map(int,input().split())
A=sorted(list(map(int,input().split())))
for i in range(1,N+1):
H-=A[-i]
if H<=0:
print('Yes')
exit()
print('No')
|
# モンスターの体力H
# アライグマの必殺技の種類N
# i番目の必殺技使うと、モンスターの体力Ai減らせる
# H - (A1 + A2 + A3...) <= 0 となるなら 'Yes',
# ならないなら'No'が出力される
h, n = map(int, input().split())
damage = list(map(int, input().split()))
if h - sum(damage) <= 0:
print("Yes")
else:
print("No")
| 1 | 77,857,861,404,452 | null | 226 | 226 |
a,b=input().split()
a=int(a)
b=int(b)
if a%b==0:
print(int(a/b))
else:
print(int((a/b)+1))
|
n,k=map(int,input().split())
A=[0]+list(map(int,input().split()))
color=["white" for _ in range(n+1)]
DP,index=[],1
while 1:
if color[index]=="white":color[index]="gray"
elif color[index]=="gray":color[index]="black"
DP.append(A[index])
index=A[index]
if color[index]=="black":break
repeat=[]
for i in DP:
if color[i]=="black":
repeat.append(i)
if repeat[0]==i and len(repeat)!=1:
repeat.pop()
break
length=len(repeat)
cnt=0
for i in DP:
if repeat[0]==i:break
cnt +=1
if k<=cnt+length:
print(DP[k-1])
else:
k -=cnt
k %=length
print(repeat[k-1])
| 0 | null | 50,122,025,920,722 | 225 | 150 |
N = int(input())
s = input()
ans = min(s.count('R'), s.count('W'), s[N-s.count('W'):].count('R'))
print(ans)
|
N = int(input())
c = list(input())
#cを[R,R,R,.....,R,W,W,W,.....,W]の形にする。
div = c.count('R')
c_for = c[:div]
c_lat = c[div:]
ans = 0
replace = min(c_for.count('W'), c_lat.count('R'))
change = max(c_for.count('W'), c_lat.count('R')) - replace
ans = replace + change
#実質 ans = max(c_for.count('W'), c_lat.count('R')) やんけ！
print(ans)
| 1 | 6,311,292,538,460 | null | 98 | 98 |
S = input()
T = input()
count = []
for k in range(0,len(S)-len(T)+1):
sum = 0
for i in range(k,k+len(T)):
if (S[i] != T[i-k]):
sum += 1
count.append(sum)
print(min(count))
|
S = input()
T = input()
U = [0] * (len(S)-len(T)+1)
for j in range(len(S)-len(T)+1):
for i in range(len(T)):
if(S[i+j] != T[i]):
U[j] += 1
print(min(U))
| 1 | 3,695,064,059,852 | null | 82 | 82 |
def main():
a, b = map(int, input().split())
import math
print(int(a*b/math.gcd(a,b)))
if __name__ == "__main__":
main()
|
def main():
Counter = 0
Text_W = input()
while True:
Text_T = input()
if "END_OF_TEXT" in Text_T:
temp = Text_T.lower().split()
for i in range(len(temp)):
Counter += 1 if Text_W == temp[i] else 0
break
else:
temp = Text_T.lower().split()
for i in range(len(temp)):
Counter += 1 if Text_W == temp[i] else 0
print (Counter)
if __name__ == '__main__':
main()
| 0 | null | 57,443,006,145,222 | 256 | 65 |
n=int(input())
a=list(map(int,input().split()))
sum=[0]*(len(a)+1)
for i in range(len(a)):
sum[i+1]=sum[i]+a[i]
# print(sum)
mini=2020202020
for i in range(len(sum)):
mini=min(mini, abs(sum[i] - (sum[-1] - sum[i])))
print(mini)
|
n = int(input())
a = list(map(int, input().split()))
x = n//2
if sum(a)/2 == sum(a[:(n//2)]):
print(0)
elif sum(a)/2 >= sum(a[:(n//2)]):
while sum(a)/2 >= sum(a[:x]):
x += 1
print(min(abs(2*sum(a[:x])-sum(a)), abs(2*sum(a[:x-1])-sum(a))))
else:
while sum(a)/2 <= sum(a[:x]):
x -= 1
print(min(abs(2*sum(a[:x])-sum(a)), abs(2*sum(a[:x+1])-sum(a))))
| 1 | 141,659,021,045,750 | null | 276 | 276 |
A,B,N=map(int,input().split())
k = min(B-1,N)
print(int(A*k/B))
|
a,b,n=map(int,input().split())
if n<b:
c=(a*n)//b
print(c)
else:
c=(a*(b-1))//b
print(c)
| 1 | 28,225,941,358,528 | null | 161 | 161 |
s = input()
n = len(s)
cnt = 0
t =s[::-1]
for i in range(n//2):
if s[i]!=t[i]:
cnt += 1
print(cnt)
|
list_s = list(input())
count = 0
for i in range(0, len(list_s) // 2):
if list_s[i] == list_s[0 - (i + 1)]:
continue
else: count += 1
print(count)
| 1 | 120,228,695,207,878 | null | 261 | 261 |
def solve():
X = [int(i) for i in input().split()]
for i in range(len(X)):
if X[i] == 0:
print(i+1)
break
if __name__ == "__main__":
solve()
|
n,a,b = map(int, input().split())
if a%2==b%2:
print((b-a)//2)
exit()
print(min(a-1,n-b) +1+ (b-a-1)//2)
| 0 | null | 61,632,918,320,338 | 126 | 253 |
def mpow(a,b,m):
ans=1
while b >0 :
if b&1:
ans = (ans*a)%m
a=(a*a)%m
b=b>>1
return ans
def calcmod(X,m,N):
mod=0
X=X[::-1]
# print(X)
for i in range(N):
if X[i] == '1':
# if X & (1<<i) >0:
mod += mpow(2,i,m)
mod%=m
return mod
def popcount(m):
return bin(m).count("1")
def findsteps(mm):
cnt=0
while mm !=0:
cnt+=1
mm=mm%popcount(mm)
return cnt
N=int(input())
x=input()
X=int(x,2)
##we need to find X%(m-1) and X%(m+1)
m=popcount(X)
m1=m+1
m2=m-1
firstmod=calcmod(x,m1,N)
if m2 !=0:
secondmod=calcmod(x,m2,N)
fans=[0 for i in range(N)]
k=0
for i in range(N-1,-1,-1):
if X & (1<<i) >0:
##the bit was set
##we need to find X%(m-1) - (2^i)%(m-1)
if m2 == 0:
ans=0
else:
mm=secondmod - mpow(2,i,m2)
if mm < 0:
mm+=m2
mm=mm%m2
ans=1+findsteps(mm)
else:
mm = firstmod + mpow(2,i,m1)
mm=mm%m1
ans=1+findsteps(mm)
fans[k] = ans
k+=1
##the bit was not set
for i in fans:
print(i)
|
N = int(input())
X = input()
val = int(X,2)
C = X.count("1")
if C==1:
for i in range(N):
if X[i]=='1':
print(0)
elif i==N-1:
print(2)
else:
print(1)
exit()
# xをpopcountで割ったあまりに置き換える
def f(x):
if x==0: return 0
return 1 + f(x % bin(x).count("1"))
# 初回のpopcountでの割り方は、(C+1) or (C-1)
Y = val%(C+1)
if C-1 != 0:
Z = val%(C-1)
else:
Z = 0
for i in range(N):
if X[i] == "1":
if Z - 1 == 0:
print(0)
continue
k = (Z - pow(2,N-i-1,C-1)) % (C-1)
else:
k = (Y + pow(2,N-i-1,C+1)) % (C+1)
print(f(k)+1)
| 1 | 8,287,626,204,012 | null | 107 | 107 |
n = int(input())
ab=[list(map(int,input().split())) for i in range(n)]
import math
from collections import defaultdict
d = defaultdict(int)
zerozero=0
azero=0
bzero=0
for tmp in ab:
a,b=tmp
if a==0 and b==0:
zerozero+=1
continue
if a==0:
azero+=1
continue
if b==0:
bzero+=1
continue
absa=abs(a)
absb=abs(b)
gcd = math.gcd(absa,absb)
absa//=gcd
absb//=gcd
if a*b >0:
d[(absa,absb)]+=1
else:
d[(absa,-absb)]+=1
found = defaultdict(int)
d[(0,1)]=azero
d[(1,0)]=bzero
ans=1
mod=1000000007
for k in list(d.keys()):
num = d[k]
a,b=k
if b>0:
bad_ab = (b,-a)
else:
bad_ab = (-b,a)
if found[k]!=0:
continue
found[bad_ab] = 1
bm=d[bad_ab]
if bm == 0:
mul = pow(2,num,mod)
if k==bad_ab:
mul = num+1
else:
mul = pow(2,num,mod) + pow(2,bm,mod) -1
ans*=mul
ans+=zerozero
ans-=1
print(ans%mod)
|
data = raw_input()
while data.count('-1') < 3:
m,f,r = map(int,data.split(" "))
if m+f < 30 or m == -1 or f == -1:
print 'F'
elif m+f >=80:
print 'A'
elif m+f >= 65:
print 'B'
elif m+f >= 50 or (m+f >=30 and r>= 50):
print 'C'
elif m+f >= 30:
print 'D'
elif m+f <30:
print 'F'
data = raw_input()
| 0 | null | 11,070,666,270,048 | 146 | 57 |
import math
a, b, h, m = map(int, input().split())
minute = 60 * h + m
argA = minute / 720 * 2 * math.pi
argB = minute / 60 * 2 * math.pi
a_x = a * math.cos(argA)
a_y = a * math.sin(argA)
b_x = b * math.cos(argB)
b_y = b * math.sin(argB)
d = math.sqrt((a_x - b_x) ** 2 + (a_y - b_y) ** 2)
print(d)
|
def selection_Sort(A,N):
count = 0
for i in range(N):
minj = i
for j in range(i,N):
if A[j] < A[minj]:
minj = j
if i != minj:
A[i],A[minj] = A[minj],A[i]
count += 1
return (count)
if __name__ == '__main__':
n = int(input())
data = [int(i) for i in input().split()]
result = selection_Sort(data,n)
print(" ".join(map(str,data)))
print(result)
| 0 | null | 10,153,856,677,052 | 144 | 15 |
while True:
H, W = map(int, input().split())
if H == 0 and W == 0:
break
square = [['#'] * W] * H
for row in square:
print(''.join(row))
print()
|
mod = 10**9 + 7
n, a, b = map(int, input().split())
res = pow(2, n, mod)-1
c1 = 1
for i in range(n-a+1, n+1):
c1 *= i
c1 %= mod
for i in range(1, a+1):
c1 *= pow(i, mod-2, mod)
c1 %= mod
c2 = 1
for i in range(n-b+1, n+1):
c2 *= i
c2 %= mod
for i in range(1, b+1):
c2 *= pow(i, mod-2, mod)
c2 %= mod
res -= (c1+c2)
res %= mod
print(res)
| 0 | null | 33,681,077,920,648 | 49 | 214 |
H, W, K = map(int, input().split())
S = [list(map(int, input())) for _ in range(H)]
ans = 100000
for i in range(2**H):
cnt = 0
temp = i
group = [0]*H
for j in range(H):
group[j] = cnt
if temp & 1:
cnt += 1
temp >>= 1
div = [0]*H
for j in range(W):
for k in range(H):
if div[group[k]] + S[k][j] > K:
cnt += 1
div = [0]*H
for l in range(H):
div[group[l]] += S[l][j]
if div[group[l]] > K:
cnt = 100000
break
else:
div[group[k]] += S[k][j]
ans = min(ans, cnt)
print(ans)
|
import sys
import math
from collections import deque
sys.setrecursionlimit(1000000)
MOD = 10 ** 9 + 7
input = lambda: sys.stdin.readline().strip()
NI = lambda: int(input())
NMI = lambda: map(int, input().split())
NLI = lambda: list(NMI())
SI = lambda: input()
def make_grid(h, w, num): return [[int(num)] * w for _ in range(h)]
def main():
H, W, K = NMI()
choco = [SI() for _ in range(H)]
ans = 100000
for case in range(2**(H-1)):
groups = [[0]]
for i in range(H-1):
if (case >> i) & 1:
groups[-1].append(i+1)
else:
groups.append([i+1])
white = [0] * len(groups)
is_badcase = False
cut = len(groups) - 1
for w in range(W):
diff = [0] * len(groups)
for gi, group in enumerate(groups):
for h in group:
if choco[h][w] == "1":
white[gi] += 1
diff[gi] += 1
if max(white) <= K:
is_cont = True
continue
if max(diff) > K:
is_badcase = True
break
cut += 1
white = diff[:]
continue
if not is_badcase:
ans = min(ans, cut)
print(ans)
if __name__ == "__main__":
main()
| 1 | 48,513,878,074,520 | null | 193 | 193 |
while True :
H, W = map(int, raw_input().split(" "))
if (H == W == 0) :
break
ans = ""
for h in range(0, H) :
for w in range(0, W) :
if ((w + h) % 2 == 0) :
ans += "#"
else :
ans += "."
ans += "\n"
print("%s" % (ans))
|
n,m = (int(i) for i in input().split())
array = [[int(i) for i in input().split()] for i in range(n)]
b = [int(input()) for i in range(m)]
for i in range(n):
ans = 0
for i2 in range(m):
ans += array[i][i2]*b[i2]
print(ans)
| 0 | null | 1,021,568,871,650 | 51 | 56 |
def main():
N, K = map(int, input().split())
A = list(map(int, input().split()))
for k in range(K):
A_temp=[0]*(N+1)
for i in range(N):
A_temp[max(0,i-A[i])]+=1
if i+A[i]+1<=N-1:
A_temp[i+A[i]+1]-=1
A[0]=A_temp[0]
for j in range(1,N):
A_temp[j]+=A_temp[j-1]
A[j]=A_temp[j]
for ai in A:
if ai != N:
break
else:
break
print(' '.join([str(a) for a in A]))
if __name__ == "__main__":
main()
|
import math
from itertools import accumulate
n, k = map(int, input().split())
As = list(map(int, input().split()))
for i in range(min(41, k)):
_As = [0]*(n+1)
for j in range(n):
l = max(0, j - As[j])
r = min(n - 1, j + As[j])
_As[l] += 1
_As[r+1] -= 1
As = list(accumulate(_As))[:-1]
print(' '.join([str(A) for A in As]))
| 1 | 15,488,356,444,708 | null | 132 | 132 |
if __name__ == '__main__':
nums = [[[0 for r in range(10)] for f in range(3)] for b in range(4)]
n = int(input())
for i in range(n):
b, f, r, v = [int(i) for i in input().split()]
nums[b-1][f-1][r-1] += v
for b in range(4):
for f in range(3):
print(' ' + ' '.join([str(i) for i in nums[b][f]]))
if b == 3: break
print('#'*20)
|
a , b = (int(a) for a in input().split())
x = min(a,b)
t = max(a,b)
ans = [str(x)]*t
print("".join(ans))
| 0 | null | 42,747,086,686,942 | 55 | 232 |
while 1:
string = raw_input()
if string == "-":
break
l = len(string)
for i in xrange(int(input())):
h = int(input())
lower = string[0:h]
upper = string[h:l]
string = upper + lower
print string
|
def main():
while True:
cards = input();
if cards == '-':
break
n = int(input())
for _ in range(n):
s = int(input())
cards = (cards*2)[s:s+len(cards)]
print(cards)
if __name__ == '__main__':
main()
| 1 | 1,869,735,236,128 | null | 66 | 66 |
from collections import defaultdict
N = int(input())
A = list(map(int, input().split()))
B = sorted([(A[i], i + 1) for i in range(N)], reverse=True)
dp = defaultdict(int)
for S in range(1, N + 1):
for x in range(S + 1):
y = S - x
candid = []
if x >= 1:
candid.append(dp[(x - 1, y)] + B[S - 1][0]
* (B[S - 1][1] - x))
if y >= 1:
candid.append(dp[(x, y - 1)] + B[S - 1][0]
* ((N - y + 1) - B[S - 1][1]))
dp[(x, y)] = max(candid)
print(max([dp[(i, N - i)] for i in range(N + 1)]))
|
import sys
input = sys.stdin.readline
N = int(input())
A = list(map(int, input().split()))
iA = [(i, A[i]) for i in range(N)]
iA.sort(key=lambda t: t[1], reverse=True)
dp = [[0]*(N+1) for _ in range(N+1)]
for i in range(N):
for j in range(N):
if i+j<N:
idx, v = iA[i+j]
dp[i+1][j] = max(dp[i+1][j], dp[i][j]+v*abs(idx-i))
dp[i][j+1] = max(dp[i][j+1], dp[i][j]+v*abs(N-1-j-idx))
ans = 0
for i in range(N+1):
ans = max(ans, dp[i][N-i])
print(ans)
| 1 | 33,576,064,538,150 | null | 171 | 171 |
N = int(input())
Ali = list(map(int,input().split()))
s = 1
res = 0
for i in range(N):
if Ali[i] == s:
s += 1
else:
res += 1
if s == 1:
print(-1)
else:
print(res)
|
n = int(input())
s = input()
rinds, ginds, binds = [], [], set()
for i in range(n):
if s[i] == 'R': rinds.append(i)
elif s[i] == 'G': ginds.append(i)
else: binds.add(i)
rlen, glen, blen = len(rinds), len(ginds), len(binds)
ans = 0
for i in rinds:
for j in ginds:
dist = abs(i-j)
i_ = min(i, j)
j_ = max(i, j)
ans += blen
# i' < j' < k
if j_ + dist in binds:
ans -= 1
if dist%2==0 and i_ + dist//2 in binds:
ans -= 1
if i_ - dist in binds:
ans -= 1
# if binsearch_same(binds, blen, dist, j_):
# ans -= 1
# # i'< k < j'
# if dist%2==0 and binsearch_same(binds, blen, dist//2, i_):
# ans -= 1
# # # k < i' < j'
# if binsearch_same(binds, blen, -dist, i_):
# ans -= 1
print(ans)
# n = input()
# print('Yes' if '7' in n else 'No')
# n = int(input())
# ans = 0
# for i in range(1, n+1):
# if i%3 == 0 or i%5==0:
# pass
# else:
# ans += i
# print(ans)
# k = int(input())
# def gcd(a, b):
# if b == 0:
# return a
# return gcd(b, a%b)
# ans = 0
# for a in range(1, k+1):
# for b in range(1, k+1):
# for c in range(1, k+1):
# ans += gcd(gcd(a, b), c)
# print(ans)
| 0 | null | 75,364,228,612,668 | 257 | 175 |
import numpy
N = int(input())
A = list(map(int, input().split()))
res = numpy.cumsum(A)
if res[-1] % 2 == 0:
L = res[-1]//2
ans = [abs(r - L) for r in res]
print(2*min(ans))
else:
L1 = res[-1]//2
L2 = L1 + 1
ans = [min(abs(r - L1),abs(r-L2)) for r in res]
print(2*min(ans)+1)
|
n = int(input())
a = list(map(int, input().split())) # 横入力
x = [0]
aaa = 0
for i in range(n):
aaa += a[i]
x.append(aaa)
aa = sum(a)
y = [aa]
for i in range(n):
aa -= a[i]
y.append(aa)
ans = 202020202020
for i in range(n+1):
ans = min(ans, abs(x[i] - y[i]))
print(ans)
| 1 | 142,219,482,743,758 | null | 276 | 276 |
x = int(input())
num = (x//500)*1000
num += ((x%500)//5)*5
print(num)
|
def selection_sort(A, N):
count = 0
for i in range(N):
min_j = i
for j in range(i, N):
if A[j] < A[min_j]:
min_j = j
if i != min_j:
A[i], A[min_j] = A[min_j], A[i]
count += 1
print " ".join(map(str, A))
print count
N = input()
A = map(int, raw_input().split())
selection_sort(A, N)
| 0 | null | 21,472,437,695,592 | 185 | 15 |
x,y,a,b,c=map(int,input().split())
R=sorted(map(int,input().split()),reverse=True)
G=sorted(map(int,input().split()),reverse=True)
N=sorted(map(int,input().split()),reverse=True)
L=sorted(R[:x]+G[:y]+N[:(x+y)],reverse=True)
print(sum(L[:(x+y)]))
|
bit=[0]*9
fa=[1]*9
for n in range(1,9):fa[n]=fa[n-1]*n
def up(id):
while id<9:
bit[id]+=1
id+=id&(-id)
def qr(id):
res=0
while id:
res+=bit[id]
id-=id&(-id)
return res
x=int(input())
s=list(map(int,input().split()))
z=list(map(int,input().split()))
v=''
for n in s:
a=qr(n)
vl=n-1-a
v+=str(vl)
up(n)
v=v[::-1]
r1=0
for n in range(len(v)):
r1+=int(v[n])*fa[n]
r2=0
v=''
bit=[0]*9
for n in z:
a=qr(n)
vl=n-1-a
v+=str(vl)
up(n)
v=v[::-1]
for n in range(len(v)):
r2+=int(v[n])*fa[n]
print(abs(r1-r2))
| 0 | null | 72,993,827,481,890 | 188 | 246 |
N,K,C=list(map(int,input().split()))
S=input()
R=[]
L=[]
i=0
while i<N:
if S[i]=="o":
R.append(i)
i+=C+1
else:
i+=1
i=N-1
while i>=0:
if S[i]=="o":
L.append(i)
i-=(C+1)
else:
i-=1
R=R[:K+1]
L=L[:K+1]
L.reverse()
for i in range(K):
if R[i]==L[i]:
print(str(R[i]+1),end=" ")
|
n, k, c = map(int, input().split())
plan = list(input())
a = [0] * k
b = [0] * k
idx = 0
pause = c
for i in range(n):
pause += 1
if plan[i]=='x':
continue
if pause>c and idx<k:
a[idx] = i+1
idx += 1
pause = 0
idx = k-1
pause = c
for i in range(n-1, -1, -1):
pause += 1
if plan[i]=='x':
continue
if pause>c:
if idx>=0:
b[idx] = i+1
idx -= 1
pause = 0
#print(a)
#print(b)
for i in range(k):
if a[i]==b[i]:
print(a[i])
| 1 | 40,389,518,398,912 | null | 182 | 182 |
N, M, K = map(int,input().split())
MOD = 998244353
fac = [1 for i in range(N+1)]
for n in range(1,N+1):
fac[n] = (n*fac[n-1])%MOD
fac_inv = [1 for i in range(n+1)]
fac_inv[N] = pow(fac[N],MOD-2,MOD)
for n in range(N-1,-1,-1):
fac_inv[n] = (fac_inv[n+1]*(n+1))%MOD
def C(n,k):
global MOD
return (fac[n]*fac_inv[k]*fac_inv[n-k])%MOD
print(sum([C(N-1,b)*M*pow(M-1,N-1-b,MOD)%MOD for b in range(K+1)])%MOD)
|
import math
x, k, d = map(int, input().split())
x = abs(x)
straight = min(k, math.floor(x / d))
k -= straight
x -= straight * d
if(k % 2 == 0):
print(x)
else:
print(abs(x - d))
| 0 | null | 14,219,474,776,900 | 151 | 92 |
N = int(input())
L = list(map(int,input().split()))
cnt = 0
for n in range(N):
if (n + 1) % 2 == 1 and L[n] % 2 == 1:
cnt += 1
print(cnt)
|
n = int(input())
a = list(map(int,input().split()))
ans = 0
tmp = 1
for i in a:
if i == tmp:
tmp += 1
else:
ans += 1
print(ans if ans != n else -1)
| 0 | null | 60,969,994,071,840 | 105 | 257 |
n,m = map(int,input().split())
mat = list()
vec = list()
ans = [0 for _ in range(n)]
for _ in range(n):
mat.append(list(map(int,input().split())))
for _ in range(m):
vec.append(int(input()))
for i in range(n):
for j in range(m):
ans[i] += mat[i][j]*vec[j]
for k in ans :
print(k)
|
n, m = map(int, input().split())
a = []
for _ in range(n):
a.append(list(map(int, input().split())))
b = []
for _ in range(m):
b.append(int(input()))
c = []
for i in range(n):
c.append(sum([a[i][j] * b[j] for j in range(m)]))
for i in c:
print(i)
| 1 | 1,172,545,992,772 | null | 56 | 56 |
def solve(a, b):
if a % b == 0:
return b
else:
return solve(b, a % b)
while True:
try:
a, b = map(int, input().split())
lcm = solve(a,b)
print(lcm, a * b // lcm)
except:
break
|
def gcd(a, b):
if b == 0:
return a
return gcd(b, a%b)
while True:
try:
a, b = map(int, raw_input().strip().split(' '))
print "%d %d" % (gcd(a, b), a*b/gcd(a, b))
except EOFError:
break
| 1 | 610,980,306 | null | 5 | 5 |
n=int(input())
flag=0
for i in range(1,10):
for j in range(1,10):
if((i*j)==n):
flag=1
break
if(flag==1):
print('Yes')
else:
print('No')
|
N = int(input())
m=[]
line = ''
m = [[[0 for k in range(10)] for j in range(3)] for i in range(10)]
for i in range(N):
n = input().split()
b = int(n[0])
f = int(n[1])
r = int(n[2])
v = int(n[3])
m[b-1][f-1][r-1] += v
for i in range(4):
for j in range(3):
for k in range(10):
line += ' {0}'.format(m[i][j][k])
print(line)
line = ''
if i < 3:
print('#'*20)
| 0 | null | 80,488,397,226,300 | 287 | 55 |
a = []
for i in range(0,2):
l = list(map(int,input().split()))
a.append(l)
d = a[1][::-1]
print(' '.join(map(str,d)))
|
import sys
def solve():
a = [int(input()) for i in range(10)]
a.sort(reverse=True)
print(*a[:3], sep='\n')
if __name__ == '__main__':
solve()
| 0 | null | 488,563,699,714 | 53 | 2 |
import bisect
import collections
N,K=map(int,input().split())
A=list(map(int,input().split()))
A.insert(0,0)
cuml=[0]*(N+1)
cuml[0]=A[0]
l=[]
cuml2=[]
l2=[]
buf=[]
ans=0
for i in range(N):
cuml[i+1]=cuml[i]+A[i+1]
#print(cuml)
for i in range(N+1):
cuml2.append([(cuml[i]-i)%K,i])
cuml[i]=(cuml[i]-i)%K
#print(cuml2,cuml)
cuml2.sort(key=lambda x:x[0])
piv=cuml2[0][0]
buf=[]
for i in range(N+1):
if piv!=cuml2[i][0]:
l2.append(buf)
piv=cuml2[i][0]
buf=[]
buf.append(cuml2[i][1])
l2.append(buf)
#print(l2)
cnt=0
for i in range(len(l2)):
for j in range(len(l2[i])):
num=l2[i][j]
id=bisect.bisect_left(l2[i], num + K)
#print(j,id)
cnt=cnt+(id-j-1)
print(cnt)
|
# --*-coding:utf-8-*--
def main():
N, K = map(int, input().split())
A = list(map(int, input().split()))
B = [0]*(N+1)
b = 0
for i, a in enumerate(A):
b += a - 1
b %= K
B[i+1] = b
Q = {}
X = 0
for i, b in enumerate(B):
if i>=K:
Q[B[i-K]] -= 1
if b in Q:
X += Q[b]
Q[b] += 1
else:
Q[b] = 1
print(X)
if __name__ == '__main__':
main()
| 1 | 137,499,734,235,040 | null | 273 | 273 |
x = int(input())
import math
def check(n):
if n == 1: return False
for i in range(2, int(math.sqrt(n)) + 1):
if n % i == 0:
return False
return True
n = x
while check(n) == False:
n += 1
print(n)
|
import sys
readline = sys.stdin.readline
N = int(readline())
A = list(map(int, readline().split()))
if N % 2 == 0:
dp = [[0, 0] for i in range(N)]
dp[1] = [A[0], A[1]]
for i in range(3, N, 2):
dp[i][0] = dp[i - 2][0] + A[i - 1]
dp[i][1] = max(dp[i - 2][0] + A[i], dp[i - 2][1] + A[i])
print(max(dp[N - 1]))
else:
dp = [[0, 0, 0] for i in range(N)]
dp[0] = [A[0], 0, 0]
for i in range(2, N, 2):
dp[i][0] = dp[i - 2][0] + A[i]
dp[i][1] = max(dp[i - 2][0], dp[i - 2][1] + A[i - 1])
dp[i][2] = max(dp[i - 2][1] + A[i], dp[i - 2][2] + A[i])
print(max(dp[N - 1]))
| 0 | null | 71,301,821,309,628 | 250 | 177 |
def main():
num = [int(input()) for i in range(2)]
print(6-num[0]-num[1])
main()
|
alpha = input()
print('A' if alpha.isupper() else 'a')
| 0 | null | 60,760,611,152,580 | 254 | 119 |
N=int(input())
A = list(map(int,input().split()))
val = 0
for i in range(N):
val = val ^ A[i]
ans = []
for i in range(N):
s = val ^ A[i]
ans.append(s)
print(*ans)
|
def main():
n = int(input())
print((n+1)//2)
if __name__ == "__main__":
main()
| 0 | null | 35,638,428,988,878 | 123 | 206 |
import sys
read = sys.stdin.buffer.read
input = sys.stdin.buffer.readline
inputs = sys.stdin.buffer.readlines
import bisect
n,m=map(int,input().split())
A=list(map(int,input().split()))
A.sort()
def hand(x):
cnt=0
for i in range(n):
p=x-A[i]
cnt+=n-bisect.bisect_left(A,p)
return cnt
def main():
l=0
h=2*10**5+1
mid=(l+h)//2
while l+1<h:
mid=(l+h)//2
if hand(mid)<m:
h=mid
else:
l=mid
B=A[::-1]
for i in range(n-1):
B[i+1]+=B[i]
B=B[::-1]
ans=0
cnt=0
for i in range(n):
y=l-A[i]+1
index=bisect.bisect_left(A,y)
if n==index:
continue
else:
ans+=(n-index)*A[i]+B[index]
cnt+=(n-index)
ans+=(m-cnt)*l
print(ans)
if __name__ == "__main__":
main()
|
n=int(input())
s=input()
ans=0
for i in range(1000):
i='0'*(3-len(str(i)))+str(i)
if i[0] in s:
if i[1] in s[s.index(i[0])+1:]:
if i[2]in s[s.index(i[0])+s[s.index(i[0])+1:].index(i[1])+2:]:
ans+=1
print(ans)
| 0 | null | 118,681,592,738,408 | 252 | 267 |
a, b = [int(x) for x in input().split()]
print("{} {}".format(a * b, 2 * a + 2 * b))
|
N, K = map(int, input().split())
A = list(map(int, input().split()))
result = []
for i in range(K, N):
if A[i] > A[i - K]:
result.append('Yes')
else:
result.append('No')
print(*result, sep='\n')
| 0 | null | 3,730,089,130,966 | 36 | 102 |
N,K = map(int, input().split())
A = list(map(int, input().split()))
k = K.bit_length()
dv = [[0]*N for _ in range(k)]
dv[0] = [a-1 for a in A]
for turn in range(1,k):
for town in range(N):
dv[turn][town] = dv[turn-1][dv[turn-1][town]]
a = 0
for i in range(k):
if (K>>i)&1:
a = dv[i][a]
print(a+1)
|
259
N,K=map(int,input().split())
A=[0]+list(map(int,input().split()))
m=1
towns=[1]
flg=[0]*(N+1)
flg[1]=1
while 1:
m=A[m]
towns.append(m)
if flg[m]==1:
l=len(towns)-towns.index(m)-1
break
flg[m]=1
pl=towns.index(m)
if K<=pl:
print(towns[K])
else:
print(towns[(K-pl)%l+pl])
| 1 | 22,738,946,318,188 | null | 150 | 150 |
n, m = list(map(int, input().split()))
A = []
V = []
B = []
for i in range(n):
A.append(list(map(int, input().split())))
for j in range(m):
V.append([int(input())])
for i in range(n):
B.append([0])
for j in range(m):
B[i][0] += A[i][j] * V[j][0]
for i in range(n):
print(B[i][0])
|
n,m = map(int,input().split())
a = []; b= [];
for i in range(n): a.append(list(map(int,input().split())))
for i in range(m): b.append(int(input()))
for i in range(n):
c = 0
for j in range(m):
c += a[i][j]*b[j]
print(c)
| 1 | 1,164,454,143,100 | null | 56 | 56 |
import math
n = (int)(input())
x = [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]
ret = x[n-1]
print("{}".format(ret))
|
N = input()
N = [int(i) for i in list(N)][::-1] + [0]
# print(N)
lenN = len(N)
dp = [[float('inf')]*2 for _ in range(len(N)+1)]
dp[0][0] = 0
for i in range(1, len(N)+1):
res0 = float('inf')
res1 = float('inf')
for j in range(2):
for num in range(10):
if j == 1:
# 前に繰り下がりしていたらnumを減らす
num = num - 1
if num >= N[i-1]:
b = num - N[i-1]
res0 = min(res0, dp[i - 1][j] + num + b + j)
else:
b = num - N[i-1] + 10
res1 = min(res1, dp[i - 1][j] + num + b + j)
dp[i][0] = res0
dp[i][1] = res1
# print(dp)
print(min(dp[lenN][0], dp[lenN][1]))
| 0 | null | 60,869,355,239,340 | 195 | 219 |
# -*- coding: utf-8 -*-
n, m= [int(i) for i in input().split()]
for i in range(0,m):
if n-2*i-1>n/2 or n%2==1:
print(i+1,n-i)
else:
print(i+1,n-i-1)
|
n, m = map(int, input().split())
if n % 2 == 0:
i = 1
while i <= m:
a_i = str(i)
if i <= (n - 2) // 4:
b_i = str(n - i)
else:
b_i = str(n - i - 1)
print(a_i + " " + b_i)
i += 1
elif n % 2 == 1:
for i in range(1, m + 1):
a_i = str(i)
b_i = str(n - i)
print(a_i + " " + b_i)
| 1 | 28,767,151,231,842 | null | 162 | 162 |
import sys
S=list(input())
reverse_S = S[::-1]
if S==reverse_S:
for i in range(int(len(S)/2)):
if S[i]==S[int(len(S)/2)-i-1] and S[int(len(S)/2)+1+i]==S[len(S)-1-i]:
continue
else:
print("No")
sys.exit()
print("Yes")
else:
print("No")
|
def main():
s=input()
x=s[:int((len(s)-1)/2)]
y=s[int((len(s)+3)/2)-1:]
flg=0
if s !=s[::-1]:
flg=1
if x !=x[::-1]:
flg=1
if y !=y[::-1]:
flg=1
if flg==1:
print("No")
else:
print("Yes")
main()
| 1 | 46,378,716,599,700 | null | 190 | 190 |
N, M = [int(x) for x in input().split()]
A = [int(x) for x in input().split()]
dp = [0] * (N + 1)
for i in range(1, N + 1):
tmp = float("inf")
for j in A:
if i - j >= 0:
tmp = min(tmp, dp[i - j])
dp[i] = tmp + 1
print(dp[N])
|
N,M=list(map(int,input().split()))
C=list(map(int,input().split()))
dp = [[0]*len(C) for n in range(N+1)] #dp[n][c]
for n in range(1,N+1):
dp[n][0] = n
for n in range(1,N+1):
for c in range(1,len(C)):
if C[c] > n:
dp[n][c]=dp[n][c-1]
else:
dp[n][c]=min(dp[n][c-1],dp[n-C[c]][c]+1)
print(dp[-1][-1])
| 1 | 147,232,755,318 | null | 28 | 28 |
N = int(input())
c = 0
for _ in range(N):
if len(set(input().split())) == 1:
c += 1
if 3 <= c:
print("Yes")
exit()
else:
c = 0
else:
print("No")
|
N = int(input())
A = [int(x) for x in input().split()]
cnt = 0
for i in range(N):
mini = i
for j in range(i, N):
if A[j] < A[mini]:
mini = j
if i != mini:
A[i], A[mini] = A[mini], A[i]
cnt +=1
print(" ".join(map(str, A)))
print(cnt)
| 0 | null | 1,253,733,882,288 | 72 | 15 |
n=int(input())
a=0
b=0
while n!=0:
n=n//2
a+=2**b
b+=1
print(a)
|
H = int(input())
ans = 0
attack_cnt = 0
while H > 0:
ans += 2 ** attack_cnt
attack_cnt += 1
H //= 2
print(ans)
| 1 | 80,207,238,769,970 | null | 228 | 228 |
N=int(input())
print((N//2+1)/N if N%2 else 0.5)
|
n=int(input())
even=n//2
a=(n-even)/n
print(a)
| 1 | 176,414,599,266,302 | null | 297 | 297 |
N = int(input())
S = input()
ans = 'No'
if len(S) % 2 == 0 and S[0:int(N/2)] == S[int(N/2):N]:
ans = 'Yes'
print(ans)
|
A = input()
B = input()
KAI = "123"
KAI1 = KAI.replace(A,"")
KAI2 = KAI1.replace(B,"")
print(KAI2)
| 0 | null | 128,851,436,676,860 | 279 | 254 |
#! /usr/bin/env python
#-*- coding: utf-8 -*-
''' ?????\????????? '''
#
# ?¨??????????O()
def insertion_sort(A, N):
for i in range(N):
tmp = A[i]
j = i - 1
while j >= 0 and A[j] > tmp:
A[j + 1] = A[j]
j -= 1
A[j + 1] = tmp
print(' '.join(map(str, A)))
return A
if __name__ == "__main__":
N = int(input())
A = list(map(int, input().split()))
# N = 6
# A = [5, 2, 4, 6, 1, 3]
array_sorted = insertion_sort(A, N)
|
#coding:utf-8
n = int(input())
numbers = list(map(int,input().split()))
for i in range(n):
tmp = numbers[i]
j = i - 1
while j >= 0 and numbers[j] > tmp:
numbers[j+1] = numbers[j]
j -= 1
numbers[j+1] = tmp
print(*numbers)
| 1 | 6,221,613,700 | null | 10 | 10 |
print(['SUN','MON','TUE','WED','THU','FRI','SAT'][::-1].index(input())+1)
|
A,B,N=map(int,input().split())
i=min(B-1,N)
tmp=(A*i)//B-A*(i//B)
print(tmp)
| 0 | null | 80,221,575,069,020 | 270 | 161 |
ryou = [0]*4
for i in range(4):
ryou[i] = [0]*3
for i in range(4):
for j in range(3):
ryou[i][j] = [0]*10
sep = '#' * 20
n = int(input())
for i in range(n):
b, f, r, v = [int(x) for x in input().split()]
ryou[b-1][f-1][r-1] += v
for i in range(4):
for j in range(3):
s = ' '
s += ' '.join(map(str,ryou[i][j]))
print(s)
if not i == 3:
print(sep)
|
N = int(input())
A = list(map(int, input().split()))
ans = "APPROVED"
for n in range(N):
if A[n] % 2 == 1:
pass
elif A[n] % 3 == 0:
pass
elif A[n] % 5 == 0:
pass
else:
ans = "DENIED"
break
print(ans)
| 0 | null | 35,163,003,304,700 | 55 | 217 |
a = input()
if a.isupper():
print("A")
else: print("a")
|
print('a' if input().islower() else 'A')
| 1 | 11,321,750,858,432 | null | 119 | 119 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.