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:
A1 = list(map(int, input().split()))
A2 = list(map(int, input().split()))
A3 = list(map(int, input().split()))
N = int(input())


for i in range(N):
    b = int(input())
    for j in range(3):
        if A1[j] == b:
            A1[j] = 0
        if A2[j] == b:
            A2[j] = 0
        if A3[j] == b:
            A3[j] = 0

f = 0

if A1[0] == 0 and A1[1] == 0 and A1[2] == 0:
    f = 1
if A2[0] == 0 and A2[1] == 0 and A2[2] == 0:
    f = 1
if A3[0] == 0 and A3[1] == 0 and A3[2] == 0:
    f = 1
if A1[0] == 0 and A2[0] == 0 and A3[0] == 0:
    f = 1
if A1[1] == 0 and A2[1] == 0 and A3[1] == 0:
    f = 1
if A1[2] == 0 and A2[2] == 0 and A3[2] == 0:
    f = 1
if A1[0] == 0 and A2[1] == 0 and A3[2] == 0:
    f = 1
if A1[2] == 0 and A2[1] == 0 and A3[0] == 0:
    f = 1
if f == 1:
    print('Yes')
else:
    print('No')

Submission status: Accepted

Solution code:
A1,A2,A3=map(int,input().split())
A4,A5,A6=map(int,input().split())
A7,A8,A9=map(int,input().split())

N=int(input())
B=[]
for i in range(N):
    B.append(int(input()))
flag=0

if A1 in B and A2 in B and A3 in B:
    flag=1
if A4 in B and A5 in B and A6 in B:
    flag=1
if A7 in B and A8 in B and A9 in B:
    flag=1

if A1 in B and A4 in B and A7 in B:
    flag=1
if A2 in B and A5 in B and A8 in B:
    flag=1
if A3 in B and A6 in B and A9 in B:
    flag=1

if A1 in B and A5 in B and A9 in B:
    flag=1
if A3 in B and A5 in B and A7 in B:
    flag=1

print('Yes' if flag==1 else 'No')

Submission status: Accepted

Solution code:
a=[]
a.append(list(map(int,input().split())))
a.append(list(map(int,input().split())))
a.append(list(map(int,input().split())))
N=int(input())
c = [int(input()) for _ in range(N)]
b=[[0,0,0],[0,0,0],[0,0,0]]
for val in c:
    for i in range(3):
        for j in range(3):
            if val == a[i][j]:
                b[i][j]=1
if sum(b[1])==3 or sum(b[0])==3 or sum(b[2])==3 or b[0][0]+b[1][0]+b[2][0]==3 or b[0][1]+b[1][1]+b[2][1]==3 or b[0][2]+b[1][2]+b[2][2]==3 or b[0][2]+b[1][1]+b[2][0]==3 or b[0][0]+b[1][1]+b[2][2]==3:
    print('Yes')
else:
    print('No')

Submission status: Accepted

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

if sum(o[0]) == 3 or sum(o[1]) == 3 or sum(o[2]) == 3 or o[0][0] == o[1][0] == o[2][0] == 1 or o[0][1] == o[1][1] == o[2][1] == 1 or o[0][2] == o[1][2] == o[2][2] == 1 or o[0][0] == o[1][1] == o[2][2] == 1 or o[0][2] == o[1][1] == o[2][0] == 1:
    print('Yes')
else:
    print('No')

Submission status: Accepted

Solution code:

#gcdは3.4.3だとfractionsにある
from fractions import gcd
import math

from math import factorial as f

from math import ceil,floor,sqrt


import bisect
import re
import heapq


from copy import deepcopy
import itertools

from sys import exit

ii = lambda : int(input())
mi = lambda : map(int,input().split())
li = lambda : list(map(int,input().split()))

yes = "Yes"
no = "No"

