Problem:


Score : 200 points

Problem Statement

We have a bingo card with a 3\times3 grid. The square at the i-th row from the top and the j-th column from the left contains the number A_{i, j}.

The MC will choose N numbers, b_1, b_2, \cdots, b_N. If our bingo sheet contains some of those numbers, we will mark them on our sheet.

Determine whether we will have a bingo when the N numbers are chosen, that is, the sheet will contain three marked numbers in a row, column, or diagonal.

Constraints

All values in input are integers.

1 \leq A_{i, j} \leq 100

A_{i_1, j_1} \neq A_{i_2, j_2} ((i_1, j_1) \neq (i_2, j_2))

1 \leq N \leq 10

1 \leq b_i \leq 100

b_i \neq b_j (i \neq j)

Input

Input is given from Standard Input in the following format:

A_{1, 1} A_{1, 2} A_{1, 3}
A_{2, 1} A_{2, 2} A_{2, 3}
A_{3, 1} A_{3, 2} A_{3, 3}
N
b_1
\vdots
b_N

Output

If we will have a bingo, print Yes; otherwise, print No.

Sample Input 1

84 97 66
79 89 11
61 59 7
7
89
7
87
79
24
84
30

Sample Output 1

Yes

We will mark A_{1, 1}, A_{2, 1}, A_{2, 2}, A_{3, 3}, and complete the diagonal from the top-left to the bottom-right.

Sample Input 2

41 7 46
26 89 2
78 92 8
5
6
45
16
57
17

Sample Output 2

No

We will mark nothing.

Sample Input 3

60 88 34
92 41 43
65 73 48
10
60
43
88
11
48
73
65
41
92
34

Sample Output 3

Yes

We will mark all the squares.



Sample input:
84 97 66
79 89 11
61 59 7
7
89
7
87
79
24
84
30


Sample output:
Yes

Submission status: Accepted

Solution code:
a = []
for i in range(3):
    a.append(tuple(map(int, input().split( ))))
a2 = [[0]*3 for _ in range(3)]
n = int(input())
b = [int(input()) for _ in range(n)]

for i in range(n):
    for j in range(3):
        for k in range(3):
            if a[j][k]==b[i]:
                a2[j][k]=1
for i in range(3):
    flag = True
    for j in range(3):
        if a2[i][j]==0:
            flag = False
            break
    if flag:
        print("Yes")
        exit()
for j in range(3):
    flag = True
    for i in range(3):
        if a2[i][j]==0:
            flag = False
            break
    if flag:
        print("Yes")
        exit()
if a2[0][0]==1 and a2[1][1]==1 and a2[2][2]==1:
    print("Yes")
    exit()
if a2[0][2]==1 and a2[1][1]==1 and a2[2][0]==1:
    print("Yes")
    exit()
print("No")

Submission status: Accepted

Solution code:
a = [list(map(int, input().split())) for _ in range(3)]
n = int(input())
b = [int(input()) for _ in range(n)]
used = [[0]*3 for _ in range(3)]
for i in range(3):
  for j in range(3):
    for k in range(n):
      if a[i][j] == b[k]:
        used[i][j] = 1 

for i in range(3):
  if sum(used[i]) == 3:
    print('Yes')
    exit()

if used[0][0] + used[1][0] + used[2][0] == 3:
  print('Yes')
  exit()
if used[0][1] + used[1][1] + used[2][1] == 3:
  print('Yes')
  exit()
if used[0][2] + used[1][2] + used[2][2] == 3:
  print('Yes')
  exit()

if used[0][0] + used[1][1] + used[2][2] == 3:
  print('Yes')
  exit()
if used[0][2] + used[1][1] + used[2][0] == 3:
  print('Yes')
  exit()

  
print('No')

Submission status: Accepted

Solution code:
a = [list(map(int, input().split())) for _ in range(3)]
n = int(input())
b = [int(input()) for _ in range(n)]

for i in range(3):
    for j in range(3):
        if a[i][j] in b:
            a[i][j] = 0

#for x in a:
#    print(x)

for i in range(3):
    if sum(a[i]) == 0:
        print('Yes')
        exit()
    elif a[0][i] + a[1][i] + a[2][i] == 0:
        print('Yes')
        exit()
    elif a[0][0] + a[1][1] + a[2][2] == 0:
        print('Yes')
        exit()
    elif a[0][2] + a[1][1] + a[2][0] == 0:
        print('Yes')
        exit()

print('No')

Submission status: Accepted

Solution code:
a = [list(map(int, input().split())) for _ in range(3)]
n = int(input())
b = [int(input()) for _ in range(n)]

