Go: package main
import (
	"fmt"
	"bufio"
	"os"
	"bytes"
	"strconv"
	"strings"
)

func nextInt(scanner *bufio.Scanner) int {
	scanner.Scan()
	num , _ :=  strconv.Atoi(scanner.Text())
	return num
}


func main() {
	scanner := bufio.NewScanner(os.Stdin)
	scanner.Split(bufio.ScanWords)

	N := nextInt(scanner)
	var A [][]int = make([][]int, N)
	for i:=0; i<N; i++ {
		A[i] = make([]int, N)
	}
	for i:=0; i<N; i++{
		idx := nextInt(scanner)
		cnt := nextInt(scanner)
		for j:=0; j<cnt; j++ {
			node := nextInt(scanner)
			A[idx-1][node-1] = 1
		}
	}
	var outBuffer bytes.Buffer
	for i:=0; i<N; i++ {
		outBuffer.WriteString(strings.TrimRight(fmt.Sprintf("%v",A[i])[1:], "]") + "\n")
	}
	fmt.Printf("%s", outBuffer.String())
}

Python: def main():
    n = int(input())

    adjacency_matrix = []
    for _ in range(n):
        u, k, *V = map(int, input().split())
        col = [0] * n
        for v in V:
            col[v-1] = 1
        adjacency_matrix.append(col)
    for col in adjacency_matrix:
        print(*col)


if __name__ == "__main__":
    main()

Python: n = int(input())
G = [[0 for i in range(n)] for j in range(n)]
for i in range(n):
    S = list(map(int, input().split()))
    tmp_n = S[1]
    for j in range(tmp_n):
        G[i][S[j+2]-1] = 1
for i in range(n):
    print(*G[i])

Python: n=int(input())
A=[list(map(int,input().split())) for i in range(n)]

M=[[0 for i in range(n)] for j in range(n)]
for i in range(n):
    for j in A[i][2:]:
        M[i][j-1]=1

for i in range(n):
    print(*M[i])

Python: from collections import deque
from enum import Enum
import sys
import math

BIG_NUM = 2000000000
MOD = 1000000007
EPS = 0.000000001


V = int(input())

table = [['0']*V for i in range(V)]

for loop in range(V):
    tmp_array = list(map(int,input().split()))
    node_id = tmp_array[0]-1
    for i in range(tmp_array[1]):
        table[node_id][tmp_array[2+i]-1] = '1'

for row in range(V):
    print(' '.join(table[row]))

Python: import sys

def debug(x, table):
    for name, val in table.items():
        if x is val:
            print('DEBUG:{} -> {}'.format(name, val), file=sys.stderr)
            return None

def solve():
    n = int(input())
    edge = [[0]*n for i in range(n)]

    for i in range(n):
        u, k, *vs = [int(j) - 1 for j in input().split()]
        # debug(vs, locals())
        for v in vs:
            edge[u][v] = 1

    for i in range(n):
        print(*edge[i])

    pass

if __name__ == '__main__':
    solve()

Python: import sys
input = sys.stdin.readline

def getNeighbor(A, i):
    a = len(A)
    for k in range(2, a):
        C[i][A[k]-1] = 1

N = int(input())
C = [[0]*N for _ in range(N)]
for i in range(N):
    A = list(map(int, input().split()))
    getNeighbor(A,i)
for i in range(N):
    print(*C[i])

Python: from sys import stdin
input = stdin.readline

n = int(input())
M = [['0']*n for _ in range(n)] # 0オリジンの隣接行列、0で初期化しておく

for _ in range(n):
    u, k, *vv = input().split()
    u = int(u)-1  # 0オリジンにする
    k = int(k)    # kは使わない
    for v in vv:
        v = int(v)-1  # 0オリジンにする
        M[u][v] = '1' #最後に出力するときstr型である必要があるので、str型で入力

for m in M:
    print(' '.join(m)) # 空白入れて出力

Python: n=int(input())
m=[[0]*n for i in range(n)]
for i in range(n):
    tmp=list(map(int,input().split()))
    for j in tmp[2:]:
        m[i][j-1]=1
for i in range(n):
    print(" ".join(list(map(str,m[i]))))

Python: v_num = int(input())
adjacent = [[0 for n in range(v_num)] for m in range(v_num)]
for _ in range(v_num):
    inp = [int(n) for n in input().split(" ")]
    for i in inp[2:]:
        adjacent[inp[0] - 1][i - 1] = 1
for i in range(v_num):
    print(*adjacent[i])

