s_id stringlengths 10 10 | p_id stringlengths 6 6 | u_id stringlengths 10 10 | date stringlengths 10 10 | language stringclasses 1 value | original_language stringclasses 11 values | filename_ext stringclasses 1 value | status stringclasses 1 value | cpu_time int64 0 100 | memory stringlengths 4 6 | code_size int64 15 14.7k | code stringlengths 15 14.7k | problem_id stringlengths 6 6 | problem_description stringlengths 358 9.83k | input stringlengths 2 4.87k | output stringclasses 807 values | __index_level_0__ int64 1.1k 1.22M |
|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
s439615127 | p00040 | u567380442 | 1423296555 | Python | Python3 | py | Accepted | 30 | 6776 | 1,207 | import sys
f = sys.stdin
import string
OFFSET = ord('a')
def to_gamma(c):
return ord(c) - OFFSET
def from_gamma(gamma, alpha, beta):
return chr((alpha * gamma + beta) % 26 + OFFSET)
def affine(c, alpha, beta):
return from_gamma(to_gamma(c), alpha, beta)
# g[0]==g[3]である前提
def search_that(w):
b = to_gamma(w[2])
for a in range(26):
if w[0] == affine('t',a,b) and w[1] == affine('h',a,b):
return a, b
return -1, -1
def search_this(w):
a = (to_gamma(w[0]) - to_gamma(w[3]) + 26) % 26
for b in range(26):
if w[0] == affine('t',a,b) and w[1] == affine('h',a,b) and w[2] == affine('i',a,b) and w[3] == affine('s',a,b):
return a, b
return -1, -1
def search(w):
if w[0] == w[3]:
return search_that(w)
else:
return search_this(w)
n = int(f.readline())
for i in range(n):
line = f.readline().strip()
words = [word for word in line.split() if len(word) == 4]
for word in words:
a, b = search(word)
if a != -1:
print(line.translate(str.maketrans(''.join([affine(c, a, b) for c in string.ascii_lowercase]), string.ascii_lowercase)))
break
| p00040 |
<script type="text/x-mathjax-config">
MathJax.Hub.Config({ tex2jax: { inlineMath: [["$","$"], ["\\(","\\)"]], processEscapes: true }});
</script>
<script type="text/javascript" src="https://cdn.mathjax.org/mathjax/latest/MathJax.js?config=TeX-MML-AM_CHTML">
</script>
<H1>アフィン暗号</H1>
<p>
簡単な暗号法の一つに、アフィン暗号というものがあります。まず、アルファベット a〜z を a = 0, b = 1, c = 2,..., x = 23, y = 24, z = 25 と 0〜25 の数字に置き換えます。そして、以下の式で、原文のアルファベットを置換します。
</p>
<center>
<!--
<p>
F(γ) = (α・γ＋β) mod 26
</p>
-->
<p>
$F(\gamma) = (\alpha \cdot \gamma + \beta)$ mod $26$
</p>
</center>
<p>
ただし、mod 26 は 26 で割った余りを表します。例えば、$\alpha = 3, \beta = 2$ のとき、アルファベットの 'a' (=0) は、$F(0) = (3 \cdot 0 + 2)$ mod $26 = 2$ で 'c' に、アルファベットの 'n' (=13) は $F(13) = (3 \cdot 13 + 2)$ mod $26 = 15$ で 'p' に置換されます。
このとき、$\gamma$ に対する $F(\gamma)$ が必ず 1 対 1 で対応付けられるように、$\alpha$ と $\beta$ は慎重に選ばれているものとします（$\alpha$ と 26 が互いに素であることが条件）。$\alpha = 4, \beta = 7$ のときのように、$F('a') = 7, F('n') = 7$ と、'a' も 'n' も同じ 'h' に置換されるようなことはありません。また、アルファベット以外の文字は置換されません。
</p>
<p>
暗号化された文字列を元の文章に復号したものを出力するプログラムを作成してください。元の文章には、キーワードとして
</p>
<pre>
that
this
</pre>
<p>
のいずれかが必ず含まれているものとします。
</p>
<H2>Input</H2>
<p>
複数のデータセットが与えられます。１行目にデータセット数 $n$ ($n \leq 30$) が与えられます。続いて $n$ 行のデータが与えられます。各データセットに英小文字と空白からなる 256 文字以内の暗号化された文章が１行に与えられます。
</p>
<H2>Output</H2>
<p>
各データセットに対して、復号した元の文章を１行に出力して下さい。
</p>
<H2>Sample Input</H2>
<pre>
1
y eazqyp pnop pngtg ye obmpngt xmybp mr lygw
</pre>
<H2>Output for the Sample Input</H2>
<pre>
i submit that there is another point of view
</pre>
| 1
y eazqyp pnop pngtg ye obmpngt xmybp mr lygw
| i submit that there is another point of view
| 9,602 |
s079717741 | p00040 | u379956761 | 1443366753 | Python | Python3 | py | Accepted | 40 | 7672 | 893 | def affine(x, a, b):
result = []
for i in range(len(x)):
c = chr((a * (ord(x[i])-97) + b) % 26 + 97)
result.append(c)
return ''.join(result)
def decode_key(a, b):
key = "abcdefghijklmnopqrstuvwxyz"
result = []
for i in range(len(key)):
result.append(affine(key[i], a, b))
return ''.join(result)
a = [1, 3, 5, 7, 9, 11, 15, 17, 19, 21, 23, 25]
n = int(input())
for i in range(n):
ai = 0
b = 0
line = input()
words = line.split()
for i in range(26):
for j in range(len(a)):
if affine('that', a[j], i) in words:
ai = j
b = i
if affine('this', a[j], i) in words:
ai = j
b = i
if ai and b:
break
line = line.translate(str.maketrans(decode_key(a[ai], b), "abcdefghijklmnopqrstuvwxyz"))
print(line) | p00040 |
<script type="text/x-mathjax-config">
MathJax.Hub.Config({ tex2jax: { inlineMath: [["$","$"], ["\\(","\\)"]], processEscapes: true }});
</script>
<script type="text/javascript" src="https://cdn.mathjax.org/mathjax/latest/MathJax.js?config=TeX-MML-AM_CHTML">
</script>
<H1>アフィン暗号</H1>
<p>
簡単な暗号法の一つに、アフィン暗号というものがあります。まず、アルファベット a〜z を a = 0, b = 1, c = 2,..., x = 23, y = 24, z = 25 と 0〜25 の数字に置き換えます。そして、以下の式で、原文のアルファベットを置換します。
</p>
<center>
<!--
<p>
F(γ) = (α・γ＋β) mod 26
</p>
-->
<p>
$F(\gamma) = (\alpha \cdot \gamma + \beta)$ mod $26$
</p>
</center>
<p>
ただし、mod 26 は 26 で割った余りを表します。例えば、$\alpha = 3, \beta = 2$ のとき、アルファベットの 'a' (=0) は、$F(0) = (3 \cdot 0 + 2)$ mod $26 = 2$ で 'c' に、アルファベットの 'n' (=13) は $F(13) = (3 \cdot 13 + 2)$ mod $26 = 15$ で 'p' に置換されます。
このとき、$\gamma$ に対する $F(\gamma)$ が必ず 1 対 1 で対応付けられるように、$\alpha$ と $\beta$ は慎重に選ばれているものとします（$\alpha$ と 26 が互いに素であることが条件）。$\alpha = 4, \beta = 7$ のときのように、$F('a') = 7, F('n') = 7$ と、'a' も 'n' も同じ 'h' に置換されるようなことはありません。また、アルファベット以外の文字は置換されません。
</p>
<p>
暗号化された文字列を元の文章に復号したものを出力するプログラムを作成してください。元の文章には、キーワードとして
</p>
<pre>
that
this
</pre>
<p>
のいずれかが必ず含まれているものとします。
</p>
<H2>Input</H2>
<p>
複数のデータセットが与えられます。１行目にデータセット数 $n$ ($n \leq 30$) が与えられます。続いて $n$ 行のデータが与えられます。各データセットに英小文字と空白からなる 256 文字以内の暗号化された文章が１行に与えられます。
</p>
<H2>Output</H2>
<p>
各データセットに対して、復号した元の文章を１行に出力して下さい。
</p>
<H2>Sample Input</H2>
<pre>
1
y eazqyp pnop pngtg ye obmpngt xmybp mr lygw
</pre>
<H2>Output for the Sample Input</H2>
<pre>
i submit that there is another point of view
</pre>
| 1
y eazqyp pnop pngtg ye obmpngt xmybp mr lygw
| i submit that there is another point of view
| 9,603 |
s932140627 | p00040 | u797673668 | 1456652209 | Python | Python3 | py | Accepted | 40 | 8264 | 986 | from string import ascii_lowercase
def ex_gcd(a, b, y0=0, y1=1):
s, r = a // b, a % b
return ex_gcd(b, r, y1, y0 - s * y1) if r else y1
def decrypt(c, a_rev, b):
return chr(a_rev * (ord(c) - 97 - b) % 26 + 97) if c in ascii_lowercase else c
decrypt_that = {}
decrypt_this = {}
for a in (1, 3, 5, 7, 9, 11, 15, 17, 19, 21, 23, 25):
for b in range(26):
_t, _h, _a, _i, _s = map(lambda c: chr((a * c + b) % 26 + 97), (19, 7, 0, 8, 18))
decrypt_that[''.join((_t, _h, _a, _t))] = (a, b)
decrypt_this[''.join((_t, _h, _i, _s))] = (a, b)
n = int(input())
while n:
line = input()
word4 = {w for w in line.split() if len(w) == 4}
a, b = 0, 0
for word in word4:
if word in decrypt_that:
a, b = decrypt_that[word]
break
if word in decrypt_this:
a, b = decrypt_this[word]
break
a_rev = ex_gcd(26, a)
print(''.join(decrypt(c, a_rev, b) for c in line))
n -= 1 | p00040 |
<script type="text/x-mathjax-config">
MathJax.Hub.Config({ tex2jax: { inlineMath: [["$","$"], ["\\(","\\)"]], processEscapes: true }});
</script>
<script type="text/javascript" src="https://cdn.mathjax.org/mathjax/latest/MathJax.js?config=TeX-MML-AM_CHTML">
</script>
<H1>アフィン暗号</H1>
<p>
簡単な暗号法の一つに、アフィン暗号というものがあります。まず、アルファベット a〜z を a = 0, b = 1, c = 2,..., x = 23, y = 24, z = 25 と 0〜25 の数字に置き換えます。そして、以下の式で、原文のアルファベットを置換します。
</p>
<center>
<!--
<p>
F(γ) = (α・γ＋β) mod 26
</p>
-->
<p>
$F(\gamma) = (\alpha \cdot \gamma + \beta)$ mod $26$
</p>
</center>
<p>
ただし、mod 26 は 26 で割った余りを表します。例えば、$\alpha = 3, \beta = 2$ のとき、アルファベットの 'a' (=0) は、$F(0) = (3 \cdot 0 + 2)$ mod $26 = 2$ で 'c' に、アルファベットの 'n' (=13) は $F(13) = (3 \cdot 13 + 2)$ mod $26 = 15$ で 'p' に置換されます。
このとき、$\gamma$ に対する $F(\gamma)$ が必ず 1 対 1 で対応付けられるように、$\alpha$ と $\beta$ は慎重に選ばれているものとします（$\alpha$ と 26 が互いに素であることが条件）。$\alpha = 4, \beta = 7$ のときのように、$F('a') = 7, F('n') = 7$ と、'a' も 'n' も同じ 'h' に置換されるようなことはありません。また、アルファベット以外の文字は置換されません。
</p>
<p>
暗号化された文字列を元の文章に復号したものを出力するプログラムを作成してください。元の文章には、キーワードとして
</p>
<pre>
that
this
</pre>
<p>
のいずれかが必ず含まれているものとします。
</p>
<H2>Input</H2>
<p>
複数のデータセットが与えられます。１行目にデータセット数 $n$ ($n \leq 30$) が与えられます。続いて $n$ 行のデータが与えられます。各データセットに英小文字と空白からなる 256 文字以内の暗号化された文章が１行に与えられます。
</p>
<H2>Output</H2>
<p>
各データセットに対して、復号した元の文章を１行に出力して下さい。
</p>
<H2>Sample Input</H2>
<pre>
1
y eazqyp pnop pngtg ye obmpngt xmybp mr lygw
</pre>
<H2>Output for the Sample Input</H2>
<pre>
i submit that there is another point of view
</pre>
| 1
y eazqyp pnop pngtg ye obmpngt xmybp mr lygw
| i submit that there is another point of view
| 9,604 |
s596222047 | p00040 | u462831976 | 1492976887 | Python | Python3 | py | Accepted | 60 | 7820 | 831 | # -*- coding: utf-8 -*-
import sys
import os
import math
N = int(input())
alphabet = 'abcdefghijklmnopqrstuvwxyz'
def encode(s, alpha, beta):
t = []
for c in s:
if c == ' ':
t.append(c)
else:
gamma = ord(c) - 97
v = (alpha * gamma + beta) % 26
w = alphabet[v]
t.append(w)
return ''.join(t)
for i in range(N):
s = input().strip()
for a in range(0, 26):
for b in range(0, 26):
encoded_this = encode('this', a, b)
encoded_that = encode('that', a, b)
if encoded_this in s or encoded_that in s:
encoded_alphabet = encode(alphabet, a, b)
table = str.maketrans(encoded_alphabet, alphabet)
dst = s.translate(table)
print(dst) | p00040 |
<script type="text/x-mathjax-config">
MathJax.Hub.Config({ tex2jax: { inlineMath: [["$","$"], ["\\(","\\)"]], processEscapes: true }});
</script>
<script type="text/javascript" src="https://cdn.mathjax.org/mathjax/latest/MathJax.js?config=TeX-MML-AM_CHTML">
</script>
<H1>アフィン暗号</H1>
<p>
簡単な暗号法の一つに、アフィン暗号というものがあります。まず、アルファベット a〜z を a = 0, b = 1, c = 2,..., x = 23, y = 24, z = 25 と 0〜25 の数字に置き換えます。そして、以下の式で、原文のアルファベットを置換します。
</p>
<center>
<!--
<p>
F(γ) = (α・γ＋β) mod 26
</p>
-->
<p>
$F(\gamma) = (\alpha \cdot \gamma + \beta)$ mod $26$
</p>
</center>
<p>
ただし、mod 26 は 26 で割った余りを表します。例えば、$\alpha = 3, \beta = 2$ のとき、アルファベットの 'a' (=0) は、$F(0) = (3 \cdot 0 + 2)$ mod $26 = 2$ で 'c' に、アルファベットの 'n' (=13) は $F(13) = (3 \cdot 13 + 2)$ mod $26 = 15$ で 'p' に置換されます。
このとき、$\gamma$ に対する $F(\gamma)$ が必ず 1 対 1 で対応付けられるように、$\alpha$ と $\beta$ は慎重に選ばれているものとします（$\alpha$ と 26 が互いに素であることが条件）。$\alpha = 4, \beta = 7$ のときのように、$F('a') = 7, F('n') = 7$ と、'a' も 'n' も同じ 'h' に置換されるようなことはありません。また、アルファベット以外の文字は置換されません。
</p>
<p>
暗号化された文字列を元の文章に復号したものを出力するプログラムを作成してください。元の文章には、キーワードとして
</p>
<pre>
that
this
</pre>
<p>
のいずれかが必ず含まれているものとします。
</p>
<H2>Input</H2>
<p>
複数のデータセットが与えられます。１行目にデータセット数 $n$ ($n \leq 30$) が与えられます。続いて $n$ 行のデータが与えられます。各データセットに英小文字と空白からなる 256 文字以内の暗号化された文章が１行に与えられます。
</p>
<H2>Output</H2>
<p>
各データセットに対して、復号した元の文章を１行に出力して下さい。
</p>
<H2>Sample Input</H2>
<pre>
1
y eazqyp pnop pngtg ye obmpngt xmybp mr lygw
</pre>
<H2>Output for the Sample Input</H2>
<pre>
i submit that there is another point of view
</pre>
| 1
y eazqyp pnop pngtg ye obmpngt xmybp mr lygw
| i submit that there is another point of view
| 9,605 |
s959440977 | p00040 | u266872031 | 1500299710 | Python | Python | py | Accepted | 70 | 6416 | 975 | import string
n=int(raw_input())
def decrypt(w,a,b):
ret=[]
for i in w:
ret.append( (i*a+b)%26 )
return ret
for i in range(n):
inp=[[string.ascii_lowercase.index(c) for c in word] for word in raw_input().split()]
#that
that=[string.ascii_lowercase.index(c) for c in 'that']
#this
this=[string.ascii_lowercase.index(c) for c in 'this']
a=0
b=0
bkf=0
for word in inp:
if len(word)==4:
for i in range(26):
for j in range(26):
dew=decrypt(word,i,j)
if dew==that or dew==this:
a=i
b=j
bkf=1
break
if bkf:
break
if bkf:
break
A=[]
for word in inp:
dw=decrypt(word,a,b)
cdw=''.join([string.ascii_lowercase[w] for w in dw])
A.append(cdw)
print ' '.join(A) | p00040 |
<script type="text/x-mathjax-config">
MathJax.Hub.Config({ tex2jax: { inlineMath: [["$","$"], ["\\(","\\)"]], processEscapes: true }});
</script>
<script type="text/javascript" src="https://cdn.mathjax.org/mathjax/latest/MathJax.js?config=TeX-MML-AM_CHTML">
</script>
<H1>アフィン暗号</H1>
<p>
簡単な暗号法の一つに、アフィン暗号というものがあります。まず、アルファベット a〜z を a = 0, b = 1, c = 2,..., x = 23, y = 24, z = 25 と 0〜25 の数字に置き換えます。そして、以下の式で、原文のアルファベットを置換します。
</p>
<center>
<!--
<p>
F(γ) = (α・γ＋β) mod 26
</p>
-->
<p>
$F(\gamma) = (\alpha \cdot \gamma + \beta)$ mod $26$
</p>
</center>
<p>
ただし、mod 26 は 26 で割った余りを表します。例えば、$\alpha = 3, \beta = 2$ のとき、アルファベットの 'a' (=0) は、$F(0) = (3 \cdot 0 + 2)$ mod $26 = 2$ で 'c' に、アルファベットの 'n' (=13) は $F(13) = (3 \cdot 13 + 2)$ mod $26 = 15$ で 'p' に置換されます。
このとき、$\gamma$ に対する $F(\gamma)$ が必ず 1 対 1 で対応付けられるように、$\alpha$ と $\beta$ は慎重に選ばれているものとします（$\alpha$ と 26 が互いに素であることが条件）。$\alpha = 4, \beta = 7$ のときのように、$F('a') = 7, F('n') = 7$ と、'a' も 'n' も同じ 'h' に置換されるようなことはありません。また、アルファベット以外の文字は置換されません。
</p>
<p>
暗号化された文字列を元の文章に復号したものを出力するプログラムを作成してください。元の文章には、キーワードとして
</p>
<pre>
that
this
</pre>
<p>
のいずれかが必ず含まれているものとします。
</p>
<H2>Input</H2>
<p>
複数のデータセットが与えられます。１行目にデータセット数 $n$ ($n \leq 30$) が与えられます。続いて $n$ 行のデータが与えられます。各データセットに英小文字と空白からなる 256 文字以内の暗号化された文章が１行に与えられます。
</p>
<H2>Output</H2>
<p>
各データセットに対して、復号した元の文章を１行に出力して下さい。
</p>
<H2>Sample Input</H2>
<pre>
1
y eazqyp pnop pngtg ye obmpngt xmybp mr lygw
</pre>
<H2>Output for the Sample Input</H2>
<pre>
i submit that there is another point of view
</pre>
| 1
y eazqyp pnop pngtg ye obmpngt xmybp mr lygw
| i submit that there is another point of view
| 9,606 |
s595325424 | p00040 | u043254318 | 1518109305 | Python | Python3 | py | Accepted | 60 | 5624 | 1,223 | def F(alpha, beta, c):
gamma = ord(c) - ord("a")
return chr((alpha*gamma + beta) % 26 + ord("a"))
alphalist = [1,3,5,7,9,11,15,17,19,21,23,25]
N = int(input())
for lines in range(N):
S = input()
words = S.split()
keyA = -1
keyB = -1
for i in range(len(words)):
if len(words[i]) == 4:
w = words[i]
for k in range(len(alphalist)):
for l in range(26):
alpha = alphalist[k]
beta = l
if F(alpha,beta,w[0]) == "t" and F(alpha,beta,w[1]) == "h":
if F(alpha,beta,w[2]) == "a" and F(alpha,beta,w[3]) == "t":
keyA = alpha
keyB = beta
elif F(alpha,beta,w[2]) == "i" and F(alpha,beta,w[3]) == "s":
keyA = alpha
keyB = beta
if keyA > 0:
break
if keyB > 0:
break
if keyA > 0:
break
for i in range(len(S)):
if S[i] == " ":
print(" ", end="")
else:
print(F(keyA,keyB,S[i]), end="")
print("")
| p00040 |
<script type="text/x-mathjax-config">
MathJax.Hub.Config({ tex2jax: { inlineMath: [["$","$"], ["\\(","\\)"]], processEscapes: true }});
</script>
<script type="text/javascript" src="https://cdn.mathjax.org/mathjax/latest/MathJax.js?config=TeX-MML-AM_CHTML">
</script>
<H1>アフィン暗号</H1>
<p>
簡単な暗号法の一つに、アフィン暗号というものがあります。まず、アルファベット a〜z を a = 0, b = 1, c = 2,..., x = 23, y = 24, z = 25 と 0〜25 の数字に置き換えます。そして、以下の式で、原文のアルファベットを置換します。
</p>
<center>
<!--
<p>
F(γ) = (α・γ＋β) mod 26
</p>
-->
<p>
$F(\gamma) = (\alpha \cdot \gamma + \beta)$ mod $26$
</p>
</center>
<p>
ただし、mod 26 は 26 で割った余りを表します。例えば、$\alpha = 3, \beta = 2$ のとき、アルファベットの 'a' (=0) は、$F(0) = (3 \cdot 0 + 2)$ mod $26 = 2$ で 'c' に、アルファベットの 'n' (=13) は $F(13) = (3 \cdot 13 + 2)$ mod $26 = 15$ で 'p' に置換されます。
このとき、$\gamma$ に対する $F(\gamma)$ が必ず 1 対 1 で対応付けられるように、$\alpha$ と $\beta$ は慎重に選ばれているものとします（$\alpha$ と 26 が互いに素であることが条件）。$\alpha = 4, \beta = 7$ のときのように、$F('a') = 7, F('n') = 7$ と、'a' も 'n' も同じ 'h' に置換されるようなことはありません。また、アルファベット以外の文字は置換されません。
</p>
<p>
暗号化された文字列を元の文章に復号したものを出力するプログラムを作成してください。元の文章には、キーワードとして
</p>
<pre>
that
this
</pre>
<p>
のいずれかが必ず含まれているものとします。
</p>
<H2>Input</H2>
<p>
複数のデータセットが与えられます。１行目にデータセット数 $n$ ($n \leq 30$) が与えられます。続いて $n$ 行のデータが与えられます。各データセットに英小文字と空白からなる 256 文字以内の暗号化された文章が１行に与えられます。
</p>
<H2>Output</H2>
<p>
各データセットに対して、復号した元の文章を１行に出力して下さい。
</p>
<H2>Sample Input</H2>
<pre>
1
y eazqyp pnop pngtg ye obmpngt xmybp mr lygw
</pre>
<H2>Output for the Sample Input</H2>
<pre>
i submit that there is another point of view
</pre>
| 1
y eazqyp pnop pngtg ye obmpngt xmybp mr lygw
| i submit that there is another point of view
| 9,607 |
s990126150 | p00040 | u150984829 | 1518159433 | Python | Python3 | py | Accepted | 30 | 5600 | 409 | z='abcdefghijklmnopqrstuvwxyz'
e=lambda x,i,j:z[(z.index(x)*i+j)%26]
def f():
for i in range(1,26,2):
for j in range(26):
if''.join(e(c,i,j)for c in'that')in s or''.join(e(c,i,j)for c in'this')in s:return(i,j)
def g(x,y,s=0,t=1):
q,r=x//y,x%y
return g(y,r,t,s-q*t) if r else t
for _ in[0]*int(input()):
s=input()
a,b=f()
h=g(26,a)
print(''.join(z[h*(z.index(c)-b)%26]if c in z else c for c in s))
| p00040 |
<script type="text/x-mathjax-config">
MathJax.Hub.Config({ tex2jax: { inlineMath: [["$","$"], ["\\(","\\)"]], processEscapes: true }});
</script>
<script type="text/javascript" src="https://cdn.mathjax.org/mathjax/latest/MathJax.js?config=TeX-MML-AM_CHTML">
</script>
<H1>アフィン暗号</H1>
<p>
簡単な暗号法の一つに、アフィン暗号というものがあります。まず、アルファベット a〜z を a = 0, b = 1, c = 2,..., x = 23, y = 24, z = 25 と 0〜25 の数字に置き換えます。そして、以下の式で、原文のアルファベットを置換します。
</p>
<center>
<!--
<p>
F(γ) = (α・γ＋β) mod 26
</p>
-->
<p>
$F(\gamma) = (\alpha \cdot \gamma + \beta)$ mod $26$
</p>
</center>
<p>
ただし、mod 26 は 26 で割った余りを表します。例えば、$\alpha = 3, \beta = 2$ のとき、アルファベットの 'a' (=0) は、$F(0) = (3 \cdot 0 + 2)$ mod $26 = 2$ で 'c' に、アルファベットの 'n' (=13) は $F(13) = (3 \cdot 13 + 2)$ mod $26 = 15$ で 'p' に置換されます。
このとき、$\gamma$ に対する $F(\gamma)$ が必ず 1 対 1 で対応付けられるように、$\alpha$ と $\beta$ は慎重に選ばれているものとします（$\alpha$ と 26 が互いに素であることが条件）。$\alpha = 4, \beta = 7$ のときのように、$F('a') = 7, F('n') = 7$ と、'a' も 'n' も同じ 'h' に置換されるようなことはありません。また、アルファベット以外の文字は置換されません。
</p>
<p>
暗号化された文字列を元の文章に復号したものを出力するプログラムを作成してください。元の文章には、キーワードとして
</p>
<pre>
that
this
</pre>
<p>
のいずれかが必ず含まれているものとします。
</p>
<H2>Input</H2>
<p>
複数のデータセットが与えられます。１行目にデータセット数 $n$ ($n \leq 30$) が与えられます。続いて $n$ 行のデータが与えられます。各データセットに英小文字と空白からなる 256 文字以内の暗号化された文章が１行に与えられます。
</p>
<H2>Output</H2>
<p>
各データセットに対して、復号した元の文章を１行に出力して下さい。
</p>
<H2>Sample Input</H2>
<pre>
1
y eazqyp pnop pngtg ye obmpngt xmybp mr lygw
</pre>
<H2>Output for the Sample Input</H2>
<pre>
i submit that there is another point of view
</pre>
| 1
y eazqyp pnop pngtg ye obmpngt xmybp mr lygw
| i submit that there is another point of view
| 9,608 |
s401123053 | p00040 | u150984829 | 1518159436 | Python | Python3 | py | Accepted | 40 | 5604 | 409 | z='abcdefghijklmnopqrstuvwxyz'
e=lambda x,i,j:z[(z.index(x)*i+j)%26]
def f():
for i in range(1,26,2):
for j in range(26):
if''.join(e(c,i,j)for c in'that')in s or''.join(e(c,i,j)for c in'this')in s:return(i,j)
def g(x,y,s=0,t=1):
q,r=x//y,x%y
return g(y,r,t,s-q*t) if r else t
for _ in[0]*int(input()):
s=input()
a,b=f()
h=g(26,a)
print(''.join(z[h*(z.index(c)-b)%26]if c in z else c for c in s))
| p00040 |
<script type="text/x-mathjax-config">
MathJax.Hub.Config({ tex2jax: { inlineMath: [["$","$"], ["\\(","\\)"]], processEscapes: true }});
</script>
<script type="text/javascript" src="https://cdn.mathjax.org/mathjax/latest/MathJax.js?config=TeX-MML-AM_CHTML">
</script>
<H1>アフィン暗号</H1>
<p>
簡単な暗号法の一つに、アフィン暗号というものがあります。まず、アルファベット a〜z を a = 0, b = 1, c = 2,..., x = 23, y = 24, z = 25 と 0〜25 の数字に置き換えます。そして、以下の式で、原文のアルファベットを置換します。
</p>
<center>
<!--
<p>
F(γ) = (α・γ＋β) mod 26
</p>
-->
<p>
$F(\gamma) = (\alpha \cdot \gamma + \beta)$ mod $26$
</p>
</center>
<p>
ただし、mod 26 は 26 で割った余りを表します。例えば、$\alpha = 3, \beta = 2$ のとき、アルファベットの 'a' (=0) は、$F(0) = (3 \cdot 0 + 2)$ mod $26 = 2$ で 'c' に、アルファベットの 'n' (=13) は $F(13) = (3 \cdot 13 + 2)$ mod $26 = 15$ で 'p' に置換されます。
このとき、$\gamma$ に対する $F(\gamma)$ が必ず 1 対 1 で対応付けられるように、$\alpha$ と $\beta$ は慎重に選ばれているものとします（$\alpha$ と 26 が互いに素であることが条件）。$\alpha = 4, \beta = 7$ のときのように、$F('a') = 7, F('n') = 7$ と、'a' も 'n' も同じ 'h' に置換されるようなことはありません。また、アルファベット以外の文字は置換されません。
</p>
<p>
暗号化された文字列を元の文章に復号したものを出力するプログラムを作成してください。元の文章には、キーワードとして
</p>
<pre>
that
this
</pre>
<p>
のいずれかが必ず含まれているものとします。
</p>
<H2>Input</H2>
<p>
複数のデータセットが与えられます。１行目にデータセット数 $n$ ($n \leq 30$) が与えられます。続いて $n$ 行のデータが与えられます。各データセットに英小文字と空白からなる 256 文字以内の暗号化された文章が１行に与えられます。
</p>
<H2>Output</H2>
<p>
各データセットに対して、復号した元の文章を１行に出力して下さい。
</p>
<H2>Sample Input</H2>
<pre>
1
y eazqyp pnop pngtg ye obmpngt xmybp mr lygw
</pre>
<H2>Output for the Sample Input</H2>
<pre>
i submit that there is another point of view
</pre>
| 1
y eazqyp pnop pngtg ye obmpngt xmybp mr lygw
| i submit that there is another point of view
| 9,609 |
s121593703 | p00040 | u150984829 | 1518159439 | Python | Python3 | py | Accepted | 40 | 5608 | 409 | z='abcdefghijklmnopqrstuvwxyz'
e=lambda x,i,j:z[(z.index(x)*i+j)%26]
def f():
for i in range(1,26,2):
for j in range(26):
if''.join(e(c,i,j)for c in'that')in s or''.join(e(c,i,j)for c in'this')in s:return(i,j)
def g(x,y,s=0,t=1):
q,r=x//y,x%y
return g(y,r,t,s-q*t) if r else t
for _ in[0]*int(input()):
s=input()
a,b=f()
h=g(26,a)
print(''.join(z[h*(z.index(c)-b)%26]if c in z else c for c in s))
| p00040 |
<script type="text/x-mathjax-config">
MathJax.Hub.Config({ tex2jax: { inlineMath: [["$","$"], ["\\(","\\)"]], processEscapes: true }});
</script>
<script type="text/javascript" src="https://cdn.mathjax.org/mathjax/latest/MathJax.js?config=TeX-MML-AM_CHTML">
</script>
<H1>アフィン暗号</H1>
<p>
簡単な暗号法の一つに、アフィン暗号というものがあります。まず、アルファベット a〜z を a = 0, b = 1, c = 2,..., x = 23, y = 24, z = 25 と 0〜25 の数字に置き換えます。そして、以下の式で、原文のアルファベットを置換します。
</p>
<center>
<!--
<p>
F(γ) = (α・γ＋β) mod 26
</p>
-->
<p>
$F(\gamma) = (\alpha \cdot \gamma + \beta)$ mod $26$
</p>
</center>
<p>
ただし、mod 26 は 26 で割った余りを表します。例えば、$\alpha = 3, \beta = 2$ のとき、アルファベットの 'a' (=0) は、$F(0) = (3 \cdot 0 + 2)$ mod $26 = 2$ で 'c' に、アルファベットの 'n' (=13) は $F(13) = (3 \cdot 13 + 2)$ mod $26 = 15$ で 'p' に置換されます。
このとき、$\gamma$ に対する $F(\gamma)$ が必ず 1 対 1 で対応付けられるように、$\alpha$ と $\beta$ は慎重に選ばれているものとします（$\alpha$ と 26 が互いに素であることが条件）。$\alpha = 4, \beta = 7$ のときのように、$F('a') = 7, F('n') = 7$ と、'a' も 'n' も同じ 'h' に置換されるようなことはありません。また、アルファベット以外の文字は置換されません。
</p>
<p>
暗号化された文字列を元の文章に復号したものを出力するプログラムを作成してください。元の文章には、キーワードとして
</p>
<pre>
that
this
</pre>
<p>
のいずれかが必ず含まれているものとします。
</p>
<H2>Input</H2>
<p>
複数のデータセットが与えられます。１行目にデータセット数 $n$ ($n \leq 30$) が与えられます。続いて $n$ 行のデータが与えられます。各データセットに英小文字と空白からなる 256 文字以内の暗号化された文章が１行に与えられます。
</p>
<H2>Output</H2>
<p>
各データセットに対して、復号した元の文章を１行に出力して下さい。
</p>
<H2>Sample Input</H2>
<pre>
1
y eazqyp pnop pngtg ye obmpngt xmybp mr lygw
</pre>
<H2>Output for the Sample Input</H2>
<pre>
i submit that there is another point of view
</pre>
| 1
y eazqyp pnop pngtg ye obmpngt xmybp mr lygw
| i submit that there is another point of view
| 9,610 |
s262226739 | p00040 | u150984829 | 1518159643 | Python | Python3 | py | Accepted | 30 | 5600 | 427 | z='abcdefghijklmnopqrstuvwxyz'
e=lambda x,i,j:z[(z.index(x)*i+j)%26]
def f():
for i in(1,3,5,7,9,11,15,17,19,21,23,25):
for j in range(26):
if''.join(e(c,i,j)for c in'that')in s or''.join(e(c,i,j)for c in'this')in s:return(i,j)
def g(x,y,s=0,t=1):
q,r=x//y,x%y
return g(y,r,t,s-q*t) if r else t
for _ in[0]*int(input()):
s=input()
a,b=f()
h=g(26,a)
print(''.join(z[h*(z.index(c)-b)%26]if c in z else c for c in s))
| p00040 |
<script type="text/x-mathjax-config">
MathJax.Hub.Config({ tex2jax: { inlineMath: [["$","$"], ["\\(","\\)"]], processEscapes: true }});
</script>
<script type="text/javascript" src="https://cdn.mathjax.org/mathjax/latest/MathJax.js?config=TeX-MML-AM_CHTML">
</script>
<H1>アフィン暗号</H1>
<p>
簡単な暗号法の一つに、アフィン暗号というものがあります。まず、アルファベット a〜z を a = 0, b = 1, c = 2,..., x = 23, y = 24, z = 25 と 0〜25 の数字に置き換えます。そして、以下の式で、原文のアルファベットを置換します。
</p>
<center>
<!--
<p>
F(γ) = (α・γ＋β) mod 26
</p>
-->
<p>
$F(\gamma) = (\alpha \cdot \gamma + \beta)$ mod $26$
</p>
</center>
<p>
ただし、mod 26 は 26 で割った余りを表します。例えば、$\alpha = 3, \beta = 2$ のとき、アルファベットの 'a' (=0) は、$F(0) = (3 \cdot 0 + 2)$ mod $26 = 2$ で 'c' に、アルファベットの 'n' (=13) は $F(13) = (3 \cdot 13 + 2)$ mod $26 = 15$ で 'p' に置換されます。
このとき、$\gamma$ に対する $F(\gamma)$ が必ず 1 対 1 で対応付けられるように、$\alpha$ と $\beta$ は慎重に選ばれているものとします（$\alpha$ と 26 が互いに素であることが条件）。$\alpha = 4, \beta = 7$ のときのように、$F('a') = 7, F('n') = 7$ と、'a' も 'n' も同じ 'h' に置換されるようなことはありません。また、アルファベット以外の文字は置換されません。
</p>
<p>
暗号化された文字列を元の文章に復号したものを出力するプログラムを作成してください。元の文章には、キーワードとして
</p>
<pre>
that
this
</pre>
<p>
のいずれかが必ず含まれているものとします。
</p>
<H2>Input</H2>
<p>
複数のデータセットが与えられます。１行目にデータセット数 $n$ ($n \leq 30$) が与えられます。続いて $n$ 行のデータが与えられます。各データセットに英小文字と空白からなる 256 文字以内の暗号化された文章が１行に与えられます。
</p>
<H2>Output</H2>
<p>
各データセットに対して、復号した元の文章を１行に出力して下さい。
</p>
<H2>Sample Input</H2>
<pre>
1
y eazqyp pnop pngtg ye obmpngt xmybp mr lygw
</pre>
<H2>Output for the Sample Input</H2>
<pre>
i submit that there is another point of view
</pre>
| 1
y eazqyp pnop pngtg ye obmpngt xmybp mr lygw
| i submit that there is another point of view
| 9,611 |
s006127605 | p00040 | u150984829 | 1518159645 | Python | Python3 | py | Accepted | 30 | 5600 | 427 | z='abcdefghijklmnopqrstuvwxyz'
e=lambda x,i,j:z[(z.index(x)*i+j)%26]
def f():
for i in(1,3,5,7,9,11,15,17,19,21,23,25):
for j in range(26):
if''.join(e(c,i,j)for c in'that')in s or''.join(e(c,i,j)for c in'this')in s:return(i,j)
def g(x,y,s=0,t=1):
q,r=x//y,x%y
return g(y,r,t,s-q*t) if r else t
for _ in[0]*int(input()):
s=input()
a,b=f()
h=g(26,a)
print(''.join(z[h*(z.index(c)-b)%26]if c in z else c for c in s))
| p00040 |
<script type="text/x-mathjax-config">
MathJax.Hub.Config({ tex2jax: { inlineMath: [["$","$"], ["\\(","\\)"]], processEscapes: true }});
</script>
<script type="text/javascript" src="https://cdn.mathjax.org/mathjax/latest/MathJax.js?config=TeX-MML-AM_CHTML">
</script>
<H1>アフィン暗号</H1>
<p>
簡単な暗号法の一つに、アフィン暗号というものがあります。まず、アルファベット a〜z を a = 0, b = 1, c = 2,..., x = 23, y = 24, z = 25 と 0〜25 の数字に置き換えます。そして、以下の式で、原文のアルファベットを置換します。
</p>
<center>
<!--
<p>
F(γ) = (α・γ＋β) mod 26
</p>
-->
<p>
$F(\gamma) = (\alpha \cdot \gamma + \beta)$ mod $26$
</p>
</center>
<p>
ただし、mod 26 は 26 で割った余りを表します。例えば、$\alpha = 3, \beta = 2$ のとき、アルファベットの 'a' (=0) は、$F(0) = (3 \cdot 0 + 2)$ mod $26 = 2$ で 'c' に、アルファベットの 'n' (=13) は $F(13) = (3 \cdot 13 + 2)$ mod $26 = 15$ で 'p' に置換されます。
このとき、$\gamma$ に対する $F(\gamma)$ が必ず 1 対 1 で対応付けられるように、$\alpha$ と $\beta$ は慎重に選ばれているものとします（$\alpha$ と 26 が互いに素であることが条件）。$\alpha = 4, \beta = 7$ のときのように、$F('a') = 7, F('n') = 7$ と、'a' も 'n' も同じ 'h' に置換されるようなことはありません。また、アルファベット以外の文字は置換されません。
</p>
<p>
暗号化された文字列を元の文章に復号したものを出力するプログラムを作成してください。元の文章には、キーワードとして
</p>
<pre>
that
this
</pre>
<p>
のいずれかが必ず含まれているものとします。
</p>
<H2>Input</H2>
<p>
複数のデータセットが与えられます。１行目にデータセット数 $n$ ($n \leq 30$) が与えられます。続いて $n$ 行のデータが与えられます。各データセットに英小文字と空白からなる 256 文字以内の暗号化された文章が１行に与えられます。
</p>
<H2>Output</H2>
<p>
各データセットに対して、復号した元の文章を１行に出力して下さい。
</p>
<H2>Sample Input</H2>
<pre>
1
y eazqyp pnop pngtg ye obmpngt xmybp mr lygw
</pre>
<H2>Output for the Sample Input</H2>
<pre>
i submit that there is another point of view
</pre>
| 1
y eazqyp pnop pngtg ye obmpngt xmybp mr lygw
| i submit that there is another point of view
| 9,612 |
s316003555 | p00040 | u150984829 | 1518159647 | Python | Python3 | py | Accepted | 40 | 5600 | 427 | z='abcdefghijklmnopqrstuvwxyz'
e=lambda x,i,j:z[(z.index(x)*i+j)%26]
def f():
for i in(1,3,5,7,9,11,15,17,19,21,23,25):
for j in range(26):
if''.join(e(c,i,j)for c in'that')in s or''.join(e(c,i,j)for c in'this')in s:return(i,j)
def g(x,y,s=0,t=1):
q,r=x//y,x%y
return g(y,r,t,s-q*t) if r else t
for _ in[0]*int(input()):
s=input()
a,b=f()
h=g(26,a)
print(''.join(z[h*(z.index(c)-b)%26]if c in z else c for c in s))
| p00040 |
<script type="text/x-mathjax-config">
MathJax.Hub.Config({ tex2jax: { inlineMath: [["$","$"], ["\\(","\\)"]], processEscapes: true }});
</script>
<script type="text/javascript" src="https://cdn.mathjax.org/mathjax/latest/MathJax.js?config=TeX-MML-AM_CHTML">
</script>
<H1>アフィン暗号</H1>
<p>
簡単な暗号法の一つに、アフィン暗号というものがあります。まず、アルファベット a〜z を a = 0, b = 1, c = 2,..., x = 23, y = 24, z = 25 と 0〜25 の数字に置き換えます。そして、以下の式で、原文のアルファベットを置換します。
</p>
<center>
<!--
<p>
F(γ) = (α・γ＋β) mod 26
</p>
-->
<p>
$F(\gamma) = (\alpha \cdot \gamma + \beta)$ mod $26$
</p>
</center>
<p>
ただし、mod 26 は 26 で割った余りを表します。例えば、$\alpha = 3, \beta = 2$ のとき、アルファベットの 'a' (=0) は、$F(0) = (3 \cdot 0 + 2)$ mod $26 = 2$ で 'c' に、アルファベットの 'n' (=13) は $F(13) = (3 \cdot 13 + 2)$ mod $26 = 15$ で 'p' に置換されます。
このとき、$\gamma$ に対する $F(\gamma)$ が必ず 1 対 1 で対応付けられるように、$\alpha$ と $\beta$ は慎重に選ばれているものとします（$\alpha$ と 26 が互いに素であることが条件）。$\alpha = 4, \beta = 7$ のときのように、$F('a') = 7, F('n') = 7$ と、'a' も 'n' も同じ 'h' に置換されるようなことはありません。また、アルファベット以外の文字は置換されません。
</p>
<p>
暗号化された文字列を元の文章に復号したものを出力するプログラムを作成してください。元の文章には、キーワードとして
</p>
<pre>
that
this
</pre>
<p>
のいずれかが必ず含まれているものとします。
</p>
<H2>Input</H2>
<p>
複数のデータセットが与えられます。１行目にデータセット数 $n$ ($n \leq 30$) が与えられます。続いて $n$ 行のデータが与えられます。各データセットに英小文字と空白からなる 256 文字以内の暗号化された文章が１行に与えられます。
</p>
<H2>Output</H2>
<p>
各データセットに対して、復号した元の文章を１行に出力して下さい。
</p>
<H2>Sample Input</H2>
<pre>
1
y eazqyp pnop pngtg ye obmpngt xmybp mr lygw
</pre>
<H2>Output for the Sample Input</H2>
<pre>
i submit that there is another point of view
</pre>
| 1
y eazqyp pnop pngtg ye obmpngt xmybp mr lygw
| i submit that there is another point of view
| 9,613 |
s159316042 | p00040 | u150984829 | 1518160532 | Python | Python3 | py | Accepted | 30 | 5600 | 335 | z='abcdefghijklmnopqrstuvwxyz'
e=lambda x,i,j:z[(z.index(x)*i+j)%26]
def f():
for i in range(1,26,2):
for j in range(26):
if''.join(e(c,i,j)for c in'that')in s or''.join(e(c,i,j)for c in'this')in s:return(i,j)
for _ in[0]*int(input()):
s=input()
k=f()
a=''.join(e(c,*k)for c in z)
t=str.maketrans(a,z)
print(s.translate(t))
| p00040 |
<script type="text/x-mathjax-config">
MathJax.Hub.Config({ tex2jax: { inlineMath: [["$","$"], ["\\(","\\)"]], processEscapes: true }});
</script>
<script type="text/javascript" src="https://cdn.mathjax.org/mathjax/latest/MathJax.js?config=TeX-MML-AM_CHTML">
</script>
<H1>アフィン暗号</H1>
<p>
簡単な暗号法の一つに、アフィン暗号というものがあります。まず、アルファベット a〜z を a = 0, b = 1, c = 2,..., x = 23, y = 24, z = 25 と 0〜25 の数字に置き換えます。そして、以下の式で、原文のアルファベットを置換します。
</p>
<center>
<!--
<p>
F(γ) = (α・γ＋β) mod 26
</p>
-->
<p>
$F(\gamma) = (\alpha \cdot \gamma + \beta)$ mod $26$
</p>
</center>
<p>
ただし、mod 26 は 26 で割った余りを表します。例えば、$\alpha = 3, \beta = 2$ のとき、アルファベットの 'a' (=0) は、$F(0) = (3 \cdot 0 + 2)$ mod $26 = 2$ で 'c' に、アルファベットの 'n' (=13) は $F(13) = (3 \cdot 13 + 2)$ mod $26 = 15$ で 'p' に置換されます。
このとき、$\gamma$ に対する $F(\gamma)$ が必ず 1 対 1 で対応付けられるように、$\alpha$ と $\beta$ は慎重に選ばれているものとします（$\alpha$ と 26 が互いに素であることが条件）。$\alpha = 4, \beta = 7$ のときのように、$F('a') = 7, F('n') = 7$ と、'a' も 'n' も同じ 'h' に置換されるようなことはありません。また、アルファベット以外の文字は置換されません。
</p>
<p>
暗号化された文字列を元の文章に復号したものを出力するプログラムを作成してください。元の文章には、キーワードとして
</p>
<pre>
that
this
</pre>
<p>
のいずれかが必ず含まれているものとします。
</p>
<H2>Input</H2>
<p>
複数のデータセットが与えられます。１行目にデータセット数 $n$ ($n \leq 30$) が与えられます。続いて $n$ 行のデータが与えられます。各データセットに英小文字と空白からなる 256 文字以内の暗号化された文章が１行に与えられます。
</p>
<H2>Output</H2>
<p>
各データセットに対して、復号した元の文章を１行に出力して下さい。
</p>
<H2>Sample Input</H2>
<pre>
1
y eazqyp pnop pngtg ye obmpngt xmybp mr lygw
</pre>
<H2>Output for the Sample Input</H2>
<pre>
i submit that there is another point of view
</pre>
| 1
y eazqyp pnop pngtg ye obmpngt xmybp mr lygw
| i submit that there is another point of view
| 9,614 |
s732887513 | p00040 | u150984829 | 1518160568 | Python | Python3 | py | Accepted | 40 | 5608 | 325 | z='abcdefghijklmnopqrstuvwxyz'
e=lambda x,i,j:z[(z.index(x)*i+j)%26]
def f():
for i in range(1,26,2):
for j in range(26):
if''.join(e(c,i,j)for c in'that')in s or''.join(e(c,i,j)for c in'this')in s:return(i,j)
for _ in[0]*int(input()):
s=input()
k=f()
print(s.translate(str.maketrans(''.join(e(c,*k)for c in z),z)))
| p00040 |
<script type="text/x-mathjax-config">
MathJax.Hub.Config({ tex2jax: { inlineMath: [["$","$"], ["\\(","\\)"]], processEscapes: true }});
</script>
<script type="text/javascript" src="https://cdn.mathjax.org/mathjax/latest/MathJax.js?config=TeX-MML-AM_CHTML">
</script>
<H1>アフィン暗号</H1>
<p>
簡単な暗号法の一つに、アフィン暗号というものがあります。まず、アルファベット a〜z を a = 0, b = 1, c = 2,..., x = 23, y = 24, z = 25 と 0〜25 の数字に置き換えます。そして、以下の式で、原文のアルファベットを置換します。
</p>
<center>
<!--
<p>
F(γ) = (α・γ＋β) mod 26
</p>
-->
<p>
$F(\gamma) = (\alpha \cdot \gamma + \beta)$ mod $26$
</p>
</center>
<p>
ただし、mod 26 は 26 で割った余りを表します。例えば、$\alpha = 3, \beta = 2$ のとき、アルファベットの 'a' (=0) は、$F(0) = (3 \cdot 0 + 2)$ mod $26 = 2$ で 'c' に、アルファベットの 'n' (=13) は $F(13) = (3 \cdot 13 + 2)$ mod $26 = 15$ で 'p' に置換されます。
このとき、$\gamma$ に対する $F(\gamma)$ が必ず 1 対 1 で対応付けられるように、$\alpha$ と $\beta$ は慎重に選ばれているものとします（$\alpha$ と 26 が互いに素であることが条件）。$\alpha = 4, \beta = 7$ のときのように、$F('a') = 7, F('n') = 7$ と、'a' も 'n' も同じ 'h' に置換されるようなことはありません。また、アルファベット以外の文字は置換されません。
</p>
<p>
暗号化された文字列を元の文章に復号したものを出力するプログラムを作成してください。元の文章には、キーワードとして
</p>
<pre>
that
this
</pre>
<p>
のいずれかが必ず含まれているものとします。
</p>
<H2>Input</H2>
<p>
複数のデータセットが与えられます。１行目にデータセット数 $n$ ($n \leq 30$) が与えられます。続いて $n$ 行のデータが与えられます。各データセットに英小文字と空白からなる 256 文字以内の暗号化された文章が１行に与えられます。
</p>
<H2>Output</H2>
<p>
各データセットに対して、復号した元の文章を１行に出力して下さい。
</p>
<H2>Sample Input</H2>
<pre>
1
y eazqyp pnop pngtg ye obmpngt xmybp mr lygw
</pre>
<H2>Output for the Sample Input</H2>
<pre>
i submit that there is another point of view
</pre>
| 1
y eazqyp pnop pngtg ye obmpngt xmybp mr lygw
| i submit that there is another point of view
| 9,615 |
s817830032 | p00040 | u150984829 | 1518160570 | Python | Python3 | py | Accepted | 30 | 5608 | 325 | z='abcdefghijklmnopqrstuvwxyz'
e=lambda x,i,j:z[(z.index(x)*i+j)%26]
def f():
for i in range(1,26,2):
for j in range(26):
if''.join(e(c,i,j)for c in'that')in s or''.join(e(c,i,j)for c in'this')in s:return(i,j)
for _ in[0]*int(input()):
s=input()
k=f()
print(s.translate(str.maketrans(''.join(e(c,*k)for c in z),z)))
| p00040 |
<script type="text/x-mathjax-config">
MathJax.Hub.Config({ tex2jax: { inlineMath: [["$","$"], ["\\(","\\)"]], processEscapes: true }});
</script>
<script type="text/javascript" src="https://cdn.mathjax.org/mathjax/latest/MathJax.js?config=TeX-MML-AM_CHTML">
</script>
<H1>アフィン暗号</H1>
<p>
簡単な暗号法の一つに、アフィン暗号というものがあります。まず、アルファベット a〜z を a = 0, b = 1, c = 2,..., x = 23, y = 24, z = 25 と 0〜25 の数字に置き換えます。そして、以下の式で、原文のアルファベットを置換します。
</p>
<center>
<!--
<p>
F(γ) = (α・γ＋β) mod 26
</p>
-->
<p>
$F(\gamma) = (\alpha \cdot \gamma + \beta)$ mod $26$
</p>
</center>
<p>
ただし、mod 26 は 26 で割った余りを表します。例えば、$\alpha = 3, \beta = 2$ のとき、アルファベットの 'a' (=0) は、$F(0) = (3 \cdot 0 + 2)$ mod $26 = 2$ で 'c' に、アルファベットの 'n' (=13) は $F(13) = (3 \cdot 13 + 2)$ mod $26 = 15$ で 'p' に置換されます。
このとき、$\gamma$ に対する $F(\gamma)$ が必ず 1 対 1 で対応付けられるように、$\alpha$ と $\beta$ は慎重に選ばれているものとします（$\alpha$ と 26 が互いに素であることが条件）。$\alpha = 4, \beta = 7$ のときのように、$F('a') = 7, F('n') = 7$ と、'a' も 'n' も同じ 'h' に置換されるようなことはありません。また、アルファベット以外の文字は置換されません。
</p>
<p>
暗号化された文字列を元の文章に復号したものを出力するプログラムを作成してください。元の文章には、キーワードとして
</p>
<pre>
that
this
</pre>
<p>
のいずれかが必ず含まれているものとします。
</p>
<H2>Input</H2>
<p>
複数のデータセットが与えられます。１行目にデータセット数 $n$ ($n \leq 30$) が与えられます。続いて $n$ 行のデータが与えられます。各データセットに英小文字と空白からなる 256 文字以内の暗号化された文章が１行に与えられます。
</p>
<H2>Output</H2>
<p>
各データセットに対して、復号した元の文章を１行に出力して下さい。
</p>
<H2>Sample Input</H2>
<pre>
1
y eazqyp pnop pngtg ye obmpngt xmybp mr lygw
</pre>
<H2>Output for the Sample Input</H2>
<pre>
i submit that there is another point of view
</pre>
| 1
y eazqyp pnop pngtg ye obmpngt xmybp mr lygw
| i submit that there is another point of view
| 9,616 |
s563006913 | p00040 | u150984829 | 1518160574 | Python | Python3 | py | Accepted | 30 | 5608 | 325 | z='abcdefghijklmnopqrstuvwxyz'
e=lambda x,i,j:z[(z.index(x)*i+j)%26]
def f():
for i in range(1,26,2):
for j in range(26):
if''.join(e(c,i,j)for c in'that')in s or''.join(e(c,i,j)for c in'this')in s:return(i,j)
for _ in[0]*int(input()):
s=input()
k=f()
print(s.translate(str.maketrans(''.join(e(c,*k)for c in z),z)))
| p00040 |
<script type="text/x-mathjax-config">
MathJax.Hub.Config({ tex2jax: { inlineMath: [["$","$"], ["\\(","\\)"]], processEscapes: true }});
</script>
<script type="text/javascript" src="https://cdn.mathjax.org/mathjax/latest/MathJax.js?config=TeX-MML-AM_CHTML">
</script>
<H1>アフィン暗号</H1>
<p>
簡単な暗号法の一つに、アフィン暗号というものがあります。まず、アルファベット a〜z を a = 0, b = 1, c = 2,..., x = 23, y = 24, z = 25 と 0〜25 の数字に置き換えます。そして、以下の式で、原文のアルファベットを置換します。
</p>
<center>
<!--
<p>
F(γ) = (α・γ＋β) mod 26
</p>
-->
<p>
$F(\gamma) = (\alpha \cdot \gamma + \beta)$ mod $26$
</p>
</center>
<p>
ただし、mod 26 は 26 で割った余りを表します。例えば、$\alpha = 3, \beta = 2$ のとき、アルファベットの 'a' (=0) は、$F(0) = (3 \cdot 0 + 2)$ mod $26 = 2$ で 'c' に、アルファベットの 'n' (=13) は $F(13) = (3 \cdot 13 + 2)$ mod $26 = 15$ で 'p' に置換されます。
このとき、$\gamma$ に対する $F(\gamma)$ が必ず 1 対 1 で対応付けられるように、$\alpha$ と $\beta$ は慎重に選ばれているものとします（$\alpha$ と 26 が互いに素であることが条件）。$\alpha = 4, \beta = 7$ のときのように、$F('a') = 7, F('n') = 7$ と、'a' も 'n' も同じ 'h' に置換されるようなことはありません。また、アルファベット以外の文字は置換されません。
</p>
<p>
暗号化された文字列を元の文章に復号したものを出力するプログラムを作成してください。元の文章には、キーワードとして
</p>
<pre>
that
this
</pre>
<p>
のいずれかが必ず含まれているものとします。
</p>
<H2>Input</H2>
<p>
複数のデータセットが与えられます。１行目にデータセット数 $n$ ($n \leq 30$) が与えられます。続いて $n$ 行のデータが与えられます。各データセットに英小文字と空白からなる 256 文字以内の暗号化された文章が１行に与えられます。
</p>
<H2>Output</H2>
<p>
各データセットに対して、復号した元の文章を１行に出力して下さい。
</p>
<H2>Sample Input</H2>
<pre>
1
y eazqyp pnop pngtg ye obmpngt xmybp mr lygw
</pre>
<H2>Output for the Sample Input</H2>
<pre>
i submit that there is another point of view
</pre>
| 1
y eazqyp pnop pngtg ye obmpngt xmybp mr lygw
| i submit that there is another point of view
| 9,617 |
s933507333 | p00040 | u150984829 | 1518160742 | Python | Python3 | py | Accepted | 30 | 5576 | 340 | import sys
z='abcdefghijklmnopqrstuvwxyz'
e=lambda x,i,j:z[(z.index(x)*i+j)%26]
def f():
for i in range(1,26,2):
for j in range(26):
if''.join(e(c,i,j)for c in'that')in s or''.join(e(c,i,j)for c in'this')in s:return(i,j)
input()
for s in sys.stdin:
s=s.strip()
k=f()
print(s.translate(str.maketrans(''.join(e(c,*k)for c in z),z)))
| p00040 |
<script type="text/x-mathjax-config">
MathJax.Hub.Config({ tex2jax: { inlineMath: [["$","$"], ["\\(","\\)"]], processEscapes: true }});
</script>
<script type="text/javascript" src="https://cdn.mathjax.org/mathjax/latest/MathJax.js?config=TeX-MML-AM_CHTML">
</script>
<H1>アフィン暗号</H1>
<p>
簡単な暗号法の一つに、アフィン暗号というものがあります。まず、アルファベット a〜z を a = 0, b = 1, c = 2,..., x = 23, y = 24, z = 25 と 0〜25 の数字に置き換えます。そして、以下の式で、原文のアルファベットを置換します。
</p>
<center>
<!--
<p>
F(γ) = (α・γ＋β) mod 26
</p>
-->
<p>
$F(\gamma) = (\alpha \cdot \gamma + \beta)$ mod $26$
</p>
</center>
<p>
ただし、mod 26 は 26 で割った余りを表します。例えば、$\alpha = 3, \beta = 2$ のとき、アルファベットの 'a' (=0) は、$F(0) = (3 \cdot 0 + 2)$ mod $26 = 2$ で 'c' に、アルファベットの 'n' (=13) は $F(13) = (3 \cdot 13 + 2)$ mod $26 = 15$ で 'p' に置換されます。
このとき、$\gamma$ に対する $F(\gamma)$ が必ず 1 対 1 で対応付けられるように、$\alpha$ と $\beta$ は慎重に選ばれているものとします（$\alpha$ と 26 が互いに素であることが条件）。$\alpha = 4, \beta = 7$ のときのように、$F('a') = 7, F('n') = 7$ と、'a' も 'n' も同じ 'h' に置換されるようなことはありません。また、アルファベット以外の文字は置換されません。
</p>
<p>
暗号化された文字列を元の文章に復号したものを出力するプログラムを作成してください。元の文章には、キーワードとして
</p>
<pre>
that
this
</pre>
<p>
のいずれかが必ず含まれているものとします。
</p>
<H2>Input</H2>
<p>
複数のデータセットが与えられます。１行目にデータセット数 $n$ ($n \leq 30$) が与えられます。続いて $n$ 行のデータが与えられます。各データセットに英小文字と空白からなる 256 文字以内の暗号化された文章が１行に与えられます。
</p>
<H2>Output</H2>
<p>
各データセットに対して、復号した元の文章を１行に出力して下さい。
</p>
<H2>Sample Input</H2>
<pre>
1
y eazqyp pnop pngtg ye obmpngt xmybp mr lygw
</pre>
<H2>Output for the Sample Input</H2>
<pre>
i submit that there is another point of view
</pre>
| 1
y eazqyp pnop pngtg ye obmpngt xmybp mr lygw
| i submit that there is another point of view
| 9,618 |
s214171699 | p00040 | u150984829 | 1518160743 | Python | Python3 | py | Accepted | 40 | 5572 | 340 | import sys
z='abcdefghijklmnopqrstuvwxyz'
e=lambda x,i,j:z[(z.index(x)*i+j)%26]
def f():
for i in range(1,26,2):
for j in range(26):
if''.join(e(c,i,j)for c in'that')in s or''.join(e(c,i,j)for c in'this')in s:return(i,j)
input()
for s in sys.stdin:
s=s.strip()
k=f()
print(s.translate(str.maketrans(''.join(e(c,*k)for c in z),z)))
| p00040 |
<script type="text/x-mathjax-config">
MathJax.Hub.Config({ tex2jax: { inlineMath: [["$","$"], ["\\(","\\)"]], processEscapes: true }});
</script>
<script type="text/javascript" src="https://cdn.mathjax.org/mathjax/latest/MathJax.js?config=TeX-MML-AM_CHTML">
</script>
<H1>アフィン暗号</H1>
<p>
簡単な暗号法の一つに、アフィン暗号というものがあります。まず、アルファベット a〜z を a = 0, b = 1, c = 2,..., x = 23, y = 24, z = 25 と 0〜25 の数字に置き換えます。そして、以下の式で、原文のアルファベットを置換します。
</p>
<center>
<!--
<p>
F(γ) = (α・γ＋β) mod 26
</p>
-->
<p>
$F(\gamma) = (\alpha \cdot \gamma + \beta)$ mod $26$
</p>
</center>
<p>
ただし、mod 26 は 26 で割った余りを表します。例えば、$\alpha = 3, \beta = 2$ のとき、アルファベットの 'a' (=0) は、$F(0) = (3 \cdot 0 + 2)$ mod $26 = 2$ で 'c' に、アルファベットの 'n' (=13) は $F(13) = (3 \cdot 13 + 2)$ mod $26 = 15$ で 'p' に置換されます。
このとき、$\gamma$ に対する $F(\gamma)$ が必ず 1 対 1 で対応付けられるように、$\alpha$ と $\beta$ は慎重に選ばれているものとします（$\alpha$ と 26 が互いに素であることが条件）。$\alpha = 4, \beta = 7$ のときのように、$F('a') = 7, F('n') = 7$ と、'a' も 'n' も同じ 'h' に置換されるようなことはありません。また、アルファベット以外の文字は置換されません。
</p>
<p>
暗号化された文字列を元の文章に復号したものを出力するプログラムを作成してください。元の文章には、キーワードとして
</p>
<pre>
that
this
</pre>
<p>
のいずれかが必ず含まれているものとします。
</p>
<H2>Input</H2>
<p>
複数のデータセットが与えられます。１行目にデータセット数 $n$ ($n \leq 30$) が与えられます。続いて $n$ 行のデータが与えられます。各データセットに英小文字と空白からなる 256 文字以内の暗号化された文章が１行に与えられます。
</p>
<H2>Output</H2>
<p>
各データセットに対して、復号した元の文章を１行に出力して下さい。
</p>
<H2>Sample Input</H2>
<pre>
1
y eazqyp pnop pngtg ye obmpngt xmybp mr lygw
</pre>
<H2>Output for the Sample Input</H2>
<pre>
i submit that there is another point of view
</pre>
| 1
y eazqyp pnop pngtg ye obmpngt xmybp mr lygw
| i submit that there is another point of view
| 9,619 |
s378943595 | p00040 | u150984829 | 1518160745 | Python | Python3 | py | Accepted | 30 | 5576 | 340 | import sys
z='abcdefghijklmnopqrstuvwxyz'
e=lambda x,i,j:z[(z.index(x)*i+j)%26]
def f():
for i in range(1,26,2):
for j in range(26):
if''.join(e(c,i,j)for c in'that')in s or''.join(e(c,i,j)for c in'this')in s:return(i,j)
input()
for s in sys.stdin:
s=s.strip()
k=f()
print(s.translate(str.maketrans(''.join(e(c,*k)for c in z),z)))
| p00040 |
<script type="text/x-mathjax-config">
MathJax.Hub.Config({ tex2jax: { inlineMath: [["$","$"], ["\\(","\\)"]], processEscapes: true }});
</script>
<script type="text/javascript" src="https://cdn.mathjax.org/mathjax/latest/MathJax.js?config=TeX-MML-AM_CHTML">
</script>
<H1>アフィン暗号</H1>
<p>
簡単な暗号法の一つに、アフィン暗号というものがあります。まず、アルファベット a〜z を a = 0, b = 1, c = 2,..., x = 23, y = 24, z = 25 と 0〜25 の数字に置き換えます。そして、以下の式で、原文のアルファベットを置換します。
</p>
<center>
<!--
<p>
F(γ) = (α・γ＋β) mod 26
</p>
-->
<p>
$F(\gamma) = (\alpha \cdot \gamma + \beta)$ mod $26$
</p>
</center>
<p>
ただし、mod 26 は 26 で割った余りを表します。例えば、$\alpha = 3, \beta = 2$ のとき、アルファベットの 'a' (=0) は、$F(0) = (3 \cdot 0 + 2)$ mod $26 = 2$ で 'c' に、アルファベットの 'n' (=13) は $F(13) = (3 \cdot 13 + 2)$ mod $26 = 15$ で 'p' に置換されます。
このとき、$\gamma$ に対する $F(\gamma)$ が必ず 1 対 1 で対応付けられるように、$\alpha$ と $\beta$ は慎重に選ばれているものとします（$\alpha$ と 26 が互いに素であることが条件）。$\alpha = 4, \beta = 7$ のときのように、$F('a') = 7, F('n') = 7$ と、'a' も 'n' も同じ 'h' に置換されるようなことはありません。また、アルファベット以外の文字は置換されません。
</p>
<p>
暗号化された文字列を元の文章に復号したものを出力するプログラムを作成してください。元の文章には、キーワードとして
</p>
<pre>
that
this
</pre>
<p>
のいずれかが必ず含まれているものとします。
</p>
<H2>Input</H2>
<p>
複数のデータセットが与えられます。１行目にデータセット数 $n$ ($n \leq 30$) が与えられます。続いて $n$ 行のデータが与えられます。各データセットに英小文字と空白からなる 256 文字以内の暗号化された文章が１行に与えられます。
</p>
<H2>Output</H2>
<p>
各データセットに対して、復号した元の文章を１行に出力して下さい。
</p>
<H2>Sample Input</H2>
<pre>
1
y eazqyp pnop pngtg ye obmpngt xmybp mr lygw
</pre>
<H2>Output for the Sample Input</H2>
<pre>
i submit that there is another point of view
</pre>
| 1
y eazqyp pnop pngtg ye obmpngt xmybp mr lygw
| i submit that there is another point of view
| 9,620 |
s881200175 | p00040 | u150984829 | 1524994851 | Python | Python3 | py | Accepted | 30 | 5608 | 313 | z='abcdefghijklmnopqrstuvwxyz'
e=lambda x,i,j:z[(z.index(x)*i+j)%26]
def f():
for i in range(1,26,2):
for j in range(26):
if sum(''.join(e(c,i,j)for c in w)in s for w in['that','this']):return(i,j)
for _ in[0]*int(input()):
s=input()
k=f()
print(s.translate(str.maketrans(''.join(e(c,*k)for c in z),z)))
| p00040 |
<script type="text/x-mathjax-config">
MathJax.Hub.Config({ tex2jax: { inlineMath: [["$","$"], ["\\(","\\)"]], processEscapes: true }});
</script>
<script type="text/javascript" src="https://cdn.mathjax.org/mathjax/latest/MathJax.js?config=TeX-MML-AM_CHTML">
</script>
<H1>アフィン暗号</H1>
<p>
簡単な暗号法の一つに、アフィン暗号というものがあります。まず、アルファベット a〜z を a = 0, b = 1, c = 2,..., x = 23, y = 24, z = 25 と 0〜25 の数字に置き換えます。そして、以下の式で、原文のアルファベットを置換します。
</p>
<center>
<!--
<p>
F(γ) = (α・γ＋β) mod 26
</p>
-->
<p>
$F(\gamma) = (\alpha \cdot \gamma + \beta)$ mod $26$
</p>
</center>
<p>
ただし、mod 26 は 26 で割った余りを表します。例えば、$\alpha = 3, \beta = 2$ のとき、アルファベットの 'a' (=0) は、$F(0) = (3 \cdot 0 + 2)$ mod $26 = 2$ で 'c' に、アルファベットの 'n' (=13) は $F(13) = (3 \cdot 13 + 2)$ mod $26 = 15$ で 'p' に置換されます。
このとき、$\gamma$ に対する $F(\gamma)$ が必ず 1 対 1 で対応付けられるように、$\alpha$ と $\beta$ は慎重に選ばれているものとします（$\alpha$ と 26 が互いに素であることが条件）。$\alpha = 4, \beta = 7$ のときのように、$F('a') = 7, F('n') = 7$ と、'a' も 'n' も同じ 'h' に置換されるようなことはありません。また、アルファベット以外の文字は置換されません。
</p>
<p>
暗号化された文字列を元の文章に復号したものを出力するプログラムを作成してください。元の文章には、キーワードとして
</p>
<pre>
that
this
</pre>
<p>
のいずれかが必ず含まれているものとします。
</p>
<H2>Input</H2>
<p>
複数のデータセットが与えられます。１行目にデータセット数 $n$ ($n \leq 30$) が与えられます。続いて $n$ 行のデータが与えられます。各データセットに英小文字と空白からなる 256 文字以内の暗号化された文章が１行に与えられます。
</p>
<H2>Output</H2>
<p>
各データセットに対して、復号した元の文章を１行に出力して下さい。
</p>
<H2>Sample Input</H2>
<pre>
1
y eazqyp pnop pngtg ye obmpngt xmybp mr lygw
</pre>
<H2>Output for the Sample Input</H2>
<pre>
i submit that there is another point of view
</pre>
| 1
y eazqyp pnop pngtg ye obmpngt xmybp mr lygw
| i submit that there is another point of view
| 9,621 |
s871664392 | p00040 | u352394527 | 1527497974 | Python | Python3 | py | Accepted | 90 | 5604 | 341 | base = ord("a")
alst = [i for i in range(1, 26, 2) if i % 13]
def restore(s):
for a in alst:
for b in range(26):
new = "".join([chr((a * (ord(x) - base) + b) % 26 + base) if x != " " else " " for x in s])
if "that" in new or "this" in new:
return new
n = int(input())
for _ in range(n):
print(restore(input()))
| p00040 |
<script type="text/x-mathjax-config">
MathJax.Hub.Config({ tex2jax: { inlineMath: [["$","$"], ["\\(","\\)"]], processEscapes: true }});
</script>
<script type="text/javascript" src="https://cdn.mathjax.org/mathjax/latest/MathJax.js?config=TeX-MML-AM_CHTML">
</script>
<H1>アフィン暗号</H1>
<p>
簡単な暗号法の一つに、アフィン暗号というものがあります。まず、アルファベット a〜z を a = 0, b = 1, c = 2,..., x = 23, y = 24, z = 25 と 0〜25 の数字に置き換えます。そして、以下の式で、原文のアルファベットを置換します。
</p>
<center>
<!--
<p>
F(γ) = (α・γ＋β) mod 26
</p>
-->
<p>
$F(\gamma) = (\alpha \cdot \gamma + \beta)$ mod $26$
</p>
</center>
<p>
ただし、mod 26 は 26 で割った余りを表します。例えば、$\alpha = 3, \beta = 2$ のとき、アルファベットの 'a' (=0) は、$F(0) = (3 \cdot 0 + 2)$ mod $26 = 2$ で 'c' に、アルファベットの 'n' (=13) は $F(13) = (3 \cdot 13 + 2)$ mod $26 = 15$ で 'p' に置換されます。
このとき、$\gamma$ に対する $F(\gamma)$ が必ず 1 対 1 で対応付けられるように、$\alpha$ と $\beta$ は慎重に選ばれているものとします（$\alpha$ と 26 が互いに素であることが条件）。$\alpha = 4, \beta = 7$ のときのように、$F('a') = 7, F('n') = 7$ と、'a' も 'n' も同じ 'h' に置換されるようなことはありません。また、アルファベット以外の文字は置換されません。
</p>
<p>
暗号化された文字列を元の文章に復号したものを出力するプログラムを作成してください。元の文章には、キーワードとして
</p>
<pre>
that
this
</pre>
<p>
のいずれかが必ず含まれているものとします。
</p>
<H2>Input</H2>
<p>
複数のデータセットが与えられます。１行目にデータセット数 $n$ ($n \leq 30$) が与えられます。続いて $n$ 行のデータが与えられます。各データセットに英小文字と空白からなる 256 文字以内の暗号化された文章が１行に与えられます。
</p>
<H2>Output</H2>
<p>
各データセットに対して、復号した元の文章を１行に出力して下さい。
</p>
<H2>Sample Input</H2>
<pre>
1
y eazqyp pnop pngtg ye obmpngt xmybp mr lygw
</pre>
<H2>Output for the Sample Input</H2>
<pre>
i submit that there is another point of view
</pre>
| 1
y eazqyp pnop pngtg ye obmpngt xmybp mr lygw
| i submit that there is another point of view
| 9,622 |
s794220226 | p00040 | u847467233 | 1530105087 | Python | Python3 | py | Accepted | 20 | 5624 | 603 | # AOJ 0040: Affine Cipher
# Python3 2018.6.27 bal4u
M = 26
A = ord('a')
re_prime = [1, 3, 5, 7, 9, 11, 15, 17, 19, 21, 23, 25]
def F(ch):
global a, b
x = ord(ch)-A
return chr((a*x + b) % M + A)
dic = {}
for a in re_prime:
for b in range(M):
dic[F('t')+F('h')+F('i')+F('s')] = (a, b)
dic[F('t')+F('h')+F('a')+F('t')] = (a, b)
n = int(input())
for i in range(n):
s = list(input().split())
for x in s:
if len(x) == 4 and x in dic:
a,b = dic[x]
break
tr = {}
for i in range(M): tr[F(chr(i+A))] = chr(i+A)
ans = []
for x in s: ans.append(''.join([tr[c] for c in x]))
print(*ans)
| p00040 |
<script type="text/x-mathjax-config">
MathJax.Hub.Config({ tex2jax: { inlineMath: [["$","$"], ["\\(","\\)"]], processEscapes: true }});
</script>
<script type="text/javascript" src="https://cdn.mathjax.org/mathjax/latest/MathJax.js?config=TeX-MML-AM_CHTML">
</script>
<H1>アフィン暗号</H1>
<p>
簡単な暗号法の一つに、アフィン暗号というものがあります。まず、アルファベット a〜z を a = 0, b = 1, c = 2,..., x = 23, y = 24, z = 25 と 0〜25 の数字に置き換えます。そして、以下の式で、原文のアルファベットを置換します。
</p>
<center>
<!--
<p>
F(γ) = (α・γ＋β) mod 26
</p>
-->
<p>
$F(\gamma) = (\alpha \cdot \gamma + \beta)$ mod $26$
</p>
</center>
<p>
ただし、mod 26 は 26 で割った余りを表します。例えば、$\alpha = 3, \beta = 2$ のとき、アルファベットの 'a' (=0) は、$F(0) = (3 \cdot 0 + 2)$ mod $26 = 2$ で 'c' に、アルファベットの 'n' (=13) は $F(13) = (3 \cdot 13 + 2)$ mod $26 = 15$ で 'p' に置換されます。
このとき、$\gamma$ に対する $F(\gamma)$ が必ず 1 対 1 で対応付けられるように、$\alpha$ と $\beta$ は慎重に選ばれているものとします（$\alpha$ と 26 が互いに素であることが条件）。$\alpha = 4, \beta = 7$ のときのように、$F('a') = 7, F('n') = 7$ と、'a' も 'n' も同じ 'h' に置換されるようなことはありません。また、アルファベット以外の文字は置換されません。
</p>
<p>
暗号化された文字列を元の文章に復号したものを出力するプログラムを作成してください。元の文章には、キーワードとして
</p>
<pre>
that
this
</pre>
<p>
のいずれかが必ず含まれているものとします。
</p>
<H2>Input</H2>
<p>
複数のデータセットが与えられます。１行目にデータセット数 $n$ ($n \leq 30$) が与えられます。続いて $n$ 行のデータが与えられます。各データセットに英小文字と空白からなる 256 文字以内の暗号化された文章が１行に与えられます。
</p>
<H2>Output</H2>
<p>
各データセットに対して、復号した元の文章を１行に出力して下さい。
</p>
<H2>Sample Input</H2>
<pre>
1
y eazqyp pnop pngtg ye obmpngt xmybp mr lygw
</pre>
<H2>Output for the Sample Input</H2>
<pre>
i submit that there is another point of view
</pre>
| 1
y eazqyp pnop pngtg ye obmpngt xmybp mr lygw
| i submit that there is another point of view
| 9,623 |
s748649263 | p00040 | u459861655 | 1356411910 | Python | Python | py | Accepted | 50 | 6560 | 766 | ALPA = 'abcdefghijklmnopqrstuvwxyz'
sets = dict(zip(list(ALPA), range(26)))
A_LIST = [n for n in range(1, 26) if n%2 != 0 and n%13 != 0]
def encode(word, a, b):
return [(a*y+b)% 26 for y in [sets[c] for c in list(word)]]
def find(words):
for a in A_LIST:
for b in range(26):
for word in words:
if word == encode("this", a, b) or word == encode("that", a, b):
return (a, b)
for i in range(int(raw_input())):
data = raw_input()
a, b = find([[sets[c] for c in list(word)] for word in data.split(' ') if len(word) == 4])
ans = dict(zip(encode(ALPA, a, b), list(ALPA)))
print ' '.join([''.join([ans[n] for n in [sets[c] for c in list(word)]]) for word in data.split(' ')]) | p00040 |
<script type="text/x-mathjax-config">
MathJax.Hub.Config({ tex2jax: { inlineMath: [["$","$"], ["\\(","\\)"]], processEscapes: true }});
</script>
<script type="text/javascript" src="https://cdn.mathjax.org/mathjax/latest/MathJax.js?config=TeX-MML-AM_CHTML">
</script>
<H1>アフィン暗号</H1>
<p>
簡単な暗号法の一つに、アフィン暗号というものがあります。まず、アルファベット a〜z を a = 0, b = 1, c = 2,..., x = 23, y = 24, z = 25 と 0〜25 の数字に置き換えます。そして、以下の式で、原文のアルファベットを置換します。
</p>
<center>
<!--
<p>
F(γ) = (α・γ＋β) mod 26
</p>
-->
<p>
$F(\gamma) = (\alpha \cdot \gamma + \beta)$ mod $26$
</p>
</center>
<p>
ただし、mod 26 は 26 で割った余りを表します。例えば、$\alpha = 3, \beta = 2$ のとき、アルファベットの 'a' (=0) は、$F(0) = (3 \cdot 0 + 2)$ mod $26 = 2$ で 'c' に、アルファベットの 'n' (=13) は $F(13) = (3 \cdot 13 + 2)$ mod $26 = 15$ で 'p' に置換されます。
このとき、$\gamma$ に対する $F(\gamma)$ が必ず 1 対 1 で対応付けられるように、$\alpha$ と $\beta$ は慎重に選ばれているものとします（$\alpha$ と 26 が互いに素であることが条件）。$\alpha = 4, \beta = 7$ のときのように、$F('a') = 7, F('n') = 7$ と、'a' も 'n' も同じ 'h' に置換されるようなことはありません。また、アルファベット以外の文字は置換されません。
</p>
<p>
暗号化された文字列を元の文章に復号したものを出力するプログラムを作成してください。元の文章には、キーワードとして
</p>
<pre>
that
this
</pre>
<p>
のいずれかが必ず含まれているものとします。
</p>
<H2>Input</H2>
<p>
複数のデータセットが与えられます。１行目にデータセット数 $n$ ($n \leq 30$) が与えられます。続いて $n$ 行のデータが与えられます。各データセットに英小文字と空白からなる 256 文字以内の暗号化された文章が１行に与えられます。
</p>
<H2>Output</H2>
<p>
各データセットに対して、復号した元の文章を１行に出力して下さい。
</p>
<H2>Sample Input</H2>
<pre>
1
y eazqyp pnop pngtg ye obmpngt xmybp mr lygw
</pre>
<H2>Output for the Sample Input</H2>
<pre>
i submit that there is another point of view
</pre>
| 1
y eazqyp pnop pngtg ye obmpngt xmybp mr lygw
| i submit that there is another point of view
| 9,624 |
s728121485 | p00040 | u912237403 | 1387569059 | Python | Python | py | Accepted | 20 | 4284 | 882 | A2Z="abcdefghijklmnopqrstuvwxyz"
def affine(msg, a, b):
offset = ord('a')
x=[]
for c in msg:
if 'a'<=c<='z':
try:
c = A2Z[(A2Z.index(c)*a+b)%26]
except:
print c
x.append(c)
return "".join(x)
def rot(msg, a):
a = a % 26
L2 = A2Z[a:]+A2Z[:a]
x = [L2[A2Z.index(c)] for c in msg]
return "".join(x)
def checkkey(msg):
c0=('t')
for i in range(26):#[2,3,5,7,11,13,17,19,23]:
x = affine(msg,i,0)
if x[0]!=c0:
a = (ord(c0)-ord(x[0]))%26
x = rot(x,a)
else:
a = 0
if x in['this','that']: return i,a
return -1,-1
n = input()
for i in range(n):
msg = raw_input()
for word in msg.split():
if len(word)==4:
a,b = checkkey(word)
if a!=-1: break
print affine(msg,a,b) | p00040 |
<script type="text/x-mathjax-config">
MathJax.Hub.Config({ tex2jax: { inlineMath: [["$","$"], ["\\(","\\)"]], processEscapes: true }});
</script>
<script type="text/javascript" src="https://cdn.mathjax.org/mathjax/latest/MathJax.js?config=TeX-MML-AM_CHTML">
</script>
<H1>アフィン暗号</H1>
<p>
簡単な暗号法の一つに、アフィン暗号というものがあります。まず、アルファベット a〜z を a = 0, b = 1, c = 2,..., x = 23, y = 24, z = 25 と 0〜25 の数字に置き換えます。そして、以下の式で、原文のアルファベットを置換します。
</p>
<center>
<!--
<p>
F(γ) = (α・γ＋β) mod 26
</p>
-->
<p>
$F(\gamma) = (\alpha \cdot \gamma + \beta)$ mod $26$
</p>
</center>
<p>
ただし、mod 26 は 26 で割った余りを表します。例えば、$\alpha = 3, \beta = 2$ のとき、アルファベットの 'a' (=0) は、$F(0) = (3 \cdot 0 + 2)$ mod $26 = 2$ で 'c' に、アルファベットの 'n' (=13) は $F(13) = (3 \cdot 13 + 2)$ mod $26 = 15$ で 'p' に置換されます。
このとき、$\gamma$ に対する $F(\gamma)$ が必ず 1 対 1 で対応付けられるように、$\alpha$ と $\beta$ は慎重に選ばれているものとします（$\alpha$ と 26 が互いに素であることが条件）。$\alpha = 4, \beta = 7$ のときのように、$F('a') = 7, F('n') = 7$ と、'a' も 'n' も同じ 'h' に置換されるようなことはありません。また、アルファベット以外の文字は置換されません。
</p>
<p>
暗号化された文字列を元の文章に復号したものを出力するプログラムを作成してください。元の文章には、キーワードとして
</p>
<pre>
that
this
</pre>
<p>
のいずれかが必ず含まれているものとします。
</p>
<H2>Input</H2>
<p>
複数のデータセットが与えられます。１行目にデータセット数 $n$ ($n \leq 30$) が与えられます。続いて $n$ 行のデータが与えられます。各データセットに英小文字と空白からなる 256 文字以内の暗号化された文章が１行に与えられます。
</p>
<H2>Output</H2>
<p>
各データセットに対して、復号した元の文章を１行に出力して下さい。
</p>
<H2>Sample Input</H2>
<pre>
1
y eazqyp pnop pngtg ye obmpngt xmybp mr lygw
</pre>
<H2>Output for the Sample Input</H2>
<pre>
i submit that there is another point of view
</pre>
| 1
y eazqyp pnop pngtg ye obmpngt xmybp mr lygw
| i submit that there is another point of view
| 9,625 |
s147516259 | p00040 | u912237403 | 1387586849 | Python | Python | py | Accepted | 30 | 4288 | 809 | A2Z="abcdefghijklmnopqrstuvwxyz"
def decode(L1,L2,msg):
x=[]
for c in msg:
if 'a'<=c<='z':
c = L2[L1.index(c)]
x.append(c)
return "".join(x)
def affine(msg, key):
a,b = key
L = [A2Z[(i*a+b)%26] for i in range(26)]
L = "".join(L)
return decode(A2Z,L,msg)
def rot(msg, a):
if a==0: return msg
a = a % 26
L = A2Z[a:]+A2Z[:a]
return decode(A2Z,L,msg)
def find(msg):
c0=ord('t')
for i in range(26):
x = affine(msg,[i,0])
a = (c0-ord(x[0]))%26
x = rot(x,a)
if x in['this','that']: return [i,a]
return []
n = input()
for i in range(n):
msg = raw_input()
for w in msg.split():
if len(w)==4:
key = find(w)
if key!=[]: break
print affine(msg,key) | p00040 |
<script type="text/x-mathjax-config">
MathJax.Hub.Config({ tex2jax: { inlineMath: [["$","$"], ["\\(","\\)"]], processEscapes: true }});
</script>
<script type="text/javascript" src="https://cdn.mathjax.org/mathjax/latest/MathJax.js?config=TeX-MML-AM_CHTML">
</script>
<H1>アフィン暗号</H1>
<p>
簡単な暗号法の一つに、アフィン暗号というものがあります。まず、アルファベット a〜z を a = 0, b = 1, c = 2,..., x = 23, y = 24, z = 25 と 0〜25 の数字に置き換えます。そして、以下の式で、原文のアルファベットを置換します。
</p>
<center>
<!--
<p>
F(γ) = (α・γ＋β) mod 26
</p>
-->
<p>
$F(\gamma) = (\alpha \cdot \gamma + \beta)$ mod $26$
</p>
</center>
<p>
ただし、mod 26 は 26 で割った余りを表します。例えば、$\alpha = 3, \beta = 2$ のとき、アルファベットの 'a' (=0) は、$F(0) = (3 \cdot 0 + 2)$ mod $26 = 2$ で 'c' に、アルファベットの 'n' (=13) は $F(13) = (3 \cdot 13 + 2)$ mod $26 = 15$ で 'p' に置換されます。
このとき、$\gamma$ に対する $F(\gamma)$ が必ず 1 対 1 で対応付けられるように、$\alpha$ と $\beta$ は慎重に選ばれているものとします（$\alpha$ と 26 が互いに素であることが条件）。$\alpha = 4, \beta = 7$ のときのように、$F('a') = 7, F('n') = 7$ と、'a' も 'n' も同じ 'h' に置換されるようなことはありません。また、アルファベット以外の文字は置換されません。
</p>
<p>
暗号化された文字列を元の文章に復号したものを出力するプログラムを作成してください。元の文章には、キーワードとして
</p>
<pre>
that
this
</pre>
<p>
のいずれかが必ず含まれているものとします。
</p>
<H2>Input</H2>
<p>
複数のデータセットが与えられます。１行目にデータセット数 $n$ ($n \leq 30$) が与えられます。続いて $n$ 行のデータが与えられます。各データセットに英小文字と空白からなる 256 文字以内の暗号化された文章が１行に与えられます。
</p>
<H2>Output</H2>
<p>
各データセットに対して、復号した元の文章を１行に出力して下さい。
</p>
<H2>Sample Input</H2>
<pre>
1
y eazqyp pnop pngtg ye obmpngt xmybp mr lygw
</pre>
<H2>Output for the Sample Input</H2>
<pre>
i submit that there is another point of view
</pre>
| 1
y eazqyp pnop pngtg ye obmpngt xmybp mr lygw
| i submit that there is another point of view
| 9,626 |
s933588050 | p00040 | u912237403 | 1394455187 | Python | Python | py | Accepted | 40 | 4420 | 754 | import string
A2Z="abcdefghijklmnopqrstuvwxyz"
def decode(msg,L):
t = string.maketrans(A2Z,L)
s = string.translate(msg,t)
return s
def affine(msg, a, b):
L = "".join([A2Z[(i*a+b)%26]for i in range(26)])
return decode(msg,L)
def rot(msg, a):
a = a % 26
L = "".join(A2Z[a:]+A2Z[:a])
return decode(msg,L)
def checkkey(s):
c0="t"
for i in range(26):
a = 0
x = affine(s,i,0)
if x[0]!=c0:
a = (ord(c0)-ord(x[0]))%26
x = rot(x,a)
if x in['this','that']: return i,a
return -1,-1
n = input()
for i in range(n):
s = raw_input()
for w in s.split():
if len(w)==4:
a,b = checkkey(w)
if a!=-1: break
print affine(s,a,b) | p00040 |
<script type="text/x-mathjax-config">
MathJax.Hub.Config({ tex2jax: { inlineMath: [["$","$"], ["\\(","\\)"]], processEscapes: true }});
</script>
<script type="text/javascript" src="https://cdn.mathjax.org/mathjax/latest/MathJax.js?config=TeX-MML-AM_CHTML">
</script>
<H1>アフィン暗号</H1>
<p>
簡単な暗号法の一つに、アフィン暗号というものがあります。まず、アルファベット a〜z を a = 0, b = 1, c = 2,..., x = 23, y = 24, z = 25 と 0〜25 の数字に置き換えます。そして、以下の式で、原文のアルファベットを置換します。
</p>
<center>
<!--
<p>
F(γ) = (α・γ＋β) mod 26
</p>
-->
<p>
$F(\gamma) = (\alpha \cdot \gamma + \beta)$ mod $26$
</p>
</center>
<p>
ただし、mod 26 は 26 で割った余りを表します。例えば、$\alpha = 3, \beta = 2$ のとき、アルファベットの 'a' (=0) は、$F(0) = (3 \cdot 0 + 2)$ mod $26 = 2$ で 'c' に、アルファベットの 'n' (=13) は $F(13) = (3 \cdot 13 + 2)$ mod $26 = 15$ で 'p' に置換されます。
このとき、$\gamma$ に対する $F(\gamma)$ が必ず 1 対 1 で対応付けられるように、$\alpha$ と $\beta$ は慎重に選ばれているものとします（$\alpha$ と 26 が互いに素であることが条件）。$\alpha = 4, \beta = 7$ のときのように、$F('a') = 7, F('n') = 7$ と、'a' も 'n' も同じ 'h' に置換されるようなことはありません。また、アルファベット以外の文字は置換されません。
</p>
<p>
暗号化された文字列を元の文章に復号したものを出力するプログラムを作成してください。元の文章には、キーワードとして
</p>
<pre>
that
this
</pre>
<p>
のいずれかが必ず含まれているものとします。
</p>
<H2>Input</H2>
<p>
複数のデータセットが与えられます。１行目にデータセット数 $n$ ($n \leq 30$) が与えられます。続いて $n$ 行のデータが与えられます。各データセットに英小文字と空白からなる 256 文字以内の暗号化された文章が１行に与えられます。
</p>
<H2>Output</H2>
<p>
各データセットに対して、復号した元の文章を１行に出力して下さい。
</p>
<H2>Sample Input</H2>
<pre>
1
y eazqyp pnop pngtg ye obmpngt xmybp mr lygw
</pre>
<H2>Output for the Sample Input</H2>
<pre>
i submit that there is another point of view
</pre>
| 1
y eazqyp pnop pngtg ye obmpngt xmybp mr lygw
| i submit that there is another point of view
| 9,627 |
s231996323 | p00040 | u912237403 | 1394545531 | Python | Python | py | Accepted | 30 | 4424 | 775 | import string
A2Z="abcdefghijklmnopqrstuvwxyz"
R=range(26)
def decode(msg,L):
x=""
for c in msg: x+=(L[A2Z.index(c)] if "a"<=c<="z" else c)
return x
def affine(msg, a, b):
L="".join([A2Z[(i*a+b)%26]for i in R])
s = decode(msg,L)
return s
def rot(msg, a):
a = a % 26
L = A2Z[a:]+A2Z[:a]
s = decode(msg,L)
return s
def checkkey(s):
c0="t"
for i in R:
a = 0
x = affine(s,i,0)
c = A2Z.index(x[0])
if c!=19:
a = (19-c)%26
x = rot(x,a)
if x in['this','that']: return i,a
return -1,-1
n = input()
while n:
n-=1
s = raw_input()
for w in s.split():
if len(w)==4:
a,b = checkkey(w)
if a!=-1: break
print affine(s,a,b) | p00040 |
<script type="text/x-mathjax-config">
MathJax.Hub.Config({ tex2jax: { inlineMath: [["$","$"], ["\\(","\\)"]], processEscapes: true }});
</script>
<script type="text/javascript" src="https://cdn.mathjax.org/mathjax/latest/MathJax.js?config=TeX-MML-AM_CHTML">
</script>
<H1>アフィン暗号</H1>
<p>
簡単な暗号法の一つに、アフィン暗号というものがあります。まず、アルファベット a〜z を a = 0, b = 1, c = 2,..., x = 23, y = 24, z = 25 と 0〜25 の数字に置き換えます。そして、以下の式で、原文のアルファベットを置換します。
</p>
<center>
<!--
<p>
F(γ) = (α・γ＋β) mod 26
</p>
-->
<p>
$F(\gamma) = (\alpha \cdot \gamma + \beta)$ mod $26$
</p>
</center>
<p>
ただし、mod 26 は 26 で割った余りを表します。例えば、$\alpha = 3, \beta = 2$ のとき、アルファベットの 'a' (=0) は、$F(0) = (3 \cdot 0 + 2)$ mod $26 = 2$ で 'c' に、アルファベットの 'n' (=13) は $F(13) = (3 \cdot 13 + 2)$ mod $26 = 15$ で 'p' に置換されます。
このとき、$\gamma$ に対する $F(\gamma)$ が必ず 1 対 1 で対応付けられるように、$\alpha$ と $\beta$ は慎重に選ばれているものとします（$\alpha$ と 26 が互いに素であることが条件）。$\alpha = 4, \beta = 7$ のときのように、$F('a') = 7, F('n') = 7$ と、'a' も 'n' も同じ 'h' に置換されるようなことはありません。また、アルファベット以外の文字は置換されません。
</p>
<p>
暗号化された文字列を元の文章に復号したものを出力するプログラムを作成してください。元の文章には、キーワードとして
</p>
<pre>
that
this
</pre>
<p>
のいずれかが必ず含まれているものとします。
</p>
<H2>Input</H2>
<p>
複数のデータセットが与えられます。１行目にデータセット数 $n$ ($n \leq 30$) が与えられます。続いて $n$ 行のデータが与えられます。各データセットに英小文字と空白からなる 256 文字以内の暗号化された文章が１行に与えられます。
</p>
<H2>Output</H2>
<p>
各データセットに対して、復号した元の文章を１行に出力して下さい。
</p>
<H2>Sample Input</H2>
<pre>
1
y eazqyp pnop pngtg ye obmpngt xmybp mr lygw
</pre>
<H2>Output for the Sample Input</H2>
<pre>
i submit that there is another point of view
</pre>
| 1
y eazqyp pnop pngtg ye obmpngt xmybp mr lygw
| i submit that there is another point of view
| 9,628 |
s708195413 | p00040 | u912237403 | 1394545966 | Python | Python | py | Accepted | 20 | 4276 | 719 | A2Z="abcdefghijklmnopqrstuvwxyz"
def affine(msg, a, b):
s=""
for c in msg: s+=(A2Z[(A2Z.index(c)*a+b)%26] if "a"<=c<="z" else c)
return s
def rot(msg, a):
a = a % 26
L = A2Z[a:]+A2Z[:a]
s=""
for c in msg: s+=(L[A2Z.index(c)] if "a"<=c<="z" else c)
return s
def checkkey(s):
c0="t"
for i in range(26):
a = 0
x = affine(s,i,0)
c = A2Z.index(x[0])
if c!=19:
a = (19-c)%26
x = rot(x,a)
if x in['this','that']: return i,a
return -1,-1
n = input()
while n:
n-=1
s = raw_input()
for w in s.split():
if len(w)==4:
a,b = checkkey(w)
if a!=-1: break
print affine(s,a,b) | p00040 |
<script type="text/x-mathjax-config">
MathJax.Hub.Config({ tex2jax: { inlineMath: [["$","$"], ["\\(","\\)"]], processEscapes: true }});
</script>
<script type="text/javascript" src="https://cdn.mathjax.org/mathjax/latest/MathJax.js?config=TeX-MML-AM_CHTML">
</script>
<H1>アフィン暗号</H1>
<p>
簡単な暗号法の一つに、アフィン暗号というものがあります。まず、アルファベット a〜z を a = 0, b = 1, c = 2,..., x = 23, y = 24, z = 25 と 0〜25 の数字に置き換えます。そして、以下の式で、原文のアルファベットを置換します。
</p>
<center>
<!--
<p>
F(γ) = (α・γ＋β) mod 26
</p>
-->
<p>
$F(\gamma) = (\alpha \cdot \gamma + \beta)$ mod $26$
</p>
</center>
<p>
ただし、mod 26 は 26 で割った余りを表します。例えば、$\alpha = 3, \beta = 2$ のとき、アルファベットの 'a' (=0) は、$F(0) = (3 \cdot 0 + 2)$ mod $26 = 2$ で 'c' に、アルファベットの 'n' (=13) は $F(13) = (3 \cdot 13 + 2)$ mod $26 = 15$ で 'p' に置換されます。
このとき、$\gamma$ に対する $F(\gamma)$ が必ず 1 対 1 で対応付けられるように、$\alpha$ と $\beta$ は慎重に選ばれているものとします（$\alpha$ と 26 が互いに素であることが条件）。$\alpha = 4, \beta = 7$ のときのように、$F('a') = 7, F('n') = 7$ と、'a' も 'n' も同じ 'h' に置換されるようなことはありません。また、アルファベット以外の文字は置換されません。
</p>
<p>
暗号化された文字列を元の文章に復号したものを出力するプログラムを作成してください。元の文章には、キーワードとして
</p>
<pre>
that
this
</pre>
<p>
のいずれかが必ず含まれているものとします。
</p>
<H2>Input</H2>
<p>
複数のデータセットが与えられます。１行目にデータセット数 $n$ ($n \leq 30$) が与えられます。続いて $n$ 行のデータが与えられます。各データセットに英小文字と空白からなる 256 文字以内の暗号化された文章が１行に与えられます。
</p>
<H2>Output</H2>
<p>
各データセットに対して、復号した元の文章を１行に出力して下さい。
</p>
<H2>Sample Input</H2>
<pre>
1
y eazqyp pnop pngtg ye obmpngt xmybp mr lygw
</pre>
<H2>Output for the Sample Input</H2>
<pre>
i submit that there is another point of view
</pre>
| 1
y eazqyp pnop pngtg ye obmpngt xmybp mr lygw
| i submit that there is another point of view
| 9,629 |
s755740495 | p00040 | u912237403 | 1394546381 | Python | Python | py | Accepted | 20 | 4252 | 573 | A2Z="abcdefghijklmnopqrstuvwxyz"
def affine(msg, a, b):
s=""
for c in msg: s+=(A2Z[(A2Z.index(c)*a+b)%26] if "a"<=c<="z" else c)
return s
def checkkey(s):
for i in range(26):
a = 0
x = affine(s,i,0)
c = A2Z.index(x[0])
if c!=19:
a = (19-c)%26
x = affine(x,1,a)
if x in['this','that']: return i,a
return -1,-1
n = input()
while n:
n-=1
s = raw_input()
for w in s.split():
if len(w)==4:
a,b = checkkey(w)
if a!=-1: break
print affine(s,a,b) | p00040 |
<script type="text/x-mathjax-config">
MathJax.Hub.Config({ tex2jax: { inlineMath: [["$","$"], ["\\(","\\)"]], processEscapes: true }});
</script>
<script type="text/javascript" src="https://cdn.mathjax.org/mathjax/latest/MathJax.js?config=TeX-MML-AM_CHTML">
</script>
<H1>アフィン暗号</H1>
<p>
簡単な暗号法の一つに、アフィン暗号というものがあります。まず、アルファベット a〜z を a = 0, b = 1, c = 2,..., x = 23, y = 24, z = 25 と 0〜25 の数字に置き換えます。そして、以下の式で、原文のアルファベットを置換します。
</p>
<center>
<!--
<p>
F(γ) = (α・γ＋β) mod 26
</p>
-->
<p>
$F(\gamma) = (\alpha \cdot \gamma + \beta)$ mod $26$
</p>
</center>
<p>
ただし、mod 26 は 26 で割った余りを表します。例えば、$\alpha = 3, \beta = 2$ のとき、アルファベットの 'a' (=0) は、$F(0) = (3 \cdot 0 + 2)$ mod $26 = 2$ で 'c' に、アルファベットの 'n' (=13) は $F(13) = (3 \cdot 13 + 2)$ mod $26 = 15$ で 'p' に置換されます。
このとき、$\gamma$ に対する $F(\gamma)$ が必ず 1 対 1 で対応付けられるように、$\alpha$ と $\beta$ は慎重に選ばれているものとします（$\alpha$ と 26 が互いに素であることが条件）。$\alpha = 4, \beta = 7$ のときのように、$F('a') = 7, F('n') = 7$ と、'a' も 'n' も同じ 'h' に置換されるようなことはありません。また、アルファベット以外の文字は置換されません。
</p>
<p>
暗号化された文字列を元の文章に復号したものを出力するプログラムを作成してください。元の文章には、キーワードとして
</p>
<pre>
that
this
</pre>
<p>
のいずれかが必ず含まれているものとします。
</p>
<H2>Input</H2>
<p>
複数のデータセットが与えられます。１行目にデータセット数 $n$ ($n \leq 30$) が与えられます。続いて $n$ 行のデータが与えられます。各データセットに英小文字と空白からなる 256 文字以内の暗号化された文章が１行に与えられます。
</p>
<H2>Output</H2>
<p>
各データセットに対して、復号した元の文章を１行に出力して下さい。
</p>
<H2>Sample Input</H2>
<pre>
1
y eazqyp pnop pngtg ye obmpngt xmybp mr lygw
</pre>
<H2>Output for the Sample Input</H2>
<pre>
i submit that there is another point of view
</pre>
| 1
y eazqyp pnop pngtg ye obmpngt xmybp mr lygw
| i submit that there is another point of view
| 9,630 |
s145565192 | p00040 | u246033265 | 1396692445 | Python | Python | py | Accepted | 20 | 4256 | 527 | for i in range(int(raw_input())):
s = raw_input()
for a in range(1, 1000):
for b in range(26):
def f(s, a, b):
return ''.join([chr(((ord(c) - ord('a')) * a + b) % 26 + ord('a')) for c in s])
if f('that', a, b) in s or f('this', a, b) in s:
dic = dict([(chr((i * a + b) % 26 + ord('a')), chr(i + ord('a'))) for i in range(26)])
print ''.join([dic.get(c, c) for c in s])
break
else:
continue
break | p00040 |
<script type="text/x-mathjax-config">
MathJax.Hub.Config({ tex2jax: { inlineMath: [["$","$"], ["\\(","\\)"]], processEscapes: true }});
</script>
<script type="text/javascript" src="https://cdn.mathjax.org/mathjax/latest/MathJax.js?config=TeX-MML-AM_CHTML">
</script>
<H1>アフィン暗号</H1>
<p>
簡単な暗号法の一つに、アフィン暗号というものがあります。まず、アルファベット a〜z を a = 0, b = 1, c = 2,..., x = 23, y = 24, z = 25 と 0〜25 の数字に置き換えます。そして、以下の式で、原文のアルファベットを置換します。
</p>
<center>
<!--
<p>
F(γ) = (α・γ＋β) mod 26
</p>
-->
<p>
$F(\gamma) = (\alpha \cdot \gamma + \beta)$ mod $26$
</p>
</center>
<p>
ただし、mod 26 は 26 で割った余りを表します。例えば、$\alpha = 3, \beta = 2$ のとき、アルファベットの 'a' (=0) は、$F(0) = (3 \cdot 0 + 2)$ mod $26 = 2$ で 'c' に、アルファベットの 'n' (=13) は $F(13) = (3 \cdot 13 + 2)$ mod $26 = 15$ で 'p' に置換されます。
このとき、$\gamma$ に対する $F(\gamma)$ が必ず 1 対 1 で対応付けられるように、$\alpha$ と $\beta$ は慎重に選ばれているものとします（$\alpha$ と 26 が互いに素であることが条件）。$\alpha = 4, \beta = 7$ のときのように、$F('a') = 7, F('n') = 7$ と、'a' も 'n' も同じ 'h' に置換されるようなことはありません。また、アルファベット以外の文字は置換されません。
</p>
<p>
暗号化された文字列を元の文章に復号したものを出力するプログラムを作成してください。元の文章には、キーワードとして
</p>
<pre>
that
this
</pre>
<p>
のいずれかが必ず含まれているものとします。
</p>
<H2>Input</H2>
<p>
複数のデータセットが与えられます。１行目にデータセット数 $n$ ($n \leq 30$) が与えられます。続いて $n$ 行のデータが与えられます。各データセットに英小文字と空白からなる 256 文字以内の暗号化された文章が１行に与えられます。
</p>
<H2>Output</H2>
<p>
各データセットに対して、復号した元の文章を１行に出力して下さい。
</p>
<H2>Sample Input</H2>
<pre>
1
y eazqyp pnop pngtg ye obmpngt xmybp mr lygw
</pre>
<H2>Output for the Sample Input</H2>
<pre>
i submit that there is another point of view
</pre>
| 1
y eazqyp pnop pngtg ye obmpngt xmybp mr lygw
| i submit that there is another point of view
| 9,631 |
s140142214 | p00040 | u436634575 | 1401188733 | Python | Python3 | py | Accepted | 50 | 6720 | 450 | from itertools import product
alphabet = 'abcdefghijklmnopqrstuvwxyz'
def decrypt(s):
for a in range(1, 26, 2):
if a == 13: continue
for b in range(26):
x = ''.join(chr(ord('a') + (a * i + b) % 26) for i in range(26))
t = s.translate(str.maketrans(x, alphabet))
if 'this' in t or 'that' in t:
return t
n = int(input())
for i in range(n):
s = input()
print(decrypt(s)) | p00040 |
<script type="text/x-mathjax-config">
MathJax.Hub.Config({ tex2jax: { inlineMath: [["$","$"], ["\\(","\\)"]], processEscapes: true }});
</script>
<script type="text/javascript" src="https://cdn.mathjax.org/mathjax/latest/MathJax.js?config=TeX-MML-AM_CHTML">
</script>
<H1>アフィン暗号</H1>
<p>
簡単な暗号法の一つに、アフィン暗号というものがあります。まず、アルファベット a〜z を a = 0, b = 1, c = 2,..., x = 23, y = 24, z = 25 と 0〜25 の数字に置き換えます。そして、以下の式で、原文のアルファベットを置換します。
</p>
<center>
<!--
<p>
F(γ) = (α・γ＋β) mod 26
</p>
-->
<p>
$F(\gamma) = (\alpha \cdot \gamma + \beta)$ mod $26$
</p>
</center>
<p>
ただし、mod 26 は 26 で割った余りを表します。例えば、$\alpha = 3, \beta = 2$ のとき、アルファベットの 'a' (=0) は、$F(0) = (3 \cdot 0 + 2)$ mod $26 = 2$ で 'c' に、アルファベットの 'n' (=13) は $F(13) = (3 \cdot 13 + 2)$ mod $26 = 15$ で 'p' に置換されます。
このとき、$\gamma$ に対する $F(\gamma)$ が必ず 1 対 1 で対応付けられるように、$\alpha$ と $\beta$ は慎重に選ばれているものとします（$\alpha$ と 26 が互いに素であることが条件）。$\alpha = 4, \beta = 7$ のときのように、$F('a') = 7, F('n') = 7$ と、'a' も 'n' も同じ 'h' に置換されるようなことはありません。また、アルファベット以外の文字は置換されません。
</p>
<p>
暗号化された文字列を元の文章に復号したものを出力するプログラムを作成してください。元の文章には、キーワードとして
</p>
<pre>
that
this
</pre>
<p>
のいずれかが必ず含まれているものとします。
</p>
<H2>Input</H2>
<p>
複数のデータセットが与えられます。１行目にデータセット数 $n$ ($n \leq 30$) が与えられます。続いて $n$ 行のデータが与えられます。各データセットに英小文字と空白からなる 256 文字以内の暗号化された文章が１行に与えられます。
</p>
<H2>Output</H2>
<p>
各データセットに対して、復号した元の文章を１行に出力して下さい。
</p>
<H2>Sample Input</H2>
<pre>
1
y eazqyp pnop pngtg ye obmpngt xmybp mr lygw
</pre>
<H2>Output for the Sample Input</H2>
<pre>
i submit that there is another point of view
</pre>
| 1
y eazqyp pnop pngtg ye obmpngt xmybp mr lygw
| i submit that there is another point of view
| 9,632 |
s771220184 | p00040 | u990228206 | 1553247247 | Python | Python3 | py | Accepted | 80 | 5672 | 951 | n=int(input())
for i in range(n):
import math
s=input()
s_l=list(map(str,s.split()))
s_ci=[]
for i in s_l:
if len(i)==4:
k_l=[]
for j in i:
k=ord(j)-97
k_l.append(k)
s_ci.append(k_l)
a_list=[]
for i in range(1,1000):
if math.gcd(i,26)==1:a_list.append(i)
for a in a_list:
for b in range(26):
for k in s_ci:
word=""
for l in k:
word+=chr(((l*a-b)%26)+97)
if word=="that" or word=="this":break
if word=="that" or word=="this":break
if word=="that" or word=="this":break
s_l=[]
for i in s:
if i==" ":
s_l.append(-1)
else:
k=ord(i)-97
s_l.append(k)
ans=""
for i in s_l:
if i==-1:ans+=" "
else:
ans+=chr(((i*a-b)%26)+97)
print(ans)
| p00040 |
<script type="text/x-mathjax-config">
MathJax.Hub.Config({ tex2jax: { inlineMath: [["$","$"], ["\\(","\\)"]], processEscapes: true }});
</script>
<script type="text/javascript" src="https://cdn.mathjax.org/mathjax/latest/MathJax.js?config=TeX-MML-AM_CHTML">
</script>
<H1>アフィン暗号</H1>
<p>
簡単な暗号法の一つに、アフィン暗号というものがあります。まず、アルファベット a〜z を a = 0, b = 1, c = 2,..., x = 23, y = 24, z = 25 と 0〜25 の数字に置き換えます。そして、以下の式で、原文のアルファベットを置換します。
</p>
<center>
<!--
<p>
F(γ) = (α・γ＋β) mod 26
</p>
-->
<p>
$F(\gamma) = (\alpha \cdot \gamma + \beta)$ mod $26$
</p>
</center>
<p>
ただし、mod 26 は 26 で割った余りを表します。例えば、$\alpha = 3, \beta = 2$ のとき、アルファベットの 'a' (=0) は、$F(0) = (3 \cdot 0 + 2)$ mod $26 = 2$ で 'c' に、アルファベットの 'n' (=13) は $F(13) = (3 \cdot 13 + 2)$ mod $26 = 15$ で 'p' に置換されます。
このとき、$\gamma$ に対する $F(\gamma)$ が必ず 1 対 1 で対応付けられるように、$\alpha$ と $\beta$ は慎重に選ばれているものとします（$\alpha$ と 26 が互いに素であることが条件）。$\alpha = 4, \beta = 7$ のときのように、$F('a') = 7, F('n') = 7$ と、'a' も 'n' も同じ 'h' に置換されるようなことはありません。また、アルファベット以外の文字は置換されません。
</p>
<p>
暗号化された文字列を元の文章に復号したものを出力するプログラムを作成してください。元の文章には、キーワードとして
</p>
<pre>
that
this
</pre>
<p>
のいずれかが必ず含まれているものとします。
</p>
<H2>Input</H2>
<p>
複数のデータセットが与えられます。１行目にデータセット数 $n$ ($n \leq 30$) が与えられます。続いて $n$ 行のデータが与えられます。各データセットに英小文字と空白からなる 256 文字以内の暗号化された文章が１行に与えられます。
</p>
<H2>Output</H2>
<p>
各データセットに対して、復号した元の文章を１行に出力して下さい。
</p>
<H2>Sample Input</H2>
<pre>
1
y eazqyp pnop pngtg ye obmpngt xmybp mr lygw
</pre>
<H2>Output for the Sample Input</H2>
<pre>
i submit that there is another point of view
</pre>
| 1
y eazqyp pnop pngtg ye obmpngt xmybp mr lygw
| i submit that there is another point of view
| 9,633 |
s850313452 | p00040 | u079141094 | 1520903651 | Python | Python3 | py | Accepted | 50 | 5608 | 794 | A_BASE = ord('a')
A = [1, 3, 5, 7, 9, 11, 15, 17, 19, 21, 23, 25]
def brute_force(len4s, dwords):
b = 0
for a in A:
while b < 26:
for word in len4s:
dec = [(a * r + b) % 26 for r in word]
if dec in [[19, 7, 8, 18], [19, 7, 0, 19]]:
dec_words = [''.join([chr((a*r + b) % 26 + A_BASE) for r in dw]) for dw in dwords]
return ' '.join(dec_words)
b += 1
b = 0
def solve():
n = int(input())
for _ in range(n):
text = input()
words = text.split()
dwords = [[ord(ch) - A_BASE for ch in word] for word in words]
len4s = [dw for dw in dwords if len(dw) == 4]
print(brute_force(len4s, dwords))
if __name__ == "__main__":
solve()
| p00040 |
<script type="text/x-mathjax-config">
MathJax.Hub.Config({ tex2jax: { inlineMath: [["$","$"], ["\\(","\\)"]], processEscapes: true }});
</script>
<script type="text/javascript" src="https://cdn.mathjax.org/mathjax/latest/MathJax.js?config=TeX-MML-AM_CHTML">
</script>
<H1>アフィン暗号</H1>
<p>
簡単な暗号法の一つに、アフィン暗号というものがあります。まず、アルファベット a〜z を a = 0, b = 1, c = 2,..., x = 23, y = 24, z = 25 と 0〜25 の数字に置き換えます。そして、以下の式で、原文のアルファベットを置換します。
</p>
<center>
<!--
<p>
F(γ) = (α・γ＋β) mod 26
</p>
-->
<p>
$F(\gamma) = (\alpha \cdot \gamma + \beta)$ mod $26$
</p>
</center>
<p>
ただし、mod 26 は 26 で割った余りを表します。例えば、$\alpha = 3, \beta = 2$ のとき、アルファベットの 'a' (=0) は、$F(0) = (3 \cdot 0 + 2)$ mod $26 = 2$ で 'c' に、アルファベットの 'n' (=13) は $F(13) = (3 \cdot 13 + 2)$ mod $26 = 15$ で 'p' に置換されます。
このとき、$\gamma$ に対する $F(\gamma)$ が必ず 1 対 1 で対応付けられるように、$\alpha$ と $\beta$ は慎重に選ばれているものとします（$\alpha$ と 26 が互いに素であることが条件）。$\alpha = 4, \beta = 7$ のときのように、$F('a') = 7, F('n') = 7$ と、'a' も 'n' も同じ 'h' に置換されるようなことはありません。また、アルファベット以外の文字は置換されません。
</p>
<p>
暗号化された文字列を元の文章に復号したものを出力するプログラムを作成してください。元の文章には、キーワードとして
</p>
<pre>
that
this
</pre>
<p>
のいずれかが必ず含まれているものとします。
</p>
<H2>Input</H2>
<p>
複数のデータセットが与えられます。１行目にデータセット数 $n$ ($n \leq 30$) が与えられます。続いて $n$ 行のデータが与えられます。各データセットに英小文字と空白からなる 256 文字以内の暗号化された文章が１行に与えられます。
</p>
<H2>Output</H2>
<p>
各データセットに対して、復号した元の文章を１行に出力して下さい。
</p>
<H2>Sample Input</H2>
<pre>
1
y eazqyp pnop pngtg ye obmpngt xmybp mr lygw
</pre>
<H2>Output for the Sample Input</H2>
<pre>
i submit that there is another point of view
</pre>
| 1
y eazqyp pnop pngtg ye obmpngt xmybp mr lygw
| i submit that there is another point of view
| 9,634 |
s069337243 | p00043 | u352394527 | 1530888576 | Python | Python3 | py | Accepted | 30 | 5608 | 1,006 | def is_solved(nums):
keys = set(nums)
for key in keys:
if nums.count(key) >= 2:
tmp = nums[:]
tmp.remove(key)
tmp.remove(key)
for key in keys:
key_count = tmp.count(key)
if key_count == 4:
if key + 1 in tmp and key + 2 in tmp:
for _ in range(4): tmp.remove(key)
tmp.remove(key + 1)
tmp.remove(key + 2)
elif key_count == 3:
for _ in range(3): tmp.remove(key)
elif tmp.count(key + 1) >= key_count and tmp.count(key + 2) >= key_count:
for _ in range(key_count):
tmp.remove(key)
tmp.remove(key + 1)
tmp.remove(key + 2)
if tmp == []:
return True
return False
while True:
try:
puzzle = list(map(int, list(input())))
ans = []
for i in range(1, 10):
if puzzle.count(i) <= 3 and is_solved(puzzle + [i]):
ans.append(i)
if ans:
print(*ans)
else:
print(0)
except EOFError:
break
| p00043 |
<H1>パズル</H1>
<p>
1 〜 9 の数字を 14 個組み合わせて完成させるパズルがあります。与えられた 13 個の数字にもうひとつ数字を付け加えて完成させます。
</p>
<p>
パズルの完成条件は
</p>
<ul>
<li>同じ数字を２つ組み合わせたものが必ずひとつ必要です。</li>
<li>残りの12 個の数字は、３個の数字の組み合わせ４つです。<br>
３個の数字の組み合わせ方は、同じ数字を３つ組み合わせたものか、または３つの連続する数字を組み合わせたものです。ただし、9 1 2 のような並びは連続する数字とは認められません。</li>
<li>同じ数字は4 回まで使えます。</li>
</ul>
<p>
13 個の数字からなる文字列を読み込んで、パズルを完成することができる数字を昇順に全て出力するプログラムを作成してください。なお、1〜9 のどの数字を付け加えてもパズルを完成させることができないときは 0 を出力してください。
</p>
<p>例えば与えられた文字列が 3456666777999 の場合<br/>
<br/>
「2」があれば、 <span>234 567 666 77 999</span><br/>
「3」があれば、 <span>33 456 666 777 999</span><br/>
「5」があれば、 <span>345 567 666 77 999</span><br/>
「8」があれば、 <span>345 666 678 77 999</span><br/>
<br/>
というふうに、2 3 5 8 のいずれかの数字が付け加えられるとパズルは完成します。「6」でも整いますが、5 回目の使用になるので、この例では使えないことに注意してください。
</p>
<H2>Input</H2>
<p>
入力は複数のデータセットからなります。各データセットとして、13 個の数字が１行に与えられます。データセットの数は 50 を超えません。
</p>
<H2>Output</H2>
<p>
データセットごとに、パズルを完成させることができる数字を昇順に空白区切りで１行に出力します。
</p>
<H2>Sample Input</H2>
<pre>
3649596966777
6358665788577
9118992346175
9643871425498
7755542764533
1133557799246
</pre>
<H2>Output for the Sample Input</H2>
<pre>
2 3 5 8
3 4
1 2 3 4 5 6 7 8 9
7 8 9
1 2 3 4 6 7 8
0
</pre>
| 3649596966777
6358665788577
9118992346175
9643871425498
7755542764533
1133557799246
| 2 3 5 8
3 4
1 2 3 4 5 6 7 8 9
7 8 9
1 2 3 4 6 7 8
0
| 9,674 |
s911071232 | p00043 | u873482706 | 1434860870 | Python | Python | py | Accepted | 60 | 4328 | 1,806 | import sys
def pokakito(num_line):
if not num_line and flag == 1:
result_lis.append(check_num)
return True
for num in num_line:
if three(num, num_line): return True
if two(num, num_line): return True
if straight(num, num_line): return True
def three(num, num_line):
count = 0
for check in num_line[:3]:
if check == num:
count += 1
else:
if count == 3:
if pokakito(num_line[3:]): return True
def two(num, num_line):
global flag
count = 0
for check in num_line[:2]:
if check == num:
count += 1
else:
if count == 2:
flag += 1
if pokakito(num_line[2:]): return True
flag -= 1
def straight(num, num_line):
for check in [num,num+1,num+2]:
if not check in num_line:
break
else:
for n in [num,num+1,num+2]:
index = 0
while num_line:
if num_line[index] == n:
del num_line[index]
break
index += 1
else:
if pokakito(num_line): return True
flag = 0
result_lis = []
check_num = 0
for input_line in sys.stdin:
for i in range(9):
check_num = i+1
input_line = input_line.rstrip()
line = sorted(input_line + str(check_num))
line = ''.join(line)
index = line.find(str(check_num))
if line[index:index+5] == str(check_num)*5:
continue
pokakito([int(char) for char in line])
result = sorted([str(num) for num in result_lis])
flag = 0
else:
if result_lis:
print ' '.join(result)
else:
print 0
flag = 0
result_lis = []
check_num = 0 | p00043 |
<H1>パズル</H1>
<p>
1 〜 9 の数字を 14 個組み合わせて完成させるパズルがあります。与えられた 13 個の数字にもうひとつ数字を付け加えて完成させます。
</p>
<p>
パズルの完成条件は
</p>
<ul>
<li>同じ数字を２つ組み合わせたものが必ずひとつ必要です。</li>
<li>残りの12 個の数字は、３個の数字の組み合わせ４つです。<br>
３個の数字の組み合わせ方は、同じ数字を３つ組み合わせたものか、または３つの連続する数字を組み合わせたものです。ただし、9 1 2 のような並びは連続する数字とは認められません。</li>
<li>同じ数字は4 回まで使えます。</li>
</ul>
<p>
13 個の数字からなる文字列を読み込んで、パズルを完成することができる数字を昇順に全て出力するプログラムを作成してください。なお、1〜9 のどの数字を付け加えてもパズルを完成させることができないときは 0 を出力してください。
</p>
<p>例えば与えられた文字列が 3456666777999 の場合<br/>
<br/>
「2」があれば、 <span>234 567 666 77 999</span><br/>
「3」があれば、 <span>33 456 666 777 999</span><br/>
「5」があれば、 <span>345 567 666 77 999</span><br/>
「8」があれば、 <span>345 666 678 77 999</span><br/>
<br/>
というふうに、2 3 5 8 のいずれかの数字が付け加えられるとパズルは完成します。「6」でも整いますが、5 回目の使用になるので、この例では使えないことに注意してください。
</p>
<H2>Input</H2>
<p>
入力は複数のデータセットからなります。各データセットとして、13 個の数字が１行に与えられます。データセットの数は 50 を超えません。
</p>
<H2>Output</H2>
<p>
データセットごとに、パズルを完成させることができる数字を昇順に空白区切りで１行に出力します。
</p>
<H2>Sample Input</H2>
<pre>
3649596966777
6358665788577
9118992346175
9643871425498
7755542764533
1133557799246
</pre>
<H2>Output for the Sample Input</H2>
<pre>
2 3 5 8
3 4
1 2 3 4 5 6 7 8 9
7 8 9
1 2 3 4 6 7 8
0
</pre>
| 3649596966777
6358665788577
9118992346175
9643871425498
7755542764533
1133557799246
| 2 3 5 8
3 4
1 2 3 4 5 6 7 8 9
7 8 9
1 2 3 4 6 7 8
0
| 9,675 |
s590492330 | p00043 | u140201022 | 1449564987 | Python | Python | py | Accepted | 50 | 6368 | 1,151 | #memo roiti 899204
def rm_s(h):
seth=set(h)
for hai in seth:
if set([hai,hai+1,hai+2])<=seth:
if len(h)==3:
return 1
h1=h[:]
for i in range(3):
h1.remove(hai+i)
return is_hora(h1)
else:
return 0
def rm_k(h):
for hai in set(h):
if h.count(hai)>=3:
if len(h)==3:
return 1
h1=h[:]
for i in range(3):
h1.remove(hai)
return is_hora(h1)
else:
return 0
def is_hora(h):
return rm_k(h) or rm_s(h)
while 1:
try:
h=map(int,raw_input())
ans=[]
for a in range(1,10):
if h.count(a)<=3:
h1=h[:]+[a]
for d in set(h1):
if 2<= h1.count(d):
h1=h[:]+[a]
h1.remove(d)
h1.remove(d)
if is_hora(h1):
ans.append(a)
break
print ' '.join(map(str, sorted(ans))) if len(ans)>0 else 0
except:
break | p00043 |
<H1>パズル</H1>
<p>
1 〜 9 の数字を 14 個組み合わせて完成させるパズルがあります。与えられた 13 個の数字にもうひとつ数字を付け加えて完成させます。
</p>
<p>
パズルの完成条件は
</p>
<ul>
<li>同じ数字を２つ組み合わせたものが必ずひとつ必要です。</li>
<li>残りの12 個の数字は、３個の数字の組み合わせ４つです。<br>
３個の数字の組み合わせ方は、同じ数字を３つ組み合わせたものか、または３つの連続する数字を組み合わせたものです。ただし、9 1 2 のような並びは連続する数字とは認められません。</li>
<li>同じ数字は4 回まで使えます。</li>
</ul>
<p>
13 個の数字からなる文字列を読み込んで、パズルを完成することができる数字を昇順に全て出力するプログラムを作成してください。なお、1〜9 のどの数字を付け加えてもパズルを完成させることができないときは 0 を出力してください。
</p>
<p>例えば与えられた文字列が 3456666777999 の場合<br/>
<br/>
「2」があれば、 <span>234 567 666 77 999</span><br/>
「3」があれば、 <span>33 456 666 777 999</span><br/>
「5」があれば、 <span>345 567 666 77 999</span><br/>
「8」があれば、 <span>345 666 678 77 999</span><br/>
<br/>
というふうに、2 3 5 8 のいずれかの数字が付け加えられるとパズルは完成します。「6」でも整いますが、5 回目の使用になるので、この例では使えないことに注意してください。
</p>
<H2>Input</H2>
<p>
入力は複数のデータセットからなります。各データセットとして、13 個の数字が１行に与えられます。データセットの数は 50 を超えません。
</p>
<H2>Output</H2>
<p>
データセットごとに、パズルを完成させることができる数字を昇順に空白区切りで１行に出力します。
</p>
<H2>Sample Input</H2>
<pre>
3649596966777
6358665788577
9118992346175
9643871425498
7755542764533
1133557799246
</pre>
<H2>Output for the Sample Input</H2>
<pre>
2 3 5 8
3 4
1 2 3 4 5 6 7 8 9
7 8 9
1 2 3 4 6 7 8
0
</pre>
| 3649596966777
6358665788577
9118992346175
9643871425498
7755542764533
1133557799246
| 2 3 5 8
3 4
1 2 3 4 5 6 7 8 9
7 8 9
1 2 3 4 6 7 8
0
| 9,676 |
s750214267 | p00043 | u186082958 | 1481055613 | Python | Python3 | py | Accepted | 30 | 7652 | 997 |
def check(nums):
for i in range(9):
if(nums[i]>4):return False
for head in range(9):
anums=nums[:]
if(anums[head]<2):continue
anums[head]-=2
for i in range(9):
if(anums[i]>=3):
anums[i]-=3
while(anums[i]>0):
if i>=7:break
ok=True
for j in range(i,i+3):
if anums[j]<=0:
ok=False
if not ok:
break
for j in range(i,i+3):
anums[j]-=1
if not any(anums):
return True
return False
while True:
st=''
try:
st=input()
except:
break
nums=[0 for i in range(9)]
for c in st:
nums[int(c)-1]+=1
anss=[]
for n in range(0,9):
nums[n]+=1
if(check(nums[:])):anss.append(n+1)
nums[n]-=1
if(len(anss)==0):anss.append(0)
print(' '.join(map(str,anss))) | p00043 |
<H1>パズル</H1>
<p>
1 〜 9 の数字を 14 個組み合わせて完成させるパズルがあります。与えられた 13 個の数字にもうひとつ数字を付け加えて完成させます。
</p>
<p>
パズルの完成条件は
</p>
<ul>
<li>同じ数字を２つ組み合わせたものが必ずひとつ必要です。</li>
<li>残りの12 個の数字は、３個の数字の組み合わせ４つです。<br>
３個の数字の組み合わせ方は、同じ数字を３つ組み合わせたものか、または３つの連続する数字を組み合わせたものです。ただし、9 1 2 のような並びは連続する数字とは認められません。</li>
<li>同じ数字は4 回まで使えます。</li>
</ul>
<p>
13 個の数字からなる文字列を読み込んで、パズルを完成することができる数字を昇順に全て出力するプログラムを作成してください。なお、1〜9 のどの数字を付け加えてもパズルを完成させることができないときは 0 を出力してください。
</p>
<p>例えば与えられた文字列が 3456666777999 の場合<br/>
<br/>
「2」があれば、 <span>234 567 666 77 999</span><br/>
「3」があれば、 <span>33 456 666 777 999</span><br/>
「5」があれば、 <span>345 567 666 77 999</span><br/>
「8」があれば、 <span>345 666 678 77 999</span><br/>
<br/>
というふうに、2 3 5 8 のいずれかの数字が付け加えられるとパズルは完成します。「6」でも整いますが、5 回目の使用になるので、この例では使えないことに注意してください。
</p>
<H2>Input</H2>
<p>
入力は複数のデータセットからなります。各データセットとして、13 個の数字が１行に与えられます。データセットの数は 50 を超えません。
</p>
<H2>Output</H2>
<p>
データセットごとに、パズルを完成させることができる数字を昇順に空白区切りで１行に出力します。
</p>
<H2>Sample Input</H2>
<pre>
3649596966777
6358665788577
9118992346175
9643871425498
7755542764533
1133557799246
</pre>
<H2>Output for the Sample Input</H2>
<pre>
2 3 5 8
3 4
1 2 3 4 5 6 7 8 9
7 8 9
1 2 3 4 6 7 8
0
</pre>
| 3649596966777
6358665788577
9118992346175
9643871425498
7755542764533
1133557799246
| 2 3 5 8
3 4
1 2 3 4 5 6 7 8 9
7 8 9
1 2 3 4 6 7 8
0
| 9,677 |
s020075829 | p00043 | u901080241 | 1491976633 | Python | Python3 | py | Accepted | 20 | 7620 | 1,154 | def is_hora(lst):
for i in range(1,10):
if lst[i] >= 2:
if(is_4chunk(lst,i)): return True
return False
def is_4chunk(lst,atama):
searchlist = [0]*10
for i in range(10):
searchlist[i] = lst[i]
searchlist[atama] -= 2
for i in range(1,8):
if searchlist[i] < 0: return False
if searchlist[i] >=3: searchlist[i]-=3
if searchlist[i] ==1:
searchlist[i]-=1
searchlist[i+1]-=1
searchlist[i+2]-=1
elif searchlist[i] ==2:
searchlist[i]-=2
searchlist[i+1]-=2
searchlist[i+2]-=2
return (searchlist[8] == 0 or searchlist[8] == 3) and (searchlist[9] == 0 or searchlist[9] == 3)
while True:
try:
instr = input()
pai = [0]*10
ans = []
for i in range(13):
pai[(int(instr[i]))] += 1
for i in range(1,10):
if pai[i] == 4: continue
pai[i] += 1
if is_hora(pai): ans.append(i)
pai[i] -= 1
if len(ans)!=0:
print(" ".join(list(map(str,ans))))
else: print(0)
except EOFError: break | p00043 |
<H1>パズル</H1>
<p>
1 〜 9 の数字を 14 個組み合わせて完成させるパズルがあります。与えられた 13 個の数字にもうひとつ数字を付け加えて完成させます。
</p>
<p>
パズルの完成条件は
</p>
<ul>
<li>同じ数字を２つ組み合わせたものが必ずひとつ必要です。</li>
<li>残りの12 個の数字は、３個の数字の組み合わせ４つです。<br>
３個の数字の組み合わせ方は、同じ数字を３つ組み合わせたものか、または３つの連続する数字を組み合わせたものです。ただし、9 1 2 のような並びは連続する数字とは認められません。</li>
<li>同じ数字は4 回まで使えます。</li>
</ul>
<p>
13 個の数字からなる文字列を読み込んで、パズルを完成することができる数字を昇順に全て出力するプログラムを作成してください。なお、1〜9 のどの数字を付け加えてもパズルを完成させることができないときは 0 を出力してください。
</p>
<p>例えば与えられた文字列が 3456666777999 の場合<br/>
<br/>
「2」があれば、 <span>234 567 666 77 999</span><br/>
「3」があれば、 <span>33 456 666 777 999</span><br/>
「5」があれば、 <span>345 567 666 77 999</span><br/>
「8」があれば、 <span>345 666 678 77 999</span><br/>
<br/>
というふうに、2 3 5 8 のいずれかの数字が付け加えられるとパズルは完成します。「6」でも整いますが、5 回目の使用になるので、この例では使えないことに注意してください。
</p>
<H2>Input</H2>
<p>
入力は複数のデータセットからなります。各データセットとして、13 個の数字が１行に与えられます。データセットの数は 50 を超えません。
</p>
<H2>Output</H2>
<p>
データセットごとに、パズルを完成させることができる数字を昇順に空白区切りで１行に出力します。
</p>
<H2>Sample Input</H2>
<pre>
3649596966777
6358665788577
9118992346175
9643871425498
7755542764533
1133557799246
</pre>
<H2>Output for the Sample Input</H2>
<pre>
2 3 5 8
3 4
1 2 3 4 5 6 7 8 9
7 8 9
1 2 3 4 6 7 8
0
</pre>
| 3649596966777
6358665788577
9118992346175
9643871425498
7755542764533
1133557799246
| 2 3 5 8
3 4
1 2 3 4 5 6 7 8 9
7 8 9
1 2 3 4 6 7 8
0
| 9,678 |
s613447063 | p00043 | u724963150 | 1506892435 | Python | Python3 | py | Accepted | 80 | 7472 | 972 | def Solve(c,s):
if s:
if max(c)>4:return False
for i in range(9):
if c[i]>=2:
cc=c[:]
cc[i]-=2
if Solve(cc,False):return True
else:
check=0
for i in range(4):check+=c.count(3*i)
if check==9:return True
else:
for i in range(7):
if c[i]>=1:
cc=c[:]
isneg=False
for j in range(3):
cc[i+j]-=1
if cc[i+j]<0:
isneg=True
break
if isneg==False and Solve(cc,False):return True
_in=""
while True:
ans=[]
try:_in=input()
except EOFError:break
for i in range(9):
l=(_in+str(i+1))[::1]
count=[l.count(str(j+1))for j in range(9)]
if Solve(count,True):ans.append(str(i+1))
print(0 if len(ans)==0 else " ".join(ans)) | p00043 |
<H1>パズル</H1>
<p>
1 〜 9 の数字を 14 個組み合わせて完成させるパズルがあります。与えられた 13 個の数字にもうひとつ数字を付け加えて完成させます。
</p>
<p>
パズルの完成条件は
</p>
<ul>
<li>同じ数字を２つ組み合わせたものが必ずひとつ必要です。</li>
<li>残りの12 個の数字は、３個の数字の組み合わせ４つです。<br>
３個の数字の組み合わせ方は、同じ数字を３つ組み合わせたものか、または３つの連続する数字を組み合わせたものです。ただし、9 1 2 のような並びは連続する数字とは認められません。</li>
<li>同じ数字は4 回まで使えます。</li>
</ul>
<p>
13 個の数字からなる文字列を読み込んで、パズルを完成することができる数字を昇順に全て出力するプログラムを作成してください。なお、1〜9 のどの数字を付け加えてもパズルを完成させることができないときは 0 を出力してください。
</p>
<p>例えば与えられた文字列が 3456666777999 の場合<br/>
<br/>
「2」があれば、 <span>234 567 666 77 999</span><br/>
「3」があれば、 <span>33 456 666 777 999</span><br/>
「5」があれば、 <span>345 567 666 77 999</span><br/>
「8」があれば、 <span>345 666 678 77 999</span><br/>
<br/>
というふうに、2 3 5 8 のいずれかの数字が付け加えられるとパズルは完成します。「6」でも整いますが、5 回目の使用になるので、この例では使えないことに注意してください。
</p>
<H2>Input</H2>
<p>
入力は複数のデータセットからなります。各データセットとして、13 個の数字が１行に与えられます。データセットの数は 50 を超えません。
</p>
<H2>Output</H2>
<p>
データセットごとに、パズルを完成させることができる数字を昇順に空白区切りで１行に出力します。
</p>
<H2>Sample Input</H2>
<pre>
3649596966777
6358665788577
9118992346175
9643871425498
7755542764533
1133557799246
</pre>
<H2>Output for the Sample Input</H2>
<pre>
2 3 5 8
3 4
1 2 3 4 5 6 7 8 9
7 8 9
1 2 3 4 6 7 8
0
</pre>
| 3649596966777
6358665788577
9118992346175
9643871425498
7755542764533
1133557799246
| 2 3 5 8
3 4
1 2 3 4 5 6 7 8 9
7 8 9
1 2 3 4 6 7 8
0
| 9,679 |
s927133770 | p00043 | u811733736 | 1507363595 | Python | Python3 | py | Accepted | 40 | 7780 | 2,280 | # -*- coding: utf-8 -*-
"""
http://judge.u-aizu.ac.jp/onlinejudge/description.jsp?id=0043
"""
import sys
from sys import stdin
input = stdin.readline
def dfs(hand, count):
# ??¢??????n????????£??????????????¨????¢??????????
if count < 1:
return True
for i, n in enumerate(hand[1:], start=1):
if n == 0:
continue
if n >= 3:
c_hand = hand[:]
c_hand[i] -= 3
res = dfs(c_hand[:], count-1)
if res:
return True
if i > 7:
return False
if hand[i+1] >= 1 and hand[i+2] >= 1:
c_hand = hand[:]
c_hand[i] -= 1
c_hand[i+1] -= 1
c_hand[i+2] -= 1
res = dfs(c_hand[:], count-1)
if res:
return True
else:
return False
def solve(data):
"""
1) ??????1??????????????¨
2) ??¢??????4??????????????¨
3) ????????°??????5?????\??????????????¨
:param data: ??????
:return: ??????????????????
"""
ans = [] # ???????????????????¨????
# ?????¨?????????l???9??????????????????????????????????????????????????§??????????????????????????????????????§????????°????????????????????°????????????????????????
for tsumo in range(1, 10):
my_hand = data[:]
my_hand.append(tsumo) # ????????????????????°??????1????¶????
remaining = [0] * 10
for n in my_hand:
remaining[n] += 1
if max(remaining) > 4: # ?????????3?¢????
continue
# ?????????1????¢????
for i, atama in enumerate(remaining[1:], start=1):
if atama >= 2:
c_remaining = remaining[:]
c_remaining[i] -= 2
res = dfs(c_remaining[:], 4)
if res:
ans.append(tsumo)
break
return ans
def main(args):
#hand = '3649596966777'
#data = list(map(int, list(hand)))
for line in sys.stdin:
data = list(map(int, list(line.strip())))
result = solve(data)
if len(result) > 0:
print(*result)
else:
print(0)
if __name__ == '__main__':
main(sys.argv[1:])
| p00043 |
<H1>パズル</H1>
<p>
1 〜 9 の数字を 14 個組み合わせて完成させるパズルがあります。与えられた 13 個の数字にもうひとつ数字を付け加えて完成させます。
</p>
<p>
パズルの完成条件は
</p>
<ul>
<li>同じ数字を２つ組み合わせたものが必ずひとつ必要です。</li>
<li>残りの12 個の数字は、３個の数字の組み合わせ４つです。<br>
３個の数字の組み合わせ方は、同じ数字を３つ組み合わせたものか、または３つの連続する数字を組み合わせたものです。ただし、9 1 2 のような並びは連続する数字とは認められません。</li>
<li>同じ数字は4 回まで使えます。</li>
</ul>
<p>
13 個の数字からなる文字列を読み込んで、パズルを完成することができる数字を昇順に全て出力するプログラムを作成してください。なお、1〜9 のどの数字を付け加えてもパズルを完成させることができないときは 0 を出力してください。
</p>
<p>例えば与えられた文字列が 3456666777999 の場合<br/>
<br/>
「2」があれば、 <span>234 567 666 77 999</span><br/>
「3」があれば、 <span>33 456 666 777 999</span><br/>
「5」があれば、 <span>345 567 666 77 999</span><br/>
「8」があれば、 <span>345 666 678 77 999</span><br/>
<br/>
というふうに、2 3 5 8 のいずれかの数字が付け加えられるとパズルは完成します。「6」でも整いますが、5 回目の使用になるので、この例では使えないことに注意してください。
</p>
<H2>Input</H2>
<p>
入力は複数のデータセットからなります。各データセットとして、13 個の数字が１行に与えられます。データセットの数は 50 を超えません。
</p>
<H2>Output</H2>
<p>
データセットごとに、パズルを完成させることができる数字を昇順に空白区切りで１行に出力します。
</p>
<H2>Sample Input</H2>
<pre>
3649596966777
6358665788577
9118992346175
9643871425498
7755542764533
1133557799246
</pre>
<H2>Output for the Sample Input</H2>
<pre>
2 3 5 8
3 4
1 2 3 4 5 6 7 8 9
7 8 9
1 2 3 4 6 7 8
0
</pre>
| 3649596966777
6358665788577
9118992346175
9643871425498
7755542764533
1133557799246
| 2 3 5 8
3 4
1 2 3 4 5 6 7 8 9
7 8 9
1 2 3 4 6 7 8
0
| 9,680 |
s334632573 | p00043 | u024715419 | 1517896511 | Python | Python3 | py | Accepted | 90 | 5608 | 1,182 | def check_set(hand):
set_list = []
for i in range(9):
if hand.count(i + 1) >= 3:
set_list.append([i + 1, i + 1, i + 1])
if i + 1 in hand and i + 2 in hand and i + 3 in hand:
set_list.append([i + 1, i + 2, i + 3])
return set_list
def check_winning(hand):
if len(hand) == 2:
if hand[0] == hand[1]:
return True
else:
return False
set_tmp_list = check_set(hand)
if len(set_tmp_list) == 0:
return False
for set_tmp in set_tmp_list:
hand_tmp = hand[:]
for i in range(3):
hand_tmp.remove(set_tmp[i])
res = check_winning(hand_tmp)
if res:
break
else:
continue
return res
while True:
try:
inp = list(map(int, list(input())))
ans = []
for i in range(9):
if inp.count(i + 1) >= 4:
continue
inp_tmp = inp[:]
inp_tmp.append(i + 1)
if check_winning(inp_tmp):
ans.append(i + 1)
if len(ans) == 0:
print(0)
else:
print(*ans)
except:
break
| p00043 |
<H1>パズル</H1>
<p>
1 〜 9 の数字を 14 個組み合わせて完成させるパズルがあります。与えられた 13 個の数字にもうひとつ数字を付け加えて完成させます。
</p>
<p>
パズルの完成条件は
</p>
<ul>
<li>同じ数字を２つ組み合わせたものが必ずひとつ必要です。</li>
<li>残りの12 個の数字は、３個の数字の組み合わせ４つです。<br>
３個の数字の組み合わせ方は、同じ数字を３つ組み合わせたものか、または３つの連続する数字を組み合わせたものです。ただし、9 1 2 のような並びは連続する数字とは認められません。</li>
<li>同じ数字は4 回まで使えます。</li>
</ul>
<p>
13 個の数字からなる文字列を読み込んで、パズルを完成することができる数字を昇順に全て出力するプログラムを作成してください。なお、1〜9 のどの数字を付け加えてもパズルを完成させることができないときは 0 を出力してください。
</p>
<p>例えば与えられた文字列が 3456666777999 の場合<br/>
<br/>
「2」があれば、 <span>234 567 666 77 999</span><br/>
「3」があれば、 <span>33 456 666 777 999</span><br/>
「5」があれば、 <span>345 567 666 77 999</span><br/>
「8」があれば、 <span>345 666 678 77 999</span><br/>
<br/>
というふうに、2 3 5 8 のいずれかの数字が付け加えられるとパズルは完成します。「6」でも整いますが、5 回目の使用になるので、この例では使えないことに注意してください。
</p>
<H2>Input</H2>
<p>
入力は複数のデータセットからなります。各データセットとして、13 個の数字が１行に与えられます。データセットの数は 50 を超えません。
</p>
<H2>Output</H2>
<p>
データセットごとに、パズルを完成させることができる数字を昇順に空白区切りで１行に出力します。
</p>
<H2>Sample Input</H2>
<pre>
3649596966777
6358665788577
9118992346175
9643871425498
7755542764533
1133557799246
</pre>
<H2>Output for the Sample Input</H2>
<pre>
2 3 5 8
3 4
1 2 3 4 5 6 7 8 9
7 8 9
1 2 3 4 6 7 8
0
</pre>
| 3649596966777
6358665788577
9118992346175
9643871425498
7755542764533
1133557799246
| 2 3 5 8
3 4
1 2 3 4 5 6 7 8 9
7 8 9
1 2 3 4 6 7 8
0
| 9,681 |
s219248606 | p00043 | u150984829 | 1518744842 | Python | Python3 | py | Accepted | 50 | 5576 | 521 | import sys
def f(c,h=0):
if 2 in c and sum(c)==2:return 1
if 5 in c:return 0 # sum(c)==2
if 4 in c:
k=c.index(4);c[k]-=3
if f(c,h+1):return 1
c[k]+=3
if 3 in c:
k=c.index(3);c[k]-=3
if f(c,h+1):return 1
c[k]+=3
for i in range(7):
if c[i]and c[i+1]and c[i+2]:
c[i]-=1;c[i+1]-=1;c[i+2]-=1
if f(c,h+1):return 1
c[i]+=1;c[i+1]+=1;c[i+2]+=1
n='123456789'
for e in sys.stdin:
e=list(e)
a=[i for i in n if f([(e+[i]).count(j)for j in n])]
if a:print(*a)
else:print(0)
| p00043 |
<H1>パズル</H1>
<p>
1 〜 9 の数字を 14 個組み合わせて完成させるパズルがあります。与えられた 13 個の数字にもうひとつ数字を付け加えて完成させます。
</p>
<p>
パズルの完成条件は
</p>
<ul>
<li>同じ数字を２つ組み合わせたものが必ずひとつ必要です。</li>
<li>残りの12 個の数字は、３個の数字の組み合わせ４つです。<br>
３個の数字の組み合わせ方は、同じ数字を３つ組み合わせたものか、または３つの連続する数字を組み合わせたものです。ただし、9 1 2 のような並びは連続する数字とは認められません。</li>
<li>同じ数字は4 回まで使えます。</li>
</ul>
<p>
13 個の数字からなる文字列を読み込んで、パズルを完成することができる数字を昇順に全て出力するプログラムを作成してください。なお、1〜9 のどの数字を付け加えてもパズルを完成させることができないときは 0 を出力してください。
</p>
<p>例えば与えられた文字列が 3456666777999 の場合<br/>
<br/>
「2」があれば、 <span>234 567 666 77 999</span><br/>
「3」があれば、 <span>33 456 666 777 999</span><br/>
「5」があれば、 <span>345 567 666 77 999</span><br/>
「8」があれば、 <span>345 666 678 77 999</span><br/>
<br/>
というふうに、2 3 5 8 のいずれかの数字が付け加えられるとパズルは完成します。「6」でも整いますが、5 回目の使用になるので、この例では使えないことに注意してください。
</p>
<H2>Input</H2>
<p>
入力は複数のデータセットからなります。各データセットとして、13 個の数字が１行に与えられます。データセットの数は 50 を超えません。
</p>
<H2>Output</H2>
<p>
データセットごとに、パズルを完成させることができる数字を昇順に空白区切りで１行に出力します。
</p>
<H2>Sample Input</H2>
<pre>
3649596966777
6358665788577
9118992346175
9643871425498
7755542764533
1133557799246
</pre>
<H2>Output for the Sample Input</H2>
<pre>
2 3 5 8
3 4
1 2 3 4 5 6 7 8 9
7 8 9
1 2 3 4 6 7 8
0
</pre>
| 3649596966777
6358665788577
9118992346175
9643871425498
7755542764533
1133557799246
| 2 3 5 8
3 4
1 2 3 4 5 6 7 8 9
7 8 9
1 2 3 4 6 7 8
0
| 9,682 |
s635875296 | p00043 | u150984829 | 1518745231 | Python | Python3 | py | Accepted | 50 | 5584 | 495 | import sys
def f(c):
if sum(c)in c:return 1
if 5 in c or sum(c)==2:return 0
if 4 in c:
k=c.index(4);c[k]-=3
if f(c):return 1
c[k]+=3
if 3 in c:
k=c.index(3);c[k]-=3
if f(c):return 1
c[k]+=3
for i in range(7):
if c[i]and c[i+1]and c[i+2]:
c[i]-=1;c[i+1]-=1;c[i+2]-=1
if f(c):return 1
c[i]+=1;c[i+1]+=1;c[i+2]+=1
n='123456789'
for e in sys.stdin:
e=list(e)
a=[i for i in n if f([(e+[i]).count(j)for j in n])]
if a:print(*a)
else:print(0)
| p00043 |
<H1>パズル</H1>
<p>
1 〜 9 の数字を 14 個組み合わせて完成させるパズルがあります。与えられた 13 個の数字にもうひとつ数字を付け加えて完成させます。
</p>
<p>
パズルの完成条件は
</p>
<ul>
<li>同じ数字を２つ組み合わせたものが必ずひとつ必要です。</li>
<li>残りの12 個の数字は、３個の数字の組み合わせ４つです。<br>
３個の数字の組み合わせ方は、同じ数字を３つ組み合わせたものか、または３つの連続する数字を組み合わせたものです。ただし、9 1 2 のような並びは連続する数字とは認められません。</li>
<li>同じ数字は4 回まで使えます。</li>
</ul>
<p>
13 個の数字からなる文字列を読み込んで、パズルを完成することができる数字を昇順に全て出力するプログラムを作成してください。なお、1〜9 のどの数字を付け加えてもパズルを完成させることができないときは 0 を出力してください。
</p>
<p>例えば与えられた文字列が 3456666777999 の場合<br/>
<br/>
「2」があれば、 <span>234 567 666 77 999</span><br/>
「3」があれば、 <span>33 456 666 777 999</span><br/>
「5」があれば、 <span>345 567 666 77 999</span><br/>
「8」があれば、 <span>345 666 678 77 999</span><br/>
<br/>
というふうに、2 3 5 8 のいずれかの数字が付け加えられるとパズルは完成します。「6」でも整いますが、5 回目の使用になるので、この例では使えないことに注意してください。
</p>
<H2>Input</H2>
<p>
入力は複数のデータセットからなります。各データセットとして、13 個の数字が１行に与えられます。データセットの数は 50 を超えません。
</p>
<H2>Output</H2>
<p>
データセットごとに、パズルを完成させることができる数字を昇順に空白区切りで１行に出力します。
</p>
<H2>Sample Input</H2>
<pre>
3649596966777
6358665788577
9118992346175
9643871425498
7755542764533
1133557799246
</pre>
<H2>Output for the Sample Input</H2>
<pre>
2 3 5 8
3 4
1 2 3 4 5 6 7 8 9
7 8 9
1 2 3 4 6 7 8
0
</pre>
| 3649596966777
6358665788577
9118992346175
9643871425498
7755542764533
1133557799246
| 2 3 5 8
3 4
1 2 3 4 5 6 7 8 9
7 8 9
1 2 3 4 6 7 8
0
| 9,683 |
s834014700 | p00043 | u150984829 | 1518745391 | Python | Python3 | py | Accepted | 50 | 5576 | 455 | import sys
def f(c):
if sum(c)in c:return 1
if 5 in c:return 0
if 4 in c:
k=c.index(4);c[k]-=3
if f(c):return 1
c[k]+=3
if 3 in c:
k=c.index(3);c[k]-=3
if f(c):return 1
c[k]+=3
for i in range(7):
if c[i]and c[i+1]and c[i+2]:
c[i]-=1;c[i+1]-=1;c[i+2]-=1
if f(c):return 1
c[i]+=1;c[i+1]+=1;c[i+2]+=1
n='123456789'
for e in sys.stdin:
e=list(e)
a=[i for i in n if f([(e+[i]).count(j)for j in n])]
if a:print(*a)
else:print(0)
| p00043 |
<H1>パズル</H1>
<p>
1 〜 9 の数字を 14 個組み合わせて完成させるパズルがあります。与えられた 13 個の数字にもうひとつ数字を付け加えて完成させます。
</p>
<p>
パズルの完成条件は
</p>
<ul>
<li>同じ数字を２つ組み合わせたものが必ずひとつ必要です。</li>
<li>残りの12 個の数字は、３個の数字の組み合わせ４つです。<br>
３個の数字の組み合わせ方は、同じ数字を３つ組み合わせたものか、または３つの連続する数字を組み合わせたものです。ただし、9 1 2 のような並びは連続する数字とは認められません。</li>
<li>同じ数字は4 回まで使えます。</li>
</ul>
<p>
13 個の数字からなる文字列を読み込んで、パズルを完成することができる数字を昇順に全て出力するプログラムを作成してください。なお、1〜9 のどの数字を付け加えてもパズルを完成させることができないときは 0 を出力してください。
</p>
<p>例えば与えられた文字列が 3456666777999 の場合<br/>
<br/>
「2」があれば、 <span>234 567 666 77 999</span><br/>
「3」があれば、 <span>33 456 666 777 999</span><br/>
「5」があれば、 <span>345 567 666 77 999</span><br/>
「8」があれば、 <span>345 666 678 77 999</span><br/>
<br/>
というふうに、2 3 5 8 のいずれかの数字が付け加えられるとパズルは完成します。「6」でも整いますが、5 回目の使用になるので、この例では使えないことに注意してください。
</p>
<H2>Input</H2>
<p>
入力は複数のデータセットからなります。各データセットとして、13 個の数字が１行に与えられます。データセットの数は 50 を超えません。
</p>
<H2>Output</H2>
<p>
データセットごとに、パズルを完成させることができる数字を昇順に空白区切りで１行に出力します。
</p>
<H2>Sample Input</H2>
<pre>
3649596966777
6358665788577
9118992346175
9643871425498
7755542764533
1133557799246
</pre>
<H2>Output for the Sample Input</H2>
<pre>
2 3 5 8
3 4
1 2 3 4 5 6 7 8 9
7 8 9
1 2 3 4 6 7 8
0
</pre>
| 3649596966777
6358665788577
9118992346175
9643871425498
7755542764533
1133557799246
| 2 3 5 8
3 4
1 2 3 4 5 6 7 8 9
7 8 9
1 2 3 4 6 7 8
0
| 9,684 |
s769014618 | p00043 | u150984829 | 1518745663 | Python | Python3 | py | Accepted | 60 | 5580 | 479 | import sys
def p(c,l,b):
for i in l:c[i]+=[-1,1][b]
def f(c):
if sum(c)in c:return 1
if 5 in c:return 0
if 4 in c:
k=c.index(4);c[k]-=3
if f(c):return 1
c[k]+=3
if 3 in c:
k=c.index(3);c[k]-=3
if f(c):return 1
c[k]+=3
for i in range(7):
if c[i]and c[i+1]and c[i+2]:
p(c,[i,i+1,i+2],0)
if f(c):return 1
p(c,[i,i+1,i+2],1)
n='123456789'
for e in sys.stdin:
e=list(e)
a=[i for i in n if f([(e+[i]).count(j)for j in n])]
if a:print(*a)
else:print(0)
| p00043 |
<H1>パズル</H1>
<p>
1 〜 9 の数字を 14 個組み合わせて完成させるパズルがあります。与えられた 13 個の数字にもうひとつ数字を付け加えて完成させます。
</p>
<p>
パズルの完成条件は
</p>
<ul>
<li>同じ数字を２つ組み合わせたものが必ずひとつ必要です。</li>
<li>残りの12 個の数字は、３個の数字の組み合わせ４つです。<br>
３個の数字の組み合わせ方は、同じ数字を３つ組み合わせたものか、または３つの連続する数字を組み合わせたものです。ただし、9 1 2 のような並びは連続する数字とは認められません。</li>
<li>同じ数字は4 回まで使えます。</li>
</ul>
<p>
13 個の数字からなる文字列を読み込んで、パズルを完成することができる数字を昇順に全て出力するプログラムを作成してください。なお、1〜9 のどの数字を付け加えてもパズルを完成させることができないときは 0 を出力してください。
</p>
<p>例えば与えられた文字列が 3456666777999 の場合<br/>
<br/>
「2」があれば、 <span>234 567 666 77 999</span><br/>
「3」があれば、 <span>33 456 666 777 999</span><br/>
「5」があれば、 <span>345 567 666 77 999</span><br/>
「8」があれば、 <span>345 666 678 77 999</span><br/>
<br/>
というふうに、2 3 5 8 のいずれかの数字が付け加えられるとパズルは完成します。「6」でも整いますが、5 回目の使用になるので、この例では使えないことに注意してください。
</p>
<H2>Input</H2>
<p>
入力は複数のデータセットからなります。各データセットとして、13 個の数字が１行に与えられます。データセットの数は 50 を超えません。
</p>
<H2>Output</H2>
<p>
データセットごとに、パズルを完成させることができる数字を昇順に空白区切りで１行に出力します。
</p>
<H2>Sample Input</H2>
<pre>
3649596966777
6358665788577
9118992346175
9643871425498
7755542764533
1133557799246
</pre>
<H2>Output for the Sample Input</H2>
<pre>
2 3 5 8
3 4
1 2 3 4 5 6 7 8 9
7 8 9
1 2 3 4 6 7 8
0
</pre>
| 3649596966777
6358665788577
9118992346175
9643871425498
7755542764533
1133557799246
| 2 3 5 8
3 4
1 2 3 4 5 6 7 8 9
7 8 9
1 2 3 4 6 7 8
0
| 9,685 |
s402814461 | p00043 | u150984829 | 1518746543 | Python | Python3 | py | Accepted | 50 | 5612 | 502 | import sys
def g(c,i):
a=[0]*9
for j in e+[i]:a[j-1]+=1
return a
def f(c):
if sum(c)in c:return 1
if 5 in c:return 0
if 4 in c:
k=c.index(4);c[k]-=3
if f(c):return 1
c[k]+=3
if 3 in c:
k=c.index(3);c[k]-=3
if f(c):return 1
c[k]+=3
for i in range(7):
if c[i]and c[i+1]and c[i+2]:
c[i]-=1;c[i+1]-=1;c[i+2]-=1
if f(c):return 1
c[i]+=1;c[i+1]+=1;c[i+2]+=1
for e in sys.stdin:
e=list(map(int,e.strip()))
a=[i for i in range(1,10)if f(g(e,i))]
if a:print(*a)
else:print(0)
| p00043 |
<H1>パズル</H1>
<p>
1 〜 9 の数字を 14 個組み合わせて完成させるパズルがあります。与えられた 13 個の数字にもうひとつ数字を付け加えて完成させます。
</p>
<p>
パズルの完成条件は
</p>
<ul>
<li>同じ数字を２つ組み合わせたものが必ずひとつ必要です。</li>
<li>残りの12 個の数字は、３個の数字の組み合わせ４つです。<br>
３個の数字の組み合わせ方は、同じ数字を３つ組み合わせたものか、または３つの連続する数字を組み合わせたものです。ただし、9 1 2 のような並びは連続する数字とは認められません。</li>
<li>同じ数字は4 回まで使えます。</li>
</ul>
<p>
13 個の数字からなる文字列を読み込んで、パズルを完成することができる数字を昇順に全て出力するプログラムを作成してください。なお、1〜9 のどの数字を付け加えてもパズルを完成させることができないときは 0 を出力してください。
</p>
<p>例えば与えられた文字列が 3456666777999 の場合<br/>
<br/>
「2」があれば、 <span>234 567 666 77 999</span><br/>
「3」があれば、 <span>33 456 666 777 999</span><br/>
「5」があれば、 <span>345 567 666 77 999</span><br/>
「8」があれば、 <span>345 666 678 77 999</span><br/>
<br/>
というふうに、2 3 5 8 のいずれかの数字が付け加えられるとパズルは完成します。「6」でも整いますが、5 回目の使用になるので、この例では使えないことに注意してください。
</p>
<H2>Input</H2>
<p>
入力は複数のデータセットからなります。各データセットとして、13 個の数字が１行に与えられます。データセットの数は 50 を超えません。
</p>
<H2>Output</H2>
<p>
データセットごとに、パズルを完成させることができる数字を昇順に空白区切りで１行に出力します。
</p>
<H2>Sample Input</H2>
<pre>
3649596966777
6358665788577
9118992346175
9643871425498
7755542764533
1133557799246
</pre>
<H2>Output for the Sample Input</H2>
<pre>
2 3 5 8
3 4
1 2 3 4 5 6 7 8 9
7 8 9
1 2 3 4 6 7 8
0
</pre>
| 3649596966777
6358665788577
9118992346175
9643871425498
7755542764533
1133557799246
| 2 3 5 8
3 4
1 2 3 4 5 6 7 8 9
7 8 9
1 2 3 4 6 7 8
0
| 9,686 |
s036116518 | p00043 | u150984829 | 1518746544 | Python | Python3 | py | Accepted | 50 | 5612 | 502 | import sys
def g(c,i):
a=[0]*9
for j in e+[i]:a[j-1]+=1
return a
def f(c):
if sum(c)in c:return 1
if 5 in c:return 0
if 4 in c:
k=c.index(4);c[k]-=3
if f(c):return 1
c[k]+=3
if 3 in c:
k=c.index(3);c[k]-=3
if f(c):return 1
c[k]+=3
for i in range(7):
if c[i]and c[i+1]and c[i+2]:
c[i]-=1;c[i+1]-=1;c[i+2]-=1
if f(c):return 1
c[i]+=1;c[i+1]+=1;c[i+2]+=1
for e in sys.stdin:
e=list(map(int,e.strip()))
a=[i for i in range(1,10)if f(g(e,i))]
if a:print(*a)
else:print(0)
| p00043 |
<H1>パズル</H1>
<p>
1 〜 9 の数字を 14 個組み合わせて完成させるパズルがあります。与えられた 13 個の数字にもうひとつ数字を付け加えて完成させます。
</p>
<p>
パズルの完成条件は
</p>
<ul>
<li>同じ数字を２つ組み合わせたものが必ずひとつ必要です。</li>
<li>残りの12 個の数字は、３個の数字の組み合わせ４つです。<br>
３個の数字の組み合わせ方は、同じ数字を３つ組み合わせたものか、または３つの連続する数字を組み合わせたものです。ただし、9 1 2 のような並びは連続する数字とは認められません。</li>
<li>同じ数字は4 回まで使えます。</li>
</ul>
<p>
13 個の数字からなる文字列を読み込んで、パズルを完成することができる数字を昇順に全て出力するプログラムを作成してください。なお、1〜9 のどの数字を付け加えてもパズルを完成させることができないときは 0 を出力してください。
</p>
<p>例えば与えられた文字列が 3456666777999 の場合<br/>
<br/>
「2」があれば、 <span>234 567 666 77 999</span><br/>
「3」があれば、 <span>33 456 666 777 999</span><br/>
「5」があれば、 <span>345 567 666 77 999</span><br/>
「8」があれば、 <span>345 666 678 77 999</span><br/>
<br/>
というふうに、2 3 5 8 のいずれかの数字が付け加えられるとパズルは完成します。「6」でも整いますが、5 回目の使用になるので、この例では使えないことに注意してください。
</p>
<H2>Input</H2>
<p>
入力は複数のデータセットからなります。各データセットとして、13 個の数字が１行に与えられます。データセットの数は 50 を超えません。
</p>
<H2>Output</H2>
<p>
データセットごとに、パズルを完成させることができる数字を昇順に空白区切りで１行に出力します。
</p>
<H2>Sample Input</H2>
<pre>
3649596966777
6358665788577
9118992346175
9643871425498
7755542764533
1133557799246
</pre>
<H2>Output for the Sample Input</H2>
<pre>
2 3 5 8
3 4
1 2 3 4 5 6 7 8 9
7 8 9
1 2 3 4 6 7 8
0
</pre>
| 3649596966777
6358665788577
9118992346175
9643871425498
7755542764533
1133557799246
| 2 3 5 8
3 4
1 2 3 4 5 6 7 8 9
7 8 9
1 2 3 4 6 7 8
0
| 9,687 |
s133081895 | p00043 | u150984829 | 1518753858 | Python | Python3 | py | Accepted | 50 | 5572 | 485 | import sys
def f(c):
if sum(c)in c:return 1
if 5 in c:return 0
if 4 in c:
k=c.index(4);c[k]-=3
if f(c):return 1
c[k]+=3
if 3 in c:
k=c.index(3);c[k]-=3
if f(c):return 1
c[k]+=3
for i in range(7):
if c[i]and c[i+1]and c[i+2]:
c[i]-=1;c[i+1]-=1;c[i+2]-=1
if f(c):return 1
c[i]+=1;c[i+1]+=1;c[i+2]+=1
n='123456789'
for e in sys.stdin:
c=[list(e).count(j)for j in n]
a=[]
for i in range(9):
t=c[:];t[i]+=1
if f(t):a+=[i+1]
if a:print(*a)
else:print(0)
| p00043 |
<H1>パズル</H1>
<p>
1 〜 9 の数字を 14 個組み合わせて完成させるパズルがあります。与えられた 13 個の数字にもうひとつ数字を付け加えて完成させます。
</p>
<p>
パズルの完成条件は
</p>
<ul>
<li>同じ数字を２つ組み合わせたものが必ずひとつ必要です。</li>
<li>残りの12 個の数字は、３個の数字の組み合わせ４つです。<br>
３個の数字の組み合わせ方は、同じ数字を３つ組み合わせたものか、または３つの連続する数字を組み合わせたものです。ただし、9 1 2 のような並びは連続する数字とは認められません。</li>
<li>同じ数字は4 回まで使えます。</li>
</ul>
<p>
13 個の数字からなる文字列を読み込んで、パズルを完成することができる数字を昇順に全て出力するプログラムを作成してください。なお、1〜9 のどの数字を付け加えてもパズルを完成させることができないときは 0 を出力してください。
</p>
<p>例えば与えられた文字列が 3456666777999 の場合<br/>
<br/>
「2」があれば、 <span>234 567 666 77 999</span><br/>
「3」があれば、 <span>33 456 666 777 999</span><br/>
「5」があれば、 <span>345 567 666 77 999</span><br/>
「8」があれば、 <span>345 666 678 77 999</span><br/>
<br/>
というふうに、2 3 5 8 のいずれかの数字が付け加えられるとパズルは完成します。「6」でも整いますが、5 回目の使用になるので、この例では使えないことに注意してください。
</p>
<H2>Input</H2>
<p>
入力は複数のデータセットからなります。各データセットとして、13 個の数字が１行に与えられます。データセットの数は 50 を超えません。
</p>
<H2>Output</H2>
<p>
データセットごとに、パズルを完成させることができる数字を昇順に空白区切りで１行に出力します。
</p>
<H2>Sample Input</H2>
<pre>
3649596966777
6358665788577
9118992346175
9643871425498
7755542764533
1133557799246
</pre>
<H2>Output for the Sample Input</H2>
<pre>
2 3 5 8
3 4
1 2 3 4 5 6 7 8 9
7 8 9
1 2 3 4 6 7 8
0
</pre>
| 3649596966777
6358665788577
9118992346175
9643871425498
7755542764533
1133557799246
| 2 3 5 8
3 4
1 2 3 4 5 6 7 8 9
7 8 9
1 2 3 4 6 7 8
0
| 9,688 |
s853958841 | p00043 | u150984829 | 1518753860 | Python | Python3 | py | Accepted | 50 | 5580 | 485 | import sys
def f(c):
if sum(c)in c:return 1
if 5 in c:return 0
if 4 in c:
k=c.index(4);c[k]-=3
if f(c):return 1
c[k]+=3
if 3 in c:
k=c.index(3);c[k]-=3
if f(c):return 1
c[k]+=3
for i in range(7):
if c[i]and c[i+1]and c[i+2]:
c[i]-=1;c[i+1]-=1;c[i+2]-=1
if f(c):return 1
c[i]+=1;c[i+1]+=1;c[i+2]+=1
n='123456789'
for e in sys.stdin:
c=[list(e).count(j)for j in n]
a=[]
for i in range(9):
t=c[:];t[i]+=1
if f(t):a+=[i+1]
if a:print(*a)
else:print(0)
| p00043 |
<H1>パズル</H1>
<p>
1 〜 9 の数字を 14 個組み合わせて完成させるパズルがあります。与えられた 13 個の数字にもうひとつ数字を付け加えて完成させます。
</p>
<p>
パズルの完成条件は
</p>
<ul>
<li>同じ数字を２つ組み合わせたものが必ずひとつ必要です。</li>
<li>残りの12 個の数字は、３個の数字の組み合わせ４つです。<br>
３個の数字の組み合わせ方は、同じ数字を３つ組み合わせたものか、または３つの連続する数字を組み合わせたものです。ただし、9 1 2 のような並びは連続する数字とは認められません。</li>
<li>同じ数字は4 回まで使えます。</li>
</ul>
<p>
13 個の数字からなる文字列を読み込んで、パズルを完成することができる数字を昇順に全て出力するプログラムを作成してください。なお、1〜9 のどの数字を付け加えてもパズルを完成させることができないときは 0 を出力してください。
</p>
<p>例えば与えられた文字列が 3456666777999 の場合<br/>
<br/>
「2」があれば、 <span>234 567 666 77 999</span><br/>
「3」があれば、 <span>33 456 666 777 999</span><br/>
「5」があれば、 <span>345 567 666 77 999</span><br/>
「8」があれば、 <span>345 666 678 77 999</span><br/>
<br/>
というふうに、2 3 5 8 のいずれかの数字が付け加えられるとパズルは完成します。「6」でも整いますが、5 回目の使用になるので、この例では使えないことに注意してください。
</p>
<H2>Input</H2>
<p>
入力は複数のデータセットからなります。各データセットとして、13 個の数字が１行に与えられます。データセットの数は 50 を超えません。
</p>
<H2>Output</H2>
<p>
データセットごとに、パズルを完成させることができる数字を昇順に空白区切りで１行に出力します。
</p>
<H2>Sample Input</H2>
<pre>
3649596966777
6358665788577
9118992346175
9643871425498
7755542764533
1133557799246
</pre>
<H2>Output for the Sample Input</H2>
<pre>
2 3 5 8
3 4
1 2 3 4 5 6 7 8 9
7 8 9
1 2 3 4 6 7 8
0
</pre>
| 3649596966777
6358665788577
9118992346175
9643871425498
7755542764533
1133557799246
| 2 3 5 8
3 4
1 2 3 4 5 6 7 8 9
7 8 9
1 2 3 4 6 7 8
0
| 9,689 |
s551638537 | p00043 | u724606305 | 1523856731 | Python | Python3 | py | Accepted | 30 | 5604 | 1,725 | def check(nums):
#print(nums)
#5回以上出てこないか判別
for i in range(9):
if(nums[i]>4):
return False
for head in range(9):
#作業用の配列を作る
anums=nums[:]
#頭ができているか確認
if(anums[head]<2):
continue
anums[head]-=2
for i in range(9):
#三つ同じものがある場合はそれをひとまとめにする
if(anums[i]>=3):
anums[i]-=3
while(anums[i]>0):
#8以上が1になってても成立しないからFalse
if i>=7:
break
ok=True
for j in range(i,i+3):
if anums[j]<=0:
ok=False
#okがFalseなら順番になってない
if not ok:
break
#okがTrueなら順番になっているので一ずつ減らす。
for j in range(i,i+3):
anums[j]-=1
#全て0になっていればTrue
if not any(anums):
return True
return False
while True:
st=""
try:
st=input()
except:
break
#9個の配列を作り0を入れる
nums=[0 for i in range(9)]
#各数字の数を数える
for c in st:
nums[int(c)-1]+=1
#答えの配列を作る
anss=[]
#与えられたものに1~9を一つずつ加えてそれぞれで判定
for n in range(0,9):
nums[n]+=1
if(check(nums[:])):
anss.append(n+1)
nums[n]-=1
if(len(anss)==0):
anss.append(0)
print(" ".join(map(str,anss)))
| p00043 |
<H1>パズル</H1>
<p>
1 〜 9 の数字を 14 個組み合わせて完成させるパズルがあります。与えられた 13 個の数字にもうひとつ数字を付け加えて完成させます。
</p>
<p>
パズルの完成条件は
</p>
<ul>
<li>同じ数字を２つ組み合わせたものが必ずひとつ必要です。</li>
<li>残りの12 個の数字は、３個の数字の組み合わせ４つです。<br>
３個の数字の組み合わせ方は、同じ数字を３つ組み合わせたものか、または３つの連続する数字を組み合わせたものです。ただし、9 1 2 のような並びは連続する数字とは認められません。</li>
<li>同じ数字は4 回まで使えます。</li>
</ul>
<p>
13 個の数字からなる文字列を読み込んで、パズルを完成することができる数字を昇順に全て出力するプログラムを作成してください。なお、1〜9 のどの数字を付け加えてもパズルを完成させることができないときは 0 を出力してください。
</p>
<p>例えば与えられた文字列が 3456666777999 の場合<br/>
<br/>
「2」があれば、 <span>234 567 666 77 999</span><br/>
「3」があれば、 <span>33 456 666 777 999</span><br/>
「5」があれば、 <span>345 567 666 77 999</span><br/>
「8」があれば、 <span>345 666 678 77 999</span><br/>
<br/>
というふうに、2 3 5 8 のいずれかの数字が付け加えられるとパズルは完成します。「6」でも整いますが、5 回目の使用になるので、この例では使えないことに注意してください。
</p>
<H2>Input</H2>
<p>
入力は複数のデータセットからなります。各データセットとして、13 個の数字が１行に与えられます。データセットの数は 50 を超えません。
</p>
<H2>Output</H2>
<p>
データセットごとに、パズルを完成させることができる数字を昇順に空白区切りで１行に出力します。
</p>
<H2>Sample Input</H2>
<pre>
3649596966777
6358665788577
9118992346175
9643871425498
7755542764533
1133557799246
</pre>
<H2>Output for the Sample Input</H2>
<pre>
2 3 5 8
3 4
1 2 3 4 5 6 7 8 9
7 8 9
1 2 3 4 6 7 8
0
</pre>
| 3649596966777
6358665788577
9118992346175
9643871425498
7755542764533
1133557799246
| 2 3 5 8
3 4
1 2 3 4 5 6 7 8 9
7 8 9
1 2 3 4 6 7 8
0
| 9,690 |
s997133066 | p00043 | u197615397 | 1530539806 | Python | Python3 | py | Accepted | 30 | 6008 | 1,164 | from collections import deque
try:
while True:
a = list(sorted(map(int, input())))
result = []
for i in range(1, 10):
if a.count(i) == 4:
continue
_a = sorted(a+[i])
dq = deque([(_a, 0)])
while dq:
hand, mentu = dq.popleft()
if mentu == 5:
if not hand:
result.append(i)
break
continue
elif mentu > 5:
continue
current = hand[0]
if hand.count(current) >= 2:
dq.append((hand[2:], mentu+1))
if hand.count(current) >= 3:
dq.append((hand[3:], mentu+1))
if current+1 in hand and current+2 in hand:
_hand = hand[:]
del _hand[0]
del _hand[_hand.index(current+1)]
del _hand[_hand.index(current+2)]
dq.append((_hand, mentu+1))
print(" ".join(map(str, result)) if result else 0)
except EOFError:
exit()
| p00043 |
<H1>パズル</H1>
<p>
1 〜 9 の数字を 14 個組み合わせて完成させるパズルがあります。与えられた 13 個の数字にもうひとつ数字を付け加えて完成させます。
</p>
<p>
パズルの完成条件は
</p>
<ul>
<li>同じ数字を２つ組み合わせたものが必ずひとつ必要です。</li>
<li>残りの12 個の数字は、３個の数字の組み合わせ４つです。<br>
３個の数字の組み合わせ方は、同じ数字を３つ組み合わせたものか、または３つの連続する数字を組み合わせたものです。ただし、9 1 2 のような並びは連続する数字とは認められません。</li>
<li>同じ数字は4 回まで使えます。</li>
</ul>
<p>
13 個の数字からなる文字列を読み込んで、パズルを完成することができる数字を昇順に全て出力するプログラムを作成してください。なお、1〜9 のどの数字を付け加えてもパズルを完成させることができないときは 0 を出力してください。
</p>
<p>例えば与えられた文字列が 3456666777999 の場合<br/>
<br/>
「2」があれば、 <span>234 567 666 77 999</span><br/>
「3」があれば、 <span>33 456 666 777 999</span><br/>
「5」があれば、 <span>345 567 666 77 999</span><br/>
「8」があれば、 <span>345 666 678 77 999</span><br/>
<br/>
というふうに、2 3 5 8 のいずれかの数字が付け加えられるとパズルは完成します。「6」でも整いますが、5 回目の使用になるので、この例では使えないことに注意してください。
</p>
<H2>Input</H2>
<p>
入力は複数のデータセットからなります。各データセットとして、13 個の数字が１行に与えられます。データセットの数は 50 を超えません。
</p>
<H2>Output</H2>
<p>
データセットごとに、パズルを完成させることができる数字を昇順に空白区切りで１行に出力します。
</p>
<H2>Sample Input</H2>
<pre>
3649596966777
6358665788577
9118992346175
9643871425498
7755542764533
1133557799246
</pre>
<H2>Output for the Sample Input</H2>
<pre>
2 3 5 8
3 4
1 2 3 4 5 6 7 8 9
7 8 9
1 2 3 4 6 7 8
0
</pre>
| 3649596966777
6358665788577
9118992346175
9643871425498
7755542764533
1133557799246
| 2 3 5 8
3 4
1 2 3 4 5 6 7 8 9
7 8 9
1 2 3 4 6 7 8
0
| 9,691 |
s741221675 | p00043 | u017525488 | 1351356866 | Python | Python | py | Accepted | 20 | 4280 | 1,277 | import sys
def dfs(hands, pair):
hands.sort()
if not hands:
return True
target = hands[0]
# sequence
if all(map(lambda x: x in hands, range(target, target + 3))):
for i in range(target, target + 3):
hands.remove(i)
if dfs(hands, pair):
return True
for i in range(target, target + 3):
hands.append(i)
# triple
if hands.count(target) >= 3:
for i in range(3):
hands.remove(target)
if dfs(hands, pair):
return True
for i in range(3):
hands.append(target)
# pair
if not pair and hands.count(target) >= 2:
for i in range(2):
hands.remove(target)
if dfs(hands, True):
return True
for i in range(2):
hands.append(target)
return False
for line in filter(lambda line: line.strip(), sys.stdin.readlines()):
result = []
data = [int(ch) for ch in line.strip()]
for num in filter(lambda x: data.count(x) < 4, range(1, 10)):
data_cp = list(data)
data_cp.append(num)
data_cp.sort()
if dfs(data_cp, False):
result.append(num)
if result:
print " ".join(map(str, result))
else:
print 0 | p00043 |
<H1>パズル</H1>
<p>
1 〜 9 の数字を 14 個組み合わせて完成させるパズルがあります。与えられた 13 個の数字にもうひとつ数字を付け加えて完成させます。
</p>
<p>
パズルの完成条件は
</p>
<ul>
<li>同じ数字を２つ組み合わせたものが必ずひとつ必要です。</li>
<li>残りの12 個の数字は、３個の数字の組み合わせ４つです。<br>
３個の数字の組み合わせ方は、同じ数字を３つ組み合わせたものか、または３つの連続する数字を組み合わせたものです。ただし、9 1 2 のような並びは連続する数字とは認められません。</li>
<li>同じ数字は4 回まで使えます。</li>
</ul>
<p>
13 個の数字からなる文字列を読み込んで、パズルを完成することができる数字を昇順に全て出力するプログラムを作成してください。なお、1〜9 のどの数字を付け加えてもパズルを完成させることができないときは 0 を出力してください。
</p>
<p>例えば与えられた文字列が 3456666777999 の場合<br/>
<br/>
「2」があれば、 <span>234 567 666 77 999</span><br/>
「3」があれば、 <span>33 456 666 777 999</span><br/>
「5」があれば、 <span>345 567 666 77 999</span><br/>
「8」があれば、 <span>345 666 678 77 999</span><br/>
<br/>
というふうに、2 3 5 8 のいずれかの数字が付け加えられるとパズルは完成します。「6」でも整いますが、5 回目の使用になるので、この例では使えないことに注意してください。
</p>
<H2>Input</H2>
<p>
入力は複数のデータセットからなります。各データセットとして、13 個の数字が１行に与えられます。データセットの数は 50 を超えません。
</p>
<H2>Output</H2>
<p>
データセットごとに、パズルを完成させることができる数字を昇順に空白区切りで１行に出力します。
</p>
<H2>Sample Input</H2>
<pre>
3649596966777
6358665788577
9118992346175
9643871425498
7755542764533
1133557799246
</pre>
<H2>Output for the Sample Input</H2>
<pre>
2 3 5 8
3 4
1 2 3 4 5 6 7 8 9
7 8 9
1 2 3 4 6 7 8
0
</pre>
| 3649596966777
6358665788577
9118992346175
9643871425498
7755542764533
1133557799246
| 2 3 5 8
3 4
1 2 3 4 5 6 7 8 9
7 8 9
1 2 3 4 6 7 8
0
| 9,692 |
s920724182 | p00043 | u647766105 | 1356958681 | Python | Python | py | Accepted | 20 | 4284 | 857 | import sys
for line in sys.stdin.readlines():
li=[0]*10
for i in map(int,line.strip()):
li[i]+=1
ans=[]
for addnum in [i for i in xrange(1,10) if not li[i]>=4]:
t_li=li[:]
t_li[addnum]+=1
for remnum in [i for i in xrange(1,10) if t_li[i]>=2]:
t2_li=t_li[:]
t2_li[remnum]-=2
top=1
while (not -1 in t2_li) and top<=7:
if t2_li[top]==0:
top+=1
elif t2_li[top]>=3:
t2_li[top]-=3
else:
for i in xrange(3):
t2_li[top+i]-=1
if top==8 and (t2_li[8]==0 or t2_li[8]==3) and (t2_li[9]==0 or t2_li[9]==3):
ans.append(addnum)
break
if ans==[]:print 0
else:print " ".join(map(str,ans))
#temp | p00043 |
<H1>パズル</H1>
<p>
1 〜 9 の数字を 14 個組み合わせて完成させるパズルがあります。与えられた 13 個の数字にもうひとつ数字を付け加えて完成させます。
</p>
<p>
パズルの完成条件は
</p>
<ul>
<li>同じ数字を２つ組み合わせたものが必ずひとつ必要です。</li>
<li>残りの12 個の数字は、３個の数字の組み合わせ４つです。<br>
３個の数字の組み合わせ方は、同じ数字を３つ組み合わせたものか、または３つの連続する数字を組み合わせたものです。ただし、9 1 2 のような並びは連続する数字とは認められません。</li>
<li>同じ数字は4 回まで使えます。</li>
</ul>
<p>
13 個の数字からなる文字列を読み込んで、パズルを完成することができる数字を昇順に全て出力するプログラムを作成してください。なお、1〜9 のどの数字を付け加えてもパズルを完成させることができないときは 0 を出力してください。
</p>
<p>例えば与えられた文字列が 3456666777999 の場合<br/>
<br/>
「2」があれば、 <span>234 567 666 77 999</span><br/>
「3」があれば、 <span>33 456 666 777 999</span><br/>
「5」があれば、 <span>345 567 666 77 999</span><br/>
「8」があれば、 <span>345 666 678 77 999</span><br/>
<br/>
というふうに、2 3 5 8 のいずれかの数字が付け加えられるとパズルは完成します。「6」でも整いますが、5 回目の使用になるので、この例では使えないことに注意してください。
</p>
<H2>Input</H2>
<p>
入力は複数のデータセットからなります。各データセットとして、13 個の数字が１行に与えられます。データセットの数は 50 を超えません。
</p>
<H2>Output</H2>
<p>
データセットごとに、パズルを完成させることができる数字を昇順に空白区切りで１行に出力します。
</p>
<H2>Sample Input</H2>
<pre>
3649596966777
6358665788577
9118992346175
9643871425498
7755542764533
1133557799246
</pre>
<H2>Output for the Sample Input</H2>
<pre>
2 3 5 8
3 4
1 2 3 4 5 6 7 8 9
7 8 9
1 2 3 4 6 7 8
0
</pre>
| 3649596966777
6358665788577
9118992346175
9643871425498
7755542764533
1133557799246
| 2 3 5 8
3 4
1 2 3 4 5 6 7 8 9
7 8 9
1 2 3 4 6 7 8
0
| 9,693 |
s459877547 | p00043 | u763301852 | 1364650186 | Python | Python | py | Accepted | 10 | 4416 | 3,009 | def main():
while True:
try:
n = [int(x) for x in raw_input()]
n.sort()
solve(n)
except EOFError as e:
break
def solve(input_numbers):
valid_numbers = []
c = count_number(input_numbers);
for i in range(9):
if c[i] == 4:
continue
c[i] += 1
if isvalid(c, 0, False):
valid_numbers.append(i+1)
c[i] -= 1
s = " ".join(map(str, valid_numbers)) if len(valid_numbers) > 0 else "0"
print(s)
def count_number(input_numbers):
c = [0] * 9
for i in input_numbers:
c[i-1] += 1
return c
def isvalid(input_numbers, pos, head):
if pos == 8:
if head and input_numbers[8] == 0:
return True
elif head and input_numbers[8] == 3:
return True
elif (not head) and input_numbers[8] == 2:
return True
else:
return False
if input_numbers[pos] == 0:
return isvalid(input_numbers, pos+1, head)
if input_numbers[pos] == 1:
if not can_sequence(input_numbers, pos, 1):
return False
else:
input_numbers[pos] -= 1
input_numbers[pos+1] -= 1
input_numbers[pos+2] -= 1
r = isvalid(input_numbers, pos+1, head)
input_numbers[pos] += 1
input_numbers[pos+1] += 1
input_numbers[pos+2] += 1
return r
if input_numbers[pos] == 2:
if not head:
input_numbers[pos] -= 2
r = isvalid(input_numbers, pos+1, True)
input_numbers[pos] += 2
if r:
return True
if can_sequence(input_numbers, pos, 2):
input_numbers[pos] -= 2
input_numbers[pos+1] -= 2
input_numbers[pos+2] -= 2
r = isvalid(input_numbers, pos+1, head)
input_numbers[pos] += 2
input_numbers[pos+1] += 2
input_numbers[pos+2] += 2
return r
if input_numbers[pos] == 3:
input_numbers[pos] -= 3
r = isvalid(input_numbers, pos+1, head)
input_numbers[pos] += 3
if r:
return True
if can_sequence(input_numbers, pos, 1):
input_numbers[pos] -= 2
r = isvalid(input_numbers, pos, True)
input_numbers[pos] += 2
return r
else:
return False
if input_numbers[pos] == 4:
input_numbers[pos] -= 3
r = isvalid(input_numbers, pos, head)
input_numbers[pos] += 3
if r:
return True
if not head:
input_numbers[pos] -= 2
r = isvalid(input_numbers, pos, True)
input_numbers[pos] += 2
return r
else:
return False
def can_sequence(input_numbers, pos, num):
if pos > 6:
return False
return input_numbers[pos] >= num and input_numbers[pos+1] >= num and input_numbers[pos+2] >= num
main() | p00043 |
<H1>パズル</H1>
<p>
1 〜 9 の数字を 14 個組み合わせて完成させるパズルがあります。与えられた 13 個の数字にもうひとつ数字を付け加えて完成させます。
</p>
<p>
パズルの完成条件は
</p>
<ul>
<li>同じ数字を２つ組み合わせたものが必ずひとつ必要です。</li>
<li>残りの12 個の数字は、３個の数字の組み合わせ４つです。<br>
３個の数字の組み合わせ方は、同じ数字を３つ組み合わせたものか、または３つの連続する数字を組み合わせたものです。ただし、9 1 2 のような並びは連続する数字とは認められません。</li>
<li>同じ数字は4 回まで使えます。</li>
</ul>
<p>
13 個の数字からなる文字列を読み込んで、パズルを完成することができる数字を昇順に全て出力するプログラムを作成してください。なお、1〜9 のどの数字を付け加えてもパズルを完成させることができないときは 0 を出力してください。
</p>
<p>例えば与えられた文字列が 3456666777999 の場合<br/>
<br/>
「2」があれば、 <span>234 567 666 77 999</span><br/>
「3」があれば、 <span>33 456 666 777 999</span><br/>
「5」があれば、 <span>345 567 666 77 999</span><br/>
「8」があれば、 <span>345 666 678 77 999</span><br/>
<br/>
というふうに、2 3 5 8 のいずれかの数字が付け加えられるとパズルは完成します。「6」でも整いますが、5 回目の使用になるので、この例では使えないことに注意してください。
</p>
<H2>Input</H2>
<p>
入力は複数のデータセットからなります。各データセットとして、13 個の数字が１行に与えられます。データセットの数は 50 を超えません。
</p>
<H2>Output</H2>
<p>
データセットごとに、パズルを完成させることができる数字を昇順に空白区切りで１行に出力します。
</p>
<H2>Sample Input</H2>
<pre>
3649596966777
6358665788577
9118992346175
9643871425498
7755542764533
1133557799246
</pre>
<H2>Output for the Sample Input</H2>
<pre>
2 3 5 8
3 4
1 2 3 4 5 6 7 8 9
7 8 9
1 2 3 4 6 7 8
0
</pre>
| 3649596966777
6358665788577
9118992346175
9643871425498
7755542764533
1133557799246
| 2 3 5 8
3 4
1 2 3 4 5 6 7 8 9
7 8 9
1 2 3 4 6 7 8
0
| 9,694 |
s450728808 | p00043 | u542421762 | 1370092827 | Python | Python | py | Accepted | 20 | 4392 | 2,086 |
import sys
DEBUG = False
def solv(nums):
r = []
for i in range(1, 10):
if DEBUG:
print 'i: ', i
if judge(list(nums), i):
r.append(i)
if DEBUG:
print '===='
if len(r) == 0:
r.append(0)
return r
def judge(nums, n):
if nums.count(n) >= 4:
return False
else:
nums.append(n)
nums.sort()
heads = overlup(nums)
r = []
for h in heads:
if DEBUG:
print 'nums: ', nums
nums2 = list(nums)
nums2.pop(nums2.index(h))
nums2.pop(nums2.index(h))
if DEBUG:
print 'head: ', h
print 'nums2: ', nums2
if judge2(nums2):
r.append(h)
if r:
return True
else:
return False
def judge2(nums):
if not nums:
if DEBUG:
print '---'
return True
nums2 = list(nums)
h3 = []
h3.append(nums.pop(0))
try:
j = nums.index(h3[0] + 1)
h3.append(nums.pop(j))
k = nums.index(h3[0] + 2)
h3.append(nums.pop(k))
if DEBUG:
print h3
if judge2(nums):
return True
except ValueError:
for i in range(1, len(h3)):
nums.append(h3.pop(i))
nums.sort()
h3 = []
h3.append(nums2.pop(0))
h3.append(nums2.pop(0))
if h3[0] == h3[1]:
h3.append(nums2.pop(0))
if DEBUG:
print h3
if h3[1] == h3[2]:
return judge2(nums2)
else:
return False
else:
return False
def overlup(lis):
r = []
def func(x, y):
if x == y and x not in r:
r.append(x)
return y
reduce(func, lis)
return r
def difference(lis):
return [y - x for x, y in zip(lis, lis[1:])]
c = 0
for line in sys.stdin:
c += 1
if DEBUG:
print 'CASE:', str(c)
numbers = map(int, line.rstrip('\n'))
print ' '.join(map(str, solv(numbers))) | p00043 |
<H1>パズル</H1>
<p>
1 〜 9 の数字を 14 個組み合わせて完成させるパズルがあります。与えられた 13 個の数字にもうひとつ数字を付け加えて完成させます。
</p>
<p>
パズルの完成条件は
</p>
<ul>
<li>同じ数字を２つ組み合わせたものが必ずひとつ必要です。</li>
<li>残りの12 個の数字は、３個の数字の組み合わせ４つです。<br>
３個の数字の組み合わせ方は、同じ数字を３つ組み合わせたものか、または３つの連続する数字を組み合わせたものです。ただし、9 1 2 のような並びは連続する数字とは認められません。</li>
<li>同じ数字は4 回まで使えます。</li>
</ul>
<p>
13 個の数字からなる文字列を読み込んで、パズルを完成することができる数字を昇順に全て出力するプログラムを作成してください。なお、1〜9 のどの数字を付け加えてもパズルを完成させることができないときは 0 を出力してください。
</p>
<p>例えば与えられた文字列が 3456666777999 の場合<br/>
<br/>
「2」があれば、 <span>234 567 666 77 999</span><br/>
「3」があれば、 <span>33 456 666 777 999</span><br/>
「5」があれば、 <span>345 567 666 77 999</span><br/>
「8」があれば、 <span>345 666 678 77 999</span><br/>
<br/>
というふうに、2 3 5 8 のいずれかの数字が付け加えられるとパズルは完成します。「6」でも整いますが、5 回目の使用になるので、この例では使えないことに注意してください。
</p>
<H2>Input</H2>
<p>
入力は複数のデータセットからなります。各データセットとして、13 個の数字が１行に与えられます。データセットの数は 50 を超えません。
</p>
<H2>Output</H2>
<p>
データセットごとに、パズルを完成させることができる数字を昇順に空白区切りで１行に出力します。
</p>
<H2>Sample Input</H2>
<pre>
3649596966777
6358665788577
9118992346175
9643871425498
7755542764533
1133557799246
</pre>
<H2>Output for the Sample Input</H2>
<pre>
2 3 5 8
3 4
1 2 3 4 5 6 7 8 9
7 8 9
1 2 3 4 6 7 8
0
</pre>
| 3649596966777
6358665788577
9118992346175
9643871425498
7755542764533
1133557799246
| 2 3 5 8
3 4
1 2 3 4 5 6 7 8 9
7 8 9
1 2 3 4 6 7 8
0
| 9,695 |
s243343412 | p00043 | u104911888 | 1370387719 | Python | Python | py | Accepted | 20 | 4260 | 731 | def Judge(P):
for h in range(1,10):
if P[h]>=2:
H=P[:]
H[h]-=2
flag=True
for i in range(1,10):
while H[i]%3:
for j in range(3):
H[i+j]-=1
if H[i+j]<0:
flag=False
if flag:
return True
return False
while True:
try:
s=map(int,raw_input())
except EOFError:
break
L=[0]*12
ans=[]
for i in range(len(s)):
L[s[i]]+=1
for i in range(1,10):
L[i]+=1
if max(L)!=5 and Judge(L[:]):
ans.append(str(i))
L[i]-=1
print " ".join(ans) if len(ans)!=0 else 0 | p00043 |
<H1>パズル</H1>
<p>
1 〜 9 の数字を 14 個組み合わせて完成させるパズルがあります。与えられた 13 個の数字にもうひとつ数字を付け加えて完成させます。
</p>
<p>
パズルの完成条件は
</p>
<ul>
<li>同じ数字を２つ組み合わせたものが必ずひとつ必要です。</li>
<li>残りの12 個の数字は、３個の数字の組み合わせ４つです。<br>
３個の数字の組み合わせ方は、同じ数字を３つ組み合わせたものか、または３つの連続する数字を組み合わせたものです。ただし、9 1 2 のような並びは連続する数字とは認められません。</li>
<li>同じ数字は4 回まで使えます。</li>
</ul>
<p>
13 個の数字からなる文字列を読み込んで、パズルを完成することができる数字を昇順に全て出力するプログラムを作成してください。なお、1〜9 のどの数字を付け加えてもパズルを完成させることができないときは 0 を出力してください。
</p>
<p>例えば与えられた文字列が 3456666777999 の場合<br/>
<br/>
「2」があれば、 <span>234 567 666 77 999</span><br/>
「3」があれば、 <span>33 456 666 777 999</span><br/>
「5」があれば、 <span>345 567 666 77 999</span><br/>
「8」があれば、 <span>345 666 678 77 999</span><br/>
<br/>
というふうに、2 3 5 8 のいずれかの数字が付け加えられるとパズルは完成します。「6」でも整いますが、5 回目の使用になるので、この例では使えないことに注意してください。
</p>
<H2>Input</H2>
<p>
入力は複数のデータセットからなります。各データセットとして、13 個の数字が１行に与えられます。データセットの数は 50 を超えません。
</p>
<H2>Output</H2>
<p>
データセットごとに、パズルを完成させることができる数字を昇順に空白区切りで１行に出力します。
</p>
<H2>Sample Input</H2>
<pre>
3649596966777
6358665788577
9118992346175
9643871425498
7755542764533
1133557799246
</pre>
<H2>Output for the Sample Input</H2>
<pre>
2 3 5 8
3 4
1 2 3 4 5 6 7 8 9
7 8 9
1 2 3 4 6 7 8
0
</pre>
| 3649596966777
6358665788577
9118992346175
9643871425498
7755542764533
1133557799246
| 2 3 5 8
3 4
1 2 3 4 5 6 7 8 9
7 8 9
1 2 3 4 6 7 8
0
| 9,696 |
s339728095 | p00043 | u782850731 | 1376064305 | Python | Python | py | Accepted | 10 | 4296 | 1,185 | #!/usr/bin/env python
# -*- coding: utf-8 -*-
from __future__ import (division, absolute_import, print_function,
unicode_literals)
from sys import stdin
def solve(L):
m = min(L)
cnt = L.count(m)
if cnt > 4:
return False
for _ in xrange(cnt):
L.remove(m)
if cnt in (1, 4):
if not L.count(m+1) or not L.count(m+2):
return False
L.remove(m+1)
L.remove(m+2)
elif cnt == 2:
if L.count(m+1) < 2 or L.count(m+2) < 2:
return False
L.remove(m+1)
L.remove(m+1)
L.remove(m+2)
L.remove(m+2)
return True if not len(L) else solve(L)
for line in stdin:
data = [int(s) for s in line.strip()]
data.append(0)
answers = []
for i in xrange(1, 10):
data[-1] = i
if data.count(i) > 4:
continue
for pair in xrange(1, 10):
if data.count(pair) < 2:
continue
L = data[:]
L.remove(pair)
L.remove(pair)
if solve(L):
answers.append(str(i))
break
print(' '.join(answers) if answers else '0') | p00043 |
<H1>パズル</H1>
<p>
1 〜 9 の数字を 14 個組み合わせて完成させるパズルがあります。与えられた 13 個の数字にもうひとつ数字を付け加えて完成させます。
</p>
<p>
パズルの完成条件は
</p>
<ul>
<li>同じ数字を２つ組み合わせたものが必ずひとつ必要です。</li>
<li>残りの12 個の数字は、３個の数字の組み合わせ４つです。<br>
３個の数字の組み合わせ方は、同じ数字を３つ組み合わせたものか、または３つの連続する数字を組み合わせたものです。ただし、9 1 2 のような並びは連続する数字とは認められません。</li>
<li>同じ数字は4 回まで使えます。</li>
</ul>
<p>
13 個の数字からなる文字列を読み込んで、パズルを完成することができる数字を昇順に全て出力するプログラムを作成してください。なお、1〜9 のどの数字を付け加えてもパズルを完成させることができないときは 0 を出力してください。
</p>
<p>例えば与えられた文字列が 3456666777999 の場合<br/>
<br/>
「2」があれば、 <span>234 567 666 77 999</span><br/>
「3」があれば、 <span>33 456 666 777 999</span><br/>
「5」があれば、 <span>345 567 666 77 999</span><br/>
「8」があれば、 <span>345 666 678 77 999</span><br/>
<br/>
というふうに、2 3 5 8 のいずれかの数字が付け加えられるとパズルは完成します。「6」でも整いますが、5 回目の使用になるので、この例では使えないことに注意してください。
</p>
<H2>Input</H2>
<p>
入力は複数のデータセットからなります。各データセットとして、13 個の数字が１行に与えられます。データセットの数は 50 を超えません。
</p>
<H2>Output</H2>
<p>
データセットごとに、パズルを完成させることができる数字を昇順に空白区切りで１行に出力します。
</p>
<H2>Sample Input</H2>
<pre>
3649596966777
6358665788577
9118992346175
9643871425498
7755542764533
1133557799246
</pre>
<H2>Output for the Sample Input</H2>
<pre>
2 3 5 8
3 4
1 2 3 4 5 6 7 8 9
7 8 9
1 2 3 4 6 7 8
0
</pre>
| 3649596966777
6358665788577
9118992346175
9643871425498
7755542764533
1133557799246
| 2 3 5 8
3 4
1 2 3 4 5 6 7 8 9
7 8 9
1 2 3 4 6 7 8
0
| 9,697 |
s296595059 | p00043 | u912237403 | 1388220397 | Python | Python | py | Accepted | 60 | 4332 | 1,409 | NUM="0123456789"
def atama(x):
return [e for e in set(x) if x.count(e)>=2]
def koutu(x,i):
return x.count(i)>=3
def shuntu(x,i):
return i<8 and x.count(i)>0 and x.count(i+1)>0 and x.count(i+2)>0
def make(x):
return [int(c) for c in x]
def check(x):
for e in set(x):
if koutu(x,e):
y = [NUM[e]*3]
x1=x+[]
x1.remove(e)
x1.remove(e)
x1.remove(e)
if len(x1)==0: return y
else:
y1 = check(x1)
if len(y1)>0: return y+y1
elif shuntu(x,e):
x1=x+[]
y = [NUM[e:e+3]]
x1.remove(e)
x1.remove(e+1)
x1.remove(e+2)
if len(x1)==0: return y
else:
y1 = check(x1)
if len(y1)>0: return y+y1
return ""
try:
while True:
s = raw_input()
y = []
for e in NUM[1:]:
if s.count(e)>=4: continue
x = make(s+e)
for e0 in atama(x):
s0= [ NUM[e0]*2]
x1 = x+[]
x1.remove(e0)
x1.remove(e0)
s0 += check(x1)
if len(s0)==5:
y.append(e)
break
if len(y)==0: print 0
else:
for e in y:
print e,
print
except:
pass | p00043 |
<H1>パズル</H1>
<p>
1 〜 9 の数字を 14 個組み合わせて完成させるパズルがあります。与えられた 13 個の数字にもうひとつ数字を付け加えて完成させます。
</p>
<p>
パズルの完成条件は
</p>
<ul>
<li>同じ数字を２つ組み合わせたものが必ずひとつ必要です。</li>
<li>残りの12 個の数字は、３個の数字の組み合わせ４つです。<br>
３個の数字の組み合わせ方は、同じ数字を３つ組み合わせたものか、または３つの連続する数字を組み合わせたものです。ただし、9 1 2 のような並びは連続する数字とは認められません。</li>
<li>同じ数字は4 回まで使えます。</li>
</ul>
<p>
13 個の数字からなる文字列を読み込んで、パズルを完成することができる数字を昇順に全て出力するプログラムを作成してください。なお、1〜9 のどの数字を付け加えてもパズルを完成させることができないときは 0 を出力してください。
</p>
<p>例えば与えられた文字列が 3456666777999 の場合<br/>
<br/>
「2」があれば、 <span>234 567 666 77 999</span><br/>
「3」があれば、 <span>33 456 666 777 999</span><br/>
「5」があれば、 <span>345 567 666 77 999</span><br/>
「8」があれば、 <span>345 666 678 77 999</span><br/>
<br/>
というふうに、2 3 5 8 のいずれかの数字が付け加えられるとパズルは完成します。「6」でも整いますが、5 回目の使用になるので、この例では使えないことに注意してください。
</p>
<H2>Input</H2>
<p>
入力は複数のデータセットからなります。各データセットとして、13 個の数字が１行に与えられます。データセットの数は 50 を超えません。
</p>
<H2>Output</H2>
<p>
データセットごとに、パズルを完成させることができる数字を昇順に空白区切りで１行に出力します。
</p>
<H2>Sample Input</H2>
<pre>
3649596966777
6358665788577
9118992346175
9643871425498
7755542764533
1133557799246
</pre>
<H2>Output for the Sample Input</H2>
<pre>
2 3 5 8
3 4
1 2 3 4 5 6 7 8 9
7 8 9
1 2 3 4 6 7 8
0
</pre>
| 3649596966777
6358665788577
9118992346175
9643871425498
7755542764533
1133557799246
| 2 3 5 8
3 4
1 2 3 4 5 6 7 8 9
7 8 9
1 2 3 4 6 7 8
0
| 9,698 |
s294805589 | p00043 | u912237403 | 1388267947 | Python | Python | py | Accepted | 30 | 4276 | 852 | def check(x,j=1):
if sum(x)==0: return True
for i in range(j,10):
y = x[:]
if y[i]>=3:
y[i] -= 3
if check(y,i): return True
y = x[:]
if i<8 and y[i]>0 and y[i+1]>0 and y[i+2]>0:
y[i] -= 1
y[i+1] -= 1
y[i+2] -= 1
if check(y,i): return True
return False
while True:
c = [0]*10
try:
for e in map(int,raw_input()):
c[e] += 1
except:
break
f = False
for i in range(1,10):
c1=c[:]
if c1[i]>=4: continue
else: c1[i]+=1
atama = [j for j,e in enumerate(c1) if e>=2]
for e in atama:
c1[e]-=2
if check(c1):
f = True
print i,
break
c1[e]+=2
if f: print
else: print 0 | p00043 |
<H1>パズル</H1>
<p>
1 〜 9 の数字を 14 個組み合わせて完成させるパズルがあります。与えられた 13 個の数字にもうひとつ数字を付け加えて完成させます。
</p>
<p>
パズルの完成条件は
</p>
<ul>
<li>同じ数字を２つ組み合わせたものが必ずひとつ必要です。</li>
<li>残りの12 個の数字は、３個の数字の組み合わせ４つです。<br>
３個の数字の組み合わせ方は、同じ数字を３つ組み合わせたものか、または３つの連続する数字を組み合わせたものです。ただし、9 1 2 のような並びは連続する数字とは認められません。</li>
<li>同じ数字は4 回まで使えます。</li>
</ul>
<p>
13 個の数字からなる文字列を読み込んで、パズルを完成することができる数字を昇順に全て出力するプログラムを作成してください。なお、1〜9 のどの数字を付け加えてもパズルを完成させることができないときは 0 を出力してください。
</p>
<p>例えば与えられた文字列が 3456666777999 の場合<br/>
<br/>
「2」があれば、 <span>234 567 666 77 999</span><br/>
「3」があれば、 <span>33 456 666 777 999</span><br/>
「5」があれば、 <span>345 567 666 77 999</span><br/>
「8」があれば、 <span>345 666 678 77 999</span><br/>
<br/>
というふうに、2 3 5 8 のいずれかの数字が付け加えられるとパズルは完成します。「6」でも整いますが、5 回目の使用になるので、この例では使えないことに注意してください。
</p>
<H2>Input</H2>
<p>
入力は複数のデータセットからなります。各データセットとして、13 個の数字が１行に与えられます。データセットの数は 50 を超えません。
</p>
<H2>Output</H2>
<p>
データセットごとに、パズルを完成させることができる数字を昇順に空白区切りで１行に出力します。
</p>
<H2>Sample Input</H2>
<pre>
3649596966777
6358665788577
9118992346175
9643871425498
7755542764533
1133557799246
</pre>
<H2>Output for the Sample Input</H2>
<pre>
2 3 5 8
3 4
1 2 3 4 5 6 7 8 9
7 8 9
1 2 3 4 6 7 8
0
</pre>
| 3649596966777
6358665788577
9118992346175
9643871425498
7755542764533
1133557799246
| 2 3 5 8
3 4
1 2 3 4 5 6 7 8 9
7 8 9
1 2 3 4 6 7 8
0
| 9,699 |
s393343090 | p00043 | u912237403 | 1388397402 | Python | Python | py | Accepted | 10 | 4284 | 836 | def check(x,j=1):
if sum(x)==0: return True
for i in range(j,10):
if x[i]>0:break
y = x[:]
if y[i]>=3:
y[i] -= 3
if check(y,i): return True
y = x[:]
if i<8 and y[i]>0 and y[i+1]>0 and y[i+2]>0:
y[i] -= 1
y[i+1] -= 1
y[i+2] -= 1
if check(y,i): return True
return False
while True:
c = [0]*10
try:
for e in map(int,raw_input()):
c[e] += 1
except:
break
f = False
for i in range(1,10):
c1=c[:]
if c1[i]>=4: continue
else: c1[i]+=1
atama = [j for j,e in enumerate(c1) if e>=2]
for e in atama:
c1[e]-=2
if check(c1):
f = True
print i,
break
c1[e]+=2
if f: print
else: print 0 | p00043 |
<H1>パズル</H1>
<p>
1 〜 9 の数字を 14 個組み合わせて完成させるパズルがあります。与えられた 13 個の数字にもうひとつ数字を付け加えて完成させます。
</p>
<p>
パズルの完成条件は
</p>
<ul>
<li>同じ数字を２つ組み合わせたものが必ずひとつ必要です。</li>
<li>残りの12 個の数字は、３個の数字の組み合わせ４つです。<br>
３個の数字の組み合わせ方は、同じ数字を３つ組み合わせたものか、または３つの連続する数字を組み合わせたものです。ただし、9 1 2 のような並びは連続する数字とは認められません。</li>
<li>同じ数字は4 回まで使えます。</li>
</ul>
<p>
13 個の数字からなる文字列を読み込んで、パズルを完成することができる数字を昇順に全て出力するプログラムを作成してください。なお、1〜9 のどの数字を付け加えてもパズルを完成させることができないときは 0 を出力してください。
</p>
<p>例えば与えられた文字列が 3456666777999 の場合<br/>
<br/>
「2」があれば、 <span>234 567 666 77 999</span><br/>
「3」があれば、 <span>33 456 666 777 999</span><br/>
「5」があれば、 <span>345 567 666 77 999</span><br/>
「8」があれば、 <span>345 666 678 77 999</span><br/>
<br/>
というふうに、2 3 5 8 のいずれかの数字が付け加えられるとパズルは完成します。「6」でも整いますが、5 回目の使用になるので、この例では使えないことに注意してください。
</p>
<H2>Input</H2>
<p>
入力は複数のデータセットからなります。各データセットとして、13 個の数字が１行に与えられます。データセットの数は 50 を超えません。
</p>
<H2>Output</H2>
<p>
データセットごとに、パズルを完成させることができる数字を昇順に空白区切りで１行に出力します。
</p>
<H2>Sample Input</H2>
<pre>
3649596966777
6358665788577
9118992346175
9643871425498
7755542764533
1133557799246
</pre>
<H2>Output for the Sample Input</H2>
<pre>
2 3 5 8
3 4
1 2 3 4 5 6 7 8 9
7 8 9
1 2 3 4 6 7 8
0
</pre>
| 3649596966777
6358665788577
9118992346175
9643871425498
7755542764533
1133557799246
| 2 3 5 8
3 4
1 2 3 4 5 6 7 8 9
7 8 9
1 2 3 4 6 7 8
0
| 9,700 |
s078884237 | p00043 | u912237403 | 1394867652 | Python | Python | py | Accepted | 10 | 4276 | 743 | import sys
def check(x,j=1):
if sum(x)==0: return 1
i = j
while x[i]==0: i+=1
y = x[:]
if y[i]>=3:
y[i] -= 3
if check(y,i): return 1
y = x[:]
if i<8 and y[i]>0 and y[i+1]>0 and y[i+2]>0:
y[i] -= 1
y[i+1] -= 1
y[i+2] -= 1
if check(y,i): return 1
return 0
for s in sys.stdin:
c = [0]*10
for e in map(int,s[:-1]): c[e] += 1
f = 0
R = range(1,10)
for i in R:
c1=c[:]
if c1[i]>=4:continue
c1[i]+=1
for j in R:
if c1[j]<2:continue
c1[j]-=2
if check(c1):
f = 1
print i,
break
c1[j]+=2
if f: print
else: print 0 | p00043 |
<H1>パズル</H1>
<p>
1 〜 9 の数字を 14 個組み合わせて完成させるパズルがあります。与えられた 13 個の数字にもうひとつ数字を付け加えて完成させます。
</p>
<p>
パズルの完成条件は
</p>
<ul>
<li>同じ数字を２つ組み合わせたものが必ずひとつ必要です。</li>
<li>残りの12 個の数字は、３個の数字の組み合わせ４つです。<br>
３個の数字の組み合わせ方は、同じ数字を３つ組み合わせたものか、または３つの連続する数字を組み合わせたものです。ただし、9 1 2 のような並びは連続する数字とは認められません。</li>
<li>同じ数字は4 回まで使えます。</li>
</ul>
<p>
13 個の数字からなる文字列を読み込んで、パズルを完成することができる数字を昇順に全て出力するプログラムを作成してください。なお、1〜9 のどの数字を付け加えてもパズルを完成させることができないときは 0 を出力してください。
</p>
<p>例えば与えられた文字列が 3456666777999 の場合<br/>
<br/>
「2」があれば、 <span>234 567 666 77 999</span><br/>
「3」があれば、 <span>33 456 666 777 999</span><br/>
「5」があれば、 <span>345 567 666 77 999</span><br/>
「8」があれば、 <span>345 666 678 77 999</span><br/>
<br/>
というふうに、2 3 5 8 のいずれかの数字が付け加えられるとパズルは完成します。「6」でも整いますが、5 回目の使用になるので、この例では使えないことに注意してください。
</p>
<H2>Input</H2>
<p>
入力は複数のデータセットからなります。各データセットとして、13 個の数字が１行に与えられます。データセットの数は 50 を超えません。
</p>
<H2>Output</H2>
<p>
データセットごとに、パズルを完成させることができる数字を昇順に空白区切りで１行に出力します。
</p>
<H2>Sample Input</H2>
<pre>
3649596966777
6358665788577
9118992346175
9643871425498
7755542764533
1133557799246
</pre>
<H2>Output for the Sample Input</H2>
<pre>
2 3 5 8
3 4
1 2 3 4 5 6 7 8 9
7 8 9
1 2 3 4 6 7 8
0
</pre>
| 3649596966777
6358665788577
9118992346175
9643871425498
7755542764533
1133557799246
| 2 3 5 8
3 4
1 2 3 4 5 6 7 8 9
7 8 9
1 2 3 4 6 7 8
0
| 9,701 |
s590920194 | p00043 | u633068244 | 1396017157 | Python | Python | py | Accepted | 30 | 4280 | 966 | def rm_shuntsu(hand):
for hai in set(hand):
if (hai in hand) and (hai+1 in hand) and (hai+2 in hand):
if len(hand) == 3: return True
hand1 = hand[:]
hand1.remove(hai);hand1.remove(hai+1);hand1.remove(hai+2)
return is_hora(hand1)
else: return False
def rm_kotsu(hand):
for hai in set(hand):
if hand.count(hai) >= 3:
if len(hand) == 3: return True
hand1 = hand[:]
hand1.remove(hai);hand1.remove(hai);hand1.remove(hai)
return is_hora(hand1)
else: return False
def is_hora(hand):
return rm_shuntsu(hand) or rm_kotsu(hand)
while True:
try:
hand = map(int, raw_input())
ans = []
for tumo in range(1,10):
if hand.count(tumo) <= 3:
for janto in set(hand+[tumo]):
if 2 <= (hand+[tumo]).count(janto):
hand1 = hand[:]+[tumo]
hand1.remove(janto);hand1.remove(janto)
if is_hora(hand1):
ans.append(tumo)
break
print " ".join(map(str, sorted(ans))) if len(ans) > 0 else 0
except:
break | p00043 |
<H1>パズル</H1>
<p>
1 〜 9 の数字を 14 個組み合わせて完成させるパズルがあります。与えられた 13 個の数字にもうひとつ数字を付け加えて完成させます。
</p>
<p>
パズルの完成条件は
</p>
<ul>
<li>同じ数字を２つ組み合わせたものが必ずひとつ必要です。</li>
<li>残りの12 個の数字は、３個の数字の組み合わせ４つです。<br>
３個の数字の組み合わせ方は、同じ数字を３つ組み合わせたものか、または３つの連続する数字を組み合わせたものです。ただし、9 1 2 のような並びは連続する数字とは認められません。</li>
<li>同じ数字は4 回まで使えます。</li>
</ul>
<p>
13 個の数字からなる文字列を読み込んで、パズルを完成することができる数字を昇順に全て出力するプログラムを作成してください。なお、1〜9 のどの数字を付け加えてもパズルを完成させることができないときは 0 を出力してください。
</p>
<p>例えば与えられた文字列が 3456666777999 の場合<br/>
<br/>
「2」があれば、 <span>234 567 666 77 999</span><br/>
「3」があれば、 <span>33 456 666 777 999</span><br/>
「5」があれば、 <span>345 567 666 77 999</span><br/>
「8」があれば、 <span>345 666 678 77 999</span><br/>
<br/>
というふうに、2 3 5 8 のいずれかの数字が付け加えられるとパズルは完成します。「6」でも整いますが、5 回目の使用になるので、この例では使えないことに注意してください。
</p>
<H2>Input</H2>
<p>
入力は複数のデータセットからなります。各データセットとして、13 個の数字が１行に与えられます。データセットの数は 50 を超えません。
</p>
<H2>Output</H2>
<p>
データセットごとに、パズルを完成させることができる数字を昇順に空白区切りで１行に出力します。
</p>
<H2>Sample Input</H2>
<pre>
3649596966777
6358665788577
9118992346175
9643871425498
7755542764533
1133557799246
</pre>
<H2>Output for the Sample Input</H2>
<pre>
2 3 5 8
3 4
1 2 3 4 5 6 7 8 9
7 8 9
1 2 3 4 6 7 8
0
</pre>
| 3649596966777
6358665788577
9118992346175
9643871425498
7755542764533
1133557799246
| 2 3 5 8
3 4
1 2 3 4 5 6 7 8 9
7 8 9
1 2 3 4 6 7 8
0
| 9,702 |
s357751291 | p00043 | u633068244 | 1396017840 | Python | Python | py | Accepted | 30 | 4280 | 792 | def rm_s(h):
for hai in set(h):
if (hai in h) and (hai+1 in h) and (hai+2 in h):
if len(h) == 3: return 1
h1 = h[:]
for i in range(3): h1.remove(hai+i)
return is_hora(h1)
else: return 0
def rm_k(h):
for hai in set(h):
if h.count(hai) >= 3:
if len(h) == 3: return 1
h1 = h[:]
for i in range(3): h1.remove(hai)
return is_hora(h1)
else: return 0
def is_hora(h):
return rm_s(h) or rm_k(h)
while True:
try:
h = map(int, raw_input())
ans = []
for add in range(1,10):
if h.count(add) <= 3:
h1 = h[:]+[add]
for d in set(h1):
if 2 <= h1.count(d):
h1 = h[:]+[add]
h1.remove(d);h1.remove(d)
if is_hora(h1):
ans.append(add)
break
print " ".join(map(str, sorted(ans))) if len(ans) > 0 else 0
except:
break | p00043 |
<H1>パズル</H1>
<p>
1 〜 9 の数字を 14 個組み合わせて完成させるパズルがあります。与えられた 13 個の数字にもうひとつ数字を付け加えて完成させます。
</p>
<p>
パズルの完成条件は
</p>
<ul>
<li>同じ数字を２つ組み合わせたものが必ずひとつ必要です。</li>
<li>残りの12 個の数字は、３個の数字の組み合わせ４つです。<br>
３個の数字の組み合わせ方は、同じ数字を３つ組み合わせたものか、または３つの連続する数字を組み合わせたものです。ただし、9 1 2 のような並びは連続する数字とは認められません。</li>
<li>同じ数字は4 回まで使えます。</li>
</ul>
<p>
13 個の数字からなる文字列を読み込んで、パズルを完成することができる数字を昇順に全て出力するプログラムを作成してください。なお、1〜9 のどの数字を付け加えてもパズルを完成させることができないときは 0 を出力してください。
</p>
<p>例えば与えられた文字列が 3456666777999 の場合<br/>
<br/>
「2」があれば、 <span>234 567 666 77 999</span><br/>
「3」があれば、 <span>33 456 666 777 999</span><br/>
「5」があれば、 <span>345 567 666 77 999</span><br/>
「8」があれば、 <span>345 666 678 77 999</span><br/>
<br/>
というふうに、2 3 5 8 のいずれかの数字が付け加えられるとパズルは完成します。「6」でも整いますが、5 回目の使用になるので、この例では使えないことに注意してください。
</p>
<H2>Input</H2>
<p>
入力は複数のデータセットからなります。各データセットとして、13 個の数字が１行に与えられます。データセットの数は 50 を超えません。
</p>
<H2>Output</H2>
<p>
データセットごとに、パズルを完成させることができる数字を昇順に空白区切りで１行に出力します。
</p>
<H2>Sample Input</H2>
<pre>
3649596966777
6358665788577
9118992346175
9643871425498
7755542764533
1133557799246
</pre>
<H2>Output for the Sample Input</H2>
<pre>
2 3 5 8
3 4
1 2 3 4 5 6 7 8 9
7 8 9
1 2 3 4 6 7 8
0
</pre>
| 3649596966777
6358665788577
9118992346175
9643871425498
7755542764533
1133557799246
| 2 3 5 8
3 4
1 2 3 4 5 6 7 8 9
7 8 9
1 2 3 4 6 7 8
0
| 9,703 |
s695398339 | p00043 | u633068244 | 1396017983 | Python | Python | py | Accepted | 30 | 4280 | 792 | def rm_s(h):
for hai in set(h):
if (hai in h) and (hai+1 in h) and (hai+2 in h):
if len(h) == 3: return 1
h1 = h[:]
for i in range(3): h1.remove(hai+i)
return is_hora(h1)
else: return 0
def rm_k(h):
for hai in set(h):
if h.count(hai) >= 3:
if len(h) == 3: return 1
h1 = h[:]
for i in range(3): h1.remove(hai)
return is_hora(h1)
else: return 0
def is_hora(h):
return rm_k(h) or rm_s(h)
while True:
try:
h = map(int, raw_input())
ans = []
for add in range(1,10):
if h.count(add) <= 3:
h1 = h[:]+[add]
for d in set(h1):
if 2 <= h1.count(d):
h1 = h[:]+[add]
h1.remove(d);h1.remove(d)
if is_hora(h1):
ans.append(add)
break
print " ".join(map(str, sorted(ans))) if len(ans) > 0 else 0
except:
break | p00043 |
<H1>パズル</H1>
<p>
1 〜 9 の数字を 14 個組み合わせて完成させるパズルがあります。与えられた 13 個の数字にもうひとつ数字を付け加えて完成させます。
</p>
<p>
パズルの完成条件は
</p>
<ul>
<li>同じ数字を２つ組み合わせたものが必ずひとつ必要です。</li>
<li>残りの12 個の数字は、３個の数字の組み合わせ４つです。<br>
３個の数字の組み合わせ方は、同じ数字を３つ組み合わせたものか、または３つの連続する数字を組み合わせたものです。ただし、9 1 2 のような並びは連続する数字とは認められません。</li>
<li>同じ数字は4 回まで使えます。</li>
</ul>
<p>
13 個の数字からなる文字列を読み込んで、パズルを完成することができる数字を昇順に全て出力するプログラムを作成してください。なお、1〜9 のどの数字を付け加えてもパズルを完成させることができないときは 0 を出力してください。
</p>
<p>例えば与えられた文字列が 3456666777999 の場合<br/>
<br/>
「2」があれば、 <span>234 567 666 77 999</span><br/>
「3」があれば、 <span>33 456 666 777 999</span><br/>
「5」があれば、 <span>345 567 666 77 999</span><br/>
「8」があれば、 <span>345 666 678 77 999</span><br/>
<br/>
というふうに、2 3 5 8 のいずれかの数字が付け加えられるとパズルは完成します。「6」でも整いますが、5 回目の使用になるので、この例では使えないことに注意してください。
</p>
<H2>Input</H2>
<p>
入力は複数のデータセットからなります。各データセットとして、13 個の数字が１行に与えられます。データセットの数は 50 を超えません。
</p>
<H2>Output</H2>
<p>
データセットごとに、パズルを完成させることができる数字を昇順に空白区切りで１行に出力します。
</p>
<H2>Sample Input</H2>
<pre>
3649596966777
6358665788577
9118992346175
9643871425498
7755542764533
1133557799246
</pre>
<H2>Output for the Sample Input</H2>
<pre>
2 3 5 8
3 4
1 2 3 4 5 6 7 8 9
7 8 9
1 2 3 4 6 7 8
0
</pre>
| 3649596966777
6358665788577
9118992346175
9643871425498
7755542764533
1133557799246
| 2 3 5 8
3 4
1 2 3 4 5 6 7 8 9
7 8 9
1 2 3 4 6 7 8
0
| 9,704 |
s895684486 | p00043 | u633068244 | 1396018351 | Python | Python | py | Accepted | 30 | 4276 | 791 | def rm_s(h):
seth = set(h)
for hai in seth:
if set([hai,hai+1,hai+2]) <= seth:
if len(h) == 3: return 1
h1 = h[:]
for i in range(3): h1.remove(hai+i)
return is_hora(h1)
else: return 0
def rm_k(h):
for hai in set(h):
if h.count(hai) >= 3:
if len(h) == 3: return 1
h1 = h[:]
for i in range(3): h1.remove(hai)
return is_hora(h1)
else: return 0
def is_hora(h):
return rm_k(h) or rm_s(h)
while True:
try:
h = map(int, raw_input())
ans = []
for add in range(1,10):
if h.count(add) <= 3:
h1 = h[:]+[add]
for d in set(h1):
if 2 <= h1.count(d):
h1 = h[:]+[add]
h1.remove(d);h1.remove(d)
if is_hora(h1):
ans.append(add)
break
print " ".join(map(str, sorted(ans))) if len(ans) > 0 else 0
except:
break | p00043 |
<H1>パズル</H1>
<p>
1 〜 9 の数字を 14 個組み合わせて完成させるパズルがあります。与えられた 13 個の数字にもうひとつ数字を付け加えて完成させます。
</p>
<p>
パズルの完成条件は
</p>
<ul>
<li>同じ数字を２つ組み合わせたものが必ずひとつ必要です。</li>
<li>残りの12 個の数字は、３個の数字の組み合わせ４つです。<br>
３個の数字の組み合わせ方は、同じ数字を３つ組み合わせたものか、または３つの連続する数字を組み合わせたものです。ただし、9 1 2 のような並びは連続する数字とは認められません。</li>
<li>同じ数字は4 回まで使えます。</li>
</ul>
<p>
13 個の数字からなる文字列を読み込んで、パズルを完成することができる数字を昇順に全て出力するプログラムを作成してください。なお、1〜9 のどの数字を付け加えてもパズルを完成させることができないときは 0 を出力してください。
</p>
<p>例えば与えられた文字列が 3456666777999 の場合<br/>
<br/>
「2」があれば、 <span>234 567 666 77 999</span><br/>
「3」があれば、 <span>33 456 666 777 999</span><br/>
「5」があれば、 <span>345 567 666 77 999</span><br/>
「8」があれば、 <span>345 666 678 77 999</span><br/>
<br/>
というふうに、2 3 5 8 のいずれかの数字が付け加えられるとパズルは完成します。「6」でも整いますが、5 回目の使用になるので、この例では使えないことに注意してください。
</p>
<H2>Input</H2>
<p>
入力は複数のデータセットからなります。各データセットとして、13 個の数字が１行に与えられます。データセットの数は 50 を超えません。
</p>
<H2>Output</H2>
<p>
データセットごとに、パズルを完成させることができる数字を昇順に空白区切りで１行に出力します。
</p>
<H2>Sample Input</H2>
<pre>
3649596966777
6358665788577
9118992346175
9643871425498
7755542764533
1133557799246
</pre>
<H2>Output for the Sample Input</H2>
<pre>
2 3 5 8
3 4
1 2 3 4 5 6 7 8 9
7 8 9
1 2 3 4 6 7 8
0
</pre>
| 3649596966777
6358665788577
9118992346175
9643871425498
7755542764533
1133557799246
| 2 3 5 8
3 4
1 2 3 4 5 6 7 8 9
7 8 9
1 2 3 4 6 7 8
0
| 9,705 |
s156771814 | p00043 | u246033265 | 1396803445 | Python | Python | py | Accepted | 50 | 4284 | 925 | def f(a):
if a == [0] * 10:
return True
for i in range(1, 10):
if a[i] < 3: continue
b = list(a)
b[i] -= 3
if f(b):
return True
for i in range(3, 10):
if a[i - 2] == 0 or a[i - 1] == 0 or a[i] == 0: continue
b = list(a)
for j in range(i - 2, i + 1):
b[j] -= 1
if f(b):
return True
return False
try:
while True:
a = [0] * 10
for c in raw_input():
a[int(c)] += 1
d = []
for i in range(1, 10):
if a[i] == 4: continue
b = list(a)
b[i] += 1
for j in range(1, 10):
if b[j] < 2: continue
c = list(b)
c[j] -= 2
if f(c):
d.append(str(i))
break
print ' '.join(d) if d else 0
except EOFError:
pass | p00043 |
<H1>パズル</H1>
<p>
1 〜 9 の数字を 14 個組み合わせて完成させるパズルがあります。与えられた 13 個の数字にもうひとつ数字を付け加えて完成させます。
</p>
<p>
パズルの完成条件は
</p>
<ul>
<li>同じ数字を２つ組み合わせたものが必ずひとつ必要です。</li>
<li>残りの12 個の数字は、３個の数字の組み合わせ４つです。<br>
３個の数字の組み合わせ方は、同じ数字を３つ組み合わせたものか、または３つの連続する数字を組み合わせたものです。ただし、9 1 2 のような並びは連続する数字とは認められません。</li>
<li>同じ数字は4 回まで使えます。</li>
</ul>
<p>
13 個の数字からなる文字列を読み込んで、パズルを完成することができる数字を昇順に全て出力するプログラムを作成してください。なお、1〜9 のどの数字を付け加えてもパズルを完成させることができないときは 0 を出力してください。
</p>
<p>例えば与えられた文字列が 3456666777999 の場合<br/>
<br/>
「2」があれば、 <span>234 567 666 77 999</span><br/>
「3」があれば、 <span>33 456 666 777 999</span><br/>
「5」があれば、 <span>345 567 666 77 999</span><br/>
「8」があれば、 <span>345 666 678 77 999</span><br/>
<br/>
というふうに、2 3 5 8 のいずれかの数字が付け加えられるとパズルは完成します。「6」でも整いますが、5 回目の使用になるので、この例では使えないことに注意してください。
</p>
<H2>Input</H2>
<p>
入力は複数のデータセットからなります。各データセットとして、13 個の数字が１行に与えられます。データセットの数は 50 を超えません。
</p>
<H2>Output</H2>
<p>
データセットごとに、パズルを完成させることができる数字を昇順に空白区切りで１行に出力します。
</p>
<H2>Sample Input</H2>
<pre>
3649596966777
6358665788577
9118992346175
9643871425498
7755542764533
1133557799246
</pre>
<H2>Output for the Sample Input</H2>
<pre>
2 3 5 8
3 4
1 2 3 4 5 6 7 8 9
7 8 9
1 2 3 4 6 7 8
0
</pre>
| 3649596966777
6358665788577
9118992346175
9643871425498
7755542764533
1133557799246
| 2 3 5 8
3 4
1 2 3 4 5 6 7 8 9
7 8 9
1 2 3 4 6 7 8
0
| 9,706 |
s359340708 | p00043 | u491763171 | 1400476476 | Python | Python | py | Accepted | 20 | 4592 | 917 | from collections import Counter
while 1:
try:
puzzle = map(int, raw_input())
except EOFError:
break
ret = []
for i in xrange(1, 10):
cnt = Counter(puzzle + [i])
if cnt[i] > 4:
continue
for j in xrange(1, 10):
if cnt[j] < 2:
continue
tmp = Counter(puzzle + [i])
tmp[j] -= 2
for k in xrange(1, 10):
if not tmp[k]:
continue
if tmp[k] >= 3:
tmp[k] -= 3
while tmp[k] and tmp[k + 1] and tmp[k + 2]:
tmp[k] -= 1
tmp[k + 1] -= 1
tmp[k + 2] -= 1
if tmp[k]:
break
else:
ret.append(i)
break
if ret:
print ' '.join(map(str, ret))
else:
print 0 | p00043 |
<H1>パズル</H1>
<p>
1 〜 9 の数字を 14 個組み合わせて完成させるパズルがあります。与えられた 13 個の数字にもうひとつ数字を付け加えて完成させます。
</p>
<p>
パズルの完成条件は
</p>
<ul>
<li>同じ数字を２つ組み合わせたものが必ずひとつ必要です。</li>
<li>残りの12 個の数字は、３個の数字の組み合わせ４つです。<br>
３個の数字の組み合わせ方は、同じ数字を３つ組み合わせたものか、または３つの連続する数字を組み合わせたものです。ただし、9 1 2 のような並びは連続する数字とは認められません。</li>
<li>同じ数字は4 回まで使えます。</li>
</ul>
<p>
13 個の数字からなる文字列を読み込んで、パズルを完成することができる数字を昇順に全て出力するプログラムを作成してください。なお、1〜9 のどの数字を付け加えてもパズルを完成させることができないときは 0 を出力してください。
</p>
<p>例えば与えられた文字列が 3456666777999 の場合<br/>
<br/>
「2」があれば、 <span>234 567 666 77 999</span><br/>
「3」があれば、 <span>33 456 666 777 999</span><br/>
「5」があれば、 <span>345 567 666 77 999</span><br/>
「8」があれば、 <span>345 666 678 77 999</span><br/>
<br/>
というふうに、2 3 5 8 のいずれかの数字が付け加えられるとパズルは完成します。「6」でも整いますが、5 回目の使用になるので、この例では使えないことに注意してください。
</p>
<H2>Input</H2>
<p>
入力は複数のデータセットからなります。各データセットとして、13 個の数字が１行に与えられます。データセットの数は 50 を超えません。
</p>
<H2>Output</H2>
<p>
データセットごとに、パズルを完成させることができる数字を昇順に空白区切りで１行に出力します。
</p>
<H2>Sample Input</H2>
<pre>
3649596966777
6358665788577
9118992346175
9643871425498
7755542764533
1133557799246
</pre>
<H2>Output for the Sample Input</H2>
<pre>
2 3 5 8
3 4
1 2 3 4 5 6 7 8 9
7 8 9
1 2 3 4 6 7 8
0
</pre>
| 3649596966777
6358665788577
9118992346175
9643871425498
7755542764533
1133557799246
| 2 3 5 8
3 4
1 2 3 4 5 6 7 8 9
7 8 9
1 2 3 4 6 7 8
0
| 9,707 |
s930737189 | p00043 | u260980560 | 1589700852 | Python | Python3 | py | Accepted | 30 | 5736 | 1,305 | import sys
readlines = sys.stdin.readlines
write = sys.stdout.write
memo = {}
def solve(s):
d = [0]*10
for c in s:
d[int(c)] += 1
def dfs(i, d):
if i == 10:
return True
key = tuple(d)
if s in key:
return memo[key]
if d[i] == 0:
return dfs(i+1, d)
if d[i] >= 3:
d[i] -= 3
r = dfs(i, d)
d[i] += 3
if r:
memo[key] = True
return True
if i+2 <= 9 and d[i+1] >= 1 and d[i+2] >= 1:
d[i] -= 1; d[i+1] -= 1; d[i+2] -= 1
r = dfs(i, d)
d[i] += 1; d[i+1] += 1; d[i+2] += 1
if r:
memo[key] = True
return True
memo[key] = False
return False
ans = []
for k in range(1, 10):
if d[k] == 4:
continue
d[k] += 1
for i in range(10):
if d[i] >= 2:
d[i] -= 2
r = dfs(0, d)
d[i] += 2
if r:
ans.append(k)
break
d[k] -= 1
if not ans:
ans.append(0)
return ans
for line in readlines():
res = solve(line.strip())
write(" ".join(map(str, res)))
write("\n")
| p00043 |
<H1>パズル</H1>
<p>
1 〜 9 の数字を 14 個組み合わせて完成させるパズルがあります。与えられた 13 個の数字にもうひとつ数字を付け加えて完成させます。
</p>
<p>
パズルの完成条件は
</p>
<ul>
<li>同じ数字を２つ組み合わせたものが必ずひとつ必要です。</li>
<li>残りの12 個の数字は、３個の数字の組み合わせ４つです。<br>
３個の数字の組み合わせ方は、同じ数字を３つ組み合わせたものか、または３つの連続する数字を組み合わせたものです。ただし、9 1 2 のような並びは連続する数字とは認められません。</li>
<li>同じ数字は4 回まで使えます。</li>
</ul>
<p>
13 個の数字からなる文字列を読み込んで、パズルを完成することができる数字を昇順に全て出力するプログラムを作成してください。なお、1〜9 のどの数字を付け加えてもパズルを完成させることができないときは 0 を出力してください。
</p>
<p>例えば与えられた文字列が 3456666777999 の場合<br/>
<br/>
「2」があれば、 <span>234 567 666 77 999</span><br/>
「3」があれば、 <span>33 456 666 777 999</span><br/>
「5」があれば、 <span>345 567 666 77 999</span><br/>
「8」があれば、 <span>345 666 678 77 999</span><br/>
<br/>
というふうに、2 3 5 8 のいずれかの数字が付け加えられるとパズルは完成します。「6」でも整いますが、5 回目の使用になるので、この例では使えないことに注意してください。
</p>
<H2>Input</H2>
<p>
入力は複数のデータセットからなります。各データセットとして、13 個の数字が１行に与えられます。データセットの数は 50 を超えません。
</p>
<H2>Output</H2>
<p>
データセットごとに、パズルを完成させることができる数字を昇順に空白区切りで１行に出力します。
</p>
<H2>Sample Input</H2>
<pre>
3649596966777
6358665788577
9118992346175
9643871425498
7755542764533
1133557799246
</pre>
<H2>Output for the Sample Input</H2>
<pre>
2 3 5 8
3 4
1 2 3 4 5 6 7 8 9
7 8 9
1 2 3 4 6 7 8
0
</pre>
| 3649596966777
6358665788577
9118992346175
9643871425498
7755542764533
1133557799246
| 2 3 5 8
3 4
1 2 3 4 5 6 7 8 9
7 8 9
1 2 3 4 6 7 8
0
| 9,708 |
s617542846 | p00043 | u371539389 | 1585150979 | Python | Python3 | py | Accepted | 50 | 6316 | 1,178 | from collections import Counter
from copy import copy
def _check(pi):
pi=sorted(pi)
if len(pi)==0:
return True
retval=False
try:
_pi=copy(pi)
tmp=_pi[0]
for i in range(3):
_pi.remove(tmp)
retval = retval or _check(_pi)
except:
pass
try:
_pi=copy(pi)
tmp=_pi[0]
for i in range(3):
_pi.remove(tmp+i)
retval = retval or _check(_pi)
except:
pass
return retval
def check(pi,tsumo):
pi=pi+[tsumo]
c=Counter(pi)
for i in range(1,10):
if c[i]>4:
return False
for i in range(1,10):
if c[i]>=2:
_pi = copy(pi)
_pi.remove(i)
_pi.remove(i)
_pi=sorted(_pi)
if _check(_pi):
return True
return False
while True:
try:
s=input()
s=[int(i) for i in s]
retval=[]
for i in range(1,10):
if check(s,i):
retval.append(str(i))
if len(retval)==0:
print("0")
else:
print(" ".join(retval))
except EOFError:
break
| p00043 |
<H1>パズル</H1>
<p>
1 〜 9 の数字を 14 個組み合わせて完成させるパズルがあります。与えられた 13 個の数字にもうひとつ数字を付け加えて完成させます。
</p>
<p>
パズルの完成条件は
</p>
<ul>
<li>同じ数字を２つ組み合わせたものが必ずひとつ必要です。</li>
<li>残りの12 個の数字は、３個の数字の組み合わせ４つです。<br>
３個の数字の組み合わせ方は、同じ数字を３つ組み合わせたものか、または３つの連続する数字を組み合わせたものです。ただし、9 1 2 のような並びは連続する数字とは認められません。</li>
<li>同じ数字は4 回まで使えます。</li>
</ul>
<p>
13 個の数字からなる文字列を読み込んで、パズルを完成することができる数字を昇順に全て出力するプログラムを作成してください。なお、1〜9 のどの数字を付け加えてもパズルを完成させることができないときは 0 を出力してください。
</p>
<p>例えば与えられた文字列が 3456666777999 の場合<br/>
<br/>
「2」があれば、 <span>234 567 666 77 999</span><br/>
「3」があれば、 <span>33 456 666 777 999</span><br/>
「5」があれば、 <span>345 567 666 77 999</span><br/>
「8」があれば、 <span>345 666 678 77 999</span><br/>
<br/>
というふうに、2 3 5 8 のいずれかの数字が付け加えられるとパズルは完成します。「6」でも整いますが、5 回目の使用になるので、この例では使えないことに注意してください。
</p>
<H2>Input</H2>
<p>
入力は複数のデータセットからなります。各データセットとして、13 個の数字が１行に与えられます。データセットの数は 50 を超えません。
</p>
<H2>Output</H2>
<p>
データセットごとに、パズルを完成させることができる数字を昇順に空白区切りで１行に出力します。
</p>
<H2>Sample Input</H2>
<pre>
3649596966777
6358665788577
9118992346175
9643871425498
7755542764533
1133557799246
</pre>
<H2>Output for the Sample Input</H2>
<pre>
2 3 5 8
3 4
1 2 3 4 5 6 7 8 9
7 8 9
1 2 3 4 6 7 8
0
</pre>
| 3649596966777
6358665788577
9118992346175
9643871425498
7755542764533
1133557799246
| 2 3 5 8
3 4
1 2 3 4 5 6 7 8 9
7 8 9
1 2 3 4 6 7 8
0
| 9,709 |
s321715673 | p00043 | u647694976 | 1557993110 | Python | Python3 | py | Accepted | 30 | 5604 | 1,016 | def check(nums):
for i in range(9):
if(nums[i]>4):return False
for head in range(9):
anums=nums[:]
if(anums[head]<2):continue
anums[head]-=2
for i in range(9):
if(anums[i]>=3):
anums[i]-=3
while(anums[i]>0):
if i>=7:break
ok=True
for j in range(i,i+3):
if anums[j]<=0:
ok=True
if not ok:
break
for j in range(i,i+3):
anums[j]-=1
if not any(anums):
return True
return False
while True:
st=""
try:
st=input()
if st=="":break
except:break
nums=[0 for i in range(9)]
for c in st:
nums[int(c)-1]+=1
anss=[]
for n in range(0,9):
nums[n]+=1
if(check(nums[:])):anss.append(n+1)
nums[n]-=1
if(len(anss)==0):anss.append(0)
print(" ".join(map(str,anss)))
| p00043 |
<H1>パズル</H1>
<p>
1 〜 9 の数字を 14 個組み合わせて完成させるパズルがあります。与えられた 13 個の数字にもうひとつ数字を付け加えて完成させます。
</p>
<p>
パズルの完成条件は
</p>
<ul>
<li>同じ数字を２つ組み合わせたものが必ずひとつ必要です。</li>
<li>残りの12 個の数字は、３個の数字の組み合わせ４つです。<br>
３個の数字の組み合わせ方は、同じ数字を３つ組み合わせたものか、または３つの連続する数字を組み合わせたものです。ただし、9 1 2 のような並びは連続する数字とは認められません。</li>
<li>同じ数字は4 回まで使えます。</li>
</ul>
<p>
13 個の数字からなる文字列を読み込んで、パズルを完成することができる数字を昇順に全て出力するプログラムを作成してください。なお、1〜9 のどの数字を付け加えてもパズルを完成させることができないときは 0 を出力してください。
</p>
<p>例えば与えられた文字列が 3456666777999 の場合<br/>
<br/>
「2」があれば、 <span>234 567 666 77 999</span><br/>
「3」があれば、 <span>33 456 666 777 999</span><br/>
「5」があれば、 <span>345 567 666 77 999</span><br/>
「8」があれば、 <span>345 666 678 77 999</span><br/>
<br/>
というふうに、2 3 5 8 のいずれかの数字が付け加えられるとパズルは完成します。「6」でも整いますが、5 回目の使用になるので、この例では使えないことに注意してください。
</p>
<H2>Input</H2>
<p>
入力は複数のデータセットからなります。各データセットとして、13 個の数字が１行に与えられます。データセットの数は 50 を超えません。
</p>
<H2>Output</H2>
<p>
データセットごとに、パズルを完成させることができる数字を昇順に空白区切りで１行に出力します。
</p>
<H2>Sample Input</H2>
<pre>
3649596966777
6358665788577
9118992346175
9643871425498
7755542764533
1133557799246
</pre>
<H2>Output for the Sample Input</H2>
<pre>
2 3 5 8
3 4
1 2 3 4 5 6 7 8 9
7 8 9
1 2 3 4 6 7 8
0
</pre>
| 3649596966777
6358665788577
9118992346175
9643871425498
7755542764533
1133557799246
| 2 3 5 8
3 4
1 2 3 4 5 6 7 8 9
7 8 9
1 2 3 4 6 7 8
0
| 9,710 |
s234174829 | p00044 | u319725914 | 1535374811 | Python | Python3 | py | Accepted | 30 | 6636 | 336 | 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
| p00044 |
<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>
| 19
3517
| 17 23
3511 3527
| 9,711 |
s304426598 | p00044 | u990228206 | 1551345323 | Python | Python3 | py | Accepted | 20 | 5656 | 509 | 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
| p00044 |
<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>
| 19
3517
| 17 23
3511 3527
| 9,712 |
s280094049 | p00044 | u193025715 | 1408728959 | Python | Python3 | py | Accepted | 60 | 7268 | 700 | 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 | p00044 |
<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>
| 19
3517
| 17 23
3511 3527
| 9,713 |
s783815895 | p00044 | u579833671 | 1410916254 | Python | Python | py | Accepted | 30 | 6848 | 558 | 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 | p00044 |
<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>
| 19
3517
| 17 23
3511 3527
| 9,714 |
s419014620 | p00044 | u506132575 | 1416885294 | Python | Python | py | Accepted | 30 | 4740 | 402 | 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 | p00044 |
<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>
| 19
3517
| 17 23
3511 3527
| 9,715 |
s998202281 | p00044 | u567380442 | 1423042026 | Python | Python3 | py | Accepted | 40 | 6968 | 562 | 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)) | p00044 |
<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>
| 19
3517
| 17 23
3511 3527
| 9,716 |
s909676740 | p00044 | u879226672 | 1425440599 | Python | Python | py | Accepted | 20 | 4212 | 346 | 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 | p00044 |
<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>
| 19
3517
| 17 23
3511 3527
| 9,717 |
s546098856 | p00044 | u540744789 | 1426827509 | Python | Python | py | Accepted | 50 | 4468 | 386 | 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 | p00044 |
<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>
| 19
3517
| 17 23
3511 3527
| 9,718 |
s431858087 | p00044 | u749493116 | 1436409297 | Python | Python | py | Accepted | 40 | 9772 | 536 | #!/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] | p00044 |
<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>
| 19
3517
| 17 23
3511 3527
| 9,719 |
s388507458 | p00044 | u075836834 | 1458951863 | Python | Python3 | py | Accepted | 60 | 7792 | 469 | 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 | p00044 |
<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>
| 19
3517
| 17 23
3511 3527
| 9,720 |
s677428171 | p00044 | u148101999 | 1460255694 | Python | Python | py | Accepted | 10 | 6344 | 617 | 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() | p00044 |
<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>
| 19
3517
| 17 23
3511 3527
| 9,721 |
s184196504 | p00044 | u358919705 | 1473244249 | Python | Python3 | py | Accepted | 20 | 7732 | 788 | 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 | p00044 |
<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>
| 19
3517
| 17 23
3511 3527
| 9,722 |
s745604185 | p00044 | u661290476 | 1483101649 | Python | Python3 | py | Accepted | 50 | 7720 | 367 | 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 | p00044 |
<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>
| 19
3517
| 17 23
3511 3527
| 9,723 |
s927533694 | p00044 | u964040941 | 1490047958 | Python | Python3 | py | Accepted | 20 | 7668 | 471 | 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) | p00044 |
<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>
| 19
3517
| 17 23
3511 3527
| 9,724 |
s313918450 | p00044 | u546285759 | 1491461650 | Python | Python3 | py | Accepted | 50 | 7660 | 322 | 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) | p00044 |
<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>
| 19
3517
| 17 23
3511 3527
| 9,725 |
s438552121 | p00044 | u901080241 | 1491977183 | Python | Python3 | py | Accepted | 70 | 7852 | 644 | 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 | p00044 |
<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>
| 19
3517
| 17 23
3511 3527
| 9,726 |
s938343857 | p00044 | u462831976 | 1493083031 | Python | Python3 | py | Accepted | 20 | 7640 | 472 | # -*- 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) | p00044 |
<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>
| 19
3517
| 17 23
3511 3527
| 9,727 |
s205664533 | p00044 | u546285759 | 1501276061 | Python | Python3 | py | Accepted | 50 | 8312 | 274 | 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) | p00044 |
<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>
| 19
3517
| 17 23
3511 3527
| 9,728 |
s788795661 | p00044 | u957021183 | 1504862410 | Python | Python3 | py | Accepted | 40 | 7988 | 897 | # 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])
| p00044 |
<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>
| 19
3517
| 17 23
3511 3527
| 9,729 |
s671795969 | p00044 | u028347703 | 1514728958 | Python | Python3 | py | Accepted | 70 | 6656 | 513 | # 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 | p00044 |
<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>
| 19
3517
| 17 23
3511 3527
| 9,730 |
s282550518 | p00044 | u028347703 | 1514728999 | Python | Python3 | py | Accepted | 70 | 6660 | 477 | 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 | p00044 |
<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>
| 19
3517
| 17 23
3511 3527
| 9,731 |
s223461181 | p00044 | u775586391 | 1518453001 | Python | Python3 | py | Accepted | 70 | 7924 | 367 | 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
| p00044 |
<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>
| 19
3517
| 17 23
3511 3527
| 9,732 |
s235575413 | p00044 | u775586391 | 1518453470 | Python | Python3 | py | Accepted | 70 | 7920 | 349 | 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
| p00044 |
<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>
| 19
3517
| 17 23
3511 3527
| 9,733 |
s202166937 | p00044 | u150984829 | 1518754655 | Python | Python3 | py | Accepted | 20 | 5600 | 149 | 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)
| p00044 |
<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>
| 19
3517
| 17 23
3511 3527
| 9,734 |
s589078436 | p00044 | u150984829 | 1518755098 | Python | Python3 | py | Accepted | 20 | 5592 | 277 | 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)
| p00044 |
<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>
| 19
3517
| 17 23
3511 3527
| 9,735 |
s664704122 | p00044 | u724548524 | 1527289786 | Python | Python3 | py | Accepted | 60 | 6692 | 279 | 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
| p00044 |
<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>
| 19
3517
| 17 23
3511 3527
| 9,736 |
s835936519 | p00044 | u352394527 | 1527515272 | Python | Python3 | py | Accepted | 50 | 6168 | 536 | 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
| p00044 |
<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>
| 19
3517
| 17 23
3511 3527
| 9,737 |
s532963938 | p00044 | u352394527 | 1527515364 | Python | Python3 | py | Accepted | 50 | 6088 | 536 | 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
| p00044 |
<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>
| 19
3517
| 17 23
3511 3527
| 9,738 |
s124271494 | p00044 | u847467233 | 1529117049 | Python | Python3 | py | Accepted | 40 | 5908 | 508 | # 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)
| p00044 |
<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>
| 19
3517
| 17 23
3511 3527
| 9,739 |
s973381371 | p00044 | u197615397 | 1530541262 | Python | Python3 | py | Accepted | 40 | 7604 | 467 | 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()
| p00044 |
<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>
| 19
3517
| 17 23
3511 3527
| 9,740 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.