submission_id string | problem_id string | status string | code string | input string | output string | problem_description string |
|---|---|---|---|---|---|---|
s184127271 | p00078 | Accepted | def chekend(mc):
for m in mc:
if not all(m):
return False
return True
def solve(n):
mc = [ [ 0 for j in xrange(n) ] for i in xrange(n)]
px = n/2
py = n/2 + 1
cnt = 1
mc[py][px] = cnt
px += 1
py += 1
cnt += 1
while True:
if chekend(mc): break
if px >= n: px = 0; continue
if px < 0: px = n-1; continue
if py >= n: py = 0; continue
if mc[py][px]: px -= 1; py += 1; continue
mc[py][px] = cnt
cnt += 1
px += 1
py += 1
for m in mc:
line = ""
for l in m:
line += "%4d"%(l)
print line
while True:
n = input()
if n == 0:
break
solve(n) | 3
5
0
| 4 9 2
3 5 7
8 1 6
11 24 7 20 3
4 12 25 8 16
17 5 13 21 9
10 18 1 14 22
23 6 19 2 15
|
<H1>魔方陣</H1>
<p>
<var>n</var> × <var>n</var> の正方形のマス目の中に数字の１から <var>n</var> × <var>n</var> が一つずつ入っていて、縦のどの列のマス目の和も、横のどの列のマス目の和も対角線のマス目の和も等しいものを魔方陣といいます。
</p>
<p>
一辺のマスの個数が奇数の魔方陣の作り方には以下の方法があります。
</p>
<ol>
<li>中央のマス目のちょうど一つ下のマス目に１を入れる。</li>
<li>次の数字を右斜め下のマス目に入れる。<br>ただし、数字を入れようとしたマス目が正方形からはみ出している場合、すでに数字が埋まっている場合は以下の方法に従って数字を入れるマス目を探す。</li>
<ul>
<li>右にはみ出した場合には、同じ行の左はしに、左にはみ出した場合には、同じ行の右はしに、下にはみ出した場合には、同じ列の一番上に数字を入れる。
</li>
<li> 数字を入れようとしたマス目が埋まっているときには、その埋まっているマス目の左斜め下のマス目に入れる。
</li>
</ul>
<li>全てのマス目が埋まるまで２を繰り返す。
</ol>
<p>
この方法に従って、一辺のマス目の個数 <var>n</var> を入力として、その大きさの魔方陣を出力するプログラムを作成して下さい。ただし、<var>n</var> は 3 以上 15 以下の奇数とします。マス目に入る各数字は右詰 4 桁で出力してください。
</p>
<H2>入力</H2>
<p>複数の入力が与えられます。各入力で <var>n</var> （正の整数）が１行に与えられます。入力は 0 で終了します。入力の数は 10 を超えません。</p>
<H2>出力</H2>
<p>各入力に対して <var>n</var> × <var>n</var> の魔方陣を出力して下さい。</p>
<H2>Sample Input</H2>
<pre>
3
5
0
</pre>
<H2>Output for the Sample Input</H2>
<pre>
4 9 2
3 5 7
8 1 6
11 24 7 20 3
4 12 25 8 16
17 5 13 21 9
10 18 1 14 22
23 6 19 2 15
</pre>
|
s726191517 | p00078 | Accepted | import sys
f = sys.stdin
def set1(sq):
x = len(sq) // 2
y = len(sq) // 2 + 1
square[y][x] = 1
return x, y, 1
def mv_r(sq, x, y):
x = (x + 1) % len(sq)
y = (y + 1) % len(sq)
return x, y
def mv_l(sq, x, y):
x -= 1
if x < 0:
x += len(sq)
y = (y + 1) % len(sq)
return x, y
def setnext(sq, x, y, i):
x, y = mv_r(sq, x,y)
i += 1
while sq[y][x]:
x, y = mv_l(sq, x, y)
sq[y][x] = i
return x, y, i
while True:
n = int(f.readline())
if n == 0:
break
square = [[None for j in range(n)] for i in range(n)]
arg = set1(square)
for i in range(n * n - 1):
arg = setnext(square,*arg)
for line in square:
for num in line:
print("{:4d}".format(num),end='')
print() | 3
5
0
| 4 9 2
3 5 7
8 1 6
11 24 7 20 3
4 12 25 8 16
17 5 13 21 9
10 18 1 14 22
23 6 19 2 15
|
<H1>魔方陣</H1>
<p>
<var>n</var> × <var>n</var> の正方形のマス目の中に数字の１から <var>n</var> × <var>n</var> が一つずつ入っていて、縦のどの列のマス目の和も、横のどの列のマス目の和も対角線のマス目の和も等しいものを魔方陣といいます。
</p>
<p>
一辺のマスの個数が奇数の魔方陣の作り方には以下の方法があります。
</p>
<ol>
<li>中央のマス目のちょうど一つ下のマス目に１を入れる。</li>
<li>次の数字を右斜め下のマス目に入れる。<br>ただし、数字を入れようとしたマス目が正方形からはみ出している場合、すでに数字が埋まっている場合は以下の方法に従って数字を入れるマス目を探す。</li>
<ul>
<li>右にはみ出した場合には、同じ行の左はしに、左にはみ出した場合には、同じ行の右はしに、下にはみ出した場合には、同じ列の一番上に数字を入れる。
</li>
<li> 数字を入れようとしたマス目が埋まっているときには、その埋まっているマス目の左斜め下のマス目に入れる。
</li>
</ul>
<li>全てのマス目が埋まるまで２を繰り返す。
</ol>
<p>
この方法に従って、一辺のマス目の個数 <var>n</var> を入力として、その大きさの魔方陣を出力するプログラムを作成して下さい。ただし、<var>n</var> は 3 以上 15 以下の奇数とします。マス目に入る各数字は右詰 4 桁で出力してください。
</p>
<H2>入力</H2>
<p>複数の入力が与えられます。各入力で <var>n</var> （正の整数）が１行に与えられます。入力は 0 で終了します。入力の数は 10 を超えません。</p>
<H2>出力</H2>
<p>各入力に対して <var>n</var> × <var>n</var> の魔方陣を出力して下さい。</p>
<H2>Sample Input</H2>
<pre>
3
5
0
</pre>
<H2>Output for the Sample Input</H2>
<pre>
4 9 2
3 5 7
8 1 6
11 24 7 20 3
4 12 25 8 16
17 5 13 21 9
10 18 1 14 22
23 6 19 2 15
</pre>
|
s861666892 | p00078 | Accepted | import sys
while True:
n=input()
if n==0:
break
magic=[[0 for i in range(n)] for j in range(n)]
i=n/2
j=n/2+1
for number in range(1,n*n+1):
magic[j][i]=number
if number==n*n:
break
if magic[(j+1)%n][(i+1)%n]==0:
i,j=(i+1)%n,(j+1)%n
else:
i,j=(i+1)%n,(j+1)%n
while magic[j][i]!=0:
i,j=(i-1)%n,(j+1)%n
for i in range(n):
print "".join(["%4d" %(e) for e in magic[i]]) | 3
5
0
| 4 9 2
3 5 7
8 1 6
11 24 7 20 3
4 12 25 8 16
17 5 13 21 9
10 18 1 14 22
23 6 19 2 15
|
<H1>魔方陣</H1>
<p>
<var>n</var> × <var>n</var> の正方形のマス目の中に数字の１から <var>n</var> × <var>n</var> が一つずつ入っていて、縦のどの列のマス目の和も、横のどの列のマス目の和も対角線のマス目の和も等しいものを魔方陣といいます。
</p>
<p>
一辺のマスの個数が奇数の魔方陣の作り方には以下の方法があります。
</p>
<ol>
<li>中央のマス目のちょうど一つ下のマス目に１を入れる。</li>
<li>次の数字を右斜め下のマス目に入れる。<br>ただし、数字を入れようとしたマス目が正方形からはみ出している場合、すでに数字が埋まっている場合は以下の方法に従って数字を入れるマス目を探す。</li>
<ul>
<li>右にはみ出した場合には、同じ行の左はしに、左にはみ出した場合には、同じ行の右はしに、下にはみ出した場合には、同じ列の一番上に数字を入れる。
</li>
<li> 数字を入れようとしたマス目が埋まっているときには、その埋まっているマス目の左斜め下のマス目に入れる。
</li>
</ul>
<li>全てのマス目が埋まるまで２を繰り返す。
</ol>
<p>
この方法に従って、一辺のマス目の個数 <var>n</var> を入力として、その大きさの魔方陣を出力するプログラムを作成して下さい。ただし、<var>n</var> は 3 以上 15 以下の奇数とします。マス目に入る各数字は右詰 4 桁で出力してください。
</p>
<H2>入力</H2>
<p>複数の入力が与えられます。各入力で <var>n</var> （正の整数）が１行に与えられます。入力は 0 で終了します。入力の数は 10 を超えません。</p>
<H2>出力</H2>
<p>各入力に対して <var>n</var> × <var>n</var> の魔方陣を出力して下さい。</p>
<H2>Sample Input</H2>
<pre>
3
5
0
</pre>
<H2>Output for the Sample Input</H2>
<pre>
4 9 2
3 5 7
8 1 6
11 24 7 20 3
4 12 25 8 16
17 5 13 21 9
10 18 1 14 22
23 6 19 2 15
</pre>
|
s505804580 | p00078 | Accepted | while True:
n = int(input())
if n==0:
break
else:
l = [[0 for i in range(n)] for j in range(n)]
x = n//2
y = n//2+1
c = 0
while c < n**2:
c += 1
while l[y][x] != 0:
y += 1
if y >= n:
y = 0
x -= 1
if x <= -1:
x = n-1
l[y][x] = c
x += 1
if x >= n:
x = 0
y += 1
if y >= n:
y = 0
for i in l:
a = ''
for j in i:
if 0 <= j < 10**1:
a = a + ' ' + str(j)
elif 10**1<=j<10**2:
a = a + ' ' + str(j)
elif 10**2<=j<10**3:
a = a + ' ' + str(j)
print(a) | 3
5
0
| 4 9 2
3 5 7
8 1 6
11 24 7 20 3
4 12 25 8 16
17 5 13 21 9
10 18 1 14 22
23 6 19 2 15
|
<H1>魔方陣</H1>
<p>
<var>n</var> × <var>n</var> の正方形のマス目の中に数字の１から <var>n</var> × <var>n</var> が一つずつ入っていて、縦のどの列のマス目の和も、横のどの列のマス目の和も対角線のマス目の和も等しいものを魔方陣といいます。
</p>
<p>
一辺のマスの個数が奇数の魔方陣の作り方には以下の方法があります。
</p>
<ol>
<li>中央のマス目のちょうど一つ下のマス目に１を入れる。</li>
<li>次の数字を右斜め下のマス目に入れる。<br>ただし、数字を入れようとしたマス目が正方形からはみ出している場合、すでに数字が埋まっている場合は以下の方法に従って数字を入れるマス目を探す。</li>
<ul>
<li>右にはみ出した場合には、同じ行の左はしに、左にはみ出した場合には、同じ行の右はしに、下にはみ出した場合には、同じ列の一番上に数字を入れる。
</li>
<li> 数字を入れようとしたマス目が埋まっているときには、その埋まっているマス目の左斜め下のマス目に入れる。
</li>
</ul>
<li>全てのマス目が埋まるまで２を繰り返す。
</ol>
<p>
この方法に従って、一辺のマス目の個数 <var>n</var> を入力として、その大きさの魔方陣を出力するプログラムを作成して下さい。ただし、<var>n</var> は 3 以上 15 以下の奇数とします。マス目に入る各数字は右詰 4 桁で出力してください。
</p>
<H2>入力</H2>
<p>複数の入力が与えられます。各入力で <var>n</var> （正の整数）が１行に与えられます。入力は 0 で終了します。入力の数は 10 を超えません。</p>
<H2>出力</H2>
<p>各入力に対して <var>n</var> × <var>n</var> の魔方陣を出力して下さい。</p>
<H2>Sample Input</H2>
<pre>
3
5
0
</pre>
<H2>Output for the Sample Input</H2>
<pre>
4 9 2
3 5 7
8 1 6
11 24 7 20 3
4 12 25 8 16
17 5 13 21 9
10 18 1 14 22
23 6 19 2 15
</pre>
|
s697128699 | p00078 | Accepted |
while 1:
n=int(raw_input())
if n==0:
break
l=[[0]*n for i in range(n)]
x,y=n/2,n/2+1
l[y][x]=1
cnt=2
while cnt<=n**2:
x,y=(x+1)%n,(y+1)%n
if l[y][x]==0:
l[y][x]=cnt
cnt+=1
else:
x,y=(x-1)%n,(y+1)%n
l[y][x]=cnt
cnt+=1
for i in range(n):
print ''.join(map(lambda s:str(s).rjust(4),l[i])) | 3
5
0
| 4 9 2
3 5 7
8 1 6
11 24 7 20 3
4 12 25 8 16
17 5 13 21 9
10 18 1 14 22
23 6 19 2 15
|
<H1>魔方陣</H1>
<p>
<var>n</var> × <var>n</var> の正方形のマス目の中に数字の１から <var>n</var> × <var>n</var> が一つずつ入っていて、縦のどの列のマス目の和も、横のどの列のマス目の和も対角線のマス目の和も等しいものを魔方陣といいます。
</p>
<p>
一辺のマスの個数が奇数の魔方陣の作り方には以下の方法があります。
</p>
<ol>
<li>中央のマス目のちょうど一つ下のマス目に１を入れる。</li>
<li>次の数字を右斜め下のマス目に入れる。<br>ただし、数字を入れようとしたマス目が正方形からはみ出している場合、すでに数字が埋まっている場合は以下の方法に従って数字を入れるマス目を探す。</li>
<ul>
<li>右にはみ出した場合には、同じ行の左はしに、左にはみ出した場合には、同じ行の右はしに、下にはみ出した場合には、同じ列の一番上に数字を入れる。
</li>
<li> 数字を入れようとしたマス目が埋まっているときには、その埋まっているマス目の左斜め下のマス目に入れる。
</li>
</ul>
<li>全てのマス目が埋まるまで２を繰り返す。
</ol>
<p>
この方法に従って、一辺のマス目の個数 <var>n</var> を入力として、その大きさの魔方陣を出力するプログラムを作成して下さい。ただし、<var>n</var> は 3 以上 15 以下の奇数とします。マス目に入る各数字は右詰 4 桁で出力してください。
</p>
<H2>入力</H2>
<p>複数の入力が与えられます。各入力で <var>n</var> （正の整数）が１行に与えられます。入力は 0 で終了します。入力の数は 10 を超えません。</p>
<H2>出力</H2>
<p>各入力に対して <var>n</var> × <var>n</var> の魔方陣を出力して下さい。</p>
<H2>Sample Input</H2>
<pre>
3
5
0
</pre>
<H2>Output for the Sample Input</H2>
<pre>
4 9 2
3 5 7
8 1 6
11 24 7 20 3
4 12 25 8 16
17 5 13 21 9
10 18 1 14 22
23 6 19 2 15
</pre>
|
s747114178 | p00078 | Accepted | def check_space(y,x):
if g[y][x]==-1:
return True
return False
while 1:
n=int(raw_input())
if n==0:break
g=[[-1]*n for _ in xrange(n)]
for i in xrange(1,n**2+1):
if i==1:
g[n/2+1][n/2]="1"
nowy=n/2+1
nowx=n/2
continue
while 1:
if check_space((nowy+1)%n,(nowx+1)%n):
g[(nowy+1)%n][(nowx+1)%n]=str(i)
nowy=(nowy+1)%n
nowx=(nowx+1)%n
break
else:
nowy=(nowy+1)%n
nowx=(nowx-1)%n
continue
for i in xrange(n):
tmp=""
for j in xrange(n):
tmp+=g[i][j].rjust(4)
print(tmp) | 3
5
0
| 4 9 2
3 5 7
8 1 6
11 24 7 20 3
4 12 25 8 16
17 5 13 21 9
10 18 1 14 22
23 6 19 2 15
|
<H1>魔方陣</H1>
<p>
<var>n</var> × <var>n</var> の正方形のマス目の中に数字の１から <var>n</var> × <var>n</var> が一つずつ入っていて、縦のどの列のマス目の和も、横のどの列のマス目の和も対角線のマス目の和も等しいものを魔方陣といいます。
</p>
<p>
一辺のマスの個数が奇数の魔方陣の作り方には以下の方法があります。
</p>
<ol>
<li>中央のマス目のちょうど一つ下のマス目に１を入れる。</li>
<li>次の数字を右斜め下のマス目に入れる。<br>ただし、数字を入れようとしたマス目が正方形からはみ出している場合、すでに数字が埋まっている場合は以下の方法に従って数字を入れるマス目を探す。</li>
<ul>
<li>右にはみ出した場合には、同じ行の左はしに、左にはみ出した場合には、同じ行の右はしに、下にはみ出した場合には、同じ列の一番上に数字を入れる。
</li>
<li> 数字を入れようとしたマス目が埋まっているときには、その埋まっているマス目の左斜め下のマス目に入れる。
</li>
</ul>
<li>全てのマス目が埋まるまで２を繰り返す。
</ol>
<p>
この方法に従って、一辺のマス目の個数 <var>n</var> を入力として、その大きさの魔方陣を出力するプログラムを作成して下さい。ただし、<var>n</var> は 3 以上 15 以下の奇数とします。マス目に入る各数字は右詰 4 桁で出力してください。
</p>
<H2>入力</H2>
<p>複数の入力が与えられます。各入力で <var>n</var> （正の整数）が１行に与えられます。入力は 0 で終了します。入力の数は 10 を超えません。</p>
<H2>出力</H2>
<p>各入力に対して <var>n</var> × <var>n</var> の魔方陣を出力して下さい。</p>
<H2>Sample Input</H2>
<pre>
3
5
0
</pre>
<H2>Output for the Sample Input</H2>
<pre>
4 9 2
3 5 7
8 1 6
11 24 7 20 3
4 12 25 8 16
17 5 13 21 9
10 18 1 14 22
23 6 19 2 15
</pre>
|
s416470230 | p00078 | Accepted | # -*- coding: utf-8 -*-
import sys
import os
import math
for s in sys.stdin:
n = int(s)
if n == 0:
break
M = [[None for i in range(n)] for j in range(n)]
# 1
x = n // 2
y = n // 2 + 1
M[y][x] = 1
x = x + 1
y = y + 1
counter = 2
while counter < n * n + 1:
if x >= n:
x = 0
elif x < 0:
x = n - 1
if y >= n:
y = 0
elif y < 0:
y = n - 1
if M[y][x] is not None:
x -= 1
y += 1
else:
M[y][x] = counter
counter += 1
x += 1
y += 1
for row in M:
for v in row:
print(str(v).rjust(4), end='')
print() | 3
5
0
| 4 9 2
3 5 7
8 1 6
11 24 7 20 3
4 12 25 8 16
17 5 13 21 9
10 18 1 14 22
23 6 19 2 15
|
<H1>魔方陣</H1>
<p>
<var>n</var> × <var>n</var> の正方形のマス目の中に数字の１から <var>n</var> × <var>n</var> が一つずつ入っていて、縦のどの列のマス目の和も、横のどの列のマス目の和も対角線のマス目の和も等しいものを魔方陣といいます。
</p>
<p>
一辺のマスの個数が奇数の魔方陣の作り方には以下の方法があります。
</p>
<ol>
<li>中央のマス目のちょうど一つ下のマス目に１を入れる。</li>
<li>次の数字を右斜め下のマス目に入れる。<br>ただし、数字を入れようとしたマス目が正方形からはみ出している場合、すでに数字が埋まっている場合は以下の方法に従って数字を入れるマス目を探す。</li>
<ul>
<li>右にはみ出した場合には、同じ行の左はしに、左にはみ出した場合には、同じ行の右はしに、下にはみ出した場合には、同じ列の一番上に数字を入れる。
</li>
<li> 数字を入れようとしたマス目が埋まっているときには、その埋まっているマス目の左斜め下のマス目に入れる。
</li>
</ul>
<li>全てのマス目が埋まるまで２を繰り返す。
</ol>
<p>
この方法に従って、一辺のマス目の個数 <var>n</var> を入力として、その大きさの魔方陣を出力するプログラムを作成して下さい。ただし、<var>n</var> は 3 以上 15 以下の奇数とします。マス目に入る各数字は右詰 4 桁で出力してください。
</p>
<H2>入力</H2>
<p>複数の入力が与えられます。各入力で <var>n</var> （正の整数）が１行に与えられます。入力は 0 で終了します。入力の数は 10 を超えません。</p>
<H2>出力</H2>
<p>各入力に対して <var>n</var> × <var>n</var> の魔方陣を出力して下さい。</p>
<H2>Sample Input</H2>
<pre>
3
5
0
</pre>
<H2>Output for the Sample Input</H2>
<pre>
4 9 2
3 5 7
8 1 6
11 24 7 20 3
4 12 25 8 16
17 5 13 21 9
10 18 1 14 22
23 6 19 2 15
</pre>
|
s669271271 | p00078 | Accepted | from sys import stdin
def sqmatrix(n):
return [[0] * n for i in range(n)]
def magicsq(m):
n = len(m)
j = int(n/2)
i = j + 1
for num in range(1, n**2 + 1):
m[i][j] = num
i += 1
j += 1
i = i%n
j = j % n
if m[i][j] != 0:
i += 1
j -= 1
if j < 0:
j = n -1
i = i % n
return m
for line in stdin:
n = int(line)
if n == 0:
break
sm = sqmatrix(n)
for row in magicsq(sm): print (''.join(map(lambda x: str(x).rjust(4, ' '),row))) | 3
5
0
| 4 9 2
3 5 7
8 1 6
11 24 7 20 3
4 12 25 8 16
17 5 13 21 9
10 18 1 14 22
23 6 19 2 15
|
<H1>魔方陣</H1>
<p>
<var>n</var> × <var>n</var> の正方形のマス目の中に数字の１から <var>n</var> × <var>n</var> が一つずつ入っていて、縦のどの列のマス目の和も、横のどの列のマス目の和も対角線のマス目の和も等しいものを魔方陣といいます。
</p>
<p>
一辺のマスの個数が奇数の魔方陣の作り方には以下の方法があります。
</p>
<ol>
<li>中央のマス目のちょうど一つ下のマス目に１を入れる。</li>
<li>次の数字を右斜め下のマス目に入れる。<br>ただし、数字を入れようとしたマス目が正方形からはみ出している場合、すでに数字が埋まっている場合は以下の方法に従って数字を入れるマス目を探す。</li>
<ul>
<li>右にはみ出した場合には、同じ行の左はしに、左にはみ出した場合には、同じ行の右はしに、下にはみ出した場合には、同じ列の一番上に数字を入れる。
</li>
<li> 数字を入れようとしたマス目が埋まっているときには、その埋まっているマス目の左斜め下のマス目に入れる。
</li>
</ul>
<li>全てのマス目が埋まるまで２を繰り返す。
</ol>
<p>
この方法に従って、一辺のマス目の個数 <var>n</var> を入力として、その大きさの魔方陣を出力するプログラムを作成して下さい。ただし、<var>n</var> は 3 以上 15 以下の奇数とします。マス目に入る各数字は右詰 4 桁で出力してください。
</p>
<H2>入力</H2>
<p>複数の入力が与えられます。各入力で <var>n</var> （正の整数）が１行に与えられます。入力は 0 で終了します。入力の数は 10 を超えません。</p>
<H2>出力</H2>
<p>各入力に対して <var>n</var> × <var>n</var> の魔方陣を出力して下さい。</p>
<H2>Sample Input</H2>
<pre>
3
5
0
</pre>
<H2>Output for the Sample Input</H2>
<pre>
4 9 2
3 5 7
8 1 6
11 24 7 20 3
4 12 25 8 16
17 5 13 21 9
10 18 1 14 22
23 6 19 2 15
</pre>
|
s199105828 | p00078 | Accepted | # -*- coding: utf-8 -*-
"""
http://judge.u-aizu.ac.jp/onlinejudge/description.jsp?id=0078
"""
import sys
class MagicSquare():
def __init__(self, size):
self.size = size
self.data = [['@']*self.size for _ in range(self.size)]
self.fill_data()
def fill_data(self):
num = 1
x = self.size // 2
y = x + 1
self.data[y][x] = num
while num < self.size**2:
x += 1
if x >= self.size:
x = 0
y += 1
if y >= self.size:
y = 0
if self.data[y][x] == '@':
num += 1
self.data[y][x] = num
else:
while self.data[y][x] != '@':
x -= 1
if x < 0:
x = self.size - 1
y += 1
if y >= self.size:
y = 0
num += 1
self.data[y][x] = num
def print_data(self):
for row in self.data:
temp = ""
for d in row:
temp += str(d).rjust(4)
print(temp)
temp = ""
def main(args):
while True:
size = int(input())
if size < 3 or size%2 == 0:
break
ms = MagicSquare(size)
ms.print_data()
if __name__ == '__main__':
main(sys.argv[1:]) | 3
5
0
| 4 9 2
3 5 7
8 1 6
11 24 7 20 3
4 12 25 8 16
17 5 13 21 9
10 18 1 14 22
23 6 19 2 15
|
<H1>魔方陣</H1>
<p>
<var>n</var> × <var>n</var> の正方形のマス目の中に数字の１から <var>n</var> × <var>n</var> が一つずつ入っていて、縦のどの列のマス目の和も、横のどの列のマス目の和も対角線のマス目の和も等しいものを魔方陣といいます。
</p>
<p>
一辺のマスの個数が奇数の魔方陣の作り方には以下の方法があります。
</p>
<ol>
<li>中央のマス目のちょうど一つ下のマス目に１を入れる。</li>
<li>次の数字を右斜め下のマス目に入れる。<br>ただし、数字を入れようとしたマス目が正方形からはみ出している場合、すでに数字が埋まっている場合は以下の方法に従って数字を入れるマス目を探す。</li>
<ul>
<li>右にはみ出した場合には、同じ行の左はしに、左にはみ出した場合には、同じ行の右はしに、下にはみ出した場合には、同じ列の一番上に数字を入れる。
</li>
<li> 数字を入れようとしたマス目が埋まっているときには、その埋まっているマス目の左斜め下のマス目に入れる。
</li>
</ul>
<li>全てのマス目が埋まるまで２を繰り返す。
</ol>
<p>
この方法に従って、一辺のマス目の個数 <var>n</var> を入力として、その大きさの魔方陣を出力するプログラムを作成して下さい。ただし、<var>n</var> は 3 以上 15 以下の奇数とします。マス目に入る各数字は右詰 4 桁で出力してください。
</p>
<H2>入力</H2>
<p>複数の入力が与えられます。各入力で <var>n</var> （正の整数）が１行に与えられます。入力は 0 で終了します。入力の数は 10 を超えません。</p>
<H2>出力</H2>
<p>各入力に対して <var>n</var> × <var>n</var> の魔方陣を出力して下さい。</p>
<H2>Sample Input</H2>
<pre>
3
5
0
</pre>
<H2>Output for the Sample Input</H2>
<pre>
4 9 2
3 5 7
8 1 6
11 24 7 20 3
4 12 25 8 16
17 5 13 21 9
10 18 1 14 22
23 6 19 2 15
</pre>
|
s800356499 | p00078 | Accepted | # Aizu Problem 0078: Magic Square
#
import sys, math, os
# read input:
PYDEV = os.environ.get('PYDEV')
if PYDEV=="True":
sys.stdin = open("sample-input.txt", "rt")
def magic_square(n):
sq = [[0 for _ in range(16)] for __ in range(16)]
nowx, nowy = n // 2, n // 2 + 1
sq[nowy][nowx] = 1
for i in range(2, n**2 + 1):
nowx += 1
nowy += 1
while True:
if nowx >= n:
nowx = 0
if nowx < 0:
nowx = n - 1
if nowy >= n:
nowy = 0
if sq[nowy][nowx] != 0:
nowx -= 1
nowy += 1
if sq[nowy][nowx] == 0 and 0 <= nowx and nowx < n and 0 <= nowy and nowy < n:
break
sq[nowy][nowx] = i
return sq[:n]
while True:
n = int(input())
if n == 0:
break
sq = magic_square(n)
for row in sq:
out = ""
for k in row[:n]:
ks = str(k)
ks = ' ' * (4 - len(ks)) + ks
out += ks
print(out)
| 3
5
0
| 4 9 2
3 5 7
8 1 6
11 24 7 20 3
4 12 25 8 16
17 5 13 21 9
10 18 1 14 22
23 6 19 2 15
|
<H1>魔方陣</H1>
<p>
<var>n</var> × <var>n</var> の正方形のマス目の中に数字の１から <var>n</var> × <var>n</var> が一つずつ入っていて、縦のどの列のマス目の和も、横のどの列のマス目の和も対角線のマス目の和も等しいものを魔方陣といいます。
</p>
<p>
一辺のマスの個数が奇数の魔方陣の作り方には以下の方法があります。
</p>
<ol>
<li>中央のマス目のちょうど一つ下のマス目に１を入れる。</li>
<li>次の数字を右斜め下のマス目に入れる。<br>ただし、数字を入れようとしたマス目が正方形からはみ出している場合、すでに数字が埋まっている場合は以下の方法に従って数字を入れるマス目を探す。</li>
<ul>
<li>右にはみ出した場合には、同じ行の左はしに、左にはみ出した場合には、同じ行の右はしに、下にはみ出した場合には、同じ列の一番上に数字を入れる。
</li>
<li> 数字を入れようとしたマス目が埋まっているときには、その埋まっているマス目の左斜め下のマス目に入れる。
</li>
</ul>
<li>全てのマス目が埋まるまで２を繰り返す。
</ol>
<p>
この方法に従って、一辺のマス目の個数 <var>n</var> を入力として、その大きさの魔方陣を出力するプログラムを作成して下さい。ただし、<var>n</var> は 3 以上 15 以下の奇数とします。マス目に入る各数字は右詰 4 桁で出力してください。
</p>
<H2>入力</H2>
<p>複数の入力が与えられます。各入力で <var>n</var> （正の整数）が１行に与えられます。入力は 0 で終了します。入力の数は 10 を超えません。</p>
<H2>出力</H2>
<p>各入力に対して <var>n</var> × <var>n</var> の魔方陣を出力して下さい。</p>
<H2>Sample Input</H2>
<pre>
3
5
0
</pre>
<H2>Output for the Sample Input</H2>
<pre>
4 9 2
3 5 7
8 1 6
11 24 7 20 3
4 12 25 8 16
17 5 13 21 9
10 18 1 14 22
23 6 19 2 15
</pre>
|
s115936315 | p00078 | Accepted | def magic_square(n):
a = [[0 for i in range(n)] for j in range(n)]
x = n//2
y = (n+1)//2
i = 1
while True:
if a[y][x] == 0:
a[y][x] = i
i += 1
x += 1
y += 1
else:
x -= 1
y += 1
if x >= n:
x = 0
elif x < 0:
x = n-1
if y >= n:
y = 0
if i > (n*n):
break
return a
def print_square(a):
for aa in a:
for aaa in aa:
print('{0:4d}'.format(aaa),end="")
print('')
while True:
n = int(input())
if n == 0:
break
else:
a = magic_square(n)
print_square(a) | 3
5
0
| 4 9 2
3 5 7
8 1 6
11 24 7 20 3
4 12 25 8 16
17 5 13 21 9
10 18 1 14 22
23 6 19 2 15
|
<H1>魔方陣</H1>
<p>
<var>n</var> × <var>n</var> の正方形のマス目の中に数字の１から <var>n</var> × <var>n</var> が一つずつ入っていて、縦のどの列のマス目の和も、横のどの列のマス目の和も対角線のマス目の和も等しいものを魔方陣といいます。
</p>
<p>
一辺のマスの個数が奇数の魔方陣の作り方には以下の方法があります。
</p>
<ol>
<li>中央のマス目のちょうど一つ下のマス目に１を入れる。</li>
<li>次の数字を右斜め下のマス目に入れる。<br>ただし、数字を入れようとしたマス目が正方形からはみ出している場合、すでに数字が埋まっている場合は以下の方法に従って数字を入れるマス目を探す。</li>
<ul>
<li>右にはみ出した場合には、同じ行の左はしに、左にはみ出した場合には、同じ行の右はしに、下にはみ出した場合には、同じ列の一番上に数字を入れる。
</li>
<li> 数字を入れようとしたマス目が埋まっているときには、その埋まっているマス目の左斜め下のマス目に入れる。
</li>
</ul>
<li>全てのマス目が埋まるまで２を繰り返す。
</ol>
<p>
この方法に従って、一辺のマス目の個数 <var>n</var> を入力として、その大きさの魔方陣を出力するプログラムを作成して下さい。ただし、<var>n</var> は 3 以上 15 以下の奇数とします。マス目に入る各数字は右詰 4 桁で出力してください。
</p>
<H2>入力</H2>
<p>複数の入力が与えられます。各入力で <var>n</var> （正の整数）が１行に与えられます。入力は 0 で終了します。入力の数は 10 を超えません。</p>
<H2>出力</H2>
<p>各入力に対して <var>n</var> × <var>n</var> の魔方陣を出力して下さい。</p>
<H2>Sample Input</H2>
<pre>
3
5
0
</pre>
<H2>Output for the Sample Input</H2>
<pre>
4 9 2
3 5 7
8 1 6
11 24 7 20 3
4 12 25 8 16
17 5 13 21 9
10 18 1 14 22
23 6 19 2 15
</pre>
|
s205747619 | p00078 | Accepted | def fprint(x):
if x < 10:
print(" ",end="")
elif x < 100:
print(" ",end="")
elif x < 1000:
print(" ",end="")
print(x,end="")
while True:
N = int(input())
if N == 0:
break
table = [[0 for i in range(N)] for j in range(N)]
cnt = 1
row = N // 2 + 1
col = N // 2
table[row][col] = cnt
while cnt < N*N:
row = (row + 1) % N
col = (col + 1) % N
while table[row][col] != 0:
row = (row + 1) % N
col = (col - 1 + N) % N
cnt += 1
table[row][col] = cnt
for i in range(N):
for j in range(N):
fprint(table[i][j])
print("")
| 3
5
0
| 4 9 2
3 5 7
8 1 6
11 24 7 20 3
4 12 25 8 16
17 5 13 21 9
10 18 1 14 22
23 6 19 2 15
|
<H1>魔方陣</H1>
<p>
<var>n</var> × <var>n</var> の正方形のマス目の中に数字の１から <var>n</var> × <var>n</var> が一つずつ入っていて、縦のどの列のマス目の和も、横のどの列のマス目の和も対角線のマス目の和も等しいものを魔方陣といいます。
</p>
<p>
一辺のマスの個数が奇数の魔方陣の作り方には以下の方法があります。
</p>
<ol>
<li>中央のマス目のちょうど一つ下のマス目に１を入れる。</li>
<li>次の数字を右斜め下のマス目に入れる。<br>ただし、数字を入れようとしたマス目が正方形からはみ出している場合、すでに数字が埋まっている場合は以下の方法に従って数字を入れるマス目を探す。</li>
<ul>
<li>右にはみ出した場合には、同じ行の左はしに、左にはみ出した場合には、同じ行の右はしに、下にはみ出した場合には、同じ列の一番上に数字を入れる。
</li>
<li> 数字を入れようとしたマス目が埋まっているときには、その埋まっているマス目の左斜め下のマス目に入れる。
</li>
</ul>
<li>全てのマス目が埋まるまで２を繰り返す。
</ol>
<p>
この方法に従って、一辺のマス目の個数 <var>n</var> を入力として、その大きさの魔方陣を出力するプログラムを作成して下さい。ただし、<var>n</var> は 3 以上 15 以下の奇数とします。マス目に入る各数字は右詰 4 桁で出力してください。
</p>
<H2>入力</H2>
<p>複数の入力が与えられます。各入力で <var>n</var> （正の整数）が１行に与えられます。入力は 0 で終了します。入力の数は 10 を超えません。</p>
<H2>出力</H2>
<p>各入力に対して <var>n</var> × <var>n</var> の魔方陣を出力して下さい。</p>
<H2>Sample Input</H2>
<pre>
3
5
0
</pre>
<H2>Output for the Sample Input</H2>
<pre>
4 9 2
3 5 7
8 1 6
11 24 7 20 3
4 12 25 8 16
17 5 13 21 9
10 18 1 14 22
23 6 19 2 15
</pre>
|
s877685671 | p00078 | Accepted | def check_range(xy, n):
for i in range(2):
if xy[i] == -1:
xy[i] = n - 1
elif xy[i] == n:
xy[i] = 0
return xy
while True:
n = int(input())
if n == 0:
break
ms = [[0 for i in range(n)] for j in range(n)]
xy = [n//2, n//2 - 1]
i = 1
while i <= n*n:
if ms[xy[1]][xy[0]] != 0:
xy[0] -= 1
xy[1] -= 1
xy = check_range(xy, n)
continue
ms[xy[1]][xy[0]] = i
xy[0] += 1
xy[1] -= 1
xy = check_range(xy, n)
i += 1
for i in range(n):
s = ""
for j in range(n):
s += "{0:>4}".format(str(ms[n - i - 1][j]))
print(s)
| 3
5
0
| 4 9 2
3 5 7
8 1 6
11 24 7 20 3
4 12 25 8 16
17 5 13 21 9
10 18 1 14 22
23 6 19 2 15
|
<H1>魔方陣</H1>
<p>
<var>n</var> × <var>n</var> の正方形のマス目の中に数字の１から <var>n</var> × <var>n</var> が一つずつ入っていて、縦のどの列のマス目の和も、横のどの列のマス目の和も対角線のマス目の和も等しいものを魔方陣といいます。
</p>
<p>
一辺のマスの個数が奇数の魔方陣の作り方には以下の方法があります。
</p>
<ol>
<li>中央のマス目のちょうど一つ下のマス目に１を入れる。</li>
<li>次の数字を右斜め下のマス目に入れる。<br>ただし、数字を入れようとしたマス目が正方形からはみ出している場合、すでに数字が埋まっている場合は以下の方法に従って数字を入れるマス目を探す。</li>
<ul>
<li>右にはみ出した場合には、同じ行の左はしに、左にはみ出した場合には、同じ行の右はしに、下にはみ出した場合には、同じ列の一番上に数字を入れる。
</li>
<li> 数字を入れようとしたマス目が埋まっているときには、その埋まっているマス目の左斜め下のマス目に入れる。
</li>
</ul>
<li>全てのマス目が埋まるまで２を繰り返す。
</ol>
<p>
この方法に従って、一辺のマス目の個数 <var>n</var> を入力として、その大きさの魔方陣を出力するプログラムを作成して下さい。ただし、<var>n</var> は 3 以上 15 以下の奇数とします。マス目に入る各数字は右詰 4 桁で出力してください。
</p>
<H2>入力</H2>
<p>複数の入力が与えられます。各入力で <var>n</var> （正の整数）が１行に与えられます。入力は 0 で終了します。入力の数は 10 を超えません。</p>
<H2>出力</H2>
<p>各入力に対して <var>n</var> × <var>n</var> の魔方陣を出力して下さい。</p>
<H2>Sample Input</H2>
<pre>
3
5
0
</pre>
<H2>Output for the Sample Input</H2>
<pre>
4 9 2
3 5 7
8 1 6
11 24 7 20 3
4 12 25 8 16
17 5 13 21 9
10 18 1 14 22
23 6 19 2 15
</pre>
|
s345663892 | p00078 | Accepted | for e in iter(input,'0'):
n=int(e);m,f=[[0]*n for _ in[0]*n],'{:4}'*n
j=n//2;i=j+1
m[i][j]=1
for k in range(2,n*n+1):
i,j=-~i%n,-~j%n
if m[i][j]:i,j=-~i%n,~-j%n
m[i][j]=k
for r in m:print(f.format(*r))
| 3
5
0
| 4 9 2
3 5 7
8 1 6
11 24 7 20 3
4 12 25 8 16
17 5 13 21 9
10 18 1 14 22
23 6 19 2 15
|
<H1>魔方陣</H1>
<p>
<var>n</var> × <var>n</var> の正方形のマス目の中に数字の１から <var>n</var> × <var>n</var> が一つずつ入っていて、縦のどの列のマス目の和も、横のどの列のマス目の和も対角線のマス目の和も等しいものを魔方陣といいます。
</p>
<p>
一辺のマスの個数が奇数の魔方陣の作り方には以下の方法があります。
</p>
<ol>
<li>中央のマス目のちょうど一つ下のマス目に１を入れる。</li>
<li>次の数字を右斜め下のマス目に入れる。<br>ただし、数字を入れようとしたマス目が正方形からはみ出している場合、すでに数字が埋まっている場合は以下の方法に従って数字を入れるマス目を探す。</li>
<ul>
<li>右にはみ出した場合には、同じ行の左はしに、左にはみ出した場合には、同じ行の右はしに、下にはみ出した場合には、同じ列の一番上に数字を入れる。
</li>
<li> 数字を入れようとしたマス目が埋まっているときには、その埋まっているマス目の左斜め下のマス目に入れる。
</li>
</ul>
<li>全てのマス目が埋まるまで２を繰り返す。
</ol>
<p>
この方法に従って、一辺のマス目の個数 <var>n</var> を入力として、その大きさの魔方陣を出力するプログラムを作成して下さい。ただし、<var>n</var> は 3 以上 15 以下の奇数とします。マス目に入る各数字は右詰 4 桁で出力してください。
</p>
<H2>入力</H2>
<p>複数の入力が与えられます。各入力で <var>n</var> （正の整数）が１行に与えられます。入力は 0 で終了します。入力の数は 10 を超えません。</p>
<H2>出力</H2>
<p>各入力に対して <var>n</var> × <var>n</var> の魔方陣を出力して下さい。</p>
<H2>Sample Input</H2>
<pre>
3
5
0
</pre>
<H2>Output for the Sample Input</H2>
<pre>
4 9 2
3 5 7
8 1 6
11 24 7 20 3
4 12 25 8 16
17 5 13 21 9
10 18 1 14 22
23 6 19 2 15
</pre>
|
s880901561 | p00078 | Accepted | for e in iter(input,'0'):
n=int(e);m,f=[[0]*n for _ in[0]*n],'{:4}'*n
j=n//2;i=j+1
m[i][j]=1
for k in range(2,n*n+1):
i,j,t=-~i%n,-~j%n,j
if m[i][j]:i,j=-~i%n,t
m[i][j]=k
for r in m:print(f.format(*r))
| 3
5
0
| 4 9 2
3 5 7
8 1 6
11 24 7 20 3
4 12 25 8 16
17 5 13 21 9
10 18 1 14 22
23 6 19 2 15
|
<H1>魔方陣</H1>
<p>
<var>n</var> × <var>n</var> の正方形のマス目の中に数字の１から <var>n</var> × <var>n</var> が一つずつ入っていて、縦のどの列のマス目の和も、横のどの列のマス目の和も対角線のマス目の和も等しいものを魔方陣といいます。
</p>
<p>
一辺のマスの個数が奇数の魔方陣の作り方には以下の方法があります。
</p>
<ol>
<li>中央のマス目のちょうど一つ下のマス目に１を入れる。</li>
<li>次の数字を右斜め下のマス目に入れる。<br>ただし、数字を入れようとしたマス目が正方形からはみ出している場合、すでに数字が埋まっている場合は以下の方法に従って数字を入れるマス目を探す。</li>
<ul>
<li>右にはみ出した場合には、同じ行の左はしに、左にはみ出した場合には、同じ行の右はしに、下にはみ出した場合には、同じ列の一番上に数字を入れる。
</li>
<li> 数字を入れようとしたマス目が埋まっているときには、その埋まっているマス目の左斜め下のマス目に入れる。
</li>
</ul>
<li>全てのマス目が埋まるまで２を繰り返す。
</ol>
<p>
この方法に従って、一辺のマス目の個数 <var>n</var> を入力として、その大きさの魔方陣を出力するプログラムを作成して下さい。ただし、<var>n</var> は 3 以上 15 以下の奇数とします。マス目に入る各数字は右詰 4 桁で出力してください。
</p>
<H2>入力</H2>
<p>複数の入力が与えられます。各入力で <var>n</var> （正の整数）が１行に与えられます。入力は 0 で終了します。入力の数は 10 を超えません。</p>
<H2>出力</H2>
<p>各入力に対して <var>n</var> × <var>n</var> の魔方陣を出力して下さい。</p>
<H2>Sample Input</H2>
<pre>
3
5
0
</pre>
<H2>Output for the Sample Input</H2>
<pre>
4 9 2
3 5 7
8 1 6
11 24 7 20 3
4 12 25 8 16
17 5 13 21 9
10 18 1 14 22
23 6 19 2 15
</pre>
|
s259725913 | p00078 | Accepted | for e in iter(input,'0'):
n=int(e);m,f=[[0]*n for _ in[0]*n],'{:4}'*n
s=lambda x:-~x%n
j=n//2;i=j+1
m[i][j]=1
for k in range(2,n*n+1):
i,j,t=s(i),s(j),j
if m[i][j]:i,j=s(i),t
m[i][j]=k
for r in m:print(f.format(*r))
| 3
5
0
| 4 9 2
3 5 7
8 1 6
11 24 7 20 3
4 12 25 8 16
17 5 13 21 9
10 18 1 14 22
23 6 19 2 15
|
<H1>魔方陣</H1>
<p>
<var>n</var> × <var>n</var> の正方形のマス目の中に数字の１から <var>n</var> × <var>n</var> が一つずつ入っていて、縦のどの列のマス目の和も、横のどの列のマス目の和も対角線のマス目の和も等しいものを魔方陣といいます。
</p>
<p>
一辺のマスの個数が奇数の魔方陣の作り方には以下の方法があります。
</p>
<ol>
<li>中央のマス目のちょうど一つ下のマス目に１を入れる。</li>
<li>次の数字を右斜め下のマス目に入れる。<br>ただし、数字を入れようとしたマス目が正方形からはみ出している場合、すでに数字が埋まっている場合は以下の方法に従って数字を入れるマス目を探す。</li>
<ul>
<li>右にはみ出した場合には、同じ行の左はしに、左にはみ出した場合には、同じ行の右はしに、下にはみ出した場合には、同じ列の一番上に数字を入れる。
</li>
<li> 数字を入れようとしたマス目が埋まっているときには、その埋まっているマス目の左斜め下のマス目に入れる。
</li>
</ul>
<li>全てのマス目が埋まるまで２を繰り返す。
</ol>
<p>
この方法に従って、一辺のマス目の個数 <var>n</var> を入力として、その大きさの魔方陣を出力するプログラムを作成して下さい。ただし、<var>n</var> は 3 以上 15 以下の奇数とします。マス目に入る各数字は右詰 4 桁で出力してください。
</p>
<H2>入力</H2>
<p>複数の入力が与えられます。各入力で <var>n</var> （正の整数）が１行に与えられます。入力は 0 で終了します。入力の数は 10 を超えません。</p>
<H2>出力</H2>
<p>各入力に対して <var>n</var> × <var>n</var> の魔方陣を出力して下さい。</p>
<H2>Sample Input</H2>
<pre>
3
5
0
</pre>
<H2>Output for the Sample Input</H2>
<pre>
4 9 2
3 5 7
8 1 6
11 24 7 20 3
4 12 25 8 16
17 5 13 21 9
10 18 1 14 22
23 6 19 2 15
</pre>
|
s193596773 | p00078 | Accepted | def square(n):
mp = [[0 for _ in range(n)] for _ in range(n)]
x, y = n // 2 , n // 2 + 1
mp[y][x] = 1
for i in range(2, n ** 2 + 1):
x = (x + 1) % n
y = (y + 1) % n
while mp[y][x]:
y = (y + 1) % n
x = (x - 1) % n
mp[y][x] = i
for line in mp:
s = ""
for i in line:
si = str(i)
s += si.rjust(4)
print(s)
while True:
n = int(input())
if not n:
break
square(n)
| 3
5
0
| 4 9 2
3 5 7
8 1 6
11 24 7 20 3
4 12 25 8 16
17 5 13 21 9
10 18 1 14 22
23 6 19 2 15
|
<H1>魔方陣</H1>
<p>
<var>n</var> × <var>n</var> の正方形のマス目の中に数字の１から <var>n</var> × <var>n</var> が一つずつ入っていて、縦のどの列のマス目の和も、横のどの列のマス目の和も対角線のマス目の和も等しいものを魔方陣といいます。
</p>
<p>
一辺のマスの個数が奇数の魔方陣の作り方には以下の方法があります。
</p>
<ol>
<li>中央のマス目のちょうど一つ下のマス目に１を入れる。</li>
<li>次の数字を右斜め下のマス目に入れる。<br>ただし、数字を入れようとしたマス目が正方形からはみ出している場合、すでに数字が埋まっている場合は以下の方法に従って数字を入れるマス目を探す。</li>
<ul>
<li>右にはみ出した場合には、同じ行の左はしに、左にはみ出した場合には、同じ行の右はしに、下にはみ出した場合には、同じ列の一番上に数字を入れる。
</li>
<li> 数字を入れようとしたマス目が埋まっているときには、その埋まっているマス目の左斜め下のマス目に入れる。
</li>
</ul>
<li>全てのマス目が埋まるまで２を繰り返す。
</ol>
<p>
この方法に従って、一辺のマス目の個数 <var>n</var> を入力として、その大きさの魔方陣を出力するプログラムを作成して下さい。ただし、<var>n</var> は 3 以上 15 以下の奇数とします。マス目に入る各数字は右詰 4 桁で出力してください。
</p>
<H2>入力</H2>
<p>複数の入力が与えられます。各入力で <var>n</var> （正の整数）が１行に与えられます。入力は 0 で終了します。入力の数は 10 を超えません。</p>
<H2>出力</H2>
<p>各入力に対して <var>n</var> × <var>n</var> の魔方陣を出力して下さい。</p>
<H2>Sample Input</H2>
<pre>
3
5
0
</pre>
<H2>Output for the Sample Input</H2>
<pre>
4 9 2
3 5 7
8 1 6
11 24 7 20 3
4 12 25 8 16
17 5 13 21 9
10 18 1 14 22
23 6 19 2 15
</pre>
|
s437997854 | p00078 | Accepted | while 1:
n=int(input())
if n==0:break
c=1
nx=ny=int((n-1)/2)
b=[[0 for _ in range(n)] for _ in range(n)]
ny=ny+1
b[ny][nx]=c
for _ in range(n*n-1):
c+=1
nx+=1
ny+=1
while 1:
if 0<=nx<=n-1 and 0<=ny<=n-1 and b[ny][nx]==0:
break
if nx>n-1:
nx=0
if nx<0:
nx=n-1
if ny>n-1:
ny=0
if b[ny][nx]==0:
break
else:
nx-=1
ny+=1
b[ny][nx]=c
for i in b:
print(("".join([str(l).rjust(4) for l in i])))
| 3
5
0
| 4 9 2
3 5 7
8 1 6
11 24 7 20 3
4 12 25 8 16
17 5 13 21 9
10 18 1 14 22
23 6 19 2 15
|
<H1>魔方陣</H1>
<p>
<var>n</var> × <var>n</var> の正方形のマス目の中に数字の１から <var>n</var> × <var>n</var> が一つずつ入っていて、縦のどの列のマス目の和も、横のどの列のマス目の和も対角線のマス目の和も等しいものを魔方陣といいます。
</p>
<p>
一辺のマスの個数が奇数の魔方陣の作り方には以下の方法があります。
</p>
<ol>
<li>中央のマス目のちょうど一つ下のマス目に１を入れる。</li>
<li>次の数字を右斜め下のマス目に入れる。<br>ただし、数字を入れようとしたマス目が正方形からはみ出している場合、すでに数字が埋まっている場合は以下の方法に従って数字を入れるマス目を探す。</li>
<ul>
<li>右にはみ出した場合には、同じ行の左はしに、左にはみ出した場合には、同じ行の右はしに、下にはみ出した場合には、同じ列の一番上に数字を入れる。
</li>
<li> 数字を入れようとしたマス目が埋まっているときには、その埋まっているマス目の左斜め下のマス目に入れる。
</li>
</ul>
<li>全てのマス目が埋まるまで２を繰り返す。
</ol>
<p>
この方法に従って、一辺のマス目の個数 <var>n</var> を入力として、その大きさの魔方陣を出力するプログラムを作成して下さい。ただし、<var>n</var> は 3 以上 15 以下の奇数とします。マス目に入る各数字は右詰 4 桁で出力してください。
</p>
<H2>入力</H2>
<p>複数の入力が与えられます。各入力で <var>n</var> （正の整数）が１行に与えられます。入力は 0 で終了します。入力の数は 10 を超えません。</p>
<H2>出力</H2>
<p>各入力に対して <var>n</var> × <var>n</var> の魔方陣を出力して下さい。</p>
<H2>Sample Input</H2>
<pre>
3
5
0
</pre>
<H2>Output for the Sample Input</H2>
<pre>
4 9 2
3 5 7
8 1 6
11 24 7 20 3
4 12 25 8 16
17 5 13 21 9
10 18 1 14 22
23 6 19 2 15
</pre>
|
s659775779 | p00078 | Accepted | # AOJ 0078 Magic Square
# Python3 2018.6.17 bal4u
MAX = 15
tbl = [0]*MAX
while True:
n = int(input())
if n == 0: break
tbl = [[0 for r in range(n)] for c in range(n)]
r, c = n//2+1, n//2
tbl[r][c] = i = 1
while i < n*n:
r += 1
c += 1
while True:
if c >= n: c = 0;
elif c < 0: c = n - 1;
if r >= n: r = 0;
if tbl[r][c] == 0:
i += 1
tbl[r][c] = i
break
r += 1
c -= 1
for r in range(n):
for c in range(n):
print(format(tbl[r][c], '4d'), end='')
print()
| 3
5
0
| 4 9 2
3 5 7
8 1 6
11 24 7 20 3
4 12 25 8 16
17 5 13 21 9
10 18 1 14 22
23 6 19 2 15
|
<H1>魔方陣</H1>
<p>
<var>n</var> × <var>n</var> の正方形のマス目の中に数字の１から <var>n</var> × <var>n</var> が一つずつ入っていて、縦のどの列のマス目の和も、横のどの列のマス目の和も対角線のマス目の和も等しいものを魔方陣といいます。
</p>
<p>
一辺のマスの個数が奇数の魔方陣の作り方には以下の方法があります。
</p>
<ol>
<li>中央のマス目のちょうど一つ下のマス目に１を入れる。</li>
<li>次の数字を右斜め下のマス目に入れる。<br>ただし、数字を入れようとしたマス目が正方形からはみ出している場合、すでに数字が埋まっている場合は以下の方法に従って数字を入れるマス目を探す。</li>
<ul>
<li>右にはみ出した場合には、同じ行の左はしに、左にはみ出した場合には、同じ行の右はしに、下にはみ出した場合には、同じ列の一番上に数字を入れる。
</li>
<li> 数字を入れようとしたマス目が埋まっているときには、その埋まっているマス目の左斜め下のマス目に入れる。
</li>
</ul>
<li>全てのマス目が埋まるまで２を繰り返す。
</ol>
<p>
この方法に従って、一辺のマス目の個数 <var>n</var> を入力として、その大きさの魔方陣を出力するプログラムを作成して下さい。ただし、<var>n</var> は 3 以上 15 以下の奇数とします。マス目に入る各数字は右詰 4 桁で出力してください。
</p>
<H2>入力</H2>
<p>複数の入力が与えられます。各入力で <var>n</var> （正の整数）が１行に与えられます。入力は 0 で終了します。入力の数は 10 を超えません。</p>
<H2>出力</H2>
<p>各入力に対して <var>n</var> × <var>n</var> の魔方陣を出力して下さい。</p>
<H2>Sample Input</H2>
<pre>
3
5
0
</pre>
<H2>Output for the Sample Input</H2>
<pre>
4 9 2
3 5 7
8 1 6
11 24 7 20 3
4 12 25 8 16
17 5 13 21 9
10 18 1 14 22
23 6 19 2 15
</pre>
|
s749545905 | p00078 | Accepted | ans = []
while True:
n = input()
if n == 0:
break
c = 1
N = n*n
circle = [0]*N
p = (N+1)/2-1
while c <= N:
if p == N:
p = 1
elif p % n == 0:
p += 1
elif p+n > N:
p -= (N-n-1)
else:
p += n+1
if circle[p-1] != 0:
while circle[p-1] != 0:
if p == N-n+1:
p = n
elif p-1 % n == 0:
p += (n*2 -1)
elif p+n > N:
p -= N - n + 1
else:
p += n-1
circle[p-1] = c
c += 1
p = 0
temp = ''
while p*n != N:
temp += ''.join(map(lambda x:str(x).rjust(4),circle[n*p:n*(p+1)]))
temp += '\n'
p += 1
ans.append(temp.rstrip())
for i in ans:
print i | 3
5
0
| 4 9 2
3 5 7
8 1 6
11 24 7 20 3
4 12 25 8 16
17 5 13 21 9
10 18 1 14 22
23 6 19 2 15
|
<H1>魔方陣</H1>
<p>
<var>n</var> × <var>n</var> の正方形のマス目の中に数字の１から <var>n</var> × <var>n</var> が一つずつ入っていて、縦のどの列のマス目の和も、横のどの列のマス目の和も対角線のマス目の和も等しいものを魔方陣といいます。
</p>
<p>
一辺のマスの個数が奇数の魔方陣の作り方には以下の方法があります。
</p>
<ol>
<li>中央のマス目のちょうど一つ下のマス目に１を入れる。</li>
<li>次の数字を右斜め下のマス目に入れる。<br>ただし、数字を入れようとしたマス目が正方形からはみ出している場合、すでに数字が埋まっている場合は以下の方法に従って数字を入れるマス目を探す。</li>
<ul>
<li>右にはみ出した場合には、同じ行の左はしに、左にはみ出した場合には、同じ行の右はしに、下にはみ出した場合には、同じ列の一番上に数字を入れる。
</li>
<li> 数字を入れようとしたマス目が埋まっているときには、その埋まっているマス目の左斜め下のマス目に入れる。
</li>
</ul>
<li>全てのマス目が埋まるまで２を繰り返す。
</ol>
<p>
この方法に従って、一辺のマス目の個数 <var>n</var> を入力として、その大きさの魔方陣を出力するプログラムを作成して下さい。ただし、<var>n</var> は 3 以上 15 以下の奇数とします。マス目に入る各数字は右詰 4 桁で出力してください。
</p>
<H2>入力</H2>
<p>複数の入力が与えられます。各入力で <var>n</var> （正の整数）が１行に与えられます。入力は 0 で終了します。入力の数は 10 を超えません。</p>
<H2>出力</H2>
<p>各入力に対して <var>n</var> × <var>n</var> の魔方陣を出力して下さい。</p>
<H2>Sample Input</H2>
<pre>
3
5
0
</pre>
<H2>Output for the Sample Input</H2>
<pre>
4 9 2
3 5 7
8 1 6
11 24 7 20 3
4 12 25 8 16
17 5 13 21 9
10 18 1 14 22
23 6 19 2 15
</pre>
|
s146588997 | p00078 | Accepted | #!/usr/bin/env python
# coding: utf-8
def table_to_string(table):
lines = []
for row in table:
line = ""
for num in row:
line += "% 4d" % num
lines.append(line)
return "\n".join(lines)
def get_answer(n):
table = [[0 for i in xrange(n)] for j in xrange(n)]
x = (n - 1) / 2
y = (n - 1) / 2 + 1
for i in xrange(1, n * n + 1):
while 1:
if x == n:
x = 0
elif x == -1:
x = n - 1
if y == n:
y = 0
if table[y][x]:
x -= 1
y += 1
continue
else:
break
table[y][x] = i
x += 1
y += 1
return table_to_string(table)
def main():
params = []
while 1:
param = int(raw_input())
if not param:
break
params.append(param)
for param in params:
print get_answer(param)
if __name__ == '__main__':
main() | 3
5
0
| 4 9 2
3 5 7
8 1 6
11 24 7 20 3
4 12 25 8 16
17 5 13 21 9
10 18 1 14 22
23 6 19 2 15
|
<H1>魔方陣</H1>
<p>
<var>n</var> × <var>n</var> の正方形のマス目の中に数字の１から <var>n</var> × <var>n</var> が一つずつ入っていて、縦のどの列のマス目の和も、横のどの列のマス目の和も対角線のマス目の和も等しいものを魔方陣といいます。
</p>
<p>
一辺のマスの個数が奇数の魔方陣の作り方には以下の方法があります。
</p>
<ol>
<li>中央のマス目のちょうど一つ下のマス目に１を入れる。</li>
<li>次の数字を右斜め下のマス目に入れる。<br>ただし、数字を入れようとしたマス目が正方形からはみ出している場合、すでに数字が埋まっている場合は以下の方法に従って数字を入れるマス目を探す。</li>
<ul>
<li>右にはみ出した場合には、同じ行の左はしに、左にはみ出した場合には、同じ行の右はしに、下にはみ出した場合には、同じ列の一番上に数字を入れる。
</li>
<li> 数字を入れようとしたマス目が埋まっているときには、その埋まっているマス目の左斜め下のマス目に入れる。
</li>
</ul>
<li>全てのマス目が埋まるまで２を繰り返す。
</ol>
<p>
この方法に従って、一辺のマス目の個数 <var>n</var> を入力として、その大きさの魔方陣を出力するプログラムを作成して下さい。ただし、<var>n</var> は 3 以上 15 以下の奇数とします。マス目に入る各数字は右詰 4 桁で出力してください。
</p>
<H2>入力</H2>
<p>複数の入力が与えられます。各入力で <var>n</var> （正の整数）が１行に与えられます。入力は 0 で終了します。入力の数は 10 を超えません。</p>
<H2>出力</H2>
<p>各入力に対して <var>n</var> × <var>n</var> の魔方陣を出力して下さい。</p>
<H2>Sample Input</H2>
<pre>
3
5
0
</pre>
<H2>Output for the Sample Input</H2>
<pre>
4 9 2
3 5 7
8 1 6
11 24 7 20 3
4 12 25 8 16
17 5 13 21 9
10 18 1 14 22
23 6 19 2 15
</pre>
|
s122541443 | p00078 | Accepted | while True:
n=input()
if n==0:
break
board=[[0]*n for unused in xrange(n)]
y,x=n/2+1,n/2
board[y][x]=1
for i in xrange(2,n*n+1):
ny,nx=(y+1)%n,(x+1)%n
while True:
if board[ny][nx]==0:
y,x=ny,nx
break
else:
ny,nx=(ny+1)%n,(nx+n-1)%n
board[y][x]=i
for i in xrange(n):
print "".join(map(lambda s:str(s).rjust(4),board[i])) | 3
5
0
| 4 9 2
3 5 7
8 1 6
11 24 7 20 3
4 12 25 8 16
17 5 13 21 9
10 18 1 14 22
23 6 19 2 15
|
<H1>魔方陣</H1>
<p>
<var>n</var> × <var>n</var> の正方形のマス目の中に数字の１から <var>n</var> × <var>n</var> が一つずつ入っていて、縦のどの列のマス目の和も、横のどの列のマス目の和も対角線のマス目の和も等しいものを魔方陣といいます。
</p>
<p>
一辺のマスの個数が奇数の魔方陣の作り方には以下の方法があります。
</p>
<ol>
<li>中央のマス目のちょうど一つ下のマス目に１を入れる。</li>
<li>次の数字を右斜め下のマス目に入れる。<br>ただし、数字を入れようとしたマス目が正方形からはみ出している場合、すでに数字が埋まっている場合は以下の方法に従って数字を入れるマス目を探す。</li>
<ul>
<li>右にはみ出した場合には、同じ行の左はしに、左にはみ出した場合には、同じ行の右はしに、下にはみ出した場合には、同じ列の一番上に数字を入れる。
</li>
<li> 数字を入れようとしたマス目が埋まっているときには、その埋まっているマス目の左斜め下のマス目に入れる。
</li>
</ul>
<li>全てのマス目が埋まるまで２を繰り返す。
</ol>
<p>
この方法に従って、一辺のマス目の個数 <var>n</var> を入力として、その大きさの魔方陣を出力するプログラムを作成して下さい。ただし、<var>n</var> は 3 以上 15 以下の奇数とします。マス目に入る各数字は右詰 4 桁で出力してください。
</p>
<H2>入力</H2>
<p>複数の入力が与えられます。各入力で <var>n</var> （正の整数）が１行に与えられます。入力は 0 で終了します。入力の数は 10 を超えません。</p>
<H2>出力</H2>
<p>各入力に対して <var>n</var> × <var>n</var> の魔方陣を出力して下さい。</p>
<H2>Sample Input</H2>
<pre>
3
5
0
</pre>
<H2>Output for the Sample Input</H2>
<pre>
4 9 2
3 5 7
8 1 6
11 24 7 20 3
4 12 25 8 16
17 5 13 21 9
10 18 1 14 22
23 6 19 2 15
</pre>
|
s631074040 | p00078 | Accepted | #!/usr/bin/env python
# -*- coding: utf-8 -*-
from __future__ import (division, absolute_import, print_function,
unicode_literals)
from sys import stdin
def solve(n):
square = [[0]*n for _ in range(n)]
x = n // 2
y = x + 1
square[y][x] = 1
for i in range(1, n*n):
x = (x+1) % n
y = (y+1) % n
if square[y][x]:
x = (x-1) % n
y = (y+1) % n
square[y][x] = i + 1
fmt = ('{:4d}' * n).format
print('\n'.join(fmt(*row) for row in square))
for line in stdin:
n = int(line)
if not n:
break
solve(n) | 3
5
0
| 4 9 2
3 5 7
8 1 6
11 24 7 20 3
4 12 25 8 16
17 5 13 21 9
10 18 1 14 22
23 6 19 2 15
|
<H1>魔方陣</H1>
<p>
<var>n</var> × <var>n</var> の正方形のマス目の中に数字の１から <var>n</var> × <var>n</var> が一つずつ入っていて、縦のどの列のマス目の和も、横のどの列のマス目の和も対角線のマス目の和も等しいものを魔方陣といいます。
</p>
<p>
一辺のマスの個数が奇数の魔方陣の作り方には以下の方法があります。
</p>
<ol>
<li>中央のマス目のちょうど一つ下のマス目に１を入れる。</li>
<li>次の数字を右斜め下のマス目に入れる。<br>ただし、数字を入れようとしたマス目が正方形からはみ出している場合、すでに数字が埋まっている場合は以下の方法に従って数字を入れるマス目を探す。</li>
<ul>
<li>右にはみ出した場合には、同じ行の左はしに、左にはみ出した場合には、同じ行の右はしに、下にはみ出した場合には、同じ列の一番上に数字を入れる。
</li>
<li> 数字を入れようとしたマス目が埋まっているときには、その埋まっているマス目の左斜め下のマス目に入れる。
</li>
</ul>
<li>全てのマス目が埋まるまで２を繰り返す。
</ol>
<p>
この方法に従って、一辺のマス目の個数 <var>n</var> を入力として、その大きさの魔方陣を出力するプログラムを作成して下さい。ただし、<var>n</var> は 3 以上 15 以下の奇数とします。マス目に入る各数字は右詰 4 桁で出力してください。
</p>
<H2>入力</H2>
<p>複数の入力が与えられます。各入力で <var>n</var> （正の整数）が１行に与えられます。入力は 0 で終了します。入力の数は 10 を超えません。</p>
<H2>出力</H2>
<p>各入力に対して <var>n</var> × <var>n</var> の魔方陣を出力して下さい。</p>
<H2>Sample Input</H2>
<pre>
3
5
0
</pre>
<H2>Output for the Sample Input</H2>
<pre>
4 9 2
3 5 7
8 1 6
11 24 7 20 3
4 12 25 8 16
17 5 13 21 9
10 18 1 14 22
23 6 19 2 15
</pre>
|
s942196509 | p00078 | Accepted | while True:
n = int(raw_input())
if n == 0:
break
magic = [[0 for i in range(n)] for i in range(n)]
x, y = n/2, n/2+1
magic[y][x] = 1
count = 2
while count <= n**2:
x, y = (x+1)%n, (y+1)%n
if magic[y][x] == 0:
magic[y][x] = count
count += 1
else:
x, y = (x-1)%n, (y+1)%n
magic[y][x] = count
count += 1
for i in xrange(n):
print "".join(map(lambda s:str(s).rjust(4),magic[i])) | 3
5
0
| 4 9 2
3 5 7
8 1 6
11 24 7 20 3
4 12 25 8 16
17 5 13 21 9
10 18 1 14 22
23 6 19 2 15
|
<H1>魔方陣</H1>
<p>
<var>n</var> × <var>n</var> の正方形のマス目の中に数字の１から <var>n</var> × <var>n</var> が一つずつ入っていて、縦のどの列のマス目の和も、横のどの列のマス目の和も対角線のマス目の和も等しいものを魔方陣といいます。
</p>
<p>
一辺のマスの個数が奇数の魔方陣の作り方には以下の方法があります。
</p>
<ol>
<li>中央のマス目のちょうど一つ下のマス目に１を入れる。</li>
<li>次の数字を右斜め下のマス目に入れる。<br>ただし、数字を入れようとしたマス目が正方形からはみ出している場合、すでに数字が埋まっている場合は以下の方法に従って数字を入れるマス目を探す。</li>
<ul>
<li>右にはみ出した場合には、同じ行の左はしに、左にはみ出した場合には、同じ行の右はしに、下にはみ出した場合には、同じ列の一番上に数字を入れる。
</li>
<li> 数字を入れようとしたマス目が埋まっているときには、その埋まっているマス目の左斜め下のマス目に入れる。
</li>
</ul>
<li>全てのマス目が埋まるまで２を繰り返す。
</ol>
<p>
この方法に従って、一辺のマス目の個数 <var>n</var> を入力として、その大きさの魔方陣を出力するプログラムを作成して下さい。ただし、<var>n</var> は 3 以上 15 以下の奇数とします。マス目に入る各数字は右詰 4 桁で出力してください。
</p>
<H2>入力</H2>
<p>複数の入力が与えられます。各入力で <var>n</var> （正の整数）が１行に与えられます。入力は 0 で終了します。入力の数は 10 を超えません。</p>
<H2>出力</H2>
<p>各入力に対して <var>n</var> × <var>n</var> の魔方陣を出力して下さい。</p>
<H2>Sample Input</H2>
<pre>
3
5
0
</pre>
<H2>Output for the Sample Input</H2>
<pre>
4 9 2
3 5 7
8 1 6
11 24 7 20 3
4 12 25 8 16
17 5 13 21 9
10 18 1 14 22
23 6 19 2 15
</pre>
|
s022458437 | p00078 | Accepted | def magic(n):
c=1
x=n/2
y=x+1
while 1:
A[y][x]=c
if c==n*n:break
while 1:
x,y=(x+1)%n,(y+1)%n
if A[y][x]==0:break
x,y=(x-1)%n,(y+1)%n
if A[y][x]==0:break
c+=1
return
while 1:
n=input()
if n==0:break
N=range(n)
A=[[0]*n for i in N]
magic(n)
for i in N:
print "".join(["%4d"%(A[i][j])for j in N]) | 3
5
0
| 4 9 2
3 5 7
8 1 6
11 24 7 20 3
4 12 25 8 16
17 5 13 21 9
10 18 1 14 22
23 6 19 2 15
|
<H1>魔方陣</H1>
<p>
<var>n</var> × <var>n</var> の正方形のマス目の中に数字の１から <var>n</var> × <var>n</var> が一つずつ入っていて、縦のどの列のマス目の和も、横のどの列のマス目の和も対角線のマス目の和も等しいものを魔方陣といいます。
</p>
<p>
一辺のマスの個数が奇数の魔方陣の作り方には以下の方法があります。
</p>
<ol>
<li>中央のマス目のちょうど一つ下のマス目に１を入れる。</li>
<li>次の数字を右斜め下のマス目に入れる。<br>ただし、数字を入れようとしたマス目が正方形からはみ出している場合、すでに数字が埋まっている場合は以下の方法に従って数字を入れるマス目を探す。</li>
<ul>
<li>右にはみ出した場合には、同じ行の左はしに、左にはみ出した場合には、同じ行の右はしに、下にはみ出した場合には、同じ列の一番上に数字を入れる。
</li>
<li> 数字を入れようとしたマス目が埋まっているときには、その埋まっているマス目の左斜め下のマス目に入れる。
</li>
</ul>
<li>全てのマス目が埋まるまで２を繰り返す。
</ol>
<p>
この方法に従って、一辺のマス目の個数 <var>n</var> を入力として、その大きさの魔方陣を出力するプログラムを作成して下さい。ただし、<var>n</var> は 3 以上 15 以下の奇数とします。マス目に入る各数字は右詰 4 桁で出力してください。
</p>
<H2>入力</H2>
<p>複数の入力が与えられます。各入力で <var>n</var> （正の整数）が１行に与えられます。入力は 0 で終了します。入力の数は 10 を超えません。</p>
<H2>出力</H2>
<p>各入力に対して <var>n</var> × <var>n</var> の魔方陣を出力して下さい。</p>
<H2>Sample Input</H2>
<pre>
3
5
0
</pre>
<H2>Output for the Sample Input</H2>
<pre>
4 9 2
3 5 7
8 1 6
11 24 7 20 3
4 12 25 8 16
17 5 13 21 9
10 18 1 14 22
23 6 19 2 15
</pre>
|
s979732025 | p00078 | Accepted | def magic(n):
c=1
x=n/2
y=x+1
while 1:
A[y][x]=c
if c==n*n:break
while 1:
x,y=(x+1)%n,(y+1)%n
if A[y][x]==0:break
x,y=(x-1)%n,(y+1)%n
if A[y][x]==0:break
c+=1
return
while 1:
n=input()
if n==0:break
N=range(n)
A=[[0]*n for i in N]
magic(n)
for i in N:
print "".join(["%4d"%(e)for e in A[i]]) | 3
5
0
| 4 9 2
3 5 7
8 1 6
11 24 7 20 3
4 12 25 8 16
17 5 13 21 9
10 18 1 14 22
23 6 19 2 15
|
<H1>魔方陣</H1>
<p>
<var>n</var> × <var>n</var> の正方形のマス目の中に数字の１から <var>n</var> × <var>n</var> が一つずつ入っていて、縦のどの列のマス目の和も、横のどの列のマス目の和も対角線のマス目の和も等しいものを魔方陣といいます。
</p>
<p>
一辺のマスの個数が奇数の魔方陣の作り方には以下の方法があります。
</p>
<ol>
<li>中央のマス目のちょうど一つ下のマス目に１を入れる。</li>
<li>次の数字を右斜め下のマス目に入れる。<br>ただし、数字を入れようとしたマス目が正方形からはみ出している場合、すでに数字が埋まっている場合は以下の方法に従って数字を入れるマス目を探す。</li>
<ul>
<li>右にはみ出した場合には、同じ行の左はしに、左にはみ出した場合には、同じ行の右はしに、下にはみ出した場合には、同じ列の一番上に数字を入れる。
</li>
<li> 数字を入れようとしたマス目が埋まっているときには、その埋まっているマス目の左斜め下のマス目に入れる。
</li>
</ul>
<li>全てのマス目が埋まるまで２を繰り返す。
</ol>
<p>
この方法に従って、一辺のマス目の個数 <var>n</var> を入力として、その大きさの魔方陣を出力するプログラムを作成して下さい。ただし、<var>n</var> は 3 以上 15 以下の奇数とします。マス目に入る各数字は右詰 4 桁で出力してください。
</p>
<H2>入力</H2>
<p>複数の入力が与えられます。各入力で <var>n</var> （正の整数）が１行に与えられます。入力は 0 で終了します。入力の数は 10 を超えません。</p>
<H2>出力</H2>
<p>各入力に対して <var>n</var> × <var>n</var> の魔方陣を出力して下さい。</p>
<H2>Sample Input</H2>
<pre>
3
5
0
</pre>
<H2>Output for the Sample Input</H2>
<pre>
4 9 2
3 5 7
8 1 6
11 24 7 20 3
4 12 25 8 16
17 5 13 21 9
10 18 1 14 22
23 6 19 2 15
</pre>
|
s584612434 | p00078 | Accepted | def f(x,y):
while 1:
x,y=(x+1)%n,(y+1)%n
if A[y][x]==0:break
x,y=(x-1)%n,(y+1)%n
if A[y][x]==0:break
return x,y
def magic(n):
c=1
x=n/2
y=x+1
while 1:
A[y][x]=c
if c==n*n:break
x,y=f(x,y)
c+=1
return
while 1:
n=input()
if n==0:break
N=range(n)
A=[[0]*n for i in N]
magic(n)
for i in N:
print "".join(["%4d"%(e)for e in A[i]]) | 3
5
0
| 4 9 2
3 5 7
8 1 6
11 24 7 20 3
4 12 25 8 16
17 5 13 21 9
10 18 1 14 22
23 6 19 2 15
|
<H1>魔方陣</H1>
<p>
<var>n</var> × <var>n</var> の正方形のマス目の中に数字の１から <var>n</var> × <var>n</var> が一つずつ入っていて、縦のどの列のマス目の和も、横のどの列のマス目の和も対角線のマス目の和も等しいものを魔方陣といいます。
</p>
<p>
一辺のマスの個数が奇数の魔方陣の作り方には以下の方法があります。
</p>
<ol>
<li>中央のマス目のちょうど一つ下のマス目に１を入れる。</li>
<li>次の数字を右斜め下のマス目に入れる。<br>ただし、数字を入れようとしたマス目が正方形からはみ出している場合、すでに数字が埋まっている場合は以下の方法に従って数字を入れるマス目を探す。</li>
<ul>
<li>右にはみ出した場合には、同じ行の左はしに、左にはみ出した場合には、同じ行の右はしに、下にはみ出した場合には、同じ列の一番上に数字を入れる。
</li>
<li> 数字を入れようとしたマス目が埋まっているときには、その埋まっているマス目の左斜め下のマス目に入れる。
</li>
</ul>
<li>全てのマス目が埋まるまで２を繰り返す。
</ol>
<p>
この方法に従って、一辺のマス目の個数 <var>n</var> を入力として、その大きさの魔方陣を出力するプログラムを作成して下さい。ただし、<var>n</var> は 3 以上 15 以下の奇数とします。マス目に入る各数字は右詰 4 桁で出力してください。
</p>
<H2>入力</H2>
<p>複数の入力が与えられます。各入力で <var>n</var> （正の整数）が１行に与えられます。入力は 0 で終了します。入力の数は 10 を超えません。</p>
<H2>出力</H2>
<p>各入力に対して <var>n</var> × <var>n</var> の魔方陣を出力して下さい。</p>
<H2>Sample Input</H2>
<pre>
3
5
0
</pre>
<H2>Output for the Sample Input</H2>
<pre>
4 9 2
3 5 7
8 1 6
11 24 7 20 3
4 12 25 8 16
17 5 13 21 9
10 18 1 14 22
23 6 19 2 15
</pre>
|
s023106472 | p00078 | Accepted | def magic(n):
c=1
x=n/2
y=x+1
while 1:
A[y][x]=c
if c==n*n:break
while 1:
x,y=(x+1)%n,(y+1)%n
if A[y][x]==0:break
x,y=(x-1)%n,(y+1)%n
if A[y][x]==0:break
c+=1
return
while 1:
n=input()
if n==0:break
N=range(n)
A=[[0]*n for i in N]
magic(n)
for i in N:
print "".join(["%4d" %(e)for e in A[i]]) | 3
5
0
| 4 9 2
3 5 7
8 1 6
11 24 7 20 3
4 12 25 8 16
17 5 13 21 9
10 18 1 14 22
23 6 19 2 15
|
<H1>魔方陣</H1>
<p>
<var>n</var> × <var>n</var> の正方形のマス目の中に数字の１から <var>n</var> × <var>n</var> が一つずつ入っていて、縦のどの列のマス目の和も、横のどの列のマス目の和も対角線のマス目の和も等しいものを魔方陣といいます。
</p>
<p>
一辺のマスの個数が奇数の魔方陣の作り方には以下の方法があります。
</p>
<ol>
<li>中央のマス目のちょうど一つ下のマス目に１を入れる。</li>
<li>次の数字を右斜め下のマス目に入れる。<br>ただし、数字を入れようとしたマス目が正方形からはみ出している場合、すでに数字が埋まっている場合は以下の方法に従って数字を入れるマス目を探す。</li>
<ul>
<li>右にはみ出した場合には、同じ行の左はしに、左にはみ出した場合には、同じ行の右はしに、下にはみ出した場合には、同じ列の一番上に数字を入れる。
</li>
<li> 数字を入れようとしたマス目が埋まっているときには、その埋まっているマス目の左斜め下のマス目に入れる。
</li>
</ul>
<li>全てのマス目が埋まるまで２を繰り返す。
</ol>
<p>
この方法に従って、一辺のマス目の個数 <var>n</var> を入力として、その大きさの魔方陣を出力するプログラムを作成して下さい。ただし、<var>n</var> は 3 以上 15 以下の奇数とします。マス目に入る各数字は右詰 4 桁で出力してください。
</p>
<H2>入力</H2>
<p>複数の入力が与えられます。各入力で <var>n</var> （正の整数）が１行に与えられます。入力は 0 で終了します。入力の数は 10 を超えません。</p>
<H2>出力</H2>
<p>各入力に対して <var>n</var> × <var>n</var> の魔方陣を出力して下さい。</p>
<H2>Sample Input</H2>
<pre>
3
5
0
</pre>
<H2>Output for the Sample Input</H2>
<pre>
4 9 2
3 5 7
8 1 6
11 24 7 20 3
4 12 25 8 16
17 5 13 21 9
10 18 1 14 22
23 6 19 2 15
</pre>
|
s139837650 | p00078 | Accepted | while 1:
n = input()
if n == 0:
break
field = [[0] * n for _ in xrange(n)]
cnt = 1
x, y = n / 2, n / 2 + 1
field[y][x] = cnt
cnt += 1
while cnt <= n ** 2:
y = (y + 1) % n
x = (x + 1) % n
while field[y][x] > 0:
y = (y + 1) % n
x = (x - 1 + n) % n
field[y][x] = cnt
cnt += 1
for i in xrange(n):
print ''.join(map("{0:4}".format, field[i])) | 3
5
0
| 4 9 2
3 5 7
8 1 6
11 24 7 20 3
4 12 25 8 16
17 5 13 21 9
10 18 1 14 22
23 6 19 2 15
|
<H1>魔方陣</H1>
<p>
<var>n</var> × <var>n</var> の正方形のマス目の中に数字の１から <var>n</var> × <var>n</var> が一つずつ入っていて、縦のどの列のマス目の和も、横のどの列のマス目の和も対角線のマス目の和も等しいものを魔方陣といいます。
</p>
<p>
一辺のマスの個数が奇数の魔方陣の作り方には以下の方法があります。
</p>
<ol>
<li>中央のマス目のちょうど一つ下のマス目に１を入れる。</li>
<li>次の数字を右斜め下のマス目に入れる。<br>ただし、数字を入れようとしたマス目が正方形からはみ出している場合、すでに数字が埋まっている場合は以下の方法に従って数字を入れるマス目を探す。</li>
<ul>
<li>右にはみ出した場合には、同じ行の左はしに、左にはみ出した場合には、同じ行の右はしに、下にはみ出した場合には、同じ列の一番上に数字を入れる。
</li>
<li> 数字を入れようとしたマス目が埋まっているときには、その埋まっているマス目の左斜め下のマス目に入れる。
</li>
</ul>
<li>全てのマス目が埋まるまで２を繰り返す。
</ol>
<p>
この方法に従って、一辺のマス目の個数 <var>n</var> を入力として、その大きさの魔方陣を出力するプログラムを作成して下さい。ただし、<var>n</var> は 3 以上 15 以下の奇数とします。マス目に入る各数字は右詰 4 桁で出力してください。
</p>
<H2>入力</H2>
<p>複数の入力が与えられます。各入力で <var>n</var> （正の整数）が１行に与えられます。入力は 0 で終了します。入力の数は 10 を超えません。</p>
<H2>出力</H2>
<p>各入力に対して <var>n</var> × <var>n</var> の魔方陣を出力して下さい。</p>
<H2>Sample Input</H2>
<pre>
3
5
0
</pre>
<H2>Output for the Sample Input</H2>
<pre>
4 9 2
3 5 7
8 1 6
11 24 7 20 3
4 12 25 8 16
17 5 13 21 9
10 18 1 14 22
23 6 19 2 15
</pre>
|
s328759982 | p00078 | Accepted | while 1:
n = int(input())
if n == 0:
break
l = [[ 0 for i in range(n)] for j in range(n)]
i = n//2 + 1
j = n//2
l[i][j] = ' 1'
c = 2
d = '{: >4}'.format(c)
for x in range(n**2 - 1):
i = (i + 1) % n
j = (j + 1) % n
while l[i][j] != 0:
i = (i + 1) % n
j = (j - 1) % n
l[i][j] = d
c += 1
d = '{: >4}'.format(c)
for s in range(n):
print(*l[s],sep="")
| 3
5
0
| 4 9 2
3 5 7
8 1 6
11 24 7 20 3
4 12 25 8 16
17 5 13 21 9
10 18 1 14 22
23 6 19 2 15
|
<H1>魔方陣</H1>
<p>
<var>n</var> × <var>n</var> の正方形のマス目の中に数字の１から <var>n</var> × <var>n</var> が一つずつ入っていて、縦のどの列のマス目の和も、横のどの列のマス目の和も対角線のマス目の和も等しいものを魔方陣といいます。
</p>
<p>
一辺のマスの個数が奇数の魔方陣の作り方には以下の方法があります。
</p>
<ol>
<li>中央のマス目のちょうど一つ下のマス目に１を入れる。</li>
<li>次の数字を右斜め下のマス目に入れる。<br>ただし、数字を入れようとしたマス目が正方形からはみ出している場合、すでに数字が埋まっている場合は以下の方法に従って数字を入れるマス目を探す。</li>
<ul>
<li>右にはみ出した場合には、同じ行の左はしに、左にはみ出した場合には、同じ行の右はしに、下にはみ出した場合には、同じ列の一番上に数字を入れる。
</li>
<li> 数字を入れようとしたマス目が埋まっているときには、その埋まっているマス目の左斜め下のマス目に入れる。
</li>
</ul>
<li>全てのマス目が埋まるまで２を繰り返す。
</ol>
<p>
この方法に従って、一辺のマス目の個数 <var>n</var> を入力として、その大きさの魔方陣を出力するプログラムを作成して下さい。ただし、<var>n</var> は 3 以上 15 以下の奇数とします。マス目に入る各数字は右詰 4 桁で出力してください。
</p>
<H2>入力</H2>
<p>複数の入力が与えられます。各入力で <var>n</var> （正の整数）が１行に与えられます。入力は 0 で終了します。入力の数は 10 を超えません。</p>
<H2>出力</H2>
<p>各入力に対して <var>n</var> × <var>n</var> の魔方陣を出力して下さい。</p>
<H2>Sample Input</H2>
<pre>
3
5
0
</pre>
<H2>Output for the Sample Input</H2>
<pre>
4 9 2
3 5 7
8 1 6
11 24 7 20 3
4 12 25 8 16
17 5 13 21 9
10 18 1 14 22
23 6 19 2 15
</pre>
|
s938079837 | p00078 | Accepted | while True :
n = int(input())
if n == 0 :
break
magic = list([0] * n for i in range(n))
x = (n+1)//2 - 1
y = (n+1)//2 - 2
for i in range(1, n**2+1) :
x += 1
y += 1
while True :
if x >= n :
x = 0
if y >= n :
y = 0
if magic[x][y] != 0 :
x += 1
y -= 1
if y == -1 :
y = n - 1
if x < n and y < n and magic[x][y] == 0 :
break
magic[x][y] = i
for i in range(n) :
for j in range(n) :
print('{:4}'.format(magic[i][j]), end="")
print()
| 3
5
0
| 4 9 2
3 5 7
8 1 6
11 24 7 20 3
4 12 25 8 16
17 5 13 21 9
10 18 1 14 22
23 6 19 2 15
|
<H1>魔方陣</H1>
<p>
<var>n</var> × <var>n</var> の正方形のマス目の中に数字の１から <var>n</var> × <var>n</var> が一つずつ入っていて、縦のどの列のマス目の和も、横のどの列のマス目の和も対角線のマス目の和も等しいものを魔方陣といいます。
</p>
<p>
一辺のマスの個数が奇数の魔方陣の作り方には以下の方法があります。
</p>
<ol>
<li>中央のマス目のちょうど一つ下のマス目に１を入れる。</li>
<li>次の数字を右斜め下のマス目に入れる。<br>ただし、数字を入れようとしたマス目が正方形からはみ出している場合、すでに数字が埋まっている場合は以下の方法に従って数字を入れるマス目を探す。</li>
<ul>
<li>右にはみ出した場合には、同じ行の左はしに、左にはみ出した場合には、同じ行の右はしに、下にはみ出した場合には、同じ列の一番上に数字を入れる。
</li>
<li> 数字を入れようとしたマス目が埋まっているときには、その埋まっているマス目の左斜め下のマス目に入れる。
</li>
</ul>
<li>全てのマス目が埋まるまで２を繰り返す。
</ol>
<p>
この方法に従って、一辺のマス目の個数 <var>n</var> を入力として、その大きさの魔方陣を出力するプログラムを作成して下さい。ただし、<var>n</var> は 3 以上 15 以下の奇数とします。マス目に入る各数字は右詰 4 桁で出力してください。
</p>
<H2>入力</H2>
<p>複数の入力が与えられます。各入力で <var>n</var> （正の整数）が１行に与えられます。入力は 0 で終了します。入力の数は 10 を超えません。</p>
<H2>出力</H2>
<p>各入力に対して <var>n</var> × <var>n</var> の魔方陣を出力して下さい。</p>
<H2>Sample Input</H2>
<pre>
3
5
0
</pre>
<H2>Output for the Sample Input</H2>
<pre>
4 9 2
3 5 7
8 1 6
11 24 7 20 3
4 12 25 8 16
17 5 13 21 9
10 18 1 14 22
23 6 19 2 15
</pre>
|
s939135575 | p00078 | Accepted | import sys
readline = sys.stdin.readline
write = sys.stdout.write
def solve():
N = int(readline())
if N == 0:
return False
x = N//2; y = x+1
P = [[-1]*N for i in range(N)]
c = 0
N2 = N*N
while c < N2:
if P[y][x] == -1:
c += 1
P[y][x] = c
x = (x + 1) % N; y = (y + 1) % N
else:
x = (x - 1) % N; y = (y + 1) % N
for line in P:
write("".join(map("{:4d}".format, line)))
write("\n")
return True
while solve():
...
| 3
5
0
| 4 9 2
3 5 7
8 1 6
11 24 7 20 3
4 12 25 8 16
17 5 13 21 9
10 18 1 14 22
23 6 19 2 15
|
<H1>魔方陣</H1>
<p>
<var>n</var> × <var>n</var> の正方形のマス目の中に数字の１から <var>n</var> × <var>n</var> が一つずつ入っていて、縦のどの列のマス目の和も、横のどの列のマス目の和も対角線のマス目の和も等しいものを魔方陣といいます。
</p>
<p>
一辺のマスの個数が奇数の魔方陣の作り方には以下の方法があります。
</p>
<ol>
<li>中央のマス目のちょうど一つ下のマス目に１を入れる。</li>
<li>次の数字を右斜め下のマス目に入れる。<br>ただし、数字を入れようとしたマス目が正方形からはみ出している場合、すでに数字が埋まっている場合は以下の方法に従って数字を入れるマス目を探す。</li>
<ul>
<li>右にはみ出した場合には、同じ行の左はしに、左にはみ出した場合には、同じ行の右はしに、下にはみ出した場合には、同じ列の一番上に数字を入れる。
</li>
<li> 数字を入れようとしたマス目が埋まっているときには、その埋まっているマス目の左斜め下のマス目に入れる。
</li>
</ul>
<li>全てのマス目が埋まるまで２を繰り返す。
</ol>
<p>
この方法に従って、一辺のマス目の個数 <var>n</var> を入力として、その大きさの魔方陣を出力するプログラムを作成して下さい。ただし、<var>n</var> は 3 以上 15 以下の奇数とします。マス目に入る各数字は右詰 4 桁で出力してください。
</p>
<H2>入力</H2>
<p>複数の入力が与えられます。各入力で <var>n</var> （正の整数）が１行に与えられます。入力は 0 で終了します。入力の数は 10 を超えません。</p>
<H2>出力</H2>
<p>各入力に対して <var>n</var> × <var>n</var> の魔方陣を出力して下さい。</p>
<H2>Sample Input</H2>
<pre>
3
5
0
</pre>
<H2>Output for the Sample Input</H2>
<pre>
4 9 2
3 5 7
8 1 6
11 24 7 20 3
4 12 25 8 16
17 5 13 21 9
10 18 1 14 22
23 6 19 2 15
</pre>
|
s804553028 | p00078 | Accepted | def print_board(A,n):
for i in range(n):
s = ""
for j in range(n):
st = str(A[i][j])
if len(st) == 1:
s += " "
elif len(st) == 2:
s += " "
elif len(st) == 3:
s += " "
s += str(st)
print(s)
def check_leftdown(A,h,w,n):
if h + 1 > n - 1:
#下に抜けるならば,左に-1してその列に値が入っていない箇所を探す
w -= 1
for x in range(n):
if A[x][w] == 0:
h = x
break
else:
#左に抜けるならば
if w - 1 < 0:
w = n
h += 1
else:
h += 1
w -= 1
return h,w
def check_rightdown(A,h,w,n):
if h + 1 > n - 1:
#下にも右にも抜ける場合
if w + 1 > n - 1:
None
else:
#下に抜けるならば,右に＋1してその列に値が入っていない箇所を探す
w += 1
for x in range(n):
if A[x][w] == 0:
h = x
break
else:
if w + 1 > n - 1:
#右に抜けるならば
w = 0
h += 1
else:
#通常パターン
h += 1
w += 1
if A[h][w] != 0:
#値が既に埋まっている
#左下をチェック
h,w = check_leftdown(A,h,w,n)
return h,w
if __name__ == '__main__':
while True:
try:
n = int(input())
if n == 0:
break
A = [[0 for i in range(n)] for j in range(n)]
cnt = n * n
for x in range(cnt):
if x == 0:
mid = n // 2
h = mid + 1
w = mid
A[h][w] = x + 1
else:
h,w = check_rightdown(A,h,w,n)
A[h][w] = x+1
print_board(A,n)
except EOFError:
break
| 3
5
0
| 4 9 2
3 5 7
8 1 6
11 24 7 20 3
4 12 25 8 16
17 5 13 21 9
10 18 1 14 22
23 6 19 2 15
|
<H1>魔方陣</H1>
<p>
<var>n</var> × <var>n</var> の正方形のマス目の中に数字の１から <var>n</var> × <var>n</var> が一つずつ入っていて、縦のどの列のマス目の和も、横のどの列のマス目の和も対角線のマス目の和も等しいものを魔方陣といいます。
</p>
<p>
一辺のマスの個数が奇数の魔方陣の作り方には以下の方法があります。
</p>
<ol>
<li>中央のマス目のちょうど一つ下のマス目に１を入れる。</li>
<li>次の数字を右斜め下のマス目に入れる。<br>ただし、数字を入れようとしたマス目が正方形からはみ出している場合、すでに数字が埋まっている場合は以下の方法に従って数字を入れるマス目を探す。</li>
<ul>
<li>右にはみ出した場合には、同じ行の左はしに、左にはみ出した場合には、同じ行の右はしに、下にはみ出した場合には、同じ列の一番上に数字を入れる。
</li>
<li> 数字を入れようとしたマス目が埋まっているときには、その埋まっているマス目の左斜め下のマス目に入れる。
</li>
</ul>
<li>全てのマス目が埋まるまで２を繰り返す。
</ol>
<p>
この方法に従って、一辺のマス目の個数 <var>n</var> を入力として、その大きさの魔方陣を出力するプログラムを作成して下さい。ただし、<var>n</var> は 3 以上 15 以下の奇数とします。マス目に入る各数字は右詰 4 桁で出力してください。
</p>
<H2>入力</H2>
<p>複数の入力が与えられます。各入力で <var>n</var> （正の整数）が１行に与えられます。入力は 0 で終了します。入力の数は 10 を超えません。</p>
<H2>出力</H2>
<p>各入力に対して <var>n</var> × <var>n</var> の魔方陣を出力して下さい。</p>
<H2>Sample Input</H2>
<pre>
3
5
0
</pre>
<H2>Output for the Sample Input</H2>
<pre>
4 9 2
3 5 7
8 1 6
11 24 7 20 3
4 12 25 8 16
17 5 13 21 9
10 18 1 14 22
23 6 19 2 15
</pre>
|
s470867398 | p00078 | Accepted | def square(n):
mp = [[0 for _ in range(n)] for _ in range(n)]
x, y = n // 2, n // 2 + 1
mp[y][x] = 1
for i in range(2, n ** 2 + 1):
x = (x + 1) % n
y = (y + 1) % n
while mp[y][x]:
y = (y + 1) % n
x = (x - 1) % n
mp[y][x] = i
for line in mp:
s = ""
for i in line:
si = str(i)
s += si.rjust(4)
print(s)
while True:
n = int(input())
if not n:
break
square(n)
| 3
5
0
| 4 9 2
3 5 7
8 1 6
11 24 7 20 3
4 12 25 8 16
17 5 13 21 9
10 18 1 14 22
23 6 19 2 15
|
<H1>魔方陣</H1>
<p>
<var>n</var> × <var>n</var> の正方形のマス目の中に数字の１から <var>n</var> × <var>n</var> が一つずつ入っていて、縦のどの列のマス目の和も、横のどの列のマス目の和も対角線のマス目の和も等しいものを魔方陣といいます。
</p>
<p>
一辺のマスの個数が奇数の魔方陣の作り方には以下の方法があります。
</p>
<ol>
<li>中央のマス目のちょうど一つ下のマス目に１を入れる。</li>
<li>次の数字を右斜め下のマス目に入れる。<br>ただし、数字を入れようとしたマス目が正方形からはみ出している場合、すでに数字が埋まっている場合は以下の方法に従って数字を入れるマス目を探す。</li>
<ul>
<li>右にはみ出した場合には、同じ行の左はしに、左にはみ出した場合には、同じ行の右はしに、下にはみ出した場合には、同じ列の一番上に数字を入れる。
</li>
<li> 数字を入れようとしたマス目が埋まっているときには、その埋まっているマス目の左斜め下のマス目に入れる。
</li>
</ul>
<li>全てのマス目が埋まるまで２を繰り返す。
</ol>
<p>
この方法に従って、一辺のマス目の個数 <var>n</var> を入力として、その大きさの魔方陣を出力するプログラムを作成して下さい。ただし、<var>n</var> は 3 以上 15 以下の奇数とします。マス目に入る各数字は右詰 4 桁で出力してください。
</p>
<H2>入力</H2>
<p>複数の入力が与えられます。各入力で <var>n</var> （正の整数）が１行に与えられます。入力は 0 で終了します。入力の数は 10 を超えません。</p>
<H2>出力</H2>
<p>各入力に対して <var>n</var> × <var>n</var> の魔方陣を出力して下さい。</p>
<H2>Sample Input</H2>
<pre>
3
5
0
</pre>
<H2>Output for the Sample Input</H2>
<pre>
4 9 2
3 5 7
8 1 6
11 24 7 20 3
4 12 25 8 16
17 5 13 21 9
10 18 1 14 22
23 6 19 2 15
</pre>
|
s480232950 | p00078 | Accepted | while 1:
n=int(input())
if n==0:break
ans=[[0 for i in range(n)] for j in range(n)]
y=n//2
x=n//2-1
for i in range(1,n**2+1):
y=[y+1,y+1-n][y+1==n]
x=[x+1,x+1-n][x+1==n]
if ans[y][x]==0:ans[y][x]=str(i).rjust(4)
else:
y=[y+1,y+1-n][y+1==n]
x=[x-1,x-1+n][x==0]
ans[y][x]=str(i).rjust(4)
for i in ans:print(''.join(map(str,i)))
| 3
5
0
| 4 9 2
3 5 7
8 1 6
11 24 7 20 3
4 12 25 8 16
17 5 13 21 9
10 18 1 14 22
23 6 19 2 15
|
<H1>魔方陣</H1>
<p>
<var>n</var> × <var>n</var> の正方形のマス目の中に数字の１から <var>n</var> × <var>n</var> が一つずつ入っていて、縦のどの列のマス目の和も、横のどの列のマス目の和も対角線のマス目の和も等しいものを魔方陣といいます。
</p>
<p>
一辺のマスの個数が奇数の魔方陣の作り方には以下の方法があります。
</p>
<ol>
<li>中央のマス目のちょうど一つ下のマス目に１を入れる。</li>
<li>次の数字を右斜め下のマス目に入れる。<br>ただし、数字を入れようとしたマス目が正方形からはみ出している場合、すでに数字が埋まっている場合は以下の方法に従って数字を入れるマス目を探す。</li>
<ul>
<li>右にはみ出した場合には、同じ行の左はしに、左にはみ出した場合には、同じ行の右はしに、下にはみ出した場合には、同じ列の一番上に数字を入れる。
</li>
<li> 数字を入れようとしたマス目が埋まっているときには、その埋まっているマス目の左斜め下のマス目に入れる。
</li>
</ul>
<li>全てのマス目が埋まるまで２を繰り返す。
</ol>
<p>
この方法に従って、一辺のマス目の個数 <var>n</var> を入力として、その大きさの魔方陣を出力するプログラムを作成して下さい。ただし、<var>n</var> は 3 以上 15 以下の奇数とします。マス目に入る各数字は右詰 4 桁で出力してください。
</p>
<H2>入力</H2>
<p>複数の入力が与えられます。各入力で <var>n</var> （正の整数）が１行に与えられます。入力は 0 で終了します。入力の数は 10 を超えません。</p>
<H2>出力</H2>
<p>各入力に対して <var>n</var> × <var>n</var> の魔方陣を出力して下さい。</p>
<H2>Sample Input</H2>
<pre>
3
5
0
</pre>
<H2>Output for the Sample Input</H2>
<pre>
4 9 2
3 5 7
8 1 6
11 24 7 20 3
4 12 25 8 16
17 5 13 21 9
10 18 1 14 22
23 6 19 2 15
</pre>
|
s248208688 | p00078 | Accepted | def fill(x,y,count):
global board
if count == n**2:
return 0
count += 1
while board[x%n][y%n] != 0:
x += 1
y -= 1
board[x%n][y%n] = count
fill(x+1,y+1,count)
while(1):
n = int(input())
if n == 0:
break
board = [[0 for i in range(n)] for j in range(n)]
fill(int(n/2)+1,int(n/2),0)
board = [["{: >4}".format(i) for i in j] for j in board]
[print(*board[i],sep="") for i in range(n)]
| 3
5
0
| 4 9 2
3 5 7
8 1 6
11 24 7 20 3
4 12 25 8 16
17 5 13 21 9
10 18 1 14 22
23 6 19 2 15
|
<H1>魔方陣</H1>
<p>
<var>n</var> × <var>n</var> の正方形のマス目の中に数字の１から <var>n</var> × <var>n</var> が一つずつ入っていて、縦のどの列のマス目の和も、横のどの列のマス目の和も対角線のマス目の和も等しいものを魔方陣といいます。
</p>
<p>
一辺のマスの個数が奇数の魔方陣の作り方には以下の方法があります。
</p>
<ol>
<li>中央のマス目のちょうど一つ下のマス目に１を入れる。</li>
<li>次の数字を右斜め下のマス目に入れる。<br>ただし、数字を入れようとしたマス目が正方形からはみ出している場合、すでに数字が埋まっている場合は以下の方法に従って数字を入れるマス目を探す。</li>
<ul>
<li>右にはみ出した場合には、同じ行の左はしに、左にはみ出した場合には、同じ行の右はしに、下にはみ出した場合には、同じ列の一番上に数字を入れる。
</li>
<li> 数字を入れようとしたマス目が埋まっているときには、その埋まっているマス目の左斜め下のマス目に入れる。
</li>
</ul>
<li>全てのマス目が埋まるまで２を繰り返す。
</ol>
<p>
この方法に従って、一辺のマス目の個数 <var>n</var> を入力として、その大きさの魔方陣を出力するプログラムを作成して下さい。ただし、<var>n</var> は 3 以上 15 以下の奇数とします。マス目に入る各数字は右詰 4 桁で出力してください。
</p>
<H2>入力</H2>
<p>複数の入力が与えられます。各入力で <var>n</var> （正の整数）が１行に与えられます。入力は 0 で終了します。入力の数は 10 を超えません。</p>
<H2>出力</H2>
<p>各入力に対して <var>n</var> × <var>n</var> の魔方陣を出力して下さい。</p>
<H2>Sample Input</H2>
<pre>
3
5
0
</pre>
<H2>Output for the Sample Input</H2>
<pre>
4 9 2
3 5 7
8 1 6
11 24 7 20 3
4 12 25 8 16
17 5 13 21 9
10 18 1 14 22
23 6 19 2 15
</pre>
|
s670815949 | p00078 | Runtime Error | from sys import stdin
def sqmatrix(n):
return [[0] * n for i in range(n)]
def magicsq(m):
n = len(m)
j = n/2
i = j + 1
for num in range(1, n**2 + 1):
m[i][j] = num
i += 1
j += 1
i = i%n
j = j % n
if m[i][j] != 0:
i += 1
j -= 1
if j < 0:
j = n -1
i = i % n
return m
for line in stdin:
n = int(line)
if n == 0:
break
sm = sqmatrix(n)
for row in magicsq(sm): print (' '.join(map(str,row))) | 3
5
0
| 4 9 2
3 5 7
8 1 6
11 24 7 20 3
4 12 25 8 16
17 5 13 21 9
10 18 1 14 22
23 6 19 2 15
|
<H1>魔方陣</H1>
<p>
<var>n</var> × <var>n</var> の正方形のマス目の中に数字の１から <var>n</var> × <var>n</var> が一つずつ入っていて、縦のどの列のマス目の和も、横のどの列のマス目の和も対角線のマス目の和も等しいものを魔方陣といいます。
</p>
<p>
一辺のマスの個数が奇数の魔方陣の作り方には以下の方法があります。
</p>
<ol>
<li>中央のマス目のちょうど一つ下のマス目に１を入れる。</li>
<li>次の数字を右斜め下のマス目に入れる。<br>ただし、数字を入れようとしたマス目が正方形からはみ出している場合、すでに数字が埋まっている場合は以下の方法に従って数字を入れるマス目を探す。</li>
<ul>
<li>右にはみ出した場合には、同じ行の左はしに、左にはみ出した場合には、同じ行の右はしに、下にはみ出した場合には、同じ列の一番上に数字を入れる。
</li>
<li> 数字を入れようとしたマス目が埋まっているときには、その埋まっているマス目の左斜め下のマス目に入れる。
</li>
</ul>
<li>全てのマス目が埋まるまで２を繰り返す。
</ol>
<p>
この方法に従って、一辺のマス目の個数 <var>n</var> を入力として、その大きさの魔方陣を出力するプログラムを作成して下さい。ただし、<var>n</var> は 3 以上 15 以下の奇数とします。マス目に入る各数字は右詰 4 桁で出力してください。
</p>
<H2>入力</H2>
<p>複数の入力が与えられます。各入力で <var>n</var> （正の整数）が１行に与えられます。入力は 0 で終了します。入力の数は 10 を超えません。</p>
<H2>出力</H2>
<p>各入力に対して <var>n</var> × <var>n</var> の魔方陣を出力して下さい。</p>
<H2>Sample Input</H2>
<pre>
3
5
0
</pre>
<H2>Output for the Sample Input</H2>
<pre>
4 9 2
3 5 7
8 1 6
11 24 7 20 3
4 12 25 8 16
17 5 13 21 9
10 18 1 14 22
23 6 19 2 15
</pre>
|
s154909676 | p00078 | Runtime Error | while True:
n = int(raw_input())
if n == 0:
break
magic = [[0 for i in range(n)] for i in range(n)]
x, y = n/2, n/2
magic[y][x] = 1
count = 2
while count <= n**2:
x, y = (x+1)%n, (y+1)%n
if magic[y][x] == 0:
magic[y][x] = count
count += 1
else:
x, y = (x-1)%n, (y+1)%n
magic[y][x] = count
count += 1
for i in xrange(n):
print "".join(map(lambda s:str(s).rjust(4),board[i]) | 3
5
0
| 4 9 2
3 5 7
8 1 6
11 24 7 20 3
4 12 25 8 16
17 5 13 21 9
10 18 1 14 22
23 6 19 2 15
|
<H1>魔方陣</H1>
<p>
<var>n</var> × <var>n</var> の正方形のマス目の中に数字の１から <var>n</var> × <var>n</var> が一つずつ入っていて、縦のどの列のマス目の和も、横のどの列のマス目の和も対角線のマス目の和も等しいものを魔方陣といいます。
</p>
<p>
一辺のマスの個数が奇数の魔方陣の作り方には以下の方法があります。
</p>
<ol>
<li>中央のマス目のちょうど一つ下のマス目に１を入れる。</li>
<li>次の数字を右斜め下のマス目に入れる。<br>ただし、数字を入れようとしたマス目が正方形からはみ出している場合、すでに数字が埋まっている場合は以下の方法に従って数字を入れるマス目を探す。</li>
<ul>
<li>右にはみ出した場合には、同じ行の左はしに、左にはみ出した場合には、同じ行の右はしに、下にはみ出した場合には、同じ列の一番上に数字を入れる。
</li>
<li> 数字を入れようとしたマス目が埋まっているときには、その埋まっているマス目の左斜め下のマス目に入れる。
</li>
</ul>
<li>全てのマス目が埋まるまで２を繰り返す。
</ol>
<p>
この方法に従って、一辺のマス目の個数 <var>n</var> を入力として、その大きさの魔方陣を出力するプログラムを作成して下さい。ただし、<var>n</var> は 3 以上 15 以下の奇数とします。マス目に入る各数字は右詰 4 桁で出力してください。
</p>
<H2>入力</H2>
<p>複数の入力が与えられます。各入力で <var>n</var> （正の整数）が１行に与えられます。入力は 0 で終了します。入力の数は 10 を超えません。</p>
<H2>出力</H2>
<p>各入力に対して <var>n</var> × <var>n</var> の魔方陣を出力して下さい。</p>
<H2>Sample Input</H2>
<pre>
3
5
0
</pre>
<H2>Output for the Sample Input</H2>
<pre>
4 9 2
3 5 7
8 1 6
11 24 7 20 3
4 12 25 8 16
17 5 13 21 9
10 18 1 14 22
23 6 19 2 15
</pre>
|
s257501573 | p00078 | WA: Presentation Error | while True:
n = input()
if n == 0: break
board = [[0] * n for i in range(n)]
xp = n / 2
yp = n / 2 + 1
for i in range(n ** 2):
if board[yp][xp] == 0:
board[yp][xp] = i + 1
else:
xp -= 1
yp += 1
if xp == -1: xp = n - 1
if yp == n : yp = 0
board[yp][xp] = i + 1
yp += 1
xp += 1
if xp == n: xp = 0
if yp == n: yp = 0
for b in board:
print " ".join(map(str, b)) | 3
5
0
| 4 9 2
3 5 7
8 1 6
11 24 7 20 3
4 12 25 8 16
17 5 13 21 9
10 18 1 14 22
23 6 19 2 15
|
<H1>魔方陣</H1>
<p>
<var>n</var> × <var>n</var> の正方形のマス目の中に数字の１から <var>n</var> × <var>n</var> が一つずつ入っていて、縦のどの列のマス目の和も、横のどの列のマス目の和も対角線のマス目の和も等しいものを魔方陣といいます。
</p>
<p>
一辺のマスの個数が奇数の魔方陣の作り方には以下の方法があります。
</p>
<ol>
<li>中央のマス目のちょうど一つ下のマス目に１を入れる。</li>
<li>次の数字を右斜め下のマス目に入れる。<br>ただし、数字を入れようとしたマス目が正方形からはみ出している場合、すでに数字が埋まっている場合は以下の方法に従って数字を入れるマス目を探す。</li>
<ul>
<li>右にはみ出した場合には、同じ行の左はしに、左にはみ出した場合には、同じ行の右はしに、下にはみ出した場合には、同じ列の一番上に数字を入れる。
</li>
<li> 数字を入れようとしたマス目が埋まっているときには、その埋まっているマス目の左斜め下のマス目に入れる。
</li>
</ul>
<li>全てのマス目が埋まるまで２を繰り返す。
</ol>
<p>
この方法に従って、一辺のマス目の個数 <var>n</var> を入力として、その大きさの魔方陣を出力するプログラムを作成して下さい。ただし、<var>n</var> は 3 以上 15 以下の奇数とします。マス目に入る各数字は右詰 4 桁で出力してください。
</p>
<H2>入力</H2>
<p>複数の入力が与えられます。各入力で <var>n</var> （正の整数）が１行に与えられます。入力は 0 で終了します。入力の数は 10 を超えません。</p>
<H2>出力</H2>
<p>各入力に対して <var>n</var> × <var>n</var> の魔方陣を出力して下さい。</p>
<H2>Sample Input</H2>
<pre>
3
5
0
</pre>
<H2>Output for the Sample Input</H2>
<pre>
4 9 2
3 5 7
8 1 6
11 24 7 20 3
4 12 25 8 16
17 5 13 21 9
10 18 1 14 22
23 6 19 2 15
</pre>
|
s000471951 | p00078 | WA: Presentation Error | def chekend(mc):
for m in mc:
if not all(m):
return False
return True
def solve(n):
mc = [ [ 0 for j in xrange(n) ] for i in xrange(n)]
px = n/2
py = n/2 + 1
cnt = 1
mc[py][px] = cnt
px += 1
py += 1
cnt += 1
while True:
if chekend(mc): break
if px >= n: px = 0; continue
if px < 0: px = n-1; continue
if py >= n: py = 0; continue
if mc[py][px]: px -= 1; py += 1; continue
mc[py][px] = cnt
cnt += 1
px += 1
py += 1
for m in mc:
for l in m:
print l,
print
while True:
n = input()
if n == 0:
break
solve(n) | 3
5
0
| 4 9 2
3 5 7
8 1 6
11 24 7 20 3
4 12 25 8 16
17 5 13 21 9
10 18 1 14 22
23 6 19 2 15
|
<H1>魔方陣</H1>
<p>
<var>n</var> × <var>n</var> の正方形のマス目の中に数字の１から <var>n</var> × <var>n</var> が一つずつ入っていて、縦のどの列のマス目の和も、横のどの列のマス目の和も対角線のマス目の和も等しいものを魔方陣といいます。
</p>
<p>
一辺のマスの個数が奇数の魔方陣の作り方には以下の方法があります。
</p>
<ol>
<li>中央のマス目のちょうど一つ下のマス目に１を入れる。</li>
<li>次の数字を右斜め下のマス目に入れる。<br>ただし、数字を入れようとしたマス目が正方形からはみ出している場合、すでに数字が埋まっている場合は以下の方法に従って数字を入れるマス目を探す。</li>
<ul>
<li>右にはみ出した場合には、同じ行の左はしに、左にはみ出した場合には、同じ行の右はしに、下にはみ出した場合には、同じ列の一番上に数字を入れる。
</li>
<li> 数字を入れようとしたマス目が埋まっているときには、その埋まっているマス目の左斜め下のマス目に入れる。
</li>
</ul>
<li>全てのマス目が埋まるまで２を繰り返す。
</ol>
<p>
この方法に従って、一辺のマス目の個数 <var>n</var> を入力として、その大きさの魔方陣を出力するプログラムを作成して下さい。ただし、<var>n</var> は 3 以上 15 以下の奇数とします。マス目に入る各数字は右詰 4 桁で出力してください。
</p>
<H2>入力</H2>
<p>複数の入力が与えられます。各入力で <var>n</var> （正の整数）が１行に与えられます。入力は 0 で終了します。入力の数は 10 を超えません。</p>
<H2>出力</H2>
<p>各入力に対して <var>n</var> × <var>n</var> の魔方陣を出力して下さい。</p>
<H2>Sample Input</H2>
<pre>
3
5
0
</pre>
<H2>Output for the Sample Input</H2>
<pre>
4 9 2
3 5 7
8 1 6
11 24 7 20 3
4 12 25 8 16
17 5 13 21 9
10 18 1 14 22
23 6 19 2 15
</pre>
|
s662993588 | p00078 | WA: Presentation Error | def chekend(mc):
for m in mc:
if not all(m):
return False
return True
def solve(n):
mc = [ [ 0 for j in xrange(n) ] for i in xrange(n)]
px = n/2
py = n/2 + 1
cnt = 1
mc[py][px] = cnt
px += 1
py += 1
cnt += 1
while True:
if chekend(mc): break
if px >= n: px = 0; continue
if px < 0: px = n-1; continue
if py >= n: py = 0; continue
if mc[py][px]: px -= 1; py += 1; continue
mc[py][px] = cnt
cnt += 1
px += 1
py += 1
for m in mc:
for l in m:
print "%4d"%(l),
print
while True:
n = input()
if n == 0:
break
solve(n) | 3
5
0
| 4 9 2
3 5 7
8 1 6
11 24 7 20 3
4 12 25 8 16
17 5 13 21 9
10 18 1 14 22
23 6 19 2 15
|
<H1>魔方陣</H1>
<p>
<var>n</var> × <var>n</var> の正方形のマス目の中に数字の１から <var>n</var> × <var>n</var> が一つずつ入っていて、縦のどの列のマス目の和も、横のどの列のマス目の和も対角線のマス目の和も等しいものを魔方陣といいます。
</p>
<p>
一辺のマスの個数が奇数の魔方陣の作り方には以下の方法があります。
</p>
<ol>
<li>中央のマス目のちょうど一つ下のマス目に１を入れる。</li>
<li>次の数字を右斜め下のマス目に入れる。<br>ただし、数字を入れようとしたマス目が正方形からはみ出している場合、すでに数字が埋まっている場合は以下の方法に従って数字を入れるマス目を探す。</li>
<ul>
<li>右にはみ出した場合には、同じ行の左はしに、左にはみ出した場合には、同じ行の右はしに、下にはみ出した場合には、同じ列の一番上に数字を入れる。
</li>
<li> 数字を入れようとしたマス目が埋まっているときには、その埋まっているマス目の左斜め下のマス目に入れる。
</li>
</ul>
<li>全てのマス目が埋まるまで２を繰り返す。
</ol>
<p>
この方法に従って、一辺のマス目の個数 <var>n</var> を入力として、その大きさの魔方陣を出力するプログラムを作成して下さい。ただし、<var>n</var> は 3 以上 15 以下の奇数とします。マス目に入る各数字は右詰 4 桁で出力してください。
</p>
<H2>入力</H2>
<p>複数の入力が与えられます。各入力で <var>n</var> （正の整数）が１行に与えられます。入力は 0 で終了します。入力の数は 10 を超えません。</p>
<H2>出力</H2>
<p>各入力に対して <var>n</var> × <var>n</var> の魔方陣を出力して下さい。</p>
<H2>Sample Input</H2>
<pre>
3
5
0
</pre>
<H2>Output for the Sample Input</H2>
<pre>
4 9 2
3 5 7
8 1 6
11 24 7 20 3
4 12 25 8 16
17 5 13 21 9
10 18 1 14 22
23 6 19 2 15
</pre>
|
s956477301 | p00078 | WA: Presentation Error | def chekend(mc):
for m in mc:
if not all(m):
return False
return True
def solve(n):
mc = [ [ 0 for j in xrange(n) ] for i in xrange(n)]
px = n/2
py = n/2 + 1
cnt = 1
mc[py][px] = cnt
px += 1
py += 1
cnt += 1
while True:
if chekend(mc): break
if px >= n: px = 0; continue
if px < 0: px = n-1; continue
if py >= n: py = 0; continue
if mc[py][px]: px -= 1; py += 1; continue
mc[py][px] = cnt
cnt += 1
px += 1
py += 1
for m in mc:
for l in m:
print "%3d"%(l),
print
while True:
n = input()
if n == 0:
break
solve(n) | 3
5
0
| 4 9 2
3 5 7
8 1 6
11 24 7 20 3
4 12 25 8 16
17 5 13 21 9
10 18 1 14 22
23 6 19 2 15
|
<H1>魔方陣</H1>
<p>
<var>n</var> × <var>n</var> の正方形のマス目の中に数字の１から <var>n</var> × <var>n</var> が一つずつ入っていて、縦のどの列のマス目の和も、横のどの列のマス目の和も対角線のマス目の和も等しいものを魔方陣といいます。
</p>
<p>
一辺のマスの個数が奇数の魔方陣の作り方には以下の方法があります。
</p>
<ol>
<li>中央のマス目のちょうど一つ下のマス目に１を入れる。</li>
<li>次の数字を右斜め下のマス目に入れる。<br>ただし、数字を入れようとしたマス目が正方形からはみ出している場合、すでに数字が埋まっている場合は以下の方法に従って数字を入れるマス目を探す。</li>
<ul>
<li>右にはみ出した場合には、同じ行の左はしに、左にはみ出した場合には、同じ行の右はしに、下にはみ出した場合には、同じ列の一番上に数字を入れる。
</li>
<li> 数字を入れようとしたマス目が埋まっているときには、その埋まっているマス目の左斜め下のマス目に入れる。
</li>
</ul>
<li>全てのマス目が埋まるまで２を繰り返す。
</ol>
<p>
この方法に従って、一辺のマス目の個数 <var>n</var> を入力として、その大きさの魔方陣を出力するプログラムを作成して下さい。ただし、<var>n</var> は 3 以上 15 以下の奇数とします。マス目に入る各数字は右詰 4 桁で出力してください。
</p>
<H2>入力</H2>
<p>複数の入力が与えられます。各入力で <var>n</var> （正の整数）が１行に与えられます。入力は 0 で終了します。入力の数は 10 を超えません。</p>
<H2>出力</H2>
<p>各入力に対して <var>n</var> × <var>n</var> の魔方陣を出力して下さい。</p>
<H2>Sample Input</H2>
<pre>
3
5
0
</pre>
<H2>Output for the Sample Input</H2>
<pre>
4 9 2
3 5 7
8 1 6
11 24 7 20 3
4 12 25 8 16
17 5 13 21 9
10 18 1 14 22
23 6 19 2 15
</pre>
|
s264356443 | p00078 | WA: Presentation Error | import sys
f = sys.stdin
def set1(sq):
x = len(sq) // 2
y = len(sq) // 2 + 1
square[y][x] = 1
return x, y, 1
def mv_r(sq, x, y):
x = (x + 1) % len(sq)
y = (y + 1) % len(sq)
return x, y
def mv_l(sq, x, y):
x -= 1
if x < 0:
x += len(sq)
y = (y + 1) % len(sq)
return x, y
def setnext(sq, x, y, i):
x, y = mv_r(sq, x,y)
i += 1
while sq[y][x]:
x, y = mv_l(sq, x, y)
sq[y][x] = i
return x, y, i
while True:
n = int(f.readline())
if n == 0:
break
square = [[None for j in range(n)] for i in range(n)]
arg = set1(square)
for i in range(n * n - 1):
arg = setnext(square,*arg)
for line in square:
print(*line) | 3
5
0
| 4 9 2
3 5 7
8 1 6
11 24 7 20 3
4 12 25 8 16
17 5 13 21 9
10 18 1 14 22
23 6 19 2 15
|
<H1>魔方陣</H1>
<p>
<var>n</var> × <var>n</var> の正方形のマス目の中に数字の１から <var>n</var> × <var>n</var> が一つずつ入っていて、縦のどの列のマス目の和も、横のどの列のマス目の和も対角線のマス目の和も等しいものを魔方陣といいます。
</p>
<p>
一辺のマスの個数が奇数の魔方陣の作り方には以下の方法があります。
</p>
<ol>
<li>中央のマス目のちょうど一つ下のマス目に１を入れる。</li>
<li>次の数字を右斜め下のマス目に入れる。<br>ただし、数字を入れようとしたマス目が正方形からはみ出している場合、すでに数字が埋まっている場合は以下の方法に従って数字を入れるマス目を探す。</li>
<ul>
<li>右にはみ出した場合には、同じ行の左はしに、左にはみ出した場合には、同じ行の右はしに、下にはみ出した場合には、同じ列の一番上に数字を入れる。
</li>
<li> 数字を入れようとしたマス目が埋まっているときには、その埋まっているマス目の左斜め下のマス目に入れる。
</li>
</ul>
<li>全てのマス目が埋まるまで２を繰り返す。
</ol>
<p>
この方法に従って、一辺のマス目の個数 <var>n</var> を入力として、その大きさの魔方陣を出力するプログラムを作成して下さい。ただし、<var>n</var> は 3 以上 15 以下の奇数とします。マス目に入る各数字は右詰 4 桁で出力してください。
</p>
<H2>入力</H2>
<p>複数の入力が与えられます。各入力で <var>n</var> （正の整数）が１行に与えられます。入力は 0 で終了します。入力の数は 10 を超えません。</p>
<H2>出力</H2>
<p>各入力に対して <var>n</var> × <var>n</var> の魔方陣を出力して下さい。</p>
<H2>Sample Input</H2>
<pre>
3
5
0
</pre>
<H2>Output for the Sample Input</H2>
<pre>
4 9 2
3 5 7
8 1 6
11 24 7 20 3
4 12 25 8 16
17 5 13 21 9
10 18 1 14 22
23 6 19 2 15
</pre>
|
s476468674 | p00078 | WA: Presentation Error | while True:
n=input()
if n==0:
break
magic=[[0 for i in range(n)] for j in range(n)]
i=n/2
j=n/2+1
for number in range(1,n*n+1):
magic[j][i]=number
if number==n*n:
break
if magic[(j+1)%n][(i+1)%n]==0:
i,j=(i+1)%n,(j+1)%n
else:
i,j=(i+1)%n,(j+1)%n
while magic[j][i]!=0:
i,j=(i-1)%n,(j+1)%n
for i in range(n):
for j in range(n):
print str(magic[i][j]).rjust(4),
print ""
| 3
5
0
| 4 9 2
3 5 7
8 1 6
11 24 7 20 3
4 12 25 8 16
17 5 13 21 9
10 18 1 14 22
23 6 19 2 15
|
<H1>魔方陣</H1>
<p>
<var>n</var> × <var>n</var> の正方形のマス目の中に数字の１から <var>n</var> × <var>n</var> が一つずつ入っていて、縦のどの列のマス目の和も、横のどの列のマス目の和も対角線のマス目の和も等しいものを魔方陣といいます。
</p>
<p>
一辺のマスの個数が奇数の魔方陣の作り方には以下の方法があります。
</p>
<ol>
<li>中央のマス目のちょうど一つ下のマス目に１を入れる。</li>
<li>次の数字を右斜め下のマス目に入れる。<br>ただし、数字を入れようとしたマス目が正方形からはみ出している場合、すでに数字が埋まっている場合は以下の方法に従って数字を入れるマス目を探す。</li>
<ul>
<li>右にはみ出した場合には、同じ行の左はしに、左にはみ出した場合には、同じ行の右はしに、下にはみ出した場合には、同じ列の一番上に数字を入れる。
</li>
<li> 数字を入れようとしたマス目が埋まっているときには、その埋まっているマス目の左斜め下のマス目に入れる。
</li>
</ul>
<li>全てのマス目が埋まるまで２を繰り返す。
</ol>
<p>
この方法に従って、一辺のマス目の個数 <var>n</var> を入力として、その大きさの魔方陣を出力するプログラムを作成して下さい。ただし、<var>n</var> は 3 以上 15 以下の奇数とします。マス目に入る各数字は右詰 4 桁で出力してください。
</p>
<H2>入力</H2>
<p>複数の入力が与えられます。各入力で <var>n</var> （正の整数）が１行に与えられます。入力は 0 で終了します。入力の数は 10 を超えません。</p>
<H2>出力</H2>
<p>各入力に対して <var>n</var> × <var>n</var> の魔方陣を出力して下さい。</p>
<H2>Sample Input</H2>
<pre>
3
5
0
</pre>
<H2>Output for the Sample Input</H2>
<pre>
4 9 2
3 5 7
8 1 6
11 24 7 20 3
4 12 25 8 16
17 5 13 21 9
10 18 1 14 22
23 6 19 2 15
</pre>
|
s860901956 | p00078 | WA: Presentation Error | while True:
n=input()
if n==0:
break
magic=[[0 for i in range(n)] for j in range(n)]
i=n/2
j=n/2+1
for number in range(1,n*n+1):
magic[j][i]=number
if number==n*n:
break
if magic[(j+1)%n][(i+1)%n]==0:
i,j=(i+1)%n,(j+1)%n
else:
i,j=(i+1)%n,(j+1)%n
while magic[j][i]!=0:
i,j=(i-1)%n,(j+1)%n
for i in range(n):
for j in range(n):
print str(magic[i][j]).rjust(3),
print ""
| 3
5
0
| 4 9 2
3 5 7
8 1 6
11 24 7 20 3
4 12 25 8 16
17 5 13 21 9
10 18 1 14 22
23 6 19 2 15
|
<H1>魔方陣</H1>
<p>
<var>n</var> × <var>n</var> の正方形のマス目の中に数字の１から <var>n</var> × <var>n</var> が一つずつ入っていて、縦のどの列のマス目の和も、横のどの列のマス目の和も対角線のマス目の和も等しいものを魔方陣といいます。
</p>
<p>
一辺のマスの個数が奇数の魔方陣の作り方には以下の方法があります。
</p>
<ol>
<li>中央のマス目のちょうど一つ下のマス目に１を入れる。</li>
<li>次の数字を右斜め下のマス目に入れる。<br>ただし、数字を入れようとしたマス目が正方形からはみ出している場合、すでに数字が埋まっている場合は以下の方法に従って数字を入れるマス目を探す。</li>
<ul>
<li>右にはみ出した場合には、同じ行の左はしに、左にはみ出した場合には、同じ行の右はしに、下にはみ出した場合には、同じ列の一番上に数字を入れる。
</li>
<li> 数字を入れようとしたマス目が埋まっているときには、その埋まっているマス目の左斜め下のマス目に入れる。
</li>
</ul>
<li>全てのマス目が埋まるまで２を繰り返す。
</ol>
<p>
この方法に従って、一辺のマス目の個数 <var>n</var> を入力として、その大きさの魔方陣を出力するプログラムを作成して下さい。ただし、<var>n</var> は 3 以上 15 以下の奇数とします。マス目に入る各数字は右詰 4 桁で出力してください。
</p>
<H2>入力</H2>
<p>複数の入力が与えられます。各入力で <var>n</var> （正の整数）が１行に与えられます。入力は 0 で終了します。入力の数は 10 を超えません。</p>
<H2>出力</H2>
<p>各入力に対して <var>n</var> × <var>n</var> の魔方陣を出力して下さい。</p>
<H2>Sample Input</H2>
<pre>
3
5
0
</pre>
<H2>Output for the Sample Input</H2>
<pre>
4 9 2
3 5 7
8 1 6
11 24 7 20 3
4 12 25 8 16
17 5 13 21 9
10 18 1 14 22
23 6 19 2 15
</pre>
|
s700423488 | p00078 | WA: Presentation Error | # -*- coding: utf-8 -*-
import sys
import os
import math
for s in sys.stdin:
n = int(s)
if n == 0:
break
M = [[None for i in range(n)] for j in range(n)]
# 1
x = n // 2
y = n // 2 + 1
M[y][x] = 1
x = x + 1
y = y + 1
counter = 2
while counter < n * n + 1:
if x >= n:
x = 0
elif x < 0:
x = n - 1
if y >= n:
y = 0
elif y < 0:
y = n - 1
if M[y][x] is not None:
x -= 1
y += 1
else:
M[y][x] = counter
counter += 1
x += 1
y += 1
for row in M:
print(*row) | 3
5
0
| 4 9 2
3 5 7
8 1 6
11 24 7 20 3
4 12 25 8 16
17 5 13 21 9
10 18 1 14 22
23 6 19 2 15
|
<H1>魔方陣</H1>
<p>
<var>n</var> × <var>n</var> の正方形のマス目の中に数字の１から <var>n</var> × <var>n</var> が一つずつ入っていて、縦のどの列のマス目の和も、横のどの列のマス目の和も対角線のマス目の和も等しいものを魔方陣といいます。
</p>
<p>
一辺のマスの個数が奇数の魔方陣の作り方には以下の方法があります。
</p>
<ol>
<li>中央のマス目のちょうど一つ下のマス目に１を入れる。</li>
<li>次の数字を右斜め下のマス目に入れる。<br>ただし、数字を入れようとしたマス目が正方形からはみ出している場合、すでに数字が埋まっている場合は以下の方法に従って数字を入れるマス目を探す。</li>
<ul>
<li>右にはみ出した場合には、同じ行の左はしに、左にはみ出した場合には、同じ行の右はしに、下にはみ出した場合には、同じ列の一番上に数字を入れる。
</li>
<li> 数字を入れようとしたマス目が埋まっているときには、その埋まっているマス目の左斜め下のマス目に入れる。
</li>
</ul>
<li>全てのマス目が埋まるまで２を繰り返す。
</ol>
<p>
この方法に従って、一辺のマス目の個数 <var>n</var> を入力として、その大きさの魔方陣を出力するプログラムを作成して下さい。ただし、<var>n</var> は 3 以上 15 以下の奇数とします。マス目に入る各数字は右詰 4 桁で出力してください。
</p>
<H2>入力</H2>
<p>複数の入力が与えられます。各入力で <var>n</var> （正の整数）が１行に与えられます。入力は 0 で終了します。入力の数は 10 を超えません。</p>
<H2>出力</H2>
<p>各入力に対して <var>n</var> × <var>n</var> の魔方陣を出力して下さい。</p>
<H2>Sample Input</H2>
<pre>
3
5
0
</pre>
<H2>Output for the Sample Input</H2>
<pre>
4 9 2
3 5 7
8 1 6
11 24 7 20 3
4 12 25 8 16
17 5 13 21 9
10 18 1 14 22
23 6 19 2 15
</pre>
|
s062696991 | p00078 | WA: Presentation Error | from sys import stdin
def sqmatrix(n):
return [[0] * n for i in range(n)]
def magicsq(m):
n = len(m)
j = int(n/2)
i = j + 1
for num in range(1, n**2 + 1):
m[i][j] = num
i += 1
j += 1
i = i%n
j = j % n
if m[i][j] != 0:
i += 1
j -= 1
if j < 0:
j = n -1
i = i % n
return m
for line in stdin:
n = int(line)
if n == 0:
break
sm = sqmatrix(n)
for row in magicsq(sm): print (' '.join(map(str,row))) | 3
5
0
| 4 9 2
3 5 7
8 1 6
11 24 7 20 3
4 12 25 8 16
17 5 13 21 9
10 18 1 14 22
23 6 19 2 15
|
<H1>魔方陣</H1>
<p>
<var>n</var> × <var>n</var> の正方形のマス目の中に数字の１から <var>n</var> × <var>n</var> が一つずつ入っていて、縦のどの列のマス目の和も、横のどの列のマス目の和も対角線のマス目の和も等しいものを魔方陣といいます。
</p>
<p>
一辺のマスの個数が奇数の魔方陣の作り方には以下の方法があります。
</p>
<ol>
<li>中央のマス目のちょうど一つ下のマス目に１を入れる。</li>
<li>次の数字を右斜め下のマス目に入れる。<br>ただし、数字を入れようとしたマス目が正方形からはみ出している場合、すでに数字が埋まっている場合は以下の方法に従って数字を入れるマス目を探す。</li>
<ul>
<li>右にはみ出した場合には、同じ行の左はしに、左にはみ出した場合には、同じ行の右はしに、下にはみ出した場合には、同じ列の一番上に数字を入れる。
</li>
<li> 数字を入れようとしたマス目が埋まっているときには、その埋まっているマス目の左斜め下のマス目に入れる。
</li>
</ul>
<li>全てのマス目が埋まるまで２を繰り返す。
</ol>
<p>
この方法に従って、一辺のマス目の個数 <var>n</var> を入力として、その大きさの魔方陣を出力するプログラムを作成して下さい。ただし、<var>n</var> は 3 以上 15 以下の奇数とします。マス目に入る各数字は右詰 4 桁で出力してください。
</p>
<H2>入力</H2>
<p>複数の入力が与えられます。各入力で <var>n</var> （正の整数）が１行に与えられます。入力は 0 で終了します。入力の数は 10 を超えません。</p>
<H2>出力</H2>
<p>各入力に対して <var>n</var> × <var>n</var> の魔方陣を出力して下さい。</p>
<H2>Sample Input</H2>
<pre>
3
5
0
</pre>
<H2>Output for the Sample Input</H2>
<pre>
4 9 2
3 5 7
8 1 6
11 24 7 20 3
4 12 25 8 16
17 5 13 21 9
10 18 1 14 22
23 6 19 2 15
</pre>
|
s166960124 | p00078 | WA: Presentation Error | # -*- coding: utf-8 -*-
"""
http://judge.u-aizu.ac.jp/onlinejudge/description.jsp?id=0078
"""
import sys
class MagicSquare():
def __init__(self, size):
self.size = size
self.data = [['@']*self.size for _ in range(self.size)]
self.fill_data()
def fill_data(self):
num = 1
x = self.size // 2
y = x + 1
self.data[y][x] = num
while num < self.size**2:
x += 1
if x >= self.size:
x = 0
y += 1
if y >= self.size:
y = 0
if self.data[y][x] == '@':
num += 1
self.data[y][x] = num
else:
while self.data[y][x] != '@':
x -= 1
if x < 0:
x = self.size - 1
y += 1
if y >= self.size:
y = 0
num += 1
self.data[y][x] = num
def print_data(self):
digits = len(str(self.size**2))
for row in self.data:
print(*row)
def main(args):
while True:
size = int(input())
if size < 3 or size%2 == 0:
break
ms = MagicSquare(size)
ms.print_data()
if __name__ == '__main__':
main(sys.argv[1:]) | 3
5
0
| 4 9 2
3 5 7
8 1 6
11 24 7 20 3
4 12 25 8 16
17 5 13 21 9
10 18 1 14 22
23 6 19 2 15
|
<H1>魔方陣</H1>
<p>
<var>n</var> × <var>n</var> の正方形のマス目の中に数字の１から <var>n</var> × <var>n</var> が一つずつ入っていて、縦のどの列のマス目の和も、横のどの列のマス目の和も対角線のマス目の和も等しいものを魔方陣といいます。
</p>
<p>
一辺のマスの個数が奇数の魔方陣の作り方には以下の方法があります。
</p>
<ol>
<li>中央のマス目のちょうど一つ下のマス目に１を入れる。</li>
<li>次の数字を右斜め下のマス目に入れる。<br>ただし、数字を入れようとしたマス目が正方形からはみ出している場合、すでに数字が埋まっている場合は以下の方法に従って数字を入れるマス目を探す。</li>
<ul>
<li>右にはみ出した場合には、同じ行の左はしに、左にはみ出した場合には、同じ行の右はしに、下にはみ出した場合には、同じ列の一番上に数字を入れる。
</li>
<li> 数字を入れようとしたマス目が埋まっているときには、その埋まっているマス目の左斜め下のマス目に入れる。
</li>
</ul>
<li>全てのマス目が埋まるまで２を繰り返す。
</ol>
<p>
この方法に従って、一辺のマス目の個数 <var>n</var> を入力として、その大きさの魔方陣を出力するプログラムを作成して下さい。ただし、<var>n</var> は 3 以上 15 以下の奇数とします。マス目に入る各数字は右詰 4 桁で出力してください。
</p>
<H2>入力</H2>
<p>複数の入力が与えられます。各入力で <var>n</var> （正の整数）が１行に与えられます。入力は 0 で終了します。入力の数は 10 を超えません。</p>
<H2>出力</H2>
<p>各入力に対して <var>n</var> × <var>n</var> の魔方陣を出力して下さい。</p>
<H2>Sample Input</H2>
<pre>
3
5
0
</pre>
<H2>Output for the Sample Input</H2>
<pre>
4 9 2
3 5 7
8 1 6
11 24 7 20 3
4 12 25 8 16
17 5 13 21 9
10 18 1 14 22
23 6 19 2 15
</pre>
|
s540506982 | p00078 | WA: Presentation Error | for e in iter(input,'0'):
n=int(e);m=[[0]*n for _ in[0]*n]
j=n//2;i=j+1
m[i][j]=1
for k in range(2,n*n+1):
i,j=-~i%n,-~j%n
if m[i][j]:i,j=-~i%n,~-j%n
m[i][j]=k
for r in m:print(' '.join(map(str,r)))
| 3
5
0
| 4 9 2
3 5 7
8 1 6
11 24 7 20 3
4 12 25 8 16
17 5 13 21 9
10 18 1 14 22
23 6 19 2 15
|
<H1>魔方陣</H1>
<p>
<var>n</var> × <var>n</var> の正方形のマス目の中に数字の１から <var>n</var> × <var>n</var> が一つずつ入っていて、縦のどの列のマス目の和も、横のどの列のマス目の和も対角線のマス目の和も等しいものを魔方陣といいます。
</p>
<p>
一辺のマスの個数が奇数の魔方陣の作り方には以下の方法があります。
</p>
<ol>
<li>中央のマス目のちょうど一つ下のマス目に１を入れる。</li>
<li>次の数字を右斜め下のマス目に入れる。<br>ただし、数字を入れようとしたマス目が正方形からはみ出している場合、すでに数字が埋まっている場合は以下の方法に従って数字を入れるマス目を探す。</li>
<ul>
<li>右にはみ出した場合には、同じ行の左はしに、左にはみ出した場合には、同じ行の右はしに、下にはみ出した場合には、同じ列の一番上に数字を入れる。
</li>
<li> 数字を入れようとしたマス目が埋まっているときには、その埋まっているマス目の左斜め下のマス目に入れる。
</li>
</ul>
<li>全てのマス目が埋まるまで２を繰り返す。
</ol>
<p>
この方法に従って、一辺のマス目の個数 <var>n</var> を入力として、その大きさの魔方陣を出力するプログラムを作成して下さい。ただし、<var>n</var> は 3 以上 15 以下の奇数とします。マス目に入る各数字は右詰 4 桁で出力してください。
</p>
<H2>入力</H2>
<p>複数の入力が与えられます。各入力で <var>n</var> （正の整数）が１行に与えられます。入力は 0 で終了します。入力の数は 10 を超えません。</p>
<H2>出力</H2>
<p>各入力に対して <var>n</var> × <var>n</var> の魔方陣を出力して下さい。</p>
<H2>Sample Input</H2>
<pre>
3
5
0
</pre>
<H2>Output for the Sample Input</H2>
<pre>
4 9 2
3 5 7
8 1 6
11 24 7 20 3
4 12 25 8 16
17 5 13 21 9
10 18 1 14 22
23 6 19 2 15
</pre>
|
s881077960 | p00078 | WA: Presentation Error | ans = []
while True:
n = input()
if n == 0:
break
c = 1
N = n*n
circle = [0]*N
p = (N+1)/2-1
while c <= N:
if p == N:
p = 1
elif p % n == 0:
p += 1
elif p+n > N:
p -= (N-n-1)
else:
p += n+1
if circle[p-1] != 0:
while circle[p-1] != 0:
if p == N-n+1:
p = n
elif p-1 % n == 0:
p += (n*2 -1)
elif p+n > N:
p -= N - n + 1
else:
p += n-1
circle[p-1] = c
c += 1
p = 0
temp = ''
while p*n != N:
temp += ''.join(map(str,circle[n*p:n*(p+1)]))
temp += '\n'
p += 1
ans.append(temp)
for i in ans:
print i | 3
5
0
| 4 9 2
3 5 7
8 1 6
11 24 7 20 3
4 12 25 8 16
17 5 13 21 9
10 18 1 14 22
23 6 19 2 15
|
<H1>魔方陣</H1>
<p>
<var>n</var> × <var>n</var> の正方形のマス目の中に数字の１から <var>n</var> × <var>n</var> が一つずつ入っていて、縦のどの列のマス目の和も、横のどの列のマス目の和も対角線のマス目の和も等しいものを魔方陣といいます。
</p>
<p>
一辺のマスの個数が奇数の魔方陣の作り方には以下の方法があります。
</p>
<ol>
<li>中央のマス目のちょうど一つ下のマス目に１を入れる。</li>
<li>次の数字を右斜め下のマス目に入れる。<br>ただし、数字を入れようとしたマス目が正方形からはみ出している場合、すでに数字が埋まっている場合は以下の方法に従って数字を入れるマス目を探す。</li>
<ul>
<li>右にはみ出した場合には、同じ行の左はしに、左にはみ出した場合には、同じ行の右はしに、下にはみ出した場合には、同じ列の一番上に数字を入れる。
</li>
<li> 数字を入れようとしたマス目が埋まっているときには、その埋まっているマス目の左斜め下のマス目に入れる。
</li>
</ul>
<li>全てのマス目が埋まるまで２を繰り返す。
</ol>
<p>
この方法に従って、一辺のマス目の個数 <var>n</var> を入力として、その大きさの魔方陣を出力するプログラムを作成して下さい。ただし、<var>n</var> は 3 以上 15 以下の奇数とします。マス目に入る各数字は右詰 4 桁で出力してください。
</p>
<H2>入力</H2>
<p>複数の入力が与えられます。各入力で <var>n</var> （正の整数）が１行に与えられます。入力は 0 で終了します。入力の数は 10 を超えません。</p>
<H2>出力</H2>
<p>各入力に対して <var>n</var> × <var>n</var> の魔方陣を出力して下さい。</p>
<H2>Sample Input</H2>
<pre>
3
5
0
</pre>
<H2>Output for the Sample Input</H2>
<pre>
4 9 2
3 5 7
8 1 6
11 24 7 20 3
4 12 25 8 16
17 5 13 21 9
10 18 1 14 22
23 6 19 2 15
</pre>
|
s024825445 | p00078 | WA: Presentation Error | ans = []
while True:
n = input()
if n == 0:
break
c = 1
N = n*n
circle = [0]*N
p = (N+1)/2-1
while c <= N:
if p == N:
p = 1
elif p % n == 0:
p += 1
elif p+n > N:
p -= (N-n-1)
else:
p += n+1
if circle[p-1] != 0:
while circle[p-1] != 0:
if p == N-n+1:
p = n
elif p-1 % n == 0:
p += (n*2 -1)
elif p+n > N:
p -= N - n + 1
else:
p += n-1
circle[p-1] = c
c += 1
p = 0
temp = ''
while p*n != N:
temp += ''.join(map(lambda x:str(x).rjust(4),circle[n*p:n*(p+1)]))
temp += '\n'
p += 1
ans.append(temp)
for i in ans:
print i | 3
5
0
| 4 9 2
3 5 7
8 1 6
11 24 7 20 3
4 12 25 8 16
17 5 13 21 9
10 18 1 14 22
23 6 19 2 15
|
<H1>魔方陣</H1>
<p>
<var>n</var> × <var>n</var> の正方形のマス目の中に数字の１から <var>n</var> × <var>n</var> が一つずつ入っていて、縦のどの列のマス目の和も、横のどの列のマス目の和も対角線のマス目の和も等しいものを魔方陣といいます。
</p>
<p>
一辺のマスの個数が奇数の魔方陣の作り方には以下の方法があります。
</p>
<ol>
<li>中央のマス目のちょうど一つ下のマス目に１を入れる。</li>
<li>次の数字を右斜め下のマス目に入れる。<br>ただし、数字を入れようとしたマス目が正方形からはみ出している場合、すでに数字が埋まっている場合は以下の方法に従って数字を入れるマス目を探す。</li>
<ul>
<li>右にはみ出した場合には、同じ行の左はしに、左にはみ出した場合には、同じ行の右はしに、下にはみ出した場合には、同じ列の一番上に数字を入れる。
</li>
<li> 数字を入れようとしたマス目が埋まっているときには、その埋まっているマス目の左斜め下のマス目に入れる。
</li>
</ul>
<li>全てのマス目が埋まるまで２を繰り返す。
</ol>
<p>
この方法に従って、一辺のマス目の個数 <var>n</var> を入力として、その大きさの魔方陣を出力するプログラムを作成して下さい。ただし、<var>n</var> は 3 以上 15 以下の奇数とします。マス目に入る各数字は右詰 4 桁で出力してください。
</p>
<H2>入力</H2>
<p>複数の入力が与えられます。各入力で <var>n</var> （正の整数）が１行に与えられます。入力は 0 で終了します。入力の数は 10 を超えません。</p>
<H2>出力</H2>
<p>各入力に対して <var>n</var> × <var>n</var> の魔方陣を出力して下さい。</p>
<H2>Sample Input</H2>
<pre>
3
5
0
</pre>
<H2>Output for the Sample Input</H2>
<pre>
4 9 2
3 5 7
8 1 6
11 24 7 20 3
4 12 25 8 16
17 5 13 21 9
10 18 1 14 22
23 6 19 2 15
</pre>
|
s125888150 | p00078 | WA: Presentation Error | while True:
n=input()
if n==0:
break
board=[[0]*n for unused in xrange(n)]
y,x=n/2+1,n/2
board[y][x]=1
for i in xrange(2,n*n+1):
ny,nx=(y+1)%n,(x+1)%n
while True:
if board[ny][nx]==0:
y,x=ny,nx
break
else:
ny,nx=(ny+1)%n,(nx+n-1)%n
board[y][x]=i
for i in xrange(n):
for j in xrange(n):
print board[i][j],
print | 3
5
0
| 4 9 2
3 5 7
8 1 6
11 24 7 20 3
4 12 25 8 16
17 5 13 21 9
10 18 1 14 22
23 6 19 2 15
|
<H1>魔方陣</H1>
<p>
<var>n</var> × <var>n</var> の正方形のマス目の中に数字の１から <var>n</var> × <var>n</var> が一つずつ入っていて、縦のどの列のマス目の和も、横のどの列のマス目の和も対角線のマス目の和も等しいものを魔方陣といいます。
</p>
<p>
一辺のマスの個数が奇数の魔方陣の作り方には以下の方法があります。
</p>
<ol>
<li>中央のマス目のちょうど一つ下のマス目に１を入れる。</li>
<li>次の数字を右斜め下のマス目に入れる。<br>ただし、数字を入れようとしたマス目が正方形からはみ出している場合、すでに数字が埋まっている場合は以下の方法に従って数字を入れるマス目を探す。</li>
<ul>
<li>右にはみ出した場合には、同じ行の左はしに、左にはみ出した場合には、同じ行の右はしに、下にはみ出した場合には、同じ列の一番上に数字を入れる。
</li>
<li> 数字を入れようとしたマス目が埋まっているときには、その埋まっているマス目の左斜め下のマス目に入れる。
</li>
</ul>
<li>全てのマス目が埋まるまで２を繰り返す。
</ol>
<p>
この方法に従って、一辺のマス目の個数 <var>n</var> を入力として、その大きさの魔方陣を出力するプログラムを作成して下さい。ただし、<var>n</var> は 3 以上 15 以下の奇数とします。マス目に入る各数字は右詰 4 桁で出力してください。
</p>
<H2>入力</H2>
<p>複数の入力が与えられます。各入力で <var>n</var> （正の整数）が１行に与えられます。入力は 0 で終了します。入力の数は 10 を超えません。</p>
<H2>出力</H2>
<p>各入力に対して <var>n</var> × <var>n</var> の魔方陣を出力して下さい。</p>
<H2>Sample Input</H2>
<pre>
3
5
0
</pre>
<H2>Output for the Sample Input</H2>
<pre>
4 9 2
3 5 7
8 1 6
11 24 7 20 3
4 12 25 8 16
17 5 13 21 9
10 18 1 14 22
23 6 19 2 15
</pre>
|
s453327744 | p00078 | WA: Presentation Error | while True:
n=input()
if n==0:
break
board=[[0]*n for unused in xrange(n)]
y,x=n/2+1,n/2
board[y][x]=1
for i in xrange(2,n*n+1):
ny,nx=(y+1)%n,(x+1)%n
while True:
if board[ny][nx]==0:
y,x=ny,nx
break
else:
ny,nx=(ny+1)%n,(nx+n-1)%n
board[y][x]=i
for i in xrange(n):
for j in xrange(n):
print str(board[i][j]).rjust(4),
print | 3
5
0
| 4 9 2
3 5 7
8 1 6
11 24 7 20 3
4 12 25 8 16
17 5 13 21 9
10 18 1 14 22
23 6 19 2 15
|
<H1>魔方陣</H1>
<p>
<var>n</var> × <var>n</var> の正方形のマス目の中に数字の１から <var>n</var> × <var>n</var> が一つずつ入っていて、縦のどの列のマス目の和も、横のどの列のマス目の和も対角線のマス目の和も等しいものを魔方陣といいます。
</p>
<p>
一辺のマスの個数が奇数の魔方陣の作り方には以下の方法があります。
</p>
<ol>
<li>中央のマス目のちょうど一つ下のマス目に１を入れる。</li>
<li>次の数字を右斜め下のマス目に入れる。<br>ただし、数字を入れようとしたマス目が正方形からはみ出している場合、すでに数字が埋まっている場合は以下の方法に従って数字を入れるマス目を探す。</li>
<ul>
<li>右にはみ出した場合には、同じ行の左はしに、左にはみ出した場合には、同じ行の右はしに、下にはみ出した場合には、同じ列の一番上に数字を入れる。
</li>
<li> 数字を入れようとしたマス目が埋まっているときには、その埋まっているマス目の左斜め下のマス目に入れる。
</li>
</ul>
<li>全てのマス目が埋まるまで２を繰り返す。
</ol>
<p>
この方法に従って、一辺のマス目の個数 <var>n</var> を入力として、その大きさの魔方陣を出力するプログラムを作成して下さい。ただし、<var>n</var> は 3 以上 15 以下の奇数とします。マス目に入る各数字は右詰 4 桁で出力してください。
</p>
<H2>入力</H2>
<p>複数の入力が与えられます。各入力で <var>n</var> （正の整数）が１行に与えられます。入力は 0 で終了します。入力の数は 10 を超えません。</p>
<H2>出力</H2>
<p>各入力に対して <var>n</var> × <var>n</var> の魔方陣を出力して下さい。</p>
<H2>Sample Input</H2>
<pre>
3
5
0
</pre>
<H2>Output for the Sample Input</H2>
<pre>
4 9 2
3 5 7
8 1 6
11 24 7 20 3
4 12 25 8 16
17 5 13 21 9
10 18 1 14 22
23 6 19 2 15
</pre>
|
s513226684 | p00079 | Wrong Answer | x,y,r,l,s=[],[],[],[],[]
while 1:
try:
a,b=map(float,raw_input().split(','))
x.append(a)
y.append(b)
except:
break
for i in range(len(x)-1):
r.append(((x[i+1]-x[0])**2+(y[i+1]-y[0])**2)**0.5)
for i in range(1,len(x)-1):
l.append(((x[i+1]-x[i])**2+(y[i+1]-y[i])**2)**0.5)
for i in range(len(x)-2):
s.append((r[i]+r[i+1]+l[i])/2)
sum=0.0
for i in range(len(x)-2):
sum+=(s[i]*(s[i]-r[i])*(s[i]-r[i+1])*(s[i]-l[i]))
print sum | 0.0,0.0
0.0,1.0
1.0,1.0
2.0,0.0
1.0,-1.0
| 2.500000
|
<H1>凸 <var>n</var> 角形の面積</H1>
<p>
凸 <var>n</var> 角形（すべての頂点の内角が 180 度未満である多角形、要するにへこんでいない多角形のこと）の頂点の座標を読んで、その面積を出力するプログラムを作成してください。頂点には辺のつながりの順序に従って頂点 1、頂点 2、頂点 3、‥‥頂点 <var>n</var> という名前がついています。
</p>
<p>
ただし、 <var>n</var> は 3 以上 20 以下とします。また、次の、三角形の 3 辺の長さ <var>a, b, c</var> から面積 <var>S</var> を求める公式を使ってもかまいません。
</p>
<center>
<img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_07">
</center>
<br/>
<H2>入力</H2>
<p>
入力は以下の形式で与えられます。
</p>
<pre>
<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>x<sub>i</sub></var>, <var>y<sub>i</sub></var> はそれぞれ頂点 <var>i</var> の <var>x</var> 座標, <var>y</var> 座標を表す実数です。
</p>
<H2>出力</H2>
<p>
面積 <var>S</var> （実数）を１行に出力します。
出力は 0.000001 以下の誤差を含んでもかまいません。
</p>
<H2>Sample Input</H2>
<pre>
0.0,0.0
0.0,1.0
1.0,1.0
2.0,0.0
1.0,-1.0
</pre>
<H2>Output for the Sample Input</H2>
<pre>
2.500000
</pre>
|
s967668989 | p00079 | Wrong Answer | #!/usr/bin/env python
# -*- coding: UTF-8 -*-
t=[]
while 1:
try:
x,y=map(float,raw_input().split(','))
t.append((x,y))
except:
break
t.sort()
ans=0
for i in range(len(t)-2):
a=t[i+1][0]-t[i][0]
b=t[i+1][1]-t[i][1]
c=t[i+2][0]-t[i][0]
d=t[i+2][1]-t[i][1]
ans+=abs(a*d-b*c)/2.0
print ans | 0.0,0.0
0.0,1.0
1.0,1.0
2.0,0.0
1.0,-1.0
| 2.500000
|
<H1>凸 <var>n</var> 角形の面積</H1>
<p>
凸 <var>n</var> 角形（すべての頂点の内角が 180 度未満である多角形、要するにへこんでいない多角形のこと）の頂点の座標を読んで、その面積を出力するプログラムを作成してください。頂点には辺のつながりの順序に従って頂点 1、頂点 2、頂点 3、‥‥頂点 <var>n</var> という名前がついています。
</p>
<p>
ただし、 <var>n</var> は 3 以上 20 以下とします。また、次の、三角形の 3 辺の長さ <var>a, b, c</var> から面積 <var>S</var> を求める公式を使ってもかまいません。
</p>
<center>
<img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_07">
</center>
<br/>
<H2>入力</H2>
<p>
入力は以下の形式で与えられます。
</p>
<pre>
<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>x<sub>i</sub></var>, <var>y<sub>i</sub></var> はそれぞれ頂点 <var>i</var> の <var>x</var> 座標, <var>y</var> 座標を表す実数です。
</p>
<H2>出力</H2>
<p>
面積 <var>S</var> （実数）を１行に出力します。
出力は 0.000001 以下の誤差を含んでもかまいません。
</p>
<H2>Sample Input</H2>
<pre>
0.0,0.0
0.0,1.0
1.0,1.0
2.0,0.0
1.0,-1.0
</pre>
<H2>Output for the Sample Input</H2>
<pre>
2.500000
</pre>
|
s618370389 | p00079 | Wrong Answer | import math
f = []
while True:
try:
st = input().strip().split(',')
print("st=",st)
x,y = list(map(float,st ))
f.append(x + y*1j)
except EOFError:
break
px = [p.real for p in f]
ox = (max(px) + min(px)) / 2.0
py = [p.imag for p in f]
oy = (max(py) + min(py)) / 2.0
fo = ox + oy * 1j
ss = 0.0
for i in range(len(f)):
if i == len(f)-1:
j = 0
else:
j = i + 1
a = abs(f[i]-fo)
b = abs(f[j]-fo)
c = abs(f[j]-f[i])
z = (a + b + c) / 2.0
s = math.sqrt(z*(z-a)*(z-b)*(z-c))
ss += s
print(ss) | 0.0,0.0
0.0,1.0
1.0,1.0
2.0,0.0
1.0,-1.0
| 2.500000
|
<H1>凸 <var>n</var> 角形の面積</H1>
<p>
凸 <var>n</var> 角形（すべての頂点の内角が 180 度未満である多角形、要するにへこんでいない多角形のこと）の頂点の座標を読んで、その面積を出力するプログラムを作成してください。頂点には辺のつながりの順序に従って頂点 1、頂点 2、頂点 3、‥‥頂点 <var>n</var> という名前がついています。
</p>
<p>
ただし、 <var>n</var> は 3 以上 20 以下とします。また、次の、三角形の 3 辺の長さ <var>a, b, c</var> から面積 <var>S</var> を求める公式を使ってもかまいません。
</p>
<center>
<img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_07">
</center>
<br/>
<H2>入力</H2>
<p>
入力は以下の形式で与えられます。
</p>
<pre>
<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>x<sub>i</sub></var>, <var>y<sub>i</sub></var> はそれぞれ頂点 <var>i</var> の <var>x</var> 座標, <var>y</var> 座標を表す実数です。
</p>
<H2>出力</H2>
<p>
面積 <var>S</var> （実数）を１行に出力します。
出力は 0.000001 以下の誤差を含んでもかまいません。
</p>
<H2>Sample Input</H2>
<pre>
0.0,0.0
0.0,1.0
1.0,1.0
2.0,0.0
1.0,-1.0
</pre>
<H2>Output for the Sample Input</H2>
<pre>
2.500000
</pre>
|
s635572895 | p00079 | Wrong Answer | import sys
s=0
p=[list(map(float,e.split(',')))for e in sys.stdin]
x,y=p[0]
for i in range(len(p)-2):
a,b=p[i+1];c,d=p[i+2]
s-=((a-x)*(d-y)-(b-y)*(c-x))/2
print(s)
| 0.0,0.0
0.0,1.0
1.0,1.0
2.0,0.0
1.0,-1.0
| 2.500000
|
<H1>凸 <var>n</var> 角形の面積</H1>
<p>
凸 <var>n</var> 角形（すべての頂点の内角が 180 度未満である多角形、要するにへこんでいない多角形のこと）の頂点の座標を読んで、その面積を出力するプログラムを作成してください。頂点には辺のつながりの順序に従って頂点 1、頂点 2、頂点 3、‥‥頂点 <var>n</var> という名前がついています。
</p>
<p>
ただし、 <var>n</var> は 3 以上 20 以下とします。また、次の、三角形の 3 辺の長さ <var>a, b, c</var> から面積 <var>S</var> を求める公式を使ってもかまいません。
</p>
<center>
<img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_07">
</center>
<br/>
<H2>入力</H2>
<p>
入力は以下の形式で与えられます。
</p>
<pre>
<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>x<sub>i</sub></var>, <var>y<sub>i</sub></var> はそれぞれ頂点 <var>i</var> の <var>x</var> 座標, <var>y</var> 座標を表す実数です。
</p>
<H2>出力</H2>
<p>
面積 <var>S</var> （実数）を１行に出力します。
出力は 0.000001 以下の誤差を含んでもかまいません。
</p>
<H2>Sample Input</H2>
<pre>
0.0,0.0
0.0,1.0
1.0,1.0
2.0,0.0
1.0,-1.0
</pre>
<H2>Output for the Sample Input</H2>
<pre>
2.500000
</pre>
|
s875952050 | p00079 | Wrong Answer | import sys
s=0
p=[list(map(float,e.split(',')))for e in sys.stdin];n=len(p)
for i in range(n):a,b=p[i];c,d=p[-~i%n];s+=a*d-b*c
print(-s/2)
| 0.0,0.0
0.0,1.0
1.0,1.0
2.0,0.0
1.0,-1.0
| 2.500000
|
<H1>凸 <var>n</var> 角形の面積</H1>
<p>
凸 <var>n</var> 角形（すべての頂点の内角が 180 度未満である多角形、要するにへこんでいない多角形のこと）の頂点の座標を読んで、その面積を出力するプログラムを作成してください。頂点には辺のつながりの順序に従って頂点 1、頂点 2、頂点 3、‥‥頂点 <var>n</var> という名前がついています。
</p>
<p>
ただし、 <var>n</var> は 3 以上 20 以下とします。また、次の、三角形の 3 辺の長さ <var>a, b, c</var> から面積 <var>S</var> を求める公式を使ってもかまいません。
</p>
<center>
<img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_07">
</center>
<br/>
<H2>入力</H2>
<p>
入力は以下の形式で与えられます。
</p>
<pre>
<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>x<sub>i</sub></var>, <var>y<sub>i</sub></var> はそれぞれ頂点 <var>i</var> の <var>x</var> 座標, <var>y</var> 座標を表す実数です。
</p>
<H2>出力</H2>
<p>
面積 <var>S</var> （実数）を１行に出力します。
出力は 0.000001 以下の誤差を含んでもかまいません。
</p>
<H2>Sample Input</H2>
<pre>
0.0,0.0
0.0,1.0
1.0,1.0
2.0,0.0
1.0,-1.0
</pre>
<H2>Output for the Sample Input</H2>
<pre>
2.500000
</pre>
|
s807002638 | p00079 | Wrong Answer | import sys,math
l=[list(map(float,i.split(","))) for i in sys.stdin]
S=0
for (i,j) in enumerate(l[:-1]):
xn,yn=j
xn_1,yn_1=l[i+1]
a=math.sqrt(xn**2+yn**2)
b=math.sqrt(xn_1**2+yn_1**2)
c=math.sqrt((xn_1-xn)**2+(yn_1-yn)**2)
z=(a+b+c)/2
S+=math.sqrt(z*(z-a)*(z-b)*(z-c))
print(S)
| 0.0,0.0
0.0,1.0
1.0,1.0
2.0,0.0
1.0,-1.0
| 2.500000
|
<H1>凸 <var>n</var> 角形の面積</H1>
<p>
凸 <var>n</var> 角形（すべての頂点の内角が 180 度未満である多角形、要するにへこんでいない多角形のこと）の頂点の座標を読んで、その面積を出力するプログラムを作成してください。頂点には辺のつながりの順序に従って頂点 1、頂点 2、頂点 3、‥‥頂点 <var>n</var> という名前がついています。
</p>
<p>
ただし、 <var>n</var> は 3 以上 20 以下とします。また、次の、三角形の 3 辺の長さ <var>a, b, c</var> から面積 <var>S</var> を求める公式を使ってもかまいません。
</p>
<center>
<img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_07">
</center>
<br/>
<H2>入力</H2>
<p>
入力は以下の形式で与えられます。
</p>
<pre>
<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>x<sub>i</sub></var>, <var>y<sub>i</sub></var> はそれぞれ頂点 <var>i</var> の <var>x</var> 座標, <var>y</var> 座標を表す実数です。
</p>
<H2>出力</H2>
<p>
面積 <var>S</var> （実数）を１行に出力します。
出力は 0.000001 以下の誤差を含んでもかまいません。
</p>
<H2>Sample Input</H2>
<pre>
0.0,0.0
0.0,1.0
1.0,1.0
2.0,0.0
1.0,-1.0
</pre>
<H2>Output for the Sample Input</H2>
<pre>
2.500000
</pre>
|
s252980094 | p00079 | Wrong Answer | import sys
x0,y0=map(float,raw_input()[:-1].split(","))
x1,y1=map(float,raw_input()[:-1].split(","))
s=0
for e in sys.stdin:
ex,ey=map(float,e[:-1].split(","))
x2,y2=ex-x0,ey-y0
s+=abs(x1*y2-x2*y1)
x1,y1=x2,y2
print s/2 | 0.0,0.0
0.0,1.0
1.0,1.0
2.0,0.0
1.0,-1.0
| 2.500000
|
<H1>凸 <var>n</var> 角形の面積</H1>
<p>
凸 <var>n</var> 角形（すべての頂点の内角が 180 度未満である多角形、要するにへこんでいない多角形のこと）の頂点の座標を読んで、その面積を出力するプログラムを作成してください。頂点には辺のつながりの順序に従って頂点 1、頂点 2、頂点 3、‥‥頂点 <var>n</var> という名前がついています。
</p>
<p>
ただし、 <var>n</var> は 3 以上 20 以下とします。また、次の、三角形の 3 辺の長さ <var>a, b, c</var> から面積 <var>S</var> を求める公式を使ってもかまいません。
</p>
<center>
<img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_07">
</center>
<br/>
<H2>入力</H2>
<p>
入力は以下の形式で与えられます。
</p>
<pre>
<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>x<sub>i</sub></var>, <var>y<sub>i</sub></var> はそれぞれ頂点 <var>i</var> の <var>x</var> 座標, <var>y</var> 座標を表す実数です。
</p>
<H2>出力</H2>
<p>
面積 <var>S</var> （実数）を１行に出力します。
出力は 0.000001 以下の誤差を含んでもかまいません。
</p>
<H2>Sample Input</H2>
<pre>
0.0,0.0
0.0,1.0
1.0,1.0
2.0,0.0
1.0,-1.0
</pre>
<H2>Output for the Sample Input</H2>
<pre>
2.500000
</pre>
|
s270013891 | p00079 | Wrong Answer | import sys
x=[map(float,s[:-1].split(",")) for s in sys.stdin]
s=[x[i][0]*x[i+1][1]-x[i][1]*x[i+1][0] for i in range(len(x)-1)]
print abs(sum(s))/2 | 0.0,0.0
0.0,1.0
1.0,1.0
2.0,0.0
1.0,-1.0
| 2.500000
|
<H1>凸 <var>n</var> 角形の面積</H1>
<p>
凸 <var>n</var> 角形（すべての頂点の内角が 180 度未満である多角形、要するにへこんでいない多角形のこと）の頂点の座標を読んで、その面積を出力するプログラムを作成してください。頂点には辺のつながりの順序に従って頂点 1、頂点 2、頂点 3、‥‥頂点 <var>n</var> という名前がついています。
</p>
<p>
ただし、 <var>n</var> は 3 以上 20 以下とします。また、次の、三角形の 3 辺の長さ <var>a, b, c</var> から面積 <var>S</var> を求める公式を使ってもかまいません。
</p>
<center>
<img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_07">
</center>
<br/>
<H2>入力</H2>
<p>
入力は以下の形式で与えられます。
</p>
<pre>
<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>x<sub>i</sub></var>, <var>y<sub>i</sub></var> はそれぞれ頂点 <var>i</var> の <var>x</var> 座標, <var>y</var> 座標を表す実数です。
</p>
<H2>出力</H2>
<p>
面積 <var>S</var> （実数）を１行に出力します。
出力は 0.000001 以下の誤差を含んでもかまいません。
</p>
<H2>Sample Input</H2>
<pre>
0.0,0.0
0.0,1.0
1.0,1.0
2.0,0.0
1.0,-1.0
</pre>
<H2>Output for the Sample Input</H2>
<pre>
2.500000
</pre>
|
s658345103 | p00079 | Wrong Answer | from math import hypot
polygon = []
while 1:
try:
x, y = map(float, raw_input().split(','))
polygon.append((x, y))
except EOFError:
break
A = polygon[0]
B = polygon[0]
ret = 0.0
for i in xrange(2, len(polygon)):
C = polygon[i]
a = hypot(A[0] - B[0], A[1] - B[1])
b = hypot(A[0] - C[0], A[1] - C[1])
c = hypot(C[0] - B[0], C[1] - B[1])
z = (a + b + c) / 2
S = (z * (z - a) * (z - b) * (z - c)) ** 0.5
ret += S
print S | 0.0,0.0
0.0,1.0
1.0,1.0
2.0,0.0
1.0,-1.0
| 2.500000
|
<H1>凸 <var>n</var> 角形の面積</H1>
<p>
凸 <var>n</var> 角形（すべての頂点の内角が 180 度未満である多角形、要するにへこんでいない多角形のこと）の頂点の座標を読んで、その面積を出力するプログラムを作成してください。頂点には辺のつながりの順序に従って頂点 1、頂点 2、頂点 3、‥‥頂点 <var>n</var> という名前がついています。
</p>
<p>
ただし、 <var>n</var> は 3 以上 20 以下とします。また、次の、三角形の 3 辺の長さ <var>a, b, c</var> から面積 <var>S</var> を求める公式を使ってもかまいません。
</p>
<center>
<img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_07">
</center>
<br/>
<H2>入力</H2>
<p>
入力は以下の形式で与えられます。
</p>
<pre>
<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>x<sub>i</sub></var>, <var>y<sub>i</sub></var> はそれぞれ頂点 <var>i</var> の <var>x</var> 座標, <var>y</var> 座標を表す実数です。
</p>
<H2>出力</H2>
<p>
面積 <var>S</var> （実数）を１行に出力します。
出力は 0.000001 以下の誤差を含んでもかまいません。
</p>
<H2>Sample Input</H2>
<pre>
0.0,0.0
0.0,1.0
1.0,1.0
2.0,0.0
1.0,-1.0
</pre>
<H2>Output for the Sample Input</H2>
<pre>
2.500000
</pre>
|
s894553549 | p00079 | Wrong Answer | from math import hypot
polygon = []
for i in xrange(5):
try:
x, y = map(float, raw_input().split(','))
polygon.append((x, y))
except EOFError:
break
polygon.sort()
A = polygon[0]
ret = 0.0
for i in xrange(1, len(polygon) - 1):
B = polygon[i]
C = polygon[i + 1]
a = hypot(A[0] - B[0], A[1] - B[1])
b = hypot(A[0] - C[0], A[1] - C[1])
c = hypot(C[0] - B[0], C[1] - B[1])
z = (a + b + c) / 2
S = (z * (z - a) * (z - b) * (z - c)) ** 0.5
ret += S
print ret | 0.0,0.0
0.0,1.0
1.0,1.0
2.0,0.0
1.0,-1.0
| 2.500000
|
<H1>凸 <var>n</var> 角形の面積</H1>
<p>
凸 <var>n</var> 角形（すべての頂点の内角が 180 度未満である多角形、要するにへこんでいない多角形のこと）の頂点の座標を読んで、その面積を出力するプログラムを作成してください。頂点には辺のつながりの順序に従って頂点 1、頂点 2、頂点 3、‥‥頂点 <var>n</var> という名前がついています。
</p>
<p>
ただし、 <var>n</var> は 3 以上 20 以下とします。また、次の、三角形の 3 辺の長さ <var>a, b, c</var> から面積 <var>S</var> を求める公式を使ってもかまいません。
</p>
<center>
<img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_07">
</center>
<br/>
<H2>入力</H2>
<p>
入力は以下の形式で与えられます。
</p>
<pre>
<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>x<sub>i</sub></var>, <var>y<sub>i</sub></var> はそれぞれ頂点 <var>i</var> の <var>x</var> 座標, <var>y</var> 座標を表す実数です。
</p>
<H2>出力</H2>
<p>
面積 <var>S</var> （実数）を１行に出力します。
出力は 0.000001 以下の誤差を含んでもかまいません。
</p>
<H2>Sample Input</H2>
<pre>
0.0,0.0
0.0,1.0
1.0,1.0
2.0,0.0
1.0,-1.0
</pre>
<H2>Output for the Sample Input</H2>
<pre>
2.500000
</pre>
|
s450841333 | p00079 | Wrong Answer | from math import hypot
polygon = []
while 1:
try:
x, y = map(float, raw_input().split(','))
polygon.append((x, y))
except EOFError:
break
polygon.sort()
A = polygon[0]
ret = 0.0
for i in xrange(1, len(polygon) - 1):
B = polygon[i]
C = polygon[i + 1]
a = hypot(A[0] - B[0], A[1] - B[1])
b = hypot(A[0] - C[0], A[1] - C[1])
c = hypot(C[0] - B[0], C[1] - B[1])
z = (a + b + c) / 2
S = (z * (z - a) * (z - b) * (z - c)) ** 0.5
ret += S
print ret | 0.0,0.0
0.0,1.0
1.0,1.0
2.0,0.0
1.0,-1.0
| 2.500000
|
<H1>凸 <var>n</var> 角形の面積</H1>
<p>
凸 <var>n</var> 角形（すべての頂点の内角が 180 度未満である多角形、要するにへこんでいない多角形のこと）の頂点の座標を読んで、その面積を出力するプログラムを作成してください。頂点には辺のつながりの順序に従って頂点 1、頂点 2、頂点 3、‥‥頂点 <var>n</var> という名前がついています。
</p>
<p>
ただし、 <var>n</var> は 3 以上 20 以下とします。また、次の、三角形の 3 辺の長さ <var>a, b, c</var> から面積 <var>S</var> を求める公式を使ってもかまいません。
</p>
<center>
<img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_07">
</center>
<br/>
<H2>入力</H2>
<p>
入力は以下の形式で与えられます。
</p>
<pre>
<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>x<sub>i</sub></var>, <var>y<sub>i</sub></var> はそれぞれ頂点 <var>i</var> の <var>x</var> 座標, <var>y</var> 座標を表す実数です。
</p>
<H2>出力</H2>
<p>
面積 <var>S</var> （実数）を１行に出力します。
出力は 0.000001 以下の誤差を含んでもかまいません。
</p>
<H2>Sample Input</H2>
<pre>
0.0,0.0
0.0,1.0
1.0,1.0
2.0,0.0
1.0,-1.0
</pre>
<H2>Output for the Sample Input</H2>
<pre>
2.500000
</pre>
|
s837136953 | p00079 | Wrong Answer | from math import hypot
polygon = []
while 1:
try:
x, y = map(float, raw_input().split(','))
polygon.append((x, y))
except EOFError:
break
polygon.sort()
ret = 0.0
for i in xrange(len(polygon) - 2):
A = polygon[i]
B = polygon[i + 1]
C = polygon[i + 2]
a = hypot(A[0] - B[0], A[1] - B[1])
b = hypot(A[0] - C[0], A[1] - C[1])
c = hypot(C[0] - B[0], C[1] - B[1])
z = (a + b + c) / 2
S = (z * (z - a) * (z - b) * (z - c)) ** 0.5
ret += S
print ret | 0.0,0.0
0.0,1.0
1.0,1.0
2.0,0.0
1.0,-1.0
| 2.500000
|
<H1>凸 <var>n</var> 角形の面積</H1>
<p>
凸 <var>n</var> 角形（すべての頂点の内角が 180 度未満である多角形、要するにへこんでいない多角形のこと）の頂点の座標を読んで、その面積を出力するプログラムを作成してください。頂点には辺のつながりの順序に従って頂点 1、頂点 2、頂点 3、‥‥頂点 <var>n</var> という名前がついています。
</p>
<p>
ただし、 <var>n</var> は 3 以上 20 以下とします。また、次の、三角形の 3 辺の長さ <var>a, b, c</var> から面積 <var>S</var> を求める公式を使ってもかまいません。
</p>
<center>
<img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_07">
</center>
<br/>
<H2>入力</H2>
<p>
入力は以下の形式で与えられます。
</p>
<pre>
<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>x<sub>i</sub></var>, <var>y<sub>i</sub></var> はそれぞれ頂点 <var>i</var> の <var>x</var> 座標, <var>y</var> 座標を表す実数です。
</p>
<H2>出力</H2>
<p>
面積 <var>S</var> （実数）を１行に出力します。
出力は 0.000001 以下の誤差を含んでもかまいません。
</p>
<H2>Sample Input</H2>
<pre>
0.0,0.0
0.0,1.0
1.0,1.0
2.0,0.0
1.0,-1.0
</pre>
<H2>Output for the Sample Input</H2>
<pre>
2.500000
</pre>
|
s870802889 | p00079 | Wrong Answer | from math import hypot
polygon = []
while 1:
try:
x, y = map(float, raw_input().split(','))
polygon.append((x, y))
except EOFError:
break
polygon.sort()
A = polygon[0]
polygon = sorted(polygon[1:], key=lambda a: a[1])
ret = 0.0
for i in xrange(len(polygon) - 1):
B = polygon[i]
C = polygon[i + 1]
a = hypot(A[0] - B[0], A[1] - B[1])
b = hypot(A[0] - C[0], A[1] - C[1])
c = hypot(C[0] - B[0], C[1] - B[1])
z = (a + b + c) / 2
S = (z * (z - a) * (z - b) * (z - c)) ** 0.5
ret += S
print ret | 0.0,0.0
0.0,1.0
1.0,1.0
2.0,0.0
1.0,-1.0
| 2.500000
|
<H1>凸 <var>n</var> 角形の面積</H1>
<p>
凸 <var>n</var> 角形（すべての頂点の内角が 180 度未満である多角形、要するにへこんでいない多角形のこと）の頂点の座標を読んで、その面積を出力するプログラムを作成してください。頂点には辺のつながりの順序に従って頂点 1、頂点 2、頂点 3、‥‥頂点 <var>n</var> という名前がついています。
</p>
<p>
ただし、 <var>n</var> は 3 以上 20 以下とします。また、次の、三角形の 3 辺の長さ <var>a, b, c</var> から面積 <var>S</var> を求める公式を使ってもかまいません。
</p>
<center>
<img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_07">
</center>
<br/>
<H2>入力</H2>
<p>
入力は以下の形式で与えられます。
</p>
<pre>
<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>x<sub>i</sub></var>, <var>y<sub>i</sub></var> はそれぞれ頂点 <var>i</var> の <var>x</var> 座標, <var>y</var> 座標を表す実数です。
</p>
<H2>出力</H2>
<p>
面積 <var>S</var> （実数）を１行に出力します。
出力は 0.000001 以下の誤差を含んでもかまいません。
</p>
<H2>Sample Input</H2>
<pre>
0.0,0.0
0.0,1.0
1.0,1.0
2.0,0.0
1.0,-1.0
</pre>
<H2>Output for the Sample Input</H2>
<pre>
2.500000
</pre>
|
s672177352 | p00079 | Accepted | xlst = []
ylst = []
while True:
try:
x, y = map(float, input().split(","))
xlst.append(x)
ylst.append(y)
except EOFError:
break
num = len(xlst)
cx, cy = sum(xlst) / num, sum(ylst) / num
xlst.append(xlst[0])
ylst.append(ylst[0])
ans = 0
for i in range(num):
x1, y1, x2, y2 = xlst[i], ylst[i], xlst[i + 1], ylst[i + 1]
a = ((x2 - x1) ** 2 + (y2 - y1) ** 2) ** (1 / 2)
b = ((x1 - cx) ** 2 + (y1 - cy) ** 2) ** (1 / 2)
c = ((x2 - cx) ** 2 + (y2 - cy) ** 2) ** (1 / 2)
z = (a + b + c) / 2
s = (z * (z - a) * (z - b) * (z - c)) ** (1 / 2)
ans += s
print(ans)
| 0.0,0.0
0.0,1.0
1.0,1.0
2.0,0.0
1.0,-1.0
| 2.500000
|
<H1>凸 <var>n</var> 角形の面積</H1>
<p>
凸 <var>n</var> 角形（すべての頂点の内角が 180 度未満である多角形、要するにへこんでいない多角形のこと）の頂点の座標を読んで、その面積を出力するプログラムを作成してください。頂点には辺のつながりの順序に従って頂点 1、頂点 2、頂点 3、‥‥頂点 <var>n</var> という名前がついています。
</p>
<p>
ただし、 <var>n</var> は 3 以上 20 以下とします。また、次の、三角形の 3 辺の長さ <var>a, b, c</var> から面積 <var>S</var> を求める公式を使ってもかまいません。
</p>
<center>
<img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_07">
</center>
<br/>
<H2>入力</H2>
<p>
入力は以下の形式で与えられます。
</p>
<pre>
<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>x<sub>i</sub></var>, <var>y<sub>i</sub></var> はそれぞれ頂点 <var>i</var> の <var>x</var> 座標, <var>y</var> 座標を表す実数です。
</p>
<H2>出力</H2>
<p>
面積 <var>S</var> （実数）を１行に出力します。
出力は 0.000001 以下の誤差を含んでもかまいません。
</p>
<H2>Sample Input</H2>
<pre>
0.0,0.0
0.0,1.0
1.0,1.0
2.0,0.0
1.0,-1.0
</pre>
<H2>Output for the Sample Input</H2>
<pre>
2.500000
</pre>
|
s817089972 | p00079 | Accepted | import sys
from math import sqrt, hypot
def _hypot(p1, p2):
return hypot(p2[0]-p1[0], p2[1]-p1[1])
def heron(p1, p2, p3):
e1, e2, e3 = _hypot(p1, p2), _hypot(p2, p3), _hypot(p1, p3)
z = (e1+e2+e3)/2
return sqrt(z*(z-e1)*(z-e2)*(z-e3))
a = [tuple(map(float, l.split(","))) for l in sys.stdin]
result = 0
for p1, p2 in zip(a[1:], a[2:]):
result += heron(a[0], p1, p2)
print(result)
| 0.0,0.0
0.0,1.0
1.0,1.0
2.0,0.0
1.0,-1.0
| 2.500000
|
<H1>凸 <var>n</var> 角形の面積</H1>
<p>
凸 <var>n</var> 角形（すべての頂点の内角が 180 度未満である多角形、要するにへこんでいない多角形のこと）の頂点の座標を読んで、その面積を出力するプログラムを作成してください。頂点には辺のつながりの順序に従って頂点 1、頂点 2、頂点 3、‥‥頂点 <var>n</var> という名前がついています。
</p>
<p>
ただし、 <var>n</var> は 3 以上 20 以下とします。また、次の、三角形の 3 辺の長さ <var>a, b, c</var> から面積 <var>S</var> を求める公式を使ってもかまいません。
</p>
<center>
<img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_07">
</center>
<br/>
<H2>入力</H2>
<p>
入力は以下の形式で与えられます。
</p>
<pre>
<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>x<sub>i</sub></var>, <var>y<sub>i</sub></var> はそれぞれ頂点 <var>i</var> の <var>x</var> 座標, <var>y</var> 座標を表す実数です。
</p>
<H2>出力</H2>
<p>
面積 <var>S</var> （実数）を１行に出力します。
出力は 0.000001 以下の誤差を含んでもかまいません。
</p>
<H2>Sample Input</H2>
<pre>
0.0,0.0
0.0,1.0
1.0,1.0
2.0,0.0
1.0,-1.0
</pre>
<H2>Output for the Sample Input</H2>
<pre>
2.500000
</pre>
|
s310088448 | p00079 | Accepted | import sys
def delta_s(p1,p2,p3):
a = ( (p2[0]-p1[0])**2 + (p2[1]-p1[1])**2 )**0.5
b = ( (p3[0]-p2[0])**2 + (p3[1]-p2[1])**2 )**0.5
c = ( (p1[0]-p3[0])**2 + (p1[1]-p3[1])**2 )**0.5
z = ( a+b+c )/2
return (z*(z-a)*(z-b)*(z-c))**0.5
d = []
for s in sys.stdin:
ds = map(float,s.split(","))
d.append(ds)
d0 = d[0]
s = 0
for i in xrange(2,len(d)):
s += delta_s(d[i],d[i-1],d0)
print s | 0.0,0.0
0.0,1.0
1.0,1.0
2.0,0.0
1.0,-1.0
| 2.500000
|
<H1>凸 <var>n</var> 角形の面積</H1>
<p>
凸 <var>n</var> 角形（すべての頂点の内角が 180 度未満である多角形、要するにへこんでいない多角形のこと）の頂点の座標を読んで、その面積を出力するプログラムを作成してください。頂点には辺のつながりの順序に従って頂点 1、頂点 2、頂点 3、‥‥頂点 <var>n</var> という名前がついています。
</p>
<p>
ただし、 <var>n</var> は 3 以上 20 以下とします。また、次の、三角形の 3 辺の長さ <var>a, b, c</var> から面積 <var>S</var> を求める公式を使ってもかまいません。
</p>
<center>
<img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_07">
</center>
<br/>
<H2>入力</H2>
<p>
入力は以下の形式で与えられます。
</p>
<pre>
<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>x<sub>i</sub></var>, <var>y<sub>i</sub></var> はそれぞれ頂点 <var>i</var> の <var>x</var> 座標, <var>y</var> 座標を表す実数です。
</p>
<H2>出力</H2>
<p>
面積 <var>S</var> （実数）を１行に出力します。
出力は 0.000001 以下の誤差を含んでもかまいません。
</p>
<H2>Sample Input</H2>
<pre>
0.0,0.0
0.0,1.0
1.0,1.0
2.0,0.0
1.0,-1.0
</pre>
<H2>Output for the Sample Input</H2>
<pre>
2.500000
</pre>
|
s184964976 | p00079 | Accepted | import sys
f = sys.stdin
def triangle_area(a, b, c):
z = (a + b + c) / 2
s = (z * (z - a) * (z - b) * (z - c)) ** 0.5
return s
apexes = []
for line in f:
x, y = map(float, line.split(','))
apexes.append(x + y * 1j)
s = 0
for i in range(2,len(apexes)):
s += triangle_area(abs(apexes[0] - apexes[i - 1]),abs(apexes[0] - apexes[i]),abs(apexes[i] - apexes[i - 1]))
print(s) | 0.0,0.0
0.0,1.0
1.0,1.0
2.0,0.0
1.0,-1.0
| 2.500000
|
<H1>凸 <var>n</var> 角形の面積</H1>
<p>
凸 <var>n</var> 角形（すべての頂点の内角が 180 度未満である多角形、要するにへこんでいない多角形のこと）の頂点の座標を読んで、その面積を出力するプログラムを作成してください。頂点には辺のつながりの順序に従って頂点 1、頂点 2、頂点 3、‥‥頂点 <var>n</var> という名前がついています。
</p>
<p>
ただし、 <var>n</var> は 3 以上 20 以下とします。また、次の、三角形の 3 辺の長さ <var>a, b, c</var> から面積 <var>S</var> を求める公式を使ってもかまいません。
</p>
<center>
<img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_07">
</center>
<br/>
<H2>入力</H2>
<p>
入力は以下の形式で与えられます。
</p>
<pre>
<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>x<sub>i</sub></var>, <var>y<sub>i</sub></var> はそれぞれ頂点 <var>i</var> の <var>x</var> 座標, <var>y</var> 座標を表す実数です。
</p>
<H2>出力</H2>
<p>
面積 <var>S</var> （実数）を１行に出力します。
出力は 0.000001 以下の誤差を含んでもかまいません。
</p>
<H2>Sample Input</H2>
<pre>
0.0,0.0
0.0,1.0
1.0,1.0
2.0,0.0
1.0,-1.0
</pre>
<H2>Output for the Sample Input</H2>
<pre>
2.500000
</pre>
|
s220352678 | p00079 | Accepted | x,y,r,l,s=[],[],[],[],[]
while 1:
try:
a,b=map(float,raw_input().split(','))
x.append(a)
y.append(b)
except:
break
for i in range(len(x)-1):
r.append(((x[i+1]-x[0])**2+(y[i+1]-y[0])**2)**0.5)
for i in range(1,len(x)-1):
l.append(((x[i+1]-x[i])**2+(y[i+1]-y[i])**2)**0.5)
for i in range(len(x)-2):
s.append((r[i]+r[i+1]+l[i])/2)
sum=0.0
for i in range(len(x)-2):
sum+=(s[i]*(s[i]-r[i])*(s[i]-r[i+1])*(s[i]-l[i]))**0.5
print sum | 0.0,0.0
0.0,1.0
1.0,1.0
2.0,0.0
1.0,-1.0
| 2.500000
|
<H1>凸 <var>n</var> 角形の面積</H1>
<p>
凸 <var>n</var> 角形（すべての頂点の内角が 180 度未満である多角形、要するにへこんでいない多角形のこと）の頂点の座標を読んで、その面積を出力するプログラムを作成してください。頂点には辺のつながりの順序に従って頂点 1、頂点 2、頂点 3、‥‥頂点 <var>n</var> という名前がついています。
</p>
<p>
ただし、 <var>n</var> は 3 以上 20 以下とします。また、次の、三角形の 3 辺の長さ <var>a, b, c</var> から面積 <var>S</var> を求める公式を使ってもかまいません。
</p>
<center>
<img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_07">
</center>
<br/>
<H2>入力</H2>
<p>
入力は以下の形式で与えられます。
</p>
<pre>
<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>x<sub>i</sub></var>, <var>y<sub>i</sub></var> はそれぞれ頂点 <var>i</var> の <var>x</var> 座標, <var>y</var> 座標を表す実数です。
</p>
<H2>出力</H2>
<p>
面積 <var>S</var> （実数）を１行に出力します。
出力は 0.000001 以下の誤差を含んでもかまいません。
</p>
<H2>Sample Input</H2>
<pre>
0.0,0.0
0.0,1.0
1.0,1.0
2.0,0.0
1.0,-1.0
</pre>
<H2>Output for the Sample Input</H2>
<pre>
2.500000
</pre>
|
s554582586 | p00079 | Accepted | def cross(x, y):
return (x.conjugate() * y).imag
def area_polygon(points):
area = 0
n = len(points)
for i in range(n):
area += cross(points[i], points[(i+1)%n])
return area / 2
import sys
p = []
for line in sys.stdin:
x, y = map(float, line.split(','))
p.append(complex(x, y))
print(area_polygon(p)) | 0.0,0.0
0.0,1.0
1.0,1.0
2.0,0.0
1.0,-1.0
| 2.500000
|
<H1>凸 <var>n</var> 角形の面積</H1>
<p>
凸 <var>n</var> 角形（すべての頂点の内角が 180 度未満である多角形、要するにへこんでいない多角形のこと）の頂点の座標を読んで、その面積を出力するプログラムを作成してください。頂点には辺のつながりの順序に従って頂点 1、頂点 2、頂点 3、‥‥頂点 <var>n</var> という名前がついています。
</p>
<p>
ただし、 <var>n</var> は 3 以上 20 以下とします。また、次の、三角形の 3 辺の長さ <var>a, b, c</var> から面積 <var>S</var> を求める公式を使ってもかまいません。
</p>
<center>
<img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_07">
</center>
<br/>
<H2>入力</H2>
<p>
入力は以下の形式で与えられます。
</p>
<pre>
<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>x<sub>i</sub></var>, <var>y<sub>i</sub></var> はそれぞれ頂点 <var>i</var> の <var>x</var> 座標, <var>y</var> 座標を表す実数です。
</p>
<H2>出力</H2>
<p>
面積 <var>S</var> （実数）を１行に出力します。
出力は 0.000001 以下の誤差を含んでもかまいません。
</p>
<H2>Sample Input</H2>
<pre>
0.0,0.0
0.0,1.0
1.0,1.0
2.0,0.0
1.0,-1.0
</pre>
<H2>Output for the Sample Input</H2>
<pre>
2.500000
</pre>
|
s790530511 | p00079 | Accepted | import math
def euclid_dis(c,d,a=0.0,b=0.0):
return math.sqrt((c-a)**2.0+(d-b)**2.0)
def heron(a,b,c):
z=(a+b+c)/2.0
return math.sqrt(z*(z-a)*(z-b)*(z-c))
ans=0
xy=[]
while 1:
try:
xy.append(map(float,raw_input().split(",")))
except:
break
n=len(xy)
for i in xrange(2,n):
a=euclid_dis(xy[(i-1)%n][0],xy[(i-1)%n][1],xy[0][0],xy[0][1])
b=euclid_dis(xy[i%n][0],xy[i%n][1],xy[0][0],xy[0][1])
c=euclid_dis(xy[i%n][0],xy[i%n][1],xy[(i-1)%n][0],xy[(i-1)%n][1])
ans+=heron(a,b,c)
print ans | 0.0,0.0
0.0,1.0
1.0,1.0
2.0,0.0
1.0,-1.0
| 2.500000
|
<H1>凸 <var>n</var> 角形の面積</H1>
<p>
凸 <var>n</var> 角形（すべての頂点の内角が 180 度未満である多角形、要するにへこんでいない多角形のこと）の頂点の座標を読んで、その面積を出力するプログラムを作成してください。頂点には辺のつながりの順序に従って頂点 1、頂点 2、頂点 3、‥‥頂点 <var>n</var> という名前がついています。
</p>
<p>
ただし、 <var>n</var> は 3 以上 20 以下とします。また、次の、三角形の 3 辺の長さ <var>a, b, c</var> から面積 <var>S</var> を求める公式を使ってもかまいません。
</p>
<center>
<img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_07">
</center>
<br/>
<H2>入力</H2>
<p>
入力は以下の形式で与えられます。
</p>
<pre>
<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>x<sub>i</sub></var>, <var>y<sub>i</sub></var> はそれぞれ頂点 <var>i</var> の <var>x</var> 座標, <var>y</var> 座標を表す実数です。
</p>
<H2>出力</H2>
<p>
面積 <var>S</var> （実数）を１行に出力します。
出力は 0.000001 以下の誤差を含んでもかまいません。
</p>
<H2>Sample Input</H2>
<pre>
0.0,0.0
0.0,1.0
1.0,1.0
2.0,0.0
1.0,-1.0
</pre>
<H2>Output for the Sample Input</H2>
<pre>
2.500000
</pre>
|
s592313154 | p00079 | Accepted | x,y=map(float,input().split(','))
bx,by=map(float,input().split(','))
s=0
while 1:
try:xx,yy=map(float,input().split(','))
except:break
a=(pow(bx - xx, 2) + pow(by - yy, 2))**0.5;
b=(pow(x - bx, 2) + pow(y - by, 2))**0.5;
c=(pow(x - xx, 2) + pow(y - yy, 2))**0.5;
z=(a+b+c)/2
s+=(z*(z - a)*(z - b)*(z - c))**0.5
bx,by=xx,yy
print(s) | 0.0,0.0
0.0,1.0
1.0,1.0
2.0,0.0
1.0,-1.0
| 2.500000
|
<H1>凸 <var>n</var> 角形の面積</H1>
<p>
凸 <var>n</var> 角形（すべての頂点の内角が 180 度未満である多角形、要するにへこんでいない多角形のこと）の頂点の座標を読んで、その面積を出力するプログラムを作成してください。頂点には辺のつながりの順序に従って頂点 1、頂点 2、頂点 3、‥‥頂点 <var>n</var> という名前がついています。
</p>
<p>
ただし、 <var>n</var> は 3 以上 20 以下とします。また、次の、三角形の 3 辺の長さ <var>a, b, c</var> から面積 <var>S</var> を求める公式を使ってもかまいません。
</p>
<center>
<img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_07">
</center>
<br/>
<H2>入力</H2>
<p>
入力は以下の形式で与えられます。
</p>
<pre>
<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>x<sub>i</sub></var>, <var>y<sub>i</sub></var> はそれぞれ頂点 <var>i</var> の <var>x</var> 座標, <var>y</var> 座標を表す実数です。
</p>
<H2>出力</H2>
<p>
面積 <var>S</var> （実数）を１行に出力します。
出力は 0.000001 以下の誤差を含んでもかまいません。
</p>
<H2>Sample Input</H2>
<pre>
0.0,0.0
0.0,1.0
1.0,1.0
2.0,0.0
1.0,-1.0
</pre>
<H2>Output for the Sample Input</H2>
<pre>
2.500000
</pre>
|
s215689333 | p00079 | Accepted | x,y=map(float,input().split(','))
bx,by=map(float,input().split(','))
s=0
while 1:
try:xx,yy=map(float,input().split(','))
except:break
a=((bx-xx)**2+(by-yy)**2)**0.5;
b=((x-bx)**2+(y-by)**2)**0.5;
c=((x-xx)**2+(y-yy)**2)**0.5;
z=(a+b+c)/2
s+=(z*(z-a)*(z-b)*(z-c))**0.5
bx,by=xx,yy
print(s) | 0.0,0.0
0.0,1.0
1.0,1.0
2.0,0.0
1.0,-1.0
| 2.500000
|
<H1>凸 <var>n</var> 角形の面積</H1>
<p>
凸 <var>n</var> 角形（すべての頂点の内角が 180 度未満である多角形、要するにへこんでいない多角形のこと）の頂点の座標を読んで、その面積を出力するプログラムを作成してください。頂点には辺のつながりの順序に従って頂点 1、頂点 2、頂点 3、‥‥頂点 <var>n</var> という名前がついています。
</p>
<p>
ただし、 <var>n</var> は 3 以上 20 以下とします。また、次の、三角形の 3 辺の長さ <var>a, b, c</var> から面積 <var>S</var> を求める公式を使ってもかまいません。
</p>
<center>
<img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_07">
</center>
<br/>
<H2>入力</H2>
<p>
入力は以下の形式で与えられます。
</p>
<pre>
<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>x<sub>i</sub></var>, <var>y<sub>i</sub></var> はそれぞれ頂点 <var>i</var> の <var>x</var> 座標, <var>y</var> 座標を表す実数です。
</p>
<H2>出力</H2>
<p>
面積 <var>S</var> （実数）を１行に出力します。
出力は 0.000001 以下の誤差を含んでもかまいません。
</p>
<H2>Sample Input</H2>
<pre>
0.0,0.0
0.0,1.0
1.0,1.0
2.0,0.0
1.0,-1.0
</pre>
<H2>Output for the Sample Input</H2>
<pre>
2.500000
</pre>
|
s860490203 | p00079 | Accepted | import math
f = []
while True:
try:
st = input().strip().split(',')
x,y = list(map(float,st ))
f.append(x + y*1j)
except EOFError:
break
px = [p.real for p in f]
ox = (max(px) + min(px)) / 2.0
py = [p.imag for p in f]
oy = (max(py) + min(py)) / 2.0
fo = ox + oy * 1j
ss = 0.0
for i in range(len(f)):
if i == len(f)-1:
j = 0
else:
j = i + 1
a = abs(f[i]-fo)
b = abs(f[j]-fo)
c = abs(f[j]-f[i])
z = (a + b + c) / 2.0
s = math.sqrt(z*(z-a)*(z-b)*(z-c))
ss += s
print("%.6f" % ss) | 0.0,0.0
0.0,1.0
1.0,1.0
2.0,0.0
1.0,-1.0
| 2.500000
|
<H1>凸 <var>n</var> 角形の面積</H1>
<p>
凸 <var>n</var> 角形（すべての頂点の内角が 180 度未満である多角形、要するにへこんでいない多角形のこと）の頂点の座標を読んで、その面積を出力するプログラムを作成してください。頂点には辺のつながりの順序に従って頂点 1、頂点 2、頂点 3、‥‥頂点 <var>n</var> という名前がついています。
</p>
<p>
ただし、 <var>n</var> は 3 以上 20 以下とします。また、次の、三角形の 3 辺の長さ <var>a, b, c</var> から面積 <var>S</var> を求める公式を使ってもかまいません。
</p>
<center>
<img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_07">
</center>
<br/>
<H2>入力</H2>
<p>
入力は以下の形式で与えられます。
</p>
<pre>
<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>x<sub>i</sub></var>, <var>y<sub>i</sub></var> はそれぞれ頂点 <var>i</var> の <var>x</var> 座標, <var>y</var> 座標を表す実数です。
</p>
<H2>出力</H2>
<p>
面積 <var>S</var> （実数）を１行に出力します。
出力は 0.000001 以下の誤差を含んでもかまいません。
</p>
<H2>Sample Input</H2>
<pre>
0.0,0.0
0.0,1.0
1.0,1.0
2.0,0.0
1.0,-1.0
</pre>
<H2>Output for the Sample Input</H2>
<pre>
2.500000
</pre>
|
s890952804 | p00079 | Accepted | def cross(x, y):
return (x.conjugate() * y).imag
def area_polygon(points):
area = 0
n = len(points)
for i in range(n):
area += cross(points[i], points[(i+1)%n])
return area / 2
import sys
p = []
for line in sys.stdin:
x, y = map(float, line.split(','))
p.append(complex(x, y))
print(area_polygon(p)) | 0.0,0.0
0.0,1.0
1.0,1.0
2.0,0.0
1.0,-1.0
| 2.500000
|
<H1>凸 <var>n</var> 角形の面積</H1>
<p>
凸 <var>n</var> 角形（すべての頂点の内角が 180 度未満である多角形、要するにへこんでいない多角形のこと）の頂点の座標を読んで、その面積を出力するプログラムを作成してください。頂点には辺のつながりの順序に従って頂点 1、頂点 2、頂点 3、‥‥頂点 <var>n</var> という名前がついています。
</p>
<p>
ただし、 <var>n</var> は 3 以上 20 以下とします。また、次の、三角形の 3 辺の長さ <var>a, b, c</var> から面積 <var>S</var> を求める公式を使ってもかまいません。
</p>
<center>
<img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_07">
</center>
<br/>
<H2>入力</H2>
<p>
入力は以下の形式で与えられます。
</p>
<pre>
<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>x<sub>i</sub></var>, <var>y<sub>i</sub></var> はそれぞれ頂点 <var>i</var> の <var>x</var> 座標, <var>y</var> 座標を表す実数です。
</p>
<H2>出力</H2>
<p>
面積 <var>S</var> （実数）を１行に出力します。
出力は 0.000001 以下の誤差を含んでもかまいません。
</p>
<H2>Sample Input</H2>
<pre>
0.0,0.0
0.0,1.0
1.0,1.0
2.0,0.0
1.0,-1.0
</pre>
<H2>Output for the Sample Input</H2>
<pre>
2.500000
</pre>
|
s347269475 | p00079 | Accepted | def cross(x, y):
return (x.conjugate() * y).imag
def area_polygon(points):
area = 0
n = len(points)
for i in range(n):
area += cross(points[i], points[(i+1)%n])
return area / 2
import sys
p = []
for line in sys.stdin:
x, y = map(float, line.split(','))
p.append(complex(x, y))
print(abs(area_polygon(p))) | 0.0,0.0
0.0,1.0
1.0,1.0
2.0,0.0
1.0,-1.0
| 2.500000
|
<H1>凸 <var>n</var> 角形の面積</H1>
<p>
凸 <var>n</var> 角形（すべての頂点の内角が 180 度未満である多角形、要するにへこんでいない多角形のこと）の頂点の座標を読んで、その面積を出力するプログラムを作成してください。頂点には辺のつながりの順序に従って頂点 1、頂点 2、頂点 3、‥‥頂点 <var>n</var> という名前がついています。
</p>
<p>
ただし、 <var>n</var> は 3 以上 20 以下とします。また、次の、三角形の 3 辺の長さ <var>a, b, c</var> から面積 <var>S</var> を求める公式を使ってもかまいません。
</p>
<center>
<img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_07">
</center>
<br/>
<H2>入力</H2>
<p>
入力は以下の形式で与えられます。
</p>
<pre>
<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>x<sub>i</sub></var>, <var>y<sub>i</sub></var> はそれぞれ頂点 <var>i</var> の <var>x</var> 座標, <var>y</var> 座標を表す実数です。
</p>
<H2>出力</H2>
<p>
面積 <var>S</var> （実数）を１行に出力します。
出力は 0.000001 以下の誤差を含んでもかまいません。
</p>
<H2>Sample Input</H2>
<pre>
0.0,0.0
0.0,1.0
1.0,1.0
2.0,0.0
1.0,-1.0
</pre>
<H2>Output for the Sample Input</H2>
<pre>
2.500000
</pre>
|
s420162195 | p00079 | Accepted | def cross(x, y):
return (x.conjugate() * y).imag
def area_polygon(points):
area = 0
n = len(points)
for i in range(n):
area += cross(points[i], points[(i+1)%n])
return area / 2
import sys
p = []
for line in sys.stdin:
x, y = map(float, line.split(','))
p.append(x+y*1j)
print(abs(area_polygon(p))) | 0.0,0.0
0.0,1.0
1.0,1.0
2.0,0.0
1.0,-1.0
| 2.500000
|
<H1>凸 <var>n</var> 角形の面積</H1>
<p>
凸 <var>n</var> 角形（すべての頂点の内角が 180 度未満である多角形、要するにへこんでいない多角形のこと）の頂点の座標を読んで、その面積を出力するプログラムを作成してください。頂点には辺のつながりの順序に従って頂点 1、頂点 2、頂点 3、‥‥頂点 <var>n</var> という名前がついています。
</p>
<p>
ただし、 <var>n</var> は 3 以上 20 以下とします。また、次の、三角形の 3 辺の長さ <var>a, b, c</var> から面積 <var>S</var> を求める公式を使ってもかまいません。
</p>
<center>
<img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_07">
</center>
<br/>
<H2>入力</H2>
<p>
入力は以下の形式で与えられます。
</p>
<pre>
<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>x<sub>i</sub></var>, <var>y<sub>i</sub></var> はそれぞれ頂点 <var>i</var> の <var>x</var> 座標, <var>y</var> 座標を表す実数です。
</p>
<H2>出力</H2>
<p>
面積 <var>S</var> （実数）を１行に出力します。
出力は 0.000001 以下の誤差を含んでもかまいません。
</p>
<H2>Sample Input</H2>
<pre>
0.0,0.0
0.0,1.0
1.0,1.0
2.0,0.0
1.0,-1.0
</pre>
<H2>Output for the Sample Input</H2>
<pre>
2.500000
</pre>
|
s389590883 | p00079 | Accepted | import math
f = []
while True:
try:
st = input().strip().split(',')
x,y = list(map(float,st ))
f.append(x + y*1j)
except EOFError:
break
ss = 0.0
fo = f[0]
for j in range(2,len(f)):
i = j - 1
a = abs(f[i]-fo)
b = abs(f[j]-fo)
c = abs(f[j]-f[i])
z = (a + b + c) / 2.0
s = math.sqrt(z*(z-a)*(z-b)*(z-c))
ss += s
print("%.6f" % ss) | 0.0,0.0
0.0,1.0
1.0,1.0
2.0,0.0
1.0,-1.0
| 2.500000
|
<H1>凸 <var>n</var> 角形の面積</H1>
<p>
凸 <var>n</var> 角形（すべての頂点の内角が 180 度未満である多角形、要するにへこんでいない多角形のこと）の頂点の座標を読んで、その面積を出力するプログラムを作成してください。頂点には辺のつながりの順序に従って頂点 1、頂点 2、頂点 3、‥‥頂点 <var>n</var> という名前がついています。
</p>
<p>
ただし、 <var>n</var> は 3 以上 20 以下とします。また、次の、三角形の 3 辺の長さ <var>a, b, c</var> から面積 <var>S</var> を求める公式を使ってもかまいません。
</p>
<center>
<img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_07">
</center>
<br/>
<H2>入力</H2>
<p>
入力は以下の形式で与えられます。
</p>
<pre>
<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>x<sub>i</sub></var>, <var>y<sub>i</sub></var> はそれぞれ頂点 <var>i</var> の <var>x</var> 座標, <var>y</var> 座標を表す実数です。
</p>
<H2>出力</H2>
<p>
面積 <var>S</var> （実数）を１行に出力します。
出力は 0.000001 以下の誤差を含んでもかまいません。
</p>
<H2>Sample Input</H2>
<pre>
0.0,0.0
0.0,1.0
1.0,1.0
2.0,0.0
1.0,-1.0
</pre>
<H2>Output for the Sample Input</H2>
<pre>
2.500000
</pre>
|
s886513006 | p00079 | Accepted | def op(u,v):
return (complex.conjugate(u)*v).imag
f = []
while True:
try:
st = input().strip().split(',')
x,y = list(map(float,st ))
f.append(x + y*1j)
except EOFError:
break
s = 0.0
fo = f[0]
for j in range(2,len(f)):
i = j - 1
s += op(f[i]-fo,f[j]-fo)/2.0
print("%.6f" % abs(s)) | 0.0,0.0
0.0,1.0
1.0,1.0
2.0,0.0
1.0,-1.0
| 2.500000
|
<H1>凸 <var>n</var> 角形の面積</H1>
<p>
凸 <var>n</var> 角形（すべての頂点の内角が 180 度未満である多角形、要するにへこんでいない多角形のこと）の頂点の座標を読んで、その面積を出力するプログラムを作成してください。頂点には辺のつながりの順序に従って頂点 1、頂点 2、頂点 3、‥‥頂点 <var>n</var> という名前がついています。
</p>
<p>
ただし、 <var>n</var> は 3 以上 20 以下とします。また、次の、三角形の 3 辺の長さ <var>a, b, c</var> から面積 <var>S</var> を求める公式を使ってもかまいません。
</p>
<center>
<img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_07">
</center>
<br/>
<H2>入力</H2>
<p>
入力は以下の形式で与えられます。
</p>
<pre>
<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>x<sub>i</sub></var>, <var>y<sub>i</sub></var> はそれぞれ頂点 <var>i</var> の <var>x</var> 座標, <var>y</var> 座標を表す実数です。
</p>
<H2>出力</H2>
<p>
面積 <var>S</var> （実数）を１行に出力します。
出力は 0.000001 以下の誤差を含んでもかまいません。
</p>
<H2>Sample Input</H2>
<pre>
0.0,0.0
0.0,1.0
1.0,1.0
2.0,0.0
1.0,-1.0
</pre>
<H2>Output for the Sample Input</H2>
<pre>
2.500000
</pre>
|
s532853641 | p00079 | Accepted | import math
X = []
Y = []
def area(a,b,c):
p = math.sqrt((X [a] - X [b]) ** 2 + (Y [a] - Y [b]) ** 2)
q = math.sqrt((X [b] - X [c]) ** 2 + (Y [b] - Y [c]) ** 2)
r = math.sqrt((X [c] - X [a]) ** 2 + (Y [c] - Y [a]) ** 2)
z = (p + q + r) / 2
return math.sqrt(z * (z - p) * (z - q) * (z - r))
while True:
try:
a,b = map(float,input().split(','))
X.append(a)
Y.append(b)
except EOFError:
break
ans = 0.0
for i in range(1,len(X) - 1):
ans += area(0,i,i + 1)
print(ans) | 0.0,0.0
0.0,1.0
1.0,1.0
2.0,0.0
1.0,-1.0
| 2.500000
|
<H1>凸 <var>n</var> 角形の面積</H1>
<p>
凸 <var>n</var> 角形（すべての頂点の内角が 180 度未満である多角形、要するにへこんでいない多角形のこと）の頂点の座標を読んで、その面積を出力するプログラムを作成してください。頂点には辺のつながりの順序に従って頂点 1、頂点 2、頂点 3、‥‥頂点 <var>n</var> という名前がついています。
</p>
<p>
ただし、 <var>n</var> は 3 以上 20 以下とします。また、次の、三角形の 3 辺の長さ <var>a, b, c</var> から面積 <var>S</var> を求める公式を使ってもかまいません。
</p>
<center>
<img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_07">
</center>
<br/>
<H2>入力</H2>
<p>
入力は以下の形式で与えられます。
</p>
<pre>
<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>x<sub>i</sub></var>, <var>y<sub>i</sub></var> はそれぞれ頂点 <var>i</var> の <var>x</var> 座標, <var>y</var> 座標を表す実数です。
</p>
<H2>出力</H2>
<p>
面積 <var>S</var> （実数）を１行に出力します。
出力は 0.000001 以下の誤差を含んでもかまいません。
</p>
<H2>Sample Input</H2>
<pre>
0.0,0.0
0.0,1.0
1.0,1.0
2.0,0.0
1.0,-1.0
</pre>
<H2>Output for the Sample Input</H2>
<pre>
2.500000
</pre>
|
s642596923 | p00079 | Accepted | # -*- coding: utf-8 -*-
import sys
import os
import math
def length(v, w):
x_diff = v[0] - w[0]
y_diff = v[1] - w[1]
return math.sqrt(x_diff ** 2 + y_diff ** 2)
X = []
Y = []
for s in sys.stdin:
x, y = map(float, s.split(','))
X.append(x)
Y.append(y)
n = len(X)
answer = 0
for i in range(1, n-1):
p0 = (X[0], Y[0])
p1 = (X[i], Y[i])
p2 = (X[i+1], Y[i+1])
a = length(p0, p1)
b = length(p1, p2)
c = length(p2, p0)
z = (a + b + c) / 2
S = math.sqrt(z * (z - a) * (z - b) * (z - c))
answer += S
print(answer) | 0.0,0.0
0.0,1.0
1.0,1.0
2.0,0.0
1.0,-1.0
| 2.500000
|
<H1>凸 <var>n</var> 角形の面積</H1>
<p>
凸 <var>n</var> 角形（すべての頂点の内角が 180 度未満である多角形、要するにへこんでいない多角形のこと）の頂点の座標を読んで、その面積を出力するプログラムを作成してください。頂点には辺のつながりの順序に従って頂点 1、頂点 2、頂点 3、‥‥頂点 <var>n</var> という名前がついています。
</p>
<p>
ただし、 <var>n</var> は 3 以上 20 以下とします。また、次の、三角形の 3 辺の長さ <var>a, b, c</var> から面積 <var>S</var> を求める公式を使ってもかまいません。
</p>
<center>
<img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_07">
</center>
<br/>
<H2>入力</H2>
<p>
入力は以下の形式で与えられます。
</p>
<pre>
<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>x<sub>i</sub></var>, <var>y<sub>i</sub></var> はそれぞれ頂点 <var>i</var> の <var>x</var> 座標, <var>y</var> 座標を表す実数です。
</p>
<H2>出力</H2>
<p>
面積 <var>S</var> （実数）を１行に出力します。
出力は 0.000001 以下の誤差を含んでもかまいません。
</p>
<H2>Sample Input</H2>
<pre>
0.0,0.0
0.0,1.0
1.0,1.0
2.0,0.0
1.0,-1.0
</pre>
<H2>Output for the Sample Input</H2>
<pre>
2.500000
</pre>
|
s754581087 | p00079 | Accepted | # Aizu Problem 0079: Area of Polygon
#
import sys, math, os
# read input:
PYDEV = os.environ.get('PYDEV')
if PYDEV=="True":
sys.stdin = open("sample-input.txt", "rt")
def poly_area(polygon, M):
A = 0
for i in range(M):
x1, y1 = polygon[i][0], polygon[i][1]
x2, y2 = polygon[(i+1)%M][0], polygon[(i+1)%M][1]
A += (x1 * y2 - x2 * y1)
return abs(A / 2)
poly = [[float(_) for _ in line.split(',')] for line in sys.stdin]
print("%.6f" % poly_area(poly, len(poly))) | 0.0,0.0
0.0,1.0
1.0,1.0
2.0,0.0
1.0,-1.0
| 2.500000
|
<H1>凸 <var>n</var> 角形の面積</H1>
<p>
凸 <var>n</var> 角形（すべての頂点の内角が 180 度未満である多角形、要するにへこんでいない多角形のこと）の頂点の座標を読んで、その面積を出力するプログラムを作成してください。頂点には辺のつながりの順序に従って頂点 1、頂点 2、頂点 3、‥‥頂点 <var>n</var> という名前がついています。
</p>
<p>
ただし、 <var>n</var> は 3 以上 20 以下とします。また、次の、三角形の 3 辺の長さ <var>a, b, c</var> から面積 <var>S</var> を求める公式を使ってもかまいません。
</p>
<center>
<img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_07">
</center>
<br/>
<H2>入力</H2>
<p>
入力は以下の形式で与えられます。
</p>
<pre>
<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>x<sub>i</sub></var>, <var>y<sub>i</sub></var> はそれぞれ頂点 <var>i</var> の <var>x</var> 座標, <var>y</var> 座標を表す実数です。
</p>
<H2>出力</H2>
<p>
面積 <var>S</var> （実数）を１行に出力します。
出力は 0.000001 以下の誤差を含んでもかまいません。
</p>
<H2>Sample Input</H2>
<pre>
0.0,0.0
0.0,1.0
1.0,1.0
2.0,0.0
1.0,-1.0
</pre>
<H2>Output for the Sample Input</H2>
<pre>
2.500000
</pre>
|
s450812736 | p00079 | Accepted | # -*- coding: utf-8 -*-
"""
http://judge.u-aizu.ac.jp/onlinejudge/description.jsp?id=0079
"""
import sys
from math import sqrt, atan2, acos, sin, cos, hypot
from sys import stdin
input = stdin.readline
class Point(object):
epsilon = 1e-10
def __init__(self, x=0.0, y=0.0):
if isinstance(x, tuple):
self.x = x[0]
self.y = x[1]
else:
self.x = x
self.y = y
# ????????????
def __add__(self, other):
return Point(self.x + other.x, self.y + other.y)
def __sub__(self, other):
return Point(self.x - other.x, self.y - other.y)
def __mul__(self, other):
return Point(other * self.x, other * self.y)
def __truediv__(self, other):
return Point(self.x / other, self.y / other)
def __lt__(self, other):
if self.x == other.x:
return self.y < other.y
else:
return self.x < other.x
def __eq__(self, other):
from math import fabs
if fabs(self.x - other.x) < Point.epsilon and fabs(self.y - other.y) < Point.epsilon:
return True
else:
return False
def norm(self):
return self.x * self.x + self.y * self.y
def __abs__(self):
return sqrt(self.norm())
def ccw(self, p0, p1):
# ??????2???(p0, p1)?????????????????????????????????????????¢????????????
a = Vector(p1 - p0)
b = Vector(self - p0)
if Vector.cross(a, b) > Point.epsilon:
return 1 # 'COUNTER_CLOCKWISE'
elif Vector.cross(a, b) < -Point.epsilon:
return -1 # 'CLOCKWISE'
elif Vector.dot(a, b) < -Point.epsilon:
return 2 # 'ONLINE_BACK'
elif a.norm() < b.norm():
return -2 # 'ONLINE_FRONT'
else:
return 0 # 'ON_SEGMENT'
def project(self, s):
# ??????(Point)????????????s??????????????????????????????????????§?¨?(?°???±)????±???????
base = Vector(s.p2 - s.p1)
a = Vector(self - s.p1)
r = Vector.dot(a, base)
r /= base.norm()
return s.p1 + base * r
def reflect(self, s):
# ??????s???????§°?????¨?????????????????¨???????§°??????????????§?¨?(????°?)????±???????
proj = self.project(s)
return self + (proj - self)*2
def distance(self, s):
# ????????¨??????s????????¢????¨??????????
if Vector.dot(s.p2-s.p1, self-s.p1) < 0.0:
return abs(self - s.p1)
if Vector.dot(s.p1-s.p2, self-s.p2) < 0.0:
return abs(self - s.p2)
return abs(Vector.cross(s.p2-s.p1, self-s.p1) / abs(s.p2-s.p1))
class Vector(Point):
def __init__(self, x=0.0, y=0.0):
if isinstance(x, tuple):
self.x = x[0]
self.y = x[1]
elif isinstance(x, Point):
self.x = x.x
self.y = x.y
else:
self.x = x
self.y = y
# ????????????
def __add__(self, other):
return Vector(self.x + other.x, self.y + other.y)
def __sub__(self, other):
return Vector(self.x - other.x, self.y - other.y)
def __mul__(self, other):
return Vector(other * self.x, other * self.y)
def __truediv__(self, other):
return Vector(self.x / other, self.y / other)
@classmethod
def dot(cls, a, b):
return a.x * b.x + a.y * b.y
@classmethod
def cross(cls, a, b):
return a.x * b.y - a.y * b.x
@classmethod
def is_orthogonal(cls, a, b):
return abs(Vector.dot(a, b)) < Vector.epsilon
@classmethod
def is_parallel(cls, a, b):
return abs(Vector.cross(a, b)) < Vector.epsilon
class Segment(object):
def __init__(self, p1=Point(), p2=Point()):
if isinstance(p1, Point):
self.p1 = p1
self.p2 = p2
elif isinstance(p1, tuple):
self.p1 = Point(p1[0], p1[1])
self.p2 = Point(p2[0], p2[1])
def intersect(self, s):
# ????????¨??????????????????????????????????????????????????????
ans1 = s.p1.ccw(self.p1, self.p2) * s.p2.ccw(self.p1, self.p2)
ans2 = self.p1.ccw(s.p1, s.p2) * self.p2.ccw(s.p1, s.p2)
return ans1 <= 0 and ans2 <= 0
def cross_point(self, s):
# ????????¨??????????????????????????????????????§?¨?????±???????
base = s.p2 - s.p1
d1 = abs(Vector.cross(base, self.p1-s.p1))
d2 = abs(Vector.cross(base, self.p2-s.p1))
t = d1 / (d1 + d2)
return self.p1 + (self.p2 - self.p1) * t
def distance(self, s):
# ????????¨?????????????????????????????¢????±???????
if self.intersect(s):
return 0.0
d1 = s.p1.distance(self)
d2 = s.p2.distance(self)
d3 = self.p1.distance(s)
d4 = self.p2.distance(s)
return min(d1, d2, d3, d4)
@classmethod
def is_orthogonal(cls, s1, s2):
a = Vector(s1.p2 - s1.p1)
b = Vector(s2.p2 - s2.p1)
return Vector.is_orthogonal(a, b)
@classmethod
def is_parallel(cls, s1, s2):
a = Vector(s1.p2 - s1.p1)
b = Vector(s2.p2 - s2.p1)
return Vector.is_parallel(a, b)
class Line(Segment):
pass
class Cirle(object):
def __init__(self, x, y=Point(), r=1.0):
if isinstance(x, Point):
self.c = x
self.r = y
elif isinstance(x, tuple):
self.c = Point(x[0], x[1])
self.r = r
def cross_points(self, s):
if isinstance(s, Segment):
pr = self.c.project(s)
e = (s.p2 - s.p1) / abs(s.p2 - s.p1)
base = sqrt(self.r * self.r - (pr - self.c).norm())
return pr + e * base, pr - e * base
elif isinstance(s, Cirle):
c2 = s
d = abs(self.c - c2.c)
a = acos((self.r * self.r + d * d - c2.r * c2.r) / (2 * self.r * d))
t = atan2(c2.c.y - self.c.y, c2.c.x - self.c.x)
temp1 = Point(cos(t+a)*self.r, sin(t+a)*self.r)
temp2 = Point(cos(t-a)*self.r, sin(t-a)*self.r)
return self.c + temp1, self.c + temp2
class Triangle(object):
def __init__(self, p1, p2, p3):
self.p1 = p1
self.p2 = p2
self.p3 = p3
def length(self):
l1 = hypot(self.p1.x-self.p2.x, self.p1.y-self.p2.y)
l2 = hypot(self.p2.x-self.p3.x, self.p2.y-self.p3.y)
l3 = hypot(self.p3.x-self.p1.x, self.p3.y-self.p1.y)
return l1, l2, l3
def area(self):
a, b, c = self.length()
z = (a+b+c) / 2.0
return sqrt(z * (z-a)*(z-b)*(z-c))
def main(args):
points = []
for line in sys.stdin:
x, y = map(float, line.split(','))
points.append(Point(x, y))
area = 0.0
p1 = points[0]
points = points[1:]
while len(points) > 1:
p2 = points[0]
p3 = points[1]
t = Triangle(p1, p2, p3)
area += t.area()
points = points[1:]
print('{:.8f}'.format(area))
if __name__ == '__main__':
main(sys.argv[1:]) | 0.0,0.0
0.0,1.0
1.0,1.0
2.0,0.0
1.0,-1.0
| 2.500000
|
<H1>凸 <var>n</var> 角形の面積</H1>
<p>
凸 <var>n</var> 角形（すべての頂点の内角が 180 度未満である多角形、要するにへこんでいない多角形のこと）の頂点の座標を読んで、その面積を出力するプログラムを作成してください。頂点には辺のつながりの順序に従って頂点 1、頂点 2、頂点 3、‥‥頂点 <var>n</var> という名前がついています。
</p>
<p>
ただし、 <var>n</var> は 3 以上 20 以下とします。また、次の、三角形の 3 辺の長さ <var>a, b, c</var> から面積 <var>S</var> を求める公式を使ってもかまいません。
</p>
<center>
<img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_07">
</center>
<br/>
<H2>入力</H2>
<p>
入力は以下の形式で与えられます。
</p>
<pre>
<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>x<sub>i</sub></var>, <var>y<sub>i</sub></var> はそれぞれ頂点 <var>i</var> の <var>x</var> 座標, <var>y</var> 座標を表す実数です。
</p>
<H2>出力</H2>
<p>
面積 <var>S</var> （実数）を１行に出力します。
出力は 0.000001 以下の誤差を含んでもかまいません。
</p>
<H2>Sample Input</H2>
<pre>
0.0,0.0
0.0,1.0
1.0,1.0
2.0,0.0
1.0,-1.0
</pre>
<H2>Output for the Sample Input</H2>
<pre>
2.500000
</pre>
|
s295036466 | p00079 | Accepted | import math
def get_input():
while True:
try:
yield ''.join(input())
except EOFError:
break
N = list(get_input())
x0,y0 = [float(i) for i in N[0].split(",")]
ans = 0.0
for l in range(2,len(N)):
x1, y1 = [float(i) for i in N[l-1].split(",")]
x2, y2 = [float(i) for i in N[l].split(",")]
a = math.sqrt((x1-x0)**2 + (y1-y0)**2)
b = math.sqrt((x2-x1)**2 + (y2-y1)**2)
c = math.sqrt((x2-x0)**2 + (y2-y0)**2)
z = (a+b+c)/2.0
S = math.sqrt(z*(z-a)*(z-b)*(z-c))
ans += S
print(ans)
| 0.0,0.0
0.0,1.0
1.0,1.0
2.0,0.0
1.0,-1.0
| 2.500000
|
<H1>凸 <var>n</var> 角形の面積</H1>
<p>
凸 <var>n</var> 角形（すべての頂点の内角が 180 度未満である多角形、要するにへこんでいない多角形のこと）の頂点の座標を読んで、その面積を出力するプログラムを作成してください。頂点には辺のつながりの順序に従って頂点 1、頂点 2、頂点 3、‥‥頂点 <var>n</var> という名前がついています。
</p>
<p>
ただし、 <var>n</var> は 3 以上 20 以下とします。また、次の、三角形の 3 辺の長さ <var>a, b, c</var> から面積 <var>S</var> を求める公式を使ってもかまいません。
</p>
<center>
<img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_07">
</center>
<br/>
<H2>入力</H2>
<p>
入力は以下の形式で与えられます。
</p>
<pre>
<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>x<sub>i</sub></var>, <var>y<sub>i</sub></var> はそれぞれ頂点 <var>i</var> の <var>x</var> 座標, <var>y</var> 座標を表す実数です。
</p>
<H2>出力</H2>
<p>
面積 <var>S</var> （実数）を１行に出力します。
出力は 0.000001 以下の誤差を含んでもかまいません。
</p>
<H2>Sample Input</H2>
<pre>
0.0,0.0
0.0,1.0
1.0,1.0
2.0,0.0
1.0,-1.0
</pre>
<H2>Output for the Sample Input</H2>
<pre>
2.500000
</pre>
|
s646301609 | p00079 | Accepted | import math
def calc_d(a, b):
return math.sqrt((a[0] - b[0])**2 + (a[1] - b[1])**2)
p = []
while True:
try:
p.append(list(map(float, input().split(","))))
except:
break
n = len(p)
s = 0
for i in range(1, n - 1):
a = calc_d(p[0], p[i])
b = calc_d(p[0], p[i+1])
c = calc_d(p[i], p[i+1])
z = (a + b + c)/2
s += math.sqrt(z*(z - a)*(z - b)*(z - c))
print(s)
| 0.0,0.0
0.0,1.0
1.0,1.0
2.0,0.0
1.0,-1.0
| 2.500000
|
<H1>凸 <var>n</var> 角形の面積</H1>
<p>
凸 <var>n</var> 角形（すべての頂点の内角が 180 度未満である多角形、要するにへこんでいない多角形のこと）の頂点の座標を読んで、その面積を出力するプログラムを作成してください。頂点には辺のつながりの順序に従って頂点 1、頂点 2、頂点 3、‥‥頂点 <var>n</var> という名前がついています。
</p>
<p>
ただし、 <var>n</var> は 3 以上 20 以下とします。また、次の、三角形の 3 辺の長さ <var>a, b, c</var> から面積 <var>S</var> を求める公式を使ってもかまいません。
</p>
<center>
<img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_07">
</center>
<br/>
<H2>入力</H2>
<p>
入力は以下の形式で与えられます。
</p>
<pre>
<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>x<sub>i</sub></var>, <var>y<sub>i</sub></var> はそれぞれ頂点 <var>i</var> の <var>x</var> 座標, <var>y</var> 座標を表す実数です。
</p>
<H2>出力</H2>
<p>
面積 <var>S</var> （実数）を１行に出力します。
出力は 0.000001 以下の誤差を含んでもかまいません。
</p>
<H2>Sample Input</H2>
<pre>
0.0,0.0
0.0,1.0
1.0,1.0
2.0,0.0
1.0,-1.0
</pre>
<H2>Output for the Sample Input</H2>
<pre>
2.500000
</pre>
|
s320600916 | p00079 | Accepted | import sys
s=0
p=[list(map(float,e.split(',')))for e in sys.stdin]
x,y=p[0]
for i in range(len(p)-2):
a,b=p[i+1];c,d=p[i+2]
s+=((a-x)*(d-y)-(b-y)*(c-x))/2
print(abs(s))
| 0.0,0.0
0.0,1.0
1.0,1.0
2.0,0.0
1.0,-1.0
| 2.500000
|
<H1>凸 <var>n</var> 角形の面積</H1>
<p>
凸 <var>n</var> 角形（すべての頂点の内角が 180 度未満である多角形、要するにへこんでいない多角形のこと）の頂点の座標を読んで、その面積を出力するプログラムを作成してください。頂点には辺のつながりの順序に従って頂点 1、頂点 2、頂点 3、‥‥頂点 <var>n</var> という名前がついています。
</p>
<p>
ただし、 <var>n</var> は 3 以上 20 以下とします。また、次の、三角形の 3 辺の長さ <var>a, b, c</var> から面積 <var>S</var> を求める公式を使ってもかまいません。
</p>
<center>
<img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_07">
</center>
<br/>
<H2>入力</H2>
<p>
入力は以下の形式で与えられます。
</p>
<pre>
<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>x<sub>i</sub></var>, <var>y<sub>i</sub></var> はそれぞれ頂点 <var>i</var> の <var>x</var> 座標, <var>y</var> 座標を表す実数です。
</p>
<H2>出力</H2>
<p>
面積 <var>S</var> （実数）を１行に出力します。
出力は 0.000001 以下の誤差を含んでもかまいません。
</p>
<H2>Sample Input</H2>
<pre>
0.0,0.0
0.0,1.0
1.0,1.0
2.0,0.0
1.0,-1.0
</pre>
<H2>Output for the Sample Input</H2>
<pre>
2.500000
</pre>
|
s060930782 | p00079 | Accepted | import sys
s=0
p=[list(map(float,e.split(',')))for e in sys.stdin]
x,y=p[0]
for i in range(len(p)-2):
a,b=p[i+1];c,d=p[i+2]
s+=(a*d-b*c+(b-d)*x+(c-a)*y)/2
print(abs(s))
| 0.0,0.0
0.0,1.0
1.0,1.0
2.0,0.0
1.0,-1.0
| 2.500000
|
<H1>凸 <var>n</var> 角形の面積</H1>
<p>
凸 <var>n</var> 角形（すべての頂点の内角が 180 度未満である多角形、要するにへこんでいない多角形のこと）の頂点の座標を読んで、その面積を出力するプログラムを作成してください。頂点には辺のつながりの順序に従って頂点 1、頂点 2、頂点 3、‥‥頂点 <var>n</var> という名前がついています。
</p>
<p>
ただし、 <var>n</var> は 3 以上 20 以下とします。また、次の、三角形の 3 辺の長さ <var>a, b, c</var> から面積 <var>S</var> を求める公式を使ってもかまいません。
</p>
<center>
<img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_07">
</center>
<br/>
<H2>入力</H2>
<p>
入力は以下の形式で与えられます。
</p>
<pre>
<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>x<sub>i</sub></var>, <var>y<sub>i</sub></var> はそれぞれ頂点 <var>i</var> の <var>x</var> 座標, <var>y</var> 座標を表す実数です。
</p>
<H2>出力</H2>
<p>
面積 <var>S</var> （実数）を１行に出力します。
出力は 0.000001 以下の誤差を含んでもかまいません。
</p>
<H2>Sample Input</H2>
<pre>
0.0,0.0
0.0,1.0
1.0,1.0
2.0,0.0
1.0,-1.0
</pre>
<H2>Output for the Sample Input</H2>
<pre>
2.500000
</pre>
|
s096153591 | p00079 | Accepted | import sys
s=0
p=[list(map(float,e.split(',')))for e in sys.stdin]
x,y=p[0]
print(abs(sum((p[i][0]-x)*(p[i+1][1]-y)-(p[i][1]-y)*(p[i+1][0]-x)for i in range(1,len(p)-1)))/2)
| 0.0,0.0
0.0,1.0
1.0,1.0
2.0,0.0
1.0,-1.0
| 2.500000
|
<H1>凸 <var>n</var> 角形の面積</H1>
<p>
凸 <var>n</var> 角形（すべての頂点の内角が 180 度未満である多角形、要するにへこんでいない多角形のこと）の頂点の座標を読んで、その面積を出力するプログラムを作成してください。頂点には辺のつながりの順序に従って頂点 1、頂点 2、頂点 3、‥‥頂点 <var>n</var> という名前がついています。
</p>
<p>
ただし、 <var>n</var> は 3 以上 20 以下とします。また、次の、三角形の 3 辺の長さ <var>a, b, c</var> から面積 <var>S</var> を求める公式を使ってもかまいません。
</p>
<center>
<img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_07">
</center>
<br/>
<H2>入力</H2>
<p>
入力は以下の形式で与えられます。
</p>
<pre>
<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>x<sub>i</sub></var>, <var>y<sub>i</sub></var> はそれぞれ頂点 <var>i</var> の <var>x</var> 座標, <var>y</var> 座標を表す実数です。
</p>
<H2>出力</H2>
<p>
面積 <var>S</var> （実数）を１行に出力します。
出力は 0.000001 以下の誤差を含んでもかまいません。
</p>
<H2>Sample Input</H2>
<pre>
0.0,0.0
0.0,1.0
1.0,1.0
2.0,0.0
1.0,-1.0
</pre>
<H2>Output for the Sample Input</H2>
<pre>
2.500000
</pre>
|
s113849305 | p00079 | Accepted | import sys
s=0
p=[list(map(float,e.split(',')))for e in sys.stdin]
x,y=p[0]
for i in range(len(p)-2):a,b=p[i+1];c,d=p[i+2];s+=(a-x)*(d-y)-(b-y)*(c-x)
print(abs(s)/2)
| 0.0,0.0
0.0,1.0
1.0,1.0
2.0,0.0
1.0,-1.0
| 2.500000
|
<H1>凸 <var>n</var> 角形の面積</H1>
<p>
凸 <var>n</var> 角形（すべての頂点の内角が 180 度未満である多角形、要するにへこんでいない多角形のこと）の頂点の座標を読んで、その面積を出力するプログラムを作成してください。頂点には辺のつながりの順序に従って頂点 1、頂点 2、頂点 3、‥‥頂点 <var>n</var> という名前がついています。
</p>
<p>
ただし、 <var>n</var> は 3 以上 20 以下とします。また、次の、三角形の 3 辺の長さ <var>a, b, c</var> から面積 <var>S</var> を求める公式を使ってもかまいません。
</p>
<center>
<img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_07">
</center>
<br/>
<H2>入力</H2>
<p>
入力は以下の形式で与えられます。
</p>
<pre>
<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>x<sub>i</sub></var>, <var>y<sub>i</sub></var> はそれぞれ頂点 <var>i</var> の <var>x</var> 座標, <var>y</var> 座標を表す実数です。
</p>
<H2>出力</H2>
<p>
面積 <var>S</var> （実数）を１行に出力します。
出力は 0.000001 以下の誤差を含んでもかまいません。
</p>
<H2>Sample Input</H2>
<pre>
0.0,0.0
0.0,1.0
1.0,1.0
2.0,0.0
1.0,-1.0
</pre>
<H2>Output for the Sample Input</H2>
<pre>
2.500000
</pre>
|
s239386772 | p00079 | Accepted | import sys
s=0
p=[list(map(float,e.split(',')))for e in sys.stdin]
n=len(p)
for i in range(n):a,b=p[i];c,d=p[-~i%n];s+=a*d-b*c
print(s/2)
## abs abs
| 0.0,0.0
0.0,1.0
1.0,1.0
2.0,0.0
1.0,-1.0
| 2.500000
|
<H1>凸 <var>n</var> 角形の面積</H1>
<p>
凸 <var>n</var> 角形（すべての頂点の内角が 180 度未満である多角形、要するにへこんでいない多角形のこと）の頂点の座標を読んで、その面積を出力するプログラムを作成してください。頂点には辺のつながりの順序に従って頂点 1、頂点 2、頂点 3、‥‥頂点 <var>n</var> という名前がついています。
</p>
<p>
ただし、 <var>n</var> は 3 以上 20 以下とします。また、次の、三角形の 3 辺の長さ <var>a, b, c</var> から面積 <var>S</var> を求める公式を使ってもかまいません。
</p>
<center>
<img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_07">
</center>
<br/>
<H2>入力</H2>
<p>
入力は以下の形式で与えられます。
</p>
<pre>
<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>x<sub>i</sub></var>, <var>y<sub>i</sub></var> はそれぞれ頂点 <var>i</var> の <var>x</var> 座標, <var>y</var> 座標を表す実数です。
</p>
<H2>出力</H2>
<p>
面積 <var>S</var> （実数）を１行に出力します。
出力は 0.000001 以下の誤差を含んでもかまいません。
</p>
<H2>Sample Input</H2>
<pre>
0.0,0.0
0.0,1.0
1.0,1.0
2.0,0.0
1.0,-1.0
</pre>
<H2>Output for the Sample Input</H2>
<pre>
2.500000
</pre>
|
s414690034 | p00079 | Accepted | import sys
s=0
p=[list(map(float,e.split(',')))for e in sys.stdin]
n=len(p)
for i in range(n):a,b=p[i];c,d=p[-~i%n];s+=a*d-b*c
print(abs(s)/2)
| 0.0,0.0
0.0,1.0
1.0,1.0
2.0,0.0
1.0,-1.0
| 2.500000
|
<H1>凸 <var>n</var> 角形の面積</H1>
<p>
凸 <var>n</var> 角形（すべての頂点の内角が 180 度未満である多角形、要するにへこんでいない多角形のこと）の頂点の座標を読んで、その面積を出力するプログラムを作成してください。頂点には辺のつながりの順序に従って頂点 1、頂点 2、頂点 3、‥‥頂点 <var>n</var> という名前がついています。
</p>
<p>
ただし、 <var>n</var> は 3 以上 20 以下とします。また、次の、三角形の 3 辺の長さ <var>a, b, c</var> から面積 <var>S</var> を求める公式を使ってもかまいません。
</p>
<center>
<img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_07">
</center>
<br/>
<H2>入力</H2>
<p>
入力は以下の形式で与えられます。
</p>
<pre>
<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>x<sub>i</sub></var>, <var>y<sub>i</sub></var> はそれぞれ頂点 <var>i</var> の <var>x</var> 座標, <var>y</var> 座標を表す実数です。
</p>
<H2>出力</H2>
<p>
面積 <var>S</var> （実数）を１行に出力します。
出力は 0.000001 以下の誤差を含んでもかまいません。
</p>
<H2>Sample Input</H2>
<pre>
0.0,0.0
0.0,1.0
1.0,1.0
2.0,0.0
1.0,-1.0
</pre>
<H2>Output for the Sample Input</H2>
<pre>
2.500000
</pre>
|
s760431046 | p00079 | Accepted | import sys,math
l=[list(map(float,i.split(","))) for i in sys.stdin]
S=0
for (i,j) in enumerate(l):
xn,yn=j
if i!=len(l)-1:
xn_1,yn_1=l[i+1]
else:
xn_1,yn_1=l[0]
a=math.sqrt(xn**2+yn**2)
b=math.sqrt(xn_1**2+yn_1**2)
c=math.sqrt((xn_1-xn)**2+(yn_1-yn)**2)
z=(a+b+c)/2
S+=math.sqrt(z*(z-a)*(z-b)*(z-c))
print(S)
| 0.0,0.0
0.0,1.0
1.0,1.0
2.0,0.0
1.0,-1.0
| 2.500000
|
<H1>凸 <var>n</var> 角形の面積</H1>
<p>
凸 <var>n</var> 角形（すべての頂点の内角が 180 度未満である多角形、要するにへこんでいない多角形のこと）の頂点の座標を読んで、その面積を出力するプログラムを作成してください。頂点には辺のつながりの順序に従って頂点 1、頂点 2、頂点 3、‥‥頂点 <var>n</var> という名前がついています。
</p>
<p>
ただし、 <var>n</var> は 3 以上 20 以下とします。また、次の、三角形の 3 辺の長さ <var>a, b, c</var> から面積 <var>S</var> を求める公式を使ってもかまいません。
</p>
<center>
<img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_07">
</center>
<br/>
<H2>入力</H2>
<p>
入力は以下の形式で与えられます。
</p>
<pre>
<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>x<sub>i</sub></var>, <var>y<sub>i</sub></var> はそれぞれ頂点 <var>i</var> の <var>x</var> 座標, <var>y</var> 座標を表す実数です。
</p>
<H2>出力</H2>
<p>
面積 <var>S</var> （実数）を１行に出力します。
出力は 0.000001 以下の誤差を含んでもかまいません。
</p>
<H2>Sample Input</H2>
<pre>
0.0,0.0
0.0,1.0
1.0,1.0
2.0,0.0
1.0,-1.0
</pre>
<H2>Output for the Sample Input</H2>
<pre>
2.500000
</pre>
|
s153706496 | p00079 | Accepted | # AOJ 0079 Area of Polygon
# Python3 2018.6.17 bal4u
def calc_area(p):
n, s = len(p), 0
p.append(p[0])
for i in range(n):
s += (p[i].real-p[i+1].real)*(p[i].imag+p[i+1].imag)
return abs(s)/2
p = []
while True:
try: x, y = list(map(float, input().split(',')))
except EOFError: break
p.append(complex(x, y))
print(calc_area(p))
| 0.0,0.0
0.0,1.0
1.0,1.0
2.0,0.0
1.0,-1.0
| 2.500000
|
<H1>凸 <var>n</var> 角形の面積</H1>
<p>
凸 <var>n</var> 角形（すべての頂点の内角が 180 度未満である多角形、要するにへこんでいない多角形のこと）の頂点の座標を読んで、その面積を出力するプログラムを作成してください。頂点には辺のつながりの順序に従って頂点 1、頂点 2、頂点 3、‥‥頂点 <var>n</var> という名前がついています。
</p>
<p>
ただし、 <var>n</var> は 3 以上 20 以下とします。また、次の、三角形の 3 辺の長さ <var>a, b, c</var> から面積 <var>S</var> を求める公式を使ってもかまいません。
</p>
<center>
<img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_07">
</center>
<br/>
<H2>入力</H2>
<p>
入力は以下の形式で与えられます。
</p>
<pre>
<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>x<sub>i</sub></var>, <var>y<sub>i</sub></var> はそれぞれ頂点 <var>i</var> の <var>x</var> 座標, <var>y</var> 座標を表す実数です。
</p>
<H2>出力</H2>
<p>
面積 <var>S</var> （実数）を１行に出力します。
出力は 0.000001 以下の誤差を含んでもかまいません。
</p>
<H2>Sample Input</H2>
<pre>
0.0,0.0
0.0,1.0
1.0,1.0
2.0,0.0
1.0,-1.0
</pre>
<H2>Output for the Sample Input</H2>
<pre>
2.500000
</pre>
|
s586049324 | p00079 | Accepted | vertices = []
for _ in range(20):
try:
vertices.append([float(x) for x in input().split(',')])
except:
break
n = len(vertices)
def dist(p,q):
return ((p[0]-q[0])**2 + (p[1]-q[1])**2)**0.5
def area(p,q,r):
a = dist(p,q)
b = dist(q,r)
c = dist(r,p)
z = (a+b+c)/2
return (z*(z-a)*(z-b)*(z-c))**0.5
S = 0
for i in range(1,n-1):
S += area(vertices[0],vertices[i],vertices[i+1])
print(S)
| 0.0,0.0
0.0,1.0
1.0,1.0
2.0,0.0
1.0,-1.0
| 2.500000
|
<H1>凸 <var>n</var> 角形の面積</H1>
<p>
凸 <var>n</var> 角形（すべての頂点の内角が 180 度未満である多角形、要するにへこんでいない多角形のこと）の頂点の座標を読んで、その面積を出力するプログラムを作成してください。頂点には辺のつながりの順序に従って頂点 1、頂点 2、頂点 3、‥‥頂点 <var>n</var> という名前がついています。
</p>
<p>
ただし、 <var>n</var> は 3 以上 20 以下とします。また、次の、三角形の 3 辺の長さ <var>a, b, c</var> から面積 <var>S</var> を求める公式を使ってもかまいません。
</p>
<center>
<img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_07">
</center>
<br/>
<H2>入力</H2>
<p>
入力は以下の形式で与えられます。
</p>
<pre>
<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>x<sub>i</sub></var>, <var>y<sub>i</sub></var> はそれぞれ頂点 <var>i</var> の <var>x</var> 座標, <var>y</var> 座標を表す実数です。
</p>
<H2>出力</H2>
<p>
面積 <var>S</var> （実数）を１行に出力します。
出力は 0.000001 以下の誤差を含んでもかまいません。
</p>
<H2>Sample Input</H2>
<pre>
0.0,0.0
0.0,1.0
1.0,1.0
2.0,0.0
1.0,-1.0
</pre>
<H2>Output for the Sample Input</H2>
<pre>
2.500000
</pre>
|
s788983773 | p00079 | Accepted | import sys
p=[map(float,line.strip().split(",")) for line in sys.stdin.readlines()]
print abs(sum([p[i-1][0]*p[i][1]-p[i][0]*p[i-1][1] for i in xrange(len(p))]))/2.0 | 0.0,0.0
0.0,1.0
1.0,1.0
2.0,0.0
1.0,-1.0
| 2.500000
|
<H1>凸 <var>n</var> 角形の面積</H1>
<p>
凸 <var>n</var> 角形（すべての頂点の内角が 180 度未満である多角形、要するにへこんでいない多角形のこと）の頂点の座標を読んで、その面積を出力するプログラムを作成してください。頂点には辺のつながりの順序に従って頂点 1、頂点 2、頂点 3、‥‥頂点 <var>n</var> という名前がついています。
</p>
<p>
ただし、 <var>n</var> は 3 以上 20 以下とします。また、次の、三角形の 3 辺の長さ <var>a, b, c</var> から面積 <var>S</var> を求める公式を使ってもかまいません。
</p>
<center>
<img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_07">
</center>
<br/>
<H2>入力</H2>
<p>
入力は以下の形式で与えられます。
</p>
<pre>
<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>x<sub>i</sub></var>, <var>y<sub>i</sub></var> はそれぞれ頂点 <var>i</var> の <var>x</var> 座標, <var>y</var> 座標を表す実数です。
</p>
<H2>出力</H2>
<p>
面積 <var>S</var> （実数）を１行に出力します。
出力は 0.000001 以下の誤差を含んでもかまいません。
</p>
<H2>Sample Input</H2>
<pre>
0.0,0.0
0.0,1.0
1.0,1.0
2.0,0.0
1.0,-1.0
</pre>
<H2>Output for the Sample Input</H2>
<pre>
2.500000
</pre>
|
s770279425 | p00079 | 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 hypot, sqrt
vertexs = []
for line in stdin:
vertexs.append(tuple(float(s) for s in line.split(',')))
s = 0.0
x0, y0 = vertexs[0]
for i in range(1, len(vertexs)-1):
x1, y1 = vertexs[i]
x2, y2 = vertexs[i+1]
a = hypot(x0 - x1, y0 - y1)
b = hypot(x1 - x2, y1 - y2)
c = hypot(x2 - x0, y2 - y0)
z = (a + b + c) / 2.0
s += sqrt(z * (z-a) * (z-b) * (z-c))
print('{:.6f}'.format(s)) | 0.0,0.0
0.0,1.0
1.0,1.0
2.0,0.0
1.0,-1.0
| 2.500000
|
<H1>凸 <var>n</var> 角形の面積</H1>
<p>
凸 <var>n</var> 角形（すべての頂点の内角が 180 度未満である多角形、要するにへこんでいない多角形のこと）の頂点の座標を読んで、その面積を出力するプログラムを作成してください。頂点には辺のつながりの順序に従って頂点 1、頂点 2、頂点 3、‥‥頂点 <var>n</var> という名前がついています。
</p>
<p>
ただし、 <var>n</var> は 3 以上 20 以下とします。また、次の、三角形の 3 辺の長さ <var>a, b, c</var> から面積 <var>S</var> を求める公式を使ってもかまいません。
</p>
<center>
<img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_07">
</center>
<br/>
<H2>入力</H2>
<p>
入力は以下の形式で与えられます。
</p>
<pre>
<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>x<sub>i</sub></var>, <var>y<sub>i</sub></var> はそれぞれ頂点 <var>i</var> の <var>x</var> 座標, <var>y</var> 座標を表す実数です。
</p>
<H2>出力</H2>
<p>
面積 <var>S</var> （実数）を１行に出力します。
出力は 0.000001 以下の誤差を含んでもかまいません。
</p>
<H2>Sample Input</H2>
<pre>
0.0,0.0
0.0,1.0
1.0,1.0
2.0,0.0
1.0,-1.0
</pre>
<H2>Output for the Sample Input</H2>
<pre>
2.500000
</pre>
|
s742116937 | p00079 | Accepted | import math
x, y, r, l, s = [], [], [], [], []
while True:
try:
a, b = map(float, raw_input().split(","))
x.append(a); y.append(b)
except:
break
for i in range(len(x)-1):
r.append(math.sqrt((x[i+1] - x[0])**2 + (y[i+1] - y[0])**2))
for i in range(1,len(x)-1):
l.append(math.sqrt((x[i+1] - x[i])**2 + (y[i+1] - y[i])**2))
for i in range(len(x)-2):
s.append((r[i]+r[i+1]+l[i])/2)
sum = 0.0
for i in range(len(x)-2):
sum += math.sqrt(s[i]*(s[i]-r[i])*(s[i]-r[i+1])*(s[i]-l[i]))
print sum | 0.0,0.0
0.0,1.0
1.0,1.0
2.0,0.0
1.0,-1.0
| 2.500000
|
<H1>凸 <var>n</var> 角形の面積</H1>
<p>
凸 <var>n</var> 角形（すべての頂点の内角が 180 度未満である多角形、要するにへこんでいない多角形のこと）の頂点の座標を読んで、その面積を出力するプログラムを作成してください。頂点には辺のつながりの順序に従って頂点 1、頂点 2、頂点 3、‥‥頂点 <var>n</var> という名前がついています。
</p>
<p>
ただし、 <var>n</var> は 3 以上 20 以下とします。また、次の、三角形の 3 辺の長さ <var>a, b, c</var> から面積 <var>S</var> を求める公式を使ってもかまいません。
</p>
<center>
<img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_07">
</center>
<br/>
<H2>入力</H2>
<p>
入力は以下の形式で与えられます。
</p>
<pre>
<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>x<sub>i</sub></var>, <var>y<sub>i</sub></var> はそれぞれ頂点 <var>i</var> の <var>x</var> 座標, <var>y</var> 座標を表す実数です。
</p>
<H2>出力</H2>
<p>
面積 <var>S</var> （実数）を１行に出力します。
出力は 0.000001 以下の誤差を含んでもかまいません。
</p>
<H2>Sample Input</H2>
<pre>
0.0,0.0
0.0,1.0
1.0,1.0
2.0,0.0
1.0,-1.0
</pre>
<H2>Output for the Sample Input</H2>
<pre>
2.500000
</pre>
|
s822141001 | p00079 | Accepted | import sys,cmath,math
c=[]
for s in sys.stdin:
x,y=map(float,s[:-1].split(","))
c+=[complex(x,y)]
c0=c[0]
c1=c[1]
r1,a1=cmath.polar(c1-c0)
s=0
for e in c[2:]:
r2,a2=cmath.polar(e-c0)
s+=r1*r2*math.sin(abs(a1-a2))/2
r1,a1=r2,a2
print s | 0.0,0.0
0.0,1.0
1.0,1.0
2.0,0.0
1.0,-1.0
| 2.500000
|
<H1>凸 <var>n</var> 角形の面積</H1>
<p>
凸 <var>n</var> 角形（すべての頂点の内角が 180 度未満である多角形、要するにへこんでいない多角形のこと）の頂点の座標を読んで、その面積を出力するプログラムを作成してください。頂点には辺のつながりの順序に従って頂点 1、頂点 2、頂点 3、‥‥頂点 <var>n</var> という名前がついています。
</p>
<p>
ただし、 <var>n</var> は 3 以上 20 以下とします。また、次の、三角形の 3 辺の長さ <var>a, b, c</var> から面積 <var>S</var> を求める公式を使ってもかまいません。
</p>
<center>
<img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_07">
</center>
<br/>
<H2>入力</H2>
<p>
入力は以下の形式で与えられます。
</p>
<pre>
<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>x<sub>i</sub></var>, <var>y<sub>i</sub></var> はそれぞれ頂点 <var>i</var> の <var>x</var> 座標, <var>y</var> 座標を表す実数です。
</p>
<H2>出力</H2>
<p>
面積 <var>S</var> （実数）を１行に出力します。
出力は 0.000001 以下の誤差を含んでもかまいません。
</p>
<H2>Sample Input</H2>
<pre>
0.0,0.0
0.0,1.0
1.0,1.0
2.0,0.0
1.0,-1.0
</pre>
<H2>Output for the Sample Input</H2>
<pre>
2.500000
</pre>
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.