def main():
    a = []
    for i in range(3):
        atmp = li()
        a.append(atmp)
    n = ii()
    b = []
    for i in range(n):
        tmp = ii()
        b.append(tmp)
    
    for i in b:
        for itr in range(3):
            for itritr in range(3):
                if a[itr][itritr] == i:
                    a[itr][itritr] = 0

    for i in range(3):
        if sum(a[i]) == 0:
            print(yes)
            exit()
    for i in range(3):
        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 or a[0][2]+a[1][1]+a[2][0] == 0:
        print(yes)
        exit()
    print(no)



main()

Submission status: Accepted

Solution code:
# coding: UTF-8
import sys
sys.setrecursionlimit(10**9)
INF=10**18
MOD=10**9+7
def input(): return sys.stdin.readline().rstrip()

def main():
    A=[[0]*3 for _ in range(3)]
    l=[]
    for i in range(3):
        A[i]=list(map(int,input().split()))
    for i in range(3):
        l.append(A[i])
        l.append([A[0][i],A[1][i],A[2][i]])
    l.append([A[0][0],A[1][1],A[2][2]])
    l.append([A[2][0],A[1][1],A[0][2]])
    N=int(input())
    b=[int(input()) for i in range(N)]
    for x in l:
        for y in x:
            if not y in b:
                break
        else:
            print('Yes')
            exit()
    print('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())
B = []
for i in range(N):
    B.append(int(input()))
L = [[False,False,False] for i in range(3)]
for e in B:
    for i in range(3):
        for j in range(3):
            if A[i][j] == e:
                L[i][j] = True

#vertical
for i in range(3):
    if L[i][0] and L[i][1] and L[i][2]:
        print('Yes')
        exit()
#horizontal
for i in range(3):
    if L[0][i] and L[1][i] and L[2][i]:
        print('Yes')
        exit()
#diagonal
if L[0][0] and L[1][1] and L[2][2]:
    print('Yes')
    exit()
if L[2][0] and L[1][1] and L[0][2]:
    print('Yes')
    exit()
print('No')

Submission status: Accepted

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

n = int(input())

for i in range(n):
    b = int(input())
    for j in range(3):
        for k in range(3):
            if l[j][k] == b:
                l[j][k] = -1

r = False
for i in l:
    if sum(i) == -3:
        r = True
for i in range(3):
    if l[0][i] == l[1][i] == l[2][i] == -1:
        r = True
if l[0][0] == l[1][1] == l[2][2] == -1:
    r = True
if l[2][0] == l[1][1] == l[0][2] == -1:
    r = True
    
if r == True:
    print("Yes")
else:
    print("No")

Submission status: Accepted

Solution code:
a = []
for _ in range(3):
    at = [int(num) for num in input().split()]
    a.append(at)
b = [[0,0,0] for _ in range(3)]
n = int(input())
for t in range(n):
    num = int(input())
    for i in range(3):
        for j in range(3):
            if num == a[i][j]:
                b[i][j] = 1
                
ans = "No"
for i in range(3):
    if b[i][0] == 1 and b[i][1] == 1 and b[i][2] == 1:
        ans = "Yes"
for j in range(3):
    if b[0][j] == 1 and b[1][j] == 1 and b[2][j] == 1:
        ans = "Yes"
if b[0][0] * b[1][1] * b[2][2] == 1:
    ans = "Yes"
if b[0][2] * b[1][1] * b[2][0] == 1:
    ans = "Yes"
    
print(ans)

Submission status: Accepted

Solution code:
a1,a2,a3 = map(int,input().split())
b1,b2,b3 = map(int,input().split())
c1,c2,c3 = map(int,input().split())

N = int(input())
holl = []
for i in range(N):
    holl_t = int(input())
    holl.append(holl_t)

#ビンゴチェック
check_list = [[a1,a2,a3],[b1,b2,b3],[c1,c2,c3],[a1,b1,c1],[a2,b2,c2],[a3,b3,c3],[a1,b2,c3],[a3,b2,c1]]
ans = 0

for check in check_list:
    count = 0
    for i in check:
        if i in holl:
            count += 1
    
    if count == 3:
        ans = 1
        break

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

Submission status: Accepted

Solution code:
a = []
a.append(list(map(int, input().split())))
a.append(list(map(int, input().split())))
a.append(list(map(int, input().split())))
n = int(input())

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

# print(a)
if (a[0][0] == 0 and a[0][1] == 0 and a[0][2] == 0) or \
        (a[1][0] == 0 and a[1][1] == 0 and a[1][2] == 0) or \
        (a[2][0] == 0 and a[2][1] == 0 and a[2][2] == 0) or \
        (a[0][0] == 0 and a[1][0] == 0 and a[2][0] == 0) or \
        (a[0][1] == 0 and a[1][1] == 0 and a[2][1] == 0) or \
        (a[0][2] == 0 and a[1][2] == 0 and a[2][2] == 0) or \
        (a[0][0] == 0 and a[1][1] == 0 and a[2][2] == 0) or \
        (a[0][2] == 0 and a[1][1] == 0 and a[2][0] == 0):
    print('Yes')
else:
    print('No')

Submission status: Accepted

Solution code:
a = []
for i in range(3):
    a.append(list(map(int,input().split())))
n = int(input())
for i in range(n):
    b = int(input())
    for j in range(3):
        for k in range(3):
            if a[j][k] == b:
                a[j][k] = 0
if sum(a[0]) == 0 or sum(a[1]) == 0 or sum(a[2]) == 0:
    print('Yes')
elif a[0][0]+a[1][0]+a[2][0] == 0:
    print('Yes')
elif a[0][1]+a[1][1]+a[2][1] == 0:
    print('Yes')
elif a[0][2]+a[1][2]+a[2][2] == 0:
    print('Yes')
elif a[0][0]+a[1][1]+a[2][2] == 0:
    print('Yes')
elif a[0][2]+a[1][1]+a[2][0] == 0:
    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 i in range(3):
    for j in range(3):
        if a[i][j] not in b:
            break
    else:
        print('Yes')
        exit()
for i in range(3):
    for j in range(3):
        if a[j][i] not in b:
            break
    else:
        print('Yes')
        exit()
for i in range(3):
    if a[i][i] not in b:
        break
else:
    print('Yes')
    exit()
for i in range(3):
    if a[2-i][i] not in b:
        break
else:
    print('Yes')
    exit()
print('No')

Submission status: Accepted

Solution code:
a = list(map(int,input().split()))
b = list(map(int,input().split()))
c = list(map(int,input().split()))
n = int(input())
l = []
for i in range(n):
  li = int(input())
  l.append(li)
for x in [a,b,c,[a[0],b[0],c[0]],[a[1],b[1],c[1]],[a[2],b[2],c[2]],[a[0],b[1],c[2]],[a[2],b[1],c[0]]]:
  flag = True
  for xi in x:
    if xi not in l:
      flag = False
      break
  if flag:
    print("Yes")
    exit()
print("No")

Submission status: Accepted

Solution code:
import itertools
A = [[int(_) for _ in input().split()] for _ in range(3)]
N = int(input())
B = set([int(input()) for _ in range(N)])
C = [[False] * 3 for _ in range(3)]
for i, j in itertools.product(range(3), range(3)):
    if A[i][j] in B:
        C[i][j] = True
f = False
for i in range(3):
    if all(C[i][j] for j in range(3)):
        f = True
for j in range(3):
    if all(C[i][j] for i in range(3)):
        f = True
if all([C[0][0], C[1][1], C[2][2]]):
    f = True
if all([C[0][2], C[1][1], C[2][0]]):
    f = True
print('Yes' if f else 'No')

Submission status: Accepted

Solution code:
A = [[] for i in range(8)]
A[0] = list(map(int,input().split()))
A[1] = list(map(int,input().split()))
A[2] = list(map(int,input().split()))
A[3] = [A[0][0],A[1][0],A[2][0]]
A[4] = [A[0][1],A[1][1],A[2][1]]
A[5] = [A[0][2],A[1][2],A[2][2]]
A[6] = [A[0][0],A[1][1],A[2][2]]
A[7] = [A[0][2],A[1][1],A[2][0]]

N = int(input())
b = [int(input()) for i in range(N)]

for i in range(8):
    bingo = True
    for j in range(3):
        if not A[i][j] in b:
            bingo = False
    if bingo:
        print('Yes')
        exit()
print('No')

Submission status: Accepted

Solution code:
# from math import sqrt
# from heapq import heappush, heappop
# from collections import deque
#from functools import reduce


def main():
    A = []
    for i in range(3):
        ary = [int(v) for v in input().split()]
        A.append(ary)
    N = int(input())

    B = []
    for _ 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

    for i in range(3):
        cnt1 = 0
        cnt2 = 0
        for j in range(3):
            if A[i][j] == 0:
                cnt1 += 1
            if A[j][i] == 0:
                cnt2 += 1
        if cnt1 == 3 or cnt2 == 3:
            print("Yes")
            exit()

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

    print("No")


if __name__ == "__main__":
    main()

Submission status: Accepted

Solution code:
def main():
    b = [list(map(int, input().split())) for _ in [0]*3]
    n = int(input())
    x = [int(input()) for _ in [0]*n]
    memo = [[False]*3 for _ in [0]*3]

    for i in x:
        for j in range(3):
            for k in range(3):
                if b[j][k] == i:
                    memo[j][k] = True
    for i in range(3):
        if memo[i][0] == memo[i][1] == memo[i][2] == True:
            print("Yes")
            return
        if memo[0][i] == memo[1][i] == memo[2][i] == True:
            print("Yes")
            return
    if memo[0][0] == memo[1][1] == memo[2][2] == True:
        print("Yes")
        return
    if memo[0][2] == memo[1][1] == memo[2][0] == True:
        print("Yes")
        return
    print("No")


main()

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)]
    bng = [[False]*3 for _ in range(3)]
    ans = "No"
    for i in range(N):
        for j in range(3):
            for k in range(3):
                if b[i] == A[j][k]:
                    bng[j][k] = True
    if (bng[0] == [True]*3 or
        bng[1] == [True]*3 or
        bng[2] == [True]*3 or
        bng[0][0] == bng[1][0] == bng[2][0] == True or
        bng[0][1] == bng[1][1] == bng[2][1] == True or
        bng[0][2] == bng[1][2] == bng[2][2] == True or
        bng[0][0] == bng[1][1] == bng[2][2] == True or
        bng[0][2] == bng[1][1] == bng[2][0] == True):
        ans = "Yes"
    print(ans)


