Professional Documents
Culture Documents
blog.dreamshire.com/more-solutions-to-spoj-programming-problems/
Loading...
More solutions (fewer than 10 lines) to some SPOJ classical problems using Python.
Note: SPOJ may prevent Python from being used for solving some problems or set time limits
suitable only for compiled languages.
some of these were originally written in Perl and have been rewritten in Python. Many solutions
have Perl-like references and influences in them.
1/32
B = [0, 1, 20, 360, 7200, 144000, 2880000, 57600000]
c = lambda d: d.count('.') + 5*d.count('-')
while True:
n = int(raw_input())
if n==0: break
A = reversed([raw_input() for _ in range(n)])
print sum(c(d) * B[i] for i, d in enumerate(A, 1))
for _ in xrange(input()):
n, k = map(int, raw_input().split())
P = [(int(x), i) for i,x in enumerate(map(int, raw_input().split()), 1) if x>=0]
dp = [0]+[9999]*k
for p, i in P:
for j in xrange(i, k+1):
if dp[j-1] != 9999:
dp[j] = min(dp[j], dp[j-i] + p)
print dp[k] if dp[k] != 9999 else -1
n, m = map(int, raw_input().split())
for _ in range(int(raw_input())):
x1, y1, x2, y2, x3, y3 = map(int, raw_input().split())
xd = min(x2+abs(y1-y2), x3+abs(y1-y3))
xm = max(x2-abs(y1-y2), x3-abs(y1-y3))
yd = min(y2+abs(x1-x2), y3+abs(x1-x3))
print 'YES' if x1 < xd or y1 < yd or x1 > xm else 'NO'
Billiard (BILLIARD)
Time: 0.00
Output: Calculate the measure of the angle A in degrees and the velocity of the ball measured
in inches per second.
2/32
from math import pi, sqrt, atan
while True:
a, b, s, m, n = map(float, raw_input().split())
if s==0: break
vx = m*a/s
vy = n*b/s
print '%.2lf %.2lf' % (atan(vy/vx)*180.0/pi, sqrt(vx*vx + vy*vy))
m = {}
def coins(n):
if n==0: return n
if not n in m:
m[n] = max(n, coins(n/2) + coins(n/3) + coins(n/4))
return m[n]
for _ in xrange(10):
print coins(input())
for _ in xrange(input()):
csi, b, x, y = map(int,raw_input().split())
i, s = 1, 0
while x+y > 0:
s+= (x+y)%b * i
x//= b; y//= b; i*= b
print csi, s
3/32
for _ in xrange(int(raw_input())):
A = [0]*1001
n = int(raw_input())
for i in map(int, raw_input().split()):
if A[i+1]==0: A[i+1] = 1
else: A[n-i] = 1
print 'YES' if n==sum(A) else 'NO'
for _ in xrange(input()):
s = ''
n = int(raw_input())
while n > 0:
n, r = divmod(n, 5)
if r==0: n -= 1
s += 'umank'[r]
print s[::-1]
while True:
d, f, b, m = map(int, raw_input().split())
if d<1 or f<1 or b<1 or m<1: break
n = (f*f + f + 2) /2
t = d - n*b
if t > m:
print 'Farmer Cream will have', t, 'Bsf to spend.'
else:
print 'The firm is trying to bankrupt Farmer Cream by', m-t, 'Bsf.'
while True:
S, T = raw_input().split()
if S=='*' and T=='*': break
c, f = 0, 0
for s,t in zip(S,T):
if s!=t and f==0:
c +=1
f = (s!=t)
print c
Seinfeld (ANARC09A)
Time: 0.00
Summary: Find the minimum number of operations needed to convert the given string into a
balanced one.
import sys
for cs, s in enumerate(sys.stdin.readlines(), 1):
if s[0] == '-': break
n, cnt = 0, 0
for c in s:
if c == '{': n+= 1
elif c == '}' and n==0: n+= 1; cnt+= 1
elif c == '}' and n>0: n-= 1
print '%d. %d' % (cs, n/2+cnt)
A = [0, 0]
for i in xrange(2, 10001):
A.append(A[-1] + 1.0/i)
while True:
n = int(raw_input())
if n == 0: break
print 'With %d competitors, a Jedi Knight will be replaced approximately %.2f
times.' % (n, A[n])
Pyramids (PIR)
Time: 0.00
Summary: Find the volume of a tetrahedron given only the six edge-lengths.
5/32
from math import sqrt
for _ in xrange(input()):
A, D, B, E, C, F = map(lambda x: int(x)**2, raw_input().split())
volume = sqrt((-A*B*C - A*D*E - B*D*F - C*E*F + A*C*D + B*C*D + \
A*B*E + B*C*E + B*D*E + C*D*E + A*B*F + A*C*F + \
A*D*F + C*D*F + A*E*F + B*E*F - C*C*D - C*D*D - \
B*B*E - B*E*E - A*A*F - A*F*F)/144.0)
print "%.4f" % volume
for _ in xrange(input()):
n, k = map(int, raw_input().split())
A = map(int, raw_input().split())
for i in xrange(min(n, k)):
if A[i]>=0: break
A[i] *= -1
k-=1
m = min(A) if k&1 else 0
print sum(A)-2*m
primes = [2,3,5,7,11,13,17,19,23,29,31,37,41,43,47,53,59,61,67,71,73,
79,83,89,97,101]
for _ in xrange(20):
n = int(raw_input())
px = 1
for p in primes:
if px*p > n: break
px*=p
print px
import sys
def L(n):
p = lambda x: [1,2,4,8][x%4]
if n<5: return [1,1,2,6,4][n]
return p(n/5) * L(n/5) * L(n%5) % 10
for b in sys.stdin.readlines():
print L(int(b))
for _ in xrange(int(raw_input())):
print (int(raw_input())+1) / 2
for _ in xrange(input()):
raw_input(); a, _, b, _, c = raw_input().split()
if 'machula' in a: a = str(int(c) - int(b))
elif 'machula' in b: b = str(int(c) - int(a))
else: c = str(int(a) + int(b))
print a, '+', b, '=', c
A023194 = [2, 4, 9, 16, 25, 64, 289, 729, 1681, 2401, 3481, 4096, 5041, 7921, 10201,
15625, \
17161, 27889, 28561, 29929, 65536, 83521, 85849, 146689, 262144, 279841, 458329, \
491401, 531441, 552049, 579121, 597529, 683929, 703921, 707281, 734449, 829921,
1190281]
for _ in range(int(raw_input())):
L, H = map(lambda x:max(A023194, key=lambda y:y>=int(x)), raw_input().split())
print A023194.index(H) - A023194.index(L)
while True:
N, D = map(int, raw_input().split())
if N==0 and D==0: break
print pow(N, D)
8/32
Candy I (CANDY)
Time: 0.00
Summary: Find the smallest number of moves for each block of data.
while True:
n = input()
if n == -1: break
A = [int(raw_input()) for _ in xrange(n)]
s = sum(A)
print -1 if s%n else sum(abs(s/n-a) for a in A)/2
for _ in xrange(input()):
a, b = map(int, raw_input().split('/'))
s = ''
while a*b > 1:
s += 'L' if a < b else 'R'
a, b = (b-a, a) if a < b else (b, a-b)
print s
for _ in range(int(raw_input())):
a, b = map(int, raw_input().split())
while b:
a, b = b, a%b
while a%2==0: a>>= 1
print 'Y' if a==1 else 'N'
GLJIVE (GLJIVE)
9/32
Time: 0.00
Output: Help Super Mario and tell him how many points he will score.
def f(s=0):
for _ in range(10):
d = int(raw_input())
s += d
if s >= 100:
return s if s <= 100+d/2 else s-d
return s
print f()
for _ in xrange(int(raw_input())):
n = int(raw_input())
print n*(n+1)*(n+2)/2
for _ in xrange(int(raw_input())):
k, n = map(int, raw_input().split())
print int(bin(n)[2:], k)
while True:
w = raw_input().strip().lower().split()
if w[0]=='*': break
s = sum(1 for c in w if c[0]==w[0][0])
print 'Y' if len(w)==s else 'N'
10/32
Time: 0.05
Summary: Find the value of a sequence.
for _ in xrange(input()):
n = float(raw_input())
print '%.11f' % (2.0/3 + (1.0/6 + 1/(n+2) - 1/(n+1))/2)
for _ in xrange(input()):
A = [raw_input().split() for _ in xrange(99)]
s = ''.join(c for n,c in A if int(n)%9==0 and int(n)<82)
print 'YES' if s==s[0]*len(s) else 'NO'
CANDY (LQDCANDY)
Time: 0.05
Summary: Find the length of the chocolate bar and the minimum number of times to break the
bar.
for _ in xrange(int(raw_input())):
N = int(raw_input())
print ((N/2 + 1)**2) % N
11/32
for cs in xrange(1, int(raw_input())+1):
K = int(raw_input())
print 'Pyramid E. Nro# %d: %d' % (cs, K*(2*K*K + 6*K - 5)/3)
print 'Tringus:', 2*(K*K - K)
Kusac (KUSAC)
Time: 0.12
Summary: Find the minimum number of cuts.
A = [0, 0, 1]
for i in xrange(3, 100000):
A.append(((i-1) * (A[-1]+A[-2])) % 1000000007)
for _ in xrange(input()):
n = int(raw_input())
print 0 if n >= 100000 else A[n]
for _ in xrange(input()):
a, b, c = map(int, raw_input().split())
n = (c*2)/(a+b)
d = (b-a)/(n-5)
m = a-2*d
print n, '\n', " ".join(str(m+d*i) for i in range(n))
12/32
for cs in xrange(1, int(raw_input())+1):
br = [0]*10
ar = map(int, list(raw_input()))
for a in ar:
br[a]+= sum(br[:a]) + 1
print 'Case %d: %d' % (cs, sum(br) % 1000000007)
for _ in xrange(int(raw_input())):
raw_input()
n = int(raw_input())
A = sorted([int(raw_input().split()[1]) for _ in xrange(n)])
print sum(abs(A[i]-i-1) for i in xrange(n))
13/32
for _ in xrange(input()):
n, s = input(), ''
if n == 0: print 10
elif n < 10: print n
else:
for i in xrange(9, 1, -1):
while n%i == 0:
s += str(i)
n /= i
print -1 if n > 1 else s[::-1]
for _ in xrange(input()):
A = sorted(map(int, raw_input().split())[1:])
B = sorted(map(int, raw_input().split())[1:])
d = abs(A[0]-B[0])
for a in A:
for b in B:
d = min(d, abs(a-b))
if a < b: break
print d
for _ in xrange(input()):
n = int(raw_input())
print pow(2, n+1, 1298074214633706835075030044377087) - 1
while True:
t, vol, N = 0, 1001, int(raw_input())
if N==0: break
for i in xrange(N):
a, b, c = map(int, raw_input().split())
t += a*b*c
vol = min(a, b, c, vol)
print t/vol**3
abs(a-b) I (ABSP1)
Time: 0.59
Summary: Calculate the summation of the absolute difference of all the distinct pairs.
14/32
for _ in xrange(input()):
N = input()
A = map(int, raw_input().split())
s, x = 0, 0
for i in xrange(1, N):
x += (i*(A[i] - A[i-1]))
s += x
print s
m = 10**9 + 7
for _ in xrange(int(raw_input())):
r, t, s = 2, [0]*100, map(ord, raw_input())
t[s[0]] = 1
for i in s[1:]:
tmp = t[i]
t[i] = r
r = (2*r - tmp) % m
print r
15/32
v = [0]*1000001
for i in xrange(1, 1000000):
if v[i]==0: print i
s, n = 0, i
while n > 0: s, n = s + n%10, n//10
v[min(s+i, 1000000)] = 1
Valences (UCV2013J)
Time: 0.44
Summary: For each compound output a single line with the sum of the valences.
while True:
V = raw_input().split()
n = int(V[0])
if n == 0: break
print sum(map(int, V[n/2+1:]))
Cylinder (CYLINDER)
Paraphrased: Calculate the biggest possible volume of a cylinder.
t, m = [1], 10**9+7
for _ in xrange(1, 100000):
t.append(2*t[-1] % m)
for cs in xrange(1, input()+1):
n = int(raw_input())
print 'Case %d: %d' % (cs, 1 if n==1 else (n+1)*t[n-2] % m)
for _ in xrange(input()):
n, m, i ,j = raw_input().split()
m = int(m[-1]) * int(n)
j = int(j[-1]) + int(i)
print 'Possible.' if m%2 and j%2==0 else 'Impossible.'
Rachu (MAY99_4)
Time: 0.06 PYPY
Summary: Calculate the number of ways muffins could be distributed.
17/32
n = int(raw_input())
A = [map(int, raw_input().split()) for _ in xrange(n)]
L1, L2 = A[0][1], A[0][0]
for i in xrange(1, n):
L1, L2 = max(L1+abs(A[i-1][0]-A[i][0])+A[i][1], L2+abs(A[i-1][1]-A[i][0])+A[i][1]), \
max(L1+abs(A[i-1][0]-A[i][1])+A[i][0], L2+abs(A[i-1][1]-A[i][1])+A[i][0])
print max(L1, L2)
18/32
m = 10**5+10
dp = [1]+[0]*m
for i in [2,3,6,7,8]:
for j in xrange(i, m):
dp[j]+= dp[j-i]
for _ in xrange(input()):
print dp[int(raw_input())]
m = {1:1}
def f(n):
if not n in m:
m[n] = f(n/2)+f(n/2+1) if n&1 else f(n/2)
return m[n]
while True:
n = int(raw_input())
if n==0: break
print '%d/%d' % (f(n), f(n+1))
GETTING AN AP (APPROB)
Time: 0.62
Summary: Find p/q, where p/q is an irreducible fraction denoting the probability of forming an
arithmetic progression from the chits LJ picks.
0 0 Pairs (M00PAIR)
Time: 0.05
Summary: For each input n print the number of consecutive zeroes pairs that will appear in the
sequence after n steps.
import sys
A = [0, 1]
for _ in xrange(1000):
A.append(2*A[-2] + A[-1])
for ns in sys.stdin:
print A[int(ns)-1]
19/32
from fractions import gcd
n = int(raw_input())
A = [int(raw_input()) for _ in xrange(n)]
d = 0
for i in xrange(1, n):
d = gcd(d, A[i]-A[i-1])
print (A[-1]-A[0])/d - n+1
while True:
try:
_, n, h = [raw_input() for _ in xrange(3)]
p = h.find(n)
while p > 0:
print p
p = h.find(n, p+1)
print
except: break
Ljutnja (C1LJUTNJ)
Time: 0.44
Summary: Minimize the total anger for the children of the corn. See the movie to get the
reference. Also, the mod 2^64 was a nice touch in adding to one's misery.
m, n = map(int, raw_input().split())
W = sorted([int(raw_input()) for _ in xrange(n)])
t = sum(W) - m
ta = 0
for i in xrange(n):
anger = min(W[i], t/(n-i))
ta += anger * anger
t -= anger
print ta % 2**64
for _ in xrange(input()):
raw_input(); raw_input(); #blank & unneeded
Gmax = max(map(int, raw_input().split()))
Mmax = max(map(int, raw_input().split()))
print 'Godzilla' if Gmax >= Mmax else 'MechaGodzilla'
20/32
Ambiguous Permutations (PERMUT2)
Time: 0.34
Paraphrased: Determine whether the permutation is ambiguous or not.
while True:
if input()==0: break
p = map(int, raw_input().split())
for j, pj in enumerate(p, 1):
if pj != j and p[pj-1] != j:
print 'not',
break
print 'ambiguous'
Collatz (CLTZ)
Time: 0.28
Paraphrased: Collatz sequence.
import sys
for ns in sys.stdin:
n, c = int(ns), 1
while n != 1:
n = 3*n +1 if n%2 else n>>1
c += 1
print c
for _ in xrange(int(raw_input())):
B = int(raw_input().split()[1])
print '1.000000' if B%2 else '0.000000'
for _ in xrange(int(raw_input())):
x, y = map(int, raw_input().split())
print x+y-x%2 if x==y or (x-y)==2 else 'No Number'
21/32
for _ in xrange(int(raw_input())):
n, m, D = map(int, raw_input().split())
c = sum((int(raw_input())-1)/D for _ in xrange(n))
print 'YES' if c >= m else 'NO'
for _ in xrange(int(raw_input())):
n = int(raw_input())
print n*(n+2)*(2*n+1) / 8
while True:
t, w = 0, 0
if raw_input() == '0': break
for a in raw_input().split():
t+= int(a)
w+= abs(t)
print w
for _ in xrange(int(raw_input())):
h = int(raw_input())
print h*(h+1) / 6
War (TAP2013G)
Time: 0.82
Paraphrased: When it comes to war, cheaters always prosper. Simple sort and compare to see
who wins more battles, and thus, the war.
S = input()
Q = sorted(map(int, raw_input().split()))
N = sorted(map(int, raw_input().split()))
b = 0
for j in range(S):
if Q[b] < N[j]: b+=1
print b
22/32
from math import sqrt
for _ in xrange(50):
x = input()
print sum(1 for i in xrange(1, int(sqrt(x/2))+1) if sqrt(x - i*i)%1 == 0)
for _ in xrange(int(raw_input())):
n = int(raw_input())
t = sum(map(int, raw_input().split()))
print n-1 if t%n else n
for _ in xrange(int(raw_input())):
N = int(raw_input())
print N + N*N*(10*N + 9)
Party (CFPARTY)
time: 0.12
Paraphrased: Maximum number of people at the end of a party.
for _ in xrange(int(raw_input())):
a, b = raw_input().split()
print int(str((int(a[::-1]) + int(b[::-1])))[::-1])
Clones (NCLNE)
Time: 0.86
Paraphrased: Check a sequence for legitimacy according to clone rules of replication.
for _ in xrange(int(raw_input())):
raw_input(); b = map(int, raw_input().split())
d = reduce(lambda d,t: 2*(d - t), b[:-1], 1)
print 'Yes' if d==b[-1] else 'No'
23/32
def sd(n): return sum(int(i) for i in str(n))
for _ in xrange(int(raw_input())):
n = int(raw_input())
while n % sd(n): n+=1
print n
import sys
for g, st in enumerate(sys.stdin, 1):
c = 0
for s in st.strip():
c+= (s=='1') ^ (c&1)
print "Game #%d: %d" % (g, c)
import sys
for c, ns in enumerate(sys.stdin, 1):
A = sorted(map(int, ns.split()))
print 'Case %d: %d' % (c, A[2] + A[3])
for _ in xrange(int(raw_input())):
raw_input(); n = int(raw_input())
k = sum(int(raw_input())%n for _ in xrange(n))
print "NO" if k%n else "YES"
24/32
while True:
N = input()
if N==0: break
C = sorted(map(int, raw_input().split()))
P = sorted(map(int, raw_input().split()))
print sum(C[i] * P[N-i-1] for i in xrange(N)) #cost
Factorial (FCTRL)
Time: 0.31 PYPY
Paraphrased: Simply, find the number of trailing zeros in a factorial.
for _ in xrange(input()):
n = input()
c = 0
while n >= 5:
n /= 5
c += n
print c
while True:
N, D = map(int, raw_input().split())
if N==0 and D==0: break
print N, D, reduce(lambda a,j:(a+D)%j, xrange(2, N+1), 0) + 1
for _ in xrange(input()):
n, m = map(int, raw_input().split())
if n>m:
print 'U' if m%2==0 else 'D'
else:
print 'L' if n%2==0 else 'R'
for _ in xrange(input()):
n = input()
k = n*n if n%2==0 else (n+3)*(n+3)
print k/48+1 if k%48>24 else k/48
for _ in xrange(input()):
nx = input()
t = [map(int, raw_input().split()) for _ in xrange(nx)]
for r in xrange(nx-1, 0, -1):
for c in xrange(0, r):
t[r-1][c] += max(t[r][c], t[r][c+1])
print t[0][0]
for _ in xrange(int(raw_input())):
x, avg = map(int, raw_input().split())
print (avg*avg - x*x - 3*x + 3*avg)/2
26/32
for _ in xrange(int(raw_input())):
N, K = map(int, raw_input().split())
h = sorted(map(int, raw_input().split()))
print min(h[K-1+i] - h[i] for i in xrange(N-K+1))
for _ in xrange(int(raw_input())):
n = int(raw_input())
print reduce(lambda q,k: (q+n-k)%k+1, xrange(2, n+1), 1)
a = [0, 1]
for i in xrange(2, 100001):
a.append(a[-1] + 1.0/i)
for _ in xrange(int(raw_input())):
print a[int(raw_input())]
27/32
from math import log
for _ in xrange(int(raw_input())):
N, K, M = map(int, raw_input().split())
print 0 if M<=N else int(log(M/N, K))
for _ in xrange(int(raw_input())):
n, p = map(int, raw_input().split())
if n < p:
q = reduce(lambda a,j:(a*j)%p, xrange(p-1, n, -1), 1)
print p - pow(q, p-2, p) if n < p else 0
SHAHBAG (SHAHBG)
Time: 0.19
Paraphrased: Print number of groups currently in shahbag.
raw_input()
cnt, Px = 0, [False]*20002
for p in map(int, raw_input().split()):
Px[p] = True
if Px[p-1] == Px[p+1] == True: cnt-= 1
if Px[p-1] == Px[p+1] == False: cnt+= 1
print cnt
print 'Justice'
for _ in xrange(int(raw_input())):
maxm = s = raw_input()
maxf = 0
for f in xrange(len(s)):
m = s[f:] + s[:f]
maxm, maxf = (m, f) if maxm > m else (maxm, maxf)
print maxf + 1
for _ in xrange(input()):
raw_input()
A = sorted(map(int, raw_input().split()))
B = sorted(map(int, raw_input().split()))
print sum(a*b for a,b in zip(A,B))
import sys, re
buff = sys.stdin.readlines()
for s in buff:
sx = ''
for g, c in re.findall(r'((\w)\2{0,})', s):
j = len(g)
sx+= c*j if j <= 3 else str(j)+'!'+c
print sx
KNJIGE (KNJIGE)
Time: 0.80
Paraphrased: Find the number of moves.
n = int(raw_input())
for a in reversed([raw_input() for _ in range(n)]):
if a == str(n): n-= 1
print n
Pizza (EGYPIZZA)
Time: 0.01
Paraphrased: Find the the minimal number of pizzas.
Bowling (BOWLING1)
Time: 0.02
Paraphrased: Calculate the bowling score.
for _ in xrange(int(raw_input())):
d = map(int,raw_input().split())
s = 0
for _ in xrange(10):
s+= sum(d[:2 + (d[0]+d[1] > 9)])
d = d[2 - (d[0] > 9):]
print s
29/32
Dukkar and Pikka (DUKKAR)
Time: 0.42
Paraphrased: Calculate the number of numbers divisible by P on Nth row of the pascal triangle.
for _ in xrange(int(raw_input())):
n, p = map(int, raw_input().split())
nx = n+1
ans = 1
while n>0:
n, r = divmod(n, p)
ans*= r+1
print nx-ans
for _ in range(int(raw_input())):
n = int(raw_input())
print 'Sorry Shaktiman' if n%2 else 'Thankyou Shaktiman'
for _ in range(int(raw_input())):
n = int(raw_input())
if n==1: print 'poor conductor'
else:
r = (n+3)/5
print r, 'AWWAAMWWMA'[n%10], 'L' if n%10<4 else 'R'
for _ in xrange(int(raw_input())):
s = raw_input() + '.'
n = int(s.replace('.', ''))
f = 10 ** len(s[s.index('.')+2:])
print f/gcd(n,f)
30/32
from math import pi, asin
for cs in range(1, int(raw_input())+1):
ta, sp = map(float, raw_input().split())
si = ta*9.806 / sp / sp
print 'Scenario #%d: %.2f' % (cs, asin(si)*90/pi if si <= 1 else -1)
BRODOVI (BRODOVI)
Time: 0.46 PYPY
Output: The first and only line of output must contain the required minimum number of ships.
n, c = int(raw_input()), 0
bx = [int(raw_input())-1 for _ in range(n)][1:]
for b in bx:
for q in bx[c+1:]:
if q%b==0: bx.remove(q)
c+=1
print c
f = [1,1]; g = [1,0]
for i in range(2, 33001):
f.append((f[-1] + f[-2] + 2*g[-1]) % 10000)
g.append((f[-3] + g[-1]))
for _ in range(int(raw_input())):
print f[int(raw_input())]
31/32
from collections import Counter
while True:
n, m = map(int, raw_input().split())
if n==0 and m==0: break
q =[0]*n
for z in Counter(raw_input() for _ in range(n)).values():
q[z-1]+= 1
for qx in q: print qx
for _ in range(int(raw_input())):
n = int(raw_input())
d = [map(int, raw_input().split()) for _ in range(n)]
for i in range(n-1):
for j in range(i+1, n):
for k in range(n):
if j!=k and i!=k and d[j][k]+d[k][i]==d[j][i]: break
if k==n-1: print i+1, j+1
raw_input()
Matches (FERT21_0)
Time: 0.10
Output: Find (1/2)**n with full precision to n<=1000.
for _ in xrange(input()):
n = int(raw_input())
x = 5**(n-1)
print '1' if n==1 else '0.'+str(x).zfill(n-1) # x/10**n
32/32