hit = [[0] * 3 for _ in range(3)]

for e in b:
    for i in range(3):
        for j in range(3):
            if a[i][j] == e:
                hit[i][j] = 1

bl = False
for i in range(3):
    if hit[i][0] and hit[i][1] and hit[i][2]:
        bl = True

    if hit[0][i] and hit[1][i] and hit[2][i]:
        bl = True

if hit[0][0] and hit[1][1] and hit[2][2]:
    bl = True

if hit[0][2] and hit[1][1] and hit[2][0]:
    bl = True

print("Yes" if bl else "No")

Submission status: Accepted

Solution code:
from collections import defaultdict

A = [list(map(int, input().split())) for _ in range(3)]
d = defaultdict(int)

for i in range(3):
    for j in range(3):
        d[A[i][j]] = (i, j)
        
N = int(input())
flag = [[False]*3 for _ in range(3)]

for _ in range(N):
    b = int(input())
    if b in d:
        x, y = d[b]
        flag[x][y] = True

ans = False

for i in range(3):
    if flag[i][0] and flag[i][1] and flag[i][2]:
        ans = True
    
for i in range(3):
    if flag[0][i] and flag[1][i] and flag[2][i]:
        ans = True
    
if flag[0][0] and flag[1][1] and flag[2][2]:
    ans = True

if flag[0][2] and flag[1][1] and flag[2][0]:
    ans = True
    
if ans:
    print('Yes')
else:
    print('No')

Submission status: Accepted

Solution code:
A=[list(map(int, input().split())) for _ in range(3)]
N=int(input())
B=[int(input()) for _ in range(N)]
card=[[False for _ in range(3)] for _ in range(3)]

for b in B:
    for i in range(3):
        for j in range(3):
            if b==A[i][j]:
                card[i][j]=True

ans="No"
if card[0][0] and card[0][1] and card[0][2]:
    ans="Yes"
elif card[1][0] and card[1][1] and card[1][2]:
    ans="Yes"
elif card[2][0] and card[2][1] and card[2][2]:
    ans="Yes"
elif card[0][0] and card[1][0] and card[2][0]:
    ans="Yes"
elif card[0][1] and card[1][1] and card[2][1]:
    ans="Yes"
elif card[0][2] and card[1][2] and card[2][2]:
    ans="Yes"
elif card[0][0] and card[1][1] and card[2][2]:
    ans="Yes"
elif card[0][2] and card[1][1] and card[2][0]:
    ans="Yes"
print(ans)

Submission status: Accepted

Solution code:
A = [list(map(int, input().split())) for _ in range(3)]
N = int(input())
b = [int(input()) for _ in range(N)]

L = [[0] * 3 for _ in range(3)]
for i in range(3):
  for j in range(3):
    for k in b:
      if A[i][j] == k:
        L[i][j] = 1

flag = False
if L[0][0] & L[1][1] & L[2][2]:
  flag = True
if L[0][2] & L[1][1] & L[2][0]:
  flag = True
for i in range(3):
  if L[i][0] & L[i][1] & L[i][2]:
    flag = True
  if L[0][i] & L[1][i] & L[2][i]:
    flag = True

if flag:
  print("Yes")
else:
  print("No")

Submission status: Accepted

Solution code:
import sys

sys.setrecursionlimit(10 ** 6)
int1 = lambda x: int(x) - 1
p2D = lambda x: print(*x, sep="\n")
def II(): return int(sys.stdin.readline())
def MI(): return map(int, sys.stdin.readline().split())
def LI(): return list(map(int, sys.stdin.readline().split()))
def LLI(rows_number): return [LI() for _ in range(rows_number)]
def SI(): return sys.stdin.readline()[:-1]

def main():
    def bingo():
        for row in t:
            if sum(row)==3:return True
        for col in zip(*t):
            if sum(col)==3:return True
        if sum(t[i][i] for i in range(3)) == 3: return True
        if sum(t[i][2-i] for i in range(3)) == 3: return True
        return False

    atoij={}
    aa=LLI(3)
    for i in range(3):
        for j in range(3):
            a=aa[i][j]
            atoij[a]=(i,j)
    t=[[False]*3 for _ in range(3)]
    n=II()
    for _ in range(n):
        a=II()
        if a in atoij:
            i,j=atoij[a]
            t[i][j]=True
    if bingo():print("Yes")
    else:print("No")

main()

Submission status: Accepted