if __name__ == '__main__':
    main()

Submission status: Accepted

Solution code:
#!/usr/bin/env python
# coding: utf-8

def ri():
    return int(input())

def rl():
    return list(input().split())

def rli():
    return list(map(int, input().split()))

def mark(b, check, la):
    for i in range(3):
        for j in range(3):
            if la[i][j] == b:
                check[i][j] = True

def ok(check):
    for i in range(3):
        if check[i][0] and check[i][1] and check[i][2]:
            return True
        if check[0][i] and check[1][i] and check[2][i]:
            return True
    if check[0][0] and check[1][1] and check[2][2]:
        return True
    if check[2][0] and check[1][1] and check[0][2]:
        return True
    return False


def main():
    check = [[False for _ in range(3)] for _ in range(3)]
    la = []
    for i in range(3):
        l = rli()
        la.append(l)
    n = ri()
    for i in range(n):
        b = ri()
        mark(b, check, la)
    if ok(check):
        print("Yes")
    else:
        print("No")


if __name__ == '__main__':
    main()

Submission status: Accepted

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

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

n = int(input())
for _ in range(n):
    num = int(input())
    for i in range(3):
        for j in range(3):
            if board[i][j] == num:
                board[i][j] = True
                break

# check bingo
bingo_count = 0
for i in range(3):
    if board[i][0] == board[i][1] == board[i][2] == True:
        bingo_count += 1
    elif board[0][i] == board[1][i] == board[2][i] == True:
        bingo_count += 1

