submission_id string | problem_id string | status string | code string | input string | output string | problem_description string |
|---|---|---|---|---|---|---|
s606560107 | p00051 | Accepted | for i in range(input()):
s = ''.join(sorted(list(raw_input())))
print int(s[::-1]) - int(s) | 2
65539010
65539010
| 96417531
96417531
|
<H1>整数の差</H1>
<p>
8 個の 0 から 9 までの数字を入力したとき、その 8 個の数字を並べ替えてできる、最大の整数と最小の整数の差を出力するプログラムを作成してください。並び替えてできる数は 00135569 のように 0 から始まってもよいものとします。
</p>
<H2>Input</H2>
<p>
複数のデータセットが与えられます。１行目にデータセット数 <var>n</var> (<var>n</var> ≤ 50) が与えられます。続いて <var>n</var> 行のデータが与えられます。各データは 8 個の数字の並び（0 から 9 の数字）です。
</p>
<H2>Output</H2>
<p>
各データセットに対して、入力された数字を並べ替えてできる最大の整数と最小の整数の差を１行に出力して下さい。
</p>
<H2>Sample Input</H2>
<pre>
2
65539010
65539010
</pre>
<H2>Output for the Sample Input</H2>
<pre>
96417531
96417531
</pre>
|
s492484808 | p00051 | Accepted |
n=int(input())
for i in range(n):
A=[]
string=input()
for j in string:
A.append(j)
A.sort(reverse=True)
Max="".join(A)
A.sort()
Min="".join(A)
Min=int(Min)
Max=int(Max)
print(Max-Min) | 2
65539010
65539010
| 96417531
96417531
|
<H1>整数の差</H1>
<p>
8 個の 0 から 9 までの数字を入力したとき、その 8 個の数字を並べ替えてできる、最大の整数と最小の整数の差を出力するプログラムを作成してください。並び替えてできる数は 00135569 のように 0 から始まってもよいものとします。
</p>
<H2>Input</H2>
<p>
複数のデータセットが与えられます。１行目にデータセット数 <var>n</var> (<var>n</var> ≤ 50) が与えられます。続いて <var>n</var> 行のデータが与えられます。各データは 8 個の数字の並び（0 から 9 の数字）です。
</p>
<H2>Output</H2>
<p>
各データセットに対して、入力された数字を並べ替えてできる最大の整数と最小の整数の差を１行に出力して下さい。
</p>
<H2>Sample Input</H2>
<pre>
2
65539010
65539010
</pre>
<H2>Output for the Sample Input</H2>
<pre>
96417531
96417531
</pre>
|
s235887244 | p00051 | Accepted | for i in xrange(input()):
s = sorted([s for s in raw_input()])
print int("".join(reversed(s))) - int("".join(s)) | 2
65539010
65539010
| 96417531
96417531
|
<H1>整数の差</H1>
<p>
8 個の 0 から 9 までの数字を入力したとき、その 8 個の数字を並べ替えてできる、最大の整数と最小の整数の差を出力するプログラムを作成してください。並び替えてできる数は 00135569 のように 0 から始まってもよいものとします。
</p>
<H2>Input</H2>
<p>
複数のデータセットが与えられます。１行目にデータセット数 <var>n</var> (<var>n</var> ≤ 50) が与えられます。続いて <var>n</var> 行のデータが与えられます。各データは 8 個の数字の並び（0 から 9 の数字）です。
</p>
<H2>Output</H2>
<p>
各データセットに対して、入力された数字を並べ替えてできる最大の整数と最小の整数の差を１行に出力して下さい。
</p>
<H2>Sample Input</H2>
<pre>
2
65539010
65539010
</pre>
<H2>Output for the Sample Input</H2>
<pre>
96417531
96417531
</pre>
|
s458948727 | p00051 | Accepted | # -*- coding: utf-8 -*-
n = int(raw_input())
for i in range(n):
line = str(raw_input())
p = []
for j in range(len(line)):
p.append(int(line[j]))
p.sort()
x = 1
max = 0
min = 0
for j in range(len(p)):
max += p[j]*x
min += p[len(p)-j-1]*x
x *= 10
print max-min | 2
65539010
65539010
| 96417531
96417531
|
<H1>整数の差</H1>
<p>
8 個の 0 から 9 までの数字を入力したとき、その 8 個の数字を並べ替えてできる、最大の整数と最小の整数の差を出力するプログラムを作成してください。並び替えてできる数は 00135569 のように 0 から始まってもよいものとします。
</p>
<H2>Input</H2>
<p>
複数のデータセットが与えられます。１行目にデータセット数 <var>n</var> (<var>n</var> ≤ 50) が与えられます。続いて <var>n</var> 行のデータが与えられます。各データは 8 個の数字の並び（0 から 9 の数字）です。
</p>
<H2>Output</H2>
<p>
各データセットに対して、入力された数字を並べ替えてできる最大の整数と最小の整数の差を１行に出力して下さい。
</p>
<H2>Sample Input</H2>
<pre>
2
65539010
65539010
</pre>
<H2>Output for the Sample Input</H2>
<pre>
96417531
96417531
</pre>
|
s925407119 | p00051 | Accepted | for _ in range(int(input())):
data = list(input())
print(int(''.join(sorted(data, reverse=True))) - int(''.join(sorted(data)))) | 2
65539010
65539010
| 96417531
96417531
|
<H1>整数の差</H1>
<p>
8 個の 0 から 9 までの数字を入力したとき、その 8 個の数字を並べ替えてできる、最大の整数と最小の整数の差を出力するプログラムを作成してください。並び替えてできる数は 00135569 のように 0 から始まってもよいものとします。
</p>
<H2>Input</H2>
<p>
複数のデータセットが与えられます。１行目にデータセット数 <var>n</var> (<var>n</var> ≤ 50) が与えられます。続いて <var>n</var> 行のデータが与えられます。各データは 8 個の数字の並び（0 から 9 の数字）です。
</p>
<H2>Output</H2>
<p>
各データセットに対して、入力された数字を並べ替えてできる最大の整数と最小の整数の差を１行に出力して下さい。
</p>
<H2>Sample Input</H2>
<pre>
2
65539010
65539010
</pre>
<H2>Output for the Sample Input</H2>
<pre>
96417531
96417531
</pre>
|
s804200029 | p00051 | Accepted | n = int(input())
for i in range(n):
s = list(input())
small = ""
big = ""
s.sort()
for j in s:
small += j
s.reverse()
for j in s:
big += j
print(int(big) - int(small)) | 2
65539010
65539010
| 96417531
96417531
|
<H1>整数の差</H1>
<p>
8 個の 0 から 9 までの数字を入力したとき、その 8 個の数字を並べ替えてできる、最大の整数と最小の整数の差を出力するプログラムを作成してください。並び替えてできる数は 00135569 のように 0 から始まってもよいものとします。
</p>
<H2>Input</H2>
<p>
複数のデータセットが与えられます。１行目にデータセット数 <var>n</var> (<var>n</var> ≤ 50) が与えられます。続いて <var>n</var> 行のデータが与えられます。各データは 8 個の数字の並び（0 から 9 の数字）です。
</p>
<H2>Output</H2>
<p>
各データセットに対して、入力された数字を並べ替えてできる最大の整数と最小の整数の差を１行に出力して下さい。
</p>
<H2>Sample Input</H2>
<pre>
2
65539010
65539010
</pre>
<H2>Output for the Sample Input</H2>
<pre>
96417531
96417531
</pre>
|
s728696266 | p00051 | Accepted | n = int(input())
for i in range(n):
Max_num = ""
Min_num = ""
n = str(input())
Lis = list(map(str,n))
Min_num_lis = sorted(Lis)
Max_num_lis = sorted(Lis)[::-1]
for j in range(8):
Max_num = Max_num + Max_num_lis[j]
Min_num = Min_num + Min_num_lis[j]
sa = int(Max_num) - int(Min_num)
print(sa)
| 2
65539010
65539010
| 96417531
96417531
|
<H1>整数の差</H1>
<p>
8 個の 0 から 9 までの数字を入力したとき、その 8 個の数字を並べ替えてできる、最大の整数と最小の整数の差を出力するプログラムを作成してください。並び替えてできる数は 00135569 のように 0 から始まってもよいものとします。
</p>
<H2>Input</H2>
<p>
複数のデータセットが与えられます。１行目にデータセット数 <var>n</var> (<var>n</var> ≤ 50) が与えられます。続いて <var>n</var> 行のデータが与えられます。各データは 8 個の数字の並び（0 から 9 の数字）です。
</p>
<H2>Output</H2>
<p>
各データセットに対して、入力された数字を並べ替えてできる最大の整数と最小の整数の差を１行に出力して下さい。
</p>
<H2>Sample Input</H2>
<pre>
2
65539010
65539010
</pre>
<H2>Output for the Sample Input</H2>
<pre>
96417531
96417531
</pre>
|
s768243767 | p00051 | Accepted | n = int(input())
for _ in range(n):
dist = [int(v) for v in str(input())]
dmax, dmin = ''.join(map(str, sorted(dist, reverse=True))), ''.join(map(str, sorted(dist)))
print(int(dmax)-int(dmin)) | 2
65539010
65539010
| 96417531
96417531
|
<H1>整数の差</H1>
<p>
8 個の 0 から 9 までの数字を入力したとき、その 8 個の数字を並べ替えてできる、最大の整数と最小の整数の差を出力するプログラムを作成してください。並び替えてできる数は 00135569 のように 0 から始まってもよいものとします。
</p>
<H2>Input</H2>
<p>
複数のデータセットが与えられます。１行目にデータセット数 <var>n</var> (<var>n</var> ≤ 50) が与えられます。続いて <var>n</var> 行のデータが与えられます。各データは 8 個の数字の並び（0 から 9 の数字）です。
</p>
<H2>Output</H2>
<p>
各データセットに対して、入力された数字を並べ替えてできる最大の整数と最小の整数の差を１行に出力して下さい。
</p>
<H2>Sample Input</H2>
<pre>
2
65539010
65539010
</pre>
<H2>Output for the Sample Input</H2>
<pre>
96417531
96417531
</pre>
|
s141281893 | p00051 | Accepted | n=int(input())
for _ in range(n):
c=[i for i in input()]
Max=int("".join(sorted(c,reverse=True)))
Min=int("".join(sorted(c)))
print(Max-Min) | 2
65539010
65539010
| 96417531
96417531
|
<H1>整数の差</H1>
<p>
8 個の 0 から 9 までの数字を入力したとき、その 8 個の数字を並べ替えてできる、最大の整数と最小の整数の差を出力するプログラムを作成してください。並び替えてできる数は 00135569 のように 0 から始まってもよいものとします。
</p>
<H2>Input</H2>
<p>
複数のデータセットが与えられます。１行目にデータセット数 <var>n</var> (<var>n</var> ≤ 50) が与えられます。続いて <var>n</var> 行のデータが与えられます。各データは 8 個の数字の並び（0 から 9 の数字）です。
</p>
<H2>Output</H2>
<p>
各データセットに対して、入力された数字を並べ替えてできる最大の整数と最小の整数の差を１行に出力して下さい。
</p>
<H2>Sample Input</H2>
<pre>
2
65539010
65539010
</pre>
<H2>Output for the Sample Input</H2>
<pre>
96417531
96417531
</pre>
|
s090101105 | p00051 | Accepted | m=int(input())
while m:
n,m=input(),m-1
n=''.join(sorted(n))
print(int(n[::-1]) - int(n)) | 2
65539010
65539010
| 96417531
96417531
|
<H1>整数の差</H1>
<p>
8 個の 0 から 9 までの数字を入力したとき、その 8 個の数字を並べ替えてできる、最大の整数と最小の整数の差を出力するプログラムを作成してください。並び替えてできる数は 00135569 のように 0 から始まってもよいものとします。
</p>
<H2>Input</H2>
<p>
複数のデータセットが与えられます。１行目にデータセット数 <var>n</var> (<var>n</var> ≤ 50) が与えられます。続いて <var>n</var> 行のデータが与えられます。各データは 8 個の数字の並び（0 から 9 の数字）です。
</p>
<H2>Output</H2>
<p>
各データセットに対して、入力された数字を並べ替えてできる最大の整数と最小の整数の差を１行に出力して下さい。
</p>
<H2>Sample Input</H2>
<pre>
2
65539010
65539010
</pre>
<H2>Output for the Sample Input</H2>
<pre>
96417531
96417531
</pre>
|
s393298750 | p00051 | Accepted | m=int(input())
while m:
n,m=''.join(sorted(input())),m-1
print(int(n[::-1]) - int(n)) | 2
65539010
65539010
| 96417531
96417531
|
<H1>整数の差</H1>
<p>
8 個の 0 から 9 までの数字を入力したとき、その 8 個の数字を並べ替えてできる、最大の整数と最小の整数の差を出力するプログラムを作成してください。並び替えてできる数は 00135569 のように 0 から始まってもよいものとします。
</p>
<H2>Input</H2>
<p>
複数のデータセットが与えられます。１行目にデータセット数 <var>n</var> (<var>n</var> ≤ 50) が与えられます。続いて <var>n</var> 行のデータが与えられます。各データは 8 個の数字の並び（0 から 9 の数字）です。
</p>
<H2>Output</H2>
<p>
各データセットに対して、入力された数字を並べ替えてできる最大の整数と最小の整数の差を１行に出力して下さい。
</p>
<H2>Sample Input</H2>
<pre>
2
65539010
65539010
</pre>
<H2>Output for the Sample Input</H2>
<pre>
96417531
96417531
</pre>
|
s550837981 | p00051 | Accepted | def join_num(arr):
result = 0
for i in range(len(arr)):
result += arr[i] * 10**(7-i)
return result
n = int(input())
x = [0] * n
for i in range(n):
x[i] = str(input())
for i in range(n):
d = []
for c in x[i]:
d.append(int(c))
d.sort()
a = join_num(d)
d.reverse()
b = join_num(d)
print(b-a) | 2
65539010
65539010
| 96417531
96417531
|
<H1>整数の差</H1>
<p>
8 個の 0 から 9 までの数字を入力したとき、その 8 個の数字を並べ替えてできる、最大の整数と最小の整数の差を出力するプログラムを作成してください。並び替えてできる数は 00135569 のように 0 から始まってもよいものとします。
</p>
<H2>Input</H2>
<p>
複数のデータセットが与えられます。１行目にデータセット数 <var>n</var> (<var>n</var> ≤ 50) が与えられます。続いて <var>n</var> 行のデータが与えられます。各データは 8 個の数字の並び（0 から 9 の数字）です。
</p>
<H2>Output</H2>
<p>
各データセットに対して、入力された数字を並べ替えてできる最大の整数と最小の整数の差を１行に出力して下さい。
</p>
<H2>Sample Input</H2>
<pre>
2
65539010
65539010
</pre>
<H2>Output for the Sample Input</H2>
<pre>
96417531
96417531
</pre>
|
s570088413 | p00051 | Accepted | n = int(input())
for _ in range(n):
s = list(input().strip())
t = sorted(s,reverse=True)
u = sorted(s)
dif = int(''.join(t)) - int(''.join(u))
print(dif) | 2
65539010
65539010
| 96417531
96417531
|
<H1>整数の差</H1>
<p>
8 個の 0 から 9 までの数字を入力したとき、その 8 個の数字を並べ替えてできる、最大の整数と最小の整数の差を出力するプログラムを作成してください。並び替えてできる数は 00135569 のように 0 から始まってもよいものとします。
</p>
<H2>Input</H2>
<p>
複数のデータセットが与えられます。１行目にデータセット数 <var>n</var> (<var>n</var> ≤ 50) が与えられます。続いて <var>n</var> 行のデータが与えられます。各データは 8 個の数字の並び（0 から 9 の数字）です。
</p>
<H2>Output</H2>
<p>
各データセットに対して、入力された数字を並べ替えてできる最大の整数と最小の整数の差を１行に出力して下さい。
</p>
<H2>Sample Input</H2>
<pre>
2
65539010
65539010
</pre>
<H2>Output for the Sample Input</H2>
<pre>
96417531
96417531
</pre>
|
s461935007 | p00051 | Accepted | N = int(input())
for i in range(N):
S = input()
mx = int(''.join(sorted(S,reverse=True)))
mn = int(''.join(sorted(S)))
print(mx - mn) | 2
65539010
65539010
| 96417531
96417531
|
<H1>整数の差</H1>
<p>
8 個の 0 から 9 までの数字を入力したとき、その 8 個の数字を並べ替えてできる、最大の整数と最小の整数の差を出力するプログラムを作成してください。並び替えてできる数は 00135569 のように 0 から始まってもよいものとします。
</p>
<H2>Input</H2>
<p>
複数のデータセットが与えられます。１行目にデータセット数 <var>n</var> (<var>n</var> ≤ 50) が与えられます。続いて <var>n</var> 行のデータが与えられます。各データは 8 個の数字の並び（0 から 9 の数字）です。
</p>
<H2>Output</H2>
<p>
各データセットに対して、入力された数字を並べ替えてできる最大の整数と最小の整数の差を１行に出力して下さい。
</p>
<H2>Sample Input</H2>
<pre>
2
65539010
65539010
</pre>
<H2>Output for the Sample Input</H2>
<pre>
96417531
96417531
</pre>
|
s216189597 | p00051 | Accepted | n = int(input())
for _ in range(n):
instr = list(input())
instr.sort()
minno = int("".join(instr))
maxno = int("".join(reversed(instr)))
print(maxno-minno) | 2
65539010
65539010
| 96417531
96417531
|
<H1>整数の差</H1>
<p>
8 個の 0 から 9 までの数字を入力したとき、その 8 個の数字を並べ替えてできる、最大の整数と最小の整数の差を出力するプログラムを作成してください。並び替えてできる数は 00135569 のように 0 から始まってもよいものとします。
</p>
<H2>Input</H2>
<p>
複数のデータセットが与えられます。１行目にデータセット数 <var>n</var> (<var>n</var> ≤ 50) が与えられます。続いて <var>n</var> 行のデータが与えられます。各データは 8 個の数字の並び（0 から 9 の数字）です。
</p>
<H2>Output</H2>
<p>
各データセットに対して、入力された数字を並べ替えてできる最大の整数と最小の整数の差を１行に出力して下さい。
</p>
<H2>Sample Input</H2>
<pre>
2
65539010
65539010
</pre>
<H2>Output for the Sample Input</H2>
<pre>
96417531
96417531
</pre>
|
s197901034 | p00051 | Accepted | # -*- coding: utf-8 -*-
import sys
import os
N = int(input())
for i in range(N):
n = int(input())
s = str(n)
A = list(s)
B = sorted(A)
C = sorted(B, reverse=True)
b = int(''.join(B))
c = int(''.join(C))
print(c - b) | 2
65539010
65539010
| 96417531
96417531
|
<H1>整数の差</H1>
<p>
8 個の 0 から 9 までの数字を入力したとき、その 8 個の数字を並べ替えてできる、最大の整数と最小の整数の差を出力するプログラムを作成してください。並び替えてできる数は 00135569 のように 0 から始まってもよいものとします。
</p>
<H2>Input</H2>
<p>
複数のデータセットが与えられます。１行目にデータセット数 <var>n</var> (<var>n</var> ≤ 50) が与えられます。続いて <var>n</var> 行のデータが与えられます。各データは 8 個の数字の並び（0 から 9 の数字）です。
</p>
<H2>Output</H2>
<p>
各データセットに対して、入力された数字を並べ替えてできる最大の整数と最小の整数の差を１行に出力して下さい。
</p>
<H2>Sample Input</H2>
<pre>
2
65539010
65539010
</pre>
<H2>Output for the Sample Input</H2>
<pre>
96417531
96417531
</pre>
|
s168094925 | p00051 | Accepted | for i in range(int(input())):
num = list(input())
num.sort()
min = int(''.join(num))
num.reverse()
max = int(''.join(num))
print(max-min) | 2
65539010
65539010
| 96417531
96417531
|
<H1>整数の差</H1>
<p>
8 個の 0 から 9 までの数字を入力したとき、その 8 個の数字を並べ替えてできる、最大の整数と最小の整数の差を出力するプログラムを作成してください。並び替えてできる数は 00135569 のように 0 から始まってもよいものとします。
</p>
<H2>Input</H2>
<p>
複数のデータセットが与えられます。１行目にデータセット数 <var>n</var> (<var>n</var> ≤ 50) が与えられます。続いて <var>n</var> 行のデータが与えられます。各データは 8 個の数字の並び（0 から 9 の数字）です。
</p>
<H2>Output</H2>
<p>
各データセットに対して、入力された数字を並べ替えてできる最大の整数と最小の整数の差を１行に出力して下さい。
</p>
<H2>Sample Input</H2>
<pre>
2
65539010
65539010
</pre>
<H2>Output for the Sample Input</H2>
<pre>
96417531
96417531
</pre>
|
s664469072 | p00051 | Accepted | for _ in range(int(input())) :
sample = list(input())
Max, Min = '', ''
sample.sort(reverse = True)
for _ in sample : Max += _
sample.sort()
for _ in sample : Min += _
print(int(Max) - int(Min)) | 2
65539010
65539010
| 96417531
96417531
|
<H1>整数の差</H1>
<p>
8 個の 0 から 9 までの数字を入力したとき、その 8 個の数字を並べ替えてできる、最大の整数と最小の整数の差を出力するプログラムを作成してください。並び替えてできる数は 00135569 のように 0 から始まってもよいものとします。
</p>
<H2>Input</H2>
<p>
複数のデータセットが与えられます。１行目にデータセット数 <var>n</var> (<var>n</var> ≤ 50) が与えられます。続いて <var>n</var> 行のデータが与えられます。各データは 8 個の数字の並び（0 から 9 の数字）です。
</p>
<H2>Output</H2>
<p>
各データセットに対して、入力された数字を並べ替えてできる最大の整数と最小の整数の差を１行に出力して下さい。
</p>
<H2>Sample Input</H2>
<pre>
2
65539010
65539010
</pre>
<H2>Output for the Sample Input</H2>
<pre>
96417531
96417531
</pre>
|
s520856799 | p00051 | Accepted | n = int(input())
for _ in range(n):
data = list(zip(*input()))[0]
print(int("".join(sorted(data)[::-1])) - int("".join(sorted(data)))) | 2
65539010
65539010
| 96417531
96417531
|
<H1>整数の差</H1>
<p>
8 個の 0 から 9 までの数字を入力したとき、その 8 個の数字を並べ替えてできる、最大の整数と最小の整数の差を出力するプログラムを作成してください。並び替えてできる数は 00135569 のように 0 から始まってもよいものとします。
</p>
<H2>Input</H2>
<p>
複数のデータセットが与えられます。１行目にデータセット数 <var>n</var> (<var>n</var> ≤ 50) が与えられます。続いて <var>n</var> 行のデータが与えられます。各データは 8 個の数字の並び（0 から 9 の数字）です。
</p>
<H2>Output</H2>
<p>
各データセットに対して、入力された数字を並べ替えてできる最大の整数と最小の整数の差を１行に出力して下さい。
</p>
<H2>Sample Input</H2>
<pre>
2
65539010
65539010
</pre>
<H2>Output for the Sample Input</H2>
<pre>
96417531
96417531
</pre>
|
s883914182 | p00051 | Accepted | def solve(data):
result = []
for d in data:
temp = list(d)
min_val = int(''.join(sorted(temp)))
max_val = int(''.join(sorted(temp, reverse=True)))
result.append(max_val - min_val)
return result
if __name__ == '__main__':
# ??????????????\???1
24241
num_of_set = int(input().strip())
data = [input() for _ in range(num_of_set)]
# ????????¨???????????¨???
result = solve(data)
for r in result:
print(r) | 2
65539010
65539010
| 96417531
96417531
|
<H1>整数の差</H1>
<p>
8 個の 0 から 9 までの数字を入力したとき、その 8 個の数字を並べ替えてできる、最大の整数と最小の整数の差を出力するプログラムを作成してください。並び替えてできる数は 00135569 のように 0 から始まってもよいものとします。
</p>
<H2>Input</H2>
<p>
複数のデータセットが与えられます。１行目にデータセット数 <var>n</var> (<var>n</var> ≤ 50) が与えられます。続いて <var>n</var> 行のデータが与えられます。各データは 8 個の数字の並び（0 から 9 の数字）です。
</p>
<H2>Output</H2>
<p>
各データセットに対して、入力された数字を並べ替えてできる最大の整数と最小の整数の差を１行に出力して下さい。
</p>
<H2>Sample Input</H2>
<pre>
2
65539010
65539010
</pre>
<H2>Output for the Sample Input</H2>
<pre>
96417531
96417531
</pre>
|
s021297167 | p00051 | Accepted | n = int(input())
for i in range(n):
num = input()
n = [i for i in num]
n_sort = sorted(n)
n_sort2 = sorted(n, reverse=True)
n_sort = "".join(n_sort)
n_sort2 = "".join(n_sort2)
print(int(n_sort2) - int(n_sort)) | 2
65539010
65539010
| 96417531
96417531
|
<H1>整数の差</H1>
<p>
8 個の 0 から 9 までの数字を入力したとき、その 8 個の数字を並べ替えてできる、最大の整数と最小の整数の差を出力するプログラムを作成してください。並び替えてできる数は 00135569 のように 0 から始まってもよいものとします。
</p>
<H2>Input</H2>
<p>
複数のデータセットが与えられます。１行目にデータセット数 <var>n</var> (<var>n</var> ≤ 50) が与えられます。続いて <var>n</var> 行のデータが与えられます。各データは 8 個の数字の並び（0 から 9 の数字）です。
</p>
<H2>Output</H2>
<p>
各データセットに対して、入力された数字を並べ替えてできる最大の整数と最小の整数の差を１行に出力して下さい。
</p>
<H2>Sample Input</H2>
<pre>
2
65539010
65539010
</pre>
<H2>Output for the Sample Input</H2>
<pre>
96417531
96417531
</pre>
|
s604017518 | p00051 | Accepted | # Aizu Problem 0051: Differential II
#
import sys, math, os
# read input:
PYDEV = os.environ.get('PYDEV')
if PYDEV=="True":
sys.stdin = open("sample-input.txt", "rt")
N = int(input())
for n in range(N):
k = sorted([_ for _ in input().strip()])
print(int(''.join(k[::-1])) - int(''.join(k))) | 2
65539010
65539010
| 96417531
96417531
|
<H1>整数の差</H1>
<p>
8 個の 0 から 9 までの数字を入力したとき、その 8 個の数字を並べ替えてできる、最大の整数と最小の整数の差を出力するプログラムを作成してください。並び替えてできる数は 00135569 のように 0 から始まってもよいものとします。
</p>
<H2>Input</H2>
<p>
複数のデータセットが与えられます。１行目にデータセット数 <var>n</var> (<var>n</var> ≤ 50) が与えられます。続いて <var>n</var> 行のデータが与えられます。各データは 8 個の数字の並び（0 から 9 の数字）です。
</p>
<H2>Output</H2>
<p>
各データセットに対して、入力された数字を並べ替えてできる最大の整数と最小の整数の差を１行に出力して下さい。
</p>
<H2>Sample Input</H2>
<pre>
2
65539010
65539010
</pre>
<H2>Output for the Sample Input</H2>
<pre>
96417531
96417531
</pre>
|
s613604476 | p00051 | Accepted | for _ in range(int(input())):
i = input()
max = int(''.join(sorted(list(i), reverse=True)))
min = int(''.join(sorted(list(i))))
print(max - min)
| 2
65539010
65539010
| 96417531
96417531
|
<H1>整数の差</H1>
<p>
8 個の 0 から 9 までの数字を入力したとき、その 8 個の数字を並べ替えてできる、最大の整数と最小の整数の差を出力するプログラムを作成してください。並び替えてできる数は 00135569 のように 0 から始まってもよいものとします。
</p>
<H2>Input</H2>
<p>
複数のデータセットが与えられます。１行目にデータセット数 <var>n</var> (<var>n</var> ≤ 50) が与えられます。続いて <var>n</var> 行のデータが与えられます。各データは 8 個の数字の並び（0 から 9 の数字）です。
</p>
<H2>Output</H2>
<p>
各データセットに対して、入力された数字を並べ替えてできる最大の整数と最小の整数の差を１行に出力して下さい。
</p>
<H2>Sample Input</H2>
<pre>
2
65539010
65539010
</pre>
<H2>Output for the Sample Input</H2>
<pre>
96417531
96417531
</pre>
|
s687980635 | p00051 | Accepted | def main():
n = int(input())
while n:
a = ''.join(sorted(input()))
print(int(a[::-1]) - int(a))
n -= 1
if __name__ == '__main__':
main()
| 2
65539010
65539010
| 96417531
96417531
|
<H1>整数の差</H1>
<p>
8 個の 0 から 9 までの数字を入力したとき、その 8 個の数字を並べ替えてできる、最大の整数と最小の整数の差を出力するプログラムを作成してください。並び替えてできる数は 00135569 のように 0 から始まってもよいものとします。
</p>
<H2>Input</H2>
<p>
複数のデータセットが与えられます。１行目にデータセット数 <var>n</var> (<var>n</var> ≤ 50) が与えられます。続いて <var>n</var> 行のデータが与えられます。各データは 8 個の数字の並び（0 から 9 の数字）です。
</p>
<H2>Output</H2>
<p>
各データセットに対して、入力された数字を並べ替えてできる最大の整数と最小の整数の差を１行に出力して下さい。
</p>
<H2>Sample Input</H2>
<pre>
2
65539010
65539010
</pre>
<H2>Output for the Sample Input</H2>
<pre>
96417531
96417531
</pre>
|
s025843592 | p00051 | Accepted | n = int(input())
for i in range(n):
inp = list(map(int, list(input())))
inp_min = sorted(inp)
inp_max = inp_min[::-1]
print(int("".join(map(str, inp_max))) - int("".join(map(str, inp_min))))
| 2
65539010
65539010
| 96417531
96417531
|
<H1>整数の差</H1>
<p>
8 個の 0 から 9 までの数字を入力したとき、その 8 個の数字を並べ替えてできる、最大の整数と最小の整数の差を出力するプログラムを作成してください。並び替えてできる数は 00135569 のように 0 から始まってもよいものとします。
</p>
<H2>Input</H2>
<p>
複数のデータセットが与えられます。１行目にデータセット数 <var>n</var> (<var>n</var> ≤ 50) が与えられます。続いて <var>n</var> 行のデータが与えられます。各データは 8 個の数字の並び（0 から 9 の数字）です。
</p>
<H2>Output</H2>
<p>
各データセットに対して、入力された数字を並べ替えてできる最大の整数と最小の整数の差を１行に出力して下さい。
</p>
<H2>Sample Input</H2>
<pre>
2
65539010
65539010
</pre>
<H2>Output for the Sample Input</H2>
<pre>
96417531
96417531
</pre>
|
s328794693 | p00051 | Accepted | N = int(input())
for l in range(N):
s = input()
n = []
for i in range(len(s)):
n.append(int(s[i]))
a,b = 0,0
n.sort()
for i in range(len(n)):
a *= 10
a += n[i]
b *= 10
b += n[len(n)-i-1]
print(b-a)
| 2
65539010
65539010
| 96417531
96417531
|
<H1>整数の差</H1>
<p>
8 個の 0 から 9 までの数字を入力したとき、その 8 個の数字を並べ替えてできる、最大の整数と最小の整数の差を出力するプログラムを作成してください。並び替えてできる数は 00135569 のように 0 から始まってもよいものとします。
</p>
<H2>Input</H2>
<p>
複数のデータセットが与えられます。１行目にデータセット数 <var>n</var> (<var>n</var> ≤ 50) が与えられます。続いて <var>n</var> 行のデータが与えられます。各データは 8 個の数字の並び（0 から 9 の数字）です。
</p>
<H2>Output</H2>
<p>
各データセットに対して、入力された数字を並べ替えてできる最大の整数と最小の整数の差を１行に出力して下さい。
</p>
<H2>Sample Input</H2>
<pre>
2
65539010
65539010
</pre>
<H2>Output for the Sample Input</H2>
<pre>
96417531
96417531
</pre>
|
s527939152 | p00051 | Accepted | for _ in[0]*int(input()):
M=''.join(sorted(input()))
print(int(M[::-1])-int(M))
| 2
65539010
65539010
| 96417531
96417531
|
<H1>整数の差</H1>
<p>
8 個の 0 から 9 までの数字を入力したとき、その 8 個の数字を並べ替えてできる、最大の整数と最小の整数の差を出力するプログラムを作成してください。並び替えてできる数は 00135569 のように 0 から始まってもよいものとします。
</p>
<H2>Input</H2>
<p>
複数のデータセットが与えられます。１行目にデータセット数 <var>n</var> (<var>n</var> ≤ 50) が与えられます。続いて <var>n</var> 行のデータが与えられます。各データは 8 個の数字の並び（0 から 9 の数字）です。
</p>
<H2>Output</H2>
<p>
各データセットに対して、入力された数字を並べ替えてできる最大の整数と最小の整数の差を１行に出力して下さい。
</p>
<H2>Sample Input</H2>
<pre>
2
65539010
65539010
</pre>
<H2>Output for the Sample Input</H2>
<pre>
96417531
96417531
</pre>
|
s264914469 | p00051 | Accepted | w = int(input())
for i in range(w):
n = input()
l = sorted(n, reverse=True)
s = sorted(n)
print(int(''.join(l)) - int(''.join(s)))
| 2
65539010
65539010
| 96417531
96417531
|
<H1>整数の差</H1>
<p>
8 個の 0 から 9 までの数字を入力したとき、その 8 個の数字を並べ替えてできる、最大の整数と最小の整数の差を出力するプログラムを作成してください。並び替えてできる数は 00135569 のように 0 から始まってもよいものとします。
</p>
<H2>Input</H2>
<p>
複数のデータセットが与えられます。１行目にデータセット数 <var>n</var> (<var>n</var> ≤ 50) が与えられます。続いて <var>n</var> 行のデータが与えられます。各データは 8 個の数字の並び（0 から 9 の数字）です。
</p>
<H2>Output</H2>
<p>
各データセットに対して、入力された数字を並べ替えてできる最大の整数と最小の整数の差を１行に出力して下さい。
</p>
<H2>Sample Input</H2>
<pre>
2
65539010
65539010
</pre>
<H2>Output for the Sample Input</H2>
<pre>
96417531
96417531
</pre>
|
s060849458 | p00051 | Accepted | n = int(input())
nl = []
for i in range(n):
a = int(input())
b = list(str(a))
c1 = list(sorted(b))
c2 = list(reversed(c1))
cc1 = ''
cc2 = ''
for i in range(len(c1)):
cc1 = cc1 + c1[i]
cc2 = cc2 + c2[i]
c1n = int(cc1)
c2n = int(cc2)
nl.append(abs(c1n-c2n))
for i in range(len(nl)):
print(nl[i])
| 2
65539010
65539010
| 96417531
96417531
|
<H1>整数の差</H1>
<p>
8 個の 0 から 9 までの数字を入力したとき、その 8 個の数字を並べ替えてできる、最大の整数と最小の整数の差を出力するプログラムを作成してください。並び替えてできる数は 00135569 のように 0 から始まってもよいものとします。
</p>
<H2>Input</H2>
<p>
複数のデータセットが与えられます。１行目にデータセット数 <var>n</var> (<var>n</var> ≤ 50) が与えられます。続いて <var>n</var> 行のデータが与えられます。各データは 8 個の数字の並び（0 から 9 の数字）です。
</p>
<H2>Output</H2>
<p>
各データセットに対して、入力された数字を並べ替えてできる最大の整数と最小の整数の差を１行に出力して下さい。
</p>
<H2>Sample Input</H2>
<pre>
2
65539010
65539010
</pre>
<H2>Output for the Sample Input</H2>
<pre>
96417531
96417531
</pre>
|
s555678676 | p00051 | Accepted | for _ in range(int(input())):
a = list(input())
print(int("".join(sorted(a, reverse = True))) - int("".join(sorted(a))))
| 2
65539010
65539010
| 96417531
96417531
|
<H1>整数の差</H1>
<p>
8 個の 0 から 9 までの数字を入力したとき、その 8 個の数字を並べ替えてできる、最大の整数と最小の整数の差を出力するプログラムを作成してください。並び替えてできる数は 00135569 のように 0 から始まってもよいものとします。
</p>
<H2>Input</H2>
<p>
複数のデータセットが与えられます。１行目にデータセット数 <var>n</var> (<var>n</var> ≤ 50) が与えられます。続いて <var>n</var> 行のデータが与えられます。各データは 8 個の数字の並び（0 から 9 の数字）です。
</p>
<H2>Output</H2>
<p>
各データセットに対して、入力された数字を並べ替えてできる最大の整数と最小の整数の差を１行に出力して下さい。
</p>
<H2>Sample Input</H2>
<pre>
2
65539010
65539010
</pre>
<H2>Output for the Sample Input</H2>
<pre>
96417531
96417531
</pre>
|
s553931503 | p00051 | Accepted | n = int(input())
for _ in range(n):
s = list(input())
print(int("".join(sorted(s,reverse=True))) - int("".join(sorted(s))))
| 2
65539010
65539010
| 96417531
96417531
|
<H1>整数の差</H1>
<p>
8 個の 0 から 9 までの数字を入力したとき、その 8 個の数字を並べ替えてできる、最大の整数と最小の整数の差を出力するプログラムを作成してください。並び替えてできる数は 00135569 のように 0 から始まってもよいものとします。
</p>
<H2>Input</H2>
<p>
複数のデータセットが与えられます。１行目にデータセット数 <var>n</var> (<var>n</var> ≤ 50) が与えられます。続いて <var>n</var> 行のデータが与えられます。各データは 8 個の数字の並び（0 から 9 の数字）です。
</p>
<H2>Output</H2>
<p>
各データセットに対して、入力された数字を並べ替えてできる最大の整数と最小の整数の差を１行に出力して下さい。
</p>
<H2>Sample Input</H2>
<pre>
2
65539010
65539010
</pre>
<H2>Output for the Sample Input</H2>
<pre>
96417531
96417531
</pre>
|
s195184113 | p00051 | Accepted | diff=lambda l:int("".join(map(str,sorted(l,reverse=True))))-int("".join(map(str,sorted(l))))
[print(diff(input())) for i in range(int(input()))]
| 2
65539010
65539010
| 96417531
96417531
|
<H1>整数の差</H1>
<p>
8 個の 0 から 9 までの数字を入力したとき、その 8 個の数字を並べ替えてできる、最大の整数と最小の整数の差を出力するプログラムを作成してください。並び替えてできる数は 00135569 のように 0 から始まってもよいものとします。
</p>
<H2>Input</H2>
<p>
複数のデータセットが与えられます。１行目にデータセット数 <var>n</var> (<var>n</var> ≤ 50) が与えられます。続いて <var>n</var> 行のデータが与えられます。各データは 8 個の数字の並び（0 から 9 の数字）です。
</p>
<H2>Output</H2>
<p>
各データセットに対して、入力された数字を並べ替えてできる最大の整数と最小の整数の差を１行に出力して下さい。
</p>
<H2>Sample Input</H2>
<pre>
2
65539010
65539010
</pre>
<H2>Output for the Sample Input</H2>
<pre>
96417531
96417531
</pre>
|
s523667468 | p00051 | Accepted | # AOJ 0051 Differential II
# Python3 2018.6.14 bal4u
n = int(input())
for i in range(n):
a = list(input())
print(int(''.join(sorted(a, reverse=True))) - int(''.join(sorted(a))))
| 2
65539010
65539010
| 96417531
96417531
|
<H1>整数の差</H1>
<p>
8 個の 0 から 9 までの数字を入力したとき、その 8 個の数字を並べ替えてできる、最大の整数と最小の整数の差を出力するプログラムを作成してください。並び替えてできる数は 00135569 のように 0 から始まってもよいものとします。
</p>
<H2>Input</H2>
<p>
複数のデータセットが与えられます。１行目にデータセット数 <var>n</var> (<var>n</var> ≤ 50) が与えられます。続いて <var>n</var> 行のデータが与えられます。各データは 8 個の数字の並び（0 から 9 の数字）です。
</p>
<H2>Output</H2>
<p>
各データセットに対して、入力された数字を並べ替えてできる最大の整数と最小の整数の差を１行に出力して下さい。
</p>
<H2>Sample Input</H2>
<pre>
2
65539010
65539010
</pre>
<H2>Output for the Sample Input</H2>
<pre>
96417531
96417531
</pre>
|
s739222920 | p00051 | Accepted | for _ in [0]*int(input()):
s = input()
max_n = int("".join(map(str, sorted(s, reverse=True))))
min_n = int("".join(map(str, sorted(s))))
print(max_n - min_n)
| 2
65539010
65539010
| 96417531
96417531
|
<H1>整数の差</H1>
<p>
8 個の 0 から 9 までの数字を入力したとき、その 8 個の数字を並べ替えてできる、最大の整数と最小の整数の差を出力するプログラムを作成してください。並び替えてできる数は 00135569 のように 0 から始まってもよいものとします。
</p>
<H2>Input</H2>
<p>
複数のデータセットが与えられます。１行目にデータセット数 <var>n</var> (<var>n</var> ≤ 50) が与えられます。続いて <var>n</var> 行のデータが与えられます。各データは 8 個の数字の並び（0 から 9 の数字）です。
</p>
<H2>Output</H2>
<p>
各データセットに対して、入力された数字を並べ替えてできる最大の整数と最小の整数の差を１行に出力して下さい。
</p>
<H2>Sample Input</H2>
<pre>
2
65539010
65539010
</pre>
<H2>Output for the Sample Input</H2>
<pre>
96417531
96417531
</pre>
|
s494440881 | p00051 | Accepted | #!/usr/bin/env python
# coding: utf-8
import sys
def get_answer(param):
param = list(param)
param.sort()
small = int("".join(param), 10)
big = int("".join(param[::-1]), 10)
return big - small
def main():
params = [line.replace("\n", "") for line in sys.stdin.readlines()]
params.pop(0)
for param in params:
print get_answer(param)
if __name__ == '__main__':
main() | 2
65539010
65539010
| 96417531
96417531
|
<H1>整数の差</H1>
<p>
8 個の 0 から 9 までの数字を入力したとき、その 8 個の数字を並べ替えてできる、最大の整数と最小の整数の差を出力するプログラムを作成してください。並び替えてできる数は 00135569 のように 0 から始まってもよいものとします。
</p>
<H2>Input</H2>
<p>
複数のデータセットが与えられます。１行目にデータセット数 <var>n</var> (<var>n</var> ≤ 50) が与えられます。続いて <var>n</var> 行のデータが与えられます。各データは 8 個の数字の並び（0 から 9 の数字）です。
</p>
<H2>Output</H2>
<p>
各データセットに対して、入力された数字を並べ替えてできる最大の整数と最小の整数の差を１行に出力して下さい。
</p>
<H2>Sample Input</H2>
<pre>
2
65539010
65539010
</pre>
<H2>Output for the Sample Input</H2>
<pre>
96417531
96417531
</pre>
|
s331685081 | p00051 | Accepted | for i in xrange(input()):
num=[i for i in raw_input()]
mi=sorted(num)
ma=sorted(num,reverse=True)
print int("".join(ma))-int("".join(mi)) | 2
65539010
65539010
| 96417531
96417531
|
<H1>整数の差</H1>
<p>
8 個の 0 から 9 までの数字を入力したとき、その 8 個の数字を並べ替えてできる、最大の整数と最小の整数の差を出力するプログラムを作成してください。並び替えてできる数は 00135569 のように 0 から始まってもよいものとします。
</p>
<H2>Input</H2>
<p>
複数のデータセットが与えられます。１行目にデータセット数 <var>n</var> (<var>n</var> ≤ 50) が与えられます。続いて <var>n</var> 行のデータが与えられます。各データは 8 個の数字の並び（0 から 9 の数字）です。
</p>
<H2>Output</H2>
<p>
各データセットに対して、入力された数字を並べ替えてできる最大の整数と最小の整数の差を１行に出力して下さい。
</p>
<H2>Sample Input</H2>
<pre>
2
65539010
65539010
</pre>
<H2>Output for the Sample Input</H2>
<pre>
96417531
96417531
</pre>
|
s234957826 | p00051 | Accepted | n = int(raw_input())
for i in range(n):
s = list(raw_input())
s.sort()
min = int("".join(s))
s.reverse()
max = int("".join(s))
print("%d" % (max - min, )) | 2
65539010
65539010
| 96417531
96417531
|
<H1>整数の差</H1>
<p>
8 個の 0 から 9 までの数字を入力したとき、その 8 個の数字を並べ替えてできる、最大の整数と最小の整数の差を出力するプログラムを作成してください。並び替えてできる数は 00135569 のように 0 から始まってもよいものとします。
</p>
<H2>Input</H2>
<p>
複数のデータセットが与えられます。１行目にデータセット数 <var>n</var> (<var>n</var> ≤ 50) が与えられます。続いて <var>n</var> 行のデータが与えられます。各データは 8 個の数字の並び（0 から 9 の数字）です。
</p>
<H2>Output</H2>
<p>
各データセットに対して、入力された数字を並べ替えてできる最大の整数と最小の整数の差を１行に出力して下さい。
</p>
<H2>Sample Input</H2>
<pre>
2
65539010
65539010
</pre>
<H2>Output for the Sample Input</H2>
<pre>
96417531
96417531
</pre>
|
s587453366 | p00051 | Accepted | n = int(raw_input())
for i in range(n):
s = sorted(raw_input())
min = int("".join(s))
max = int("".join(reversed(s)))
print("%d" % (max - min, )) | 2
65539010
65539010
| 96417531
96417531
|
<H1>整数の差</H1>
<p>
8 個の 0 から 9 までの数字を入力したとき、その 8 個の数字を並べ替えてできる、最大の整数と最小の整数の差を出力するプログラムを作成してください。並び替えてできる数は 00135569 のように 0 から始まってもよいものとします。
</p>
<H2>Input</H2>
<p>
複数のデータセットが与えられます。１行目にデータセット数 <var>n</var> (<var>n</var> ≤ 50) が与えられます。続いて <var>n</var> 行のデータが与えられます。各データは 8 個の数字の並び（0 から 9 の数字）です。
</p>
<H2>Output</H2>
<p>
各データセットに対して、入力された数字を並べ替えてできる最大の整数と最小の整数の差を１行に出力して下さい。
</p>
<H2>Sample Input</H2>
<pre>
2
65539010
65539010
</pre>
<H2>Output for the Sample Input</H2>
<pre>
96417531
96417531
</pre>
|
s669864074 | p00051 | Accepted |
import sys
def solv(nums):
nums.sort()
min_number = int(''.join(nums))
nums.sort(lambda a, b: cmp(b, a))
max_number = int(''.join(nums))
return max_number - min_number
sys.stdin.readline()
for line in sys.stdin:
nums = list(line.rstrip('\n'))
print solv(nums) | 2
65539010
65539010
| 96417531
96417531
|
<H1>整数の差</H1>
<p>
8 個の 0 から 9 までの数字を入力したとき、その 8 個の数字を並べ替えてできる、最大の整数と最小の整数の差を出力するプログラムを作成してください。並び替えてできる数は 00135569 のように 0 から始まってもよいものとします。
</p>
<H2>Input</H2>
<p>
複数のデータセットが与えられます。１行目にデータセット数 <var>n</var> (<var>n</var> ≤ 50) が与えられます。続いて <var>n</var> 行のデータが与えられます。各データは 8 個の数字の並び（0 から 9 の数字）です。
</p>
<H2>Output</H2>
<p>
各データセットに対して、入力された数字を並べ替えてできる最大の整数と最小の整数の差を１行に出力して下さい。
</p>
<H2>Sample Input</H2>
<pre>
2
65539010
65539010
</pre>
<H2>Output for the Sample Input</H2>
<pre>
96417531
96417531
</pre>
|
s052793804 | p00051 | Accepted | n = int(raw_input())
for i in range(n):
t = list(raw_input())
t.sort()
#print t
lo = int("".join(map(str,t)))
t.reverse()
he = int("".join(map(str,t)))
#print he
print he-lo | 2
65539010
65539010
| 96417531
96417531
|
<H1>整数の差</H1>
<p>
8 個の 0 から 9 までの数字を入力したとき、その 8 個の数字を並べ替えてできる、最大の整数と最小の整数の差を出力するプログラムを作成してください。並び替えてできる数は 00135569 のように 0 から始まってもよいものとします。
</p>
<H2>Input</H2>
<p>
複数のデータセットが与えられます。１行目にデータセット数 <var>n</var> (<var>n</var> ≤ 50) が与えられます。続いて <var>n</var> 行のデータが与えられます。各データは 8 個の数字の並び（0 から 9 の数字）です。
</p>
<H2>Output</H2>
<p>
各データセットに対して、入力された数字を並べ替えてできる最大の整数と最小の整数の差を１行に出力して下さい。
</p>
<H2>Sample Input</H2>
<pre>
2
65539010
65539010
</pre>
<H2>Output for the Sample Input</H2>
<pre>
96417531
96417531
</pre>
|
s072918052 | p00051 | Accepted | #!/usr/bin/env python
# -*- coding: utf-8 -*-
from __future__ import (division, absolute_import, print_function,
unicode_literals)
from sys import stdin
n = int(stdin.readline())
for _ in range(n):
s = stdin.readline().strip()
under = int(''.join(sorted(s)))
upper = int(''.join(sorted(s, reverse=True)))
print(upper - under) | 2
65539010
65539010
| 96417531
96417531
|
<H1>整数の差</H1>
<p>
8 個の 0 から 9 までの数字を入力したとき、その 8 個の数字を並べ替えてできる、最大の整数と最小の整数の差を出力するプログラムを作成してください。並び替えてできる数は 00135569 のように 0 から始まってもよいものとします。
</p>
<H2>Input</H2>
<p>
複数のデータセットが与えられます。１行目にデータセット数 <var>n</var> (<var>n</var> ≤ 50) が与えられます。続いて <var>n</var> 行のデータが与えられます。各データは 8 個の数字の並び（0 から 9 の数字）です。
</p>
<H2>Output</H2>
<p>
各データセットに対して、入力された数字を並べ替えてできる最大の整数と最小の整数の差を１行に出力して下さい。
</p>
<H2>Sample Input</H2>
<pre>
2
65539010
65539010
</pre>
<H2>Output for the Sample Input</H2>
<pre>
96417531
96417531
</pre>
|
s113709324 | p00051 | Accepted | n = int(raw_input())
for _ in range(n):
s = raw_input()
print int(''.join(sorted(s, reverse = True))) - int(''.join(sorted(s))) | 2
65539010
65539010
| 96417531
96417531
|
<H1>整数の差</H1>
<p>
8 個の 0 から 9 までの数字を入力したとき、その 8 個の数字を並べ替えてできる、最大の整数と最小の整数の差を出力するプログラムを作成してください。並び替えてできる数は 00135569 のように 0 から始まってもよいものとします。
</p>
<H2>Input</H2>
<p>
複数のデータセットが与えられます。１行目にデータセット数 <var>n</var> (<var>n</var> ≤ 50) が与えられます。続いて <var>n</var> 行のデータが与えられます。各データは 8 個の数字の並び（0 から 9 の数字）です。
</p>
<H2>Output</H2>
<p>
各データセットに対して、入力された数字を並べ替えてできる最大の整数と最小の整数の差を１行に出力して下さい。
</p>
<H2>Sample Input</H2>
<pre>
2
65539010
65539010
</pre>
<H2>Output for the Sample Input</H2>
<pre>
96417531
96417531
</pre>
|
s029213857 | p00051 | Accepted | n=input()
while n:
n-=1
a="".join(sorted(str(input())))
print int(a[::-1])-int(a) | 2
65539010
65539010
| 96417531
96417531
|
<H1>整数の差</H1>
<p>
8 個の 0 から 9 までの数字を入力したとき、その 8 個の数字を並べ替えてできる、最大の整数と最小の整数の差を出力するプログラムを作成してください。並び替えてできる数は 00135569 のように 0 から始まってもよいものとします。
</p>
<H2>Input</H2>
<p>
複数のデータセットが与えられます。１行目にデータセット数 <var>n</var> (<var>n</var> ≤ 50) が与えられます。続いて <var>n</var> 行のデータが与えられます。各データは 8 個の数字の並び（0 から 9 の数字）です。
</p>
<H2>Output</H2>
<p>
各データセットに対して、入力された数字を並べ替えてできる最大の整数と最小の整数の差を１行に出力して下さい。
</p>
<H2>Sample Input</H2>
<pre>
2
65539010
65539010
</pre>
<H2>Output for the Sample Input</H2>
<pre>
96417531
96417531
</pre>
|
s501598611 | p00051 | Accepted | n=input()
while n:
n-=1
a="".join(sorted(raw_input()))
print int(a[::-1])-int(a) | 2
65539010
65539010
| 96417531
96417531
|
<H1>整数の差</H1>
<p>
8 個の 0 から 9 までの数字を入力したとき、その 8 個の数字を並べ替えてできる、最大の整数と最小の整数の差を出力するプログラムを作成してください。並び替えてできる数は 00135569 のように 0 から始まってもよいものとします。
</p>
<H2>Input</H2>
<p>
複数のデータセットが与えられます。１行目にデータセット数 <var>n</var> (<var>n</var> ≤ 50) が与えられます。続いて <var>n</var> 行のデータが与えられます。各データは 8 個の数字の並び（0 から 9 の数字）です。
</p>
<H2>Output</H2>
<p>
各データセットに対して、入力された数字を並べ替えてできる最大の整数と最小の整数の差を１行に出力して下さい。
</p>
<H2>Sample Input</H2>
<pre>
2
65539010
65539010
</pre>
<H2>Output for the Sample Input</H2>
<pre>
96417531
96417531
</pre>
|
s675850730 | p00051 | Accepted | n = int(raw_input())
for i in range(n):
inp = raw_input()
min = sorted(list(inp))
max = sorted(list(inp))
max.reverse()
print int("".join(map(str, max))) - int("".join(map(str, min))) | 2
65539010
65539010
| 96417531
96417531
|
<H1>整数の差</H1>
<p>
8 個の 0 から 9 までの数字を入力したとき、その 8 個の数字を並べ替えてできる、最大の整数と最小の整数の差を出力するプログラムを作成してください。並び替えてできる数は 00135569 のように 0 から始まってもよいものとします。
</p>
<H2>Input</H2>
<p>
複数のデータセットが与えられます。１行目にデータセット数 <var>n</var> (<var>n</var> ≤ 50) が与えられます。続いて <var>n</var> 行のデータが与えられます。各データは 8 個の数字の並び（0 から 9 の数字）です。
</p>
<H2>Output</H2>
<p>
各データセットに対して、入力された数字を並べ替えてできる最大の整数と最小の整数の差を１行に出力して下さい。
</p>
<H2>Sample Input</H2>
<pre>
2
65539010
65539010
</pre>
<H2>Output for the Sample Input</H2>
<pre>
96417531
96417531
</pre>
|
s565162515 | p00051 | Accepted | n = int(raw_input())
for i in range(n):
m = "".join(sorted(raw_input()))
print int(m[::-1]) - int(m) | 2
65539010
65539010
| 96417531
96417531
|
<H1>整数の差</H1>
<p>
8 個の 0 から 9 までの数字を入力したとき、その 8 個の数字を並べ替えてできる、最大の整数と最小の整数の差を出力するプログラムを作成してください。並び替えてできる数は 00135569 のように 0 から始まってもよいものとします。
</p>
<H2>Input</H2>
<p>
複数のデータセットが与えられます。１行目にデータセット数 <var>n</var> (<var>n</var> ≤ 50) が与えられます。続いて <var>n</var> 行のデータが与えられます。各データは 8 個の数字の並び（0 から 9 の数字）です。
</p>
<H2>Output</H2>
<p>
各データセットに対して、入力された数字を並べ替えてできる最大の整数と最小の整数の差を１行に出力して下さい。
</p>
<H2>Sample Input</H2>
<pre>
2
65539010
65539010
</pre>
<H2>Output for the Sample Input</H2>
<pre>
96417531
96417531
</pre>
|
s862517271 | p00051 | Accepted | for i in range(int(raw_input())):
s = raw_input()
print int(''.join(sorted(s, reverse=True))) - int(''.join(sorted(s))) | 2
65539010
65539010
| 96417531
96417531
|
<H1>整数の差</H1>
<p>
8 個の 0 から 9 までの数字を入力したとき、その 8 個の数字を並べ替えてできる、最大の整数と最小の整数の差を出力するプログラムを作成してください。並び替えてできる数は 00135569 のように 0 から始まってもよいものとします。
</p>
<H2>Input</H2>
<p>
複数のデータセットが与えられます。１行目にデータセット数 <var>n</var> (<var>n</var> ≤ 50) が与えられます。続いて <var>n</var> 行のデータが与えられます。各データは 8 個の数字の並び（0 から 9 の数字）です。
</p>
<H2>Output</H2>
<p>
各データセットに対して、入力された数字を並べ替えてできる最大の整数と最小の整数の差を１行に出力して下さい。
</p>
<H2>Sample Input</H2>
<pre>
2
65539010
65539010
</pre>
<H2>Output for the Sample Input</H2>
<pre>
96417531
96417531
</pre>
|
s665075789 | p00051 | Accepted | for i in range(input()):
n = list(raw_input())
n.sort()
mini = int("".join(sorted(n)))
mixi = int("".join(sorted(n)[::-1]))
print mixi - mini | 2
65539010
65539010
| 96417531
96417531
|
<H1>整数の差</H1>
<p>
8 個の 0 から 9 までの数字を入力したとき、その 8 個の数字を並べ替えてできる、最大の整数と最小の整数の差を出力するプログラムを作成してください。並び替えてできる数は 00135569 のように 0 から始まってもよいものとします。
</p>
<H2>Input</H2>
<p>
複数のデータセットが与えられます。１行目にデータセット数 <var>n</var> (<var>n</var> ≤ 50) が与えられます。続いて <var>n</var> 行のデータが与えられます。各データは 8 個の数字の並び（0 から 9 の数字）です。
</p>
<H2>Output</H2>
<p>
各データセットに対して、入力された数字を並べ替えてできる最大の整数と最小の整数の差を１行に出力して下さい。
</p>
<H2>Sample Input</H2>
<pre>
2
65539010
65539010
</pre>
<H2>Output for the Sample Input</H2>
<pre>
96417531
96417531
</pre>
|
s949564266 | p00051 | Accepted | n = input()
for i in xrange(n):
num = raw_input()
print int(''.join(sorted(num, reverse=True))) - int(''.join(sorted(num))) | 2
65539010
65539010
| 96417531
96417531
|
<H1>整数の差</H1>
<p>
8 個の 0 から 9 までの数字を入力したとき、その 8 個の数字を並べ替えてできる、最大の整数と最小の整数の差を出力するプログラムを作成してください。並び替えてできる数は 00135569 のように 0 から始まってもよいものとします。
</p>
<H2>Input</H2>
<p>
複数のデータセットが与えられます。１行目にデータセット数 <var>n</var> (<var>n</var> ≤ 50) が与えられます。続いて <var>n</var> 行のデータが与えられます。各データは 8 個の数字の並び（0 から 9 の数字）です。
</p>
<H2>Output</H2>
<p>
各データセットに対して、入力された数字を並べ替えてできる最大の整数と最小の整数の差を１行に出力して下さい。
</p>
<H2>Sample Input</H2>
<pre>
2
65539010
65539010
</pre>
<H2>Output for the Sample Input</H2>
<pre>
96417531
96417531
</pre>
|
s080394331 | p00051 | Accepted | n = int(input())
for i in range(n):
s = sorted(input())
print(int(''.join(s[::-1])) - int(''.join(s))) | 2
65539010
65539010
| 96417531
96417531
|
<H1>整数の差</H1>
<p>
8 個の 0 から 9 までの数字を入力したとき、その 8 個の数字を並べ替えてできる、最大の整数と最小の整数の差を出力するプログラムを作成してください。並び替えてできる数は 00135569 のように 0 から始まってもよいものとします。
</p>
<H2>Input</H2>
<p>
複数のデータセットが与えられます。１行目にデータセット数 <var>n</var> (<var>n</var> ≤ 50) が与えられます。続いて <var>n</var> 行のデータが与えられます。各データは 8 個の数字の並び（0 から 9 の数字）です。
</p>
<H2>Output</H2>
<p>
各データセットに対して、入力された数字を並べ替えてできる最大の整数と最小の整数の差を１行に出力して下さい。
</p>
<H2>Sample Input</H2>
<pre>
2
65539010
65539010
</pre>
<H2>Output for the Sample Input</H2>
<pre>
96417531
96417531
</pre>
|
s509183068 | p00051 | Accepted | n = int(input())
for i in range(n):
numlst = list(input())
numlst.sort(reverse= True)
maxnum = [i for i in numlst]
numlst.sort()
minnum = [i for i in numlst]
maxnum = int(''.join(maxnum))
minnum = int(''.join(minnum))
print(maxnum - minnum)
| 2
65539010
65539010
| 96417531
96417531
|
<H1>整数の差</H1>
<p>
8 個の 0 から 9 までの数字を入力したとき、その 8 個の数字を並べ替えてできる、最大の整数と最小の整数の差を出力するプログラムを作成してください。並び替えてできる数は 00135569 のように 0 から始まってもよいものとします。
</p>
<H2>Input</H2>
<p>
複数のデータセットが与えられます。１行目にデータセット数 <var>n</var> (<var>n</var> ≤ 50) が与えられます。続いて <var>n</var> 行のデータが与えられます。各データは 8 個の数字の並び（0 から 9 の数字）です。
</p>
<H2>Output</H2>
<p>
各データセットに対して、入力された数字を並べ替えてできる最大の整数と最小の整数の差を１行に出力して下さい。
</p>
<H2>Sample Input</H2>
<pre>
2
65539010
65539010
</pre>
<H2>Output for the Sample Input</H2>
<pre>
96417531
96417531
</pre>
|
s773738075 | p00051 | Accepted | def toValue(arr):
s = 0
l = len(arr) - 1
i = 0
while l >= 0:
s += int(arr[i]) * pow(10,l)
i += 1
l -= 1
return s
n = int(input())
for i in range(0,n):
s = input()
max = []
for j in s:
max.append(j)
max = sorted(max,reverse=True)
min = sorted(max)
print(toValue(max) - toValue(min))
| 2
65539010
65539010
| 96417531
96417531
|
<H1>整数の差</H1>
<p>
8 個の 0 から 9 までの数字を入力したとき、その 8 個の数字を並べ替えてできる、最大の整数と最小の整数の差を出力するプログラムを作成してください。並び替えてできる数は 00135569 のように 0 から始まってもよいものとします。
</p>
<H2>Input</H2>
<p>
複数のデータセットが与えられます。１行目にデータセット数 <var>n</var> (<var>n</var> ≤ 50) が与えられます。続いて <var>n</var> 行のデータが与えられます。各データは 8 個の数字の並び（0 から 9 の数字）です。
</p>
<H2>Output</H2>
<p>
各データセットに対して、入力された数字を並べ替えてできる最大の整数と最小の整数の差を１行に出力して下さい。
</p>
<H2>Sample Input</H2>
<pre>
2
65539010
65539010
</pre>
<H2>Output for the Sample Input</H2>
<pre>
96417531
96417531
</pre>
|
s273323435 | p00051 | Accepted | n = int(input())
for i in range(n) :
list_m = list(input())
list_large_m = sorted(list_m, reverse = True)
list_small_m = sorted(list_m)
large_m = "".join(list_large_m)
small_m = "".join(list_small_m)
print(int(large_m) - int(small_m))
| 2
65539010
65539010
| 96417531
96417531
|
<H1>整数の差</H1>
<p>
8 個の 0 から 9 までの数字を入力したとき、その 8 個の数字を並べ替えてできる、最大の整数と最小の整数の差を出力するプログラムを作成してください。並び替えてできる数は 00135569 のように 0 から始まってもよいものとします。
</p>
<H2>Input</H2>
<p>
複数のデータセットが与えられます。１行目にデータセット数 <var>n</var> (<var>n</var> ≤ 50) が与えられます。続いて <var>n</var> 行のデータが与えられます。各データは 8 個の数字の並び（0 から 9 の数字）です。
</p>
<H2>Output</H2>
<p>
各データセットに対して、入力された数字を並べ替えてできる最大の整数と最小の整数の差を１行に出力して下さい。
</p>
<H2>Sample Input</H2>
<pre>
2
65539010
65539010
</pre>
<H2>Output for the Sample Input</H2>
<pre>
96417531
96417531
</pre>
|
s394069648 | p00051 | Accepted | import sys
readline = sys.stdin.readline
write = sys.stdout.write
def solve():
N = readline().strip()
res = int("".join(sorted(N, reverse=1))) - int("".join(sorted(N)))
write("%d\n" % res)
T = int(readline())
for i in range(T):
solve()
| 2
65539010
65539010
| 96417531
96417531
|
<H1>整数の差</H1>
<p>
8 個の 0 から 9 までの数字を入力したとき、その 8 個の数字を並べ替えてできる、最大の整数と最小の整数の差を出力するプログラムを作成してください。並び替えてできる数は 00135569 のように 0 から始まってもよいものとします。
</p>
<H2>Input</H2>
<p>
複数のデータセットが与えられます。１行目にデータセット数 <var>n</var> (<var>n</var> ≤ 50) が与えられます。続いて <var>n</var> 行のデータが与えられます。各データは 8 個の数字の並び（0 から 9 の数字）です。
</p>
<H2>Output</H2>
<p>
各データセットに対して、入力された数字を並べ替えてできる最大の整数と最小の整数の差を１行に出力して下さい。
</p>
<H2>Sample Input</H2>
<pre>
2
65539010
65539010
</pre>
<H2>Output for the Sample Input</H2>
<pre>
96417531
96417531
</pre>
|
s485852796 | p00051 | Accepted | for _ in range(int(input())): #与えられたデータセット回繰り返す
str0 = input() #標準入力
int1 = [int(a) for a in str0] #入力された値を数値化する
int1.sort() #リストの数を小さい順に並べる
int2 = sorted(int1,reverse=True) #大きい順に並べたリストの作成
str1 = [str(b) for b in int1] #"join"を使うために文字になおす
str2 = [str(c) for c in int2] #上記同様
strm1 = ''.join(str1) #リストを1個の文字列にする
strm2 = ''.join(str2) #上記同様
print(int(strm2) - int(strm1)) #2つの数の差を求める
| 2
65539010
65539010
| 96417531
96417531
|
<H1>整数の差</H1>
<p>
8 個の 0 から 9 までの数字を入力したとき、その 8 個の数字を並べ替えてできる、最大の整数と最小の整数の差を出力するプログラムを作成してください。並び替えてできる数は 00135569 のように 0 から始まってもよいものとします。
</p>
<H2>Input</H2>
<p>
複数のデータセットが与えられます。１行目にデータセット数 <var>n</var> (<var>n</var> ≤ 50) が与えられます。続いて <var>n</var> 行のデータが与えられます。各データは 8 個の数字の並び（0 から 9 の数字）です。
</p>
<H2>Output</H2>
<p>
各データセットに対して、入力された数字を並べ替えてできる最大の整数と最小の整数の差を１行に出力して下さい。
</p>
<H2>Sample Input</H2>
<pre>
2
65539010
65539010
</pre>
<H2>Output for the Sample Input</H2>
<pre>
96417531
96417531
</pre>
|
s379946834 | p00051 | Accepted | n = int(input())
for i in range(n):
s = input().strip()
min_str = ''.join(sorted(s))
max_str = ''.join(sorted(s, reverse=True))
print(int(max_str) - int(min_str))
| 2
65539010
65539010
| 96417531
96417531
|
<H1>整数の差</H1>
<p>
8 個の 0 から 9 までの数字を入力したとき、その 8 個の数字を並べ替えてできる、最大の整数と最小の整数の差を出力するプログラムを作成してください。並び替えてできる数は 00135569 のように 0 から始まってもよいものとします。
</p>
<H2>Input</H2>
<p>
複数のデータセットが与えられます。１行目にデータセット数 <var>n</var> (<var>n</var> ≤ 50) が与えられます。続いて <var>n</var> 行のデータが与えられます。各データは 8 個の数字の並び（0 から 9 の数字）です。
</p>
<H2>Output</H2>
<p>
各データセットに対して、入力された数字を並べ替えてできる最大の整数と最小の整数の差を１行に出力して下さい。
</p>
<H2>Sample Input</H2>
<pre>
2
65539010
65539010
</pre>
<H2>Output for the Sample Input</H2>
<pre>
96417531
96417531
</pre>
|
s875736378 | p00051 | Accepted | def ans_num(num):
min_list=(sorted(num,reverse=True))
#print(min_list)
max_list=sorted(num)
#print(max_list)
max_num=0
min_num=0
for i in range(len(num)):
max_num+=max_list[i]*(10**i)
min_num+=min_list[i]*(10**i)
return max_num-min_num
N=int(input())
for i in range(N):
num=list(map(int,input()))
print(ans_num(num))
| 2
65539010
65539010
| 96417531
96417531
|
<H1>整数の差</H1>
<p>
8 個の 0 から 9 までの数字を入力したとき、その 8 個の数字を並べ替えてできる、最大の整数と最小の整数の差を出力するプログラムを作成してください。並び替えてできる数は 00135569 のように 0 から始まってもよいものとします。
</p>
<H2>Input</H2>
<p>
複数のデータセットが与えられます。１行目にデータセット数 <var>n</var> (<var>n</var> ≤ 50) が与えられます。続いて <var>n</var> 行のデータが与えられます。各データは 8 個の数字の並び（0 から 9 の数字）です。
</p>
<H2>Output</H2>
<p>
各データセットに対して、入力された数字を並べ替えてできる最大の整数と最小の整数の差を１行に出力して下さい。
</p>
<H2>Sample Input</H2>
<pre>
2
65539010
65539010
</pre>
<H2>Output for the Sample Input</H2>
<pre>
96417531
96417531
</pre>
|
s833240638 | p00051 | Accepted | n=int(input())
while(n):
n-=1
a = list(input())
a.sort()
min = int("".join(a))
a.sort(reverse=True)
max = int("".join(a))
print(max-min)
| 2
65539010
65539010
| 96417531
96417531
|
<H1>整数の差</H1>
<p>
8 個の 0 から 9 までの数字を入力したとき、その 8 個の数字を並べ替えてできる、最大の整数と最小の整数の差を出力するプログラムを作成してください。並び替えてできる数は 00135569 のように 0 から始まってもよいものとします。
</p>
<H2>Input</H2>
<p>
複数のデータセットが与えられます。１行目にデータセット数 <var>n</var> (<var>n</var> ≤ 50) が与えられます。続いて <var>n</var> 行のデータが与えられます。各データは 8 個の数字の並び（0 から 9 の数字）です。
</p>
<H2>Output</H2>
<p>
各データセットに対して、入力された数字を並べ替えてできる最大の整数と最小の整数の差を１行に出力して下さい。
</p>
<H2>Sample Input</H2>
<pre>
2
65539010
65539010
</pre>
<H2>Output for the Sample Input</H2>
<pre>
96417531
96417531
</pre>
|
s554934229 | p00051 | Accepted | n = int(input())
for _ in range(n):
s = input()
max = int("".join(sorted(s,reverse=True)))
min = int("".join(sorted(s)))
print(max-min)
| 2
65539010
65539010
| 96417531
96417531
|
<H1>整数の差</H1>
<p>
8 個の 0 から 9 までの数字を入力したとき、その 8 個の数字を並べ替えてできる、最大の整数と最小の整数の差を出力するプログラムを作成してください。並び替えてできる数は 00135569 のように 0 から始まってもよいものとします。
</p>
<H2>Input</H2>
<p>
複数のデータセットが与えられます。１行目にデータセット数 <var>n</var> (<var>n</var> ≤ 50) が与えられます。続いて <var>n</var> 行のデータが与えられます。各データは 8 個の数字の並び（0 から 9 の数字）です。
</p>
<H2>Output</H2>
<p>
各データセットに対して、入力された数字を並べ替えてできる最大の整数と最小の整数の差を１行に出力して下さい。
</p>
<H2>Sample Input</H2>
<pre>
2
65539010
65539010
</pre>
<H2>Output for the Sample Input</H2>
<pre>
96417531
96417531
</pre>
|
s865359030 | p00051 | Accepted | n = int(input())
for i in range(n):
s = input()
minv = ''.join(sorted(s))
maxv = ''.join(sorted(s, reverse=1))
print(int(maxv) - int(minv))
| 2
65539010
65539010
| 96417531
96417531
|
<H1>整数の差</H1>
<p>
8 個の 0 から 9 までの数字を入力したとき、その 8 個の数字を並べ替えてできる、最大の整数と最小の整数の差を出力するプログラムを作成してください。並び替えてできる数は 00135569 のように 0 から始まってもよいものとします。
</p>
<H2>Input</H2>
<p>
複数のデータセットが与えられます。１行目にデータセット数 <var>n</var> (<var>n</var> ≤ 50) が与えられます。続いて <var>n</var> 行のデータが与えられます。各データは 8 個の数字の並び（0 から 9 の数字）です。
</p>
<H2>Output</H2>
<p>
各データセットに対して、入力された数字を並べ替えてできる最大の整数と最小の整数の差を１行に出力して下さい。
</p>
<H2>Sample Input</H2>
<pre>
2
65539010
65539010
</pre>
<H2>Output for the Sample Input</H2>
<pre>
96417531
96417531
</pre>
|
s203261198 | p00051 | Accepted | # coding=utf-8
###
### for atcorder program
###
import sys
import math
# math class
class mymath:
### pi
pi = 3.14159265358979323846264338
### Prime Number
def pnum_eratosthenes(self, n):
ptable = [0 for i in range(n+1)]
plist = []
for i in range(2, n+1):
if ptable[i]==0:
plist.append(i)
for j in range(i+i, n+1, i):
ptable[j] = 1
return plist
### GCD
def gcd(self, a, b):
if b == 0:
return a
return self.gcd(b, a%b)
### LCM
def lcm(self, a, b):
return (a*b)//self.gcd(a,b)
### Mat Multiplication
def mul(self, A, B):
ans = []
for a in A:
c = 0
for j, row in enumerate(a):
c += row*B[j]
ans.append(c)
return ans
mymath = mymath()
### output class
class output:
### list
def list(self, l):
l = list(l)
#print(" ", end="")
for i, num in enumerate(l):
print(num, end="")
if i != len(l)-1:
print(" ", end="")
print()
output = output()
### input sample
#i = input()
#N = int(input())
#A, B, C = [x for x in input().split()]
#N, K = [int(x) for x in input().split()]
#inlist = [int(w) for w in input().split()]
#R = float(input())
#A.append(list(map(int,input().split())))
#for line in sys.stdin.readlines():
# x, y = [int(temp) for temp in line.split()]
#abc list
#abc = [chr(ord('a') + i) for i in range(26)]
### output sample
#print("{0} {1} {2:.5f}".format(A//B, A%B, A/B))
#print("{0:.6f} {1:.6f}".format(R*R*math.pi,R*2*math.pi))
#print(" {}".format(i), end="")
# リスト内包表記 ifあり
# [x-k if x != 0 else x for x in C]
# ソート
# N = N.sort()
def get_input():
N = []
while True:
try:
N.append(input())
#N.append(int(input()))
#N.append(float(input()))
except EOFError:
break
return N
def is_integer(n):
try:
float(n)
except ValueError:
return False
else:
return float(n).is_integer()
def dist(A, B):
d = 0
for i in range(len(A)):
d += (A[i]-B[i])**2
d = d**(1/2)
return d
N = int(input())
for i in range(N):
S = input()
M = []
for s in S:
M.append(int(s))
M.sort()
minnum = 0
maxnum = 0
#print(M)
for j, n in enumerate(M[::-1]):
minnum += (n*10**(j))
for j, n in enumerate(M):
maxnum += (n*10**(j))
#print(minnum)
#print(maxnum)
print(maxnum-minnum)
| 2
65539010
65539010
| 96417531
96417531
|
<H1>整数の差</H1>
<p>
8 個の 0 から 9 までの数字を入力したとき、その 8 個の数字を並べ替えてできる、最大の整数と最小の整数の差を出力するプログラムを作成してください。並び替えてできる数は 00135569 のように 0 から始まってもよいものとします。
</p>
<H2>Input</H2>
<p>
複数のデータセットが与えられます。１行目にデータセット数 <var>n</var> (<var>n</var> ≤ 50) が与えられます。続いて <var>n</var> 行のデータが与えられます。各データは 8 個の数字の並び（0 から 9 の数字）です。
</p>
<H2>Output</H2>
<p>
各データセットに対して、入力された数字を並べ替えてできる最大の整数と最小の整数の差を１行に出力して下さい。
</p>
<H2>Sample Input</H2>
<pre>
2
65539010
65539010
</pre>
<H2>Output for the Sample Input</H2>
<pre>
96417531
96417531
</pre>
|
s572024310 | p00051 | Accepted | if __name__ == '__main__':
n = int(input())
for i in range(n):
tmp = ""
tmp2 = ""
line = list(map(int,input()))
ans = sorted(line)
for j in ans:
tmp += str(j)
ans2 = sorted(ans,reverse=True)
for k in ans2:
tmp2 += str(k)
print(int(tmp2) - int(tmp))
| 2
65539010
65539010
| 96417531
96417531
|
<H1>整数の差</H1>
<p>
8 個の 0 から 9 までの数字を入力したとき、その 8 個の数字を並べ替えてできる、最大の整数と最小の整数の差を出力するプログラムを作成してください。並び替えてできる数は 00135569 のように 0 から始まってもよいものとします。
</p>
<H2>Input</H2>
<p>
複数のデータセットが与えられます。１行目にデータセット数 <var>n</var> (<var>n</var> ≤ 50) が与えられます。続いて <var>n</var> 行のデータが与えられます。各データは 8 個の数字の並び（0 から 9 の数字）です。
</p>
<H2>Output</H2>
<p>
各データセットに対して、入力された数字を並べ替えてできる最大の整数と最小の整数の差を１行に出力して下さい。
</p>
<H2>Sample Input</H2>
<pre>
2
65539010
65539010
</pre>
<H2>Output for the Sample Input</H2>
<pre>
96417531
96417531
</pre>
|
s478059953 | p00051 | Accepted | while True:
try:
N=int(input())
for i in range(N):
n=list(input())
n_max=""
n_min=""
for j in sorted(n):
n_min +=j
n_max=int(n_min[::-1])
n_min=int(n_min)
print(n_max-n_min)
break
except:break
| 2
65539010
65539010
| 96417531
96417531
|
<H1>整数の差</H1>
<p>
8 個の 0 から 9 までの数字を入力したとき、その 8 個の数字を並べ替えてできる、最大の整数と最小の整数の差を出力するプログラムを作成してください。並び替えてできる数は 00135569 のように 0 から始まってもよいものとします。
</p>
<H2>Input</H2>
<p>
複数のデータセットが与えられます。１行目にデータセット数 <var>n</var> (<var>n</var> ≤ 50) が与えられます。続いて <var>n</var> 行のデータが与えられます。各データは 8 個の数字の並び（0 から 9 の数字）です。
</p>
<H2>Output</H2>
<p>
各データセットに対して、入力された数字を並べ替えてできる最大の整数と最小の整数の差を１行に出力して下さい。
</p>
<H2>Sample Input</H2>
<pre>
2
65539010
65539010
</pre>
<H2>Output for the Sample Input</H2>
<pre>
96417531
96417531
</pre>
|
s766161322 | p00051 | Accepted | n = int(input())
for _ in range(n):
n = [int(i) for i in list(input())]
min_n = sorted(n)
max_n = sorted(n,reverse=True)
min_ = int("".join([str(i) for i in min_n]))
max_ = int("".join([str(i) for i in max_n]))
dif = max_ - min_
print(dif)
| 2
65539010
65539010
| 96417531
96417531
|
<H1>整数の差</H1>
<p>
8 個の 0 から 9 までの数字を入力したとき、その 8 個の数字を並べ替えてできる、最大の整数と最小の整数の差を出力するプログラムを作成してください。並び替えてできる数は 00135569 のように 0 から始まってもよいものとします。
</p>
<H2>Input</H2>
<p>
複数のデータセットが与えられます。１行目にデータセット数 <var>n</var> (<var>n</var> ≤ 50) が与えられます。続いて <var>n</var> 行のデータが与えられます。各データは 8 個の数字の並び（0 から 9 の数字）です。
</p>
<H2>Output</H2>
<p>
各データセットに対して、入力された数字を並べ替えてできる最大の整数と最小の整数の差を１行に出力して下さい。
</p>
<H2>Sample Input</H2>
<pre>
2
65539010
65539010
</pre>
<H2>Output for the Sample Input</H2>
<pre>
96417531
96417531
</pre>
|
s720431230 | p00051 | Accepted | n = int(input())
for _ in range(n):
data = list(input())
data.sort(reverse=True)
max = int(''.join(d for d in data))
data.sort()
min = int(''.join(d for d in data))
print(max - min)
| 2
65539010
65539010
| 96417531
96417531
|
<H1>整数の差</H1>
<p>
8 個の 0 から 9 までの数字を入力したとき、その 8 個の数字を並べ替えてできる、最大の整数と最小の整数の差を出力するプログラムを作成してください。並び替えてできる数は 00135569 のように 0 から始まってもよいものとします。
</p>
<H2>Input</H2>
<p>
複数のデータセットが与えられます。１行目にデータセット数 <var>n</var> (<var>n</var> ≤ 50) が与えられます。続いて <var>n</var> 行のデータが与えられます。各データは 8 個の数字の並び（0 から 9 の数字）です。
</p>
<H2>Output</H2>
<p>
各データセットに対して、入力された数字を並べ替えてできる最大の整数と最小の整数の差を１行に出力して下さい。
</p>
<H2>Sample Input</H2>
<pre>
2
65539010
65539010
</pre>
<H2>Output for the Sample Input</H2>
<pre>
96417531
96417531
</pre>
|
s339562263 | p00051 | Accepted | for _ in range(int(input())):
num = list(map(int, list(input())))
min_num = ''.join(list(map(str, sorted(num))))
max_num = ''.join(list(map(str, sorted(num, reverse=True))))
print(int(max_num) - int(min_num))
| 2
65539010
65539010
| 96417531
96417531
|
<H1>整数の差</H1>
<p>
8 個の 0 から 9 までの数字を入力したとき、その 8 個の数字を並べ替えてできる、最大の整数と最小の整数の差を出力するプログラムを作成してください。並び替えてできる数は 00135569 のように 0 から始まってもよいものとします。
</p>
<H2>Input</H2>
<p>
複数のデータセットが与えられます。１行目にデータセット数 <var>n</var> (<var>n</var> ≤ 50) が与えられます。続いて <var>n</var> 行のデータが与えられます。各データは 8 個の数字の並び（0 から 9 の数字）です。
</p>
<H2>Output</H2>
<p>
各データセットに対して、入力された数字を並べ替えてできる最大の整数と最小の整数の差を１行に出力して下さい。
</p>
<H2>Sample Input</H2>
<pre>
2
65539010
65539010
</pre>
<H2>Output for the Sample Input</H2>
<pre>
96417531
96417531
</pre>
|
s110105002 | p00051 | Accepted | n = int(input())
for _ in range(n):
s = list(input())
mins = "".join(sorted(s,reverse=False))
maxs = "".join(sorted(s,reverse=True))
print(int(maxs)-int(mins))
| 2
65539010
65539010
| 96417531
96417531
|
<H1>整数の差</H1>
<p>
8 個の 0 から 9 までの数字を入力したとき、その 8 個の数字を並べ替えてできる、最大の整数と最小の整数の差を出力するプログラムを作成してください。並び替えてできる数は 00135569 のように 0 から始まってもよいものとします。
</p>
<H2>Input</H2>
<p>
複数のデータセットが与えられます。１行目にデータセット数 <var>n</var> (<var>n</var> ≤ 50) が与えられます。続いて <var>n</var> 行のデータが与えられます。各データは 8 個の数字の並び（0 から 9 の数字）です。
</p>
<H2>Output</H2>
<p>
各データセットに対して、入力された数字を並べ替えてできる最大の整数と最小の整数の差を１行に出力して下さい。
</p>
<H2>Sample Input</H2>
<pre>
2
65539010
65539010
</pre>
<H2>Output for the Sample Input</H2>
<pre>
96417531
96417531
</pre>
|
s323556369 | p00051 | Runtime Error | st = []
n = raw_input()
for s in n:
st.append(s)
s.sort()
a = int("".join())
b = int("".join(s[::-1]))
print b - a | 2
65539010
65539010
| 96417531
96417531
|
<H1>整数の差</H1>
<p>
8 個の 0 から 9 までの数字を入力したとき、その 8 個の数字を並べ替えてできる、最大の整数と最小の整数の差を出力するプログラムを作成してください。並び替えてできる数は 00135569 のように 0 から始まってもよいものとします。
</p>
<H2>Input</H2>
<p>
複数のデータセットが与えられます。１行目にデータセット数 <var>n</var> (<var>n</var> ≤ 50) が与えられます。続いて <var>n</var> 行のデータが与えられます。各データは 8 個の数字の並び（0 から 9 の数字）です。
</p>
<H2>Output</H2>
<p>
各データセットに対して、入力された数字を並べ替えてできる最大の整数と最小の整数の差を１行に出力して下さい。
</p>
<H2>Sample Input</H2>
<pre>
2
65539010
65539010
</pre>
<H2>Output for the Sample Input</H2>
<pre>
96417531
96417531
</pre>
|
s701366904 | p00051 | Runtime Error | i = raw_input()
while (i):
i -= 1
st = []
n = raw_input()
for s in n:
st.append(s)
s.sort()
a = int("".join())
b = int("".join(s[::-1]))
print b - a | 2
65539010
65539010
| 96417531
96417531
|
<H1>整数の差</H1>
<p>
8 個の 0 から 9 までの数字を入力したとき、その 8 個の数字を並べ替えてできる、最大の整数と最小の整数の差を出力するプログラムを作成してください。並び替えてできる数は 00135569 のように 0 から始まってもよいものとします。
</p>
<H2>Input</H2>
<p>
複数のデータセットが与えられます。１行目にデータセット数 <var>n</var> (<var>n</var> ≤ 50) が与えられます。続いて <var>n</var> 行のデータが与えられます。各データは 8 個の数字の並び（0 から 9 の数字）です。
</p>
<H2>Output</H2>
<p>
各データセットに対して、入力された数字を並べ替えてできる最大の整数と最小の整数の差を１行に出力して下さい。
</p>
<H2>Sample Input</H2>
<pre>
2
65539010
65539010
</pre>
<H2>Output for the Sample Input</H2>
<pre>
96417531
96417531
</pre>
|
s442154464 | p00051 | Runtime Error | i = int(raw_input())
while (i):
i -= 1
st = []
n = raw_input()
for s in n:
st.append(s)
s.sort()
a = int("".join())
b = int("".join(s[::-1]))
print b - a | 2
65539010
65539010
| 96417531
96417531
|
<H1>整数の差</H1>
<p>
8 個の 0 から 9 までの数字を入力したとき、その 8 個の数字を並べ替えてできる、最大の整数と最小の整数の差を出力するプログラムを作成してください。並び替えてできる数は 00135569 のように 0 から始まってもよいものとします。
</p>
<H2>Input</H2>
<p>
複数のデータセットが与えられます。１行目にデータセット数 <var>n</var> (<var>n</var> ≤ 50) が与えられます。続いて <var>n</var> 行のデータが与えられます。各データは 8 個の数字の並び（0 から 9 の数字）です。
</p>
<H2>Output</H2>
<p>
各データセットに対して、入力された数字を並べ替えてできる最大の整数と最小の整数の差を１行に出力して下さい。
</p>
<H2>Sample Input</H2>
<pre>
2
65539010
65539010
</pre>
<H2>Output for the Sample Input</H2>
<pre>
96417531
96417531
</pre>
|
s544728849 | p00051 | Runtime Error | i = int(raw_input())
while (i):
i -= 1
st = []
n = raw_input()
for s in n:
st.append(s)
st.sort()
a = int("".join())
b = int("".join(st[::-1]))
print b - a | 2
65539010
65539010
| 96417531
96417531
|
<H1>整数の差</H1>
<p>
8 個の 0 から 9 までの数字を入力したとき、その 8 個の数字を並べ替えてできる、最大の整数と最小の整数の差を出力するプログラムを作成してください。並び替えてできる数は 00135569 のように 0 から始まってもよいものとします。
</p>
<H2>Input</H2>
<p>
複数のデータセットが与えられます。１行目にデータセット数 <var>n</var> (<var>n</var> ≤ 50) が与えられます。続いて <var>n</var> 行のデータが与えられます。各データは 8 個の数字の並び（0 から 9 の数字）です。
</p>
<H2>Output</H2>
<p>
各データセットに対して、入力された数字を並べ替えてできる最大の整数と最小の整数の差を１行に出力して下さい。
</p>
<H2>Sample Input</H2>
<pre>
2
65539010
65539010
</pre>
<H2>Output for the Sample Input</H2>
<pre>
96417531
96417531
</pre>
|
s608508303 | p00051 | Runtime Error | for i in xrange(input()):
n = sorted(raw_input())
x = int("".join(n[::-1]))
for j in xrange(len(n)):
if n[i] == "0": del n[i]
else: break
print x - int("".join(n)) | 2
65539010
65539010
| 96417531
96417531
|
<H1>整数の差</H1>
<p>
8 個の 0 から 9 までの数字を入力したとき、その 8 個の数字を並べ替えてできる、最大の整数と最小の整数の差を出力するプログラムを作成してください。並び替えてできる数は 00135569 のように 0 から始まってもよいものとします。
</p>
<H2>Input</H2>
<p>
複数のデータセットが与えられます。１行目にデータセット数 <var>n</var> (<var>n</var> ≤ 50) が与えられます。続いて <var>n</var> 行のデータが与えられます。各データは 8 個の数字の並び（0 から 9 の数字）です。
</p>
<H2>Output</H2>
<p>
各データセットに対して、入力された数字を並べ替えてできる最大の整数と最小の整数の差を１行に出力して下さい。
</p>
<H2>Sample Input</H2>
<pre>
2
65539010
65539010
</pre>
<H2>Output for the Sample Input</H2>
<pre>
96417531
96417531
</pre>
|
s009233044 | p00051 | Runtime Error | #encoding=utf-8
for i in xrange(input()):
n = sorted(raw_input())
x = int("".join(n[::-1]))
for j in xrange(len(n)):
if n[i] == "0": del n[i]
else: break
print x - int("".join(n)) | 2
65539010
65539010
| 96417531
96417531
|
<H1>整数の差</H1>
<p>
8 個の 0 から 9 までの数字を入力したとき、その 8 個の数字を並べ替えてできる、最大の整数と最小の整数の差を出力するプログラムを作成してください。並び替えてできる数は 00135569 のように 0 から始まってもよいものとします。
</p>
<H2>Input</H2>
<p>
複数のデータセットが与えられます。１行目にデータセット数 <var>n</var> (<var>n</var> ≤ 50) が与えられます。続いて <var>n</var> 行のデータが与えられます。各データは 8 個の数字の並び（0 から 9 の数字）です。
</p>
<H2>Output</H2>
<p>
各データセットに対して、入力された数字を並べ替えてできる最大の整数と最小の整数の差を１行に出力して下さい。
</p>
<H2>Sample Input</H2>
<pre>
2
65539010
65539010
</pre>
<H2>Output for the Sample Input</H2>
<pre>
96417531
96417531
</pre>
|
s106249151 | p00051 | Runtime Error | for _ in[0]*int(input()):
M=''.join(sorted(input()))[::-1]
print(int(M)-int(M[::-1].replace('0','')))
| 2
65539010
65539010
| 96417531
96417531
|
<H1>整数の差</H1>
<p>
8 個の 0 から 9 までの数字を入力したとき、その 8 個の数字を並べ替えてできる、最大の整数と最小の整数の差を出力するプログラムを作成してください。並び替えてできる数は 00135569 のように 0 から始まってもよいものとします。
</p>
<H2>Input</H2>
<p>
複数のデータセットが与えられます。１行目にデータセット数 <var>n</var> (<var>n</var> ≤ 50) が与えられます。続いて <var>n</var> 行のデータが与えられます。各データは 8 個の数字の並び（0 から 9 の数字）です。
</p>
<H2>Output</H2>
<p>
各データセットに対して、入力された数字を並べ替えてできる最大の整数と最小の整数の差を１行に出力して下さい。
</p>
<H2>Sample Input</H2>
<pre>
2
65539010
65539010
</pre>
<H2>Output for the Sample Input</H2>
<pre>
96417531
96417531
</pre>
|
s175781671 | p00051 | Runtime Error | for _ in[0]*int(input()):
M=''.join(sorted(input()))
print(int(M[::-1])-int(M.replace('0','')))
| 2
65539010
65539010
| 96417531
96417531
|
<H1>整数の差</H1>
<p>
8 個の 0 から 9 までの数字を入力したとき、その 8 個の数字を並べ替えてできる、最大の整数と最小の整数の差を出力するプログラムを作成してください。並び替えてできる数は 00135569 のように 0 から始まってもよいものとします。
</p>
<H2>Input</H2>
<p>
複数のデータセットが与えられます。１行目にデータセット数 <var>n</var> (<var>n</var> ≤ 50) が与えられます。続いて <var>n</var> 行のデータが与えられます。各データは 8 個の数字の並び（0 から 9 の数字）です。
</p>
<H2>Output</H2>
<p>
各データセットに対して、入力された数字を並べ替えてできる最大の整数と最小の整数の差を１行に出力して下さい。
</p>
<H2>Sample Input</H2>
<pre>
2
65539010
65539010
</pre>
<H2>Output for the Sample Input</H2>
<pre>
96417531
96417531
</pre>
|
s788781635 | p00051 | Runtime Error | while True:
x = int(input())
for i in range(x):
li = list(input())
li1 = int("".join(sorted(li)))
li2 = int("".join(sorted(li,reverse=True)))
print(li2-li1)
| 2
65539010
65539010
| 96417531
96417531
|
<H1>整数の差</H1>
<p>
8 個の 0 から 9 までの数字を入力したとき、その 8 個の数字を並べ替えてできる、最大の整数と最小の整数の差を出力するプログラムを作成してください。並び替えてできる数は 00135569 のように 0 から始まってもよいものとします。
</p>
<H2>Input</H2>
<p>
複数のデータセットが与えられます。１行目にデータセット数 <var>n</var> (<var>n</var> ≤ 50) が与えられます。続いて <var>n</var> 行のデータが与えられます。各データは 8 個の数字の並び（0 から 9 の数字）です。
</p>
<H2>Output</H2>
<p>
各データセットに対して、入力された数字を並べ替えてできる最大の整数と最小の整数の差を１行に出力して下さい。
</p>
<H2>Sample Input</H2>
<pre>
2
65539010
65539010
</pre>
<H2>Output for the Sample Input</H2>
<pre>
96417531
96417531
</pre>
|
s466467686 | p00051 | Runtime Error | while True:
x = int(input())
for i in range(x):
try:
li = list(input())
except:
break
li1 = int("".join(sorted(li)))
li2 = int("".join(sorted(li,reverse=True)))
print(li2-li1)
| 2
65539010
65539010
| 96417531
96417531
|
<H1>整数の差</H1>
<p>
8 個の 0 から 9 までの数字を入力したとき、その 8 個の数字を並べ替えてできる、最大の整数と最小の整数の差を出力するプログラムを作成してください。並び替えてできる数は 00135569 のように 0 から始まってもよいものとします。
</p>
<H2>Input</H2>
<p>
複数のデータセットが与えられます。１行目にデータセット数 <var>n</var> (<var>n</var> ≤ 50) が与えられます。続いて <var>n</var> 行のデータが与えられます。各データは 8 個の数字の並び（0 から 9 の数字）です。
</p>
<H2>Output</H2>
<p>
各データセットに対して、入力された数字を並べ替えてできる最大の整数と最小の整数の差を１行に出力して下さい。
</p>
<H2>Sample Input</H2>
<pre>
2
65539010
65539010
</pre>
<H2>Output for the Sample Input</H2>
<pre>
96417531
96417531
</pre>
|
s506243424 | p00052 | Wrong Answer | while 1:
try:
zero=0
number=1
n=int(input())
for i in range(1,n+1):
number*=i
while len(str(number))>7:number=int(str(number)[1:])
while number%10==0:
zero+=1
number=int(number/10)
print(zero)
except:break
| 2
12
10000
0
| 0
2
2499
|
<H1>階乗 II</H1>
<p>
<var>n! = n × (n − 1) × (n − 2) ×</var> ... <var> × 3 × 2 × 1</var><br/>
<br/>
を <var>n</var> の階乗といいます。例えば、12 の階乗は<br/>
<br/>
<var>12! = 12 × 11 × 10 × 9 × 8 × 7 × 6 × 5 × 4 × 3 × 2 × 1 = 479001600</var><br/>
<br/>
となり、末尾に 0 が 2 つ連続して並んでいます。
</p>
<p>
整数 <var>n</var> を入力して、<var>n!</var> の末尾に連続して並んでいる 0 の数を出力するプログラムを作成してください。ただし、<var>n</var> は 20000 以下の正の整数とします。
</p>
<H2>Input</H2>
<p>
複数のデータが与えられます。各データに <var>n</var> (<var>n</var> ≤ 20000) が１行に与えられます。<var>n</var> が 0 の時入力の最後とします。
</p>
<p>
データの数は 20 を超えません。
</p>
<H2>Output</H2>
<p>
各データに対して <var>n!</var> の末尾に連続して並んでいる 0 の数を１行に出力して下さい。
</p>
<H2>Sample Input</H2>
<pre>
2
12
10000
0
</pre>
<H2>Output for the Sample Input</H2>
<pre>
0
2
2499
</pre>
|
s003981305 | p00052 | Wrong Answer | import math
while True:
try:
n = int(input())
except:
break
s = 0
fac = math.factorial(n)
while fac % 10 == 0:
fac = fac // 10
s += 1
print(s) | 2
12
10000
0
| 0
2
2499
|
<H1>階乗 II</H1>
<p>
<var>n! = n × (n − 1) × (n − 2) ×</var> ... <var> × 3 × 2 × 1</var><br/>
<br/>
を <var>n</var> の階乗といいます。例えば、12 の階乗は<br/>
<br/>
<var>12! = 12 × 11 × 10 × 9 × 8 × 7 × 6 × 5 × 4 × 3 × 2 × 1 = 479001600</var><br/>
<br/>
となり、末尾に 0 が 2 つ連続して並んでいます。
</p>
<p>
整数 <var>n</var> を入力して、<var>n!</var> の末尾に連続して並んでいる 0 の数を出力するプログラムを作成してください。ただし、<var>n</var> は 20000 以下の正の整数とします。
</p>
<H2>Input</H2>
<p>
複数のデータが与えられます。各データに <var>n</var> (<var>n</var> ≤ 20000) が１行に与えられます。<var>n</var> が 0 の時入力の最後とします。
</p>
<p>
データの数は 20 を超えません。
</p>
<H2>Output</H2>
<p>
各データに対して <var>n!</var> の末尾に連続して並んでいる 0 の数を１行に出力して下さい。
</p>
<H2>Sample Input</H2>
<pre>
2
12
10000
0
</pre>
<H2>Output for the Sample Input</H2>
<pre>
0
2
2499
</pre>
|
s343751690 | p00052 | Wrong Answer | while 1:
try:
n=int(raw_input())
ans=1
for i in range(1,n+1):
ans*=i
ans=str(ans)[::-1]
cnt=0
for i in ans:
if i=='0':
cnt+=1
else:
break
print cnt
except:
break | 2
12
10000
0
| 0
2
2499
|
<H1>階乗 II</H1>
<p>
<var>n! = n × (n − 1) × (n − 2) ×</var> ... <var> × 3 × 2 × 1</var><br/>
<br/>
を <var>n</var> の階乗といいます。例えば、12 の階乗は<br/>
<br/>
<var>12! = 12 × 11 × 10 × 9 × 8 × 7 × 6 × 5 × 4 × 3 × 2 × 1 = 479001600</var><br/>
<br/>
となり、末尾に 0 が 2 つ連続して並んでいます。
</p>
<p>
整数 <var>n</var> を入力して、<var>n!</var> の末尾に連続して並んでいる 0 の数を出力するプログラムを作成してください。ただし、<var>n</var> は 20000 以下の正の整数とします。
</p>
<H2>Input</H2>
<p>
複数のデータが与えられます。各データに <var>n</var> (<var>n</var> ≤ 20000) が１行に与えられます。<var>n</var> が 0 の時入力の最後とします。
</p>
<p>
データの数は 20 を超えません。
</p>
<H2>Output</H2>
<p>
各データに対して <var>n!</var> の末尾に連続して並んでいる 0 の数を１行に出力して下さい。
</p>
<H2>Sample Input</H2>
<pre>
2
12
10000
0
</pre>
<H2>Output for the Sample Input</H2>
<pre>
0
2
2499
</pre>
|
s324304050 | p00052 | Wrong Answer | def fac(a):
i=0
b=5
c=1
while b<=a:
i+=c*(a//b)
b*=5
c+=1
print(i)
while True:
a=input()
if a!=0:
fac
else:
break | 2
12
10000
0
| 0
2
2499
|
<H1>階乗 II</H1>
<p>
<var>n! = n × (n − 1) × (n − 2) ×</var> ... <var> × 3 × 2 × 1</var><br/>
<br/>
を <var>n</var> の階乗といいます。例えば、12 の階乗は<br/>
<br/>
<var>12! = 12 × 11 × 10 × 9 × 8 × 7 × 6 × 5 × 4 × 3 × 2 × 1 = 479001600</var><br/>
<br/>
となり、末尾に 0 が 2 つ連続して並んでいます。
</p>
<p>
整数 <var>n</var> を入力して、<var>n!</var> の末尾に連続して並んでいる 0 の数を出力するプログラムを作成してください。ただし、<var>n</var> は 20000 以下の正の整数とします。
</p>
<H2>Input</H2>
<p>
複数のデータが与えられます。各データに <var>n</var> (<var>n</var> ≤ 20000) が１行に与えられます。<var>n</var> が 0 の時入力の最後とします。
</p>
<p>
データの数は 20 を超えません。
</p>
<H2>Output</H2>
<p>
各データに対して <var>n!</var> の末尾に連続して並んでいる 0 の数を１行に出力して下さい。
</p>
<H2>Sample Input</H2>
<pre>
2
12
10000
0
</pre>
<H2>Output for the Sample Input</H2>
<pre>
0
2
2499
</pre>
|
s059329879 | p00052 | Wrong Answer | def fac(a):
i=0
b=5
c=1
while b<=a:
i+=c*(a//b)
b*=5
c+=1
print(i)
while True:
a=int(input())
if a!=0:
fac(a)
else:
break | 2
12
10000
0
| 0
2
2499
|
<H1>階乗 II</H1>
<p>
<var>n! = n × (n − 1) × (n − 2) ×</var> ... <var> × 3 × 2 × 1</var><br/>
<br/>
を <var>n</var> の階乗といいます。例えば、12 の階乗は<br/>
<br/>
<var>12! = 12 × 11 × 10 × 9 × 8 × 7 × 6 × 5 × 4 × 3 × 2 × 1 = 479001600</var><br/>
<br/>
となり、末尾に 0 が 2 つ連続して並んでいます。
</p>
<p>
整数 <var>n</var> を入力して、<var>n!</var> の末尾に連続して並んでいる 0 の数を出力するプログラムを作成してください。ただし、<var>n</var> は 20000 以下の正の整数とします。
</p>
<H2>Input</H2>
<p>
複数のデータが与えられます。各データに <var>n</var> (<var>n</var> ≤ 20000) が１行に与えられます。<var>n</var> が 0 の時入力の最後とします。
</p>
<p>
データの数は 20 を超えません。
</p>
<H2>Output</H2>
<p>
各データに対して <var>n!</var> の末尾に連続して並んでいる 0 の数を１行に出力して下さい。
</p>
<H2>Sample Input</H2>
<pre>
2
12
10000
0
</pre>
<H2>Output for the Sample Input</H2>
<pre>
0
2
2499
</pre>
|
s053775052 | p00052 | Wrong Answer | def fac(a):
i=0
b=5
c=1
while b<=a:
i+=c*(a//b)
b*=5
c+=1
return i
while True:
a=int(input())
if a!=0:
print(fac(a))
else:
break | 2
12
10000
0
| 0
2
2499
|
<H1>階乗 II</H1>
<p>
<var>n! = n × (n − 1) × (n − 2) ×</var> ... <var> × 3 × 2 × 1</var><br/>
<br/>
を <var>n</var> の階乗といいます。例えば、12 の階乗は<br/>
<br/>
<var>12! = 12 × 11 × 10 × 9 × 8 × 7 × 6 × 5 × 4 × 3 × 2 × 1 = 479001600</var><br/>
<br/>
となり、末尾に 0 が 2 つ連続して並んでいます。
</p>
<p>
整数 <var>n</var> を入力して、<var>n!</var> の末尾に連続して並んでいる 0 の数を出力するプログラムを作成してください。ただし、<var>n</var> は 20000 以下の正の整数とします。
</p>
<H2>Input</H2>
<p>
複数のデータが与えられます。各データに <var>n</var> (<var>n</var> ≤ 20000) が１行に与えられます。<var>n</var> が 0 の時入力の最後とします。
</p>
<p>
データの数は 20 を超えません。
</p>
<H2>Output</H2>
<p>
各データに対して <var>n!</var> の末尾に連続して並んでいる 0 の数を１行に出力して下さい。
</p>
<H2>Sample Input</H2>
<pre>
2
12
10000
0
</pre>
<H2>Output for the Sample Input</H2>
<pre>
0
2
2499
</pre>
|
s344581410 | p00052 | Wrong Answer | while True:
n = int(input())
if n == 0:
break
f = 1
for i in range(n + 1):
f *= i + 1
i = 0
f_str = str(f)
while True:
if f_str[-1] == "0":
i += 1
f_str = f_str[:-1]
else:
break
print(i)
| 2
12
10000
0
| 0
2
2499
|
<H1>階乗 II</H1>
<p>
<var>n! = n × (n − 1) × (n − 2) ×</var> ... <var> × 3 × 2 × 1</var><br/>
<br/>
を <var>n</var> の階乗といいます。例えば、12 の階乗は<br/>
<br/>
<var>12! = 12 × 11 × 10 × 9 × 8 × 7 × 6 × 5 × 4 × 3 × 2 × 1 = 479001600</var><br/>
<br/>
となり、末尾に 0 が 2 つ連続して並んでいます。
</p>
<p>
整数 <var>n</var> を入力して、<var>n!</var> の末尾に連続して並んでいる 0 の数を出力するプログラムを作成してください。ただし、<var>n</var> は 20000 以下の正の整数とします。
</p>
<H2>Input</H2>
<p>
複数のデータが与えられます。各データに <var>n</var> (<var>n</var> ≤ 20000) が１行に与えられます。<var>n</var> が 0 の時入力の最後とします。
</p>
<p>
データの数は 20 を超えません。
</p>
<H2>Output</H2>
<p>
各データに対して <var>n!</var> の末尾に連続して並んでいる 0 の数を１行に出力して下さい。
</p>
<H2>Sample Input</H2>
<pre>
2
12
10000
0
</pre>
<H2>Output for the Sample Input</H2>
<pre>
0
2
2499
</pre>
|
s766689269 | p00052 | Wrong Answer | for e in iter(input,'0'):
a=i=1;e=int(e)
while 1:
d=e//5**i
print(i,d)
if d:a+=d
else:break
i+=1
print(a-1)
| 2
12
10000
0
| 0
2
2499
|
<H1>階乗 II</H1>
<p>
<var>n! = n × (n − 1) × (n − 2) ×</var> ... <var> × 3 × 2 × 1</var><br/>
<br/>
を <var>n</var> の階乗といいます。例えば、12 の階乗は<br/>
<br/>
<var>12! = 12 × 11 × 10 × 9 × 8 × 7 × 6 × 5 × 4 × 3 × 2 × 1 = 479001600</var><br/>
<br/>
となり、末尾に 0 が 2 つ連続して並んでいます。
</p>
<p>
整数 <var>n</var> を入力して、<var>n!</var> の末尾に連続して並んでいる 0 の数を出力するプログラムを作成してください。ただし、<var>n</var> は 20000 以下の正の整数とします。
</p>
<H2>Input</H2>
<p>
複数のデータが与えられます。各データに <var>n</var> (<var>n</var> ≤ 20000) が１行に与えられます。<var>n</var> が 0 の時入力の最後とします。
</p>
<p>
データの数は 20 を超えません。
</p>
<H2>Output</H2>
<p>
各データに対して <var>n!</var> の末尾に連続して並んでいる 0 の数を１行に出力して下さい。
</p>
<H2>Sample Input</H2>
<pre>
2
12
10000
0
</pre>
<H2>Output for the Sample Input</H2>
<pre>
0
2
2499
</pre>
|
s746262758 | p00052 | Wrong Answer | for e in iter(input,'0'):
e=int(e)
print(sum(e//5**i for i in range(1,6)))
| 2
12
10000
0
| 0
2
2499
|
<H1>階乗 II</H1>
<p>
<var>n! = n × (n − 1) × (n − 2) ×</var> ... <var> × 3 × 2 × 1</var><br/>
<br/>
を <var>n</var> の階乗といいます。例えば、12 の階乗は<br/>
<br/>
<var>12! = 12 × 11 × 10 × 9 × 8 × 7 × 6 × 5 × 4 × 3 × 2 × 1 = 479001600</var><br/>
<br/>
となり、末尾に 0 が 2 つ連続して並んでいます。
</p>
<p>
整数 <var>n</var> を入力して、<var>n!</var> の末尾に連続して並んでいる 0 の数を出力するプログラムを作成してください。ただし、<var>n</var> は 20000 以下の正の整数とします。
</p>
<H2>Input</H2>
<p>
複数のデータが与えられます。各データに <var>n</var> (<var>n</var> ≤ 20000) が１行に与えられます。<var>n</var> が 0 の時入力の最後とします。
</p>
<p>
データの数は 20 を超えません。
</p>
<H2>Output</H2>
<p>
各データに対して <var>n!</var> の末尾に連続して並んでいる 0 の数を１行に出力して下さい。
</p>
<H2>Sample Input</H2>
<pre>
2
12
10000
0
</pre>
<H2>Output for the Sample Input</H2>
<pre>
0
2
2499
</pre>
|
s916951531 | p00052 | Wrong Answer | for e in iter(input,'0'):print(sum(int(e)//5**i for i in range(1,6)))
| 2
12
10000
0
| 0
2
2499
|
<H1>階乗 II</H1>
<p>
<var>n! = n × (n − 1) × (n − 2) ×</var> ... <var> × 3 × 2 × 1</var><br/>
<br/>
を <var>n</var> の階乗といいます。例えば、12 の階乗は<br/>
<br/>
<var>12! = 12 × 11 × 10 × 9 × 8 × 7 × 6 × 5 × 4 × 3 × 2 × 1 = 479001600</var><br/>
<br/>
となり、末尾に 0 が 2 つ連続して並んでいます。
</p>
<p>
整数 <var>n</var> を入力して、<var>n!</var> の末尾に連続して並んでいる 0 の数を出力するプログラムを作成してください。ただし、<var>n</var> は 20000 以下の正の整数とします。
</p>
<H2>Input</H2>
<p>
複数のデータが与えられます。各データに <var>n</var> (<var>n</var> ≤ 20000) が１行に与えられます。<var>n</var> が 0 の時入力の最後とします。
</p>
<p>
データの数は 20 を超えません。
</p>
<H2>Output</H2>
<p>
各データに対して <var>n!</var> の末尾に連続して並んでいる 0 の数を１行に出力して下さい。
</p>
<H2>Sample Input</H2>
<pre>
2
12
10000
0
</pre>
<H2>Output for the Sample Input</H2>
<pre>
0
2
2499
</pre>
|
s019446014 | p00052 | Wrong Answer | import math
while True:
n = int(raw_input())
if not n:
break
ans = 0
for i in range(1,n+1):
ans += math.log10(i)
print int(ans) | 2
12
10000
0
| 0
2
2499
|
<H1>階乗 II</H1>
<p>
<var>n! = n × (n − 1) × (n − 2) ×</var> ... <var> × 3 × 2 × 1</var><br/>
<br/>
を <var>n</var> の階乗といいます。例えば、12 の階乗は<br/>
<br/>
<var>12! = 12 × 11 × 10 × 9 × 8 × 7 × 6 × 5 × 4 × 3 × 2 × 1 = 479001600</var><br/>
<br/>
となり、末尾に 0 が 2 つ連続して並んでいます。
</p>
<p>
整数 <var>n</var> を入力して、<var>n!</var> の末尾に連続して並んでいる 0 の数を出力するプログラムを作成してください。ただし、<var>n</var> は 20000 以下の正の整数とします。
</p>
<H2>Input</H2>
<p>
複数のデータが与えられます。各データに <var>n</var> (<var>n</var> ≤ 20000) が１行に与えられます。<var>n</var> が 0 の時入力の最後とします。
</p>
<p>
データの数は 20 を超えません。
</p>
<H2>Output</H2>
<p>
各データに対して <var>n!</var> の末尾に連続して並んでいる 0 の数を１行に出力して下さい。
</p>
<H2>Sample Input</H2>
<pre>
2
12
10000
0
</pre>
<H2>Output for the Sample Input</H2>
<pre>
0
2
2499
</pre>
|
s215894697 | p00052 | Wrong Answer | while True:
n = int(raw_input())
if not n:
break
all = 0
for i in range(10):
all += (i+1)*n/(5*10**i)
print all | 2
12
10000
0
| 0
2
2499
|
<H1>階乗 II</H1>
<p>
<var>n! = n × (n − 1) × (n − 2) ×</var> ... <var> × 3 × 2 × 1</var><br/>
<br/>
を <var>n</var> の階乗といいます。例えば、12 の階乗は<br/>
<br/>
<var>12! = 12 × 11 × 10 × 9 × 8 × 7 × 6 × 5 × 4 × 3 × 2 × 1 = 479001600</var><br/>
<br/>
となり、末尾に 0 が 2 つ連続して並んでいます。
</p>
<p>
整数 <var>n</var> を入力して、<var>n!</var> の末尾に連続して並んでいる 0 の数を出力するプログラムを作成してください。ただし、<var>n</var> は 20000 以下の正の整数とします。
</p>
<H2>Input</H2>
<p>
複数のデータが与えられます。各データに <var>n</var> (<var>n</var> ≤ 20000) が１行に与えられます。<var>n</var> が 0 の時入力の最後とします。
</p>
<p>
データの数は 20 を超えません。
</p>
<H2>Output</H2>
<p>
各データに対して <var>n!</var> の末尾に連続して並んでいる 0 の数を１行に出力して下さい。
</p>
<H2>Sample Input</H2>
<pre>
2
12
10000
0
</pre>
<H2>Output for the Sample Input</H2>
<pre>
0
2
2499
</pre>
|
s089063602 | p00052 | Time Limit Exceeded | n = []
while True:
try:
tmp = int(input())
if tmp == 0:
break
else:
n.append(tmp)
except EOFError:
break
for i in range(len(n)):
f = 1
for j in range(1,n[i]+1):
f *= j
k = 0
while True:
if f % (10 ** k) != 0:
print(k-1)
break
else:
k += 1 | 2
12
10000
0
| 0
2
2499
|
<H1>階乗 II</H1>
<p>
<var>n! = n × (n − 1) × (n − 2) ×</var> ... <var> × 3 × 2 × 1</var><br/>
<br/>
を <var>n</var> の階乗といいます。例えば、12 の階乗は<br/>
<br/>
<var>12! = 12 × 11 × 10 × 9 × 8 × 7 × 6 × 5 × 4 × 3 × 2 × 1 = 479001600</var><br/>
<br/>
となり、末尾に 0 が 2 つ連続して並んでいます。
</p>
<p>
整数 <var>n</var> を入力して、<var>n!</var> の末尾に連続して並んでいる 0 の数を出力するプログラムを作成してください。ただし、<var>n</var> は 20000 以下の正の整数とします。
</p>
<H2>Input</H2>
<p>
複数のデータが与えられます。各データに <var>n</var> (<var>n</var> ≤ 20000) が１行に与えられます。<var>n</var> が 0 の時入力の最後とします。
</p>
<p>
データの数は 20 を超えません。
</p>
<H2>Output</H2>
<p>
各データに対して <var>n!</var> の末尾に連続して並んでいる 0 の数を１行に出力して下さい。
</p>
<H2>Sample Input</H2>
<pre>
2
12
10000
0
</pre>
<H2>Output for the Sample Input</H2>
<pre>
0
2
2499
</pre>
|
s080064944 | p00052 | Time Limit Exceeded | import math
# ????????§??????????????????????????????
def fact(n):
sum = 0
for i in range(1,n+1):
sum += math.log(i)
return math.exp(sum)
def fact2(n):
return math.sqrt(2*math.pi*n)*(n/math.exp(1))**n
n = []
while True:
try:
tmp = int(input())
if tmp == 0:
break
else:
n.append(tmp)
except EOFError:
break
for i in range(len(n)):
f = math.factorial(n[i])
k = 0
while True:
if f % (10 ** k) != 0:
print(k-1)
break
else:
k += 1 | 2
12
10000
0
| 0
2
2499
|
<H1>階乗 II</H1>
<p>
<var>n! = n × (n − 1) × (n − 2) ×</var> ... <var> × 3 × 2 × 1</var><br/>
<br/>
を <var>n</var> の階乗といいます。例えば、12 の階乗は<br/>
<br/>
<var>12! = 12 × 11 × 10 × 9 × 8 × 7 × 6 × 5 × 4 × 3 × 2 × 1 = 479001600</var><br/>
<br/>
となり、末尾に 0 が 2 つ連続して並んでいます。
</p>
<p>
整数 <var>n</var> を入力して、<var>n!</var> の末尾に連続して並んでいる 0 の数を出力するプログラムを作成してください。ただし、<var>n</var> は 20000 以下の正の整数とします。
</p>
<H2>Input</H2>
<p>
複数のデータが与えられます。各データに <var>n</var> (<var>n</var> ≤ 20000) が１行に与えられます。<var>n</var> が 0 の時入力の最後とします。
</p>
<p>
データの数は 20 を超えません。
</p>
<H2>Output</H2>
<p>
各データに対して <var>n!</var> の末尾に連続して並んでいる 0 の数を１行に出力して下さい。
</p>
<H2>Sample Input</H2>
<pre>
2
12
10000
0
</pre>
<H2>Output for the Sample Input</H2>
<pre>
0
2
2499
</pre>
|
s841784475 | p00052 | Time Limit Exceeded | import math
# ????????§??????????????????????????????
def fact(n):
sum = 0
for i in range(1,n+1):
sum += math.log(i)
return math.exp(sum)
# ????????????????????§??????
def fact2(n):
return math.sqrt(2*math.pi*n)*(n/math.exp(1))**n
def mfactorial(n, _factcache={}):
if n not in _factcache:
_factcache[n] = math.factorial(n)
return _factcache[n]
n = []
while True:
try:
tmp = int(input())
if tmp == 0:
break
else:
n.append(tmp)
except EOFError:
break
for i in range(len(n)):
f = mfactorial(n[i])
k = 0
while True:
if f % (10 ** k) != 0:
print(k-1)
break
else:
k += 1 | 2
12
10000
0
| 0
2
2499
|
<H1>階乗 II</H1>
<p>
<var>n! = n × (n − 1) × (n − 2) ×</var> ... <var> × 3 × 2 × 1</var><br/>
<br/>
を <var>n</var> の階乗といいます。例えば、12 の階乗は<br/>
<br/>
<var>12! = 12 × 11 × 10 × 9 × 8 × 7 × 6 × 5 × 4 × 3 × 2 × 1 = 479001600</var><br/>
<br/>
となり、末尾に 0 が 2 つ連続して並んでいます。
</p>
<p>
整数 <var>n</var> を入力して、<var>n!</var> の末尾に連続して並んでいる 0 の数を出力するプログラムを作成してください。ただし、<var>n</var> は 20000 以下の正の整数とします。
</p>
<H2>Input</H2>
<p>
複数のデータが与えられます。各データに <var>n</var> (<var>n</var> ≤ 20000) が１行に与えられます。<var>n</var> が 0 の時入力の最後とします。
</p>
<p>
データの数は 20 を超えません。
</p>
<H2>Output</H2>
<p>
各データに対して <var>n!</var> の末尾に連続して並んでいる 0 の数を１行に出力して下さい。
</p>
<H2>Sample Input</H2>
<pre>
2
12
10000
0
</pre>
<H2>Output for the Sample Input</H2>
<pre>
0
2
2499
</pre>
|
s595170917 | p00052 | Accepted | import math
while True:
x = int(input())
if x == 0: break
n = list(str(math.factorial(x)))
con = 0
for i in range(len(n)-1,0,-1):
if n[i] != '0':
break
con += 1
print(con)
| 2
12
10000
0
| 0
2
2499
|
<H1>階乗 II</H1>
<p>
<var>n! = n × (n − 1) × (n − 2) ×</var> ... <var> × 3 × 2 × 1</var><br/>
<br/>
を <var>n</var> の階乗といいます。例えば、12 の階乗は<br/>
<br/>
<var>12! = 12 × 11 × 10 × 9 × 8 × 7 × 6 × 5 × 4 × 3 × 2 × 1 = 479001600</var><br/>
<br/>
となり、末尾に 0 が 2 つ連続して並んでいます。
</p>
<p>
整数 <var>n</var> を入力して、<var>n!</var> の末尾に連続して並んでいる 0 の数を出力するプログラムを作成してください。ただし、<var>n</var> は 20000 以下の正の整数とします。
</p>
<H2>Input</H2>
<p>
複数のデータが与えられます。各データに <var>n</var> (<var>n</var> ≤ 20000) が１行に与えられます。<var>n</var> が 0 の時入力の最後とします。
</p>
<p>
データの数は 20 を超えません。
</p>
<H2>Output</H2>
<p>
各データに対して <var>n!</var> の末尾に連続して並んでいる 0 の数を１行に出力して下さい。
</p>
<H2>Sample Input</H2>
<pre>
2
12
10000
0
</pre>
<H2>Output for the Sample Input</H2>
<pre>
0
2
2499
</pre>
|
s360477452 | p00052 | Accepted | while True:
n = int(raw_input())
cnt = 0
_sum = 1
if n == 0:
break
for i in range(1, n+1):
_sum*=i
while _sum >= 10:
if _sum % 10 != 0:
break
else:
_sum /= 10
cnt+=1
print cnt
| 2
12
10000
0
| 0
2
2499
|
<H1>階乗 II</H1>
<p>
<var>n! = n × (n − 1) × (n − 2) ×</var> ... <var> × 3 × 2 × 1</var><br/>
<br/>
を <var>n</var> の階乗といいます。例えば、12 の階乗は<br/>
<br/>
<var>12! = 12 × 11 × 10 × 9 × 8 × 7 × 6 × 5 × 4 × 3 × 2 × 1 = 479001600</var><br/>
<br/>
となり、末尾に 0 が 2 つ連続して並んでいます。
</p>
<p>
整数 <var>n</var> を入力して、<var>n!</var> の末尾に連続して並んでいる 0 の数を出力するプログラムを作成してください。ただし、<var>n</var> は 20000 以下の正の整数とします。
</p>
<H2>Input</H2>
<p>
複数のデータが与えられます。各データに <var>n</var> (<var>n</var> ≤ 20000) が１行に与えられます。<var>n</var> が 0 の時入力の最後とします。
</p>
<p>
データの数は 20 を超えません。
</p>
<H2>Output</H2>
<p>
各データに対して <var>n!</var> の末尾に連続して並んでいる 0 の数を１行に出力して下さい。
</p>
<H2>Sample Input</H2>
<pre>
2
12
10000
0
</pre>
<H2>Output for the Sample Input</H2>
<pre>
0
2
2499
</pre>
|
s526695858 | p00052 | Accepted | while 1:
zero=0
number=1
n=int(input())
if n==0:break
for i in range(1,n+1):
number*=i
while len(str(number))>7:number=int(str(number)[1:])
while number%10==0:
zero+=1
number=int(number/10)
print(zero)
| 2
12
10000
0
| 0
2
2499
|
<H1>階乗 II</H1>
<p>
<var>n! = n × (n − 1) × (n − 2) ×</var> ... <var> × 3 × 2 × 1</var><br/>
<br/>
を <var>n</var> の階乗といいます。例えば、12 の階乗は<br/>
<br/>
<var>12! = 12 × 11 × 10 × 9 × 8 × 7 × 6 × 5 × 4 × 3 × 2 × 1 = 479001600</var><br/>
<br/>
となり、末尾に 0 が 2 つ連続して並んでいます。
</p>
<p>
整数 <var>n</var> を入力して、<var>n!</var> の末尾に連続して並んでいる 0 の数を出力するプログラムを作成してください。ただし、<var>n</var> は 20000 以下の正の整数とします。
</p>
<H2>Input</H2>
<p>
複数のデータが与えられます。各データに <var>n</var> (<var>n</var> ≤ 20000) が１行に与えられます。<var>n</var> が 0 の時入力の最後とします。
</p>
<p>
データの数は 20 を超えません。
</p>
<H2>Output</H2>
<p>
各データに対して <var>n!</var> の末尾に連続して並んでいる 0 の数を１行に出力して下さい。
</p>
<H2>Sample Input</H2>
<pre>
2
12
10000
0
</pre>
<H2>Output for the Sample Input</H2>
<pre>
0
2
2499
</pre>
|
s750886115 | p00052 | Accepted | from math import factorial
import re
ez = re.compile(r'(0+)$')
while True:
n = input()
if n == 0: break
m = ez.search(str(factorial(n)))
if m:
print len(m.group(1))
else:
print 0 | 2
12
10000
0
| 0
2
2499
|
<H1>階乗 II</H1>
<p>
<var>n! = n × (n − 1) × (n − 2) ×</var> ... <var> × 3 × 2 × 1</var><br/>
<br/>
を <var>n</var> の階乗といいます。例えば、12 の階乗は<br/>
<br/>
<var>12! = 12 × 11 × 10 × 9 × 8 × 7 × 6 × 5 × 4 × 3 × 2 × 1 = 479001600</var><br/>
<br/>
となり、末尾に 0 が 2 つ連続して並んでいます。
</p>
<p>
整数 <var>n</var> を入力して、<var>n!</var> の末尾に連続して並んでいる 0 の数を出力するプログラムを作成してください。ただし、<var>n</var> は 20000 以下の正の整数とします。
</p>
<H2>Input</H2>
<p>
複数のデータが与えられます。各データに <var>n</var> (<var>n</var> ≤ 20000) が１行に与えられます。<var>n</var> が 0 の時入力の最後とします。
</p>
<p>
データの数は 20 を超えません。
</p>
<H2>Output</H2>
<p>
各データに対して <var>n!</var> の末尾に連続して並んでいる 0 の数を１行に出力して下さい。
</p>
<H2>Sample Input</H2>
<pre>
2
12
10000
0
</pre>
<H2>Output for the Sample Input</H2>
<pre>
0
2
2499
</pre>
|
s267715642 | p00052 | Accepted | import math
while True:
n = int(input())
if n == 0: break
fac = str(math.factorial(n))
print(len(fac) - len(fac.rstrip('0'))) | 2
12
10000
0
| 0
2
2499
|
<H1>階乗 II</H1>
<p>
<var>n! = n × (n − 1) × (n − 2) ×</var> ... <var> × 3 × 2 × 1</var><br/>
<br/>
を <var>n</var> の階乗といいます。例えば、12 の階乗は<br/>
<br/>
<var>12! = 12 × 11 × 10 × 9 × 8 × 7 × 6 × 5 × 4 × 3 × 2 × 1 = 479001600</var><br/>
<br/>
となり、末尾に 0 が 2 つ連続して並んでいます。
</p>
<p>
整数 <var>n</var> を入力して、<var>n!</var> の末尾に連続して並んでいる 0 の数を出力するプログラムを作成してください。ただし、<var>n</var> は 20000 以下の正の整数とします。
</p>
<H2>Input</H2>
<p>
複数のデータが与えられます。各データに <var>n</var> (<var>n</var> ≤ 20000) が１行に与えられます。<var>n</var> が 0 の時入力の最後とします。
</p>
<p>
データの数は 20 を超えません。
</p>
<H2>Output</H2>
<p>
各データに対して <var>n!</var> の末尾に連続して並んでいる 0 の数を１行に出力して下さい。
</p>
<H2>Sample Input</H2>
<pre>
2
12
10000
0
</pre>
<H2>Output for the Sample Input</H2>
<pre>
0
2
2499
</pre>
|
s487686814 | p00052 | Accepted | while(True):
n = input()
if(n == 0):
break
ans = 0
a = 5
count = 0
while(True):
count = n / a
if(count == 0):
break
ans += count
a *= 5
print(ans) | 2
12
10000
0
| 0
2
2499
|
<H1>階乗 II</H1>
<p>
<var>n! = n × (n − 1) × (n − 2) ×</var> ... <var> × 3 × 2 × 1</var><br/>
<br/>
を <var>n</var> の階乗といいます。例えば、12 の階乗は<br/>
<br/>
<var>12! = 12 × 11 × 10 × 9 × 8 × 7 × 6 × 5 × 4 × 3 × 2 × 1 = 479001600</var><br/>
<br/>
となり、末尾に 0 が 2 つ連続して並んでいます。
</p>
<p>
整数 <var>n</var> を入力して、<var>n!</var> の末尾に連続して並んでいる 0 の数を出力するプログラムを作成してください。ただし、<var>n</var> は 20000 以下の正の整数とします。
</p>
<H2>Input</H2>
<p>
複数のデータが与えられます。各データに <var>n</var> (<var>n</var> ≤ 20000) が１行に与えられます。<var>n</var> が 0 の時入力の最後とします。
</p>
<p>
データの数は 20 を超えません。
</p>
<H2>Output</H2>
<p>
各データに対して <var>n!</var> の末尾に連続して並んでいる 0 の数を１行に出力して下さい。
</p>
<H2>Sample Input</H2>
<pre>
2
12
10000
0
</pre>
<H2>Output for the Sample Input</H2>
<pre>
0
2
2499
</pre>
|
s458051457 | p00052 | Accepted | while 1:
n = int(raw_input())
if n==0: break
c = 0
while n:
n /= 5
c += n
print c | 2
12
10000
0
| 0
2
2499
|
<H1>階乗 II</H1>
<p>
<var>n! = n × (n − 1) × (n − 2) ×</var> ... <var> × 3 × 2 × 1</var><br/>
<br/>
を <var>n</var> の階乗といいます。例えば、12 の階乗は<br/>
<br/>
<var>12! = 12 × 11 × 10 × 9 × 8 × 7 × 6 × 5 × 4 × 3 × 2 × 1 = 479001600</var><br/>
<br/>
となり、末尾に 0 が 2 つ連続して並んでいます。
</p>
<p>
整数 <var>n</var> を入力して、<var>n!</var> の末尾に連続して並んでいる 0 の数を出力するプログラムを作成してください。ただし、<var>n</var> は 20000 以下の正の整数とします。
</p>
<H2>Input</H2>
<p>
複数のデータが与えられます。各データに <var>n</var> (<var>n</var> ≤ 20000) が１行に与えられます。<var>n</var> が 0 の時入力の最後とします。
</p>
<p>
データの数は 20 を超えません。
</p>
<H2>Output</H2>
<p>
各データに対して <var>n!</var> の末尾に連続して並んでいる 0 の数を１行に出力して下さい。
</p>
<H2>Sample Input</H2>
<pre>
2
12
10000
0
</pre>
<H2>Output for the Sample Input</H2>
<pre>
0
2
2499
</pre>
|
s061480671 | p00052 | Accepted | def div(num,d):
cnt = 0
while True:
if num % d or num == 1 : return cnt
num /= d; cnt += 1
while True:
n = int(raw_input())
if n == 0: break
n2,n5 = 0,0
for i in xrange(2,n+1):
n2 += div(i,2);
n5 += div(i,5)
print min(n2,n5) | 2
12
10000
0
| 0
2
2499
|
<H1>階乗 II</H1>
<p>
<var>n! = n × (n − 1) × (n − 2) ×</var> ... <var> × 3 × 2 × 1</var><br/>
<br/>
を <var>n</var> の階乗といいます。例えば、12 の階乗は<br/>
<br/>
<var>12! = 12 × 11 × 10 × 9 × 8 × 7 × 6 × 5 × 4 × 3 × 2 × 1 = 479001600</var><br/>
<br/>
となり、末尾に 0 が 2 つ連続して並んでいます。
</p>
<p>
整数 <var>n</var> を入力して、<var>n!</var> の末尾に連続して並んでいる 0 の数を出力するプログラムを作成してください。ただし、<var>n</var> は 20000 以下の正の整数とします。
</p>
<H2>Input</H2>
<p>
複数のデータが与えられます。各データに <var>n</var> (<var>n</var> ≤ 20000) が１行に与えられます。<var>n</var> が 0 の時入力の最後とします。
</p>
<p>
データの数は 20 を超えません。
</p>
<H2>Output</H2>
<p>
各データに対して <var>n!</var> の末尾に連続して並んでいる 0 の数を１行に出力して下さい。
</p>
<H2>Sample Input</H2>
<pre>
2
12
10000
0
</pre>
<H2>Output for the Sample Input</H2>
<pre>
0
2
2499
</pre>
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.