Solution code:
import sys, re
from collections import deque, defaultdict, Counter
from math import ceil, sqrt, hypot, factorial, pi, sin, cos, radians
from itertools import accumulate, permutations, combinations, product
from operator import itemgetter, mul
from copy import deepcopy
from string import ascii_lowercase, ascii_uppercase, digits
from bisect import bisect, bisect_left
from fractions import gcd
from heapq import heappush, heappop
from functools import reduce
def input(): return sys.stdin.readline().strip()
def INT(): return int(input())
def MAP(): return map(int, input().split())
def LIST(): return list(map(int, input().split()))
sys.setrecursionlimit(10 ** 9)
INF = float('inf')
mod = 10 ** 9 + 7

A = [LIST() for _ in range(3)]
N = INT()
b = [INT() for _ in range(N)]

check = [[0]*3 for _ in range(3)]
for n in b:
	for i in range(3):
		for j in range(3):
			if A[i][j] == n:
				check[i][j] = 1

for i in range(3):
	if sum(check[i]) == 3:
		print("Yes")
		exit()
for i in range(3):
	if check[0][i] and check[1][i] and check[2][i]:
		print("Yes")
		exit()

if check[0][0] and check[1][1] and check[2][2]:
	print("Yes")
	exit()

if check[0][2] and check[1][1] and check[2][0]:
	print("Yes")
	exit()

print("No")

Submission status: Accepted

Solution code:
import sys

stdin = sys.stdin

ns = lambda: stdin.readline().rstrip()
ni = lambda: int(stdin.readline().rstrip())
nm = lambda: map(int, stdin.readline().split())
nl = lambda: list(map(int, stdin.readline().split()))

l = list()
for _ in range(3):
    l += nl()
n = ni()
b = set([ni() for _ in range(n)])
g = [(x in b) for x in l]
f = g[0]&g[1]&g[2]
f |= g[3]&g[4]&g[5]
f |= g[6]&g[7]&g[8]
f |= g[0]&g[3]&g[6]
f |= g[1]&g[4]&g[7]
f |= g[2]&g[5]&g[8]
f |= g[0]&g[4]&g[8]
f |= g[2]&g[4]&g[6]
print('YNeos'[1^f::2])

Submission status: Accepted

Solution code:
dat = []
isok = []
for _ in range(3):
    l = list(map(int, input().split()))
    dat.append(l)
    isok.append([False] * 3)
n = int(input())
for _ in range(n):
    c = int(input())
    for i in range(3):
        for j in range(3):
            if dat[j][i] == c:
                isok[i][j] = True
if isok[0][0] and isok[0][1] and isok[0][2]:
    print("Yes")
elif isok[1][0] and isok[1][1] and isok[1][2]:
    print("Yes")
elif isok[2][0] and isok[2][1] and isok[2][2]:
    print("Yes")
elif isok[0][0] and isok[1][0] and isok[2][0]:
    print("Yes")
elif isok[0][1] and isok[1][1] and isok[2][1]:
    print("Yes")
elif isok[0][2] and isok[1][2] and isok[2][2]:
    print("Yes")
elif isok[0][0] and isok[1][1] and isok[2][2]:
    print("Yes")
elif isok[2][0] and isok[1][1] and isok[0][2]:
    print("Yes")
else:
    print("No")

Submission status: Accepted

Solution code:
A = [list(map(int, input().split())) for _ in range(3)]
N = int(input())
B = [int(input()) for _ in range(N)]

for b in B:
    for i in range(3):
        for j in range(3):
            if A[i][j] == b:
                A[i][j] = 0
                
for i in range(3):
    if A[i][0] == A[i][1] == A[i][2] == 0:
        print("Yes")
        exit()
for j in range(3):
    if A[0][j] == A[1][j] == A[2][j] == 0:
        print("Yes")
        exit()
if A[0][0] == A[1][1] == A[2][2] == 0:
    print("Yes")
    exit()
if A[0][2] == A[1][1] == A[2][0] == 0:
    print("Yes")
    exit()
    
print("No")

Submission status: Accepted

Solution code:
def main():
    a = [list(map(int, input().split())) for i in range(3)]
    n = int(input())
    for i in range(n):
        x = int(input())
        for j in range(3):
            for k in range(3):
                if a[j][k] == x:
                    a[j][k] = 0
    f = False
    for i in range(3):
        s = True
        for j in range(3):
            if a[i][j] != 0:
                s = False
        if s:
            f = True
    for i in range(3):
        s = True
        for j in range(3):
            if a[j][i] != 0:
                s = False
        if s:
            f = True
    if a[0][0] == 0 and a[1][1] == 0 and a[2][2] == 0:
        f = True
    if a[2][0] == 0 and a[1][1] == 0 and a[0][2] == 0:
        f = True
    if f:
        print("Yes")
    else:
        print("No")

if __name__ == "__main__":
    main()