Python: n = int(input())
answerL = []
for i in range(n):
    inputL = input().split()
    newL = [0]*n
    k = int(inputL[1])
    for j in range(k):
        target = int(inputL[1+j+1])
        newL[target-1] = 1
    answerL.append(newL)
for ans in answerL:
    print(' '.join(list(map(str, ans))))

Python: n = int(input())
a = [[0]*n for i in range(n)]
  
for i in range(n):
    v = list(map(int, input().split()))
    u, k = v[0], v[1]
    for j in range(v[1]):
        a[u - 1][v[2 + j] - 1] = 1
 
for i in range(n):
    print(*a[i])

Python: import numpy as np
n=int(input())
g=np.zeros((n,n),dtype=np.int)
for i in range(n):
	s=list(map(int,input().split()))
	for j in range(s[1]):
		g[s[0]-1][s[2+j]-1]+=1
print(g)

Python: #!/usr/bin/env python
# -*- coding: utf-8 -*-


import sys


def generate_graph(v_info):
    for info in v_info:
        adj_info = info[2:]
        assert len(adj_info) == int(info[1])
        for each in adj_info:
            adj_matrix[int(info[0]) - 1][int(each) - 1] = 1
    return adj_matrix


if __name__ == '__main__':
    _input = sys.stdin.readlines()
    vertex_num = int(_input[0])
    vertex_info = list(map(lambda x: x.split(), _input[1:]))
    adj_matrix = [[0] * vertex_num for _ in range(vertex_num)]
    # assert len(vertex_info) == vertex_num

    ans = generate_graph(vertex_info)
    for v_result in ans:
        print(*v_result)

Python: def convertList(G):
    n = len(G)
    GL = [ [0 for _ in range(n)] for _ in range(n)]
    for key, values in G.items():
        GL[key - 1][key - 1] = 0
        for v in values:
            GL[key - 1][v - 1] = 1

    return GL


if __name__ == '__main__':
    G = {}
    n = int(input())
    for _ in range(n):
        tmp = list(map(int, input().split()))
        u = tmp.pop(0)
        k = tmp.pop(0)
        G[u] = tmp
    GL = convertList(G)
    for i in range(n):
        print(*GL[i])

Python: num = int(input())

mat = [[0 for i in range(num)] for j in range(num)]

for i in range(num):
    arr = list(map(int,input().split()))
    
    if  arr[1] >= 1:
        for j in range(len(arr)-2):
            m = arr[j+2]
            
            mat[i][m-1] += 1

    else:
        pass

for i in range(num):
    print(*mat[i])

Python: from sys import stdin

X = [ 0 for i in range(100) ]
G = [[ 0 for i in range(100) ] for i in range(100)]

n = int(input())
for i in range(n) :
	X[i] = stdin.readline().strip().split()


for i in range(n) :
	for j in range(int(X[i][1])) :
		G[i][int(X[i][j+2])-1] = 1

for i in range(n) :
	for j in range(n) :
		print(G[i][j],end=" ")
	print("")

Python: import sys, collections
input = lambda: sys.stdin.readline().rstrip() 
sys.setrecursionlimit(10**7)
INF = 10**10
def I(): return int(input())
def F(): return float(input())
def SS(): return input()
def LI(): return [int(x) for x in input().split()]
def LI_(): return [int(x)-1 for x in input().split()]
def LF(): return [float(x) for x in input().split()]
def LSS(): return input().split()

def resolve():
    n = I()
    Adj = [[0]*n for _ in range(n)]
    for _ in range(n):
        ukv = LI()
        u = ukv[0]
        # k = ukv[1]
        v = ukv[2:]
        for i in v:
            Adj[u-1][i-1] = 1

    for i in Adj:
        print(*i)

if __name__ == '__main__':
    resolve()

Python: n = int(input())
v_matrix = [[0 for j in range(n+1)] for i in range(n+1)]
for i in range(n):
    u, k, *v = map(int, input().split())
    for vi in v:
        v_matrix[u][vi] = 1

for row in v_matrix[1:]:
    print(" ".join(map(str, row[1:])))

Python: n = int(input())

A = [[0 for i in range(n)] for j in range(n)]

for i in range(n):

	B = input().split()

	if B[1]!=0:
		for j in range(int(B[1])):
			#B[2+j]
			A[i][int(B[2+j])-1] = 1

for i in range(n):
	for j in range(n):
		if j!=n-1:
			print(A[i][j], end=" ")
		else:
			print(A[i][j], end="\n")