if board[0][0] == board[1][1] == board[2][2] == True:
    bingo_count += 1
if board[0][2] == board[1][1] == board[2][0] == True:
    bingo_count += 1

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

Submission status: Accepted

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

ok = [[False for i in range(3)] for j in range(3)]
for i in range(3):
    for j in range(3):
        for k in range(n):
            if a[i][j] == b[k]:
                ok[i][j] = True

    

bingo = False

if [True, True, True] in ok:
    bingo = True
if ok[0][0] == ok[1][1] == ok[2][2] == True:
    bingo = True
if ok[0][2] == ok[1][1] == ok[2][0] == True:
    bingo = True
for i in range(3):
    if ok[0][i] == ok[1][i] == ok[2][i] == True:
        bingo = True

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

Submission status: Accepted

Solution code:
# -*- coding: utf-8 -*-
import bisect
import heapq
import math
import random
import sys
from collections import Counter, defaultdict, deque
from decimal import ROUND_CEILING, ROUND_HALF_UP, Decimal
from functools import lru_cache, reduce
from itertools import combinations, combinations_with_replacement, product, permutations
from operator import add, mul, sub

sys.setrecursionlimit(100000)
input = sys.stdin.readline
INF = 2**62-1

def read_int():
    return int(input())


def read_int_n():
    return list(map(int, input().split()))


