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 |
|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
s584875648 | p00076 | u847467233 | 1529228182 | Python | Python3 | py | Accepted | 20 | 5788 | 321 | # AOJ 0076 Treasure Hunt II
# Python3 2018.6.15 bal4u
import math
MAX = 1005
r, d = [0.0]*MAX, [0.0]*MAX
r[1] = 1.0
for i in range(2, MAX):
d[i] = d[i-1] + math.atan(1 / r[i-1])
r[i] = math.sqrt(r[i-1]**2 + 1)
while True:
i = int(input())
if i < 0: break
print(r[i]*math.cos(d[i]), r[i]*math.sin(d[i]), sep='\n')
| p00076 |
<H1>宝探し II</H1>
<p>
蔵を片付けていたら、先祖の宝のありかへの行き方を記した古文書が見つかりました。この古文書にはおおよそ次のような事が書かれていました。
</p>
<pre class=exp>
1. まず、町外れの井戸から、真東に 1m の地点に立ち、まっすぐ井戸の方向を向け。
2. 右回りに 90 度向きを変え、1m 直進したら、まっすぐ井戸の方向を向け。
3. 右回りに 90 度向きを変え、1m 直進したら、まっすぐ井戸の方向を向け。
4. 〃
5. 〃
6. ：
</pre>
<p>
2 行目以降は、全く同じことが書かれていました。あなたは、宝を探そうと思いましたが、厄介なことに気がつきました。昔と違い建物が邪魔をしていて、まっすぐ井戸の方向をむこうにも井戸が見えなかったり 1m 直進しようにも直進できなかったりします。さらに、この古文書ときたら、1000 行近くあり、古文書どおりの作業をすることは、かなりの時間と体力が要ります。しかしながら、幸運なことに、あなたはコンピュータを利用することができます。
</p>
<p>古文書に書かれている行数 <var>n</var> を入力して、宝のありかを出力するプログラムを作成してください。ただし、 <var>n</var> は 2 以上 1,000 以下の正の整数とします。
</p>
<H2>入力</H2>
<p>複数のデータセットが与えられます。各データセットとして、古文書の行数を表す１つの整数 <var>n</var> が１行に与えられます。
</p>
<p>入力は -1 で終わります。データセットの数は 50 を超えません。</p>
<H2>出力</H2>
<p>
町外れの井戸から東に <var>x</var> (m)，北に <var>y</var> (m)の位置に宝があるとして、
各データセットごとに以下の形式で出力して下さい。</p>
<pre>
<var>x</var>
<var>y</var>
</pre>
<p>
出力は実数とし、0.01 以下の誤差を含んでもよい。
</pre>
<H2>Sample Input</H2>
<pre>
3
6
-1
</pre>
<H2>Output for the Sample Input</H2>
<pre>
0.29
1.71
-2.31
0.80
</pre>
<H2>参考</H2>
<p><var>n</var> =2, 3, 4, 5, 6 の宝の位置</p>
<img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_04_1">
| 3
6
-1
| 0.29
1.71
-2.31
0.80
| 11,841 |
s206233496 | p00076 | u647766105 | 1357083014 | Python | Python | py | Accepted | 20 | 4364 | 203 | def f(x,y):
d=(x*x+y*y)**0.5
return -y/d,x/d
while True:
n=input()
if n==-1:
break
x,y=1.0,0
for i in xrange(n-1):
dx,dy=f(x,y)
x,y=x+dx,y+dy
print x,y | p00076 |
<H1>宝探し II</H1>
<p>
蔵を片付けていたら、先祖の宝のありかへの行き方を記した古文書が見つかりました。この古文書にはおおよそ次のような事が書かれていました。
</p>
<pre class=exp>
1. まず、町外れの井戸から、真東に 1m の地点に立ち、まっすぐ井戸の方向を向け。
2. 右回りに 90 度向きを変え、1m 直進したら、まっすぐ井戸の方向を向け。
3. 右回りに 90 度向きを変え、1m 直進したら、まっすぐ井戸の方向を向け。
4. 〃
5. 〃
6. ：
</pre>
<p>
2 行目以降は、全く同じことが書かれていました。あなたは、宝を探そうと思いましたが、厄介なことに気がつきました。昔と違い建物が邪魔をしていて、まっすぐ井戸の方向をむこうにも井戸が見えなかったり 1m 直進しようにも直進できなかったりします。さらに、この古文書ときたら、1000 行近くあり、古文書どおりの作業をすることは、かなりの時間と体力が要ります。しかしながら、幸運なことに、あなたはコンピュータを利用することができます。
</p>
<p>古文書に書かれている行数 <var>n</var> を入力して、宝のありかを出力するプログラムを作成してください。ただし、 <var>n</var> は 2 以上 1,000 以下の正の整数とします。
</p>
<H2>入力</H2>
<p>複数のデータセットが与えられます。各データセットとして、古文書の行数を表す１つの整数 <var>n</var> が１行に与えられます。
</p>
<p>入力は -1 で終わります。データセットの数は 50 を超えません。</p>
<H2>出力</H2>
<p>
町外れの井戸から東に <var>x</var> (m)，北に <var>y</var> (m)の位置に宝があるとして、
各データセットごとに以下の形式で出力して下さい。</p>
<pre>
<var>x</var>
<var>y</var>
</pre>
<p>
出力は実数とし、0.01 以下の誤差を含んでもよい。
</pre>
<H2>Sample Input</H2>
<pre>
3
6
-1
</pre>
<H2>Output for the Sample Input</H2>
<pre>
0.29
1.71
-2.31
0.80
</pre>
<H2>参考</H2>
<p><var>n</var> =2, 3, 4, 5, 6 の宝の位置</p>
<img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_04_1">
| 3
6
-1
| 0.29
1.71
-2.31
0.80
| 11,842 |
s251098515 | p00076 | u647766105 | 1357083091 | Python | Python | py | Accepted | 20 | 4364 | 182 | def f(x,y):
d=(x*x+y*y)**0.5
return x-y/d,y+x/d
while True:
n=input()
if n==-1:
break
x,y=1.0,0
for i in xrange(n-1):
x,y=f(x,y)
print x,y | p00076 |
<H1>宝探し II</H1>
<p>
蔵を片付けていたら、先祖の宝のありかへの行き方を記した古文書が見つかりました。この古文書にはおおよそ次のような事が書かれていました。
</p>
<pre class=exp>
1. まず、町外れの井戸から、真東に 1m の地点に立ち、まっすぐ井戸の方向を向け。
2. 右回りに 90 度向きを変え、1m 直進したら、まっすぐ井戸の方向を向け。
3. 右回りに 90 度向きを変え、1m 直進したら、まっすぐ井戸の方向を向け。
4. 〃
5. 〃
6. ：
</pre>
<p>
2 行目以降は、全く同じことが書かれていました。あなたは、宝を探そうと思いましたが、厄介なことに気がつきました。昔と違い建物が邪魔をしていて、まっすぐ井戸の方向をむこうにも井戸が見えなかったり 1m 直進しようにも直進できなかったりします。さらに、この古文書ときたら、1000 行近くあり、古文書どおりの作業をすることは、かなりの時間と体力が要ります。しかしながら、幸運なことに、あなたはコンピュータを利用することができます。
</p>
<p>古文書に書かれている行数 <var>n</var> を入力して、宝のありかを出力するプログラムを作成してください。ただし、 <var>n</var> は 2 以上 1,000 以下の正の整数とします。
</p>
<H2>入力</H2>
<p>複数のデータセットが与えられます。各データセットとして、古文書の行数を表す１つの整数 <var>n</var> が１行に与えられます。
</p>
<p>入力は -1 で終わります。データセットの数は 50 を超えません。</p>
<H2>出力</H2>
<p>
町外れの井戸から東に <var>x</var> (m)，北に <var>y</var> (m)の位置に宝があるとして、
各データセットごとに以下の形式で出力して下さい。</p>
<pre>
<var>x</var>
<var>y</var>
</pre>
<p>
出力は実数とし、0.01 以下の誤差を含んでもよい。
</pre>
<H2>Sample Input</H2>
<pre>
3
6
-1
</pre>
<H2>Output for the Sample Input</H2>
<pre>
0.29
1.71
-2.31
0.80
</pre>
<H2>参考</H2>
<p><var>n</var> =2, 3, 4, 5, 6 の宝の位置</p>
<img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_04_1">
| 3
6
-1
| 0.29
1.71
-2.31
0.80
| 11,843 |
s492134200 | p00076 | u782850731 | 1378728718 | Python | Python | py | Accepted | 20 | 4644 | 475 | #!/usr/bin/env python
# -*- coding: utf-8 -*-
from __future__ import (division, absolute_import, print_function,
unicode_literals)
from sys import stdin
from math import cos, sin, atan2, pi
PI2 = pi / 2
L = [None, (1.0, 0.0)]
for _ in range(2, 1001):
x, y = L[-1]
rad = atan2(y, x) + PI2
L.append((x + cos(rad), y + sin(rad)))
for line in stdin:
n = int(line)
if n == -1:
break
print('{:0.2f}\n{:0.2f}'.format(*L[n])) | p00076 |
<H1>宝探し II</H1>
<p>
蔵を片付けていたら、先祖の宝のありかへの行き方を記した古文書が見つかりました。この古文書にはおおよそ次のような事が書かれていました。
</p>
<pre class=exp>
1. まず、町外れの井戸から、真東に 1m の地点に立ち、まっすぐ井戸の方向を向け。
2. 右回りに 90 度向きを変え、1m 直進したら、まっすぐ井戸の方向を向け。
3. 右回りに 90 度向きを変え、1m 直進したら、まっすぐ井戸の方向を向け。
4. 〃
5. 〃
6. ：
</pre>
<p>
2 行目以降は、全く同じことが書かれていました。あなたは、宝を探そうと思いましたが、厄介なことに気がつきました。昔と違い建物が邪魔をしていて、まっすぐ井戸の方向をむこうにも井戸が見えなかったり 1m 直進しようにも直進できなかったりします。さらに、この古文書ときたら、1000 行近くあり、古文書どおりの作業をすることは、かなりの時間と体力が要ります。しかしながら、幸運なことに、あなたはコンピュータを利用することができます。
</p>
<p>古文書に書かれている行数 <var>n</var> を入力して、宝のありかを出力するプログラムを作成してください。ただし、 <var>n</var> は 2 以上 1,000 以下の正の整数とします。
</p>
<H2>入力</H2>
<p>複数のデータセットが与えられます。各データセットとして、古文書の行数を表す１つの整数 <var>n</var> が１行に与えられます。
</p>
<p>入力は -1 で終わります。データセットの数は 50 を超えません。</p>
<H2>出力</H2>
<p>
町外れの井戸から東に <var>x</var> (m)，北に <var>y</var> (m)の位置に宝があるとして、
各データセットごとに以下の形式で出力して下さい。</p>
<pre>
<var>x</var>
<var>y</var>
</pre>
<p>
出力は実数とし、0.01 以下の誤差を含んでもよい。
</pre>
<H2>Sample Input</H2>
<pre>
3
6
-1
</pre>
<H2>Output for the Sample Input</H2>
<pre>
0.29
1.71
-2.31
0.80
</pre>
<H2>参考</H2>
<p><var>n</var> =2, 3, 4, 5, 6 の宝の位置</p>
<img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_04_1">
| 3
6
-1
| 0.29
1.71
-2.31
0.80
| 11,844 |
s559259110 | p00076 | u633068244 | 1393755678 | Python | Python | py | Accepted | 10 | 4464 | 252 | import math
while True:
n = int(raw_input())
if n == -1:
break
r, theta = 1.0, 0.0
for i in range(n-1):
r = math.sqrt(r**2 + 1.0)
theta += math.asin(1.0/r)
print r*math.cos(theta)
print r*math.sin(theta) | p00076 |
<H1>宝探し II</H1>
<p>
蔵を片付けていたら、先祖の宝のありかへの行き方を記した古文書が見つかりました。この古文書にはおおよそ次のような事が書かれていました。
</p>
<pre class=exp>
1. まず、町外れの井戸から、真東に 1m の地点に立ち、まっすぐ井戸の方向を向け。
2. 右回りに 90 度向きを変え、1m 直進したら、まっすぐ井戸の方向を向け。
3. 右回りに 90 度向きを変え、1m 直進したら、まっすぐ井戸の方向を向け。
4. 〃
5. 〃
6. ：
</pre>
<p>
2 行目以降は、全く同じことが書かれていました。あなたは、宝を探そうと思いましたが、厄介なことに気がつきました。昔と違い建物が邪魔をしていて、まっすぐ井戸の方向をむこうにも井戸が見えなかったり 1m 直進しようにも直進できなかったりします。さらに、この古文書ときたら、1000 行近くあり、古文書どおりの作業をすることは、かなりの時間と体力が要ります。しかしながら、幸運なことに、あなたはコンピュータを利用することができます。
</p>
<p>古文書に書かれている行数 <var>n</var> を入力して、宝のありかを出力するプログラムを作成してください。ただし、 <var>n</var> は 2 以上 1,000 以下の正の整数とします。
</p>
<H2>入力</H2>
<p>複数のデータセットが与えられます。各データセットとして、古文書の行数を表す１つの整数 <var>n</var> が１行に与えられます。
</p>
<p>入力は -1 で終わります。データセットの数は 50 を超えません。</p>
<H2>出力</H2>
<p>
町外れの井戸から東に <var>x</var> (m)，北に <var>y</var> (m)の位置に宝があるとして、
各データセットごとに以下の形式で出力して下さい。</p>
<pre>
<var>x</var>
<var>y</var>
</pre>
<p>
出力は実数とし、0.01 以下の誤差を含んでもよい。
</pre>
<H2>Sample Input</H2>
<pre>
3
6
-1
</pre>
<H2>Output for the Sample Input</H2>
<pre>
0.29
1.71
-2.31
0.80
</pre>
<H2>参考</H2>
<p><var>n</var> =2, 3, 4, 5, 6 の宝の位置</p>
<img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_04_1">
| 3
6
-1
| 0.29
1.71
-2.31
0.80
| 11,845 |
s737989939 | p00076 | u912237403 | 1396531870 | Python | Python | py | Accepted | 20 | 4504 | 212 | A=[]
x=1.0
y=0.0
for i in range(1001):
A.append([x,y])
tmp=(x**2+y**2)**.5
dx,dy=-y/tmp,x/tmp
x+=dx
y+=dy
while 1:
n=input()
if n==-1:break
a,b=A[n-1]
print "%.2f\n%.2f"%(a,b) | p00076 |
<H1>宝探し II</H1>
<p>
蔵を片付けていたら、先祖の宝のありかへの行き方を記した古文書が見つかりました。この古文書にはおおよそ次のような事が書かれていました。
</p>
<pre class=exp>
1. まず、町外れの井戸から、真東に 1m の地点に立ち、まっすぐ井戸の方向を向け。
2. 右回りに 90 度向きを変え、1m 直進したら、まっすぐ井戸の方向を向け。
3. 右回りに 90 度向きを変え、1m 直進したら、まっすぐ井戸の方向を向け。
4. 〃
5. 〃
6. ：
</pre>
<p>
2 行目以降は、全く同じことが書かれていました。あなたは、宝を探そうと思いましたが、厄介なことに気がつきました。昔と違い建物が邪魔をしていて、まっすぐ井戸の方向をむこうにも井戸が見えなかったり 1m 直進しようにも直進できなかったりします。さらに、この古文書ときたら、1000 行近くあり、古文書どおりの作業をすることは、かなりの時間と体力が要ります。しかしながら、幸運なことに、あなたはコンピュータを利用することができます。
</p>
<p>古文書に書かれている行数 <var>n</var> を入力して、宝のありかを出力するプログラムを作成してください。ただし、 <var>n</var> は 2 以上 1,000 以下の正の整数とします。
</p>
<H2>入力</H2>
<p>複数のデータセットが与えられます。各データセットとして、古文書の行数を表す１つの整数 <var>n</var> が１行に与えられます。
</p>
<p>入力は -1 で終わります。データセットの数は 50 を超えません。</p>
<H2>出力</H2>
<p>
町外れの井戸から東に <var>x</var> (m)，北に <var>y</var> (m)の位置に宝があるとして、
各データセットごとに以下の形式で出力して下さい。</p>
<pre>
<var>x</var>
<var>y</var>
</pre>
<p>
出力は実数とし、0.01 以下の誤差を含んでもよい。
</pre>
<H2>Sample Input</H2>
<pre>
3
6
-1
</pre>
<H2>Output for the Sample Input</H2>
<pre>
0.29
1.71
-2.31
0.80
</pre>
<H2>参考</H2>
<p><var>n</var> =2, 3, 4, 5, 6 の宝の位置</p>
<img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_04_1">
| 3
6
-1
| 0.29
1.71
-2.31
0.80
| 11,846 |
s746842968 | p00076 | u912237403 | 1396532381 | Python | Python | py | Accepted | 20 | 4448 | 185 | A=[]
x=1.0
y=0.0
for i in range(1,1001):
A.append([x,y])
tmp=i**.5
x,y=x-y/tmp,y+x/tmp
while 1:
n=input()
if n==-1:break
a,b=A[n-1]
print "%.2f\n%.2f"%(a,b) | p00076 |
<H1>宝探し II</H1>
<p>
蔵を片付けていたら、先祖の宝のありかへの行き方を記した古文書が見つかりました。この古文書にはおおよそ次のような事が書かれていました。
</p>
<pre class=exp>
1. まず、町外れの井戸から、真東に 1m の地点に立ち、まっすぐ井戸の方向を向け。
2. 右回りに 90 度向きを変え、1m 直進したら、まっすぐ井戸の方向を向け。
3. 右回りに 90 度向きを変え、1m 直進したら、まっすぐ井戸の方向を向け。
4. 〃
5. 〃
6. ：
</pre>
<p>
2 行目以降は、全く同じことが書かれていました。あなたは、宝を探そうと思いましたが、厄介なことに気がつきました。昔と違い建物が邪魔をしていて、まっすぐ井戸の方向をむこうにも井戸が見えなかったり 1m 直進しようにも直進できなかったりします。さらに、この古文書ときたら、1000 行近くあり、古文書どおりの作業をすることは、かなりの時間と体力が要ります。しかしながら、幸運なことに、あなたはコンピュータを利用することができます。
</p>
<p>古文書に書かれている行数 <var>n</var> を入力して、宝のありかを出力するプログラムを作成してください。ただし、 <var>n</var> は 2 以上 1,000 以下の正の整数とします。
</p>
<H2>入力</H2>
<p>複数のデータセットが与えられます。各データセットとして、古文書の行数を表す１つの整数 <var>n</var> が１行に与えられます。
</p>
<p>入力は -1 で終わります。データセットの数は 50 を超えません。</p>
<H2>出力</H2>
<p>
町外れの井戸から東に <var>x</var> (m)，北に <var>y</var> (m)の位置に宝があるとして、
各データセットごとに以下の形式で出力して下さい。</p>
<pre>
<var>x</var>
<var>y</var>
</pre>
<p>
出力は実数とし、0.01 以下の誤差を含んでもよい。
</pre>
<H2>Sample Input</H2>
<pre>
3
6
-1
</pre>
<H2>Output for the Sample Input</H2>
<pre>
0.29
1.71
-2.31
0.80
</pre>
<H2>参考</H2>
<p><var>n</var> =2, 3, 4, 5, 6 の宝の位置</p>
<img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_04_1">
| 3
6
-1
| 0.29
1.71
-2.31
0.80
| 11,847 |
s821996272 | p00076 | u912237403 | 1396532430 | Python | Python | py | Accepted | 20 | 4448 | 197 | A=[]
x=1.0
y=0.0
for i in range(1,1001):
A.append([x,y])
tmp = i**.5
x, y = x-y/tmp, y+x/tmp
while 1:
n = input()
if n==-1:break
a,b = A[n-1]
print "%.2f\n%.2f" % (a,b) | p00076 |
<H1>宝探し II</H1>
<p>
蔵を片付けていたら、先祖の宝のありかへの行き方を記した古文書が見つかりました。この古文書にはおおよそ次のような事が書かれていました。
</p>
<pre class=exp>
1. まず、町外れの井戸から、真東に 1m の地点に立ち、まっすぐ井戸の方向を向け。
2. 右回りに 90 度向きを変え、1m 直進したら、まっすぐ井戸の方向を向け。
3. 右回りに 90 度向きを変え、1m 直進したら、まっすぐ井戸の方向を向け。
4. 〃
5. 〃
6. ：
</pre>
<p>
2 行目以降は、全く同じことが書かれていました。あなたは、宝を探そうと思いましたが、厄介なことに気がつきました。昔と違い建物が邪魔をしていて、まっすぐ井戸の方向をむこうにも井戸が見えなかったり 1m 直進しようにも直進できなかったりします。さらに、この古文書ときたら、1000 行近くあり、古文書どおりの作業をすることは、かなりの時間と体力が要ります。しかしながら、幸運なことに、あなたはコンピュータを利用することができます。
</p>
<p>古文書に書かれている行数 <var>n</var> を入力して、宝のありかを出力するプログラムを作成してください。ただし、 <var>n</var> は 2 以上 1,000 以下の正の整数とします。
</p>
<H2>入力</H2>
<p>複数のデータセットが与えられます。各データセットとして、古文書の行数を表す１つの整数 <var>n</var> が１行に与えられます。
</p>
<p>入力は -1 で終わります。データセットの数は 50 を超えません。</p>
<H2>出力</H2>
<p>
町外れの井戸から東に <var>x</var> (m)，北に <var>y</var> (m)の位置に宝があるとして、
各データセットごとに以下の形式で出力して下さい。</p>
<pre>
<var>x</var>
<var>y</var>
</pre>
<p>
出力は実数とし、0.01 以下の誤差を含んでもよい。
</pre>
<H2>Sample Input</H2>
<pre>
3
6
-1
</pre>
<H2>Output for the Sample Input</H2>
<pre>
0.29
1.71
-2.31
0.80
</pre>
<H2>参考</H2>
<p><var>n</var> =2, 3, 4, 5, 6 の宝の位置</p>
<img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_04_1">
| 3
6
-1
| 0.29
1.71
-2.31
0.80
| 11,848 |
s523626125 | p00076 | u912237403 | 1396611429 | Python | Python | py | Accepted | 20 | 4440 | 182 | A=[[]]*1001
x=1.0
y=0.0
for i in range(1,1001):
A[i]=[x,y]
tmp=i**.5
x,y=x-y/tmp,y+x/tmp
while 1:
n = input()
if n==-1:break
print A[n][0]
print A[n][1] | p00076 |
<H1>宝探し II</H1>
<p>
蔵を片付けていたら、先祖の宝のありかへの行き方を記した古文書が見つかりました。この古文書にはおおよそ次のような事が書かれていました。
</p>
<pre class=exp>
1. まず、町外れの井戸から、真東に 1m の地点に立ち、まっすぐ井戸の方向を向け。
2. 右回りに 90 度向きを変え、1m 直進したら、まっすぐ井戸の方向を向け。
3. 右回りに 90 度向きを変え、1m 直進したら、まっすぐ井戸の方向を向け。
4. 〃
5. 〃
6. ：
</pre>
<p>
2 行目以降は、全く同じことが書かれていました。あなたは、宝を探そうと思いましたが、厄介なことに気がつきました。昔と違い建物が邪魔をしていて、まっすぐ井戸の方向をむこうにも井戸が見えなかったり 1m 直進しようにも直進できなかったりします。さらに、この古文書ときたら、1000 行近くあり、古文書どおりの作業をすることは、かなりの時間と体力が要ります。しかしながら、幸運なことに、あなたはコンピュータを利用することができます。
</p>
<p>古文書に書かれている行数 <var>n</var> を入力して、宝のありかを出力するプログラムを作成してください。ただし、 <var>n</var> は 2 以上 1,000 以下の正の整数とします。
</p>
<H2>入力</H2>
<p>複数のデータセットが与えられます。各データセットとして、古文書の行数を表す１つの整数 <var>n</var> が１行に与えられます。
</p>
<p>入力は -1 で終わります。データセットの数は 50 を超えません。</p>
<H2>出力</H2>
<p>
町外れの井戸から東に <var>x</var> (m)，北に <var>y</var> (m)の位置に宝があるとして、
各データセットごとに以下の形式で出力して下さい。</p>
<pre>
<var>x</var>
<var>y</var>
</pre>
<p>
出力は実数とし、0.01 以下の誤差を含んでもよい。
</pre>
<H2>Sample Input</H2>
<pre>
3
6
-1
</pre>
<H2>Output for the Sample Input</H2>
<pre>
0.29
1.71
-2.31
0.80
</pre>
<H2>参考</H2>
<p><var>n</var> =2, 3, 4, 5, 6 の宝の位置</p>
<img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_04_1">
| 3
6
-1
| 0.29
1.71
-2.31
0.80
| 11,849 |
s096294964 | p00076 | u912237403 | 1396611678 | Python | Python | py | Accepted | 10 | 4440 | 174 | N=1001
A=[[]]*N
x=1.0
y=0.0
for i in range(1,N):
A[i]=[x,y]
tmp=i**.5
x,y=x-y/tmp,y+x/tmp
while 1:
n = input()
if n==-1:break
a,b=A[n]
print a,b | p00076 |
<H1>宝探し II</H1>
<p>
蔵を片付けていたら、先祖の宝のありかへの行き方を記した古文書が見つかりました。この古文書にはおおよそ次のような事が書かれていました。
</p>
<pre class=exp>
1. まず、町外れの井戸から、真東に 1m の地点に立ち、まっすぐ井戸の方向を向け。
2. 右回りに 90 度向きを変え、1m 直進したら、まっすぐ井戸の方向を向け。
3. 右回りに 90 度向きを変え、1m 直進したら、まっすぐ井戸の方向を向け。
4. 〃
5. 〃
6. ：
</pre>
<p>
2 行目以降は、全く同じことが書かれていました。あなたは、宝を探そうと思いましたが、厄介なことに気がつきました。昔と違い建物が邪魔をしていて、まっすぐ井戸の方向をむこうにも井戸が見えなかったり 1m 直進しようにも直進できなかったりします。さらに、この古文書ときたら、1000 行近くあり、古文書どおりの作業をすることは、かなりの時間と体力が要ります。しかしながら、幸運なことに、あなたはコンピュータを利用することができます。
</p>
<p>古文書に書かれている行数 <var>n</var> を入力して、宝のありかを出力するプログラムを作成してください。ただし、 <var>n</var> は 2 以上 1,000 以下の正の整数とします。
</p>
<H2>入力</H2>
<p>複数のデータセットが与えられます。各データセットとして、古文書の行数を表す１つの整数 <var>n</var> が１行に与えられます。
</p>
<p>入力は -1 で終わります。データセットの数は 50 を超えません。</p>
<H2>出力</H2>
<p>
町外れの井戸から東に <var>x</var> (m)，北に <var>y</var> (m)の位置に宝があるとして、
各データセットごとに以下の形式で出力して下さい。</p>
<pre>
<var>x</var>
<var>y</var>
</pre>
<p>
出力は実数とし、0.01 以下の誤差を含んでもよい。
</pre>
<H2>Sample Input</H2>
<pre>
3
6
-1
</pre>
<H2>Output for the Sample Input</H2>
<pre>
0.29
1.71
-2.31
0.80
</pre>
<H2>参考</H2>
<p><var>n</var> =2, 3, 4, 5, 6 の宝の位置</p>
<img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_04_1">
| 3
6
-1
| 0.29
1.71
-2.31
0.80
| 11,850 |
s062103816 | p00076 | u491763171 | 1400494302 | Python | Python | py | Accepted | 20 | 4496 | 318 | import math
while 1:
n = input()
if n == -1:
break
x, y = 0.0, 0.0
radian = math.radians(-90)
for i in xrange(n):
radian = (radian + math.pi / 2)
x += math.cos(radian)
y += math.sin(radian)
radian = math.atan2(y, x)
print "%.2f" % x
print "%.2f" % y | p00076 |
<H1>宝探し II</H1>
<p>
蔵を片付けていたら、先祖の宝のありかへの行き方を記した古文書が見つかりました。この古文書にはおおよそ次のような事が書かれていました。
</p>
<pre class=exp>
1. まず、町外れの井戸から、真東に 1m の地点に立ち、まっすぐ井戸の方向を向け。
2. 右回りに 90 度向きを変え、1m 直進したら、まっすぐ井戸の方向を向け。
3. 右回りに 90 度向きを変え、1m 直進したら、まっすぐ井戸の方向を向け。
4. 〃
5. 〃
6. ：
</pre>
<p>
2 行目以降は、全く同じことが書かれていました。あなたは、宝を探そうと思いましたが、厄介なことに気がつきました。昔と違い建物が邪魔をしていて、まっすぐ井戸の方向をむこうにも井戸が見えなかったり 1m 直進しようにも直進できなかったりします。さらに、この古文書ときたら、1000 行近くあり、古文書どおりの作業をすることは、かなりの時間と体力が要ります。しかしながら、幸運なことに、あなたはコンピュータを利用することができます。
</p>
<p>古文書に書かれている行数 <var>n</var> を入力して、宝のありかを出力するプログラムを作成してください。ただし、 <var>n</var> は 2 以上 1,000 以下の正の整数とします。
</p>
<H2>入力</H2>
<p>複数のデータセットが与えられます。各データセットとして、古文書の行数を表す１つの整数 <var>n</var> が１行に与えられます。
</p>
<p>入力は -1 で終わります。データセットの数は 50 を超えません。</p>
<H2>出力</H2>
<p>
町外れの井戸から東に <var>x</var> (m)，北に <var>y</var> (m)の位置に宝があるとして、
各データセットごとに以下の形式で出力して下さい。</p>
<pre>
<var>x</var>
<var>y</var>
</pre>
<p>
出力は実数とし、0.01 以下の誤差を含んでもよい。
</pre>
<H2>Sample Input</H2>
<pre>
3
6
-1
</pre>
<H2>Output for the Sample Input</H2>
<pre>
0.29
1.71
-2.31
0.80
</pre>
<H2>参考</H2>
<p><var>n</var> =2, 3, 4, 5, 6 の宝の位置</p>
<img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_04_1">
| 3
6
-1
| 0.29
1.71
-2.31
0.80
| 11,851 |
s199767109 | p00076 | u491763171 | 1400494422 | Python | Python | py | Accepted | 20 | 4496 | 298 | import math
while 1:
n = input()
if n == -1:
break
x, y = 0.0, 0.0
radian = math.radians(-90)
for i in xrange(n):
radian += math.pi / 2
x += math.cos(radian)
y += math.sin(radian)
radian = math.atan2(y, x)
print "%.2f\n%.2f" % (x, y) | p00076 |
<H1>宝探し II</H1>
<p>
蔵を片付けていたら、先祖の宝のありかへの行き方を記した古文書が見つかりました。この古文書にはおおよそ次のような事が書かれていました。
</p>
<pre class=exp>
1. まず、町外れの井戸から、真東に 1m の地点に立ち、まっすぐ井戸の方向を向け。
2. 右回りに 90 度向きを変え、1m 直進したら、まっすぐ井戸の方向を向け。
3. 右回りに 90 度向きを変え、1m 直進したら、まっすぐ井戸の方向を向け。
4. 〃
5. 〃
6. ：
</pre>
<p>
2 行目以降は、全く同じことが書かれていました。あなたは、宝を探そうと思いましたが、厄介なことに気がつきました。昔と違い建物が邪魔をしていて、まっすぐ井戸の方向をむこうにも井戸が見えなかったり 1m 直進しようにも直進できなかったりします。さらに、この古文書ときたら、1000 行近くあり、古文書どおりの作業をすることは、かなりの時間と体力が要ります。しかしながら、幸運なことに、あなたはコンピュータを利用することができます。
</p>
<p>古文書に書かれている行数 <var>n</var> を入力して、宝のありかを出力するプログラムを作成してください。ただし、 <var>n</var> は 2 以上 1,000 以下の正の整数とします。
</p>
<H2>入力</H2>
<p>複数のデータセットが与えられます。各データセットとして、古文書の行数を表す１つの整数 <var>n</var> が１行に与えられます。
</p>
<p>入力は -1 で終わります。データセットの数は 50 を超えません。</p>
<H2>出力</H2>
<p>
町外れの井戸から東に <var>x</var> (m)，北に <var>y</var> (m)の位置に宝があるとして、
各データセットごとに以下の形式で出力して下さい。</p>
<pre>
<var>x</var>
<var>y</var>
</pre>
<p>
出力は実数とし、0.01 以下の誤差を含んでもよい。
</pre>
<H2>Sample Input</H2>
<pre>
3
6
-1
</pre>
<H2>Output for the Sample Input</H2>
<pre>
0.29
1.71
-2.31
0.80
</pre>
<H2>参考</H2>
<p><var>n</var> =2, 3, 4, 5, 6 の宝の位置</p>
<img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_04_1">
| 3
6
-1
| 0.29
1.71
-2.31
0.80
| 11,852 |
s186004252 | p00076 | u187074069 | 1595262384 | Python | Python3 | py | Accepted | 30 | 5664 | 289 | def calc(k, ax, ay):
bx = ax - ay/(k**0.5)
by = ay + ax/(k**0.5)
return(bx, by)
while True:
n = int(input())
if n == -1:
break
ax, ay = 1, 0
for i in range(n-1):
ax, ay = calc(i+1, ax, ay)
print(round(ax, 3))
print(round(ay, 3))
| p00076 |
<H1>宝探し II</H1>
<p>
蔵を片付けていたら、先祖の宝のありかへの行き方を記した古文書が見つかりました。この古文書にはおおよそ次のような事が書かれていました。
</p>
<pre class=exp>
1. まず、町外れの井戸から、真東に 1m の地点に立ち、まっすぐ井戸の方向を向け。
2. 右回りに 90 度向きを変え、1m 直進したら、まっすぐ井戸の方向を向け。
3. 右回りに 90 度向きを変え、1m 直進したら、まっすぐ井戸の方向を向け。
4. 〃
5. 〃
6. ：
</pre>
<p>
2 行目以降は、全く同じことが書かれていました。あなたは、宝を探そうと思いましたが、厄介なことに気がつきました。昔と違い建物が邪魔をしていて、まっすぐ井戸の方向をむこうにも井戸が見えなかったり 1m 直進しようにも直進できなかったりします。さらに、この古文書ときたら、1000 行近くあり、古文書どおりの作業をすることは、かなりの時間と体力が要ります。しかしながら、幸運なことに、あなたはコンピュータを利用することができます。
</p>
<p>古文書に書かれている行数 <var>n</var> を入力して、宝のありかを出力するプログラムを作成してください。ただし、 <var>n</var> は 2 以上 1,000 以下の正の整数とします。
</p>
<H2>入力</H2>
<p>複数のデータセットが与えられます。各データセットとして、古文書の行数を表す１つの整数 <var>n</var> が１行に与えられます。
</p>
<p>入力は -1 で終わります。データセットの数は 50 を超えません。</p>
<H2>出力</H2>
<p>
町外れの井戸から東に <var>x</var> (m)，北に <var>y</var> (m)の位置に宝があるとして、
各データセットごとに以下の形式で出力して下さい。</p>
<pre>
<var>x</var>
<var>y</var>
</pre>
<p>
出力は実数とし、0.01 以下の誤差を含んでもよい。
</pre>
<H2>Sample Input</H2>
<pre>
3
6
-1
</pre>
<H2>Output for the Sample Input</H2>
<pre>
0.29
1.71
-2.31
0.80
</pre>
<H2>参考</H2>
<p><var>n</var> =2, 3, 4, 5, 6 の宝の位置</p>
<img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_04_1">
| 3
6
-1
| 0.29
1.71
-2.31
0.80
| 11,853 |
s115378116 | p00076 | u240091169 | 1591852007 | Python | Python3 | py | Accepted | 30 | 5668 | 306 | import math
while True :
n = int(input())
if n == -1 :
break
x = 1
y = 0
for i in range(n-1) :
a = y / (math.sqrt(x**2 + y**2))
b = x / (math.sqrt(x**2 + y**2))
x = x - a
y = y + b
print('{:.2f}'.format(x))
print('{:.2f}'.format(y))
| p00076 |
<H1>宝探し II</H1>
<p>
蔵を片付けていたら、先祖の宝のありかへの行き方を記した古文書が見つかりました。この古文書にはおおよそ次のような事が書かれていました。
</p>
<pre class=exp>
1. まず、町外れの井戸から、真東に 1m の地点に立ち、まっすぐ井戸の方向を向け。
2. 右回りに 90 度向きを変え、1m 直進したら、まっすぐ井戸の方向を向け。
3. 右回りに 90 度向きを変え、1m 直進したら、まっすぐ井戸の方向を向け。
4. 〃
5. 〃
6. ：
</pre>
<p>
2 行目以降は、全く同じことが書かれていました。あなたは、宝を探そうと思いましたが、厄介なことに気がつきました。昔と違い建物が邪魔をしていて、まっすぐ井戸の方向をむこうにも井戸が見えなかったり 1m 直進しようにも直進できなかったりします。さらに、この古文書ときたら、1000 行近くあり、古文書どおりの作業をすることは、かなりの時間と体力が要ります。しかしながら、幸運なことに、あなたはコンピュータを利用することができます。
</p>
<p>古文書に書かれている行数 <var>n</var> を入力して、宝のありかを出力するプログラムを作成してください。ただし、 <var>n</var> は 2 以上 1,000 以下の正の整数とします。
</p>
<H2>入力</H2>
<p>複数のデータセットが与えられます。各データセットとして、古文書の行数を表す１つの整数 <var>n</var> が１行に与えられます。
</p>
<p>入力は -1 で終わります。データセットの数は 50 を超えません。</p>
<H2>出力</H2>
<p>
町外れの井戸から東に <var>x</var> (m)，北に <var>y</var> (m)の位置に宝があるとして、
各データセットごとに以下の形式で出力して下さい。</p>
<pre>
<var>x</var>
<var>y</var>
</pre>
<p>
出力は実数とし、0.01 以下の誤差を含んでもよい。
</pre>
<H2>Sample Input</H2>
<pre>
3
6
-1
</pre>
<H2>Output for the Sample Input</H2>
<pre>
0.29
1.71
-2.31
0.80
</pre>
<H2>参考</H2>
<p><var>n</var> =2, 3, 4, 5, 6 の宝の位置</p>
<img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_04_1">
| 3
6
-1
| 0.29
1.71
-2.31
0.80
| 11,854 |
s962247099 | p00076 | u286298310 | 1591285422 | Python | Python3 | py | Accepted | 30 | 5700 | 194 |
while True:
n = int(input())
if n == -1:
break
x,y = 1,0
for i in range(1,n):
l = (x**2 + y**2)** -0.5
x,y = x - l*y , y + l*x
print(x)
print(y)
| p00076 |
<H1>宝探し II</H1>
<p>
蔵を片付けていたら、先祖の宝のありかへの行き方を記した古文書が見つかりました。この古文書にはおおよそ次のような事が書かれていました。
</p>
<pre class=exp>
1. まず、町外れの井戸から、真東に 1m の地点に立ち、まっすぐ井戸の方向を向け。
2. 右回りに 90 度向きを変え、1m 直進したら、まっすぐ井戸の方向を向け。
3. 右回りに 90 度向きを変え、1m 直進したら、まっすぐ井戸の方向を向け。
4. 〃
5. 〃
6. ：
</pre>
<p>
2 行目以降は、全く同じことが書かれていました。あなたは、宝を探そうと思いましたが、厄介なことに気がつきました。昔と違い建物が邪魔をしていて、まっすぐ井戸の方向をむこうにも井戸が見えなかったり 1m 直進しようにも直進できなかったりします。さらに、この古文書ときたら、1000 行近くあり、古文書どおりの作業をすることは、かなりの時間と体力が要ります。しかしながら、幸運なことに、あなたはコンピュータを利用することができます。
</p>
<p>古文書に書かれている行数 <var>n</var> を入力して、宝のありかを出力するプログラムを作成してください。ただし、 <var>n</var> は 2 以上 1,000 以下の正の整数とします。
</p>
<H2>入力</H2>
<p>複数のデータセットが与えられます。各データセットとして、古文書の行数を表す１つの整数 <var>n</var> が１行に与えられます。
</p>
<p>入力は -1 で終わります。データセットの数は 50 を超えません。</p>
<H2>出力</H2>
<p>
町外れの井戸から東に <var>x</var> (m)，北に <var>y</var> (m)の位置に宝があるとして、
各データセットごとに以下の形式で出力して下さい。</p>
<pre>
<var>x</var>
<var>y</var>
</pre>
<p>
出力は実数とし、0.01 以下の誤差を含んでもよい。
</pre>
<H2>Sample Input</H2>
<pre>
3
6
-1
</pre>
<H2>Output for the Sample Input</H2>
<pre>
0.29
1.71
-2.31
0.80
</pre>
<H2>参考</H2>
<p><var>n</var> =2, 3, 4, 5, 6 の宝の位置</p>
<img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_04_1">
| 3
6
-1
| 0.29
1.71
-2.31
0.80
| 11,855 |
s930583313 | p00076 | u260980560 | 1590422190 | Python | Python3 | py | Accepted | 20 | 5736 | 374 | import sys
readline = sys.stdin.readline
write = sys.stdout.write
L = 1000
D = [(0, 0), (1, 0)]
x = 1; y = 0
for i in range(L-1):
d = (x**2 + y**2)**.5
x, y = x - y/d, y + x/d
D.append((x, y))
def solve():
N = int(readline())
if N == -1:
return False
x, y = D[N]
write("%.16f\n%.16f\n" % (x, y))
return True
while solve():
...
| p00076 |
<H1>宝探し II</H1>
<p>
蔵を片付けていたら、先祖の宝のありかへの行き方を記した古文書が見つかりました。この古文書にはおおよそ次のような事が書かれていました。
</p>
<pre class=exp>
1. まず、町外れの井戸から、真東に 1m の地点に立ち、まっすぐ井戸の方向を向け。
2. 右回りに 90 度向きを変え、1m 直進したら、まっすぐ井戸の方向を向け。
3. 右回りに 90 度向きを変え、1m 直進したら、まっすぐ井戸の方向を向け。
4. 〃
5. 〃
6. ：
</pre>
<p>
2 行目以降は、全く同じことが書かれていました。あなたは、宝を探そうと思いましたが、厄介なことに気がつきました。昔と違い建物が邪魔をしていて、まっすぐ井戸の方向をむこうにも井戸が見えなかったり 1m 直進しようにも直進できなかったりします。さらに、この古文書ときたら、1000 行近くあり、古文書どおりの作業をすることは、かなりの時間と体力が要ります。しかしながら、幸運なことに、あなたはコンピュータを利用することができます。
</p>
<p>古文書に書かれている行数 <var>n</var> を入力して、宝のありかを出力するプログラムを作成してください。ただし、 <var>n</var> は 2 以上 1,000 以下の正の整数とします。
</p>
<H2>入力</H2>
<p>複数のデータセットが与えられます。各データセットとして、古文書の行数を表す１つの整数 <var>n</var> が１行に与えられます。
</p>
<p>入力は -1 で終わります。データセットの数は 50 を超えません。</p>
<H2>出力</H2>
<p>
町外れの井戸から東に <var>x</var> (m)，北に <var>y</var> (m)の位置に宝があるとして、
各データセットごとに以下の形式で出力して下さい。</p>
<pre>
<var>x</var>
<var>y</var>
</pre>
<p>
出力は実数とし、0.01 以下の誤差を含んでもよい。
</pre>
<H2>Sample Input</H2>
<pre>
3
6
-1
</pre>
<H2>Output for the Sample Input</H2>
<pre>
0.29
1.71
-2.31
0.80
</pre>
<H2>参考</H2>
<p><var>n</var> =2, 3, 4, 5, 6 の宝の位置</p>
<img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_04_1">
| 3
6
-1
| 0.29
1.71
-2.31
0.80
| 11,856 |
s941194795 | p00076 | u803862921 | 1572003143 | Python | Python3 | py | Accepted | 30 | 5732 | 324 |
L = []
L.append((0,0))
L.append((1,0))
x = 1
y = 0
for _ in range(1000):
dy = x /( (x**2 + y**2)**0.5 )
dx = -y/( (x**2 + y**2)**0.5 )
x += dx
y += dy
L.append((x,y))
while True:
k = int(input())
if k < 0:
break
print("{:.2f}".format(L[k][0]))
print("{:.2f}".format(L[k][1]))
| p00076 |
<H1>宝探し II</H1>
<p>
蔵を片付けていたら、先祖の宝のありかへの行き方を記した古文書が見つかりました。この古文書にはおおよそ次のような事が書かれていました。
</p>
<pre class=exp>
1. まず、町外れの井戸から、真東に 1m の地点に立ち、まっすぐ井戸の方向を向け。
2. 右回りに 90 度向きを変え、1m 直進したら、まっすぐ井戸の方向を向け。
3. 右回りに 90 度向きを変え、1m 直進したら、まっすぐ井戸の方向を向け。
4. 〃
5. 〃
6. ：
</pre>
<p>
2 行目以降は、全く同じことが書かれていました。あなたは、宝を探そうと思いましたが、厄介なことに気がつきました。昔と違い建物が邪魔をしていて、まっすぐ井戸の方向をむこうにも井戸が見えなかったり 1m 直進しようにも直進できなかったりします。さらに、この古文書ときたら、1000 行近くあり、古文書どおりの作業をすることは、かなりの時間と体力が要ります。しかしながら、幸運なことに、あなたはコンピュータを利用することができます。
</p>
<p>古文書に書かれている行数 <var>n</var> を入力して、宝のありかを出力するプログラムを作成してください。ただし、 <var>n</var> は 2 以上 1,000 以下の正の整数とします。
</p>
<H2>入力</H2>
<p>複数のデータセットが与えられます。各データセットとして、古文書の行数を表す１つの整数 <var>n</var> が１行に与えられます。
</p>
<p>入力は -1 で終わります。データセットの数は 50 を超えません。</p>
<H2>出力</H2>
<p>
町外れの井戸から東に <var>x</var> (m)，北に <var>y</var> (m)の位置に宝があるとして、
各データセットごとに以下の形式で出力して下さい。</p>
<pre>
<var>x</var>
<var>y</var>
</pre>
<p>
出力は実数とし、0.01 以下の誤差を含んでもよい。
</pre>
<H2>Sample Input</H2>
<pre>
3
6
-1
</pre>
<H2>Output for the Sample Input</H2>
<pre>
0.29
1.71
-2.31
0.80
</pre>
<H2>参考</H2>
<p><var>n</var> =2, 3, 4, 5, 6 の宝の位置</p>
<img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_04_1">
| 3
6
-1
| 0.29
1.71
-2.31
0.80
| 11,857 |
s327518245 | p00076 | u990228206 | 1554280627 | Python | Python3 | py | Accepted | 40 | 7084 | 542 | import math
from decimal import Decimal, ROUND_HALF_UP
def run(n):
if len(pos)>=n:return(pos[n-1])
else:run(n-1)
x,y=pos[-1]
d=math.degrees(math.atan(y/x))
xi=x+math.cos(math.radians(d+[90,270][x<0]))
yi=y+math.sin(math.radians(d+[90,270][x<0]))
pos.append([xi,yi])
pos=[[1.0,0.0],[1.0,1.0]]
while 1:
n=int(input())
if n==-1:break
run(n)
print(Decimal(pos[n-1][0]).quantize(Decimal('0.01'), rounding=ROUND_HALF_UP))
print(Decimal(pos[n-1][1]).quantize(Decimal('0.01'), rounding=ROUND_HALF_UP))
| p00076 |
<H1>宝探し II</H1>
<p>
蔵を片付けていたら、先祖の宝のありかへの行き方を記した古文書が見つかりました。この古文書にはおおよそ次のような事が書かれていました。
</p>
<pre class=exp>
1. まず、町外れの井戸から、真東に 1m の地点に立ち、まっすぐ井戸の方向を向け。
2. 右回りに 90 度向きを変え、1m 直進したら、まっすぐ井戸の方向を向け。
3. 右回りに 90 度向きを変え、1m 直進したら、まっすぐ井戸の方向を向け。
4. 〃
5. 〃
6. ：
</pre>
<p>
2 行目以降は、全く同じことが書かれていました。あなたは、宝を探そうと思いましたが、厄介なことに気がつきました。昔と違い建物が邪魔をしていて、まっすぐ井戸の方向をむこうにも井戸が見えなかったり 1m 直進しようにも直進できなかったりします。さらに、この古文書ときたら、1000 行近くあり、古文書どおりの作業をすることは、かなりの時間と体力が要ります。しかしながら、幸運なことに、あなたはコンピュータを利用することができます。
</p>
<p>古文書に書かれている行数 <var>n</var> を入力して、宝のありかを出力するプログラムを作成してください。ただし、 <var>n</var> は 2 以上 1,000 以下の正の整数とします。
</p>
<H2>入力</H2>
<p>複数のデータセットが与えられます。各データセットとして、古文書の行数を表す１つの整数 <var>n</var> が１行に与えられます。
</p>
<p>入力は -1 で終わります。データセットの数は 50 を超えません。</p>
<H2>出力</H2>
<p>
町外れの井戸から東に <var>x</var> (m)，北に <var>y</var> (m)の位置に宝があるとして、
各データセットごとに以下の形式で出力して下さい。</p>
<pre>
<var>x</var>
<var>y</var>
</pre>
<p>
出力は実数とし、0.01 以下の誤差を含んでもよい。
</pre>
<H2>Sample Input</H2>
<pre>
3
6
-1
</pre>
<H2>Output for the Sample Input</H2>
<pre>
0.29
1.71
-2.31
0.80
</pre>
<H2>参考</H2>
<p><var>n</var> =2, 3, 4, 5, 6 の宝の位置</p>
<img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_04_1">
| 3
6
-1
| 0.29
1.71
-2.31
0.80
| 11,858 |
s360570238 | p00076 | u563075864 | 1544874276 | Python | Python3 | py | Accepted | 30 | 5800 | 317 | from math import pi,cos,sin,atan2
while(1):
n = int(input())
if n == -1:
break
n -= 1
ang = 0.0
x = 1.0
y = 0.0
for i in range(n):
ang += pi/2
x += cos(ang)
y += sin(ang)
ang = atan2(y,x)
print("{:.2f}".format(x))
print("{:.2f}".format(y))
| p00076 |
<H1>宝探し II</H1>
<p>
蔵を片付けていたら、先祖の宝のありかへの行き方を記した古文書が見つかりました。この古文書にはおおよそ次のような事が書かれていました。
</p>
<pre class=exp>
1. まず、町外れの井戸から、真東に 1m の地点に立ち、まっすぐ井戸の方向を向け。
2. 右回りに 90 度向きを変え、1m 直進したら、まっすぐ井戸の方向を向け。
3. 右回りに 90 度向きを変え、1m 直進したら、まっすぐ井戸の方向を向け。
4. 〃
5. 〃
6. ：
</pre>
<p>
2 行目以降は、全く同じことが書かれていました。あなたは、宝を探そうと思いましたが、厄介なことに気がつきました。昔と違い建物が邪魔をしていて、まっすぐ井戸の方向をむこうにも井戸が見えなかったり 1m 直進しようにも直進できなかったりします。さらに、この古文書ときたら、1000 行近くあり、古文書どおりの作業をすることは、かなりの時間と体力が要ります。しかしながら、幸運なことに、あなたはコンピュータを利用することができます。
</p>
<p>古文書に書かれている行数 <var>n</var> を入力して、宝のありかを出力するプログラムを作成してください。ただし、 <var>n</var> は 2 以上 1,000 以下の正の整数とします。
</p>
<H2>入力</H2>
<p>複数のデータセットが与えられます。各データセットとして、古文書の行数を表す１つの整数 <var>n</var> が１行に与えられます。
</p>
<p>入力は -1 で終わります。データセットの数は 50 を超えません。</p>
<H2>出力</H2>
<p>
町外れの井戸から東に <var>x</var> (m)，北に <var>y</var> (m)の位置に宝があるとして、
各データセットごとに以下の形式で出力して下さい。</p>
<pre>
<var>x</var>
<var>y</var>
</pre>
<p>
出力は実数とし、0.01 以下の誤差を含んでもよい。
</pre>
<H2>Sample Input</H2>
<pre>
3
6
-1
</pre>
<H2>Output for the Sample Input</H2>
<pre>
0.29
1.71
-2.31
0.80
</pre>
<H2>参考</H2>
<p><var>n</var> =2, 3, 4, 5, 6 の宝の位置</p>
<img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_04_1">
| 3
6
-1
| 0.29
1.71
-2.31
0.80
| 11,859 |
s444853761 | p00077 | u932203900 | 1531932330 | Python | Python3 | py | Accepted | 20 | 5612 | 325 | import sys
for line in sys.stdin:
appendStrs = []
line = line.strip()
for i in range(0, len(line) ) :
if line[i] == "@" :
appendStrs.append((line[i:i+3], "".join([ line[i+2] for _ in range(0, int(line[i+1]) )]))) ;
for a in appendStrs :
line = line.replace(*a, 1)
print(line)
| p00077 |
<H1>ランレングス</H1>
<p>
文字列が連続した場合、ある規則で文字を置き換え文字列を短くすることができます。たとえば、AAAA という文字列の場合、@4A と表現すれば 1 文字分圧縮されます。この規則で圧縮された文字列を入力してもとの文字列に復元するプログラムを作成してください。ただし、復元した文字列に＠文字は出現しないものとします。
</p>
<p>
また、原文の文字列は英大文字、英小文字、数字、記号であり 100 文字以内、連続する文字は 9 文字以内です。
</p>
<H2>入力</H2>
<p>複数の文字列が与えられます。１行に１つの文字列が与えられます。文字列の数は 50 を超えません。</p>
<H2>出力</H2>
<p>文字列ごとに、各文字に対して復元した文字列を１行に出力して下さい。
</p>
<H2>Sample Input</H2>
<pre>
ab@5C1@8050
@99+1=1@90
</pre>
<H2>Output for the Sample Input</H2>
<pre>
abCCCCC10000000050
999999999+1=1000000000
</pre>
| ab@5C1@8050
@99+1=1@90
| abCCCCC10000000050
999999999+1=1000000000
| 11,860 |
s961638276 | p00077 | u197615397 | 1532087148 | Python | Python3 | py | Accepted | 30 | 6532 | 122 | import re
import sys
for s in sys.stdin:
print(re.sub(r"@(\d)(.)", lambda m: m.group(2)*int(m.group(1)), s.rstrip()))
| p00077 |
<H1>ランレングス</H1>
<p>
文字列が連続した場合、ある規則で文字を置き換え文字列を短くすることができます。たとえば、AAAA という文字列の場合、@4A と表現すれば 1 文字分圧縮されます。この規則で圧縮された文字列を入力してもとの文字列に復元するプログラムを作成してください。ただし、復元した文字列に＠文字は出現しないものとします。
</p>
<p>
また、原文の文字列は英大文字、英小文字、数字、記号であり 100 文字以内、連続する文字は 9 文字以内です。
</p>
<H2>入力</H2>
<p>複数の文字列が与えられます。１行に１つの文字列が与えられます。文字列の数は 50 を超えません。</p>
<H2>出力</H2>
<p>文字列ごとに、各文字に対して復元した文字列を１行に出力して下さい。
</p>
<H2>Sample Input</H2>
<pre>
ab@5C1@8050
@99+1=1@90
</pre>
<H2>Output for the Sample Input</H2>
<pre>
abCCCCC10000000050
999999999+1=1000000000
</pre>
| ab@5C1@8050
@99+1=1@90
| abCCCCC10000000050
999999999+1=1000000000
| 11,861 |
s899961927 | p00077 | u506132575 | 1417586495 | Python | Python | py | Accepted | 10 | 4196 | 262 | import sys
for s in sys.stdin:
out = ""
i = 0
while True:
if i > len(s)-2 :
break
if s[i] == "@":
out += s[i+2]*int(s[i+1])
i += 2
else:
out += s[i]
i += 1
print out | p00077 |
<H1>ランレングス</H1>
<p>
文字列が連続した場合、ある規則で文字を置き換え文字列を短くすることができます。たとえば、AAAA という文字列の場合、@4A と表現すれば 1 文字分圧縮されます。この規則で圧縮された文字列を入力してもとの文字列に復元するプログラムを作成してください。ただし、復元した文字列に＠文字は出現しないものとします。
</p>
<p>
また、原文の文字列は英大文字、英小文字、数字、記号であり 100 文字以内、連続する文字は 9 文字以内です。
</p>
<H2>入力</H2>
<p>複数の文字列が与えられます。１行に１つの文字列が与えられます。文字列の数は 50 を超えません。</p>
<H2>出力</H2>
<p>文字列ごとに、各文字に対して復元した文字列を１行に出力して下さい。
</p>
<H2>Sample Input</H2>
<pre>
ab@5C1@8050
@99+1=1@90
</pre>
<H2>Output for the Sample Input</H2>
<pre>
abCCCCC10000000050
999999999+1=1000000000
</pre>
| ab@5C1@8050
@99+1=1@90
| abCCCCC10000000050
999999999+1=1000000000
| 11,862 |
s884475587 | p00077 | u846356981 | 1418954407 | Python | Python3 | py | Accepted | 30 | 6720 | 200 | import sys
def method(l):
idx = l.find('@')
return l if idx < 0 else method(l.replace(l[idx:idx+3], l[idx+2]*int(l[idx+1])))
for line in sys.stdin:
print(method(line.replace('\n', ''))) | p00077 |
<H1>ランレングス</H1>
<p>
文字列が連続した場合、ある規則で文字を置き換え文字列を短くすることができます。たとえば、AAAA という文字列の場合、@4A と表現すれば 1 文字分圧縮されます。この規則で圧縮された文字列を入力してもとの文字列に復元するプログラムを作成してください。ただし、復元した文字列に＠文字は出現しないものとします。
</p>
<p>
また、原文の文字列は英大文字、英小文字、数字、記号であり 100 文字以内、連続する文字は 9 文字以内です。
</p>
<H2>入力</H2>
<p>複数の文字列が与えられます。１行に１つの文字列が与えられます。文字列の数は 50 を超えません。</p>
<H2>出力</H2>
<p>文字列ごとに、各文字に対して復元した文字列を１行に出力して下さい。
</p>
<H2>Sample Input</H2>
<pre>
ab@5C1@8050
@99+1=1@90
</pre>
<H2>Output for the Sample Input</H2>
<pre>
abCCCCC10000000050
999999999+1=1000000000
</pre>
| ab@5C1@8050
@99+1=1@90
| abCCCCC10000000050
999999999+1=1000000000
| 11,863 |
s564180832 | p00077 | u567380442 | 1423101976 | Python | Python3 | py | Accepted | 30 | 6724 | 264 | import sys
f = sys.stdin
for line in f:
line = line.strip()
index = line.find('@')
while index != -1:
target = line[index:index + 3]
line = line.replace(target, target[2] * int(target[1]))
index = line.find('@')
print(line) | p00077 |
<H1>ランレングス</H1>
<p>
文字列が連続した場合、ある規則で文字を置き換え文字列を短くすることができます。たとえば、AAAA という文字列の場合、@4A と表現すれば 1 文字分圧縮されます。この規則で圧縮された文字列を入力してもとの文字列に復元するプログラムを作成してください。ただし、復元した文字列に＠文字は出現しないものとします。
</p>
<p>
また、原文の文字列は英大文字、英小文字、数字、記号であり 100 文字以内、連続する文字は 9 文字以内です。
</p>
<H2>入力</H2>
<p>複数の文字列が与えられます。１行に１つの文字列が与えられます。文字列の数は 50 を超えません。</p>
<H2>出力</H2>
<p>文字列ごとに、各文字に対して復元した文字列を１行に出力して下さい。
</p>
<H2>Sample Input</H2>
<pre>
ab@5C1@8050
@99+1=1@90
</pre>
<H2>Output for the Sample Input</H2>
<pre>
abCCCCC10000000050
999999999+1=1000000000
</pre>
| ab@5C1@8050
@99+1=1@90
| abCCCCC10000000050
999999999+1=1000000000
| 11,864 |
s518908317 | p00077 | u540744789 | 1427261330 | Python | Python | py | Accepted | 20 | 4204 | 367 | while True:
try:
data=raw_input()
original=''
i=0
while True:
if data[i]=='@':
original+=int(data[i+1])*data[i+2]
i+=2
else:
original+=data[i]
i+=1
if len(data)<=i:
break
print original
except:
break | p00077 |
<H1>ランレングス</H1>
<p>
文字列が連続した場合、ある規則で文字を置き換え文字列を短くすることができます。たとえば、AAAA という文字列の場合、@4A と表現すれば 1 文字分圧縮されます。この規則で圧縮された文字列を入力してもとの文字列に復元するプログラムを作成してください。ただし、復元した文字列に＠文字は出現しないものとします。
</p>
<p>
また、原文の文字列は英大文字、英小文字、数字、記号であり 100 文字以内、連続する文字は 9 文字以内です。
</p>
<H2>入力</H2>
<p>複数の文字列が与えられます。１行に１つの文字列が与えられます。文字列の数は 50 を超えません。</p>
<H2>出力</H2>
<p>文字列ごとに、各文字に対して復元した文字列を１行に出力して下さい。
</p>
<H2>Sample Input</H2>
<pre>
ab@5C1@8050
@99+1=1@90
</pre>
<H2>Output for the Sample Input</H2>
<pre>
abCCCCC10000000050
999999999+1=1000000000
</pre>
| ab@5C1@8050
@99+1=1@90
| abCCCCC10000000050
999999999+1=1000000000
| 11,865 |
s493942519 | p00077 | u879226672 | 1428228568 | Python | Python | py | Accepted | 10 | 4208 | 362 | while True:
try:
s = raw_input()
except EOFError:
break
i=0
hirabun = ''
while i <len(s):
if s[i] != '@':
hirabun += s[i]
i += 1
elif s[i] == '@' and i+2 < len(s):
hira_part = s[i+2]*int(s[i+1])
hirabun += hira_part
i += 3
print hirabun | p00077 |
<H1>ランレングス</H1>
<p>
文字列が連続した場合、ある規則で文字を置き換え文字列を短くすることができます。たとえば、AAAA という文字列の場合、@4A と表現すれば 1 文字分圧縮されます。この規則で圧縮された文字列を入力してもとの文字列に復元するプログラムを作成してください。ただし、復元した文字列に＠文字は出現しないものとします。
</p>
<p>
また、原文の文字列は英大文字、英小文字、数字、記号であり 100 文字以内、連続する文字は 9 文字以内です。
</p>
<H2>入力</H2>
<p>複数の文字列が与えられます。１行に１つの文字列が与えられます。文字列の数は 50 を超えません。</p>
<H2>出力</H2>
<p>文字列ごとに、各文字に対して復元した文字列を１行に出力して下さい。
</p>
<H2>Sample Input</H2>
<pre>
ab@5C1@8050
@99+1=1@90
</pre>
<H2>Output for the Sample Input</H2>
<pre>
abCCCCC10000000050
999999999+1=1000000000
</pre>
| ab@5C1@8050
@99+1=1@90
| abCCCCC10000000050
999999999+1=1000000000
| 11,866 |
s840946160 | p00077 | u461370825 | 1449761701 | Python | Python | py | Accepted | 10 | 6344 | 415 | from math import *
PI = 3.1415926535898
while True:
try:
s = raw_input()
i = 0
ans = ""
while i < len(s):
if s[i] == '@':
d = int(s[i+1])
for x in range(d):
ans += s[i+2]
i += 3
else:
ans += s[i]
i += 1
print ans
except EOFError:
break | p00077 |
<H1>ランレングス</H1>
<p>
文字列が連続した場合、ある規則で文字を置き換え文字列を短くすることができます。たとえば、AAAA という文字列の場合、@4A と表現すれば 1 文字分圧縮されます。この規則で圧縮された文字列を入力してもとの文字列に復元するプログラムを作成してください。ただし、復元した文字列に＠文字は出現しないものとします。
</p>
<p>
また、原文の文字列は英大文字、英小文字、数字、記号であり 100 文字以内、連続する文字は 9 文字以内です。
</p>
<H2>入力</H2>
<p>複数の文字列が与えられます。１行に１つの文字列が与えられます。文字列の数は 50 を超えません。</p>
<H2>出力</H2>
<p>文字列ごとに、各文字に対して復元した文字列を１行に出力して下さい。
</p>
<H2>Sample Input</H2>
<pre>
ab@5C1@8050
@99+1=1@90
</pre>
<H2>Output for the Sample Input</H2>
<pre>
abCCCCC10000000050
999999999+1=1000000000
</pre>
| ab@5C1@8050
@99+1=1@90
| abCCCCC10000000050
999999999+1=1000000000
| 11,867 |
s788865266 | p00077 | u140201022 | 1451307923 | Python | Python | py | Accepted | 10 | 6284 | 380 | while 1:
try:
n=raw_input()
ans=''
f=t=0
for i in n:
if i!='@' and f==0:
ans+=i
elif i=='@':
f=1
elif f==1 and t==0:
t=int(i)
else:
ans+=i*t
f=0
t=0
print ans
except:
break
exit() | p00077 |
<H1>ランレングス</H1>
<p>
文字列が連続した場合、ある規則で文字を置き換え文字列を短くすることができます。たとえば、AAAA という文字列の場合、@4A と表現すれば 1 文字分圧縮されます。この規則で圧縮された文字列を入力してもとの文字列に復元するプログラムを作成してください。ただし、復元した文字列に＠文字は出現しないものとします。
</p>
<p>
また、原文の文字列は英大文字、英小文字、数字、記号であり 100 文字以内、連続する文字は 9 文字以内です。
</p>
<H2>入力</H2>
<p>複数の文字列が与えられます。１行に１つの文字列が与えられます。文字列の数は 50 を超えません。</p>
<H2>出力</H2>
<p>文字列ごとに、各文字に対して復元した文字列を１行に出力して下さい。
</p>
<H2>Sample Input</H2>
<pre>
ab@5C1@8050
@99+1=1@90
</pre>
<H2>Output for the Sample Input</H2>
<pre>
abCCCCC10000000050
999999999+1=1000000000
</pre>
| ab@5C1@8050
@99+1=1@90
| abCCCCC10000000050
999999999+1=1000000000
| 11,868 |
s668696936 | p00077 | u442166898 | 1454575395 | Python | Python | py | Accepted | 10 | 6440 | 507 | import sys
if __name__=="__main__":
while True:
try:
st=raw_input()
ans=[]
for i,e in enumerate(st):
if e=='@':
for j in range(1,int(st[i+1])):
ans.append(st[i+2])
else :
if st[i-1]!='@':
ans.append(e)
for e in ans:
sys.stdout.write(e)
print ""
except EOFError: break
| p00077 |
<H1>ランレングス</H1>
<p>
文字列が連続した場合、ある規則で文字を置き換え文字列を短くすることができます。たとえば、AAAA という文字列の場合、@4A と表現すれば 1 文字分圧縮されます。この規則で圧縮された文字列を入力してもとの文字列に復元するプログラムを作成してください。ただし、復元した文字列に＠文字は出現しないものとします。
</p>
<p>
また、原文の文字列は英大文字、英小文字、数字、記号であり 100 文字以内、連続する文字は 9 文字以内です。
</p>
<H2>入力</H2>
<p>複数の文字列が与えられます。１行に１つの文字列が与えられます。文字列の数は 50 を超えません。</p>
<H2>出力</H2>
<p>文字列ごとに、各文字に対して復元した文字列を１行に出力して下さい。
</p>
<H2>Sample Input</H2>
<pre>
ab@5C1@8050
@99+1=1@90
</pre>
<H2>Output for the Sample Input</H2>
<pre>
abCCCCC10000000050
999999999+1=1000000000
</pre>
| ab@5C1@8050
@99+1=1@90
| abCCCCC10000000050
999999999+1=1000000000
| 11,869 |
s980554386 | p00077 | u075836834 | 1458415974 | Python | Python3 | py | Accepted | 30 | 7592 | 295 | while True:
try:
line=list(map(str,input()))
string=""
for i in range(len(line)):
if (line[i]!='@' and line[i-1]!='@' and line[i-2]!='@'):
string+=line[i]
elif line[i]=='@':
string+=line[i+2]*int(line[i+1])
else:
pass
print(string)
except EOFError:
break
| p00077 |
<H1>ランレングス</H1>
<p>
文字列が連続した場合、ある規則で文字を置き換え文字列を短くすることができます。たとえば、AAAA という文字列の場合、@4A と表現すれば 1 文字分圧縮されます。この規則で圧縮された文字列を入力してもとの文字列に復元するプログラムを作成してください。ただし、復元した文字列に＠文字は出現しないものとします。
</p>
<p>
また、原文の文字列は英大文字、英小文字、数字、記号であり 100 文字以内、連続する文字は 9 文字以内です。
</p>
<H2>入力</H2>
<p>複数の文字列が与えられます。１行に１つの文字列が与えられます。文字列の数は 50 を超えません。</p>
<H2>出力</H2>
<p>文字列ごとに、各文字に対して復元した文字列を１行に出力して下さい。
</p>
<H2>Sample Input</H2>
<pre>
ab@5C1@8050
@99+1=1@90
</pre>
<H2>Output for the Sample Input</H2>
<pre>
abCCCCC10000000050
999999999+1=1000000000
</pre>
| ab@5C1@8050
@99+1=1@90
| abCCCCC10000000050
999999999+1=1000000000
| 11,870 |
s618011569 | p00077 | u894114233 | 1476603890 | Python | Python | py | Accepted | 10 | 6444 | 309 | while 1:
try:
s=raw_input()
n=len(s)
ns=""
i=0
while i<=n-1:
if s[i]=="@" and i!=n-2:
ns+=int(s[i+1])*s[i+2]
i+=3
else:
ns+=s[i]
i+=1
print(ns)
except:
break | p00077 |
<H1>ランレングス</H1>
<p>
文字列が連続した場合、ある規則で文字を置き換え文字列を短くすることができます。たとえば、AAAA という文字列の場合、@4A と表現すれば 1 文字分圧縮されます。この規則で圧縮された文字列を入力してもとの文字列に復元するプログラムを作成してください。ただし、復元した文字列に＠文字は出現しないものとします。
</p>
<p>
また、原文の文字列は英大文字、英小文字、数字、記号であり 100 文字以内、連続する文字は 9 文字以内です。
</p>
<H2>入力</H2>
<p>複数の文字列が与えられます。１行に１つの文字列が与えられます。文字列の数は 50 を超えません。</p>
<H2>出力</H2>
<p>文字列ごとに、各文字に対して復元した文字列を１行に出力して下さい。
</p>
<H2>Sample Input</H2>
<pre>
ab@5C1@8050
@99+1=1@90
</pre>
<H2>Output for the Sample Input</H2>
<pre>
abCCCCC10000000050
999999999+1=1000000000
</pre>
| ab@5C1@8050
@99+1=1@90
| abCCCCC10000000050
999999999+1=1000000000
| 11,871 |
s155638675 | p00077 | u301729341 | 1482488975 | Python | Python3 | py | Accepted | 20 | 7528 | 431 | while True:
try:
cha = input()
cha = list(cha)
ans = ""
i = 0
while i < len(cha):
if cha[i] == "@":
n = int(cha[i + 1])
moji = cha[i + 2]
for j in range(n):
ans += moji
i += 3
else:
ans += cha[i]
i += 1
print(ans)
except:
break | p00077 |
<H1>ランレングス</H1>
<p>
文字列が連続した場合、ある規則で文字を置き換え文字列を短くすることができます。たとえば、AAAA という文字列の場合、@4A と表現すれば 1 文字分圧縮されます。この規則で圧縮された文字列を入力してもとの文字列に復元するプログラムを作成してください。ただし、復元した文字列に＠文字は出現しないものとします。
</p>
<p>
また、原文の文字列は英大文字、英小文字、数字、記号であり 100 文字以内、連続する文字は 9 文字以内です。
</p>
<H2>入力</H2>
<p>複数の文字列が与えられます。１行に１つの文字列が与えられます。文字列の数は 50 を超えません。</p>
<H2>出力</H2>
<p>文字列ごとに、各文字に対して復元した文字列を１行に出力して下さい。
</p>
<H2>Sample Input</H2>
<pre>
ab@5C1@8050
@99+1=1@90
</pre>
<H2>Output for the Sample Input</H2>
<pre>
abCCCCC10000000050
999999999+1=1000000000
</pre>
| ab@5C1@8050
@99+1=1@90
| abCCCCC10000000050
999999999+1=1000000000
| 11,872 |
s171814428 | p00077 | u546285759 | 1482753216 | Python | Python3 | py | Accepted | 20 | 7596 | 307 | import sys
for line in sys.stdin:
line = line.strip()
i = 0
ans = ""
while i < len(line):
if line[i] == "@":
m = int(line[i+1])
c = line[i+2]
i += 3
ans += m*c
else:
ans += line[i]
i += 1
print(ans) | p00077 |
<H1>ランレングス</H1>
<p>
文字列が連続した場合、ある規則で文字を置き換え文字列を短くすることができます。たとえば、AAAA という文字列の場合、@4A と表現すれば 1 文字分圧縮されます。この規則で圧縮された文字列を入力してもとの文字列に復元するプログラムを作成してください。ただし、復元した文字列に＠文字は出現しないものとします。
</p>
<p>
また、原文の文字列は英大文字、英小文字、数字、記号であり 100 文字以内、連続する文字は 9 文字以内です。
</p>
<H2>入力</H2>
<p>複数の文字列が与えられます。１行に１つの文字列が与えられます。文字列の数は 50 を超えません。</p>
<H2>出力</H2>
<p>文字列ごとに、各文字に対して復元した文字列を１行に出力して下さい。
</p>
<H2>Sample Input</H2>
<pre>
ab@5C1@8050
@99+1=1@90
</pre>
<H2>Output for the Sample Input</H2>
<pre>
abCCCCC10000000050
999999999+1=1000000000
</pre>
| ab@5C1@8050
@99+1=1@90
| abCCCCC10000000050
999999999+1=1000000000
| 11,873 |
s817845396 | p00077 | u078042885 | 1484123422 | Python | Python3 | py | Accepted | 30 | 7676 | 188 | while 1:
try:s=input()
except:break
i,a,n=0,'',1
for i in s:
if n==0:n=int(i)
elif i=='@': n=0
else:
a+=i*n
n=1
print(a) | p00077 |
<H1>ランレングス</H1>
<p>
文字列が連続した場合、ある規則で文字を置き換え文字列を短くすることができます。たとえば、AAAA という文字列の場合、@4A と表現すれば 1 文字分圧縮されます。この規則で圧縮された文字列を入力してもとの文字列に復元するプログラムを作成してください。ただし、復元した文字列に＠文字は出現しないものとします。
</p>
<p>
また、原文の文字列は英大文字、英小文字、数字、記号であり 100 文字以内、連続する文字は 9 文字以内です。
</p>
<H2>入力</H2>
<p>複数の文字列が与えられます。１行に１つの文字列が与えられます。文字列の数は 50 を超えません。</p>
<H2>出力</H2>
<p>文字列ごとに、各文字に対して復元した文字列を１行に出力して下さい。
</p>
<H2>Sample Input</H2>
<pre>
ab@5C1@8050
@99+1=1@90
</pre>
<H2>Output for the Sample Input</H2>
<pre>
abCCCCC10000000050
999999999+1=1000000000
</pre>
| ab@5C1@8050
@99+1=1@90
| abCCCCC10000000050
999999999+1=1000000000
| 11,874 |
s308951516 | p00077 | u032662562 | 1489044414 | Python | Python3 | py | Accepted | 20 | 7616 | 224 | def aux(s):
return(s[1]*int(s[0]) + s[2:])
while True:
try:
s = input().strip()
v = s.split('@')
t = v[0]
for i in (map(lambda x:aux(x), v[1:])):
t += i
print(t)
except EOFError:
break | p00077 |
<H1>ランレングス</H1>
<p>
文字列が連続した場合、ある規則で文字を置き換え文字列を短くすることができます。たとえば、AAAA という文字列の場合、@4A と表現すれば 1 文字分圧縮されます。この規則で圧縮された文字列を入力してもとの文字列に復元するプログラムを作成してください。ただし、復元した文字列に＠文字は出現しないものとします。
</p>
<p>
また、原文の文字列は英大文字、英小文字、数字、記号であり 100 文字以内、連続する文字は 9 文字以内です。
</p>
<H2>入力</H2>
<p>複数の文字列が与えられます。１行に１つの文字列が与えられます。文字列の数は 50 を超えません。</p>
<H2>出力</H2>
<p>文字列ごとに、各文字に対して復元した文字列を１行に出力して下さい。
</p>
<H2>Sample Input</H2>
<pre>
ab@5C1@8050
@99+1=1@90
</pre>
<H2>Output for the Sample Input</H2>
<pre>
abCCCCC10000000050
999999999+1=1000000000
</pre>
| ab@5C1@8050
@99+1=1@90
| abCCCCC10000000050
999999999+1=1000000000
| 11,875 |
s329078409 | p00077 | u964040941 | 1490811202 | Python | Python3 | py | Accepted | 20 | 7664 | 283 | while True:
try:
S = input()
except EOFError:
break
ans = ''
i = 0
while i < len(S):
if S [i] == '@':
ans += S [i + 2] * int(S [i + 1])
i += 3
else:
ans += S [i]
i += 1
print(ans) | p00077 |
<H1>ランレングス</H1>
<p>
文字列が連続した場合、ある規則で文字を置き換え文字列を短くすることができます。たとえば、AAAA という文字列の場合、@4A と表現すれば 1 文字分圧縮されます。この規則で圧縮された文字列を入力してもとの文字列に復元するプログラムを作成してください。ただし、復元した文字列に＠文字は出現しないものとします。
</p>
<p>
また、原文の文字列は英大文字、英小文字、数字、記号であり 100 文字以内、連続する文字は 9 文字以内です。
</p>
<H2>入力</H2>
<p>複数の文字列が与えられます。１行に１つの文字列が与えられます。文字列の数は 50 を超えません。</p>
<H2>出力</H2>
<p>文字列ごとに、各文字に対して復元した文字列を１行に出力して下さい。
</p>
<H2>Sample Input</H2>
<pre>
ab@5C1@8050
@99+1=1@90
</pre>
<H2>Output for the Sample Input</H2>
<pre>
abCCCCC10000000050
999999999+1=1000000000
</pre>
| ab@5C1@8050
@99+1=1@90
| abCCCCC10000000050
999999999+1=1000000000
| 11,876 |
s976861179 | p00077 | u462831976 | 1493348117 | Python | Python3 | py | Accepted | 20 | 7564 | 369 | # -*- coding: utf-8 -*-
import sys
import os
import math
for s in sys.stdin:
s = s.strip()
answer = []
i = 0
while i < len(s):
if s[i] == '@':
num = int(s[i+1])
c = s[i+2]
answer.append(c * num)
i += 3
else:
answer.append(s[i])
i += 1
print(''.join(answer)) | p00077 |
<H1>ランレングス</H1>
<p>
文字列が連続した場合、ある規則で文字を置き換え文字列を短くすることができます。たとえば、AAAA という文字列の場合、@4A と表現すれば 1 文字分圧縮されます。この規則で圧縮された文字列を入力してもとの文字列に復元するプログラムを作成してください。ただし、復元した文字列に＠文字は出現しないものとします。
</p>
<p>
また、原文の文字列は英大文字、英小文字、数字、記号であり 100 文字以内、連続する文字は 9 文字以内です。
</p>
<H2>入力</H2>
<p>複数の文字列が与えられます。１行に１つの文字列が与えられます。文字列の数は 50 を超えません。</p>
<H2>出力</H2>
<p>文字列ごとに、各文字に対して復元した文字列を１行に出力して下さい。
</p>
<H2>Sample Input</H2>
<pre>
ab@5C1@8050
@99+1=1@90
</pre>
<H2>Output for the Sample Input</H2>
<pre>
abCCCCC10000000050
999999999+1=1000000000
</pre>
| ab@5C1@8050
@99+1=1@90
| abCCCCC10000000050
999999999+1=1000000000
| 11,877 |
s404050879 | p00077 | u972901560 | 1499160339 | Python | Python3 | py | Accepted | 20 | 7672 | 401 | while 1:
res = ""
check = []
try:
s = input()
for i in range(len(s)):
if i in check:
continue
elif s[i] == "@":
res = res + s[i+2] * int(s[i+1])
check.append(i+1)
check.append(i+2)
else:
res = res + s[i]
print(res)
except EOFError:
break | p00077 |
<H1>ランレングス</H1>
<p>
文字列が連続した場合、ある規則で文字を置き換え文字列を短くすることができます。たとえば、AAAA という文字列の場合、@4A と表現すれば 1 文字分圧縮されます。この規則で圧縮された文字列を入力してもとの文字列に復元するプログラムを作成してください。ただし、復元した文字列に＠文字は出現しないものとします。
</p>
<p>
また、原文の文字列は英大文字、英小文字、数字、記号であり 100 文字以内、連続する文字は 9 文字以内です。
</p>
<H2>入力</H2>
<p>複数の文字列が与えられます。１行に１つの文字列が与えられます。文字列の数は 50 を超えません。</p>
<H2>出力</H2>
<p>文字列ごとに、各文字に対して復元した文字列を１行に出力して下さい。
</p>
<H2>Sample Input</H2>
<pre>
ab@5C1@8050
@99+1=1@90
</pre>
<H2>Output for the Sample Input</H2>
<pre>
abCCCCC10000000050
999999999+1=1000000000
</pre>
| ab@5C1@8050
@99+1=1@90
| abCCCCC10000000050
999999999+1=1000000000
| 11,878 |
s149482571 | p00077 | u811733736 | 1503313899 | Python | Python3 | py | Accepted | 20 | 7596 | 667 | # -*- coding: utf-8 -*-
"""
http://judge.u-aizu.ac.jp/onlinejudge/description.jsp?id=0077
"""
import sys
def expand(data):
result = []
skip_count = 0
for i in range(len(data)):
if skip_count:
skip_count -= 1
else:
if data[i] == '@':
skip_count = 2
num = int(data[i+1])
c = data[i+2]
result.append(c*num)
else:
result.append(data[i])
return (''.join(result))
def main(args):
for line in sys.stdin:
result = expand(line.strip())
print(result)
if __name__ == '__main__':
main(sys.argv[1:]) | p00077 |
<H1>ランレングス</H1>
<p>
文字列が連続した場合、ある規則で文字を置き換え文字列を短くすることができます。たとえば、AAAA という文字列の場合、@4A と表現すれば 1 文字分圧縮されます。この規則で圧縮された文字列を入力してもとの文字列に復元するプログラムを作成してください。ただし、復元した文字列に＠文字は出現しないものとします。
</p>
<p>
また、原文の文字列は英大文字、英小文字、数字、記号であり 100 文字以内、連続する文字は 9 文字以内です。
</p>
<H2>入力</H2>
<p>複数の文字列が与えられます。１行に１つの文字列が与えられます。文字列の数は 50 を超えません。</p>
<H2>出力</H2>
<p>文字列ごとに、各文字に対して復元した文字列を１行に出力して下さい。
</p>
<H2>Sample Input</H2>
<pre>
ab@5C1@8050
@99+1=1@90
</pre>
<H2>Output for the Sample Input</H2>
<pre>
abCCCCC10000000050
999999999+1=1000000000
</pre>
| ab@5C1@8050
@99+1=1@90
| abCCCCC10000000050
999999999+1=1000000000
| 11,879 |
s901126504 | p00077 | u546285759 | 1503459332 | Python | Python3 | py | Accepted | 30 | 7508 | 294 | while True:
try:
string = input()
except:
break
ans = ""
i = 0
while i < len(string):
if string[i] == "@":
ans += int(string[i+1])*string[i+2]
i += 3
else:
ans += string[i]
i += 1
print(ans) | p00077 |
<H1>ランレングス</H1>
<p>
文字列が連続した場合、ある規則で文字を置き換え文字列を短くすることができます。たとえば、AAAA という文字列の場合、@4A と表現すれば 1 文字分圧縮されます。この規則で圧縮された文字列を入力してもとの文字列に復元するプログラムを作成してください。ただし、復元した文字列に＠文字は出現しないものとします。
</p>
<p>
また、原文の文字列は英大文字、英小文字、数字、記号であり 100 文字以内、連続する文字は 9 文字以内です。
</p>
<H2>入力</H2>
<p>複数の文字列が与えられます。１行に１つの文字列が与えられます。文字列の数は 50 を超えません。</p>
<H2>出力</H2>
<p>文字列ごとに、各文字に対して復元した文字列を１行に出力して下さい。
</p>
<H2>Sample Input</H2>
<pre>
ab@5C1@8050
@99+1=1@90
</pre>
<H2>Output for the Sample Input</H2>
<pre>
abCCCCC10000000050
999999999+1=1000000000
</pre>
| ab@5C1@8050
@99+1=1@90
| abCCCCC10000000050
999999999+1=1000000000
| 11,880 |
s208077202 | p00077 | u957021183 | 1505122394 | Python | Python3 | py | Accepted | 20 | 7844 | 539 | # Aizu Problem 0077: Run Length
#
import sys, math, os
# read input:
PYDEV = os.environ.get('PYDEV')
if PYDEV=="True":
sys.stdin = open("sample-input.txt", "rt")
def run_length(string):
out = ""
k = 0
while k < len(string):
char = string[k]
if char != '@':
out += char
k += 1
else:
cnt = int(string[k+1])
char = string[k+2]
out += char * cnt
k += 3
return out
for line in sys.stdin:
print(run_length(line.strip())) | p00077 |
<H1>ランレングス</H1>
<p>
文字列が連続した場合、ある規則で文字を置き換え文字列を短くすることができます。たとえば、AAAA という文字列の場合、@4A と表現すれば 1 文字分圧縮されます。この規則で圧縮された文字列を入力してもとの文字列に復元するプログラムを作成してください。ただし、復元した文字列に＠文字は出現しないものとします。
</p>
<p>
また、原文の文字列は英大文字、英小文字、数字、記号であり 100 文字以内、連続する文字は 9 文字以内です。
</p>
<H2>入力</H2>
<p>複数の文字列が与えられます。１行に１つの文字列が与えられます。文字列の数は 50 を超えません。</p>
<H2>出力</H2>
<p>文字列ごとに、各文字に対して復元した文字列を１行に出力して下さい。
</p>
<H2>Sample Input</H2>
<pre>
ab@5C1@8050
@99+1=1@90
</pre>
<H2>Output for the Sample Input</H2>
<pre>
abCCCCC10000000050
999999999+1=1000000000
</pre>
| ab@5C1@8050
@99+1=1@90
| abCCCCC10000000050
999999999+1=1000000000
| 11,881 |
s472567865 | p00077 | u043254318 | 1518977350 | Python | Python3 | py | Accepted | 20 | 5592 | 471 | def get_input():
while True:
try:
yield ''.join(input())
except EOFError:
break
N = list(get_input())
for l in range(len(N)):
S = N[l]
skip = 0
for i in range(len(S)):
if skip > 0:
skip -= 1
elif S[i] == "@":
n = int(S[i+1])
for j in range(n):
print(S[i+2],end="")
skip = 2
else:
print(S[i],end="")
print("")
| p00077 |
<H1>ランレングス</H1>
<p>
文字列が連続した場合、ある規則で文字を置き換え文字列を短くすることができます。たとえば、AAAA という文字列の場合、@4A と表現すれば 1 文字分圧縮されます。この規則で圧縮された文字列を入力してもとの文字列に復元するプログラムを作成してください。ただし、復元した文字列に＠文字は出現しないものとします。
</p>
<p>
また、原文の文字列は英大文字、英小文字、数字、記号であり 100 文字以内、連続する文字は 9 文字以内です。
</p>
<H2>入力</H2>
<p>複数の文字列が与えられます。１行に１つの文字列が与えられます。文字列の数は 50 を超えません。</p>
<H2>出力</H2>
<p>文字列ごとに、各文字に対して復元した文字列を１行に出力して下さい。
</p>
<H2>Sample Input</H2>
<pre>
ab@5C1@8050
@99+1=1@90
</pre>
<H2>Output for the Sample Input</H2>
<pre>
abCCCCC10000000050
999999999+1=1000000000
</pre>
| ab@5C1@8050
@99+1=1@90
| abCCCCC10000000050
999999999+1=1000000000
| 11,882 |
s680826860 | p00077 | u024715419 | 1519295637 | Python | Python3 | py | Accepted | 20 | 5592 | 461 | while True:
try:
s_inp = input()
s_out = ""
flag = 0
for c in s_inp:
if flag == 1:
n = int(c)
flag = 2
elif flag == 2:
for i in range(n):
s_out = s_out + c
flag = 0
elif c == "@":
flag = 1
else:
s_out = s_out + c
print(s_out)
except:
break
| p00077 |
<H1>ランレングス</H1>
<p>
文字列が連続した場合、ある規則で文字を置き換え文字列を短くすることができます。たとえば、AAAA という文字列の場合、@4A と表現すれば 1 文字分圧縮されます。この規則で圧縮された文字列を入力してもとの文字列に復元するプログラムを作成してください。ただし、復元した文字列に＠文字は出現しないものとします。
</p>
<p>
また、原文の文字列は英大文字、英小文字、数字、記号であり 100 文字以内、連続する文字は 9 文字以内です。
</p>
<H2>入力</H2>
<p>複数の文字列が与えられます。１行に１つの文字列が与えられます。文字列の数は 50 を超えません。</p>
<H2>出力</H2>
<p>文字列ごとに、各文字に対して復元した文字列を１行に出力して下さい。
</p>
<H2>Sample Input</H2>
<pre>
ab@5C1@8050
@99+1=1@90
</pre>
<H2>Output for the Sample Input</H2>
<pre>
abCCCCC10000000050
999999999+1=1000000000
</pre>
| ab@5C1@8050
@99+1=1@90
| abCCCCC10000000050
999999999+1=1000000000
| 11,883 |
s982270904 | p00077 | u150984829 | 1520124630 | Python | Python3 | py | Accepted | 20 | 5600 | 144 | import sys
for e in sys.stdin:
a='';b=n=0
for c in e[:-1]:
if'@'==c:b=1
elif b&1:n=int(c);b=2
elif b&2:a+=c*n;b=0
else:a+=c
print(a)
| p00077 |
<H1>ランレングス</H1>
<p>
文字列が連続した場合、ある規則で文字を置き換え文字列を短くすることができます。たとえば、AAAA という文字列の場合、@4A と表現すれば 1 文字分圧縮されます。この規則で圧縮された文字列を入力してもとの文字列に復元するプログラムを作成してください。ただし、復元した文字列に＠文字は出現しないものとします。
</p>
<p>
また、原文の文字列は英大文字、英小文字、数字、記号であり 100 文字以内、連続する文字は 9 文字以内です。
</p>
<H2>入力</H2>
<p>複数の文字列が与えられます。１行に１つの文字列が与えられます。文字列の数は 50 を超えません。</p>
<H2>出力</H2>
<p>文字列ごとに、各文字に対して復元した文字列を１行に出力して下さい。
</p>
<H2>Sample Input</H2>
<pre>
ab@5C1@8050
@99+1=1@90
</pre>
<H2>Output for the Sample Input</H2>
<pre>
abCCCCC10000000050
999999999+1=1000000000
</pre>
| ab@5C1@8050
@99+1=1@90
| abCCCCC10000000050
999999999+1=1000000000
| 11,884 |
s955307331 | p00077 | u150984829 | 1520125053 | Python | Python3 | py | Accepted | 20 | 5604 | 122 | import sys
for e in sys.stdin:
a,n='',1
for c in e[:-1]:
if'@'==c:n=0
elif n<1:n=int(c)
else:a+=c*n;n=1
print(a)
| p00077 |
<H1>ランレングス</H1>
<p>
文字列が連続した場合、ある規則で文字を置き換え文字列を短くすることができます。たとえば、AAAA という文字列の場合、@4A と表現すれば 1 文字分圧縮されます。この規則で圧縮された文字列を入力してもとの文字列に復元するプログラムを作成してください。ただし、復元した文字列に＠文字は出現しないものとします。
</p>
<p>
また、原文の文字列は英大文字、英小文字、数字、記号であり 100 文字以内、連続する文字は 9 文字以内です。
</p>
<H2>入力</H2>
<p>複数の文字列が与えられます。１行に１つの文字列が与えられます。文字列の数は 50 を超えません。</p>
<H2>出力</H2>
<p>文字列ごとに、各文字に対して復元した文字列を１行に出力して下さい。
</p>
<H2>Sample Input</H2>
<pre>
ab@5C1@8050
@99+1=1@90
</pre>
<H2>Output for the Sample Input</H2>
<pre>
abCCCCC10000000050
999999999+1=1000000000
</pre>
| ab@5C1@8050
@99+1=1@90
| abCCCCC10000000050
999999999+1=1000000000
| 11,885 |
s095287935 | p00077 | u352394527 | 1527560307 | Python | Python3 | py | Accepted | 20 | 5600 | 286 | def restore(s):
ret = ""
ind = 0
end = len(s)
while ind < end:
if s[ind] == "@":
ret += s[ind + 2] * int(s[ind + 1])
ind += 3
else:
ret += s[ind]
ind += 1
return ret
while True:
try:
print(restore(input()))
except EOFError:
break
| p00077 |
<H1>ランレングス</H1>
<p>
文字列が連続した場合、ある規則で文字を置き換え文字列を短くすることができます。たとえば、AAAA という文字列の場合、@4A と表現すれば 1 文字分圧縮されます。この規則で圧縮された文字列を入力してもとの文字列に復元するプログラムを作成してください。ただし、復元した文字列に＠文字は出現しないものとします。
</p>
<p>
また、原文の文字列は英大文字、英小文字、数字、記号であり 100 文字以内、連続する文字は 9 文字以内です。
</p>
<H2>入力</H2>
<p>複数の文字列が与えられます。１行に１つの文字列が与えられます。文字列の数は 50 を超えません。</p>
<H2>出力</H2>
<p>文字列ごとに、各文字に対して復元した文字列を１行に出力して下さい。
</p>
<H2>Sample Input</H2>
<pre>
ab@5C1@8050
@99+1=1@90
</pre>
<H2>Output for the Sample Input</H2>
<pre>
abCCCCC10000000050
999999999+1=1000000000
</pre>
| ab@5C1@8050
@99+1=1@90
| abCCCCC10000000050
999999999+1=1000000000
| 11,886 |
s721874892 | p00077 | u136916346 | 1528639229 | Python | Python3 | py | Accepted | 20 | 5612 | 224 | import sys
for s in sys.stdin:
s=s[:-1]
while 1:
idx=s.find("@")
if idx==-1:break
s=s.replace(s[idx:idx+3],
"".join([s[idx+2] for _ in range(int(s[idx+1]))]))
print(s)
| p00077 |
<H1>ランレングス</H1>
<p>
文字列が連続した場合、ある規則で文字を置き換え文字列を短くすることができます。たとえば、AAAA という文字列の場合、@4A と表現すれば 1 文字分圧縮されます。この規則で圧縮された文字列を入力してもとの文字列に復元するプログラムを作成してください。ただし、復元した文字列に＠文字は出現しないものとします。
</p>
<p>
また、原文の文字列は英大文字、英小文字、数字、記号であり 100 文字以内、連続する文字は 9 文字以内です。
</p>
<H2>入力</H2>
<p>複数の文字列が与えられます。１行に１つの文字列が与えられます。文字列の数は 50 を超えません。</p>
<H2>出力</H2>
<p>文字列ごとに、各文字に対して復元した文字列を１行に出力して下さい。
</p>
<H2>Sample Input</H2>
<pre>
ab@5C1@8050
@99+1=1@90
</pre>
<H2>Output for the Sample Input</H2>
<pre>
abCCCCC10000000050
999999999+1=1000000000
</pre>
| ab@5C1@8050
@99+1=1@90
| abCCCCC10000000050
999999999+1=1000000000
| 11,887 |
s217471312 | p00077 | u847467233 | 1529032185 | Python | Python3 | py | Accepted | 20 | 5600 | 273 | # AOJ 0077 Run Length
# Python3 2018.6.15 bal4u
while True:
try: s = list(input())
except EOFError: break
ans = []
i = 0
while i < len(s):
if s[i] == '@':
for j in range(int(s[i+1])): ans += s[i+2]
i += 2
else: ans += s[i]
i += 1
print(*ans, sep='')
| p00077 |
<H1>ランレングス</H1>
<p>
文字列が連続した場合、ある規則で文字を置き換え文字列を短くすることができます。たとえば、AAAA という文字列の場合、@4A と表現すれば 1 文字分圧縮されます。この規則で圧縮された文字列を入力してもとの文字列に復元するプログラムを作成してください。ただし、復元した文字列に＠文字は出現しないものとします。
</p>
<p>
また、原文の文字列は英大文字、英小文字、数字、記号であり 100 文字以内、連続する文字は 9 文字以内です。
</p>
<H2>入力</H2>
<p>複数の文字列が与えられます。１行に１つの文字列が与えられます。文字列の数は 50 を超えません。</p>
<H2>出力</H2>
<p>文字列ごとに、各文字に対して復元した文字列を１行に出力して下さい。
</p>
<H2>Sample Input</H2>
<pre>
ab@5C1@8050
@99+1=1@90
</pre>
<H2>Output for the Sample Input</H2>
<pre>
abCCCCC10000000050
999999999+1=1000000000
</pre>
| ab@5C1@8050
@99+1=1@90
| abCCCCC10000000050
999999999+1=1000000000
| 11,888 |
s569703387 | p00077 | u894941280 | 1348539164 | Python | Python | py | Accepted | 10 | 4236 | 440 | import sys
while True:
try:
ans=[]
hoge=raw_input()
hoge+=" "
for i in range(len(hoge)-2):
if hoge[i] == "@":
tt = hoge[i+2]*int(hoge[i+1])
ans.append(tt)
else:
if hoge[i-1] == "@" or hoge[i-2] == "@":
continue
else:
ans.append(hoge[i])
else:
for i in range(len(ans)):
sys.stdout.write(ans[i])
else: print ""
except EOFError: break | p00077 |
<H1>ランレングス</H1>
<p>
文字列が連続した場合、ある規則で文字を置き換え文字列を短くすることができます。たとえば、AAAA という文字列の場合、@4A と表現すれば 1 文字分圧縮されます。この規則で圧縮された文字列を入力してもとの文字列に復元するプログラムを作成してください。ただし、復元した文字列に＠文字は出現しないものとします。
</p>
<p>
また、原文の文字列は英大文字、英小文字、数字、記号であり 100 文字以内、連続する文字は 9 文字以内です。
</p>
<H2>入力</H2>
<p>複数の文字列が与えられます。１行に１つの文字列が与えられます。文字列の数は 50 を超えません。</p>
<H2>出力</H2>
<p>文字列ごとに、各文字に対して復元した文字列を１行に出力して下さい。
</p>
<H2>Sample Input</H2>
<pre>
ab@5C1@8050
@99+1=1@90
</pre>
<H2>Output for the Sample Input</H2>
<pre>
abCCCCC10000000050
999999999+1=1000000000
</pre>
| ab@5C1@8050
@99+1=1@90
| abCCCCC10000000050
999999999+1=1000000000
| 11,889 |
s734166384 | p00077 | u504990413 | 1353501772 | Python | Python | py | Accepted | 10 | 4240 | 525 | while True:
try:
array = map(str,raw_input())
display = []
for i in range(len(array)):
if array[i] != '@':
display.append(array[i])
elif array[i] == '@':
insert = int(array[i+1])*array[i+2]
display.append(insert)
array[i+1] ,array[i+2]= '',''
for i in range(len(display)-1):
display[i+1] = display[i]+ display[i+1]
print display[-1]
except EOFError:
break | p00077 |
<H1>ランレングス</H1>
<p>
文字列が連続した場合、ある規則で文字を置き換え文字列を短くすることができます。たとえば、AAAA という文字列の場合、@4A と表現すれば 1 文字分圧縮されます。この規則で圧縮された文字列を入力してもとの文字列に復元するプログラムを作成してください。ただし、復元した文字列に＠文字は出現しないものとします。
</p>
<p>
また、原文の文字列は英大文字、英小文字、数字、記号であり 100 文字以内、連続する文字は 9 文字以内です。
</p>
<H2>入力</H2>
<p>複数の文字列が与えられます。１行に１つの文字列が与えられます。文字列の数は 50 を超えません。</p>
<H2>出力</H2>
<p>文字列ごとに、各文字に対して復元した文字列を１行に出力して下さい。
</p>
<H2>Sample Input</H2>
<pre>
ab@5C1@8050
@99+1=1@90
</pre>
<H2>Output for the Sample Input</H2>
<pre>
abCCCCC10000000050
999999999+1=1000000000
</pre>
| ab@5C1@8050
@99+1=1@90
| abCCCCC10000000050
999999999+1=1000000000
| 11,890 |
s029754971 | p00077 | u735362704 | 1356018537 | Python | Python | py | Accepted | 10 | 4224 | 423 | #!/usr/bin/env python
# coding: utf-8
import sys
import re
def get_answer(s):
encodeds = re.findall(r"@\d.", s)
for encoded in encodeds:
n = int(encoded[1])
c = encoded[2]
s = s.replace(encoded, c * n)
return s
def main():
params = [line.rstrip() for line in sys.stdin.readlines()]
for param in params:
print get_answer(param)
if __name__ == '__main__':
main() | p00077 |
<H1>ランレングス</H1>
<p>
文字列が連続した場合、ある規則で文字を置き換え文字列を短くすることができます。たとえば、AAAA という文字列の場合、@4A と表現すれば 1 文字分圧縮されます。この規則で圧縮された文字列を入力してもとの文字列に復元するプログラムを作成してください。ただし、復元した文字列に＠文字は出現しないものとします。
</p>
<p>
また、原文の文字列は英大文字、英小文字、数字、記号であり 100 文字以内、連続する文字は 9 文字以内です。
</p>
<H2>入力</H2>
<p>複数の文字列が与えられます。１行に１つの文字列が与えられます。文字列の数は 50 を超えません。</p>
<H2>出力</H2>
<p>文字列ごとに、各文字に対して復元した文字列を１行に出力して下さい。
</p>
<H2>Sample Input</H2>
<pre>
ab@5C1@8050
@99+1=1@90
</pre>
<H2>Output for the Sample Input</H2>
<pre>
abCCCCC10000000050
999999999+1=1000000000
</pre>
| ab@5C1@8050
@99+1=1@90
| abCCCCC10000000050
999999999+1=1000000000
| 11,891 |
s820684466 | p00077 | u647766105 | 1356477844 | Python | Python | py | Accepted | 10 | 4212 | 202 | import sys
for line in sys.stdin.readlines():
while True:
i=line.find("@")
if i==-1:
break
line=line.replace(line[i:i+3],line[i+2]*int(line[i+1]))
print line, | p00077 |
<H1>ランレングス</H1>
<p>
文字列が連続した場合、ある規則で文字を置き換え文字列を短くすることができます。たとえば、AAAA という文字列の場合、@4A と表現すれば 1 文字分圧縮されます。この規則で圧縮された文字列を入力してもとの文字列に復元するプログラムを作成してください。ただし、復元した文字列に＠文字は出現しないものとします。
</p>
<p>
また、原文の文字列は英大文字、英小文字、数字、記号であり 100 文字以内、連続する文字は 9 文字以内です。
</p>
<H2>入力</H2>
<p>複数の文字列が与えられます。１行に１つの文字列が与えられます。文字列の数は 50 を超えません。</p>
<H2>出力</H2>
<p>文字列ごとに、各文字に対して復元した文字列を１行に出力して下さい。
</p>
<H2>Sample Input</H2>
<pre>
ab@5C1@8050
@99+1=1@90
</pre>
<H2>Output for the Sample Input</H2>
<pre>
abCCCCC10000000050
999999999+1=1000000000
</pre>
| ab@5C1@8050
@99+1=1@90
| abCCCCC10000000050
999999999+1=1000000000
| 11,892 |
s347071056 | p00077 | u350508326 | 1373013130 | Python | Python | py | Accepted | 10 | 4292 | 1,221 | text = []
ptext = []
while True:
try:
text = list(map(str,raw_input()))
f = 0
ptext = []
for i in range(len(text)):
if text[i] == '@':
for k in range(int(text[i+1])-1):
ptext.append(text[i+2])
f = 1
else:
if f == 0:
ptext.append(text[i])
else:
f = 0
print "".join(map(str,ptext))
except EOFError:
break
text = []
ptext = []
while True:
try:
text = list(map(str,raw_input()))
f = 0
ptext = []
for i in range(len(text)):
if text[i] == '@':
for k in range(int(text[i+1])-1):
ptext.append(text[i+2])
f = 1
else:
if f == 0:
ptext.append(text[i])
else:
f = 0
print "".join(map(str,ptext))
except EOFError:
break | p00077 |
<H1>ランレングス</H1>
<p>
文字列が連続した場合、ある規則で文字を置き換え文字列を短くすることができます。たとえば、AAAA という文字列の場合、@4A と表現すれば 1 文字分圧縮されます。この規則で圧縮された文字列を入力してもとの文字列に復元するプログラムを作成してください。ただし、復元した文字列に＠文字は出現しないものとします。
</p>
<p>
また、原文の文字列は英大文字、英小文字、数字、記号であり 100 文字以内、連続する文字は 9 文字以内です。
</p>
<H2>入力</H2>
<p>複数の文字列が与えられます。１行に１つの文字列が与えられます。文字列の数は 50 を超えません。</p>
<H2>出力</H2>
<p>文字列ごとに、各文字に対して復元した文字列を１行に出力して下さい。
</p>
<H2>Sample Input</H2>
<pre>
ab@5C1@8050
@99+1=1@90
</pre>
<H2>Output for the Sample Input</H2>
<pre>
abCCCCC10000000050
999999999+1=1000000000
</pre>
| ab@5C1@8050
@99+1=1@90
| abCCCCC10000000050
999999999+1=1000000000
| 11,893 |
s040349985 | p00077 | u782850731 | 1378825719 | Python | Python | py | Accepted | 10 | 4252 | 474 | #!/usr/bin/env python
# -*- coding: utf-8 -*-
from __future__ import (division, absolute_import, print_function,
unicode_literals)
from sys import stdin
li = []
for line in stdin:
compress = False
num = 1
for c in line:
if c == '@':
compress = True
elif compress:
compress = False
num = int(c)
else:
li.append(c * num)
num = 1
print(''.join(li), end='') | p00077 |
<H1>ランレングス</H1>
<p>
文字列が連続した場合、ある規則で文字を置き換え文字列を短くすることができます。たとえば、AAAA という文字列の場合、@4A と表現すれば 1 文字分圧縮されます。この規則で圧縮された文字列を入力してもとの文字列に復元するプログラムを作成してください。ただし、復元した文字列に＠文字は出現しないものとします。
</p>
<p>
また、原文の文字列は英大文字、英小文字、数字、記号であり 100 文字以内、連続する文字は 9 文字以内です。
</p>
<H2>入力</H2>
<p>複数の文字列が与えられます。１行に１つの文字列が与えられます。文字列の数は 50 を超えません。</p>
<H2>出力</H2>
<p>文字列ごとに、各文字に対して復元した文字列を１行に出力して下さい。
</p>
<H2>Sample Input</H2>
<pre>
ab@5C1@8050
@99+1=1@90
</pre>
<H2>Output for the Sample Input</H2>
<pre>
abCCCCC10000000050
999999999+1=1000000000
</pre>
| ab@5C1@8050
@99+1=1@90
| abCCCCC10000000050
999999999+1=1000000000
| 11,894 |
s264921080 | p00077 | u093607836 | 1384844318 | Python | Python | py | Accepted | 20 | 4188 | 135 | import re,sys
for s in sys.stdin:
l = re.split('(@.{2})',s)
for s in l:
if '@' in s:
s = s[2] * int(s[1])
sys.stdout.write(s) | p00077 |
<H1>ランレングス</H1>
<p>
文字列が連続した場合、ある規則で文字を置き換え文字列を短くすることができます。たとえば、AAAA という文字列の場合、@4A と表現すれば 1 文字分圧縮されます。この規則で圧縮された文字列を入力してもとの文字列に復元するプログラムを作成してください。ただし、復元した文字列に＠文字は出現しないものとします。
</p>
<p>
また、原文の文字列は英大文字、英小文字、数字、記号であり 100 文字以内、連続する文字は 9 文字以内です。
</p>
<H2>入力</H2>
<p>複数の文字列が与えられます。１行に１つの文字列が与えられます。文字列の数は 50 を超えません。</p>
<H2>出力</H2>
<p>文字列ごとに、各文字に対して復元した文字列を１行に出力して下さい。
</p>
<H2>Sample Input</H2>
<pre>
ab@5C1@8050
@99+1=1@90
</pre>
<H2>Output for the Sample Input</H2>
<pre>
abCCCCC10000000050
999999999+1=1000000000
</pre>
| ab@5C1@8050
@99+1=1@90
| abCCCCC10000000050
999999999+1=1000000000
| 11,895 |
s054563727 | p00077 | u633068244 | 1393756633 | Python | Python | py | Accepted | 10 | 4208 | 311 | while True:
try:
inp = raw_input()
i, msg = 0, ""
while i < len(inp):
if inp[i] == "@":
msg += inp[i+2]*int(inp[i+1])
i += 3
else:
msg += inp[i]
i += 1
print msg
except:
break | p00077 |
<H1>ランレングス</H1>
<p>
文字列が連続した場合、ある規則で文字を置き換え文字列を短くすることができます。たとえば、AAAA という文字列の場合、@4A と表現すれば 1 文字分圧縮されます。この規則で圧縮された文字列を入力してもとの文字列に復元するプログラムを作成してください。ただし、復元した文字列に＠文字は出現しないものとします。
</p>
<p>
また、原文の文字列は英大文字、英小文字、数字、記号であり 100 文字以内、連続する文字は 9 文字以内です。
</p>
<H2>入力</H2>
<p>複数の文字列が与えられます。１行に１つの文字列が与えられます。文字列の数は 50 を超えません。</p>
<H2>出力</H2>
<p>文字列ごとに、各文字に対して復元した文字列を１行に出力して下さい。
</p>
<H2>Sample Input</H2>
<pre>
ab@5C1@8050
@99+1=1@90
</pre>
<H2>Output for the Sample Input</H2>
<pre>
abCCCCC10000000050
999999999+1=1000000000
</pre>
| ab@5C1@8050
@99+1=1@90
| abCCCCC10000000050
999999999+1=1000000000
| 11,896 |
s396831112 | p00077 | u912237403 | 1396626039 | Python | Python | py | Accepted | 10 | 4208 | 289 | import sys
for s in sys.stdin:
n=s.count("@")
m=0
x=""
for c in s[:-1]:
if m==0:
if c=="@":m=1
else:x+=c
elif m==1:
a="0123456789".index(c)
m=2
elif m==2:
x+=c*a
m=0
print x | p00077 |
<H1>ランレングス</H1>
<p>
文字列が連続した場合、ある規則で文字を置き換え文字列を短くすることができます。たとえば、AAAA という文字列の場合、@4A と表現すれば 1 文字分圧縮されます。この規則で圧縮された文字列を入力してもとの文字列に復元するプログラムを作成してください。ただし、復元した文字列に＠文字は出現しないものとします。
</p>
<p>
また、原文の文字列は英大文字、英小文字、数字、記号であり 100 文字以内、連続する文字は 9 文字以内です。
</p>
<H2>入力</H2>
<p>複数の文字列が与えられます。１行に１つの文字列が与えられます。文字列の数は 50 を超えません。</p>
<H2>出力</H2>
<p>文字列ごとに、各文字に対して復元した文字列を１行に出力して下さい。
</p>
<H2>Sample Input</H2>
<pre>
ab@5C1@8050
@99+1=1@90
</pre>
<H2>Output for the Sample Input</H2>
<pre>
abCCCCC10000000050
999999999+1=1000000000
</pre>
| ab@5C1@8050
@99+1=1@90
| abCCCCC10000000050
999999999+1=1000000000
| 11,897 |
s965494949 | p00077 | u912237403 | 1396626538 | Python | Python | py | Accepted | 10 | 4196 | 154 | import sys
for s in sys.stdin:
while 1:
p=s.find("@")
if p==-1:break
s=s.replace(s[p:p+3],s[p+2]*int(s[p+1]))
print s[:-1] | p00077 |
<H1>ランレングス</H1>
<p>
文字列が連続した場合、ある規則で文字を置き換え文字列を短くすることができます。たとえば、AAAA という文字列の場合、@4A と表現すれば 1 文字分圧縮されます。この規則で圧縮された文字列を入力してもとの文字列に復元するプログラムを作成してください。ただし、復元した文字列に＠文字は出現しないものとします。
</p>
<p>
また、原文の文字列は英大文字、英小文字、数字、記号であり 100 文字以内、連続する文字は 9 文字以内です。
</p>
<H2>入力</H2>
<p>複数の文字列が与えられます。１行に１つの文字列が与えられます。文字列の数は 50 を超えません。</p>
<H2>出力</H2>
<p>文字列ごとに、各文字に対して復元した文字列を１行に出力して下さい。
</p>
<H2>Sample Input</H2>
<pre>
ab@5C1@8050
@99+1=1@90
</pre>
<H2>Output for the Sample Input</H2>
<pre>
abCCCCC10000000050
999999999+1=1000000000
</pre>
| ab@5C1@8050
@99+1=1@90
| abCCCCC10000000050
999999999+1=1000000000
| 11,898 |
s289470544 | p00077 | u912237403 | 1396626630 | Python | Python | py | Accepted | 10 | 4200 | 162 | import sys
for s in sys.stdin:
while 1:
p = s.find("@")
if p==-1: break
s = s.replace(s[p:p+3], s[p+2] * int(s[p+1]))
print s[:-1] | p00077 |
<H1>ランレングス</H1>
<p>
文字列が連続した場合、ある規則で文字を置き換え文字列を短くすることができます。たとえば、AAAA という文字列の場合、@4A と表現すれば 1 文字分圧縮されます。この規則で圧縮された文字列を入力してもとの文字列に復元するプログラムを作成してください。ただし、復元した文字列に＠文字は出現しないものとします。
</p>
<p>
また、原文の文字列は英大文字、英小文字、数字、記号であり 100 文字以内、連続する文字は 9 文字以内です。
</p>
<H2>入力</H2>
<p>複数の文字列が与えられます。１行に１つの文字列が与えられます。文字列の数は 50 を超えません。</p>
<H2>出力</H2>
<p>文字列ごとに、各文字に対して復元した文字列を１行に出力して下さい。
</p>
<H2>Sample Input</H2>
<pre>
ab@5C1@8050
@99+1=1@90
</pre>
<H2>Output for the Sample Input</H2>
<pre>
abCCCCC10000000050
999999999+1=1000000000
</pre>
| ab@5C1@8050
@99+1=1@90
| abCCCCC10000000050
999999999+1=1000000000
| 11,899 |
s021562659 | p00077 | u193025715 | 1398062812 | Python | Python | py | Accepted | 10 | 4208 | 224 | while True:
try:
char = raw_input()
ans = ""
while "@" in char:
ans += char[0:char.index("@")]
char = char[char.index("@"):]
char = char[2] * int(char[1]) + char[3:]
ans += char
print ans
except:
break | p00077 |
<H1>ランレングス</H1>
<p>
文字列が連続した場合、ある規則で文字を置き換え文字列を短くすることができます。たとえば、AAAA という文字列の場合、@4A と表現すれば 1 文字分圧縮されます。この規則で圧縮された文字列を入力してもとの文字列に復元するプログラムを作成してください。ただし、復元した文字列に＠文字は出現しないものとします。
</p>
<p>
また、原文の文字列は英大文字、英小文字、数字、記号であり 100 文字以内、連続する文字は 9 文字以内です。
</p>
<H2>入力</H2>
<p>複数の文字列が与えられます。１行に１つの文字列が与えられます。文字列の数は 50 を超えません。</p>
<H2>出力</H2>
<p>文字列ごとに、各文字に対して復元した文字列を１行に出力して下さい。
</p>
<H2>Sample Input</H2>
<pre>
ab@5C1@8050
@99+1=1@90
</pre>
<H2>Output for the Sample Input</H2>
<pre>
abCCCCC10000000050
999999999+1=1000000000
</pre>
| ab@5C1@8050
@99+1=1@90
| abCCCCC10000000050
999999999+1=1000000000
| 11,900 |
s875052729 | p00077 | u491763171 | 1400480774 | Python | Python | py | Accepted | 10 | 4212 | 297 | while 1:
try:
line = raw_input()
except EOFError:
break
i = 0
ret = ''
while i < len(line):
if line[i] == '@':
ret += line[i + 2] * int(line[i + 1])
i += 3
else:
ret += line[i]
i += 1
print ret | p00077 |
<H1>ランレングス</H1>
<p>
文字列が連続した場合、ある規則で文字を置き換え文字列を短くすることができます。たとえば、AAAA という文字列の場合、@4A と表現すれば 1 文字分圧縮されます。この規則で圧縮された文字列を入力してもとの文字列に復元するプログラムを作成してください。ただし、復元した文字列に＠文字は出現しないものとします。
</p>
<p>
また、原文の文字列は英大文字、英小文字、数字、記号であり 100 文字以内、連続する文字は 9 文字以内です。
</p>
<H2>入力</H2>
<p>複数の文字列が与えられます。１行に１つの文字列が与えられます。文字列の数は 50 を超えません。</p>
<H2>出力</H2>
<p>文字列ごとに、各文字に対して復元した文字列を１行に出力して下さい。
</p>
<H2>Sample Input</H2>
<pre>
ab@5C1@8050
@99+1=1@90
</pre>
<H2>Output for the Sample Input</H2>
<pre>
abCCCCC10000000050
999999999+1=1000000000
</pre>
| ab@5C1@8050
@99+1=1@90
| abCCCCC10000000050
999999999+1=1000000000
| 11,901 |
s150001352 | p00077 | u436634575 | 1402323905 | Python | Python3 | py | Accepted | 30 | 6720 | 264 | while True:
try:
s = input()
except EOFError:
break
r = ''
n = 1
for c in s:
if n < 0:
n = int(c)
elif c == '@':
n = -1
else:
r += c * n
n = 1
print(r) | p00077 |
<H1>ランレングス</H1>
<p>
文字列が連続した場合、ある規則で文字を置き換え文字列を短くすることができます。たとえば、AAAA という文字列の場合、@4A と表現すれば 1 文字分圧縮されます。この規則で圧縮された文字列を入力してもとの文字列に復元するプログラムを作成してください。ただし、復元した文字列に＠文字は出現しないものとします。
</p>
<p>
また、原文の文字列は英大文字、英小文字、数字、記号であり 100 文字以内、連続する文字は 9 文字以内です。
</p>
<H2>入力</H2>
<p>複数の文字列が与えられます。１行に１つの文字列が与えられます。文字列の数は 50 を超えません。</p>
<H2>出力</H2>
<p>文字列ごとに、各文字に対して復元した文字列を１行に出力して下さい。
</p>
<H2>Sample Input</H2>
<pre>
ab@5C1@8050
@99+1=1@90
</pre>
<H2>Output for the Sample Input</H2>
<pre>
abCCCCC10000000050
999999999+1=1000000000
</pre>
| ab@5C1@8050
@99+1=1@90
| abCCCCC10000000050
999999999+1=1000000000
| 11,902 |
s968191407 | p00077 | u747915832 | 1597073889 | Python | Python3 | py | Accepted | 20 | 5596 | 267 | while True:
try:
Tlist = list(input())
except:
break
while '@' in Tlist:
at = Tlist.index('@')
t = Tlist[at+2]
x = int(Tlist[at+1])
del(Tlist[at:at+3])
Tlist.insert(at,t*x)
print(''.join(Tlist))
| p00077 |
<H1>ランレングス</H1>
<p>
文字列が連続した場合、ある規則で文字を置き換え文字列を短くすることができます。たとえば、AAAA という文字列の場合、@4A と表現すれば 1 文字分圧縮されます。この規則で圧縮された文字列を入力してもとの文字列に復元するプログラムを作成してください。ただし、復元した文字列に＠文字は出現しないものとします。
</p>
<p>
また、原文の文字列は英大文字、英小文字、数字、記号であり 100 文字以内、連続する文字は 9 文字以内です。
</p>
<H2>入力</H2>
<p>複数の文字列が与えられます。１行に１つの文字列が与えられます。文字列の数は 50 を超えません。</p>
<H2>出力</H2>
<p>文字列ごとに、各文字に対して復元した文字列を１行に出力して下さい。
</p>
<H2>Sample Input</H2>
<pre>
ab@5C1@8050
@99+1=1@90
</pre>
<H2>Output for the Sample Input</H2>
<pre>
abCCCCC10000000050
999999999+1=1000000000
</pre>
| ab@5C1@8050
@99+1=1@90
| abCCCCC10000000050
999999999+1=1000000000
| 11,903 |
s119476878 | p00077 | u286298310 | 1596516388 | Python | Python3 | py | Accepted | 20 | 5596 | 203 |
import sys
for x in sys.stdin:
for i in range(1000):
if x[i] == "@":
x = x[:i] + x[i+2]*int(x[i+1]) + x[i+3:]
if i == len(x) - 1:
break
print(x,end="")
| p00077 |
<H1>ランレングス</H1>
<p>
文字列が連続した場合、ある規則で文字を置き換え文字列を短くすることができます。たとえば、AAAA という文字列の場合、@4A と表現すれば 1 文字分圧縮されます。この規則で圧縮された文字列を入力してもとの文字列に復元するプログラムを作成してください。ただし、復元した文字列に＠文字は出現しないものとします。
</p>
<p>
また、原文の文字列は英大文字、英小文字、数字、記号であり 100 文字以内、連続する文字は 9 文字以内です。
</p>
<H2>入力</H2>
<p>複数の文字列が与えられます。１行に１つの文字列が与えられます。文字列の数は 50 を超えません。</p>
<H2>出力</H2>
<p>文字列ごとに、各文字に対して復元した文字列を１行に出力して下さい。
</p>
<H2>Sample Input</H2>
<pre>
ab@5C1@8050
@99+1=1@90
</pre>
<H2>Output for the Sample Input</H2>
<pre>
abCCCCC10000000050
999999999+1=1000000000
</pre>
| ab@5C1@8050
@99+1=1@90
| abCCCCC10000000050
999999999+1=1000000000
| 11,904 |
s342704520 | p00077 | u187074069 | 1594991570 | Python | Python3 | py | Accepted | 20 | 5596 | 236 | while True:
try:
s = list(input())
while '@' in s:
num = s.index('@')
s[num+1] = s[num+2] * (int(s[num+1])-1)
s.pop(num)
except EOFError:
break
print(''.join(s))
| p00077 |
<H1>ランレングス</H1>
<p>
文字列が連続した場合、ある規則で文字を置き換え文字列を短くすることができます。たとえば、AAAA という文字列の場合、@4A と表現すれば 1 文字分圧縮されます。この規則で圧縮された文字列を入力してもとの文字列に復元するプログラムを作成してください。ただし、復元した文字列に＠文字は出現しないものとします。
</p>
<p>
また、原文の文字列は英大文字、英小文字、数字、記号であり 100 文字以内、連続する文字は 9 文字以内です。
</p>
<H2>入力</H2>
<p>複数の文字列が与えられます。１行に１つの文字列が与えられます。文字列の数は 50 を超えません。</p>
<H2>出力</H2>
<p>文字列ごとに、各文字に対して復元した文字列を１行に出力して下さい。
</p>
<H2>Sample Input</H2>
<pre>
ab@5C1@8050
@99+1=1@90
</pre>
<H2>Output for the Sample Input</H2>
<pre>
abCCCCC10000000050
999999999+1=1000000000
</pre>
| ab@5C1@8050
@99+1=1@90
| abCCCCC10000000050
999999999+1=1000000000
| 11,905 |
s072754683 | p00077 | u240091169 | 1591852697 | Python | Python3 | py | Accepted | 30 | 5600 | 325 | while True :
try :
s = list(input())
except EOFError :
break
i = 0
while i < len(s) :
if s[i] == "@" :
for j in range(int(s[i+1])) :
print(s[i+2], end="")
i += 3
else :
print(s[i], end="")
i += 1
print()
| p00077 |
<H1>ランレングス</H1>
<p>
文字列が連続した場合、ある規則で文字を置き換え文字列を短くすることができます。たとえば、AAAA という文字列の場合、@4A と表現すれば 1 文字分圧縮されます。この規則で圧縮された文字列を入力してもとの文字列に復元するプログラムを作成してください。ただし、復元した文字列に＠文字は出現しないものとします。
</p>
<p>
また、原文の文字列は英大文字、英小文字、数字、記号であり 100 文字以内、連続する文字は 9 文字以内です。
</p>
<H2>入力</H2>
<p>複数の文字列が与えられます。１行に１つの文字列が与えられます。文字列の数は 50 を超えません。</p>
<H2>出力</H2>
<p>文字列ごとに、各文字に対して復元した文字列を１行に出力して下さい。
</p>
<H2>Sample Input</H2>
<pre>
ab@5C1@8050
@99+1=1@90
</pre>
<H2>Output for the Sample Input</H2>
<pre>
abCCCCC10000000050
999999999+1=1000000000
</pre>
| ab@5C1@8050
@99+1=1@90
| abCCCCC10000000050
999999999+1=1000000000
| 11,906 |
s668705420 | p00077 | u260980560 | 1590422401 | Python | Python3 | py | Accepted | 20 | 5604 | 454 | import sys
readlines = sys.stdin.readlines
write = sys.stdout.write
def solve():
for line in readlines():
s = line.strip()
ans = []
L = len(s)
i = 0
while i < L:
if s[i] == "@":
k = int(s[i+1])
i += 2
else:
k = 1
c = s[i]
ans.append(c*k)
i += 1
write("".join(ans))
write("\n")
solve()
| p00077 |
<H1>ランレングス</H1>
<p>
文字列が連続した場合、ある規則で文字を置き換え文字列を短くすることができます。たとえば、AAAA という文字列の場合、@4A と表現すれば 1 文字分圧縮されます。この規則で圧縮された文字列を入力してもとの文字列に復元するプログラムを作成してください。ただし、復元した文字列に＠文字は出現しないものとします。
</p>
<p>
また、原文の文字列は英大文字、英小文字、数字、記号であり 100 文字以内、連続する文字は 9 文字以内です。
</p>
<H2>入力</H2>
<p>複数の文字列が与えられます。１行に１つの文字列が与えられます。文字列の数は 50 を超えません。</p>
<H2>出力</H2>
<p>文字列ごとに、各文字に対して復元した文字列を１行に出力して下さい。
</p>
<H2>Sample Input</H2>
<pre>
ab@5C1@8050
@99+1=1@90
</pre>
<H2>Output for the Sample Input</H2>
<pre>
abCCCCC10000000050
999999999+1=1000000000
</pre>
| ab@5C1@8050
@99+1=1@90
| abCCCCC10000000050
999999999+1=1000000000
| 11,907 |
s240773746 | p00077 | u842461513 | 1588558718 | Python | Python3 | py | Accepted | 20 | 5612 | 597 | try:
while True:
n = 0
str3 = []
str1 = input()
str2 = [a for a in str1]
num = len(str2)
for num1 in range(0,num):
if str2[num1] == "@":
for num2 in range(int(str2[num1 + 1])):
print(str2[num1 + 2],end="")
n = 2
continue
else:
if n > 0:
n -= 1
continue
else:
print(str2[num1],end="")
continue
print()
except EOFError as e:
n = 0
| p00077 |
<H1>ランレングス</H1>
<p>
文字列が連続した場合、ある規則で文字を置き換え文字列を短くすることができます。たとえば、AAAA という文字列の場合、@4A と表現すれば 1 文字分圧縮されます。この規則で圧縮された文字列を入力してもとの文字列に復元するプログラムを作成してください。ただし、復元した文字列に＠文字は出現しないものとします。
</p>
<p>
また、原文の文字列は英大文字、英小文字、数字、記号であり 100 文字以内、連続する文字は 9 文字以内です。
</p>
<H2>入力</H2>
<p>複数の文字列が与えられます。１行に１つの文字列が与えられます。文字列の数は 50 を超えません。</p>
<H2>出力</H2>
<p>文字列ごとに、各文字に対して復元した文字列を１行に出力して下さい。
</p>
<H2>Sample Input</H2>
<pre>
ab@5C1@8050
@99+1=1@90
</pre>
<H2>Output for the Sample Input</H2>
<pre>
abCCCCC10000000050
999999999+1=1000000000
</pre>
| ab@5C1@8050
@99+1=1@90
| abCCCCC10000000050
999999999+1=1000000000
| 11,908 |
s977216943 | p00077 | u630911389 | 1581626550 | Python | Python3 | py | Accepted | 20 | 5588 | 341 | while True:
try:
str = input()
ans = ''
# flag
n = 1
for c in str:
if '@' == c:
n = 0
elif n < 1:
n = int(c)
else:
ans += c * n
n = 1
print(ans)
except:
break
| p00077 |
<H1>ランレングス</H1>
<p>
文字列が連続した場合、ある規則で文字を置き換え文字列を短くすることができます。たとえば、AAAA という文字列の場合、@4A と表現すれば 1 文字分圧縮されます。この規則で圧縮された文字列を入力してもとの文字列に復元するプログラムを作成してください。ただし、復元した文字列に＠文字は出現しないものとします。
</p>
<p>
また、原文の文字列は英大文字、英小文字、数字、記号であり 100 文字以内、連続する文字は 9 文字以内です。
</p>
<H2>入力</H2>
<p>複数の文字列が与えられます。１行に１つの文字列が与えられます。文字列の数は 50 を超えません。</p>
<H2>出力</H2>
<p>文字列ごとに、各文字に対して復元した文字列を１行に出力して下さい。
</p>
<H2>Sample Input</H2>
<pre>
ab@5C1@8050
@99+1=1@90
</pre>
<H2>Output for the Sample Input</H2>
<pre>
abCCCCC10000000050
999999999+1=1000000000
</pre>
| ab@5C1@8050
@99+1=1@90
| abCCCCC10000000050
999999999+1=1000000000
| 11,909 |
s098055897 | p00077 | u153447291 | 1576584841 | Python | Python3 | py | Accepted | 20 | 5596 | 276 | while True:
try:
a = list(input())
except:
break
ans = ""
for i in range(len(a)-a.count("@")*2):
if a[i] == "@":
ans += a[i+2]*int(a[i+1])
del a[i+1:i+3]
else:
ans += a[i]
print(ans)
| p00077 |
<H1>ランレングス</H1>
<p>
文字列が連続した場合、ある規則で文字を置き換え文字列を短くすることができます。たとえば、AAAA という文字列の場合、@4A と表現すれば 1 文字分圧縮されます。この規則で圧縮された文字列を入力してもとの文字列に復元するプログラムを作成してください。ただし、復元した文字列に＠文字は出現しないものとします。
</p>
<p>
また、原文の文字列は英大文字、英小文字、数字、記号であり 100 文字以内、連続する文字は 9 文字以内です。
</p>
<H2>入力</H2>
<p>複数の文字列が与えられます。１行に１つの文字列が与えられます。文字列の数は 50 を超えません。</p>
<H2>出力</H2>
<p>文字列ごとに、各文字に対して復元した文字列を１行に出力して下さい。
</p>
<H2>Sample Input</H2>
<pre>
ab@5C1@8050
@99+1=1@90
</pre>
<H2>Output for the Sample Input</H2>
<pre>
abCCCCC10000000050
999999999+1=1000000000
</pre>
| ab@5C1@8050
@99+1=1@90
| abCCCCC10000000050
999999999+1=1000000000
| 11,910 |
s613645566 | p00077 | u350155409 | 1574260110 | Python | Python3 | py | Accepted | 20 | 5608 | 298 | import sys
r = []
for string in sys.stdin:
i = 0
s = ""
sin = string.strip()
while i < len(sin):
if sin[i] == '@':
s += sin[i+2] * int(sin[i+1])
i = i+3
else:
s += sin[i]
i += 1
r.append(s)
print(*r, sep='\n')
| p00077 |
<H1>ランレングス</H1>
<p>
文字列が連続した場合、ある規則で文字を置き換え文字列を短くすることができます。たとえば、AAAA という文字列の場合、@4A と表現すれば 1 文字分圧縮されます。この規則で圧縮された文字列を入力してもとの文字列に復元するプログラムを作成してください。ただし、復元した文字列に＠文字は出現しないものとします。
</p>
<p>
また、原文の文字列は英大文字、英小文字、数字、記号であり 100 文字以内、連続する文字は 9 文字以内です。
</p>
<H2>入力</H2>
<p>複数の文字列が与えられます。１行に１つの文字列が与えられます。文字列の数は 50 を超えません。</p>
<H2>出力</H2>
<p>文字列ごとに、各文字に対して復元した文字列を１行に出力して下さい。
</p>
<H2>Sample Input</H2>
<pre>
ab@5C1@8050
@99+1=1@90
</pre>
<H2>Output for the Sample Input</H2>
<pre>
abCCCCC10000000050
999999999+1=1000000000
</pre>
| ab@5C1@8050
@99+1=1@90
| abCCCCC10000000050
999999999+1=1000000000
| 11,911 |
s926325345 | p00077 | u824708460 | 1567509394 | Python | Python3 | py | Accepted | 20 | 5596 | 301 | while 1:
try:
s = input()
t = ''
i = 0
while i < len(s):
if s[i] == '@':
t += s[i + 2] * int(s[i + 1])
i += 3
else:
t += s[i]
i += 1
print(t)
except:
break
| p00077 |
<H1>ランレングス</H1>
<p>
文字列が連続した場合、ある規則で文字を置き換え文字列を短くすることができます。たとえば、AAAA という文字列の場合、@4A と表現すれば 1 文字分圧縮されます。この規則で圧縮された文字列を入力してもとの文字列に復元するプログラムを作成してください。ただし、復元した文字列に＠文字は出現しないものとします。
</p>
<p>
また、原文の文字列は英大文字、英小文字、数字、記号であり 100 文字以内、連続する文字は 9 文字以内です。
</p>
<H2>入力</H2>
<p>複数の文字列が与えられます。１行に１つの文字列が与えられます。文字列の数は 50 を超えません。</p>
<H2>出力</H2>
<p>文字列ごとに、各文字に対して復元した文字列を１行に出力して下さい。
</p>
<H2>Sample Input</H2>
<pre>
ab@5C1@8050
@99+1=1@90
</pre>
<H2>Output for the Sample Input</H2>
<pre>
abCCCCC10000000050
999999999+1=1000000000
</pre>
| ab@5C1@8050
@99+1=1@90
| abCCCCC10000000050
999999999+1=1000000000
| 11,912 |
s320377328 | p00077 | u678843586 | 1564834904 | Python | Python3 | py | Accepted | 20 | 5596 | 122 | import sys
for e in sys.stdin:
a,n='',1
for c in e[:-1]:
if'@'==c:n=0
elif n<1:n=int(c)
else:a+=c*n;n=1
print(a)
| p00077 |
<H1>ランレングス</H1>
<p>
文字列が連続した場合、ある規則で文字を置き換え文字列を短くすることができます。たとえば、AAAA という文字列の場合、@4A と表現すれば 1 文字分圧縮されます。この規則で圧縮された文字列を入力してもとの文字列に復元するプログラムを作成してください。ただし、復元した文字列に＠文字は出現しないものとします。
</p>
<p>
また、原文の文字列は英大文字、英小文字、数字、記号であり 100 文字以内、連続する文字は 9 文字以内です。
</p>
<H2>入力</H2>
<p>複数の文字列が与えられます。１行に１つの文字列が与えられます。文字列の数は 50 を超えません。</p>
<H2>出力</H2>
<p>文字列ごとに、各文字に対して復元した文字列を１行に出力して下さい。
</p>
<H2>Sample Input</H2>
<pre>
ab@5C1@8050
@99+1=1@90
</pre>
<H2>Output for the Sample Input</H2>
<pre>
abCCCCC10000000050
999999999+1=1000000000
</pre>
| ab@5C1@8050
@99+1=1@90
| abCCCCC10000000050
999999999+1=1000000000
| 11,913 |
s772143675 | p00077 | u548252256 | 1562329902 | Python | Python3 | py | Accepted | 20 | 5600 | 578 | if __name__ == '__main__':
ans = ""
while True:
try:
tmp = ""
ans = ""
line = input()
for x in line:
if x == "@":
tmp += "@"
else:
if len(tmp) == 0:
ans += x
else:
tmp += x
if len(tmp) == 3:
ans += tmp[2]*int(tmp[1])
tmp = ""
print(ans)
except EOFError:
break
| p00077 |
<H1>ランレングス</H1>
<p>
文字列が連続した場合、ある規則で文字を置き換え文字列を短くすることができます。たとえば、AAAA という文字列の場合、@4A と表現すれば 1 文字分圧縮されます。この規則で圧縮された文字列を入力してもとの文字列に復元するプログラムを作成してください。ただし、復元した文字列に＠文字は出現しないものとします。
</p>
<p>
また、原文の文字列は英大文字、英小文字、数字、記号であり 100 文字以内、連続する文字は 9 文字以内です。
</p>
<H2>入力</H2>
<p>複数の文字列が与えられます。１行に１つの文字列が与えられます。文字列の数は 50 を超えません。</p>
<H2>出力</H2>
<p>文字列ごとに、各文字に対して復元した文字列を１行に出力して下さい。
</p>
<H2>Sample Input</H2>
<pre>
ab@5C1@8050
@99+1=1@90
</pre>
<H2>Output for the Sample Input</H2>
<pre>
abCCCCC10000000050
999999999+1=1000000000
</pre>
| ab@5C1@8050
@99+1=1@90
| abCCCCC10000000050
999999999+1=1000000000
| 11,914 |
s926145962 | p00077 | u314166831 | 1562240647 | Python | Python3 | py | Accepted | 20 | 5632 | 1,519 | ###
### atcorder test program
###
import sys
### math class
class math:
### pi
pi = 3.14159265358979323846264338
### GCD
def gcd(self, a, b):
if b == 0:
return a
return self.gcd(b, a%b)
### LCM
def lcm(self, a, b):
return (a*b)//self.gcd(a,b)
### Prime number search
def Pnum(self, a):
if a == 1: return False
for i in range(2,int(a**0.5)+1):
if a % i == 0:
return False
return True
### Circle area
def caria(self, r):
return r*r*self.pi
math = math()
### input sample
#i = input()
#A, B, C = [x for x in input().split()]
#inlist = [int(w) for w in input().split()]
#R = float(input())
#A = [int(x) for x in input().split()]
#for line in sys.stdin.readlines():
# x, y = [int(temp) for temp in line.split()]
### output sample
#print("{0} {1} {2:.5f}".format(A//B, A%B, A/B))
#print("{0:.6f} {1:.6f}".format(R*R*math.pi,R*2*math.pi))
#print(" {}".format(i), end="")
#A, B, C = [int(x) for x in input().split()]
def get_input():
N = []
while True:
try:
N.append(input())
#N.append(int(input()))
except EOFError:
break
return N
N = get_input()
for S in N:
i = 0
while True:
if i >= len(S):
break
if (S[i]=='@'):
for j in range(int(S[i+1])):
print(S[i+2], end='')
i += 3
else:
print(S[i], end='')
i += 1
print()
| p00077 |
<H1>ランレングス</H1>
<p>
文字列が連続した場合、ある規則で文字を置き換え文字列を短くすることができます。たとえば、AAAA という文字列の場合、@4A と表現すれば 1 文字分圧縮されます。この規則で圧縮された文字列を入力してもとの文字列に復元するプログラムを作成してください。ただし、復元した文字列に＠文字は出現しないものとします。
</p>
<p>
また、原文の文字列は英大文字、英小文字、数字、記号であり 100 文字以内、連続する文字は 9 文字以内です。
</p>
<H2>入力</H2>
<p>複数の文字列が与えられます。１行に１つの文字列が与えられます。文字列の数は 50 を超えません。</p>
<H2>出力</H2>
<p>文字列ごとに、各文字に対して復元した文字列を１行に出力して下さい。
</p>
<H2>Sample Input</H2>
<pre>
ab@5C1@8050
@99+1=1@90
</pre>
<H2>Output for the Sample Input</H2>
<pre>
abCCCCC10000000050
999999999+1=1000000000
</pre>
| ab@5C1@8050
@99+1=1@90
| abCCCCC10000000050
999999999+1=1000000000
| 11,915 |
s193890925 | p00077 | u647694976 | 1559805366 | Python | Python3 | py | Accepted | 20 | 5596 | 353 | while 1:
try:
count = 0
answer = ""
N = list(input())
for i in N:
if i == "@":
answer += int(N[count + 1]) * N[count + 2]
del N[count], N[count + 1]
else:
answer += N[count]
count += 1
print(answer)
except:
break
| p00077 |
<H1>ランレングス</H1>
<p>
文字列が連続した場合、ある規則で文字を置き換え文字列を短くすることができます。たとえば、AAAA という文字列の場合、@4A と表現すれば 1 文字分圧縮されます。この規則で圧縮された文字列を入力してもとの文字列に復元するプログラムを作成してください。ただし、復元した文字列に＠文字は出現しないものとします。
</p>
<p>
また、原文の文字列は英大文字、英小文字、数字、記号であり 100 文字以内、連続する文字は 9 文字以内です。
</p>
<H2>入力</H2>
<p>複数の文字列が与えられます。１行に１つの文字列が与えられます。文字列の数は 50 を超えません。</p>
<H2>出力</H2>
<p>文字列ごとに、各文字に対して復元した文字列を１行に出力して下さい。
</p>
<H2>Sample Input</H2>
<pre>
ab@5C1@8050
@99+1=1@90
</pre>
<H2>Output for the Sample Input</H2>
<pre>
abCCCCC10000000050
999999999+1=1000000000
</pre>
| ab@5C1@8050
@99+1=1@90
| abCCCCC10000000050
999999999+1=1000000000
| 11,916 |
s444830688 | p00077 | u406093358 | 1555560630 | Python | Python | py | Accepted | 10 | 4644 | 279 | import sys
for line in sys.stdin:
s = line
ans = ''
flag = False
reg = 1
for i in range(0, len(s)-1):
if flag:
reg = int(s[i])
flag = False
else:
if s[i] == '@':
flag = True
else:
for j in range(0, reg):
ans = ans + s[i]
reg = 1
print ans
| p00077 |
<H1>ランレングス</H1>
<p>
文字列が連続した場合、ある規則で文字を置き換え文字列を短くすることができます。たとえば、AAAA という文字列の場合、@4A と表現すれば 1 文字分圧縮されます。この規則で圧縮された文字列を入力してもとの文字列に復元するプログラムを作成してください。ただし、復元した文字列に＠文字は出現しないものとします。
</p>
<p>
また、原文の文字列は英大文字、英小文字、数字、記号であり 100 文字以内、連続する文字は 9 文字以内です。
</p>
<H2>入力</H2>
<p>複数の文字列が与えられます。１行に１つの文字列が与えられます。文字列の数は 50 を超えません。</p>
<H2>出力</H2>
<p>文字列ごとに、各文字に対して復元した文字列を１行に出力して下さい。
</p>
<H2>Sample Input</H2>
<pre>
ab@5C1@8050
@99+1=1@90
</pre>
<H2>Output for the Sample Input</H2>
<pre>
abCCCCC10000000050
999999999+1=1000000000
</pre>
| ab@5C1@8050
@99+1=1@90
| abCCCCC10000000050
999999999+1=1000000000
| 11,917 |
s696163475 | p00077 | u990228206 | 1554280857 | Python | Python3 | py | Accepted | 20 | 5588 | 271 | while 1:
try:
s=list(input())
ans=""
while len(s)>0:
i=s.pop(0)
if i=="@":
c=s.pop(0)
l=s.pop(0)
ans+=l*int(c)
else:ans+=i
print(ans)
except:break
| p00077 |
<H1>ランレングス</H1>
<p>
文字列が連続した場合、ある規則で文字を置き換え文字列を短くすることができます。たとえば、AAAA という文字列の場合、@4A と表現すれば 1 文字分圧縮されます。この規則で圧縮された文字列を入力してもとの文字列に復元するプログラムを作成してください。ただし、復元した文字列に＠文字は出現しないものとします。
</p>
<p>
また、原文の文字列は英大文字、英小文字、数字、記号であり 100 文字以内、連続する文字は 9 文字以内です。
</p>
<H2>入力</H2>
<p>複数の文字列が与えられます。１行に１つの文字列が与えられます。文字列の数は 50 を超えません。</p>
<H2>出力</H2>
<p>文字列ごとに、各文字に対して復元した文字列を１行に出力して下さい。
</p>
<H2>Sample Input</H2>
<pre>
ab@5C1@8050
@99+1=1@90
</pre>
<H2>Output for the Sample Input</H2>
<pre>
abCCCCC10000000050
999999999+1=1000000000
</pre>
| ab@5C1@8050
@99+1=1@90
| abCCCCC10000000050
999999999+1=1000000000
| 11,918 |
s872498825 | p00077 | u563075864 | 1544937760 | Python | Python3 | py | Accepted | 20 | 5600 | 431 | while(1):
try:
s = list(input())
skip = 0
o = []
for i in range(len(s)):
if skip != 0:
skip -= 1
continue
if s[i] != "@":
o.append(s[i])
else:
skip = 2
for j in range(int(s[i+1])):
o.append(s[i+2])
print(*o,sep="")
except EOFError:
break
| p00077 |
<H1>ランレングス</H1>
<p>
文字列が連続した場合、ある規則で文字を置き換え文字列を短くすることができます。たとえば、AAAA という文字列の場合、@4A と表現すれば 1 文字分圧縮されます。この規則で圧縮された文字列を入力してもとの文字列に復元するプログラムを作成してください。ただし、復元した文字列に＠文字は出現しないものとします。
</p>
<p>
また、原文の文字列は英大文字、英小文字、数字、記号であり 100 文字以内、連続する文字は 9 文字以内です。
</p>
<H2>入力</H2>
<p>複数の文字列が与えられます。１行に１つの文字列が与えられます。文字列の数は 50 を超えません。</p>
<H2>出力</H2>
<p>文字列ごとに、各文字に対して復元した文字列を１行に出力して下さい。
</p>
<H2>Sample Input</H2>
<pre>
ab@5C1@8050
@99+1=1@90
</pre>
<H2>Output for the Sample Input</H2>
<pre>
abCCCCC10000000050
999999999+1=1000000000
</pre>
| ab@5C1@8050
@99+1=1@90
| abCCCCC10000000050
999999999+1=1000000000
| 11,919 |
s093673240 | p00077 | u717526540 | 1542703230 | Python | Python3 | py | Accepted | 20 | 5596 | 402 | while 1:
try:
word = input()
except EOFError:
break
newword = []
word = list(word)
while word != []:
w = word.pop(0)
if w == "@":
count = int(word.pop(0))
s = word.pop(0)
for _ in range(count):
newword.append(s)
else:
newword.append(w)
print(''.join(w for w in newword))
| p00077 |
<H1>ランレングス</H1>
<p>
文字列が連続した場合、ある規則で文字を置き換え文字列を短くすることができます。たとえば、AAAA という文字列の場合、@4A と表現すれば 1 文字分圧縮されます。この規則で圧縮された文字列を入力してもとの文字列に復元するプログラムを作成してください。ただし、復元した文字列に＠文字は出現しないものとします。
</p>
<p>
また、原文の文字列は英大文字、英小文字、数字、記号であり 100 文字以内、連続する文字は 9 文字以内です。
</p>
<H2>入力</H2>
<p>複数の文字列が与えられます。１行に１つの文字列が与えられます。文字列の数は 50 を超えません。</p>
<H2>出力</H2>
<p>文字列ごとに、各文字に対して復元した文字列を１行に出力して下さい。
</p>
<H2>Sample Input</H2>
<pre>
ab@5C1@8050
@99+1=1@90
</pre>
<H2>Output for the Sample Input</H2>
<pre>
abCCCCC10000000050
999999999+1=1000000000
</pre>
| ab@5C1@8050
@99+1=1@90
| abCCCCC10000000050
999999999+1=1000000000
| 11,920 |
s889052293 | p00077 | u219940997 | 1538964472 | Python | Python3 | py | Accepted | 20 | 5596 | 173 | while True:
try: n = input().split('@')
except: break
S, ans = n[1:], n[0]
for s in S:
ans += int(s[0]) * s[1]
ans += s[2:]
print(ans)
| p00077 |
<H1>ランレングス</H1>
<p>
文字列が連続した場合、ある規則で文字を置き換え文字列を短くすることができます。たとえば、AAAA という文字列の場合、@4A と表現すれば 1 文字分圧縮されます。この規則で圧縮された文字列を入力してもとの文字列に復元するプログラムを作成してください。ただし、復元した文字列に＠文字は出現しないものとします。
</p>
<p>
また、原文の文字列は英大文字、英小文字、数字、記号であり 100 文字以内、連続する文字は 9 文字以内です。
</p>
<H2>入力</H2>
<p>複数の文字列が与えられます。１行に１つの文字列が与えられます。文字列の数は 50 を超えません。</p>
<H2>出力</H2>
<p>文字列ごとに、各文字に対して復元した文字列を１行に出力して下さい。
</p>
<H2>Sample Input</H2>
<pre>
ab@5C1@8050
@99+1=1@90
</pre>
<H2>Output for the Sample Input</H2>
<pre>
abCCCCC10000000050
999999999+1=1000000000
</pre>
| ab@5C1@8050
@99+1=1@90
| abCCCCC10000000050
999999999+1=1000000000
| 11,921 |
s983971809 | p00078 | u197615397 | 1532089164 | Python | Python3 | py | Accepted | 30 | 5632 | 578 | import sys
for n in map(int, sys.stdin):
if not n:
break
a = [[-1]*(n+2)]+[[-1]+[0]*n+[-1] for _ in [0]*n]+[[-1]*(n+2)]
x, y = (n+1)//2, (n+1)//2+1
for i in range(1, n**2+1):
while a[y][x]:
if a[y][x] == -1:
if x in {0, n+1}:
x = (1, n)[x==0]
if y in {0, n+1}:
y = (1, n)[y==0]
else:
x, y = x-1, y+1
a[y][x] = i
x, y = x+1, y+1
for l in a[1:-1]:
print("".join(map(lambda x: "{:>4d}".format(x), l[1:-1])))
| p00078 |
<H1>魔方陣</H1>
<p>
<var>n</var> × <var>n</var> の正方形のマス目の中に数字の１から <var>n</var> × <var>n</var> が一つずつ入っていて、縦のどの列のマス目の和も、横のどの列のマス目の和も対角線のマス目の和も等しいものを魔方陣といいます。
</p>
<p>
一辺のマスの個数が奇数の魔方陣の作り方には以下の方法があります。
</p>
<ol>
<li>中央のマス目のちょうど一つ下のマス目に１を入れる。</li>
<li>次の数字を右斜め下のマス目に入れる。<br>ただし、数字を入れようとしたマス目が正方形からはみ出している場合、すでに数字が埋まっている場合は以下の方法に従って数字を入れるマス目を探す。</li>
<ul>
<li>右にはみ出した場合には、同じ行の左はしに、左にはみ出した場合には、同じ行の右はしに、下にはみ出した場合には、同じ列の一番上に数字を入れる。
</li>
<li> 数字を入れようとしたマス目が埋まっているときには、その埋まっているマス目の左斜め下のマス目に入れる。
</li>
</ul>
<li>全てのマス目が埋まるまで２を繰り返す。
</ol>
<p>
この方法に従って、一辺のマス目の個数 <var>n</var> を入力として、その大きさの魔方陣を出力するプログラムを作成して下さい。ただし、<var>n</var> は 3 以上 15 以下の奇数とします。マス目に入る各数字は右詰 4 桁で出力してください。
</p>
<H2>入力</H2>
<p>複数の入力が与えられます。各入力で <var>n</var> （正の整数）が１行に与えられます。入力は 0 で終了します。入力の数は 10 を超えません。</p>
<H2>出力</H2>
<p>各入力に対して <var>n</var> × <var>n</var> の魔方陣を出力して下さい。</p>
<H2>Sample Input</H2>
<pre>
3
5
0
</pre>
<H2>Output for the Sample Input</H2>
<pre>
4 9 2
3 5 7
8 1 6
11 24 7 20 3
4 12 25 8 16
17 5 13 21 9
10 18 1 14 22
23 6 19 2 15
</pre>
| 3
5
0
| 4 9 2
3 5 7
8 1 6
11 24 7 20 3
4 12 25 8 16
17 5 13 21 9
10 18 1 14 22
23 6 19 2 15
| 11,922 |
s513349173 | p00078 | u193025715 | 1407920216 | Python | Python | py | Accepted | 20 | 4248 | 416 | while True:
n = input()
if n == 0: break
board = [[0] * n for i in range(n)]
xp = n / 2
yp = n / 2 + 1
for i in range(n ** 2):
if board[yp][xp] == 0:
board[yp][xp] = i + 1
else:
xp -= 1
yp += 1
if xp == -1: xp = n - 1
if yp == n : yp = 0
board[yp][xp] = i + 1
yp += 1
xp += 1
if xp == n: xp = 0
if yp == n: yp = 0
for b in board:
print "".join(map(lambda x:str("% 4d" % x), b)) | p00078 |
<H1>魔方陣</H1>
<p>
<var>n</var> × <var>n</var> の正方形のマス目の中に数字の１から <var>n</var> × <var>n</var> が一つずつ入っていて、縦のどの列のマス目の和も、横のどの列のマス目の和も対角線のマス目の和も等しいものを魔方陣といいます。
</p>
<p>
一辺のマスの個数が奇数の魔方陣の作り方には以下の方法があります。
</p>
<ol>
<li>中央のマス目のちょうど一つ下のマス目に１を入れる。</li>
<li>次の数字を右斜め下のマス目に入れる。<br>ただし、数字を入れようとしたマス目が正方形からはみ出している場合、すでに数字が埋まっている場合は以下の方法に従って数字を入れるマス目を探す。</li>
<ul>
<li>右にはみ出した場合には、同じ行の左はしに、左にはみ出した場合には、同じ行の右はしに、下にはみ出した場合には、同じ列の一番上に数字を入れる。
</li>
<li> 数字を入れようとしたマス目が埋まっているときには、その埋まっているマス目の左斜め下のマス目に入れる。
</li>
</ul>
<li>全てのマス目が埋まるまで２を繰り返す。
</ol>
<p>
この方法に従って、一辺のマス目の個数 <var>n</var> を入力として、その大きさの魔方陣を出力するプログラムを作成して下さい。ただし、<var>n</var> は 3 以上 15 以下の奇数とします。マス目に入る各数字は右詰 4 桁で出力してください。
</p>
<H2>入力</H2>
<p>複数の入力が与えられます。各入力で <var>n</var> （正の整数）が１行に与えられます。入力は 0 で終了します。入力の数は 10 を超えません。</p>
<H2>出力</H2>
<p>各入力に対して <var>n</var> × <var>n</var> の魔方陣を出力して下さい。</p>
<H2>Sample Input</H2>
<pre>
3
5
0
</pre>
<H2>Output for the Sample Input</H2>
<pre>
4 9 2
3 5 7
8 1 6
11 24 7 20 3
4 12 25 8 16
17 5 13 21 9
10 18 1 14 22
23 6 19 2 15
</pre>
| 3
5
0
| 4 9 2
3 5 7
8 1 6
11 24 7 20 3
4 12 25 8 16
17 5 13 21 9
10 18 1 14 22
23 6 19 2 15
| 11,923 |
s184127271 | p00078 | u506132575 | 1417588275 | Python | Python | py | Accepted | 20 | 4268 | 726 | def chekend(mc):
for m in mc:
if not all(m):
return False
return True
def solve(n):
mc = [ [ 0 for j in xrange(n) ] for i in xrange(n)]
px = n/2
py = n/2 + 1
cnt = 1
mc[py][px] = cnt
px += 1
py += 1
cnt += 1
while True:
if chekend(mc): break
if px >= n: px = 0; continue
if px < 0: px = n-1; continue
if py >= n: py = 0; continue
if mc[py][px]: px -= 1; py += 1; continue
mc[py][px] = cnt
cnt += 1
px += 1
py += 1
for m in mc:
line = ""
for l in m:
line += "%4d"%(l)
print line
while True:
n = input()
if n == 0:
break
solve(n) | p00078 |
<H1>魔方陣</H1>
<p>
<var>n</var> × <var>n</var> の正方形のマス目の中に数字の１から <var>n</var> × <var>n</var> が一つずつ入っていて、縦のどの列のマス目の和も、横のどの列のマス目の和も対角線のマス目の和も等しいものを魔方陣といいます。
</p>
<p>
一辺のマスの個数が奇数の魔方陣の作り方には以下の方法があります。
</p>
<ol>
<li>中央のマス目のちょうど一つ下のマス目に１を入れる。</li>
<li>次の数字を右斜め下のマス目に入れる。<br>ただし、数字を入れようとしたマス目が正方形からはみ出している場合、すでに数字が埋まっている場合は以下の方法に従って数字を入れるマス目を探す。</li>
<ul>
<li>右にはみ出した場合には、同じ行の左はしに、左にはみ出した場合には、同じ行の右はしに、下にはみ出した場合には、同じ列の一番上に数字を入れる。
</li>
<li> 数字を入れようとしたマス目が埋まっているときには、その埋まっているマス目の左斜め下のマス目に入れる。
</li>
</ul>
<li>全てのマス目が埋まるまで２を繰り返す。
</ol>
<p>
この方法に従って、一辺のマス目の個数 <var>n</var> を入力として、その大きさの魔方陣を出力するプログラムを作成して下さい。ただし、<var>n</var> は 3 以上 15 以下の奇数とします。マス目に入る各数字は右詰 4 桁で出力してください。
</p>
<H2>入力</H2>
<p>複数の入力が与えられます。各入力で <var>n</var> （正の整数）が１行に与えられます。入力は 0 で終了します。入力の数は 10 を超えません。</p>
<H2>出力</H2>
<p>各入力に対して <var>n</var> × <var>n</var> の魔方陣を出力して下さい。</p>
<H2>Sample Input</H2>
<pre>
3
5
0
</pre>
<H2>Output for the Sample Input</H2>
<pre>
4 9 2
3 5 7
8 1 6
11 24 7 20 3
4 12 25 8 16
17 5 13 21 9
10 18 1 14 22
23 6 19 2 15
</pre>
| 3
5
0
| 4 9 2
3 5 7
8 1 6
11 24 7 20 3
4 12 25 8 16
17 5 13 21 9
10 18 1 14 22
23 6 19 2 15
| 11,924 |
s726191517 | p00078 | u567380442 | 1423290455 | Python | Python3 | py | Accepted | 30 | 6752 | 797 | import sys
f = sys.stdin
def set1(sq):
x = len(sq) // 2
y = len(sq) // 2 + 1
square[y][x] = 1
return x, y, 1
def mv_r(sq, x, y):
x = (x + 1) % len(sq)
y = (y + 1) % len(sq)
return x, y
def mv_l(sq, x, y):
x -= 1
if x < 0:
x += len(sq)
y = (y + 1) % len(sq)
return x, y
def setnext(sq, x, y, i):
x, y = mv_r(sq, x,y)
i += 1
while sq[y][x]:
x, y = mv_l(sq, x, y)
sq[y][x] = i
return x, y, i
while True:
n = int(f.readline())
if n == 0:
break
square = [[None for j in range(n)] for i in range(n)]
arg = set1(square)
for i in range(n * n - 1):
arg = setnext(square,*arg)
for line in square:
for num in line:
print("{:4d}".format(num),end='')
print() | p00078 |
<H1>魔方陣</H1>
<p>
<var>n</var> × <var>n</var> の正方形のマス目の中に数字の１から <var>n</var> × <var>n</var> が一つずつ入っていて、縦のどの列のマス目の和も、横のどの列のマス目の和も対角線のマス目の和も等しいものを魔方陣といいます。
</p>
<p>
一辺のマスの個数が奇数の魔方陣の作り方には以下の方法があります。
</p>
<ol>
<li>中央のマス目のちょうど一つ下のマス目に１を入れる。</li>
<li>次の数字を右斜め下のマス目に入れる。<br>ただし、数字を入れようとしたマス目が正方形からはみ出している場合、すでに数字が埋まっている場合は以下の方法に従って数字を入れるマス目を探す。</li>
<ul>
<li>右にはみ出した場合には、同じ行の左はしに、左にはみ出した場合には、同じ行の右はしに、下にはみ出した場合には、同じ列の一番上に数字を入れる。
</li>
<li> 数字を入れようとしたマス目が埋まっているときには、その埋まっているマス目の左斜め下のマス目に入れる。
</li>
</ul>
<li>全てのマス目が埋まるまで２を繰り返す。
</ol>
<p>
この方法に従って、一辺のマス目の個数 <var>n</var> を入力として、その大きさの魔方陣を出力するプログラムを作成して下さい。ただし、<var>n</var> は 3 以上 15 以下の奇数とします。マス目に入る各数字は右詰 4 桁で出力してください。
</p>
<H2>入力</H2>
<p>複数の入力が与えられます。各入力で <var>n</var> （正の整数）が１行に与えられます。入力は 0 で終了します。入力の数は 10 を超えません。</p>
<H2>出力</H2>
<p>各入力に対して <var>n</var> × <var>n</var> の魔方陣を出力して下さい。</p>
<H2>Sample Input</H2>
<pre>
3
5
0
</pre>
<H2>Output for the Sample Input</H2>
<pre>
4 9 2
3 5 7
8 1 6
11 24 7 20 3
4 12 25 8 16
17 5 13 21 9
10 18 1 14 22
23 6 19 2 15
</pre>
| 3
5
0
| 4 9 2
3 5 7
8 1 6
11 24 7 20 3
4 12 25 8 16
17 5 13 21 9
10 18 1 14 22
23 6 19 2 15
| 11,925 |
s861666892 | p00078 | u540744789 | 1427284254 | Python | Python | py | Accepted | 20 | 4248 | 504 | import sys
while True:
n=input()
if n==0:
break
magic=[[0 for i in range(n)] for j in range(n)]
i=n/2
j=n/2+1
for number in range(1,n*n+1):
magic[j][i]=number
if number==n*n:
break
if magic[(j+1)%n][(i+1)%n]==0:
i,j=(i+1)%n,(j+1)%n
else:
i,j=(i+1)%n,(j+1)%n
while magic[j][i]!=0:
i,j=(i-1)%n,(j+1)%n
for i in range(n):
print "".join(["%4d" %(e) for e in magic[i]]) | p00078 |
<H1>魔方陣</H1>
<p>
<var>n</var> × <var>n</var> の正方形のマス目の中に数字の１から <var>n</var> × <var>n</var> が一つずつ入っていて、縦のどの列のマス目の和も、横のどの列のマス目の和も対角線のマス目の和も等しいものを魔方陣といいます。
</p>
<p>
一辺のマスの個数が奇数の魔方陣の作り方には以下の方法があります。
</p>
<ol>
<li>中央のマス目のちょうど一つ下のマス目に１を入れる。</li>
<li>次の数字を右斜め下のマス目に入れる。<br>ただし、数字を入れようとしたマス目が正方形からはみ出している場合、すでに数字が埋まっている場合は以下の方法に従って数字を入れるマス目を探す。</li>
<ul>
<li>右にはみ出した場合には、同じ行の左はしに、左にはみ出した場合には、同じ行の右はしに、下にはみ出した場合には、同じ列の一番上に数字を入れる。
</li>
<li> 数字を入れようとしたマス目が埋まっているときには、その埋まっているマス目の左斜め下のマス目に入れる。
</li>
</ul>
<li>全てのマス目が埋まるまで２を繰り返す。
</ol>
<p>
この方法に従って、一辺のマス目の個数 <var>n</var> を入力として、その大きさの魔方陣を出力するプログラムを作成して下さい。ただし、<var>n</var> は 3 以上 15 以下の奇数とします。マス目に入る各数字は右詰 4 桁で出力してください。
</p>
<H2>入力</H2>
<p>複数の入力が与えられます。各入力で <var>n</var> （正の整数）が１行に与えられます。入力は 0 で終了します。入力の数は 10 を超えません。</p>
<H2>出力</H2>
<p>各入力に対して <var>n</var> × <var>n</var> の魔方陣を出力して下さい。</p>
<H2>Sample Input</H2>
<pre>
3
5
0
</pre>
<H2>Output for the Sample Input</H2>
<pre>
4 9 2
3 5 7
8 1 6
11 24 7 20 3
4 12 25 8 16
17 5 13 21 9
10 18 1 14 22
23 6 19 2 15
</pre>
| 3
5
0
| 4 9 2
3 5 7
8 1 6
11 24 7 20 3
4 12 25 8 16
17 5 13 21 9
10 18 1 14 22
23 6 19 2 15
| 11,926 |
s505804580 | p00078 | u775586391 | 1449732236 | Python | Python3 | py | Accepted | 30 | 7796 | 658 | while True:
n = int(input())
if n==0:
break
else:
l = [[0 for i in range(n)] for j in range(n)]
x = n//2
y = n//2+1
c = 0
while c < n**2:
c += 1
while l[y][x] != 0:
y += 1
if y >= n:
y = 0
x -= 1
if x <= -1:
x = n-1
l[y][x] = c
x += 1
if x >= n:
x = 0
y += 1
if y >= n:
y = 0
for i in l:
a = ''
for j in i:
if 0 <= j < 10**1:
a = a + ' ' + str(j)
elif 10**1<=j<10**2:
a = a + ' ' + str(j)
elif 10**2<=j<10**3:
a = a + ' ' + str(j)
print(a) | p00078 |
<H1>魔方陣</H1>
<p>
<var>n</var> × <var>n</var> の正方形のマス目の中に数字の１から <var>n</var> × <var>n</var> が一つずつ入っていて、縦のどの列のマス目の和も、横のどの列のマス目の和も対角線のマス目の和も等しいものを魔方陣といいます。
</p>
<p>
一辺のマスの個数が奇数の魔方陣の作り方には以下の方法があります。
</p>
<ol>
<li>中央のマス目のちょうど一つ下のマス目に１を入れる。</li>
<li>次の数字を右斜め下のマス目に入れる。<br>ただし、数字を入れようとしたマス目が正方形からはみ出している場合、すでに数字が埋まっている場合は以下の方法に従って数字を入れるマス目を探す。</li>
<ul>
<li>右にはみ出した場合には、同じ行の左はしに、左にはみ出した場合には、同じ行の右はしに、下にはみ出した場合には、同じ列の一番上に数字を入れる。
</li>
<li> 数字を入れようとしたマス目が埋まっているときには、その埋まっているマス目の左斜め下のマス目に入れる。
</li>
</ul>
<li>全てのマス目が埋まるまで２を繰り返す。
</ol>
<p>
この方法に従って、一辺のマス目の個数 <var>n</var> を入力として、その大きさの魔方陣を出力するプログラムを作成して下さい。ただし、<var>n</var> は 3 以上 15 以下の奇数とします。マス目に入る各数字は右詰 4 桁で出力してください。
</p>
<H2>入力</H2>
<p>複数の入力が与えられます。各入力で <var>n</var> （正の整数）が１行に与えられます。入力は 0 で終了します。入力の数は 10 を超えません。</p>
<H2>出力</H2>
<p>各入力に対して <var>n</var> × <var>n</var> の魔方陣を出力して下さい。</p>
<H2>Sample Input</H2>
<pre>
3
5
0
</pre>
<H2>Output for the Sample Input</H2>
<pre>
4 9 2
3 5 7
8 1 6
11 24 7 20 3
4 12 25 8 16
17 5 13 21 9
10 18 1 14 22
23 6 19 2 15
</pre>
| 3
5
0
| 4 9 2
3 5 7
8 1 6
11 24 7 20 3
4 12 25 8 16
17 5 13 21 9
10 18 1 14 22
23 6 19 2 15
| 11,927 |
s697128699 | p00078 | u140201022 | 1451309015 | Python | Python | py | Accepted | 10 | 6356 | 418 |
while 1:
n=int(raw_input())
if n==0:
break
l=[[0]*n for i in range(n)]
x,y=n/2,n/2+1
l[y][x]=1
cnt=2
while cnt<=n**2:
x,y=(x+1)%n,(y+1)%n
if l[y][x]==0:
l[y][x]=cnt
cnt+=1
else:
x,y=(x-1)%n,(y+1)%n
l[y][x]=cnt
cnt+=1
for i in range(n):
print ''.join(map(lambda s:str(s).rjust(4),l[i])) | p00078 |
<H1>魔方陣</H1>
<p>
<var>n</var> × <var>n</var> の正方形のマス目の中に数字の１から <var>n</var> × <var>n</var> が一つずつ入っていて、縦のどの列のマス目の和も、横のどの列のマス目の和も対角線のマス目の和も等しいものを魔方陣といいます。
</p>
<p>
一辺のマスの個数が奇数の魔方陣の作り方には以下の方法があります。
</p>
<ol>
<li>中央のマス目のちょうど一つ下のマス目に１を入れる。</li>
<li>次の数字を右斜め下のマス目に入れる。<br>ただし、数字を入れようとしたマス目が正方形からはみ出している場合、すでに数字が埋まっている場合は以下の方法に従って数字を入れるマス目を探す。</li>
<ul>
<li>右にはみ出した場合には、同じ行の左はしに、左にはみ出した場合には、同じ行の右はしに、下にはみ出した場合には、同じ列の一番上に数字を入れる。
</li>
<li> 数字を入れようとしたマス目が埋まっているときには、その埋まっているマス目の左斜め下のマス目に入れる。
</li>
</ul>
<li>全てのマス目が埋まるまで２を繰り返す。
</ol>
<p>
この方法に従って、一辺のマス目の個数 <var>n</var> を入力として、その大きさの魔方陣を出力するプログラムを作成して下さい。ただし、<var>n</var> は 3 以上 15 以下の奇数とします。マス目に入る各数字は右詰 4 桁で出力してください。
</p>
<H2>入力</H2>
<p>複数の入力が与えられます。各入力で <var>n</var> （正の整数）が１行に与えられます。入力は 0 で終了します。入力の数は 10 を超えません。</p>
<H2>出力</H2>
<p>各入力に対して <var>n</var> × <var>n</var> の魔方陣を出力して下さい。</p>
<H2>Sample Input</H2>
<pre>
3
5
0
</pre>
<H2>Output for the Sample Input</H2>
<pre>
4 9 2
3 5 7
8 1 6
11 24 7 20 3
4 12 25 8 16
17 5 13 21 9
10 18 1 14 22
23 6 19 2 15
</pre>
| 3
5
0
| 4 9 2
3 5 7
8 1 6
11 24 7 20 3
4 12 25 8 16
17 5 13 21 9
10 18 1 14 22
23 6 19 2 15
| 11,928 |
s747114178 | p00078 | u894114233 | 1476612672 | Python | Python | py | Accepted | 10 | 6284 | 736 | def check_space(y,x):
if g[y][x]==-1:
return True
return False
while 1:
n=int(raw_input())
if n==0:break
g=[[-1]*n for _ in xrange(n)]
for i in xrange(1,n**2+1):
if i==1:
g[n/2+1][n/2]="1"
nowy=n/2+1
nowx=n/2
continue
while 1:
if check_space((nowy+1)%n,(nowx+1)%n):
g[(nowy+1)%n][(nowx+1)%n]=str(i)
nowy=(nowy+1)%n
nowx=(nowx+1)%n
break
else:
nowy=(nowy+1)%n
nowx=(nowx-1)%n
continue
for i in xrange(n):
tmp=""
for j in xrange(n):
tmp+=g[i][j].rjust(4)
print(tmp) | p00078 |
<H1>魔方陣</H1>
<p>
<var>n</var> × <var>n</var> の正方形のマス目の中に数字の１から <var>n</var> × <var>n</var> が一つずつ入っていて、縦のどの列のマス目の和も、横のどの列のマス目の和も対角線のマス目の和も等しいものを魔方陣といいます。
</p>
<p>
一辺のマスの個数が奇数の魔方陣の作り方には以下の方法があります。
</p>
<ol>
<li>中央のマス目のちょうど一つ下のマス目に１を入れる。</li>
<li>次の数字を右斜め下のマス目に入れる。<br>ただし、数字を入れようとしたマス目が正方形からはみ出している場合、すでに数字が埋まっている場合は以下の方法に従って数字を入れるマス目を探す。</li>
<ul>
<li>右にはみ出した場合には、同じ行の左はしに、左にはみ出した場合には、同じ行の右はしに、下にはみ出した場合には、同じ列の一番上に数字を入れる。
</li>
<li> 数字を入れようとしたマス目が埋まっているときには、その埋まっているマス目の左斜め下のマス目に入れる。
</li>
</ul>
<li>全てのマス目が埋まるまで２を繰り返す。
</ol>
<p>
この方法に従って、一辺のマス目の個数 <var>n</var> を入力として、その大きさの魔方陣を出力するプログラムを作成して下さい。ただし、<var>n</var> は 3 以上 15 以下の奇数とします。マス目に入る各数字は右詰 4 桁で出力してください。
</p>
<H2>入力</H2>
<p>複数の入力が与えられます。各入力で <var>n</var> （正の整数）が１行に与えられます。入力は 0 で終了します。入力の数は 10 を超えません。</p>
<H2>出力</H2>
<p>各入力に対して <var>n</var> × <var>n</var> の魔方陣を出力して下さい。</p>
<H2>Sample Input</H2>
<pre>
3
5
0
</pre>
<H2>Output for the Sample Input</H2>
<pre>
4 9 2
3 5 7
8 1 6
11 24 7 20 3
4 12 25 8 16
17 5 13 21 9
10 18 1 14 22
23 6 19 2 15
</pre>
| 3
5
0
| 4 9 2
3 5 7
8 1 6
11 24 7 20 3
4 12 25 8 16
17 5 13 21 9
10 18 1 14 22
23 6 19 2 15
| 11,929 |
s416470230 | p00078 | u462831976 | 1493349728 | Python | Python3 | py | Accepted | 30 | 7792 | 749 | # -*- coding: utf-8 -*-
import sys
import os
import math
for s in sys.stdin:
n = int(s)
if n == 0:
break
M = [[None for i in range(n)] for j in range(n)]
# 1
x = n // 2
y = n // 2 + 1
M[y][x] = 1
x = x + 1
y = y + 1
counter = 2
while counter < n * n + 1:
if x >= n:
x = 0
elif x < 0:
x = n - 1
if y >= n:
y = 0
elif y < 0:
y = n - 1
if M[y][x] is not None:
x -= 1
y += 1
else:
M[y][x] = counter
counter += 1
x += 1
y += 1
for row in M:
for v in row:
print(str(v).rjust(4), end='')
print() | p00078 |
<H1>魔方陣</H1>
<p>
<var>n</var> × <var>n</var> の正方形のマス目の中に数字の１から <var>n</var> × <var>n</var> が一つずつ入っていて、縦のどの列のマス目の和も、横のどの列のマス目の和も対角線のマス目の和も等しいものを魔方陣といいます。
</p>
<p>
一辺のマスの個数が奇数の魔方陣の作り方には以下の方法があります。
</p>
<ol>
<li>中央のマス目のちょうど一つ下のマス目に１を入れる。</li>
<li>次の数字を右斜め下のマス目に入れる。<br>ただし、数字を入れようとしたマス目が正方形からはみ出している場合、すでに数字が埋まっている場合は以下の方法に従って数字を入れるマス目を探す。</li>
<ul>
<li>右にはみ出した場合には、同じ行の左はしに、左にはみ出した場合には、同じ行の右はしに、下にはみ出した場合には、同じ列の一番上に数字を入れる。
</li>
<li> 数字を入れようとしたマス目が埋まっているときには、その埋まっているマス目の左斜め下のマス目に入れる。
</li>
</ul>
<li>全てのマス目が埋まるまで２を繰り返す。
</ol>
<p>
この方法に従って、一辺のマス目の個数 <var>n</var> を入力として、その大きさの魔方陣を出力するプログラムを作成して下さい。ただし、<var>n</var> は 3 以上 15 以下の奇数とします。マス目に入る各数字は右詰 4 桁で出力してください。
</p>
<H2>入力</H2>
<p>複数の入力が与えられます。各入力で <var>n</var> （正の整数）が１行に与えられます。入力は 0 で終了します。入力の数は 10 を超えません。</p>
<H2>出力</H2>
<p>各入力に対して <var>n</var> × <var>n</var> の魔方陣を出力して下さい。</p>
<H2>Sample Input</H2>
<pre>
3
5
0
</pre>
<H2>Output for the Sample Input</H2>
<pre>
4 9 2
3 5 7
8 1 6
11 24 7 20 3
4 12 25 8 16
17 5 13 21 9
10 18 1 14 22
23 6 19 2 15
</pre>
| 3
5
0
| 4 9 2
3 5 7
8 1 6
11 24 7 20 3
4 12 25 8 16
17 5 13 21 9
10 18 1 14 22
23 6 19 2 15
| 11,930 |
s669271271 | p00078 | u519227872 | 1498837789 | Python | Python3 | py | Accepted | 30 | 7588 | 565 | from sys import stdin
def sqmatrix(n):
return [[0] * n for i in range(n)]
def magicsq(m):
n = len(m)
j = int(n/2)
i = j + 1
for num in range(1, n**2 + 1):
m[i][j] = num
i += 1
j += 1
i = i%n
j = j % n
if m[i][j] != 0:
i += 1
j -= 1
if j < 0:
j = n -1
i = i % n
return m
for line in stdin:
n = int(line)
if n == 0:
break
sm = sqmatrix(n)
for row in magicsq(sm): print (''.join(map(lambda x: str(x).rjust(4, ' '),row))) | p00078 |
<H1>魔方陣</H1>
<p>
<var>n</var> × <var>n</var> の正方形のマス目の中に数字の１から <var>n</var> × <var>n</var> が一つずつ入っていて、縦のどの列のマス目の和も、横のどの列のマス目の和も対角線のマス目の和も等しいものを魔方陣といいます。
</p>
<p>
一辺のマスの個数が奇数の魔方陣の作り方には以下の方法があります。
</p>
<ol>
<li>中央のマス目のちょうど一つ下のマス目に１を入れる。</li>
<li>次の数字を右斜め下のマス目に入れる。<br>ただし、数字を入れようとしたマス目が正方形からはみ出している場合、すでに数字が埋まっている場合は以下の方法に従って数字を入れるマス目を探す。</li>
<ul>
<li>右にはみ出した場合には、同じ行の左はしに、左にはみ出した場合には、同じ行の右はしに、下にはみ出した場合には、同じ列の一番上に数字を入れる。
</li>
<li> 数字を入れようとしたマス目が埋まっているときには、その埋まっているマス目の左斜め下のマス目に入れる。
</li>
</ul>
<li>全てのマス目が埋まるまで２を繰り返す。
</ol>
<p>
この方法に従って、一辺のマス目の個数 <var>n</var> を入力として、その大きさの魔方陣を出力するプログラムを作成して下さい。ただし、<var>n</var> は 3 以上 15 以下の奇数とします。マス目に入る各数字は右詰 4 桁で出力してください。
</p>
<H2>入力</H2>
<p>複数の入力が与えられます。各入力で <var>n</var> （正の整数）が１行に与えられます。入力は 0 で終了します。入力の数は 10 を超えません。</p>
<H2>出力</H2>
<p>各入力に対して <var>n</var> × <var>n</var> の魔方陣を出力して下さい。</p>
<H2>Sample Input</H2>
<pre>
3
5
0
</pre>
<H2>Output for the Sample Input</H2>
<pre>
4 9 2
3 5 7
8 1 6
11 24 7 20 3
4 12 25 8 16
17 5 13 21 9
10 18 1 14 22
23 6 19 2 15
</pre>
| 3
5
0
| 4 9 2
3 5 7
8 1 6
11 24 7 20 3
4 12 25 8 16
17 5 13 21 9
10 18 1 14 22
23 6 19 2 15
| 11,931 |
s199105828 | p00078 | u811733736 | 1503323643 | Python | Python3 | py | Accepted | 30 | 7656 | 1,407 | # -*- coding: utf-8 -*-
"""
http://judge.u-aizu.ac.jp/onlinejudge/description.jsp?id=0078
"""
import sys
class MagicSquare():
def __init__(self, size):
self.size = size
self.data = [['@']*self.size for _ in range(self.size)]
self.fill_data()
def fill_data(self):
num = 1
x = self.size // 2
y = x + 1
self.data[y][x] = num
while num < self.size**2:
x += 1
if x >= self.size:
x = 0
y += 1
if y >= self.size:
y = 0
if self.data[y][x] == '@':
num += 1
self.data[y][x] = num
else:
while self.data[y][x] != '@':
x -= 1
if x < 0:
x = self.size - 1
y += 1
if y >= self.size:
y = 0
num += 1
self.data[y][x] = num
def print_data(self):
for row in self.data:
temp = ""
for d in row:
temp += str(d).rjust(4)
print(temp)
temp = ""
def main(args):
while True:
size = int(input())
if size < 3 or size%2 == 0:
break
ms = MagicSquare(size)
ms.print_data()
if __name__ == '__main__':
main(sys.argv[1:]) | p00078 |
<H1>魔方陣</H1>
<p>
<var>n</var> × <var>n</var> の正方形のマス目の中に数字の１から <var>n</var> × <var>n</var> が一つずつ入っていて、縦のどの列のマス目の和も、横のどの列のマス目の和も対角線のマス目の和も等しいものを魔方陣といいます。
</p>
<p>
一辺のマスの個数が奇数の魔方陣の作り方には以下の方法があります。
</p>
<ol>
<li>中央のマス目のちょうど一つ下のマス目に１を入れる。</li>
<li>次の数字を右斜め下のマス目に入れる。<br>ただし、数字を入れようとしたマス目が正方形からはみ出している場合、すでに数字が埋まっている場合は以下の方法に従って数字を入れるマス目を探す。</li>
<ul>
<li>右にはみ出した場合には、同じ行の左はしに、左にはみ出した場合には、同じ行の右はしに、下にはみ出した場合には、同じ列の一番上に数字を入れる。
</li>
<li> 数字を入れようとしたマス目が埋まっているときには、その埋まっているマス目の左斜め下のマス目に入れる。
</li>
</ul>
<li>全てのマス目が埋まるまで２を繰り返す。
</ol>
<p>
この方法に従って、一辺のマス目の個数 <var>n</var> を入力として、その大きさの魔方陣を出力するプログラムを作成して下さい。ただし、<var>n</var> は 3 以上 15 以下の奇数とします。マス目に入る各数字は右詰 4 桁で出力してください。
</p>
<H2>入力</H2>
<p>複数の入力が与えられます。各入力で <var>n</var> （正の整数）が１行に与えられます。入力は 0 で終了します。入力の数は 10 を超えません。</p>
<H2>出力</H2>
<p>各入力に対して <var>n</var> × <var>n</var> の魔方陣を出力して下さい。</p>
<H2>Sample Input</H2>
<pre>
3
5
0
</pre>
<H2>Output for the Sample Input</H2>
<pre>
4 9 2
3 5 7
8 1 6
11 24 7 20 3
4 12 25 8 16
17 5 13 21 9
10 18 1 14 22
23 6 19 2 15
</pre>
| 3
5
0
| 4 9 2
3 5 7
8 1 6
11 24 7 20 3
4 12 25 8 16
17 5 13 21 9
10 18 1 14 22
23 6 19 2 15
| 11,932 |
s800356499 | p00078 | u957021183 | 1505123167 | Python | Python3 | py | Accepted | 50 | 7828 | 1,069 | # Aizu Problem 0078: Magic Square
#
import sys, math, os
# read input:
PYDEV = os.environ.get('PYDEV')
if PYDEV=="True":
sys.stdin = open("sample-input.txt", "rt")
def magic_square(n):
sq = [[0 for _ in range(16)] for __ in range(16)]
nowx, nowy = n // 2, n // 2 + 1
sq[nowy][nowx] = 1
for i in range(2, n**2 + 1):
nowx += 1
nowy += 1
while True:
if nowx >= n:
nowx = 0
if nowx < 0:
nowx = n - 1
if nowy >= n:
nowy = 0
if sq[nowy][nowx] != 0:
nowx -= 1
nowy += 1
if sq[nowy][nowx] == 0 and 0 <= nowx and nowx < n and 0 <= nowy and nowy < n:
break
sq[nowy][nowx] = i
return sq[:n]
while True:
n = int(input())
if n == 0:
break
sq = magic_square(n)
for row in sq:
out = ""
for k in row[:n]:
ks = str(k)
ks = ' ' * (4 - len(ks)) + ks
out += ks
print(out)
| p00078 |
<H1>魔方陣</H1>
<p>
<var>n</var> × <var>n</var> の正方形のマス目の中に数字の１から <var>n</var> × <var>n</var> が一つずつ入っていて、縦のどの列のマス目の和も、横のどの列のマス目の和も対角線のマス目の和も等しいものを魔方陣といいます。
</p>
<p>
一辺のマスの個数が奇数の魔方陣の作り方には以下の方法があります。
</p>
<ol>
<li>中央のマス目のちょうど一つ下のマス目に１を入れる。</li>
<li>次の数字を右斜め下のマス目に入れる。<br>ただし、数字を入れようとしたマス目が正方形からはみ出している場合、すでに数字が埋まっている場合は以下の方法に従って数字を入れるマス目を探す。</li>
<ul>
<li>右にはみ出した場合には、同じ行の左はしに、左にはみ出した場合には、同じ行の右はしに、下にはみ出した場合には、同じ列の一番上に数字を入れる。
</li>
<li> 数字を入れようとしたマス目が埋まっているときには、その埋まっているマス目の左斜め下のマス目に入れる。
</li>
</ul>
<li>全てのマス目が埋まるまで２を繰り返す。
</ol>
<p>
この方法に従って、一辺のマス目の個数 <var>n</var> を入力として、その大きさの魔方陣を出力するプログラムを作成して下さい。ただし、<var>n</var> は 3 以上 15 以下の奇数とします。マス目に入る各数字は右詰 4 桁で出力してください。
</p>
<H2>入力</H2>
<p>複数の入力が与えられます。各入力で <var>n</var> （正の整数）が１行に与えられます。入力は 0 で終了します。入力の数は 10 を超えません。</p>
<H2>出力</H2>
<p>各入力に対して <var>n</var> × <var>n</var> の魔方陣を出力して下さい。</p>
<H2>Sample Input</H2>
<pre>
3
5
0
</pre>
<H2>Output for the Sample Input</H2>
<pre>
4 9 2
3 5 7
8 1 6
11 24 7 20 3
4 12 25 8 16
17 5 13 21 9
10 18 1 14 22
23 6 19 2 15
</pre>
| 3
5
0
| 4 9 2
3 5 7
8 1 6
11 24 7 20 3
4 12 25 8 16
17 5 13 21 9
10 18 1 14 22
23 6 19 2 15
| 11,933 |
s115936315 | p00078 | u133119785 | 1505612824 | Python | Python3 | py | Accepted | 30 | 7736 | 726 | def magic_square(n):
a = [[0 for i in range(n)] for j in range(n)]
x = n//2
y = (n+1)//2
i = 1
while True:
if a[y][x] == 0:
a[y][x] = i
i += 1
x += 1
y += 1
else:
x -= 1
y += 1
if x >= n:
x = 0
elif x < 0:
x = n-1
if y >= n:
y = 0
if i > (n*n):
break
return a
def print_square(a):
for aa in a:
for aaa in aa:
print('{0:4d}'.format(aaa),end="")
print('')
while True:
n = int(input())
if n == 0:
break
else:
a = magic_square(n)
print_square(a) | p00078 |
<H1>魔方陣</H1>
<p>
<var>n</var> × <var>n</var> の正方形のマス目の中に数字の１から <var>n</var> × <var>n</var> が一つずつ入っていて、縦のどの列のマス目の和も、横のどの列のマス目の和も対角線のマス目の和も等しいものを魔方陣といいます。
</p>
<p>
一辺のマスの個数が奇数の魔方陣の作り方には以下の方法があります。
</p>
<ol>
<li>中央のマス目のちょうど一つ下のマス目に１を入れる。</li>
<li>次の数字を右斜め下のマス目に入れる。<br>ただし、数字を入れようとしたマス目が正方形からはみ出している場合、すでに数字が埋まっている場合は以下の方法に従って数字を入れるマス目を探す。</li>
<ul>
<li>右にはみ出した場合には、同じ行の左はしに、左にはみ出した場合には、同じ行の右はしに、下にはみ出した場合には、同じ列の一番上に数字を入れる。
</li>
<li> 数字を入れようとしたマス目が埋まっているときには、その埋まっているマス目の左斜め下のマス目に入れる。
</li>
</ul>
<li>全てのマス目が埋まるまで２を繰り返す。
</ol>
<p>
この方法に従って、一辺のマス目の個数 <var>n</var> を入力として、その大きさの魔方陣を出力するプログラムを作成して下さい。ただし、<var>n</var> は 3 以上 15 以下の奇数とします。マス目に入る各数字は右詰 4 桁で出力してください。
</p>
<H2>入力</H2>
<p>複数の入力が与えられます。各入力で <var>n</var> （正の整数）が１行に与えられます。入力は 0 で終了します。入力の数は 10 を超えません。</p>
<H2>出力</H2>
<p>各入力に対して <var>n</var> × <var>n</var> の魔方陣を出力して下さい。</p>
<H2>Sample Input</H2>
<pre>
3
5
0
</pre>
<H2>Output for the Sample Input</H2>
<pre>
4 9 2
3 5 7
8 1 6
11 24 7 20 3
4 12 25 8 16
17 5 13 21 9
10 18 1 14 22
23 6 19 2 15
</pre>
| 3
5
0
| 4 9 2
3 5 7
8 1 6
11 24 7 20 3
4 12 25 8 16
17 5 13 21 9
10 18 1 14 22
23 6 19 2 15
| 11,934 |
s205747619 | p00078 | u043254318 | 1518979875 | Python | Python3 | py | Accepted | 30 | 5680 | 694 | def fprint(x):
if x < 10:
print(" ",end="")
elif x < 100:
print(" ",end="")
elif x < 1000:
print(" ",end="")
print(x,end="")
while True:
N = int(input())
if N == 0:
break
table = [[0 for i in range(N)] for j in range(N)]
cnt = 1
row = N // 2 + 1
col = N // 2
table[row][col] = cnt
while cnt < N*N:
row = (row + 1) % N
col = (col + 1) % N
while table[row][col] != 0:
row = (row + 1) % N
col = (col - 1 + N) % N
cnt += 1
table[row][col] = cnt
for i in range(N):
for j in range(N):
fprint(table[i][j])
print("")
| p00078 |
<H1>魔方陣</H1>
<p>
<var>n</var> × <var>n</var> の正方形のマス目の中に数字の１から <var>n</var> × <var>n</var> が一つずつ入っていて、縦のどの列のマス目の和も、横のどの列のマス目の和も対角線のマス目の和も等しいものを魔方陣といいます。
</p>
<p>
一辺のマスの個数が奇数の魔方陣の作り方には以下の方法があります。
</p>
<ol>
<li>中央のマス目のちょうど一つ下のマス目に１を入れる。</li>
<li>次の数字を右斜め下のマス目に入れる。<br>ただし、数字を入れようとしたマス目が正方形からはみ出している場合、すでに数字が埋まっている場合は以下の方法に従って数字を入れるマス目を探す。</li>
<ul>
<li>右にはみ出した場合には、同じ行の左はしに、左にはみ出した場合には、同じ行の右はしに、下にはみ出した場合には、同じ列の一番上に数字を入れる。
</li>
<li> 数字を入れようとしたマス目が埋まっているときには、その埋まっているマス目の左斜め下のマス目に入れる。
</li>
</ul>
<li>全てのマス目が埋まるまで２を繰り返す。
</ol>
<p>
この方法に従って、一辺のマス目の個数 <var>n</var> を入力として、その大きさの魔方陣を出力するプログラムを作成して下さい。ただし、<var>n</var> は 3 以上 15 以下の奇数とします。マス目に入る各数字は右詰 4 桁で出力してください。
</p>
<H2>入力</H2>
<p>複数の入力が与えられます。各入力で <var>n</var> （正の整数）が１行に与えられます。入力は 0 で終了します。入力の数は 10 を超えません。</p>
<H2>出力</H2>
<p>各入力に対して <var>n</var> × <var>n</var> の魔方陣を出力して下さい。</p>
<H2>Sample Input</H2>
<pre>
3
5
0
</pre>
<H2>Output for the Sample Input</H2>
<pre>
4 9 2
3 5 7
8 1 6
11 24 7 20 3
4 12 25 8 16
17 5 13 21 9
10 18 1 14 22
23 6 19 2 15
</pre>
| 3
5
0
| 4 9 2
3 5 7
8 1 6
11 24 7 20 3
4 12 25 8 16
17 5 13 21 9
10 18 1 14 22
23 6 19 2 15
| 11,935 |
s877685671 | p00078 | u024715419 | 1519297921 | Python | Python3 | py | Accepted | 20 | 5616 | 718 | def check_range(xy, n):
for i in range(2):
if xy[i] == -1:
xy[i] = n - 1
elif xy[i] == n:
xy[i] = 0
return xy
while True:
n = int(input())
if n == 0:
break
ms = [[0 for i in range(n)] for j in range(n)]
xy = [n//2, n//2 - 1]
i = 1
while i <= n*n:
if ms[xy[1]][xy[0]] != 0:
xy[0] -= 1
xy[1] -= 1
xy = check_range(xy, n)
continue
ms[xy[1]][xy[0]] = i
xy[0] += 1
xy[1] -= 1
xy = check_range(xy, n)
i += 1
for i in range(n):
s = ""
for j in range(n):
s += "{0:>4}".format(str(ms[n - i - 1][j]))
print(s)
| p00078 |
<H1>魔方陣</H1>
<p>
<var>n</var> × <var>n</var> の正方形のマス目の中に数字の１から <var>n</var> × <var>n</var> が一つずつ入っていて、縦のどの列のマス目の和も、横のどの列のマス目の和も対角線のマス目の和も等しいものを魔方陣といいます。
</p>
<p>
一辺のマスの個数が奇数の魔方陣の作り方には以下の方法があります。
</p>
<ol>
<li>中央のマス目のちょうど一つ下のマス目に１を入れる。</li>
<li>次の数字を右斜め下のマス目に入れる。<br>ただし、数字を入れようとしたマス目が正方形からはみ出している場合、すでに数字が埋まっている場合は以下の方法に従って数字を入れるマス目を探す。</li>
<ul>
<li>右にはみ出した場合には、同じ行の左はしに、左にはみ出した場合には、同じ行の右はしに、下にはみ出した場合には、同じ列の一番上に数字を入れる。
</li>
<li> 数字を入れようとしたマス目が埋まっているときには、その埋まっているマス目の左斜め下のマス目に入れる。
</li>
</ul>
<li>全てのマス目が埋まるまで２を繰り返す。
</ol>
<p>
この方法に従って、一辺のマス目の個数 <var>n</var> を入力として、その大きさの魔方陣を出力するプログラムを作成して下さい。ただし、<var>n</var> は 3 以上 15 以下の奇数とします。マス目に入る各数字は右詰 4 桁で出力してください。
</p>
<H2>入力</H2>
<p>複数の入力が与えられます。各入力で <var>n</var> （正の整数）が１行に与えられます。入力は 0 で終了します。入力の数は 10 を超えません。</p>
<H2>出力</H2>
<p>各入力に対して <var>n</var> × <var>n</var> の魔方陣を出力して下さい。</p>
<H2>Sample Input</H2>
<pre>
3
5
0
</pre>
<H2>Output for the Sample Input</H2>
<pre>
4 9 2
3 5 7
8 1 6
11 24 7 20 3
4 12 25 8 16
17 5 13 21 9
10 18 1 14 22
23 6 19 2 15
</pre>
| 3
5
0
| 4 9 2
3 5 7
8 1 6
11 24 7 20 3
4 12 25 8 16
17 5 13 21 9
10 18 1 14 22
23 6 19 2 15
| 11,936 |
s345663892 | p00078 | u150984829 | 1525257618 | Python | Python3 | py | Accepted | 20 | 5608 | 213 | for e in iter(input,'0'):
n=int(e);m,f=[[0]*n for _ in[0]*n],'{:4}'*n
j=n//2;i=j+1
m[i][j]=1
for k in range(2,n*n+1):
i,j=-~i%n,-~j%n
if m[i][j]:i,j=-~i%n,~-j%n
m[i][j]=k
for r in m:print(f.format(*r))
| p00078 |
<H1>魔方陣</H1>
<p>
<var>n</var> × <var>n</var> の正方形のマス目の中に数字の１から <var>n</var> × <var>n</var> が一つずつ入っていて、縦のどの列のマス目の和も、横のどの列のマス目の和も対角線のマス目の和も等しいものを魔方陣といいます。
</p>
<p>
一辺のマスの個数が奇数の魔方陣の作り方には以下の方法があります。
</p>
<ol>
<li>中央のマス目のちょうど一つ下のマス目に１を入れる。</li>
<li>次の数字を右斜め下のマス目に入れる。<br>ただし、数字を入れようとしたマス目が正方形からはみ出している場合、すでに数字が埋まっている場合は以下の方法に従って数字を入れるマス目を探す。</li>
<ul>
<li>右にはみ出した場合には、同じ行の左はしに、左にはみ出した場合には、同じ行の右はしに、下にはみ出した場合には、同じ列の一番上に数字を入れる。
</li>
<li> 数字を入れようとしたマス目が埋まっているときには、その埋まっているマス目の左斜め下のマス目に入れる。
</li>
</ul>
<li>全てのマス目が埋まるまで２を繰り返す。
</ol>
<p>
この方法に従って、一辺のマス目の個数 <var>n</var> を入力として、その大きさの魔方陣を出力するプログラムを作成して下さい。ただし、<var>n</var> は 3 以上 15 以下の奇数とします。マス目に入る各数字は右詰 4 桁で出力してください。
</p>
<H2>入力</H2>
<p>複数の入力が与えられます。各入力で <var>n</var> （正の整数）が１行に与えられます。入力は 0 で終了します。入力の数は 10 を超えません。</p>
<H2>出力</H2>
<p>各入力に対して <var>n</var> × <var>n</var> の魔方陣を出力して下さい。</p>
<H2>Sample Input</H2>
<pre>
3
5
0
</pre>
<H2>Output for the Sample Input</H2>
<pre>
4 9 2
3 5 7
8 1 6
11 24 7 20 3
4 12 25 8 16
17 5 13 21 9
10 18 1 14 22
23 6 19 2 15
</pre>
| 3
5
0
| 4 9 2
3 5 7
8 1 6
11 24 7 20 3
4 12 25 8 16
17 5 13 21 9
10 18 1 14 22
23 6 19 2 15
| 11,937 |
s880901561 | p00078 | u150984829 | 1525257665 | Python | Python3 | py | Accepted | 20 | 5612 | 213 | for e in iter(input,'0'):
n=int(e);m,f=[[0]*n for _ in[0]*n],'{:4}'*n
j=n//2;i=j+1
m[i][j]=1
for k in range(2,n*n+1):
i,j,t=-~i%n,-~j%n,j
if m[i][j]:i,j=-~i%n,t
m[i][j]=k
for r in m:print(f.format(*r))
| p00078 |
<H1>魔方陣</H1>
<p>
<var>n</var> × <var>n</var> の正方形のマス目の中に数字の１から <var>n</var> × <var>n</var> が一つずつ入っていて、縦のどの列のマス目の和も、横のどの列のマス目の和も対角線のマス目の和も等しいものを魔方陣といいます。
</p>
<p>
一辺のマスの個数が奇数の魔方陣の作り方には以下の方法があります。
</p>
<ol>
<li>中央のマス目のちょうど一つ下のマス目に１を入れる。</li>
<li>次の数字を右斜め下のマス目に入れる。<br>ただし、数字を入れようとしたマス目が正方形からはみ出している場合、すでに数字が埋まっている場合は以下の方法に従って数字を入れるマス目を探す。</li>
<ul>
<li>右にはみ出した場合には、同じ行の左はしに、左にはみ出した場合には、同じ行の右はしに、下にはみ出した場合には、同じ列の一番上に数字を入れる。
</li>
<li> 数字を入れようとしたマス目が埋まっているときには、その埋まっているマス目の左斜め下のマス目に入れる。
</li>
</ul>
<li>全てのマス目が埋まるまで２を繰り返す。
</ol>
<p>
この方法に従って、一辺のマス目の個数 <var>n</var> を入力として、その大きさの魔方陣を出力するプログラムを作成して下さい。ただし、<var>n</var> は 3 以上 15 以下の奇数とします。マス目に入る各数字は右詰 4 桁で出力してください。
</p>
<H2>入力</H2>
<p>複数の入力が与えられます。各入力で <var>n</var> （正の整数）が１行に与えられます。入力は 0 で終了します。入力の数は 10 を超えません。</p>
<H2>出力</H2>
<p>各入力に対して <var>n</var> × <var>n</var> の魔方陣を出力して下さい。</p>
<H2>Sample Input</H2>
<pre>
3
5
0
</pre>
<H2>Output for the Sample Input</H2>
<pre>
4 9 2
3 5 7
8 1 6
11 24 7 20 3
4 12 25 8 16
17 5 13 21 9
10 18 1 14 22
23 6 19 2 15
</pre>
| 3
5
0
| 4 9 2
3 5 7
8 1 6
11 24 7 20 3
4 12 25 8 16
17 5 13 21 9
10 18 1 14 22
23 6 19 2 15
| 11,938 |
s259725913 | p00078 | u150984829 | 1525257867 | Python | Python3 | py | Accepted | 20 | 5612 | 228 | for e in iter(input,'0'):
n=int(e);m,f=[[0]*n for _ in[0]*n],'{:4}'*n
s=lambda x:-~x%n
j=n//2;i=j+1
m[i][j]=1
for k in range(2,n*n+1):
i,j,t=s(i),s(j),j
if m[i][j]:i,j=s(i),t
m[i][j]=k
for r in m:print(f.format(*r))
| p00078 |
<H1>魔方陣</H1>
<p>
<var>n</var> × <var>n</var> の正方形のマス目の中に数字の１から <var>n</var> × <var>n</var> が一つずつ入っていて、縦のどの列のマス目の和も、横のどの列のマス目の和も対角線のマス目の和も等しいものを魔方陣といいます。
</p>
<p>
一辺のマスの個数が奇数の魔方陣の作り方には以下の方法があります。
</p>
<ol>
<li>中央のマス目のちょうど一つ下のマス目に１を入れる。</li>
<li>次の数字を右斜め下のマス目に入れる。<br>ただし、数字を入れようとしたマス目が正方形からはみ出している場合、すでに数字が埋まっている場合は以下の方法に従って数字を入れるマス目を探す。</li>
<ul>
<li>右にはみ出した場合には、同じ行の左はしに、左にはみ出した場合には、同じ行の右はしに、下にはみ出した場合には、同じ列の一番上に数字を入れる。
</li>
<li> 数字を入れようとしたマス目が埋まっているときには、その埋まっているマス目の左斜め下のマス目に入れる。
</li>
</ul>
<li>全てのマス目が埋まるまで２を繰り返す。
</ol>
<p>
この方法に従って、一辺のマス目の個数 <var>n</var> を入力として、その大きさの魔方陣を出力するプログラムを作成して下さい。ただし、<var>n</var> は 3 以上 15 以下の奇数とします。マス目に入る各数字は右詰 4 桁で出力してください。
</p>
<H2>入力</H2>
<p>複数の入力が与えられます。各入力で <var>n</var> （正の整数）が１行に与えられます。入力は 0 で終了します。入力の数は 10 を超えません。</p>
<H2>出力</H2>
<p>各入力に対して <var>n</var> × <var>n</var> の魔方陣を出力して下さい。</p>
<H2>Sample Input</H2>
<pre>
3
5
0
</pre>
<H2>Output for the Sample Input</H2>
<pre>
4 9 2
3 5 7
8 1 6
11 24 7 20 3
4 12 25 8 16
17 5 13 21 9
10 18 1 14 22
23 6 19 2 15
</pre>
| 3
5
0
| 4 9 2
3 5 7
8 1 6
11 24 7 20 3
4 12 25 8 16
17 5 13 21 9
10 18 1 14 22
23 6 19 2 15
| 11,939 |
s193596773 | p00078 | u352394527 | 1527562040 | Python | Python3 | py | Accepted | 30 | 5596 | 453 | def square(n):
mp = [[0 for _ in range(n)] for _ in range(n)]
x, y = n // 2 , n // 2 + 1
mp[y][x] = 1
for i in range(2, n ** 2 + 1):
x = (x + 1) % n
y = (y + 1) % n
while mp[y][x]:
y = (y + 1) % n
x = (x - 1) % n
mp[y][x] = i
for line in mp:
s = ""
for i in line:
si = str(i)
s += si.rjust(4)
print(s)
while True:
n = int(input())
if not n:
break
square(n)
| p00078 |
<H1>魔方陣</H1>
<p>
<var>n</var> × <var>n</var> の正方形のマス目の中に数字の１から <var>n</var> × <var>n</var> が一つずつ入っていて、縦のどの列のマス目の和も、横のどの列のマス目の和も対角線のマス目の和も等しいものを魔方陣といいます。
</p>
<p>
一辺のマスの個数が奇数の魔方陣の作り方には以下の方法があります。
</p>
<ol>
<li>中央のマス目のちょうど一つ下のマス目に１を入れる。</li>
<li>次の数字を右斜め下のマス目に入れる。<br>ただし、数字を入れようとしたマス目が正方形からはみ出している場合、すでに数字が埋まっている場合は以下の方法に従って数字を入れるマス目を探す。</li>
<ul>
<li>右にはみ出した場合には、同じ行の左はしに、左にはみ出した場合には、同じ行の右はしに、下にはみ出した場合には、同じ列の一番上に数字を入れる。
</li>
<li> 数字を入れようとしたマス目が埋まっているときには、その埋まっているマス目の左斜め下のマス目に入れる。
</li>
</ul>
<li>全てのマス目が埋まるまで２を繰り返す。
</ol>
<p>
この方法に従って、一辺のマス目の個数 <var>n</var> を入力として、その大きさの魔方陣を出力するプログラムを作成して下さい。ただし、<var>n</var> は 3 以上 15 以下の奇数とします。マス目に入る各数字は右詰 4 桁で出力してください。
</p>
<H2>入力</H2>
<p>複数の入力が与えられます。各入力で <var>n</var> （正の整数）が１行に与えられます。入力は 0 で終了します。入力の数は 10 を超えません。</p>
<H2>出力</H2>
<p>各入力に対して <var>n</var> × <var>n</var> の魔方陣を出力して下さい。</p>
<H2>Sample Input</H2>
<pre>
3
5
0
</pre>
<H2>Output for the Sample Input</H2>
<pre>
4 9 2
3 5 7
8 1 6
11 24 7 20 3
4 12 25 8 16
17 5 13 21 9
10 18 1 14 22
23 6 19 2 15
</pre>
| 3
5
0
| 4 9 2
3 5 7
8 1 6
11 24 7 20 3
4 12 25 8 16
17 5 13 21 9
10 18 1 14 22
23 6 19 2 15
| 11,940 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.