Submission status: Accepted

Solution code:
#!/usr/bin/env python3

import sys
sys.setrecursionlimit(300000)

YES = "Yes"  # type: str
NO = "No"  # type: str

def solve(A: "List[List[int]]", N: int, b: "List[int]"):
    tmp = [[False] * 3 for _ in range(3)]
    for i, vals in enumerate(A):
        for j, v in enumerate(vals):
            if v in b:
                tmp[i][j] = True
    for i in range(3):
        found = True
        for j in range(3):
            if not tmp[i][j]:
                found = False
        if found:
            print(YES)
            return
    for i in range(3):
        found = True
        for j in range(3):
            if not tmp[j][i]:
                found = False
        if found:
            print(YES)
            return
    if tmp[0][0] and tmp[1][1] and tmp[2][2]:
        print(YES)
        return
    if tmp[0][2] and tmp[1][1] and tmp[2][0]:
        print(YES)
        return
    print(NO)
    return

def main():
    def iterate_tokens():
        for line in sys.stdin:
            for word in line.split():
                yield word
    tokens = iterate_tokens()
    A = [[int(next(tokens)) for _ in range(3)] for _ in range(3)]  # type: "List[List[int]]"
    N = int(next(tokens))  # type: int
    b = [int(next(tokens)) for _ in range(N)]  # type: "List[int]"
    solve(A, N, b)

if __name__ == '__main__':
    main()

Submission status: Accepted

Solution code:
import sys
input = sys.stdin.readline

A=[list(map(int,input().split())) for i in range(3)]
N=int(input())
B=[int(input()) for i in range(N)]

ANS=[[0]*3 for i in range(3)]

B=set(B)

for i in range(3):
    for j in range(3):
        if A[i][j] in B:
            ANS[i][j]=1

SCORE=0
for i in range(3):
    if sum(ANS[i])==3:
        SCORE=1

for i in range(3):
    X=0
    for j in range(3):
        X+=ANS[j][i]
    if X==3:
        SCORE=1

if ANS[0][0]==1 and ANS[1][1]==1 and ANS[2][2]==1:
    SCORE=1

if ANS[0][2]==1 and ANS[1][1]==1 and ANS[2][0]==1:
    SCORE=1

if SCORE==1:
    print("Yes")
else:
    print("No")

Submission status: Accepted

Solution code:
A=[]
B=[False]*9
for i in range(3):
  A+=[int(i) for i in input().split()]
n=int(input())
for _ in range(n):
  b=int(input())
  for i in range(9):
    if b==A[i]:
      B[i]=True
C=[[1,2,3],[4,5,6],[7,8,9],[1,4,7],[2,5,8],[3,6,9],[1,5,9],[3,5,7]]
Chk=False
for a,b,c in C:
  if B[a-1] and B[b-1] and B[c-1]:
    Chk=True
print("Yes" if Chk else "No")

Submission status: Accepted

Solution code:
import sys
# input = sys.stdin.buffer.readline
def getN():
    return int(input())
def getNM():
    return map(int, input().split())
def getlist():
    return list(map(int, input().split()))
import math
import heapq
import bisect
from collections import defaultdict, Counter, deque
MOD = 10**9 + 7
INF = 10**21

def main():
    bingo = []
    punched = [[0 for i in range(3)] for j in range(3)]
    for i in range(3):
        bingo.append(getlist())

    n = getN()
    for ball in range(n):
        num = getN()
        for i, row in enumerate(bingo):
            for j, cell in enumerate(row):
                if num == cell:
                    punched[i][j] = 1

    for row in punched:
        if sum(row) == 3:
            print("Yes")
            return

    for i in range(3):
        if punched[0][i] and punched[1][i] and punched[2][i]:
            print("Yes")
            return

    if punched[0][0] and punched[1][1] and punched[2][2]:
        print("Yes")
        return

    if punched[0][2] and punched[1][1] and punched[2][0]:
        print("Yes")
        return

    print("No")
    return

if __name__ == '__main__':
    main()

"""
9999
3

2916
"""

Submission status: Accepted

Solution code:
a11, a12, a13 = map(int, input().split())
a21, a22, a23 = map(int, input().split())
a31, a32, a33 = map(int, input().split())
pairs = [
    [a11, a12, a13],
    [a21, a22, a23],
    [a31, a32, a33],
    [a11, a21, a31],
    [a12, a22, a32],
    [a13, a23, a33],
    [a11, a22, a33],
    [a13, a22, a31],
]
n = int(input())
bList = []
for i in range(n):
    bList.append(int(input()))
flag = False
for pair in pairs:
    if (pair[0] in bList) and (pair[1] in bList) and (pair[2] in bList):
        flag = True
        break
