def dataStream ():
size = (int)(stdin.next())
a = [int(stdin.next())*-1 for _ in xrange(size)]
heapify(a)
for line in stdin:
if (a[0]<((int)(line)*-1)):
heappushpop(a,((int)(line)*-1))
return sorted([x*-1 for x in a])
def read_walls(self): M = self.M; N = self.N; self.vertical = []; self.horizontal = []; for y in range(N): line = stdin.next(); self.vertical.append([int(w) for w in line.split()]); for y in range(N-1): line = stdin.next(); self.horizontal.append([int(w) for w in line.split()]);
def transcribe_dna(sequence=None):
"""
Given test:
>>> seq = 'GATGGAACTTGACTACGTAAATT'
>>> transcribe_dna(seq)
GAUGGAACUUGACUACGUAAAUU
"""
if not sequence:
sequence = stdin.next().upper()
sequence = sequence.replace('T', 'U')
print sequence
def count_dna_nucleotides(sequence=None):
"""
Given test:
>>> seq = 'AGCTTTTCATTCTGACTGCAACGGGCAATATGTCTCTGTGTGGATTAAAAAAAGAGTGTCTGATAGCAGC'
>>> count_dna_nucleotides(seq)
20 12 17 21
"""
if not sequence:
sequence = stdin.next().upper()
counts = Counter(sequence)
print counts['A'], counts['C'], counts['G'], counts['T']
def complement_dna(sequence=None):
"""
Given test:
>>> seq = 'AAAACCCGGT'
>>> complement_dna(seq)
'ACCGGGTTTT'
"""
if not sequence:
sequence = stdin.next().upper()
complement = sequence.replace('A', 't').\
replace('T','a').\
replace('C','g').\
replace('G','c').\
upper()[::-1]
return complement
def translate_to_protein_string(sequence=None):
"""
Given test:
>>> seq = 'AUGGCCAUGGCGCCCAGAACUGAGAUCAAUAGUACCCGUAUUAACGGGUGA'
>>> translate_to_protein_string(seq)
MAMAPRTEINSTRING
"""
if not sequence:
sequence = stdin.next().strip()
protein_list = []
for codon_start_index in range(0, len(sequence), 3):
codon = sequence[codon_start_index:codon_start_index + 3]
protein = codon_to_protein_dct[codon]
if protein == 'Stop':
break
protein_list.append(protein)
print ''.join(protein_list)
from sys import stdin T=int(stdin.next()) for _t in range(1,T+1): F=[];S=[] r1=int(stdin.next())-1 for i in range(4): F.append([int(x) for x in stdin.next().strip().split()]) r2=int(stdin.next())-1 for j in range(4): S.append([int(x) for x in stdin.next().strip().split()]) count=0;res=0 for i in F[r1]: for j in S[r2]: if(i==j): res=i count+=1 if(count==0): print "Case #%d: %s"%(_t,"Volunteer cheated!") elif(count==1): print "Case #%d: %d"%(_t,res) else: print "Case #%d: %s"%(_t,"Bad magician!")
# @EXPECTED_RESULTS@: CORRECT
from sys import stdin, exit
from collections import deque
n, m = int(stdin.next()), int(stdin.next())
you = deque(map(int, stdin.next().split())) if n else []
mike = deque(map(int, stdin.next().split())) if m else []
you_table = []
mike_table = []
def draw():
global you, mike, you_table, mike_table
if not you or not mike:
if not you and not mike:
print 'draw'
exit(0)
elif not you:
print 'mike'
exit(0)
else:
print 'you'
exit(0)
you_table.append(you.popleft())
mike_table.append(mike.popleft())
return you_table[-1], mike_table[-1]
#!/usr/bin/env python
from sys import stdin
from itertools import *
def answer(data):
time = 0
pos = { 'O':1, 'B':1 }
lastTime = { 'O':0, 'B':0 }
for robot,newPos in data:
arriveTime = lastTime[robot] + abs(pos[robot]-newPos)
time = max(time, arriveTime) + 1
pos[robot] = newPos
lastTime[robot] = time
return time
def cases(s):
while 1:
pc = stdin.next().split()[1:]
yield zip(pc[::2], map(int, pc[1::2]))
if __name__ == '__main__':
stdin.next()
for n,case in enumerate(cases(stdin)):
print "Case #%d: %s" % (n+1, answer(case))
def is_perfect_square(apositiveint):
if apositiveint == 1:
return True
x = apositiveint // 2
seen = set([x])
while x * x != apositiveint:
x = (x + (apositiveint // x)) // 2
if x in seen: return False
seen.add(x)
return True
def count_fair_and_squre(start, end):
count = 0
for number in np.arange(start, end + 1):
if is_palindrome(number):
if is_perfect_square(number):
if is_palindrome(int(math.sqrt(number))):
count += 1
return count
test_cases = int(stdin.next().strip())
for test_case in xrange(1, test_cases + 1):
start, end = map(int, stdin.next().split())
print "Case #%d: %d" % (test_case, count_fair_and_squre(start, end))
from sys import stdin
import re
import operator
import bisect
import sys
import random
def pancakes(p):
cur_max = p.pop()
if cur_max <= 3:
return cur_max
else:
if cur_max == 9:
new_p = p[:]
bisect.insort(new_p, 3)
bisect.insort(new_p, 6)
t9 = pancakes(new_p)
else:
t9 = cur_max
bisect.insort(p, cur_max / 2)
bisect.insort(p, cur_max / 2 + cur_max % 2)
return min(cur_max, 1 + t9, 1 + pancakes(p))
cases = int(stdin.next().strip())
for case in range(1, cases + 1):
D = int(stdin.next().strip())
p = map(int, stdin.next().split())
p.sort()
print 'Case #%d: %d' % (case, pancakes(p))
from sys import stdin
for _t in xrange(1, int(stdin.next()) + 1):
N = int(stdin.next())
if N == 0:
out = "INSOMNIA"
else:
out = 0
digits = []
temp_N = N
while temp_N > 0:
digit = temp_N % 10
if digit not in digits:
out += 1
digits.append(digit)
temp_N /= 10
# print digits,N,out
i = 2
while len(digits) < 10:
out = next_N = N * i
while next_N > 0:
digit = next_N % 10
if digit not in digits:
digits.append(digit)
next_N /= 10
i += 1
next_N *= i
print "Case #" + str(_t) + ":", out
from sys import stdin
import re
import operator
import bisect
import sys
import random
cases = int(stdin.next().strip())
for case in range(1, cases + 1):
N = int(stdin.next().strip())
M = map(int, stdin.next().split())
drops = [max(i - j, 0) for i, j in zip(M[:-1], M[1:])]
max_eaten = [min(max(drops), x) for x in M[:-1]]
print 'Case #%d: %d %d' % (case, sum(drops), sum(max_eaten))
from sys import stdin
T9R = {'2':'abc','3':'def', '4': 'ghi', '5':'jkl', '6':'mno','7':'pqrs', '8':'tuv', '9':'wxyz','0':' '}
T9={}
for k,v in T9R.items():
for i,c in enumerate(v):
T9[c]=k*(i+1)
T=int(stdin.next())
for t in range(T):
M=stdin.next().strip('\n')
KP=T9[M[0]]
for c in M[1:]:
kp=T9[c]
if(kp[0] == KP[-1]):
KP+=' '
KP+=kp
print 'Case #%d: %s' %(t+1,KP)
def output():
for case in xrange(1, int(stdin.next()) + 1):
r,t = [int(i) for i in stdin.next().strip().split()]
ans = solve(r,t)
print 'Case #%d:' % case, ans
print >>stderr, 'Case #%d:' % case, ans
from sys import stdin
import re
import operator
import bisect
import sys
import random
from collections import defaultdict
from functools import reduce # Valid in Python 2.6+, required in Python 3
import operator
from fractions import gcd
def lcm(a, b):
"""Return lowest common multiple."""
return a * b // gcd(a, b)
d = {"0": 0}
for i in xrange(1, 10**6 + 1):
s, p = str(i), str(i - 1)
r = s[::-1]
d[s] = d[p] + 1
if r in d:
d[s] = min(d[s], d[r] + 1)
cases = int(stdin.next().strip())
for case in range(1, cases + 1):
N = str(stdin.next().strip())
print 'Case #%d: %d' % (case, d[N])
from sys import stdin
import re
import operator
import bisect
import sys
import random
cases = int(stdin.next().strip())
for case in range(1, cases + 1):
Smax, audience = stdin.next().split()
to_add, tot = 0, 0
for i, v in enumerate(audience):
if tot < i:
to_add += i - tot
tot = i
tot += int(v)
print 'Case #%d: %d' % (case, to_add)
from sys import stdin
n, o, t, f = map(int, stdin.next().split())
assert (2 <= n <= 500)
assert (0 <= o <= n)
assert (0 <= t <= n)
assert (0 <= o + t <= n)
oslo = {}
os = map(int, stdin.next().split())
assert (len(os) == o)
for i in os:
assert (1 <= i <= n)
assert (i not in oslo)
oslo[i] = True
trondheim = {}
tr = map(int, stdin.next().split())
assert (len(tr) == t)
for i in tr:
assert (1 <= i <= n)
assert (i not in oslo)
assert (i not in trondheim)
trondheim[i] = True
def output():
for case in xrange(1, int(stdin.next()) + 1):
x, r, c = [int(a) for a in stdin.next().strip().split()]
ans = 'RICHARD' if solve(x, r, c) == 'W' else 'GABRIEL'
print 'Case #%d:' % case, ans
print >> stderr, 'Case #%d:' % case, ans
from sys import stdin, stdout
from collections import deque
n,m = map(int, stdin.next().split(' '))
edges = ' '.join([ stdin.next()[:-1] for _ in xrange(m) ]).split(' ')
_edges = [ (edges[i], edges[i+1]) for i in xrange(0,2*m,2) ]
q = int(stdin.next().strip())
indexes = deque(map(int,stdin.next().split(' ')))
forbidden = set(indexes)
parent = {str(i): str(i) for i in xrange(n+1) }
rank = {str(i): 0 for i in xrange(n+1) }
def find(u):
if parent[u] != u:
parent[u] = find(parent[u])
return parent[u]
def union(u,v):
ru,rv = find(u), find(v)
if ru != rv:
if rank[ru] < rank[rv]:
parent[ru] = rv
elif rank[ru] > rank[rv]:
parent[rv] = ru
else:
parent[rv] = ru
rank[ru] += 1
return ru != rv
count = n
randomNumber = random.randint(2, number)-1
if ( pow(randomNumber, number-1, number) != 1 ):
return False
return True
else:
''' case number == 1 '''
return False
def isValid(A):
for number in A:
if isPrime(number):
return False
return True
# A = [55, 337, 1301, 3781, 9115, 19265, 36937, 65701, 110111]
# B = [51, 328, 1285, 3756, 9079, 19216, 36873, 65620, 110011]
for _t in range(1,int(stdin.next().strip())+1):
N,J = (int(x) for x in stdin.next().split())
# print N,J
coins = []
#N = 4
for i in xrange(pow(2,N-1),pow(2,N)):
temp = bin(i)[2:]
if temp.endswith('1'):
coins.append(temp)
final = [];index = 0
while len(final) < J:
# for i in range(10):
values = []
for base in xrange(2,11):
values.append(int(coins[index],base))
if isValid(values):
# @EXPECTED_RESULTS@: CORRECT
from sys import stdin
# Read
n = int(stdin.next().strip())
m = int(stdin.next().strip())
p1stack = []
p2stack = []
p1bet = []
p2bet = []
p1card = None
p2card = None
if n:
line = stdin.next()
[p1stack.append(int(x)) for x in line.strip().split()]
if m:
line = stdin.next()
[p2stack.append(int(x)) for x in line.strip().split()]
iter = 0
while len(p1stack) and len(p2stack):
p1card = p1stack[0]
p1stack = p1stack[1:]
p2card = p2stack[0]
p2stack = p2stack[1:]
if p1card == p2card:
from __future__ import division
from sys import stdin
from collections import defaultdict
def lcs(s1, s2):
prev = defaultdict(int)
for i in range(len(s1)):
cur = defaultdict(int)
for j in range(len(s2)):
cur[j] = 1 + prev[j-1] if s1[i] == s2[j] else max(cur[j - 1], prev[j])
prev = cur
return prev[len(s2)-1]
s, t = stdin.next().strip(), stdin.next().strip()
print lcs(s, t)
def read_parameters(self): line = stdin.next(); par = line.split(); self.M = int(par[0]); self.N = int(par[1]); self.I = int(par[2]);
# @EXPECTED_RESULTS@: CORRECT
from sys import stdin
from heapq import heapify, heappush, heappop
n, d = map(int, stdin.next().split())
q, q2 = [], []
if n:
q = map(int, stdin.next().split())
heapify(q)
if d:
q2 = [map(int, line.split()) for line in stdin]
heapify(q2)
num_ministers = 0
day = 0
while q or q2:
if not q:
day = q2[0][0]
while q2 and day >= q2[0][0]:
heappush(q, sum(heappop(q2)))
continue
resigned = False
if heappop(q)-1 < day:
resigned = True
from sys import stdin for _t in xrange(1,int(stdin.next())+1): N = int(stdin.next()) if N == 0: out = "INSOMNIA" else: out = 0 digits = [] temp_N = N while temp_N > 0: digit = temp_N % 10 if digit not in digits: out += 1 digits.append(digit) temp_N /= 10 # print digits,N,out i = 2 while len(digits) < 10: out = next_N = N*i while next_N > 0: digit = next_N % 10 if digit not in digits: digits.append(digit) next_N /= 10 i += 1 next_N *= i print "Case #"+str(_t)+":",out
#python
from sys import stdin
from fractions import gcd
import math
f = open('large.out','w')
T = int(stdin.next())
def is2power(a):
if a < 2: return 0
if (a & a - 1) == 0:
return 1
else:
return 0
def log2(x):
x = float(x)
temp = math.log(x)/math.log(2)
return int(temp)
for case in xrange(1,T+1):
print 'Case #%d: ' %case,
print >> f, 'Case #%d: ' %case,
p, q = map(int,stdin.next().split('/'))
com = gcd(p,q)
p, q = p/com, q/com
if not is2power(q):
print 'Impossible'
print>>f, 'Impossible'
continue
else:
#x will change for each y, Vertical if(countPiecesInRow(grid,piece,0,i,1,0,n) >= k): return True #Upper TOP RIGHT -> BOTTOM LEFT if(countPiecesInRow(grid,piece,0,i,1,-1,n) >= k): return True # if(countPiecesInRow(grid,piece,i,n-1,1,-1,n) >= k): return True if(countPiecesInRow(grid, piece, i, 0, 1, 1, n) >= k): return True if(countPiecesInRow(grid, piece, 0, i, 1, 1, n) >= k): return True return False T = int(stdin.next()) for i in range(1,T+1): n,k = tuple([int(x) for x in stdin.next().split()]) grid=[] for j in range(n): grid.append(MutableString(stdin.next().strip())) grid=gravityToRight(grid,n) redHasWon = isWinning(grid,n,k,RED) blueHasWon = isWinning(grid,n,k,BLUE) if(redHasWon and blueHasWon): result="Both" elif(redHasWon):
def main():
s, t = stdin.next().strip(), stdin.next().strip()
print lcs(s, t)
from sys import stdin for _t in range(1,int(stdin.next().strip())+1): inp = [x for x in stdin.next().split()] print "Case #"+str(_t)+":", for word in inp[::-1]: print word, print
from sys import stdin
import numpy as np
f = open('large.out', 'w')
T = int(stdin.next())
for i in xrange(1, T + 1):
(mShy, ltShy) = stdin.next().split()
mShy = int(mShy)
ltShy = map(int, list(ltShy))
nPerson = []
result = 0
for j in xrange(mShy + 1):
nPerson.append(sum(ltShy[:j]))
for k in xrange(mShy + 1):
needperson = k - nPerson[k]
if needperson <= 0:
continue
else:
result += needperson
for l in xrange(k + 1, mShy + 1):
nPerson[l] += needperson
print 'Case #%d:' % i, result
print >> f, 'Case #%d:' % i, result
# @EXPECTED_RESULTS@: CORRECT from sys import stdin stdin.next() j = int(stdin.next(), 2) g = int(stdin.next(), 2) print bin((j + g)/2)[2:]
# !/usr/bin/env python
from sys import stdin
T = int(stdin.next().strip())
fout = open('output.out','w')
for i in xrange(T):
row1 = int(stdin.next().strip())
sq1 = []
for j in xrange(4):
temp = stdin.next().strip().split()
sq1.append(temp)
row2 = int(stdin.next().strip())
sq2 = []
for j in xrange(4):
temp = stdin.next().strip().split()
sq2.append(temp)
match=[x for x in sq1[row1-1] if x in sq2[row2-1]]
if len(match)==1:
out = int(match[0])
elif len(match)>1:
out = 'Bad magician!'
elif len(match)==0:
out = 'Volunteer cheated!'
print>>fout,'Case #%d: %s' %(i+1,out)
print 'Case #%d: %s' %(i+1,out)
win = True
winner = ''
for item in range(0,4):
if array[item] == notation['empty']:
win = False
elif array[0] == array[item] or array[item] == notation['friend']:
if not winner and ( not array[item] == notation['empty'] ):
winner = array[item]
pass
else:
win = False
return {'winner': winner, 'win': win}
test_cases = int(stdin.next().strip())
for test_case in xrange(1, test_cases+1):
tic_tac = np.array(np.arange(16).reshape(4,4), dtype=object)
for i in range(0,4):
string = stdin.next().split()[0]
tic_tac[i] = [char for char in string]
result = check_for_win(tic_tac)
if result['win']:
print "Case #%d: %s won" % (test_case, result['winner'])
elif check_for_empty(tic_tac):
print "Case #%d: Game has not completed" % test_case
else:
print "Case #%d: Draw" % test_case
try:
stdin.next()
except StopIteration:
from math import sqrt, ceil, floor
def is_palindrome(number):
if len(str(number)) < 2:
return True
reversed = int(str(number)[::-1])
if reversed == number:
return True
return False
f = open('C-small-attempt0.txt','w')
stdin = open('C-small-attempt0.in', 'r')
T = int(stdin.next().strip())
for t in xrange(1,T+1):
A, B = map(int, stdin.next().split())
sqrt_A = int(ceil(sqrt(A)))
sqrt_B = int(floor(sqrt(B)))
counter = 0
for i in range(sqrt_A, sqrt_B+1):
if is_palindrome(i):
if is_palindrome(i**2):
counter += 1
#print 'Case #%d: %s' % (t, counter)
# @EXPECTED_RESULTS@: CORRECT
from sys import stdin
N, M = map(int, stdin.next().split())
raw_grid = ''.join(stdin).replace('\n', '')
# find start and goal
start_idx = raw_grid.index('S')
start = (start_idx / N, start_idx % N)
goal_idx = raw_grid.index('G')
goal = (goal_idx / N, goal_idx % N)
# find open intersections
opened = [[c != 'X' for c in raw_grid[i:i+N]] for i in xrange(0, M*N, N)]
def get_neighbors(p):
global M, N
for dp in ((-1, 0), (1, 0), (0, -1), (0, 1)):
np = (p[0] + dp[0], p[1] + dp[1])
if np[0] < 0 or np[0] >= M or np[1] < 0 or np[1] >= N:
continue
yield np
def bfs(start, goal):
global opened, M, N
dist = [[-1]*N for i in xrange(M)]
from sys import stdin
def solution(cakes):
if len(cakes) == 0:
return 0
elif len(cakes) == 1:
if cakes[0] == '-':
return 1
else:
return 0
if '-' not in cakes:
return 0
for _t in range(1,int(stdin.next().strip())+1):
cakes = list(stdin.next().strip())
cakes.reverse()
while cakes and cakes[0] == '+':
cakes.remove('+')
cakes.reverse()
print len(cakes),cakes,solution(cakes)
#print solution(cakes)
#print "Case #"+str(_t)+":",
def main():
s, t = stdin.next().strip(), stdin.next().strip()
print lcs(s, t)
#!/usr/bin/env python
# External libraries (standard in Python >= 2.4, at least)
from sys import stdin
from re import split, sub
# Skip the first two lines (headers)
stdin.next()
stdin.next()
print "<MuonAlignment>"
print ""
for line in stdin:
line = sub("[ \t\n]+$", "", line)
Alignable, struct1, struct2, struct3, struct4, struct5, \
relativeto, x, y, z, angletype, angle1, angle2, angle3, \
xx, xy, xz, yy, yz, zz = split("[ \t]*,[ \t]", line)
print "<operation>"
if Alignable[0:2] == "DT":
print (" <%s " % Alignable),
if struct1 != "":
print ("wheel=\"%s\" " % struct1),
if struct2 != "":
print ("station=\"%s\" " % struct2),
if struct3 != "":
print ("sector=\"%s\" " % struct3),
if struct4 != "":
print ("superlayer=\"%s\" " % struct4),
if struct5 != "":
# @EXPECTED_RESULTS@: CORRECT
from datetime import date
from sys import stdin
start, end = [date(*map(int, s.split()[::-1])) for s in stdin.next().split(' - ')]
def is_good_year(year):
try:
return date(year, 2, 29).isoweekday() in (5, 6)
except ValueError:
return False
print (start < date(start.year, 3, 1) and is_good_year(start.year)) + \
sum(map(is_good_year, xrange(start.year+1, end.year))) + \
(end > date(end.year, 2, 28) and is_good_year(end.year))
from sys import stdin
m = int(stdin.next())
edge = [[f > 0 for f in map(int, line.split())] for line in stdin]
for i in xrange(m):
for j in xrange(m):
edge[i][j] = edge[i][j] or edge[j][i]
edges = []
for i in xrange(m):
for j in xrange(i+1, m):
if edge[i][j]:
edges.append('%d %d' % (i+1, j+1))
print m, 0, 0, len(edges)
print '\n'.join(edges)
# @EXPECTED_RESULTS@: CORRECT from sys import stdin; #Let f(R,C) be optimal nb. of divisions. # #Suppose f(R,C) = R*C-1. This holds for R=C=1. #Suppose then that f(R+1, C) < (R+1)*C-1. Then #f(R,C) < f(R+1, C)-C= R*C-1. Contradiction. line = stdin.next(); line = line.split(); R = int(line[0]); C = int(line[1]); ans = R*C-1; print(ans);
# -*- coding: utf-8 -*-
"""
Created on Sat Feb 15 18:33:33 2014
@author: Caasar
"""
from sys import stdin
import numpy as np
T = int(stdin.next())
for t in xrange(T):
row1 = int(stdin.next()) - 1
conf1 = []
for line in stdin:
conf1.append(np.fromstring(line, sep=" "))
if len(conf1) == 4:
conf1 = np.array(conf1, np.int) - 1
break
row2 = int(stdin.next()) - 1
conf2 = []
for line in stdin:
conf2.append(np.fromstring(line, sep=" "))
if len(conf2) == 4:
conf2 = np.array(conf2, np.int) - 1
break
mask1 = np.zeros(16, np.bool)
mask1[conf1[row1]] = True
mask2 = np.zeros(16, np.bool)
from sys import stdin T = int(stdin.next()) for _t in xrange(1,T+1): num_red=0 num_blue=0 answer=0 N,K,B,T=tuple([int(x) for x in stdin.next().strip().split()]) X=[int(x) for x in stdin.next().strip().split()] V=[int(x) for x in stdin.next().strip().split()] for i in range(N): if num_red == K: break if ((X[i]+ T*V[i]) < B): num_blue+=1 else: num_red+=1 answer+=num_blue if num_red >= K: print answer else: print "IMPOSSIBLE"
#python
from sys import stdin
f = open('test.out', 'w')
T = int(stdin.next())
for i in xrange(T):
a, b, k = map(int, stdin.next().split())
count = 0
for j1 in xrange(a):
for j2 in xrange(b):
if j1 & j2 < k:
count += 1
print count
print >> f, 'Case #%d: %d' % (i + 1, count)
from sys import stdin
fout = open('outS.out', 'w')
def cost(c, f, x, n):
farmCost = 0
rate = 2.0
if n == 0:
return x / 2
for i in xrange(int(n)):
farmCost += c / rate
rate += f
return farmCost + x / rate
T = int(stdin.next().strip())
for i in xrange(T):
(C, F, X) = map(float, stdin.next().strip().split())
n = 0
while 1:
if cost(C, F, X, n) > cost(C, F, X, n + 1):
n += 1
else:
out = cost(C, F, X, n)
break
print >> fout, 'Case #%d: %.6f' % (i + 1, out)
print 'Case #%d: %.7f' % (i + 1, out)
from sys import stdin
import numpy as np
f = open('B-small-attempt0.txt', 'w')
stdin = open('B-small-attempt0.in', 'r')
T = int(stdin.next().strip())
for t in xrange(1, T + 1):
N, M = map(int, stdin.next().split())
pattern = np.array([map(int, stdin.next().split()) for i in xrange(N)])
lawn = np.empty([N, M])
for i in range(N):
lawn[i, :] = np.max(pattern[i, :])
for j in range(M):
if not (lawn[:, j] == pattern[:, j]).all():
lawn[:, j] = np.max(pattern[:, j])
result = 'NO'
if (lawn == pattern).all():
result = 'YES'
#print 'Case #%d: %s' % (t, result)
f.write("""Case #"""), f.write(str(t)), f.write(": "), f.write(
str(result)), f.write("\n")
f.close()
def is_perfect_square(apositiveint):
if apositiveint == 1:
return True
x = apositiveint // 2
seen = set([x])
while x * x != apositiveint:
x = (x + (apositiveint // x)) // 2
if x in seen: return False
seen.add(x)
return True
def count_fair_and_squre(start, end):
count = 0
for number in np.arange(start, end+1):
print "checking "+str(number)
if is_palindrome(number):
if is_perfect_square(number):
if is_palindrome(int(math.sqrt(number))):
count += 1
return count
test_cases = int(stdin.next().strip())
for test_case in xrange(1, test_cases+1):
start, end = map(int, stdin.next().split())
print "Case #%d: %d" % (test_case, count_fair_and_squre(start, end))
# -*- coding: utf-8 -*-
"""
Created on Sat Feb 15 18:33:33 2014
@author: Caasar
"""
from sys import stdin
import numpy as np
T = int(stdin.next())
for t, line in enumerate(stdin, 1):
C, F, X = np.fromstring(line, sep=" ")
n_opt = int(np.floor((F * X - C * (2 + F)) / (F * C)))
if n_opt < 0:
min_time = X / 2.0
else:
part = np.sum(C / (2.0 + F * np.arange(n_opt)))
min_time1 = part + X / (2.0 + n_opt * F)
min_time2 = part + C / (2.0 + n_opt * F) + X / (2.0 + (n_opt + 1) * F)
min_time = np.minimum(min_time1, min_time2)
print 'Case #%d: %.7f' % (t, min_time)
from sys import stdin
for _t in range(1,int(stdin.next().strip())+1):
D = {'abc':'2','def':'3','ghi':'4','jkl':'5','mno':'6','pqrs':'7','tuv':'8','wxyz':'9'}
D1 = {' ':'0'}
for (i,j) in D.items():
for (k,l) in enumerate(i):
D1[l] = (k+1) * j
line = stdin.next()[:-1]
out = D1[line[0]]
print "Case #"+str(_t)+":",
if len(line) > 1:
for char in line[1:]:
if out[-1] == D1[char][0]:
out += ' '
out += D1[char]
print out
# @EXPECTED_RESULTS@: CORRECT from sys import stdin stdin.next() j = stdin.next().strip() g = stdin.next().strip() print g[:-len(j)] + j[:-1]
