submission_id string | problem_id string | status string | code string | input string | output string | problem_description string |
|---|---|---|---|---|---|---|
s310460928 | p00056 | Accepted | import bisect
primes = [0, 0] + [1] * 49999
for i in range(2, 224):
if primes[i]:
for j in range(i*i, 50001, i):
primes[j] = 0
values = [i for i, k in enumerate(primes) if k]
while True:
n = int(input())
if n == 0:
break
I = bisect.bisect(values, n//2)
print(len([1 for v in values[:I] if primes[n-v]])) | 10
11
0
| 2
0
|
<H1>ゴールドバッハの予想</H1>
<p>
4 以上の偶数は 2 つの素数の和で表すことができるということが知られています。これはゴールドバッハ予想といい、コンピュータの計算によりかなり大きな数まで正しいことが確かめられています。例えば、10 は、7 + 3、5 + 5 の 2 通りの素数の和で表すことができます。
</p>
<p>
整数 <var>n</var> を入力し、<var>n</var> を 2 つの素数の和で表す組み合わせ数が何通りあるかを出力するプログラムを作成してください。ただし、<var>n</var> は 4 以上、50,000 以下とします。また、入力される <var>n</var> は偶数であるとはかぎりません。
</p>
<H2>Input</H2>
<p>
複数のデータセットが与えられます。各データセットに <var>n</var> が１行に与えられます。<var>n</var> が 0 のとき入力の最後とします。データセットの数は 10,000 を超えません。
</p>
<H2>Output</H2>
<p>
各データセットに対して、<var>n</var> を 2 つの素数の和で表す組み合わせ数を１行に出力して下さい。
</p>
<H2>Sample Input</H2>
<pre>
10
11
0
</pre>
<H2>Output for the Sample Input</H2>
<pre>
2
0
</pre>
|
s870389254 | p00056 | Accepted | n = 50001
is_prime = [i for i in range(n)]
is_prime[0] = is_prime[1] = 0
i = 2
while i**2 <= n:
j = i*2
while j < n:
is_prime[j] = 0
j += i
i += 1
prime_set = set(is_prime)
prime_set.remove(0)
prime_list = sorted(list(prime_set))
while True:
cnt = 0
n = int(input())
if n == 0:
break
for i in prime_list:
if i > n//2:
break
if n - i in prime_set:
cnt += 1
print(cnt)
| 10
11
0
| 2
0
|
<H1>ゴールドバッハの予想</H1>
<p>
4 以上の偶数は 2 つの素数の和で表すことができるということが知られています。これはゴールドバッハ予想といい、コンピュータの計算によりかなり大きな数まで正しいことが確かめられています。例えば、10 は、7 + 3、5 + 5 の 2 通りの素数の和で表すことができます。
</p>
<p>
整数 <var>n</var> を入力し、<var>n</var> を 2 つの素数の和で表す組み合わせ数が何通りあるかを出力するプログラムを作成してください。ただし、<var>n</var> は 4 以上、50,000 以下とします。また、入力される <var>n</var> は偶数であるとはかぎりません。
</p>
<H2>Input</H2>
<p>
複数のデータセットが与えられます。各データセットに <var>n</var> が１行に与えられます。<var>n</var> が 0 のとき入力の最後とします。データセットの数は 10,000 を超えません。
</p>
<H2>Output</H2>
<p>
各データセットに対して、<var>n</var> を 2 つの素数の和で表す組み合わせ数を１行に出力して下さい。
</p>
<H2>Sample Input</H2>
<pre>
10
11
0
</pre>
<H2>Output for the Sample Input</H2>
<pre>
2
0
</pre>
|
s463870462 | p00056 | Accepted | import bisect
primes = [0, 0] + [1] * 49999
for i in range(2, 224):
if primes[i]:
for j in range(i*i, 50001, i):
primes[j] = 0
values = [i for i, k in enumerate(primes) if k]
while True:
n = int(input())
if n == 0:
break
I = bisect.bisect(values, n//2)
print(len([1 for v in values[:I] if primes[n-v]]))
| 10
11
0
| 2
0
|
<H1>ゴールドバッハの予想</H1>
<p>
4 以上の偶数は 2 つの素数の和で表すことができるということが知られています。これはゴールドバッハ予想といい、コンピュータの計算によりかなり大きな数まで正しいことが確かめられています。例えば、10 は、7 + 3、5 + 5 の 2 通りの素数の和で表すことができます。
</p>
<p>
整数 <var>n</var> を入力し、<var>n</var> を 2 つの素数の和で表す組み合わせ数が何通りあるかを出力するプログラムを作成してください。ただし、<var>n</var> は 4 以上、50,000 以下とします。また、入力される <var>n</var> は偶数であるとはかぎりません。
</p>
<H2>Input</H2>
<p>
複数のデータセットが与えられます。各データセットに <var>n</var> が１行に与えられます。<var>n</var> が 0 のとき入力の最後とします。データセットの数は 10,000 を超えません。
</p>
<H2>Output</H2>
<p>
各データセットに対して、<var>n</var> を 2 つの素数の和で表す組み合わせ数を１行に出力して下さい。
</p>
<H2>Sample Input</H2>
<pre>
10
11
0
</pre>
<H2>Output for the Sample Input</H2>
<pre>
2
0
</pre>
|
s824372628 | p00056 | Accepted | import bisect
from itertools import *
n=range(50001);a=list(n);a[1]=0
for i in range(2,224):a[i*2::i]=[0]*len(a[i*2::i])
p=list(compress(n,a))
for x in iter(input,'0'):x=int(x);print(sum(a[x-d]>0 for d in p[:bisect.bisect(p,x//2)]))
| 10
11
0
| 2
0
|
<H1>ゴールドバッハの予想</H1>
<p>
4 以上の偶数は 2 つの素数の和で表すことができるということが知られています。これはゴールドバッハ予想といい、コンピュータの計算によりかなり大きな数まで正しいことが確かめられています。例えば、10 は、7 + 3、5 + 5 の 2 通りの素数の和で表すことができます。
</p>
<p>
整数 <var>n</var> を入力し、<var>n</var> を 2 つの素数の和で表す組み合わせ数が何通りあるかを出力するプログラムを作成してください。ただし、<var>n</var> は 4 以上、50,000 以下とします。また、入力される <var>n</var> は偶数であるとはかぎりません。
</p>
<H2>Input</H2>
<p>
複数のデータセットが与えられます。各データセットに <var>n</var> が１行に与えられます。<var>n</var> が 0 のとき入力の最後とします。データセットの数は 10,000 を超えません。
</p>
<H2>Output</H2>
<p>
各データセットに対して、<var>n</var> を 2 つの素数の和で表す組み合わせ数を１行に出力して下さい。
</p>
<H2>Sample Input</H2>
<pre>
10
11
0
</pre>
<H2>Output for the Sample Input</H2>
<pre>
2
0
</pre>
|
s429715472 | p00056 | Accepted | import bisect
from itertools import *
n=range(50001);a=list(n);a[1]=0
for i in range(2,224):a[i*2::i]=[0]*len(a[i*2::i])
p=list(compress(n,a))
for x in iter(input,'0'):x=int(x);print(sum(1 for d in p[:bisect.bisect(p,x//2)]if a[x-d]))
| 10
11
0
| 2
0
|
<H1>ゴールドバッハの予想</H1>
<p>
4 以上の偶数は 2 つの素数の和で表すことができるということが知られています。これはゴールドバッハ予想といい、コンピュータの計算によりかなり大きな数まで正しいことが確かめられています。例えば、10 は、7 + 3、5 + 5 の 2 通りの素数の和で表すことができます。
</p>
<p>
整数 <var>n</var> を入力し、<var>n</var> を 2 つの素数の和で表す組み合わせ数が何通りあるかを出力するプログラムを作成してください。ただし、<var>n</var> は 4 以上、50,000 以下とします。また、入力される <var>n</var> は偶数であるとはかぎりません。
</p>
<H2>Input</H2>
<p>
複数のデータセットが与えられます。各データセットに <var>n</var> が１行に与えられます。<var>n</var> が 0 のとき入力の最後とします。データセットの数は 10,000 を超えません。
</p>
<H2>Output</H2>
<p>
各データセットに対して、<var>n</var> を 2 つの素数の和で表す組み合わせ数を１行に出力して下さい。
</p>
<H2>Sample Input</H2>
<pre>
10
11
0
</pre>
<H2>Output for the Sample Input</H2>
<pre>
2
0
</pre>
|
s097378185 | p00056 | Accepted | from bisect import *
from itertools import *
n=range(50001);a=list(n);a[1]=0
for i in range(2,224):a[i*2::i]=[0]*len(a[i*2::i])
p=list(compress(n,a))
for x in iter(input,'0'):x=int(x);print(sum(1 for d in p[:bisect(p,x//2)]if a[x-d]))
| 10
11
0
| 2
0
|
<H1>ゴールドバッハの予想</H1>
<p>
4 以上の偶数は 2 つの素数の和で表すことができるということが知られています。これはゴールドバッハ予想といい、コンピュータの計算によりかなり大きな数まで正しいことが確かめられています。例えば、10 は、7 + 3、5 + 5 の 2 通りの素数の和で表すことができます。
</p>
<p>
整数 <var>n</var> を入力し、<var>n</var> を 2 つの素数の和で表す組み合わせ数が何通りあるかを出力するプログラムを作成してください。ただし、<var>n</var> は 4 以上、50,000 以下とします。また、入力される <var>n</var> は偶数であるとはかぎりません。
</p>
<H2>Input</H2>
<p>
複数のデータセットが与えられます。各データセットに <var>n</var> が１行に与えられます。<var>n</var> が 0 のとき入力の最後とします。データセットの数は 10,000 を超えません。
</p>
<H2>Output</H2>
<p>
各データセットに対して、<var>n</var> を 2 つの素数の和で表す組み合わせ数を１行に出力して下さい。
</p>
<H2>Sample Input</H2>
<pre>
10
11
0
</pre>
<H2>Output for the Sample Input</H2>
<pre>
2
0
</pre>
|
s849602268 | p00056 | Accepted | import bisect,sys
from itertools import *
n=range(50001);a=list(n);a[1]=0
for i in range(2,224):a[i*2::i]=[0]*len(a[i*2::i])
p=list(compress(n,a))
for x in sys.stdin:
x=int(x)
if x:print(sum(1 for d in p[:bisect.bisect(p,x//2)]if a[x-d]))
| 10
11
0
| 2
0
|
<H1>ゴールドバッハの予想</H1>
<p>
4 以上の偶数は 2 つの素数の和で表すことができるということが知られています。これはゴールドバッハ予想といい、コンピュータの計算によりかなり大きな数まで正しいことが確かめられています。例えば、10 は、7 + 3、5 + 5 の 2 通りの素数の和で表すことができます。
</p>
<p>
整数 <var>n</var> を入力し、<var>n</var> を 2 つの素数の和で表す組み合わせ数が何通りあるかを出力するプログラムを作成してください。ただし、<var>n</var> は 4 以上、50,000 以下とします。また、入力される <var>n</var> は偶数であるとはかぎりません。
</p>
<H2>Input</H2>
<p>
複数のデータセットが与えられます。各データセットに <var>n</var> が１行に与えられます。<var>n</var> が 0 のとき入力の最後とします。データセットの数は 10,000 を超えません。
</p>
<H2>Output</H2>
<p>
各データセットに対して、<var>n</var> を 2 つの素数の和で表す組み合わせ数を１行に出力して下さい。
</p>
<H2>Sample Input</H2>
<pre>
10
11
0
</pre>
<H2>Output for the Sample Input</H2>
<pre>
2
0
</pre>
|
s492954462 | p00056 | Accepted | import bisect,sys
from itertools import *
n=range(50001);a=list(n);a[1]=0
for i in range(2,224):a[i*2::i]=[0]*len(a[i*2::i])
p=list(compress(n,a))
for x in map(int,sys.stdin):
if x:print(sum(1 for d in p[:bisect.bisect(p,x//2)]if a[x-d]))
| 10
11
0
| 2
0
|
<H1>ゴールドバッハの予想</H1>
<p>
4 以上の偶数は 2 つの素数の和で表すことができるということが知られています。これはゴールドバッハ予想といい、コンピュータの計算によりかなり大きな数まで正しいことが確かめられています。例えば、10 は、7 + 3、5 + 5 の 2 通りの素数の和で表すことができます。
</p>
<p>
整数 <var>n</var> を入力し、<var>n</var> を 2 つの素数の和で表す組み合わせ数が何通りあるかを出力するプログラムを作成してください。ただし、<var>n</var> は 4 以上、50,000 以下とします。また、入力される <var>n</var> は偶数であるとはかぎりません。
</p>
<H2>Input</H2>
<p>
複数のデータセットが与えられます。各データセットに <var>n</var> が１行に与えられます。<var>n</var> が 0 のとき入力の最後とします。データセットの数は 10,000 を超えません。
</p>
<H2>Output</H2>
<p>
各データセットに対して、<var>n</var> を 2 つの素数の和で表す組み合わせ数を１行に出力して下さい。
</p>
<H2>Sample Input</H2>
<pre>
10
11
0
</pre>
<H2>Output for the Sample Input</H2>
<pre>
2
0
</pre>
|
s451753048 | p00056 | Accepted | import bisect,sys
from itertools import *
n=range(50001);a=list(n);a[1]=0
for i in range(2,224):a[i*2::i]=[0]*len(a[i*2::i])
for x in map(int,sys.stdin):
if x:print(sum(1 for d in compress(n[:x//2+1],a[:x//2+1])if a[x-d]))
| 10
11
0
| 2
0
|
<H1>ゴールドバッハの予想</H1>
<p>
4 以上の偶数は 2 つの素数の和で表すことができるということが知られています。これはゴールドバッハ予想といい、コンピュータの計算によりかなり大きな数まで正しいことが確かめられています。例えば、10 は、7 + 3、5 + 5 の 2 通りの素数の和で表すことができます。
</p>
<p>
整数 <var>n</var> を入力し、<var>n</var> を 2 つの素数の和で表す組み合わせ数が何通りあるかを出力するプログラムを作成してください。ただし、<var>n</var> は 4 以上、50,000 以下とします。また、入力される <var>n</var> は偶数であるとはかぎりません。
</p>
<H2>Input</H2>
<p>
複数のデータセットが与えられます。各データセットに <var>n</var> が１行に与えられます。<var>n</var> が 0 のとき入力の最後とします。データセットの数は 10,000 を超えません。
</p>
<H2>Output</H2>
<p>
各データセットに対して、<var>n</var> を 2 つの素数の和で表す組み合わせ数を１行に出力して下さい。
</p>
<H2>Sample Input</H2>
<pre>
10
11
0
</pre>
<H2>Output for the Sample Input</H2>
<pre>
2
0
</pre>
|
s746086889 | p00056 | Accepted | import bisect,sys
from itertools import *
n=range(50001);a=list(n);a[1]=0
for i in range(2,224):a[i*2::i]=[0]*len(a[i*2::i])
p=list(compress(n,a))
for x in map(int,sys.stdin):
if x:print(len([1 for d in p[:bisect.bisect(p,x//2)]if a[x-d]]))
| 10
11
0
| 2
0
|
<H1>ゴールドバッハの予想</H1>
<p>
4 以上の偶数は 2 つの素数の和で表すことができるということが知られています。これはゴールドバッハ予想といい、コンピュータの計算によりかなり大きな数まで正しいことが確かめられています。例えば、10 は、7 + 3、5 + 5 の 2 通りの素数の和で表すことができます。
</p>
<p>
整数 <var>n</var> を入力し、<var>n</var> を 2 つの素数の和で表す組み合わせ数が何通りあるかを出力するプログラムを作成してください。ただし、<var>n</var> は 4 以上、50,000 以下とします。また、入力される <var>n</var> は偶数であるとはかぎりません。
</p>
<H2>Input</H2>
<p>
複数のデータセットが与えられます。各データセットに <var>n</var> が１行に与えられます。<var>n</var> が 0 のとき入力の最後とします。データセットの数は 10,000 を超えません。
</p>
<H2>Output</H2>
<p>
各データセットに対して、<var>n</var> を 2 つの素数の和で表す組み合わせ数を１行に出力して下さい。
</p>
<H2>Sample Input</H2>
<pre>
10
11
0
</pre>
<H2>Output for the Sample Input</H2>
<pre>
2
0
</pre>
|
s556563833 | p00056 | Accepted | MAX = 50001
is_prime = [True for _ in range(MAX)]
is_prime[0] = is_prime[1] = False
for i in range(2, int(MAX ** (1 / 2)) + 1):
if is_prime[i]:
for j in range(i ** 2, MAX, i):
is_prime[j] = False
primes = [i for i in range(MAX) if is_prime[i]]
while True:
n = int(input())
if not n:
break
ans = 0
for i in primes:
if i > n // 2:
break
if is_prime[n - i]:
ans += 1
print(ans)
| 10
11
0
| 2
0
|
<H1>ゴールドバッハの予想</H1>
<p>
4 以上の偶数は 2 つの素数の和で表すことができるということが知られています。これはゴールドバッハ予想といい、コンピュータの計算によりかなり大きな数まで正しいことが確かめられています。例えば、10 は、7 + 3、5 + 5 の 2 通りの素数の和で表すことができます。
</p>
<p>
整数 <var>n</var> を入力し、<var>n</var> を 2 つの素数の和で表す組み合わせ数が何通りあるかを出力するプログラムを作成してください。ただし、<var>n</var> は 4 以上、50,000 以下とします。また、入力される <var>n</var> は偶数であるとはかぎりません。
</p>
<H2>Input</H2>
<p>
複数のデータセットが与えられます。各データセットに <var>n</var> が１行に与えられます。<var>n</var> が 0 のとき入力の最後とします。データセットの数は 10,000 を超えません。
</p>
<H2>Output</H2>
<p>
各データセットに対して、<var>n</var> を 2 つの素数の和で表す組み合わせ数を１行に出力して下さい。
</p>
<H2>Sample Input</H2>
<pre>
10
11
0
</pre>
<H2>Output for the Sample Input</H2>
<pre>
2
0
</pre>
|
s205676037 | p00056 | Accepted | MAX = 50001
is_prime = [True for _ in range(MAX)]
is_prime[0] = is_prime[1] = False
for i in range(2, int(MAX ** (1 / 2)) + 1):
if is_prime[i]:
for j in range(i ** 2, MAX, i):
is_prime[j] = False
primes = [i for i in range(MAX) if is_prime[i]]
def main():
while True:
n = int(input())
if not n:
break
ans = 0
for i in primes:
if i > n // 2:
break
if is_prime[n - i]:
ans += 1
print(ans)
main()
| 10
11
0
| 2
0
|
<H1>ゴールドバッハの予想</H1>
<p>
4 以上の偶数は 2 つの素数の和で表すことができるということが知られています。これはゴールドバッハ予想といい、コンピュータの計算によりかなり大きな数まで正しいことが確かめられています。例えば、10 は、7 + 3、5 + 5 の 2 通りの素数の和で表すことができます。
</p>
<p>
整数 <var>n</var> を入力し、<var>n</var> を 2 つの素数の和で表す組み合わせ数が何通りあるかを出力するプログラムを作成してください。ただし、<var>n</var> は 4 以上、50,000 以下とします。また、入力される <var>n</var> は偶数であるとはかぎりません。
</p>
<H2>Input</H2>
<p>
複数のデータセットが与えられます。各データセットに <var>n</var> が１行に与えられます。<var>n</var> が 0 のとき入力の最後とします。データセットの数は 10,000 を超えません。
</p>
<H2>Output</H2>
<p>
各データセットに対して、<var>n</var> を 2 つの素数の和で表す組み合わせ数を１行に出力して下さい。
</p>
<H2>Sample Input</H2>
<pre>
10
11
0
</pre>
<H2>Output for the Sample Input</H2>
<pre>
2
0
</pre>
|
s302870672 | p00056 | Accepted | # AOJ 0056 Goldbach's Conjecture
# Python3 2018.6.16 bal4u
MAX = 50000
HALF = 2761 # prime[2760]=24989, prime[2761]=25013
prime = [
3, 5, 7, 11, 13, 17, 19, 23, 29,
31, 37, 41, 43, 47, 53, 59, 61, 67, 71,
73, 79, 83, 89, 97,101,103,107,109,113,
127,131,137,139,149,151,157,163,167,173,
179,181,191,193,197,199,211,223 ]
sqp = [ # sqp[i] = prime[i]**2
9,25,49,121,169,289,361,529,841,961,
1369,1681,1849,2209,2809,3481,3721,4489,5041,
5329,6241,6889,7921,9409,10201,10609,11449,11881,12769,
16129,17161,18769,19321,22201,22801,24649,26569,27889,29929,
32041,32761,36481,37249,38809,39601,44521,49729 ]
tbl = [0]*(MAX+1) # zero if prime
ans = [0]*(MAX+1)
ans[4] = 1
for i in range(47):
for j in range(sqp[i], MAX, prime[i]): tbl[j] = 1;
for i in range(225, MAX+1, 2):
if tbl[i] == 0: prime.append(i)
for i in range(HALF):
j = i
while True:
k = prime[i]+prime[j]
if k > MAX: break
ans[k] += 1
j += 1
while True:
n = int(input())
if n == 0: break
if (n & 1) == 1: print(1-tbl[n-2])
else: print(ans[n])
| 10
11
0
| 2
0
|
<H1>ゴールドバッハの予想</H1>
<p>
4 以上の偶数は 2 つの素数の和で表すことができるということが知られています。これはゴールドバッハ予想といい、コンピュータの計算によりかなり大きな数まで正しいことが確かめられています。例えば、10 は、7 + 3、5 + 5 の 2 通りの素数の和で表すことができます。
</p>
<p>
整数 <var>n</var> を入力し、<var>n</var> を 2 つの素数の和で表す組み合わせ数が何通りあるかを出力するプログラムを作成してください。ただし、<var>n</var> は 4 以上、50,000 以下とします。また、入力される <var>n</var> は偶数であるとはかぎりません。
</p>
<H2>Input</H2>
<p>
複数のデータセットが与えられます。各データセットに <var>n</var> が１行に与えられます。<var>n</var> が 0 のとき入力の最後とします。データセットの数は 10,000 を超えません。
</p>
<H2>Output</H2>
<p>
各データセットに対して、<var>n</var> を 2 つの素数の和で表す組み合わせ数を１行に出力して下さい。
</p>
<H2>Sample Input</H2>
<pre>
10
11
0
</pre>
<H2>Output for the Sample Input</H2>
<pre>
2
0
</pre>
|
s071993661 | p00056 | Accepted | #!/usr/bin/env python:
# -*- coding: utf-8 -*-
import sys
def make_prime_list(lim):
lst = [True for i in xrange(lim + 1)]
num = 2
while num ** 2 <= lim:
for i in xrange(num * 2, lim + 1, num):
lst[i] = False
num += 1
while not lst[num]:
num += 1
return [i for i in xrange(2, lim + 1) if lst[i]]
def binary_search(n, prime_list):
rLim = len(prime_list) - 1
lLim = 0
while lLim < rLim:
middle = (rLim + lLim) / 2
if prime_list[middle] == n:
return middle
elif prime_list[middle] < n:
lLim = middle + 1
else:
rLim = middle - 1
while prime_list[rLim] < n and rLim < len(prime_list) - 1:
rLim += 1
return rLim
def solve():
prime_list = make_prime_list(50000)
while True:
n = input()
if n > 0:
if n % 2 == 0:
count = 0
index = 0
rev_index = binary_search(n, prime_list)
while index <= rev_index:
while prime_list[index] + prime_list[rev_index] > n:
rev_index -= 1
if index <= rev_index and prime_list[index] + prime_list[rev_index] == n:
count += 1
index += 1
print count
else:
if n - 2 in prime_list:
print 1
else:
print 0
else:
sys.exit()
if __name__ == "__main__":
solve() | 10
11
0
| 2
0
|
<H1>ゴールドバッハの予想</H1>
<p>
4 以上の偶数は 2 つの素数の和で表すことができるということが知られています。これはゴールドバッハ予想といい、コンピュータの計算によりかなり大きな数まで正しいことが確かめられています。例えば、10 は、7 + 3、5 + 5 の 2 通りの素数の和で表すことができます。
</p>
<p>
整数 <var>n</var> を入力し、<var>n</var> を 2 つの素数の和で表す組み合わせ数が何通りあるかを出力するプログラムを作成してください。ただし、<var>n</var> は 4 以上、50,000 以下とします。また、入力される <var>n</var> は偶数であるとはかぎりません。
</p>
<H2>Input</H2>
<p>
複数のデータセットが与えられます。各データセットに <var>n</var> が１行に与えられます。<var>n</var> が 0 のとき入力の最後とします。データセットの数は 10,000 を超えません。
</p>
<H2>Output</H2>
<p>
各データセットに対して、<var>n</var> を 2 つの素数の和で表す組み合わせ数を１行に出力して下さい。
</p>
<H2>Sample Input</H2>
<pre>
10
11
0
</pre>
<H2>Output for the Sample Input</H2>
<pre>
2
0
</pre>
|
s224446895 | p00056 | Accepted | import itertools
N=50000+1
p=[True]*N
p[0],p[1]=False,False
for i in xrange(2,int(N**0.5)+1):
if p[i]==True:
for j in xrange(i**2,N,i):
p[j]=False
plist=[i for i in xrange(N) if p[i]]
c=[0]*N*2
for i,j in itertools.combinations(plist,2):
c[i+j]+=1
for i in xrange(N):
if p[i]:c[i+i]+=1
while True:
n=input()
if n==0:break
print c[n] | 10
11
0
| 2
0
|
<H1>ゴールドバッハの予想</H1>
<p>
4 以上の偶数は 2 つの素数の和で表すことができるということが知られています。これはゴールドバッハ予想といい、コンピュータの計算によりかなり大きな数まで正しいことが確かめられています。例えば、10 は、7 + 3、5 + 5 の 2 通りの素数の和で表すことができます。
</p>
<p>
整数 <var>n</var> を入力し、<var>n</var> を 2 つの素数の和で表す組み合わせ数が何通りあるかを出力するプログラムを作成してください。ただし、<var>n</var> は 4 以上、50,000 以下とします。また、入力される <var>n</var> は偶数であるとはかぎりません。
</p>
<H2>Input</H2>
<p>
複数のデータセットが与えられます。各データセットに <var>n</var> が１行に与えられます。<var>n</var> が 0 のとき入力の最後とします。データセットの数は 10,000 を超えません。
</p>
<H2>Output</H2>
<p>
各データセットに対して、<var>n</var> を 2 つの素数の和で表す組み合わせ数を１行に出力して下さい。
</p>
<H2>Sample Input</H2>
<pre>
10
11
0
</pre>
<H2>Output for the Sample Input</H2>
<pre>
2
0
</pre>
|
s407697294 | p00056 | Accepted |
import sys
import itertools
def prime_list(n):
limit = int(n ** 0.5) + 1
lis = range(1, n + 1, 2)
lis[0] = 2
while True:
if len(lis) == 0:
break
p = lis.pop(0)
yield p
if p <= limit:
lis = [x for x in lis if x % p != 0]
primes = []
for p in prime_list(50000):
primes.append(p)
c = [0] * 50001 * 2
for i, j in itertools.combinations(primes, 2):
c[i+j] += 1
for i in primes:
c[i+i] += 1
while True:
n = int(sys.stdin.readline())
if n == 0:
exit()
print c[n] | 10
11
0
| 2
0
|
<H1>ゴールドバッハの予想</H1>
<p>
4 以上の偶数は 2 つの素数の和で表すことができるということが知られています。これはゴールドバッハ予想といい、コンピュータの計算によりかなり大きな数まで正しいことが確かめられています。例えば、10 は、7 + 3、5 + 5 の 2 通りの素数の和で表すことができます。
</p>
<p>
整数 <var>n</var> を入力し、<var>n</var> を 2 つの素数の和で表す組み合わせ数が何通りあるかを出力するプログラムを作成してください。ただし、<var>n</var> は 4 以上、50,000 以下とします。また、入力される <var>n</var> は偶数であるとはかぎりません。
</p>
<H2>Input</H2>
<p>
複数のデータセットが与えられます。各データセットに <var>n</var> が１行に与えられます。<var>n</var> が 0 のとき入力の最後とします。データセットの数は 10,000 を超えません。
</p>
<H2>Output</H2>
<p>
各データセットに対して、<var>n</var> を 2 つの素数の和で表す組み合わせ数を１行に出力して下さい。
</p>
<H2>Sample Input</H2>
<pre>
10
11
0
</pre>
<H2>Output for the Sample Input</H2>
<pre>
2
0
</pre>
|
s735764046 | p00056 | Accepted | #!/usr/bin/env python
# -*- coding: utf-8 -*-
from __future__ import (division, absolute_import, print_function,
unicode_literals)
from sys import stdin
def enum_prime(m):
L = [True for _ in xrange(m + 1)]
L[0] = L[1] = False
for i in xrange(2, m + 1):
if L[i]:
for j in xrange(i + i, m + 1, i):
L[j] = False
if m < i * i:
break
return L
FLAGS = enum_prime(50000)
PRIMES = [i for i, isprime in enumerate(FLAGS) if isprime]
for line in stdin:
if line.startswith('0'):
break
n = int(line)
n2 = n // 2
cnt = 0
if n % 2 == 0:
for p in PRIMES:
if p > n2:
break
if FLAGS[n - p]:
cnt += 1
elif FLAGS[n - 2]:
cnt = 1
print(cnt) | 10
11
0
| 2
0
|
<H1>ゴールドバッハの予想</H1>
<p>
4 以上の偶数は 2 つの素数の和で表すことができるということが知られています。これはゴールドバッハ予想といい、コンピュータの計算によりかなり大きな数まで正しいことが確かめられています。例えば、10 は、7 + 3、5 + 5 の 2 通りの素数の和で表すことができます。
</p>
<p>
整数 <var>n</var> を入力し、<var>n</var> を 2 つの素数の和で表す組み合わせ数が何通りあるかを出力するプログラムを作成してください。ただし、<var>n</var> は 4 以上、50,000 以下とします。また、入力される <var>n</var> は偶数であるとはかぎりません。
</p>
<H2>Input</H2>
<p>
複数のデータセットが与えられます。各データセットに <var>n</var> が１行に与えられます。<var>n</var> が 0 のとき入力の最後とします。データセットの数は 10,000 を超えません。
</p>
<H2>Output</H2>
<p>
各データセットに対して、<var>n</var> を 2 つの素数の和で表す組み合わせ数を１行に出力して下さい。
</p>
<H2>Sample Input</H2>
<pre>
10
11
0
</pre>
<H2>Output for the Sample Input</H2>
<pre>
2
0
</pre>
|
s630669711 | p00056 | Accepted | import sys
def sieve(m):
N=range(1,m+2,2)
r=int(m**.5)
h=len(N)
N[0]=0
for i in range(h):
x=N[i]
if x>r: break
if x and i+x<h: N[i+x:h:x]=[0] * ((h-1-i-x)/x+1)
return N
def f0056(n):
x=0
if n<4 : x=0
elif n==4: x=1
elif n%2==1:
if SIEVES[(n-2)/2]!=0:
x=1
else:
a=n/2
for e in PRIMES:
if e>a:break
if SIEVES[(n-e)/2]!=0:
x+=1
return x
SIEVES=sieve(50000)
PRIMES=filter(None,SIEVES)
for n in sys.stdin:
n=int(n)
if n==0: break
print f0056(n) | 10
11
0
| 2
0
|
<H1>ゴールドバッハの予想</H1>
<p>
4 以上の偶数は 2 つの素数の和で表すことができるということが知られています。これはゴールドバッハ予想といい、コンピュータの計算によりかなり大きな数まで正しいことが確かめられています。例えば、10 は、7 + 3、5 + 5 の 2 通りの素数の和で表すことができます。
</p>
<p>
整数 <var>n</var> を入力し、<var>n</var> を 2 つの素数の和で表す組み合わせ数が何通りあるかを出力するプログラムを作成してください。ただし、<var>n</var> は 4 以上、50,000 以下とします。また、入力される <var>n</var> は偶数であるとはかぎりません。
</p>
<H2>Input</H2>
<p>
複数のデータセットが与えられます。各データセットに <var>n</var> が１行に与えられます。<var>n</var> が 0 のとき入力の最後とします。データセットの数は 10,000 を超えません。
</p>
<H2>Output</H2>
<p>
各データセットに対して、<var>n</var> を 2 つの素数の和で表す組み合わせ数を１行に出力して下さい。
</p>
<H2>Sample Input</H2>
<pre>
10
11
0
</pre>
<H2>Output for the Sample Input</H2>
<pre>
2
0
</pre>
|
s047359089 | p00056 | Accepted | import sys
def sieve(m):
N=range(1,m+2,2)
r=int(m**.5)
h=len(N)
N[0]=0
for i in range(h):
x=N[i]
if x>r: break
if x and i+x<h: N[i+x:h:x]=[0]*((h-1-i-x)/x+1)
return N
def f0056(n):
x=0
if n<4:x=0
elif n==4:x=1
elif n%2==1:
if S[(n-2)/2]:
x=1
else:
a=n/2
for e in PRIMES:
if e>a: break
if S[(n-e)/2]:
x+=1
return x
S=sieve(50000)
PRIMES=filter(None,S)
for n in sys.stdin:
n=int(n)
if n==0: break
print f0056(n) | 10
11
0
| 2
0
|
<H1>ゴールドバッハの予想</H1>
<p>
4 以上の偶数は 2 つの素数の和で表すことができるということが知られています。これはゴールドバッハ予想といい、コンピュータの計算によりかなり大きな数まで正しいことが確かめられています。例えば、10 は、7 + 3、5 + 5 の 2 通りの素数の和で表すことができます。
</p>
<p>
整数 <var>n</var> を入力し、<var>n</var> を 2 つの素数の和で表す組み合わせ数が何通りあるかを出力するプログラムを作成してください。ただし、<var>n</var> は 4 以上、50,000 以下とします。また、入力される <var>n</var> は偶数であるとはかぎりません。
</p>
<H2>Input</H2>
<p>
複数のデータセットが与えられます。各データセットに <var>n</var> が１行に与えられます。<var>n</var> が 0 のとき入力の最後とします。データセットの数は 10,000 を超えません。
</p>
<H2>Output</H2>
<p>
各データセットに対して、<var>n</var> を 2 つの素数の和で表す組み合わせ数を１行に出力して下さい。
</p>
<H2>Sample Input</H2>
<pre>
10
11
0
</pre>
<H2>Output for the Sample Input</H2>
<pre>
2
0
</pre>
|
s017547588 | p00056 | Accepted | import math
r = 50001
sqrt = int(math.sqrt(r))
p = [1]*r
p[0] = 0
for i in range(1,sqrt):
if p[i]:
p[2*i+1::i+1] = [0 for x in range(2*i+1,r,i+1)]
prime = []
for i in range(len(p)):
if p[i] == 1:
prime.append(i+1)
while True:
n = int(raw_input())
if n == 0:
break
count = 0
for i in prime:
if i > n/2:
break
m = n - i
if p[m-1] == 1:
count += 1
print count | 10
11
0
| 2
0
|
<H1>ゴールドバッハの予想</H1>
<p>
4 以上の偶数は 2 つの素数の和で表すことができるということが知られています。これはゴールドバッハ予想といい、コンピュータの計算によりかなり大きな数まで正しいことが確かめられています。例えば、10 は、7 + 3、5 + 5 の 2 通りの素数の和で表すことができます。
</p>
<p>
整数 <var>n</var> を入力し、<var>n</var> を 2 つの素数の和で表す組み合わせ数が何通りあるかを出力するプログラムを作成してください。ただし、<var>n</var> は 4 以上、50,000 以下とします。また、入力される <var>n</var> は偶数であるとはかぎりません。
</p>
<H2>Input</H2>
<p>
複数のデータセットが与えられます。各データセットに <var>n</var> が１行に与えられます。<var>n</var> が 0 のとき入力の最後とします。データセットの数は 10,000 を超えません。
</p>
<H2>Output</H2>
<p>
各データセットに対して、<var>n</var> を 2 つの素数の和で表す組み合わせ数を１行に出力して下さい。
</p>
<H2>Sample Input</H2>
<pre>
10
11
0
</pre>
<H2>Output for the Sample Input</H2>
<pre>
2
0
</pre>
|
s130998065 | p00056 | Accepted | import sys
def sieve(m):
N=range(1,m+2,2)
r=int(m**.5)
h=len(N)
N[0]=0
for i in range(h):
x=N[i]
if x>r: break
if x and i+x<h: N[i+x:h:x]=[0]*((h-1-i-x)/x+1)
return N
def f0056(n):
x=0
if n<4:x=0
elif n==4:x=1
elif n%2==1:
if S[(n-2)/2]: x=1
else:
a=n/2
for e in PRIMES:
if e>a: break
if S[(n-e)/2]: x+=1
return x
S=sieve(50000)
PRIMES=filter(None,S)
for n in sys.stdin:
n=int(n)
if n==0: break
print f0056(n) | 10
11
0
| 2
0
|
<H1>ゴールドバッハの予想</H1>
<p>
4 以上の偶数は 2 つの素数の和で表すことができるということが知られています。これはゴールドバッハ予想といい、コンピュータの計算によりかなり大きな数まで正しいことが確かめられています。例えば、10 は、7 + 3、5 + 5 の 2 通りの素数の和で表すことができます。
</p>
<p>
整数 <var>n</var> を入力し、<var>n</var> を 2 つの素数の和で表す組み合わせ数が何通りあるかを出力するプログラムを作成してください。ただし、<var>n</var> は 4 以上、50,000 以下とします。また、入力される <var>n</var> は偶数であるとはかぎりません。
</p>
<H2>Input</H2>
<p>
複数のデータセットが与えられます。各データセットに <var>n</var> が１行に与えられます。<var>n</var> が 0 のとき入力の最後とします。データセットの数は 10,000 を超えません。
</p>
<H2>Output</H2>
<p>
各データセットに対して、<var>n</var> を 2 つの素数の和で表す組み合わせ数を１行に出力して下さい。
</p>
<H2>Sample Input</H2>
<pre>
10
11
0
</pre>
<H2>Output for the Sample Input</H2>
<pre>
2
0
</pre>
|
s639646791 | p00056 | Accepted | import sys
def sieve(m):
N=range(1,m+2,2)
r=int(m**.5)
h=len(N)
N[0]=0
i=0
while i<h:
x=N[i]
if x>r: break
if x and i+x<h: N[i+x:h:x]=[0]*((h-1-i-x)/x+1)
i+=1
return N
def f0056(n):
x=0
if n<4:x=0
elif n==4:x=1
elif n%2:
if S[(n-2)/2]: x=1
else:
a=n/2
for e in PRIMES:
if e>a: break
if S[(n-e)/2]: x+=1
return x
S=sieve(50000)
PRIMES=filter(None,S)
for n in sys.stdin:
n=int(n)
if n==0: break
print f0056(n) | 10
11
0
| 2
0
|
<H1>ゴールドバッハの予想</H1>
<p>
4 以上の偶数は 2 つの素数の和で表すことができるということが知られています。これはゴールドバッハ予想といい、コンピュータの計算によりかなり大きな数まで正しいことが確かめられています。例えば、10 は、7 + 3、5 + 5 の 2 通りの素数の和で表すことができます。
</p>
<p>
整数 <var>n</var> を入力し、<var>n</var> を 2 つの素数の和で表す組み合わせ数が何通りあるかを出力するプログラムを作成してください。ただし、<var>n</var> は 4 以上、50,000 以下とします。また、入力される <var>n</var> は偶数であるとはかぎりません。
</p>
<H2>Input</H2>
<p>
複数のデータセットが与えられます。各データセットに <var>n</var> が１行に与えられます。<var>n</var> が 0 のとき入力の最後とします。データセットの数は 10,000 を超えません。
</p>
<H2>Output</H2>
<p>
各データセットに対して、<var>n</var> を 2 つの素数の和で表す組み合わせ数を１行に出力して下さい。
</p>
<H2>Sample Input</H2>
<pre>
10
11
0
</pre>
<H2>Output for the Sample Input</H2>
<pre>
2
0
</pre>
|
s511441862 | p00056 | Accepted | import sys
def sieve(m):
N=range(1,m+2,2)
r=int(m**.5)
h=len(N)
N[0]=0
for i in range(h):
x=N[i]
if x>r: break
if x and i+x<h: N[i+x:h:x]=[0]*((h-1-i-x)/x+1)
return N
def f0056(n):
x=0
if n<4:x=0
elif n==4:x=1
elif n%2==1:
if S[n/2-1]: x=1
else:
a=n/2
for e in PRIMES:
if e>a: break
if S[(n-e)/2]: x+=1
return x
S=sieve(50000)
PRIMES=filter(None,S)
for n in sys.stdin:
n=int(n)
if n==0: break
print f0056(n) | 10
11
0
| 2
0
|
<H1>ゴールドバッハの予想</H1>
<p>
4 以上の偶数は 2 つの素数の和で表すことができるということが知られています。これはゴールドバッハ予想といい、コンピュータの計算によりかなり大きな数まで正しいことが確かめられています。例えば、10 は、7 + 3、5 + 5 の 2 通りの素数の和で表すことができます。
</p>
<p>
整数 <var>n</var> を入力し、<var>n</var> を 2 つの素数の和で表す組み合わせ数が何通りあるかを出力するプログラムを作成してください。ただし、<var>n</var> は 4 以上、50,000 以下とします。また、入力される <var>n</var> は偶数であるとはかぎりません。
</p>
<H2>Input</H2>
<p>
複数のデータセットが与えられます。各データセットに <var>n</var> が１行に与えられます。<var>n</var> が 0 のとき入力の最後とします。データセットの数は 10,000 を超えません。
</p>
<H2>Output</H2>
<p>
各データセットに対して、<var>n</var> を 2 つの素数の和で表す組み合わせ数を１行に出力して下さい。
</p>
<H2>Sample Input</H2>
<pre>
10
11
0
</pre>
<H2>Output for the Sample Input</H2>
<pre>
2
0
</pre>
|
s553556988 | p00056 | Accepted | from itertools import *
def sieve(n):
a = range(n)
a[:2] = None, None
for i in range(2, n):
if i ** 2 >= n: break
if not a[i]: continue
for i in range(i ** 2, n, i):
a[i] = None
return a
b = sieve(50000)
a = [v for v in b if v]
while True:
n = int(raw_input())
if n == 0: break
ct = 0
for v in a:
if v > n / 2: break
if b[n - v]:
ct += 1
print ct | 10
11
0
| 2
0
|
<H1>ゴールドバッハの予想</H1>
<p>
4 以上の偶数は 2 つの素数の和で表すことができるということが知られています。これはゴールドバッハ予想といい、コンピュータの計算によりかなり大きな数まで正しいことが確かめられています。例えば、10 は、7 + 3、5 + 5 の 2 通りの素数の和で表すことができます。
</p>
<p>
整数 <var>n</var> を入力し、<var>n</var> を 2 つの素数の和で表す組み合わせ数が何通りあるかを出力するプログラムを作成してください。ただし、<var>n</var> は 4 以上、50,000 以下とします。また、入力される <var>n</var> は偶数であるとはかぎりません。
</p>
<H2>Input</H2>
<p>
複数のデータセットが与えられます。各データセットに <var>n</var> が１行に与えられます。<var>n</var> が 0 のとき入力の最後とします。データセットの数は 10,000 を超えません。
</p>
<H2>Output</H2>
<p>
各データセットに対して、<var>n</var> を 2 つの素数の和で表す組み合わせ数を１行に出力して下さい。
</p>
<H2>Sample Input</H2>
<pre>
10
11
0
</pre>
<H2>Output for the Sample Input</H2>
<pre>
2
0
</pre>
|
s580541092 | p00056 | Accepted | def sieve(n):
primes = [True] * n
primes[0] = primes[1] = False
for i in xrange(2, int(n ** 0.5) + 1):
if primes[i]:
for j in xrange(i * i, n, i):
primes[j] = False
return [i for i in xrange(n) if primes[i]]
primes_a = sieve(25000)
primes_b = set(sieve(50000))
while 1:
n = input()
if n == 0:
break
ret = 0
for prime in primes_a:
if prime > n / 2:
break
if n - prime in primes_b:
ret += 1
print ret | 10
11
0
| 2
0
|
<H1>ゴールドバッハの予想</H1>
<p>
4 以上の偶数は 2 つの素数の和で表すことができるということが知られています。これはゴールドバッハ予想といい、コンピュータの計算によりかなり大きな数まで正しいことが確かめられています。例えば、10 は、7 + 3、5 + 5 の 2 通りの素数の和で表すことができます。
</p>
<p>
整数 <var>n</var> を入力し、<var>n</var> を 2 つの素数の和で表す組み合わせ数が何通りあるかを出力するプログラムを作成してください。ただし、<var>n</var> は 4 以上、50,000 以下とします。また、入力される <var>n</var> は偶数であるとはかぎりません。
</p>
<H2>Input</H2>
<p>
複数のデータセットが与えられます。各データセットに <var>n</var> が１行に与えられます。<var>n</var> が 0 のとき入力の最後とします。データセットの数は 10,000 を超えません。
</p>
<H2>Output</H2>
<p>
各データセットに対して、<var>n</var> を 2 つの素数の和で表す組み合わせ数を１行に出力して下さい。
</p>
<H2>Sample Input</H2>
<pre>
10
11
0
</pre>
<H2>Output for the Sample Input</H2>
<pre>
2
0
</pre>
|
s141714808 | p00056 | Accepted | def sieve(n):
primes = [True] * n
primes[0] = primes[1] = False
for i in xrange(2, int(n ** 0.5) + 1):
if primes[i]:
for j in xrange(i * i, n, i):
primes[j] = False
return [i for i in xrange(n) if primes[i]]
primes = sieve(50000)
ret = [0] * 100001
for i in xrange(len(primes)):
for j in xrange(i, len(primes)):
tmp = primes[i] + primes[j]
if tmp > 50000:
break
ret[tmp] += 1
while 1:
n = input()
if n == 0:
break
print ret[n] | 10
11
0
| 2
0
|
<H1>ゴールドバッハの予想</H1>
<p>
4 以上の偶数は 2 つの素数の和で表すことができるということが知られています。これはゴールドバッハ予想といい、コンピュータの計算によりかなり大きな数まで正しいことが確かめられています。例えば、10 は、7 + 3、5 + 5 の 2 通りの素数の和で表すことができます。
</p>
<p>
整数 <var>n</var> を入力し、<var>n</var> を 2 つの素数の和で表す組み合わせ数が何通りあるかを出力するプログラムを作成してください。ただし、<var>n</var> は 4 以上、50,000 以下とします。また、入力される <var>n</var> は偶数であるとはかぎりません。
</p>
<H2>Input</H2>
<p>
複数のデータセットが与えられます。各データセットに <var>n</var> が１行に与えられます。<var>n</var> が 0 のとき入力の最後とします。データセットの数は 10,000 を超えません。
</p>
<H2>Output</H2>
<p>
各データセットに対して、<var>n</var> を 2 つの素数の和で表す組み合わせ数を１行に出力して下さい。
</p>
<H2>Sample Input</H2>
<pre>
10
11
0
</pre>
<H2>Output for the Sample Input</H2>
<pre>
2
0
</pre>
|
s617451297 | p00056 | Accepted | def sieve(n):
primes = [True] * n
primes[0] = primes[1] = False
for i in xrange(2, int(n ** 0.5) + 1):
if primes[i]:
for j in xrange(i * i, n, i):
primes[j] = False
return [i for i in xrange(n) if primes[i]]
primes = sieve(50000)
ret = [0] * 50001
for i in xrange(len(primes)):
for j in xrange(i, len(primes)):
tmp = primes[i] + primes[j]
if tmp > 50000:
break
ret[tmp] += 1
while 1:
n = int(input())
if n == 0:
break
print ret[n] | 10
11
0
| 2
0
|
<H1>ゴールドバッハの予想</H1>
<p>
4 以上の偶数は 2 つの素数の和で表すことができるということが知られています。これはゴールドバッハ予想といい、コンピュータの計算によりかなり大きな数まで正しいことが確かめられています。例えば、10 は、7 + 3、5 + 5 の 2 通りの素数の和で表すことができます。
</p>
<p>
整数 <var>n</var> を入力し、<var>n</var> を 2 つの素数の和で表す組み合わせ数が何通りあるかを出力するプログラムを作成してください。ただし、<var>n</var> は 4 以上、50,000 以下とします。また、入力される <var>n</var> は偶数であるとはかぎりません。
</p>
<H2>Input</H2>
<p>
複数のデータセットが与えられます。各データセットに <var>n</var> が１行に与えられます。<var>n</var> が 0 のとき入力の最後とします。データセットの数は 10,000 を超えません。
</p>
<H2>Output</H2>
<p>
各データセットに対して、<var>n</var> を 2 つの素数の和で表す組み合わせ数を１行に出力して下さい。
</p>
<H2>Sample Input</H2>
<pre>
10
11
0
</pre>
<H2>Output for the Sample Input</H2>
<pre>
2
0
</pre>
|
s103179588 | p00056 | Accepted | def sieve(n):
primes = [True] * n
primes[0] = primes[1] = False
for i in xrange(2, int(n ** 0.5) + 1):
if primes[i]:
for j in xrange(i * i, n, i):
primes[j] = False
return [i for i in xrange(n) if primes[i]]
primes = sieve(50000)
ret = [0] * 50001
for i in xrange(len(primes)):
for j in xrange(i, len(primes)):
tmp = primes[i] + primes[j]
if tmp > 50000:
break
ret[tmp] += 1
while 1:
n = int(raw_input())
if n == 0:
break
print ret[n] | 10
11
0
| 2
0
|
<H1>ゴールドバッハの予想</H1>
<p>
4 以上の偶数は 2 つの素数の和で表すことができるということが知られています。これはゴールドバッハ予想といい、コンピュータの計算によりかなり大きな数まで正しいことが確かめられています。例えば、10 は、7 + 3、5 + 5 の 2 通りの素数の和で表すことができます。
</p>
<p>
整数 <var>n</var> を入力し、<var>n</var> を 2 つの素数の和で表す組み合わせ数が何通りあるかを出力するプログラムを作成してください。ただし、<var>n</var> は 4 以上、50,000 以下とします。また、入力される <var>n</var> は偶数であるとはかぎりません。
</p>
<H2>Input</H2>
<p>
複数のデータセットが与えられます。各データセットに <var>n</var> が１行に与えられます。<var>n</var> が 0 のとき入力の最後とします。データセットの数は 10,000 を超えません。
</p>
<H2>Output</H2>
<p>
各データセットに対して、<var>n</var> を 2 つの素数の和で表す組み合わせ数を１行に出力して下さい。
</p>
<H2>Sample Input</H2>
<pre>
10
11
0
</pre>
<H2>Output for the Sample Input</H2>
<pre>
2
0
</pre>
|
s117369313 | p00056 | Accepted | import sys
def sieve(m):
N=range(1,m+2,2)
r=int(m**.5)
h=len(N)
N[0]=0
for i in range(h):
x=N[i]
if x>r: break
if x and i+x<h: N[i+x:h:x]=[0]*((h-1-i-x)/x+1)
return N
def f0056(n):
x=0
if n<4:x=0
elif n==4:x=1
elif n%2==1:
if S[(n-2)/2]: x=1
else:
a=n/2
for e in PRIMES:
if e>a: break
if S[(n-e)/2]: x+=1
return x
S=sieve(50000)
PRIMES=filter(None,S)
for n in sys.stdin:
n=int(n)
if n==0: break
print f0056(n) | 10
11
0
| 2
0
|
<H1>ゴールドバッハの予想</H1>
<p>
4 以上の偶数は 2 つの素数の和で表すことができるということが知られています。これはゴールドバッハ予想といい、コンピュータの計算によりかなり大きな数まで正しいことが確かめられています。例えば、10 は、7 + 3、5 + 5 の 2 通りの素数の和で表すことができます。
</p>
<p>
整数 <var>n</var> を入力し、<var>n</var> を 2 つの素数の和で表す組み合わせ数が何通りあるかを出力するプログラムを作成してください。ただし、<var>n</var> は 4 以上、50,000 以下とします。また、入力される <var>n</var> は偶数であるとはかぎりません。
</p>
<H2>Input</H2>
<p>
複数のデータセットが与えられます。各データセットに <var>n</var> が１行に与えられます。<var>n</var> が 0 のとき入力の最後とします。データセットの数は 10,000 を超えません。
</p>
<H2>Output</H2>
<p>
各データセットに対して、<var>n</var> を 2 つの素数の和で表す組み合わせ数を１行に出力して下さい。
</p>
<H2>Sample Input</H2>
<pre>
10
11
0
</pre>
<H2>Output for the Sample Input</H2>
<pre>
2
0
</pre>
|
s901153595 | p00056 | Accepted | N = 50000
t = [1]*(N)
p = [2]
d = {2:1}
for i in range(3, N, 2):
if t[i]:
p.append(i)
d[i] = 1
for j in range(3*i, N, 2*i): t[j] = 0
while True:
n = int(input())
if n == 0: break
count = 0
if n % 2:
if n - 2 in p: count += 1
else:
for p1 in p:
if 2*p1 > n: break
if n - p1 in d:
count += 1
print(count) | 10
11
0
| 2
0
|
<H1>ゴールドバッハの予想</H1>
<p>
4 以上の偶数は 2 つの素数の和で表すことができるということが知られています。これはゴールドバッハ予想といい、コンピュータの計算によりかなり大きな数まで正しいことが確かめられています。例えば、10 は、7 + 3、5 + 5 の 2 通りの素数の和で表すことができます。
</p>
<p>
整数 <var>n</var> を入力し、<var>n</var> を 2 つの素数の和で表す組み合わせ数が何通りあるかを出力するプログラムを作成してください。ただし、<var>n</var> は 4 以上、50,000 以下とします。また、入力される <var>n</var> は偶数であるとはかぎりません。
</p>
<H2>Input</H2>
<p>
複数のデータセットが与えられます。各データセットに <var>n</var> が１行に与えられます。<var>n</var> が 0 のとき入力の最後とします。データセットの数は 10,000 を超えません。
</p>
<H2>Output</H2>
<p>
各データセットに対して、<var>n</var> を 2 つの素数の和で表す組み合わせ数を１行に出力して下さい。
</p>
<H2>Sample Input</H2>
<pre>
10
11
0
</pre>
<H2>Output for the Sample Input</H2>
<pre>
2
0
</pre>
|
s524941067 | p00056 | Accepted | import sys
N = 50000
t = [1]*(N)
p = [2]
d = {2:1}
for i in range(3, N, 2):
if t[i]:
p.append(i)
d[i] = 1
for j in range(3*i, N, 2*i): t[j] = 0
while True:
n = int(sys.stdin.readline())
if n == 0: break
count = 0
if n % 2:
if n - 2 in p: count += 1
else:
for p1 in p:
if 2*p1 > n: break
if n - p1 in d:
count += 1
print(count) | 10
11
0
| 2
0
|
<H1>ゴールドバッハの予想</H1>
<p>
4 以上の偶数は 2 つの素数の和で表すことができるということが知られています。これはゴールドバッハ予想といい、コンピュータの計算によりかなり大きな数まで正しいことが確かめられています。例えば、10 は、7 + 3、5 + 5 の 2 通りの素数の和で表すことができます。
</p>
<p>
整数 <var>n</var> を入力し、<var>n</var> を 2 つの素数の和で表す組み合わせ数が何通りあるかを出力するプログラムを作成してください。ただし、<var>n</var> は 4 以上、50,000 以下とします。また、入力される <var>n</var> は偶数であるとはかぎりません。
</p>
<H2>Input</H2>
<p>
複数のデータセットが与えられます。各データセットに <var>n</var> が１行に与えられます。<var>n</var> が 0 のとき入力の最後とします。データセットの数は 10,000 を超えません。
</p>
<H2>Output</H2>
<p>
各データセットに対して、<var>n</var> を 2 つの素数の和で表す組み合わせ数を１行に出力して下さい。
</p>
<H2>Sample Input</H2>
<pre>
10
11
0
</pre>
<H2>Output for the Sample Input</H2>
<pre>
2
0
</pre>
|
s428592835 | p00056 | Accepted | import sys
readline = sys.stdin.readline
write = sys.stdout.write
L = 50000
sq = int(L**.5)
p = [1]*(L+1)
p[0] = p[1] = 0
pn = []
for x in range(sq+1):
if not p[x]:
continue
for y in range(x*x, L+1, x):
p[y] = 0
pn.append(x)
for x in range(sq+1, L+1):
if not p[x]:
continue
pn.append(x)
pp = [0]*(L+1)
L0 = len(pn)
for i in range(L0):
x = pn[i]
for j in range(i+1):
z = x + pn[j]
if z > L:
break
pp[z] += 1
def solve():
N = int(readline())
if N == 0:
return False
write("%d\n" % pp[N])
return True
while solve():
...
| 10
11
0
| 2
0
|
<H1>ゴールドバッハの予想</H1>
<p>
4 以上の偶数は 2 つの素数の和で表すことができるということが知られています。これはゴールドバッハ予想といい、コンピュータの計算によりかなり大きな数まで正しいことが確かめられています。例えば、10 は、7 + 3、5 + 5 の 2 通りの素数の和で表すことができます。
</p>
<p>
整数 <var>n</var> を入力し、<var>n</var> を 2 つの素数の和で表す組み合わせ数が何通りあるかを出力するプログラムを作成してください。ただし、<var>n</var> は 4 以上、50,000 以下とします。また、入力される <var>n</var> は偶数であるとはかぎりません。
</p>
<H2>Input</H2>
<p>
複数のデータセットが与えられます。各データセットに <var>n</var> が１行に与えられます。<var>n</var> が 0 のとき入力の最後とします。データセットの数は 10,000 を超えません。
</p>
<H2>Output</H2>
<p>
各データセットに対して、<var>n</var> を 2 つの素数の和で表す組み合わせ数を１行に出力して下さい。
</p>
<H2>Sample Input</H2>
<pre>
10
11
0
</pre>
<H2>Output for the Sample Input</H2>
<pre>
2
0
</pre>
|
s053368510 | p00056 | Accepted | #4から50000までの素数を見つけ出す
MAX=50001
SQRT=233
num=[True for i in range(MAX)]
def prime(num):
num[0]=num[1]=False
for i in range(4,MAX,2):
num[i]=False
for i in range(2,SQRT+1):
if num[i]==True:
for j in range(i*i,MAX,i):
num[j]=False
prime(num)
prime_num=[i for i in range(MAX) if num[i]==True]
#print(len(num))
def count(num,n):
#数える処理
total=0
#足していく
for i in prime_num:
if i>(n/2):
break
if num[n-i]==True:
#print(i)
total+=1
return total
while True:
n=int(input())
if n==0:
break
print(count(num,n))
| 10
11
0
| 2
0
|
<H1>ゴールドバッハの予想</H1>
<p>
4 以上の偶数は 2 つの素数の和で表すことができるということが知られています。これはゴールドバッハ予想といい、コンピュータの計算によりかなり大きな数まで正しいことが確かめられています。例えば、10 は、7 + 3、5 + 5 の 2 通りの素数の和で表すことができます。
</p>
<p>
整数 <var>n</var> を入力し、<var>n</var> を 2 つの素数の和で表す組み合わせ数が何通りあるかを出力するプログラムを作成してください。ただし、<var>n</var> は 4 以上、50,000 以下とします。また、入力される <var>n</var> は偶数であるとはかぎりません。
</p>
<H2>Input</H2>
<p>
複数のデータセットが与えられます。各データセットに <var>n</var> が１行に与えられます。<var>n</var> が 0 のとき入力の最後とします。データセットの数は 10,000 を超えません。
</p>
<H2>Output</H2>
<p>
各データセットに対して、<var>n</var> を 2 つの素数の和で表す組み合わせ数を１行に出力して下さい。
</p>
<H2>Sample Input</H2>
<pre>
10
11
0
</pre>
<H2>Output for the Sample Input</H2>
<pre>
2
0
</pre>
|
s288271429 | p00056 | Accepted | import math
num = 50000
L = [True] * (num+1)
L[0] = L[1] = False
sqrt = int(num**0.5) +1
for i in range(2, sqrt):
if L[i] == False:
continue
for j in range(i*2,num+1,i):
L[j] = False
p = [x for x in range(num+1) if L[x] ]
#pset = set(p)
while True:
num = int(input())
if num == 0:
break
half = num // 2
c = 0
for i in p:
if i > half:
break
j = num - i
if L[j]:
c += 1
print(c)
| 10
11
0
| 2
0
|
<H1>ゴールドバッハの予想</H1>
<p>
4 以上の偶数は 2 つの素数の和で表すことができるということが知られています。これはゴールドバッハ予想といい、コンピュータの計算によりかなり大きな数まで正しいことが確かめられています。例えば、10 は、7 + 3、5 + 5 の 2 通りの素数の和で表すことができます。
</p>
<p>
整数 <var>n</var> を入力し、<var>n</var> を 2 つの素数の和で表す組み合わせ数が何通りあるかを出力するプログラムを作成してください。ただし、<var>n</var> は 4 以上、50,000 以下とします。また、入力される <var>n</var> は偶数であるとはかぎりません。
</p>
<H2>Input</H2>
<p>
複数のデータセットが与えられます。各データセットに <var>n</var> が１行に与えられます。<var>n</var> が 0 のとき入力の最後とします。データセットの数は 10,000 を超えません。
</p>
<H2>Output</H2>
<p>
各データセットに対して、<var>n</var> を 2 つの素数の和で表す組み合わせ数を１行に出力して下さい。
</p>
<H2>Sample Input</H2>
<pre>
10
11
0
</pre>
<H2>Output for the Sample Input</H2>
<pre>
2
0
</pre>
|
s533260287 | p00056 | Accepted | p = [1] * (50000 + 1)
p[0], p[1] = 0, 0
for i in range(2, int(50000 ** 0.5) + 1):
if not p[i]:
continue
for j in range(2 * i, 50000 + 1, i):
p[j] = 0
p_num = [i for i in range(50000 + 1) if p[i] == 1]
while 1:
n = int(input())
if (n == 0):
break
cnt = 0
for i in p_num:
if n // 2 < i:
break
if p[n - i]:
cnt += 1
print(cnt)
| 10
11
0
| 2
0
|
<H1>ゴールドバッハの予想</H1>
<p>
4 以上の偶数は 2 つの素数の和で表すことができるということが知られています。これはゴールドバッハ予想といい、コンピュータの計算によりかなり大きな数まで正しいことが確かめられています。例えば、10 は、7 + 3、5 + 5 の 2 通りの素数の和で表すことができます。
</p>
<p>
整数 <var>n</var> を入力し、<var>n</var> を 2 つの素数の和で表す組み合わせ数が何通りあるかを出力するプログラムを作成してください。ただし、<var>n</var> は 4 以上、50,000 以下とします。また、入力される <var>n</var> は偶数であるとはかぎりません。
</p>
<H2>Input</H2>
<p>
複数のデータセットが与えられます。各データセットに <var>n</var> が１行に与えられます。<var>n</var> が 0 のとき入力の最後とします。データセットの数は 10,000 を超えません。
</p>
<H2>Output</H2>
<p>
各データセットに対して、<var>n</var> を 2 つの素数の和で表す組み合わせ数を１行に出力して下さい。
</p>
<H2>Sample Input</H2>
<pre>
10
11
0
</pre>
<H2>Output for the Sample Input</H2>
<pre>
2
0
</pre>
|
s172077637 | p00056 | Accepted | LIM = 50001
# prepare primes
is_prime = [True for _ in range(LIM)]
is_prime[0] = is_prime[1] = False
# sieve of eratosthenes
for x in range(LIM//2 + 1):
if is_prime[x]:
for y in range(x*x, LIM, x):
is_prime[y] = False
primes = [x for x in range(LIM) if is_prime[x]]
# END `prepare primes`
count_arr = [0 for x in range(LIM)]
len_primes = len(primes)
for x in range(len_primes):
p = primes[x]
for y in range(x, len_primes):
q = primes[y]
if p+q >= LIM:
break
count_arr[p+q] += 1
while True:
n = int(input())
if n == 0:
break
print(count_arr[n])
| 10
11
0
| 2
0
|
<H1>ゴールドバッハの予想</H1>
<p>
4 以上の偶数は 2 つの素数の和で表すことができるということが知られています。これはゴールドバッハ予想といい、コンピュータの計算によりかなり大きな数まで正しいことが確かめられています。例えば、10 は、7 + 3、5 + 5 の 2 通りの素数の和で表すことができます。
</p>
<p>
整数 <var>n</var> を入力し、<var>n</var> を 2 つの素数の和で表す組み合わせ数が何通りあるかを出力するプログラムを作成してください。ただし、<var>n</var> は 4 以上、50,000 以下とします。また、入力される <var>n</var> は偶数であるとはかぎりません。
</p>
<H2>Input</H2>
<p>
複数のデータセットが与えられます。各データセットに <var>n</var> が１行に与えられます。<var>n</var> が 0 のとき入力の最後とします。データセットの数は 10,000 を超えません。
</p>
<H2>Output</H2>
<p>
各データセットに対して、<var>n</var> を 2 つの素数の和で表す組み合わせ数を１行に出力して下さい。
</p>
<H2>Sample Input</H2>
<pre>
10
11
0
</pre>
<H2>Output for the Sample Input</H2>
<pre>
2
0
</pre>
|
s330723535 | p00056 | Accepted | p = [True for i in range(50000)]
p[0] = 0
for i in range(2,int(50000**(1/2)+1)):
if p[i-1]:
for j in range(i**2,50000,i):
p[j-1] = False
prime = [i+1 for i in range(50000) if p[i]]
while(1):
n = int(input())
if not n:
break
count = 0
half = n//2
for i in prime:
if i > half:
break
if p[n - i - 1]:
count += 1
print(count)
| 10
11
0
| 2
0
|
<H1>ゴールドバッハの予想</H1>
<p>
4 以上の偶数は 2 つの素数の和で表すことができるということが知られています。これはゴールドバッハ予想といい、コンピュータの計算によりかなり大きな数まで正しいことが確かめられています。例えば、10 は、7 + 3、5 + 5 の 2 通りの素数の和で表すことができます。
</p>
<p>
整数 <var>n</var> を入力し、<var>n</var> を 2 つの素数の和で表す組み合わせ数が何通りあるかを出力するプログラムを作成してください。ただし、<var>n</var> は 4 以上、50,000 以下とします。また、入力される <var>n</var> は偶数であるとはかぎりません。
</p>
<H2>Input</H2>
<p>
複数のデータセットが与えられます。各データセットに <var>n</var> が１行に与えられます。<var>n</var> が 0 のとき入力の最後とします。データセットの数は 10,000 を超えません。
</p>
<H2>Output</H2>
<p>
各データセットに対して、<var>n</var> を 2 つの素数の和で表す組み合わせ数を１行に出力して下さい。
</p>
<H2>Sample Input</H2>
<pre>
10
11
0
</pre>
<H2>Output for the Sample Input</H2>
<pre>
2
0
</pre>
|
s222685241 | p00056 | Runtime Error | def make_ps(n):
tbl = [False, True, False, False, False, True] * (n // 6 + 1)
for i in range(1, 4):
tbl[i] = not tbl[i]
p, stp, sqrt = 5, 2, n ** 0.5
while p < sqrt:
for i in range(p ** 2, n, 2 * p):
tbl[i] = False
while True:
p += stp
stp = 6 - stp
if tbl[p]:
break
return [i for i in range(n) if tbl[i]]
ps = make_ps(n)
while True:
n = int(input())
if not n:
break
res = 0
if n % 2:
if n - 2 in ps:
res += 1
else:
res = 0
for p in ps:
if p > n / 2:
break
if n - p in ps:
res += 1
print(res) | 10
11
0
| 2
0
|
<H1>ゴールドバッハの予想</H1>
<p>
4 以上の偶数は 2 つの素数の和で表すことができるということが知られています。これはゴールドバッハ予想といい、コンピュータの計算によりかなり大きな数まで正しいことが確かめられています。例えば、10 は、7 + 3、5 + 5 の 2 通りの素数の和で表すことができます。
</p>
<p>
整数 <var>n</var> を入力し、<var>n</var> を 2 つの素数の和で表す組み合わせ数が何通りあるかを出力するプログラムを作成してください。ただし、<var>n</var> は 4 以上、50,000 以下とします。また、入力される <var>n</var> は偶数であるとはかぎりません。
</p>
<H2>Input</H2>
<p>
複数のデータセットが与えられます。各データセットに <var>n</var> が１行に与えられます。<var>n</var> が 0 のとき入力の最後とします。データセットの数は 10,000 を超えません。
</p>
<H2>Output</H2>
<p>
各データセットに対して、<var>n</var> を 2 つの素数の和で表す組み合わせ数を１行に出力して下さい。
</p>
<H2>Sample Input</H2>
<pre>
10
11
0
</pre>
<H2>Output for the Sample Input</H2>
<pre>
2
0
</pre>
|
s677725445 | p00056 | Runtime Error | N = 50001
lst = [True] * N
lst[0] = False
lst[1] = False
for i in range(2, int(N ** 0.5) + 1):
if lst[i]:
for j in range(i * i, N, i):
lst[j] = False
primes = [i for i in range(1, N) if lst[i]]
for s in sys.stdin:
n = int(s)
if n == 0:
break
elif n % 2 == 1:
if lst[n - 2]:
print(1)
else:
print(0)
elif n == 4:
print(1)
else:
counter = 0
for prime0 in primes:
prime1 = n - prime0
if prime0 <= prime1 and lst[prime1]:
#print(prime0, prime1)
counter += 1
print(counter) | 10
11
0
| 2
0
|
<H1>ゴールドバッハの予想</H1>
<p>
4 以上の偶数は 2 つの素数の和で表すことができるということが知られています。これはゴールドバッハ予想といい、コンピュータの計算によりかなり大きな数まで正しいことが確かめられています。例えば、10 は、7 + 3、5 + 5 の 2 通りの素数の和で表すことができます。
</p>
<p>
整数 <var>n</var> を入力し、<var>n</var> を 2 つの素数の和で表す組み合わせ数が何通りあるかを出力するプログラムを作成してください。ただし、<var>n</var> は 4 以上、50,000 以下とします。また、入力される <var>n</var> は偶数であるとはかぎりません。
</p>
<H2>Input</H2>
<p>
複数のデータセットが与えられます。各データセットに <var>n</var> が１行に与えられます。<var>n</var> が 0 のとき入力の最後とします。データセットの数は 10,000 を超えません。
</p>
<H2>Output</H2>
<p>
各データセットに対して、<var>n</var> を 2 つの素数の和で表す組み合わせ数を１行に出力して下さい。
</p>
<H2>Sample Input</H2>
<pre>
10
11
0
</pre>
<H2>Output for the Sample Input</H2>
<pre>
2
0
</pre>
|
s835115454 | p00056 | Runtime Error | import bisect
primes = [0, 0] + [1] * 49999
for i in range(2, 224):
if primes[i]:
for j in range(i*i, 50001, i):
primes[j] = 0
values = [i for i, k in enumerate(primes) if k]
while True:
n = int(input())
if n == 0:
break
I = bisect.bisect(values, n//2)
print([i for i, v in enumerate(values[:I]) if primes[n-v]][-1] + 1) | 10
11
0
| 2
0
|
<H1>ゴールドバッハの予想</H1>
<p>
4 以上の偶数は 2 つの素数の和で表すことができるということが知られています。これはゴールドバッハ予想といい、コンピュータの計算によりかなり大きな数まで正しいことが確かめられています。例えば、10 は、7 + 3、5 + 5 の 2 通りの素数の和で表すことができます。
</p>
<p>
整数 <var>n</var> を入力し、<var>n</var> を 2 つの素数の和で表す組み合わせ数が何通りあるかを出力するプログラムを作成してください。ただし、<var>n</var> は 4 以上、50,000 以下とします。また、入力される <var>n</var> は偶数であるとはかぎりません。
</p>
<H2>Input</H2>
<p>
複数のデータセットが与えられます。各データセットに <var>n</var> が１行に与えられます。<var>n</var> が 0 のとき入力の最後とします。データセットの数は 10,000 を超えません。
</p>
<H2>Output</H2>
<p>
各データセットに対して、<var>n</var> を 2 つの素数の和で表す組み合わせ数を１行に出力して下さい。
</p>
<H2>Sample Input</H2>
<pre>
10
11
0
</pre>
<H2>Output for the Sample Input</H2>
<pre>
2
0
</pre>
|
s221123097 | p00056 | Runtime Error | n = 50001
c = [1 for i in range(n)]
c[0] = 0
i = 2
while i**2 <= n:
j = i*2
while j <= n:
c[j - 1] = 0
j += i
i += 1
while True:
n = int(input())
if n == 0:
break
elif n%2 == 1:
print(0)
continue
cnt = 0
for i in range(n/2):
if c[i] == 1 and c[n-i] == 1:
cnt +=1
print(cnt)
| 10
11
0
| 2
0
|
<H1>ゴールドバッハの予想</H1>
<p>
4 以上の偶数は 2 つの素数の和で表すことができるということが知られています。これはゴールドバッハ予想といい、コンピュータの計算によりかなり大きな数まで正しいことが確かめられています。例えば、10 は、7 + 3、5 + 5 の 2 通りの素数の和で表すことができます。
</p>
<p>
整数 <var>n</var> を入力し、<var>n</var> を 2 つの素数の和で表す組み合わせ数が何通りあるかを出力するプログラムを作成してください。ただし、<var>n</var> は 4 以上、50,000 以下とします。また、入力される <var>n</var> は偶数であるとはかぎりません。
</p>
<H2>Input</H2>
<p>
複数のデータセットが与えられます。各データセットに <var>n</var> が１行に与えられます。<var>n</var> が 0 のとき入力の最後とします。データセットの数は 10,000 を超えません。
</p>
<H2>Output</H2>
<p>
各データセットに対して、<var>n</var> を 2 つの素数の和で表す組み合わせ数を１行に出力して下さい。
</p>
<H2>Sample Input</H2>
<pre>
10
11
0
</pre>
<H2>Output for the Sample Input</H2>
<pre>
2
0
</pre>
|
s417453957 | p00056 | Runtime Error | n = 30000
is_prime = [True for i in range(n)]
is_prime[0] = is_prime[1] = False
i = 2
while i**2 <= n:
j = i*2
while j < n:
is_prime[j] = False
j += i
i += 1
cnt_pair = [0 for i in range(n)]
for i in range(n):
if is_prime[i]:
for j in range(i, n):
if i + j >= n:
break
if is_prime[j]:
cnt_pair[i + j] += 1
while True:
n = int(input())
if n == 0:
break
print(cnt_pair[n])
| 10
11
0
| 2
0
|
<H1>ゴールドバッハの予想</H1>
<p>
4 以上の偶数は 2 つの素数の和で表すことができるということが知られています。これはゴールドバッハ予想といい、コンピュータの計算によりかなり大きな数まで正しいことが確かめられています。例えば、10 は、7 + 3、5 + 5 の 2 通りの素数の和で表すことができます。
</p>
<p>
整数 <var>n</var> を入力し、<var>n</var> を 2 つの素数の和で表す組み合わせ数が何通りあるかを出力するプログラムを作成してください。ただし、<var>n</var> は 4 以上、50,000 以下とします。また、入力される <var>n</var> は偶数であるとはかぎりません。
</p>
<H2>Input</H2>
<p>
複数のデータセットが与えられます。各データセットに <var>n</var> が１行に与えられます。<var>n</var> が 0 のとき入力の最後とします。データセットの数は 10,000 を超えません。
</p>
<H2>Output</H2>
<p>
各データセットに対して、<var>n</var> を 2 つの素数の和で表す組み合わせ数を１行に出力して下さい。
</p>
<H2>Sample Input</H2>
<pre>
10
11
0
</pre>
<H2>Output for the Sample Input</H2>
<pre>
2
0
</pre>
|
s140685066 | p00056 | Runtime Error | import bisect
from itertools import *
n=range(49994);a=list(n)
for i in range(2,224):a[i*2::i]=[0]*len(a[i*2::i])
p=list(compress(n,a))
for x in iter(input,'0'):
x=int(x)
y=bisect.bisect(p,x//2)
if x%2:print(sum(1 for c in p[1:y]if 2+c==x))
elif x-4:print(sum(1 for c in p[1:y]if a[x-c]))
else:print(1)
| 10
11
0
| 2
0
|
<H1>ゴールドバッハの予想</H1>
<p>
4 以上の偶数は 2 つの素数の和で表すことができるということが知られています。これはゴールドバッハ予想といい、コンピュータの計算によりかなり大きな数まで正しいことが確かめられています。例えば、10 は、7 + 3、5 + 5 の 2 通りの素数の和で表すことができます。
</p>
<p>
整数 <var>n</var> を入力し、<var>n</var> を 2 つの素数の和で表す組み合わせ数が何通りあるかを出力するプログラムを作成してください。ただし、<var>n</var> は 4 以上、50,000 以下とします。また、入力される <var>n</var> は偶数であるとはかぎりません。
</p>
<H2>Input</H2>
<p>
複数のデータセットが与えられます。各データセットに <var>n</var> が１行に与えられます。<var>n</var> が 0 のとき入力の最後とします。データセットの数は 10,000 を超えません。
</p>
<H2>Output</H2>
<p>
各データセットに対して、<var>n</var> を 2 つの素数の和で表す組み合わせ数を１行に出力して下さい。
</p>
<H2>Sample Input</H2>
<pre>
10
11
0
</pre>
<H2>Output for the Sample Input</H2>
<pre>
2
0
</pre>
|
s003698309 | p00056 | Runtime Error | import bisect
from itertools import *
n=range(49994);a=list(n)
for i in range(2,224):a[i*2::i]=[0]*len(a[i*2::i])
p=list(compress(n,a))
for x in iter(input,'0'):
x=int(x)
y=bisect.bisect(p,x//2)
if x%2:print(sum(1 for c in p[1:x]if 2+c==x))
elif x-4:print(sum(1 for c in p[1:y]if a[x-c]))
else:print(1)
| 10
11
0
| 2
0
|
<H1>ゴールドバッハの予想</H1>
<p>
4 以上の偶数は 2 つの素数の和で表すことができるということが知られています。これはゴールドバッハ予想といい、コンピュータの計算によりかなり大きな数まで正しいことが確かめられています。例えば、10 は、7 + 3、5 + 5 の 2 通りの素数の和で表すことができます。
</p>
<p>
整数 <var>n</var> を入力し、<var>n</var> を 2 つの素数の和で表す組み合わせ数が何通りあるかを出力するプログラムを作成してください。ただし、<var>n</var> は 4 以上、50,000 以下とします。また、入力される <var>n</var> は偶数であるとはかぎりません。
</p>
<H2>Input</H2>
<p>
複数のデータセットが与えられます。各データセットに <var>n</var> が１行に与えられます。<var>n</var> が 0 のとき入力の最後とします。データセットの数は 10,000 を超えません。
</p>
<H2>Output</H2>
<p>
各データセットに対して、<var>n</var> を 2 つの素数の和で表す組み合わせ数を１行に出力して下さい。
</p>
<H2>Sample Input</H2>
<pre>
10
11
0
</pre>
<H2>Output for the Sample Input</H2>
<pre>
2
0
</pre>
|
s135459611 | p00056 | Runtime Error | import bisect
from itertools import *
n=range(49994);a=list(n);a[1]=0
for i in range(2,224):a[i*2::i]=[0]*len(a[i*2::i])
p=list(compress(n,a))
for x in iter(input,'0'):
x=int(x)
if x%2:print(sum(2+c==x for c in p[:bisect.bisect(p,x)]))
elif x-4:print(sum(1 for c in p[:bisect.bisect(p,x//2)]if a[x-c]))
else:print(1)
| 10
11
0
| 2
0
|
<H1>ゴールドバッハの予想</H1>
<p>
4 以上の偶数は 2 つの素数の和で表すことができるということが知られています。これはゴールドバッハ予想といい、コンピュータの計算によりかなり大きな数まで正しいことが確かめられています。例えば、10 は、7 + 3、5 + 5 の 2 通りの素数の和で表すことができます。
</p>
<p>
整数 <var>n</var> を入力し、<var>n</var> を 2 つの素数の和で表す組み合わせ数が何通りあるかを出力するプログラムを作成してください。ただし、<var>n</var> は 4 以上、50,000 以下とします。また、入力される <var>n</var> は偶数であるとはかぎりません。
</p>
<H2>Input</H2>
<p>
複数のデータセットが与えられます。各データセットに <var>n</var> が１行に与えられます。<var>n</var> が 0 のとき入力の最後とします。データセットの数は 10,000 を超えません。
</p>
<H2>Output</H2>
<p>
各データセットに対して、<var>n</var> を 2 つの素数の和で表す組み合わせ数を１行に出力して下さい。
</p>
<H2>Sample Input</H2>
<pre>
10
11
0
</pre>
<H2>Output for the Sample Input</H2>
<pre>
2
0
</pre>
|
s974490623 | p00056 | Runtime Error | import bisect
from itertools import *
n=range(49994);a=list(n);a[1]=0
for i in range(2,224):a[i*2::i]=[0]*len(a[i*2::i])
p=list(compress(n,a))
for x in iter(input,'0'):
x=int(x)
if x%2:print(sum(2+c==x for c in p[:bisect.bisect(p,x)-1]))
elif x-4:print(sum(1 for c in p[:bisect.bisect(p,x//2)]if a[x-c]))
else:print(1)
| 10
11
0
| 2
0
|
<H1>ゴールドバッハの予想</H1>
<p>
4 以上の偶数は 2 つの素数の和で表すことができるということが知られています。これはゴールドバッハ予想といい、コンピュータの計算によりかなり大きな数まで正しいことが確かめられています。例えば、10 は、7 + 3、5 + 5 の 2 通りの素数の和で表すことができます。
</p>
<p>
整数 <var>n</var> を入力し、<var>n</var> を 2 つの素数の和で表す組み合わせ数が何通りあるかを出力するプログラムを作成してください。ただし、<var>n</var> は 4 以上、50,000 以下とします。また、入力される <var>n</var> は偶数であるとはかぎりません。
</p>
<H2>Input</H2>
<p>
複数のデータセットが与えられます。各データセットに <var>n</var> が１行に与えられます。<var>n</var> が 0 のとき入力の最後とします。データセットの数は 10,000 を超えません。
</p>
<H2>Output</H2>
<p>
各データセットに対して、<var>n</var> を 2 つの素数の和で表す組み合わせ数を１行に出力して下さい。
</p>
<H2>Sample Input</H2>
<pre>
10
11
0
</pre>
<H2>Output for the Sample Input</H2>
<pre>
2
0
</pre>
|
s684846560 | p00056 | Runtime Error | import bisect,sys
from itertools import *
n=range(50001);a=list(n);a[1]=0
for i in range(2,224):a[i*2::i]=[0]*len(a[i*2::i])
p=list(compress(n,a))
for x in map(int,sys.stdin):
if x:print(len(1 for d in p[:bisect.bisect(p,x//2)]if a[x-d]))
| 10
11
0
| 2
0
|
<H1>ゴールドバッハの予想</H1>
<p>
4 以上の偶数は 2 つの素数の和で表すことができるということが知られています。これはゴールドバッハ予想といい、コンピュータの計算によりかなり大きな数まで正しいことが確かめられています。例えば、10 は、7 + 3、5 + 5 の 2 通りの素数の和で表すことができます。
</p>
<p>
整数 <var>n</var> を入力し、<var>n</var> を 2 つの素数の和で表す組み合わせ数が何通りあるかを出力するプログラムを作成してください。ただし、<var>n</var> は 4 以上、50,000 以下とします。また、入力される <var>n</var> は偶数であるとはかぎりません。
</p>
<H2>Input</H2>
<p>
複数のデータセットが与えられます。各データセットに <var>n</var> が１行に与えられます。<var>n</var> が 0 のとき入力の最後とします。データセットの数は 10,000 を超えません。
</p>
<H2>Output</H2>
<p>
各データセットに対して、<var>n</var> を 2 つの素数の和で表す組み合わせ数を１行に出力して下さい。
</p>
<H2>Sample Input</H2>
<pre>
10
11
0
</pre>
<H2>Output for the Sample Input</H2>
<pre>
2
0
</pre>
|
s832880195 | p00056 | Runtime Error | MAX = 50001
is_prime = [True for _ in range(MAX)]
is_prime[0] = is_prime[1] = False
for i in range(2, int(MAX ** (1 / 2)) + 1):
if is_prime[i]:
for j in range(i ** 2, MAX, i):
is_prime[j] = False
primes = [i for i in range(MAX) if is_prime[i]]
def main():
while True:
n = int(input())
if not n:
break
ans = 0
for i in primes_less_than_n:
if is_prime[n - i]:
ans += 1
print(ans)
main()
| 10
11
0
| 2
0
|
<H1>ゴールドバッハの予想</H1>
<p>
4 以上の偶数は 2 つの素数の和で表すことができるということが知られています。これはゴールドバッハ予想といい、コンピュータの計算によりかなり大きな数まで正しいことが確かめられています。例えば、10 は、7 + 3、5 + 5 の 2 通りの素数の和で表すことができます。
</p>
<p>
整数 <var>n</var> を入力し、<var>n</var> を 2 つの素数の和で表す組み合わせ数が何通りあるかを出力するプログラムを作成してください。ただし、<var>n</var> は 4 以上、50,000 以下とします。また、入力される <var>n</var> は偶数であるとはかぎりません。
</p>
<H2>Input</H2>
<p>
複数のデータセットが与えられます。各データセットに <var>n</var> が１行に与えられます。<var>n</var> が 0 のとき入力の最後とします。データセットの数は 10,000 を超えません。
</p>
<H2>Output</H2>
<p>
各データセットに対して、<var>n</var> を 2 つの素数の和で表す組み合わせ数を１行に出力して下さい。
</p>
<H2>Sample Input</H2>
<pre>
10
11
0
</pre>
<H2>Output for the Sample Input</H2>
<pre>
2
0
</pre>
|
s131703709 | p00056 | Runtime Error | n=5*10**4
p=[True]*n
p[0],p[1]=False,False
for i in xrange(2,int(n**0.5)+1):
if p[i]==True:
for j in xrange(i**2,n,i):
p[j]=False
while True:
n=input()
if n==0:break
for i in xrange(n/2+1):
if p[i] and p[n-i]:c+=1
print c | 10
11
0
| 2
0
|
<H1>ゴールドバッハの予想</H1>
<p>
4 以上の偶数は 2 つの素数の和で表すことができるということが知られています。これはゴールドバッハ予想といい、コンピュータの計算によりかなり大きな数まで正しいことが確かめられています。例えば、10 は、7 + 3、5 + 5 の 2 通りの素数の和で表すことができます。
</p>
<p>
整数 <var>n</var> を入力し、<var>n</var> を 2 つの素数の和で表す組み合わせ数が何通りあるかを出力するプログラムを作成してください。ただし、<var>n</var> は 4 以上、50,000 以下とします。また、入力される <var>n</var> は偶数であるとはかぎりません。
</p>
<H2>Input</H2>
<p>
複数のデータセットが与えられます。各データセットに <var>n</var> が１行に与えられます。<var>n</var> が 0 のとき入力の最後とします。データセットの数は 10,000 を超えません。
</p>
<H2>Output</H2>
<p>
各データセットに対して、<var>n</var> を 2 つの素数の和で表す組み合わせ数を１行に出力して下さい。
</p>
<H2>Sample Input</H2>
<pre>
10
11
0
</pre>
<H2>Output for the Sample Input</H2>
<pre>
2
0
</pre>
|
s137158815 | p00056 | Runtime Error | N=5000+1
p=[True]*N
p[0],p[1]=False,False
for i in xrange(2,int(N**0.5)+1):
if p[i]==True:
for j in xrange(i**2,N,i):
p[j]=False
c=[0]*N
for i in xrange(N):
for j in xrange(i/2+1):
if p[j] and p[i-j]:c[i]+=1
while True:
n=input()
if n==0:break
print c[n] | 10
11
0
| 2
0
|
<H1>ゴールドバッハの予想</H1>
<p>
4 以上の偶数は 2 つの素数の和で表すことができるということが知られています。これはゴールドバッハ予想といい、コンピュータの計算によりかなり大きな数まで正しいことが確かめられています。例えば、10 は、7 + 3、5 + 5 の 2 通りの素数の和で表すことができます。
</p>
<p>
整数 <var>n</var> を入力し、<var>n</var> を 2 つの素数の和で表す組み合わせ数が何通りあるかを出力するプログラムを作成してください。ただし、<var>n</var> は 4 以上、50,000 以下とします。また、入力される <var>n</var> は偶数であるとはかぎりません。
</p>
<H2>Input</H2>
<p>
複数のデータセットが与えられます。各データセットに <var>n</var> が１行に与えられます。<var>n</var> が 0 のとき入力の最後とします。データセットの数は 10,000 を超えません。
</p>
<H2>Output</H2>
<p>
各データセットに対して、<var>n</var> を 2 つの素数の和で表す組み合わせ数を１行に出力して下さい。
</p>
<H2>Sample Input</H2>
<pre>
10
11
0
</pre>
<H2>Output for the Sample Input</H2>
<pre>
2
0
</pre>
|
s041065121 | p00056 | Runtime Error | import sys
def sieve(m):
N=range(1,m+2,2)
r=int(m**.5)
h=len(N)
N[0]=0
for i in range(h):
x=N[i]
if x>r: break
if x and i+x<h: N[i+x:h:x]=[0] * ((h-1-i-x)/x+1)
return N
def f0056(n):
x=0
if n%2==1:
if SIEVES[(n-2)/2]!=0: x=1
else:
for e in PRIMES:
if e>n/2: break
if SIEVES[(n-e)/2]!=0]:x+=1
return x
SIEVES=sieve(50000)
PRIMES=filter(None,SIEVES)
for n in sys.stdin:
n=int(n)
if n==0: break
print f0056(n) | 10
11
0
| 2
0
|
<H1>ゴールドバッハの予想</H1>
<p>
4 以上の偶数は 2 つの素数の和で表すことができるということが知られています。これはゴールドバッハ予想といい、コンピュータの計算によりかなり大きな数まで正しいことが確かめられています。例えば、10 は、7 + 3、5 + 5 の 2 通りの素数の和で表すことができます。
</p>
<p>
整数 <var>n</var> を入力し、<var>n</var> を 2 つの素数の和で表す組み合わせ数が何通りあるかを出力するプログラムを作成してください。ただし、<var>n</var> は 4 以上、50,000 以下とします。また、入力される <var>n</var> は偶数であるとはかぎりません。
</p>
<H2>Input</H2>
<p>
複数のデータセットが与えられます。各データセットに <var>n</var> が１行に与えられます。<var>n</var> が 0 のとき入力の最後とします。データセットの数は 10,000 を超えません。
</p>
<H2>Output</H2>
<p>
各データセットに対して、<var>n</var> を 2 つの素数の和で表す組み合わせ数を１行に出力して下さい。
</p>
<H2>Sample Input</H2>
<pre>
10
11
0
</pre>
<H2>Output for the Sample Input</H2>
<pre>
2
0
</pre>
|
s425896229 | p00056 | Runtime Error | def sieve(m):
N=range(1,m+2,2)
r=int(m**.5)
h=len(N)
N[0]=0
for i in range(h):
x=N[i]
if x>r: break
if x and i+x<h: N[i+x:h:x]=[0]*((h-1-i-x)/x+1)
return N
def f0056(n):
x=0
if n<4:x=0
elif n==4:x=1
elif n%2==1:
if S[(n-2)/2]:
x=1
else:
a=n/2
for e in PRIMES:
if e>a: break
if S[(n-e)/2]:
x+=1
return x
S=sieve(50000)
PRIMES=filter(None,S)
for n in sys.stdin:
n=int(n)
if n==0: break
print f0056(n) | 10
11
0
| 2
0
|
<H1>ゴールドバッハの予想</H1>
<p>
4 以上の偶数は 2 つの素数の和で表すことができるということが知られています。これはゴールドバッハ予想といい、コンピュータの計算によりかなり大きな数まで正しいことが確かめられています。例えば、10 は、7 + 3、5 + 5 の 2 通りの素数の和で表すことができます。
</p>
<p>
整数 <var>n</var> を入力し、<var>n</var> を 2 つの素数の和で表す組み合わせ数が何通りあるかを出力するプログラムを作成してください。ただし、<var>n</var> は 4 以上、50,000 以下とします。また、入力される <var>n</var> は偶数であるとはかぎりません。
</p>
<H2>Input</H2>
<p>
複数のデータセットが与えられます。各データセットに <var>n</var> が１行に与えられます。<var>n</var> が 0 のとき入力の最後とします。データセットの数は 10,000 を超えません。
</p>
<H2>Output</H2>
<p>
各データセットに対して、<var>n</var> を 2 つの素数の和で表す組み合わせ数を１行に出力して下さい。
</p>
<H2>Sample Input</H2>
<pre>
10
11
0
</pre>
<H2>Output for the Sample Input</H2>
<pre>
2
0
</pre>
|
s550157257 | p00056 | Runtime Error | r = 50001
sqrt = int(math.sqrt(r))
p = [1]*r
p[0] = 0
for i in range(1,sqrt):
if p[i]:
p[2*i+1::i+1] = [0 for x in range(2*i+1,r,i+1)]
while True:
n = int(raw_input())
if n == 0:
break
count = 0
for i in range(n/2):
if p[i] == 1:
m = n - (i+1)
if p[m-1] == 1:
count += 1
print count | 10
11
0
| 2
0
|
<H1>ゴールドバッハの予想</H1>
<p>
4 以上の偶数は 2 つの素数の和で表すことができるということが知られています。これはゴールドバッハ予想といい、コンピュータの計算によりかなり大きな数まで正しいことが確かめられています。例えば、10 は、7 + 3、5 + 5 の 2 通りの素数の和で表すことができます。
</p>
<p>
整数 <var>n</var> を入力し、<var>n</var> を 2 つの素数の和で表す組み合わせ数が何通りあるかを出力するプログラムを作成してください。ただし、<var>n</var> は 4 以上、50,000 以下とします。また、入力される <var>n</var> は偶数であるとはかぎりません。
</p>
<H2>Input</H2>
<p>
複数のデータセットが与えられます。各データセットに <var>n</var> が１行に与えられます。<var>n</var> が 0 のとき入力の最後とします。データセットの数は 10,000 を超えません。
</p>
<H2>Output</H2>
<p>
各データセットに対して、<var>n</var> を 2 つの素数の和で表す組み合わせ数を１行に出力して下さい。
</p>
<H2>Sample Input</H2>
<pre>
10
11
0
</pre>
<H2>Output for the Sample Input</H2>
<pre>
2
0
</pre>
|
s323460879 | p00056 | Runtime Error | def enum_prime(m):
L = [True for _ in range(m + 1)]
L[0] = L[1] = False
for i in range(2, m + 1):
if L[i]:
for j in range(i + i, m + 1, i):
L[j] = False
if m < i * i:
break
return L
FLAGS = enum_prime(50000)
PRIMES = [i for i, isprime in enumerate(FLAGS) if isprime]
while True:
n = int(input())
n2 = n // 2
cnt = 0
if n % 2 == 0:
for p in PRIMES:
if p > n2:
break
if FLAGS[n - p]:
cnt += 1
elif FLAGS[n - 2]:
cnt = 1
print(cnt) | 10
11
0
| 2
0
|
<H1>ゴールドバッハの予想</H1>
<p>
4 以上の偶数は 2 つの素数の和で表すことができるということが知られています。これはゴールドバッハ予想といい、コンピュータの計算によりかなり大きな数まで正しいことが確かめられています。例えば、10 は、7 + 3、5 + 5 の 2 通りの素数の和で表すことができます。
</p>
<p>
整数 <var>n</var> を入力し、<var>n</var> を 2 つの素数の和で表す組み合わせ数が何通りあるかを出力するプログラムを作成してください。ただし、<var>n</var> は 4 以上、50,000 以下とします。また、入力される <var>n</var> は偶数であるとはかぎりません。
</p>
<H2>Input</H2>
<p>
複数のデータセットが与えられます。各データセットに <var>n</var> が１行に与えられます。<var>n</var> が 0 のとき入力の最後とします。データセットの数は 10,000 を超えません。
</p>
<H2>Output</H2>
<p>
各データセットに対して、<var>n</var> を 2 つの素数の和で表す組み合わせ数を１行に出力して下さい。
</p>
<H2>Sample Input</H2>
<pre>
10
11
0
</pre>
<H2>Output for the Sample Input</H2>
<pre>
2
0
</pre>
|
s005250487 | p00057 | Wrong Answer | while True:
try:
a = int(input())
print(((a * a) + a + 2) / 2)
except EOFError:
break | 1
3
| 2
7
|
<H1>領域の数</H1>
<p>
無限に広い平面の上に、無限に長い直線を数本引くと、この平面はいくつかの領域に分割されます。たとえば、直線を１本引くと、平面は２つの領域に分割されます。同じ数の直線を引いても、引き方によって得られる領域の数は異なります。たとえば、2 本の直線を平行に引けば得られる領域は 3 つになり、互いに垂直に引けば得られる領域は 4 つになります。
</p>
<center>
<img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_area">
</center>
<br/>
<p>
<var>n</var> 本の直線を引くことで得られる最大の領域の数を出力するプログラムを作成してください。
</p>
<H2>Input</H2>
<p>
複数のデータセットが与えられます。各データセットに <var>n</var> (1 ≤ <var>n</var> ≤ 10,000) が１行に与えられます。入力の最後まで処理して下さい。
</p>
<p>
データセットの数は 50 を超えません。
</p>
<H2>Output</H2>
<p>
各データセットに対して、最大の分割数を１行に出力して下さい。
</p>
<H2>Sample Input</H2>
<pre>
1
3
</pre>
<H2>Output for the Sample Input</H2>
<pre>
2
7
</pre>
|
s189658995 | p00057 | Wrong Answer | while True:
try:
a = int(input())
print(str(((a * a) + a + 2) / 2))
except EOFError:
break | 1
3
| 2
7
|
<H1>領域の数</H1>
<p>
無限に広い平面の上に、無限に長い直線を数本引くと、この平面はいくつかの領域に分割されます。たとえば、直線を１本引くと、平面は２つの領域に分割されます。同じ数の直線を引いても、引き方によって得られる領域の数は異なります。たとえば、2 本の直線を平行に引けば得られる領域は 3 つになり、互いに垂直に引けば得られる領域は 4 つになります。
</p>
<center>
<img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_area">
</center>
<br/>
<p>
<var>n</var> 本の直線を引くことで得られる最大の領域の数を出力するプログラムを作成してください。
</p>
<H2>Input</H2>
<p>
複数のデータセットが与えられます。各データセットに <var>n</var> (1 ≤ <var>n</var> ≤ 10,000) が１行に与えられます。入力の最後まで処理して下さい。
</p>
<p>
データセットの数は 50 を超えません。
</p>
<H2>Output</H2>
<p>
各データセットに対して、最大の分割数を１行に出力して下さい。
</p>
<H2>Sample Input</H2>
<pre>
1
3
</pre>
<H2>Output for the Sample Input</H2>
<pre>
2
7
</pre>
|
s874362953 | p00057 | Wrong Answer | d= dict()
j=v= 2
for i in range(1, 10001):
d[i]= v
if i%2==0: j+= 1
v+= j
while True:
try:
l= int(input())
except:
break
print(d[l]) | 1
3
| 2
7
|
<H1>領域の数</H1>
<p>
無限に広い平面の上に、無限に長い直線を数本引くと、この平面はいくつかの領域に分割されます。たとえば、直線を１本引くと、平面は２つの領域に分割されます。同じ数の直線を引いても、引き方によって得られる領域の数は異なります。たとえば、2 本の直線を平行に引けば得られる領域は 3 つになり、互いに垂直に引けば得られる領域は 4 つになります。
</p>
<center>
<img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_area">
</center>
<br/>
<p>
<var>n</var> 本の直線を引くことで得られる最大の領域の数を出力するプログラムを作成してください。
</p>
<H2>Input</H2>
<p>
複数のデータセットが与えられます。各データセットに <var>n</var> (1 ≤ <var>n</var> ≤ 10,000) が１行に与えられます。入力の最後まで処理して下さい。
</p>
<p>
データセットの数は 50 を超えません。
</p>
<H2>Output</H2>
<p>
各データセットに対して、最大の分割数を１行に出力して下さい。
</p>
<H2>Sample Input</H2>
<pre>
1
3
</pre>
<H2>Output for the Sample Input</H2>
<pre>
2
7
</pre>
|
s261047737 | p00057 | Wrong Answer | import sys
def solve(n):
if n == 0:
return 1
else:
return n + solve(n - 1)
for line in sys.stdin:
try:
n = int(line)
print(solve(n))
except:
break
| 1
3
| 2
7
|
<H1>領域の数</H1>
<p>
無限に広い平面の上に、無限に長い直線を数本引くと、この平面はいくつかの領域に分割されます。たとえば、直線を１本引くと、平面は２つの領域に分割されます。同じ数の直線を引いても、引き方によって得られる領域の数は異なります。たとえば、2 本の直線を平行に引けば得られる領域は 3 つになり、互いに垂直に引けば得られる領域は 4 つになります。
</p>
<center>
<img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_area">
</center>
<br/>
<p>
<var>n</var> 本の直線を引くことで得られる最大の領域の数を出力するプログラムを作成してください。
</p>
<H2>Input</H2>
<p>
複数のデータセットが与えられます。各データセットに <var>n</var> (1 ≤ <var>n</var> ≤ 10,000) が１行に与えられます。入力の最後まで処理して下さい。
</p>
<p>
データセットの数は 50 を超えません。
</p>
<H2>Output</H2>
<p>
各データセットに対して、最大の分割数を１行に出力して下さい。
</p>
<H2>Sample Input</H2>
<pre>
1
3
</pre>
<H2>Output for the Sample Input</H2>
<pre>
2
7
</pre>
|
s165474988 | p00057 | Accepted | import sys
for n in map(int, sys.stdin):
print(n*(n+1)//2+1)
| 1
3
| 2
7
|
<H1>領域の数</H1>
<p>
無限に広い平面の上に、無限に長い直線を数本引くと、この平面はいくつかの領域に分割されます。たとえば、直線を１本引くと、平面は２つの領域に分割されます。同じ数の直線を引いても、引き方によって得られる領域の数は異なります。たとえば、2 本の直線を平行に引けば得られる領域は 3 つになり、互いに垂直に引けば得られる領域は 4 つになります。
</p>
<center>
<img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_area">
</center>
<br/>
<p>
<var>n</var> 本の直線を引くことで得られる最大の領域の数を出力するプログラムを作成してください。
</p>
<H2>Input</H2>
<p>
複数のデータセットが与えられます。各データセットに <var>n</var> (1 ≤ <var>n</var> ≤ 10,000) が１行に与えられます。入力の最後まで処理して下さい。
</p>
<p>
データセットの数は 50 を超えません。
</p>
<H2>Output</H2>
<p>
各データセットに対して、最大の分割数を１行に出力して下さい。
</p>
<H2>Sample Input</H2>
<pre>
1
3
</pre>
<H2>Output for the Sample Input</H2>
<pre>
2
7
</pre>
|
s790113996 | p00057 | Accepted | while True:
try:
x = int(input())
print(int((x**2 + x + 2) / 2))
except:
break
| 1
3
| 2
7
|
<H1>領域の数</H1>
<p>
無限に広い平面の上に、無限に長い直線を数本引くと、この平面はいくつかの領域に分割されます。たとえば、直線を１本引くと、平面は２つの領域に分割されます。同じ数の直線を引いても、引き方によって得られる領域の数は異なります。たとえば、2 本の直線を平行に引けば得られる領域は 3 つになり、互いに垂直に引けば得られる領域は 4 つになります。
</p>
<center>
<img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_area">
</center>
<br/>
<p>
<var>n</var> 本の直線を引くことで得られる最大の領域の数を出力するプログラムを作成してください。
</p>
<H2>Input</H2>
<p>
複数のデータセットが与えられます。各データセットに <var>n</var> (1 ≤ <var>n</var> ≤ 10,000) が１行に与えられます。入力の最後まで処理して下さい。
</p>
<p>
データセットの数は 50 を超えません。
</p>
<H2>Output</H2>
<p>
各データセットに対して、最大の分割数を１行に出力して下さい。
</p>
<H2>Sample Input</H2>
<pre>
1
3
</pre>
<H2>Output for the Sample Input</H2>
<pre>
2
7
</pre>
|
s078991859 | p00057 | Accepted | while True:
try:
n = int(input())
except:
break
ans = 2
for i in range(2, n + 1):
ans += i
print(ans) | 1
3
| 2
7
|
<H1>領域の数</H1>
<p>
無限に広い平面の上に、無限に長い直線を数本引くと、この平面はいくつかの領域に分割されます。たとえば、直線を１本引くと、平面は２つの領域に分割されます。同じ数の直線を引いても、引き方によって得られる領域の数は異なります。たとえば、2 本の直線を平行に引けば得られる領域は 3 つになり、互いに垂直に引けば得られる領域は 4 つになります。
</p>
<center>
<img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_area">
</center>
<br/>
<p>
<var>n</var> 本の直線を引くことで得られる最大の領域の数を出力するプログラムを作成してください。
</p>
<H2>Input</H2>
<p>
複数のデータセットが与えられます。各データセットに <var>n</var> (1 ≤ <var>n</var> ≤ 10,000) が１行に与えられます。入力の最後まで処理して下さい。
</p>
<p>
データセットの数は 50 を超えません。
</p>
<H2>Output</H2>
<p>
各データセットに対して、最大の分割数を１行に出力して下さい。
</p>
<H2>Sample Input</H2>
<pre>
1
3
</pre>
<H2>Output for the Sample Input</H2>
<pre>
2
7
</pre>
|
s810187624 | p00057 | Accepted | import sys
n = 10001
l = [0]*n
l[2] = 1
for i in xrange(3,n): l[i] = (i-1)+l[i-1]
for i in xrange(1,n): l[i] += i+1
for s in sys.stdin:
d = int(s)
print l[d] | 1
3
| 2
7
|
<H1>領域の数</H1>
<p>
無限に広い平面の上に、無限に長い直線を数本引くと、この平面はいくつかの領域に分割されます。たとえば、直線を１本引くと、平面は２つの領域に分割されます。同じ数の直線を引いても、引き方によって得られる領域の数は異なります。たとえば、2 本の直線を平行に引けば得られる領域は 3 つになり、互いに垂直に引けば得られる領域は 4 つになります。
</p>
<center>
<img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_area">
</center>
<br/>
<p>
<var>n</var> 本の直線を引くことで得られる最大の領域の数を出力するプログラムを作成してください。
</p>
<H2>Input</H2>
<p>
複数のデータセットが与えられます。各データセットに <var>n</var> (1 ≤ <var>n</var> ≤ 10,000) が１行に与えられます。入力の最後まで処理して下さい。
</p>
<p>
データセットの数は 50 を超えません。
</p>
<H2>Output</H2>
<p>
各データセットに対して、最大の分割数を１行に出力して下さい。
</p>
<H2>Sample Input</H2>
<pre>
1
3
</pre>
<H2>Output for the Sample Input</H2>
<pre>
2
7
</pre>
|
s201427257 | p00057 | Accepted | #! /usr/bin/python
# -*- coding: utf-8 -*-
def main():
# input
while(True):
try:
data = int(raw_input())
print(countArea(data))
except EOFError:
break
def countArea(n):
ans = 2
while(n > 1):
ans = ans + n
n -= 1
return ans
if __name__=='__main__':
main() | 1
3
| 2
7
|
<H1>領域の数</H1>
<p>
無限に広い平面の上に、無限に長い直線を数本引くと、この平面はいくつかの領域に分割されます。たとえば、直線を１本引くと、平面は２つの領域に分割されます。同じ数の直線を引いても、引き方によって得られる領域の数は異なります。たとえば、2 本の直線を平行に引けば得られる領域は 3 つになり、互いに垂直に引けば得られる領域は 4 つになります。
</p>
<center>
<img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_area">
</center>
<br/>
<p>
<var>n</var> 本の直線を引くことで得られる最大の領域の数を出力するプログラムを作成してください。
</p>
<H2>Input</H2>
<p>
複数のデータセットが与えられます。各データセットに <var>n</var> (1 ≤ <var>n</var> ≤ 10,000) が１行に与えられます。入力の最後まで処理して下さい。
</p>
<p>
データセットの数は 50 を超えません。
</p>
<H2>Output</H2>
<p>
各データセットに対して、最大の分割数を１行に出力して下さい。
</p>
<H2>Sample Input</H2>
<pre>
1
3
</pre>
<H2>Output for the Sample Input</H2>
<pre>
2
7
</pre>
|
s843418944 | p00057 | Accepted | import sys
f = sys.stdin
for n in f:
n = int(n)
print(n * (n + 1) // 2 + 1) | 1
3
| 2
7
|
<H1>領域の数</H1>
<p>
無限に広い平面の上に、無限に長い直線を数本引くと、この平面はいくつかの領域に分割されます。たとえば、直線を１本引くと、平面は２つの領域に分割されます。同じ数の直線を引いても、引き方によって得られる領域の数は異なります。たとえば、2 本の直線を平行に引けば得られる領域は 3 つになり、互いに垂直に引けば得られる領域は 4 つになります。
</p>
<center>
<img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_area">
</center>
<br/>
<p>
<var>n</var> 本の直線を引くことで得られる最大の領域の数を出力するプログラムを作成してください。
</p>
<H2>Input</H2>
<p>
複数のデータセットが与えられます。各データセットに <var>n</var> (1 ≤ <var>n</var> ≤ 10,000) が１行に与えられます。入力の最後まで処理して下さい。
</p>
<p>
データセットの数は 50 を超えません。
</p>
<H2>Output</H2>
<p>
各データセットに対して、最大の分割数を１行に出力して下さい。
</p>
<H2>Sample Input</H2>
<pre>
1
3
</pre>
<H2>Output for the Sample Input</H2>
<pre>
2
7
</pre>
|
s768567372 | p00057 | Accepted | # -*- coding:utf-8 -*-
while True:
try:
n = int(raw_input())
print (n * n + n + 2) / 2
except:
break
| 1
3
| 2
7
|
<H1>領域の数</H1>
<p>
無限に広い平面の上に、無限に長い直線を数本引くと、この平面はいくつかの領域に分割されます。たとえば、直線を１本引くと、平面は２つの領域に分割されます。同じ数の直線を引いても、引き方によって得られる領域の数は異なります。たとえば、2 本の直線を平行に引けば得られる領域は 3 つになり、互いに垂直に引けば得られる領域は 4 つになります。
</p>
<center>
<img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_area">
</center>
<br/>
<p>
<var>n</var> 本の直線を引くことで得られる最大の領域の数を出力するプログラムを作成してください。
</p>
<H2>Input</H2>
<p>
複数のデータセットが与えられます。各データセットに <var>n</var> (1 ≤ <var>n</var> ≤ 10,000) が１行に与えられます。入力の最後まで処理して下さい。
</p>
<p>
データセットの数は 50 を超えません。
</p>
<H2>Output</H2>
<p>
各データセットに対して、最大の分割数を１行に出力して下さい。
</p>
<H2>Sample Input</H2>
<pre>
1
3
</pre>
<H2>Output for the Sample Input</H2>
<pre>
2
7
</pre>
|
s458309907 | p00057 | Accepted | while True:
try:
n = int(input())
except:
break
sum = 1
for i in range(1, n + 1):
sum += i
print(sum) | 1
3
| 2
7
|
<H1>領域の数</H1>
<p>
無限に広い平面の上に、無限に長い直線を数本引くと、この平面はいくつかの領域に分割されます。たとえば、直線を１本引くと、平面は２つの領域に分割されます。同じ数の直線を引いても、引き方によって得られる領域の数は異なります。たとえば、2 本の直線を平行に引けば得られる領域は 3 つになり、互いに垂直に引けば得られる領域は 4 つになります。
</p>
<center>
<img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_area">
</center>
<br/>
<p>
<var>n</var> 本の直線を引くことで得られる最大の領域の数を出力するプログラムを作成してください。
</p>
<H2>Input</H2>
<p>
複数のデータセットが与えられます。各データセットに <var>n</var> (1 ≤ <var>n</var> ≤ 10,000) が１行に与えられます。入力の最後まで処理して下さい。
</p>
<p>
データセットの数は 50 を超えません。
</p>
<H2>Output</H2>
<p>
各データセットに対して、最大の分割数を１行に出力して下さい。
</p>
<H2>Sample Input</H2>
<pre>
1
3
</pre>
<H2>Output for the Sample Input</H2>
<pre>
2
7
</pre>
|
s216433097 | p00057 | Accepted | while True:
try:
n=int(raw_input())
except EOFError:
break
print n*(n+1)/2+1 | 1
3
| 2
7
|
<H1>領域の数</H1>
<p>
無限に広い平面の上に、無限に長い直線を数本引くと、この平面はいくつかの領域に分割されます。たとえば、直線を１本引くと、平面は２つの領域に分割されます。同じ数の直線を引いても、引き方によって得られる領域の数は異なります。たとえば、2 本の直線を平行に引けば得られる領域は 3 つになり、互いに垂直に引けば得られる領域は 4 つになります。
</p>
<center>
<img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_area">
</center>
<br/>
<p>
<var>n</var> 本の直線を引くことで得られる最大の領域の数を出力するプログラムを作成してください。
</p>
<H2>Input</H2>
<p>
複数のデータセットが与えられます。各データセットに <var>n</var> (1 ≤ <var>n</var> ≤ 10,000) が１行に与えられます。入力の最後まで処理して下さい。
</p>
<p>
データセットの数は 50 を超えません。
</p>
<H2>Output</H2>
<p>
各データセットに対して、最大の分割数を１行に出力して下さい。
</p>
<H2>Sample Input</H2>
<pre>
1
3
</pre>
<H2>Output for the Sample Input</H2>
<pre>
2
7
</pre>
|
s447164520 | p00057 | Accepted | import sys
for line in sys.stdin.readlines():
n = int(line)
i = (1+n)*n//2+1
print(i) | 1
3
| 2
7
|
<H1>領域の数</H1>
<p>
無限に広い平面の上に、無限に長い直線を数本引くと、この平面はいくつかの領域に分割されます。たとえば、直線を１本引くと、平面は２つの領域に分割されます。同じ数の直線を引いても、引き方によって得られる領域の数は異なります。たとえば、2 本の直線を平行に引けば得られる領域は 3 つになり、互いに垂直に引けば得られる領域は 4 つになります。
</p>
<center>
<img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_area">
</center>
<br/>
<p>
<var>n</var> 本の直線を引くことで得られる最大の領域の数を出力するプログラムを作成してください。
</p>
<H2>Input</H2>
<p>
複数のデータセットが与えられます。各データセットに <var>n</var> (1 ≤ <var>n</var> ≤ 10,000) が１行に与えられます。入力の最後まで処理して下さい。
</p>
<p>
データセットの数は 50 を超えません。
</p>
<H2>Output</H2>
<p>
各データセットに対して、最大の分割数を１行に出力して下さい。
</p>
<H2>Sample Input</H2>
<pre>
1
3
</pre>
<H2>Output for the Sample Input</H2>
<pre>
2
7
</pre>
|
s584686262 | p00057 | Accepted | while 1:
try:
n=int(raw_input())
ans=1
for i in range(1,n+1):
ans=ans+i
print ans
except:
break | 1
3
| 2
7
|
<H1>領域の数</H1>
<p>
無限に広い平面の上に、無限に長い直線を数本引くと、この平面はいくつかの領域に分割されます。たとえば、直線を１本引くと、平面は２つの領域に分割されます。同じ数の直線を引いても、引き方によって得られる領域の数は異なります。たとえば、2 本の直線を平行に引けば得られる領域は 3 つになり、互いに垂直に引けば得られる領域は 4 つになります。
</p>
<center>
<img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_area">
</center>
<br/>
<p>
<var>n</var> 本の直線を引くことで得られる最大の領域の数を出力するプログラムを作成してください。
</p>
<H2>Input</H2>
<p>
複数のデータセットが与えられます。各データセットに <var>n</var> (1 ≤ <var>n</var> ≤ 10,000) が１行に与えられます。入力の最後まで処理して下さい。
</p>
<p>
データセットの数は 50 を超えません。
</p>
<H2>Output</H2>
<p>
各データセットに対して、最大の分割数を１行に出力して下さい。
</p>
<H2>Sample Input</H2>
<pre>
1
3
</pre>
<H2>Output for the Sample Input</H2>
<pre>
2
7
</pre>
|
s428386633 | p00057 | Accepted | while True:
try:
n=int(input())
a=2
d=2
for i in range(n-1):
a+=d
d+=1
print(a)
except EOFError:
break | 1
3
| 2
7
|
<H1>領域の数</H1>
<p>
無限に広い平面の上に、無限に長い直線を数本引くと、この平面はいくつかの領域に分割されます。たとえば、直線を１本引くと、平面は２つの領域に分割されます。同じ数の直線を引いても、引き方によって得られる領域の数は異なります。たとえば、2 本の直線を平行に引けば得られる領域は 3 つになり、互いに垂直に引けば得られる領域は 4 つになります。
</p>
<center>
<img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_area">
</center>
<br/>
<p>
<var>n</var> 本の直線を引くことで得られる最大の領域の数を出力するプログラムを作成してください。
</p>
<H2>Input</H2>
<p>
複数のデータセットが与えられます。各データセットに <var>n</var> (1 ≤ <var>n</var> ≤ 10,000) が１行に与えられます。入力の最後まで処理して下さい。
</p>
<p>
データセットの数は 50 を超えません。
</p>
<H2>Output</H2>
<p>
各データセットに対して、最大の分割数を１行に出力して下さい。
</p>
<H2>Sample Input</H2>
<pre>
1
3
</pre>
<H2>Output for the Sample Input</H2>
<pre>
2
7
</pre>
|
s565497890 | p00057 | Accepted | # -*- coding: utf-8 -*-
import sys
for line in sys.stdin:
n = int(line)
print (n*n+n+2)/2 | 1
3
| 2
7
|
<H1>領域の数</H1>
<p>
無限に広い平面の上に、無限に長い直線を数本引くと、この平面はいくつかの領域に分割されます。たとえば、直線を１本引くと、平面は２つの領域に分割されます。同じ数の直線を引いても、引き方によって得られる領域の数は異なります。たとえば、2 本の直線を平行に引けば得られる領域は 3 つになり、互いに垂直に引けば得られる領域は 4 つになります。
</p>
<center>
<img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_area">
</center>
<br/>
<p>
<var>n</var> 本の直線を引くことで得られる最大の領域の数を出力するプログラムを作成してください。
</p>
<H2>Input</H2>
<p>
複数のデータセットが与えられます。各データセットに <var>n</var> (1 ≤ <var>n</var> ≤ 10,000) が１行に与えられます。入力の最後まで処理して下さい。
</p>
<p>
データセットの数は 50 を超えません。
</p>
<H2>Output</H2>
<p>
各データセットに対して、最大の分割数を１行に出力して下さい。
</p>
<H2>Sample Input</H2>
<pre>
1
3
</pre>
<H2>Output for the Sample Input</H2>
<pre>
2
7
</pre>
|
s584067179 | p00057 | Accepted | while True:
try:
n = int(input())
except:
break
print(n * (n + 1) // 2 + 1) | 1
3
| 2
7
|
<H1>領域の数</H1>
<p>
無限に広い平面の上に、無限に長い直線を数本引くと、この平面はいくつかの領域に分割されます。たとえば、直線を１本引くと、平面は２つの領域に分割されます。同じ数の直線を引いても、引き方によって得られる領域の数は異なります。たとえば、2 本の直線を平行に引けば得られる領域は 3 つになり、互いに垂直に引けば得られる領域は 4 つになります。
</p>
<center>
<img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_area">
</center>
<br/>
<p>
<var>n</var> 本の直線を引くことで得られる最大の領域の数を出力するプログラムを作成してください。
</p>
<H2>Input</H2>
<p>
複数のデータセットが与えられます。各データセットに <var>n</var> (1 ≤ <var>n</var> ≤ 10,000) が１行に与えられます。入力の最後まで処理して下さい。
</p>
<p>
データセットの数は 50 を超えません。
</p>
<H2>Output</H2>
<p>
各データセットに対して、最大の分割数を１行に出力して下さい。
</p>
<H2>Sample Input</H2>
<pre>
1
3
</pre>
<H2>Output for the Sample Input</H2>
<pre>
2
7
</pre>
|
s796289679 | p00057 | Accepted | while True:
try:
a = int(input())
print(str(int(((a * a) + a + 2) / 2)))
except EOFError:
break | 1
3
| 2
7
|
<H1>領域の数</H1>
<p>
無限に広い平面の上に、無限に長い直線を数本引くと、この平面はいくつかの領域に分割されます。たとえば、直線を１本引くと、平面は２つの領域に分割されます。同じ数の直線を引いても、引き方によって得られる領域の数は異なります。たとえば、2 本の直線を平行に引けば得られる領域は 3 つになり、互いに垂直に引けば得られる領域は 4 つになります。
</p>
<center>
<img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_area">
</center>
<br/>
<p>
<var>n</var> 本の直線を引くことで得られる最大の領域の数を出力するプログラムを作成してください。
</p>
<H2>Input</H2>
<p>
複数のデータセットが与えられます。各データセットに <var>n</var> (1 ≤ <var>n</var> ≤ 10,000) が１行に与えられます。入力の最後まで処理して下さい。
</p>
<p>
データセットの数は 50 を超えません。
</p>
<H2>Output</H2>
<p>
各データセットに対して、最大の分割数を１行に出力して下さい。
</p>
<H2>Sample Input</H2>
<pre>
1
3
</pre>
<H2>Output for the Sample Input</H2>
<pre>
2
7
</pre>
|
s338798005 | p00057 | Accepted | while True:
try:
n = int(input())
ans = 2 + (n + 2)*(n - 1) / 2
print(int(ans))
except EOFError:
break | 1
3
| 2
7
|
<H1>領域の数</H1>
<p>
無限に広い平面の上に、無限に長い直線を数本引くと、この平面はいくつかの領域に分割されます。たとえば、直線を１本引くと、平面は２つの領域に分割されます。同じ数の直線を引いても、引き方によって得られる領域の数は異なります。たとえば、2 本の直線を平行に引けば得られる領域は 3 つになり、互いに垂直に引けば得られる領域は 4 つになります。
</p>
<center>
<img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_area">
</center>
<br/>
<p>
<var>n</var> 本の直線を引くことで得られる最大の領域の数を出力するプログラムを作成してください。
</p>
<H2>Input</H2>
<p>
複数のデータセットが与えられます。各データセットに <var>n</var> (1 ≤ <var>n</var> ≤ 10,000) が１行に与えられます。入力の最後まで処理して下さい。
</p>
<p>
データセットの数は 50 を超えません。
</p>
<H2>Output</H2>
<p>
各データセットに対して、最大の分割数を１行に出力して下さい。
</p>
<H2>Sample Input</H2>
<pre>
1
3
</pre>
<H2>Output for the Sample Input</H2>
<pre>
2
7
</pre>
|
s130927560 | p00057 | Accepted | while 1:
try:n=int(input())
except:break
print((n*n+n+2)//2) | 1
3
| 2
7
|
<H1>領域の数</H1>
<p>
無限に広い平面の上に、無限に長い直線を数本引くと、この平面はいくつかの領域に分割されます。たとえば、直線を１本引くと、平面は２つの領域に分割されます。同じ数の直線を引いても、引き方によって得られる領域の数は異なります。たとえば、2 本の直線を平行に引けば得られる領域は 3 つになり、互いに垂直に引けば得られる領域は 4 つになります。
</p>
<center>
<img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_area">
</center>
<br/>
<p>
<var>n</var> 本の直線を引くことで得られる最大の領域の数を出力するプログラムを作成してください。
</p>
<H2>Input</H2>
<p>
複数のデータセットが与えられます。各データセットに <var>n</var> (1 ≤ <var>n</var> ≤ 10,000) が１行に与えられます。入力の最後まで処理して下さい。
</p>
<p>
データセットの数は 50 を超えません。
</p>
<H2>Output</H2>
<p>
各データセットに対して、最大の分割数を１行に出力して下さい。
</p>
<H2>Sample Input</H2>
<pre>
1
3
</pre>
<H2>Output for the Sample Input</H2>
<pre>
2
7
</pre>
|
s615163523 | p00057 | Accepted | while True:
try:
n=int(input())
except:
break
print(n * (n + 1) // 2 + 1) | 1
3
| 2
7
|
<H1>領域の数</H1>
<p>
無限に広い平面の上に、無限に長い直線を数本引くと、この平面はいくつかの領域に分割されます。たとえば、直線を１本引くと、平面は２つの領域に分割されます。同じ数の直線を引いても、引き方によって得られる領域の数は異なります。たとえば、2 本の直線を平行に引けば得られる領域は 3 つになり、互いに垂直に引けば得られる領域は 4 つになります。
</p>
<center>
<img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_area">
</center>
<br/>
<p>
<var>n</var> 本の直線を引くことで得られる最大の領域の数を出力するプログラムを作成してください。
</p>
<H2>Input</H2>
<p>
複数のデータセットが与えられます。各データセットに <var>n</var> (1 ≤ <var>n</var> ≤ 10,000) が１行に与えられます。入力の最後まで処理して下さい。
</p>
<p>
データセットの数は 50 を超えません。
</p>
<H2>Output</H2>
<p>
各データセットに対して、最大の分割数を１行に出力して下さい。
</p>
<H2>Sample Input</H2>
<pre>
1
3
</pre>
<H2>Output for the Sample Input</H2>
<pre>
2
7
</pre>
|
s402666802 | p00057 | Accepted | while True:
try:
l= int(input())
except:
break
print((l**2+l+2)//2) | 1
3
| 2
7
|
<H1>領域の数</H1>
<p>
無限に広い平面の上に、無限に長い直線を数本引くと、この平面はいくつかの領域に分割されます。たとえば、直線を１本引くと、平面は２つの領域に分割されます。同じ数の直線を引いても、引き方によって得られる領域の数は異なります。たとえば、2 本の直線を平行に引けば得られる領域は 3 つになり、互いに垂直に引けば得られる領域は 4 つになります。
</p>
<center>
<img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_area">
</center>
<br/>
<p>
<var>n</var> 本の直線を引くことで得られる最大の領域の数を出力するプログラムを作成してください。
</p>
<H2>Input</H2>
<p>
複数のデータセットが与えられます。各データセットに <var>n</var> (1 ≤ <var>n</var> ≤ 10,000) が１行に与えられます。入力の最後まで処理して下さい。
</p>
<p>
データセットの数は 50 を超えません。
</p>
<H2>Output</H2>
<p>
各データセットに対して、最大の分割数を１行に出力して下さい。
</p>
<H2>Sample Input</H2>
<pre>
1
3
</pre>
<H2>Output for the Sample Input</H2>
<pre>
2
7
</pre>
|
s092999959 | p00057 | Accepted | import sys
for i in sys.stdin.readlines():
a = 2
for i2 in range(2,int(i)+1):
a += i2
print(a) | 1
3
| 2
7
|
<H1>領域の数</H1>
<p>
無限に広い平面の上に、無限に長い直線を数本引くと、この平面はいくつかの領域に分割されます。たとえば、直線を１本引くと、平面は２つの領域に分割されます。同じ数の直線を引いても、引き方によって得られる領域の数は異なります。たとえば、2 本の直線を平行に引けば得られる領域は 3 つになり、互いに垂直に引けば得られる領域は 4 つになります。
</p>
<center>
<img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_area">
</center>
<br/>
<p>
<var>n</var> 本の直線を引くことで得られる最大の領域の数を出力するプログラムを作成してください。
</p>
<H2>Input</H2>
<p>
複数のデータセットが与えられます。各データセットに <var>n</var> (1 ≤ <var>n</var> ≤ 10,000) が１行に与えられます。入力の最後まで処理して下さい。
</p>
<p>
データセットの数は 50 を超えません。
</p>
<H2>Output</H2>
<p>
各データセットに対して、最大の分割数を１行に出力して下さい。
</p>
<H2>Sample Input</H2>
<pre>
1
3
</pre>
<H2>Output for the Sample Input</H2>
<pre>
2
7
</pre>
|
s332533048 | p00057 | Accepted | while True:
try:
N = int(input())
except EOFError:
break
print(1 + sum(range(N + 1))) | 1
3
| 2
7
|
<H1>領域の数</H1>
<p>
無限に広い平面の上に、無限に長い直線を数本引くと、この平面はいくつかの領域に分割されます。たとえば、直線を１本引くと、平面は２つの領域に分割されます。同じ数の直線を引いても、引き方によって得られる領域の数は異なります。たとえば、2 本の直線を平行に引けば得られる領域は 3 つになり、互いに垂直に引けば得られる領域は 4 つになります。
</p>
<center>
<img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_area">
</center>
<br/>
<p>
<var>n</var> 本の直線を引くことで得られる最大の領域の数を出力するプログラムを作成してください。
</p>
<H2>Input</H2>
<p>
複数のデータセットが与えられます。各データセットに <var>n</var> (1 ≤ <var>n</var> ≤ 10,000) が１行に与えられます。入力の最後まで処理して下さい。
</p>
<p>
データセットの数は 50 を超えません。
</p>
<H2>Output</H2>
<p>
各データセットに対して、最大の分割数を１行に出力して下さい。
</p>
<H2>Sample Input</H2>
<pre>
1
3
</pre>
<H2>Output for the Sample Input</H2>
<pre>
2
7
</pre>
|
s872300573 | p00057 | Accepted | # -*- coding: utf-8 -*-
import sys
import os
for s in sys.stdin:
n = int(s)
if n == 1:
print(2)
else:
num = 2
for i in range(2, n+1):
num += i
print(num) | 1
3
| 2
7
|
<H1>領域の数</H1>
<p>
無限に広い平面の上に、無限に長い直線を数本引くと、この平面はいくつかの領域に分割されます。たとえば、直線を１本引くと、平面は２つの領域に分割されます。同じ数の直線を引いても、引き方によって得られる領域の数は異なります。たとえば、2 本の直線を平行に引けば得られる領域は 3 つになり、互いに垂直に引けば得られる領域は 4 つになります。
</p>
<center>
<img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_area">
</center>
<br/>
<p>
<var>n</var> 本の直線を引くことで得られる最大の領域の数を出力するプログラムを作成してください。
</p>
<H2>Input</H2>
<p>
複数のデータセットが与えられます。各データセットに <var>n</var> (1 ≤ <var>n</var> ≤ 10,000) が１行に与えられます。入力の最後まで処理して下さい。
</p>
<p>
データセットの数は 50 を超えません。
</p>
<H2>Output</H2>
<p>
各データセットに対して、最大の分割数を１行に出力して下さい。
</p>
<H2>Sample Input</H2>
<pre>
1
3
</pre>
<H2>Output for the Sample Input</H2>
<pre>
2
7
</pre>
|
s996876926 | p00057 | Accepted | # -*- coding: utf-8 -*-
"""
http://judge.u-aizu.ac.jp/onlinejudge/description.jsp?id=0057
"""
import sys
Area_memo = [0 for _ in range(10002)] # n??¬???????????????????????????????????° (0???????¨????)
Area_memo[0] = 1
def count_area(num):
"""
????????°??¨???????????°?????¢????????\????????????????????£????????????
0 -> 1
1 -> 2
2 -> 4
3 -> 7
4 -> 11
?????£??????i??¬???????????????????????????????????°??????(i-1)??¬????????????????????° + ????????° ??¨?????????
n?????°????????§??§10,000????????§????????¢???????????????????????????
??? ?????????????????¨???n?????§????????¨?????°????????????????????°????¢???????????????¨???????????????
:param num:????????°
:return: ???????????°
"""
global Area_memo
if Area_memo[num] == 0:
Area_memo[num] = num + count_area(num-1)
return Area_memo[num]
def count_area2(num):
wa = num * (1 + num) // 2
return wa + 1
def main(args):
for line in sys.stdin:
num = int(line.strip())
result = count_area2(num)
print(result)
if __name__ == '__main__':
main(sys.argv[1:]) | 1
3
| 2
7
|
<H1>領域の数</H1>
<p>
無限に広い平面の上に、無限に長い直線を数本引くと、この平面はいくつかの領域に分割されます。たとえば、直線を１本引くと、平面は２つの領域に分割されます。同じ数の直線を引いても、引き方によって得られる領域の数は異なります。たとえば、2 本の直線を平行に引けば得られる領域は 3 つになり、互いに垂直に引けば得られる領域は 4 つになります。
</p>
<center>
<img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_area">
</center>
<br/>
<p>
<var>n</var> 本の直線を引くことで得られる最大の領域の数を出力するプログラムを作成してください。
</p>
<H2>Input</H2>
<p>
複数のデータセットが与えられます。各データセットに <var>n</var> (1 ≤ <var>n</var> ≤ 10,000) が１行に与えられます。入力の最後まで処理して下さい。
</p>
<p>
データセットの数は 50 を超えません。
</p>
<H2>Output</H2>
<p>
各データセットに対して、最大の分割数を１行に出力して下さい。
</p>
<H2>Sample Input</H2>
<pre>
1
3
</pre>
<H2>Output for the Sample Input</H2>
<pre>
2
7
</pre>
|
s166503083 | p00057 | Accepted | # Aizu Problem 0057: Number of Area
#
import sys, math, os, bisect
# read input:
PYDEV = os.environ.get('PYDEV')
if PYDEV=="True":
sys.stdin = open("sample-input.txt", "rt")
for line in sys.stdin:
n = int(line)
print(1 + n * (n + 1) // 2) | 1
3
| 2
7
|
<H1>領域の数</H1>
<p>
無限に広い平面の上に、無限に長い直線を数本引くと、この平面はいくつかの領域に分割されます。たとえば、直線を１本引くと、平面は２つの領域に分割されます。同じ数の直線を引いても、引き方によって得られる領域の数は異なります。たとえば、2 本の直線を平行に引けば得られる領域は 3 つになり、互いに垂直に引けば得られる領域は 4 つになります。
</p>
<center>
<img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_area">
</center>
<br/>
<p>
<var>n</var> 本の直線を引くことで得られる最大の領域の数を出力するプログラムを作成してください。
</p>
<H2>Input</H2>
<p>
複数のデータセットが与えられます。各データセットに <var>n</var> (1 ≤ <var>n</var> ≤ 10,000) が１行に与えられます。入力の最後まで処理して下さい。
</p>
<p>
データセットの数は 50 を超えません。
</p>
<H2>Output</H2>
<p>
各データセットに対して、最大の分割数を１行に出力して下さい。
</p>
<H2>Sample Input</H2>
<pre>
1
3
</pre>
<H2>Output for the Sample Input</H2>
<pre>
2
7
</pre>
|
s049129562 | p00057 | Accepted | import sys
for line in sys.stdin:
try:
n = int(line)
print((n**2 + n + 2) // 2)
except:
break
| 1
3
| 2
7
|
<H1>領域の数</H1>
<p>
無限に広い平面の上に、無限に長い直線を数本引くと、この平面はいくつかの領域に分割されます。たとえば、直線を１本引くと、平面は２つの領域に分割されます。同じ数の直線を引いても、引き方によって得られる領域の数は異なります。たとえば、2 本の直線を平行に引けば得られる領域は 3 つになり、互いに垂直に引けば得られる領域は 4 つになります。
</p>
<center>
<img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_area">
</center>
<br/>
<p>
<var>n</var> 本の直線を引くことで得られる最大の領域の数を出力するプログラムを作成してください。
</p>
<H2>Input</H2>
<p>
複数のデータセットが与えられます。各データセットに <var>n</var> (1 ≤ <var>n</var> ≤ 10,000) が１行に与えられます。入力の最後まで処理して下さい。
</p>
<p>
データセットの数は 50 を超えません。
</p>
<H2>Output</H2>
<p>
各データセットに対して、最大の分割数を１行に出力して下さい。
</p>
<H2>Sample Input</H2>
<pre>
1
3
</pre>
<H2>Output for the Sample Input</H2>
<pre>
2
7
</pre>
|
s807121446 | p00057 | Accepted | while True:
try:
n = int(input())
print((n**2 + n + 2)//2)
except:
break
| 1
3
| 2
7
|
<H1>領域の数</H1>
<p>
無限に広い平面の上に、無限に長い直線を数本引くと、この平面はいくつかの領域に分割されます。たとえば、直線を１本引くと、平面は２つの領域に分割されます。同じ数の直線を引いても、引き方によって得られる領域の数は異なります。たとえば、2 本の直線を平行に引けば得られる領域は 3 つになり、互いに垂直に引けば得られる領域は 4 つになります。
</p>
<center>
<img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_area">
</center>
<br/>
<p>
<var>n</var> 本の直線を引くことで得られる最大の領域の数を出力するプログラムを作成してください。
</p>
<H2>Input</H2>
<p>
複数のデータセットが与えられます。各データセットに <var>n</var> (1 ≤ <var>n</var> ≤ 10,000) が１行に与えられます。入力の最後まで処理して下さい。
</p>
<p>
データセットの数は 50 を超えません。
</p>
<H2>Output</H2>
<p>
各データセットに対して、最大の分割数を１行に出力して下さい。
</p>
<H2>Sample Input</H2>
<pre>
1
3
</pre>
<H2>Output for the Sample Input</H2>
<pre>
2
7
</pre>
|
s904360530 | p00057 | Accepted | def get_input():
while True:
try:
yield ''.join(input())
except EOFError:
break
N = list(get_input())
for l in range(len(N)):
n = int(N[l])
print(n*(n+1)//2+1)
| 1
3
| 2
7
|
<H1>領域の数</H1>
<p>
無限に広い平面の上に、無限に長い直線を数本引くと、この平面はいくつかの領域に分割されます。たとえば、直線を１本引くと、平面は２つの領域に分割されます。同じ数の直線を引いても、引き方によって得られる領域の数は異なります。たとえば、2 本の直線を平行に引けば得られる領域は 3 つになり、互いに垂直に引けば得られる領域は 4 つになります。
</p>
<center>
<img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_area">
</center>
<br/>
<p>
<var>n</var> 本の直線を引くことで得られる最大の領域の数を出力するプログラムを作成してください。
</p>
<H2>Input</H2>
<p>
複数のデータセットが与えられます。各データセットに <var>n</var> (1 ≤ <var>n</var> ≤ 10,000) が１行に与えられます。入力の最後まで処理して下さい。
</p>
<p>
データセットの数は 50 を超えません。
</p>
<H2>Output</H2>
<p>
各データセットに対して、最大の分割数を１行に出力して下さい。
</p>
<H2>Sample Input</H2>
<pre>
1
3
</pre>
<H2>Output for the Sample Input</H2>
<pre>
2
7
</pre>
|
s822930141 | p00057 | Accepted | import sys
for e in sys.stdin:e=int(e);print(e*(e+1)//2+1)
| 1
3
| 2
7
|
<H1>領域の数</H1>
<p>
無限に広い平面の上に、無限に長い直線を数本引くと、この平面はいくつかの領域に分割されます。たとえば、直線を１本引くと、平面は２つの領域に分割されます。同じ数の直線を引いても、引き方によって得られる領域の数は異なります。たとえば、2 本の直線を平行に引けば得られる領域は 3 つになり、互いに垂直に引けば得られる領域は 4 つになります。
</p>
<center>
<img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_area">
</center>
<br/>
<p>
<var>n</var> 本の直線を引くことで得られる最大の領域の数を出力するプログラムを作成してください。
</p>
<H2>Input</H2>
<p>
複数のデータセットが与えられます。各データセットに <var>n</var> (1 ≤ <var>n</var> ≤ 10,000) が１行に与えられます。入力の最後まで処理して下さい。
</p>
<p>
データセットの数は 50 を超えません。
</p>
<H2>Output</H2>
<p>
各データセットに対して、最大の分割数を１行に出力して下さい。
</p>
<H2>Sample Input</H2>
<pre>
1
3
</pre>
<H2>Output for the Sample Input</H2>
<pre>
2
7
</pre>
|
s592048843 | p00057 | Accepted | while True:
try:
n = int(input())
print(1 + n * (n + 1) // 2)
except EOFError:
break
| 1
3
| 2
7
|
<H1>領域の数</H1>
<p>
無限に広い平面の上に、無限に長い直線を数本引くと、この平面はいくつかの領域に分割されます。たとえば、直線を１本引くと、平面は２つの領域に分割されます。同じ数の直線を引いても、引き方によって得られる領域の数は異なります。たとえば、2 本の直線を平行に引けば得られる領域は 3 つになり、互いに垂直に引けば得られる領域は 4 つになります。
</p>
<center>
<img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_area">
</center>
<br/>
<p>
<var>n</var> 本の直線を引くことで得られる最大の領域の数を出力するプログラムを作成してください。
</p>
<H2>Input</H2>
<p>
複数のデータセットが与えられます。各データセットに <var>n</var> (1 ≤ <var>n</var> ≤ 10,000) が１行に与えられます。入力の最後まで処理して下さい。
</p>
<p>
データセットの数は 50 を超えません。
</p>
<H2>Output</H2>
<p>
各データセットに対して、最大の分割数を１行に出力して下さい。
</p>
<H2>Sample Input</H2>
<pre>
1
3
</pre>
<H2>Output for the Sample Input</H2>
<pre>
2
7
</pre>
|
s168665550 | p00057 | Accepted | import sys
lc=lambda n:int((n**2+n+2)/2)
[print(i) for i in [lc(int(j)) for j in sys.stdin]]
| 1
3
| 2
7
|
<H1>領域の数</H1>
<p>
無限に広い平面の上に、無限に長い直線を数本引くと、この平面はいくつかの領域に分割されます。たとえば、直線を１本引くと、平面は２つの領域に分割されます。同じ数の直線を引いても、引き方によって得られる領域の数は異なります。たとえば、2 本の直線を平行に引けば得られる領域は 3 つになり、互いに垂直に引けば得られる領域は 4 つになります。
</p>
<center>
<img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_area">
</center>
<br/>
<p>
<var>n</var> 本の直線を引くことで得られる最大の領域の数を出力するプログラムを作成してください。
</p>
<H2>Input</H2>
<p>
複数のデータセットが与えられます。各データセットに <var>n</var> (1 ≤ <var>n</var> ≤ 10,000) が１行に与えられます。入力の最後まで処理して下さい。
</p>
<p>
データセットの数は 50 を超えません。
</p>
<H2>Output</H2>
<p>
各データセットに対して、最大の分割数を１行に出力して下さい。
</p>
<H2>Sample Input</H2>
<pre>
1
3
</pre>
<H2>Output for the Sample Input</H2>
<pre>
2
7
</pre>
|
s673247416 | p00057 | Accepted | # AOJ 0057 The Number of Area
# Python3 2018.6.16 bal4u
while True:
try: n= int(input())
except: break
print(1+n*(n+1)//2)
| 1
3
| 2
7
|
<H1>領域の数</H1>
<p>
無限に広い平面の上に、無限に長い直線を数本引くと、この平面はいくつかの領域に分割されます。たとえば、直線を１本引くと、平面は２つの領域に分割されます。同じ数の直線を引いても、引き方によって得られる領域の数は異なります。たとえば、2 本の直線を平行に引けば得られる領域は 3 つになり、互いに垂直に引けば得られる領域は 4 つになります。
</p>
<center>
<img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_area">
</center>
<br/>
<p>
<var>n</var> 本の直線を引くことで得られる最大の領域の数を出力するプログラムを作成してください。
</p>
<H2>Input</H2>
<p>
複数のデータセットが与えられます。各データセットに <var>n</var> (1 ≤ <var>n</var> ≤ 10,000) が１行に与えられます。入力の最後まで処理して下さい。
</p>
<p>
データセットの数は 50 を超えません。
</p>
<H2>Output</H2>
<p>
各データセットに対して、最大の分割数を１行に出力して下さい。
</p>
<H2>Sample Input</H2>
<pre>
1
3
</pre>
<H2>Output for the Sample Input</H2>
<pre>
2
7
</pre>
|
s884374185 | p00057 | Accepted | #!/usr/bin/env python
# coding: utf-8
import sys
def get_answer(param):
answer = 1
for i in xrange(1, param + 1):
answer += i
return answer
def main():
params = [int(line) for line in sys.stdin.readlines()]
for param in params:
print get_answer(param)
if __name__ == '__main__':
main() | 1
3
| 2
7
|
<H1>領域の数</H1>
<p>
無限に広い平面の上に、無限に長い直線を数本引くと、この平面はいくつかの領域に分割されます。たとえば、直線を１本引くと、平面は２つの領域に分割されます。同じ数の直線を引いても、引き方によって得られる領域の数は異なります。たとえば、2 本の直線を平行に引けば得られる領域は 3 つになり、互いに垂直に引けば得られる領域は 4 つになります。
</p>
<center>
<img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_area">
</center>
<br/>
<p>
<var>n</var> 本の直線を引くことで得られる最大の領域の数を出力するプログラムを作成してください。
</p>
<H2>Input</H2>
<p>
複数のデータセットが与えられます。各データセットに <var>n</var> (1 ≤ <var>n</var> ≤ 10,000) が１行に与えられます。入力の最後まで処理して下さい。
</p>
<p>
データセットの数は 50 を超えません。
</p>
<H2>Output</H2>
<p>
各データセットに対して、最大の分割数を１行に出力して下さい。
</p>
<H2>Sample Input</H2>
<pre>
1
3
</pre>
<H2>Output for the Sample Input</H2>
<pre>
2
7
</pre>
|
s648582577 | p00057 | Accepted | import sys
N=10000+1
d=[0]*N
d[0]=1
for i in xrange(1,N):
d[i]=d[i-1]+i
for line in sys.stdin.readlines():
print d[int(line.strip())] | 1
3
| 2
7
|
<H1>領域の数</H1>
<p>
無限に広い平面の上に、無限に長い直線を数本引くと、この平面はいくつかの領域に分割されます。たとえば、直線を１本引くと、平面は２つの領域に分割されます。同じ数の直線を引いても、引き方によって得られる領域の数は異なります。たとえば、2 本の直線を平行に引けば得られる領域は 3 つになり、互いに垂直に引けば得られる領域は 4 つになります。
</p>
<center>
<img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_area">
</center>
<br/>
<p>
<var>n</var> 本の直線を引くことで得られる最大の領域の数を出力するプログラムを作成してください。
</p>
<H2>Input</H2>
<p>
複数のデータセットが与えられます。各データセットに <var>n</var> (1 ≤ <var>n</var> ≤ 10,000) が１行に与えられます。入力の最後まで処理して下さい。
</p>
<p>
データセットの数は 50 を超えません。
</p>
<H2>Output</H2>
<p>
各データセットに対して、最大の分割数を１行に出力して下さい。
</p>
<H2>Sample Input</H2>
<pre>
1
3
</pre>
<H2>Output for the Sample Input</H2>
<pre>
2
7
</pre>
|
s782986578 | p00057 | Accepted | import sys
a = [1]
for i in range(1, 10001):
a.append(a[-1] + i)
for line in sys.stdin:
n = int(line)
print a[n] | 1
3
| 2
7
|
<H1>領域の数</H1>
<p>
無限に広い平面の上に、無限に長い直線を数本引くと、この平面はいくつかの領域に分割されます。たとえば、直線を１本引くと、平面は２つの領域に分割されます。同じ数の直線を引いても、引き方によって得られる領域の数は異なります。たとえば、2 本の直線を平行に引けば得られる領域は 3 つになり、互いに垂直に引けば得られる領域は 4 つになります。
</p>
<center>
<img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_area">
</center>
<br/>
<p>
<var>n</var> 本の直線を引くことで得られる最大の領域の数を出力するプログラムを作成してください。
</p>
<H2>Input</H2>
<p>
複数のデータセットが与えられます。各データセットに <var>n</var> (1 ≤ <var>n</var> ≤ 10,000) が１行に与えられます。入力の最後まで処理して下さい。
</p>
<p>
データセットの数は 50 を超えません。
</p>
<H2>Output</H2>
<p>
各データセットに対して、最大の分割数を１行に出力して下さい。
</p>
<H2>Sample Input</H2>
<pre>
1
3
</pre>
<H2>Output for the Sample Input</H2>
<pre>
2
7
</pre>
|
s105181872 | p00057 | Accepted | while True:
try:
a = int(raw_input())
print (a**2+a+2)/2
except EOFError: break | 1
3
| 2
7
|
<H1>領域の数</H1>
<p>
無限に広い平面の上に、無限に長い直線を数本引くと、この平面はいくつかの領域に分割されます。たとえば、直線を１本引くと、平面は２つの領域に分割されます。同じ数の直線を引いても、引き方によって得られる領域の数は異なります。たとえば、2 本の直線を平行に引けば得られる領域は 3 つになり、互いに垂直に引けば得られる領域は 4 つになります。
</p>
<center>
<img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_area">
</center>
<br/>
<p>
<var>n</var> 本の直線を引くことで得られる最大の領域の数を出力するプログラムを作成してください。
</p>
<H2>Input</H2>
<p>
複数のデータセットが与えられます。各データセットに <var>n</var> (1 ≤ <var>n</var> ≤ 10,000) が１行に与えられます。入力の最後まで処理して下さい。
</p>
<p>
データセットの数は 50 を超えません。
</p>
<H2>Output</H2>
<p>
各データセットに対して、最大の分割数を１行に出力して下さい。
</p>
<H2>Sample Input</H2>
<pre>
1
3
</pre>
<H2>Output for the Sample Input</H2>
<pre>
2
7
</pre>
|
s622406028 | p00057 | Accepted | import sys
dp=[0]*10001
for line in sys.stdin.readlines():
n = int(line)
dp[0]=1
for i in range(1,n+1):
dp[i]=dp[i-1]+i
print dp[n] | 1
3
| 2
7
|
<H1>領域の数</H1>
<p>
無限に広い平面の上に、無限に長い直線を数本引くと、この平面はいくつかの領域に分割されます。たとえば、直線を１本引くと、平面は２つの領域に分割されます。同じ数の直線を引いても、引き方によって得られる領域の数は異なります。たとえば、2 本の直線を平行に引けば得られる領域は 3 つになり、互いに垂直に引けば得られる領域は 4 つになります。
</p>
<center>
<img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_area">
</center>
<br/>
<p>
<var>n</var> 本の直線を引くことで得られる最大の領域の数を出力するプログラムを作成してください。
</p>
<H2>Input</H2>
<p>
複数のデータセットが与えられます。各データセットに <var>n</var> (1 ≤ <var>n</var> ≤ 10,000) が１行に与えられます。入力の最後まで処理して下さい。
</p>
<p>
データセットの数は 50 を超えません。
</p>
<H2>Output</H2>
<p>
各データセットに対して、最大の分割数を１行に出力して下さい。
</p>
<H2>Sample Input</H2>
<pre>
1
3
</pre>
<H2>Output for the Sample Input</H2>
<pre>
2
7
</pre>
|
s217928028 | p00057 | Accepted | import sys
for line in sys.stdin.readlines():
n = int(line)
dp=1
for i in range(1,n+1):
dp+=i
print dp | 1
3
| 2
7
|
<H1>領域の数</H1>
<p>
無限に広い平面の上に、無限に長い直線を数本引くと、この平面はいくつかの領域に分割されます。たとえば、直線を１本引くと、平面は２つの領域に分割されます。同じ数の直線を引いても、引き方によって得られる領域の数は異なります。たとえば、2 本の直線を平行に引けば得られる領域は 3 つになり、互いに垂直に引けば得られる領域は 4 つになります。
</p>
<center>
<img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_area">
</center>
<br/>
<p>
<var>n</var> 本の直線を引くことで得られる最大の領域の数を出力するプログラムを作成してください。
</p>
<H2>Input</H2>
<p>
複数のデータセットが与えられます。各データセットに <var>n</var> (1 ≤ <var>n</var> ≤ 10,000) が１行に与えられます。入力の最後まで処理して下さい。
</p>
<p>
データセットの数は 50 を超えません。
</p>
<H2>Output</H2>
<p>
各データセットに対して、最大の分割数を１行に出力して下さい。
</p>
<H2>Sample Input</H2>
<pre>
1
3
</pre>
<H2>Output for the Sample Input</H2>
<pre>
2
7
</pre>
|
s713925659 | p00057 | Accepted | #!/usr/bin/env python
# -*- coding: utf-8 -*-
from __future__ import (division, absolute_import, print_function,
unicode_literals)
from sys import stdin
L = [1]
for i in xrange(1, 10001):
L.append(i + L[-1])
for line in stdin:
n = int(line)
print(L[n]) | 1
3
| 2
7
|
<H1>領域の数</H1>
<p>
無限に広い平面の上に、無限に長い直線を数本引くと、この平面はいくつかの領域に分割されます。たとえば、直線を１本引くと、平面は２つの領域に分割されます。同じ数の直線を引いても、引き方によって得られる領域の数は異なります。たとえば、2 本の直線を平行に引けば得られる領域は 3 つになり、互いに垂直に引けば得られる領域は 4 つになります。
</p>
<center>
<img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_area">
</center>
<br/>
<p>
<var>n</var> 本の直線を引くことで得られる最大の領域の数を出力するプログラムを作成してください。
</p>
<H2>Input</H2>
<p>
複数のデータセットが与えられます。各データセットに <var>n</var> (1 ≤ <var>n</var> ≤ 10,000) が１行に与えられます。入力の最後まで処理して下さい。
</p>
<p>
データセットの数は 50 を超えません。
</p>
<H2>Output</H2>
<p>
各データセットに対して、最大の分割数を１行に出力して下さい。
</p>
<H2>Sample Input</H2>
<pre>
1
3
</pre>
<H2>Output for the Sample Input</H2>
<pre>
2
7
</pre>
|
s615319366 | p00057 | Accepted | import sys
for s in sys.stdin:
n = int(s)
print (n * n + n + 2) / 2 | 1
3
| 2
7
|
<H1>領域の数</H1>
<p>
無限に広い平面の上に、無限に長い直線を数本引くと、この平面はいくつかの領域に分割されます。たとえば、直線を１本引くと、平面は２つの領域に分割されます。同じ数の直線を引いても、引き方によって得られる領域の数は異なります。たとえば、2 本の直線を平行に引けば得られる領域は 3 つになり、互いに垂直に引けば得られる領域は 4 つになります。
</p>
<center>
<img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_area">
</center>
<br/>
<p>
<var>n</var> 本の直線を引くことで得られる最大の領域の数を出力するプログラムを作成してください。
</p>
<H2>Input</H2>
<p>
複数のデータセットが与えられます。各データセットに <var>n</var> (1 ≤ <var>n</var> ≤ 10,000) が１行に与えられます。入力の最後まで処理して下さい。
</p>
<p>
データセットの数は 50 を超えません。
</p>
<H2>Output</H2>
<p>
各データセットに対して、最大の分割数を１行に出力して下さい。
</p>
<H2>Sample Input</H2>
<pre>
1
3
</pre>
<H2>Output for the Sample Input</H2>
<pre>
2
7
</pre>
|
s957543203 | p00057 | Accepted | import sys
for n in sys.stdin:
n=int(n)
print n*(n+1)/2+1 | 1
3
| 2
7
|
<H1>領域の数</H1>
<p>
無限に広い平面の上に、無限に長い直線を数本引くと、この平面はいくつかの領域に分割されます。たとえば、直線を１本引くと、平面は２つの領域に分割されます。同じ数の直線を引いても、引き方によって得られる領域の数は異なります。たとえば、2 本の直線を平行に引けば得られる領域は 3 つになり、互いに垂直に引けば得られる領域は 4 つになります。
</p>
<center>
<img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_area">
</center>
<br/>
<p>
<var>n</var> 本の直線を引くことで得られる最大の領域の数を出力するプログラムを作成してください。
</p>
<H2>Input</H2>
<p>
複数のデータセットが与えられます。各データセットに <var>n</var> (1 ≤ <var>n</var> ≤ 10,000) が１行に与えられます。入力の最後まで処理して下さい。
</p>
<p>
データセットの数は 50 を超えません。
</p>
<H2>Output</H2>
<p>
各データセットに対して、最大の分割数を１行に出力して下さい。
</p>
<H2>Sample Input</H2>
<pre>
1
3
</pre>
<H2>Output for the Sample Input</H2>
<pre>
2
7
</pre>
|
s328241418 | p00057 | Accepted | while True:
try:
n = int(raw_input())
area = 2
for i in range(n-1):
area += i+2
print area
except:
break | 1
3
| 2
7
|
<H1>領域の数</H1>
<p>
無限に広い平面の上に、無限に長い直線を数本引くと、この平面はいくつかの領域に分割されます。たとえば、直線を１本引くと、平面は２つの領域に分割されます。同じ数の直線を引いても、引き方によって得られる領域の数は異なります。たとえば、2 本の直線を平行に引けば得られる領域は 3 つになり、互いに垂直に引けば得られる領域は 4 つになります。
</p>
<center>
<img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_area">
</center>
<br/>
<p>
<var>n</var> 本の直線を引くことで得られる最大の領域の数を出力するプログラムを作成してください。
</p>
<H2>Input</H2>
<p>
複数のデータセットが与えられます。各データセットに <var>n</var> (1 ≤ <var>n</var> ≤ 10,000) が１行に与えられます。入力の最後まで処理して下さい。
</p>
<p>
データセットの数は 50 を超えません。
</p>
<H2>Output</H2>
<p>
各データセットに対して、最大の分割数を１行に出力して下さい。
</p>
<H2>Sample Input</H2>
<pre>
1
3
</pre>
<H2>Output for the Sample Input</H2>
<pre>
2
7
</pre>
|
s797701840 | p00057 | Accepted | while True:
try:
n = int(raw_input())
print 1 + n*(n+1)/2
except:
break | 1
3
| 2
7
|
<H1>領域の数</H1>
<p>
無限に広い平面の上に、無限に長い直線を数本引くと、この平面はいくつかの領域に分割されます。たとえば、直線を１本引くと、平面は２つの領域に分割されます。同じ数の直線を引いても、引き方によって得られる領域の数は異なります。たとえば、2 本の直線を平行に引けば得られる領域は 3 つになり、互いに垂直に引けば得られる領域は 4 つになります。
</p>
<center>
<img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_area">
</center>
<br/>
<p>
<var>n</var> 本の直線を引くことで得られる最大の領域の数を出力するプログラムを作成してください。
</p>
<H2>Input</H2>
<p>
複数のデータセットが与えられます。各データセットに <var>n</var> (1 ≤ <var>n</var> ≤ 10,000) が１行に与えられます。入力の最後まで処理して下さい。
</p>
<p>
データセットの数は 50 を超えません。
</p>
<H2>Output</H2>
<p>
各データセットに対して、最大の分割数を１行に出力して下さい。
</p>
<H2>Sample Input</H2>
<pre>
1
3
</pre>
<H2>Output for the Sample Input</H2>
<pre>
2
7
</pre>
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.