print('Yes' if flag else 'No')

Submission status: Accepted

Solution code:
#
# 　　  ⋀_⋀　 
#　　  (･ω･)  
# .／ Ｕ ∽ Ｕ＼
#  │＊　合　＊│
#  │＊　格　＊│ 
#  │＊　祈　＊│ 
#  │＊　願　＊│ 
#  │＊　　　＊│ 
#      ￣
#
import sys
sys.setrecursionlimit(10**6)
input=sys.stdin.readline
from math import floor,sqrt,factorial,hypot,log #log2ないｙｐ
from heapq import heappop, heappush, heappushpop
from collections import Counter,defaultdict,deque
from itertools import accumulate,permutations,combinations,product,combinations_with_replacement
from bisect import bisect_left,bisect_right
from copy import deepcopy
from fractions import gcd
from random import randint
def ceil(a,b): return (a+b-1)//b
inf=float('inf')
mod = 10**9+7
def pprint(*A): 
    for a in A:     print(*a,sep='\n')
def INT_(n): return int(n)-1
def MI(): return map(int,input().split())
def MF(): return map(float, input().split())
def MI_(): return map(INT_,input().split())
def LI(): return list(MI())
def LI_(): return [int(x) - 1 for x in input().split()]
def LF(): return list(MF())
def LIN(n:int): return [I() for _ in range(n)]
def LLIN(n: int): return [LI() for _ in range(n)]
def LLIN_(n: int): return [LI_() for _ in range(n)]
def LLI(): return [list(map(int, l.split() )) for l in input()]
def I(): return int(input())
def F(): return float(input())
def ST(): return input().replace('\n', '')
def main():
    A=LLIN(3)
    M=I()
    B=[[0]*3 for _ in range(3)]
    for _ in range(M):
        b = I()
        for i in range(3):
            for j in range(3):
                if A[i][j] == b:
                    B[i][j] = 1
    for i in range(3):
        if B[i]==[1]*3:
            print("Yes")
            return
        if [B[0][i],B[1][i],B[2][i]] == [1]*3:
            print("Yes")
            return
    if [B[0][0],B[1][1],B[2][2]] == [1]*3:
        print("Yes")
        return
    if [B[0][2],B[1][1],B[2][0]] == [1]*3:
        print("Yes")
        return
    print("No")
if __name__ == '__main__':
    main()

Submission status: Accepted

Solution code:
A = [list(map(int, input().split())) for i in range(3)]
X = [[0] * 3 for i in range(3)]
N = int(input())
for i in range(N):
    b = int(input())
    for row in range(3):
        for col in range(3):
            if A[row][col] == b:
                X[row][col] = 1


for i in range(3):
    if X[i][0] + X[i][1] + X[i][2] == 3:
        print('Yes')
        exit()

for j in range(3):
    if X[0][j] + X[1][j] + X[2][j] == 3:
        print('Yes')
        exit()

if X[0][0] + X[1][1] + X[2][2] == 3:
    print('Yes')
    exit()

if X[0][2] + X[1][1] + X[2][0] == 3:
    print('Yes')
    exit()

print('No')

Submission status: Accepted

Solution code:
card = [[0 for i in range(3)] for j in range(3)]

for i in range(3):
    a,b,c = map(int,input().split())
    card[i][0] = a
    card[i][1] = b
    card[i][2] = c

op = [[False for i in range(3)] for j in range(3)]

n = int(input())

for l in range(n):
    b = int(input())
    for i in range(3):
        for j in range(3):
            if card[i][j] == b:
                op[i][j] = True

flag = False

for i in range(3):
    if op[i][0] and op[i][1] and op[i][2]:
        flag = True
    if op[0][i] and op[1][i] and op[2][i]:
        flag = True

if op[0][0] and op[1][1] and op[2][2]:
    flag = True


if op[0][2] and op[1][1] and op[2][0]:
    flag = True

if flag:
    print("Yes")
else:
    print("No")

Submission status: Accepted

Solution code:
def main():
    a = [list(map(int, input().split())) for _ in range(3)]
    n = int(input())
    b = [int(input()) for _ in range(n)]
    for i in range(3):
        for j in range(3):
            if a[i][j] in b:
                a[i][j] = -1
    answer = 0
    for i in range(3):
        if a[i] == [-1, -1, -1]:
            answer += 1
    for i in range(3):
        if a[0][i] == a[1][i] == a[2][i] == -1:
            answer += 1
    if a[0][0] == a[1][1] == a[2][2] == -1:
        answer += 1
    if a[0][2] == a[1][1] == a[2][0] == -1:
        answer += 1
    print("Yes" if answer > 0 else "No")


