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 |
|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
s005390580 | p00084 | u862272701 | 1592845969 | Python | Python3 | py | Accepted | 20 | 5552 | 164 | s = str(input())
n = s.replace(',','')
o = n.replace('.','')
m = o.split()
a = []
for i in m:
l = len(i)
if l>=3 and l<=6:
a.append(i)
print(*a)
| p00084 |
<H1>検索エンジン</H1>
<p>
インターネットの検索エンジン、例えば、Google などでは、世界中のウェブページを自動で収捨して分類し、巨大なデータベースを作成します。また、ユーザが入力した検索キーワードを解析して、データベース検索のための問い合わせ文を作成します。
</p>
<p>
いずれの場合も、効率的な検索を実現するために複雑な処理を行っていますが、とりあえずの基本は全て文章からの単語の切り出しです。
</p>
<p>
ということで、文章からの単語の切り出しに挑戦してください。今回は以下の通り、単語区切りが明確な英語の文章を対象とします。
</p>
<ul>
<li> 対象となる文章 ： 改行を含まない 1024 文字以下の英語の文章 </li>
<li> 区切り文字 ： いずれも半角で空白、ピリオド、カンマのみ</li>
<li> 切り出す単語 ： 3 から 6 文字の単語（2文字以下や7文字以上の単語は無視） </li>
</ul>
<H2>入力</H2>
<p>区切り文字及び英数字で構成される英文が１行（すべて半角）に与えられます。
</p>
<H2>出力</H2>
<p>空白文字１文字（半角）で区切られた単語を１行に出力してください。
</p>
<H2>Sample Input</H2>
<pre>
Rain, rain, go to Spain.
</pre>
<H2>Output for the Sample Input</H2>
<pre>
Rain rain Spain
</pre>
<H2>Sample Input 2</H2>
<pre>
Win today's preliminary contest and be qualified to visit University of Aizu.
</pre>
<H2>Output for the Sample Input 2</H2>
<pre>
Win and visit Aizu
</pre>
| Rain, rain, go to Spain.
| Rain rain Spain
| 12,341 |
s798090502 | p00084 | u057249340 | 1592784303 | Python | Python3 | py | Accepted | 30 | 6520 | 169 | import re
a=input()
x=re.split('[, .]',a)
for i in range(len(x)):
if len(x[i]) < 3 or len(x[i]) > 6:
x[i]=0
y=list(x)
z=[n for n in y if n != 0]
print(*z)
| p00084 |
<H1>検索エンジン</H1>
<p>
インターネットの検索エンジン、例えば、Google などでは、世界中のウェブページを自動で収捨して分類し、巨大なデータベースを作成します。また、ユーザが入力した検索キーワードを解析して、データベース検索のための問い合わせ文を作成します。
</p>
<p>
いずれの場合も、効率的な検索を実現するために複雑な処理を行っていますが、とりあえずの基本は全て文章からの単語の切り出しです。
</p>
<p>
ということで、文章からの単語の切り出しに挑戦してください。今回は以下の通り、単語区切りが明確な英語の文章を対象とします。
</p>
<ul>
<li> 対象となる文章 ： 改行を含まない 1024 文字以下の英語の文章 </li>
<li> 区切り文字 ： いずれも半角で空白、ピリオド、カンマのみ</li>
<li> 切り出す単語 ： 3 から 6 文字の単語（2文字以下や7文字以上の単語は無視） </li>
</ul>
<H2>入力</H2>
<p>区切り文字及び英数字で構成される英文が１行（すべて半角）に与えられます。
</p>
<H2>出力</H2>
<p>空白文字１文字（半角）で区切られた単語を１行に出力してください。
</p>
<H2>Sample Input</H2>
<pre>
Rain, rain, go to Spain.
</pre>
<H2>Output for the Sample Input</H2>
<pre>
Rain rain Spain
</pre>
<H2>Sample Input 2</H2>
<pre>
Win today's preliminary contest and be qualified to visit University of Aizu.
</pre>
<H2>Output for the Sample Input 2</H2>
<pre>
Win and visit Aizu
</pre>
| Rain, rain, go to Spain.
| Rain rain Spain
| 12,342 |
s834234837 | p00084 | u228556128 | 1591793357 | Python | Python3 | py | Accepted | 20 | 5560 | 167 | n=input()
n=n.replace(","," ")
n=n.replace("."," ")
lst=n.split()
a=[]
for i in range(len(lst)):
if 3<=len(lst[i])<=6:
a.append(lst[i])
print(" ".join(a))
| p00084 |
<H1>検索エンジン</H1>
<p>
インターネットの検索エンジン、例えば、Google などでは、世界中のウェブページを自動で収捨して分類し、巨大なデータベースを作成します。また、ユーザが入力した検索キーワードを解析して、データベース検索のための問い合わせ文を作成します。
</p>
<p>
いずれの場合も、効率的な検索を実現するために複雑な処理を行っていますが、とりあえずの基本は全て文章からの単語の切り出しです。
</p>
<p>
ということで、文章からの単語の切り出しに挑戦してください。今回は以下の通り、単語区切りが明確な英語の文章を対象とします。
</p>
<ul>
<li> 対象となる文章 ： 改行を含まない 1024 文字以下の英語の文章 </li>
<li> 区切り文字 ： いずれも半角で空白、ピリオド、カンマのみ</li>
<li> 切り出す単語 ： 3 から 6 文字の単語（2文字以下や7文字以上の単語は無視） </li>
</ul>
<H2>入力</H2>
<p>区切り文字及び英数字で構成される英文が１行（すべて半角）に与えられます。
</p>
<H2>出力</H2>
<p>空白文字１文字（半角）で区切られた単語を１行に出力してください。
</p>
<H2>Sample Input</H2>
<pre>
Rain, rain, go to Spain.
</pre>
<H2>Output for the Sample Input</H2>
<pre>
Rain rain Spain
</pre>
<H2>Sample Input 2</H2>
<pre>
Win today's preliminary contest and be qualified to visit University of Aizu.
</pre>
<H2>Output for the Sample Input 2</H2>
<pre>
Win and visit Aizu
</pre>
| Rain, rain, go to Spain.
| Rain rain Spain
| 12,343 |
s297820291 | p00084 | u994684803 | 1591790173 | Python | Python3 | py | Accepted | 40 | 6508 | 112 | import re
s=re.split('[,. ]',input())
ans=[]
for i in s:
if 2<len(i)<7:
ans.append(i)
print(*ans)
| p00084 |
<H1>検索エンジン</H1>
<p>
インターネットの検索エンジン、例えば、Google などでは、世界中のウェブページを自動で収捨して分類し、巨大なデータベースを作成します。また、ユーザが入力した検索キーワードを解析して、データベース検索のための問い合わせ文を作成します。
</p>
<p>
いずれの場合も、効率的な検索を実現するために複雑な処理を行っていますが、とりあえずの基本は全て文章からの単語の切り出しです。
</p>
<p>
ということで、文章からの単語の切り出しに挑戦してください。今回は以下の通り、単語区切りが明確な英語の文章を対象とします。
</p>
<ul>
<li> 対象となる文章 ： 改行を含まない 1024 文字以下の英語の文章 </li>
<li> 区切り文字 ： いずれも半角で空白、ピリオド、カンマのみ</li>
<li> 切り出す単語 ： 3 から 6 文字の単語（2文字以下や7文字以上の単語は無視） </li>
</ul>
<H2>入力</H2>
<p>区切り文字及び英数字で構成される英文が１行（すべて半角）に与えられます。
</p>
<H2>出力</H2>
<p>空白文字１文字（半角）で区切られた単語を１行に出力してください。
</p>
<H2>Sample Input</H2>
<pre>
Rain, rain, go to Spain.
</pre>
<H2>Output for the Sample Input</H2>
<pre>
Rain rain Spain
</pre>
<H2>Sample Input 2</H2>
<pre>
Win today's preliminary contest and be qualified to visit University of Aizu.
</pre>
<H2>Output for the Sample Input 2</H2>
<pre>
Win and visit Aizu
</pre>
| Rain, rain, go to Spain.
| Rain rain Spain
| 12,344 |
s128379533 | p00084 | u260980560 | 1590591616 | Python | Python3 | py | Accepted | 40 | 6512 | 263 | import sys, re
readline = sys.stdin.readline
write = sys.stdout.write
def solve():
s = readline().strip()
ans = []
for w in re.split("[ .,]", s):
if 3 <= len(w) <= 6:
ans.append(w)
write(" ".join(ans))
write("\n")
solve()
| p00084 |
<H1>検索エンジン</H1>
<p>
インターネットの検索エンジン、例えば、Google などでは、世界中のウェブページを自動で収捨して分類し、巨大なデータベースを作成します。また、ユーザが入力した検索キーワードを解析して、データベース検索のための問い合わせ文を作成します。
</p>
<p>
いずれの場合も、効率的な検索を実現するために複雑な処理を行っていますが、とりあえずの基本は全て文章からの単語の切り出しです。
</p>
<p>
ということで、文章からの単語の切り出しに挑戦してください。今回は以下の通り、単語区切りが明確な英語の文章を対象とします。
</p>
<ul>
<li> 対象となる文章 ： 改行を含まない 1024 文字以下の英語の文章 </li>
<li> 区切り文字 ： いずれも半角で空白、ピリオド、カンマのみ</li>
<li> 切り出す単語 ： 3 から 6 文字の単語（2文字以下や7文字以上の単語は無視） </li>
</ul>
<H2>入力</H2>
<p>区切り文字及び英数字で構成される英文が１行（すべて半角）に与えられます。
</p>
<H2>出力</H2>
<p>空白文字１文字（半角）で区切られた単語を１行に出力してください。
</p>
<H2>Sample Input</H2>
<pre>
Rain, rain, go to Spain.
</pre>
<H2>Output for the Sample Input</H2>
<pre>
Rain rain Spain
</pre>
<H2>Sample Input 2</H2>
<pre>
Win today's preliminary contest and be qualified to visit University of Aizu.
</pre>
<H2>Output for the Sample Input 2</H2>
<pre>
Win and visit Aizu
</pre>
| Rain, rain, go to Spain.
| Rain rain Spain
| 12,345 |
s473470648 | p00084 | u747915832 | 1590249739 | Python | Python3 | py | Accepted | 20 | 5556 | 173 | text = input()
text = text.replace(',',' ')
text = text.replace('.',' ')
TEXT = []
for i in text.split():
if 3<=len(i)<=6:
TEXT.append(i)
print(' '.join(TEXT))
| p00084 |
<H1>検索エンジン</H1>
<p>
インターネットの検索エンジン、例えば、Google などでは、世界中のウェブページを自動で収捨して分類し、巨大なデータベースを作成します。また、ユーザが入力した検索キーワードを解析して、データベース検索のための問い合わせ文を作成します。
</p>
<p>
いずれの場合も、効率的な検索を実現するために複雑な処理を行っていますが、とりあえずの基本は全て文章からの単語の切り出しです。
</p>
<p>
ということで、文章からの単語の切り出しに挑戦してください。今回は以下の通り、単語区切りが明確な英語の文章を対象とします。
</p>
<ul>
<li> 対象となる文章 ： 改行を含まない 1024 文字以下の英語の文章 </li>
<li> 区切り文字 ： いずれも半角で空白、ピリオド、カンマのみ</li>
<li> 切り出す単語 ： 3 から 6 文字の単語（2文字以下や7文字以上の単語は無視） </li>
</ul>
<H2>入力</H2>
<p>区切り文字及び英数字で構成される英文が１行（すべて半角）に与えられます。
</p>
<H2>出力</H2>
<p>空白文字１文字（半角）で区切られた単語を１行に出力してください。
</p>
<H2>Sample Input</H2>
<pre>
Rain, rain, go to Spain.
</pre>
<H2>Output for the Sample Input</H2>
<pre>
Rain rain Spain
</pre>
<H2>Sample Input 2</H2>
<pre>
Win today's preliminary contest and be qualified to visit University of Aizu.
</pre>
<H2>Output for the Sample Input 2</H2>
<pre>
Win and visit Aizu
</pre>
| Rain, rain, go to Spain.
| Rain rain Spain
| 12,346 |
s835871301 | p00084 | u814278309 | 1589175022 | Python | Python3 | py | Accepted | 20 | 5556 | 173 | a = input()
a = a.replace("."," ")
a = a.replace(","," ")
x = a.split()
y = []
for i in range(len(x)):
if 3 <= len(x[i]) <= 6:
y.append(x[i])
print(" ".join(y))
| p00084 |
<H1>検索エンジン</H1>
<p>
インターネットの検索エンジン、例えば、Google などでは、世界中のウェブページを自動で収捨して分類し、巨大なデータベースを作成します。また、ユーザが入力した検索キーワードを解析して、データベース検索のための問い合わせ文を作成します。
</p>
<p>
いずれの場合も、効率的な検索を実現するために複雑な処理を行っていますが、とりあえずの基本は全て文章からの単語の切り出しです。
</p>
<p>
ということで、文章からの単語の切り出しに挑戦してください。今回は以下の通り、単語区切りが明確な英語の文章を対象とします。
</p>
<ul>
<li> 対象となる文章 ： 改行を含まない 1024 文字以下の英語の文章 </li>
<li> 区切り文字 ： いずれも半角で空白、ピリオド、カンマのみ</li>
<li> 切り出す単語 ： 3 から 6 文字の単語（2文字以下や7文字以上の単語は無視） </li>
</ul>
<H2>入力</H2>
<p>区切り文字及び英数字で構成される英文が１行（すべて半角）に与えられます。
</p>
<H2>出力</H2>
<p>空白文字１文字（半角）で区切られた単語を１行に出力してください。
</p>
<H2>Sample Input</H2>
<pre>
Rain, rain, go to Spain.
</pre>
<H2>Output for the Sample Input</H2>
<pre>
Rain rain Spain
</pre>
<H2>Sample Input 2</H2>
<pre>
Win today's preliminary contest and be qualified to visit University of Aizu.
</pre>
<H2>Output for the Sample Input 2</H2>
<pre>
Win and visit Aizu
</pre>
| Rain, rain, go to Spain.
| Rain rain Spain
| 12,347 |
s308269416 | p00084 | u014861569 | 1589010431 | Python | Python3 | py | Accepted | 20 | 5556 | 156 | s = input()
s = s.replace(",", " ")
s = s.replace(".", " ")
y=[]
for i in s.split():
if 3<=len(i) and len(i)<=6:
y.append(i)
print(' '.join(y))
| p00084 |
<H1>検索エンジン</H1>
<p>
インターネットの検索エンジン、例えば、Google などでは、世界中のウェブページを自動で収捨して分類し、巨大なデータベースを作成します。また、ユーザが入力した検索キーワードを解析して、データベース検索のための問い合わせ文を作成します。
</p>
<p>
いずれの場合も、効率的な検索を実現するために複雑な処理を行っていますが、とりあえずの基本は全て文章からの単語の切り出しです。
</p>
<p>
ということで、文章からの単語の切り出しに挑戦してください。今回は以下の通り、単語区切りが明確な英語の文章を対象とします。
</p>
<ul>
<li> 対象となる文章 ： 改行を含まない 1024 文字以下の英語の文章 </li>
<li> 区切り文字 ： いずれも半角で空白、ピリオド、カンマのみ</li>
<li> 切り出す単語 ： 3 から 6 文字の単語（2文字以下や7文字以上の単語は無視） </li>
</ul>
<H2>入力</H2>
<p>区切り文字及び英数字で構成される英文が１行（すべて半角）に与えられます。
</p>
<H2>出力</H2>
<p>空白文字１文字（半角）で区切られた単語を１行に出力してください。
</p>
<H2>Sample Input</H2>
<pre>
Rain, rain, go to Spain.
</pre>
<H2>Output for the Sample Input</H2>
<pre>
Rain rain Spain
</pre>
<H2>Sample Input 2</H2>
<pre>
Win today's preliminary contest and be qualified to visit University of Aizu.
</pre>
<H2>Output for the Sample Input 2</H2>
<pre>
Win and visit Aizu
</pre>
| Rain, rain, go to Spain.
| Rain rain Spain
| 12,348 |
s104365904 | p00084 | u642972715 | 1583302445 | Python | Python3 | py | Accepted | 30 | 5556 | 508 | try:
while True:
str = str(input())
str_replace_period = str.replace(".",",")
str_replace_space = str_replace_period.replace(" ",",")
word = str_replace_space.split(",")
i = 0
word_list = ""
while i < len(word) :
if len(word[i]) >= 3 and len(word[i]) <= 6 :
word_list = word_list + word[i] + " "
i += 1
except EOFError:
pass
if(word_list[-1:]==" "):
print(word_list[:-1])
else:
print(word_list)
| p00084 |
<H1>検索エンジン</H1>
<p>
インターネットの検索エンジン、例えば、Google などでは、世界中のウェブページを自動で収捨して分類し、巨大なデータベースを作成します。また、ユーザが入力した検索キーワードを解析して、データベース検索のための問い合わせ文を作成します。
</p>
<p>
いずれの場合も、効率的な検索を実現するために複雑な処理を行っていますが、とりあえずの基本は全て文章からの単語の切り出しです。
</p>
<p>
ということで、文章からの単語の切り出しに挑戦してください。今回は以下の通り、単語区切りが明確な英語の文章を対象とします。
</p>
<ul>
<li> 対象となる文章 ： 改行を含まない 1024 文字以下の英語の文章 </li>
<li> 区切り文字 ： いずれも半角で空白、ピリオド、カンマのみ</li>
<li> 切り出す単語 ： 3 から 6 文字の単語（2文字以下や7文字以上の単語は無視） </li>
</ul>
<H2>入力</H2>
<p>区切り文字及び英数字で構成される英文が１行（すべて半角）に与えられます。
</p>
<H2>出力</H2>
<p>空白文字１文字（半角）で区切られた単語を１行に出力してください。
</p>
<H2>Sample Input</H2>
<pre>
Rain, rain, go to Spain.
</pre>
<H2>Output for the Sample Input</H2>
<pre>
Rain rain Spain
</pre>
<H2>Sample Input 2</H2>
<pre>
Win today's preliminary contest and be qualified to visit University of Aizu.
</pre>
<H2>Output for the Sample Input 2</H2>
<pre>
Win and visit Aizu
</pre>
| Rain, rain, go to Spain.
| Rain rain Spain
| 12,349 |
s505175616 | p00084 | u371539389 | 1582611267 | Python | Python3 | py | Accepted | 20 | 5556 | 290 | while True:
try:
s=input()
s=s.replace(","," ")
s=s.replace("."," ")
s=s.split(" ")
ans=[]
for w in s:
if len(w)>=3 and len(w)<=6:
ans.append(w)
print(" ".join(ans))
except EOFError:
break
| p00084 |
<H1>検索エンジン</H1>
<p>
インターネットの検索エンジン、例えば、Google などでは、世界中のウェブページを自動で収捨して分類し、巨大なデータベースを作成します。また、ユーザが入力した検索キーワードを解析して、データベース検索のための問い合わせ文を作成します。
</p>
<p>
いずれの場合も、効率的な検索を実現するために複雑な処理を行っていますが、とりあえずの基本は全て文章からの単語の切り出しです。
</p>
<p>
ということで、文章からの単語の切り出しに挑戦してください。今回は以下の通り、単語区切りが明確な英語の文章を対象とします。
</p>
<ul>
<li> 対象となる文章 ： 改行を含まない 1024 文字以下の英語の文章 </li>
<li> 区切り文字 ： いずれも半角で空白、ピリオド、カンマのみ</li>
<li> 切り出す単語 ： 3 から 6 文字の単語（2文字以下や7文字以上の単語は無視） </li>
</ul>
<H2>入力</H2>
<p>区切り文字及び英数字で構成される英文が１行（すべて半角）に与えられます。
</p>
<H2>出力</H2>
<p>空白文字１文字（半角）で区切られた単語を１行に出力してください。
</p>
<H2>Sample Input</H2>
<pre>
Rain, rain, go to Spain.
</pre>
<H2>Output for the Sample Input</H2>
<pre>
Rain rain Spain
</pre>
<H2>Sample Input 2</H2>
<pre>
Win today's preliminary contest and be qualified to visit University of Aizu.
</pre>
<H2>Output for the Sample Input 2</H2>
<pre>
Win and visit Aizu
</pre>
| Rain, rain, go to Spain.
| Rain rain Spain
| 12,350 |
s557955173 | p00084 | u630911389 | 1581894002 | Python | Python3 | py | Accepted | 20 | 5556 | 99 | s = input().replace(",", " ").replace(".", " ")
print(*[s for s in s.split() if 3 <= len(s) <= 6])
| p00084 |
<H1>検索エンジン</H1>
<p>
インターネットの検索エンジン、例えば、Google などでは、世界中のウェブページを自動で収捨して分類し、巨大なデータベースを作成します。また、ユーザが入力した検索キーワードを解析して、データベース検索のための問い合わせ文を作成します。
</p>
<p>
いずれの場合も、効率的な検索を実現するために複雑な処理を行っていますが、とりあえずの基本は全て文章からの単語の切り出しです。
</p>
<p>
ということで、文章からの単語の切り出しに挑戦してください。今回は以下の通り、単語区切りが明確な英語の文章を対象とします。
</p>
<ul>
<li> 対象となる文章 ： 改行を含まない 1024 文字以下の英語の文章 </li>
<li> 区切り文字 ： いずれも半角で空白、ピリオド、カンマのみ</li>
<li> 切り出す単語 ： 3 から 6 文字の単語（2文字以下や7文字以上の単語は無視） </li>
</ul>
<H2>入力</H2>
<p>区切り文字及び英数字で構成される英文が１行（すべて半角）に与えられます。
</p>
<H2>出力</H2>
<p>空白文字１文字（半角）で区切られた単語を１行に出力してください。
</p>
<H2>Sample Input</H2>
<pre>
Rain, rain, go to Spain.
</pre>
<H2>Output for the Sample Input</H2>
<pre>
Rain rain Spain
</pre>
<H2>Sample Input 2</H2>
<pre>
Win today's preliminary contest and be qualified to visit University of Aizu.
</pre>
<H2>Output for the Sample Input 2</H2>
<pre>
Win and visit Aizu
</pre>
| Rain, rain, go to Spain.
| Rain rain Spain
| 12,351 |
s420986888 | p00084 | u697145890 | 1575724672 | Python | Python3 | py | Accepted | 40 | 6372 | 849 | import heapq
from collections import deque
from enum import Enum
import sys
import math
from _heapq import heappush, heappop
import copy
BIG_NUM = 2000000000
HUGE_NUM = 99999999999999999
MOD = 1000000007
EPS = 0.000000001
sys.setrecursionlimit(100000)
input_str = input()
length = 0
work = deque()
is_First = True
for i in range(len(input_str)):
ch = input_str[i]
if ch in [' ',',','.'] or i == len(input_str)-1: #区切り文字または最後の文字
if length >= 3 and length <= 6:
if is_First == False:
print(" ",end="")
while len(work) > 0:
print("%s"%(work.popleft()),end="")
is_First = False
else:
while len(work) > 0:
work.popleft()
length = 0
else:
work.append(ch)
length += 1
print()
| p00084 |
<H1>検索エンジン</H1>
<p>
インターネットの検索エンジン、例えば、Google などでは、世界中のウェブページを自動で収捨して分類し、巨大なデータベースを作成します。また、ユーザが入力した検索キーワードを解析して、データベース検索のための問い合わせ文を作成します。
</p>
<p>
いずれの場合も、効率的な検索を実現するために複雑な処理を行っていますが、とりあえずの基本は全て文章からの単語の切り出しです。
</p>
<p>
ということで、文章からの単語の切り出しに挑戦してください。今回は以下の通り、単語区切りが明確な英語の文章を対象とします。
</p>
<ul>
<li> 対象となる文章 ： 改行を含まない 1024 文字以下の英語の文章 </li>
<li> 区切り文字 ： いずれも半角で空白、ピリオド、カンマのみ</li>
<li> 切り出す単語 ： 3 から 6 文字の単語（2文字以下や7文字以上の単語は無視） </li>
</ul>
<H2>入力</H2>
<p>区切り文字及び英数字で構成される英文が１行（すべて半角）に与えられます。
</p>
<H2>出力</H2>
<p>空白文字１文字（半角）で区切られた単語を１行に出力してください。
</p>
<H2>Sample Input</H2>
<pre>
Rain, rain, go to Spain.
</pre>
<H2>Output for the Sample Input</H2>
<pre>
Rain rain Spain
</pre>
<H2>Sample Input 2</H2>
<pre>
Win today's preliminary contest and be qualified to visit University of Aizu.
</pre>
<H2>Output for the Sample Input 2</H2>
<pre>
Win and visit Aizu
</pre>
| Rain, rain, go to Spain.
| Rain rain Spain
| 12,352 |
s862213164 | p00084 | u824708460 | 1567728727 | Python | Python3 | py | Accepted | 20 | 5556 | 149 | ans = []
s = input().replace(',', ' ').replace('.', ' ').split()
for m in s:
if 3 <= len(m) and len(m) <= 6:
ans.append(m)
print(*ans)
| p00084 |
<H1>検索エンジン</H1>
<p>
インターネットの検索エンジン、例えば、Google などでは、世界中のウェブページを自動で収捨して分類し、巨大なデータベースを作成します。また、ユーザが入力した検索キーワードを解析して、データベース検索のための問い合わせ文を作成します。
</p>
<p>
いずれの場合も、効率的な検索を実現するために複雑な処理を行っていますが、とりあえずの基本は全て文章からの単語の切り出しです。
</p>
<p>
ということで、文章からの単語の切り出しに挑戦してください。今回は以下の通り、単語区切りが明確な英語の文章を対象とします。
</p>
<ul>
<li> 対象となる文章 ： 改行を含まない 1024 文字以下の英語の文章 </li>
<li> 区切り文字 ： いずれも半角で空白、ピリオド、カンマのみ</li>
<li> 切り出す単語 ： 3 から 6 文字の単語（2文字以下や7文字以上の単語は無視） </li>
</ul>
<H2>入力</H2>
<p>区切り文字及び英数字で構成される英文が１行（すべて半角）に与えられます。
</p>
<H2>出力</H2>
<p>空白文字１文字（半角）で区切られた単語を１行に出力してください。
</p>
<H2>Sample Input</H2>
<pre>
Rain, rain, go to Spain.
</pre>
<H2>Output for the Sample Input</H2>
<pre>
Rain rain Spain
</pre>
<H2>Sample Input 2</H2>
<pre>
Win today's preliminary contest and be qualified to visit University of Aizu.
</pre>
<H2>Output for the Sample Input 2</H2>
<pre>
Win and visit Aizu
</pre>
| Rain, rain, go to Spain.
| Rain rain Spain
| 12,353 |
s077559536 | p00084 | u548252256 | 1562326696 | Python | Python3 | py | Accepted | 30 | 5564 | 163 |
if __name__ == '__main__':
line = input().replace(".","").replace(",","").split()
ans = [i for i in line if 3 <= len(i) <= 6]
print(*ans)
| p00084 |
<H1>検索エンジン</H1>
<p>
インターネットの検索エンジン、例えば、Google などでは、世界中のウェブページを自動で収捨して分類し、巨大なデータベースを作成します。また、ユーザが入力した検索キーワードを解析して、データベース検索のための問い合わせ文を作成します。
</p>
<p>
いずれの場合も、効率的な検索を実現するために複雑な処理を行っていますが、とりあえずの基本は全て文章からの単語の切り出しです。
</p>
<p>
ということで、文章からの単語の切り出しに挑戦してください。今回は以下の通り、単語区切りが明確な英語の文章を対象とします。
</p>
<ul>
<li> 対象となる文章 ： 改行を含まない 1024 文字以下の英語の文章 </li>
<li> 区切り文字 ： いずれも半角で空白、ピリオド、カンマのみ</li>
<li> 切り出す単語 ： 3 から 6 文字の単語（2文字以下や7文字以上の単語は無視） </li>
</ul>
<H2>入力</H2>
<p>区切り文字及び英数字で構成される英文が１行（すべて半角）に与えられます。
</p>
<H2>出力</H2>
<p>空白文字１文字（半角）で区切られた単語を１行に出力してください。
</p>
<H2>Sample Input</H2>
<pre>
Rain, rain, go to Spain.
</pre>
<H2>Output for the Sample Input</H2>
<pre>
Rain rain Spain
</pre>
<H2>Sample Input 2</H2>
<pre>
Win today's preliminary contest and be qualified to visit University of Aizu.
</pre>
<H2>Output for the Sample Input 2</H2>
<pre>
Win and visit Aizu
</pre>
| Rain, rain, go to Spain.
| Rain rain Spain
| 12,354 |
s936502594 | p00084 | u647694976 | 1560238219 | Python | Python3 | py | Accepted | 40 | 6516 | 205 | import re
while 1:
try:
N = re.split("[., ]", input())
ans = []
for i in N:
if 3 <= len(i) <= 6:
ans.append(i)
print(*ans)
except:break
| p00084 |
<H1>検索エンジン</H1>
<p>
インターネットの検索エンジン、例えば、Google などでは、世界中のウェブページを自動で収捨して分類し、巨大なデータベースを作成します。また、ユーザが入力した検索キーワードを解析して、データベース検索のための問い合わせ文を作成します。
</p>
<p>
いずれの場合も、効率的な検索を実現するために複雑な処理を行っていますが、とりあえずの基本は全て文章からの単語の切り出しです。
</p>
<p>
ということで、文章からの単語の切り出しに挑戦してください。今回は以下の通り、単語区切りが明確な英語の文章を対象とします。
</p>
<ul>
<li> 対象となる文章 ： 改行を含まない 1024 文字以下の英語の文章 </li>
<li> 区切り文字 ： いずれも半角で空白、ピリオド、カンマのみ</li>
<li> 切り出す単語 ： 3 から 6 文字の単語（2文字以下や7文字以上の単語は無視） </li>
</ul>
<H2>入力</H2>
<p>区切り文字及び英数字で構成される英文が１行（すべて半角）に与えられます。
</p>
<H2>出力</H2>
<p>空白文字１文字（半角）で区切られた単語を１行に出力してください。
</p>
<H2>Sample Input</H2>
<pre>
Rain, rain, go to Spain.
</pre>
<H2>Output for the Sample Input</H2>
<pre>
Rain rain Spain
</pre>
<H2>Sample Input 2</H2>
<pre>
Win today's preliminary contest and be qualified to visit University of Aizu.
</pre>
<H2>Output for the Sample Input 2</H2>
<pre>
Win and visit Aizu
</pre>
| Rain, rain, go to Spain.
| Rain rain Spain
| 12,355 |
s072345218 | p00084 | u108130680 | 1560143381 | Python | Python3 | py | Accepted | 20 | 5564 | 100 | print(' '.join([x for x in input().replace('.',' ').replace(',',' ').split() if 3 <= len(x) <= 6]))
| p00084 |
<H1>検索エンジン</H1>
<p>
インターネットの検索エンジン、例えば、Google などでは、世界中のウェブページを自動で収捨して分類し、巨大なデータベースを作成します。また、ユーザが入力した検索キーワードを解析して、データベース検索のための問い合わせ文を作成します。
</p>
<p>
いずれの場合も、効率的な検索を実現するために複雑な処理を行っていますが、とりあえずの基本は全て文章からの単語の切り出しです。
</p>
<p>
ということで、文章からの単語の切り出しに挑戦してください。今回は以下の通り、単語区切りが明確な英語の文章を対象とします。
</p>
<ul>
<li> 対象となる文章 ： 改行を含まない 1024 文字以下の英語の文章 </li>
<li> 区切り文字 ： いずれも半角で空白、ピリオド、カンマのみ</li>
<li> 切り出す単語 ： 3 から 6 文字の単語（2文字以下や7文字以上の単語は無視） </li>
</ul>
<H2>入力</H2>
<p>区切り文字及び英数字で構成される英文が１行（すべて半角）に与えられます。
</p>
<H2>出力</H2>
<p>空白文字１文字（半角）で区切られた単語を１行に出力してください。
</p>
<H2>Sample Input</H2>
<pre>
Rain, rain, go to Spain.
</pre>
<H2>Output for the Sample Input</H2>
<pre>
Rain rain Spain
</pre>
<H2>Sample Input 2</H2>
<pre>
Win today's preliminary contest and be qualified to visit University of Aizu.
</pre>
<H2>Output for the Sample Input 2</H2>
<pre>
Win and visit Aizu
</pre>
| Rain, rain, go to Spain.
| Rain rain Spain
| 12,356 |
s685834279 | p00084 | u990228206 | 1554283023 | Python | Python3 | py | Accepted | 40 | 6508 | 119 | import re
s=re.split("[ .,]",input())
ans=[]
for i in s:
if 2<len(i)<7:ans.append(i)
print(' '.join(map(str,ans)))
| p00084 |
<H1>検索エンジン</H1>
<p>
インターネットの検索エンジン、例えば、Google などでは、世界中のウェブページを自動で収捨して分類し、巨大なデータベースを作成します。また、ユーザが入力した検索キーワードを解析して、データベース検索のための問い合わせ文を作成します。
</p>
<p>
いずれの場合も、効率的な検索を実現するために複雑な処理を行っていますが、とりあえずの基本は全て文章からの単語の切り出しです。
</p>
<p>
ということで、文章からの単語の切り出しに挑戦してください。今回は以下の通り、単語区切りが明確な英語の文章を対象とします。
</p>
<ul>
<li> 対象となる文章 ： 改行を含まない 1024 文字以下の英語の文章 </li>
<li> 区切り文字 ： いずれも半角で空白、ピリオド、カンマのみ</li>
<li> 切り出す単語 ： 3 から 6 文字の単語（2文字以下や7文字以上の単語は無視） </li>
</ul>
<H2>入力</H2>
<p>区切り文字及び英数字で構成される英文が１行（すべて半角）に与えられます。
</p>
<H2>出力</H2>
<p>空白文字１文字（半角）で区切られた単語を１行に出力してください。
</p>
<H2>Sample Input</H2>
<pre>
Rain, rain, go to Spain.
</pre>
<H2>Output for the Sample Input</H2>
<pre>
Rain rain Spain
</pre>
<H2>Sample Input 2</H2>
<pre>
Win today's preliminary contest and be qualified to visit University of Aizu.
</pre>
<H2>Output for the Sample Input 2</H2>
<pre>
Win and visit Aizu
</pre>
| Rain, rain, go to Spain.
| Rain rain Spain
| 12,357 |
s117880698 | p00084 | u717526540 | 1542860409 | Python | Python3 | py | Accepted | 20 | 5556 | 344 | wordlist = list(map(str, input().split()))
newwordlist = []
for i, word in enumerate(wordlist):
newword = word
if word[-1] == ",":
newword = word.replace(',', '')
elif word[-1] == ".":
newword = word.replace('.', '')
if 3 <= len(newword) <= 6:
newwordlist.append(newword)
print(' '.join(newwordlist))
| p00084 |
<H1>検索エンジン</H1>
<p>
インターネットの検索エンジン、例えば、Google などでは、世界中のウェブページを自動で収捨して分類し、巨大なデータベースを作成します。また、ユーザが入力した検索キーワードを解析して、データベース検索のための問い合わせ文を作成します。
</p>
<p>
いずれの場合も、効率的な検索を実現するために複雑な処理を行っていますが、とりあえずの基本は全て文章からの単語の切り出しです。
</p>
<p>
ということで、文章からの単語の切り出しに挑戦してください。今回は以下の通り、単語区切りが明確な英語の文章を対象とします。
</p>
<ul>
<li> 対象となる文章 ： 改行を含まない 1024 文字以下の英語の文章 </li>
<li> 区切り文字 ： いずれも半角で空白、ピリオド、カンマのみ</li>
<li> 切り出す単語 ： 3 から 6 文字の単語（2文字以下や7文字以上の単語は無視） </li>
</ul>
<H2>入力</H2>
<p>区切り文字及び英数字で構成される英文が１行（すべて半角）に与えられます。
</p>
<H2>出力</H2>
<p>空白文字１文字（半角）で区切られた単語を１行に出力してください。
</p>
<H2>Sample Input</H2>
<pre>
Rain, rain, go to Spain.
</pre>
<H2>Output for the Sample Input</H2>
<pre>
Rain rain Spain
</pre>
<H2>Sample Input 2</H2>
<pre>
Win today's preliminary contest and be qualified to visit University of Aizu.
</pre>
<H2>Output for the Sample Input 2</H2>
<pre>
Win and visit Aizu
</pre>
| Rain, rain, go to Spain.
| Rain rain Spain
| 12,358 |
s492455388 | p00084 | u197615397 | 1532237735 | Python | Python3 | py | Accepted | 40 | 6512 | 94 | import re
print(" ".join(word for word in re.split(r"[,.\s]", input()) if 2 < len(word) < 7))
| p00084 |
<H1>検索エンジン</H1>
<p>
インターネットの検索エンジン、例えば、Google などでは、世界中のウェブページを自動で収捨して分類し、巨大なデータベースを作成します。また、ユーザが入力した検索キーワードを解析して、データベース検索のための問い合わせ文を作成します。
</p>
<p>
いずれの場合も、効率的な検索を実現するために複雑な処理を行っていますが、とりあえずの基本は全て文章からの単語の切り出しです。
</p>
<p>
ということで、文章からの単語の切り出しに挑戦してください。今回は以下の通り、単語区切りが明確な英語の文章を対象とします。
</p>
<ul>
<li> 対象となる文章 ： 改行を含まない 1024 文字以下の英語の文章 </li>
<li> 区切り文字 ： いずれも半角で空白、ピリオド、カンマのみ</li>
<li> 切り出す単語 ： 3 から 6 文字の単語（2文字以下や7文字以上の単語は無視） </li>
</ul>
<H2>入力</H2>
<p>区切り文字及び英数字で構成される英文が１行（すべて半角）に与えられます。
</p>
<H2>出力</H2>
<p>空白文字１文字（半角）で区切られた単語を１行に出力してください。
</p>
<H2>Sample Input</H2>
<pre>
Rain, rain, go to Spain.
</pre>
<H2>Output for the Sample Input</H2>
<pre>
Rain rain Spain
</pre>
<H2>Sample Input 2</H2>
<pre>
Win today's preliminary contest and be qualified to visit University of Aizu.
</pre>
<H2>Output for the Sample Input 2</H2>
<pre>
Win and visit Aizu
</pre>
| Rain, rain, go to Spain.
| Rain rain Spain
| 12,359 |
s458650528 | p00085 | u563075864 | 1545302772 | Python | Python3 | py | Accepted | 60 | 6336 | 436 | from copy import copy
while(1):
n,m_ = [int(i) for i in input().split()]
if n == 0 and m_ == 0:
break
m = m_ -1
potato = [i+1 for i in range(n)]
while(1):
l = len(potato)
if l == 1:
print(potato[0])
break
pivot = (m+1)%l
if pivot != 0:
potato = copy(potato[pivot:] + potato[:pivot-1])
else:
potato = copy(potato[:-1])
| p00085 |
<H1>ヨセフのおイモ</H1>
<center>
<img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_13_1">
</center>
<br/>
<p>昔、ヨセフのおイモというゲームがありました。<var>n</var> 人が参加しているとしましょう。参加者は中心を向いて円陣を組み、1 から順番に番号が振られます。アツアツのおイモがひとつ、参加者 <var>n</var> (左の図内側の大きい数字の 30 )に渡されます。おイモを渡された参加者は右隣の参加者にそのおイモを渡します。 <var>m</var> 回目に渡された人は右隣の人に渡して円陣から抜けます(左の図では <var>m</var> = 9 の場合を表しています) 。 回渡す毎に一人ずつぬけ、最後に残った人が勝者となり、おイモをいただきます。
</p>
<p>
<var>n</var> ,<var>m</var> が決まってから、実際におイモを渡し始める前にどこにいたら勝てるかわかるといいですよね。上の図は 30 人の参加者で 9 人ごとに抜けるというルールでこのゲームをした場合を書き表しています。内側の大きい数字が参加者に振られた番号、外側の小さい数字が抜ける順番です。それによると、9,18,27,6,16,26 という順番で円陣から抜け出し、最後には 21 が残ることになります。すなわち 21 が勝者となります(小さい数字が 30 になっています)。
</p>
<p>
ゲーム参加者数 <var>n</var> と円陣から抜け出す参加者の間隔 <var>m</var> を入力し、勝者の番号を出力するプログラムを作成してください。ただし、<var>m</var>, <var>n</var> < 1000 とします。
</p>
<H2>入力</H2>
<p>複数のデータセットが与えられます。各データセットは以下の形式で与えられます。</p>
<pre>
<var>n</var> <var>m</var>
</pre>
<p>
ゲーム参加者数 <var>n</var> （整数）と円陣から抜け出す参加者の間隔 <var>m</var> （整数）が空白区切りで１行に与えられます。
</p>
<p>入力は２つの 0 で終わります。データセットの数は 50 を超えません。</p>
<H2>出力</H2>
<p>各データセットに対して、勝者となりおイモをいただく人の番号（整数）を１行に出力してください。</P>
<H2>Sample Input</H2>
<pre>
41 3
30 9
0 0
</pre>
<H2>Output for the Sample Input</H2>
<pre>
31
21
</pre>
| 41 3
30 9
0 0
| 31
21
| 12,360 |
s562306821 | p00085 | u506132575 | 1417745830 | Python | Python | py | Accepted | 20 | 4728 | 330 | def solve(li,nu,mu,cnt):
if len(li) == 1:
return li[0]
next_num = (nu+mu)%(len(li))-1
pop_num = (nu+mu)%(len(li))
li.pop(pop_num)
return solve(li,next_num,mu,cnt+1)
while True:
n,m = map(int,raw_input().split())
if n == m == 0:
break
lis = range(1,n+1)
print solve(lis,n-1,m,0) | p00085 |
<H1>ヨセフのおイモ</H1>
<center>
<img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_13_1">
</center>
<br/>
<p>昔、ヨセフのおイモというゲームがありました。<var>n</var> 人が参加しているとしましょう。参加者は中心を向いて円陣を組み、1 から順番に番号が振られます。アツアツのおイモがひとつ、参加者 <var>n</var> (左の図内側の大きい数字の 30 )に渡されます。おイモを渡された参加者は右隣の参加者にそのおイモを渡します。 <var>m</var> 回目に渡された人は右隣の人に渡して円陣から抜けます(左の図では <var>m</var> = 9 の場合を表しています) 。 回渡す毎に一人ずつぬけ、最後に残った人が勝者となり、おイモをいただきます。
</p>
<p>
<var>n</var> ,<var>m</var> が決まってから、実際におイモを渡し始める前にどこにいたら勝てるかわかるといいですよね。上の図は 30 人の参加者で 9 人ごとに抜けるというルールでこのゲームをした場合を書き表しています。内側の大きい数字が参加者に振られた番号、外側の小さい数字が抜ける順番です。それによると、9,18,27,6,16,26 という順番で円陣から抜け出し、最後には 21 が残ることになります。すなわち 21 が勝者となります(小さい数字が 30 になっています)。
</p>
<p>
ゲーム参加者数 <var>n</var> と円陣から抜け出す参加者の間隔 <var>m</var> を入力し、勝者の番号を出力するプログラムを作成してください。ただし、<var>m</var>, <var>n</var> < 1000 とします。
</p>
<H2>入力</H2>
<p>複数のデータセットが与えられます。各データセットは以下の形式で与えられます。</p>
<pre>
<var>n</var> <var>m</var>
</pre>
<p>
ゲーム参加者数 <var>n</var> （整数）と円陣から抜け出す参加者の間隔 <var>m</var> （整数）が空白区切りで１行に与えられます。
</p>
<p>入力は２つの 0 で終わります。データセットの数は 50 を超えません。</p>
<H2>出力</H2>
<p>各データセットに対して、勝者となりおイモをいただく人の番号（整数）を１行に出力してください。</P>
<H2>Sample Input</H2>
<pre>
41 3
30 9
0 0
</pre>
<H2>Output for the Sample Input</H2>
<pre>
31
21
</pre>
| 41 3
30 9
0 0
| 31
21
| 12,361 |
s474124068 | p00085 | u567380442 | 1423286710 | Python | Python3 | py | Accepted | 40 | 6720 | 310 | import sys
f = sys.stdin
while True:
n, m = map(int, f.readline().split())
if n == m == 0:
break
circle = [i + 1 for i in range(n)]
cnt = 0
while len(circle) != 1:
cnt += m - 1
cnt %= len(circle)
circle = circle[:cnt] + circle[cnt + 1:]
print(circle[0]) | p00085 |
<H1>ヨセフのおイモ</H1>
<center>
<img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_13_1">
</center>
<br/>
<p>昔、ヨセフのおイモというゲームがありました。<var>n</var> 人が参加しているとしましょう。参加者は中心を向いて円陣を組み、1 から順番に番号が振られます。アツアツのおイモがひとつ、参加者 <var>n</var> (左の図内側の大きい数字の 30 )に渡されます。おイモを渡された参加者は右隣の参加者にそのおイモを渡します。 <var>m</var> 回目に渡された人は右隣の人に渡して円陣から抜けます(左の図では <var>m</var> = 9 の場合を表しています) 。 回渡す毎に一人ずつぬけ、最後に残った人が勝者となり、おイモをいただきます。
</p>
<p>
<var>n</var> ,<var>m</var> が決まってから、実際におイモを渡し始める前にどこにいたら勝てるかわかるといいですよね。上の図は 30 人の参加者で 9 人ごとに抜けるというルールでこのゲームをした場合を書き表しています。内側の大きい数字が参加者に振られた番号、外側の小さい数字が抜ける順番です。それによると、9,18,27,6,16,26 という順番で円陣から抜け出し、最後には 21 が残ることになります。すなわち 21 が勝者となります(小さい数字が 30 になっています)。
</p>
<p>
ゲーム参加者数 <var>n</var> と円陣から抜け出す参加者の間隔 <var>m</var> を入力し、勝者の番号を出力するプログラムを作成してください。ただし、<var>m</var>, <var>n</var> < 1000 とします。
</p>
<H2>入力</H2>
<p>複数のデータセットが与えられます。各データセットは以下の形式で与えられます。</p>
<pre>
<var>n</var> <var>m</var>
</pre>
<p>
ゲーム参加者数 <var>n</var> （整数）と円陣から抜け出す参加者の間隔 <var>m</var> （整数）が空白区切りで１行に与えられます。
</p>
<p>入力は２つの 0 で終わります。データセットの数は 50 を超えません。</p>
<H2>出力</H2>
<p>各データセットに対して、勝者となりおイモをいただく人の番号（整数）を１行に出力してください。</P>
<H2>Sample Input</H2>
<pre>
41 3
30 9
0 0
</pre>
<H2>Output for the Sample Input</H2>
<pre>
31
21
</pre>
| 41 3
30 9
0 0
| 31
21
| 12,362 |
s993146505 | p00085 | u879226672 | 1428077647 | Python | Python | py | Accepted | 20 | 4628 | 303 | from collections import deque
while True:
try:
n,m = map(int,raw_input().split())
if (n,m) == (0,0) :
break
except EOFError:
break
d = deque([i for i in range(1,1+n)])
while len(d)> 1:
d.rotate(-m+1)
d.popleft()
print d[0] | p00085 |
<H1>ヨセフのおイモ</H1>
<center>
<img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_13_1">
</center>
<br/>
<p>昔、ヨセフのおイモというゲームがありました。<var>n</var> 人が参加しているとしましょう。参加者は中心を向いて円陣を組み、1 から順番に番号が振られます。アツアツのおイモがひとつ、参加者 <var>n</var> (左の図内側の大きい数字の 30 )に渡されます。おイモを渡された参加者は右隣の参加者にそのおイモを渡します。 <var>m</var> 回目に渡された人は右隣の人に渡して円陣から抜けます(左の図では <var>m</var> = 9 の場合を表しています) 。 回渡す毎に一人ずつぬけ、最後に残った人が勝者となり、おイモをいただきます。
</p>
<p>
<var>n</var> ,<var>m</var> が決まってから、実際におイモを渡し始める前にどこにいたら勝てるかわかるといいですよね。上の図は 30 人の参加者で 9 人ごとに抜けるというルールでこのゲームをした場合を書き表しています。内側の大きい数字が参加者に振られた番号、外側の小さい数字が抜ける順番です。それによると、9,18,27,6,16,26 という順番で円陣から抜け出し、最後には 21 が残ることになります。すなわち 21 が勝者となります(小さい数字が 30 になっています)。
</p>
<p>
ゲーム参加者数 <var>n</var> と円陣から抜け出す参加者の間隔 <var>m</var> を入力し、勝者の番号を出力するプログラムを作成してください。ただし、<var>m</var>, <var>n</var> < 1000 とします。
</p>
<H2>入力</H2>
<p>複数のデータセットが与えられます。各データセットは以下の形式で与えられます。</p>
<pre>
<var>n</var> <var>m</var>
</pre>
<p>
ゲーム参加者数 <var>n</var> （整数）と円陣から抜け出す参加者の間隔 <var>m</var> （整数）が空白区切りで１行に与えられます。
</p>
<p>入力は２つの 0 で終わります。データセットの数は 50 を超えません。</p>
<H2>出力</H2>
<p>各データセットに対して、勝者となりおイモをいただく人の番号（整数）を１行に出力してください。</P>
<H2>Sample Input</H2>
<pre>
41 3
30 9
0 0
</pre>
<H2>Output for the Sample Input</H2>
<pre>
31
21
</pre>
| 41 3
30 9
0 0
| 31
21
| 12,363 |
s088340683 | p00085 | u775586391 | 1449734178 | Python | Python3 | py | Accepted | 30 | 7560 | 204 | while True:
n,m = input().split()
n = int(n)
m = int(m)
if n==m==0:
break
l = [i for i in range(n)]
c = -1
while len(l) >= 2:
c = (c+m)%len(l)
l.pop(c)
c -= 1
print(l[0]+1) | p00085 |
<H1>ヨセフのおイモ</H1>
<center>
<img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_13_1">
</center>
<br/>
<p>昔、ヨセフのおイモというゲームがありました。<var>n</var> 人が参加しているとしましょう。参加者は中心を向いて円陣を組み、1 から順番に番号が振られます。アツアツのおイモがひとつ、参加者 <var>n</var> (左の図内側の大きい数字の 30 )に渡されます。おイモを渡された参加者は右隣の参加者にそのおイモを渡します。 <var>m</var> 回目に渡された人は右隣の人に渡して円陣から抜けます(左の図では <var>m</var> = 9 の場合を表しています) 。 回渡す毎に一人ずつぬけ、最後に残った人が勝者となり、おイモをいただきます。
</p>
<p>
<var>n</var> ,<var>m</var> が決まってから、実際におイモを渡し始める前にどこにいたら勝てるかわかるといいですよね。上の図は 30 人の参加者で 9 人ごとに抜けるというルールでこのゲームをした場合を書き表しています。内側の大きい数字が参加者に振られた番号、外側の小さい数字が抜ける順番です。それによると、9,18,27,6,16,26 という順番で円陣から抜け出し、最後には 21 が残ることになります。すなわち 21 が勝者となります(小さい数字が 30 になっています)。
</p>
<p>
ゲーム参加者数 <var>n</var> と円陣から抜け出す参加者の間隔 <var>m</var> を入力し、勝者の番号を出力するプログラムを作成してください。ただし、<var>m</var>, <var>n</var> < 1000 とします。
</p>
<H2>入力</H2>
<p>複数のデータセットが与えられます。各データセットは以下の形式で与えられます。</p>
<pre>
<var>n</var> <var>m</var>
</pre>
<p>
ゲーム参加者数 <var>n</var> （整数）と円陣から抜け出す参加者の間隔 <var>m</var> （整数）が空白区切りで１行に与えられます。
</p>
<p>入力は２つの 0 で終わります。データセットの数は 50 を超えません。</p>
<H2>出力</H2>
<p>各データセットに対して、勝者となりおイモをいただく人の番号（整数）を１行に出力してください。</P>
<H2>Sample Input</H2>
<pre>
41 3
30 9
0 0
</pre>
<H2>Output for the Sample Input</H2>
<pre>
31
21
</pre>
| 41 3
30 9
0 0
| 31
21
| 12,364 |
s631175351 | p00085 | u075836834 | 1459147835 | Python | Python3 | py | Accepted | 20 | 7744 | 245 | def solve(n,m):
A=[i for i in range(1,n+1)]
i=n-1
while True:
if len(A)==1:
break
i=(i+m)%len(A)
A.pop(i)
i=i-1 if i>0 else len(A)-1
return A[0]
while True:
n,m=map(int,input().split())
if n==m==0:
break
print(solve(n,m)) | p00085 |
<H1>ヨセフのおイモ</H1>
<center>
<img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_13_1">
</center>
<br/>
<p>昔、ヨセフのおイモというゲームがありました。<var>n</var> 人が参加しているとしましょう。参加者は中心を向いて円陣を組み、1 から順番に番号が振られます。アツアツのおイモがひとつ、参加者 <var>n</var> (左の図内側の大きい数字の 30 )に渡されます。おイモを渡された参加者は右隣の参加者にそのおイモを渡します。 <var>m</var> 回目に渡された人は右隣の人に渡して円陣から抜けます(左の図では <var>m</var> = 9 の場合を表しています) 。 回渡す毎に一人ずつぬけ、最後に残った人が勝者となり、おイモをいただきます。
</p>
<p>
<var>n</var> ,<var>m</var> が決まってから、実際におイモを渡し始める前にどこにいたら勝てるかわかるといいですよね。上の図は 30 人の参加者で 9 人ごとに抜けるというルールでこのゲームをした場合を書き表しています。内側の大きい数字が参加者に振られた番号、外側の小さい数字が抜ける順番です。それによると、9,18,27,6,16,26 という順番で円陣から抜け出し、最後には 21 が残ることになります。すなわち 21 が勝者となります(小さい数字が 30 になっています)。
</p>
<p>
ゲーム参加者数 <var>n</var> と円陣から抜け出す参加者の間隔 <var>m</var> を入力し、勝者の番号を出力するプログラムを作成してください。ただし、<var>m</var>, <var>n</var> < 1000 とします。
</p>
<H2>入力</H2>
<p>複数のデータセットが与えられます。各データセットは以下の形式で与えられます。</p>
<pre>
<var>n</var> <var>m</var>
</pre>
<p>
ゲーム参加者数 <var>n</var> （整数）と円陣から抜け出す参加者の間隔 <var>m</var> （整数）が空白区切りで１行に与えられます。
</p>
<p>入力は２つの 0 で終わります。データセットの数は 50 を超えません。</p>
<H2>出力</H2>
<p>各データセットに対して、勝者となりおイモをいただく人の番号（整数）を１行に出力してください。</P>
<H2>Sample Input</H2>
<pre>
41 3
30 9
0 0
</pre>
<H2>Output for the Sample Input</H2>
<pre>
31
21
</pre>
| 41 3
30 9
0 0
| 31
21
| 12,365 |
s500360670 | p00085 | u078042885 | 1482890577 | Python | Python3 | py | Accepted | 20 | 7536 | 216 | # -*- coding: utf-8 -*-
import sys
'import math'
while 1:
n,m=input().split()
n=int(n)
m=int(m)
if n==m==0:sys.exit()
a=m-1
while a<(m-1)*n:
a=int(m*a/(m-1)+1)
a=n*m-a
print(a) | p00085 |
<H1>ヨセフのおイモ</H1>
<center>
<img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_13_1">
</center>
<br/>
<p>昔、ヨセフのおイモというゲームがありました。<var>n</var> 人が参加しているとしましょう。参加者は中心を向いて円陣を組み、1 から順番に番号が振られます。アツアツのおイモがひとつ、参加者 <var>n</var> (左の図内側の大きい数字の 30 )に渡されます。おイモを渡された参加者は右隣の参加者にそのおイモを渡します。 <var>m</var> 回目に渡された人は右隣の人に渡して円陣から抜けます(左の図では <var>m</var> = 9 の場合を表しています) 。 回渡す毎に一人ずつぬけ、最後に残った人が勝者となり、おイモをいただきます。
</p>
<p>
<var>n</var> ,<var>m</var> が決まってから、実際におイモを渡し始める前にどこにいたら勝てるかわかるといいですよね。上の図は 30 人の参加者で 9 人ごとに抜けるというルールでこのゲームをした場合を書き表しています。内側の大きい数字が参加者に振られた番号、外側の小さい数字が抜ける順番です。それによると、9,18,27,6,16,26 という順番で円陣から抜け出し、最後には 21 が残ることになります。すなわち 21 が勝者となります(小さい数字が 30 になっています)。
</p>
<p>
ゲーム参加者数 <var>n</var> と円陣から抜け出す参加者の間隔 <var>m</var> を入力し、勝者の番号を出力するプログラムを作成してください。ただし、<var>m</var>, <var>n</var> < 1000 とします。
</p>
<H2>入力</H2>
<p>複数のデータセットが与えられます。各データセットは以下の形式で与えられます。</p>
<pre>
<var>n</var> <var>m</var>
</pre>
<p>
ゲーム参加者数 <var>n</var> （整数）と円陣から抜け出す参加者の間隔 <var>m</var> （整数）が空白区切りで１行に与えられます。
</p>
<p>入力は２つの 0 で終わります。データセットの数は 50 を超えません。</p>
<H2>出力</H2>
<p>各データセットに対して、勝者となりおイモをいただく人の番号（整数）を１行に出力してください。</P>
<H2>Sample Input</H2>
<pre>
41 3
30 9
0 0
</pre>
<H2>Output for the Sample Input</H2>
<pre>
31
21
</pre>
| 41 3
30 9
0 0
| 31
21
| 12,366 |
s528665892 | p00085 | u078042885 | 1483502172 | Python | Python3 | py | Accepted | 30 | 7520 | 137 | while 1:
n,m=map(int,input().split())
if n==m==0:break
a=m-1
while a<(m-1)*n:
a=int(m*a/(m-1)+1)
print(n*m-a) | p00085 |
<H1>ヨセフのおイモ</H1>
<center>
<img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_13_1">
</center>
<br/>
<p>昔、ヨセフのおイモというゲームがありました。<var>n</var> 人が参加しているとしましょう。参加者は中心を向いて円陣を組み、1 から順番に番号が振られます。アツアツのおイモがひとつ、参加者 <var>n</var> (左の図内側の大きい数字の 30 )に渡されます。おイモを渡された参加者は右隣の参加者にそのおイモを渡します。 <var>m</var> 回目に渡された人は右隣の人に渡して円陣から抜けます(左の図では <var>m</var> = 9 の場合を表しています) 。 回渡す毎に一人ずつぬけ、最後に残った人が勝者となり、おイモをいただきます。
</p>
<p>
<var>n</var> ,<var>m</var> が決まってから、実際におイモを渡し始める前にどこにいたら勝てるかわかるといいですよね。上の図は 30 人の参加者で 9 人ごとに抜けるというルールでこのゲームをした場合を書き表しています。内側の大きい数字が参加者に振られた番号、外側の小さい数字が抜ける順番です。それによると、9,18,27,6,16,26 という順番で円陣から抜け出し、最後には 21 が残ることになります。すなわち 21 が勝者となります(小さい数字が 30 になっています)。
</p>
<p>
ゲーム参加者数 <var>n</var> と円陣から抜け出す参加者の間隔 <var>m</var> を入力し、勝者の番号を出力するプログラムを作成してください。ただし、<var>m</var>, <var>n</var> < 1000 とします。
</p>
<H2>入力</H2>
<p>複数のデータセットが与えられます。各データセットは以下の形式で与えられます。</p>
<pre>
<var>n</var> <var>m</var>
</pre>
<p>
ゲーム参加者数 <var>n</var> （整数）と円陣から抜け出す参加者の間隔 <var>m</var> （整数）が空白区切りで１行に与えられます。
</p>
<p>入力は２つの 0 で終わります。データセットの数は 50 を超えません。</p>
<H2>出力</H2>
<p>各データセットに対して、勝者となりおイモをいただく人の番号（整数）を１行に出力してください。</P>
<H2>Sample Input</H2>
<pre>
41 3
30 9
0 0
</pre>
<H2>Output for the Sample Input</H2>
<pre>
31
21
</pre>
| 41 3
30 9
0 0
| 31
21
| 12,367 |
s843449224 | p00085 | u078042885 | 1484135788 | Python | Python3 | py | Accepted | 30 | 7576 | 138 | while 1:
n,m=map(int,input().split())
if n==0:break
a=m-1
while a<(m-1)*n:
a=m*a//(m-1)+1
a=n*m-a
print(a) | p00085 |
<H1>ヨセフのおイモ</H1>
<center>
<img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_13_1">
</center>
<br/>
<p>昔、ヨセフのおイモというゲームがありました。<var>n</var> 人が参加しているとしましょう。参加者は中心を向いて円陣を組み、1 から順番に番号が振られます。アツアツのおイモがひとつ、参加者 <var>n</var> (左の図内側の大きい数字の 30 )に渡されます。おイモを渡された参加者は右隣の参加者にそのおイモを渡します。 <var>m</var> 回目に渡された人は右隣の人に渡して円陣から抜けます(左の図では <var>m</var> = 9 の場合を表しています) 。 回渡す毎に一人ずつぬけ、最後に残った人が勝者となり、おイモをいただきます。
</p>
<p>
<var>n</var> ,<var>m</var> が決まってから、実際におイモを渡し始める前にどこにいたら勝てるかわかるといいですよね。上の図は 30 人の参加者で 9 人ごとに抜けるというルールでこのゲームをした場合を書き表しています。内側の大きい数字が参加者に振られた番号、外側の小さい数字が抜ける順番です。それによると、9,18,27,6,16,26 という順番で円陣から抜け出し、最後には 21 が残ることになります。すなわち 21 が勝者となります(小さい数字が 30 になっています)。
</p>
<p>
ゲーム参加者数 <var>n</var> と円陣から抜け出す参加者の間隔 <var>m</var> を入力し、勝者の番号を出力するプログラムを作成してください。ただし、<var>m</var>, <var>n</var> < 1000 とします。
</p>
<H2>入力</H2>
<p>複数のデータセットが与えられます。各データセットは以下の形式で与えられます。</p>
<pre>
<var>n</var> <var>m</var>
</pre>
<p>
ゲーム参加者数 <var>n</var> （整数）と円陣から抜け出す参加者の間隔 <var>m</var> （整数）が空白区切りで１行に与えられます。
</p>
<p>入力は２つの 0 で終わります。データセットの数は 50 を超えません。</p>
<H2>出力</H2>
<p>各データセットに対して、勝者となりおイモをいただく人の番号（整数）を１行に出力してください。</P>
<H2>Sample Input</H2>
<pre>
41 3
30 9
0 0
</pre>
<H2>Output for the Sample Input</H2>
<pre>
31
21
</pre>
| 41 3
30 9
0 0
| 31
21
| 12,368 |
s616985515 | p00085 | u078042885 | 1484135907 | Python | Python3 | py | Accepted | 30 | 7496 | 130 | while 1:
n,m=map(int,input().split())
if n==0:break
a=m-1
while a<(m-1)*n:
a=m*a//(m-1)+1
print(n*m-a) | p00085 |
<H1>ヨセフのおイモ</H1>
<center>
<img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_13_1">
</center>
<br/>
<p>昔、ヨセフのおイモというゲームがありました。<var>n</var> 人が参加しているとしましょう。参加者は中心を向いて円陣を組み、1 から順番に番号が振られます。アツアツのおイモがひとつ、参加者 <var>n</var> (左の図内側の大きい数字の 30 )に渡されます。おイモを渡された参加者は右隣の参加者にそのおイモを渡します。 <var>m</var> 回目に渡された人は右隣の人に渡して円陣から抜けます(左の図では <var>m</var> = 9 の場合を表しています) 。 回渡す毎に一人ずつぬけ、最後に残った人が勝者となり、おイモをいただきます。
</p>
<p>
<var>n</var> ,<var>m</var> が決まってから、実際におイモを渡し始める前にどこにいたら勝てるかわかるといいですよね。上の図は 30 人の参加者で 9 人ごとに抜けるというルールでこのゲームをした場合を書き表しています。内側の大きい数字が参加者に振られた番号、外側の小さい数字が抜ける順番です。それによると、9,18,27,6,16,26 という順番で円陣から抜け出し、最後には 21 が残ることになります。すなわち 21 が勝者となります(小さい数字が 30 になっています)。
</p>
<p>
ゲーム参加者数 <var>n</var> と円陣から抜け出す参加者の間隔 <var>m</var> を入力し、勝者の番号を出力するプログラムを作成してください。ただし、<var>m</var>, <var>n</var> < 1000 とします。
</p>
<H2>入力</H2>
<p>複数のデータセットが与えられます。各データセットは以下の形式で与えられます。</p>
<pre>
<var>n</var> <var>m</var>
</pre>
<p>
ゲーム参加者数 <var>n</var> （整数）と円陣から抜け出す参加者の間隔 <var>m</var> （整数）が空白区切りで１行に与えられます。
</p>
<p>入力は２つの 0 で終わります。データセットの数は 50 を超えません。</p>
<H2>出力</H2>
<p>各データセットに対して、勝者となりおイモをいただく人の番号（整数）を１行に出力してください。</P>
<H2>Sample Input</H2>
<pre>
41 3
30 9
0 0
</pre>
<H2>Output for the Sample Input</H2>
<pre>
31
21
</pre>
| 41 3
30 9
0 0
| 31
21
| 12,369 |
s300773951 | p00085 | u078042885 | 1484982498 | Python | Python3 | py | Accepted | 30 | 7548 | 121 | while 1:
n,m=map(int,input().split())
if n==0:break
a=m-1
while a<(m-1)*n:a=m*a//(m-1)+1
print(n*m-a) | p00085 |
<H1>ヨセフのおイモ</H1>
<center>
<img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_13_1">
</center>
<br/>
<p>昔、ヨセフのおイモというゲームがありました。<var>n</var> 人が参加しているとしましょう。参加者は中心を向いて円陣を組み、1 から順番に番号が振られます。アツアツのおイモがひとつ、参加者 <var>n</var> (左の図内側の大きい数字の 30 )に渡されます。おイモを渡された参加者は右隣の参加者にそのおイモを渡します。 <var>m</var> 回目に渡された人は右隣の人に渡して円陣から抜けます(左の図では <var>m</var> = 9 の場合を表しています) 。 回渡す毎に一人ずつぬけ、最後に残った人が勝者となり、おイモをいただきます。
</p>
<p>
<var>n</var> ,<var>m</var> が決まってから、実際におイモを渡し始める前にどこにいたら勝てるかわかるといいですよね。上の図は 30 人の参加者で 9 人ごとに抜けるというルールでこのゲームをした場合を書き表しています。内側の大きい数字が参加者に振られた番号、外側の小さい数字が抜ける順番です。それによると、9,18,27,6,16,26 という順番で円陣から抜け出し、最後には 21 が残ることになります。すなわち 21 が勝者となります(小さい数字が 30 になっています)。
</p>
<p>
ゲーム参加者数 <var>n</var> と円陣から抜け出す参加者の間隔 <var>m</var> を入力し、勝者の番号を出力するプログラムを作成してください。ただし、<var>m</var>, <var>n</var> < 1000 とします。
</p>
<H2>入力</H2>
<p>複数のデータセットが与えられます。各データセットは以下の形式で与えられます。</p>
<pre>
<var>n</var> <var>m</var>
</pre>
<p>
ゲーム参加者数 <var>n</var> （整数）と円陣から抜け出す参加者の間隔 <var>m</var> （整数）が空白区切りで１行に与えられます。
</p>
<p>入力は２つの 0 で終わります。データセットの数は 50 を超えません。</p>
<H2>出力</H2>
<p>各データセットに対して、勝者となりおイモをいただく人の番号（整数）を１行に出力してください。</P>
<H2>Sample Input</H2>
<pre>
41 3
30 9
0 0
</pre>
<H2>Output for the Sample Input</H2>
<pre>
31
21
</pre>
| 41 3
30 9
0 0
| 31
21
| 12,370 |
s730572475 | p00085 | u078042885 | 1486957591 | Python | Python3 | py | Accepted | 30 | 7564 | 125 | while 1:
n,m=map(int,input().split())
if n==0:break
a=m-1
while a<(m-1)*n:a=int(m*a/(m-1)+1)
print(n*m-a) | p00085 |
<H1>ヨセフのおイモ</H1>
<center>
<img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_13_1">
</center>
<br/>
<p>昔、ヨセフのおイモというゲームがありました。<var>n</var> 人が参加しているとしましょう。参加者は中心を向いて円陣を組み、1 から順番に番号が振られます。アツアツのおイモがひとつ、参加者 <var>n</var> (左の図内側の大きい数字の 30 )に渡されます。おイモを渡された参加者は右隣の参加者にそのおイモを渡します。 <var>m</var> 回目に渡された人は右隣の人に渡して円陣から抜けます(左の図では <var>m</var> = 9 の場合を表しています) 。 回渡す毎に一人ずつぬけ、最後に残った人が勝者となり、おイモをいただきます。
</p>
<p>
<var>n</var> ,<var>m</var> が決まってから、実際におイモを渡し始める前にどこにいたら勝てるかわかるといいですよね。上の図は 30 人の参加者で 9 人ごとに抜けるというルールでこのゲームをした場合を書き表しています。内側の大きい数字が参加者に振られた番号、外側の小さい数字が抜ける順番です。それによると、9,18,27,6,16,26 という順番で円陣から抜け出し、最後には 21 が残ることになります。すなわち 21 が勝者となります(小さい数字が 30 になっています)。
</p>
<p>
ゲーム参加者数 <var>n</var> と円陣から抜け出す参加者の間隔 <var>m</var> を入力し、勝者の番号を出力するプログラムを作成してください。ただし、<var>m</var>, <var>n</var> < 1000 とします。
</p>
<H2>入力</H2>
<p>複数のデータセットが与えられます。各データセットは以下の形式で与えられます。</p>
<pre>
<var>n</var> <var>m</var>
</pre>
<p>
ゲーム参加者数 <var>n</var> （整数）と円陣から抜け出す参加者の間隔 <var>m</var> （整数）が空白区切りで１行に与えられます。
</p>
<p>入力は２つの 0 で終わります。データセットの数は 50 を超えません。</p>
<H2>出力</H2>
<p>各データセットに対して、勝者となりおイモをいただく人の番号（整数）を１行に出力してください。</P>
<H2>Sample Input</H2>
<pre>
41 3
30 9
0 0
</pre>
<H2>Output for the Sample Input</H2>
<pre>
31
21
</pre>
| 41 3
30 9
0 0
| 31
21
| 12,371 |
s348064045 | p00085 | u078042885 | 1486957688 | Python | Python3 | py | Accepted | 30 | 7520 | 119 | while 1:
n,m=map(int,input().split())
if n==0:break
a=m-1
while a<m*n-n:a=m*a//(m-1)+1
print(n*m-a) | p00085 |
<H1>ヨセフのおイモ</H1>
<center>
<img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_13_1">
</center>
<br/>
<p>昔、ヨセフのおイモというゲームがありました。<var>n</var> 人が参加しているとしましょう。参加者は中心を向いて円陣を組み、1 から順番に番号が振られます。アツアツのおイモがひとつ、参加者 <var>n</var> (左の図内側の大きい数字の 30 )に渡されます。おイモを渡された参加者は右隣の参加者にそのおイモを渡します。 <var>m</var> 回目に渡された人は右隣の人に渡して円陣から抜けます(左の図では <var>m</var> = 9 の場合を表しています) 。 回渡す毎に一人ずつぬけ、最後に残った人が勝者となり、おイモをいただきます。
</p>
<p>
<var>n</var> ,<var>m</var> が決まってから、実際におイモを渡し始める前にどこにいたら勝てるかわかるといいですよね。上の図は 30 人の参加者で 9 人ごとに抜けるというルールでこのゲームをした場合を書き表しています。内側の大きい数字が参加者に振られた番号、外側の小さい数字が抜ける順番です。それによると、9,18,27,6,16,26 という順番で円陣から抜け出し、最後には 21 が残ることになります。すなわち 21 が勝者となります(小さい数字が 30 になっています)。
</p>
<p>
ゲーム参加者数 <var>n</var> と円陣から抜け出す参加者の間隔 <var>m</var> を入力し、勝者の番号を出力するプログラムを作成してください。ただし、<var>m</var>, <var>n</var> < 1000 とします。
</p>
<H2>入力</H2>
<p>複数のデータセットが与えられます。各データセットは以下の形式で与えられます。</p>
<pre>
<var>n</var> <var>m</var>
</pre>
<p>
ゲーム参加者数 <var>n</var> （整数）と円陣から抜け出す参加者の間隔 <var>m</var> （整数）が空白区切りで１行に与えられます。
</p>
<p>入力は２つの 0 で終わります。データセットの数は 50 を超えません。</p>
<H2>出力</H2>
<p>各データセットに対して、勝者となりおイモをいただく人の番号（整数）を１行に出力してください。</P>
<H2>Sample Input</H2>
<pre>
41 3
30 9
0 0
</pre>
<H2>Output for the Sample Input</H2>
<pre>
31
21
</pre>
| 41 3
30 9
0 0
| 31
21
| 12,372 |
s516272539 | p00085 | u078042885 | 1486957819 | Python | Python3 | py | Accepted | 20 | 7524 | 118 | while 1:
n,m=map(int,input().split())
if n==0:break
a=0
for i in range(2,n+1):a=(a+m)%i
print(a+1) | p00085 |
<H1>ヨセフのおイモ</H1>
<center>
<img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_13_1">
</center>
<br/>
<p>昔、ヨセフのおイモというゲームがありました。<var>n</var> 人が参加しているとしましょう。参加者は中心を向いて円陣を組み、1 から順番に番号が振られます。アツアツのおイモがひとつ、参加者 <var>n</var> (左の図内側の大きい数字の 30 )に渡されます。おイモを渡された参加者は右隣の参加者にそのおイモを渡します。 <var>m</var> 回目に渡された人は右隣の人に渡して円陣から抜けます(左の図では <var>m</var> = 9 の場合を表しています) 。 回渡す毎に一人ずつぬけ、最後に残った人が勝者となり、おイモをいただきます。
</p>
<p>
<var>n</var> ,<var>m</var> が決まってから、実際におイモを渡し始める前にどこにいたら勝てるかわかるといいですよね。上の図は 30 人の参加者で 9 人ごとに抜けるというルールでこのゲームをした場合を書き表しています。内側の大きい数字が参加者に振られた番号、外側の小さい数字が抜ける順番です。それによると、9,18,27,6,16,26 という順番で円陣から抜け出し、最後には 21 が残ることになります。すなわち 21 が勝者となります(小さい数字が 30 になっています)。
</p>
<p>
ゲーム参加者数 <var>n</var> と円陣から抜け出す参加者の間隔 <var>m</var> を入力し、勝者の番号を出力するプログラムを作成してください。ただし、<var>m</var>, <var>n</var> < 1000 とします。
</p>
<H2>入力</H2>
<p>複数のデータセットが与えられます。各データセットは以下の形式で与えられます。</p>
<pre>
<var>n</var> <var>m</var>
</pre>
<p>
ゲーム参加者数 <var>n</var> （整数）と円陣から抜け出す参加者の間隔 <var>m</var> （整数）が空白区切りで１行に与えられます。
</p>
<p>入力は２つの 0 で終わります。データセットの数は 50 を超えません。</p>
<H2>出力</H2>
<p>各データセットに対して、勝者となりおイモをいただく人の番号（整数）を１行に出力してください。</P>
<H2>Sample Input</H2>
<pre>
41 3
30 9
0 0
</pre>
<H2>Output for the Sample Input</H2>
<pre>
31
21
</pre>
| 41 3
30 9
0 0
| 31
21
| 12,373 |
s893166274 | p00085 | u462831976 | 1493452452 | Python | Python3 | py | Accepted | 20 | 7572 | 422 | # -*- coding: utf-8 -*-
import sys
import os
import math
for s in sys.stdin:
n, m = map(int, s.split())
if n == m == 0:
break
lst = [i for i in range(1, n+1)]
remove_index = m - 1
while len(lst) > 1:
del lst[remove_index]
# next index
remove_index += (m - 1)
if remove_index >= len(lst):
remove_index = remove_index % len(lst)
print(lst[0]) | p00085 |
<H1>ヨセフのおイモ</H1>
<center>
<img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_13_1">
</center>
<br/>
<p>昔、ヨセフのおイモというゲームがありました。<var>n</var> 人が参加しているとしましょう。参加者は中心を向いて円陣を組み、1 から順番に番号が振られます。アツアツのおイモがひとつ、参加者 <var>n</var> (左の図内側の大きい数字の 30 )に渡されます。おイモを渡された参加者は右隣の参加者にそのおイモを渡します。 <var>m</var> 回目に渡された人は右隣の人に渡して円陣から抜けます(左の図では <var>m</var> = 9 の場合を表しています) 。 回渡す毎に一人ずつぬけ、最後に残った人が勝者となり、おイモをいただきます。
</p>
<p>
<var>n</var> ,<var>m</var> が決まってから、実際におイモを渡し始める前にどこにいたら勝てるかわかるといいですよね。上の図は 30 人の参加者で 9 人ごとに抜けるというルールでこのゲームをした場合を書き表しています。内側の大きい数字が参加者に振られた番号、外側の小さい数字が抜ける順番です。それによると、9,18,27,6,16,26 という順番で円陣から抜け出し、最後には 21 が残ることになります。すなわち 21 が勝者となります(小さい数字が 30 になっています)。
</p>
<p>
ゲーム参加者数 <var>n</var> と円陣から抜け出す参加者の間隔 <var>m</var> を入力し、勝者の番号を出力するプログラムを作成してください。ただし、<var>m</var>, <var>n</var> < 1000 とします。
</p>
<H2>入力</H2>
<p>複数のデータセットが与えられます。各データセットは以下の形式で与えられます。</p>
<pre>
<var>n</var> <var>m</var>
</pre>
<p>
ゲーム参加者数 <var>n</var> （整数）と円陣から抜け出す参加者の間隔 <var>m</var> （整数）が空白区切りで１行に与えられます。
</p>
<p>入力は２つの 0 で終わります。データセットの数は 50 を超えません。</p>
<H2>出力</H2>
<p>各データセットに対して、勝者となりおイモをいただく人の番号（整数）を１行に出力してください。</P>
<H2>Sample Input</H2>
<pre>
41 3
30 9
0 0
</pre>
<H2>Output for the Sample Input</H2>
<pre>
31
21
</pre>
| 41 3
30 9
0 0
| 31
21
| 12,374 |
s685147294 | p00085 | u546285759 | 1496402920 | Python | Python3 | py | Accepted | 30 | 7720 | 219 | while True:
n, m = map(int, input().split())
if n == 0:
break
p = [i for i in range(1, n+1)]
idx = m-1
while len(p) != 1:
v = p.pop(idx)
idx = (idx+m-1) % len(p)
print(*p) | p00085 |
<H1>ヨセフのおイモ</H1>
<center>
<img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_13_1">
</center>
<br/>
<p>昔、ヨセフのおイモというゲームがありました。<var>n</var> 人が参加しているとしましょう。参加者は中心を向いて円陣を組み、1 から順番に番号が振られます。アツアツのおイモがひとつ、参加者 <var>n</var> (左の図内側の大きい数字の 30 )に渡されます。おイモを渡された参加者は右隣の参加者にそのおイモを渡します。 <var>m</var> 回目に渡された人は右隣の人に渡して円陣から抜けます(左の図では <var>m</var> = 9 の場合を表しています) 。 回渡す毎に一人ずつぬけ、最後に残った人が勝者となり、おイモをいただきます。
</p>
<p>
<var>n</var> ,<var>m</var> が決まってから、実際におイモを渡し始める前にどこにいたら勝てるかわかるといいですよね。上の図は 30 人の参加者で 9 人ごとに抜けるというルールでこのゲームをした場合を書き表しています。内側の大きい数字が参加者に振られた番号、外側の小さい数字が抜ける順番です。それによると、9,18,27,6,16,26 という順番で円陣から抜け出し、最後には 21 が残ることになります。すなわち 21 が勝者となります(小さい数字が 30 になっています)。
</p>
<p>
ゲーム参加者数 <var>n</var> と円陣から抜け出す参加者の間隔 <var>m</var> を入力し、勝者の番号を出力するプログラムを作成してください。ただし、<var>m</var>, <var>n</var> < 1000 とします。
</p>
<H2>入力</H2>
<p>複数のデータセットが与えられます。各データセットは以下の形式で与えられます。</p>
<pre>
<var>n</var> <var>m</var>
</pre>
<p>
ゲーム参加者数 <var>n</var> （整数）と円陣から抜け出す参加者の間隔 <var>m</var> （整数）が空白区切りで１行に与えられます。
</p>
<p>入力は２つの 0 で終わります。データセットの数は 50 を超えません。</p>
<H2>出力</H2>
<p>各データセットに対して、勝者となりおイモをいただく人の番号（整数）を１行に出力してください。</P>
<H2>Sample Input</H2>
<pre>
41 3
30 9
0 0
</pre>
<H2>Output for the Sample Input</H2>
<pre>
31
21
</pre>
| 41 3
30 9
0 0
| 31
21
| 12,375 |
s165443978 | p00085 | u133119785 | 1498916805 | Python | Python | py | Accepted | 10 | 6404 | 349 | def act(t,m,l):
t = (t+m) % len(l);
del l[t-1]
return (t-1) % (len(l)+1)
while True:
i = raw_input().split()
n = int(i[0])
m = int(i[1])
if n == 0 and m == 0:
break
else:
l = range(1,n+1)
t = 0
for i in range(n-1):
tt = act(t,m,l);
t = tt;
print l[0] | p00085 |
<H1>ヨセフのおイモ</H1>
<center>
<img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_13_1">
</center>
<br/>
<p>昔、ヨセフのおイモというゲームがありました。<var>n</var> 人が参加しているとしましょう。参加者は中心を向いて円陣を組み、1 から順番に番号が振られます。アツアツのおイモがひとつ、参加者 <var>n</var> (左の図内側の大きい数字の 30 )に渡されます。おイモを渡された参加者は右隣の参加者にそのおイモを渡します。 <var>m</var> 回目に渡された人は右隣の人に渡して円陣から抜けます(左の図では <var>m</var> = 9 の場合を表しています) 。 回渡す毎に一人ずつぬけ、最後に残った人が勝者となり、おイモをいただきます。
</p>
<p>
<var>n</var> ,<var>m</var> が決まってから、実際におイモを渡し始める前にどこにいたら勝てるかわかるといいですよね。上の図は 30 人の参加者で 9 人ごとに抜けるというルールでこのゲームをした場合を書き表しています。内側の大きい数字が参加者に振られた番号、外側の小さい数字が抜ける順番です。それによると、9,18,27,6,16,26 という順番で円陣から抜け出し、最後には 21 が残ることになります。すなわち 21 が勝者となります(小さい数字が 30 になっています)。
</p>
<p>
ゲーム参加者数 <var>n</var> と円陣から抜け出す参加者の間隔 <var>m</var> を入力し、勝者の番号を出力するプログラムを作成してください。ただし、<var>m</var>, <var>n</var> < 1000 とします。
</p>
<H2>入力</H2>
<p>複数のデータセットが与えられます。各データセットは以下の形式で与えられます。</p>
<pre>
<var>n</var> <var>m</var>
</pre>
<p>
ゲーム参加者数 <var>n</var> （整数）と円陣から抜け出す参加者の間隔 <var>m</var> （整数）が空白区切りで１行に与えられます。
</p>
<p>入力は２つの 0 で終わります。データセットの数は 50 を超えません。</p>
<H2>出力</H2>
<p>各データセットに対して、勝者となりおイモをいただく人の番号（整数）を１行に出力してください。</P>
<H2>Sample Input</H2>
<pre>
41 3
30 9
0 0
</pre>
<H2>Output for the Sample Input</H2>
<pre>
31
21
</pre>
| 41 3
30 9
0 0
| 31
21
| 12,376 |
s384069795 | p00085 | u957021183 | 1505198219 | Python | Python3 | py | Accepted | 30 | 7768 | 547 | # Aizu Problem 0085: Joseph's Potato
#
import sys, math, os
# read input:
PYDEV = os.environ.get('PYDEV')
if PYDEV=="True":
sys.stdin = open("sample-input2.txt", "rt")
def josephus_survivor(n,k):
people = list(range(1, n+1))
current = (k - 1) % n
while len(people)> 1:
removed = people.pop(current)
current = (current + k - 1) % len(people)
return people[0]
while True:
n, m = [int(_) for _ in input().split()]
if n == m == 0:
break
print(josephus_survivor(n, m))
| p00085 |
<H1>ヨセフのおイモ</H1>
<center>
<img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_13_1">
</center>
<br/>
<p>昔、ヨセフのおイモというゲームがありました。<var>n</var> 人が参加しているとしましょう。参加者は中心を向いて円陣を組み、1 から順番に番号が振られます。アツアツのおイモがひとつ、参加者 <var>n</var> (左の図内側の大きい数字の 30 )に渡されます。おイモを渡された参加者は右隣の参加者にそのおイモを渡します。 <var>m</var> 回目に渡された人は右隣の人に渡して円陣から抜けます(左の図では <var>m</var> = 9 の場合を表しています) 。 回渡す毎に一人ずつぬけ、最後に残った人が勝者となり、おイモをいただきます。
</p>
<p>
<var>n</var> ,<var>m</var> が決まってから、実際におイモを渡し始める前にどこにいたら勝てるかわかるといいですよね。上の図は 30 人の参加者で 9 人ごとに抜けるというルールでこのゲームをした場合を書き表しています。内側の大きい数字が参加者に振られた番号、外側の小さい数字が抜ける順番です。それによると、9,18,27,6,16,26 という順番で円陣から抜け出し、最後には 21 が残ることになります。すなわち 21 が勝者となります(小さい数字が 30 になっています)。
</p>
<p>
ゲーム参加者数 <var>n</var> と円陣から抜け出す参加者の間隔 <var>m</var> を入力し、勝者の番号を出力するプログラムを作成してください。ただし、<var>m</var>, <var>n</var> < 1000 とします。
</p>
<H2>入力</H2>
<p>複数のデータセットが与えられます。各データセットは以下の形式で与えられます。</p>
<pre>
<var>n</var> <var>m</var>
</pre>
<p>
ゲーム参加者数 <var>n</var> （整数）と円陣から抜け出す参加者の間隔 <var>m</var> （整数）が空白区切りで１行に与えられます。
</p>
<p>入力は２つの 0 で終わります。データセットの数は 50 を超えません。</p>
<H2>出力</H2>
<p>各データセットに対して、勝者となりおイモをいただく人の番号（整数）を１行に出力してください。</P>
<H2>Sample Input</H2>
<pre>
41 3
30 9
0 0
</pre>
<H2>Output for the Sample Input</H2>
<pre>
31
21
</pre>
| 41 3
30 9
0 0
| 31
21
| 12,377 |
s077248639 | p00085 | u811733736 | 1507444062 | Python | Python3 | py | Accepted | 30 | 7788 | 736 | # -*- coding: utf-8 -*-
"""
http://judge.u-aizu.ac.jp/onlinejudge/description.jsp?id=0085
"""
import sys
from sys import stdin
input = stdin.readline
def solve(n, m):
remaining = list(range(1, n+1))
start = n - 1 # ????????????????????????????????????
while n > 1:
v = (m+start) % n # ????????????????±???????
remaining.pop(v)
start = v - 1 # ????????????????????¢????????£??????????????????
n -= 1
return remaining[0]
def main(args):
while True:
n, m = map(int, input().split())
if n == 0 and m == 0:
break
result = solve(n, m)
print(result)
if __name__ == '__main__':
main(sys.argv[1:])
| p00085 |
<H1>ヨセフのおイモ</H1>
<center>
<img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_13_1">
</center>
<br/>
<p>昔、ヨセフのおイモというゲームがありました。<var>n</var> 人が参加しているとしましょう。参加者は中心を向いて円陣を組み、1 から順番に番号が振られます。アツアツのおイモがひとつ、参加者 <var>n</var> (左の図内側の大きい数字の 30 )に渡されます。おイモを渡された参加者は右隣の参加者にそのおイモを渡します。 <var>m</var> 回目に渡された人は右隣の人に渡して円陣から抜けます(左の図では <var>m</var> = 9 の場合を表しています) 。 回渡す毎に一人ずつぬけ、最後に残った人が勝者となり、おイモをいただきます。
</p>
<p>
<var>n</var> ,<var>m</var> が決まってから、実際におイモを渡し始める前にどこにいたら勝てるかわかるといいですよね。上の図は 30 人の参加者で 9 人ごとに抜けるというルールでこのゲームをした場合を書き表しています。内側の大きい数字が参加者に振られた番号、外側の小さい数字が抜ける順番です。それによると、9,18,27,6,16,26 という順番で円陣から抜け出し、最後には 21 が残ることになります。すなわち 21 が勝者となります(小さい数字が 30 になっています)。
</p>
<p>
ゲーム参加者数 <var>n</var> と円陣から抜け出す参加者の間隔 <var>m</var> を入力し、勝者の番号を出力するプログラムを作成してください。ただし、<var>m</var>, <var>n</var> < 1000 とします。
</p>
<H2>入力</H2>
<p>複数のデータセットが与えられます。各データセットは以下の形式で与えられます。</p>
<pre>
<var>n</var> <var>m</var>
</pre>
<p>
ゲーム参加者数 <var>n</var> （整数）と円陣から抜け出す参加者の間隔 <var>m</var> （整数）が空白区切りで１行に与えられます。
</p>
<p>入力は２つの 0 で終わります。データセットの数は 50 を超えません。</p>
<H2>出力</H2>
<p>各データセットに対して、勝者となりおイモをいただく人の番号（整数）を１行に出力してください。</P>
<H2>Sample Input</H2>
<pre>
41 3
30 9
0 0
</pre>
<H2>Output for the Sample Input</H2>
<pre>
31
21
</pre>
| 41 3
30 9
0 0
| 31
21
| 12,378 |
s698812189 | p00085 | u043254318 | 1519757101 | Python | Python3 | py | Accepted | 30 | 5600 | 297 | while True:
n,m = [int(i) for i in input().split()]
if n == 0 and m == 0:
break
table = []
for i in range(n):
table.append(i+1)
p = m - 1
for i in range(n-1):
table.pop(p)
p = (p+m-1) % len(table)
#print(table)
print(table[0])
| p00085 |
<H1>ヨセフのおイモ</H1>
<center>
<img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_13_1">
</center>
<br/>
<p>昔、ヨセフのおイモというゲームがありました。<var>n</var> 人が参加しているとしましょう。参加者は中心を向いて円陣を組み、1 から順番に番号が振られます。アツアツのおイモがひとつ、参加者 <var>n</var> (左の図内側の大きい数字の 30 )に渡されます。おイモを渡された参加者は右隣の参加者にそのおイモを渡します。 <var>m</var> 回目に渡された人は右隣の人に渡して円陣から抜けます(左の図では <var>m</var> = 9 の場合を表しています) 。 回渡す毎に一人ずつぬけ、最後に残った人が勝者となり、おイモをいただきます。
</p>
<p>
<var>n</var> ,<var>m</var> が決まってから、実際におイモを渡し始める前にどこにいたら勝てるかわかるといいですよね。上の図は 30 人の参加者で 9 人ごとに抜けるというルールでこのゲームをした場合を書き表しています。内側の大きい数字が参加者に振られた番号、外側の小さい数字が抜ける順番です。それによると、9,18,27,6,16,26 という順番で円陣から抜け出し、最後には 21 が残ることになります。すなわち 21 が勝者となります(小さい数字が 30 になっています)。
</p>
<p>
ゲーム参加者数 <var>n</var> と円陣から抜け出す参加者の間隔 <var>m</var> を入力し、勝者の番号を出力するプログラムを作成してください。ただし、<var>m</var>, <var>n</var> < 1000 とします。
</p>
<H2>入力</H2>
<p>複数のデータセットが与えられます。各データセットは以下の形式で与えられます。</p>
<pre>
<var>n</var> <var>m</var>
</pre>
<p>
ゲーム参加者数 <var>n</var> （整数）と円陣から抜け出す参加者の間隔 <var>m</var> （整数）が空白区切りで１行に与えられます。
</p>
<p>入力は２つの 0 で終わります。データセットの数は 50 を超えません。</p>
<H2>出力</H2>
<p>各データセットに対して、勝者となりおイモをいただく人の番号（整数）を１行に出力してください。</P>
<H2>Sample Input</H2>
<pre>
41 3
30 9
0 0
</pre>
<H2>Output for the Sample Input</H2>
<pre>
31
21
</pre>
| 41 3
30 9
0 0
| 31
21
| 12,379 |
s965320570 | p00085 | u352394527 | 1527587030 | Python | Python3 | py | Accepted | 30 | 5604 | 222 | while True:
n, m = map(int, input().split())
if not n:
break
lst = [i for i in range(1, n + 1)]
ind = n - 1
while len(lst) > 1:
ind = (ind + m) % len(lst)
lst.pop(ind)
ind -= 1
print(lst[0])
| p00085 |
<H1>ヨセフのおイモ</H1>
<center>
<img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_13_1">
</center>
<br/>
<p>昔、ヨセフのおイモというゲームがありました。<var>n</var> 人が参加しているとしましょう。参加者は中心を向いて円陣を組み、1 から順番に番号が振られます。アツアツのおイモがひとつ、参加者 <var>n</var> (左の図内側の大きい数字の 30 )に渡されます。おイモを渡された参加者は右隣の参加者にそのおイモを渡します。 <var>m</var> 回目に渡された人は右隣の人に渡して円陣から抜けます(左の図では <var>m</var> = 9 の場合を表しています) 。 回渡す毎に一人ずつぬけ、最後に残った人が勝者となり、おイモをいただきます。
</p>
<p>
<var>n</var> ,<var>m</var> が決まってから、実際におイモを渡し始める前にどこにいたら勝てるかわかるといいですよね。上の図は 30 人の参加者で 9 人ごとに抜けるというルールでこのゲームをした場合を書き表しています。内側の大きい数字が参加者に振られた番号、外側の小さい数字が抜ける順番です。それによると、9,18,27,6,16,26 という順番で円陣から抜け出し、最後には 21 が残ることになります。すなわち 21 が勝者となります(小さい数字が 30 になっています)。
</p>
<p>
ゲーム参加者数 <var>n</var> と円陣から抜け出す参加者の間隔 <var>m</var> を入力し、勝者の番号を出力するプログラムを作成してください。ただし、<var>m</var>, <var>n</var> < 1000 とします。
</p>
<H2>入力</H2>
<p>複数のデータセットが与えられます。各データセットは以下の形式で与えられます。</p>
<pre>
<var>n</var> <var>m</var>
</pre>
<p>
ゲーム参加者数 <var>n</var> （整数）と円陣から抜け出す参加者の間隔 <var>m</var> （整数）が空白区切りで１行に与えられます。
</p>
<p>入力は２つの 0 で終わります。データセットの数は 50 を超えません。</p>
<H2>出力</H2>
<p>各データセットに対して、勝者となりおイモをいただく人の番号（整数）を１行に出力してください。</P>
<H2>Sample Input</H2>
<pre>
41 3
30 9
0 0
</pre>
<H2>Output for the Sample Input</H2>
<pre>
31
21
</pre>
| 41 3
30 9
0 0
| 31
21
| 12,380 |
s261571337 | p00085 | u136916346 | 1528727958 | Python | Python3 | py | Accepted | 40 | 5600 | 297 | while 1:
n,m=list(map(int,input().split()))
if n==0 and m==0:break
l=[i for i in range(1,1+n)]
st=m-1
while len(l)!=1:
del l[st]
st+=(m-1)
while 1:
if st>=len(l):
st=st-len(l)
if st<len(l):break
print(l[0])
| p00085 |
<H1>ヨセフのおイモ</H1>
<center>
<img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_13_1">
</center>
<br/>
<p>昔、ヨセフのおイモというゲームがありました。<var>n</var> 人が参加しているとしましょう。参加者は中心を向いて円陣を組み、1 から順番に番号が振られます。アツアツのおイモがひとつ、参加者 <var>n</var> (左の図内側の大きい数字の 30 )に渡されます。おイモを渡された参加者は右隣の参加者にそのおイモを渡します。 <var>m</var> 回目に渡された人は右隣の人に渡して円陣から抜けます(左の図では <var>m</var> = 9 の場合を表しています) 。 回渡す毎に一人ずつぬけ、最後に残った人が勝者となり、おイモをいただきます。
</p>
<p>
<var>n</var> ,<var>m</var> が決まってから、実際におイモを渡し始める前にどこにいたら勝てるかわかるといいですよね。上の図は 30 人の参加者で 9 人ごとに抜けるというルールでこのゲームをした場合を書き表しています。内側の大きい数字が参加者に振られた番号、外側の小さい数字が抜ける順番です。それによると、9,18,27,6,16,26 という順番で円陣から抜け出し、最後には 21 が残ることになります。すなわち 21 が勝者となります(小さい数字が 30 になっています)。
</p>
<p>
ゲーム参加者数 <var>n</var> と円陣から抜け出す参加者の間隔 <var>m</var> を入力し、勝者の番号を出力するプログラムを作成してください。ただし、<var>m</var>, <var>n</var> < 1000 とします。
</p>
<H2>入力</H2>
<p>複数のデータセットが与えられます。各データセットは以下の形式で与えられます。</p>
<pre>
<var>n</var> <var>m</var>
</pre>
<p>
ゲーム参加者数 <var>n</var> （整数）と円陣から抜け出す参加者の間隔 <var>m</var> （整数）が空白区切りで１行に与えられます。
</p>
<p>入力は２つの 0 で終わります。データセットの数は 50 を超えません。</p>
<H2>出力</H2>
<p>各データセットに対して、勝者となりおイモをいただく人の番号（整数）を１行に出力してください。</P>
<H2>Sample Input</H2>
<pre>
41 3
30 9
0 0
</pre>
<H2>Output for the Sample Input</H2>
<pre>
31
21
</pre>
| 41 3
30 9
0 0
| 31
21
| 12,381 |
s883092790 | p00085 | u136916346 | 1528728071 | Python | Python3 | py | Accepted | 30 | 5592 | 291 | while 1:
n,m=list(map(int,input().split()))
if n==0 and m==0:break
l=list(range(1,1+n))
st=m-1
while len(l)!=1:
del l[st]
st+=(m-1)
while 1:
if st>=len(l):
st=st-len(l)
if st<len(l):break
print(l[0])
| p00085 |
<H1>ヨセフのおイモ</H1>
<center>
<img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_13_1">
</center>
<br/>
<p>昔、ヨセフのおイモというゲームがありました。<var>n</var> 人が参加しているとしましょう。参加者は中心を向いて円陣を組み、1 から順番に番号が振られます。アツアツのおイモがひとつ、参加者 <var>n</var> (左の図内側の大きい数字の 30 )に渡されます。おイモを渡された参加者は右隣の参加者にそのおイモを渡します。 <var>m</var> 回目に渡された人は右隣の人に渡して円陣から抜けます(左の図では <var>m</var> = 9 の場合を表しています) 。 回渡す毎に一人ずつぬけ、最後に残った人が勝者となり、おイモをいただきます。
</p>
<p>
<var>n</var> ,<var>m</var> が決まってから、実際におイモを渡し始める前にどこにいたら勝てるかわかるといいですよね。上の図は 30 人の参加者で 9 人ごとに抜けるというルールでこのゲームをした場合を書き表しています。内側の大きい数字が参加者に振られた番号、外側の小さい数字が抜ける順番です。それによると、9,18,27,6,16,26 という順番で円陣から抜け出し、最後には 21 が残ることになります。すなわち 21 が勝者となります(小さい数字が 30 になっています)。
</p>
<p>
ゲーム参加者数 <var>n</var> と円陣から抜け出す参加者の間隔 <var>m</var> を入力し、勝者の番号を出力するプログラムを作成してください。ただし、<var>m</var>, <var>n</var> < 1000 とします。
</p>
<H2>入力</H2>
<p>複数のデータセットが与えられます。各データセットは以下の形式で与えられます。</p>
<pre>
<var>n</var> <var>m</var>
</pre>
<p>
ゲーム参加者数 <var>n</var> （整数）と円陣から抜け出す参加者の間隔 <var>m</var> （整数）が空白区切りで１行に与えられます。
</p>
<p>入力は２つの 0 で終わります。データセットの数は 50 を超えません。</p>
<H2>出力</H2>
<p>各データセットに対して、勝者となりおイモをいただく人の番号（整数）を１行に出力してください。</P>
<H2>Sample Input</H2>
<pre>
41 3
30 9
0 0
</pre>
<H2>Output for the Sample Input</H2>
<pre>
31
21
</pre>
| 41 3
30 9
0 0
| 31
21
| 12,382 |
s266531222 | p00085 | u847467233 | 1529028041 | Python | Python3 | py | Accepted | 20 | 5600 | 242 | # AOJ 0085 Joseph's Potato
# Python3 2018.6.15 bal4u
while True:
try:
n, m = map(int, input().split())
if n == 0:
break
except EOFError:
break
k = 1;
for j in range(2, n+1):
k = (k + m) % j
if k == 0: k = j
print(k)
| p00085 |
<H1>ヨセフのおイモ</H1>
<center>
<img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_13_1">
</center>
<br/>
<p>昔、ヨセフのおイモというゲームがありました。<var>n</var> 人が参加しているとしましょう。参加者は中心を向いて円陣を組み、1 から順番に番号が振られます。アツアツのおイモがひとつ、参加者 <var>n</var> (左の図内側の大きい数字の 30 )に渡されます。おイモを渡された参加者は右隣の参加者にそのおイモを渡します。 <var>m</var> 回目に渡された人は右隣の人に渡して円陣から抜けます(左の図では <var>m</var> = 9 の場合を表しています) 。 回渡す毎に一人ずつぬけ、最後に残った人が勝者となり、おイモをいただきます。
</p>
<p>
<var>n</var> ,<var>m</var> が決まってから、実際におイモを渡し始める前にどこにいたら勝てるかわかるといいですよね。上の図は 30 人の参加者で 9 人ごとに抜けるというルールでこのゲームをした場合を書き表しています。内側の大きい数字が参加者に振られた番号、外側の小さい数字が抜ける順番です。それによると、9,18,27,6,16,26 という順番で円陣から抜け出し、最後には 21 が残ることになります。すなわち 21 が勝者となります(小さい数字が 30 になっています)。
</p>
<p>
ゲーム参加者数 <var>n</var> と円陣から抜け出す参加者の間隔 <var>m</var> を入力し、勝者の番号を出力するプログラムを作成してください。ただし、<var>m</var>, <var>n</var> < 1000 とします。
</p>
<H2>入力</H2>
<p>複数のデータセットが与えられます。各データセットは以下の形式で与えられます。</p>
<pre>
<var>n</var> <var>m</var>
</pre>
<p>
ゲーム参加者数 <var>n</var> （整数）と円陣から抜け出す参加者の間隔 <var>m</var> （整数）が空白区切りで１行に与えられます。
</p>
<p>入力は２つの 0 で終わります。データセットの数は 50 を超えません。</p>
<H2>出力</H2>
<p>各データセットに対して、勝者となりおイモをいただく人の番号（整数）を１行に出力してください。</P>
<H2>Sample Input</H2>
<pre>
41 3
30 9
0 0
</pre>
<H2>Output for the Sample Input</H2>
<pre>
31
21
</pre>
| 41 3
30 9
0 0
| 31
21
| 12,383 |
s669083786 | p00085 | u847467233 | 1529028236 | Python | Python3 | py | Accepted | 20 | 5596 | 200 | # AOJ 0085 Joseph's Potato
# Python3 2018.6.15 bal4u
while True:
n, m = map(int, input().split())
if n == 0:
break
k = 1;
for j in range(2, n+1):
k = (k + m) % j
if k == 0: k = j
print(k)
| p00085 |
<H1>ヨセフのおイモ</H1>
<center>
<img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_13_1">
</center>
<br/>
<p>昔、ヨセフのおイモというゲームがありました。<var>n</var> 人が参加しているとしましょう。参加者は中心を向いて円陣を組み、1 から順番に番号が振られます。アツアツのおイモがひとつ、参加者 <var>n</var> (左の図内側の大きい数字の 30 )に渡されます。おイモを渡された参加者は右隣の参加者にそのおイモを渡します。 <var>m</var> 回目に渡された人は右隣の人に渡して円陣から抜けます(左の図では <var>m</var> = 9 の場合を表しています) 。 回渡す毎に一人ずつぬけ、最後に残った人が勝者となり、おイモをいただきます。
</p>
<p>
<var>n</var> ,<var>m</var> が決まってから、実際におイモを渡し始める前にどこにいたら勝てるかわかるといいですよね。上の図は 30 人の参加者で 9 人ごとに抜けるというルールでこのゲームをした場合を書き表しています。内側の大きい数字が参加者に振られた番号、外側の小さい数字が抜ける順番です。それによると、9,18,27,6,16,26 という順番で円陣から抜け出し、最後には 21 が残ることになります。すなわち 21 が勝者となります(小さい数字が 30 になっています)。
</p>
<p>
ゲーム参加者数 <var>n</var> と円陣から抜け出す参加者の間隔 <var>m</var> を入力し、勝者の番号を出力するプログラムを作成してください。ただし、<var>m</var>, <var>n</var> < 1000 とします。
</p>
<H2>入力</H2>
<p>複数のデータセットが与えられます。各データセットは以下の形式で与えられます。</p>
<pre>
<var>n</var> <var>m</var>
</pre>
<p>
ゲーム参加者数 <var>n</var> （整数）と円陣から抜け出す参加者の間隔 <var>m</var> （整数）が空白区切りで１行に与えられます。
</p>
<p>入力は２つの 0 で終わります。データセットの数は 50 を超えません。</p>
<H2>出力</H2>
<p>各データセットに対して、勝者となりおイモをいただく人の番号（整数）を１行に出力してください。</P>
<H2>Sample Input</H2>
<pre>
41 3
30 9
0 0
</pre>
<H2>Output for the Sample Input</H2>
<pre>
31
21
</pre>
| 41 3
30 9
0 0
| 31
21
| 12,384 |
s923074511 | p00085 | u575065019 | 1345128237 | Python | Python | py | Accepted | 20 | 4260 | 492 | ans = []
while True:
data = raw_input().split()
n = int(data[0])
m = int(data[1])
if n == 0 and m == 0:
break
member = range(1,n+1)
p = 0
c = n
while c != 1:
p += m-1
if p >= c:
while p >= c:
#print 'out:',p,'->',p-c
p = p-c
#print 'c:',c,' p:',p
temp = member.pop(p)
#print temp
c -= 1
ans.append(member[0])
for i in ans:
print i | p00085 |
<H1>ヨセフのおイモ</H1>
<center>
<img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_13_1">
</center>
<br/>
<p>昔、ヨセフのおイモというゲームがありました。<var>n</var> 人が参加しているとしましょう。参加者は中心を向いて円陣を組み、1 から順番に番号が振られます。アツアツのおイモがひとつ、参加者 <var>n</var> (左の図内側の大きい数字の 30 )に渡されます。おイモを渡された参加者は右隣の参加者にそのおイモを渡します。 <var>m</var> 回目に渡された人は右隣の人に渡して円陣から抜けます(左の図では <var>m</var> = 9 の場合を表しています) 。 回渡す毎に一人ずつぬけ、最後に残った人が勝者となり、おイモをいただきます。
</p>
<p>
<var>n</var> ,<var>m</var> が決まってから、実際におイモを渡し始める前にどこにいたら勝てるかわかるといいですよね。上の図は 30 人の参加者で 9 人ごとに抜けるというルールでこのゲームをした場合を書き表しています。内側の大きい数字が参加者に振られた番号、外側の小さい数字が抜ける順番です。それによると、9,18,27,6,16,26 という順番で円陣から抜け出し、最後には 21 が残ることになります。すなわち 21 が勝者となります(小さい数字が 30 になっています)。
</p>
<p>
ゲーム参加者数 <var>n</var> と円陣から抜け出す参加者の間隔 <var>m</var> を入力し、勝者の番号を出力するプログラムを作成してください。ただし、<var>m</var>, <var>n</var> < 1000 とします。
</p>
<H2>入力</H2>
<p>複数のデータセットが与えられます。各データセットは以下の形式で与えられます。</p>
<pre>
<var>n</var> <var>m</var>
</pre>
<p>
ゲーム参加者数 <var>n</var> （整数）と円陣から抜け出す参加者の間隔 <var>m</var> （整数）が空白区切りで１行に与えられます。
</p>
<p>入力は２つの 0 で終わります。データセットの数は 50 を超えません。</p>
<H2>出力</H2>
<p>各データセットに対して、勝者となりおイモをいただく人の番号（整数）を１行に出力してください。</P>
<H2>Sample Input</H2>
<pre>
41 3
30 9
0 0
</pre>
<H2>Output for the Sample Input</H2>
<pre>
31
21
</pre>
| 41 3
30 9
0 0
| 31
21
| 12,385 |
s866212470 | p00085 | u647766105 | 1357095236 | Python | Python | py | Accepted | 10 | 4876 | 163 | def f(n,k):
return 0 if n==1 else (f(n-1,k)+k)%n
while True:
n,k=map(int,raw_input().strip().split())
if (n,k)==(0,0):
break
print f(n,k)+1 | p00085 |
<H1>ヨセフのおイモ</H1>
<center>
<img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_13_1">
</center>
<br/>
<p>昔、ヨセフのおイモというゲームがありました。<var>n</var> 人が参加しているとしましょう。参加者は中心を向いて円陣を組み、1 から順番に番号が振られます。アツアツのおイモがひとつ、参加者 <var>n</var> (左の図内側の大きい数字の 30 )に渡されます。おイモを渡された参加者は右隣の参加者にそのおイモを渡します。 <var>m</var> 回目に渡された人は右隣の人に渡して円陣から抜けます(左の図では <var>m</var> = 9 の場合を表しています) 。 回渡す毎に一人ずつぬけ、最後に残った人が勝者となり、おイモをいただきます。
</p>
<p>
<var>n</var> ,<var>m</var> が決まってから、実際におイモを渡し始める前にどこにいたら勝てるかわかるといいですよね。上の図は 30 人の参加者で 9 人ごとに抜けるというルールでこのゲームをした場合を書き表しています。内側の大きい数字が参加者に振られた番号、外側の小さい数字が抜ける順番です。それによると、9,18,27,6,16,26 という順番で円陣から抜け出し、最後には 21 が残ることになります。すなわち 21 が勝者となります(小さい数字が 30 になっています)。
</p>
<p>
ゲーム参加者数 <var>n</var> と円陣から抜け出す参加者の間隔 <var>m</var> を入力し、勝者の番号を出力するプログラムを作成してください。ただし、<var>m</var>, <var>n</var> < 1000 とします。
</p>
<H2>入力</H2>
<p>複数のデータセットが与えられます。各データセットは以下の形式で与えられます。</p>
<pre>
<var>n</var> <var>m</var>
</pre>
<p>
ゲーム参加者数 <var>n</var> （整数）と円陣から抜け出す参加者の間隔 <var>m</var> （整数）が空白区切りで１行に与えられます。
</p>
<p>入力は２つの 0 で終わります。データセットの数は 50 を超えません。</p>
<H2>出力</H2>
<p>各データセットに対して、勝者となりおイモをいただく人の番号（整数）を１行に出力してください。</P>
<H2>Sample Input</H2>
<pre>
41 3
30 9
0 0
</pre>
<H2>Output for the Sample Input</H2>
<pre>
31
21
</pre>
| 41 3
30 9
0 0
| 31
21
| 12,386 |
s498037887 | p00085 | u813384600 | 1383974014 | Python | Python | py | Accepted | 20 | 4220 | 202 | while True:
n, m = map(int, raw_input().split())
if (n,m) == (0,0):
break
r = 1
for i in range(2, n + 1):
r = (r + m) % i
if r == 0:
r = i
print r | p00085 |
<H1>ヨセフのおイモ</H1>
<center>
<img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_13_1">
</center>
<br/>
<p>昔、ヨセフのおイモというゲームがありました。<var>n</var> 人が参加しているとしましょう。参加者は中心を向いて円陣を組み、1 から順番に番号が振られます。アツアツのおイモがひとつ、参加者 <var>n</var> (左の図内側の大きい数字の 30 )に渡されます。おイモを渡された参加者は右隣の参加者にそのおイモを渡します。 <var>m</var> 回目に渡された人は右隣の人に渡して円陣から抜けます(左の図では <var>m</var> = 9 の場合を表しています) 。 回渡す毎に一人ずつぬけ、最後に残った人が勝者となり、おイモをいただきます。
</p>
<p>
<var>n</var> ,<var>m</var> が決まってから、実際におイモを渡し始める前にどこにいたら勝てるかわかるといいですよね。上の図は 30 人の参加者で 9 人ごとに抜けるというルールでこのゲームをした場合を書き表しています。内側の大きい数字が参加者に振られた番号、外側の小さい数字が抜ける順番です。それによると、9,18,27,6,16,26 という順番で円陣から抜け出し、最後には 21 が残ることになります。すなわち 21 が勝者となります(小さい数字が 30 になっています)。
</p>
<p>
ゲーム参加者数 <var>n</var> と円陣から抜け出す参加者の間隔 <var>m</var> を入力し、勝者の番号を出力するプログラムを作成してください。ただし、<var>m</var>, <var>n</var> < 1000 とします。
</p>
<H2>入力</H2>
<p>複数のデータセットが与えられます。各データセットは以下の形式で与えられます。</p>
<pre>
<var>n</var> <var>m</var>
</pre>
<p>
ゲーム参加者数 <var>n</var> （整数）と円陣から抜け出す参加者の間隔 <var>m</var> （整数）が空白区切りで１行に与えられます。
</p>
<p>入力は２つの 0 で終わります。データセットの数は 50 を超えません。</p>
<H2>出力</H2>
<p>各データセットに対して、勝者となりおイモをいただく人の番号（整数）を１行に出力してください。</P>
<H2>Sample Input</H2>
<pre>
41 3
30 9
0 0
</pre>
<H2>Output for the Sample Input</H2>
<pre>
31
21
</pre>
| 41 3
30 9
0 0
| 31
21
| 12,387 |
s679952750 | p00085 | u633068244 | 1393851433 | Python | Python | py | Accepted | 20 | 4256 | 265 | while True:
n, m = map(int, raw_input().split())
if n == 0 and m == 0:
break
p = [ i+1 for i in range(n) ]
np = n; a = 0
while np > 1:
a = (a+m-1)%len(p)
p.pop(a)
np -= 1
print p[0] | p00085 |
<H1>ヨセフのおイモ</H1>
<center>
<img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_13_1">
</center>
<br/>
<p>昔、ヨセフのおイモというゲームがありました。<var>n</var> 人が参加しているとしましょう。参加者は中心を向いて円陣を組み、1 から順番に番号が振られます。アツアツのおイモがひとつ、参加者 <var>n</var> (左の図内側の大きい数字の 30 )に渡されます。おイモを渡された参加者は右隣の参加者にそのおイモを渡します。 <var>m</var> 回目に渡された人は右隣の人に渡して円陣から抜けます(左の図では <var>m</var> = 9 の場合を表しています) 。 回渡す毎に一人ずつぬけ、最後に残った人が勝者となり、おイモをいただきます。
</p>
<p>
<var>n</var> ,<var>m</var> が決まってから、実際におイモを渡し始める前にどこにいたら勝てるかわかるといいですよね。上の図は 30 人の参加者で 9 人ごとに抜けるというルールでこのゲームをした場合を書き表しています。内側の大きい数字が参加者に振られた番号、外側の小さい数字が抜ける順番です。それによると、9,18,27,6,16,26 という順番で円陣から抜け出し、最後には 21 が残ることになります。すなわち 21 が勝者となります(小さい数字が 30 になっています)。
</p>
<p>
ゲーム参加者数 <var>n</var> と円陣から抜け出す参加者の間隔 <var>m</var> を入力し、勝者の番号を出力するプログラムを作成してください。ただし、<var>m</var>, <var>n</var> < 1000 とします。
</p>
<H2>入力</H2>
<p>複数のデータセットが与えられます。各データセットは以下の形式で与えられます。</p>
<pre>
<var>n</var> <var>m</var>
</pre>
<p>
ゲーム参加者数 <var>n</var> （整数）と円陣から抜け出す参加者の間隔 <var>m</var> （整数）が空白区切りで１行に与えられます。
</p>
<p>入力は２つの 0 で終わります。データセットの数は 50 を超えません。</p>
<H2>出力</H2>
<p>各データセットに対して、勝者となりおイモをいただく人の番号（整数）を１行に出力してください。</P>
<H2>Sample Input</H2>
<pre>
41 3
30 9
0 0
</pre>
<H2>Output for the Sample Input</H2>
<pre>
31
21
</pre>
| 41 3
30 9
0 0
| 31
21
| 12,388 |
s530546588 | p00085 | u633068244 | 1393852626 | Python | Python | py | Accepted | 10 | 4252 | 265 | while True:
n, m = map(int, raw_input().split())
if n == 0 and m == 0:
break
p = [ i+1 for i in range(n) ]
np = n; a = 0
while np > 1:
a = (a+m-1)%len(p)
p.pop(a)
np -= 1
print p[0] | p00085 |
<H1>ヨセフのおイモ</H1>
<center>
<img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_13_1">
</center>
<br/>
<p>昔、ヨセフのおイモというゲームがありました。<var>n</var> 人が参加しているとしましょう。参加者は中心を向いて円陣を組み、1 から順番に番号が振られます。アツアツのおイモがひとつ、参加者 <var>n</var> (左の図内側の大きい数字の 30 )に渡されます。おイモを渡された参加者は右隣の参加者にそのおイモを渡します。 <var>m</var> 回目に渡された人は右隣の人に渡して円陣から抜けます(左の図では <var>m</var> = 9 の場合を表しています) 。 回渡す毎に一人ずつぬけ、最後に残った人が勝者となり、おイモをいただきます。
</p>
<p>
<var>n</var> ,<var>m</var> が決まってから、実際におイモを渡し始める前にどこにいたら勝てるかわかるといいですよね。上の図は 30 人の参加者で 9 人ごとに抜けるというルールでこのゲームをした場合を書き表しています。内側の大きい数字が参加者に振られた番号、外側の小さい数字が抜ける順番です。それによると、9,18,27,6,16,26 という順番で円陣から抜け出し、最後には 21 が残ることになります。すなわち 21 が勝者となります(小さい数字が 30 になっています)。
</p>
<p>
ゲーム参加者数 <var>n</var> と円陣から抜け出す参加者の間隔 <var>m</var> を入力し、勝者の番号を出力するプログラムを作成してください。ただし、<var>m</var>, <var>n</var> < 1000 とします。
</p>
<H2>入力</H2>
<p>複数のデータセットが与えられます。各データセットは以下の形式で与えられます。</p>
<pre>
<var>n</var> <var>m</var>
</pre>
<p>
ゲーム参加者数 <var>n</var> （整数）と円陣から抜け出す参加者の間隔 <var>m</var> （整数）が空白区切りで１行に与えられます。
</p>
<p>入力は２つの 0 で終わります。データセットの数は 50 を超えません。</p>
<H2>出力</H2>
<p>各データセットに対して、勝者となりおイモをいただく人の番号（整数）を１行に出力してください。</P>
<H2>Sample Input</H2>
<pre>
41 3
30 9
0 0
</pre>
<H2>Output for the Sample Input</H2>
<pre>
31
21
</pre>
| 41 3
30 9
0 0
| 31
21
| 12,389 |
s348408968 | p00085 | u260980560 | 1397836879 | Python | Python | py | Accepted | 20 | 4232 | 246 | while True:
n, m = map(int, raw_input().split())
if n==0 and m==0:
break
p = range(1,n+1); idx = n-1;
while len(p)>1:
idx = (idx + m)%len(p)
p.pop(idx)
idx = (idx + len(p) - 1)%len(p)
print p[0] | p00085 |
<H1>ヨセフのおイモ</H1>
<center>
<img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_13_1">
</center>
<br/>
<p>昔、ヨセフのおイモというゲームがありました。<var>n</var> 人が参加しているとしましょう。参加者は中心を向いて円陣を組み、1 から順番に番号が振られます。アツアツのおイモがひとつ、参加者 <var>n</var> (左の図内側の大きい数字の 30 )に渡されます。おイモを渡された参加者は右隣の参加者にそのおイモを渡します。 <var>m</var> 回目に渡された人は右隣の人に渡して円陣から抜けます(左の図では <var>m</var> = 9 の場合を表しています) 。 回渡す毎に一人ずつぬけ、最後に残った人が勝者となり、おイモをいただきます。
</p>
<p>
<var>n</var> ,<var>m</var> が決まってから、実際におイモを渡し始める前にどこにいたら勝てるかわかるといいですよね。上の図は 30 人の参加者で 9 人ごとに抜けるというルールでこのゲームをした場合を書き表しています。内側の大きい数字が参加者に振られた番号、外側の小さい数字が抜ける順番です。それによると、9,18,27,6,16,26 という順番で円陣から抜け出し、最後には 21 が残ることになります。すなわち 21 が勝者となります(小さい数字が 30 になっています)。
</p>
<p>
ゲーム参加者数 <var>n</var> と円陣から抜け出す参加者の間隔 <var>m</var> を入力し、勝者の番号を出力するプログラムを作成してください。ただし、<var>m</var>, <var>n</var> < 1000 とします。
</p>
<H2>入力</H2>
<p>複数のデータセットが与えられます。各データセットは以下の形式で与えられます。</p>
<pre>
<var>n</var> <var>m</var>
</pre>
<p>
ゲーム参加者数 <var>n</var> （整数）と円陣から抜け出す参加者の間隔 <var>m</var> （整数）が空白区切りで１行に与えられます。
</p>
<p>入力は２つの 0 で終わります。データセットの数は 50 を超えません。</p>
<H2>出力</H2>
<p>各データセットに対して、勝者となりおイモをいただく人の番号（整数）を１行に出力してください。</P>
<H2>Sample Input</H2>
<pre>
41 3
30 9
0 0
</pre>
<H2>Output for the Sample Input</H2>
<pre>
31
21
</pre>
| 41 3
30 9
0 0
| 31
21
| 12,390 |
s173392937 | p00085 | u912237403 | 1398438402 | Python | Python | py | Accepted | 20 | 4236 | 171 | while 1:
n,m=map(int,raw_input().split())
if n==0&m==0:break
G=range(1,n+1)
while n>1:
if m%n==0:G=G[:n-1]
else:G=G[m%n:]+G[:(m-1)%n]
n-=1
print G[0] | p00085 |
<H1>ヨセフのおイモ</H1>
<center>
<img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_13_1">
</center>
<br/>
<p>昔、ヨセフのおイモというゲームがありました。<var>n</var> 人が参加しているとしましょう。参加者は中心を向いて円陣を組み、1 から順番に番号が振られます。アツアツのおイモがひとつ、参加者 <var>n</var> (左の図内側の大きい数字の 30 )に渡されます。おイモを渡された参加者は右隣の参加者にそのおイモを渡します。 <var>m</var> 回目に渡された人は右隣の人に渡して円陣から抜けます(左の図では <var>m</var> = 9 の場合を表しています) 。 回渡す毎に一人ずつぬけ、最後に残った人が勝者となり、おイモをいただきます。
</p>
<p>
<var>n</var> ,<var>m</var> が決まってから、実際におイモを渡し始める前にどこにいたら勝てるかわかるといいですよね。上の図は 30 人の参加者で 9 人ごとに抜けるというルールでこのゲームをした場合を書き表しています。内側の大きい数字が参加者に振られた番号、外側の小さい数字が抜ける順番です。それによると、9,18,27,6,16,26 という順番で円陣から抜け出し、最後には 21 が残ることになります。すなわち 21 が勝者となります(小さい数字が 30 になっています)。
</p>
<p>
ゲーム参加者数 <var>n</var> と円陣から抜け出す参加者の間隔 <var>m</var> を入力し、勝者の番号を出力するプログラムを作成してください。ただし、<var>m</var>, <var>n</var> < 1000 とします。
</p>
<H2>入力</H2>
<p>複数のデータセットが与えられます。各データセットは以下の形式で与えられます。</p>
<pre>
<var>n</var> <var>m</var>
</pre>
<p>
ゲーム参加者数 <var>n</var> （整数）と円陣から抜け出す参加者の間隔 <var>m</var> （整数）が空白区切りで１行に与えられます。
</p>
<p>入力は２つの 0 で終わります。データセットの数は 50 を超えません。</p>
<H2>出力</H2>
<p>各データセットに対して、勝者となりおイモをいただく人の番号（整数）を１行に出力してください。</P>
<H2>Sample Input</H2>
<pre>
41 3
30 9
0 0
</pre>
<H2>Output for the Sample Input</H2>
<pre>
31
21
</pre>
| 41 3
30 9
0 0
| 31
21
| 12,391 |
s769038511 | p00085 | u912237403 | 1398438822 | Python | Python | py | Accepted | 20 | 4236 | 183 | import sys
for s in sys.stdin:
n,m=map(int,s.split())
if n==0&m==0:break
G=range(1,n+1)
while n>1:
if m%n==0:G=G[:n-1]
else:G=G[m%n:]+G[:(m-1)%n]
n-=1
print G[0] | p00085 |
<H1>ヨセフのおイモ</H1>
<center>
<img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_13_1">
</center>
<br/>
<p>昔、ヨセフのおイモというゲームがありました。<var>n</var> 人が参加しているとしましょう。参加者は中心を向いて円陣を組み、1 から順番に番号が振られます。アツアツのおイモがひとつ、参加者 <var>n</var> (左の図内側の大きい数字の 30 )に渡されます。おイモを渡された参加者は右隣の参加者にそのおイモを渡します。 <var>m</var> 回目に渡された人は右隣の人に渡して円陣から抜けます(左の図では <var>m</var> = 9 の場合を表しています) 。 回渡す毎に一人ずつぬけ、最後に残った人が勝者となり、おイモをいただきます。
</p>
<p>
<var>n</var> ,<var>m</var> が決まってから、実際におイモを渡し始める前にどこにいたら勝てるかわかるといいですよね。上の図は 30 人の参加者で 9 人ごとに抜けるというルールでこのゲームをした場合を書き表しています。内側の大きい数字が参加者に振られた番号、外側の小さい数字が抜ける順番です。それによると、9,18,27,6,16,26 という順番で円陣から抜け出し、最後には 21 が残ることになります。すなわち 21 が勝者となります(小さい数字が 30 になっています)。
</p>
<p>
ゲーム参加者数 <var>n</var> と円陣から抜け出す参加者の間隔 <var>m</var> を入力し、勝者の番号を出力するプログラムを作成してください。ただし、<var>m</var>, <var>n</var> < 1000 とします。
</p>
<H2>入力</H2>
<p>複数のデータセットが与えられます。各データセットは以下の形式で与えられます。</p>
<pre>
<var>n</var> <var>m</var>
</pre>
<p>
ゲーム参加者数 <var>n</var> （整数）と円陣から抜け出す参加者の間隔 <var>m</var> （整数）が空白区切りで１行に与えられます。
</p>
<p>入力は２つの 0 で終わります。データセットの数は 50 を超えません。</p>
<H2>出力</H2>
<p>各データセットに対して、勝者となりおイモをいただく人の番号（整数）を１行に出力してください。</P>
<H2>Sample Input</H2>
<pre>
41 3
30 9
0 0
</pre>
<H2>Output for the Sample Input</H2>
<pre>
31
21
</pre>
| 41 3
30 9
0 0
| 31
21
| 12,392 |
s335119232 | p00085 | u912237403 | 1398438901 | Python | Python | py | Accepted | 20 | 4236 | 193 | while 1:
n,m = map(int,raw_input().split())
if n==0 & m==0: break
G = range(1, n+1)
while n>1:
if m%n == 0: G = G[:n-1]
else: G = G[m % n:] + G[:(m-1) % n]
n-=1
print G[0] | p00085 |
<H1>ヨセフのおイモ</H1>
<center>
<img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_13_1">
</center>
<br/>
<p>昔、ヨセフのおイモというゲームがありました。<var>n</var> 人が参加しているとしましょう。参加者は中心を向いて円陣を組み、1 から順番に番号が振られます。アツアツのおイモがひとつ、参加者 <var>n</var> (左の図内側の大きい数字の 30 )に渡されます。おイモを渡された参加者は右隣の参加者にそのおイモを渡します。 <var>m</var> 回目に渡された人は右隣の人に渡して円陣から抜けます(左の図では <var>m</var> = 9 の場合を表しています) 。 回渡す毎に一人ずつぬけ、最後に残った人が勝者となり、おイモをいただきます。
</p>
<p>
<var>n</var> ,<var>m</var> が決まってから、実際におイモを渡し始める前にどこにいたら勝てるかわかるといいですよね。上の図は 30 人の参加者で 9 人ごとに抜けるというルールでこのゲームをした場合を書き表しています。内側の大きい数字が参加者に振られた番号、外側の小さい数字が抜ける順番です。それによると、9,18,27,6,16,26 という順番で円陣から抜け出し、最後には 21 が残ることになります。すなわち 21 が勝者となります(小さい数字が 30 になっています)。
</p>
<p>
ゲーム参加者数 <var>n</var> と円陣から抜け出す参加者の間隔 <var>m</var> を入力し、勝者の番号を出力するプログラムを作成してください。ただし、<var>m</var>, <var>n</var> < 1000 とします。
</p>
<H2>入力</H2>
<p>複数のデータセットが与えられます。各データセットは以下の形式で与えられます。</p>
<pre>
<var>n</var> <var>m</var>
</pre>
<p>
ゲーム参加者数 <var>n</var> （整数）と円陣から抜け出す参加者の間隔 <var>m</var> （整数）が空白区切りで１行に与えられます。
</p>
<p>入力は２つの 0 で終わります。データセットの数は 50 を超えません。</p>
<H2>出力</H2>
<p>各データセットに対して、勝者となりおイモをいただく人の番号（整数）を１行に出力してください。</P>
<H2>Sample Input</H2>
<pre>
41 3
30 9
0 0
</pre>
<H2>Output for the Sample Input</H2>
<pre>
31
21
</pre>
| 41 3
30 9
0 0
| 31
21
| 12,393 |
s895513350 | p00085 | u912237403 | 1398459855 | Python | Python | py | Accepted | 10 | 4228 | 149 | while 1:
n,m=map(int,raw_input().split())
if n==0==m:break
G=range(1,n+1)
p=0
while n>1:
p=(p+m-1)%n
G.pop(p)
n-=1
print G[0] | p00085 |
<H1>ヨセフのおイモ</H1>
<center>
<img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_13_1">
</center>
<br/>
<p>昔、ヨセフのおイモというゲームがありました。<var>n</var> 人が参加しているとしましょう。参加者は中心を向いて円陣を組み、1 から順番に番号が振られます。アツアツのおイモがひとつ、参加者 <var>n</var> (左の図内側の大きい数字の 30 )に渡されます。おイモを渡された参加者は右隣の参加者にそのおイモを渡します。 <var>m</var> 回目に渡された人は右隣の人に渡して円陣から抜けます(左の図では <var>m</var> = 9 の場合を表しています) 。 回渡す毎に一人ずつぬけ、最後に残った人が勝者となり、おイモをいただきます。
</p>
<p>
<var>n</var> ,<var>m</var> が決まってから、実際におイモを渡し始める前にどこにいたら勝てるかわかるといいですよね。上の図は 30 人の参加者で 9 人ごとに抜けるというルールでこのゲームをした場合を書き表しています。内側の大きい数字が参加者に振られた番号、外側の小さい数字が抜ける順番です。それによると、9,18,27,6,16,26 という順番で円陣から抜け出し、最後には 21 が残ることになります。すなわち 21 が勝者となります(小さい数字が 30 になっています)。
</p>
<p>
ゲーム参加者数 <var>n</var> と円陣から抜け出す参加者の間隔 <var>m</var> を入力し、勝者の番号を出力するプログラムを作成してください。ただし、<var>m</var>, <var>n</var> < 1000 とします。
</p>
<H2>入力</H2>
<p>複数のデータセットが与えられます。各データセットは以下の形式で与えられます。</p>
<pre>
<var>n</var> <var>m</var>
</pre>
<p>
ゲーム参加者数 <var>n</var> （整数）と円陣から抜け出す参加者の間隔 <var>m</var> （整数）が空白区切りで１行に与えられます。
</p>
<p>入力は２つの 0 で終わります。データセットの数は 50 を超えません。</p>
<H2>出力</H2>
<p>各データセットに対して、勝者となりおイモをいただく人の番号（整数）を１行に出力してください。</P>
<H2>Sample Input</H2>
<pre>
41 3
30 9
0 0
</pre>
<H2>Output for the Sample Input</H2>
<pre>
31
21
</pre>
| 41 3
30 9
0 0
| 31
21
| 12,394 |
s039268121 | p00085 | u912237403 | 1398512986 | Python | Python | py | Accepted | 10 | 4208 | 114 | while 1:
n,m=map(int,raw_input().split())
if n==0==m:break
p=0
for i in range(2,n+1):p=(p+m)%i
print p+1 | p00085 |
<H1>ヨセフのおイモ</H1>
<center>
<img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_13_1">
</center>
<br/>
<p>昔、ヨセフのおイモというゲームがありました。<var>n</var> 人が参加しているとしましょう。参加者は中心を向いて円陣を組み、1 から順番に番号が振られます。アツアツのおイモがひとつ、参加者 <var>n</var> (左の図内側の大きい数字の 30 )に渡されます。おイモを渡された参加者は右隣の参加者にそのおイモを渡します。 <var>m</var> 回目に渡された人は右隣の人に渡して円陣から抜けます(左の図では <var>m</var> = 9 の場合を表しています) 。 回渡す毎に一人ずつぬけ、最後に残った人が勝者となり、おイモをいただきます。
</p>
<p>
<var>n</var> ,<var>m</var> が決まってから、実際におイモを渡し始める前にどこにいたら勝てるかわかるといいですよね。上の図は 30 人の参加者で 9 人ごとに抜けるというルールでこのゲームをした場合を書き表しています。内側の大きい数字が参加者に振られた番号、外側の小さい数字が抜ける順番です。それによると、9,18,27,6,16,26 という順番で円陣から抜け出し、最後には 21 が残ることになります。すなわち 21 が勝者となります(小さい数字が 30 になっています)。
</p>
<p>
ゲーム参加者数 <var>n</var> と円陣から抜け出す参加者の間隔 <var>m</var> を入力し、勝者の番号を出力するプログラムを作成してください。ただし、<var>m</var>, <var>n</var> < 1000 とします。
</p>
<H2>入力</H2>
<p>複数のデータセットが与えられます。各データセットは以下の形式で与えられます。</p>
<pre>
<var>n</var> <var>m</var>
</pre>
<p>
ゲーム参加者数 <var>n</var> （整数）と円陣から抜け出す参加者の間隔 <var>m</var> （整数）が空白区切りで１行に与えられます。
</p>
<p>入力は２つの 0 で終わります。データセットの数は 50 を超えません。</p>
<H2>出力</H2>
<p>各データセットに対して、勝者となりおイモをいただく人の番号（整数）を１行に出力してください。</P>
<H2>Sample Input</H2>
<pre>
41 3
30 9
0 0
</pre>
<H2>Output for the Sample Input</H2>
<pre>
31
21
</pre>
| 41 3
30 9
0 0
| 31
21
| 12,395 |
s564639357 | p00085 | u240091169 | 1591880427 | Python | Python3 | py | Accepted | 30 | 5600 | 400 | while True :
n, m = map(int, input().split())
if n == 0 and m == 0 :
break
guest = []
for i in range(n) :
guest.append(i+1)
potate = n - 1
while True :
potate += m
while potate >= n :
potate -= n
n -= 1
del guest[potate]
potate -= 1
if n == 1 :
break
print(*guest)
| p00085 |
<H1>ヨセフのおイモ</H1>
<center>
<img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_13_1">
</center>
<br/>
<p>昔、ヨセフのおイモというゲームがありました。<var>n</var> 人が参加しているとしましょう。参加者は中心を向いて円陣を組み、1 から順番に番号が振られます。アツアツのおイモがひとつ、参加者 <var>n</var> (左の図内側の大きい数字の 30 )に渡されます。おイモを渡された参加者は右隣の参加者にそのおイモを渡します。 <var>m</var> 回目に渡された人は右隣の人に渡して円陣から抜けます(左の図では <var>m</var> = 9 の場合を表しています) 。 回渡す毎に一人ずつぬけ、最後に残った人が勝者となり、おイモをいただきます。
</p>
<p>
<var>n</var> ,<var>m</var> が決まってから、実際におイモを渡し始める前にどこにいたら勝てるかわかるといいですよね。上の図は 30 人の参加者で 9 人ごとに抜けるというルールでこのゲームをした場合を書き表しています。内側の大きい数字が参加者に振られた番号、外側の小さい数字が抜ける順番です。それによると、9,18,27,6,16,26 という順番で円陣から抜け出し、最後には 21 が残ることになります。すなわち 21 が勝者となります(小さい数字が 30 になっています)。
</p>
<p>
ゲーム参加者数 <var>n</var> と円陣から抜け出す参加者の間隔 <var>m</var> を入力し、勝者の番号を出力するプログラムを作成してください。ただし、<var>m</var>, <var>n</var> < 1000 とします。
</p>
<H2>入力</H2>
<p>複数のデータセットが与えられます。各データセットは以下の形式で与えられます。</p>
<pre>
<var>n</var> <var>m</var>
</pre>
<p>
ゲーム参加者数 <var>n</var> （整数）と円陣から抜け出す参加者の間隔 <var>m</var> （整数）が空白区切りで１行に与えられます。
</p>
<p>入力は２つの 0 で終わります。データセットの数は 50 を超えません。</p>
<H2>出力</H2>
<p>各データセットに対して、勝者となりおイモをいただく人の番号（整数）を１行に出力してください。</P>
<H2>Sample Input</H2>
<pre>
41 3
30 9
0 0
</pre>
<H2>Output for the Sample Input</H2>
<pre>
31
21
</pre>
| 41 3
30 9
0 0
| 31
21
| 12,396 |
s481098522 | p00085 | u824708460 | 1567743762 | Python | Python3 | py | Accepted | 30 | 5608 | 238 | while 1:
n, m = map(int, input().split())
if n == 0:
break
s = [i for i in range(1, n + 1)]
ind = n - 1
while len(s) > 1:
ind = (ind + m) % len(s)
s.pop(ind)
ind -= 1
print(s[0])
| p00085 |
<H1>ヨセフのおイモ</H1>
<center>
<img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_13_1">
</center>
<br/>
<p>昔、ヨセフのおイモというゲームがありました。<var>n</var> 人が参加しているとしましょう。参加者は中心を向いて円陣を組み、1 から順番に番号が振られます。アツアツのおイモがひとつ、参加者 <var>n</var> (左の図内側の大きい数字の 30 )に渡されます。おイモを渡された参加者は右隣の参加者にそのおイモを渡します。 <var>m</var> 回目に渡された人は右隣の人に渡して円陣から抜けます(左の図では <var>m</var> = 9 の場合を表しています) 。 回渡す毎に一人ずつぬけ、最後に残った人が勝者となり、おイモをいただきます。
</p>
<p>
<var>n</var> ,<var>m</var> が決まってから、実際におイモを渡し始める前にどこにいたら勝てるかわかるといいですよね。上の図は 30 人の参加者で 9 人ごとに抜けるというルールでこのゲームをした場合を書き表しています。内側の大きい数字が参加者に振られた番号、外側の小さい数字が抜ける順番です。それによると、9,18,27,6,16,26 という順番で円陣から抜け出し、最後には 21 が残ることになります。すなわち 21 が勝者となります(小さい数字が 30 になっています)。
</p>
<p>
ゲーム参加者数 <var>n</var> と円陣から抜け出す参加者の間隔 <var>m</var> を入力し、勝者の番号を出力するプログラムを作成してください。ただし、<var>m</var>, <var>n</var> < 1000 とします。
</p>
<H2>入力</H2>
<p>複数のデータセットが与えられます。各データセットは以下の形式で与えられます。</p>
<pre>
<var>n</var> <var>m</var>
</pre>
<p>
ゲーム参加者数 <var>n</var> （整数）と円陣から抜け出す参加者の間隔 <var>m</var> （整数）が空白区切りで１行に与えられます。
</p>
<p>入力は２つの 0 で終わります。データセットの数は 50 を超えません。</p>
<H2>出力</H2>
<p>各データセットに対して、勝者となりおイモをいただく人の番号（整数）を１行に出力してください。</P>
<H2>Sample Input</H2>
<pre>
41 3
30 9
0 0
</pre>
<H2>Output for the Sample Input</H2>
<pre>
31
21
</pre>
| 41 3
30 9
0 0
| 31
21
| 12,397 |
s887478625 | p00085 | u264450287 | 1563166731 | Python | Python3 | py | Accepted | 40 | 5596 | 303 | while True:
n,m=map(int,input().split())
if n==0 and m==0:
break
P=[]
for i in range(1,n+1):
P.append(i)
a=m-1
for i in range(n-1):
#print(P.pop(a))
P.pop(a)
a+=m
while True:
if a<=int(len(P)):
break
a=a-int(len(P))
a=a-1
print(P[0])
| p00085 |
<H1>ヨセフのおイモ</H1>
<center>
<img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_13_1">
</center>
<br/>
<p>昔、ヨセフのおイモというゲームがありました。<var>n</var> 人が参加しているとしましょう。参加者は中心を向いて円陣を組み、1 から順番に番号が振られます。アツアツのおイモがひとつ、参加者 <var>n</var> (左の図内側の大きい数字の 30 )に渡されます。おイモを渡された参加者は右隣の参加者にそのおイモを渡します。 <var>m</var> 回目に渡された人は右隣の人に渡して円陣から抜けます(左の図では <var>m</var> = 9 の場合を表しています) 。 回渡す毎に一人ずつぬけ、最後に残った人が勝者となり、おイモをいただきます。
</p>
<p>
<var>n</var> ,<var>m</var> が決まってから、実際におイモを渡し始める前にどこにいたら勝てるかわかるといいですよね。上の図は 30 人の参加者で 9 人ごとに抜けるというルールでこのゲームをした場合を書き表しています。内側の大きい数字が参加者に振られた番号、外側の小さい数字が抜ける順番です。それによると、9,18,27,6,16,26 という順番で円陣から抜け出し、最後には 21 が残ることになります。すなわち 21 が勝者となります(小さい数字が 30 になっています)。
</p>
<p>
ゲーム参加者数 <var>n</var> と円陣から抜け出す参加者の間隔 <var>m</var> を入力し、勝者の番号を出力するプログラムを作成してください。ただし、<var>m</var>, <var>n</var> < 1000 とします。
</p>
<H2>入力</H2>
<p>複数のデータセットが与えられます。各データセットは以下の形式で与えられます。</p>
<pre>
<var>n</var> <var>m</var>
</pre>
<p>
ゲーム参加者数 <var>n</var> （整数）と円陣から抜け出す参加者の間隔 <var>m</var> （整数）が空白区切りで１行に与えられます。
</p>
<p>入力は２つの 0 で終わります。データセットの数は 50 を超えません。</p>
<H2>出力</H2>
<p>各データセットに対して、勝者となりおイモをいただく人の番号（整数）を１行に出力してください。</P>
<H2>Sample Input</H2>
<pre>
41 3
30 9
0 0
</pre>
<H2>Output for the Sample Input</H2>
<pre>
31
21
</pre>
| 41 3
30 9
0 0
| 31
21
| 12,398 |
s406752291 | p00085 | u548252256 | 1562496753 | Python | Python3 | py | Accepted | 30 | 5604 | 269 | if __name__ == '__main__':
while True:
n,m = map(int,input().split())
if n == 0 and m == 0:
break
A = [i for i in range(1,n+1)]
ind = 0
for _ in range(n-1):
x = len(A)
ind += m - 1
if ind >= x:
ind = ind % x
A.pop(ind)
print(A[0])
| p00085 |
<H1>ヨセフのおイモ</H1>
<center>
<img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_13_1">
</center>
<br/>
<p>昔、ヨセフのおイモというゲームがありました。<var>n</var> 人が参加しているとしましょう。参加者は中心を向いて円陣を組み、1 から順番に番号が振られます。アツアツのおイモがひとつ、参加者 <var>n</var> (左の図内側の大きい数字の 30 )に渡されます。おイモを渡された参加者は右隣の参加者にそのおイモを渡します。 <var>m</var> 回目に渡された人は右隣の人に渡して円陣から抜けます(左の図では <var>m</var> = 9 の場合を表しています) 。 回渡す毎に一人ずつぬけ、最後に残った人が勝者となり、おイモをいただきます。
</p>
<p>
<var>n</var> ,<var>m</var> が決まってから、実際におイモを渡し始める前にどこにいたら勝てるかわかるといいですよね。上の図は 30 人の参加者で 9 人ごとに抜けるというルールでこのゲームをした場合を書き表しています。内側の大きい数字が参加者に振られた番号、外側の小さい数字が抜ける順番です。それによると、9,18,27,6,16,26 という順番で円陣から抜け出し、最後には 21 が残ることになります。すなわち 21 が勝者となります(小さい数字が 30 になっています)。
</p>
<p>
ゲーム参加者数 <var>n</var> と円陣から抜け出す参加者の間隔 <var>m</var> を入力し、勝者の番号を出力するプログラムを作成してください。ただし、<var>m</var>, <var>n</var> < 1000 とします。
</p>
<H2>入力</H2>
<p>複数のデータセットが与えられます。各データセットは以下の形式で与えられます。</p>
<pre>
<var>n</var> <var>m</var>
</pre>
<p>
ゲーム参加者数 <var>n</var> （整数）と円陣から抜け出す参加者の間隔 <var>m</var> （整数）が空白区切りで１行に与えられます。
</p>
<p>入力は２つの 0 で終わります。データセットの数は 50 を超えません。</p>
<H2>出力</H2>
<p>各データセットに対して、勝者となりおイモをいただく人の番号（整数）を１行に出力してください。</P>
<H2>Sample Input</H2>
<pre>
41 3
30 9
0 0
</pre>
<H2>Output for the Sample Input</H2>
<pre>
31
21
</pre>
| 41 3
30 9
0 0
| 31
21
| 12,399 |
s558715719 | p00085 | u990228206 | 1554283714 | Python | Python3 | py | Accepted | 30 | 5600 | 192 | while 1:
n,m=map(int,input().split())
if n==m==0:break
l=[i+1 for i in range(n)]
pos=0
for i in range(n-1):
pos=(pos+m-1)%len(l)
del l[pos]
print(l[0])
| p00085 |
<H1>ヨセフのおイモ</H1>
<center>
<img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_13_1">
</center>
<br/>
<p>昔、ヨセフのおイモというゲームがありました。<var>n</var> 人が参加しているとしましょう。参加者は中心を向いて円陣を組み、1 から順番に番号が振られます。アツアツのおイモがひとつ、参加者 <var>n</var> (左の図内側の大きい数字の 30 )に渡されます。おイモを渡された参加者は右隣の参加者にそのおイモを渡します。 <var>m</var> 回目に渡された人は右隣の人に渡して円陣から抜けます(左の図では <var>m</var> = 9 の場合を表しています) 。 回渡す毎に一人ずつぬけ、最後に残った人が勝者となり、おイモをいただきます。
</p>
<p>
<var>n</var> ,<var>m</var> が決まってから、実際におイモを渡し始める前にどこにいたら勝てるかわかるといいですよね。上の図は 30 人の参加者で 9 人ごとに抜けるというルールでこのゲームをした場合を書き表しています。内側の大きい数字が参加者に振られた番号、外側の小さい数字が抜ける順番です。それによると、9,18,27,6,16,26 という順番で円陣から抜け出し、最後には 21 が残ることになります。すなわち 21 が勝者となります(小さい数字が 30 になっています)。
</p>
<p>
ゲーム参加者数 <var>n</var> と円陣から抜け出す参加者の間隔 <var>m</var> を入力し、勝者の番号を出力するプログラムを作成してください。ただし、<var>m</var>, <var>n</var> < 1000 とします。
</p>
<H2>入力</H2>
<p>複数のデータセットが与えられます。各データセットは以下の形式で与えられます。</p>
<pre>
<var>n</var> <var>m</var>
</pre>
<p>
ゲーム参加者数 <var>n</var> （整数）と円陣から抜け出す参加者の間隔 <var>m</var> （整数）が空白区切りで１行に与えられます。
</p>
<p>入力は２つの 0 で終わります。データセットの数は 50 を超えません。</p>
<H2>出力</H2>
<p>各データセットに対して、勝者となりおイモをいただく人の番号（整数）を１行に出力してください。</P>
<H2>Sample Input</H2>
<pre>
41 3
30 9
0 0
</pre>
<H2>Output for the Sample Input</H2>
<pre>
31
21
</pre>
| 41 3
30 9
0 0
| 31
21
| 12,400 |
s458071583 | p00085 | u717526540 | 1542861143 | Python | Python3 | py | Accepted | 20 | 5612 | 207 | while 1:
n, m = map(int, input().split())
if n == 0 and m == 0:
break
number = list(range(1, n+1))
cnt = 0
for i in range(2, n+1):
cnt = (cnt + m) % i
print(cnt+1)
| p00085 |
<H1>ヨセフのおイモ</H1>
<center>
<img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_13_1">
</center>
<br/>
<p>昔、ヨセフのおイモというゲームがありました。<var>n</var> 人が参加しているとしましょう。参加者は中心を向いて円陣を組み、1 から順番に番号が振られます。アツアツのおイモがひとつ、参加者 <var>n</var> (左の図内側の大きい数字の 30 )に渡されます。おイモを渡された参加者は右隣の参加者にそのおイモを渡します。 <var>m</var> 回目に渡された人は右隣の人に渡して円陣から抜けます(左の図では <var>m</var> = 9 の場合を表しています) 。 回渡す毎に一人ずつぬけ、最後に残った人が勝者となり、おイモをいただきます。
</p>
<p>
<var>n</var> ,<var>m</var> が決まってから、実際におイモを渡し始める前にどこにいたら勝てるかわかるといいですよね。上の図は 30 人の参加者で 9 人ごとに抜けるというルールでこのゲームをした場合を書き表しています。内側の大きい数字が参加者に振られた番号、外側の小さい数字が抜ける順番です。それによると、9,18,27,6,16,26 という順番で円陣から抜け出し、最後には 21 が残ることになります。すなわち 21 が勝者となります(小さい数字が 30 になっています)。
</p>
<p>
ゲーム参加者数 <var>n</var> と円陣から抜け出す参加者の間隔 <var>m</var> を入力し、勝者の番号を出力するプログラムを作成してください。ただし、<var>m</var>, <var>n</var> < 1000 とします。
</p>
<H2>入力</H2>
<p>複数のデータセットが与えられます。各データセットは以下の形式で与えられます。</p>
<pre>
<var>n</var> <var>m</var>
</pre>
<p>
ゲーム参加者数 <var>n</var> （整数）と円陣から抜け出す参加者の間隔 <var>m</var> （整数）が空白区切りで１行に与えられます。
</p>
<p>入力は２つの 0 で終わります。データセットの数は 50 を超えません。</p>
<H2>出力</H2>
<p>各データセットに対して、勝者となりおイモをいただく人の番号（整数）を１行に出力してください。</P>
<H2>Sample Input</H2>
<pre>
41 3
30 9
0 0
</pre>
<H2>Output for the Sample Input</H2>
<pre>
31
21
</pre>
| 41 3
30 9
0 0
| 31
21
| 12,401 |
s616044472 | p00085 | u197615397 | 1532247073 | Python | Python3 | py | Accepted | 30 | 5608 | 467 | import sys
for n, m in (map(int, l.split()) for l in sys.stdin):
if not n:
break
if m == 1:
print(n)
continue
a = list(range(1, n+1))
rem = 0
while len(a) > m:
d, _rem = divmod(len(a)+rem, m)
for i in list(range(-rem+m-1, len(a), m))[::-1]:
del a[i]
rem = _rem
while len(a) > 1:
i = (m % len(a) - rem - 1) % len(a)
del a[i]
rem = len(a)-i
print(a[0])
| p00085 |
<H1>ヨセフのおイモ</H1>
<center>
<img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_13_1">
</center>
<br/>
<p>昔、ヨセフのおイモというゲームがありました。<var>n</var> 人が参加しているとしましょう。参加者は中心を向いて円陣を組み、1 から順番に番号が振られます。アツアツのおイモがひとつ、参加者 <var>n</var> (左の図内側の大きい数字の 30 )に渡されます。おイモを渡された参加者は右隣の参加者にそのおイモを渡します。 <var>m</var> 回目に渡された人は右隣の人に渡して円陣から抜けます(左の図では <var>m</var> = 9 の場合を表しています) 。 回渡す毎に一人ずつぬけ、最後に残った人が勝者となり、おイモをいただきます。
</p>
<p>
<var>n</var> ,<var>m</var> が決まってから、実際におイモを渡し始める前にどこにいたら勝てるかわかるといいですよね。上の図は 30 人の参加者で 9 人ごとに抜けるというルールでこのゲームをした場合を書き表しています。内側の大きい数字が参加者に振られた番号、外側の小さい数字が抜ける順番です。それによると、9,18,27,6,16,26 という順番で円陣から抜け出し、最後には 21 が残ることになります。すなわち 21 が勝者となります(小さい数字が 30 になっています)。
</p>
<p>
ゲーム参加者数 <var>n</var> と円陣から抜け出す参加者の間隔 <var>m</var> を入力し、勝者の番号を出力するプログラムを作成してください。ただし、<var>m</var>, <var>n</var> < 1000 とします。
</p>
<H2>入力</H2>
<p>複数のデータセットが与えられます。各データセットは以下の形式で与えられます。</p>
<pre>
<var>n</var> <var>m</var>
</pre>
<p>
ゲーム参加者数 <var>n</var> （整数）と円陣から抜け出す参加者の間隔 <var>m</var> （整数）が空白区切りで１行に与えられます。
</p>
<p>入力は２つの 0 で終わります。データセットの数は 50 を超えません。</p>
<H2>出力</H2>
<p>各データセットに対して、勝者となりおイモをいただく人の番号（整数）を１行に出力してください。</P>
<H2>Sample Input</H2>
<pre>
41 3
30 9
0 0
</pre>
<H2>Output for the Sample Input</H2>
<pre>
31
21
</pre>
| 41 3
30 9
0 0
| 31
21
| 12,402 |
s093936436 | p00086 | u506132575 | 1417749747 | Python | Python | py | Accepted | 10 | 4216 | 349 | import sys
def solve(lis):
for e in lis[1:3]:
if not e%2:
return "NG"
for e in lis[3:10]:
if e%2:
return "NG"
return "OK"
li = [0]*102
for s in sys.stdin:
a,b = map(int,s.split())
if a == b == 0:
print solve(li)
li = [0]*102
continue
li[a] += 1
li[b] += 1 | p00086 |
<H1>パトロール</H1>
<p>
文久２（1862）年、会津の殿様が京都守護職を命ぜられました。京都守護職とは治安の悪化した幕末の京都を守る大切な役目です。幕府や他の藩と分担して市中をパトロールしなければなりません。ところがいざ分担ルートを決める段になって、家臣の中でも有名な頑固者の古老から以下のような注文がつきました。
</p>
<center>
<img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_14_1">
</center>
<br/>
<p>
大変なことになりました。殿様といえどもこの家臣の言い分を無視するわけにはいきません。分担ルートの選択によっては、「武士の面目が立たない」ということになってしまいます。
</p>
<p>
ということで、スタート地点、ゴール地点、交差点の情報を入力として、上の三つの条件を満たすかどうかを判定するプログラムを作って、殿様に献上してください。
</p>
<p>
スタート地点を 1、ゴール地点を2、その他の交差点を 3 以上の整数で表します。1つの道路は、その道が結ぶ1組の交差点番号で表します。なお、交差点の数は 100 以下とし、全ての交差点からスタート地点およびゴール地点への経路がそれぞれ一つ以上あるものとします。
</p>
<H2>入力</H2>
<p>複数のデータセットが与えられます。各データセットは以下の形式で与えられます。</p>
<pre>
<var>a<sub>1</sub></var> <var>b<sub>1</sub></var>
<var>a<sub>2</sub></var> <var>b<sub>2</sub></var>
：
：
<var>0</var> <var>0</var>
</pre>
<p>
各行の２つの整数は、交差点 <var>a<sub>i</sub></var> と交差点 <var>b<sub>i</sub></var> とをつなぐ道路が存在することを示します。
<var>a<sub>i</sub></var> と <var>b<sub>i</sub></var> がともに 0 のとき交差点情報の入力の終わりを示します。
</p>
<p>
データセットの数は50を超えません。
</p>
<H2>出力</H2>
<p>
各データセットに対して、武士の面目が立つ場合（三つの条件を満たす場合）OK、それ以外の場合（三つの条件を満たさない場合）NG と１行に出力してください。
</p>
<H2>Sample Input</H2>
<pre>
1 3
3 4
3 5
3 6
4 6
4 7
4 7
5 6
6 7
5 8
5 8
6 8
6 9
7 9
8 9
9 2
0 0
1 3
3 4
3 4
4 2
0 0
</pre>
<H2>Output for the Sample Input</H2>
<pre>
OK
NG
</pre>
<img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_14_2">
<img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_14_3">
<img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_14_4">
| 1 3
3 4
3 5
3 6
4 6
4 7
4 7
5 6
6 7
5 8
5 8
6 8
6 9
7 9
8 9
9 2
0 0
1 3
3 4
3 4
4 2
0 0
| OK
NG
| 12,403 |
s912476250 | p00086 | u567380442 | 1424679871 | Python | Python3 | py | Accepted | 40 | 6720 | 496 | import sys
f = sys.stdin
def is_odd(num):
return num % 2 == 1
intersection = [0 for _ in range(101)]
for line in f:
a, b = map(int, line.split())
if a == b == 0:
if is_odd(intersection[1]) and is_odd(intersection[2]) and 0 == sum(1 for i in range(3, len(intersection)) if is_odd(intersection[i])):
print('OK')
else:
print('NG')
intersection = [0 for _ in range(101)]
else:
intersection[a] += 1
intersection[b] += 1 | p00086 |
<H1>パトロール</H1>
<p>
文久２（1862）年、会津の殿様が京都守護職を命ぜられました。京都守護職とは治安の悪化した幕末の京都を守る大切な役目です。幕府や他の藩と分担して市中をパトロールしなければなりません。ところがいざ分担ルートを決める段になって、家臣の中でも有名な頑固者の古老から以下のような注文がつきました。
</p>
<center>
<img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_14_1">
</center>
<br/>
<p>
大変なことになりました。殿様といえどもこの家臣の言い分を無視するわけにはいきません。分担ルートの選択によっては、「武士の面目が立たない」ということになってしまいます。
</p>
<p>
ということで、スタート地点、ゴール地点、交差点の情報を入力として、上の三つの条件を満たすかどうかを判定するプログラムを作って、殿様に献上してください。
</p>
<p>
スタート地点を 1、ゴール地点を2、その他の交差点を 3 以上の整数で表します。1つの道路は、その道が結ぶ1組の交差点番号で表します。なお、交差点の数は 100 以下とし、全ての交差点からスタート地点およびゴール地点への経路がそれぞれ一つ以上あるものとします。
</p>
<H2>入力</H2>
<p>複数のデータセットが与えられます。各データセットは以下の形式で与えられます。</p>
<pre>
<var>a<sub>1</sub></var> <var>b<sub>1</sub></var>
<var>a<sub>2</sub></var> <var>b<sub>2</sub></var>
：
：
<var>0</var> <var>0</var>
</pre>
<p>
各行の２つの整数は、交差点 <var>a<sub>i</sub></var> と交差点 <var>b<sub>i</sub></var> とをつなぐ道路が存在することを示します。
<var>a<sub>i</sub></var> と <var>b<sub>i</sub></var> がともに 0 のとき交差点情報の入力の終わりを示します。
</p>
<p>
データセットの数は50を超えません。
</p>
<H2>出力</H2>
<p>
各データセットに対して、武士の面目が立つ場合（三つの条件を満たす場合）OK、それ以外の場合（三つの条件を満たさない場合）NG と１行に出力してください。
</p>
<H2>Sample Input</H2>
<pre>
1 3
3 4
3 5
3 6
4 6
4 7
4 7
5 6
6 7
5 8
5 8
6 8
6 9
7 9
8 9
9 2
0 0
1 3
3 4
3 4
4 2
0 0
</pre>
<H2>Output for the Sample Input</H2>
<pre>
OK
NG
</pre>
<img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_14_2">
<img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_14_3">
<img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_14_4">
| 1 3
3 4
3 5
3 6
4 6
4 7
4 7
5 6
6 7
5 8
5 8
6 8
6 9
7 9
8 9
9 2
0 0
1 3
3 4
3 4
4 2
0 0
| OK
NG
| 12,404 |
s728825525 | p00086 | u140201022 | 1451499970 | Python | Python | py | Accepted | 20 | 6296 | 342 | while 1:
try:
p=[0]*100
while 1:
a,b=map(int,raw_input().split())
if a==0:
break
p[a-1]+=1
p[b-1]+=1
if p[0]%2==p[1]%2==1 and sum(filter(lambda x:x%2==1,p[2:]))==0:
print 'OK'
else:
print 'NG'
except:
break | p00086 |
<H1>パトロール</H1>
<p>
文久２（1862）年、会津の殿様が京都守護職を命ぜられました。京都守護職とは治安の悪化した幕末の京都を守る大切な役目です。幕府や他の藩と分担して市中をパトロールしなければなりません。ところがいざ分担ルートを決める段になって、家臣の中でも有名な頑固者の古老から以下のような注文がつきました。
</p>
<center>
<img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_14_1">
</center>
<br/>
<p>
大変なことになりました。殿様といえどもこの家臣の言い分を無視するわけにはいきません。分担ルートの選択によっては、「武士の面目が立たない」ということになってしまいます。
</p>
<p>
ということで、スタート地点、ゴール地点、交差点の情報を入力として、上の三つの条件を満たすかどうかを判定するプログラムを作って、殿様に献上してください。
</p>
<p>
スタート地点を 1、ゴール地点を2、その他の交差点を 3 以上の整数で表します。1つの道路は、その道が結ぶ1組の交差点番号で表します。なお、交差点の数は 100 以下とし、全ての交差点からスタート地点およびゴール地点への経路がそれぞれ一つ以上あるものとします。
</p>
<H2>入力</H2>
<p>複数のデータセットが与えられます。各データセットは以下の形式で与えられます。</p>
<pre>
<var>a<sub>1</sub></var> <var>b<sub>1</sub></var>
<var>a<sub>2</sub></var> <var>b<sub>2</sub></var>
：
：
<var>0</var> <var>0</var>
</pre>
<p>
各行の２つの整数は、交差点 <var>a<sub>i</sub></var> と交差点 <var>b<sub>i</sub></var> とをつなぐ道路が存在することを示します。
<var>a<sub>i</sub></var> と <var>b<sub>i</sub></var> がともに 0 のとき交差点情報の入力の終わりを示します。
</p>
<p>
データセットの数は50を超えません。
</p>
<H2>出力</H2>
<p>
各データセットに対して、武士の面目が立つ場合（三つの条件を満たす場合）OK、それ以外の場合（三つの条件を満たさない場合）NG と１行に出力してください。
</p>
<H2>Sample Input</H2>
<pre>
1 3
3 4
3 5
3 6
4 6
4 7
4 7
5 6
6 7
5 8
5 8
6 8
6 9
7 9
8 9
9 2
0 0
1 3
3 4
3 4
4 2
0 0
</pre>
<H2>Output for the Sample Input</H2>
<pre>
OK
NG
</pre>
<img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_14_2">
<img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_14_3">
<img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_14_4">
| 1 3
3 4
3 5
3 6
4 6
4 7
4 7
5 6
6 7
5 8
5 8
6 8
6 9
7 9
8 9
9 2
0 0
1 3
3 4
3 4
4 2
0 0
| OK
NG
| 12,405 |
s682808700 | p00086 | u685815919 | 1473922087 | Python | Python | py | Accepted | 20 | 6316 | 422 | import sys
ipt = []
for line in sys.stdin:
ipt.append(line)
dic = {}
dic[1] = True
dic[2] = True
for i in xrange(len(ipt)):
s = ipt[i]
a,b = map(int, s.split())
if a==b==0:
if len(dic) == 0:
print "OK"
else:
print "NG"
dic = {}
dic[1] = True
dic[2] = True
continue
if a in dic:
del dic[a]
else:
dic[a] = True
if b in dic:
del dic[b]
else:
dic[b] = True | p00086 |
<H1>パトロール</H1>
<p>
文久２（1862）年、会津の殿様が京都守護職を命ぜられました。京都守護職とは治安の悪化した幕末の京都を守る大切な役目です。幕府や他の藩と分担して市中をパトロールしなければなりません。ところがいざ分担ルートを決める段になって、家臣の中でも有名な頑固者の古老から以下のような注文がつきました。
</p>
<center>
<img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_14_1">
</center>
<br/>
<p>
大変なことになりました。殿様といえどもこの家臣の言い分を無視するわけにはいきません。分担ルートの選択によっては、「武士の面目が立たない」ということになってしまいます。
</p>
<p>
ということで、スタート地点、ゴール地点、交差点の情報を入力として、上の三つの条件を満たすかどうかを判定するプログラムを作って、殿様に献上してください。
</p>
<p>
スタート地点を 1、ゴール地点を2、その他の交差点を 3 以上の整数で表します。1つの道路は、その道が結ぶ1組の交差点番号で表します。なお、交差点の数は 100 以下とし、全ての交差点からスタート地点およびゴール地点への経路がそれぞれ一つ以上あるものとします。
</p>
<H2>入力</H2>
<p>複数のデータセットが与えられます。各データセットは以下の形式で与えられます。</p>
<pre>
<var>a<sub>1</sub></var> <var>b<sub>1</sub></var>
<var>a<sub>2</sub></var> <var>b<sub>2</sub></var>
：
：
<var>0</var> <var>0</var>
</pre>
<p>
各行の２つの整数は、交差点 <var>a<sub>i</sub></var> と交差点 <var>b<sub>i</sub></var> とをつなぐ道路が存在することを示します。
<var>a<sub>i</sub></var> と <var>b<sub>i</sub></var> がともに 0 のとき交差点情報の入力の終わりを示します。
</p>
<p>
データセットの数は50を超えません。
</p>
<H2>出力</H2>
<p>
各データセットに対して、武士の面目が立つ場合（三つの条件を満たす場合）OK、それ以外の場合（三つの条件を満たさない場合）NG と１行に出力してください。
</p>
<H2>Sample Input</H2>
<pre>
1 3
3 4
3 5
3 6
4 6
4 7
4 7
5 6
6 7
5 8
5 8
6 8
6 9
7 9
8 9
9 2
0 0
1 3
3 4
3 4
4 2
0 0
</pre>
<H2>Output for the Sample Input</H2>
<pre>
OK
NG
</pre>
<img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_14_2">
<img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_14_3">
<img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_14_4">
| 1 3
3 4
3 5
3 6
4 6
4 7
4 7
5 6
6 7
5 8
5 8
6 8
6 9
7 9
8 9
9 2
0 0
1 3
3 4
3 4
4 2
0 0
| OK
NG
| 12,406 |
s909268411 | p00086 | u078042885 | 1484984977 | Python | Python3 | py | Accepted | 30 | 7520 | 254 | c=[0]*100
while 1:
try:a,b=map(int,input().split())
except:break
c[a-1]+=1;c[b-1]+=1
if a==0:
for i in range(2,100):
if c[i]&1:print('NG');break
else:print('OK' if c[0]&1 and c[1]&1 else 'NG')
c=[0]*100 | p00086 |
<H1>パトロール</H1>
<p>
文久２（1862）年、会津の殿様が京都守護職を命ぜられました。京都守護職とは治安の悪化した幕末の京都を守る大切な役目です。幕府や他の藩と分担して市中をパトロールしなければなりません。ところがいざ分担ルートを決める段になって、家臣の中でも有名な頑固者の古老から以下のような注文がつきました。
</p>
<center>
<img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_14_1">
</center>
<br/>
<p>
大変なことになりました。殿様といえどもこの家臣の言い分を無視するわけにはいきません。分担ルートの選択によっては、「武士の面目が立たない」ということになってしまいます。
</p>
<p>
ということで、スタート地点、ゴール地点、交差点の情報を入力として、上の三つの条件を満たすかどうかを判定するプログラムを作って、殿様に献上してください。
</p>
<p>
スタート地点を 1、ゴール地点を2、その他の交差点を 3 以上の整数で表します。1つの道路は、その道が結ぶ1組の交差点番号で表します。なお、交差点の数は 100 以下とし、全ての交差点からスタート地点およびゴール地点への経路がそれぞれ一つ以上あるものとします。
</p>
<H2>入力</H2>
<p>複数のデータセットが与えられます。各データセットは以下の形式で与えられます。</p>
<pre>
<var>a<sub>1</sub></var> <var>b<sub>1</sub></var>
<var>a<sub>2</sub></var> <var>b<sub>2</sub></var>
：
：
<var>0</var> <var>0</var>
</pre>
<p>
各行の２つの整数は、交差点 <var>a<sub>i</sub></var> と交差点 <var>b<sub>i</sub></var> とをつなぐ道路が存在することを示します。
<var>a<sub>i</sub></var> と <var>b<sub>i</sub></var> がともに 0 のとき交差点情報の入力の終わりを示します。
</p>
<p>
データセットの数は50を超えません。
</p>
<H2>出力</H2>
<p>
各データセットに対して、武士の面目が立つ場合（三つの条件を満たす場合）OK、それ以外の場合（三つの条件を満たさない場合）NG と１行に出力してください。
</p>
<H2>Sample Input</H2>
<pre>
1 3
3 4
3 5
3 6
4 6
4 7
4 7
5 6
6 7
5 8
5 8
6 8
6 9
7 9
8 9
9 2
0 0
1 3
3 4
3 4
4 2
0 0
</pre>
<H2>Output for the Sample Input</H2>
<pre>
OK
NG
</pre>
<img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_14_2">
<img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_14_3">
<img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_14_4">
| 1 3
3 4
3 5
3 6
4 6
4 7
4 7
5 6
6 7
5 8
5 8
6 8
6 9
7 9
8 9
9 2
0 0
1 3
3 4
3 4
4 2
0 0
| OK
NG
| 12,407 |
s687706703 | p00086 | u462831976 | 1493454622 | Python | Python3 | py | Accepted | 30 | 7728 | 683 | # -*- coding: utf-8 -*-
import sys
import os
import math
# adjacent list
M = []
for i in range(105):
M.append([])
def solve(M):
odd_num = 0
even_num = 0
for m in M:
if len(m) % 2 == 0:
even_num += 1
else:
odd_num += 1
# semi-Eulerlian graph
if odd_num == 2 and len(M[0]) % 2 == 1 and len(M[1]) % 2 == 1:
print('OK')
else:
print('NG')
for s in sys.stdin:
a, b = map(int, s.split())
if a == b == 0:
solve(M)
# reset
M = []
for i in range(105):
M.append([])
else:
a -= 1
b -= 1
M[a].append(b)
M[b].append(a) | p00086 |
<H1>パトロール</H1>
<p>
文久２（1862）年、会津の殿様が京都守護職を命ぜられました。京都守護職とは治安の悪化した幕末の京都を守る大切な役目です。幕府や他の藩と分担して市中をパトロールしなければなりません。ところがいざ分担ルートを決める段になって、家臣の中でも有名な頑固者の古老から以下のような注文がつきました。
</p>
<center>
<img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_14_1">
</center>
<br/>
<p>
大変なことになりました。殿様といえどもこの家臣の言い分を無視するわけにはいきません。分担ルートの選択によっては、「武士の面目が立たない」ということになってしまいます。
</p>
<p>
ということで、スタート地点、ゴール地点、交差点の情報を入力として、上の三つの条件を満たすかどうかを判定するプログラムを作って、殿様に献上してください。
</p>
<p>
スタート地点を 1、ゴール地点を2、その他の交差点を 3 以上の整数で表します。1つの道路は、その道が結ぶ1組の交差点番号で表します。なお、交差点の数は 100 以下とし、全ての交差点からスタート地点およびゴール地点への経路がそれぞれ一つ以上あるものとします。
</p>
<H2>入力</H2>
<p>複数のデータセットが与えられます。各データセットは以下の形式で与えられます。</p>
<pre>
<var>a<sub>1</sub></var> <var>b<sub>1</sub></var>
<var>a<sub>2</sub></var> <var>b<sub>2</sub></var>
：
：
<var>0</var> <var>0</var>
</pre>
<p>
各行の２つの整数は、交差点 <var>a<sub>i</sub></var> と交差点 <var>b<sub>i</sub></var> とをつなぐ道路が存在することを示します。
<var>a<sub>i</sub></var> と <var>b<sub>i</sub></var> がともに 0 のとき交差点情報の入力の終わりを示します。
</p>
<p>
データセットの数は50を超えません。
</p>
<H2>出力</H2>
<p>
各データセットに対して、武士の面目が立つ場合（三つの条件を満たす場合）OK、それ以外の場合（三つの条件を満たさない場合）NG と１行に出力してください。
</p>
<H2>Sample Input</H2>
<pre>
1 3
3 4
3 5
3 6
4 6
4 7
4 7
5 6
6 7
5 8
5 8
6 8
6 9
7 9
8 9
9 2
0 0
1 3
3 4
3 4
4 2
0 0
</pre>
<H2>Output for the Sample Input</H2>
<pre>
OK
NG
</pre>
<img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_14_2">
<img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_14_3">
<img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_14_4">
| 1 3
3 4
3 5
3 6
4 6
4 7
4 7
5 6
6 7
5 8
5 8
6 8
6 9
7 9
8 9
9 2
0 0
1 3
3 4
3 4
4 2
0 0
| OK
NG
| 12,408 |
s786033968 | p00086 | u957021183 | 1505198877 | Python | Python3 | py | Accepted | 60 | 7780 | 516 | # Aizu Problem 0086: Patrol
#
import sys, math, os
# read input:
PYDEV = os.environ.get('PYDEV')
if PYDEV=="True":
sys.stdin = open("sample-input2.txt", "rt")
a = [0] * 101
while True:
try:
x, y = [int(_) for _ in input().split()]
except EOFError:
break
if x == y == 0:
c = sum([a[i] % 2 for i in range(3, 101)])
print("OK" if c == 0 and a[1] % 2 == 1 and a[2] % 2 == 1 else "NG")
a = [0] * 101
else:
a[x] += 1
a[y] += 1
| p00086 |
<H1>パトロール</H1>
<p>
文久２（1862）年、会津の殿様が京都守護職を命ぜられました。京都守護職とは治安の悪化した幕末の京都を守る大切な役目です。幕府や他の藩と分担して市中をパトロールしなければなりません。ところがいざ分担ルートを決める段になって、家臣の中でも有名な頑固者の古老から以下のような注文がつきました。
</p>
<center>
<img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_14_1">
</center>
<br/>
<p>
大変なことになりました。殿様といえどもこの家臣の言い分を無視するわけにはいきません。分担ルートの選択によっては、「武士の面目が立たない」ということになってしまいます。
</p>
<p>
ということで、スタート地点、ゴール地点、交差点の情報を入力として、上の三つの条件を満たすかどうかを判定するプログラムを作って、殿様に献上してください。
</p>
<p>
スタート地点を 1、ゴール地点を2、その他の交差点を 3 以上の整数で表します。1つの道路は、その道が結ぶ1組の交差点番号で表します。なお、交差点の数は 100 以下とし、全ての交差点からスタート地点およびゴール地点への経路がそれぞれ一つ以上あるものとします。
</p>
<H2>入力</H2>
<p>複数のデータセットが与えられます。各データセットは以下の形式で与えられます。</p>
<pre>
<var>a<sub>1</sub></var> <var>b<sub>1</sub></var>
<var>a<sub>2</sub></var> <var>b<sub>2</sub></var>
：
：
<var>0</var> <var>0</var>
</pre>
<p>
各行の２つの整数は、交差点 <var>a<sub>i</sub></var> と交差点 <var>b<sub>i</sub></var> とをつなぐ道路が存在することを示します。
<var>a<sub>i</sub></var> と <var>b<sub>i</sub></var> がともに 0 のとき交差点情報の入力の終わりを示します。
</p>
<p>
データセットの数は50を超えません。
</p>
<H2>出力</H2>
<p>
各データセットに対して、武士の面目が立つ場合（三つの条件を満たす場合）OK、それ以外の場合（三つの条件を満たさない場合）NG と１行に出力してください。
</p>
<H2>Sample Input</H2>
<pre>
1 3
3 4
3 5
3 6
4 6
4 7
4 7
5 6
6 7
5 8
5 8
6 8
6 9
7 9
8 9
9 2
0 0
1 3
3 4
3 4
4 2
0 0
</pre>
<H2>Output for the Sample Input</H2>
<pre>
OK
NG
</pre>
<img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_14_2">
<img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_14_3">
<img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_14_4">
| 1 3
3 4
3 5
3 6
4 6
4 7
4 7
5 6
6 7
5 8
5 8
6 8
6 9
7 9
8 9
9 2
0 0
1 3
3 4
3 4
4 2
0 0
| OK
NG
| 12,409 |
s883541268 | p00086 | u811733736 | 1505386758 | Python | Python3 | py | Accepted | 30 | 7664 | 831 | # -*- coding: utf-8 -*-
"""
http://judge.u-aizu.ac.jp/onlinejudge/description.jsp?id=0086
"""
import sys
from sys import stdin
input = stdin.readline
def main(args):
for line in sys.stdin:
routes = []
a, b = map(int, line.split())
if a == 0 and b == 0:
break
while a != 0 or b!= 0:
routes.append([a, b])
a, b = map(int, input().split())
degrees = [0] * 101
for a, b in routes:
degrees[a] += 1
degrees[b] += 1
odds = [x for x in degrees if x%2==1]
# evens = [x for x in degrees if x%2==0]
# print(degrees)
if len(odds) == 2 and degrees[1]%2==1 and degrees[2]%2==1:
print('OK')
else:
print('NG')
if __name__ == '__main__':
main(sys.argv[1:])
| p00086 |
<H1>パトロール</H1>
<p>
文久２（1862）年、会津の殿様が京都守護職を命ぜられました。京都守護職とは治安の悪化した幕末の京都を守る大切な役目です。幕府や他の藩と分担して市中をパトロールしなければなりません。ところがいざ分担ルートを決める段になって、家臣の中でも有名な頑固者の古老から以下のような注文がつきました。
</p>
<center>
<img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_14_1">
</center>
<br/>
<p>
大変なことになりました。殿様といえどもこの家臣の言い分を無視するわけにはいきません。分担ルートの選択によっては、「武士の面目が立たない」ということになってしまいます。
</p>
<p>
ということで、スタート地点、ゴール地点、交差点の情報を入力として、上の三つの条件を満たすかどうかを判定するプログラムを作って、殿様に献上してください。
</p>
<p>
スタート地点を 1、ゴール地点を2、その他の交差点を 3 以上の整数で表します。1つの道路は、その道が結ぶ1組の交差点番号で表します。なお、交差点の数は 100 以下とし、全ての交差点からスタート地点およびゴール地点への経路がそれぞれ一つ以上あるものとします。
</p>
<H2>入力</H2>
<p>複数のデータセットが与えられます。各データセットは以下の形式で与えられます。</p>
<pre>
<var>a<sub>1</sub></var> <var>b<sub>1</sub></var>
<var>a<sub>2</sub></var> <var>b<sub>2</sub></var>
：
：
<var>0</var> <var>0</var>
</pre>
<p>
各行の２つの整数は、交差点 <var>a<sub>i</sub></var> と交差点 <var>b<sub>i</sub></var> とをつなぐ道路が存在することを示します。
<var>a<sub>i</sub></var> と <var>b<sub>i</sub></var> がともに 0 のとき交差点情報の入力の終わりを示します。
</p>
<p>
データセットの数は50を超えません。
</p>
<H2>出力</H2>
<p>
各データセットに対して、武士の面目が立つ場合（三つの条件を満たす場合）OK、それ以外の場合（三つの条件を満たさない場合）NG と１行に出力してください。
</p>
<H2>Sample Input</H2>
<pre>
1 3
3 4
3 5
3 6
4 6
4 7
4 7
5 6
6 7
5 8
5 8
6 8
6 9
7 9
8 9
9 2
0 0
1 3
3 4
3 4
4 2
0 0
</pre>
<H2>Output for the Sample Input</H2>
<pre>
OK
NG
</pre>
<img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_14_2">
<img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_14_3">
<img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_14_4">
| 1 3
3 4
3 5
3 6
4 6
4 7
4 7
5 6
6 7
5 8
5 8
6 8
6 9
7 9
8 9
9 2
0 0
1 3
3 4
3 4
4 2
0 0
| OK
NG
| 12,410 |
s352817858 | p00086 | u117140447 | 1519579794 | Python | Python3 | py | Accepted | 30 | 6044 | 1,287 | import sys
from collections import defaultdict
data_list = []
for line in sys.stdin:
data_list.append(list(map(int, line.split())))
def is_half_euler_graph(node_list):
for node in node_list:
isBool = True
for dic_key, dic_value in node.items():
if dic_key != 1 and dic_key != 2:
if dic_value % 2 != 0:
isBool = False
break
else :
if dic_value % 2 == 0:
isBool = False
break
if isBool :
print("OK")
else :
print("NG")
if __name__ == '__main__' :
node_data_lists = []
tmp_list = []
count_lists = []
tmp_dic = {}
tmp_dic = defaultdict(int)
for i in range(0, len(data_list)):
if data_list[i][0] == 0 and data_list[i][1] == 0:
node_data_lists.append(tmp_list[:])
tmp_list.clear()
else :
tmp_list.append(data_list[i])
for node_data_list in node_data_lists :
tmp_dic.clear()
for i in range(0, len(node_data_list)):
tmp_dic[node_data_list[i][0]] += 1
tmp_dic[node_data_list[i][1]] += 1
count_lists.append(tmp_dic.copy())
is_half_euler_graph(count_lists)
| p00086 |
<H1>パトロール</H1>
<p>
文久２（1862）年、会津の殿様が京都守護職を命ぜられました。京都守護職とは治安の悪化した幕末の京都を守る大切な役目です。幕府や他の藩と分担して市中をパトロールしなければなりません。ところがいざ分担ルートを決める段になって、家臣の中でも有名な頑固者の古老から以下のような注文がつきました。
</p>
<center>
<img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_14_1">
</center>
<br/>
<p>
大変なことになりました。殿様といえどもこの家臣の言い分を無視するわけにはいきません。分担ルートの選択によっては、「武士の面目が立たない」ということになってしまいます。
</p>
<p>
ということで、スタート地点、ゴール地点、交差点の情報を入力として、上の三つの条件を満たすかどうかを判定するプログラムを作って、殿様に献上してください。
</p>
<p>
スタート地点を 1、ゴール地点を2、その他の交差点を 3 以上の整数で表します。1つの道路は、その道が結ぶ1組の交差点番号で表します。なお、交差点の数は 100 以下とし、全ての交差点からスタート地点およびゴール地点への経路がそれぞれ一つ以上あるものとします。
</p>
<H2>入力</H2>
<p>複数のデータセットが与えられます。各データセットは以下の形式で与えられます。</p>
<pre>
<var>a<sub>1</sub></var> <var>b<sub>1</sub></var>
<var>a<sub>2</sub></var> <var>b<sub>2</sub></var>
：
：
<var>0</var> <var>0</var>
</pre>
<p>
各行の２つの整数は、交差点 <var>a<sub>i</sub></var> と交差点 <var>b<sub>i</sub></var> とをつなぐ道路が存在することを示します。
<var>a<sub>i</sub></var> と <var>b<sub>i</sub></var> がともに 0 のとき交差点情報の入力の終わりを示します。
</p>
<p>
データセットの数は50を超えません。
</p>
<H2>出力</H2>
<p>
各データセットに対して、武士の面目が立つ場合（三つの条件を満たす場合）OK、それ以外の場合（三つの条件を満たさない場合）NG と１行に出力してください。
</p>
<H2>Sample Input</H2>
<pre>
1 3
3 4
3 5
3 6
4 6
4 7
4 7
5 6
6 7
5 8
5 8
6 8
6 9
7 9
8 9
9 2
0 0
1 3
3 4
3 4
4 2
0 0
</pre>
<H2>Output for the Sample Input</H2>
<pre>
OK
NG
</pre>
<img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_14_2">
<img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_14_3">
<img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_14_4">
| 1 3
3 4
3 5
3 6
4 6
4 7
4 7
5 6
6 7
5 8
5 8
6 8
6 9
7 9
8 9
9 2
0 0
1 3
3 4
3 4
4 2
0 0
| OK
NG
| 12,411 |
s647107268 | p00086 | u117140447 | 1519579882 | Python | Python3 | py | Accepted | 30 | 6044 | 1,306 | import sys
def is_half_euler_graph(node_list):
for node in node_list:
isBool = True
for dic_key, dic_value in node.items():
if dic_key != 1 and dic_key != 2:
if dic_value % 2 != 0:
isBool = False
break
else :
if dic_value % 2 == 0:
isBool = False
break
if isBool :
print("OK")
else :
print("NG")
if __name__ == '__main__' :
from collections import defaultdict
data_list = []
for line in sys.stdin:
data_list.append(list(map(int, line.split())))
node_data_lists = []
tmp_list = []
count_lists = []
tmp_dic = {}
tmp_dic = defaultdict(int)
for i in range(0, len(data_list)):
if data_list[i][0] == 0 and data_list[i][1] == 0:
node_data_lists.append(tmp_list[:])
tmp_list.clear()
else :
tmp_list.append(data_list[i])
for node_data_list in node_data_lists :
tmp_dic.clear()
for i in range(0, len(node_data_list)):
tmp_dic[node_data_list[i][0]] += 1
tmp_dic[node_data_list[i][1]] += 1
count_lists.append(tmp_dic.copy())
is_half_euler_graph(count_lists)
| p00086 |
<H1>パトロール</H1>
<p>
文久２（1862）年、会津の殿様が京都守護職を命ぜられました。京都守護職とは治安の悪化した幕末の京都を守る大切な役目です。幕府や他の藩と分担して市中をパトロールしなければなりません。ところがいざ分担ルートを決める段になって、家臣の中でも有名な頑固者の古老から以下のような注文がつきました。
</p>
<center>
<img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_14_1">
</center>
<br/>
<p>
大変なことになりました。殿様といえどもこの家臣の言い分を無視するわけにはいきません。分担ルートの選択によっては、「武士の面目が立たない」ということになってしまいます。
</p>
<p>
ということで、スタート地点、ゴール地点、交差点の情報を入力として、上の三つの条件を満たすかどうかを判定するプログラムを作って、殿様に献上してください。
</p>
<p>
スタート地点を 1、ゴール地点を2、その他の交差点を 3 以上の整数で表します。1つの道路は、その道が結ぶ1組の交差点番号で表します。なお、交差点の数は 100 以下とし、全ての交差点からスタート地点およびゴール地点への経路がそれぞれ一つ以上あるものとします。
</p>
<H2>入力</H2>
<p>複数のデータセットが与えられます。各データセットは以下の形式で与えられます。</p>
<pre>
<var>a<sub>1</sub></var> <var>b<sub>1</sub></var>
<var>a<sub>2</sub></var> <var>b<sub>2</sub></var>
：
：
<var>0</var> <var>0</var>
</pre>
<p>
各行の２つの整数は、交差点 <var>a<sub>i</sub></var> と交差点 <var>b<sub>i</sub></var> とをつなぐ道路が存在することを示します。
<var>a<sub>i</sub></var> と <var>b<sub>i</sub></var> がともに 0 のとき交差点情報の入力の終わりを示します。
</p>
<p>
データセットの数は50を超えません。
</p>
<H2>出力</H2>
<p>
各データセットに対して、武士の面目が立つ場合（三つの条件を満たす場合）OK、それ以外の場合（三つの条件を満たさない場合）NG と１行に出力してください。
</p>
<H2>Sample Input</H2>
<pre>
1 3
3 4
3 5
3 6
4 6
4 7
4 7
5 6
6 7
5 8
5 8
6 8
6 9
7 9
8 9
9 2
0 0
1 3
3 4
3 4
4 2
0 0
</pre>
<H2>Output for the Sample Input</H2>
<pre>
OK
NG
</pre>
<img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_14_2">
<img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_14_3">
<img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_14_4">
| 1 3
3 4
3 5
3 6
4 6
4 7
4 7
5 6
6 7
5 8
5 8
6 8
6 9
7 9
8 9
9 2
0 0
1 3
3 4
3 4
4 2
0 0
| OK
NG
| 12,412 |
s459544275 | p00086 | u869924057 | 1519857108 | Python | Python3 | py | Accepted | 40 | 5720 | 809 | import fileinput
if __name__ == '__main__':
# 標準入力からグラフ読み込み
G = []
g = []
for line in fileinput.input():
tokens = list(map(int, line.strip().split()))
a, b = tokens[0], tokens[1]
if a == 0 and b == 0:
G.append(g)
g = []
else:
g.append((tokens[0], tokens[1]))
# グラフオブジェクトから経路判定
for g in G:
result = True
counts = [0 for i in range(100)]
for a, b in g:
counts[a-1] += 1
counts[b-1] += 1
for c in counts[0:2]:
if c % 2 == 0:
result = False
for c in counts[2:100]:
if c % 2 == 1:
result = False
print("OK" if result else "NG")
| p00086 |
<H1>パトロール</H1>
<p>
文久２（1862）年、会津の殿様が京都守護職を命ぜられました。京都守護職とは治安の悪化した幕末の京都を守る大切な役目です。幕府や他の藩と分担して市中をパトロールしなければなりません。ところがいざ分担ルートを決める段になって、家臣の中でも有名な頑固者の古老から以下のような注文がつきました。
</p>
<center>
<img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_14_1">
</center>
<br/>
<p>
大変なことになりました。殿様といえどもこの家臣の言い分を無視するわけにはいきません。分担ルートの選択によっては、「武士の面目が立たない」ということになってしまいます。
</p>
<p>
ということで、スタート地点、ゴール地点、交差点の情報を入力として、上の三つの条件を満たすかどうかを判定するプログラムを作って、殿様に献上してください。
</p>
<p>
スタート地点を 1、ゴール地点を2、その他の交差点を 3 以上の整数で表します。1つの道路は、その道が結ぶ1組の交差点番号で表します。なお、交差点の数は 100 以下とし、全ての交差点からスタート地点およびゴール地点への経路がそれぞれ一つ以上あるものとします。
</p>
<H2>入力</H2>
<p>複数のデータセットが与えられます。各データセットは以下の形式で与えられます。</p>
<pre>
<var>a<sub>1</sub></var> <var>b<sub>1</sub></var>
<var>a<sub>2</sub></var> <var>b<sub>2</sub></var>
：
：
<var>0</var> <var>0</var>
</pre>
<p>
各行の２つの整数は、交差点 <var>a<sub>i</sub></var> と交差点 <var>b<sub>i</sub></var> とをつなぐ道路が存在することを示します。
<var>a<sub>i</sub></var> と <var>b<sub>i</sub></var> がともに 0 のとき交差点情報の入力の終わりを示します。
</p>
<p>
データセットの数は50を超えません。
</p>
<H2>出力</H2>
<p>
各データセットに対して、武士の面目が立つ場合（三つの条件を満たす場合）OK、それ以外の場合（三つの条件を満たさない場合）NG と１行に出力してください。
</p>
<H2>Sample Input</H2>
<pre>
1 3
3 4
3 5
3 6
4 6
4 7
4 7
5 6
6 7
5 8
5 8
6 8
6 9
7 9
8 9
9 2
0 0
1 3
3 4
3 4
4 2
0 0
</pre>
<H2>Output for the Sample Input</H2>
<pre>
OK
NG
</pre>
<img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_14_2">
<img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_14_3">
<img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_14_4">
| 1 3
3 4
3 5
3 6
4 6
4 7
4 7
5 6
6 7
5 8
5 8
6 8
6 9
7 9
8 9
9 2
0 0
1 3
3 4
3 4
4 2
0 0
| OK
NG
| 12,413 |
s037689804 | p00086 | u024715419 | 1521104469 | Python | Python3 | py | Accepted | 30 | 5612 | 628 | while True:
try:
d = {}
while True:
a, b = map(int, input().split())
if a == 0:
break
if a in d:
d[a] += 1
else:
d[a] = 1
if b in d:
d[b] += 1
else:
d[b] = 1
if d[1]%2 == 1 and d[2]%2 == 1:
del d[1], d[2]
for node in d:
if d[node]%2 == 1:
print("NG")
break
else:
print("OK")
else:
print("NG")
except:
break
| p00086 |
<H1>パトロール</H1>
<p>
文久２（1862）年、会津の殿様が京都守護職を命ぜられました。京都守護職とは治安の悪化した幕末の京都を守る大切な役目です。幕府や他の藩と分担して市中をパトロールしなければなりません。ところがいざ分担ルートを決める段になって、家臣の中でも有名な頑固者の古老から以下のような注文がつきました。
</p>
<center>
<img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_14_1">
</center>
<br/>
<p>
大変なことになりました。殿様といえどもこの家臣の言い分を無視するわけにはいきません。分担ルートの選択によっては、「武士の面目が立たない」ということになってしまいます。
</p>
<p>
ということで、スタート地点、ゴール地点、交差点の情報を入力として、上の三つの条件を満たすかどうかを判定するプログラムを作って、殿様に献上してください。
</p>
<p>
スタート地点を 1、ゴール地点を2、その他の交差点を 3 以上の整数で表します。1つの道路は、その道が結ぶ1組の交差点番号で表します。なお、交差点の数は 100 以下とし、全ての交差点からスタート地点およびゴール地点への経路がそれぞれ一つ以上あるものとします。
</p>
<H2>入力</H2>
<p>複数のデータセットが与えられます。各データセットは以下の形式で与えられます。</p>
<pre>
<var>a<sub>1</sub></var> <var>b<sub>1</sub></var>
<var>a<sub>2</sub></var> <var>b<sub>2</sub></var>
：
：
<var>0</var> <var>0</var>
</pre>
<p>
各行の２つの整数は、交差点 <var>a<sub>i</sub></var> と交差点 <var>b<sub>i</sub></var> とをつなぐ道路が存在することを示します。
<var>a<sub>i</sub></var> と <var>b<sub>i</sub></var> がともに 0 のとき交差点情報の入力の終わりを示します。
</p>
<p>
データセットの数は50を超えません。
</p>
<H2>出力</H2>
<p>
各データセットに対して、武士の面目が立つ場合（三つの条件を満たす場合）OK、それ以外の場合（三つの条件を満たさない場合）NG と１行に出力してください。
</p>
<H2>Sample Input</H2>
<pre>
1 3
3 4
3 5
3 6
4 6
4 7
4 7
5 6
6 7
5 8
5 8
6 8
6 9
7 9
8 9
9 2
0 0
1 3
3 4
3 4
4 2
0 0
</pre>
<H2>Output for the Sample Input</H2>
<pre>
OK
NG
</pre>
<img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_14_2">
<img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_14_3">
<img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_14_4">
| 1 3
3 4
3 5
3 6
4 6
4 7
4 7
5 6
6 7
5 8
5 8
6 8
6 9
7 9
8 9
9 2
0 0
1 3
3 4
3 4
4 2
0 0
| OK
NG
| 12,414 |
s946914622 | p00086 | u306037418 | 1524741362 | Python | Python3 | py | Accepted | 30 | 5612 | 443 | import sys
ab = []
for line in sys.stdin:
temp = list(map(int, line.split()))
if temp == [0, 0]:
v = [0 for i in range(max(ab)+1)]
for i in ab:
v[i] += 1
odd = 0
for i in v:
if i % 2 == 1:
odd += 1
if odd == 2 and ((v[1] % 2) == (v[2] % 2) == 1):
print('OK')
else:
print('NG')
ab = []
else:
ab += temp
| p00086 |
<H1>パトロール</H1>
<p>
文久２（1862）年、会津の殿様が京都守護職を命ぜられました。京都守護職とは治安の悪化した幕末の京都を守る大切な役目です。幕府や他の藩と分担して市中をパトロールしなければなりません。ところがいざ分担ルートを決める段になって、家臣の中でも有名な頑固者の古老から以下のような注文がつきました。
</p>
<center>
<img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_14_1">
</center>
<br/>
<p>
大変なことになりました。殿様といえどもこの家臣の言い分を無視するわけにはいきません。分担ルートの選択によっては、「武士の面目が立たない」ということになってしまいます。
</p>
<p>
ということで、スタート地点、ゴール地点、交差点の情報を入力として、上の三つの条件を満たすかどうかを判定するプログラムを作って、殿様に献上してください。
</p>
<p>
スタート地点を 1、ゴール地点を2、その他の交差点を 3 以上の整数で表します。1つの道路は、その道が結ぶ1組の交差点番号で表します。なお、交差点の数は 100 以下とし、全ての交差点からスタート地点およびゴール地点への経路がそれぞれ一つ以上あるものとします。
</p>
<H2>入力</H2>
<p>複数のデータセットが与えられます。各データセットは以下の形式で与えられます。</p>
<pre>
<var>a<sub>1</sub></var> <var>b<sub>1</sub></var>
<var>a<sub>2</sub></var> <var>b<sub>2</sub></var>
：
：
<var>0</var> <var>0</var>
</pre>
<p>
各行の２つの整数は、交差点 <var>a<sub>i</sub></var> と交差点 <var>b<sub>i</sub></var> とをつなぐ道路が存在することを示します。
<var>a<sub>i</sub></var> と <var>b<sub>i</sub></var> がともに 0 のとき交差点情報の入力の終わりを示します。
</p>
<p>
データセットの数は50を超えません。
</p>
<H2>出力</H2>
<p>
各データセットに対して、武士の面目が立つ場合（三つの条件を満たす場合）OK、それ以外の場合（三つの条件を満たさない場合）NG と１行に出力してください。
</p>
<H2>Sample Input</H2>
<pre>
1 3
3 4
3 5
3 6
4 6
4 7
4 7
5 6
6 7
5 8
5 8
6 8
6 9
7 9
8 9
9 2
0 0
1 3
3 4
3 4
4 2
0 0
</pre>
<H2>Output for the Sample Input</H2>
<pre>
OK
NG
</pre>
<img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_14_2">
<img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_14_3">
<img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_14_4">
| 1 3
3 4
3 5
3 6
4 6
4 7
4 7
5 6
6 7
5 8
5 8
6 8
6 9
7 9
8 9
9 2
0 0
1 3
3 4
3 4
4 2
0 0
| OK
NG
| 12,415 |
s742799825 | p00086 | u150984829 | 1525269153 | Python | Python3 | py | Accepted | 30 | 5612 | 173 | import sys
v=[0]*101
for e in sys.stdin:
a,b=map(int,e.split())
if a==0:
print(['NG','OK'][1&v[1]and 1&v[2]and sum(x&1 for x in v[3:])==0])
v=[0]*101
v[a]+=1;v[b]+=1
| p00086 |
<H1>パトロール</H1>
<p>
文久２（1862）年、会津の殿様が京都守護職を命ぜられました。京都守護職とは治安の悪化した幕末の京都を守る大切な役目です。幕府や他の藩と分担して市中をパトロールしなければなりません。ところがいざ分担ルートを決める段になって、家臣の中でも有名な頑固者の古老から以下のような注文がつきました。
</p>
<center>
<img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_14_1">
</center>
<br/>
<p>
大変なことになりました。殿様といえどもこの家臣の言い分を無視するわけにはいきません。分担ルートの選択によっては、「武士の面目が立たない」ということになってしまいます。
</p>
<p>
ということで、スタート地点、ゴール地点、交差点の情報を入力として、上の三つの条件を満たすかどうかを判定するプログラムを作って、殿様に献上してください。
</p>
<p>
スタート地点を 1、ゴール地点を2、その他の交差点を 3 以上の整数で表します。1つの道路は、その道が結ぶ1組の交差点番号で表します。なお、交差点の数は 100 以下とし、全ての交差点からスタート地点およびゴール地点への経路がそれぞれ一つ以上あるものとします。
</p>
<H2>入力</H2>
<p>複数のデータセットが与えられます。各データセットは以下の形式で与えられます。</p>
<pre>
<var>a<sub>1</sub></var> <var>b<sub>1</sub></var>
<var>a<sub>2</sub></var> <var>b<sub>2</sub></var>
：
：
<var>0</var> <var>0</var>
</pre>
<p>
各行の２つの整数は、交差点 <var>a<sub>i</sub></var> と交差点 <var>b<sub>i</sub></var> とをつなぐ道路が存在することを示します。
<var>a<sub>i</sub></var> と <var>b<sub>i</sub></var> がともに 0 のとき交差点情報の入力の終わりを示します。
</p>
<p>
データセットの数は50を超えません。
</p>
<H2>出力</H2>
<p>
各データセットに対して、武士の面目が立つ場合（三つの条件を満たす場合）OK、それ以外の場合（三つの条件を満たさない場合）NG と１行に出力してください。
</p>
<H2>Sample Input</H2>
<pre>
1 3
3 4
3 5
3 6
4 6
4 7
4 7
5 6
6 7
5 8
5 8
6 8
6 9
7 9
8 9
9 2
0 0
1 3
3 4
3 4
4 2
0 0
</pre>
<H2>Output for the Sample Input</H2>
<pre>
OK
NG
</pre>
<img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_14_2">
<img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_14_3">
<img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_14_4">
| 1 3
3 4
3 5
3 6
4 6
4 7
4 7
5 6
6 7
5 8
5 8
6 8
6 9
7 9
8 9
9 2
0 0
1 3
3 4
3 4
4 2
0 0
| OK
NG
| 12,416 |
s141884066 | p00086 | u150984829 | 1525269345 | Python | Python3 | py | Accepted | 30 | 5616 | 169 | import sys
v=[0]*101
for e in sys.stdin:
a,b=map(int,e.split())
v[a]+=1;v[b]+=1
if a==0:
print(['NG','OK'][1&v[1]and 1&v[2]and sum(x&1 for x in v)==2])
v=[0]*101
| p00086 |
<H1>パトロール</H1>
<p>
文久２（1862）年、会津の殿様が京都守護職を命ぜられました。京都守護職とは治安の悪化した幕末の京都を守る大切な役目です。幕府や他の藩と分担して市中をパトロールしなければなりません。ところがいざ分担ルートを決める段になって、家臣の中でも有名な頑固者の古老から以下のような注文がつきました。
</p>
<center>
<img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_14_1">
</center>
<br/>
<p>
大変なことになりました。殿様といえどもこの家臣の言い分を無視するわけにはいきません。分担ルートの選択によっては、「武士の面目が立たない」ということになってしまいます。
</p>
<p>
ということで、スタート地点、ゴール地点、交差点の情報を入力として、上の三つの条件を満たすかどうかを判定するプログラムを作って、殿様に献上してください。
</p>
<p>
スタート地点を 1、ゴール地点を2、その他の交差点を 3 以上の整数で表します。1つの道路は、その道が結ぶ1組の交差点番号で表します。なお、交差点の数は 100 以下とし、全ての交差点からスタート地点およびゴール地点への経路がそれぞれ一つ以上あるものとします。
</p>
<H2>入力</H2>
<p>複数のデータセットが与えられます。各データセットは以下の形式で与えられます。</p>
<pre>
<var>a<sub>1</sub></var> <var>b<sub>1</sub></var>
<var>a<sub>2</sub></var> <var>b<sub>2</sub></var>
：
：
<var>0</var> <var>0</var>
</pre>
<p>
各行の２つの整数は、交差点 <var>a<sub>i</sub></var> と交差点 <var>b<sub>i</sub></var> とをつなぐ道路が存在することを示します。
<var>a<sub>i</sub></var> と <var>b<sub>i</sub></var> がともに 0 のとき交差点情報の入力の終わりを示します。
</p>
<p>
データセットの数は50を超えません。
</p>
<H2>出力</H2>
<p>
各データセットに対して、武士の面目が立つ場合（三つの条件を満たす場合）OK、それ以外の場合（三つの条件を満たさない場合）NG と１行に出力してください。
</p>
<H2>Sample Input</H2>
<pre>
1 3
3 4
3 5
3 6
4 6
4 7
4 7
5 6
6 7
5 8
5 8
6 8
6 9
7 9
8 9
9 2
0 0
1 3
3 4
3 4
4 2
0 0
</pre>
<H2>Output for the Sample Input</H2>
<pre>
OK
NG
</pre>
<img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_14_2">
<img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_14_3">
<img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_14_4">
| 1 3
3 4
3 5
3 6
4 6
4 7
4 7
5 6
6 7
5 8
5 8
6 8
6 9
7 9
8 9
9 2
0 0
1 3
3 4
3 4
4 2
0 0
| OK
NG
| 12,417 |
s296401853 | p00086 | u150984829 | 1525269546 | Python | Python3 | py | Accepted | 20 | 5608 | 167 | import sys
v=[0]*101
for e in sys.stdin:
a,b=map(int,e.split())
v[a]+=1;v[b]+=1
if a==0:
print(['NG','OK'][(v[1]&1)*(v[2]&1)*sum(x&1 for x in v)==2])
v=[0]*101
| p00086 |
<H1>パトロール</H1>
<p>
文久２（1862）年、会津の殿様が京都守護職を命ぜられました。京都守護職とは治安の悪化した幕末の京都を守る大切な役目です。幕府や他の藩と分担して市中をパトロールしなければなりません。ところがいざ分担ルートを決める段になって、家臣の中でも有名な頑固者の古老から以下のような注文がつきました。
</p>
<center>
<img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_14_1">
</center>
<br/>
<p>
大変なことになりました。殿様といえどもこの家臣の言い分を無視するわけにはいきません。分担ルートの選択によっては、「武士の面目が立たない」ということになってしまいます。
</p>
<p>
ということで、スタート地点、ゴール地点、交差点の情報を入力として、上の三つの条件を満たすかどうかを判定するプログラムを作って、殿様に献上してください。
</p>
<p>
スタート地点を 1、ゴール地点を2、その他の交差点を 3 以上の整数で表します。1つの道路は、その道が結ぶ1組の交差点番号で表します。なお、交差点の数は 100 以下とし、全ての交差点からスタート地点およびゴール地点への経路がそれぞれ一つ以上あるものとします。
</p>
<H2>入力</H2>
<p>複数のデータセットが与えられます。各データセットは以下の形式で与えられます。</p>
<pre>
<var>a<sub>1</sub></var> <var>b<sub>1</sub></var>
<var>a<sub>2</sub></var> <var>b<sub>2</sub></var>
：
：
<var>0</var> <var>0</var>
</pre>
<p>
各行の２つの整数は、交差点 <var>a<sub>i</sub></var> と交差点 <var>b<sub>i</sub></var> とをつなぐ道路が存在することを示します。
<var>a<sub>i</sub></var> と <var>b<sub>i</sub></var> がともに 0 のとき交差点情報の入力の終わりを示します。
</p>
<p>
データセットの数は50を超えません。
</p>
<H2>出力</H2>
<p>
各データセットに対して、武士の面目が立つ場合（三つの条件を満たす場合）OK、それ以外の場合（三つの条件を満たさない場合）NG と１行に出力してください。
</p>
<H2>Sample Input</H2>
<pre>
1 3
3 4
3 5
3 6
4 6
4 7
4 7
5 6
6 7
5 8
5 8
6 8
6 9
7 9
8 9
9 2
0 0
1 3
3 4
3 4
4 2
0 0
</pre>
<H2>Output for the Sample Input</H2>
<pre>
OK
NG
</pre>
<img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_14_2">
<img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_14_3">
<img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_14_4">
| 1 3
3 4
3 5
3 6
4 6
4 7
4 7
5 6
6 7
5 8
5 8
6 8
6 9
7 9
8 9
9 2
0 0
1 3
3 4
3 4
4 2
0 0
| OK
NG
| 12,418 |
s796157034 | p00086 | u150984829 | 1525269580 | Python | Python3 | py | Accepted | 30 | 5608 | 167 | import sys
v=[0]*101
for e in sys.stdin:
a,b=map(int,e.split())
v[a]+=1;v[b]+=1
if a==0:
print(['NG','OK'][(v[1]&1)*(v[2]&1)*sum(x&1 for x in v)==2])
v=[0]*100
| p00086 |
<H1>パトロール</H1>
<p>
文久２（1862）年、会津の殿様が京都守護職を命ぜられました。京都守護職とは治安の悪化した幕末の京都を守る大切な役目です。幕府や他の藩と分担して市中をパトロールしなければなりません。ところがいざ分担ルートを決める段になって、家臣の中でも有名な頑固者の古老から以下のような注文がつきました。
</p>
<center>
<img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_14_1">
</center>
<br/>
<p>
大変なことになりました。殿様といえどもこの家臣の言い分を無視するわけにはいきません。分担ルートの選択によっては、「武士の面目が立たない」ということになってしまいます。
</p>
<p>
ということで、スタート地点、ゴール地点、交差点の情報を入力として、上の三つの条件を満たすかどうかを判定するプログラムを作って、殿様に献上してください。
</p>
<p>
スタート地点を 1、ゴール地点を2、その他の交差点を 3 以上の整数で表します。1つの道路は、その道が結ぶ1組の交差点番号で表します。なお、交差点の数は 100 以下とし、全ての交差点からスタート地点およびゴール地点への経路がそれぞれ一つ以上あるものとします。
</p>
<H2>入力</H2>
<p>複数のデータセットが与えられます。各データセットは以下の形式で与えられます。</p>
<pre>
<var>a<sub>1</sub></var> <var>b<sub>1</sub></var>
<var>a<sub>2</sub></var> <var>b<sub>2</sub></var>
：
：
<var>0</var> <var>0</var>
</pre>
<p>
各行の２つの整数は、交差点 <var>a<sub>i</sub></var> と交差点 <var>b<sub>i</sub></var> とをつなぐ道路が存在することを示します。
<var>a<sub>i</sub></var> と <var>b<sub>i</sub></var> がともに 0 のとき交差点情報の入力の終わりを示します。
</p>
<p>
データセットの数は50を超えません。
</p>
<H2>出力</H2>
<p>
各データセットに対して、武士の面目が立つ場合（三つの条件を満たす場合）OK、それ以外の場合（三つの条件を満たさない場合）NG と１行に出力してください。
</p>
<H2>Sample Input</H2>
<pre>
1 3
3 4
3 5
3 6
4 6
4 7
4 7
5 6
6 7
5 8
5 8
6 8
6 9
7 9
8 9
9 2
0 0
1 3
3 4
3 4
4 2
0 0
</pre>
<H2>Output for the Sample Input</H2>
<pre>
OK
NG
</pre>
<img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_14_2">
<img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_14_3">
<img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_14_4">
| 1 3
3 4
3 5
3 6
4 6
4 7
4 7
5 6
6 7
5 8
5 8
6 8
6 9
7 9
8 9
9 2
0 0
1 3
3 4
3 4
4 2
0 0
| OK
NG
| 12,419 |
s062172614 | p00086 | u150984829 | 1525269587 | Python | Python3 | py | Accepted | 30 | 5612 | 167 | import sys
v=[0]*100
for e in sys.stdin:
a,b=map(int,e.split())
v[a]+=1;v[b]+=1
if a==0:
print(['NG','OK'][(v[1]&1)*(v[2]&1)*sum(x&1 for x in v)==2])
v=[0]*100
| p00086 |
<H1>パトロール</H1>
<p>
文久２（1862）年、会津の殿様が京都守護職を命ぜられました。京都守護職とは治安の悪化した幕末の京都を守る大切な役目です。幕府や他の藩と分担して市中をパトロールしなければなりません。ところがいざ分担ルートを決める段になって、家臣の中でも有名な頑固者の古老から以下のような注文がつきました。
</p>
<center>
<img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_14_1">
</center>
<br/>
<p>
大変なことになりました。殿様といえどもこの家臣の言い分を無視するわけにはいきません。分担ルートの選択によっては、「武士の面目が立たない」ということになってしまいます。
</p>
<p>
ということで、スタート地点、ゴール地点、交差点の情報を入力として、上の三つの条件を満たすかどうかを判定するプログラムを作って、殿様に献上してください。
</p>
<p>
スタート地点を 1、ゴール地点を2、その他の交差点を 3 以上の整数で表します。1つの道路は、その道が結ぶ1組の交差点番号で表します。なお、交差点の数は 100 以下とし、全ての交差点からスタート地点およびゴール地点への経路がそれぞれ一つ以上あるものとします。
</p>
<H2>入力</H2>
<p>複数のデータセットが与えられます。各データセットは以下の形式で与えられます。</p>
<pre>
<var>a<sub>1</sub></var> <var>b<sub>1</sub></var>
<var>a<sub>2</sub></var> <var>b<sub>2</sub></var>
：
：
<var>0</var> <var>0</var>
</pre>
<p>
各行の２つの整数は、交差点 <var>a<sub>i</sub></var> と交差点 <var>b<sub>i</sub></var> とをつなぐ道路が存在することを示します。
<var>a<sub>i</sub></var> と <var>b<sub>i</sub></var> がともに 0 のとき交差点情報の入力の終わりを示します。
</p>
<p>
データセットの数は50を超えません。
</p>
<H2>出力</H2>
<p>
各データセットに対して、武士の面目が立つ場合（三つの条件を満たす場合）OK、それ以外の場合（三つの条件を満たさない場合）NG と１行に出力してください。
</p>
<H2>Sample Input</H2>
<pre>
1 3
3 4
3 5
3 6
4 6
4 7
4 7
5 6
6 7
5 8
5 8
6 8
6 9
7 9
8 9
9 2
0 0
1 3
3 4
3 4
4 2
0 0
</pre>
<H2>Output for the Sample Input</H2>
<pre>
OK
NG
</pre>
<img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_14_2">
<img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_14_3">
<img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_14_4">
| 1 3
3 4
3 5
3 6
4 6
4 7
4 7
5 6
6 7
5 8
5 8
6 8
6 9
7 9
8 9
9 2
0 0
1 3
3 4
3 4
4 2
0 0
| OK
NG
| 12,420 |
s073849788 | p00086 | u352394527 | 1527589995 | Python | Python3 | py | Accepted | 30 | 5608 | 609 | def solve():
dic = {}
while True:
a, b = map(int, input().split())
if not a:
break
if a in dic:
dic[a] += 1
else:
dic[a] = 1
if b in dic:
dic[b] += 1
else:
dic[b] = 1
#スタートとゴールの次数が偶数ならNG
if not dic[1] % 2 or not dic[2] % 2:
print("NG")
else:
#それ以外の頂点の次数が奇数ならNG
for k in dic:
if not k in (1,2) and dic[k] % 2:
print("NG")
break
#それ以外はOK
else:
print("OK")
while True:
try:
solve()
except EOFError:
break
| p00086 |
<H1>パトロール</H1>
<p>
文久２（1862）年、会津の殿様が京都守護職を命ぜられました。京都守護職とは治安の悪化した幕末の京都を守る大切な役目です。幕府や他の藩と分担して市中をパトロールしなければなりません。ところがいざ分担ルートを決める段になって、家臣の中でも有名な頑固者の古老から以下のような注文がつきました。
</p>
<center>
<img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_14_1">
</center>
<br/>
<p>
大変なことになりました。殿様といえどもこの家臣の言い分を無視するわけにはいきません。分担ルートの選択によっては、「武士の面目が立たない」ということになってしまいます。
</p>
<p>
ということで、スタート地点、ゴール地点、交差点の情報を入力として、上の三つの条件を満たすかどうかを判定するプログラムを作って、殿様に献上してください。
</p>
<p>
スタート地点を 1、ゴール地点を2、その他の交差点を 3 以上の整数で表します。1つの道路は、その道が結ぶ1組の交差点番号で表します。なお、交差点の数は 100 以下とし、全ての交差点からスタート地点およびゴール地点への経路がそれぞれ一つ以上あるものとします。
</p>
<H2>入力</H2>
<p>複数のデータセットが与えられます。各データセットは以下の形式で与えられます。</p>
<pre>
<var>a<sub>1</sub></var> <var>b<sub>1</sub></var>
<var>a<sub>2</sub></var> <var>b<sub>2</sub></var>
：
：
<var>0</var> <var>0</var>
</pre>
<p>
各行の２つの整数は、交差点 <var>a<sub>i</sub></var> と交差点 <var>b<sub>i</sub></var> とをつなぐ道路が存在することを示します。
<var>a<sub>i</sub></var> と <var>b<sub>i</sub></var> がともに 0 のとき交差点情報の入力の終わりを示します。
</p>
<p>
データセットの数は50を超えません。
</p>
<H2>出力</H2>
<p>
各データセットに対して、武士の面目が立つ場合（三つの条件を満たす場合）OK、それ以外の場合（三つの条件を満たさない場合）NG と１行に出力してください。
</p>
<H2>Sample Input</H2>
<pre>
1 3
3 4
3 5
3 6
4 6
4 7
4 7
5 6
6 7
5 8
5 8
6 8
6 9
7 9
8 9
9 2
0 0
1 3
3 4
3 4
4 2
0 0
</pre>
<H2>Output for the Sample Input</H2>
<pre>
OK
NG
</pre>
<img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_14_2">
<img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_14_3">
<img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_14_4">
| 1 3
3 4
3 5
3 6
4 6
4 7
4 7
5 6
6 7
5 8
5 8
6 8
6 9
7 9
8 9
9 2
0 0
1 3
3 4
3 4
4 2
0 0
| OK
NG
| 12,421 |
s875645414 | p00086 | u847467233 | 1529240421 | Python | Python3 | py | Accepted | 40 | 5600 | 432 | # AOJ 0086 Patrol
# Python3 2018.6.17 bal4u
while True:
try: a, b = list(map(int, input().split()))
except: break
c = [0]*105
n = 0
while True:
if a != b:
c[a] += 1
c[b] += 1
if a > n: n = a
if b > n: n = b
a, b = list(map(int, input().split()))
if a == 0: break
f = False
if (c[1]&1) and (c[2]&1):
i = 3
while i <= n:
if (c[i]&1): break;
i += 1
if i > n: f = True
print("OK" if f else "NG")
| p00086 |
<H1>パトロール</H1>
<p>
文久２（1862）年、会津の殿様が京都守護職を命ぜられました。京都守護職とは治安の悪化した幕末の京都を守る大切な役目です。幕府や他の藩と分担して市中をパトロールしなければなりません。ところがいざ分担ルートを決める段になって、家臣の中でも有名な頑固者の古老から以下のような注文がつきました。
</p>
<center>
<img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_14_1">
</center>
<br/>
<p>
大変なことになりました。殿様といえどもこの家臣の言い分を無視するわけにはいきません。分担ルートの選択によっては、「武士の面目が立たない」ということになってしまいます。
</p>
<p>
ということで、スタート地点、ゴール地点、交差点の情報を入力として、上の三つの条件を満たすかどうかを判定するプログラムを作って、殿様に献上してください。
</p>
<p>
スタート地点を 1、ゴール地点を2、その他の交差点を 3 以上の整数で表します。1つの道路は、その道が結ぶ1組の交差点番号で表します。なお、交差点の数は 100 以下とし、全ての交差点からスタート地点およびゴール地点への経路がそれぞれ一つ以上あるものとします。
</p>
<H2>入力</H2>
<p>複数のデータセットが与えられます。各データセットは以下の形式で与えられます。</p>
<pre>
<var>a<sub>1</sub></var> <var>b<sub>1</sub></var>
<var>a<sub>2</sub></var> <var>b<sub>2</sub></var>
：
：
<var>0</var> <var>0</var>
</pre>
<p>
各行の２つの整数は、交差点 <var>a<sub>i</sub></var> と交差点 <var>b<sub>i</sub></var> とをつなぐ道路が存在することを示します。
<var>a<sub>i</sub></var> と <var>b<sub>i</sub></var> がともに 0 のとき交差点情報の入力の終わりを示します。
</p>
<p>
データセットの数は50を超えません。
</p>
<H2>出力</H2>
<p>
各データセットに対して、武士の面目が立つ場合（三つの条件を満たす場合）OK、それ以外の場合（三つの条件を満たさない場合）NG と１行に出力してください。
</p>
<H2>Sample Input</H2>
<pre>
1 3
3 4
3 5
3 6
4 6
4 7
4 7
5 6
6 7
5 8
5 8
6 8
6 9
7 9
8 9
9 2
0 0
1 3
3 4
3 4
4 2
0 0
</pre>
<H2>Output for the Sample Input</H2>
<pre>
OK
NG
</pre>
<img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_14_2">
<img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_14_3">
<img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_14_4">
| 1 3
3 4
3 5
3 6
4 6
4 7
4 7
5 6
6 7
5 8
5 8
6 8
6 9
7 9
8 9
9 2
0 0
1 3
3 4
3 4
4 2
0 0
| OK
NG
| 12,422 |
s726792826 | p00086 | u647766105 | 1356546977 | Python | Python | py | Accepted | 10 | 5336 | 376 | while True:
try:
cross=[0]*101
while True:
a,b=map(int,raw_input().split())
if (a,b)==(0,0):
break
cross[a]+=1
cross[b]+=1
if cross[1]%2==cross[2]%2==1 and len(filter(lambda x:x%2==1,cross[3:]))==0:
print "OK"
else:
print "NG"
except:
break | p00086 |
<H1>パトロール</H1>
<p>
文久２（1862）年、会津の殿様が京都守護職を命ぜられました。京都守護職とは治安の悪化した幕末の京都を守る大切な役目です。幕府や他の藩と分担して市中をパトロールしなければなりません。ところがいざ分担ルートを決める段になって、家臣の中でも有名な頑固者の古老から以下のような注文がつきました。
</p>
<center>
<img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_14_1">
</center>
<br/>
<p>
大変なことになりました。殿様といえどもこの家臣の言い分を無視するわけにはいきません。分担ルートの選択によっては、「武士の面目が立たない」ということになってしまいます。
</p>
<p>
ということで、スタート地点、ゴール地点、交差点の情報を入力として、上の三つの条件を満たすかどうかを判定するプログラムを作って、殿様に献上してください。
</p>
<p>
スタート地点を 1、ゴール地点を2、その他の交差点を 3 以上の整数で表します。1つの道路は、その道が結ぶ1組の交差点番号で表します。なお、交差点の数は 100 以下とし、全ての交差点からスタート地点およびゴール地点への経路がそれぞれ一つ以上あるものとします。
</p>
<H2>入力</H2>
<p>複数のデータセットが与えられます。各データセットは以下の形式で与えられます。</p>
<pre>
<var>a<sub>1</sub></var> <var>b<sub>1</sub></var>
<var>a<sub>2</sub></var> <var>b<sub>2</sub></var>
：
：
<var>0</var> <var>0</var>
</pre>
<p>
各行の２つの整数は、交差点 <var>a<sub>i</sub></var> と交差点 <var>b<sub>i</sub></var> とをつなぐ道路が存在することを示します。
<var>a<sub>i</sub></var> と <var>b<sub>i</sub></var> がともに 0 のとき交差点情報の入力の終わりを示します。
</p>
<p>
データセットの数は50を超えません。
</p>
<H2>出力</H2>
<p>
各データセットに対して、武士の面目が立つ場合（三つの条件を満たす場合）OK、それ以外の場合（三つの条件を満たさない場合）NG と１行に出力してください。
</p>
<H2>Sample Input</H2>
<pre>
1 3
3 4
3 5
3 6
4 6
4 7
4 7
5 6
6 7
5 8
5 8
6 8
6 9
7 9
8 9
9 2
0 0
1 3
3 4
3 4
4 2
0 0
</pre>
<H2>Output for the Sample Input</H2>
<pre>
OK
NG
</pre>
<img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_14_2">
<img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_14_3">
<img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_14_4">
| 1 3
3 4
3 5
3 6
4 6
4 7
4 7
5 6
6 7
5 8
5 8
6 8
6 9
7 9
8 9
9 2
0 0
1 3
3 4
3 4
4 2
0 0
| OK
NG
| 12,423 |
s522902038 | p00086 | u104911888 | 1370952917 | Python | Python | py | Accepted | 10 | 4228 | 315 | import sys
while True:
L=[0]*101
while True:
try:
a,b=map(int,raw_input().split())
except EOFError:
sys.exit()
if a==b==0:break
L[a]+=1
L[b]+=1
odd=0
for i in L:
if i%2==1:
odd+=1
print "NG" if odd!=2 else "OK" | p00086 |
<H1>パトロール</H1>
<p>
文久２（1862）年、会津の殿様が京都守護職を命ぜられました。京都守護職とは治安の悪化した幕末の京都を守る大切な役目です。幕府や他の藩と分担して市中をパトロールしなければなりません。ところがいざ分担ルートを決める段になって、家臣の中でも有名な頑固者の古老から以下のような注文がつきました。
</p>
<center>
<img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_14_1">
</center>
<br/>
<p>
大変なことになりました。殿様といえどもこの家臣の言い分を無視するわけにはいきません。分担ルートの選択によっては、「武士の面目が立たない」ということになってしまいます。
</p>
<p>
ということで、スタート地点、ゴール地点、交差点の情報を入力として、上の三つの条件を満たすかどうかを判定するプログラムを作って、殿様に献上してください。
</p>
<p>
スタート地点を 1、ゴール地点を2、その他の交差点を 3 以上の整数で表します。1つの道路は、その道が結ぶ1組の交差点番号で表します。なお、交差点の数は 100 以下とし、全ての交差点からスタート地点およびゴール地点への経路がそれぞれ一つ以上あるものとします。
</p>
<H2>入力</H2>
<p>複数のデータセットが与えられます。各データセットは以下の形式で与えられます。</p>
<pre>
<var>a<sub>1</sub></var> <var>b<sub>1</sub></var>
<var>a<sub>2</sub></var> <var>b<sub>2</sub></var>
：
：
<var>0</var> <var>0</var>
</pre>
<p>
各行の２つの整数は、交差点 <var>a<sub>i</sub></var> と交差点 <var>b<sub>i</sub></var> とをつなぐ道路が存在することを示します。
<var>a<sub>i</sub></var> と <var>b<sub>i</sub></var> がともに 0 のとき交差点情報の入力の終わりを示します。
</p>
<p>
データセットの数は50を超えません。
</p>
<H2>出力</H2>
<p>
各データセットに対して、武士の面目が立つ場合（三つの条件を満たす場合）OK、それ以外の場合（三つの条件を満たさない場合）NG と１行に出力してください。
</p>
<H2>Sample Input</H2>
<pre>
1 3
3 4
3 5
3 6
4 6
4 7
4 7
5 6
6 7
5 8
5 8
6 8
6 9
7 9
8 9
9 2
0 0
1 3
3 4
3 4
4 2
0 0
</pre>
<H2>Output for the Sample Input</H2>
<pre>
OK
NG
</pre>
<img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_14_2">
<img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_14_3">
<img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_14_4">
| 1 3
3 4
3 5
3 6
4 6
4 7
4 7
5 6
6 7
5 8
5 8
6 8
6 9
7 9
8 9
9 2
0 0
1 3
3 4
3 4
4 2
0 0
| OK
NG
| 12,424 |
s732785608 | p00086 | u759949288 | 1371159739 | Python | Python | py | Accepted | 10 | 4228 | 284 | import sys
nodes = [0] * 100
for line in sys.stdin:
frm, to = map(int, line.split())
if frm == 0 and to == 0:
if nodes[1] & 1 and nodes[2] & 1 and all(not(i & 1) for i in nodes[3:]):
print "OK"
else:
print "NG"
nodes = [0] * 100
else:
nodes[frm] += 1
nodes[to] += 1 | p00086 |
<H1>パトロール</H1>
<p>
文久２（1862）年、会津の殿様が京都守護職を命ぜられました。京都守護職とは治安の悪化した幕末の京都を守る大切な役目です。幕府や他の藩と分担して市中をパトロールしなければなりません。ところがいざ分担ルートを決める段になって、家臣の中でも有名な頑固者の古老から以下のような注文がつきました。
</p>
<center>
<img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_14_1">
</center>
<br/>
<p>
大変なことになりました。殿様といえどもこの家臣の言い分を無視するわけにはいきません。分担ルートの選択によっては、「武士の面目が立たない」ということになってしまいます。
</p>
<p>
ということで、スタート地点、ゴール地点、交差点の情報を入力として、上の三つの条件を満たすかどうかを判定するプログラムを作って、殿様に献上してください。
</p>
<p>
スタート地点を 1、ゴール地点を2、その他の交差点を 3 以上の整数で表します。1つの道路は、その道が結ぶ1組の交差点番号で表します。なお、交差点の数は 100 以下とし、全ての交差点からスタート地点およびゴール地点への経路がそれぞれ一つ以上あるものとします。
</p>
<H2>入力</H2>
<p>複数のデータセットが与えられます。各データセットは以下の形式で与えられます。</p>
<pre>
<var>a<sub>1</sub></var> <var>b<sub>1</sub></var>
<var>a<sub>2</sub></var> <var>b<sub>2</sub></var>
：
：
<var>0</var> <var>0</var>
</pre>
<p>
各行の２つの整数は、交差点 <var>a<sub>i</sub></var> と交差点 <var>b<sub>i</sub></var> とをつなぐ道路が存在することを示します。
<var>a<sub>i</sub></var> と <var>b<sub>i</sub></var> がともに 0 のとき交差点情報の入力の終わりを示します。
</p>
<p>
データセットの数は50を超えません。
</p>
<H2>出力</H2>
<p>
各データセットに対して、武士の面目が立つ場合（三つの条件を満たす場合）OK、それ以外の場合（三つの条件を満たさない場合）NG と１行に出力してください。
</p>
<H2>Sample Input</H2>
<pre>
1 3
3 4
3 5
3 6
4 6
4 7
4 7
5 6
6 7
5 8
5 8
6 8
6 9
7 9
8 9
9 2
0 0
1 3
3 4
3 4
4 2
0 0
</pre>
<H2>Output for the Sample Input</H2>
<pre>
OK
NG
</pre>
<img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_14_2">
<img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_14_3">
<img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_14_4">
| 1 3
3 4
3 5
3 6
4 6
4 7
4 7
5 6
6 7
5 8
5 8
6 8
6 9
7 9
8 9
9 2
0 0
1 3
3 4
3 4
4 2
0 0
| OK
NG
| 12,425 |
s160459598 | p00086 | u782850731 | 1379213780 | Python | Python | py | Accepted | 20 | 4648 | 569 | #!/usr/bin/env python
# -*- coding: utf-8 -*-
from __future__ import (division, absolute_import, print_function,
unicode_literals)
from sys import stdin
from collections import Counter
cnt = Counter()
for line in stdin:
start, end = (int(s) for s in line.split())
if start or end:
cnt[start] += 1
cnt[end] += 1
else:
semi_eulerian = sum(i % 2 for i in cnt.values()) == 2
if semi_eulerian and cnt[1] % 2 and cnt[2] % 2:
print('OK')
else:
print('NG')
cnt.clear() | p00086 |
<H1>パトロール</H1>
<p>
文久２（1862）年、会津の殿様が京都守護職を命ぜられました。京都守護職とは治安の悪化した幕末の京都を守る大切な役目です。幕府や他の藩と分担して市中をパトロールしなければなりません。ところがいざ分担ルートを決める段になって、家臣の中でも有名な頑固者の古老から以下のような注文がつきました。
</p>
<center>
<img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_14_1">
</center>
<br/>
<p>
大変なことになりました。殿様といえどもこの家臣の言い分を無視するわけにはいきません。分担ルートの選択によっては、「武士の面目が立たない」ということになってしまいます。
</p>
<p>
ということで、スタート地点、ゴール地点、交差点の情報を入力として、上の三つの条件を満たすかどうかを判定するプログラムを作って、殿様に献上してください。
</p>
<p>
スタート地点を 1、ゴール地点を2、その他の交差点を 3 以上の整数で表します。1つの道路は、その道が結ぶ1組の交差点番号で表します。なお、交差点の数は 100 以下とし、全ての交差点からスタート地点およびゴール地点への経路がそれぞれ一つ以上あるものとします。
</p>
<H2>入力</H2>
<p>複数のデータセットが与えられます。各データセットは以下の形式で与えられます。</p>
<pre>
<var>a<sub>1</sub></var> <var>b<sub>1</sub></var>
<var>a<sub>2</sub></var> <var>b<sub>2</sub></var>
：
：
<var>0</var> <var>0</var>
</pre>
<p>
各行の２つの整数は、交差点 <var>a<sub>i</sub></var> と交差点 <var>b<sub>i</sub></var> とをつなぐ道路が存在することを示します。
<var>a<sub>i</sub></var> と <var>b<sub>i</sub></var> がともに 0 のとき交差点情報の入力の終わりを示します。
</p>
<p>
データセットの数は50を超えません。
</p>
<H2>出力</H2>
<p>
各データセットに対して、武士の面目が立つ場合（三つの条件を満たす場合）OK、それ以外の場合（三つの条件を満たさない場合）NG と１行に出力してください。
</p>
<H2>Sample Input</H2>
<pre>
1 3
3 4
3 5
3 6
4 6
4 7
4 7
5 6
6 7
5 8
5 8
6 8
6 9
7 9
8 9
9 2
0 0
1 3
3 4
3 4
4 2
0 0
</pre>
<H2>Output for the Sample Input</H2>
<pre>
OK
NG
</pre>
<img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_14_2">
<img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_14_3">
<img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_14_4">
| 1 3
3 4
3 5
3 6
4 6
4 7
4 7
5 6
6 7
5 8
5 8
6 8
6 9
7 9
8 9
9 2
0 0
1 3
3 4
3 4
4 2
0 0
| OK
NG
| 12,426 |
s407539577 | p00086 | u633068244 | 1395976780 | Python | Python | py | Accepted | 20 | 4216 | 334 | while True:
try:
path = [0]*101
while True:
a,b = map(int, raw_input().split())
if a == 0: break
path[a-1] += 1; path[b-1] += 1
for i in range(3,101):
if path[i]%2 != 0:
flag = 0
break
else:
flag = 1
if path[0]%2 == path[1]%2 == 1 and flag:
print "OK"
else:
print "NG"
except:
break | p00086 |
<H1>パトロール</H1>
<p>
文久２（1862）年、会津の殿様が京都守護職を命ぜられました。京都守護職とは治安の悪化した幕末の京都を守る大切な役目です。幕府や他の藩と分担して市中をパトロールしなければなりません。ところがいざ分担ルートを決める段になって、家臣の中でも有名な頑固者の古老から以下のような注文がつきました。
</p>
<center>
<img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_14_1">
</center>
<br/>
<p>
大変なことになりました。殿様といえどもこの家臣の言い分を無視するわけにはいきません。分担ルートの選択によっては、「武士の面目が立たない」ということになってしまいます。
</p>
<p>
ということで、スタート地点、ゴール地点、交差点の情報を入力として、上の三つの条件を満たすかどうかを判定するプログラムを作って、殿様に献上してください。
</p>
<p>
スタート地点を 1、ゴール地点を2、その他の交差点を 3 以上の整数で表します。1つの道路は、その道が結ぶ1組の交差点番号で表します。なお、交差点の数は 100 以下とし、全ての交差点からスタート地点およびゴール地点への経路がそれぞれ一つ以上あるものとします。
</p>
<H2>入力</H2>
<p>複数のデータセットが与えられます。各データセットは以下の形式で与えられます。</p>
<pre>
<var>a<sub>1</sub></var> <var>b<sub>1</sub></var>
<var>a<sub>2</sub></var> <var>b<sub>2</sub></var>
：
：
<var>0</var> <var>0</var>
</pre>
<p>
各行の２つの整数は、交差点 <var>a<sub>i</sub></var> と交差点 <var>b<sub>i</sub></var> とをつなぐ道路が存在することを示します。
<var>a<sub>i</sub></var> と <var>b<sub>i</sub></var> がともに 0 のとき交差点情報の入力の終わりを示します。
</p>
<p>
データセットの数は50を超えません。
</p>
<H2>出力</H2>
<p>
各データセットに対して、武士の面目が立つ場合（三つの条件を満たす場合）OK、それ以外の場合（三つの条件を満たさない場合）NG と１行に出力してください。
</p>
<H2>Sample Input</H2>
<pre>
1 3
3 4
3 5
3 6
4 6
4 7
4 7
5 6
6 7
5 8
5 8
6 8
6 9
7 9
8 9
9 2
0 0
1 3
3 4
3 4
4 2
0 0
</pre>
<H2>Output for the Sample Input</H2>
<pre>
OK
NG
</pre>
<img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_14_2">
<img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_14_3">
<img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_14_4">
| 1 3
3 4
3 5
3 6
4 6
4 7
4 7
5 6
6 7
5 8
5 8
6 8
6 9
7 9
8 9
9 2
0 0
1 3
3 4
3 4
4 2
0 0
| OK
NG
| 12,427 |
s770789272 | p00086 | u633068244 | 1395978073 | Python | Python | py | Accepted | 10 | 4216 | 281 | while True:
try:
path = [0]*100
while True:
a,b = map(int, raw_input().split())
if a == 0: break
path[a-1] += 1; path[b-1] += 1
if path[0]%2 == path[1]%2 == 1 and sum(filter(lambda x:x%2==1,path[2:])) == 0:
print "OK"
else:
print "NG"
except:
break | p00086 |
<H1>パトロール</H1>
<p>
文久２（1862）年、会津の殿様が京都守護職を命ぜられました。京都守護職とは治安の悪化した幕末の京都を守る大切な役目です。幕府や他の藩と分担して市中をパトロールしなければなりません。ところがいざ分担ルートを決める段になって、家臣の中でも有名な頑固者の古老から以下のような注文がつきました。
</p>
<center>
<img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_14_1">
</center>
<br/>
<p>
大変なことになりました。殿様といえどもこの家臣の言い分を無視するわけにはいきません。分担ルートの選択によっては、「武士の面目が立たない」ということになってしまいます。
</p>
<p>
ということで、スタート地点、ゴール地点、交差点の情報を入力として、上の三つの条件を満たすかどうかを判定するプログラムを作って、殿様に献上してください。
</p>
<p>
スタート地点を 1、ゴール地点を2、その他の交差点を 3 以上の整数で表します。1つの道路は、その道が結ぶ1組の交差点番号で表します。なお、交差点の数は 100 以下とし、全ての交差点からスタート地点およびゴール地点への経路がそれぞれ一つ以上あるものとします。
</p>
<H2>入力</H2>
<p>複数のデータセットが与えられます。各データセットは以下の形式で与えられます。</p>
<pre>
<var>a<sub>1</sub></var> <var>b<sub>1</sub></var>
<var>a<sub>2</sub></var> <var>b<sub>2</sub></var>
：
：
<var>0</var> <var>0</var>
</pre>
<p>
各行の２つの整数は、交差点 <var>a<sub>i</sub></var> と交差点 <var>b<sub>i</sub></var> とをつなぐ道路が存在することを示します。
<var>a<sub>i</sub></var> と <var>b<sub>i</sub></var> がともに 0 のとき交差点情報の入力の終わりを示します。
</p>
<p>
データセットの数は50を超えません。
</p>
<H2>出力</H2>
<p>
各データセットに対して、武士の面目が立つ場合（三つの条件を満たす場合）OK、それ以外の場合（三つの条件を満たさない場合）NG と１行に出力してください。
</p>
<H2>Sample Input</H2>
<pre>
1 3
3 4
3 5
3 6
4 6
4 7
4 7
5 6
6 7
5 8
5 8
6 8
6 9
7 9
8 9
9 2
0 0
1 3
3 4
3 4
4 2
0 0
</pre>
<H2>Output for the Sample Input</H2>
<pre>
OK
NG
</pre>
<img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_14_2">
<img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_14_3">
<img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_14_4">
| 1 3
3 4
3 5
3 6
4 6
4 7
4 7
5 6
6 7
5 8
5 8
6 8
6 9
7 9
8 9
9 2
0 0
1 3
3 4
3 4
4 2
0 0
| OK
NG
| 12,428 |
s887316502 | p00086 | u912237403 | 1398516190 | Python | Python | py | Accepted | 20 | 4220 | 261 | def f():
c=[0]*101
while 1:
a,b=map(int,raw_input().split())
if a==b==0:break
c[a]+=1
c[b]+=1
f=0
if c[1]%2==c[2]%2==1:
for e in c[3:]:
if e%2:break
else:f=1
print ["NG","OK"][f]
return
while 1:
try:f()
except:break | p00086 |
<H1>パトロール</H1>
<p>
文久２（1862）年、会津の殿様が京都守護職を命ぜられました。京都守護職とは治安の悪化した幕末の京都を守る大切な役目です。幕府や他の藩と分担して市中をパトロールしなければなりません。ところがいざ分担ルートを決める段になって、家臣の中でも有名な頑固者の古老から以下のような注文がつきました。
</p>
<center>
<img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_14_1">
</center>
<br/>
<p>
大変なことになりました。殿様といえどもこの家臣の言い分を無視するわけにはいきません。分担ルートの選択によっては、「武士の面目が立たない」ということになってしまいます。
</p>
<p>
ということで、スタート地点、ゴール地点、交差点の情報を入力として、上の三つの条件を満たすかどうかを判定するプログラムを作って、殿様に献上してください。
</p>
<p>
スタート地点を 1、ゴール地点を2、その他の交差点を 3 以上の整数で表します。1つの道路は、その道が結ぶ1組の交差点番号で表します。なお、交差点の数は 100 以下とし、全ての交差点からスタート地点およびゴール地点への経路がそれぞれ一つ以上あるものとします。
</p>
<H2>入力</H2>
<p>複数のデータセットが与えられます。各データセットは以下の形式で与えられます。</p>
<pre>
<var>a<sub>1</sub></var> <var>b<sub>1</sub></var>
<var>a<sub>2</sub></var> <var>b<sub>2</sub></var>
：
：
<var>0</var> <var>0</var>
</pre>
<p>
各行の２つの整数は、交差点 <var>a<sub>i</sub></var> と交差点 <var>b<sub>i</sub></var> とをつなぐ道路が存在することを示します。
<var>a<sub>i</sub></var> と <var>b<sub>i</sub></var> がともに 0 のとき交差点情報の入力の終わりを示します。
</p>
<p>
データセットの数は50を超えません。
</p>
<H2>出力</H2>
<p>
各データセットに対して、武士の面目が立つ場合（三つの条件を満たす場合）OK、それ以外の場合（三つの条件を満たさない場合）NG と１行に出力してください。
</p>
<H2>Sample Input</H2>
<pre>
1 3
3 4
3 5
3 6
4 6
4 7
4 7
5 6
6 7
5 8
5 8
6 8
6 9
7 9
8 9
9 2
0 0
1 3
3 4
3 4
4 2
0 0
</pre>
<H2>Output for the Sample Input</H2>
<pre>
OK
NG
</pre>
<img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_14_2">
<img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_14_3">
<img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_14_4">
| 1 3
3 4
3 5
3 6
4 6
4 7
4 7
5 6
6 7
5 8
5 8
6 8
6 9
7 9
8 9
9 2
0 0
1 3
3 4
3 4
4 2
0 0
| OK
NG
| 12,429 |
s768475145 | p00086 | u912237403 | 1398516849 | Python | Python | py | Accepted | 20 | 4216 | 241 | while 1:
try:
c=[0]*101
while 1:
a,b=map(int,raw_input().split())
if a==b==0:break
c[a]+=1
c[b]+=1
c=map(lambda x:x%2,c)
if c[1]==1==c[2] and sum(c[3:])==0:print"OK"
else:print"NG"
except:break | p00086 |
<H1>パトロール</H1>
<p>
文久２（1862）年、会津の殿様が京都守護職を命ぜられました。京都守護職とは治安の悪化した幕末の京都を守る大切な役目です。幕府や他の藩と分担して市中をパトロールしなければなりません。ところがいざ分担ルートを決める段になって、家臣の中でも有名な頑固者の古老から以下のような注文がつきました。
</p>
<center>
<img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_14_1">
</center>
<br/>
<p>
大変なことになりました。殿様といえどもこの家臣の言い分を無視するわけにはいきません。分担ルートの選択によっては、「武士の面目が立たない」ということになってしまいます。
</p>
<p>
ということで、スタート地点、ゴール地点、交差点の情報を入力として、上の三つの条件を満たすかどうかを判定するプログラムを作って、殿様に献上してください。
</p>
<p>
スタート地点を 1、ゴール地点を2、その他の交差点を 3 以上の整数で表します。1つの道路は、その道が結ぶ1組の交差点番号で表します。なお、交差点の数は 100 以下とし、全ての交差点からスタート地点およびゴール地点への経路がそれぞれ一つ以上あるものとします。
</p>
<H2>入力</H2>
<p>複数のデータセットが与えられます。各データセットは以下の形式で与えられます。</p>
<pre>
<var>a<sub>1</sub></var> <var>b<sub>1</sub></var>
<var>a<sub>2</sub></var> <var>b<sub>2</sub></var>
：
：
<var>0</var> <var>0</var>
</pre>
<p>
各行の２つの整数は、交差点 <var>a<sub>i</sub></var> と交差点 <var>b<sub>i</sub></var> とをつなぐ道路が存在することを示します。
<var>a<sub>i</sub></var> と <var>b<sub>i</sub></var> がともに 0 のとき交差点情報の入力の終わりを示します。
</p>
<p>
データセットの数は50を超えません。
</p>
<H2>出力</H2>
<p>
各データセットに対して、武士の面目が立つ場合（三つの条件を満たす場合）OK、それ以外の場合（三つの条件を満たさない場合）NG と１行に出力してください。
</p>
<H2>Sample Input</H2>
<pre>
1 3
3 4
3 5
3 6
4 6
4 7
4 7
5 6
6 7
5 8
5 8
6 8
6 9
7 9
8 9
9 2
0 0
1 3
3 4
3 4
4 2
0 0
</pre>
<H2>Output for the Sample Input</H2>
<pre>
OK
NG
</pre>
<img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_14_2">
<img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_14_3">
<img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_14_4">
| 1 3
3 4
3 5
3 6
4 6
4 7
4 7
5 6
6 7
5 8
5 8
6 8
6 9
7 9
8 9
9 2
0 0
1 3
3 4
3 4
4 2
0 0
| OK
NG
| 12,430 |
s558433145 | p00086 | u912237403 | 1398516886 | Python | Python | py | Accepted | 20 | 4216 | 245 | while 1:
try:
c=[0]*101
while 1:
a,b=map(int,raw_input().split())
if a==b==0: break
c[a]+=1
c[b]+=1
c=map(lambda x:x%2,c)
if c[1]==1==c[2] and sum(c[3:])==0: print"OK"
else: print"NG"
except: break | p00086 |
<H1>パトロール</H1>
<p>
文久２（1862）年、会津の殿様が京都守護職を命ぜられました。京都守護職とは治安の悪化した幕末の京都を守る大切な役目です。幕府や他の藩と分担して市中をパトロールしなければなりません。ところがいざ分担ルートを決める段になって、家臣の中でも有名な頑固者の古老から以下のような注文がつきました。
</p>
<center>
<img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_14_1">
</center>
<br/>
<p>
大変なことになりました。殿様といえどもこの家臣の言い分を無視するわけにはいきません。分担ルートの選択によっては、「武士の面目が立たない」ということになってしまいます。
</p>
<p>
ということで、スタート地点、ゴール地点、交差点の情報を入力として、上の三つの条件を満たすかどうかを判定するプログラムを作って、殿様に献上してください。
</p>
<p>
スタート地点を 1、ゴール地点を2、その他の交差点を 3 以上の整数で表します。1つの道路は、その道が結ぶ1組の交差点番号で表します。なお、交差点の数は 100 以下とし、全ての交差点からスタート地点およびゴール地点への経路がそれぞれ一つ以上あるものとします。
</p>
<H2>入力</H2>
<p>複数のデータセットが与えられます。各データセットは以下の形式で与えられます。</p>
<pre>
<var>a<sub>1</sub></var> <var>b<sub>1</sub></var>
<var>a<sub>2</sub></var> <var>b<sub>2</sub></var>
：
：
<var>0</var> <var>0</var>
</pre>
<p>
各行の２つの整数は、交差点 <var>a<sub>i</sub></var> と交差点 <var>b<sub>i</sub></var> とをつなぐ道路が存在することを示します。
<var>a<sub>i</sub></var> と <var>b<sub>i</sub></var> がともに 0 のとき交差点情報の入力の終わりを示します。
</p>
<p>
データセットの数は50を超えません。
</p>
<H2>出力</H2>
<p>
各データセットに対して、武士の面目が立つ場合（三つの条件を満たす場合）OK、それ以外の場合（三つの条件を満たさない場合）NG と１行に出力してください。
</p>
<H2>Sample Input</H2>
<pre>
1 3
3 4
3 5
3 6
4 6
4 7
4 7
5 6
6 7
5 8
5 8
6 8
6 9
7 9
8 9
9 2
0 0
1 3
3 4
3 4
4 2
0 0
</pre>
<H2>Output for the Sample Input</H2>
<pre>
OK
NG
</pre>
<img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_14_2">
<img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_14_3">
<img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_14_4">
| 1 3
3 4
3 5
3 6
4 6
4 7
4 7
5 6
6 7
5 8
5 8
6 8
6 9
7 9
8 9
9 2
0 0
1 3
3 4
3 4
4 2
0 0
| OK
NG
| 12,431 |
s841303498 | p00086 | u912237403 | 1398517395 | Python | Python | py | Accepted | 20 | 4216 | 255 | while 1:
try:
c = [0]*101
while 1:
a, b = map(int, raw_input().split())
if a==0==b:break
c[a] += 1
c[b] += 1
c = map(lambda x: x%2, c)
if c[1] and c[2] and sum(c[3:])==0:print"OK"
else:print"NG"
except:break | p00086 |
<H1>パトロール</H1>
<p>
文久２（1862）年、会津の殿様が京都守護職を命ぜられました。京都守護職とは治安の悪化した幕末の京都を守る大切な役目です。幕府や他の藩と分担して市中をパトロールしなければなりません。ところがいざ分担ルートを決める段になって、家臣の中でも有名な頑固者の古老から以下のような注文がつきました。
</p>
<center>
<img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_14_1">
</center>
<br/>
<p>
大変なことになりました。殿様といえどもこの家臣の言い分を無視するわけにはいきません。分担ルートの選択によっては、「武士の面目が立たない」ということになってしまいます。
</p>
<p>
ということで、スタート地点、ゴール地点、交差点の情報を入力として、上の三つの条件を満たすかどうかを判定するプログラムを作って、殿様に献上してください。
</p>
<p>
スタート地点を 1、ゴール地点を2、その他の交差点を 3 以上の整数で表します。1つの道路は、その道が結ぶ1組の交差点番号で表します。なお、交差点の数は 100 以下とし、全ての交差点からスタート地点およびゴール地点への経路がそれぞれ一つ以上あるものとします。
</p>
<H2>入力</H2>
<p>複数のデータセットが与えられます。各データセットは以下の形式で与えられます。</p>
<pre>
<var>a<sub>1</sub></var> <var>b<sub>1</sub></var>
<var>a<sub>2</sub></var> <var>b<sub>2</sub></var>
：
：
<var>0</var> <var>0</var>
</pre>
<p>
各行の２つの整数は、交差点 <var>a<sub>i</sub></var> と交差点 <var>b<sub>i</sub></var> とをつなぐ道路が存在することを示します。
<var>a<sub>i</sub></var> と <var>b<sub>i</sub></var> がともに 0 のとき交差点情報の入力の終わりを示します。
</p>
<p>
データセットの数は50を超えません。
</p>
<H2>出力</H2>
<p>
各データセットに対して、武士の面目が立つ場合（三つの条件を満たす場合）OK、それ以外の場合（三つの条件を満たさない場合）NG と１行に出力してください。
</p>
<H2>Sample Input</H2>
<pre>
1 3
3 4
3 5
3 6
4 6
4 7
4 7
5 6
6 7
5 8
5 8
6 8
6 9
7 9
8 9
9 2
0 0
1 3
3 4
3 4
4 2
0 0
</pre>
<H2>Output for the Sample Input</H2>
<pre>
OK
NG
</pre>
<img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_14_2">
<img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_14_3">
<img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_14_4">
| 1 3
3 4
3 5
3 6
4 6
4 7
4 7
5 6
6 7
5 8
5 8
6 8
6 9
7 9
8 9
9 2
0 0
1 3
3 4
3 4
4 2
0 0
| OK
NG
| 12,432 |
s765370983 | p00086 | u912237403 | 1398517407 | Python | Python | py | Accepted | 20 | 4212 | 255 | while 1:
try:
c = [0]*101
while 1:
a, b = map(int, raw_input().split())
if a==0==b:break
c[a] += 1
c[b] += 1
c = map(lambda x: x%2, c)
if c[1] and c[2] and sum(c[3:])==0:print"OK"
else:print"NG"
except:break | p00086 |
<H1>パトロール</H1>
<p>
文久２（1862）年、会津の殿様が京都守護職を命ぜられました。京都守護職とは治安の悪化した幕末の京都を守る大切な役目です。幕府や他の藩と分担して市中をパトロールしなければなりません。ところがいざ分担ルートを決める段になって、家臣の中でも有名な頑固者の古老から以下のような注文がつきました。
</p>
<center>
<img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_14_1">
</center>
<br/>
<p>
大変なことになりました。殿様といえどもこの家臣の言い分を無視するわけにはいきません。分担ルートの選択によっては、「武士の面目が立たない」ということになってしまいます。
</p>
<p>
ということで、スタート地点、ゴール地点、交差点の情報を入力として、上の三つの条件を満たすかどうかを判定するプログラムを作って、殿様に献上してください。
</p>
<p>
スタート地点を 1、ゴール地点を2、その他の交差点を 3 以上の整数で表します。1つの道路は、その道が結ぶ1組の交差点番号で表します。なお、交差点の数は 100 以下とし、全ての交差点からスタート地点およびゴール地点への経路がそれぞれ一つ以上あるものとします。
</p>
<H2>入力</H2>
<p>複数のデータセットが与えられます。各データセットは以下の形式で与えられます。</p>
<pre>
<var>a<sub>1</sub></var> <var>b<sub>1</sub></var>
<var>a<sub>2</sub></var> <var>b<sub>2</sub></var>
：
：
<var>0</var> <var>0</var>
</pre>
<p>
各行の２つの整数は、交差点 <var>a<sub>i</sub></var> と交差点 <var>b<sub>i</sub></var> とをつなぐ道路が存在することを示します。
<var>a<sub>i</sub></var> と <var>b<sub>i</sub></var> がともに 0 のとき交差点情報の入力の終わりを示します。
</p>
<p>
データセットの数は50を超えません。
</p>
<H2>出力</H2>
<p>
各データセットに対して、武士の面目が立つ場合（三つの条件を満たす場合）OK、それ以外の場合（三つの条件を満たさない場合）NG と１行に出力してください。
</p>
<H2>Sample Input</H2>
<pre>
1 3
3 4
3 5
3 6
4 6
4 7
4 7
5 6
6 7
5 8
5 8
6 8
6 9
7 9
8 9
9 2
0 0
1 3
3 4
3 4
4 2
0 0
</pre>
<H2>Output for the Sample Input</H2>
<pre>
OK
NG
</pre>
<img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_14_2">
<img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_14_3">
<img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_14_4">
| 1 3
3 4
3 5
3 6
4 6
4 7
4 7
5 6
6 7
5 8
5 8
6 8
6 9
7 9
8 9
9 2
0 0
1 3
3 4
3 4
4 2
0 0
| OK
NG
| 12,433 |
s582163763 | p00086 | u912237403 | 1398521223 | Python | Python | py | Accepted | 20 | 4204 | 220 | try:
while 1:
c=[0,1,1]+[0]*98
while 1:
a, b = map(int, raw_input().split())
if a==0==b:break
c[a] = -c[a]+1
c[b] = -c[b]+1
if c.count(1): print "NG"
else: print "OK"
except:exit | p00086 |
<H1>パトロール</H1>
<p>
文久２（1862）年、会津の殿様が京都守護職を命ぜられました。京都守護職とは治安の悪化した幕末の京都を守る大切な役目です。幕府や他の藩と分担して市中をパトロールしなければなりません。ところがいざ分担ルートを決める段になって、家臣の中でも有名な頑固者の古老から以下のような注文がつきました。
</p>
<center>
<img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_14_1">
</center>
<br/>
<p>
大変なことになりました。殿様といえどもこの家臣の言い分を無視するわけにはいきません。分担ルートの選択によっては、「武士の面目が立たない」ということになってしまいます。
</p>
<p>
ということで、スタート地点、ゴール地点、交差点の情報を入力として、上の三つの条件を満たすかどうかを判定するプログラムを作って、殿様に献上してください。
</p>
<p>
スタート地点を 1、ゴール地点を2、その他の交差点を 3 以上の整数で表します。1つの道路は、その道が結ぶ1組の交差点番号で表します。なお、交差点の数は 100 以下とし、全ての交差点からスタート地点およびゴール地点への経路がそれぞれ一つ以上あるものとします。
</p>
<H2>入力</H2>
<p>複数のデータセットが与えられます。各データセットは以下の形式で与えられます。</p>
<pre>
<var>a<sub>1</sub></var> <var>b<sub>1</sub></var>
<var>a<sub>2</sub></var> <var>b<sub>2</sub></var>
：
：
<var>0</var> <var>0</var>
</pre>
<p>
各行の２つの整数は、交差点 <var>a<sub>i</sub></var> と交差点 <var>b<sub>i</sub></var> とをつなぐ道路が存在することを示します。
<var>a<sub>i</sub></var> と <var>b<sub>i</sub></var> がともに 0 のとき交差点情報の入力の終わりを示します。
</p>
<p>
データセットの数は50を超えません。
</p>
<H2>出力</H2>
<p>
各データセットに対して、武士の面目が立つ場合（三つの条件を満たす場合）OK、それ以外の場合（三つの条件を満たさない場合）NG と１行に出力してください。
</p>
<H2>Sample Input</H2>
<pre>
1 3
3 4
3 5
3 6
4 6
4 7
4 7
5 6
6 7
5 8
5 8
6 8
6 9
7 9
8 9
9 2
0 0
1 3
3 4
3 4
4 2
0 0
</pre>
<H2>Output for the Sample Input</H2>
<pre>
OK
NG
</pre>
<img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_14_2">
<img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_14_3">
<img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_14_4">
| 1 3
3 4
3 5
3 6
4 6
4 7
4 7
5 6
6 7
5 8
5 8
6 8
6 9
7 9
8 9
9 2
0 0
1 3
3 4
3 4
4 2
0 0
| OK
NG
| 12,434 |
s169458172 | p00086 | u912237403 | 1398521638 | Python | Python | py | Accepted | 20 | 4208 | 209 | while 1:
c=[0,1,1]+[0]*98
while 1:
try: a, b = map(int, raw_input().split())
except: exit()
if a==0==b:break
c[a] = -c[a]+1
c[b] = -c[b]+1
if c.count(1): print "NG"
else: print "OK" | p00086 |
<H1>パトロール</H1>
<p>
文久２（1862）年、会津の殿様が京都守護職を命ぜられました。京都守護職とは治安の悪化した幕末の京都を守る大切な役目です。幕府や他の藩と分担して市中をパトロールしなければなりません。ところがいざ分担ルートを決める段になって、家臣の中でも有名な頑固者の古老から以下のような注文がつきました。
</p>
<center>
<img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_14_1">
</center>
<br/>
<p>
大変なことになりました。殿様といえどもこの家臣の言い分を無視するわけにはいきません。分担ルートの選択によっては、「武士の面目が立たない」ということになってしまいます。
</p>
<p>
ということで、スタート地点、ゴール地点、交差点の情報を入力として、上の三つの条件を満たすかどうかを判定するプログラムを作って、殿様に献上してください。
</p>
<p>
スタート地点を 1、ゴール地点を2、その他の交差点を 3 以上の整数で表します。1つの道路は、その道が結ぶ1組の交差点番号で表します。なお、交差点の数は 100 以下とし、全ての交差点からスタート地点およびゴール地点への経路がそれぞれ一つ以上あるものとします。
</p>
<H2>入力</H2>
<p>複数のデータセットが与えられます。各データセットは以下の形式で与えられます。</p>
<pre>
<var>a<sub>1</sub></var> <var>b<sub>1</sub></var>
<var>a<sub>2</sub></var> <var>b<sub>2</sub></var>
：
：
<var>0</var> <var>0</var>
</pre>
<p>
各行の２つの整数は、交差点 <var>a<sub>i</sub></var> と交差点 <var>b<sub>i</sub></var> とをつなぐ道路が存在することを示します。
<var>a<sub>i</sub></var> と <var>b<sub>i</sub></var> がともに 0 のとき交差点情報の入力の終わりを示します。
</p>
<p>
データセットの数は50を超えません。
</p>
<H2>出力</H2>
<p>
各データセットに対して、武士の面目が立つ場合（三つの条件を満たす場合）OK、それ以外の場合（三つの条件を満たさない場合）NG と１行に出力してください。
</p>
<H2>Sample Input</H2>
<pre>
1 3
3 4
3 5
3 6
4 6
4 7
4 7
5 6
6 7
5 8
5 8
6 8
6 9
7 9
8 9
9 2
0 0
1 3
3 4
3 4
4 2
0 0
</pre>
<H2>Output for the Sample Input</H2>
<pre>
OK
NG
</pre>
<img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_14_2">
<img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_14_3">
<img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_14_4">
| 1 3
3 4
3 5
3 6
4 6
4 7
4 7
5 6
6 7
5 8
5 8
6 8
6 9
7 9
8 9
9 2
0 0
1 3
3 4
3 4
4 2
0 0
| OK
NG
| 12,435 |
s667130244 | p00086 | u912237403 | 1398522485 | Python | Python | py | Accepted | 20 | 4212 | 193 | while 1:
c=[0,1,1]+[0]*98
while 1:
try: a, b = map(int, raw_input().split())
except: exit()
if a==0==b:break
c[a] = -c[a]+1
c[b] = -c[b]+1
print ["NG","OK"][sum(c)==0] | p00086 |
<H1>パトロール</H1>
<p>
文久２（1862）年、会津の殿様が京都守護職を命ぜられました。京都守護職とは治安の悪化した幕末の京都を守る大切な役目です。幕府や他の藩と分担して市中をパトロールしなければなりません。ところがいざ分担ルートを決める段になって、家臣の中でも有名な頑固者の古老から以下のような注文がつきました。
</p>
<center>
<img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_14_1">
</center>
<br/>
<p>
大変なことになりました。殿様といえどもこの家臣の言い分を無視するわけにはいきません。分担ルートの選択によっては、「武士の面目が立たない」ということになってしまいます。
</p>
<p>
ということで、スタート地点、ゴール地点、交差点の情報を入力として、上の三つの条件を満たすかどうかを判定するプログラムを作って、殿様に献上してください。
</p>
<p>
スタート地点を 1、ゴール地点を2、その他の交差点を 3 以上の整数で表します。1つの道路は、その道が結ぶ1組の交差点番号で表します。なお、交差点の数は 100 以下とし、全ての交差点からスタート地点およびゴール地点への経路がそれぞれ一つ以上あるものとします。
</p>
<H2>入力</H2>
<p>複数のデータセットが与えられます。各データセットは以下の形式で与えられます。</p>
<pre>
<var>a<sub>1</sub></var> <var>b<sub>1</sub></var>
<var>a<sub>2</sub></var> <var>b<sub>2</sub></var>
：
：
<var>0</var> <var>0</var>
</pre>
<p>
各行の２つの整数は、交差点 <var>a<sub>i</sub></var> と交差点 <var>b<sub>i</sub></var> とをつなぐ道路が存在することを示します。
<var>a<sub>i</sub></var> と <var>b<sub>i</sub></var> がともに 0 のとき交差点情報の入力の終わりを示します。
</p>
<p>
データセットの数は50を超えません。
</p>
<H2>出力</H2>
<p>
各データセットに対して、武士の面目が立つ場合（三つの条件を満たす場合）OK、それ以外の場合（三つの条件を満たさない場合）NG と１行に出力してください。
</p>
<H2>Sample Input</H2>
<pre>
1 3
3 4
3 5
3 6
4 6
4 7
4 7
5 6
6 7
5 8
5 8
6 8
6 9
7 9
8 9
9 2
0 0
1 3
3 4
3 4
4 2
0 0
</pre>
<H2>Output for the Sample Input</H2>
<pre>
OK
NG
</pre>
<img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_14_2">
<img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_14_3">
<img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_14_4">
| 1 3
3 4
3 5
3 6
4 6
4 7
4 7
5 6
6 7
5 8
5 8
6 8
6 9
7 9
8 9
9 2
0 0
1 3
3 4
3 4
4 2
0 0
| OK
NG
| 12,436 |
s316461005 | p00086 | u912237403 | 1398522602 | Python | Python | py | Accepted | 10 | 4212 | 191 | while 1:
c=[0,1,1]+[0]*98
while 1:
try: a, b = map(int, raw_input().split())
except: exit()
if a==0==b:break
c[a] = 1-c[a]
c[b] = 1-c[b]
print ["NG","OK"][sum(c)==0] | p00086 |
<H1>パトロール</H1>
<p>
文久２（1862）年、会津の殿様が京都守護職を命ぜられました。京都守護職とは治安の悪化した幕末の京都を守る大切な役目です。幕府や他の藩と分担して市中をパトロールしなければなりません。ところがいざ分担ルートを決める段になって、家臣の中でも有名な頑固者の古老から以下のような注文がつきました。
</p>
<center>
<img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_14_1">
</center>
<br/>
<p>
大変なことになりました。殿様といえどもこの家臣の言い分を無視するわけにはいきません。分担ルートの選択によっては、「武士の面目が立たない」ということになってしまいます。
</p>
<p>
ということで、スタート地点、ゴール地点、交差点の情報を入力として、上の三つの条件を満たすかどうかを判定するプログラムを作って、殿様に献上してください。
</p>
<p>
スタート地点を 1、ゴール地点を2、その他の交差点を 3 以上の整数で表します。1つの道路は、その道が結ぶ1組の交差点番号で表します。なお、交差点の数は 100 以下とし、全ての交差点からスタート地点およびゴール地点への経路がそれぞれ一つ以上あるものとします。
</p>
<H2>入力</H2>
<p>複数のデータセットが与えられます。各データセットは以下の形式で与えられます。</p>
<pre>
<var>a<sub>1</sub></var> <var>b<sub>1</sub></var>
<var>a<sub>2</sub></var> <var>b<sub>2</sub></var>
：
：
<var>0</var> <var>0</var>
</pre>
<p>
各行の２つの整数は、交差点 <var>a<sub>i</sub></var> と交差点 <var>b<sub>i</sub></var> とをつなぐ道路が存在することを示します。
<var>a<sub>i</sub></var> と <var>b<sub>i</sub></var> がともに 0 のとき交差点情報の入力の終わりを示します。
</p>
<p>
データセットの数は50を超えません。
</p>
<H2>出力</H2>
<p>
各データセットに対して、武士の面目が立つ場合（三つの条件を満たす場合）OK、それ以外の場合（三つの条件を満たさない場合）NG と１行に出力してください。
</p>
<H2>Sample Input</H2>
<pre>
1 3
3 4
3 5
3 6
4 6
4 7
4 7
5 6
6 7
5 8
5 8
6 8
6 9
7 9
8 9
9 2
0 0
1 3
3 4
3 4
4 2
0 0
</pre>
<H2>Output for the Sample Input</H2>
<pre>
OK
NG
</pre>
<img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_14_2">
<img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_14_3">
<img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_14_4">
| 1 3
3 4
3 5
3 6
4 6
4 7
4 7
5 6
6 7
5 8
5 8
6 8
6 9
7 9
8 9
9 2
0 0
1 3
3 4
3 4
4 2
0 0
| OK
NG
| 12,437 |
s575038173 | p00086 | u912237403 | 1398522660 | Python | Python | py | Accepted | 20 | 4216 | 180 | while 1:
c=[0,1,1]+[0]*98
while 1:
try:a,b=map(int,raw_input().split())
except:exit()
if a==0==b:break
c[a]=1-c[a]
c[b]=1-c[b]
print["NG","OK"][sum(c)==0] | p00086 |
<H1>パトロール</H1>
<p>
文久２（1862）年、会津の殿様が京都守護職を命ぜられました。京都守護職とは治安の悪化した幕末の京都を守る大切な役目です。幕府や他の藩と分担して市中をパトロールしなければなりません。ところがいざ分担ルートを決める段になって、家臣の中でも有名な頑固者の古老から以下のような注文がつきました。
</p>
<center>
<img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_14_1">
</center>
<br/>
<p>
大変なことになりました。殿様といえどもこの家臣の言い分を無視するわけにはいきません。分担ルートの選択によっては、「武士の面目が立たない」ということになってしまいます。
</p>
<p>
ということで、スタート地点、ゴール地点、交差点の情報を入力として、上の三つの条件を満たすかどうかを判定するプログラムを作って、殿様に献上してください。
</p>
<p>
スタート地点を 1、ゴール地点を2、その他の交差点を 3 以上の整数で表します。1つの道路は、その道が結ぶ1組の交差点番号で表します。なお、交差点の数は 100 以下とし、全ての交差点からスタート地点およびゴール地点への経路がそれぞれ一つ以上あるものとします。
</p>
<H2>入力</H2>
<p>複数のデータセットが与えられます。各データセットは以下の形式で与えられます。</p>
<pre>
<var>a<sub>1</sub></var> <var>b<sub>1</sub></var>
<var>a<sub>2</sub></var> <var>b<sub>2</sub></var>
：
：
<var>0</var> <var>0</var>
</pre>
<p>
各行の２つの整数は、交差点 <var>a<sub>i</sub></var> と交差点 <var>b<sub>i</sub></var> とをつなぐ道路が存在することを示します。
<var>a<sub>i</sub></var> と <var>b<sub>i</sub></var> がともに 0 のとき交差点情報の入力の終わりを示します。
</p>
<p>
データセットの数は50を超えません。
</p>
<H2>出力</H2>
<p>
各データセットに対して、武士の面目が立つ場合（三つの条件を満たす場合）OK、それ以外の場合（三つの条件を満たさない場合）NG と１行に出力してください。
</p>
<H2>Sample Input</H2>
<pre>
1 3
3 4
3 5
3 6
4 6
4 7
4 7
5 6
6 7
5 8
5 8
6 8
6 9
7 9
8 9
9 2
0 0
1 3
3 4
3 4
4 2
0 0
</pre>
<H2>Output for the Sample Input</H2>
<pre>
OK
NG
</pre>
<img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_14_2">
<img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_14_3">
<img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_14_4">
| 1 3
3 4
3 5
3 6
4 6
4 7
4 7
5 6
6 7
5 8
5 8
6 8
6 9
7 9
8 9
9 2
0 0
1 3
3 4
3 4
4 2
0 0
| OK
NG
| 12,438 |
s237726739 | p00086 | u491763171 | 1401195997 | Python | Python | py | Accepted | 20 | 4224 | 439 | while 1:
edges = [0] * 101
try:
a, b = map(int, raw_input().split())
edges[a] += 1
edges[b] += 1
except EOFError:
break
while 1:
a, b = map(int, raw_input().split())
if a == b == 0:
break
edges[a] += 1
edges[b] += 1
if edges[1] % 2 and edges[2] % 2 and all(map(lambda a: a % 2 == 0, edges[3:])):
print "OK"
else:
print "NG" | p00086 |
<H1>パトロール</H1>
<p>
文久２（1862）年、会津の殿様が京都守護職を命ぜられました。京都守護職とは治安の悪化した幕末の京都を守る大切な役目です。幕府や他の藩と分担して市中をパトロールしなければなりません。ところがいざ分担ルートを決める段になって、家臣の中でも有名な頑固者の古老から以下のような注文がつきました。
</p>
<center>
<img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_14_1">
</center>
<br/>
<p>
大変なことになりました。殿様といえどもこの家臣の言い分を無視するわけにはいきません。分担ルートの選択によっては、「武士の面目が立たない」ということになってしまいます。
</p>
<p>
ということで、スタート地点、ゴール地点、交差点の情報を入力として、上の三つの条件を満たすかどうかを判定するプログラムを作って、殿様に献上してください。
</p>
<p>
スタート地点を 1、ゴール地点を2、その他の交差点を 3 以上の整数で表します。1つの道路は、その道が結ぶ1組の交差点番号で表します。なお、交差点の数は 100 以下とし、全ての交差点からスタート地点およびゴール地点への経路がそれぞれ一つ以上あるものとします。
</p>
<H2>入力</H2>
<p>複数のデータセットが与えられます。各データセットは以下の形式で与えられます。</p>
<pre>
<var>a<sub>1</sub></var> <var>b<sub>1</sub></var>
<var>a<sub>2</sub></var> <var>b<sub>2</sub></var>
：
：
<var>0</var> <var>0</var>
</pre>
<p>
各行の２つの整数は、交差点 <var>a<sub>i</sub></var> と交差点 <var>b<sub>i</sub></var> とをつなぐ道路が存在することを示します。
<var>a<sub>i</sub></var> と <var>b<sub>i</sub></var> がともに 0 のとき交差点情報の入力の終わりを示します。
</p>
<p>
データセットの数は50を超えません。
</p>
<H2>出力</H2>
<p>
各データセットに対して、武士の面目が立つ場合（三つの条件を満たす場合）OK、それ以外の場合（三つの条件を満たさない場合）NG と１行に出力してください。
</p>
<H2>Sample Input</H2>
<pre>
1 3
3 4
3 5
3 6
4 6
4 7
4 7
5 6
6 7
5 8
5 8
6 8
6 9
7 9
8 9
9 2
0 0
1 3
3 4
3 4
4 2
0 0
</pre>
<H2>Output for the Sample Input</H2>
<pre>
OK
NG
</pre>
<img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_14_2">
<img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_14_3">
<img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_14_4">
| 1 3
3 4
3 5
3 6
4 6
4 7
4 7
5 6
6 7
5 8
5 8
6 8
6 9
7 9
8 9
9 2
0 0
1 3
3 4
3 4
4 2
0 0
| OK
NG
| 12,439 |
s818317718 | p00086 | u822971508 | 1401201032 | Python | Python | py | Accepted | 20 | 4220 | 566 | #coding:utf-8
while 1:
try:
#初期化
key=[0]*101
#オイラー路：すべての頂点のうち、次数が奇数であるものがちょうど２つ(入口と出口)
while 1:
input = map(int, raw_input().split())
if(input[0] == 0 and input[1] == 0):
break
key[input[0]]+=1
key[input[1]]+=1
if(key[1]%2 == 1 and key[2]%2==1 and len(filter(lambda x:x%2==1,key[3:]))==0):
print "OK"
else:
print "NG"
except:
break | p00086 |
<H1>パトロール</H1>
<p>
文久２（1862）年、会津の殿様が京都守護職を命ぜられました。京都守護職とは治安の悪化した幕末の京都を守る大切な役目です。幕府や他の藩と分担して市中をパトロールしなければなりません。ところがいざ分担ルートを決める段になって、家臣の中でも有名な頑固者の古老から以下のような注文がつきました。
</p>
<center>
<img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_14_1">
</center>
<br/>
<p>
大変なことになりました。殿様といえどもこの家臣の言い分を無視するわけにはいきません。分担ルートの選択によっては、「武士の面目が立たない」ということになってしまいます。
</p>
<p>
ということで、スタート地点、ゴール地点、交差点の情報を入力として、上の三つの条件を満たすかどうかを判定するプログラムを作って、殿様に献上してください。
</p>
<p>
スタート地点を 1、ゴール地点を2、その他の交差点を 3 以上の整数で表します。1つの道路は、その道が結ぶ1組の交差点番号で表します。なお、交差点の数は 100 以下とし、全ての交差点からスタート地点およびゴール地点への経路がそれぞれ一つ以上あるものとします。
</p>
<H2>入力</H2>
<p>複数のデータセットが与えられます。各データセットは以下の形式で与えられます。</p>
<pre>
<var>a<sub>1</sub></var> <var>b<sub>1</sub></var>
<var>a<sub>2</sub></var> <var>b<sub>2</sub></var>
：
：
<var>0</var> <var>0</var>
</pre>
<p>
各行の２つの整数は、交差点 <var>a<sub>i</sub></var> と交差点 <var>b<sub>i</sub></var> とをつなぐ道路が存在することを示します。
<var>a<sub>i</sub></var> と <var>b<sub>i</sub></var> がともに 0 のとき交差点情報の入力の終わりを示します。
</p>
<p>
データセットの数は50を超えません。
</p>
<H2>出力</H2>
<p>
各データセットに対して、武士の面目が立つ場合（三つの条件を満たす場合）OK、それ以外の場合（三つの条件を満たさない場合）NG と１行に出力してください。
</p>
<H2>Sample Input</H2>
<pre>
1 3
3 4
3 5
3 6
4 6
4 7
4 7
5 6
6 7
5 8
5 8
6 8
6 9
7 9
8 9
9 2
0 0
1 3
3 4
3 4
4 2
0 0
</pre>
<H2>Output for the Sample Input</H2>
<pre>
OK
NG
</pre>
<img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_14_2">
<img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_14_3">
<img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_14_4">
| 1 3
3 4
3 5
3 6
4 6
4 7
4 7
5 6
6 7
5 8
5 8
6 8
6 9
7 9
8 9
9 2
0 0
1 3
3 4
3 4
4 2
0 0
| OK
NG
| 12,440 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.