def read_float():
    return float(input())


def read_float_n():
    return list(map(float, input().split()))


def read_str():
    return input().strip()


def read_str_n():
    return list(map(str, input().split()))


def error_print(*args):
    print(*args, file=sys.stderr)


def mt(f):
    import time

    def wrap(*args, **kwargs):
        s = time.time()
        ret = f(*args, **kwargs)
        e = time.time()

        error_print(e - s, 'sec')
        return ret

    return wrap


@mt
def slv(A, N, B):
    C = [[False] * 3 for _ in range(3)]
    D = {}
    for i, r in enumerate(A):
        for j, c in enumerate(r):
            D[c] = (i, j)

    for b in B:
        if b in D:
            i, j = D[b]
            C[i][j] = True

    for i in range(3):
        t = True
        for j in range(3):
            t = t and C[i][j]
        if t:
            return 'Yes'

    for i in range(3):
        t = True
        for j in range(3):
            t = t and C[j][i]
        if t:
            return 'Yes'

    t = True
    for i in range(3):
        t = t and C[i][i]
    if t:
            return 'Yes'

    t = True
    for i in range(3):
        t = t and C[2-i][i]
    if t:
            return 'Yes'
    return 'No'


def main():
    A = [read_int_n() for _ in range(3)]
    N = read_int()
    B = [read_int() for _ in range(N)]

    print(slv(A, N, B))


if __name__ == '__main__':
    main()

Submission status: Accepted

Solution code:
lists=[]
for i in range(3):
    a=list(map(int,input().split()))
    lists.append(a)
bingo=[[0 for i in range(3)] for j in range(3)]
n=int(input())
for i in range(n):
    x=int(input())
    for i in range(3):
        for j in range(3):
            if x==lists[i][j]:
                bingo[i][j]=1
flag=False
for i in range(3):
    if sum(bingo[i])==3:
        flag=True
for j in range(3):
    c=0
    for i in range(3):
        c+=bingo[i][j]
    if c==3:
        flag=True
if bingo[0][0]+bingo[1][1]+bingo[2][2]==3:
    flag=True
if bingo[0][2]+bingo[1][1]+bingo[2][0]==3:
    flag=True
if flag:
    print("Yes")
else:
    print("No")

Submission status: Accepted

Solution code:
a1_list = list(map(int, input().split()))
a2_list = list(map(int, input().split()))
a3_list = list(map(int, input().split()))
n = int(input())
for i in range(n):
    b = int(input())
    for j in range(3):
        if a1_list[j] == b:
            a1_list[j] = 0
        if a2_list[j] == b:
            a2_list[j] = 0
        if a3_list[j] == b:
            a3_list[j] = 0
