input stringlengths 20 127k | target stringlengths 20 119k | problem_id stringlengths 6 6 |
|---|---|---|
L = list(map(int,input().split(" ")))
if len(set(L)) == 2:
print("Yes")
else:
print("No") | ans = "Yes" if len(set(input().split())) == 2 else "No"
print(ans) | p02771 |
a, b, c = list(map(int, input().split()))
if a == b != c or b == c != a or c == a != b:
print("Yes")
else:
print("No") | st = set(map(int, input().split()))
print(('Yes' if len(st) == 2 else 'No')) | p02771 |
print(*[i[0] for i in input().split()],sep='')
| print(f'A{input()[8]}C') | p03860 |
s = input()[8]
print(("A"+s+"C")) | s = input()[8]
print(("A%sC" % s)) | p03860 |
lst=input().split()
x=lst[1]
print(('A'+x[0]+'C')) | a,b,c=list(map(str,input().split()))
print(('A'+b[0]+'C')) | p03860 |
import re
A, B, C = list(map(str, input().split()))
def search_func(string_list):
return re.match('[A-Z]', string_list).group()
second_string = search_func(B)
print(('A' + second_string + 'C'))
| s,t,u=input().split()
print(('A'+t[0]+'C')) | p03860 |
abc=list(input().split())
print(('A'+abc[1][0]+'C'))
| A, B, C = input().split()
print(('A' + B[0] + 'C'))
| p03860 |
n = input().split()[1]
print(('A%sC'%n[0])) | a = input().split()
print((a[0][0] + a[1][0] + a[2][0])) | p03860 |
a,b,c= input().split()
print((a[0]+b[0]+c[0])) | print(("A%sC"%input()[8])) | p03860 |
print(("A%sC"%input()[8])) | print(("A"+input()[8]+"C")) | p03860 |
a=input().split()
print(("A"+a[1][0]+"C"))
| print(("A"+input()[8]+"C")) | p03860 |
a,s,c = input().split(" ")
print(("A{}C".format(s[0]))) | a,s,c = input().split()
print(("A"+s[0]+"C")) | p03860 |
s = list(input().split())
print(s[0][0],s[1][0],s[2][0], sep="")
| import sys
a, b, c = sys.stdin.readline().split()
print((a[0] + b[0] + c[0])) | p03860 |
S = input().split()
print(("A"+S[1][0]+"C"))
| a, b, c = input().split()
print((a[0]+b[0]+c[0]))
| p03860 |
_,s,_ = input().split()
print(("A"+s[0]+"C"))
| S = input().split()
print(("A"+S[1][0]+"C")) | p03860 |
a, b, c = list(map(str, input().split()))
print((a[0] + b[0] + c[0]))
| a, b, c = list(map(str, input().split()))
print((a[0].upper() + b[0].upper() + c[0].upper()))
| p03860 |
a = input().split()
x = a[1]
print(('A' + x[0] + 'C')) | print(('A'+input()[8]+'C')) | p03860 |
print(('A' + input().split()[1][0] + 'C'))
| a = input().split()
print(*[h[0] for h in a], sep='')
| p03860 |
a,b,c=list(map(str,input().split()))
c=b[0]
print(('A'+c+'C'))
| xs = input().split()
print(("A"+xs[1][0]+"C")) | p03860 |
a, b, c = input().split()
print((a[0] + b[0] + c[0])) | A, B, C = input().split()
print(('A'+B[0]+'C')) | p03860 |
s1, s2, s3 = input().split()
print(("{0}{1}{2}".format(s1[0], s2[0], s3[0]))) | print(("A"+input()[8]+"C")) | p03860 |
s = input().split()
print(('{}{}{}'.format(s[0][0], s[1][0], s[2][0]))) | a, b, c = input().split(' ')
print((a[0] + b[0] + c[0])) | p03860 |
s=tuple(input().split())
print(("A{}C".format(s[1][0]))) | s = input().split()
ans = s[0][0] + s[1][0] + s[2][0]
print(ans)
| p03860 |
a,b,c = list(map(int,input().split()))
sound_max = b//a
if c >= sound_max:
print(sound_max)
elif c <= sound_max:
print(c)
| a,b,c = list(map(int,input().split()))
if b//a >= c:
print(c)
else:
print((b//a)) | p03105 |
A, B, C = list(map(int, input().split()))
print((min(C, B//A))) | a,b,c=list(map(int,input().split()))
print((min(c,b//a))) | p03105 |
a, b, c = list(map(int, input().split()))
if a*c <= b:
print (c)
else:
print((b//a)) | a, b, c = list(map(int, input().split()))
if a*c < b:
print (c)
else:
print((b//a)) | p03105 |
import sys
# import bisect
# import math
# import itertools
# import numpy as np
"""Template"""
class IP:
"""
入力を取得するクラス
"""
def __init__(self):
self.input = sys.stdin.readline
def I(self):
"""
1文字の取得に使います
:return: int
"""
return int(self.input())
def S(self):
"""
1文字の取得(str
:return: str
"""
return self.input()
def IL(self):
"""
1行を空白で区切りリストにします(int
:return: リスト
"""
return list(map(int, self.input().split()))
def SL(self):
"""
1行の文字列を空白区切りでリストにします
:return: リスト
"""
return list(map(str, self.input().split()))
def ILS(self, n):
"""
1列丸々取得します(int
:param n: 行数
:return: リスト
"""
return [int(self.input()) for _ in range(n)]
def SLS(self, n):
"""
1列丸々取得します（str
:param n: 行数
:return: リスト
"""
return [self.input() for _ in range(n)]
def SILS(self, n):
"""
Some Int LineS
横に複数、縦にも複数
:param n: 行数
:return: list
"""
return [self.IL() for _ in range(n)]
def SSLS(self, n):
"""
Some String LineS
:param n: 行数
:return: list
"""
return [self.SL() for _ in range(n)]
class Idea:
def __init__(self):
pass
def HF(self, p):
"""
Half enumeration
半分全列挙です
pの要素の和の組み合わせを作ります。
ソート、重複削除行います
:param p: list : 元となるリスト
:return: list : 組み合わせられた和のリスト
"""
return sorted(set(p[i] + p[j] for i in range(len(p)) for j in range(i, len(p))))
def Bfs2(self, a):
"""
bit_full_search2
bit全探索の改良版
全探索させたら2進数のリストと10進数のリストを返す
:return: list２つ : １個目 2進数(16桁) 2個目 10進数
"""
# 参考
# https://blog.rossywhite.com/2018/08/06/bit-search/
# https://atcoder.jp/contests/abc105/submissions/4088632
value = []
for i in range(1 << len(a)):
output = []
for j in range(len(a)):
if self.bit_o(i, j):
"""右からj+1番目のiが1かどうか判定"""
# output.append(a[j])
output.append(a[j])
value.append([format(i, 'b').zfill(16), sum(output)])
value.sort(key=lambda x: x[1])
bin = [value[k][0] for k in range(len(value))]
val = [value[k][1] for k in range(len(value))]
return bin, val
def S(self, s, r=0, m=-1):
"""
ソート関係行います。色々な設定あります。
:param s: 元となるリスト
:param r: reversするかどうか 0=False 1=True
:param m: （2次元配列）何番目のインデックスのソートなのか
:return: None
"""
r = bool(r)
if m == -1:
s.sort(reverse=r)
else:
s.sort(reverse=r, key=lambda x: x[m])
def bit_n(self, a, b):
"""
bit探索で使います。0以上のときにTrue出します
自然数だからn
:param a: int
:param b: int
:return: bool
"""
return bool((a >> b & 1) > 0)
def bit_o(self, a, b):
"""
bit探索で使います。1のときにTrue出すよ
oneで1
:param a: int
:param b: int
:return: bool
"""
return bool(((a >> b) & 1) == 1)
def ceil(self, x, y):
"""
Round up
小数点切り上げ割り算
:param x: int
:param y: int
:return: int
"""
return -(-x // y)
def ave(self, a):
"""
平均を求めます
:param a: list
:return: int
"""
return sum(a) / len(a)
def gcd(self, x, y):
if y == 0:
return x
else:
return self.gcd(y, x % y)
"""ここからメインコード"""
def main():
# 1文字に省略
r, e = range, enumerate
ip = IP()
id = Idea()
"""この下から書いてね"""
a, b, c = ip.IL()
d = b // a
print((min(c, d)))
main()
| a,b,c=list(map(int,input().split()));print((min(c,b//a))) | p03105 |
a, b, c = list(map(int, input().split()))
print((c if b//a >= c else b//a)) | a, b, c = list(map(int, input().split()))
print((b // a if b//a <= c else c)) | p03105 |
A, B, C = list(map(int, input().split()))
if A * C > B:
print((B // A))
else:
print(C) | A, B, C = list(map(int, input().split()))
if A * C >= B:
print((B // A))
else:
print(C) | p03105 |
A, B, C = list(map(int, input().split()))
print((min(B//A, C))) | A, B, C = list(map(int, input().split()))
print((min(C, B // A))) | p03105 |
a,b,c=list(map(int,input().split()))
print((min(b//a,c))) | a,b,c = list(map(int,input().split()))
print((min(c,b//a))) | p03105 |
A, B, C = list(map(int, input().split()))
print((C if B // A > C else B // A)) | A, B, C = list(map(int, input().split()))
print((min(C, B // A))) | p03105 |
a,b,c=list(map(int,input().split()))
if b//a > c:
print(c)
else:
print((b//a)) | A,B,C=list(map(int, input().split()))
print((B//A if B<A*C else C)) | p03105 |
a,b,c=list(map(int,input().split()))
print((min(c,b//a))) | A,B,C = list(map(int,input().split()))
print((min(C,B//A))) | p03105 |
import sys
from bisect import *
from heapq import *
from collections import *
from itertools import *
from functools import *
from math import *
from fractions import *
sys.setrecursionlimit(100000000)
input = lambda: sys.stdin.readline().rstrip()
A, B, C = list(map(int, input().split()))
print((min(C, B // A)))
| A, B, C = list(map(int, input().split()))
print((min(C, B // A)))
| p03105 |
a,b,c = list(map(int,input().split()))
print((min(b//a,c))) | a,b,c = list(map(int,input().split()))
print((min(c,b//a))) | p03105 |
A, B, C = list(map(int, input().split()))
retval = B // A
print((min(retval, C))) | A, B, C = list(map(int, input().split()))
print((min(C, B // A))) | p03105 |
import math
def main():
a, b, c = [int(x) for x in input().split()]
max_listen = math.floor(b/a)
print((min(c, max_listen)))
pass
if __name__ == "__main__":
main() | a, b, c = [int(x) for x in input().split()]
print((min(b//a, c))) | p03105 |
n, m, l = list(map(int, input().split()))
A = []
B = []
C = [[] for i in range(n)]
for i in range(n):
tmp_row = list(map(int, input().split()))
A.append(tmp_row)
for i in range(m):
tmp_row = list(map(int, input().split()))
B.append(tmp_row)
for i in range(n):
line = ""
for j in range(l):
ab = sum([A[i][k] * B[k][j] for k in range(m)])
line += " {0}".format(ab)
print((line[1:])) | n, m, l = list(map(int, input().split()))
A = []
B = []
C = [[] for i in range(n)]
for i in range(n):
tmp_row = list(map(int, input().split()))
A.append(tmp_row)
for i in range(m):
tmp_row = list(map(int, input().split()))
B.append(tmp_row)
for i in range(n):
for j in range(l):
ab = sum([A[i][k] * B[k][j] for k in range(m)])
C[i].append(ab)
for i in C:
print((" ".join(map(str, i)))) | p02414 |
[n, m, l] = [int(x) for x in input().split()]
A = []
B = []
C = []
counter = 0
while counter < n:
A.append([int(x) for x in input().split()])
counter += 1
counter = 0
while counter < m:
B.append([int(x) for x in input().split()])
counter += 1
counter = 0
while counter < n:
C.append([0] * l)
counter += 1
for i in range(n):
for j in range(l):
for k in range(m):
C[i][j] += (A[i][k] * B[k][j])
for data in C:
print((' '.join([str(x) for x in data]))) | [n, m, l] = [int(x) for x in input().split()]
A = []
B = []
counter = 0
while counter < n:
A.append([int(x) for x in input().split()])
counter += 1
counter = 0
while counter < m:
B.append([int(x) for x in input().split()])
counter += 1
B = list(zip(*B))
for i in range(n):
data = []
for j in range(l):
data.append(sum([x[0] * x[1] for x in zip(A[i], B[j])]))
print((' '.join([str(x) for x in data]))) | p02414 |
(n, m, l) = [int(i) for i in input().split()]
A = []
for nc in range(n):
A.append([int(i) for i in input().split()])
B = []
for mc in range(m):
B.append([int(i) for i in input().split()])
product = [[0 for d in range(l)] for dd in range(n)]
for nc in range(n):
for lc in range(l):
for mc in range(m):
product[nc][lc] += A[nc][mc] * B[mc][lc]
for r in product:
print((' '.join([str(d) for d in r]))) | (n, m, l) = [int(i) for i in input().split()]
A = []
B = []
for _ in range(n):
A.append([int(i) for i in input().split()])
for _ in range(m):
B.append([int(i) for i in input().split()])
for i in range(n):
C = [0 for _ in range(l)]
for j in range(l):
for k in range(m):
C[j] += A[i][k] * B[k][j]
print((" ".join([str(a) for a in C]))) | p02414 |
n,m,l=map(int,input().split())
a=[list(map(int,input().split()))for _ in range(n)]
b=[list(map(int,input().split()))for _ in range(m)]
[print(*x)for x in[[sum(s*t for s,t in zip(c,l))for l in zip(*b)]for c in a]]
| n,m,l=map(int,input().split())
a=[list(map(int,input().split()))for _ in range(n)]
b=[list(map(int,input().split()))for _ in range(m)]
[print(*x)for x in[[sum([s*t for s,t in zip(c,l)])for l in zip(*b)]for c in a]]
| p02414 |
import sys
e=[list(map(int,e.split()))for e in sys.stdin]
n=e[0][0]+1
for c in e[1:n]:
t=''
for l in zip(*e[n:]):t+=f'{sum(s*t for s,t in zip(c,l))} '
print((t[:-1]))
| import sys
e=[list(map(int,e.split()))for e in sys.stdin]
n=e[0][0]+1
t=''
for c in e[1:n]:
for l in zip(*e[n:]):t+=f'{sum(s*t for s,t in zip(c,l))} '
t=t[:-1]+'\n'
print((t[:-1]))
| p02414 |
import sys
e=[list(map(int,e.split()))for e in sys.stdin]
n=e[0][0]+1
t=''
for c in e[1:n]:
for l in zip(*e[n:]):t+=f'{sum(s*t for s,t in zip(c,l))} '
t=t[:-1]+'\n'
print((t[:-1]))
| import sys
e=[list(map(int,e.split()))for e in sys.stdin]
n=e[0][0]+1
[print(*[sum(s*t for s,t in zip(c,l))for l in zip(*e[n:])])for c in e[1:n]]
| p02414 |
import sys
e=[list(map(int,e.split()))for e in sys.stdin]
n=e[0][0]+1
[print(*[sum(s*t for s,t in zip(c,l))for l in zip(*e[n:])])for c in e[1:n]]
| import sys
e=[list(map(int,x.split()))for x in sys.stdin];n=e[0][0]+1
[print(*x)for x in[[sum(s*t for s,t in zip(c,l))for l in zip(*e[n:])]for c in e[1:n]]]
| p02414 |
(n, m, l) = [int(i) for i in input().split()]
A = []
for nc in range(n):
A.append([int(i) for i in input().split()])
B = []
for mc in range(m):
B.append([int(i) for i in input().split()])
product = [[0 for d in range(l)] for dd in range(n)]
for nc in range(n):
for lc in range(l):
for mc in range(m):
product[nc][lc] += A[nc][mc] * B[mc][lc]
for r in product:
print((' '.join([str(d) for d in r]))) | n, m, l = (int(i) for i in input().split())
A = []
B = []
#C = [[0] * n] * l
C = [[0 for i in range(l)] for j in range(n)]
#??\?????????????????????????´?
for i in range(n):
#swap_list = input().split()
#A.append(swap_list)
A.append([int(i) for i in input().split()])
for i in range(m):
#swap_list = input().split()
#B.append(swap_list)
B.append([int(i) for i in input().split()])
#????????????????¨????
for i in range(n):
for j in range(l):
for k in range(m):
C[i][j] += A[i][k] * B[k][j]
#?????????????????????
#for i in range(n):
# for j in range(l):
# print("{0}".format(C[i][j]), end="\b")
# print("")
#for i in range(n):
# print(" ".join(map(str, C[i][:])))
for r in C:
print((" ".join([str(d) for d in r]))) | p02414 |
def main():
n, m, l = tuple(map(int, input().split()))
matA = [[0 for j in range(m)] for i in range(n)]
matB = [[0 for k in range(l)] for j in range(m)]
matC = [[0 for k in range(l)] for i in range(n)]
for i in range(n):
tmp = list(map(int, input().split()))
for j in range(m):
matA[i][j] = tmp[j]
for j in range(m):
tmp = list(map(int, input().split()))
for k in range(l):
matB[j][k] = tmp[k]
for i in range(n):
for k in range(l):
for j in range(m):
matC[i][k] += matA[i][j] * matB[j][k]
for i in range(n):
for k in range(l):
if k == l-1:
print(matC[i][k])
else:
print(matC[i][k], end=' ')
if __name__ == '__main__':
main()
| n, m, l = map(int, input().split())
A = [list(map(int, input().split())) for _ in range(n)]
B = [list(map(int, input().split())) for _ in range(m)]
[print(*x) for x in [[sum(j*k for j,k in zip(x,y)) for y in zip(*B)] for x in A]]
| p02414 |
import copy
a = [[0 for i in range(100)] for j in range(100)]
b = copy.deepcopy(a)
n, m, l = map(int, input().split())
for i in range(n):
a[i][:m] = map(int, input().split())
for i in range(m):
b[i][:l] = map(int, input().split())
for i in range(n):
for j in range(l):
c = 0
for k in range(m):
c += a[i][k] * b[k][j]
print(c, end='')
if j < l - 1:
print(' ', end='')
else:
print()
| a = [[0 for i in range(100)] for j in range(100)]
b = [[0 for i in range(100)] for j in range(100)]
n, m, l = map(int, input().split())
for i in range(n):
a[i][:m] = map(int, input().split())
for i in range(m):
b[i][:l] = map(int, input().split())
for i in range(n):
for j in range(l):
c = 0
for k in range(m):
c += a[i][k] * b[k][j]
print(c, end='')
if j < l - 1:
print(' ', end='')
else:
print()
| p02414 |
import sys
n, m, l = [ int( val ) for val in sys.stdin.readline().split( " " ) ]
matrixA = [ [ int( val ) for val in sys.stdin.readline().split( " " ) ] for row in range( n ) ]
matrixB = [ [ int( val ) for val in sys.stdin.readline().split( " " ) ] for row in range( m ) ]
matrixC = [ [ 0 for row in range( l ) ] for row in range( n ) ]
output = []
for i in range( n ):
for j in range( l ):
for k in range( m ):
matrixC[i][j] += ( matrixA[i][k] * matrixB[k][j] )
output.append( "{:d}".format( matrixC[i][j] ) )
output.append( " " )
output.pop()
output.append( "\n" )
output.pop()
print(( "".join( output ) )) | import sys
n, m, l = [ int( val ) for val in sys.stdin.readline().split( " " ) ]
matrixA = [ [ int( val ) for val in sys.stdin.readline().split( " " ) ] for row in range( n ) ]
matrixB = [ [ int( val ) for val in sys.stdin.readline().split( " " ) ] for row in range( m ) ]
c = 0
output = []
for i in range( n ):
for j in range( l ):
c = 0
for k in range( m ):
c += ( matrixA[i][k] * matrixB[k][j] )
output.append( "{:d}".format( c ) )
output.append( " " )
output.pop()
output.append( "\n" )
output.pop()
print(( "".join( output ) )) | p02414 |
import sys
n, m, l = [ int( val ) for val in sys.stdin.readline().split( " " ) ]
matrixA = [ [ int( val ) for val in sys.stdin.readline().split( " " ) ] for row in range( n ) ]
matrixB = [ [ int( val ) for val in sys.stdin.readline().split( " " ) ] for row in range( m ) ]
c = 0
output = []
for i in range( n ):
for j in range( l ):
c = 0
for k in range( m ):
c += ( matrixA[i][k] * matrixB[k][j] )
output.append( "{:d}".format( c ) )
output.append( " " )
output.pop()
output.append( "\n" )
output.pop()
print(( "".join( output ) )) | import sys
n, m, l = [ int( val ) for val in sys.stdin.readline().split( " " ) ]
matrixA = [ [ int( val ) for val in sys.stdin.readline().split( " " ) ] for row in range( n ) ]
matrixB = [ [ int( val ) for val in sys.stdin.readline().split( " " ) ] for row in range( m ) ]
matrixC = [ [ sum( matrixA[i][k] * matrixB[k][j] for k in range( m ) ) for j in range( l ) ] for i in range( n ) ]
for i in range( n ):
print(( " ".join( map( str, matrixC[i] ) ) )) | p02414 |
n, m, l = map(int, input().split())
a = [list(map(int, input().split())) for _ in range(n)]
b = [list(map(int, input().split())) for _ in range(m)]
ans = [[0 for _ in range(l)] for _ in range(n)]
for i in range(n) :
for j in range(l) :
for k in range(m) :
ans[i][j] += a[i][k] * b[k][j]
print(*ans[i], sep = ' ')
| n, m, l = map(int, input().split())
a = [list(map(int, input().split())) for _ in range(n)]
b = [list(map(int, input().split())) for _ in range(m)]
[print(*x) for x in [[sum(j*k for j,k in zip(x,y)) for y in zip(*b)] for x in a]]
| p02414 |
n, m, l = map(int, input().split())
A = []
B = []
for _ in range(n):
A.append(list(map(int, input().split())))
for _ in range(m):
B.append(list(map(int, input().split())))
for i in range(n):
for j in range(l):
s = 0
for k in range(m):
s += A[i][k] * B[k][j]
print(s, end='')
if j != l-1:
print(' ', end='')
print()
| n, m, l = list(map(int, input().split()))
A = []
for i in range(n):
row = list(map(int, input().split()))
A.append(row)
B = []
for i in range(m):
row = list(map(int, input().split()))
B.append(row)
C = []
for i in range(n):
row = []
for j in range(l):
sum = 0
for k in range(m):
sum += A[i][k] * B[k][j]
row.append(sum)
C.append(row)
for i in range(n):
print((' '.join(map(str, C[i]))))
| p02414 |
n, m, l = map(int, input().split())
A = [[int(n) for n in input().split()] for i in range(n)]
B = [[int(n) for n in input().split()] for i in range(m)]
C = [[0 for i in range(l)] for i in range(n)]
for i in range(n):
for j in range(l):
for k in range(m):
C[i][j] += A[i][k] * B[k][j]
for i in range(n):
for j in range(l):
if j == l - 1:
print(C[i][j])
else:
print(C[i][j], end = " ")
| n, m, l = map(int, input().split())
a = [[int(num) for num in input().split()] for i in range(n)]
b = [[int(num) for num in input().split()] for i in range(m)]
c = [[0 for i in range(l)] for j in range(n)]
for i in range(n):
for j in range(l):
for k in range(m):
c[i][j] += a[i][k] * b[k][j]
for i in range(n):
for j in range(l):
if j == l - 1:
print(c[i][j])
else:
print(c[i][j], end=" ")
| p02414 |
if __name__ == '__main__':
n,m,l=list(map(int,input().split()))
a=[list(map(int,input().split())) for _ in [0]*n]
b=list(zip(*[list(map(int,input().split())) for _ in [0]*m]))
sums=[i[k]*j[k] for i in a for j in b for k in range(m)]
c=[sum(sums[i:i+m]) for i in [j for j in range(len(sums)) if j%m==0]]
for i in range(len(c)):
if (i+1)%l==0: print(c[i])
else: print(c[i], end=' ') | if __name__ == '__main__':
n,m,l=list(map(int,input().split()))
a=[list(map(int,input().split())) for _ in [0]*n]
b=list(zip(*[list(map(int,input().split())) for _ in [0]*m]))
sums=[i[k]*j[k] for i in a for j in b for k in range(m)]
c=[sum(sums[i:i+m]) for i in [j for j in range(len(sums)) if j%m==0]]
c=[c[i:i+l] for i in range(len(c)) if i%l==0]
for i in c:
print(" ".join(map(str, i))) | p02414 |
import sys
def cmb(n,r,mod):
if r<0 or r>n:
return 0
r=min(r,n-r)
return g1[n]*g2[r]*g2[n-r]%mod
n=int(eval(input()))
a=list(map(int,input().split()))
mod=10**9+7
g1=[1,1]
g2=[1,1]
inverse=[0,1]
for i in range(2,n*2):
g1.append((g1[-1]*i)%mod)
inverse.append((-inverse[mod%i]*(mod//i))%mod)
g2.append((g2[-1]*inverse[-1])%mod)
ct=[0,0,0]
ans=1
for i in range(n):
f=0
ct2=0
for j in range(3):
if a[i]==ct[j]:
if ct2==0:
ct[j]+=1
ct2+=1
ans*=ct2
print((ans%mod)) | n=int(eval(input()))
a=list(map(int,input().split()))
mod=10**9+7
ct=[0,0,0]
ans=1
for i in range(n):
f=0
ct2=0
for j in range(3):
if a[i]==ct[j]:
if ct2==0:
ct[j]+=1
ct2+=1
ans*=ct2
ans%=mod
print((ans%mod)) | p02845 |
#!/usr/bin/env python3
import sys
MOD = 1000000007 # type: int
def solve(N: int, A: "List[int]"):
if A[0] != 0:
print((0))
return
## 一番多い色の帽子の数
color = [1,0,0]
answer = 3
for i in range(1,N):
if A[i] not in color:
print((0))
return
count = color.count(A[i])
answer *= count
for j in range(len(color)):
if color[j] == A[i]:
color[j]+=1
break
print((answer%MOD))
return
def main():
def iterate_tokens():
for line in sys.stdin:
for word in line.split():
yield word
tokens = iterate_tokens()
N = int(next(tokens)) # type: int
A = [int(next(tokens)) for _ in range(N)] # type: "List[int]"
solve(N, A)
if __name__ == '__main__':
main()
| #!/usr/bin/env python3
import sys
input = sys.stdin.readline
def INT(): return int(eval(input()))
def MAP(): return list(map(int,input().split()))
def LI(): return list(map(int,input().split()))
def main():
N = INT()
A = LI()
RGB = [0,0,0]
answer = 1
MOD = 10**9+7
for i in range(N):
if RGB.count(A[i]) == 0:
print((0))
return
answer *= RGB.count(A[i])
answer %= MOD
for j in range(3):
if RGB[j] == A[i]:
RGB[j] += 1
break
print(answer)
return
if __name__ == '__main__':
main()
| p02845 |
from collections import defaultdict
N = int(eval(input()))
A = list(map(int, input().split()))
ans = 1
d = defaultdict(int)
for i,n in enumerate(A):
if n == 0:
ans *= (3-d[n])
d[n] += 1
else:
ans *= (d[n-1] - d[n])
d[n] += 1
print((ans % (10**9+7))) |
N = int(eval(input()))
A = list(map(int, input().split()))
MOD = 10**9 + 7
if A[0] != 0:
print((0))
exit()
ans = 1
colors = [0] * 3
for n in A:
ans *= colors.count(n)
ans %= MOD
for i in range(3):
if colors[i] == n:
colors[i] += 1
break
print(ans)
| p02845 |
# coding: utf-8
import sys
#from operator import itemgetter
sysread = sys.stdin.buffer.readline
read = sys.stdin.buffer.read
from heapq import heappop, heappush
from collections import defaultdict
sys.setrecursionlimit(10**7)
import math
#from itertools import product, accumulate, combinations, product
#import bisect
#import numpy as np
#from copy import deepcopy
#from collections import deque
#from decimal import Decimal
#from numba import jit
INF = 1 << 50
EPS = 1e-8
mod = 10 ** 9 + 7
def mapline(t = int):
return list(map(t, sysread().split()))
def mapread(t = int):
return list(map(t, read().split()))
def run():
N, *A = mapread()
dp = [defaultdict(lambda:0) for _ in range(N+1)]
dp[0][(0,0,0)] = 1
for i in range(N):
a = A[i]
k = i + 1
for key in list(dp[k-1].keys()):
for ii, v in enumerate(key):
if v == a:
tmp = list(key)
tmp[ii] += 1
dp[k][tuple(tmp)] += dp[k-1][key] % mod
ans = 0
for key in list(dp[N].keys()):
ans = (ans + dp[N][key]) % mod
#print(dp)
print(ans)
if __name__ == "__main__":
run()
| # coding: utf-8
import sys
#from operator import itemgetter
sysread = sys.stdin.buffer.readline
read = sys.stdin.buffer.read
from heapq import heappop, heappush
from collections import defaultdict
sys.setrecursionlimit(10**7)
import math
#from itertools import product, accumulate, combinations, product
#import bisect
#import numpy as np
#from copy import deepcopy
#from collections import deque
#from decimal import Decimal
#from numba import jit
INF = 1 << 50
EPS = 1e-8
mod = 10 ** 9 + 7
def mapline(t = int):
return list(map(t, sysread().split()))
def mapread(t = int):
return list(map(t, read().split()))
def run():
N, *A = mapread()
ans = 1
current = [0,0,0]
for a in A:
transition = 0
cache = 1
for i, c in enumerate(current):
if c == a:
transition += 1
cache = i
ans *= transition
ans %= mod
current[cache] += 1
#print(current)
print(ans)
if __name__ == "__main__":
run()
| p02845 |
import sys
input = sys.stdin.readline
N = int(eval(input()))
A = list(map(int, input().split()))
cnt = [0]*N
p = 0
ans = 1
MOD = 10**9+7
for Ai in A:
if Ai==0:
cnt[Ai] += 1
p += 1
else:
ans *= cnt[Ai-1]
ans %= MOD
cnt[Ai-1] -= 1
cnt[Ai] += 1
if p==1:
ans *= 3
elif p==2:
ans *= 6
elif p==3:
ans *= 6
else:
ans = 0
print((ans%MOD)) | import sys
input = sys.stdin.readline
N = int(eval(input()))
A = list(map(int, input().split()))
ans = 1
MOD = 10**9+7
r, g, b = 0, 0, 0
for Ai in A:
cnt = 0
if r==Ai:
cnt += 1
if g==Ai:
cnt += 1
if b==Ai:
cnt += 1
ans *= cnt
ans %= MOD
if r==Ai:
r += 1
elif g==Ai:
g += 1
else:
b += 1
print(ans) | p02845 |
N, *A = list(map(int, open(0).read().split()))
MOD = 10 ** 9 + 7
ctr = [0] * 3
ans = 1
for a in A:
ans *= sum(a == v for v in ctr)
for j in range(3):
if ctr[j] == a:
ctr[j] += 1
break
print((ans % MOD))
|
N = int(eval(input()))
X = list(map(int, input().split()))
MOD = 10 ** 9 + 7
ctr = [0, 0, 0]
ans = 1
for a in X:
ptn = sum(a == v for v in ctr)
ans = ans * ptn % MOD
if ans == 0:
break
for i in range(3):
if ctr[i] == a:
ctr[i] += 1
break
print(ans)
| p02845 |
import sys
input = sys.stdin.readline
def main():
mod = 1000000007
N = int(eval(input()))
A = list(map(int, input().split()))
cnt = [[0, 0, 0] for i in range(N+1)]
ans = 1
for i in range(N):
a = A[i]
ans = ans * cnt[i].count(a) % mod
for j in range(3):
cnt[i+1][j] = cnt[i][j]
for j in range(3):
if cnt[i][j] == a:
cnt[i+1][j] = a+1
break
print(ans)
if __name__ == '__main__':
main()
| import sys
input = sys.stdin.readline
def main():
mod = 1000000007
N = int(eval(input()))
A = list(map(int, input().split()))
cnt = [0, 0, 0]
ans = 1
for a in A:
ans = ans * cnt.count(a) % mod
for j in range(3):
if cnt[j] == a:
cnt[j] = a+1
break
print(ans)
if __name__ == '__main__':
main()
| p02845 |
n=int(eval(input()))
a=list(map(int,input().split()))
l=[0,0,0]
mod=10**9+7
ans=1
for i in a:
l_cnt=l.count(i)
ans*=l_cnt
ans%=mod
for j in range(3):
if l[j]==i:
l[j]+=1
break
print(ans) | n=int(eval(input()))
a=list(map(int,input().split()))
l=[0,0,0]
mod=10**9+7
ans=1
for i in a:
ans*=l.count(i)
ans%=mod
for j in range(3):
if l[j]==i:
l[j]+=1
break
print(ans) | p02845 |
#!/usr/bin/env python3
#三井住友信託銀行プログラミングコンテスト2019 E
import sys
import math
from bisect import bisect_right as br
from bisect import bisect_left as bl
sys.setrecursionlimit(1000000)
from heapq import heappush, heappop,heappushpop
from collections import defaultdict
from itertools import accumulate
from collections import Counter
from collections import deque
from operator import itemgetter
from itertools import permutations
mod = 10**9 + 7
inf = float('inf')
def I(): return int(sys.stdin.readline())
def LI(): return list(map(int,sys.stdin.readline().split()))
n = I()
a = LI()
cnt = [0]*n
ans = 1
tmp = 3
for i in range(n):
if a[i] == 0:
ans *= tmp
ans %= mod
tmp -= 1
else:
ans *= cnt[a[i]-1]
ans %= mod
cnt[a[i]-1] -= 1
cnt[a[i]] += 1
print(ans) | #!/usr/bin/env python3
import sys
import math
from bisect import bisect_right as br
from bisect import bisect_left as bl
sys.setrecursionlimit(2147483647)
from heapq import heappush, heappop,heappushpop
from collections import defaultdict
from itertools import accumulate
from collections import Counter
from collections import deque
from operator import itemgetter
from itertools import permutations
mod = 10**9 + 7
inf = float('inf')
def I(): return int(sys.stdin.readline())
def LI(): return list(map(int,sys.stdin.readline().split()))
n = I()
a = LI()
ans = 1
cnt = [0] * (n+1)
for i in range(n):
if a[i] == 0:
ans *= 3 - cnt[0]
ans %= mod
else:
ans *= cnt[a[i]-1] - cnt[a[i]]
ans %= mod
cnt[a[i]] += 1
print(ans) | p02845 |
n = int(eval(input()))
a = list(map(int, input().split()))
MOD = 10**9+7
ans = 1
s = [0] * 3
for i in range(n):
ans *= len([0 for x in s if x == a[i]])
if ans == 0: break
ans %= MOD
for j in range(3):
if s[j] == a[i]:
s[j] += 1
break
print((ans % MOD))
| MOD = 10**9+7
n = int(eval(input()))
a = list(map(int, input().split()))
cnt = [0 for _ in range(n)]
ans = 1
for x in a:
if x > 0:
ans *= cnt[x-1] - cnt[x]
else:
ans *= 3 - cnt[0]
cnt[x] += 1
ans %= MOD
print(ans)
| p02845 |
def main():
import sys
N=int(eval(input()))
MOD=1000000007
a=list(map(int,input().split()))
c=[0,0,0]
ans=1
for i in range(N):
if a[i]!=c[0] and a[i]!=c[1] and a[i]!=c[2]:
print((0))
sys.exit()
if c[1]==c[0] and c[2]==c[0]:
ans=(ans*3)%MOD
c[0]+=1
elif c[0]==c[1]:
if c[0]==a[i]:
c[0]+=1
ans=(ans*2)%MOD
else:
c[2]+=1
elif c[0]>c[1] and c[1]==c[2]:
if c[0]==a[i]:
c[0]+=1
else:
ans=(ans*2)%MOD
c[1]+=1
else:
if c[0]==a[i]: c[0]+=1
if c[1]==a[i]: c[1]+=1
if c[2]==a[i]: c[2]+=1
c.sort(reverse=True)
print(ans)
if __name__ == '__main__':
main() | def main():
import sys
N=int(eval(input()))
MOD=1000000007
a=list(map(int,input().split()))
c=[3]+[0]*N
ans=1
for i in range(N):
p=a[i]
ans=ans*c[p]%MOD
c[p]-=1
c[p+1]+=1
print(ans)
if __name__ == '__main__':
main()
| p02845 |
import sys
sys.setrecursionlimit(10 ** 6)
input = sys.stdin.readline
N = int(eval(input()))
A = list(map(int, input().split(" ")))
dp = dict()
mod = 10 ** 9 + 7
def f(i, ma, mi):
if i == N:
return 1
if (i, ma, mi) in dp:
return dp[(i, ma, mi)]
if A[i] != ma and A[i] != mi and A[i] != i - ma - mi:
dp[(i, ma, mi)] = 0
return 0
ans = 0
# iがr, b, gを被って矛盾がないかを見ていく
if A[i] == ma:
ans += f(i + 1, ma + 1, mi)
if A[i] == mi:
if ma > mi + 1:
ans += f(i + 1, ma, mi + 1)
else:
ans += f(i + 1, mi + 1, ma)
if A[i] == i - ma - mi:
ans += f(i + 1, ma, mi)
dp[(i, ma, mi)] = ans % mod
return dp[(i, ma, mi)]
print((f(0, 0, 0) % mod)) | import sys
sys.setrecursionlimit(10 ** 6)
N = int(eval(input()))
A = list(map(int, input().strip().split(" ")))
dp = {i: dict() for i in range(N)}
mod = 10 ** 9 + 7
def f(i, ma, mi):
if i == N:
return 1
if (ma, mi) in dp[i]:
return dp[i][(ma, mi)]
if A[i] != ma and A[i] != mi and A[i] != i - ma - mi:
dp[i][(ma, mi)] = 0
return 0
ans = 0
# iがr, b, gを被って矛盾がないかを見ていく
if A[i] == ma:
ans += f(i + 1, ma + 1, mi)
if A[i] == mi:
if ma > mi + 1:
ans += f(i + 1, ma, mi + 1)
else:
ans += f(i + 1, mi + 1, ma)
if A[i] == i - ma - mi:
ans += f(i + 1, ma, mi)
dp[i][(ma, mi)] = ans % mod
return ans % mod
print((f(0, 0, 0) % mod)) | p02845 |
n=int(eval(input()))
l=list(map(int,input().split()))
mod=10**9+7
ans=1
rgb=[0]*3
for i in range(n):
f=0
for j in range(3):
if l[i]==rgb[j]:
if f==0:
rgb[j]+=1
f+=1
ans*=f
ans%=mod
print(ans) | mod=10**9+7
n=int(eval(input()))
l=list(map(int,input().split()))
ans=1
rgb=[0,0,0]
for i in range(n):
c=0
for j in range(3):
if l[i]==rgb[j]:
c+=1
if c==0:
print((0))
exit()
p=rgb.index(l[i])
if not 0<=p<=2:
print((0))
exit()
rgb[p]+=1
ans*=c
ans%=mod
print(ans)
| p02845 |
n=int(eval(input()))
a=list(map(int,input().split()))
d=[-1,-1,-1]
x=1
for i in a:
b=0
f=True
for j in range(3):
if d[j]==i-1:
b+=1
if f:
f=False
d[j]=i
x*=b
x%=10**9+7
print(x) | n=int(eval(input()))
d=[-1,-1,-1]
x=1
for i in list(map(int,input().split())):
x*=d.count(i-1)
x%=10**9+7
if i-1 in d:d[d.index(i-1)]+=1
print(x) | p02845 |
def main():
from collections import defaultdict
N = int(eval(input()))
A = list(map(int,input().split()))
MOD = 1000000007
c = defaultdict(int)
c[0] = 3
ans = 1
for i in range(N):
if not c[A[i]]:
print((0))
exit()
ans *= c[A[i]]
ans %= MOD
c[A[i]] -= 1
c[A[i]+1] += 1
print(ans)
main()
| def main():
N = int(eval(input()))
A = list(map(int,input().split()))
MOD = 1000000007
c = [0] * (N+1)
c[0] = 3
ans = 1
for i in range(N):
if not c[A[i]]:
print((0))
exit()
ans *= c[A[i]]
ans %= MOD
c[A[i]] -= 1
c[A[i]+1] += 1
print(ans)
main()
| p02845 |
from collections import Counter
MOD = 10**9 + 7
N = int(eval(input()))
As = list(map(int, input().split()))
ptns = Counter([(0, 0, 0)])
#print('ptns:', ptns)
for A in As:
ptn2s = Counter()
for ptn, num in list(ptns.items()):
for i in range(3):
if ptn[i] == A:
ptn2 = list(ptn)
ptn2[i] += 1
ptn2s[tuple(ptn2)] += num
ptn2s[tuple(ptn2)] %= MOD
ptns = ptn2s
#print(ptns)
print((sum(ptns.values()) % MOD))
| MOD = 10**9 + 7
N = int(eval(input()))
As = list(map(int, input().split()))
ans = 1
numRGBs = [0] * 3
for A in As:
num = 0
for i in range(3):
if numRGBs[i] == A:
num += 1
if num == 1:
numRGBs[i] += 1
ans *= num
ans %= MOD
print(ans)
| p02845 |
MOD = 10**9 + 7
class modint():
def __init__(self, value):
self.value = value % MOD
def __int__(self):
return int(self.value)
def __float__(self):
return float(self.value)
def __str__(self):
return str(self.value)
def __repr__(self):
return str(self.value)
def __add__(self, other):
return (modint(self.value + other.value) if isinstance(other, modint)
else modint(self.value + other))
def __sub__(self, other):
return (modint(self.value - other.value) if isinstance(other, modint)
else modint(self.value - other))
def __mul__(self, other):
return (modint(self.value * other.value) if isinstance(other, modint)
else modint(self.value * other))
def __truediv__(self, other):
return (modint(self.value * pow(other.value, MOD - 2, MOD))
if isinstance(other, modint)
else modint(self.value * pow(other, MOD - 2, MOD)))
def __pow__(self, other):
return (modint(pow(self.value, other.value, MOD))
if isinstance(other, modint)
else modint(pow(self.value, other, MOD)))
def __eq__(self, other):
return (self.value == other.value if isinstance(other, modint)
else self.value == (other % MOD))
def __ne__(self, other):
return (self.value == other.value if isinstance(other, modint)
else self.value == (other % MOD))
def __radd__(self, other):
return (modint(other.value + self.value) if isinstance(other, modint)
else modint(other + self.value))
def __rsub__(self, other):
return (modint(other.value - self.value) if isinstance(other, modint)
else modint(other - self.value))
def __rmul__(self, other):
return (modint(other.value * self.value) if isinstance(other, modint)
else modint(other * self.value))
def __rtruediv__(self, other):
return (modint(other.value * pow(self.value, MOD - 2, MOD))
if isinstance(other, modint)
else modint(other * pow(self.value, MOD - 2, MOD)))
def __rpow__(self, other):
return (modint(pow(other.value, self.value, MOD))
if isinstance(other, modint)
else modint(pow(other, self.value, MOD)))
def modinv(self):
return modint(pow(self.value, MOD - 2, MOD))
def main():
_ = int(input())
A = [int(i) for i in input().split()]
from collections import defaultdict
d = defaultdict(int)
ans = modint(0)
for a in A:
d[a] += 1
if (a != 0 and d[a-1] < d[a]) or 3 < d[a]:
return print(0)
if a == 0:
if d[a] == 1:
ans += 1
elif d[a] == 2:
ans *= 2
continue
if d[a] == 1:
ans *= d[a-1]
elif d[a] == 2:
ans *= d[a-1] - 1
print((ans*3))
if __name__ == '__main__':
main()
| MOD = 10**9 + 7
def main():
N = int(eval(input()))
A = [int(i) for i in input().split()]
B = [0]*N
ans = 3
for a in A:
if a == 0:
if B[a] == 1:
ans *= 2
else:
ans *= B[a-1] - B[a]
B[a] += 1
if 3 < B[a] or (a != 0 and B[a-1] < B[a]):
ans = 0
break
ans %= MOD
print(ans)
if __name__ == '__main__':
main()
| p02845 |
from collections import defaultdict,deque
import sys,heapq,bisect,math,itertools,string,queue,copy,time
sys.setrecursionlimit(10**8)
INF = float('inf')
mod = 10**9+7
eps = 10**-7
def inp(): return int(sys.stdin.readline())
def inpl(): return list(map(int, sys.stdin.readline().split()))
def inpl_str(): return list(sys.stdin.readline().split())
N = inp()
AA = inpl()
cnts = [0]*(N+1)
cnts[-1] = 3
ans = 1
for a in AA:
ans *= (cnts[a-1] - cnts[a])
ans %= mod
cnts[a] += 1
print(ans)
| c = [0]*(int(eval(input()))+1)
c[-1] = 3
ans = 1
for a in list(map(int, input().split())):
ans = (ans * (c[a-1] - c[a]))%(10**9+7)
c[a] += 1
print(ans)
| p02845 |
import itertools
import sys
from collections import Counter
sys.setrecursionlimit(10 ** 9)
M = 1000000007
N = int(sys.stdin.readline())
left = list(map(int, sys.stdin.read().split()))
counter = Counter(left)
def dp(t, ns):
cached = t.get(ns)
if cached is not None:
return cached
remaining = sum(ns)
assert remaining > 0
last_cnt = left[remaining - 1] + 1
n1, n2, n3 = ns
res = 0
if last_cnt == n1:
res += dp(t, tuple(sorted([n1 - 1, n2, n3])))
res %= M
if last_cnt == n2:
res += dp(t, tuple(sorted([n1, n2 - 1, n3])))
res %= M
if last_cnt == n3:
res += dp(t, tuple(sorted([n1, n2, n3 - 1])))
res %= M
# print(f"{remaining}: ({n1},{n2},{n3}) => {res}")
t[ns] = res
return res
def solve():
h = [0, 0, 0]
for i in range(N):
k = counter[i]
if k == 3:
h[0] = h[1] = h[2] = i + 1
elif k == 2:
h[0] = h[1] = i + 1
elif k == 1:
h[0] = i + 1
else:
break
if sum(h) != N:
return 0
t = dict()
t[0, 0, 0] = 1
res = dp(t, tuple(sorted(h)))
return (res * len(set(itertools.permutations(h)))) % M
print((solve()))
| M = 1000000007
N = int(eval(input()))
left = list(map(int, input().split()))
def solve():
res = 1
h = [0, 0, 0]
for i in range(N):
k = h.count(left[i])
res = res * k % M
for j in range(3):
if h[j] == left[i]:
h[j] += 1
break
return res
print((solve()))
| p02845 |
N = int(eval(input()))
A = list(map(int, input().split()))
result = 1
t = [0, 0, 0]
for i in range(N):
a = A[i]
f = -1
k = 0
for j in range(3):
if t[j] == a:
k += 1
if f == -1:
t[j] += 1
f = j
result = (result * k) % 1000000007
print(result)
| N = int(eval(input()))
A = list(map(int, input().split()))
m = 1000000007
result = 1
t = [0, 0, 0]
for i in range(N):
a = A[i]
f = -1
k = 0
for j in range(3):
if t[j] == a:
k += 1
if f == -1:
t[j] += 1
f = j
result *= k
result %= m
print(result)
| p02845 |
N = int(eval(input()))
A = list(map(int, input().split()))
MOD = 10**9+7
ans = 1
dp = [0]*3
for a in A:
cnt = 0
for i in range(3):
if a == dp[i]:
cnt += 1
for i in range(3):
if a == dp[i]:
dp[i] += 1
break
ans = ans*cnt % MOD
print(ans)
| N = int(eval(input()))
A = list(map(int, input().split()))
MOD = 10**9+7
ans = 1
dp = [0]*3
for a in A:
ans = ans*dp.count(a) % MOD
try:
dp[dp.index(a)] += 1
except ValueError:
break
print(ans)
| p02845 |
n = int(eval(input()))
A = list(map(int, input().split()))
mod = 10**9 + 7
ans = 3
hats = [1, 0, 0]
if n == 1:
if A[0] == 0:
print((3))
else:
print((0))
exit()
if A[0] != 0:
print((0))
exit()
for a in A[1:]:
count = hats.count(a)
if count == 0:
print((0))
exit()
idx = hats.index(a)
hats[idx] += 1
ans *= count
ans %= mod
print(ans) | n = int(eval(input()))
A = list(map(int, input().split()))
mod = 10**9 + 7
ans = 1
hats = [0, 0, 0]
for a in A:
count = hats.count(a)
if count == 0:
print((0))
exit()
idx = hats.index(a)
hats[idx] += 1
ans *= count
ans %= mod
print(ans) | p02845 |
n = int(eval(input()))
A = list(map(int, input().split()))
mod = 10**9 + 7
ans = 1
hats = [0, 0, 0]
for a in A:
count = hats.count(a)
if count == 0:
print((0))
exit()
idx = hats.index(a)
hats[idx] += 1
ans *= count
ans %= mod
print(ans) | import sys
input = sys.stdin.readline
mod = 10**9 + 7
def main():
n = int(eval(input()))
A = list(map(int, input().split()))
candidates = [0] * (n+1)
candidates[0] = 3
ans = 1
for a in A:
ans *= candidates[a]
ans %= mod
candidates[a] -= 1
candidates[a+1] += 1
print(ans)
if __name__ == "__main__":
main()
| p02845 |
import sys
read = sys.stdin.buffer.read
input = sys.stdin.buffer.readline
inputs = sys.stdin.buffer.readlines
# rstrip().decode('utf-8')
# INF=float("inf")
MOD=10**9+7
# sys.setrecursionlimit(2147483647)
# import math
#import numpy as np
# import operator
import bisect
# from heapq import heapify,heappop,heappush
#from math import gcd
# from fractions import gcd
#from collections import deque
#from collections import defaultdict
# from collections import Counter
#from itertools import accumulate
# from itertools import groupby
# from itertools import permutations
# from itertools import combinations
# from scipy.sparse import csr_matrix
# from scipy.sparse.csgraph import floyd_warshall
# from scipy.sparse.csgraph import csgraph_from_dense
# from scipy.sparse.csgraph import dijkstra
# map(int,input().split())
def main():
n,*a=list(map(int,read().split()))
aa=max(a)
li=[[] for _ in range(aa+1)]
for i in range(n):
li[a[i]].append(i)
if len(li[0])>3 or len(li[0])==0:
print((0))
exit(0)
else:
ans=3 if len(li[0])==1 else 6
for i in range(1,aa+1):
if len(li[i])>3 or len(li[i])==0 or len(li[i])>len(li[i-1]):
print((0))
exit(0)
else:
k=bisect.bisect_right(li[i-1],li[i][0])
ans*=k
ans%=MOD
if len(li[i])>1:
k=bisect.bisect_right(li[i-1],li[i][1])-1
ans *= k
ans %= MOD
print(ans)
if __name__ == "__main__":
main()
| import sys
read = sys.stdin.buffer.read
input = sys.stdin.readline
input = sys.stdin.buffer.readline
#sys.setrecursionlimit(10**9)
#from functools import lru_cache
def RD(): return sys.stdin.read()
def II(): return int(eval(input()))
def MI(): return list(map(int,input().split()))
def MF(): return list(map(float,input().split()))
def LI(): return list(map(int,input().split()))
def LF(): return list(map(float,input().split()))
def TI(): return tuple(map(int,input().split()))
# rstrip().decode('utf-8')
#2234
#import numpy as np
def main():
n=II()
A=LI()
ans=1
mod=10**9+7
li=[3]+[0]*(n+1)
for i in A:
ans*=li[i]-li[i+1]
ans%=mod
li[i+1]+=1
print(ans)
if __name__ == "__main__":
main() | p02845 |
import sys
INF = 10 ** 15
MOD = 10 ** 9 + 7
sys.setrecursionlimit(100000000)
input = sys.stdin.readline
from math import pi
from functools import lru_cache
def main():
n = int(eval(input()))
num = list(map(int,input().split()))
@lru_cache(maxsize = None)
def dfs(a,b,c):
if a + b + c == n:
return 1
ans = 0
if num[a + b + c] == a:
ans += dfs(a + 1,b,c)
ans %= MOD
if num[a + b + c] == b:
ans += dfs(a,b + 1,c)
ans %= MOD
if num[a + b + c] == c:
ans += dfs(a,b,c + 1)
ans %= MOD
return ans
print((dfs(0,0,0)))
if __name__ =='__main__':
main() | MOD = 10 ** 9 + 7
INF = 10 ** 10
import sys
sys.setrecursionlimit(100000000)
dy = (-1,0,1,0)
dx = (0,1,0,-1)
ans = 1
def dfs(i,x,y,z,a,n):
global ans
if i == n:
return
if x == y == z == a[i]:
ans *= 3
ans %= MOD
dfs(i + 1,x + 1,y,z,a,n)
elif x == y == a[i]:
ans *= 2
ans %= MOD
dfs(i + 1,x + 1,y,z,a,n)
elif y == z == a[i]:
ans *= 2
ans %= MOD
dfs(i + 1,x,y + 1,z,a,n)
elif x == a[i]:
dfs(i + 1,x + 1,y,z,a,n)
elif y == a[i]:
dfs(i + 1,x,y + 1,z,a,n)
elif z == a[i]:
dfs(i + 1,x,y,z + 1,a,n)
else:
ans = 0
return
def main():
n = int(eval(input()))
a = list(map(int,input().split()))
dfs(0,0,0,0,a,n)
print(ans)
if __name__ =='__main__':
main()
| p02845 |
MOD = 10 ** 9 + 7
INF = 10 ** 10
import sys
sys.setrecursionlimit(100000000)
dy = (-1,0,1,0)
dx = (0,1,0,-1)
ans = 1
def dfs(i,x,y,z,a,n):
global ans
if i == n:
return
if x == y == z == a[i]:
ans *= 3
ans %= MOD
dfs(i + 1,x + 1,y,z,a,n)
elif x == y == a[i]:
ans *= 2
ans %= MOD
dfs(i + 1,x + 1,y,z,a,n)
elif y == z == a[i]:
ans *= 2
ans %= MOD
dfs(i + 1,x,y + 1,z,a,n)
elif x == a[i]:
dfs(i + 1,x + 1,y,z,a,n)
elif y == a[i]:
dfs(i + 1,x,y + 1,z,a,n)
elif z == a[i]:
dfs(i + 1,x,y,z + 1,a,n)
else:
ans = 0
return
def main():
n = int(eval(input()))
a = list(map(int,input().split()))
dfs(0,0,0,0,a,n)
print(ans)
if __name__ =='__main__':
main()
| MOD = 10 ** 9 + 7
INF = 10 ** 10
import sys
sys.setrecursionlimit(100000000)
dy = (-1,0,1,0)
dx = (0,1,0,-1)
def main():
n = int(eval(input()))
a = list(map(int,input().split()))
cnt = [0] * (n + 1)
cnt[0] = 3
ans = 1
for num in a:
ans *= cnt[num]
ans %= MOD
cnt[num] -= 1
cnt[num + 1] += 1
print(ans)
if __name__ =='__main__':
main()
| p02845 |
import sys
input = sys.stdin.readline
n = int(eval(input()))
a = list(map(int, input().split()))
rbg = [-1, -1, -1]
ans = 1
mod = 10 ** 9 + 7
for A in a:
ans *= rbg.count(A - 1)
ans %= mod
for i in range(3):
if rbg[i] == A - 1:
rbg[i] = A
break
print(ans)
| import sys
read = sys.stdin.buffer.read
readline = sys.stdin.buffer.readline
readlines = sys.stdin.buffer.readlines
sys.setrecursionlimit(10 ** 7)
n, *a = list(map(int, read().split()))
ans = 1
mod = 10 ** 9 + 7
memo = [0, 0, 0]
for check in a:
if check in memo:
ans *= memo.count(check)
ans %= mod
memo[memo.index(check)] += 1
else:
print((0))
exit()
print(ans)
| p02845 |
import sys,queue,math,copy
sys.setrecursionlimit(10**7)
input = sys.stdin.readline
INF = 10**18
MOD = 10**9 + 7
LI = lambda : [int(x) for x in input().split()]
_LI = lambda : [int(x)-1 for x in input().split()]
N = int(eval(input()))
A = LI()
c =[0,0,0]
cnt = [0 for _ in range(N)]
for i in range(N):
cnt[i] = c.count(A[i])
if cnt[i] == 0:
print((0))
exit (0)
for j in range(3):
if c[j] == A[i]:
c[j] += 1
break
ans = 1
for i in range(N):
ans = (ans * cnt[i]) % MOD
print (ans) | import sys,queue,math,copy
input = sys.stdin.readline
MOD = 10**9 + 7
LI = lambda : [int(x) for x in input().split()]
N = int(eval(input()))
A = LI()
c =[0,0,0]
cnt = [0 for _ in range(N)]
for i in range(N):
cnt[i] = c.count(A[i])
if cnt[i] == 0: break
c[c.index(A[i])] += 1
ans = 1
for i in range(N):
ans = (ans * cnt[i]) % MOD
print (ans) | p02845 |
N = int(eval(input()))
A = list(map(int, input().split()))
c = [-1, -1 ,-1]
sum = 1
tmp = 0
for i in range(N):
sum = sum * c.count(A[i]-1) % 1000000007
if (A[i]-1) == c[0]:
c[0] += 1
tmp = c.count(c[0] - 1) + 1
elif (A[i]-1) == c[1]:
c[1] += 1
tmp = c.count(c[1]-1) + 1
elif (A[i]-1) == c[2]:
c[2] += 1
tmp = c.count(c[2] - 1) + 1
print(sum)
| N = int(eval(input()))
A = list(map(int, input().split()))
c = [-1, -1 ,-1]
sum = 1
tmp = 0
for a in A:
sum = sum * c.count(a-1) % 1000000007
if a-1 == c[0]:
c[0] += 1
tmp = c.count(c[0] - 1) + 1
elif a-1 == c[1]:
c[1] += 1
tmp = c.count(c[1]-1) + 1
elif a-1 == c[2]:
c[2] += 1
tmp = c.count(c[2] - 1) + 1
print(sum)
| p02845 |
def main():
MOD = 10 ** 9 + 7
N = int(eval(input()))
A = list(map(int, input().split()))
ans = 1
d = [0] * (max(A) + 1)
for a in A:
if a == 0:
ans *= 3 - d[a]
ans %= MOD
d[a] += 1
else:
ans *= d[a-1] - d[a]
d[a] += 1
ans %= MOD
print(ans)
if __name__ == "__main__":
main() | def main():
N = int(eval(input()))
A = list(map(int, input().split()))
MOD = 10 ** 9 + 7
ans = 1
cnt = [0] * (N + 1)
for i in range(N):
if A[i] == 0:
ans *= 3 - cnt[A[i]]
cnt[A[i]] += 1
else:
ans *= cnt[A[i]-1] - cnt[A[i]]
cnt[A[i]] += 1
ans %= MOD
print(ans)
if __name__ == "__main__":
main() | p02845 |
n = int(eval(input()))
a = list(map(int, input().split()))
mod = 10 ** 9 + 7
ans = 1
cnt = [0, 0, 0]
for i in range(n):
ans *= cnt.count(a[i])
if a[i] not in cnt:
print((0))
exit()
ind = cnt.index(a[i])
cnt[ind] += 1
print((ans % mod)) | n = int(eval(input()))
a = list(map(int, input().split()))
mod = 10 ** 9 + 7
ans = 1
cnt = [0, 0, 0]
for i in a:
ans *= cnt.count(i)
ans %= mod
if i not in cnt:
print((0))
exit()
ind = cnt.index(i)
cnt[ind] += 1
print(ans) | p02845 |
MOD = 10**9+7
n = int(eval(input()))
A = list(map(int, input().split()))
colors = [0]*3
dp = [0]*n
for i in range(n):
c = colors.count(A[i])
dp[i] = c
if c == 0:
break
colors[colors.index(A[i])] += 1
ans = 1
for x in dp:
ans = ans*x % MOD
print((ans % MOD))
| MOD = 10**9+7
n = int(eval(input()))
A = list(map(int, input().split()))
colors = [0]*3
ans = 1
for i in range(n):
c = colors.count(A[i])
ans = ans*c % MOD
if c == 0:
break
colors[colors.index(A[i])] += 1
print((ans % MOD)) | p02845 |
import sys
def input(): return sys.stdin.readline().rstrip()
from collections import Counter
def main():
n=int(eval(input()))
A=list(map(int,input().split()))
rgb=[-1,-1,-1]
ans=1
mod=10**9+7
for a in A:
ans=ans*Counter(rgb)[a-1]%mod
if ans==0:break
rgb[rgb.index(a-1)]+=1
print(ans)
if __name__=='__main__':
main() | import sys
def input(): return sys.stdin.readline().rstrip()
def main():
n=int(eval(input()))
A=list(map(int,input().split()))
cunt=[0]*(n+1)
cunt[0]=3
ans=1
mod=10**9+7
for a in A:
ans=ans*cunt[a]%mod
if ans==0:break
cunt[a+1]+=1
cunt[a]-=1
print(ans)
if __name__=='__main__':
main() | p02845 |
N = int(eval(input()))
A = list(map(int, input().split()))
mod = 1000000007
colors = [0,0,0]
ans = 1
for i in range(N):
ans = (ans * colors.count(A[i])) % mod
for j in range(3):
if colors[j] == A[i]:
colors[j] += 1
break
print(ans) | N = int(eval(input()))
A = list(map(int, input().split()))
mod = 10**9+7
RGB = [0, 0, 0]
ans = 1
for i in range(N):
cnt = RGB.count(A[i])
ans = (ans * cnt) % mod
for j in range(3):
if A[i] == RGB[j]:
RGB[j] += 1
break
print(ans)
| p02845 |
N = int(eval(input()))
A = list(map(int, input().split()))
MOD = 1_000_000_007
cnt = [0, 0, 0]
ans = 1
for i in range(N):
ans *= sum(c == A[i] for c in cnt)
ans %= MOD
for j in range(3):
if cnt[j] == A[i]:
cnt[j] += 1
break
print(ans)
| N, *A = list(map(int, open(0).read().split()))
MOD = 1_000_000_007
cnt = [0, 0, 0]
ans = 1
for a in A:
possible = sum(c == a for c in cnt)
ans *= possible
ans %= MOD
for i in range(3):
if cnt[i] == a:
cnt[i] += 1
break
print(ans)
| p02845 |
mod = 10**9+7
def main():
ans =1
n = int(eval(input()))
arr = list(map(int , input().split()))
col=[0 for i in range(0 , 6)]
for i in range(0 , n):
cnt , cur =0 , -1
if arr[i]==col[0]:
cnt = cnt+1
cur = 0
if arr[i]==col[1]:
cnt = cnt+1
cur = 1
if arr[i]==col[2]:
cnt = cnt+1
cur = 2
if cur ==-1:
print((0))
exit()
col[cur]=col[cur]+1
ans = (ans*cnt)%mod
ans = ans%mod
print(ans)
if __name__ =="__main__":
main() | # similar to problem if n person are arranged in a row and have 3 different hats to wear
# no of ways of wearing hats so that every adjacent person wears different hats
# so ith person cannot wear more than 3 no of different ways
mod = 10**9+7
def main():
ans =1
n = int(eval(input()))
arr = list(map(int , input().split()))
col=[0 for i in range(0 , 6)]
for i in range(0 , n):
cnt , cur =0 , -1
if arr[i]==col[0]:
cnt = cnt+1
cur = 0
if arr[i]==col[1]:
cnt = cnt+1
cur = 1
if arr[i]==col[2]:
cnt = cnt+1
cur = 2
if cur ==-1:
print((0))
exit()
col[cur]=col[cur]+1
ans = (ans*cnt)%mod
ans = ans%mod
print(ans)
if __name__ =="__main__":
main() | p02845 |
import sys
read = sys.stdin.read
N, *A = list(map(int, read().split()))
mod = 10 ** 9 + 7
hats = [[0] * 3 for _ in range(N + 1)]
answer = 1
for i in range(N):
answer *= hats[i].count(A[i])
answer %= mod
flag = True
for j in range(3):
if hats[i][j] == A[i] and flag:
hats[i + 1][j] = A[i] + 1
flag = False
else:
hats[i + 1][j] = hats[i][j]
print(answer) | import sys
read = sys.stdin.read
N, *A = list(map(int, read().split()))
mod = 10 ** 9 + 7
hats = [0] * 3
answer = 1
for i in range(N):
answer *= hats.count(A[i])
answer %= mod
for j in range(3):
if hats[j] == A[i]:
hats[j] += 1
break
print(answer) | p02845 |
import copy
n = int(eval(input()))
a = list(map(int,input().split()))
dp = [[0,0,0] for _ in range(n+1)]
mod = 10**9+7
ans = 1
for i in range(1,n+1):
dp[i] = copy.copy(dp[i-1])
for j in range(3):
if dp[i-1][j] == a[i-1]:
dp[i][j] += 1
break
dp[i].sort(reverse=True)
for i in range(n):
ans = ans*dp[i].count(a[i])%mod
print(ans) | n = int(eval(input()))
a = list(map(int,input().split()))
mod = 10**9+7
dp = [[0]*3 for _ in range(n+1)]
ans = 1
for i in range(n):
ans *= dp[i].count(a[i])
ans %= mod
for j in range(3):
dp[i+1][j] = dp[i][j]
if dp[i][j] == a[i]:
dp[i+1][j] += 1
a[i] = -1
print(ans) | p02845 |
import sys
read = sys.stdin.read
readline = sys.stdin.readline
readlines = sys.stdin.readlines
sys.setrecursionlimit(10 ** 9)
INF = 1 << 60
def main():
MOD = 1000000007
N, *A = list(map(int, read().split()))
C = [0] * (N + 1)
C[0] = 3
ans = 1
for a in A:
ans = ans * C[a] % MOD
C[a] -= 1
C[a + 1] += 1
print(ans)
return
if __name__ == '__main__':
main()
| def main():
import sys
MOD = 1000000007
N, *A = list(map(int, sys.stdin.buffer.read().split()))
C = [0] * (N + 1)
C[0] = 3
ans = 1
for a in A:
ans = ans * C[a] % MOD
C[a] -= 1
C[a + 1] += 1
print(ans)
return
if __name__ == '__main__':
main()
| p02845 |
def main():
import sys
MOD = 1000000007
N, *A = list(map(int, sys.stdin.buffer.read().split()))
C = [0] * (N + 1)
C[0] = 3
ans = 1
for a in A:
ans = ans * C[a]
C[a] -= 1
C[a + 1] += 1
print((ans % MOD))
return
if __name__ == '__main__':
main()
| import sys
read = sys.stdin.read
readline = sys.stdin.readline
readlines = sys.stdin.readlines
sys.setrecursionlimit(10 ** 9)
INF = 1 << 60
def main():
MOD = 1000000007
N, *A = list(map(int, read().split()))
ans = 1
C = [0, 0, 0]
for a in A:
try:
ans = (ans * C.count(a)) % MOD
C[C.index(a)] += 1
except ValueError:
print((0))
return
print(ans)
return
if __name__ == '__main__':
main()
| p02845 |
import sys
read = sys.stdin.read
readline = sys.stdin.readline
readlines = sys.stdin.readlines
sys.setrecursionlimit(10 ** 9)
INF = 1 << 60
def main():
MOD = 1000000007
N, *A = list(map(int, read().split()))
ans = 1
C = [0, 0, 0]
for a in A:
try:
ans = (ans * C.count(a)) % MOD
C[C.index(a)] += 1
except ValueError:
print((0))
return
print(ans)
return
if __name__ == '__main__':
main()
| import sys
read = sys.stdin.read
readline = sys.stdin.readline
readlines = sys.stdin.readlines
sys.setrecursionlimit(10 ** 9)
INF = 1 << 60
def main():
MOD = 1000000007
N, *A = list(map(int, read().split()))
ans = 1
C = [0] * (N + 1)
C[0] = 3
for a in A:
ans = ans * C[a] % MOD
C[a] -= 1
C[a + 1] += 1
print(ans)
return
if __name__ == '__main__':
main()
| p02845 |
n=int(eval(input()))
A=[int(i) for i in input().split()]
mod=10**9+7
ans=1
B=[0,0,0]
for i in range(n):
ct=0
chk=False
for j in range(3):
if B[j]==A[i]:
ct+=1
if not chk:
B[j]+=1
chk=True
ans=(ans*ct)%mod
print(ans)
| import sys
input=lambda: sys.stdin.readline().rstrip()
n=int(eval(input()))
A=[int(i) for i in input().split()]
ans=1
mod=10**9+7
C=[0,0,0]
for i in range(n):
cur=A[i]
ct=0
Chk=True
for i,c in enumerate(C):
if cur==c:
ct+=1
if Chk:
C[i]+=1
Chk=False
ans=(ans*ct)%mod
print(ans)
| p02845 |
# coding: utf-8
# hello worldと表示する
#float型を許すな
#numpyはpythonで
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,factorial
from operator import itemgetter
def I(): return int(eval(input()))
def MI(): return list(map(int, input().split()))
def LI(): return list(map(int, input().split()))
def LI2(): return [int(eval(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
n=I()
lis=list(SI())
#s="".join(list(map(str,lis)))
#print(s)
#sys.exit()
#print(lis)
#sys.exit()
orig=0
for i in range(n):
if lis[i]=="0":
lis[i]=0
else:
lis[i]=1
orcount=sum(lis)
beki=[1 for i in range(n+1)]
for i in range(n):
beki[i+1]=beki[i]*2
#print(beki)
#print(lis)
for i in range(n):
j=n-i-1
if lis[i]==1:
orig+=beki[j]
#print(orig)
dp=[0 for i in range(n+1)]
dp[1]=1
for i in range(1,n):
#u=count1(i+1)
count=0
j=0
while beki[j]<=i+1:
if ((i+1)>>j) %2==1:
count+=1
j+=1
z=1
dp[i+1]=z+dp[(i+1)%count]
#print(dp)
for i in range(n):
if lis[i]==0:
num=orig+beki[n-i-1]
pr=orcount+1
else:
num=orig-beki[n-i-1]
pr=orcount-1
#print(num,pr)
if pr==0:
print((0))
else:
print((1+dp[num%pr])) | # coding: utf-8
# hello worldと表示する
#float型を許すな
#numpyはpythonで
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,factorial
from operator import itemgetter
def I(): return int(eval(input()))
def MI(): return list(map(int, input().split()))
def LI(): return list(map(int, input().split()))
def LI2(): return [int(eval(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
n=I()
lis=list(SI())
#s="".join(list(map(str,lis)))
#print(s)
#sys.exit()
#print(lis)
#sys.exit()
orig=0
for i in range(n):
if lis[i]=="0":
lis[i]=0
else:
lis[i]=1
orcount=sum(lis)
#beki=[1 for i in range(n+1)]
#for i in range(n):
#beki[i+1]=beki[i]*2
#print(beki)
#print(lis)
for i in range(n):
j=n-i-1
if lis[i]==1:
orig+=pow(2,j)
#print(orig)
dp=[0 for i in range(n+1)]
dp[1]=1
for i in range(1,n):
#u=count1(i+1)
count=0
j=0
while pow(2,j)<=i+1:
if ((i+1)>>j) %2==1:
count+=1
j+=1
z=1
dp[i+1]=z+dp[(i+1)%count]
#print(dp)
for i in range(n):
if lis[i]==0:
num=orig+pow(2,n-i-1)
pr=orcount+1
else:
num=orig-pow(2,n-i-1)
pr=orcount-1
#print(num,pr)
if pr==0:
print((0))
else:
print((1+dp[num%pr]))
| p02609 |
from sys import exit
from collections import defaultdict
n,x = open(0).read().split()
n = int(n)
x = int(x, 2)
x = x^(2**(n-1))
d = defaultdict(int)
d[0] = 0
def calc(m):
if m not in d:
nxt = m % bin(m).count('1')
d[m] = calc(nxt) + 1
return d[m]
if n == 1:
print((calc(x)))
exit()
mask = 3 << (n-2)
while 1:
print((calc(x)))
x ^= mask
if mask < 3:
break
mask //= 2 | from sys import exit
from collections import defaultdict
n,x = open(0).read().split()
n = int(n)
cnt = x.count('1')
digits = list(map(int, list(x)))
x = int(x, 2)
d = defaultdict(int)
d[0] = 0
def calc(m):
if m not in d:
nxt = m % bin(m).count('1')
d[m] = calc(nxt) + 1
return d[m]
if n == 1:
print((calc(x^1)))
exit()
mmod = cnt - 1
pmod = cnt + 1
if mmod > 0:
mx = x % mmod
px = x % pmod
mbase = 1
pbase = 1
ans = []
while digits:
digit = digits.pop()
if digit and mmod <= 0:
ans.append(0)
else:
if digit:
nx = (mx - mbase)%mmod
else:
nx = (px + pbase)%pmod
ans.append(calc(nx) + 1)
if mmod > 0:
mbase = (mbase * 2) % mmod
pbase = (pbase * 2) % pmod
while ans:
print((ans.pop())) | p02609 |
import sys
sys.setrecursionlimit(10 ** 8)
input = sys.stdin.readline
def binbin(binn):
return bin(binn).count("1")
def popcount(n):
if n == 0:
return 0
return 1 + popcount(n % binbin(n))
def main():
N = int(eval(input()))
X = input().strip()
x1 = 0
xc = binbin(int(X, 2))
if xc == 1:
x2 = -1
else:
x2 = 0
for i in range(N):
if X[-1 - i] == '1':
x1 += pow(2, i, xc + 1)
if x2 != -1:
x2 += pow(2, i, xc - 1)
for i in range(N):
if X[i] == '0':
print((1 + popcount((x1 + pow(2, N - i - 1, xc + 1)) % (xc + 1))))
else:
if x2 == -1:
print((0))
else:
print((1 + popcount((x2 - pow(2, N - i - 1, xc - 1) + xc - 1) % (xc - 1))))
if __name__ == '__main__':
main()
| import sys
sys.setrecursionlimit(10 ** 8)
input = sys.stdin.readline
def popcount(n):
if n == 0:
return 0
return 1 + popcount(n % bin(n).count("1"))
def main():
N = int(eval(input()))
X = input().strip()
x1 = 0
xc = bin(int(X, 2)).count("1")
if xc == 1:
x2 = -1
else:
x2 = 0
for i in range(N):
if X[-1 - i] == '1':
x1 += pow(2, i, xc + 1)
if x2 != -1:
x2 += pow(2, i, xc - 1)
for i in range(N):
if X[i] == '0':
print((1 + popcount((x1 + pow(2, N - i - 1, xc + 1)) % (xc + 1))))
else:
if x2 == -1:
print((0))
else:
print((1 + popcount((x2 - pow(2, N - i - 1, xc - 1) + xc - 1) % (xc - 1))))
if __name__ == '__main__':
main()
| p02609 |
import sys
sys.setrecursionlimit(10**7)
def I(): return int(sys.stdin.readline().rstrip())
def LI(): return list(map(int,sys.stdin.readline().rstrip().split())) #空白あり
def LI2(): return list(map(int,sys.stdin.readline().rstrip())) #空白なし
def S(): return sys.stdin.readline().rstrip()
def LS(): return list(sys.stdin.readline().rstrip().split()) #空白あり
def LS2(): return list(sys.stdin.readline().rstrip()) #空白なし
N = I()
A = [0]
for i in range(1,2*10**5):
a = 0
r = i
for j in range(18):
a += (i>>j)&1
r %= a
if r == 0:
A.append(1)
else:
A.append(1+A[r])
X = LS2()
b = 0
for i in range(N):
if X[i] == '1':
b += 1
if b >= 2:
c = b-1
d = b+1
r1 = 0
r2 = 0
for i in range(N):
if X[i] == '1':
r1 += pow(2,N-i-1)
r1 %= c
r2 += pow(2,N-i-1)
r2 %= d
ANS = []
for i in range(N):
if X[i] == '1':
e = r1
e -= pow(2,N-i-1)
e %= c
ANS.append(A[e]+1)
else:
f = r2
f += pow(2,N-i-1)
f %= d
ANS.append(A[f]+1)
else:
d = b + 1
r2 = 0
for i in range(N):
if X[i] == '1':
r2 += pow(2, N - i - 1)
r2 %= d
ANS = []
for i in range(N):
if X[i] == '1':
ANS.append(0)
else:
f = r2
f += pow(2, N - i - 1)
f %= d
ANS.append(A[f] + 1)
print(*ANS,sep='\n')
| import sys
sys.setrecursionlimit(10**7)
def I(): return int(sys.stdin.readline().rstrip())
def LI(): return list(map(int,sys.stdin.readline().rstrip().split())) #空白あり
def LI2(): return list(map(int,sys.stdin.readline().rstrip())) #空白なし
def S(): return sys.stdin.readline().rstrip()
def LS(): return list(sys.stdin.readline().rstrip().split()) #空白あり
def LS2(): return list(sys.stdin.readline().rstrip()) #空白なし
N = I()
A = [0]
for i in range(1,2*10**5):
a = 0
r = i
for j in range(18):
a += (i>>j)&1
r %= a
if r == 0:
A.append(1)
else:
A.append(1+A[r])
X = LS2()
b = 0
for i in range(N):
if X[i] == '1':
b += 1
if b >= 2:
c = b-1
d = b+1
r1 = 0
r2 = 0
amari1 = [1]
amari2 = [1]
for i in range(1,N):
amari1.append((amari1[-1]*2) % c)
amari2.append((amari2[-1]*2) % d)
amari1.reverse()
amari2.reverse()
for i in range(N):
if X[i] == '1':
r1 += amari1[i]
r1 %= c
r2 += amari2[i]
r2 %= d
ANS = []
for i in range(N):
if X[i] == '1':
e = r1
e -= amari1[i]
e %= c
ANS.append(A[e]+1)
else:
f = r2
f += amari2[i]
f %= d
ANS.append(A[f]+1)
else:
d = b + 1
r2 = 0
amari2 = [1]
for i in range(1, N):
amari2.append((amari2[-1] * 2) % d)
amari2.reverse()
for i in range(N):
if X[i] == '1':
r2 += amari2[i]
r2 %= d
ANS = []
for i in range(N):
if X[i] == '1':
ANS.append(0)
else:
f = r2
f += amari2[i]
f %= d
ANS.append(A[f] + 1)
print(*ANS,sep='\n')
| p02609 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.