if __name__ == '__main__':
    main()

Submission status: Accepted

Solution code:
A = []
for i in range(3):
    A.append(list(map(int, input().split())))
N = int(input())
for k in range(N):
    B = int(input())
    for i in range(3):
        for j in range(3):
            if A[i][j] == B:
                A[i][j] = 0

ok = False
for i in range(3):
    if A[i][0] == A[i][1] and A[i][1] == A[i][2]:
        ok = True
    if A[0][i] == A[1][i] and A[1][i] == A[2][i]:
        ok = True
if A[0][0] == A[1][1] and A[1][1] == A[2][2]:
    ok = True
if A[2][0] == A[1][1] and A[1][1] == A[0][2]:
    ok = True
print('Yes' if ok else 'No')

Submission status: Accepted

Solution code:
def main():
    A = []
    for _ in range(3):
        A.append(list(map(int, input().split())))
    N = int(input())
    B = []
    for _ in range(N):
        B.append(int(input()))
    for b in B:
        for a in A:
            if b in a:
                a[a.index(b)] = 0
    for a in A:
        if a == [0, 0, 0]:
            return True
    for i in range(3):
        if A[0][i] == A[1][i] == A[2][i] == 0:
            return True
    return (A[0][0] == A[1][1] == A[2][2] == 0) or (A[0][2] == A[1][1] == A[2][0] == 0)

print('Yes' if main() else 'No')

Submission status: Accepted

Solution code:
import sys

sys.setrecursionlimit(10 ** 8)

input = sys.stdin.readline


def main():
    A1 = [int(x) for x in input().split()]
    A2 = [int(x) for x in input().split()]
    A3 = [int(x) for x in input().split()]
    N = int(input())
    A = set([int(input()) for _ in range(N)])
    f = False
    if A1[0] in A and A1[1] in A and A1[2] in A:
        print("Yes")
        return
    if A2[0] in A and A2[1] in A and A2[2] in A:
        print("Yes")
        return
    if A3[0] in A and A3[1] in A and A3[2] in A:
        print("Yes")
        return
    if A1[0] in A and A2[0] in A and A3[0] in A:
        print("Yes")
        return
    if A1[1] in A and A2[1] in A and A3[1] in A:
        print("Yes")
        return
    if A1[2] in A and A2[2] in A and A3[2] in A:
        print("Yes")
        return
    if A1[0] in A and A2[1] in A and A3[2] in A:
        print("Yes")
        return
    if A1[2] in A and A2[1] in A and A3[0] in A:
        print("Yes")
        return
    print("No")

    
    
    



if __name__ == '__main__':
    main()

Submission status: Accepted

Solution code:
A = [list(map(int,input().split())) for i in range(3)]
N = int(input())
B = [int(input()) for i in range(N)]

c = [[0]*3 for _ in range(3)]
for b in B:
    for i in range(3):
        for j in range(3):
            if A[i][j] == b:
                c[i][j] = 1

for i in range(3):
    if c[i][0] and c[i][1] and c[i][2]:
        print('Yes')
        exit()
    if c[0][i] and c[1][i] and c[2][i]:
        print('Yes')
        exit()
if c[0][0] and c[1][1] and c[2][2]:
    print('Yes')
    exit()
if c[0][2] and c[1][1] and c[2][0]:
    print('Yes')
    exit()
print('No')

Submission status: Accepted

Solution code:
a = [list(map(int, input().split())) for _ in range(3)]
n = int(input())

for i in range(n):
    b = int(input())
    for r in range(3):
        for c in range(3):
            if a[r][c] == b:
                a[r][c] = 0

is_bingo = False
for i in range(3):
    if sum([a[i][j] for j in range(3)]) == 0:
        is_bingo = True
        break
    if sum([a[j][i] for j in range(3)]) == 0:
        is_bingo = True
        break

if sum([a[j][j] for j in range(3)]) == 0:
    is_bingo = True
if sum([a[j][2 - j] for j in range(3)]) == 0:
    is_bingo = True

ans = 'Yes' if is_bingo else 'No'
print(ans)

Submission status: Accepted

Solution code:
A = []

for i in range(3):
    A.append(list(map(int, input().split())))
N = int(input())
b = []
for i in range(N):
    b.append(int(input()))

for i in range(3):
    if A[i][0] in b and A[i][1] in b and A[i][2] in b:
        print('Yes')
        exit()
for i in range(3):
    if A[0][i] in b and A[1][i] in b and A[2][i] in b:
        print('Yes')
        exit()