bingo = False
yoko = [0] * 3
tate = [0] * 3
for j in range(3):
    if(a1_list[j] == 0):
        tate[j] += 1
        yoko[0] += 1
        if tate[j] == 3 or yoko[0] == 3:
            bingo = True
            break
    if(a2_list[j] == 0):
        tate[j] += 1
        yoko[1] += 1
        if tate[j] == 3 or yoko[1] == 3:
            bingo = True
            break
    if(a3_list[j] == 0):
        tate[j] += 1
        yoko[2] += 1
        if tate[j] == 3 or yoko[2] == 3:
            bingo = True
            break
if bingo:
    print("Yes")
else:
    if(a1_list[0] == 0 and a2_list[1] == 0 and a3_list[2] == 0):
        print("Yes")
    elif(a1_list[2] == 0 and a2_list[1] == 0 and a3_list[0] == 0):
        print("Yes")
    else:
        print("No")

Submission status: Accepted

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

bingo = [[False]*3 for _ in [0]*3]
for b in B:
    for i in range(3):
        for j in range(3):
            if A[i][j] == b:
                bingo[i][j] = True

ans = False
for i in range(3):
    tmp = True
    for j in range(3):
        tmp = tmp and bingo[i][j]
    ans = ans or tmp

for j in range(3):
    tmp = True
    for i in range(3):
        tmp = tmp and bingo[i][j]
    ans = ans or tmp
tmp = bingo[0][0] and bingo[1][1] and bingo[2][2]
ans = ans or tmp
tmp = bingo[0][2] and bingo[1][1] and bingo[2][0]
ans = ans or tmp
print("Yes" if ans else "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)]

C = [[False] * 3 for _ in range(3)]
for i in range(3):
    for j in range(3):
        if A[i][j] in B:
            C[i][j] = 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[2][0] == C[1][1] == C[0][2] == True:
    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)]

li = []
for i in A:
  li.append(i)
for i in range(3):
  li.append([A[0][i], A[1][i], A[2][i]])
li.append([A[0][0], A[1][1], A[2][2]])
li.append([A[0][2], A[1][1], A[2][0]])

for i, j, k in li:
  if i in B and j in B and k in B:
    print("Yes")
    exit()
print("No")

Submission status: Accepted

Solution code:
a=[]
b=[]
for i in range(3):
    a.append(list(map(int,input().split())))
n=int(input())
for i in range(n):
    b.append(int(input()))
for i in range(3):
    for j in range(3):
        if a[i][j] in b:
            a[i][j]=101
for i in range(3):
    if sum(a[i])==303:
        print('Yes')
        exit()
    if a[0][i]+a[1][i]+a[2][i]==303:
        print('Yes')
        exit()
if a[0][0]+a[1][1]+a[2][2]==303 or a[0][2]+a[1][1]+a[2][0]==303:
    print('Yes')
    exit()
print('No')

Submission status: Accepted

Solution code:
a=[list(map(int,input().split())) for i in range(3)]
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]=-1
for i in range(3):
    ans=True
    for j in range(3):
        if a[i][j]!=-1:
            ans=False
            break
    if ans:
        print("Yes")
        exit()
for i in range(3):
    ans=True
    for j in range(3):
        if a[j][i]!=-1:
            ans=False
            break
    if ans:
        print("Yes")
        exit()
ans=True
for i in range(3):
    if a[i][i]!=-1:
        ans=False
        break
if ans:
    print("Yes")
    exit()
ans=True
for i in range(3):
    if a[i][2-i]!=-1:
        ans=False
        break
if ans:
    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)]

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

for i, bi in enumerate(b):
    for y in range(3):
        for x in range(3):
            if A[y][x] == bi: card[y][x] = True

ans = 'No'

# horizontal
for y in range(3):
    if card[y].count(True) == len(card[y]):
        ans = 'Yes'

