Datasets:
lizn-zn
/
CodeNet_Extracted

Dataset card Data Studio Files
xet
 Community
1
submission_id
string
problem_id
string
status
string
code
string
input
string
output
string
problem_description
string
s275546897
p00067
Accepted
def dfs(land,y,x): land[y][x] = '0' if y > 0: if land[y-1][x] == '1': dfs(land,y-1,x) if y != 11: if (land[y+1][x] == '1'): dfs(land,y+1,x) if (x > 0): if (land[y][x-1] == '1'): dfs(land,y,x-1) if (x != 11) : if (land[y][x+1] == '1'): dfs(land,y,x+1) island = [] while True: try: ss = input() if ss : island.append(list(ss)) except: break num = int(len(island) / 12) for i in range(num): count = 0 for j in range(12): for k in range(12): if (island[i*12+j][k] == '1'): dfs(island[i*12:(i+1)*12],j,k) count += 1 print(count)
111100001111 111000001111 110000001111 100000001111 000100010000 000000111000 000001111100 100011111110 110001111100 111000111000 111100010000 000000000000 010001111100 110010000010 010010000001 010000000001 010000000110 010000111000 010000000100 010000000010 010000000001 010010000001 010010000010 111001111100 000000000000 111111111111 100010100001 100010100001 100010100001 100010100001 100100100101 101000011101 100000000001 100000000001 111111111111 100000000001
5 13 4
<H1>島の数</H1> <p> 地勢を示す縦 12, 横 12 のマスからなる平面図があります。おのおののマスは白か黒に塗られています。白は海を、黒は陸地を表します。二つの黒いマスが上下、あるいは左右に接しているとき、これらは地続きであるといいます。この平面図では、黒いマス一つのみ、あるいは地続きの黒いマスが作る領域を「島」といいます。例えば下図には、5 つの島があります。 </p> <pre> ■■■■□□□□■■■■ ■■■□□□□□■■■■ ■■□□□□□□■■■■ ■□□□□□□□■■■■ □□□■□□□■□□□□ □□□□□□■■■□□□ □□□□□■■■■■□□ ■□□□■■■■■■■□ ■■□□□■■■■■□□ ■■■□□□■■■□□□ ■■■■□□□■□□□□ □□□□□□□□□□□□ </pre> <p> マスのデータを読み込んで、島の数を出力するプログラムを作成してください。 </p> <H2>Input</H2> <p> 入力は複数のデータセットからなります。各データセットに１つの平面図が与えられます。黒いマスを 1、白いマスを 0 で表現した 12 個の数字の列 12 行でひとつの平面図を表します。データセットの間は１つの空行で区切られています。 </p> <p> データセットの数は 20 を超えません。 </p> <H2>Output</H2> <p> データセットごとに、島の数を１行に出力します。 </p> <H2>Sample Input</H2> <pre> 111100001111 111000001111 110000001111 100000001111 000100010000 000000111000 000001111100 100011111110 110001111100 111000111000 111100010000 000000000000 010001111100 110010000010 010010000001 010000000001 010000000110 010000111000 010000000100 010000000010 010000000001 010010000001 010010000010 111001111100 000000000000 111111111111 100010100001 100010100001 100010100001 100010100001 100100100101 101000011101 100000000001 100000000001 111111111111 100000000001 </pre> <H2>Output for the Sample Input</H2> <pre> 5 13 4 </pre> <H2>Hint</H2> <p> 以下はサンプルインプットを■と□で表したものです。 <pre> ■■■■□□□□■■■■　　□■□□□■■■■■□□　　□□□□□□□□□□□□ ■■■□□□□□■■■■　　■■□□■□□□□□■□　　■■■■■■■■■■■■ ■■□□□□□□■■■■　　□■□□■□□□□□□■　　■□□□■□■□□□□■ ■□□□□□□□■■■■　　□■□□□□□□□□□■　　■□□□■□■□□□□■ □□□■□□□■□□□□　　□■□□□□□□□■■□　　■□□□■□■□□□□■ □□□□□□■■■□□□　　□■□□□□■■■□□□　　■□□□■□■□□□□■ □□□□□■■■■■□□　　□■□□□□□□□■□□　　■□□■□□■□□■□■ ■□□□■■■■■■■□　　□■□□□□□□□□■□　　■□■□□□□■■■□■ ■■□□□■■■■■□□　　□■□□□□□□□□□■　　■□□□□□□□□□□■ ■■■□□□■■■□□□　　□■□□■□□□□□□■　　■□□□□□□□□□□■ ■■■■□□□■□□□□　　□■□□■□□□□□■□　　■■■■■■■■■■■■ □□□□□□□□□□□□　　■■■□□■■■■■□□　　■□□□□□□□□□□■ </pre> </p>
s853637698
p00067
Runtime Error
def isearch(field,dir1,dir2,I,J,Q): field[I][J]=0 for d in dir1: if field[min(11,I+d[0])][min(11,J+d[1])]: Q.append([I+d[0],J+d[1]]) for d in dir2: if field[max(0,I+d[0])][max(0,J+d[1])]: Q.append([I+d[0],J+d[1]]) if len(Q)!=0: [i,j]=Q.pop(0) isearch(field,dir1,dir2,i,j,Q) while(1): field=[] for i in range(12): field.append([int(x) for x in raw_input()]) Q=[] N=0 dir1=[[0,1],[1,0]] dir2=[[0,-1],[-1,0]] for i in range(12): for j in range(12): if field[i][j]: N=N+1 isearch(field,dir1,dir2,i,j,Q) print N try: raw_input() except: break
111100001111 111000001111 110000001111 100000001111 000100010000 000000111000 000001111100 100011111110 110001111100 111000111000 111100010000 000000000000 010001111100 110010000010 010010000001 010000000001 010000000110 010000111000 010000000100 010000000010 010000000001 010010000001 010010000010 111001111100 000000000000 111111111111 100010100001 100010100001 100010100001 100010100001 100100100101 101000011101 100000000001 100000000001 111111111111 100000000001
5 13 4
<H1>島の数</H1> <p> 地勢を示す縦 12, 横 12 のマスからなる平面図があります。おのおののマスは白か黒に塗られています。白は海を、黒は陸地を表します。二つの黒いマスが上下、あるいは左右に接しているとき、これらは地続きであるといいます。この平面図では、黒いマス一つのみ、あるいは地続きの黒いマスが作る領域を「島」といいます。例えば下図には、5 つの島があります。 </p> <pre> ■■■■□□□□■■■■ ■■■□□□□□■■■■ ■■□□□□□□■■■■ ■□□□□□□□■■■■ □□□■□□□■□□□□ □□□□□□■■■□□□ □□□□□■■■■■□□ ■□□□■■■■■■■□ ■■□□□■■■■■□□ ■■■□□□■■■□□□ ■■■■□□□■□□□□ □□□□□□□□□□□□ </pre> <p> マスのデータを読み込んで、島の数を出力するプログラムを作成してください。 </p> <H2>Input</H2> <p> 入力は複数のデータセットからなります。各データセットに１つの平面図が与えられます。黒いマスを 1、白いマスを 0 で表現した 12 個の数字の列 12 行でひとつの平面図を表します。データセットの間は１つの空行で区切られています。 </p> <p> データセットの数は 20 を超えません。 </p> <H2>Output</H2> <p> データセットごとに、島の数を１行に出力します。 </p> <H2>Sample Input</H2> <pre> 111100001111 111000001111 110000001111 100000001111 000100010000 000000111000 000001111100 100011111110 110001111100 111000111000 111100010000 000000000000 010001111100 110010000010 010010000001 010000000001 010000000110 010000111000 010000000100 010000000010 010000000001 010010000001 010010000010 111001111100 000000000000 111111111111 100010100001 100010100001 100010100001 100010100001 100100100101 101000011101 100000000001 100000000001 111111111111 100000000001 </pre> <H2>Output for the Sample Input</H2> <pre> 5 13 4 </pre> <H2>Hint</H2> <p> 以下はサンプルインプットを■と□で表したものです。 <pre> ■■■■□□□□■■■■　　□■□□□■■■■■□□　　□□□□□□□□□□□□ ■■■□□□□□■■■■　　■■□□■□□□□□■□　　■■■■■■■■■■■■ ■■□□□□□□■■■■　　□■□□■□□□□□□■　　■□□□■□■□□□□■ ■□□□□□□□■■■■　　□■□□□□□□□□□■　　■□□□■□■□□□□■ □□□■□□□■□□□□　　□■□□□□□□□■■□　　■□□□■□■□□□□■ □□□□□□■■■□□□　　□■□□□□■■■□□□　　■□□□■□■□□□□■ □□□□□■■■■■□□　　□■□□□□□□□■□□　　■□□■□□■□□■□■ ■□□□■■■■■■■□　　□■□□□□□□□□■□　　■□■□□□□■■■□■ ■■□□□■■■■■□□　　□■□□□□□□□□□■　　■□□□□□□□□□□■ ■■■□□□■■■□□□　　□■□□■□□□□□□■　　■□□□□□□□□□□■ ■■■■□□□■□□□□　　□■□□■□□□□□■□　　■■■■■■■■■■■■ □□□□□□□□□□□□　　■■■□□■■■■■□□　　■□□□□□□□□□□■ </pre> </p>
s186879297
p00067
Runtime Error
def isearch(field,dir1,dir2,I,J,Q): field[I][J]=0 for d in dir1: if field[min(11,I+d[0])][min(11,J+d[1])]: Q.append([I+d[0],J+d[1]]) for d in dir2: if field[max(0,I+d[0])][max(0,J+d[1])]: Q.append([I+d[0],J+d[1]]) if len(Q)!=0: [i,j]=Q.pop(0) isearch(field,dir1,dir2,i,j,Q) while(1): field=[] for i in range(12): field.append([int(x) for x in raw_input()]) Q=[] N=0 dir1=[[0,1],[1,0]] dir2=[[0,-1],[-1,0]] for i in range(12): for j in range(12): if field[i][j]: N=N+1 isearch(field,dir1,dir2,i,j,Q) print N try: skip=raw_input() except: break
111100001111 111000001111 110000001111 100000001111 000100010000 000000111000 000001111100 100011111110 110001111100 111000111000 111100010000 000000000000 010001111100 110010000010 010010000001 010000000001 010000000110 010000111000 010000000100 010000000010 010000000001 010010000001 010010000010 111001111100 000000000000 111111111111 100010100001 100010100001 100010100001 100010100001 100100100101 101000011101 100000000001 100000000001 111111111111 100000000001
5 13 4
<H1>島の数</H1> <p> 地勢を示す縦 12, 横 12 のマスからなる平面図があります。おのおののマスは白か黒に塗られています。白は海を、黒は陸地を表します。二つの黒いマスが上下、あるいは左右に接しているとき、これらは地続きであるといいます。この平面図では、黒いマス一つのみ、あるいは地続きの黒いマスが作る領域を「島」といいます。例えば下図には、5 つの島があります。 </p> <pre> ■■■■□□□□■■■■ ■■■□□□□□■■■■ ■■□□□□□□■■■■ ■□□□□□□□■■■■ □□□■□□□■□□□□ □□□□□□■■■□□□ □□□□□■■■■■□□ ■□□□■■■■■■■□ ■■□□□■■■■■□□ ■■■□□□■■■□□□ ■■■■□□□■□□□□ □□□□□□□□□□□□ </pre> <p> マスのデータを読み込んで、島の数を出力するプログラムを作成してください。 </p> <H2>Input</H2> <p> 入力は複数のデータセットからなります。各データセットに１つの平面図が与えられます。黒いマスを 1、白いマスを 0 で表現した 12 個の数字の列 12 行でひとつの平面図を表します。データセットの間は１つの空行で区切られています。 </p> <p> データセットの数は 20 を超えません。 </p> <H2>Output</H2> <p> データセットごとに、島の数を１行に出力します。 </p> <H2>Sample Input</H2> <pre> 111100001111 111000001111 110000001111 100000001111 000100010000 000000111000 000001111100 100011111110 110001111100 111000111000 111100010000 000000000000 010001111100 110010000010 010010000001 010000000001 010000000110 010000111000 010000000100 010000000010 010000000001 010010000001 010010000010 111001111100 000000000000 111111111111 100010100001 100010100001 100010100001 100010100001 100100100101 101000011101 100000000001 100000000001 111111111111 100000000001 </pre> <H2>Output for the Sample Input</H2> <pre> 5 13 4 </pre> <H2>Hint</H2> <p> 以下はサンプルインプットを■と□で表したものです。 <pre> ■■■■□□□□■■■■　　□■□□□■■■■■□□　　□□□□□□□□□□□□ ■■■□□□□□■■■■　　■■□□■□□□□□■□　　■■■■■■■■■■■■ ■■□□□□□□■■■■　　□■□□■□□□□□□■　　■□□□■□■□□□□■ ■□□□□□□□■■■■　　□■□□□□□□□□□■　　■□□□■□■□□□□■ □□□■□□□■□□□□　　□■□□□□□□□■■□　　■□□□■□■□□□□■ □□□□□□■■■□□□　　□■□□□□■■■□□□　　■□□□■□■□□□□■ □□□□□■■■■■□□　　□■□□□□□□□■□□　　■□□■□□■□□■□■ ■□□□■■■■■■■□　　□■□□□□□□□□■□　　■□■□□□□■■■□■ ■■□□□■■■■■□□　　□■□□□□□□□□□■　　■□□□□□□□□□□■ ■■■□□□■■■□□□　　□■□□■□□□□□□■　　■□□□□□□□□□□■ ■■■■□□□■□□□□　　□■□□■□□□□□■□　　■■■■■■■■■■■■ □□□□□□□□□□□□　　■■■□□■■■■■□□　　■□□□□□□□□□□■ </pre> </p>
s847225643
p00067
Runtime Error
import sys sys.setrecursionlimit(10000000) M, N = map(int, raw_input().split()) field = [[0] * (M + 2)] for i in range(N): row = [0] row.extend(map(int, raw_input().split())) row.append(0) field.append(row) field.append([0] * (M + 2)) def search(row, column): global field if field[row][column] == 0: return 0 field[row][column] = 0 search(row - 1, column) search(row + 1, column) search(row, column + 1) search(row, column - 1) return 1 ans = 0 for row in range(N): for column in range(M): ans += search(row + 1, column + 1) print ans
111100001111 111000001111 110000001111 100000001111 000100010000 000000111000 000001111100 100011111110 110001111100 111000111000 111100010000 000000000000 010001111100 110010000010 010010000001 010000000001 010000000110 010000111000 010000000100 010000000010 010000000001 010010000001 010010000010 111001111100 000000000000 111111111111 100010100001 100010100001 100010100001 100010100001 100100100101 101000011101 100000000001 100000000001 111111111111 100000000001
5 13 4
<H1>島の数</H1> <p> 地勢を示す縦 12, 横 12 のマスからなる平面図があります。おのおののマスは白か黒に塗られています。白は海を、黒は陸地を表します。二つの黒いマスが上下、あるいは左右に接しているとき、これらは地続きであるといいます。この平面図では、黒いマス一つのみ、あるいは地続きの黒いマスが作る領域を「島」といいます。例えば下図には、5 つの島があります。 </p> <pre> ■■■■□□□□■■■■ ■■■□□□□□■■■■ ■■□□□□□□■■■■ ■□□□□□□□■■■■ □□□■□□□■□□□□ □□□□□□■■■□□□ □□□□□■■■■■□□ ■□□□■■■■■■■□ ■■□□□■■■■■□□ ■■■□□□■■■□□□ ■■■■□□□■□□□□ □□□□□□□□□□□□ </pre> <p> マスのデータを読み込んで、島の数を出力するプログラムを作成してください。 </p> <H2>Input</H2> <p> 入力は複数のデータセットからなります。各データセットに１つの平面図が与えられます。黒いマスを 1、白いマスを 0 で表現した 12 個の数字の列 12 行でひとつの平面図を表します。データセットの間は１つの空行で区切られています。 </p> <p> データセットの数は 20 を超えません。 </p> <H2>Output</H2> <p> データセットごとに、島の数を１行に出力します。 </p> <H2>Sample Input</H2> <pre> 111100001111 111000001111 110000001111 100000001111 000100010000 000000111000 000001111100 100011111110 110001111100 111000111000 111100010000 000000000000 010001111100 110010000010 010010000001 010000000001 010000000110 010000111000 010000000100 010000000010 010000000001 010010000001 010010000010 111001111100 000000000000 111111111111 100010100001 100010100001 100010100001 100010100001 100100100101 101000011101 100000000001 100000000001 111111111111 100000000001 </pre> <H2>Output for the Sample Input</H2> <pre> 5 13 4 </pre> <H2>Hint</H2> <p> 以下はサンプルインプットを■と□で表したものです。 <pre> ■■■■□□□□■■■■　　□■□□□■■■■■□□　　□□□□□□□□□□□□ ■■■□□□□□■■■■　　■■□□■□□□□□■□　　■■■■■■■■■■■■ ■■□□□□□□■■■■　　□■□□■□□□□□□■　　■□□□■□■□□□□■ ■□□□□□□□■■■■　　□■□□□□□□□□□■　　■□□□■□■□□□□■ □□□■□□□■□□□□　　□■□□□□□□□■■□　　■□□□■□■□□□□■ □□□□□□■■■□□□　　□■□□□□■■■□□□　　■□□□■□■□□□□■ □□□□□■■■■■□□　　□■□□□□□□□■□□　　■□□■□□■□□■□■ ■□□□■■■■■■■□　　□■□□□□□□□□■□　　■□■□□□□■■■□■ ■■□□□■■■■■□□　　□■□□□□□□□□□■　　■□□□□□□□□□□■ ■■■□□□■■■□□□　　□■□□■□□□□□□■　　■□□□□□□□□□□■ ■■■■□□□■□□□□　　□■□□■□□□□□■□　　■■■■■■■■■■■■ □□□□□□□□□□□□　　■■■□□■■■■■□□　　■□□□□□□□□□□■ </pre> </p>
s380686097
p00067
Runtime Error
import sys def quartet(h, w): global flag if 0 <= h <= 11 and 0 <= w <= 11: if mapp[h][w] == '1': mapp[h][w] = '$' flag = True bigbang(h, w) elif mapp[h][w] == '0' or mapp[h][w] == '$': return else: return def bigbang(h, w): quartet(h, w+1) quartet(h-1,w) quartet(h, w-1) quartet(h+1, w) while True: try: mapp = [] for line in sys.stdin: lis = [] for char in line.rstrip(): lis.append(char) else: mapp.append(lis) flag = False count = 0 for h in range(12): for w in range(12): quartet(h, w) if flag == True: count += 1 flag = False else: print count if raw_input == '': continue except EOFError: break
111100001111 111000001111 110000001111 100000001111 000100010000 000000111000 000001111100 100011111110 110001111100 111000111000 111100010000 000000000000 010001111100 110010000010 010010000001 010000000001 010000000110 010000111000 010000000100 010000000010 010000000001 010010000001 010010000010 111001111100 000000000000 111111111111 100010100001 100010100001 100010100001 100010100001 100100100101 101000011101 100000000001 100000000001 111111111111 100000000001
5 13 4
<H1>島の数</H1> <p> 地勢を示す縦 12, 横 12 のマスからなる平面図があります。おのおののマスは白か黒に塗られています。白は海を、黒は陸地を表します。二つの黒いマスが上下、あるいは左右に接しているとき、これらは地続きであるといいます。この平面図では、黒いマス一つのみ、あるいは地続きの黒いマスが作る領域を「島」といいます。例えば下図には、5 つの島があります。 </p> <pre> ■■■■□□□□■■■■ ■■■□□□□□■■■■ ■■□□□□□□■■■■ ■□□□□□□□■■■■ □□□■□□□■□□□□ □□□□□□■■■□□□ □□□□□■■■■■□□ ■□□□■■■■■■■□ ■■□□□■■■■■□□ ■■■□□□■■■□□□ ■■■■□□□■□□□□ □□□□□□□□□□□□ </pre> <p> マスのデータを読み込んで、島の数を出力するプログラムを作成してください。 </p> <H2>Input</H2> <p> 入力は複数のデータセットからなります。各データセットに１つの平面図が与えられます。黒いマスを 1、白いマスを 0 で表現した 12 個の数字の列 12 行でひとつの平面図を表します。データセットの間は１つの空行で区切られています。 </p> <p> データセットの数は 20 を超えません。 </p> <H2>Output</H2> <p> データセットごとに、島の数を１行に出力します。 </p> <H2>Sample Input</H2> <pre> 111100001111 111000001111 110000001111 100000001111 000100010000 000000111000 000001111100 100011111110 110001111100 111000111000 111100010000 000000000000 010001111100 110010000010 010010000001 010000000001 010000000110 010000111000 010000000100 010000000010 010000000001 010010000001 010010000010 111001111100 000000000000 111111111111 100010100001 100010100001 100010100001 100010100001 100100100101 101000011101 100000000001 100000000001 111111111111 100000000001 </pre> <H2>Output for the Sample Input</H2> <pre> 5 13 4 </pre> <H2>Hint</H2> <p> 以下はサンプルインプットを■と□で表したものです。 <pre> ■■■■□□□□■■■■　　□■□□□■■■■■□□　　□□□□□□□□□□□□ ■■■□□□□□■■■■　　■■□□■□□□□□■□　　■■■■■■■■■■■■ ■■□□□□□□■■■■　　□■□□■□□□□□□■　　■□□□■□■□□□□■ ■□□□□□□□■■■■　　□■□□□□□□□□□■　　■□□□■□■□□□□■ □□□■□□□■□□□□　　□■□□□□□□□■■□　　■□□□■□■□□□□■ □□□□□□■■■□□□　　□■□□□□■■■□□□　　■□□□■□■□□□□■ □□□□□■■■■■□□　　□■□□□□□□□■□□　　■□□■□□■□□■□■ ■□□□■■■■■■■□　　□■□□□□□□□□■□　　■□■□□□□■■■□■ ■■□□□■■■■■□□　　□■□□□□□□□□□■　　■□□□□□□□□□□■ ■■■□□□■■■□□□　　□■□□■□□□□□□■　　■□□□□□□□□□□■ ■■■■□□□■□□□□　　□■□□■□□□□□■□　　■■■■■■■■■■■■ □□□□□□□□□□□□　　■■■□□■■■■■□□　　■□□□□□□□□□□■ </pre> </p>
s257019218
p00067
Runtime Error
import sys def quartet(h, w): global flag if 0 <= h <= 11 and 0 <= w <= 11: if mapp[h][w] == '1': mapp[h][w] = '$' flag = True bigbang(h, w) elif mapp[h][w] == '0' or mapp[h][w] == '$': return else: return def bigbang(h, w): quartet(h, w+1) quartet(h-1,w) quartet(h, w-1) quartet(h+1, w) while True: try: mapp = [] for i in range(12): line = raw_input() lis = [] for char in line: lis.append(char) else: mapp.append(lis) flag = False count = 0 for h in range(12): for w in range(12): quartet(h, w) if flag == True: count += 1 flag = False else: print count if raw_input == '': continue except EOFError: break
111100001111 111000001111 110000001111 100000001111 000100010000 000000111000 000001111100 100011111110 110001111100 111000111000 111100010000 000000000000 010001111100 110010000010 010010000001 010000000001 010000000110 010000111000 010000000100 010000000010 010000000001 010010000001 010010000010 111001111100 000000000000 111111111111 100010100001 100010100001 100010100001 100010100001 100100100101 101000011101 100000000001 100000000001 111111111111 100000000001
5 13 4
<H1>島の数</H1> <p> 地勢を示す縦 12, 横 12 のマスからなる平面図があります。おのおののマスは白か黒に塗られています。白は海を、黒は陸地を表します。二つの黒いマスが上下、あるいは左右に接しているとき、これらは地続きであるといいます。この平面図では、黒いマス一つのみ、あるいは地続きの黒いマスが作る領域を「島」といいます。例えば下図には、5 つの島があります。 </p> <pre> ■■■■□□□□■■■■ ■■■□□□□□■■■■ ■■□□□□□□■■■■ ■□□□□□□□■■■■ □□□■□□□■□□□□ □□□□□□■■■□□□ □□□□□■■■■■□□ ■□□□■■■■■■■□ ■■□□□■■■■■□□ ■■■□□□■■■□□□ ■■■■□□□■□□□□ □□□□□□□□□□□□ </pre> <p> マスのデータを読み込んで、島の数を出力するプログラムを作成してください。 </p> <H2>Input</H2> <p> 入力は複数のデータセットからなります。各データセットに１つの平面図が与えられます。黒いマスを 1、白いマスを 0 で表現した 12 個の数字の列 12 行でひとつの平面図を表します。データセットの間は１つの空行で区切られています。 </p> <p> データセットの数は 20 を超えません。 </p> <H2>Output</H2> <p> データセットごとに、島の数を１行に出力します。 </p> <H2>Sample Input</H2> <pre> 111100001111 111000001111 110000001111 100000001111 000100010000 000000111000 000001111100 100011111110 110001111100 111000111000 111100010000 000000000000 010001111100 110010000010 010010000001 010000000001 010000000110 010000111000 010000000100 010000000010 010000000001 010010000001 010010000010 111001111100 000000000000 111111111111 100010100001 100010100001 100010100001 100010100001 100100100101 101000011101 100000000001 100000000001 111111111111 100000000001 </pre> <H2>Output for the Sample Input</H2> <pre> 5 13 4 </pre> <H2>Hint</H2> <p> 以下はサンプルインプットを■と□で表したものです。 <pre> ■■■■□□□□■■■■　　□■□□□■■■■■□□　　□□□□□□□□□□□□ ■■■□□□□□■■■■　　■■□□■□□□□□■□　　■■■■■■■■■■■■ ■■□□□□□□■■■■　　□■□□■□□□□□□■　　■□□□■□■□□□□■ ■□□□□□□□■■■■　　□■□□□□□□□□□■　　■□□□■□■□□□□■ □□□■□□□■□□□□　　□■□□□□□□□■■□　　■□□□■□■□□□□■ □□□□□□■■■□□□　　□■□□□□■■■□□□　　■□□□■□■□□□□■ □□□□□■■■■■□□　　□■□□□□□□□■□□　　■□□■□□■□□■□■ ■□□□■■■■■■■□　　□■□□□□□□□□■□　　■□■□□□□■■■□■ ■■□□□■■■■■□□　　□■□□□□□□□□□■　　■□□□□□□□□□□■ ■■■□□□■■■□□□　　□■□□■□□□□□□■　　■□□□□□□□□□□■ ■■■■□□□■□□□□　　□■□□■□□□□□■□　　■■■■■■■■■■■■ □□□□□□□□□□□□　　■■■□□■■■■■□□　　■□□□□□□□□□□■ </pre> </p>
s003322971
p00067
Runtime Error
class Depth_First_Search_stack: def __init__(self, map): self.map = map self.num_island = 0 self.stack = [] self.start_point = None def get_start_point(self): get_start = False for i in range(12): for j in range(12): if self.map[i][j] == '1': self.start_point = [i, j] get_start = True return get_start def check(self, new_r, new_c): return 0<=new_r<12 and 0<=new_c<12 and self.map[new_r][new_c] == '1' def search(self, r, c): while self.stack: r, c = self.stack.pop() self.map[r][c] = '0' for (i, j) in [[1, 0], [0, 1], [-1, 0], [0, -1]]: if self.check(r+i, c+j): self.stack.append([r+i, c+j]) def run(self): while self.get_start_point(): r, c = self.start_point self.stack.append([r, c]) self.search(r, c) self.num_island += 1 if __name__ == '__main__': while 1: map = [] for i in range(12): row = [x for x in input()] map.append(row) if len(map[0]) != 12: break DFS = Depth_First_Search_stack(map) DFS.run() print(DFS.num_island) empty = input()
111100001111 111000001111 110000001111 100000001111 000100010000 000000111000 000001111100 100011111110 110001111100 111000111000 111100010000 000000000000 010001111100 110010000010 010010000001 010000000001 010000000110 010000111000 010000000100 010000000010 010000000001 010010000001 010010000010 111001111100 000000000000 111111111111 100010100001 100010100001 100010100001 100010100001 100100100101 101000011101 100000000001 100000000001 111111111111 100000000001
5 13 4
<H1>島の数</H1> <p> 地勢を示す縦 12, 横 12 のマスからなる平面図があります。おのおののマスは白か黒に塗られています。白は海を、黒は陸地を表します。二つの黒いマスが上下、あるいは左右に接しているとき、これらは地続きであるといいます。この平面図では、黒いマス一つのみ、あるいは地続きの黒いマスが作る領域を「島」といいます。例えば下図には、5 つの島があります。 </p> <pre> ■■■■□□□□■■■■ ■■■□□□□□■■■■ ■■□□□□□□■■■■ ■□□□□□□□■■■■ □□□■□□□■□□□□ □□□□□□■■■□□□ □□□□□■■■■■□□ ■□□□■■■■■■■□ ■■□□□■■■■■□□ ■■■□□□■■■□□□ ■■■■□□□■□□□□ □□□□□□□□□□□□ </pre> <p> マスのデータを読み込んで、島の数を出力するプログラムを作成してください。 </p> <H2>Input</H2> <p> 入力は複数のデータセットからなります。各データセットに１つの平面図が与えられます。黒いマスを 1、白いマスを 0 で表現した 12 個の数字の列 12 行でひとつの平面図を表します。データセットの間は１つの空行で区切られています。 </p> <p> データセットの数は 20 を超えません。 </p> <H2>Output</H2> <p> データセットごとに、島の数を１行に出力します。 </p> <H2>Sample Input</H2> <pre> 111100001111 111000001111 110000001111 100000001111 000100010000 000000111000 000001111100 100011111110 110001111100 111000111000 111100010000 000000000000 010001111100 110010000010 010010000001 010000000001 010000000110 010000111000 010000000100 010000000010 010000000001 010010000001 010010000010 111001111100 000000000000 111111111111 100010100001 100010100001 100010100001 100010100001 100100100101 101000011101 100000000001 100000000001 111111111111 100000000001 </pre> <H2>Output for the Sample Input</H2> <pre> 5 13 4 </pre> <H2>Hint</H2> <p> 以下はサンプルインプットを■と□で表したものです。 <pre> ■■■■□□□□■■■■　　□■□□□■■■■■□□　　□□□□□□□□□□□□ ■■■□□□□□■■■■　　■■□□■□□□□□■□　　■■■■■■■■■■■■ ■■□□□□□□■■■■　　□■□□■□□□□□□■　　■□□□■□■□□□□■ ■□□□□□□□■■■■　　□■□□□□□□□□□■　　■□□□■□■□□□□■ □□□■□□□■□□□□　　□■□□□□□□□■■□　　■□□□■□■□□□□■ □□□□□□■■■□□□　　□■□□□□■■■□□□　　■□□□■□■□□□□■ □□□□□■■■■■□□　　□■□□□□□□□■□□　　■□□■□□■□□■□■ ■□□□■■■■■■■□　　□■□□□□□□□□■□　　■□■□□□□■■■□■ ■■□□□■■■■■□□　　□■□□□□□□□□□■　　■□□□□□□□□□□■ ■■■□□□■■■□□□　　□■□□■□□□□□□■　　■□□□□□□□□□□■ ■■■■□□□■□□□□　　□■□□■□□□□□■□　　■■■■■■■■■■■■ □□□□□□□□□□□□　　■■■□□■■■■■□□　　■□□□□□□□□□□■ </pre> </p>
s816876003
p00067
Runtime Error
class Depth_First_Search_stack: def __init__(self, map): self.map = map self.num_island = 0 self.stack = [] self.start_point = None def get_start_point(self): get_start = False for i in range(12): for j in range(12): if self.map[i][j] == '1': self.start_point = [i, j] get_start = True return get_start def check(self, new_r, new_c): return 0<=new_r<12 and 0<=new_c<12 and self.map[new_r][new_c] == '1' def search(self, r, c): while self.stack: r, c = self.stack.pop() self.map[r][c] = '0' for (i, j) in [[1, 0], [0, 1], [-1, 0], [0, -1]]: if self.check(r+i, c+j): self.stack.append([r+i, c+j]) def run(self): while self.get_start_point(): r, c = self.start_point self.stack.append([r, c]) self.search(r, c) self.num_island += 1 if __name__ == '__main__': while 1: stop_flag = False map = [] for i in range(12): row = [x for x in input()] if i==0: if len(row) != 12: stop_flag = True break map.append(row) if stop_flag: break DFS = Depth_First_Search_stack(map) DFS.run() print(DFS.num_island) empty = input()
111100001111 111000001111 110000001111 100000001111 000100010000 000000111000 000001111100 100011111110 110001111100 111000111000 111100010000 000000000000 010001111100 110010000010 010010000001 010000000001 010000000110 010000111000 010000000100 010000000010 010000000001 010010000001 010010000010 111001111100 000000000000 111111111111 100010100001 100010100001 100010100001 100010100001 100100100101 101000011101 100000000001 100000000001 111111111111 100000000001
5 13 4
<H1>島の数</H1> <p> 地勢を示す縦 12, 横 12 のマスからなる平面図があります。おのおののマスは白か黒に塗られています。白は海を、黒は陸地を表します。二つの黒いマスが上下、あるいは左右に接しているとき、これらは地続きであるといいます。この平面図では、黒いマス一つのみ、あるいは地続きの黒いマスが作る領域を「島」といいます。例えば下図には、5 つの島があります。 </p> <pre> ■■■■□□□□■■■■ ■■■□□□□□■■■■ ■■□□□□□□■■■■ ■□□□□□□□■■■■ □□□■□□□■□□□□ □□□□□□■■■□□□ □□□□□■■■■■□□ ■□□□■■■■■■■□ ■■□□□■■■■■□□ ■■■□□□■■■□□□ ■■■■□□□■□□□□ □□□□□□□□□□□□ </pre> <p> マスのデータを読み込んで、島の数を出力するプログラムを作成してください。 </p> <H2>Input</H2> <p> 入力は複数のデータセットからなります。各データセットに１つの平面図が与えられます。黒いマスを 1、白いマスを 0 で表現した 12 個の数字の列 12 行でひとつの平面図を表します。データセットの間は１つの空行で区切られています。 </p> <p> データセットの数は 20 を超えません。 </p> <H2>Output</H2> <p> データセットごとに、島の数を１行に出力します。 </p> <H2>Sample Input</H2> <pre> 111100001111 111000001111 110000001111 100000001111 000100010000 000000111000 000001111100 100011111110 110001111100 111000111000 111100010000 000000000000 010001111100 110010000010 010010000001 010000000001 010000000110 010000111000 010000000100 010000000010 010000000001 010010000001 010010000010 111001111100 000000000000 111111111111 100010100001 100010100001 100010100001 100010100001 100100100101 101000011101 100000000001 100000000001 111111111111 100000000001 </pre> <H2>Output for the Sample Input</H2> <pre> 5 13 4 </pre> <H2>Hint</H2> <p> 以下はサンプルインプットを■と□で表したものです。 <pre> ■■■■□□□□■■■■　　□■□□□■■■■■□□　　□□□□□□□□□□□□ ■■■□□□□□■■■■　　■■□□■□□□□□■□　　■■■■■■■■■■■■ ■■□□□□□□■■■■　　□■□□■□□□□□□■　　■□□□■□■□□□□■ ■□□□□□□□■■■■　　□■□□□□□□□□□■　　■□□□■□■□□□□■ □□□■□□□■□□□□　　□■□□□□□□□■■□　　■□□□■□■□□□□■ □□□□□□■■■□□□　　□■□□□□■■■□□□　　■□□□■□■□□□□■ □□□□□■■■■■□□　　□■□□□□□□□■□□　　■□□■□□■□□■□■ ■□□□■■■■■■■□　　□■□□□□□□□□■□　　■□■□□□□■■■□■ ■■□□□■■■■■□□　　□■□□□□□□□□□■　　■□□□□□□□□□□■ ■■■□□□■■■□□□　　□■□□■□□□□□□■　　■□□□□□□□□□□■ ■■■■□□□■□□□□　　□■□□■□□□□□■□　　■■■■■■■■■■■■ □□□□□□□□□□□□　　■■■□□■■■■■□□　　■□□□□□□□□□□■ </pre> </p>
s123953638
p00067
Runtime Error
class Depth_First_Search_stack: def __init__(self, map): self.map = map self.num_island = 0 self.stack = [] self.start_point = None def get_start_point(self): get_start = False for i in range(12): for j in range(12): if self.map[i][j] == '1': self.start_point = [i, j] get_start = True return get_start def check(self, new_r, new_c): return 0<=new_r<12 and 0<=new_c<12 and self.map[new_r][new_c] == '1' def search(self, r, c): while self.stack: r, c = self.stack.pop() self.map[r][c] = '0' for (i, j) in [[1, 0], [0, 1], [-1, 0], [0, -1]]: if self.check(r+i, c+j): self.stack.append([r+i, c+j]) def run(self): while self.get_start_point(): r, c = self.start_point self.stack.append([r, c]) self.search(r, c) self.num_island += 1 if __name__ == '__main__': for t in range(20): stop_flag = False map = [] for i in range(12): row = [x for x in input()] if i==0: if len(row) != 12: stop_flag = True break map.append(row) if stop_flag: break DFS = Depth_First_Search_stack(map) DFS.run() print(DFS.num_island) empty = input()
111100001111 111000001111 110000001111 100000001111 000100010000 000000111000 000001111100 100011111110 110001111100 111000111000 111100010000 000000000000 010001111100 110010000010 010010000001 010000000001 010000000110 010000111000 010000000100 010000000010 010000000001 010010000001 010010000010 111001111100 000000000000 111111111111 100010100001 100010100001 100010100001 100010100001 100100100101 101000011101 100000000001 100000000001 111111111111 100000000001
5 13 4
<H1>島の数</H1> <p> 地勢を示す縦 12, 横 12 のマスからなる平面図があります。おのおののマスは白か黒に塗られています。白は海を、黒は陸地を表します。二つの黒いマスが上下、あるいは左右に接しているとき、これらは地続きであるといいます。この平面図では、黒いマス一つのみ、あるいは地続きの黒いマスが作る領域を「島」といいます。例えば下図には、5 つの島があります。 </p> <pre> ■■■■□□□□■■■■ ■■■□□□□□■■■■ ■■□□□□□□■■■■ ■□□□□□□□■■■■ □□□■□□□■□□□□ □□□□□□■■■□□□ □□□□□■■■■■□□ ■□□□■■■■■■■□ ■■□□□■■■■■□□ ■■■□□□■■■□□□ ■■■■□□□■□□□□ □□□□□□□□□□□□ </pre> <p> マスのデータを読み込んで、島の数を出力するプログラムを作成してください。 </p> <H2>Input</H2> <p> 入力は複数のデータセットからなります。各データセットに１つの平面図が与えられます。黒いマスを 1、白いマスを 0 で表現した 12 個の数字の列 12 行でひとつの平面図を表します。データセットの間は１つの空行で区切られています。 </p> <p> データセットの数は 20 を超えません。 </p> <H2>Output</H2> <p> データセットごとに、島の数を１行に出力します。 </p> <H2>Sample Input</H2> <pre> 111100001111 111000001111 110000001111 100000001111 000100010000 000000111000 000001111100 100011111110 110001111100 111000111000 111100010000 000000000000 010001111100 110010000010 010010000001 010000000001 010000000110 010000111000 010000000100 010000000010 010000000001 010010000001 010010000010 111001111100 000000000000 111111111111 100010100001 100010100001 100010100001 100010100001 100100100101 101000011101 100000000001 100000000001 111111111111 100000000001 </pre> <H2>Output for the Sample Input</H2> <pre> 5 13 4 </pre> <H2>Hint</H2> <p> 以下はサンプルインプットを■と□で表したものです。 <pre> ■■■■□□□□■■■■　　□■□□□■■■■■□□　　□□□□□□□□□□□□ ■■■□□□□□■■■■　　■■□□■□□□□□■□　　■■■■■■■■■■■■ ■■□□□□□□■■■■　　□■□□■□□□□□□■　　■□□□■□■□□□□■ ■□□□□□□□■■■■　　□■□□□□□□□□□■　　■□□□■□■□□□□■ □□□■□□□■□□□□　　□■□□□□□□□■■□　　■□□□■□■□□□□■ □□□□□□■■■□□□　　□■□□□□■■■□□□　　■□□□■□■□□□□■ □□□□□■■■■■□□　　□■□□□□□□□■□□　　■□□■□□■□□■□■ ■□□□■■■■■■■□　　□■□□□□□□□□■□　　■□■□□□□■■■□■ ■■□□□■■■■■□□　　□■□□□□□□□□□■　　■□□□□□□□□□□■ ■■■□□□■■■□□□　　□■□□■□□□□□□■　　■□□□□□□□□□□■ ■■■■□□□■□□□□　　□■□□■□□□□□■□　　■■■■■■■■■■■■ □□□□□□□□□□□□　　■■■□□■■■■■□□　　■□□□□□□□□□□■ </pre> </p>
s080202026
p00067
Runtime Error
class Depth_First_Search_stack: def __init__(self, map): self.map = map self.num_island = 0 self.stack = [] self.start_point = None def get_start_point(self): get_start = False for i in range(12): for j in range(12): if self.map[i][j] == '1': self.start_point = [i, j] get_start = True return get_start def check(self, new_r, new_c): return 0<=new_r<12 and 0<=new_c<12 and self.map[new_r][new_c] == '1' def search(self, r, c): while self.stack: r, c = self.stack.pop() self.map[r][c] = '0' for (i, j) in [[1, 0], [0, 1], [-1, 0], [0, -1]]: if self.check(r+i, c+j): self.stack.append([r+i, c+j]) def run(self): while self.get_start_point(): r, c = self.start_point self.stack.append([r, c]) self.search(r, c) self.num_island += 1 if __name__ == '__main__': for t in range(20): stop_flag = False map = [] for i in range(12): row = [x for x in input()] if i==0: if len(row) != 12: stop_flag = True break map.append(row) if stop_flag: break DFS = Depth_First_Search_stack(map) DFS.run() print(DFS.num_island) empty = input()
111100001111 111000001111 110000001111 100000001111 000100010000 000000111000 000001111100 100011111110 110001111100 111000111000 111100010000 000000000000 010001111100 110010000010 010010000001 010000000001 010000000110 010000111000 010000000100 010000000010 010000000001 010010000001 010010000010 111001111100 000000000000 111111111111 100010100001 100010100001 100010100001 100010100001 100100100101 101000011101 100000000001 100000000001 111111111111 100000000001
5 13 4
<H1>島の数</H1> <p> 地勢を示す縦 12, 横 12 のマスからなる平面図があります。おのおののマスは白か黒に塗られています。白は海を、黒は陸地を表します。二つの黒いマスが上下、あるいは左右に接しているとき、これらは地続きであるといいます。この平面図では、黒いマス一つのみ、あるいは地続きの黒いマスが作る領域を「島」といいます。例えば下図には、5 つの島があります。 </p> <pre> ■■■■□□□□■■■■ ■■■□□□□□■■■■ ■■□□□□□□■■■■ ■□□□□□□□■■■■ □□□■□□□■□□□□ □□□□□□■■■□□□ □□□□□■■■■■□□ ■□□□■■■■■■■□ ■■□□□■■■■■□□ ■■■□□□■■■□□□ ■■■■□□□■□□□□ □□□□□□□□□□□□ </pre> <p> マスのデータを読み込んで、島の数を出力するプログラムを作成してください。 </p> <H2>Input</H2> <p> 入力は複数のデータセットからなります。各データセットに１つの平面図が与えられます。黒いマスを 1、白いマスを 0 で表現した 12 個の数字の列 12 行でひとつの平面図を表します。データセットの間は１つの空行で区切られています。 </p> <p> データセットの数は 20 を超えません。 </p> <H2>Output</H2> <p> データセットごとに、島の数を１行に出力します。 </p> <H2>Sample Input</H2> <pre> 111100001111 111000001111 110000001111 100000001111 000100010000 000000111000 000001111100 100011111110 110001111100 111000111000 111100010000 000000000000 010001111100 110010000010 010010000001 010000000001 010000000110 010000111000 010000000100 010000000010 010000000001 010010000001 010010000010 111001111100 000000000000 111111111111 100010100001 100010100001 100010100001 100010100001 100100100101 101000011101 100000000001 100000000001 111111111111 100000000001 </pre> <H2>Output for the Sample Input</H2> <pre> 5 13 4 </pre> <H2>Hint</H2> <p> 以下はサンプルインプットを■と□で表したものです。 <pre> ■■■■□□□□■■■■　　□■□□□■■■■■□□　　□□□□□□□□□□□□ ■■■□□□□□■■■■　　■■□□■□□□□□■□　　■■■■■■■■■■■■ ■■□□□□□□■■■■　　□■□□■□□□□□□■　　■□□□■□■□□□□■ ■□□□□□□□■■■■　　□■□□□□□□□□□■　　■□□□■□■□□□□■ □□□■□□□■□□□□　　□■□□□□□□□■■□　　■□□□■□■□□□□■ □□□□□□■■■□□□　　□■□□□□■■■□□□　　■□□□■□■□□□□■ □□□□□■■■■■□□　　□■□□□□□□□■□□　　■□□■□□■□□■□■ ■□□□■■■■■■■□　　□■□□□□□□□□■□　　■□■□□□□■■■□■ ■■□□□■■■■■□□　　□■□□□□□□□□□■　　■□□□□□□□□□□■ ■■■□□□■■■□□□　　□■□□■□□□□□□■　　■□□□□□□□□□□■ ■■■■□□□■□□□□　　□■□□■□□□□□■□　　■■■■■■■■■■■■ □□□□□□□□□□□□　　■■■□□■■■■■□□　　■□□□□□□□□□□■ </pre> </p>
s416351115
p00067
Runtime Error
class Depth_First_Search_stack: def __init__(self, map): self.map = map self.num_island = 0 self.stack = [] self.start_point = None def get_start_point(self): get_start = False for i in range(12): for j in range(12): if self.map[i][j] == '1': self.start_point = [i, j] get_start = True return get_start def check(self, new_r, new_c): if not(0<=new_r<12 and 0<=new_c<12): return False else: return self.map[new_r][new_c] == '1' def search(self, r, c): self.stack.append(self.start_point) while self.stack: r, c = self.stack.pop() self.map[r][c] = '0' for (i, j) in [[1, 0], [0, 1], [-1, 0], [0, -1]]: if self.check(r+i, c+j): self.stack.append([r+i, c+j]) def run(self): while self.get_start_point(): r, c = self.start_point self.search(r, c) self.num_island += 1 if __name__ == '__main__': for t in range(20): stop_flag = False map = [] for i in range(12): row = [x for x in input()] if i==0: if len(row) != 12: stop_flag = True break map.append(row) if stop_flag: break DFS = Depth_First_Search_stack(map) DFS.run() print(DFS.num_island) empty = input()
111100001111 111000001111 110000001111 100000001111 000100010000 000000111000 000001111100 100011111110 110001111100 111000111000 111100010000 000000000000 010001111100 110010000010 010010000001 010000000001 010000000110 010000111000 010000000100 010000000010 010000000001 010010000001 010010000010 111001111100 000000000000 111111111111 100010100001 100010100001 100010100001 100010100001 100100100101 101000011101 100000000001 100000000001 111111111111 100000000001
5 13 4
<H1>島の数</H1> <p> 地勢を示す縦 12, 横 12 のマスからなる平面図があります。おのおののマスは白か黒に塗られています。白は海を、黒は陸地を表します。二つの黒いマスが上下、あるいは左右に接しているとき、これらは地続きであるといいます。この平面図では、黒いマス一つのみ、あるいは地続きの黒いマスが作る領域を「島」といいます。例えば下図には、5 つの島があります。 </p> <pre> ■■■■□□□□■■■■ ■■■□□□□□■■■■ ■■□□□□□□■■■■ ■□□□□□□□■■■■ □□□■□□□■□□□□ □□□□□□■■■□□□ □□□□□■■■■■□□ ■□□□■■■■■■■□ ■■□□□■■■■■□□ ■■■□□□■■■□□□ ■■■■□□□■□□□□ □□□□□□□□□□□□ </pre> <p> マスのデータを読み込んで、島の数を出力するプログラムを作成してください。 </p> <H2>Input</H2> <p> 入力は複数のデータセットからなります。各データセットに１つの平面図が与えられます。黒いマスを 1、白いマスを 0 で表現した 12 個の数字の列 12 行でひとつの平面図を表します。データセットの間は１つの空行で区切られています。 </p> <p> データセットの数は 20 を超えません。 </p> <H2>Output</H2> <p> データセットごとに、島の数を１行に出力します。 </p> <H2>Sample Input</H2> <pre> 111100001111 111000001111 110000001111 100000001111 000100010000 000000111000 000001111100 100011111110 110001111100 111000111000 111100010000 000000000000 010001111100 110010000010 010010000001 010000000001 010000000110 010000111000 010000000100 010000000010 010000000001 010010000001 010010000010 111001111100 000000000000 111111111111 100010100001 100010100001 100010100001 100010100001 100100100101 101000011101 100000000001 100000000001 111111111111 100000000001 </pre> <H2>Output for the Sample Input</H2> <pre> 5 13 4 </pre> <H2>Hint</H2> <p> 以下はサンプルインプットを■と□で表したものです。 <pre> ■■■■□□□□■■■■　　□■□□□■■■■■□□　　□□□□□□□□□□□□ ■■■□□□□□■■■■　　■■□□■□□□□□■□　　■■■■■■■■■■■■ ■■□□□□□□■■■■　　□■□□■□□□□□□■　　■□□□■□■□□□□■ ■□□□□□□□■■■■　　□■□□□□□□□□□■　　■□□□■□■□□□□■ □□□■□□□■□□□□　　□■□□□□□□□■■□　　■□□□■□■□□□□■ □□□□□□■■■□□□　　□■□□□□■■■□□□　　■□□□■□■□□□□■ □□□□□■■■■■□□　　□■□□□□□□□■□□　　■□□■□□■□□■□■ ■□□□■■■■■■■□　　□■□□□□□□□□■□　　■□■□□□□■■■□■ ■■□□□■■■■■□□　　□■□□□□□□□□□■　　■□□□□□□□□□□■ ■■■□□□■■■□□□　　□■□□■□□□□□□■　　■□□□□□□□□□□■ ■■■■□□□■□□□□　　□■□□■□□□□□■□　　■■■■■■■■■■■■ □□□□□□□□□□□□　　■■■□□■■■■■□□　　■□□□□□□□□□□■ </pre> </p>
s413056961
p00067
Runtime Error
mx = [0, 1, 0, -1] my = [-1, 0, 1, 0] while True: try: board = [[int(i) for i in input()] for j in range(12)] except: break cnt = 0 for y in range(12): for x in range(12): if board[y][x] == 1: cnt += 1 q = [(y, x)] while len(q) > 0: new_q = [] for yy, xx in q: board[yy][xx] = 0 for i in range(4): nx, ny = xx + mx[i], yy + my[i] if 0 <= nx < 12 and 0 <= ny < 12 and board[ny][nx]: new_q.append((ny, nx)) q = new_q print(cnt)
111100001111 111000001111 110000001111 100000001111 000100010000 000000111000 000001111100 100011111110 110001111100 111000111000 111100010000 000000000000 010001111100 110010000010 010010000001 010000000001 010000000110 010000111000 010000000100 010000000010 010000000001 010010000001 010010000010 111001111100 000000000000 111111111111 100010100001 100010100001 100010100001 100010100001 100100100101 101000011101 100000000001 100000000001 111111111111 100000000001
5 13 4
<H1>島の数</H1> <p> 地勢を示す縦 12, 横 12 のマスからなる平面図があります。おのおののマスは白か黒に塗られています。白は海を、黒は陸地を表します。二つの黒いマスが上下、あるいは左右に接しているとき、これらは地続きであるといいます。この平面図では、黒いマス一つのみ、あるいは地続きの黒いマスが作る領域を「島」といいます。例えば下図には、5 つの島があります。 </p> <pre> ■■■■□□□□■■■■ ■■■□□□□□■■■■ ■■□□□□□□■■■■ ■□□□□□□□■■■■ □□□■□□□■□□□□ □□□□□□■■■□□□ □□□□□■■■■■□□ ■□□□■■■■■■■□ ■■□□□■■■■■□□ ■■■□□□■■■□□□ ■■■■□□□■□□□□ □□□□□□□□□□□□ </pre> <p> マスのデータを読み込んで、島の数を出力するプログラムを作成してください。 </p> <H2>Input</H2> <p> 入力は複数のデータセットからなります。各データセットに１つの平面図が与えられます。黒いマスを 1、白いマスを 0 で表現した 12 個の数字の列 12 行でひとつの平面図を表します。データセットの間は１つの空行で区切られています。 </p> <p> データセットの数は 20 を超えません。 </p> <H2>Output</H2> <p> データセットごとに、島の数を１行に出力します。 </p> <H2>Sample Input</H2> <pre> 111100001111 111000001111 110000001111 100000001111 000100010000 000000111000 000001111100 100011111110 110001111100 111000111000 111100010000 000000000000 010001111100 110010000010 010010000001 010000000001 010000000110 010000111000 010000000100 010000000010 010000000001 010010000001 010010000010 111001111100 000000000000 111111111111 100010100001 100010100001 100010100001 100010100001 100100100101 101000011101 100000000001 100000000001 111111111111 100000000001 </pre> <H2>Output for the Sample Input</H2> <pre> 5 13 4 </pre> <H2>Hint</H2> <p> 以下はサンプルインプットを■と□で表したものです。 <pre> ■■■■□□□□■■■■　　□■□□□■■■■■□□　　□□□□□□□□□□□□ ■■■□□□□□■■■■　　■■□□■□□□□□■□　　■■■■■■■■■■■■ ■■□□□□□□■■■■　　□■□□■□□□□□□■　　■□□□■□■□□□□■ ■□□□□□□□■■■■　　□■□□□□□□□□□■　　■□□□■□■□□□□■ □□□■□□□■□□□□　　□■□□□□□□□■■□　　■□□□■□■□□□□■ □□□□□□■■■□□□　　□■□□□□■■■□□□　　■□□□■□■□□□□■ □□□□□■■■■■□□　　□■□□□□□□□■□□　　■□□■□□■□□■□■ ■□□□■■■■■■■□　　□■□□□□□□□□■□　　■□■□□□□■■■□■ ■■□□□■■■■■□□　　□■□□□□□□□□□■　　■□□□□□□□□□□■ ■■■□□□■■■□□□　　□■□□■□□□□□□■　　■□□□□□□□□□□■ ■■■■□□□■□□□□　　□■□□■□□□□□■□　　■■■■■■■■■■■■ □□□□□□□□□□□□　　■■■□□■■■■■□□　　■□□□□□□□□□□■ </pre> </p>
s758898354
p00067
Runtime Error
mx = [0, 1, 0, -1] my = [-1, 0, 1, 0] while True: try: board = [[int(i) for i in input()] for j in range(12)] except EOFError: break cnt = 0 for y in range(12): for x in range(12): if board[y][x] == 1: cnt += 1 q = [(y, x)] while len(q) > 0: new_q = [] for yy, xx in q: board[yy][xx] = 0 for i in range(4): nx, ny = xx + mx[i], yy + my[i] if 0 <= nx < 12 and 0 <= ny < 12 and board[ny][nx]: new_q.append((ny, nx)) q = new_q print(cnt)
111100001111 111000001111 110000001111 100000001111 000100010000 000000111000 000001111100 100011111110 110001111100 111000111000 111100010000 000000000000 010001111100 110010000010 010010000001 010000000001 010000000110 010000111000 010000000100 010000000010 010000000001 010010000001 010010000010 111001111100 000000000000 111111111111 100010100001 100010100001 100010100001 100010100001 100100100101 101000011101 100000000001 100000000001 111111111111 100000000001
5 13 4
<H1>島の数</H1> <p> 地勢を示す縦 12, 横 12 のマスからなる平面図があります。おのおののマスは白か黒に塗られています。白は海を、黒は陸地を表します。二つの黒いマスが上下、あるいは左右に接しているとき、これらは地続きであるといいます。この平面図では、黒いマス一つのみ、あるいは地続きの黒いマスが作る領域を「島」といいます。例えば下図には、5 つの島があります。 </p> <pre> ■■■■□□□□■■■■ ■■■□□□□□■■■■ ■■□□□□□□■■■■ ■□□□□□□□■■■■ □□□■□□□■□□□□ □□□□□□■■■□□□ □□□□□■■■■■□□ ■□□□■■■■■■■□ ■■□□□■■■■■□□ ■■■□□□■■■□□□ ■■■■□□□■□□□□ □□□□□□□□□□□□ </pre> <p> マスのデータを読み込んで、島の数を出力するプログラムを作成してください。 </p> <H2>Input</H2> <p> 入力は複数のデータセットからなります。各データセットに１つの平面図が与えられます。黒いマスを 1、白いマスを 0 で表現した 12 個の数字の列 12 行でひとつの平面図を表します。データセットの間は１つの空行で区切られています。 </p> <p> データセットの数は 20 を超えません。 </p> <H2>Output</H2> <p> データセットごとに、島の数を１行に出力します。 </p> <H2>Sample Input</H2> <pre> 111100001111 111000001111 110000001111 100000001111 000100010000 000000111000 000001111100 100011111110 110001111100 111000111000 111100010000 000000000000 010001111100 110010000010 010010000001 010000000001 010000000110 010000111000 010000000100 010000000010 010000000001 010010000001 010010000010 111001111100 000000000000 111111111111 100010100001 100010100001 100010100001 100010100001 100100100101 101000011101 100000000001 100000000001 111111111111 100000000001 </pre> <H2>Output for the Sample Input</H2> <pre> 5 13 4 </pre> <H2>Hint</H2> <p> 以下はサンプルインプットを■と□で表したものです。 <pre> ■■■■□□□□■■■■　　□■□□□■■■■■□□　　□□□□□□□□□□□□ ■■■□□□□□■■■■　　■■□□■□□□□□■□　　■■■■■■■■■■■■ ■■□□□□□□■■■■　　□■□□■□□□□□□■　　■□□□■□■□□□□■ ■□□□□□□□■■■■　　□■□□□□□□□□□■　　■□□□■□■□□□□■ □□□■□□□■□□□□　　□■□□□□□□□■■□　　■□□□■□■□□□□■ □□□□□□■■■□□□　　□■□□□□■■■□□□　　■□□□■□■□□□□■ □□□□□■■■■■□□　　□■□□□□□□□■□□　　■□□■□□■□□■□■ ■□□□■■■■■■■□　　□■□□□□□□□□■□　　■□■□□□□■■■□■ ■■□□□■■■■■□□　　□■□□□□□□□□□■　　■□□□□□□□□□□■ ■■■□□□■■■□□□　　□■□□■□□□□□□■　　■□□□□□□□□□□■ ■■■■□□□■□□□□　　□■□□■□□□□□■□　　■■■■■■■■■■■■ □□□□□□□□□□□□　　■■■□□■■■■■□□　　■□□□□□□□□□□■ </pre> </p>
s850835773
p00067
Runtime Error
mx = [0, 1, 0, -1] my = [-1, 0, 1, 0] while True: try: board = [[int(i) for i in input()] for j in range(12)] cnt = 0 for y in range(12): for x in range(12): if board[y][x] == 1: cnt += 1 q = [(y, x)] while len(q) > 0: new_q = [] for yy, xx in q: board[yy][xx] = 0 for i in range(4): nx, ny = xx + mx[i], yy + my[i] if 0 <= nx < 12 and 0 <= ny < 12 and board[ny][nx]: new_q.append((ny, nx)) q = new_q print(cnt) except EOFError: break
111100001111 111000001111 110000001111 100000001111 000100010000 000000111000 000001111100 100011111110 110001111100 111000111000 111100010000 000000000000 010001111100 110010000010 010010000001 010000000001 010000000110 010000111000 010000000100 010000000010 010000000001 010010000001 010010000010 111001111100 000000000000 111111111111 100010100001 100010100001 100010100001 100010100001 100100100101 101000011101 100000000001 100000000001 111111111111 100000000001
5 13 4
<H1>島の数</H1> <p> 地勢を示す縦 12, 横 12 のマスからなる平面図があります。おのおののマスは白か黒に塗られています。白は海を、黒は陸地を表します。二つの黒いマスが上下、あるいは左右に接しているとき、これらは地続きであるといいます。この平面図では、黒いマス一つのみ、あるいは地続きの黒いマスが作る領域を「島」といいます。例えば下図には、5 つの島があります。 </p> <pre> ■■■■□□□□■■■■ ■■■□□□□□■■■■ ■■□□□□□□■■■■ ■□□□□□□□■■■■ □□□■□□□■□□□□ □□□□□□■■■□□□ □□□□□■■■■■□□ ■□□□■■■■■■■□ ■■□□□■■■■■□□ ■■■□□□■■■□□□ ■■■■□□□■□□□□ □□□□□□□□□□□□ </pre> <p> マスのデータを読み込んで、島の数を出力するプログラムを作成してください。 </p> <H2>Input</H2> <p> 入力は複数のデータセットからなります。各データセットに１つの平面図が与えられます。黒いマスを 1、白いマスを 0 で表現した 12 個の数字の列 12 行でひとつの平面図を表します。データセットの間は１つの空行で区切られています。 </p> <p> データセットの数は 20 を超えません。 </p> <H2>Output</H2> <p> データセットごとに、島の数を１行に出力します。 </p> <H2>Sample Input</H2> <pre> 111100001111 111000001111 110000001111 100000001111 000100010000 000000111000 000001111100 100011111110 110001111100 111000111000 111100010000 000000000000 010001111100 110010000010 010010000001 010000000001 010000000110 010000111000 010000000100 010000000010 010000000001 010010000001 010010000010 111001111100 000000000000 111111111111 100010100001 100010100001 100010100001 100010100001 100100100101 101000011101 100000000001 100000000001 111111111111 100000000001 </pre> <H2>Output for the Sample Input</H2> <pre> 5 13 4 </pre> <H2>Hint</H2> <p> 以下はサンプルインプットを■と□で表したものです。 <pre> ■■■■□□□□■■■■　　□■□□□■■■■■□□　　□□□□□□□□□□□□ ■■■□□□□□■■■■　　■■□□■□□□□□■□　　■■■■■■■■■■■■ ■■□□□□□□■■■■　　□■□□■□□□□□□■　　■□□□■□■□□□□■ ■□□□□□□□■■■■　　□■□□□□□□□□□■　　■□□□■□■□□□□■ □□□■□□□■□□□□　　□■□□□□□□□■■□　　■□□□■□■□□□□■ □□□□□□■■■□□□　　□■□□□□■■■□□□　　■□□□■□■□□□□■ □□□□□■■■■■□□　　□■□□□□□□□■□□　　■□□■□□■□□■□■ ■□□□■■■■■■■□　　□■□□□□□□□□■□　　■□■□□□□■■■□■ ■■□□□■■■■■□□　　□■□□□□□□□□□■　　■□□□□□□□□□□■ ■■■□□□■■■□□□　　□■□□■□□□□□□■　　■□□□□□□□□□□■ ■■■■□□□■□□□□　　□■□□■□□□□□■□　　■■■■■■■■■■■■ □□□□□□□□□□□□　　■■■□□■■■■■□□　　■□□□□□□□□□□■ </pre> </p>
s179717416
p00067
Runtime Error
mx = [0, 1, 0, -1] my = [-1, 0, 1, 0] while True: try: board = [[int(i) for i in input()] for j in range(12)] except EOFError: break cnt = 0 for y in range(12): for x in range(12): if board[y][x] == 1: cnt += 1 q = [(y, x)] while len(q) > 0: new_q = [] for yy, xx in q: board[yy][xx] = 0 for i in range(4): nx, ny = xx + mx[i], yy + my[i] if 0 <= nx < 12 and 0 <= ny < 12 and board[ny][nx]: new_q.append((ny, nx)) q = new_q print(cnt) input()
111100001111 111000001111 110000001111 100000001111 000100010000 000000111000 000001111100 100011111110 110001111100 111000111000 111100010000 000000000000 010001111100 110010000010 010010000001 010000000001 010000000110 010000111000 010000000100 010000000010 010000000001 010010000001 010010000010 111001111100 000000000000 111111111111 100010100001 100010100001 100010100001 100010100001 100100100101 101000011101 100000000001 100000000001 111111111111 100000000001
5 13 4
<H1>島の数</H1> <p> 地勢を示す縦 12, 横 12 のマスからなる平面図があります。おのおののマスは白か黒に塗られています。白は海を、黒は陸地を表します。二つの黒いマスが上下、あるいは左右に接しているとき、これらは地続きであるといいます。この平面図では、黒いマス一つのみ、あるいは地続きの黒いマスが作る領域を「島」といいます。例えば下図には、5 つの島があります。 </p> <pre> ■■■■□□□□■■■■ ■■■□□□□□■■■■ ■■□□□□□□■■■■ ■□□□□□□□■■■■ □□□■□□□■□□□□ □□□□□□■■■□□□ □□□□□■■■■■□□ ■□□□■■■■■■■□ ■■□□□■■■■■□□ ■■■□□□■■■□□□ ■■■■□□□■□□□□ □□□□□□□□□□□□ </pre> <p> マスのデータを読み込んで、島の数を出力するプログラムを作成してください。 </p> <H2>Input</H2> <p> 入力は複数のデータセットからなります。各データセットに１つの平面図が与えられます。黒いマスを 1、白いマスを 0 で表現した 12 個の数字の列 12 行でひとつの平面図を表します。データセットの間は１つの空行で区切られています。 </p> <p> データセットの数は 20 を超えません。 </p> <H2>Output</H2> <p> データセットごとに、島の数を１行に出力します。 </p> <H2>Sample Input</H2> <pre> 111100001111 111000001111 110000001111 100000001111 000100010000 000000111000 000001111100 100011111110 110001111100 111000111000 111100010000 000000000000 010001111100 110010000010 010010000001 010000000001 010000000110 010000111000 010000000100 010000000010 010000000001 010010000001 010010000010 111001111100 000000000000 111111111111 100010100001 100010100001 100010100001 100010100001 100100100101 101000011101 100000000001 100000000001 111111111111 100000000001 </pre> <H2>Output for the Sample Input</H2> <pre> 5 13 4 </pre> <H2>Hint</H2> <p> 以下はサンプルインプットを■と□で表したものです。 <pre> ■■■■□□□□■■■■　　□■□□□■■■■■□□　　□□□□□□□□□□□□ ■■■□□□□□■■■■　　■■□□■□□□□□■□　　■■■■■■■■■■■■ ■■□□□□□□■■■■　　□■□□■□□□□□□■　　■□□□■□■□□□□■ ■□□□□□□□■■■■　　□■□□□□□□□□□■　　■□□□■□■□□□□■ □□□■□□□■□□□□　　□■□□□□□□□■■□　　■□□□■□■□□□□■ □□□□□□■■■□□□　　□■□□□□■■■□□□　　■□□□■□■□□□□■ □□□□□■■■■■□□　　□■□□□□□□□■□□　　■□□■□□■□□■□■ ■□□□■■■■■■■□　　□■□□□□□□□□■□　　■□■□□□□■■■□■ ■■□□□■■■■■□□　　□■□□□□□□□□□■　　■□□□□□□□□□□■ ■■■□□□■■■□□□　　□■□□■□□□□□□■　　■□□□□□□□□□□■ ■■■■□□□■□□□□　　□■□□■□□□□□■□　　■■■■■■■■■■■■ □□□□□□□□□□□□　　■■■□□■■■■■□□　　■□□□□□□□□□□■ </pre> </p>
s969746033
p00067
Runtime Error
mx = [0, 1, 0, -1] my = [-1, 0, 1, 0] while True: try: board = [[int(i) for i in input()] for j in range(12)] except EOFError: break cnt = 0 for y in range(12): for x in range(12): if board[y][x] == 1: cnt += 1 q = [(y, x)] while len(q) > 0: new_q = [] for yy, xx in q: board[yy][xx] = 0 for i in range(4): nx, ny = xx + mx[i], yy + my[i] if 0 <= nx < 12 and 0 <= ny < 12 and board[ny][nx] and (ny, nx) not in new_q: new_q.append((ny, nx)) q = new_q print(cnt) input()
111100001111 111000001111 110000001111 100000001111 000100010000 000000111000 000001111100 100011111110 110001111100 111000111000 111100010000 000000000000 010001111100 110010000010 010010000001 010000000001 010000000110 010000111000 010000000100 010000000010 010000000001 010010000001 010010000010 111001111100 000000000000 111111111111 100010100001 100010100001 100010100001 100010100001 100100100101 101000011101 100000000001 100000000001 111111111111 100000000001
5 13 4
<H1>島の数</H1> <p> 地勢を示す縦 12, 横 12 のマスからなる平面図があります。おのおののマスは白か黒に塗られています。白は海を、黒は陸地を表します。二つの黒いマスが上下、あるいは左右に接しているとき、これらは地続きであるといいます。この平面図では、黒いマス一つのみ、あるいは地続きの黒いマスが作る領域を「島」といいます。例えば下図には、5 つの島があります。 </p> <pre> ■■■■□□□□■■■■ ■■■□□□□□■■■■ ■■□□□□□□■■■■ ■□□□□□□□■■■■ □□□■□□□■□□□□ □□□□□□■■■□□□ □□□□□■■■■■□□ ■□□□■■■■■■■□ ■■□□□■■■■■□□ ■■■□□□■■■□□□ ■■■■□□□■□□□□ □□□□□□□□□□□□ </pre> <p> マスのデータを読み込んで、島の数を出力するプログラムを作成してください。 </p> <H2>Input</H2> <p> 入力は複数のデータセットからなります。各データセットに１つの平面図が与えられます。黒いマスを 1、白いマスを 0 で表現した 12 個の数字の列 12 行でひとつの平面図を表します。データセットの間は１つの空行で区切られています。 </p> <p> データセットの数は 20 を超えません。 </p> <H2>Output</H2> <p> データセットごとに、島の数を１行に出力します。 </p> <H2>Sample Input</H2> <pre> 111100001111 111000001111 110000001111 100000001111 000100010000 000000111000 000001111100 100011111110 110001111100 111000111000 111100010000 000000000000 010001111100 110010000010 010010000001 010000000001 010000000110 010000111000 010000000100 010000000010 010000000001 010010000001 010010000010 111001111100 000000000000 111111111111 100010100001 100010100001 100010100001 100010100001 100100100101 101000011101 100000000001 100000000001 111111111111 100000000001 </pre> <H2>Output for the Sample Input</H2> <pre> 5 13 4 </pre> <H2>Hint</H2> <p> 以下はサンプルインプットを■と□で表したものです。 <pre> ■■■■□□□□■■■■　　□■□□□■■■■■□□　　□□□□□□□□□□□□ ■■■□□□□□■■■■　　■■□□■□□□□□■□　　■■■■■■■■■■■■ ■■□□□□□□■■■■　　□■□□■□□□□□□■　　■□□□■□■□□□□■ ■□□□□□□□■■■■　　□■□□□□□□□□□■　　■□□□■□■□□□□■ □□□■□□□■□□□□　　□■□□□□□□□■■□　　■□□□■□■□□□□■ □□□□□□■■■□□□　　□■□□□□■■■□□□　　■□□□■□■□□□□■ □□□□□■■■■■□□　　□■□□□□□□□■□□　　■□□■□□■□□■□■ ■□□□■■■■■■■□　　□■□□□□□□□□■□　　■□■□□□□■■■□■ ■■□□□■■■■■□□　　□■□□□□□□□□□■　　■□□□□□□□□□□■ ■■■□□□■■■□□□　　□■□□■□□□□□□■　　■□□□□□□□□□□■ ■■■■□□□■□□□□　　□■□□■□□□□□■□　　■■■■■■■■■■■■ □□□□□□□□□□□□　　■■■□□■■■■■□□　　■□□□□□□□□□□■ </pre> </p>
s205439834
p00067
Runtime Error
def dfs(i, j, m): ''' m[i][j]??¨????????£??????????????°???????????????????????? ''' m[i][j] = 0 for di, dj in [(-1, 0), (1, 0), (0, -1), (0, 1)]: ni = i + di nj = j + dj if ni in range(12) and nj in range(12) and m[ni][nj] == 1: dfs(ni, nj, m) while True: m = [] for i in range(12): m.append(list(map(int, list(input())))) count = 0 for i in range(12): for j in range(12): if m[i][j] == 1: count += 1 dfs(i, j, m) print(count)
111100001111 111000001111 110000001111 100000001111 000100010000 000000111000 000001111100 100011111110 110001111100 111000111000 111100010000 000000000000 010001111100 110010000010 010010000001 010000000001 010000000110 010000111000 010000000100 010000000010 010000000001 010010000001 010010000010 111001111100 000000000000 111111111111 100010100001 100010100001 100010100001 100010100001 100100100101 101000011101 100000000001 100000000001 111111111111 100000000001
5 13 4
<H1>島の数</H1> <p> 地勢を示す縦 12, 横 12 のマスからなる平面図があります。おのおののマスは白か黒に塗られています。白は海を、黒は陸地を表します。二つの黒いマスが上下、あるいは左右に接しているとき、これらは地続きであるといいます。この平面図では、黒いマス一つのみ、あるいは地続きの黒いマスが作る領域を「島」といいます。例えば下図には、5 つの島があります。 </p> <pre> ■■■■□□□□■■■■ ■■■□□□□□■■■■ ■■□□□□□□■■■■ ■□□□□□□□■■■■ □□□■□□□■□□□□ □□□□□□■■■□□□ □□□□□■■■■■□□ ■□□□■■■■■■■□ ■■□□□■■■■■□□ ■■■□□□■■■□□□ ■■■■□□□■□□□□ □□□□□□□□□□□□ </pre> <p> マスのデータを読み込んで、島の数を出力するプログラムを作成してください。 </p> <H2>Input</H2> <p> 入力は複数のデータセットからなります。各データセットに１つの平面図が与えられます。黒いマスを 1、白いマスを 0 で表現した 12 個の数字の列 12 行でひとつの平面図を表します。データセットの間は１つの空行で区切られています。 </p> <p> データセットの数は 20 を超えません。 </p> <H2>Output</H2> <p> データセットごとに、島の数を１行に出力します。 </p> <H2>Sample Input</H2> <pre> 111100001111 111000001111 110000001111 100000001111 000100010000 000000111000 000001111100 100011111110 110001111100 111000111000 111100010000 000000000000 010001111100 110010000010 010010000001 010000000001 010000000110 010000111000 010000000100 010000000010 010000000001 010010000001 010010000010 111001111100 000000000000 111111111111 100010100001 100010100001 100010100001 100010100001 100100100101 101000011101 100000000001 100000000001 111111111111 100000000001 </pre> <H2>Output for the Sample Input</H2> <pre> 5 13 4 </pre> <H2>Hint</H2> <p> 以下はサンプルインプットを■と□で表したものです。 <pre> ■■■■□□□□■■■■　　□■□□□■■■■■□□　　□□□□□□□□□□□□ ■■■□□□□□■■■■　　■■□□■□□□□□■□　　■■■■■■■■■■■■ ■■□□□□□□■■■■　　□■□□■□□□□□□■　　■□□□■□■□□□□■ ■□□□□□□□■■■■　　□■□□□□□□□□□■　　■□□□■□■□□□□■ □□□■□□□■□□□□　　□■□□□□□□□■■□　　■□□□■□■□□□□■ □□□□□□■■■□□□　　□■□□□□■■■□□□　　■□□□■□■□□□□■ □□□□□■■■■■□□　　□■□□□□□□□■□□　　■□□■□□■□□■□■ ■□□□■■■■■■■□　　□■□□□□□□□□■□　　■□■□□□□■■■□■ ■■□□□■■■■■□□　　□■□□□□□□□□□■　　■□□□□□□□□□□■ ■■■□□□■■■□□□　　□■□□■□□□□□□■　　■□□□□□□□□□□■ ■■■■□□□■□□□□　　□■□□■□□□□□■□　　■■■■■■■■■■■■ □□□□□□□□□□□□　　■■■□□■■■■■□□　　■□□□□□□□□□□■ </pre> </p>
s029238061
p00067
Runtime Error
def dfs(i, j, m): ''' m[i][j]??¨????????£??????????????°???????????????????????? ''' m[i][j] = 0 for di, dj in [(-1, 0), (1, 0), (0, -1), (0, 1)]: ni = i + di nj = j + dj if ni in range(12) and nj in range(12) and m[ni][nj] == 1: dfs(ni, nj, m) while True: m = [] for i in range(12): m.append(list(map(int, list(input())))) count = 0 for i in range(12): for j in range(12): if m[i][j] == 1: count += 1 dfs(i, j, m) print(count) input()
111100001111 111000001111 110000001111 100000001111 000100010000 000000111000 000001111100 100011111110 110001111100 111000111000 111100010000 000000000000 010001111100 110010000010 010010000001 010000000001 010000000110 010000111000 010000000100 010000000010 010000000001 010010000001 010010000010 111001111100 000000000000 111111111111 100010100001 100010100001 100010100001 100010100001 100100100101 101000011101 100000000001 100000000001 111111111111 100000000001
5 13 4
<H1>島の数</H1> <p> 地勢を示す縦 12, 横 12 のマスからなる平面図があります。おのおののマスは白か黒に塗られています。白は海を、黒は陸地を表します。二つの黒いマスが上下、あるいは左右に接しているとき、これらは地続きであるといいます。この平面図では、黒いマス一つのみ、あるいは地続きの黒いマスが作る領域を「島」といいます。例えば下図には、5 つの島があります。 </p> <pre> ■■■■□□□□■■■■ ■■■□□□□□■■■■ ■■□□□□□□■■■■ ■□□□□□□□■■■■ □□□■□□□■□□□□ □□□□□□■■■□□□ □□□□□■■■■■□□ ■□□□■■■■■■■□ ■■□□□■■■■■□□ ■■■□□□■■■□□□ ■■■■□□□■□□□□ □□□□□□□□□□□□ </pre> <p> マスのデータを読み込んで、島の数を出力するプログラムを作成してください。 </p> <H2>Input</H2> <p> 入力は複数のデータセットからなります。各データセットに１つの平面図が与えられます。黒いマスを 1、白いマスを 0 で表現した 12 個の数字の列 12 行でひとつの平面図を表します。データセットの間は１つの空行で区切られています。 </p> <p> データセットの数は 20 を超えません。 </p> <H2>Output</H2> <p> データセットごとに、島の数を１行に出力します。 </p> <H2>Sample Input</H2> <pre> 111100001111 111000001111 110000001111 100000001111 000100010000 000000111000 000001111100 100011111110 110001111100 111000111000 111100010000 000000000000 010001111100 110010000010 010010000001 010000000001 010000000110 010000111000 010000000100 010000000010 010000000001 010010000001 010010000010 111001111100 000000000000 111111111111 100010100001 100010100001 100010100001 100010100001 100100100101 101000011101 100000000001 100000000001 111111111111 100000000001 </pre> <H2>Output for the Sample Input</H2> <pre> 5 13 4 </pre> <H2>Hint</H2> <p> 以下はサンプルインプットを■と□で表したものです。 <pre> ■■■■□□□□■■■■　　□■□□□■■■■■□□　　□□□□□□□□□□□□ ■■■□□□□□■■■■　　■■□□■□□□□□■□　　■■■■■■■■■■■■ ■■□□□□□□■■■■　　□■□□■□□□□□□■　　■□□□■□■□□□□■ ■□□□□□□□■■■■　　□■□□□□□□□□□■　　■□□□■□■□□□□■ □□□■□□□■□□□□　　□■□□□□□□□■■□　　■□□□■□■□□□□■ □□□□□□■■■□□□　　□■□□□□■■■□□□　　■□□□■□■□□□□■ □□□□□■■■■■□□　　□■□□□□□□□■□□　　■□□■□□■□□■□■ ■□□□■■■■■■■□　　□■□□□□□□□□■□　　■□■□□□□■■■□■ ■■□□□■■■■■□□　　□■□□□□□□□□□■　　■□□□□□□□□□□■ ■■■□□□■■■□□□　　□■□□■□□□□□□■　　■□□□□□□□□□□■ ■■■■□□□■□□□□　　□■□□■□□□□□■□　　■■■■■■■■■■■■ □□□□□□□□□□□□　　■■■□□■■■■■□□　　■□□□□□□□□□□■ </pre> </p>
s493705834
p00067
Runtime Error
dx = [0, 0, -1, 1] dy = [1, -1, 0, 0] def main(): while True: map = [] count = 0 try: for i in range(12): map.append([x for x in input()]) for i in range(12): for j in range(12): if map[i][j] == '1': dfs(map, j, i) count += 1 print(count) except EOFError: break def dfs(map, x, y): if x < 0 or y < 0 or x >= 12 or y >= 12: return map[y][x] = '0' for i in range(4): next_x = x + dx[i] next_y = y + dy[i] if next_x >= 0 and next_x < 12 and next_y >= 0 and next_y < 12: if map[next_y][next_x] == '1': dfs(map, next_x, next_y) if __name__ == '__main__': main()
111100001111 111000001111 110000001111 100000001111 000100010000 000000111000 000001111100 100011111110 110001111100 111000111000 111100010000 000000000000 010001111100 110010000010 010010000001 010000000001 010000000110 010000111000 010000000100 010000000010 010000000001 010010000001 010010000010 111001111100 000000000000 111111111111 100010100001 100010100001 100010100001 100010100001 100100100101 101000011101 100000000001 100000000001 111111111111 100000000001
5 13 4
<H1>島の数</H1> <p> 地勢を示す縦 12, 横 12 のマスからなる平面図があります。おのおののマスは白か黒に塗られています。白は海を、黒は陸地を表します。二つの黒いマスが上下、あるいは左右に接しているとき、これらは地続きであるといいます。この平面図では、黒いマス一つのみ、あるいは地続きの黒いマスが作る領域を「島」といいます。例えば下図には、5 つの島があります。 </p> <pre> ■■■■□□□□■■■■ ■■■□□□□□■■■■ ■■□□□□□□■■■■ ■□□□□□□□■■■■ □□□■□□□■□□□□ □□□□□□■■■□□□ □□□□□■■■■■□□ ■□□□■■■■■■■□ ■■□□□■■■■■□□ ■■■□□□■■■□□□ ■■■■□□□■□□□□ □□□□□□□□□□□□ </pre> <p> マスのデータを読み込んで、島の数を出力するプログラムを作成してください。 </p> <H2>Input</H2> <p> 入力は複数のデータセットからなります。各データセットに１つの平面図が与えられます。黒いマスを 1、白いマスを 0 で表現した 12 個の数字の列 12 行でひとつの平面図を表します。データセットの間は１つの空行で区切られています。 </p> <p> データセットの数は 20 を超えません。 </p> <H2>Output</H2> <p> データセットごとに、島の数を１行に出力します。 </p> <H2>Sample Input</H2> <pre> 111100001111 111000001111 110000001111 100000001111 000100010000 000000111000 000001111100 100011111110 110001111100 111000111000 111100010000 000000000000 010001111100 110010000010 010010000001 010000000001 010000000110 010000111000 010000000100 010000000010 010000000001 010010000001 010010000010 111001111100 000000000000 111111111111 100010100001 100010100001 100010100001 100010100001 100100100101 101000011101 100000000001 100000000001 111111111111 100000000001 </pre> <H2>Output for the Sample Input</H2> <pre> 5 13 4 </pre> <H2>Hint</H2> <p> 以下はサンプルインプットを■と□で表したものです。 <pre> ■■■■□□□□■■■■　　□■□□□■■■■■□□　　□□□□□□□□□□□□ ■■■□□□□□■■■■　　■■□□■□□□□□■□　　■■■■■■■■■■■■ ■■□□□□□□■■■■　　□■□□■□□□□□□■　　■□□□■□■□□□□■ ■□□□□□□□■■■■　　□■□□□□□□□□□■　　■□□□■□■□□□□■ □□□■□□□■□□□□　　□■□□□□□□□■■□　　■□□□■□■□□□□■ □□□□□□■■■□□□　　□■□□□□■■■□□□　　■□□□■□■□□□□■ □□□□□■■■■■□□　　□■□□□□□□□■□□　　■□□■□□■□□■□■ ■□□□■■■■■■■□　　□■□□□□□□□□■□　　■□■□□□□■■■□■ ■■□□□■■■■■□□　　□■□□□□□□□□□■　　■□□□□□□□□□□■ ■■■□□□■■■□□□　　□■□□■□□□□□□■　　■□□□□□□□□□□■ ■■■■□□□■□□□□　　□■□□■□□□□□■□　　■■■■■■■■■■■■ □□□□□□□□□□□□　　■■■□□■■■■■□□　　■□□□□□□□□□□■ </pre> </p>
s789054113
p00067
Runtime Error
ID=0 def dfs(row,col): global ID if islands[row][col]==1: islandsID[row][col]==ID if row<11: dfs(row+1,col) if row>0: dfs(row-1,col) if col<11: dfs(row,col+1) if col>0: dfs(row,col-1) while True: c=0 islands=[] islandsID=[] for i in range(12): islands.append(list(map(int,input().split()))) for _ in range(12): islandsID.append([0 for i in range(12)]) for i in range(12): for j in range(12): if islands[i][j]==1 and islandsID[i][j]==0: ID+=1 dfs(i,j) print(ID) try: c=input() except: break
111100001111 111000001111 110000001111 100000001111 000100010000 000000111000 000001111100 100011111110 110001111100 111000111000 111100010000 000000000000 010001111100 110010000010 010010000001 010000000001 010000000110 010000111000 010000000100 010000000010 010000000001 010010000001 010010000010 111001111100 000000000000 111111111111 100010100001 100010100001 100010100001 100010100001 100100100101 101000011101 100000000001 100000000001 111111111111 100000000001
5 13 4
<H1>島の数</H1> <p> 地勢を示す縦 12, 横 12 のマスからなる平面図があります。おのおののマスは白か黒に塗られています。白は海を、黒は陸地を表します。二つの黒いマスが上下、あるいは左右に接しているとき、これらは地続きであるといいます。この平面図では、黒いマス一つのみ、あるいは地続きの黒いマスが作る領域を「島」といいます。例えば下図には、5 つの島があります。 </p> <pre> ■■■■□□□□■■■■ ■■■□□□□□■■■■ ■■□□□□□□■■■■ ■□□□□□□□■■■■ □□□■□□□■□□□□ □□□□□□■■■□□□ □□□□□■■■■■□□ ■□□□■■■■■■■□ ■■□□□■■■■■□□ ■■■□□□■■■□□□ ■■■■□□□■□□□□ □□□□□□□□□□□□ </pre> <p> マスのデータを読み込んで、島の数を出力するプログラムを作成してください。 </p> <H2>Input</H2> <p> 入力は複数のデータセットからなります。各データセットに１つの平面図が与えられます。黒いマスを 1、白いマスを 0 で表現した 12 個の数字の列 12 行でひとつの平面図を表します。データセットの間は１つの空行で区切られています。 </p> <p> データセットの数は 20 を超えません。 </p> <H2>Output</H2> <p> データセットごとに、島の数を１行に出力します。 </p> <H2>Sample Input</H2> <pre> 111100001111 111000001111 110000001111 100000001111 000100010000 000000111000 000001111100 100011111110 110001111100 111000111000 111100010000 000000000000 010001111100 110010000010 010010000001 010000000001 010000000110 010000111000 010000000100 010000000010 010000000001 010010000001 010010000010 111001111100 000000000000 111111111111 100010100001 100010100001 100010100001 100010100001 100100100101 101000011101 100000000001 100000000001 111111111111 100000000001 </pre> <H2>Output for the Sample Input</H2> <pre> 5 13 4 </pre> <H2>Hint</H2> <p> 以下はサンプルインプットを■と□で表したものです。 <pre> ■■■■□□□□■■■■　　□■□□□■■■■■□□　　□□□□□□□□□□□□ ■■■□□□□□■■■■　　■■□□■□□□□□■□　　■■■■■■■■■■■■ ■■□□□□□□■■■■　　□■□□■□□□□□□■　　■□□□■□■□□□□■ ■□□□□□□□■■■■　　□■□□□□□□□□□■　　■□□□■□■□□□□■ □□□■□□□■□□□□　　□■□□□□□□□■■□　　■□□□■□■□□□□■ □□□□□□■■■□□□　　□■□□□□■■■□□□　　■□□□■□■□□□□■ □□□□□■■■■■□□　　□■□□□□□□□■□□　　■□□■□□■□□■□■ ■□□□■■■■■■■□　　□■□□□□□□□□■□　　■□■□□□□■■■□■ ■■□□□■■■■■□□　　□■□□□□□□□□□■　　■□□□□□□□□□□■ ■■■□□□■■■□□□　　□■□□■□□□□□□■　　■□□□□□□□□□□■ ■■■■□□□■□□□□　　□■□□■□□□□□■□　　■■■■■■■■■■■■ □□□□□□□□□□□□　　■■■□□■■■■■□□　　■□□□□□□□□□□■ </pre> </p>
s297156639
p00067
Runtime Error
def counter():#島の数をカウントする count=0 #12*12個の値をひとつずつ調べる for x in range(12): for y in range(12): if is_data[x][y] == 1:#島が発見されたら dfs(x,y) count+=1 return count def dfs(x,y): if x<0 or x == len(is_data[x]) or y<0 or y == len(is_data): return if is_data[x][y] == 1: is_data[x][y] = 0 dfs(x+1,y) dfs(x,y+1) dfs(x-1,y) dfs(x,y-1) try: while True: s = input()#入力 for i in range(len(s)): is_data[i] = list(is_data[i].strip()) is_data = np.array(is_data).reshape(12,12) except EOFError: print(counter())
111100001111 111000001111 110000001111 100000001111 000100010000 000000111000 000001111100 100011111110 110001111100 111000111000 111100010000 000000000000 010001111100 110010000010 010010000001 010000000001 010000000110 010000111000 010000000100 010000000010 010000000001 010010000001 010010000010 111001111100 000000000000 111111111111 100010100001 100010100001 100010100001 100010100001 100100100101 101000011101 100000000001 100000000001 111111111111 100000000001
5 13 4
<H1>島の数</H1> <p> 地勢を示す縦 12, 横 12 のマスからなる平面図があります。おのおののマスは白か黒に塗られています。白は海を、黒は陸地を表します。二つの黒いマスが上下、あるいは左右に接しているとき、これらは地続きであるといいます。この平面図では、黒いマス一つのみ、あるいは地続きの黒いマスが作る領域を「島」といいます。例えば下図には、5 つの島があります。 </p> <pre> ■■■■□□□□■■■■ ■■■□□□□□■■■■ ■■□□□□□□■■■■ ■□□□□□□□■■■■ □□□■□□□■□□□□ □□□□□□■■■□□□ □□□□□■■■■■□□ ■□□□■■■■■■■□ ■■□□□■■■■■□□ ■■■□□□■■■□□□ ■■■■□□□■□□□□ □□□□□□□□□□□□ </pre> <p> マスのデータを読み込んで、島の数を出力するプログラムを作成してください。 </p> <H2>Input</H2> <p> 入力は複数のデータセットからなります。各データセットに１つの平面図が与えられます。黒いマスを 1、白いマスを 0 で表現した 12 個の数字の列 12 行でひとつの平面図を表します。データセットの間は１つの空行で区切られています。 </p> <p> データセットの数は 20 を超えません。 </p> <H2>Output</H2> <p> データセットごとに、島の数を１行に出力します。 </p> <H2>Sample Input</H2> <pre> 111100001111 111000001111 110000001111 100000001111 000100010000 000000111000 000001111100 100011111110 110001111100 111000111000 111100010000 000000000000 010001111100 110010000010 010010000001 010000000001 010000000110 010000111000 010000000100 010000000010 010000000001 010010000001 010010000010 111001111100 000000000000 111111111111 100010100001 100010100001 100010100001 100010100001 100100100101 101000011101 100000000001 100000000001 111111111111 100000000001 </pre> <H2>Output for the Sample Input</H2> <pre> 5 13 4 </pre> <H2>Hint</H2> <p> 以下はサンプルインプットを■と□で表したものです。 <pre> ■■■■□□□□■■■■　　□■□□□■■■■■□□　　□□□□□□□□□□□□ ■■■□□□□□■■■■　　■■□□■□□□□□■□　　■■■■■■■■■■■■ ■■□□□□□□■■■■　　□■□□■□□□□□□■　　■□□□■□■□□□□■ ■□□□□□□□■■■■　　□■□□□□□□□□□■　　■□□□■□■□□□□■ □□□■□□□■□□□□　　□■□□□□□□□■■□　　■□□□■□■□□□□■ □□□□□□■■■□□□　　□■□□□□■■■□□□　　■□□□■□■□□□□■ □□□□□■■■■■□□　　□■□□□□□□□■□□　　■□□■□□■□□■□■ ■□□□■■■■■■■□　　□■□□□□□□□□■□　　■□■□□□□■■■□■ ■■□□□■■■■■□□　　□■□□□□□□□□□■　　■□□□□□□□□□□■ ■■■□□□■■■□□□　　□■□□■□□□□□□■　　■□□□□□□□□□□■ ■■■■□□□■□□□□　　□■□□■□□□□□■□　　■■■■■■■■■■■■ □□□□□□□□□□□□　　■■■□□■■■■■□□　　■□□□□□□□□□□■ </pre> </p>
s924460573
p00067
Runtime Error
def counter():#島の数をカウントする count=0 #12*12個の値をひとつずつ調べる for x in range(12): for y in range(12): if is_data[x][y] == 1:#島が発見されたら dfs(x,y) count+=1 return count def dfs(x,y): if x<0 or x == len(is_data[x]) or y<0 or y == len(is_data): return if is_data[x][y] == 1: is_data[x][y] = 0 dfs(x+1,y) dfs(x,y+1) dfs(x-1,y) dfs(x,y-1) def get_map(): is_data = [] while True: try: tmp = list(int(input())) if len(tmp) != 12: break is_data.append(tmp) except: break return map try: while True: is_data = get_map() if len(is_data) != 12: break except EOFError: print(counter())
111100001111 111000001111 110000001111 100000001111 000100010000 000000111000 000001111100 100011111110 110001111100 111000111000 111100010000 000000000000 010001111100 110010000010 010010000001 010000000001 010000000110 010000111000 010000000100 010000000010 010000000001 010010000001 010010000010 111001111100 000000000000 111111111111 100010100001 100010100001 100010100001 100010100001 100100100101 101000011101 100000000001 100000000001 111111111111 100000000001
5 13 4
<H1>島の数</H1> <p> 地勢を示す縦 12, 横 12 のマスからなる平面図があります。おのおののマスは白か黒に塗られています。白は海を、黒は陸地を表します。二つの黒いマスが上下、あるいは左右に接しているとき、これらは地続きであるといいます。この平面図では、黒いマス一つのみ、あるいは地続きの黒いマスが作る領域を「島」といいます。例えば下図には、5 つの島があります。 </p> <pre> ■■■■□□□□■■■■ ■■■□□□□□■■■■ ■■□□□□□□■■■■ ■□□□□□□□■■■■ □□□■□□□■□□□□ □□□□□□■■■□□□ □□□□□■■■■■□□ ■□□□■■■■■■■□ ■■□□□■■■■■□□ ■■■□□□■■■□□□ ■■■■□□□■□□□□ □□□□□□□□□□□□ </pre> <p> マスのデータを読み込んで、島の数を出力するプログラムを作成してください。 </p> <H2>Input</H2> <p> 入力は複数のデータセットからなります。各データセットに１つの平面図が与えられます。黒いマスを 1、白いマスを 0 で表現した 12 個の数字の列 12 行でひとつの平面図を表します。データセットの間は１つの空行で区切られています。 </p> <p> データセットの数は 20 を超えません。 </p> <H2>Output</H2> <p> データセットごとに、島の数を１行に出力します。 </p> <H2>Sample Input</H2> <pre> 111100001111 111000001111 110000001111 100000001111 000100010000 000000111000 000001111100 100011111110 110001111100 111000111000 111100010000 000000000000 010001111100 110010000010 010010000001 010000000001 010000000110 010000111000 010000000100 010000000010 010000000001 010010000001 010010000010 111001111100 000000000000 111111111111 100010100001 100010100001 100010100001 100010100001 100100100101 101000011101 100000000001 100000000001 111111111111 100000000001 </pre> <H2>Output for the Sample Input</H2> <pre> 5 13 4 </pre> <H2>Hint</H2> <p> 以下はサンプルインプットを■と□で表したものです。 <pre> ■■■■□□□□■■■■　　□■□□□■■■■■□□　　□□□□□□□□□□□□ ■■■□□□□□■■■■　　■■□□■□□□□□■□　　■■■■■■■■■■■■ ■■□□□□□□■■■■　　□■□□■□□□□□□■　　■□□□■□■□□□□■ ■□□□□□□□■■■■　　□■□□□□□□□□□■　　■□□□■□■□□□□■ □□□■□□□■□□□□　　□■□□□□□□□■■□　　■□□□■□■□□□□■ □□□□□□■■■□□□　　□■□□□□■■■□□□　　■□□□■□■□□□□■ □□□□□■■■■■□□　　□■□□□□□□□■□□　　■□□■□□■□□■□■ ■□□□■■■■■■■□　　□■□□□□□□□□■□　　■□■□□□□■■■□■ ■■□□□■■■■■□□　　□■□□□□□□□□□■　　■□□□□□□□□□□■ ■■■□□□■■■□□□　　□■□□■□□□□□□■　　■□□□□□□□□□□■ ■■■■□□□■□□□□　　□■□□■□□□□□■□　　■■■■■■■■■■■■ □□□□□□□□□□□□　　■■■□□■■■■■□□　　■□□□□□□□□□□■ </pre> </p>
s218144481
p00067
Runtime Error
def counter():#島の数をカウントする count=0 #12*12個の値をひとつずつ調べる for x in range(12): for y in range(12): if is_data[x][y] == 1:#島が発見されたら dfs(x,y) count+=1 return count def dfs(x,y): if x<0 or x == len(is_data[x]) or y<0 or y == len(is_data): return if is_data[x][y] == 1: is_data[x][y] = 0 dfs(x+1,y) dfs(x,y+1) dfs(x-1,y) dfs(x,y-1) while True: try: is_data=[] while True: s = list(input())#入力 if not s :#空入力のときループぬける break is_data.append(s) except EOFError: print(counter())
111100001111 111000001111 110000001111 100000001111 000100010000 000000111000 000001111100 100011111110 110001111100 111000111000 111100010000 000000000000 010001111100 110010000010 010010000001 010000000001 010000000110 010000111000 010000000100 010000000010 010000000001 010010000001 010010000010 111001111100 000000000000 111111111111 100010100001 100010100001 100010100001 100010100001 100100100101 101000011101 100000000001 100000000001 111111111111 100000000001
5 13 4
<H1>島の数</H1> <p> 地勢を示す縦 12, 横 12 のマスからなる平面図があります。おのおののマスは白か黒に塗られています。白は海を、黒は陸地を表します。二つの黒いマスが上下、あるいは左右に接しているとき、これらは地続きであるといいます。この平面図では、黒いマス一つのみ、あるいは地続きの黒いマスが作る領域を「島」といいます。例えば下図には、5 つの島があります。 </p> <pre> ■■■■□□□□■■■■ ■■■□□□□□■■■■ ■■□□□□□□■■■■ ■□□□□□□□■■■■ □□□■□□□■□□□□ □□□□□□■■■□□□ □□□□□■■■■■□□ ■□□□■■■■■■■□ ■■□□□■■■■■□□ ■■■□□□■■■□□□ ■■■■□□□■□□□□ □□□□□□□□□□□□ </pre> <p> マスのデータを読み込んで、島の数を出力するプログラムを作成してください。 </p> <H2>Input</H2> <p> 入力は複数のデータセットからなります。各データセットに１つの平面図が与えられます。黒いマスを 1、白いマスを 0 で表現した 12 個の数字の列 12 行でひとつの平面図を表します。データセットの間は１つの空行で区切られています。 </p> <p> データセットの数は 20 を超えません。 </p> <H2>Output</H2> <p> データセットごとに、島の数を１行に出力します。 </p> <H2>Sample Input</H2> <pre> 111100001111 111000001111 110000001111 100000001111 000100010000 000000111000 000001111100 100011111110 110001111100 111000111000 111100010000 000000000000 010001111100 110010000010 010010000001 010000000001 010000000110 010000111000 010000000100 010000000010 010000000001 010010000001 010010000010 111001111100 000000000000 111111111111 100010100001 100010100001 100010100001 100010100001 100100100101 101000011101 100000000001 100000000001 111111111111 100000000001 </pre> <H2>Output for the Sample Input</H2> <pre> 5 13 4 </pre> <H2>Hint</H2> <p> 以下はサンプルインプットを■と□で表したものです。 <pre> ■■■■□□□□■■■■　　□■□□□■■■■■□□　　□□□□□□□□□□□□ ■■■□□□□□■■■■　　■■□□■□□□□□■□　　■■■■■■■■■■■■ ■■□□□□□□■■■■　　□■□□■□□□□□□■　　■□□□■□■□□□□■ ■□□□□□□□■■■■　　□■□□□□□□□□□■　　■□□□■□■□□□□■ □□□■□□□■□□□□　　□■□□□□□□□■■□　　■□□□■□■□□□□■ □□□□□□■■■□□□　　□■□□□□■■■□□□　　■□□□■□■□□□□■ □□□□□■■■■■□□　　□■□□□□□□□■□□　　■□□■□□■□□■□■ ■□□□■■■■■■■□　　□■□□□□□□□□■□　　■□■□□□□■■■□■ ■■□□□■■■■■□□　　□■□□□□□□□□□■　　■□□□□□□□□□□■ ■■■□□□■■■□□□　　□■□□■□□□□□□■　　■□□□□□□□□□□■ ■■■■□□□■□□□□　　□■□□■□□□□□■□　　■■■■■■■■■■■■ □□□□□□□□□□□□　　■■■□□■■■■■□□　　■□□□□□□□□□□■ </pre> </p>
s885759970
p00067
Runtime Error
def counter():#島の数をカウントする count=0 #12*12個の値をひとつずつ調べる for x in range(12): for y in range(12): if is_data[x][y] == 1:#島が発見されたら dfs(x,y) count+=1 return count def dfs(x,y): if x<0 or x == len(is_data[x]) or y<0 or y == len(is_data): return if is_data[x][y] == 1: is_data[x][y] = 0 dfs(x+1,y) dfs(x,y+1) dfs(x-1,y) dfs(x,y-1) while True: try: is_data=[] while True: s = list(input())#入力 if not s :#空入力のときループぬける break is_data.append(s) if len(is_data) != 12:break except EOFError: print(counter())
111100001111 111000001111 110000001111 100000001111 000100010000 000000111000 000001111100 100011111110 110001111100 111000111000 111100010000 000000000000 010001111100 110010000010 010010000001 010000000001 010000000110 010000111000 010000000100 010000000010 010000000001 010010000001 010010000010 111001111100 000000000000 111111111111 100010100001 100010100001 100010100001 100010100001 100100100101 101000011101 100000000001 100000000001 111111111111 100000000001
5 13 4
<H1>島の数</H1> <p> 地勢を示す縦 12, 横 12 のマスからなる平面図があります。おのおののマスは白か黒に塗られています。白は海を、黒は陸地を表します。二つの黒いマスが上下、あるいは左右に接しているとき、これらは地続きであるといいます。この平面図では、黒いマス一つのみ、あるいは地続きの黒いマスが作る領域を「島」といいます。例えば下図には、5 つの島があります。 </p> <pre> ■■■■□□□□■■■■ ■■■□□□□□■■■■ ■■□□□□□□■■■■ ■□□□□□□□■■■■ □□□■□□□■□□□□ □□□□□□■■■□□□ □□□□□■■■■■□□ ■□□□■■■■■■■□ ■■□□□■■■■■□□ ■■■□□□■■■□□□ ■■■■□□□■□□□□ □□□□□□□□□□□□ </pre> <p> マスのデータを読み込んで、島の数を出力するプログラムを作成してください。 </p> <H2>Input</H2> <p> 入力は複数のデータセットからなります。各データセットに１つの平面図が与えられます。黒いマスを 1、白いマスを 0 で表現した 12 個の数字の列 12 行でひとつの平面図を表します。データセットの間は１つの空行で区切られています。 </p> <p> データセットの数は 20 を超えません。 </p> <H2>Output</H2> <p> データセットごとに、島の数を１行に出力します。 </p> <H2>Sample Input</H2> <pre> 111100001111 111000001111 110000001111 100000001111 000100010000 000000111000 000001111100 100011111110 110001111100 111000111000 111100010000 000000000000 010001111100 110010000010 010010000001 010000000001 010000000110 010000111000 010000000100 010000000010 010000000001 010010000001 010010000010 111001111100 000000000000 111111111111 100010100001 100010100001 100010100001 100010100001 100100100101 101000011101 100000000001 100000000001 111111111111 100000000001 </pre> <H2>Output for the Sample Input</H2> <pre> 5 13 4 </pre> <H2>Hint</H2> <p> 以下はサンプルインプットを■と□で表したものです。 <pre> ■■■■□□□□■■■■　　□■□□□■■■■■□□　　□□□□□□□□□□□□ ■■■□□□□□■■■■　　■■□□■□□□□□■□　　■■■■■■■■■■■■ ■■□□□□□□■■■■　　□■□□■□□□□□□■　　■□□□■□■□□□□■ ■□□□□□□□■■■■　　□■□□□□□□□□□■　　■□□□■□■□□□□■ □□□■□□□■□□□□　　□■□□□□□□□■■□　　■□□□■□■□□□□■ □□□□□□■■■□□□　　□■□□□□■■■□□□　　■□□□■□■□□□□■ □□□□□■■■■■□□　　□■□□□□□□□■□□　　■□□■□□■□□■□■ ■□□□■■■■■■■□　　□■□□□□□□□□■□　　■□■□□□□■■■□■ ■■□□□■■■■■□□　　□■□□□□□□□□□■　　■□□□□□□□□□□■ ■■■□□□■■■□□□　　□■□□■□□□□□□■　　■□□□□□□□□□□■ ■■■■□□□■□□□□　　□■□□■□□□□□■□　　■■■■■■■■■■■■ □□□□□□□□□□□□　　■■■□□■■■■■□□　　■□□□□□□□□□□■ </pre> </p>
s162436347
p00067
Runtime Error
def counter():#島の数をカウントする count=0 #12*12個の値をひとつずつ調べる for x in range(12): for y in range(12): if is_data[x][y] == 1:#島が発見されたら print(x,y) dfs(x,y) count+=1 return count def dfs(x,y): if x<0 or x == len(is_data[x]) or y<0 or y == len(is_data): return if is_data[x][y] == 1: is_data[x][y] = 0 dfs(x+1,y) dfs(x,y+1) dfs(x-1,y) dfs(x,y-1) try: is_data=[] while True: s = input()#入力 if not s :#空入力のときループぬける break is_data.append(s) for i in range(len(is_data)): is_data[i] = list(map(int,is_data[i])) is_data = np.array(is_data).reshape(12,12) except EOFError: print(counter())
111100001111 111000001111 110000001111 100000001111 000100010000 000000111000 000001111100 100011111110 110001111100 111000111000 111100010000 000000000000 010001111100 110010000010 010010000001 010000000001 010000000110 010000111000 010000000100 010000000010 010000000001 010010000001 010010000010 111001111100 000000000000 111111111111 100010100001 100010100001 100010100001 100010100001 100100100101 101000011101 100000000001 100000000001 111111111111 100000000001
5 13 4
<H1>島の数</H1> <p> 地勢を示す縦 12, 横 12 のマスからなる平面図があります。おのおののマスは白か黒に塗られています。白は海を、黒は陸地を表します。二つの黒いマスが上下、あるいは左右に接しているとき、これらは地続きであるといいます。この平面図では、黒いマス一つのみ、あるいは地続きの黒いマスが作る領域を「島」といいます。例えば下図には、5 つの島があります。 </p> <pre> ■■■■□□□□■■■■ ■■■□□□□□■■■■ ■■□□□□□□■■■■ ■□□□□□□□■■■■ □□□■□□□■□□□□ □□□□□□■■■□□□ □□□□□■■■■■□□ ■□□□■■■■■■■□ ■■□□□■■■■■□□ ■■■□□□■■■□□□ ■■■■□□□■□□□□ □□□□□□□□□□□□ </pre> <p> マスのデータを読み込んで、島の数を出力するプログラムを作成してください。 </p> <H2>Input</H2> <p> 入力は複数のデータセットからなります。各データセットに１つの平面図が与えられます。黒いマスを 1、白いマスを 0 で表現した 12 個の数字の列 12 行でひとつの平面図を表します。データセットの間は１つの空行で区切られています。 </p> <p> データセットの数は 20 を超えません。 </p> <H2>Output</H2> <p> データセットごとに、島の数を１行に出力します。 </p> <H2>Sample Input</H2> <pre> 111100001111 111000001111 110000001111 100000001111 000100010000 000000111000 000001111100 100011111110 110001111100 111000111000 111100010000 000000000000 010001111100 110010000010 010010000001 010000000001 010000000110 010000111000 010000000100 010000000010 010000000001 010010000001 010010000010 111001111100 000000000000 111111111111 100010100001 100010100001 100010100001 100010100001 100100100101 101000011101 100000000001 100000000001 111111111111 100000000001 </pre> <H2>Output for the Sample Input</H2> <pre> 5 13 4 </pre> <H2>Hint</H2> <p> 以下はサンプルインプットを■と□で表したものです。 <pre> ■■■■□□□□■■■■　　□■□□□■■■■■□□　　□□□□□□□□□□□□ ■■■□□□□□■■■■　　■■□□■□□□□□■□　　■■■■■■■■■■■■ ■■□□□□□□■■■■　　□■□□■□□□□□□■　　■□□□■□■□□□□■ ■□□□□□□□■■■■　　□■□□□□□□□□□■　　■□□□■□■□□□□■ □□□■□□□■□□□□　　□■□□□□□□□■■□　　■□□□■□■□□□□■ □□□□□□■■■□□□　　□■□□□□■■■□□□　　■□□□■□■□□□□■ □□□□□■■■■■□□　　□■□□□□□□□■□□　　■□□■□□■□□■□■ ■□□□■■■■■■■□　　□■□□□□□□□□■□　　■□■□□□□■■■□■ ■■□□□■■■■■□□　　□■□□□□□□□□□■　　■□□□□□□□□□□■ ■■■□□□■■■□□□　　□■□□■□□□□□□■　　■□□□□□□□□□□■ ■■■■□□□■□□□□　　□■□□■□□□□□■□　　■■■■■■■■■■■■ □□□□□□□□□□□□　　■■■□□■■■■■□□　　■□□□□□□□□□□■ </pre> </p>
s211707870
p00067
Runtime Error
def get_map(): map = [] while True: try: tmp = list(raw_input()) if len(tmp) != 12: break map.append(tmp) except: break return map def remove_island(x, y, map): map[x][y] = 0 move = [[1, 0], [0, 1], [-1, 0], [0, -1]] for i, j in move: if 0 <= x + i <= 11 and 0 <= y + j <= 11 and map[x + i][y + j] == '1': map = remove_island(x + i, y + j, map) return map[:] while True: map = get_map() if len(map) != 12: break count = 0 for x in range(12): for y in range(12): if map[x][y] == '1': count += 1 map = remove_island(x, y, map) print count
111100001111 111000001111 110000001111 100000001111 000100010000 000000111000 000001111100 100011111110 110001111100 111000111000 111100010000 000000000000 010001111100 110010000010 010010000001 010000000001 010000000110 010000111000 010000000100 010000000010 010000000001 010010000001 010010000010 111001111100 000000000000 111111111111 100010100001 100010100001 100010100001 100010100001 100100100101 101000011101 100000000001 100000000001 111111111111 100000000001
5 13 4
<H1>島の数</H1> <p> 地勢を示す縦 12, 横 12 のマスからなる平面図があります。おのおののマスは白か黒に塗られています。白は海を、黒は陸地を表します。二つの黒いマスが上下、あるいは左右に接しているとき、これらは地続きであるといいます。この平面図では、黒いマス一つのみ、あるいは地続きの黒いマスが作る領域を「島」といいます。例えば下図には、5 つの島があります。 </p> <pre> ■■■■□□□□■■■■ ■■■□□□□□■■■■ ■■□□□□□□■■■■ ■□□□□□□□■■■■ □□□■□□□■□□□□ □□□□□□■■■□□□ □□□□□■■■■■□□ ■□□□■■■■■■■□ ■■□□□■■■■■□□ ■■■□□□■■■□□□ ■■■■□□□■□□□□ □□□□□□□□□□□□ </pre> <p> マスのデータを読み込んで、島の数を出力するプログラムを作成してください。 </p> <H2>Input</H2> <p> 入力は複数のデータセットからなります。各データセットに１つの平面図が与えられます。黒いマスを 1、白いマスを 0 で表現した 12 個の数字の列 12 行でひとつの平面図を表します。データセットの間は１つの空行で区切られています。 </p> <p> データセットの数は 20 を超えません。 </p> <H2>Output</H2> <p> データセットごとに、島の数を１行に出力します。 </p> <H2>Sample Input</H2> <pre> 111100001111 111000001111 110000001111 100000001111 000100010000 000000111000 000001111100 100011111110 110001111100 111000111000 111100010000 000000000000 010001111100 110010000010 010010000001 010000000001 010000000110 010000111000 010000000100 010000000010 010000000001 010010000001 010010000010 111001111100 000000000000 111111111111 100010100001 100010100001 100010100001 100010100001 100100100101 101000011101 100000000001 100000000001 111111111111 100000000001 </pre> <H2>Output for the Sample Input</H2> <pre> 5 13 4 </pre> <H2>Hint</H2> <p> 以下はサンプルインプットを■と□で表したものです。 <pre> ■■■■□□□□■■■■　　□■□□□■■■■■□□　　□□□□□□□□□□□□ ■■■□□□□□■■■■　　■■□□■□□□□□■□　　■■■■■■■■■■■■ ■■□□□□□□■■■■　　□■□□■□□□□□□■　　■□□□■□■□□□□■ ■□□□□□□□■■■■　　□■□□□□□□□□□■　　■□□□■□■□□□□■ □□□■□□□■□□□□　　□■□□□□□□□■■□　　■□□□■□■□□□□■ □□□□□□■■■□□□　　□■□□□□■■■□□□　　■□□□■□■□□□□■ □□□□□■■■■■□□　　□■□□□□□□□■□□　　■□□■□□■□□■□■ ■□□□■■■■■■■□　　□■□□□□□□□□■□　　■□■□□□□■■■□■ ■■□□□■■■■■□□　　□■□□□□□□□□□■　　■□□□□□□□□□□■ ■■■□□□■■■□□□　　□■□□■□□□□□□■　　■□□□□□□□□□□■ ■■■■□□□■□□□□　　□■□□■□□□□□■□　　■■■■■■■■■■■■ □□□□□□□□□□□□　　■■■□□■■■■■□□　　■□□□□□□□□□□■ </pre> </p>
s573217574
p00067
Runtime Error
def counter():#島の数をカウントする count=0 #12*12個の値をひとつずつ調べる for x in range(12): for y in range(12): if is_data[x][y] == 1:#島が発見されたら print(x,y) dfs(x,y) count+=1 return count def dfs(x,y): if x<0 or x == len(is_data[x]) or y<0 or y == len(is_data): return if is_data[x][y] == 1: is_data[x][y] = 0 dfs(x+1,y) dfs(x,y+1) dfs(x-1,y) dfs(x,y-1) try: is_data=[] while True: s = input()#入力 if not s :#空入力のときループぬける break else: is_data.append(s) for i in range(len(is_data)): is_data[i] = list(map(int,is_data[i])) is_data = np.array(is_data).reshape(12,12) except EOFError: print(counter())
111100001111 111000001111 110000001111 100000001111 000100010000 000000111000 000001111100 100011111110 110001111100 111000111000 111100010000 000000000000 010001111100 110010000010 010010000001 010000000001 010000000110 010000111000 010000000100 010000000010 010000000001 010010000001 010010000010 111001111100 000000000000 111111111111 100010100001 100010100001 100010100001 100010100001 100100100101 101000011101 100000000001 100000000001 111111111111 100000000001
5 13 4
<H1>島の数</H1> <p> 地勢を示す縦 12, 横 12 のマスからなる平面図があります。おのおののマスは白か黒に塗られています。白は海を、黒は陸地を表します。二つの黒いマスが上下、あるいは左右に接しているとき、これらは地続きであるといいます。この平面図では、黒いマス一つのみ、あるいは地続きの黒いマスが作る領域を「島」といいます。例えば下図には、5 つの島があります。 </p> <pre> ■■■■□□□□■■■■ ■■■□□□□□■■■■ ■■□□□□□□■■■■ ■□□□□□□□■■■■ □□□■□□□■□□□□ □□□□□□■■■□□□ □□□□□■■■■■□□ ■□□□■■■■■■■□ ■■□□□■■■■■□□ ■■■□□□■■■□□□ ■■■■□□□■□□□□ □□□□□□□□□□□□ </pre> <p> マスのデータを読み込んで、島の数を出力するプログラムを作成してください。 </p> <H2>Input</H2> <p> 入力は複数のデータセットからなります。各データセットに１つの平面図が与えられます。黒いマスを 1、白いマスを 0 で表現した 12 個の数字の列 12 行でひとつの平面図を表します。データセットの間は１つの空行で区切られています。 </p> <p> データセットの数は 20 を超えません。 </p> <H2>Output</H2> <p> データセットごとに、島の数を１行に出力します。 </p> <H2>Sample Input</H2> <pre> 111100001111 111000001111 110000001111 100000001111 000100010000 000000111000 000001111100 100011111110 110001111100 111000111000 111100010000 000000000000 010001111100 110010000010 010010000001 010000000001 010000000110 010000111000 010000000100 010000000010 010000000001 010010000001 010010000010 111001111100 000000000000 111111111111 100010100001 100010100001 100010100001 100010100001 100100100101 101000011101 100000000001 100000000001 111111111111 100000000001 </pre> <H2>Output for the Sample Input</H2> <pre> 5 13 4 </pre> <H2>Hint</H2> <p> 以下はサンプルインプットを■と□で表したものです。 <pre> ■■■■□□□□■■■■　　□■□□□■■■■■□□　　□□□□□□□□□□□□ ■■■□□□□□■■■■　　■■□□■□□□□□■□　　■■■■■■■■■■■■ ■■□□□□□□■■■■　　□■□□■□□□□□□■　　■□□□■□■□□□□■ ■□□□□□□□■■■■　　□■□□□□□□□□□■　　■□□□■□■□□□□■ □□□■□□□■□□□□　　□■□□□□□□□■■□　　■□□□■□■□□□□■ □□□□□□■■■□□□　　□■□□□□■■■□□□　　■□□□■□■□□□□■ □□□□□■■■■■□□　　□■□□□□□□□■□□　　■□□■□□■□□■□■ ■□□□■■■■■■■□　　□■□□□□□□□□■□　　■□■□□□□■■■□■ ■■□□□■■■■■□□　　□■□□□□□□□□□■　　■□□□□□□□□□□■ ■■■□□□■■■□□□　　□■□□■□□□□□□■　　■□□□□□□□□□□■ ■■■■□□□■□□□□　　□■□□■□□□□□■□　　■■■■■■■■■■■■ □□□□□□□□□□□□　　■■■□□■■■■■□□　　■□□□□□□□□□□■ </pre> </p>
s783650929
p00067
Runtime Error
import numpy as np while 1: global a,c c = np.array([[0]*14]*14) a = np.array([[0]*14]*14) a[1:-1,1:-1] = [list(map(int,list(input()))) for i in range(12)] def dfs(x,y,n): if c[x][y] == 0 and a[x][y] == 1: c[x][y] = n [dfs(x+i, y+j, n) for i,j in [(-1,0),(1,0),(0,-1),(0,1)]] [[dfs(x,y,12*x + y) for x in range(1,12+1)] for y in range(1,12+1)] flat = [a for b in c for a in b] print(len(set(flat)) - 1) dump = input() #if input() ==
111100001111 111000001111 110000001111 100000001111 000100010000 000000111000 000001111100 100011111110 110001111100 111000111000 111100010000 000000000000 010001111100 110010000010 010010000001 010000000001 010000000110 010000111000 010000000100 010000000010 010000000001 010010000001 010010000010 111001111100 000000000000 111111111111 100010100001 100010100001 100010100001 100010100001 100100100101 101000011101 100000000001 100000000001 111111111111 100000000001
5 13 4
<H1>島の数</H1> <p> 地勢を示す縦 12, 横 12 のマスからなる平面図があります。おのおののマスは白か黒に塗られています。白は海を、黒は陸地を表します。二つの黒いマスが上下、あるいは左右に接しているとき、これらは地続きであるといいます。この平面図では、黒いマス一つのみ、あるいは地続きの黒いマスが作る領域を「島」といいます。例えば下図には、5 つの島があります。 </p> <pre> ■■■■□□□□■■■■ ■■■□□□□□■■■■ ■■□□□□□□■■■■ ■□□□□□□□■■■■ □□□■□□□■□□□□ □□□□□□■■■□□□ □□□□□■■■■■□□ ■□□□■■■■■■■□ ■■□□□■■■■■□□ ■■■□□□■■■□□□ ■■■■□□□■□□□□ □□□□□□□□□□□□ </pre> <p> マスのデータを読み込んで、島の数を出力するプログラムを作成してください。 </p> <H2>Input</H2> <p> 入力は複数のデータセットからなります。各データセットに１つの平面図が与えられます。黒いマスを 1、白いマスを 0 で表現した 12 個の数字の列 12 行でひとつの平面図を表します。データセットの間は１つの空行で区切られています。 </p> <p> データセットの数は 20 を超えません。 </p> <H2>Output</H2> <p> データセットごとに、島の数を１行に出力します。 </p> <H2>Sample Input</H2> <pre> 111100001111 111000001111 110000001111 100000001111 000100010000 000000111000 000001111100 100011111110 110001111100 111000111000 111100010000 000000000000 010001111100 110010000010 010010000001 010000000001 010000000110 010000111000 010000000100 010000000010 010000000001 010010000001 010010000010 111001111100 000000000000 111111111111 100010100001 100010100001 100010100001 100010100001 100100100101 101000011101 100000000001 100000000001 111111111111 100000000001 </pre> <H2>Output for the Sample Input</H2> <pre> 5 13 4 </pre> <H2>Hint</H2> <p> 以下はサンプルインプットを■と□で表したものです。 <pre> ■■■■□□□□■■■■　　□■□□□■■■■■□□　　□□□□□□□□□□□□ ■■■□□□□□■■■■　　■■□□■□□□□□■□　　■■■■■■■■■■■■ ■■□□□□□□■■■■　　□■□□■□□□□□□■　　■□□□■□■□□□□■ ■□□□□□□□■■■■　　□■□□□□□□□□□■　　■□□□■□■□□□□■ □□□■□□□■□□□□　　□■□□□□□□□■■□　　■□□□■□■□□□□■ □□□□□□■■■□□□　　□■□□□□■■■□□□　　■□□□■□■□□□□■ □□□□□■■■■■□□　　□■□□□□□□□■□□　　■□□■□□■□□■□■ ■□□□■■■■■■■□　　□■□□□□□□□□■□　　■□■□□□□■■■□■ ■■□□□■■■■■□□　　□■□□□□□□□□□■　　■□□□□□□□□□□■ ■■■□□□■■■□□□　　□■□□■□□□□□□■　　■□□□□□□□□□□■ ■■■■□□□■□□□□　　□■□□■□□□□□■□　　■■■■■■■■■■■■ □□□□□□□□□□□□　　■■■□□■■■■■□□　　■□□□□□□□□□□■ </pre> </p>
s151295421
p00067
Runtime Error
import numpy as np while 1: global a,c c = np.array([[0]*14]*14) a = np.array([[0]*14]*14) a[1:-1,1:-1] = [list(map(int,list(input()))) for i in range(12)] def dfs(x,y,n): if c[x][y] == 0 and a[x][y] == 1: c[x][y] = n [dfs(x+i, y+j, n) for i,j in [(-1,0),(1,0),(0,-1),(0,1)]] [[dfs(x,y,12*x + y) for x in range(1,12+1)] for y in range(1,12+1)] flat = [a for b in c for a in b] print(len(set(flat)) - 1) if input() is None: break
111100001111 111000001111 110000001111 100000001111 000100010000 000000111000 000001111100 100011111110 110001111100 111000111000 111100010000 000000000000 010001111100 110010000010 010010000001 010000000001 010000000110 010000111000 010000000100 010000000010 010000000001 010010000001 010010000010 111001111100 000000000000 111111111111 100010100001 100010100001 100010100001 100010100001 100100100101 101000011101 100000000001 100000000001 111111111111 100000000001
5 13 4
<H1>島の数</H1> <p> 地勢を示す縦 12, 横 12 のマスからなる平面図があります。おのおののマスは白か黒に塗られています。白は海を、黒は陸地を表します。二つの黒いマスが上下、あるいは左右に接しているとき、これらは地続きであるといいます。この平面図では、黒いマス一つのみ、あるいは地続きの黒いマスが作る領域を「島」といいます。例えば下図には、5 つの島があります。 </p> <pre> ■■■■□□□□■■■■ ■■■□□□□□■■■■ ■■□□□□□□■■■■ ■□□□□□□□■■■■ □□□■□□□■□□□□ □□□□□□■■■□□□ □□□□□■■■■■□□ ■□□□■■■■■■■□ ■■□□□■■■■■□□ ■■■□□□■■■□□□ ■■■■□□□■□□□□ □□□□□□□□□□□□ </pre> <p> マスのデータを読み込んで、島の数を出力するプログラムを作成してください。 </p> <H2>Input</H2> <p> 入力は複数のデータセットからなります。各データセットに１つの平面図が与えられます。黒いマスを 1、白いマスを 0 で表現した 12 個の数字の列 12 行でひとつの平面図を表します。データセットの間は１つの空行で区切られています。 </p> <p> データセットの数は 20 を超えません。 </p> <H2>Output</H2> <p> データセットごとに、島の数を１行に出力します。 </p> <H2>Sample Input</H2> <pre> 111100001111 111000001111 110000001111 100000001111 000100010000 000000111000 000001111100 100011111110 110001111100 111000111000 111100010000 000000000000 010001111100 110010000010 010010000001 010000000001 010000000110 010000111000 010000000100 010000000010 010000000001 010010000001 010010000010 111001111100 000000000000 111111111111 100010100001 100010100001 100010100001 100010100001 100100100101 101000011101 100000000001 100000000001 111111111111 100000000001 </pre> <H2>Output for the Sample Input</H2> <pre> 5 13 4 </pre> <H2>Hint</H2> <p> 以下はサンプルインプットを■と□で表したものです。 <pre> ■■■■□□□□■■■■　　□■□□□■■■■■□□　　□□□□□□□□□□□□ ■■■□□□□□■■■■　　■■□□■□□□□□■□　　■■■■■■■■■■■■ ■■□□□□□□■■■■　　□■□□■□□□□□□■　　■□□□■□■□□□□■ ■□□□□□□□■■■■　　□■□□□□□□□□□■　　■□□□■□■□□□□■ □□□■□□□■□□□□　　□■□□□□□□□■■□　　■□□□■□■□□□□■ □□□□□□■■■□□□　　□■□□□□■■■□□□　　■□□□■□■□□□□■ □□□□□■■■■■□□　　□■□□□□□□□■□□　　■□□■□□■□□■□■ ■□□□■■■■■■■□　　□■□□□□□□□□■□　　■□■□□□□■■■□■ ■■□□□■■■■■□□　　□■□□□□□□□□□■　　■□□□□□□□□□□■ ■■■□□□■■■□□□　　□■□□■□□□□□□■　　■□□□□□□□□□□■ ■■■■□□□■□□□□　　□■□□■□□□□□■□　　■■■■■■■■■■■■ □□□□□□□□□□□□　　■■■□□■■■■■□□　　■□□□□□□□□□□■ </pre> </p>
s702727904
p00067
Runtime Error
import sys def f(y,x): f=0 if m[y][x]==1: m[y][x]=c f=1 return f def LR(y,x,dx): P=[] x+=dx while 0<=x<12 and m[y][x]!=0: if f(y,x):P+=[(y,x)] x+=dx return P def UD(y,x,dy): P=[] y+=dy while 0<=y<12 and m[y][x]!=0: if f(y,x):P+=[(y,x)] y+=dy return P def v1(buf): f=0 while len(buf)>0: f=1 y,x=buf.pop() m[y][x]=c buf=list(set(buf+LR(y,x,-1)+LR(y,x,1)+UD(y,x,-1)+UD(y,x,1))) return f def solve(): global c buf=[] c=2 for i in A: x=m[i] while x.count(1)>0: buf+=[(i,x.index(1))] if v1(buf):c+=1 return c-2 A=range(12) m=[[0 for x in A] for y in A] y=0 for s in sys.stdin: if y<12: x=0 for e in map(int,list(s[:-1])): m[y][x]=e x+=1 y+=1 else: print solve() y=0 print solve()
111100001111 111000001111 110000001111 100000001111 000100010000 000000111000 000001111100 100011111110 110001111100 111000111000 111100010000 000000000000 010001111100 110010000010 010010000001 010000000001 010000000110 010000111000 010000000100 010000000010 010000000001 010010000001 010010000010 111001111100 000000000000 111111111111 100010100001 100010100001 100010100001 100010100001 100100100101 101000011101 100000000001 100000000001 111111111111 100000000001
5 13 4
<H1>島の数</H1> <p> 地勢を示す縦 12, 横 12 のマスからなる平面図があります。おのおののマスは白か黒に塗られています。白は海を、黒は陸地を表します。二つの黒いマスが上下、あるいは左右に接しているとき、これらは地続きであるといいます。この平面図では、黒いマス一つのみ、あるいは地続きの黒いマスが作る領域を「島」といいます。例えば下図には、5 つの島があります。 </p> <pre> ■■■■□□□□■■■■ ■■■□□□□□■■■■ ■■□□□□□□■■■■ ■□□□□□□□■■■■ □□□■□□□■□□□□ □□□□□□■■■□□□ □□□□□■■■■■□□ ■□□□■■■■■■■□ ■■□□□■■■■■□□ ■■■□□□■■■□□□ ■■■■□□□■□□□□ □□□□□□□□□□□□ </pre> <p> マスのデータを読み込んで、島の数を出力するプログラムを作成してください。 </p> <H2>Input</H2> <p> 入力は複数のデータセットからなります。各データセットに１つの平面図が与えられます。黒いマスを 1、白いマスを 0 で表現した 12 個の数字の列 12 行でひとつの平面図を表します。データセットの間は１つの空行で区切られています。 </p> <p> データセットの数は 20 を超えません。 </p> <H2>Output</H2> <p> データセットごとに、島の数を１行に出力します。 </p> <H2>Sample Input</H2> <pre> 111100001111 111000001111 110000001111 100000001111 000100010000 000000111000 000001111100 100011111110 110001111100 111000111000 111100010000 000000000000 010001111100 110010000010 010010000001 010000000001 010000000110 010000111000 010000000100 010000000010 010000000001 010010000001 010010000010 111001111100 000000000000 111111111111 100010100001 100010100001 100010100001 100010100001 100100100101 101000011101 100000000001 100000000001 111111111111 100000000001 </pre> <H2>Output for the Sample Input</H2> <pre> 5 13 4 </pre> <H2>Hint</H2> <p> 以下はサンプルインプットを■と□で表したものです。 <pre> ■■■■□□□□■■■■　　□■□□□■■■■■□□　　□□□□□□□□□□□□ ■■■□□□□□■■■■　　■■□□■□□□□□■□　　■■■■■■■■■■■■ ■■□□□□□□■■■■　　□■□□■□□□□□□■　　■□□□■□■□□□□■ ■□□□□□□□■■■■　　□■□□□□□□□□□■　　■□□□■□■□□□□■ □□□■□□□■□□□□　　□■□□□□□□□■■□　　■□□□■□■□□□□■ □□□□□□■■■□□□　　□■□□□□■■■□□□　　■□□□■□■□□□□■ □□□□□■■■■■□□　　□■□□□□□□□■□□　　■□□■□□■□□■□■ ■□□□■■■■■■■□　　□■□□□□□□□□■□　　■□■□□□□■■■□■ ■■□□□■■■■■□□　　□■□□□□□□□□□■　　■□□□□□□□□□□■ ■■■□□□■■■□□□　　□■□□■□□□□□□■　　■□□□□□□□□□□■ ■■■■□□□■□□□□　　□■□□■□□□□□■□　　■■■■■■■■■■■■ □□□□□□□□□□□□　　■■■□□■■■■■□□　　■□□□□□□□□□□■ </pre> </p>
s854528678
p00067
Runtime Error
l = 12 def island(f,x,y,m): rf = f[:][:] if rf[y][x] == 1: rf[y][x] = m for i in [-1,1]: if 0 <= x+i <= l-1: rf = island(rf,x+i,y,m) if 0 <= y+i <= l-1: rf = island(rf,x,y+i,m) return rf while True: f = [] for i in range(l): f.append(map(int, list(raw_input()))) for y in range(l): for x in range(l): f = island(f,x,y,m) m += 1 m, ans = 2, [] for i in range(l): for j in range(l): ans.append(f[i][j]) print len(list(set(ans)))-1 try : raw_input() except: break
111100001111 111000001111 110000001111 100000001111 000100010000 000000111000 000001111100 100011111110 110001111100 111000111000 111100010000 000000000000 010001111100 110010000010 010010000001 010000000001 010000000110 010000111000 010000000100 010000000010 010000000001 010010000001 010010000010 111001111100 000000000000 111111111111 100010100001 100010100001 100010100001 100010100001 100100100101 101000011101 100000000001 100000000001 111111111111 100000000001
5 13 4
<H1>島の数</H1> <p> 地勢を示す縦 12, 横 12 のマスからなる平面図があります。おのおののマスは白か黒に塗られています。白は海を、黒は陸地を表します。二つの黒いマスが上下、あるいは左右に接しているとき、これらは地続きであるといいます。この平面図では、黒いマス一つのみ、あるいは地続きの黒いマスが作る領域を「島」といいます。例えば下図には、5 つの島があります。 </p> <pre> ■■■■□□□□■■■■ ■■■□□□□□■■■■ ■■□□□□□□■■■■ ■□□□□□□□■■■■ □□□■□□□■□□□□ □□□□□□■■■□□□ □□□□□■■■■■□□ ■□□□■■■■■■■□ ■■□□□■■■■■□□ ■■■□□□■■■□□□ ■■■■□□□■□□□□ □□□□□□□□□□□□ </pre> <p> マスのデータを読み込んで、島の数を出力するプログラムを作成してください。 </p> <H2>Input</H2> <p> 入力は複数のデータセットからなります。各データセットに１つの平面図が与えられます。黒いマスを 1、白いマスを 0 で表現した 12 個の数字の列 12 行でひとつの平面図を表します。データセットの間は１つの空行で区切られています。 </p> <p> データセットの数は 20 を超えません。 </p> <H2>Output</H2> <p> データセットごとに、島の数を１行に出力します。 </p> <H2>Sample Input</H2> <pre> 111100001111 111000001111 110000001111 100000001111 000100010000 000000111000 000001111100 100011111110 110001111100 111000111000 111100010000 000000000000 010001111100 110010000010 010010000001 010000000001 010000000110 010000111000 010000000100 010000000010 010000000001 010010000001 010010000010 111001111100 000000000000 111111111111 100010100001 100010100001 100010100001 100010100001 100100100101 101000011101 100000000001 100000000001 111111111111 100000000001 </pre> <H2>Output for the Sample Input</H2> <pre> 5 13 4 </pre> <H2>Hint</H2> <p> 以下はサンプルインプットを■と□で表したものです。 <pre> ■■■■□□□□■■■■　　□■□□□■■■■■□□　　□□□□□□□□□□□□ ■■■□□□□□■■■■　　■■□□■□□□□□■□　　■■■■■■■■■■■■ ■■□□□□□□■■■■　　□■□□■□□□□□□■　　■□□□■□■□□□□■ ■□□□□□□□■■■■　　□■□□□□□□□□□■　　■□□□■□■□□□□■ □□□■□□□■□□□□　　□■□□□□□□□■■□　　■□□□■□■□□□□■ □□□□□□■■■□□□　　□■□□□□■■■□□□　　■□□□■□■□□□□■ □□□□□■■■■■□□　　□■□□□□□□□■□□　　■□□■□□■□□■□■ ■□□□■■■■■■■□　　□■□□□□□□□□■□　　■□■□□□□■■■□■ ■■□□□■■■■■□□　　□■□□□□□□□□□■　　■□□□□□□□□□□■ ■■■□□□■■■□□□　　□■□□■□□□□□□■　　■□□□□□□□□□□■ ■■■■□□□■□□□□　　□■□□■□□□□□■□　　■■■■■■■■■■■■ □□□□□□□□□□□□　　■■■□□■■■■■□□　　■□□□□□□□□□□■ </pre> </p>
s076408919
p00067
Runtime Error
File Edit Options Buffers Tools Python Help def island(f,x,y,m): if f[y][x] == 1: f[y][x] = m for i in [-1,1]: if 0 <= x+i <= 11: f = island(f,x+i,y,m) if 0 <= y+i <= 11: f = island(f,x,y+i,m) return f while True: f = []; m = 2 for i in range(12): f.append(map(int, list(raw_input()))) for y in range(12): for x in range(12): if f[y][x]: f = island(f,x,y,m) m += 1 ans = [] for i in range(12): for j in range(12): ans.append(f[i][j]) ans = list(set(ans)) print len(ans) - 1*ans.count(0) try:raw_input() except: break
111100001111 111000001111 110000001111 100000001111 000100010000 000000111000 000001111100 100011111110 110001111100 111000111000 111100010000 000000000000 010001111100 110010000010 010010000001 010000000001 010000000110 010000111000 010000000100 010000000010 010000000001 010010000001 010010000010 111001111100 000000000000 111111111111 100010100001 100010100001 100010100001 100010100001 100100100101 101000011101 100000000001 100000000001 111111111111 100000000001
5 13 4
<H1>島の数</H1> <p> 地勢を示す縦 12, 横 12 のマスからなる平面図があります。おのおののマスは白か黒に塗られています。白は海を、黒は陸地を表します。二つの黒いマスが上下、あるいは左右に接しているとき、これらは地続きであるといいます。この平面図では、黒いマス一つのみ、あるいは地続きの黒いマスが作る領域を「島」といいます。例えば下図には、5 つの島があります。 </p> <pre> ■■■■□□□□■■■■ ■■■□□□□□■■■■ ■■□□□□□□■■■■ ■□□□□□□□■■■■ □□□■□□□■□□□□ □□□□□□■■■□□□ □□□□□■■■■■□□ ■□□□■■■■■■■□ ■■□□□■■■■■□□ ■■■□□□■■■□□□ ■■■■□□□■□□□□ □□□□□□□□□□□□ </pre> <p> マスのデータを読み込んで、島の数を出力するプログラムを作成してください。 </p> <H2>Input</H2> <p> 入力は複数のデータセットからなります。各データセットに１つの平面図が与えられます。黒いマスを 1、白いマスを 0 で表現した 12 個の数字の列 12 行でひとつの平面図を表します。データセットの間は１つの空行で区切られています。 </p> <p> データセットの数は 20 を超えません。 </p> <H2>Output</H2> <p> データセットごとに、島の数を１行に出力します。 </p> <H2>Sample Input</H2> <pre> 111100001111 111000001111 110000001111 100000001111 000100010000 000000111000 000001111100 100011111110 110001111100 111000111000 111100010000 000000000000 010001111100 110010000010 010010000001 010000000001 010000000110 010000111000 010000000100 010000000010 010000000001 010010000001 010010000010 111001111100 000000000000 111111111111 100010100001 100010100001 100010100001 100010100001 100100100101 101000011101 100000000001 100000000001 111111111111 100000000001 </pre> <H2>Output for the Sample Input</H2> <pre> 5 13 4 </pre> <H2>Hint</H2> <p> 以下はサンプルインプットを■と□で表したものです。 <pre> ■■■■□□□□■■■■　　□■□□□■■■■■□□　　□□□□□□□□□□□□ ■■■□□□□□■■■■　　■■□□■□□□□□■□　　■■■■■■■■■■■■ ■■□□□□□□■■■■　　□■□□■□□□□□□■　　■□□□■□■□□□□■ ■□□□□□□□■■■■　　□■□□□□□□□□□■　　■□□□■□■□□□□■ □□□■□□□■□□□□　　□■□□□□□□□■■□　　■□□□■□■□□□□■ □□□□□□■■■□□□　　□■□□□□■■■□□□　　■□□□■□■□□□□■ □□□□□■■■■■□□　　□■□□□□□□□■□□　　■□□■□□■□□■□■ ■□□□■■■■■■■□　　□■□□□□□□□□■□　　■□■□□□□■■■□■ ■■□□□■■■■■□□　　□■□□□□□□□□□■　　■□□□□□□□□□□■ ■■■□□□■■■□□□　　□■□□■□□□□□□■　　■□□□□□□□□□□■ ■■■■□□□■□□□□　　□■□□■□□□□□■□　　■■■■■■■■■■■■ □□□□□□□□□□□□　　■■■□□■■■■■□□　　■□□□□□□□□□□■ </pre> </p>
s017818627
p00067
Runtime Error
dx, dy = [-1, 0, 1, 0], [0, -1, 0, 1] while True: ans = 0 try: m = ['0'*14] + ['0'+raw_input()+'0' for i in xrange(12)] + ['0'*14] f = [[False for i in xrange(14)] for j in xrange(14)] for y in xrange(1, 13): for x in xrange(1, 13): if m[y][x]=='1' and f[y][x]==False: q = [[x, y]] f[y][x] = True while len(q)>0: px, py = q.pop(0) for k in xrange(4): nx = px + dx[k]; ny = py + dy[k]; if m[ny][nx]=='1' and f[ny][nx]==False: f[ny][nx] = True q.append([nx, ny]) ans += 1 print ans except EOFError: break
111100001111 111000001111 110000001111 100000001111 000100010000 000000111000 000001111100 100011111110 110001111100 111000111000 111100010000 000000000000 010001111100 110010000010 010010000001 010000000001 010000000110 010000111000 010000000100 010000000010 010000000001 010010000001 010010000010 111001111100 000000000000 111111111111 100010100001 100010100001 100010100001 100010100001 100100100101 101000011101 100000000001 100000000001 111111111111 100000000001
5 13 4
<H1>島の数</H1> <p> 地勢を示す縦 12, 横 12 のマスからなる平面図があります。おのおののマスは白か黒に塗られています。白は海を、黒は陸地を表します。二つの黒いマスが上下、あるいは左右に接しているとき、これらは地続きであるといいます。この平面図では、黒いマス一つのみ、あるいは地続きの黒いマスが作る領域を「島」といいます。例えば下図には、5 つの島があります。 </p> <pre> ■■■■□□□□■■■■ ■■■□□□□□■■■■ ■■□□□□□□■■■■ ■□□□□□□□■■■■ □□□■□□□■□□□□ □□□□□□■■■□□□ □□□□□■■■■■□□ ■□□□■■■■■■■□ ■■□□□■■■■■□□ ■■■□□□■■■□□□ ■■■■□□□■□□□□ □□□□□□□□□□□□ </pre> <p> マスのデータを読み込んで、島の数を出力するプログラムを作成してください。 </p> <H2>Input</H2> <p> 入力は複数のデータセットからなります。各データセットに１つの平面図が与えられます。黒いマスを 1、白いマスを 0 で表現した 12 個の数字の列 12 行でひとつの平面図を表します。データセットの間は１つの空行で区切られています。 </p> <p> データセットの数は 20 を超えません。 </p> <H2>Output</H2> <p> データセットごとに、島の数を１行に出力します。 </p> <H2>Sample Input</H2> <pre> 111100001111 111000001111 110000001111 100000001111 000100010000 000000111000 000001111100 100011111110 110001111100 111000111000 111100010000 000000000000 010001111100 110010000010 010010000001 010000000001 010000000110 010000111000 010000000100 010000000010 010000000001 010010000001 010010000010 111001111100 000000000000 111111111111 100010100001 100010100001 100010100001 100010100001 100100100101 101000011101 100000000001 100000000001 111111111111 100000000001 </pre> <H2>Output for the Sample Input</H2> <pre> 5 13 4 </pre> <H2>Hint</H2> <p> 以下はサンプルインプットを■と□で表したものです。 <pre> ■■■■□□□□■■■■　　□■□□□■■■■■□□　　□□□□□□□□□□□□ ■■■□□□□□■■■■　　■■□□■□□□□□■□　　■■■■■■■■■■■■ ■■□□□□□□■■■■　　□■□□■□□□□□□■　　■□□□■□■□□□□■ ■□□□□□□□■■■■　　□■□□□□□□□□□■　　■□□□■□■□□□□■ □□□■□□□■□□□□　　□■□□□□□□□■■□　　■□□□■□■□□□□■ □□□□□□■■■□□□　　□■□□□□■■■□□□　　■□□□■□■□□□□■ □□□□□■■■■■□□　　□■□□□□□□□■□□　　■□□■□□■□□■□■ ■□□□■■■■■■■□　　□■□□□□□□□□■□　　■□■□□□□■■■□■ ■■□□□■■■■■□□　　□■□□□□□□□□□■　　■□□□□□□□□□□■ ■■■□□□■■■□□□　　□■□□■□□□□□□■　　■□□□□□□□□□□■ ■■■■□□□■□□□□　　□■□□■□□□□□■□　　■■■■■■■■■■■■ □□□□□□□□□□□□　　■■■□□■■■■■□□　　■□□□□□□□□□□■ </pre> </p>
s619501160
p00067
Runtime Error
#include <iostream> using namespace std; int m[12][12]; bool valid(int y, int x){ if(0 <= y && y < 12){ if(0 <= x && x < 12){ if(m[y][x] == 1) return true; } } return false; } void remove_island(int y, int x) { int nx, ny; int dx[4] = {1, 0, -1, 0}; int dy[4] = {0, 1, 0, -1}; m[y][x] = 0; for(int i = 0; i < 4; i++){ ny = y + dy[i]; nx = x + dx[i]; if(valid(ny, nx)) remove_island(ny, nx); } } int main() { char c[12]; int ans; while(1){ for(int i = 0; i < 12; i++){ if(!(cin >> c)) return 0; for(int j = 0; j < 12; j++){ m[i][j] = (int)(c[j] - '0'); } } ans = 0; for(int i = 0; i < 12; i++){ for(int j = 0; j < 12; j++){ if(valid(i, j)){ remove_island(i, j); ans++; } } } cout << ans << endl; } return 0; }
111100001111 111000001111 110000001111 100000001111 000100010000 000000111000 000001111100 100011111110 110001111100 111000111000 111100010000 000000000000 010001111100 110010000010 010010000001 010000000001 010000000110 010000111000 010000000100 010000000010 010000000001 010010000001 010010000010 111001111100 000000000000 111111111111 100010100001 100010100001 100010100001 100010100001 100100100101 101000011101 100000000001 100000000001 111111111111 100000000001
5 13 4
<H1>島の数</H1> <p> 地勢を示す縦 12, 横 12 のマスからなる平面図があります。おのおののマスは白か黒に塗られています。白は海を、黒は陸地を表します。二つの黒いマスが上下、あるいは左右に接しているとき、これらは地続きであるといいます。この平面図では、黒いマス一つのみ、あるいは地続きの黒いマスが作る領域を「島」といいます。例えば下図には、5 つの島があります。 </p> <pre> ■■■■□□□□■■■■ ■■■□□□□□■■■■ ■■□□□□□□■■■■ ■□□□□□□□■■■■ □□□■□□□■□□□□ □□□□□□■■■□□□ □□□□□■■■■■□□ ■□□□■■■■■■■□ ■■□□□■■■■■□□ ■■■□□□■■■□□□ ■■■■□□□■□□□□ □□□□□□□□□□□□ </pre> <p> マスのデータを読み込んで、島の数を出力するプログラムを作成してください。 </p> <H2>Input</H2> <p> 入力は複数のデータセットからなります。各データセットに１つの平面図が与えられます。黒いマスを 1、白いマスを 0 で表現した 12 個の数字の列 12 行でひとつの平面図を表します。データセットの間は１つの空行で区切られています。 </p> <p> データセットの数は 20 を超えません。 </p> <H2>Output</H2> <p> データセットごとに、島の数を１行に出力します。 </p> <H2>Sample Input</H2> <pre> 111100001111 111000001111 110000001111 100000001111 000100010000 000000111000 000001111100 100011111110 110001111100 111000111000 111100010000 000000000000 010001111100 110010000010 010010000001 010000000001 010000000110 010000111000 010000000100 010000000010 010000000001 010010000001 010010000010 111001111100 000000000000 111111111111 100010100001 100010100001 100010100001 100010100001 100100100101 101000011101 100000000001 100000000001 111111111111 100000000001 </pre> <H2>Output for the Sample Input</H2> <pre> 5 13 4 </pre> <H2>Hint</H2> <p> 以下はサンプルインプットを■と□で表したものです。 <pre> ■■■■□□□□■■■■　　□■□□□■■■■■□□　　□□□□□□□□□□□□ ■■■□□□□□■■■■　　■■□□■□□□□□■□　　■■■■■■■■■■■■ ■■□□□□□□■■■■　　□■□□■□□□□□□■　　■□□□■□■□□□□■ ■□□□□□□□■■■■　　□■□□□□□□□□□■　　■□□□■□■□□□□■ □□□■□□□■□□□□　　□■□□□□□□□■■□　　■□□□■□■□□□□■ □□□□□□■■■□□□　　□■□□□□■■■□□□　　■□□□■□■□□□□■ □□□□□■■■■■□□　　□■□□□□□□□■□□　　■□□■□□■□□■□■ ■□□□■■■■■■■□　　□■□□□□□□□□■□　　■□■□□□□■■■□■ ■■□□□■■■■■□□　　□■□□□□□□□□□■　　■□□□□□□□□□□■ ■■■□□□■■■□□□　　□■□□■□□□□□□■　　■□□□□□□□□□□■ ■■■■□□□■□□□□　　□■□□■□□□□□■□　　■■■■■■■■■■■■ □□□□□□□□□□□□　　■■■□□■■■■■□□　　■□□□□□□□□□□■ </pre> </p>
s266860718
p00068
Wrong Answer
from math import atan2 def grahams_scan(a: list): a.sort(key=lambda x: x[1]) x1, y1 = a[0] a = [((x1, y1), 0)] +\ sorted([((x2, y2), atan2(y2-y1, x2-x1)) for x2, y2 in a[1:]], key=lambda x: x[1]) +\ [((x1, y1), 0)] result = [(x1, y1)] for ((x2, y2),_), ((x3, y3),_) in zip(a[1:], a[2:]): if (x1-x2)*(y3-y2) - (y1-y2)*(x3-x2) < 0: result.append((x2, x3)) x1, y1 = x2, y2 return result while True: n = int(input()) if not n: break a = [tuple(map(float, input().split(","))) for _ in [0]*n] r = grahams_scan(a) print(n-len(r))
4 1.0,0.0 0.0,1.0 2.0,1.0 1.0,2.0 9 -509.94,892.63 567.62,639.99 -859.32,-64.84 -445.99,383.69 667.54,430.49 551.12,828.21 -940.2,-877.2 -361.62,-970 -125.42,-178.48 0
0 3
<H1>輪ゴム</H1> <p> <var>n</var> 本の釘を平板上の座標 <var>P<sub>1</sub></var> (<var>x<sub>1</sub></var>, <var>y</sub>1</sub></var>), <var>P<sub>2</sub></var> (<var>x<sub>2</sub></var>, <var>y<sub>2</sub></var>), <var>P<sub>3</sub></var> (<var>x<sub>3</sub></var>, <var>y<sub>3</sub></var>),..., <var>P<sub>n</sub></var> (<var>x<sub>n</sub></var>, <var>y<sub>n</sub></var>) に１本ずつ打ち、輪ゴムの輪の中に全ての釘が入るように 1 本の輪ゴムで囲みます。このとき、輪ゴムが交差してはいけません。 </p> <p> 釘の座標を読み込んで、上記のように釘を輪ゴムで囲んだときに輪ゴムに接していない釘の本数を出力するプログラムを作成してください。輪ゴムは充分に伸び縮みするものとします。同じ座標に 2 本以上の釘を打つことはないものとします。また、輪ゴムがかかった釘と釘の間は直線で結ばれるものとし、その直線上に 3 本以上の釘が並ぶことはないものとします。例えば、図 1 に示すような入力はありえません。図 2 に示すように輪ゴムがかかっていない釘が 1 直線上に並ぶことはありえます。 </p> <center> <table> <tr> <td width="240"><img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_convex1"></td> <td width="240"><img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_convex2"></td> </tr> <tr> <td>図１</td> <td>図２</td> </tr> </table> </center> <br/> <p> ただし、それぞれの座標値は -1000.0 以上1000.0 以下の実数です。また、<var>n</var> は 3 以上 100 以下の整数です。 </p> <H2>Input</H2> <p> 複数のデータセットが与えられます。各データセットは以下のような形式です与えられます。 </p> <pre> <var>n</var> <var>x<sub>1</sub></var>, <var>y<sub>1</sub></var> <var>x<sub>2</sub></var>, <var>y<sub>2</sub></var> ... 　　　　 ... <var>x<sub>n</sub></var>, <var>y<sub>n</sub></var> </pre> <p> <var>n</var> が 0 の時、入力の最後を示します。データセットの数は 50 を超えません。 </p> <H2>Output</H2> <p> データセットごとに、ゴムと接していない釘の本数を出力してください。 例えば、図 3 に示す４つの釘を表す入力があった場合、図 4 のように囲まれるので、輪ゴムに接していない釘の本数は 1 本です。 </p> <center> <table> <tr> <td width="240"><img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_convex3"></td> <td width="240"><img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_convex4"></td> </tr> <tr> <td>図３</td> <td>図４</td> </tr> </table> </center> <br/> <H2>Sample Input</H2> <pre> 4 1.0,0.0 0.0,1.0 2.0,1.0 1.0,2.0 9 -509.94,892.63 567.62,639.99 -859.32,-64.84 -445.99,383.69 667.54,430.49 551.12,828.21 -940.2,-877.2 -361.62,-970 -125.42,-178.48 0 </pre> <H2>Output for the Sample Input</H2> <pre> 0 3 </pre> <H2>Hint</H2> <p> 以下は２つめのサンプル入力に対する図です。 </p> <center> <table> <tr> <td><img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_convex5"></td> </tr> <tr> </tr> </table> </center>
s917984826
p00068
Wrong Answer
from math import atan2 class Point(object): def __init__(self, x, y): self.x = x self.y = y class Vector(object): def __init__(self, p1, p2): self.x = p2.x - p1.x self.y = p2.y - p1.y def cross(self, other: "Vector") -> float: return self.x*other.y - self.y*other.x def grahams_scan(a: list): a.sort(key=lambda p: p.y) bottom_x, bottom_y = a[0].x, a[0].y _a = sorted(a[1:], key=lambda p: atan2(bottom_y-p.y, bottom_x-p.x)) result = [a[0], _a[0]] for next_point in _a[1:]: while Vector(result[-1], result[-2]).cross(Vector(result[-1], next_point)) >= 0: result.pop() result.append(next_point) return result while True: n = int(input()) if not n: break a = [Point(*map(float, input().split(","))) for _ in [0]*n] result = grahams_scan(a) print(n-len(result))
4 1.0,0.0 0.0,1.0 2.0,1.0 1.0,2.0 9 -509.94,892.63 567.62,639.99 -859.32,-64.84 -445.99,383.69 667.54,430.49 551.12,828.21 -940.2,-877.2 -361.62,-970 -125.42,-178.48 0
0 3
<H1>輪ゴム</H1> <p> <var>n</var> 本の釘を平板上の座標 <var>P<sub>1</sub></var> (<var>x<sub>1</sub></var>, <var>y</sub>1</sub></var>), <var>P<sub>2</sub></var> (<var>x<sub>2</sub></var>, <var>y<sub>2</sub></var>), <var>P<sub>3</sub></var> (<var>x<sub>3</sub></var>, <var>y<sub>3</sub></var>),..., <var>P<sub>n</sub></var> (<var>x<sub>n</sub></var>, <var>y<sub>n</sub></var>) に１本ずつ打ち、輪ゴムの輪の中に全ての釘が入るように 1 本の輪ゴムで囲みます。このとき、輪ゴムが交差してはいけません。 </p> <p> 釘の座標を読み込んで、上記のように釘を輪ゴムで囲んだときに輪ゴムに接していない釘の本数を出力するプログラムを作成してください。輪ゴムは充分に伸び縮みするものとします。同じ座標に 2 本以上の釘を打つことはないものとします。また、輪ゴムがかかった釘と釘の間は直線で結ばれるものとし、その直線上に 3 本以上の釘が並ぶことはないものとします。例えば、図 1 に示すような入力はありえません。図 2 に示すように輪ゴムがかかっていない釘が 1 直線上に並ぶことはありえます。 </p> <center> <table> <tr> <td width="240"><img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_convex1"></td> <td width="240"><img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_convex2"></td> </tr> <tr> <td>図１</td> <td>図２</td> </tr> </table> </center> <br/> <p> ただし、それぞれの座標値は -1000.0 以上1000.0 以下の実数です。また、<var>n</var> は 3 以上 100 以下の整数です。 </p> <H2>Input</H2> <p> 複数のデータセットが与えられます。各データセットは以下のような形式です与えられます。 </p> <pre> <var>n</var> <var>x<sub>1</sub></var>, <var>y<sub>1</sub></var> <var>x<sub>2</sub></var>, <var>y<sub>2</sub></var> ... 　　　　 ... <var>x<sub>n</sub></var>, <var>y<sub>n</sub></var> </pre> <p> <var>n</var> が 0 の時、入力の最後を示します。データセットの数は 50 を超えません。 </p> <H2>Output</H2> <p> データセットごとに、ゴムと接していない釘の本数を出力してください。 例えば、図 3 に示す４つの釘を表す入力があった場合、図 4 のように囲まれるので、輪ゴムに接していない釘の本数は 1 本です。 </p> <center> <table> <tr> <td width="240"><img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_convex3"></td> <td width="240"><img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_convex4"></td> </tr> <tr> <td>図３</td> <td>図４</td> </tr> </table> </center> <br/> <H2>Sample Input</H2> <pre> 4 1.0,0.0 0.0,1.0 2.0,1.0 1.0,2.0 9 -509.94,892.63 567.62,639.99 -859.32,-64.84 -445.99,383.69 667.54,430.49 551.12,828.21 -940.2,-877.2 -361.62,-970 -125.42,-178.48 0 </pre> <H2>Output for the Sample Input</H2> <pre> 0 3 </pre> <H2>Hint</H2> <p> 以下は２つめのサンプル入力に対する図です。 </p> <center> <table> <tr> <td><img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_convex5"></td> </tr> <tr> </tr> </table> </center>
s893226254
p00068
Wrong Answer
from math import atan2 class Point(object): def __init__(self, x, y): self.x = x self.y = y class Vector(object): def __init__(self, p1, p2): self.x = p2.x - p1.x self.y = p2.y - p1.y def cross(self, other: "Vector") -> float: return self.x*other.y - self.y*other.x def grahams_scan(a: list): a.sort(key=lambda p: p.y) bottom_x, bottom_y = a[0].x, a[0].y _a = sorted(a[1:], key=lambda p: atan2(bottom_y-p.y, bottom_x-p.x)) + [a[0]] result = [a[0], _a[0]] for next_point in _a[1:]: while Vector(result[-1], result[-2]).cross(Vector(result[-1], next_point)) >= 0: result.pop() result.append(next_point) return result while True: n = int(input()) if not n: break a = [Point(*map(float, input().split(","))) for _ in [0]*n] result = grahams_scan(a) print(n-len(result)-1)
4 1.0,0.0 0.0,1.0 2.0,1.0 1.0,2.0 9 -509.94,892.63 567.62,639.99 -859.32,-64.84 -445.99,383.69 667.54,430.49 551.12,828.21 -940.2,-877.2 -361.62,-970 -125.42,-178.48 0
0 3
<H1>輪ゴム</H1> <p> <var>n</var> 本の釘を平板上の座標 <var>P<sub>1</sub></var> (<var>x<sub>1</sub></var>, <var>y</sub>1</sub></var>), <var>P<sub>2</sub></var> (<var>x<sub>2</sub></var>, <var>y<sub>2</sub></var>), <var>P<sub>3</sub></var> (<var>x<sub>3</sub></var>, <var>y<sub>3</sub></var>),..., <var>P<sub>n</sub></var> (<var>x<sub>n</sub></var>, <var>y<sub>n</sub></var>) に１本ずつ打ち、輪ゴムの輪の中に全ての釘が入るように 1 本の輪ゴムで囲みます。このとき、輪ゴムが交差してはいけません。 </p> <p> 釘の座標を読み込んで、上記のように釘を輪ゴムで囲んだときに輪ゴムに接していない釘の本数を出力するプログラムを作成してください。輪ゴムは充分に伸び縮みするものとします。同じ座標に 2 本以上の釘を打つことはないものとします。また、輪ゴムがかかった釘と釘の間は直線で結ばれるものとし、その直線上に 3 本以上の釘が並ぶことはないものとします。例えば、図 1 に示すような入力はありえません。図 2 に示すように輪ゴムがかかっていない釘が 1 直線上に並ぶことはありえます。 </p> <center> <table> <tr> <td width="240"><img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_convex1"></td> <td width="240"><img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_convex2"></td> </tr> <tr> <td>図１</td> <td>図２</td> </tr> </table> </center> <br/> <p> ただし、それぞれの座標値は -1000.0 以上1000.0 以下の実数です。また、<var>n</var> は 3 以上 100 以下の整数です。 </p> <H2>Input</H2> <p> 複数のデータセットが与えられます。各データセットは以下のような形式です与えられます。 </p> <pre> <var>n</var> <var>x<sub>1</sub></var>, <var>y<sub>1</sub></var> <var>x<sub>2</sub></var>, <var>y<sub>2</sub></var> ... 　　　　 ... <var>x<sub>n</sub></var>, <var>y<sub>n</sub></var> </pre> <p> <var>n</var> が 0 の時、入力の最後を示します。データセットの数は 50 を超えません。 </p> <H2>Output</H2> <p> データセットごとに、ゴムと接していない釘の本数を出力してください。 例えば、図 3 に示す４つの釘を表す入力があった場合、図 4 のように囲まれるので、輪ゴムに接していない釘の本数は 1 本です。 </p> <center> <table> <tr> <td width="240"><img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_convex3"></td> <td width="240"><img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_convex4"></td> </tr> <tr> <td>図３</td> <td>図４</td> </tr> </table> </center> <br/> <H2>Sample Input</H2> <pre> 4 1.0,0.0 0.0,1.0 2.0,1.0 1.0,2.0 9 -509.94,892.63 567.62,639.99 -859.32,-64.84 -445.99,383.69 667.54,430.49 551.12,828.21 -940.2,-877.2 -361.62,-970 -125.42,-178.48 0 </pre> <H2>Output for the Sample Input</H2> <pre> 0 3 </pre> <H2>Hint</H2> <p> 以下は２つめのサンプル入力に対する図です。 </p> <center> <table> <tr> <td><img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_convex5"></td> </tr> <tr> </tr> </table> </center>
s649532760
p00068
Wrong Answer
eps = 1e-10 def add(a, b): return 0 if abs(a + b) < eps * (abs(a) + abs(b)) else a + b class Point: def __init__(self, x, y): self.x = x self.y = y def __add__(self, p): return Point(add(self.x, p.x), add(self.y, p.y)) def __sub__(self, p): return Point(add(self.x, -p.x), add(self.y, -p.y)) def __mul__(self, d): return Point(self.x * d, self.y * d) def dot(self, p): return add(self.x * p.x, self.y * p.y) def det(self, p): return add(self.x * p.y, -self.y * p.x) def __str__(self): return "({}, {})".format(self.x, self.y) def convex_hull(ps): ps = [Point(x, y) for x, y in sorted([(p.x, p.y) for p in ps])] upper_hull = get_bounds(ps) ps.reverse() lower_hull = get_bounds(ps) del upper_hull[-1] del lower_hull[-1] upper_hull.extend(lower_hull) return upper_hull def get_bounds(ps): qs = [] for p in ps: while len(qs) > 2 and (qs[-1] - qs[-2]).det(p - qs[-1]) <= 0: del qs[-1] qs.append(p) return qs while True: n = int(input()) if n == 0: break points = [] for i in range(n): x, y = map(float, input().split(',')) points.append(Point(x, y)) print(len(points) - len(convex_hull(points)))
4 1.0,0.0 0.0,1.0 2.0,1.0 1.0,2.0 9 -509.94,892.63 567.62,639.99 -859.32,-64.84 -445.99,383.69 667.54,430.49 551.12,828.21 -940.2,-877.2 -361.62,-970 -125.42,-178.48 0
0 3
<H1>輪ゴム</H1> <p> <var>n</var> 本の釘を平板上の座標 <var>P<sub>1</sub></var> (<var>x<sub>1</sub></var>, <var>y</sub>1</sub></var>), <var>P<sub>2</sub></var> (<var>x<sub>2</sub></var>, <var>y<sub>2</sub></var>), <var>P<sub>3</sub></var> (<var>x<sub>3</sub></var>, <var>y<sub>3</sub></var>),..., <var>P<sub>n</sub></var> (<var>x<sub>n</sub></var>, <var>y<sub>n</sub></var>) に１本ずつ打ち、輪ゴムの輪の中に全ての釘が入るように 1 本の輪ゴムで囲みます。このとき、輪ゴムが交差してはいけません。 </p> <p> 釘の座標を読み込んで、上記のように釘を輪ゴムで囲んだときに輪ゴムに接していない釘の本数を出力するプログラムを作成してください。輪ゴムは充分に伸び縮みするものとします。同じ座標に 2 本以上の釘を打つことはないものとします。また、輪ゴムがかかった釘と釘の間は直線で結ばれるものとし、その直線上に 3 本以上の釘が並ぶことはないものとします。例えば、図 1 に示すような入力はありえません。図 2 に示すように輪ゴムがかかっていない釘が 1 直線上に並ぶことはありえます。 </p> <center> <table> <tr> <td width="240"><img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_convex1"></td> <td width="240"><img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_convex2"></td> </tr> <tr> <td>図１</td> <td>図２</td> </tr> </table> </center> <br/> <p> ただし、それぞれの座標値は -1000.0 以上1000.0 以下の実数です。また、<var>n</var> は 3 以上 100 以下の整数です。 </p> <H2>Input</H2> <p> 複数のデータセットが与えられます。各データセットは以下のような形式です与えられます。 </p> <pre> <var>n</var> <var>x<sub>1</sub></var>, <var>y<sub>1</sub></var> <var>x<sub>2</sub></var>, <var>y<sub>2</sub></var> ... 　　　　 ... <var>x<sub>n</sub></var>, <var>y<sub>n</sub></var> </pre> <p> <var>n</var> が 0 の時、入力の最後を示します。データセットの数は 50 を超えません。 </p> <H2>Output</H2> <p> データセットごとに、ゴムと接していない釘の本数を出力してください。 例えば、図 3 に示す４つの釘を表す入力があった場合、図 4 のように囲まれるので、輪ゴムに接していない釘の本数は 1 本です。 </p> <center> <table> <tr> <td width="240"><img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_convex3"></td> <td width="240"><img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_convex4"></td> </tr> <tr> <td>図３</td> <td>図４</td> </tr> </table> </center> <br/> <H2>Sample Input</H2> <pre> 4 1.0,0.0 0.0,1.0 2.0,1.0 1.0,2.0 9 -509.94,892.63 567.62,639.99 -859.32,-64.84 -445.99,383.69 667.54,430.49 551.12,828.21 -940.2,-877.2 -361.62,-970 -125.42,-178.48 0 </pre> <H2>Output for the Sample Input</H2> <pre> 0 3 </pre> <H2>Hint</H2> <p> 以下は２つめのサンプル入力に対する図です。 </p> <center> <table> <tr> <td><img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_convex5"></td> </tr> <tr> </tr> </table> </center>
s575070566
p00068
Wrong Answer
import math def ccw(p1,p2,p3): return (p2[0]-p1[0])*(p3[1]-p1[1])-(p2[1]-p1[1])*(p3[0]-p1[0]) while True: n=input() if n==0: break p=[0]*n for i in xrange(n): p[i]=map(float,raw_input().strip().split(",")) P=min(p,key=lambda a:(a[1],a[0])) p.remove(P) p.sort(key=lambda x:math.atan2(P[1]-x[1],P[0]-x[0])) M=0 ans=0 for i in xrange(1,n-1): if not all([ccw(p[M],p[i],p[j])>=0 for j in xrange(i+1,n-1)]): ans+=1 else: M+=1 print ans
4 1.0,0.0 0.0,1.0 2.0,1.0 1.0,2.0 9 -509.94,892.63 567.62,639.99 -859.32,-64.84 -445.99,383.69 667.54,430.49 551.12,828.21 -940.2,-877.2 -361.62,-970 -125.42,-178.48 0
0 3
<H1>輪ゴム</H1> <p> <var>n</var> 本の釘を平板上の座標 <var>P<sub>1</sub></var> (<var>x<sub>1</sub></var>, <var>y</sub>1</sub></var>), <var>P<sub>2</sub></var> (<var>x<sub>2</sub></var>, <var>y<sub>2</sub></var>), <var>P<sub>3</sub></var> (<var>x<sub>3</sub></var>, <var>y<sub>3</sub></var>),..., <var>P<sub>n</sub></var> (<var>x<sub>n</sub></var>, <var>y<sub>n</sub></var>) に１本ずつ打ち、輪ゴムの輪の中に全ての釘が入るように 1 本の輪ゴムで囲みます。このとき、輪ゴムが交差してはいけません。 </p> <p> 釘の座標を読み込んで、上記のように釘を輪ゴムで囲んだときに輪ゴムに接していない釘の本数を出力するプログラムを作成してください。輪ゴムは充分に伸び縮みするものとします。同じ座標に 2 本以上の釘を打つことはないものとします。また、輪ゴムがかかった釘と釘の間は直線で結ばれるものとし、その直線上に 3 本以上の釘が並ぶことはないものとします。例えば、図 1 に示すような入力はありえません。図 2 に示すように輪ゴムがかかっていない釘が 1 直線上に並ぶことはありえます。 </p> <center> <table> <tr> <td width="240"><img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_convex1"></td> <td width="240"><img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_convex2"></td> </tr> <tr> <td>図１</td> <td>図２</td> </tr> </table> </center> <br/> <p> ただし、それぞれの座標値は -1000.0 以上1000.0 以下の実数です。また、<var>n</var> は 3 以上 100 以下の整数です。 </p> <H2>Input</H2> <p> 複数のデータセットが与えられます。各データセットは以下のような形式です与えられます。 </p> <pre> <var>n</var> <var>x<sub>1</sub></var>, <var>y<sub>1</sub></var> <var>x<sub>2</sub></var>, <var>y<sub>2</sub></var> ... 　　　　 ... <var>x<sub>n</sub></var>, <var>y<sub>n</sub></var> </pre> <p> <var>n</var> が 0 の時、入力の最後を示します。データセットの数は 50 を超えません。 </p> <H2>Output</H2> <p> データセットごとに、ゴムと接していない釘の本数を出力してください。 例えば、図 3 に示す４つの釘を表す入力があった場合、図 4 のように囲まれるので、輪ゴムに接していない釘の本数は 1 本です。 </p> <center> <table> <tr> <td width="240"><img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_convex3"></td> <td width="240"><img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_convex4"></td> </tr> <tr> <td>図３</td> <td>図４</td> </tr> </table> </center> <br/> <H2>Sample Input</H2> <pre> 4 1.0,0.0 0.0,1.0 2.0,1.0 1.0,2.0 9 -509.94,892.63 567.62,639.99 -859.32,-64.84 -445.99,383.69 667.54,430.49 551.12,828.21 -940.2,-877.2 -361.62,-970 -125.42,-178.48 0 </pre> <H2>Output for the Sample Input</H2> <pre> 0 3 </pre> <H2>Hint</H2> <p> 以下は２つめのサンプル入力に対する図です。 </p> <center> <table> <tr> <td><img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_convex5"></td> </tr> <tr> </tr> </table> </center>
s144407983
p00068
Wrong Answer
import math def ccw(p1,p2,p3): # print (p2[0]-p1[0])*(p3[1]-p1[1])-(p2[1]-p1[1])*(p3[0]-p1[0]) return (p2[0]-p1[0])*(p3[1]-p1[1])-(p2[1]-p1[1])*(p3[0]-p1[0]) while True: n=input() if n==0: break p=[0]*n for i in xrange(n): p[i]=map(float,raw_input().strip().split(",")) P=min(p,key=lambda a:(a[1],a[0])) p.remove(P) p.sort(key=lambda x:math.atan2(x[1]-P[1],x[0]-P[0])) """ print P,p for x in p: print x[0],x[1],math.atan2(x[1]-P[1],x[0]-P[0]) """ M=0 ans=0 for i in xrange(1,n-1): if not all([ccw(p[M],p[i],p[j])>=0 for j in xrange(i+1,n-1)]): ans+=1 else: M+=1 print ans
4 1.0,0.0 0.0,1.0 2.0,1.0 1.0,2.0 9 -509.94,892.63 567.62,639.99 -859.32,-64.84 -445.99,383.69 667.54,430.49 551.12,828.21 -940.2,-877.2 -361.62,-970 -125.42,-178.48 0
0 3
<H1>輪ゴム</H1> <p> <var>n</var> 本の釘を平板上の座標 <var>P<sub>1</sub></var> (<var>x<sub>1</sub></var>, <var>y</sub>1</sub></var>), <var>P<sub>2</sub></var> (<var>x<sub>2</sub></var>, <var>y<sub>2</sub></var>), <var>P<sub>3</sub></var> (<var>x<sub>3</sub></var>, <var>y<sub>3</sub></var>),..., <var>P<sub>n</sub></var> (<var>x<sub>n</sub></var>, <var>y<sub>n</sub></var>) に１本ずつ打ち、輪ゴムの輪の中に全ての釘が入るように 1 本の輪ゴムで囲みます。このとき、輪ゴムが交差してはいけません。 </p> <p> 釘の座標を読み込んで、上記のように釘を輪ゴムで囲んだときに輪ゴムに接していない釘の本数を出力するプログラムを作成してください。輪ゴムは充分に伸び縮みするものとします。同じ座標に 2 本以上の釘を打つことはないものとします。また、輪ゴムがかかった釘と釘の間は直線で結ばれるものとし、その直線上に 3 本以上の釘が並ぶことはないものとします。例えば、図 1 に示すような入力はありえません。図 2 に示すように輪ゴムがかかっていない釘が 1 直線上に並ぶことはありえます。 </p> <center> <table> <tr> <td width="240"><img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_convex1"></td> <td width="240"><img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_convex2"></td> </tr> <tr> <td>図１</td> <td>図２</td> </tr> </table> </center> <br/> <p> ただし、それぞれの座標値は -1000.0 以上1000.0 以下の実数です。また、<var>n</var> は 3 以上 100 以下の整数です。 </p> <H2>Input</H2> <p> 複数のデータセットが与えられます。各データセットは以下のような形式です与えられます。 </p> <pre> <var>n</var> <var>x<sub>1</sub></var>, <var>y<sub>1</sub></var> <var>x<sub>2</sub></var>, <var>y<sub>2</sub></var> ... 　　　　 ... <var>x<sub>n</sub></var>, <var>y<sub>n</sub></var> </pre> <p> <var>n</var> が 0 の時、入力の最後を示します。データセットの数は 50 を超えません。 </p> <H2>Output</H2> <p> データセットごとに、ゴムと接していない釘の本数を出力してください。 例えば、図 3 に示す４つの釘を表す入力があった場合、図 4 のように囲まれるので、輪ゴムに接していない釘の本数は 1 本です。 </p> <center> <table> <tr> <td width="240"><img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_convex3"></td> <td width="240"><img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_convex4"></td> </tr> <tr> <td>図３</td> <td>図４</td> </tr> </table> </center> <br/> <H2>Sample Input</H2> <pre> 4 1.0,0.0 0.0,1.0 2.0,1.0 1.0,2.0 9 -509.94,892.63 567.62,639.99 -859.32,-64.84 -445.99,383.69 667.54,430.49 551.12,828.21 -940.2,-877.2 -361.62,-970 -125.42,-178.48 0 </pre> <H2>Output for the Sample Input</H2> <pre> 0 3 </pre> <H2>Hint</H2> <p> 以下は２つめのサンプル入力に対する図です。 </p> <center> <table> <tr> <td><img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_convex5"></td> </tr> <tr> </tr> </table> </center>
s298858987
p00068
Wrong Answer
import math def ccw(p1,p2,p3): #print (p2[0]-p1[0])*(p3[1]-p2[1])-(p2[1]-p1[1])*(p3[0]-p2[0])>=0 return (p2[0]-p1[0])*(p3[1]-p2[1])-(p2[1]-p1[1])*(p3[0]-p2[0]) while True: n=input() if n==0: print n break p=[0]*n for i in xrange(n): p[i]=map(float,raw_input().strip().split(",")) P=min(p,key=lambda a:(a[1],a[0])) p.sort(key=lambda x:math.atan2(x[1]-P[1],x[0]-P[0])) M=0 ans=0 i=1 #print M,p while M<len(p)-1: if all([ccw(p[M-1],p[M],p[i])>=0 for i in xrange(M+1,len(p))]): M+=1 else: ans+=1 p.remove(p[M]) #print M,p print ans # print len(p) # print "\n".join(map(lambda x:"{},{}".format(x[0],x[1]),p))
4 1.0,0.0 0.0,1.0 2.0,1.0 1.0,2.0 9 -509.94,892.63 567.62,639.99 -859.32,-64.84 -445.99,383.69 667.54,430.49 551.12,828.21 -940.2,-877.2 -361.62,-970 -125.42,-178.48 0
0 3
<H1>輪ゴム</H1> <p> <var>n</var> 本の釘を平板上の座標 <var>P<sub>1</sub></var> (<var>x<sub>1</sub></var>, <var>y</sub>1</sub></var>), <var>P<sub>2</sub></var> (<var>x<sub>2</sub></var>, <var>y<sub>2</sub></var>), <var>P<sub>3</sub></var> (<var>x<sub>3</sub></var>, <var>y<sub>3</sub></var>),..., <var>P<sub>n</sub></var> (<var>x<sub>n</sub></var>, <var>y<sub>n</sub></var>) に１本ずつ打ち、輪ゴムの輪の中に全ての釘が入るように 1 本の輪ゴムで囲みます。このとき、輪ゴムが交差してはいけません。 </p> <p> 釘の座標を読み込んで、上記のように釘を輪ゴムで囲んだときに輪ゴムに接していない釘の本数を出力するプログラムを作成してください。輪ゴムは充分に伸び縮みするものとします。同じ座標に 2 本以上の釘を打つことはないものとします。また、輪ゴムがかかった釘と釘の間は直線で結ばれるものとし、その直線上に 3 本以上の釘が並ぶことはないものとします。例えば、図 1 に示すような入力はありえません。図 2 に示すように輪ゴムがかかっていない釘が 1 直線上に並ぶことはありえます。 </p> <center> <table> <tr> <td width="240"><img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_convex1"></td> <td width="240"><img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_convex2"></td> </tr> <tr> <td>図１</td> <td>図２</td> </tr> </table> </center> <br/> <p> ただし、それぞれの座標値は -1000.0 以上1000.0 以下の実数です。また、<var>n</var> は 3 以上 100 以下の整数です。 </p> <H2>Input</H2> <p> 複数のデータセットが与えられます。各データセットは以下のような形式です与えられます。 </p> <pre> <var>n</var> <var>x<sub>1</sub></var>, <var>y<sub>1</sub></var> <var>x<sub>2</sub></var>, <var>y<sub>2</sub></var> ... 　　　　 ... <var>x<sub>n</sub></var>, <var>y<sub>n</sub></var> </pre> <p> <var>n</var> が 0 の時、入力の最後を示します。データセットの数は 50 を超えません。 </p> <H2>Output</H2> <p> データセットごとに、ゴムと接していない釘の本数を出力してください。 例えば、図 3 に示す４つの釘を表す入力があった場合、図 4 のように囲まれるので、輪ゴムに接していない釘の本数は 1 本です。 </p> <center> <table> <tr> <td width="240"><img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_convex3"></td> <td width="240"><img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_convex4"></td> </tr> <tr> <td>図３</td> <td>図４</td> </tr> </table> </center> <br/> <H2>Sample Input</H2> <pre> 4 1.0,0.0 0.0,1.0 2.0,1.0 1.0,2.0 9 -509.94,892.63 567.62,639.99 -859.32,-64.84 -445.99,383.69 667.54,430.49 551.12,828.21 -940.2,-877.2 -361.62,-970 -125.42,-178.48 0 </pre> <H2>Output for the Sample Input</H2> <pre> 0 3 </pre> <H2>Hint</H2> <p> 以下は２つめのサンプル入力に対する図です。 </p> <center> <table> <tr> <td><img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_convex5"></td> </tr> <tr> </tr> </table> </center>
s377987435
p00068
Wrong Answer
import sys def side(p1,p2): global D y1,x1=p1 y2,x2=p2 dy=y2-y1 dx=x2-x1 for p3 in D[::-1]: if p1==p3 or p2==p3:pass elif (x2-x1)*dy-dx*(y2-y1)<0:return 0 else:return 1 while 1: n=input() if n==0:break D=sorted([list(input()) for i in range(n)]) p=p1=D[0] D1=D[:] while True: for p2 in D1: if p1!=p2 and side(p1,p2):break p1=p2 D1.remove(p2) if p2==p:break print len(D1)
4 1.0,0.0 0.0,1.0 2.0,1.0 1.0,2.0 9 -509.94,892.63 567.62,639.99 -859.32,-64.84 -445.99,383.69 667.54,430.49 551.12,828.21 -940.2,-877.2 -361.62,-970 -125.42,-178.48 0
0 3
<H1>輪ゴム</H1> <p> <var>n</var> 本の釘を平板上の座標 <var>P<sub>1</sub></var> (<var>x<sub>1</sub></var>, <var>y</sub>1</sub></var>), <var>P<sub>2</sub></var> (<var>x<sub>2</sub></var>, <var>y<sub>2</sub></var>), <var>P<sub>3</sub></var> (<var>x<sub>3</sub></var>, <var>y<sub>3</sub></var>),..., <var>P<sub>n</sub></var> (<var>x<sub>n</sub></var>, <var>y<sub>n</sub></var>) に１本ずつ打ち、輪ゴムの輪の中に全ての釘が入るように 1 本の輪ゴムで囲みます。このとき、輪ゴムが交差してはいけません。 </p> <p> 釘の座標を読み込んで、上記のように釘を輪ゴムで囲んだときに輪ゴムに接していない釘の本数を出力するプログラムを作成してください。輪ゴムは充分に伸び縮みするものとします。同じ座標に 2 本以上の釘を打つことはないものとします。また、輪ゴムがかかった釘と釘の間は直線で結ばれるものとし、その直線上に 3 本以上の釘が並ぶことはないものとします。例えば、図 1 に示すような入力はありえません。図 2 に示すように輪ゴムがかかっていない釘が 1 直線上に並ぶことはありえます。 </p> <center> <table> <tr> <td width="240"><img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_convex1"></td> <td width="240"><img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_convex2"></td> </tr> <tr> <td>図１</td> <td>図２</td> </tr> </table> </center> <br/> <p> ただし、それぞれの座標値は -1000.0 以上1000.0 以下の実数です。また、<var>n</var> は 3 以上 100 以下の整数です。 </p> <H2>Input</H2> <p> 複数のデータセットが与えられます。各データセットは以下のような形式です与えられます。 </p> <pre> <var>n</var> <var>x<sub>1</sub></var>, <var>y<sub>1</sub></var> <var>x<sub>2</sub></var>, <var>y<sub>2</sub></var> ... 　　　　 ... <var>x<sub>n</sub></var>, <var>y<sub>n</sub></var> </pre> <p> <var>n</var> が 0 の時、入力の最後を示します。データセットの数は 50 を超えません。 </p> <H2>Output</H2> <p> データセットごとに、ゴムと接していない釘の本数を出力してください。 例えば、図 3 に示す４つの釘を表す入力があった場合、図 4 のように囲まれるので、輪ゴムに接していない釘の本数は 1 本です。 </p> <center> <table> <tr> <td width="240"><img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_convex3"></td> <td width="240"><img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_convex4"></td> </tr> <tr> <td>図３</td> <td>図４</td> </tr> </table> </center> <br/> <H2>Sample Input</H2> <pre> 4 1.0,0.0 0.0,1.0 2.0,1.0 1.0,2.0 9 -509.94,892.63 567.62,639.99 -859.32,-64.84 -445.99,383.69 667.54,430.49 551.12,828.21 -940.2,-877.2 -361.62,-970 -125.42,-178.48 0 </pre> <H2>Output for the Sample Input</H2> <pre> 0 3 </pre> <H2>Hint</H2> <p> 以下は２つめのサンプル入力に対する図です。 </p> <center> <table> <tr> <td><img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_convex5"></td> </tr> <tr> </tr> </table> </center>
s436023178
p00068
Wrong Answer
def f(x,y,x1,y1,x2,y2): if x1 <= x2: return (x2-x1)*y-(y2-y1)*x+x1*y2-x2*y1 else: return -((x2-x1)*y-(y2-y1)*x+x1*y2-x2*y1) def DC(a): if len(a) > 3: # Divide la = a[:len(a)/2] ra = a[len(a)/2:] # Conquer la,ra = DC(la),DC(ra) while len(ra) > 1 and f(ra[1][0],ra[1][1],la[-1][0],la[-1][1],ra[0][0],ra[0][1]) > 0: ra.pop(0) while len(la) > 1 and f(la[-2][0],la[-2][1],ra[0][0],ra[0][1],la[-1][0],la[-1][1]) > 0: la.pop(-1) return la+ra else: return a while True: n = int(raw_input()) if n == 0: break p = [] for i in range(n): p.append(map(float, raw_input().split(","))) p = sorted(p, key = lambda x: x[0]) print n - len(DC(p))
4 1.0,0.0 0.0,1.0 2.0,1.0 1.0,2.0 9 -509.94,892.63 567.62,639.99 -859.32,-64.84 -445.99,383.69 667.54,430.49 551.12,828.21 -940.2,-877.2 -361.62,-970 -125.42,-178.48 0
0 3
<H1>輪ゴム</H1> <p> <var>n</var> 本の釘を平板上の座標 <var>P<sub>1</sub></var> (<var>x<sub>1</sub></var>, <var>y</sub>1</sub></var>), <var>P<sub>2</sub></var> (<var>x<sub>2</sub></var>, <var>y<sub>2</sub></var>), <var>P<sub>3</sub></var> (<var>x<sub>3</sub></var>, <var>y<sub>3</sub></var>),..., <var>P<sub>n</sub></var> (<var>x<sub>n</sub></var>, <var>y<sub>n</sub></var>) に１本ずつ打ち、輪ゴムの輪の中に全ての釘が入るように 1 本の輪ゴムで囲みます。このとき、輪ゴムが交差してはいけません。 </p> <p> 釘の座標を読み込んで、上記のように釘を輪ゴムで囲んだときに輪ゴムに接していない釘の本数を出力するプログラムを作成してください。輪ゴムは充分に伸び縮みするものとします。同じ座標に 2 本以上の釘を打つことはないものとします。また、輪ゴムがかかった釘と釘の間は直線で結ばれるものとし、その直線上に 3 本以上の釘が並ぶことはないものとします。例えば、図 1 に示すような入力はありえません。図 2 に示すように輪ゴムがかかっていない釘が 1 直線上に並ぶことはありえます。 </p> <center> <table> <tr> <td width="240"><img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_convex1"></td> <td width="240"><img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_convex2"></td> </tr> <tr> <td>図１</td> <td>図２</td> </tr> </table> </center> <br/> <p> ただし、それぞれの座標値は -1000.0 以上1000.0 以下の実数です。また、<var>n</var> は 3 以上 100 以下の整数です。 </p> <H2>Input</H2> <p> 複数のデータセットが与えられます。各データセットは以下のような形式です与えられます。 </p> <pre> <var>n</var> <var>x<sub>1</sub></var>, <var>y<sub>1</sub></var> <var>x<sub>2</sub></var>, <var>y<sub>2</sub></var> ... 　　　　 ... <var>x<sub>n</sub></var>, <var>y<sub>n</sub></var> </pre> <p> <var>n</var> が 0 の時、入力の最後を示します。データセットの数は 50 を超えません。 </p> <H2>Output</H2> <p> データセットごとに、ゴムと接していない釘の本数を出力してください。 例えば、図 3 に示す４つの釘を表す入力があった場合、図 4 のように囲まれるので、輪ゴムに接していない釘の本数は 1 本です。 </p> <center> <table> <tr> <td width="240"><img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_convex3"></td> <td width="240"><img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_convex4"></td> </tr> <tr> <td>図３</td> <td>図４</td> </tr> </table> </center> <br/> <H2>Sample Input</H2> <pre> 4 1.0,0.0 0.0,1.0 2.0,1.0 1.0,2.0 9 -509.94,892.63 567.62,639.99 -859.32,-64.84 -445.99,383.69 667.54,430.49 551.12,828.21 -940.2,-877.2 -361.62,-970 -125.42,-178.48 0 </pre> <H2>Output for the Sample Input</H2> <pre> 0 3 </pre> <H2>Hint</H2> <p> 以下は２つめのサンプル入力に対する図です。 </p> <center> <table> <tr> <td><img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_convex5"></td> </tr> <tr> </tr> </table> </center>
s922195567
p00068
Wrong Answer
def f(x,y,x1,y1,x2,y2): if x1 <= x2: return (x2-x1)*y-(y2-y1)*x+x1*y2-x2*y1 else: return -((x2-x1)*y-(y2-y1)*x+x1*y2-x2*y1) def DC(a): if len(a) > 3: # Divide la = a[:len(a)/2] ra = a[len(a)/2:] # Conquer la,ra = DC(la),DC(ra) while len(ra) > 1 and f(ra[1][0],ra[1][1],la[-1][0],la[-1][1],ra[0][0],ra[0][1]) > 0: ra.pop(0) while len(la) > 1 and f(la[-2][0],la[-2][1],ra[0][0],ra[0][1],la[-1][0],la[-1][1]) > 0: la.pop() return la+ra else: return a while True: n = int(raw_input()) if n == 0: break p = [] for i in range(n): p.append(map(float, raw_input().split(","))) p = sorted(p, key = lambda x: x[0]) print n - len(DC(p))
4 1.0,0.0 0.0,1.0 2.0,1.0 1.0,2.0 9 -509.94,892.63 567.62,639.99 -859.32,-64.84 -445.99,383.69 667.54,430.49 551.12,828.21 -940.2,-877.2 -361.62,-970 -125.42,-178.48 0
0 3
<H1>輪ゴム</H1> <p> <var>n</var> 本の釘を平板上の座標 <var>P<sub>1</sub></var> (<var>x<sub>1</sub></var>, <var>y</sub>1</sub></var>), <var>P<sub>2</sub></var> (<var>x<sub>2</sub></var>, <var>y<sub>2</sub></var>), <var>P<sub>3</sub></var> (<var>x<sub>3</sub></var>, <var>y<sub>3</sub></var>),..., <var>P<sub>n</sub></var> (<var>x<sub>n</sub></var>, <var>y<sub>n</sub></var>) に１本ずつ打ち、輪ゴムの輪の中に全ての釘が入るように 1 本の輪ゴムで囲みます。このとき、輪ゴムが交差してはいけません。 </p> <p> 釘の座標を読み込んで、上記のように釘を輪ゴムで囲んだときに輪ゴムに接していない釘の本数を出力するプログラムを作成してください。輪ゴムは充分に伸び縮みするものとします。同じ座標に 2 本以上の釘を打つことはないものとします。また、輪ゴムがかかった釘と釘の間は直線で結ばれるものとし、その直線上に 3 本以上の釘が並ぶことはないものとします。例えば、図 1 に示すような入力はありえません。図 2 に示すように輪ゴムがかかっていない釘が 1 直線上に並ぶことはありえます。 </p> <center> <table> <tr> <td width="240"><img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_convex1"></td> <td width="240"><img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_convex2"></td> </tr> <tr> <td>図１</td> <td>図２</td> </tr> </table> </center> <br/> <p> ただし、それぞれの座標値は -1000.0 以上1000.0 以下の実数です。また、<var>n</var> は 3 以上 100 以下の整数です。 </p> <H2>Input</H2> <p> 複数のデータセットが与えられます。各データセットは以下のような形式です与えられます。 </p> <pre> <var>n</var> <var>x<sub>1</sub></var>, <var>y<sub>1</sub></var> <var>x<sub>2</sub></var>, <var>y<sub>2</sub></var> ... 　　　　 ... <var>x<sub>n</sub></var>, <var>y<sub>n</sub></var> </pre> <p> <var>n</var> が 0 の時、入力の最後を示します。データセットの数は 50 を超えません。 </p> <H2>Output</H2> <p> データセットごとに、ゴムと接していない釘の本数を出力してください。 例えば、図 3 に示す４つの釘を表す入力があった場合、図 4 のように囲まれるので、輪ゴムに接していない釘の本数は 1 本です。 </p> <center> <table> <tr> <td width="240"><img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_convex3"></td> <td width="240"><img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_convex4"></td> </tr> <tr> <td>図３</td> <td>図４</td> </tr> </table> </center> <br/> <H2>Sample Input</H2> <pre> 4 1.0,0.0 0.0,1.0 2.0,1.0 1.0,2.0 9 -509.94,892.63 567.62,639.99 -859.32,-64.84 -445.99,383.69 667.54,430.49 551.12,828.21 -940.2,-877.2 -361.62,-970 -125.42,-178.48 0 </pre> <H2>Output for the Sample Input</H2> <pre> 0 3 </pre> <H2>Hint</H2> <p> 以下は２つめのサンプル入力に対する図です。 </p> <center> <table> <tr> <td><img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_convex5"></td> </tr> <tr> </tr> </table> </center>
s438504466
p00068
Wrong Answer
def f(x,y,x1,y1,x2,y2): if x1 <= x2: return (x2-x1)*y-(y2-y1)*x+x1*y2-x2*y1 else: return -((x2-x1)*y-(y2-y1)*x+x1*y2-x2*y1) def DC(a): if len(a) > 3: # Divide la = a[:len(a)/2] ra = a[len(a)/2:] # Conquer la,ra = DC(la),DC(ra) while len(ra) > 1 and f(ra[1][0],ra[1][1],la[-1][0],la[-1][1],ra[0][0],ra[0][1]) > 0.0: ra.pop(0) while len(la) > 1 and f(la[-2][0],la[-2][1],ra[0][0],ra[0][1],la[-1][0],la[-1][1]) > 0.0: la.pop() return la+ra else: return a while True: n = int(raw_input()) if n == 0: break p = [] for i in range(n): p.append(map(float, raw_input().split(","))) p = sorted(p, key = lambda x: x[0]) print n - len(DC(p))
4 1.0,0.0 0.0,1.0 2.0,1.0 1.0,2.0 9 -509.94,892.63 567.62,639.99 -859.32,-64.84 -445.99,383.69 667.54,430.49 551.12,828.21 -940.2,-877.2 -361.62,-970 -125.42,-178.48 0
0 3
<H1>輪ゴム</H1> <p> <var>n</var> 本の釘を平板上の座標 <var>P<sub>1</sub></var> (<var>x<sub>1</sub></var>, <var>y</sub>1</sub></var>), <var>P<sub>2</sub></var> (<var>x<sub>2</sub></var>, <var>y<sub>2</sub></var>), <var>P<sub>3</sub></var> (<var>x<sub>3</sub></var>, <var>y<sub>3</sub></var>),..., <var>P<sub>n</sub></var> (<var>x<sub>n</sub></var>, <var>y<sub>n</sub></var>) に１本ずつ打ち、輪ゴムの輪の中に全ての釘が入るように 1 本の輪ゴムで囲みます。このとき、輪ゴムが交差してはいけません。 </p> <p> 釘の座標を読み込んで、上記のように釘を輪ゴムで囲んだときに輪ゴムに接していない釘の本数を出力するプログラムを作成してください。輪ゴムは充分に伸び縮みするものとします。同じ座標に 2 本以上の釘を打つことはないものとします。また、輪ゴムがかかった釘と釘の間は直線で結ばれるものとし、その直線上に 3 本以上の釘が並ぶことはないものとします。例えば、図 1 に示すような入力はありえません。図 2 に示すように輪ゴムがかかっていない釘が 1 直線上に並ぶことはありえます。 </p> <center> <table> <tr> <td width="240"><img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_convex1"></td> <td width="240"><img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_convex2"></td> </tr> <tr> <td>図１</td> <td>図２</td> </tr> </table> </center> <br/> <p> ただし、それぞれの座標値は -1000.0 以上1000.0 以下の実数です。また、<var>n</var> は 3 以上 100 以下の整数です。 </p> <H2>Input</H2> <p> 複数のデータセットが与えられます。各データセットは以下のような形式です与えられます。 </p> <pre> <var>n</var> <var>x<sub>1</sub></var>, <var>y<sub>1</sub></var> <var>x<sub>2</sub></var>, <var>y<sub>2</sub></var> ... 　　　　 ... <var>x<sub>n</sub></var>, <var>y<sub>n</sub></var> </pre> <p> <var>n</var> が 0 の時、入力の最後を示します。データセットの数は 50 を超えません。 </p> <H2>Output</H2> <p> データセットごとに、ゴムと接していない釘の本数を出力してください。 例えば、図 3 に示す４つの釘を表す入力があった場合、図 4 のように囲まれるので、輪ゴムに接していない釘の本数は 1 本です。 </p> <center> <table> <tr> <td width="240"><img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_convex3"></td> <td width="240"><img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_convex4"></td> </tr> <tr> <td>図３</td> <td>図４</td> </tr> </table> </center> <br/> <H2>Sample Input</H2> <pre> 4 1.0,0.0 0.0,1.0 2.0,1.0 1.0,2.0 9 -509.94,892.63 567.62,639.99 -859.32,-64.84 -445.99,383.69 667.54,430.49 551.12,828.21 -940.2,-877.2 -361.62,-970 -125.42,-178.48 0 </pre> <H2>Output for the Sample Input</H2> <pre> 0 3 </pre> <H2>Hint</H2> <p> 以下は２つめのサンプル入力に対する図です。 </p> <center> <table> <tr> <td><img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_convex5"></td> </tr> <tr> </tr> </table> </center>
s176656467
p00068
Time Limit Exceeded
import sys import math def deg(v1,v2): normv1 = math.sqrt(v1[0]**2+v1[1]**2) normv2 = math.sqrt(v2[0]**2+v2[1]**2) if normv1 == 0 or normv2 == 0: print "ERROR"; exit() return (v1[0]*v2[0]+v1[1]*v2[1])/(normv1*normv2) def calc_hull(d): hull = [] point_first = d[0] hull.append(point_first) v = [ 1, 0 ] oldpoint=point_first while True: minipoint = 0; minv = [ 0,0 ] maxcos = -1 for p in d: if p == oldpoint: continue o = [ p[i]-oldpoint[i] for i in xrange(2) ] cos = deg(o,v) if cos > maxcos: maxcos = cos minv = o minpoint = p if minpoint == point_first: break v = minv oldpoint = minpoint hull.append(minpoint) return hull while True: n = int(raw_input()) if n == 0: break d = [] for t in xrange(n): d.append(map(float,raw_input().split(","))) h = calc_hull(sorted(d,key=lambda x:-x[1])) print len(d) - len(calc_hull(d))
4 1.0,0.0 0.0,1.0 2.0,1.0 1.0,2.0 9 -509.94,892.63 567.62,639.99 -859.32,-64.84 -445.99,383.69 667.54,430.49 551.12,828.21 -940.2,-877.2 -361.62,-970 -125.42,-178.48 0
0 3
<H1>輪ゴム</H1> <p> <var>n</var> 本の釘を平板上の座標 <var>P<sub>1</sub></var> (<var>x<sub>1</sub></var>, <var>y</sub>1</sub></var>), <var>P<sub>2</sub></var> (<var>x<sub>2</sub></var>, <var>y<sub>2</sub></var>), <var>P<sub>3</sub></var> (<var>x<sub>3</sub></var>, <var>y<sub>3</sub></var>),..., <var>P<sub>n</sub></var> (<var>x<sub>n</sub></var>, <var>y<sub>n</sub></var>) に１本ずつ打ち、輪ゴムの輪の中に全ての釘が入るように 1 本の輪ゴムで囲みます。このとき、輪ゴムが交差してはいけません。 </p> <p> 釘の座標を読み込んで、上記のように釘を輪ゴムで囲んだときに輪ゴムに接していない釘の本数を出力するプログラムを作成してください。輪ゴムは充分に伸び縮みするものとします。同じ座標に 2 本以上の釘を打つことはないものとします。また、輪ゴムがかかった釘と釘の間は直線で結ばれるものとし、その直線上に 3 本以上の釘が並ぶことはないものとします。例えば、図 1 に示すような入力はありえません。図 2 に示すように輪ゴムがかかっていない釘が 1 直線上に並ぶことはありえます。 </p> <center> <table> <tr> <td width="240"><img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_convex1"></td> <td width="240"><img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_convex2"></td> </tr> <tr> <td>図１</td> <td>図２</td> </tr> </table> </center> <br/> <p> ただし、それぞれの座標値は -1000.0 以上1000.0 以下の実数です。また、<var>n</var> は 3 以上 100 以下の整数です。 </p> <H2>Input</H2> <p> 複数のデータセットが与えられます。各データセットは以下のような形式です与えられます。 </p> <pre> <var>n</var> <var>x<sub>1</sub></var>, <var>y<sub>1</sub></var> <var>x<sub>2</sub></var>, <var>y<sub>2</sub></var> ... 　　　　 ... <var>x<sub>n</sub></var>, <var>y<sub>n</sub></var> </pre> <p> <var>n</var> が 0 の時、入力の最後を示します。データセットの数は 50 を超えません。 </p> <H2>Output</H2> <p> データセットごとに、ゴムと接していない釘の本数を出力してください。 例えば、図 3 に示す４つの釘を表す入力があった場合、図 4 のように囲まれるので、輪ゴムに接していない釘の本数は 1 本です。 </p> <center> <table> <tr> <td width="240"><img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_convex3"></td> <td width="240"><img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_convex4"></td> </tr> <tr> <td>図３</td> <td>図４</td> </tr> </table> </center> <br/> <H2>Sample Input</H2> <pre> 4 1.0,0.0 0.0,1.0 2.0,1.0 1.0,2.0 9 -509.94,892.63 567.62,639.99 -859.32,-64.84 -445.99,383.69 667.54,430.49 551.12,828.21 -940.2,-877.2 -361.62,-970 -125.42,-178.48 0 </pre> <H2>Output for the Sample Input</H2> <pre> 0 3 </pre> <H2>Hint</H2> <p> 以下は２つめのサンプル入力に対する図です。 </p> <center> <table> <tr> <td><img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_convex5"></td> </tr> <tr> </tr> </table> </center>
s159007322
p00068
Accepted
from math import atan2 class Point(object): def __init__(self, x, y): self.x = x self.y = y class Vector(object): def __init__(self, p1, p2): self.x = p2.x - p1.x self.y = p2.y - p1.y def cross(self, other: "Vector") -> float: return self.x*other.y - self.y*other.x def grahams_scan(a: list): a.sort(key=lambda p: p.y) bottom_x, bottom_y = a[0].x, a[0].y _a = sorted(a[1:], key=lambda p: atan2(bottom_y-p.y, bottom_x-p.x)) + [a[0]] result = [a[0], _a[0]] for next_point in _a[1:]: while Vector(result[-1], result[-2]).cross(Vector(result[-1], next_point)) >= 0: result.pop() result.append(next_point) return result while True: n = int(input()) if not n: break a = [Point(*map(float, input().split(","))) for _ in [0]*n] result = grahams_scan(a) print(n-len(result)+1)
4 1.0,0.0 0.0,1.0 2.0,1.0 1.0,2.0 9 -509.94,892.63 567.62,639.99 -859.32,-64.84 -445.99,383.69 667.54,430.49 551.12,828.21 -940.2,-877.2 -361.62,-970 -125.42,-178.48 0
0 3
<H1>輪ゴム</H1> <p> <var>n</var> 本の釘を平板上の座標 <var>P<sub>1</sub></var> (<var>x<sub>1</sub></var>, <var>y</sub>1</sub></var>), <var>P<sub>2</sub></var> (<var>x<sub>2</sub></var>, <var>y<sub>2</sub></var>), <var>P<sub>3</sub></var> (<var>x<sub>3</sub></var>, <var>y<sub>3</sub></var>),..., <var>P<sub>n</sub></var> (<var>x<sub>n</sub></var>, <var>y<sub>n</sub></var>) に１本ずつ打ち、輪ゴムの輪の中に全ての釘が入るように 1 本の輪ゴムで囲みます。このとき、輪ゴムが交差してはいけません。 </p> <p> 釘の座標を読み込んで、上記のように釘を輪ゴムで囲んだときに輪ゴムに接していない釘の本数を出力するプログラムを作成してください。輪ゴムは充分に伸び縮みするものとします。同じ座標に 2 本以上の釘を打つことはないものとします。また、輪ゴムがかかった釘と釘の間は直線で結ばれるものとし、その直線上に 3 本以上の釘が並ぶことはないものとします。例えば、図 1 に示すような入力はありえません。図 2 に示すように輪ゴムがかかっていない釘が 1 直線上に並ぶことはありえます。 </p> <center> <table> <tr> <td width="240"><img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_convex1"></td> <td width="240"><img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_convex2"></td> </tr> <tr> <td>図１</td> <td>図２</td> </tr> </table> </center> <br/> <p> ただし、それぞれの座標値は -1000.0 以上1000.0 以下の実数です。また、<var>n</var> は 3 以上 100 以下の整数です。 </p> <H2>Input</H2> <p> 複数のデータセットが与えられます。各データセットは以下のような形式です与えられます。 </p> <pre> <var>n</var> <var>x<sub>1</sub></var>, <var>y<sub>1</sub></var> <var>x<sub>2</sub></var>, <var>y<sub>2</sub></var> ... 　　　　 ... <var>x<sub>n</sub></var>, <var>y<sub>n</sub></var> </pre> <p> <var>n</var> が 0 の時、入力の最後を示します。データセットの数は 50 を超えません。 </p> <H2>Output</H2> <p> データセットごとに、ゴムと接していない釘の本数を出力してください。 例えば、図 3 に示す４つの釘を表す入力があった場合、図 4 のように囲まれるので、輪ゴムに接していない釘の本数は 1 本です。 </p> <center> <table> <tr> <td width="240"><img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_convex3"></td> <td width="240"><img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_convex4"></td> </tr> <tr> <td>図３</td> <td>図４</td> </tr> </table> </center> <br/> <H2>Sample Input</H2> <pre> 4 1.0,0.0 0.0,1.0 2.0,1.0 1.0,2.0 9 -509.94,892.63 567.62,639.99 -859.32,-64.84 -445.99,383.69 667.54,430.49 551.12,828.21 -940.2,-877.2 -361.62,-970 -125.42,-178.48 0 </pre> <H2>Output for the Sample Input</H2> <pre> 0 3 </pre> <H2>Hint</H2> <p> 以下は２つめのサンプル入力に対する図です。 </p> <center> <table> <tr> <td><img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_convex5"></td> </tr> <tr> </tr> </table> </center>
s961436583
p00068
Accepted
import sys import math def deg(v1,v2): normv1 = math.sqrt(v1[0]**2+v1[1]**2) normv2 = math.sqrt(v2[0]**2+v2[1]**2) if normv1 == 0 or normv2 == 0: print "ERROR"; exit() return (v1[0]*v2[0]+v1[1]*v2[1])/(normv1*normv2) def calc_hull_right(d): hull_right = [d[0]] first = d[0] p = d[0] while True: maxcos = -1.0 for i in xrange(1,len(d)): if d[i][1] < p[1] or d[i] == p: continue c = deg([d[i][0]-p[0],d[i][1]-p[1]],[1,0]) if c >= maxcos: maxcos = c q = d[i] p = q hull_right.append(q) if q == d[-1]: break return hull_right def calc_hull_left(d): hull_left = [d[0]] first = d[0] p = d[0] while True: maxcos = 1.0 for i in xrange(1,len(d)): if d[i][1] < p[1] or d[i] == p: continue c = deg([d[i][0]-p[0],d[i][1]-p[1]],[1,0]) if c <= maxcos: maxcos = c q = d[i] p = q hull_left.append(q) if q == d[-1]: break return hull_left while True: n = int(raw_input()) if n == 0: break d = [] for t in xrange(n): d.append(map(float,raw_input().split(","))) d.sort(key = lambda x:x[1]) #print calc_hull_left(d) + calc_hull_right(d) print - len( calc_hull_left(d) + calc_hull_right(d) ) + 2 + len(d)
4 1.0,0.0 0.0,1.0 2.0,1.0 1.0,2.0 9 -509.94,892.63 567.62,639.99 -859.32,-64.84 -445.99,383.69 667.54,430.49 551.12,828.21 -940.2,-877.2 -361.62,-970 -125.42,-178.48 0
0 3
<H1>輪ゴム</H1> <p> <var>n</var> 本の釘を平板上の座標 <var>P<sub>1</sub></var> (<var>x<sub>1</sub></var>, <var>y</sub>1</sub></var>), <var>P<sub>2</sub></var> (<var>x<sub>2</sub></var>, <var>y<sub>2</sub></var>), <var>P<sub>3</sub></var> (<var>x<sub>3</sub></var>, <var>y<sub>3</sub></var>),..., <var>P<sub>n</sub></var> (<var>x<sub>n</sub></var>, <var>y<sub>n</sub></var>) に１本ずつ打ち、輪ゴムの輪の中に全ての釘が入るように 1 本の輪ゴムで囲みます。このとき、輪ゴムが交差してはいけません。 </p> <p> 釘の座標を読み込んで、上記のように釘を輪ゴムで囲んだときに輪ゴムに接していない釘の本数を出力するプログラムを作成してください。輪ゴムは充分に伸び縮みするものとします。同じ座標に 2 本以上の釘を打つことはないものとします。また、輪ゴムがかかった釘と釘の間は直線で結ばれるものとし、その直線上に 3 本以上の釘が並ぶことはないものとします。例えば、図 1 に示すような入力はありえません。図 2 に示すように輪ゴムがかかっていない釘が 1 直線上に並ぶことはありえます。 </p> <center> <table> <tr> <td width="240"><img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_convex1"></td> <td width="240"><img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_convex2"></td> </tr> <tr> <td>図１</td> <td>図２</td> </tr> </table> </center> <br/> <p> ただし、それぞれの座標値は -1000.0 以上1000.0 以下の実数です。また、<var>n</var> は 3 以上 100 以下の整数です。 </p> <H2>Input</H2> <p> 複数のデータセットが与えられます。各データセットは以下のような形式です与えられます。 </p> <pre> <var>n</var> <var>x<sub>1</sub></var>, <var>y<sub>1</sub></var> <var>x<sub>2</sub></var>, <var>y<sub>2</sub></var> ... 　　　　 ... <var>x<sub>n</sub></var>, <var>y<sub>n</sub></var> </pre> <p> <var>n</var> が 0 の時、入力の最後を示します。データセットの数は 50 を超えません。 </p> <H2>Output</H2> <p> データセットごとに、ゴムと接していない釘の本数を出力してください。 例えば、図 3 に示す４つの釘を表す入力があった場合、図 4 のように囲まれるので、輪ゴムに接していない釘の本数は 1 本です。 </p> <center> <table> <tr> <td width="240"><img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_convex3"></td> <td width="240"><img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_convex4"></td> </tr> <tr> <td>図３</td> <td>図４</td> </tr> </table> </center> <br/> <H2>Sample Input</H2> <pre> 4 1.0,0.0 0.0,1.0 2.0,1.0 1.0,2.0 9 -509.94,892.63 567.62,639.99 -859.32,-64.84 -445.99,383.69 667.54,430.49 551.12,828.21 -940.2,-877.2 -361.62,-970 -125.42,-178.48 0 </pre> <H2>Output for the Sample Input</H2> <pre> 0 3 </pre> <H2>Hint</H2> <p> 以下は２つめのサンプル入力に対する図です。 </p> <center> <table> <tr> <td><img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_convex5"></td> </tr> <tr> </tr> </table> </center>
s138048836
p00068
Accepted
import sys def calc_hull(d,direction): maxcos0 = {"r":-1.0,"l":1.0} hull = [d[0]] p = d[0] while True: maxcos = maxcos0[direction] for i in xrange(1,len(d)): if d[i][1] < p[1] or d[i] == p: continue v = [ d[i][0]-p[0] , d[i][1]-p[1] ] c = v[0]/(v[0]**2+v[1]**2)**0.5 if c >= maxcos and direction == "r": maxcos = c q = d[i] if c <= maxcos and direction == "l": maxcos = c q = d[i] p = q hull.append(q) if q == d[-1]: break return hull while True: n = int(raw_input()) if n == 0: break d = [] for t in xrange(n): d.append(map(float,raw_input().split(","))) d.sort(key = lambda x:x[1]) print len(d) - ( len( calc_hull(d,"r") + calc_hull(d,"l") ) - 2)
4 1.0,0.0 0.0,1.0 2.0,1.0 1.0,2.0 9 -509.94,892.63 567.62,639.99 -859.32,-64.84 -445.99,383.69 667.54,430.49 551.12,828.21 -940.2,-877.2 -361.62,-970 -125.42,-178.48 0
0 3
<H1>輪ゴム</H1> <p> <var>n</var> 本の釘を平板上の座標 <var>P<sub>1</sub></var> (<var>x<sub>1</sub></var>, <var>y</sub>1</sub></var>), <var>P<sub>2</sub></var> (<var>x<sub>2</sub></var>, <var>y<sub>2</sub></var>), <var>P<sub>3</sub></var> (<var>x<sub>3</sub></var>, <var>y<sub>3</sub></var>),..., <var>P<sub>n</sub></var> (<var>x<sub>n</sub></var>, <var>y<sub>n</sub></var>) に１本ずつ打ち、輪ゴムの輪の中に全ての釘が入るように 1 本の輪ゴムで囲みます。このとき、輪ゴムが交差してはいけません。 </p> <p> 釘の座標を読み込んで、上記のように釘を輪ゴムで囲んだときに輪ゴムに接していない釘の本数を出力するプログラムを作成してください。輪ゴムは充分に伸び縮みするものとします。同じ座標に 2 本以上の釘を打つことはないものとします。また、輪ゴムがかかった釘と釘の間は直線で結ばれるものとし、その直線上に 3 本以上の釘が並ぶことはないものとします。例えば、図 1 に示すような入力はありえません。図 2 に示すように輪ゴムがかかっていない釘が 1 直線上に並ぶことはありえます。 </p> <center> <table> <tr> <td width="240"><img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_convex1"></td> <td width="240"><img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_convex2"></td> </tr> <tr> <td>図１</td> <td>図２</td> </tr> </table> </center> <br/> <p> ただし、それぞれの座標値は -1000.0 以上1000.0 以下の実数です。また、<var>n</var> は 3 以上 100 以下の整数です。 </p> <H2>Input</H2> <p> 複数のデータセットが与えられます。各データセットは以下のような形式です与えられます。 </p> <pre> <var>n</var> <var>x<sub>1</sub></var>, <var>y<sub>1</sub></var> <var>x<sub>2</sub></var>, <var>y<sub>2</sub></var> ... 　　　　 ... <var>x<sub>n</sub></var>, <var>y<sub>n</sub></var> </pre> <p> <var>n</var> が 0 の時、入力の最後を示します。データセットの数は 50 を超えません。 </p> <H2>Output</H2> <p> データセットごとに、ゴムと接していない釘の本数を出力してください。 例えば、図 3 に示す４つの釘を表す入力があった場合、図 4 のように囲まれるので、輪ゴムに接していない釘の本数は 1 本です。 </p> <center> <table> <tr> <td width="240"><img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_convex3"></td> <td width="240"><img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_convex4"></td> </tr> <tr> <td>図３</td> <td>図４</td> </tr> </table> </center> <br/> <H2>Sample Input</H2> <pre> 4 1.0,0.0 0.0,1.0 2.0,1.0 1.0,2.0 9 -509.94,892.63 567.62,639.99 -859.32,-64.84 -445.99,383.69 667.54,430.49 551.12,828.21 -940.2,-877.2 -361.62,-970 -125.42,-178.48 0 </pre> <H2>Output for the Sample Input</H2> <pre> 0 3 </pre> <H2>Hint</H2> <p> 以下は２つめのサンプル入力に対する図です。 </p> <center> <table> <tr> <td><img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_convex5"></td> </tr> <tr> </tr> </table> </center>
s782460910
p00068
Accepted
def area(x1,y1,x2,y2,x3,y3): return ((x2-x1)*(y3-y1)-(x3-x1)*(y2-y1))/2.0 def totu(S,d): if len(S)<=3: if len(S)==3: if d=="r": if area(S[0][0],S[0][1],S[1][0],S[1][1],S[2][0],S[2][1])>0: S[1],S[2]=S[2],S[1] else: if area(S[0][0],S[0][1],S[1][0],S[1][1],S[2][0],S[2][1])>0: S=[S[2],S[0],S[1]] else: S=[S[2],S[1],S[0]] if len(S)==2: if d=="l": S[0],S[1]=S[1],S[0] return S else: S1=totu(S[:len(S)/2],"l") S2=totu(S[len(S)/2:],"r") ue_old_ri=0 ue_old_li=0 ue_new_ri=0 ue_new_li=0 while True: for i in [i for i in range(len(S2)) if i>=ue_old_ri]: if area(S1[ue_old_li][0],S1[ue_old_li][1],S2[i][0],S2[i][1],S2[(i+1)%len(S2)][0], S2[(i+1)%len(S2)][1])<=0: ue_new_ri=i break for j in [j for j in range(len(S1)) if j>=ue_old_li]: if area(S2[ue_new_ri][0],S2[ue_new_ri][1],S1[j][0],S1[j][1],S1[(j+1)%len(S1)][0], S1[(j+1)%len(S1)][1])>=0: ue_new_li=j break if ue_old_ri==ue_new_ri and ue_old_li==ue_new_li: break ue_old_ri,ue_old_li=ue_new_ri,ue_new_li si_old_ri=0 si_old_li=0 si_new_ri=0 si_new_li=0 while True: for i in [-i for i in range(len(S2)) if (-1)*i<=si_old_ri]: if area(S1[si_old_li%len(S1)][0],S1[si_old_li%len(S1)][1],S2[i%len(S2)][0],S2[i%len(S2)][1],S2[(i-1)%len(S2)][0], S2[(i-1)%len(S2)][1])>=0: si_new_ri=i break for j in [-j for j in range(len(S1)) if (-1)*j<=si_old_li]: if area(S2[si_new_ri%len(S2)][0],S2[si_new_ri%len(S2)][1],S1[j%len(S1)][0],S1[j%len(S1)][1],S1[(j-1)%len(S1)][0], S1[(j-1)%len(S1)][1])<=0: si_new_li=j break if si_old_ri==si_new_ri and si_old_li==si_new_li: break si_old_ri,si_old_li=si_new_ri,si_new_li if d=="r": Sx=[] i=0 while True: Sx.append(S2[(i+ue_old_ri)%len(S2)]) if (i+ue_old_ri)%len(S2)==si_old_ri%len(S2): break i+=1 Sy=[] j=0 while True: Sy.append(S1[(si_old_li-j)%len(S1)]) if (si_old_li-j)%len(S1)==ue_old_li%len(S1): break j+=1 S=Sx+Sy m=S.index(min(S)) S_d=[] for i in range(len(S)): S_d.append(S[(m+i)%len(S)]) return S_d else: Sx=[] i=0 while True: Sx.append(S1[(i+ue_old_li)%len(S1)]) if (i+ue_old_li)%len(S1)==si_old_li%len(S1): break i+=1 Sy=[] j=0 while True: Sy.append(S2[(si_old_ri-j)%len(S2)]) if (si_old_ri-j)%len(S2)==ue_old_ri%len(S2): break j+=1 S=Sx+Sy m=S.index(max(S)) S_d=[] for i in range(len(S)): S_d.append(S[(m+i)%len(S)]) return S_d while True: L=[] n=input() prin=n if n==0: break while n!=0: L.append(map(float,raw_input().split(","))) n-=1 L.sort() L=totu(L,"l") print prin-len(L)
4 1.0,0.0 0.0,1.0 2.0,1.0 1.0,2.0 9 -509.94,892.63 567.62,639.99 -859.32,-64.84 -445.99,383.69 667.54,430.49 551.12,828.21 -940.2,-877.2 -361.62,-970 -125.42,-178.48 0
0 3
<H1>輪ゴム</H1> <p> <var>n</var> 本の釘を平板上の座標 <var>P<sub>1</sub></var> (<var>x<sub>1</sub></var>, <var>y</sub>1</sub></var>), <var>P<sub>2</sub></var> (<var>x<sub>2</sub></var>, <var>y<sub>2</sub></var>), <var>P<sub>3</sub></var> (<var>x<sub>3</sub></var>, <var>y<sub>3</sub></var>),..., <var>P<sub>n</sub></var> (<var>x<sub>n</sub></var>, <var>y<sub>n</sub></var>) に１本ずつ打ち、輪ゴムの輪の中に全ての釘が入るように 1 本の輪ゴムで囲みます。このとき、輪ゴムが交差してはいけません。 </p> <p> 釘の座標を読み込んで、上記のように釘を輪ゴムで囲んだときに輪ゴムに接していない釘の本数を出力するプログラムを作成してください。輪ゴムは充分に伸び縮みするものとします。同じ座標に 2 本以上の釘を打つことはないものとします。また、輪ゴムがかかった釘と釘の間は直線で結ばれるものとし、その直線上に 3 本以上の釘が並ぶことはないものとします。例えば、図 1 に示すような入力はありえません。図 2 に示すように輪ゴムがかかっていない釘が 1 直線上に並ぶことはありえます。 </p> <center> <table> <tr> <td width="240"><img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_convex1"></td> <td width="240"><img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_convex2"></td> </tr> <tr> <td>図１</td> <td>図２</td> </tr> </table> </center> <br/> <p> ただし、それぞれの座標値は -1000.0 以上1000.0 以下の実数です。また、<var>n</var> は 3 以上 100 以下の整数です。 </p> <H2>Input</H2> <p> 複数のデータセットが与えられます。各データセットは以下のような形式です与えられます。 </p> <pre> <var>n</var> <var>x<sub>1</sub></var>, <var>y<sub>1</sub></var> <var>x<sub>2</sub></var>, <var>y<sub>2</sub></var> ... 　　　　 ... <var>x<sub>n</sub></var>, <var>y<sub>n</sub></var> </pre> <p> <var>n</var> が 0 の時、入力の最後を示します。データセットの数は 50 を超えません。 </p> <H2>Output</H2> <p> データセットごとに、ゴムと接していない釘の本数を出力してください。 例えば、図 3 に示す４つの釘を表す入力があった場合、図 4 のように囲まれるので、輪ゴムに接していない釘の本数は 1 本です。 </p> <center> <table> <tr> <td width="240"><img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_convex3"></td> <td width="240"><img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_convex4"></td> </tr> <tr> <td>図３</td> <td>図４</td> </tr> </table> </center> <br/> <H2>Sample Input</H2> <pre> 4 1.0,0.0 0.0,1.0 2.0,1.0 1.0,2.0 9 -509.94,892.63 567.62,639.99 -859.32,-64.84 -445.99,383.69 667.54,430.49 551.12,828.21 -940.2,-877.2 -361.62,-970 -125.42,-178.48 0 </pre> <H2>Output for the Sample Input</H2> <pre> 0 3 </pre> <H2>Hint</H2> <p> 以下は２つめのサンプル入力に対する図です。 </p> <center> <table> <tr> <td><img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_convex5"></td> </tr> <tr> </tr> </table> </center>
s550318387
p00068
Accepted
eps = 1e-10 def add(a, b): return 0 if abs(a + b) < eps * (abs(a) + abs(b)) else a + b class Point: def __init__(self, x, y): self.x = x self.y = y def __add__(self, p): return Point(add(self.x, p.x), add(self.y, p.y)) def __sub__(self, p): return Point(add(self.x, -p.x), add(self.y, -p.y)) def __mul__(self, d): return Point(self.x * d, self.y * d) def dot(self, p): return add(self.x * p.x, self.y * p.y) def det(self, p): return add(self.x * p.y, -self.y * p.x) def __str__(self): return "({}, {})".format(self.x, self.y) def convex_hull(ps): ps = [Point(x, y) for x, y in sorted([(p.x, p.y) for p in ps])] upper_hull = get_bounds(ps) ps.reverse() lower_hull = get_bounds(ps) del upper_hull[-1] del lower_hull[-1] upper_hull.extend(lower_hull) return upper_hull def get_bounds(ps): qs = [ps[0], ps[1]] for p in ps[2:]: while len(qs) > 1 and (qs[-1] - qs[-2]).det(p - qs[-1]) <= 0: del qs[-1] qs.append(p) return qs while True: n = int(input()) if n == 0: break points = [] for i in range(n): x, y = map(float, input().split(',')) points.append(Point(x, y)) print(len(points) - len(convex_hull(points)))
4 1.0,0.0 0.0,1.0 2.0,1.0 1.0,2.0 9 -509.94,892.63 567.62,639.99 -859.32,-64.84 -445.99,383.69 667.54,430.49 551.12,828.21 -940.2,-877.2 -361.62,-970 -125.42,-178.48 0
0 3
<H1>輪ゴム</H1> <p> <var>n</var> 本の釘を平板上の座標 <var>P<sub>1</sub></var> (<var>x<sub>1</sub></var>, <var>y</sub>1</sub></var>), <var>P<sub>2</sub></var> (<var>x<sub>2</sub></var>, <var>y<sub>2</sub></var>), <var>P<sub>3</sub></var> (<var>x<sub>3</sub></var>, <var>y<sub>3</sub></var>),..., <var>P<sub>n</sub></var> (<var>x<sub>n</sub></var>, <var>y<sub>n</sub></var>) に１本ずつ打ち、輪ゴムの輪の中に全ての釘が入るように 1 本の輪ゴムで囲みます。このとき、輪ゴムが交差してはいけません。 </p> <p> 釘の座標を読み込んで、上記のように釘を輪ゴムで囲んだときに輪ゴムに接していない釘の本数を出力するプログラムを作成してください。輪ゴムは充分に伸び縮みするものとします。同じ座標に 2 本以上の釘を打つことはないものとします。また、輪ゴムがかかった釘と釘の間は直線で結ばれるものとし、その直線上に 3 本以上の釘が並ぶことはないものとします。例えば、図 1 に示すような入力はありえません。図 2 に示すように輪ゴムがかかっていない釘が 1 直線上に並ぶことはありえます。 </p> <center> <table> <tr> <td width="240"><img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_convex1"></td> <td width="240"><img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_convex2"></td> </tr> <tr> <td>図１</td> <td>図２</td> </tr> </table> </center> <br/> <p> ただし、それぞれの座標値は -1000.0 以上1000.0 以下の実数です。また、<var>n</var> は 3 以上 100 以下の整数です。 </p> <H2>Input</H2> <p> 複数のデータセットが与えられます。各データセットは以下のような形式です与えられます。 </p> <pre> <var>n</var> <var>x<sub>1</sub></var>, <var>y<sub>1</sub></var> <var>x<sub>2</sub></var>, <var>y<sub>2</sub></var> ... 　　　　 ... <var>x<sub>n</sub></var>, <var>y<sub>n</sub></var> </pre> <p> <var>n</var> が 0 の時、入力の最後を示します。データセットの数は 50 を超えません。 </p> <H2>Output</H2> <p> データセットごとに、ゴムと接していない釘の本数を出力してください。 例えば、図 3 に示す４つの釘を表す入力があった場合、図 4 のように囲まれるので、輪ゴムに接していない釘の本数は 1 本です。 </p> <center> <table> <tr> <td width="240"><img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_convex3"></td> <td width="240"><img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_convex4"></td> </tr> <tr> <td>図３</td> <td>図４</td> </tr> </table> </center> <br/> <H2>Sample Input</H2> <pre> 4 1.0,0.0 0.0,1.0 2.0,1.0 1.0,2.0 9 -509.94,892.63 567.62,639.99 -859.32,-64.84 -445.99,383.69 667.54,430.49 551.12,828.21 -940.2,-877.2 -361.62,-970 -125.42,-178.48 0 </pre> <H2>Output for the Sample Input</H2> <pre> 0 3 </pre> <H2>Hint</H2> <p> 以下は２つめのサンプル入力に対する図です。 </p> <center> <table> <tr> <td><img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_convex5"></td> </tr> <tr> </tr> </table> </center>
s848002531
p00068
Accepted
eps = 1e-10 def add(a, b): return 0 if abs(a + b) < eps * (abs(a) + abs(b)) else a + b class Point: def __init__(self, x, y): self.x = x self.y = y def __add__(self, p): return Point(add(self.x, p.x), add(self.y, p.y)) def __sub__(self, p): return Point(add(self.x, -p.x), add(self.y, -p.y)) def __mul__(self, d): return Point(self.x * d, self.y * d) def dot(self, p): return add(self.x * p.x, self.y * p.y) def det(self, p): return add(self.x * p.y, -self.y * p.x) def __str__(self): return "({}, {})".format(self.x, self.y) def convex_hull(ps): ps = [Point(x, y) for x, y in sorted([(p.x, p.y) for p in ps])] lower_hull = get_bounds(ps) ps.reverse() upper_hull = get_bounds(ps) del upper_hull[-1] del lower_hull[-1] lower_hull.extend(upper_hull) return lower_hull def get_bounds(ps): qs = [ps[0], ps[1]] for p in ps[2:]: while len(qs) > 1 and (qs[-1] - qs[-2]).det(p - qs[-1]) <= 0: del qs[-1] qs.append(p) return qs while True: n = int(input()) if n == 0: break points = [] for i in range(n): x, y = map(float, input().split(',')) points.append(Point(x, y)) print(len(points) - len(convex_hull(points)))
4 1.0,0.0 0.0,1.0 2.0,1.0 1.0,2.0 9 -509.94,892.63 567.62,639.99 -859.32,-64.84 -445.99,383.69 667.54,430.49 551.12,828.21 -940.2,-877.2 -361.62,-970 -125.42,-178.48 0
0 3
<H1>輪ゴム</H1> <p> <var>n</var> 本の釘を平板上の座標 <var>P<sub>1</sub></var> (<var>x<sub>1</sub></var>, <var>y</sub>1</sub></var>), <var>P<sub>2</sub></var> (<var>x<sub>2</sub></var>, <var>y<sub>2</sub></var>), <var>P<sub>3</sub></var> (<var>x<sub>3</sub></var>, <var>y<sub>3</sub></var>),..., <var>P<sub>n</sub></var> (<var>x<sub>n</sub></var>, <var>y<sub>n</sub></var>) に１本ずつ打ち、輪ゴムの輪の中に全ての釘が入るように 1 本の輪ゴムで囲みます。このとき、輪ゴムが交差してはいけません。 </p> <p> 釘の座標を読み込んで、上記のように釘を輪ゴムで囲んだときに輪ゴムに接していない釘の本数を出力するプログラムを作成してください。輪ゴムは充分に伸び縮みするものとします。同じ座標に 2 本以上の釘を打つことはないものとします。また、輪ゴムがかかった釘と釘の間は直線で結ばれるものとし、その直線上に 3 本以上の釘が並ぶことはないものとします。例えば、図 1 に示すような入力はありえません。図 2 に示すように輪ゴムがかかっていない釘が 1 直線上に並ぶことはありえます。 </p> <center> <table> <tr> <td width="240"><img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_convex1"></td> <td width="240"><img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_convex2"></td> </tr> <tr> <td>図１</td> <td>図２</td> </tr> </table> </center> <br/> <p> ただし、それぞれの座標値は -1000.0 以上1000.0 以下の実数です。また、<var>n</var> は 3 以上 100 以下の整数です。 </p> <H2>Input</H2> <p> 複数のデータセットが与えられます。各データセットは以下のような形式です与えられます。 </p> <pre> <var>n</var> <var>x<sub>1</sub></var>, <var>y<sub>1</sub></var> <var>x<sub>2</sub></var>, <var>y<sub>2</sub></var> ... 　　　　 ... <var>x<sub>n</sub></var>, <var>y<sub>n</sub></var> </pre> <p> <var>n</var> が 0 の時、入力の最後を示します。データセットの数は 50 を超えません。 </p> <H2>Output</H2> <p> データセットごとに、ゴムと接していない釘の本数を出力してください。 例えば、図 3 に示す４つの釘を表す入力があった場合、図 4 のように囲まれるので、輪ゴムに接していない釘の本数は 1 本です。 </p> <center> <table> <tr> <td width="240"><img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_convex3"></td> <td width="240"><img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_convex4"></td> </tr> <tr> <td>図３</td> <td>図４</td> </tr> </table> </center> <br/> <H2>Sample Input</H2> <pre> 4 1.0,0.0 0.0,1.0 2.0,1.0 1.0,2.0 9 -509.94,892.63 567.62,639.99 -859.32,-64.84 -445.99,383.69 667.54,430.49 551.12,828.21 -940.2,-877.2 -361.62,-970 -125.42,-178.48 0 </pre> <H2>Output for the Sample Input</H2> <pre> 0 3 </pre> <H2>Hint</H2> <p> 以下は２つめのサンプル入力に対する図です。 </p> <center> <table> <tr> <td><img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_convex5"></td> </tr> <tr> </tr> </table> </center>
s586577318
p00068
Accepted
while 1: n = input() if n == 0: break x = [] y = [] for i in range(n): a,b = map(float,raw_input().split(',')) x.append(a) y.append(b) ys = y.index(min(y)) s = ys vx = 1.0 vy = 0.0 ans = n while 1: cx = -1.0 t = -1 for i in range(n): if i != s: tx = x[i] - x[s] ty = y[i] - y[s] d = (tx**2 + ty**2) ** 0.5 c = (vx*tx + vy*ty) / d if cx < c: cx = c t = i ans -= 1 if t == ys: break vx = x[t] - x[s] vy = y[t] - y[s] s = t print ans
4 1.0,0.0 0.0,1.0 2.0,1.0 1.0,2.0 9 -509.94,892.63 567.62,639.99 -859.32,-64.84 -445.99,383.69 667.54,430.49 551.12,828.21 -940.2,-877.2 -361.62,-970 -125.42,-178.48 0
0 3
<H1>輪ゴム</H1> <p> <var>n</var> 本の釘を平板上の座標 <var>P<sub>1</sub></var> (<var>x<sub>1</sub></var>, <var>y</sub>1</sub></var>), <var>P<sub>2</sub></var> (<var>x<sub>2</sub></var>, <var>y<sub>2</sub></var>), <var>P<sub>3</sub></var> (<var>x<sub>3</sub></var>, <var>y<sub>3</sub></var>),..., <var>P<sub>n</sub></var> (<var>x<sub>n</sub></var>, <var>y<sub>n</sub></var>) に１本ずつ打ち、輪ゴムの輪の中に全ての釘が入るように 1 本の輪ゴムで囲みます。このとき、輪ゴムが交差してはいけません。 </p> <p> 釘の座標を読み込んで、上記のように釘を輪ゴムで囲んだときに輪ゴムに接していない釘の本数を出力するプログラムを作成してください。輪ゴムは充分に伸び縮みするものとします。同じ座標に 2 本以上の釘を打つことはないものとします。また、輪ゴムがかかった釘と釘の間は直線で結ばれるものとし、その直線上に 3 本以上の釘が並ぶことはないものとします。例えば、図 1 に示すような入力はありえません。図 2 に示すように輪ゴムがかかっていない釘が 1 直線上に並ぶことはありえます。 </p> <center> <table> <tr> <td width="240"><img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_convex1"></td> <td width="240"><img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_convex2"></td> </tr> <tr> <td>図１</td> <td>図２</td> </tr> </table> </center> <br/> <p> ただし、それぞれの座標値は -1000.0 以上1000.0 以下の実数です。また、<var>n</var> は 3 以上 100 以下の整数です。 </p> <H2>Input</H2> <p> 複数のデータセットが与えられます。各データセットは以下のような形式です与えられます。 </p> <pre> <var>n</var> <var>x<sub>1</sub></var>, <var>y<sub>1</sub></var> <var>x<sub>2</sub></var>, <var>y<sub>2</sub></var> ... 　　　　 ... <var>x<sub>n</sub></var>, <var>y<sub>n</sub></var> </pre> <p> <var>n</var> が 0 の時、入力の最後を示します。データセットの数は 50 を超えません。 </p> <H2>Output</H2> <p> データセットごとに、ゴムと接していない釘の本数を出力してください。 例えば、図 3 に示す４つの釘を表す入力があった場合、図 4 のように囲まれるので、輪ゴムに接していない釘の本数は 1 本です。 </p> <center> <table> <tr> <td width="240"><img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_convex3"></td> <td width="240"><img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_convex4"></td> </tr> <tr> <td>図３</td> <td>図４</td> </tr> </table> </center> <br/> <H2>Sample Input</H2> <pre> 4 1.0,0.0 0.0,1.0 2.0,1.0 1.0,2.0 9 -509.94,892.63 567.62,639.99 -859.32,-64.84 -445.99,383.69 667.54,430.49 551.12,828.21 -940.2,-877.2 -361.62,-970 -125.42,-178.48 0 </pre> <H2>Output for the Sample Input</H2> <pre> 0 3 </pre> <H2>Hint</H2> <p> 以下は２つめのサンプル入力に対する図です。 </p> <center> <table> <tr> <td><img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_convex5"></td> </tr> <tr> </tr> </table> </center>
s099262381
p00068
Accepted
def a(v1,v2): if v1[0]!=v2[0]: return (v2[1]-v1[1])/(v2[0]-v1[0]) else: return (v2[1]-v1[1])*(10**10) def dlt(p,v,sign): while len(p)>2: if sign*(a(v[p[-3]],v[p[-2]])-a(v[p[-2]],v[p[-1]]))<0: del p[-2] else: break return p def convex(v,n): d,u=[],[] for i in range(n): d=dlt(d+[i],v,1) u=dlt(u+[i],v,-1) return n-len(set(d+u)) while 1: n=int(raw_input()) if n==0: break v=[map(float,raw_input().split(',')) for i in range(n)] v=sorted(sorted(v,key=lambda x:x[1])) print convex(v,n)
4 1.0,0.0 0.0,1.0 2.0,1.0 1.0,2.0 9 -509.94,892.63 567.62,639.99 -859.32,-64.84 -445.99,383.69 667.54,430.49 551.12,828.21 -940.2,-877.2 -361.62,-970 -125.42,-178.48 0
0 3
<H1>輪ゴム</H1> <p> <var>n</var> 本の釘を平板上の座標 <var>P<sub>1</sub></var> (<var>x<sub>1</sub></var>, <var>y</sub>1</sub></var>), <var>P<sub>2</sub></var> (<var>x<sub>2</sub></var>, <var>y<sub>2</sub></var>), <var>P<sub>3</sub></var> (<var>x<sub>3</sub></var>, <var>y<sub>3</sub></var>),..., <var>P<sub>n</sub></var> (<var>x<sub>n</sub></var>, <var>y<sub>n</sub></var>) に１本ずつ打ち、輪ゴムの輪の中に全ての釘が入るように 1 本の輪ゴムで囲みます。このとき、輪ゴムが交差してはいけません。 </p> <p> 釘の座標を読み込んで、上記のように釘を輪ゴムで囲んだときに輪ゴムに接していない釘の本数を出力するプログラムを作成してください。輪ゴムは充分に伸び縮みするものとします。同じ座標に 2 本以上の釘を打つことはないものとします。また、輪ゴムがかかった釘と釘の間は直線で結ばれるものとし、その直線上に 3 本以上の釘が並ぶことはないものとします。例えば、図 1 に示すような入力はありえません。図 2 に示すように輪ゴムがかかっていない釘が 1 直線上に並ぶことはありえます。 </p> <center> <table> <tr> <td width="240"><img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_convex1"></td> <td width="240"><img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_convex2"></td> </tr> <tr> <td>図１</td> <td>図２</td> </tr> </table> </center> <br/> <p> ただし、それぞれの座標値は -1000.0 以上1000.0 以下の実数です。また、<var>n</var> は 3 以上 100 以下の整数です。 </p> <H2>Input</H2> <p> 複数のデータセットが与えられます。各データセットは以下のような形式です与えられます。 </p> <pre> <var>n</var> <var>x<sub>1</sub></var>, <var>y<sub>1</sub></var> <var>x<sub>2</sub></var>, <var>y<sub>2</sub></var> ... 　　　　 ... <var>x<sub>n</sub></var>, <var>y<sub>n</sub></var> </pre> <p> <var>n</var> が 0 の時、入力の最後を示します。データセットの数は 50 を超えません。 </p> <H2>Output</H2> <p> データセットごとに、ゴムと接していない釘の本数を出力してください。 例えば、図 3 に示す４つの釘を表す入力があった場合、図 4 のように囲まれるので、輪ゴムに接していない釘の本数は 1 本です。 </p> <center> <table> <tr> <td width="240"><img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_convex3"></td> <td width="240"><img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_convex4"></td> </tr> <tr> <td>図３</td> <td>図４</td> </tr> </table> </center> <br/> <H2>Sample Input</H2> <pre> 4 1.0,0.0 0.0,1.0 2.0,1.0 1.0,2.0 9 -509.94,892.63 567.62,639.99 -859.32,-64.84 -445.99,383.69 667.54,430.49 551.12,828.21 -940.2,-877.2 -361.62,-970 -125.42,-178.48 0 </pre> <H2>Output for the Sample Input</H2> <pre> 0 3 </pre> <H2>Hint</H2> <p> 以下は２つめのサンプル入力に対する図です。 </p> <center> <table> <tr> <td><img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_convex5"></td> </tr> <tr> </tr> </table> </center>
s607698290
p00068
Accepted
#!/usr/bin/env python3 # ????????????????????°???????????°????????????????????\??????????????¢?????´???????????¨??????????§??????? # ?????????http://www.prefield.com/algorithm/geometry/convex_hull.html import enum EPS = 1e-10 class PointsRelation(enum.Enum): counter_clockwise = 1 clockwise = 2 online_back = 3 on_segment = 4 online_front = 5 def inner_product(v1, v2): return v1.real * v2.real + v1.imag * v2.imag def outer_product(v1, v2): return v1.real * v2.imag - v1.imag * v2.real def project(a, b): return a * inner_product(a, b) / (abs(a) ** 2) def points_relation(p0, p1, p2): v1 = p1 - p0 v2 = p2 - p0 op = outer_product(v1, v2) if op > EPS: return PointsRelation.counter_clockwise elif op < -EPS: return PointsRelation.clockwise elif inner_product(v1, v2) < -EPS: return PointsRelation.online_back elif abs(v1) < abs(v2): return PointsRelation.online_front else: return PointsRelation.on_segment def in_place_convex_hull_andrew(ps): def judge(p0, p1, p2): b = points_relation(p0, p1, p2) != PointsRelation.counter_clockwise b &= points_relation(p0, p1, p2) != PointsRelation.online_front return b if len(ps) < 3: return ps ps.sort(key=lambda p: p.imag) n = len(ps) k = 0 ch = [None for _ in range(2 * n)] for i in range(n): while k >= 2 and judge(ch[k - 2], ch[k - 1], ps[i]): k -= 1 ch[k] = ps[i] k += 1 t = k + 1 for i in range(n - 1)[::-1]: while k >= t and judge(ch[k - 2], ch[k - 1], ps[i]): k -= 1 ch[k] = ps[i] k += 1 ch = ch[:k - 1] return ch def main(): while True: n = int(input()) if n == 0: return ps = [complex(*map(float, input().split(","))) for _ in range(n)] ch = in_place_convex_hull_andrew(ps) print(n - len(ch)) if __name__ == '__main__': main()
4 1.0,0.0 0.0,1.0 2.0,1.0 1.0,2.0 9 -509.94,892.63 567.62,639.99 -859.32,-64.84 -445.99,383.69 667.54,430.49 551.12,828.21 -940.2,-877.2 -361.62,-970 -125.42,-178.48 0
0 3
<H1>輪ゴム</H1> <p> <var>n</var> 本の釘を平板上の座標 <var>P<sub>1</sub></var> (<var>x<sub>1</sub></var>, <var>y</sub>1</sub></var>), <var>P<sub>2</sub></var> (<var>x<sub>2</sub></var>, <var>y<sub>2</sub></var>), <var>P<sub>3</sub></var> (<var>x<sub>3</sub></var>, <var>y<sub>3</sub></var>),..., <var>P<sub>n</sub></var> (<var>x<sub>n</sub></var>, <var>y<sub>n</sub></var>) に１本ずつ打ち、輪ゴムの輪の中に全ての釘が入るように 1 本の輪ゴムで囲みます。このとき、輪ゴムが交差してはいけません。 </p> <p> 釘の座標を読み込んで、上記のように釘を輪ゴムで囲んだときに輪ゴムに接していない釘の本数を出力するプログラムを作成してください。輪ゴムは充分に伸び縮みするものとします。同じ座標に 2 本以上の釘を打つことはないものとします。また、輪ゴムがかかった釘と釘の間は直線で結ばれるものとし、その直線上に 3 本以上の釘が並ぶことはないものとします。例えば、図 1 に示すような入力はありえません。図 2 に示すように輪ゴムがかかっていない釘が 1 直線上に並ぶことはありえます。 </p> <center> <table> <tr> <td width="240"><img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_convex1"></td> <td width="240"><img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_convex2"></td> </tr> <tr> <td>図１</td> <td>図２</td> </tr> </table> </center> <br/> <p> ただし、それぞれの座標値は -1000.0 以上1000.0 以下の実数です。また、<var>n</var> は 3 以上 100 以下の整数です。 </p> <H2>Input</H2> <p> 複数のデータセットが与えられます。各データセットは以下のような形式です与えられます。 </p> <pre> <var>n</var> <var>x<sub>1</sub></var>, <var>y<sub>1</sub></var> <var>x<sub>2</sub></var>, <var>y<sub>2</sub></var> ... 　　　　 ... <var>x<sub>n</sub></var>, <var>y<sub>n</sub></var> </pre> <p> <var>n</var> が 0 の時、入力の最後を示します。データセットの数は 50 を超えません。 </p> <H2>Output</H2> <p> データセットごとに、ゴムと接していない釘の本数を出力してください。 例えば、図 3 に示す４つの釘を表す入力があった場合、図 4 のように囲まれるので、輪ゴムに接していない釘の本数は 1 本です。 </p> <center> <table> <tr> <td width="240"><img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_convex3"></td> <td width="240"><img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_convex4"></td> </tr> <tr> <td>図３</td> <td>図４</td> </tr> </table> </center> <br/> <H2>Sample Input</H2> <pre> 4 1.0,0.0 0.0,1.0 2.0,1.0 1.0,2.0 9 -509.94,892.63 567.62,639.99 -859.32,-64.84 -445.99,383.69 667.54,430.49 551.12,828.21 -940.2,-877.2 -361.62,-970 -125.42,-178.48 0 </pre> <H2>Output for the Sample Input</H2> <pre> 0 3 </pre> <H2>Hint</H2> <p> 以下は２つめのサンプル入力に対する図です。 </p> <center> <table> <tr> <td><img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_convex5"></td> </tr> <tr> </tr> </table> </center>
s612413033
p00068
Accepted
def op(x,y): """ Outer product """ return(complex.conjugate(x)*y).imag def isrm(q,i,x): """ is i right most to q's from view of x? """ for j in q: if op(i-x, j-x) < 0: return(False) return(True) def rightmost(p,x): """ Find a point in p which is rightmost from x(other than x) """ for i in [i for i in p if i!=x]: q = p.copy() q.remove(i) if isrm(q,i,x): return(i) raise ValueError('Do not come here') def solve(p,pf,orig): nx = rightmost(p,orig) ni = p.index(nx) if pf[ni]: # second visit return(pf) pf[ni] = True return(solve(p,pf,nx)) while True: p = [] n = int(input().strip()) if n==0: break for i in range(n): x,y = list(map(float, input().strip().split(','))) p.append(x+y*1j) print(solve(p,[False for _ in range(n)],2000.0 + 0.0*1j).count(False))
4 1.0,0.0 0.0,1.0 2.0,1.0 1.0,2.0 9 -509.94,892.63 567.62,639.99 -859.32,-64.84 -445.99,383.69 667.54,430.49 551.12,828.21 -940.2,-877.2 -361.62,-970 -125.42,-178.48 0
0 3
<H1>輪ゴム</H1> <p> <var>n</var> 本の釘を平板上の座標 <var>P<sub>1</sub></var> (<var>x<sub>1</sub></var>, <var>y</sub>1</sub></var>), <var>P<sub>2</sub></var> (<var>x<sub>2</sub></var>, <var>y<sub>2</sub></var>), <var>P<sub>3</sub></var> (<var>x<sub>3</sub></var>, <var>y<sub>3</sub></var>),..., <var>P<sub>n</sub></var> (<var>x<sub>n</sub></var>, <var>y<sub>n</sub></var>) に１本ずつ打ち、輪ゴムの輪の中に全ての釘が入るように 1 本の輪ゴムで囲みます。このとき、輪ゴムが交差してはいけません。 </p> <p> 釘の座標を読み込んで、上記のように釘を輪ゴムで囲んだときに輪ゴムに接していない釘の本数を出力するプログラムを作成してください。輪ゴムは充分に伸び縮みするものとします。同じ座標に 2 本以上の釘を打つことはないものとします。また、輪ゴムがかかった釘と釘の間は直線で結ばれるものとし、その直線上に 3 本以上の釘が並ぶことはないものとします。例えば、図 1 に示すような入力はありえません。図 2 に示すように輪ゴムがかかっていない釘が 1 直線上に並ぶことはありえます。 </p> <center> <table> <tr> <td width="240"><img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_convex1"></td> <td width="240"><img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_convex2"></td> </tr> <tr> <td>図１</td> <td>図２</td> </tr> </table> </center> <br/> <p> ただし、それぞれの座標値は -1000.0 以上1000.0 以下の実数です。また、<var>n</var> は 3 以上 100 以下の整数です。 </p> <H2>Input</H2> <p> 複数のデータセットが与えられます。各データセットは以下のような形式です与えられます。 </p> <pre> <var>n</var> <var>x<sub>1</sub></var>, <var>y<sub>1</sub></var> <var>x<sub>2</sub></var>, <var>y<sub>2</sub></var> ... 　　　　 ... <var>x<sub>n</sub></var>, <var>y<sub>n</sub></var> </pre> <p> <var>n</var> が 0 の時、入力の最後を示します。データセットの数は 50 を超えません。 </p> <H2>Output</H2> <p> データセットごとに、ゴムと接していない釘の本数を出力してください。 例えば、図 3 に示す４つの釘を表す入力があった場合、図 4 のように囲まれるので、輪ゴムに接していない釘の本数は 1 本です。 </p> <center> <table> <tr> <td width="240"><img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_convex3"></td> <td width="240"><img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_convex4"></td> </tr> <tr> <td>図３</td> <td>図４</td> </tr> </table> </center> <br/> <H2>Sample Input</H2> <pre> 4 1.0,0.0 0.0,1.0 2.0,1.0 1.0,2.0 9 -509.94,892.63 567.62,639.99 -859.32,-64.84 -445.99,383.69 667.54,430.49 551.12,828.21 -940.2,-877.2 -361.62,-970 -125.42,-178.48 0 </pre> <H2>Output for the Sample Input</H2> <pre> 0 3 </pre> <H2>Hint</H2> <p> 以下は２つめのサンプル入力に対する図です。 </p> <center> <table> <tr> <td><img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_convex5"></td> </tr> <tr> </tr> </table> </center>
s949893616
p00068
Accepted
# -*- coding: utf-8 -*- import sys import os for s in sys.stdin: N = int(s) if N == 0: break X = [] Y = [] visited = [False] * N for i in range(N): x, y = map(float, input().split(',')) X.append(x) Y.append(y) def paint(start_i, is_right, is_up): x_start = X[start_i] y_start = Y[start_i] visited[start_i] = True if is_right: dir_sign = 1 # search right only else: dir_sign = -1 # search left only if (is_up and is_right) or (not is_up and not is_right) : min_max_sign = 1 # search min else: min_max_sign = -1 # search max tangent_min_i = None tangent_min = None for i, x in enumerate(X): if dir_sign * (x - x_start) > 0: y = Y[i] tangent = (y - y_start) / (x - x_start) if tangent_min is None: tangent_min = tangent tangent_min_i = i else: if min_max_sign * (tangent_min - tangent) > 0: tangent_min = tangent tangent_min_i = i if tangent_min_i is not None: paint(tangent_min_i, is_right, is_up) start_index = Y.index(min(Y)) visited[start_index] = True paint(start_index, is_right=True, is_up=True) paint(start_index, is_right=False, is_up=True) start_index = Y.index(max(Y)) visited[start_index] = True paint(start_index, is_right=True, is_up=False) paint(start_index, is_right=False, is_up=False) visit_num = 0 for is_visit in visited: if is_visit: visit_num += 1 print(len(X) - visit_num)
4 1.0,0.0 0.0,1.0 2.0,1.0 1.0,2.0 9 -509.94,892.63 567.62,639.99 -859.32,-64.84 -445.99,383.69 667.54,430.49 551.12,828.21 -940.2,-877.2 -361.62,-970 -125.42,-178.48 0
0 3
<H1>輪ゴム</H1> <p> <var>n</var> 本の釘を平板上の座標 <var>P<sub>1</sub></var> (<var>x<sub>1</sub></var>, <var>y</sub>1</sub></var>), <var>P<sub>2</sub></var> (<var>x<sub>2</sub></var>, <var>y<sub>2</sub></var>), <var>P<sub>3</sub></var> (<var>x<sub>3</sub></var>, <var>y<sub>3</sub></var>),..., <var>P<sub>n</sub></var> (<var>x<sub>n</sub></var>, <var>y<sub>n</sub></var>) に１本ずつ打ち、輪ゴムの輪の中に全ての釘が入るように 1 本の輪ゴムで囲みます。このとき、輪ゴムが交差してはいけません。 </p> <p> 釘の座標を読み込んで、上記のように釘を輪ゴムで囲んだときに輪ゴムに接していない釘の本数を出力するプログラムを作成してください。輪ゴムは充分に伸び縮みするものとします。同じ座標に 2 本以上の釘を打つことはないものとします。また、輪ゴムがかかった釘と釘の間は直線で結ばれるものとし、その直線上に 3 本以上の釘が並ぶことはないものとします。例えば、図 1 に示すような入力はありえません。図 2 に示すように輪ゴムがかかっていない釘が 1 直線上に並ぶことはありえます。 </p> <center> <table> <tr> <td width="240"><img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_convex1"></td> <td width="240"><img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_convex2"></td> </tr> <tr> <td>図１</td> <td>図２</td> </tr> </table> </center> <br/> <p> ただし、それぞれの座標値は -1000.0 以上1000.0 以下の実数です。また、<var>n</var> は 3 以上 100 以下の整数です。 </p> <H2>Input</H2> <p> 複数のデータセットが与えられます。各データセットは以下のような形式です与えられます。 </p> <pre> <var>n</var> <var>x<sub>1</sub></var>, <var>y<sub>1</sub></var> <var>x<sub>2</sub></var>, <var>y<sub>2</sub></var> ... 　　　　 ... <var>x<sub>n</sub></var>, <var>y<sub>n</sub></var> </pre> <p> <var>n</var> が 0 の時、入力の最後を示します。データセットの数は 50 を超えません。 </p> <H2>Output</H2> <p> データセットごとに、ゴムと接していない釘の本数を出力してください。 例えば、図 3 に示す４つの釘を表す入力があった場合、図 4 のように囲まれるので、輪ゴムに接していない釘の本数は 1 本です。 </p> <center> <table> <tr> <td width="240"><img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_convex3"></td> <td width="240"><img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_convex4"></td> </tr> <tr> <td>図３</td> <td>図４</td> </tr> </table> </center> <br/> <H2>Sample Input</H2> <pre> 4 1.0,0.0 0.0,1.0 2.0,1.0 1.0,2.0 9 -509.94,892.63 567.62,639.99 -859.32,-64.84 -445.99,383.69 667.54,430.49 551.12,828.21 -940.2,-877.2 -361.62,-970 -125.42,-178.48 0 </pre> <H2>Output for the Sample Input</H2> <pre> 0 3 </pre> <H2>Hint</H2> <p> 以下は２つめのサンプル入力に対する図です。 </p> <center> <table> <tr> <td><img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_convex5"></td> </tr> <tr> </tr> </table> </center>
s267815826
p00068
Accepted
# Aizu Problem 0068: Enclose Pins with a Rubber Band # import sys, math, os # read input: PYDEV = os.environ.get('PYDEV') if PYDEV=="True": sys.stdin = open("sample-input.txt", "rt") def distance(p1, p2): return math.sqrt((p1[0] - p2[0])**2 + (p1[1] - p2[1])**2) def is_to_the_left(p1, p2, p3): # determine whether point p3 is to the left from the line from p1 to p2 position = (p2[0] - p1[0]) * (p3[1] - p1[1]) - (p2[1] - p1[1]) * (p3[0] - p1[0]) return position < 0 def jarvis(points): # determine convex hull by Jarvis' algorithm: max_y = max([p[1] for p in points]) pointOnHull = [p for p in points if p[1] == max_y][0] convex_hull = [pointOnHull] while len(convex_hull) == 1 or convex_hull[-1] != convex_hull[0]: p = convex_hull[-1] endpoint = points[0] for j in range(len(points)): if endpoint == pointOnHull or is_to_the_left(p, endpoint, points[j]): endpoint = points[j] pointOnHull = endpoint convex_hull.append(pointOnHull) return convex_hull[::-1] while True: N = int(input()) if N == 0: break points = [[float(_) for _ in input().split(',')] for __ in range(N)] print(N - (len(jarvis(points)) - 1))
4 1.0,0.0 0.0,1.0 2.0,1.0 1.0,2.0 9 -509.94,892.63 567.62,639.99 -859.32,-64.84 -445.99,383.69 667.54,430.49 551.12,828.21 -940.2,-877.2 -361.62,-970 -125.42,-178.48 0
0 3
<H1>輪ゴム</H1> <p> <var>n</var> 本の釘を平板上の座標 <var>P<sub>1</sub></var> (<var>x<sub>1</sub></var>, <var>y</sub>1</sub></var>), <var>P<sub>2</sub></var> (<var>x<sub>2</sub></var>, <var>y<sub>2</sub></var>), <var>P<sub>3</sub></var> (<var>x<sub>3</sub></var>, <var>y<sub>3</sub></var>),..., <var>P<sub>n</sub></var> (<var>x<sub>n</sub></var>, <var>y<sub>n</sub></var>) に１本ずつ打ち、輪ゴムの輪の中に全ての釘が入るように 1 本の輪ゴムで囲みます。このとき、輪ゴムが交差してはいけません。 </p> <p> 釘の座標を読み込んで、上記のように釘を輪ゴムで囲んだときに輪ゴムに接していない釘の本数を出力するプログラムを作成してください。輪ゴムは充分に伸び縮みするものとします。同じ座標に 2 本以上の釘を打つことはないものとします。また、輪ゴムがかかった釘と釘の間は直線で結ばれるものとし、その直線上に 3 本以上の釘が並ぶことはないものとします。例えば、図 1 に示すような入力はありえません。図 2 に示すように輪ゴムがかかっていない釘が 1 直線上に並ぶことはありえます。 </p> <center> <table> <tr> <td width="240"><img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_convex1"></td> <td width="240"><img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_convex2"></td> </tr> <tr> <td>図１</td> <td>図２</td> </tr> </table> </center> <br/> <p> ただし、それぞれの座標値は -1000.0 以上1000.0 以下の実数です。また、<var>n</var> は 3 以上 100 以下の整数です。 </p> <H2>Input</H2> <p> 複数のデータセットが与えられます。各データセットは以下のような形式です与えられます。 </p> <pre> <var>n</var> <var>x<sub>1</sub></var>, <var>y<sub>1</sub></var> <var>x<sub>2</sub></var>, <var>y<sub>2</sub></var> ... 　　　　 ... <var>x<sub>n</sub></var>, <var>y<sub>n</sub></var> </pre> <p> <var>n</var> が 0 の時、入力の最後を示します。データセットの数は 50 を超えません。 </p> <H2>Output</H2> <p> データセットごとに、ゴムと接していない釘の本数を出力してください。 例えば、図 3 に示す４つの釘を表す入力があった場合、図 4 のように囲まれるので、輪ゴムに接していない釘の本数は 1 本です。 </p> <center> <table> <tr> <td width="240"><img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_convex3"></td> <td width="240"><img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_convex4"></td> </tr> <tr> <td>図３</td> <td>図４</td> </tr> </table> </center> <br/> <H2>Sample Input</H2> <pre> 4 1.0,0.0 0.0,1.0 2.0,1.0 1.0,2.0 9 -509.94,892.63 567.62,639.99 -859.32,-64.84 -445.99,383.69 667.54,430.49 551.12,828.21 -940.2,-877.2 -361.62,-970 -125.42,-178.48 0 </pre> <H2>Output for the Sample Input</H2> <pre> 0 3 </pre> <H2>Hint</H2> <p> 以下は２つめのサンプル入力に対する図です。 </p> <center> <table> <tr> <td><img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_convex5"></td> </tr> <tr> </tr> </table> </center>
s582600598
p00068
Accepted
import math def vec(a, b): return [b[0] - a[0], b[1] - a[1]] def norm(a): return math.sqrt(a[0]**2 + a[1]**2) def cross(a, b): return a[0]*b[1] - b[0]*a[1] def gift_wrap(p_a, p_h, a): while True: p_h.append(a) b = p_a[0] for i in range(len(p_a)): c = p_a[i] if b == a: b = c else: ab = vec(a, b) ac = vec(a, c) v = cross(ab, ac) if v > 0 or (v == 0 and norm(ac) > norm(ab)): b = c a = b if a == p_h[0]: break while True: n = int(input()) if n == 0: break p_all = [] p_hull = [] for i in range(n): p_all.append(list(map(float, input().split(",")))) p_all = sorted(p_all) gift_wrap(p_all, p_hull, p_all[0]) print(len(p_all) - len(p_hull))
4 1.0,0.0 0.0,1.0 2.0,1.0 1.0,2.0 9 -509.94,892.63 567.62,639.99 -859.32,-64.84 -445.99,383.69 667.54,430.49 551.12,828.21 -940.2,-877.2 -361.62,-970 -125.42,-178.48 0
0 3
<H1>輪ゴム</H1> <p> <var>n</var> 本の釘を平板上の座標 <var>P<sub>1</sub></var> (<var>x<sub>1</sub></var>, <var>y</sub>1</sub></var>), <var>P<sub>2</sub></var> (<var>x<sub>2</sub></var>, <var>y<sub>2</sub></var>), <var>P<sub>3</sub></var> (<var>x<sub>3</sub></var>, <var>y<sub>3</sub></var>),..., <var>P<sub>n</sub></var> (<var>x<sub>n</sub></var>, <var>y<sub>n</sub></var>) に１本ずつ打ち、輪ゴムの輪の中に全ての釘が入るように 1 本の輪ゴムで囲みます。このとき、輪ゴムが交差してはいけません。 </p> <p> 釘の座標を読み込んで、上記のように釘を輪ゴムで囲んだときに輪ゴムに接していない釘の本数を出力するプログラムを作成してください。輪ゴムは充分に伸び縮みするものとします。同じ座標に 2 本以上の釘を打つことはないものとします。また、輪ゴムがかかった釘と釘の間は直線で結ばれるものとし、その直線上に 3 本以上の釘が並ぶことはないものとします。例えば、図 1 に示すような入力はありえません。図 2 に示すように輪ゴムがかかっていない釘が 1 直線上に並ぶことはありえます。 </p> <center> <table> <tr> <td width="240"><img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_convex1"></td> <td width="240"><img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_convex2"></td> </tr> <tr> <td>図１</td> <td>図２</td> </tr> </table> </center> <br/> <p> ただし、それぞれの座標値は -1000.0 以上1000.0 以下の実数です。また、<var>n</var> は 3 以上 100 以下の整数です。 </p> <H2>Input</H2> <p> 複数のデータセットが与えられます。各データセットは以下のような形式です与えられます。 </p> <pre> <var>n</var> <var>x<sub>1</sub></var>, <var>y<sub>1</sub></var> <var>x<sub>2</sub></var>, <var>y<sub>2</sub></var> ... 　　　　 ... <var>x<sub>n</sub></var>, <var>y<sub>n</sub></var> </pre> <p> <var>n</var> が 0 の時、入力の最後を示します。データセットの数は 50 を超えません。 </p> <H2>Output</H2> <p> データセットごとに、ゴムと接していない釘の本数を出力してください。 例えば、図 3 に示す４つの釘を表す入力があった場合、図 4 のように囲まれるので、輪ゴムに接していない釘の本数は 1 本です。 </p> <center> <table> <tr> <td width="240"><img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_convex3"></td> <td width="240"><img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_convex4"></td> </tr> <tr> <td>図３</td> <td>図４</td> </tr> </table> </center> <br/> <H2>Sample Input</H2> <pre> 4 1.0,0.0 0.0,1.0 2.0,1.0 1.0,2.0 9 -509.94,892.63 567.62,639.99 -859.32,-64.84 -445.99,383.69 667.54,430.49 551.12,828.21 -940.2,-877.2 -361.62,-970 -125.42,-178.48 0 </pre> <H2>Output for the Sample Input</H2> <pre> 0 3 </pre> <H2>Hint</H2> <p> 以下は２つめのサンプル入力に対する図です。 </p> <center> <table> <tr> <td><img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_convex5"></td> </tr> <tr> </tr> </table> </center>
s835844816
p00068
Accepted
# AOJ 0068 Enclose Pins with a Rubber Band # Python3 2018.6.22 bal4u def cross(a, b): return a.real*b.imag - a.imag*b.real # 凸包　入力: 座標リスト　リターン:凸包を構成する座標リスト def convex_hull(p): pp = sorted(p, key=lambda x:(x.imag,x.real)) # y座標を優先して昇順、同じならx座標で昇順 n = len(pp) ans, j = [0]*(n+1), 0 for i in range(n): while j > 1 and cross(ans[j-1]-ans[j-2], pp[i]-ans[j-1]) <= 0: j -= 1 ans[j] = pp[i] j += 1 k = j for i in range(n-2, -1, -1): while j > k and cross(ans[j-1]-ans[j-2], pp[i]-ans[j-1]) <= 0: j -= 1 ans[j] = pp[i] j += 1 return ans[0:j-1] while 1: n = int(input()) if n == 0: break p = [] for i in range(n): x, y = list(map(float, input().split(','))) p.append(complex(x, y)) print(n - len(convex_hull(p)))
4 1.0,0.0 0.0,1.0 2.0,1.0 1.0,2.0 9 -509.94,892.63 567.62,639.99 -859.32,-64.84 -445.99,383.69 667.54,430.49 551.12,828.21 -940.2,-877.2 -361.62,-970 -125.42,-178.48 0
0 3
<H1>輪ゴム</H1> <p> <var>n</var> 本の釘を平板上の座標 <var>P<sub>1</sub></var> (<var>x<sub>1</sub></var>, <var>y</sub>1</sub></var>), <var>P<sub>2</sub></var> (<var>x<sub>2</sub></var>, <var>y<sub>2</sub></var>), <var>P<sub>3</sub></var> (<var>x<sub>3</sub></var>, <var>y<sub>3</sub></var>),..., <var>P<sub>n</sub></var> (<var>x<sub>n</sub></var>, <var>y<sub>n</sub></var>) に１本ずつ打ち、輪ゴムの輪の中に全ての釘が入るように 1 本の輪ゴムで囲みます。このとき、輪ゴムが交差してはいけません。 </p> <p> 釘の座標を読み込んで、上記のように釘を輪ゴムで囲んだときに輪ゴムに接していない釘の本数を出力するプログラムを作成してください。輪ゴムは充分に伸び縮みするものとします。同じ座標に 2 本以上の釘を打つことはないものとします。また、輪ゴムがかかった釘と釘の間は直線で結ばれるものとし、その直線上に 3 本以上の釘が並ぶことはないものとします。例えば、図 1 に示すような入力はありえません。図 2 に示すように輪ゴムがかかっていない釘が 1 直線上に並ぶことはありえます。 </p> <center> <table> <tr> <td width="240"><img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_convex1"></td> <td width="240"><img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_convex2"></td> </tr> <tr> <td>図１</td> <td>図２</td> </tr> </table> </center> <br/> <p> ただし、それぞれの座標値は -1000.0 以上1000.0 以下の実数です。また、<var>n</var> は 3 以上 100 以下の整数です。 </p> <H2>Input</H2> <p> 複数のデータセットが与えられます。各データセットは以下のような形式です与えられます。 </p> <pre> <var>n</var> <var>x<sub>1</sub></var>, <var>y<sub>1</sub></var> <var>x<sub>2</sub></var>, <var>y<sub>2</sub></var> ... 　　　　 ... <var>x<sub>n</sub></var>, <var>y<sub>n</sub></var> </pre> <p> <var>n</var> が 0 の時、入力の最後を示します。データセットの数は 50 を超えません。 </p> <H2>Output</H2> <p> データセットごとに、ゴムと接していない釘の本数を出力してください。 例えば、図 3 に示す４つの釘を表す入力があった場合、図 4 のように囲まれるので、輪ゴムに接していない釘の本数は 1 本です。 </p> <center> <table> <tr> <td width="240"><img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_convex3"></td> <td width="240"><img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_convex4"></td> </tr> <tr> <td>図３</td> <td>図４</td> </tr> </table> </center> <br/> <H2>Sample Input</H2> <pre> 4 1.0,0.0 0.0,1.0 2.0,1.0 1.0,2.0 9 -509.94,892.63 567.62,639.99 -859.32,-64.84 -445.99,383.69 667.54,430.49 551.12,828.21 -940.2,-877.2 -361.62,-970 -125.42,-178.48 0 </pre> <H2>Output for the Sample Input</H2> <pre> 0 3 </pre> <H2>Hint</H2> <p> 以下は２つめのサンプル入力に対する図です。 </p> <center> <table> <tr> <td><img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_convex5"></td> </tr> <tr> </tr> </table> </center>
s090759705
p00068
Accepted
# AOJ 0068 Enclose Pins with a Rubber Band # Python3 2018.6.22 bal4u def cross(a, b): return a.real*b.imag - a.imag*b.real # 凸包　入力: 座標リスト　リターン:凸包を構成する座標リスト def convex_hull(p): pp = sorted(p, key=lambda x:(x.imag,x.real)) # y座標を優先して昇順、同じならx座標で昇順 n = len(pp) ans, j = [0]*(n+1), 0 for i in range(n): while j > 1 and cross(ans[j-1]-ans[j-2], pp[i]-ans[j-1]) < 0: j -= 1 ans[j] = pp[i] j += 1 k = j for i in range(n-2, -1, -1): while j > k and cross(ans[j-1]-ans[j-2], pp[i]-ans[j-1]) < 0: j -= 1 ans[j] = pp[i] j += 1 return ans[0:j-1] while 1: n = int(input()) if n == 0: break p = [] for i in range(n): x, y = list(map(float, input().split(','))) p.append(complex(x, y)) print(n - len(convex_hull(p)))
4 1.0,0.0 0.0,1.0 2.0,1.0 1.0,2.0 9 -509.94,892.63 567.62,639.99 -859.32,-64.84 -445.99,383.69 667.54,430.49 551.12,828.21 -940.2,-877.2 -361.62,-970 -125.42,-178.48 0
0 3
<H1>輪ゴム</H1> <p> <var>n</var> 本の釘を平板上の座標 <var>P<sub>1</sub></var> (<var>x<sub>1</sub></var>, <var>y</sub>1</sub></var>), <var>P<sub>2</sub></var> (<var>x<sub>2</sub></var>, <var>y<sub>2</sub></var>), <var>P<sub>3</sub></var> (<var>x<sub>3</sub></var>, <var>y<sub>3</sub></var>),..., <var>P<sub>n</sub></var> (<var>x<sub>n</sub></var>, <var>y<sub>n</sub></var>) に１本ずつ打ち、輪ゴムの輪の中に全ての釘が入るように 1 本の輪ゴムで囲みます。このとき、輪ゴムが交差してはいけません。 </p> <p> 釘の座標を読み込んで、上記のように釘を輪ゴムで囲んだときに輪ゴムに接していない釘の本数を出力するプログラムを作成してください。輪ゴムは充分に伸び縮みするものとします。同じ座標に 2 本以上の釘を打つことはないものとします。また、輪ゴムがかかった釘と釘の間は直線で結ばれるものとし、その直線上に 3 本以上の釘が並ぶことはないものとします。例えば、図 1 に示すような入力はありえません。図 2 に示すように輪ゴムがかかっていない釘が 1 直線上に並ぶことはありえます。 </p> <center> <table> <tr> <td width="240"><img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_convex1"></td> <td width="240"><img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_convex2"></td> </tr> <tr> <td>図１</td> <td>図２</td> </tr> </table> </center> <br/> <p> ただし、それぞれの座標値は -1000.0 以上1000.0 以下の実数です。また、<var>n</var> は 3 以上 100 以下の整数です。 </p> <H2>Input</H2> <p> 複数のデータセットが与えられます。各データセットは以下のような形式です与えられます。 </p> <pre> <var>n</var> <var>x<sub>1</sub></var>, <var>y<sub>1</sub></var> <var>x<sub>2</sub></var>, <var>y<sub>2</sub></var> ... 　　　　 ... <var>x<sub>n</sub></var>, <var>y<sub>n</sub></var> </pre> <p> <var>n</var> が 0 の時、入力の最後を示します。データセットの数は 50 を超えません。 </p> <H2>Output</H2> <p> データセットごとに、ゴムと接していない釘の本数を出力してください。 例えば、図 3 に示す４つの釘を表す入力があった場合、図 4 のように囲まれるので、輪ゴムに接していない釘の本数は 1 本です。 </p> <center> <table> <tr> <td width="240"><img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_convex3"></td> <td width="240"><img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_convex4"></td> </tr> <tr> <td>図３</td> <td>図４</td> </tr> </table> </center> <br/> <H2>Sample Input</H2> <pre> 4 1.0,0.0 0.0,1.0 2.0,1.0 1.0,2.0 9 -509.94,892.63 567.62,639.99 -859.32,-64.84 -445.99,383.69 667.54,430.49 551.12,828.21 -940.2,-877.2 -361.62,-970 -125.42,-178.48 0 </pre> <H2>Output for the Sample Input</H2> <pre> 0 3 </pre> <H2>Hint</H2> <p> 以下は２つめのサンプル入力に対する図です。 </p> <center> <table> <tr> <td><img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_convex5"></td> </tr> <tr> </tr> </table> </center>
s969966814
p00068
Accepted
import math def ccw(p1,p2,p3): # print (p2[0]-p1[0])*(p3[1]-p1[1])-(p2[1]-p1[1])*(p3[0]-p1[0]) return (p2[0]-p1[0])*(p3[1]-p1[1])-(p2[1]-p1[1])*(p3[0]-p1[0]) while True: n=input() if n==0: #print 0 break p=[0]*n for i in xrange(n): p[i]=map(float,raw_input().strip().split(",")) P=min(p,key=lambda a:(a[1],a[0])) p.sort(key=lambda x:math.atan2(x[1]-P[1],x[0]-P[0])) #print len(p) #print "\n".join(map(lambda x:"{},{}".format(x[0],x[1]),p)) M=0 ans=0 for i in xrange(1,n): while ccw(p[M-1],p[M],p[i])<=0: if M>0: M-=1 ans+=1 elif i==n: break else: i+=1 M+=1 p[M],p[i]=p[i],p[M] print ans #print len(p) #print "\n".join(map(lambda x:"{},{}".format(x[0],x[1]),p))
4 1.0,0.0 0.0,1.0 2.0,1.0 1.0,2.0 9 -509.94,892.63 567.62,639.99 -859.32,-64.84 -445.99,383.69 667.54,430.49 551.12,828.21 -940.2,-877.2 -361.62,-970 -125.42,-178.48 0
0 3
<H1>輪ゴム</H1> <p> <var>n</var> 本の釘を平板上の座標 <var>P<sub>1</sub></var> (<var>x<sub>1</sub></var>, <var>y</sub>1</sub></var>), <var>P<sub>2</sub></var> (<var>x<sub>2</sub></var>, <var>y<sub>2</sub></var>), <var>P<sub>3</sub></var> (<var>x<sub>3</sub></var>, <var>y<sub>3</sub></var>),..., <var>P<sub>n</sub></var> (<var>x<sub>n</sub></var>, <var>y<sub>n</sub></var>) に１本ずつ打ち、輪ゴムの輪の中に全ての釘が入るように 1 本の輪ゴムで囲みます。このとき、輪ゴムが交差してはいけません。 </p> <p> 釘の座標を読み込んで、上記のように釘を輪ゴムで囲んだときに輪ゴムに接していない釘の本数を出力するプログラムを作成してください。輪ゴムは充分に伸び縮みするものとします。同じ座標に 2 本以上の釘を打つことはないものとします。また、輪ゴムがかかった釘と釘の間は直線で結ばれるものとし、その直線上に 3 本以上の釘が並ぶことはないものとします。例えば、図 1 に示すような入力はありえません。図 2 に示すように輪ゴムがかかっていない釘が 1 直線上に並ぶことはありえます。 </p> <center> <table> <tr> <td width="240"><img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_convex1"></td> <td width="240"><img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_convex2"></td> </tr> <tr> <td>図１</td> <td>図２</td> </tr> </table> </center> <br/> <p> ただし、それぞれの座標値は -1000.0 以上1000.0 以下の実数です。また、<var>n</var> は 3 以上 100 以下の整数です。 </p> <H2>Input</H2> <p> 複数のデータセットが与えられます。各データセットは以下のような形式です与えられます。 </p> <pre> <var>n</var> <var>x<sub>1</sub></var>, <var>y<sub>1</sub></var> <var>x<sub>2</sub></var>, <var>y<sub>2</sub></var> ... 　　　　 ... <var>x<sub>n</sub></var>, <var>y<sub>n</sub></var> </pre> <p> <var>n</var> が 0 の時、入力の最後を示します。データセットの数は 50 を超えません。 </p> <H2>Output</H2> <p> データセットごとに、ゴムと接していない釘の本数を出力してください。 例えば、図 3 に示す４つの釘を表す入力があった場合、図 4 のように囲まれるので、輪ゴムに接していない釘の本数は 1 本です。 </p> <center> <table> <tr> <td width="240"><img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_convex3"></td> <td width="240"><img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_convex4"></td> </tr> <tr> <td>図３</td> <td>図４</td> </tr> </table> </center> <br/> <H2>Sample Input</H2> <pre> 4 1.0,0.0 0.0,1.0 2.0,1.0 1.0,2.0 9 -509.94,892.63 567.62,639.99 -859.32,-64.84 -445.99,383.69 667.54,430.49 551.12,828.21 -940.2,-877.2 -361.62,-970 -125.42,-178.48 0 </pre> <H2>Output for the Sample Input</H2> <pre> 0 3 </pre> <H2>Hint</H2> <p> 以下は２つめのサンプル入力に対する図です。 </p> <center> <table> <tr> <td><img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_convex5"></td> </tr> <tr> </tr> </table> </center>
s633749704
p00068
Accepted
import math def ccw(p1,p2,p3): #print (p2[0]-p1[0])*(p3[1]-p2[1])-(p2[1]-p1[1])*(p3[0]-p2[0])>=0 return (p2[0]-p1[0])*(p3[1]-p2[1])-(p2[1]-p1[1])*(p3[0]-p2[0]) while True: n=input() if n==0: break p=[0]*n for i in xrange(n): p[i]=map(float,raw_input().strip().split(",")) P=min(p,key=lambda a:(a[1],a[0])) p.sort(key=lambda x:math.atan2(x[1]-P[1],x[0]-P[0])) #print n #print "\n".join(map(lambda x:"{},{}".format(x[0],x[1]),p)) M=0 i=1 c_p=p[:] #print M,p while M<len(p)-1: if all([ccw(p[M-1],p[M],p[i])>=0 for i in xrange(M+1,len(p))]): M+=1 else: p.remove(p[M]) #print M,p print len(c_p)-len(p) #print len(p) #print "\n".join(map(lambda x:"{},{}".format(x[0],x[1]),p))
4 1.0,0.0 0.0,1.0 2.0,1.0 1.0,2.0 9 -509.94,892.63 567.62,639.99 -859.32,-64.84 -445.99,383.69 667.54,430.49 551.12,828.21 -940.2,-877.2 -361.62,-970 -125.42,-178.48 0
0 3
<H1>輪ゴム</H1> <p> <var>n</var> 本の釘を平板上の座標 <var>P<sub>1</sub></var> (<var>x<sub>1</sub></var>, <var>y</sub>1</sub></var>), <var>P<sub>2</sub></var> (<var>x<sub>2</sub></var>, <var>y<sub>2</sub></var>), <var>P<sub>3</sub></var> (<var>x<sub>3</sub></var>, <var>y<sub>3</sub></var>),..., <var>P<sub>n</sub></var> (<var>x<sub>n</sub></var>, <var>y<sub>n</sub></var>) に１本ずつ打ち、輪ゴムの輪の中に全ての釘が入るように 1 本の輪ゴムで囲みます。このとき、輪ゴムが交差してはいけません。 </p> <p> 釘の座標を読み込んで、上記のように釘を輪ゴムで囲んだときに輪ゴムに接していない釘の本数を出力するプログラムを作成してください。輪ゴムは充分に伸び縮みするものとします。同じ座標に 2 本以上の釘を打つことはないものとします。また、輪ゴムがかかった釘と釘の間は直線で結ばれるものとし、その直線上に 3 本以上の釘が並ぶことはないものとします。例えば、図 1 に示すような入力はありえません。図 2 に示すように輪ゴムがかかっていない釘が 1 直線上に並ぶことはありえます。 </p> <center> <table> <tr> <td width="240"><img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_convex1"></td> <td width="240"><img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_convex2"></td> </tr> <tr> <td>図１</td> <td>図２</td> </tr> </table> </center> <br/> <p> ただし、それぞれの座標値は -1000.0 以上1000.0 以下の実数です。また、<var>n</var> は 3 以上 100 以下の整数です。 </p> <H2>Input</H2> <p> 複数のデータセットが与えられます。各データセットは以下のような形式です与えられます。 </p> <pre> <var>n</var> <var>x<sub>1</sub></var>, <var>y<sub>1</sub></var> <var>x<sub>2</sub></var>, <var>y<sub>2</sub></var> ... 　　　　 ... <var>x<sub>n</sub></var>, <var>y<sub>n</sub></var> </pre> <p> <var>n</var> が 0 の時、入力の最後を示します。データセットの数は 50 を超えません。 </p> <H2>Output</H2> <p> データセットごとに、ゴムと接していない釘の本数を出力してください。 例えば、図 3 に示す４つの釘を表す入力があった場合、図 4 のように囲まれるので、輪ゴムに接していない釘の本数は 1 本です。 </p> <center> <table> <tr> <td width="240"><img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_convex3"></td> <td width="240"><img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_convex4"></td> </tr> <tr> <td>図３</td> <td>図４</td> </tr> </table> </center> <br/> <H2>Sample Input</H2> <pre> 4 1.0,0.0 0.0,1.0 2.0,1.0 1.0,2.0 9 -509.94,892.63 567.62,639.99 -859.32,-64.84 -445.99,383.69 667.54,430.49 551.12,828.21 -940.2,-877.2 -361.62,-970 -125.42,-178.48 0 </pre> <H2>Output for the Sample Input</H2> <pre> 0 3 </pre> <H2>Hint</H2> <p> 以下は２つめのサンプル入力に対する図です。 </p> <center> <table> <tr> <td><img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_convex5"></td> </tr> <tr> </tr> </table> </center>
s418059020
p00068
Accepted
import math def ccw(p1,p2,p3): return (p2[0]-p1[0])*(p3[1]-p2[1])-(p2[1]-p1[1])*(p3[0]-p2[0]) while True: n=input() if n==0: break p=[0]*n for i in xrange(n): p[i]=map(float,raw_input().strip().split(",")) P=min(p,key=lambda a:(a[1],a[0])) p.sort(key=lambda x:math.atan2(x[1]-P[1],x[0]-P[0])) M=0 ans=0 while M<len(p)-1: if all([ccw(p[M-1],p[M],p[i])>=0 for i in xrange(M+1,len(p))]): M+=1 else: ans+=1 p.remove(p[M]) print ans
4 1.0,0.0 0.0,1.0 2.0,1.0 1.0,2.0 9 -509.94,892.63 567.62,639.99 -859.32,-64.84 -445.99,383.69 667.54,430.49 551.12,828.21 -940.2,-877.2 -361.62,-970 -125.42,-178.48 0
0 3
<H1>輪ゴム</H1> <p> <var>n</var> 本の釘を平板上の座標 <var>P<sub>1</sub></var> (<var>x<sub>1</sub></var>, <var>y</sub>1</sub></var>), <var>P<sub>2</sub></var> (<var>x<sub>2</sub></var>, <var>y<sub>2</sub></var>), <var>P<sub>3</sub></var> (<var>x<sub>3</sub></var>, <var>y<sub>3</sub></var>),..., <var>P<sub>n</sub></var> (<var>x<sub>n</sub></var>, <var>y<sub>n</sub></var>) に１本ずつ打ち、輪ゴムの輪の中に全ての釘が入るように 1 本の輪ゴムで囲みます。このとき、輪ゴムが交差してはいけません。 </p> <p> 釘の座標を読み込んで、上記のように釘を輪ゴムで囲んだときに輪ゴムに接していない釘の本数を出力するプログラムを作成してください。輪ゴムは充分に伸び縮みするものとします。同じ座標に 2 本以上の釘を打つことはないものとします。また、輪ゴムがかかった釘と釘の間は直線で結ばれるものとし、その直線上に 3 本以上の釘が並ぶことはないものとします。例えば、図 1 に示すような入力はありえません。図 2 に示すように輪ゴムがかかっていない釘が 1 直線上に並ぶことはありえます。 </p> <center> <table> <tr> <td width="240"><img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_convex1"></td> <td width="240"><img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_convex2"></td> </tr> <tr> <td>図１</td> <td>図２</td> </tr> </table> </center> <br/> <p> ただし、それぞれの座標値は -1000.0 以上1000.0 以下の実数です。また、<var>n</var> は 3 以上 100 以下の整数です。 </p> <H2>Input</H2> <p> 複数のデータセットが与えられます。各データセットは以下のような形式です与えられます。 </p> <pre> <var>n</var> <var>x<sub>1</sub></var>, <var>y<sub>1</sub></var> <var>x<sub>2</sub></var>, <var>y<sub>2</sub></var> ... 　　　　 ... <var>x<sub>n</sub></var>, <var>y<sub>n</sub></var> </pre> <p> <var>n</var> が 0 の時、入力の最後を示します。データセットの数は 50 を超えません。 </p> <H2>Output</H2> <p> データセットごとに、ゴムと接していない釘の本数を出力してください。 例えば、図 3 に示す４つの釘を表す入力があった場合、図 4 のように囲まれるので、輪ゴムに接していない釘の本数は 1 本です。 </p> <center> <table> <tr> <td width="240"><img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_convex3"></td> <td width="240"><img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_convex4"></td> </tr> <tr> <td>図３</td> <td>図４</td> </tr> </table> </center> <br/> <H2>Sample Input</H2> <pre> 4 1.0,0.0 0.0,1.0 2.0,1.0 1.0,2.0 9 -509.94,892.63 567.62,639.99 -859.32,-64.84 -445.99,383.69 667.54,430.49 551.12,828.21 -940.2,-877.2 -361.62,-970 -125.42,-178.48 0 </pre> <H2>Output for the Sample Input</H2> <pre> 0 3 </pre> <H2>Hint</H2> <p> 以下は２つめのサンプル入力に対する図です。 </p> <center> <table> <tr> <td><img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_convex5"></td> </tr> <tr> </tr> </table> </center>
s111561625
p00068
Accepted
import math def ccw(p1,p2,p3): return (p2[0]-p1[0])*(p3[1]-p2[1])-(p2[1]-p1[1])*(p3[0]-p2[0]) while True: n=input() if n==0: break p=[0]*n for i in xrange(n): p[i]=map(float,raw_input().strip().split(",")) P=min(p,key=lambda a:(a[1],a[0])) p.sort(key=lambda x:math.atan2(x[1]-P[1],x[0]-P[0])) M=0 ans=0 for i in xrange(1,n-1): if all([ccw(p[M],p[i],p[j])>=0 for j in xrange(i+1,n)]): M=i else: ans+=1 print ans
4 1.0,0.0 0.0,1.0 2.0,1.0 1.0,2.0 9 -509.94,892.63 567.62,639.99 -859.32,-64.84 -445.99,383.69 667.54,430.49 551.12,828.21 -940.2,-877.2 -361.62,-970 -125.42,-178.48 0
0 3
<H1>輪ゴム</H1> <p> <var>n</var> 本の釘を平板上の座標 <var>P<sub>1</sub></var> (<var>x<sub>1</sub></var>, <var>y</sub>1</sub></var>), <var>P<sub>2</sub></var> (<var>x<sub>2</sub></var>, <var>y<sub>2</sub></var>), <var>P<sub>3</sub></var> (<var>x<sub>3</sub></var>, <var>y<sub>3</sub></var>),..., <var>P<sub>n</sub></var> (<var>x<sub>n</sub></var>, <var>y<sub>n</sub></var>) に１本ずつ打ち、輪ゴムの輪の中に全ての釘が入るように 1 本の輪ゴムで囲みます。このとき、輪ゴムが交差してはいけません。 </p> <p> 釘の座標を読み込んで、上記のように釘を輪ゴムで囲んだときに輪ゴムに接していない釘の本数を出力するプログラムを作成してください。輪ゴムは充分に伸び縮みするものとします。同じ座標に 2 本以上の釘を打つことはないものとします。また、輪ゴムがかかった釘と釘の間は直線で結ばれるものとし、その直線上に 3 本以上の釘が並ぶことはないものとします。例えば、図 1 に示すような入力はありえません。図 2 に示すように輪ゴムがかかっていない釘が 1 直線上に並ぶことはありえます。 </p> <center> <table> <tr> <td width="240"><img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_convex1"></td> <td width="240"><img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_convex2"></td> </tr> <tr> <td>図１</td> <td>図２</td> </tr> </table> </center> <br/> <p> ただし、それぞれの座標値は -1000.0 以上1000.0 以下の実数です。また、<var>n</var> は 3 以上 100 以下の整数です。 </p> <H2>Input</H2> <p> 複数のデータセットが与えられます。各データセットは以下のような形式です与えられます。 </p> <pre> <var>n</var> <var>x<sub>1</sub></var>, <var>y<sub>1</sub></var> <var>x<sub>2</sub></var>, <var>y<sub>2</sub></var> ... 　　　　 ... <var>x<sub>n</sub></var>, <var>y<sub>n</sub></var> </pre> <p> <var>n</var> が 0 の時、入力の最後を示します。データセットの数は 50 を超えません。 </p> <H2>Output</H2> <p> データセットごとに、ゴムと接していない釘の本数を出力してください。 例えば、図 3 に示す４つの釘を表す入力があった場合、図 4 のように囲まれるので、輪ゴムに接していない釘の本数は 1 本です。 </p> <center> <table> <tr> <td width="240"><img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_convex3"></td> <td width="240"><img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_convex4"></td> </tr> <tr> <td>図３</td> <td>図４</td> </tr> </table> </center> <br/> <H2>Sample Input</H2> <pre> 4 1.0,0.0 0.0,1.0 2.0,1.0 1.0,2.0 9 -509.94,892.63 567.62,639.99 -859.32,-64.84 -445.99,383.69 667.54,430.49 551.12,828.21 -940.2,-877.2 -361.62,-970 -125.42,-178.48 0 </pre> <H2>Output for the Sample Input</H2> <pre> 0 3 </pre> <H2>Hint</H2> <p> 以下は２つめのサンプル入力に対する図です。 </p> <center> <table> <tr> <td><img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_convex5"></td> </tr> <tr> </tr> </table> </center>
s370463036
p00068
Accepted
import math def ccw(p1,p2,p3): return (p2[0]-p1[0])*(p3[1]-p2[1])-(p2[1]-p1[1])*(p3[0]-p2[0]) while True: n=input() if n==0: break p=[0]*n for i in xrange(n): p[i]=map(float,raw_input().strip().split(",")) P=min(p,key=lambda a:(a[1],a[0])) p.sort(key=lambda x:math.atan2(x[1]-P[1],x[0]-P[0])) M,ans=0,0 for i in xrange(1,n-1): if all([ccw(p[M],p[i],p[j])>=0 for j in xrange(i+1,n)]): M=i else: ans+=1 print ans
4 1.0,0.0 0.0,1.0 2.0,1.0 1.0,2.0 9 -509.94,892.63 567.62,639.99 -859.32,-64.84 -445.99,383.69 667.54,430.49 551.12,828.21 -940.2,-877.2 -361.62,-970 -125.42,-178.48 0
0 3
<H1>輪ゴム</H1> <p> <var>n</var> 本の釘を平板上の座標 <var>P<sub>1</sub></var> (<var>x<sub>1</sub></var>, <var>y</sub>1</sub></var>), <var>P<sub>2</sub></var> (<var>x<sub>2</sub></var>, <var>y<sub>2</sub></var>), <var>P<sub>3</sub></var> (<var>x<sub>3</sub></var>, <var>y<sub>3</sub></var>),..., <var>P<sub>n</sub></var> (<var>x<sub>n</sub></var>, <var>y<sub>n</sub></var>) に１本ずつ打ち、輪ゴムの輪の中に全ての釘が入るように 1 本の輪ゴムで囲みます。このとき、輪ゴムが交差してはいけません。 </p> <p> 釘の座標を読み込んで、上記のように釘を輪ゴムで囲んだときに輪ゴムに接していない釘の本数を出力するプログラムを作成してください。輪ゴムは充分に伸び縮みするものとします。同じ座標に 2 本以上の釘を打つことはないものとします。また、輪ゴムがかかった釘と釘の間は直線で結ばれるものとし、その直線上に 3 本以上の釘が並ぶことはないものとします。例えば、図 1 に示すような入力はありえません。図 2 に示すように輪ゴムがかかっていない釘が 1 直線上に並ぶことはありえます。 </p> <center> <table> <tr> <td width="240"><img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_convex1"></td> <td width="240"><img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_convex2"></td> </tr> <tr> <td>図１</td> <td>図２</td> </tr> </table> </center> <br/> <p> ただし、それぞれの座標値は -1000.0 以上1000.0 以下の実数です。また、<var>n</var> は 3 以上 100 以下の整数です。 </p> <H2>Input</H2> <p> 複数のデータセットが与えられます。各データセットは以下のような形式です与えられます。 </p> <pre> <var>n</var> <var>x<sub>1</sub></var>, <var>y<sub>1</sub></var> <var>x<sub>2</sub></var>, <var>y<sub>2</sub></var> ... 　　　　 ... <var>x<sub>n</sub></var>, <var>y<sub>n</sub></var> </pre> <p> <var>n</var> が 0 の時、入力の最後を示します。データセットの数は 50 を超えません。 </p> <H2>Output</H2> <p> データセットごとに、ゴムと接していない釘の本数を出力してください。 例えば、図 3 に示す４つの釘を表す入力があった場合、図 4 のように囲まれるので、輪ゴムに接していない釘の本数は 1 本です。 </p> <center> <table> <tr> <td width="240"><img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_convex3"></td> <td width="240"><img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_convex4"></td> </tr> <tr> <td>図３</td> <td>図４</td> </tr> </table> </center> <br/> <H2>Sample Input</H2> <pre> 4 1.0,0.0 0.0,1.0 2.0,1.0 1.0,2.0 9 -509.94,892.63 567.62,639.99 -859.32,-64.84 -445.99,383.69 667.54,430.49 551.12,828.21 -940.2,-877.2 -361.62,-970 -125.42,-178.48 0 </pre> <H2>Output for the Sample Input</H2> <pre> 0 3 </pre> <H2>Hint</H2> <p> 以下は２つめのサンプル入力に対する図です。 </p> <center> <table> <tr> <td><img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_convex5"></td> </tr> <tr> </tr> </table> </center>
s058073877
p00068
Accepted
import math def ccw(p1,p2,p3): return (p2[0]-p1[0])*(p3[1]-p2[1])-(p2[1]-p1[1])*(p3[0]-p2[0]) while True: n=input() if n==0: break p=[0]*n for i in xrange(n): p[i]=map(float,raw_input().split(",")) P=min(p,key=lambda a:(a[1],a[0])) p.sort(key=lambda x:math.atan2(x[1]-P[1],x[0]-P[0])) M,ans=0,0 for i in xrange(1,n-1): if all([ccw(p[M],p[i],p[j])>=0 for j in xrange(i+1,n)]): M=i else: ans+=1 print ans
4 1.0,0.0 0.0,1.0 2.0,1.0 1.0,2.0 9 -509.94,892.63 567.62,639.99 -859.32,-64.84 -445.99,383.69 667.54,430.49 551.12,828.21 -940.2,-877.2 -361.62,-970 -125.42,-178.48 0
0 3
<H1>輪ゴム</H1> <p> <var>n</var> 本の釘を平板上の座標 <var>P<sub>1</sub></var> (<var>x<sub>1</sub></var>, <var>y</sub>1</sub></var>), <var>P<sub>2</sub></var> (<var>x<sub>2</sub></var>, <var>y<sub>2</sub></var>), <var>P<sub>3</sub></var> (<var>x<sub>3</sub></var>, <var>y<sub>3</sub></var>),..., <var>P<sub>n</sub></var> (<var>x<sub>n</sub></var>, <var>y<sub>n</sub></var>) に１本ずつ打ち、輪ゴムの輪の中に全ての釘が入るように 1 本の輪ゴムで囲みます。このとき、輪ゴムが交差してはいけません。 </p> <p> 釘の座標を読み込んで、上記のように釘を輪ゴムで囲んだときに輪ゴムに接していない釘の本数を出力するプログラムを作成してください。輪ゴムは充分に伸び縮みするものとします。同じ座標に 2 本以上の釘を打つことはないものとします。また、輪ゴムがかかった釘と釘の間は直線で結ばれるものとし、その直線上に 3 本以上の釘が並ぶことはないものとします。例えば、図 1 に示すような入力はありえません。図 2 に示すように輪ゴムがかかっていない釘が 1 直線上に並ぶことはありえます。 </p> <center> <table> <tr> <td width="240"><img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_convex1"></td> <td width="240"><img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_convex2"></td> </tr> <tr> <td>図１</td> <td>図２</td> </tr> </table> </center> <br/> <p> ただし、それぞれの座標値は -1000.0 以上1000.0 以下の実数です。また、<var>n</var> は 3 以上 100 以下の整数です。 </p> <H2>Input</H2> <p> 複数のデータセットが与えられます。各データセットは以下のような形式です与えられます。 </p> <pre> <var>n</var> <var>x<sub>1</sub></var>, <var>y<sub>1</sub></var> <var>x<sub>2</sub></var>, <var>y<sub>2</sub></var> ... 　　　　 ... <var>x<sub>n</sub></var>, <var>y<sub>n</sub></var> </pre> <p> <var>n</var> が 0 の時、入力の最後を示します。データセットの数は 50 を超えません。 </p> <H2>Output</H2> <p> データセットごとに、ゴムと接していない釘の本数を出力してください。 例えば、図 3 に示す４つの釘を表す入力があった場合、図 4 のように囲まれるので、輪ゴムに接していない釘の本数は 1 本です。 </p> <center> <table> <tr> <td width="240"><img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_convex3"></td> <td width="240"><img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_convex4"></td> </tr> <tr> <td>図３</td> <td>図４</td> </tr> </table> </center> <br/> <H2>Sample Input</H2> <pre> 4 1.0,0.0 0.0,1.0 2.0,1.0 1.0,2.0 9 -509.94,892.63 567.62,639.99 -859.32,-64.84 -445.99,383.69 667.54,430.49 551.12,828.21 -940.2,-877.2 -361.62,-970 -125.42,-178.48 0 </pre> <H2>Output for the Sample Input</H2> <pre> 0 3 </pre> <H2>Hint</H2> <p> 以下は２つめのサンプル入力に対する図です。 </p> <center> <table> <tr> <td><img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_convex5"></td> </tr> <tr> </tr> </table> </center>
s518443398
p00068
Accepted
def func(u,v): f=lambda x,y:(v[0]-u[0])*(y-u[1])-(v[1]-u[1])*(x-u[0]) return f while True: n=input() if n==0:break L=[map(float,raw_input().split(",")) for i in range(n)] L.sort() S=[] init=L[0] for i in range(n): if L[i]!=init: f=func(init,L[i]) for j in range(i+1,n): if f(L[j][0],L[j][1])>0: break else: S.append(L[i]) init=L[i] init=L[0] for i in range(n): if L[i]!=init: f=func(init,L[i]) for j in range(i+1,n): if f(L[j][0],L[j][1])<0: break else: S.append(L[i]) init=L[i] print n-len(set(map(tuple,S)))-1
4 1.0,0.0 0.0,1.0 2.0,1.0 1.0,2.0 9 -509.94,892.63 567.62,639.99 -859.32,-64.84 -445.99,383.69 667.54,430.49 551.12,828.21 -940.2,-877.2 -361.62,-970 -125.42,-178.48 0
0 3
<H1>輪ゴム</H1> <p> <var>n</var> 本の釘を平板上の座標 <var>P<sub>1</sub></var> (<var>x<sub>1</sub></var>, <var>y</sub>1</sub></var>), <var>P<sub>2</sub></var> (<var>x<sub>2</sub></var>, <var>y<sub>2</sub></var>), <var>P<sub>3</sub></var> (<var>x<sub>3</sub></var>, <var>y<sub>3</sub></var>),..., <var>P<sub>n</sub></var> (<var>x<sub>n</sub></var>, <var>y<sub>n</sub></var>) に１本ずつ打ち、輪ゴムの輪の中に全ての釘が入るように 1 本の輪ゴムで囲みます。このとき、輪ゴムが交差してはいけません。 </p> <p> 釘の座標を読み込んで、上記のように釘を輪ゴムで囲んだときに輪ゴムに接していない釘の本数を出力するプログラムを作成してください。輪ゴムは充分に伸び縮みするものとします。同じ座標に 2 本以上の釘を打つことはないものとします。また、輪ゴムがかかった釘と釘の間は直線で結ばれるものとし、その直線上に 3 本以上の釘が並ぶことはないものとします。例えば、図 1 に示すような入力はありえません。図 2 に示すように輪ゴムがかかっていない釘が 1 直線上に並ぶことはありえます。 </p> <center> <table> <tr> <td width="240"><img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_convex1"></td> <td width="240"><img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_convex2"></td> </tr> <tr> <td>図１</td> <td>図２</td> </tr> </table> </center> <br/> <p> ただし、それぞれの座標値は -1000.0 以上1000.0 以下の実数です。また、<var>n</var> は 3 以上 100 以下の整数です。 </p> <H2>Input</H2> <p> 複数のデータセットが与えられます。各データセットは以下のような形式です与えられます。 </p> <pre> <var>n</var> <var>x<sub>1</sub></var>, <var>y<sub>1</sub></var> <var>x<sub>2</sub></var>, <var>y<sub>2</sub></var> ... 　　　　 ... <var>x<sub>n</sub></var>, <var>y<sub>n</sub></var> </pre> <p> <var>n</var> が 0 の時、入力の最後を示します。データセットの数は 50 を超えません。 </p> <H2>Output</H2> <p> データセットごとに、ゴムと接していない釘の本数を出力してください。 例えば、図 3 に示す４つの釘を表す入力があった場合、図 4 のように囲まれるので、輪ゴムに接していない釘の本数は 1 本です。 </p> <center> <table> <tr> <td width="240"><img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_convex3"></td> <td width="240"><img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_convex4"></td> </tr> <tr> <td>図３</td> <td>図４</td> </tr> </table> </center> <br/> <H2>Sample Input</H2> <pre> 4 1.0,0.0 0.0,1.0 2.0,1.0 1.0,2.0 9 -509.94,892.63 567.62,639.99 -859.32,-64.84 -445.99,383.69 667.54,430.49 551.12,828.21 -940.2,-877.2 -361.62,-970 -125.42,-178.48 0 </pre> <H2>Output for the Sample Input</H2> <pre> 0 3 </pre> <H2>Hint</H2> <p> 以下は２つめのサンプル入力に対する図です。 </p> <center> <table> <tr> <td><img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_convex5"></td> </tr> <tr> </tr> </table> </center>
s345739703
p00068
Accepted
import sys import math class Point: def __init__(self, x, y): self.x = x self.y = y class Vector: def __init__(self, p1, p2): self.vx = p2.x - p1.x self.vy = p2.y - p1.y def length(self): return math.sqrt(self.vx ** 2.0 + self.vy ** 2.0) def degree(self, other): theta = math.acos((self.vx * other.vx + self.vy * other.vy)/(self.length() * other.length())) return theta def show(self): return "Vector(%f, %f)" % (self.vx, self.vy) def solv(points): p0 = points[0] for p in points[1:]: if p.y < p0.y: p0 = p v1 = Vector(Point(0.0, 0.0), Point(1.0, 0.0)) p1 = p0 t = [p1] while True: min_deg = math.pi next_p = None next_v = None points2 = list(points) points2.remove(p1) for p2 in points2: v2 = Vector(p1, p2) deg = v1.degree(v2) if deg < min_deg: min_deg = deg next_p = p2 next_v = v2 if next_p == p0: break p1 = next_p t.append(p1) v1 = next_v return len(points) - len(t) while True: n = int(sys.stdin.readline()) if n == 0: break points = [] for i in range(n): x, y = map(float, sys.stdin.readline().split(',')) points.append(Point(x, y)) print solv(points)
4 1.0,0.0 0.0,1.0 2.0,1.0 1.0,2.0 9 -509.94,892.63 567.62,639.99 -859.32,-64.84 -445.99,383.69 667.54,430.49 551.12,828.21 -940.2,-877.2 -361.62,-970 -125.42,-178.48 0
0 3
<H1>輪ゴム</H1> <p> <var>n</var> 本の釘を平板上の座標 <var>P<sub>1</sub></var> (<var>x<sub>1</sub></var>, <var>y</sub>1</sub></var>), <var>P<sub>2</sub></var> (<var>x<sub>2</sub></var>, <var>y<sub>2</sub></var>), <var>P<sub>3</sub></var> (<var>x<sub>3</sub></var>, <var>y<sub>3</sub></var>),..., <var>P<sub>n</sub></var> (<var>x<sub>n</sub></var>, <var>y<sub>n</sub></var>) に１本ずつ打ち、輪ゴムの輪の中に全ての釘が入るように 1 本の輪ゴムで囲みます。このとき、輪ゴムが交差してはいけません。 </p> <p> 釘の座標を読み込んで、上記のように釘を輪ゴムで囲んだときに輪ゴムに接していない釘の本数を出力するプログラムを作成してください。輪ゴムは充分に伸び縮みするものとします。同じ座標に 2 本以上の釘を打つことはないものとします。また、輪ゴムがかかった釘と釘の間は直線で結ばれるものとし、その直線上に 3 本以上の釘が並ぶことはないものとします。例えば、図 1 に示すような入力はありえません。図 2 に示すように輪ゴムがかかっていない釘が 1 直線上に並ぶことはありえます。 </p> <center> <table> <tr> <td width="240"><img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_convex1"></td> <td width="240"><img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_convex2"></td> </tr> <tr> <td>図１</td> <td>図２</td> </tr> </table> </center> <br/> <p> ただし、それぞれの座標値は -1000.0 以上1000.0 以下の実数です。また、<var>n</var> は 3 以上 100 以下の整数です。 </p> <H2>Input</H2> <p> 複数のデータセットが与えられます。各データセットは以下のような形式です与えられます。 </p> <pre> <var>n</var> <var>x<sub>1</sub></var>, <var>y<sub>1</sub></var> <var>x<sub>2</sub></var>, <var>y<sub>2</sub></var> ... 　　　　 ... <var>x<sub>n</sub></var>, <var>y<sub>n</sub></var> </pre> <p> <var>n</var> が 0 の時、入力の最後を示します。データセットの数は 50 を超えません。 </p> <H2>Output</H2> <p> データセットごとに、ゴムと接していない釘の本数を出力してください。 例えば、図 3 に示す４つの釘を表す入力があった場合、図 4 のように囲まれるので、輪ゴムに接していない釘の本数は 1 本です。 </p> <center> <table> <tr> <td width="240"><img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_convex3"></td> <td width="240"><img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_convex4"></td> </tr> <tr> <td>図３</td> <td>図４</td> </tr> </table> </center> <br/> <H2>Sample Input</H2> <pre> 4 1.0,0.0 0.0,1.0 2.0,1.0 1.0,2.0 9 -509.94,892.63 567.62,639.99 -859.32,-64.84 -445.99,383.69 667.54,430.49 551.12,828.21 -940.2,-877.2 -361.62,-970 -125.42,-178.48 0 </pre> <H2>Output for the Sample Input</H2> <pre> 0 3 </pre> <H2>Hint</H2> <p> 以下は２つめのサンプル入力に対する図です。 </p> <center> <table> <tr> <td><img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_convex5"></td> </tr> <tr> </tr> </table> </center>
s810968977
p00068
Accepted
#!/usr/bin/env python # -*- coding: utf-8 -*- from __future__ import (division, absolute_import, print_function, unicode_literals) from sys import stdin from math import copysign def gradient(p): def fn(t): dx = p[0] - t[0] dy = p[1] - t[1] if dx: return dy / dx return copysign(float('inf'), -dy) return fn def solve(n): L = [] for i in range(n): L.append(tuple(float(s) for s in stdin.readline().split(','))) L.sort() p = p0 = L.pop(0) while True: p = max((t for t in L if t[0] >= p[0]), key=gradient(p)) if p == L[-1]: break L.remove(p) p = p0 while True: p = min((t for t in L if t[0] >= p[0]), key=gradient(p)) if p == L[-1]: break L.remove(p) return len(L) - 1 while True: n = int(stdin.readline()) if not n: break print(solve(n))
4 1.0,0.0 0.0,1.0 2.0,1.0 1.0,2.0 9 -509.94,892.63 567.62,639.99 -859.32,-64.84 -445.99,383.69 667.54,430.49 551.12,828.21 -940.2,-877.2 -361.62,-970 -125.42,-178.48 0
0 3
<H1>輪ゴム</H1> <p> <var>n</var> 本の釘を平板上の座標 <var>P<sub>1</sub></var> (<var>x<sub>1</sub></var>, <var>y</sub>1</sub></var>), <var>P<sub>2</sub></var> (<var>x<sub>2</sub></var>, <var>y<sub>2</sub></var>), <var>P<sub>3</sub></var> (<var>x<sub>3</sub></var>, <var>y<sub>3</sub></var>),..., <var>P<sub>n</sub></var> (<var>x<sub>n</sub></var>, <var>y<sub>n</sub></var>) に１本ずつ打ち、輪ゴムの輪の中に全ての釘が入るように 1 本の輪ゴムで囲みます。このとき、輪ゴムが交差してはいけません。 </p> <p> 釘の座標を読み込んで、上記のように釘を輪ゴムで囲んだときに輪ゴムに接していない釘の本数を出力するプログラムを作成してください。輪ゴムは充分に伸び縮みするものとします。同じ座標に 2 本以上の釘を打つことはないものとします。また、輪ゴムがかかった釘と釘の間は直線で結ばれるものとし、その直線上に 3 本以上の釘が並ぶことはないものとします。例えば、図 1 に示すような入力はありえません。図 2 に示すように輪ゴムがかかっていない釘が 1 直線上に並ぶことはありえます。 </p> <center> <table> <tr> <td width="240"><img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_convex1"></td> <td width="240"><img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_convex2"></td> </tr> <tr> <td>図１</td> <td>図２</td> </tr> </table> </center> <br/> <p> ただし、それぞれの座標値は -1000.0 以上1000.0 以下の実数です。また、<var>n</var> は 3 以上 100 以下の整数です。 </p> <H2>Input</H2> <p> 複数のデータセットが与えられます。各データセットは以下のような形式です与えられます。 </p> <pre> <var>n</var> <var>x<sub>1</sub></var>, <var>y<sub>1</sub></var> <var>x<sub>2</sub></var>, <var>y<sub>2</sub></var> ... 　　　　 ... <var>x<sub>n</sub></var>, <var>y<sub>n</sub></var> </pre> <p> <var>n</var> が 0 の時、入力の最後を示します。データセットの数は 50 を超えません。 </p> <H2>Output</H2> <p> データセットごとに、ゴムと接していない釘の本数を出力してください。 例えば、図 3 に示す４つの釘を表す入力があった場合、図 4 のように囲まれるので、輪ゴムに接していない釘の本数は 1 本です。 </p> <center> <table> <tr> <td width="240"><img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_convex3"></td> <td width="240"><img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_convex4"></td> </tr> <tr> <td>図３</td> <td>図４</td> </tr> </table> </center> <br/> <H2>Sample Input</H2> <pre> 4 1.0,0.0 0.0,1.0 2.0,1.0 1.0,2.0 9 -509.94,892.63 567.62,639.99 -859.32,-64.84 -445.99,383.69 667.54,430.49 551.12,828.21 -940.2,-877.2 -361.62,-970 -125.42,-178.48 0 </pre> <H2>Output for the Sample Input</H2> <pre> 0 3 </pre> <H2>Hint</H2> <p> 以下は２つめのサンプル入力に対する図です。 </p> <center> <table> <tr> <td><img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_convex5"></td> </tr> <tr> </tr> </table> </center>
s546108945
p00068
Accepted
import sys def side(p1, p2, p3): y1,x1=p1 y2,x2=p2 y3,x3=p3 return (x3-x1)*(y2-y1)-(x2-x1)*(y3-y1)>0 while 1: n=input() if n==0:break D=[input() for i in range(n)] for p1 in D: c=0 for p2 in D: if p1==p2:continue f=[0,0] for p3 in D: if p1==p3 or p2==p3: continue f[side(p1,p2,p3)]+=1 if min(f)==0: n-=1 break print n
4 1.0,0.0 0.0,1.0 2.0,1.0 1.0,2.0 9 -509.94,892.63 567.62,639.99 -859.32,-64.84 -445.99,383.69 667.54,430.49 551.12,828.21 -940.2,-877.2 -361.62,-970 -125.42,-178.48 0
0 3
<H1>輪ゴム</H1> <p> <var>n</var> 本の釘を平板上の座標 <var>P<sub>1</sub></var> (<var>x<sub>1</sub></var>, <var>y</sub>1</sub></var>), <var>P<sub>2</sub></var> (<var>x<sub>2</sub></var>, <var>y<sub>2</sub></var>), <var>P<sub>3</sub></var> (<var>x<sub>3</sub></var>, <var>y<sub>3</sub></var>),..., <var>P<sub>n</sub></var> (<var>x<sub>n</sub></var>, <var>y<sub>n</sub></var>) に１本ずつ打ち、輪ゴムの輪の中に全ての釘が入るように 1 本の輪ゴムで囲みます。このとき、輪ゴムが交差してはいけません。 </p> <p> 釘の座標を読み込んで、上記のように釘を輪ゴムで囲んだときに輪ゴムに接していない釘の本数を出力するプログラムを作成してください。輪ゴムは充分に伸び縮みするものとします。同じ座標に 2 本以上の釘を打つことはないものとします。また、輪ゴムがかかった釘と釘の間は直線で結ばれるものとし、その直線上に 3 本以上の釘が並ぶことはないものとします。例えば、図 1 に示すような入力はありえません。図 2 に示すように輪ゴムがかかっていない釘が 1 直線上に並ぶことはありえます。 </p> <center> <table> <tr> <td width="240"><img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_convex1"></td> <td width="240"><img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_convex2"></td> </tr> <tr> <td>図１</td> <td>図２</td> </tr> </table> </center> <br/> <p> ただし、それぞれの座標値は -1000.0 以上1000.0 以下の実数です。また、<var>n</var> は 3 以上 100 以下の整数です。 </p> <H2>Input</H2> <p> 複数のデータセットが与えられます。各データセットは以下のような形式です与えられます。 </p> <pre> <var>n</var> <var>x<sub>1</sub></var>, <var>y<sub>1</sub></var> <var>x<sub>2</sub></var>, <var>y<sub>2</sub></var> ... 　　　　 ... <var>x<sub>n</sub></var>, <var>y<sub>n</sub></var> </pre> <p> <var>n</var> が 0 の時、入力の最後を示します。データセットの数は 50 を超えません。 </p> <H2>Output</H2> <p> データセットごとに、ゴムと接していない釘の本数を出力してください。 例えば、図 3 に示す４つの釘を表す入力があった場合、図 4 のように囲まれるので、輪ゴムに接していない釘の本数は 1 本です。 </p> <center> <table> <tr> <td width="240"><img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_convex3"></td> <td width="240"><img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_convex4"></td> </tr> <tr> <td>図３</td> <td>図４</td> </tr> </table> </center> <br/> <H2>Sample Input</H2> <pre> 4 1.0,0.0 0.0,1.0 2.0,1.0 1.0,2.0 9 -509.94,892.63 567.62,639.99 -859.32,-64.84 -445.99,383.69 667.54,430.49 551.12,828.21 -940.2,-877.2 -361.62,-970 -125.42,-178.48 0 </pre> <H2>Output for the Sample Input</H2> <pre> 0 3 </pre> <H2>Hint</H2> <p> 以下は２つめのサンプル入力に対する図です。 </p> <center> <table> <tr> <td><img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_convex5"></td> </tr> <tr> </tr> </table> </center>
s613372520
p00068
Accepted
import sys def side(p1, p2, p3): y1,x1=p1 y2,x2=p2 y3,x3=p3 return (x3-x1)*(y2-y1)-(x2-x1)*(y3-y1)>0 while 1: n=input() if n==0:break D=sorted([list(input()) for i in range(n)]) p1=D[0] D1=D[:] while True: c=0 for p2 in D1: if p1==p2:continue f=[0,0] for p3 in D: if p1==p3 or p2==p3: continue f[side(p1,p2,p3)]+=1 if f[0]==0:break p1=p2 D1.remove(p2) if p2==D[0]:break print len(D1)
4 1.0,0.0 0.0,1.0 2.0,1.0 1.0,2.0 9 -509.94,892.63 567.62,639.99 -859.32,-64.84 -445.99,383.69 667.54,430.49 551.12,828.21 -940.2,-877.2 -361.62,-970 -125.42,-178.48 0
0 3
<H1>輪ゴム</H1> <p> <var>n</var> 本の釘を平板上の座標 <var>P<sub>1</sub></var> (<var>x<sub>1</sub></var>, <var>y</sub>1</sub></var>), <var>P<sub>2</sub></var> (<var>x<sub>2</sub></var>, <var>y<sub>2</sub></var>), <var>P<sub>3</sub></var> (<var>x<sub>3</sub></var>, <var>y<sub>3</sub></var>),..., <var>P<sub>n</sub></var> (<var>x<sub>n</sub></var>, <var>y<sub>n</sub></var>) に１本ずつ打ち、輪ゴムの輪の中に全ての釘が入るように 1 本の輪ゴムで囲みます。このとき、輪ゴムが交差してはいけません。 </p> <p> 釘の座標を読み込んで、上記のように釘を輪ゴムで囲んだときに輪ゴムに接していない釘の本数を出力するプログラムを作成してください。輪ゴムは充分に伸び縮みするものとします。同じ座標に 2 本以上の釘を打つことはないものとします。また、輪ゴムがかかった釘と釘の間は直線で結ばれるものとし、その直線上に 3 本以上の釘が並ぶことはないものとします。例えば、図 1 に示すような入力はありえません。図 2 に示すように輪ゴムがかかっていない釘が 1 直線上に並ぶことはありえます。 </p> <center> <table> <tr> <td width="240"><img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_convex1"></td> <td width="240"><img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_convex2"></td> </tr> <tr> <td>図１</td> <td>図２</td> </tr> </table> </center> <br/> <p> ただし、それぞれの座標値は -1000.0 以上1000.0 以下の実数です。また、<var>n</var> は 3 以上 100 以下の整数です。 </p> <H2>Input</H2> <p> 複数のデータセットが与えられます。各データセットは以下のような形式です与えられます。 </p> <pre> <var>n</var> <var>x<sub>1</sub></var>, <var>y<sub>1</sub></var> <var>x<sub>2</sub></var>, <var>y<sub>2</sub></var> ... 　　　　 ... <var>x<sub>n</sub></var>, <var>y<sub>n</sub></var> </pre> <p> <var>n</var> が 0 の時、入力の最後を示します。データセットの数は 50 を超えません。 </p> <H2>Output</H2> <p> データセットごとに、ゴムと接していない釘の本数を出力してください。 例えば、図 3 に示す４つの釘を表す入力があった場合、図 4 のように囲まれるので、輪ゴムに接していない釘の本数は 1 本です。 </p> <center> <table> <tr> <td width="240"><img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_convex3"></td> <td width="240"><img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_convex4"></td> </tr> <tr> <td>図３</td> <td>図４</td> </tr> </table> </center> <br/> <H2>Sample Input</H2> <pre> 4 1.0,0.0 0.0,1.0 2.0,1.0 1.0,2.0 9 -509.94,892.63 567.62,639.99 -859.32,-64.84 -445.99,383.69 667.54,430.49 551.12,828.21 -940.2,-877.2 -361.62,-970 -125.42,-178.48 0 </pre> <H2>Output for the Sample Input</H2> <pre> 0 3 </pre> <H2>Hint</H2> <p> 以下は２つめのサンプル入力に対する図です。 </p> <center> <table> <tr> <td><img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_convex5"></td> </tr> <tr> </tr> </table> </center>
s755057489
p00068
Accepted
import sys def side(p1, p2, p3): y1,x1=p1 y2,x2=p2 y3,x3=p3 return (x3-x1)*(y2-y1)-(x2-x1)*(y3-y1)>0 while 1: n=input() if n==0:break D=sorted([list(input()) for i in range(n)]) p1=D[0] D1=D[:] while True: c=0 for p2 in D1: if p1==p2:continue f=[0,0] for p3 in D[::-1]: if p1==p3 or p2==p3: continue f[side(p1,p2,p3)]+=1 if f[0]==0:break p1=p2 D1.remove(p2) if p2==D[0]:break print len(D1)
4 1.0,0.0 0.0,1.0 2.0,1.0 1.0,2.0 9 -509.94,892.63 567.62,639.99 -859.32,-64.84 -445.99,383.69 667.54,430.49 551.12,828.21 -940.2,-877.2 -361.62,-970 -125.42,-178.48 0
0 3
<H1>輪ゴム</H1> <p> <var>n</var> 本の釘を平板上の座標 <var>P<sub>1</sub></var> (<var>x<sub>1</sub></var>, <var>y</sub>1</sub></var>), <var>P<sub>2</sub></var> (<var>x<sub>2</sub></var>, <var>y<sub>2</sub></var>), <var>P<sub>3</sub></var> (<var>x<sub>3</sub></var>, <var>y<sub>3</sub></var>),..., <var>P<sub>n</sub></var> (<var>x<sub>n</sub></var>, <var>y<sub>n</sub></var>) に１本ずつ打ち、輪ゴムの輪の中に全ての釘が入るように 1 本の輪ゴムで囲みます。このとき、輪ゴムが交差してはいけません。 </p> <p> 釘の座標を読み込んで、上記のように釘を輪ゴムで囲んだときに輪ゴムに接していない釘の本数を出力するプログラムを作成してください。輪ゴムは充分に伸び縮みするものとします。同じ座標に 2 本以上の釘を打つことはないものとします。また、輪ゴムがかかった釘と釘の間は直線で結ばれるものとし、その直線上に 3 本以上の釘が並ぶことはないものとします。例えば、図 1 に示すような入力はありえません。図 2 に示すように輪ゴムがかかっていない釘が 1 直線上に並ぶことはありえます。 </p> <center> <table> <tr> <td width="240"><img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_convex1"></td> <td width="240"><img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_convex2"></td> </tr> <tr> <td>図１</td> <td>図２</td> </tr> </table> </center> <br/> <p> ただし、それぞれの座標値は -1000.0 以上1000.0 以下の実数です。また、<var>n</var> は 3 以上 100 以下の整数です。 </p> <H2>Input</H2> <p> 複数のデータセットが与えられます。各データセットは以下のような形式です与えられます。 </p> <pre> <var>n</var> <var>x<sub>1</sub></var>, <var>y<sub>1</sub></var> <var>x<sub>2</sub></var>, <var>y<sub>2</sub></var> ... 　　　　 ... <var>x<sub>n</sub></var>, <var>y<sub>n</sub></var> </pre> <p> <var>n</var> が 0 の時、入力の最後を示します。データセットの数は 50 を超えません。 </p> <H2>Output</H2> <p> データセットごとに、ゴムと接していない釘の本数を出力してください。 例えば、図 3 に示す４つの釘を表す入力があった場合、図 4 のように囲まれるので、輪ゴムに接していない釘の本数は 1 本です。 </p> <center> <table> <tr> <td width="240"><img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_convex3"></td> <td width="240"><img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_convex4"></td> </tr> <tr> <td>図３</td> <td>図４</td> </tr> </table> </center> <br/> <H2>Sample Input</H2> <pre> 4 1.0,0.0 0.0,1.0 2.0,1.0 1.0,2.0 9 -509.94,892.63 567.62,639.99 -859.32,-64.84 -445.99,383.69 667.54,430.49 551.12,828.21 -940.2,-877.2 -361.62,-970 -125.42,-178.48 0 </pre> <H2>Output for the Sample Input</H2> <pre> 0 3 </pre> <H2>Hint</H2> <p> 以下は２つめのサンプル入力に対する図です。 </p> <center> <table> <tr> <td><img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_convex5"></td> </tr> <tr> </tr> </table> </center>
s103941281
p00068
Accepted
import sys def side(p1, p2, p3): y1,x1=p1 y2,x2=p2 y3,x3=p3 return (x3-x1)*(y2-y1)-(x2-x1)*(y3-y1)>0 while 1: n=input() if n==0:break D=sorted([list(input()) for i in range(n)]) p1=D[0] D1=D[:] while True: for p2 in D1: if p1==p2:continue for p3 in D[::-1]: if p1==p3 or p2==p3: continue if side(p1,p2,p3)==0:break else:break p1=p2 D1.remove(p2) if p2==D[0]:break print len(D1)
4 1.0,0.0 0.0,1.0 2.0,1.0 1.0,2.0 9 -509.94,892.63 567.62,639.99 -859.32,-64.84 -445.99,383.69 667.54,430.49 551.12,828.21 -940.2,-877.2 -361.62,-970 -125.42,-178.48 0
0 3
<H1>輪ゴム</H1> <p> <var>n</var> 本の釘を平板上の座標 <var>P<sub>1</sub></var> (<var>x<sub>1</sub></var>, <var>y</sub>1</sub></var>), <var>P<sub>2</sub></var> (<var>x<sub>2</sub></var>, <var>y<sub>2</sub></var>), <var>P<sub>3</sub></var> (<var>x<sub>3</sub></var>, <var>y<sub>3</sub></var>),..., <var>P<sub>n</sub></var> (<var>x<sub>n</sub></var>, <var>y<sub>n</sub></var>) に１本ずつ打ち、輪ゴムの輪の中に全ての釘が入るように 1 本の輪ゴムで囲みます。このとき、輪ゴムが交差してはいけません。 </p> <p> 釘の座標を読み込んで、上記のように釘を輪ゴムで囲んだときに輪ゴムに接していない釘の本数を出力するプログラムを作成してください。輪ゴムは充分に伸び縮みするものとします。同じ座標に 2 本以上の釘を打つことはないものとします。また、輪ゴムがかかった釘と釘の間は直線で結ばれるものとし、その直線上に 3 本以上の釘が並ぶことはないものとします。例えば、図 1 に示すような入力はありえません。図 2 に示すように輪ゴムがかかっていない釘が 1 直線上に並ぶことはありえます。 </p> <center> <table> <tr> <td width="240"><img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_convex1"></td> <td width="240"><img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_convex2"></td> </tr> <tr> <td>図１</td> <td>図２</td> </tr> </table> </center> <br/> <p> ただし、それぞれの座標値は -1000.0 以上1000.0 以下の実数です。また、<var>n</var> は 3 以上 100 以下の整数です。 </p> <H2>Input</H2> <p> 複数のデータセットが与えられます。各データセットは以下のような形式です与えられます。 </p> <pre> <var>n</var> <var>x<sub>1</sub></var>, <var>y<sub>1</sub></var> <var>x<sub>2</sub></var>, <var>y<sub>2</sub></var> ... 　　　　 ... <var>x<sub>n</sub></var>, <var>y<sub>n</sub></var> </pre> <p> <var>n</var> が 0 の時、入力の最後を示します。データセットの数は 50 を超えません。 </p> <H2>Output</H2> <p> データセットごとに、ゴムと接していない釘の本数を出力してください。 例えば、図 3 に示す４つの釘を表す入力があった場合、図 4 のように囲まれるので、輪ゴムに接していない釘の本数は 1 本です。 </p> <center> <table> <tr> <td width="240"><img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_convex3"></td> <td width="240"><img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_convex4"></td> </tr> <tr> <td>図３</td> <td>図４</td> </tr> </table> </center> <br/> <H2>Sample Input</H2> <pre> 4 1.0,0.0 0.0,1.0 2.0,1.0 1.0,2.0 9 -509.94,892.63 567.62,639.99 -859.32,-64.84 -445.99,383.69 667.54,430.49 551.12,828.21 -940.2,-877.2 -361.62,-970 -125.42,-178.48 0 </pre> <H2>Output for the Sample Input</H2> <pre> 0 3 </pre> <H2>Hint</H2> <p> 以下は２つめのサンプル入力に対する図です。 </p> <center> <table> <tr> <td><img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_convex5"></td> </tr> <tr> </tr> </table> </center>
s994927518
p00068
Accepted
import sys def side(p1,p2): global D y1,x1=p1 y2,x2=p2 dy=y2-y1 dx=x2-x1 for p3 in D[::-1]: if p1==p3 or p2==p3:continue y3,x3=p3 if (x3-x1)*dy-dx*(y3-y1)<0:return 0 else:return 1 while 1: n=input() if n==0:break D=sorted([list(input()) for i in range(n)]) p=p1=D[0] D1=D[:] while True: for p2 in D1: if p1!=p2 and side(p1,p2):break p1=p2 D1.remove(p2) if p2==p:break print len(D1)
4 1.0,0.0 0.0,1.0 2.0,1.0 1.0,2.0 9 -509.94,892.63 567.62,639.99 -859.32,-64.84 -445.99,383.69 667.54,430.49 551.12,828.21 -940.2,-877.2 -361.62,-970 -125.42,-178.48 0
0 3
<H1>輪ゴム</H1> <p> <var>n</var> 本の釘を平板上の座標 <var>P<sub>1</sub></var> (<var>x<sub>1</sub></var>, <var>y</sub>1</sub></var>), <var>P<sub>2</sub></var> (<var>x<sub>2</sub></var>, <var>y<sub>2</sub></var>), <var>P<sub>3</sub></var> (<var>x<sub>3</sub></var>, <var>y<sub>3</sub></var>),..., <var>P<sub>n</sub></var> (<var>x<sub>n</sub></var>, <var>y<sub>n</sub></var>) に１本ずつ打ち、輪ゴムの輪の中に全ての釘が入るように 1 本の輪ゴムで囲みます。このとき、輪ゴムが交差してはいけません。 </p> <p> 釘の座標を読み込んで、上記のように釘を輪ゴムで囲んだときに輪ゴムに接していない釘の本数を出力するプログラムを作成してください。輪ゴムは充分に伸び縮みするものとします。同じ座標に 2 本以上の釘を打つことはないものとします。また、輪ゴムがかかった釘と釘の間は直線で結ばれるものとし、その直線上に 3 本以上の釘が並ぶことはないものとします。例えば、図 1 に示すような入力はありえません。図 2 に示すように輪ゴムがかかっていない釘が 1 直線上に並ぶことはありえます。 </p> <center> <table> <tr> <td width="240"><img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_convex1"></td> <td width="240"><img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_convex2"></td> </tr> <tr> <td>図１</td> <td>図２</td> </tr> </table> </center> <br/> <p> ただし、それぞれの座標値は -1000.0 以上1000.0 以下の実数です。また、<var>n</var> は 3 以上 100 以下の整数です。 </p> <H2>Input</H2> <p> 複数のデータセットが与えられます。各データセットは以下のような形式です与えられます。 </p> <pre> <var>n</var> <var>x<sub>1</sub></var>, <var>y<sub>1</sub></var> <var>x<sub>2</sub></var>, <var>y<sub>2</sub></var> ... 　　　　 ... <var>x<sub>n</sub></var>, <var>y<sub>n</sub></var> </pre> <p> <var>n</var> が 0 の時、入力の最後を示します。データセットの数は 50 を超えません。 </p> <H2>Output</H2> <p> データセットごとに、ゴムと接していない釘の本数を出力してください。 例えば、図 3 に示す４つの釘を表す入力があった場合、図 4 のように囲まれるので、輪ゴムに接していない釘の本数は 1 本です。 </p> <center> <table> <tr> <td width="240"><img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_convex3"></td> <td width="240"><img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_convex4"></td> </tr> <tr> <td>図３</td> <td>図４</td> </tr> </table> </center> <br/> <H2>Sample Input</H2> <pre> 4 1.0,0.0 0.0,1.0 2.0,1.0 1.0,2.0 9 -509.94,892.63 567.62,639.99 -859.32,-64.84 -445.99,383.69 667.54,430.49 551.12,828.21 -940.2,-877.2 -361.62,-970 -125.42,-178.48 0 </pre> <H2>Output for the Sample Input</H2> <pre> 0 3 </pre> <H2>Hint</H2> <p> 以下は２つめのサンプル入力に対する図です。 </p> <center> <table> <tr> <td><img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_convex5"></td> </tr> <tr> </tr> </table> </center>
s732747888
p00068
Accepted
import sys def side(p1,p2): global D y1,x1=p1 dy=p2[0]-y1 dx=p2[1]-x1 for p3 in D[::-1]: if p1==p3 or p2==p3:pass elif (p3[1]-x1)*dy-dx*(p3[0]-y1)<0:return 0 else:return 1 while 1: n=input() if n==0:break D=sorted([list(input()) for i in range(n)]) p=p1=D[0] D1=D[:] while True: for p2 in D1: if p1!=p2 and side(p1,p2):break p1=p2 D1.remove(p2) if p2==p:break print len(D1)
4 1.0,0.0 0.0,1.0 2.0,1.0 1.0,2.0 9 -509.94,892.63 567.62,639.99 -859.32,-64.84 -445.99,383.69 667.54,430.49 551.12,828.21 -940.2,-877.2 -361.62,-970 -125.42,-178.48 0
0 3
<H1>輪ゴム</H1> <p> <var>n</var> 本の釘を平板上の座標 <var>P<sub>1</sub></var> (<var>x<sub>1</sub></var>, <var>y</sub>1</sub></var>), <var>P<sub>2</sub></var> (<var>x<sub>2</sub></var>, <var>y<sub>2</sub></var>), <var>P<sub>3</sub></var> (<var>x<sub>3</sub></var>, <var>y<sub>3</sub></var>),..., <var>P<sub>n</sub></var> (<var>x<sub>n</sub></var>, <var>y<sub>n</sub></var>) に１本ずつ打ち、輪ゴムの輪の中に全ての釘が入るように 1 本の輪ゴムで囲みます。このとき、輪ゴムが交差してはいけません。 </p> <p> 釘の座標を読み込んで、上記のように釘を輪ゴムで囲んだときに輪ゴムに接していない釘の本数を出力するプログラムを作成してください。輪ゴムは充分に伸び縮みするものとします。同じ座標に 2 本以上の釘を打つことはないものとします。また、輪ゴムがかかった釘と釘の間は直線で結ばれるものとし、その直線上に 3 本以上の釘が並ぶことはないものとします。例えば、図 1 に示すような入力はありえません。図 2 に示すように輪ゴムがかかっていない釘が 1 直線上に並ぶことはありえます。 </p> <center> <table> <tr> <td width="240"><img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_convex1"></td> <td width="240"><img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_convex2"></td> </tr> <tr> <td>図１</td> <td>図２</td> </tr> </table> </center> <br/> <p> ただし、それぞれの座標値は -1000.0 以上1000.0 以下の実数です。また、<var>n</var> は 3 以上 100 以下の整数です。 </p> <H2>Input</H2> <p> 複数のデータセットが与えられます。各データセットは以下のような形式です与えられます。 </p> <pre> <var>n</var> <var>x<sub>1</sub></var>, <var>y<sub>1</sub></var> <var>x<sub>2</sub></var>, <var>y<sub>2</sub></var> ... 　　　　 ... <var>x<sub>n</sub></var>, <var>y<sub>n</sub></var> </pre> <p> <var>n</var> が 0 の時、入力の最後を示します。データセットの数は 50 を超えません。 </p> <H2>Output</H2> <p> データセットごとに、ゴムと接していない釘の本数を出力してください。 例えば、図 3 に示す４つの釘を表す入力があった場合、図 4 のように囲まれるので、輪ゴムに接していない釘の本数は 1 本です。 </p> <center> <table> <tr> <td width="240"><img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_convex3"></td> <td width="240"><img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_convex4"></td> </tr> <tr> <td>図３</td> <td>図４</td> </tr> </table> </center> <br/> <H2>Sample Input</H2> <pre> 4 1.0,0.0 0.0,1.0 2.0,1.0 1.0,2.0 9 -509.94,892.63 567.62,639.99 -859.32,-64.84 -445.99,383.69 667.54,430.49 551.12,828.21 -940.2,-877.2 -361.62,-970 -125.42,-178.48 0 </pre> <H2>Output for the Sample Input</H2> <pre> 0 3 </pre> <H2>Hint</H2> <p> 以下は２つめのサンプル入力に対する図です。 </p> <center> <table> <tr> <td><img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_convex5"></td> </tr> <tr> </tr> </table> </center>
s161513872
p00068
Accepted
import sys def side(p1,p2): global D y1,x1=p1 y2,x2=p2 dy=y2-y1 dx=x2-x1 for p3 in D[::-1]: if p1==p3 or p2==p3:pass elif (p3[1]-x1)*dy-dx*(p3[0]-y1)<0:return 0 else:return 1 while 1: n=input() if n==0:break D=sorted([list(input()) for i in range(n)]) p=p1=D[0] D1=D[:] while True: for p2 in D1: if p1!=p2 and side(p1,p2):break p1=p2 D1.remove(p2) if p2==p:break print len(D1)
4 1.0,0.0 0.0,1.0 2.0,1.0 1.0,2.0 9 -509.94,892.63 567.62,639.99 -859.32,-64.84 -445.99,383.69 667.54,430.49 551.12,828.21 -940.2,-877.2 -361.62,-970 -125.42,-178.48 0
0 3
<H1>輪ゴム</H1> <p> <var>n</var> 本の釘を平板上の座標 <var>P<sub>1</sub></var> (<var>x<sub>1</sub></var>, <var>y</sub>1</sub></var>), <var>P<sub>2</sub></var> (<var>x<sub>2</sub></var>, <var>y<sub>2</sub></var>), <var>P<sub>3</sub></var> (<var>x<sub>3</sub></var>, <var>y<sub>3</sub></var>),..., <var>P<sub>n</sub></var> (<var>x<sub>n</sub></var>, <var>y<sub>n</sub></var>) に１本ずつ打ち、輪ゴムの輪の中に全ての釘が入るように 1 本の輪ゴムで囲みます。このとき、輪ゴムが交差してはいけません。 </p> <p> 釘の座標を読み込んで、上記のように釘を輪ゴムで囲んだときに輪ゴムに接していない釘の本数を出力するプログラムを作成してください。輪ゴムは充分に伸び縮みするものとします。同じ座標に 2 本以上の釘を打つことはないものとします。また、輪ゴムがかかった釘と釘の間は直線で結ばれるものとし、その直線上に 3 本以上の釘が並ぶことはないものとします。例えば、図 1 に示すような入力はありえません。図 2 に示すように輪ゴムがかかっていない釘が 1 直線上に並ぶことはありえます。 </p> <center> <table> <tr> <td width="240"><img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_convex1"></td> <td width="240"><img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_convex2"></td> </tr> <tr> <td>図１</td> <td>図２</td> </tr> </table> </center> <br/> <p> ただし、それぞれの座標値は -1000.0 以上1000.0 以下の実数です。また、<var>n</var> は 3 以上 100 以下の整数です。 </p> <H2>Input</H2> <p> 複数のデータセットが与えられます。各データセットは以下のような形式です与えられます。 </p> <pre> <var>n</var> <var>x<sub>1</sub></var>, <var>y<sub>1</sub></var> <var>x<sub>2</sub></var>, <var>y<sub>2</sub></var> ... 　　　　 ... <var>x<sub>n</sub></var>, <var>y<sub>n</sub></var> </pre> <p> <var>n</var> が 0 の時、入力の最後を示します。データセットの数は 50 を超えません。 </p> <H2>Output</H2> <p> データセットごとに、ゴムと接していない釘の本数を出力してください。 例えば、図 3 に示す４つの釘を表す入力があった場合、図 4 のように囲まれるので、輪ゴムに接していない釘の本数は 1 本です。 </p> <center> <table> <tr> <td width="240"><img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_convex3"></td> <td width="240"><img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_convex4"></td> </tr> <tr> <td>図３</td> <td>図４</td> </tr> </table> </center> <br/> <H2>Sample Input</H2> <pre> 4 1.0,0.0 0.0,1.0 2.0,1.0 1.0,2.0 9 -509.94,892.63 567.62,639.99 -859.32,-64.84 -445.99,383.69 667.54,430.49 551.12,828.21 -940.2,-877.2 -361.62,-970 -125.42,-178.48 0 </pre> <H2>Output for the Sample Input</H2> <pre> 0 3 </pre> <H2>Hint</H2> <p> 以下は２つめのサンプル入力に対する図です。 </p> <center> <table> <tr> <td><img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_convex5"></td> </tr> <tr> </tr> </table> </center>
s183879674
p00068
Accepted
import sys def side(p1,p2): global D y1,x1=p1 y2,x2=p2 dy=y2-y1 dx=x2-x1 for p3 in D[::-1]: y3,x3=p3 if p1==p3 or p2==p3:pass elif (x3-x1)*dy-dx*(y3-y1)<0:return 0 else:return 1 while 1: n=input() if n==0:break D=sorted([list(input()) for i in range(n)]) p=p1=D[0] D1=D[:] while True: for p2 in D1: if p1!=p2 and side(p1,p2):break p1=p2 D1.remove(p2) if p2==p:break print len(D1)
4 1.0,0.0 0.0,1.0 2.0,1.0 1.0,2.0 9 -509.94,892.63 567.62,639.99 -859.32,-64.84 -445.99,383.69 667.54,430.49 551.12,828.21 -940.2,-877.2 -361.62,-970 -125.42,-178.48 0
0 3
<H1>輪ゴム</H1> <p> <var>n</var> 本の釘を平板上の座標 <var>P<sub>1</sub></var> (<var>x<sub>1</sub></var>, <var>y</sub>1</sub></var>), <var>P<sub>2</sub></var> (<var>x<sub>2</sub></var>, <var>y<sub>2</sub></var>), <var>P<sub>3</sub></var> (<var>x<sub>3</sub></var>, <var>y<sub>3</sub></var>),..., <var>P<sub>n</sub></var> (<var>x<sub>n</sub></var>, <var>y<sub>n</sub></var>) に１本ずつ打ち、輪ゴムの輪の中に全ての釘が入るように 1 本の輪ゴムで囲みます。このとき、輪ゴムが交差してはいけません。 </p> <p> 釘の座標を読み込んで、上記のように釘を輪ゴムで囲んだときに輪ゴムに接していない釘の本数を出力するプログラムを作成してください。輪ゴムは充分に伸び縮みするものとします。同じ座標に 2 本以上の釘を打つことはないものとします。また、輪ゴムがかかった釘と釘の間は直線で結ばれるものとし、その直線上に 3 本以上の釘が並ぶことはないものとします。例えば、図 1 に示すような入力はありえません。図 2 に示すように輪ゴムがかかっていない釘が 1 直線上に並ぶことはありえます。 </p> <center> <table> <tr> <td width="240"><img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_convex1"></td> <td width="240"><img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_convex2"></td> </tr> <tr> <td>図１</td> <td>図２</td> </tr> </table> </center> <br/> <p> ただし、それぞれの座標値は -1000.0 以上1000.0 以下の実数です。また、<var>n</var> は 3 以上 100 以下の整数です。 </p> <H2>Input</H2> <p> 複数のデータセットが与えられます。各データセットは以下のような形式です与えられます。 </p> <pre> <var>n</var> <var>x<sub>1</sub></var>, <var>y<sub>1</sub></var> <var>x<sub>2</sub></var>, <var>y<sub>2</sub></var> ... 　　　　 ... <var>x<sub>n</sub></var>, <var>y<sub>n</sub></var> </pre> <p> <var>n</var> が 0 の時、入力の最後を示します。データセットの数は 50 を超えません。 </p> <H2>Output</H2> <p> データセットごとに、ゴムと接していない釘の本数を出力してください。 例えば、図 3 に示す４つの釘を表す入力があった場合、図 4 のように囲まれるので、輪ゴムに接していない釘の本数は 1 本です。 </p> <center> <table> <tr> <td width="240"><img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_convex3"></td> <td width="240"><img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_convex4"></td> </tr> <tr> <td>図３</td> <td>図４</td> </tr> </table> </center> <br/> <H2>Sample Input</H2> <pre> 4 1.0,0.0 0.0,1.0 2.0,1.0 1.0,2.0 9 -509.94,892.63 567.62,639.99 -859.32,-64.84 -445.99,383.69 667.54,430.49 551.12,828.21 -940.2,-877.2 -361.62,-970 -125.42,-178.48 0 </pre> <H2>Output for the Sample Input</H2> <pre> 0 3 </pre> <H2>Hint</H2> <p> 以下は２つめのサンプル入力に対する図です。 </p> <center> <table> <tr> <td><img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_convex5"></td> </tr> <tr> </tr> </table> </center>
s337320177
p00068
Accepted
import sys def side(p1,p2): global D y1,x1=p1 y2,x2=p2 dy=y2-y1 dx=x2-x1 for p3 in D[::-1]: y3,x3=p3 if p1==p3 or p2==p3:continue if (x3-x1)*dy-dx*(y3-y1)<0:return 0 else:return 1 while 1: n=input() if n==0:break D=sorted([list(input()) for i in range(n)]) p=p1=D[0] D1=D[:] while True: for p2 in D1: if p1!=p2 and side(p1,p2):break p1=p2 D1.remove(p2) if p2==p:break print len(D1)
4 1.0,0.0 0.0,1.0 2.0,1.0 1.0,2.0 9 -509.94,892.63 567.62,639.99 -859.32,-64.84 -445.99,383.69 667.54,430.49 551.12,828.21 -940.2,-877.2 -361.62,-970 -125.42,-178.48 0
0 3
<H1>輪ゴム</H1> <p> <var>n</var> 本の釘を平板上の座標 <var>P<sub>1</sub></var> (<var>x<sub>1</sub></var>, <var>y</sub>1</sub></var>), <var>P<sub>2</sub></var> (<var>x<sub>2</sub></var>, <var>y<sub>2</sub></var>), <var>P<sub>3</sub></var> (<var>x<sub>3</sub></var>, <var>y<sub>3</sub></var>),..., <var>P<sub>n</sub></var> (<var>x<sub>n</sub></var>, <var>y<sub>n</sub></var>) に１本ずつ打ち、輪ゴムの輪の中に全ての釘が入るように 1 本の輪ゴムで囲みます。このとき、輪ゴムが交差してはいけません。 </p> <p> 釘の座標を読み込んで、上記のように釘を輪ゴムで囲んだときに輪ゴムに接していない釘の本数を出力するプログラムを作成してください。輪ゴムは充分に伸び縮みするものとします。同じ座標に 2 本以上の釘を打つことはないものとします。また、輪ゴムがかかった釘と釘の間は直線で結ばれるものとし、その直線上に 3 本以上の釘が並ぶことはないものとします。例えば、図 1 に示すような入力はありえません。図 2 に示すように輪ゴムがかかっていない釘が 1 直線上に並ぶことはありえます。 </p> <center> <table> <tr> <td width="240"><img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_convex1"></td> <td width="240"><img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_convex2"></td> </tr> <tr> <td>図１</td> <td>図２</td> </tr> </table> </center> <br/> <p> ただし、それぞれの座標値は -1000.0 以上1000.0 以下の実数です。また、<var>n</var> は 3 以上 100 以下の整数です。 </p> <H2>Input</H2> <p> 複数のデータセットが与えられます。各データセットは以下のような形式です与えられます。 </p> <pre> <var>n</var> <var>x<sub>1</sub></var>, <var>y<sub>1</sub></var> <var>x<sub>2</sub></var>, <var>y<sub>2</sub></var> ... 　　　　 ... <var>x<sub>n</sub></var>, <var>y<sub>n</sub></var> </pre> <p> <var>n</var> が 0 の時、入力の最後を示します。データセットの数は 50 を超えません。 </p> <H2>Output</H2> <p> データセットごとに、ゴムと接していない釘の本数を出力してください。 例えば、図 3 に示す４つの釘を表す入力があった場合、図 4 のように囲まれるので、輪ゴムに接していない釘の本数は 1 本です。 </p> <center> <table> <tr> <td width="240"><img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_convex3"></td> <td width="240"><img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_convex4"></td> </tr> <tr> <td>図３</td> <td>図４</td> </tr> </table> </center> <br/> <H2>Sample Input</H2> <pre> 4 1.0,0.0 0.0,1.0 2.0,1.0 1.0,2.0 9 -509.94,892.63 567.62,639.99 -859.32,-64.84 -445.99,383.69 667.54,430.49 551.12,828.21 -940.2,-877.2 -361.62,-970 -125.42,-178.48 0 </pre> <H2>Output for the Sample Input</H2> <pre> 0 3 </pre> <H2>Hint</H2> <p> 以下は２つめのサンプル入力に対する図です。 </p> <center> <table> <tr> <td><img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_convex5"></td> </tr> <tr> </tr> </table> </center>
s956526003
p00068
Accepted
import sys def side(p1,p2): global D y1,x1=p1 y2,x2=p2 dy=y2-y1 dx=x2-x1 for p3 in D[::-1]: if p1==p3 or p2==p3:continue if (p3[1]-x1)*dy-dx*(p3[0]-y1)<0:return 0 else:return 1 while 1: n=input() if n==0:break D=sorted([list(input()) for i in range(n)]) p=p1=D[0] D1=D[:] while True: for p2 in D1: if p1!=p2 and side(p1,p2):break p1=p2 D1.remove(p2) if p2==p:break print len(D1)
4 1.0,0.0 0.0,1.0 2.0,1.0 1.0,2.0 9 -509.94,892.63 567.62,639.99 -859.32,-64.84 -445.99,383.69 667.54,430.49 551.12,828.21 -940.2,-877.2 -361.62,-970 -125.42,-178.48 0
0 3
<H1>輪ゴム</H1> <p> <var>n</var> 本の釘を平板上の座標 <var>P<sub>1</sub></var> (<var>x<sub>1</sub></var>, <var>y</sub>1</sub></var>), <var>P<sub>2</sub></var> (<var>x<sub>2</sub></var>, <var>y<sub>2</sub></var>), <var>P<sub>3</sub></var> (<var>x<sub>3</sub></var>, <var>y<sub>3</sub></var>),..., <var>P<sub>n</sub></var> (<var>x<sub>n</sub></var>, <var>y<sub>n</sub></var>) に１本ずつ打ち、輪ゴムの輪の中に全ての釘が入るように 1 本の輪ゴムで囲みます。このとき、輪ゴムが交差してはいけません。 </p> <p> 釘の座標を読み込んで、上記のように釘を輪ゴムで囲んだときに輪ゴムに接していない釘の本数を出力するプログラムを作成してください。輪ゴムは充分に伸び縮みするものとします。同じ座標に 2 本以上の釘を打つことはないものとします。また、輪ゴムがかかった釘と釘の間は直線で結ばれるものとし、その直線上に 3 本以上の釘が並ぶことはないものとします。例えば、図 1 に示すような入力はありえません。図 2 に示すように輪ゴムがかかっていない釘が 1 直線上に並ぶことはありえます。 </p> <center> <table> <tr> <td width="240"><img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_convex1"></td> <td width="240"><img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_convex2"></td> </tr> <tr> <td>図１</td> <td>図２</td> </tr> </table> </center> <br/> <p> ただし、それぞれの座標値は -1000.0 以上1000.0 以下の実数です。また、<var>n</var> は 3 以上 100 以下の整数です。 </p> <H2>Input</H2> <p> 複数のデータセットが与えられます。各データセットは以下のような形式です与えられます。 </p> <pre> <var>n</var> <var>x<sub>1</sub></var>, <var>y<sub>1</sub></var> <var>x<sub>2</sub></var>, <var>y<sub>2</sub></var> ... 　　　　 ... <var>x<sub>n</sub></var>, <var>y<sub>n</sub></var> </pre> <p> <var>n</var> が 0 の時、入力の最後を示します。データセットの数は 50 を超えません。 </p> <H2>Output</H2> <p> データセットごとに、ゴムと接していない釘の本数を出力してください。 例えば、図 3 に示す４つの釘を表す入力があった場合、図 4 のように囲まれるので、輪ゴムに接していない釘の本数は 1 本です。 </p> <center> <table> <tr> <td width="240"><img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_convex3"></td> <td width="240"><img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_convex4"></td> </tr> <tr> <td>図３</td> <td>図４</td> </tr> </table> </center> <br/> <H2>Sample Input</H2> <pre> 4 1.0,0.0 0.0,1.0 2.0,1.0 1.0,2.0 9 -509.94,892.63 567.62,639.99 -859.32,-64.84 -445.99,383.69 667.54,430.49 551.12,828.21 -940.2,-877.2 -361.62,-970 -125.42,-178.48 0 </pre> <H2>Output for the Sample Input</H2> <pre> 0 3 </pre> <H2>Hint</H2> <p> 以下は２つめのサンプル入力に対する図です。 </p> <center> <table> <tr> <td><img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_convex5"></td> </tr> <tr> </tr> </table> </center>
s782930907
p00068
Accepted
import sys def side(p1,p2): global D y1,x1=p1 y2,x2=p2 dy=y2-y1 dx=x2-x1 for p3 in D: if p1!=p3 and p2!=p3 and (p3[1]-x1)*dy-dx*(p3[0]-y1)<0:return 0 else:return 1 while 1: n=input() if n==0:break D=sorted([list(input()) for i in range(n)]) p=p1=D[0] while 1: for p2 in D: if p1!=p2 and side(p1,p2):break p1=p2 D.remove(p2) if p2==p:break print len(D)
4 1.0,0.0 0.0,1.0 2.0,1.0 1.0,2.0 9 -509.94,892.63 567.62,639.99 -859.32,-64.84 -445.99,383.69 667.54,430.49 551.12,828.21 -940.2,-877.2 -361.62,-970 -125.42,-178.48 0
0 3
<H1>輪ゴム</H1> <p> <var>n</var> 本の釘を平板上の座標 <var>P<sub>1</sub></var> (<var>x<sub>1</sub></var>, <var>y</sub>1</sub></var>), <var>P<sub>2</sub></var> (<var>x<sub>2</sub></var>, <var>y<sub>2</sub></var>), <var>P<sub>3</sub></var> (<var>x<sub>3</sub></var>, <var>y<sub>3</sub></var>),..., <var>P<sub>n</sub></var> (<var>x<sub>n</sub></var>, <var>y<sub>n</sub></var>) に１本ずつ打ち、輪ゴムの輪の中に全ての釘が入るように 1 本の輪ゴムで囲みます。このとき、輪ゴムが交差してはいけません。 </p> <p> 釘の座標を読み込んで、上記のように釘を輪ゴムで囲んだときに輪ゴムに接していない釘の本数を出力するプログラムを作成してください。輪ゴムは充分に伸び縮みするものとします。同じ座標に 2 本以上の釘を打つことはないものとします。また、輪ゴムがかかった釘と釘の間は直線で結ばれるものとし、その直線上に 3 本以上の釘が並ぶことはないものとします。例えば、図 1 に示すような入力はありえません。図 2 に示すように輪ゴムがかかっていない釘が 1 直線上に並ぶことはありえます。 </p> <center> <table> <tr> <td width="240"><img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_convex1"></td> <td width="240"><img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_convex2"></td> </tr> <tr> <td>図１</td> <td>図２</td> </tr> </table> </center> <br/> <p> ただし、それぞれの座標値は -1000.0 以上1000.0 以下の実数です。また、<var>n</var> は 3 以上 100 以下の整数です。 </p> <H2>Input</H2> <p> 複数のデータセットが与えられます。各データセットは以下のような形式です与えられます。 </p> <pre> <var>n</var> <var>x<sub>1</sub></var>, <var>y<sub>1</sub></var> <var>x<sub>2</sub></var>, <var>y<sub>2</sub></var> ... 　　　　 ... <var>x<sub>n</sub></var>, <var>y<sub>n</sub></var> </pre> <p> <var>n</var> が 0 の時、入力の最後を示します。データセットの数は 50 を超えません。 </p> <H2>Output</H2> <p> データセットごとに、ゴムと接していない釘の本数を出力してください。 例えば、図 3 に示す４つの釘を表す入力があった場合、図 4 のように囲まれるので、輪ゴムに接していない釘の本数は 1 本です。 </p> <center> <table> <tr> <td width="240"><img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_convex3"></td> <td width="240"><img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_convex4"></td> </tr> <tr> <td>図３</td> <td>図４</td> </tr> </table> </center> <br/> <H2>Sample Input</H2> <pre> 4 1.0,0.0 0.0,1.0 2.0,1.0 1.0,2.0 9 -509.94,892.63 567.62,639.99 -859.32,-64.84 -445.99,383.69 667.54,430.49 551.12,828.21 -940.2,-877.2 -361.62,-970 -125.42,-178.48 0 </pre> <H2>Output for the Sample Input</H2> <pre> 0 3 </pre> <H2>Hint</H2> <p> 以下は２つめのサンプル入力に対する図です。 </p> <center> <table> <tr> <td><img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_convex5"></td> </tr> <tr> </tr> </table> </center>
s432451246
p00068
Accepted
import sys def side(p1,p2): global D y1,x1=p1 y2,x2=p2 dy=y2-y1 dx=x2-x1 for p3 in D: if p1==p3 or p2==p3:continue if (p3[1]-x1)*dy-dx*(p3[0]-y1)<0:return 0 else:return 1 while 1: n=input() if n==0:break D=sorted([list(input()) for i in range(n)]) p=p1=D[0] while 1: for p2 in D: if p1!=p2 and side(p1,p2):break p1=p2 D.remove(p2) if p2==p:break print len(D)
4 1.0,0.0 0.0,1.0 2.0,1.0 1.0,2.0 9 -509.94,892.63 567.62,639.99 -859.32,-64.84 -445.99,383.69 667.54,430.49 551.12,828.21 -940.2,-877.2 -361.62,-970 -125.42,-178.48 0
0 3
<H1>輪ゴム</H1> <p> <var>n</var> 本の釘を平板上の座標 <var>P<sub>1</sub></var> (<var>x<sub>1</sub></var>, <var>y</sub>1</sub></var>), <var>P<sub>2</sub></var> (<var>x<sub>2</sub></var>, <var>y<sub>2</sub></var>), <var>P<sub>3</sub></var> (<var>x<sub>3</sub></var>, <var>y<sub>3</sub></var>),..., <var>P<sub>n</sub></var> (<var>x<sub>n</sub></var>, <var>y<sub>n</sub></var>) に１本ずつ打ち、輪ゴムの輪の中に全ての釘が入るように 1 本の輪ゴムで囲みます。このとき、輪ゴムが交差してはいけません。 </p> <p> 釘の座標を読み込んで、上記のように釘を輪ゴムで囲んだときに輪ゴムに接していない釘の本数を出力するプログラムを作成してください。輪ゴムは充分に伸び縮みするものとします。同じ座標に 2 本以上の釘を打つことはないものとします。また、輪ゴムがかかった釘と釘の間は直線で結ばれるものとし、その直線上に 3 本以上の釘が並ぶことはないものとします。例えば、図 1 に示すような入力はありえません。図 2 に示すように輪ゴムがかかっていない釘が 1 直線上に並ぶことはありえます。 </p> <center> <table> <tr> <td width="240"><img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_convex1"></td> <td width="240"><img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_convex2"></td> </tr> <tr> <td>図１</td> <td>図２</td> </tr> </table> </center> <br/> <p> ただし、それぞれの座標値は -1000.0 以上1000.0 以下の実数です。また、<var>n</var> は 3 以上 100 以下の整数です。 </p> <H2>Input</H2> <p> 複数のデータセットが与えられます。各データセットは以下のような形式です与えられます。 </p> <pre> <var>n</var> <var>x<sub>1</sub></var>, <var>y<sub>1</sub></var> <var>x<sub>2</sub></var>, <var>y<sub>2</sub></var> ... 　　　　 ... <var>x<sub>n</sub></var>, <var>y<sub>n</sub></var> </pre> <p> <var>n</var> が 0 の時、入力の最後を示します。データセットの数は 50 を超えません。 </p> <H2>Output</H2> <p> データセットごとに、ゴムと接していない釘の本数を出力してください。 例えば、図 3 に示す４つの釘を表す入力があった場合、図 4 のように囲まれるので、輪ゴムに接していない釘の本数は 1 本です。 </p> <center> <table> <tr> <td width="240"><img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_convex3"></td> <td width="240"><img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_convex4"></td> </tr> <tr> <td>図３</td> <td>図４</td> </tr> </table> </center> <br/> <H2>Sample Input</H2> <pre> 4 1.0,0.0 0.0,1.0 2.0,1.0 1.0,2.0 9 -509.94,892.63 567.62,639.99 -859.32,-64.84 -445.99,383.69 667.54,430.49 551.12,828.21 -940.2,-877.2 -361.62,-970 -125.42,-178.48 0 </pre> <H2>Output for the Sample Input</H2> <pre> 0 3 </pre> <H2>Hint</H2> <p> 以下は２つめのサンプル入力に対する図です。 </p> <center> <table> <tr> <td><img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_convex5"></td> </tr> <tr> </tr> </table> </center>
s875293937
p00068
Accepted
def a(v1,v2): if v1[0] != v2[0]: return (v2[1]-v1[1])/(v2[0]-v1[0]) else: return (v2[1]-v1[1])*(10**10) def convex(v,n): k = 0 d = [] u = [] for i in range(n): d.append(i) u.append(i) while len(d) > 2: if a(v[d[-3]],v[d[-2]]) < a(v[d[-2]],v[d[-1]]): del d[-2] else: break while len(u) > 2: if a(v[u[-3]],v[u[-2]]) > a(v[u[-2]],v[u[-1]]): del u[-2] else: break return n - len(set(d+u)) while 1: n = input() if n == 0: break v = [map(float,raw_input().split(",")) for i in range(n)] v = sorted(sorted(v, key = lambda x:x[1])) print convex(v,n)
4 1.0,0.0 0.0,1.0 2.0,1.0 1.0,2.0 9 -509.94,892.63 567.62,639.99 -859.32,-64.84 -445.99,383.69 667.54,430.49 551.12,828.21 -940.2,-877.2 -361.62,-970 -125.42,-178.48 0
0 3
<H1>輪ゴム</H1> <p> <var>n</var> 本の釘を平板上の座標 <var>P<sub>1</sub></var> (<var>x<sub>1</sub></var>, <var>y</sub>1</sub></var>), <var>P<sub>2</sub></var> (<var>x<sub>2</sub></var>, <var>y<sub>2</sub></var>), <var>P<sub>3</sub></var> (<var>x<sub>3</sub></var>, <var>y<sub>3</sub></var>),..., <var>P<sub>n</sub></var> (<var>x<sub>n</sub></var>, <var>y<sub>n</sub></var>) に１本ずつ打ち、輪ゴムの輪の中に全ての釘が入るように 1 本の輪ゴムで囲みます。このとき、輪ゴムが交差してはいけません。 </p> <p> 釘の座標を読み込んで、上記のように釘を輪ゴムで囲んだときに輪ゴムに接していない釘の本数を出力するプログラムを作成してください。輪ゴムは充分に伸び縮みするものとします。同じ座標に 2 本以上の釘を打つことはないものとします。また、輪ゴムがかかった釘と釘の間は直線で結ばれるものとし、その直線上に 3 本以上の釘が並ぶことはないものとします。例えば、図 1 に示すような入力はありえません。図 2 に示すように輪ゴムがかかっていない釘が 1 直線上に並ぶことはありえます。 </p> <center> <table> <tr> <td width="240"><img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_convex1"></td> <td width="240"><img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_convex2"></td> </tr> <tr> <td>図１</td> <td>図２</td> </tr> </table> </center> <br/> <p> ただし、それぞれの座標値は -1000.0 以上1000.0 以下の実数です。また、<var>n</var> は 3 以上 100 以下の整数です。 </p> <H2>Input</H2> <p> 複数のデータセットが与えられます。各データセットは以下のような形式です与えられます。 </p> <pre> <var>n</var> <var>x<sub>1</sub></var>, <var>y<sub>1</sub></var> <var>x<sub>2</sub></var>, <var>y<sub>2</sub></var> ... 　　　　 ... <var>x<sub>n</sub></var>, <var>y<sub>n</sub></var> </pre> <p> <var>n</var> が 0 の時、入力の最後を示します。データセットの数は 50 を超えません。 </p> <H2>Output</H2> <p> データセットごとに、ゴムと接していない釘の本数を出力してください。 例えば、図 3 に示す４つの釘を表す入力があった場合、図 4 のように囲まれるので、輪ゴムに接していない釘の本数は 1 本です。 </p> <center> <table> <tr> <td width="240"><img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_convex3"></td> <td width="240"><img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_convex4"></td> </tr> <tr> <td>図３</td> <td>図４</td> </tr> </table> </center> <br/> <H2>Sample Input</H2> <pre> 4 1.0,0.0 0.0,1.0 2.0,1.0 1.0,2.0 9 -509.94,892.63 567.62,639.99 -859.32,-64.84 -445.99,383.69 667.54,430.49 551.12,828.21 -940.2,-877.2 -361.62,-970 -125.42,-178.48 0 </pre> <H2>Output for the Sample Input</H2> <pre> 0 3 </pre> <H2>Hint</H2> <p> 以下は２つめのサンプル入力に対する図です。 </p> <center> <table> <tr> <td><img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_convex5"></td> </tr> <tr> </tr> </table> </center>
s053234145
p00068
Accepted
def a(v1,v2): if v1[0] != v2[0]: return (v2[1]-v1[1])/(v2[0]-v1[0]) else: return (v2[1]-v1[1])*(10**10) def dlt(p,v,sign): while len(p) > 2: if sign*(a(v[p[-3]],v[p[-2]]) - a(v[p[-2]],v[p[-1]])) < 0: del p[-2] else: break return p def convex(v,n): d,u = [],[] for i in range(n): d = dlt(d+[i],v,1) u = dlt(u+[i],v,-1) return n - len(set(d+u)) while 1: n = input() if n == 0: break v = [map(float,raw_input().split(",")) for i in range(n)] v = sorted(sorted(v, key = lambda x:x[1])) print convex(v,n)
4 1.0,0.0 0.0,1.0 2.0,1.0 1.0,2.0 9 -509.94,892.63 567.62,639.99 -859.32,-64.84 -445.99,383.69 667.54,430.49 551.12,828.21 -940.2,-877.2 -361.62,-970 -125.42,-178.48 0
0 3
<H1>輪ゴム</H1> <p> <var>n</var> 本の釘を平板上の座標 <var>P<sub>1</sub></var> (<var>x<sub>1</sub></var>, <var>y</sub>1</sub></var>), <var>P<sub>2</sub></var> (<var>x<sub>2</sub></var>, <var>y<sub>2</sub></var>), <var>P<sub>3</sub></var> (<var>x<sub>3</sub></var>, <var>y<sub>3</sub></var>),..., <var>P<sub>n</sub></var> (<var>x<sub>n</sub></var>, <var>y<sub>n</sub></var>) に１本ずつ打ち、輪ゴムの輪の中に全ての釘が入るように 1 本の輪ゴムで囲みます。このとき、輪ゴムが交差してはいけません。 </p> <p> 釘の座標を読み込んで、上記のように釘を輪ゴムで囲んだときに輪ゴムに接していない釘の本数を出力するプログラムを作成してください。輪ゴムは充分に伸び縮みするものとします。同じ座標に 2 本以上の釘を打つことはないものとします。また、輪ゴムがかかった釘と釘の間は直線で結ばれるものとし、その直線上に 3 本以上の釘が並ぶことはないものとします。例えば、図 1 に示すような入力はありえません。図 2 に示すように輪ゴムがかかっていない釘が 1 直線上に並ぶことはありえます。 </p> <center> <table> <tr> <td width="240"><img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_convex1"></td> <td width="240"><img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_convex2"></td> </tr> <tr> <td>図１</td> <td>図２</td> </tr> </table> </center> <br/> <p> ただし、それぞれの座標値は -1000.0 以上1000.0 以下の実数です。また、<var>n</var> は 3 以上 100 以下の整数です。 </p> <H2>Input</H2> <p> 複数のデータセットが与えられます。各データセットは以下のような形式です与えられます。 </p> <pre> <var>n</var> <var>x<sub>1</sub></var>, <var>y<sub>1</sub></var> <var>x<sub>2</sub></var>, <var>y<sub>2</sub></var> ... 　　　　 ... <var>x<sub>n</sub></var>, <var>y<sub>n</sub></var> </pre> <p> <var>n</var> が 0 の時、入力の最後を示します。データセットの数は 50 を超えません。 </p> <H2>Output</H2> <p> データセットごとに、ゴムと接していない釘の本数を出力してください。 例えば、図 3 に示す４つの釘を表す入力があった場合、図 4 のように囲まれるので、輪ゴムに接していない釘の本数は 1 本です。 </p> <center> <table> <tr> <td width="240"><img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_convex3"></td> <td width="240"><img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_convex4"></td> </tr> <tr> <td>図３</td> <td>図４</td> </tr> </table> </center> <br/> <H2>Sample Input</H2> <pre> 4 1.0,0.0 0.0,1.0 2.0,1.0 1.0,2.0 9 -509.94,892.63 567.62,639.99 -859.32,-64.84 -445.99,383.69 667.54,430.49 551.12,828.21 -940.2,-877.2 -361.62,-970 -125.42,-178.48 0 </pre> <H2>Output for the Sample Input</H2> <pre> 0 3 </pre> <H2>Hint</H2> <p> 以下は２つめのサンプル入力に対する図です。 </p> <center> <table> <tr> <td><img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_convex5"></td> </tr> <tr> </tr> </table> </center>
s134433827
p00068
Accepted
import sys readline = sys.stdin.readline write = sys.stdout.write def cross3(a, b, c): return (b[0]-a[0])*(c[1]-a[1]) - (b[1]-a[1])*(c[0]-a[0]) EPS = -1e-9 def convex_hull(ps): qs = [] n = len(ps) for p in ps: while len(qs)>1 and cross3(qs[-1], qs[-2], p) > -EPS: qs.pop() qs.append(p) t = len(qs) for i in range(n-2, -1, -1): p = ps[i] while len(qs)>t and cross3(qs[-1], qs[-2], p) > -EPS: qs.pop() qs.append(p) return qs def solve(): N = int(readline()) if N == 0: return False P = [list(map(float, readline().split(","))) for i in range(N)] P.sort() Q = convex_hull(P) write("%d\n" % (N - len(Q) + 1)) return True while solve(): ...
4 1.0,0.0 0.0,1.0 2.0,1.0 1.0,2.0 9 -509.94,892.63 567.62,639.99 -859.32,-64.84 -445.99,383.69 667.54,430.49 551.12,828.21 -940.2,-877.2 -361.62,-970 -125.42,-178.48 0
0 3
<H1>輪ゴム</H1> <p> <var>n</var> 本の釘を平板上の座標 <var>P<sub>1</sub></var> (<var>x<sub>1</sub></var>, <var>y</sub>1</sub></var>), <var>P<sub>2</sub></var> (<var>x<sub>2</sub></var>, <var>y<sub>2</sub></var>), <var>P<sub>3</sub></var> (<var>x<sub>3</sub></var>, <var>y<sub>3</sub></var>),..., <var>P<sub>n</sub></var> (<var>x<sub>n</sub></var>, <var>y<sub>n</sub></var>) に１本ずつ打ち、輪ゴムの輪の中に全ての釘が入るように 1 本の輪ゴムで囲みます。このとき、輪ゴムが交差してはいけません。 </p> <p> 釘の座標を読み込んで、上記のように釘を輪ゴムで囲んだときに輪ゴムに接していない釘の本数を出力するプログラムを作成してください。輪ゴムは充分に伸び縮みするものとします。同じ座標に 2 本以上の釘を打つことはないものとします。また、輪ゴムがかかった釘と釘の間は直線で結ばれるものとし、その直線上に 3 本以上の釘が並ぶことはないものとします。例えば、図 1 に示すような入力はありえません。図 2 に示すように輪ゴムがかかっていない釘が 1 直線上に並ぶことはありえます。 </p> <center> <table> <tr> <td width="240"><img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_convex1"></td> <td width="240"><img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_convex2"></td> </tr> <tr> <td>図１</td> <td>図２</td> </tr> </table> </center> <br/> <p> ただし、それぞれの座標値は -1000.0 以上1000.0 以下の実数です。また、<var>n</var> は 3 以上 100 以下の整数です。 </p> <H2>Input</H2> <p> 複数のデータセットが与えられます。各データセットは以下のような形式です与えられます。 </p> <pre> <var>n</var> <var>x<sub>1</sub></var>, <var>y<sub>1</sub></var> <var>x<sub>2</sub></var>, <var>y<sub>2</sub></var> ... 　　　　 ... <var>x<sub>n</sub></var>, <var>y<sub>n</sub></var> </pre> <p> <var>n</var> が 0 の時、入力の最後を示します。データセットの数は 50 を超えません。 </p> <H2>Output</H2> <p> データセットごとに、ゴムと接していない釘の本数を出力してください。 例えば、図 3 に示す４つの釘を表す入力があった場合、図 4 のように囲まれるので、輪ゴムに接していない釘の本数は 1 本です。 </p> <center> <table> <tr> <td width="240"><img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_convex3"></td> <td width="240"><img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_convex4"></td> </tr> <tr> <td>図３</td> <td>図４</td> </tr> </table> </center> <br/> <H2>Sample Input</H2> <pre> 4 1.0,0.0 0.0,1.0 2.0,1.0 1.0,2.0 9 -509.94,892.63 567.62,639.99 -859.32,-64.84 -445.99,383.69 667.54,430.49 551.12,828.21 -940.2,-877.2 -361.62,-970 -125.42,-178.48 0 </pre> <H2>Output for the Sample Input</H2> <pre> 0 3 </pre> <H2>Hint</H2> <p> 以下は２つめのサンプル入力に対する図です。 </p> <center> <table> <tr> <td><img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_convex5"></td> </tr> <tr> </tr> </table> </center>
s447467591
p00068
Accepted
#凸包を求める def quickhull(l,r,s,k): if not s: return su = [] sd = [] a = (r[0]-l[0],r[1]-l[1]) for x,y in s: b = (x-l[0],y-l[1]) cro = cross(a,b) if cro > 0: su.append((x,y)) #上半分 elif cro < 0: sd.append((x,y)) #下半分 if su: c,d = direction(l,r,su[0]) p = su[0] for i in range(1,len(su)): c_,d_ = direction(l,r,su[i]) if c*d_ < c_*d: c,d = c_,d_ p = su[i] k.append(tuple(p)) #もっとも離れた点を凸包の頂点に追加 b = (l[0]-p[0],l[1]-p[1]) c = (p[0]-r[0],p[1]-r[1]) s1 = [] s2 = [] for x,y in su: b_ = (x-p[0],y-p[1]) c_ = (x-r[0],y-r[1]) cro_b,cro_c = cross(b,b_),cross(c,c_) if cro_b >= 0 and cro_c >= 0: #三角形内部判定 continue else: if cro_b < 0: s1.append((x,y)) elif cro_c < 0: s2.append((x,y)) quickhull(l,p,s1,k) #再帰 quickhull(p,r,s2,k) if sd: c,d = direction(l,r,sd[0]) p = sd[0] for i in range(1,len(sd)): c_,d_ = direction(l,r,sd[i]) if c*d_ < c_*d: c,d = c_,d_ p = sd[i] k.append(tuple(p)) #もっとも離れた点を凸包の頂点に追加 b = (l[0]-p[0],l[1]-p[1]) c = (p[0]-r[0],p[1]-r[1]) s1 = [] s2 = [] for x,y in sd: b_ = (x-p[0],y-p[1]) c_ = (x-r[0],y-r[1]) cro_b,cro_c = cross(b,b_),cross(c,c_) if cro_b <= 0 and cro_c <= 0: #三角形内部判定(ベクトルの向きにより上下で判定が異なることに注意) continue else: if cro_b > 0: s1.append((x,y)) elif cro_c > 0: s2.append((x,y)) quickhull(l,p,s1,k) #再帰 quickhull(p,r,s2,k) return k def cross(a,b): #外積 return a[0]*b[1]-a[1]*b[0] def direction(l,r,p): #点と直線の距離 a = r[1]-l[1] b = l[0]-r[0] return (a*(p[0]-l[0])+b*(p[1]-l[1]))**2, a**2+b**2 #分子の2乗,分母の2乗 while 1: n = int(input()) if n == 0: break s = [[float(x) for x in input().split(",")] for i in range(n)] s.sort() l = tuple(s.pop(0)) r = tuple(s.pop(-1)) k = quickhull(l,r,s,[l,r]) print(n-len(k))
4 1.0,0.0 0.0,1.0 2.0,1.0 1.0,2.0 9 -509.94,892.63 567.62,639.99 -859.32,-64.84 -445.99,383.69 667.54,430.49 551.12,828.21 -940.2,-877.2 -361.62,-970 -125.42,-178.48 0
0 3
<H1>輪ゴム</H1> <p> <var>n</var> 本の釘を平板上の座標 <var>P<sub>1</sub></var> (<var>x<sub>1</sub></var>, <var>y</sub>1</sub></var>), <var>P<sub>2</sub></var> (<var>x<sub>2</sub></var>, <var>y<sub>2</sub></var>), <var>P<sub>3</sub></var> (<var>x<sub>3</sub></var>, <var>y<sub>3</sub></var>),..., <var>P<sub>n</sub></var> (<var>x<sub>n</sub></var>, <var>y<sub>n</sub></var>) に１本ずつ打ち、輪ゴムの輪の中に全ての釘が入るように 1 本の輪ゴムで囲みます。このとき、輪ゴムが交差してはいけません。 </p> <p> 釘の座標を読み込んで、上記のように釘を輪ゴムで囲んだときに輪ゴムに接していない釘の本数を出力するプログラムを作成してください。輪ゴムは充分に伸び縮みするものとします。同じ座標に 2 本以上の釘を打つことはないものとします。また、輪ゴムがかかった釘と釘の間は直線で結ばれるものとし、その直線上に 3 本以上の釘が並ぶことはないものとします。例えば、図 1 に示すような入力はありえません。図 2 に示すように輪ゴムがかかっていない釘が 1 直線上に並ぶことはありえます。 </p> <center> <table> <tr> <td width="240"><img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_convex1"></td> <td width="240"><img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_convex2"></td> </tr> <tr> <td>図１</td> <td>図２</td> </tr> </table> </center> <br/> <p> ただし、それぞれの座標値は -1000.0 以上1000.0 以下の実数です。また、<var>n</var> は 3 以上 100 以下の整数です。 </p> <H2>Input</H2> <p> 複数のデータセットが与えられます。各データセットは以下のような形式です与えられます。 </p> <pre> <var>n</var> <var>x<sub>1</sub></var>, <var>y<sub>1</sub></var> <var>x<sub>2</sub></var>, <var>y<sub>2</sub></var> ... 　　　　 ... <var>x<sub>n</sub></var>, <var>y<sub>n</sub></var> </pre> <p> <var>n</var> が 0 の時、入力の最後を示します。データセットの数は 50 を超えません。 </p> <H2>Output</H2> <p> データセットごとに、ゴムと接していない釘の本数を出力してください。 例えば、図 3 に示す４つの釘を表す入力があった場合、図 4 のように囲まれるので、輪ゴムに接していない釘の本数は 1 本です。 </p> <center> <table> <tr> <td width="240"><img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_convex3"></td> <td width="240"><img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_convex4"></td> </tr> <tr> <td>図３</td> <td>図４</td> </tr> </table> </center> <br/> <H2>Sample Input</H2> <pre> 4 1.0,0.0 0.0,1.0 2.0,1.0 1.0,2.0 9 -509.94,892.63 567.62,639.99 -859.32,-64.84 -445.99,383.69 667.54,430.49 551.12,828.21 -940.2,-877.2 -361.62,-970 -125.42,-178.48 0 </pre> <H2>Output for the Sample Input</H2> <pre> 0 3 </pre> <H2>Hint</H2> <p> 以下は２つめのサンプル入力に対する図です。 </p> <center> <table> <tr> <td><img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_convex5"></td> </tr> <tr> </tr> </table> </center>
s458353198
p00068
Accepted
import math,string,itertools,fractions,heapq,collections,re,array,bisect,sys,random,time,copy,functools sys.setrecursionlimit(10**7) inf = 10**20 eps = 1.0 / 10**10 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 LI_(): return [int(x)-1 for x in sys.stdin.readline().split()] def LF(): return [float(x) for x in sys.stdin.readline().split()] def LS(): return sys.stdin.readline().split() def I(): return int(sys.stdin.readline()) def F(): return float(sys.stdin.readline()) def S(): return input() def pf(s): return print(s, flush=True) def ccw(a, b, c): ax = b[0] - a[0] ay = b[1] - a[1] bx = c[0] - a[0] by = c[1] - a[1] t = ax*by - ay*bx; if t > 0: return 1 if t < 0: return -1 if ax*bx + ay*by < 0: return 2 if ax*ax + ay*ay < bx*bx + by*by: return -2 return 0 def convex_hull(ps): n = len(ps) k = 0 ps.sort() ch = [[-1,-1] for _ in range(n*2)] for i in range(n): while k >= 2 and ccw(ch[k-2], ch[k-1], ps[i]) <= 0: k -= 1 ch[k] = ps[i] k += 1 t = k + 1 for i in range(n-2,-1,-1): while k >= t and ccw(ch[k-2], ch[k-1], ps[i]) <= 0: k -= 1 ch[k] = ps[i] k += 1 ch = ch[:k-1] return ch def main(): rr = [] while True: n = I() if n == 0: break a = [list(map(float, S().split(','))) for _ in range(n)] r = convex_hull(a) rr.append(n-len(r)) return '\n'.join(map(str,rr)) print(main())
4 1.0,0.0 0.0,1.0 2.0,1.0 1.0,2.0 9 -509.94,892.63 567.62,639.99 -859.32,-64.84 -445.99,383.69 667.54,430.49 551.12,828.21 -940.2,-877.2 -361.62,-970 -125.42,-178.48 0
0 3
<H1>輪ゴム</H1> <p> <var>n</var> 本の釘を平板上の座標 <var>P<sub>1</sub></var> (<var>x<sub>1</sub></var>, <var>y</sub>1</sub></var>), <var>P<sub>2</sub></var> (<var>x<sub>2</sub></var>, <var>y<sub>2</sub></var>), <var>P<sub>3</sub></var> (<var>x<sub>3</sub></var>, <var>y<sub>3</sub></var>),..., <var>P<sub>n</sub></var> (<var>x<sub>n</sub></var>, <var>y<sub>n</sub></var>) に１本ずつ打ち、輪ゴムの輪の中に全ての釘が入るように 1 本の輪ゴムで囲みます。このとき、輪ゴムが交差してはいけません。 </p> <p> 釘の座標を読み込んで、上記のように釘を輪ゴムで囲んだときに輪ゴムに接していない釘の本数を出力するプログラムを作成してください。輪ゴムは充分に伸び縮みするものとします。同じ座標に 2 本以上の釘を打つことはないものとします。また、輪ゴムがかかった釘と釘の間は直線で結ばれるものとし、その直線上に 3 本以上の釘が並ぶことはないものとします。例えば、図 1 に示すような入力はありえません。図 2 に示すように輪ゴムがかかっていない釘が 1 直線上に並ぶことはありえます。 </p> <center> <table> <tr> <td width="240"><img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_convex1"></td> <td width="240"><img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_convex2"></td> </tr> <tr> <td>図１</td> <td>図２</td> </tr> </table> </center> <br/> <p> ただし、それぞれの座標値は -1000.0 以上1000.0 以下の実数です。また、<var>n</var> は 3 以上 100 以下の整数です。 </p> <H2>Input</H2> <p> 複数のデータセットが与えられます。各データセットは以下のような形式です与えられます。 </p> <pre> <var>n</var> <var>x<sub>1</sub></var>, <var>y<sub>1</sub></var> <var>x<sub>2</sub></var>, <var>y<sub>2</sub></var> ... 　　　　 ... <var>x<sub>n</sub></var>, <var>y<sub>n</sub></var> </pre> <p> <var>n</var> が 0 の時、入力の最後を示します。データセットの数は 50 を超えません。 </p> <H2>Output</H2> <p> データセットごとに、ゴムと接していない釘の本数を出力してください。 例えば、図 3 に示す４つの釘を表す入力があった場合、図 4 のように囲まれるので、輪ゴムに接していない釘の本数は 1 本です。 </p> <center> <table> <tr> <td width="240"><img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_convex3"></td> <td width="240"><img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_convex4"></td> </tr> <tr> <td>図３</td> <td>図４</td> </tr> </table> </center> <br/> <H2>Sample Input</H2> <pre> 4 1.0,0.0 0.0,1.0 2.0,1.0 1.0,2.0 9 -509.94,892.63 567.62,639.99 -859.32,-64.84 -445.99,383.69 667.54,430.49 551.12,828.21 -940.2,-877.2 -361.62,-970 -125.42,-178.48 0 </pre> <H2>Output for the Sample Input</H2> <pre> 0 3 </pre> <H2>Hint</H2> <p> 以下は２つめのサンプル入力に対する図です。 </p> <center> <table> <tr> <td><img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_convex5"></td> </tr> <tr> </tr> </table> </center>
s935667015
p00068
Runtime Error
upper_hull = get_bounds(ps) ps.reverse() lower_hull = get_bounds(ps) del upper_hull[-1] del lower_hull[-1] upper_hull.extend(lower_hull) return upper_hull def get_bounds(ps): qs = [] for p in ps: while len(qs) > 1 and (qs[-1] - qs[-2]).det(p - qs[-1]) <= 0: del qs[-1] qs.append(p) return qs while True: n = int(input()) if n == 0: break points = [] for i in range(n): x, y = map(float, input().split(',')) points.append(Point(x, y)) print(len(points) - len(convex_hull(points)))
4 1.0,0.0 0.0,1.0 2.0,1.0 1.0,2.0 9 -509.94,892.63 567.62,639.99 -859.32,-64.84 -445.99,383.69 667.54,430.49 551.12,828.21 -940.2,-877.2 -361.62,-970 -125.42,-178.48 0
0 3
<H1>輪ゴム</H1> <p> <var>n</var> 本の釘を平板上の座標 <var>P<sub>1</sub></var> (<var>x<sub>1</sub></var>, <var>y</sub>1</sub></var>), <var>P<sub>2</sub></var> (<var>x<sub>2</sub></var>, <var>y<sub>2</sub></var>), <var>P<sub>3</sub></var> (<var>x<sub>3</sub></var>, <var>y<sub>3</sub></var>),..., <var>P<sub>n</sub></var> (<var>x<sub>n</sub></var>, <var>y<sub>n</sub></var>) に１本ずつ打ち、輪ゴムの輪の中に全ての釘が入るように 1 本の輪ゴムで囲みます。このとき、輪ゴムが交差してはいけません。 </p> <p> 釘の座標を読み込んで、上記のように釘を輪ゴムで囲んだときに輪ゴムに接していない釘の本数を出力するプログラムを作成してください。輪ゴムは充分に伸び縮みするものとします。同じ座標に 2 本以上の釘を打つことはないものとします。また、輪ゴムがかかった釘と釘の間は直線で結ばれるものとし、その直線上に 3 本以上の釘が並ぶことはないものとします。例えば、図 1 に示すような入力はありえません。図 2 に示すように輪ゴムがかかっていない釘が 1 直線上に並ぶことはありえます。 </p> <center> <table> <tr> <td width="240"><img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_convex1"></td> <td width="240"><img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_convex2"></td> </tr> <tr> <td>図１</td> <td>図２</td> </tr> </table> </center> <br/> <p> ただし、それぞれの座標値は -1000.0 以上1000.0 以下の実数です。また、<var>n</var> は 3 以上 100 以下の整数です。 </p> <H2>Input</H2> <p> 複数のデータセットが与えられます。各データセットは以下のような形式です与えられます。 </p> <pre> <var>n</var> <var>x<sub>1</sub></var>, <var>y<sub>1</sub></var> <var>x<sub>2</sub></var>, <var>y<sub>2</sub></var> ... 　　　　 ... <var>x<sub>n</sub></var>, <var>y<sub>n</sub></var> </pre> <p> <var>n</var> が 0 の時、入力の最後を示します。データセットの数は 50 を超えません。 </p> <H2>Output</H2> <p> データセットごとに、ゴムと接していない釘の本数を出力してください。 例えば、図 3 に示す４つの釘を表す入力があった場合、図 4 のように囲まれるので、輪ゴムに接していない釘の本数は 1 本です。 </p> <center> <table> <tr> <td width="240"><img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_convex3"></td> <td width="240"><img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_convex4"></td> </tr> <tr> <td>図３</td> <td>図４</td> </tr> </table> </center> <br/> <H2>Sample Input</H2> <pre> 4 1.0,0.0 0.0,1.0 2.0,1.0 1.0,2.0 9 -509.94,892.63 567.62,639.99 -859.32,-64.84 -445.99,383.69 667.54,430.49 551.12,828.21 -940.2,-877.2 -361.62,-970 -125.42,-178.48 0 </pre> <H2>Output for the Sample Input</H2> <pre> 0 3 </pre> <H2>Hint</H2> <p> 以下は２つめのサンプル入力に対する図です。 </p> <center> <table> <tr> <td><img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_convex5"></td> </tr> <tr> </tr> </table> </center>
s464683478
p00068
Runtime Error
def a(v1,v2): if v1[0]!=v2[0]: return (v2[1]-v1[1])/(v2[0]-v1[0]) else: return (v2[1]-v1[1])*(10**10) def dlt(p,v,sign): while len(p)>2: if sign*(a(v[p[-3]],v[p[-2]])-a(v[p[-2]],v[p[-1]]))<0: del p[-2] else: break return p def convex(v,n): d,u=[],[] for i in range(n): d=dlt(d+[i],v,1) u=dlt(u+[i],v,-1) return n-len(set(d+u)) while 1: n=int(raw_input()) if n==0: break v=[map(float,raw_input().splirt(',')) for i in range(n)] v=sorted(sorted(v,key=lambda x:x[1])) print convex(v,n)
4 1.0,0.0 0.0,1.0 2.0,1.0 1.0,2.0 9 -509.94,892.63 567.62,639.99 -859.32,-64.84 -445.99,383.69 667.54,430.49 551.12,828.21 -940.2,-877.2 -361.62,-970 -125.42,-178.48 0
0 3
<H1>輪ゴム</H1> <p> <var>n</var> 本の釘を平板上の座標 <var>P<sub>1</sub></var> (<var>x<sub>1</sub></var>, <var>y</sub>1</sub></var>), <var>P<sub>2</sub></var> (<var>x<sub>2</sub></var>, <var>y<sub>2</sub></var>), <var>P<sub>3</sub></var> (<var>x<sub>3</sub></var>, <var>y<sub>3</sub></var>),..., <var>P<sub>n</sub></var> (<var>x<sub>n</sub></var>, <var>y<sub>n</sub></var>) に１本ずつ打ち、輪ゴムの輪の中に全ての釘が入るように 1 本の輪ゴムで囲みます。このとき、輪ゴムが交差してはいけません。 </p> <p> 釘の座標を読み込んで、上記のように釘を輪ゴムで囲んだときに輪ゴムに接していない釘の本数を出力するプログラムを作成してください。輪ゴムは充分に伸び縮みするものとします。同じ座標に 2 本以上の釘を打つことはないものとします。また、輪ゴムがかかった釘と釘の間は直線で結ばれるものとし、その直線上に 3 本以上の釘が並ぶことはないものとします。例えば、図 1 に示すような入力はありえません。図 2 に示すように輪ゴムがかかっていない釘が 1 直線上に並ぶことはありえます。 </p> <center> <table> <tr> <td width="240"><img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_convex1"></td> <td width="240"><img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_convex2"></td> </tr> <tr> <td>図１</td> <td>図２</td> </tr> </table> </center> <br/> <p> ただし、それぞれの座標値は -1000.0 以上1000.0 以下の実数です。また、<var>n</var> は 3 以上 100 以下の整数です。 </p> <H2>Input</H2> <p> 複数のデータセットが与えられます。各データセットは以下のような形式です与えられます。 </p> <pre> <var>n</var> <var>x<sub>1</sub></var>, <var>y<sub>1</sub></var> <var>x<sub>2</sub></var>, <var>y<sub>2</sub></var> ... 　　　　 ... <var>x<sub>n</sub></var>, <var>y<sub>n</sub></var> </pre> <p> <var>n</var> が 0 の時、入力の最後を示します。データセットの数は 50 を超えません。 </p> <H2>Output</H2> <p> データセットごとに、ゴムと接していない釘の本数を出力してください。 例えば、図 3 に示す４つの釘を表す入力があった場合、図 4 のように囲まれるので、輪ゴムに接していない釘の本数は 1 本です。 </p> <center> <table> <tr> <td width="240"><img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_convex3"></td> <td width="240"><img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_convex4"></td> </tr> <tr> <td>図３</td> <td>図４</td> </tr> </table> </center> <br/> <H2>Sample Input</H2> <pre> 4 1.0,0.0 0.0,1.0 2.0,1.0 1.0,2.0 9 -509.94,892.63 567.62,639.99 -859.32,-64.84 -445.99,383.69 667.54,430.49 551.12,828.21 -940.2,-877.2 -361.62,-970 -125.42,-178.48 0 </pre> <H2>Output for the Sample Input</H2> <pre> 0 3 </pre> <H2>Hint</H2> <p> 以下は２つめのサンプル入力に対する図です。 </p> <center> <table> <tr> <td><img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_convex5"></td> </tr> <tr> </tr> </table> </center>
s124577525
p00068
Runtime Error
import sys def side(p1,p2): global D y1,x1=p1 y2,x2=p2 dy=y2-y1 dx=x2-x1 for p3 in D[::-1]: if p1==p3 or p2==p3:pass y3,x3=p3 elif (x3-x1)*dy-dx*(y3-y1)<0:return 0 else:return 1 while 1: n=input() if n==0:break D=sorted([list(input()) for i in range(n)]) p=p1=D[0] D1=D[:] while True: for p2 in D1: if p1!=p2 and side(p1,p2):break p1=p2 D1.remove(p2) if p2==p:break print len(D1)
4 1.0,0.0 0.0,1.0 2.0,1.0 1.0,2.0 9 -509.94,892.63 567.62,639.99 -859.32,-64.84 -445.99,383.69 667.54,430.49 551.12,828.21 -940.2,-877.2 -361.62,-970 -125.42,-178.48 0
0 3
<H1>輪ゴム</H1> <p> <var>n</var> 本の釘を平板上の座標 <var>P<sub>1</sub></var> (<var>x<sub>1</sub></var>, <var>y</sub>1</sub></var>), <var>P<sub>2</sub></var> (<var>x<sub>2</sub></var>, <var>y<sub>2</sub></var>), <var>P<sub>3</sub></var> (<var>x<sub>3</sub></var>, <var>y<sub>3</sub></var>),..., <var>P<sub>n</sub></var> (<var>x<sub>n</sub></var>, <var>y<sub>n</sub></var>) に１本ずつ打ち、輪ゴムの輪の中に全ての釘が入るように 1 本の輪ゴムで囲みます。このとき、輪ゴムが交差してはいけません。 </p> <p> 釘の座標を読み込んで、上記のように釘を輪ゴムで囲んだときに輪ゴムに接していない釘の本数を出力するプログラムを作成してください。輪ゴムは充分に伸び縮みするものとします。同じ座標に 2 本以上の釘を打つことはないものとします。また、輪ゴムがかかった釘と釘の間は直線で結ばれるものとし、その直線上に 3 本以上の釘が並ぶことはないものとします。例えば、図 1 に示すような入力はありえません。図 2 に示すように輪ゴムがかかっていない釘が 1 直線上に並ぶことはありえます。 </p> <center> <table> <tr> <td width="240"><img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_convex1"></td> <td width="240"><img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_convex2"></td> </tr> <tr> <td>図１</td> <td>図２</td> </tr> </table> </center> <br/> <p> ただし、それぞれの座標値は -1000.0 以上1000.0 以下の実数です。また、<var>n</var> は 3 以上 100 以下の整数です。 </p> <H2>Input</H2> <p> 複数のデータセットが与えられます。各データセットは以下のような形式です与えられます。 </p> <pre> <var>n</var> <var>x<sub>1</sub></var>, <var>y<sub>1</sub></var> <var>x<sub>2</sub></var>, <var>y<sub>2</sub></var> ... 　　　　 ... <var>x<sub>n</sub></var>, <var>y<sub>n</sub></var> </pre> <p> <var>n</var> が 0 の時、入力の最後を示します。データセットの数は 50 を超えません。 </p> <H2>Output</H2> <p> データセットごとに、ゴムと接していない釘の本数を出力してください。 例えば、図 3 に示す４つの釘を表す入力があった場合、図 4 のように囲まれるので、輪ゴムに接していない釘の本数は 1 本です。 </p> <center> <table> <tr> <td width="240"><img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_convex3"></td> <td width="240"><img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_convex4"></td> </tr> <tr> <td>図３</td> <td>図４</td> </tr> </table> </center> <br/> <H2>Sample Input</H2> <pre> 4 1.0,0.0 0.0,1.0 2.0,1.0 1.0,2.0 9 -509.94,892.63 567.62,639.99 -859.32,-64.84 -445.99,383.69 667.54,430.49 551.12,828.21 -940.2,-877.2 -361.62,-970 -125.42,-178.48 0 </pre> <H2>Output for the Sample Input</H2> <pre> 0 3 </pre> <H2>Hint</H2> <p> 以下は２つめのサンプル入力に対する図です。 </p> <center> <table> <tr> <td><img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_convex5"></td> </tr> <tr> </tr> </table> </center>
s136260872
p00068
Runtime Error
def f(x,y,x1,y1,x2,y2): if x1 <= x2: return (x2-x1)*y-(y2-y1)*x+x1*y2-x2*y1 else: return -((x2-x1)*y-(y2-y1)*x+x1*y2-x2*y1) def DC(a): if len(a) > 3: # Divide la = a[:len(a)/2] ra = a[len(a)/2:] la,ra = DC(la),DC(ra) # Conquer if len(la) == 1 or len(ra) == 1: return la+ra else: while f(ra[1][0],ra[1][1],la[-1][0],la[-1][1],ra[0][0],ra[0][1]) > 0: ra.pop(0) while f(la[-2][0],la[-2][1],ra[0][0],ra[0][1],la[-1][0],la[-1][1]) > 0: la.pop(-1) return la+ra else: return a while True: n = int(raw_input()) if n == 0: break p = [] for i in range(n): p.append(map(float, raw_input().split(","))) p = sorted(p, key = lambda x: x[0]) print n - len(DC(p))
4 1.0,0.0 0.0,1.0 2.0,1.0 1.0,2.0 9 -509.94,892.63 567.62,639.99 -859.32,-64.84 -445.99,383.69 667.54,430.49 551.12,828.21 -940.2,-877.2 -361.62,-970 -125.42,-178.48 0
0 3
<H1>輪ゴム</H1> <p> <var>n</var> 本の釘を平板上の座標 <var>P<sub>1</sub></var> (<var>x<sub>1</sub></var>, <var>y</sub>1</sub></var>), <var>P<sub>2</sub></var> (<var>x<sub>2</sub></var>, <var>y<sub>2</sub></var>), <var>P<sub>3</sub></var> (<var>x<sub>3</sub></var>, <var>y<sub>3</sub></var>),..., <var>P<sub>n</sub></var> (<var>x<sub>n</sub></var>, <var>y<sub>n</sub></var>) に１本ずつ打ち、輪ゴムの輪の中に全ての釘が入るように 1 本の輪ゴムで囲みます。このとき、輪ゴムが交差してはいけません。 </p> <p> 釘の座標を読み込んで、上記のように釘を輪ゴムで囲んだときに輪ゴムに接していない釘の本数を出力するプログラムを作成してください。輪ゴムは充分に伸び縮みするものとします。同じ座標に 2 本以上の釘を打つことはないものとします。また、輪ゴムがかかった釘と釘の間は直線で結ばれるものとし、その直線上に 3 本以上の釘が並ぶことはないものとします。例えば、図 1 に示すような入力はありえません。図 2 に示すように輪ゴムがかかっていない釘が 1 直線上に並ぶことはありえます。 </p> <center> <table> <tr> <td width="240"><img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_convex1"></td> <td width="240"><img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_convex2"></td> </tr> <tr> <td>図１</td> <td>図２</td> </tr> </table> </center> <br/> <p> ただし、それぞれの座標値は -1000.0 以上1000.0 以下の実数です。また、<var>n</var> は 3 以上 100 以下の整数です。 </p> <H2>Input</H2> <p> 複数のデータセットが与えられます。各データセットは以下のような形式です与えられます。 </p> <pre> <var>n</var> <var>x<sub>1</sub></var>, <var>y<sub>1</sub></var> <var>x<sub>2</sub></var>, <var>y<sub>2</sub></var> ... 　　　　 ... <var>x<sub>n</sub></var>, <var>y<sub>n</sub></var> </pre> <p> <var>n</var> が 0 の時、入力の最後を示します。データセットの数は 50 を超えません。 </p> <H2>Output</H2> <p> データセットごとに、ゴムと接していない釘の本数を出力してください。 例えば、図 3 に示す４つの釘を表す入力があった場合、図 4 のように囲まれるので、輪ゴムに接していない釘の本数は 1 本です。 </p> <center> <table> <tr> <td width="240"><img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_convex3"></td> <td width="240"><img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_convex4"></td> </tr> <tr> <td>図３</td> <td>図４</td> </tr> </table> </center> <br/> <H2>Sample Input</H2> <pre> 4 1.0,0.0 0.0,1.0 2.0,1.0 1.0,2.0 9 -509.94,892.63 567.62,639.99 -859.32,-64.84 -445.99,383.69 667.54,430.49 551.12,828.21 -940.2,-877.2 -361.62,-970 -125.42,-178.48 0 </pre> <H2>Output for the Sample Input</H2> <pre> 0 3 </pre> <H2>Hint</H2> <p> 以下は２つめのサンプル入力に対する図です。 </p> <center> <table> <tr> <td><img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_convex5"></td> </tr> <tr> </tr> </table> </center>
s037797140
p00068
Runtime Error
def f(x,y,x1,y1,x2,y2): if x1 <= x2: return (x2-x1)*y-(y2-y1)*x+x1*y2-x2*y1 else: return -((x2-x1)*y-(y2-y1)*x+x1*y2-x2*y1) def DC(a): if len(a) > 3: # Divide la = a[:len(a)/2] ra = a[len(a)/2:] # Conquer la,ra = DC(la),DC(ra) while f(ra[1][0],ra[1][1],la[-1][0],la[-1][1],ra[0][0],ra[0][1]) > 0 and len(ra) > 1: ra.pop(0) while f(la[-2][0],la[-2][1],ra[0][0],ra[0][1],la[-1][0],la[-1][1]) > 0 and len(la) > 1: la.pop(-1) return la+ra else: return a while True: n = int(raw_input()) if n == 0: break p = [] for i in range(n): p.append(map(float, raw_input().split(","))) p = sorted(p, key = lambda x: x[0]) print n - len(DC(p))
4 1.0,0.0 0.0,1.0 2.0,1.0 1.0,2.0 9 -509.94,892.63 567.62,639.99 -859.32,-64.84 -445.99,383.69 667.54,430.49 551.12,828.21 -940.2,-877.2 -361.62,-970 -125.42,-178.48 0
0 3
<H1>輪ゴム</H1> <p> <var>n</var> 本の釘を平板上の座標 <var>P<sub>1</sub></var> (<var>x<sub>1</sub></var>, <var>y</sub>1</sub></var>), <var>P<sub>2</sub></var> (<var>x<sub>2</sub></var>, <var>y<sub>2</sub></var>), <var>P<sub>3</sub></var> (<var>x<sub>3</sub></var>, <var>y<sub>3</sub></var>),..., <var>P<sub>n</sub></var> (<var>x<sub>n</sub></var>, <var>y<sub>n</sub></var>) に１本ずつ打ち、輪ゴムの輪の中に全ての釘が入るように 1 本の輪ゴムで囲みます。このとき、輪ゴムが交差してはいけません。 </p> <p> 釘の座標を読み込んで、上記のように釘を輪ゴムで囲んだときに輪ゴムに接していない釘の本数を出力するプログラムを作成してください。輪ゴムは充分に伸び縮みするものとします。同じ座標に 2 本以上の釘を打つことはないものとします。また、輪ゴムがかかった釘と釘の間は直線で結ばれるものとし、その直線上に 3 本以上の釘が並ぶことはないものとします。例えば、図 1 に示すような入力はありえません。図 2 に示すように輪ゴムがかかっていない釘が 1 直線上に並ぶことはありえます。 </p> <center> <table> <tr> <td width="240"><img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_convex1"></td> <td width="240"><img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_convex2"></td> </tr> <tr> <td>図１</td> <td>図２</td> </tr> </table> </center> <br/> <p> ただし、それぞれの座標値は -1000.0 以上1000.0 以下の実数です。また、<var>n</var> は 3 以上 100 以下の整数です。 </p> <H2>Input</H2> <p> 複数のデータセットが与えられます。各データセットは以下のような形式です与えられます。 </p> <pre> <var>n</var> <var>x<sub>1</sub></var>, <var>y<sub>1</sub></var> <var>x<sub>2</sub></var>, <var>y<sub>2</sub></var> ... 　　　　 ... <var>x<sub>n</sub></var>, <var>y<sub>n</sub></var> </pre> <p> <var>n</var> が 0 の時、入力の最後を示します。データセットの数は 50 を超えません。 </p> <H2>Output</H2> <p> データセットごとに、ゴムと接していない釘の本数を出力してください。 例えば、図 3 に示す４つの釘を表す入力があった場合、図 4 のように囲まれるので、輪ゴムに接していない釘の本数は 1 本です。 </p> <center> <table> <tr> <td width="240"><img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_convex3"></td> <td width="240"><img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_convex4"></td> </tr> <tr> <td>図３</td> <td>図４</td> </tr> </table> </center> <br/> <H2>Sample Input</H2> <pre> 4 1.0,0.0 0.0,1.0 2.0,1.0 1.0,2.0 9 -509.94,892.63 567.62,639.99 -859.32,-64.84 -445.99,383.69 667.54,430.49 551.12,828.21 -940.2,-877.2 -361.62,-970 -125.42,-178.48 0 </pre> <H2>Output for the Sample Input</H2> <pre> 0 3 </pre> <H2>Hint</H2> <p> 以下は２つめのサンプル入力に対する図です。 </p> <center> <table> <tr> <td><img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_convex5"></td> </tr> <tr> </tr> </table> </center>
s759206599
p00069
Wrong Answer
import sys import itertools def one_step(lo,lis): nu = [ e for e in lis ] for j in xrange(len(nu)-1): if lo[0][j] == 1: nu[j],nu[j+1] = nu[j+1],nu[j] return lo[1:],nu def solve(lo,lis): if len(lo) == 0: return lis nu = [ e for e in lis] lo2,nu2 = one_step(lo,nu) return solve(lo2,nu2) n = input() m = input() star = input() d = input() lis = range(1,n+1) lots = [] for i in xrange(d): lots.append([ 1 if e == '1' else 0 for e in list(raw_input()) ] ) if solve(lots,lis)[m-1] == star: print 0;exit() lis = range(1,n+1) #print one_step(lots,lis) for i in xrange(d): print i,"-->" if lots[0][0] == 0 and lots[0][1] == 0: lots[0][0] = 1 if solve(lots,lis)[star-1] == m: print i+1,1;exit() lots[0][0] = 0 if lots[0][n-3] == 0 and lots[0][n-2] == 0: lots[0][n-2] = 1 if solve(lots,lis)[star-1] == m: print i+1,n-1;exit() lots[0][n-2] = 0 for j in xrange(1,n-2): if lots[0][j-1] == 0 and lots[0][j] == 0 and lots[0][j+1] == 0: lots[0][j] = 1 if solve(lots,lis)[star-1] == m: print i+1,j+1;exit() lots[0][j] = 0 lots,lis = one_step(lots,lis) print 1
5 2 3 9 1010 1001 0100 1001 0010 1000 0100 0101 1010 0
6 4
<H1>あみだくじ II</H1> <p> 縦線が <var>n</var> 本のあみだくじがあります。このあみだくじは以下の条件を満たしています。 </p> <ul> <li>横線は真横に引きます。斜めに引くことはありません。</li> <li>横線は必ず隣り合った縦線同士をつなぎます。つまり、横線が縦線をまたぐことはありません。</li> <li>どの縦線についても同じ点から左右同時に横線が出ることはありません。つまり、横線が縦線を横切ることはありません。</li> <li>当りはひとつだけです。</li> </ul> <p> 下図 に <var>n</var> = 5 のときの、あみだくじの例を示します。上側の数字は縦線の番号(左から1, 2, 3, 4, 5 ) を表します。☆が当たりです。 </p> <center> <img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_lotsII"> </center> <br/> <p> 縦線の本数 <var>n</var>、選んだ縦線の番号 <var>m</var>、あみだくじの当りの場所、各段における横線の有無を読み込んで、当りにたどり着けるかどうかの判定を出力するプログラムを作成してください。ただし、与えられたあみだくじの任意の位置に1 本だけ横線を付け加えることができるものとします（付け加えなくてもかまいません）。横線を1 本付け加えた後のあみだくじも前述の条件を満たしていなければなりません。 </p> <H2>Input</H2> <p> 複数のデータセットが与えられます。各データセットは以下のとおりです： </p> <p> １行目に、縦線の本数 <var>n</var> (1 &lt; <var>n</var> &le; 10) が書かれています。<br/> ２行目には、選んだ縦線の番号 <var>m</var> (1 &le; <var>m</var> &le; <var>n</var>) が書かれています。<br/> ３行目には、当りの場所（図でいう☆）が左から数えて何番目かが書かれています。<br/> ４行目には、あみだくじの段数 <var>d</var> (1 &le; <var>d</var> &le; 30) が書かれています。<br/> ５行目以降は、図に対応する数字の並びのように、あみだくじの上から順に、各縦線の間に横線があるときを 1、ないときを 0 として、<var>n</var> - 1 つの数字が並んでいます。<br/> <!--あみだくじの段数は d です。<br/>--> </p> <p> 入力は１つの 0 が書かれた行で終わります。 </p> <H2>Output</H2> <p> 各データセットについて、選んだ縦線の番号 <var>m</var> から当りにたどり着けるかどうかに応じて以下の値を出力してください。 </p> <ul> <li>横線を引かなくても当りにたどり着けるときは 0 を出力してください。</li> <li>横線を1 本引けば当りにたどり着けるときは、その中で最も出発側（図でみて上）に近い横線の位置を出力してください。出発側から数えて何段目（図 を参考にしてください）に、左から数えて何番目の縦線から右に向かって横線を引くかを半角の空白で区切って出力してください。</li> <li>横線を1 本引いても当りにたどり着けないときには 1 を出力してください。</li> </ul> <H2>Sample Input</H2> <pre> 5 2 3 9 1010 1001 0100 1001 0010 1000 0100 0101 1010 0 </pre> <H2>Output for the Sample Input</H2> <pre> 6 4 </pre>
s603149087
p00069
Wrong Answer
import sys import itertools def one_step(lo,lis): nu = [ e for e in lis ] for j in xrange(len(nu)-1): if lo[0][j] == 1: nu[j],nu[j+1] = nu[j+1],nu[j] return lo[1:],nu def solve(lo,lis): if len(lo) == 0: return lis nu = [ e for e in lis] lo2,nu2 = one_step(lo,nu) return solve(lo2,nu2) n = input() m = input() star = input() d = input() lis = range(1,n+1) lots = [] for i in xrange(d): lots.append([ 1 if e == '1' else 0 for e in list(raw_input()) ] ) if solve(lots,lis)[m-1] == star: print 0;exit() lis = range(1,n+1) #print one_step(lots,lis) for i in xrange(d): if lots[0][0] == 0 and lots[0][1] == 0: lots[0][0] = 1 if solve(lots,lis)[star-1] == m: print i+1,1;exit() lots[0][0] = 0 if lots[0][n-3] == 0 and lots[0][n-2] == 0: lots[0][n-2] = 1 if solve(lots,lis)[star-1] == m: print i+1,n-1;exit() lots[0][n-2] = 0 for j in xrange(1,n-2): if lots[0][j-1] == 0 and lots[0][j] == 0 and lots[0][j+1] == 0: lots[0][j] = 1 if solve(lots,lis)[star-1] == m: print i+1,j+1;exit() lots[0][j] = 0 lots,lis = one_step(lots,lis) print 1
5 2 3 9 1010 1001 0100 1001 0010 1000 0100 0101 1010 0
6 4
<H1>あみだくじ II</H1> <p> 縦線が <var>n</var> 本のあみだくじがあります。このあみだくじは以下の条件を満たしています。 </p> <ul> <li>横線は真横に引きます。斜めに引くことはありません。</li> <li>横線は必ず隣り合った縦線同士をつなぎます。つまり、横線が縦線をまたぐことはありません。</li> <li>どの縦線についても同じ点から左右同時に横線が出ることはありません。つまり、横線が縦線を横切ることはありません。</li> <li>当りはひとつだけです。</li> </ul> <p> 下図 に <var>n</var> = 5 のときの、あみだくじの例を示します。上側の数字は縦線の番号(左から1, 2, 3, 4, 5 ) を表します。☆が当たりです。 </p> <center> <img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_lotsII"> </center> <br/> <p> 縦線の本数 <var>n</var>、選んだ縦線の番号 <var>m</var>、あみだくじの当りの場所、各段における横線の有無を読み込んで、当りにたどり着けるかどうかの判定を出力するプログラムを作成してください。ただし、与えられたあみだくじの任意の位置に1 本だけ横線を付け加えることができるものとします（付け加えなくてもかまいません）。横線を1 本付け加えた後のあみだくじも前述の条件を満たしていなければなりません。 </p> <H2>Input</H2> <p> 複数のデータセットが与えられます。各データセットは以下のとおりです： </p> <p> １行目に、縦線の本数 <var>n</var> (1 &lt; <var>n</var> &le; 10) が書かれています。<br/> ２行目には、選んだ縦線の番号 <var>m</var> (1 &le; <var>m</var> &le; <var>n</var>) が書かれています。<br/> ３行目には、当りの場所（図でいう☆）が左から数えて何番目かが書かれています。<br/> ４行目には、あみだくじの段数 <var>d</var> (1 &le; <var>d</var> &le; 30) が書かれています。<br/> ５行目以降は、図に対応する数字の並びのように、あみだくじの上から順に、各縦線の間に横線があるときを 1、ないときを 0 として、<var>n</var> - 1 つの数字が並んでいます。<br/> <!--あみだくじの段数は d です。<br/>--> </p> <p> 入力は１つの 0 が書かれた行で終わります。 </p> <H2>Output</H2> <p> 各データセットについて、選んだ縦線の番号 <var>m</var> から当りにたどり着けるかどうかに応じて以下の値を出力してください。 </p> <ul> <li>横線を引かなくても当りにたどり着けるときは 0 を出力してください。</li> <li>横線を1 本引けば当りにたどり着けるときは、その中で最も出発側（図でみて上）に近い横線の位置を出力してください。出発側から数えて何段目（図 を参考にしてください）に、左から数えて何番目の縦線から右に向かって横線を引くかを半角の空白で区切って出力してください。</li> <li>横線を1 本引いても当りにたどり着けないときには 1 を出力してください。</li> </ul> <H2>Sample Input</H2> <pre> 5 2 3 9 1010 1001 0100 1001 0010 1000 0100 0101 1010 0 </pre> <H2>Output for the Sample Input</H2> <pre> 6 4 </pre>
s150278766
p00069
Wrong Answer
import sys import itertools def one_step(lo,lis): nu = [ e for e in lis ] for j in xrange(len(nu)-1): if lo[0][j] == 1: nu[j],nu[j+1] = nu[j+1],nu[j] return lo[1:],nu def solve(lo,lis): if len(lo) == 0: return lis nu = [ e for e in lis] lo2,nu2 = one_step(lo,nu) return solve(lo2,nu2) n = input() m = input() star = input() d = input() lis = range(1,n+1) lots = [] for i in xrange(d): lots.append([ 1 if e == '1' else 0 for e in list(raw_input()) ] ) if solve(lots,lis)[star-1] == m: print 0;exit() lis = range(1,n+1) #print one_step(lots,lis) for i in xrange(d): if lots[0][0] == 0 and lots[0][1] == 0: lots[0][0] = 1 if solve(lots,lis)[star-1] == m: print i+1,1;exit() lots[0][0] = 0 for j in xrange(1,n-2): if lots[0][j-1] == 0 and lots[0][j] == 0 and lots[0][j+1] == 0: lots[0][j] = 1 if solve(lots,lis)[star-1] == m: print i+1,j+1;exit() lots[0][j] = 0 if lots[0][n-3] == 0 and lots[0][n-2] == 0: lots[0][n-2] = 1 if solve(lots,lis)[star-1] == m: print i+1,n-1;exit() lots[0][n-2] = 0 lots,lis = one_step(lots,lis) print 1
5 2 3 9 1010 1001 0100 1001 0010 1000 0100 0101 1010 0
6 4
<H1>あみだくじ II</H1> <p> 縦線が <var>n</var> 本のあみだくじがあります。このあみだくじは以下の条件を満たしています。 </p> <ul> <li>横線は真横に引きます。斜めに引くことはありません。</li> <li>横線は必ず隣り合った縦線同士をつなぎます。つまり、横線が縦線をまたぐことはありません。</li> <li>どの縦線についても同じ点から左右同時に横線が出ることはありません。つまり、横線が縦線を横切ることはありません。</li> <li>当りはひとつだけです。</li> </ul> <p> 下図 に <var>n</var> = 5 のときの、あみだくじの例を示します。上側の数字は縦線の番号(左から1, 2, 3, 4, 5 ) を表します。☆が当たりです。 </p> <center> <img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_lotsII"> </center> <br/> <p> 縦線の本数 <var>n</var>、選んだ縦線の番号 <var>m</var>、あみだくじの当りの場所、各段における横線の有無を読み込んで、当りにたどり着けるかどうかの判定を出力するプログラムを作成してください。ただし、与えられたあみだくじの任意の位置に1 本だけ横線を付け加えることができるものとします（付け加えなくてもかまいません）。横線を1 本付け加えた後のあみだくじも前述の条件を満たしていなければなりません。 </p> <H2>Input</H2> <p> 複数のデータセットが与えられます。各データセットは以下のとおりです： </p> <p> １行目に、縦線の本数 <var>n</var> (1 &lt; <var>n</var> &le; 10) が書かれています。<br/> ２行目には、選んだ縦線の番号 <var>m</var> (1 &le; <var>m</var> &le; <var>n</var>) が書かれています。<br/> ３行目には、当りの場所（図でいう☆）が左から数えて何番目かが書かれています。<br/> ４行目には、あみだくじの段数 <var>d</var> (1 &le; <var>d</var> &le; 30) が書かれています。<br/> ５行目以降は、図に対応する数字の並びのように、あみだくじの上から順に、各縦線の間に横線があるときを 1、ないときを 0 として、<var>n</var> - 1 つの数字が並んでいます。<br/> <!--あみだくじの段数は d です。<br/>--> </p> <p> 入力は１つの 0 が書かれた行で終わります。 </p> <H2>Output</H2> <p> 各データセットについて、選んだ縦線の番号 <var>m</var> から当りにたどり着けるかどうかに応じて以下の値を出力してください。 </p> <ul> <li>横線を引かなくても当りにたどり着けるときは 0 を出力してください。</li> <li>横線を1 本引けば当りにたどり着けるときは、その中で最も出発側（図でみて上）に近い横線の位置を出力してください。出発側から数えて何段目（図 を参考にしてください）に、左から数えて何番目の縦線から右に向かって横線を引くかを半角の空白で区切って出力してください。</li> <li>横線を1 本引いても当りにたどり着けないときには 1 を出力してください。</li> </ul> <H2>Sample Input</H2> <pre> 5 2 3 9 1010 1001 0100 1001 0010 1000 0100 0101 1010 0 </pre> <H2>Output for the Sample Input</H2> <pre> 6 4 </pre>
s304788474
p00069
Wrong Answer
import sys import itertools def one_step(lo,lis): nu = [ e for e in lis ] for j in xrange(len(nu)-1): if lo[0][j] == 1: nu[j],nu[j+1] = nu[j+1],nu[j] return lo[1:],nu def solve(lo,lis): if len(lo) == 0: return lis nu = [ e for e in lis] lo2,nu2 = one_step(lo,nu) return solve(lo2,nu2) n = input() m = input() star = input() d = input() lis = range(1,n+1) lots = [] for i in xrange(d): lots.append([ 1 if e == '1' else 0 for e in list(raw_input()) ] ) if solve(lots,lis)[star-1] == m: print 0;exit() for i in xrange(d): if lots[0][0] == 0 and lots[0][1] == 0: lots[0][0] = 1 if solve(lots,lis)[star-1] == m: print i+1,1;exit() lots[0][0] = 0 for j in xrange(1,n-2): if lots[0][j-1] == 0 and lots[0][j] == 0 and lots[0][j+1] == 0: lots[0][j] = 1 if solve(lots,lis)[star-1] == m: print i+1,j+1;exit() lots[0][j] = 0 if lots[0][n-3] == 0 and lots[0][n-2] == 0: lots[0][n-2] = 1 if solve(lots,lis)[star-1] == m: print i+1,n-1;exit() lots[0][n-2] = 0 lots,lis = one_step(lots,lis) print 1
5 2 3 9 1010 1001 0100 1001 0010 1000 0100 0101 1010 0
6 4
<H1>あみだくじ II</H1> <p> 縦線が <var>n</var> 本のあみだくじがあります。このあみだくじは以下の条件を満たしています。 </p> <ul> <li>横線は真横に引きます。斜めに引くことはありません。</li> <li>横線は必ず隣り合った縦線同士をつなぎます。つまり、横線が縦線をまたぐことはありません。</li> <li>どの縦線についても同じ点から左右同時に横線が出ることはありません。つまり、横線が縦線を横切ることはありません。</li> <li>当りはひとつだけです。</li> </ul> <p> 下図 に <var>n</var> = 5 のときの、あみだくじの例を示します。上側の数字は縦線の番号(左から1, 2, 3, 4, 5 ) を表します。☆が当たりです。 </p> <center> <img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_lotsII"> </center> <br/> <p> 縦線の本数 <var>n</var>、選んだ縦線の番号 <var>m</var>、あみだくじの当りの場所、各段における横線の有無を読み込んで、当りにたどり着けるかどうかの判定を出力するプログラムを作成してください。ただし、与えられたあみだくじの任意の位置に1 本だけ横線を付け加えることができるものとします（付け加えなくてもかまいません）。横線を1 本付け加えた後のあみだくじも前述の条件を満たしていなければなりません。 </p> <H2>Input</H2> <p> 複数のデータセットが与えられます。各データセットは以下のとおりです： </p> <p> １行目に、縦線の本数 <var>n</var> (1 &lt; <var>n</var> &le; 10) が書かれています。<br/> ２行目には、選んだ縦線の番号 <var>m</var> (1 &le; <var>m</var> &le; <var>n</var>) が書かれています。<br/> ３行目には、当りの場所（図でいう☆）が左から数えて何番目かが書かれています。<br/> ４行目には、あみだくじの段数 <var>d</var> (1 &le; <var>d</var> &le; 30) が書かれています。<br/> ５行目以降は、図に対応する数字の並びのように、あみだくじの上から順に、各縦線の間に横線があるときを 1、ないときを 0 として、<var>n</var> - 1 つの数字が並んでいます。<br/> <!--あみだくじの段数は d です。<br/>--> </p> <p> 入力は１つの 0 が書かれた行で終わります。 </p> <H2>Output</H2> <p> 各データセットについて、選んだ縦線の番号 <var>m</var> から当りにたどり着けるかどうかに応じて以下の値を出力してください。 </p> <ul> <li>横線を引かなくても当りにたどり着けるときは 0 を出力してください。</li> <li>横線を1 本引けば当りにたどり着けるときは、その中で最も出発側（図でみて上）に近い横線の位置を出力してください。出発側から数えて何段目（図 を参考にしてください）に、左から数えて何番目の縦線から右に向かって横線を引くかを半角の空白で区切って出力してください。</li> <li>横線を1 本引いても当りにたどり着けないときには 1 を出力してください。</li> </ul> <H2>Sample Input</H2> <pre> 5 2 3 9 1010 1001 0100 1001 0010 1000 0100 0101 1010 0 </pre> <H2>Output for the Sample Input</H2> <pre> 6 4 </pre>
s026406848
p00069
Wrong Answer
import sys import itertools def one_step(lo,lis): nu = [ e for e in lis ] for j in xrange(len(nu)): if lo[0][j] == 1: nu[j],nu[j+1] = nu[j+1],nu[j] return lo[1:],nu def solve(lo,lis): if len(lo) == 0: return lis nu = [ e for e in lis] lo2,nu2 = one_step(lo,nu) return solve(lo2,nu2) n = input() m = input() star = input() d = input() lis = range(n+1) lots = [] for i in xrange(d): lots.append([0]+[ 1 if e == '1' else 0 for e in list(raw_input()) ] +[0]) if solve(lots,lis)[star] == m: print 0;exit() for i in xrange(d): for j in xrange(1,n): if lots[0][j-1] == 0 and lots[0][j] == 0 and lots[0][j+1] == 0: lots[0][j] = 1 if solve(lots,lis)[star] == m: print i+1,j;exit() lots[0][j] = 0 lots,lis = one_step(lots,lis) print 1
5 2 3 9 1010 1001 0100 1001 0010 1000 0100 0101 1010 0
6 4
<H1>あみだくじ II</H1> <p> 縦線が <var>n</var> 本のあみだくじがあります。このあみだくじは以下の条件を満たしています。 </p> <ul> <li>横線は真横に引きます。斜めに引くことはありません。</li> <li>横線は必ず隣り合った縦線同士をつなぎます。つまり、横線が縦線をまたぐことはありません。</li> <li>どの縦線についても同じ点から左右同時に横線が出ることはありません。つまり、横線が縦線を横切ることはありません。</li> <li>当りはひとつだけです。</li> </ul> <p> 下図 に <var>n</var> = 5 のときの、あみだくじの例を示します。上側の数字は縦線の番号(左から1, 2, 3, 4, 5 ) を表します。☆が当たりです。 </p> <center> <img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_lotsII"> </center> <br/> <p> 縦線の本数 <var>n</var>、選んだ縦線の番号 <var>m</var>、あみだくじの当りの場所、各段における横線の有無を読み込んで、当りにたどり着けるかどうかの判定を出力するプログラムを作成してください。ただし、与えられたあみだくじの任意の位置に1 本だけ横線を付け加えることができるものとします（付け加えなくてもかまいません）。横線を1 本付け加えた後のあみだくじも前述の条件を満たしていなければなりません。 </p> <H2>Input</H2> <p> 複数のデータセットが与えられます。各データセットは以下のとおりです： </p> <p> １行目に、縦線の本数 <var>n</var> (1 &lt; <var>n</var> &le; 10) が書かれています。<br/> ２行目には、選んだ縦線の番号 <var>m</var> (1 &le; <var>m</var> &le; <var>n</var>) が書かれています。<br/> ３行目には、当りの場所（図でいう☆）が左から数えて何番目かが書かれています。<br/> ４行目には、あみだくじの段数 <var>d</var> (1 &le; <var>d</var> &le; 30) が書かれています。<br/> ５行目以降は、図に対応する数字の並びのように、あみだくじの上から順に、各縦線の間に横線があるときを 1、ないときを 0 として、<var>n</var> - 1 つの数字が並んでいます。<br/> <!--あみだくじの段数は d です。<br/>--> </p> <p> 入力は１つの 0 が書かれた行で終わります。 </p> <H2>Output</H2> <p> 各データセットについて、選んだ縦線の番号 <var>m</var> から当りにたどり着けるかどうかに応じて以下の値を出力してください。 </p> <ul> <li>横線を引かなくても当りにたどり着けるときは 0 を出力してください。</li> <li>横線を1 本引けば当りにたどり着けるときは、その中で最も出発側（図でみて上）に近い横線の位置を出力してください。出発側から数えて何段目（図 を参考にしてください）に、左から数えて何番目の縦線から右に向かって横線を引くかを半角の空白で区切って出力してください。</li> <li>横線を1 本引いても当りにたどり着けないときには 1 を出力してください。</li> </ul> <H2>Sample Input</H2> <pre> 5 2 3 9 1010 1001 0100 1001 0010 1000 0100 0101 1010 0 </pre> <H2>Output for the Sample Input</H2> <pre> 6 4 </pre>
s148512790
p00069
Wrong Answer
import sys import itertools def one_step(lo,lis): nu = [ e for e in lis ] for j in xrange(len(nu)): if lo[0][j] == 1: nu[j],nu[j+1] = nu[j+1],nu[j] return lo[1:],nu def solve(lo,lis): if len(lo) == 0: return lis nu = [ e for e in lis] lo2,nu2 = one_step(lo,nu) return solve(lo2,nu2) n = input() m = input() star = input() d = input() lis = range(n+1) lots = [] for i in xrange(d): lots.append([0]+[ 1 if e == '1' else 0 for e in list(raw_input()) ] +[0]) if solve(lots,lis)[star] == m: print 0;exit() for i in xrange(d): for j in xrange(1,n): if lots[i][j-1] == 0 and lots[i][j] == 0 and lots[i][j+1] == 0: lots[i][j] = 1 if solve(lots,lis)[star] == m: print i+1,j;exit() lots[i][j] = 0 print 1
5 2 3 9 1010 1001 0100 1001 0010 1000 0100 0101 1010 0
6 4
<H1>あみだくじ II</H1> <p> 縦線が <var>n</var> 本のあみだくじがあります。このあみだくじは以下の条件を満たしています。 </p> <ul> <li>横線は真横に引きます。斜めに引くことはありません。</li> <li>横線は必ず隣り合った縦線同士をつなぎます。つまり、横線が縦線をまたぐことはありません。</li> <li>どの縦線についても同じ点から左右同時に横線が出ることはありません。つまり、横線が縦線を横切ることはありません。</li> <li>当りはひとつだけです。</li> </ul> <p> 下図 に <var>n</var> = 5 のときの、あみだくじの例を示します。上側の数字は縦線の番号(左から1, 2, 3, 4, 5 ) を表します。☆が当たりです。 </p> <center> <img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_lotsII"> </center> <br/> <p> 縦線の本数 <var>n</var>、選んだ縦線の番号 <var>m</var>、あみだくじの当りの場所、各段における横線の有無を読み込んで、当りにたどり着けるかどうかの判定を出力するプログラムを作成してください。ただし、与えられたあみだくじの任意の位置に1 本だけ横線を付け加えることができるものとします（付け加えなくてもかまいません）。横線を1 本付け加えた後のあみだくじも前述の条件を満たしていなければなりません。 </p> <H2>Input</H2> <p> 複数のデータセットが与えられます。各データセットは以下のとおりです： </p> <p> １行目に、縦線の本数 <var>n</var> (1 &lt; <var>n</var> &le; 10) が書かれています。<br/> ２行目には、選んだ縦線の番号 <var>m</var> (1 &le; <var>m</var> &le; <var>n</var>) が書かれています。<br/> ３行目には、当りの場所（図でいう☆）が左から数えて何番目かが書かれています。<br/> ４行目には、あみだくじの段数 <var>d</var> (1 &le; <var>d</var> &le; 30) が書かれています。<br/> ５行目以降は、図に対応する数字の並びのように、あみだくじの上から順に、各縦線の間に横線があるときを 1、ないときを 0 として、<var>n</var> - 1 つの数字が並んでいます。<br/> <!--あみだくじの段数は d です。<br/>--> </p> <p> 入力は１つの 0 が書かれた行で終わります。 </p> <H2>Output</H2> <p> 各データセットについて、選んだ縦線の番号 <var>m</var> から当りにたどり着けるかどうかに応じて以下の値を出力してください。 </p> <ul> <li>横線を引かなくても当りにたどり着けるときは 0 を出力してください。</li> <li>横線を1 本引けば当りにたどり着けるときは、その中で最も出発側（図でみて上）に近い横線の位置を出力してください。出発側から数えて何段目（図 を参考にしてください）に、左から数えて何番目の縦線から右に向かって横線を引くかを半角の空白で区切って出力してください。</li> <li>横線を1 本引いても当りにたどり着けないときには 1 を出力してください。</li> </ul> <H2>Sample Input</H2> <pre> 5 2 3 9 1010 1001 0100 1001 0010 1000 0100 0101 1010 0 </pre> <H2>Output for the Sample Input</H2> <pre> 6 4 </pre>
s691944969
p00069
Wrong Answer
import sys import itertools def one_step(lo,lis): nu = [ e for e in lis ] for j in xrange(len(nu)): if lo[0][j] == 1: nu[j],nu[j+1] = nu[j+1],nu[j] return lo[1:],nu def solve(lo,lis): if len(lo) == 0: return lis nu = [ e for e in lis] lo2,nu2 = one_step(lo,nu) return solve(lo2,nu2) n = input() m = input() star = input() d = input() lis = range(n+1) lots = [] for i in xrange(d): lots.append([0]+[ 1 if e == '1' else 0 for e in list(raw_input()) ] +[0]) if solve(lots,lis)[star] == m: print 0;exit() for i in xrange(d): for j in xrange(1,n): if lots[i][j-1] == 0 and lots[i][j] == 0 and lots[i][j+1] == 0: lots[i][j] = 1 if solve(lots,lis)[star] == m: print i+1,j;exit() lots[i][j] = 0 print 1;exit()
5 2 3 9 1010 1001 0100 1001 0010 1000 0100 0101 1010 0
6 4
<H1>あみだくじ II</H1> <p> 縦線が <var>n</var> 本のあみだくじがあります。このあみだくじは以下の条件を満たしています。 </p> <ul> <li>横線は真横に引きます。斜めに引くことはありません。</li> <li>横線は必ず隣り合った縦線同士をつなぎます。つまり、横線が縦線をまたぐことはありません。</li> <li>どの縦線についても同じ点から左右同時に横線が出ることはありません。つまり、横線が縦線を横切ることはありません。</li> <li>当りはひとつだけです。</li> </ul> <p> 下図 に <var>n</var> = 5 のときの、あみだくじの例を示します。上側の数字は縦線の番号(左から1, 2, 3, 4, 5 ) を表します。☆が当たりです。 </p> <center> <img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_lotsII"> </center> <br/> <p> 縦線の本数 <var>n</var>、選んだ縦線の番号 <var>m</var>、あみだくじの当りの場所、各段における横線の有無を読み込んで、当りにたどり着けるかどうかの判定を出力するプログラムを作成してください。ただし、与えられたあみだくじの任意の位置に1 本だけ横線を付け加えることができるものとします（付け加えなくてもかまいません）。横線を1 本付け加えた後のあみだくじも前述の条件を満たしていなければなりません。 </p> <H2>Input</H2> <p> 複数のデータセットが与えられます。各データセットは以下のとおりです： </p> <p> １行目に、縦線の本数 <var>n</var> (1 &lt; <var>n</var> &le; 10) が書かれています。<br/> ２行目には、選んだ縦線の番号 <var>m</var> (1 &le; <var>m</var> &le; <var>n</var>) が書かれています。<br/> ３行目には、当りの場所（図でいう☆）が左から数えて何番目かが書かれています。<br/> ４行目には、あみだくじの段数 <var>d</var> (1 &le; <var>d</var> &le; 30) が書かれています。<br/> ５行目以降は、図に対応する数字の並びのように、あみだくじの上から順に、各縦線の間に横線があるときを 1、ないときを 0 として、<var>n</var> - 1 つの数字が並んでいます。<br/> <!--あみだくじの段数は d です。<br/>--> </p> <p> 入力は１つの 0 が書かれた行で終わります。 </p> <H2>Output</H2> <p> 各データセットについて、選んだ縦線の番号 <var>m</var> から当りにたどり着けるかどうかに応じて以下の値を出力してください。 </p> <ul> <li>横線を引かなくても当りにたどり着けるときは 0 を出力してください。</li> <li>横線を1 本引けば当りにたどり着けるときは、その中で最も出発側（図でみて上）に近い横線の位置を出力してください。出発側から数えて何段目（図 を参考にしてください）に、左から数えて何番目の縦線から右に向かって横線を引くかを半角の空白で区切って出力してください。</li> <li>横線を1 本引いても当りにたどり着けないときには 1 を出力してください。</li> </ul> <H2>Sample Input</H2> <pre> 5 2 3 9 1010 1001 0100 1001 0010 1000 0100 0101 1010 0 </pre> <H2>Output for the Sample Input</H2> <pre> 6 4 </pre>
s554882282
p00069
Wrong Answer
import sys import itertools def one_step(lo,lis): nu = [ e for e in lis ] for j in xrange(len(nu)): if lo[0][j] == 1: nu[j],nu[j+1] = nu[j+1],nu[j] return lo[1:],nu def solve(lo,lis): if len(lo) == 0: return lis nu = [ e for e in lis] lo2,nu2 = one_step(lo,nu) return solve(lo2,nu2) while True: n = input() if n == 0: exit() m = input() star = input() d = input() lis = range(n+1) lots = [] for i in xrange(d): lots.append([0]+[ 1 if e == '1' else 0 for e in list(raw_input()) ] +[0]) if solve(lots,lis)[star] == m: print 0;exit() for i,j in itertools.product(xrange(d),xrange(1,n)): if lots[i][j-1] == 0 and lots[i][j] == 0 and lots[i][j+1] == 0: lots[i][j] = 1 if solve(lots,lis)[star] == m: print i+1,j;break lots[i][j] = 0 else:print 1
5 2 3 9 1010 1001 0100 1001 0010 1000 0100 0101 1010 0
6 4
<H1>あみだくじ II</H1> <p> 縦線が <var>n</var> 本のあみだくじがあります。このあみだくじは以下の条件を満たしています。 </p> <ul> <li>横線は真横に引きます。斜めに引くことはありません。</li> <li>横線は必ず隣り合った縦線同士をつなぎます。つまり、横線が縦線をまたぐことはありません。</li> <li>どの縦線についても同じ点から左右同時に横線が出ることはありません。つまり、横線が縦線を横切ることはありません。</li> <li>当りはひとつだけです。</li> </ul> <p> 下図 に <var>n</var> = 5 のときの、あみだくじの例を示します。上側の数字は縦線の番号(左から1, 2, 3, 4, 5 ) を表します。☆が当たりです。 </p> <center> <img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_lotsII"> </center> <br/> <p> 縦線の本数 <var>n</var>、選んだ縦線の番号 <var>m</var>、あみだくじの当りの場所、各段における横線の有無を読み込んで、当りにたどり着けるかどうかの判定を出力するプログラムを作成してください。ただし、与えられたあみだくじの任意の位置に1 本だけ横線を付け加えることができるものとします（付け加えなくてもかまいません）。横線を1 本付け加えた後のあみだくじも前述の条件を満たしていなければなりません。 </p> <H2>Input</H2> <p> 複数のデータセットが与えられます。各データセットは以下のとおりです： </p> <p> １行目に、縦線の本数 <var>n</var> (1 &lt; <var>n</var> &le; 10) が書かれています。<br/> ２行目には、選んだ縦線の番号 <var>m</var> (1 &le; <var>m</var> &le; <var>n</var>) が書かれています。<br/> ３行目には、当りの場所（図でいう☆）が左から数えて何番目かが書かれています。<br/> ４行目には、あみだくじの段数 <var>d</var> (1 &le; <var>d</var> &le; 30) が書かれています。<br/> ５行目以降は、図に対応する数字の並びのように、あみだくじの上から順に、各縦線の間に横線があるときを 1、ないときを 0 として、<var>n</var> - 1 つの数字が並んでいます。<br/> <!--あみだくじの段数は d です。<br/>--> </p> <p> 入力は１つの 0 が書かれた行で終わります。 </p> <H2>Output</H2> <p> 各データセットについて、選んだ縦線の番号 <var>m</var> から当りにたどり着けるかどうかに応じて以下の値を出力してください。 </p> <ul> <li>横線を引かなくても当りにたどり着けるときは 0 を出力してください。</li> <li>横線を1 本引けば当りにたどり着けるときは、その中で最も出発側（図でみて上）に近い横線の位置を出力してください。出発側から数えて何段目（図 を参考にしてください）に、左から数えて何番目の縦線から右に向かって横線を引くかを半角の空白で区切って出力してください。</li> <li>横線を1 本引いても当りにたどり着けないときには 1 を出力してください。</li> </ul> <H2>Sample Input</H2> <pre> 5 2 3 9 1010 1001 0100 1001 0010 1000 0100 0101 1010 0 </pre> <H2>Output for the Sample Input</H2> <pre> 6 4 </pre>