if A[0][0] in b and A[1][1] in b and A[2][2] in b:
    print('Yes')
    exit()
if A[2][0] in b and A[1][1] in b and A[0][2] in b:
    print('Yes')
    exit()



print('No')

Submission status: Accepted

Solution code:
# coding: utf-8
# Your code here!

import sys
readline = sys.stdin.readline
read = sys.stdin.read

#n,*a = [int(i) for i in read().split()]
#a = [int(i) for i in readline().split()]
#n = int(input())


#n,*a = [int(i) for i in read().split()]

    
a = [[int(i) for i in readline().split()] for _ in range(3)]
n,*b = [int(i) for i in read().split()]

res = [0]*1000
for i in b:
    res[i] = 1

ok = 0
for i in range(3):
    if res[a[i][0]] == res[a[i][1]] == res[a[i][2]] == 1:
        ok = 1

for i in range(3):
    if res[a[0][i]] == res[a[1][i]] == res[a[2][i]] == 1:
        ok = 1

if res[a[0][0]] == res[a[1][1]] == res[a[2][2]] == 1:
    ok = 1

if res[a[0][2]] == res[a[1][1]] == res[a[2][0]] == 1:
    ok = 1

if ok:
    print("Yes")
else:
    print("No")

Submission status: Accepted

Solution code:
A = [[int(i) for i in input().split()] for _ in range(3)]
N = int(input())
b = [int(input()) for _ in range(N)]

def check() :
  # TATE
  for x in range(3) :
    if all(A[y][x] in b for y in range(3)) :
      return True
      
  # YOKO
  for y in range(3) :
    if all(A[y][x] in b for x in range(3)) :
      return True
      
  # NANAME
  if all(A[i][i] in b for i in range(3)) : return True
  if all(A[2-i][i] in b for i in range(3)) : return True
    
  return False
  
if check() :
  print('Yes')
else :
  print('No')

Submission status: Accepted

Solution code:
a = list(map(int,input().split()))
a += list(map(int,input().split()))
a += list(map(int,input().split()))
b = [0 for _ in range(9)]
n = int(input())
for _ in range(n):
  tmp = int(input())
  for i in range(9):
    if tmp == a[i]:
      b[i] = 1
if b[0] == b[1] == b[2] == 1:
  print('Yes')
  exit()
if b[3] == b[4] == b[5] == 1:
  print('Yes')
  exit()
if b[6] == b[7] == b[8] == 1:
  print('Yes')
  exit()
if b[0] == b[3] == b[6] == 1:
  print('Yes')
  exit()
if b[1] == b[4] == b[7] == 1:
  print('Yes')
  exit()
if b[2] == b[5] == b[8] == 1:
  print('Yes')
  exit()
if b[0] == b[4] == b[8] == 1:
  print('Yes')
  exit()
if b[2] == b[4] == b[6] == 1:
  print('Yes')
  exit()
print('No')

Submission status: Accepted

Solution code:
A = [[int(a) for a in input().split()] for _ in range(3)]
B = [[0] * 3 for _ in range(3)]
N = int(input())
for _ in range(N):
    a = int(input())
    for i in range(3):
        for j in range(3):
            if A[i][j] == a:
                B[i][j] = 1

for i in range(3):
    if sum([B[i][j] for j in range(3)]) == 3:
        print("Yes")
        exit()

for j in range(3):
    if sum([B[i][j] for i in range(3)]) == 3:
        print("Yes")
        exit()

if sum([B[i][i] for i in range(3)]) == 3:
    print("Yes")
    exit()

if sum([B[i][2-i] for i in range(3)]) == 3:
    print("Yes")
    exit()

print("No")

Submission status: Accepted

Solution code:
A = [None]*3
for i in range(3):
  A[i] = map(int, raw_input().split())

N = input()
for _ in range(N):
  b = input()
  for y in range(3):
    for x in range(3):
      if A[y][x]==b:
        A[y][x] = 0

ans = "No"
for y in range(3):
  if A[y]==[0, 0, 0]:
    ans = "Yes"
for x in range(3):
  if [A[y][x] for y in range(3)]==[0, 0, 0]:
    ans = "Yes"
if [A[0][0], A[1][1], A[2][2]]==[0, 0, 0]:
  ans = "Yes"
if [A[2][0], A[1][1], A[0][2]]==[0, 0, 0]:
  ans = "Yes"
print ans

Submission status: Accepted

Solution code:
#!/usr/bin/env python3
import sys
INF = float("inf")


def yes():
    print("Yes")  # type: str


def no():
    print("No")  # type: str