# vertical
for x in range(3):
    if card[0][x] == card[1][x] == card[2][x] == True:
        ans = 'Yes'

# diagonal
if card[0][0] == card[1][1] == card[2][2] == True:
    ans = 'Yes'

if card[2][0] == card[1][1] == card[0][2] == True:
    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)]

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

for i in range(3):
  for j in range(3):
    if b.count(a[i][j]) >= 1:
      h[i][j] = True


def ok():
  print('Yes')
  exit()


for i in range(3):
  if all(h[i]):
    ok()
for j in range(3):
  for i in range(3):
    if not h[i][j]:
      break
  else:
    ok()
if all([h[k][k] for k in range(3)]):
  ok()
if all([h[3 - 1 - k][k] for k in range(3)]):
  ok()

print('No')

Submission status: Accepted

Solution code:
import sys
sys.setrecursionlimit(1000000000)
import math
from fractions import gcd
def lcm(a, b): return a * b // gcd(a, b)
from itertools import count, permutations
from functools import lru_cache
from collections import deque, defaultdict
from pprint import pprint
ii = lambda: int(input())
mis = lambda: map(int, input().split())
lmis = lambda: list(mis())
INF = float('inf')
N1097 = 10**9 + 7

def meg(f, ok, ng):
    while abs(ok-ng)>1:
        mid = (ok+ng)//2
        if f(mid):
            ok=mid
        else:
            ng=mid
    return ok

def get_inv(n, modp):
    return pow(n, modp-2, modp)

def factorials_list(n, modp):    # 10**6
    fs = [1]
    for i in range(1, n+1):
        fs.append(fs[-1] * i % modp)
    return fs

def invs_list(n, fs, modp):     # 10**6
    invs = [get_inv(fs[-1], modp)]
    for i in range(n, 1-1, -1):
        invs.append(invs[-1] * i % modp)
    invs.reverse()
    return invs

def comb(n, k, modp):
    num = 1
    for i in range(n, n-k, -1):
        num = num * i % modp
    den = 1
    for i in range(2, k+1):
        den = den * i % modp
    return num * get_inv(den, modp) % modp

def comb_from_list(n, k, modp, fs, invs):   
    return fs[n] * invs[n-k] * invs[k] % modp

#

def main():
    A = [lmis(), lmis(), lmis()]
    for _ in range(ii()):
        b = ii()
        for vec in A:
            for i in range(3):
                if vec[i] == b:
                    vec[i] = 0
    import numpy as np
    A = np.array(A)
    for i in range(3):
        if np.sum(A[i]) == 0 or np.sum(A[:, i]) == 0:
            print('Yes')
            return
    if A[0][0] == A[1][1] == A[2][2] == 0:
        print('Yes')
        return
    if A[0][2] == A[1][1] == A[2][0] == 0:
        print('Yes')
        return
    print('No')




main()

Submission status: Accepted

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

n = int(input())

for _ in range(n):
  m = int(input())
  for i in range(3):
    for j in range(3):
      if m == a[i][j]:
        a[i][j] = -1
        
for i in range(3):
  if a[i][0] == -1 and a[i][1] == -1 and a[i][2] == -1:
    print("Yes")
    exit(0)
  if a[0][i] == -1 and a[1][i] == -1 and a[2][i] == -1:
    print("Yes")
    exit(0)
if a[0][0] == -1 and a[1][1] == -1 and a[2][2] == -1:
  print("Yes")
  exit(0)
if a[0][2] == -1 and a[1][1] == -1 and a[2][0] == -1:
  print("Yes")
  exit(0)
print("No")

Submission status: Accepted

Solution code:
# -*- coding: utf-8 -*-

import sys
from collections import Counter

