submission_id string | problem_id string | status string | code string | input string | output string | problem_description string |
|---|---|---|---|---|---|---|
s542593195 | p00038 | Accepted | HANDS = {
'one pair': [1,1,1,2],
'two pair': [1,2,2],
'three card': [1,1,3],
'four card': [1,4],
'full house': [2,3],
}
def check(key, value):
for (k, v) in HANDS.iteritems():
if value == v:
return k
if key[-1] - key[0] == 4 or key == [1, 10, 11, 12, 13]:
return 'straight'
else:
return 'null'
while True:
try:
cards = map(int, raw_input().split(','))
m = {}
for n in cards:
if m.has_key(n):
m[n] += 1
else:
m[n] = 1
print check(sorted(m.keys()), sorted(m.values()))
except EOFError:
break | 1,2,3,4,1
2,3,2,3,12
12,13,11,12,12
7,6,7,6,7
3,3,2,3,3
6,7,8,9,10
11,12,10,1,13
11,12,13,1,2
| one pair
two pair
three card
full house
four card
straight
straight
null
|
<H1>ポーカー</H1>
<p>
ポーカーの手札データを読み込んで、それぞれについてその役を出力するプログラムを作成してください。ただし、この問題では、以下のルールに従います。
</p>
<ul>
<li>ポーカーはトランプ 5 枚で行う競技です。</li>
<li>同じ数字のカードは 5 枚以上ありません。</li>
<li>ジョーカーは無いものとします。</li>
<li>以下のポーカーの役だけを考えるものとします。(番号が大きいほど役が高くなります。)</li>
</ul>
<ol style="margin-left:40px">
<li>役なし(以下に挙げるどれにも当てはまらない)</li>
<li>ワンペア（2 枚の同じ数字のカードが1 組ある）</li>
<li>ツーペア（2 枚の同じ数字のカードが2 組ある）</li>
<li>スリーカード（3 枚の同じ数字のカードが1 組ある）</li>
<li>ストレート（5 枚のカードの数字が連続している）<br>
ただし、A を含むストレートの場合、A で終わる並びもストレートとします。つまり、A を含むストレート
は、A 2 3 4 5 と 10 J Q K A の２種類です。J Q K A 2 などのように、A をまたぐ並び
はストレートではありません。（この場合、「役なし」になります）。
</li>
<li>フルハウス（3 枚の同じ数字のカードが1 組と、残りの2 枚が同じ数字のカード）</li>
<li>フォーカード（4 枚の同じ数字のカードが1 組ある）</li>
</ol>
<H2>Input</H2>
<p>
入力は複数のデータセットからなります。各データセットは以下の形式で与えられます。
</p>
<pre class=exp>
手札1,手札2,手札3,手札4,手札5
</pre>
<p>
手札は、トランプのJ(ジャック) を11、Q(クイーン) を12、K(キング) を13、A（エース）を 1、その他はそれぞれの数字で表すこととします。
</p>
<p>
データセットの数は 50 を超えません。
</p>
<H2>Output</H2>
<p>
データセットごとに、手札によってできる最も高い役をひとつ出力してください。役の表記については出力例に従ってください。
</p>
<H2>Sample Input</H2>
<pre>
1,2,3,4,1
2,3,2,3,12
12,13,11,12,12
7,6,7,6,7
3,3,2,3,3
6,7,8,9,10
11,12,10,1,13
11,12,13,1,2
</pre>
<H2>Output for the Sample Input</H2>
<pre>
one pair
two pair
three card
full house
four card
straight
straight
null
</pre>
<p>
3 3 2 3 3 という手札であったときは、two pair ではなく four card です。
</p>
|
s524135267 | p00038 | Accepted | while True:
try:
nums = [0 for x in xrange(13)]
hands = map(int,raw_input().split(','))
for val in hands: nums[val-1] += 1
if 4 in nums: print 'four card'
else:
if 3 in nums:
if 2 in nums: print 'full house'
else: print 'three card'
else:
if nums.count(2) == 2: print 'two pair'
elif nums.count(2) == 1: print 'one pair'
else:
hands2 = ''
for val in xrange(14): hands2 += str(nums[val%13])
if '11111' in hands2: print 'straight'
else: print 'null'
except: break | 1,2,3,4,1
2,3,2,3,12
12,13,11,12,12
7,6,7,6,7
3,3,2,3,3
6,7,8,9,10
11,12,10,1,13
11,12,13,1,2
| one pair
two pair
three card
full house
four card
straight
straight
null
|
<H1>ポーカー</H1>
<p>
ポーカーの手札データを読み込んで、それぞれについてその役を出力するプログラムを作成してください。ただし、この問題では、以下のルールに従います。
</p>
<ul>
<li>ポーカーはトランプ 5 枚で行う競技です。</li>
<li>同じ数字のカードは 5 枚以上ありません。</li>
<li>ジョーカーは無いものとします。</li>
<li>以下のポーカーの役だけを考えるものとします。(番号が大きいほど役が高くなります。)</li>
</ul>
<ol style="margin-left:40px">
<li>役なし(以下に挙げるどれにも当てはまらない)</li>
<li>ワンペア（2 枚の同じ数字のカードが1 組ある）</li>
<li>ツーペア（2 枚の同じ数字のカードが2 組ある）</li>
<li>スリーカード（3 枚の同じ数字のカードが1 組ある）</li>
<li>ストレート（5 枚のカードの数字が連続している）<br>
ただし、A を含むストレートの場合、A で終わる並びもストレートとします。つまり、A を含むストレート
は、A 2 3 4 5 と 10 J Q K A の２種類です。J Q K A 2 などのように、A をまたぐ並び
はストレートではありません。（この場合、「役なし」になります）。
</li>
<li>フルハウス（3 枚の同じ数字のカードが1 組と、残りの2 枚が同じ数字のカード）</li>
<li>フォーカード（4 枚の同じ数字のカードが1 組ある）</li>
</ol>
<H2>Input</H2>
<p>
入力は複数のデータセットからなります。各データセットは以下の形式で与えられます。
</p>
<pre class=exp>
手札1,手札2,手札3,手札4,手札5
</pre>
<p>
手札は、トランプのJ(ジャック) を11、Q(クイーン) を12、K(キング) を13、A（エース）を 1、その他はそれぞれの数字で表すこととします。
</p>
<p>
データセットの数は 50 を超えません。
</p>
<H2>Output</H2>
<p>
データセットごとに、手札によってできる最も高い役をひとつ出力してください。役の表記については出力例に従ってください。
</p>
<H2>Sample Input</H2>
<pre>
1,2,3,4,1
2,3,2,3,12
12,13,11,12,12
7,6,7,6,7
3,3,2,3,3
6,7,8,9,10
11,12,10,1,13
11,12,13,1,2
</pre>
<H2>Output for the Sample Input</H2>
<pre>
one pair
two pair
three card
full house
four card
straight
straight
null
</pre>
<p>
3 3 2 3 3 という手札であったときは、two pair ではなく four card です。
</p>
|
s886179051 | p00038 | Accepted |
import sys
def solv(hand):
if four_card(hand):
return "four card"
elif full_house(hand):
return "full house"
elif straight(hand):
return "straight"
elif three_card(hand):
return "three card"
elif two_pair(hand):
return "two pair"
elif one_pair(hand):
return "one pair"
else:
return "null"
def four_card(hand):
s = set(hand)
if len(s) == 2:
for c in s:
if count(hand, c) == 4:
return True
else:
return False
def full_house(hand):
s = set(hand)
if len(s) == 2:
for c in s:
if count(hand, c) == 3:
return True
else:
return False
def straight(hand):
hand.sort()
if difference_one(hand):
return True
elif difference_one(change_ace(hand)):
return True
else:
return False
def three_card(hand):
s = set(hand)
if len(s) == 3:
for c in s:
if count(hand, c) == 3:
return True
else:
return False
def two_pair(hand):
s = set(hand)
return len(s) == 3
def one_pair(hand):
s = set(hand)
return len(s) == 4
def count(hand, c):
return len(filter(lambda x: x == c, hand))
def difference_one(hand):
r = []
d = reduce(lambda x, y: (add_list(x[0], y-x[1]), y), hand, (r,0))
d[0].pop(0)
return d[0] == [1,1,1,1]
def add_list(lis, x):
lis.append(x)
return lis
def change_ace(hand):
r = []
for c in hand:
if c == 1:
r.append(14)
else:
r.append(c)
r.sort()
return r
for line in sys.stdin:
hand = map(int, line.split(','))
print solv(hand) | 1,2,3,4,1
2,3,2,3,12
12,13,11,12,12
7,6,7,6,7
3,3,2,3,3
6,7,8,9,10
11,12,10,1,13
11,12,13,1,2
| one pair
two pair
three card
full house
four card
straight
straight
null
|
<H1>ポーカー</H1>
<p>
ポーカーの手札データを読み込んで、それぞれについてその役を出力するプログラムを作成してください。ただし、この問題では、以下のルールに従います。
</p>
<ul>
<li>ポーカーはトランプ 5 枚で行う競技です。</li>
<li>同じ数字のカードは 5 枚以上ありません。</li>
<li>ジョーカーは無いものとします。</li>
<li>以下のポーカーの役だけを考えるものとします。(番号が大きいほど役が高くなります。)</li>
</ul>
<ol style="margin-left:40px">
<li>役なし(以下に挙げるどれにも当てはまらない)</li>
<li>ワンペア（2 枚の同じ数字のカードが1 組ある）</li>
<li>ツーペア（2 枚の同じ数字のカードが2 組ある）</li>
<li>スリーカード（3 枚の同じ数字のカードが1 組ある）</li>
<li>ストレート（5 枚のカードの数字が連続している）<br>
ただし、A を含むストレートの場合、A で終わる並びもストレートとします。つまり、A を含むストレート
は、A 2 3 4 5 と 10 J Q K A の２種類です。J Q K A 2 などのように、A をまたぐ並び
はストレートではありません。（この場合、「役なし」になります）。
</li>
<li>フルハウス（3 枚の同じ数字のカードが1 組と、残りの2 枚が同じ数字のカード）</li>
<li>フォーカード（4 枚の同じ数字のカードが1 組ある）</li>
</ol>
<H2>Input</H2>
<p>
入力は複数のデータセットからなります。各データセットは以下の形式で与えられます。
</p>
<pre class=exp>
手札1,手札2,手札3,手札4,手札5
</pre>
<p>
手札は、トランプのJ(ジャック) を11、Q(クイーン) を12、K(キング) を13、A（エース）を 1、その他はそれぞれの数字で表すこととします。
</p>
<p>
データセットの数は 50 を超えません。
</p>
<H2>Output</H2>
<p>
データセットごとに、手札によってできる最も高い役をひとつ出力してください。役の表記については出力例に従ってください。
</p>
<H2>Sample Input</H2>
<pre>
1,2,3,4,1
2,3,2,3,12
12,13,11,12,12
7,6,7,6,7
3,3,2,3,3
6,7,8,9,10
11,12,10,1,13
11,12,13,1,2
</pre>
<H2>Output for the Sample Input</H2>
<pre>
one pair
two pair
three card
full house
four card
straight
straight
null
</pre>
<p>
3 3 2 3 3 という手札であったときは、two pair ではなく four card です。
</p>
|
s494650784 | p00038 | Accepted | #!/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
for line in stdin:
L = sorted([int(s) for s in line.split(',')])
cnt = Counter(L)
length, num = len(cnt), cnt.most_common(1)[0][1]
if length == 4 and num == 2:
print('one pair')
elif length == 3 and num == 2:
print('two pair')
elif length == 3 and num == 3:
print('three card')
elif length == 2 and num == 3:
print('full house')
elif length == 2 and num == 4:
print('four card')
elif L[0] == L[1]-1 == L[2]-2 == L[3]-3 == L[4]-4:
print('straight')
elif L[0] == 1 and L[1]-1 == L[2]-2 == L[3]-3 == L[4]-4:
print('straight')
else:
print('null') | 1,2,3,4,1
2,3,2,3,12
12,13,11,12,12
7,6,7,6,7
3,3,2,3,3
6,7,8,9,10
11,12,10,1,13
11,12,13,1,2
| one pair
two pair
three card
full house
four card
straight
straight
null
|
<H1>ポーカー</H1>
<p>
ポーカーの手札データを読み込んで、それぞれについてその役を出力するプログラムを作成してください。ただし、この問題では、以下のルールに従います。
</p>
<ul>
<li>ポーカーはトランプ 5 枚で行う競技です。</li>
<li>同じ数字のカードは 5 枚以上ありません。</li>
<li>ジョーカーは無いものとします。</li>
<li>以下のポーカーの役だけを考えるものとします。(番号が大きいほど役が高くなります。)</li>
</ul>
<ol style="margin-left:40px">
<li>役なし(以下に挙げるどれにも当てはまらない)</li>
<li>ワンペア（2 枚の同じ数字のカードが1 組ある）</li>
<li>ツーペア（2 枚の同じ数字のカードが2 組ある）</li>
<li>スリーカード（3 枚の同じ数字のカードが1 組ある）</li>
<li>ストレート（5 枚のカードの数字が連続している）<br>
ただし、A を含むストレートの場合、A で終わる並びもストレートとします。つまり、A を含むストレート
は、A 2 3 4 5 と 10 J Q K A の２種類です。J Q K A 2 などのように、A をまたぐ並び
はストレートではありません。（この場合、「役なし」になります）。
</li>
<li>フルハウス（3 枚の同じ数字のカードが1 組と、残りの2 枚が同じ数字のカード）</li>
<li>フォーカード（4 枚の同じ数字のカードが1 組ある）</li>
</ol>
<H2>Input</H2>
<p>
入力は複数のデータセットからなります。各データセットは以下の形式で与えられます。
</p>
<pre class=exp>
手札1,手札2,手札3,手札4,手札5
</pre>
<p>
手札は、トランプのJ(ジャック) を11、Q(クイーン) を12、K(キング) を13、A（エース）を 1、その他はそれぞれの数字で表すこととします。
</p>
<p>
データセットの数は 50 を超えません。
</p>
<H2>Output</H2>
<p>
データセットごとに、手札によってできる最も高い役をひとつ出力してください。役の表記については出力例に従ってください。
</p>
<H2>Sample Input</H2>
<pre>
1,2,3,4,1
2,3,2,3,12
12,13,11,12,12
7,6,7,6,7
3,3,2,3,3
6,7,8,9,10
11,12,10,1,13
11,12,13,1,2
</pre>
<H2>Output for the Sample Input</H2>
<pre>
one pair
two pair
three card
full house
four card
straight
straight
null
</pre>
<p>
3 3 2 3 3 という手札であったときは、two pair ではなく four card です。
</p>
|
s594355521 | p00038 | Accepted | import sys
def straight(cards):
aa = range(1,5)
if cards == [1, 10, 11, 12, 13]:
return True
for i in range(1, 10):
if cards == range(i, i+5):
return True
return False
for s in sys.stdin.read().rstrip().split('\n'):
cards = sorted(map(int, s.split(',')))
c = [0]*13
for card in cards:
c[card-1] += 1
if 4 in c:
print 'four card'
elif (3 in c) and (2 in c):
print 'full house'
elif straight(cards):
print 'straight'
elif 3 in c:
print 'three card'
elif c.count(2) == 2:
print 'two pair'
elif c.count(2) == 1:
print 'one pair'
else:
print 'null' | 1,2,3,4,1
2,3,2,3,12
12,13,11,12,12
7,6,7,6,7
3,3,2,3,3
6,7,8,9,10
11,12,10,1,13
11,12,13,1,2
| one pair
two pair
three card
full house
four card
straight
straight
null
|
<H1>ポーカー</H1>
<p>
ポーカーの手札データを読み込んで、それぞれについてその役を出力するプログラムを作成してください。ただし、この問題では、以下のルールに従います。
</p>
<ul>
<li>ポーカーはトランプ 5 枚で行う競技です。</li>
<li>同じ数字のカードは 5 枚以上ありません。</li>
<li>ジョーカーは無いものとします。</li>
<li>以下のポーカーの役だけを考えるものとします。(番号が大きいほど役が高くなります。)</li>
</ul>
<ol style="margin-left:40px">
<li>役なし(以下に挙げるどれにも当てはまらない)</li>
<li>ワンペア（2 枚の同じ数字のカードが1 組ある）</li>
<li>ツーペア（2 枚の同じ数字のカードが2 組ある）</li>
<li>スリーカード（3 枚の同じ数字のカードが1 組ある）</li>
<li>ストレート（5 枚のカードの数字が連続している）<br>
ただし、A を含むストレートの場合、A で終わる並びもストレートとします。つまり、A を含むストレート
は、A 2 3 4 5 と 10 J Q K A の２種類です。J Q K A 2 などのように、A をまたぐ並び
はストレートではありません。（この場合、「役なし」になります）。
</li>
<li>フルハウス（3 枚の同じ数字のカードが1 組と、残りの2 枚が同じ数字のカード）</li>
<li>フォーカード（4 枚の同じ数字のカードが1 組ある）</li>
</ol>
<H2>Input</H2>
<p>
入力は複数のデータセットからなります。各データセットは以下の形式で与えられます。
</p>
<pre class=exp>
手札1,手札2,手札3,手札4,手札5
</pre>
<p>
手札は、トランプのJ(ジャック) を11、Q(クイーン) を12、K(キング) を13、A（エース）を 1、その他はそれぞれの数字で表すこととします。
</p>
<p>
データセットの数は 50 を超えません。
</p>
<H2>Output</H2>
<p>
データセットごとに、手札によってできる最も高い役をひとつ出力してください。役の表記については出力例に従ってください。
</p>
<H2>Sample Input</H2>
<pre>
1,2,3,4,1
2,3,2,3,12
12,13,11,12,12
7,6,7,6,7
3,3,2,3,3
6,7,8,9,10
11,12,10,1,13
11,12,13,1,2
</pre>
<H2>Output for the Sample Input</H2>
<pre>
one pair
two pair
three card
full house
four card
straight
straight
null
</pre>
<p>
3 3 2 3 3 という手札であったときは、two pair ではなく four card です。
</p>
|
s752541984 | p00038 | Accepted | def readdata():
x = []
try:
while True:
x.append(map(int,raw_input().split(",")))
except: return x
def checkhand2(hand):
tmp = [(e+11)%13 for e in hand]
x1=sorted(list(set(tmp)))
x2=[]
for e in x1:
x2.append(tmp.count(e))
return x1,x2
def isstraight(x1):
if x1==[0,1,2,3,12]: return True
e = x1[0]
if x1==range(e,e+5): return True
else: return False
def checkhand(hand):
x1,x2 = checkhand2(hand)
x2 = sorted(x2)
prize = 0
if x2==[1,1,1,1,1]:
if isstraight(x1): prize = 4
else: prize = 0
elif x2==[1,1,1,2]: prize = 1
elif x2==[1,2,2]: prize = 2
elif x2==[1,1,3]: prize = 3
elif x2==[2,3]: prize = 5
elif x2==[1,4]: prize = 6
return prize
values=[2,3,4,5,6,7,8,9,10,11,12,13,1]
prize=["null","one pair","two pair","three card",
"straight","full house","four card"]
hands = readdata()
for e in hands:
print prize[checkhand(e)] | 1,2,3,4,1
2,3,2,3,12
12,13,11,12,12
7,6,7,6,7
3,3,2,3,3
6,7,8,9,10
11,12,10,1,13
11,12,13,1,2
| one pair
two pair
three card
full house
four card
straight
straight
null
|
<H1>ポーカー</H1>
<p>
ポーカーの手札データを読み込んで、それぞれについてその役を出力するプログラムを作成してください。ただし、この問題では、以下のルールに従います。
</p>
<ul>
<li>ポーカーはトランプ 5 枚で行う競技です。</li>
<li>同じ数字のカードは 5 枚以上ありません。</li>
<li>ジョーカーは無いものとします。</li>
<li>以下のポーカーの役だけを考えるものとします。(番号が大きいほど役が高くなります。)</li>
</ul>
<ol style="margin-left:40px">
<li>役なし(以下に挙げるどれにも当てはまらない)</li>
<li>ワンペア（2 枚の同じ数字のカードが1 組ある）</li>
<li>ツーペア（2 枚の同じ数字のカードが2 組ある）</li>
<li>スリーカード（3 枚の同じ数字のカードが1 組ある）</li>
<li>ストレート（5 枚のカードの数字が連続している）<br>
ただし、A を含むストレートの場合、A で終わる並びもストレートとします。つまり、A を含むストレート
は、A 2 3 4 5 と 10 J Q K A の２種類です。J Q K A 2 などのように、A をまたぐ並び
はストレートではありません。（この場合、「役なし」になります）。
</li>
<li>フルハウス（3 枚の同じ数字のカードが1 組と、残りの2 枚が同じ数字のカード）</li>
<li>フォーカード（4 枚の同じ数字のカードが1 組ある）</li>
</ol>
<H2>Input</H2>
<p>
入力は複数のデータセットからなります。各データセットは以下の形式で与えられます。
</p>
<pre class=exp>
手札1,手札2,手札3,手札4,手札5
</pre>
<p>
手札は、トランプのJ(ジャック) を11、Q(クイーン) を12、K(キング) を13、A（エース）を 1、その他はそれぞれの数字で表すこととします。
</p>
<p>
データセットの数は 50 を超えません。
</p>
<H2>Output</H2>
<p>
データセットごとに、手札によってできる最も高い役をひとつ出力してください。役の表記については出力例に従ってください。
</p>
<H2>Sample Input</H2>
<pre>
1,2,3,4,1
2,3,2,3,12
12,13,11,12,12
7,6,7,6,7
3,3,2,3,3
6,7,8,9,10
11,12,10,1,13
11,12,13,1,2
</pre>
<H2>Output for the Sample Input</H2>
<pre>
one pair
two pair
three card
full house
four card
straight
straight
null
</pre>
<p>
3 3 2 3 3 という手札であったときは、two pair ではなく four card です。
</p>
|
s911093993 | p00038 | Accepted | prize=["null","one pair","two pair","three card",
"straight","full house","four card"]
try:
while True:
hand = map(int,raw_input().split(","))
x = sorted(list(set(hand)))
a = len(x)
b = max([hand.count(e) for e in x])
if b==4: p=6
elif b==3:
if a==2: p=5
else: p=3
elif b==2:
if a==3: p=2
else: p=1
elif b==1:
e = x[0]
if x==[1,10,11,12,13] or x==range(e,e+5): p=4
else: p=0
print prize[p]
except:
pass | 1,2,3,4,1
2,3,2,3,12
12,13,11,12,12
7,6,7,6,7
3,3,2,3,3
6,7,8,9,10
11,12,10,1,13
11,12,13,1,2
| one pair
two pair
three card
full house
four card
straight
straight
null
|
<H1>ポーカー</H1>
<p>
ポーカーの手札データを読み込んで、それぞれについてその役を出力するプログラムを作成してください。ただし、この問題では、以下のルールに従います。
</p>
<ul>
<li>ポーカーはトランプ 5 枚で行う競技です。</li>
<li>同じ数字のカードは 5 枚以上ありません。</li>
<li>ジョーカーは無いものとします。</li>
<li>以下のポーカーの役だけを考えるものとします。(番号が大きいほど役が高くなります。)</li>
</ul>
<ol style="margin-left:40px">
<li>役なし(以下に挙げるどれにも当てはまらない)</li>
<li>ワンペア（2 枚の同じ数字のカードが1 組ある）</li>
<li>ツーペア（2 枚の同じ数字のカードが2 組ある）</li>
<li>スリーカード（3 枚の同じ数字のカードが1 組ある）</li>
<li>ストレート（5 枚のカードの数字が連続している）<br>
ただし、A を含むストレートの場合、A で終わる並びもストレートとします。つまり、A を含むストレート
は、A 2 3 4 5 と 10 J Q K A の２種類です。J Q K A 2 などのように、A をまたぐ並び
はストレートではありません。（この場合、「役なし」になります）。
</li>
<li>フルハウス（3 枚の同じ数字のカードが1 組と、残りの2 枚が同じ数字のカード）</li>
<li>フォーカード（4 枚の同じ数字のカードが1 組ある）</li>
</ol>
<H2>Input</H2>
<p>
入力は複数のデータセットからなります。各データセットは以下の形式で与えられます。
</p>
<pre class=exp>
手札1,手札2,手札3,手札4,手札5
</pre>
<p>
手札は、トランプのJ(ジャック) を11、Q(クイーン) を12、K(キング) を13、A（エース）を 1、その他はそれぞれの数字で表すこととします。
</p>
<p>
データセットの数は 50 を超えません。
</p>
<H2>Output</H2>
<p>
データセットごとに、手札によってできる最も高い役をひとつ出力してください。役の表記については出力例に従ってください。
</p>
<H2>Sample Input</H2>
<pre>
1,2,3,4,1
2,3,2,3,12
12,13,11,12,12
7,6,7,6,7
3,3,2,3,3
6,7,8,9,10
11,12,10,1,13
11,12,13,1,2
</pre>
<H2>Output for the Sample Input</H2>
<pre>
one pair
two pair
three card
full house
four card
straight
straight
null
</pre>
<p>
3 3 2 3 3 という手札であったときは、two pair ではなく four card です。
</p>
|
s094506768 | p00038 | Accepted | from sys import stdin
prize=["null","one pair","two pair","three card",
"straight","full house","four card"]
for line in stdin:
hand = map(int,line.split(","))
x = sorted(list(set(hand)))
a = len(x)
b = max([hand.count(e) for e in x])
if b==4: p=6
elif b==3:
if a==2: p=5
else: p=3
elif b==2:
if a==3: p=2
else: p=1
elif b==1:
e = x[0]
if x==[1,10,11,12,13] or x==range(e,e+5): p=4
else: p=0
print prize[p] | 1,2,3,4,1
2,3,2,3,12
12,13,11,12,12
7,6,7,6,7
3,3,2,3,3
6,7,8,9,10
11,12,10,1,13
11,12,13,1,2
| one pair
two pair
three card
full house
four card
straight
straight
null
|
<H1>ポーカー</H1>
<p>
ポーカーの手札データを読み込んで、それぞれについてその役を出力するプログラムを作成してください。ただし、この問題では、以下のルールに従います。
</p>
<ul>
<li>ポーカーはトランプ 5 枚で行う競技です。</li>
<li>同じ数字のカードは 5 枚以上ありません。</li>
<li>ジョーカーは無いものとします。</li>
<li>以下のポーカーの役だけを考えるものとします。(番号が大きいほど役が高くなります。)</li>
</ul>
<ol style="margin-left:40px">
<li>役なし(以下に挙げるどれにも当てはまらない)</li>
<li>ワンペア（2 枚の同じ数字のカードが1 組ある）</li>
<li>ツーペア（2 枚の同じ数字のカードが2 組ある）</li>
<li>スリーカード（3 枚の同じ数字のカードが1 組ある）</li>
<li>ストレート（5 枚のカードの数字が連続している）<br>
ただし、A を含むストレートの場合、A で終わる並びもストレートとします。つまり、A を含むストレート
は、A 2 3 4 5 と 10 J Q K A の２種類です。J Q K A 2 などのように、A をまたぐ並び
はストレートではありません。（この場合、「役なし」になります）。
</li>
<li>フルハウス（3 枚の同じ数字のカードが1 組と、残りの2 枚が同じ数字のカード）</li>
<li>フォーカード（4 枚の同じ数字のカードが1 組ある）</li>
</ol>
<H2>Input</H2>
<p>
入力は複数のデータセットからなります。各データセットは以下の形式で与えられます。
</p>
<pre class=exp>
手札1,手札2,手札3,手札4,手札5
</pre>
<p>
手札は、トランプのJ(ジャック) を11、Q(クイーン) を12、K(キング) を13、A（エース）を 1、その他はそれぞれの数字で表すこととします。
</p>
<p>
データセットの数は 50 を超えません。
</p>
<H2>Output</H2>
<p>
データセットごとに、手札によってできる最も高い役をひとつ出力してください。役の表記については出力例に従ってください。
</p>
<H2>Sample Input</H2>
<pre>
1,2,3,4,1
2,3,2,3,12
12,13,11,12,12
7,6,7,6,7
3,3,2,3,3
6,7,8,9,10
11,12,10,1,13
11,12,13,1,2
</pre>
<H2>Output for the Sample Input</H2>
<pre>
one pair
two pair
three card
full house
four card
straight
straight
null
</pre>
<p>
3 3 2 3 3 という手札であったときは、two pair ではなく four card です。
</p>
|
s224771062 | p00038 | Accepted | while True:
try:
hand = map(int, raw_input().split(","))
kind = list(set(hand))
rank =[]
for card in kind:
rank.append(hand.count(card))
rank.sort()
rank.reverse()
if rank[0] == 4:
print "four card"
elif rank[0] == 3:
if rank[1] == 2:
print "full house"
else:
print "three card"
elif rank[0] == 2:
if rank[1] == 2:
print "two pair"
else:
print "one pair"
else:
hand.sort()
if hand[4] - hand[0] == 4 or (hand[0] == 1 and hand[1] == 10):
print "straight"
else:
print "null"
except:
break | 1,2,3,4,1
2,3,2,3,12
12,13,11,12,12
7,6,7,6,7
3,3,2,3,3
6,7,8,9,10
11,12,10,1,13
11,12,13,1,2
| one pair
two pair
three card
full house
four card
straight
straight
null
|
<H1>ポーカー</H1>
<p>
ポーカーの手札データを読み込んで、それぞれについてその役を出力するプログラムを作成してください。ただし、この問題では、以下のルールに従います。
</p>
<ul>
<li>ポーカーはトランプ 5 枚で行う競技です。</li>
<li>同じ数字のカードは 5 枚以上ありません。</li>
<li>ジョーカーは無いものとします。</li>
<li>以下のポーカーの役だけを考えるものとします。(番号が大きいほど役が高くなります。)</li>
</ul>
<ol style="margin-left:40px">
<li>役なし(以下に挙げるどれにも当てはまらない)</li>
<li>ワンペア（2 枚の同じ数字のカードが1 組ある）</li>
<li>ツーペア（2 枚の同じ数字のカードが2 組ある）</li>
<li>スリーカード（3 枚の同じ数字のカードが1 組ある）</li>
<li>ストレート（5 枚のカードの数字が連続している）<br>
ただし、A を含むストレートの場合、A で終わる並びもストレートとします。つまり、A を含むストレート
は、A 2 3 4 5 と 10 J Q K A の２種類です。J Q K A 2 などのように、A をまたぐ並び
はストレートではありません。（この場合、「役なし」になります）。
</li>
<li>フルハウス（3 枚の同じ数字のカードが1 組と、残りの2 枚が同じ数字のカード）</li>
<li>フォーカード（4 枚の同じ数字のカードが1 組ある）</li>
</ol>
<H2>Input</H2>
<p>
入力は複数のデータセットからなります。各データセットは以下の形式で与えられます。
</p>
<pre class=exp>
手札1,手札2,手札3,手札4,手札5
</pre>
<p>
手札は、トランプのJ(ジャック) を11、Q(クイーン) を12、K(キング) を13、A（エース）を 1、その他はそれぞれの数字で表すこととします。
</p>
<p>
データセットの数は 50 を超えません。
</p>
<H2>Output</H2>
<p>
データセットごとに、手札によってできる最も高い役をひとつ出力してください。役の表記については出力例に従ってください。
</p>
<H2>Sample Input</H2>
<pre>
1,2,3,4,1
2,3,2,3,12
12,13,11,12,12
7,6,7,6,7
3,3,2,3,3
6,7,8,9,10
11,12,10,1,13
11,12,13,1,2
</pre>
<H2>Output for the Sample Input</H2>
<pre>
one pair
two pair
three card
full house
four card
straight
straight
null
</pre>
<p>
3 3 2 3 3 という手札であったときは、two pair ではなく four card です。
</p>
|
s821879037 | p00038 | Accepted | while True:
try:
hand = sorted(map(int, raw_input().split(",")))
kind = len(set(hand))
ma = max([hand.count(i) for i in hand])
if kind == 4:
print "one pair"
elif kind == 3:
if ma == 2:
print "two pair"
else:
print "three card"
elif kind == 2:
if ma==4:
print "four card"
else:
print "full house"
else:
if hand==[1,10,11,12,13] or hand[4] - hand[0] == 4:
print "straight"
else:
print "null"
except:
break | 1,2,3,4,1
2,3,2,3,12
12,13,11,12,12
7,6,7,6,7
3,3,2,3,3
6,7,8,9,10
11,12,10,1,13
11,12,13,1,2
| one pair
two pair
three card
full house
four card
straight
straight
null
|
<H1>ポーカー</H1>
<p>
ポーカーの手札データを読み込んで、それぞれについてその役を出力するプログラムを作成してください。ただし、この問題では、以下のルールに従います。
</p>
<ul>
<li>ポーカーはトランプ 5 枚で行う競技です。</li>
<li>同じ数字のカードは 5 枚以上ありません。</li>
<li>ジョーカーは無いものとします。</li>
<li>以下のポーカーの役だけを考えるものとします。(番号が大きいほど役が高くなります。)</li>
</ul>
<ol style="margin-left:40px">
<li>役なし(以下に挙げるどれにも当てはまらない)</li>
<li>ワンペア（2 枚の同じ数字のカードが1 組ある）</li>
<li>ツーペア（2 枚の同じ数字のカードが2 組ある）</li>
<li>スリーカード（3 枚の同じ数字のカードが1 組ある）</li>
<li>ストレート（5 枚のカードの数字が連続している）<br>
ただし、A を含むストレートの場合、A で終わる並びもストレートとします。つまり、A を含むストレート
は、A 2 3 4 5 と 10 J Q K A の２種類です。J Q K A 2 などのように、A をまたぐ並び
はストレートではありません。（この場合、「役なし」になります）。
</li>
<li>フルハウス（3 枚の同じ数字のカードが1 組と、残りの2 枚が同じ数字のカード）</li>
<li>フォーカード（4 枚の同じ数字のカードが1 組ある）</li>
</ol>
<H2>Input</H2>
<p>
入力は複数のデータセットからなります。各データセットは以下の形式で与えられます。
</p>
<pre class=exp>
手札1,手札2,手札3,手札4,手札5
</pre>
<p>
手札は、トランプのJ(ジャック) を11、Q(クイーン) を12、K(キング) を13、A（エース）を 1、その他はそれぞれの数字で表すこととします。
</p>
<p>
データセットの数は 50 を超えません。
</p>
<H2>Output</H2>
<p>
データセットごとに、手札によってできる最も高い役をひとつ出力してください。役の表記については出力例に従ってください。
</p>
<H2>Sample Input</H2>
<pre>
1,2,3,4,1
2,3,2,3,12
12,13,11,12,12
7,6,7,6,7
3,3,2,3,3
6,7,8,9,10
11,12,10,1,13
11,12,13,1,2
</pre>
<H2>Output for the Sample Input</H2>
<pre>
one pair
two pair
three card
full house
four card
straight
straight
null
</pre>
<p>
3 3 2 3 3 という手札であったときは、two pair ではなく four card です。
</p>
|
s018341384 | p00038 | Accepted | try:
while True:
a = sorted(map(int, raw_input().split(',')))
if a.count(a[2]) == 4:
print 'four card'
elif a.count(a[1]) + a.count(a[-2]) == 5:
print 'full house'
elif a == range(a[0], a[0] + 5) or a == [1, 10, 11, 12, 13]:
print 'straight'
elif a.count(a[2]) == 3:
print 'three card'
elif a.count(a[1]) == 2 and a.count(a[-2]) == 2:
print 'two pair'
elif len(set(a)) == 4:
print 'one pair'
else:
print 'null'
except EOFError:
pass | 1,2,3,4,1
2,3,2,3,12
12,13,11,12,12
7,6,7,6,7
3,3,2,3,3
6,7,8,9,10
11,12,10,1,13
11,12,13,1,2
| one pair
two pair
three card
full house
four card
straight
straight
null
|
<H1>ポーカー</H1>
<p>
ポーカーの手札データを読み込んで、それぞれについてその役を出力するプログラムを作成してください。ただし、この問題では、以下のルールに従います。
</p>
<ul>
<li>ポーカーはトランプ 5 枚で行う競技です。</li>
<li>同じ数字のカードは 5 枚以上ありません。</li>
<li>ジョーカーは無いものとします。</li>
<li>以下のポーカーの役だけを考えるものとします。(番号が大きいほど役が高くなります。)</li>
</ul>
<ol style="margin-left:40px">
<li>役なし(以下に挙げるどれにも当てはまらない)</li>
<li>ワンペア（2 枚の同じ数字のカードが1 組ある）</li>
<li>ツーペア（2 枚の同じ数字のカードが2 組ある）</li>
<li>スリーカード（3 枚の同じ数字のカードが1 組ある）</li>
<li>ストレート（5 枚のカードの数字が連続している）<br>
ただし、A を含むストレートの場合、A で終わる並びもストレートとします。つまり、A を含むストレート
は、A 2 3 4 5 と 10 J Q K A の２種類です。J Q K A 2 などのように、A をまたぐ並び
はストレートではありません。（この場合、「役なし」になります）。
</li>
<li>フルハウス（3 枚の同じ数字のカードが1 組と、残りの2 枚が同じ数字のカード）</li>
<li>フォーカード（4 枚の同じ数字のカードが1 組ある）</li>
</ol>
<H2>Input</H2>
<p>
入力は複数のデータセットからなります。各データセットは以下の形式で与えられます。
</p>
<pre class=exp>
手札1,手札2,手札3,手札4,手札5
</pre>
<p>
手札は、トランプのJ(ジャック) を11、Q(クイーン) を12、K(キング) を13、A（エース）を 1、その他はそれぞれの数字で表すこととします。
</p>
<p>
データセットの数は 50 を超えません。
</p>
<H2>Output</H2>
<p>
データセットごとに、手札によってできる最も高い役をひとつ出力してください。役の表記については出力例に従ってください。
</p>
<H2>Sample Input</H2>
<pre>
1,2,3,4,1
2,3,2,3,12
12,13,11,12,12
7,6,7,6,7
3,3,2,3,3
6,7,8,9,10
11,12,10,1,13
11,12,13,1,2
</pre>
<H2>Output for the Sample Input</H2>
<pre>
one pair
two pair
three card
full house
four card
straight
straight
null
</pre>
<p>
3 3 2 3 3 という手札であったときは、two pair ではなく four card です。
</p>
|
s949948901 | p00038 | Accepted | import sys
for s in sys.stdin:
hand = sorted(map(int, s.split(',')))
kind = len(set(hand))
ma = max([hand.count(i) for i in hand])
ans = 'null'
if kind == 4:
ans = 'one pair'
elif kind == 3:
if ma == 2:
ans = 'two pair'
else:
ans = 'three card'
elif kind == 2:
if ma==4:
ans = 'four card'
else:
ans = 'full house'
else:
if hand == [1,10,11,12,13] or (hand[4] - hand[0]) == 4:
ans = 'straight'
print ans | 1,2,3,4,1
2,3,2,3,12
12,13,11,12,12
7,6,7,6,7
3,3,2,3,3
6,7,8,9,10
11,12,10,1,13
11,12,13,1,2
| one pair
two pair
three card
full house
four card
straight
straight
null
|
<H1>ポーカー</H1>
<p>
ポーカーの手札データを読み込んで、それぞれについてその役を出力するプログラムを作成してください。ただし、この問題では、以下のルールに従います。
</p>
<ul>
<li>ポーカーはトランプ 5 枚で行う競技です。</li>
<li>同じ数字のカードは 5 枚以上ありません。</li>
<li>ジョーカーは無いものとします。</li>
<li>以下のポーカーの役だけを考えるものとします。(番号が大きいほど役が高くなります。)</li>
</ul>
<ol style="margin-left:40px">
<li>役なし(以下に挙げるどれにも当てはまらない)</li>
<li>ワンペア（2 枚の同じ数字のカードが1 組ある）</li>
<li>ツーペア（2 枚の同じ数字のカードが2 組ある）</li>
<li>スリーカード（3 枚の同じ数字のカードが1 組ある）</li>
<li>ストレート（5 枚のカードの数字が連続している）<br>
ただし、A を含むストレートの場合、A で終わる並びもストレートとします。つまり、A を含むストレート
は、A 2 3 4 5 と 10 J Q K A の２種類です。J Q K A 2 などのように、A をまたぐ並び
はストレートではありません。（この場合、「役なし」になります）。
</li>
<li>フルハウス（3 枚の同じ数字のカードが1 組と、残りの2 枚が同じ数字のカード）</li>
<li>フォーカード（4 枚の同じ数字のカードが1 組ある）</li>
</ol>
<H2>Input</H2>
<p>
入力は複数のデータセットからなります。各データセットは以下の形式で与えられます。
</p>
<pre class=exp>
手札1,手札2,手札3,手札4,手札5
</pre>
<p>
手札は、トランプのJ(ジャック) を11、Q(クイーン) を12、K(キング) を13、A（エース）を 1、その他はそれぞれの数字で表すこととします。
</p>
<p>
データセットの数は 50 を超えません。
</p>
<H2>Output</H2>
<p>
データセットごとに、手札によってできる最も高い役をひとつ出力してください。役の表記については出力例に従ってください。
</p>
<H2>Sample Input</H2>
<pre>
1,2,3,4,1
2,3,2,3,12
12,13,11,12,12
7,6,7,6,7
3,3,2,3,3
6,7,8,9,10
11,12,10,1,13
11,12,13,1,2
</pre>
<H2>Output for the Sample Input</H2>
<pre>
one pair
two pair
three card
full house
four card
straight
straight
null
</pre>
<p>
3 3 2 3 3 という手札であったときは、two pair ではなく four card です。
</p>
|
s730152507 | p00038 | Accepted | from collections import Counter
while 1:
try:
hand = map(int, raw_input().split(','))
except EOFError:
break
count = Counter(hand).most_common()
ret = ''
if count[0][1] >= 4:
ret = 'four card'
elif len(count) >= 2 and count[0][1] == 3 and count[1][1] == 2:
ret = 'full house'
elif len(count) == 5:
sort_hand = sorted(hand)
for i in xrange(4):
if sort_hand[i] + 1 != sort_hand[i + 1]:
break
else:
ret = 'straight'
if sort_hand == [1, 10, 11, 12, 13]:
ret = 'straight'
elif len(count) == 3 and count[0][1] == 3:
ret = 'three card'
elif len(count) == 3 and count[0][1] == count[1][1] == 2:
ret = 'two pair'
elif len(count) == 4:
ret = 'one pair'
if ret:
print ret
else:
print 'null' | 1,2,3,4,1
2,3,2,3,12
12,13,11,12,12
7,6,7,6,7
3,3,2,3,3
6,7,8,9,10
11,12,10,1,13
11,12,13,1,2
| one pair
two pair
three card
full house
four card
straight
straight
null
|
<H1>ポーカー</H1>
<p>
ポーカーの手札データを読み込んで、それぞれについてその役を出力するプログラムを作成してください。ただし、この問題では、以下のルールに従います。
</p>
<ul>
<li>ポーカーはトランプ 5 枚で行う競技です。</li>
<li>同じ数字のカードは 5 枚以上ありません。</li>
<li>ジョーカーは無いものとします。</li>
<li>以下のポーカーの役だけを考えるものとします。(番号が大きいほど役が高くなります。)</li>
</ul>
<ol style="margin-left:40px">
<li>役なし(以下に挙げるどれにも当てはまらない)</li>
<li>ワンペア（2 枚の同じ数字のカードが1 組ある）</li>
<li>ツーペア（2 枚の同じ数字のカードが2 組ある）</li>
<li>スリーカード（3 枚の同じ数字のカードが1 組ある）</li>
<li>ストレート（5 枚のカードの数字が連続している）<br>
ただし、A を含むストレートの場合、A で終わる並びもストレートとします。つまり、A を含むストレート
は、A 2 3 4 5 と 10 J Q K A の２種類です。J Q K A 2 などのように、A をまたぐ並び
はストレートではありません。（この場合、「役なし」になります）。
</li>
<li>フルハウス（3 枚の同じ数字のカードが1 組と、残りの2 枚が同じ数字のカード）</li>
<li>フォーカード（4 枚の同じ数字のカードが1 組ある）</li>
</ol>
<H2>Input</H2>
<p>
入力は複数のデータセットからなります。各データセットは以下の形式で与えられます。
</p>
<pre class=exp>
手札1,手札2,手札3,手札4,手札5
</pre>
<p>
手札は、トランプのJ(ジャック) を11、Q(クイーン) を12、K(キング) を13、A（エース）を 1、その他はそれぞれの数字で表すこととします。
</p>
<p>
データセットの数は 50 を超えません。
</p>
<H2>Output</H2>
<p>
データセットごとに、手札によってできる最も高い役をひとつ出力してください。役の表記については出力例に従ってください。
</p>
<H2>Sample Input</H2>
<pre>
1,2,3,4,1
2,3,2,3,12
12,13,11,12,12
7,6,7,6,7
3,3,2,3,3
6,7,8,9,10
11,12,10,1,13
11,12,13,1,2
</pre>
<H2>Output for the Sample Input</H2>
<pre>
one pair
two pair
three card
full house
four card
straight
straight
null
</pre>
<p>
3 3 2 3 3 という手札であったときは、two pair ではなく four card です。
</p>
|
s364825994 | p00038 | Accepted | from collections import Counter
import sys
for line in sys.stdin:
card = sorted(list(map(int, line.split(','))))
pair = Counter(card).most_common()
if pair[0][1] == 4:
print('four card')
elif pair[0][1] == 3 and pair[1][1] == 2:
print('full house')
elif pair[0][1] == 3:
print('three card')
elif pair[0][1] == pair[1][1] == 2:
print('two pair')
elif pair[0][1] == 2:
print('one pair')
elif [x - card[0] for x in card] == [0,1,2,3,4] or card == [1,10,11,12,13]:
print('straight')
else:
print('null') | 1,2,3,4,1
2,3,2,3,12
12,13,11,12,12
7,6,7,6,7
3,3,2,3,3
6,7,8,9,10
11,12,10,1,13
11,12,13,1,2
| one pair
two pair
three card
full house
four card
straight
straight
null
|
<H1>ポーカー</H1>
<p>
ポーカーの手札データを読み込んで、それぞれについてその役を出力するプログラムを作成してください。ただし、この問題では、以下のルールに従います。
</p>
<ul>
<li>ポーカーはトランプ 5 枚で行う競技です。</li>
<li>同じ数字のカードは 5 枚以上ありません。</li>
<li>ジョーカーは無いものとします。</li>
<li>以下のポーカーの役だけを考えるものとします。(番号が大きいほど役が高くなります。)</li>
</ul>
<ol style="margin-left:40px">
<li>役なし(以下に挙げるどれにも当てはまらない)</li>
<li>ワンペア（2 枚の同じ数字のカードが1 組ある）</li>
<li>ツーペア（2 枚の同じ数字のカードが2 組ある）</li>
<li>スリーカード（3 枚の同じ数字のカードが1 組ある）</li>
<li>ストレート（5 枚のカードの数字が連続している）<br>
ただし、A を含むストレートの場合、A で終わる並びもストレートとします。つまり、A を含むストレート
は、A 2 3 4 5 と 10 J Q K A の２種類です。J Q K A 2 などのように、A をまたぐ並び
はストレートではありません。（この場合、「役なし」になります）。
</li>
<li>フルハウス（3 枚の同じ数字のカードが1 組と、残りの2 枚が同じ数字のカード）</li>
<li>フォーカード（4 枚の同じ数字のカードが1 組ある）</li>
</ol>
<H2>Input</H2>
<p>
入力は複数のデータセットからなります。各データセットは以下の形式で与えられます。
</p>
<pre class=exp>
手札1,手札2,手札3,手札4,手札5
</pre>
<p>
手札は、トランプのJ(ジャック) を11、Q(クイーン) を12、K(キング) を13、A（エース）を 1、その他はそれぞれの数字で表すこととします。
</p>
<p>
データセットの数は 50 を超えません。
</p>
<H2>Output</H2>
<p>
データセットごとに、手札によってできる最も高い役をひとつ出力してください。役の表記については出力例に従ってください。
</p>
<H2>Sample Input</H2>
<pre>
1,2,3,4,1
2,3,2,3,12
12,13,11,12,12
7,6,7,6,7
3,3,2,3,3
6,7,8,9,10
11,12,10,1,13
11,12,13,1,2
</pre>
<H2>Output for the Sample Input</H2>
<pre>
one pair
two pair
three card
full house
four card
straight
straight
null
</pre>
<p>
3 3 2 3 3 という手札であったときは、two pair ではなく four card です。
</p>
|
s511398853 | p00038 | Accepted | def straight(cards):
if cards==[1,10,11,12,13]:
return 1
else:
for i in range(1,5):
if cards[i] != cards[i-1] + 1 :
return 0
return 1
while True:
try:
cards = sorted(list(map(int, input().split(','))))
except:
break
if cards.count(cards[1])==4:
print('four card')
continue
elif len(set(cards))==2:
print('full house')
continue
elif straight(cards)==1:
print('straight')
continue
elif cards.count(cards[2])==3:
print('three card')
continue
elif len(set(cards))==3:
print('two pair')
continue
elif len(set(cards))==4:
print('one pair')
continue
else:
print('null')
continue
| 1,2,3,4,1
2,3,2,3,12
12,13,11,12,12
7,6,7,6,7
3,3,2,3,3
6,7,8,9,10
11,12,10,1,13
11,12,13,1,2
| one pair
two pair
three card
full house
four card
straight
straight
null
|
<H1>ポーカー</H1>
<p>
ポーカーの手札データを読み込んで、それぞれについてその役を出力するプログラムを作成してください。ただし、この問題では、以下のルールに従います。
</p>
<ul>
<li>ポーカーはトランプ 5 枚で行う競技です。</li>
<li>同じ数字のカードは 5 枚以上ありません。</li>
<li>ジョーカーは無いものとします。</li>
<li>以下のポーカーの役だけを考えるものとします。(番号が大きいほど役が高くなります。)</li>
</ul>
<ol style="margin-left:40px">
<li>役なし(以下に挙げるどれにも当てはまらない)</li>
<li>ワンペア（2 枚の同じ数字のカードが1 組ある）</li>
<li>ツーペア（2 枚の同じ数字のカードが2 組ある）</li>
<li>スリーカード（3 枚の同じ数字のカードが1 組ある）</li>
<li>ストレート（5 枚のカードの数字が連続している）<br>
ただし、A を含むストレートの場合、A で終わる並びもストレートとします。つまり、A を含むストレート
は、A 2 3 4 5 と 10 J Q K A の２種類です。J Q K A 2 などのように、A をまたぐ並び
はストレートではありません。（この場合、「役なし」になります）。
</li>
<li>フルハウス（3 枚の同じ数字のカードが1 組と、残りの2 枚が同じ数字のカード）</li>
<li>フォーカード（4 枚の同じ数字のカードが1 組ある）</li>
</ol>
<H2>Input</H2>
<p>
入力は複数のデータセットからなります。各データセットは以下の形式で与えられます。
</p>
<pre class=exp>
手札1,手札2,手札3,手札4,手札5
</pre>
<p>
手札は、トランプのJ(ジャック) を11、Q(クイーン) を12、K(キング) を13、A（エース）を 1、その他はそれぞれの数字で表すこととします。
</p>
<p>
データセットの数は 50 を超えません。
</p>
<H2>Output</H2>
<p>
データセットごとに、手札によってできる最も高い役をひとつ出力してください。役の表記については出力例に従ってください。
</p>
<H2>Sample Input</H2>
<pre>
1,2,3,4,1
2,3,2,3,12
12,13,11,12,12
7,6,7,6,7
3,3,2,3,3
6,7,8,9,10
11,12,10,1,13
11,12,13,1,2
</pre>
<H2>Output for the Sample Input</H2>
<pre>
one pair
two pair
three card
full house
four card
straight
straight
null
</pre>
<p>
3 3 2 3 3 という手札であったときは、two pair ではなく four card です。
</p>
|
s664907074 | p00038 | Accepted | while True:
try:
A = sorted(list(map(int, input().split(","))))
_sum = 0
_max = 0
for i in range(1,14):
tmp = A.count(i)
if tmp > 1:
_sum+=tmp
_max = max(_max, tmp)
if _max == 4:
print("four card")
elif _max == 3 and _sum == 5:
print("full house")
elif A.count(1) == 1 and (A[0] == 1 and A[2]-1 == A[3]-2 == A[4]-3 == A[1]) \
or (A[4] == 1 and A[1]-1 == A[2]-2 == A[3] == A[0]):
print("straight")
elif A[1]-1 == A[2]-2 == A[3]-3 == A[4]-4 == A[0]:
print("straight")
elif _max == 3:
print("three card")
elif _sum == 4:
print("two pair")
elif _max == 2:
print("one pair")
else:
print("null")
except:
break
| 1,2,3,4,1
2,3,2,3,12
12,13,11,12,12
7,6,7,6,7
3,3,2,3,3
6,7,8,9,10
11,12,10,1,13
11,12,13,1,2
| one pair
two pair
three card
full house
four card
straight
straight
null
|
<H1>ポーカー</H1>
<p>
ポーカーの手札データを読み込んで、それぞれについてその役を出力するプログラムを作成してください。ただし、この問題では、以下のルールに従います。
</p>
<ul>
<li>ポーカーはトランプ 5 枚で行う競技です。</li>
<li>同じ数字のカードは 5 枚以上ありません。</li>
<li>ジョーカーは無いものとします。</li>
<li>以下のポーカーの役だけを考えるものとします。(番号が大きいほど役が高くなります。)</li>
</ul>
<ol style="margin-left:40px">
<li>役なし(以下に挙げるどれにも当てはまらない)</li>
<li>ワンペア（2 枚の同じ数字のカードが1 組ある）</li>
<li>ツーペア（2 枚の同じ数字のカードが2 組ある）</li>
<li>スリーカード（3 枚の同じ数字のカードが1 組ある）</li>
<li>ストレート（5 枚のカードの数字が連続している）<br>
ただし、A を含むストレートの場合、A で終わる並びもストレートとします。つまり、A を含むストレート
は、A 2 3 4 5 と 10 J Q K A の２種類です。J Q K A 2 などのように、A をまたぐ並び
はストレートではありません。（この場合、「役なし」になります）。
</li>
<li>フルハウス（3 枚の同じ数字のカードが1 組と、残りの2 枚が同じ数字のカード）</li>
<li>フォーカード（4 枚の同じ数字のカードが1 組ある）</li>
</ol>
<H2>Input</H2>
<p>
入力は複数のデータセットからなります。各データセットは以下の形式で与えられます。
</p>
<pre class=exp>
手札1,手札2,手札3,手札4,手札5
</pre>
<p>
手札は、トランプのJ(ジャック) を11、Q(クイーン) を12、K(キング) を13、A（エース）を 1、その他はそれぞれの数字で表すこととします。
</p>
<p>
データセットの数は 50 を超えません。
</p>
<H2>Output</H2>
<p>
データセットごとに、手札によってできる最も高い役をひとつ出力してください。役の表記については出力例に従ってください。
</p>
<H2>Sample Input</H2>
<pre>
1,2,3,4,1
2,3,2,3,12
12,13,11,12,12
7,6,7,6,7
3,3,2,3,3
6,7,8,9,10
11,12,10,1,13
11,12,13,1,2
</pre>
<H2>Output for the Sample Input</H2>
<pre>
one pair
two pair
three card
full house
four card
straight
straight
null
</pre>
<p>
3 3 2 3 3 という手札であったときは、two pair ではなく four card です。
</p>
|
s509516352 | p00038 | Accepted | straight = '12345678910111213110111213'
while True:
try:
lst = list(map(int, input().split(',')))
lst.sort()
clst = []
for i in lst:
clst.append(lst.count(i))
if clst.count(4) == 4:
print('four card')
elif clst.count(3) == 3:
if clst.count(2) == 2:
print('full house')
else:
print('three card')
elif clst.count(2) == 4:
print('two pair')
elif clst.count(2) == 2:
print('one pair')
else:
s = str(lst[0]) + str(lst[1]) + str(lst[2]) + str(lst[3]) + str(lst[4])
if s in straight:
print('straight')
else:
print('null')
except EOFError:
break
| 1,2,3,4,1
2,3,2,3,12
12,13,11,12,12
7,6,7,6,7
3,3,2,3,3
6,7,8,9,10
11,12,10,1,13
11,12,13,1,2
| one pair
two pair
three card
full house
four card
straight
straight
null
|
<H1>ポーカー</H1>
<p>
ポーカーの手札データを読み込んで、それぞれについてその役を出力するプログラムを作成してください。ただし、この問題では、以下のルールに従います。
</p>
<ul>
<li>ポーカーはトランプ 5 枚で行う競技です。</li>
<li>同じ数字のカードは 5 枚以上ありません。</li>
<li>ジョーカーは無いものとします。</li>
<li>以下のポーカーの役だけを考えるものとします。(番号が大きいほど役が高くなります。)</li>
</ul>
<ol style="margin-left:40px">
<li>役なし(以下に挙げるどれにも当てはまらない)</li>
<li>ワンペア（2 枚の同じ数字のカードが1 組ある）</li>
<li>ツーペア（2 枚の同じ数字のカードが2 組ある）</li>
<li>スリーカード（3 枚の同じ数字のカードが1 組ある）</li>
<li>ストレート（5 枚のカードの数字が連続している）<br>
ただし、A を含むストレートの場合、A で終わる並びもストレートとします。つまり、A を含むストレート
は、A 2 3 4 5 と 10 J Q K A の２種類です。J Q K A 2 などのように、A をまたぐ並び
はストレートではありません。（この場合、「役なし」になります）。
</li>
<li>フルハウス（3 枚の同じ数字のカードが1 組と、残りの2 枚が同じ数字のカード）</li>
<li>フォーカード（4 枚の同じ数字のカードが1 組ある）</li>
</ol>
<H2>Input</H2>
<p>
入力は複数のデータセットからなります。各データセットは以下の形式で与えられます。
</p>
<pre class=exp>
手札1,手札2,手札3,手札4,手札5
</pre>
<p>
手札は、トランプのJ(ジャック) を11、Q(クイーン) を12、K(キング) を13、A（エース）を 1、その他はそれぞれの数字で表すこととします。
</p>
<p>
データセットの数は 50 を超えません。
</p>
<H2>Output</H2>
<p>
データセットごとに、手札によってできる最も高い役をひとつ出力してください。役の表記については出力例に従ってください。
</p>
<H2>Sample Input</H2>
<pre>
1,2,3,4,1
2,3,2,3,12
12,13,11,12,12
7,6,7,6,7
3,3,2,3,3
6,7,8,9,10
11,12,10,1,13
11,12,13,1,2
</pre>
<H2>Output for the Sample Input</H2>
<pre>
one pair
two pair
three card
full house
four card
straight
straight
null
</pre>
<p>
3 3 2 3 3 という手札であったときは、two pair ではなく four card です。
</p>
|
s157231935 | p00038 | Accepted | def fourcard(card) :
if card.count(card[0]) == 4 or card.count(card[1]) == 4 :
return True
else :
return False
def fullhouse(card) :
card.sort()
if (card[0] == card[1] == card[2] and card[3] == card[4]) or (card[0] == card[1] and card[2] == card[3] == card[4]) :
return True
else :
return False
def straight(card) :
card.sort()
if card[0] == 1 and card[1] == 10 and card[2] == 11 and card[3] == 12 and card[4] == 13 :
return True
else :
ans = 'True'
for i in range(4) :
if card[i] + 1 != card[i + 1] :
ans = False
if ans == 'True' :
return True
else :
return False
def threecard(card) :
if card.count(card[0]) == 3 or card.count(card[1]) == 3 or card.count(card[2]) == 3 :
return True
else :
return False
def twopair(card) :
card.sort()
if card[0] == card[1] :
if card[2] == card[3] or card[3] == card[4]:
return True
elif card[1] == card[2] :
if card[3] == card[4] :
return True
else :
return False
def onepair(card) :
card.sort()
if card[0] == card[1] or card[1] == card[2] or card[2] == card[3] or card[3] == card[4] :
return True
else :
return False
while True :
try :
card = list(map(int, input().split(',')))
except EOFError :
break
if fourcard(card) :
print('four card')
elif fullhouse(card) :
print('full house')
elif straight(card) :
print('straight')
elif threecard(card) :
print('three card')
elif twopair(card) :
print('two pair')
elif onepair(card) :
print('one pair')
else :
print('null')
| 1,2,3,4,1
2,3,2,3,12
12,13,11,12,12
7,6,7,6,7
3,3,2,3,3
6,7,8,9,10
11,12,10,1,13
11,12,13,1,2
| one pair
two pair
three card
full house
four card
straight
straight
null
|
<H1>ポーカー</H1>
<p>
ポーカーの手札データを読み込んで、それぞれについてその役を出力するプログラムを作成してください。ただし、この問題では、以下のルールに従います。
</p>
<ul>
<li>ポーカーはトランプ 5 枚で行う競技です。</li>
<li>同じ数字のカードは 5 枚以上ありません。</li>
<li>ジョーカーは無いものとします。</li>
<li>以下のポーカーの役だけを考えるものとします。(番号が大きいほど役が高くなります。)</li>
</ul>
<ol style="margin-left:40px">
<li>役なし(以下に挙げるどれにも当てはまらない)</li>
<li>ワンペア（2 枚の同じ数字のカードが1 組ある）</li>
<li>ツーペア（2 枚の同じ数字のカードが2 組ある）</li>
<li>スリーカード（3 枚の同じ数字のカードが1 組ある）</li>
<li>ストレート（5 枚のカードの数字が連続している）<br>
ただし、A を含むストレートの場合、A で終わる並びもストレートとします。つまり、A を含むストレート
は、A 2 3 4 5 と 10 J Q K A の２種類です。J Q K A 2 などのように、A をまたぐ並び
はストレートではありません。（この場合、「役なし」になります）。
</li>
<li>フルハウス（3 枚の同じ数字のカードが1 組と、残りの2 枚が同じ数字のカード）</li>
<li>フォーカード（4 枚の同じ数字のカードが1 組ある）</li>
</ol>
<H2>Input</H2>
<p>
入力は複数のデータセットからなります。各データセットは以下の形式で与えられます。
</p>
<pre class=exp>
手札1,手札2,手札3,手札4,手札5
</pre>
<p>
手札は、トランプのJ(ジャック) を11、Q(クイーン) を12、K(キング) を13、A（エース）を 1、その他はそれぞれの数字で表すこととします。
</p>
<p>
データセットの数は 50 を超えません。
</p>
<H2>Output</H2>
<p>
データセットごとに、手札によってできる最も高い役をひとつ出力してください。役の表記については出力例に従ってください。
</p>
<H2>Sample Input</H2>
<pre>
1,2,3,4,1
2,3,2,3,12
12,13,11,12,12
7,6,7,6,7
3,3,2,3,3
6,7,8,9,10
11,12,10,1,13
11,12,13,1,2
</pre>
<H2>Output for the Sample Input</H2>
<pre>
one pair
two pair
three card
full house
four card
straight
straight
null
</pre>
<p>
3 3 2 3 3 という手札であったときは、two pair ではなく four card です。
</p>
|
s040114424 | p00038 | Accepted | import sys
readlines = sys.stdin.readlines
write = sys.stdout.write
def solve(C):
d = {}
for c in C:
d[c] = d.get(c, 0) + 1
*vs, = d.values()
vs.sort()
if vs[-1] == 4:
return "four card"
if vs == [2, 3]:
return "full house"
c0 = C[0]
if C == list(range(c0, c0+5)) or C == [1, 10, 11, 12, 13]:
return "straight"
if vs == [1, 1, 3]:
return "three card"
if vs == [1, 2, 2]:
return "two pair"
if vs == [1, 1, 1, 2]:
return "one pair"
return "null"
for line in readlines():
*C, = map(int, line.split(","))
C.sort()
write("%s\n" % solve(C))
| 1,2,3,4,1
2,3,2,3,12
12,13,11,12,12
7,6,7,6,7
3,3,2,3,3
6,7,8,9,10
11,12,10,1,13
11,12,13,1,2
| one pair
two pair
three card
full house
four card
straight
straight
null
|
<H1>ポーカー</H1>
<p>
ポーカーの手札データを読み込んで、それぞれについてその役を出力するプログラムを作成してください。ただし、この問題では、以下のルールに従います。
</p>
<ul>
<li>ポーカーはトランプ 5 枚で行う競技です。</li>
<li>同じ数字のカードは 5 枚以上ありません。</li>
<li>ジョーカーは無いものとします。</li>
<li>以下のポーカーの役だけを考えるものとします。(番号が大きいほど役が高くなります。)</li>
</ul>
<ol style="margin-left:40px">
<li>役なし(以下に挙げるどれにも当てはまらない)</li>
<li>ワンペア（2 枚の同じ数字のカードが1 組ある）</li>
<li>ツーペア（2 枚の同じ数字のカードが2 組ある）</li>
<li>スリーカード（3 枚の同じ数字のカードが1 組ある）</li>
<li>ストレート（5 枚のカードの数字が連続している）<br>
ただし、A を含むストレートの場合、A で終わる並びもストレートとします。つまり、A を含むストレート
は、A 2 3 4 5 と 10 J Q K A の２種類です。J Q K A 2 などのように、A をまたぐ並び
はストレートではありません。（この場合、「役なし」になります）。
</li>
<li>フルハウス（3 枚の同じ数字のカードが1 組と、残りの2 枚が同じ数字のカード）</li>
<li>フォーカード（4 枚の同じ数字のカードが1 組ある）</li>
</ol>
<H2>Input</H2>
<p>
入力は複数のデータセットからなります。各データセットは以下の形式で与えられます。
</p>
<pre class=exp>
手札1,手札2,手札3,手札4,手札5
</pre>
<p>
手札は、トランプのJ(ジャック) を11、Q(クイーン) を12、K(キング) を13、A（エース）を 1、その他はそれぞれの数字で表すこととします。
</p>
<p>
データセットの数は 50 を超えません。
</p>
<H2>Output</H2>
<p>
データセットごとに、手札によってできる最も高い役をひとつ出力してください。役の表記については出力例に従ってください。
</p>
<H2>Sample Input</H2>
<pre>
1,2,3,4,1
2,3,2,3,12
12,13,11,12,12
7,6,7,6,7
3,3,2,3,3
6,7,8,9,10
11,12,10,1,13
11,12,13,1,2
</pre>
<H2>Output for the Sample Input</H2>
<pre>
one pair
two pair
three card
full house
four card
straight
straight
null
</pre>
<p>
3 3 2 3 3 という手札であったときは、two pair ではなく four card です。
</p>
|
s786119928 | p00038 | Accepted | words = [['null','one pair','three card','four card'], ['','','two pair','full house']]
while True:
try:
cards = list(int(x) for x in input().split(","))
cards = sorted(cards,reverse=False)
isStright = True
pairCard = -1
pairNum = 0
pairIndex = 0
tmp = cards[0]
for i in range(1,5):
if tmp + 1 != cards[i]:
isStright = False
if tmp == cards[i]:
if pairNum >= 1 and pairCard != cards[i]:
pairIndex = 1
pairNum += 1
pairCard = cards[i]
tmp = cards[i]
if isStright or (cards[0] == 1 and cards[1] == 10 and cards[2] == 11 and cards[3] == 12 and cards[4] == 13):
ans = "straight"
else:
ans = words[pairIndex][pairNum]
print(ans)
except:
break
| 1,2,3,4,1
2,3,2,3,12
12,13,11,12,12
7,6,7,6,7
3,3,2,3,3
6,7,8,9,10
11,12,10,1,13
11,12,13,1,2
| one pair
two pair
three card
full house
four card
straight
straight
null
|
<H1>ポーカー</H1>
<p>
ポーカーの手札データを読み込んで、それぞれについてその役を出力するプログラムを作成してください。ただし、この問題では、以下のルールに従います。
</p>
<ul>
<li>ポーカーはトランプ 5 枚で行う競技です。</li>
<li>同じ数字のカードは 5 枚以上ありません。</li>
<li>ジョーカーは無いものとします。</li>
<li>以下のポーカーの役だけを考えるものとします。(番号が大きいほど役が高くなります。)</li>
</ul>
<ol style="margin-left:40px">
<li>役なし(以下に挙げるどれにも当てはまらない)</li>
<li>ワンペア（2 枚の同じ数字のカードが1 組ある）</li>
<li>ツーペア（2 枚の同じ数字のカードが2 組ある）</li>
<li>スリーカード（3 枚の同じ数字のカードが1 組ある）</li>
<li>ストレート（5 枚のカードの数字が連続している）<br>
ただし、A を含むストレートの場合、A で終わる並びもストレートとします。つまり、A を含むストレート
は、A 2 3 4 5 と 10 J Q K A の２種類です。J Q K A 2 などのように、A をまたぐ並び
はストレートではありません。（この場合、「役なし」になります）。
</li>
<li>フルハウス（3 枚の同じ数字のカードが1 組と、残りの2 枚が同じ数字のカード）</li>
<li>フォーカード（4 枚の同じ数字のカードが1 組ある）</li>
</ol>
<H2>Input</H2>
<p>
入力は複数のデータセットからなります。各データセットは以下の形式で与えられます。
</p>
<pre class=exp>
手札1,手札2,手札3,手札4,手札5
</pre>
<p>
手札は、トランプのJ(ジャック) を11、Q(クイーン) を12、K(キング) を13、A（エース）を 1、その他はそれぞれの数字で表すこととします。
</p>
<p>
データセットの数は 50 を超えません。
</p>
<H2>Output</H2>
<p>
データセットごとに、手札によってできる最も高い役をひとつ出力してください。役の表記については出力例に従ってください。
</p>
<H2>Sample Input</H2>
<pre>
1,2,3,4,1
2,3,2,3,12
12,13,11,12,12
7,6,7,6,7
3,3,2,3,3
6,7,8,9,10
11,12,10,1,13
11,12,13,1,2
</pre>
<H2>Output for the Sample Input</H2>
<pre>
one pair
two pair
three card
full house
four card
straight
straight
null
</pre>
<p>
3 3 2 3 3 という手札であったときは、two pair ではなく four card です。
</p>
|
s350400637 | p00038 | Accepted | from collections import Counter
def checkStraint(hand):
hand=sorted(hand)
if set(hand)==set([10,11,12,13,1]):
return True
for i in range(5):
if hand[0]+i==hand[i]:
continue
else:
return False
return True
while True:
try:
hand=[int(i) for i in input().split(",")]
hand=sorted(hand)
c=Counter(hand)
c=sorted(dict(c).items(),key=lambda w:w[1],reverse=True)
if c[0][1]==4:
print("four card")
continue
elif c[0][1]==3 and c[1][1]==2:
print("full house")
continue
elif checkStraint(hand):
print("straight")
continue
elif c[0][1]==3:
print("three card")
continue
elif c[0][1]==2 and c[1][1]==2:
print("two pair")
continue
elif c[0][1]==2:
print("one pair")
continue
else:
print("null")
except EOFError:
break
| 1,2,3,4,1
2,3,2,3,12
12,13,11,12,12
7,6,7,6,7
3,3,2,3,3
6,7,8,9,10
11,12,10,1,13
11,12,13,1,2
| one pair
two pair
three card
full house
four card
straight
straight
null
|
<H1>ポーカー</H1>
<p>
ポーカーの手札データを読み込んで、それぞれについてその役を出力するプログラムを作成してください。ただし、この問題では、以下のルールに従います。
</p>
<ul>
<li>ポーカーはトランプ 5 枚で行う競技です。</li>
<li>同じ数字のカードは 5 枚以上ありません。</li>
<li>ジョーカーは無いものとします。</li>
<li>以下のポーカーの役だけを考えるものとします。(番号が大きいほど役が高くなります。)</li>
</ul>
<ol style="margin-left:40px">
<li>役なし(以下に挙げるどれにも当てはまらない)</li>
<li>ワンペア（2 枚の同じ数字のカードが1 組ある）</li>
<li>ツーペア（2 枚の同じ数字のカードが2 組ある）</li>
<li>スリーカード（3 枚の同じ数字のカードが1 組ある）</li>
<li>ストレート（5 枚のカードの数字が連続している）<br>
ただし、A を含むストレートの場合、A で終わる並びもストレートとします。つまり、A を含むストレート
は、A 2 3 4 5 と 10 J Q K A の２種類です。J Q K A 2 などのように、A をまたぐ並び
はストレートではありません。（この場合、「役なし」になります）。
</li>
<li>フルハウス（3 枚の同じ数字のカードが1 組と、残りの2 枚が同じ数字のカード）</li>
<li>フォーカード（4 枚の同じ数字のカードが1 組ある）</li>
</ol>
<H2>Input</H2>
<p>
入力は複数のデータセットからなります。各データセットは以下の形式で与えられます。
</p>
<pre class=exp>
手札1,手札2,手札3,手札4,手札5
</pre>
<p>
手札は、トランプのJ(ジャック) を11、Q(クイーン) を12、K(キング) を13、A（エース）を 1、その他はそれぞれの数字で表すこととします。
</p>
<p>
データセットの数は 50 を超えません。
</p>
<H2>Output</H2>
<p>
データセットごとに、手札によってできる最も高い役をひとつ出力してください。役の表記については出力例に従ってください。
</p>
<H2>Sample Input</H2>
<pre>
1,2,3,4,1
2,3,2,3,12
12,13,11,12,12
7,6,7,6,7
3,3,2,3,3
6,7,8,9,10
11,12,10,1,13
11,12,13,1,2
</pre>
<H2>Output for the Sample Input</H2>
<pre>
one pair
two pair
three card
full house
four card
straight
straight
null
</pre>
<p>
3 3 2 3 3 という手札であったときは、two pair ではなく four card です。
</p>
|
s178610172 | p00038 | Accepted | # coding=utf-8
###
### for python program
###
import sys
import math
# math class
class mymath:
### pi
pi = 3.14159265358979323846264338
### Prime Number
def pnum_eratosthenes(self, n):
ptable = [0 for i in range(n+1)]
plist = []
for i in range(2, n+1):
if ptable[i]==0:
plist.append(i)
for j in range(i+i, n+1, i):
ptable[j] = 1
return plist
def pnum_check(self, n):
if (n==1):
return False
elif (n==2):
return True
else:
for x in range(2,n):
if(n % x==0):
return False
return True
### GCD
def gcd(self, a, b):
if b == 0:
return a
return self.gcd(b, a%b)
### LCM
def lcm(self, a, b):
return (a*b)//self.gcd(a,b)
### Mat Multiplication
def mul(self, A, B):
ans = []
for a in A:
c = 0
for j, row in enumerate(a):
c += row*B[j]
ans.append(c)
return ans
### intチェック
def is_integer(self, n):
try:
float(n)
except ValueError:
return False
else:
return float(n).is_integer()
### 幾何学問題用
def dist(self, A, B):
d = 0
for i in range(len(A)):
d += (A[i]-B[i])**2
d = d**(1/2)
return d
### 絶対値
def abs(self, n):
if n >= 0:
return n
else:
return -n
mymath = mymath()
### output class
class output:
### list
def list(self, l):
l = list(l)
#print(" ", end="")
for i, num in enumerate(l):
print(num, end="")
if i != len(l)-1:
print(" ", end="")
print()
output = output()
### input sample
#i = input()
#N = int(input())
#A, B, C = [x for x in input().split()]
#N, K = [int(x) for x in input().split()]
#inlist = [int(w) for w in input().split()]
#R = float(input())
#A.append(list(map(int,input().split())))
#for line in sys.stdin.readlines():
# x, y = [int(temp) for temp in line.split()]
#abc list
#abc = [chr(ord('a') + i) for i in range(26)]
### output sample
# print("{0} {1} {2:.5f}".format(A//B, A%B, A/B))
# print("{0:.6f} {1:.6f}".format(R*R*math.pi,R*2*math.pi))
# print(" {}".format(i), end="")
def printA(A):
N = len(A)
for i, n in enumerate(A):
print(n, end='')
if i != N-1:
print(' ', end='')
print()
# リスト内包表記 ifあり
# [x-k if x != 0 else x for x in C]
# ソート（代入する必要なし）
# N.sort()
# 10000個の素数リスト
# P = mymath.pnum_eratosthenes(105000)
def get_input():
N = []
while True:
try:
#N.append(input())
#N.append(int(input()))
#N.append(float(input()))
#N.append([int(x) for x in input().split()])
N.append([int(x) for x in input().split(',')])
except EOFError:
break
return N
### 0038
D = get_input()
for d in D:
ans = "null"
L = [0 for x in range(13)]
for i in d:
L[i-1] += 1
if 4 in L:
ans = "four card"
elif 3 in L:
if 2 in L:
ans = "full house"
else:
ans = "three card"
elif 2 in L:
if L.count(2)==2:
ans = "two pair"
else:
ans = "one pair"
else:
d.sort()
d = [x-min(d) for x in d]
if d == [0,1,2,3,4]:
ans = "straight"
elif d == [0,9,10,11,12]:
ans = "straight"
print(ans)
| 1,2,3,4,1
2,3,2,3,12
12,13,11,12,12
7,6,7,6,7
3,3,2,3,3
6,7,8,9,10
11,12,10,1,13
11,12,13,1,2
| one pair
two pair
three card
full house
four card
straight
straight
null
|
<H1>ポーカー</H1>
<p>
ポーカーの手札データを読み込んで、それぞれについてその役を出力するプログラムを作成してください。ただし、この問題では、以下のルールに従います。
</p>
<ul>
<li>ポーカーはトランプ 5 枚で行う競技です。</li>
<li>同じ数字のカードは 5 枚以上ありません。</li>
<li>ジョーカーは無いものとします。</li>
<li>以下のポーカーの役だけを考えるものとします。(番号が大きいほど役が高くなります。)</li>
</ul>
<ol style="margin-left:40px">
<li>役なし(以下に挙げるどれにも当てはまらない)</li>
<li>ワンペア（2 枚の同じ数字のカードが1 組ある）</li>
<li>ツーペア（2 枚の同じ数字のカードが2 組ある）</li>
<li>スリーカード（3 枚の同じ数字のカードが1 組ある）</li>
<li>ストレート（5 枚のカードの数字が連続している）<br>
ただし、A を含むストレートの場合、A で終わる並びもストレートとします。つまり、A を含むストレート
は、A 2 3 4 5 と 10 J Q K A の２種類です。J Q K A 2 などのように、A をまたぐ並び
はストレートではありません。（この場合、「役なし」になります）。
</li>
<li>フルハウス（3 枚の同じ数字のカードが1 組と、残りの2 枚が同じ数字のカード）</li>
<li>フォーカード（4 枚の同じ数字のカードが1 組ある）</li>
</ol>
<H2>Input</H2>
<p>
入力は複数のデータセットからなります。各データセットは以下の形式で与えられます。
</p>
<pre class=exp>
手札1,手札2,手札3,手札4,手札5
</pre>
<p>
手札は、トランプのJ(ジャック) を11、Q(クイーン) を12、K(キング) を13、A（エース）を 1、その他はそれぞれの数字で表すこととします。
</p>
<p>
データセットの数は 50 を超えません。
</p>
<H2>Output</H2>
<p>
データセットごとに、手札によってできる最も高い役をひとつ出力してください。役の表記については出力例に従ってください。
</p>
<H2>Sample Input</H2>
<pre>
1,2,3,4,1
2,3,2,3,12
12,13,11,12,12
7,6,7,6,7
3,3,2,3,3
6,7,8,9,10
11,12,10,1,13
11,12,13,1,2
</pre>
<H2>Output for the Sample Input</H2>
<pre>
one pair
two pair
three card
full house
four card
straight
straight
null
</pre>
<p>
3 3 2 3 3 という手札であったときは、two pair ではなく four card です。
</p>
|
s519429333 | p00038 | Accepted | import collections
def solution1(kard):
#強いものから順に探していく
if fourcard(kard):
print("four card")
elif fullhouse(kard):
print("full house")
elif straight(kard):
print("straight")
elif threecard(kard):
print("three card")
elif twopair(kard):
print("two pair")
elif onepair(kard):
print("one pair")
else:
print("null")
def fourcard(kard):
if kard.count(kard[0])==4 or kard.count(kard[1])==4:
return True
else:
return False
def fullhouse(kard):
list=collections.Counter(kard)
if len(list)==2:
return True
else:
return False
def straight(kard):
c=sorted(kard,reverse=True)
if c[0]==(c[1]+1)==(c[2]+2)==(c[3]+3)==(c[4]+4) or (c[0]==(c[1]+1)==(c[2]+2)==(c[3]+3) and c[4]==1 and c[0]==13):
return True
else:
return False
def threecard(kard):
if kard.count(kard[0])==3 or kard.count(kard[1])==3 or kard.count(kard[2])==3:
return True
else:
return False
def twopair(kard):
list=collections.Counter(kard)
if len(list)==3:
return True
else:
return False
def onepair(kard):
list=collections.Counter(kard)
if len(list)==4:
return True
else:
return False
while True:
try:
kard=list(map(int,input().split(",")))
except:
break
solution1(kard)
| 1,2,3,4,1
2,3,2,3,12
12,13,11,12,12
7,6,7,6,7
3,3,2,3,3
6,7,8,9,10
11,12,10,1,13
11,12,13,1,2
| one pair
two pair
three card
full house
four card
straight
straight
null
|
<H1>ポーカー</H1>
<p>
ポーカーの手札データを読み込んで、それぞれについてその役を出力するプログラムを作成してください。ただし、この問題では、以下のルールに従います。
</p>
<ul>
<li>ポーカーはトランプ 5 枚で行う競技です。</li>
<li>同じ数字のカードは 5 枚以上ありません。</li>
<li>ジョーカーは無いものとします。</li>
<li>以下のポーカーの役だけを考えるものとします。(番号が大きいほど役が高くなります。)</li>
</ul>
<ol style="margin-left:40px">
<li>役なし(以下に挙げるどれにも当てはまらない)</li>
<li>ワンペア（2 枚の同じ数字のカードが1 組ある）</li>
<li>ツーペア（2 枚の同じ数字のカードが2 組ある）</li>
<li>スリーカード（3 枚の同じ数字のカードが1 組ある）</li>
<li>ストレート（5 枚のカードの数字が連続している）<br>
ただし、A を含むストレートの場合、A で終わる並びもストレートとします。つまり、A を含むストレート
は、A 2 3 4 5 と 10 J Q K A の２種類です。J Q K A 2 などのように、A をまたぐ並び
はストレートではありません。（この場合、「役なし」になります）。
</li>
<li>フルハウス（3 枚の同じ数字のカードが1 組と、残りの2 枚が同じ数字のカード）</li>
<li>フォーカード（4 枚の同じ数字のカードが1 組ある）</li>
</ol>
<H2>Input</H2>
<p>
入力は複数のデータセットからなります。各データセットは以下の形式で与えられます。
</p>
<pre class=exp>
手札1,手札2,手札3,手札4,手札5
</pre>
<p>
手札は、トランプのJ(ジャック) を11、Q(クイーン) を12、K(キング) を13、A（エース）を 1、その他はそれぞれの数字で表すこととします。
</p>
<p>
データセットの数は 50 を超えません。
</p>
<H2>Output</H2>
<p>
データセットごとに、手札によってできる最も高い役をひとつ出力してください。役の表記については出力例に従ってください。
</p>
<H2>Sample Input</H2>
<pre>
1,2,3,4,1
2,3,2,3,12
12,13,11,12,12
7,6,7,6,7
3,3,2,3,3
6,7,8,9,10
11,12,10,1,13
11,12,13,1,2
</pre>
<H2>Output for the Sample Input</H2>
<pre>
one pair
two pair
three card
full house
four card
straight
straight
null
</pre>
<p>
3 3 2 3 3 という手札であったときは、two pair ではなく four card です。
</p>
|
s653076087 | p00038 | Accepted | import collections
def judge(card, cnt):
nmax = cnt[0][1]
if nmax == 4: return "four card"
if nmax == 3: return "full house" if cnt[1][1] == 2 else "three card"
if nmax == 2: return "two pair" if cnt[1][1] == 2 else "one pair"
if (card[0] == 1 and list(range(10, 14)) == card[1:]) or list(range(card[0], card[0] + 5)) == card : return "straight"
return "null"
while True:
try:
card = list(map(int, input().split(",")))
except:
break
cnt = collections.Counter(card)
print(judge(sorted(card), sorted(cnt.items(), key = lambda x:-x[1])))
| 1,2,3,4,1
2,3,2,3,12
12,13,11,12,12
7,6,7,6,7
3,3,2,3,3
6,7,8,9,10
11,12,10,1,13
11,12,13,1,2
| one pair
two pair
three card
full house
four card
straight
straight
null
|
<H1>ポーカー</H1>
<p>
ポーカーの手札データを読み込んで、それぞれについてその役を出力するプログラムを作成してください。ただし、この問題では、以下のルールに従います。
</p>
<ul>
<li>ポーカーはトランプ 5 枚で行う競技です。</li>
<li>同じ数字のカードは 5 枚以上ありません。</li>
<li>ジョーカーは無いものとします。</li>
<li>以下のポーカーの役だけを考えるものとします。(番号が大きいほど役が高くなります。)</li>
</ul>
<ol style="margin-left:40px">
<li>役なし(以下に挙げるどれにも当てはまらない)</li>
<li>ワンペア（2 枚の同じ数字のカードが1 組ある）</li>
<li>ツーペア（2 枚の同じ数字のカードが2 組ある）</li>
<li>スリーカード（3 枚の同じ数字のカードが1 組ある）</li>
<li>ストレート（5 枚のカードの数字が連続している）<br>
ただし、A を含むストレートの場合、A で終わる並びもストレートとします。つまり、A を含むストレート
は、A 2 3 4 5 と 10 J Q K A の２種類です。J Q K A 2 などのように、A をまたぐ並び
はストレートではありません。（この場合、「役なし」になります）。
</li>
<li>フルハウス（3 枚の同じ数字のカードが1 組と、残りの2 枚が同じ数字のカード）</li>
<li>フォーカード（4 枚の同じ数字のカードが1 組ある）</li>
</ol>
<H2>Input</H2>
<p>
入力は複数のデータセットからなります。各データセットは以下の形式で与えられます。
</p>
<pre class=exp>
手札1,手札2,手札3,手札4,手札5
</pre>
<p>
手札は、トランプのJ(ジャック) を11、Q(クイーン) を12、K(キング) を13、A（エース）を 1、その他はそれぞれの数字で表すこととします。
</p>
<p>
データセットの数は 50 を超えません。
</p>
<H2>Output</H2>
<p>
データセットごとに、手札によってできる最も高い役をひとつ出力してください。役の表記については出力例に従ってください。
</p>
<H2>Sample Input</H2>
<pre>
1,2,3,4,1
2,3,2,3,12
12,13,11,12,12
7,6,7,6,7
3,3,2,3,3
6,7,8,9,10
11,12,10,1,13
11,12,13,1,2
</pre>
<H2>Output for the Sample Input</H2>
<pre>
one pair
two pair
three card
full house
four card
straight
straight
null
</pre>
<p>
3 3 2 3 3 という手札であったときは、two pair ではなく four card です。
</p>
|
s388179965 | p00038 | Accepted |
def chk_all(A):
s_A = set(A)
B = list(s_A)
leng = len(s_A)
if leng == 2:
if A.count(B[0]) == 4 or A.count(B[1]) == 4:
return "four card"
else:
return "full house"
elif leng == 3:
if A.count(B[0]) == 3 or A.count(B[1]) == 3 or A.count(B[2]) == 3:
return "three card"
else:
return "two pair"
elif leng == 4:
return "one pair"
else:
A = sorted(A)
if A[0] == 1 and A[1] == 10 and A[2] == 11 and A[3] == 12 and A[4] == 13:
return "straight"
for i in range(1,5):
if A[i] - A[i-1] != 1:
return "null"
return "straight"
return "null"
if __name__ == '__main__':
while True:
try:
A = list(map(int,input().split(",")))
print(chk_all(A))
except EOFError:
break
| 1,2,3,4,1
2,3,2,3,12
12,13,11,12,12
7,6,7,6,7
3,3,2,3,3
6,7,8,9,10
11,12,10,1,13
11,12,13,1,2
| one pair
two pair
three card
full house
four card
straight
straight
null
|
<H1>ポーカー</H1>
<p>
ポーカーの手札データを読み込んで、それぞれについてその役を出力するプログラムを作成してください。ただし、この問題では、以下のルールに従います。
</p>
<ul>
<li>ポーカーはトランプ 5 枚で行う競技です。</li>
<li>同じ数字のカードは 5 枚以上ありません。</li>
<li>ジョーカーは無いものとします。</li>
<li>以下のポーカーの役だけを考えるものとします。(番号が大きいほど役が高くなります。)</li>
</ul>
<ol style="margin-left:40px">
<li>役なし(以下に挙げるどれにも当てはまらない)</li>
<li>ワンペア（2 枚の同じ数字のカードが1 組ある）</li>
<li>ツーペア（2 枚の同じ数字のカードが2 組ある）</li>
<li>スリーカード（3 枚の同じ数字のカードが1 組ある）</li>
<li>ストレート（5 枚のカードの数字が連続している）<br>
ただし、A を含むストレートの場合、A で終わる並びもストレートとします。つまり、A を含むストレート
は、A 2 3 4 5 と 10 J Q K A の２種類です。J Q K A 2 などのように、A をまたぐ並び
はストレートではありません。（この場合、「役なし」になります）。
</li>
<li>フルハウス（3 枚の同じ数字のカードが1 組と、残りの2 枚が同じ数字のカード）</li>
<li>フォーカード（4 枚の同じ数字のカードが1 組ある）</li>
</ol>
<H2>Input</H2>
<p>
入力は複数のデータセットからなります。各データセットは以下の形式で与えられます。
</p>
<pre class=exp>
手札1,手札2,手札3,手札4,手札5
</pre>
<p>
手札は、トランプのJ(ジャック) を11、Q(クイーン) を12、K(キング) を13、A（エース）を 1、その他はそれぞれの数字で表すこととします。
</p>
<p>
データセットの数は 50 を超えません。
</p>
<H2>Output</H2>
<p>
データセットごとに、手札によってできる最も高い役をひとつ出力してください。役の表記については出力例に従ってください。
</p>
<H2>Sample Input</H2>
<pre>
1,2,3,4,1
2,3,2,3,12
12,13,11,12,12
7,6,7,6,7
3,3,2,3,3
6,7,8,9,10
11,12,10,1,13
11,12,13,1,2
</pre>
<H2>Output for the Sample Input</H2>
<pre>
one pair
two pair
three card
full house
four card
straight
straight
null
</pre>
<p>
3 3 2 3 3 という手札であったときは、two pair ではなく four card です。
</p>
|
s882848337 | p00038 | Accepted | def yaku(N):
n=N[0]
li=[]
for i in range(5):
li.append(n)
n +=1
if N==li or N==[1,10,11,12,13]:
print("straight")
return
mp={}
count_2=0
count_3=0
for i in N:
if i in mp:
mp[i] +=1
else:
mp[i]=1
co=0
for k,v in mp.items():
if v!=1:
if v==2:
count_2 +=1
elif v==3:
count_3 +=1
else:
print("four card")
return
else:
co +=1
if co==5:
print("null")
return
if count_2==1 and count_3==1:
print("full house")
elif count_3==1:
print("three card")
elif count_2==2:
print("two pair")
elif count_2==1:
print("one pair")
while True:
try:
N=sorted(list(map(int,input().split(","))))
yaku(N)
except:break
| 1,2,3,4,1
2,3,2,3,12
12,13,11,12,12
7,6,7,6,7
3,3,2,3,3
6,7,8,9,10
11,12,10,1,13
11,12,13,1,2
| one pair
two pair
three card
full house
four card
straight
straight
null
|
<H1>ポーカー</H1>
<p>
ポーカーの手札データを読み込んで、それぞれについてその役を出力するプログラムを作成してください。ただし、この問題では、以下のルールに従います。
</p>
<ul>
<li>ポーカーはトランプ 5 枚で行う競技です。</li>
<li>同じ数字のカードは 5 枚以上ありません。</li>
<li>ジョーカーは無いものとします。</li>
<li>以下のポーカーの役だけを考えるものとします。(番号が大きいほど役が高くなります。)</li>
</ul>
<ol style="margin-left:40px">
<li>役なし(以下に挙げるどれにも当てはまらない)</li>
<li>ワンペア（2 枚の同じ数字のカードが1 組ある）</li>
<li>ツーペア（2 枚の同じ数字のカードが2 組ある）</li>
<li>スリーカード（3 枚の同じ数字のカードが1 組ある）</li>
<li>ストレート（5 枚のカードの数字が連続している）<br>
ただし、A を含むストレートの場合、A で終わる並びもストレートとします。つまり、A を含むストレート
は、A 2 3 4 5 と 10 J Q K A の２種類です。J Q K A 2 などのように、A をまたぐ並び
はストレートではありません。（この場合、「役なし」になります）。
</li>
<li>フルハウス（3 枚の同じ数字のカードが1 組と、残りの2 枚が同じ数字のカード）</li>
<li>フォーカード（4 枚の同じ数字のカードが1 組ある）</li>
</ol>
<H2>Input</H2>
<p>
入力は複数のデータセットからなります。各データセットは以下の形式で与えられます。
</p>
<pre class=exp>
手札1,手札2,手札3,手札4,手札5
</pre>
<p>
手札は、トランプのJ(ジャック) を11、Q(クイーン) を12、K(キング) を13、A（エース）を 1、その他はそれぞれの数字で表すこととします。
</p>
<p>
データセットの数は 50 を超えません。
</p>
<H2>Output</H2>
<p>
データセットごとに、手札によってできる最も高い役をひとつ出力してください。役の表記については出力例に従ってください。
</p>
<H2>Sample Input</H2>
<pre>
1,2,3,4,1
2,3,2,3,12
12,13,11,12,12
7,6,7,6,7
3,3,2,3,3
6,7,8,9,10
11,12,10,1,13
11,12,13,1,2
</pre>
<H2>Output for the Sample Input</H2>
<pre>
one pair
two pair
three card
full house
four card
straight
straight
null
</pre>
<p>
3 3 2 3 3 という手札であったときは、two pair ではなく four card です。
</p>
|
s808938579 | p00038 | Accepted | while 1:
try:
hand=list(map(int,input().split(",")))
hand.sort()
if len(list(set(hand)))==2:
if hand.count(hand[0])==4 or hand.count(hand[4])==4:print("four card")
else:print("full house")
elif hand[0]+1==hand[1] and hand[1]+1==hand[2] and hand[2]+1==hand[3] and hand[3]+1==hand[4]:print("straight")
elif hand[0]==1 and hand[1]==10 and hand[2]==11 and hand[3]==12 and hand[4]==13:print("straight")
elif len(list(set(hand)))==3:
if hand.count(hand[0])==3 or hand.count(hand[2])==3 or hand.count(hand[4])==3:print("three card")
else:print("two pair")
elif len(list(set(hand)))==4:print("one pair")
else:print("null")
except:break
| 1,2,3,4,1
2,3,2,3,12
12,13,11,12,12
7,6,7,6,7
3,3,2,3,3
6,7,8,9,10
11,12,10,1,13
11,12,13,1,2
| one pair
two pair
three card
full house
four card
straight
straight
null
|
<H1>ポーカー</H1>
<p>
ポーカーの手札データを読み込んで、それぞれについてその役を出力するプログラムを作成してください。ただし、この問題では、以下のルールに従います。
</p>
<ul>
<li>ポーカーはトランプ 5 枚で行う競技です。</li>
<li>同じ数字のカードは 5 枚以上ありません。</li>
<li>ジョーカーは無いものとします。</li>
<li>以下のポーカーの役だけを考えるものとします。(番号が大きいほど役が高くなります。)</li>
</ul>
<ol style="margin-left:40px">
<li>役なし(以下に挙げるどれにも当てはまらない)</li>
<li>ワンペア（2 枚の同じ数字のカードが1 組ある）</li>
<li>ツーペア（2 枚の同じ数字のカードが2 組ある）</li>
<li>スリーカード（3 枚の同じ数字のカードが1 組ある）</li>
<li>ストレート（5 枚のカードの数字が連続している）<br>
ただし、A を含むストレートの場合、A で終わる並びもストレートとします。つまり、A を含むストレート
は、A 2 3 4 5 と 10 J Q K A の２種類です。J Q K A 2 などのように、A をまたぐ並び
はストレートではありません。（この場合、「役なし」になります）。
</li>
<li>フルハウス（3 枚の同じ数字のカードが1 組と、残りの2 枚が同じ数字のカード）</li>
<li>フォーカード（4 枚の同じ数字のカードが1 組ある）</li>
</ol>
<H2>Input</H2>
<p>
入力は複数のデータセットからなります。各データセットは以下の形式で与えられます。
</p>
<pre class=exp>
手札1,手札2,手札3,手札4,手札5
</pre>
<p>
手札は、トランプのJ(ジャック) を11、Q(クイーン) を12、K(キング) を13、A（エース）を 1、その他はそれぞれの数字で表すこととします。
</p>
<p>
データセットの数は 50 を超えません。
</p>
<H2>Output</H2>
<p>
データセットごとに、手札によってできる最も高い役をひとつ出力してください。役の表記については出力例に従ってください。
</p>
<H2>Sample Input</H2>
<pre>
1,2,3,4,1
2,3,2,3,12
12,13,11,12,12
7,6,7,6,7
3,3,2,3,3
6,7,8,9,10
11,12,10,1,13
11,12,13,1,2
</pre>
<H2>Output for the Sample Input</H2>
<pre>
one pair
two pair
three card
full house
four card
straight
straight
null
</pre>
<p>
3 3 2 3 3 という手札であったときは、two pair ではなく four card です。
</p>
|
s348740452 | p00038 | Accepted | while(1):
try:
a = [int(i) for i in input().split(",")]
a.sort()
pairs = []
for i in set(a):
count = 0
for j in a:
if j == i:
count += 1
pairs.append(count)
if 5 in pairs:
print("full house")
elif 4 in pairs:
print("four card")
elif 3 in pairs and 2 in pairs:
print("full house")
elif 3 in pairs:
print("three card")
elif pairs.count(2) == 2:
print("two pair")
elif 2 in pairs:
print("one pair")
elif [a[i+1] - a[i] for i in range(4)] == [1 for i in range(4)] or a == [1,10,11,12,13]:
print("straight")
else:
print("null")
except EOFError:
break
| 1,2,3,4,1
2,3,2,3,12
12,13,11,12,12
7,6,7,6,7
3,3,2,3,3
6,7,8,9,10
11,12,10,1,13
11,12,13,1,2
| one pair
two pair
three card
full house
four card
straight
straight
null
|
<H1>ポーカー</H1>
<p>
ポーカーの手札データを読み込んで、それぞれについてその役を出力するプログラムを作成してください。ただし、この問題では、以下のルールに従います。
</p>
<ul>
<li>ポーカーはトランプ 5 枚で行う競技です。</li>
<li>同じ数字のカードは 5 枚以上ありません。</li>
<li>ジョーカーは無いものとします。</li>
<li>以下のポーカーの役だけを考えるものとします。(番号が大きいほど役が高くなります。)</li>
</ul>
<ol style="margin-left:40px">
<li>役なし(以下に挙げるどれにも当てはまらない)</li>
<li>ワンペア（2 枚の同じ数字のカードが1 組ある）</li>
<li>ツーペア（2 枚の同じ数字のカードが2 組ある）</li>
<li>スリーカード（3 枚の同じ数字のカードが1 組ある）</li>
<li>ストレート（5 枚のカードの数字が連続している）<br>
ただし、A を含むストレートの場合、A で終わる並びもストレートとします。つまり、A を含むストレート
は、A 2 3 4 5 と 10 J Q K A の２種類です。J Q K A 2 などのように、A をまたぐ並び
はストレートではありません。（この場合、「役なし」になります）。
</li>
<li>フルハウス（3 枚の同じ数字のカードが1 組と、残りの2 枚が同じ数字のカード）</li>
<li>フォーカード（4 枚の同じ数字のカードが1 組ある）</li>
</ol>
<H2>Input</H2>
<p>
入力は複数のデータセットからなります。各データセットは以下の形式で与えられます。
</p>
<pre class=exp>
手札1,手札2,手札3,手札4,手札5
</pre>
<p>
手札は、トランプのJ(ジャック) を11、Q(クイーン) を12、K(キング) を13、A（エース）を 1、その他はそれぞれの数字で表すこととします。
</p>
<p>
データセットの数は 50 を超えません。
</p>
<H2>Output</H2>
<p>
データセットごとに、手札によってできる最も高い役をひとつ出力してください。役の表記については出力例に従ってください。
</p>
<H2>Sample Input</H2>
<pre>
1,2,3,4,1
2,3,2,3,12
12,13,11,12,12
7,6,7,6,7
3,3,2,3,3
6,7,8,9,10
11,12,10,1,13
11,12,13,1,2
</pre>
<H2>Output for the Sample Input</H2>
<pre>
one pair
two pair
three card
full house
four card
straight
straight
null
</pre>
<p>
3 3 2 3 3 という手札であったときは、two pair ではなく four card です。
</p>
|
s508060076 | p00038 | Accepted | import collections
while 1:
try:
hand = list(map(int, input().split(",")))
except:
break
chand = collections.Counter(hand)
count = chand.most_common()
straight = [1, 10, 11, 12, 13]
if count[0][1] == 4:
print("four card")
continue
elif count[0][1] == 3 and count[1][1] == 2:
print("full house")
continue
else:
hand.sort()
if hand == straight:
print("straight")
continue
else:
check = True
for i in range(len(hand)-1):
if hand[i+1] - hand[i] != 1:
check = False
if check:
print("straight")
continue
if count[0][1] == 3:
print("three card")
continue
elif count[0][1] == count[1][1] == 2:
print("two pair")
continue
elif count[0][1] == 2:
print("one pair")
continue
else:
print("null")
| 1,2,3,4,1
2,3,2,3,12
12,13,11,12,12
7,6,7,6,7
3,3,2,3,3
6,7,8,9,10
11,12,10,1,13
11,12,13,1,2
| one pair
two pair
three card
full house
four card
straight
straight
null
|
<H1>ポーカー</H1>
<p>
ポーカーの手札データを読み込んで、それぞれについてその役を出力するプログラムを作成してください。ただし、この問題では、以下のルールに従います。
</p>
<ul>
<li>ポーカーはトランプ 5 枚で行う競技です。</li>
<li>同じ数字のカードは 5 枚以上ありません。</li>
<li>ジョーカーは無いものとします。</li>
<li>以下のポーカーの役だけを考えるものとします。(番号が大きいほど役が高くなります。)</li>
</ul>
<ol style="margin-left:40px">
<li>役なし(以下に挙げるどれにも当てはまらない)</li>
<li>ワンペア（2 枚の同じ数字のカードが1 組ある）</li>
<li>ツーペア（2 枚の同じ数字のカードが2 組ある）</li>
<li>スリーカード（3 枚の同じ数字のカードが1 組ある）</li>
<li>ストレート（5 枚のカードの数字が連続している）<br>
ただし、A を含むストレートの場合、A で終わる並びもストレートとします。つまり、A を含むストレート
は、A 2 3 4 5 と 10 J Q K A の２種類です。J Q K A 2 などのように、A をまたぐ並び
はストレートではありません。（この場合、「役なし」になります）。
</li>
<li>フルハウス（3 枚の同じ数字のカードが1 組と、残りの2 枚が同じ数字のカード）</li>
<li>フォーカード（4 枚の同じ数字のカードが1 組ある）</li>
</ol>
<H2>Input</H2>
<p>
入力は複数のデータセットからなります。各データセットは以下の形式で与えられます。
</p>
<pre class=exp>
手札1,手札2,手札3,手札4,手札5
</pre>
<p>
手札は、トランプのJ(ジャック) を11、Q(クイーン) を12、K(キング) を13、A（エース）を 1、その他はそれぞれの数字で表すこととします。
</p>
<p>
データセットの数は 50 を超えません。
</p>
<H2>Output</H2>
<p>
データセットごとに、手札によってできる最も高い役をひとつ出力してください。役の表記については出力例に従ってください。
</p>
<H2>Sample Input</H2>
<pre>
1,2,3,4,1
2,3,2,3,12
12,13,11,12,12
7,6,7,6,7
3,3,2,3,3
6,7,8,9,10
11,12,10,1,13
11,12,13,1,2
</pre>
<H2>Output for the Sample Input</H2>
<pre>
one pair
two pair
three card
full house
four card
straight
straight
null
</pre>
<p>
3 3 2 3 3 という手札であったときは、two pair ではなく four card です。
</p>
|
s175565417 | p00038 | Accepted | from collections import Counter
def is_straight(game):
if 1 in game:
if game == [1, 2, 3, 4, 5] or game == [1, 10, 11, 12, 13]:
return True
else:
return False
else:
for i in range(len(game)-1):
if game[i+1] != game[i]+1:
return False
return True
while True:
try: start = input()
except: break
game = list(map(int, start.split(',')))
game.sort()
result = Counter(game)
values, counts = zip(*result.most_common())
if counts[0] == 2:
if len(counts) == 4:
print('one pair')
else:
print('two pair')
elif counts[0] == 3:
if len(counts) == 3:
print('three card')
else:
print('full house')
elif counts[0] == 4:
print('four card')
elif is_straight(game):
print('straight')
else:
print('null')
| 1,2,3,4,1
2,3,2,3,12
12,13,11,12,12
7,6,7,6,7
3,3,2,3,3
6,7,8,9,10
11,12,10,1,13
11,12,13,1,2
| one pair
two pair
three card
full house
four card
straight
straight
null
|
<H1>ポーカー</H1>
<p>
ポーカーの手札データを読み込んで、それぞれについてその役を出力するプログラムを作成してください。ただし、この問題では、以下のルールに従います。
</p>
<ul>
<li>ポーカーはトランプ 5 枚で行う競技です。</li>
<li>同じ数字のカードは 5 枚以上ありません。</li>
<li>ジョーカーは無いものとします。</li>
<li>以下のポーカーの役だけを考えるものとします。(番号が大きいほど役が高くなります。)</li>
</ul>
<ol style="margin-left:40px">
<li>役なし(以下に挙げるどれにも当てはまらない)</li>
<li>ワンペア（2 枚の同じ数字のカードが1 組ある）</li>
<li>ツーペア（2 枚の同じ数字のカードが2 組ある）</li>
<li>スリーカード（3 枚の同じ数字のカードが1 組ある）</li>
<li>ストレート（5 枚のカードの数字が連続している）<br>
ただし、A を含むストレートの場合、A で終わる並びもストレートとします。つまり、A を含むストレート
は、A 2 3 4 5 と 10 J Q K A の２種類です。J Q K A 2 などのように、A をまたぐ並び
はストレートではありません。（この場合、「役なし」になります）。
</li>
<li>フルハウス（3 枚の同じ数字のカードが1 組と、残りの2 枚が同じ数字のカード）</li>
<li>フォーカード（4 枚の同じ数字のカードが1 組ある）</li>
</ol>
<H2>Input</H2>
<p>
入力は複数のデータセットからなります。各データセットは以下の形式で与えられます。
</p>
<pre class=exp>
手札1,手札2,手札3,手札4,手札5
</pre>
<p>
手札は、トランプのJ(ジャック) を11、Q(クイーン) を12、K(キング) を13、A（エース）を 1、その他はそれぞれの数字で表すこととします。
</p>
<p>
データセットの数は 50 を超えません。
</p>
<H2>Output</H2>
<p>
データセットごとに、手札によってできる最も高い役をひとつ出力してください。役の表記については出力例に従ってください。
</p>
<H2>Sample Input</H2>
<pre>
1,2,3,4,1
2,3,2,3,12
12,13,11,12,12
7,6,7,6,7
3,3,2,3,3
6,7,8,9,10
11,12,10,1,13
11,12,13,1,2
</pre>
<H2>Output for the Sample Input</H2>
<pre>
one pair
two pair
three card
full house
four card
straight
straight
null
</pre>
<p>
3 3 2 3 3 という手札であったときは、two pair ではなく four card です。
</p>
|
s711130437 | p00038 | Accepted | import sys
def check(cards):
ones, twos, threes, fours = 0, 0, 0, 0
for i in range(1, 14):
c = cards.count(i)
if c == 1: ones += 1
elif c == 2: twos += 1
elif c == 3: threes += 1
elif c == 4: fours += 1
if fours:
return 'four card'
if threes and twos:
return 'full house'
if ones == 5:
for i, v in enumerate(cards[:-1]):
if not v == cards[i + 1] - 1:
break
else: return 'straight'
if cards == [1, 10, 11, 12, 13]:
return 'straight'
if threes:
return 'three card'
if twos == 2:
return 'two pair'
if twos:
return 'one pair'
return 'null'
def solve():
for line in sys.stdin:
cards = sorted(map(int, line.split(',')))
print(check(cards))
if __name__ == "__main__":
solve()
| 1,2,3,4,1
2,3,2,3,12
12,13,11,12,12
7,6,7,6,7
3,3,2,3,3
6,7,8,9,10
11,12,10,1,13
11,12,13,1,2
| one pair
two pair
three card
full house
four card
straight
straight
null
|
<H1>ポーカー</H1>
<p>
ポーカーの手札データを読み込んで、それぞれについてその役を出力するプログラムを作成してください。ただし、この問題では、以下のルールに従います。
</p>
<ul>
<li>ポーカーはトランプ 5 枚で行う競技です。</li>
<li>同じ数字のカードは 5 枚以上ありません。</li>
<li>ジョーカーは無いものとします。</li>
<li>以下のポーカーの役だけを考えるものとします。(番号が大きいほど役が高くなります。)</li>
</ul>
<ol style="margin-left:40px">
<li>役なし(以下に挙げるどれにも当てはまらない)</li>
<li>ワンペア（2 枚の同じ数字のカードが1 組ある）</li>
<li>ツーペア（2 枚の同じ数字のカードが2 組ある）</li>
<li>スリーカード（3 枚の同じ数字のカードが1 組ある）</li>
<li>ストレート（5 枚のカードの数字が連続している）<br>
ただし、A を含むストレートの場合、A で終わる並びもストレートとします。つまり、A を含むストレート
は、A 2 3 4 5 と 10 J Q K A の２種類です。J Q K A 2 などのように、A をまたぐ並び
はストレートではありません。（この場合、「役なし」になります）。
</li>
<li>フルハウス（3 枚の同じ数字のカードが1 組と、残りの2 枚が同じ数字のカード）</li>
<li>フォーカード（4 枚の同じ数字のカードが1 組ある）</li>
</ol>
<H2>Input</H2>
<p>
入力は複数のデータセットからなります。各データセットは以下の形式で与えられます。
</p>
<pre class=exp>
手札1,手札2,手札3,手札4,手札5
</pre>
<p>
手札は、トランプのJ(ジャック) を11、Q(クイーン) を12、K(キング) を13、A（エース）を 1、その他はそれぞれの数字で表すこととします。
</p>
<p>
データセットの数は 50 を超えません。
</p>
<H2>Output</H2>
<p>
データセットごとに、手札によってできる最も高い役をひとつ出力してください。役の表記については出力例に従ってください。
</p>
<H2>Sample Input</H2>
<pre>
1,2,3,4,1
2,3,2,3,12
12,13,11,12,12
7,6,7,6,7
3,3,2,3,3
6,7,8,9,10
11,12,10,1,13
11,12,13,1,2
</pre>
<H2>Output for the Sample Input</H2>
<pre>
one pair
two pair
three card
full house
four card
straight
straight
null
</pre>
<p>
3 3 2 3 3 という手札であったときは、two pair ではなく four card です。
</p>
|
s379496821 | p00038 | Runtime Error | import sys
def is_onepair(x):
for i in range(4):
if x.count(x[i]) == 2:
return True
return False
def is_twopair(x):
count = 0
for e in x:
for e2 in x:
if e == e2:
count += 1
if count == 2:
return True
return False
def is_threecard(x):
for i in range(3):
if x.count(x[i]) == 3:
return True
return False
def is_straight(x):
x.sort()
if x[0] == 1 and x[1:] = [10, 11, 12, 13]:
return True
for i in range(4):
if x[i]+1 != x[i+1]:
return False
return True
def is_fullhouse(x):
if is_threecard(x) and is_onepair(x):
return True
return False
def is_fourcard(x):
for i in range(2):
if x.count(x[i]) == 4:
return True
return False
for line in sys.stdin.readlines():
hand = list(map(int, line.split(',')))
if is_fourcard(hand):
print("four card")
elif is_fullhouse(hand):
print("full house")
elif is_straight(hand):
print("straight")
elif is_threecard(hand):
print("three card")
elif is_twopair(hand):
print("two pair")
elif is_onepair(hand):
print("one pair")
else:
print("null") | 1,2,3,4,1
2,3,2,3,12
12,13,11,12,12
7,6,7,6,7
3,3,2,3,3
6,7,8,9,10
11,12,10,1,13
11,12,13,1,2
| one pair
two pair
three card
full house
four card
straight
straight
null
|
<H1>ポーカー</H1>
<p>
ポーカーの手札データを読み込んで、それぞれについてその役を出力するプログラムを作成してください。ただし、この問題では、以下のルールに従います。
</p>
<ul>
<li>ポーカーはトランプ 5 枚で行う競技です。</li>
<li>同じ数字のカードは 5 枚以上ありません。</li>
<li>ジョーカーは無いものとします。</li>
<li>以下のポーカーの役だけを考えるものとします。(番号が大きいほど役が高くなります。)</li>
</ul>
<ol style="margin-left:40px">
<li>役なし(以下に挙げるどれにも当てはまらない)</li>
<li>ワンペア（2 枚の同じ数字のカードが1 組ある）</li>
<li>ツーペア（2 枚の同じ数字のカードが2 組ある）</li>
<li>スリーカード（3 枚の同じ数字のカードが1 組ある）</li>
<li>ストレート（5 枚のカードの数字が連続している）<br>
ただし、A を含むストレートの場合、A で終わる並びもストレートとします。つまり、A を含むストレート
は、A 2 3 4 5 と 10 J Q K A の２種類です。J Q K A 2 などのように、A をまたぐ並び
はストレートではありません。（この場合、「役なし」になります）。
</li>
<li>フルハウス（3 枚の同じ数字のカードが1 組と、残りの2 枚が同じ数字のカード）</li>
<li>フォーカード（4 枚の同じ数字のカードが1 組ある）</li>
</ol>
<H2>Input</H2>
<p>
入力は複数のデータセットからなります。各データセットは以下の形式で与えられます。
</p>
<pre class=exp>
手札1,手札2,手札3,手札4,手札5
</pre>
<p>
手札は、トランプのJ(ジャック) を11、Q(クイーン) を12、K(キング) を13、A（エース）を 1、その他はそれぞれの数字で表すこととします。
</p>
<p>
データセットの数は 50 を超えません。
</p>
<H2>Output</H2>
<p>
データセットごとに、手札によってできる最も高い役をひとつ出力してください。役の表記については出力例に従ってください。
</p>
<H2>Sample Input</H2>
<pre>
1,2,3,4,1
2,3,2,3,12
12,13,11,12,12
7,6,7,6,7
3,3,2,3,3
6,7,8,9,10
11,12,10,1,13
11,12,13,1,2
</pre>
<H2>Output for the Sample Input</H2>
<pre>
one pair
two pair
three card
full house
four card
straight
straight
null
</pre>
<p>
3 3 2 3 3 という手札であったときは、two pair ではなく four card です。
</p>
|
s299062267 | p00038 | Runtime Error | # -*- coding: utf-8 -*-
def is_four_card(d):
return 4 in d.values()
def is_full_house(d):
return 3 in d.values() and 2 in d.values()
def is_straight(d):
flag = [False, 0]
for i in d.values():
if flag[0] == True and flag[1] == 5:
return True
if i == 1:
flag[0] = True
flag[1] += 1
return False
def is_three_card(d):
return 3 in d.values()
def is_two_pair(d):
return list(d.values()).count(2) == 2
def is_one_pair(d):
return list(d.values()).count(2) == 1
def judge(d):
if is_four_card(d):
print('four card')
elif is_full_house(d):
print('full house')
elif is_straight(d):
print('straight')
elif is_three_card(d):
print('three card')
elif is_two_pair(d):
print('two pair')
elif is_one_pair(d):
print('one pair')
else:
print('null')
def solve(cards):
d = {k: 0 for k in range(1, 14)}
for card in cards:
d[card] += 1
judge(d)
_input = input().split(",")
solve(_input) | 1,2,3,4,1
2,3,2,3,12
12,13,11,12,12
7,6,7,6,7
3,3,2,3,3
6,7,8,9,10
11,12,10,1,13
11,12,13,1,2
| one pair
two pair
three card
full house
four card
straight
straight
null
|
<H1>ポーカー</H1>
<p>
ポーカーの手札データを読み込んで、それぞれについてその役を出力するプログラムを作成してください。ただし、この問題では、以下のルールに従います。
</p>
<ul>
<li>ポーカーはトランプ 5 枚で行う競技です。</li>
<li>同じ数字のカードは 5 枚以上ありません。</li>
<li>ジョーカーは無いものとします。</li>
<li>以下のポーカーの役だけを考えるものとします。(番号が大きいほど役が高くなります。)</li>
</ul>
<ol style="margin-left:40px">
<li>役なし(以下に挙げるどれにも当てはまらない)</li>
<li>ワンペア（2 枚の同じ数字のカードが1 組ある）</li>
<li>ツーペア（2 枚の同じ数字のカードが2 組ある）</li>
<li>スリーカード（3 枚の同じ数字のカードが1 組ある）</li>
<li>ストレート（5 枚のカードの数字が連続している）<br>
ただし、A を含むストレートの場合、A で終わる並びもストレートとします。つまり、A を含むストレート
は、A 2 3 4 5 と 10 J Q K A の２種類です。J Q K A 2 などのように、A をまたぐ並び
はストレートではありません。（この場合、「役なし」になります）。
</li>
<li>フルハウス（3 枚の同じ数字のカードが1 組と、残りの2 枚が同じ数字のカード）</li>
<li>フォーカード（4 枚の同じ数字のカードが1 組ある）</li>
</ol>
<H2>Input</H2>
<p>
入力は複数のデータセットからなります。各データセットは以下の形式で与えられます。
</p>
<pre class=exp>
手札1,手札2,手札3,手札4,手札5
</pre>
<p>
手札は、トランプのJ(ジャック) を11、Q(クイーン) を12、K(キング) を13、A（エース）を 1、その他はそれぞれの数字で表すこととします。
</p>
<p>
データセットの数は 50 を超えません。
</p>
<H2>Output</H2>
<p>
データセットごとに、手札によってできる最も高い役をひとつ出力してください。役の表記については出力例に従ってください。
</p>
<H2>Sample Input</H2>
<pre>
1,2,3,4,1
2,3,2,3,12
12,13,11,12,12
7,6,7,6,7
3,3,2,3,3
6,7,8,9,10
11,12,10,1,13
11,12,13,1,2
</pre>
<H2>Output for the Sample Input</H2>
<pre>
one pair
two pair
three card
full house
four card
straight
straight
null
</pre>
<p>
3 3 2 3 3 という手札であったときは、two pair ではなく four card です。
</p>
|
s333543319 | p00038 | Runtime Error | import sys
for e in sys.stdin:
e=sorted(map(int,e.split(',')))
print([['null','straight'][e[4]-e[0]==4 or e[0]*10==e[1]],'one pair','two pair','three card','full house',0,'four card'][(sum(e.count(s)for s in e)//2-2])
| 1,2,3,4,1
2,3,2,3,12
12,13,11,12,12
7,6,7,6,7
3,3,2,3,3
6,7,8,9,10
11,12,10,1,13
11,12,13,1,2
| one pair
two pair
three card
full house
four card
straight
straight
null
|
<H1>ポーカー</H1>
<p>
ポーカーの手札データを読み込んで、それぞれについてその役を出力するプログラムを作成してください。ただし、この問題では、以下のルールに従います。
</p>
<ul>
<li>ポーカーはトランプ 5 枚で行う競技です。</li>
<li>同じ数字のカードは 5 枚以上ありません。</li>
<li>ジョーカーは無いものとします。</li>
<li>以下のポーカーの役だけを考えるものとします。(番号が大きいほど役が高くなります。)</li>
</ul>
<ol style="margin-left:40px">
<li>役なし(以下に挙げるどれにも当てはまらない)</li>
<li>ワンペア（2 枚の同じ数字のカードが1 組ある）</li>
<li>ツーペア（2 枚の同じ数字のカードが2 組ある）</li>
<li>スリーカード（3 枚の同じ数字のカードが1 組ある）</li>
<li>ストレート（5 枚のカードの数字が連続している）<br>
ただし、A を含むストレートの場合、A で終わる並びもストレートとします。つまり、A を含むストレート
は、A 2 3 4 5 と 10 J Q K A の２種類です。J Q K A 2 などのように、A をまたぐ並び
はストレートではありません。（この場合、「役なし」になります）。
</li>
<li>フルハウス（3 枚の同じ数字のカードが1 組と、残りの2 枚が同じ数字のカード）</li>
<li>フォーカード（4 枚の同じ数字のカードが1 組ある）</li>
</ol>
<H2>Input</H2>
<p>
入力は複数のデータセットからなります。各データセットは以下の形式で与えられます。
</p>
<pre class=exp>
手札1,手札2,手札3,手札4,手札5
</pre>
<p>
手札は、トランプのJ(ジャック) を11、Q(クイーン) を12、K(キング) を13、A（エース）を 1、その他はそれぞれの数字で表すこととします。
</p>
<p>
データセットの数は 50 を超えません。
</p>
<H2>Output</H2>
<p>
データセットごとに、手札によってできる最も高い役をひとつ出力してください。役の表記については出力例に従ってください。
</p>
<H2>Sample Input</H2>
<pre>
1,2,3,4,1
2,3,2,3,12
12,13,11,12,12
7,6,7,6,7
3,3,2,3,3
6,7,8,9,10
11,12,10,1,13
11,12,13,1,2
</pre>
<H2>Output for the Sample Input</H2>
<pre>
one pair
two pair
three card
full house
four card
straight
straight
null
</pre>
<p>
3 3 2 3 3 という手札であったときは、two pair ではなく four card です。
</p>
|
s691871498 | p00038 | Runtime Error | while True:
try:
hand = sorted(map(int, raw_input().split(",")))
kind = len(set(hand))
ma = max([hand.count(i) for i in hand])
if kind == 4:
print "one pair"
elif kind == 3:
if ma == 2:
print "two pair"
else:
print "three card"
elif kind == 2:
if ma==4:
print "four card"
else:
print "full house"
else:
if hand==[1,10,11,12,13] or hand[4] - hand[0] == 4:
print "straight"
else:
print "null"
except:
break | 1,2,3,4,1
2,3,2,3,12
12,13,11,12,12
7,6,7,6,7
3,3,2,3,3
6,7,8,9,10
11,12,10,1,13
11,12,13,1,2
| one pair
two pair
three card
full house
four card
straight
straight
null
|
<H1>ポーカー</H1>
<p>
ポーカーの手札データを読み込んで、それぞれについてその役を出力するプログラムを作成してください。ただし、この問題では、以下のルールに従います。
</p>
<ul>
<li>ポーカーはトランプ 5 枚で行う競技です。</li>
<li>同じ数字のカードは 5 枚以上ありません。</li>
<li>ジョーカーは無いものとします。</li>
<li>以下のポーカーの役だけを考えるものとします。(番号が大きいほど役が高くなります。)</li>
</ul>
<ol style="margin-left:40px">
<li>役なし(以下に挙げるどれにも当てはまらない)</li>
<li>ワンペア（2 枚の同じ数字のカードが1 組ある）</li>
<li>ツーペア（2 枚の同じ数字のカードが2 組ある）</li>
<li>スリーカード（3 枚の同じ数字のカードが1 組ある）</li>
<li>ストレート（5 枚のカードの数字が連続している）<br>
ただし、A を含むストレートの場合、A で終わる並びもストレートとします。つまり、A を含むストレート
は、A 2 3 4 5 と 10 J Q K A の２種類です。J Q K A 2 などのように、A をまたぐ並び
はストレートではありません。（この場合、「役なし」になります）。
</li>
<li>フルハウス（3 枚の同じ数字のカードが1 組と、残りの2 枚が同じ数字のカード）</li>
<li>フォーカード（4 枚の同じ数字のカードが1 組ある）</li>
</ol>
<H2>Input</H2>
<p>
入力は複数のデータセットからなります。各データセットは以下の形式で与えられます。
</p>
<pre class=exp>
手札1,手札2,手札3,手札4,手札5
</pre>
<p>
手札は、トランプのJ(ジャック) を11、Q(クイーン) を12、K(キング) を13、A（エース）を 1、その他はそれぞれの数字で表すこととします。
</p>
<p>
データセットの数は 50 を超えません。
</p>
<H2>Output</H2>
<p>
データセットごとに、手札によってできる最も高い役をひとつ出力してください。役の表記については出力例に従ってください。
</p>
<H2>Sample Input</H2>
<pre>
1,2,3,4,1
2,3,2,3,12
12,13,11,12,12
7,6,7,6,7
3,3,2,3,3
6,7,8,9,10
11,12,10,1,13
11,12,13,1,2
</pre>
<H2>Output for the Sample Input</H2>
<pre>
one pair
two pair
three card
full house
four card
straight
straight
null
</pre>
<p>
3 3 2 3 3 という手札であったときは、two pair ではなく four card です。
</p>
|
s790792319 | p00039 | Wrong Answer |
def Roman_numerals(x):
if x=='I':
return 1
elif x=='V':
return 5
elif x=='X':
return 10
elif x=='L':
return 50
elif x=='C':
return 100
elif x=='D':
return 500
elif x=='M':
return 1000
while True:
try:
s=0
string=input()
for i in range(len(string)):
tmp_now =Roman_numerals(string[i:i+1])
tmp_next=Roman_numerals(string[i+1:i+2])
if (tmp_now==1 and tmp_next==5):
s+=-1
elif (tmp_now==1 and tmp_next==10):
s+=-1
elif (tmp_now==10 and tmp_next==50):
s+=-10
elif (tmp_now==10 and tmp_next==100):
s+=-10
elif (tmp_now==100 and tmp_next==500):
s+=-100
else:
s+=tmp_now
print(s)
except EOFError:
break | IV
CCCCLXXXXVIIII
CDXCIX
| 4
499
499
|
<H1>ローマ数字</H1>
<p>
古代ローマでは数を数えることは難しい仕事でした。アラビア数字の 0,1,2,3,…, 9 はまだ流布していませんでした。その代わり次のような記号が使われていました。
</p>
<center>
<table border=1>
<tr>
<td bgcolor="#EEFFFF" width="100">アラビア数字</td><td width="100">ローマ数字</td><td bgcolor="#EEFFFF" width="100">アラビア数字</td><td width="100">ローマ数字</td><td bgcolor="#EEFFFF" width="100">アラビア数字</td><td width="100">ローマ数字</td>
</tr>
<tr><td bgcolor="#EEFFFF">1</td><td>I</td><td bgcolor="#EEFFFF">11<td>XI</td><td bgcolor="#EEFFFF">30</td><td>XXX</td><td>
<tr><td bgcolor="#EEFFFF">2</td><td>II</td><td bgcolor="#EEFFFF">12<td>XII</td><td bgcolor="#EEFFFF">40</td><td>XL</td><td>
<tr><td bgcolor="#EEFFFF">3</td><td>III</td><td bgcolor="#EEFFFF">13<td>XIII</td><td bgcolor="#EEFFFF">50</td><td>L</td><td>
<tr><td bgcolor="#EEFFFF">4</td><td>IV</td><td bgcolor="#EEFFFF">14<td>XIV</td><td bgcolor="#EEFFFF">60</td><td>LX</td><td>
<tr><td bgcolor="#EEFFFF">5</td><td>V</td><td bgcolor="#EEFFFF">15<td>XV</td><td bgcolor="#EEFFFF">70</td><td>LXX</td><td>
<tr><td bgcolor="#EEFFFF">6</td><td>VI</td><td bgcolor="#EEFFFF">16<td>XVI</td><td bgcolor="#EEFFFF">80</td><td>LXXX</td><td>
<tr><td bgcolor="#EEFFFF">7</td><td>VII</td><td bgcolor="#EEFFFF">17<td>XVII</td><td bgcolor="#EEFFFF">90</td><td>XC</td><td>
<tr><td bgcolor="#EEFFFF">8</td><td>VIII</td><td bgcolor="#EEFFFF">18<td>XVIII</td><td bgcolor="#EEFFFF">100</td><td>C</td><td>
<tr><td bgcolor="#EEFFFF">9</td><td>IX</td><td bgcolor="#EEFFFF">19<td>XIX</td><td bgcolor="#EEFFFF">500</td><td>D</td><td>
<tr><td bgcolor="#EEFFFF">10</td><td>X</td><td bgcolor="#EEFFFF">20<td>XX</td><td bgcolor="#EEFFFF">1000</td><td>M</td><td>
</table>
</center>
<br/>
<p>
I は 1、 V は 5、 X は 10、 L は 50、 C は 100、 D は 500、 M は 1000、 他の例は上の表を見てください。小さい数が大きい数に続いている、つまり右側にあるときは足し算をします。小さい数が大きい数の前に、つまり左にあるときは、大きい数から小さい数を引きます。大きい数字の前にあって引き算を表す小さな数字は一回の引き算あたりひとつしかありません。
</p>
<p>
ローマ数字をアラビア数字（通常の数字）の表記（10 進表示）に変換して出力するプログラムを作成してください。ただし、与えられるローマ数字は上記のルールにのみ従っています(実際のローマ数字の表記にはもっと細かいルールがありますが、ここでは考慮する必要はありません。たとえば、実際のローマ数字ではI はV かX から、X はL かC から、C はD かM からしか引き算しませんし、同じローマ数字は４つ以上（または５つ以上）足し並べることはありません。)
</p>
<H2>Input</H2>
<p>
複数のデータセットが与えられます。それぞれのデータセットにローマ数字（半角大文字のI, V, X, L, C, D ,M で表される連続した文字列）が１行に与えられます。与えられるローマ数字の文字列の長さはおのおの 100 以下です。
</p>
<p>
データセットの数は 50 を超えません。
</p>
<H2>Output</H2>
<p>
各データセットに対し、アラビア数字（整数）を１行に出力して下さい。
</p>
<H2>Sample Input</H2>
<pre>
IV
CCCCLXXXXVIIII
CDXCIX
</pre>
<H2>Output for the Sample Input</H2>
<pre>
4
499
499
</pre>
|
s174359350 | p00039 | Wrong Answer | _input = input()
d = {
'I': 1, 'V': 5, 'X': 10, 'L': 50, 'C': 100, 'D': 500, 'M': 1000
}
def solve(roma):
roma_nums = [d[c] for c in roma]
_sum = 0
for i, num in enumerate(roma_nums):
if i == 0 or i == len(roma_nums) - 1:
_sum += num
continue
else:
try:
next_num = roma_nums[i + 1]
except IndexError:
break
if next_num <= num:
_sum += num
else:
_sum -= num
return _sum
if __name__ == '__main__':
print(solve(_input)) | IV
CCCCLXXXXVIIII
CDXCIX
| 4
499
499
|
<H1>ローマ数字</H1>
<p>
古代ローマでは数を数えることは難しい仕事でした。アラビア数字の 0,1,2,3,…, 9 はまだ流布していませんでした。その代わり次のような記号が使われていました。
</p>
<center>
<table border=1>
<tr>
<td bgcolor="#EEFFFF" width="100">アラビア数字</td><td width="100">ローマ数字</td><td bgcolor="#EEFFFF" width="100">アラビア数字</td><td width="100">ローマ数字</td><td bgcolor="#EEFFFF" width="100">アラビア数字</td><td width="100">ローマ数字</td>
</tr>
<tr><td bgcolor="#EEFFFF">1</td><td>I</td><td bgcolor="#EEFFFF">11<td>XI</td><td bgcolor="#EEFFFF">30</td><td>XXX</td><td>
<tr><td bgcolor="#EEFFFF">2</td><td>II</td><td bgcolor="#EEFFFF">12<td>XII</td><td bgcolor="#EEFFFF">40</td><td>XL</td><td>
<tr><td bgcolor="#EEFFFF">3</td><td>III</td><td bgcolor="#EEFFFF">13<td>XIII</td><td bgcolor="#EEFFFF">50</td><td>L</td><td>
<tr><td bgcolor="#EEFFFF">4</td><td>IV</td><td bgcolor="#EEFFFF">14<td>XIV</td><td bgcolor="#EEFFFF">60</td><td>LX</td><td>
<tr><td bgcolor="#EEFFFF">5</td><td>V</td><td bgcolor="#EEFFFF">15<td>XV</td><td bgcolor="#EEFFFF">70</td><td>LXX</td><td>
<tr><td bgcolor="#EEFFFF">6</td><td>VI</td><td bgcolor="#EEFFFF">16<td>XVI</td><td bgcolor="#EEFFFF">80</td><td>LXXX</td><td>
<tr><td bgcolor="#EEFFFF">7</td><td>VII</td><td bgcolor="#EEFFFF">17<td>XVII</td><td bgcolor="#EEFFFF">90</td><td>XC</td><td>
<tr><td bgcolor="#EEFFFF">8</td><td>VIII</td><td bgcolor="#EEFFFF">18<td>XVIII</td><td bgcolor="#EEFFFF">100</td><td>C</td><td>
<tr><td bgcolor="#EEFFFF">9</td><td>IX</td><td bgcolor="#EEFFFF">19<td>XIX</td><td bgcolor="#EEFFFF">500</td><td>D</td><td>
<tr><td bgcolor="#EEFFFF">10</td><td>X</td><td bgcolor="#EEFFFF">20<td>XX</td><td bgcolor="#EEFFFF">1000</td><td>M</td><td>
</table>
</center>
<br/>
<p>
I は 1、 V は 5、 X は 10、 L は 50、 C は 100、 D は 500、 M は 1000、 他の例は上の表を見てください。小さい数が大きい数に続いている、つまり右側にあるときは足し算をします。小さい数が大きい数の前に、つまり左にあるときは、大きい数から小さい数を引きます。大きい数字の前にあって引き算を表す小さな数字は一回の引き算あたりひとつしかありません。
</p>
<p>
ローマ数字をアラビア数字（通常の数字）の表記（10 進表示）に変換して出力するプログラムを作成してください。ただし、与えられるローマ数字は上記のルールにのみ従っています(実際のローマ数字の表記にはもっと細かいルールがありますが、ここでは考慮する必要はありません。たとえば、実際のローマ数字ではI はV かX から、X はL かC から、C はD かM からしか引き算しませんし、同じローマ数字は４つ以上（または５つ以上）足し並べることはありません。)
</p>
<H2>Input</H2>
<p>
複数のデータセットが与えられます。それぞれのデータセットにローマ数字（半角大文字のI, V, X, L, C, D ,M で表される連続した文字列）が１行に与えられます。与えられるローマ数字の文字列の長さはおのおの 100 以下です。
</p>
<p>
データセットの数は 50 を超えません。
</p>
<H2>Output</H2>
<p>
各データセットに対し、アラビア数字（整数）を１行に出力して下さい。
</p>
<H2>Sample Input</H2>
<pre>
IV
CCCCLXXXXVIIII
CDXCIX
</pre>
<H2>Output for the Sample Input</H2>
<pre>
4
499
499
</pre>
|
s927150935 | p00039 | Wrong Answer | dict = {"I":1, "V":5, "X":10, "L":50, "C":100, "D":500, "M":1000}
while True:
try:
roman = raw_input()
sum = 0
for i in range(len(roman)):
print roman[i]
sum += dict[roman[i]]
sum -= 2*roman.count("IV")
sum -= 2*roman.count("IX")
sum -= 20*roman.count("XL")
sum -= 20*roman.count("XC")
sum -= 200*roman.count("CD")
sum -= 200*roman.count("CM")
print sum
except:
break | IV
CCCCLXXXXVIIII
CDXCIX
| 4
499
499
|
<H1>ローマ数字</H1>
<p>
古代ローマでは数を数えることは難しい仕事でした。アラビア数字の 0,1,2,3,…, 9 はまだ流布していませんでした。その代わり次のような記号が使われていました。
</p>
<center>
<table border=1>
<tr>
<td bgcolor="#EEFFFF" width="100">アラビア数字</td><td width="100">ローマ数字</td><td bgcolor="#EEFFFF" width="100">アラビア数字</td><td width="100">ローマ数字</td><td bgcolor="#EEFFFF" width="100">アラビア数字</td><td width="100">ローマ数字</td>
</tr>
<tr><td bgcolor="#EEFFFF">1</td><td>I</td><td bgcolor="#EEFFFF">11<td>XI</td><td bgcolor="#EEFFFF">30</td><td>XXX</td><td>
<tr><td bgcolor="#EEFFFF">2</td><td>II</td><td bgcolor="#EEFFFF">12<td>XII</td><td bgcolor="#EEFFFF">40</td><td>XL</td><td>
<tr><td bgcolor="#EEFFFF">3</td><td>III</td><td bgcolor="#EEFFFF">13<td>XIII</td><td bgcolor="#EEFFFF">50</td><td>L</td><td>
<tr><td bgcolor="#EEFFFF">4</td><td>IV</td><td bgcolor="#EEFFFF">14<td>XIV</td><td bgcolor="#EEFFFF">60</td><td>LX</td><td>
<tr><td bgcolor="#EEFFFF">5</td><td>V</td><td bgcolor="#EEFFFF">15<td>XV</td><td bgcolor="#EEFFFF">70</td><td>LXX</td><td>
<tr><td bgcolor="#EEFFFF">6</td><td>VI</td><td bgcolor="#EEFFFF">16<td>XVI</td><td bgcolor="#EEFFFF">80</td><td>LXXX</td><td>
<tr><td bgcolor="#EEFFFF">7</td><td>VII</td><td bgcolor="#EEFFFF">17<td>XVII</td><td bgcolor="#EEFFFF">90</td><td>XC</td><td>
<tr><td bgcolor="#EEFFFF">8</td><td>VIII</td><td bgcolor="#EEFFFF">18<td>XVIII</td><td bgcolor="#EEFFFF">100</td><td>C</td><td>
<tr><td bgcolor="#EEFFFF">9</td><td>IX</td><td bgcolor="#EEFFFF">19<td>XIX</td><td bgcolor="#EEFFFF">500</td><td>D</td><td>
<tr><td bgcolor="#EEFFFF">10</td><td>X</td><td bgcolor="#EEFFFF">20<td>XX</td><td bgcolor="#EEFFFF">1000</td><td>M</td><td>
</table>
</center>
<br/>
<p>
I は 1、 V は 5、 X は 10、 L は 50、 C は 100、 D は 500、 M は 1000、 他の例は上の表を見てください。小さい数が大きい数に続いている、つまり右側にあるときは足し算をします。小さい数が大きい数の前に、つまり左にあるときは、大きい数から小さい数を引きます。大きい数字の前にあって引き算を表す小さな数字は一回の引き算あたりひとつしかありません。
</p>
<p>
ローマ数字をアラビア数字（通常の数字）の表記（10 進表示）に変換して出力するプログラムを作成してください。ただし、与えられるローマ数字は上記のルールにのみ従っています(実際のローマ数字の表記にはもっと細かいルールがありますが、ここでは考慮する必要はありません。たとえば、実際のローマ数字ではI はV かX から、X はL かC から、C はD かM からしか引き算しませんし、同じローマ数字は４つ以上（または５つ以上）足し並べることはありません。)
</p>
<H2>Input</H2>
<p>
複数のデータセットが与えられます。それぞれのデータセットにローマ数字（半角大文字のI, V, X, L, C, D ,M で表される連続した文字列）が１行に与えられます。与えられるローマ数字の文字列の長さはおのおの 100 以下です。
</p>
<p>
データセットの数は 50 を超えません。
</p>
<H2>Output</H2>
<p>
各データセットに対し、アラビア数字（整数）を１行に出力して下さい。
</p>
<H2>Sample Input</H2>
<pre>
IV
CCCCLXXXXVIIII
CDXCIX
</pre>
<H2>Output for the Sample Input</H2>
<pre>
4
499
499
</pre>
|
s074862730 | p00039 | Accepted | dic = {"I":1,"V":5,"X":10,"L":50,"C":100,"D":500,"M":1000}
while(True):
try:
lis = list(input())
ans = [dic[e] for e in lis]
print(sum([-ans[i] if ans[i]<ans[i+1] else ans[i] for i in range(len(ans)-1)] + [ans[-1]]))
except:
break
| IV
CCCCLXXXXVIIII
CDXCIX
| 4
499
499
|
<H1>ローマ数字</H1>
<p>
古代ローマでは数を数えることは難しい仕事でした。アラビア数字の 0,1,2,3,…, 9 はまだ流布していませんでした。その代わり次のような記号が使われていました。
</p>
<center>
<table border=1>
<tr>
<td bgcolor="#EEFFFF" width="100">アラビア数字</td><td width="100">ローマ数字</td><td bgcolor="#EEFFFF" width="100">アラビア数字</td><td width="100">ローマ数字</td><td bgcolor="#EEFFFF" width="100">アラビア数字</td><td width="100">ローマ数字</td>
</tr>
<tr><td bgcolor="#EEFFFF">1</td><td>I</td><td bgcolor="#EEFFFF">11<td>XI</td><td bgcolor="#EEFFFF">30</td><td>XXX</td><td>
<tr><td bgcolor="#EEFFFF">2</td><td>II</td><td bgcolor="#EEFFFF">12<td>XII</td><td bgcolor="#EEFFFF">40</td><td>XL</td><td>
<tr><td bgcolor="#EEFFFF">3</td><td>III</td><td bgcolor="#EEFFFF">13<td>XIII</td><td bgcolor="#EEFFFF">50</td><td>L</td><td>
<tr><td bgcolor="#EEFFFF">4</td><td>IV</td><td bgcolor="#EEFFFF">14<td>XIV</td><td bgcolor="#EEFFFF">60</td><td>LX</td><td>
<tr><td bgcolor="#EEFFFF">5</td><td>V</td><td bgcolor="#EEFFFF">15<td>XV</td><td bgcolor="#EEFFFF">70</td><td>LXX</td><td>
<tr><td bgcolor="#EEFFFF">6</td><td>VI</td><td bgcolor="#EEFFFF">16<td>XVI</td><td bgcolor="#EEFFFF">80</td><td>LXXX</td><td>
<tr><td bgcolor="#EEFFFF">7</td><td>VII</td><td bgcolor="#EEFFFF">17<td>XVII</td><td bgcolor="#EEFFFF">90</td><td>XC</td><td>
<tr><td bgcolor="#EEFFFF">8</td><td>VIII</td><td bgcolor="#EEFFFF">18<td>XVIII</td><td bgcolor="#EEFFFF">100</td><td>C</td><td>
<tr><td bgcolor="#EEFFFF">9</td><td>IX</td><td bgcolor="#EEFFFF">19<td>XIX</td><td bgcolor="#EEFFFF">500</td><td>D</td><td>
<tr><td bgcolor="#EEFFFF">10</td><td>X</td><td bgcolor="#EEFFFF">20<td>XX</td><td bgcolor="#EEFFFF">1000</td><td>M</td><td>
</table>
</center>
<br/>
<p>
I は 1、 V は 5、 X は 10、 L は 50、 C は 100、 D は 500、 M は 1000、 他の例は上の表を見てください。小さい数が大きい数に続いている、つまり右側にあるときは足し算をします。小さい数が大きい数の前に、つまり左にあるときは、大きい数から小さい数を引きます。大きい数字の前にあって引き算を表す小さな数字は一回の引き算あたりひとつしかありません。
</p>
<p>
ローマ数字をアラビア数字（通常の数字）の表記（10 進表示）に変換して出力するプログラムを作成してください。ただし、与えられるローマ数字は上記のルールにのみ従っています(実際のローマ数字の表記にはもっと細かいルールがありますが、ここでは考慮する必要はありません。たとえば、実際のローマ数字ではI はV かX から、X はL かC から、C はD かM からしか引き算しませんし、同じローマ数字は４つ以上（または５つ以上）足し並べることはありません。)
</p>
<H2>Input</H2>
<p>
複数のデータセットが与えられます。それぞれのデータセットにローマ数字（半角大文字のI, V, X, L, C, D ,M で表される連続した文字列）が１行に与えられます。与えられるローマ数字の文字列の長さはおのおの 100 以下です。
</p>
<p>
データセットの数は 50 を超えません。
</p>
<H2>Output</H2>
<p>
各データセットに対し、アラビア数字（整数）を１行に出力して下さい。
</p>
<H2>Sample Input</H2>
<pre>
IV
CCCCLXXXXVIIII
CDXCIX
</pre>
<H2>Output for the Sample Input</H2>
<pre>
4
499
499
</pre>
|
s675410336 | p00039 | Accepted | #!/usr/bin/env python
# -*- coding: utf-8 -*-
from sys import *
lis = {"I":1,"V":5,"X":10,"L":50,"C":100,"D":500,"M":1000,"\n":0}
for s in stdin:
num = 0
for i in xrange(len(s)-1):
if lis[s[i]] < lis[s[i+1]]: num -= lis[s[i]];
else: num += lis[s[i]]
print num | IV
CCCCLXXXXVIIII
CDXCIX
| 4
499
499
|
<H1>ローマ数字</H1>
<p>
古代ローマでは数を数えることは難しい仕事でした。アラビア数字の 0,1,2,3,…, 9 はまだ流布していませんでした。その代わり次のような記号が使われていました。
</p>
<center>
<table border=1>
<tr>
<td bgcolor="#EEFFFF" width="100">アラビア数字</td><td width="100">ローマ数字</td><td bgcolor="#EEFFFF" width="100">アラビア数字</td><td width="100">ローマ数字</td><td bgcolor="#EEFFFF" width="100">アラビア数字</td><td width="100">ローマ数字</td>
</tr>
<tr><td bgcolor="#EEFFFF">1</td><td>I</td><td bgcolor="#EEFFFF">11<td>XI</td><td bgcolor="#EEFFFF">30</td><td>XXX</td><td>
<tr><td bgcolor="#EEFFFF">2</td><td>II</td><td bgcolor="#EEFFFF">12<td>XII</td><td bgcolor="#EEFFFF">40</td><td>XL</td><td>
<tr><td bgcolor="#EEFFFF">3</td><td>III</td><td bgcolor="#EEFFFF">13<td>XIII</td><td bgcolor="#EEFFFF">50</td><td>L</td><td>
<tr><td bgcolor="#EEFFFF">4</td><td>IV</td><td bgcolor="#EEFFFF">14<td>XIV</td><td bgcolor="#EEFFFF">60</td><td>LX</td><td>
<tr><td bgcolor="#EEFFFF">5</td><td>V</td><td bgcolor="#EEFFFF">15<td>XV</td><td bgcolor="#EEFFFF">70</td><td>LXX</td><td>
<tr><td bgcolor="#EEFFFF">6</td><td>VI</td><td bgcolor="#EEFFFF">16<td>XVI</td><td bgcolor="#EEFFFF">80</td><td>LXXX</td><td>
<tr><td bgcolor="#EEFFFF">7</td><td>VII</td><td bgcolor="#EEFFFF">17<td>XVII</td><td bgcolor="#EEFFFF">90</td><td>XC</td><td>
<tr><td bgcolor="#EEFFFF">8</td><td>VIII</td><td bgcolor="#EEFFFF">18<td>XVIII</td><td bgcolor="#EEFFFF">100</td><td>C</td><td>
<tr><td bgcolor="#EEFFFF">9</td><td>IX</td><td bgcolor="#EEFFFF">19<td>XIX</td><td bgcolor="#EEFFFF">500</td><td>D</td><td>
<tr><td bgcolor="#EEFFFF">10</td><td>X</td><td bgcolor="#EEFFFF">20<td>XX</td><td bgcolor="#EEFFFF">1000</td><td>M</td><td>
</table>
</center>
<br/>
<p>
I は 1、 V は 5、 X は 10、 L は 50、 C は 100、 D は 500、 M は 1000、 他の例は上の表を見てください。小さい数が大きい数に続いている、つまり右側にあるときは足し算をします。小さい数が大きい数の前に、つまり左にあるときは、大きい数から小さい数を引きます。大きい数字の前にあって引き算を表す小さな数字は一回の引き算あたりひとつしかありません。
</p>
<p>
ローマ数字をアラビア数字（通常の数字）の表記（10 進表示）に変換して出力するプログラムを作成してください。ただし、与えられるローマ数字は上記のルールにのみ従っています(実際のローマ数字の表記にはもっと細かいルールがありますが、ここでは考慮する必要はありません。たとえば、実際のローマ数字ではI はV かX から、X はL かC から、C はD かM からしか引き算しませんし、同じローマ数字は４つ以上（または５つ以上）足し並べることはありません。)
</p>
<H2>Input</H2>
<p>
複数のデータセットが与えられます。それぞれのデータセットにローマ数字（半角大文字のI, V, X, L, C, D ,M で表される連続した文字列）が１行に与えられます。与えられるローマ数字の文字列の長さはおのおの 100 以下です。
</p>
<p>
データセットの数は 50 を超えません。
</p>
<H2>Output</H2>
<p>
各データセットに対し、アラビア数字（整数）を１行に出力して下さい。
</p>
<H2>Sample Input</H2>
<pre>
IV
CCCCLXXXXVIIII
CDXCIX
</pre>
<H2>Output for the Sample Input</H2>
<pre>
4
499
499
</pre>
|
s844746511 | p00039 | Accepted | import sys
for l in sys.stdin:
s=0
d=[[100,500,0,0,0,5,1,10,0,50,1000][(n-67)%14]for n in map(ord,l.strip())]
for i,j in zip(d,d[1:]+[0]):s+=-i if i<j else i
print s | IV
CCCCLXXXXVIIII
CDXCIX
| 4
499
499
|
<H1>ローマ数字</H1>
<p>
古代ローマでは数を数えることは難しい仕事でした。アラビア数字の 0,1,2,3,…, 9 はまだ流布していませんでした。その代わり次のような記号が使われていました。
</p>
<center>
<table border=1>
<tr>
<td bgcolor="#EEFFFF" width="100">アラビア数字</td><td width="100">ローマ数字</td><td bgcolor="#EEFFFF" width="100">アラビア数字</td><td width="100">ローマ数字</td><td bgcolor="#EEFFFF" width="100">アラビア数字</td><td width="100">ローマ数字</td>
</tr>
<tr><td bgcolor="#EEFFFF">1</td><td>I</td><td bgcolor="#EEFFFF">11<td>XI</td><td bgcolor="#EEFFFF">30</td><td>XXX</td><td>
<tr><td bgcolor="#EEFFFF">2</td><td>II</td><td bgcolor="#EEFFFF">12<td>XII</td><td bgcolor="#EEFFFF">40</td><td>XL</td><td>
<tr><td bgcolor="#EEFFFF">3</td><td>III</td><td bgcolor="#EEFFFF">13<td>XIII</td><td bgcolor="#EEFFFF">50</td><td>L</td><td>
<tr><td bgcolor="#EEFFFF">4</td><td>IV</td><td bgcolor="#EEFFFF">14<td>XIV</td><td bgcolor="#EEFFFF">60</td><td>LX</td><td>
<tr><td bgcolor="#EEFFFF">5</td><td>V</td><td bgcolor="#EEFFFF">15<td>XV</td><td bgcolor="#EEFFFF">70</td><td>LXX</td><td>
<tr><td bgcolor="#EEFFFF">6</td><td>VI</td><td bgcolor="#EEFFFF">16<td>XVI</td><td bgcolor="#EEFFFF">80</td><td>LXXX</td><td>
<tr><td bgcolor="#EEFFFF">7</td><td>VII</td><td bgcolor="#EEFFFF">17<td>XVII</td><td bgcolor="#EEFFFF">90</td><td>XC</td><td>
<tr><td bgcolor="#EEFFFF">8</td><td>VIII</td><td bgcolor="#EEFFFF">18<td>XVIII</td><td bgcolor="#EEFFFF">100</td><td>C</td><td>
<tr><td bgcolor="#EEFFFF">9</td><td>IX</td><td bgcolor="#EEFFFF">19<td>XIX</td><td bgcolor="#EEFFFF">500</td><td>D</td><td>
<tr><td bgcolor="#EEFFFF">10</td><td>X</td><td bgcolor="#EEFFFF">20<td>XX</td><td bgcolor="#EEFFFF">1000</td><td>M</td><td>
</table>
</center>
<br/>
<p>
I は 1、 V は 5、 X は 10、 L は 50、 C は 100、 D は 500、 M は 1000、 他の例は上の表を見てください。小さい数が大きい数に続いている、つまり右側にあるときは足し算をします。小さい数が大きい数の前に、つまり左にあるときは、大きい数から小さい数を引きます。大きい数字の前にあって引き算を表す小さな数字は一回の引き算あたりひとつしかありません。
</p>
<p>
ローマ数字をアラビア数字（通常の数字）の表記（10 進表示）に変換して出力するプログラムを作成してください。ただし、与えられるローマ数字は上記のルールにのみ従っています(実際のローマ数字の表記にはもっと細かいルールがありますが、ここでは考慮する必要はありません。たとえば、実際のローマ数字ではI はV かX から、X はL かC から、C はD かM からしか引き算しませんし、同じローマ数字は４つ以上（または５つ以上）足し並べることはありません。)
</p>
<H2>Input</H2>
<p>
複数のデータセットが与えられます。それぞれのデータセットにローマ数字（半角大文字のI, V, X, L, C, D ,M で表される連続した文字列）が１行に与えられます。与えられるローマ数字の文字列の長さはおのおの 100 以下です。
</p>
<p>
データセットの数は 50 を超えません。
</p>
<H2>Output</H2>
<p>
各データセットに対し、アラビア数字（整数）を１行に出力して下さい。
</p>
<H2>Sample Input</H2>
<pre>
IV
CCCCLXXXXVIIII
CDXCIX
</pre>
<H2>Output for the Sample Input</H2>
<pre>
4
499
499
</pre>
|
s665731186 | p00039 | Accepted | import sys
for l in sys.stdin:
s=0
d=[[100,500,0,0,0,5,1,10,0,50,1000,0,0,0][(n-67)%14]for n in map(ord,l)]
for i,j in zip(d,d[1:]+[0]):s+=-i if i<j else i
print s | IV
CCCCLXXXXVIIII
CDXCIX
| 4
499
499
|
<H1>ローマ数字</H1>
<p>
古代ローマでは数を数えることは難しい仕事でした。アラビア数字の 0,1,2,3,…, 9 はまだ流布していませんでした。その代わり次のような記号が使われていました。
</p>
<center>
<table border=1>
<tr>
<td bgcolor="#EEFFFF" width="100">アラビア数字</td><td width="100">ローマ数字</td><td bgcolor="#EEFFFF" width="100">アラビア数字</td><td width="100">ローマ数字</td><td bgcolor="#EEFFFF" width="100">アラビア数字</td><td width="100">ローマ数字</td>
</tr>
<tr><td bgcolor="#EEFFFF">1</td><td>I</td><td bgcolor="#EEFFFF">11<td>XI</td><td bgcolor="#EEFFFF">30</td><td>XXX</td><td>
<tr><td bgcolor="#EEFFFF">2</td><td>II</td><td bgcolor="#EEFFFF">12<td>XII</td><td bgcolor="#EEFFFF">40</td><td>XL</td><td>
<tr><td bgcolor="#EEFFFF">3</td><td>III</td><td bgcolor="#EEFFFF">13<td>XIII</td><td bgcolor="#EEFFFF">50</td><td>L</td><td>
<tr><td bgcolor="#EEFFFF">4</td><td>IV</td><td bgcolor="#EEFFFF">14<td>XIV</td><td bgcolor="#EEFFFF">60</td><td>LX</td><td>
<tr><td bgcolor="#EEFFFF">5</td><td>V</td><td bgcolor="#EEFFFF">15<td>XV</td><td bgcolor="#EEFFFF">70</td><td>LXX</td><td>
<tr><td bgcolor="#EEFFFF">6</td><td>VI</td><td bgcolor="#EEFFFF">16<td>XVI</td><td bgcolor="#EEFFFF">80</td><td>LXXX</td><td>
<tr><td bgcolor="#EEFFFF">7</td><td>VII</td><td bgcolor="#EEFFFF">17<td>XVII</td><td bgcolor="#EEFFFF">90</td><td>XC</td><td>
<tr><td bgcolor="#EEFFFF">8</td><td>VIII</td><td bgcolor="#EEFFFF">18<td>XVIII</td><td bgcolor="#EEFFFF">100</td><td>C</td><td>
<tr><td bgcolor="#EEFFFF">9</td><td>IX</td><td bgcolor="#EEFFFF">19<td>XIX</td><td bgcolor="#EEFFFF">500</td><td>D</td><td>
<tr><td bgcolor="#EEFFFF">10</td><td>X</td><td bgcolor="#EEFFFF">20<td>XX</td><td bgcolor="#EEFFFF">1000</td><td>M</td><td>
</table>
</center>
<br/>
<p>
I は 1、 V は 5、 X は 10、 L は 50、 C は 100、 D は 500、 M は 1000、 他の例は上の表を見てください。小さい数が大きい数に続いている、つまり右側にあるときは足し算をします。小さい数が大きい数の前に、つまり左にあるときは、大きい数から小さい数を引きます。大きい数字の前にあって引き算を表す小さな数字は一回の引き算あたりひとつしかありません。
</p>
<p>
ローマ数字をアラビア数字（通常の数字）の表記（10 進表示）に変換して出力するプログラムを作成してください。ただし、与えられるローマ数字は上記のルールにのみ従っています(実際のローマ数字の表記にはもっと細かいルールがありますが、ここでは考慮する必要はありません。たとえば、実際のローマ数字ではI はV かX から、X はL かC から、C はD かM からしか引き算しませんし、同じローマ数字は４つ以上（または５つ以上）足し並べることはありません。)
</p>
<H2>Input</H2>
<p>
複数のデータセットが与えられます。それぞれのデータセットにローマ数字（半角大文字のI, V, X, L, C, D ,M で表される連続した文字列）が１行に与えられます。与えられるローマ数字の文字列の長さはおのおの 100 以下です。
</p>
<p>
データセットの数は 50 を超えません。
</p>
<H2>Output</H2>
<p>
各データセットに対し、アラビア数字（整数）を１行に出力して下さい。
</p>
<H2>Sample Input</H2>
<pre>
IV
CCCCLXXXXVIIII
CDXCIX
</pre>
<H2>Output for the Sample Input</H2>
<pre>
4
499
499
</pre>
|
s903065448 | p00039 | Accepted | import sys
for l in sys.stdin:
s=0
d=[[0,0,5,1,10,0,50,1000,0,0,0,100,500,0][n%14]for n in map(ord,l)]
for i,j in zip(d,d[1:]+[0]):s+=-i if i<j else i
print s | IV
CCCCLXXXXVIIII
CDXCIX
| 4
499
499
|
<H1>ローマ数字</H1>
<p>
古代ローマでは数を数えることは難しい仕事でした。アラビア数字の 0,1,2,3,…, 9 はまだ流布していませんでした。その代わり次のような記号が使われていました。
</p>
<center>
<table border=1>
<tr>
<td bgcolor="#EEFFFF" width="100">アラビア数字</td><td width="100">ローマ数字</td><td bgcolor="#EEFFFF" width="100">アラビア数字</td><td width="100">ローマ数字</td><td bgcolor="#EEFFFF" width="100">アラビア数字</td><td width="100">ローマ数字</td>
</tr>
<tr><td bgcolor="#EEFFFF">1</td><td>I</td><td bgcolor="#EEFFFF">11<td>XI</td><td bgcolor="#EEFFFF">30</td><td>XXX</td><td>
<tr><td bgcolor="#EEFFFF">2</td><td>II</td><td bgcolor="#EEFFFF">12<td>XII</td><td bgcolor="#EEFFFF">40</td><td>XL</td><td>
<tr><td bgcolor="#EEFFFF">3</td><td>III</td><td bgcolor="#EEFFFF">13<td>XIII</td><td bgcolor="#EEFFFF">50</td><td>L</td><td>
<tr><td bgcolor="#EEFFFF">4</td><td>IV</td><td bgcolor="#EEFFFF">14<td>XIV</td><td bgcolor="#EEFFFF">60</td><td>LX</td><td>
<tr><td bgcolor="#EEFFFF">5</td><td>V</td><td bgcolor="#EEFFFF">15<td>XV</td><td bgcolor="#EEFFFF">70</td><td>LXX</td><td>
<tr><td bgcolor="#EEFFFF">6</td><td>VI</td><td bgcolor="#EEFFFF">16<td>XVI</td><td bgcolor="#EEFFFF">80</td><td>LXXX</td><td>
<tr><td bgcolor="#EEFFFF">7</td><td>VII</td><td bgcolor="#EEFFFF">17<td>XVII</td><td bgcolor="#EEFFFF">90</td><td>XC</td><td>
<tr><td bgcolor="#EEFFFF">8</td><td>VIII</td><td bgcolor="#EEFFFF">18<td>XVIII</td><td bgcolor="#EEFFFF">100</td><td>C</td><td>
<tr><td bgcolor="#EEFFFF">9</td><td>IX</td><td bgcolor="#EEFFFF">19<td>XIX</td><td bgcolor="#EEFFFF">500</td><td>D</td><td>
<tr><td bgcolor="#EEFFFF">10</td><td>X</td><td bgcolor="#EEFFFF">20<td>XX</td><td bgcolor="#EEFFFF">1000</td><td>M</td><td>
</table>
</center>
<br/>
<p>
I は 1、 V は 5、 X は 10、 L は 50、 C は 100、 D は 500、 M は 1000、 他の例は上の表を見てください。小さい数が大きい数に続いている、つまり右側にあるときは足し算をします。小さい数が大きい数の前に、つまり左にあるときは、大きい数から小さい数を引きます。大きい数字の前にあって引き算を表す小さな数字は一回の引き算あたりひとつしかありません。
</p>
<p>
ローマ数字をアラビア数字（通常の数字）の表記（10 進表示）に変換して出力するプログラムを作成してください。ただし、与えられるローマ数字は上記のルールにのみ従っています(実際のローマ数字の表記にはもっと細かいルールがありますが、ここでは考慮する必要はありません。たとえば、実際のローマ数字ではI はV かX から、X はL かC から、C はD かM からしか引き算しませんし、同じローマ数字は４つ以上（または５つ以上）足し並べることはありません。)
</p>
<H2>Input</H2>
<p>
複数のデータセットが与えられます。それぞれのデータセットにローマ数字（半角大文字のI, V, X, L, C, D ,M で表される連続した文字列）が１行に与えられます。与えられるローマ数字の文字列の長さはおのおの 100 以下です。
</p>
<p>
データセットの数は 50 を超えません。
</p>
<H2>Output</H2>
<p>
各データセットに対し、アラビア数字（整数）を１行に出力して下さい。
</p>
<H2>Sample Input</H2>
<pre>
IV
CCCCLXXXXVIIII
CDXCIX
</pre>
<H2>Output for the Sample Input</H2>
<pre>
4
499
499
</pre>
|
s512268512 | p00039 | Accepted | def brain(l):
c = l[1] - l[0]
if 0 < c:
result.append(c)
del lis[0]
del lis[0]
else:
lis.append(l[0])
del lis[0]
def cisco(l):
for i in range(len(l)):
if l[i] == 'I':
l[i] = 1
elif l[i] == 'V':
l[i] = 5
elif l[i] == 'X':
l[i] = 10
elif l[i] == 'L':
l[i] = 50
elif l[i] == 'C':
l[i] = 100
elif l[i] == 'D':
l[i] = 500
elif l[i] == 'M':
l[i] = 1000
return l
while True:
result = []
try:
lis = list(raw_input())+['*']
while lis:
if not (lis[0] == '*' or lis[1] == '*'):
l = cisco([lis[0], lis[1]])
brain(l)
elif lis[0] == '*':
del lis[0]
break
elif lis[1] == '*':
l = cisco([lis[0]])
lis.append(l[0])
del lis[0]
del lis[0]
break
result.append(sum(lis))
print sum(result)
except EOFError:
break | IV
CCCCLXXXXVIIII
CDXCIX
| 4
499
499
|
<H1>ローマ数字</H1>
<p>
古代ローマでは数を数えることは難しい仕事でした。アラビア数字の 0,1,2,3,…, 9 はまだ流布していませんでした。その代わり次のような記号が使われていました。
</p>
<center>
<table border=1>
<tr>
<td bgcolor="#EEFFFF" width="100">アラビア数字</td><td width="100">ローマ数字</td><td bgcolor="#EEFFFF" width="100">アラビア数字</td><td width="100">ローマ数字</td><td bgcolor="#EEFFFF" width="100">アラビア数字</td><td width="100">ローマ数字</td>
</tr>
<tr><td bgcolor="#EEFFFF">1</td><td>I</td><td bgcolor="#EEFFFF">11<td>XI</td><td bgcolor="#EEFFFF">30</td><td>XXX</td><td>
<tr><td bgcolor="#EEFFFF">2</td><td>II</td><td bgcolor="#EEFFFF">12<td>XII</td><td bgcolor="#EEFFFF">40</td><td>XL</td><td>
<tr><td bgcolor="#EEFFFF">3</td><td>III</td><td bgcolor="#EEFFFF">13<td>XIII</td><td bgcolor="#EEFFFF">50</td><td>L</td><td>
<tr><td bgcolor="#EEFFFF">4</td><td>IV</td><td bgcolor="#EEFFFF">14<td>XIV</td><td bgcolor="#EEFFFF">60</td><td>LX</td><td>
<tr><td bgcolor="#EEFFFF">5</td><td>V</td><td bgcolor="#EEFFFF">15<td>XV</td><td bgcolor="#EEFFFF">70</td><td>LXX</td><td>
<tr><td bgcolor="#EEFFFF">6</td><td>VI</td><td bgcolor="#EEFFFF">16<td>XVI</td><td bgcolor="#EEFFFF">80</td><td>LXXX</td><td>
<tr><td bgcolor="#EEFFFF">7</td><td>VII</td><td bgcolor="#EEFFFF">17<td>XVII</td><td bgcolor="#EEFFFF">90</td><td>XC</td><td>
<tr><td bgcolor="#EEFFFF">8</td><td>VIII</td><td bgcolor="#EEFFFF">18<td>XVIII</td><td bgcolor="#EEFFFF">100</td><td>C</td><td>
<tr><td bgcolor="#EEFFFF">9</td><td>IX</td><td bgcolor="#EEFFFF">19<td>XIX</td><td bgcolor="#EEFFFF">500</td><td>D</td><td>
<tr><td bgcolor="#EEFFFF">10</td><td>X</td><td bgcolor="#EEFFFF">20<td>XX</td><td bgcolor="#EEFFFF">1000</td><td>M</td><td>
</table>
</center>
<br/>
<p>
I は 1、 V は 5、 X は 10、 L は 50、 C は 100、 D は 500、 M は 1000、 他の例は上の表を見てください。小さい数が大きい数に続いている、つまり右側にあるときは足し算をします。小さい数が大きい数の前に、つまり左にあるときは、大きい数から小さい数を引きます。大きい数字の前にあって引き算を表す小さな数字は一回の引き算あたりひとつしかありません。
</p>
<p>
ローマ数字をアラビア数字（通常の数字）の表記（10 進表示）に変換して出力するプログラムを作成してください。ただし、与えられるローマ数字は上記のルールにのみ従っています(実際のローマ数字の表記にはもっと細かいルールがありますが、ここでは考慮する必要はありません。たとえば、実際のローマ数字ではI はV かX から、X はL かC から、C はD かM からしか引き算しませんし、同じローマ数字は４つ以上（または５つ以上）足し並べることはありません。)
</p>
<H2>Input</H2>
<p>
複数のデータセットが与えられます。それぞれのデータセットにローマ数字（半角大文字のI, V, X, L, C, D ,M で表される連続した文字列）が１行に与えられます。与えられるローマ数字の文字列の長さはおのおの 100 以下です。
</p>
<p>
データセットの数は 50 を超えません。
</p>
<H2>Output</H2>
<p>
各データセットに対し、アラビア数字（整数）を１行に出力して下さい。
</p>
<H2>Sample Input</H2>
<pre>
IV
CCCCLXXXXVIIII
CDXCIX
</pre>
<H2>Output for the Sample Input</H2>
<pre>
4
499
499
</pre>
|
s395961045 | p00039 | Accepted | import sys
def dec_num(x):
for i in range(len(x)):
if x[i] == 2:
x[i] = 5
elif x[i] == 3:
x[i] = 10
elif x[i] == 4:
x[i] = 50
elif x[i] == 5:
x[i] = 100
elif x[i] == 6:
x[i] = 500
elif x[i] == 7:
x[i] = 1000
def to_index(x):
if x == 1:
return 1
elif x == 5:
return 2
elif x == 10:
return 3
elif x == 50:
return 4
elif x == 100:
return 5
elif x == 500:
return 6
elif x == 1000:
return 7
def toNum(x):
result = 0
tmp = x[0]
for i in range(len(x)):
if tmp < x[i]:
result += x[i]-tmp
elif i < len(x)-1 and x[i] < x[i+1]:
result += 0
else:
result += x[i]
tmp = x[i]
return result
for line in sys.stdin.readlines():
line = line.translate(str.maketrans('IVXLCDM', '1234567'))
num = list(map(int, (' '.join(line)).split()))
dec_num(num)
print(toNum(num)) | IV
CCCCLXXXXVIIII
CDXCIX
| 4
499
499
|
<H1>ローマ数字</H1>
<p>
古代ローマでは数を数えることは難しい仕事でした。アラビア数字の 0,1,2,3,…, 9 はまだ流布していませんでした。その代わり次のような記号が使われていました。
</p>
<center>
<table border=1>
<tr>
<td bgcolor="#EEFFFF" width="100">アラビア数字</td><td width="100">ローマ数字</td><td bgcolor="#EEFFFF" width="100">アラビア数字</td><td width="100">ローマ数字</td><td bgcolor="#EEFFFF" width="100">アラビア数字</td><td width="100">ローマ数字</td>
</tr>
<tr><td bgcolor="#EEFFFF">1</td><td>I</td><td bgcolor="#EEFFFF">11<td>XI</td><td bgcolor="#EEFFFF">30</td><td>XXX</td><td>
<tr><td bgcolor="#EEFFFF">2</td><td>II</td><td bgcolor="#EEFFFF">12<td>XII</td><td bgcolor="#EEFFFF">40</td><td>XL</td><td>
<tr><td bgcolor="#EEFFFF">3</td><td>III</td><td bgcolor="#EEFFFF">13<td>XIII</td><td bgcolor="#EEFFFF">50</td><td>L</td><td>
<tr><td bgcolor="#EEFFFF">4</td><td>IV</td><td bgcolor="#EEFFFF">14<td>XIV</td><td bgcolor="#EEFFFF">60</td><td>LX</td><td>
<tr><td bgcolor="#EEFFFF">5</td><td>V</td><td bgcolor="#EEFFFF">15<td>XV</td><td bgcolor="#EEFFFF">70</td><td>LXX</td><td>
<tr><td bgcolor="#EEFFFF">6</td><td>VI</td><td bgcolor="#EEFFFF">16<td>XVI</td><td bgcolor="#EEFFFF">80</td><td>LXXX</td><td>
<tr><td bgcolor="#EEFFFF">7</td><td>VII</td><td bgcolor="#EEFFFF">17<td>XVII</td><td bgcolor="#EEFFFF">90</td><td>XC</td><td>
<tr><td bgcolor="#EEFFFF">8</td><td>VIII</td><td bgcolor="#EEFFFF">18<td>XVIII</td><td bgcolor="#EEFFFF">100</td><td>C</td><td>
<tr><td bgcolor="#EEFFFF">9</td><td>IX</td><td bgcolor="#EEFFFF">19<td>XIX</td><td bgcolor="#EEFFFF">500</td><td>D</td><td>
<tr><td bgcolor="#EEFFFF">10</td><td>X</td><td bgcolor="#EEFFFF">20<td>XX</td><td bgcolor="#EEFFFF">1000</td><td>M</td><td>
</table>
</center>
<br/>
<p>
I は 1、 V は 5、 X は 10、 L は 50、 C は 100、 D は 500、 M は 1000、 他の例は上の表を見てください。小さい数が大きい数に続いている、つまり右側にあるときは足し算をします。小さい数が大きい数の前に、つまり左にあるときは、大きい数から小さい数を引きます。大きい数字の前にあって引き算を表す小さな数字は一回の引き算あたりひとつしかありません。
</p>
<p>
ローマ数字をアラビア数字（通常の数字）の表記（10 進表示）に変換して出力するプログラムを作成してください。ただし、与えられるローマ数字は上記のルールにのみ従っています(実際のローマ数字の表記にはもっと細かいルールがありますが、ここでは考慮する必要はありません。たとえば、実際のローマ数字ではI はV かX から、X はL かC から、C はD かM からしか引き算しませんし、同じローマ数字は４つ以上（または５つ以上）足し並べることはありません。)
</p>
<H2>Input</H2>
<p>
複数のデータセットが与えられます。それぞれのデータセットにローマ数字（半角大文字のI, V, X, L, C, D ,M で表される連続した文字列）が１行に与えられます。与えられるローマ数字の文字列の長さはおのおの 100 以下です。
</p>
<p>
データセットの数は 50 を超えません。
</p>
<H2>Output</H2>
<p>
各データセットに対し、アラビア数字（整数）を１行に出力して下さい。
</p>
<H2>Sample Input</H2>
<pre>
IV
CCCCLXXXXVIIII
CDXCIX
</pre>
<H2>Output for the Sample Input</H2>
<pre>
4
499
499
</pre>
|
s255221331 | p00039 | Accepted | #"memo roiti 875674"
d={"I":1, "V":5, "X":10, "L":50, "C":100, "D":500, "M":1000}
while 1:
try:
n=raw_input()
t=0
value=1000
for i in n:
if value>=d[i]:
value=d[i]
t=t+value
else:
t=t-value*2
value=d[i]
t=t+value
print t
except:
break | IV
CCCCLXXXXVIIII
CDXCIX
| 4
499
499
|
<H1>ローマ数字</H1>
<p>
古代ローマでは数を数えることは難しい仕事でした。アラビア数字の 0,1,2,3,…, 9 はまだ流布していませんでした。その代わり次のような記号が使われていました。
</p>
<center>
<table border=1>
<tr>
<td bgcolor="#EEFFFF" width="100">アラビア数字</td><td width="100">ローマ数字</td><td bgcolor="#EEFFFF" width="100">アラビア数字</td><td width="100">ローマ数字</td><td bgcolor="#EEFFFF" width="100">アラビア数字</td><td width="100">ローマ数字</td>
</tr>
<tr><td bgcolor="#EEFFFF">1</td><td>I</td><td bgcolor="#EEFFFF">11<td>XI</td><td bgcolor="#EEFFFF">30</td><td>XXX</td><td>
<tr><td bgcolor="#EEFFFF">2</td><td>II</td><td bgcolor="#EEFFFF">12<td>XII</td><td bgcolor="#EEFFFF">40</td><td>XL</td><td>
<tr><td bgcolor="#EEFFFF">3</td><td>III</td><td bgcolor="#EEFFFF">13<td>XIII</td><td bgcolor="#EEFFFF">50</td><td>L</td><td>
<tr><td bgcolor="#EEFFFF">4</td><td>IV</td><td bgcolor="#EEFFFF">14<td>XIV</td><td bgcolor="#EEFFFF">60</td><td>LX</td><td>
<tr><td bgcolor="#EEFFFF">5</td><td>V</td><td bgcolor="#EEFFFF">15<td>XV</td><td bgcolor="#EEFFFF">70</td><td>LXX</td><td>
<tr><td bgcolor="#EEFFFF">6</td><td>VI</td><td bgcolor="#EEFFFF">16<td>XVI</td><td bgcolor="#EEFFFF">80</td><td>LXXX</td><td>
<tr><td bgcolor="#EEFFFF">7</td><td>VII</td><td bgcolor="#EEFFFF">17<td>XVII</td><td bgcolor="#EEFFFF">90</td><td>XC</td><td>
<tr><td bgcolor="#EEFFFF">8</td><td>VIII</td><td bgcolor="#EEFFFF">18<td>XVIII</td><td bgcolor="#EEFFFF">100</td><td>C</td><td>
<tr><td bgcolor="#EEFFFF">9</td><td>IX</td><td bgcolor="#EEFFFF">19<td>XIX</td><td bgcolor="#EEFFFF">500</td><td>D</td><td>
<tr><td bgcolor="#EEFFFF">10</td><td>X</td><td bgcolor="#EEFFFF">20<td>XX</td><td bgcolor="#EEFFFF">1000</td><td>M</td><td>
</table>
</center>
<br/>
<p>
I は 1、 V は 5、 X は 10、 L は 50、 C は 100、 D は 500、 M は 1000、 他の例は上の表を見てください。小さい数が大きい数に続いている、つまり右側にあるときは足し算をします。小さい数が大きい数の前に、つまり左にあるときは、大きい数から小さい数を引きます。大きい数字の前にあって引き算を表す小さな数字は一回の引き算あたりひとつしかありません。
</p>
<p>
ローマ数字をアラビア数字（通常の数字）の表記（10 進表示）に変換して出力するプログラムを作成してください。ただし、与えられるローマ数字は上記のルールにのみ従っています(実際のローマ数字の表記にはもっと細かいルールがありますが、ここでは考慮する必要はありません。たとえば、実際のローマ数字ではI はV かX から、X はL かC から、C はD かM からしか引き算しませんし、同じローマ数字は４つ以上（または５つ以上）足し並べることはありません。)
</p>
<H2>Input</H2>
<p>
複数のデータセットが与えられます。それぞれのデータセットにローマ数字（半角大文字のI, V, X, L, C, D ,M で表される連続した文字列）が１行に与えられます。与えられるローマ数字の文字列の長さはおのおの 100 以下です。
</p>
<p>
データセットの数は 50 を超えません。
</p>
<H2>Output</H2>
<p>
各データセットに対し、アラビア数字（整数）を１行に出力して下さい。
</p>
<H2>Sample Input</H2>
<pre>
IV
CCCCLXXXXVIIII
CDXCIX
</pre>
<H2>Output for the Sample Input</H2>
<pre>
4
499
499
</pre>
|
s768841132 | p00039 | Accepted | import sys
def todec(s):
roman_dic = {'I': 1, 'V': 5, 'X': 10, 'L': 50, 'C': 100, 'D': 500, 'M': 1000}
ret, prev = 0, 0
for i in reversed(s):
d = roman_dic[i]
if d < prev:
ret -= d
else:
ret += d
prev = d
return ret
A = sys.stdin.read().split()
for a in A:
print(todec(a)) | IV
CCCCLXXXXVIIII
CDXCIX
| 4
499
499
|
<H1>ローマ数字</H1>
<p>
古代ローマでは数を数えることは難しい仕事でした。アラビア数字の 0,1,2,3,…, 9 はまだ流布していませんでした。その代わり次のような記号が使われていました。
</p>
<center>
<table border=1>
<tr>
<td bgcolor="#EEFFFF" width="100">アラビア数字</td><td width="100">ローマ数字</td><td bgcolor="#EEFFFF" width="100">アラビア数字</td><td width="100">ローマ数字</td><td bgcolor="#EEFFFF" width="100">アラビア数字</td><td width="100">ローマ数字</td>
</tr>
<tr><td bgcolor="#EEFFFF">1</td><td>I</td><td bgcolor="#EEFFFF">11<td>XI</td><td bgcolor="#EEFFFF">30</td><td>XXX</td><td>
<tr><td bgcolor="#EEFFFF">2</td><td>II</td><td bgcolor="#EEFFFF">12<td>XII</td><td bgcolor="#EEFFFF">40</td><td>XL</td><td>
<tr><td bgcolor="#EEFFFF">3</td><td>III</td><td bgcolor="#EEFFFF">13<td>XIII</td><td bgcolor="#EEFFFF">50</td><td>L</td><td>
<tr><td bgcolor="#EEFFFF">4</td><td>IV</td><td bgcolor="#EEFFFF">14<td>XIV</td><td bgcolor="#EEFFFF">60</td><td>LX</td><td>
<tr><td bgcolor="#EEFFFF">5</td><td>V</td><td bgcolor="#EEFFFF">15<td>XV</td><td bgcolor="#EEFFFF">70</td><td>LXX</td><td>
<tr><td bgcolor="#EEFFFF">6</td><td>VI</td><td bgcolor="#EEFFFF">16<td>XVI</td><td bgcolor="#EEFFFF">80</td><td>LXXX</td><td>
<tr><td bgcolor="#EEFFFF">7</td><td>VII</td><td bgcolor="#EEFFFF">17<td>XVII</td><td bgcolor="#EEFFFF">90</td><td>XC</td><td>
<tr><td bgcolor="#EEFFFF">8</td><td>VIII</td><td bgcolor="#EEFFFF">18<td>XVIII</td><td bgcolor="#EEFFFF">100</td><td>C</td><td>
<tr><td bgcolor="#EEFFFF">9</td><td>IX</td><td bgcolor="#EEFFFF">19<td>XIX</td><td bgcolor="#EEFFFF">500</td><td>D</td><td>
<tr><td bgcolor="#EEFFFF">10</td><td>X</td><td bgcolor="#EEFFFF">20<td>XX</td><td bgcolor="#EEFFFF">1000</td><td>M</td><td>
</table>
</center>
<br/>
<p>
I は 1、 V は 5、 X は 10、 L は 50、 C は 100、 D は 500、 M は 1000、 他の例は上の表を見てください。小さい数が大きい数に続いている、つまり右側にあるときは足し算をします。小さい数が大きい数の前に、つまり左にあるときは、大きい数から小さい数を引きます。大きい数字の前にあって引き算を表す小さな数字は一回の引き算あたりひとつしかありません。
</p>
<p>
ローマ数字をアラビア数字（通常の数字）の表記（10 進表示）に変換して出力するプログラムを作成してください。ただし、与えられるローマ数字は上記のルールにのみ従っています(実際のローマ数字の表記にはもっと細かいルールがありますが、ここでは考慮する必要はありません。たとえば、実際のローマ数字ではI はV かX から、X はL かC から、C はD かM からしか引き算しませんし、同じローマ数字は４つ以上（または５つ以上）足し並べることはありません。)
</p>
<H2>Input</H2>
<p>
複数のデータセットが与えられます。それぞれのデータセットにローマ数字（半角大文字のI, V, X, L, C, D ,M で表される連続した文字列）が１行に与えられます。与えられるローマ数字の文字列の長さはおのおの 100 以下です。
</p>
<p>
データセットの数は 50 を超えません。
</p>
<H2>Output</H2>
<p>
各データセットに対し、アラビア数字（整数）を１行に出力して下さい。
</p>
<H2>Sample Input</H2>
<pre>
IV
CCCCLXXXXVIIII
CDXCIX
</pre>
<H2>Output for the Sample Input</H2>
<pre>
4
499
499
</pre>
|
s396661985 | p00039 | Accepted |
def Roman_numerals(x):
if x=='I':
return 1
elif x=='V':
return 5
elif x=='X':
return 10
elif x=='L':
return 50
elif x=='C':
return 100
elif x=='D':
return 500
elif x=='M':
return 1000
while True:
try:
s=0
string=input()
for i in range(len(string)):
tmp_now =Roman_numerals(string[i:i+1])
tmp_next=Roman_numerals(string[i+1:i+2])
if (tmp_now==1 and tmp_next==5):
s+=-1
elif (tmp_now==1 and tmp_next==10):
s+=-1
elif (tmp_now==10 and tmp_next==50):
s+=-10
elif (tmp_now==10 and tmp_next==100):
s+=-10
elif (tmp_now==100 and tmp_next==500):
s+=-100
elif (tmp_now==100 and tmp_next==1000):
s+=-100
else:
s+=tmp_now
print(s)
except EOFError:
break | IV
CCCCLXXXXVIIII
CDXCIX
| 4
499
499
|
<H1>ローマ数字</H1>
<p>
古代ローマでは数を数えることは難しい仕事でした。アラビア数字の 0,1,2,3,…, 9 はまだ流布していませんでした。その代わり次のような記号が使われていました。
</p>
<center>
<table border=1>
<tr>
<td bgcolor="#EEFFFF" width="100">アラビア数字</td><td width="100">ローマ数字</td><td bgcolor="#EEFFFF" width="100">アラビア数字</td><td width="100">ローマ数字</td><td bgcolor="#EEFFFF" width="100">アラビア数字</td><td width="100">ローマ数字</td>
</tr>
<tr><td bgcolor="#EEFFFF">1</td><td>I</td><td bgcolor="#EEFFFF">11<td>XI</td><td bgcolor="#EEFFFF">30</td><td>XXX</td><td>
<tr><td bgcolor="#EEFFFF">2</td><td>II</td><td bgcolor="#EEFFFF">12<td>XII</td><td bgcolor="#EEFFFF">40</td><td>XL</td><td>
<tr><td bgcolor="#EEFFFF">3</td><td>III</td><td bgcolor="#EEFFFF">13<td>XIII</td><td bgcolor="#EEFFFF">50</td><td>L</td><td>
<tr><td bgcolor="#EEFFFF">4</td><td>IV</td><td bgcolor="#EEFFFF">14<td>XIV</td><td bgcolor="#EEFFFF">60</td><td>LX</td><td>
<tr><td bgcolor="#EEFFFF">5</td><td>V</td><td bgcolor="#EEFFFF">15<td>XV</td><td bgcolor="#EEFFFF">70</td><td>LXX</td><td>
<tr><td bgcolor="#EEFFFF">6</td><td>VI</td><td bgcolor="#EEFFFF">16<td>XVI</td><td bgcolor="#EEFFFF">80</td><td>LXXX</td><td>
<tr><td bgcolor="#EEFFFF">7</td><td>VII</td><td bgcolor="#EEFFFF">17<td>XVII</td><td bgcolor="#EEFFFF">90</td><td>XC</td><td>
<tr><td bgcolor="#EEFFFF">8</td><td>VIII</td><td bgcolor="#EEFFFF">18<td>XVIII</td><td bgcolor="#EEFFFF">100</td><td>C</td><td>
<tr><td bgcolor="#EEFFFF">9</td><td>IX</td><td bgcolor="#EEFFFF">19<td>XIX</td><td bgcolor="#EEFFFF">500</td><td>D</td><td>
<tr><td bgcolor="#EEFFFF">10</td><td>X</td><td bgcolor="#EEFFFF">20<td>XX</td><td bgcolor="#EEFFFF">1000</td><td>M</td><td>
</table>
</center>
<br/>
<p>
I は 1、 V は 5、 X は 10、 L は 50、 C は 100、 D は 500、 M は 1000、 他の例は上の表を見てください。小さい数が大きい数に続いている、つまり右側にあるときは足し算をします。小さい数が大きい数の前に、つまり左にあるときは、大きい数から小さい数を引きます。大きい数字の前にあって引き算を表す小さな数字は一回の引き算あたりひとつしかありません。
</p>
<p>
ローマ数字をアラビア数字（通常の数字）の表記（10 進表示）に変換して出力するプログラムを作成してください。ただし、与えられるローマ数字は上記のルールにのみ従っています(実際のローマ数字の表記にはもっと細かいルールがありますが、ここでは考慮する必要はありません。たとえば、実際のローマ数字ではI はV かX から、X はL かC から、C はD かM からしか引き算しませんし、同じローマ数字は４つ以上（または５つ以上）足し並べることはありません。)
</p>
<H2>Input</H2>
<p>
複数のデータセットが与えられます。それぞれのデータセットにローマ数字（半角大文字のI, V, X, L, C, D ,M で表される連続した文字列）が１行に与えられます。与えられるローマ数字の文字列の長さはおのおの 100 以下です。
</p>
<p>
データセットの数は 50 を超えません。
</p>
<H2>Output</H2>
<p>
各データセットに対し、アラビア数字（整数）を１行に出力して下さい。
</p>
<H2>Sample Input</H2>
<pre>
IV
CCCCLXXXXVIIII
CDXCIX
</pre>
<H2>Output for the Sample Input</H2>
<pre>
4
499
499
</pre>
|
s644073322 | p00039 | Accepted | #encoding=utf-8
import sys
def inp():
for line in sys.stdin:
word = line.split()
je(word[0])
def je(word):
ans, i = 0, 0
while True:
if word[i] == "M":
ans += 1000
elif word[i] == "D":
ans += 500
elif word[i] == "C":
ans += 100
try:
if word[i + 1] == "M":
ans += 800
i += 1
elif word[i + 1] == "D":
ans += 300
i += 1
except: pass
elif word[i] == "L":
ans += 50
elif word[i] == "X":
ans += 10
try:
if word[i + 1] == "C":
ans += 80
i += 1
elif word[i + 1] == "L":
ans += 30
i += 1
except: pass
elif word[i] == "V":
ans += 5
elif word[i] == "I":
ans += 1
try:
if word[i + 1] == "X":
ans += 8
i += 1
elif word[i + 1] == "V":
ans += 3
i += 1
except: pass
i += 1
if i == len(word):
print ans
break
if __name__ == "__main__":
inp() | IV
CCCCLXXXXVIIII
CDXCIX
| 4
499
499
|
<H1>ローマ数字</H1>
<p>
古代ローマでは数を数えることは難しい仕事でした。アラビア数字の 0,1,2,3,…, 9 はまだ流布していませんでした。その代わり次のような記号が使われていました。
</p>
<center>
<table border=1>
<tr>
<td bgcolor="#EEFFFF" width="100">アラビア数字</td><td width="100">ローマ数字</td><td bgcolor="#EEFFFF" width="100">アラビア数字</td><td width="100">ローマ数字</td><td bgcolor="#EEFFFF" width="100">アラビア数字</td><td width="100">ローマ数字</td>
</tr>
<tr><td bgcolor="#EEFFFF">1</td><td>I</td><td bgcolor="#EEFFFF">11<td>XI</td><td bgcolor="#EEFFFF">30</td><td>XXX</td><td>
<tr><td bgcolor="#EEFFFF">2</td><td>II</td><td bgcolor="#EEFFFF">12<td>XII</td><td bgcolor="#EEFFFF">40</td><td>XL</td><td>
<tr><td bgcolor="#EEFFFF">3</td><td>III</td><td bgcolor="#EEFFFF">13<td>XIII</td><td bgcolor="#EEFFFF">50</td><td>L</td><td>
<tr><td bgcolor="#EEFFFF">4</td><td>IV</td><td bgcolor="#EEFFFF">14<td>XIV</td><td bgcolor="#EEFFFF">60</td><td>LX</td><td>
<tr><td bgcolor="#EEFFFF">5</td><td>V</td><td bgcolor="#EEFFFF">15<td>XV</td><td bgcolor="#EEFFFF">70</td><td>LXX</td><td>
<tr><td bgcolor="#EEFFFF">6</td><td>VI</td><td bgcolor="#EEFFFF">16<td>XVI</td><td bgcolor="#EEFFFF">80</td><td>LXXX</td><td>
<tr><td bgcolor="#EEFFFF">7</td><td>VII</td><td bgcolor="#EEFFFF">17<td>XVII</td><td bgcolor="#EEFFFF">90</td><td>XC</td><td>
<tr><td bgcolor="#EEFFFF">8</td><td>VIII</td><td bgcolor="#EEFFFF">18<td>XVIII</td><td bgcolor="#EEFFFF">100</td><td>C</td><td>
<tr><td bgcolor="#EEFFFF">9</td><td>IX</td><td bgcolor="#EEFFFF">19<td>XIX</td><td bgcolor="#EEFFFF">500</td><td>D</td><td>
<tr><td bgcolor="#EEFFFF">10</td><td>X</td><td bgcolor="#EEFFFF">20<td>XX</td><td bgcolor="#EEFFFF">1000</td><td>M</td><td>
</table>
</center>
<br/>
<p>
I は 1、 V は 5、 X は 10、 L は 50、 C は 100、 D は 500、 M は 1000、 他の例は上の表を見てください。小さい数が大きい数に続いている、つまり右側にあるときは足し算をします。小さい数が大きい数の前に、つまり左にあるときは、大きい数から小さい数を引きます。大きい数字の前にあって引き算を表す小さな数字は一回の引き算あたりひとつしかありません。
</p>
<p>
ローマ数字をアラビア数字（通常の数字）の表記（10 進表示）に変換して出力するプログラムを作成してください。ただし、与えられるローマ数字は上記のルールにのみ従っています(実際のローマ数字の表記にはもっと細かいルールがありますが、ここでは考慮する必要はありません。たとえば、実際のローマ数字ではI はV かX から、X はL かC から、C はD かM からしか引き算しませんし、同じローマ数字は４つ以上（または５つ以上）足し並べることはありません。)
</p>
<H2>Input</H2>
<p>
複数のデータセットが与えられます。それぞれのデータセットにローマ数字（半角大文字のI, V, X, L, C, D ,M で表される連続した文字列）が１行に与えられます。与えられるローマ数字の文字列の長さはおのおの 100 以下です。
</p>
<p>
データセットの数は 50 を超えません。
</p>
<H2>Output</H2>
<p>
各データセットに対し、アラビア数字（整数）を１行に出力して下さい。
</p>
<H2>Sample Input</H2>
<pre>
IV
CCCCLXXXXVIIII
CDXCIX
</pre>
<H2>Output for the Sample Input</H2>
<pre>
4
499
499
</pre>
|
s964058295 | p00039 | Accepted | # -*- coding: utf-8 -*-
import sys
rom = {'I':1, 'V':5, 'X':10, 'L':50, 'C':100, 'D':500, 'M':1000}
for line in sys.stdin:
ans = 0
for i in range(len(line)-2):
if rom[line[i]] < rom[line[i+1]]:
ans -= rom[line[i]]
else:
ans += rom[line[i]]
ans += rom[line[len(line)-2]]
print ans | IV
CCCCLXXXXVIIII
CDXCIX
| 4
499
499
|
<H1>ローマ数字</H1>
<p>
古代ローマでは数を数えることは難しい仕事でした。アラビア数字の 0,1,2,3,…, 9 はまだ流布していませんでした。その代わり次のような記号が使われていました。
</p>
<center>
<table border=1>
<tr>
<td bgcolor="#EEFFFF" width="100">アラビア数字</td><td width="100">ローマ数字</td><td bgcolor="#EEFFFF" width="100">アラビア数字</td><td width="100">ローマ数字</td><td bgcolor="#EEFFFF" width="100">アラビア数字</td><td width="100">ローマ数字</td>
</tr>
<tr><td bgcolor="#EEFFFF">1</td><td>I</td><td bgcolor="#EEFFFF">11<td>XI</td><td bgcolor="#EEFFFF">30</td><td>XXX</td><td>
<tr><td bgcolor="#EEFFFF">2</td><td>II</td><td bgcolor="#EEFFFF">12<td>XII</td><td bgcolor="#EEFFFF">40</td><td>XL</td><td>
<tr><td bgcolor="#EEFFFF">3</td><td>III</td><td bgcolor="#EEFFFF">13<td>XIII</td><td bgcolor="#EEFFFF">50</td><td>L</td><td>
<tr><td bgcolor="#EEFFFF">4</td><td>IV</td><td bgcolor="#EEFFFF">14<td>XIV</td><td bgcolor="#EEFFFF">60</td><td>LX</td><td>
<tr><td bgcolor="#EEFFFF">5</td><td>V</td><td bgcolor="#EEFFFF">15<td>XV</td><td bgcolor="#EEFFFF">70</td><td>LXX</td><td>
<tr><td bgcolor="#EEFFFF">6</td><td>VI</td><td bgcolor="#EEFFFF">16<td>XVI</td><td bgcolor="#EEFFFF">80</td><td>LXXX</td><td>
<tr><td bgcolor="#EEFFFF">7</td><td>VII</td><td bgcolor="#EEFFFF">17<td>XVII</td><td bgcolor="#EEFFFF">90</td><td>XC</td><td>
<tr><td bgcolor="#EEFFFF">8</td><td>VIII</td><td bgcolor="#EEFFFF">18<td>XVIII</td><td bgcolor="#EEFFFF">100</td><td>C</td><td>
<tr><td bgcolor="#EEFFFF">9</td><td>IX</td><td bgcolor="#EEFFFF">19<td>XIX</td><td bgcolor="#EEFFFF">500</td><td>D</td><td>
<tr><td bgcolor="#EEFFFF">10</td><td>X</td><td bgcolor="#EEFFFF">20<td>XX</td><td bgcolor="#EEFFFF">1000</td><td>M</td><td>
</table>
</center>
<br/>
<p>
I は 1、 V は 5、 X は 10、 L は 50、 C は 100、 D は 500、 M は 1000、 他の例は上の表を見てください。小さい数が大きい数に続いている、つまり右側にあるときは足し算をします。小さい数が大きい数の前に、つまり左にあるときは、大きい数から小さい数を引きます。大きい数字の前にあって引き算を表す小さな数字は一回の引き算あたりひとつしかありません。
</p>
<p>
ローマ数字をアラビア数字（通常の数字）の表記（10 進表示）に変換して出力するプログラムを作成してください。ただし、与えられるローマ数字は上記のルールにのみ従っています(実際のローマ数字の表記にはもっと細かいルールがありますが、ここでは考慮する必要はありません。たとえば、実際のローマ数字ではI はV かX から、X はL かC から、C はD かM からしか引き算しませんし、同じローマ数字は４つ以上（または５つ以上）足し並べることはありません。)
</p>
<H2>Input</H2>
<p>
複数のデータセットが与えられます。それぞれのデータセットにローマ数字（半角大文字のI, V, X, L, C, D ,M で表される連続した文字列）が１行に与えられます。与えられるローマ数字の文字列の長さはおのおの 100 以下です。
</p>
<p>
データセットの数は 50 を超えません。
</p>
<H2>Output</H2>
<p>
各データセットに対し、アラビア数字（整数）を１行に出力して下さい。
</p>
<H2>Sample Input</H2>
<pre>
IV
CCCCLXXXXVIIII
CDXCIX
</pre>
<H2>Output for the Sample Input</H2>
<pre>
4
499
499
</pre>
|
s098951115 | p00039 | Accepted | import sys
for line in sys.stdin:
roman = list(line)
roman.pop()
for i in range(len(roman)):
if roman[i] == 'I':
roman[i] = 1
elif roman[i] == 'V':
roman[i] = 5
elif roman[i] == 'X':
roman[i] = 10
elif roman[i] == 'L':
roman[i] = 50
elif roman[i] == 'C':
roman[i] = 100
elif roman[i] == 'D':
roman[i] = 500
elif roman[i] == 'M':
roman[i] = 1000
x = 0
for i in range(len(roman)):
if i == len(roman) - 1:
x += roman[i]
elif roman[i] < roman[i+1]:
x -= roman[i]
else:
x += roman[i]
print(x) | IV
CCCCLXXXXVIIII
CDXCIX
| 4
499
499
|
<H1>ローマ数字</H1>
<p>
古代ローマでは数を数えることは難しい仕事でした。アラビア数字の 0,1,2,3,…, 9 はまだ流布していませんでした。その代わり次のような記号が使われていました。
</p>
<center>
<table border=1>
<tr>
<td bgcolor="#EEFFFF" width="100">アラビア数字</td><td width="100">ローマ数字</td><td bgcolor="#EEFFFF" width="100">アラビア数字</td><td width="100">ローマ数字</td><td bgcolor="#EEFFFF" width="100">アラビア数字</td><td width="100">ローマ数字</td>
</tr>
<tr><td bgcolor="#EEFFFF">1</td><td>I</td><td bgcolor="#EEFFFF">11<td>XI</td><td bgcolor="#EEFFFF">30</td><td>XXX</td><td>
<tr><td bgcolor="#EEFFFF">2</td><td>II</td><td bgcolor="#EEFFFF">12<td>XII</td><td bgcolor="#EEFFFF">40</td><td>XL</td><td>
<tr><td bgcolor="#EEFFFF">3</td><td>III</td><td bgcolor="#EEFFFF">13<td>XIII</td><td bgcolor="#EEFFFF">50</td><td>L</td><td>
<tr><td bgcolor="#EEFFFF">4</td><td>IV</td><td bgcolor="#EEFFFF">14<td>XIV</td><td bgcolor="#EEFFFF">60</td><td>LX</td><td>
<tr><td bgcolor="#EEFFFF">5</td><td>V</td><td bgcolor="#EEFFFF">15<td>XV</td><td bgcolor="#EEFFFF">70</td><td>LXX</td><td>
<tr><td bgcolor="#EEFFFF">6</td><td>VI</td><td bgcolor="#EEFFFF">16<td>XVI</td><td bgcolor="#EEFFFF">80</td><td>LXXX</td><td>
<tr><td bgcolor="#EEFFFF">7</td><td>VII</td><td bgcolor="#EEFFFF">17<td>XVII</td><td bgcolor="#EEFFFF">90</td><td>XC</td><td>
<tr><td bgcolor="#EEFFFF">8</td><td>VIII</td><td bgcolor="#EEFFFF">18<td>XVIII</td><td bgcolor="#EEFFFF">100</td><td>C</td><td>
<tr><td bgcolor="#EEFFFF">9</td><td>IX</td><td bgcolor="#EEFFFF">19<td>XIX</td><td bgcolor="#EEFFFF">500</td><td>D</td><td>
<tr><td bgcolor="#EEFFFF">10</td><td>X</td><td bgcolor="#EEFFFF">20<td>XX</td><td bgcolor="#EEFFFF">1000</td><td>M</td><td>
</table>
</center>
<br/>
<p>
I は 1、 V は 5、 X は 10、 L は 50、 C は 100、 D は 500、 M は 1000、 他の例は上の表を見てください。小さい数が大きい数に続いている、つまり右側にあるときは足し算をします。小さい数が大きい数の前に、つまり左にあるときは、大きい数から小さい数を引きます。大きい数字の前にあって引き算を表す小さな数字は一回の引き算あたりひとつしかありません。
</p>
<p>
ローマ数字をアラビア数字（通常の数字）の表記（10 進表示）に変換して出力するプログラムを作成してください。ただし、与えられるローマ数字は上記のルールにのみ従っています(実際のローマ数字の表記にはもっと細かいルールがありますが、ここでは考慮する必要はありません。たとえば、実際のローマ数字ではI はV かX から、X はL かC から、C はD かM からしか引き算しませんし、同じローマ数字は４つ以上（または５つ以上）足し並べることはありません。)
</p>
<H2>Input</H2>
<p>
複数のデータセットが与えられます。それぞれのデータセットにローマ数字（半角大文字のI, V, X, L, C, D ,M で表される連続した文字列）が１行に与えられます。与えられるローマ数字の文字列の長さはおのおの 100 以下です。
</p>
<p>
データセットの数は 50 を超えません。
</p>
<H2>Output</H2>
<p>
各データセットに対し、アラビア数字（整数）を１行に出力して下さい。
</p>
<H2>Sample Input</H2>
<pre>
IV
CCCCLXXXXVIIII
CDXCIX
</pre>
<H2>Output for the Sample Input</H2>
<pre>
4
499
499
</pre>
|
s962805485 | p00039 | Accepted | import sys
h = {'I' : 1, 'V' : 5, 'X' : 10, 'L' : 50, 'C' : 100, 'D' : 500, 'M' : 1000, 'E' : 0}
for line in sys.stdin:
line = line.rstrip()
line += 'E'
ans = 0
i = 0
while i < len(line) - 1:
if h[line[i]] >= h[line[i+1]]:
ans += h[line[i]]
else:
ans += h[line[i+1]] - h[line[i]]
i += 1
i += 1
print(ans) | IV
CCCCLXXXXVIIII
CDXCIX
| 4
499
499
|
<H1>ローマ数字</H1>
<p>
古代ローマでは数を数えることは難しい仕事でした。アラビア数字の 0,1,2,3,…, 9 はまだ流布していませんでした。その代わり次のような記号が使われていました。
</p>
<center>
<table border=1>
<tr>
<td bgcolor="#EEFFFF" width="100">アラビア数字</td><td width="100">ローマ数字</td><td bgcolor="#EEFFFF" width="100">アラビア数字</td><td width="100">ローマ数字</td><td bgcolor="#EEFFFF" width="100">アラビア数字</td><td width="100">ローマ数字</td>
</tr>
<tr><td bgcolor="#EEFFFF">1</td><td>I</td><td bgcolor="#EEFFFF">11<td>XI</td><td bgcolor="#EEFFFF">30</td><td>XXX</td><td>
<tr><td bgcolor="#EEFFFF">2</td><td>II</td><td bgcolor="#EEFFFF">12<td>XII</td><td bgcolor="#EEFFFF">40</td><td>XL</td><td>
<tr><td bgcolor="#EEFFFF">3</td><td>III</td><td bgcolor="#EEFFFF">13<td>XIII</td><td bgcolor="#EEFFFF">50</td><td>L</td><td>
<tr><td bgcolor="#EEFFFF">4</td><td>IV</td><td bgcolor="#EEFFFF">14<td>XIV</td><td bgcolor="#EEFFFF">60</td><td>LX</td><td>
<tr><td bgcolor="#EEFFFF">5</td><td>V</td><td bgcolor="#EEFFFF">15<td>XV</td><td bgcolor="#EEFFFF">70</td><td>LXX</td><td>
<tr><td bgcolor="#EEFFFF">6</td><td>VI</td><td bgcolor="#EEFFFF">16<td>XVI</td><td bgcolor="#EEFFFF">80</td><td>LXXX</td><td>
<tr><td bgcolor="#EEFFFF">7</td><td>VII</td><td bgcolor="#EEFFFF">17<td>XVII</td><td bgcolor="#EEFFFF">90</td><td>XC</td><td>
<tr><td bgcolor="#EEFFFF">8</td><td>VIII</td><td bgcolor="#EEFFFF">18<td>XVIII</td><td bgcolor="#EEFFFF">100</td><td>C</td><td>
<tr><td bgcolor="#EEFFFF">9</td><td>IX</td><td bgcolor="#EEFFFF">19<td>XIX</td><td bgcolor="#EEFFFF">500</td><td>D</td><td>
<tr><td bgcolor="#EEFFFF">10</td><td>X</td><td bgcolor="#EEFFFF">20<td>XX</td><td bgcolor="#EEFFFF">1000</td><td>M</td><td>
</table>
</center>
<br/>
<p>
I は 1、 V は 5、 X は 10、 L は 50、 C は 100、 D は 500、 M は 1000、 他の例は上の表を見てください。小さい数が大きい数に続いている、つまり右側にあるときは足し算をします。小さい数が大きい数の前に、つまり左にあるときは、大きい数から小さい数を引きます。大きい数字の前にあって引き算を表す小さな数字は一回の引き算あたりひとつしかありません。
</p>
<p>
ローマ数字をアラビア数字（通常の数字）の表記（10 進表示）に変換して出力するプログラムを作成してください。ただし、与えられるローマ数字は上記のルールにのみ従っています(実際のローマ数字の表記にはもっと細かいルールがありますが、ここでは考慮する必要はありません。たとえば、実際のローマ数字ではI はV かX から、X はL かC から、C はD かM からしか引き算しませんし、同じローマ数字は４つ以上（または５つ以上）足し並べることはありません。)
</p>
<H2>Input</H2>
<p>
複数のデータセットが与えられます。それぞれのデータセットにローマ数字（半角大文字のI, V, X, L, C, D ,M で表される連続した文字列）が１行に与えられます。与えられるローマ数字の文字列の長さはおのおの 100 以下です。
</p>
<p>
データセットの数は 50 を超えません。
</p>
<H2>Output</H2>
<p>
各データセットに対し、アラビア数字（整数）を１行に出力して下さい。
</p>
<H2>Sample Input</H2>
<pre>
IV
CCCCLXXXXVIIII
CDXCIX
</pre>
<H2>Output for the Sample Input</H2>
<pre>
4
499
499
</pre>
|
s213339372 | p00039 | Accepted | M = {'I':1, 'V':5, 'X':10, 'L':50, 'C':100, 'D':500, 'M':1000}
try:
while 1:
l = input()
stock = []
res = 0
for v in l:
if len(stock) == 0 or stock[-1] >= M[v]:
stock.append(M[v])
else:
stock[-1] = M[v] - stock[-1]
res += sum(stock)
stock = []
res += sum(stock)
print(res)
except:
pass | IV
CCCCLXXXXVIIII
CDXCIX
| 4
499
499
|
<H1>ローマ数字</H1>
<p>
古代ローマでは数を数えることは難しい仕事でした。アラビア数字の 0,1,2,3,…, 9 はまだ流布していませんでした。その代わり次のような記号が使われていました。
</p>
<center>
<table border=1>
<tr>
<td bgcolor="#EEFFFF" width="100">アラビア数字</td><td width="100">ローマ数字</td><td bgcolor="#EEFFFF" width="100">アラビア数字</td><td width="100">ローマ数字</td><td bgcolor="#EEFFFF" width="100">アラビア数字</td><td width="100">ローマ数字</td>
</tr>
<tr><td bgcolor="#EEFFFF">1</td><td>I</td><td bgcolor="#EEFFFF">11<td>XI</td><td bgcolor="#EEFFFF">30</td><td>XXX</td><td>
<tr><td bgcolor="#EEFFFF">2</td><td>II</td><td bgcolor="#EEFFFF">12<td>XII</td><td bgcolor="#EEFFFF">40</td><td>XL</td><td>
<tr><td bgcolor="#EEFFFF">3</td><td>III</td><td bgcolor="#EEFFFF">13<td>XIII</td><td bgcolor="#EEFFFF">50</td><td>L</td><td>
<tr><td bgcolor="#EEFFFF">4</td><td>IV</td><td bgcolor="#EEFFFF">14<td>XIV</td><td bgcolor="#EEFFFF">60</td><td>LX</td><td>
<tr><td bgcolor="#EEFFFF">5</td><td>V</td><td bgcolor="#EEFFFF">15<td>XV</td><td bgcolor="#EEFFFF">70</td><td>LXX</td><td>
<tr><td bgcolor="#EEFFFF">6</td><td>VI</td><td bgcolor="#EEFFFF">16<td>XVI</td><td bgcolor="#EEFFFF">80</td><td>LXXX</td><td>
<tr><td bgcolor="#EEFFFF">7</td><td>VII</td><td bgcolor="#EEFFFF">17<td>XVII</td><td bgcolor="#EEFFFF">90</td><td>XC</td><td>
<tr><td bgcolor="#EEFFFF">8</td><td>VIII</td><td bgcolor="#EEFFFF">18<td>XVIII</td><td bgcolor="#EEFFFF">100</td><td>C</td><td>
<tr><td bgcolor="#EEFFFF">9</td><td>IX</td><td bgcolor="#EEFFFF">19<td>XIX</td><td bgcolor="#EEFFFF">500</td><td>D</td><td>
<tr><td bgcolor="#EEFFFF">10</td><td>X</td><td bgcolor="#EEFFFF">20<td>XX</td><td bgcolor="#EEFFFF">1000</td><td>M</td><td>
</table>
</center>
<br/>
<p>
I は 1、 V は 5、 X は 10、 L は 50、 C は 100、 D は 500、 M は 1000、 他の例は上の表を見てください。小さい数が大きい数に続いている、つまり右側にあるときは足し算をします。小さい数が大きい数の前に、つまり左にあるときは、大きい数から小さい数を引きます。大きい数字の前にあって引き算を表す小さな数字は一回の引き算あたりひとつしかありません。
</p>
<p>
ローマ数字をアラビア数字（通常の数字）の表記（10 進表示）に変換して出力するプログラムを作成してください。ただし、与えられるローマ数字は上記のルールにのみ従っています(実際のローマ数字の表記にはもっと細かいルールがありますが、ここでは考慮する必要はありません。たとえば、実際のローマ数字ではI はV かX から、X はL かC から、C はD かM からしか引き算しませんし、同じローマ数字は４つ以上（または５つ以上）足し並べることはありません。)
</p>
<H2>Input</H2>
<p>
複数のデータセットが与えられます。それぞれのデータセットにローマ数字（半角大文字のI, V, X, L, C, D ,M で表される連続した文字列）が１行に与えられます。与えられるローマ数字の文字列の長さはおのおの 100 以下です。
</p>
<p>
データセットの数は 50 を超えません。
</p>
<H2>Output</H2>
<p>
各データセットに対し、アラビア数字（整数）を１行に出力して下さい。
</p>
<H2>Sample Input</H2>
<pre>
IV
CCCCLXXXXVIIII
CDXCIX
</pre>
<H2>Output for the Sample Input</H2>
<pre>
4
499
499
</pre>
|
s683380963 | p00039 | Accepted | dic = dict(I=1, V=5, X=10, L=50, C=100, D=500, M=1000)
while True:
try:
nums = list(map(lambda x: dic[x], list(input())))
except:
break
ans = 0
for i in range(1, len(nums)):
if nums[i - 1] >= nums[i]:
ans += nums[i - 1]
else:
ans -= nums[i - 1]
print(ans + nums[-1]) | IV
CCCCLXXXXVIIII
CDXCIX
| 4
499
499
|
<H1>ローマ数字</H1>
<p>
古代ローマでは数を数えることは難しい仕事でした。アラビア数字の 0,1,2,3,…, 9 はまだ流布していませんでした。その代わり次のような記号が使われていました。
</p>
<center>
<table border=1>
<tr>
<td bgcolor="#EEFFFF" width="100">アラビア数字</td><td width="100">ローマ数字</td><td bgcolor="#EEFFFF" width="100">アラビア数字</td><td width="100">ローマ数字</td><td bgcolor="#EEFFFF" width="100">アラビア数字</td><td width="100">ローマ数字</td>
</tr>
<tr><td bgcolor="#EEFFFF">1</td><td>I</td><td bgcolor="#EEFFFF">11<td>XI</td><td bgcolor="#EEFFFF">30</td><td>XXX</td><td>
<tr><td bgcolor="#EEFFFF">2</td><td>II</td><td bgcolor="#EEFFFF">12<td>XII</td><td bgcolor="#EEFFFF">40</td><td>XL</td><td>
<tr><td bgcolor="#EEFFFF">3</td><td>III</td><td bgcolor="#EEFFFF">13<td>XIII</td><td bgcolor="#EEFFFF">50</td><td>L</td><td>
<tr><td bgcolor="#EEFFFF">4</td><td>IV</td><td bgcolor="#EEFFFF">14<td>XIV</td><td bgcolor="#EEFFFF">60</td><td>LX</td><td>
<tr><td bgcolor="#EEFFFF">5</td><td>V</td><td bgcolor="#EEFFFF">15<td>XV</td><td bgcolor="#EEFFFF">70</td><td>LXX</td><td>
<tr><td bgcolor="#EEFFFF">6</td><td>VI</td><td bgcolor="#EEFFFF">16<td>XVI</td><td bgcolor="#EEFFFF">80</td><td>LXXX</td><td>
<tr><td bgcolor="#EEFFFF">7</td><td>VII</td><td bgcolor="#EEFFFF">17<td>XVII</td><td bgcolor="#EEFFFF">90</td><td>XC</td><td>
<tr><td bgcolor="#EEFFFF">8</td><td>VIII</td><td bgcolor="#EEFFFF">18<td>XVIII</td><td bgcolor="#EEFFFF">100</td><td>C</td><td>
<tr><td bgcolor="#EEFFFF">9</td><td>IX</td><td bgcolor="#EEFFFF">19<td>XIX</td><td bgcolor="#EEFFFF">500</td><td>D</td><td>
<tr><td bgcolor="#EEFFFF">10</td><td>X</td><td bgcolor="#EEFFFF">20<td>XX</td><td bgcolor="#EEFFFF">1000</td><td>M</td><td>
</table>
</center>
<br/>
<p>
I は 1、 V は 5、 X は 10、 L は 50、 C は 100、 D は 500、 M は 1000、 他の例は上の表を見てください。小さい数が大きい数に続いている、つまり右側にあるときは足し算をします。小さい数が大きい数の前に、つまり左にあるときは、大きい数から小さい数を引きます。大きい数字の前にあって引き算を表す小さな数字は一回の引き算あたりひとつしかありません。
</p>
<p>
ローマ数字をアラビア数字（通常の数字）の表記（10 進表示）に変換して出力するプログラムを作成してください。ただし、与えられるローマ数字は上記のルールにのみ従っています(実際のローマ数字の表記にはもっと細かいルールがありますが、ここでは考慮する必要はありません。たとえば、実際のローマ数字ではI はV かX から、X はL かC から、C はD かM からしか引き算しませんし、同じローマ数字は４つ以上（または５つ以上）足し並べることはありません。)
</p>
<H2>Input</H2>
<p>
複数のデータセットが与えられます。それぞれのデータセットにローマ数字（半角大文字のI, V, X, L, C, D ,M で表される連続した文字列）が１行に与えられます。与えられるローマ数字の文字列の長さはおのおの 100 以下です。
</p>
<p>
データセットの数は 50 を超えません。
</p>
<H2>Output</H2>
<p>
各データセットに対し、アラビア数字（整数）を１行に出力して下さい。
</p>
<H2>Sample Input</H2>
<pre>
IV
CCCCLXXXXVIIII
CDXCIX
</pre>
<H2>Output for the Sample Input</H2>
<pre>
4
499
499
</pre>
|
s033234779 | p00039 | Accepted | import sys
d = {"I":1, "V":5, "X":10, "L":50, "C":100 ,"D":500,"M":1000}
for line in sys.stdin:
l = [d[i] for i in line.rstrip()]
if len(l) == 1:
print(l[0])
else:
s = sum(l)
for i in range(len(l)-1):
if l[i] < l[i+1]:
s -= (2*l[i])
print(s) | IV
CCCCLXXXXVIIII
CDXCIX
| 4
499
499
|
<H1>ローマ数字</H1>
<p>
古代ローマでは数を数えることは難しい仕事でした。アラビア数字の 0,1,2,3,…, 9 はまだ流布していませんでした。その代わり次のような記号が使われていました。
</p>
<center>
<table border=1>
<tr>
<td bgcolor="#EEFFFF" width="100">アラビア数字</td><td width="100">ローマ数字</td><td bgcolor="#EEFFFF" width="100">アラビア数字</td><td width="100">ローマ数字</td><td bgcolor="#EEFFFF" width="100">アラビア数字</td><td width="100">ローマ数字</td>
</tr>
<tr><td bgcolor="#EEFFFF">1</td><td>I</td><td bgcolor="#EEFFFF">11<td>XI</td><td bgcolor="#EEFFFF">30</td><td>XXX</td><td>
<tr><td bgcolor="#EEFFFF">2</td><td>II</td><td bgcolor="#EEFFFF">12<td>XII</td><td bgcolor="#EEFFFF">40</td><td>XL</td><td>
<tr><td bgcolor="#EEFFFF">3</td><td>III</td><td bgcolor="#EEFFFF">13<td>XIII</td><td bgcolor="#EEFFFF">50</td><td>L</td><td>
<tr><td bgcolor="#EEFFFF">4</td><td>IV</td><td bgcolor="#EEFFFF">14<td>XIV</td><td bgcolor="#EEFFFF">60</td><td>LX</td><td>
<tr><td bgcolor="#EEFFFF">5</td><td>V</td><td bgcolor="#EEFFFF">15<td>XV</td><td bgcolor="#EEFFFF">70</td><td>LXX</td><td>
<tr><td bgcolor="#EEFFFF">6</td><td>VI</td><td bgcolor="#EEFFFF">16<td>XVI</td><td bgcolor="#EEFFFF">80</td><td>LXXX</td><td>
<tr><td bgcolor="#EEFFFF">7</td><td>VII</td><td bgcolor="#EEFFFF">17<td>XVII</td><td bgcolor="#EEFFFF">90</td><td>XC</td><td>
<tr><td bgcolor="#EEFFFF">8</td><td>VIII</td><td bgcolor="#EEFFFF">18<td>XVIII</td><td bgcolor="#EEFFFF">100</td><td>C</td><td>
<tr><td bgcolor="#EEFFFF">9</td><td>IX</td><td bgcolor="#EEFFFF">19<td>XIX</td><td bgcolor="#EEFFFF">500</td><td>D</td><td>
<tr><td bgcolor="#EEFFFF">10</td><td>X</td><td bgcolor="#EEFFFF">20<td>XX</td><td bgcolor="#EEFFFF">1000</td><td>M</td><td>
</table>
</center>
<br/>
<p>
I は 1、 V は 5、 X は 10、 L は 50、 C は 100、 D は 500、 M は 1000、 他の例は上の表を見てください。小さい数が大きい数に続いている、つまり右側にあるときは足し算をします。小さい数が大きい数の前に、つまり左にあるときは、大きい数から小さい数を引きます。大きい数字の前にあって引き算を表す小さな数字は一回の引き算あたりひとつしかありません。
</p>
<p>
ローマ数字をアラビア数字（通常の数字）の表記（10 進表示）に変換して出力するプログラムを作成してください。ただし、与えられるローマ数字は上記のルールにのみ従っています(実際のローマ数字の表記にはもっと細かいルールがありますが、ここでは考慮する必要はありません。たとえば、実際のローマ数字ではI はV かX から、X はL かC から、C はD かM からしか引き算しませんし、同じローマ数字は４つ以上（または５つ以上）足し並べることはありません。)
</p>
<H2>Input</H2>
<p>
複数のデータセットが与えられます。それぞれのデータセットにローマ数字（半角大文字のI, V, X, L, C, D ,M で表される連続した文字列）が１行に与えられます。与えられるローマ数字の文字列の長さはおのおの 100 以下です。
</p>
<p>
データセットの数は 50 を超えません。
</p>
<H2>Output</H2>
<p>
各データセットに対し、アラビア数字（整数）を１行に出力して下さい。
</p>
<H2>Sample Input</H2>
<pre>
IV
CCCCLXXXXVIIII
CDXCIX
</pre>
<H2>Output for the Sample Input</H2>
<pre>
4
499
499
</pre>
|
s717341655 | p00039 | Accepted | while True:
try:
Roma = input()
Roma = Roma.replace('IV', 'IIII')
Roma = Roma.replace('IX', 'VIIII')
Roma = Roma.replace('XL', 'XXXX')
Roma = Roma.replace('XC', 'LXXXX')
Roma = Roma.replace('CD', 'CCCC')
Roma = Roma.replace('CM', 'DCCCC')
Roma = list(Roma)
Num = 1000 * Roma.count('M') + 500 * Roma.count('D') + 100 * Roma.count('C') + 50 * Roma.count('L') + 10 * Roma.count('X') + 5 * Roma.count('V') + Roma.count('I')
print(Num)
except EOFError:
break | IV
CCCCLXXXXVIIII
CDXCIX
| 4
499
499
|
<H1>ローマ数字</H1>
<p>
古代ローマでは数を数えることは難しい仕事でした。アラビア数字の 0,1,2,3,…, 9 はまだ流布していませんでした。その代わり次のような記号が使われていました。
</p>
<center>
<table border=1>
<tr>
<td bgcolor="#EEFFFF" width="100">アラビア数字</td><td width="100">ローマ数字</td><td bgcolor="#EEFFFF" width="100">アラビア数字</td><td width="100">ローマ数字</td><td bgcolor="#EEFFFF" width="100">アラビア数字</td><td width="100">ローマ数字</td>
</tr>
<tr><td bgcolor="#EEFFFF">1</td><td>I</td><td bgcolor="#EEFFFF">11<td>XI</td><td bgcolor="#EEFFFF">30</td><td>XXX</td><td>
<tr><td bgcolor="#EEFFFF">2</td><td>II</td><td bgcolor="#EEFFFF">12<td>XII</td><td bgcolor="#EEFFFF">40</td><td>XL</td><td>
<tr><td bgcolor="#EEFFFF">3</td><td>III</td><td bgcolor="#EEFFFF">13<td>XIII</td><td bgcolor="#EEFFFF">50</td><td>L</td><td>
<tr><td bgcolor="#EEFFFF">4</td><td>IV</td><td bgcolor="#EEFFFF">14<td>XIV</td><td bgcolor="#EEFFFF">60</td><td>LX</td><td>
<tr><td bgcolor="#EEFFFF">5</td><td>V</td><td bgcolor="#EEFFFF">15<td>XV</td><td bgcolor="#EEFFFF">70</td><td>LXX</td><td>
<tr><td bgcolor="#EEFFFF">6</td><td>VI</td><td bgcolor="#EEFFFF">16<td>XVI</td><td bgcolor="#EEFFFF">80</td><td>LXXX</td><td>
<tr><td bgcolor="#EEFFFF">7</td><td>VII</td><td bgcolor="#EEFFFF">17<td>XVII</td><td bgcolor="#EEFFFF">90</td><td>XC</td><td>
<tr><td bgcolor="#EEFFFF">8</td><td>VIII</td><td bgcolor="#EEFFFF">18<td>XVIII</td><td bgcolor="#EEFFFF">100</td><td>C</td><td>
<tr><td bgcolor="#EEFFFF">9</td><td>IX</td><td bgcolor="#EEFFFF">19<td>XIX</td><td bgcolor="#EEFFFF">500</td><td>D</td><td>
<tr><td bgcolor="#EEFFFF">10</td><td>X</td><td bgcolor="#EEFFFF">20<td>XX</td><td bgcolor="#EEFFFF">1000</td><td>M</td><td>
</table>
</center>
<br/>
<p>
I は 1、 V は 5、 X は 10、 L は 50、 C は 100、 D は 500、 M は 1000、 他の例は上の表を見てください。小さい数が大きい数に続いている、つまり右側にあるときは足し算をします。小さい数が大きい数の前に、つまり左にあるときは、大きい数から小さい数を引きます。大きい数字の前にあって引き算を表す小さな数字は一回の引き算あたりひとつしかありません。
</p>
<p>
ローマ数字をアラビア数字（通常の数字）の表記（10 進表示）に変換して出力するプログラムを作成してください。ただし、与えられるローマ数字は上記のルールにのみ従っています(実際のローマ数字の表記にはもっと細かいルールがありますが、ここでは考慮する必要はありません。たとえば、実際のローマ数字ではI はV かX から、X はL かC から、C はD かM からしか引き算しませんし、同じローマ数字は４つ以上（または５つ以上）足し並べることはありません。)
</p>
<H2>Input</H2>
<p>
複数のデータセットが与えられます。それぞれのデータセットにローマ数字（半角大文字のI, V, X, L, C, D ,M で表される連続した文字列）が１行に与えられます。与えられるローマ数字の文字列の長さはおのおの 100 以下です。
</p>
<p>
データセットの数は 50 を超えません。
</p>
<H2>Output</H2>
<p>
各データセットに対し、アラビア数字（整数）を１行に出力して下さい。
</p>
<H2>Sample Input</H2>
<pre>
IV
CCCCLXXXXVIIII
CDXCIX
</pre>
<H2>Output for the Sample Input</H2>
<pre>
4
499
499
</pre>
|
s510260650 | p00039 | Accepted | import sys
def decode_roman_number(data):
""" ???????????°????????¢????????¢??°??????????????????
????????§??????????????¨????????????????????§???I, V, X??????????????????????????????????????¢????????¢??°???????????????????????????
?????¬????????????????????????????????????????????????????????????????????????????????§???????????°??????????????¨???????????¨???????????§????????????????????????????????????????????????
?¬??????????????????????????°????????????£?????????????????§????????°(???: V ??? I)??????????????????????????§????????°??????????????¨??¨?????????????????????
??????????????§???????????£?????????????????§????????°(???: I ??? V)??????????????????????????§????????°??????????????¨??¨?????????????????????
???????????????????????°??????????¬????????????¨????????????????????????????????????
??¨???????????????????????????????????????????????£????????????????????¨???????????¨???
"""
numbers = []
for d in data:
if d == 'I':
numbers.append(1)
elif d == 'V':
numbers.append(5)
elif d == 'X':
numbers.append(10)
elif d == 'L':
numbers.append(50)
elif d == 'C':
numbers.append(100)
elif d == 'D':
numbers.append(500)
elif d == 'M':
numbers.append(1000)
else:
raise ValueError
decoded_number = 0 # ??¢????????¢??°??????????????????????????????
my_stack = []
for n in numbers:
if len(my_stack) == 0: # ???????????????????????????????????§??????????????§?????¨?????????????????????????????????
my_stack.append(n)
else:
while len(my_stack) > 0 and my_stack[-1] < n: # I???V ??? X???C ??????????????±?????????????????¨
decoded_number -= my_stack.pop()
while len(my_stack) > 0:
decoded_number += my_stack.pop()
my_stack.append(n) # ???????????????????¬????????????¨??????????????????????????§??????????????????????????¨???XXIV(24)???????????£????????????????????§????????????
while len(my_stack) > 0:
decoded_number += my_stack.pop()
return decoded_number
if __name__ == '__main__':
#
for line in sys.stdin:
data = line.strip()
# data = 'CCCCLXXXXVIIII'
# data = 'MCMXLV'
# ???????????°???????§£???
ans = decode_roman_number(data)
# ???????????¨???
print(ans) | IV
CCCCLXXXXVIIII
CDXCIX
| 4
499
499
|
<H1>ローマ数字</H1>
<p>
古代ローマでは数を数えることは難しい仕事でした。アラビア数字の 0,1,2,3,…, 9 はまだ流布していませんでした。その代わり次のような記号が使われていました。
</p>
<center>
<table border=1>
<tr>
<td bgcolor="#EEFFFF" width="100">アラビア数字</td><td width="100">ローマ数字</td><td bgcolor="#EEFFFF" width="100">アラビア数字</td><td width="100">ローマ数字</td><td bgcolor="#EEFFFF" width="100">アラビア数字</td><td width="100">ローマ数字</td>
</tr>
<tr><td bgcolor="#EEFFFF">1</td><td>I</td><td bgcolor="#EEFFFF">11<td>XI</td><td bgcolor="#EEFFFF">30</td><td>XXX</td><td>
<tr><td bgcolor="#EEFFFF">2</td><td>II</td><td bgcolor="#EEFFFF">12<td>XII</td><td bgcolor="#EEFFFF">40</td><td>XL</td><td>
<tr><td bgcolor="#EEFFFF">3</td><td>III</td><td bgcolor="#EEFFFF">13<td>XIII</td><td bgcolor="#EEFFFF">50</td><td>L</td><td>
<tr><td bgcolor="#EEFFFF">4</td><td>IV</td><td bgcolor="#EEFFFF">14<td>XIV</td><td bgcolor="#EEFFFF">60</td><td>LX</td><td>
<tr><td bgcolor="#EEFFFF">5</td><td>V</td><td bgcolor="#EEFFFF">15<td>XV</td><td bgcolor="#EEFFFF">70</td><td>LXX</td><td>
<tr><td bgcolor="#EEFFFF">6</td><td>VI</td><td bgcolor="#EEFFFF">16<td>XVI</td><td bgcolor="#EEFFFF">80</td><td>LXXX</td><td>
<tr><td bgcolor="#EEFFFF">7</td><td>VII</td><td bgcolor="#EEFFFF">17<td>XVII</td><td bgcolor="#EEFFFF">90</td><td>XC</td><td>
<tr><td bgcolor="#EEFFFF">8</td><td>VIII</td><td bgcolor="#EEFFFF">18<td>XVIII</td><td bgcolor="#EEFFFF">100</td><td>C</td><td>
<tr><td bgcolor="#EEFFFF">9</td><td>IX</td><td bgcolor="#EEFFFF">19<td>XIX</td><td bgcolor="#EEFFFF">500</td><td>D</td><td>
<tr><td bgcolor="#EEFFFF">10</td><td>X</td><td bgcolor="#EEFFFF">20<td>XX</td><td bgcolor="#EEFFFF">1000</td><td>M</td><td>
</table>
</center>
<br/>
<p>
I は 1、 V は 5、 X は 10、 L は 50、 C は 100、 D は 500、 M は 1000、 他の例は上の表を見てください。小さい数が大きい数に続いている、つまり右側にあるときは足し算をします。小さい数が大きい数の前に、つまり左にあるときは、大きい数から小さい数を引きます。大きい数字の前にあって引き算を表す小さな数字は一回の引き算あたりひとつしかありません。
</p>
<p>
ローマ数字をアラビア数字（通常の数字）の表記（10 進表示）に変換して出力するプログラムを作成してください。ただし、与えられるローマ数字は上記のルールにのみ従っています(実際のローマ数字の表記にはもっと細かいルールがありますが、ここでは考慮する必要はありません。たとえば、実際のローマ数字ではI はV かX から、X はL かC から、C はD かM からしか引き算しませんし、同じローマ数字は４つ以上（または５つ以上）足し並べることはありません。)
</p>
<H2>Input</H2>
<p>
複数のデータセットが与えられます。それぞれのデータセットにローマ数字（半角大文字のI, V, X, L, C, D ,M で表される連続した文字列）が１行に与えられます。与えられるローマ数字の文字列の長さはおのおの 100 以下です。
</p>
<p>
データセットの数は 50 を超えません。
</p>
<H2>Output</H2>
<p>
各データセットに対し、アラビア数字（整数）を１行に出力して下さい。
</p>
<H2>Sample Input</H2>
<pre>
IV
CCCCLXXXXVIIII
CDXCIX
</pre>
<H2>Output for the Sample Input</H2>
<pre>
4
499
499
</pre>
|
s292239274 | p00039 | Accepted | import sys
def decode_roman_number(data):
""" ???????????°????????¢????????¢??°??????????????????
????????§??????????????¨????????????????????§???I, V, X??????????????????????????????????????¢????????¢??°???????????????????????????
?????¬????????????????????????????????????????????????????????????????????????????????§???????????°??????????????¨???????????¨???????????§????????????????????????????????????????????????
?¬??????????????????????????°????????????£?????????????????§????????°(???: V ??? I)??????????????????????????§????????°??????????????¨??¨?????????????????????
??????????????§???????????£?????????????????§????????°(???: I ??? V)??????????????????????????§????????°??????????????¨??¨?????????????????????
???????????????????????°??????????¬????????????¨????????????????????????????????????
??¨???????????????????????????????????????????????£????????????????????¨???????????¨???
"""
roman_num = {'I': 1, 'V': 5, 'X': 10, 'L': 50, 'C': 100, 'D': 500, 'M': 1000} # ???????????°???????????????????????????????????????
decoded_number = 0 # ??¢????????¢??°??????????????????????????????
my_stack = []
for c in data:
try:
if len(my_stack) == 0: # ???????????????????????????????????§??????????????§?????¨?????????????????????????????????
my_stack.append(c)
else:
while len(my_stack) > 0 and roman_num[my_stack[-1]] < roman_num[c]: # I???V ??? X???C ??????????????±?????????????????¨
decoded_number -= roman_num[my_stack.pop()]
while len(my_stack) > 0:
decoded_number += roman_num[my_stack.pop()]
my_stack.append(c) # ???????????????????¬????????????¨??????????????????????????§??????????????????????????¨???XXIV(24)???????????£????????????????????§????????????
except KeyError:
raise ValueError
while len(my_stack) > 0:
try:
decoded_number += roman_num[my_stack.pop()]
except KeyError:
raise ValueError
return decoded_number
if __name__ == '__main__':
#
for line in sys.stdin:
data = line.strip()
# data = 'CCCCLXXXXVIIII'
# data = 'MCMXLV'
# ???????????°???????§£???
ans = decode_roman_number(data)
# ???????????¨???
print(ans) | IV
CCCCLXXXXVIIII
CDXCIX
| 4
499
499
|
<H1>ローマ数字</H1>
<p>
古代ローマでは数を数えることは難しい仕事でした。アラビア数字の 0,1,2,3,…, 9 はまだ流布していませんでした。その代わり次のような記号が使われていました。
</p>
<center>
<table border=1>
<tr>
<td bgcolor="#EEFFFF" width="100">アラビア数字</td><td width="100">ローマ数字</td><td bgcolor="#EEFFFF" width="100">アラビア数字</td><td width="100">ローマ数字</td><td bgcolor="#EEFFFF" width="100">アラビア数字</td><td width="100">ローマ数字</td>
</tr>
<tr><td bgcolor="#EEFFFF">1</td><td>I</td><td bgcolor="#EEFFFF">11<td>XI</td><td bgcolor="#EEFFFF">30</td><td>XXX</td><td>
<tr><td bgcolor="#EEFFFF">2</td><td>II</td><td bgcolor="#EEFFFF">12<td>XII</td><td bgcolor="#EEFFFF">40</td><td>XL</td><td>
<tr><td bgcolor="#EEFFFF">3</td><td>III</td><td bgcolor="#EEFFFF">13<td>XIII</td><td bgcolor="#EEFFFF">50</td><td>L</td><td>
<tr><td bgcolor="#EEFFFF">4</td><td>IV</td><td bgcolor="#EEFFFF">14<td>XIV</td><td bgcolor="#EEFFFF">60</td><td>LX</td><td>
<tr><td bgcolor="#EEFFFF">5</td><td>V</td><td bgcolor="#EEFFFF">15<td>XV</td><td bgcolor="#EEFFFF">70</td><td>LXX</td><td>
<tr><td bgcolor="#EEFFFF">6</td><td>VI</td><td bgcolor="#EEFFFF">16<td>XVI</td><td bgcolor="#EEFFFF">80</td><td>LXXX</td><td>
<tr><td bgcolor="#EEFFFF">7</td><td>VII</td><td bgcolor="#EEFFFF">17<td>XVII</td><td bgcolor="#EEFFFF">90</td><td>XC</td><td>
<tr><td bgcolor="#EEFFFF">8</td><td>VIII</td><td bgcolor="#EEFFFF">18<td>XVIII</td><td bgcolor="#EEFFFF">100</td><td>C</td><td>
<tr><td bgcolor="#EEFFFF">9</td><td>IX</td><td bgcolor="#EEFFFF">19<td>XIX</td><td bgcolor="#EEFFFF">500</td><td>D</td><td>
<tr><td bgcolor="#EEFFFF">10</td><td>X</td><td bgcolor="#EEFFFF">20<td>XX</td><td bgcolor="#EEFFFF">1000</td><td>M</td><td>
</table>
</center>
<br/>
<p>
I は 1、 V は 5、 X は 10、 L は 50、 C は 100、 D は 500、 M は 1000、 他の例は上の表を見てください。小さい数が大きい数に続いている、つまり右側にあるときは足し算をします。小さい数が大きい数の前に、つまり左にあるときは、大きい数から小さい数を引きます。大きい数字の前にあって引き算を表す小さな数字は一回の引き算あたりひとつしかありません。
</p>
<p>
ローマ数字をアラビア数字（通常の数字）の表記（10 進表示）に変換して出力するプログラムを作成してください。ただし、与えられるローマ数字は上記のルールにのみ従っています(実際のローマ数字の表記にはもっと細かいルールがありますが、ここでは考慮する必要はありません。たとえば、実際のローマ数字ではI はV かX から、X はL かC から、C はD かM からしか引き算しませんし、同じローマ数字は４つ以上（または５つ以上）足し並べることはありません。)
</p>
<H2>Input</H2>
<p>
複数のデータセットが与えられます。それぞれのデータセットにローマ数字（半角大文字のI, V, X, L, C, D ,M で表される連続した文字列）が１行に与えられます。与えられるローマ数字の文字列の長さはおのおの 100 以下です。
</p>
<p>
データセットの数は 50 を超えません。
</p>
<H2>Output</H2>
<p>
各データセットに対し、アラビア数字（整数）を１行に出力して下さい。
</p>
<H2>Sample Input</H2>
<pre>
IV
CCCCLXXXXVIIII
CDXCIX
</pre>
<H2>Output for the Sample Input</H2>
<pre>
4
499
499
</pre>
|
s502385722 | p00039 | Accepted | nums={"I":1,"V":5,"X":10,"L":50,"C":100,"D":500,"M":1000}
while True:
try:
s=input()
except:
break
ans=nums[s[0]]
for i in range(1,len(s)):
if nums[s[i-1]]<nums[s[i]]:
ans+=nums[s[i]]-2*nums[s[i-1]]
else:
ans+=nums[s[i]]
print(ans)
| IV
CCCCLXXXXVIIII
CDXCIX
| 4
499
499
|
<H1>ローマ数字</H1>
<p>
古代ローマでは数を数えることは難しい仕事でした。アラビア数字の 0,1,2,3,…, 9 はまだ流布していませんでした。その代わり次のような記号が使われていました。
</p>
<center>
<table border=1>
<tr>
<td bgcolor="#EEFFFF" width="100">アラビア数字</td><td width="100">ローマ数字</td><td bgcolor="#EEFFFF" width="100">アラビア数字</td><td width="100">ローマ数字</td><td bgcolor="#EEFFFF" width="100">アラビア数字</td><td width="100">ローマ数字</td>
</tr>
<tr><td bgcolor="#EEFFFF">1</td><td>I</td><td bgcolor="#EEFFFF">11<td>XI</td><td bgcolor="#EEFFFF">30</td><td>XXX</td><td>
<tr><td bgcolor="#EEFFFF">2</td><td>II</td><td bgcolor="#EEFFFF">12<td>XII</td><td bgcolor="#EEFFFF">40</td><td>XL</td><td>
<tr><td bgcolor="#EEFFFF">3</td><td>III</td><td bgcolor="#EEFFFF">13<td>XIII</td><td bgcolor="#EEFFFF">50</td><td>L</td><td>
<tr><td bgcolor="#EEFFFF">4</td><td>IV</td><td bgcolor="#EEFFFF">14<td>XIV</td><td bgcolor="#EEFFFF">60</td><td>LX</td><td>
<tr><td bgcolor="#EEFFFF">5</td><td>V</td><td bgcolor="#EEFFFF">15<td>XV</td><td bgcolor="#EEFFFF">70</td><td>LXX</td><td>
<tr><td bgcolor="#EEFFFF">6</td><td>VI</td><td bgcolor="#EEFFFF">16<td>XVI</td><td bgcolor="#EEFFFF">80</td><td>LXXX</td><td>
<tr><td bgcolor="#EEFFFF">7</td><td>VII</td><td bgcolor="#EEFFFF">17<td>XVII</td><td bgcolor="#EEFFFF">90</td><td>XC</td><td>
<tr><td bgcolor="#EEFFFF">8</td><td>VIII</td><td bgcolor="#EEFFFF">18<td>XVIII</td><td bgcolor="#EEFFFF">100</td><td>C</td><td>
<tr><td bgcolor="#EEFFFF">9</td><td>IX</td><td bgcolor="#EEFFFF">19<td>XIX</td><td bgcolor="#EEFFFF">500</td><td>D</td><td>
<tr><td bgcolor="#EEFFFF">10</td><td>X</td><td bgcolor="#EEFFFF">20<td>XX</td><td bgcolor="#EEFFFF">1000</td><td>M</td><td>
</table>
</center>
<br/>
<p>
I は 1、 V は 5、 X は 10、 L は 50、 C は 100、 D は 500、 M は 1000、 他の例は上の表を見てください。小さい数が大きい数に続いている、つまり右側にあるときは足し算をします。小さい数が大きい数の前に、つまり左にあるときは、大きい数から小さい数を引きます。大きい数字の前にあって引き算を表す小さな数字は一回の引き算あたりひとつしかありません。
</p>
<p>
ローマ数字をアラビア数字（通常の数字）の表記（10 進表示）に変換して出力するプログラムを作成してください。ただし、与えられるローマ数字は上記のルールにのみ従っています(実際のローマ数字の表記にはもっと細かいルールがありますが、ここでは考慮する必要はありません。たとえば、実際のローマ数字ではI はV かX から、X はL かC から、C はD かM からしか引き算しませんし、同じローマ数字は４つ以上（または５つ以上）足し並べることはありません。)
</p>
<H2>Input</H2>
<p>
複数のデータセットが与えられます。それぞれのデータセットにローマ数字（半角大文字のI, V, X, L, C, D ,M で表される連続した文字列）が１行に与えられます。与えられるローマ数字の文字列の長さはおのおの 100 以下です。
</p>
<p>
データセットの数は 50 を超えません。
</p>
<H2>Output</H2>
<p>
各データセットに対し、アラビア数字（整数）を１行に出力して下さい。
</p>
<H2>Sample Input</H2>
<pre>
IV
CCCCLXXXXVIIII
CDXCIX
</pre>
<H2>Output for the Sample Input</H2>
<pre>
4
499
499
</pre>
|
s854093436 | p00039 | Accepted | nums={"I":1,"V":5,"X":10,"L":50,"C":100,"D":500,"M":1000}
while True:
try:
s=input()
except:
break
ans=nums[s[0]]
for i in range(1,len(s)):
if nums[s[i-1]]<nums[s[i]]:
ans-=2*nums[s[i-1]]
ans+=nums[s[i]]
print(ans)
| IV
CCCCLXXXXVIIII
CDXCIX
| 4
499
499
|
<H1>ローマ数字</H1>
<p>
古代ローマでは数を数えることは難しい仕事でした。アラビア数字の 0,1,2,3,…, 9 はまだ流布していませんでした。その代わり次のような記号が使われていました。
</p>
<center>
<table border=1>
<tr>
<td bgcolor="#EEFFFF" width="100">アラビア数字</td><td width="100">ローマ数字</td><td bgcolor="#EEFFFF" width="100">アラビア数字</td><td width="100">ローマ数字</td><td bgcolor="#EEFFFF" width="100">アラビア数字</td><td width="100">ローマ数字</td>
</tr>
<tr><td bgcolor="#EEFFFF">1</td><td>I</td><td bgcolor="#EEFFFF">11<td>XI</td><td bgcolor="#EEFFFF">30</td><td>XXX</td><td>
<tr><td bgcolor="#EEFFFF">2</td><td>II</td><td bgcolor="#EEFFFF">12<td>XII</td><td bgcolor="#EEFFFF">40</td><td>XL</td><td>
<tr><td bgcolor="#EEFFFF">3</td><td>III</td><td bgcolor="#EEFFFF">13<td>XIII</td><td bgcolor="#EEFFFF">50</td><td>L</td><td>
<tr><td bgcolor="#EEFFFF">4</td><td>IV</td><td bgcolor="#EEFFFF">14<td>XIV</td><td bgcolor="#EEFFFF">60</td><td>LX</td><td>
<tr><td bgcolor="#EEFFFF">5</td><td>V</td><td bgcolor="#EEFFFF">15<td>XV</td><td bgcolor="#EEFFFF">70</td><td>LXX</td><td>
<tr><td bgcolor="#EEFFFF">6</td><td>VI</td><td bgcolor="#EEFFFF">16<td>XVI</td><td bgcolor="#EEFFFF">80</td><td>LXXX</td><td>
<tr><td bgcolor="#EEFFFF">7</td><td>VII</td><td bgcolor="#EEFFFF">17<td>XVII</td><td bgcolor="#EEFFFF">90</td><td>XC</td><td>
<tr><td bgcolor="#EEFFFF">8</td><td>VIII</td><td bgcolor="#EEFFFF">18<td>XVIII</td><td bgcolor="#EEFFFF">100</td><td>C</td><td>
<tr><td bgcolor="#EEFFFF">9</td><td>IX</td><td bgcolor="#EEFFFF">19<td>XIX</td><td bgcolor="#EEFFFF">500</td><td>D</td><td>
<tr><td bgcolor="#EEFFFF">10</td><td>X</td><td bgcolor="#EEFFFF">20<td>XX</td><td bgcolor="#EEFFFF">1000</td><td>M</td><td>
</table>
</center>
<br/>
<p>
I は 1、 V は 5、 X は 10、 L は 50、 C は 100、 D は 500、 M は 1000、 他の例は上の表を見てください。小さい数が大きい数に続いている、つまり右側にあるときは足し算をします。小さい数が大きい数の前に、つまり左にあるときは、大きい数から小さい数を引きます。大きい数字の前にあって引き算を表す小さな数字は一回の引き算あたりひとつしかありません。
</p>
<p>
ローマ数字をアラビア数字（通常の数字）の表記（10 進表示）に変換して出力するプログラムを作成してください。ただし、与えられるローマ数字は上記のルールにのみ従っています(実際のローマ数字の表記にはもっと細かいルールがありますが、ここでは考慮する必要はありません。たとえば、実際のローマ数字ではI はV かX から、X はL かC から、C はD かM からしか引き算しませんし、同じローマ数字は４つ以上（または５つ以上）足し並べることはありません。)
</p>
<H2>Input</H2>
<p>
複数のデータセットが与えられます。それぞれのデータセットにローマ数字（半角大文字のI, V, X, L, C, D ,M で表される連続した文字列）が１行に与えられます。与えられるローマ数字の文字列の長さはおのおの 100 以下です。
</p>
<p>
データセットの数は 50 を超えません。
</p>
<H2>Output</H2>
<p>
各データセットに対し、アラビア数字（整数）を１行に出力して下さい。
</p>
<H2>Sample Input</H2>
<pre>
IV
CCCCLXXXXVIIII
CDXCIX
</pre>
<H2>Output for the Sample Input</H2>
<pre>
4
499
499
</pre>
|
s694247867 | p00039 | Accepted | val={'I':1,'V':5,'X':10,'L':50,'C':100,'D':500,'M':1000}
rom=['I','V','X','L','C','D','M']
while True:
try:
s = list(input().strip())
w = 0
c = s[0]
s = s[1:]
while len(s) > 0:
if rom.index(s[0]) <= rom.index(c):
w += val[c]
else:
w -= val[c]
c = s[0]
s = s[1:]
w += val[c]
print(w)
except EOFError:
break | IV
CCCCLXXXXVIIII
CDXCIX
| 4
499
499
|
<H1>ローマ数字</H1>
<p>
古代ローマでは数を数えることは難しい仕事でした。アラビア数字の 0,1,2,3,…, 9 はまだ流布していませんでした。その代わり次のような記号が使われていました。
</p>
<center>
<table border=1>
<tr>
<td bgcolor="#EEFFFF" width="100">アラビア数字</td><td width="100">ローマ数字</td><td bgcolor="#EEFFFF" width="100">アラビア数字</td><td width="100">ローマ数字</td><td bgcolor="#EEFFFF" width="100">アラビア数字</td><td width="100">ローマ数字</td>
</tr>
<tr><td bgcolor="#EEFFFF">1</td><td>I</td><td bgcolor="#EEFFFF">11<td>XI</td><td bgcolor="#EEFFFF">30</td><td>XXX</td><td>
<tr><td bgcolor="#EEFFFF">2</td><td>II</td><td bgcolor="#EEFFFF">12<td>XII</td><td bgcolor="#EEFFFF">40</td><td>XL</td><td>
<tr><td bgcolor="#EEFFFF">3</td><td>III</td><td bgcolor="#EEFFFF">13<td>XIII</td><td bgcolor="#EEFFFF">50</td><td>L</td><td>
<tr><td bgcolor="#EEFFFF">4</td><td>IV</td><td bgcolor="#EEFFFF">14<td>XIV</td><td bgcolor="#EEFFFF">60</td><td>LX</td><td>
<tr><td bgcolor="#EEFFFF">5</td><td>V</td><td bgcolor="#EEFFFF">15<td>XV</td><td bgcolor="#EEFFFF">70</td><td>LXX</td><td>
<tr><td bgcolor="#EEFFFF">6</td><td>VI</td><td bgcolor="#EEFFFF">16<td>XVI</td><td bgcolor="#EEFFFF">80</td><td>LXXX</td><td>
<tr><td bgcolor="#EEFFFF">7</td><td>VII</td><td bgcolor="#EEFFFF">17<td>XVII</td><td bgcolor="#EEFFFF">90</td><td>XC</td><td>
<tr><td bgcolor="#EEFFFF">8</td><td>VIII</td><td bgcolor="#EEFFFF">18<td>XVIII</td><td bgcolor="#EEFFFF">100</td><td>C</td><td>
<tr><td bgcolor="#EEFFFF">9</td><td>IX</td><td bgcolor="#EEFFFF">19<td>XIX</td><td bgcolor="#EEFFFF">500</td><td>D</td><td>
<tr><td bgcolor="#EEFFFF">10</td><td>X</td><td bgcolor="#EEFFFF">20<td>XX</td><td bgcolor="#EEFFFF">1000</td><td>M</td><td>
</table>
</center>
<br/>
<p>
I は 1、 V は 5、 X は 10、 L は 50、 C は 100、 D は 500、 M は 1000、 他の例は上の表を見てください。小さい数が大きい数に続いている、つまり右側にあるときは足し算をします。小さい数が大きい数の前に、つまり左にあるときは、大きい数から小さい数を引きます。大きい数字の前にあって引き算を表す小さな数字は一回の引き算あたりひとつしかありません。
</p>
<p>
ローマ数字をアラビア数字（通常の数字）の表記（10 進表示）に変換して出力するプログラムを作成してください。ただし、与えられるローマ数字は上記のルールにのみ従っています(実際のローマ数字の表記にはもっと細かいルールがありますが、ここでは考慮する必要はありません。たとえば、実際のローマ数字ではI はV かX から、X はL かC から、C はD かM からしか引き算しませんし、同じローマ数字は４つ以上（または５つ以上）足し並べることはありません。)
</p>
<H2>Input</H2>
<p>
複数のデータセットが与えられます。それぞれのデータセットにローマ数字（半角大文字のI, V, X, L, C, D ,M で表される連続した文字列）が１行に与えられます。与えられるローマ数字の文字列の長さはおのおの 100 以下です。
</p>
<p>
データセットの数は 50 を超えません。
</p>
<H2>Output</H2>
<p>
各データセットに対し、アラビア数字（整数）を１行に出力して下さい。
</p>
<H2>Sample Input</H2>
<pre>
IV
CCCCLXXXXVIIII
CDXCIX
</pre>
<H2>Output for the Sample Input</H2>
<pre>
4
499
499
</pre>
|
s995435297 | p00039 | Accepted | num = {'I':1,'V':5,'X':10,'L':50,'C':100,'D':500,'M':1000}
while True:
try:
S = input()
except EOFError:
break
ans = 0
for i in range(0,len(S) - 1):
if num [S [i]] < num [S [i + 1]]:
ans -= num [S [i]]
else:
ans += num [S [i]]
ans += num [S [-1]]
print(ans) | IV
CCCCLXXXXVIIII
CDXCIX
| 4
499
499
|
<H1>ローマ数字</H1>
<p>
古代ローマでは数を数えることは難しい仕事でした。アラビア数字の 0,1,2,3,…, 9 はまだ流布していませんでした。その代わり次のような記号が使われていました。
</p>
<center>
<table border=1>
<tr>
<td bgcolor="#EEFFFF" width="100">アラビア数字</td><td width="100">ローマ数字</td><td bgcolor="#EEFFFF" width="100">アラビア数字</td><td width="100">ローマ数字</td><td bgcolor="#EEFFFF" width="100">アラビア数字</td><td width="100">ローマ数字</td>
</tr>
<tr><td bgcolor="#EEFFFF">1</td><td>I</td><td bgcolor="#EEFFFF">11<td>XI</td><td bgcolor="#EEFFFF">30</td><td>XXX</td><td>
<tr><td bgcolor="#EEFFFF">2</td><td>II</td><td bgcolor="#EEFFFF">12<td>XII</td><td bgcolor="#EEFFFF">40</td><td>XL</td><td>
<tr><td bgcolor="#EEFFFF">3</td><td>III</td><td bgcolor="#EEFFFF">13<td>XIII</td><td bgcolor="#EEFFFF">50</td><td>L</td><td>
<tr><td bgcolor="#EEFFFF">4</td><td>IV</td><td bgcolor="#EEFFFF">14<td>XIV</td><td bgcolor="#EEFFFF">60</td><td>LX</td><td>
<tr><td bgcolor="#EEFFFF">5</td><td>V</td><td bgcolor="#EEFFFF">15<td>XV</td><td bgcolor="#EEFFFF">70</td><td>LXX</td><td>
<tr><td bgcolor="#EEFFFF">6</td><td>VI</td><td bgcolor="#EEFFFF">16<td>XVI</td><td bgcolor="#EEFFFF">80</td><td>LXXX</td><td>
<tr><td bgcolor="#EEFFFF">7</td><td>VII</td><td bgcolor="#EEFFFF">17<td>XVII</td><td bgcolor="#EEFFFF">90</td><td>XC</td><td>
<tr><td bgcolor="#EEFFFF">8</td><td>VIII</td><td bgcolor="#EEFFFF">18<td>XVIII</td><td bgcolor="#EEFFFF">100</td><td>C</td><td>
<tr><td bgcolor="#EEFFFF">9</td><td>IX</td><td bgcolor="#EEFFFF">19<td>XIX</td><td bgcolor="#EEFFFF">500</td><td>D</td><td>
<tr><td bgcolor="#EEFFFF">10</td><td>X</td><td bgcolor="#EEFFFF">20<td>XX</td><td bgcolor="#EEFFFF">1000</td><td>M</td><td>
</table>
</center>
<br/>
<p>
I は 1、 V は 5、 X は 10、 L は 50、 C は 100、 D は 500、 M は 1000、 他の例は上の表を見てください。小さい数が大きい数に続いている、つまり右側にあるときは足し算をします。小さい数が大きい数の前に、つまり左にあるときは、大きい数から小さい数を引きます。大きい数字の前にあって引き算を表す小さな数字は一回の引き算あたりひとつしかありません。
</p>
<p>
ローマ数字をアラビア数字（通常の数字）の表記（10 進表示）に変換して出力するプログラムを作成してください。ただし、与えられるローマ数字は上記のルールにのみ従っています(実際のローマ数字の表記にはもっと細かいルールがありますが、ここでは考慮する必要はありません。たとえば、実際のローマ数字ではI はV かX から、X はL かC から、C はD かM からしか引き算しませんし、同じローマ数字は４つ以上（または５つ以上）足し並べることはありません。)
</p>
<H2>Input</H2>
<p>
複数のデータセットが与えられます。それぞれのデータセットにローマ数字（半角大文字のI, V, X, L, C, D ,M で表される連続した文字列）が１行に与えられます。与えられるローマ数字の文字列の長さはおのおの 100 以下です。
</p>
<p>
データセットの数は 50 を超えません。
</p>
<H2>Output</H2>
<p>
各データセットに対し、アラビア数字（整数）を１行に出力して下さい。
</p>
<H2>Sample Input</H2>
<pre>
IV
CCCCLXXXXVIIII
CDXCIX
</pre>
<H2>Output for the Sample Input</H2>
<pre>
4
499
499
</pre>
|
s368453480 | p00039 | Accepted | rule = ["I","V","X","L","C","D","M"]
val = [1,5,10,50,100,500,1000]
while True:
try:
nums = input()
ans = val[rule.index(nums[0])]
for i in range(1,len(nums)):
ans += val[rule.index(nums[i])]
if rule.index(nums[i]) > rule.index(nums[i-1]):
ans -= (2*val[rule.index(nums[i-1])])
print(ans)
except EOFError: break | IV
CCCCLXXXXVIIII
CDXCIX
| 4
499
499
|
<H1>ローマ数字</H1>
<p>
古代ローマでは数を数えることは難しい仕事でした。アラビア数字の 0,1,2,3,…, 9 はまだ流布していませんでした。その代わり次のような記号が使われていました。
</p>
<center>
<table border=1>
<tr>
<td bgcolor="#EEFFFF" width="100">アラビア数字</td><td width="100">ローマ数字</td><td bgcolor="#EEFFFF" width="100">アラビア数字</td><td width="100">ローマ数字</td><td bgcolor="#EEFFFF" width="100">アラビア数字</td><td width="100">ローマ数字</td>
</tr>
<tr><td bgcolor="#EEFFFF">1</td><td>I</td><td bgcolor="#EEFFFF">11<td>XI</td><td bgcolor="#EEFFFF">30</td><td>XXX</td><td>
<tr><td bgcolor="#EEFFFF">2</td><td>II</td><td bgcolor="#EEFFFF">12<td>XII</td><td bgcolor="#EEFFFF">40</td><td>XL</td><td>
<tr><td bgcolor="#EEFFFF">3</td><td>III</td><td bgcolor="#EEFFFF">13<td>XIII</td><td bgcolor="#EEFFFF">50</td><td>L</td><td>
<tr><td bgcolor="#EEFFFF">4</td><td>IV</td><td bgcolor="#EEFFFF">14<td>XIV</td><td bgcolor="#EEFFFF">60</td><td>LX</td><td>
<tr><td bgcolor="#EEFFFF">5</td><td>V</td><td bgcolor="#EEFFFF">15<td>XV</td><td bgcolor="#EEFFFF">70</td><td>LXX</td><td>
<tr><td bgcolor="#EEFFFF">6</td><td>VI</td><td bgcolor="#EEFFFF">16<td>XVI</td><td bgcolor="#EEFFFF">80</td><td>LXXX</td><td>
<tr><td bgcolor="#EEFFFF">7</td><td>VII</td><td bgcolor="#EEFFFF">17<td>XVII</td><td bgcolor="#EEFFFF">90</td><td>XC</td><td>
<tr><td bgcolor="#EEFFFF">8</td><td>VIII</td><td bgcolor="#EEFFFF">18<td>XVIII</td><td bgcolor="#EEFFFF">100</td><td>C</td><td>
<tr><td bgcolor="#EEFFFF">9</td><td>IX</td><td bgcolor="#EEFFFF">19<td>XIX</td><td bgcolor="#EEFFFF">500</td><td>D</td><td>
<tr><td bgcolor="#EEFFFF">10</td><td>X</td><td bgcolor="#EEFFFF">20<td>XX</td><td bgcolor="#EEFFFF">1000</td><td>M</td><td>
</table>
</center>
<br/>
<p>
I は 1、 V は 5、 X は 10、 L は 50、 C は 100、 D は 500、 M は 1000、 他の例は上の表を見てください。小さい数が大きい数に続いている、つまり右側にあるときは足し算をします。小さい数が大きい数の前に、つまり左にあるときは、大きい数から小さい数を引きます。大きい数字の前にあって引き算を表す小さな数字は一回の引き算あたりひとつしかありません。
</p>
<p>
ローマ数字をアラビア数字（通常の数字）の表記（10 進表示）に変換して出力するプログラムを作成してください。ただし、与えられるローマ数字は上記のルールにのみ従っています(実際のローマ数字の表記にはもっと細かいルールがありますが、ここでは考慮する必要はありません。たとえば、実際のローマ数字ではI はV かX から、X はL かC から、C はD かM からしか引き算しませんし、同じローマ数字は４つ以上（または５つ以上）足し並べることはありません。)
</p>
<H2>Input</H2>
<p>
複数のデータセットが与えられます。それぞれのデータセットにローマ数字（半角大文字のI, V, X, L, C, D ,M で表される連続した文字列）が１行に与えられます。与えられるローマ数字の文字列の長さはおのおの 100 以下です。
</p>
<p>
データセットの数は 50 を超えません。
</p>
<H2>Output</H2>
<p>
各データセットに対し、アラビア数字（整数）を１行に出力して下さい。
</p>
<H2>Sample Input</H2>
<pre>
IV
CCCCLXXXXVIIII
CDXCIX
</pre>
<H2>Output for the Sample Input</H2>
<pre>
4
499
499
</pre>
|
s409074916 | p00039 | Accepted | # -*- coding: utf-8 -*-
import sys
import os
alab = {}
alab['I'] = 1
alab['V'] = 5
alab['X'] = 10
alab['L'] = 50
alab['C'] = 100
alab['D'] = 500
alab['M'] = 1000
for s in sys.stdin:
s = s.strip()
#print('s', s)
A = []
for c in s:
A.append(alab[c])
#print('A', A)
for i in range(len(A) - 1):
if A[i] < A[i+1]:
A[i] *= -1
#print('A', A)
print(sum(A)) | IV
CCCCLXXXXVIIII
CDXCIX
| 4
499
499
|
<H1>ローマ数字</H1>
<p>
古代ローマでは数を数えることは難しい仕事でした。アラビア数字の 0,1,2,3,…, 9 はまだ流布していませんでした。その代わり次のような記号が使われていました。
</p>
<center>
<table border=1>
<tr>
<td bgcolor="#EEFFFF" width="100">アラビア数字</td><td width="100">ローマ数字</td><td bgcolor="#EEFFFF" width="100">アラビア数字</td><td width="100">ローマ数字</td><td bgcolor="#EEFFFF" width="100">アラビア数字</td><td width="100">ローマ数字</td>
</tr>
<tr><td bgcolor="#EEFFFF">1</td><td>I</td><td bgcolor="#EEFFFF">11<td>XI</td><td bgcolor="#EEFFFF">30</td><td>XXX</td><td>
<tr><td bgcolor="#EEFFFF">2</td><td>II</td><td bgcolor="#EEFFFF">12<td>XII</td><td bgcolor="#EEFFFF">40</td><td>XL</td><td>
<tr><td bgcolor="#EEFFFF">3</td><td>III</td><td bgcolor="#EEFFFF">13<td>XIII</td><td bgcolor="#EEFFFF">50</td><td>L</td><td>
<tr><td bgcolor="#EEFFFF">4</td><td>IV</td><td bgcolor="#EEFFFF">14<td>XIV</td><td bgcolor="#EEFFFF">60</td><td>LX</td><td>
<tr><td bgcolor="#EEFFFF">5</td><td>V</td><td bgcolor="#EEFFFF">15<td>XV</td><td bgcolor="#EEFFFF">70</td><td>LXX</td><td>
<tr><td bgcolor="#EEFFFF">6</td><td>VI</td><td bgcolor="#EEFFFF">16<td>XVI</td><td bgcolor="#EEFFFF">80</td><td>LXXX</td><td>
<tr><td bgcolor="#EEFFFF">7</td><td>VII</td><td bgcolor="#EEFFFF">17<td>XVII</td><td bgcolor="#EEFFFF">90</td><td>XC</td><td>
<tr><td bgcolor="#EEFFFF">8</td><td>VIII</td><td bgcolor="#EEFFFF">18<td>XVIII</td><td bgcolor="#EEFFFF">100</td><td>C</td><td>
<tr><td bgcolor="#EEFFFF">9</td><td>IX</td><td bgcolor="#EEFFFF">19<td>XIX</td><td bgcolor="#EEFFFF">500</td><td>D</td><td>
<tr><td bgcolor="#EEFFFF">10</td><td>X</td><td bgcolor="#EEFFFF">20<td>XX</td><td bgcolor="#EEFFFF">1000</td><td>M</td><td>
</table>
</center>
<br/>
<p>
I は 1、 V は 5、 X は 10、 L は 50、 C は 100、 D は 500、 M は 1000、 他の例は上の表を見てください。小さい数が大きい数に続いている、つまり右側にあるときは足し算をします。小さい数が大きい数の前に、つまり左にあるときは、大きい数から小さい数を引きます。大きい数字の前にあって引き算を表す小さな数字は一回の引き算あたりひとつしかありません。
</p>
<p>
ローマ数字をアラビア数字（通常の数字）の表記（10 進表示）に変換して出力するプログラムを作成してください。ただし、与えられるローマ数字は上記のルールにのみ従っています(実際のローマ数字の表記にはもっと細かいルールがありますが、ここでは考慮する必要はありません。たとえば、実際のローマ数字ではI はV かX から、X はL かC から、C はD かM からしか引き算しませんし、同じローマ数字は４つ以上（または５つ以上）足し並べることはありません。)
</p>
<H2>Input</H2>
<p>
複数のデータセットが与えられます。それぞれのデータセットにローマ数字（半角大文字のI, V, X, L, C, D ,M で表される連続した文字列）が１行に与えられます。与えられるローマ数字の文字列の長さはおのおの 100 以下です。
</p>
<p>
データセットの数は 50 を超えません。
</p>
<H2>Output</H2>
<p>
各データセットに対し、アラビア数字（整数）を１行に出力して下さい。
</p>
<H2>Sample Input</H2>
<pre>
IV
CCCCLXXXXVIIII
CDXCIX
</pre>
<H2>Output for the Sample Input</H2>
<pre>
4
499
499
</pre>
|
s299558457 | p00039 | Accepted | sample = {'I':1, 'V':5, 'X':10, 'L':50, 'C':100, 'D':500, 'M':1000}
while True :
try :
temp = input()
f = temp[0]
total = 0
for _ in temp[1:] :
if sample[f] < sample[_] : total -= sample[f]
else : total += sample[f]
f = _
total += sample[temp[-1]]
print(total)
except : break | IV
CCCCLXXXXVIIII
CDXCIX
| 4
499
499
|
<H1>ローマ数字</H1>
<p>
古代ローマでは数を数えることは難しい仕事でした。アラビア数字の 0,1,2,3,…, 9 はまだ流布していませんでした。その代わり次のような記号が使われていました。
</p>
<center>
<table border=1>
<tr>
<td bgcolor="#EEFFFF" width="100">アラビア数字</td><td width="100">ローマ数字</td><td bgcolor="#EEFFFF" width="100">アラビア数字</td><td width="100">ローマ数字</td><td bgcolor="#EEFFFF" width="100">アラビア数字</td><td width="100">ローマ数字</td>
</tr>
<tr><td bgcolor="#EEFFFF">1</td><td>I</td><td bgcolor="#EEFFFF">11<td>XI</td><td bgcolor="#EEFFFF">30</td><td>XXX</td><td>
<tr><td bgcolor="#EEFFFF">2</td><td>II</td><td bgcolor="#EEFFFF">12<td>XII</td><td bgcolor="#EEFFFF">40</td><td>XL</td><td>
<tr><td bgcolor="#EEFFFF">3</td><td>III</td><td bgcolor="#EEFFFF">13<td>XIII</td><td bgcolor="#EEFFFF">50</td><td>L</td><td>
<tr><td bgcolor="#EEFFFF">4</td><td>IV</td><td bgcolor="#EEFFFF">14<td>XIV</td><td bgcolor="#EEFFFF">60</td><td>LX</td><td>
<tr><td bgcolor="#EEFFFF">5</td><td>V</td><td bgcolor="#EEFFFF">15<td>XV</td><td bgcolor="#EEFFFF">70</td><td>LXX</td><td>
<tr><td bgcolor="#EEFFFF">6</td><td>VI</td><td bgcolor="#EEFFFF">16<td>XVI</td><td bgcolor="#EEFFFF">80</td><td>LXXX</td><td>
<tr><td bgcolor="#EEFFFF">7</td><td>VII</td><td bgcolor="#EEFFFF">17<td>XVII</td><td bgcolor="#EEFFFF">90</td><td>XC</td><td>
<tr><td bgcolor="#EEFFFF">8</td><td>VIII</td><td bgcolor="#EEFFFF">18<td>XVIII</td><td bgcolor="#EEFFFF">100</td><td>C</td><td>
<tr><td bgcolor="#EEFFFF">9</td><td>IX</td><td bgcolor="#EEFFFF">19<td>XIX</td><td bgcolor="#EEFFFF">500</td><td>D</td><td>
<tr><td bgcolor="#EEFFFF">10</td><td>X</td><td bgcolor="#EEFFFF">20<td>XX</td><td bgcolor="#EEFFFF">1000</td><td>M</td><td>
</table>
</center>
<br/>
<p>
I は 1、 V は 5、 X は 10、 L は 50、 C は 100、 D は 500、 M は 1000、 他の例は上の表を見てください。小さい数が大きい数に続いている、つまり右側にあるときは足し算をします。小さい数が大きい数の前に、つまり左にあるときは、大きい数から小さい数を引きます。大きい数字の前にあって引き算を表す小さな数字は一回の引き算あたりひとつしかありません。
</p>
<p>
ローマ数字をアラビア数字（通常の数字）の表記（10 進表示）に変換して出力するプログラムを作成してください。ただし、与えられるローマ数字は上記のルールにのみ従っています(実際のローマ数字の表記にはもっと細かいルールがありますが、ここでは考慮する必要はありません。たとえば、実際のローマ数字ではI はV かX から、X はL かC から、C はD かM からしか引き算しませんし、同じローマ数字は４つ以上（または５つ以上）足し並べることはありません。)
</p>
<H2>Input</H2>
<p>
複数のデータセットが与えられます。それぞれのデータセットにローマ数字（半角大文字のI, V, X, L, C, D ,M で表される連続した文字列）が１行に与えられます。与えられるローマ数字の文字列の長さはおのおの 100 以下です。
</p>
<p>
データセットの数は 50 を超えません。
</p>
<H2>Output</H2>
<p>
各データセットに対し、アラビア数字（整数）を１行に出力して下さい。
</p>
<H2>Sample Input</H2>
<pre>
IV
CCCCLXXXXVIIII
CDXCIX
</pre>
<H2>Output for the Sample Input</H2>
<pre>
4
499
499
</pre>
|
s796213233 | p00039 | Accepted | figures = ["M", "D", "C", "L", "X", "V", "I"]
hoge = {0: 1000, 1: 500, 2: 100, 3: 50, 4: 10, 5: 5, 6: 1}
while True:
try:
st = input()
except:
break
idx = figures.index(st[0])
res = [hoge[idx]]
pretoken = st[0]
for i, s in enumerate(st[1:]):
idx = figures.index(s)
preidx = figures.index(pretoken)
if idx < preidx:
res[i] = -1 * res[i]
res.append(hoge[idx])
pretoken = s
print(sum(res)) | IV
CCCCLXXXXVIIII
CDXCIX
| 4
499
499
|
<H1>ローマ数字</H1>
<p>
古代ローマでは数を数えることは難しい仕事でした。アラビア数字の 0,1,2,3,…, 9 はまだ流布していませんでした。その代わり次のような記号が使われていました。
</p>
<center>
<table border=1>
<tr>
<td bgcolor="#EEFFFF" width="100">アラビア数字</td><td width="100">ローマ数字</td><td bgcolor="#EEFFFF" width="100">アラビア数字</td><td width="100">ローマ数字</td><td bgcolor="#EEFFFF" width="100">アラビア数字</td><td width="100">ローマ数字</td>
</tr>
<tr><td bgcolor="#EEFFFF">1</td><td>I</td><td bgcolor="#EEFFFF">11<td>XI</td><td bgcolor="#EEFFFF">30</td><td>XXX</td><td>
<tr><td bgcolor="#EEFFFF">2</td><td>II</td><td bgcolor="#EEFFFF">12<td>XII</td><td bgcolor="#EEFFFF">40</td><td>XL</td><td>
<tr><td bgcolor="#EEFFFF">3</td><td>III</td><td bgcolor="#EEFFFF">13<td>XIII</td><td bgcolor="#EEFFFF">50</td><td>L</td><td>
<tr><td bgcolor="#EEFFFF">4</td><td>IV</td><td bgcolor="#EEFFFF">14<td>XIV</td><td bgcolor="#EEFFFF">60</td><td>LX</td><td>
<tr><td bgcolor="#EEFFFF">5</td><td>V</td><td bgcolor="#EEFFFF">15<td>XV</td><td bgcolor="#EEFFFF">70</td><td>LXX</td><td>
<tr><td bgcolor="#EEFFFF">6</td><td>VI</td><td bgcolor="#EEFFFF">16<td>XVI</td><td bgcolor="#EEFFFF">80</td><td>LXXX</td><td>
<tr><td bgcolor="#EEFFFF">7</td><td>VII</td><td bgcolor="#EEFFFF">17<td>XVII</td><td bgcolor="#EEFFFF">90</td><td>XC</td><td>
<tr><td bgcolor="#EEFFFF">8</td><td>VIII</td><td bgcolor="#EEFFFF">18<td>XVIII</td><td bgcolor="#EEFFFF">100</td><td>C</td><td>
<tr><td bgcolor="#EEFFFF">9</td><td>IX</td><td bgcolor="#EEFFFF">19<td>XIX</td><td bgcolor="#EEFFFF">500</td><td>D</td><td>
<tr><td bgcolor="#EEFFFF">10</td><td>X</td><td bgcolor="#EEFFFF">20<td>XX</td><td bgcolor="#EEFFFF">1000</td><td>M</td><td>
</table>
</center>
<br/>
<p>
I は 1、 V は 5、 X は 10、 L は 50、 C は 100、 D は 500、 M は 1000、 他の例は上の表を見てください。小さい数が大きい数に続いている、つまり右側にあるときは足し算をします。小さい数が大きい数の前に、つまり左にあるときは、大きい数から小さい数を引きます。大きい数字の前にあって引き算を表す小さな数字は一回の引き算あたりひとつしかありません。
</p>
<p>
ローマ数字をアラビア数字（通常の数字）の表記（10 進表示）に変換して出力するプログラムを作成してください。ただし、与えられるローマ数字は上記のルールにのみ従っています(実際のローマ数字の表記にはもっと細かいルールがありますが、ここでは考慮する必要はありません。たとえば、実際のローマ数字ではI はV かX から、X はL かC から、C はD かM からしか引き算しませんし、同じローマ数字は４つ以上（または５つ以上）足し並べることはありません。)
</p>
<H2>Input</H2>
<p>
複数のデータセットが与えられます。それぞれのデータセットにローマ数字（半角大文字のI, V, X, L, C, D ,M で表される連続した文字列）が１行に与えられます。与えられるローマ数字の文字列の長さはおのおの 100 以下です。
</p>
<p>
データセットの数は 50 を超えません。
</p>
<H2>Output</H2>
<p>
各データセットに対し、アラビア数字（整数）を１行に出力して下さい。
</p>
<H2>Sample Input</H2>
<pre>
IV
CCCCLXXXXVIIII
CDXCIX
</pre>
<H2>Output for the Sample Input</H2>
<pre>
4
499
499
</pre>
|
s359317286 | p00039 | Accepted | import sys
def arabic(s):
if s == "I":
return 1
elif s == "V":
return 5
elif s == "X":
return 10
elif s == "L":
return 50
elif s == "C":
return 100
elif s == "D":
return 500
elif s == "M":
return 1000
else:
return -1
for i in sys.stdin:
S = 0
for j in range(len(i)):
if arabic(i[j]) == -1:
continue
# print("ver1")
elif j != 0 and arabic(i[j-1]) < arabic(i[j]):
S = S - arabic(i[j-1]) * 2 + arabic(i[j])
# print("ver2")
else:
S += arabic(i[j])
# print("ver3")
# print(str(S) + "!")
print(S) | IV
CCCCLXXXXVIIII
CDXCIX
| 4
499
499
|
<H1>ローマ数字</H1>
<p>
古代ローマでは数を数えることは難しい仕事でした。アラビア数字の 0,1,2,3,…, 9 はまだ流布していませんでした。その代わり次のような記号が使われていました。
</p>
<center>
<table border=1>
<tr>
<td bgcolor="#EEFFFF" width="100">アラビア数字</td><td width="100">ローマ数字</td><td bgcolor="#EEFFFF" width="100">アラビア数字</td><td width="100">ローマ数字</td><td bgcolor="#EEFFFF" width="100">アラビア数字</td><td width="100">ローマ数字</td>
</tr>
<tr><td bgcolor="#EEFFFF">1</td><td>I</td><td bgcolor="#EEFFFF">11<td>XI</td><td bgcolor="#EEFFFF">30</td><td>XXX</td><td>
<tr><td bgcolor="#EEFFFF">2</td><td>II</td><td bgcolor="#EEFFFF">12<td>XII</td><td bgcolor="#EEFFFF">40</td><td>XL</td><td>
<tr><td bgcolor="#EEFFFF">3</td><td>III</td><td bgcolor="#EEFFFF">13<td>XIII</td><td bgcolor="#EEFFFF">50</td><td>L</td><td>
<tr><td bgcolor="#EEFFFF">4</td><td>IV</td><td bgcolor="#EEFFFF">14<td>XIV</td><td bgcolor="#EEFFFF">60</td><td>LX</td><td>
<tr><td bgcolor="#EEFFFF">5</td><td>V</td><td bgcolor="#EEFFFF">15<td>XV</td><td bgcolor="#EEFFFF">70</td><td>LXX</td><td>
<tr><td bgcolor="#EEFFFF">6</td><td>VI</td><td bgcolor="#EEFFFF">16<td>XVI</td><td bgcolor="#EEFFFF">80</td><td>LXXX</td><td>
<tr><td bgcolor="#EEFFFF">7</td><td>VII</td><td bgcolor="#EEFFFF">17<td>XVII</td><td bgcolor="#EEFFFF">90</td><td>XC</td><td>
<tr><td bgcolor="#EEFFFF">8</td><td>VIII</td><td bgcolor="#EEFFFF">18<td>XVIII</td><td bgcolor="#EEFFFF">100</td><td>C</td><td>
<tr><td bgcolor="#EEFFFF">9</td><td>IX</td><td bgcolor="#EEFFFF">19<td>XIX</td><td bgcolor="#EEFFFF">500</td><td>D</td><td>
<tr><td bgcolor="#EEFFFF">10</td><td>X</td><td bgcolor="#EEFFFF">20<td>XX</td><td bgcolor="#EEFFFF">1000</td><td>M</td><td>
</table>
</center>
<br/>
<p>
I は 1、 V は 5、 X は 10、 L は 50、 C は 100、 D は 500、 M は 1000、 他の例は上の表を見てください。小さい数が大きい数に続いている、つまり右側にあるときは足し算をします。小さい数が大きい数の前に、つまり左にあるときは、大きい数から小さい数を引きます。大きい数字の前にあって引き算を表す小さな数字は一回の引き算あたりひとつしかありません。
</p>
<p>
ローマ数字をアラビア数字（通常の数字）の表記（10 進表示）に変換して出力するプログラムを作成してください。ただし、与えられるローマ数字は上記のルールにのみ従っています(実際のローマ数字の表記にはもっと細かいルールがありますが、ここでは考慮する必要はありません。たとえば、実際のローマ数字ではI はV かX から、X はL かC から、C はD かM からしか引き算しませんし、同じローマ数字は４つ以上（または５つ以上）足し並べることはありません。)
</p>
<H2>Input</H2>
<p>
複数のデータセットが与えられます。それぞれのデータセットにローマ数字（半角大文字のI, V, X, L, C, D ,M で表される連続した文字列）が１行に与えられます。与えられるローマ数字の文字列の長さはおのおの 100 以下です。
</p>
<p>
データセットの数は 50 を超えません。
</p>
<H2>Output</H2>
<p>
各データセットに対し、アラビア数字（整数）を１行に出力して下さい。
</p>
<H2>Sample Input</H2>
<pre>
IV
CCCCLXXXXVIIII
CDXCIX
</pre>
<H2>Output for the Sample Input</H2>
<pre>
4
499
499
</pre>
|
s805923967 | p00039 | Accepted | # Aizu Problem 0039: Roman Figure
#
import sys, math, os
# read input:
PYDEV = os.environ.get('PYDEV')
if PYDEV=="True":
sys.stdin = open("sample-input.txt", "rt")
def roman_to_decimal(r):
n = 0
while len(r) > 0 and r[0] == "M":
n += 1000
r = r[1:]
if len(r) == 0:
return n
if r[:2] == "CM":
n += 900
r = r[2:]
if len(r) == 0:
return n
if r[0] == "D":
n += 500
r = r[1:]
if len(r) == 0:
return n
if r[:2] == "CD":
n += 400
r = r[2:]
if len(r) == 0:
return n
while len(r) > 0 and r[0] == "C":
n += 100
r = r[1:]
if len(r) == 0:
return n
if r[:2] == "XC":
n += 90
r = r[2:]
if len(r) == 0:
return n
if r[0] == "L":
n += 50
r = r[1:]
if len(r) == 0:
return n
if r[:2] == "XL":
n += 40
r = r[2:]
if len(r) == 0:
return n
while len(r) > 0 and r[0] == "X":
n += 10
r = r[1:]
if len(r) == 0:
return n
if r[:2] == "IX":
n += 9
elif r[:2] == "IV":
n += 4
else:
if r[0] == "V":
n += 5
r = r[1:]
while len(r) > 0 and r[0] == "I":
n += 1
r = r[1:]
if len(r) == 0:
return n
return n
for line in sys.stdin:
print(roman_to_decimal(line.strip())) | IV
CCCCLXXXXVIIII
CDXCIX
| 4
499
499
|
<H1>ローマ数字</H1>
<p>
古代ローマでは数を数えることは難しい仕事でした。アラビア数字の 0,1,2,3,…, 9 はまだ流布していませんでした。その代わり次のような記号が使われていました。
</p>
<center>
<table border=1>
<tr>
<td bgcolor="#EEFFFF" width="100">アラビア数字</td><td width="100">ローマ数字</td><td bgcolor="#EEFFFF" width="100">アラビア数字</td><td width="100">ローマ数字</td><td bgcolor="#EEFFFF" width="100">アラビア数字</td><td width="100">ローマ数字</td>
</tr>
<tr><td bgcolor="#EEFFFF">1</td><td>I</td><td bgcolor="#EEFFFF">11<td>XI</td><td bgcolor="#EEFFFF">30</td><td>XXX</td><td>
<tr><td bgcolor="#EEFFFF">2</td><td>II</td><td bgcolor="#EEFFFF">12<td>XII</td><td bgcolor="#EEFFFF">40</td><td>XL</td><td>
<tr><td bgcolor="#EEFFFF">3</td><td>III</td><td bgcolor="#EEFFFF">13<td>XIII</td><td bgcolor="#EEFFFF">50</td><td>L</td><td>
<tr><td bgcolor="#EEFFFF">4</td><td>IV</td><td bgcolor="#EEFFFF">14<td>XIV</td><td bgcolor="#EEFFFF">60</td><td>LX</td><td>
<tr><td bgcolor="#EEFFFF">5</td><td>V</td><td bgcolor="#EEFFFF">15<td>XV</td><td bgcolor="#EEFFFF">70</td><td>LXX</td><td>
<tr><td bgcolor="#EEFFFF">6</td><td>VI</td><td bgcolor="#EEFFFF">16<td>XVI</td><td bgcolor="#EEFFFF">80</td><td>LXXX</td><td>
<tr><td bgcolor="#EEFFFF">7</td><td>VII</td><td bgcolor="#EEFFFF">17<td>XVII</td><td bgcolor="#EEFFFF">90</td><td>XC</td><td>
<tr><td bgcolor="#EEFFFF">8</td><td>VIII</td><td bgcolor="#EEFFFF">18<td>XVIII</td><td bgcolor="#EEFFFF">100</td><td>C</td><td>
<tr><td bgcolor="#EEFFFF">9</td><td>IX</td><td bgcolor="#EEFFFF">19<td>XIX</td><td bgcolor="#EEFFFF">500</td><td>D</td><td>
<tr><td bgcolor="#EEFFFF">10</td><td>X</td><td bgcolor="#EEFFFF">20<td>XX</td><td bgcolor="#EEFFFF">1000</td><td>M</td><td>
</table>
</center>
<br/>
<p>
I は 1、 V は 5、 X は 10、 L は 50、 C は 100、 D は 500、 M は 1000、 他の例は上の表を見てください。小さい数が大きい数に続いている、つまり右側にあるときは足し算をします。小さい数が大きい数の前に、つまり左にあるときは、大きい数から小さい数を引きます。大きい数字の前にあって引き算を表す小さな数字は一回の引き算あたりひとつしかありません。
</p>
<p>
ローマ数字をアラビア数字（通常の数字）の表記（10 進表示）に変換して出力するプログラムを作成してください。ただし、与えられるローマ数字は上記のルールにのみ従っています(実際のローマ数字の表記にはもっと細かいルールがありますが、ここでは考慮する必要はありません。たとえば、実際のローマ数字ではI はV かX から、X はL かC から、C はD かM からしか引き算しませんし、同じローマ数字は４つ以上（または５つ以上）足し並べることはありません。)
</p>
<H2>Input</H2>
<p>
複数のデータセットが与えられます。それぞれのデータセットにローマ数字（半角大文字のI, V, X, L, C, D ,M で表される連続した文字列）が１行に与えられます。与えられるローマ数字の文字列の長さはおのおの 100 以下です。
</p>
<p>
データセットの数は 50 を超えません。
</p>
<H2>Output</H2>
<p>
各データセットに対し、アラビア数字（整数）を１行に出力して下さい。
</p>
<H2>Sample Input</H2>
<pre>
IV
CCCCLXXXXVIIII
CDXCIX
</pre>
<H2>Output for the Sample Input</H2>
<pre>
4
499
499
</pre>
|
s815283327 | p00039 | Accepted | import sys
roman = {'I': 1, 'V': 5, 'X': 10, 'L': 50, 'C': 100, 'D': 500, 'M': 1000}
def check(i, y):
if i == y:
return True
elif i == 'I' and y == 'V':
return True
elif i == 'V' and (y == 'I' or y == 'X'):
return True
elif i == 'X' and (y == 'V' or y == 'L'):
return True
elif i == 'L' and (y == 'X' or y == 'C'):
return True
elif i == 'C' and (y == 'L' or y == 'D'):
return True
elif i == 'D' and (y == 'C' or y == 'M'):
return True
elif i == 'M' and y == 'D':
return True
else:
return False
def solve(r):
if len(r) == 1:
return roman[r[0]]
else:
maxRoman = 0
for i in range(len(r) - 1):
if roman[r[i]] < roman[r[i + 1]]:
maxRoman = i + 1
else:
break
ans = roman[r[maxRoman]]
for sub in range(maxRoman - 1, -1, -1):
ans -= roman[r[sub]]
for add in range(maxRoman + 1, len(r)):
if add < len(r) - 1 and not check(r[add - 1], r[add]):
r = r[add:]
return ans + solve(r)
ans += roman[r[add]]
return ans
for line in sys.stdin:
try:
line = line.replace('\n', '')
print(solve(line))
except:
break | IV
CCCCLXXXXVIIII
CDXCIX
| 4
499
499
|
<H1>ローマ数字</H1>
<p>
古代ローマでは数を数えることは難しい仕事でした。アラビア数字の 0,1,2,3,…, 9 はまだ流布していませんでした。その代わり次のような記号が使われていました。
</p>
<center>
<table border=1>
<tr>
<td bgcolor="#EEFFFF" width="100">アラビア数字</td><td width="100">ローマ数字</td><td bgcolor="#EEFFFF" width="100">アラビア数字</td><td width="100">ローマ数字</td><td bgcolor="#EEFFFF" width="100">アラビア数字</td><td width="100">ローマ数字</td>
</tr>
<tr><td bgcolor="#EEFFFF">1</td><td>I</td><td bgcolor="#EEFFFF">11<td>XI</td><td bgcolor="#EEFFFF">30</td><td>XXX</td><td>
<tr><td bgcolor="#EEFFFF">2</td><td>II</td><td bgcolor="#EEFFFF">12<td>XII</td><td bgcolor="#EEFFFF">40</td><td>XL</td><td>
<tr><td bgcolor="#EEFFFF">3</td><td>III</td><td bgcolor="#EEFFFF">13<td>XIII</td><td bgcolor="#EEFFFF">50</td><td>L</td><td>
<tr><td bgcolor="#EEFFFF">4</td><td>IV</td><td bgcolor="#EEFFFF">14<td>XIV</td><td bgcolor="#EEFFFF">60</td><td>LX</td><td>
<tr><td bgcolor="#EEFFFF">5</td><td>V</td><td bgcolor="#EEFFFF">15<td>XV</td><td bgcolor="#EEFFFF">70</td><td>LXX</td><td>
<tr><td bgcolor="#EEFFFF">6</td><td>VI</td><td bgcolor="#EEFFFF">16<td>XVI</td><td bgcolor="#EEFFFF">80</td><td>LXXX</td><td>
<tr><td bgcolor="#EEFFFF">7</td><td>VII</td><td bgcolor="#EEFFFF">17<td>XVII</td><td bgcolor="#EEFFFF">90</td><td>XC</td><td>
<tr><td bgcolor="#EEFFFF">8</td><td>VIII</td><td bgcolor="#EEFFFF">18<td>XVIII</td><td bgcolor="#EEFFFF">100</td><td>C</td><td>
<tr><td bgcolor="#EEFFFF">9</td><td>IX</td><td bgcolor="#EEFFFF">19<td>XIX</td><td bgcolor="#EEFFFF">500</td><td>D</td><td>
<tr><td bgcolor="#EEFFFF">10</td><td>X</td><td bgcolor="#EEFFFF">20<td>XX</td><td bgcolor="#EEFFFF">1000</td><td>M</td><td>
</table>
</center>
<br/>
<p>
I は 1、 V は 5、 X は 10、 L は 50、 C は 100、 D は 500、 M は 1000、 他の例は上の表を見てください。小さい数が大きい数に続いている、つまり右側にあるときは足し算をします。小さい数が大きい数の前に、つまり左にあるときは、大きい数から小さい数を引きます。大きい数字の前にあって引き算を表す小さな数字は一回の引き算あたりひとつしかありません。
</p>
<p>
ローマ数字をアラビア数字（通常の数字）の表記（10 進表示）に変換して出力するプログラムを作成してください。ただし、与えられるローマ数字は上記のルールにのみ従っています(実際のローマ数字の表記にはもっと細かいルールがありますが、ここでは考慮する必要はありません。たとえば、実際のローマ数字ではI はV かX から、X はL かC から、C はD かM からしか引き算しませんし、同じローマ数字は４つ以上（または５つ以上）足し並べることはありません。)
</p>
<H2>Input</H2>
<p>
複数のデータセットが与えられます。それぞれのデータセットにローマ数字（半角大文字のI, V, X, L, C, D ,M で表される連続した文字列）が１行に与えられます。与えられるローマ数字の文字列の長さはおのおの 100 以下です。
</p>
<p>
データセットの数は 50 を超えません。
</p>
<H2>Output</H2>
<p>
各データセットに対し、アラビア数字（整数）を１行に出力して下さい。
</p>
<H2>Sample Input</H2>
<pre>
IV
CCCCLXXXXVIIII
CDXCIX
</pre>
<H2>Output for the Sample Input</H2>
<pre>
4
499
499
</pre>
|
s127284951 | p00039 | Accepted | import sys
d = {
'I': 1,
'V': 5,
'X': 10,
'L': 50,
'C': 100,
'D': 500,
'M': 1000
}
for s in sys.stdin:
c = 0
for i,j in enumerate(list(s)):
if j == '\n':
break
try:
if j == 'I' and (s[i+1] == 'V' or s[i+1] == 'X'):
c -= 1
elif j == 'X' and (s[i+1] == 'L' or s[i+1] == 'C'):
c -= 10
elif j == 'C' and (s[i+1] == 'D' or s[i+1] == 'M'):
c -= 100
else:
c += d[j]
except:
c += d[j]
print(c)
| IV
CCCCLXXXXVIIII
CDXCIX
| 4
499
499
|
<H1>ローマ数字</H1>
<p>
古代ローマでは数を数えることは難しい仕事でした。アラビア数字の 0,1,2,3,…, 9 はまだ流布していませんでした。その代わり次のような記号が使われていました。
</p>
<center>
<table border=1>
<tr>
<td bgcolor="#EEFFFF" width="100">アラビア数字</td><td width="100">ローマ数字</td><td bgcolor="#EEFFFF" width="100">アラビア数字</td><td width="100">ローマ数字</td><td bgcolor="#EEFFFF" width="100">アラビア数字</td><td width="100">ローマ数字</td>
</tr>
<tr><td bgcolor="#EEFFFF">1</td><td>I</td><td bgcolor="#EEFFFF">11<td>XI</td><td bgcolor="#EEFFFF">30</td><td>XXX</td><td>
<tr><td bgcolor="#EEFFFF">2</td><td>II</td><td bgcolor="#EEFFFF">12<td>XII</td><td bgcolor="#EEFFFF">40</td><td>XL</td><td>
<tr><td bgcolor="#EEFFFF">3</td><td>III</td><td bgcolor="#EEFFFF">13<td>XIII</td><td bgcolor="#EEFFFF">50</td><td>L</td><td>
<tr><td bgcolor="#EEFFFF">4</td><td>IV</td><td bgcolor="#EEFFFF">14<td>XIV</td><td bgcolor="#EEFFFF">60</td><td>LX</td><td>
<tr><td bgcolor="#EEFFFF">5</td><td>V</td><td bgcolor="#EEFFFF">15<td>XV</td><td bgcolor="#EEFFFF">70</td><td>LXX</td><td>
<tr><td bgcolor="#EEFFFF">6</td><td>VI</td><td bgcolor="#EEFFFF">16<td>XVI</td><td bgcolor="#EEFFFF">80</td><td>LXXX</td><td>
<tr><td bgcolor="#EEFFFF">7</td><td>VII</td><td bgcolor="#EEFFFF">17<td>XVII</td><td bgcolor="#EEFFFF">90</td><td>XC</td><td>
<tr><td bgcolor="#EEFFFF">8</td><td>VIII</td><td bgcolor="#EEFFFF">18<td>XVIII</td><td bgcolor="#EEFFFF">100</td><td>C</td><td>
<tr><td bgcolor="#EEFFFF">9</td><td>IX</td><td bgcolor="#EEFFFF">19<td>XIX</td><td bgcolor="#EEFFFF">500</td><td>D</td><td>
<tr><td bgcolor="#EEFFFF">10</td><td>X</td><td bgcolor="#EEFFFF">20<td>XX</td><td bgcolor="#EEFFFF">1000</td><td>M</td><td>
</table>
</center>
<br/>
<p>
I は 1、 V は 5、 X は 10、 L は 50、 C は 100、 D は 500、 M は 1000、 他の例は上の表を見てください。小さい数が大きい数に続いている、つまり右側にあるときは足し算をします。小さい数が大きい数の前に、つまり左にあるときは、大きい数から小さい数を引きます。大きい数字の前にあって引き算を表す小さな数字は一回の引き算あたりひとつしかありません。
</p>
<p>
ローマ数字をアラビア数字（通常の数字）の表記（10 進表示）に変換して出力するプログラムを作成してください。ただし、与えられるローマ数字は上記のルールにのみ従っています(実際のローマ数字の表記にはもっと細かいルールがありますが、ここでは考慮する必要はありません。たとえば、実際のローマ数字ではI はV かX から、X はL かC から、C はD かM からしか引き算しませんし、同じローマ数字は４つ以上（または５つ以上）足し並べることはありません。)
</p>
<H2>Input</H2>
<p>
複数のデータセットが与えられます。それぞれのデータセットにローマ数字（半角大文字のI, V, X, L, C, D ,M で表される連続した文字列）が１行に与えられます。与えられるローマ数字の文字列の長さはおのおの 100 以下です。
</p>
<p>
データセットの数は 50 を超えません。
</p>
<H2>Output</H2>
<p>
各データセットに対し、アラビア数字（整数）を１行に出力して下さい。
</p>
<H2>Sample Input</H2>
<pre>
IV
CCCCLXXXXVIIII
CDXCIX
</pre>
<H2>Output for the Sample Input</H2>
<pre>
4
499
499
</pre>
|
s567165831 | p00039 | Accepted | r_dict = {"I":1, "V":5, "X":10, "L":50, "C":100, "D":500, "M":1000}
while True:
try:
s = 0
b = 0
r = input()
for i in range(len(r))[::-1]:
a = r_dict[r[i]]
if b <= a:
s += a
else:
s -= a
b = a
print(s)
except:
break
| IV
CCCCLXXXXVIIII
CDXCIX
| 4
499
499
|
<H1>ローマ数字</H1>
<p>
古代ローマでは数を数えることは難しい仕事でした。アラビア数字の 0,1,2,3,…, 9 はまだ流布していませんでした。その代わり次のような記号が使われていました。
</p>
<center>
<table border=1>
<tr>
<td bgcolor="#EEFFFF" width="100">アラビア数字</td><td width="100">ローマ数字</td><td bgcolor="#EEFFFF" width="100">アラビア数字</td><td width="100">ローマ数字</td><td bgcolor="#EEFFFF" width="100">アラビア数字</td><td width="100">ローマ数字</td>
</tr>
<tr><td bgcolor="#EEFFFF">1</td><td>I</td><td bgcolor="#EEFFFF">11<td>XI</td><td bgcolor="#EEFFFF">30</td><td>XXX</td><td>
<tr><td bgcolor="#EEFFFF">2</td><td>II</td><td bgcolor="#EEFFFF">12<td>XII</td><td bgcolor="#EEFFFF">40</td><td>XL</td><td>
<tr><td bgcolor="#EEFFFF">3</td><td>III</td><td bgcolor="#EEFFFF">13<td>XIII</td><td bgcolor="#EEFFFF">50</td><td>L</td><td>
<tr><td bgcolor="#EEFFFF">4</td><td>IV</td><td bgcolor="#EEFFFF">14<td>XIV</td><td bgcolor="#EEFFFF">60</td><td>LX</td><td>
<tr><td bgcolor="#EEFFFF">5</td><td>V</td><td bgcolor="#EEFFFF">15<td>XV</td><td bgcolor="#EEFFFF">70</td><td>LXX</td><td>
<tr><td bgcolor="#EEFFFF">6</td><td>VI</td><td bgcolor="#EEFFFF">16<td>XVI</td><td bgcolor="#EEFFFF">80</td><td>LXXX</td><td>
<tr><td bgcolor="#EEFFFF">7</td><td>VII</td><td bgcolor="#EEFFFF">17<td>XVII</td><td bgcolor="#EEFFFF">90</td><td>XC</td><td>
<tr><td bgcolor="#EEFFFF">8</td><td>VIII</td><td bgcolor="#EEFFFF">18<td>XVIII</td><td bgcolor="#EEFFFF">100</td><td>C</td><td>
<tr><td bgcolor="#EEFFFF">9</td><td>IX</td><td bgcolor="#EEFFFF">19<td>XIX</td><td bgcolor="#EEFFFF">500</td><td>D</td><td>
<tr><td bgcolor="#EEFFFF">10</td><td>X</td><td bgcolor="#EEFFFF">20<td>XX</td><td bgcolor="#EEFFFF">1000</td><td>M</td><td>
</table>
</center>
<br/>
<p>
I は 1、 V は 5、 X は 10、 L は 50、 C は 100、 D は 500、 M は 1000、 他の例は上の表を見てください。小さい数が大きい数に続いている、つまり右側にあるときは足し算をします。小さい数が大きい数の前に、つまり左にあるときは、大きい数から小さい数を引きます。大きい数字の前にあって引き算を表す小さな数字は一回の引き算あたりひとつしかありません。
</p>
<p>
ローマ数字をアラビア数字（通常の数字）の表記（10 進表示）に変換して出力するプログラムを作成してください。ただし、与えられるローマ数字は上記のルールにのみ従っています(実際のローマ数字の表記にはもっと細かいルールがありますが、ここでは考慮する必要はありません。たとえば、実際のローマ数字ではI はV かX から、X はL かC から、C はD かM からしか引き算しませんし、同じローマ数字は４つ以上（または５つ以上）足し並べることはありません。)
</p>
<H2>Input</H2>
<p>
複数のデータセットが与えられます。それぞれのデータセットにローマ数字（半角大文字のI, V, X, L, C, D ,M で表される連続した文字列）が１行に与えられます。与えられるローマ数字の文字列の長さはおのおの 100 以下です。
</p>
<p>
データセットの数は 50 を超えません。
</p>
<H2>Output</H2>
<p>
各データセットに対し、アラビア数字（整数）を１行に出力して下さい。
</p>
<H2>Sample Input</H2>
<pre>
IV
CCCCLXXXXVIIII
CDXCIX
</pre>
<H2>Output for the Sample Input</H2>
<pre>
4
499
499
</pre>
|
s538299567 | p00039 | Accepted | def get_input():
while True:
try:
yield ''.join(input())
except EOFError:
break
N = list(get_input())
for l in range(len(N)):
num = N[l]
ans = 0
d = 0
d_past = 9999
for i in range(len(num)):
if num[i] == "I":
d = 1
elif num[i] == "V":
d = 5
elif num[i] == "X":
d = 10
elif num[i] == "L":
d = 50
elif num[i] == "C":
d = 100
elif num[i] == "D":
d = 500
elif num[i] == "M":
d = 1000
if d_past < d:
ans -= d_past * 2
ans += d
d_past = d
print(ans)
| IV
CCCCLXXXXVIIII
CDXCIX
| 4
499
499
|
<H1>ローマ数字</H1>
<p>
古代ローマでは数を数えることは難しい仕事でした。アラビア数字の 0,1,2,3,…, 9 はまだ流布していませんでした。その代わり次のような記号が使われていました。
</p>
<center>
<table border=1>
<tr>
<td bgcolor="#EEFFFF" width="100">アラビア数字</td><td width="100">ローマ数字</td><td bgcolor="#EEFFFF" width="100">アラビア数字</td><td width="100">ローマ数字</td><td bgcolor="#EEFFFF" width="100">アラビア数字</td><td width="100">ローマ数字</td>
</tr>
<tr><td bgcolor="#EEFFFF">1</td><td>I</td><td bgcolor="#EEFFFF">11<td>XI</td><td bgcolor="#EEFFFF">30</td><td>XXX</td><td>
<tr><td bgcolor="#EEFFFF">2</td><td>II</td><td bgcolor="#EEFFFF">12<td>XII</td><td bgcolor="#EEFFFF">40</td><td>XL</td><td>
<tr><td bgcolor="#EEFFFF">3</td><td>III</td><td bgcolor="#EEFFFF">13<td>XIII</td><td bgcolor="#EEFFFF">50</td><td>L</td><td>
<tr><td bgcolor="#EEFFFF">4</td><td>IV</td><td bgcolor="#EEFFFF">14<td>XIV</td><td bgcolor="#EEFFFF">60</td><td>LX</td><td>
<tr><td bgcolor="#EEFFFF">5</td><td>V</td><td bgcolor="#EEFFFF">15<td>XV</td><td bgcolor="#EEFFFF">70</td><td>LXX</td><td>
<tr><td bgcolor="#EEFFFF">6</td><td>VI</td><td bgcolor="#EEFFFF">16<td>XVI</td><td bgcolor="#EEFFFF">80</td><td>LXXX</td><td>
<tr><td bgcolor="#EEFFFF">7</td><td>VII</td><td bgcolor="#EEFFFF">17<td>XVII</td><td bgcolor="#EEFFFF">90</td><td>XC</td><td>
<tr><td bgcolor="#EEFFFF">8</td><td>VIII</td><td bgcolor="#EEFFFF">18<td>XVIII</td><td bgcolor="#EEFFFF">100</td><td>C</td><td>
<tr><td bgcolor="#EEFFFF">9</td><td>IX</td><td bgcolor="#EEFFFF">19<td>XIX</td><td bgcolor="#EEFFFF">500</td><td>D</td><td>
<tr><td bgcolor="#EEFFFF">10</td><td>X</td><td bgcolor="#EEFFFF">20<td>XX</td><td bgcolor="#EEFFFF">1000</td><td>M</td><td>
</table>
</center>
<br/>
<p>
I は 1、 V は 5、 X は 10、 L は 50、 C は 100、 D は 500、 M は 1000、 他の例は上の表を見てください。小さい数が大きい数に続いている、つまり右側にあるときは足し算をします。小さい数が大きい数の前に、つまり左にあるときは、大きい数から小さい数を引きます。大きい数字の前にあって引き算を表す小さな数字は一回の引き算あたりひとつしかありません。
</p>
<p>
ローマ数字をアラビア数字（通常の数字）の表記（10 進表示）に変換して出力するプログラムを作成してください。ただし、与えられるローマ数字は上記のルールにのみ従っています(実際のローマ数字の表記にはもっと細かいルールがありますが、ここでは考慮する必要はありません。たとえば、実際のローマ数字ではI はV かX から、X はL かC から、C はD かM からしか引き算しませんし、同じローマ数字は４つ以上（または５つ以上）足し並べることはありません。)
</p>
<H2>Input</H2>
<p>
複数のデータセットが与えられます。それぞれのデータセットにローマ数字（半角大文字のI, V, X, L, C, D ,M で表される連続した文字列）が１行に与えられます。与えられるローマ数字の文字列の長さはおのおの 100 以下です。
</p>
<p>
データセットの数は 50 を超えません。
</p>
<H2>Output</H2>
<p>
各データセットに対し、アラビア数字（整数）を１行に出力して下さい。
</p>
<H2>Sample Input</H2>
<pre>
IV
CCCCLXXXXVIIII
CDXCIX
</pre>
<H2>Output for the Sample Input</H2>
<pre>
4
499
499
</pre>
|
s584261524 | p00039 | Accepted | r={'I':1,'V':5,'X':10,'L':50,'C':100,'D':500,'M':1000}
import sys
for e in sys.stdin:
a=0
n=[r[c]for c in e.strip()]
for i in range(len(n)):
if i+1<len(n)and n[i]<n[i+1]:a-=n[i]
else:a+=n[i]
print(a)
| IV
CCCCLXXXXVIIII
CDXCIX
| 4
499
499
|
<H1>ローマ数字</H1>
<p>
古代ローマでは数を数えることは難しい仕事でした。アラビア数字の 0,1,2,3,…, 9 はまだ流布していませんでした。その代わり次のような記号が使われていました。
</p>
<center>
<table border=1>
<tr>
<td bgcolor="#EEFFFF" width="100">アラビア数字</td><td width="100">ローマ数字</td><td bgcolor="#EEFFFF" width="100">アラビア数字</td><td width="100">ローマ数字</td><td bgcolor="#EEFFFF" width="100">アラビア数字</td><td width="100">ローマ数字</td>
</tr>
<tr><td bgcolor="#EEFFFF">1</td><td>I</td><td bgcolor="#EEFFFF">11<td>XI</td><td bgcolor="#EEFFFF">30</td><td>XXX</td><td>
<tr><td bgcolor="#EEFFFF">2</td><td>II</td><td bgcolor="#EEFFFF">12<td>XII</td><td bgcolor="#EEFFFF">40</td><td>XL</td><td>
<tr><td bgcolor="#EEFFFF">3</td><td>III</td><td bgcolor="#EEFFFF">13<td>XIII</td><td bgcolor="#EEFFFF">50</td><td>L</td><td>
<tr><td bgcolor="#EEFFFF">4</td><td>IV</td><td bgcolor="#EEFFFF">14<td>XIV</td><td bgcolor="#EEFFFF">60</td><td>LX</td><td>
<tr><td bgcolor="#EEFFFF">5</td><td>V</td><td bgcolor="#EEFFFF">15<td>XV</td><td bgcolor="#EEFFFF">70</td><td>LXX</td><td>
<tr><td bgcolor="#EEFFFF">6</td><td>VI</td><td bgcolor="#EEFFFF">16<td>XVI</td><td bgcolor="#EEFFFF">80</td><td>LXXX</td><td>
<tr><td bgcolor="#EEFFFF">7</td><td>VII</td><td bgcolor="#EEFFFF">17<td>XVII</td><td bgcolor="#EEFFFF">90</td><td>XC</td><td>
<tr><td bgcolor="#EEFFFF">8</td><td>VIII</td><td bgcolor="#EEFFFF">18<td>XVIII</td><td bgcolor="#EEFFFF">100</td><td>C</td><td>
<tr><td bgcolor="#EEFFFF">9</td><td>IX</td><td bgcolor="#EEFFFF">19<td>XIX</td><td bgcolor="#EEFFFF">500</td><td>D</td><td>
<tr><td bgcolor="#EEFFFF">10</td><td>X</td><td bgcolor="#EEFFFF">20<td>XX</td><td bgcolor="#EEFFFF">1000</td><td>M</td><td>
</table>
</center>
<br/>
<p>
I は 1、 V は 5、 X は 10、 L は 50、 C は 100、 D は 500、 M は 1000、 他の例は上の表を見てください。小さい数が大きい数に続いている、つまり右側にあるときは足し算をします。小さい数が大きい数の前に、つまり左にあるときは、大きい数から小さい数を引きます。大きい数字の前にあって引き算を表す小さな数字は一回の引き算あたりひとつしかありません。
</p>
<p>
ローマ数字をアラビア数字（通常の数字）の表記（10 進表示）に変換して出力するプログラムを作成してください。ただし、与えられるローマ数字は上記のルールにのみ従っています(実際のローマ数字の表記にはもっと細かいルールがありますが、ここでは考慮する必要はありません。たとえば、実際のローマ数字ではI はV かX から、X はL かC から、C はD かM からしか引き算しませんし、同じローマ数字は４つ以上（または５つ以上）足し並べることはありません。)
</p>
<H2>Input</H2>
<p>
複数のデータセットが与えられます。それぞれのデータセットにローマ数字（半角大文字のI, V, X, L, C, D ,M で表される連続した文字列）が１行に与えられます。与えられるローマ数字の文字列の長さはおのおの 100 以下です。
</p>
<p>
データセットの数は 50 を超えません。
</p>
<H2>Output</H2>
<p>
各データセットに対し、アラビア数字（整数）を１行に出力して下さい。
</p>
<H2>Sample Input</H2>
<pre>
IV
CCCCLXXXXVIIII
CDXCIX
</pre>
<H2>Output for the Sample Input</H2>
<pre>
4
499
499
</pre>
|
s032785979 | p00039 | Accepted | import sys
r={'I':1,'V':5,'X':10,'L':50,'C':100,'D':500,'M':1000}
for e in sys.stdin:
a=0
n=[r[c]for c in e.strip()]
for i in range(len(n)):
if i+1<len(n)and n[i]<n[i+1]:a-=n[i]
else:a+=n[i]
print(a)
| IV
CCCCLXXXXVIIII
CDXCIX
| 4
499
499
|
<H1>ローマ数字</H1>
<p>
古代ローマでは数を数えることは難しい仕事でした。アラビア数字の 0,1,2,3,…, 9 はまだ流布していませんでした。その代わり次のような記号が使われていました。
</p>
<center>
<table border=1>
<tr>
<td bgcolor="#EEFFFF" width="100">アラビア数字</td><td width="100">ローマ数字</td><td bgcolor="#EEFFFF" width="100">アラビア数字</td><td width="100">ローマ数字</td><td bgcolor="#EEFFFF" width="100">アラビア数字</td><td width="100">ローマ数字</td>
</tr>
<tr><td bgcolor="#EEFFFF">1</td><td>I</td><td bgcolor="#EEFFFF">11<td>XI</td><td bgcolor="#EEFFFF">30</td><td>XXX</td><td>
<tr><td bgcolor="#EEFFFF">2</td><td>II</td><td bgcolor="#EEFFFF">12<td>XII</td><td bgcolor="#EEFFFF">40</td><td>XL</td><td>
<tr><td bgcolor="#EEFFFF">3</td><td>III</td><td bgcolor="#EEFFFF">13<td>XIII</td><td bgcolor="#EEFFFF">50</td><td>L</td><td>
<tr><td bgcolor="#EEFFFF">4</td><td>IV</td><td bgcolor="#EEFFFF">14<td>XIV</td><td bgcolor="#EEFFFF">60</td><td>LX</td><td>
<tr><td bgcolor="#EEFFFF">5</td><td>V</td><td bgcolor="#EEFFFF">15<td>XV</td><td bgcolor="#EEFFFF">70</td><td>LXX</td><td>
<tr><td bgcolor="#EEFFFF">6</td><td>VI</td><td bgcolor="#EEFFFF">16<td>XVI</td><td bgcolor="#EEFFFF">80</td><td>LXXX</td><td>
<tr><td bgcolor="#EEFFFF">7</td><td>VII</td><td bgcolor="#EEFFFF">17<td>XVII</td><td bgcolor="#EEFFFF">90</td><td>XC</td><td>
<tr><td bgcolor="#EEFFFF">8</td><td>VIII</td><td bgcolor="#EEFFFF">18<td>XVIII</td><td bgcolor="#EEFFFF">100</td><td>C</td><td>
<tr><td bgcolor="#EEFFFF">9</td><td>IX</td><td bgcolor="#EEFFFF">19<td>XIX</td><td bgcolor="#EEFFFF">500</td><td>D</td><td>
<tr><td bgcolor="#EEFFFF">10</td><td>X</td><td bgcolor="#EEFFFF">20<td>XX</td><td bgcolor="#EEFFFF">1000</td><td>M</td><td>
</table>
</center>
<br/>
<p>
I は 1、 V は 5、 X は 10、 L は 50、 C は 100、 D は 500、 M は 1000、 他の例は上の表を見てください。小さい数が大きい数に続いている、つまり右側にあるときは足し算をします。小さい数が大きい数の前に、つまり左にあるときは、大きい数から小さい数を引きます。大きい数字の前にあって引き算を表す小さな数字は一回の引き算あたりひとつしかありません。
</p>
<p>
ローマ数字をアラビア数字（通常の数字）の表記（10 進表示）に変換して出力するプログラムを作成してください。ただし、与えられるローマ数字は上記のルールにのみ従っています(実際のローマ数字の表記にはもっと細かいルールがありますが、ここでは考慮する必要はありません。たとえば、実際のローマ数字ではI はV かX から、X はL かC から、C はD かM からしか引き算しませんし、同じローマ数字は４つ以上（または５つ以上）足し並べることはありません。)
</p>
<H2>Input</H2>
<p>
複数のデータセットが与えられます。それぞれのデータセットにローマ数字（半角大文字のI, V, X, L, C, D ,M で表される連続した文字列）が１行に与えられます。与えられるローマ数字の文字列の長さはおのおの 100 以下です。
</p>
<p>
データセットの数は 50 を超えません。
</p>
<H2>Output</H2>
<p>
各データセットに対し、アラビア数字（整数）を１行に出力して下さい。
</p>
<H2>Sample Input</H2>
<pre>
IV
CCCCLXXXXVIIII
CDXCIX
</pre>
<H2>Output for the Sample Input</H2>
<pre>
4
499
499
</pre>
|
s077979497 | p00039 | Accepted | import sys
r={'I':1,'V':5,'X':10,'L':50,'C':100,'D':500,'M':1000}
for e in sys.stdin:
n=[r[c]for c in e.strip()]
print(sum(n[i]*[1,-1][i+1<len(n)and n[i]<n[i+1]]for i in range(len(n))))
| IV
CCCCLXXXXVIIII
CDXCIX
| 4
499
499
|
<H1>ローマ数字</H1>
<p>
古代ローマでは数を数えることは難しい仕事でした。アラビア数字の 0,1,2,3,…, 9 はまだ流布していませんでした。その代わり次のような記号が使われていました。
</p>
<center>
<table border=1>
<tr>
<td bgcolor="#EEFFFF" width="100">アラビア数字</td><td width="100">ローマ数字</td><td bgcolor="#EEFFFF" width="100">アラビア数字</td><td width="100">ローマ数字</td><td bgcolor="#EEFFFF" width="100">アラビア数字</td><td width="100">ローマ数字</td>
</tr>
<tr><td bgcolor="#EEFFFF">1</td><td>I</td><td bgcolor="#EEFFFF">11<td>XI</td><td bgcolor="#EEFFFF">30</td><td>XXX</td><td>
<tr><td bgcolor="#EEFFFF">2</td><td>II</td><td bgcolor="#EEFFFF">12<td>XII</td><td bgcolor="#EEFFFF">40</td><td>XL</td><td>
<tr><td bgcolor="#EEFFFF">3</td><td>III</td><td bgcolor="#EEFFFF">13<td>XIII</td><td bgcolor="#EEFFFF">50</td><td>L</td><td>
<tr><td bgcolor="#EEFFFF">4</td><td>IV</td><td bgcolor="#EEFFFF">14<td>XIV</td><td bgcolor="#EEFFFF">60</td><td>LX</td><td>
<tr><td bgcolor="#EEFFFF">5</td><td>V</td><td bgcolor="#EEFFFF">15<td>XV</td><td bgcolor="#EEFFFF">70</td><td>LXX</td><td>
<tr><td bgcolor="#EEFFFF">6</td><td>VI</td><td bgcolor="#EEFFFF">16<td>XVI</td><td bgcolor="#EEFFFF">80</td><td>LXXX</td><td>
<tr><td bgcolor="#EEFFFF">7</td><td>VII</td><td bgcolor="#EEFFFF">17<td>XVII</td><td bgcolor="#EEFFFF">90</td><td>XC</td><td>
<tr><td bgcolor="#EEFFFF">8</td><td>VIII</td><td bgcolor="#EEFFFF">18<td>XVIII</td><td bgcolor="#EEFFFF">100</td><td>C</td><td>
<tr><td bgcolor="#EEFFFF">9</td><td>IX</td><td bgcolor="#EEFFFF">19<td>XIX</td><td bgcolor="#EEFFFF">500</td><td>D</td><td>
<tr><td bgcolor="#EEFFFF">10</td><td>X</td><td bgcolor="#EEFFFF">20<td>XX</td><td bgcolor="#EEFFFF">1000</td><td>M</td><td>
</table>
</center>
<br/>
<p>
I は 1、 V は 5、 X は 10、 L は 50、 C は 100、 D は 500、 M は 1000、 他の例は上の表を見てください。小さい数が大きい数に続いている、つまり右側にあるときは足し算をします。小さい数が大きい数の前に、つまり左にあるときは、大きい数から小さい数を引きます。大きい数字の前にあって引き算を表す小さな数字は一回の引き算あたりひとつしかありません。
</p>
<p>
ローマ数字をアラビア数字（通常の数字）の表記（10 進表示）に変換して出力するプログラムを作成してください。ただし、与えられるローマ数字は上記のルールにのみ従っています(実際のローマ数字の表記にはもっと細かいルールがありますが、ここでは考慮する必要はありません。たとえば、実際のローマ数字ではI はV かX から、X はL かC から、C はD かM からしか引き算しませんし、同じローマ数字は４つ以上（または５つ以上）足し並べることはありません。)
</p>
<H2>Input</H2>
<p>
複数のデータセットが与えられます。それぞれのデータセットにローマ数字（半角大文字のI, V, X, L, C, D ,M で表される連続した文字列）が１行に与えられます。与えられるローマ数字の文字列の長さはおのおの 100 以下です。
</p>
<p>
データセットの数は 50 を超えません。
</p>
<H2>Output</H2>
<p>
各データセットに対し、アラビア数字（整数）を１行に出力して下さい。
</p>
<H2>Sample Input</H2>
<pre>
IV
CCCCLXXXXVIIII
CDXCIX
</pre>
<H2>Output for the Sample Input</H2>
<pre>
4
499
499
</pre>
|
s204262753 | p00039 | Accepted | import sys
r={'I':1,'V':5,'X':10,'L':50,'C':100,'D':500,'M':1000}
for e in sys.stdin:
n=[r[c]for c in e[:-1]]
print(sum(n[i]*[1,-1][i+1<len(n)and n[i]<n[i+1]]for i in range(len(n))))
| IV
CCCCLXXXXVIIII
CDXCIX
| 4
499
499
|
<H1>ローマ数字</H1>
<p>
古代ローマでは数を数えることは難しい仕事でした。アラビア数字の 0,1,2,3,…, 9 はまだ流布していませんでした。その代わり次のような記号が使われていました。
</p>
<center>
<table border=1>
<tr>
<td bgcolor="#EEFFFF" width="100">アラビア数字</td><td width="100">ローマ数字</td><td bgcolor="#EEFFFF" width="100">アラビア数字</td><td width="100">ローマ数字</td><td bgcolor="#EEFFFF" width="100">アラビア数字</td><td width="100">ローマ数字</td>
</tr>
<tr><td bgcolor="#EEFFFF">1</td><td>I</td><td bgcolor="#EEFFFF">11<td>XI</td><td bgcolor="#EEFFFF">30</td><td>XXX</td><td>
<tr><td bgcolor="#EEFFFF">2</td><td>II</td><td bgcolor="#EEFFFF">12<td>XII</td><td bgcolor="#EEFFFF">40</td><td>XL</td><td>
<tr><td bgcolor="#EEFFFF">3</td><td>III</td><td bgcolor="#EEFFFF">13<td>XIII</td><td bgcolor="#EEFFFF">50</td><td>L</td><td>
<tr><td bgcolor="#EEFFFF">4</td><td>IV</td><td bgcolor="#EEFFFF">14<td>XIV</td><td bgcolor="#EEFFFF">60</td><td>LX</td><td>
<tr><td bgcolor="#EEFFFF">5</td><td>V</td><td bgcolor="#EEFFFF">15<td>XV</td><td bgcolor="#EEFFFF">70</td><td>LXX</td><td>
<tr><td bgcolor="#EEFFFF">6</td><td>VI</td><td bgcolor="#EEFFFF">16<td>XVI</td><td bgcolor="#EEFFFF">80</td><td>LXXX</td><td>
<tr><td bgcolor="#EEFFFF">7</td><td>VII</td><td bgcolor="#EEFFFF">17<td>XVII</td><td bgcolor="#EEFFFF">90</td><td>XC</td><td>
<tr><td bgcolor="#EEFFFF">8</td><td>VIII</td><td bgcolor="#EEFFFF">18<td>XVIII</td><td bgcolor="#EEFFFF">100</td><td>C</td><td>
<tr><td bgcolor="#EEFFFF">9</td><td>IX</td><td bgcolor="#EEFFFF">19<td>XIX</td><td bgcolor="#EEFFFF">500</td><td>D</td><td>
<tr><td bgcolor="#EEFFFF">10</td><td>X</td><td bgcolor="#EEFFFF">20<td>XX</td><td bgcolor="#EEFFFF">1000</td><td>M</td><td>
</table>
</center>
<br/>
<p>
I は 1、 V は 5、 X は 10、 L は 50、 C は 100、 D は 500、 M は 1000、 他の例は上の表を見てください。小さい数が大きい数に続いている、つまり右側にあるときは足し算をします。小さい数が大きい数の前に、つまり左にあるときは、大きい数から小さい数を引きます。大きい数字の前にあって引き算を表す小さな数字は一回の引き算あたりひとつしかありません。
</p>
<p>
ローマ数字をアラビア数字（通常の数字）の表記（10 進表示）に変換して出力するプログラムを作成してください。ただし、与えられるローマ数字は上記のルールにのみ従っています(実際のローマ数字の表記にはもっと細かいルールがありますが、ここでは考慮する必要はありません。たとえば、実際のローマ数字ではI はV かX から、X はL かC から、C はD かM からしか引き算しませんし、同じローマ数字は４つ以上（または５つ以上）足し並べることはありません。)
</p>
<H2>Input</H2>
<p>
複数のデータセットが与えられます。それぞれのデータセットにローマ数字（半角大文字のI, V, X, L, C, D ,M で表される連続した文字列）が１行に与えられます。与えられるローマ数字の文字列の長さはおのおの 100 以下です。
</p>
<p>
データセットの数は 50 を超えません。
</p>
<H2>Output</H2>
<p>
各データセットに対し、アラビア数字（整数）を１行に出力して下さい。
</p>
<H2>Sample Input</H2>
<pre>
IV
CCCCLXXXXVIIII
CDXCIX
</pre>
<H2>Output for the Sample Input</H2>
<pre>
4
499
499
</pre>
|
s196861400 | p00039 | Accepted | dic = {"I":1, "V":5, "X":10, "L":50, "C":100 ,"D":500,"M":1000}
while True:
try:
line = [dic[i] for i in input()]
acc = 0
for i in range(len(line) - 1):
if line[i] < line[i + 1]:
acc -= line[i]
else:
acc += line[i]
acc += line[-1]
print(acc)
except EOFError:
break
| IV
CCCCLXXXXVIIII
CDXCIX
| 4
499
499
|
<H1>ローマ数字</H1>
<p>
古代ローマでは数を数えることは難しい仕事でした。アラビア数字の 0,1,2,3,…, 9 はまだ流布していませんでした。その代わり次のような記号が使われていました。
</p>
<center>
<table border=1>
<tr>
<td bgcolor="#EEFFFF" width="100">アラビア数字</td><td width="100">ローマ数字</td><td bgcolor="#EEFFFF" width="100">アラビア数字</td><td width="100">ローマ数字</td><td bgcolor="#EEFFFF" width="100">アラビア数字</td><td width="100">ローマ数字</td>
</tr>
<tr><td bgcolor="#EEFFFF">1</td><td>I</td><td bgcolor="#EEFFFF">11<td>XI</td><td bgcolor="#EEFFFF">30</td><td>XXX</td><td>
<tr><td bgcolor="#EEFFFF">2</td><td>II</td><td bgcolor="#EEFFFF">12<td>XII</td><td bgcolor="#EEFFFF">40</td><td>XL</td><td>
<tr><td bgcolor="#EEFFFF">3</td><td>III</td><td bgcolor="#EEFFFF">13<td>XIII</td><td bgcolor="#EEFFFF">50</td><td>L</td><td>
<tr><td bgcolor="#EEFFFF">4</td><td>IV</td><td bgcolor="#EEFFFF">14<td>XIV</td><td bgcolor="#EEFFFF">60</td><td>LX</td><td>
<tr><td bgcolor="#EEFFFF">5</td><td>V</td><td bgcolor="#EEFFFF">15<td>XV</td><td bgcolor="#EEFFFF">70</td><td>LXX</td><td>
<tr><td bgcolor="#EEFFFF">6</td><td>VI</td><td bgcolor="#EEFFFF">16<td>XVI</td><td bgcolor="#EEFFFF">80</td><td>LXXX</td><td>
<tr><td bgcolor="#EEFFFF">7</td><td>VII</td><td bgcolor="#EEFFFF">17<td>XVII</td><td bgcolor="#EEFFFF">90</td><td>XC</td><td>
<tr><td bgcolor="#EEFFFF">8</td><td>VIII</td><td bgcolor="#EEFFFF">18<td>XVIII</td><td bgcolor="#EEFFFF">100</td><td>C</td><td>
<tr><td bgcolor="#EEFFFF">9</td><td>IX</td><td bgcolor="#EEFFFF">19<td>XIX</td><td bgcolor="#EEFFFF">500</td><td>D</td><td>
<tr><td bgcolor="#EEFFFF">10</td><td>X</td><td bgcolor="#EEFFFF">20<td>XX</td><td bgcolor="#EEFFFF">1000</td><td>M</td><td>
</table>
</center>
<br/>
<p>
I は 1、 V は 5、 X は 10、 L は 50、 C は 100、 D は 500、 M は 1000、 他の例は上の表を見てください。小さい数が大きい数に続いている、つまり右側にあるときは足し算をします。小さい数が大きい数の前に、つまり左にあるときは、大きい数から小さい数を引きます。大きい数字の前にあって引き算を表す小さな数字は一回の引き算あたりひとつしかありません。
</p>
<p>
ローマ数字をアラビア数字（通常の数字）の表記（10 進表示）に変換して出力するプログラムを作成してください。ただし、与えられるローマ数字は上記のルールにのみ従っています(実際のローマ数字の表記にはもっと細かいルールがありますが、ここでは考慮する必要はありません。たとえば、実際のローマ数字ではI はV かX から、X はL かC から、C はD かM からしか引き算しませんし、同じローマ数字は４つ以上（または５つ以上）足し並べることはありません。)
</p>
<H2>Input</H2>
<p>
複数のデータセットが与えられます。それぞれのデータセットにローマ数字（半角大文字のI, V, X, L, C, D ,M で表される連続した文字列）が１行に与えられます。与えられるローマ数字の文字列の長さはおのおの 100 以下です。
</p>
<p>
データセットの数は 50 を超えません。
</p>
<H2>Output</H2>
<p>
各データセットに対し、アラビア数字（整数）を１行に出力して下さい。
</p>
<H2>Sample Input</H2>
<pre>
IV
CCCCLXXXXVIIII
CDXCIX
</pre>
<H2>Output for the Sample Input</H2>
<pre>
4
499
499
</pre>
|
s987702421 | p00039 | Accepted | import sys
r_d={"I":1,"V":5,"X":10,"L":50,"C":100,"D":500,"M":1000}
res=[]
for s in sys.stdin:
l=[r_d[i] for i in s.strip()]
m=[l[i] if l[i]>=l[i+1] else -l[i] for i in range(len(l)-1)]
m.extend([l[-1]])
res.extend([sum(m)])
[print(i) for i in res]
| IV
CCCCLXXXXVIIII
CDXCIX
| 4
499
499
|
<H1>ローマ数字</H1>
<p>
古代ローマでは数を数えることは難しい仕事でした。アラビア数字の 0,1,2,3,…, 9 はまだ流布していませんでした。その代わり次のような記号が使われていました。
</p>
<center>
<table border=1>
<tr>
<td bgcolor="#EEFFFF" width="100">アラビア数字</td><td width="100">ローマ数字</td><td bgcolor="#EEFFFF" width="100">アラビア数字</td><td width="100">ローマ数字</td><td bgcolor="#EEFFFF" width="100">アラビア数字</td><td width="100">ローマ数字</td>
</tr>
<tr><td bgcolor="#EEFFFF">1</td><td>I</td><td bgcolor="#EEFFFF">11<td>XI</td><td bgcolor="#EEFFFF">30</td><td>XXX</td><td>
<tr><td bgcolor="#EEFFFF">2</td><td>II</td><td bgcolor="#EEFFFF">12<td>XII</td><td bgcolor="#EEFFFF">40</td><td>XL</td><td>
<tr><td bgcolor="#EEFFFF">3</td><td>III</td><td bgcolor="#EEFFFF">13<td>XIII</td><td bgcolor="#EEFFFF">50</td><td>L</td><td>
<tr><td bgcolor="#EEFFFF">4</td><td>IV</td><td bgcolor="#EEFFFF">14<td>XIV</td><td bgcolor="#EEFFFF">60</td><td>LX</td><td>
<tr><td bgcolor="#EEFFFF">5</td><td>V</td><td bgcolor="#EEFFFF">15<td>XV</td><td bgcolor="#EEFFFF">70</td><td>LXX</td><td>
<tr><td bgcolor="#EEFFFF">6</td><td>VI</td><td bgcolor="#EEFFFF">16<td>XVI</td><td bgcolor="#EEFFFF">80</td><td>LXXX</td><td>
<tr><td bgcolor="#EEFFFF">7</td><td>VII</td><td bgcolor="#EEFFFF">17<td>XVII</td><td bgcolor="#EEFFFF">90</td><td>XC</td><td>
<tr><td bgcolor="#EEFFFF">8</td><td>VIII</td><td bgcolor="#EEFFFF">18<td>XVIII</td><td bgcolor="#EEFFFF">100</td><td>C</td><td>
<tr><td bgcolor="#EEFFFF">9</td><td>IX</td><td bgcolor="#EEFFFF">19<td>XIX</td><td bgcolor="#EEFFFF">500</td><td>D</td><td>
<tr><td bgcolor="#EEFFFF">10</td><td>X</td><td bgcolor="#EEFFFF">20<td>XX</td><td bgcolor="#EEFFFF">1000</td><td>M</td><td>
</table>
</center>
<br/>
<p>
I は 1、 V は 5、 X は 10、 L は 50、 C は 100、 D は 500、 M は 1000、 他の例は上の表を見てください。小さい数が大きい数に続いている、つまり右側にあるときは足し算をします。小さい数が大きい数の前に、つまり左にあるときは、大きい数から小さい数を引きます。大きい数字の前にあって引き算を表す小さな数字は一回の引き算あたりひとつしかありません。
</p>
<p>
ローマ数字をアラビア数字（通常の数字）の表記（10 進表示）に変換して出力するプログラムを作成してください。ただし、与えられるローマ数字は上記のルールにのみ従っています(実際のローマ数字の表記にはもっと細かいルールがありますが、ここでは考慮する必要はありません。たとえば、実際のローマ数字ではI はV かX から、X はL かC から、C はD かM からしか引き算しませんし、同じローマ数字は４つ以上（または５つ以上）足し並べることはありません。)
</p>
<H2>Input</H2>
<p>
複数のデータセットが与えられます。それぞれのデータセットにローマ数字（半角大文字のI, V, X, L, C, D ,M で表される連続した文字列）が１行に与えられます。与えられるローマ数字の文字列の長さはおのおの 100 以下です。
</p>
<p>
データセットの数は 50 を超えません。
</p>
<H2>Output</H2>
<p>
各データセットに対し、アラビア数字（整数）を１行に出力して下さい。
</p>
<H2>Sample Input</H2>
<pre>
IV
CCCCLXXXXVIIII
CDXCIX
</pre>
<H2>Output for the Sample Input</H2>
<pre>
4
499
499
</pre>
|
s845567398 | p00039 | Accepted | # AOJ 0039 Roman Figure
# Python3 2018.6.15 bal4u
roman = {'I':1, 'V':5, 'X':10, 'L':50, 'C':100, 'D':500, 'M': 1000}
while True:
try:
p = list(input())
except EOFError:
break
ans = i = 0
while i < len(p):
if i+1 < len(p) and roman[p[i]] < roman[p[i+1]]:
ans += roman[p[i+1]] - roman[p[i]]
i += 1
else: ans += roman[p[i]]
i += 1
print(ans)
| IV
CCCCLXXXXVIIII
CDXCIX
| 4
499
499
|
<H1>ローマ数字</H1>
<p>
古代ローマでは数を数えることは難しい仕事でした。アラビア数字の 0,1,2,3,…, 9 はまだ流布していませんでした。その代わり次のような記号が使われていました。
</p>
<center>
<table border=1>
<tr>
<td bgcolor="#EEFFFF" width="100">アラビア数字</td><td width="100">ローマ数字</td><td bgcolor="#EEFFFF" width="100">アラビア数字</td><td width="100">ローマ数字</td><td bgcolor="#EEFFFF" width="100">アラビア数字</td><td width="100">ローマ数字</td>
</tr>
<tr><td bgcolor="#EEFFFF">1</td><td>I</td><td bgcolor="#EEFFFF">11<td>XI</td><td bgcolor="#EEFFFF">30</td><td>XXX</td><td>
<tr><td bgcolor="#EEFFFF">2</td><td>II</td><td bgcolor="#EEFFFF">12<td>XII</td><td bgcolor="#EEFFFF">40</td><td>XL</td><td>
<tr><td bgcolor="#EEFFFF">3</td><td>III</td><td bgcolor="#EEFFFF">13<td>XIII</td><td bgcolor="#EEFFFF">50</td><td>L</td><td>
<tr><td bgcolor="#EEFFFF">4</td><td>IV</td><td bgcolor="#EEFFFF">14<td>XIV</td><td bgcolor="#EEFFFF">60</td><td>LX</td><td>
<tr><td bgcolor="#EEFFFF">5</td><td>V</td><td bgcolor="#EEFFFF">15<td>XV</td><td bgcolor="#EEFFFF">70</td><td>LXX</td><td>
<tr><td bgcolor="#EEFFFF">6</td><td>VI</td><td bgcolor="#EEFFFF">16<td>XVI</td><td bgcolor="#EEFFFF">80</td><td>LXXX</td><td>
<tr><td bgcolor="#EEFFFF">7</td><td>VII</td><td bgcolor="#EEFFFF">17<td>XVII</td><td bgcolor="#EEFFFF">90</td><td>XC</td><td>
<tr><td bgcolor="#EEFFFF">8</td><td>VIII</td><td bgcolor="#EEFFFF">18<td>XVIII</td><td bgcolor="#EEFFFF">100</td><td>C</td><td>
<tr><td bgcolor="#EEFFFF">9</td><td>IX</td><td bgcolor="#EEFFFF">19<td>XIX</td><td bgcolor="#EEFFFF">500</td><td>D</td><td>
<tr><td bgcolor="#EEFFFF">10</td><td>X</td><td bgcolor="#EEFFFF">20<td>XX</td><td bgcolor="#EEFFFF">1000</td><td>M</td><td>
</table>
</center>
<br/>
<p>
I は 1、 V は 5、 X は 10、 L は 50、 C は 100、 D は 500、 M は 1000、 他の例は上の表を見てください。小さい数が大きい数に続いている、つまり右側にあるときは足し算をします。小さい数が大きい数の前に、つまり左にあるときは、大きい数から小さい数を引きます。大きい数字の前にあって引き算を表す小さな数字は一回の引き算あたりひとつしかありません。
</p>
<p>
ローマ数字をアラビア数字（通常の数字）の表記（10 進表示）に変換して出力するプログラムを作成してください。ただし、与えられるローマ数字は上記のルールにのみ従っています(実際のローマ数字の表記にはもっと細かいルールがありますが、ここでは考慮する必要はありません。たとえば、実際のローマ数字ではI はV かX から、X はL かC から、C はD かM からしか引き算しませんし、同じローマ数字は４つ以上（または５つ以上）足し並べることはありません。)
</p>
<H2>Input</H2>
<p>
複数のデータセットが与えられます。それぞれのデータセットにローマ数字（半角大文字のI, V, X, L, C, D ,M で表される連続した文字列）が１行に与えられます。与えられるローマ数字の文字列の長さはおのおの 100 以下です。
</p>
<p>
データセットの数は 50 を超えません。
</p>
<H2>Output</H2>
<p>
各データセットに対し、アラビア数字（整数）を１行に出力して下さい。
</p>
<H2>Sample Input</H2>
<pre>
IV
CCCCLXXXXVIIII
CDXCIX
</pre>
<H2>Output for the Sample Input</H2>
<pre>
4
499
499
</pre>
|
s585620520 | p00039 | Accepted | table = {"I": 1, "V": 5, "X": 10, "L": 50, "C": 100, "D": 500, "M": 1000}
try:
while True:
a = [table[c] for c in input()] + [0]
result = 0
for n1, n2 in zip(a, a[1:]):
result += n1 if n1 >= n2 else -n1
print(result)
except EOFError:
exit()
| IV
CCCCLXXXXVIIII
CDXCIX
| 4
499
499
|
<H1>ローマ数字</H1>
<p>
古代ローマでは数を数えることは難しい仕事でした。アラビア数字の 0,1,2,3,…, 9 はまだ流布していませんでした。その代わり次のような記号が使われていました。
</p>
<center>
<table border=1>
<tr>
<td bgcolor="#EEFFFF" width="100">アラビア数字</td><td width="100">ローマ数字</td><td bgcolor="#EEFFFF" width="100">アラビア数字</td><td width="100">ローマ数字</td><td bgcolor="#EEFFFF" width="100">アラビア数字</td><td width="100">ローマ数字</td>
</tr>
<tr><td bgcolor="#EEFFFF">1</td><td>I</td><td bgcolor="#EEFFFF">11<td>XI</td><td bgcolor="#EEFFFF">30</td><td>XXX</td><td>
<tr><td bgcolor="#EEFFFF">2</td><td>II</td><td bgcolor="#EEFFFF">12<td>XII</td><td bgcolor="#EEFFFF">40</td><td>XL</td><td>
<tr><td bgcolor="#EEFFFF">3</td><td>III</td><td bgcolor="#EEFFFF">13<td>XIII</td><td bgcolor="#EEFFFF">50</td><td>L</td><td>
<tr><td bgcolor="#EEFFFF">4</td><td>IV</td><td bgcolor="#EEFFFF">14<td>XIV</td><td bgcolor="#EEFFFF">60</td><td>LX</td><td>
<tr><td bgcolor="#EEFFFF">5</td><td>V</td><td bgcolor="#EEFFFF">15<td>XV</td><td bgcolor="#EEFFFF">70</td><td>LXX</td><td>
<tr><td bgcolor="#EEFFFF">6</td><td>VI</td><td bgcolor="#EEFFFF">16<td>XVI</td><td bgcolor="#EEFFFF">80</td><td>LXXX</td><td>
<tr><td bgcolor="#EEFFFF">7</td><td>VII</td><td bgcolor="#EEFFFF">17<td>XVII</td><td bgcolor="#EEFFFF">90</td><td>XC</td><td>
<tr><td bgcolor="#EEFFFF">8</td><td>VIII</td><td bgcolor="#EEFFFF">18<td>XVIII</td><td bgcolor="#EEFFFF">100</td><td>C</td><td>
<tr><td bgcolor="#EEFFFF">9</td><td>IX</td><td bgcolor="#EEFFFF">19<td>XIX</td><td bgcolor="#EEFFFF">500</td><td>D</td><td>
<tr><td bgcolor="#EEFFFF">10</td><td>X</td><td bgcolor="#EEFFFF">20<td>XX</td><td bgcolor="#EEFFFF">1000</td><td>M</td><td>
</table>
</center>
<br/>
<p>
I は 1、 V は 5、 X は 10、 L は 50、 C は 100、 D は 500、 M は 1000、 他の例は上の表を見てください。小さい数が大きい数に続いている、つまり右側にあるときは足し算をします。小さい数が大きい数の前に、つまり左にあるときは、大きい数から小さい数を引きます。大きい数字の前にあって引き算を表す小さな数字は一回の引き算あたりひとつしかありません。
</p>
<p>
ローマ数字をアラビア数字（通常の数字）の表記（10 進表示）に変換して出力するプログラムを作成してください。ただし、与えられるローマ数字は上記のルールにのみ従っています(実際のローマ数字の表記にはもっと細かいルールがありますが、ここでは考慮する必要はありません。たとえば、実際のローマ数字ではI はV かX から、X はL かC から、C はD かM からしか引き算しませんし、同じローマ数字は４つ以上（または５つ以上）足し並べることはありません。)
</p>
<H2>Input</H2>
<p>
複数のデータセットが与えられます。それぞれのデータセットにローマ数字（半角大文字のI, V, X, L, C, D ,M で表される連続した文字列）が１行に与えられます。与えられるローマ数字の文字列の長さはおのおの 100 以下です。
</p>
<p>
データセットの数は 50 を超えません。
</p>
<H2>Output</H2>
<p>
各データセットに対し、アラビア数字（整数）を１行に出力して下さい。
</p>
<H2>Sample Input</H2>
<pre>
IV
CCCCLXXXXVIIII
CDXCIX
</pre>
<H2>Output for the Sample Input</H2>
<pre>
4
499
499
</pre>
|
s877583394 | p00039 | Accepted | #!/usr/bin/env python
# coding: utf-8
import sys
def parseRomanNumber(roman):
roman_dict = {
"I": 1,
"V": 5,
"X": 10,
"L": 50,
"C": 100,
"D": 500,
"M": 1000}
numbers = [0]
roman = roman.replace("\n", "")
for i in [roman_dict[c] for c in roman[::-1]]:
if i >= numbers[-1]:
numbers.append(i)
else:
numbers.append(i * -1)
return sum(numbers)
def main():
romans = sys.stdin.readlines()
for roman in romans:
print parseRomanNumber(roman)
if __name__ == '__main__':
main() | IV
CCCCLXXXXVIIII
CDXCIX
| 4
499
499
|
<H1>ローマ数字</H1>
<p>
古代ローマでは数を数えることは難しい仕事でした。アラビア数字の 0,1,2,3,…, 9 はまだ流布していませんでした。その代わり次のような記号が使われていました。
</p>
<center>
<table border=1>
<tr>
<td bgcolor="#EEFFFF" width="100">アラビア数字</td><td width="100">ローマ数字</td><td bgcolor="#EEFFFF" width="100">アラビア数字</td><td width="100">ローマ数字</td><td bgcolor="#EEFFFF" width="100">アラビア数字</td><td width="100">ローマ数字</td>
</tr>
<tr><td bgcolor="#EEFFFF">1</td><td>I</td><td bgcolor="#EEFFFF">11<td>XI</td><td bgcolor="#EEFFFF">30</td><td>XXX</td><td>
<tr><td bgcolor="#EEFFFF">2</td><td>II</td><td bgcolor="#EEFFFF">12<td>XII</td><td bgcolor="#EEFFFF">40</td><td>XL</td><td>
<tr><td bgcolor="#EEFFFF">3</td><td>III</td><td bgcolor="#EEFFFF">13<td>XIII</td><td bgcolor="#EEFFFF">50</td><td>L</td><td>
<tr><td bgcolor="#EEFFFF">4</td><td>IV</td><td bgcolor="#EEFFFF">14<td>XIV</td><td bgcolor="#EEFFFF">60</td><td>LX</td><td>
<tr><td bgcolor="#EEFFFF">5</td><td>V</td><td bgcolor="#EEFFFF">15<td>XV</td><td bgcolor="#EEFFFF">70</td><td>LXX</td><td>
<tr><td bgcolor="#EEFFFF">6</td><td>VI</td><td bgcolor="#EEFFFF">16<td>XVI</td><td bgcolor="#EEFFFF">80</td><td>LXXX</td><td>
<tr><td bgcolor="#EEFFFF">7</td><td>VII</td><td bgcolor="#EEFFFF">17<td>XVII</td><td bgcolor="#EEFFFF">90</td><td>XC</td><td>
<tr><td bgcolor="#EEFFFF">8</td><td>VIII</td><td bgcolor="#EEFFFF">18<td>XVIII</td><td bgcolor="#EEFFFF">100</td><td>C</td><td>
<tr><td bgcolor="#EEFFFF">9</td><td>IX</td><td bgcolor="#EEFFFF">19<td>XIX</td><td bgcolor="#EEFFFF">500</td><td>D</td><td>
<tr><td bgcolor="#EEFFFF">10</td><td>X</td><td bgcolor="#EEFFFF">20<td>XX</td><td bgcolor="#EEFFFF">1000</td><td>M</td><td>
</table>
</center>
<br/>
<p>
I は 1、 V は 5、 X は 10、 L は 50、 C は 100、 D は 500、 M は 1000、 他の例は上の表を見てください。小さい数が大きい数に続いている、つまり右側にあるときは足し算をします。小さい数が大きい数の前に、つまり左にあるときは、大きい数から小さい数を引きます。大きい数字の前にあって引き算を表す小さな数字は一回の引き算あたりひとつしかありません。
</p>
<p>
ローマ数字をアラビア数字（通常の数字）の表記（10 進表示）に変換して出力するプログラムを作成してください。ただし、与えられるローマ数字は上記のルールにのみ従っています(実際のローマ数字の表記にはもっと細かいルールがありますが、ここでは考慮する必要はありません。たとえば、実際のローマ数字ではI はV かX から、X はL かC から、C はD かM からしか引き算しませんし、同じローマ数字は４つ以上（または５つ以上）足し並べることはありません。)
</p>
<H2>Input</H2>
<p>
複数のデータセットが与えられます。それぞれのデータセットにローマ数字（半角大文字のI, V, X, L, C, D ,M で表される連続した文字列）が１行に与えられます。与えられるローマ数字の文字列の長さはおのおの 100 以下です。
</p>
<p>
データセットの数は 50 を超えません。
</p>
<H2>Output</H2>
<p>
各データセットに対し、アラビア数字（整数）を１行に出力して下さい。
</p>
<H2>Sample Input</H2>
<pre>
IV
CCCCLXXXXVIIII
CDXCIX
</pre>
<H2>Output for the Sample Input</H2>
<pre>
4
499
499
</pre>
|
s457279901 | p00039 | Accepted | import sys
dic={"I":1,"V":5,"X":10,"L":50,"C":100,"D":500,"M":1000}
for line in sys.stdin.readlines():
total,temp,left=0,0,line[0]
for roman in line:
if left==roman:
temp+=dic[roman]
else:
if roman=="\n":
total+=temp
break
if dic[left]>dic[roman]:
total+=temp
else:
total-=temp
left=roman
temp=dic[roman]
print total | IV
CCCCLXXXXVIIII
CDXCIX
| 4
499
499
|
<H1>ローマ数字</H1>
<p>
古代ローマでは数を数えることは難しい仕事でした。アラビア数字の 0,1,2,3,…, 9 はまだ流布していませんでした。その代わり次のような記号が使われていました。
</p>
<center>
<table border=1>
<tr>
<td bgcolor="#EEFFFF" width="100">アラビア数字</td><td width="100">ローマ数字</td><td bgcolor="#EEFFFF" width="100">アラビア数字</td><td width="100">ローマ数字</td><td bgcolor="#EEFFFF" width="100">アラビア数字</td><td width="100">ローマ数字</td>
</tr>
<tr><td bgcolor="#EEFFFF">1</td><td>I</td><td bgcolor="#EEFFFF">11<td>XI</td><td bgcolor="#EEFFFF">30</td><td>XXX</td><td>
<tr><td bgcolor="#EEFFFF">2</td><td>II</td><td bgcolor="#EEFFFF">12<td>XII</td><td bgcolor="#EEFFFF">40</td><td>XL</td><td>
<tr><td bgcolor="#EEFFFF">3</td><td>III</td><td bgcolor="#EEFFFF">13<td>XIII</td><td bgcolor="#EEFFFF">50</td><td>L</td><td>
<tr><td bgcolor="#EEFFFF">4</td><td>IV</td><td bgcolor="#EEFFFF">14<td>XIV</td><td bgcolor="#EEFFFF">60</td><td>LX</td><td>
<tr><td bgcolor="#EEFFFF">5</td><td>V</td><td bgcolor="#EEFFFF">15<td>XV</td><td bgcolor="#EEFFFF">70</td><td>LXX</td><td>
<tr><td bgcolor="#EEFFFF">6</td><td>VI</td><td bgcolor="#EEFFFF">16<td>XVI</td><td bgcolor="#EEFFFF">80</td><td>LXXX</td><td>
<tr><td bgcolor="#EEFFFF">7</td><td>VII</td><td bgcolor="#EEFFFF">17<td>XVII</td><td bgcolor="#EEFFFF">90</td><td>XC</td><td>
<tr><td bgcolor="#EEFFFF">8</td><td>VIII</td><td bgcolor="#EEFFFF">18<td>XVIII</td><td bgcolor="#EEFFFF">100</td><td>C</td><td>
<tr><td bgcolor="#EEFFFF">9</td><td>IX</td><td bgcolor="#EEFFFF">19<td>XIX</td><td bgcolor="#EEFFFF">500</td><td>D</td><td>
<tr><td bgcolor="#EEFFFF">10</td><td>X</td><td bgcolor="#EEFFFF">20<td>XX</td><td bgcolor="#EEFFFF">1000</td><td>M</td><td>
</table>
</center>
<br/>
<p>
I は 1、 V は 5、 X は 10、 L は 50、 C は 100、 D は 500、 M は 1000、 他の例は上の表を見てください。小さい数が大きい数に続いている、つまり右側にあるときは足し算をします。小さい数が大きい数の前に、つまり左にあるときは、大きい数から小さい数を引きます。大きい数字の前にあって引き算を表す小さな数字は一回の引き算あたりひとつしかありません。
</p>
<p>
ローマ数字をアラビア数字（通常の数字）の表記（10 進表示）に変換して出力するプログラムを作成してください。ただし、与えられるローマ数字は上記のルールにのみ従っています(実際のローマ数字の表記にはもっと細かいルールがありますが、ここでは考慮する必要はありません。たとえば、実際のローマ数字ではI はV かX から、X はL かC から、C はD かM からしか引き算しませんし、同じローマ数字は４つ以上（または５つ以上）足し並べることはありません。)
</p>
<H2>Input</H2>
<p>
複数のデータセットが与えられます。それぞれのデータセットにローマ数字（半角大文字のI, V, X, L, C, D ,M で表される連続した文字列）が１行に与えられます。与えられるローマ数字の文字列の長さはおのおの 100 以下です。
</p>
<p>
データセットの数は 50 を超えません。
</p>
<H2>Output</H2>
<p>
各データセットに対し、アラビア数字（整数）を１行に出力して下さい。
</p>
<H2>Sample Input</H2>
<pre>
IV
CCCCLXXXXVIIII
CDXCIX
</pre>
<H2>Output for the Sample Input</H2>
<pre>
4
499
499
</pre>
|
s733515619 | p00039 | Accepted | rule = {'I': 1, 'V': 5, 'X': 10, 'L': 50, 'C': 100, 'D': 500, 'M': 1000}
while True:
try:
line = raw_input()
nums = [rule[c] for c in list(line)] + [0]
print sum(map(
lambda (a, b): -a if a < b else a,
[(a, b) for a, b in [nums[i:i+2] for i in range(len(line))]]))
except EOFError:
break | IV
CCCCLXXXXVIIII
CDXCIX
| 4
499
499
|
<H1>ローマ数字</H1>
<p>
古代ローマでは数を数えることは難しい仕事でした。アラビア数字の 0,1,2,3,…, 9 はまだ流布していませんでした。その代わり次のような記号が使われていました。
</p>
<center>
<table border=1>
<tr>
<td bgcolor="#EEFFFF" width="100">アラビア数字</td><td width="100">ローマ数字</td><td bgcolor="#EEFFFF" width="100">アラビア数字</td><td width="100">ローマ数字</td><td bgcolor="#EEFFFF" width="100">アラビア数字</td><td width="100">ローマ数字</td>
</tr>
<tr><td bgcolor="#EEFFFF">1</td><td>I</td><td bgcolor="#EEFFFF">11<td>XI</td><td bgcolor="#EEFFFF">30</td><td>XXX</td><td>
<tr><td bgcolor="#EEFFFF">2</td><td>II</td><td bgcolor="#EEFFFF">12<td>XII</td><td bgcolor="#EEFFFF">40</td><td>XL</td><td>
<tr><td bgcolor="#EEFFFF">3</td><td>III</td><td bgcolor="#EEFFFF">13<td>XIII</td><td bgcolor="#EEFFFF">50</td><td>L</td><td>
<tr><td bgcolor="#EEFFFF">4</td><td>IV</td><td bgcolor="#EEFFFF">14<td>XIV</td><td bgcolor="#EEFFFF">60</td><td>LX</td><td>
<tr><td bgcolor="#EEFFFF">5</td><td>V</td><td bgcolor="#EEFFFF">15<td>XV</td><td bgcolor="#EEFFFF">70</td><td>LXX</td><td>
<tr><td bgcolor="#EEFFFF">6</td><td>VI</td><td bgcolor="#EEFFFF">16<td>XVI</td><td bgcolor="#EEFFFF">80</td><td>LXXX</td><td>
<tr><td bgcolor="#EEFFFF">7</td><td>VII</td><td bgcolor="#EEFFFF">17<td>XVII</td><td bgcolor="#EEFFFF">90</td><td>XC</td><td>
<tr><td bgcolor="#EEFFFF">8</td><td>VIII</td><td bgcolor="#EEFFFF">18<td>XVIII</td><td bgcolor="#EEFFFF">100</td><td>C</td><td>
<tr><td bgcolor="#EEFFFF">9</td><td>IX</td><td bgcolor="#EEFFFF">19<td>XIX</td><td bgcolor="#EEFFFF">500</td><td>D</td><td>
<tr><td bgcolor="#EEFFFF">10</td><td>X</td><td bgcolor="#EEFFFF">20<td>XX</td><td bgcolor="#EEFFFF">1000</td><td>M</td><td>
</table>
</center>
<br/>
<p>
I は 1、 V は 5、 X は 10、 L は 50、 C は 100、 D は 500、 M は 1000、 他の例は上の表を見てください。小さい数が大きい数に続いている、つまり右側にあるときは足し算をします。小さい数が大きい数の前に、つまり左にあるときは、大きい数から小さい数を引きます。大きい数字の前にあって引き算を表す小さな数字は一回の引き算あたりひとつしかありません。
</p>
<p>
ローマ数字をアラビア数字（通常の数字）の表記（10 進表示）に変換して出力するプログラムを作成してください。ただし、与えられるローマ数字は上記のルールにのみ従っています(実際のローマ数字の表記にはもっと細かいルールがありますが、ここでは考慮する必要はありません。たとえば、実際のローマ数字ではI はV かX から、X はL かC から、C はD かM からしか引き算しませんし、同じローマ数字は４つ以上（または５つ以上）足し並べることはありません。)
</p>
<H2>Input</H2>
<p>
複数のデータセットが与えられます。それぞれのデータセットにローマ数字（半角大文字のI, V, X, L, C, D ,M で表される連続した文字列）が１行に与えられます。与えられるローマ数字の文字列の長さはおのおの 100 以下です。
</p>
<p>
データセットの数は 50 を超えません。
</p>
<H2>Output</H2>
<p>
各データセットに対し、アラビア数字（整数）を１行に出力して下さい。
</p>
<H2>Sample Input</H2>
<pre>
IV
CCCCLXXXXVIIII
CDXCIX
</pre>
<H2>Output for the Sample Input</H2>
<pre>
4
499
499
</pre>
|
s332538580 | p00039 | Accepted | d={"I":1,"V":5,"X":10,"L":50,"C":100,"D":500,"M":1000}
while True:
try:
s=[d[i] for i in raw_input()]
except EOFError:
break
i,m=0,0
while i<len(s)-1:
if s[i]<s[i+1]:
m+=s[i+1]-s[i]
s[i],s[i+1]=0,0
i+=2
else:
i+=1
print sum(s)+m | IV
CCCCLXXXXVIIII
CDXCIX
| 4
499
499
|
<H1>ローマ数字</H1>
<p>
古代ローマでは数を数えることは難しい仕事でした。アラビア数字の 0,1,2,3,…, 9 はまだ流布していませんでした。その代わり次のような記号が使われていました。
</p>
<center>
<table border=1>
<tr>
<td bgcolor="#EEFFFF" width="100">アラビア数字</td><td width="100">ローマ数字</td><td bgcolor="#EEFFFF" width="100">アラビア数字</td><td width="100">ローマ数字</td><td bgcolor="#EEFFFF" width="100">アラビア数字</td><td width="100">ローマ数字</td>
</tr>
<tr><td bgcolor="#EEFFFF">1</td><td>I</td><td bgcolor="#EEFFFF">11<td>XI</td><td bgcolor="#EEFFFF">30</td><td>XXX</td><td>
<tr><td bgcolor="#EEFFFF">2</td><td>II</td><td bgcolor="#EEFFFF">12<td>XII</td><td bgcolor="#EEFFFF">40</td><td>XL</td><td>
<tr><td bgcolor="#EEFFFF">3</td><td>III</td><td bgcolor="#EEFFFF">13<td>XIII</td><td bgcolor="#EEFFFF">50</td><td>L</td><td>
<tr><td bgcolor="#EEFFFF">4</td><td>IV</td><td bgcolor="#EEFFFF">14<td>XIV</td><td bgcolor="#EEFFFF">60</td><td>LX</td><td>
<tr><td bgcolor="#EEFFFF">5</td><td>V</td><td bgcolor="#EEFFFF">15<td>XV</td><td bgcolor="#EEFFFF">70</td><td>LXX</td><td>
<tr><td bgcolor="#EEFFFF">6</td><td>VI</td><td bgcolor="#EEFFFF">16<td>XVI</td><td bgcolor="#EEFFFF">80</td><td>LXXX</td><td>
<tr><td bgcolor="#EEFFFF">7</td><td>VII</td><td bgcolor="#EEFFFF">17<td>XVII</td><td bgcolor="#EEFFFF">90</td><td>XC</td><td>
<tr><td bgcolor="#EEFFFF">8</td><td>VIII</td><td bgcolor="#EEFFFF">18<td>XVIII</td><td bgcolor="#EEFFFF">100</td><td>C</td><td>
<tr><td bgcolor="#EEFFFF">9</td><td>IX</td><td bgcolor="#EEFFFF">19<td>XIX</td><td bgcolor="#EEFFFF">500</td><td>D</td><td>
<tr><td bgcolor="#EEFFFF">10</td><td>X</td><td bgcolor="#EEFFFF">20<td>XX</td><td bgcolor="#EEFFFF">1000</td><td>M</td><td>
</table>
</center>
<br/>
<p>
I は 1、 V は 5、 X は 10、 L は 50、 C は 100、 D は 500、 M は 1000、 他の例は上の表を見てください。小さい数が大きい数に続いている、つまり右側にあるときは足し算をします。小さい数が大きい数の前に、つまり左にあるときは、大きい数から小さい数を引きます。大きい数字の前にあって引き算を表す小さな数字は一回の引き算あたりひとつしかありません。
</p>
<p>
ローマ数字をアラビア数字（通常の数字）の表記（10 進表示）に変換して出力するプログラムを作成してください。ただし、与えられるローマ数字は上記のルールにのみ従っています(実際のローマ数字の表記にはもっと細かいルールがありますが、ここでは考慮する必要はありません。たとえば、実際のローマ数字ではI はV かX から、X はL かC から、C はD かM からしか引き算しませんし、同じローマ数字は４つ以上（または５つ以上）足し並べることはありません。)
</p>
<H2>Input</H2>
<p>
複数のデータセットが与えられます。それぞれのデータセットにローマ数字（半角大文字のI, V, X, L, C, D ,M で表される連続した文字列）が１行に与えられます。与えられるローマ数字の文字列の長さはおのおの 100 以下です。
</p>
<p>
データセットの数は 50 を超えません。
</p>
<H2>Output</H2>
<p>
各データセットに対し、アラビア数字（整数）を１行に出力して下さい。
</p>
<H2>Sample Input</H2>
<pre>
IV
CCCCLXXXXVIIII
CDXCIX
</pre>
<H2>Output for the Sample Input</H2>
<pre>
4
499
499
</pre>
|
s934989944 | p00039 | Accepted |
import sys
def solv(roman):
a = map(lambda x: roman_to_arabic(x), roman)
arabic = reduce(roman_count, a, (0,0))[0]
return arabic
def roman_to_arabic(s):
tbl = {'I': 1, 'V': 5, 'X': 10, 'L': 50, 'C': 100, 'D': 500, 'M': 1000}
return tbl[s]
def roman_count(acc, y):
x = acc[1]
if x < y:
a = acc[0] + y - 2 * x
else:
a = acc[0] + y
return (a, y)
for line in sys.stdin:
roman = line.rstrip("\n")
print solv(roman) | IV
CCCCLXXXXVIIII
CDXCIX
| 4
499
499
|
<H1>ローマ数字</H1>
<p>
古代ローマでは数を数えることは難しい仕事でした。アラビア数字の 0,1,2,3,…, 9 はまだ流布していませんでした。その代わり次のような記号が使われていました。
</p>
<center>
<table border=1>
<tr>
<td bgcolor="#EEFFFF" width="100">アラビア数字</td><td width="100">ローマ数字</td><td bgcolor="#EEFFFF" width="100">アラビア数字</td><td width="100">ローマ数字</td><td bgcolor="#EEFFFF" width="100">アラビア数字</td><td width="100">ローマ数字</td>
</tr>
<tr><td bgcolor="#EEFFFF">1</td><td>I</td><td bgcolor="#EEFFFF">11<td>XI</td><td bgcolor="#EEFFFF">30</td><td>XXX</td><td>
<tr><td bgcolor="#EEFFFF">2</td><td>II</td><td bgcolor="#EEFFFF">12<td>XII</td><td bgcolor="#EEFFFF">40</td><td>XL</td><td>
<tr><td bgcolor="#EEFFFF">3</td><td>III</td><td bgcolor="#EEFFFF">13<td>XIII</td><td bgcolor="#EEFFFF">50</td><td>L</td><td>
<tr><td bgcolor="#EEFFFF">4</td><td>IV</td><td bgcolor="#EEFFFF">14<td>XIV</td><td bgcolor="#EEFFFF">60</td><td>LX</td><td>
<tr><td bgcolor="#EEFFFF">5</td><td>V</td><td bgcolor="#EEFFFF">15<td>XV</td><td bgcolor="#EEFFFF">70</td><td>LXX</td><td>
<tr><td bgcolor="#EEFFFF">6</td><td>VI</td><td bgcolor="#EEFFFF">16<td>XVI</td><td bgcolor="#EEFFFF">80</td><td>LXXX</td><td>
<tr><td bgcolor="#EEFFFF">7</td><td>VII</td><td bgcolor="#EEFFFF">17<td>XVII</td><td bgcolor="#EEFFFF">90</td><td>XC</td><td>
<tr><td bgcolor="#EEFFFF">8</td><td>VIII</td><td bgcolor="#EEFFFF">18<td>XVIII</td><td bgcolor="#EEFFFF">100</td><td>C</td><td>
<tr><td bgcolor="#EEFFFF">9</td><td>IX</td><td bgcolor="#EEFFFF">19<td>XIX</td><td bgcolor="#EEFFFF">500</td><td>D</td><td>
<tr><td bgcolor="#EEFFFF">10</td><td>X</td><td bgcolor="#EEFFFF">20<td>XX</td><td bgcolor="#EEFFFF">1000</td><td>M</td><td>
</table>
</center>
<br/>
<p>
I は 1、 V は 5、 X は 10、 L は 50、 C は 100、 D は 500、 M は 1000、 他の例は上の表を見てください。小さい数が大きい数に続いている、つまり右側にあるときは足し算をします。小さい数が大きい数の前に、つまり左にあるときは、大きい数から小さい数を引きます。大きい数字の前にあって引き算を表す小さな数字は一回の引き算あたりひとつしかありません。
</p>
<p>
ローマ数字をアラビア数字（通常の数字）の表記（10 進表示）に変換して出力するプログラムを作成してください。ただし、与えられるローマ数字は上記のルールにのみ従っています(実際のローマ数字の表記にはもっと細かいルールがありますが、ここでは考慮する必要はありません。たとえば、実際のローマ数字ではI はV かX から、X はL かC から、C はD かM からしか引き算しませんし、同じローマ数字は４つ以上（または５つ以上）足し並べることはありません。)
</p>
<H2>Input</H2>
<p>
複数のデータセットが与えられます。それぞれのデータセットにローマ数字（半角大文字のI, V, X, L, C, D ,M で表される連続した文字列）が１行に与えられます。与えられるローマ数字の文字列の長さはおのおの 100 以下です。
</p>
<p>
データセットの数は 50 を超えません。
</p>
<H2>Output</H2>
<p>
各データセットに対し、アラビア数字（整数）を１行に出力して下さい。
</p>
<H2>Sample Input</H2>
<pre>
IV
CCCCLXXXXVIIII
CDXCIX
</pre>
<H2>Output for the Sample Input</H2>
<pre>
4
499
499
</pre>
|
s002432525 | p00039 | Accepted | #!/usr/bin/env python
# -*- coding: utf-8 -*-
from __future__ import (division, absolute_import, print_function,
unicode_literals)
from sys import stdin
from re import findall
FIGURE = {'I': 1, 'V': 5, 'X': 10, 'L': 50, 'C': 100, 'D': 500, 'M': 1000}
for line in stdin:
vs = [FIGURE[s[0]] * len(s) for s in findall('(\w)\1*', line)]
value = 0
while vs:
buf = vs.pop(0)
if vs and buf < vs[0]:
value -= buf
else:
value += buf
print(value) | IV
CCCCLXXXXVIIII
CDXCIX
| 4
499
499
|
<H1>ローマ数字</H1>
<p>
古代ローマでは数を数えることは難しい仕事でした。アラビア数字の 0,1,2,3,…, 9 はまだ流布していませんでした。その代わり次のような記号が使われていました。
</p>
<center>
<table border=1>
<tr>
<td bgcolor="#EEFFFF" width="100">アラビア数字</td><td width="100">ローマ数字</td><td bgcolor="#EEFFFF" width="100">アラビア数字</td><td width="100">ローマ数字</td><td bgcolor="#EEFFFF" width="100">アラビア数字</td><td width="100">ローマ数字</td>
</tr>
<tr><td bgcolor="#EEFFFF">1</td><td>I</td><td bgcolor="#EEFFFF">11<td>XI</td><td bgcolor="#EEFFFF">30</td><td>XXX</td><td>
<tr><td bgcolor="#EEFFFF">2</td><td>II</td><td bgcolor="#EEFFFF">12<td>XII</td><td bgcolor="#EEFFFF">40</td><td>XL</td><td>
<tr><td bgcolor="#EEFFFF">3</td><td>III</td><td bgcolor="#EEFFFF">13<td>XIII</td><td bgcolor="#EEFFFF">50</td><td>L</td><td>
<tr><td bgcolor="#EEFFFF">4</td><td>IV</td><td bgcolor="#EEFFFF">14<td>XIV</td><td bgcolor="#EEFFFF">60</td><td>LX</td><td>
<tr><td bgcolor="#EEFFFF">5</td><td>V</td><td bgcolor="#EEFFFF">15<td>XV</td><td bgcolor="#EEFFFF">70</td><td>LXX</td><td>
<tr><td bgcolor="#EEFFFF">6</td><td>VI</td><td bgcolor="#EEFFFF">16<td>XVI</td><td bgcolor="#EEFFFF">80</td><td>LXXX</td><td>
<tr><td bgcolor="#EEFFFF">7</td><td>VII</td><td bgcolor="#EEFFFF">17<td>XVII</td><td bgcolor="#EEFFFF">90</td><td>XC</td><td>
<tr><td bgcolor="#EEFFFF">8</td><td>VIII</td><td bgcolor="#EEFFFF">18<td>XVIII</td><td bgcolor="#EEFFFF">100</td><td>C</td><td>
<tr><td bgcolor="#EEFFFF">9</td><td>IX</td><td bgcolor="#EEFFFF">19<td>XIX</td><td bgcolor="#EEFFFF">500</td><td>D</td><td>
<tr><td bgcolor="#EEFFFF">10</td><td>X</td><td bgcolor="#EEFFFF">20<td>XX</td><td bgcolor="#EEFFFF">1000</td><td>M</td><td>
</table>
</center>
<br/>
<p>
I は 1、 V は 5、 X は 10、 L は 50、 C は 100、 D は 500、 M は 1000、 他の例は上の表を見てください。小さい数が大きい数に続いている、つまり右側にあるときは足し算をします。小さい数が大きい数の前に、つまり左にあるときは、大きい数から小さい数を引きます。大きい数字の前にあって引き算を表す小さな数字は一回の引き算あたりひとつしかありません。
</p>
<p>
ローマ数字をアラビア数字（通常の数字）の表記（10 進表示）に変換して出力するプログラムを作成してください。ただし、与えられるローマ数字は上記のルールにのみ従っています(実際のローマ数字の表記にはもっと細かいルールがありますが、ここでは考慮する必要はありません。たとえば、実際のローマ数字ではI はV かX から、X はL かC から、C はD かM からしか引き算しませんし、同じローマ数字は４つ以上（または５つ以上）足し並べることはありません。)
</p>
<H2>Input</H2>
<p>
複数のデータセットが与えられます。それぞれのデータセットにローマ数字（半角大文字のI, V, X, L, C, D ,M で表される連続した文字列）が１行に与えられます。与えられるローマ数字の文字列の長さはおのおの 100 以下です。
</p>
<p>
データセットの数は 50 を超えません。
</p>
<H2>Output</H2>
<p>
各データセットに対し、アラビア数字（整数）を１行に出力して下さい。
</p>
<H2>Sample Input</H2>
<pre>
IV
CCCCLXXXXVIIII
CDXCIX
</pre>
<H2>Output for the Sample Input</H2>
<pre>
4
499
499
</pre>
|
s336971764 | p00039 | Accepted | import sys
d = {'I':1,'V':5,'X':10,'L':50,'C':100,'D':500,'M':1000}
for s in sys.stdin.read().rstrip().split('\n'):
r = 0
for i in range(len(s)):
r += d[s[i]]
if i > 0 and (d[s[i]] > d[s[i-1]]):
r -= d[s[i-1]]*2
print r | IV
CCCCLXXXXVIIII
CDXCIX
| 4
499
499
|
<H1>ローマ数字</H1>
<p>
古代ローマでは数を数えることは難しい仕事でした。アラビア数字の 0,1,2,3,…, 9 はまだ流布していませんでした。その代わり次のような記号が使われていました。
</p>
<center>
<table border=1>
<tr>
<td bgcolor="#EEFFFF" width="100">アラビア数字</td><td width="100">ローマ数字</td><td bgcolor="#EEFFFF" width="100">アラビア数字</td><td width="100">ローマ数字</td><td bgcolor="#EEFFFF" width="100">アラビア数字</td><td width="100">ローマ数字</td>
</tr>
<tr><td bgcolor="#EEFFFF">1</td><td>I</td><td bgcolor="#EEFFFF">11<td>XI</td><td bgcolor="#EEFFFF">30</td><td>XXX</td><td>
<tr><td bgcolor="#EEFFFF">2</td><td>II</td><td bgcolor="#EEFFFF">12<td>XII</td><td bgcolor="#EEFFFF">40</td><td>XL</td><td>
<tr><td bgcolor="#EEFFFF">3</td><td>III</td><td bgcolor="#EEFFFF">13<td>XIII</td><td bgcolor="#EEFFFF">50</td><td>L</td><td>
<tr><td bgcolor="#EEFFFF">4</td><td>IV</td><td bgcolor="#EEFFFF">14<td>XIV</td><td bgcolor="#EEFFFF">60</td><td>LX</td><td>
<tr><td bgcolor="#EEFFFF">5</td><td>V</td><td bgcolor="#EEFFFF">15<td>XV</td><td bgcolor="#EEFFFF">70</td><td>LXX</td><td>
<tr><td bgcolor="#EEFFFF">6</td><td>VI</td><td bgcolor="#EEFFFF">16<td>XVI</td><td bgcolor="#EEFFFF">80</td><td>LXXX</td><td>
<tr><td bgcolor="#EEFFFF">7</td><td>VII</td><td bgcolor="#EEFFFF">17<td>XVII</td><td bgcolor="#EEFFFF">90</td><td>XC</td><td>
<tr><td bgcolor="#EEFFFF">8</td><td>VIII</td><td bgcolor="#EEFFFF">18<td>XVIII</td><td bgcolor="#EEFFFF">100</td><td>C</td><td>
<tr><td bgcolor="#EEFFFF">9</td><td>IX</td><td bgcolor="#EEFFFF">19<td>XIX</td><td bgcolor="#EEFFFF">500</td><td>D</td><td>
<tr><td bgcolor="#EEFFFF">10</td><td>X</td><td bgcolor="#EEFFFF">20<td>XX</td><td bgcolor="#EEFFFF">1000</td><td>M</td><td>
</table>
</center>
<br/>
<p>
I は 1、 V は 5、 X は 10、 L は 50、 C は 100、 D は 500、 M は 1000、 他の例は上の表を見てください。小さい数が大きい数に続いている、つまり右側にあるときは足し算をします。小さい数が大きい数の前に、つまり左にあるときは、大きい数から小さい数を引きます。大きい数字の前にあって引き算を表す小さな数字は一回の引き算あたりひとつしかありません。
</p>
<p>
ローマ数字をアラビア数字（通常の数字）の表記（10 進表示）に変換して出力するプログラムを作成してください。ただし、与えられるローマ数字は上記のルールにのみ従っています(実際のローマ数字の表記にはもっと細かいルールがありますが、ここでは考慮する必要はありません。たとえば、実際のローマ数字ではI はV かX から、X はL かC から、C はD かM からしか引き算しませんし、同じローマ数字は４つ以上（または５つ以上）足し並べることはありません。)
</p>
<H2>Input</H2>
<p>
複数のデータセットが与えられます。それぞれのデータセットにローマ数字（半角大文字のI, V, X, L, C, D ,M で表される連続した文字列）が１行に与えられます。与えられるローマ数字の文字列の長さはおのおの 100 以下です。
</p>
<p>
データセットの数は 50 を超えません。
</p>
<H2>Output</H2>
<p>
各データセットに対し、アラビア数字（整数）を１行に出力して下さい。
</p>
<H2>Sample Input</H2>
<pre>
IV
CCCCLXXXXVIIII
CDXCIX
</pre>
<H2>Output for the Sample Input</H2>
<pre>
4
499
499
</pre>
|
s902275461 | p00039 | Accepted | roman={"I":1, "V":5, "X":10, "L":50, "C":100, "D":500, "M":1000}
try:
while True:
x=[]
line = raw_input()
tmp = roman[line[0]]
x.append(tmp)
for c in line[1:]:
tmp = roman[c]
if x[-1]<tmp: x[-1] = -x[-1]
x.append(tmp)
print sum(x)
except:
pass | IV
CCCCLXXXXVIIII
CDXCIX
| 4
499
499
|
<H1>ローマ数字</H1>
<p>
古代ローマでは数を数えることは難しい仕事でした。アラビア数字の 0,1,2,3,…, 9 はまだ流布していませんでした。その代わり次のような記号が使われていました。
</p>
<center>
<table border=1>
<tr>
<td bgcolor="#EEFFFF" width="100">アラビア数字</td><td width="100">ローマ数字</td><td bgcolor="#EEFFFF" width="100">アラビア数字</td><td width="100">ローマ数字</td><td bgcolor="#EEFFFF" width="100">アラビア数字</td><td width="100">ローマ数字</td>
</tr>
<tr><td bgcolor="#EEFFFF">1</td><td>I</td><td bgcolor="#EEFFFF">11<td>XI</td><td bgcolor="#EEFFFF">30</td><td>XXX</td><td>
<tr><td bgcolor="#EEFFFF">2</td><td>II</td><td bgcolor="#EEFFFF">12<td>XII</td><td bgcolor="#EEFFFF">40</td><td>XL</td><td>
<tr><td bgcolor="#EEFFFF">3</td><td>III</td><td bgcolor="#EEFFFF">13<td>XIII</td><td bgcolor="#EEFFFF">50</td><td>L</td><td>
<tr><td bgcolor="#EEFFFF">4</td><td>IV</td><td bgcolor="#EEFFFF">14<td>XIV</td><td bgcolor="#EEFFFF">60</td><td>LX</td><td>
<tr><td bgcolor="#EEFFFF">5</td><td>V</td><td bgcolor="#EEFFFF">15<td>XV</td><td bgcolor="#EEFFFF">70</td><td>LXX</td><td>
<tr><td bgcolor="#EEFFFF">6</td><td>VI</td><td bgcolor="#EEFFFF">16<td>XVI</td><td bgcolor="#EEFFFF">80</td><td>LXXX</td><td>
<tr><td bgcolor="#EEFFFF">7</td><td>VII</td><td bgcolor="#EEFFFF">17<td>XVII</td><td bgcolor="#EEFFFF">90</td><td>XC</td><td>
<tr><td bgcolor="#EEFFFF">8</td><td>VIII</td><td bgcolor="#EEFFFF">18<td>XVIII</td><td bgcolor="#EEFFFF">100</td><td>C</td><td>
<tr><td bgcolor="#EEFFFF">9</td><td>IX</td><td bgcolor="#EEFFFF">19<td>XIX</td><td bgcolor="#EEFFFF">500</td><td>D</td><td>
<tr><td bgcolor="#EEFFFF">10</td><td>X</td><td bgcolor="#EEFFFF">20<td>XX</td><td bgcolor="#EEFFFF">1000</td><td>M</td><td>
</table>
</center>
<br/>
<p>
I は 1、 V は 5、 X は 10、 L は 50、 C は 100、 D は 500、 M は 1000、 他の例は上の表を見てください。小さい数が大きい数に続いている、つまり右側にあるときは足し算をします。小さい数が大きい数の前に、つまり左にあるときは、大きい数から小さい数を引きます。大きい数字の前にあって引き算を表す小さな数字は一回の引き算あたりひとつしかありません。
</p>
<p>
ローマ数字をアラビア数字（通常の数字）の表記（10 進表示）に変換して出力するプログラムを作成してください。ただし、与えられるローマ数字は上記のルールにのみ従っています(実際のローマ数字の表記にはもっと細かいルールがありますが、ここでは考慮する必要はありません。たとえば、実際のローマ数字ではI はV かX から、X はL かC から、C はD かM からしか引き算しませんし、同じローマ数字は４つ以上（または５つ以上）足し並べることはありません。)
</p>
<H2>Input</H2>
<p>
複数のデータセットが与えられます。それぞれのデータセットにローマ数字（半角大文字のI, V, X, L, C, D ,M で表される連続した文字列）が１行に与えられます。与えられるローマ数字の文字列の長さはおのおの 100 以下です。
</p>
<p>
データセットの数は 50 を超えません。
</p>
<H2>Output</H2>
<p>
各データセットに対し、アラビア数字（整数）を１行に出力して下さい。
</p>
<H2>Sample Input</H2>
<pre>
IV
CCCCLXXXXVIIII
CDXCIX
</pre>
<H2>Output for the Sample Input</H2>
<pre>
4
499
499
</pre>
|
s451312231 | p00039 | Accepted | R = dict(zip("IVXLCDM",[1,5,10,50,100,500,1000]))
while 1:
try:
ans = 0; n = 0;
s = raw_input();
for i in xrange(len(s)-1):
n += R[s[i]]
if R[s[i]]<R[s[i+1]]:
ans -= n; n = 0;
elif R[s[i]]>R[s[i+1]]:
ans += n; n = 0;
ans += n + R[s[len(s)-1]]
print ans
except EOFError:
break | IV
CCCCLXXXXVIIII
CDXCIX
| 4
499
499
|
<H1>ローマ数字</H1>
<p>
古代ローマでは数を数えることは難しい仕事でした。アラビア数字の 0,1,2,3,…, 9 はまだ流布していませんでした。その代わり次のような記号が使われていました。
</p>
<center>
<table border=1>
<tr>
<td bgcolor="#EEFFFF" width="100">アラビア数字</td><td width="100">ローマ数字</td><td bgcolor="#EEFFFF" width="100">アラビア数字</td><td width="100">ローマ数字</td><td bgcolor="#EEFFFF" width="100">アラビア数字</td><td width="100">ローマ数字</td>
</tr>
<tr><td bgcolor="#EEFFFF">1</td><td>I</td><td bgcolor="#EEFFFF">11<td>XI</td><td bgcolor="#EEFFFF">30</td><td>XXX</td><td>
<tr><td bgcolor="#EEFFFF">2</td><td>II</td><td bgcolor="#EEFFFF">12<td>XII</td><td bgcolor="#EEFFFF">40</td><td>XL</td><td>
<tr><td bgcolor="#EEFFFF">3</td><td>III</td><td bgcolor="#EEFFFF">13<td>XIII</td><td bgcolor="#EEFFFF">50</td><td>L</td><td>
<tr><td bgcolor="#EEFFFF">4</td><td>IV</td><td bgcolor="#EEFFFF">14<td>XIV</td><td bgcolor="#EEFFFF">60</td><td>LX</td><td>
<tr><td bgcolor="#EEFFFF">5</td><td>V</td><td bgcolor="#EEFFFF">15<td>XV</td><td bgcolor="#EEFFFF">70</td><td>LXX</td><td>
<tr><td bgcolor="#EEFFFF">6</td><td>VI</td><td bgcolor="#EEFFFF">16<td>XVI</td><td bgcolor="#EEFFFF">80</td><td>LXXX</td><td>
<tr><td bgcolor="#EEFFFF">7</td><td>VII</td><td bgcolor="#EEFFFF">17<td>XVII</td><td bgcolor="#EEFFFF">90</td><td>XC</td><td>
<tr><td bgcolor="#EEFFFF">8</td><td>VIII</td><td bgcolor="#EEFFFF">18<td>XVIII</td><td bgcolor="#EEFFFF">100</td><td>C</td><td>
<tr><td bgcolor="#EEFFFF">9</td><td>IX</td><td bgcolor="#EEFFFF">19<td>XIX</td><td bgcolor="#EEFFFF">500</td><td>D</td><td>
<tr><td bgcolor="#EEFFFF">10</td><td>X</td><td bgcolor="#EEFFFF">20<td>XX</td><td bgcolor="#EEFFFF">1000</td><td>M</td><td>
</table>
</center>
<br/>
<p>
I は 1、 V は 5、 X は 10、 L は 50、 C は 100、 D は 500、 M は 1000、 他の例は上の表を見てください。小さい数が大きい数に続いている、つまり右側にあるときは足し算をします。小さい数が大きい数の前に、つまり左にあるときは、大きい数から小さい数を引きます。大きい数字の前にあって引き算を表す小さな数字は一回の引き算あたりひとつしかありません。
</p>
<p>
ローマ数字をアラビア数字（通常の数字）の表記（10 進表示）に変換して出力するプログラムを作成してください。ただし、与えられるローマ数字は上記のルールにのみ従っています(実際のローマ数字の表記にはもっと細かいルールがありますが、ここでは考慮する必要はありません。たとえば、実際のローマ数字ではI はV かX から、X はL かC から、C はD かM からしか引き算しませんし、同じローマ数字は４つ以上（または５つ以上）足し並べることはありません。)
</p>
<H2>Input</H2>
<p>
複数のデータセットが与えられます。それぞれのデータセットにローマ数字（半角大文字のI, V, X, L, C, D ,M で表される連続した文字列）が１行に与えられます。与えられるローマ数字の文字列の長さはおのおの 100 以下です。
</p>
<p>
データセットの数は 50 を超えません。
</p>
<H2>Output</H2>
<p>
各データセットに対し、アラビア数字（整数）を１行に出力して下さい。
</p>
<H2>Sample Input</H2>
<pre>
IV
CCCCLXXXXVIIII
CDXCIX
</pre>
<H2>Output for the Sample Input</H2>
<pre>
4
499
499
</pre>
|
s274513462 | p00039 | Accepted | #!/usr/bin/python
#compat with both Py2/Py3
import sys
if sys.version_info[0]>=3: raw_input=input
def main(roman):
m={'I':1,'V':5,'X':10,'L':50,'C':100,'D':500,'M':1000}
r=0
for i in range(len(roman)):
r+=m[roman[i]]*(1 if i==len(roman)-1 or m[roman[i]]>=m[roman[i+1]] else -1)
print(str(r))
if __name__=='__main__':
try:
while True:
main(raw_input().rstrip())
except EOFError:
pass | IV
CCCCLXXXXVIIII
CDXCIX
| 4
499
499
|
<H1>ローマ数字</H1>
<p>
古代ローマでは数を数えることは難しい仕事でした。アラビア数字の 0,1,2,3,…, 9 はまだ流布していませんでした。その代わり次のような記号が使われていました。
</p>
<center>
<table border=1>
<tr>
<td bgcolor="#EEFFFF" width="100">アラビア数字</td><td width="100">ローマ数字</td><td bgcolor="#EEFFFF" width="100">アラビア数字</td><td width="100">ローマ数字</td><td bgcolor="#EEFFFF" width="100">アラビア数字</td><td width="100">ローマ数字</td>
</tr>
<tr><td bgcolor="#EEFFFF">1</td><td>I</td><td bgcolor="#EEFFFF">11<td>XI</td><td bgcolor="#EEFFFF">30</td><td>XXX</td><td>
<tr><td bgcolor="#EEFFFF">2</td><td>II</td><td bgcolor="#EEFFFF">12<td>XII</td><td bgcolor="#EEFFFF">40</td><td>XL</td><td>
<tr><td bgcolor="#EEFFFF">3</td><td>III</td><td bgcolor="#EEFFFF">13<td>XIII</td><td bgcolor="#EEFFFF">50</td><td>L</td><td>
<tr><td bgcolor="#EEFFFF">4</td><td>IV</td><td bgcolor="#EEFFFF">14<td>XIV</td><td bgcolor="#EEFFFF">60</td><td>LX</td><td>
<tr><td bgcolor="#EEFFFF">5</td><td>V</td><td bgcolor="#EEFFFF">15<td>XV</td><td bgcolor="#EEFFFF">70</td><td>LXX</td><td>
<tr><td bgcolor="#EEFFFF">6</td><td>VI</td><td bgcolor="#EEFFFF">16<td>XVI</td><td bgcolor="#EEFFFF">80</td><td>LXXX</td><td>
<tr><td bgcolor="#EEFFFF">7</td><td>VII</td><td bgcolor="#EEFFFF">17<td>XVII</td><td bgcolor="#EEFFFF">90</td><td>XC</td><td>
<tr><td bgcolor="#EEFFFF">8</td><td>VIII</td><td bgcolor="#EEFFFF">18<td>XVIII</td><td bgcolor="#EEFFFF">100</td><td>C</td><td>
<tr><td bgcolor="#EEFFFF">9</td><td>IX</td><td bgcolor="#EEFFFF">19<td>XIX</td><td bgcolor="#EEFFFF">500</td><td>D</td><td>
<tr><td bgcolor="#EEFFFF">10</td><td>X</td><td bgcolor="#EEFFFF">20<td>XX</td><td bgcolor="#EEFFFF">1000</td><td>M</td><td>
</table>
</center>
<br/>
<p>
I は 1、 V は 5、 X は 10、 L は 50、 C は 100、 D は 500、 M は 1000、 他の例は上の表を見てください。小さい数が大きい数に続いている、つまり右側にあるときは足し算をします。小さい数が大きい数の前に、つまり左にあるときは、大きい数から小さい数を引きます。大きい数字の前にあって引き算を表す小さな数字は一回の引き算あたりひとつしかありません。
</p>
<p>
ローマ数字をアラビア数字（通常の数字）の表記（10 進表示）に変換して出力するプログラムを作成してください。ただし、与えられるローマ数字は上記のルールにのみ従っています(実際のローマ数字の表記にはもっと細かいルールがありますが、ここでは考慮する必要はありません。たとえば、実際のローマ数字ではI はV かX から、X はL かC から、C はD かM からしか引き算しませんし、同じローマ数字は４つ以上（または５つ以上）足し並べることはありません。)
</p>
<H2>Input</H2>
<p>
複数のデータセットが与えられます。それぞれのデータセットにローマ数字（半角大文字のI, V, X, L, C, D ,M で表される連続した文字列）が１行に与えられます。与えられるローマ数字の文字列の長さはおのおの 100 以下です。
</p>
<p>
データセットの数は 50 を超えません。
</p>
<H2>Output</H2>
<p>
各データセットに対し、アラビア数字（整数）を１行に出力して下さい。
</p>
<H2>Sample Input</H2>
<pre>
IV
CCCCLXXXXVIIII
CDXCIX
</pre>
<H2>Output for the Sample Input</H2>
<pre>
4
499
499
</pre>
|
s321048294 | p00039 | Accepted | dict = {"I":1, "V":5, "X":10, "L":50, "C":100, "D":500, "M":1000}
while True:
try:
roman = raw_input()
sum = 0
for i in range(len(roman)):
sum += dict[roman[i]]
sum -= 2*roman.count("IV")
sum -= 2*roman.count("IX")
sum -= 20*roman.count("XL")
sum -= 20*roman.count("XC")
sum -= 200*roman.count("CD")
sum -= 200*roman.count("CM")
print sum
except:
break | IV
CCCCLXXXXVIIII
CDXCIX
| 4
499
499
|
<H1>ローマ数字</H1>
<p>
古代ローマでは数を数えることは難しい仕事でした。アラビア数字の 0,1,2,3,…, 9 はまだ流布していませんでした。その代わり次のような記号が使われていました。
</p>
<center>
<table border=1>
<tr>
<td bgcolor="#EEFFFF" width="100">アラビア数字</td><td width="100">ローマ数字</td><td bgcolor="#EEFFFF" width="100">アラビア数字</td><td width="100">ローマ数字</td><td bgcolor="#EEFFFF" width="100">アラビア数字</td><td width="100">ローマ数字</td>
</tr>
<tr><td bgcolor="#EEFFFF">1</td><td>I</td><td bgcolor="#EEFFFF">11<td>XI</td><td bgcolor="#EEFFFF">30</td><td>XXX</td><td>
<tr><td bgcolor="#EEFFFF">2</td><td>II</td><td bgcolor="#EEFFFF">12<td>XII</td><td bgcolor="#EEFFFF">40</td><td>XL</td><td>
<tr><td bgcolor="#EEFFFF">3</td><td>III</td><td bgcolor="#EEFFFF">13<td>XIII</td><td bgcolor="#EEFFFF">50</td><td>L</td><td>
<tr><td bgcolor="#EEFFFF">4</td><td>IV</td><td bgcolor="#EEFFFF">14<td>XIV</td><td bgcolor="#EEFFFF">60</td><td>LX</td><td>
<tr><td bgcolor="#EEFFFF">5</td><td>V</td><td bgcolor="#EEFFFF">15<td>XV</td><td bgcolor="#EEFFFF">70</td><td>LXX</td><td>
<tr><td bgcolor="#EEFFFF">6</td><td>VI</td><td bgcolor="#EEFFFF">16<td>XVI</td><td bgcolor="#EEFFFF">80</td><td>LXXX</td><td>
<tr><td bgcolor="#EEFFFF">7</td><td>VII</td><td bgcolor="#EEFFFF">17<td>XVII</td><td bgcolor="#EEFFFF">90</td><td>XC</td><td>
<tr><td bgcolor="#EEFFFF">8</td><td>VIII</td><td bgcolor="#EEFFFF">18<td>XVIII</td><td bgcolor="#EEFFFF">100</td><td>C</td><td>
<tr><td bgcolor="#EEFFFF">9</td><td>IX</td><td bgcolor="#EEFFFF">19<td>XIX</td><td bgcolor="#EEFFFF">500</td><td>D</td><td>
<tr><td bgcolor="#EEFFFF">10</td><td>X</td><td bgcolor="#EEFFFF">20<td>XX</td><td bgcolor="#EEFFFF">1000</td><td>M</td><td>
</table>
</center>
<br/>
<p>
I は 1、 V は 5、 X は 10、 L は 50、 C は 100、 D は 500、 M は 1000、 他の例は上の表を見てください。小さい数が大きい数に続いている、つまり右側にあるときは足し算をします。小さい数が大きい数の前に、つまり左にあるときは、大きい数から小さい数を引きます。大きい数字の前にあって引き算を表す小さな数字は一回の引き算あたりひとつしかありません。
</p>
<p>
ローマ数字をアラビア数字（通常の数字）の表記（10 進表示）に変換して出力するプログラムを作成してください。ただし、与えられるローマ数字は上記のルールにのみ従っています(実際のローマ数字の表記にはもっと細かいルールがありますが、ここでは考慮する必要はありません。たとえば、実際のローマ数字ではI はV かX から、X はL かC から、C はD かM からしか引き算しませんし、同じローマ数字は４つ以上（または５つ以上）足し並べることはありません。)
</p>
<H2>Input</H2>
<p>
複数のデータセットが与えられます。それぞれのデータセットにローマ数字（半角大文字のI, V, X, L, C, D ,M で表される連続した文字列）が１行に与えられます。与えられるローマ数字の文字列の長さはおのおの 100 以下です。
</p>
<p>
データセットの数は 50 を超えません。
</p>
<H2>Output</H2>
<p>
各データセットに対し、アラビア数字（整数）を１行に出力して下さい。
</p>
<H2>Sample Input</H2>
<pre>
IV
CCCCLXXXXVIIII
CDXCIX
</pre>
<H2>Output for the Sample Input</H2>
<pre>
4
499
499
</pre>
|
s293536678 | p00039 | Accepted | dict = {"I":1, "V":5, "X":10, "L":50, "C":100, "D":500, "M":1000}
while True:
try:
roman = raw_input()
sum = 0
value = 1000
for i in range(len(roman)):
if value >= dict[roman[i]]:
value = dict[roman[i]]
sum += value
else:
sum -= 2*value
value = dict[roman[i]]
sum += value
print sum
except:
break | IV
CCCCLXXXXVIIII
CDXCIX
| 4
499
499
|
<H1>ローマ数字</H1>
<p>
古代ローマでは数を数えることは難しい仕事でした。アラビア数字の 0,1,2,3,…, 9 はまだ流布していませんでした。その代わり次のような記号が使われていました。
</p>
<center>
<table border=1>
<tr>
<td bgcolor="#EEFFFF" width="100">アラビア数字</td><td width="100">ローマ数字</td><td bgcolor="#EEFFFF" width="100">アラビア数字</td><td width="100">ローマ数字</td><td bgcolor="#EEFFFF" width="100">アラビア数字</td><td width="100">ローマ数字</td>
</tr>
<tr><td bgcolor="#EEFFFF">1</td><td>I</td><td bgcolor="#EEFFFF">11<td>XI</td><td bgcolor="#EEFFFF">30</td><td>XXX</td><td>
<tr><td bgcolor="#EEFFFF">2</td><td>II</td><td bgcolor="#EEFFFF">12<td>XII</td><td bgcolor="#EEFFFF">40</td><td>XL</td><td>
<tr><td bgcolor="#EEFFFF">3</td><td>III</td><td bgcolor="#EEFFFF">13<td>XIII</td><td bgcolor="#EEFFFF">50</td><td>L</td><td>
<tr><td bgcolor="#EEFFFF">4</td><td>IV</td><td bgcolor="#EEFFFF">14<td>XIV</td><td bgcolor="#EEFFFF">60</td><td>LX</td><td>
<tr><td bgcolor="#EEFFFF">5</td><td>V</td><td bgcolor="#EEFFFF">15<td>XV</td><td bgcolor="#EEFFFF">70</td><td>LXX</td><td>
<tr><td bgcolor="#EEFFFF">6</td><td>VI</td><td bgcolor="#EEFFFF">16<td>XVI</td><td bgcolor="#EEFFFF">80</td><td>LXXX</td><td>
<tr><td bgcolor="#EEFFFF">7</td><td>VII</td><td bgcolor="#EEFFFF">17<td>XVII</td><td bgcolor="#EEFFFF">90</td><td>XC</td><td>
<tr><td bgcolor="#EEFFFF">8</td><td>VIII</td><td bgcolor="#EEFFFF">18<td>XVIII</td><td bgcolor="#EEFFFF">100</td><td>C</td><td>
<tr><td bgcolor="#EEFFFF">9</td><td>IX</td><td bgcolor="#EEFFFF">19<td>XIX</td><td bgcolor="#EEFFFF">500</td><td>D</td><td>
<tr><td bgcolor="#EEFFFF">10</td><td>X</td><td bgcolor="#EEFFFF">20<td>XX</td><td bgcolor="#EEFFFF">1000</td><td>M</td><td>
</table>
</center>
<br/>
<p>
I は 1、 V は 5、 X は 10、 L は 50、 C は 100、 D は 500、 M は 1000、 他の例は上の表を見てください。小さい数が大きい数に続いている、つまり右側にあるときは足し算をします。小さい数が大きい数の前に、つまり左にあるときは、大きい数から小さい数を引きます。大きい数字の前にあって引き算を表す小さな数字は一回の引き算あたりひとつしかありません。
</p>
<p>
ローマ数字をアラビア数字（通常の数字）の表記（10 進表示）に変換して出力するプログラムを作成してください。ただし、与えられるローマ数字は上記のルールにのみ従っています(実際のローマ数字の表記にはもっと細かいルールがありますが、ここでは考慮する必要はありません。たとえば、実際のローマ数字ではI はV かX から、X はL かC から、C はD かM からしか引き算しませんし、同じローマ数字は４つ以上（または５つ以上）足し並べることはありません。)
</p>
<H2>Input</H2>
<p>
複数のデータセットが与えられます。それぞれのデータセットにローマ数字（半角大文字のI, V, X, L, C, D ,M で表される連続した文字列）が１行に与えられます。与えられるローマ数字の文字列の長さはおのおの 100 以下です。
</p>
<p>
データセットの数は 50 を超えません。
</p>
<H2>Output</H2>
<p>
各データセットに対し、アラビア数字（整数）を１行に出力して下さい。
</p>
<H2>Sample Input</H2>
<pre>
IV
CCCCLXXXXVIIII
CDXCIX
</pre>
<H2>Output for the Sample Input</H2>
<pre>
4
499
499
</pre>
|
s979970066 | p00039 | Accepted | import sys
roman={"I":1, "V":5, "X":10, "L":50, "C":100, "D":500, "M":1000}
for s in sys.stdin:
x=[]
tmp = roman[s[0]]
x.append(tmp)
for c in s[1:-1]:
tmp = roman[c]
if x[-1]<tmp: x[-1] *= -1
x.append(tmp)
print sum(x) | IV
CCCCLXXXXVIIII
CDXCIX
| 4
499
499
|
<H1>ローマ数字</H1>
<p>
古代ローマでは数を数えることは難しい仕事でした。アラビア数字の 0,1,2,3,…, 9 はまだ流布していませんでした。その代わり次のような記号が使われていました。
</p>
<center>
<table border=1>
<tr>
<td bgcolor="#EEFFFF" width="100">アラビア数字</td><td width="100">ローマ数字</td><td bgcolor="#EEFFFF" width="100">アラビア数字</td><td width="100">ローマ数字</td><td bgcolor="#EEFFFF" width="100">アラビア数字</td><td width="100">ローマ数字</td>
</tr>
<tr><td bgcolor="#EEFFFF">1</td><td>I</td><td bgcolor="#EEFFFF">11<td>XI</td><td bgcolor="#EEFFFF">30</td><td>XXX</td><td>
<tr><td bgcolor="#EEFFFF">2</td><td>II</td><td bgcolor="#EEFFFF">12<td>XII</td><td bgcolor="#EEFFFF">40</td><td>XL</td><td>
<tr><td bgcolor="#EEFFFF">3</td><td>III</td><td bgcolor="#EEFFFF">13<td>XIII</td><td bgcolor="#EEFFFF">50</td><td>L</td><td>
<tr><td bgcolor="#EEFFFF">4</td><td>IV</td><td bgcolor="#EEFFFF">14<td>XIV</td><td bgcolor="#EEFFFF">60</td><td>LX</td><td>
<tr><td bgcolor="#EEFFFF">5</td><td>V</td><td bgcolor="#EEFFFF">15<td>XV</td><td bgcolor="#EEFFFF">70</td><td>LXX</td><td>
<tr><td bgcolor="#EEFFFF">6</td><td>VI</td><td bgcolor="#EEFFFF">16<td>XVI</td><td bgcolor="#EEFFFF">80</td><td>LXXX</td><td>
<tr><td bgcolor="#EEFFFF">7</td><td>VII</td><td bgcolor="#EEFFFF">17<td>XVII</td><td bgcolor="#EEFFFF">90</td><td>XC</td><td>
<tr><td bgcolor="#EEFFFF">8</td><td>VIII</td><td bgcolor="#EEFFFF">18<td>XVIII</td><td bgcolor="#EEFFFF">100</td><td>C</td><td>
<tr><td bgcolor="#EEFFFF">9</td><td>IX</td><td bgcolor="#EEFFFF">19<td>XIX</td><td bgcolor="#EEFFFF">500</td><td>D</td><td>
<tr><td bgcolor="#EEFFFF">10</td><td>X</td><td bgcolor="#EEFFFF">20<td>XX</td><td bgcolor="#EEFFFF">1000</td><td>M</td><td>
</table>
</center>
<br/>
<p>
I は 1、 V は 5、 X は 10、 L は 50、 C は 100、 D は 500、 M は 1000、 他の例は上の表を見てください。小さい数が大きい数に続いている、つまり右側にあるときは足し算をします。小さい数が大きい数の前に、つまり左にあるときは、大きい数から小さい数を引きます。大きい数字の前にあって引き算を表す小さな数字は一回の引き算あたりひとつしかありません。
</p>
<p>
ローマ数字をアラビア数字（通常の数字）の表記（10 進表示）に変換して出力するプログラムを作成してください。ただし、与えられるローマ数字は上記のルールにのみ従っています(実際のローマ数字の表記にはもっと細かいルールがありますが、ここでは考慮する必要はありません。たとえば、実際のローマ数字ではI はV かX から、X はL かC から、C はD かM からしか引き算しませんし、同じローマ数字は４つ以上（または５つ以上）足し並べることはありません。)
</p>
<H2>Input</H2>
<p>
複数のデータセットが与えられます。それぞれのデータセットにローマ数字（半角大文字のI, V, X, L, C, D ,M で表される連続した文字列）が１行に与えられます。与えられるローマ数字の文字列の長さはおのおの 100 以下です。
</p>
<p>
データセットの数は 50 を超えません。
</p>
<H2>Output</H2>
<p>
各データセットに対し、アラビア数字（整数）を１行に出力して下さい。
</p>
<H2>Sample Input</H2>
<pre>
IV
CCCCLXXXXVIIII
CDXCIX
</pre>
<H2>Output for the Sample Input</H2>
<pre>
4
499
499
</pre>
|
s686832784 | p00039 | Accepted | import sys
roman={"I":1,"V":5,"X":10,"L":50,"C":100,"D":500,"M":1000}
for s in sys.stdin:
x=[roman[s[0]]]
for c in s[1:-1]:
tmp = roman[c]
if x[-1]<tmp: x[-1] *= -1
x.append(tmp)
print sum(x) | IV
CCCCLXXXXVIIII
CDXCIX
| 4
499
499
|
<H1>ローマ数字</H1>
<p>
古代ローマでは数を数えることは難しい仕事でした。アラビア数字の 0,1,2,3,…, 9 はまだ流布していませんでした。その代わり次のような記号が使われていました。
</p>
<center>
<table border=1>
<tr>
<td bgcolor="#EEFFFF" width="100">アラビア数字</td><td width="100">ローマ数字</td><td bgcolor="#EEFFFF" width="100">アラビア数字</td><td width="100">ローマ数字</td><td bgcolor="#EEFFFF" width="100">アラビア数字</td><td width="100">ローマ数字</td>
</tr>
<tr><td bgcolor="#EEFFFF">1</td><td>I</td><td bgcolor="#EEFFFF">11<td>XI</td><td bgcolor="#EEFFFF">30</td><td>XXX</td><td>
<tr><td bgcolor="#EEFFFF">2</td><td>II</td><td bgcolor="#EEFFFF">12<td>XII</td><td bgcolor="#EEFFFF">40</td><td>XL</td><td>
<tr><td bgcolor="#EEFFFF">3</td><td>III</td><td bgcolor="#EEFFFF">13<td>XIII</td><td bgcolor="#EEFFFF">50</td><td>L</td><td>
<tr><td bgcolor="#EEFFFF">4</td><td>IV</td><td bgcolor="#EEFFFF">14<td>XIV</td><td bgcolor="#EEFFFF">60</td><td>LX</td><td>
<tr><td bgcolor="#EEFFFF">5</td><td>V</td><td bgcolor="#EEFFFF">15<td>XV</td><td bgcolor="#EEFFFF">70</td><td>LXX</td><td>
<tr><td bgcolor="#EEFFFF">6</td><td>VI</td><td bgcolor="#EEFFFF">16<td>XVI</td><td bgcolor="#EEFFFF">80</td><td>LXXX</td><td>
<tr><td bgcolor="#EEFFFF">7</td><td>VII</td><td bgcolor="#EEFFFF">17<td>XVII</td><td bgcolor="#EEFFFF">90</td><td>XC</td><td>
<tr><td bgcolor="#EEFFFF">8</td><td>VIII</td><td bgcolor="#EEFFFF">18<td>XVIII</td><td bgcolor="#EEFFFF">100</td><td>C</td><td>
<tr><td bgcolor="#EEFFFF">9</td><td>IX</td><td bgcolor="#EEFFFF">19<td>XIX</td><td bgcolor="#EEFFFF">500</td><td>D</td><td>
<tr><td bgcolor="#EEFFFF">10</td><td>X</td><td bgcolor="#EEFFFF">20<td>XX</td><td bgcolor="#EEFFFF">1000</td><td>M</td><td>
</table>
</center>
<br/>
<p>
I は 1、 V は 5、 X は 10、 L は 50、 C は 100、 D は 500、 M は 1000、 他の例は上の表を見てください。小さい数が大きい数に続いている、つまり右側にあるときは足し算をします。小さい数が大きい数の前に、つまり左にあるときは、大きい数から小さい数を引きます。大きい数字の前にあって引き算を表す小さな数字は一回の引き算あたりひとつしかありません。
</p>
<p>
ローマ数字をアラビア数字（通常の数字）の表記（10 進表示）に変換して出力するプログラムを作成してください。ただし、与えられるローマ数字は上記のルールにのみ従っています(実際のローマ数字の表記にはもっと細かいルールがありますが、ここでは考慮する必要はありません。たとえば、実際のローマ数字ではI はV かX から、X はL かC から、C はD かM からしか引き算しませんし、同じローマ数字は４つ以上（または５つ以上）足し並べることはありません。)
</p>
<H2>Input</H2>
<p>
複数のデータセットが与えられます。それぞれのデータセットにローマ数字（半角大文字のI, V, X, L, C, D ,M で表される連続した文字列）が１行に与えられます。与えられるローマ数字の文字列の長さはおのおの 100 以下です。
</p>
<p>
データセットの数は 50 を超えません。
</p>
<H2>Output</H2>
<p>
各データセットに対し、アラビア数字（整数）を１行に出力して下さい。
</p>
<H2>Sample Input</H2>
<pre>
IV
CCCCLXXXXVIIII
CDXCIX
</pre>
<H2>Output for the Sample Input</H2>
<pre>
4
499
499
</pre>
|
s693053662 | p00039 | Accepted | num_list = {'I':1, 'V':5, 'X':10, 'L':50, 'C':100, 'D':500, 'M':1000}
s_list = {'IV':4, 'IX':9, 'XL':40, 'XC':90, 'CD':400, 'CM':900}
while True:
try:
num = raw_input()
ans = 0
for n in s_list:
if n in num:
num = num.replace(n, '')
ans += s_list[n]
res = list(num)
for n in res:
ans += num_list[n]
print ans
except:
break | IV
CCCCLXXXXVIIII
CDXCIX
| 4
499
499
|
<H1>ローマ数字</H1>
<p>
古代ローマでは数を数えることは難しい仕事でした。アラビア数字の 0,1,2,3,…, 9 はまだ流布していませんでした。その代わり次のような記号が使われていました。
</p>
<center>
<table border=1>
<tr>
<td bgcolor="#EEFFFF" width="100">アラビア数字</td><td width="100">ローマ数字</td><td bgcolor="#EEFFFF" width="100">アラビア数字</td><td width="100">ローマ数字</td><td bgcolor="#EEFFFF" width="100">アラビア数字</td><td width="100">ローマ数字</td>
</tr>
<tr><td bgcolor="#EEFFFF">1</td><td>I</td><td bgcolor="#EEFFFF">11<td>XI</td><td bgcolor="#EEFFFF">30</td><td>XXX</td><td>
<tr><td bgcolor="#EEFFFF">2</td><td>II</td><td bgcolor="#EEFFFF">12<td>XII</td><td bgcolor="#EEFFFF">40</td><td>XL</td><td>
<tr><td bgcolor="#EEFFFF">3</td><td>III</td><td bgcolor="#EEFFFF">13<td>XIII</td><td bgcolor="#EEFFFF">50</td><td>L</td><td>
<tr><td bgcolor="#EEFFFF">4</td><td>IV</td><td bgcolor="#EEFFFF">14<td>XIV</td><td bgcolor="#EEFFFF">60</td><td>LX</td><td>
<tr><td bgcolor="#EEFFFF">5</td><td>V</td><td bgcolor="#EEFFFF">15<td>XV</td><td bgcolor="#EEFFFF">70</td><td>LXX</td><td>
<tr><td bgcolor="#EEFFFF">6</td><td>VI</td><td bgcolor="#EEFFFF">16<td>XVI</td><td bgcolor="#EEFFFF">80</td><td>LXXX</td><td>
<tr><td bgcolor="#EEFFFF">7</td><td>VII</td><td bgcolor="#EEFFFF">17<td>XVII</td><td bgcolor="#EEFFFF">90</td><td>XC</td><td>
<tr><td bgcolor="#EEFFFF">8</td><td>VIII</td><td bgcolor="#EEFFFF">18<td>XVIII</td><td bgcolor="#EEFFFF">100</td><td>C</td><td>
<tr><td bgcolor="#EEFFFF">9</td><td>IX</td><td bgcolor="#EEFFFF">19<td>XIX</td><td bgcolor="#EEFFFF">500</td><td>D</td><td>
<tr><td bgcolor="#EEFFFF">10</td><td>X</td><td bgcolor="#EEFFFF">20<td>XX</td><td bgcolor="#EEFFFF">1000</td><td>M</td><td>
</table>
</center>
<br/>
<p>
I は 1、 V は 5、 X は 10、 L は 50、 C は 100、 D は 500、 M は 1000、 他の例は上の表を見てください。小さい数が大きい数に続いている、つまり右側にあるときは足し算をします。小さい数が大きい数の前に、つまり左にあるときは、大きい数から小さい数を引きます。大きい数字の前にあって引き算を表す小さな数字は一回の引き算あたりひとつしかありません。
</p>
<p>
ローマ数字をアラビア数字（通常の数字）の表記（10 進表示）に変換して出力するプログラムを作成してください。ただし、与えられるローマ数字は上記のルールにのみ従っています(実際のローマ数字の表記にはもっと細かいルールがありますが、ここでは考慮する必要はありません。たとえば、実際のローマ数字ではI はV かX から、X はL かC から、C はD かM からしか引き算しませんし、同じローマ数字は４つ以上（または５つ以上）足し並べることはありません。)
</p>
<H2>Input</H2>
<p>
複数のデータセットが与えられます。それぞれのデータセットにローマ数字（半角大文字のI, V, X, L, C, D ,M で表される連続した文字列）が１行に与えられます。与えられるローマ数字の文字列の長さはおのおの 100 以下です。
</p>
<p>
データセットの数は 50 を超えません。
</p>
<H2>Output</H2>
<p>
各データセットに対し、アラビア数字（整数）を１行に出力して下さい。
</p>
<H2>Sample Input</H2>
<pre>
IV
CCCCLXXXXVIIII
CDXCIX
</pre>
<H2>Output for the Sample Input</H2>
<pre>
4
499
499
</pre>
|
s865753674 | p00039 | Accepted | a = {'I': 1, 'V': 5, 'X': 10, 'L': 50, 'C': 100, 'D': 500, 'M': 1000}
try:
while True:
s = raw_input()
sm = a[s[-1]]
for i in range(1, len(s)):
if a[s[i - 1]] < a[s[i]]:
sm -= a[s[i - 1]]
else:
sm += a[s[i - 1]]
print sm
except EOFError:
pass | IV
CCCCLXXXXVIIII
CDXCIX
| 4
499
499
|
<H1>ローマ数字</H1>
<p>
古代ローマでは数を数えることは難しい仕事でした。アラビア数字の 0,1,2,3,…, 9 はまだ流布していませんでした。その代わり次のような記号が使われていました。
</p>
<center>
<table border=1>
<tr>
<td bgcolor="#EEFFFF" width="100">アラビア数字</td><td width="100">ローマ数字</td><td bgcolor="#EEFFFF" width="100">アラビア数字</td><td width="100">ローマ数字</td><td bgcolor="#EEFFFF" width="100">アラビア数字</td><td width="100">ローマ数字</td>
</tr>
<tr><td bgcolor="#EEFFFF">1</td><td>I</td><td bgcolor="#EEFFFF">11<td>XI</td><td bgcolor="#EEFFFF">30</td><td>XXX</td><td>
<tr><td bgcolor="#EEFFFF">2</td><td>II</td><td bgcolor="#EEFFFF">12<td>XII</td><td bgcolor="#EEFFFF">40</td><td>XL</td><td>
<tr><td bgcolor="#EEFFFF">3</td><td>III</td><td bgcolor="#EEFFFF">13<td>XIII</td><td bgcolor="#EEFFFF">50</td><td>L</td><td>
<tr><td bgcolor="#EEFFFF">4</td><td>IV</td><td bgcolor="#EEFFFF">14<td>XIV</td><td bgcolor="#EEFFFF">60</td><td>LX</td><td>
<tr><td bgcolor="#EEFFFF">5</td><td>V</td><td bgcolor="#EEFFFF">15<td>XV</td><td bgcolor="#EEFFFF">70</td><td>LXX</td><td>
<tr><td bgcolor="#EEFFFF">6</td><td>VI</td><td bgcolor="#EEFFFF">16<td>XVI</td><td bgcolor="#EEFFFF">80</td><td>LXXX</td><td>
<tr><td bgcolor="#EEFFFF">7</td><td>VII</td><td bgcolor="#EEFFFF">17<td>XVII</td><td bgcolor="#EEFFFF">90</td><td>XC</td><td>
<tr><td bgcolor="#EEFFFF">8</td><td>VIII</td><td bgcolor="#EEFFFF">18<td>XVIII</td><td bgcolor="#EEFFFF">100</td><td>C</td><td>
<tr><td bgcolor="#EEFFFF">9</td><td>IX</td><td bgcolor="#EEFFFF">19<td>XIX</td><td bgcolor="#EEFFFF">500</td><td>D</td><td>
<tr><td bgcolor="#EEFFFF">10</td><td>X</td><td bgcolor="#EEFFFF">20<td>XX</td><td bgcolor="#EEFFFF">1000</td><td>M</td><td>
</table>
</center>
<br/>
<p>
I は 1、 V は 5、 X は 10、 L は 50、 C は 100、 D は 500、 M は 1000、 他の例は上の表を見てください。小さい数が大きい数に続いている、つまり右側にあるときは足し算をします。小さい数が大きい数の前に、つまり左にあるときは、大きい数から小さい数を引きます。大きい数字の前にあって引き算を表す小さな数字は一回の引き算あたりひとつしかありません。
</p>
<p>
ローマ数字をアラビア数字（通常の数字）の表記（10 進表示）に変換して出力するプログラムを作成してください。ただし、与えられるローマ数字は上記のルールにのみ従っています(実際のローマ数字の表記にはもっと細かいルールがありますが、ここでは考慮する必要はありません。たとえば、実際のローマ数字ではI はV かX から、X はL かC から、C はD かM からしか引き算しませんし、同じローマ数字は４つ以上（または５つ以上）足し並べることはありません。)
</p>
<H2>Input</H2>
<p>
複数のデータセットが与えられます。それぞれのデータセットにローマ数字（半角大文字のI, V, X, L, C, D ,M で表される連続した文字列）が１行に与えられます。与えられるローマ数字の文字列の長さはおのおの 100 以下です。
</p>
<p>
データセットの数は 50 を超えません。
</p>
<H2>Output</H2>
<p>
各データセットに対し、アラビア数字（整数）を１行に出力して下さい。
</p>
<H2>Sample Input</H2>
<pre>
IV
CCCCLXXXXVIIII
CDXCIX
</pre>
<H2>Output for the Sample Input</H2>
<pre>
4
499
499
</pre>
|
s749812735 | p00039 | Accepted | dict = {'I': 1, 'V': 5, 'X': 10, 'L': 50, 'C': 100, 'D': 500, 'M': 1000}
while True:
try:
arr = list(raw_input())
sum = 0
for i in range(len(arr)):
if i == (len(arr) - 1):
sum += dict[arr[i]]
else:
a = dict[arr[i]]
b = dict[arr[i+1]]
if a >= b:
sum += a
else:
sum -= a
print sum
except EOFError:
break | IV
CCCCLXXXXVIIII
CDXCIX
| 4
499
499
|
<H1>ローマ数字</H1>
<p>
古代ローマでは数を数えることは難しい仕事でした。アラビア数字の 0,1,2,3,…, 9 はまだ流布していませんでした。その代わり次のような記号が使われていました。
</p>
<center>
<table border=1>
<tr>
<td bgcolor="#EEFFFF" width="100">アラビア数字</td><td width="100">ローマ数字</td><td bgcolor="#EEFFFF" width="100">アラビア数字</td><td width="100">ローマ数字</td><td bgcolor="#EEFFFF" width="100">アラビア数字</td><td width="100">ローマ数字</td>
</tr>
<tr><td bgcolor="#EEFFFF">1</td><td>I</td><td bgcolor="#EEFFFF">11<td>XI</td><td bgcolor="#EEFFFF">30</td><td>XXX</td><td>
<tr><td bgcolor="#EEFFFF">2</td><td>II</td><td bgcolor="#EEFFFF">12<td>XII</td><td bgcolor="#EEFFFF">40</td><td>XL</td><td>
<tr><td bgcolor="#EEFFFF">3</td><td>III</td><td bgcolor="#EEFFFF">13<td>XIII</td><td bgcolor="#EEFFFF">50</td><td>L</td><td>
<tr><td bgcolor="#EEFFFF">4</td><td>IV</td><td bgcolor="#EEFFFF">14<td>XIV</td><td bgcolor="#EEFFFF">60</td><td>LX</td><td>
<tr><td bgcolor="#EEFFFF">5</td><td>V</td><td bgcolor="#EEFFFF">15<td>XV</td><td bgcolor="#EEFFFF">70</td><td>LXX</td><td>
<tr><td bgcolor="#EEFFFF">6</td><td>VI</td><td bgcolor="#EEFFFF">16<td>XVI</td><td bgcolor="#EEFFFF">80</td><td>LXXX</td><td>
<tr><td bgcolor="#EEFFFF">7</td><td>VII</td><td bgcolor="#EEFFFF">17<td>XVII</td><td bgcolor="#EEFFFF">90</td><td>XC</td><td>
<tr><td bgcolor="#EEFFFF">8</td><td>VIII</td><td bgcolor="#EEFFFF">18<td>XVIII</td><td bgcolor="#EEFFFF">100</td><td>C</td><td>
<tr><td bgcolor="#EEFFFF">9</td><td>IX</td><td bgcolor="#EEFFFF">19<td>XIX</td><td bgcolor="#EEFFFF">500</td><td>D</td><td>
<tr><td bgcolor="#EEFFFF">10</td><td>X</td><td bgcolor="#EEFFFF">20<td>XX</td><td bgcolor="#EEFFFF">1000</td><td>M</td><td>
</table>
</center>
<br/>
<p>
I は 1、 V は 5、 X は 10、 L は 50、 C は 100、 D は 500、 M は 1000、 他の例は上の表を見てください。小さい数が大きい数に続いている、つまり右側にあるときは足し算をします。小さい数が大きい数の前に、つまり左にあるときは、大きい数から小さい数を引きます。大きい数字の前にあって引き算を表す小さな数字は一回の引き算あたりひとつしかありません。
</p>
<p>
ローマ数字をアラビア数字（通常の数字）の表記（10 進表示）に変換して出力するプログラムを作成してください。ただし、与えられるローマ数字は上記のルールにのみ従っています(実際のローマ数字の表記にはもっと細かいルールがありますが、ここでは考慮する必要はありません。たとえば、実際のローマ数字ではI はV かX から、X はL かC から、C はD かM からしか引き算しませんし、同じローマ数字は４つ以上（または５つ以上）足し並べることはありません。)
</p>
<H2>Input</H2>
<p>
複数のデータセットが与えられます。それぞれのデータセットにローマ数字（半角大文字のI, V, X, L, C, D ,M で表される連続した文字列）が１行に与えられます。与えられるローマ数字の文字列の長さはおのおの 100 以下です。
</p>
<p>
データセットの数は 50 を超えません。
</p>
<H2>Output</H2>
<p>
各データセットに対し、アラビア数字（整数）を１行に出力して下さい。
</p>
<H2>Sample Input</H2>
<pre>
IV
CCCCLXXXXVIIII
CDXCIX
</pre>
<H2>Output for the Sample Input</H2>
<pre>
4
499
499
</pre>
|
s652757594 | p00039 | Accepted | Roman = {'I': 1, 'V': 5, 'X': 10, 'L': 50, 'C': 100, 'D': 500, 'M': 1000}
while 1:
try:
roman = raw_input()
except EOFError:
break
phase = 1000
ret = 0
cnt = 0
for x in roman:
cur = Roman[x]
if cur < phase:
ret += phase * cnt
phase = cur
cnt = 1
elif cur == phase:
cnt += 1
elif cur > phase:
ret += cur - cnt * phase
phase = cur
cnt = 0
else:
ret += phase * cnt
print ret | IV
CCCCLXXXXVIIII
CDXCIX
| 4
499
499
|
<H1>ローマ数字</H1>
<p>
古代ローマでは数を数えることは難しい仕事でした。アラビア数字の 0,1,2,3,…, 9 はまだ流布していませんでした。その代わり次のような記号が使われていました。
</p>
<center>
<table border=1>
<tr>
<td bgcolor="#EEFFFF" width="100">アラビア数字</td><td width="100">ローマ数字</td><td bgcolor="#EEFFFF" width="100">アラビア数字</td><td width="100">ローマ数字</td><td bgcolor="#EEFFFF" width="100">アラビア数字</td><td width="100">ローマ数字</td>
</tr>
<tr><td bgcolor="#EEFFFF">1</td><td>I</td><td bgcolor="#EEFFFF">11<td>XI</td><td bgcolor="#EEFFFF">30</td><td>XXX</td><td>
<tr><td bgcolor="#EEFFFF">2</td><td>II</td><td bgcolor="#EEFFFF">12<td>XII</td><td bgcolor="#EEFFFF">40</td><td>XL</td><td>
<tr><td bgcolor="#EEFFFF">3</td><td>III</td><td bgcolor="#EEFFFF">13<td>XIII</td><td bgcolor="#EEFFFF">50</td><td>L</td><td>
<tr><td bgcolor="#EEFFFF">4</td><td>IV</td><td bgcolor="#EEFFFF">14<td>XIV</td><td bgcolor="#EEFFFF">60</td><td>LX</td><td>
<tr><td bgcolor="#EEFFFF">5</td><td>V</td><td bgcolor="#EEFFFF">15<td>XV</td><td bgcolor="#EEFFFF">70</td><td>LXX</td><td>
<tr><td bgcolor="#EEFFFF">6</td><td>VI</td><td bgcolor="#EEFFFF">16<td>XVI</td><td bgcolor="#EEFFFF">80</td><td>LXXX</td><td>
<tr><td bgcolor="#EEFFFF">7</td><td>VII</td><td bgcolor="#EEFFFF">17<td>XVII</td><td bgcolor="#EEFFFF">90</td><td>XC</td><td>
<tr><td bgcolor="#EEFFFF">8</td><td>VIII</td><td bgcolor="#EEFFFF">18<td>XVIII</td><td bgcolor="#EEFFFF">100</td><td>C</td><td>
<tr><td bgcolor="#EEFFFF">9</td><td>IX</td><td bgcolor="#EEFFFF">19<td>XIX</td><td bgcolor="#EEFFFF">500</td><td>D</td><td>
<tr><td bgcolor="#EEFFFF">10</td><td>X</td><td bgcolor="#EEFFFF">20<td>XX</td><td bgcolor="#EEFFFF">1000</td><td>M</td><td>
</table>
</center>
<br/>
<p>
I は 1、 V は 5、 X は 10、 L は 50、 C は 100、 D は 500、 M は 1000、 他の例は上の表を見てください。小さい数が大きい数に続いている、つまり右側にあるときは足し算をします。小さい数が大きい数の前に、つまり左にあるときは、大きい数から小さい数を引きます。大きい数字の前にあって引き算を表す小さな数字は一回の引き算あたりひとつしかありません。
</p>
<p>
ローマ数字をアラビア数字（通常の数字）の表記（10 進表示）に変換して出力するプログラムを作成してください。ただし、与えられるローマ数字は上記のルールにのみ従っています(実際のローマ数字の表記にはもっと細かいルールがありますが、ここでは考慮する必要はありません。たとえば、実際のローマ数字ではI はV かX から、X はL かC から、C はD かM からしか引き算しませんし、同じローマ数字は４つ以上（または５つ以上）足し並べることはありません。)
</p>
<H2>Input</H2>
<p>
複数のデータセットが与えられます。それぞれのデータセットにローマ数字（半角大文字のI, V, X, L, C, D ,M で表される連続した文字列）が１行に与えられます。与えられるローマ数字の文字列の長さはおのおの 100 以下です。
</p>
<p>
データセットの数は 50 を超えません。
</p>
<H2>Output</H2>
<p>
各データセットに対し、アラビア数字（整数）を１行に出力して下さい。
</p>
<H2>Sample Input</H2>
<pre>
IV
CCCCLXXXXVIIII
CDXCIX
</pre>
<H2>Output for the Sample Input</H2>
<pre>
4
499
499
</pre>
|
s302091873 | p00039 | Accepted | import sys
if sys.version_info[0]>=3: raw_input=input
def main(roman):
m={'I':1,'V':5,'X':10,'L':50,'C':100,'D':500,'M':1000}
r=0
for i in range(len(roman)):
r+=m[roman[i]]*(1 if i==len(roman)-1 or m[roman[i]]>=m[roman[i+1]] else -1)
print(str(r))
if __name__=='__main__':
try:
while True:
main(raw_input().rstrip())
except EOFError:
pass | IV
CCCCLXXXXVIIII
CDXCIX
| 4
499
499
|
<H1>ローマ数字</H1>
<p>
古代ローマでは数を数えることは難しい仕事でした。アラビア数字の 0,1,2,3,…, 9 はまだ流布していませんでした。その代わり次のような記号が使われていました。
</p>
<center>
<table border=1>
<tr>
<td bgcolor="#EEFFFF" width="100">アラビア数字</td><td width="100">ローマ数字</td><td bgcolor="#EEFFFF" width="100">アラビア数字</td><td width="100">ローマ数字</td><td bgcolor="#EEFFFF" width="100">アラビア数字</td><td width="100">ローマ数字</td>
</tr>
<tr><td bgcolor="#EEFFFF">1</td><td>I</td><td bgcolor="#EEFFFF">11<td>XI</td><td bgcolor="#EEFFFF">30</td><td>XXX</td><td>
<tr><td bgcolor="#EEFFFF">2</td><td>II</td><td bgcolor="#EEFFFF">12<td>XII</td><td bgcolor="#EEFFFF">40</td><td>XL</td><td>
<tr><td bgcolor="#EEFFFF">3</td><td>III</td><td bgcolor="#EEFFFF">13<td>XIII</td><td bgcolor="#EEFFFF">50</td><td>L</td><td>
<tr><td bgcolor="#EEFFFF">4</td><td>IV</td><td bgcolor="#EEFFFF">14<td>XIV</td><td bgcolor="#EEFFFF">60</td><td>LX</td><td>
<tr><td bgcolor="#EEFFFF">5</td><td>V</td><td bgcolor="#EEFFFF">15<td>XV</td><td bgcolor="#EEFFFF">70</td><td>LXX</td><td>
<tr><td bgcolor="#EEFFFF">6</td><td>VI</td><td bgcolor="#EEFFFF">16<td>XVI</td><td bgcolor="#EEFFFF">80</td><td>LXXX</td><td>
<tr><td bgcolor="#EEFFFF">7</td><td>VII</td><td bgcolor="#EEFFFF">17<td>XVII</td><td bgcolor="#EEFFFF">90</td><td>XC</td><td>
<tr><td bgcolor="#EEFFFF">8</td><td>VIII</td><td bgcolor="#EEFFFF">18<td>XVIII</td><td bgcolor="#EEFFFF">100</td><td>C</td><td>
<tr><td bgcolor="#EEFFFF">9</td><td>IX</td><td bgcolor="#EEFFFF">19<td>XIX</td><td bgcolor="#EEFFFF">500</td><td>D</td><td>
<tr><td bgcolor="#EEFFFF">10</td><td>X</td><td bgcolor="#EEFFFF">20<td>XX</td><td bgcolor="#EEFFFF">1000</td><td>M</td><td>
</table>
</center>
<br/>
<p>
I は 1、 V は 5、 X は 10、 L は 50、 C は 100、 D は 500、 M は 1000、 他の例は上の表を見てください。小さい数が大きい数に続いている、つまり右側にあるときは足し算をします。小さい数が大きい数の前に、つまり左にあるときは、大きい数から小さい数を引きます。大きい数字の前にあって引き算を表す小さな数字は一回の引き算あたりひとつしかありません。
</p>
<p>
ローマ数字をアラビア数字（通常の数字）の表記（10 進表示）に変換して出力するプログラムを作成してください。ただし、与えられるローマ数字は上記のルールにのみ従っています(実際のローマ数字の表記にはもっと細かいルールがありますが、ここでは考慮する必要はありません。たとえば、実際のローマ数字ではI はV かX から、X はL かC から、C はD かM からしか引き算しませんし、同じローマ数字は４つ以上（または５つ以上）足し並べることはありません。)
</p>
<H2>Input</H2>
<p>
複数のデータセットが与えられます。それぞれのデータセットにローマ数字（半角大文字のI, V, X, L, C, D ,M で表される連続した文字列）が１行に与えられます。与えられるローマ数字の文字列の長さはおのおの 100 以下です。
</p>
<p>
データセットの数は 50 を超えません。
</p>
<H2>Output</H2>
<p>
各データセットに対し、アラビア数字（整数）を１行に出力して下さい。
</p>
<H2>Sample Input</H2>
<pre>
IV
CCCCLXXXXVIIII
CDXCIX
</pre>
<H2>Output for the Sample Input</H2>
<pre>
4
499
499
</pre>
|
s641108578 | p00039 | Accepted | import sys
d = {'I':1, 'V':5, 'X':10, 'L':50, 'C':100, 'D':500, 'M':1000}
for s in sys.stdin:
s = [d[c] for c in s.strip()] + [0]
n = 0
for i, x in enumerate(s[:-1]):
if x >= s[i + 1]:
n += x
else:
n -= x
print(n) | IV
CCCCLXXXXVIIII
CDXCIX
| 4
499
499
|
<H1>ローマ数字</H1>
<p>
古代ローマでは数を数えることは難しい仕事でした。アラビア数字の 0,1,2,3,…, 9 はまだ流布していませんでした。その代わり次のような記号が使われていました。
</p>
<center>
<table border=1>
<tr>
<td bgcolor="#EEFFFF" width="100">アラビア数字</td><td width="100">ローマ数字</td><td bgcolor="#EEFFFF" width="100">アラビア数字</td><td width="100">ローマ数字</td><td bgcolor="#EEFFFF" width="100">アラビア数字</td><td width="100">ローマ数字</td>
</tr>
<tr><td bgcolor="#EEFFFF">1</td><td>I</td><td bgcolor="#EEFFFF">11<td>XI</td><td bgcolor="#EEFFFF">30</td><td>XXX</td><td>
<tr><td bgcolor="#EEFFFF">2</td><td>II</td><td bgcolor="#EEFFFF">12<td>XII</td><td bgcolor="#EEFFFF">40</td><td>XL</td><td>
<tr><td bgcolor="#EEFFFF">3</td><td>III</td><td bgcolor="#EEFFFF">13<td>XIII</td><td bgcolor="#EEFFFF">50</td><td>L</td><td>
<tr><td bgcolor="#EEFFFF">4</td><td>IV</td><td bgcolor="#EEFFFF">14<td>XIV</td><td bgcolor="#EEFFFF">60</td><td>LX</td><td>
<tr><td bgcolor="#EEFFFF">5</td><td>V</td><td bgcolor="#EEFFFF">15<td>XV</td><td bgcolor="#EEFFFF">70</td><td>LXX</td><td>
<tr><td bgcolor="#EEFFFF">6</td><td>VI</td><td bgcolor="#EEFFFF">16<td>XVI</td><td bgcolor="#EEFFFF">80</td><td>LXXX</td><td>
<tr><td bgcolor="#EEFFFF">7</td><td>VII</td><td bgcolor="#EEFFFF">17<td>XVII</td><td bgcolor="#EEFFFF">90</td><td>XC</td><td>
<tr><td bgcolor="#EEFFFF">8</td><td>VIII</td><td bgcolor="#EEFFFF">18<td>XVIII</td><td bgcolor="#EEFFFF">100</td><td>C</td><td>
<tr><td bgcolor="#EEFFFF">9</td><td>IX</td><td bgcolor="#EEFFFF">19<td>XIX</td><td bgcolor="#EEFFFF">500</td><td>D</td><td>
<tr><td bgcolor="#EEFFFF">10</td><td>X</td><td bgcolor="#EEFFFF">20<td>XX</td><td bgcolor="#EEFFFF">1000</td><td>M</td><td>
</table>
</center>
<br/>
<p>
I は 1、 V は 5、 X は 10、 L は 50、 C は 100、 D は 500、 M は 1000、 他の例は上の表を見てください。小さい数が大きい数に続いている、つまり右側にあるときは足し算をします。小さい数が大きい数の前に、つまり左にあるときは、大きい数から小さい数を引きます。大きい数字の前にあって引き算を表す小さな数字は一回の引き算あたりひとつしかありません。
</p>
<p>
ローマ数字をアラビア数字（通常の数字）の表記（10 進表示）に変換して出力するプログラムを作成してください。ただし、与えられるローマ数字は上記のルールにのみ従っています(実際のローマ数字の表記にはもっと細かいルールがありますが、ここでは考慮する必要はありません。たとえば、実際のローマ数字ではI はV かX から、X はL かC から、C はD かM からしか引き算しませんし、同じローマ数字は４つ以上（または５つ以上）足し並べることはありません。)
</p>
<H2>Input</H2>
<p>
複数のデータセットが与えられます。それぞれのデータセットにローマ数字（半角大文字のI, V, X, L, C, D ,M で表される連続した文字列）が１行に与えられます。与えられるローマ数字の文字列の長さはおのおの 100 以下です。
</p>
<p>
データセットの数は 50 を超えません。
</p>
<H2>Output</H2>
<p>
各データセットに対し、アラビア数字（整数）を１行に出力して下さい。
</p>
<H2>Sample Input</H2>
<pre>
IV
CCCCLXXXXVIIII
CDXCIX
</pre>
<H2>Output for the Sample Input</H2>
<pre>
4
499
499
</pre>
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.