submission_id string | problem_id string | status string | code string | input string | output string | problem_description string |
|---|---|---|---|---|---|---|
s634323045 | p00044 | Wrong Answer | def main():
while True:
try:
value = int(input())
prime_MAX = 0
for v in range(2,value-1):
flag = 0
for _v in range(2,int(v**0.5)):
if v%_v == 0:
flag = 777
break
if flag == 0:
prime_MAX = v
for v in range(value+1,50000):
flag = 0
for _v in range(2,int(v**0.5)):
if v%_v == 0:
flag = 777
break
if flag == 0:
print(str(prime_MAX)+" "+str(v))
break
except EOFError:
break
if __name__ == '__main__':
main()
| 19
3517
| 17 23
3511 3527
|
<H1>素数 II</H1>
<p>
素数というのは、1 よりも大きくそれ自身か 1 でしか割りきれない整数をいいます。例えば、2 は、2 と 1 でしか割り切れないので素数ですが、12 は、12 と 1 のほかに、2, 3, 4, 6 で割りきれる数なので素数ではありません。
</p>
<p>
整数 <var>n</var> を入力したとき、<var>n</var> より小さい素数のうち最も大きいものと、<var>n</var> より大きい素数のうち最も小さいものを出力するプログラムを作成してください。
</p>
<H2>Input</H2>
<p>
複数のデータセットが与えられます。各データセットに <var>n</var> (3 ≤ <var>n</var> ≤ 50,000) が１行に与えられます。
</p>
<p>
データセットの数は 50 を超えません。
</p>
<H2>Output</H2>
<p>
各データセットに対して、<var>n</var> より小さい素数のうち最大のものと、<var>n</var> より大きい素数のうち最小のものを１つのスペースで区切って１行に出力して下さい。
</p>
<H2>Sample Input</H2>
<pre>
19
3517
</pre>
<H2>Output for the Sample Input</H2>
<pre>
17 23
3511 3527
</pre>
|
s925047308 | p00044 | Wrong Answer | def is_prime(q):
q = abs(q)
if q == 2: return True
if q < 2 or q&1 == 0: return False
return pow(2, q-1, q) == 1
def main():
while True:
try:
value = int(input())
prime_MAX = 0
for v in range(2,value-1):
if is_prime(v):
prime_MAX = v
for v in range(value+1,50000):
if is_prime(v):
break
print(str(prime_MAX)+" "+str(v))
except EOFError:
break
if __name__ == '__main__':
main()
| 19
3517
| 17 23
3511 3527
|
<H1>素数 II</H1>
<p>
素数というのは、1 よりも大きくそれ自身か 1 でしか割りきれない整数をいいます。例えば、2 は、2 と 1 でしか割り切れないので素数ですが、12 は、12 と 1 のほかに、2, 3, 4, 6 で割りきれる数なので素数ではありません。
</p>
<p>
整数 <var>n</var> を入力したとき、<var>n</var> より小さい素数のうち最も大きいものと、<var>n</var> より大きい素数のうち最も小さいものを出力するプログラムを作成してください。
</p>
<H2>Input</H2>
<p>
複数のデータセットが与えられます。各データセットに <var>n</var> (3 ≤ <var>n</var> ≤ 50,000) が１行に与えられます。
</p>
<p>
データセットの数は 50 を超えません。
</p>
<H2>Output</H2>
<p>
各データセットに対して、<var>n</var> より小さい素数のうち最大のものと、<var>n</var> より大きい素数のうち最小のものを１つのスペースで区切って１行に出力して下さい。
</p>
<H2>Sample Input</H2>
<pre>
19
3517
</pre>
<H2>Output for the Sample Input</H2>
<pre>
17 23
3511 3527
</pre>
|
s432199249 | p00044 | Wrong Answer | def is_prime(q):
q = abs(q)
if q == 2: return True
if q < 2 or q&1 == 0: return False
return pow(2, q-1, q) == 1
def main():
while True:
try:
value = int(input())
prime_MAX = 0
for v in range(2,value):
if is_prime(v):
prime_MAX = v
for v in range(value+1,50001):
if is_prime(v):
break
print(str(prime_MAX)+" "+str(v))
except EOFError:
break
if __name__ == '__main__':
main()
| 19
3517
| 17 23
3511 3527
|
<H1>素数 II</H1>
<p>
素数というのは、1 よりも大きくそれ自身か 1 でしか割りきれない整数をいいます。例えば、2 は、2 と 1 でしか割り切れないので素数ですが、12 は、12 と 1 のほかに、2, 3, 4, 6 で割りきれる数なので素数ではありません。
</p>
<p>
整数 <var>n</var> を入力したとき、<var>n</var> より小さい素数のうち最も大きいものと、<var>n</var> より大きい素数のうち最も小さいものを出力するプログラムを作成してください。
</p>
<H2>Input</H2>
<p>
複数のデータセットが与えられます。各データセットに <var>n</var> (3 ≤ <var>n</var> ≤ 50,000) が１行に与えられます。
</p>
<p>
データセットの数は 50 を超えません。
</p>
<H2>Output</H2>
<p>
各データセットに対して、<var>n</var> より小さい素数のうち最大のものと、<var>n</var> より大きい素数のうち最小のものを１つのスペースで区切って１行に出力して下さい。
</p>
<H2>Sample Input</H2>
<pre>
19
3517
</pre>
<H2>Output for the Sample Input</H2>
<pre>
17 23
3511 3527
</pre>
|
s307754484 | p00044 | Wrong Answer | import math
def is_prime(q):
q = abs(q)
if q == 2: return True
if q < 2 or q&1 == 0: return False
return pow(2, q-1, q) == 1
def main():
while True:
try:
value = int(input())
for v in range(0,value):
if is_prime(v):
prime_MAX = v
for v in range(value+1,10000):
if is_prime(v):
break
print(str(prime_MAX)+" "+str(v))
except EOFError:
break
if __name__ == '__main__':
main()
| 19
3517
| 17 23
3511 3527
|
<H1>素数 II</H1>
<p>
素数というのは、1 よりも大きくそれ自身か 1 でしか割りきれない整数をいいます。例えば、2 は、2 と 1 でしか割り切れないので素数ですが、12 は、12 と 1 のほかに、2, 3, 4, 6 で割りきれる数なので素数ではありません。
</p>
<p>
整数 <var>n</var> を入力したとき、<var>n</var> より小さい素数のうち最も大きいものと、<var>n</var> より大きい素数のうち最も小さいものを出力するプログラムを作成してください。
</p>
<H2>Input</H2>
<p>
複数のデータセットが与えられます。各データセットに <var>n</var> (3 ≤ <var>n</var> ≤ 50,000) が１行に与えられます。
</p>
<p>
データセットの数は 50 を超えません。
</p>
<H2>Output</H2>
<p>
各データセットに対して、<var>n</var> より小さい素数のうち最大のものと、<var>n</var> より大きい素数のうち最小のものを１つのスペースで区切って１行に出力して下さい。
</p>
<H2>Sample Input</H2>
<pre>
19
3517
</pre>
<H2>Output for the Sample Input</H2>
<pre>
17 23
3511 3527
</pre>
|
s215574910 | p00044 | Wrong Answer | import math
import os
import sys
def is_prime(q):
q = abs(q)
if q == 2: return True
if q < 2 or q&1 == 0: return False
return pow(2, q-1, q) == 1
def main():
for Value in sys.stdin:
value = int(Value)
for v in range(0,value):
if is_prime(v):
prime_MAX = v
for v in range(value+1,10000):
if is_prime(v):
break
print(str(prime_MAX)+" "+str(v))
if __name__ == '__main__':
main()
| 19
3517
| 17 23
3511 3527
|
<H1>素数 II</H1>
<p>
素数というのは、1 よりも大きくそれ自身か 1 でしか割りきれない整数をいいます。例えば、2 は、2 と 1 でしか割り切れないので素数ですが、12 は、12 と 1 のほかに、2, 3, 4, 6 で割りきれる数なので素数ではありません。
</p>
<p>
整数 <var>n</var> を入力したとき、<var>n</var> より小さい素数のうち最も大きいものと、<var>n</var> より大きい素数のうち最も小さいものを出力するプログラムを作成してください。
</p>
<H2>Input</H2>
<p>
複数のデータセットが与えられます。各データセットに <var>n</var> (3 ≤ <var>n</var> ≤ 50,000) が１行に与えられます。
</p>
<p>
データセットの数は 50 を超えません。
</p>
<H2>Output</H2>
<p>
各データセットに対して、<var>n</var> より小さい素数のうち最大のものと、<var>n</var> より大きい素数のうち最小のものを１つのスペースで区切って１行に出力して下さい。
</p>
<H2>Sample Input</H2>
<pre>
19
3517
</pre>
<H2>Output for the Sample Input</H2>
<pre>
17 23
3511 3527
</pre>
|
s981730130 | p00044 | Wrong Answer | import math
import os
import sys
def is_prime(q):
q = abs(q)
if q == 2: return True
if q < 2 or q&1 == 0: return False
return pow(2, q-1, q) == 1
def main():
for Value in sys.stdin:
value = int(Value)
for v in range(0,value):
if is_prime(v):
prime_MAX = v
for v in range(value+1,10000):
if is_prime(v):
break
print(prime_MAX,v)
if __name__ == '__main__':
main()
| 19
3517
| 17 23
3511 3527
|
<H1>素数 II</H1>
<p>
素数というのは、1 よりも大きくそれ自身か 1 でしか割りきれない整数をいいます。例えば、2 は、2 と 1 でしか割り切れないので素数ですが、12 は、12 と 1 のほかに、2, 3, 4, 6 で割りきれる数なので素数ではありません。
</p>
<p>
整数 <var>n</var> を入力したとき、<var>n</var> より小さい素数のうち最も大きいものと、<var>n</var> より大きい素数のうち最も小さいものを出力するプログラムを作成してください。
</p>
<H2>Input</H2>
<p>
複数のデータセットが与えられます。各データセットに <var>n</var> (3 ≤ <var>n</var> ≤ 50,000) が１行に与えられます。
</p>
<p>
データセットの数は 50 を超えません。
</p>
<H2>Output</H2>
<p>
各データセットに対して、<var>n</var> より小さい素数のうち最大のものと、<var>n</var> より大きい素数のうち最小のものを１つのスペースで区切って１行に出力して下さい。
</p>
<H2>Sample Input</H2>
<pre>
19
3517
</pre>
<H2>Output for the Sample Input</H2>
<pre>
17 23
3511 3527
</pre>
|
s159147184 | p00044 | Wrong Answer | n = 50000
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:
try:
n = int(input())
i, a, b = 0, 0, 0
while a == 0 and b == 0:
i += 1
if n - i >= 0 and a == 0 and c[n - i] == 1:
a = n - i
if n + i < 50000 and b == 0 and c[n + i] == 1:
b = n + i
print(a,b)
except:
break
| 19
3517
| 17 23
3511 3527
|
<H1>素数 II</H1>
<p>
素数というのは、1 よりも大きくそれ自身か 1 でしか割りきれない整数をいいます。例えば、2 は、2 と 1 でしか割り切れないので素数ですが、12 は、12 と 1 のほかに、2, 3, 4, 6 で割りきれる数なので素数ではありません。
</p>
<p>
整数 <var>n</var> を入力したとき、<var>n</var> より小さい素数のうち最も大きいものと、<var>n</var> より大きい素数のうち最も小さいものを出力するプログラムを作成してください。
</p>
<H2>Input</H2>
<p>
複数のデータセットが与えられます。各データセットに <var>n</var> (3 ≤ <var>n</var> ≤ 50,000) が１行に与えられます。
</p>
<p>
データセットの数は 50 を超えません。
</p>
<H2>Output</H2>
<p>
各データセットに対して、<var>n</var> より小さい素数のうち最大のものと、<var>n</var> より大きい素数のうち最小のものを１つのスペースで区切って１行に出力して下さい。
</p>
<H2>Sample Input</H2>
<pre>
19
3517
</pre>
<H2>Output for the Sample Input</H2>
<pre>
17 23
3511 3527
</pre>
|
s808396367 | p00044 | Wrong Answer | n = 50000
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
c2 = []
for i in range(50000):
if c[i] == 1:
c2.append(i + 1)
while True:
try:
n = int(input())
n_ind = c2.index(n)
print(c2[n_ind - 1], c2[n_ind + 1])
except:
break
| 19
3517
| 17 23
3511 3527
|
<H1>素数 II</H1>
<p>
素数というのは、1 よりも大きくそれ自身か 1 でしか割りきれない整数をいいます。例えば、2 は、2 と 1 でしか割り切れないので素数ですが、12 は、12 と 1 のほかに、2, 3, 4, 6 で割りきれる数なので素数ではありません。
</p>
<p>
整数 <var>n</var> を入力したとき、<var>n</var> より小さい素数のうち最も大きいものと、<var>n</var> より大きい素数のうち最も小さいものを出力するプログラムを作成してください。
</p>
<H2>Input</H2>
<p>
複数のデータセットが与えられます。各データセットに <var>n</var> (3 ≤ <var>n</var> ≤ 50,000) が１行に与えられます。
</p>
<p>
データセットの数は 50 を超えません。
</p>
<H2>Output</H2>
<p>
各データセットに対して、<var>n</var> より小さい素数のうち最大のものと、<var>n</var> より大きい素数のうち最小のものを１つのスペースで区切って１行に出力して下さい。
</p>
<H2>Sample Input</H2>
<pre>
19
3517
</pre>
<H2>Output for the Sample Input</H2>
<pre>
17 23
3511 3527
</pre>
|
s495322535 | p00044 | Wrong Answer | a = [0, 0, 1, 1] + [0, 1] * 24999
for i in range(3, 50001, 2):
if a[i]:
for j in range(2, 50001 // i):a[i * j] = 0
while 1:
try:
n = int(input())
print("{} {}".format(n - 1 - a[:n][::-1].index(1), n + 1 + a[n + 1:].index(1)))
except:break
| 19
3517
| 17 23
3511 3527
|
<H1>素数 II</H1>
<p>
素数というのは、1 よりも大きくそれ自身か 1 でしか割りきれない整数をいいます。例えば、2 は、2 と 1 でしか割り切れないので素数ですが、12 は、12 と 1 のほかに、2, 3, 4, 6 で割りきれる数なので素数ではありません。
</p>
<p>
整数 <var>n</var> を入力したとき、<var>n</var> より小さい素数のうち最も大きいものと、<var>n</var> より大きい素数のうち最も小さいものを出力するプログラムを作成してください。
</p>
<H2>Input</H2>
<p>
複数のデータセットが与えられます。各データセットに <var>n</var> (3 ≤ <var>n</var> ≤ 50,000) が１行に与えられます。
</p>
<p>
データセットの数は 50 を超えません。
</p>
<H2>Output</H2>
<p>
各データセットに対して、<var>n</var> より小さい素数のうち最大のものと、<var>n</var> より大きい素数のうち最小のものを１つのスペースで区切って１行に出力して下さい。
</p>
<H2>Sample Input</H2>
<pre>
19
3517
</pre>
<H2>Output for the Sample Input</H2>
<pre>
17 23
3511 3527
</pre>
|
s739199905 | p00044 | Wrong Answer | import bisect
MAX = 60000
#エラトステネスの篩
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:
try:
n = int(input())
ind = bisect.bisect_left(primes, n)
if primes[ind] == n:
print(primes[ind - 1], primes[ind + 1])
else:
print(primes[ind], primes[ind + 1])
except EOFError:
break
| 19
3517
| 17 23
3511 3527
|
<H1>素数 II</H1>
<p>
素数というのは、1 よりも大きくそれ自身か 1 でしか割りきれない整数をいいます。例えば、2 は、2 と 1 でしか割り切れないので素数ですが、12 は、12 と 1 のほかに、2, 3, 4, 6 で割りきれる数なので素数ではありません。
</p>
<p>
整数 <var>n</var> を入力したとき、<var>n</var> より小さい素数のうち最も大きいものと、<var>n</var> より大きい素数のうち最も小さいものを出力するプログラムを作成してください。
</p>
<H2>Input</H2>
<p>
複数のデータセットが与えられます。各データセットに <var>n</var> (3 ≤ <var>n</var> ≤ 50,000) が１行に与えられます。
</p>
<p>
データセットの数は 50 を超えません。
</p>
<H2>Output</H2>
<p>
各データセットに対して、<var>n</var> より小さい素数のうち最大のものと、<var>n</var> より大きい素数のうち最小のものを１つのスペースで区切って１行に出力して下さい。
</p>
<H2>Sample Input</H2>
<pre>
19
3517
</pre>
<H2>Output for the Sample Input</H2>
<pre>
17 23
3511 3527
</pre>
|
s504026286 | p00044 | Wrong Answer | q=[]
for i in range(2,10000):
for j in range(2,i):
if i % j == 0:
break
else:
q.append(i)
if __name__ =='__main__':
while True:
try:
a = int(input())
if a in q:
ans = q.index(a)
print q[ans-1],q[ans+1]
else:
for i in range(100):
if a-i in q:
ans = q.index(a-i)
print q[ans-1],q[ans+1]
break
elif a+i in q:
print q[ans-1],q[ans+1]
break
except EOFError: break | 19
3517
| 17 23
3511 3527
|
<H1>素数 II</H1>
<p>
素数というのは、1 よりも大きくそれ自身か 1 でしか割りきれない整数をいいます。例えば、2 は、2 と 1 でしか割り切れないので素数ですが、12 は、12 と 1 のほかに、2, 3, 4, 6 で割りきれる数なので素数ではありません。
</p>
<p>
整数 <var>n</var> を入力したとき、<var>n</var> より小さい素数のうち最も大きいものと、<var>n</var> より大きい素数のうち最も小さいものを出力するプログラムを作成してください。
</p>
<H2>Input</H2>
<p>
複数のデータセットが与えられます。各データセットに <var>n</var> (3 ≤ <var>n</var> ≤ 50,000) が１行に与えられます。
</p>
<p>
データセットの数は 50 を超えません。
</p>
<H2>Output</H2>
<p>
各データセットに対して、<var>n</var> より小さい素数のうち最大のものと、<var>n</var> より大きい素数のうち最小のものを１つのスペースで区切って１行に出力して下さい。
</p>
<H2>Sample Input</H2>
<pre>
19
3517
</pre>
<H2>Output for the Sample Input</H2>
<pre>
17 23
3511 3527
</pre>
|
s021656450 | p00044 | Wrong Answer | def is_prime(q):
q = abs(q)
if q == 2: return True
if q < 2 or q&1 == 0: return False
return pow(2, q-1, q) == 1
n=input()
a,b=n,n
while 1:
a+=1
if is_prime(a):
max_a=a
break
while 1:
b-=1
if is_prime(b):
min_b=b
break
print min_b,max_a | 19
3517
| 17 23
3511 3527
|
<H1>素数 II</H1>
<p>
素数というのは、1 よりも大きくそれ自身か 1 でしか割りきれない整数をいいます。例えば、2 は、2 と 1 でしか割り切れないので素数ですが、12 は、12 と 1 のほかに、2, 3, 4, 6 で割りきれる数なので素数ではありません。
</p>
<p>
整数 <var>n</var> を入力したとき、<var>n</var> より小さい素数のうち最も大きいものと、<var>n</var> より大きい素数のうち最も小さいものを出力するプログラムを作成してください。
</p>
<H2>Input</H2>
<p>
複数のデータセットが与えられます。各データセットに <var>n</var> (3 ≤ <var>n</var> ≤ 50,000) が１行に与えられます。
</p>
<p>
データセットの数は 50 を超えません。
</p>
<H2>Output</H2>
<p>
各データセットに対して、<var>n</var> より小さい素数のうち最大のものと、<var>n</var> より大きい素数のうち最小のものを１つのスペースで区切って１行に出力して下さい。
</p>
<H2>Sample Input</H2>
<pre>
19
3517
</pre>
<H2>Output for the Sample Input</H2>
<pre>
17 23
3511 3527
</pre>
|
s329015744 | p00044 | Wrong Answer | #!/usr/bin/env python
# -*- coding: utf-8 -*-
from __future__ import (division, absolute_import, print_function,
unicode_literals)
from sys import stdin
def prime(n):
L = list(xrange(2, n))
P = []
while L[0] ** 2 < n:
P.append(L[0])
L = [i for i in L if i % P[-1]]
return P + L
ps = prime(50030)
for line in stdin:
n = int(line)
for p in ps:
if n < p:
upper = p
break
under = p
print(under, upper) | 19
3517
| 17 23
3511 3527
|
<H1>素数 II</H1>
<p>
素数というのは、1 よりも大きくそれ自身か 1 でしか割りきれない整数をいいます。例えば、2 は、2 と 1 でしか割り切れないので素数ですが、12 は、12 と 1 のほかに、2, 3, 4, 6 で割りきれる数なので素数ではありません。
</p>
<p>
整数 <var>n</var> を入力したとき、<var>n</var> より小さい素数のうち最も大きいものと、<var>n</var> より大きい素数のうち最も小さいものを出力するプログラムを作成してください。
</p>
<H2>Input</H2>
<p>
複数のデータセットが与えられます。各データセットに <var>n</var> (3 ≤ <var>n</var> ≤ 50,000) が１行に与えられます。
</p>
<p>
データセットの数は 50 を超えません。
</p>
<H2>Output</H2>
<p>
各データセットに対して、<var>n</var> より小さい素数のうち最大のものと、<var>n</var> より大きい素数のうち最小のものを１つのスペースで区切って１行に出力して下さい。
</p>
<H2>Sample Input</H2>
<pre>
19
3517
</pre>
<H2>Output for the Sample Input</H2>
<pre>
17 23
3511 3527
</pre>
|
s235086321 | p00044 | Wrong Answer | import sys
p = [True] * (50001)
p[0] = p[1] = False
for i in range(2, 50001):
if p[i]:
for j in range(i * 2, 50001, i):
p[j] = False
for s in sys.stdin.read().rstrip().split('\n'):
n = int(s)
for i in range(n-1, 0, -1):
if p[i]:
m1 = i
break
for i in range(n+1, len(p)):
if p[i]:
m2 = i
break
print m1, m2 | 19
3517
| 17 23
3511 3527
|
<H1>素数 II</H1>
<p>
素数というのは、1 よりも大きくそれ自身か 1 でしか割りきれない整数をいいます。例えば、2 は、2 と 1 でしか割り切れないので素数ですが、12 は、12 と 1 のほかに、2, 3, 4, 6 で割りきれる数なので素数ではありません。
</p>
<p>
整数 <var>n</var> を入力したとき、<var>n</var> より小さい素数のうち最も大きいものと、<var>n</var> より大きい素数のうち最も小さいものを出力するプログラムを作成してください。
</p>
<H2>Input</H2>
<p>
複数のデータセットが与えられます。各データセットに <var>n</var> (3 ≤ <var>n</var> ≤ 50,000) が１行に与えられます。
</p>
<p>
データセットの数は 50 を超えません。
</p>
<H2>Output</H2>
<p>
各データセットに対して、<var>n</var> より小さい素数のうち最大のものと、<var>n</var> より大きい素数のうち最小のものを１つのスペースで区切って１行に出力して下さい。
</p>
<H2>Sample Input</H2>
<pre>
19
3517
</pre>
<H2>Output for the Sample Input</H2>
<pre>
17 23
3511 3527
</pre>
|
s414778903 | p00044 | Wrong Answer | import math
def get_primes(max_number):
if max_number == 2:
return [2]
elif max_number < 3:
return []
numbers = range(1, max_number + 2, 2)
nroot = math.floor(max_number ** 0.5)
n = len(numbers)
numbers[0] = 0
for i in range(1, n):
x = numbers[i]
if x > nroot:
break
if x and i + x < n:
for j in range(i+x, n, x):
numbers[j] = 0
x=[2] + filter(None, numbers[1:])
return x
primes = get_primes(50000)
while True:
try:
n = input()
except:
break
for a in primes:
if a<n: b=a
elif a>n: break
print b,a | 19
3517
| 17 23
3511 3527
|
<H1>素数 II</H1>
<p>
素数というのは、1 よりも大きくそれ自身か 1 でしか割りきれない整数をいいます。例えば、2 は、2 と 1 でしか割り切れないので素数ですが、12 は、12 と 1 のほかに、2, 3, 4, 6 で割りきれる数なので素数ではありません。
</p>
<p>
整数 <var>n</var> を入力したとき、<var>n</var> より小さい素数のうち最も大きいものと、<var>n</var> より大きい素数のうち最も小さいものを出力するプログラムを作成してください。
</p>
<H2>Input</H2>
<p>
複数のデータセットが与えられます。各データセットに <var>n</var> (3 ≤ <var>n</var> ≤ 50,000) が１行に与えられます。
</p>
<p>
データセットの数は 50 を超えません。
</p>
<H2>Output</H2>
<p>
各データセットに対して、<var>n</var> より小さい素数のうち最大のものと、<var>n</var> より大きい素数のうち最小のものを１つのスペースで区切って１行に出力して下さい。
</p>
<H2>Sample Input</H2>
<pre>
19
3517
</pre>
<H2>Output for the Sample Input</H2>
<pre>
17 23
3511 3527
</pre>
|
s275746853 | p00044 | Wrong Answer | import math
r = 50000
sqrt = int(math.sqrt(r))
p = [1]*r
p[0] = 0
for i in range(1,sqrt):
if p[i]:
for j in range(2*i+1,r,i+1):
p[j] = 0
while True:
try:
n = int(raw_input())
for i in range(n,50000):
if p[i] == 1:
lp = i+1
break
for i in range(n-2,3,-1):
if p[i] == 1:
sp = i+1
break
print sp, lp
except:
break | 19
3517
| 17 23
3511 3527
|
<H1>素数 II</H1>
<p>
素数というのは、1 よりも大きくそれ自身か 1 でしか割りきれない整数をいいます。例えば、2 は、2 と 1 でしか割り切れないので素数ですが、12 は、12 と 1 のほかに、2, 3, 4, 6 で割りきれる数なので素数ではありません。
</p>
<p>
整数 <var>n</var> を入力したとき、<var>n</var> より小さい素数のうち最も大きいものと、<var>n</var> より大きい素数のうち最も小さいものを出力するプログラムを作成してください。
</p>
<H2>Input</H2>
<p>
複数のデータセットが与えられます。各データセットに <var>n</var> (3 ≤ <var>n</var> ≤ 50,000) が１行に与えられます。
</p>
<p>
データセットの数は 50 を超えません。
</p>
<H2>Output</H2>
<p>
各データセットに対して、<var>n</var> より小さい素数のうち最大のものと、<var>n</var> より大きい素数のうち最小のものを１つのスペースで区切って１行に出力して下さい。
</p>
<H2>Sample Input</H2>
<pre>
19
3517
</pre>
<H2>Output for the Sample Input</H2>
<pre>
17 23
3511 3527
</pre>
|
s002370677 | p00044 | Wrong Answer | import math
r = 50000
sqrt = int(math.sqrt(r))
p = [1]*r
p[0] = 0
for i in range(1,sqrt):
if p[i]:
for j in range(2*i+1,r,i+1):
p[j] = 0
while True:
try:
n = int(raw_input())
for i in range(n,50000):
if p[i] == 1:
lp = i+1
break
for i in range(n-2,0,-1):
if p[i] == 1:
sp = i+1
break
print sp, lp
except:
break | 19
3517
| 17 23
3511 3527
|
<H1>素数 II</H1>
<p>
素数というのは、1 よりも大きくそれ自身か 1 でしか割りきれない整数をいいます。例えば、2 は、2 と 1 でしか割り切れないので素数ですが、12 は、12 と 1 のほかに、2, 3, 4, 6 で割りきれる数なので素数ではありません。
</p>
<p>
整数 <var>n</var> を入力したとき、<var>n</var> より小さい素数のうち最も大きいものと、<var>n</var> より大きい素数のうち最も小さいものを出力するプログラムを作成してください。
</p>
<H2>Input</H2>
<p>
複数のデータセットが与えられます。各データセットに <var>n</var> (3 ≤ <var>n</var> ≤ 50,000) が１行に与えられます。
</p>
<p>
データセットの数は 50 を超えません。
</p>
<H2>Output</H2>
<p>
各データセットに対して、<var>n</var> より小さい素数のうち最大のものと、<var>n</var> より大きい素数のうち最小のものを１つのスペースで区切って１行に出力して下さい。
</p>
<H2>Sample Input</H2>
<pre>
19
3517
</pre>
<H2>Output for the Sample Input</H2>
<pre>
17 23
3511 3527
</pre>
|
s170875452 | p00044 | Wrong Answer | import math
r = 51000
sqrt = int(math.sqrt(r))
p = [1]*r
p[0] = 0
for i in range(1,sqrt):
if p[i]:
for j in range(2*i+1,r,i+1):
p[j] = 0
while True:
try:
n = int(raw_input())
for i in range(n,50000):
if p[i] == 1:
lp = i+1
break
for i in range(n-2,0,-1):
if p[i] == 1:
sp = i+1
break
print sp, lp
except:
break | 19
3517
| 17 23
3511 3527
|
<H1>素数 II</H1>
<p>
素数というのは、1 よりも大きくそれ自身か 1 でしか割りきれない整数をいいます。例えば、2 は、2 と 1 でしか割り切れないので素数ですが、12 は、12 と 1 のほかに、2, 3, 4, 6 で割りきれる数なので素数ではありません。
</p>
<p>
整数 <var>n</var> を入力したとき、<var>n</var> より小さい素数のうち最も大きいものと、<var>n</var> より大きい素数のうち最も小さいものを出力するプログラムを作成してください。
</p>
<H2>Input</H2>
<p>
複数のデータセットが与えられます。各データセットに <var>n</var> (3 ≤ <var>n</var> ≤ 50,000) が１行に与えられます。
</p>
<p>
データセットの数は 50 を超えません。
</p>
<H2>Output</H2>
<p>
各データセットに対して、<var>n</var> より小さい素数のうち最大のものと、<var>n</var> より大きい素数のうち最小のものを１つのスペースで区切って１行に出力して下さい。
</p>
<H2>Sample Input</H2>
<pre>
19
3517
</pre>
<H2>Output for the Sample Input</H2>
<pre>
17 23
3511 3527
</pre>
|
s648462985 | p00044 | Wrong Answer | N = 50001
a = [True] * N
i = 3
while i * i < N:
for j in range(3 * i, N, 2 * i): a[j] = False
i += 2
while True:
try:
n = int(input())
except:
break
n0 = n + 2 if (n & 1) else n + 1
for maxv in range(n0, N, 2):
if a[maxv]: break
n0 = n - 2 if (n & 1) else n - 1
for minv in range(n0, 2, -2):
if a[minv]: break
else:
minv = 2
print(minv, maxv) | 19
3517
| 17 23
3511 3527
|
<H1>素数 II</H1>
<p>
素数というのは、1 よりも大きくそれ自身か 1 でしか割りきれない整数をいいます。例えば、2 は、2 と 1 でしか割り切れないので素数ですが、12 は、12 と 1 のほかに、2, 3, 4, 6 で割りきれる数なので素数ではありません。
</p>
<p>
整数 <var>n</var> を入力したとき、<var>n</var> より小さい素数のうち最も大きいものと、<var>n</var> より大きい素数のうち最も小さいものを出力するプログラムを作成してください。
</p>
<H2>Input</H2>
<p>
複数のデータセットが与えられます。各データセットに <var>n</var> (3 ≤ <var>n</var> ≤ 50,000) が１行に与えられます。
</p>
<p>
データセットの数は 50 を超えません。
</p>
<H2>Output</H2>
<p>
各データセットに対して、<var>n</var> より小さい素数のうち最大のものと、<var>n</var> より大きい素数のうち最小のものを１つのスペースで区切って１行に出力して下さい。
</p>
<H2>Sample Input</H2>
<pre>
19
3517
</pre>
<H2>Output for the Sample Input</H2>
<pre>
17 23
3511 3527
</pre>
|
s375287156 | p00044 | Wrong Answer | N = 50010
a = [True] * N
i = 3
while i * i < N:
for j in range(3 * i, N, 2 * i): a[j] = False
i += 2
while True:
try:
n = int(input())
except:
break
n0 = n + 2 if (n & 1) else n + 1
for maxv in range(n0, N, 2):
if a[maxv]: break
n0 = n - 2 if (n & 1) else n - 1
for minv in range(n0, 2, -2):
if a[minv]: break
else:
minv = 2
print(minv, maxv) | 19
3517
| 17 23
3511 3527
|
<H1>素数 II</H1>
<p>
素数というのは、1 よりも大きくそれ自身か 1 でしか割りきれない整数をいいます。例えば、2 は、2 と 1 でしか割り切れないので素数ですが、12 は、12 と 1 のほかに、2, 3, 4, 6 で割りきれる数なので素数ではありません。
</p>
<p>
整数 <var>n</var> を入力したとき、<var>n</var> より小さい素数のうち最も大きいものと、<var>n</var> より大きい素数のうち最も小さいものを出力するプログラムを作成してください。
</p>
<H2>Input</H2>
<p>
複数のデータセットが与えられます。各データセットに <var>n</var> (3 ≤ <var>n</var> ≤ 50,000) が１行に与えられます。
</p>
<p>
データセットの数は 50 を超えません。
</p>
<H2>Output</H2>
<p>
各データセットに対して、<var>n</var> より小さい素数のうち最大のものと、<var>n</var> より大きい素数のうち最小のものを１つのスペースで区切って１行に出力して下さい。
</p>
<H2>Sample Input</H2>
<pre>
19
3517
</pre>
<H2>Output for the Sample Input</H2>
<pre>
17 23
3511 3527
</pre>
|
s931782522 | p00044 | Time Limit Exceeded | import sys
def primegen():
l = [2]
while True:
yield max(l)
n = max(l)
while True:
n += 1
flag = 1
for i in l:
if n % i == 0:
flag = 0
break
if flag:
l.append(n)
break
for line in sys.stdin:
n = int(line)
seq = primegen()
i1 = 0
i2 = 0
while i2 < n:
i1 = i2
i2 = seq.__next__()
if i2 == n:
i2 = seq.__next__()
print(str(i1) + " " + str(i2)) | 19
3517
| 17 23
3511 3527
|
<H1>素数 II</H1>
<p>
素数というのは、1 よりも大きくそれ自身か 1 でしか割りきれない整数をいいます。例えば、2 は、2 と 1 でしか割り切れないので素数ですが、12 は、12 と 1 のほかに、2, 3, 4, 6 で割りきれる数なので素数ではありません。
</p>
<p>
整数 <var>n</var> を入力したとき、<var>n</var> より小さい素数のうち最も大きいものと、<var>n</var> より大きい素数のうち最も小さいものを出力するプログラムを作成してください。
</p>
<H2>Input</H2>
<p>
複数のデータセットが与えられます。各データセットに <var>n</var> (3 ≤ <var>n</var> ≤ 50,000) が１行に与えられます。
</p>
<p>
データセットの数は 50 を超えません。
</p>
<H2>Output</H2>
<p>
各データセットに対して、<var>n</var> より小さい素数のうち最大のものと、<var>n</var> より大きい素数のうち最小のものを１つのスペースで区切って１行に出力して下さい。
</p>
<H2>Sample Input</H2>
<pre>
19
3517
</pre>
<H2>Output for the Sample Input</H2>
<pre>
17 23
3511 3527
</pre>
|
s632620955 | p00044 | Time Limit Exceeded | def main():
while True:
try:
value = int(input())
prime_MAX = 0
for v in range(2,value-1):
flag = 0
for _v in range(2,v):
if v%_v == 0:
flag = 777
break
if flag == 0:
prime_MAX = v
for v in range(value+1,50000):
flag = 0
for _v in range(2,v):
if v%_v == 0:
flag = 777
break
if flag == 0:
print(str(prime_MAX)+" "+str(v))
break
except EOFError:
break
if __name__ == '__main__':
main()
| 19
3517
| 17 23
3511 3527
|
<H1>素数 II</H1>
<p>
素数というのは、1 よりも大きくそれ自身か 1 でしか割りきれない整数をいいます。例えば、2 は、2 と 1 でしか割り切れないので素数ですが、12 は、12 と 1 のほかに、2, 3, 4, 6 で割りきれる数なので素数ではありません。
</p>
<p>
整数 <var>n</var> を入力したとき、<var>n</var> より小さい素数のうち最も大きいものと、<var>n</var> より大きい素数のうち最も小さいものを出力するプログラムを作成してください。
</p>
<H2>Input</H2>
<p>
複数のデータセットが与えられます。各データセットに <var>n</var> (3 ≤ <var>n</var> ≤ 50,000) が１行に与えられます。
</p>
<p>
データセットの数は 50 を超えません。
</p>
<H2>Output</H2>
<p>
各データセットに対して、<var>n</var> より小さい素数のうち最大のものと、<var>n</var> より大きい素数のうち最小のものを１つのスペースで区切って１行に出力して下さい。
</p>
<H2>Sample Input</H2>
<pre>
19
3517
</pre>
<H2>Output for the Sample Input</H2>
<pre>
17 23
3511 3527
</pre>
|
s150179744 | p00044 | Time Limit Exceeded | n = 50000
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:
try:
n = int(input())
i, a, b = 0, 0, 0
while a == 0 or b == 0:
i += 1
if n - i - 1 >= 0 and a == 0 and c[n - i - 1] == 1:
a = n - i
if n + i - 1 < 50000 and b == 0 and c[n + i - 1] == 1:
b = n + i
print(a,b)
except:
break
| 19
3517
| 17 23
3511 3527
|
<H1>素数 II</H1>
<p>
素数というのは、1 よりも大きくそれ自身か 1 でしか割りきれない整数をいいます。例えば、2 は、2 と 1 でしか割り切れないので素数ですが、12 は、12 と 1 のほかに、2, 3, 4, 6 で割りきれる数なので素数ではありません。
</p>
<p>
整数 <var>n</var> を入力したとき、<var>n</var> より小さい素数のうち最も大きいものと、<var>n</var> より大きい素数のうち最も小さいものを出力するプログラムを作成してください。
</p>
<H2>Input</H2>
<p>
複数のデータセットが与えられます。各データセットに <var>n</var> (3 ≤ <var>n</var> ≤ 50,000) が１行に与えられます。
</p>
<p>
データセットの数は 50 を超えません。
</p>
<H2>Output</H2>
<p>
各データセットに対して、<var>n</var> より小さい素数のうち最大のものと、<var>n</var> より大きい素数のうち最小のものを１つのスペースで区切って１行に出力して下さい。
</p>
<H2>Sample Input</H2>
<pre>
19
3517
</pre>
<H2>Output for the Sample Input</H2>
<pre>
17 23
3511 3527
</pre>
|
s059423045 | p00044 | Time Limit Exceeded | import sys
def is_prime(q):
q = abs(q)
if q == 2: return True
if q < 2 or q&1 == 0: return False
return pow(2, q-1, q) == 1
for n in sys.stdin:
a=int(n.strip())
b=a
while 1:
a+=2
if is_prime(a):
max_a=a
break
while 1:
b-=2
if is_prime(b):
min_b=b
break
print min_b,max_a | 19
3517
| 17 23
3511 3527
|
<H1>素数 II</H1>
<p>
素数というのは、1 よりも大きくそれ自身か 1 でしか割りきれない整数をいいます。例えば、2 は、2 と 1 でしか割り切れないので素数ですが、12 は、12 と 1 のほかに、2, 3, 4, 6 で割りきれる数なので素数ではありません。
</p>
<p>
整数 <var>n</var> を入力したとき、<var>n</var> より小さい素数のうち最も大きいものと、<var>n</var> より大きい素数のうち最も小さいものを出力するプログラムを作成してください。
</p>
<H2>Input</H2>
<p>
複数のデータセットが与えられます。各データセットに <var>n</var> (3 ≤ <var>n</var> ≤ 50,000) が１行に与えられます。
</p>
<p>
データセットの数は 50 を超えません。
</p>
<H2>Output</H2>
<p>
各データセットに対して、<var>n</var> より小さい素数のうち最大のものと、<var>n</var> より大きい素数のうち最小のものを１つのスペースで区切って１行に出力して下さい。
</p>
<H2>Sample Input</H2>
<pre>
19
3517
</pre>
<H2>Output for the Sample Input</H2>
<pre>
17 23
3511 3527
</pre>
|
s234174829 | p00044 | Accepted | from math import sqrt, ceil
N = 53000
temp = [True]*(N+1)
temp[0] = temp[1] = False
for i in range(2, ceil(sqrt(N+1))):
if temp[i]:
temp[i+i::i] = [False]*(len(temp[i+i::i]))
while True:
try:
n = int(input())
print(n-1-temp[n-1:0:-1].index(True), n+1+temp[n+1:].index(True))
except EOFError: break
| 19
3517
| 17 23
3511 3527
|
<H1>素数 II</H1>
<p>
素数というのは、1 よりも大きくそれ自身か 1 でしか割りきれない整数をいいます。例えば、2 は、2 と 1 でしか割り切れないので素数ですが、12 は、12 と 1 のほかに、2, 3, 4, 6 で割りきれる数なので素数ではありません。
</p>
<p>
整数 <var>n</var> を入力したとき、<var>n</var> より小さい素数のうち最も大きいものと、<var>n</var> より大きい素数のうち最も小さいものを出力するプログラムを作成してください。
</p>
<H2>Input</H2>
<p>
複数のデータセットが与えられます。各データセットに <var>n</var> (3 ≤ <var>n</var> ≤ 50,000) が１行に与えられます。
</p>
<p>
データセットの数は 50 を超えません。
</p>
<H2>Output</H2>
<p>
各データセットに対して、<var>n</var> より小さい素数のうち最大のものと、<var>n</var> より大きい素数のうち最小のものを１つのスペースで区切って１行に出力して下さい。
</p>
<H2>Sample Input</H2>
<pre>
19
3517
</pre>
<H2>Output for the Sample Input</H2>
<pre>
17 23
3511 3527
</pre>
|
s304426598 | p00044 | Accepted | import math
def p_l(n):
for i in range(n-1, 1, -1):
flag=0
for j in range(2, int(math.sqrt(i)) + 1):
if i % j == 0:
flag=1
if flag==1:continue
return i
def p_h(n):
for i in range(n+1,50022):
flag=0
for j in range(2, int(math.sqrt(i)) + 1):
if i % j == 0:
flag=1
if flag==1:continue
return i
while 1:
try:
n=int(input())
print(p_l(n),p_h(n))
except:break
| 19
3517
| 17 23
3511 3527
|
<H1>素数 II</H1>
<p>
素数というのは、1 よりも大きくそれ自身か 1 でしか割りきれない整数をいいます。例えば、2 は、2 と 1 でしか割り切れないので素数ですが、12 は、12 と 1 のほかに、2, 3, 4, 6 で割りきれる数なので素数ではありません。
</p>
<p>
整数 <var>n</var> を入力したとき、<var>n</var> より小さい素数のうち最も大きいものと、<var>n</var> より大きい素数のうち最も小さいものを出力するプログラムを作成してください。
</p>
<H2>Input</H2>
<p>
複数のデータセットが与えられます。各データセットに <var>n</var> (3 ≤ <var>n</var> ≤ 50,000) が１行に与えられます。
</p>
<p>
データセットの数は 50 を超えません。
</p>
<H2>Output</H2>
<p>
各データセットに対して、<var>n</var> より小さい素数のうち最大のものと、<var>n</var> より大きい素数のうち最小のものを１つのスペースで区切って１行に出力して下さい。
</p>
<H2>Sample Input</H2>
<pre>
19
3517
</pre>
<H2>Output for the Sample Input</H2>
<pre>
17 23
3511 3527
</pre>
|
s280094049 | p00044 | Accepted | def sieve(n):
res = []
nums = [1] * n
nums[0] = 0
for i in range(int(n ** 0.5) + 1):
if nums[i] == 0: continue
j = 2
while (i + 1) * j <= n:
nums[(i+1) * j - 1] = 0
j += 1
for i in range(len(nums)):
if nums[i] == 1:
res.append(i+1)
return res
primes = sieve(50021)
while True:
try:
n = int(input())
minn, maxn = 0, 0
for i in range(len(primes)):
if primes[i] > n:
maxn = primes[i]
minn = primes[i-1]
if minn == n: minn = primes[i-2]
break
print('%d %d' % (minn, maxn))
except:
break | 19
3517
| 17 23
3511 3527
|
<H1>素数 II</H1>
<p>
素数というのは、1 よりも大きくそれ自身か 1 でしか割りきれない整数をいいます。例えば、2 は、2 と 1 でしか割り切れないので素数ですが、12 は、12 と 1 のほかに、2, 3, 4, 6 で割りきれる数なので素数ではありません。
</p>
<p>
整数 <var>n</var> を入力したとき、<var>n</var> より小さい素数のうち最も大きいものと、<var>n</var> より大きい素数のうち最も小さいものを出力するプログラムを作成してください。
</p>
<H2>Input</H2>
<p>
複数のデータセットが与えられます。各データセットに <var>n</var> (3 ≤ <var>n</var> ≤ 50,000) が１行に与えられます。
</p>
<p>
データセットの数は 50 を超えません。
</p>
<H2>Output</H2>
<p>
各データセットに対して、<var>n</var> より小さい素数のうち最大のものと、<var>n</var> より大きい素数のうち最小のものを１つのスペースで区切って１行に出力して下さい。
</p>
<H2>Sample Input</H2>
<pre>
19
3517
</pre>
<H2>Output for the Sample Input</H2>
<pre>
17 23
3511 3527
</pre>
|
s783815895 | p00044 | Accepted | isPrime = [True] * 50100
prime = []
def calcPrime():
isPrime[0] = isPrime[1] = False
for i in range(len(isPrime)):
if(isPrime[i]):
prime.append(i)
for j in range(2 * i, len(isPrime), i):
isPrime[j] = False
calcPrime()
while(True):
try:
n = input()
pos = 0
while(prime[pos] < n):
pos += 1
print(prime[pos - 1]),
if(n == prime[pos]):
print(prime[pos + 1])
else:
print(prime[pos])
except Exception:
break | 19
3517
| 17 23
3511 3527
|
<H1>素数 II</H1>
<p>
素数というのは、1 よりも大きくそれ自身か 1 でしか割りきれない整数をいいます。例えば、2 は、2 と 1 でしか割り切れないので素数ですが、12 は、12 と 1 のほかに、2, 3, 4, 6 で割りきれる数なので素数ではありません。
</p>
<p>
整数 <var>n</var> を入力したとき、<var>n</var> より小さい素数のうち最も大きいものと、<var>n</var> より大きい素数のうち最も小さいものを出力するプログラムを作成してください。
</p>
<H2>Input</H2>
<p>
複数のデータセットが与えられます。各データセットに <var>n</var> (3 ≤ <var>n</var> ≤ 50,000) が１行に与えられます。
</p>
<p>
データセットの数は 50 を超えません。
</p>
<H2>Output</H2>
<p>
各データセットに対して、<var>n</var> より小さい素数のうち最大のものと、<var>n</var> より大きい素数のうち最小のものを１つのスペースで区切って１行に出力して下さい。
</p>
<H2>Sample Input</H2>
<pre>
19
3517
</pre>
<H2>Output for the Sample Input</H2>
<pre>
17 23
3511 3527
</pre>
|
s419014620 | p00044 | Accepted | from sys import *
maxnum = 60000
primes = [True]*maxnum
primes[0] = primes[1] = False
for i in xrange(maxnum):
if i >= maxnum**0.5 : break
if not primes[i]: continue
for j in xrange(i*2,maxnum,i): primes[j] = False
for s in stdin:
d = int(s)
for i in reversed(xrange(2,d)):
if primes[i]: print i,; break
for i in xrange(d+1,maxnum):
if primes[i]: print i;break | 19
3517
| 17 23
3511 3527
|
<H1>素数 II</H1>
<p>
素数というのは、1 よりも大きくそれ自身か 1 でしか割りきれない整数をいいます。例えば、2 は、2 と 1 でしか割り切れないので素数ですが、12 は、12 と 1 のほかに、2, 3, 4, 6 で割りきれる数なので素数ではありません。
</p>
<p>
整数 <var>n</var> を入力したとき、<var>n</var> より小さい素数のうち最も大きいものと、<var>n</var> より大きい素数のうち最も小さいものを出力するプログラムを作成してください。
</p>
<H2>Input</H2>
<p>
複数のデータセットが与えられます。各データセットに <var>n</var> (3 ≤ <var>n</var> ≤ 50,000) が１行に与えられます。
</p>
<p>
データセットの数は 50 を超えません。
</p>
<H2>Output</H2>
<p>
各データセットに対して、<var>n</var> より小さい素数のうち最大のものと、<var>n</var> より大きい素数のうち最小のものを１つのスペースで区切って１行に出力して下さい。
</p>
<H2>Sample Input</H2>
<pre>
19
3517
</pre>
<H2>Output for the Sample Input</H2>
<pre>
17 23
3511 3527
</pre>
|
s998202281 | p00044 | Accepted | def create_prime(n):
prime = [1] * (n + 1)
prime[:2] = [0, 0]
for i in range(len(prime)):
if prime[i]:
for j in range(2 * i, len(prime), i):
prime[j] = 0
return prime
def under(prime, n):
for i in range(n - 1, -1, -1):
if prime[i]:
return i
def over(prime, n):
for i in range(n + 1, len(prime)):
if prime[i]:
return i
import sys
n = [int(line) for line in sys.stdin]
prime = create_prime(max(n) + 100)
for ni in n:
print(under(prime, ni), over(prime, ni)) | 19
3517
| 17 23
3511 3527
|
<H1>素数 II</H1>
<p>
素数というのは、1 よりも大きくそれ自身か 1 でしか割りきれない整数をいいます。例えば、2 は、2 と 1 でしか割り切れないので素数ですが、12 は、12 と 1 のほかに、2, 3, 4, 6 で割りきれる数なので素数ではありません。
</p>
<p>
整数 <var>n</var> を入力したとき、<var>n</var> より小さい素数のうち最も大きいものと、<var>n</var> より大きい素数のうち最も小さいものを出力するプログラムを作成してください。
</p>
<H2>Input</H2>
<p>
複数のデータセットが与えられます。各データセットに <var>n</var> (3 ≤ <var>n</var> ≤ 50,000) が１行に与えられます。
</p>
<p>
データセットの数は 50 を超えません。
</p>
<H2>Output</H2>
<p>
各データセットに対して、<var>n</var> より小さい素数のうち最大のものと、<var>n</var> より大きい素数のうち最小のものを１つのスペースで区切って１行に出力して下さい。
</p>
<H2>Sample Input</H2>
<pre>
19
3517
</pre>
<H2>Output for the Sample Input</H2>
<pre>
17 23
3511 3527
</pre>
|
s909676740 | p00044 | Accepted | def is_prime(n):
i = 2
while i * i <=n:
if n % i == 0:
return False
i += 1
return True
while True:
try:
n = int(raw_input())
except EOFError:
break
k = n - 1
m = n + 1
while not is_prime(k):
k -= 1
while not is_prime(m):
m += 1
print k,m | 19
3517
| 17 23
3511 3527
|
<H1>素数 II</H1>
<p>
素数というのは、1 よりも大きくそれ自身か 1 でしか割りきれない整数をいいます。例えば、2 は、2 と 1 でしか割り切れないので素数ですが、12 は、12 と 1 のほかに、2, 3, 4, 6 で割りきれる数なので素数ではありません。
</p>
<p>
整数 <var>n</var> を入力したとき、<var>n</var> より小さい素数のうち最も大きいものと、<var>n</var> より大きい素数のうち最も小さいものを出力するプログラムを作成してください。
</p>
<H2>Input</H2>
<p>
複数のデータセットが与えられます。各データセットに <var>n</var> (3 ≤ <var>n</var> ≤ 50,000) が１行に与えられます。
</p>
<p>
データセットの数は 50 を超えません。
</p>
<H2>Output</H2>
<p>
各データセットに対して、<var>n</var> より小さい素数のうち最大のものと、<var>n</var> より大きい素数のうち最小のものを１つのスペースで区切って１行に出力して下さい。
</p>
<H2>Sample Input</H2>
<pre>
19
3517
</pre>
<H2>Output for the Sample Input</H2>
<pre>
17 23
3511 3527
</pre>
|
s546098856 | p00044 | Accepted | import sys
n=60000
prime = [1]*(n+1)
(prime[0],prime[1])=(0,0)
for i in [v for v in xrange(2,n+1) if v*v<n+1]:
for j in xrange(i*i,n+1,i):
prime[j]=0
for inp in sys.stdin:
i=int(inp)
j=int(inp)
while i<n:
if prime[i+1]==1:
break
i+=1
while j>0:
if prime[j-1]==1:
break
j-=1
print j-1,i+1 | 19
3517
| 17 23
3511 3527
|
<H1>素数 II</H1>
<p>
素数というのは、1 よりも大きくそれ自身か 1 でしか割りきれない整数をいいます。例えば、2 は、2 と 1 でしか割り切れないので素数ですが、12 は、12 と 1 のほかに、2, 3, 4, 6 で割りきれる数なので素数ではありません。
</p>
<p>
整数 <var>n</var> を入力したとき、<var>n</var> より小さい素数のうち最も大きいものと、<var>n</var> より大きい素数のうち最も小さいものを出力するプログラムを作成してください。
</p>
<H2>Input</H2>
<p>
複数のデータセットが与えられます。各データセットに <var>n</var> (3 ≤ <var>n</var> ≤ 50,000) が１行に与えられます。
</p>
<p>
データセットの数は 50 を超えません。
</p>
<H2>Output</H2>
<p>
各データセットに対して、<var>n</var> より小さい素数のうち最大のものと、<var>n</var> より大きい素数のうち最小のものを１つのスペースで区切って１行に出力して下さい。
</p>
<H2>Sample Input</H2>
<pre>
19
3517
</pre>
<H2>Output for the Sample Input</H2>
<pre>
17 23
3511 3527
</pre>
|
s431858087 | p00044 | Accepted | #!/usr/bin/env python
# -*- coding: utf-8 -*-
import bisect
import sys
def sieve(n):
prime = []
isprime = [1] * n
isprime[0] = isprime[1] = False
for i in range(2, n):
if(isprime[i] == False):continue
prime.append(i)
for j in range(2*i, n, i):
isprime[j] = False
return prime
prime = sieve(100000)
for n in sys.stdin:
n = int(n)
m = bisect.bisect_left(prime, n)
if n == prime[m]:
print prime[m - 1], prime[m + 1]
else:
print prime[m - 1], prime[m] | 19
3517
| 17 23
3511 3527
|
<H1>素数 II</H1>
<p>
素数というのは、1 よりも大きくそれ自身か 1 でしか割りきれない整数をいいます。例えば、2 は、2 と 1 でしか割り切れないので素数ですが、12 は、12 と 1 のほかに、2, 3, 4, 6 で割りきれる数なので素数ではありません。
</p>
<p>
整数 <var>n</var> を入力したとき、<var>n</var> より小さい素数のうち最も大きいものと、<var>n</var> より大きい素数のうち最も小さいものを出力するプログラムを作成してください。
</p>
<H2>Input</H2>
<p>
複数のデータセットが与えられます。各データセットに <var>n</var> (3 ≤ <var>n</var> ≤ 50,000) が１行に与えられます。
</p>
<p>
データセットの数は 50 を超えません。
</p>
<H2>Output</H2>
<p>
各データセットに対して、<var>n</var> より小さい素数のうち最大のものと、<var>n</var> より大きい素数のうち最小のものを１つのスペースで区切って１行に出力して下さい。
</p>
<H2>Sample Input</H2>
<pre>
19
3517
</pre>
<H2>Output for the Sample Input</H2>
<pre>
17 23
3511 3527
</pre>
|
s359453306 | p00044 | Accepted | def prime_t(t):
i=2
while i**2<=t:
if t%i==0:
return 0
i+=1
return 1
l=[]
for i in range(2,50022):
if prime_t(i):
l.append(i)
#print l
while 1:
try:
o=y=50000
n=int(raw_input())
for i in l:
if y<n and n<i:
print y,i
break
elif y==n and o<n and n<i:
print o,i
break
o=y
y=i
except:
break | 19
3517
| 17 23
3511 3527
|
<H1>素数 II</H1>
<p>
素数というのは、1 よりも大きくそれ自身か 1 でしか割りきれない整数をいいます。例えば、2 は、2 と 1 でしか割り切れないので素数ですが、12 は、12 と 1 のほかに、2, 3, 4, 6 で割りきれる数なので素数ではありません。
</p>
<p>
整数 <var>n</var> を入力したとき、<var>n</var> より小さい素数のうち最も大きいものと、<var>n</var> より大きい素数のうち最も小さいものを出力するプログラムを作成してください。
</p>
<H2>Input</H2>
<p>
複数のデータセットが与えられます。各データセットに <var>n</var> (3 ≤ <var>n</var> ≤ 50,000) が１行に与えられます。
</p>
<p>
データセットの数は 50 を超えません。
</p>
<H2>Output</H2>
<p>
各データセットに対して、<var>n</var> より小さい素数のうち最大のものと、<var>n</var> より大きい素数のうち最小のものを１つのスペースで区切って１行に出力して下さい。
</p>
<H2>Sample Input</H2>
<pre>
19
3517
</pre>
<H2>Output for the Sample Input</H2>
<pre>
17 23
3511 3527
</pre>
|
s388507458 | p00044 | Accepted | def sieve(n):
p=[True]*(n+1)
p[0]=p[1]=False
for i in range(2,int((n+1)*0.5)+1):
if p[i]==True:
for j in range(i*i,n+1,i):
p[j]=False
prime=[]
for i in range(n+1):
if p[i]==True:
prime.append(i)
return prime
def solve(n):
i=0
while True:
if n>prime[i]:
a=prime[i]
elif n==prime[i]:
a=prime[i-1]
else:
b=prime[i]
break
i+=1
print(a,b)
prime=sieve(50021)
while True:
try:
n=int(input())
solve(n)
except EOFError:
break | 19
3517
| 17 23
3511 3527
|
<H1>素数 II</H1>
<p>
素数というのは、1 よりも大きくそれ自身か 1 でしか割りきれない整数をいいます。例えば、2 は、2 と 1 でしか割り切れないので素数ですが、12 は、12 と 1 のほかに、2, 3, 4, 6 で割りきれる数なので素数ではありません。
</p>
<p>
整数 <var>n</var> を入力したとき、<var>n</var> より小さい素数のうち最も大きいものと、<var>n</var> より大きい素数のうち最も小さいものを出力するプログラムを作成してください。
</p>
<H2>Input</H2>
<p>
複数のデータセットが与えられます。各データセットに <var>n</var> (3 ≤ <var>n</var> ≤ 50,000) が１行に与えられます。
</p>
<p>
データセットの数は 50 を超えません。
</p>
<H2>Output</H2>
<p>
各データセットに対して、<var>n</var> より小さい素数のうち最大のものと、<var>n</var> より大きい素数のうち最小のものを１つのスペースで区切って１行に出力して下さい。
</p>
<H2>Sample Input</H2>
<pre>
19
3517
</pre>
<H2>Output for the Sample Input</H2>
<pre>
17 23
3511 3527
</pre>
|
s677428171 | p00044 | Accepted | import sys
def inp():
for line in sys.stdin:
i = 1
while True:
if is_prime(int(line[:-1]) - i) == True:
print (int(line[:-1]) - i),
break
else:
i += 1
i = 1
while True:
if is_prime(int(line[:-1]) + i) == True:
print (int(line[:-1]) + i)
break
else:
i += 1
def is_prime(q):
q = abs(q)
if q == 2: return True
if q < 2 or q&1 == 0: return False
return pow(2, q-1, q) == 1
if __name__ == "__main__":
inp() | 19
3517
| 17 23
3511 3527
|
<H1>素数 II</H1>
<p>
素数というのは、1 よりも大きくそれ自身か 1 でしか割りきれない整数をいいます。例えば、2 は、2 と 1 でしか割り切れないので素数ですが、12 は、12 と 1 のほかに、2, 3, 4, 6 で割りきれる数なので素数ではありません。
</p>
<p>
整数 <var>n</var> を入力したとき、<var>n</var> より小さい素数のうち最も大きいものと、<var>n</var> より大きい素数のうち最も小さいものを出力するプログラムを作成してください。
</p>
<H2>Input</H2>
<p>
複数のデータセットが与えられます。各データセットに <var>n</var> (3 ≤ <var>n</var> ≤ 50,000) が１行に与えられます。
</p>
<p>
データセットの数は 50 を超えません。
</p>
<H2>Output</H2>
<p>
各データセットに対して、<var>n</var> より小さい素数のうち最大のものと、<var>n</var> より大きい素数のうち最小のものを１つのスペースで区切って１行に出力して下さい。
</p>
<H2>Sample Input</H2>
<pre>
19
3517
</pre>
<H2>Output for the Sample Input</H2>
<pre>
17 23
3511 3527
</pre>
|
s873212929 | p00044 | Accepted | # -*- coding: utf-8 -*-
import sys
primes = [2]
for i in range(3, 50022):
flag = True
for p in primes:
if i % p == 0:
flag = False
break
if flag:
primes.append(i)
for line in sys.stdin:
n = int(line)
i = 0
while primes[i] < n and i < len(primes):
i += 1
if primes[i] == n:
s = primes[i-1]
m = primes[i+1]
else:
s = primes[i-1]
m = primes[i]
print s, m | 19
3517
| 17 23
3511 3527
|
<H1>素数 II</H1>
<p>
素数というのは、1 よりも大きくそれ自身か 1 でしか割りきれない整数をいいます。例えば、2 は、2 と 1 でしか割り切れないので素数ですが、12 は、12 と 1 のほかに、2, 3, 4, 6 で割りきれる数なので素数ではありません。
</p>
<p>
整数 <var>n</var> を入力したとき、<var>n</var> より小さい素数のうち最も大きいものと、<var>n</var> より大きい素数のうち最も小さいものを出力するプログラムを作成してください。
</p>
<H2>Input</H2>
<p>
複数のデータセットが与えられます。各データセットに <var>n</var> (3 ≤ <var>n</var> ≤ 50,000) が１行に与えられます。
</p>
<p>
データセットの数は 50 を超えません。
</p>
<H2>Output</H2>
<p>
各データセットに対して、<var>n</var> より小さい素数のうち最大のものと、<var>n</var> より大きい素数のうち最小のものを１つのスペースで区切って１行に出力して下さい。
</p>
<H2>Sample Input</H2>
<pre>
19
3517
</pre>
<H2>Output for the Sample Input</H2>
<pre>
17 23
3511 3527
</pre>
|
s751050029 | p00044 | Accepted | # -*- coding: utf-8 -*-
import sys
primes = [2]
for i in range(3, 50022):
flag = True
for p in primes:
if i % p == 0:
flag = False
break
if flag:
primes.append(i)
for line in sys.stdin:
n = int(line)
i = 0
while primes[i] < n and i < len(primes):
i += 1
if primes[i] == n:
s = primes[i-1]
m = primes[i+1]
else:
s = primes[i-1]
m = primes[i]
print s, m | 19
3517
| 17 23
3511 3527
|
<H1>素数 II</H1>
<p>
素数というのは、1 よりも大きくそれ自身か 1 でしか割りきれない整数をいいます。例えば、2 は、2 と 1 でしか割り切れないので素数ですが、12 は、12 と 1 のほかに、2, 3, 4, 6 で割りきれる数なので素数ではありません。
</p>
<p>
整数 <var>n</var> を入力したとき、<var>n</var> より小さい素数のうち最も大きいものと、<var>n</var> より大きい素数のうち最も小さいものを出力するプログラムを作成してください。
</p>
<H2>Input</H2>
<p>
複数のデータセットが与えられます。各データセットに <var>n</var> (3 ≤ <var>n</var> ≤ 50,000) が１行に与えられます。
</p>
<p>
データセットの数は 50 を超えません。
</p>
<H2>Output</H2>
<p>
各データセットに対して、<var>n</var> より小さい素数のうち最大のものと、<var>n</var> より大きい素数のうち最小のものを１つのスペースで区切って１行に出力して下さい。
</p>
<H2>Sample Input</H2>
<pre>
19
3517
</pre>
<H2>Output for the Sample Input</H2>
<pre>
17 23
3511 3527
</pre>
|
s184196504 | p00044 | Accepted | def make_ps(n):
nums = [True for i in range(n)]
nums[0] = nums[1] = False
p = 2
sqrt = n ** 0.5
while p < sqrt:
for i in range(2 * p, n, p):
nums[i] = False
while True:
p += 1
if nums[p]:
break
return [i for i in range(n) if nums[i]]
ps = make_ps(250)
def is_p(x):
i = 0
s = x ** 0.5
while True:
if ps[i] > s:
break
if not x % ps[i]:
return False
i += 1
return True
while True:
try:
n = int(input())
except:
break
for i in range(n - 1, 0, -1):
if is_p(i):
print(i, end=' ')
break
for i in range(n + 1, 50100):
if is_p(i):
print(i)
break | 19
3517
| 17 23
3511 3527
|
<H1>素数 II</H1>
<p>
素数というのは、1 よりも大きくそれ自身か 1 でしか割りきれない整数をいいます。例えば、2 は、2 と 1 でしか割り切れないので素数ですが、12 は、12 と 1 のほかに、2, 3, 4, 6 で割りきれる数なので素数ではありません。
</p>
<p>
整数 <var>n</var> を入力したとき、<var>n</var> より小さい素数のうち最も大きいものと、<var>n</var> より大きい素数のうち最も小さいものを出力するプログラムを作成してください。
</p>
<H2>Input</H2>
<p>
複数のデータセットが与えられます。各データセットに <var>n</var> (3 ≤ <var>n</var> ≤ 50,000) が１行に与えられます。
</p>
<p>
データセットの数は 50 を超えません。
</p>
<H2>Output</H2>
<p>
各データセットに対して、<var>n</var> より小さい素数のうち最大のものと、<var>n</var> より大きい素数のうち最小のものを１つのスペースで区切って１行に出力して下さい。
</p>
<H2>Sample Input</H2>
<pre>
19
3517
</pre>
<H2>Output for the Sample Input</H2>
<pre>
17 23
3511 3527
</pre>
|
s446622175 | p00044 | Accepted | import sys
def furui(n):
l = [1 for i in range(n+1)]
l[0] = 0
l[1] = 0
for i in range(2,n+1):
if l[i] == 1:
for j in range(2,n//i+1):
l[i*j] = 0
l2 = []
for i in range (len(l)):
if l[i] == 1:
l2.append(i)
return l2
for line in sys.stdin:
n = int(line)
l = furui(n)
if max(l) == n:
i1 = l[len(l)-2]
else:
i1 = max(l)
i2 = n
while True:
i2 += 1
flag = 1
for i in l:
if i2 % i == 0:
flag = 0
break
if flag:
break
print(str(i1) + " " + str(i2)) | 19
3517
| 17 23
3511 3527
|
<H1>素数 II</H1>
<p>
素数というのは、1 よりも大きくそれ自身か 1 でしか割りきれない整数をいいます。例えば、2 は、2 と 1 でしか割り切れないので素数ですが、12 は、12 と 1 のほかに、2, 3, 4, 6 で割りきれる数なので素数ではありません。
</p>
<p>
整数 <var>n</var> を入力したとき、<var>n</var> より小さい素数のうち最も大きいものと、<var>n</var> より大きい素数のうち最も小さいものを出力するプログラムを作成してください。
</p>
<H2>Input</H2>
<p>
複数のデータセットが与えられます。各データセットに <var>n</var> (3 ≤ <var>n</var> ≤ 50,000) が１行に与えられます。
</p>
<p>
データセットの数は 50 を超えません。
</p>
<H2>Output</H2>
<p>
各データセットに対して、<var>n</var> より小さい素数のうち最大のものと、<var>n</var> より大きい素数のうち最小のものを１つのスペースで区切って１行に出力して下さい。
</p>
<H2>Sample Input</H2>
<pre>
19
3517
</pre>
<H2>Output for the Sample Input</H2>
<pre>
17 23
3511 3527
</pre>
|
s745604185 | p00044 | Accepted | pr=[True]*50100
for i in range(2,225):
if pr[i]:
for j in range(i*2,50100,i):
pr[j]=False
while True:
try:
n=int(input())
except:
break
for i in range(n-1,0,-1):
if pr[i]:
print(i,end=" ")
break
for i in range(n+1,50100):
if pr[i]:
print(i)
break | 19
3517
| 17 23
3511 3527
|
<H1>素数 II</H1>
<p>
素数というのは、1 よりも大きくそれ自身か 1 でしか割りきれない整数をいいます。例えば、2 は、2 と 1 でしか割り切れないので素数ですが、12 は、12 と 1 のほかに、2, 3, 4, 6 で割りきれる数なので素数ではありません。
</p>
<p>
整数 <var>n</var> を入力したとき、<var>n</var> より小さい素数のうち最も大きいものと、<var>n</var> より大きい素数のうち最も小さいものを出力するプログラムを作成してください。
</p>
<H2>Input</H2>
<p>
複数のデータセットが与えられます。各データセットに <var>n</var> (3 ≤ <var>n</var> ≤ 50,000) が１行に与えられます。
</p>
<p>
データセットの数は 50 を超えません。
</p>
<H2>Output</H2>
<p>
各データセットに対して、<var>n</var> より小さい素数のうち最大のものと、<var>n</var> より大きい素数のうち最小のものを１つのスペースで区切って１行に出力して下さい。
</p>
<H2>Sample Input</H2>
<pre>
19
3517
</pre>
<H2>Output for the Sample Input</H2>
<pre>
17 23
3511 3527
</pre>
|
s956563885 | p00044 | Accepted | n=1000000
p=[1]*(n+1)
p[0],p[1]=0,0
for i in range(2,int(n**0.5)+1):
if p[i]:
for j in range(i*i,n+1,i):
p[j]=0
p=[i for i in range(n+1) if p[i]==1]
while 1:
try:n=int(input())
except:break
for i in range(len(p)):
if p[i]==n:
print(p[i-1],p[i+1])
break
elif p[i]>n:
print(p[i-1],p[i])
break | 19
3517
| 17 23
3511 3527
|
<H1>素数 II</H1>
<p>
素数というのは、1 よりも大きくそれ自身か 1 でしか割りきれない整数をいいます。例えば、2 は、2 と 1 でしか割り切れないので素数ですが、12 は、12 と 1 のほかに、2, 3, 4, 6 で割りきれる数なので素数ではありません。
</p>
<p>
整数 <var>n</var> を入力したとき、<var>n</var> より小さい素数のうち最も大きいものと、<var>n</var> より大きい素数のうち最も小さいものを出力するプログラムを作成してください。
</p>
<H2>Input</H2>
<p>
複数のデータセットが与えられます。各データセットに <var>n</var> (3 ≤ <var>n</var> ≤ 50,000) が１行に与えられます。
</p>
<p>
データセットの数は 50 を超えません。
</p>
<H2>Output</H2>
<p>
各データセットに対して、<var>n</var> より小さい素数のうち最大のものと、<var>n</var> より大きい素数のうち最小のものを１つのスペースで区切って１行に出力して下さい。
</p>
<H2>Sample Input</H2>
<pre>
19
3517
</pre>
<H2>Output for the Sample Input</H2>
<pre>
17 23
3511 3527
</pre>
|
s975554692 | p00044 | Accepted | def f(s,p):
p.append(s.pop(0))
for i,num in enumerate(s):
if num % p[-1] == 0:
s.pop(i)
return 0
def vol44(k):
for i in range(len(p)):
if p[i] == k:
print(p[i-1],p[i+1])
break
elif p[i] > k:
print(p[i-1],p[i])
break
primes = list(range(2,50100))
arr = []
while not arr or arr[-1] ** 2 < primes[-1]:
f(primes,arr)
p = arr+primes
n = []
while True:
try:
n.append(int(input()))
except EOFError:
break
for i in range(len(n)):
vol44(n[i]) | 19
3517
| 17 23
3511 3527
|
<H1>素数 II</H1>
<p>
素数というのは、1 よりも大きくそれ自身か 1 でしか割りきれない整数をいいます。例えば、2 は、2 と 1 でしか割り切れないので素数ですが、12 は、12 と 1 のほかに、2, 3, 4, 6 で割りきれる数なので素数ではありません。
</p>
<p>
整数 <var>n</var> を入力したとき、<var>n</var> より小さい素数のうち最も大きいものと、<var>n</var> より大きい素数のうち最も小さいものを出力するプログラムを作成してください。
</p>
<H2>Input</H2>
<p>
複数のデータセットが与えられます。各データセットに <var>n</var> (3 ≤ <var>n</var> ≤ 50,000) が１行に与えられます。
</p>
<p>
データセットの数は 50 を超えません。
</p>
<H2>Output</H2>
<p>
各データセットに対して、<var>n</var> より小さい素数のうち最大のものと、<var>n</var> より大きい素数のうち最小のものを１つのスペースで区切って１行に出力して下さい。
</p>
<H2>Sample Input</H2>
<pre>
19
3517
</pre>
<H2>Output for the Sample Input</H2>
<pre>
17 23
3511 3527
</pre>
|
s927533694 | p00044 | Accepted | def is_prime(x):
if x <= 1:
return False
i = 2
while i * i <= x:
if x % i == 0:
return False
i += 1
return True
while True:
try:
N = int(input())
except EOFError:
break
mx = 0
mn = 0
for i in range(N - 1,1,-1):
if is_prime(i):
mx = i
break
for i in range(N + 1,N * 2):
if is_prime(i):
mn = i
break
print(mx,mn) | 19
3517
| 17 23
3511 3527
|
<H1>素数 II</H1>
<p>
素数というのは、1 よりも大きくそれ自身か 1 でしか割りきれない整数をいいます。例えば、2 は、2 と 1 でしか割り切れないので素数ですが、12 は、12 と 1 のほかに、2, 3, 4, 6 で割りきれる数なので素数ではありません。
</p>
<p>
整数 <var>n</var> を入力したとき、<var>n</var> より小さい素数のうち最も大きいものと、<var>n</var> より大きい素数のうち最も小さいものを出力するプログラムを作成してください。
</p>
<H2>Input</H2>
<p>
複数のデータセットが与えられます。各データセットに <var>n</var> (3 ≤ <var>n</var> ≤ 50,000) が１行に与えられます。
</p>
<p>
データセットの数は 50 を超えません。
</p>
<H2>Output</H2>
<p>
各データセットに対して、<var>n</var> より小さい素数のうち最大のものと、<var>n</var> より大きい素数のうち最小のものを１つのスペースで区切って１行に出力して下さい。
</p>
<H2>Sample Input</H2>
<pre>
19
3517
</pre>
<H2>Output for the Sample Input</H2>
<pre>
17 23
3511 3527
</pre>
|
s313918450 | p00044 | Accepted | primes = [0, 0] + [1]*50020
for i in range(2, 225):
if primes[i]:
for j in range(i*i, 50022, i):
primes[j] = 0
while True:
try:
n = int(input())
except:
break
m, o = n-1, n+1
while not primes[m]:
m -= 1
while not primes[o]:
o += 1
print(m, o) | 19
3517
| 17 23
3511 3527
|
<H1>素数 II</H1>
<p>
素数というのは、1 よりも大きくそれ自身か 1 でしか割りきれない整数をいいます。例えば、2 は、2 と 1 でしか割り切れないので素数ですが、12 は、12 と 1 のほかに、2, 3, 4, 6 で割りきれる数なので素数ではありません。
</p>
<p>
整数 <var>n</var> を入力したとき、<var>n</var> より小さい素数のうち最も大きいものと、<var>n</var> より大きい素数のうち最も小さいものを出力するプログラムを作成してください。
</p>
<H2>Input</H2>
<p>
複数のデータセットが与えられます。各データセットに <var>n</var> (3 ≤ <var>n</var> ≤ 50,000) が１行に与えられます。
</p>
<p>
データセットの数は 50 を超えません。
</p>
<H2>Output</H2>
<p>
各データセットに対して、<var>n</var> より小さい素数のうち最大のものと、<var>n</var> より大きい素数のうち最小のものを１つのスペースで区切って１行に出力して下さい。
</p>
<H2>Sample Input</H2>
<pre>
19
3517
</pre>
<H2>Output for the Sample Input</H2>
<pre>
17 23
3511 3527
</pre>
|
s438552121 | p00044 | Accepted | import bisect
prime = [2,3,5,7,11,13]
shieve1 = [1]*257
for i in prime:
itr = i-1
while(itr<256):
shieve1[itr] = 0
itr += i
for i in range(16,256):
if shieve1[i]:
prime.append(i+1)
shieve2 = [1]*(50101)
for i in prime:
itr = i-1
while(itr<50100):
shieve2[itr] = 0
itr += i
for i in range(257,50101):
if shieve2[i]:
prime.append(i+1)
while True:
try:
n = int(input())
m = bisect.bisect(prime,n)
if n==prime[m-1]:
print(prime[m-2],prime[m])
else:
print(prime[m-1],prime[m])
except EOFError:
break | 19
3517
| 17 23
3511 3527
|
<H1>素数 II</H1>
<p>
素数というのは、1 よりも大きくそれ自身か 1 でしか割りきれない整数をいいます。例えば、2 は、2 と 1 でしか割り切れないので素数ですが、12 は、12 と 1 のほかに、2, 3, 4, 6 で割りきれる数なので素数ではありません。
</p>
<p>
整数 <var>n</var> を入力したとき、<var>n</var> より小さい素数のうち最も大きいものと、<var>n</var> より大きい素数のうち最も小さいものを出力するプログラムを作成してください。
</p>
<H2>Input</H2>
<p>
複数のデータセットが与えられます。各データセットに <var>n</var> (3 ≤ <var>n</var> ≤ 50,000) が１行に与えられます。
</p>
<p>
データセットの数は 50 を超えません。
</p>
<H2>Output</H2>
<p>
各データセットに対して、<var>n</var> より小さい素数のうち最大のものと、<var>n</var> より大きい素数のうち最小のものを１つのスペースで区切って１行に出力して下さい。
</p>
<H2>Sample Input</H2>
<pre>
19
3517
</pre>
<H2>Output for the Sample Input</H2>
<pre>
17 23
3511 3527
</pre>
|
s938343857 | p00044 | Accepted | # -*- coding: utf-8 -*-
import sys
import os
import math
import itertools
def is_prime(q):
q = abs(q)
if q == 2: return True
if q < 2 or q&1 == 0: return False
return pow(2, q-1, q) == 1
for s in sys.stdin:
n = int(s)
for i in range(n-1, 0, -1):
if is_prime(i):
answer0 = i
break
for i in range(n+1, 100000, 1):
if is_prime(i):
answer1 = i
break
print(answer0, answer1) | 19
3517
| 17 23
3511 3527
|
<H1>素数 II</H1>
<p>
素数というのは、1 よりも大きくそれ自身か 1 でしか割りきれない整数をいいます。例えば、2 は、2 と 1 でしか割り切れないので素数ですが、12 は、12 と 1 のほかに、2, 3, 4, 6 で割りきれる数なので素数ではありません。
</p>
<p>
整数 <var>n</var> を入力したとき、<var>n</var> より小さい素数のうち最も大きいものと、<var>n</var> より大きい素数のうち最も小さいものを出力するプログラムを作成してください。
</p>
<H2>Input</H2>
<p>
複数のデータセットが与えられます。各データセットに <var>n</var> (3 ≤ <var>n</var> ≤ 50,000) が１行に与えられます。
</p>
<p>
データセットの数は 50 を超えません。
</p>
<H2>Output</H2>
<p>
各データセットに対して、<var>n</var> より小さい素数のうち最大のものと、<var>n</var> より大きい素数のうち最小のものを１つのスペースで区切って１行に出力して下さい。
</p>
<H2>Sample Input</H2>
<pre>
19
3517
</pre>
<H2>Output for the Sample Input</H2>
<pre>
17 23
3511 3527
</pre>
|
s205664533 | p00044 | Accepted | primes = [0, 0] + [1]*50020
for i in range(2, 226):
if primes[i]:
for j in range(i*i, 50021, i):
primes[j] = 0
while True:
try:
n = int(input())
except:
break
print(n-primes[n-1::-1].index(1)-1, n+primes[n+1:].index(1)+1) | 19
3517
| 17 23
3511 3527
|
<H1>素数 II</H1>
<p>
素数というのは、1 よりも大きくそれ自身か 1 でしか割りきれない整数をいいます。例えば、2 は、2 と 1 でしか割り切れないので素数ですが、12 は、12 と 1 のほかに、2, 3, 4, 6 で割りきれる数なので素数ではありません。
</p>
<p>
整数 <var>n</var> を入力したとき、<var>n</var> より小さい素数のうち最も大きいものと、<var>n</var> より大きい素数のうち最も小さいものを出力するプログラムを作成してください。
</p>
<H2>Input</H2>
<p>
複数のデータセットが与えられます。各データセットに <var>n</var> (3 ≤ <var>n</var> ≤ 50,000) が１行に与えられます。
</p>
<p>
データセットの数は 50 を超えません。
</p>
<H2>Output</H2>
<p>
各データセットに対して、<var>n</var> より小さい素数のうち最大のものと、<var>n</var> より大きい素数のうち最小のものを１つのスペースで区切って１行に出力して下さい。
</p>
<H2>Sample Input</H2>
<pre>
19
3517
</pre>
<H2>Output for the Sample Input</H2>
<pre>
17 23
3511 3527
</pre>
|
s362408085 | p00044 | Accepted | # -*- coding: utf-8 -*-
"""
http://judge.u-aizu.ac.jp/onlinejudge/description.jsp?id=0044
"""
from math import sqrt, ceil, pow
import bisect
import sys
# https://github.com/mccricardo/sieve_of_atkin/blob/master/sieve_of_atkin.py
class SieveOfAtkin:
def __init__(self, limit):
self.limit = limit
self.primes = []
self.sieve = [False] * (self.limit + 1)
def flip(self, prime):
try:
self.sieve[prime] = True if self.sieve[prime] == False else False
except KeyError:
pass
def invalidate(self, prime):
try:
if self.sieve[prime] == True: self.sieve[prime] = False
except KeyError:
pass
def isPrime(self, prime):
try:
return self.sieve[prime]
except KeyError:
return False
def getPrimes(self):
testingLimit = int(ceil(sqrt(self.limit)))
for i in range(testingLimit):
for j in range(testingLimit):
# n = 4*i^2 + j^2
n = 4 * int(pow(i, 2)) + int(pow(j, 2))
if n <= self.limit and (n % 12 == 1 or n % 12 == 5):
self.flip(n)
# n = 3*i^2 + j^2
n = 3 * int(pow(i, 2)) + int(pow(j, 2))
if n <= self.limit and n % 12 == 7:
self.flip(n)
# n = 3*i^2 - j^2
n = 3 * int(pow(i, 2)) - int(pow(j, 2))
if n <= self.limit and i > j and n % 12 == 11:
self.flip(n)
for i in range(5, testingLimit):
if self.isPrime(i):
k = int(pow(i, 2))
for j in range(k, self.limit, k):
self.invalidate(j)
self.primes = [2, 3] + [x for x in range(len(self.sieve)) if self.isPrime(x) and x >= 5]
return self.primes
def solve1(num, primes):
#
i = bisect.bisect_left(primes, num)
lt = primes[i-1]
i = bisect.bisect_left(primes, num+1)
gt = primes[i]
return lt, gt
if __name__ == '__main__':
A = SieveOfAtkin(55000)
A.getPrimes()
# ??????????????\?????¨???????????????
for line in sys.stdin:
num = int(line)
lt, gt = solve1(num, A.primes)
print('{} {}'.format(lt, gt)) | 19
3517
| 17 23
3511 3527
|
<H1>素数 II</H1>
<p>
素数というのは、1 よりも大きくそれ自身か 1 でしか割りきれない整数をいいます。例えば、2 は、2 と 1 でしか割り切れないので素数ですが、12 は、12 と 1 のほかに、2, 3, 4, 6 で割りきれる数なので素数ではありません。
</p>
<p>
整数 <var>n</var> を入力したとき、<var>n</var> より小さい素数のうち最も大きいものと、<var>n</var> より大きい素数のうち最も小さいものを出力するプログラムを作成してください。
</p>
<H2>Input</H2>
<p>
複数のデータセットが与えられます。各データセットに <var>n</var> (3 ≤ <var>n</var> ≤ 50,000) が１行に与えられます。
</p>
<p>
データセットの数は 50 を超えません。
</p>
<H2>Output</H2>
<p>
各データセットに対して、<var>n</var> より小さい素数のうち最大のものと、<var>n</var> より大きい素数のうち最小のものを１つのスペースで区切って１行に出力して下さい。
</p>
<H2>Sample Input</H2>
<pre>
19
3517
</pre>
<H2>Output for the Sample Input</H2>
<pre>
17 23
3511 3527
</pre>
|
s014730480 | p00044 | Accepted | # -*- coding: utf-8 -*-
"""
http://judge.u-aizu.ac.jp/onlinejudge/description.jsp?id=0044
"""
from math import sqrt, ceil, pow
import bisect
import sys
# https://github.com/mccricardo/sieve_of_atkin/blob/master/sieve_of_atkin.py
class SieveOfAtkin:
def __init__(self, limit):
self.limit = limit
self.primes = []
self.sieve = [False] * (self.limit + 1)
def flip(self, prime):
try:
self.sieve[prime] = True if self.sieve[prime] == False else False
except KeyError:
pass
def invalidate(self, prime):
try:
if self.sieve[prime] == True: self.sieve[prime] = False
except KeyError:
pass
def isPrime(self, prime):
try:
return self.sieve[prime]
except KeyError:
return False
def getPrimes(self):
testingLimit = int(ceil(sqrt(self.limit)))
for i in range(testingLimit):
for j in range(testingLimit):
# n = 4*i^2 + j^2
n = 4 * int(pow(i, 2)) + int(pow(j, 2))
if n <= self.limit and (n % 12 == 1 or n % 12 == 5):
self.flip(n)
# n = 3*i^2 + j^2
n = 3 * int(pow(i, 2)) + int(pow(j, 2))
if n <= self.limit and n % 12 == 7:
self.flip(n)
# n = 3*i^2 - j^2
n = 3 * int(pow(i, 2)) - int(pow(j, 2))
if n <= self.limit and i > j and n % 12 == 11:
self.flip(n)
for i in range(5, testingLimit):
if self.isPrime(i):
k = int(pow(i, 2))
for j in range(k, self.limit, k):
self.invalidate(j)
self.primes = [2, 3] + [x for x in range(len(self.sieve)) if self.isPrime(x) and x >= 5]
return self.primes
def solve1(num, primes):
#
i = bisect.bisect_left(primes, num)
lt = primes[i-1]
i = bisect.bisect_right(primes, num)
gt = primes[i]
return lt, gt
if __name__ == '__main__':
A = SieveOfAtkin(55000)
A.getPrimes()
# ??????????????\?????¨???????????????
for line in sys.stdin:
num = int(line)
lt, gt = solve1(num, A.primes)
print('{} {}'.format(lt, gt)) | 19
3517
| 17 23
3511 3527
|
<H1>素数 II</H1>
<p>
素数というのは、1 よりも大きくそれ自身か 1 でしか割りきれない整数をいいます。例えば、2 は、2 と 1 でしか割り切れないので素数ですが、12 は、12 と 1 のほかに、2, 3, 4, 6 で割りきれる数なので素数ではありません。
</p>
<p>
整数 <var>n</var> を入力したとき、<var>n</var> より小さい素数のうち最も大きいものと、<var>n</var> より大きい素数のうち最も小さいものを出力するプログラムを作成してください。
</p>
<H2>Input</H2>
<p>
複数のデータセットが与えられます。各データセットに <var>n</var> (3 ≤ <var>n</var> ≤ 50,000) が１行に与えられます。
</p>
<p>
データセットの数は 50 を超えません。
</p>
<H2>Output</H2>
<p>
各データセットに対して、<var>n</var> より小さい素数のうち最大のものと、<var>n</var> より大きい素数のうち最小のものを１つのスペースで区切って１行に出力して下さい。
</p>
<H2>Sample Input</H2>
<pre>
19
3517
</pre>
<H2>Output for the Sample Input</H2>
<pre>
17 23
3511 3527
</pre>
|
s788795661 | p00044 | Accepted | # Aizu Problem 0009: Prime Number
#
import sys, math, os, bisect
# read input:
PYDEV = os.environ.get('PYDEV')
if PYDEV=="True":
sys.stdin = open("sample-input.txt", "rt")
def primes2(n):
""" Input n>=6, Returns a list of primes, 2 <= p < n """
n, correction = n-n%6+6, 2-(n%6>1)
sieve = [True] * (n//3)
for i in range(1,int(n**0.5)//3+1):
if sieve[i]:
k=3*i+1|1
sieve[ k*k//3 ::2*k] = [False] * ((n//6-k*k//6-1)//k+1)
sieve[k*(k-2*(i&1)+4)//3::2*k] = [False] * ((n//6-k*(k-2*(i&1)+4)//6-1)//k+1)
return [2,3] + [3*i+1|1 for i in range(1,n//3-correction) if sieve[i]]
primes = primes2(50500)
for line in sys.stdin:
n = int(line)
if n in primes:
idx = primes.index(n)
print(primes[idx-1], primes[idx+1])
else:
idx = bisect.bisect_right(primes, n)
print(primes[idx-1], primes[idx])
| 19
3517
| 17 23
3511 3527
|
<H1>素数 II</H1>
<p>
素数というのは、1 よりも大きくそれ自身か 1 でしか割りきれない整数をいいます。例えば、2 は、2 と 1 でしか割り切れないので素数ですが、12 は、12 と 1 のほかに、2, 3, 4, 6 で割りきれる数なので素数ではありません。
</p>
<p>
整数 <var>n</var> を入力したとき、<var>n</var> より小さい素数のうち最も大きいものと、<var>n</var> より大きい素数のうち最も小さいものを出力するプログラムを作成してください。
</p>
<H2>Input</H2>
<p>
複数のデータセットが与えられます。各データセットに <var>n</var> (3 ≤ <var>n</var> ≤ 50,000) が１行に与えられます。
</p>
<p>
データセットの数は 50 を超えません。
</p>
<H2>Output</H2>
<p>
各データセットに対して、<var>n</var> より小さい素数のうち最大のものと、<var>n</var> より大きい素数のうち最小のものを１つのスペースで区切って１行に出力して下さい。
</p>
<H2>Sample Input</H2>
<pre>
19
3517
</pre>
<H2>Output for the Sample Input</H2>
<pre>
17 23
3511 3527
</pre>
|
s558148357 | p00044 | Accepted | import sys
import math
primes = [2]
for line in sys.stdin:
try:
n = int(line)
for i in range(max(primes) + 1, n):
if i % 2 == 0:
continue
elif math.sqrt(i) == 0:
continue
elif len([j for j in primes if i % j == 0]) > 0:
continue
primes.append(i)
if n == 3:
print(2, end=" ")
else:
for i in range(n - 1, 1, -1):
if i % 2 == 0:
continue
elif math.sqrt(i) == 0:
continue
elif len([j for j in primes if i % j == 0 and i != j]) > 0:
continue
print(i, end=" ")
break
for i in range(n + 1, n + 1000):
if i % 2 == 0:
continue
elif math.sqrt(i) == 0:
continue
elif len([j for j in primes if i % j == 0 and i != j]) > 0:
continue
print(i)
break
except:
break | 19
3517
| 17 23
3511 3527
|
<H1>素数 II</H1>
<p>
素数というのは、1 よりも大きくそれ自身か 1 でしか割りきれない整数をいいます。例えば、2 は、2 と 1 でしか割り切れないので素数ですが、12 は、12 と 1 のほかに、2, 3, 4, 6 で割りきれる数なので素数ではありません。
</p>
<p>
整数 <var>n</var> を入力したとき、<var>n</var> より小さい素数のうち最も大きいものと、<var>n</var> より大きい素数のうち最も小さいものを出力するプログラムを作成してください。
</p>
<H2>Input</H2>
<p>
複数のデータセットが与えられます。各データセットに <var>n</var> (3 ≤ <var>n</var> ≤ 50,000) が１行に与えられます。
</p>
<p>
データセットの数は 50 を超えません。
</p>
<H2>Output</H2>
<p>
各データセットに対して、<var>n</var> より小さい素数のうち最大のものと、<var>n</var> より大きい素数のうち最小のものを１つのスペースで区切って１行に出力して下さい。
</p>
<H2>Sample Input</H2>
<pre>
19
3517
</pre>
<H2>Output for the Sample Input</H2>
<pre>
17 23
3511 3527
</pre>
|
s671795969 | p00044 | Accepted | # 04.77 sec -> Time Limit Exceeded?
import sys
import math
# Sieve of Eratosthenes
N = 50021
searchList = list(range(3, N + 1, 2))
primes = [2]
while True:
top = searchList.pop(0)
primes.append(top)
if top > math.sqrt(N):
break
searchList = [s for s in searchList if s % top != 0]
primes.extend(searchList)
# solve
for line in sys.stdin:
try:
n = int(line)
pre = 2
for p in primes:
if p < n:
pre = p
if p > n:
print(pre, p)
break
except:
break | 19
3517
| 17 23
3511 3527
|
<H1>素数 II</H1>
<p>
素数というのは、1 よりも大きくそれ自身か 1 でしか割りきれない整数をいいます。例えば、2 は、2 と 1 でしか割り切れないので素数ですが、12 は、12 と 1 のほかに、2, 3, 4, 6 で割りきれる数なので素数ではありません。
</p>
<p>
整数 <var>n</var> を入力したとき、<var>n</var> より小さい素数のうち最も大きいものと、<var>n</var> より大きい素数のうち最も小さいものを出力するプログラムを作成してください。
</p>
<H2>Input</H2>
<p>
複数のデータセットが与えられます。各データセットに <var>n</var> (3 ≤ <var>n</var> ≤ 50,000) が１行に与えられます。
</p>
<p>
データセットの数は 50 を超えません。
</p>
<H2>Output</H2>
<p>
各データセットに対して、<var>n</var> より小さい素数のうち最大のものと、<var>n</var> より大きい素数のうち最小のものを１つのスペースで区切って１行に出力して下さい。
</p>
<H2>Sample Input</H2>
<pre>
19
3517
</pre>
<H2>Output for the Sample Input</H2>
<pre>
17 23
3511 3527
</pre>
|
s282550518 | p00044 | Accepted | import sys
import math
# Sieve of Eratosthenes
N = 50021
searchList = list(range(3, N + 1, 2))
primes = [2]
while True:
top = searchList.pop(0)
primes.append(top)
if top > math.sqrt(N):
break
searchList = [s for s in searchList if s % top != 0]
primes.extend(searchList)
# solve
for line in sys.stdin:
try:
n = int(line)
pre = 2
for p in primes:
if p < n:
pre = p
if p > n:
print(pre, p)
break
except:
break | 19
3517
| 17 23
3511 3527
|
<H1>素数 II</H1>
<p>
素数というのは、1 よりも大きくそれ自身か 1 でしか割りきれない整数をいいます。例えば、2 は、2 と 1 でしか割り切れないので素数ですが、12 は、12 と 1 のほかに、2, 3, 4, 6 で割りきれる数なので素数ではありません。
</p>
<p>
整数 <var>n</var> を入力したとき、<var>n</var> より小さい素数のうち最も大きいものと、<var>n</var> より大きい素数のうち最も小さいものを出力するプログラムを作成してください。
</p>
<H2>Input</H2>
<p>
複数のデータセットが与えられます。各データセットに <var>n</var> (3 ≤ <var>n</var> ≤ 50,000) が１行に与えられます。
</p>
<p>
データセットの数は 50 を超えません。
</p>
<H2>Output</H2>
<p>
各データセットに対して、<var>n</var> より小さい素数のうち最大のものと、<var>n</var> より大きい素数のうち最小のものを１つのスペースで区切って１行に出力して下さい。
</p>
<H2>Sample Input</H2>
<pre>
19
3517
</pre>
<H2>Output for the Sample Input</H2>
<pre>
17 23
3511 3527
</pre>
|
s955989752 | p00044 | Accepted | n = 50021
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:
try:
n = int(input())
i, a, b = 0, 0, 0
while a == 0 or b == 0:
i += 1
if n - i - 1 >= 0 and a == 0 and c[n - i - 1] == 1:
a = n - i
if n + i - 1 < 50021 and b == 0 and c[n + i - 1] == 1:
b = n + i
print(a,b)
except:
break
| 19
3517
| 17 23
3511 3527
|
<H1>素数 II</H1>
<p>
素数というのは、1 よりも大きくそれ自身か 1 でしか割りきれない整数をいいます。例えば、2 は、2 と 1 でしか割り切れないので素数ですが、12 は、12 と 1 のほかに、2, 3, 4, 6 で割りきれる数なので素数ではありません。
</p>
<p>
整数 <var>n</var> を入力したとき、<var>n</var> より小さい素数のうち最も大きいものと、<var>n</var> より大きい素数のうち最も小さいものを出力するプログラムを作成してください。
</p>
<H2>Input</H2>
<p>
複数のデータセットが与えられます。各データセットに <var>n</var> (3 ≤ <var>n</var> ≤ 50,000) が１行に与えられます。
</p>
<p>
データセットの数は 50 を超えません。
</p>
<H2>Output</H2>
<p>
各データセットに対して、<var>n</var> より小さい素数のうち最大のものと、<var>n</var> より大きい素数のうち最小のものを１つのスペースで区切って１行に出力して下さい。
</p>
<H2>Sample Input</H2>
<pre>
19
3517
</pre>
<H2>Output for the Sample Input</H2>
<pre>
17 23
3511 3527
</pre>
|
s360635109 | p00044 | Accepted | def get_input():
while True:
try:
yield ''.join(input())
except EOFError:
break
MAX = 60000
primes = list()
for i in range(MAX):
primes.append(True)
primes[0] = False
primes[1] = False
for i in range(2, MAX):
j = i + i
while j < MAX:
primes[j] = False
j = j + i
N = list(get_input())
for l in range(len(N)):
n = int(N[l])
d = 1
while True:
if primes[n-d]:
print(n-d, end=" ")
break
d += 1
d = 1
while True:
if primes[n+d]:
print(n+d)
break
d += 1
| 19
3517
| 17 23
3511 3527
|
<H1>素数 II</H1>
<p>
素数というのは、1 よりも大きくそれ自身か 1 でしか割りきれない整数をいいます。例えば、2 は、2 と 1 でしか割り切れないので素数ですが、12 は、12 と 1 のほかに、2, 3, 4, 6 で割りきれる数なので素数ではありません。
</p>
<p>
整数 <var>n</var> を入力したとき、<var>n</var> より小さい素数のうち最も大きいものと、<var>n</var> より大きい素数のうち最も小さいものを出力するプログラムを作成してください。
</p>
<H2>Input</H2>
<p>
複数のデータセットが与えられます。各データセットに <var>n</var> (3 ≤ <var>n</var> ≤ 50,000) が１行に与えられます。
</p>
<p>
データセットの数は 50 を超えません。
</p>
<H2>Output</H2>
<p>
各データセットに対して、<var>n</var> より小さい素数のうち最大のものと、<var>n</var> より大きい素数のうち最小のものを１つのスペースで区切って１行に出力して下さい。
</p>
<H2>Sample Input</H2>
<pre>
19
3517
</pre>
<H2>Output for the Sample Input</H2>
<pre>
17 23
3511 3527
</pre>
|
s223461181 | p00044 | Accepted | MAX = 60000
lst = [i for i in range(MAX)]
lst[0] = lst[1] = 0
for i in range(MAX):
if lst[i] != 0:
for j in range(i * 2, MAX, i):
lst[j] = 0
while 0 == 0:
try:
n = int(input())
i = n - 1
j = n + 1
while lst[i] == 0:
i -= 1
while lst[j] == 0:
j += 1
print(str(lst[i]) + " " + str(lst[j]))
except EOFError:
break
| 19
3517
| 17 23
3511 3527
|
<H1>素数 II</H1>
<p>
素数というのは、1 よりも大きくそれ自身か 1 でしか割りきれない整数をいいます。例えば、2 は、2 と 1 でしか割り切れないので素数ですが、12 は、12 と 1 のほかに、2, 3, 4, 6 で割りきれる数なので素数ではありません。
</p>
<p>
整数 <var>n</var> を入力したとき、<var>n</var> より小さい素数のうち最も大きいものと、<var>n</var> より大きい素数のうち最も小さいものを出力するプログラムを作成してください。
</p>
<H2>Input</H2>
<p>
複数のデータセットが与えられます。各データセットに <var>n</var> (3 ≤ <var>n</var> ≤ 50,000) が１行に与えられます。
</p>
<p>
データセットの数は 50 を超えません。
</p>
<H2>Output</H2>
<p>
各データセットに対して、<var>n</var> より小さい素数のうち最大のものと、<var>n</var> より大きい素数のうち最小のものを１つのスペースで区切って１行に出力して下さい。
</p>
<H2>Sample Input</H2>
<pre>
19
3517
</pre>
<H2>Output for the Sample Input</H2>
<pre>
17 23
3511 3527
</pre>
|
s235575413 | p00044 | Accepted | MAX = 60000
lst = [i for i in range(MAX)]
lst[0] = lst[1] = 0
for i in range(MAX):
if lst[i] != 0:
for j in range(i * 2, MAX, i):
lst[j] = 0
while 0 == 0:
try:
n = int(input())
i = n - 1
j = n + 1
while lst[i] == 0:
i -= 1
while lst[j] == 0:
j += 1
print(lst[i],lst[j])
except EOFError:
break
| 19
3517
| 17 23
3511 3527
|
<H1>素数 II</H1>
<p>
素数というのは、1 よりも大きくそれ自身か 1 でしか割りきれない整数をいいます。例えば、2 は、2 と 1 でしか割り切れないので素数ですが、12 は、12 と 1 のほかに、2, 3, 4, 6 で割りきれる数なので素数ではありません。
</p>
<p>
整数 <var>n</var> を入力したとき、<var>n</var> より小さい素数のうち最も大きいものと、<var>n</var> より大きい素数のうち最も小さいものを出力するプログラムを作成してください。
</p>
<H2>Input</H2>
<p>
複数のデータセットが与えられます。各データセットに <var>n</var> (3 ≤ <var>n</var> ≤ 50,000) が１行に与えられます。
</p>
<p>
データセットの数は 50 を超えません。
</p>
<H2>Output</H2>
<p>
各データセットに対して、<var>n</var> より小さい素数のうち最大のものと、<var>n</var> より大きい素数のうち最小のものを１つのスペースで区切って１行に出力して下さい。
</p>
<H2>Sample Input</H2>
<pre>
19
3517
</pre>
<H2>Output for the Sample Input</H2>
<pre>
17 23
3511 3527
</pre>
|
s202166937 | p00044 | Accepted | import sys
for e in sys.stdin:
a=b=int(e)
while 1:
a-=1
if 2 in[a,pow(2,a,a)]:break
while 1:
b+=1
if 2 in[b,pow(2,b,b)]:break
print(a,b)
| 19
3517
| 17 23
3511 3527
|
<H1>素数 II</H1>
<p>
素数というのは、1 よりも大きくそれ自身か 1 でしか割りきれない整数をいいます。例えば、2 は、2 と 1 でしか割り切れないので素数ですが、12 は、12 と 1 のほかに、2, 3, 4, 6 で割りきれる数なので素数ではありません。
</p>
<p>
整数 <var>n</var> を入力したとき、<var>n</var> より小さい素数のうち最も大きいものと、<var>n</var> より大きい素数のうち最も小さいものを出力するプログラムを作成してください。
</p>
<H2>Input</H2>
<p>
複数のデータセットが与えられます。各データセットに <var>n</var> (3 ≤ <var>n</var> ≤ 50,000) が１行に与えられます。
</p>
<p>
データセットの数は 50 を超えません。
</p>
<H2>Output</H2>
<p>
各データセットに対して、<var>n</var> より小さい素数のうち最大のものと、<var>n</var> より大きい素数のうち最小のものを１つのスペースで区切って１行に出力して下さい。
</p>
<H2>Sample Input</H2>
<pre>
19
3517
</pre>
<H2>Output for the Sample Input</H2>
<pre>
17 23
3511 3527
</pre>
|
s589078436 | p00044 | Accepted | import sys
def is_prime(x):
if x<=1:return False
i=2
while i*i<=x:
if x%i==0:return False
i+=1
return True
for e in sys.stdin:
N=int(e)
mx=mn=0
for i in range(N-1,1,-1):
if is_prime(i):mx=i;break
for i in range(N+1,N*2):
if is_prime(i):mn=i;break
print(mx,mn)
| 19
3517
| 17 23
3511 3527
|
<H1>素数 II</H1>
<p>
素数というのは、1 よりも大きくそれ自身か 1 でしか割りきれない整数をいいます。例えば、2 は、2 と 1 でしか割り切れないので素数ですが、12 は、12 と 1 のほかに、2, 3, 4, 6 で割りきれる数なので素数ではありません。
</p>
<p>
整数 <var>n</var> を入力したとき、<var>n</var> より小さい素数のうち最も大きいものと、<var>n</var> より大きい素数のうち最も小さいものを出力するプログラムを作成してください。
</p>
<H2>Input</H2>
<p>
複数のデータセットが与えられます。各データセットに <var>n</var> (3 ≤ <var>n</var> ≤ 50,000) が１行に与えられます。
</p>
<p>
データセットの数は 50 を超えません。
</p>
<H2>Output</H2>
<p>
各データセットに対して、<var>n</var> より小さい素数のうち最大のものと、<var>n</var> より大きい素数のうち最小のものを１つのスペースで区切って１行に出力して下さい。
</p>
<H2>Sample Input</H2>
<pre>
19
3517
</pre>
<H2>Output for the Sample Input</H2>
<pre>
17 23
3511 3527
</pre>
|
s664704122 | p00044 | Accepted | a = [0, 0, 1, 1] + [0, 1] * 25009
for i in range(3, 50022, 2):
if a[i]:
for j in range(2, 50021 // i + 1):a[i * j] = 0
while 1:
try:
n = int(input())
print("{} {}".format(n - 1 - a[:n][::-1].index(1), n + 1 + a[n + 1:].index(1)))
except:break
| 19
3517
| 17 23
3511 3527
|
<H1>素数 II</H1>
<p>
素数というのは、1 よりも大きくそれ自身か 1 でしか割りきれない整数をいいます。例えば、2 は、2 と 1 でしか割り切れないので素数ですが、12 は、12 と 1 のほかに、2, 3, 4, 6 で割りきれる数なので素数ではありません。
</p>
<p>
整数 <var>n</var> を入力したとき、<var>n</var> より小さい素数のうち最も大きいものと、<var>n</var> より大きい素数のうち最も小さいものを出力するプログラムを作成してください。
</p>
<H2>Input</H2>
<p>
複数のデータセットが与えられます。各データセットに <var>n</var> (3 ≤ <var>n</var> ≤ 50,000) が１行に与えられます。
</p>
<p>
データセットの数は 50 を超えません。
</p>
<H2>Output</H2>
<p>
各データセットに対して、<var>n</var> より小さい素数のうち最大のものと、<var>n</var> より大きい素数のうち最小のものを１つのスペースで区切って１行に出力して下さい。
</p>
<H2>Sample Input</H2>
<pre>
19
3517
</pre>
<H2>Output for the Sample Input</H2>
<pre>
17 23
3511 3527
</pre>
|
s835936519 | p00044 | Accepted | import bisect
MAX = 60000
#エラトステネスの篩
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:
try:
n = int(input())
ind = bisect.bisect_left(primes, n)
if primes[ind] == n:
print(primes[ind - 1], primes[ind + 1])
else:
print(primes[ind - 1], primes[ind])
except EOFError:
break
| 19
3517
| 17 23
3511 3527
|
<H1>素数 II</H1>
<p>
素数というのは、1 よりも大きくそれ自身か 1 でしか割りきれない整数をいいます。例えば、2 は、2 と 1 でしか割り切れないので素数ですが、12 は、12 と 1 のほかに、2, 3, 4, 6 で割りきれる数なので素数ではありません。
</p>
<p>
整数 <var>n</var> を入力したとき、<var>n</var> より小さい素数のうち最も大きいものと、<var>n</var> より大きい素数のうち最も小さいものを出力するプログラムを作成してください。
</p>
<H2>Input</H2>
<p>
複数のデータセットが与えられます。各データセットに <var>n</var> (3 ≤ <var>n</var> ≤ 50,000) が１行に与えられます。
</p>
<p>
データセットの数は 50 を超えません。
</p>
<H2>Output</H2>
<p>
各データセットに対して、<var>n</var> より小さい素数のうち最大のものと、<var>n</var> より大きい素数のうち最小のものを１つのスペースで区切って１行に出力して下さい。
</p>
<H2>Sample Input</H2>
<pre>
19
3517
</pre>
<H2>Output for the Sample Input</H2>
<pre>
17 23
3511 3527
</pre>
|
s532963938 | p00044 | Accepted | import bisect
MAX = 50050
#エラトステネスの篩
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:
try:
n = int(input())
ind = bisect.bisect_left(primes, n)
if primes[ind] == n:
print(primes[ind - 1], primes[ind + 1])
else:
print(primes[ind - 1], primes[ind])
except EOFError:
break
| 19
3517
| 17 23
3511 3527
|
<H1>素数 II</H1>
<p>
素数というのは、1 よりも大きくそれ自身か 1 でしか割りきれない整数をいいます。例えば、2 は、2 と 1 でしか割り切れないので素数ですが、12 は、12 と 1 のほかに、2, 3, 4, 6 で割りきれる数なので素数ではありません。
</p>
<p>
整数 <var>n</var> を入力したとき、<var>n</var> より小さい素数のうち最も大きいものと、<var>n</var> より大きい素数のうち最も小さいものを出力するプログラムを作成してください。
</p>
<H2>Input</H2>
<p>
複数のデータセットが与えられます。各データセットに <var>n</var> (3 ≤ <var>n</var> ≤ 50,000) が１行に与えられます。
</p>
<p>
データセットの数は 50 を超えません。
</p>
<H2>Output</H2>
<p>
各データセットに対して、<var>n</var> より小さい素数のうち最大のものと、<var>n</var> より大きい素数のうち最小のものを１つのスペースで区切って１行に出力して下さい。
</p>
<H2>Sample Input</H2>
<pre>
19
3517
</pre>
<H2>Output for the Sample Input</H2>
<pre>
17 23
3511 3527
</pre>
|
s124271494 | p00044 | Accepted | # AOJ 0044 Prime Number II
# Python3 2018.6.16 bal4u
MAX = 50025
SQRT = 223 # sqrt(MAX)
prime = [True for i in range(MAX)]
def sieve():
for i in range(4, MAX, 2):
prime[i] = False
for i in range(3, SQRT, 2):
if prime[i] is True:
for j in range(i*i, MAX, i):
prime[j] = False
sieve()
while True:
try:
n = int(input())
except EOFError:
break
for i in range(n-1, 1, -1):
if prime[i]:
a = i
break
for i in range(n+1, MAX):
if prime[i]:
b = i
break
print(a, b)
| 19
3517
| 17 23
3511 3527
|
<H1>素数 II</H1>
<p>
素数というのは、1 よりも大きくそれ自身か 1 でしか割りきれない整数をいいます。例えば、2 は、2 と 1 でしか割り切れないので素数ですが、12 は、12 と 1 のほかに、2, 3, 4, 6 で割りきれる数なので素数ではありません。
</p>
<p>
整数 <var>n</var> を入力したとき、<var>n</var> より小さい素数のうち最も大きいものと、<var>n</var> より大きい素数のうち最も小さいものを出力するプログラムを作成してください。
</p>
<H2>Input</H2>
<p>
複数のデータセットが与えられます。各データセットに <var>n</var> (3 ≤ <var>n</var> ≤ 50,000) が１行に与えられます。
</p>
<p>
データセットの数は 50 を超えません。
</p>
<H2>Output</H2>
<p>
各データセットに対して、<var>n</var> より小さい素数のうち最大のものと、<var>n</var> より大きい素数のうち最小のものを１つのスペースで区切って１行に出力して下さい。
</p>
<H2>Sample Input</H2>
<pre>
19
3517
</pre>
<H2>Output for the Sample Input</H2>
<pre>
17 23
3511 3527
</pre>
|
s973381371 | p00044 | Accepted | from itertools import chain
from bisect import bisect_left
max_n = 50022
primes = {2,3} | {m for n in (5, 7) for m in range(n, max_n, 6)}
du = primes.difference_update
for n in chain(range(5, max_n, 6), range(7, max_n, 6)):
if n in primes:
du(range(n*3, max_n, n*2))
primes = tuple(primes)
try:
while True:
n = int(input())
i = bisect_left(primes, n)
print(primes[i-1], primes[i+(n==primes[i])])
except EOFError:
exit()
| 19
3517
| 17 23
3511 3527
|
<H1>素数 II</H1>
<p>
素数というのは、1 よりも大きくそれ自身か 1 でしか割りきれない整数をいいます。例えば、2 は、2 と 1 でしか割り切れないので素数ですが、12 は、12 と 1 のほかに、2, 3, 4, 6 で割りきれる数なので素数ではありません。
</p>
<p>
整数 <var>n</var> を入力したとき、<var>n</var> より小さい素数のうち最も大きいものと、<var>n</var> より大きい素数のうち最も小さいものを出力するプログラムを作成してください。
</p>
<H2>Input</H2>
<p>
複数のデータセットが与えられます。各データセットに <var>n</var> (3 ≤ <var>n</var> ≤ 50,000) が１行に与えられます。
</p>
<p>
データセットの数は 50 を超えません。
</p>
<H2>Output</H2>
<p>
各データセットに対して、<var>n</var> より小さい素数のうち最大のものと、<var>n</var> より大きい素数のうち最小のものを１つのスペースで区切って１行に出力して下さい。
</p>
<H2>Sample Input</H2>
<pre>
19
3517
</pre>
<H2>Output for the Sample Input</H2>
<pre>
17 23
3511 3527
</pre>
|
s241311451 | p00044 | Accepted | def primes(n):
is_prime = [True] * (n + 1)
is_prime[0] = False
is_prime[1] = False
for i in range(2, int(n**0.5) + 1):
if not is_prime[i]:
continue
for j in range(i * 2, n + 1, i):
is_prime[j] = False
return [i for i in range(n + 1) if is_prime[i]]
if __name__ == "__main__":
all_primes = primes(60000)
while True:
try:
n = int(input())
ps = primes(n)
x = ps[-1] if ps[-1] != n else ps[-2]
y = all_primes[len(ps)]
print("{} {}".format(x, y))
except:
break
| 19
3517
| 17 23
3511 3527
|
<H1>素数 II</H1>
<p>
素数というのは、1 よりも大きくそれ自身か 1 でしか割りきれない整数をいいます。例えば、2 は、2 と 1 でしか割り切れないので素数ですが、12 は、12 と 1 のほかに、2, 3, 4, 6 で割りきれる数なので素数ではありません。
</p>
<p>
整数 <var>n</var> を入力したとき、<var>n</var> より小さい素数のうち最も大きいものと、<var>n</var> より大きい素数のうち最も小さいものを出力するプログラムを作成してください。
</p>
<H2>Input</H2>
<p>
複数のデータセットが与えられます。各データセットに <var>n</var> (3 ≤ <var>n</var> ≤ 50,000) が１行に与えられます。
</p>
<p>
データセットの数は 50 を超えません。
</p>
<H2>Output</H2>
<p>
各データセットに対して、<var>n</var> より小さい素数のうち最大のものと、<var>n</var> より大きい素数のうち最小のものを１つのスペースで区切って１行に出力して下さい。
</p>
<H2>Sample Input</H2>
<pre>
19
3517
</pre>
<H2>Output for the Sample Input</H2>
<pre>
17 23
3511 3527
</pre>
|
s651664525 | p00044 | Accepted | import sys
n=10**6
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
gr,le=[None]*n,[None]*n
prime=None
for i in xrange(n-1,-1,-1):
gr[i]=prime
if p[i]:
prime=i
for i in xrange(0,n):
le[i]=prime
if p[i]:
prime=i
for line in sys.stdin.readlines():
num=int(line.strip())
print le[num],gr[num] | 19
3517
| 17 23
3511 3527
|
<H1>素数 II</H1>
<p>
素数というのは、1 よりも大きくそれ自身か 1 でしか割りきれない整数をいいます。例えば、2 は、2 と 1 でしか割り切れないので素数ですが、12 は、12 と 1 のほかに、2, 3, 4, 6 で割りきれる数なので素数ではありません。
</p>
<p>
整数 <var>n</var> を入力したとき、<var>n</var> より小さい素数のうち最も大きいものと、<var>n</var> より大きい素数のうち最も小さいものを出力するプログラムを作成してください。
</p>
<H2>Input</H2>
<p>
複数のデータセットが与えられます。各データセットに <var>n</var> (3 ≤ <var>n</var> ≤ 50,000) が１行に与えられます。
</p>
<p>
データセットの数は 50 を超えません。
</p>
<H2>Output</H2>
<p>
各データセットに対して、<var>n</var> より小さい素数のうち最大のものと、<var>n</var> より大きい素数のうち最小のものを１つのスペースで区切って１行に出力して下さい。
</p>
<H2>Sample Input</H2>
<pre>
19
3517
</pre>
<H2>Output for the Sample Input</H2>
<pre>
17 23
3511 3527
</pre>
|
s877241646 | p00044 | Accepted | import math
p = [2]
s = 3
max = 50000
while p[len(p)-1] <= max:
m = int(math.sqrt(s))
r = True
for i in p:
if i > m:
break
if s % i == 0:
r = False
break
if r:
p.append(s)
s += 2
while True:
try:
n = int(raw_input())
except EOFError as e:
break
i = 0
while p[i] < n:
i += 1
print("%d %d" % (p[i-1], p[i+1] if p[i] == n else p[i])) | 19
3517
| 17 23
3511 3527
|
<H1>素数 II</H1>
<p>
素数というのは、1 よりも大きくそれ自身か 1 でしか割りきれない整数をいいます。例えば、2 は、2 と 1 でしか割り切れないので素数ですが、12 は、12 と 1 のほかに、2, 3, 4, 6 で割りきれる数なので素数ではありません。
</p>
<p>
整数 <var>n</var> を入力したとき、<var>n</var> より小さい素数のうち最も大きいものと、<var>n</var> より大きい素数のうち最も小さいものを出力するプログラムを作成してください。
</p>
<H2>Input</H2>
<p>
複数のデータセットが与えられます。各データセットに <var>n</var> (3 ≤ <var>n</var> ≤ 50,000) が１行に与えられます。
</p>
<p>
データセットの数は 50 を超えません。
</p>
<H2>Output</H2>
<p>
各データセットに対して、<var>n</var> より小さい素数のうち最大のものと、<var>n</var> より大きい素数のうち最小のものを１つのスペースで区切って１行に出力して下さい。
</p>
<H2>Sample Input</H2>
<pre>
19
3517
</pre>
<H2>Output for the Sample Input</H2>
<pre>
17 23
3511 3527
</pre>
|
s984938690 | p00044 | Accepted | import math
p = [2]
s = 3
max = 50000
last = 0
while p[last] <= max:
m = int(math.sqrt(s))
r = True
for i in p:
if i > m:
break
if s % i == 0:
r = False
break
if r:
p.append(s)
last += 1
s += 2
while True:
try:
n = int(raw_input())
except EOFError as e:
break
i = 0
while p[i] < n:
i += 1
print("%d %d" % (p[i-1], p[i+1] if p[i] == n else p[i])) | 19
3517
| 17 23
3511 3527
|
<H1>素数 II</H1>
<p>
素数というのは、1 よりも大きくそれ自身か 1 でしか割りきれない整数をいいます。例えば、2 は、2 と 1 でしか割り切れないので素数ですが、12 は、12 と 1 のほかに、2, 3, 4, 6 で割りきれる数なので素数ではありません。
</p>
<p>
整数 <var>n</var> を入力したとき、<var>n</var> より小さい素数のうち最も大きいものと、<var>n</var> より大きい素数のうち最も小さいものを出力するプログラムを作成してください。
</p>
<H2>Input</H2>
<p>
複数のデータセットが与えられます。各データセットに <var>n</var> (3 ≤ <var>n</var> ≤ 50,000) が１行に与えられます。
</p>
<p>
データセットの数は 50 を超えません。
</p>
<H2>Output</H2>
<p>
各データセットに対して、<var>n</var> より小さい素数のうち最大のものと、<var>n</var> より大きい素数のうち最小のものを１つのスペースで区切って１行に出力して下さい。
</p>
<H2>Sample Input</H2>
<pre>
19
3517
</pre>
<H2>Output for the Sample Input</H2>
<pre>
17 23
3511 3527
</pre>
|
s704633869 | p00044 | Accepted | import sys
def is_prime(q):
q = abs(q)
if q == 2: return True
if q < 2 or q&1 == 0: return False
return pow(2, q-1, q) == 1
for n in sys.stdin:
a=int(n.strip())
b=a
while 1:
a+=1
if is_prime(a):
max_a=a
break
while 1:
b-=1
if is_prime(b):
min_b=b
break
print min_b,max_a | 19
3517
| 17 23
3511 3527
|
<H1>素数 II</H1>
<p>
素数というのは、1 よりも大きくそれ自身か 1 でしか割りきれない整数をいいます。例えば、2 は、2 と 1 でしか割り切れないので素数ですが、12 は、12 と 1 のほかに、2, 3, 4, 6 で割りきれる数なので素数ではありません。
</p>
<p>
整数 <var>n</var> を入力したとき、<var>n</var> より小さい素数のうち最も大きいものと、<var>n</var> より大きい素数のうち最も小さいものを出力するプログラムを作成してください。
</p>
<H2>Input</H2>
<p>
複数のデータセットが与えられます。各データセットに <var>n</var> (3 ≤ <var>n</var> ≤ 50,000) が１行に与えられます。
</p>
<p>
データセットの数は 50 を超えません。
</p>
<H2>Output</H2>
<p>
各データセットに対して、<var>n</var> より小さい素数のうち最大のものと、<var>n</var> より大きい素数のうち最小のものを１つのスペースで区切って１行に出力して下さい。
</p>
<H2>Sample Input</H2>
<pre>
19
3517
</pre>
<H2>Output for the Sample Input</H2>
<pre>
17 23
3511 3527
</pre>
|
s023842875 | p00044 | Accepted |
import sys
primes = [2]
def solv(num):
p1 = 0
p2 = 0
if num < primes[-1]:
p1 = filter(lambda x: x < num, primes)[-1]
lis = filter(lambda x: num < x, primes)
if lis:
p2 = lis[0]
else:
for p in prime_list(num * 2):
primes.append(p)
if num < p:
p2 = p
break
else:
if p < num:
p1 = p
return (p1, p2)
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]
for line in sys.stdin:
number = int(line)
p1, p2 = solv(number)
print ' '.join(map(str, [p1, p2])) | 19
3517
| 17 23
3511 3527
|
<H1>素数 II</H1>
<p>
素数というのは、1 よりも大きくそれ自身か 1 でしか割りきれない整数をいいます。例えば、2 は、2 と 1 でしか割り切れないので素数ですが、12 は、12 と 1 のほかに、2, 3, 4, 6 で割りきれる数なので素数ではありません。
</p>
<p>
整数 <var>n</var> を入力したとき、<var>n</var> より小さい素数のうち最も大きいものと、<var>n</var> より大きい素数のうち最も小さいものを出力するプログラムを作成してください。
</p>
<H2>Input</H2>
<p>
複数のデータセットが与えられます。各データセットに <var>n</var> (3 ≤ <var>n</var> ≤ 50,000) が１行に与えられます。
</p>
<p>
データセットの数は 50 を超えません。
</p>
<H2>Output</H2>
<p>
各データセットに対して、<var>n</var> より小さい素数のうち最大のものと、<var>n</var> より大きい素数のうち最小のものを１つのスペースで区切って１行に出力して下さい。
</p>
<H2>Sample Input</H2>
<pre>
19
3517
</pre>
<H2>Output for the Sample Input</H2>
<pre>
17 23
3511 3527
</pre>
|
s033539919 | p00044 | Accepted | #!/usr/bin/env python
# -*- coding: utf-8 -*-
from __future__ import (division, absolute_import, print_function,
unicode_literals)
from sys import stdin
def prime(n):
L = list(xrange(2, n))
P = []
while L[0] ** 2 < n:
P.append(L[0])
L = [i for i in L if i % P[-1]]
return P + L
ps = prime(50030)
for line in stdin:
n = int(line)
for p in ps:
if n < p:
upper = p
break
if p < n:
under = p
print(under, upper) | 19
3517
| 17 23
3511 3527
|
<H1>素数 II</H1>
<p>
素数というのは、1 よりも大きくそれ自身か 1 でしか割りきれない整数をいいます。例えば、2 は、2 と 1 でしか割り切れないので素数ですが、12 は、12 と 1 のほかに、2, 3, 4, 6 で割りきれる数なので素数ではありません。
</p>
<p>
整数 <var>n</var> を入力したとき、<var>n</var> より小さい素数のうち最も大きいものと、<var>n</var> より大きい素数のうち最も小さいものを出力するプログラムを作成してください。
</p>
<H2>Input</H2>
<p>
複数のデータセットが与えられます。各データセットに <var>n</var> (3 ≤ <var>n</var> ≤ 50,000) が１行に与えられます。
</p>
<p>
データセットの数は 50 を超えません。
</p>
<H2>Output</H2>
<p>
各データセットに対して、<var>n</var> より小さい素数のうち最大のものと、<var>n</var> より大きい素数のうち最小のものを１つのスペースで区切って１行に出力して下さい。
</p>
<H2>Sample Input</H2>
<pre>
19
3517
</pre>
<H2>Output for the Sample Input</H2>
<pre>
17 23
3511 3527
</pre>
|
s774128292 | p00044 | Accepted | import sys
p = [True] * (55000)
p[0] = p[1] = False
for i in range(2, 55000):
if p[i]:
for j in range(i * 2, 55000, i):
p[j] = False
for s in sys.stdin.read().rstrip().split('\n'):
n = int(s)
for i in range(n-1, 0, -1):
if p[i]:
m1 = i
break
for i in range(n+1, len(p)):
if p[i]:
m2 = i
break
print m1, m2 | 19
3517
| 17 23
3511 3527
|
<H1>素数 II</H1>
<p>
素数というのは、1 よりも大きくそれ自身か 1 でしか割りきれない整数をいいます。例えば、2 は、2 と 1 でしか割り切れないので素数ですが、12 は、12 と 1 のほかに、2, 3, 4, 6 で割りきれる数なので素数ではありません。
</p>
<p>
整数 <var>n</var> を入力したとき、<var>n</var> より小さい素数のうち最も大きいものと、<var>n</var> より大きい素数のうち最も小さいものを出力するプログラムを作成してください。
</p>
<H2>Input</H2>
<p>
複数のデータセットが与えられます。各データセットに <var>n</var> (3 ≤ <var>n</var> ≤ 50,000) が１行に与えられます。
</p>
<p>
データセットの数は 50 を超えません。
</p>
<H2>Output</H2>
<p>
各データセットに対して、<var>n</var> より小さい素数のうち最大のものと、<var>n</var> より大きい素数のうち最小のものを１つのスペースで区切って１行に出力して下さい。
</p>
<H2>Sample Input</H2>
<pre>
19
3517
</pre>
<H2>Output for the Sample Input</H2>
<pre>
17 23
3511 3527
</pre>
|
s556708800 | p00044 | Accepted | M = 50100
p = [1]*M; p[0],p[1]=0,0;
pm = [0]*M; pM = [0]*M;
for i in range(2,M):
if p[i]:
for j in range(i*i,M,i): p[j] = 0
num = -1
for i in range(1,M):
pm[i] = num
if p[i]: num = i
num = -1
for i in range(M-1,2,-1):
pM[i] = num
if p[i]: num = i
while 1:
try:
n = input()
print pm[n],pM[n]
except EOFError:
break | 19
3517
| 17 23
3511 3527
|
<H1>素数 II</H1>
<p>
素数というのは、1 よりも大きくそれ自身か 1 でしか割りきれない整数をいいます。例えば、2 は、2 と 1 でしか割り切れないので素数ですが、12 は、12 と 1 のほかに、2, 3, 4, 6 で割りきれる数なので素数ではありません。
</p>
<p>
整数 <var>n</var> を入力したとき、<var>n</var> より小さい素数のうち最も大きいものと、<var>n</var> より大きい素数のうち最も小さいものを出力するプログラムを作成してください。
</p>
<H2>Input</H2>
<p>
複数のデータセットが与えられます。各データセットに <var>n</var> (3 ≤ <var>n</var> ≤ 50,000) が１行に与えられます。
</p>
<p>
データセットの数は 50 を超えません。
</p>
<H2>Output</H2>
<p>
各データセットに対して、<var>n</var> より小さい素数のうち最大のものと、<var>n</var> より大きい素数のうち最小のものを１つのスペースで区切って１行に出力して下さい。
</p>
<H2>Sample Input</H2>
<pre>
19
3517
</pre>
<H2>Output for the Sample Input</H2>
<pre>
17 23
3511 3527
</pre>
|
s921696961 | p00044 | Accepted | import math
def get_primes(max_number):
if max_number == 2:
return [2]
elif max_number < 3:
return []
numbers = range(1, max_number + 2, 2)
nroot = math.floor(max_number ** 0.5)
n = len(numbers)
numbers[0] = 0
for i in range(1, n):
x = numbers[i]
if x > nroot:
break
if x and i + x < n:
for j in range(i+x, n, x):
numbers[j] = 0
x=[2] + filter(None, numbers[1:])
return x
primes = get_primes(50100)
while True:
try:
n = input()
except:
break
for a in primes:
if a<n: b=a
elif a>n: break
print b,a | 19
3517
| 17 23
3511 3527
|
<H1>素数 II</H1>
<p>
素数というのは、1 よりも大きくそれ自身か 1 でしか割りきれない整数をいいます。例えば、2 は、2 と 1 でしか割り切れないので素数ですが、12 は、12 と 1 のほかに、2, 3, 4, 6 で割りきれる数なので素数ではありません。
</p>
<p>
整数 <var>n</var> を入力したとき、<var>n</var> より小さい素数のうち最も大きいものと、<var>n</var> より大きい素数のうち最も小さいものを出力するプログラムを作成してください。
</p>
<H2>Input</H2>
<p>
複数のデータセットが与えられます。各データセットに <var>n</var> (3 ≤ <var>n</var> ≤ 50,000) が１行に与えられます。
</p>
<p>
データセットの数は 50 を超えません。
</p>
<H2>Output</H2>
<p>
各データセットに対して、<var>n</var> より小さい素数のうち最大のものと、<var>n</var> より大きい素数のうち最小のものを１つのスペースで区切って１行に出力して下さい。
</p>
<H2>Sample Input</H2>
<pre>
19
3517
</pre>
<H2>Output for the Sample Input</H2>
<pre>
17 23
3511 3527
</pre>
|
s627710505 | p00044 | Accepted | import math
def get_primes(m):
if m == 2: return [2]
elif m < 3: return []
N = [0]+range(3, m + 2, 2)
nroot = math.floor(m ** 0.5)
n = len(N)
for i in range(1, n):
x = N[i]
if x > nroot: break
if x and i + x < n:
for j in range(i+x, n, x):
N[j] = 0
x=[2] + filter(None, N[1:])
return x
n=10000
primes=get_primes(50100)
while True:
try: n=input()
except: break
for a in primes:
if a<n: b=a
elif a>n: break
print b,a | 19
3517
| 17 23
3511 3527
|
<H1>素数 II</H1>
<p>
素数というのは、1 よりも大きくそれ自身か 1 でしか割りきれない整数をいいます。例えば、2 は、2 と 1 でしか割り切れないので素数ですが、12 は、12 と 1 のほかに、2, 3, 4, 6 で割りきれる数なので素数ではありません。
</p>
<p>
整数 <var>n</var> を入力したとき、<var>n</var> より小さい素数のうち最も大きいものと、<var>n</var> より大きい素数のうち最も小さいものを出力するプログラムを作成してください。
</p>
<H2>Input</H2>
<p>
複数のデータセットが与えられます。各データセットに <var>n</var> (3 ≤ <var>n</var> ≤ 50,000) が１行に与えられます。
</p>
<p>
データセットの数は 50 を超えません。
</p>
<H2>Output</H2>
<p>
各データセットに対して、<var>n</var> より小さい素数のうち最大のものと、<var>n</var> より大きい素数のうち最小のものを１つのスペースで区切って１行に出力して下さい。
</p>
<H2>Sample Input</H2>
<pre>
19
3517
</pre>
<H2>Output for the Sample Input</H2>
<pre>
17 23
3511 3527
</pre>
|
s299937218 | p00044 | Accepted | import math
r = 50021
sqrt = int(math.sqrt(r))
p = [1]*r
p[0] = 0
for i in range(1,sqrt):
if p[i]:
for j in range(2*i+1,r,i+1):
p[j] = 0
while True:
try:
n = int(raw_input())
for i in range(n,r):
if p[i] == 1:
lp = i+1
break
for i in range(n-2,0,-1):
if p[i] == 1:
sp = i+1
break
print sp, lp
except:
break | 19
3517
| 17 23
3511 3527
|
<H1>素数 II</H1>
<p>
素数というのは、1 よりも大きくそれ自身か 1 でしか割りきれない整数をいいます。例えば、2 は、2 と 1 でしか割り切れないので素数ですが、12 は、12 と 1 のほかに、2, 3, 4, 6 で割りきれる数なので素数ではありません。
</p>
<p>
整数 <var>n</var> を入力したとき、<var>n</var> より小さい素数のうち最も大きいものと、<var>n</var> より大きい素数のうち最も小さいものを出力するプログラムを作成してください。
</p>
<H2>Input</H2>
<p>
複数のデータセットが与えられます。各データセットに <var>n</var> (3 ≤ <var>n</var> ≤ 50,000) が１行に与えられます。
</p>
<p>
データセットの数は 50 を超えません。
</p>
<H2>Output</H2>
<p>
各データセットに対して、<var>n</var> より小さい素数のうち最大のものと、<var>n</var> より大きい素数のうち最小のものを１つのスペースで区切って１行に出力して下さい。
</p>
<H2>Sample Input</H2>
<pre>
19
3517
</pre>
<H2>Output for the Sample Input</H2>
<pre>
17 23
3511 3527
</pre>
|
s836322834 | p00044 | Accepted | import math
n = []
while True:
try:
n.append(int(raw_input()))
except:
break
r = max(n)+100
sqrt = int(math.sqrt(r))
p = [1]*r
p[0] = 0
for i in range(1,sqrt):
if p[i]:
for j in range(2*i+1,r,i+1):
p[j] = 0
for a in n:
for i in range(a,r):
if p[i] == 1:
lp = i+1
break
for i in range(a-2,0,-1):
if p[i] == 1:
sp = i+1
break
print sp, lp | 19
3517
| 17 23
3511 3527
|
<H1>素数 II</H1>
<p>
素数というのは、1 よりも大きくそれ自身か 1 でしか割りきれない整数をいいます。例えば、2 は、2 と 1 でしか割り切れないので素数ですが、12 は、12 と 1 のほかに、2, 3, 4, 6 で割りきれる数なので素数ではありません。
</p>
<p>
整数 <var>n</var> を入力したとき、<var>n</var> より小さい素数のうち最も大きいものと、<var>n</var> より大きい素数のうち最も小さいものを出力するプログラムを作成してください。
</p>
<H2>Input</H2>
<p>
複数のデータセットが与えられます。各データセットに <var>n</var> (3 ≤ <var>n</var> ≤ 50,000) が１行に与えられます。
</p>
<p>
データセットの数は 50 を超えません。
</p>
<H2>Output</H2>
<p>
各データセットに対して、<var>n</var> より小さい素数のうち最大のものと、<var>n</var> より大きい素数のうち最小のものを１つのスペースで区切って１行に出力して下さい。
</p>
<H2>Sample Input</H2>
<pre>
19
3517
</pre>
<H2>Output for the Sample Input</H2>
<pre>
17 23
3511 3527
</pre>
|
s891819616 | p00044 | Accepted | import sys
def primes(m):
N = range(1,m+1,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)
x = [2] + filter(None,N)
return x
PRIMES = primes(50100)
for s in sys.stdin:
n = int(s)
for a in PRIMES:
if a>n: break
elif a<n: b = a
print b,a | 19
3517
| 17 23
3511 3527
|
<H1>素数 II</H1>
<p>
素数というのは、1 よりも大きくそれ自身か 1 でしか割りきれない整数をいいます。例えば、2 は、2 と 1 でしか割り切れないので素数ですが、12 は、12 と 1 のほかに、2, 3, 4, 6 で割りきれる数なので素数ではありません。
</p>
<p>
整数 <var>n</var> を入力したとき、<var>n</var> より小さい素数のうち最も大きいものと、<var>n</var> より大きい素数のうち最も小さいものを出力するプログラムを作成してください。
</p>
<H2>Input</H2>
<p>
複数のデータセットが与えられます。各データセットに <var>n</var> (3 ≤ <var>n</var> ≤ 50,000) が１行に与えられます。
</p>
<p>
データセットの数は 50 を超えません。
</p>
<H2>Output</H2>
<p>
各データセットに対して、<var>n</var> より小さい素数のうち最大のものと、<var>n</var> より大きい素数のうち最小のものを１つのスペースで区切って１行に出力して下さい。
</p>
<H2>Sample Input</H2>
<pre>
19
3517
</pre>
<H2>Output for the Sample Input</H2>
<pre>
17 23
3511 3527
</pre>
|
s286763584 | p00044 | Accepted | import sys
def sieves(m):
N = range(1,m+1,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)
N[0] = 2
return N
S = sieves(50100)
for s in sys.stdin:
n = int(s)
p1 = n/2-1
p2 = (n+1)/2
while S[p1]==0: p1 -=1
while S[p2]==0: p2 +=1
print S[p1],S[p2] | 19
3517
| 17 23
3511 3527
|
<H1>素数 II</H1>
<p>
素数というのは、1 よりも大きくそれ自身か 1 でしか割りきれない整数をいいます。例えば、2 は、2 と 1 でしか割り切れないので素数ですが、12 は、12 と 1 のほかに、2, 3, 4, 6 で割りきれる数なので素数ではありません。
</p>
<p>
整数 <var>n</var> を入力したとき、<var>n</var> より小さい素数のうち最も大きいものと、<var>n</var> より大きい素数のうち最も小さいものを出力するプログラムを作成してください。
</p>
<H2>Input</H2>
<p>
複数のデータセットが与えられます。各データセットに <var>n</var> (3 ≤ <var>n</var> ≤ 50,000) が１行に与えられます。
</p>
<p>
データセットの数は 50 を超えません。
</p>
<H2>Output</H2>
<p>
各データセットに対して、<var>n</var> より小さい素数のうち最大のものと、<var>n</var> より大きい素数のうち最小のものを１つのスペースで区切って１行に出力して下さい。
</p>
<H2>Sample Input</H2>
<pre>
19
3517
</pre>
<H2>Output for the Sample Input</H2>
<pre>
17 23
3511 3527
</pre>
|
s909951695 | p00044 | Accepted | import sys
def primes(m):
N = range(1,m+1,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)
x = [2] + filter(None,N)
return x
PRIMES = primes(50030)
for s in sys.stdin:
n = int(s)
for a in PRIMES:
if a>n: break
elif a<n: b = a
print b,a | 19
3517
| 17 23
3511 3527
|
<H1>素数 II</H1>
<p>
素数というのは、1 よりも大きくそれ自身か 1 でしか割りきれない整数をいいます。例えば、2 は、2 と 1 でしか割り切れないので素数ですが、12 は、12 と 1 のほかに、2, 3, 4, 6 で割りきれる数なので素数ではありません。
</p>
<p>
整数 <var>n</var> を入力したとき、<var>n</var> より小さい素数のうち最も大きいものと、<var>n</var> より大きい素数のうち最も小さいものを出力するプログラムを作成してください。
</p>
<H2>Input</H2>
<p>
複数のデータセットが与えられます。各データセットに <var>n</var> (3 ≤ <var>n</var> ≤ 50,000) が１行に与えられます。
</p>
<p>
データセットの数は 50 を超えません。
</p>
<H2>Output</H2>
<p>
各データセットに対して、<var>n</var> より小さい素数のうち最大のものと、<var>n</var> より大きい素数のうち最小のものを１つのスペースで区切って１行に出力して下さい。
</p>
<H2>Sample Input</H2>
<pre>
19
3517
</pre>
<H2>Output for the Sample Input</H2>
<pre>
17 23
3511 3527
</pre>
|
s441939520 | p00044 | Accepted | import sys
def primes(m):
N = range(1,m+1,2)
r = int(m**.5)
h = len(N)
N[0] = 0
i=0
while 1:
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
x = [2] + filter(None,N)
return x
PRIMES = primes(50030)
for s in sys.stdin:
n = int(s)
for a in PRIMES:
if a>n: break
elif a<n: b = a
print b,a | 19
3517
| 17 23
3511 3527
|
<H1>素数 II</H1>
<p>
素数というのは、1 よりも大きくそれ自身か 1 でしか割りきれない整数をいいます。例えば、2 は、2 と 1 でしか割り切れないので素数ですが、12 は、12 と 1 のほかに、2, 3, 4, 6 で割りきれる数なので素数ではありません。
</p>
<p>
整数 <var>n</var> を入力したとき、<var>n</var> より小さい素数のうち最も大きいものと、<var>n</var> より大きい素数のうち最も小さいものを出力するプログラムを作成してください。
</p>
<H2>Input</H2>
<p>
複数のデータセットが与えられます。各データセットに <var>n</var> (3 ≤ <var>n</var> ≤ 50,000) が１行に与えられます。
</p>
<p>
データセットの数は 50 を超えません。
</p>
<H2>Output</H2>
<p>
各データセットに対して、<var>n</var> より小さい素数のうち最大のものと、<var>n</var> より大きい素数のうち最小のものを１つのスペースで区切って１行に出力して下さい。
</p>
<H2>Sample Input</H2>
<pre>
19
3517
</pre>
<H2>Output for the Sample Input</H2>
<pre>
17 23
3511 3527
</pre>
|
s822216263 | p00044 | Accepted | import sys
def primes(m):
N = range(1,m+1,2)
r = int(m**.5)
h = len(N)
N[0] = 0
i=0
while N[i]<=r:
x = N[i]
if x and i+x<h: N[i+x:h:x] = [0]*((h-1-i-x)/x+1)
i += 1
x = [2] + filter(None,N)
return x
PRIMES = primes(50030)
for s in sys.stdin:
n = int(s)
for a in PRIMES:
if a>n: break
elif a<n: b = a
print b,a | 19
3517
| 17 23
3511 3527
|
<H1>素数 II</H1>
<p>
素数というのは、1 よりも大きくそれ自身か 1 でしか割りきれない整数をいいます。例えば、2 は、2 と 1 でしか割り切れないので素数ですが、12 は、12 と 1 のほかに、2, 3, 4, 6 で割りきれる数なので素数ではありません。
</p>
<p>
整数 <var>n</var> を入力したとき、<var>n</var> より小さい素数のうち最も大きいものと、<var>n</var> より大きい素数のうち最も小さいものを出力するプログラムを作成してください。
</p>
<H2>Input</H2>
<p>
複数のデータセットが与えられます。各データセットに <var>n</var> (3 ≤ <var>n</var> ≤ 50,000) が１行に与えられます。
</p>
<p>
データセットの数は 50 を超えません。
</p>
<H2>Output</H2>
<p>
各データセットに対して、<var>n</var> より小さい素数のうち最大のものと、<var>n</var> より大きい素数のうち最小のものを１つのスペースで区切って１行に出力して下さい。
</p>
<H2>Sample Input</H2>
<pre>
19
3517
</pre>
<H2>Output for the Sample Input</H2>
<pre>
17 23
3511 3527
</pre>
|
s616473967 | p00044 | Accepted | from bisect 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 [v for v in a if v]
try:
a = sieve(90000)
while True:
n = int(raw_input())
i = bisect_right(a, n)
print a[i - (2 if a[i - 1] == n else 1)], a[i]
except EOFError:
pass | 19
3517
| 17 23
3511 3527
|
<H1>素数 II</H1>
<p>
素数というのは、1 よりも大きくそれ自身か 1 でしか割りきれない整数をいいます。例えば、2 は、2 と 1 でしか割り切れないので素数ですが、12 は、12 と 1 のほかに、2, 3, 4, 6 で割りきれる数なので素数ではありません。
</p>
<p>
整数 <var>n</var> を入力したとき、<var>n</var> より小さい素数のうち最も大きいものと、<var>n</var> より大きい素数のうち最も小さいものを出力するプログラムを作成してください。
</p>
<H2>Input</H2>
<p>
複数のデータセットが与えられます。各データセットに <var>n</var> (3 ≤ <var>n</var> ≤ 50,000) が１行に与えられます。
</p>
<p>
データセットの数は 50 を超えません。
</p>
<H2>Output</H2>
<p>
各データセットに対して、<var>n</var> より小さい素数のうち最大のものと、<var>n</var> より大きい素数のうち最小のものを１つのスペースで区切って１行に出力して下さい。
</p>
<H2>Sample Input</H2>
<pre>
19
3517
</pre>
<H2>Output for the Sample Input</H2>
<pre>
17 23
3511 3527
</pre>
|
s797377559 | p00044 | 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]]
while 1:
try:
n = input()
except EOFError:
break
primes = sieve(n * 2)
small, big = -1, -1
for prime in primes:
if prime < n:
small = prime
if prime > n:
big = prime
break
print small, big | 19
3517
| 17 23
3511 3527
|
<H1>素数 II</H1>
<p>
素数というのは、1 よりも大きくそれ自身か 1 でしか割りきれない整数をいいます。例えば、2 は、2 と 1 でしか割り切れないので素数ですが、12 は、12 と 1 のほかに、2, 3, 4, 6 で割りきれる数なので素数ではありません。
</p>
<p>
整数 <var>n</var> を入力したとき、<var>n</var> より小さい素数のうち最も大きいものと、<var>n</var> より大きい素数のうち最も小さいものを出力するプログラムを作成してください。
</p>
<H2>Input</H2>
<p>
複数のデータセットが与えられます。各データセットに <var>n</var> (3 ≤ <var>n</var> ≤ 50,000) が１行に与えられます。
</p>
<p>
データセットの数は 50 を超えません。
</p>
<H2>Output</H2>
<p>
各データセットに対して、<var>n</var> より小さい素数のうち最大のものと、<var>n</var> より大きい素数のうち最小のものを１つのスペースで区切って１行に出力して下さい。
</p>
<H2>Sample Input</H2>
<pre>
19
3517
</pre>
<H2>Output for the Sample Input</H2>
<pre>
17 23
3511 3527
</pre>
|
s934231895 | p00044 | Accepted | N = 50030
a = [True] * N
i = 3
while i * i < N:
for j in range(3 * i, N, 2 * i): a[j] = False
i += 2
while True:
try:
n = int(input())
except:
break
n0 = n + 2 if (n & 1) else n + 1
for maxv in range(n0, N, 2):
if a[maxv]: break
n0 = n - 2 if (n & 1) else n - 1
for minv in range(n0, 2, -2):
if a[minv]: break
else:
minv = 2
print(minv, maxv) | 19
3517
| 17 23
3511 3527
|
<H1>素数 II</H1>
<p>
素数というのは、1 よりも大きくそれ自身か 1 でしか割りきれない整数をいいます。例えば、2 は、2 と 1 でしか割り切れないので素数ですが、12 は、12 と 1 のほかに、2, 3, 4, 6 で割りきれる数なので素数ではありません。
</p>
<p>
整数 <var>n</var> を入力したとき、<var>n</var> より小さい素数のうち最も大きいものと、<var>n</var> より大きい素数のうち最も小さいものを出力するプログラムを作成してください。
</p>
<H2>Input</H2>
<p>
複数のデータセットが与えられます。各データセットに <var>n</var> (3 ≤ <var>n</var> ≤ 50,000) が１行に与えられます。
</p>
<p>
データセットの数は 50 を超えません。
</p>
<H2>Output</H2>
<p>
各データセットに対して、<var>n</var> より小さい素数のうち最大のものと、<var>n</var> より大きい素数のうち最小のものを１つのスペースで区切って１行に出力して下さい。
</p>
<H2>Sample Input</H2>
<pre>
19
3517
</pre>
<H2>Output for the Sample Input</H2>
<pre>
17 23
3511 3527
</pre>
|
s212988961 | p00044 | Accepted | def is_prime(q):
q = abs(q)
if q == 2: return True
if q < 2 or q&1 == 0: return False
return pow(2, q-1, q) == 1
while(True):
try:
a = int(raw_input())
except:
break
b = a
while(True):
b -= 1
if(is_prime(b)):
print b ,
break
while(True):
a+=1
if(is_prime(a)):
print a
break | 19
3517
| 17 23
3511 3527
|
<H1>素数 II</H1>
<p>
素数というのは、1 よりも大きくそれ自身か 1 でしか割りきれない整数をいいます。例えば、2 は、2 と 1 でしか割り切れないので素数ですが、12 は、12 と 1 のほかに、2, 3, 4, 6 で割りきれる数なので素数ではありません。
</p>
<p>
整数 <var>n</var> を入力したとき、<var>n</var> より小さい素数のうち最も大きいものと、<var>n</var> より大きい素数のうち最も小さいものを出力するプログラムを作成してください。
</p>
<H2>Input</H2>
<p>
複数のデータセットが与えられます。各データセットに <var>n</var> (3 ≤ <var>n</var> ≤ 50,000) が１行に与えられます。
</p>
<p>
データセットの数は 50 を超えません。
</p>
<H2>Output</H2>
<p>
各データセットに対して、<var>n</var> より小さい素数のうち最大のものと、<var>n</var> より大きい素数のうち最小のものを１つのスペースで区切って１行に出力して下さい。
</p>
<H2>Sample Input</H2>
<pre>
19
3517
</pre>
<H2>Output for the Sample Input</H2>
<pre>
17 23
3511 3527
</pre>
|
s572239940 | p00044 | Accepted | import math
def prime(x):
for i in range(2, int(math.sqrt(x))+1):
if x%i==0:
return 0
return 1
prime_list = []
for i in range(2,50022):
if prime(i)==1:
prime_list.append(i)
while True:
try:
n = int(input())
except:
break
print(max([x for x in prime_list if x < n]), end=' ')
print(min([x for x in prime_list if x > n]))
| 19
3517
| 17 23
3511 3527
|
<H1>素数 II</H1>
<p>
素数というのは、1 よりも大きくそれ自身か 1 でしか割りきれない整数をいいます。例えば、2 は、2 と 1 でしか割り切れないので素数ですが、12 は、12 と 1 のほかに、2, 3, 4, 6 で割りきれる数なので素数ではありません。
</p>
<p>
整数 <var>n</var> を入力したとき、<var>n</var> より小さい素数のうち最も大きいものと、<var>n</var> より大きい素数のうち最も小さいものを出力するプログラムを作成してください。
</p>
<H2>Input</H2>
<p>
複数のデータセットが与えられます。各データセットに <var>n</var> (3 ≤ <var>n</var> ≤ 50,000) が１行に与えられます。
</p>
<p>
データセットの数は 50 を超えません。
</p>
<H2>Output</H2>
<p>
各データセットに対して、<var>n</var> より小さい素数のうち最大のものと、<var>n</var> より大きい素数のうち最小のものを１つのスペースで区切って１行に出力して下さい。
</p>
<H2>Sample Input</H2>
<pre>
19
3517
</pre>
<H2>Output for the Sample Input</H2>
<pre>
17 23
3511 3527
</pre>
|
s162866198 | p00044 | Accepted | lst = [1]*50021
for i in range(50021):
if i == 0:
lst[i] = 0
else:
if lst[i] == 1:
j = i +1
k = i
while True:
k = k + j
if k >= 50021:
break
lst[k] = 0
while True:
try:
n = int(input())
a = lst[0:n-1]
b = lst[n:]
print((n - 1 - a[::-1].index(1)),(n + 1 + b.index(1)))
except EOFError:
break
| 19
3517
| 17 23
3511 3527
|
<H1>素数 II</H1>
<p>
素数というのは、1 よりも大きくそれ自身か 1 でしか割りきれない整数をいいます。例えば、2 は、2 と 1 でしか割り切れないので素数ですが、12 は、12 と 1 のほかに、2, 3, 4, 6 で割りきれる数なので素数ではありません。
</p>
<p>
整数 <var>n</var> を入力したとき、<var>n</var> より小さい素数のうち最も大きいものと、<var>n</var> より大きい素数のうち最も小さいものを出力するプログラムを作成してください。
</p>
<H2>Input</H2>
<p>
複数のデータセットが与えられます。各データセットに <var>n</var> (3 ≤ <var>n</var> ≤ 50,000) が１行に与えられます。
</p>
<p>
データセットの数は 50 を超えません。
</p>
<H2>Output</H2>
<p>
各データセットに対して、<var>n</var> より小さい素数のうち最大のものと、<var>n</var> より大きい素数のうち最小のものを１つのスペースで区切って１行に出力して下さい。
</p>
<H2>Sample Input</H2>
<pre>
19
3517
</pre>
<H2>Output for the Sample Input</H2>
<pre>
17 23
3511 3527
</pre>
|
s138724717 | p00044 | Accepted | import math
import sys
isPrime=[False, False]
for i in range(2,1000000):
isPrime.append(True)
for i in range(2,int(math.sqrt(1000000))):
if isPrime[i]:
for j in range(i*i, 1000000, i):
isPrime[j]=False
for l in sys.stdin:
f=int(l)
ans=[]
while True:
if isPrime[f-1]:
ans.append(int(f-1))
break
else:
f=f-1
f=int(l)
while True:
if isPrime[f+1]:
ans.append(int(f+1))
break
else:
f=f+1
print("%d %d"%(ans[0],ans[1]))
| 19
3517
| 17 23
3511 3527
|
<H1>素数 II</H1>
<p>
素数というのは、1 よりも大きくそれ自身か 1 でしか割りきれない整数をいいます。例えば、2 は、2 と 1 でしか割り切れないので素数ですが、12 は、12 と 1 のほかに、2, 3, 4, 6 で割りきれる数なので素数ではありません。
</p>
<p>
整数 <var>n</var> を入力したとき、<var>n</var> より小さい素数のうち最も大きいものと、<var>n</var> より大きい素数のうち最も小さいものを出力するプログラムを作成してください。
</p>
<H2>Input</H2>
<p>
複数のデータセットが与えられます。各データセットに <var>n</var> (3 ≤ <var>n</var> ≤ 50,000) が１行に与えられます。
</p>
<p>
データセットの数は 50 を超えません。
</p>
<H2>Output</H2>
<p>
各データセットに対して、<var>n</var> より小さい素数のうち最大のものと、<var>n</var> より大きい素数のうち最小のものを１つのスペースで区切って１行に出力して下さい。
</p>
<H2>Sample Input</H2>
<pre>
19
3517
</pre>
<H2>Output for the Sample Input</H2>
<pre>
17 23
3511 3527
</pre>
|
s091266358 | p00044 | Accepted | is_prime = [False,False]
for i in range(2,1000000):
is_prime.append(True)
for i in range(2,1000000):
if is_prime[i]:
for j in range(i*i,1000000,i):
is_prime[j] = False
while 1:
try:
a = int(0)
b = int(0)
n = int(input())
for i in range(n-1,0,-1):
if is_prime[i]:
a = i
break
for i in range(n+1,50022):
if is_prime[i]:
b = i
break
print("%s %d"%(a,b))
except:
break
| 19
3517
| 17 23
3511 3527
|
<H1>素数 II</H1>
<p>
素数というのは、1 よりも大きくそれ自身か 1 でしか割りきれない整数をいいます。例えば、2 は、2 と 1 でしか割り切れないので素数ですが、12 は、12 と 1 のほかに、2, 3, 4, 6 で割りきれる数なので素数ではありません。
</p>
<p>
整数 <var>n</var> を入力したとき、<var>n</var> より小さい素数のうち最も大きいものと、<var>n</var> より大きい素数のうち最も小さいものを出力するプログラムを作成してください。
</p>
<H2>Input</H2>
<p>
複数のデータセットが与えられます。各データセットに <var>n</var> (3 ≤ <var>n</var> ≤ 50,000) が１行に与えられます。
</p>
<p>
データセットの数は 50 を超えません。
</p>
<H2>Output</H2>
<p>
各データセットに対して、<var>n</var> より小さい素数のうち最大のものと、<var>n</var> より大きい素数のうち最小のものを１つのスペースで区切って１行に出力して下さい。
</p>
<H2>Sample Input</H2>
<pre>
19
3517
</pre>
<H2>Output for the Sample Input</H2>
<pre>
17 23
3511 3527
</pre>
|
s503430978 | p00044 | Accepted | check = [False,False]
for i in range(0,100000):
check.append(True)
for i in range(2,100000):
if(check[i]):
for j in range(i*i,100000,i):
check[j]=False
while True:
try:
x = int(input())
a = b = x
for i in reversed(range(0,x)):
if(check[i]):
a = i
break
while True:
x += 1
if(check[x]):
b = x
break
print("%d %d"%(a,b))
except:
break
| 19
3517
| 17 23
3511 3527
|
<H1>素数 II</H1>
<p>
素数というのは、1 よりも大きくそれ自身か 1 でしか割りきれない整数をいいます。例えば、2 は、2 と 1 でしか割り切れないので素数ですが、12 は、12 と 1 のほかに、2, 3, 4, 6 で割りきれる数なので素数ではありません。
</p>
<p>
整数 <var>n</var> を入力したとき、<var>n</var> より小さい素数のうち最も大きいものと、<var>n</var> より大きい素数のうち最も小さいものを出力するプログラムを作成してください。
</p>
<H2>Input</H2>
<p>
複数のデータセットが与えられます。各データセットに <var>n</var> (3 ≤ <var>n</var> ≤ 50,000) が１行に与えられます。
</p>
<p>
データセットの数は 50 を超えません。
</p>
<H2>Output</H2>
<p>
各データセットに対して、<var>n</var> より小さい素数のうち最大のものと、<var>n</var> より大きい素数のうち最小のものを１つのスペースで区切って１行に出力して下さい。
</p>
<H2>Sample Input</H2>
<pre>
19
3517
</pre>
<H2>Output for the Sample Input</H2>
<pre>
17 23
3511 3527
</pre>
|
s150480287 | p00044 | Accepted | def main():
is_prime = [i for i in range(1000000)]
is_prime[0] = is_prime[1] = False
for i in range(2, 1000000):
is_prime[i] = True
for i in range(2, 1000000):
if i*i >= 1000000:
break
for j in range(i*i, 1000000, i):
is_prime[j] = False
while 1:
try:
ans = [0,0]
n = int(input())
for i in range(2,1000001):
if is_prime[i]:
if i < n:
ans[0] = i
else:
if i != n:
ans[1] = i
break
print('%s %d' % (ans[0],ans[1]))
except:
break
if __name__ == "__main__":
main()
| 19
3517
| 17 23
3511 3527
|
<H1>素数 II</H1>
<p>
素数というのは、1 よりも大きくそれ自身か 1 でしか割りきれない整数をいいます。例えば、2 は、2 と 1 でしか割り切れないので素数ですが、12 は、12 と 1 のほかに、2, 3, 4, 6 で割りきれる数なので素数ではありません。
</p>
<p>
整数 <var>n</var> を入力したとき、<var>n</var> より小さい素数のうち最も大きいものと、<var>n</var> より大きい素数のうち最も小さいものを出力するプログラムを作成してください。
</p>
<H2>Input</H2>
<p>
複数のデータセットが与えられます。各データセットに <var>n</var> (3 ≤ <var>n</var> ≤ 50,000) が１行に与えられます。
</p>
<p>
データセットの数は 50 を超えません。
</p>
<H2>Output</H2>
<p>
各データセットに対して、<var>n</var> より小さい素数のうち最大のものと、<var>n</var> より大きい素数のうち最小のものを１つのスペースで区切って１行に出力して下さい。
</p>
<H2>Sample Input</H2>
<pre>
19
3517
</pre>
<H2>Output for the Sample Input</H2>
<pre>
17 23
3511 3527
</pre>
|
s651414937 | p00044 | Accepted | def main():
is_prime = [i for i in range(1000000)]
is_prime[0] = is_prime[1] = False
for i in range(2, 1000000):
is_prime[i] = True
for i in range(2, 1000000):
if i*i >= 1000000:
break
for j in range(i*i, 1000000, i):
is_prime[j] = False
while 1:
try:
ans = [0,0]
n = int(input())
for i in range(2,1000001):
if is_prime[i]:
if i < n:
ans[0] = i
else:
if i != n:
ans[1] = i
break
print('%s %d' % (ans[0],ans[1]))
except:
break
if __name__ == "__main__":
main()
| 19
3517
| 17 23
3511 3527
|
<H1>素数 II</H1>
<p>
素数というのは、1 よりも大きくそれ自身か 1 でしか割りきれない整数をいいます。例えば、2 は、2 と 1 でしか割り切れないので素数ですが、12 は、12 と 1 のほかに、2, 3, 4, 6 で割りきれる数なので素数ではありません。
</p>
<p>
整数 <var>n</var> を入力したとき、<var>n</var> より小さい素数のうち最も大きいものと、<var>n</var> より大きい素数のうち最も小さいものを出力するプログラムを作成してください。
</p>
<H2>Input</H2>
<p>
複数のデータセットが与えられます。各データセットに <var>n</var> (3 ≤ <var>n</var> ≤ 50,000) が１行に与えられます。
</p>
<p>
データセットの数は 50 を超えません。
</p>
<H2>Output</H2>
<p>
各データセットに対して、<var>n</var> より小さい素数のうち最大のものと、<var>n</var> より大きい素数のうち最小のものを１つのスペースで区切って１行に出力して下さい。
</p>
<H2>Sample Input</H2>
<pre>
19
3517
</pre>
<H2>Output for the Sample Input</H2>
<pre>
17 23
3511 3527
</pre>
|
s140415951 | p00044 | Accepted | import math
isPrime = [True] * 60001
primes = []
def eratos(n):
isPrime[0] = isPrime[1] = False
for i in range(2,int(math.sqrt(n))):
if isPrime[i]:
j = 2 * i
while j <= n:
isPrime[j] = False
j = j + i
for i in range(2,60000):
if isPrime[i]:
primes.append(i)
eratos(60000)
while True:
try:
p = int(input())
min = list(filter(lambda x: x < p,primes))
max = list(filter(lambda x: x > p,primes))
print(min[-1],max[0])
except:
break
| 19
3517
| 17 23
3511 3527
|
<H1>素数 II</H1>
<p>
素数というのは、1 よりも大きくそれ自身か 1 でしか割りきれない整数をいいます。例えば、2 は、2 と 1 でしか割り切れないので素数ですが、12 は、12 と 1 のほかに、2, 3, 4, 6 で割りきれる数なので素数ではありません。
</p>
<p>
整数 <var>n</var> を入力したとき、<var>n</var> より小さい素数のうち最も大きいものと、<var>n</var> より大きい素数のうち最も小さいものを出力するプログラムを作成してください。
</p>
<H2>Input</H2>
<p>
複数のデータセットが与えられます。各データセットに <var>n</var> (3 ≤ <var>n</var> ≤ 50,000) が１行に与えられます。
</p>
<p>
データセットの数は 50 を超えません。
</p>
<H2>Output</H2>
<p>
各データセットに対して、<var>n</var> より小さい素数のうち最大のものと、<var>n</var> より大きい素数のうち最小のものを１つのスペースで区切って１行に出力して下さい。
</p>
<H2>Sample Input</H2>
<pre>
19
3517
</pre>
<H2>Output for the Sample Input</H2>
<pre>
17 23
3511 3527
</pre>
|
s531189954 | p00044 | Accepted | import math
def first_try(num):
list=[2,3,5,7,11,13,17,19,23,29,31,37,41,43,47,53,59,61,67]
i=0
tmp=int(math.sqrt(num))
while True:
if num in list:
return True
#その数を超えたら終了
if list[i]>tmp or i==len(list)-1:
return True
if (num%list[i]==0):
return False
i+=1
while True:
try:
num=int(input())
except:
break
#小さいの
s=0
while True:
s+=1
if first_try(num-s)==True:
print(num-s,end=" ")
break
#大きいの
l=0
while True:
l+=1
if first_try(num+l)==True:
print(num+l)
break
| 19
3517
| 17 23
3511 3527
|
<H1>素数 II</H1>
<p>
素数というのは、1 よりも大きくそれ自身か 1 でしか割りきれない整数をいいます。例えば、2 は、2 と 1 でしか割り切れないので素数ですが、12 は、12 と 1 のほかに、2, 3, 4, 6 で割りきれる数なので素数ではありません。
</p>
<p>
整数 <var>n</var> を入力したとき、<var>n</var> より小さい素数のうち最も大きいものと、<var>n</var> より大きい素数のうち最も小さいものを出力するプログラムを作成してください。
</p>
<H2>Input</H2>
<p>
複数のデータセットが与えられます。各データセットに <var>n</var> (3 ≤ <var>n</var> ≤ 50,000) が１行に与えられます。
</p>
<p>
データセットの数は 50 を超えません。
</p>
<H2>Output</H2>
<p>
各データセットに対して、<var>n</var> より小さい素数のうち最大のものと、<var>n</var> より大きい素数のうち最小のものを１つのスペースで区切って１行に出力して下さい。
</p>
<H2>Sample Input</H2>
<pre>
19
3517
</pre>
<H2>Output for the Sample Input</H2>
<pre>
17 23
3511 3527
</pre>
|
s128444169 | p00044 | Accepted | import bisect
L = [True] * 60000
L[0] = L[1] = False
for i in range(2,int(60000**0.5)+1):
if not L[i]:
continue
for j in range(i*2,60000, i):
L[j] = False
p = [x for x in range(60000) if L[x]]
#print(" ".join(map(str,p)))
while True:
try:
n = int(input())
except EOFError:
break
k = bisect.bisect_left(p,n)
a = p[k-1]
if p[k] == n:
b = p[k+1]
else:
b = p[k]
print(a,b)
| 19
3517
| 17 23
3511 3527
|
<H1>素数 II</H1>
<p>
素数というのは、1 よりも大きくそれ自身か 1 でしか割りきれない整数をいいます。例えば、2 は、2 と 1 でしか割り切れないので素数ですが、12 は、12 と 1 のほかに、2, 3, 4, 6 で割りきれる数なので素数ではありません。
</p>
<p>
整数 <var>n</var> を入力したとき、<var>n</var> より小さい素数のうち最も大きいものと、<var>n</var> より大きい素数のうち最も小さいものを出力するプログラムを作成してください。
</p>
<H2>Input</H2>
<p>
複数のデータセットが与えられます。各データセットに <var>n</var> (3 ≤ <var>n</var> ≤ 50,000) が１行に与えられます。
</p>
<p>
データセットの数は 50 を超えません。
</p>
<H2>Output</H2>
<p>
各データセットに対して、<var>n</var> より小さい素数のうち最大のものと、<var>n</var> より大きい素数のうち最小のものを１つのスペースで区切って１行に出力して下さい。
</p>
<H2>Sample Input</H2>
<pre>
19
3517
</pre>
<H2>Output for the Sample Input</H2>
<pre>
17 23
3511 3527
</pre>
|
s758454959 | p00044 | Accepted | l = [2]
for i in range(3, 60000):
flag = True
for j in l:
if i % j == 0:
flag = False
break
if flag:
l.append(i)
while True:
try:
n = int(input())
except:
break
a = b = 0
for k in range(1, n):
if n -k in l:
a = n-k
break
for kk in range(1, 10000):
if n+kk in l:
b=n+kk
break
print(a,b)
| 19
3517
| 17 23
3511 3527
|
<H1>素数 II</H1>
<p>
素数というのは、1 よりも大きくそれ自身か 1 でしか割りきれない整数をいいます。例えば、2 は、2 と 1 でしか割り切れないので素数ですが、12 は、12 と 1 のほかに、2, 3, 4, 6 で割りきれる数なので素数ではありません。
</p>
<p>
整数 <var>n</var> を入力したとき、<var>n</var> より小さい素数のうち最も大きいものと、<var>n</var> より大きい素数のうち最も小さいものを出力するプログラムを作成してください。
</p>
<H2>Input</H2>
<p>
複数のデータセットが与えられます。各データセットに <var>n</var> (3 ≤ <var>n</var> ≤ 50,000) が１行に与えられます。
</p>
<p>
データセットの数は 50 を超えません。
</p>
<H2>Output</H2>
<p>
各データセットに対して、<var>n</var> より小さい素数のうち最大のものと、<var>n</var> より大きい素数のうち最小のものを１つのスペースで区切って１行に出力して下さい。
</p>
<H2>Sample Input</H2>
<pre>
19
3517
</pre>
<H2>Output for the Sample Input</H2>
<pre>
17 23
3511 3527
</pre>
|
s472782379 | p00044 | Accepted | p = [1] * (100000 + 1)
p[0], p[1] = 0, 0
for i in range(2, int(100000 ** 0.5) + 1):
if not p[i]:
continue
for j in range(2 * i, 100000 + 1, i):
p[j] = 0
while 1:
try:
n = int(input())
bp, ap = 0, 0
for i in range(n)[::-1]:
if p[i] == 1:
bp = i
break
for i in range(n+1, 2 * n + 1):
if p[i] == 1:
ap = i
break
print(bp, ap)
except:
break
| 19
3517
| 17 23
3511 3527
|
<H1>素数 II</H1>
<p>
素数というのは、1 よりも大きくそれ自身か 1 でしか割りきれない整数をいいます。例えば、2 は、2 と 1 でしか割り切れないので素数ですが、12 は、12 と 1 のほかに、2, 3, 4, 6 で割りきれる数なので素数ではありません。
</p>
<p>
整数 <var>n</var> を入力したとき、<var>n</var> より小さい素数のうち最も大きいものと、<var>n</var> より大きい素数のうち最も小さいものを出力するプログラムを作成してください。
</p>
<H2>Input</H2>
<p>
複数のデータセットが与えられます。各データセットに <var>n</var> (3 ≤ <var>n</var> ≤ 50,000) が１行に与えられます。
</p>
<p>
データセットの数は 50 を超えません。
</p>
<H2>Output</H2>
<p>
各データセットに対して、<var>n</var> より小さい素数のうち最大のものと、<var>n</var> より大きい素数のうち最小のものを１つのスペースで区切って１行に出力して下さい。
</p>
<H2>Sample Input</H2>
<pre>
19
3517
</pre>
<H2>Output for the Sample Input</H2>
<pre>
17 23
3511 3527
</pre>
|
s672345515 | p00044 | Accepted | N = 50050
a = [True] * N
i = 3
while i * i < N:
for j in range(3 * i, N, 2 * i): a[j] = False
i += 2
while True:
try:
n = int(input())
except:
break
n0 = n + 2 if (n & 1) else n + 1
for max in range(n0, N, 2):
if a[max]: break
n0 = n - 2 if (n & 1) else n - 1
for min in range(n0, 2, -2):
if a[min]: break
else:
min = 2
print(min, max)
| 19
3517
| 17 23
3511 3527
|
<H1>素数 II</H1>
<p>
素数というのは、1 よりも大きくそれ自身か 1 でしか割りきれない整数をいいます。例えば、2 は、2 と 1 でしか割り切れないので素数ですが、12 は、12 と 1 のほかに、2, 3, 4, 6 で割りきれる数なので素数ではありません。
</p>
<p>
整数 <var>n</var> を入力したとき、<var>n</var> より小さい素数のうち最も大きいものと、<var>n</var> より大きい素数のうち最も小さいものを出力するプログラムを作成してください。
</p>
<H2>Input</H2>
<p>
複数のデータセットが与えられます。各データセットに <var>n</var> (3 ≤ <var>n</var> ≤ 50,000) が１行に与えられます。
</p>
<p>
データセットの数は 50 を超えません。
</p>
<H2>Output</H2>
<p>
各データセットに対して、<var>n</var> より小さい素数のうち最大のものと、<var>n</var> より大きい素数のうち最小のものを１つのスペースで区切って１行に出力して下さい。
</p>
<H2>Sample Input</H2>
<pre>
19
3517
</pre>
<H2>Output for the Sample Input</H2>
<pre>
17 23
3511 3527
</pre>
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.