def input(): return sys.stdin.readline().strip()
def list2d(a, b, c): return [[c] * b for i in range(a)]
def list3d(a, b, c, d): return [[[d] * c for j in range(b)] for i in range(a)]
def list4d(a, b, c, d, e): return [[[[e] * d for j in range(c)] for j in range(b)] for i in range(a)]
def ceil(x, y=1): return int(-(-x // y))
def INT(): return int(input())
def MAP(): return map(int, input().split())
def LIST(N=None): return list(MAP()) if N is None else [INT() for i in range(N)]
def Yes(): print('Yes')
def No(): print('No')
def YES(): print('YES')
def NO(): print('NO')
sys.setrecursionlimit(10 ** 9)
INF = 10 ** 18
MOD = 10 ** 9 + 7

def build_grid(H, W, intv, _type, space=True, padding=False):
    # 入力がスペース区切りかどうか
    if space:
        _input = lambda: input().split()
    else:
        _input = lambda: input()
    _list = lambda: list(map(_type, _input()))
    # 余白の有無
    if padding:
        offset = 1
    else:
        offset = 0
    grid = list2d(H+offset*2, W+offset*2, intv)
    for i in range(offset, H+offset):
        row = _list()
        for j in range(offset, W+offset):
            grid[i][j] = row[j-offset]
    return grid

grid = build_grid(3, 3, 0, int)
D = {}
for i in range(3):
    for j in range(3):
        D[grid[i][j]] = (i, j)

N = INT()
res = list2d(3, 3, 0)
for _ in range(N):
    a = INT()
    if a in D:
        i, j = D[a]
        res[i][j] = 1

for i in range(3):
    if sum(res[i]) == 3:
        Yes()
        exit()
res = list(zip(*res))
for i in range(3):
    if sum(res[i]) == 3:
        Yes()
        exit()
if res[0][0] and res[1][1] and res[2][2] or res[0][2] and res[1][1] and res[2][0]:
    Yes()
else:
    No()

Submission status: Accepted

Solution code:
import sys
import math
import bisect

def solve(A, B):
    C = []
    for i in range(3):
        C.append([0]*3)
    for b in B:
        for i in range(3):
            for j in range(3):
                if A[i][j] == b:
                    C[i][j] = 1
    '''
    print('A: ' + str(A))
    print('B: ' + str(B))
    print('C: ' + str(C))
    '''
    for i in range(3):
        if C[i][0] and C[i][1] and C[i][2]:
            return True
        if C[0][i] and C[1][i] and C[2][i]:
            return True
    if C[0][0] and C[1][1] and C[2][2]:
        return True
    if C[2][0] and C[1][1] and C[0][2]:
        return True
    return False

def main():
    A = []
    for i in range(3):
        A.append(list(map(int, input().split())))
    B = []
    for _ in range(int(input())):
        B.append(int(input()))
    if solve(A, B):
        print('Yes')
    else:
        print('No')

if __name__ == "__main__":
    main()

Submission status: Accepted

Solution code:
import math,itertools,fractions,heapq,collections,bisect,sys,queue,copy

sys.setrecursionlimit(10**7)
inf=10**20
mod=10**9+7
dd=[(-1,0),(0,1),(1,0),(0,-1)]
ddn=[(-1,0),(-1,1),(0,1),(1,1),(1,0),(1,-1),(0,-1),(-1,-1)]

def LI(): return [int(x) for x in sys.stdin.readline().split()]
def I(): return int(sys.stdin.readline())
def LS(): return sys.stdin.readline().split()
def S(): return input()

def main():
  l=[LI() for _ in range(3)]
  n=I()
  ans=[[0]*3 for _ in range(3)]

  for i in range(n):
    a=I()
    for j in range(3):
      for k in range(3):
        if l[j][k]==a:
          ans[j][k]=1

  for i in range(3):
    if ans[i][0]==1 and ans[i][1]==1 and ans[i][2]==1:
      return 'Yes'

  for i in range(3):
    if ans[0][i]==1 and ans[1][i]==1 and ans[2][i]==1:
      return 'Yes'

  if ans[0][0]==1 and ans[1][1]==1 and ans[2][2]==1:
    return 'Yes'

  if ans[0][2]==1 and ans[1][1]==1 and ans[0][2]==1:
    return 'Yes'

  return 'No'

# main()
print(main())