s_id stringlengths 10 10 | p_id stringlengths 6 6 | u_id stringlengths 10 10 | date stringlengths 10 10 | language stringclasses 1
value | original_language stringclasses 11
values | filename_ext stringclasses 1
value | status stringclasses 1
value | cpu_time int64 0 100 | memory stringlengths 4 6 | code_size int64 15 14.7k | code stringlengths 15 14.7k | problem_id stringlengths 6 6 | problem_description stringlengths 358 9.83k | input stringlengths 2 4.87k | output stringclasses 807
values | __index_level_0__ int64 1.1k 1.22M |
|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
s245022706 | p00081 | u647766105 | 1357369808 | Python | Python | py | Accepted | 10 | 4252 | 344 | import sys
for line in sys.stdin.readlines():
x1,y1,x2,y2,xq,yq=map(float,line.strip().split(","))
if x1==x2:
x,y=-xq+2*x1,yq
elif y1==y2:
x,y=xq,-yq+2*y1
else:
m=(y1-y2)/(x1-x2)
n=-m*x1+y1
x=(2*yq*m-2*m*n+xq-m*m*xq)/(m*m+1)
y=(xq-x)/m+yq
print "{:.6f} {:.6f}".format(x+0,y+0) | p00081 |
<H1>線対称</H1>
<p>
平面上の異なる 3 点 <var>P1(x1,y1)</var>, <var>P2(x2,y2)</var>, <var>Q(xq,yq)</var> の座標の組を読み込んで、点 <var>P1</var> 点<var>P2</var> を通る直線を対称軸として点 <var>Q</var> と線対称の位置にある点 <var>R(x,y)</var> を出力するプログラムを作成してください。なお、点 <var>Q</var> は、その対称軸上にないものとします。
</p>
<center>
<img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_09_1">
</center>
<H2>入力</H2>
<p>
入力は複数のデータセットからなります。各データセットは以下の形式で与えられます。
</p>
<pre>
<var>x1</var>,<var>y1</var>,<var>x2</var>,<var>y2</var>,<var>xq</var>,<var>yq</var>
</pre>
<p>
<var>x1</var>, <var>y1</var>, <var>x2</var>, <var>y2</var>, <var>xq</var>, <var>yq</var> (-100 以上 100 以下の実数) がカンマ区切りで１行に与えられます。
</p>
<p>
データセットの数は 50 を超えない。
</p>
<H2>出力</H2>
<p>
データセットごとに、<var>x</var>, <var>y</var> を空白区切りで 1 行に出力する。出力は実数で 0.0001 以下の誤差を含んでもよい。
</p>
<H2>Sample Input</H2>
<pre>
1.0,0.0,-1.0,0.0,1.0,1.0
1.0,0.0,0.0,-1.0,3.0,0.0
0.0,1.0,0.0,-1.0,1.0,1.0
</pre>
<H2>Output for the Sample Input</H2>
<pre>
1.000000 -1.000000
1.000000 2.000000
-1.000000 1.000000
</pre>
| 1.0,0.0,-1.0,0.0,1.0,1.0
1.0,0.0,0.0,-1.0,3.0,0.0
0.0,1.0,0.0,-1.0,1.0,1.0
| 1.000000 -1.000000
1.000000 2.000000
-1.000000 1.000000
| 12,141 |
s990110761 | p00081 | u104911888 | 1367074881 | Python | Python | py | Accepted | 20 | 4244 | 293 | while True:
try:
x1,y1,x2,y2,xq,yq=map(float,raw_input().split(","))
except EOFError:
break
try:
m=(y2-y1)/(x2-x1)
y=(yq*(m*m-1)+2*m*xq+2*(y2-m*x2))/(1+m*m)
x=m*yq+xq-m*y
except ZeroDivisionError:
x=-xq
y=yq
print x,y | p00081 |
<H1>線対称</H1>
<p>
平面上の異なる 3 点 <var>P1(x1,y1)</var>, <var>P2(x2,y2)</var>, <var>Q(xq,yq)</var> の座標の組を読み込んで、点 <var>P1</var> 点<var>P2</var> を通る直線を対称軸として点 <var>Q</var> と線対称の位置にある点 <var>R(x,y)</var> を出力するプログラムを作成してください。なお、点 <var>Q</var> は、その対称軸上にないものとします。
</p>
<center>
<img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_09_1">
</center>
<H2>入力</H2>
<p>
入力は複数のデータセットからなります。各データセットは以下の形式で与えられます。
</p>
<pre>
<var>x1</var>,<var>y1</var>,<var>x2</var>,<var>y2</var>,<var>xq</var>,<var>yq</var>
</pre>
<p>
<var>x1</var>, <var>y1</var>, <var>x2</var>, <var>y2</var>, <var>xq</var>, <var>yq</var> (-100 以上 100 以下の実数) がカンマ区切りで１行に与えられます。
</p>
<p>
データセットの数は 50 を超えない。
</p>
<H2>出力</H2>
<p>
データセットごとに、<var>x</var>, <var>y</var> を空白区切りで 1 行に出力する。出力は実数で 0.0001 以下の誤差を含んでもよい。
</p>
<H2>Sample Input</H2>
<pre>
1.0,0.0,-1.0,0.0,1.0,1.0
1.0,0.0,0.0,-1.0,3.0,0.0
0.0,1.0,0.0,-1.0,1.0,1.0
</pre>
<H2>Output for the Sample Input</H2>
<pre>
1.000000 -1.000000
1.000000 2.000000
-1.000000 1.000000
</pre>
| 1.0,0.0,-1.0,0.0,1.0,1.0
1.0,0.0,0.0,-1.0,3.0,0.0
0.0,1.0,0.0,-1.0,1.0,1.0
| 1.000000 -1.000000
1.000000 2.000000
-1.000000 1.000000
| 12,142 |
s183885011 | p00081 | u260980560 | 1384354343 | Python | Python | py | Accepted | 10 | 4324 | 481 | def rot(x, y, t):
v = [0.0, 0.0]
v[0] = ((1-t**2)*x+2*t*y)/(t**2+1)
v[1] = (2*t*x+(t**2-1)*y)/(t**2+1)
return v
import sys
v=[0.0,0.0]
for line in sys.stdin:
ipt = line.split(',')
x = [float(ipt[i]) for i in range(0,6,2)]
y = [float(ipt[j]) for j in range(1,6,2)]
if x[1]!=x[0]:
v = rot(x[2]-x[0],y[2]-y[0],(y[1]-y[0])/(x[1]-x[0]))
v[0]+=x[0]; v[1]+=y[0];
else:
v = [-x[2], y[2]]
print "%.6f %.6f"%(0.0+v[0],0.0+v[1]) | p00081 |
<H1>線対称</H1>
<p>
平面上の異なる 3 点 <var>P1(x1,y1)</var>, <var>P2(x2,y2)</var>, <var>Q(xq,yq)</var> の座標の組を読み込んで、点 <var>P1</var> 点<var>P2</var> を通る直線を対称軸として点 <var>Q</var> と線対称の位置にある点 <var>R(x,y)</var> を出力するプログラムを作成してください。なお、点 <var>Q</var> は、その対称軸上にないものとします。
</p>
<center>
<img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_09_1">
</center>
<H2>入力</H2>
<p>
入力は複数のデータセットからなります。各データセットは以下の形式で与えられます。
</p>
<pre>
<var>x1</var>,<var>y1</var>,<var>x2</var>,<var>y2</var>,<var>xq</var>,<var>yq</var>
</pre>
<p>
<var>x1</var>, <var>y1</var>, <var>x2</var>, <var>y2</var>, <var>xq</var>, <var>yq</var> (-100 以上 100 以下の実数) がカンマ区切りで１行に与えられます。
</p>
<p>
データセットの数は 50 を超えない。
</p>
<H2>出力</H2>
<p>
データセットごとに、<var>x</var>, <var>y</var> を空白区切りで 1 行に出力する。出力は実数で 0.0001 以下の誤差を含んでもよい。
</p>
<H2>Sample Input</H2>
<pre>
1.0,0.0,-1.0,0.0,1.0,1.0
1.0,0.0,0.0,-1.0,3.0,0.0
0.0,1.0,0.0,-1.0,1.0,1.0
</pre>
<H2>Output for the Sample Input</H2>
<pre>
1.000000 -1.000000
1.000000 2.000000
-1.000000 1.000000
</pre>
| 1.0,0.0,-1.0,0.0,1.0,1.0
1.0,0.0,0.0,-1.0,3.0,0.0
0.0,1.0,0.0,-1.0,1.0,1.0
| 1.000000 -1.000000
1.000000 2.000000
-1.000000 1.000000
| 12,143 |
s482762887 | p00081 | u633068244 | 1395924143 | Python | Python | py | Accepted | 20 | 4256 | 284 | def sp(a,b,c,xq,yq):
xr = xq - 2*a*(a*xq+b*yq+c)/(a**2+b**2)
yr = yq - 2*b*(a*xq+b*yq+c)/(a**2+b**2)
print xr,yr
while True:
try:
x1,y1,x2,y2,xq,yq = map(float, raw_input().split(","))
sp(y2-y1,-(x2-x1),x2*y1-x1*y2,xq,yq)
except:
break | p00081 |
<H1>線対称</H1>
<p>
平面上の異なる 3 点 <var>P1(x1,y1)</var>, <var>P2(x2,y2)</var>, <var>Q(xq,yq)</var> の座標の組を読み込んで、点 <var>P1</var> 点<var>P2</var> を通る直線を対称軸として点 <var>Q</var> と線対称の位置にある点 <var>R(x,y)</var> を出力するプログラムを作成してください。なお、点 <var>Q</var> は、その対称軸上にないものとします。
</p>
<center>
<img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_09_1">
</center>
<H2>入力</H2>
<p>
入力は複数のデータセットからなります。各データセットは以下の形式で与えられます。
</p>
<pre>
<var>x1</var>,<var>y1</var>,<var>x2</var>,<var>y2</var>,<var>xq</var>,<var>yq</var>
</pre>
<p>
<var>x1</var>, <var>y1</var>, <var>x2</var>, <var>y2</var>, <var>xq</var>, <var>yq</var> (-100 以上 100 以下の実数) がカンマ区切りで１行に与えられます。
</p>
<p>
データセットの数は 50 を超えない。
</p>
<H2>出力</H2>
<p>
データセットごとに、<var>x</var>, <var>y</var> を空白区切りで 1 行に出力する。出力は実数で 0.0001 以下の誤差を含んでもよい。
</p>
<H2>Sample Input</H2>
<pre>
1.0,0.0,-1.0,0.0,1.0,1.0
1.0,0.0,0.0,-1.0,3.0,0.0
0.0,1.0,0.0,-1.0,1.0,1.0
</pre>
<H2>Output for the Sample Input</H2>
<pre>
1.000000 -1.000000
1.000000 2.000000
-1.000000 1.000000
</pre>
| 1.0,0.0,-1.0,0.0,1.0,1.0
1.0,0.0,0.0,-1.0,3.0,0.0
0.0,1.0,0.0,-1.0,1.0,1.0
| 1.000000 -1.000000
1.000000 2.000000
-1.000000 1.000000
| 12,144 |
s327758761 | p00081 | u633068244 | 1395924150 | Python | Python | py | Accepted | 10 | 4256 | 284 | def sp(a,b,c,xq,yq):
xr = xq - 2*a*(a*xq+b*yq+c)/(a**2+b**2)
yr = yq - 2*b*(a*xq+b*yq+c)/(a**2+b**2)
print xr,yr
while True:
try:
x1,y1,x2,y2,xq,yq = map(float, raw_input().split(","))
sp(y2-y1,-(x2-x1),x2*y1-x1*y2,xq,yq)
except:
break | p00081 |
<H1>線対称</H1>
<p>
平面上の異なる 3 点 <var>P1(x1,y1)</var>, <var>P2(x2,y2)</var>, <var>Q(xq,yq)</var> の座標の組を読み込んで、点 <var>P1</var> 点<var>P2</var> を通る直線を対称軸として点 <var>Q</var> と線対称の位置にある点 <var>R(x,y)</var> を出力するプログラムを作成してください。なお、点 <var>Q</var> は、その対称軸上にないものとします。
</p>
<center>
<img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_09_1">
</center>
<H2>入力</H2>
<p>
入力は複数のデータセットからなります。各データセットは以下の形式で与えられます。
</p>
<pre>
<var>x1</var>,<var>y1</var>,<var>x2</var>,<var>y2</var>,<var>xq</var>,<var>yq</var>
</pre>
<p>
<var>x1</var>, <var>y1</var>, <var>x2</var>, <var>y2</var>, <var>xq</var>, <var>yq</var> (-100 以上 100 以下の実数) がカンマ区切りで１行に与えられます。
</p>
<p>
データセットの数は 50 を超えない。
</p>
<H2>出力</H2>
<p>
データセットごとに、<var>x</var>, <var>y</var> を空白区切りで 1 行に出力する。出力は実数で 0.0001 以下の誤差を含んでもよい。
</p>
<H2>Sample Input</H2>
<pre>
1.0,0.0,-1.0,0.0,1.0,1.0
1.0,0.0,0.0,-1.0,3.0,0.0
0.0,1.0,0.0,-1.0,1.0,1.0
</pre>
<H2>Output for the Sample Input</H2>
<pre>
1.000000 -1.000000
1.000000 2.000000
-1.000000 1.000000
</pre>
| 1.0,0.0,-1.0,0.0,1.0,1.0
1.0,0.0,0.0,-1.0,3.0,0.0
0.0,1.0,0.0,-1.0,1.0,1.0
| 1.000000 -1.000000
1.000000 2.000000
-1.000000 1.000000
| 12,145 |
s204997106 | p00081 | u912237403 | 1397272649 | Python | Python | py | Accepted | 10 | 4248 | 262 | import sys
for s in sys.stdin:
x1,y1,x2,y2,xq,yq =map(float,s[:-1].split(","))
if x2==x1:
y=yq
x=x1
else:
m=1.0*(y2-y1)/(x2-x1)
a=m*m+1
x0=m*x1-y1
y0=xq+m*yq
x=(m*x0+y0)/a
y=(-x0+m*y0)/a
print "%0.5f %0.5f"%(2*x-xq,2*y-yq) | p00081 |
<H1>線対称</H1>
<p>
平面上の異なる 3 点 <var>P1(x1,y1)</var>, <var>P2(x2,y2)</var>, <var>Q(xq,yq)</var> の座標の組を読み込んで、点 <var>P1</var> 点<var>P2</var> を通る直線を対称軸として点 <var>Q</var> と線対称の位置にある点 <var>R(x,y)</var> を出力するプログラムを作成してください。なお、点 <var>Q</var> は、その対称軸上にないものとします。
</p>
<center>
<img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_09_1">
</center>
<H2>入力</H2>
<p>
入力は複数のデータセットからなります。各データセットは以下の形式で与えられます。
</p>
<pre>
<var>x1</var>,<var>y1</var>,<var>x2</var>,<var>y2</var>,<var>xq</var>,<var>yq</var>
</pre>
<p>
<var>x1</var>, <var>y1</var>, <var>x2</var>, <var>y2</var>, <var>xq</var>, <var>yq</var> (-100 以上 100 以下の実数) がカンマ区切りで１行に与えられます。
</p>
<p>
データセットの数は 50 を超えない。
</p>
<H2>出力</H2>
<p>
データセットごとに、<var>x</var>, <var>y</var> を空白区切りで 1 行に出力する。出力は実数で 0.0001 以下の誤差を含んでもよい。
</p>
<H2>Sample Input</H2>
<pre>
1.0,0.0,-1.0,0.0,1.0,1.0
1.0,0.0,0.0,-1.0,3.0,0.0
0.0,1.0,0.0,-1.0,1.0,1.0
</pre>
<H2>Output for the Sample Input</H2>
<pre>
1.000000 -1.000000
1.000000 2.000000
-1.000000 1.000000
</pre>
| 1.0,0.0,-1.0,0.0,1.0,1.0
1.0,0.0,0.0,-1.0,3.0,0.0
0.0,1.0,0.0,-1.0,1.0,1.0
| 1.000000 -1.000000
1.000000 2.000000
-1.000000 1.000000
| 12,146 |
s199649676 | p00081 | u187074069 | 1595332758 | Python | Python3 | py | Accepted | 20 | 5592 | 368 | while True:
try:
x1, y1, x2, y2, xp, yp = map(float, input().split(','))
dx = x2 - x1
dy = y2 - y1
xr = (2*dx*dy*yp + (dx**2 - dy**2)*xp + 2*dy*(x1*y2 - x2*y1))/(dx**2 + dy**2)
yr = (2*dx*dy*xp - (dx**2 - dy**2)*yp - 2*dx*(x1*y2 - x2*y1))/(dx**2 + dy**2)
print(xr, yr)
except EOFError:
break
| p00081 |
<H1>線対称</H1>
<p>
平面上の異なる 3 点 <var>P1(x1,y1)</var>, <var>P2(x2,y2)</var>, <var>Q(xq,yq)</var> の座標の組を読み込んで、点 <var>P1</var> 点<var>P2</var> を通る直線を対称軸として点 <var>Q</var> と線対称の位置にある点 <var>R(x,y)</var> を出力するプログラムを作成してください。なお、点 <var>Q</var> は、その対称軸上にないものとします。
</p>
<center>
<img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_09_1">
</center>
<H2>入力</H2>
<p>
入力は複数のデータセットからなります。各データセットは以下の形式で与えられます。
</p>
<pre>
<var>x1</var>,<var>y1</var>,<var>x2</var>,<var>y2</var>,<var>xq</var>,<var>yq</var>
</pre>
<p>
<var>x1</var>, <var>y1</var>, <var>x2</var>, <var>y2</var>, <var>xq</var>, <var>yq</var> (-100 以上 100 以下の実数) がカンマ区切りで１行に与えられます。
</p>
<p>
データセットの数は 50 を超えない。
</p>
<H2>出力</H2>
<p>
データセットごとに、<var>x</var>, <var>y</var> を空白区切りで 1 行に出力する。出力は実数で 0.0001 以下の誤差を含んでもよい。
</p>
<H2>Sample Input</H2>
<pre>
1.0,0.0,-1.0,0.0,1.0,1.0
1.0,0.0,0.0,-1.0,3.0,0.0
0.0,1.0,0.0,-1.0,1.0,1.0
</pre>
<H2>Output for the Sample Input</H2>
<pre>
1.000000 -1.000000
1.000000 2.000000
-1.000000 1.000000
</pre>
| 1.0,0.0,-1.0,0.0,1.0,1.0
1.0,0.0,0.0,-1.0,3.0,0.0
0.0,1.0,0.0,-1.0,1.0,1.0
| 1.000000 -1.000000
1.000000 2.000000
-1.000000 1.000000
| 12,147 |
s660687481 | p00081 | u240091169 | 1594857135 | Python | Python3 | py | Accepted | 20 | 5588 | 1,083 | while True :
try :
x1, y1, x2, y2, xq, yq = map(float, input().split(','))
except EOFError :
break
if x1 != x2 and y1 != y2:
## d_P1_P2 : P1-P2の傾き ##
d_P1_P2 = (y2-y1)/(x2-x1)
## d_Q1_Q2 : Q1-Q2の傾き ##
d_Q1_Q2 = -1/d_P1_P2
## 直線P1-P2 ##
b_P1_P2 = y1 - d_P1_P2 * x1
## y = d_P1_P2 * x + b_P1_P2
## 直線Q1-Q2 ##
b_Q1_Q2 = yq - d_Q1_Q2 * xq
## y = d_Q1_Q2 * x + b_Q1_Q2
## P1-P2 と Q1-Q2 の交点(xq3, yq3) ##
## d_P1_P2 * x + b_P1_P2 = d_Q1_Q2 * x + b_Q1_Q2
## (d_P1_P2 - d_Q1_Q2) * x = b_Q1_Q2 - b_P1_P2
xq3 = (b_Q1_Q2 - b_P1_P2) / (d_P1_P2 - d_Q1_Q2)
yq3 = d_P1_P2 * xq3 + b_P1_P2
## Q2の座標(xq2, yq2) ##
xq2 = xq3 - (xq - xq3)
yq2 = yq3 - (yq - yq3)
elif x1 == x2 :
xq2 = x1 + x1 - xq
yq2 = yq
else :
xq2 = xq
yq2 = y1 - (yq - y1)
print('{0:.8f} {1:.8f}'.format(xq2, yq2))
| p00081 |
<H1>線対称</H1>
<p>
平面上の異なる 3 点 <var>P1(x1,y1)</var>, <var>P2(x2,y2)</var>, <var>Q(xq,yq)</var> の座標の組を読み込んで、点 <var>P1</var> 点<var>P2</var> を通る直線を対称軸として点 <var>Q</var> と線対称の位置にある点 <var>R(x,y)</var> を出力するプログラムを作成してください。なお、点 <var>Q</var> は、その対称軸上にないものとします。
</p>
<center>
<img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_09_1">
</center>
<H2>入力</H2>
<p>
入力は複数のデータセットからなります。各データセットは以下の形式で与えられます。
</p>
<pre>
<var>x1</var>,<var>y1</var>,<var>x2</var>,<var>y2</var>,<var>xq</var>,<var>yq</var>
</pre>
<p>
<var>x1</var>, <var>y1</var>, <var>x2</var>, <var>y2</var>, <var>xq</var>, <var>yq</var> (-100 以上 100 以下の実数) がカンマ区切りで１行に与えられます。
</p>
<p>
データセットの数は 50 を超えない。
</p>
<H2>出力</H2>
<p>
データセットごとに、<var>x</var>, <var>y</var> を空白区切りで 1 行に出力する。出力は実数で 0.0001 以下の誤差を含んでもよい。
</p>
<H2>Sample Input</H2>
<pre>
1.0,0.0,-1.0,0.0,1.0,1.0
1.0,0.0,0.0,-1.0,3.0,0.0
0.0,1.0,0.0,-1.0,1.0,1.0
</pre>
<H2>Output for the Sample Input</H2>
<pre>
1.000000 -1.000000
1.000000 2.000000
-1.000000 1.000000
</pre>
| 1.0,0.0,-1.0,0.0,1.0,1.0
1.0,0.0,0.0,-1.0,3.0,0.0
0.0,1.0,0.0,-1.0,1.0,1.0
| 1.000000 -1.000000
1.000000 2.000000
-1.000000 1.000000
| 12,148 |
s208020017 | p00081 | u197615397 | 1547905509 | Python | Python3 | py | Accepted | 20 | 5644 | 1,699 | class Point(object):
__slots__ = ["x", "y"]
def __init__(self, x, y):
self.x = x
self.y = y
def __iter__(self):
yield self.x
yield self.y
def __add__(self, other: "Point") -> "Point":
return Point(self.x + other.x, self.y + other.y)
def __sub__(self, other: "Point") -> "Point":
return Point(self.x - other.x, self.y - other.y)
def __mul__(self, s: int):
return Point(self.x * s, self.y * s)
def project(self, vector: "Vector") -> "Point":
return (vector * (Vector(vector.p1, self).dot(vector) / vector.norm)).p2
def reflect(self, vector: "Vector") -> "Point":
return self + (self.project(vector) - self) * 2
class Vector(object):
__slots__ = ["p1", "p2", "x", "y", "norm", "abs"]
def __init__(self, p1: Point, p2: Point):
self.p1 = p1
self.p2 = p2
self.x = p2.x - p1.x
self.y = p2.y - p1.y
self.norm = self.x ** 2 + self.y ** 2
self.abs = abs(self.x + self.y)
def __mul__(self, s):
return Vector(self.p1, Point(self.p1.x + self.x * s, self.p1.y + self.y * s))
def __lt__(self, other: "Vector"):
return other.abs > self.abs
def __gt__(self, other: "Vector"):
return other.abs < self.abs
def dot(self, other: "Vector"):
return self.x * other.x + self.y * other.y
def cross(self, other: "Vector"):
return self.x * other.y - self.y * other.x
if __name__ == "__main__":
import sys
for x1, y1, x2, y2, xq, yq in (map(float, l.split(",")) for l in sys.stdin):
vector = Vector(Point(x1, y1), Point(x2, y2))
print(*Point(xq, yq).reflect(vector))
| p00081 |
<H1>線対称</H1>
<p>
平面上の異なる 3 点 <var>P1(x1,y1)</var>, <var>P2(x2,y2)</var>, <var>Q(xq,yq)</var> の座標の組を読み込んで、点 <var>P1</var> 点<var>P2</var> を通る直線を対称軸として点 <var>Q</var> と線対称の位置にある点 <var>R(x,y)</var> を出力するプログラムを作成してください。なお、点 <var>Q</var> は、その対称軸上にないものとします。
</p>
<center>
<img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_09_1">
</center>
<H2>入力</H2>
<p>
入力は複数のデータセットからなります。各データセットは以下の形式で与えられます。
</p>
<pre>
<var>x1</var>,<var>y1</var>,<var>x2</var>,<var>y2</var>,<var>xq</var>,<var>yq</var>
</pre>
<p>
<var>x1</var>, <var>y1</var>, <var>x2</var>, <var>y2</var>, <var>xq</var>, <var>yq</var> (-100 以上 100 以下の実数) がカンマ区切りで１行に与えられます。
</p>
<p>
データセットの数は 50 を超えない。
</p>
<H2>出力</H2>
<p>
データセットごとに、<var>x</var>, <var>y</var> を空白区切りで 1 行に出力する。出力は実数で 0.0001 以下の誤差を含んでもよい。
</p>
<H2>Sample Input</H2>
<pre>
1.0,0.0,-1.0,0.0,1.0,1.0
1.0,0.0,0.0,-1.0,3.0,0.0
0.0,1.0,0.0,-1.0,1.0,1.0
</pre>
<H2>Output for the Sample Input</H2>
<pre>
1.000000 -1.000000
1.000000 2.000000
-1.000000 1.000000
</pre>
| 1.0,0.0,-1.0,0.0,1.0,1.0
1.0,0.0,0.0,-1.0,3.0,0.0
0.0,1.0,0.0,-1.0,1.0,1.0
| 1.000000 -1.000000
1.000000 2.000000
-1.000000 1.000000
| 12,149 |
s442839013 | p00081 | u563075864 | 1545106198 | Python | Python3 | py | Accepted | 20 | 5752 | 365 | from math import sqrt,atan2,cos,sin
while(1):
try:
x1,y1,x2,y2,xq,yq = [float(i) for i in input().split(",")]
r = sqrt((xq-x1)**2 + (yq-y1)**2)
th1 = atan2(y2-y1,x2-x1)
th2 = atan2(yq-y1,xq-x1)
th3 = -(th2 - th1) + th1
print("{:.6f} {:.6f}".format(x1+r*cos(th3),y1+r*sin(th3)))
except EOFError:
break
| p00081 |
<H1>線対称</H1>
<p>
平面上の異なる 3 点 <var>P1(x1,y1)</var>, <var>P2(x2,y2)</var>, <var>Q(xq,yq)</var> の座標の組を読み込んで、点 <var>P1</var> 点<var>P2</var> を通る直線を対称軸として点 <var>Q</var> と線対称の位置にある点 <var>R(x,y)</var> を出力するプログラムを作成してください。なお、点 <var>Q</var> は、その対称軸上にないものとします。
</p>
<center>
<img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_09_1">
</center>
<H2>入力</H2>
<p>
入力は複数のデータセットからなります。各データセットは以下の形式で与えられます。
</p>
<pre>
<var>x1</var>,<var>y1</var>,<var>x2</var>,<var>y2</var>,<var>xq</var>,<var>yq</var>
</pre>
<p>
<var>x1</var>, <var>y1</var>, <var>x2</var>, <var>y2</var>, <var>xq</var>, <var>yq</var> (-100 以上 100 以下の実数) がカンマ区切りで１行に与えられます。
</p>
<p>
データセットの数は 50 を超えない。
</p>
<H2>出力</H2>
<p>
データセットごとに、<var>x</var>, <var>y</var> を空白区切りで 1 行に出力する。出力は実数で 0.0001 以下の誤差を含んでもよい。
</p>
<H2>Sample Input</H2>
<pre>
1.0,0.0,-1.0,0.0,1.0,1.0
1.0,0.0,0.0,-1.0,3.0,0.0
0.0,1.0,0.0,-1.0,1.0,1.0
</pre>
<H2>Output for the Sample Input</H2>
<pre>
1.000000 -1.000000
1.000000 2.000000
-1.000000 1.000000
</pre>
| 1.0,0.0,-1.0,0.0,1.0,1.0
1.0,0.0,0.0,-1.0,3.0,0.0
0.0,1.0,0.0,-1.0,1.0,1.0
| 1.000000 -1.000000
1.000000 2.000000
-1.000000 1.000000
| 12,150 |
s731324042 | p00081 | u025180675 | 1544965320 | Python | Python3 | py | Accepted | 20 | 5584 | 306 | try:
while True:
T = tuple(map(float,input().strip().split(",")))
z = complex(T[0]-T[2],T[1]-T[3])
P = complex(T[0],T[1])
Q = complex(T[4],T[5])
R = P + (Q-P).conjugate() * z / z.conjugate()
print("%.6f %.6f" % (R.real,R.imag))
except EOFError:
pass
| p00081 |
<H1>線対称</H1>
<p>
平面上の異なる 3 点 <var>P1(x1,y1)</var>, <var>P2(x2,y2)</var>, <var>Q(xq,yq)</var> の座標の組を読み込んで、点 <var>P1</var> 点<var>P2</var> を通る直線を対称軸として点 <var>Q</var> と線対称の位置にある点 <var>R(x,y)</var> を出力するプログラムを作成してください。なお、点 <var>Q</var> は、その対称軸上にないものとします。
</p>
<center>
<img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_09_1">
</center>
<H2>入力</H2>
<p>
入力は複数のデータセットからなります。各データセットは以下の形式で与えられます。
</p>
<pre>
<var>x1</var>,<var>y1</var>,<var>x2</var>,<var>y2</var>,<var>xq</var>,<var>yq</var>
</pre>
<p>
<var>x1</var>, <var>y1</var>, <var>x2</var>, <var>y2</var>, <var>xq</var>, <var>yq</var> (-100 以上 100 以下の実数) がカンマ区切りで１行に与えられます。
</p>
<p>
データセットの数は 50 を超えない。
</p>
<H2>出力</H2>
<p>
データセットごとに、<var>x</var>, <var>y</var> を空白区切りで 1 行に出力する。出力は実数で 0.0001 以下の誤差を含んでもよい。
</p>
<H2>Sample Input</H2>
<pre>
1.0,0.0,-1.0,0.0,1.0,1.0
1.0,0.0,0.0,-1.0,3.0,0.0
0.0,1.0,0.0,-1.0,1.0,1.0
</pre>
<H2>Output for the Sample Input</H2>
<pre>
1.000000 -1.000000
1.000000 2.000000
-1.000000 1.000000
</pre>
| 1.0,0.0,-1.0,0.0,1.0,1.0
1.0,0.0,0.0,-1.0,3.0,0.0
0.0,1.0,0.0,-1.0,1.0,1.0
| 1.000000 -1.000000
1.000000 2.000000
-1.000000 1.000000
| 12,151 |
s680759829 | p00082 | u197615397 | 1532173572 | Python | Python3 | py | Accepted | 40 | 5616 | 340 | import sys
m = [4,1,4,1,2,1,2,1]
for l in sys.stdin:
l = list(map(int, l.rstrip().split()))
a = []
for i in range(0, 8):
_m = [m[j%8] for j in range(i, i+8)]
n = 0
for n1, n2 in zip(l, _m):
n += max(0, n1-n2)
a.append((n, "".join(map(str, _m))))
print(" ".join(sorted(a)[0][1]))
| p00082 |
<H1>メリーゴーランド</H1>
<center>
<img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_10_1">
</center><br/>
<p>
遊園地にあるメリーゴーランドはご存じでしょう。大きな円盤の上に馬や馬車などの乗り物が固定されていて、円盤が回転すると同時に乗り物が上下に揺れる、定番の遊具です。ある遊園地のメリーゴーランドは、４人乗りの馬車が２台、２人乗りの車２台、１人乗りの馬が４台、計８台の乗り物が図１のような順序で備えられています。そして、遊園地においでのお客様は、図１に示す乗り場０〜７のどこかで待つようになっています。
</p>
<center>
<img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_10_2">
</center><br/>
<p>
この遊園地のメリーゴーランドは、かならず乗り物が乗り場にぴったりと合う位置に停止します。そして、０〜７のそれぞれで待っているお客さまは、目の前にとまった乗り物に乗ることになっています。急いで他の乗り場へ移動してそこから乗るということはできません。効率よく、お客さまにたのしんでいただくためには、メリーゴーランドの停止する位置をうまく調整して、乗れないお客さまをできるだけ少なくするようにしなければなりません。
</p>
<p>
乗り場０〜７で待っているお客さまの人数を読み込んで、どの位置にどの乗り物が来るように止めれば乗れないお客さまが最も少なくなるかを出力するプログラムを作成してください。
<!--なお、乗れなくなるお客さまが最小となるとめ方が何通りもある場合は、そのうちの一つだけ出力するようにしてください。-->
</p>
<H2>入力</H2>
<p>
入力は複数のデータセットからなります。各データセットは以下の形式で与えられます。
</p>
<pre>
<var>p<sub>0</sub></var> <var>p<sub>1</sub></var> <var>p<sub>2</sub></var> <var>p<sub>3</sub></var> <var>p<sub>4</sub></var> <var>p<sub>5</sub></var> <var>p<sub>6</sub></var> <var>p<sub>7</sub></var>
</pre>
<p>
乗り場 0, 1, ..., 7 で待っているお客様の人数を表す整数 <var>p<sub>0</sub></var>, <var>p<sub>1</sub></var>,... , <var>p<sub>7</sub></var> ( 0 ≤ <var>p<sub>i</sub></var> ≤ 10,000) が空白区切りで１行に与えられます。
</p>
<H2>出力</H2>
<p>
メリーゴーランドの乗り物の馬車を 4、車を 2、馬を 1 で表すこととします。乗り場 0, 1, ... , 7 にとめる乗り物を、それぞれ <var>c<sub>0</sub></var>, <var>c<sub>1</sub></var>,..., <var>c<sub>7</sub></var> とします。データセットごとに、<var>c<sub>0</sub></var>, <var>c<sub>1</sub></var>,..., <var>c<sub>7</sub></var> を空白区切りで 1 行に出力します。
</p>
<p>
なお、乗れなくなるお客さまが最小となるとめ方が複数ある場合は、<var>c<sub>0</sub>c<sub>1</sub>c<sub>2</sub>c<sub>3</sub>c<sub>4</sub>c<sub>5</sub>c<sub>6</sub>c<sub>7</sub></var> を 8 桁の整数 <var>V</var> とみなし、<var>V</var> が最小となるとめ方を選ぶものとします。
</p>
<p>
データセットの数は 100 を超えません。
</p>
<H2>Sample Input</H2>
<pre>
2 3 1 4 0 1 0 1
4 2 3 2 2 2 1 1
</pre>
<H2>Output for the Sample Input</H2>
<pre>
1 4 1 4 1 2 1 2
4 1 4 1 2 1 2 1
</pre>
| 2 3 1 4 0 1 0 1
4 2 3 2 2 2 1 1
| 1 4 1 4 1 2 1 2
4 1 4 1 2 1 2 1
| 12,152 |
s170404528 | p00082 | u260980560 | 1540299427 | Python | Python3 | py | Accepted | 30 | 5728 | 371 | G = [4, 1, 4, 1, 2, 1, 2, 1]
N = 8
ans = []
for line in open(0).readlines():
*P, = map(int, line.split())
Q = None; c = -1
for i in range(N):
R = G[i:] + G[:i]
d = 0
for j in range(N):
d += min(R[j], P[j])
if c < d:
c = d
Q = R
elif c == d and R < Q:
Q = R
print(*Q)
| p00082 |
<H1>メリーゴーランド</H1>
<center>
<img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_10_1">
</center><br/>
<p>
遊園地にあるメリーゴーランドはご存じでしょう。大きな円盤の上に馬や馬車などの乗り物が固定されていて、円盤が回転すると同時に乗り物が上下に揺れる、定番の遊具です。ある遊園地のメリーゴーランドは、４人乗りの馬車が２台、２人乗りの車２台、１人乗りの馬が４台、計８台の乗り物が図１のような順序で備えられています。そして、遊園地においでのお客様は、図１に示す乗り場０〜７のどこかで待つようになっています。
</p>
<center>
<img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_10_2">
</center><br/>
<p>
この遊園地のメリーゴーランドは、かならず乗り物が乗り場にぴったりと合う位置に停止します。そして、０〜７のそれぞれで待っているお客さまは、目の前にとまった乗り物に乗ることになっています。急いで他の乗り場へ移動してそこから乗るということはできません。効率よく、お客さまにたのしんでいただくためには、メリーゴーランドの停止する位置をうまく調整して、乗れないお客さまをできるだけ少なくするようにしなければなりません。
</p>
<p>
乗り場０〜７で待っているお客さまの人数を読み込んで、どの位置にどの乗り物が来るように止めれば乗れないお客さまが最も少なくなるかを出力するプログラムを作成してください。
<!--なお、乗れなくなるお客さまが最小となるとめ方が何通りもある場合は、そのうちの一つだけ出力するようにしてください。-->
</p>
<H2>入力</H2>
<p>
入力は複数のデータセットからなります。各データセットは以下の形式で与えられます。
</p>
<pre>
<var>p<sub>0</sub></var> <var>p<sub>1</sub></var> <var>p<sub>2</sub></var> <var>p<sub>3</sub></var> <var>p<sub>4</sub></var> <var>p<sub>5</sub></var> <var>p<sub>6</sub></var> <var>p<sub>7</sub></var>
</pre>
<p>
乗り場 0, 1, ..., 7 で待っているお客様の人数を表す整数 <var>p<sub>0</sub></var>, <var>p<sub>1</sub></var>,... , <var>p<sub>7</sub></var> ( 0 ≤ <var>p<sub>i</sub></var> ≤ 10,000) が空白区切りで１行に与えられます。
</p>
<H2>出力</H2>
<p>
メリーゴーランドの乗り物の馬車を 4、車を 2、馬を 1 で表すこととします。乗り場 0, 1, ... , 7 にとめる乗り物を、それぞれ <var>c<sub>0</sub></var>, <var>c<sub>1</sub></var>,..., <var>c<sub>7</sub></var> とします。データセットごとに、<var>c<sub>0</sub></var>, <var>c<sub>1</sub></var>,..., <var>c<sub>7</sub></var> を空白区切りで 1 行に出力します。
</p>
<p>
なお、乗れなくなるお客さまが最小となるとめ方が複数ある場合は、<var>c<sub>0</sub>c<sub>1</sub>c<sub>2</sub>c<sub>3</sub>c<sub>4</sub>c<sub>5</sub>c<sub>6</sub>c<sub>7</sub></var> を 8 桁の整数 <var>V</var> とみなし、<var>V</var> が最小となるとめ方を選ぶものとします。
</p>
<p>
データセットの数は 100 を超えません。
</p>
<H2>Sample Input</H2>
<pre>
2 3 1 4 0 1 0 1
4 2 3 2 2 2 1 1
</pre>
<H2>Output for the Sample Input</H2>
<pre>
1 4 1 4 1 2 1 2
4 1 4 1 2 1 2 1
</pre>
| 2 3 1 4 0 1 0 1
4 2 3 2 2 2 1 1
| 1 4 1 4 1 2 1 2
4 1 4 1 2 1 2 1
| 12,153 |
s693046726 | p00082 | u193025715 | 1408289393 | Python | Python3 | py | Accepted | 30 | 6744 | 681 | mgr = [4, 1, 4, 1, 2, 1, 2, 1]
while True:
try:
p = list(map(int, input().split(' ')))
v = []
for i in range(8):
q = mgr[i:] + mgr[:i]
sum_v = sum(p) - sum(p[j]-q[j] if p[j]-q[j] >= 0 else 0 for j in range(8))
v.append(sum_v)
if v.count(max(v)) > 1:
mv = max(v)
ans = []
for i in range(8):
if v[i] == mv:
ans.append(int("".join(map(str, mgr[i:] + mgr[:i]))))
print(" ".join(list(str(min(ans)))))
else:
i = v.index(max(v))
print(" ".join(map(str, mgr[i:] + mgr[:i])))
except:
break | p00082 |
<H1>メリーゴーランド</H1>
<center>
<img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_10_1">
</center><br/>
<p>
遊園地にあるメリーゴーランドはご存じでしょう。大きな円盤の上に馬や馬車などの乗り物が固定されていて、円盤が回転すると同時に乗り物が上下に揺れる、定番の遊具です。ある遊園地のメリーゴーランドは、４人乗りの馬車が２台、２人乗りの車２台、１人乗りの馬が４台、計８台の乗り物が図１のような順序で備えられています。そして、遊園地においでのお客様は、図１に示す乗り場０〜７のどこかで待つようになっています。
</p>
<center>
<img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_10_2">
</center><br/>
<p>
この遊園地のメリーゴーランドは、かならず乗り物が乗り場にぴったりと合う位置に停止します。そして、０〜７のそれぞれで待っているお客さまは、目の前にとまった乗り物に乗ることになっています。急いで他の乗り場へ移動してそこから乗るということはできません。効率よく、お客さまにたのしんでいただくためには、メリーゴーランドの停止する位置をうまく調整して、乗れないお客さまをできるだけ少なくするようにしなければなりません。
</p>
<p>
乗り場０〜７で待っているお客さまの人数を読み込んで、どの位置にどの乗り物が来るように止めれば乗れないお客さまが最も少なくなるかを出力するプログラムを作成してください。
<!--なお、乗れなくなるお客さまが最小となるとめ方が何通りもある場合は、そのうちの一つだけ出力するようにしてください。-->
</p>
<H2>入力</H2>
<p>
入力は複数のデータセットからなります。各データセットは以下の形式で与えられます。
</p>
<pre>
<var>p<sub>0</sub></var> <var>p<sub>1</sub></var> <var>p<sub>2</sub></var> <var>p<sub>3</sub></var> <var>p<sub>4</sub></var> <var>p<sub>5</sub></var> <var>p<sub>6</sub></var> <var>p<sub>7</sub></var>
</pre>
<p>
乗り場 0, 1, ..., 7 で待っているお客様の人数を表す整数 <var>p<sub>0</sub></var>, <var>p<sub>1</sub></var>,... , <var>p<sub>7</sub></var> ( 0 ≤ <var>p<sub>i</sub></var> ≤ 10,000) が空白区切りで１行に与えられます。
</p>
<H2>出力</H2>
<p>
メリーゴーランドの乗り物の馬車を 4、車を 2、馬を 1 で表すこととします。乗り場 0, 1, ... , 7 にとめる乗り物を、それぞれ <var>c<sub>0</sub></var>, <var>c<sub>1</sub></var>,..., <var>c<sub>7</sub></var> とします。データセットごとに、<var>c<sub>0</sub></var>, <var>c<sub>1</sub></var>,..., <var>c<sub>7</sub></var> を空白区切りで 1 行に出力します。
</p>
<p>
なお、乗れなくなるお客さまが最小となるとめ方が複数ある場合は、<var>c<sub>0</sub>c<sub>1</sub>c<sub>2</sub>c<sub>3</sub>c<sub>4</sub>c<sub>5</sub>c<sub>6</sub>c<sub>7</sub></var> を 8 桁の整数 <var>V</var> とみなし、<var>V</var> が最小となるとめ方を選ぶものとします。
</p>
<p>
データセットの数は 100 を超えません。
</p>
<H2>Sample Input</H2>
<pre>
2 3 1 4 0 1 0 1
4 2 3 2 2 2 1 1
</pre>
<H2>Output for the Sample Input</H2>
<pre>
1 4 1 4 1 2 1 2
4 1 4 1 2 1 2 1
</pre>
| 2 3 1 4 0 1 0 1
4 2 3 2 2 2 1 1
| 1 4 1 4 1 2 1 2
4 1 4 1 2 1 2 1
| 12,154 |
s450985347 | p00082 | u506132575 | 1417702757 | Python | Python | py | Accepted | 20 | 4244 | 509 | import sys
for s in sys.stdin:
row = [1,2,1,2,1,4,1,4]
d = map(int,s.split())
mini = 10000000
n = len(row)
m_row = [4]*n
for i in xrange(n):
su = [d[j]-row[(i+j)%n] if d[j] > row[(i+j)%n] else 0 for j in xrange(n) ]
su = sum(su)
if mini == su:
m_row = min(m_row,[ row[(i+j)%n] for j in xrange(n) ])
elif mini > su:
mini = su
m_row =[ row[(i+j)%n] for j in xrange(n) ]
for m in m_row:
print m,
print | p00082 |
<H1>メリーゴーランド</H1>
<center>
<img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_10_1">
</center><br/>
<p>
遊園地にあるメリーゴーランドはご存じでしょう。大きな円盤の上に馬や馬車などの乗り物が固定されていて、円盤が回転すると同時に乗り物が上下に揺れる、定番の遊具です。ある遊園地のメリーゴーランドは、４人乗りの馬車が２台、２人乗りの車２台、１人乗りの馬が４台、計８台の乗り物が図１のような順序で備えられています。そして、遊園地においでのお客様は、図１に示す乗り場０〜７のどこかで待つようになっています。
</p>
<center>
<img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_10_2">
</center><br/>
<p>
この遊園地のメリーゴーランドは、かならず乗り物が乗り場にぴったりと合う位置に停止します。そして、０〜７のそれぞれで待っているお客さまは、目の前にとまった乗り物に乗ることになっています。急いで他の乗り場へ移動してそこから乗るということはできません。効率よく、お客さまにたのしんでいただくためには、メリーゴーランドの停止する位置をうまく調整して、乗れないお客さまをできるだけ少なくするようにしなければなりません。
</p>
<p>
乗り場０〜７で待っているお客さまの人数を読み込んで、どの位置にどの乗り物が来るように止めれば乗れないお客さまが最も少なくなるかを出力するプログラムを作成してください。
<!--なお、乗れなくなるお客さまが最小となるとめ方が何通りもある場合は、そのうちの一つだけ出力するようにしてください。-->
</p>
<H2>入力</H2>
<p>
入力は複数のデータセットからなります。各データセットは以下の形式で与えられます。
</p>
<pre>
<var>p<sub>0</sub></var> <var>p<sub>1</sub></var> <var>p<sub>2</sub></var> <var>p<sub>3</sub></var> <var>p<sub>4</sub></var> <var>p<sub>5</sub></var> <var>p<sub>6</sub></var> <var>p<sub>7</sub></var>
</pre>
<p>
乗り場 0, 1, ..., 7 で待っているお客様の人数を表す整数 <var>p<sub>0</sub></var>, <var>p<sub>1</sub></var>,... , <var>p<sub>7</sub></var> ( 0 ≤ <var>p<sub>i</sub></var> ≤ 10,000) が空白区切りで１行に与えられます。
</p>
<H2>出力</H2>
<p>
メリーゴーランドの乗り物の馬車を 4、車を 2、馬を 1 で表すこととします。乗り場 0, 1, ... , 7 にとめる乗り物を、それぞれ <var>c<sub>0</sub></var>, <var>c<sub>1</sub></var>,..., <var>c<sub>7</sub></var> とします。データセットごとに、<var>c<sub>0</sub></var>, <var>c<sub>1</sub></var>,..., <var>c<sub>7</sub></var> を空白区切りで 1 行に出力します。
</p>
<p>
なお、乗れなくなるお客さまが最小となるとめ方が複数ある場合は、<var>c<sub>0</sub>c<sub>1</sub>c<sub>2</sub>c<sub>3</sub>c<sub>4</sub>c<sub>5</sub>c<sub>6</sub>c<sub>7</sub></var> を 8 桁の整数 <var>V</var> とみなし、<var>V</var> が最小となるとめ方を選ぶものとします。
</p>
<p>
データセットの数は 100 を超えません。
</p>
<H2>Sample Input</H2>
<pre>
2 3 1 4 0 1 0 1
4 2 3 2 2 2 1 1
</pre>
<H2>Output for the Sample Input</H2>
<pre>
1 4 1 4 1 2 1 2
4 1 4 1 2 1 2 1
</pre>
| 2 3 1 4 0 1 0 1
4 2 3 2 2 2 1 1
| 1 4 1 4 1 2 1 2
4 1 4 1 2 1 2 1
| 12,155 |
s948472446 | p00082 | u567380442 | 1423397537 | Python | Python3 | py | Accepted | 40 | 6716 | 587 | import sys
f = sys.stdin
def get_v(c):
v = 0
for ci in c:
v *= 10
v += ci
return v
c = (1,4,1,4,1,2,1,2)
for line in f:
p = list(map(int, line.split()))
min_waiting = None
min_c = None
for i in range(len(c)):
ci = c[i:] +c[:i]
waiting = sum(max(0, p[i] - ci[i]) for i in range(len(c)))
if min_waiting == None or min_waiting > waiting:
min_waiting = waiting
min_c = ci
elif min_waiting == waiting and get_v(min_c) > get_v(ci):
min_c = ci
print(*min_c)
| p00082 |
<H1>メリーゴーランド</H1>
<center>
<img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_10_1">
</center><br/>
<p>
遊園地にあるメリーゴーランドはご存じでしょう。大きな円盤の上に馬や馬車などの乗り物が固定されていて、円盤が回転すると同時に乗り物が上下に揺れる、定番の遊具です。ある遊園地のメリーゴーランドは、４人乗りの馬車が２台、２人乗りの車２台、１人乗りの馬が４台、計８台の乗り物が図１のような順序で備えられています。そして、遊園地においでのお客様は、図１に示す乗り場０〜７のどこかで待つようになっています。
</p>
<center>
<img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_10_2">
</center><br/>
<p>
この遊園地のメリーゴーランドは、かならず乗り物が乗り場にぴったりと合う位置に停止します。そして、０〜７のそれぞれで待っているお客さまは、目の前にとまった乗り物に乗ることになっています。急いで他の乗り場へ移動してそこから乗るということはできません。効率よく、お客さまにたのしんでいただくためには、メリーゴーランドの停止する位置をうまく調整して、乗れないお客さまをできるだけ少なくするようにしなければなりません。
</p>
<p>
乗り場０〜７で待っているお客さまの人数を読み込んで、どの位置にどの乗り物が来るように止めれば乗れないお客さまが最も少なくなるかを出力するプログラムを作成してください。
<!--なお、乗れなくなるお客さまが最小となるとめ方が何通りもある場合は、そのうちの一つだけ出力するようにしてください。-->
</p>
<H2>入力</H2>
<p>
入力は複数のデータセットからなります。各データセットは以下の形式で与えられます。
</p>
<pre>
<var>p<sub>0</sub></var> <var>p<sub>1</sub></var> <var>p<sub>2</sub></var> <var>p<sub>3</sub></var> <var>p<sub>4</sub></var> <var>p<sub>5</sub></var> <var>p<sub>6</sub></var> <var>p<sub>7</sub></var>
</pre>
<p>
乗り場 0, 1, ..., 7 で待っているお客様の人数を表す整数 <var>p<sub>0</sub></var>, <var>p<sub>1</sub></var>,... , <var>p<sub>7</sub></var> ( 0 ≤ <var>p<sub>i</sub></var> ≤ 10,000) が空白区切りで１行に与えられます。
</p>
<H2>出力</H2>
<p>
メリーゴーランドの乗り物の馬車を 4、車を 2、馬を 1 で表すこととします。乗り場 0, 1, ... , 7 にとめる乗り物を、それぞれ <var>c<sub>0</sub></var>, <var>c<sub>1</sub></var>,..., <var>c<sub>7</sub></var> とします。データセットごとに、<var>c<sub>0</sub></var>, <var>c<sub>1</sub></var>,..., <var>c<sub>7</sub></var> を空白区切りで 1 行に出力します。
</p>
<p>
なお、乗れなくなるお客さまが最小となるとめ方が複数ある場合は、<var>c<sub>0</sub>c<sub>1</sub>c<sub>2</sub>c<sub>3</sub>c<sub>4</sub>c<sub>5</sub>c<sub>6</sub>c<sub>7</sub></var> を 8 桁の整数 <var>V</var> とみなし、<var>V</var> が最小となるとめ方を選ぶものとします。
</p>
<p>
データセットの数は 100 を超えません。
</p>
<H2>Sample Input</H2>
<pre>
2 3 1 4 0 1 0 1
4 2 3 2 2 2 1 1
</pre>
<H2>Output for the Sample Input</H2>
<pre>
1 4 1 4 1 2 1 2
4 1 4 1 2 1 2 1
</pre>
| 2 3 1 4 0 1 0 1
4 2 3 2 2 2 1 1
| 1 4 1 4 1 2 1 2
4 1 4 1 2 1 2 1
| 12,156 |
s462810595 | p00082 | u540744789 | 1427870031 | Python | Python | py | Accepted | 20 | 4284 | 1,015 | v=[4,1,4,1,2,1,2,1]
while True:
try:
p=map(int,raw_input().split(" "))
min=[]
min_value=0
for i in range(8):
count=0
for j in range(8):
if p[(j)%8]-v[(j+i)%8]>=0:
count+=p[(j)%8]-v[(j+i)%8]
if len(min)==0:
min_value=count
min.append(i)
else:
if count<min_value:
min_value=count
min=[]
min.append(i)
elif count==min_value:
min.append(i)
min1_value=41412122
for i in range(len(min)):
value=""
for j in range(8):
value+=str(v[(j+min[i])%8])
if min1_value>int(value):
min1_value=int(value)
min1=min[i]
solve=[]
for i in range(8):
solve.append(str(v[(i+min1)%8]))
print " ".join(solve)
except:
break | p00082 |
<H1>メリーゴーランド</H1>
<center>
<img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_10_1">
</center><br/>
<p>
遊園地にあるメリーゴーランドはご存じでしょう。大きな円盤の上に馬や馬車などの乗り物が固定されていて、円盤が回転すると同時に乗り物が上下に揺れる、定番の遊具です。ある遊園地のメリーゴーランドは、４人乗りの馬車が２台、２人乗りの車２台、１人乗りの馬が４台、計８台の乗り物が図１のような順序で備えられています。そして、遊園地においでのお客様は、図１に示す乗り場０〜７のどこかで待つようになっています。
</p>
<center>
<img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_10_2">
</center><br/>
<p>
この遊園地のメリーゴーランドは、かならず乗り物が乗り場にぴったりと合う位置に停止します。そして、０〜７のそれぞれで待っているお客さまは、目の前にとまった乗り物に乗ることになっています。急いで他の乗り場へ移動してそこから乗るということはできません。効率よく、お客さまにたのしんでいただくためには、メリーゴーランドの停止する位置をうまく調整して、乗れないお客さまをできるだけ少なくするようにしなければなりません。
</p>
<p>
乗り場０〜７で待っているお客さまの人数を読み込んで、どの位置にどの乗り物が来るように止めれば乗れないお客さまが最も少なくなるかを出力するプログラムを作成してください。
<!--なお、乗れなくなるお客さまが最小となるとめ方が何通りもある場合は、そのうちの一つだけ出力するようにしてください。-->
</p>
<H2>入力</H2>
<p>
入力は複数のデータセットからなります。各データセットは以下の形式で与えられます。
</p>
<pre>
<var>p<sub>0</sub></var> <var>p<sub>1</sub></var> <var>p<sub>2</sub></var> <var>p<sub>3</sub></var> <var>p<sub>4</sub></var> <var>p<sub>5</sub></var> <var>p<sub>6</sub></var> <var>p<sub>7</sub></var>
</pre>
<p>
乗り場 0, 1, ..., 7 で待っているお客様の人数を表す整数 <var>p<sub>0</sub></var>, <var>p<sub>1</sub></var>,... , <var>p<sub>7</sub></var> ( 0 ≤ <var>p<sub>i</sub></var> ≤ 10,000) が空白区切りで１行に与えられます。
</p>
<H2>出力</H2>
<p>
メリーゴーランドの乗り物の馬車を 4、車を 2、馬を 1 で表すこととします。乗り場 0, 1, ... , 7 にとめる乗り物を、それぞれ <var>c<sub>0</sub></var>, <var>c<sub>1</sub></var>,..., <var>c<sub>7</sub></var> とします。データセットごとに、<var>c<sub>0</sub></var>, <var>c<sub>1</sub></var>,..., <var>c<sub>7</sub></var> を空白区切りで 1 行に出力します。
</p>
<p>
なお、乗れなくなるお客さまが最小となるとめ方が複数ある場合は、<var>c<sub>0</sub>c<sub>1</sub>c<sub>2</sub>c<sub>3</sub>c<sub>4</sub>c<sub>5</sub>c<sub>6</sub>c<sub>7</sub></var> を 8 桁の整数 <var>V</var> とみなし、<var>V</var> が最小となるとめ方を選ぶものとします。
</p>
<p>
データセットの数は 100 を超えません。
</p>
<H2>Sample Input</H2>
<pre>
2 3 1 4 0 1 0 1
4 2 3 2 2 2 1 1
</pre>
<H2>Output for the Sample Input</H2>
<pre>
1 4 1 4 1 2 1 2
4 1 4 1 2 1 2 1
</pre>
| 2 3 1 4 0 1 0 1
4 2 3 2 2 2 1 1
| 1 4 1 4 1 2 1 2
4 1 4 1 2 1 2 1
| 12,157 |
s315817905 | p00082 | u140201022 | 1451486571 | Python | Python | py | Accepted | 20 | 6320 | 543 | m=[4,1,4,1,2,1,2,1]
l=[]
while 1:
try:
c=map(int,raw_input().split())
cnt=[0]*8
for i in range(8):
chk=[m[(i+x)%8] for x in range(8)]
l.append(chk)
for j in range(8):
if c[j]>chk[j]:
cnt[i]+=c[j]-chk[j]
ans=[]
for i in range(8):
if cnt[i]==min(cnt):
ans.append(int(''.join(map(str,l[i]))))
ans.sort()
for i in str(ans[0]):
print i,
print
except:
break | p00082 |
<H1>メリーゴーランド</H1>
<center>
<img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_10_1">
</center><br/>
<p>
遊園地にあるメリーゴーランドはご存じでしょう。大きな円盤の上に馬や馬車などの乗り物が固定されていて、円盤が回転すると同時に乗り物が上下に揺れる、定番の遊具です。ある遊園地のメリーゴーランドは、４人乗りの馬車が２台、２人乗りの車２台、１人乗りの馬が４台、計８台の乗り物が図１のような順序で備えられています。そして、遊園地においでのお客様は、図１に示す乗り場０〜７のどこかで待つようになっています。
</p>
<center>
<img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_10_2">
</center><br/>
<p>
この遊園地のメリーゴーランドは、かならず乗り物が乗り場にぴったりと合う位置に停止します。そして、０〜７のそれぞれで待っているお客さまは、目の前にとまった乗り物に乗ることになっています。急いで他の乗り場へ移動してそこから乗るということはできません。効率よく、お客さまにたのしんでいただくためには、メリーゴーランドの停止する位置をうまく調整して、乗れないお客さまをできるだけ少なくするようにしなければなりません。
</p>
<p>
乗り場０〜７で待っているお客さまの人数を読み込んで、どの位置にどの乗り物が来るように止めれば乗れないお客さまが最も少なくなるかを出力するプログラムを作成してください。
<!--なお、乗れなくなるお客さまが最小となるとめ方が何通りもある場合は、そのうちの一つだけ出力するようにしてください。-->
</p>
<H2>入力</H2>
<p>
入力は複数のデータセットからなります。各データセットは以下の形式で与えられます。
</p>
<pre>
<var>p<sub>0</sub></var> <var>p<sub>1</sub></var> <var>p<sub>2</sub></var> <var>p<sub>3</sub></var> <var>p<sub>4</sub></var> <var>p<sub>5</sub></var> <var>p<sub>6</sub></var> <var>p<sub>7</sub></var>
</pre>
<p>
乗り場 0, 1, ..., 7 で待っているお客様の人数を表す整数 <var>p<sub>0</sub></var>, <var>p<sub>1</sub></var>,... , <var>p<sub>7</sub></var> ( 0 ≤ <var>p<sub>i</sub></var> ≤ 10,000) が空白区切りで１行に与えられます。
</p>
<H2>出力</H2>
<p>
メリーゴーランドの乗り物の馬車を 4、車を 2、馬を 1 で表すこととします。乗り場 0, 1, ... , 7 にとめる乗り物を、それぞれ <var>c<sub>0</sub></var>, <var>c<sub>1</sub></var>,..., <var>c<sub>7</sub></var> とします。データセットごとに、<var>c<sub>0</sub></var>, <var>c<sub>1</sub></var>,..., <var>c<sub>7</sub></var> を空白区切りで 1 行に出力します。
</p>
<p>
なお、乗れなくなるお客さまが最小となるとめ方が複数ある場合は、<var>c<sub>0</sub>c<sub>1</sub>c<sub>2</sub>c<sub>3</sub>c<sub>4</sub>c<sub>5</sub>c<sub>6</sub>c<sub>7</sub></var> を 8 桁の整数 <var>V</var> とみなし、<var>V</var> が最小となるとめ方を選ぶものとします。
</p>
<p>
データセットの数は 100 を超えません。
</p>
<H2>Sample Input</H2>
<pre>
2 3 1 4 0 1 0 1
4 2 3 2 2 2 1 1
</pre>
<H2>Output for the Sample Input</H2>
<pre>
1 4 1 4 1 2 1 2
4 1 4 1 2 1 2 1
</pre>
| 2 3 1 4 0 1 0 1
4 2 3 2 2 2 1 1
| 1 4 1 4 1 2 1 2
4 1 4 1 2 1 2 1
| 12,158 |
s770159713 | p00082 | u462831976 | 1493450070 | Python | Python3 | py | Accepted | 30 | 7776 | 740 | # -*- coding: utf-8 -*-
import sys
import os
import math
for s in sys.stdin:
P = list(map(int, s.split()))
C = [1, 4, 1, 4, 1, 2, 1, 2]
enter_num_max_list = []
enter_num_max = 0
for i in range(8):
# rotate
D = C[i:] + C[:i]
enter_num = 0
for j in range(8):
p = P[j]
capacity = D[j]
if capacity >= p:
enter_num += p
else:
enter_num += capacity
if enter_num > enter_num_max:
enter_num_max = enter_num
enter_num_max_list = [D]
elif enter_num == enter_num_max:
enter_num_max_list.append(D)
enter_num_max_list.sort()
print(*enter_num_max_list[0]) | p00082 |
<H1>メリーゴーランド</H1>
<center>
<img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_10_1">
</center><br/>
<p>
遊園地にあるメリーゴーランドはご存じでしょう。大きな円盤の上に馬や馬車などの乗り物が固定されていて、円盤が回転すると同時に乗り物が上下に揺れる、定番の遊具です。ある遊園地のメリーゴーランドは、４人乗りの馬車が２台、２人乗りの車２台、１人乗りの馬が４台、計８台の乗り物が図１のような順序で備えられています。そして、遊園地においでのお客様は、図１に示す乗り場０〜７のどこかで待つようになっています。
</p>
<center>
<img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_10_2">
</center><br/>
<p>
この遊園地のメリーゴーランドは、かならず乗り物が乗り場にぴったりと合う位置に停止します。そして、０〜７のそれぞれで待っているお客さまは、目の前にとまった乗り物に乗ることになっています。急いで他の乗り場へ移動してそこから乗るということはできません。効率よく、お客さまにたのしんでいただくためには、メリーゴーランドの停止する位置をうまく調整して、乗れないお客さまをできるだけ少なくするようにしなければなりません。
</p>
<p>
乗り場０〜７で待っているお客さまの人数を読み込んで、どの位置にどの乗り物が来るように止めれば乗れないお客さまが最も少なくなるかを出力するプログラムを作成してください。
<!--なお、乗れなくなるお客さまが最小となるとめ方が何通りもある場合は、そのうちの一つだけ出力するようにしてください。-->
</p>
<H2>入力</H2>
<p>
入力は複数のデータセットからなります。各データセットは以下の形式で与えられます。
</p>
<pre>
<var>p<sub>0</sub></var> <var>p<sub>1</sub></var> <var>p<sub>2</sub></var> <var>p<sub>3</sub></var> <var>p<sub>4</sub></var> <var>p<sub>5</sub></var> <var>p<sub>6</sub></var> <var>p<sub>7</sub></var>
</pre>
<p>
乗り場 0, 1, ..., 7 で待っているお客様の人数を表す整数 <var>p<sub>0</sub></var>, <var>p<sub>1</sub></var>,... , <var>p<sub>7</sub></var> ( 0 ≤ <var>p<sub>i</sub></var> ≤ 10,000) が空白区切りで１行に与えられます。
</p>
<H2>出力</H2>
<p>
メリーゴーランドの乗り物の馬車を 4、車を 2、馬を 1 で表すこととします。乗り場 0, 1, ... , 7 にとめる乗り物を、それぞれ <var>c<sub>0</sub></var>, <var>c<sub>1</sub></var>,..., <var>c<sub>7</sub></var> とします。データセットごとに、<var>c<sub>0</sub></var>, <var>c<sub>1</sub></var>,..., <var>c<sub>7</sub></var> を空白区切りで 1 行に出力します。
</p>
<p>
なお、乗れなくなるお客さまが最小となるとめ方が複数ある場合は、<var>c<sub>0</sub>c<sub>1</sub>c<sub>2</sub>c<sub>3</sub>c<sub>4</sub>c<sub>5</sub>c<sub>6</sub>c<sub>7</sub></var> を 8 桁の整数 <var>V</var> とみなし、<var>V</var> が最小となるとめ方を選ぶものとします。
</p>
<p>
データセットの数は 100 を超えません。
</p>
<H2>Sample Input</H2>
<pre>
2 3 1 4 0 1 0 1
4 2 3 2 2 2 1 1
</pre>
<H2>Output for the Sample Input</H2>
<pre>
1 4 1 4 1 2 1 2
4 1 4 1 2 1 2 1
</pre>
| 2 3 1 4 0 1 0 1
4 2 3 2 2 2 1 1
| 1 4 1 4 1 2 1 2
4 1 4 1 2 1 2 1
| 12,159 |
s620630124 | p00082 | u811733736 | 1507467931 | Python | Python3 | py | Accepted | 40 | 8068 | 1,318 | # -*- coding: utf-8 -*-
"""
http://judge.u-aizu.ac.jp/onlinejudge/description.jsp?id=0082
"""
import sys
from sys import stdin
from collections import deque
input = stdin.readline
def calc_remaining(data, carriges):
# ??????????????£????????°?????????
total = 0
for d, c in zip(data, carriges):
if d > c:
total += d - c
return total
def solve(data):
carriges = deque([1, 4, 1, 4, 1, 2, 1, 2])
min_remaining = float('inf')
min_carrige_value = float('inf')
for i in range(8):
remaining = calc_remaining(data, carriges)
if remaining < min_remaining:
min_remaining = remaining
min_carrige_value = int(''.join(map(str, carriges)))
elif remaining == min_remaining:
carrige_value = int(''.join(map(str, carriges)))
if carrige_value < min_carrige_value:
min_carrige_value = carrige_value
carriges.rotate(1)
return min_remaining, min_carrige_value
def main(args):
for line in sys.stdin:
# data = [2, 3, 1, 4, 0, 1, 0, 1]
# data = [4, 2, 3, 2, 2, 2, 1, 1]
data = [int(x) for x in line.split()]
_, result = solve(data)
print(' '.join(map(str, list(str(result)))))
if __name__ == '__main__':
main(sys.argv[1:])
| p00082 |
<H1>メリーゴーランド</H1>
<center>
<img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_10_1">
</center><br/>
<p>
遊園地にあるメリーゴーランドはご存じでしょう。大きな円盤の上に馬や馬車などの乗り物が固定されていて、円盤が回転すると同時に乗り物が上下に揺れる、定番の遊具です。ある遊園地のメリーゴーランドは、４人乗りの馬車が２台、２人乗りの車２台、１人乗りの馬が４台、計８台の乗り物が図１のような順序で備えられています。そして、遊園地においでのお客様は、図１に示す乗り場０〜７のどこかで待つようになっています。
</p>
<center>
<img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_10_2">
</center><br/>
<p>
この遊園地のメリーゴーランドは、かならず乗り物が乗り場にぴったりと合う位置に停止します。そして、０〜７のそれぞれで待っているお客さまは、目の前にとまった乗り物に乗ることになっています。急いで他の乗り場へ移動してそこから乗るということはできません。効率よく、お客さまにたのしんでいただくためには、メリーゴーランドの停止する位置をうまく調整して、乗れないお客さまをできるだけ少なくするようにしなければなりません。
</p>
<p>
乗り場０〜７で待っているお客さまの人数を読み込んで、どの位置にどの乗り物が来るように止めれば乗れないお客さまが最も少なくなるかを出力するプログラムを作成してください。
<!--なお、乗れなくなるお客さまが最小となるとめ方が何通りもある場合は、そのうちの一つだけ出力するようにしてください。-->
</p>
<H2>入力</H2>
<p>
入力は複数のデータセットからなります。各データセットは以下の形式で与えられます。
</p>
<pre>
<var>p<sub>0</sub></var> <var>p<sub>1</sub></var> <var>p<sub>2</sub></var> <var>p<sub>3</sub></var> <var>p<sub>4</sub></var> <var>p<sub>5</sub></var> <var>p<sub>6</sub></var> <var>p<sub>7</sub></var>
</pre>
<p>
乗り場 0, 1, ..., 7 で待っているお客様の人数を表す整数 <var>p<sub>0</sub></var>, <var>p<sub>1</sub></var>,... , <var>p<sub>7</sub></var> ( 0 ≤ <var>p<sub>i</sub></var> ≤ 10,000) が空白区切りで１行に与えられます。
</p>
<H2>出力</H2>
<p>
メリーゴーランドの乗り物の馬車を 4、車を 2、馬を 1 で表すこととします。乗り場 0, 1, ... , 7 にとめる乗り物を、それぞれ <var>c<sub>0</sub></var>, <var>c<sub>1</sub></var>,..., <var>c<sub>7</sub></var> とします。データセットごとに、<var>c<sub>0</sub></var>, <var>c<sub>1</sub></var>,..., <var>c<sub>7</sub></var> を空白区切りで 1 行に出力します。
</p>
<p>
なお、乗れなくなるお客さまが最小となるとめ方が複数ある場合は、<var>c<sub>0</sub>c<sub>1</sub>c<sub>2</sub>c<sub>3</sub>c<sub>4</sub>c<sub>5</sub>c<sub>6</sub>c<sub>7</sub></var> を 8 桁の整数 <var>V</var> とみなし、<var>V</var> が最小となるとめ方を選ぶものとします。
</p>
<p>
データセットの数は 100 を超えません。
</p>
<H2>Sample Input</H2>
<pre>
2 3 1 4 0 1 0 1
4 2 3 2 2 2 1 1
</pre>
<H2>Output for the Sample Input</H2>
<pre>
1 4 1 4 1 2 1 2
4 1 4 1 2 1 2 1
</pre>
| 2 3 1 4 0 1 0 1
4 2 3 2 2 2 1 1
| 1 4 1 4 1 2 1 2
4 1 4 1 2 1 2 1
| 12,160 |
s195703643 | p00082 | u024715419 | 1519370987 | Python | Python3 | py | Accepted | 30 | 5608 | 687 | c = [4,1,4,1,2,1,2,1,4,1,4,1,2,1,2,1]
while True:
try:
p = list(map(int, input().split()))
c_tmp = 41412121
s_min = 100000
for i in range(8):
s = 0
for j in range(8):
p_rest = p[j] - c[i + j] if p[j] - c[i + j] > 0 else 0
s += p_rest
if s == s_min and c_tmp > int("".join(map(str, c[i:i + 8]))):
c_tmp = int("".join(map(str, c[i:i + 8])))
ans = i
elif s < s_min:
s_min = s
c_tmp = int("".join(map(str, c[i:i + 8])))
ans = i
print(*c[ans:ans + 8])
except:
break
| p00082 |
<H1>メリーゴーランド</H1>
<center>
<img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_10_1">
</center><br/>
<p>
遊園地にあるメリーゴーランドはご存じでしょう。大きな円盤の上に馬や馬車などの乗り物が固定されていて、円盤が回転すると同時に乗り物が上下に揺れる、定番の遊具です。ある遊園地のメリーゴーランドは、４人乗りの馬車が２台、２人乗りの車２台、１人乗りの馬が４台、計８台の乗り物が図１のような順序で備えられています。そして、遊園地においでのお客様は、図１に示す乗り場０〜７のどこかで待つようになっています。
</p>
<center>
<img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_10_2">
</center><br/>
<p>
この遊園地のメリーゴーランドは、かならず乗り物が乗り場にぴったりと合う位置に停止します。そして、０〜７のそれぞれで待っているお客さまは、目の前にとまった乗り物に乗ることになっています。急いで他の乗り場へ移動してそこから乗るということはできません。効率よく、お客さまにたのしんでいただくためには、メリーゴーランドの停止する位置をうまく調整して、乗れないお客さまをできるだけ少なくするようにしなければなりません。
</p>
<p>
乗り場０〜７で待っているお客さまの人数を読み込んで、どの位置にどの乗り物が来るように止めれば乗れないお客さまが最も少なくなるかを出力するプログラムを作成してください。
<!--なお、乗れなくなるお客さまが最小となるとめ方が何通りもある場合は、そのうちの一つだけ出力するようにしてください。-->
</p>
<H2>入力</H2>
<p>
入力は複数のデータセットからなります。各データセットは以下の形式で与えられます。
</p>
<pre>
<var>p<sub>0</sub></var> <var>p<sub>1</sub></var> <var>p<sub>2</sub></var> <var>p<sub>3</sub></var> <var>p<sub>4</sub></var> <var>p<sub>5</sub></var> <var>p<sub>6</sub></var> <var>p<sub>7</sub></var>
</pre>
<p>
乗り場 0, 1, ..., 7 で待っているお客様の人数を表す整数 <var>p<sub>0</sub></var>, <var>p<sub>1</sub></var>,... , <var>p<sub>7</sub></var> ( 0 ≤ <var>p<sub>i</sub></var> ≤ 10,000) が空白区切りで１行に与えられます。
</p>
<H2>出力</H2>
<p>
メリーゴーランドの乗り物の馬車を 4、車を 2、馬を 1 で表すこととします。乗り場 0, 1, ... , 7 にとめる乗り物を、それぞれ <var>c<sub>0</sub></var>, <var>c<sub>1</sub></var>,..., <var>c<sub>7</sub></var> とします。データセットごとに、<var>c<sub>0</sub></var>, <var>c<sub>1</sub></var>,..., <var>c<sub>7</sub></var> を空白区切りで 1 行に出力します。
</p>
<p>
なお、乗れなくなるお客さまが最小となるとめ方が複数ある場合は、<var>c<sub>0</sub>c<sub>1</sub>c<sub>2</sub>c<sub>3</sub>c<sub>4</sub>c<sub>5</sub>c<sub>6</sub>c<sub>7</sub></var> を 8 桁の整数 <var>V</var> とみなし、<var>V</var> が最小となるとめ方を選ぶものとします。
</p>
<p>
データセットの数は 100 を超えません。
</p>
<H2>Sample Input</H2>
<pre>
2 3 1 4 0 1 0 1
4 2 3 2 2 2 1 1
</pre>
<H2>Output for the Sample Input</H2>
<pre>
1 4 1 4 1 2 1 2
4 1 4 1 2 1 2 1
</pre>
| 2 3 1 4 0 1 0 1
4 2 3 2 2 2 1 1
| 1 4 1 4 1 2 1 2
4 1 4 1 2 1 2 1
| 12,161 |
s947162898 | p00082 | u043254318 | 1519653386 | Python | Python3 | py | Accepted | 30 | 5728 | 770 | def get_input():
while True:
try:
yield ''.join(input())
except EOFError:
break
N = list(get_input())
for l in range(len(N)):
c = [4, 1, 4, 1, 2, 1, 2, 1]
p = [int(i) for i in N[l].split()]
for i in range(len(p)):
if p[i] > 9:
p[i] = 9
V = 99999999
score = 99999
for d in range(8):
s = 0
for i in range(8):
s += max(p[i] - c[(i+d)%8], 0)
v = 0
for i in range(8):
v *= 10
v += c[(i+d)%8]
if s < score:
score = s
V = v
elif s == score:
if v < V:
V = v
ans = str(V)
for i in range(7):
print(ans[i], end=" ")
print(ans[7])
| p00082 |
<H1>メリーゴーランド</H1>
<center>
<img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_10_1">
</center><br/>
<p>
遊園地にあるメリーゴーランドはご存じでしょう。大きな円盤の上に馬や馬車などの乗り物が固定されていて、円盤が回転すると同時に乗り物が上下に揺れる、定番の遊具です。ある遊園地のメリーゴーランドは、４人乗りの馬車が２台、２人乗りの車２台、１人乗りの馬が４台、計８台の乗り物が図１のような順序で備えられています。そして、遊園地においでのお客様は、図１に示す乗り場０〜７のどこかで待つようになっています。
</p>
<center>
<img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_10_2">
</center><br/>
<p>
この遊園地のメリーゴーランドは、かならず乗り物が乗り場にぴったりと合う位置に停止します。そして、０〜７のそれぞれで待っているお客さまは、目の前にとまった乗り物に乗ることになっています。急いで他の乗り場へ移動してそこから乗るということはできません。効率よく、お客さまにたのしんでいただくためには、メリーゴーランドの停止する位置をうまく調整して、乗れないお客さまをできるだけ少なくするようにしなければなりません。
</p>
<p>
乗り場０〜７で待っているお客さまの人数を読み込んで、どの位置にどの乗り物が来るように止めれば乗れないお客さまが最も少なくなるかを出力するプログラムを作成してください。
<!--なお、乗れなくなるお客さまが最小となるとめ方が何通りもある場合は、そのうちの一つだけ出力するようにしてください。-->
</p>
<H2>入力</H2>
<p>
入力は複数のデータセットからなります。各データセットは以下の形式で与えられます。
</p>
<pre>
<var>p<sub>0</sub></var> <var>p<sub>1</sub></var> <var>p<sub>2</sub></var> <var>p<sub>3</sub></var> <var>p<sub>4</sub></var> <var>p<sub>5</sub></var> <var>p<sub>6</sub></var> <var>p<sub>7</sub></var>
</pre>
<p>
乗り場 0, 1, ..., 7 で待っているお客様の人数を表す整数 <var>p<sub>0</sub></var>, <var>p<sub>1</sub></var>,... , <var>p<sub>7</sub></var> ( 0 ≤ <var>p<sub>i</sub></var> ≤ 10,000) が空白区切りで１行に与えられます。
</p>
<H2>出力</H2>
<p>
メリーゴーランドの乗り物の馬車を 4、車を 2、馬を 1 で表すこととします。乗り場 0, 1, ... , 7 にとめる乗り物を、それぞれ <var>c<sub>0</sub></var>, <var>c<sub>1</sub></var>,..., <var>c<sub>7</sub></var> とします。データセットごとに、<var>c<sub>0</sub></var>, <var>c<sub>1</sub></var>,..., <var>c<sub>7</sub></var> を空白区切りで 1 行に出力します。
</p>
<p>
なお、乗れなくなるお客さまが最小となるとめ方が複数ある場合は、<var>c<sub>0</sub>c<sub>1</sub>c<sub>2</sub>c<sub>3</sub>c<sub>4</sub>c<sub>5</sub>c<sub>6</sub>c<sub>7</sub></var> を 8 桁の整数 <var>V</var> とみなし、<var>V</var> が最小となるとめ方を選ぶものとします。
</p>
<p>
データセットの数は 100 を超えません。
</p>
<H2>Sample Input</H2>
<pre>
2 3 1 4 0 1 0 1
4 2 3 2 2 2 1 1
</pre>
<H2>Output for the Sample Input</H2>
<pre>
1 4 1 4 1 2 1 2
4 1 4 1 2 1 2 1
</pre>
| 2 3 1 4 0 1 0 1
4 2 3 2 2 2 1 1
| 1 4 1 4 1 2 1 2
4 1 4 1 2 1 2 1
| 12,162 |
s133223095 | p00082 | u306037418 | 1524738985 | Python | Python3 | py | Accepted | 30 | 5608 | 714 | import sys
for line in sys.stdin:
p = list(map(int, line.split()))
car = [4, 1, 4, 1, 2, 1, 2, 1, 4, 1, 4, 1, 2, 1, 2, 1]
ans_d = 10**9
ans = -1
for i in range(8):
now_d = 0
for j in range(8):
now_d += abs(p[j] - car[i+j])
if ans_d > now_d:
ans_d = now_d
ans = car[i:i+8]
elif ans_d == now_d:
ans_s, now_s = '', ''
for k in ans:
ans_s += str(k)
for k in car[i:i+8]:
now_s += str(k)
if int(ans_s) > int(now_s):
ans_d = now_d
ans = car[i:i+8]
t = ''
for i in ans:
t += str(i) + ' '
print(t[:-1])
| p00082 |
<H1>メリーゴーランド</H1>
<center>
<img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_10_1">
</center><br/>
<p>
遊園地にあるメリーゴーランドはご存じでしょう。大きな円盤の上に馬や馬車などの乗り物が固定されていて、円盤が回転すると同時に乗り物が上下に揺れる、定番の遊具です。ある遊園地のメリーゴーランドは、４人乗りの馬車が２台、２人乗りの車２台、１人乗りの馬が４台、計８台の乗り物が図１のような順序で備えられています。そして、遊園地においでのお客様は、図１に示す乗り場０〜７のどこかで待つようになっています。
</p>
<center>
<img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_10_2">
</center><br/>
<p>
この遊園地のメリーゴーランドは、かならず乗り物が乗り場にぴったりと合う位置に停止します。そして、０〜７のそれぞれで待っているお客さまは、目の前にとまった乗り物に乗ることになっています。急いで他の乗り場へ移動してそこから乗るということはできません。効率よく、お客さまにたのしんでいただくためには、メリーゴーランドの停止する位置をうまく調整して、乗れないお客さまをできるだけ少なくするようにしなければなりません。
</p>
<p>
乗り場０〜７で待っているお客さまの人数を読み込んで、どの位置にどの乗り物が来るように止めれば乗れないお客さまが最も少なくなるかを出力するプログラムを作成してください。
<!--なお、乗れなくなるお客さまが最小となるとめ方が何通りもある場合は、そのうちの一つだけ出力するようにしてください。-->
</p>
<H2>入力</H2>
<p>
入力は複数のデータセットからなります。各データセットは以下の形式で与えられます。
</p>
<pre>
<var>p<sub>0</sub></var> <var>p<sub>1</sub></var> <var>p<sub>2</sub></var> <var>p<sub>3</sub></var> <var>p<sub>4</sub></var> <var>p<sub>5</sub></var> <var>p<sub>6</sub></var> <var>p<sub>7</sub></var>
</pre>
<p>
乗り場 0, 1, ..., 7 で待っているお客様の人数を表す整数 <var>p<sub>0</sub></var>, <var>p<sub>1</sub></var>,... , <var>p<sub>7</sub></var> ( 0 ≤ <var>p<sub>i</sub></var> ≤ 10,000) が空白区切りで１行に与えられます。
</p>
<H2>出力</H2>
<p>
メリーゴーランドの乗り物の馬車を 4、車を 2、馬を 1 で表すこととします。乗り場 0, 1, ... , 7 にとめる乗り物を、それぞれ <var>c<sub>0</sub></var>, <var>c<sub>1</sub></var>,..., <var>c<sub>7</sub></var> とします。データセットごとに、<var>c<sub>0</sub></var>, <var>c<sub>1</sub></var>,..., <var>c<sub>7</sub></var> を空白区切りで 1 行に出力します。
</p>
<p>
なお、乗れなくなるお客さまが最小となるとめ方が複数ある場合は、<var>c<sub>0</sub>c<sub>1</sub>c<sub>2</sub>c<sub>3</sub>c<sub>4</sub>c<sub>5</sub>c<sub>6</sub>c<sub>7</sub></var> を 8 桁の整数 <var>V</var> とみなし、<var>V</var> が最小となるとめ方を選ぶものとします。
</p>
<p>
データセットの数は 100 を超えません。
</p>
<H2>Sample Input</H2>
<pre>
2 3 1 4 0 1 0 1
4 2 3 2 2 2 1 1
</pre>
<H2>Output for the Sample Input</H2>
<pre>
1 4 1 4 1 2 1 2
4 1 4 1 2 1 2 1
</pre>
| 2 3 1 4 0 1 0 1
4 2 3 2 2 2 1 1
| 1 4 1 4 1 2 1 2
4 1 4 1 2 1 2 1
| 12,163 |
s573452833 | p00082 | u150984829 | 1525265212 | Python | Python3 | py | Accepted | 40 | 5724 | 248 | import sys
p=['41412121','41212141','21414121','21214141','14141212','14121214','12141412','12121414']
g=lambda x:list(map(int,x))
for e in sys.stdin:
d={}
for f in p:d[sum(s-t for s,t in zip(g(e.split()),g(f))if s>t)]=f
print(*list(d[min(d)]))
| p00082 |
<H1>メリーゴーランド</H1>
<center>
<img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_10_1">
</center><br/>
<p>
遊園地にあるメリーゴーランドはご存じでしょう。大きな円盤の上に馬や馬車などの乗り物が固定されていて、円盤が回転すると同時に乗り物が上下に揺れる、定番の遊具です。ある遊園地のメリーゴーランドは、４人乗りの馬車が２台、２人乗りの車２台、１人乗りの馬が４台、計８台の乗り物が図１のような順序で備えられています。そして、遊園地においでのお客様は、図１に示す乗り場０〜７のどこかで待つようになっています。
</p>
<center>
<img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_10_2">
</center><br/>
<p>
この遊園地のメリーゴーランドは、かならず乗り物が乗り場にぴったりと合う位置に停止します。そして、０〜７のそれぞれで待っているお客さまは、目の前にとまった乗り物に乗ることになっています。急いで他の乗り場へ移動してそこから乗るということはできません。効率よく、お客さまにたのしんでいただくためには、メリーゴーランドの停止する位置をうまく調整して、乗れないお客さまをできるだけ少なくするようにしなければなりません。
</p>
<p>
乗り場０〜７で待っているお客さまの人数を読み込んで、どの位置にどの乗り物が来るように止めれば乗れないお客さまが最も少なくなるかを出力するプログラムを作成してください。
<!--なお、乗れなくなるお客さまが最小となるとめ方が何通りもある場合は、そのうちの一つだけ出力するようにしてください。-->
</p>
<H2>入力</H2>
<p>
入力は複数のデータセットからなります。各データセットは以下の形式で与えられます。
</p>
<pre>
<var>p<sub>0</sub></var> <var>p<sub>1</sub></var> <var>p<sub>2</sub></var> <var>p<sub>3</sub></var> <var>p<sub>4</sub></var> <var>p<sub>5</sub></var> <var>p<sub>6</sub></var> <var>p<sub>7</sub></var>
</pre>
<p>
乗り場 0, 1, ..., 7 で待っているお客様の人数を表す整数 <var>p<sub>0</sub></var>, <var>p<sub>1</sub></var>,... , <var>p<sub>7</sub></var> ( 0 ≤ <var>p<sub>i</sub></var> ≤ 10,000) が空白区切りで１行に与えられます。
</p>
<H2>出力</H2>
<p>
メリーゴーランドの乗り物の馬車を 4、車を 2、馬を 1 で表すこととします。乗り場 0, 1, ... , 7 にとめる乗り物を、それぞれ <var>c<sub>0</sub></var>, <var>c<sub>1</sub></var>,..., <var>c<sub>7</sub></var> とします。データセットごとに、<var>c<sub>0</sub></var>, <var>c<sub>1</sub></var>,..., <var>c<sub>7</sub></var> を空白区切りで 1 行に出力します。
</p>
<p>
なお、乗れなくなるお客さまが最小となるとめ方が複数ある場合は、<var>c<sub>0</sub>c<sub>1</sub>c<sub>2</sub>c<sub>3</sub>c<sub>4</sub>c<sub>5</sub>c<sub>6</sub>c<sub>7</sub></var> を 8 桁の整数 <var>V</var> とみなし、<var>V</var> が最小となるとめ方を選ぶものとします。
</p>
<p>
データセットの数は 100 を超えません。
</p>
<H2>Sample Input</H2>
<pre>
2 3 1 4 0 1 0 1
4 2 3 2 2 2 1 1
</pre>
<H2>Output for the Sample Input</H2>
<pre>
1 4 1 4 1 2 1 2
4 1 4 1 2 1 2 1
</pre>
| 2 3 1 4 0 1 0 1
4 2 3 2 2 2 1 1
| 1 4 1 4 1 2 1 2
4 1 4 1 2 1 2 1
| 12,164 |
s611780657 | p00082 | u150984829 | 1525265224 | Python | Python3 | py | Accepted | 40 | 5732 | 248 | import sys
p=['41412121','41212141','21414121','21214141','14141212','14121214','12141412','12121414']
g=lambda x:list(map(int,x))
for e in sys.stdin:
d={}
for f in p:d[sum(s-t for s,t in zip(g(e.split()),g(f))if s>t)]=f
print(*list(d[min(d)]))
| p00082 |
<H1>メリーゴーランド</H1>
<center>
<img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_10_1">
</center><br/>
<p>
遊園地にあるメリーゴーランドはご存じでしょう。大きな円盤の上に馬や馬車などの乗り物が固定されていて、円盤が回転すると同時に乗り物が上下に揺れる、定番の遊具です。ある遊園地のメリーゴーランドは、４人乗りの馬車が２台、２人乗りの車２台、１人乗りの馬が４台、計８台の乗り物が図１のような順序で備えられています。そして、遊園地においでのお客様は、図１に示す乗り場０〜７のどこかで待つようになっています。
</p>
<center>
<img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_10_2">
</center><br/>
<p>
この遊園地のメリーゴーランドは、かならず乗り物が乗り場にぴったりと合う位置に停止します。そして、０〜７のそれぞれで待っているお客さまは、目の前にとまった乗り物に乗ることになっています。急いで他の乗り場へ移動してそこから乗るということはできません。効率よく、お客さまにたのしんでいただくためには、メリーゴーランドの停止する位置をうまく調整して、乗れないお客さまをできるだけ少なくするようにしなければなりません。
</p>
<p>
乗り場０〜７で待っているお客さまの人数を読み込んで、どの位置にどの乗り物が来るように止めれば乗れないお客さまが最も少なくなるかを出力するプログラムを作成してください。
<!--なお、乗れなくなるお客さまが最小となるとめ方が何通りもある場合は、そのうちの一つだけ出力するようにしてください。-->
</p>
<H2>入力</H2>
<p>
入力は複数のデータセットからなります。各データセットは以下の形式で与えられます。
</p>
<pre>
<var>p<sub>0</sub></var> <var>p<sub>1</sub></var> <var>p<sub>2</sub></var> <var>p<sub>3</sub></var> <var>p<sub>4</sub></var> <var>p<sub>5</sub></var> <var>p<sub>6</sub></var> <var>p<sub>7</sub></var>
</pre>
<p>
乗り場 0, 1, ..., 7 で待っているお客様の人数を表す整数 <var>p<sub>0</sub></var>, <var>p<sub>1</sub></var>,... , <var>p<sub>7</sub></var> ( 0 ≤ <var>p<sub>i</sub></var> ≤ 10,000) が空白区切りで１行に与えられます。
</p>
<H2>出力</H2>
<p>
メリーゴーランドの乗り物の馬車を 4、車を 2、馬を 1 で表すこととします。乗り場 0, 1, ... , 7 にとめる乗り物を、それぞれ <var>c<sub>0</sub></var>, <var>c<sub>1</sub></var>,..., <var>c<sub>7</sub></var> とします。データセットごとに、<var>c<sub>0</sub></var>, <var>c<sub>1</sub></var>,..., <var>c<sub>7</sub></var> を空白区切りで 1 行に出力します。
</p>
<p>
なお、乗れなくなるお客さまが最小となるとめ方が複数ある場合は、<var>c<sub>0</sub>c<sub>1</sub>c<sub>2</sub>c<sub>3</sub>c<sub>4</sub>c<sub>5</sub>c<sub>6</sub>c<sub>7</sub></var> を 8 桁の整数 <var>V</var> とみなし、<var>V</var> が最小となるとめ方を選ぶものとします。
</p>
<p>
データセットの数は 100 を超えません。
</p>
<H2>Sample Input</H2>
<pre>
2 3 1 4 0 1 0 1
4 2 3 2 2 2 1 1
</pre>
<H2>Output for the Sample Input</H2>
<pre>
1 4 1 4 1 2 1 2
4 1 4 1 2 1 2 1
</pre>
| 2 3 1 4 0 1 0 1
4 2 3 2 2 2 1 1
| 1 4 1 4 1 2 1 2
4 1 4 1 2 1 2 1
| 12,165 |
s945046474 | p00082 | u150984829 | 1525265227 | Python | Python3 | py | Accepted | 40 | 5724 | 248 | import sys
p=['41412121','41212141','21414121','21214141','14141212','14121214','12141412','12121414']
g=lambda x:list(map(int,x))
for e in sys.stdin:
d={}
for f in p:d[sum(s-t for s,t in zip(g(e.split()),g(f))if s>t)]=f
print(*list(d[min(d)]))
| p00082 |
<H1>メリーゴーランド</H1>
<center>
<img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_10_1">
</center><br/>
<p>
遊園地にあるメリーゴーランドはご存じでしょう。大きな円盤の上に馬や馬車などの乗り物が固定されていて、円盤が回転すると同時に乗り物が上下に揺れる、定番の遊具です。ある遊園地のメリーゴーランドは、４人乗りの馬車が２台、２人乗りの車２台、１人乗りの馬が４台、計８台の乗り物が図１のような順序で備えられています。そして、遊園地においでのお客様は、図１に示す乗り場０〜７のどこかで待つようになっています。
</p>
<center>
<img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_10_2">
</center><br/>
<p>
この遊園地のメリーゴーランドは、かならず乗り物が乗り場にぴったりと合う位置に停止します。そして、０〜７のそれぞれで待っているお客さまは、目の前にとまった乗り物に乗ることになっています。急いで他の乗り場へ移動してそこから乗るということはできません。効率よく、お客さまにたのしんでいただくためには、メリーゴーランドの停止する位置をうまく調整して、乗れないお客さまをできるだけ少なくするようにしなければなりません。
</p>
<p>
乗り場０〜７で待っているお客さまの人数を読み込んで、どの位置にどの乗り物が来るように止めれば乗れないお客さまが最も少なくなるかを出力するプログラムを作成してください。
<!--なお、乗れなくなるお客さまが最小となるとめ方が何通りもある場合は、そのうちの一つだけ出力するようにしてください。-->
</p>
<H2>入力</H2>
<p>
入力は複数のデータセットからなります。各データセットは以下の形式で与えられます。
</p>
<pre>
<var>p<sub>0</sub></var> <var>p<sub>1</sub></var> <var>p<sub>2</sub></var> <var>p<sub>3</sub></var> <var>p<sub>4</sub></var> <var>p<sub>5</sub></var> <var>p<sub>6</sub></var> <var>p<sub>7</sub></var>
</pre>
<p>
乗り場 0, 1, ..., 7 で待っているお客様の人数を表す整数 <var>p<sub>0</sub></var>, <var>p<sub>1</sub></var>,... , <var>p<sub>7</sub></var> ( 0 ≤ <var>p<sub>i</sub></var> ≤ 10,000) が空白区切りで１行に与えられます。
</p>
<H2>出力</H2>
<p>
メリーゴーランドの乗り物の馬車を 4、車を 2、馬を 1 で表すこととします。乗り場 0, 1, ... , 7 にとめる乗り物を、それぞれ <var>c<sub>0</sub></var>, <var>c<sub>1</sub></var>,..., <var>c<sub>7</sub></var> とします。データセットごとに、<var>c<sub>0</sub></var>, <var>c<sub>1</sub></var>,..., <var>c<sub>7</sub></var> を空白区切りで 1 行に出力します。
</p>
<p>
なお、乗れなくなるお客さまが最小となるとめ方が複数ある場合は、<var>c<sub>0</sub>c<sub>1</sub>c<sub>2</sub>c<sub>3</sub>c<sub>4</sub>c<sub>5</sub>c<sub>6</sub>c<sub>7</sub></var> を 8 桁の整数 <var>V</var> とみなし、<var>V</var> が最小となるとめ方を選ぶものとします。
</p>
<p>
データセットの数は 100 を超えません。
</p>
<H2>Sample Input</H2>
<pre>
2 3 1 4 0 1 0 1
4 2 3 2 2 2 1 1
</pre>
<H2>Output for the Sample Input</H2>
<pre>
1 4 1 4 1 2 1 2
4 1 4 1 2 1 2 1
</pre>
| 2 3 1 4 0 1 0 1
4 2 3 2 2 2 1 1
| 1 4 1 4 1 2 1 2
4 1 4 1 2 1 2 1
| 12,166 |
s006529030 | p00082 | u150984829 | 1525265229 | Python | Python3 | py | Accepted | 30 | 5728 | 248 | import sys
p=['41412121','41212141','21414121','21214141','14141212','14121214','12141412','12121414']
g=lambda x:list(map(int,x))
for e in sys.stdin:
d={}
for f in p:d[sum(s-t for s,t in zip(g(e.split()),g(f))if s>t)]=f
print(*list(d[min(d)]))
| p00082 |
<H1>メリーゴーランド</H1>
<center>
<img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_10_1">
</center><br/>
<p>
遊園地にあるメリーゴーランドはご存じでしょう。大きな円盤の上に馬や馬車などの乗り物が固定されていて、円盤が回転すると同時に乗り物が上下に揺れる、定番の遊具です。ある遊園地のメリーゴーランドは、４人乗りの馬車が２台、２人乗りの車２台、１人乗りの馬が４台、計８台の乗り物が図１のような順序で備えられています。そして、遊園地においでのお客様は、図１に示す乗り場０〜７のどこかで待つようになっています。
</p>
<center>
<img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_10_2">
</center><br/>
<p>
この遊園地のメリーゴーランドは、かならず乗り物が乗り場にぴったりと合う位置に停止します。そして、０〜７のそれぞれで待っているお客さまは、目の前にとまった乗り物に乗ることになっています。急いで他の乗り場へ移動してそこから乗るということはできません。効率よく、お客さまにたのしんでいただくためには、メリーゴーランドの停止する位置をうまく調整して、乗れないお客さまをできるだけ少なくするようにしなければなりません。
</p>
<p>
乗り場０〜７で待っているお客さまの人数を読み込んで、どの位置にどの乗り物が来るように止めれば乗れないお客さまが最も少なくなるかを出力するプログラムを作成してください。
<!--なお、乗れなくなるお客さまが最小となるとめ方が何通りもある場合は、そのうちの一つだけ出力するようにしてください。-->
</p>
<H2>入力</H2>
<p>
入力は複数のデータセットからなります。各データセットは以下の形式で与えられます。
</p>
<pre>
<var>p<sub>0</sub></var> <var>p<sub>1</sub></var> <var>p<sub>2</sub></var> <var>p<sub>3</sub></var> <var>p<sub>4</sub></var> <var>p<sub>5</sub></var> <var>p<sub>6</sub></var> <var>p<sub>7</sub></var>
</pre>
<p>
乗り場 0, 1, ..., 7 で待っているお客様の人数を表す整数 <var>p<sub>0</sub></var>, <var>p<sub>1</sub></var>,... , <var>p<sub>7</sub></var> ( 0 ≤ <var>p<sub>i</sub></var> ≤ 10,000) が空白区切りで１行に与えられます。
</p>
<H2>出力</H2>
<p>
メリーゴーランドの乗り物の馬車を 4、車を 2、馬を 1 で表すこととします。乗り場 0, 1, ... , 7 にとめる乗り物を、それぞれ <var>c<sub>0</sub></var>, <var>c<sub>1</sub></var>,..., <var>c<sub>7</sub></var> とします。データセットごとに、<var>c<sub>0</sub></var>, <var>c<sub>1</sub></var>,..., <var>c<sub>7</sub></var> を空白区切りで 1 行に出力します。
</p>
<p>
なお、乗れなくなるお客さまが最小となるとめ方が複数ある場合は、<var>c<sub>0</sub>c<sub>1</sub>c<sub>2</sub>c<sub>3</sub>c<sub>4</sub>c<sub>5</sub>c<sub>6</sub>c<sub>7</sub></var> を 8 桁の整数 <var>V</var> とみなし、<var>V</var> が最小となるとめ方を選ぶものとします。
</p>
<p>
データセットの数は 100 を超えません。
</p>
<H2>Sample Input</H2>
<pre>
2 3 1 4 0 1 0 1
4 2 3 2 2 2 1 1
</pre>
<H2>Output for the Sample Input</H2>
<pre>
1 4 1 4 1 2 1 2
4 1 4 1 2 1 2 1
</pre>
| 2 3 1 4 0 1 0 1
4 2 3 2 2 2 1 1
| 1 4 1 4 1 2 1 2
4 1 4 1 2 1 2 1
| 12,167 |
s911831311 | p00082 | u150984829 | 1525265303 | Python | Python3 | py | Accepted | 30 | 5724 | 232 | import sys
p=['41412121','41212141','21414121','21214141','14141212','14121214','12141412','12121414']
for e in sys.stdin:
d={}
for f in p:d[sum(s-t for s,t in zip(map(int,e.split()),map(int,f))if s>t)]=f
print(*list(d[min(d)]))
| p00082 |
<H1>メリーゴーランド</H1>
<center>
<img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_10_1">
</center><br/>
<p>
遊園地にあるメリーゴーランドはご存じでしょう。大きな円盤の上に馬や馬車などの乗り物が固定されていて、円盤が回転すると同時に乗り物が上下に揺れる、定番の遊具です。ある遊園地のメリーゴーランドは、４人乗りの馬車が２台、２人乗りの車２台、１人乗りの馬が４台、計８台の乗り物が図１のような順序で備えられています。そして、遊園地においでのお客様は、図１に示す乗り場０〜７のどこかで待つようになっています。
</p>
<center>
<img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_10_2">
</center><br/>
<p>
この遊園地のメリーゴーランドは、かならず乗り物が乗り場にぴったりと合う位置に停止します。そして、０〜７のそれぞれで待っているお客さまは、目の前にとまった乗り物に乗ることになっています。急いで他の乗り場へ移動してそこから乗るということはできません。効率よく、お客さまにたのしんでいただくためには、メリーゴーランドの停止する位置をうまく調整して、乗れないお客さまをできるだけ少なくするようにしなければなりません。
</p>
<p>
乗り場０〜７で待っているお客さまの人数を読み込んで、どの位置にどの乗り物が来るように止めれば乗れないお客さまが最も少なくなるかを出力するプログラムを作成してください。
<!--なお、乗れなくなるお客さまが最小となるとめ方が何通りもある場合は、そのうちの一つだけ出力するようにしてください。-->
</p>
<H2>入力</H2>
<p>
入力は複数のデータセットからなります。各データセットは以下の形式で与えられます。
</p>
<pre>
<var>p<sub>0</sub></var> <var>p<sub>1</sub></var> <var>p<sub>2</sub></var> <var>p<sub>3</sub></var> <var>p<sub>4</sub></var> <var>p<sub>5</sub></var> <var>p<sub>6</sub></var> <var>p<sub>7</sub></var>
</pre>
<p>
乗り場 0, 1, ..., 7 で待っているお客様の人数を表す整数 <var>p<sub>0</sub></var>, <var>p<sub>1</sub></var>,... , <var>p<sub>7</sub></var> ( 0 ≤ <var>p<sub>i</sub></var> ≤ 10,000) が空白区切りで１行に与えられます。
</p>
<H2>出力</H2>
<p>
メリーゴーランドの乗り物の馬車を 4、車を 2、馬を 1 で表すこととします。乗り場 0, 1, ... , 7 にとめる乗り物を、それぞれ <var>c<sub>0</sub></var>, <var>c<sub>1</sub></var>,..., <var>c<sub>7</sub></var> とします。データセットごとに、<var>c<sub>0</sub></var>, <var>c<sub>1</sub></var>,..., <var>c<sub>7</sub></var> を空白区切りで 1 行に出力します。
</p>
<p>
なお、乗れなくなるお客さまが最小となるとめ方が複数ある場合は、<var>c<sub>0</sub>c<sub>1</sub>c<sub>2</sub>c<sub>3</sub>c<sub>4</sub>c<sub>5</sub>c<sub>6</sub>c<sub>7</sub></var> を 8 桁の整数 <var>V</var> とみなし、<var>V</var> が最小となるとめ方を選ぶものとします。
</p>
<p>
データセットの数は 100 を超えません。
</p>
<H2>Sample Input</H2>
<pre>
2 3 1 4 0 1 0 1
4 2 3 2 2 2 1 1
</pre>
<H2>Output for the Sample Input</H2>
<pre>
1 4 1 4 1 2 1 2
4 1 4 1 2 1 2 1
</pre>
| 2 3 1 4 0 1 0 1
4 2 3 2 2 2 1 1
| 1 4 1 4 1 2 1 2
4 1 4 1 2 1 2 1
| 12,168 |
s153294335 | p00082 | u150984829 | 1525265326 | Python | Python3 | py | Accepted | 30 | 5728 | 242 | import sys
p=['41412121','41212141','21414121','21214141','14141212','14121214','12141412','12121414']
g=lambda x:map(int,x)
for e in sys.stdin:
d={}
for f in p:d[sum(s-t for s,t in zip(g(e.split()),g(f))if s>t)]=f
print(*list(d[min(d)]))
| p00082 |
<H1>メリーゴーランド</H1>
<center>
<img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_10_1">
</center><br/>
<p>
遊園地にあるメリーゴーランドはご存じでしょう。大きな円盤の上に馬や馬車などの乗り物が固定されていて、円盤が回転すると同時に乗り物が上下に揺れる、定番の遊具です。ある遊園地のメリーゴーランドは、４人乗りの馬車が２台、２人乗りの車２台、１人乗りの馬が４台、計８台の乗り物が図１のような順序で備えられています。そして、遊園地においでのお客様は、図１に示す乗り場０〜７のどこかで待つようになっています。
</p>
<center>
<img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_10_2">
</center><br/>
<p>
この遊園地のメリーゴーランドは、かならず乗り物が乗り場にぴったりと合う位置に停止します。そして、０〜７のそれぞれで待っているお客さまは、目の前にとまった乗り物に乗ることになっています。急いで他の乗り場へ移動してそこから乗るということはできません。効率よく、お客さまにたのしんでいただくためには、メリーゴーランドの停止する位置をうまく調整して、乗れないお客さまをできるだけ少なくするようにしなければなりません。
</p>
<p>
乗り場０〜７で待っているお客さまの人数を読み込んで、どの位置にどの乗り物が来るように止めれば乗れないお客さまが最も少なくなるかを出力するプログラムを作成してください。
<!--なお、乗れなくなるお客さまが最小となるとめ方が何通りもある場合は、そのうちの一つだけ出力するようにしてください。-->
</p>
<H2>入力</H2>
<p>
入力は複数のデータセットからなります。各データセットは以下の形式で与えられます。
</p>
<pre>
<var>p<sub>0</sub></var> <var>p<sub>1</sub></var> <var>p<sub>2</sub></var> <var>p<sub>3</sub></var> <var>p<sub>4</sub></var> <var>p<sub>5</sub></var> <var>p<sub>6</sub></var> <var>p<sub>7</sub></var>
</pre>
<p>
乗り場 0, 1, ..., 7 で待っているお客様の人数を表す整数 <var>p<sub>0</sub></var>, <var>p<sub>1</sub></var>,... , <var>p<sub>7</sub></var> ( 0 ≤ <var>p<sub>i</sub></var> ≤ 10,000) が空白区切りで１行に与えられます。
</p>
<H2>出力</H2>
<p>
メリーゴーランドの乗り物の馬車を 4、車を 2、馬を 1 で表すこととします。乗り場 0, 1, ... , 7 にとめる乗り物を、それぞれ <var>c<sub>0</sub></var>, <var>c<sub>1</sub></var>,..., <var>c<sub>7</sub></var> とします。データセットごとに、<var>c<sub>0</sub></var>, <var>c<sub>1</sub></var>,..., <var>c<sub>7</sub></var> を空白区切りで 1 行に出力します。
</p>
<p>
なお、乗れなくなるお客さまが最小となるとめ方が複数ある場合は、<var>c<sub>0</sub>c<sub>1</sub>c<sub>2</sub>c<sub>3</sub>c<sub>4</sub>c<sub>5</sub>c<sub>6</sub>c<sub>7</sub></var> を 8 桁の整数 <var>V</var> とみなし、<var>V</var> が最小となるとめ方を選ぶものとします。
</p>
<p>
データセットの数は 100 を超えません。
</p>
<H2>Sample Input</H2>
<pre>
2 3 1 4 0 1 0 1
4 2 3 2 2 2 1 1
</pre>
<H2>Output for the Sample Input</H2>
<pre>
1 4 1 4 1 2 1 2
4 1 4 1 2 1 2 1
</pre>
| 2 3 1 4 0 1 0 1
4 2 3 2 2 2 1 1
| 1 4 1 4 1 2 1 2
4 1 4 1 2 1 2 1
| 12,169 |
s648617719 | p00082 | u352394527 | 1527584184 | Python | Python3 | py | Accepted | 30 | 5612 | 846 | def comp(lst1, lst2):
for v1, v2 in zip(lst1, lst2):
if v1 < v2:
return False
if v1 > v2:
return True
return False
while True:
try:
plst = list(map(int, input().split()))
horse = [4, 1, 4, 1, 2, 1, 2, 1]
min_num = 100000
min_horse = horse[:]
for _ in range(8):
#乗車不能人数
num = sum([max(0, plst[j] - horse[j]) for j in range(8)])
#人数が最小値と等しく、並びの数値が小さければ更新
if num == min_num and comp(min_horse, horse):
min_horse = horse[:]
#人数が最小値より小さければ更新
elif num < min_num:
min_num = num
min_horse = horse[:]
#馬を回転
horse.append(horse.pop(0))
print(" ".join(map(str, min_horse)))
except EOFError:
break
| p00082 |
<H1>メリーゴーランド</H1>
<center>
<img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_10_1">
</center><br/>
<p>
遊園地にあるメリーゴーランドはご存じでしょう。大きな円盤の上に馬や馬車などの乗り物が固定されていて、円盤が回転すると同時に乗り物が上下に揺れる、定番の遊具です。ある遊園地のメリーゴーランドは、４人乗りの馬車が２台、２人乗りの車２台、１人乗りの馬が４台、計８台の乗り物が図１のような順序で備えられています。そして、遊園地においでのお客様は、図１に示す乗り場０〜７のどこかで待つようになっています。
</p>
<center>
<img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_10_2">
</center><br/>
<p>
この遊園地のメリーゴーランドは、かならず乗り物が乗り場にぴったりと合う位置に停止します。そして、０〜７のそれぞれで待っているお客さまは、目の前にとまった乗り物に乗ることになっています。急いで他の乗り場へ移動してそこから乗るということはできません。効率よく、お客さまにたのしんでいただくためには、メリーゴーランドの停止する位置をうまく調整して、乗れないお客さまをできるだけ少なくするようにしなければなりません。
</p>
<p>
乗り場０〜７で待っているお客さまの人数を読み込んで、どの位置にどの乗り物が来るように止めれば乗れないお客さまが最も少なくなるかを出力するプログラムを作成してください。
<!--なお、乗れなくなるお客さまが最小となるとめ方が何通りもある場合は、そのうちの一つだけ出力するようにしてください。-->
</p>
<H2>入力</H2>
<p>
入力は複数のデータセットからなります。各データセットは以下の形式で与えられます。
</p>
<pre>
<var>p<sub>0</sub></var> <var>p<sub>1</sub></var> <var>p<sub>2</sub></var> <var>p<sub>3</sub></var> <var>p<sub>4</sub></var> <var>p<sub>5</sub></var> <var>p<sub>6</sub></var> <var>p<sub>7</sub></var>
</pre>
<p>
乗り場 0, 1, ..., 7 で待っているお客様の人数を表す整数 <var>p<sub>0</sub></var>, <var>p<sub>1</sub></var>,... , <var>p<sub>7</sub></var> ( 0 ≤ <var>p<sub>i</sub></var> ≤ 10,000) が空白区切りで１行に与えられます。
</p>
<H2>出力</H2>
<p>
メリーゴーランドの乗り物の馬車を 4、車を 2、馬を 1 で表すこととします。乗り場 0, 1, ... , 7 にとめる乗り物を、それぞれ <var>c<sub>0</sub></var>, <var>c<sub>1</sub></var>,..., <var>c<sub>7</sub></var> とします。データセットごとに、<var>c<sub>0</sub></var>, <var>c<sub>1</sub></var>,..., <var>c<sub>7</sub></var> を空白区切りで 1 行に出力します。
</p>
<p>
なお、乗れなくなるお客さまが最小となるとめ方が複数ある場合は、<var>c<sub>0</sub>c<sub>1</sub>c<sub>2</sub>c<sub>3</sub>c<sub>4</sub>c<sub>5</sub>c<sub>6</sub>c<sub>7</sub></var> を 8 桁の整数 <var>V</var> とみなし、<var>V</var> が最小となるとめ方を選ぶものとします。
</p>
<p>
データセットの数は 100 を超えません。
</p>
<H2>Sample Input</H2>
<pre>
2 3 1 4 0 1 0 1
4 2 3 2 2 2 1 1
</pre>
<H2>Output for the Sample Input</H2>
<pre>
1 4 1 4 1 2 1 2
4 1 4 1 2 1 2 1
</pre>
| 2 3 1 4 0 1 0 1
4 2 3 2 2 2 1 1
| 1 4 1 4 1 2 1 2
4 1 4 1 2 1 2 1
| 12,170 |
s703145960 | p00082 | u352394527 | 1527584219 | Python | Python3 | py | Accepted | 30 | 5612 | 700 | while True:
try:
plst = list(map(int, input().split()))
horse = [4, 1, 4, 1, 2, 1, 2, 1]
min_num = 100000
min_horse = horse[:]
for _ in range(8):
#乗車不能人数
num = sum([max(0, plst[j] - horse[j]) for j in range(8)])
#人数が最小値と等しく、並びの数値が小さければ更新
if num == min_num and min_horse > horse:
min_horse = horse[:]
#人数が最小値より小さければ更新
elif num < min_num:
min_num = num
min_horse = horse[:]
#馬を回転
horse.append(horse.pop(0))
print(" ".join(map(str, min_horse)))
except EOFError:
break
| p00082 |
<H1>メリーゴーランド</H1>
<center>
<img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_10_1">
</center><br/>
<p>
遊園地にあるメリーゴーランドはご存じでしょう。大きな円盤の上に馬や馬車などの乗り物が固定されていて、円盤が回転すると同時に乗り物が上下に揺れる、定番の遊具です。ある遊園地のメリーゴーランドは、４人乗りの馬車が２台、２人乗りの車２台、１人乗りの馬が４台、計８台の乗り物が図１のような順序で備えられています。そして、遊園地においでのお客様は、図１に示す乗り場０〜７のどこかで待つようになっています。
</p>
<center>
<img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_10_2">
</center><br/>
<p>
この遊園地のメリーゴーランドは、かならず乗り物が乗り場にぴったりと合う位置に停止します。そして、０〜７のそれぞれで待っているお客さまは、目の前にとまった乗り物に乗ることになっています。急いで他の乗り場へ移動してそこから乗るということはできません。効率よく、お客さまにたのしんでいただくためには、メリーゴーランドの停止する位置をうまく調整して、乗れないお客さまをできるだけ少なくするようにしなければなりません。
</p>
<p>
乗り場０〜７で待っているお客さまの人数を読み込んで、どの位置にどの乗り物が来るように止めれば乗れないお客さまが最も少なくなるかを出力するプログラムを作成してください。
<!--なお、乗れなくなるお客さまが最小となるとめ方が何通りもある場合は、そのうちの一つだけ出力するようにしてください。-->
</p>
<H2>入力</H2>
<p>
入力は複数のデータセットからなります。各データセットは以下の形式で与えられます。
</p>
<pre>
<var>p<sub>0</sub></var> <var>p<sub>1</sub></var> <var>p<sub>2</sub></var> <var>p<sub>3</sub></var> <var>p<sub>4</sub></var> <var>p<sub>5</sub></var> <var>p<sub>6</sub></var> <var>p<sub>7</sub></var>
</pre>
<p>
乗り場 0, 1, ..., 7 で待っているお客様の人数を表す整数 <var>p<sub>0</sub></var>, <var>p<sub>1</sub></var>,... , <var>p<sub>7</sub></var> ( 0 ≤ <var>p<sub>i</sub></var> ≤ 10,000) が空白区切りで１行に与えられます。
</p>
<H2>出力</H2>
<p>
メリーゴーランドの乗り物の馬車を 4、車を 2、馬を 1 で表すこととします。乗り場 0, 1, ... , 7 にとめる乗り物を、それぞれ <var>c<sub>0</sub></var>, <var>c<sub>1</sub></var>,..., <var>c<sub>7</sub></var> とします。データセットごとに、<var>c<sub>0</sub></var>, <var>c<sub>1</sub></var>,..., <var>c<sub>7</sub></var> を空白区切りで 1 行に出力します。
</p>
<p>
なお、乗れなくなるお客さまが最小となるとめ方が複数ある場合は、<var>c<sub>0</sub>c<sub>1</sub>c<sub>2</sub>c<sub>3</sub>c<sub>4</sub>c<sub>5</sub>c<sub>6</sub>c<sub>7</sub></var> を 8 桁の整数 <var>V</var> とみなし、<var>V</var> が最小となるとめ方を選ぶものとします。
</p>
<p>
データセットの数は 100 を超えません。
</p>
<H2>Sample Input</H2>
<pre>
2 3 1 4 0 1 0 1
4 2 3 2 2 2 1 1
</pre>
<H2>Output for the Sample Input</H2>
<pre>
1 4 1 4 1 2 1 2
4 1 4 1 2 1 2 1
</pre>
| 2 3 1 4 0 1 0 1
4 2 3 2 2 2 1 1
| 1 4 1 4 1 2 1 2
4 1 4 1 2 1 2 1
| 12,171 |
s862315727 | p00082 | u352394527 | 1527584336 | Python | Python3 | py | Accepted | 30 | 5608 | 692 | while True:
try:
plst = list(map(int, input().split()))
horse = [4, 1, 4, 1, 2, 1, 2, 1]
max_num = -1
max_horse = horse[:]
for _ in range(8):
#乗車可能人数
num = sum([min(plst[j], horse[j]) for j in range(8)])
#人数が最大値と等しく、並びの数値が小さければ更新
if num == max_num and max_horse > horse:
max_horse = horse[:]
#人数が最大値より大きければ更新
elif num > max_num:
max_num = num
max_horse = horse[:]
#馬を回転
horse.append(horse.pop(0))
print(" ".join(map(str, max_horse)))
except EOFError:
break
| p00082 |
<H1>メリーゴーランド</H1>
<center>
<img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_10_1">
</center><br/>
<p>
遊園地にあるメリーゴーランドはご存じでしょう。大きな円盤の上に馬や馬車などの乗り物が固定されていて、円盤が回転すると同時に乗り物が上下に揺れる、定番の遊具です。ある遊園地のメリーゴーランドは、４人乗りの馬車が２台、２人乗りの車２台、１人乗りの馬が４台、計８台の乗り物が図１のような順序で備えられています。そして、遊園地においでのお客様は、図１に示す乗り場０〜７のどこかで待つようになっています。
</p>
<center>
<img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_10_2">
</center><br/>
<p>
この遊園地のメリーゴーランドは、かならず乗り物が乗り場にぴったりと合う位置に停止します。そして、０〜７のそれぞれで待っているお客さまは、目の前にとまった乗り物に乗ることになっています。急いで他の乗り場へ移動してそこから乗るということはできません。効率よく、お客さまにたのしんでいただくためには、メリーゴーランドの停止する位置をうまく調整して、乗れないお客さまをできるだけ少なくするようにしなければなりません。
</p>
<p>
乗り場０〜７で待っているお客さまの人数を読み込んで、どの位置にどの乗り物が来るように止めれば乗れないお客さまが最も少なくなるかを出力するプログラムを作成してください。
<!--なお、乗れなくなるお客さまが最小となるとめ方が何通りもある場合は、そのうちの一つだけ出力するようにしてください。-->
</p>
<H2>入力</H2>
<p>
入力は複数のデータセットからなります。各データセットは以下の形式で与えられます。
</p>
<pre>
<var>p<sub>0</sub></var> <var>p<sub>1</sub></var> <var>p<sub>2</sub></var> <var>p<sub>3</sub></var> <var>p<sub>4</sub></var> <var>p<sub>5</sub></var> <var>p<sub>6</sub></var> <var>p<sub>7</sub></var>
</pre>
<p>
乗り場 0, 1, ..., 7 で待っているお客様の人数を表す整数 <var>p<sub>0</sub></var>, <var>p<sub>1</sub></var>,... , <var>p<sub>7</sub></var> ( 0 ≤ <var>p<sub>i</sub></var> ≤ 10,000) が空白区切りで１行に与えられます。
</p>
<H2>出力</H2>
<p>
メリーゴーランドの乗り物の馬車を 4、車を 2、馬を 1 で表すこととします。乗り場 0, 1, ... , 7 にとめる乗り物を、それぞれ <var>c<sub>0</sub></var>, <var>c<sub>1</sub></var>,..., <var>c<sub>7</sub></var> とします。データセットごとに、<var>c<sub>0</sub></var>, <var>c<sub>1</sub></var>,..., <var>c<sub>7</sub></var> を空白区切りで 1 行に出力します。
</p>
<p>
なお、乗れなくなるお客さまが最小となるとめ方が複数ある場合は、<var>c<sub>0</sub>c<sub>1</sub>c<sub>2</sub>c<sub>3</sub>c<sub>4</sub>c<sub>5</sub>c<sub>6</sub>c<sub>7</sub></var> を 8 桁の整数 <var>V</var> とみなし、<var>V</var> が最小となるとめ方を選ぶものとします。
</p>
<p>
データセットの数は 100 を超えません。
</p>
<H2>Sample Input</H2>
<pre>
2 3 1 4 0 1 0 1
4 2 3 2 2 2 1 1
</pre>
<H2>Output for the Sample Input</H2>
<pre>
1 4 1 4 1 2 1 2
4 1 4 1 2 1 2 1
</pre>
| 2 3 1 4 0 1 0 1
4 2 3 2 2 2 1 1
| 1 4 1 4 1 2 1 2
4 1 4 1 2 1 2 1
| 12,172 |
s782649585 | p00082 | u136916346 | 1528724051 | Python | Python3 | py | Accepted | 30 | 5624 | 383 | import sys
t=[1,4,1,4,1,2,1,2]
for i in sys.stdin:
l=list(map(int,i[:-1].split()))
q={}
for i in range(8):
e=int("".join(map(str,t[i:]+t[:i])))
s=sum([j if j<i else i for (i,j) in zip(t[i:]+t[:i],l)])
if s not in q:
q[s]=[e]
else:
q[s].extend([e])
print(" ".join([i for i in str(sorted(q[max(q.keys())])[0])]))
| p00082 |
<H1>メリーゴーランド</H1>
<center>
<img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_10_1">
</center><br/>
<p>
遊園地にあるメリーゴーランドはご存じでしょう。大きな円盤の上に馬や馬車などの乗り物が固定されていて、円盤が回転すると同時に乗り物が上下に揺れる、定番の遊具です。ある遊園地のメリーゴーランドは、４人乗りの馬車が２台、２人乗りの車２台、１人乗りの馬が４台、計８台の乗り物が図１のような順序で備えられています。そして、遊園地においでのお客様は、図１に示す乗り場０〜７のどこかで待つようになっています。
</p>
<center>
<img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_10_2">
</center><br/>
<p>
この遊園地のメリーゴーランドは、かならず乗り物が乗り場にぴったりと合う位置に停止します。そして、０〜７のそれぞれで待っているお客さまは、目の前にとまった乗り物に乗ることになっています。急いで他の乗り場へ移動してそこから乗るということはできません。効率よく、お客さまにたのしんでいただくためには、メリーゴーランドの停止する位置をうまく調整して、乗れないお客さまをできるだけ少なくするようにしなければなりません。
</p>
<p>
乗り場０〜７で待っているお客さまの人数を読み込んで、どの位置にどの乗り物が来るように止めれば乗れないお客さまが最も少なくなるかを出力するプログラムを作成してください。
<!--なお、乗れなくなるお客さまが最小となるとめ方が何通りもある場合は、そのうちの一つだけ出力するようにしてください。-->
</p>
<H2>入力</H2>
<p>
入力は複数のデータセットからなります。各データセットは以下の形式で与えられます。
</p>
<pre>
<var>p<sub>0</sub></var> <var>p<sub>1</sub></var> <var>p<sub>2</sub></var> <var>p<sub>3</sub></var> <var>p<sub>4</sub></var> <var>p<sub>5</sub></var> <var>p<sub>6</sub></var> <var>p<sub>7</sub></var>
</pre>
<p>
乗り場 0, 1, ..., 7 で待っているお客様の人数を表す整数 <var>p<sub>0</sub></var>, <var>p<sub>1</sub></var>,... , <var>p<sub>7</sub></var> ( 0 ≤ <var>p<sub>i</sub></var> ≤ 10,000) が空白区切りで１行に与えられます。
</p>
<H2>出力</H2>
<p>
メリーゴーランドの乗り物の馬車を 4、車を 2、馬を 1 で表すこととします。乗り場 0, 1, ... , 7 にとめる乗り物を、それぞれ <var>c<sub>0</sub></var>, <var>c<sub>1</sub></var>,..., <var>c<sub>7</sub></var> とします。データセットごとに、<var>c<sub>0</sub></var>, <var>c<sub>1</sub></var>,..., <var>c<sub>7</sub></var> を空白区切りで 1 行に出力します。
</p>
<p>
なお、乗れなくなるお客さまが最小となるとめ方が複数ある場合は、<var>c<sub>0</sub>c<sub>1</sub>c<sub>2</sub>c<sub>3</sub>c<sub>4</sub>c<sub>5</sub>c<sub>6</sub>c<sub>7</sub></var> を 8 桁の整数 <var>V</var> とみなし、<var>V</var> が最小となるとめ方を選ぶものとします。
</p>
<p>
データセットの数は 100 を超えません。
</p>
<H2>Sample Input</H2>
<pre>
2 3 1 4 0 1 0 1
4 2 3 2 2 2 1 1
</pre>
<H2>Output for the Sample Input</H2>
<pre>
1 4 1 4 1 2 1 2
4 1 4 1 2 1 2 1
</pre>
| 2 3 1 4 0 1 0 1
4 2 3 2 2 2 1 1
| 1 4 1 4 1 2 1 2
4 1 4 1 2 1 2 1
| 12,173 |
s793242316 | p00082 | u847467233 | 1529582835 | Python | Python3 | py | Accepted | 30 | 5608 | 457 | # AOJ 0082 Flying Jenny
# Python3 2018.6.21 bal4u
h = [4,1,4,1,2,1,2,1,4,1,4,1,2,1,2,1]
d = [41412121, 14121214, 41212141, 12121414, 21214141, 12141412, 21414121, 14141212]
while 1:
try: p = list(map(int, input().split()))
except: break
max, id = 0, 3
for i in range(8):
c = 0
for j in range(8):
if p[j] >= h[i+j]: c += h[i+j]
else: c += p[j]
if max < c: max, id = c, i
elif max == c and d[id] > d[i]: id = i
print(*list(str(d[id])))
| p00082 |
<H1>メリーゴーランド</H1>
<center>
<img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_10_1">
</center><br/>
<p>
遊園地にあるメリーゴーランドはご存じでしょう。大きな円盤の上に馬や馬車などの乗り物が固定されていて、円盤が回転すると同時に乗り物が上下に揺れる、定番の遊具です。ある遊園地のメリーゴーランドは、４人乗りの馬車が２台、２人乗りの車２台、１人乗りの馬が４台、計８台の乗り物が図１のような順序で備えられています。そして、遊園地においでのお客様は、図１に示す乗り場０〜７のどこかで待つようになっています。
</p>
<center>
<img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_10_2">
</center><br/>
<p>
この遊園地のメリーゴーランドは、かならず乗り物が乗り場にぴったりと合う位置に停止します。そして、０〜７のそれぞれで待っているお客さまは、目の前にとまった乗り物に乗ることになっています。急いで他の乗り場へ移動してそこから乗るということはできません。効率よく、お客さまにたのしんでいただくためには、メリーゴーランドの停止する位置をうまく調整して、乗れないお客さまをできるだけ少なくするようにしなければなりません。
</p>
<p>
乗り場０〜７で待っているお客さまの人数を読み込んで、どの位置にどの乗り物が来るように止めれば乗れないお客さまが最も少なくなるかを出力するプログラムを作成してください。
<!--なお、乗れなくなるお客さまが最小となるとめ方が何通りもある場合は、そのうちの一つだけ出力するようにしてください。-->
</p>
<H2>入力</H2>
<p>
入力は複数のデータセットからなります。各データセットは以下の形式で与えられます。
</p>
<pre>
<var>p<sub>0</sub></var> <var>p<sub>1</sub></var> <var>p<sub>2</sub></var> <var>p<sub>3</sub></var> <var>p<sub>4</sub></var> <var>p<sub>5</sub></var> <var>p<sub>6</sub></var> <var>p<sub>7</sub></var>
</pre>
<p>
乗り場 0, 1, ..., 7 で待っているお客様の人数を表す整数 <var>p<sub>0</sub></var>, <var>p<sub>1</sub></var>,... , <var>p<sub>7</sub></var> ( 0 ≤ <var>p<sub>i</sub></var> ≤ 10,000) が空白区切りで１行に与えられます。
</p>
<H2>出力</H2>
<p>
メリーゴーランドの乗り物の馬車を 4、車を 2、馬を 1 で表すこととします。乗り場 0, 1, ... , 7 にとめる乗り物を、それぞれ <var>c<sub>0</sub></var>, <var>c<sub>1</sub></var>,..., <var>c<sub>7</sub></var> とします。データセットごとに、<var>c<sub>0</sub></var>, <var>c<sub>1</sub></var>,..., <var>c<sub>7</sub></var> を空白区切りで 1 行に出力します。
</p>
<p>
なお、乗れなくなるお客さまが最小となるとめ方が複数ある場合は、<var>c<sub>0</sub>c<sub>1</sub>c<sub>2</sub>c<sub>3</sub>c<sub>4</sub>c<sub>5</sub>c<sub>6</sub>c<sub>7</sub></var> を 8 桁の整数 <var>V</var> とみなし、<var>V</var> が最小となるとめ方を選ぶものとします。
</p>
<p>
データセットの数は 100 を超えません。
</p>
<H2>Sample Input</H2>
<pre>
2 3 1 4 0 1 0 1
4 2 3 2 2 2 1 1
</pre>
<H2>Output for the Sample Input</H2>
<pre>
1 4 1 4 1 2 1 2
4 1 4 1 2 1 2 1
</pre>
| 2 3 1 4 0 1 0 1
4 2 3 2 2 2 1 1
| 1 4 1 4 1 2 1 2
4 1 4 1 2 1 2 1
| 12,174 |
s039163521 | p00082 | u647766105 | 1357086727 | Python | Python | py | Accepted | 20 | 4244 | 391 | import sys
raw=[4,1,2,1,2,1,4,1]
for line in sys.stdin.readlines():
p=map(int,line.strip().split())
ma,ans=1<<30,str(1<<30)
for i in xrange(8):
t=raw[i:]+raw[:i]
temp=sum(map(lambda a,b:a-b if a>b else 0,p,t))
if (temp<ma) or (temp==ma and int(ans)>int("".join(map(str,t)))):
ma=temp
ans="".join(map(str,t))
print " ".join(ans) | p00082 |
<H1>メリーゴーランド</H1>
<center>
<img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_10_1">
</center><br/>
<p>
遊園地にあるメリーゴーランドはご存じでしょう。大きな円盤の上に馬や馬車などの乗り物が固定されていて、円盤が回転すると同時に乗り物が上下に揺れる、定番の遊具です。ある遊園地のメリーゴーランドは、４人乗りの馬車が２台、２人乗りの車２台、１人乗りの馬が４台、計８台の乗り物が図１のような順序で備えられています。そして、遊園地においでのお客様は、図１に示す乗り場０〜７のどこかで待つようになっています。
</p>
<center>
<img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_10_2">
</center><br/>
<p>
この遊園地のメリーゴーランドは、かならず乗り物が乗り場にぴったりと合う位置に停止します。そして、０〜７のそれぞれで待っているお客さまは、目の前にとまった乗り物に乗ることになっています。急いで他の乗り場へ移動してそこから乗るということはできません。効率よく、お客さまにたのしんでいただくためには、メリーゴーランドの停止する位置をうまく調整して、乗れないお客さまをできるだけ少なくするようにしなければなりません。
</p>
<p>
乗り場０〜７で待っているお客さまの人数を読み込んで、どの位置にどの乗り物が来るように止めれば乗れないお客さまが最も少なくなるかを出力するプログラムを作成してください。
<!--なお、乗れなくなるお客さまが最小となるとめ方が何通りもある場合は、そのうちの一つだけ出力するようにしてください。-->
</p>
<H2>入力</H2>
<p>
入力は複数のデータセットからなります。各データセットは以下の形式で与えられます。
</p>
<pre>
<var>p<sub>0</sub></var> <var>p<sub>1</sub></var> <var>p<sub>2</sub></var> <var>p<sub>3</sub></var> <var>p<sub>4</sub></var> <var>p<sub>5</sub></var> <var>p<sub>6</sub></var> <var>p<sub>7</sub></var>
</pre>
<p>
乗り場 0, 1, ..., 7 で待っているお客様の人数を表す整数 <var>p<sub>0</sub></var>, <var>p<sub>1</sub></var>,... , <var>p<sub>7</sub></var> ( 0 ≤ <var>p<sub>i</sub></var> ≤ 10,000) が空白区切りで１行に与えられます。
</p>
<H2>出力</H2>
<p>
メリーゴーランドの乗り物の馬車を 4、車を 2、馬を 1 で表すこととします。乗り場 0, 1, ... , 7 にとめる乗り物を、それぞれ <var>c<sub>0</sub></var>, <var>c<sub>1</sub></var>,..., <var>c<sub>7</sub></var> とします。データセットごとに、<var>c<sub>0</sub></var>, <var>c<sub>1</sub></var>,..., <var>c<sub>7</sub></var> を空白区切りで 1 行に出力します。
</p>
<p>
なお、乗れなくなるお客さまが最小となるとめ方が複数ある場合は、<var>c<sub>0</sub>c<sub>1</sub>c<sub>2</sub>c<sub>3</sub>c<sub>4</sub>c<sub>5</sub>c<sub>6</sub>c<sub>7</sub></var> を 8 桁の整数 <var>V</var> とみなし、<var>V</var> が最小となるとめ方を選ぶものとします。
</p>
<p>
データセットの数は 100 を超えません。
</p>
<H2>Sample Input</H2>
<pre>
2 3 1 4 0 1 0 1
4 2 3 2 2 2 1 1
</pre>
<H2>Output for the Sample Input</H2>
<pre>
1 4 1 4 1 2 1 2
4 1 4 1 2 1 2 1
</pre>
| 2 3 1 4 0 1 0 1
4 2 3 2 2 2 1 1
| 1 4 1 4 1 2 1 2
4 1 4 1 2 1 2 1
| 12,175 |
s219791587 | p00082 | u104911888 | 1367116417 | Python | Python | py | Accepted | 20 | 4256 | 396 | c=[4,1,4,1,2,1,2,1]
while True:
try:
p=map(int,raw_input().split())
except EOFError:
break
m,ans=100000000,"9"*10
for i in range(len(c)):
t=c[i:]+c[:i]
s=sum([p[i]-t[i] for i in range(len(c)) if p[i]>t[i]])
if (s<m) or (s==m and int(ans)>int("".join(map(str,t)))):
m=s
ans="".join(map(str,t))
print " ".join(ans) | p00082 |
<H1>メリーゴーランド</H1>
<center>
<img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_10_1">
</center><br/>
<p>
遊園地にあるメリーゴーランドはご存じでしょう。大きな円盤の上に馬や馬車などの乗り物が固定されていて、円盤が回転すると同時に乗り物が上下に揺れる、定番の遊具です。ある遊園地のメリーゴーランドは、４人乗りの馬車が２台、２人乗りの車２台、１人乗りの馬が４台、計８台の乗り物が図１のような順序で備えられています。そして、遊園地においでのお客様は、図１に示す乗り場０〜７のどこかで待つようになっています。
</p>
<center>
<img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_10_2">
</center><br/>
<p>
この遊園地のメリーゴーランドは、かならず乗り物が乗り場にぴったりと合う位置に停止します。そして、０〜７のそれぞれで待っているお客さまは、目の前にとまった乗り物に乗ることになっています。急いで他の乗り場へ移動してそこから乗るということはできません。効率よく、お客さまにたのしんでいただくためには、メリーゴーランドの停止する位置をうまく調整して、乗れないお客さまをできるだけ少なくするようにしなければなりません。
</p>
<p>
乗り場０〜７で待っているお客さまの人数を読み込んで、どの位置にどの乗り物が来るように止めれば乗れないお客さまが最も少なくなるかを出力するプログラムを作成してください。
<!--なお、乗れなくなるお客さまが最小となるとめ方が何通りもある場合は、そのうちの一つだけ出力するようにしてください。-->
</p>
<H2>入力</H2>
<p>
入力は複数のデータセットからなります。各データセットは以下の形式で与えられます。
</p>
<pre>
<var>p<sub>0</sub></var> <var>p<sub>1</sub></var> <var>p<sub>2</sub></var> <var>p<sub>3</sub></var> <var>p<sub>4</sub></var> <var>p<sub>5</sub></var> <var>p<sub>6</sub></var> <var>p<sub>7</sub></var>
</pre>
<p>
乗り場 0, 1, ..., 7 で待っているお客様の人数を表す整数 <var>p<sub>0</sub></var>, <var>p<sub>1</sub></var>,... , <var>p<sub>7</sub></var> ( 0 ≤ <var>p<sub>i</sub></var> ≤ 10,000) が空白区切りで１行に与えられます。
</p>
<H2>出力</H2>
<p>
メリーゴーランドの乗り物の馬車を 4、車を 2、馬を 1 で表すこととします。乗り場 0, 1, ... , 7 にとめる乗り物を、それぞれ <var>c<sub>0</sub></var>, <var>c<sub>1</sub></var>,..., <var>c<sub>7</sub></var> とします。データセットごとに、<var>c<sub>0</sub></var>, <var>c<sub>1</sub></var>,..., <var>c<sub>7</sub></var> を空白区切りで 1 行に出力します。
</p>
<p>
なお、乗れなくなるお客さまが最小となるとめ方が複数ある場合は、<var>c<sub>0</sub>c<sub>1</sub>c<sub>2</sub>c<sub>3</sub>c<sub>4</sub>c<sub>5</sub>c<sub>6</sub>c<sub>7</sub></var> を 8 桁の整数 <var>V</var> とみなし、<var>V</var> が最小となるとめ方を選ぶものとします。
</p>
<p>
データセットの数は 100 を超えません。
</p>
<H2>Sample Input</H2>
<pre>
2 3 1 4 0 1 0 1
4 2 3 2 2 2 1 1
</pre>
<H2>Output for the Sample Input</H2>
<pre>
1 4 1 4 1 2 1 2
4 1 4 1 2 1 2 1
</pre>
| 2 3 1 4 0 1 0 1
4 2 3 2 2 2 1 1
| 1 4 1 4 1 2 1 2
4 1 4 1 2 1 2 1
| 12,176 |
s370164251 | p00082 | u782850731 | 1379076078 | Python | Python | py | Accepted | 20 | 4292 | 885 | #!/usr/bin/env python
# -*- coding: utf-8 -*-
from __future__ import (division, absolute_import, print_function,
unicode_literals)
from sys import stdin
NUM = 8
VALUE = (12121414, 21214141, 12141412, 21414121, 14141212, 41412121,
14121214, 41212141)
RIDE = ((1, 2, 1, 2, 1, 4, 1, 4), (2, 1, 2, 1, 4, 1, 4, 1),
(1, 2, 1, 4, 1, 4, 1, 2), (2, 1, 4, 1, 4, 1, 2, 1),
(1, 4, 1, 4, 1, 2, 1, 2), (4, 1, 4, 1, 2, 1, 2, 1),
(1, 4, 1, 2, 1, 2, 1, 4), (4, 1, 2, 1, 2, 1, 4, 1))
for line in stdin:
gast = [int(s) for s in line.split()]
remain = sum(gast)
value = max(VALUE)
for i in range(NUM):
r = sum(g-n if g-n > 0 else 0 for g, n in zip(gast, RIDE[i]))
if remain > r or (remain == r and value > VALUE[i]):
remain = r
index = i
value = VALUE[i]
print(*RIDE[index]) | p00082 |
<H1>メリーゴーランド</H1>
<center>
<img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_10_1">
</center><br/>
<p>
遊園地にあるメリーゴーランドはご存じでしょう。大きな円盤の上に馬や馬車などの乗り物が固定されていて、円盤が回転すると同時に乗り物が上下に揺れる、定番の遊具です。ある遊園地のメリーゴーランドは、４人乗りの馬車が２台、２人乗りの車２台、１人乗りの馬が４台、計８台の乗り物が図１のような順序で備えられています。そして、遊園地においでのお客様は、図１に示す乗り場０〜７のどこかで待つようになっています。
</p>
<center>
<img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_10_2">
</center><br/>
<p>
この遊園地のメリーゴーランドは、かならず乗り物が乗り場にぴったりと合う位置に停止します。そして、０〜７のそれぞれで待っているお客さまは、目の前にとまった乗り物に乗ることになっています。急いで他の乗り場へ移動してそこから乗るということはできません。効率よく、お客さまにたのしんでいただくためには、メリーゴーランドの停止する位置をうまく調整して、乗れないお客さまをできるだけ少なくするようにしなければなりません。
</p>
<p>
乗り場０〜７で待っているお客さまの人数を読み込んで、どの位置にどの乗り物が来るように止めれば乗れないお客さまが最も少なくなるかを出力するプログラムを作成してください。
<!--なお、乗れなくなるお客さまが最小となるとめ方が何通りもある場合は、そのうちの一つだけ出力するようにしてください。-->
</p>
<H2>入力</H2>
<p>
入力は複数のデータセットからなります。各データセットは以下の形式で与えられます。
</p>
<pre>
<var>p<sub>0</sub></var> <var>p<sub>1</sub></var> <var>p<sub>2</sub></var> <var>p<sub>3</sub></var> <var>p<sub>4</sub></var> <var>p<sub>5</sub></var> <var>p<sub>6</sub></var> <var>p<sub>7</sub></var>
</pre>
<p>
乗り場 0, 1, ..., 7 で待っているお客様の人数を表す整数 <var>p<sub>0</sub></var>, <var>p<sub>1</sub></var>,... , <var>p<sub>7</sub></var> ( 0 ≤ <var>p<sub>i</sub></var> ≤ 10,000) が空白区切りで１行に与えられます。
</p>
<H2>出力</H2>
<p>
メリーゴーランドの乗り物の馬車を 4、車を 2、馬を 1 で表すこととします。乗り場 0, 1, ... , 7 にとめる乗り物を、それぞれ <var>c<sub>0</sub></var>, <var>c<sub>1</sub></var>,..., <var>c<sub>7</sub></var> とします。データセットごとに、<var>c<sub>0</sub></var>, <var>c<sub>1</sub></var>,..., <var>c<sub>7</sub></var> を空白区切りで 1 行に出力します。
</p>
<p>
なお、乗れなくなるお客さまが最小となるとめ方が複数ある場合は、<var>c<sub>0</sub>c<sub>1</sub>c<sub>2</sub>c<sub>3</sub>c<sub>4</sub>c<sub>5</sub>c<sub>6</sub>c<sub>7</sub></var> を 8 桁の整数 <var>V</var> とみなし、<var>V</var> が最小となるとめ方を選ぶものとします。
</p>
<p>
データセットの数は 100 を超えません。
</p>
<H2>Sample Input</H2>
<pre>
2 3 1 4 0 1 0 1
4 2 3 2 2 2 1 1
</pre>
<H2>Output for the Sample Input</H2>
<pre>
1 4 1 4 1 2 1 2
4 1 4 1 2 1 2 1
</pre>
| 2 3 1 4 0 1 0 1
4 2 3 2 2 2 1 1
| 1 4 1 4 1 2 1 2
4 1 4 1 2 1 2 1
| 12,177 |
s829252717 | p00082 | u813384600 | 1383972905 | Python | Python | py | Accepted | 20 | 4264 | 577 | import sys
d = [[1, 2, 1, 2, 1, 4, 1, 4],
[1, 2, 1, 4, 1, 4, 1, 2],
[1, 4, 1, 2, 1, 2, 1, 4],
[1, 4, 1, 4, 1, 2, 1, 2],
[2, 1, 2, 1, 4, 1, 4, 1],
[2, 1, 4, 1, 4, 1, 2, 1],
[4, 1, 2, 1, 2, 1, 4, 1],
[4, 1, 4, 1, 2, 1, 2, 1]]
for s in sys.stdin:
c = map(int, s.split())
r = 0
min = 0x7fffffff
for i in range(8):
rr = 0
for j in range(8):
if c[j] > d[i][j]:
rr += c[j] - d[i][j]
if rr < min:
min = rr
r = i
print ' '.join(map(str, d[r]))
a = 1 | p00082 |
<H1>メリーゴーランド</H1>
<center>
<img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_10_1">
</center><br/>
<p>
遊園地にあるメリーゴーランドはご存じでしょう。大きな円盤の上に馬や馬車などの乗り物が固定されていて、円盤が回転すると同時に乗り物が上下に揺れる、定番の遊具です。ある遊園地のメリーゴーランドは、４人乗りの馬車が２台、２人乗りの車２台、１人乗りの馬が４台、計８台の乗り物が図１のような順序で備えられています。そして、遊園地においでのお客様は、図１に示す乗り場０〜７のどこかで待つようになっています。
</p>
<center>
<img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_10_2">
</center><br/>
<p>
この遊園地のメリーゴーランドは、かならず乗り物が乗り場にぴったりと合う位置に停止します。そして、０〜７のそれぞれで待っているお客さまは、目の前にとまった乗り物に乗ることになっています。急いで他の乗り場へ移動してそこから乗るということはできません。効率よく、お客さまにたのしんでいただくためには、メリーゴーランドの停止する位置をうまく調整して、乗れないお客さまをできるだけ少なくするようにしなければなりません。
</p>
<p>
乗り場０〜７で待っているお客さまの人数を読み込んで、どの位置にどの乗り物が来るように止めれば乗れないお客さまが最も少なくなるかを出力するプログラムを作成してください。
<!--なお、乗れなくなるお客さまが最小となるとめ方が何通りもある場合は、そのうちの一つだけ出力するようにしてください。-->
</p>
<H2>入力</H2>
<p>
入力は複数のデータセットからなります。各データセットは以下の形式で与えられます。
</p>
<pre>
<var>p<sub>0</sub></var> <var>p<sub>1</sub></var> <var>p<sub>2</sub></var> <var>p<sub>3</sub></var> <var>p<sub>4</sub></var> <var>p<sub>5</sub></var> <var>p<sub>6</sub></var> <var>p<sub>7</sub></var>
</pre>
<p>
乗り場 0, 1, ..., 7 で待っているお客様の人数を表す整数 <var>p<sub>0</sub></var>, <var>p<sub>1</sub></var>,... , <var>p<sub>7</sub></var> ( 0 ≤ <var>p<sub>i</sub></var> ≤ 10,000) が空白区切りで１行に与えられます。
</p>
<H2>出力</H2>
<p>
メリーゴーランドの乗り物の馬車を 4、車を 2、馬を 1 で表すこととします。乗り場 0, 1, ... , 7 にとめる乗り物を、それぞれ <var>c<sub>0</sub></var>, <var>c<sub>1</sub></var>,..., <var>c<sub>7</sub></var> とします。データセットごとに、<var>c<sub>0</sub></var>, <var>c<sub>1</sub></var>,..., <var>c<sub>7</sub></var> を空白区切りで 1 行に出力します。
</p>
<p>
なお、乗れなくなるお客さまが最小となるとめ方が複数ある場合は、<var>c<sub>0</sub>c<sub>1</sub>c<sub>2</sub>c<sub>3</sub>c<sub>4</sub>c<sub>5</sub>c<sub>6</sub>c<sub>7</sub></var> を 8 桁の整数 <var>V</var> とみなし、<var>V</var> が最小となるとめ方を選ぶものとします。
</p>
<p>
データセットの数は 100 を超えません。
</p>
<H2>Sample Input</H2>
<pre>
2 3 1 4 0 1 0 1
4 2 3 2 2 2 1 1
</pre>
<H2>Output for the Sample Input</H2>
<pre>
1 4 1 4 1 2 1 2
4 1 4 1 2 1 2 1
</pre>
| 2 3 1 4 0 1 0 1
4 2 3 2 2 2 1 1
| 1 4 1 4 1 2 1 2
4 1 4 1 2 1 2 1
| 12,178 |
s149287624 | p00082 | u633068244 | 1396076770 | Python | Python | py | Accepted | 20 | 4252 | 512 | cart = [4,1,4,1,2,1,2,1]
while True:
try:
que = map(int, raw_input().split())
mx,mxcart = 0, "99999999"
for sp in range(8):
sm = 0
for num in range(8):
if cart[(sp+num)%8] <= que[num]:
sm += cart[(sp+num)%8]
else:
sm += que[num]
if sm > mx:
mx = sm
mxcart = "".join(map(str, cart[sp:]+cart[:sp]))
elif sm == mx:
acart = "".join(map(str, cart[sp:]+cart[:sp]))
if int(mxcart) > int(acart):
mxcart = acart
print " ".join(map(str, mxcart))
except:
break | p00082 |
<H1>メリーゴーランド</H1>
<center>
<img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_10_1">
</center><br/>
<p>
遊園地にあるメリーゴーランドはご存じでしょう。大きな円盤の上に馬や馬車などの乗り物が固定されていて、円盤が回転すると同時に乗り物が上下に揺れる、定番の遊具です。ある遊園地のメリーゴーランドは、４人乗りの馬車が２台、２人乗りの車２台、１人乗りの馬が４台、計８台の乗り物が図１のような順序で備えられています。そして、遊園地においでのお客様は、図１に示す乗り場０〜７のどこかで待つようになっています。
</p>
<center>
<img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_10_2">
</center><br/>
<p>
この遊園地のメリーゴーランドは、かならず乗り物が乗り場にぴったりと合う位置に停止します。そして、０〜７のそれぞれで待っているお客さまは、目の前にとまった乗り物に乗ることになっています。急いで他の乗り場へ移動してそこから乗るということはできません。効率よく、お客さまにたのしんでいただくためには、メリーゴーランドの停止する位置をうまく調整して、乗れないお客さまをできるだけ少なくするようにしなければなりません。
</p>
<p>
乗り場０〜７で待っているお客さまの人数を読み込んで、どの位置にどの乗り物が来るように止めれば乗れないお客さまが最も少なくなるかを出力するプログラムを作成してください。
<!--なお、乗れなくなるお客さまが最小となるとめ方が何通りもある場合は、そのうちの一つだけ出力するようにしてください。-->
</p>
<H2>入力</H2>
<p>
入力は複数のデータセットからなります。各データセットは以下の形式で与えられます。
</p>
<pre>
<var>p<sub>0</sub></var> <var>p<sub>1</sub></var> <var>p<sub>2</sub></var> <var>p<sub>3</sub></var> <var>p<sub>4</sub></var> <var>p<sub>5</sub></var> <var>p<sub>6</sub></var> <var>p<sub>7</sub></var>
</pre>
<p>
乗り場 0, 1, ..., 7 で待っているお客様の人数を表す整数 <var>p<sub>0</sub></var>, <var>p<sub>1</sub></var>,... , <var>p<sub>7</sub></var> ( 0 ≤ <var>p<sub>i</sub></var> ≤ 10,000) が空白区切りで１行に与えられます。
</p>
<H2>出力</H2>
<p>
メリーゴーランドの乗り物の馬車を 4、車を 2、馬を 1 で表すこととします。乗り場 0, 1, ... , 7 にとめる乗り物を、それぞれ <var>c<sub>0</sub></var>, <var>c<sub>1</sub></var>,..., <var>c<sub>7</sub></var> とします。データセットごとに、<var>c<sub>0</sub></var>, <var>c<sub>1</sub></var>,..., <var>c<sub>7</sub></var> を空白区切りで 1 行に出力します。
</p>
<p>
なお、乗れなくなるお客さまが最小となるとめ方が複数ある場合は、<var>c<sub>0</sub>c<sub>1</sub>c<sub>2</sub>c<sub>3</sub>c<sub>4</sub>c<sub>5</sub>c<sub>6</sub>c<sub>7</sub></var> を 8 桁の整数 <var>V</var> とみなし、<var>V</var> が最小となるとめ方を選ぶものとします。
</p>
<p>
データセットの数は 100 を超えません。
</p>
<H2>Sample Input</H2>
<pre>
2 3 1 4 0 1 0 1
4 2 3 2 2 2 1 1
</pre>
<H2>Output for the Sample Input</H2>
<pre>
1 4 1 4 1 2 1 2
4 1 4 1 2 1 2 1
</pre>
| 2 3 1 4 0 1 0 1
4 2 3 2 2 2 1 1
| 1 4 1 4 1 2 1 2
4 1 4 1 2 1 2 1
| 12,179 |
s906512548 | p00082 | u633068244 | 1396077000 | Python | Python | py | Accepted | 10 | 4248 | 445 | c = [4,1,4,1,2,1,2,1]
while True:
try:
que = map(int, raw_input().split())
mx,mxc = 0, "99999999"
for sp in range(8):
sm = 0
for num in range(8):
sm += c[(sp+num)%8] if c[(sp+num)%8] <= que[num] else que[num]
if sm > mx:
mx = sm
mxc = "".join(map(str, c[sp:]+c[:sp]))
elif sm == mx:
ac = "".join(map(str, c[sp:]+c[:sp]))
if int(mxc) > int(ac):
mxc = ac
print " ".join(map(str, mxc))
except:
break | p00082 |
<H1>メリーゴーランド</H1>
<center>
<img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_10_1">
</center><br/>
<p>
遊園地にあるメリーゴーランドはご存じでしょう。大きな円盤の上に馬や馬車などの乗り物が固定されていて、円盤が回転すると同時に乗り物が上下に揺れる、定番の遊具です。ある遊園地のメリーゴーランドは、４人乗りの馬車が２台、２人乗りの車２台、１人乗りの馬が４台、計８台の乗り物が図１のような順序で備えられています。そして、遊園地においでのお客様は、図１に示す乗り場０〜７のどこかで待つようになっています。
</p>
<center>
<img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_10_2">
</center><br/>
<p>
この遊園地のメリーゴーランドは、かならず乗り物が乗り場にぴったりと合う位置に停止します。そして、０〜７のそれぞれで待っているお客さまは、目の前にとまった乗り物に乗ることになっています。急いで他の乗り場へ移動してそこから乗るということはできません。効率よく、お客さまにたのしんでいただくためには、メリーゴーランドの停止する位置をうまく調整して、乗れないお客さまをできるだけ少なくするようにしなければなりません。
</p>
<p>
乗り場０〜７で待っているお客さまの人数を読み込んで、どの位置にどの乗り物が来るように止めれば乗れないお客さまが最も少なくなるかを出力するプログラムを作成してください。
<!--なお、乗れなくなるお客さまが最小となるとめ方が何通りもある場合は、そのうちの一つだけ出力するようにしてください。-->
</p>
<H2>入力</H2>
<p>
入力は複数のデータセットからなります。各データセットは以下の形式で与えられます。
</p>
<pre>
<var>p<sub>0</sub></var> <var>p<sub>1</sub></var> <var>p<sub>2</sub></var> <var>p<sub>3</sub></var> <var>p<sub>4</sub></var> <var>p<sub>5</sub></var> <var>p<sub>6</sub></var> <var>p<sub>7</sub></var>
</pre>
<p>
乗り場 0, 1, ..., 7 で待っているお客様の人数を表す整数 <var>p<sub>0</sub></var>, <var>p<sub>1</sub></var>,... , <var>p<sub>7</sub></var> ( 0 ≤ <var>p<sub>i</sub></var> ≤ 10,000) が空白区切りで１行に与えられます。
</p>
<H2>出力</H2>
<p>
メリーゴーランドの乗り物の馬車を 4、車を 2、馬を 1 で表すこととします。乗り場 0, 1, ... , 7 にとめる乗り物を、それぞれ <var>c<sub>0</sub></var>, <var>c<sub>1</sub></var>,..., <var>c<sub>7</sub></var> とします。データセットごとに、<var>c<sub>0</sub></var>, <var>c<sub>1</sub></var>,..., <var>c<sub>7</sub></var> を空白区切りで 1 行に出力します。
</p>
<p>
なお、乗れなくなるお客さまが最小となるとめ方が複数ある場合は、<var>c<sub>0</sub>c<sub>1</sub>c<sub>2</sub>c<sub>3</sub>c<sub>4</sub>c<sub>5</sub>c<sub>6</sub>c<sub>7</sub></var> を 8 桁の整数 <var>V</var> とみなし、<var>V</var> が最小となるとめ方を選ぶものとします。
</p>
<p>
データセットの数は 100 を超えません。
</p>
<H2>Sample Input</H2>
<pre>
2 3 1 4 0 1 0 1
4 2 3 2 2 2 1 1
</pre>
<H2>Output for the Sample Input</H2>
<pre>
1 4 1 4 1 2 1 2
4 1 4 1 2 1 2 1
</pre>
| 2 3 1 4 0 1 0 1
4 2 3 2 2 2 1 1
| 1 4 1 4 1 2 1 2
4 1 4 1 2 1 2 1
| 12,180 |
s801839451 | p00082 | u912237403 | 1397937483 | Python | Python | py | Accepted | 20 | 4232 | 301 | R=range(8)
A=[4,1,4,1,2,1,2,1]
A+=A
B="41412121"
B=map(int,[B[i:]+B[:i] for i in R])
import sys
for s in sys.stdin:
x=map(int,s[:-1].split())
m=sum(x)
for i in R:
s=sum([max(0,x[j]-A[i+j]) for j in R])
if s<m: m,p=s,i
elif m==s and B[i]<B[p]: p=i
for i in R: print A[p+i],
print | p00082 |
<H1>メリーゴーランド</H1>
<center>
<img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_10_1">
</center><br/>
<p>
遊園地にあるメリーゴーランドはご存じでしょう。大きな円盤の上に馬や馬車などの乗り物が固定されていて、円盤が回転すると同時に乗り物が上下に揺れる、定番の遊具です。ある遊園地のメリーゴーランドは、４人乗りの馬車が２台、２人乗りの車２台、１人乗りの馬が４台、計８台の乗り物が図１のような順序で備えられています。そして、遊園地においでのお客様は、図１に示す乗り場０〜７のどこかで待つようになっています。
</p>
<center>
<img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_10_2">
</center><br/>
<p>
この遊園地のメリーゴーランドは、かならず乗り物が乗り場にぴったりと合う位置に停止します。そして、０〜７のそれぞれで待っているお客さまは、目の前にとまった乗り物に乗ることになっています。急いで他の乗り場へ移動してそこから乗るということはできません。効率よく、お客さまにたのしんでいただくためには、メリーゴーランドの停止する位置をうまく調整して、乗れないお客さまをできるだけ少なくするようにしなければなりません。
</p>
<p>
乗り場０〜７で待っているお客さまの人数を読み込んで、どの位置にどの乗り物が来るように止めれば乗れないお客さまが最も少なくなるかを出力するプログラムを作成してください。
<!--なお、乗れなくなるお客さまが最小となるとめ方が何通りもある場合は、そのうちの一つだけ出力するようにしてください。-->
</p>
<H2>入力</H2>
<p>
入力は複数のデータセットからなります。各データセットは以下の形式で与えられます。
</p>
<pre>
<var>p<sub>0</sub></var> <var>p<sub>1</sub></var> <var>p<sub>2</sub></var> <var>p<sub>3</sub></var> <var>p<sub>4</sub></var> <var>p<sub>5</sub></var> <var>p<sub>6</sub></var> <var>p<sub>7</sub></var>
</pre>
<p>
乗り場 0, 1, ..., 7 で待っているお客様の人数を表す整数 <var>p<sub>0</sub></var>, <var>p<sub>1</sub></var>,... , <var>p<sub>7</sub></var> ( 0 ≤ <var>p<sub>i</sub></var> ≤ 10,000) が空白区切りで１行に与えられます。
</p>
<H2>出力</H2>
<p>
メリーゴーランドの乗り物の馬車を 4、車を 2、馬を 1 で表すこととします。乗り場 0, 1, ... , 7 にとめる乗り物を、それぞれ <var>c<sub>0</sub></var>, <var>c<sub>1</sub></var>,..., <var>c<sub>7</sub></var> とします。データセットごとに、<var>c<sub>0</sub></var>, <var>c<sub>1</sub></var>,..., <var>c<sub>7</sub></var> を空白区切りで 1 行に出力します。
</p>
<p>
なお、乗れなくなるお客さまが最小となるとめ方が複数ある場合は、<var>c<sub>0</sub>c<sub>1</sub>c<sub>2</sub>c<sub>3</sub>c<sub>4</sub>c<sub>5</sub>c<sub>6</sub>c<sub>7</sub></var> を 8 桁の整数 <var>V</var> とみなし、<var>V</var> が最小となるとめ方を選ぶものとします。
</p>
<p>
データセットの数は 100 を超えません。
</p>
<H2>Sample Input</H2>
<pre>
2 3 1 4 0 1 0 1
4 2 3 2 2 2 1 1
</pre>
<H2>Output for the Sample Input</H2>
<pre>
1 4 1 4 1 2 1 2
4 1 4 1 2 1 2 1
</pre>
| 2 3 1 4 0 1 0 1
4 2 3 2 2 2 1 1
| 1 4 1 4 1 2 1 2
4 1 4 1 2 1 2 1
| 12,181 |
s575986422 | p00082 | u912237403 | 1397937823 | Python | Python | py | Accepted | 20 | 4244 | 299 | R=range(8)
A=[4,1,4,1,2,1,2,1]
A+=A
B="41412121"
B=map(int,[B[i:]+B[:i] for i in R])
import sys
for s in sys.stdin:
x=map(int,s[:-1].split())
m=sum(x)
for i in R:
s=sum([max(0,x[j]-A[i+j]) for j in R])
if s<m: m,p=s,B[i]
elif m==s and B[i]<p: p=B[i]
print " ".join(list(str(p))) | p00082 |
<H1>メリーゴーランド</H1>
<center>
<img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_10_1">
</center><br/>
<p>
遊園地にあるメリーゴーランドはご存じでしょう。大きな円盤の上に馬や馬車などの乗り物が固定されていて、円盤が回転すると同時に乗り物が上下に揺れる、定番の遊具です。ある遊園地のメリーゴーランドは、４人乗りの馬車が２台、２人乗りの車２台、１人乗りの馬が４台、計８台の乗り物が図１のような順序で備えられています。そして、遊園地においでのお客様は、図１に示す乗り場０〜７のどこかで待つようになっています。
</p>
<center>
<img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_10_2">
</center><br/>
<p>
この遊園地のメリーゴーランドは、かならず乗り物が乗り場にぴったりと合う位置に停止します。そして、０〜７のそれぞれで待っているお客さまは、目の前にとまった乗り物に乗ることになっています。急いで他の乗り場へ移動してそこから乗るということはできません。効率よく、お客さまにたのしんでいただくためには、メリーゴーランドの停止する位置をうまく調整して、乗れないお客さまをできるだけ少なくするようにしなければなりません。
</p>
<p>
乗り場０〜７で待っているお客さまの人数を読み込んで、どの位置にどの乗り物が来るように止めれば乗れないお客さまが最も少なくなるかを出力するプログラムを作成してください。
<!--なお、乗れなくなるお客さまが最小となるとめ方が何通りもある場合は、そのうちの一つだけ出力するようにしてください。-->
</p>
<H2>入力</H2>
<p>
入力は複数のデータセットからなります。各データセットは以下の形式で与えられます。
</p>
<pre>
<var>p<sub>0</sub></var> <var>p<sub>1</sub></var> <var>p<sub>2</sub></var> <var>p<sub>3</sub></var> <var>p<sub>4</sub></var> <var>p<sub>5</sub></var> <var>p<sub>6</sub></var> <var>p<sub>7</sub></var>
</pre>
<p>
乗り場 0, 1, ..., 7 で待っているお客様の人数を表す整数 <var>p<sub>0</sub></var>, <var>p<sub>1</sub></var>,... , <var>p<sub>7</sub></var> ( 0 ≤ <var>p<sub>i</sub></var> ≤ 10,000) が空白区切りで１行に与えられます。
</p>
<H2>出力</H2>
<p>
メリーゴーランドの乗り物の馬車を 4、車を 2、馬を 1 で表すこととします。乗り場 0, 1, ... , 7 にとめる乗り物を、それぞれ <var>c<sub>0</sub></var>, <var>c<sub>1</sub></var>,..., <var>c<sub>7</sub></var> とします。データセットごとに、<var>c<sub>0</sub></var>, <var>c<sub>1</sub></var>,..., <var>c<sub>7</sub></var> を空白区切りで 1 行に出力します。
</p>
<p>
なお、乗れなくなるお客さまが最小となるとめ方が複数ある場合は、<var>c<sub>0</sub>c<sub>1</sub>c<sub>2</sub>c<sub>3</sub>c<sub>4</sub>c<sub>5</sub>c<sub>6</sub>c<sub>7</sub></var> を 8 桁の整数 <var>V</var> とみなし、<var>V</var> が最小となるとめ方を選ぶものとします。
</p>
<p>
データセットの数は 100 を超えません。
</p>
<H2>Sample Input</H2>
<pre>
2 3 1 4 0 1 0 1
4 2 3 2 2 2 1 1
</pre>
<H2>Output for the Sample Input</H2>
<pre>
1 4 1 4 1 2 1 2
4 1 4 1 2 1 2 1
</pre>
| 2 3 1 4 0 1 0 1
4 2 3 2 2 2 1 1
| 1 4 1 4 1 2 1 2
4 1 4 1 2 1 2 1
| 12,182 |
s619676189 | p00082 | u912237403 | 1397938081 | Python | Python | py | Accepted | 20 | 4240 | 322 | R = range(8)
A = [4,1,4,1,2,1,2,1]
A += A
B = "41412121"
B = map(int, [B[i:]+B[:i] for i in R])
import sys
for s in sys.stdin:
x = map(int, s[:-1].split())
m = sum(x)
for i in R:
s = sum([max(0, x[j] - A[i+j]) for j in R])
if s<m: m,p = s,B[i]
elif m==s and B[i]<p: p=B[i]
print " ".join(list(str(p))) | p00082 |
<H1>メリーゴーランド</H1>
<center>
<img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_10_1">
</center><br/>
<p>
遊園地にあるメリーゴーランドはご存じでしょう。大きな円盤の上に馬や馬車などの乗り物が固定されていて、円盤が回転すると同時に乗り物が上下に揺れる、定番の遊具です。ある遊園地のメリーゴーランドは、４人乗りの馬車が２台、２人乗りの車２台、１人乗りの馬が４台、計８台の乗り物が図１のような順序で備えられています。そして、遊園地においでのお客様は、図１に示す乗り場０〜７のどこかで待つようになっています。
</p>
<center>
<img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_10_2">
</center><br/>
<p>
この遊園地のメリーゴーランドは、かならず乗り物が乗り場にぴったりと合う位置に停止します。そして、０〜７のそれぞれで待っているお客さまは、目の前にとまった乗り物に乗ることになっています。急いで他の乗り場へ移動してそこから乗るということはできません。効率よく、お客さまにたのしんでいただくためには、メリーゴーランドの停止する位置をうまく調整して、乗れないお客さまをできるだけ少なくするようにしなければなりません。
</p>
<p>
乗り場０〜７で待っているお客さまの人数を読み込んで、どの位置にどの乗り物が来るように止めれば乗れないお客さまが最も少なくなるかを出力するプログラムを作成してください。
<!--なお、乗れなくなるお客さまが最小となるとめ方が何通りもある場合は、そのうちの一つだけ出力するようにしてください。-->
</p>
<H2>入力</H2>
<p>
入力は複数のデータセットからなります。各データセットは以下の形式で与えられます。
</p>
<pre>
<var>p<sub>0</sub></var> <var>p<sub>1</sub></var> <var>p<sub>2</sub></var> <var>p<sub>3</sub></var> <var>p<sub>4</sub></var> <var>p<sub>5</sub></var> <var>p<sub>6</sub></var> <var>p<sub>7</sub></var>
</pre>
<p>
乗り場 0, 1, ..., 7 で待っているお客様の人数を表す整数 <var>p<sub>0</sub></var>, <var>p<sub>1</sub></var>,... , <var>p<sub>7</sub></var> ( 0 ≤ <var>p<sub>i</sub></var> ≤ 10,000) が空白区切りで１行に与えられます。
</p>
<H2>出力</H2>
<p>
メリーゴーランドの乗り物の馬車を 4、車を 2、馬を 1 で表すこととします。乗り場 0, 1, ... , 7 にとめる乗り物を、それぞれ <var>c<sub>0</sub></var>, <var>c<sub>1</sub></var>,..., <var>c<sub>7</sub></var> とします。データセットごとに、<var>c<sub>0</sub></var>, <var>c<sub>1</sub></var>,..., <var>c<sub>7</sub></var> を空白区切りで 1 行に出力します。
</p>
<p>
なお、乗れなくなるお客さまが最小となるとめ方が複数ある場合は、<var>c<sub>0</sub>c<sub>1</sub>c<sub>2</sub>c<sub>3</sub>c<sub>4</sub>c<sub>5</sub>c<sub>6</sub>c<sub>7</sub></var> を 8 桁の整数 <var>V</var> とみなし、<var>V</var> が最小となるとめ方を選ぶものとします。
</p>
<p>
データセットの数は 100 を超えません。
</p>
<H2>Sample Input</H2>
<pre>
2 3 1 4 0 1 0 1
4 2 3 2 2 2 1 1
</pre>
<H2>Output for the Sample Input</H2>
<pre>
1 4 1 4 1 2 1 2
4 1 4 1 2 1 2 1
</pre>
| 2 3 1 4 0 1 0 1
4 2 3 2 2 2 1 1
| 1 4 1 4 1 2 1 2
4 1 4 1 2 1 2 1
| 12,183 |
s944581814 | p00082 | u912237403 | 1397938197 | Python | Python | py | Accepted | 20 | 4244 | 329 | R = range(8)
A = [4,1,4,1,2,1,2,1]
A += A
B = "41412121"
B = map(int, [B[i:]+B[:i] for i in R])
import sys
for s in sys.stdin:
x = map(int, s[:-1].split())
m = sum(x)
for i in R:
s = sum([max(0, x[j] - A[i+j]) for j in R])
if s<m: m,p = s,B[i]
elif m==s and B[i]<p: p=B[i]
a= " ".join(list(str(p)))
print a | p00082 |
<H1>メリーゴーランド</H1>
<center>
<img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_10_1">
</center><br/>
<p>
遊園地にあるメリーゴーランドはご存じでしょう。大きな円盤の上に馬や馬車などの乗り物が固定されていて、円盤が回転すると同時に乗り物が上下に揺れる、定番の遊具です。ある遊園地のメリーゴーランドは、４人乗りの馬車が２台、２人乗りの車２台、１人乗りの馬が４台、計８台の乗り物が図１のような順序で備えられています。そして、遊園地においでのお客様は、図１に示す乗り場０〜７のどこかで待つようになっています。
</p>
<center>
<img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_10_2">
</center><br/>
<p>
この遊園地のメリーゴーランドは、かならず乗り物が乗り場にぴったりと合う位置に停止します。そして、０〜７のそれぞれで待っているお客さまは、目の前にとまった乗り物に乗ることになっています。急いで他の乗り場へ移動してそこから乗るということはできません。効率よく、お客さまにたのしんでいただくためには、メリーゴーランドの停止する位置をうまく調整して、乗れないお客さまをできるだけ少なくするようにしなければなりません。
</p>
<p>
乗り場０〜７で待っているお客さまの人数を読み込んで、どの位置にどの乗り物が来るように止めれば乗れないお客さまが最も少なくなるかを出力するプログラムを作成してください。
<!--なお、乗れなくなるお客さまが最小となるとめ方が何通りもある場合は、そのうちの一つだけ出力するようにしてください。-->
</p>
<H2>入力</H2>
<p>
入力は複数のデータセットからなります。各データセットは以下の形式で与えられます。
</p>
<pre>
<var>p<sub>0</sub></var> <var>p<sub>1</sub></var> <var>p<sub>2</sub></var> <var>p<sub>3</sub></var> <var>p<sub>4</sub></var> <var>p<sub>5</sub></var> <var>p<sub>6</sub></var> <var>p<sub>7</sub></var>
</pre>
<p>
乗り場 0, 1, ..., 7 で待っているお客様の人数を表す整数 <var>p<sub>0</sub></var>, <var>p<sub>1</sub></var>,... , <var>p<sub>7</sub></var> ( 0 ≤ <var>p<sub>i</sub></var> ≤ 10,000) が空白区切りで１行に与えられます。
</p>
<H2>出力</H2>
<p>
メリーゴーランドの乗り物の馬車を 4、車を 2、馬を 1 で表すこととします。乗り場 0, 1, ... , 7 にとめる乗り物を、それぞれ <var>c<sub>0</sub></var>, <var>c<sub>1</sub></var>,..., <var>c<sub>7</sub></var> とします。データセットごとに、<var>c<sub>0</sub></var>, <var>c<sub>1</sub></var>,..., <var>c<sub>7</sub></var> を空白区切りで 1 行に出力します。
</p>
<p>
なお、乗れなくなるお客さまが最小となるとめ方が複数ある場合は、<var>c<sub>0</sub>c<sub>1</sub>c<sub>2</sub>c<sub>3</sub>c<sub>4</sub>c<sub>5</sub>c<sub>6</sub>c<sub>7</sub></var> を 8 桁の整数 <var>V</var> とみなし、<var>V</var> が最小となるとめ方を選ぶものとします。
</p>
<p>
データセットの数は 100 を超えません。
</p>
<H2>Sample Input</H2>
<pre>
2 3 1 4 0 1 0 1
4 2 3 2 2 2 1 1
</pre>
<H2>Output for the Sample Input</H2>
<pre>
1 4 1 4 1 2 1 2
4 1 4 1 2 1 2 1
</pre>
| 2 3 1 4 0 1 0 1
4 2 3 2 2 2 1 1
| 1 4 1 4 1 2 1 2
4 1 4 1 2 1 2 1
| 12,184 |
s839672924 | p00082 | u912237403 | 1397938515 | Python | Python | py | Accepted | 20 | 4236 | 311 | R=range(8)
A=[4,1,4,1,2,1,2,1]
A+=A
B="41412121"
B=map(int,[B[i:]+B[:i] for i in R])
import sys
for s in sys.stdin:
x=map(int,s[:-1].split())
m=sum(x)
for i in R:
s=sum([max(0,x[j]-A[i+j]) for j in R])
if s<m:
m=s
p=B[i]
elif m==s and B[i]<p: p=B[i]
print " ".join(list(str(p))) | p00082 |
<H1>メリーゴーランド</H1>
<center>
<img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_10_1">
</center><br/>
<p>
遊園地にあるメリーゴーランドはご存じでしょう。大きな円盤の上に馬や馬車などの乗り物が固定されていて、円盤が回転すると同時に乗り物が上下に揺れる、定番の遊具です。ある遊園地のメリーゴーランドは、４人乗りの馬車が２台、２人乗りの車２台、１人乗りの馬が４台、計８台の乗り物が図１のような順序で備えられています。そして、遊園地においでのお客様は、図１に示す乗り場０〜７のどこかで待つようになっています。
</p>
<center>
<img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_10_2">
</center><br/>
<p>
この遊園地のメリーゴーランドは、かならず乗り物が乗り場にぴったりと合う位置に停止します。そして、０〜７のそれぞれで待っているお客さまは、目の前にとまった乗り物に乗ることになっています。急いで他の乗り場へ移動してそこから乗るということはできません。効率よく、お客さまにたのしんでいただくためには、メリーゴーランドの停止する位置をうまく調整して、乗れないお客さまをできるだけ少なくするようにしなければなりません。
</p>
<p>
乗り場０〜７で待っているお客さまの人数を読み込んで、どの位置にどの乗り物が来るように止めれば乗れないお客さまが最も少なくなるかを出力するプログラムを作成してください。
<!--なお、乗れなくなるお客さまが最小となるとめ方が何通りもある場合は、そのうちの一つだけ出力するようにしてください。-->
</p>
<H2>入力</H2>
<p>
入力は複数のデータセットからなります。各データセットは以下の形式で与えられます。
</p>
<pre>
<var>p<sub>0</sub></var> <var>p<sub>1</sub></var> <var>p<sub>2</sub></var> <var>p<sub>3</sub></var> <var>p<sub>4</sub></var> <var>p<sub>5</sub></var> <var>p<sub>6</sub></var> <var>p<sub>7</sub></var>
</pre>
<p>
乗り場 0, 1, ..., 7 で待っているお客様の人数を表す整数 <var>p<sub>0</sub></var>, <var>p<sub>1</sub></var>,... , <var>p<sub>7</sub></var> ( 0 ≤ <var>p<sub>i</sub></var> ≤ 10,000) が空白区切りで１行に与えられます。
</p>
<H2>出力</H2>
<p>
メリーゴーランドの乗り物の馬車を 4、車を 2、馬を 1 で表すこととします。乗り場 0, 1, ... , 7 にとめる乗り物を、それぞれ <var>c<sub>0</sub></var>, <var>c<sub>1</sub></var>,..., <var>c<sub>7</sub></var> とします。データセットごとに、<var>c<sub>0</sub></var>, <var>c<sub>1</sub></var>,..., <var>c<sub>7</sub></var> を空白区切りで 1 行に出力します。
</p>
<p>
なお、乗れなくなるお客さまが最小となるとめ方が複数ある場合は、<var>c<sub>0</sub>c<sub>1</sub>c<sub>2</sub>c<sub>3</sub>c<sub>4</sub>c<sub>5</sub>c<sub>6</sub>c<sub>7</sub></var> を 8 桁の整数 <var>V</var> とみなし、<var>V</var> が最小となるとめ方を選ぶものとします。
</p>
<p>
データセットの数は 100 を超えません。
</p>
<H2>Sample Input</H2>
<pre>
2 3 1 4 0 1 0 1
4 2 3 2 2 2 1 1
</pre>
<H2>Output for the Sample Input</H2>
<pre>
1 4 1 4 1 2 1 2
4 1 4 1 2 1 2 1
</pre>
| 2 3 1 4 0 1 0 1
4 2 3 2 2 2 1 1
| 1 4 1 4 1 2 1 2
4 1 4 1 2 1 2 1
| 12,185 |
s659874455 | p00082 | u759949288 | 1403584489 | Python | Python | py | Accepted | 20 | 4268 | 491 | import sys
patterns = [
[1, 2, 1, 2, 1, 4, 1, 4],
[1, 2, 1, 4, 1, 4, 1, 2],
[1, 4, 1, 2, 1, 2, 1, 4],
[1, 4, 1, 4, 1, 2, 1, 2],
[2, 1, 2, 1, 4, 1, 4, 1],
[2, 1, 4, 1, 4, 1, 2, 1],
[4, 1, 2, 1, 2, 1, 4, 1],
[4, 1, 4, 1, 2, 1, 2, 1],
]
while True:
try:
p = [int(x) for x in raw_input().split()]
m = 999999999
for ptn in patterns:
rem = sum(max(0, v - x) for v, x in zip(ptn, p))
if rem < m:
m = rem
pt = ptn
print " ".join([str(x) for x in pt])
except:
break | p00082 |
<H1>メリーゴーランド</H1>
<center>
<img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_10_1">
</center><br/>
<p>
遊園地にあるメリーゴーランドはご存じでしょう。大きな円盤の上に馬や馬車などの乗り物が固定されていて、円盤が回転すると同時に乗り物が上下に揺れる、定番の遊具です。ある遊園地のメリーゴーランドは、４人乗りの馬車が２台、２人乗りの車２台、１人乗りの馬が４台、計８台の乗り物が図１のような順序で備えられています。そして、遊園地においでのお客様は、図１に示す乗り場０〜７のどこかで待つようになっています。
</p>
<center>
<img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_10_2">
</center><br/>
<p>
この遊園地のメリーゴーランドは、かならず乗り物が乗り場にぴったりと合う位置に停止します。そして、０〜７のそれぞれで待っているお客さまは、目の前にとまった乗り物に乗ることになっています。急いで他の乗り場へ移動してそこから乗るということはできません。効率よく、お客さまにたのしんでいただくためには、メリーゴーランドの停止する位置をうまく調整して、乗れないお客さまをできるだけ少なくするようにしなければなりません。
</p>
<p>
乗り場０〜７で待っているお客さまの人数を読み込んで、どの位置にどの乗り物が来るように止めれば乗れないお客さまが最も少なくなるかを出力するプログラムを作成してください。
<!--なお、乗れなくなるお客さまが最小となるとめ方が何通りもある場合は、そのうちの一つだけ出力するようにしてください。-->
</p>
<H2>入力</H2>
<p>
入力は複数のデータセットからなります。各データセットは以下の形式で与えられます。
</p>
<pre>
<var>p<sub>0</sub></var> <var>p<sub>1</sub></var> <var>p<sub>2</sub></var> <var>p<sub>3</sub></var> <var>p<sub>4</sub></var> <var>p<sub>5</sub></var> <var>p<sub>6</sub></var> <var>p<sub>7</sub></var>
</pre>
<p>
乗り場 0, 1, ..., 7 で待っているお客様の人数を表す整数 <var>p<sub>0</sub></var>, <var>p<sub>1</sub></var>,... , <var>p<sub>7</sub></var> ( 0 ≤ <var>p<sub>i</sub></var> ≤ 10,000) が空白区切りで１行に与えられます。
</p>
<H2>出力</H2>
<p>
メリーゴーランドの乗り物の馬車を 4、車を 2、馬を 1 で表すこととします。乗り場 0, 1, ... , 7 にとめる乗り物を、それぞれ <var>c<sub>0</sub></var>, <var>c<sub>1</sub></var>,..., <var>c<sub>7</sub></var> とします。データセットごとに、<var>c<sub>0</sub></var>, <var>c<sub>1</sub></var>,..., <var>c<sub>7</sub></var> を空白区切りで 1 行に出力します。
</p>
<p>
なお、乗れなくなるお客さまが最小となるとめ方が複数ある場合は、<var>c<sub>0</sub>c<sub>1</sub>c<sub>2</sub>c<sub>3</sub>c<sub>4</sub>c<sub>5</sub>c<sub>6</sub>c<sub>7</sub></var> を 8 桁の整数 <var>V</var> とみなし、<var>V</var> が最小となるとめ方を選ぶものとします。
</p>
<p>
データセットの数は 100 を超えません。
</p>
<H2>Sample Input</H2>
<pre>
2 3 1 4 0 1 0 1
4 2 3 2 2 2 1 1
</pre>
<H2>Output for the Sample Input</H2>
<pre>
1 4 1 4 1 2 1 2
4 1 4 1 2 1 2 1
</pre>
| 2 3 1 4 0 1 0 1
4 2 3 2 2 2 1 1
| 1 4 1 4 1 2 1 2
4 1 4 1 2 1 2 1
| 12,186 |
s303379524 | p00082 | u187074069 | 1595402060 | Python | Python3 | py | Accepted | 30 | 5604 | 672 | lst = [[1, 2, 1, 2, 1, 4, 1, 4],
[1, 2, 1, 4, 1, 4, 1, 2],
[1, 4, 1, 2, 1, 2, 1, 4],
[1, 4, 1, 4, 1, 2, 1, 2],
[2, 1, 2, 1, 4, 1, 4, 1],
[2, 1, 4, 1, 4, 1, 2, 1],
[4, 1, 2, 1, 2, 1, 4, 1],
[4, 1, 4, 1, 2, 1, 2, 1]]
while True:
try:
inputlst = list(map(int, input().split()))
m = 70000
ans = 0
for num, i in enumerate(lst):
n = 0
for j, k in zip(inputlst,i):
if j > k:
n = n + (j - k)
if m > n:
m = n
ans = num
print(*lst[ans])
except EOFError:
break
| p00082 |
<H1>メリーゴーランド</H1>
<center>
<img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_10_1">
</center><br/>
<p>
遊園地にあるメリーゴーランドはご存じでしょう。大きな円盤の上に馬や馬車などの乗り物が固定されていて、円盤が回転すると同時に乗り物が上下に揺れる、定番の遊具です。ある遊園地のメリーゴーランドは、４人乗りの馬車が２台、２人乗りの車２台、１人乗りの馬が４台、計８台の乗り物が図１のような順序で備えられています。そして、遊園地においでのお客様は、図１に示す乗り場０〜７のどこかで待つようになっています。
</p>
<center>
<img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_10_2">
</center><br/>
<p>
この遊園地のメリーゴーランドは、かならず乗り物が乗り場にぴったりと合う位置に停止します。そして、０〜７のそれぞれで待っているお客さまは、目の前にとまった乗り物に乗ることになっています。急いで他の乗り場へ移動してそこから乗るということはできません。効率よく、お客さまにたのしんでいただくためには、メリーゴーランドの停止する位置をうまく調整して、乗れないお客さまをできるだけ少なくするようにしなければなりません。
</p>
<p>
乗り場０〜７で待っているお客さまの人数を読み込んで、どの位置にどの乗り物が来るように止めれば乗れないお客さまが最も少なくなるかを出力するプログラムを作成してください。
<!--なお、乗れなくなるお客さまが最小となるとめ方が何通りもある場合は、そのうちの一つだけ出力するようにしてください。-->
</p>
<H2>入力</H2>
<p>
入力は複数のデータセットからなります。各データセットは以下の形式で与えられます。
</p>
<pre>
<var>p<sub>0</sub></var> <var>p<sub>1</sub></var> <var>p<sub>2</sub></var> <var>p<sub>3</sub></var> <var>p<sub>4</sub></var> <var>p<sub>5</sub></var> <var>p<sub>6</sub></var> <var>p<sub>7</sub></var>
</pre>
<p>
乗り場 0, 1, ..., 7 で待っているお客様の人数を表す整数 <var>p<sub>0</sub></var>, <var>p<sub>1</sub></var>,... , <var>p<sub>7</sub></var> ( 0 ≤ <var>p<sub>i</sub></var> ≤ 10,000) が空白区切りで１行に与えられます。
</p>
<H2>出力</H2>
<p>
メリーゴーランドの乗り物の馬車を 4、車を 2、馬を 1 で表すこととします。乗り場 0, 1, ... , 7 にとめる乗り物を、それぞれ <var>c<sub>0</sub></var>, <var>c<sub>1</sub></var>,..., <var>c<sub>7</sub></var> とします。データセットごとに、<var>c<sub>0</sub></var>, <var>c<sub>1</sub></var>,..., <var>c<sub>7</sub></var> を空白区切りで 1 行に出力します。
</p>
<p>
なお、乗れなくなるお客さまが最小となるとめ方が複数ある場合は、<var>c<sub>0</sub>c<sub>1</sub>c<sub>2</sub>c<sub>3</sub>c<sub>4</sub>c<sub>5</sub>c<sub>6</sub>c<sub>7</sub></var> を 8 桁の整数 <var>V</var> とみなし、<var>V</var> が最小となるとめ方を選ぶものとします。
</p>
<p>
データセットの数は 100 を超えません。
</p>
<H2>Sample Input</H2>
<pre>
2 3 1 4 0 1 0 1
4 2 3 2 2 2 1 1
</pre>
<H2>Output for the Sample Input</H2>
<pre>
1 4 1 4 1 2 1 2
4 1 4 1 2 1 2 1
</pre>
| 2 3 1 4 0 1 0 1
4 2 3 2 2 2 1 1
| 1 4 1 4 1 2 1 2
4 1 4 1 2 1 2 1
| 12,187 |
s516519273 | p00082 | u630911389 | 1583893310 | Python | Python3 | py | Accepted | 30 | 5620 | 1,158 | table = [4,1,4,1,2,1,2,1]
def round():
item = table.pop(0)
table.append(item)
def getRideNum(participants):
rideNum = 0
for i in range(0,8):
n = table[i] - participants[i]
if n >= 0:
n = participants[i]
else:
n = table[i]
rideNum += n
return rideNum
def tableToNum(t):
num = 0
for i in range(7,-1,-1):
n = t[i] * pow(10,7 - i)
num += n
return num
while(1):
try:
participants = list(int(x) for x in input().split())
maxRideNum = 0
maxTable = []
for i in range(0,8):
rideNum = getRideNum(participants)
if rideNum > maxRideNum:
maxRideNum = rideNum
maxTable = table.copy()
elif rideNum == maxRideNum:
if tableToNum(table) < tableToNum(maxTable):
maxTable = table.copy()
round()
for i in range(0,len(maxTable)):
if i != 0:
print(" ",end="")
print(maxTable[i],end="")
print()
except EOFError:
break
| p00082 |
<H1>メリーゴーランド</H1>
<center>
<img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_10_1">
</center><br/>
<p>
遊園地にあるメリーゴーランドはご存じでしょう。大きな円盤の上に馬や馬車などの乗り物が固定されていて、円盤が回転すると同時に乗り物が上下に揺れる、定番の遊具です。ある遊園地のメリーゴーランドは、４人乗りの馬車が２台、２人乗りの車２台、１人乗りの馬が４台、計８台の乗り物が図１のような順序で備えられています。そして、遊園地においでのお客様は、図１に示す乗り場０〜７のどこかで待つようになっています。
</p>
<center>
<img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_10_2">
</center><br/>
<p>
この遊園地のメリーゴーランドは、かならず乗り物が乗り場にぴったりと合う位置に停止します。そして、０〜７のそれぞれで待っているお客さまは、目の前にとまった乗り物に乗ることになっています。急いで他の乗り場へ移動してそこから乗るということはできません。効率よく、お客さまにたのしんでいただくためには、メリーゴーランドの停止する位置をうまく調整して、乗れないお客さまをできるだけ少なくするようにしなければなりません。
</p>
<p>
乗り場０〜７で待っているお客さまの人数を読み込んで、どの位置にどの乗り物が来るように止めれば乗れないお客さまが最も少なくなるかを出力するプログラムを作成してください。
<!--なお、乗れなくなるお客さまが最小となるとめ方が何通りもある場合は、そのうちの一つだけ出力するようにしてください。-->
</p>
<H2>入力</H2>
<p>
入力は複数のデータセットからなります。各データセットは以下の形式で与えられます。
</p>
<pre>
<var>p<sub>0</sub></var> <var>p<sub>1</sub></var> <var>p<sub>2</sub></var> <var>p<sub>3</sub></var> <var>p<sub>4</sub></var> <var>p<sub>5</sub></var> <var>p<sub>6</sub></var> <var>p<sub>7</sub></var>
</pre>
<p>
乗り場 0, 1, ..., 7 で待っているお客様の人数を表す整数 <var>p<sub>0</sub></var>, <var>p<sub>1</sub></var>,... , <var>p<sub>7</sub></var> ( 0 ≤ <var>p<sub>i</sub></var> ≤ 10,000) が空白区切りで１行に与えられます。
</p>
<H2>出力</H2>
<p>
メリーゴーランドの乗り物の馬車を 4、車を 2、馬を 1 で表すこととします。乗り場 0, 1, ... , 7 にとめる乗り物を、それぞれ <var>c<sub>0</sub></var>, <var>c<sub>1</sub></var>,..., <var>c<sub>7</sub></var> とします。データセットごとに、<var>c<sub>0</sub></var>, <var>c<sub>1</sub></var>,..., <var>c<sub>7</sub></var> を空白区切りで 1 行に出力します。
</p>
<p>
なお、乗れなくなるお客さまが最小となるとめ方が複数ある場合は、<var>c<sub>0</sub>c<sub>1</sub>c<sub>2</sub>c<sub>3</sub>c<sub>4</sub>c<sub>5</sub>c<sub>6</sub>c<sub>7</sub></var> を 8 桁の整数 <var>V</var> とみなし、<var>V</var> が最小となるとめ方を選ぶものとします。
</p>
<p>
データセットの数は 100 を超えません。
</p>
<H2>Sample Input</H2>
<pre>
2 3 1 4 0 1 0 1
4 2 3 2 2 2 1 1
</pre>
<H2>Output for the Sample Input</H2>
<pre>
1 4 1 4 1 2 1 2
4 1 4 1 2 1 2 1
</pre>
| 2 3 1 4 0 1 0 1
4 2 3 2 2 2 1 1
| 1 4 1 4 1 2 1 2
4 1 4 1 2 1 2 1
| 12,188 |
s278000235 | p00082 | u563075864 | 1545122194 | Python | Python3 | py | Accepted | 50 | 6340 | 803 | from copy import copy
p = []
while(1):
try:
p = [int(i) for i in input().split()]
min_ = 10**10
point = 0
arrmin = []
arr = [4,1,4,1,2,1,2,1]
for _ in range(8):
temp = copy(arr[0])
repl = copy(arr[1:8])
arr[0:7] = repl
arr[7] = temp
point = sum([j-i if i < j else 0 for i,j in zip(arr,p)])
if point == min_:
arrmin.append(copy(arr))
min_ = point
elif point < min_:
arrmin = [copy(arr)]
min_ = point
arrmin = ["".join([str(i) for i in j]) for j in arrmin]
amin = min([int(i) for i in arrmin])
out = list(str(amin))
print(" ".join(out))
except EOFError:
break
| p00082 |
<H1>メリーゴーランド</H1>
<center>
<img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_10_1">
</center><br/>
<p>
遊園地にあるメリーゴーランドはご存じでしょう。大きな円盤の上に馬や馬車などの乗り物が固定されていて、円盤が回転すると同時に乗り物が上下に揺れる、定番の遊具です。ある遊園地のメリーゴーランドは、４人乗りの馬車が２台、２人乗りの車２台、１人乗りの馬が４台、計８台の乗り物が図１のような順序で備えられています。そして、遊園地においでのお客様は、図１に示す乗り場０〜７のどこかで待つようになっています。
</p>
<center>
<img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_10_2">
</center><br/>
<p>
この遊園地のメリーゴーランドは、かならず乗り物が乗り場にぴったりと合う位置に停止します。そして、０〜７のそれぞれで待っているお客さまは、目の前にとまった乗り物に乗ることになっています。急いで他の乗り場へ移動してそこから乗るということはできません。効率よく、お客さまにたのしんでいただくためには、メリーゴーランドの停止する位置をうまく調整して、乗れないお客さまをできるだけ少なくするようにしなければなりません。
</p>
<p>
乗り場０〜７で待っているお客さまの人数を読み込んで、どの位置にどの乗り物が来るように止めれば乗れないお客さまが最も少なくなるかを出力するプログラムを作成してください。
<!--なお、乗れなくなるお客さまが最小となるとめ方が何通りもある場合は、そのうちの一つだけ出力するようにしてください。-->
</p>
<H2>入力</H2>
<p>
入力は複数のデータセットからなります。各データセットは以下の形式で与えられます。
</p>
<pre>
<var>p<sub>0</sub></var> <var>p<sub>1</sub></var> <var>p<sub>2</sub></var> <var>p<sub>3</sub></var> <var>p<sub>4</sub></var> <var>p<sub>5</sub></var> <var>p<sub>6</sub></var> <var>p<sub>7</sub></var>
</pre>
<p>
乗り場 0, 1, ..., 7 で待っているお客様の人数を表す整数 <var>p<sub>0</sub></var>, <var>p<sub>1</sub></var>,... , <var>p<sub>7</sub></var> ( 0 ≤ <var>p<sub>i</sub></var> ≤ 10,000) が空白区切りで１行に与えられます。
</p>
<H2>出力</H2>
<p>
メリーゴーランドの乗り物の馬車を 4、車を 2、馬を 1 で表すこととします。乗り場 0, 1, ... , 7 にとめる乗り物を、それぞれ <var>c<sub>0</sub></var>, <var>c<sub>1</sub></var>,..., <var>c<sub>7</sub></var> とします。データセットごとに、<var>c<sub>0</sub></var>, <var>c<sub>1</sub></var>,..., <var>c<sub>7</sub></var> を空白区切りで 1 行に出力します。
</p>
<p>
なお、乗れなくなるお客さまが最小となるとめ方が複数ある場合は、<var>c<sub>0</sub>c<sub>1</sub>c<sub>2</sub>c<sub>3</sub>c<sub>4</sub>c<sub>5</sub>c<sub>6</sub>c<sub>7</sub></var> を 8 桁の整数 <var>V</var> とみなし、<var>V</var> が最小となるとめ方を選ぶものとします。
</p>
<p>
データセットの数は 100 を超えません。
</p>
<H2>Sample Input</H2>
<pre>
2 3 1 4 0 1 0 1
4 2 3 2 2 2 1 1
</pre>
<H2>Output for the Sample Input</H2>
<pre>
1 4 1 4 1 2 1 2
4 1 4 1 2 1 2 1
</pre>
| 2 3 1 4 0 1 0 1
4 2 3 2 2 2 1 1
| 1 4 1 4 1 2 1 2
4 1 4 1 2 1 2 1
| 12,189 |
s307540279 | p00083 | u563075864 | 1545205914 | Python | Python3 | py | Accepted | 20 | 5612 | 1,018 | m_ = [31,28,31,30,31,30,31,31,30,31,30,31]
m_sum = [0]
m_sum.extend([sum(m_[0:i+1]) for i in range(12)])
def mtod(m,d):
s = m_sum[m-1] + d
return s
def dtom(s):
for i in range(13):
if s < m_sum[i]:
return i,s - m_sum[i-1]
def minus(a,b):
if a >= b:
return a-b
else:
return a + 365 - b
meiji = 1000*1868 + mtod(9,8)
taisho = 1000*1912 + mtod(7,30)
showa = 1000*1926 + mtod(12,25)
heisei = 1000*1989 + mtod(1,8)
while(1):
try:
y,m,d = [int(i) for i in input().split()]
s = 1000*y + mtod(m,d)
if s < meiji:
print("pre-meiji")
elif s < taisho:
print("meiji", int(s/1000) -int(meiji/1000) + 1, m ,d)
elif s < showa:
print("taisho", int(s/1000) -int(taisho/1000) + 1, m,d)
elif s < heisei:
print("showa", int(s/1000) -int(showa/1000) + 1, m,d)
else:
print("heisei", int(s/1000) -int(heisei/1000) + 1, m,d)
except EOFError:
break
| p00083 |
<H1>西暦和暦変換</H1>
<p>
西暦で表された年月日を、元号を用いた和暦に変換し、その年月日を出力するプログラムを作成してください。入力は例に示すように 3 つの整数であり、順に西暦年、月、日です。これを、出力例に示すように変換してください。なお、明治以前の年月日が入力された場合は「pre-meiji」と表示してください。
</p>
<p>
各年号の最初の年は「元年」ではなく「１年」と出力することとします。
</p>
<center>
<table border=1>
<tr><td align=center width=100>元号</td><td align=center width=240>期間</td></tr>
<tr><td align=center >meiji</td><td>1868. 9. 8 〜 1912. 7.29</td></tr>
<tr><td align=center >taisho</td><td>1912. 7.30 〜 1926.12.24</td></tr>
<tr><td align=center >showa</td><td>1926.12.25 〜 1989. 1. 7</td></tr>
<tr><td align=center >heisei</td><td>1989. 1. 8 〜</td></tr>
</table>
</center>
<br/>
<H2>入力</H2>
<p>
複数のデータが与えられます。各データとして年、月、日を表す３つの整数が空白区切りで１行に与えられます。
</p>
<p>
入力の終わりまで処理してください。データの数は 50 を超えません。
</p>
<H2>出力</H2>
<p>
空白区切りの元号、年、月、日、または「pre-meiji」を１行に出力してください。
</p>
<H2>Sample Input</H2>
<pre>
2005 9 3
1868 12 2
1868 9 7
</pre>
<H2>Output for the Sample Input</H2>
<pre>
heisei 17 9 3
meiji 1 12 2
pre-meiji
</pre>
| 2005 9 3
1868 12 2
1868 9 7
| heisei 17 9 3
meiji 1 12 2
pre-meiji
| 12,190 |
s220152343 | p00083 | u506132575 | 1417740094 | Python | Python | py | Accepted | 10 | 4428 | 469 | import sys
from datetime import timedelta,date
for s in sys.stdin:
y,m,d = map(int,s.split())
d = date(y,m,d)
lis = [
[date(1989,1,8),"heisei"],
[date(1926,12,25),"showa"],
[date(1912,7,30),"taisho"],
[date(1868,9,8),"meiji"]
]
for e in lis:
if d >= e[0]:
print e[1],
print d.year-e[0].year + 1,
print d.month,
print d.day
break
else:
print "pre-meiji" | p00083 |
<H1>西暦和暦変換</H1>
<p>
西暦で表された年月日を、元号を用いた和暦に変換し、その年月日を出力するプログラムを作成してください。入力は例に示すように 3 つの整数であり、順に西暦年、月、日です。これを、出力例に示すように変換してください。なお、明治以前の年月日が入力された場合は「pre-meiji」と表示してください。
</p>
<p>
各年号の最初の年は「元年」ではなく「１年」と出力することとします。
</p>
<center>
<table border=1>
<tr><td align=center width=100>元号</td><td align=center width=240>期間</td></tr>
<tr><td align=center >meiji</td><td>1868. 9. 8 〜 1912. 7.29</td></tr>
<tr><td align=center >taisho</td><td>1912. 7.30 〜 1926.12.24</td></tr>
<tr><td align=center >showa</td><td>1926.12.25 〜 1989. 1. 7</td></tr>
<tr><td align=center >heisei</td><td>1989. 1. 8 〜</td></tr>
</table>
</center>
<br/>
<H2>入力</H2>
<p>
複数のデータが与えられます。各データとして年、月、日を表す３つの整数が空白区切りで１行に与えられます。
</p>
<p>
入力の終わりまで処理してください。データの数は 50 を超えません。
</p>
<H2>出力</H2>
<p>
空白区切りの元号、年、月、日、または「pre-meiji」を１行に出力してください。
</p>
<H2>Sample Input</H2>
<pre>
2005 9 3
1868 12 2
1868 9 7
</pre>
<H2>Output for the Sample Input</H2>
<pre>
heisei 17 9 3
meiji 1 12 2
pre-meiji
</pre>
| 2005 9 3
1868 12 2
1868 9 7
| heisei 17 9 3
meiji 1 12 2
pre-meiji
| 12,191 |
s886916717 | p00083 | u567380442 | 1423278407 | Python | Python3 | py | Accepted | 30 | 7064 | 800 | import sys
f = sys.stdin
from datetime import date
eras = {'pre-meiji':{'start':None, 'end':date(1868,9,7)},
'meiji':{'start':date(1868, 9, 8), 'end':date(1912,7,29)},
'taisho':{'start':date(1912, 7, 30), 'end':date(1926,12,24)},
'showa':{'start':date(1926, 12, 25), 'end':date(1989,1,7)},
'heisei':{'start':date(1989, 1, 8), 'end':None}}
for line in f:
y, m, d = map(int, line.split())
target = date(y,m,d)
for era_name, period in eras.items():
if (period['start'] is None or period['start'] <= target) and(period['end'] is None or target <= period['end']):
if era_name == 'pre-meiji':
print(era_name)
else:
print(era_name, target.year - period['start'].year + 1, target.month, target.day)
break
| p00083 |
<H1>西暦和暦変換</H1>
<p>
西暦で表された年月日を、元号を用いた和暦に変換し、その年月日を出力するプログラムを作成してください。入力は例に示すように 3 つの整数であり、順に西暦年、月、日です。これを、出力例に示すように変換してください。なお、明治以前の年月日が入力された場合は「pre-meiji」と表示してください。
</p>
<p>
各年号の最初の年は「元年」ではなく「１年」と出力することとします。
</p>
<center>
<table border=1>
<tr><td align=center width=100>元号</td><td align=center width=240>期間</td></tr>
<tr><td align=center >meiji</td><td>1868. 9. 8 〜 1912. 7.29</td></tr>
<tr><td align=center >taisho</td><td>1912. 7.30 〜 1926.12.24</td></tr>
<tr><td align=center >showa</td><td>1926.12.25 〜 1989. 1. 7</td></tr>
<tr><td align=center >heisei</td><td>1989. 1. 8 〜</td></tr>
</table>
</center>
<br/>
<H2>入力</H2>
<p>
複数のデータが与えられます。各データとして年、月、日を表す３つの整数が空白区切りで１行に与えられます。
</p>
<p>
入力の終わりまで処理してください。データの数は 50 を超えません。
</p>
<H2>出力</H2>
<p>
空白区切りの元号、年、月、日、または「pre-meiji」を１行に出力してください。
</p>
<H2>Sample Input</H2>
<pre>
2005 9 3
1868 12 2
1868 9 7
</pre>
<H2>Output for the Sample Input</H2>
<pre>
heisei 17 9 3
meiji 1 12 2
pre-meiji
</pre>
| 2005 9 3
1868 12 2
1868 9 7
| heisei 17 9 3
meiji 1 12 2
pre-meiji
| 12,192 |
s399309154 | p00083 | u873482706 | 1435020190 | Python | Python | py | Accepted | 20 | 4252 | 656 | import sys
for line in sys.stdin:
y, m, d = map(int, line.rstrip().split())
if (1989 == y and 1 == m and 8 <= d) or (1989 == y and 2 <= m) or 1990 <= y:
print 'heisei %s %s %s' % (y-1989+1, m, d)
elif (1926 == y and 12 == m and 25 <= d) or (1927 <= y <= 1989):
print 'showa %s %s %s' % (y-1926+1, m, d)
elif (1912 == y and 7 == m and 30 <= d) or (1912 == y and 8 <= m) or (1913 <= y <= 1926):
print 'taisho %s %s %s' % (y-1912+1, m, d)
elif (1868 == y and 9 == m and 8 <= d) or (1868 == y and 10 <= m) or (1869 <= y <= 1912):
print 'meiji %s %s %s' % (y-1868+1, m, d)
else:
print 'pre-meiji' | p00083 |
<H1>西暦和暦変換</H1>
<p>
西暦で表された年月日を、元号を用いた和暦に変換し、その年月日を出力するプログラムを作成してください。入力は例に示すように 3 つの整数であり、順に西暦年、月、日です。これを、出力例に示すように変換してください。なお、明治以前の年月日が入力された場合は「pre-meiji」と表示してください。
</p>
<p>
各年号の最初の年は「元年」ではなく「１年」と出力することとします。
</p>
<center>
<table border=1>
<tr><td align=center width=100>元号</td><td align=center width=240>期間</td></tr>
<tr><td align=center >meiji</td><td>1868. 9. 8 〜 1912. 7.29</td></tr>
<tr><td align=center >taisho</td><td>1912. 7.30 〜 1926.12.24</td></tr>
<tr><td align=center >showa</td><td>1926.12.25 〜 1989. 1. 7</td></tr>
<tr><td align=center >heisei</td><td>1989. 1. 8 〜</td></tr>
</table>
</center>
<br/>
<H2>入力</H2>
<p>
複数のデータが与えられます。各データとして年、月、日を表す３つの整数が空白区切りで１行に与えられます。
</p>
<p>
入力の終わりまで処理してください。データの数は 50 を超えません。
</p>
<H2>出力</H2>
<p>
空白区切りの元号、年、月、日、または「pre-meiji」を１行に出力してください。
</p>
<H2>Sample Input</H2>
<pre>
2005 9 3
1868 12 2
1868 9 7
</pre>
<H2>Output for the Sample Input</H2>
<pre>
heisei 17 9 3
meiji 1 12 2
pre-meiji
</pre>
| 2005 9 3
1868 12 2
1868 9 7
| heisei 17 9 3
meiji 1 12 2
pre-meiji
| 12,193 |
s836105981 | p00083 | u489809100 | 1447242407 | Python | Python | py | Accepted | 10 | 6348 | 593 | def doc_string():
"""
I can fly.
"""
while True:
try:
a,b,c = map(str,raw_input().split())
except EOFError:
break
if len(b) == 1:
b = "0" + b
if len(c) == 1:
c = "0" + c
code = int(a + b + c)
if code >= 19890108:
print "heisei",int(a) - 1989 + 1,int(b),int(c)
elif 19261225 <= code and code <= 19890107:
print "showa",int(a) - 1926 + 1,int(b),int(c)
elif 19120730 <= code and code <= 19261224:
print "taisho",int(a) - 1912 + 1,int(b),int(c)
elif 18680908 <= code and code <= 19120729:
print "meiji",int(a) - 1868 + 1,int(b),int(c)
else:
print "pre-meiji" | p00083 |
<H1>西暦和暦変換</H1>
<p>
西暦で表された年月日を、元号を用いた和暦に変換し、その年月日を出力するプログラムを作成してください。入力は例に示すように 3 つの整数であり、順に西暦年、月、日です。これを、出力例に示すように変換してください。なお、明治以前の年月日が入力された場合は「pre-meiji」と表示してください。
</p>
<p>
各年号の最初の年は「元年」ではなく「１年」と出力することとします。
</p>
<center>
<table border=1>
<tr><td align=center width=100>元号</td><td align=center width=240>期間</td></tr>
<tr><td align=center >meiji</td><td>1868. 9. 8 〜 1912. 7.29</td></tr>
<tr><td align=center >taisho</td><td>1912. 7.30 〜 1926.12.24</td></tr>
<tr><td align=center >showa</td><td>1926.12.25 〜 1989. 1. 7</td></tr>
<tr><td align=center >heisei</td><td>1989. 1. 8 〜</td></tr>
</table>
</center>
<br/>
<H2>入力</H2>
<p>
複数のデータが与えられます。各データとして年、月、日を表す３つの整数が空白区切りで１行に与えられます。
</p>
<p>
入力の終わりまで処理してください。データの数は 50 を超えません。
</p>
<H2>出力</H2>
<p>
空白区切りの元号、年、月、日、または「pre-meiji」を１行に出力してください。
</p>
<H2>Sample Input</H2>
<pre>
2005 9 3
1868 12 2
1868 9 7
</pre>
<H2>Output for the Sample Input</H2>
<pre>
heisei 17 9 3
meiji 1 12 2
pre-meiji
</pre>
| 2005 9 3
1868 12 2
1868 9 7
| heisei 17 9 3
meiji 1 12 2
pre-meiji
| 12,194 |
s181214295 | p00083 | u140201022 | 1451497275 | Python | Python | py | Accepted | 10 | 6264 | 576 | while 1:
#n=int(raw_input())
try:
y,m,d=map(int,raw_input().split())
if (y<=1868 and m<=9 and d<8) or (y<=1868 and m<=8) or y<=1867:
print 'pre-meiji'
elif (y<=1912 and m<=7 and d<30) or (y<=1912 and m<=6) or y<=1911:
print 'meiji',y-1867,m,d
elif (y<=1926 and m<=12 and d<25) or (y<=1926 and m<=11) or y<=1925:
print 'taisho',y-1911,m,d
elif (y<=1989 and m<=1 and d<8) or y<=1988:
print 'showa',y-1925,m,d
else:
print 'heisei',y-1988,m,d
except:
break | p00083 |
<H1>西暦和暦変換</H1>
<p>
西暦で表された年月日を、元号を用いた和暦に変換し、その年月日を出力するプログラムを作成してください。入力は例に示すように 3 つの整数であり、順に西暦年、月、日です。これを、出力例に示すように変換してください。なお、明治以前の年月日が入力された場合は「pre-meiji」と表示してください。
</p>
<p>
各年号の最初の年は「元年」ではなく「１年」と出力することとします。
</p>
<center>
<table border=1>
<tr><td align=center width=100>元号</td><td align=center width=240>期間</td></tr>
<tr><td align=center >meiji</td><td>1868. 9. 8 〜 1912. 7.29</td></tr>
<tr><td align=center >taisho</td><td>1912. 7.30 〜 1926.12.24</td></tr>
<tr><td align=center >showa</td><td>1926.12.25 〜 1989. 1. 7</td></tr>
<tr><td align=center >heisei</td><td>1989. 1. 8 〜</td></tr>
</table>
</center>
<br/>
<H2>入力</H2>
<p>
複数のデータが与えられます。各データとして年、月、日を表す３つの整数が空白区切りで１行に与えられます。
</p>
<p>
入力の終わりまで処理してください。データの数は 50 を超えません。
</p>
<H2>出力</H2>
<p>
空白区切りの元号、年、月、日、または「pre-meiji」を１行に出力してください。
</p>
<H2>Sample Input</H2>
<pre>
2005 9 3
1868 12 2
1868 9 7
</pre>
<H2>Output for the Sample Input</H2>
<pre>
heisei 17 9 3
meiji 1 12 2
pre-meiji
</pre>
| 2005 9 3
1868 12 2
1868 9 7
| heisei 17 9 3
meiji 1 12 2
pre-meiji
| 12,195 |
s310787586 | p00083 | u075836834 | 1459476812 | Python | Python3 | py | Accepted | 20 | 7712 | 745 | def solve(y,m,d):
if y<1868 or (y==1868 and m<9) or (y==1868 and m==9 and d<8):
print("pre-meiji")
elif 1868<y<1912 or (y==1868 and 9<m) or (y==1868 and m==9 and 8<=d) or (y==1912 and m<7) or(y==1912 and m==7 and d<=29):
print("meiji %d %d %d"%(y-1868+1,m,d))
elif 1912<y<1926 or (y==1912 and 7<m) or (y==1912 and m==7 and 30<=d) or (y==1926 and m<12) or (y==1926 and m==12 and d<=24):
print("taisho %d %d %d"%(y-1912+1,m,d))
elif 1926<y<1989 or (y==1926 and 12<m) or (y==1926 and m==12 and 25<=d) or (y==1989 and m<1) or (y==1989 and m==1 and d<=7):
print("showa %d %d %d"%(y-1926+1,m,d))
else:
print("heisei %d %d %d"%(y-1989+1,m,d))
while True:
try:
y,m,d=map(int,input().split())
solve(y,m,d)
except EOFError:
break | p00083 |
<H1>西暦和暦変換</H1>
<p>
西暦で表された年月日を、元号を用いた和暦に変換し、その年月日を出力するプログラムを作成してください。入力は例に示すように 3 つの整数であり、順に西暦年、月、日です。これを、出力例に示すように変換してください。なお、明治以前の年月日が入力された場合は「pre-meiji」と表示してください。
</p>
<p>
各年号の最初の年は「元年」ではなく「１年」と出力することとします。
</p>
<center>
<table border=1>
<tr><td align=center width=100>元号</td><td align=center width=240>期間</td></tr>
<tr><td align=center >meiji</td><td>1868. 9. 8 〜 1912. 7.29</td></tr>
<tr><td align=center >taisho</td><td>1912. 7.30 〜 1926.12.24</td></tr>
<tr><td align=center >showa</td><td>1926.12.25 〜 1989. 1. 7</td></tr>
<tr><td align=center >heisei</td><td>1989. 1. 8 〜</td></tr>
</table>
</center>
<br/>
<H2>入力</H2>
<p>
複数のデータが与えられます。各データとして年、月、日を表す３つの整数が空白区切りで１行に与えられます。
</p>
<p>
入力の終わりまで処理してください。データの数は 50 を超えません。
</p>
<H2>出力</H2>
<p>
空白区切りの元号、年、月、日、または「pre-meiji」を１行に出力してください。
</p>
<H2>Sample Input</H2>
<pre>
2005 9 3
1868 12 2
1868 9 7
</pre>
<H2>Output for the Sample Input</H2>
<pre>
heisei 17 9 3
meiji 1 12 2
pre-meiji
</pre>
| 2005 9 3
1868 12 2
1868 9 7
| heisei 17 9 3
meiji 1 12 2
pre-meiji
| 12,196 |
s525705367 | p00083 | u301729341 | 1481672758 | Python | Python3 | py | Accepted | 20 | 7612 | 777 | while True:
try:
y,m,d = map(int,input().split())
if y < 1868 or (y == 1868 and m < 9):
print("pre-meiji")
elif y == 1868 and m == 9 and d < 8:
print("pre-meiji")
elif y < 1912 or (y == 1926 and m < 7):
print("meiji",y - 1868 + 1,m,d)
elif y == 1912 and m == 7 and d < 30:
print("meiji",y - 1868 + 1,m,d)
elif y < 1926 or (y == 1926 and m < 12):
print("taisho",y - 1912 + 1,m,d)
elif y == 1926 and m ==12 and d < 25:
print("taisho",y - 1912 + 1,m,d)
elif y <1989 or (y == 1989 and m == 1 and d < 8):
print("showa",y - 1926 + 1,m,d)
else:
print("heisei",y - 1989 + 1,m,d)
except EOFError:
break | p00083 |
<H1>西暦和暦変換</H1>
<p>
西暦で表された年月日を、元号を用いた和暦に変換し、その年月日を出力するプログラムを作成してください。入力は例に示すように 3 つの整数であり、順に西暦年、月、日です。これを、出力例に示すように変換してください。なお、明治以前の年月日が入力された場合は「pre-meiji」と表示してください。
</p>
<p>
各年号の最初の年は「元年」ではなく「１年」と出力することとします。
</p>
<center>
<table border=1>
<tr><td align=center width=100>元号</td><td align=center width=240>期間</td></tr>
<tr><td align=center >meiji</td><td>1868. 9. 8 〜 1912. 7.29</td></tr>
<tr><td align=center >taisho</td><td>1912. 7.30 〜 1926.12.24</td></tr>
<tr><td align=center >showa</td><td>1926.12.25 〜 1989. 1. 7</td></tr>
<tr><td align=center >heisei</td><td>1989. 1. 8 〜</td></tr>
</table>
</center>
<br/>
<H2>入力</H2>
<p>
複数のデータが与えられます。各データとして年、月、日を表す３つの整数が空白区切りで１行に与えられます。
</p>
<p>
入力の終わりまで処理してください。データの数は 50 を超えません。
</p>
<H2>出力</H2>
<p>
空白区切りの元号、年、月、日、または「pre-meiji」を１行に出力してください。
</p>
<H2>Sample Input</H2>
<pre>
2005 9 3
1868 12 2
1868 9 7
</pre>
<H2>Output for the Sample Input</H2>
<pre>
heisei 17 9 3
meiji 1 12 2
pre-meiji
</pre>
| 2005 9 3
1868 12 2
1868 9 7
| heisei 17 9 3
meiji 1 12 2
pre-meiji
| 12,197 |
s552549434 | p00083 | u546285759 | 1483801178 | Python | Python3 | py | Accepted | 20 | 7556 | 511 | while True:
try:
a, b, c = map(int, input().split())
except:
break
if a < 1868 or (a==1868 and b<10 and c<8):
print("pre-meiji")
elif a < 1912 or (a==1912 and b<8 and c<30):
print("meiji %d %d %d" % (a-1867, b, c))
elif a < 1926 or (a==1926 and c<25):
print("taisho %d %d %d" % (a-1911, b, c))
elif a < 1989 or (a==1989 and b<2 and c<8):
print("showa %d %d %d" % (a-1925, b, c))
else:
print("heisei %d %d %d" % (a-1988, b, c)) | p00083 |
<H1>西暦和暦変換</H1>
<p>
西暦で表された年月日を、元号を用いた和暦に変換し、その年月日を出力するプログラムを作成してください。入力は例に示すように 3 つの整数であり、順に西暦年、月、日です。これを、出力例に示すように変換してください。なお、明治以前の年月日が入力された場合は「pre-meiji」と表示してください。
</p>
<p>
各年号の最初の年は「元年」ではなく「１年」と出力することとします。
</p>
<center>
<table border=1>
<tr><td align=center width=100>元号</td><td align=center width=240>期間</td></tr>
<tr><td align=center >meiji</td><td>1868. 9. 8 〜 1912. 7.29</td></tr>
<tr><td align=center >taisho</td><td>1912. 7.30 〜 1926.12.24</td></tr>
<tr><td align=center >showa</td><td>1926.12.25 〜 1989. 1. 7</td></tr>
<tr><td align=center >heisei</td><td>1989. 1. 8 〜</td></tr>
</table>
</center>
<br/>
<H2>入力</H2>
<p>
複数のデータが与えられます。各データとして年、月、日を表す３つの整数が空白区切りで１行に与えられます。
</p>
<p>
入力の終わりまで処理してください。データの数は 50 を超えません。
</p>
<H2>出力</H2>
<p>
空白区切りの元号、年、月、日、または「pre-meiji」を１行に出力してください。
</p>
<H2>Sample Input</H2>
<pre>
2005 9 3
1868 12 2
1868 9 7
</pre>
<H2>Output for the Sample Input</H2>
<pre>
heisei 17 9 3
meiji 1 12 2
pre-meiji
</pre>
| 2005 9 3
1868 12 2
1868 9 7
| heisei 17 9 3
meiji 1 12 2
pre-meiji
| 12,198 |
s328212478 | p00083 | u078042885 | 1484590464 | Python | Python3 | py | Accepted | 30 | 7964 | 345 | from datetime import datetime
while 1:
try:y,m,d=map(int,input().split())
except:break
dt = (datetime(y,m,d)-datetime(1868,9,8)).days
if dt<0:print('pre-meiji')
elif dt<16030:print('meiji',y-1867,m,d)
elif dt<21291:print('taisho',y-1911,m,d)
elif dt<43951:print('showa',y-1925,m,d)
else:print('heisei',y-1988,m,d) | p00083 |
<H1>西暦和暦変換</H1>
<p>
西暦で表された年月日を、元号を用いた和暦に変換し、その年月日を出力するプログラムを作成してください。入力は例に示すように 3 つの整数であり、順に西暦年、月、日です。これを、出力例に示すように変換してください。なお、明治以前の年月日が入力された場合は「pre-meiji」と表示してください。
</p>
<p>
各年号の最初の年は「元年」ではなく「１年」と出力することとします。
</p>
<center>
<table border=1>
<tr><td align=center width=100>元号</td><td align=center width=240>期間</td></tr>
<tr><td align=center >meiji</td><td>1868. 9. 8 〜 1912. 7.29</td></tr>
<tr><td align=center >taisho</td><td>1912. 7.30 〜 1926.12.24</td></tr>
<tr><td align=center >showa</td><td>1926.12.25 〜 1989. 1. 7</td></tr>
<tr><td align=center >heisei</td><td>1989. 1. 8 〜</td></tr>
</table>
</center>
<br/>
<H2>入力</H2>
<p>
複数のデータが与えられます。各データとして年、月、日を表す３つの整数が空白区切りで１行に与えられます。
</p>
<p>
入力の終わりまで処理してください。データの数は 50 を超えません。
</p>
<H2>出力</H2>
<p>
空白区切りの元号、年、月、日、または「pre-meiji」を１行に出力してください。
</p>
<H2>Sample Input</H2>
<pre>
2005 9 3
1868 12 2
1868 9 7
</pre>
<H2>Output for the Sample Input</H2>
<pre>
heisei 17 9 3
meiji 1 12 2
pre-meiji
</pre>
| 2005 9 3
1868 12 2
1868 9 7
| heisei 17 9 3
meiji 1 12 2
pre-meiji
| 12,199 |
s333124462 | p00083 | u032662562 | 1489821341 | Python | Python3 | py | Accepted | 30 | 8152 | 822 | from datetime import datetime
def era(f):
meiji_st = datetime(1868, 9, 8)
taisho_st = datetime(1912, 7,30)
showa_st = datetime(1926,12,25)
heisei_st = datetime(1989, 1, 8)
y,m,d = f
dt = datetime(y,m,d)
if dt >= heisei_st:
ret = "heisei %d %d %d" % (dt.year - heisei_st.year+1,dt.month,dt.day)
elif dt >= showa_st:
ret = "showa %d %d %d" % (dt.year - showa_st.year+1,dt.month,dt.day)
elif dt >= taisho_st:
ret = "taisho %d %d %d" % (dt.year - taisho_st.year+1,dt.month,dt.day)
elif dt >= meiji_st:
ret = "meiji %d %d %d" % (dt.year - meiji_st.year+1,dt.month,dt.day)
else:
ret = "pre-meiji"
return(ret)
while True:
try:
f = map(int, input().strip().split())
print(era(f))
except EOFError:
break | p00083 |
<H1>西暦和暦変換</H1>
<p>
西暦で表された年月日を、元号を用いた和暦に変換し、その年月日を出力するプログラムを作成してください。入力は例に示すように 3 つの整数であり、順に西暦年、月、日です。これを、出力例に示すように変換してください。なお、明治以前の年月日が入力された場合は「pre-meiji」と表示してください。
</p>
<p>
各年号の最初の年は「元年」ではなく「１年」と出力することとします。
</p>
<center>
<table border=1>
<tr><td align=center width=100>元号</td><td align=center width=240>期間</td></tr>
<tr><td align=center >meiji</td><td>1868. 9. 8 〜 1912. 7.29</td></tr>
<tr><td align=center >taisho</td><td>1912. 7.30 〜 1926.12.24</td></tr>
<tr><td align=center >showa</td><td>1926.12.25 〜 1989. 1. 7</td></tr>
<tr><td align=center >heisei</td><td>1989. 1. 8 〜</td></tr>
</table>
</center>
<br/>
<H2>入力</H2>
<p>
複数のデータが与えられます。各データとして年、月、日を表す３つの整数が空白区切りで１行に与えられます。
</p>
<p>
入力の終わりまで処理してください。データの数は 50 を超えません。
</p>
<H2>出力</H2>
<p>
空白区切りの元号、年、月、日、または「pre-meiji」を１行に出力してください。
</p>
<H2>Sample Input</H2>
<pre>
2005 9 3
1868 12 2
1868 9 7
</pre>
<H2>Output for the Sample Input</H2>
<pre>
heisei 17 9 3
meiji 1 12 2
pre-meiji
</pre>
| 2005 9 3
1868 12 2
1868 9 7
| heisei 17 9 3
meiji 1 12 2
pre-meiji
| 12,200 |
s429187125 | p00083 | u462831976 | 1493450852 | Python | Python3 | py | Accepted | 20 | 7688 | 693 | # -*- coding: utf-8 -*-
import sys
import os
import math
def day_to_num(y, m, d):
s = "{:04d}{:02d}{:02d}".format(y, m, d)
return int(s)
for s in sys.stdin:
y, m, d = list(map(int, s.split()))
n = day_to_num(y, m, d)
if n < 18680908:
gengo = 'pre-meiji'
elif 18680908 <= n <= 19120729:
gengo = 'meiji'
Y = y - 1868 + 1
elif 19120730 <= n <= 19261224:
gengo = 'taisho'
Y = y - 1912 + 1
elif 19261225 <= n <= 19890107:
gengo = 'showa'
Y = y - 1926 + 1
else:
Y = y - 1989 + 1
gengo = 'heisei'
if gengo == 'pre-meiji':
print(gengo)
else:
print(gengo, Y, m, d) | p00083 |
<H1>西暦和暦変換</H1>
<p>
西暦で表された年月日を、元号を用いた和暦に変換し、その年月日を出力するプログラムを作成してください。入力は例に示すように 3 つの整数であり、順に西暦年、月、日です。これを、出力例に示すように変換してください。なお、明治以前の年月日が入力された場合は「pre-meiji」と表示してください。
</p>
<p>
各年号の最初の年は「元年」ではなく「１年」と出力することとします。
</p>
<center>
<table border=1>
<tr><td align=center width=100>元号</td><td align=center width=240>期間</td></tr>
<tr><td align=center >meiji</td><td>1868. 9. 8 〜 1912. 7.29</td></tr>
<tr><td align=center >taisho</td><td>1912. 7.30 〜 1926.12.24</td></tr>
<tr><td align=center >showa</td><td>1926.12.25 〜 1989. 1. 7</td></tr>
<tr><td align=center >heisei</td><td>1989. 1. 8 〜</td></tr>
</table>
</center>
<br/>
<H2>入力</H2>
<p>
複数のデータが与えられます。各データとして年、月、日を表す３つの整数が空白区切りで１行に与えられます。
</p>
<p>
入力の終わりまで処理してください。データの数は 50 を超えません。
</p>
<H2>出力</H2>
<p>
空白区切りの元号、年、月、日、または「pre-meiji」を１行に出力してください。
</p>
<H2>Sample Input</H2>
<pre>
2005 9 3
1868 12 2
1868 9 7
</pre>
<H2>Output for the Sample Input</H2>
<pre>
heisei 17 9 3
meiji 1 12 2
pre-meiji
</pre>
| 2005 9 3
1868 12 2
1868 9 7
| heisei 17 9 3
meiji 1 12 2
pre-meiji
| 12,201 |
s280014526 | p00083 | u811733736 | 1503900173 | Python | Python3 | py | Accepted | 20 | 8104 | 1,152 | # -*- coding: utf-8 -*-
"""
http://judge.u-aizu.ac.jp/onlinejudge/description.jsp?id=0083
"""
import sys
import datetime
def solve(yyyy, mm, dd):
d = datetime.datetime(yyyy, mm, dd)
meiji_start = datetime.datetime(1868, 9, 8)
taisho_start = datetime.datetime(1912, 7, 30)
showa_start = datetime.datetime(1926, 12, 25)
heisei_start = datetime.datetime(1989, 1, 8)
result = 'not initialized'
if d < meiji_start:
result = 'pre-meiji'
elif meiji_start <= d < taisho_start:
result = 'meiji {} {} {}'.format(d.year-meiji_start.year+1, mm, dd)
elif taisho_start <= d < showa_start:
result = 'taisho {} {} {}'.format(d.year-taisho_start.year+1, mm, dd)
elif showa_start <= d < heisei_start:
result = 'showa {} {} {}'.format(d.year-showa_start.year+1, mm, dd)
else:
result = 'heisei {} {} {}'.format(d.year-heisei_start.year+1, mm, dd)
return result
def main(args):
for line in sys.stdin:
yyyy, mm, dd = [int(x) for x in line.strip().split(' ')]
result = solve(yyyy, mm, dd)
print(result)
if __name__ == '__main__':
main(sys.argv[1:]) | p00083 |
<H1>西暦和暦変換</H1>
<p>
西暦で表された年月日を、元号を用いた和暦に変換し、その年月日を出力するプログラムを作成してください。入力は例に示すように 3 つの整数であり、順に西暦年、月、日です。これを、出力例に示すように変換してください。なお、明治以前の年月日が入力された場合は「pre-meiji」と表示してください。
</p>
<p>
各年号の最初の年は「元年」ではなく「１年」と出力することとします。
</p>
<center>
<table border=1>
<tr><td align=center width=100>元号</td><td align=center width=240>期間</td></tr>
<tr><td align=center >meiji</td><td>1868. 9. 8 〜 1912. 7.29</td></tr>
<tr><td align=center >taisho</td><td>1912. 7.30 〜 1926.12.24</td></tr>
<tr><td align=center >showa</td><td>1926.12.25 〜 1989. 1. 7</td></tr>
<tr><td align=center >heisei</td><td>1989. 1. 8 〜</td></tr>
</table>
</center>
<br/>
<H2>入力</H2>
<p>
複数のデータが与えられます。各データとして年、月、日を表す３つの整数が空白区切りで１行に与えられます。
</p>
<p>
入力の終わりまで処理してください。データの数は 50 を超えません。
</p>
<H2>出力</H2>
<p>
空白区切りの元号、年、月、日、または「pre-meiji」を１行に出力してください。
</p>
<H2>Sample Input</H2>
<pre>
2005 9 3
1868 12 2
1868 9 7
</pre>
<H2>Output for the Sample Input</H2>
<pre>
heisei 17 9 3
meiji 1 12 2
pre-meiji
</pre>
| 2005 9 3
1868 12 2
1868 9 7
| heisei 17 9 3
meiji 1 12 2
pre-meiji
| 12,202 |
s811777551 | p00083 | u957021183 | 1505197011 | Python | Python3 | py | Accepted | 20 | 7760 | 779 | # Aizu Problem 0083: Era Transformation
#
import sys, math, os
# read input:
PYDEV = os.environ.get('PYDEV')
if PYDEV=="True":
sys.stdin = open("sample-input.txt", "rt")
def era_transformation(y, m, d):
if int(m) < 10:
m = '0' + m
if int(d) < 10:
d = '0' + d
date = int(y + m + d)
y = int(y)
m = int(m)
d = int(d)
if date < 18680908:
print("pre-meiji")
return
elif date <= 19120729:
print("meiji", y - 1868 + 1, m, d)
elif date <= 19261224:
print("taisho", y - 1912 + 1, m, d)
elif date <= 19890107:
print("showa", y - 1926 + 1, m, d)
else:
print("heisei", y - 1989 + 1, m, d)
for line in sys.stdin:
y, m, d = line.split()
era_transformation(y, m, d) | p00083 |
<H1>西暦和暦変換</H1>
<p>
西暦で表された年月日を、元号を用いた和暦に変換し、その年月日を出力するプログラムを作成してください。入力は例に示すように 3 つの整数であり、順に西暦年、月、日です。これを、出力例に示すように変換してください。なお、明治以前の年月日が入力された場合は「pre-meiji」と表示してください。
</p>
<p>
各年号の最初の年は「元年」ではなく「１年」と出力することとします。
</p>
<center>
<table border=1>
<tr><td align=center width=100>元号</td><td align=center width=240>期間</td></tr>
<tr><td align=center >meiji</td><td>1868. 9. 8 〜 1912. 7.29</td></tr>
<tr><td align=center >taisho</td><td>1912. 7.30 〜 1926.12.24</td></tr>
<tr><td align=center >showa</td><td>1926.12.25 〜 1989. 1. 7</td></tr>
<tr><td align=center >heisei</td><td>1989. 1. 8 〜</td></tr>
</table>
</center>
<br/>
<H2>入力</H2>
<p>
複数のデータが与えられます。各データとして年、月、日を表す３つの整数が空白区切りで１行に与えられます。
</p>
<p>
入力の終わりまで処理してください。データの数は 50 を超えません。
</p>
<H2>出力</H2>
<p>
空白区切りの元号、年、月、日、または「pre-meiji」を１行に出力してください。
</p>
<H2>Sample Input</H2>
<pre>
2005 9 3
1868 12 2
1868 9 7
</pre>
<H2>Output for the Sample Input</H2>
<pre>
heisei 17 9 3
meiji 1 12 2
pre-meiji
</pre>
| 2005 9 3
1868 12 2
1868 9 7
| heisei 17 9 3
meiji 1 12 2
pre-meiji
| 12,203 |
s362862446 | p00083 | u024715419 | 1519372327 | Python | Python3 | py | Accepted | 30 | 6032 | 465 | import datetime
while True:
try:
y, m, d = map(int, input().split())
n = 10000*y + 100*m +d
if n < 18680908:
print("pre-meiji")
elif n < 19120730:
print("meiji", y - 1867, m, d)
elif n < 19261225:
print("taisho", y - 1911, m, d)
elif n < 19890108:
print("showa", y - 1925, m, d)
else:
print("heisei", y - 1988, m, d)
except:
break
| p00083 |
<H1>西暦和暦変換</H1>
<p>
西暦で表された年月日を、元号を用いた和暦に変換し、その年月日を出力するプログラムを作成してください。入力は例に示すように 3 つの整数であり、順に西暦年、月、日です。これを、出力例に示すように変換してください。なお、明治以前の年月日が入力された場合は「pre-meiji」と表示してください。
</p>
<p>
各年号の最初の年は「元年」ではなく「１年」と出力することとします。
</p>
<center>
<table border=1>
<tr><td align=center width=100>元号</td><td align=center width=240>期間</td></tr>
<tr><td align=center >meiji</td><td>1868. 9. 8 〜 1912. 7.29</td></tr>
<tr><td align=center >taisho</td><td>1912. 7.30 〜 1926.12.24</td></tr>
<tr><td align=center >showa</td><td>1926.12.25 〜 1989. 1. 7</td></tr>
<tr><td align=center >heisei</td><td>1989. 1. 8 〜</td></tr>
</table>
</center>
<br/>
<H2>入力</H2>
<p>
複数のデータが与えられます。各データとして年、月、日を表す３つの整数が空白区切りで１行に与えられます。
</p>
<p>
入力の終わりまで処理してください。データの数は 50 を超えません。
</p>
<H2>出力</H2>
<p>
空白区切りの元号、年、月、日、または「pre-meiji」を１行に出力してください。
</p>
<H2>Sample Input</H2>
<pre>
2005 9 3
1868 12 2
1868 9 7
</pre>
<H2>Output for the Sample Input</H2>
<pre>
heisei 17 9 3
meiji 1 12 2
pre-meiji
</pre>
| 2005 9 3
1868 12 2
1868 9 7
| heisei 17 9 3
meiji 1 12 2
pre-meiji
| 12,204 |
s748996193 | p00083 | u043254318 | 1519654167 | Python | Python3 | py | Accepted | 20 | 5596 | 539 | def get_input():
while True:
try:
yield ''.join(input())
except EOFError:
break
N = list(get_input())
for l in range(len(N)):
y,m,d = [int(i) for i in N[l].split()]
id = y * 10000 + m * 100 + d
if id < 18680908:
print("pre-meiji")
elif id < 19120730:
print("meiji", y - 1867, m, d)
elif id < 19261225:
print("taisho", y - 1911, m, d)
elif id < 19890108:
print("showa", y - 1925, m, d)
else:
print("heisei", y - 1988, m, d)
| p00083 |
<H1>西暦和暦変換</H1>
<p>
西暦で表された年月日を、元号を用いた和暦に変換し、その年月日を出力するプログラムを作成してください。入力は例に示すように 3 つの整数であり、順に西暦年、月、日です。これを、出力例に示すように変換してください。なお、明治以前の年月日が入力された場合は「pre-meiji」と表示してください。
</p>
<p>
各年号の最初の年は「元年」ではなく「１年」と出力することとします。
</p>
<center>
<table border=1>
<tr><td align=center width=100>元号</td><td align=center width=240>期間</td></tr>
<tr><td align=center >meiji</td><td>1868. 9. 8 〜 1912. 7.29</td></tr>
<tr><td align=center >taisho</td><td>1912. 7.30 〜 1926.12.24</td></tr>
<tr><td align=center >showa</td><td>1926.12.25 〜 1989. 1. 7</td></tr>
<tr><td align=center >heisei</td><td>1989. 1. 8 〜</td></tr>
</table>
</center>
<br/>
<H2>入力</H2>
<p>
複数のデータが与えられます。各データとして年、月、日を表す３つの整数が空白区切りで１行に与えられます。
</p>
<p>
入力の終わりまで処理してください。データの数は 50 を超えません。
</p>
<H2>出力</H2>
<p>
空白区切りの元号、年、月、日、または「pre-meiji」を１行に出力してください。
</p>
<H2>Sample Input</H2>
<pre>
2005 9 3
1868 12 2
1868 9 7
</pre>
<H2>Output for the Sample Input</H2>
<pre>
heisei 17 9 3
meiji 1 12 2
pre-meiji
</pre>
| 2005 9 3
1868 12 2
1868 9 7
| heisei 17 9 3
meiji 1 12 2
pre-meiji
| 12,205 |
s029834438 | p00083 | u150984829 | 1520142588 | Python | Python3 | py | Accepted | 20 | 5628 | 267 | import sys
n=[19890107,19261224,19120729,18680907]
for e in sys.stdin:
y,m,d=map(int,e.split())
t=y*1e4+m*100+d
for i in range(4):
if n[i]<t:print([f'heisei {y-1988}',f'showa {y-1925}',f'taisho {y-1911}',f'meiji {y-1867}'][i],m,d);break
else:print('pre-meiji')
| p00083 |
<H1>西暦和暦変換</H1>
<p>
西暦で表された年月日を、元号を用いた和暦に変換し、その年月日を出力するプログラムを作成してください。入力は例に示すように 3 つの整数であり、順に西暦年、月、日です。これを、出力例に示すように変換してください。なお、明治以前の年月日が入力された場合は「pre-meiji」と表示してください。
</p>
<p>
各年号の最初の年は「元年」ではなく「１年」と出力することとします。
</p>
<center>
<table border=1>
<tr><td align=center width=100>元号</td><td align=center width=240>期間</td></tr>
<tr><td align=center >meiji</td><td>1868. 9. 8 〜 1912. 7.29</td></tr>
<tr><td align=center >taisho</td><td>1912. 7.30 〜 1926.12.24</td></tr>
<tr><td align=center >showa</td><td>1926.12.25 〜 1989. 1. 7</td></tr>
<tr><td align=center >heisei</td><td>1989. 1. 8 〜</td></tr>
</table>
</center>
<br/>
<H2>入力</H2>
<p>
複数のデータが与えられます。各データとして年、月、日を表す３つの整数が空白区切りで１行に与えられます。
</p>
<p>
入力の終わりまで処理してください。データの数は 50 を超えません。
</p>
<H2>出力</H2>
<p>
空白区切りの元号、年、月、日、または「pre-meiji」を１行に出力してください。
</p>
<H2>Sample Input</H2>
<pre>
2005 9 3
1868 12 2
1868 9 7
</pre>
<H2>Output for the Sample Input</H2>
<pre>
heisei 17 9 3
meiji 1 12 2
pre-meiji
</pre>
| 2005 9 3
1868 12 2
1868 9 7
| heisei 17 9 3
meiji 1 12 2
pre-meiji
| 12,206 |
s034822518 | p00083 | u150984829 | 1520142734 | Python | Python3 | py | Accepted | 30 | 6036 | 322 | from datetime import datetime
while 1:
try:y,m,d=map(int,input().split())
except:break
dt = (datetime(y,m,d)-datetime(1868,9,8)).days
if dt<0:print('pre-meiji')
elif dt<16030:print('meiji',y-1867,m,d)
elif dt<21291:print('taisho',y-1911,m,d)
elif dt<43951:print('showa',y-1925,m,d)
else:print('heisei',y-1988,m,d)
| p00083 |
<H1>西暦和暦変換</H1>
<p>
西暦で表された年月日を、元号を用いた和暦に変換し、その年月日を出力するプログラムを作成してください。入力は例に示すように 3 つの整数であり、順に西暦年、月、日です。これを、出力例に示すように変換してください。なお、明治以前の年月日が入力された場合は「pre-meiji」と表示してください。
</p>
<p>
各年号の最初の年は「元年」ではなく「１年」と出力することとします。
</p>
<center>
<table border=1>
<tr><td align=center width=100>元号</td><td align=center width=240>期間</td></tr>
<tr><td align=center >meiji</td><td>1868. 9. 8 〜 1912. 7.29</td></tr>
<tr><td align=center >taisho</td><td>1912. 7.30 〜 1926.12.24</td></tr>
<tr><td align=center >showa</td><td>1926.12.25 〜 1989. 1. 7</td></tr>
<tr><td align=center >heisei</td><td>1989. 1. 8 〜</td></tr>
</table>
</center>
<br/>
<H2>入力</H2>
<p>
複数のデータが与えられます。各データとして年、月、日を表す３つの整数が空白区切りで１行に与えられます。
</p>
<p>
入力の終わりまで処理してください。データの数は 50 を超えません。
</p>
<H2>出力</H2>
<p>
空白区切りの元号、年、月、日、または「pre-meiji」を１行に出力してください。
</p>
<H2>Sample Input</H2>
<pre>
2005 9 3
1868 12 2
1868 9 7
</pre>
<H2>Output for the Sample Input</H2>
<pre>
heisei 17 9 3
meiji 1 12 2
pre-meiji
</pre>
| 2005 9 3
1868 12 2
1868 9 7
| heisei 17 9 3
meiji 1 12 2
pre-meiji
| 12,207 |
s188588676 | p00083 | u150984829 | 1520142736 | Python | Python3 | py | Accepted | 30 | 6040 | 322 | from datetime import datetime
while 1:
try:y,m,d=map(int,input().split())
except:break
dt = (datetime(y,m,d)-datetime(1868,9,8)).days
if dt<0:print('pre-meiji')
elif dt<16030:print('meiji',y-1867,m,d)
elif dt<21291:print('taisho',y-1911,m,d)
elif dt<43951:print('showa',y-1925,m,d)
else:print('heisei',y-1988,m,d)
| p00083 |
<H1>西暦和暦変換</H1>
<p>
西暦で表された年月日を、元号を用いた和暦に変換し、その年月日を出力するプログラムを作成してください。入力は例に示すように 3 つの整数であり、順に西暦年、月、日です。これを、出力例に示すように変換してください。なお、明治以前の年月日が入力された場合は「pre-meiji」と表示してください。
</p>
<p>
各年号の最初の年は「元年」ではなく「１年」と出力することとします。
</p>
<center>
<table border=1>
<tr><td align=center width=100>元号</td><td align=center width=240>期間</td></tr>
<tr><td align=center >meiji</td><td>1868. 9. 8 〜 1912. 7.29</td></tr>
<tr><td align=center >taisho</td><td>1912. 7.30 〜 1926.12.24</td></tr>
<tr><td align=center >showa</td><td>1926.12.25 〜 1989. 1. 7</td></tr>
<tr><td align=center >heisei</td><td>1989. 1. 8 〜</td></tr>
</table>
</center>
<br/>
<H2>入力</H2>
<p>
複数のデータが与えられます。各データとして年、月、日を表す３つの整数が空白区切りで１行に与えられます。
</p>
<p>
入力の終わりまで処理してください。データの数は 50 を超えません。
</p>
<H2>出力</H2>
<p>
空白区切りの元号、年、月、日、または「pre-meiji」を１行に出力してください。
</p>
<H2>Sample Input</H2>
<pre>
2005 9 3
1868 12 2
1868 9 7
</pre>
<H2>Output for the Sample Input</H2>
<pre>
heisei 17 9 3
meiji 1 12 2
pre-meiji
</pre>
| 2005 9 3
1868 12 2
1868 9 7
| heisei 17 9 3
meiji 1 12 2
pre-meiji
| 12,208 |
s374859456 | p00083 | u352394527 | 1527585561 | Python | Python3 | py | Accepted | 30 | 5600 | 508 | def put_era(day):
if day < [1868, 9, 8]:
print("pre-meiji")
elif day <= [1912, 7, 29]:
print(*["meiji",day[0] - 1868 + 1, day[1], day[2]])
elif day <= [1926, 12, 24]:
print(*["taisho",day[0] - 1912 + 1, day[1], day[2]])
elif day <= [1989, 1, 7]:
print(*["showa",day[0] - 1926 + 1, day[1], day[2]])
else:
print(*["heisei",day[0] - 1989 + 1, day[1], day[2]])
while True:
try:
day = list(map(int, input().split()))
put_era(day)
except EOFError:
break
| p00083 |
<H1>西暦和暦変換</H1>
<p>
西暦で表された年月日を、元号を用いた和暦に変換し、その年月日を出力するプログラムを作成してください。入力は例に示すように 3 つの整数であり、順に西暦年、月、日です。これを、出力例に示すように変換してください。なお、明治以前の年月日が入力された場合は「pre-meiji」と表示してください。
</p>
<p>
各年号の最初の年は「元年」ではなく「１年」と出力することとします。
</p>
<center>
<table border=1>
<tr><td align=center width=100>元号</td><td align=center width=240>期間</td></tr>
<tr><td align=center >meiji</td><td>1868. 9. 8 〜 1912. 7.29</td></tr>
<tr><td align=center >taisho</td><td>1912. 7.30 〜 1926.12.24</td></tr>
<tr><td align=center >showa</td><td>1926.12.25 〜 1989. 1. 7</td></tr>
<tr><td align=center >heisei</td><td>1989. 1. 8 〜</td></tr>
</table>
</center>
<br/>
<H2>入力</H2>
<p>
複数のデータが与えられます。各データとして年、月、日を表す３つの整数が空白区切りで１行に与えられます。
</p>
<p>
入力の終わりまで処理してください。データの数は 50 を超えません。
</p>
<H2>出力</H2>
<p>
空白区切りの元号、年、月、日、または「pre-meiji」を１行に出力してください。
</p>
<H2>Sample Input</H2>
<pre>
2005 9 3
1868 12 2
1868 9 7
</pre>
<H2>Output for the Sample Input</H2>
<pre>
heisei 17 9 3
meiji 1 12 2
pre-meiji
</pre>
| 2005 9 3
1868 12 2
1868 9 7
| heisei 17 9 3
meiji 1 12 2
pre-meiji
| 12,209 |
s940655934 | p00083 | u352394527 | 1527585675 | Python | Python3 | py | Accepted | 20 | 5596 | 496 | def put_era(day):
if day < [1868, 9, 8]:
print("pre-meiji")
elif day <= [1912, 7, 29]:
print("meiji",day[0] - 1868 + 1, day[1], day[2])
elif day <= [1926, 12, 24]:
print("taisho",day[0] - 1912 + 1, day[1], day[2])
elif day <= [1989, 1, 7]:
print("showa",day[0] - 1926 + 1, day[1], day[2])
else:
print("heisei",day[0] - 1989 + 1, day[1], day[2])
while True:
try:
day = list(map(int, input().split()))
put_era(day)
except EOFError:
break
| p00083 |
<H1>西暦和暦変換</H1>
<p>
西暦で表された年月日を、元号を用いた和暦に変換し、その年月日を出力するプログラムを作成してください。入力は例に示すように 3 つの整数であり、順に西暦年、月、日です。これを、出力例に示すように変換してください。なお、明治以前の年月日が入力された場合は「pre-meiji」と表示してください。
</p>
<p>
各年号の最初の年は「元年」ではなく「１年」と出力することとします。
</p>
<center>
<table border=1>
<tr><td align=center width=100>元号</td><td align=center width=240>期間</td></tr>
<tr><td align=center >meiji</td><td>1868. 9. 8 〜 1912. 7.29</td></tr>
<tr><td align=center >taisho</td><td>1912. 7.30 〜 1926.12.24</td></tr>
<tr><td align=center >showa</td><td>1926.12.25 〜 1989. 1. 7</td></tr>
<tr><td align=center >heisei</td><td>1989. 1. 8 〜</td></tr>
</table>
</center>
<br/>
<H2>入力</H2>
<p>
複数のデータが与えられます。各データとして年、月、日を表す３つの整数が空白区切りで１行に与えられます。
</p>
<p>
入力の終わりまで処理してください。データの数は 50 を超えません。
</p>
<H2>出力</H2>
<p>
空白区切りの元号、年、月、日、または「pre-meiji」を１行に出力してください。
</p>
<H2>Sample Input</H2>
<pre>
2005 9 3
1868 12 2
1868 9 7
</pre>
<H2>Output for the Sample Input</H2>
<pre>
heisei 17 9 3
meiji 1 12 2
pre-meiji
</pre>
| 2005 9 3
1868 12 2
1868 9 7
| heisei 17 9 3
meiji 1 12 2
pre-meiji
| 12,210 |
s141660664 | p00083 | u847467233 | 1528696543 | Python | Python3 | py | Accepted | 20 | 5600 | 517 | # AOJ 0083 Era Name Transformation
# Python3 2018.6.11 bal4u
start_date = [18680908, 19120730, 19261225, 19890108, 99999999]
era = ["pre-meiji", "meiji", "taisho", "showa", "heisei"]
import sys
for line in sys.stdin:
y, m, d = list(map(int, line.split()))
date = y*10000 + m*100 + d
for i in range(5):
if date < start_date[i]:
if i is 0:
print(era[0])
else:
print(era[i], date//10000 - start_date[i-1]//10000 + 1, m, d)
break
| p00083 |
<H1>西暦和暦変換</H1>
<p>
西暦で表された年月日を、元号を用いた和暦に変換し、その年月日を出力するプログラムを作成してください。入力は例に示すように 3 つの整数であり、順に西暦年、月、日です。これを、出力例に示すように変換してください。なお、明治以前の年月日が入力された場合は「pre-meiji」と表示してください。
</p>
<p>
各年号の最初の年は「元年」ではなく「１年」と出力することとします。
</p>
<center>
<table border=1>
<tr><td align=center width=100>元号</td><td align=center width=240>期間</td></tr>
<tr><td align=center >meiji</td><td>1868. 9. 8 〜 1912. 7.29</td></tr>
<tr><td align=center >taisho</td><td>1912. 7.30 〜 1926.12.24</td></tr>
<tr><td align=center >showa</td><td>1926.12.25 〜 1989. 1. 7</td></tr>
<tr><td align=center >heisei</td><td>1989. 1. 8 〜</td></tr>
</table>
</center>
<br/>
<H2>入力</H2>
<p>
複数のデータが与えられます。各データとして年、月、日を表す３つの整数が空白区切りで１行に与えられます。
</p>
<p>
入力の終わりまで処理してください。データの数は 50 を超えません。
</p>
<H2>出力</H2>
<p>
空白区切りの元号、年、月、日、または「pre-meiji」を１行に出力してください。
</p>
<H2>Sample Input</H2>
<pre>
2005 9 3
1868 12 2
1868 9 7
</pre>
<H2>Output for the Sample Input</H2>
<pre>
heisei 17 9 3
meiji 1 12 2
pre-meiji
</pre>
| 2005 9 3
1868 12 2
1868 9 7
| heisei 17 9 3
meiji 1 12 2
pre-meiji
| 12,211 |
s383480129 | p00083 | u136916346 | 1528724947 | Python | Python3 | py | Accepted | 20 | 6040 | 504 | from datetime import date
import sys
for i in sys.stdin:
y,m,d=list(map(int,i[:-1].split()))
dt=lambda y,m,d:date(year=y,month=m,day=d)
nd=dt(y,m,d)
if nd < dt(1868,9,8):
print("pre-meiji")
elif dt(1868,9,8) <= nd <= dt(1912,7,29):
print("meiji",y-1867,m,d)
elif dt(1912,7,30) <= nd <= dt(1926,12,24):
print("taisho",y-1911,m,d)
elif dt(1926,12,25) <= nd <= dt(1989,1,7):
print("showa",y-1925,m,d)
else:
print("heisei",y-1988,m,d)
| p00083 |
<H1>西暦和暦変換</H1>
<p>
西暦で表された年月日を、元号を用いた和暦に変換し、その年月日を出力するプログラムを作成してください。入力は例に示すように 3 つの整数であり、順に西暦年、月、日です。これを、出力例に示すように変換してください。なお、明治以前の年月日が入力された場合は「pre-meiji」と表示してください。
</p>
<p>
各年号の最初の年は「元年」ではなく「１年」と出力することとします。
</p>
<center>
<table border=1>
<tr><td align=center width=100>元号</td><td align=center width=240>期間</td></tr>
<tr><td align=center >meiji</td><td>1868. 9. 8 〜 1912. 7.29</td></tr>
<tr><td align=center >taisho</td><td>1912. 7.30 〜 1926.12.24</td></tr>
<tr><td align=center >showa</td><td>1926.12.25 〜 1989. 1. 7</td></tr>
<tr><td align=center >heisei</td><td>1989. 1. 8 〜</td></tr>
</table>
</center>
<br/>
<H2>入力</H2>
<p>
複数のデータが与えられます。各データとして年、月、日を表す３つの整数が空白区切りで１行に与えられます。
</p>
<p>
入力の終わりまで処理してください。データの数は 50 を超えません。
</p>
<H2>出力</H2>
<p>
空白区切りの元号、年、月、日、または「pre-meiji」を１行に出力してください。
</p>
<H2>Sample Input</H2>
<pre>
2005 9 3
1868 12 2
1868 9 7
</pre>
<H2>Output for the Sample Input</H2>
<pre>
heisei 17 9 3
meiji 1 12 2
pre-meiji
</pre>
| 2005 9 3
1868 12 2
1868 9 7
| heisei 17 9 3
meiji 1 12 2
pre-meiji
| 12,212 |
s271188755 | p00083 | u647766105 | 1357088638 | Python | Python | py | Accepted | 10 | 4232 | 329 | import sys
p=["pre-meiji","meiji","taisho","showa","heisei"]
q=[-999999,18680908,19120730,19261225,19890108,99999999]
for line in sys.stdin.readlines():
y,m,d=map(int,line.strip().split())
t=y*10000+m*100+d
i=0
while not (q[i]<=t<q[i+1]):
i+=1
if i==0:print p[i]
else:print p[i],y-q[i]/10000+1,m,d | p00083 |
<H1>西暦和暦変換</H1>
<p>
西暦で表された年月日を、元号を用いた和暦に変換し、その年月日を出力するプログラムを作成してください。入力は例に示すように 3 つの整数であり、順に西暦年、月、日です。これを、出力例に示すように変換してください。なお、明治以前の年月日が入力された場合は「pre-meiji」と表示してください。
</p>
<p>
各年号の最初の年は「元年」ではなく「１年」と出力することとします。
</p>
<center>
<table border=1>
<tr><td align=center width=100>元号</td><td align=center width=240>期間</td></tr>
<tr><td align=center >meiji</td><td>1868. 9. 8 〜 1912. 7.29</td></tr>
<tr><td align=center >taisho</td><td>1912. 7.30 〜 1926.12.24</td></tr>
<tr><td align=center >showa</td><td>1926.12.25 〜 1989. 1. 7</td></tr>
<tr><td align=center >heisei</td><td>1989. 1. 8 〜</td></tr>
</table>
</center>
<br/>
<H2>入力</H2>
<p>
複数のデータが与えられます。各データとして年、月、日を表す３つの整数が空白区切りで１行に与えられます。
</p>
<p>
入力の終わりまで処理してください。データの数は 50 を超えません。
</p>
<H2>出力</H2>
<p>
空白区切りの元号、年、月、日、または「pre-meiji」を１行に出力してください。
</p>
<H2>Sample Input</H2>
<pre>
2005 9 3
1868 12 2
1868 9 7
</pre>
<H2>Output for the Sample Input</H2>
<pre>
heisei 17 9 3
meiji 1 12 2
pre-meiji
</pre>
| 2005 9 3
1868 12 2
1868 9 7
| heisei 17 9 3
meiji 1 12 2
pre-meiji
| 12,213 |
s375170418 | p00083 | u575065019 | 1365168232 | Python | Python | py | Accepted | 10 | 4280 | 873 | ans=[]
while True:
try:
year,month,day=map(int,raw_input().split())
except EOFError:
break
except ValueError:
break
wareki=''
if (year < 1868) or (year == 1868 and month < 9) or (year == 1868 and month == 9 and day <= 7):
ans.append('pre-meiji')
continue
elif (year < 1912) or (year == 1912 and month < 7) or (year == 1912 and month == 7 and day <= 29):
wareki+='meiji '+str(year-1867)
elif (year < 1926) or (year == 1926 and month < 12) or (year == 1926 and month == 12 and day <= 24):
wareki+='taisho '+str(year-1911)
elif (year < 1989) or (year == 1989 and month < 1) or (year == 1989 and month == 1 and day <= 7):
wareki+='showa '+str(year-1925)
else:
wareki+='heisei '+str(year-1988)
ans.append(wareki+' '+str(month)+' '+str(day))
for i in ans:
print i | p00083 |
<H1>西暦和暦変換</H1>
<p>
西暦で表された年月日を、元号を用いた和暦に変換し、その年月日を出力するプログラムを作成してください。入力は例に示すように 3 つの整数であり、順に西暦年、月、日です。これを、出力例に示すように変換してください。なお、明治以前の年月日が入力された場合は「pre-meiji」と表示してください。
</p>
<p>
各年号の最初の年は「元年」ではなく「１年」と出力することとします。
</p>
<center>
<table border=1>
<tr><td align=center width=100>元号</td><td align=center width=240>期間</td></tr>
<tr><td align=center >meiji</td><td>1868. 9. 8 〜 1912. 7.29</td></tr>
<tr><td align=center >taisho</td><td>1912. 7.30 〜 1926.12.24</td></tr>
<tr><td align=center >showa</td><td>1926.12.25 〜 1989. 1. 7</td></tr>
<tr><td align=center >heisei</td><td>1989. 1. 8 〜</td></tr>
</table>
</center>
<br/>
<H2>入力</H2>
<p>
複数のデータが与えられます。各データとして年、月、日を表す３つの整数が空白区切りで１行に与えられます。
</p>
<p>
入力の終わりまで処理してください。データの数は 50 を超えません。
</p>
<H2>出力</H2>
<p>
空白区切りの元号、年、月、日、または「pre-meiji」を１行に出力してください。
</p>
<H2>Sample Input</H2>
<pre>
2005 9 3
1868 12 2
1868 9 7
</pre>
<H2>Output for the Sample Input</H2>
<pre>
heisei 17 9 3
meiji 1 12 2
pre-meiji
</pre>
| 2005 9 3
1868 12 2
1868 9 7
| heisei 17 9 3
meiji 1 12 2
pre-meiji
| 12,214 |
s882901692 | p00083 | u782850731 | 1379079701 | Python | Python | py | Accepted | 10 | 4264 | 631 | #!/usr/bin/env python
# -*- coding: utf-8 -*-
from __future__ import (division, absolute_import, print_function,
unicode_literals)
from sys import stdin
for line in stdin:
date = tuple(int(s) for s in line.split())
if date < (1868, 9, 8):
print('pre-meiji')
elif date < (1912, 7, 30):
print('meiji', date[0] - 1867, date[1], date[2])
elif date < (1926, 12, 25):
print('taisho', date[0] - 1911, date[1], date[2])
elif date < (1989, 1, 8):
print('showa', date[0] - 1925, date[1], date[2])
else:
print('heisei', date[0] - 1988, date[1], date[2]) | p00083 |
<H1>西暦和暦変換</H1>
<p>
西暦で表された年月日を、元号を用いた和暦に変換し、その年月日を出力するプログラムを作成してください。入力は例に示すように 3 つの整数であり、順に西暦年、月、日です。これを、出力例に示すように変換してください。なお、明治以前の年月日が入力された場合は「pre-meiji」と表示してください。
</p>
<p>
各年号の最初の年は「元年」ではなく「１年」と出力することとします。
</p>
<center>
<table border=1>
<tr><td align=center width=100>元号</td><td align=center width=240>期間</td></tr>
<tr><td align=center >meiji</td><td>1868. 9. 8 〜 1912. 7.29</td></tr>
<tr><td align=center >taisho</td><td>1912. 7.30 〜 1926.12.24</td></tr>
<tr><td align=center >showa</td><td>1926.12.25 〜 1989. 1. 7</td></tr>
<tr><td align=center >heisei</td><td>1989. 1. 8 〜</td></tr>
</table>
</center>
<br/>
<H2>入力</H2>
<p>
複数のデータが与えられます。各データとして年、月、日を表す３つの整数が空白区切りで１行に与えられます。
</p>
<p>
入力の終わりまで処理してください。データの数は 50 を超えません。
</p>
<H2>出力</H2>
<p>
空白区切りの元号、年、月、日、または「pre-meiji」を１行に出力してください。
</p>
<H2>Sample Input</H2>
<pre>
2005 9 3
1868 12 2
1868 9 7
</pre>
<H2>Output for the Sample Input</H2>
<pre>
heisei 17 9 3
meiji 1 12 2
pre-meiji
</pre>
| 2005 9 3
1868 12 2
1868 9 7
| heisei 17 9 3
meiji 1 12 2
pre-meiji
| 12,215 |
s475346008 | p00083 | u633068244 | 1393768495 | Python | Python | py | Accepted | 20 | 4212 | 436 | while True:
try:
y, m, d = map(int, raw_input().split())
ymd = 10000*y + 100*m + d
if ymd < 18680908:
print "pre-meiji"
elif ymd < 19120730:
print "meiji",y-1867,m,d
elif ymd < 19261225:
print "taisho",y-1911,m,d
elif ymd < 19890108:
print "showa",y-1925,m,d
else:
print "heisei",y-1988,m,d
except:
break | p00083 |
<H1>西暦和暦変換</H1>
<p>
西暦で表された年月日を、元号を用いた和暦に変換し、その年月日を出力するプログラムを作成してください。入力は例に示すように 3 つの整数であり、順に西暦年、月、日です。これを、出力例に示すように変換してください。なお、明治以前の年月日が入力された場合は「pre-meiji」と表示してください。
</p>
<p>
各年号の最初の年は「元年」ではなく「１年」と出力することとします。
</p>
<center>
<table border=1>
<tr><td align=center width=100>元号</td><td align=center width=240>期間</td></tr>
<tr><td align=center >meiji</td><td>1868. 9. 8 〜 1912. 7.29</td></tr>
<tr><td align=center >taisho</td><td>1912. 7.30 〜 1926.12.24</td></tr>
<tr><td align=center >showa</td><td>1926.12.25 〜 1989. 1. 7</td></tr>
<tr><td align=center >heisei</td><td>1989. 1. 8 〜</td></tr>
</table>
</center>
<br/>
<H2>入力</H2>
<p>
複数のデータが与えられます。各データとして年、月、日を表す３つの整数が空白区切りで１行に与えられます。
</p>
<p>
入力の終わりまで処理してください。データの数は 50 を超えません。
</p>
<H2>出力</H2>
<p>
空白区切りの元号、年、月、日、または「pre-meiji」を１行に出力してください。
</p>
<H2>Sample Input</H2>
<pre>
2005 9 3
1868 12 2
1868 9 7
</pre>
<H2>Output for the Sample Input</H2>
<pre>
heisei 17 9 3
meiji 1 12 2
pre-meiji
</pre>
| 2005 9 3
1868 12 2
1868 9 7
| heisei 17 9 3
meiji 1 12 2
pre-meiji
| 12,216 |
s028037755 | p00083 | u633068244 | 1393768619 | Python | Python | py | Accepted | 10 | 4208 | 472 | def check(ymd):
if ymd < 18680908:
print "pre-meiji"
elif ymd < 19120730:
print "meiji",y-1867,m,d
elif ymd < 19261225:
print "taisho",y-1911,m,d
elif ymd < 19890108:
print "showa",y-1925,m,d
else:
print "heisei",y-1988,m,d
while True:
try:
y, m, d = map(int, raw_input().split())
ymd = 10000*y + 100*m + d
check(ymd)
except:
break | p00083 |
<H1>西暦和暦変換</H1>
<p>
西暦で表された年月日を、元号を用いた和暦に変換し、その年月日を出力するプログラムを作成してください。入力は例に示すように 3 つの整数であり、順に西暦年、月、日です。これを、出力例に示すように変換してください。なお、明治以前の年月日が入力された場合は「pre-meiji」と表示してください。
</p>
<p>
各年号の最初の年は「元年」ではなく「１年」と出力することとします。
</p>
<center>
<table border=1>
<tr><td align=center width=100>元号</td><td align=center width=240>期間</td></tr>
<tr><td align=center >meiji</td><td>1868. 9. 8 〜 1912. 7.29</td></tr>
<tr><td align=center >taisho</td><td>1912. 7.30 〜 1926.12.24</td></tr>
<tr><td align=center >showa</td><td>1926.12.25 〜 1989. 1. 7</td></tr>
<tr><td align=center >heisei</td><td>1989. 1. 8 〜</td></tr>
</table>
</center>
<br/>
<H2>入力</H2>
<p>
複数のデータが与えられます。各データとして年、月、日を表す３つの整数が空白区切りで１行に与えられます。
</p>
<p>
入力の終わりまで処理してください。データの数は 50 を超えません。
</p>
<H2>出力</H2>
<p>
空白区切りの元号、年、月、日、または「pre-meiji」を１行に出力してください。
</p>
<H2>Sample Input</H2>
<pre>
2005 9 3
1868 12 2
1868 9 7
</pre>
<H2>Output for the Sample Input</H2>
<pre>
heisei 17 9 3
meiji 1 12 2
pre-meiji
</pre>
| 2005 9 3
1868 12 2
1868 9 7
| heisei 17 9 3
meiji 1 12 2
pre-meiji
| 12,217 |
s594696648 | p00083 | u633068244 | 1393768703 | Python | Python | py | Accepted | 10 | 4212 | 484 | def check(ymd,y,m,d):
if ymd < 18680908:
print "pre-meiji"
elif ymd < 19120730:
print "meiji",y-1867,m,d
elif ymd < 19261225:
print "taisho",y-1911,m,d
elif ymd < 19890108:
print "showa",y-1925,m,d
else:
print "heisei",y-1988,m,d
while True:
try:
y, m, d = map(int, raw_input().split())
ymd = 10000*y + 100*m + d
check(ymd,y,m,d)
except:
break | p00083 |
<H1>西暦和暦変換</H1>
<p>
西暦で表された年月日を、元号を用いた和暦に変換し、その年月日を出力するプログラムを作成してください。入力は例に示すように 3 つの整数であり、順に西暦年、月、日です。これを、出力例に示すように変換してください。なお、明治以前の年月日が入力された場合は「pre-meiji」と表示してください。
</p>
<p>
各年号の最初の年は「元年」ではなく「１年」と出力することとします。
</p>
<center>
<table border=1>
<tr><td align=center width=100>元号</td><td align=center width=240>期間</td></tr>
<tr><td align=center >meiji</td><td>1868. 9. 8 〜 1912. 7.29</td></tr>
<tr><td align=center >taisho</td><td>1912. 7.30 〜 1926.12.24</td></tr>
<tr><td align=center >showa</td><td>1926.12.25 〜 1989. 1. 7</td></tr>
<tr><td align=center >heisei</td><td>1989. 1. 8 〜</td></tr>
</table>
</center>
<br/>
<H2>入力</H2>
<p>
複数のデータが与えられます。各データとして年、月、日を表す３つの整数が空白区切りで１行に与えられます。
</p>
<p>
入力の終わりまで処理してください。データの数は 50 を超えません。
</p>
<H2>出力</H2>
<p>
空白区切りの元号、年、月、日、または「pre-meiji」を１行に出力してください。
</p>
<H2>Sample Input</H2>
<pre>
2005 9 3
1868 12 2
1868 9 7
</pre>
<H2>Output for the Sample Input</H2>
<pre>
heisei 17 9 3
meiji 1 12 2
pre-meiji
</pre>
| 2005 9 3
1868 12 2
1868 9 7
| heisei 17 9 3
meiji 1 12 2
pre-meiji
| 12,218 |
s875475233 | p00083 | u193025715 | 1396156865 | Python | Python | py | Accepted | 10 | 4224 | 499 | while True:
try:
y, m, d = map(int, raw_input().split())
date = int("{}{}{}".format('%04d'%y,'%02d'%m,'%02d'%d))
if date < 18680908:
print "pre-meiji"
elif date < 19120730:
y = y - 1868 + 1
print "meiji {} {} {}".format(y,m,d)
elif date < 19261225:
y = y - 1912 + 1
print "taisho {} {} {}".format(y,m,d)
elif date < 19890108:
y = y - 1926 + 1
print "showa {} {} {}".format(y,m,d)
else:
y = y - 1989 + 1
print "heisei {} {} {}".format(y,m,d)
except:
break | p00083 |
<H1>西暦和暦変換</H1>
<p>
西暦で表された年月日を、元号を用いた和暦に変換し、その年月日を出力するプログラムを作成してください。入力は例に示すように 3 つの整数であり、順に西暦年、月、日です。これを、出力例に示すように変換してください。なお、明治以前の年月日が入力された場合は「pre-meiji」と表示してください。
</p>
<p>
各年号の最初の年は「元年」ではなく「１年」と出力することとします。
</p>
<center>
<table border=1>
<tr><td align=center width=100>元号</td><td align=center width=240>期間</td></tr>
<tr><td align=center >meiji</td><td>1868. 9. 8 〜 1912. 7.29</td></tr>
<tr><td align=center >taisho</td><td>1912. 7.30 〜 1926.12.24</td></tr>
<tr><td align=center >showa</td><td>1926.12.25 〜 1989. 1. 7</td></tr>
<tr><td align=center >heisei</td><td>1989. 1. 8 〜</td></tr>
</table>
</center>
<br/>
<H2>入力</H2>
<p>
複数のデータが与えられます。各データとして年、月、日を表す３つの整数が空白区切りで１行に与えられます。
</p>
<p>
入力の終わりまで処理してください。データの数は 50 を超えません。
</p>
<H2>出力</H2>
<p>
空白区切りの元号、年、月、日、または「pre-meiji」を１行に出力してください。
</p>
<H2>Sample Input</H2>
<pre>
2005 9 3
1868 12 2
1868 9 7
</pre>
<H2>Output for the Sample Input</H2>
<pre>
heisei 17 9 3
meiji 1 12 2
pre-meiji
</pre>
| 2005 9 3
1868 12 2
1868 9 7
| heisei 17 9 3
meiji 1 12 2
pre-meiji
| 12,219 |
s618367321 | p00083 | u912237403 | 1398009599 | Python | Python | py | Accepted | 10 | 4220 | 326 | import sys
for s in sys.stdin:
y,m,d=map(int,s[:-1].split())
x="%d%02d%02d"%(y,m,d)
if x<"18680908":e="pre-meiji"
elif x<"19120730":e="meiji %d %d %d"%(y-1867,m,d)
elif x<"19261225":e="taisho %d %d %d"%(y-1911,m,d)
elif x<"19890108":e="showa %d %d %d"%(y-1925,m,d)
else:e="heisei %d %d %d"%(y-1988,m,d)
print e | p00083 |
<H1>西暦和暦変換</H1>
<p>
西暦で表された年月日を、元号を用いた和暦に変換し、その年月日を出力するプログラムを作成してください。入力は例に示すように 3 つの整数であり、順に西暦年、月、日です。これを、出力例に示すように変換してください。なお、明治以前の年月日が入力された場合は「pre-meiji」と表示してください。
</p>
<p>
各年号の最初の年は「元年」ではなく「１年」と出力することとします。
</p>
<center>
<table border=1>
<tr><td align=center width=100>元号</td><td align=center width=240>期間</td></tr>
<tr><td align=center >meiji</td><td>1868. 9. 8 〜 1912. 7.29</td></tr>
<tr><td align=center >taisho</td><td>1912. 7.30 〜 1926.12.24</td></tr>
<tr><td align=center >showa</td><td>1926.12.25 〜 1989. 1. 7</td></tr>
<tr><td align=center >heisei</td><td>1989. 1. 8 〜</td></tr>
</table>
</center>
<br/>
<H2>入力</H2>
<p>
複数のデータが与えられます。各データとして年、月、日を表す３つの整数が空白区切りで１行に与えられます。
</p>
<p>
入力の終わりまで処理してください。データの数は 50 を超えません。
</p>
<H2>出力</H2>
<p>
空白区切りの元号、年、月、日、または「pre-meiji」を１行に出力してください。
</p>
<H2>Sample Input</H2>
<pre>
2005 9 3
1868 12 2
1868 9 7
</pre>
<H2>Output for the Sample Input</H2>
<pre>
heisei 17 9 3
meiji 1 12 2
pre-meiji
</pre>
| 2005 9 3
1868 12 2
1868 9 7
| heisei 17 9 3
meiji 1 12 2
pre-meiji
| 12,220 |
s163486019 | p00083 | u912237403 | 1398010114 | Python | Python | py | Accepted | 10 | 4220 | 313 | import sys
for s in sys.stdin:
y,m,d=map(int,s[:-1].split())
x="%d%02d%02d"%(y,m,d)
w=" %d %d"%(m,d)
if x<"18680908":e="pre-meiji"
elif x<"19120730":e="meiji %d"%(y-1867)+w
elif x<"19261225":e="taisho %d"%(y-1911)+w
elif x<"19890108":e="showa %d"%(y-1925)+w
else:e="heisei %d"%(y-1988)+w
print e | p00083 |
<H1>西暦和暦変換</H1>
<p>
西暦で表された年月日を、元号を用いた和暦に変換し、その年月日を出力するプログラムを作成してください。入力は例に示すように 3 つの整数であり、順に西暦年、月、日です。これを、出力例に示すように変換してください。なお、明治以前の年月日が入力された場合は「pre-meiji」と表示してください。
</p>
<p>
各年号の最初の年は「元年」ではなく「１年」と出力することとします。
</p>
<center>
<table border=1>
<tr><td align=center width=100>元号</td><td align=center width=240>期間</td></tr>
<tr><td align=center >meiji</td><td>1868. 9. 8 〜 1912. 7.29</td></tr>
<tr><td align=center >taisho</td><td>1912. 7.30 〜 1926.12.24</td></tr>
<tr><td align=center >showa</td><td>1926.12.25 〜 1989. 1. 7</td></tr>
<tr><td align=center >heisei</td><td>1989. 1. 8 〜</td></tr>
</table>
</center>
<br/>
<H2>入力</H2>
<p>
複数のデータが与えられます。各データとして年、月、日を表す３つの整数が空白区切りで１行に与えられます。
</p>
<p>
入力の終わりまで処理してください。データの数は 50 を超えません。
</p>
<H2>出力</H2>
<p>
空白区切りの元号、年、月、日、または「pre-meiji」を１行に出力してください。
</p>
<H2>Sample Input</H2>
<pre>
2005 9 3
1868 12 2
1868 9 7
</pre>
<H2>Output for the Sample Input</H2>
<pre>
heisei 17 9 3
meiji 1 12 2
pre-meiji
</pre>
| 2005 9 3
1868 12 2
1868 9 7
| heisei 17 9 3
meiji 1 12 2
pre-meiji
| 12,221 |
s251623651 | p00083 | u912237403 | 1398010592 | Python | Python | py | Accepted | 10 | 4212 | 274 | import sys
for s in sys.stdin:
y,m,d=map(int,s[:-1].split())
x=y*10000+m*100+d
if x<18680908:print"pre-meiji"
elif x<19120730:print"meiji",y-1867,m,d
elif x<19261225:print"taisho",y-1911,m,d
elif x<19890108:print"showa",y-1925,m,d
else:print"heisei",y-1988,m,d | p00083 |
<H1>西暦和暦変換</H1>
<p>
西暦で表された年月日を、元号を用いた和暦に変換し、その年月日を出力するプログラムを作成してください。入力は例に示すように 3 つの整数であり、順に西暦年、月、日です。これを、出力例に示すように変換してください。なお、明治以前の年月日が入力された場合は「pre-meiji」と表示してください。
</p>
<p>
各年号の最初の年は「元年」ではなく「１年」と出力することとします。
</p>
<center>
<table border=1>
<tr><td align=center width=100>元号</td><td align=center width=240>期間</td></tr>
<tr><td align=center >meiji</td><td>1868. 9. 8 〜 1912. 7.29</td></tr>
<tr><td align=center >taisho</td><td>1912. 7.30 〜 1926.12.24</td></tr>
<tr><td align=center >showa</td><td>1926.12.25 〜 1989. 1. 7</td></tr>
<tr><td align=center >heisei</td><td>1989. 1. 8 〜</td></tr>
</table>
</center>
<br/>
<H2>入力</H2>
<p>
複数のデータが与えられます。各データとして年、月、日を表す３つの整数が空白区切りで１行に与えられます。
</p>
<p>
入力の終わりまで処理してください。データの数は 50 を超えません。
</p>
<H2>出力</H2>
<p>
空白区切りの元号、年、月、日、または「pre-meiji」を１行に出力してください。
</p>
<H2>Sample Input</H2>
<pre>
2005 9 3
1868 12 2
1868 9 7
</pre>
<H2>Output for the Sample Input</H2>
<pre>
heisei 17 9 3
meiji 1 12 2
pre-meiji
</pre>
| 2005 9 3
1868 12 2
1868 9 7
| heisei 17 9 3
meiji 1 12 2
pre-meiji
| 12,222 |
s508966826 | p00083 | u912237403 | 1398010949 | Python | Python | py | Accepted | 10 | 4212 | 287 | import sys
for s in sys.stdin:
y,m,d=map(int,s[:-1].split())
x=y*10000+m*100+d
def f(i,w):
print ["meiji","taisho","showa","heisei"][i],y-w,m,d
if x<18680908:print"pre-meiji"
elif x<19120730:f(0,1867)
elif x<19261225:f(1,1911)
elif x<19890108:f(2,1925)
else:f(3,1988) | p00083 |
<H1>西暦和暦変換</H1>
<p>
西暦で表された年月日を、元号を用いた和暦に変換し、その年月日を出力するプログラムを作成してください。入力は例に示すように 3 つの整数であり、順に西暦年、月、日です。これを、出力例に示すように変換してください。なお、明治以前の年月日が入力された場合は「pre-meiji」と表示してください。
</p>
<p>
各年号の最初の年は「元年」ではなく「１年」と出力することとします。
</p>
<center>
<table border=1>
<tr><td align=center width=100>元号</td><td align=center width=240>期間</td></tr>
<tr><td align=center >meiji</td><td>1868. 9. 8 〜 1912. 7.29</td></tr>
<tr><td align=center >taisho</td><td>1912. 7.30 〜 1926.12.24</td></tr>
<tr><td align=center >showa</td><td>1926.12.25 〜 1989. 1. 7</td></tr>
<tr><td align=center >heisei</td><td>1989. 1. 8 〜</td></tr>
</table>
</center>
<br/>
<H2>入力</H2>
<p>
複数のデータが与えられます。各データとして年、月、日を表す３つの整数が空白区切りで１行に与えられます。
</p>
<p>
入力の終わりまで処理してください。データの数は 50 を超えません。
</p>
<H2>出力</H2>
<p>
空白区切りの元号、年、月、日、または「pre-meiji」を１行に出力してください。
</p>
<H2>Sample Input</H2>
<pre>
2005 9 3
1868 12 2
1868 9 7
</pre>
<H2>Output for the Sample Input</H2>
<pre>
heisei 17 9 3
meiji 1 12 2
pre-meiji
</pre>
| 2005 9 3
1868 12 2
1868 9 7
| heisei 17 9 3
meiji 1 12 2
pre-meiji
| 12,223 |
s516528720 | p00083 | u187074069 | 1594292530 | Python | Python3 | py | Accepted | 20 | 5596 | 752 | while True:
try:
lst = list(map(int, input().split()))
num = lst[2] + 100*lst[1] + 10000*lst[0]
if num >= 19890108:
era = "heisei"
lst[0] = lst[0] - 1988
elif num >= 19261225:
era = "showa"
lst[0] = lst[0] - 1925
elif num >= 19120730:
era = "taisho"
lst[0] = lst[0] - 1911
elif num >= 18680908:
era = "meiji"
lst[0] = lst[0] - 1867
else:
era = "pre-meiji"
lst[0] = 0
if lst[0] == 0:
print(era)
else:
print(era + " " + str(lst[0]) + " " + str(lst[1]) + " " + str(lst[2]))
except EOFError:
break
| p00083 |
<H1>西暦和暦変換</H1>
<p>
西暦で表された年月日を、元号を用いた和暦に変換し、その年月日を出力するプログラムを作成してください。入力は例に示すように 3 つの整数であり、順に西暦年、月、日です。これを、出力例に示すように変換してください。なお、明治以前の年月日が入力された場合は「pre-meiji」と表示してください。
</p>
<p>
各年号の最初の年は「元年」ではなく「１年」と出力することとします。
</p>
<center>
<table border=1>
<tr><td align=center width=100>元号</td><td align=center width=240>期間</td></tr>
<tr><td align=center >meiji</td><td>1868. 9. 8 〜 1912. 7.29</td></tr>
<tr><td align=center >taisho</td><td>1912. 7.30 〜 1926.12.24</td></tr>
<tr><td align=center >showa</td><td>1926.12.25 〜 1989. 1. 7</td></tr>
<tr><td align=center >heisei</td><td>1989. 1. 8 〜</td></tr>
</table>
</center>
<br/>
<H2>入力</H2>
<p>
複数のデータが与えられます。各データとして年、月、日を表す３つの整数が空白区切りで１行に与えられます。
</p>
<p>
入力の終わりまで処理してください。データの数は 50 を超えません。
</p>
<H2>出力</H2>
<p>
空白区切りの元号、年、月、日、または「pre-meiji」を１行に出力してください。
</p>
<H2>Sample Input</H2>
<pre>
2005 9 3
1868 12 2
1868 9 7
</pre>
<H2>Output for the Sample Input</H2>
<pre>
heisei 17 9 3
meiji 1 12 2
pre-meiji
</pre>
| 2005 9 3
1868 12 2
1868 9 7
| heisei 17 9 3
meiji 1 12 2
pre-meiji
| 12,224 |
s654977972 | p00083 | u240091169 | 1591856638 | Python | Python3 | py | Accepted | 30 | 5604 | 880 | while True :
try :
y, m, d = map(int, input().split())
except EOFError :
break
if y < 1868 :
print("pre-meiji")
elif y == 1868 and m < 9 :
print("pre-meiji")
elif y == 1868 and m == 9 and d < 8 :
print("pre-meiji")
elif y < 1912 :
print("meiji", y-1867, m, d)
elif y == 1912 and m < 7 :
print("meiji", y-1867, m, d)
elif y == 1912 and m == 7 and d < 30 :
print("meiji", y-1867, m, d)
elif y < 1926 :
print("taisho", y-1911, m, d)
elif y == 1926 and m < 12 :
print("taisho", y-1911, m, d)
elif y == 1926 and m == 12 and d < 25 :
print("taisho", y-1911, m, d)
elif y < 1989 :
print("showa", y-1925, m, d)
elif y == 1989 and m == 1 and d < 8 :
print("showa", y-1925, m, d)
else :
print("heisei", y-1988, m, d)
| p00083 |
<H1>西暦和暦変換</H1>
<p>
西暦で表された年月日を、元号を用いた和暦に変換し、その年月日を出力するプログラムを作成してください。入力は例に示すように 3 つの整数であり、順に西暦年、月、日です。これを、出力例に示すように変換してください。なお、明治以前の年月日が入力された場合は「pre-meiji」と表示してください。
</p>
<p>
各年号の最初の年は「元年」ではなく「１年」と出力することとします。
</p>
<center>
<table border=1>
<tr><td align=center width=100>元号</td><td align=center width=240>期間</td></tr>
<tr><td align=center >meiji</td><td>1868. 9. 8 〜 1912. 7.29</td></tr>
<tr><td align=center >taisho</td><td>1912. 7.30 〜 1926.12.24</td></tr>
<tr><td align=center >showa</td><td>1926.12.25 〜 1989. 1. 7</td></tr>
<tr><td align=center >heisei</td><td>1989. 1. 8 〜</td></tr>
</table>
</center>
<br/>
<H2>入力</H2>
<p>
複数のデータが与えられます。各データとして年、月、日を表す３つの整数が空白区切りで１行に与えられます。
</p>
<p>
入力の終わりまで処理してください。データの数は 50 を超えません。
</p>
<H2>出力</H2>
<p>
空白区切りの元号、年、月、日、または「pre-meiji」を１行に出力してください。
</p>
<H2>Sample Input</H2>
<pre>
2005 9 3
1868 12 2
1868 9 7
</pre>
<H2>Output for the Sample Input</H2>
<pre>
heisei 17 9 3
meiji 1 12 2
pre-meiji
</pre>
| 2005 9 3
1868 12 2
1868 9 7
| heisei 17 9 3
meiji 1 12 2
pre-meiji
| 12,225 |
s548427556 | p00083 | u260980560 | 1590591325 | Python | Python3 | py | Accepted | 20 | 5620 | 822 | import sys
readlines = sys.stdin.readlines
write = sys.stdout.write
def convert(y, m, d):
if m <= 2:
m += 12
y -= 1
mjd = int(365.25*y) + (y//400) - (y//100) + int(30.59*(m-2)) + d - 678912
return mjd
def solve():
A = convert(1868, 9, 8)
B = convert(1912, 7, 30)
C = convert(1926, 12, 25)
D = convert(1989, 1, 8)
for line in readlines():
y, m, d = map(int, line.split())
X = convert(y, m, d)
if X < A:
write("pre-meiji\n")
elif X < B:
write("meiji %d %d %d\n" % (y - 1867, m, d))
elif X < C:
write("taisho %d %d %d\n" % (y - 1911, m, d))
elif X < D:
write("showa %d %d %d\n" % (y - 1925, m, d))
else:
write("heisei %d %d %d\n" % (y - 1988, m, d))
solve()
| p00083 |
<H1>西暦和暦変換</H1>
<p>
西暦で表された年月日を、元号を用いた和暦に変換し、その年月日を出力するプログラムを作成してください。入力は例に示すように 3 つの整数であり、順に西暦年、月、日です。これを、出力例に示すように変換してください。なお、明治以前の年月日が入力された場合は「pre-meiji」と表示してください。
</p>
<p>
各年号の最初の年は「元年」ではなく「１年」と出力することとします。
</p>
<center>
<table border=1>
<tr><td align=center width=100>元号</td><td align=center width=240>期間</td></tr>
<tr><td align=center >meiji</td><td>1868. 9. 8 〜 1912. 7.29</td></tr>
<tr><td align=center >taisho</td><td>1912. 7.30 〜 1926.12.24</td></tr>
<tr><td align=center >showa</td><td>1926.12.25 〜 1989. 1. 7</td></tr>
<tr><td align=center >heisei</td><td>1989. 1. 8 〜</td></tr>
</table>
</center>
<br/>
<H2>入力</H2>
<p>
複数のデータが与えられます。各データとして年、月、日を表す３つの整数が空白区切りで１行に与えられます。
</p>
<p>
入力の終わりまで処理してください。データの数は 50 を超えません。
</p>
<H2>出力</H2>
<p>
空白区切りの元号、年、月、日、または「pre-meiji」を１行に出力してください。
</p>
<H2>Sample Input</H2>
<pre>
2005 9 3
1868 12 2
1868 9 7
</pre>
<H2>Output for the Sample Input</H2>
<pre>
heisei 17 9 3
meiji 1 12 2
pre-meiji
</pre>
| 2005 9 3
1868 12 2
1868 9 7
| heisei 17 9 3
meiji 1 12 2
pre-meiji
| 12,226 |
s978030661 | p00083 | u630911389 | 1584399430 | Python | Python3 | py | Accepted | 20 | 5600 | 610 | while True:
try:
y, m, d = (int(x) for x in input().split())
ymd = 10000 * y + 100 * m + d
ans = "heisei" + " " + str(y - 1988) + " " + str(m) + " " + str(d)
if ymd < 18680908:
ans = "pre-meiji"
elif ymd < 19120730:
ans = "meiji" + " " + str(y - 1867) + " " + str(m) + " " + str(d)
elif ymd < 19261225:
ans = "taisho" + " " + str(y - 1911) + " " + str(m) + " " + str(d)
elif ymd < 19890108:
ans = "showa" + " " + str(y - 1925) + " " + str(m) + " " + str(d)
print(ans)
except:
break
| p00083 |
<H1>西暦和暦変換</H1>
<p>
西暦で表された年月日を、元号を用いた和暦に変換し、その年月日を出力するプログラムを作成してください。入力は例に示すように 3 つの整数であり、順に西暦年、月、日です。これを、出力例に示すように変換してください。なお、明治以前の年月日が入力された場合は「pre-meiji」と表示してください。
</p>
<p>
各年号の最初の年は「元年」ではなく「１年」と出力することとします。
</p>
<center>
<table border=1>
<tr><td align=center width=100>元号</td><td align=center width=240>期間</td></tr>
<tr><td align=center >meiji</td><td>1868. 9. 8 〜 1912. 7.29</td></tr>
<tr><td align=center >taisho</td><td>1912. 7.30 〜 1926.12.24</td></tr>
<tr><td align=center >showa</td><td>1926.12.25 〜 1989. 1. 7</td></tr>
<tr><td align=center >heisei</td><td>1989. 1. 8 〜</td></tr>
</table>
</center>
<br/>
<H2>入力</H2>
<p>
複数のデータが与えられます。各データとして年、月、日を表す３つの整数が空白区切りで１行に与えられます。
</p>
<p>
入力の終わりまで処理してください。データの数は 50 を超えません。
</p>
<H2>出力</H2>
<p>
空白区切りの元号、年、月、日、または「pre-meiji」を１行に出力してください。
</p>
<H2>Sample Input</H2>
<pre>
2005 9 3
1868 12 2
1868 9 7
</pre>
<H2>Output for the Sample Input</H2>
<pre>
heisei 17 9 3
meiji 1 12 2
pre-meiji
</pre>
| 2005 9 3
1868 12 2
1868 9 7
| heisei 17 9 3
meiji 1 12 2
pre-meiji
| 12,227 |
s549338234 | p00083 | u371539389 | 1582611598 | Python | Python3 | py | Accepted | 30 | 6044 | 606 | from datetime import datetime
def gengo(y,m,d):
date=datetime(y,m,d)
if date<datetime(1868,9,8):
return "pre-meiji"
elif date<=datetime(1912,7,29):
return "meiji {0} {1} {2}".format(y-1867,m,d)
elif date<=datetime(1926,12,24):
return "taisho {0} {1} {2}".format(y-1911,m,d)
elif date<=datetime(1989,1,7):
return "showa {0} {1} {2}".format(y-1925,m,d)
else:
return "heisei {0} {1} {2}".format(y-1988,m,d)
while True:
try:
y,m,d=[int(i) for i in input().split(" ")]
print(gengo(y,m,d))
except EOFError:
break
| p00083 |
<H1>西暦和暦変換</H1>
<p>
西暦で表された年月日を、元号を用いた和暦に変換し、その年月日を出力するプログラムを作成してください。入力は例に示すように 3 つの整数であり、順に西暦年、月、日です。これを、出力例に示すように変換してください。なお、明治以前の年月日が入力された場合は「pre-meiji」と表示してください。
</p>
<p>
各年号の最初の年は「元年」ではなく「１年」と出力することとします。
</p>
<center>
<table border=1>
<tr><td align=center width=100>元号</td><td align=center width=240>期間</td></tr>
<tr><td align=center >meiji</td><td>1868. 9. 8 〜 1912. 7.29</td></tr>
<tr><td align=center >taisho</td><td>1912. 7.30 〜 1926.12.24</td></tr>
<tr><td align=center >showa</td><td>1926.12.25 〜 1989. 1. 7</td></tr>
<tr><td align=center >heisei</td><td>1989. 1. 8 〜</td></tr>
</table>
</center>
<br/>
<H2>入力</H2>
<p>
複数のデータが与えられます。各データとして年、月、日を表す３つの整数が空白区切りで１行に与えられます。
</p>
<p>
入力の終わりまで処理してください。データの数は 50 を超えません。
</p>
<H2>出力</H2>
<p>
空白区切りの元号、年、月、日、または「pre-meiji」を１行に出力してください。
</p>
<H2>Sample Input</H2>
<pre>
2005 9 3
1868 12 2
1868 9 7
</pre>
<H2>Output for the Sample Input</H2>
<pre>
heisei 17 9 3
meiji 1 12 2
pre-meiji
</pre>
| 2005 9 3
1868 12 2
1868 9 7
| heisei 17 9 3
meiji 1 12 2
pre-meiji
| 12,228 |
s400601336 | p00083 | u824708460 | 1568333587 | Python | Python3 | py | Accepted | 20 | 5596 | 527 | while 1:
try:
a, b, c = map(int, input().split())
x = a * 10000 + b * 100 + c
if x <= 18680907:
print('pre-meiji')
elif 18680908 <= x and x <= 19120729:
print('meiji', (a-67) % 100, b, c)
elif 19120730 <= x and x <= 19261224:
print('taisho', (a-11) % 100, b, c)
elif 19261225 <= x and x <= 19890107:
print('showa', (a-25) % 100, b, c)
else:
print('heisei', (a - 88) % 100, b, c)
except:
break
| p00083 |
<H1>西暦和暦変換</H1>
<p>
西暦で表された年月日を、元号を用いた和暦に変換し、その年月日を出力するプログラムを作成してください。入力は例に示すように 3 つの整数であり、順に西暦年、月、日です。これを、出力例に示すように変換してください。なお、明治以前の年月日が入力された場合は「pre-meiji」と表示してください。
</p>
<p>
各年号の最初の年は「元年」ではなく「１年」と出力することとします。
</p>
<center>
<table border=1>
<tr><td align=center width=100>元号</td><td align=center width=240>期間</td></tr>
<tr><td align=center >meiji</td><td>1868. 9. 8 〜 1912. 7.29</td></tr>
<tr><td align=center >taisho</td><td>1912. 7.30 〜 1926.12.24</td></tr>
<tr><td align=center >showa</td><td>1926.12.25 〜 1989. 1. 7</td></tr>
<tr><td align=center >heisei</td><td>1989. 1. 8 〜</td></tr>
</table>
</center>
<br/>
<H2>入力</H2>
<p>
複数のデータが与えられます。各データとして年、月、日を表す３つの整数が空白区切りで１行に与えられます。
</p>
<p>
入力の終わりまで処理してください。データの数は 50 を超えません。
</p>
<H2>出力</H2>
<p>
空白区切りの元号、年、月、日、または「pre-meiji」を１行に出力してください。
</p>
<H2>Sample Input</H2>
<pre>
2005 9 3
1868 12 2
1868 9 7
</pre>
<H2>Output for the Sample Input</H2>
<pre>
heisei 17 9 3
meiji 1 12 2
pre-meiji
</pre>
| 2005 9 3
1868 12 2
1868 9 7
| heisei 17 9 3
meiji 1 12 2
pre-meiji
| 12,229 |
s725087490 | p00083 | u647694976 | 1560151250 | Python | Python3 | py | Accepted | 30 | 5600 | 541 | start_data = [18680908, 19120730, 19261225, 19890108, 99999999]
era = ["pre-meiji", "meiji", "taisho", "showa", "heisei"]
while 1:
try:
y, m, d = map(int, input().split(" "))
data = y * 10000 + m * 100 + d
for i in range(5):
if data < start_data[i]:
if i is 0:
print(era[0])
break
else:
print(era[i], data // 10000 - start_data[i - 1] // 10000 + 1, m, d)
break
except:
break
| p00083 |
<H1>西暦和暦変換</H1>
<p>
西暦で表された年月日を、元号を用いた和暦に変換し、その年月日を出力するプログラムを作成してください。入力は例に示すように 3 つの整数であり、順に西暦年、月、日です。これを、出力例に示すように変換してください。なお、明治以前の年月日が入力された場合は「pre-meiji」と表示してください。
</p>
<p>
各年号の最初の年は「元年」ではなく「１年」と出力することとします。
</p>
<center>
<table border=1>
<tr><td align=center width=100>元号</td><td align=center width=240>期間</td></tr>
<tr><td align=center >meiji</td><td>1868. 9. 8 〜 1912. 7.29</td></tr>
<tr><td align=center >taisho</td><td>1912. 7.30 〜 1926.12.24</td></tr>
<tr><td align=center >showa</td><td>1926.12.25 〜 1989. 1. 7</td></tr>
<tr><td align=center >heisei</td><td>1989. 1. 8 〜</td></tr>
</table>
</center>
<br/>
<H2>入力</H2>
<p>
複数のデータが与えられます。各データとして年、月、日を表す３つの整数が空白区切りで１行に与えられます。
</p>
<p>
入力の終わりまで処理してください。データの数は 50 を超えません。
</p>
<H2>出力</H2>
<p>
空白区切りの元号、年、月、日、または「pre-meiji」を１行に出力してください。
</p>
<H2>Sample Input</H2>
<pre>
2005 9 3
1868 12 2
1868 9 7
</pre>
<H2>Output for the Sample Input</H2>
<pre>
heisei 17 9 3
meiji 1 12 2
pre-meiji
</pre>
| 2005 9 3
1868 12 2
1868 9 7
| heisei 17 9 3
meiji 1 12 2
pre-meiji
| 12,230 |
s385130580 | p00083 | u717526540 | 1542854466 | Python | Python3 | py | Accepted | 20 | 5604 | 1,766 | while 1:
try:
year, month, day = map(int, input().split())
except EOFError:
break
if year < 1868:
gen = "pre-meiji"
elif year == 1868:
if month < 9:
gen = "pre-meiji"
elif month == 9:
if day < 8:
gen = "pre-meiji"
else:
gen = "meiji"
y = 1
else:
gen = "meiji"
y = 1
elif 1868 < year < 1912:
gen = "meiji"
y = year - 1868 + 1
elif year == 1912:
if month < 7:
gen = "meiji"
y = 45
elif month == 7:
if day < 30:
gen = "meiji"
y = 45
else:
gen = "taisho"
y = 1
else:
gen = "taisho"
y = 1
elif 1912 < year < 1926:
gen = "taisho"
y = year - 1912 + 1
elif year == 1926:
if month < 12:
gen = "taisho"
y = 15
elif month == 12:
if day < 25:
gen = "taisho"
y = 15
else:
gen = "showa"
y = 1
else:
gen = "showa"
y = 1
elif 1926 < year < 1989:
gen = "showa"
y = year - 1926 + 1
elif year == 1989:
if month == 1:
if day < 8:
gen = "showa"
y = 64
else:
gen = "heisei"
y = 1
else:
gen = "heisei"
y = 1
elif 1989 < year:
gen = "heisei"
y = year - 1989 + 1
if gen == "pre-meiji":
print(gen)
else:
print(gen, str(y), str(month), str(day))
| p00083 |
<H1>西暦和暦変換</H1>
<p>
西暦で表された年月日を、元号を用いた和暦に変換し、その年月日を出力するプログラムを作成してください。入力は例に示すように 3 つの整数であり、順に西暦年、月、日です。これを、出力例に示すように変換してください。なお、明治以前の年月日が入力された場合は「pre-meiji」と表示してください。
</p>
<p>
各年号の最初の年は「元年」ではなく「１年」と出力することとします。
</p>
<center>
<table border=1>
<tr><td align=center width=100>元号</td><td align=center width=240>期間</td></tr>
<tr><td align=center >meiji</td><td>1868. 9. 8 〜 1912. 7.29</td></tr>
<tr><td align=center >taisho</td><td>1912. 7.30 〜 1926.12.24</td></tr>
<tr><td align=center >showa</td><td>1926.12.25 〜 1989. 1. 7</td></tr>
<tr><td align=center >heisei</td><td>1989. 1. 8 〜</td></tr>
</table>
</center>
<br/>
<H2>入力</H2>
<p>
複数のデータが与えられます。各データとして年、月、日を表す３つの整数が空白区切りで１行に与えられます。
</p>
<p>
入力の終わりまで処理してください。データの数は 50 を超えません。
</p>
<H2>出力</H2>
<p>
空白区切りの元号、年、月、日、または「pre-meiji」を１行に出力してください。
</p>
<H2>Sample Input</H2>
<pre>
2005 9 3
1868 12 2
1868 9 7
</pre>
<H2>Output for the Sample Input</H2>
<pre>
heisei 17 9 3
meiji 1 12 2
pre-meiji
</pre>
| 2005 9 3
1868 12 2
1868 9 7
| heisei 17 9 3
meiji 1 12 2
pre-meiji
| 12,231 |
s036638964 | p00083 | u197615397 | 1532220175 | Python | Python3 | py | Accepted | 20 | 5640 | 413 | from bisect import bisect_left
import sys
name = ["pre-meiji", "meiji", "taisho", "showa", "heisei"]
period = [(1868,9,7), (1912,7,29), (1926,12,24), (1989,1,7)]
for t in (tuple(map(int, l.split())) for l in sys.stdin):
index = bisect_left(period, t)
if index:
date = "{} {} {}".format(t[0]-period[index-1][0]+1, t[1], t[2])
print(name[index], date)
else:
print(name[index])
| p00083 |
<H1>西暦和暦変換</H1>
<p>
西暦で表された年月日を、元号を用いた和暦に変換し、その年月日を出力するプログラムを作成してください。入力は例に示すように 3 つの整数であり、順に西暦年、月、日です。これを、出力例に示すように変換してください。なお、明治以前の年月日が入力された場合は「pre-meiji」と表示してください。
</p>
<p>
各年号の最初の年は「元年」ではなく「１年」と出力することとします。
</p>
<center>
<table border=1>
<tr><td align=center width=100>元号</td><td align=center width=240>期間</td></tr>
<tr><td align=center >meiji</td><td>1868. 9. 8 〜 1912. 7.29</td></tr>
<tr><td align=center >taisho</td><td>1912. 7.30 〜 1926.12.24</td></tr>
<tr><td align=center >showa</td><td>1926.12.25 〜 1989. 1. 7</td></tr>
<tr><td align=center >heisei</td><td>1989. 1. 8 〜</td></tr>
</table>
</center>
<br/>
<H2>入力</H2>
<p>
複数のデータが与えられます。各データとして年、月、日を表す３つの整数が空白区切りで１行に与えられます。
</p>
<p>
入力の終わりまで処理してください。データの数は 50 を超えません。
</p>
<H2>出力</H2>
<p>
空白区切りの元号、年、月、日、または「pre-meiji」を１行に出力してください。
</p>
<H2>Sample Input</H2>
<pre>
2005 9 3
1868 12 2
1868 9 7
</pre>
<H2>Output for the Sample Input</H2>
<pre>
heisei 17 9 3
meiji 1 12 2
pre-meiji
</pre>
| 2005 9 3
1868 12 2
1868 9 7
| heisei 17 9 3
meiji 1 12 2
pre-meiji
| 12,232 |
s662992969 | p00083 | u197615660 | 1374674353 | Python | Python | py | Accepted | 20 | 4268 | 783 | while True:
try:
data = map(int, raw_input().split())
if data[0] <= 1868 and data[1] <= 9 and data[2] < 8:
gengo = 'pre-meiji'
elif 1868 <= data[0] <= 1911:
gengo = 'meiji' + ' ' + str(data[0]-1867)
elif data[0] == 1912 and data[1] <= 7 and data[2] < 30:
gengo = 'meiji 45'
elif data[0] <= 1925:
gengo = 'taisho' + ' ' + str(data[0]-1911)
elif data[0] == 1926 and data[1] <= 12 and data[2] < 25:
gengo = 'taisho 15'
elif data[0] <= 1988:
gengo = 'showa' + ' ' + str(data[0]-1925)
elif data[0] == 1989 and data[1] == 1 and data[2] <8:
gengo = 'showa 64'
else:
gengo = 'heisei' + ' ' + str(data[0]-1988)
if gengo == 'pre-meiji':
print gengo
else:
print gengo + ' ' + str(data[1]) + ' ' + str(data[2])
except EOFError:
break
| p00083 |
<H1>西暦和暦変換</H1>
<p>
西暦で表された年月日を、元号を用いた和暦に変換し、その年月日を出力するプログラムを作成してください。入力は例に示すように 3 つの整数であり、順に西暦年、月、日です。これを、出力例に示すように変換してください。なお、明治以前の年月日が入力された場合は「pre-meiji」と表示してください。
</p>
<p>
各年号の最初の年は「元年」ではなく「１年」と出力することとします。
</p>
<center>
<table border=1>
<tr><td align=center width=100>元号</td><td align=center width=240>期間</td></tr>
<tr><td align=center >meiji</td><td>1868. 9. 8 〜 1912. 7.29</td></tr>
<tr><td align=center >taisho</td><td>1912. 7.30 〜 1926.12.24</td></tr>
<tr><td align=center >showa</td><td>1926.12.25 〜 1989. 1. 7</td></tr>
<tr><td align=center >heisei</td><td>1989. 1. 8 〜</td></tr>
</table>
</center>
<br/>
<H2>入力</H2>
<p>
複数のデータが与えられます。各データとして年、月、日を表す３つの整数が空白区切りで１行に与えられます。
</p>
<p>
入力の終わりまで処理してください。データの数は 50 を超えません。
</p>
<H2>出力</H2>
<p>
空白区切りの元号、年、月、日、または「pre-meiji」を１行に出力してください。
</p>
<H2>Sample Input</H2>
<pre>
2005 9 3
1868 12 2
1868 9 7
</pre>
<H2>Output for the Sample Input</H2>
<pre>
heisei 17 9 3
meiji 1 12 2
pre-meiji
</pre>
| 2005 9 3
1868 12 2
1868 9 7
| heisei 17 9 3
meiji 1 12 2
pre-meiji
| 12,233 |
s584628609 | p00084 | u563075864 | 1545206179 | Python | Python3 | py | Accepted | 20 | 5568 | 199 | sent = input()
sent = sent.replace("."," ")
sent = sent.replace(","," ")
words = sent.split()
words = [i for i in words if len(i) <= 6]
words = [i for i in words if len(i) > 2]
print(*words,sep=" ")
| p00084 |
<H1>検索エンジン</H1>
<p>
インターネットの検索エンジン、例えば、Google などでは、世界中のウェブページを自動で収捨して分類し、巨大なデータベースを作成します。また、ユーザが入力した検索キーワードを解析して、データベース検索のための問い合わせ文を作成します。
</p>
<p>
いずれの場合も、効率的な検索を実現するために複雑な処理を行っていますが、とりあえずの基本は全て文章からの単語の切り出しです。
</p>
<p>
ということで、文章からの単語の切り出しに挑戦してください。今回は以下の通り、単語区切りが明確な英語の文章を対象とします。
</p>
<ul>
<li> 対象となる文章 ： 改行を含まない 1024 文字以下の英語の文章 </li>
<li> 区切り文字 ： いずれも半角で空白、ピリオド、カンマのみ</li>
<li> 切り出す単語 ： 3 から 6 文字の単語（2文字以下や7文字以上の単語は無視） </li>
</ul>
<H2>入力</H2>
<p>区切り文字及び英数字で構成される英文が１行（すべて半角）に与えられます。
</p>
<H2>出力</H2>
<p>空白文字１文字（半角）で区切られた単語を１行に出力してください。
</p>
<H2>Sample Input</H2>
<pre>
Rain, rain, go to Spain.
</pre>
<H2>Output for the Sample Input</H2>
<pre>
Rain rain Spain
</pre>
<H2>Sample Input 2</H2>
<pre>
Win today's preliminary contest and be qualified to visit University of Aizu.
</pre>
<H2>Output for the Sample Input 2</H2>
<pre>
Win and visit Aizu
</pre>
| Rain, rain, go to Spain.
| Rain rain Spain
| 12,234 |
s293971397 | p00084 | u037441960 | 1559540347 | Python | Python3 | py | Accepted | 40 | 6512 | 289 | import re
s = re.split("[ .,]", input())
sl = len(s)
ans = list()
for i in range(sl) :
if(2 < len(s[i]) and len(s[i]) < 7) :
ans.append(s[i])
else :
pass
ansl = len(ans)
for i in range(ansl) :
if(i == ansl - 1) :
print(ans[i])
else :
print(ans[i], end = (" "))
| p00084 |
<H1>検索エンジン</H1>
<p>
インターネットの検索エンジン、例えば、Google などでは、世界中のウェブページを自動で収捨して分類し、巨大なデータベースを作成します。また、ユーザが入力した検索キーワードを解析して、データベース検索のための問い合わせ文を作成します。
</p>
<p>
いずれの場合も、効率的な検索を実現するために複雑な処理を行っていますが、とりあえずの基本は全て文章からの単語の切り出しです。
</p>
<p>
ということで、文章からの単語の切り出しに挑戦してください。今回は以下の通り、単語区切りが明確な英語の文章を対象とします。
</p>
<ul>
<li> 対象となる文章 ： 改行を含まない 1024 文字以下の英語の文章 </li>
<li> 区切り文字 ： いずれも半角で空白、ピリオド、カンマのみ</li>
<li> 切り出す単語 ： 3 から 6 文字の単語（2文字以下や7文字以上の単語は無視） </li>
</ul>
<H2>入力</H2>
<p>区切り文字及び英数字で構成される英文が１行（すべて半角）に与えられます。
</p>
<H2>出力</H2>
<p>空白文字１文字（半角）で区切られた単語を１行に出力してください。
</p>
<H2>Sample Input</H2>
<pre>
Rain, rain, go to Spain.
</pre>
<H2>Output for the Sample Input</H2>
<pre>
Rain rain Spain
</pre>
<H2>Sample Input 2</H2>
<pre>
Win today's preliminary contest and be qualified to visit University of Aizu.
</pre>
<H2>Output for the Sample Input 2</H2>
<pre>
Win and visit Aizu
</pre>
| Rain, rain, go to Spain.
| Rain rain Spain
| 12,235 |
s758387377 | p00084 | u506132575 | 1417742956 | Python | Python | py | Accepted | 10 | 4192 | 106 | import re
s = raw_input()
for e in filter(lambda w: 2 < len(w) < 7, re.split(r'\s|,|\.',s) ):
print e, | p00084 |
<H1>検索エンジン</H1>
<p>
インターネットの検索エンジン、例えば、Google などでは、世界中のウェブページを自動で収捨して分類し、巨大なデータベースを作成します。また、ユーザが入力した検索キーワードを解析して、データベース検索のための問い合わせ文を作成します。
</p>
<p>
いずれの場合も、効率的な検索を実現するために複雑な処理を行っていますが、とりあえずの基本は全て文章からの単語の切り出しです。
</p>
<p>
ということで、文章からの単語の切り出しに挑戦してください。今回は以下の通り、単語区切りが明確な英語の文章を対象とします。
</p>
<ul>
<li> 対象となる文章 ： 改行を含まない 1024 文字以下の英語の文章 </li>
<li> 区切り文字 ： いずれも半角で空白、ピリオド、カンマのみ</li>
<li> 切り出す単語 ： 3 から 6 文字の単語（2文字以下や7文字以上の単語は無視） </li>
</ul>
<H2>入力</H2>
<p>区切り文字及び英数字で構成される英文が１行（すべて半角）に与えられます。
</p>
<H2>出力</H2>
<p>空白文字１文字（半角）で区切られた単語を１行に出力してください。
</p>
<H2>Sample Input</H2>
<pre>
Rain, rain, go to Spain.
</pre>
<H2>Output for the Sample Input</H2>
<pre>
Rain rain Spain
</pre>
<H2>Sample Input 2</H2>
<pre>
Win today's preliminary contest and be qualified to visit University of Aizu.
</pre>
<H2>Output for the Sample Input 2</H2>
<pre>
Win and visit Aizu
</pre>
| Rain, rain, go to Spain.
| Rain rain Spain
| 12,236 |
s305758798 | p00084 | u567380442 | 1423311371 | Python | Python3 | py | Accepted | 30 | 6728 | 121 | import sys
f = sys.stdin
import re
print(*[word for word in re.split(r'\s|,|\.', f.readline()) if 3 <= len(word) <= 6]) | p00084 |
<H1>検索エンジン</H1>
<p>
インターネットの検索エンジン、例えば、Google などでは、世界中のウェブページを自動で収捨して分類し、巨大なデータベースを作成します。また、ユーザが入力した検索キーワードを解析して、データベース検索のための問い合わせ文を作成します。
</p>
<p>
いずれの場合も、効率的な検索を実現するために複雑な処理を行っていますが、とりあえずの基本は全て文章からの単語の切り出しです。
</p>
<p>
ということで、文章からの単語の切り出しに挑戦してください。今回は以下の通り、単語区切りが明確な英語の文章を対象とします。
</p>
<ul>
<li> 対象となる文章 ： 改行を含まない 1024 文字以下の英語の文章 </li>
<li> 区切り文字 ： いずれも半角で空白、ピリオド、カンマのみ</li>
<li> 切り出す単語 ： 3 から 6 文字の単語（2文字以下や7文字以上の単語は無視） </li>
</ul>
<H2>入力</H2>
<p>区切り文字及び英数字で構成される英文が１行（すべて半角）に与えられます。
</p>
<H2>出力</H2>
<p>空白文字１文字（半角）で区切られた単語を１行に出力してください。
</p>
<H2>Sample Input</H2>
<pre>
Rain, rain, go to Spain.
</pre>
<H2>Output for the Sample Input</H2>
<pre>
Rain rain Spain
</pre>
<H2>Sample Input 2</H2>
<pre>
Win today's preliminary contest and be qualified to visit University of Aizu.
</pre>
<H2>Output for the Sample Input 2</H2>
<pre>
Win and visit Aizu
</pre>
| Rain, rain, go to Spain.
| Rain rain Spain
| 12,237 |
s418933829 | p00084 | u145563629 | 1429602433 | Python | Python | py | Accepted | 10 | 4184 | 104 | import re
s = re.split("[ .,]", raw_input())
for i in s:
d = len(i)
if d >= 3 and d <= 6:
print i, | p00084 |
<H1>検索エンジン</H1>
<p>
インターネットの検索エンジン、例えば、Google などでは、世界中のウェブページを自動で収捨して分類し、巨大なデータベースを作成します。また、ユーザが入力した検索キーワードを解析して、データベース検索のための問い合わせ文を作成します。
</p>
<p>
いずれの場合も、効率的な検索を実現するために複雑な処理を行っていますが、とりあえずの基本は全て文章からの単語の切り出しです。
</p>
<p>
ということで、文章からの単語の切り出しに挑戦してください。今回は以下の通り、単語区切りが明確な英語の文章を対象とします。
</p>
<ul>
<li> 対象となる文章 ： 改行を含まない 1024 文字以下の英語の文章 </li>
<li> 区切り文字 ： いずれも半角で空白、ピリオド、カンマのみ</li>
<li> 切り出す単語 ： 3 から 6 文字の単語（2文字以下や7文字以上の単語は無視） </li>
</ul>
<H2>入力</H2>
<p>区切り文字及び英数字で構成される英文が１行（すべて半角）に与えられます。
</p>
<H2>出力</H2>
<p>空白文字１文字（半角）で区切られた単語を１行に出力してください。
</p>
<H2>Sample Input</H2>
<pre>
Rain, rain, go to Spain.
</pre>
<H2>Output for the Sample Input</H2>
<pre>
Rain rain Spain
</pre>
<H2>Sample Input 2</H2>
<pre>
Win today's preliminary contest and be qualified to visit University of Aizu.
</pre>
<H2>Output for the Sample Input 2</H2>
<pre>
Win and visit Aizu
</pre>
| Rain, rain, go to Spain.
| Rain rain Spain
| 12,238 |
s984296395 | p00084 | u873482706 | 1435021864 | Python | Python | py | Accepted | 10 | 4212 | 441 | while True:
result = []
try:
sentence = raw_input()
s_i = None
for i, c in enumerate(sentence):
if s_i == None:
s_i = i
if c == ' ' or c == ',' or c == '.':
if 3 <= len(sentence[s_i:i]) <= 6:
result.append(sentence[s_i:i])
s_i = None
else:
print ' '.join(result)
except EOFError:
break | p00084 |
<H1>検索エンジン</H1>
<p>
インターネットの検索エンジン、例えば、Google などでは、世界中のウェブページを自動で収捨して分類し、巨大なデータベースを作成します。また、ユーザが入力した検索キーワードを解析して、データベース検索のための問い合わせ文を作成します。
</p>
<p>
いずれの場合も、効率的な検索を実現するために複雑な処理を行っていますが、とりあえずの基本は全て文章からの単語の切り出しです。
</p>
<p>
ということで、文章からの単語の切り出しに挑戦してください。今回は以下の通り、単語区切りが明確な英語の文章を対象とします。
</p>
<ul>
<li> 対象となる文章 ： 改行を含まない 1024 文字以下の英語の文章 </li>
<li> 区切り文字 ： いずれも半角で空白、ピリオド、カンマのみ</li>
<li> 切り出す単語 ： 3 から 6 文字の単語（2文字以下や7文字以上の単語は無視） </li>
</ul>
<H2>入力</H2>
<p>区切り文字及び英数字で構成される英文が１行（すべて半角）に与えられます。
</p>
<H2>出力</H2>
<p>空白文字１文字（半角）で区切られた単語を１行に出力してください。
</p>
<H2>Sample Input</H2>
<pre>
Rain, rain, go to Spain.
</pre>
<H2>Output for the Sample Input</H2>
<pre>
Rain rain Spain
</pre>
<H2>Sample Input 2</H2>
<pre>
Win today's preliminary contest and be qualified to visit University of Aizu.
</pre>
<H2>Output for the Sample Input 2</H2>
<pre>
Win and visit Aizu
</pre>
| Rain, rain, go to Spain.
| Rain rain Spain
| 12,239 |
s737605154 | p00084 | u467929102 | 1440507011 | Python | Python | py | Accepted | 10 | 6388 | 297 | import sys
line = raw_input()
word_list = line.translate(None, '.,').split()
ans = []
for word in word_list:
if len(word) >= 3 and len(word) <= 6:
ans.append(word)
for i, w in enumerate(ans):
if i != 0:
sys.stdout.write(" ")
sys.stdout.write(w)
sys.stdout.write("\n") | p00084 |
<H1>検索エンジン</H1>
<p>
インターネットの検索エンジン、例えば、Google などでは、世界中のウェブページを自動で収捨して分類し、巨大なデータベースを作成します。また、ユーザが入力した検索キーワードを解析して、データベース検索のための問い合わせ文を作成します。
</p>
<p>
いずれの場合も、効率的な検索を実現するために複雑な処理を行っていますが、とりあえずの基本は全て文章からの単語の切り出しです。
</p>
<p>
ということで、文章からの単語の切り出しに挑戦してください。今回は以下の通り、単語区切りが明確な英語の文章を対象とします。
</p>
<ul>
<li> 対象となる文章 ： 改行を含まない 1024 文字以下の英語の文章 </li>
<li> 区切り文字 ： いずれも半角で空白、ピリオド、カンマのみ</li>
<li> 切り出す単語 ： 3 から 6 文字の単語（2文字以下や7文字以上の単語は無視） </li>
</ul>
<H2>入力</H2>
<p>区切り文字及び英数字で構成される英文が１行（すべて半角）に与えられます。
</p>
<H2>出力</H2>
<p>空白文字１文字（半角）で区切られた単語を１行に出力してください。
</p>
<H2>Sample Input</H2>
<pre>
Rain, rain, go to Spain.
</pre>
<H2>Output for the Sample Input</H2>
<pre>
Rain rain Spain
</pre>
<H2>Sample Input 2</H2>
<pre>
Win today's preliminary contest and be qualified to visit University of Aizu.
</pre>
<H2>Output for the Sample Input 2</H2>
<pre>
Win and visit Aizu
</pre>
| Rain, rain, go to Spain.
| Rain rain Spain
| 12,240 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.