def solve(A: "List[List[int]]", N: int, b: "List[int]"):

    flag = False
    # 横
    for i in range(3):
        if A[i][0] in b and A[i][1] in b and A[i][2] in b:
            flag = True
            break
    # 縦
    for i in range(3):
        if A[0][i] in b and A[1][i] in b and A[2][i] in b:
            flag = True
            break
    # ななめ
    if A[0][0] in b and A[1][1] in b and A[2][2] in b:
        flag = True
    if A[0][2] in b and A[1][1] in b and A[2][0] in b:
        flag = True

    if flag:
        yes()
    else:
        no()

    return


def main():

    def iterate_tokens():
        for line in sys.stdin:
            for word in line.split():
                yield word
    tokens = iterate_tokens()
    A = [[int(next(tokens)) for _ in range(3)]
         for _ in range(3)]  # type: "List[List[int]]"
    N = int(next(tokens))  # type: int
    b = [int(next(tokens)) for _ in range(N)]  # type: "List[int]"
    solve(A, N, b)


if __name__ == '__main__':
    main()

Submission status: Accepted

Solution code:
def main() -> None:
    board = [[int(x) for x in input().split()] for _ in range(3)]
    N = int(input())
    B = [int(input()) for _ in range(N)]
    bingo = [[False] * 3 for _ in range(3)]
    for b in B:
        for i in range(3):
            for j in range(3):
                if b == board[i][j]:
                    bingo[i][j] = True
    flag = False
    for i in range(3):
        if all(bingo[i][j] for j in range(3)):
            flag = True
        if all(bingo[j][i] for j in range(3)):
            flag = True
    if all(bingo[i][i] for i in range(3)):
        flag = True
    if all(bingo[i][2-i] for i in range(3)):
        flag = True
    print("Yes" if flag else "No")



if __name__ == '__main__':
    main()

Submission status: Accepted

Solution code:
import sys
import math
from collections import defaultdict

sys.setrecursionlimit(10**7)
def input():
    return sys.stdin.readline()[:-1]

mod = 10**9 + 7

def I(): return int(input())
def LI(): return list(map(int, input().split()))
def LIR(row,col):
    if row <= 0:
        return [[] for _ in range(col)]
    elif col == 1:
        return [I() for _ in range(row)]
    else:
        read_all = [LI() for _ in range(row)]
        return map(list, zip(*read_all))

#################

A = [LI() for _ in range(3)]
N = I()
b = LIR(N,1)

c = [[False]*3 for _ in range(3)]

for i in range(N):
    for j in range(3):
        for k in range(3):
            if A[j][k] == b[i]:
                c[j][k] = True
for i in range(3):
    if c[i][0] == c[i][1] == c[i][2] == True:
        print('Yes')
        exit()
for i in range(3):
    if c[0][i] == c[1][i] == c[2][i] == True:
        print('Yes')
        exit()
if c[0][0] == c[1][1] == c[2][2] == True:
    print('Yes')
    exit()
if c[0][2] == c[1][1] == c[2][0] == True:
    print('Yes')
    exit()

print('No')

Submission status: Accepted

Solution code:
a = [list(map(int, input().split())) for i in range(3)]
n = int(input())
b = [int(input()) for i in range(n)]

used = [[False] * 3 for i in range(3)] 
for num in range(n):
    for i in range(3):
        for j in range(3):
            if a[i][j] == b[num]:
                used[i][j] = True

for i in range(3):
    if used[i][0] and used[i][1] and used[i][2]:
        print("Yes")
        exit()
for i in range(3):
    if used[0][i] and used[1][i] and used[2][i]:
        print("Yes")
        exit()
if used[0][0] and used[1][1] and used[2][2]:
    print("Yes")
    exit()
if used[0][2] and used[1][1] and used[2][0]:
    print("Yes")
    exit()
print("No")

Submission status: Accepted

Solution code:
#!/usr/bin/env python

from collections import deque, defaultdict
import itertools as ite
import sys
import math
from decimal import *

sys.setrecursionlimit(1000000)

INF = 10 ** 18
MOD = 10 ** 9 + 7

A = [map(int, raw_input().split()) for i in range(3)]
N = input()
for i in range(N):
    b = input()
    for j in range(3):
        for k in range(3):
            if b == A[j][k]:
                A[j][k] = 0
for i in range(3):
    if A[i][0] == A[i][1] == A[i][2] == 0:
        print "Yes"
        exit()
    if A[0][i] == A[1][i] == A[2][i] == 0:
        print "Yes"
        exit()
if A[0][0] == A[1][1] == A[2][2] == 0:
    print "Yes"
    exit()
if A[0][2] == A[1][1] == A[2][0] == 0:
    print "Yes"
    exit()
print "No"