s_id stringlengths 10 10 | p_id stringlengths 6 6 | u_id stringlengths 10 10 | date stringlengths 10 10 | language stringclasses 1
value | original_language stringclasses 11
values | filename_ext stringclasses 1
value | status stringclasses 1
value | cpu_time stringlengths 1 5 | memory stringlengths 1 7 | code_size stringlengths 1 6 | code stringlengths 1 539k |
|---|---|---|---|---|---|---|---|---|---|---|---|
s933634297 | p00884 | u633068244 | 1399617522 | Python | Python | py | Runtime Error | 0 | 0 | 425 | while 1:
n = input()
if n == 0: break
ans = {}
for i in range(n):
group,name = raw_input().split(":")
if i == 0: first = group
ans[group] = set(name[:-1].split(","))
while 1:
for key in ans:
flag = 0
for key1 in ans:
if key in ans[key1]:
ans[key1] |= ans[key]
ans[key1].discard(key)
flag = 1
if flag:
del ans[key]
break
if flag == 0: break
print len(ans[first]) |
s490519104 | p00894 | u633068244 | 1424619584 | Python | Python | py | Runtime Error | 0 | 0 | 572 | while 1:
n = int(raw_input())
if n == 0: break
exist = set([])
enter = [0]*1000
bless = [0]*1000
for loop in xrange(n):
md,hm,io,p = raw_input().split()
h,m = map(int,hm.split(":"))
t = 60*h+m
p = int(p)
if io == "I":
time[p] = t
exist.add(p)
else:
exist.remove(p)
if p == 0:
for i in exist: bless[i] += t-max(enter[p],enter[i])
elif 0 in exist:
bless[p] += t-max(enter[0],enter[p])
print max(bless)
|
s462455219 | p00894 | u260980560 | 1482842703 | Python | Python | py | Runtime Error | 0 | 0 | 731 | while 1:
n = input()
if n == 0:
break
status = {}
god_st = 0
res = {}
for i in xrange(n):
s = raw_input().split()
#M, D = map(int, s[0].split("/"))
h, m = map(int, s[1].split(":"))
mi = 60*h + m
st = s[2] == 'I'
ID = s[3]
if ID == '000':
# goddness
if st == 1:
god_st = mi
else:
for k in status:
if k != ID and status[k] != -1:
res[k] = res.get(k, 0) + (mi - max(god_st, status[k]))
else:
if st == 1:
status[ID] = mi
else:
status[ID] = -1
print max(res.values()) |
s930765000 | p00895 | u629779621 | 1529955204 | Python | Python3 | py | Runtime Error | 0 | 0 | 2587 |
def gcd_recursive(a, b):
if b == 0:
return a
else:
return gcd_recursive(b, a % b)
def modulo(x, base):
return (x % base + base) % base
class Donut:
def __init__(self, letters):
self.letters = letters
self.lengths = [len(letters), len(letters[0])]
max_diag = self.lengths[0] * self.lengths[1]
max_i = self.lengths[0]
max_j = self.lengths[1]
self.directions = [
[-1, -1, max_diag],
[-1, 0, max_i],
[-1, 1, max_diag],
[0, -1, max_j],
[0, 1, max_j],
[1, -1, max_diag],
[1, 0, max_i],
[1, 1, max_diag]]
def get_letter(self, start, dist):
mi = modulo(start[0] + start[2][0]*dist, self.lengths[0])
mj = modulo(start[1] + start[2][1]*dist, self.lengths[1])
return self.letters[mi][mj]
def compute(rows):
print('computing', rows)
donut = Donut(rows)
longest_spell = ''
for i in range(0, donut.lengths[0]):
for j in range(0, donut.lengths[1]):
for direction in donut.directions:
length = 0
spell = ''
duplicates = [[a, b, d]
for a in range(donut.lengths[0])
for b in range(donut.lengths[1])
for d in donut.directions]
while True:
letter = donut.get_letter([i, j, direction], length)
remaining_duplicates = []
for duplicate in duplicates:
a = duplicate[0]
b = duplicate[1]
d = duplicate[2]
if donut.get_letter(duplicate, length) == letter:
remaining_duplicates.append(duplicate)
if len(remaining_duplicates) > 1:
length += 1
spell += letter
duplicates = remaining_duplicates
else:
break
if length >= direction[2]:
break
if len(spell) > len(longest_spell):
longest_spell = spell
return longest_spell
if __name__ == '__main__':
while True:
inp_size = input().split()
num_rows = int(inp_size[0])
if num_rows == 0:
break;
rows = []
for i in range(int(num_rows)):
rows.append(input())
print(compute(rows))
|
s548258430 | p00895 | u629779621 | 1529955284 | Python | Python3 | py | Runtime Error | 0 | 0 | 2558 |
def gcd_recursive(a, b):
if b == 0:
return a
else:
return gcd_recursive(b, a % b)
def modulo(x, base):
return (x % base + base) % base
class Donut:
def __init__(self, letters):
self.letters = letters
self.lengths = [len(letters), len(letters[0])]
max_diag = self.lengths[0] * self.lengths[1]
max_i = self.lengths[0]
max_j = self.lengths[1]
self.directions = [
[-1, -1, max_diag],
[-1, 0, max_i],
[-1, 1, max_diag],
[0, -1, max_j],
[0, 1, max_j],
[1, -1, max_diag],
[1, 0, max_i],
[1, 1, max_diag]]
def get_letter(self, start, dist):
mi = modulo(start[0] + start[2][0]*dist, self.lengths[0])
mj = modulo(start[1] + start[2][1]*dist, self.lengths[1])
return self.letters[mi][mj]
def compute(rows):
donut = Donut(rows)
longest_spell = ''
for i in range(0, donut.lengths[0]):
for j in range(0, donut.lengths[1]):
for direction in donut.directions:
length = 0
spell = ''
duplicates = [[a, b, d]
for a in range(donut.lengths[0])
for b in range(donut.lengths[1])
for d in donut.directions]
while True:
letter = donut.get_letter([i, j, direction], length)
remaining_duplicates = []
for duplicate in duplicates:
a = duplicate[0]
b = duplicate[1]
d = duplicate[2]
if donut.get_letter(duplicate, length) == letter:
remaining_duplicates.append(duplicate)
if len(remaining_duplicates) > 1:
length += 1
spell += letter
duplicates = remaining_duplicates
else:
break
if length >= direction[2]:
break
if len(spell) > len(longest_spell):
longest_spell = spell
return longest_spell
if __name__ == '__main__':
while True:
inp_size = input().split()
num_rows = int(inp_size[0])
if num_rows == 0:
break;
rows = []
for i in range(int(num_rows)):
rows.append(input())
print(compute(rows))
|
s497116500 | p00895 | u629779621 | 1529955665 | Python | Python3 | py | Runtime Error | 0 | 0 | 2599 |
from sys import stdin
def gcd_recursive(a, b):
if b == 0:
return a
else:
return gcd_recursive(b, a % b)
def modulo(x, base):
return (x % base + base) % base
class Donut:
def __init__(self, letters):
self.letters = letters
self.lengths = [len(letters), len(letters[0])]
max_diag = self.lengths[0] * self.lengths[1]
max_i = self.lengths[0]
max_j = self.lengths[1]
self.directions = [
[-1, -1, max_diag],
[-1, 0, max_i],
[-1, 1, max_diag],
[0, -1, max_j],
[0, 1, max_j],
[1, -1, max_diag],
[1, 0, max_i],
[1, 1, max_diag]]
def get_letter(self, start, dist):
mi = modulo(start[0] + start[2][0]*dist, self.lengths[0])
mj = modulo(start[1] + start[2][1]*dist, self.lengths[1])
return self.letters[mi][mj]
def compute(rows):
donut = Donut(rows)
longest_spell = ''
for i in range(0, donut.lengths[0]):
for j in range(0, donut.lengths[1]):
for direction in donut.directions:
length = 0
spell = ''
duplicates = [[a, b, d]
for a in range(donut.lengths[0])
for b in range(donut.lengths[1])
for d in donut.directions]
while True:
letter = donut.get_letter([i, j, direction], length)
remaining_duplicates = []
for duplicate in duplicates:
a = duplicate[0]
b = duplicate[1]
d = duplicate[2]
if donut.get_letter(duplicate, length) == letter:
remaining_duplicates.append(duplicate)
if len(remaining_duplicates) > 1:
length += 1
spell += letter
duplicates = remaining_duplicates
else:
break
if length >= direction[2]:
break
if len(spell) > len(longest_spell):
longest_spell = spell
return longest_spell
if __name__ == '__main__':
while True:
inp_size = stdin.readline().split()
num_rows = int(inp_size[0])
if num_rows == 0:
break;
rows = []
for i in range(int(num_rows)):
rows.append(stdin.readline())
print(compute(rows))
|
s283017292 | p00895 | u629779621 | 1529955823 | Python | Python3 | py | Runtime Error | 0 | 0 | 2536 |
from sys import stdin
def gcd_recursive(a, b):
if b == 0:
return a
else:
return gcd_recursive(b, a % b)
def modulo(x, base):
return (x % base + base) % base
class Donut:
def __init__(self, letters):
self.letters = letters
self.lengths = [len(letters), len(letters[0])]
max_diag = self.lengths[0] * self.lengths[1]
max_i = self.lengths[0]
max_j = self.lengths[1]
self.directions = [
[-1, -1, max_diag],
[-1, 0, max_i],
[-1, 1, max_diag],
[0, -1, max_j],
[0, 1, max_j],
[1, -1, max_diag],
[1, 0, max_i],
[1, 1, max_diag]]
def get_letter(self, start, dist):
mi = modulo(start[0] + start[2][0]*dist, self.lengths[0])
mj = modulo(start[1] + start[2][1]*dist, self.lengths[1])
return self.letters[mi][mj]
def compute(rows):
donut = Donut(rows)
longest_spell = ''
for i in range(0, donut.lengths[0]):
for j in range(0, donut.lengths[1]):
for direction in donut.directions:
length = 0
spell = ''
duplicates = [[a, b, d]
for a in range(donut.lengths[0])
for b in range(donut.lengths[1])
for d in donut.directions]
while True:
letter = donut.get_letter([i, j, direction], length)
remaining_duplicates = []
for duplicate in duplicates:
a = duplicate[0]
b = duplicate[1]
d = duplicate[2]
if donut.get_letter(duplicate, length) == letter:
remaining_duplicates.append(duplicate)
if len(remaining_duplicates) > 1:
length += 1
spell += letter
duplicates = remaining_duplicates
else:
break
if length >= direction[2]:
break
if len(spell) > len(longest_spell):
longest_spell = spell
return longest_spell
while True:
inp_size = stdin.readline().split()
num_rows = int(inp_size[0])
if num_rows == 0:
break;
rows = []
for i in range(int(num_rows)):
rows.append(stdin.readline())
print(compute(rows))
|
s973340339 | p00895 | u629779621 | 1529956025 | Python | Python3 | py | Runtime Error | 0 | 0 | 2558 |
def gcd_recursive(a, b):
if b == 0:
return a
else:
return gcd_recursive(b, a % b)
def modulo(x, base):
return (x % base + base) % base
class Donut:
def __init__(self, letters):
self.letters = letters
self.lengths = [len(letters), len(letters[0])]
max_diag = self.lengths[0] * self.lengths[1]
max_i = self.lengths[0]
max_j = self.lengths[1]
self.directions = [
[-1, -1, max_diag],
[-1, 0, max_i],
[-1, 1, max_diag],
[0, -1, max_j],
[0, 1, max_j],
[1, -1, max_diag],
[1, 0, max_i],
[1, 1, max_diag]]
def get_letter(self, start, dist):
mi = modulo(start[0] + start[2][0]*dist, self.lengths[0])
mj = modulo(start[1] + start[2][1]*dist, self.lengths[1])
return self.letters[mi][mj]
def compute(rows):
donut = Donut(rows)
longest_spell = ''
for i in range(0, donut.lengths[0]):
for j in range(0, donut.lengths[1]):
for direction in donut.directions:
length = 0
spell = ''
duplicates = [[a, b, d]
for a in range(donut.lengths[0])
for b in range(donut.lengths[1])
for d in donut.directions]
while True:
letter = donut.get_letter([i, j, direction], length)
remaining_duplicates = []
for duplicate in duplicates:
a = duplicate[0]
b = duplicate[1]
d = duplicate[2]
if donut.get_letter(duplicate, length) == letter:
remaining_duplicates.append(duplicate)
if len(remaining_duplicates) > 1:
length += 1
spell += letter
duplicates = remaining_duplicates
else:
break
if length >= direction[2]:
break
if len(spell) > len(longest_spell):
longest_spell = spell
return longest_spell
if __name__ == '__main__':
while True:
inp_size = input().split()
num_rows = int(inp_size[0])
if num_rows == 0:
break;
rows = []
for i in range(int(num_rows)):
rows.append(input())
print(compute(rows))
|
s696798564 | p00895 | u629779621 | 1529956108 | Python | Python3 | py | Runtime Error | 0 | 0 | 2495 |
def gcd_recursive(a, b):
if b == 0:
return a
else:
return gcd_recursive(b, a % b)
def modulo(x, base):
return (x % base + base) % base
class Donut:
def __init__(self, letters):
self.letters = letters
self.lengths = [len(letters), len(letters[0])]
max_diag = self.lengths[0] * self.lengths[1]
max_i = self.lengths[0]
max_j = self.lengths[1]
self.directions = [
[-1, -1, max_diag],
[-1, 0, max_i],
[-1, 1, max_diag],
[0, -1, max_j],
[0, 1, max_j],
[1, -1, max_diag],
[1, 0, max_i],
[1, 1, max_diag]]
def get_letter(self, start, dist):
mi = modulo(start[0] + start[2][0]*dist, self.lengths[0])
mj = modulo(start[1] + start[2][1]*dist, self.lengths[1])
return self.letters[mi][mj]
def compute(rows):
donut = Donut(rows)
longest_spell = ''
for i in range(0, donut.lengths[0]):
for j in range(0, donut.lengths[1]):
for direction in donut.directions:
length = 0
spell = ''
duplicates = [[a, b, d]
for a in range(donut.lengths[0])
for b in range(donut.lengths[1])
for d in donut.directions]
while True:
letter = donut.get_letter([i, j, direction], length)
remaining_duplicates = []
for duplicate in duplicates:
a = duplicate[0]
b = duplicate[1]
d = duplicate[2]
if donut.get_letter(duplicate, length) == letter:
remaining_duplicates.append(duplicate)
if len(remaining_duplicates) > 1:
length += 1
spell += letter
duplicates = remaining_duplicates
else:
break
if length >= direction[2]:
break
if len(spell) > len(longest_spell):
longest_spell = spell
return longest_spell
while True:
inp_size = input().split()
num_rows = int(inp_size[0])
if num_rows == 0:
break;
rows = []
for i in range(int(num_rows)):
rows.append(input())
print(compute(rows))
|
s665688929 | p00895 | u629779621 | 1529957902 | Python | Python3 | py | Runtime Error | 0 | 0 | 3570 |
def gcd_recursive(a, b):
if b == 0:
return a
else:
return gcd_recursive(b, a % b)
def modulo(x, base):
return (x % base + base) % base
class Donut:
def __init__(self, letters):
self.letters = letters
self.lengths = [len(letters), len(letters[0])]
max_i = self.lengths[0]
max_j = self.lengths[1]
max_diag = self.lengths[0] * self.lengths[1] / gcd_recursive(max_i, max_j)
self.directions = [
[-1, -1, max_diag],
[-1, 0, max_i],
[-1, 1, max_diag],
[0, -1, max_j],
[0, 1, max_j],
[1, -1, max_diag],
[1, 0, max_i],
[1, 1, max_diag]]
def get_letter(self, start, dist):
mi = modulo(start[0] + start[2][0]*dist, self.lengths[0])
mj = modulo(start[1] + start[2][1]*dist, self.lengths[1])
return self.letters[mi][mj]
def compute(rows):
donut = Donut(rows)
longest = 0
longest_spell = ''
for i in range(0, donut.lengths[0]):
for j in range(0, donut.lengths[1]):
for direction in donut.directions:
length = 0
spell = ''
duplicates = [[a, b, d]
for a in range(donut.lengths[0])
for b in range(donut.lengths[1])
for d in donut.directions]
# ignore shorter spells
if direction[2] <= longest:
continue
while length < longest:
spell += donut.get_letter([i, j, direction], length)
length += 1
remaining_duplicates = []
for duplicate in duplicates:
a = duplicate[0]
b = duplicate[1]
d = duplicate[2]
match = True
for l in range(0, length):
if donut.get_letter(duplicate, l) != spell[l]:
match = False
break
if match:
remaining_duplicates.append(duplicate)
duplicates = remaining_duplicates
# extend spell as long as there is a match
while True:
letter = donut.get_letter([i, j, direction], length)
remaining_duplicates = []
for duplicate in duplicates:
a = duplicate[0]
b = duplicate[1]
d = duplicate[2]
if donut.get_letter(duplicate, length) == letter:
remaining_duplicates.append(duplicate)
if len(remaining_duplicates) > 1:
length += 1
spell += letter
duplicates = remaining_duplicates
if len(spell) > longest:
longest_spell = spell
longest = length
else:
break
if length >= direction[2]:
break
return longest_spell
while True:
inp_size = input().split()
num_rows = int(inp_size[0])
if num_rows == 0:
break;
rows = []
for i in range(int(num_rows)):
rows.append(input())
found_spell = compute(rows)
if len(found_spell) == 1:
print(0)
else:
print(found_spell)
|
s107621202 | p00895 | u629779621 | 1529961247 | Python | Python3 | py | Runtime Error | 0 | 0 | 3573 |
def gcd_recursive(a, b):
if b == 0:
return a
else:
return gcd_recursive(b, a % b)
def modulo(x, base):
return (x % base + base) % base
class Donut:
def __init__(self, letters):
self.letters = letters
self.lengths = [len(letters), len(letters[0])]
max_i = self.lengths[0]
max_j = self.lengths[1]
max_diag = self.lengths[0] * self.lengths[1] / gcd_recursive(max_i, max_j)
self.directions = [
[-1, -1, max_diag],
[-1, 0, max_i],
[-1, 1, max_diag],
[0, -1, max_j],
[0, 1, max_j],
[1, -1, max_diag],
[1, 0, max_i],
[1, 1, max_diag]]
def get_letter(self, start, dist):
mi = modulo(start[0] + start[2][0]*dist, self.lengths[0])
mj = modulo(start[1] + start[2][1]*dist, self.lengths[1])
return self.letters[mi][mj]
def compute(rows):
donut = Donut(rows)
longest = 0
longest_spell = ''
for i in range(0, donut.lengths[0]):
for j in range(0, donut.lengths[1]):
for direction in donut.directions:
length = 0
spell = ''
duplicates = [[a, b, d]
for a in range(donut.lengths[0])
for b in range(donut.lengths[1])
for d in donut.directions]
# ignore shorter spells
if direction[2] <= longest:
continue
while length < longest:
spell += donut.get_letter([i, j, direction], length)
length += 1
remaining_duplicates = []
for duplicate in duplicates:
a = duplicate[0]
b = duplicate[1]
d = duplicate[2]
match = True
for l in range(0, length):
if donut.get_letter(duplicate, l) != spell[l]:
match = False
break
if match:
remaining_duplicates.append(duplicate)
duplicates = remaining_duplicates
# extend spell as long as there is a match
while True:
letter = donut.get_letter([i, j, direction], length)
remaining_duplicates = []
for duplicate in duplicates:
a = duplicate[0]
b = duplicate[1]
d = duplicate[2]
if donut.get_letter(duplicate, length) == letter:
remaining_duplicates.append(duplicate)
if len(remaining_duplicates) > 1:
length += 1
spell += letter
duplicates = remaining_duplicates
if len(spell) > longest:
longest_spell = spell
longest = length
else:
break
if length >= direction[2]:
break
return longest_spell
while True:
inp_size = [input(), input()]
num_rows = int(inp_size[0])
if num_rows == 0:
break;
rows = []
for i in range(int(num_rows)):
rows.append(input())
found_spell = compute(rows)
if len(found_spell) == 1:
print(0)
else:
print(found_spell)
|
s467037642 | p00899 | u260980560 | 1507908789 | Python | Python3 | py | Runtime Error | 40000 | 30964 | 1138 | while 1:
n = int(input())
if n == 0:
break
S = [input() for i in range(n)]
dup = [0]*n
for i in range(n):
for j in range(i+1, n):
if S[i].find(S[j])+1:
dup[j] = 1
if S[j].find(S[i])+1:
dup[i] = 1
S = [S[i] for i in range(n) if not dup[i]]
n -= sum(dup)
P = [[0]*n for i in range(n)]
for i in range(n):
for j in range(n):
l = len(S[i])
pos = l
for k in range(l):
if S[j].startswith(S[i][k:]):
pos = k
break
P[i][j] = pos
dp = {(1 << i, i): 0 for i in range(n)}
for state in range(2**n-1):
for i in range(n):
if (state >> i) & 1 < 1:
continue
for j in range(n):
if (state >> j) & 1 < 1:
dp[state | (1 << j), j] = min(
dp.get((state | (1 << j), j), 10**18),
dp[state, i] + P[i][j]
)
print(min(dp[2**n-1, i] + len(S[i]) for i in range(n))) |
s891555390 | p00899 | u260980560 | 1507909804 | Python | Python3 | py | Runtime Error | 40000 | 37084 | 1305 | from heapq import heappush, heappop, heapify
while 1:
n = int(input())
if n == 0:
break
S = [input() for i in range(n)]
dup = [0]*n
for i in range(n):
for j in range(i+1, n):
if S[i].find(S[j])+1:
dup[j] = 1
if S[j].find(S[i])+1:
dup[i] = 1
S = [S[i] for i in range(n) if not dup[i]]
n -= sum(dup)
P = [[0]*n for i in range(n)]
for i in range(n):
for j in range(n):
l = len(S[i])
pos = l
for k in range(l):
if S[j].startswith(S[i][k:]):
pos = k
break
P[i][j] = len(S[j]) - (l - pos)
que = [(len(S[i]), 1 << i, i) for i in range(n)]
heapify(que)
ALL = 2**n-1
INF = 10**18
memo = {(1 << i, i): len(S[i]) for i in range(n)}
while que:
l, state, i = heappop(que)
if memo[state, i] < l:
continue
if state == ALL:
print(l)
break
for j in range(n):
if (state >> j) & 1 < 1:
key = (state | (1 << j), j)
if l + P[i][j] < memo.get(key, INF):
memo[key] = l + P[i][j]
heappush(que, (l + P[i][j], state | (1 << j), j)) |
s174941496 | p00899 | u260980560 | 1507912058 | Python | Python3 | py | Runtime Error | 40000 | 45968 | 1615 | while 1:
n = int(input())
if n == 0:
break
S = [input() for i in range(n)]
dup = [0]*n
for i in range(n):
si = S[i]
for j in range(i+1, n):
sj = S[j]
if si.find(sj)+1:
dup[j] = 1
if sj.find(si)+1:
dup[i] = 1
S = [S[i] for i in range(n) if not dup[i]]
n -= sum(dup)
P = [[0]*n for i in range(n)]
D = [[0]*n for i in range(n)]
for i in range(n):
si = S[i]
l = len(si)
for j in range(n):
sj = S[j]
pos = l
for k in range(l):
if sj.startswith(si[k:]):
pos = k
break
P[i][j] = len(sj) - (l - pos)
D[i][j] = l - pos
Q = [[] for i in range(300)]
for i in range(n):
Q[len(S[i])].append((1 << i, i, 0))
ALL = 2**n-1
up = sum(map(len, S))
border = up
memo = {(1 << i, i): len(S[i]) for i in range(n)}
l = 0
while l < border:
for state, i, d in Q[l]:
if memo[state, i] < l:
continue
for j in range(n):
if (state >> j) & 1 < 1:
ncost = l + P[i][j]
nstate = state | (1 << j)
if (nstate, j) not in memo or ncost < memo[nstate, j]:
border = min(border, up - d - D[i][j])
if ncost <= border:
memo[nstate, j] = ncost
Q[ncost].append((nstate, j, d+D[i][j]))
l += 1
print(border) |
s776493512 | p00899 | u467175809 | 1530176083 | Python | Python | py | Runtime Error | 0 | 0 | 1516 | #!/usr/bin/env python
from collections import deque
import itertools as it
import sys
sys.setrecursionlimit(1000000)
def hoge():
while True:
N = input()
if N == 0:
break
lst = []
for i in range(N):
S = raw_input()
flag = True
for SS in lst:
if S in SS:
flag = False
if flag:
lst.append(S)
N = len(lst)
cost = [[0 for i in range(N)] for j in range(N)]
for i in range(N):
for j in range(N):
if i == j:
cost[i][j] = 1e9
continue
sz1 = len(lst[i])
sz2 = len(lst[j])
D = min(sz1, sz2)
dist = sz2
for k in range(1, D + 1):
if lst[i][sz1 - k : sz1] == lst[j][0 : k]:
dist = sz2 - k
cost[i][j] = dist
DP = [[1e9 for i in range((2 ** N))] for j in range(N)]
for i in range(N):
DP[i][(2 ** i)] = len(lst[i])
for i in range(2 ** N):
for j in range(N):
if (i & (1 << j)) != 0:
for k in range(N):
DP[j][i] = min(DP[j][i], DP[k][i - (1 << j)] + cost[k][j])
ans = 1e9
for i in range(N):
#print DP[i][2 ** N - 1]
ans = min(ans, DP[i][2 ** N - 1])
print ans
hoge()
|
s752940283 | p00899 | u467175809 | 1530176495 | Python | Python | py | Runtime Error | 0 | 0 | 1696 | #!/usr/bin/env python
from collections import deque
import itertools as it
import sys
sys.setrecursionlimit(1000000)
def hoge():
while True:
N = input()
if N == 0:
break
lst_input = []
lst = []
for i in range(N):
S = raw_input()
lst_input.append(S)
for i in range(N):
flag = True
for j in range(N):
if i == j:
break
if lst_input[i] in lst_input[j]:
flag = False
if flag:
lst.append(lst_input[i])
N = len(lst)
cost = [[0 for i in range(N)] for j in range(N)]
for i in range(N):
for j in range(N):
if i == j:
cost[i][j] = 1e9
continue
sz1 = len(lst[i])
sz2 = len(lst[j])
D = min(sz1, sz2)
dist = sz2
for k in range(1, D + 1):
if lst[i][sz1 - k : sz1] == lst[j][0 : k]:
dist = sz2 - k
cost[i][j] = dist
DP = [[1e9 for i in range((2 ** N))] for j in range(N)]
for i in range(N):
DP[i][(2 ** i)] = len(lst[i])
for i in range(2 ** N):
for j in range(N):
if (i & (1 << j)) != 0:
for k in range(N):
DP[j][i] = min(DP[j][i], DP[k][i - (1 << j)] + cost[k][j])
ans = 1e9
for i in range(N):
#print DP[i][2 ** N - 1]
ans = min(ans, DP[i][2 ** N - 1])
print ans
hoge()
|
s105468905 | p00899 | u467175809 | 1530176777 | Python | Python | py | Runtime Error | 0 | 0 | 1690 | #!/usr/bin/env python
from collections import deque
import itertools as it
import sys
sys.setrecursionlimit(1000000)
def hoge():
while True:
N = input()
if N == 0:
break
lst_input = []
lst = []
for i in range(N):
S = raw_input()
lst_input.append(S)
for i in range(N):
flag = True
for j in range(N):
if i == j:
continue
if lst_input[i] in lst_input[j]:
flag = False
if flag:
lst.append(lst_input[i])
N = len(lst)
cost = [[0 for i in range(N)] for j in range(N)]
for i in range(N):
for j in range(N):
if i == j:
cost[i][j] = 1e9
continue
sz1 = len(lst[i])
sz2 = len(lst[j])
D = min(sz1, sz2)
dist = sz2
for k in range(1, D + 1):
if lst[i][sz1 - k : sz1] == lst[j][0 : k]:
dist = sz2 - k
cost[i][j] = dist
DP = [[1e9 for i in range((2 ** N))] for j in range(N)]
for i in range(N):
DP[i][(2 ** i)] = len(lst[i])
for i in range(2 ** N):
for j in range(N):
if (i & (1 << j)) != 0:
for k in range(N):
DP[j][i] = min(DP[j][i], DP[k][i - (1 << j)] + cost[k][j])
ans = 1e9
for i in range(N):
#print DP[i][2 ** N - 1]
ans = min(ans, DP[i][2 ** N - 1])
print ans
hoge()
|
s393013625 | p00899 | u467175809 | 1530176844 | Python | Python | py | Runtime Error | 0 | 0 | 1475 | #!/usr/bin/env python
from collections import deque
import itertools as it
import sys
sys.setrecursionlimit(1000000)
while True:
N = input()
if N == 0:
break
lst_input = []
lst = []
for i in range(N):
S = raw_input()
lst_input.append(S)
for i in range(N):
flag = True
for j in range(N):
if i == j:
continue
if lst_input[i] in lst_input[j]:
flag = False
if flag:
lst.append(lst_input[i])
N = len(lst)
cost = [[0 for i in range(N)] for j in range(N)]
for i in range(N):
for j in range(N):
if i == j:
cost[i][j] = 1e9
continue
sz1 = len(lst[i])
sz2 = len(lst[j])
D = min(sz1, sz2)
dist = sz2
for k in range(1, D + 1):
if lst[i][sz1 - k : sz1] == lst[j][0 : k]:
dist = sz2 - k
cost[i][j] = dist
DP = [[1e9 for i in range((2 ** N))] for j in range(N)]
for i in range(N):
DP[i][(2 ** i)] = len(lst[i])
for i in range(2 ** N):
for j in range(N):
if (i & (1 << j)) != 0:
for k in range(N):
DP[j][i] = min(DP[j][i], DP[k][i - (1 << j)] + cost[k][j])
ans = 1e9
for i in range(N):
#print DP[i][2 ** N - 1]
ans = min(ans, DP[i][2 ** N - 1])
print ans
|
s324289445 | p00899 | u467175809 | 1530177978 | Python | Python | py | Runtime Error | 0 | 0 | 1857 | #!/usr/bin/env python
from collections import deque
import itertools as it
import sys
sys.setrecursionlimit(1000000)
def hoge():
input_ = []
while True:
S = raw_input()
input_.append(S)
if S == '0':
break
input_ = list(reversed(input_))
while True:
N = int(input_.pop())
if N == 0:
break
lst_input = []
lst = []
for i in range(N):
S = input_.pop()
lst_input.append(S)
for i in range(N):
flag = True
for j in range(N):
if i == j:
continue
if lst_input[i] in lst_input[j]:
flag = False
if flag:
lst.append(lst_input[i])
N = len(lst)
cost = [[0 for i in range(N)] for j in range(N)]
for i in range(N):
for j in range(N):
if i == j:
cost[i][j] = 1e9
continue
sz1 = len(lst[i])
sz2 = len(lst[j])
D = min(sz1, sz2)
dist = sz2
for k in range(1, D + 1):
if lst[i][sz1 - k : sz1] == lst[j][0 : k]:
dist = sz2 - k
cost[i][j] = dist
DP = [[1e9 for i in range((2 ** N))] for j in range(N)]
for i in range(N):
DP[i][(2 ** i)] = len(lst[i])
for i in range(2 ** N):
for j in range(N):
if (i & (1 << j)) != 0:
for k in range(N):
DP[j][i] = min(DP[j][i], DP[k][i - (1 << j)] + cost[k][j])
ans = 1e9
for i in range(N):
#print DP[i][2 ** N - 1]
ans = min(ans, DP[i][2 ** N - 1])
print ans
hoge()
|
s355717785 | p00899 | u467175809 | 1530178161 | Python | Python | py | Runtime Error | 0 | 0 | 1863 | #!/usr/bin/env python
from collections import deque
import itertools as it
import sys
sys.setrecursionlimit(1000000)
def hoge():
input_ = []
while True:
S = raw_input()
input_.append(S)
if S == '0':
break
input_ = list(reversed(input_))
while True:
N = int(input_.pop())
if N == 0:
break
lst_input = []
lst = []
for i in range(N):
S = input_.pop()
lst_input.append(S)
for i in range(N):
flag = True
for j in range(N):
if i == j:
continue
if lst_input[i] in lst_input[j]:
flag = False
if flag:
lst.append(lst_input[i])
N = len(lst)
cost = [[0 for i in range(N)] for j in range(N)]
for i in range(N):
for j in range(N):
if i == j:
cost[i][j] = 1e9
continue
sz1 = len(lst[i])
sz2 = len(lst[j])
D = min(sz1, sz2)
dist = sz2
for k in range(1, D + 1):
if lst[i][sz1 - k : sz1] == lst[j][0 : k]:
dist = sz2 - k
cost[i][j] = dist
DP = [[1e9 for i in range((2 ** N))] for j in range(N)]
for i in range(N):
DP[i][(2 ** i)] = len(lst[i])
for i in range(2 ** N):
for j in range(N):
if (i & (1 << j)) != 0:
for k in range(N):
DP[j][i] = min(DP[j][i], DP[k][i - (1 << j)] + cost[k][j])
ans = 1e9
for i in range(N):
#print DP[i][2 ** N - 1]
ans = min(ans, DP[i][2 ** N - 1])
print ans
2 / 0
hoge()
|
s053746619 | p00899 | u467175809 | 1530178202 | Python | Python | py | Runtime Error | 0 | 0 | 1897 | #!/usr/bin/env python
from collections import deque
import itertools as it
import sys
sys.setrecursionlimit(1000000)
def hoge():
input_ = []
while True:
S = raw_input()
input_.append(S)
if S == '0':
break
input_ = list(reversed(input_))
while True:
N = int(input_.pop())
if N == 0:
break
lst_input = []
lst = []
for i in range(N):
S = input_.pop()
lst_input.append(S)
for i in range(N):
flag = True
for j in range(N):
if i == j:
continue
if lst_input[i] in lst_input[j]:
flag = False
if flag:
lst.append(lst_input[i])
N = len(lst)
cost = [[0 for i in range(N)] for j in range(N)]
for i in range(N):
for j in range(N):
if i == j:
cost[i][j] = 1e9
continue
sz1 = len(lst[i])
sz2 = len(lst[j])
D = min(sz1, sz2)
dist = sz2
for k in range(1, D + 1):
if lst[i][sz1 - k : sz1] == lst[j][0 : k]:
dist = sz2 - k
cost[i][j] = dist
DP = [[1e9 for i in range((2 ** N))] for j in range(N)]
for i in range(N):
DP[i][(2 ** i)] = len(lst[i])
for i in range(2 ** N):
for j in range(N):
if (i & (1 << j)) != 0:
for k in range(N):
DP[j][i] = min(DP[j][i], DP[k][i - (1 << j)] + cost[k][j])
ans = 1e9
for i in range(N):
#print DP[i][2 ** N - 1]
ans = min(ans, DP[i][2 ** N - 1])
print ans
if ans == 65:
2 / 0
hoge()
|
s994483678 | p00899 | u467175809 | 1530178216 | Python | Python | py | Runtime Error | 0 | 0 | 1857 | #!/usr/bin/env python
from collections import deque
import itertools as it
import sys
sys.setrecursionlimit(1000000)
def hoge():
input_ = []
while True:
S = raw_input()
input_.append(S)
if S == '0':
break
input_ = list(reversed(input_))
while True:
N = int(input_.pop())
if N == 0:
break
lst_input = []
lst = []
for i in range(N):
S = input_.pop()
lst_input.append(S)
for i in range(N):
flag = True
for j in range(N):
if i == j:
continue
if lst_input[i] in lst_input[j]:
flag = False
if flag:
lst.append(lst_input[i])
N = len(lst)
cost = [[0 for i in range(N)] for j in range(N)]
for i in range(N):
for j in range(N):
if i == j:
cost[i][j] = 1e9
continue
sz1 = len(lst[i])
sz2 = len(lst[j])
D = min(sz1, sz2)
dist = sz2
for k in range(1, D + 1):
if lst[i][sz1 - k : sz1] == lst[j][0 : k]:
dist = sz2 - k
cost[i][j] = dist
DP = [[1e9 for i in range((2 ** N))] for j in range(N)]
for i in range(N):
DP[i][(2 ** i)] = len(lst[i])
for i in range(2 ** N):
for j in range(N):
if (i & (1 << j)) != 0:
for k in range(N):
DP[j][i] = min(DP[j][i], DP[k][i - (1 << j)] + cost[k][j])
ans = 1e9
for i in range(N):
#print DP[i][2 ** N - 1]
ans = min(ans, DP[i][2 ** N - 1])
print ans
hoge()
|
s686073402 | p00899 | u467175809 | 1530178281 | Python | Python | py | Runtime Error | 0 | 0 | 1874 | #!/usr/bin/env python
from collections import deque
import itertools as it
import sys
sys.setrecursionlimit(1000000)
def hoge():
input_ = []
while True:
S = raw_input()
input_.append(S)
if S == '0':
break
input_ = list(reversed(input_))
while True:
N = int(input_.pop())
if N == 0:
break
lst_input = []
lst = []
for i in range(N):
S = input_.pop()
lst_input.append(S)
for i in range(N):
flag = True
for j in range(N):
if i == j:
continue
if lst_input[i] in lst_input[j]:
flag = False
if flag:
lst.append(lst_input[i])
N = len(lst)
cost = [[0 for i in range(N)] for j in range(N)]
for i in range(N):
for j in range(N):
if i == j:
cost[i][j] = 1e9
continue
sz1 = len(lst[i])
sz2 = len(lst[j])
D = min(sz1, sz2)
dist = sz2
for k in range(1, D + 1):
if lst[i][sz1 - k : sz1] == lst[j][0 : k]:
dist = sz2 - k
cost[i][j] = dist
DP = [[1e9 for i in range((2 ** N))] for j in range(N)]
for i in range(N):
DP[i][(2 ** i)] = len(lst[i])
for i in range(2 ** N):
for j in range(N):
if (i & (1 << j)) != 0:
for k in range(N):
DP[j][i] = min(DP[j][i], DP[k][i - (1 << j)] + cost[k][j])
ans = 1e9
for i in range(N):
#print DP[i][2 ** N - 1]
ans = min(ans, DP[i][2 ** N - 1])
print ans
return 0
a = hoge()
|
s184543481 | p00899 | u467175809 | 1530178373 | Python | Python | py | Runtime Error | 0 | 0 | 1928 | #!/usr/bin/env python
from collections import deque
import itertools as it
import sys
sys.setrecursionlimit(1000000)
def hoge():
input_ = []
while True:
S = raw_input()
input_.append(S)
if S == '0':
break
input_ = list(reversed(input_))
while True:
N = int(input_.pop())
if N == 0:
break
lst_input = []
lst = []
for i in range(N):
S = input_.pop()
lst_input.append(S)
for i in range(N):
flag = True
for j in range(N):
if i == j:
continue
if lst_input[i] in lst_input[j]:
flag = False
if flag:
lst.append(lst_input[i])
N = len(lst)
cost = [[0 for i in range(N)] for j in range(N)]
for i in range(N):
for j in range(N):
if i == j:
cost[i][j] = 1e9
continue
sz1 = len(lst[i])
sz2 = len(lst[j])
D = min(sz1, sz2)
dist = sz2
for k in range(1, D + 1):
if lst[i][sz1 - k : sz1] == lst[j][0 : k]:
dist = sz2 - k
cost[i][j] = dist
DP = [[1e9 for i in range((2 ** N))] for j in range(N)]
for i in range(N):
DP[i][(2 ** i)] = len(lst[i])
for i in range(2 ** N):
for j in range(N):
if (i & (1 << j)) != 0:
for k in range(N):
DP[j][i] = min(DP[j][i], DP[k][i - (1 << j)] + cost[k][j])
ans = 1e9
for i in range(N):
#print DP[i][2 ** N - 1]
ans = min(ans, DP[i][2 ** N - 1])
print ans
if ans == 77:
while True:
pass
a = hoge()
|
s819379037 | p00899 | u467175809 | 1530178436 | Python | Python | py | Runtime Error | 0 | 0 | 1928 | #!/usr/bin/env python
from collections import deque
import itertools as it
import sys
sys.setrecursionlimit(1000000)
def hoge():
input_ = []
while True:
S = raw_input()
input_.append(S)
if S == '0':
break
input_ = list(reversed(input_))
while True:
N = int(input_.pop())
if N == 0:
break
lst_input = []
lst = []
for i in range(N):
S = input_.pop()
lst_input.append(S)
for i in range(N):
flag = True
for j in range(N):
if i == j:
continue
if lst_input[i] in lst_input[j]:
flag = False
if flag:
lst.append(lst_input[i])
N = len(lst)
cost = [[0 for i in range(N)] for j in range(N)]
for i in range(N):
for j in range(N):
if i == j:
cost[i][j] = 1e9
continue
sz1 = len(lst[i])
sz2 = len(lst[j])
D = min(sz1, sz2)
dist = sz2
for k in range(1, D + 1):
if lst[i][sz1 - k : sz1] == lst[j][0 : k]:
dist = sz2 - k
cost[i][j] = dist
DP = [[1e9 for i in range((2 ** N))] for j in range(N)]
for i in range(N):
DP[i][(2 ** i)] = len(lst[i])
for i in range(2 ** N):
for j in range(N):
if (i & (1 << j)) != 0:
for k in range(N):
DP[j][i] = min(DP[j][i], DP[k][i - (1 << j)] + cost[k][j])
ans = 1e9
for i in range(N):
#print DP[i][2 ** N - 1]
ans = min(ans, DP[i][2 ** N - 1])
print ans
if ans == 89:
while True:
pass
a = hoge()
|
s811501697 | p00899 | u467175809 | 1530178535 | Python | Python | py | Runtime Error | 0 | 0 | 1928 | #!/usr/bin/env python
from collections import deque
import itertools as it
import sys
sys.setrecursionlimit(1000000)
def hoge():
input_ = []
while True:
S = raw_input()
input_.append(S)
if S == '0':
break
input_ = list(reversed(input_))
while True:
N = int(input_.pop())
if N == 0:
break
lst_input = []
lst = []
for i in range(N):
S = input_.pop()
lst_input.append(S)
for i in range(N):
flag = True
for j in range(N):
if i == j:
continue
if lst_input[i] in lst_input[j]:
flag = False
if flag:
lst.append(lst_input[i])
N = len(lst)
cost = [[0 for i in range(N)] for j in range(N)]
for i in range(N):
for j in range(N):
if i == j:
cost[i][j] = 1e9
continue
sz1 = len(lst[i])
sz2 = len(lst[j])
D = min(sz1, sz2)
dist = sz2
for k in range(1, D + 1):
if lst[i][sz1 - k : sz1] == lst[j][0 : k]:
dist = sz2 - k
cost[i][j] = dist
DP = [[1e9 for i in range((2 ** N))] for j in range(N)]
for i in range(N):
DP[i][(2 ** i)] = len(lst[i])
for i in range(2 ** N):
for j in range(N):
if (i & (1 << j)) != 0:
for k in range(N):
DP[j][i] = min(DP[j][i], DP[k][i - (1 << j)] + cost[k][j])
ans = 1e9
for i in range(N):
#print DP[i][2 ** N - 1]
ans = min(ans, DP[i][2 ** N - 1])
print ans
if ans == 16:
while True:
pass
a = hoge()
|
s992156172 | p00899 | u467175809 | 1530178613 | Python | Python | py | Runtime Error | 0 | 0 | 1890 | #!/usr/bin/env python
from collections import deque
import itertools as it
import sys
sys.setrecursionlimit(1000000)
def hoge():
input_ = []
while True:
S = raw_input()
input_.append(S)
if S == '0':
break
input_ = list(reversed(input_))
while True:
pass
while True:
N = int(input_.pop())
if N == 0:
break
lst_input = []
lst = []
for i in range(N):
S = input_.pop()
lst_input.append(S)
for i in range(N):
flag = True
for j in range(N):
if i == j:
continue
if lst_input[i] in lst_input[j]:
flag = False
if flag:
lst.append(lst_input[i])
N = len(lst)
cost = [[0 for i in range(N)] for j in range(N)]
for i in range(N):
for j in range(N):
if i == j:
cost[i][j] = 1e9
continue
sz1 = len(lst[i])
sz2 = len(lst[j])
D = min(sz1, sz2)
dist = sz2
for k in range(1, D + 1):
if lst[i][sz1 - k : sz1] == lst[j][0 : k]:
dist = sz2 - k
cost[i][j] = dist
DP = [[1e9 for i in range((2 ** N))] for j in range(N)]
for i in range(N):
DP[i][(2 ** i)] = len(lst[i])
for i in range(2 ** N):
for j in range(N):
if (i & (1 << j)) != 0:
for k in range(N):
DP[j][i] = min(DP[j][i], DP[k][i - (1 << j)] + cost[k][j])
ans = 1e9
for i in range(N):
#print DP[i][2 ** N - 1]
ans = min(ans, DP[i][2 ** N - 1])
print ans
a = hoge()
|
s977957748 | p00899 | u467175809 | 1530178674 | Python | Python | py | Runtime Error | 0 | 0 | 1890 | #!/usr/bin/env python
from collections import deque
import itertools as it
import sys
sys.setrecursionlimit(1000000)
def hoge():
input_ = []
while True:
S = raw_input()
input_.append(S)
if S == '0':
break
while True:
pass
input_ = list(reversed(input_))
while True:
N = int(input_.pop())
if N == 0:
break
lst_input = []
lst = []
for i in range(N):
S = input_.pop()
lst_input.append(S)
for i in range(N):
flag = True
for j in range(N):
if i == j:
continue
if lst_input[i] in lst_input[j]:
flag = False
if flag:
lst.append(lst_input[i])
N = len(lst)
cost = [[0 for i in range(N)] for j in range(N)]
for i in range(N):
for j in range(N):
if i == j:
cost[i][j] = 1e9
continue
sz1 = len(lst[i])
sz2 = len(lst[j])
D = min(sz1, sz2)
dist = sz2
for k in range(1, D + 1):
if lst[i][sz1 - k : sz1] == lst[j][0 : k]:
dist = sz2 - k
cost[i][j] = dist
DP = [[1e9 for i in range((2 ** N))] for j in range(N)]
for i in range(N):
DP[i][(2 ** i)] = len(lst[i])
for i in range(2 ** N):
for j in range(N):
if (i & (1 << j)) != 0:
for k in range(N):
DP[j][i] = min(DP[j][i], DP[k][i - (1 << j)] + cost[k][j])
ans = 1e9
for i in range(N):
#print DP[i][2 ** N - 1]
ans = min(ans, DP[i][2 ** N - 1])
print ans
a = hoge()
|
s051933231 | p00899 | u467175809 | 1530178737 | Python | Python | py | Runtime Error | 0 | 0 | 1916 | #!/usr/bin/env python
from collections import deque
import itertools as it
import sys
sys.setrecursionlimit(1000000)
def hoge():
input_ = []
while True:
S = raw_input()
input_.append(S)
if S == '0':
break
a = 0
for i in range(2 ** 100):
a += i
input_ = list(reversed(input_))
while True:
N = int(input_.pop())
if N == 0:
break
lst_input = []
lst = []
for i in range(N):
S = input_.pop()
lst_input.append(S)
for i in range(N):
flag = True
for j in range(N):
if i == j:
continue
if lst_input[i] in lst_input[j]:
flag = False
if flag:
lst.append(lst_input[i])
N = len(lst)
cost = [[0 for i in range(N)] for j in range(N)]
for i in range(N):
for j in range(N):
if i == j:
cost[i][j] = 1e9
continue
sz1 = len(lst[i])
sz2 = len(lst[j])
D = min(sz1, sz2)
dist = sz2
for k in range(1, D + 1):
if lst[i][sz1 - k : sz1] == lst[j][0 : k]:
dist = sz2 - k
cost[i][j] = dist
DP = [[1e9 for i in range((2 ** N))] for j in range(N)]
for i in range(N):
DP[i][(2 ** i)] = len(lst[i])
for i in range(2 ** N):
for j in range(N):
if (i & (1 << j)) != 0:
for k in range(N):
DP[j][i] = min(DP[j][i], DP[k][i - (1 << j)] + cost[k][j])
ans = 1e9
for i in range(N):
#print DP[i][2 ** N - 1]
ans = min(ans, DP[i][2 ** N - 1])
print ans
a = hoge()
|
s730805989 | p00899 | u467175809 | 1530178784 | Python | Python | py | Runtime Error | 0 | 0 | 1902 | #!/usr/bin/env python
from collections import deque
import itertools as it
import sys
sys.setrecursionlimit(1000000)
def hoge():
input_ = []
while True:
S = raw_input()
input_.append(S)
if S == '0':
break
a = 0
while True:
a += 1
input_ = list(reversed(input_))
while True:
N = int(input_.pop())
if N == 0:
break
lst_input = []
lst = []
for i in range(N):
S = input_.pop()
lst_input.append(S)
for i in range(N):
flag = True
for j in range(N):
if i == j:
continue
if lst_input[i] in lst_input[j]:
flag = False
if flag:
lst.append(lst_input[i])
N = len(lst)
cost = [[0 for i in range(N)] for j in range(N)]
for i in range(N):
for j in range(N):
if i == j:
cost[i][j] = 1e9
continue
sz1 = len(lst[i])
sz2 = len(lst[j])
D = min(sz1, sz2)
dist = sz2
for k in range(1, D + 1):
if lst[i][sz1 - k : sz1] == lst[j][0 : k]:
dist = sz2 - k
cost[i][j] = dist
DP = [[1e9 for i in range((2 ** N))] for j in range(N)]
for i in range(N):
DP[i][(2 ** i)] = len(lst[i])
for i in range(2 ** N):
for j in range(N):
if (i & (1 << j)) != 0:
for k in range(N):
DP[j][i] = min(DP[j][i], DP[k][i - (1 << j)] + cost[k][j])
ans = 1e9
for i in range(N):
#print DP[i][2 ** N - 1]
ans = min(ans, DP[i][2 ** N - 1])
print ans
a = hoge()
|
s972655483 | p00899 | u467175809 | 1530178981 | Python | Python | py | Runtime Error | 0 | 0 | 1956 | #!/usr/bin/env python
from collections import deque
import itertools as it
import sys
sys.setrecursionlimit(1000000)
DP = [[1e9 for i in range((2 ** N))] for j in range(N)]
def hoge():
input_ = []
while True:
S = raw_input()
input_.append(S)
if S == '0':
break
input_ = list(reversed(input_))
while True:
N = int(input_.pop())
if N == 0:
break
lst_input = []
lst = []
for i in range(N):
S = input_.pop()
lst_input.append(S)
for i in range(N):
flag = True
for j in range(N):
if i == j:
continue
if lst_input[i] in lst_input[j]:
flag = False
if flag:
lst.append(lst_input[i])
N = len(lst)
cost = [[0 for i in range(N)] for j in range(N)]
for i in range(N):
for j in range(N):
if i == j:
cost[i][j] = 1e9
continue
sz1 = len(lst[i])
sz2 = len(lst[j])
D = min(sz1, sz2)
dist = sz2
for k in range(1, D + 1):
if lst[i][sz1 - k : sz1] == lst[j][0 : k]:
dist = sz2 - k
cost[i][j] = dist
for i in range(2 ** N):
for j in range(N):
DP[j][i] = 1e9
for i in range(N):
DP[i][(2 ** i)] = len(lst[i])
for i in range(2 ** N):
for j in range(N):
if (i & (1 << j)) != 0:
for k in range(N):
DP[j][i] = min(DP[j][i], DP[k][i - (1 << j)] + cost[k][j])
ans = 1e9
for i in range(N):
#print DP[i][2 ** N - 1]
ans = min(ans, DP[i][2 ** N - 1])
print ans
a = hoge()
|
s690757765 | p00899 | u467175809 | 1530179020 | Python | Python | py | Runtime Error | 0 | 0 | 1958 | #!/usr/bin/env python
from collections import deque
import itertools as it
import sys
sys.setrecursionlimit(1000000)
DP = [[1e9 for i in range((2 ** 14))] for j in range(14)]
def hoge():
input_ = []
while True:
S = raw_input()
input_.append(S)
if S == '0':
break
input_ = list(reversed(input_))
while True:
N = int(input_.pop())
if N == 0:
break
lst_input = []
lst = []
for i in range(N):
S = input_.pop()
lst_input.append(S)
for i in range(N):
flag = True
for j in range(N):
if i == j:
continue
if lst_input[i] in lst_input[j]:
flag = False
if flag:
lst.append(lst_input[i])
N = len(lst)
cost = [[0 for i in range(N)] for j in range(N)]
for i in range(N):
for j in range(N):
if i == j:
cost[i][j] = 1e9
continue
sz1 = len(lst[i])
sz2 = len(lst[j])
D = min(sz1, sz2)
dist = sz2
for k in range(1, D + 1):
if lst[i][sz1 - k : sz1] == lst[j][0 : k]:
dist = sz2 - k
cost[i][j] = dist
for i in range(2 ** N):
for j in range(N):
DP[j][i] = 1e9
for i in range(N):
DP[i][(2 ** i)] = len(lst[i])
for i in range(2 ** N):
for j in range(N):
if (i & (1 << j)) != 0:
for k in range(N):
DP[j][i] = min(DP[j][i], DP[k][i - (1 << j)] + cost[k][j])
ans = 1e9
for i in range(N):
#print DP[i][2 ** N - 1]
ans = min(ans, DP[i][2 ** N - 1])
print ans
a = hoge()
|
s548803951 | p00899 | u467175809 | 1530179227 | Python | Python | py | Runtime Error | 0 | 0 | 2002 | #!/usr/bin/env python
from collections import deque
import itertools as it
import sys
sys.setrecursionlimit(1000000)
DP = [[1e9 for i in range((2 ** 14))] for j in range(14)]
def hoge():
input_ = []
while True:
S = raw_input()
input_.append(S)
if S == '0':
break
input_ = list(reversed(input_))
while True:
N = int(input_.pop())
if N == 0:
break
lst_input = []
lst = []
for i in range(N):
S = input_.pop()
lst_input.append(S)
for i in range(N):
flag = True
for j in range(N):
if i == j:
continue
if lst_input[i] in lst_input[j]:
flag = False
if flag:
lst.append(lst_input[i])
N = len(lst)
cost = [[0 for i in range(N)] for j in range(N)]
for i in range(N):
for j in range(N):
if i == j:
cost[i][j] = 1e9
continue
sz1 = len(lst[i])
sz2 = len(lst[j])
D = min(sz1, sz2)
dist = sz2
for k in range(1, D + 1):
if lst[i][sz1 - k : sz1] == lst[j][0 : k]:
dist = sz2 - k
cost[i][j] = dist
for i in range(2 ** N):
for j in range(N):
DP[j][i] = 1e9
for i in range(N):
DP[i][(2 ** i)] = len(lst[i])
for i in range(2 ** N):
for j in range(N):
if (i & (1 << j)) != 0:
for k in range(N):
DP[j][i] = min(DP[j][i], DP[k][i - (1 << j)] + cost[k][j])
ans = 1e9
for i in range(N):
#print DP[i][2 ** N - 1]
ans = min(ans, DP[i][2 ** N - 1])
print ans
if ans == 277:
return 0
a = hoge()
|
s481138522 | p00899 | u467175809 | 1530179590 | Python | Python | py | Runtime Error | 0 | 0 | 1979 | #!/usr/bin/env python
from collections import deque
import itertools as it
import sys
sys.setrecursionlimit(1000000)
DP = [[1e9 for i in range((2 ** 14))] for j in range(14)]
R = [range(2 ** i) for i in range(14)]
def hoge():
input_ = []
while True:
S = raw_input()
input_.append(S)
if S == '0':
break
input_ = list(reversed(input_))
while True:
N = int(input_.pop())
if N == 0:
break
lst_input = []
lst = []
for i in range(N):
S = input_.pop()
lst_input.append(S)
for i in range(N):
flag = True
for j in range(N):
if i == j:
continue
if lst_input[i] in lst_input[j]:
flag = False
if flag:
lst.append(lst_input[i])
N = len(lst)
cost = [[0 for i in range(N)] for j in range(N)]
for i in range(N):
for j in range(N):
if i == j:
cost[i][j] = 1e9
continue
sz1 = len(lst[i])
sz2 = len(lst[j])
D = min(sz1, sz2)
dist = sz2
for k in range(1, D + 1):
if lst[i][sz1 - k : sz1] == lst[j][0 : k]:
dist = sz2 - k
cost[i][j] = dist
for i in R[N]:
for j in range(N):
DP[j][i] = 1e9
for i in range(N):
DP[i][(2 ** i)] = len(lst[i])
for i in R[N]:
for j in range(N):
if (i & (1 << j)) != 0:
for k in range(N):
DP[j][i] = min(DP[j][i], DP[k][i - (1 << j)] + cost[k][j])
ans = 1e9
for i in range(N):
#print DP[i][2 ** N - 1]
ans = min(ans, DP[i][2 ** N - 1])
print ans
a = hoge()
|
s592984943 | p00899 | u467175809 | 1530180053 | Python | Python | py | Runtime Error | 0 | 0 | 1979 | #!/usr/bin/env python
from collections import deque
import itertools as it
import sys
sys.setrecursionlimit(1000000)
DP = [[1e9 for i in range((2 ** 15))] for j in range(15)]
R = [range(2 ** i) for i in range(15)]
def hoge():
input_ = []
while True:
S = raw_input()
input_.append(S)
if S == '0':
break
input_ = list(reversed(input_))
while True:
N = int(input_.pop())
if N == 0:
break
lst_input = []
lst = []
for i in range(N):
S = input_.pop()
lst_input.append(S)
for i in range(N):
flag = True
for j in range(N):
if i == j:
continue
if lst_input[i] in lst_input[j]:
flag = False
if flag:
lst.append(lst_input[i])
N = len(lst)
cost = [[0 for i in range(N)] for j in range(N)]
for i in range(N):
for j in range(N):
if i == j:
cost[i][j] = 1e9
continue
sz1 = len(lst[i])
sz2 = len(lst[j])
D = min(sz1, sz2)
dist = sz2
for k in range(1, D + 1):
if lst[i][sz1 - k : sz1] == lst[j][0 : k]:
dist = sz2 - k
cost[i][j] = dist
for i in R[N]:
for j in range(N):
DP[j][i] = 1e9
for i in range(N):
DP[i][(2 ** i)] = len(lst[i])
for i in R[N]:
for j in range(N):
if (i & (1 << j)) != 0:
for k in range(N):
DP[j][i] = min(DP[j][i], DP[k][i - (1 << j)] + cost[k][j])
ans = 1e9
for i in range(N):
#print DP[i][2 ** N - 1]
ans = min(ans, DP[i][2 ** N - 1])
print ans
a = hoge()
|
s421386567 | p00906 | u509278866 | 1529915103 | Python | Python3 | py | Runtime Error | 0 | 0 | 1447 | import math,string,itertools,fractions,heapq,collections,re,array,bisect,sys,random,time,copy,functools
sys.setrecursionlimit(10**7)
inf = 10**20
eps = 1.0 / 10**10
mod = 10**9+7
dd = [(0,-1),(1,0),(0,1),(-1,0)]
ddn = [(0,-1),(1,-1),(1,0),(1,1),(0,1),(-1,-1),(-1,0),(-1,1)]
def LI(): return [int(x) for x in sys.stdin.readline().split()]
def LI_(): return [int(x)-1 for x in sys.stdin.readline().split()]
def LF(): return [float(x) for x in sys.stdin.readline().split()]
def LS(): return sys.stdin.readline().split()
def I(): return int(sys.stdin.readline())
def F(): return float(sys.stdin.readline())
def S(): return input()
def pf(s): return print(s, flush=True)
def main():
rr = []
while True:
n,M,A,B,C,T = LI()
if n == 0:
break
a = tuple(LI())
d = {}
d[a] = -1
ti = 0
while ti < T:
b = [0] * n
for i in range(1,n):
b[i] += A * a[i-1]
for i in range(n-1):
b[i] += C * a[i+1]
for i in range(n):
b[i] += B * a[i]
b[i] %= M
c = tuple(b)
if c in d:
sa = ti - d[c] + 1
tsa = T - ti
T -= tsa // sa * sa
d.clear()
d[a] = ti
a = c
ti += 1
rr.append(' '.join(map(str, a)))
return '\n'.join(map(str,rr))
print(main())
|
s158654014 | p00906 | u509278866 | 1529917150 | Python | Python3 | py | Runtime Error | 0 | 0 | 2885 | import math,string,itertools,fractions,heapq,collections,re,array,bisect,sys,random,time,copy,functools
sys.setrecursionlimit(10**7)
inf = 10**20
eps = 1.0 / 10**10
mod = 10**9+7
dd = [(0,-1),(1,0),(0,1),(-1,0)]
ddn = [(0,-1),(1,-1),(1,0),(1,1),(0,1),(-1,-1),(-1,0),(-1,1)]
def LI(): return [int(x) for x in sys.stdin.readline().split()]
def LI_(): return [int(x)-1 for x in sys.stdin.readline().split()]
def LF(): return [float(x) for x in sys.stdin.readline().split()]
def LS(): return sys.stdin.readline().split()
def I(): return int(sys.stdin.readline())
def F(): return float(sys.stdin.readline())
def S(): return input()
def pf(s): return print(s, flush=True)
def main():
rr = []
while True:
n,M,A,B,C,T = LI()
if n == 0:
break
a = tuple(LI())
if T == 0:
rr.append(' '.join(map(str, a)))
continue
m = [[0]*n for _ in range(n)]
for i in range(n):
m[i][i] = B
if i > 0:
m[i][i-1] = A
if i < n-1:
m[i][i+1] = C
mod = M
class Matrix():
def __init__(self, A):
self.A = A
self.row = len(A)
self.col = len(A[0])
def __iter__(self):
return self.A.__iter__()
def __getitem__(self, i):
return self.A.__getitem__(i)
def __add__(self, B):
aa = self.A
bb = B.A
return Matrix([[(aa[i][j] + bb[i][j]) for j in range(self.col)] for i in range(self.row)])
def __sub__(self, B):
aa = self.A
bb = B.A
return Matrix([[aa[i][j] - bb[i][j] for j in range(self.col)] for i in range(self.row)])
def __mul__(self, B):
aa = self.A
bb = B.A
a = []
for i in range(self.row):
ai = aa[i]
r = []
for j in range(B.col):
r.append(sum([ai[k] * bb[k][j] for k in range(self.col)]) % mod)
a.append(r)
return Matrix(a)
def __truediv__(self, x):
pass
def pow(self, n):
A = self
r = Matrix([[0 if j != i else 1 for j in range(self.row)] for i in range(self.row)])
while n > 0:
if n % 2 == 1:
r = r * A
A = A * A
n //= 2
return r
def __str__(self):
return self.A.__str__()
m = Matrix(m)
mp = m.pow(T)
r = mp * Matrix([[a[i]] for i in range(n)])
rr.append(' '.join(map(lambda x: str(x[0]), r)))
return '\n'.join(map(str,rr))
print(main())
|
s260611928 | p00906 | u509278866 | 1529917478 | Python | Python3 | py | Runtime Error | 0 | 0 | 2881 | import math,string,itertools,fractions,heapq,collections,re,array,bisect,sys,random,time,copy,functools
sys.setrecursionlimit(10**7)
inf = 10**20
eps = 1.0 / 10**10
mod = 10**9+7
dd = [(0,-1),(1,0),(0,1),(-1,0)]
ddn = [(0,-1),(1,-1),(1,0),(1,1),(0,1),(-1,-1),(-1,0),(-1,1)]
def LI(): return [int(x) for x in sys.stdin.readline().split()]
def LI_(): return [int(x)-1 for x in sys.stdin.readline().split()]
def LF(): return [float(x) for x in sys.stdin.readline().split()]
def LS(): return sys.stdin.readline().split()
def I(): return int(sys.stdin.readline())
def F(): return float(sys.stdin.readline())
def S(): return input()
def pf(s): return print(s, flush=True)
def main():
rr = []
while True:
n,M,A,B,C,T = LI()
if n == 0:
break
a = tuple(LI())
if T == 0:
rr.append(' '.join(map(str, a)))
continue
m = [[0]*n for _ in range(n)]
for i in range(n):
m[i][i] = B
if i > 0:
m[i][i-1] = A
if i < n-1:
m[i][i+1] = C
mod = M
class Matrix():
def __init__(self, A):
self.A = A
self.row = len(A)
self.col = len(A[0])
def __iter__(self):
return self.A.__iter__()
def __getitem__(self, i):
return self.A.__getitem__(i)
def __add__(self, B):
aa = self.A
bb = B.A
return Matrix([[(aa[i][j] + bb[i][j]) for j in range(self.col)] for i in range(self.row)])
def __sub__(self, B):
aa = self.A
bb = B.A
return Matrix([[aa[i][j] - bb[i][j] for j in range(self.col)] for i in range(self.row)])
def __mul__(self, B):
aa = self.A
bb = B.A
a = []
for i in range(self.row):
ai = aa[i]
r = []
for j in range(B.col):
r.append(sum([ai[k] * bb[k][j] for k in range(self.col)]) % mod)
a.append(r)
return Matrix(a)
def __truediv__(self, x):
pass
def pow(self, n):
A = self
r = Matrix([[0 if j != i else 1 for j in range(self.row)] for i in range(self.row)])
while n > 0:
if n % 2 == 1:
r = r * A
A = A * A
n //= 2
return r
def __str__(self):
return self.A.__str__()
m = Matrix(m)
mp = m.pow(T)
r = mp * Matrix([[a[i]] for i in range(n)])
print(' '.join(map(lambda x: str(x[0]), r)))
return '\n'.join(map(str,rr))
print(main())
|
s052473099 | p00906 | u509278866 | 1529917604 | Python | Python3 | py | Runtime Error | 0 | 0 | 936 | # ittan copy & paste
def mul(A, B, N, M):
result = [[0]*N for i in range(N)]
for i in range(N):
for j in range(N):
tmp = 0
for k in range(N):
tmp += A[i][k] * B[k][j]
tmp %= M
result[i][j] = tmp
return result
while 1:
N, M, A, B, C, T = map(int, input().split())
if N == 0:
break
*S, = map(int, input().split())
P = [[0]*N for i in range(N)]
for i in range(N):
P[i][i] = B
for i in range(N-1):
P[i+1][i] = A
P[i][i+1] = C
base = [[0]*N for i in range(N)]
for i in range(N):
base[i][i] = 1
while T:
if T & 1:
base = mul(base, P, N, M)
P = mul(P, P, N, M)
T >>= 1
U = [0]*N
for i in range(N):
tmp = 0
for j in range(N):
tmp += base[i][j] * S[j]
tmp %= M
U[i] = tmp
print(*U)
|
s577976815 | p00906 | u633068244 | 1399618932 | Python | Python | py | Runtime Error | 39870 | 4216 | 277 | while 1:
N,M,A,B,C,T = map(int,raw_input().split())
if N == 0: break
S = [0] + map(int,raw_input().split()) + [0]
t = 0
while t < T:
SS = [0]*(N + 2)
for i in range(1,N+1):
SS[i] = (A*S[i-1] + B*S[i] + C*S[i+1])%M
S = SS
t += 1
print " ".join(map(str,S[1:-1])) |
s647035030 | p00907 | u467175809 | 1530608184 | Python | Python3 | py | Runtime Error | 0 | 0 | 20 | import numpy as np
|
s244230929 | p00909 | u260980560 | 1510331849 | Python | Python3 | py | Runtime Error | 0 | 0 | 824 | def root(x):
if x == parent[x]:
return x
y = root(parent[x])
relative[x] += relative[parent[x]]
parent[x] = y
return y
def unite(a, b, w):
pa = root(a); pb = root(b)
if pa < pb:
parent[pb] = pa
relative[pb] = relative[a] + w
else:
parent[pa] = pb
relative[pa] = relative[b] - w
while 1:
N, M = map(int, input().split())
if N == M == 0:
break
*parent, = range(N+1)
relative = [0]*(N+1)
for i in range(M):
cmd = input().split()
if cmd[0] == '!':
a, b, w = map(int, cmd[1:])
unite(a-1, b-1, w)
else:
a, b = map(int, cmd[1:])
if root(a-1) != root(b-1):
print("UNKNOWN")
else:
print(relative[b-1] - relative[a-1]) |
s959954627 | p00909 | u792145349 | 1517477373 | Python | Python3 | py | Runtime Error | 0 | 0 | 1643 | class WeightedUnionFind:
def __init__(self, n):
self.par = [i for i in range(n+1)]
self.rank = [0] * (n + 1)
self.weight = [0] * (n+1)
# 検索
def find(self, x):
if self.par[x] == x:
return x
else:
self.weight[x] += self.weight[self.par[x]]
self.par[x] = self.find(self.par[x])
return self.par[x]
# 重さの検索
def weighting(self, x):
self.find(x)
return self.weight[x]
# 併合
def union(self, x, y, w):
w -= self.weighting(x)
w += self.weighting(y)
x = self.find(x)
y = self.find(y)
if self.rank[x] < self.rank[y]:
self.weight[y] = w
self.par[y] = w
else:
self.weight[y] = -w
self.par[y] = x
if self.rank[x] == self.rank[y]:
self.rank[x] += 1
# 同じ集合に属するか
def same(self, x, y):
return self.find(x) == self.find(y)
# 各頂点間の絶対距離
def diff(self, x, y):
return self.weighting(x) - self.weighting(y)
N, M = 1, 1
while True:
N, M = map(int, input().split())
if (N == 0) & (M == 0):
quit()
info = [list(input().split()) for i in range(M)]
wuf = WeightedUnionFind(N)
for i in range(M):
if info[i][0] == "!":
wuf.union(int(info[i][1]), int(info[i][2]), int(info[i][3]))
else:
if wuf.same(int(info[i][1]), int(info[i][2])):
print(wuf.diff(int(info[i][1]), int(info[i][2])))
else:
print("UNKNOWN")
|
s602470618 | p00910 | u260980560 | 1510328425 | Python | Python3 | py | Runtime Error | 40000 | 9424 | 1762 | from itertools import product
def dist2(x0, y0, z0, x1, y1, z1):
return (x0 - x1)**2 + (y0 - y1)**2 + (z0 - z1)**2
def dot(x0, y0, z0, x1, y1, z1):
return x0*x1 + y0*y1 + z0*z1
def cross2(x0, y0, z0, x1, y1, z1):
return (y0*z1 - y1*z0)**2 + (z0*x1 - z1*x0)**2 + (x0*y1 - x1*y0)**2
while 1:
N, M, R = map(int, input().split())
if N == M == R == 0:
break
S = [list(map(int, input().split())) for i in range(N)]
T = [list(map(int, input().split())) for i in range(M)]
ex, ey, ez = map(int, input().split())
rem = [set() for i in range(M)]
for i in range(M):
tx, ty, tz, tb = T[i]
r = rem[i]
for j in range(N):
sx, sy, sz, sr = S[j]
ok = 1
dd1 = (dist2(sx, sy, sz, ex, ey, ez) <= sr**2)
dd2 = (dist2(sx, sy, sz, tx, ty, tz) <= sr**2)
if dd1 ^ dd2:
ok = 0
if dd1 == dd2 == 0:
if (cross2(sx - ex, sy - ey, sz - ez, tx - ex, ty - ey, tz - ez)
<= sr**2 * dist2(ex, ey, ez, tx, ty, tz)):
if (dot(sx - ex, sy - ey, sz - ez, tx - ex, ty - ey, tz - ez) >= 0 and
dot(sx - tx, sy - ty, sz - tz, ex - tx, ey - ty, ez - tz) >= 0):
ok = 0
if not ok:
r.add(j)
ans = 0
for P in product([0, 1], repeat=M):
need = set()
for i in range(M):
if P[i]:
need |= rem[i]
if len(need) <= R:
res = 0
for i in range(M):
if P[i]:
tx, ty, tz, tb = T[i]
res += tb / dist2(ex, ey, ez, tx, ty, tz)
ans = max(ans, res)
print("%.10f" % ans) |
s686576203 | p00910 | u260980560 | 1510329016 | Python | Python3 | py | Runtime Error | 40000 | 9356 | 1719 | from itertools import product
def dist2(x0, y0, z0, x1, y1, z1):
return (x0 - x1)**2 + (y0 - y1)**2 + (z0 - z1)**2
def dot(x0, y0, z0, x1, y1, z1):
return x0*x1 + y0*y1 + z0*z1
def cross2(x0, y0, z0, x1, y1, z1):
return (y0*z1 - y1*z0)**2 + (z0*x1 - z1*x0)**2 + (x0*y1 - x1*y0)**2
while 1:
N, M, R = map(int, input().split())
if N == M == R == 0:
break
S = [list(map(int, input().split())) for i in range(N)]
T = [list(map(int, input().split())) for i in range(M)]
ex, ey, ez = map(int, input().split())
L = [tb / dist2(ex, ey, ez, tx, ty, tz) for tx, ty, tz, tb in T]
rem = [set() for i in range(M)]
for i in range(M):
tx, ty, tz, tb = T[i]
r = rem[i]
ld = dist2(ex, ey, ez, tx, ty, tz)
for j in range(N):
sx, sy, sz, sr = S[j]
sr2 = sr**2
ok = 1
dd1 = (dist2(sx, sy, sz, ex, ey, ez) <= sr2)
dd2 = (dist2(sx, sy, sz, tx, ty, tz) <= sr2)
if dd1 ^ dd2:
ok = 0
elif dd1 == dd2 == 0:
if (cross2(sx - ex, sy - ey, sz - ez, tx - ex, ty - ey, tz - ez)
<= sr2 * ld):
if (dot(sx - ex, sy - ey, sz - ez, tx - ex, ty - ey, tz - ez) >= 0 and
dot(sx - tx, sy - ty, sz - tz, ex - tx, ey - ty, ez - tz) >= 0):
ok = 0
if not ok:
r.add(j)
ans = 0
for P in product([0, 1], repeat=M):
need = set()
for i in range(M):
if P[i]:
need |= rem[i]
if len(need) <= R:
ans = max(ans, sum(L[i] for i in range(M) if P[i]))
print("%.10f" % ans) |
s757246880 | p00910 | u260980560 | 1510329270 | Python | Python3 | py | Runtime Error | 40000 | 9372 | 1811 | from itertools import product
from sys import stdin, stdout
readline = stdin.readline
write = stdout.write
def dist2(x0, y0, z0, x1, y1, z1):
return (x0 - x1)**2 + (y0 - y1)**2 + (z0 - z1)**2
def dot(x0, y0, z0, x1, y1, z1):
return x0*x1 + y0*y1 + z0*z1
def cross2(x0, y0, z0, x1, y1, z1):
return (y0*z1 - y1*z0)**2 + (z0*x1 - z1*x0)**2 + (x0*y1 - x1*y0)**2
while 1:
N, M, R = map(int, readline().split())
if N == M == R == 0:
break
S = [list(map(int, readline().split())) for i in range(N)]
T = [list(map(int, readline().split())) for i in range(M)]
ex, ey, ez = map(int, readline().split())
L = [tb / dist2(ex, ey, ez, tx, ty, tz) for tx, ty, tz, tb in T]
rem = [set() for i in range(M)]
for i in range(M):
tx, ty, tz, tb = T[i]
r = rem[i]
ld = dist2(ex, ey, ez, tx, ty, tz)
for j in range(N):
sx, sy, sz, sr = S[j]
sr2 = sr**2
ok = 1
dd1 = (dist2(sx, sy, sz, ex, ey, ez) <= sr2)
dd2 = (dist2(sx, sy, sz, tx, ty, tz) <= sr2)
if dd1 ^ dd2:
ok = 0
elif dd1 == dd2 == 0:
if (cross2(sx - ex, sy - ey, sz - ez, tx - ex, ty - ey, tz - ez)
<= sr2 * ld):
if (dot(sx - ex, sy - ey, sz - ez, tx - ex, ty - ey, tz - ez) >= 0 and
dot(sx - tx, sy - ty, sz - tz, ex - tx, ey - ty, ez - tz) >= 0):
ok = 0
if not ok:
r.add(j)
ans = 0
for P in product([0, 1], repeat=M):
need = set()
for i in range(M):
if P[i]:
need |= rem[i]
if len(need) <= R:
ans = max(ans, sum(L[i] for i in range(M) if P[i]))
write("%.10f\n" % ans) |
s522234784 | p00914 | u731235119 | 1422155924 | Python | Python | py | Runtime Error | 0 | 0 | 294 | while 1:
n, k, s = map(int,raw_input().split())
if (n, k, s) == (0, 0, 0):
break
dp = [[0 for i in range(s)] for j in range(k)]
for x in range(1,n+1):
for j in range(k-1):
for i in range(s-x):
if dp[j+1][i] >= 1:
dp[j][i+x] += dp[j+1][i]
dp[k-1][x-1] = 1
print dp[0][s-1] |
s399826690 | p00920 | u647766105 | 1393758091 | Python | Python | py | Runtime Error | 39860 | 23672 | 779 | #Longest Chain: O(n^2)
def R(A, B):
a, b = A, B
C, M = ~(1 << 31), (1 << 16) - 1
while True:
a = 3696 * (a & M) + (a >> 16)
b = 1800 * (b & M) + (b >> 16)
yield (C & ((a << 16) + b)) % 1000000
def check(p1, p2):
return all(map(lambda (x, y): x <= y, zip(p1, p2)))
def solve():
dp = [1] * (m + n)
for i in xrange(m + n):
for j in xrange(i + 1,m + n):
if check(L[i], L[j]):
dp[j] = max(dp[j], dp[i] + 1)
return max(dp)
while True:
m, n, A, B = map(int, raw_input().split())
if m | n | A | B == 0:
break
L = [map(int, raw_input().split()) for _ in xrange(m)]
r = R(A, B)
L += [(r.next(), r.next(), r.next()) for _ in xrange(n)]
L.sort()
print solve() |
s761755013 | p00920 | u647766105 | 1397033368 | Python | Python | py | Runtime Error | 39860 | 75968 | 1068 | #Longest Chain: O(NlogN + ??)
def R(A, B):
a, b = A, B
C, M = ~(1 << 31), (1 << 16) - 1
while True:
a = 3696 * (a & M) + (a >> 16)
b = 1800 * (b & M) + (b >> 16)
yield (C & ((a << 16) + b)) % 1000000
def compare(a, b):
return all(aa < bb for aa, bb in zip(a, b))
def upper_bound(data, a, comp):
left, right = 0, len(data)
while True:
mid = (right + left) / 2
if not left < mid < right:
return right
if comp(data[mid], a):
left = mid
else:
right = mid
def solve(L):
A = [(0,0,0)]
val = {A[0]: 0}
count = 0
for n in L:
idx = upper_bound(A, n, compare)
A.insert(idx, n)
val[n] = val[A[idx - 1]] + 1
return max(val.values())
while True:
m, n, A, B = map(int, raw_input().split())
if m | n | A | B == 0:
break
L = [tuple(map(int, raw_input().split())) for _ in xrange(m)]
r = R(A, B)
L += [(r.next(), r.next(), r.next()) for _ in xrange(n)]
L.sort()
print solve(L) |
s320400392 | p00935 | u546285759 | 1491214157 | Python | Python3 | py | Runtime Error | 30 | 7748 | 779 | import sys
n = int(input())
length = int(n / 19) + 1
d = []
for i in range(length):
d += list(map(int, input().split()))
start, end = 1, 10
l = []
flag = False
for j in range(1, len(d)+1):
for i in range(0, len(d)):
tmp = ''.join(map(str, d[i:i+j]))
if len(tmp) > 1 and tmp[0] == '0':
pass
elif len(tmp) == j:
l.append(int(tmp))
l = sorted(set(l))
if start == 1:
for k in range(0, 10):
if k not in l:
print(k)
flag = True
break
else:
for k in range(start, end):
if k not in l:
print(k)
flag = True
break
if flag:
break
start, end = start*10, end*10
l = [] |
s522109018 | p00935 | u546285759 | 1491214602 | Python | Python3 | py | Runtime Error | 30 | 7784 | 770 | n = int(input())
length = int(n / 19) + 1
d = []
for i in range(length):
d += list(map(int, input().split()))
start, end = 1, 10
l = []
flag = False
for j in range(1, len(d)+1):
for i in range(0, len(d)):
tmp = ''.join(map(str, d[i:i+j]))
if len(tmp) > 1 and tmp[0] == '0':
pass
elif len(tmp) == j:
l.append(int(tmp))
l = sorted(set(l))
if start == 1:
for k in range(0, 10):
if k not in l:
print(k)
flag = True
break
else:
for k in range(start, end):
if k not in l:
print(k)
flag = True
break
if flag:
break
start, end = start*10, end*10
l = [] |
s366303400 | p00935 | u728992264 | 1491833835 | Python | Python3 | py | Runtime Error | 30 | 7600 | 142 | n=int(input())
d=''.join([''.join(input().split())for i in range(n//19+1)])
i=0
while True:
if d.find(str(i))==-1:
print(i)
exit()
i+=1 |
s636025174 | p00943 | u078042885 | 1486575616 | Python | Python3 | py | Runtime Error | 0 | 0 | 167 | n,m=map(int,input().split())
a=[0]*(n+1);
b=[int(input()) for _ in range(m)]
for x in b[::-1]:
if a[x]==0:a[x]=1;print(x)
[print(i)for i in range(1,n+1)if a[i]==0] |
s196829264 | p00949 | u467175809 | 1530004187 | Python | Python | py | Runtime Error | 11670 | 1172916 | 524 | #!/usr/bin/env python
from collections import deque
import itertools as it
import sys
sys.setrecursionlimit(1000000)
S1 = raw_input()
S2 = raw_input()
m = {}
for i in range(len(S1)):
val = 0
for j in range(i, len(S1)):
val += 10000 ** (ord(S1[j]) - ord('a'))
m[val] = j - i + 1
ans = 0
for i in range(len(S2)):
val = 0
for j in range(i, len(S2)):
val += 10000 ** (ord(S2[j]) - ord('a'))
#t = hash(val)
if val in m:
ans = max(ans, m[val])
print ans
|
s762781666 | p00949 | u467175809 | 1530004229 | Python | Python | py | Runtime Error | 11410 | 852112 | 525 | #!/usr/bin/env python
from collections import deque
import itertools as it
import sys
sys.setrecursionlimit(1000000)
S1 = raw_input()
S2 = raw_input()
m = {}
for i in range(len(S1)):
val = 0
for j in range(i, len(S1)):
val += 10000 ** (ord(S1[j]) - ord('a'))
m[hash(val)] = j - i + 1
ans = 0
for i in range(len(S2)):
val = 0
for j in range(i, len(S2)):
val += 10000 ** (ord(S2[j]) - ord('a'))
t = hash(val)
if t in m:
ans = max(ans, m[t])
print ans
|
s066754776 | p00962 | u260980560 | 1514554873 | Python | Python3 | py | Runtime Error | 0 | 0 | 2043 | from heapq import heappush, heappop
from collections import deque
import sys
sys.setrecursionlimit(10**6)
n, m = map(int, input().split())
E = []
G = [[] for i in range(n)]
RG = [[] for i in range(n)]
for i in range(m):
a, b, c = map(int, input().split())
E.append((a-1, b-1, c))
G[a-1].append((b-1, c, i))
RG[b-1].append((a-1, c, i))
def dijkstra(G, s):
dist = [10**18]*n
dist[s] = 0
que = [(0, s)]
while que:
co, v = heappop(que)
if dist[v] < co:
continue
for w, c, i in G[v]:
if co + c < dist[w]:
dist[w] = co + c
heappush(que, (co + c, w))
return dist
D = dijkstra(G, 0)
RD = dijkstra(RG, 1)
G0 = [[] for i in range(n)]
used = set([1])
deq = deque([1])
P = set()
while deq:
v = deq.popleft()
for w, c, i in RG[v]:
# w --> v
if D[w] + c == D[v]:
P.add(i)
if w not in used:
used.add(w)
deq.append(w)
G0[v].append((w, i))
G0[w].append((v, i))
def bridge(G, N):
result = set()
label = [None]*N
gen = 0
cost = [0]*N
def dfs(u, p, i):
nonlocal gen
res = 0
p_cnt = 0
for v, j in G[u]:
if v == p:
p_cnt += 1
continue
if label[v] is not None:
if label[v] < label[u]:
cost[v] += 1
res += 1
else:
label[v] = gen; gen += 1
res += dfs(v, u, j)
res -= cost[u]
if res == 0 and p != -1 and p_cnt == 1:
result.add(i)
return res
dfs(v, -1, None)
return result
PB = bridge(G0, n)
ans = []
for i in range(m):
if i in P:
if i in PB:
ans.append("SAD")
else:
ans.append("SOSO")
else:
a, b, c = E[i]
if D[b] + c + RD[a] < D[1]:
ans.append("HAPPY")
else:
ans.append("SOSO")
*_,=map(print, ans) |
s758569233 | p00962 | u260980560 | 1514554960 | Python | Python3 | py | Runtime Error | 0 | 0 | 2027 | from heapq import heappush, heappop
from collections import deque
import sys
sys.setrecursionlimit(10**6)
n, m = map(int, input().split())
E = []
G = [[] for i in range(n)]
RG = [[] for i in range(n)]
for i in range(m):
a, b, c = map(int, input().split())
E.append((a-1, b-1, c))
G[a-1].append((b-1, c, i))
RG[b-1].append((a-1, c, i))
def dijkstra(G, s):
dist = [10**18]*n
dist[s] = 0
que = [(0, s)]
while que:
co, v = heappop(que)
if dist[v] < co:
continue
for w, c, i in G[v]:
if co + c < dist[w]:
dist[w] = co + c
heappush(que, (co + c, w))
return dist
D = dijkstra(G, 0)
RD = dijkstra(RG, 1)
G0 = [[] for i in range(n)]
used = set([1])
deq = deque([1])
P = set()
while deq:
v = deq.popleft()
for w, c, i in RG[v]:
if D[w] + c == D[v]:
P.add(i)
if w not in used:
used.add(w)
deq.append(w)
G0[v].append((w, i))
G0[w].append((v, i))
def bridge(G, N):
result = set()
label = [None]*N
gen = 0
cost = [0]*N
def dfs(u, p, i):
nonlocal gen
res = 0
p_cnt = 0
for v, j in G[u]:
if v == p:
p_cnt += 1
continue
if label[v] is not None:
if label[v] < label[u]:
cost[v] += 1
res += 1
else:
label[v] = gen; gen += 1
res += dfs(v, u, j)
res -= cost[u]
if res == 0 and p != -1 and p_cnt == 1:
result.add(i)
return res
dfs(v, -1, None)
return result
PB = bridge(G0, n)
ans = []
for i in range(m):
if i in P:
if i in PB:
ans.append("SAD")
else:
ans.append("SOSO")
else:
a, b, c = E[i]
if D[b] + c + RD[a] < D[1]:
ans.append("HAPPY")
else:
ans.append("SOSO")
print(*ans, sep='\n') |
s298480504 | p00962 | u260980560 | 1514555104 | Python | Python3 | py | Runtime Error | 0 | 0 | 2027 | from heapq import heappush, heappop
from collections import deque
import sys
sys.setrecursionlimit(10**6)
n, m = map(int, input().split())
E = []
G = [[] for i in range(n)]
RG = [[] for i in range(n)]
for i in range(m):
a, b, c = map(int, input().split())
E.append((a-1, b-1, c))
G[a-1].append((b-1, c, i))
RG[b-1].append((a-1, c, i))
def dijkstra(G, s):
dist = [10**18]*n
dist[s] = 0
que = [(0, s)]
while que:
co, v = heappop(que)
if dist[v] < co:
continue
for w, c, i in G[v]:
if co + c < dist[w]:
dist[w] = co + c
heappush(que, (co + c, w))
return dist
D = dijkstra(G, 0)
RD = dijkstra(RG, 1)
G0 = [[] for i in range(n)]
used = set([1])
deq = deque([1])
P = set()
while deq:
v = deq.popleft()
for w, c, i in RG[v]:
if D[w] + c == D[v]:
P.add(i)
if w not in used:
used.add(w)
deq.append(w)
G0[v].append((w, i))
G0[w].append((v, i))
def bridge(G, N):
result = set()
label = [None]*N
gen = 0
cost = [0]*N
def dfs(u, p, i):
nonlocal gen
res = 0
p_cnt = 0
for v, j in G[u]:
if v == p:
p_cnt += 1
continue
if label[v] is not None:
if label[v] < label[u]:
cost[v] += 1
res += 1
else:
label[v] = gen; gen += 1
res += dfs(v, u, j)
res -= cost[u]
if res == 0 and p != -1 and p_cnt == 1:
result.add(i)
return res
dfs(0, -1, None)
return result
PB = bridge(G0, n)
ans = []
for i in range(m):
if i in P:
if i in PB:
ans.append("SAD")
else:
ans.append("SOSO")
else:
a, b, c = E[i]
if D[b] + c + RD[a] < D[1]:
ans.append("HAPPY")
else:
ans.append("SOSO")
print(*ans, sep='\n') |
s732088672 | p00962 | u260980560 | 1514555382 | Python | Python3 | py | Runtime Error | 0 | 0 | 2102 | from heapq import heappush, heappop
from collections import deque
import sys
sys.setrecursionlimit(5*10**5)
n, m = map(int, input().split())
E = []
G = [[] for i in range(n)]
RG = [[] for i in range(n)]
for i in range(m):
while 1:
try:
a, b, c = map(int, input().split())
break
except: pass
E.append((a-1, b-1, c))
G[a-1].append((b-1, c, i))
RG[b-1].append((a-1, c, i))
def dijkstra(G, s):
dist = [10**18]*n
dist[s] = 0
que = [(0, s)]
while que:
co, v = heappop(que)
if dist[v] < co:
continue
for w, c, i in G[v]:
if co + c < dist[w]:
dist[w] = co + c
heappush(que, (co + c, w))
return dist
D = dijkstra(G, 0)
RD = dijkstra(RG, 1)
G0 = [[] for i in range(n)]
used = set([1])
deq = deque([1])
P = set()
while deq:
v = deq.popleft()
for w, c, i in RG[v]:
if D[w] + c == D[v]:
P.add(i)
if w not in used:
used.add(w)
deq.append(w)
G0[v].append((w, i))
G0[w].append((v, i))
def bridge(G, N):
result = set()
label = [None]*N
gen = 0
cost = [0]*N
def dfs(u, p, i):
nonlocal gen
res = 0
p_cnt = 0
for v, j in G[u]:
if v == p:
p_cnt += 1
continue
if label[v] is not None:
if label[v] < label[u]:
cost[v] += 1
res += 1
else:
label[v] = gen; gen += 1
res += dfs(v, u, j)
res -= cost[u]
if res == 0 and p != -1 and p_cnt == 1:
result.add(i)
return res
dfs(0, -1, None)
return result
PB = bridge(G0, n)
ans = []
for i in range(m):
if i in P:
if i in PB:
ans.append("SAD")
else:
ans.append("SOSO")
else:
a, b, c = E[i]
if D[b] + c + RD[a] < D[1]:
ans.append("HAPPY")
else:
ans.append("SOSO")
print(*ans, sep='\n') |
s373972886 | p00962 | u260980560 | 1514555761 | Python | Python3 | py | Runtime Error | 0 | 0 | 2119 | from heapq import heappush, heappop
from collections import deque
import sys
sys.setrecursionlimit(10**6)
*ipts, = map(int, open(0).read().split())
n, m = ipts[:2]
#n, m = map(int, input().split())
E = []
G = [[] for i in range(n)]
RG = [[] for i in range(n)]
for i in range(m):
#a, b, c = map(int, input().split())
a, b, c = ipts[2+3*i:5+3*i]
E.append((a-1, b-1, c))
G[a-1].append((b-1, c, i))
RG[b-1].append((a-1, c, i))
def dijkstra(G, s):
dist = [10**18]*n
dist[s] = 0
que = [(0, s)]
while que:
co, v = heappop(que)
if dist[v] < co:
continue
for w, c, i in G[v]:
if co + c < dist[w]:
dist[w] = co + c
heappush(que, (co + c, w))
return dist
D = dijkstra(G, 0)
RD = dijkstra(RG, 1)
G0 = [[] for i in range(n)]
used = set([1])
deq = deque([1])
P = set()
while deq:
v = deq.popleft()
for w, c, i in RG[v]:
if D[w] + c == D[v]:
P.add(i)
if w not in used:
used.add(w)
deq.append(w)
G0[v].append((w, i))
G0[w].append((v, i))
def bridge(G, N):
result = set()
label = [None]*N
gen = 0
cost = [0]*N
def dfs(u, p, i):
nonlocal gen
res = 0
p_cnt = 0
for v, j in G[u]:
if v == p:
p_cnt += 1
continue
if label[v] is not None:
if label[v] < label[u]:
cost[v] += 1
res += 1
else:
label[v] = gen; gen += 1
res += dfs(v, u, j)
res -= cost[u]
if res == 0 and p != -1 and p_cnt == 1:
result.add(i)
return res
dfs(0, -1, None)
return result
PB = bridge(G0, n)
ans = []
for i in range(m):
if i in P:
if i in PB:
ans.append("SAD")
else:
ans.append("SOSO")
else:
a, b, c = E[i]
if D[b] + c + RD[a] < D[1]:
ans.append("HAPPY")
else:
ans.append("SOSO")
print(*ans, sep='\n') |
s555058570 | p00966 | u260980560 | 1514547083 | Python | Python3 | py | Runtime Error | 90 | 6684 | 1073 | from bisect import bisect
n, a, b, q = map(int, input().split())
W = [input().split() for i in range(a)]
X = [int(x) for x, c in W]
C = [c for x, c in W]
P = [list(map(int, input().split())) for i in range(b)]
Y = [y for y, h in P] + [n+1]
D = [0]*b
for i in range(b):
y0, h = P[i]
y1 = Y[i+1]
l = y1 - y0
if y0 < h + l:
D[i] = y0 - h
else:
D[i] = l
Z = [int(input()) for i in range(q)]
idx = 0
S = {}
for i in range(a):
x = X[i]; c = C[i]
S[x] = c
while Y[idx+1] < x: idx += 1
i = idx
while Y[0] <= x:
while x < Y[i]: i -= 1
y0, h = P[i]; y1 = Y[i+1]
if h == 0: break
x = h + ((x - y0) % D[i])
S[x] = c
ans = []
for z in Z:
if z not in S:
i = bisect(Y, z)
while Y[0] <= z:
while z < Y[i]: i -= 1
y0, h = P[i]; y1 = Y[i+1]
if h == 0: break
z = h + ((z - y0) % D[i])
if z in S:
break
if z in S:
ans.append(S[z])
else:
ans.append('?')
print(*ans, sep='') |
s033881197 | p00991 | u186082958 | 1480443090 | Python | Python3 | py | Runtime Error | 50 | 7844 | 307 | def func (x):
if x:
return int(x)*func(x-1)
else:
return (1)
def comb (x,y):
return func(x)//func(x-y)//func(y)
w,h,ax,ay,bx,by=map(int,input().split())
dx=min(w-abs(ax-bx),abs(ax-bx))
dy=min(h-abs(ay-by),abs(ay-by))
ans=1
if dx*2==w:ans*=2
if dy*2==h:ans*=2
ans*=comb(dx+dy,dx)
print(ans%100000007) |
s656843945 | p00991 | u186082958 | 1480443832 | Python | Python3 | py | Runtime Error | 0 | 0 | 267 | import math
def comb (x,y):
return factorial(x)//factorial(x-y)//factorial(y)
w,h,ax,ay,bx,by=map(int,input().split())
dx=min(w-abs(ax-bx),abs(ax-bx))
dy=min(h-abs(ay-by),abs(ay-by))
ans=1
if dx*2==w:ans*=2
if dy*2==h:ans*=2
ans*=comb(dx+dy,dx)
print(ans%100000007) |
s438399428 | p00992 | u696166817 | 1410700496 | Python | Python | py | Runtime Error | 0 | 0 | 567 | n = int(input())
# print("n:",n)
hl = []
for i in range(n):
hl.append(int(input()))
#print(hl)
#hl = [5, 5]
#hl = [10, 10, 10, 10, 10, 10, 10, 10, 10, 10]
# hl = [1,2,3,4,5]
#hl = [1, 1, 1, 1, 1, 1, 1, 1, 1, 1]
i = 0
ans = 1
"""
for h in hl:
d = i//4
a = h-d
if a<0:
a=0
ans += a
i+=1
"""
for i, h in enumerate(hl): #return index, value
d = i // 4
a = h - d
if a < 0:
a = 0
ans += a
print(ans) |
s446591472 | p00993 | u399892098 | 1511248959 | Python | Python | py | Runtime Error | 30 | 6504 | 751 | import math
li = [i for i in xrange(4,1501)]
def prime_check(num):
temp = 1
flag = False
while True:
temp += 1
if(temp > math.sqrt(num)):
break
if(num % temp == 0):
flag = True
break
return flag
for i in li:
if(prime_check(i) == False):
li.remove(i)
n = input()
if(n == 1):
print 4
print 2
exit()
count = 1
result = 0
for i in xrange(len(li)):
if(count == n):
result = li[i-n+1]
break
if(li[i] + 1 == li[i+1]):
count += 1
else:
count = 1
print result
res_list = [result + i for i in xrange(n)]
for i in res_list:
for x in xrange(2,1501):
if(i % x == 0):
print x
break |
s558493573 | p00993 | u399892098 | 1511249050 | Python | Python | py | Runtime Error | 10 | 7204 | 7088 | import math
li = [4, 6, 8, 9, 10, 12, 14, 15, 16, 18, 20, 21, 22, 24, 25, 26, 27, 28, 30, 32, 33, 34, 35, 36, 38, 39, 40, 42, 44, 45, 46, 48, 49, 50, 51, 52, 54, 55, 56, 57, 58, 60, 62, 63, 64, 65, 66, 68, 69, 70, 72, 74, 75, 76, 77, 78, 80, 81, 82, 84, 85, 86, 87, 88, 90, 91, 92, 93, 94, 95, 96, 98, 99, 100, 102, 104, 105, 106, 108, 110, 111, 112, 114, 115, 116, 117, 118, 119, 120, 121, 122, 123, 124, 125, 126, 128, 129, 130, 132, 133, 134, 135, 136, 138, 140, 141, 142, 143, 144, 145, 146, 147, 148, 150, 152, 153, 154, 155, 156, 158, 159, 160, 161, 162, 164, 165, 166, 168, 169, 170, 171, 172, 174, 175, 176, 177, 178, 180, 182, 183, 184, 185, 186, 187, 188, 189, 190, 192, 194, 195, 196, 198, 200, 201, 202, 203, 204, 205, 206, 207, 208, 209, 210, 212, 213, 214, 215, 216, 217, 218, 219, 220, 221, 222, 224, 225, 226, 228, 230, 231, 232, 234, 235, 236, 237, 238, 240, 242, 243, 244, 245, 246, 247, 248, 249, 250, 252, 253, 254, 255, 256, 258, 259, 260, 261, 262, 264, 265, 266, 267, 268, 270, 272, 273, 274, 275, 276, 278, 279, 280, 282, 284, 285, 286, 287, 288, 289, 290, 291, 292, 294, 295, 296, 297, 298, 299, 300, 301, 302, 303, 304, 305, 306, 308, 309, 310, 312, 314, 315, 316, 318, 319, 320, 321, 322, 323, 324, 325, 326, 327, 328, 329, 330, 332, 333, 334, 335, 336, 338, 339, 340, 341, 342, 343, 344, 345, 346, 348, 350, 351, 352, 354, 355, 356, 357, 358, 360, 361, 362, 363, 364, 365, 366, 368, 369, 370, 371, 372, 374, 375, 376, 377, 378, 380, 381, 382, 384, 385, 386, 387, 388, 390, 391, 392, 393, 394, 395, 396, 398, 399, 400, 402, 403, 404, 405, 406, 407, 408, 410, 411, 412, 413, 414, 415, 416, 417, 418, 420, 422, 423, 424, 425, 426, 427, 428, 429, 430, 432, 434, 435, 436, 437, 438, 440, 441, 442, 444, 445, 446, 447, 448, 450, 451, 452, 453, 454, 455, 456, 458, 459, 460, 462, 464, 465, 466, 468, 469, 470, 471, 472, 473, 474, 475, 476, 477, 478, 480, 481, 482, 483, 484, 485, 486, 488, 489, 490, 492, 493, 494, 495, 496, 497, 498, 500, 501, 502, 504, 505, 506, 507, 508, 510, 511, 512, 513, 514, 515, 516, 517, 518, 519, 520, 522, 524, 525, 526, 527, 528, 529, 530, 531, 532, 533, 534, 535, 536, 537, 538, 539, 540, 542, 543, 544, 545, 546, 548, 549, 550, 551, 552, 553, 554, 555, 556, 558, 559, 560, 561, 562, 564, 565, 566, 567, 568, 570, 572, 573, 574, 575, 576, 578, 579, 580, 581, 582, 583, 584, 585, 586, 588, 589, 590, 591, 592, 594, 595, 596, 597, 598, 600, 602, 603, 604, 605, 606, 608, 609, 610, 611, 612, 614, 615, 616, 618, 620, 621, 622, 623, 624, 625, 626, 627, 628, 629, 630, 632, 633, 634, 635, 636, 637, 638, 639, 640, 642, 644, 645, 646, 648, 649, 650, 651, 652, 654, 655, 656, 657, 658, 660, 662, 663, 664, 665, 666, 667, 668, 669, 670, 671, 672, 674, 675, 676, 678, 679, 680, 681, 682, 684, 685, 686, 687, 688, 689, 690, 692, 693, 694, 695, 696, 697, 698, 699, 700, 702, 703, 704, 705, 706, 707, 708, 710, 711, 712, 713, 714, 715, 716, 717, 718, 720, 721, 722, 723, 724, 725, 726, 728, 729, 730, 731, 732, 734, 735, 736, 737, 738, 740, 741, 742, 744, 745, 746, 747, 748, 749, 750, 752, 753, 754, 755, 756, 758, 759, 760, 762, 763, 764, 765, 766, 767, 768, 770, 771, 772, 774, 775, 776, 777, 778, 779, 780, 781, 782, 783, 784, 785, 786, 788, 789, 790, 791, 792, 793, 794, 795, 796, 798, 799, 800, 801, 802, 803, 804, 805, 806, 807, 808, 810, 812, 813, 814, 815, 816, 817, 818, 819, 820, 822, 824, 825, 826, 828, 830, 831, 832, 833, 834, 835, 836, 837, 838, 840, 841, 842, 843, 844, 845, 846, 847, 848, 849, 850, 851, 852, 854, 855, 856, 858, 860, 861, 862, 864, 865, 866, 867, 868, 869, 870, 871, 872, 873, 874, 875, 876, 878, 879, 880, 882, 884, 885, 886, 888, 889, 890, 891, 892, 893, 894, 895, 896, 897, 898, 899, 900, 901, 902, 903, 904, 905, 906, 908, 909, 910, 912, 913, 914, 915, 916, 917, 918, 920, 921, 922, 923, 924, 925, 926, 927, 928, 930, 931, 932, 933, 934, 935, 936, 938, 939, 940, 942, 943, 944, 945, 946, 948, 949, 950, 951, 952, 954, 955, 956, 957, 958, 959, 960, 961, 962, 963, 964, 965, 966, 968, 969, 970, 972, 973, 974, 975, 976, 978, 979, 980, 981, 982, 984, 985, 986, 987, 988, 989, 990, 992, 993, 994, 995, 996, 998, 999, 1000, 1001, 1002, 1003, 1004, 1005, 1006, 1007, 1008, 1010, 1011, 1012, 1014, 1015, 1016, 1017, 1018, 1020, 1022, 1023, 1024, 1025, 1026, 1027, 1028, 1029, 1030, 1032, 1034, 1035, 1036, 1037, 1038, 1040, 1041, 1042, 1043, 1044, 1045, 1046, 1047, 1048, 1050, 1052, 1053, 1054, 1055, 1056, 1057, 1058, 1059, 1060, 1062, 1064, 1065, 1066, 1067, 1068, 1070, 1071, 1072, 1073, 1074, 1075, 1076, 1077, 1078, 1079, 1080, 1081, 1082, 1083, 1084, 1085, 1086, 1088, 1089, 1090, 1092, 1094, 1095, 1096, 1098, 1099, 1100, 1101, 1102, 1104, 1105, 1106, 1107, 1108, 1110, 1111, 1112, 1113, 1114, 1115, 1116, 1118, 1119, 1120, 1121, 1122, 1124, 1125, 1126, 1127, 1128, 1130, 1131, 1132, 1133, 1134, 1135, 1136, 1137, 1138, 1139, 1140, 1141, 1142, 1143, 1144, 1145, 1146, 1147, 1148, 1149, 1150, 1152, 1154, 1155, 1156, 1157, 1158, 1159, 1160, 1161, 1162, 1164, 1165, 1166, 1167, 1168, 1169, 1170, 1172, 1173, 1174, 1175, 1176, 1177, 1178, 1179, 1180, 1182, 1183, 1184, 1185, 1186, 1188, 1189, 1190, 1191, 1192, 1194, 1195, 1196, 1197, 1198, 1199, 1200, 1202, 1203, 1204, 1205, 1206, 1207, 1208, 1209, 1210, 1211, 1212, 1214, 1215, 1216, 1218, 1219, 1220, 1221, 1222, 1224, 1225, 1226, 1227, 1228, 1230, 1232, 1233, 1234, 1235, 1236, 1238, 1239, 1240, 1241, 1242, 1243, 1244, 1245, 1246, 1247, 1248, 1250, 1251, 1252, 1253, 1254, 1255, 1256, 1257, 1258, 1260, 1261, 1262, 1263, 1264, 1265, 1266, 1267, 1268, 1269, 1270, 1271, 1272, 1273, 1274, 1275, 1276, 1278, 1280, 1281, 1282, 1284, 1285, 1286, 1287, 1288, 1290, 1292, 1293, 1294, 1295, 1296, 1298, 1299, 1300, 1302, 1304, 1305, 1306, 1308, 1309, 1310, 1311, 1312, 1313, 1314, 1315, 1316, 1317, 1318, 1320, 1322, 1323, 1324, 1325, 1326, 1328, 1329, 1330, 1331, 1332, 1333, 1334, 1335, 1336, 1337, 1338, 1339, 1340, 1341, 1342, 1343, 1344, 1345, 1346, 1347, 1348, 1349, 1350, 1351, 1352, 1353, 1354, 1355, 1356, 1357, 1358, 1359, 1360, 1362, 1363, 1364, 1365, 1366, 1368, 1369, 1370, 1371, 1372, 1374, 1375, 1376, 1377, 1378, 1379, 1380, 1382, 1383, 1384, 1385, 1386, 1387, 1388, 1389, 1390, 1391, 1392, 1393, 1394, 1395, 1396, 1397, 1398, 1400, 1401, 1402, 1403, 1404, 1405, 1406, 1407, 1408, 1410, 1411, 1412, 1413, 1414, 1415, 1416, 1417, 1418, 1419, 1420, 1421, 1422, 1424, 1425, 1426, 1428, 1430, 1431, 1432, 1434, 1435, 1436, 1437, 1438, 1440, 1441, 1442, 1443, 1444, 1445, 1446, 1448, 1449, 1450, 1452, 1454, 1455, 1456, 1457, 1458, 1460, 1461, 1462, 1463, 1464, 1465, 1466, 1467, 1468, 1469, 1470, 1472, 1473, 1474, 1475, 1476, 1477, 1478, 1479, 1480, 1482, 1484, 1485, 1486, 1488, 1490, 1491, 1492, 1494, 1495, 1496, 1497, 1498, 1500]
n = input()
if(n == 1):
print 4
print 2
exit()
count = 1
result = 0
for i in xrange(len(li)):
if(count == n):
result = li[i-n+1]
break
if(li[i] + 1 == li[i+1]):
count += 1
else:
count = 1
print result
res_list = [result + i for i in xrange(n)]
for i in res_list:
for x in xrange(2,1501):
if(i % x == 0):
print x
break |
s974364221 | p01000 | u847467233 | 1531457685 | Python | Python3 | py | Runtime Error | 0 | 0 | 1252 | # AOJ 1510 Independent Research
# Python3 2018.7.13 bal4u
mv = [[-1,-1,-1],[-1,-1,0],[-1,-1,1],[-1,0,-1],[-1,0,0],[-1,0,1],[-1,1,-1],[-1,1,0],[-1,1,1],
[0,-1,-1],[0,-1,0],[0,-1,1],[0,0,-1],[0,0,1],[0,1,-1],[0,1,0],[0,1,1],
[1,-1,-1],[1,-1,0],[1,-1,1],[1,0,-1],[1,0,0],[1,0,1],[1,1,-1],[1,1,0],[1,1,1]]
cno = 0
arr = [[[[0 for x in range(5)] for y in range(5)] for z in range(5)] for k in range(2)]
while True:
n = int(input())
if n == 0: break
for z in range(5):
for y in range(5): arr[0][z][y] = list(map(int, input()))
input()
a, b = [0]*27, [0]*27
ts = list(map(int, input().split()))
for t in ts[1:]: a[t] = 1
ts = list(map(int, input().split()))
for t in ts[1:]: b[t] = 1
for j in range(n):
for z in range(5):
for y in range(5):
for x in range(5):
s = 0;
for i in range(26):
xx, yy, zz = x+mv[i][0], y+mv[i][1], z+mv[i][2]
if xx >= 0 and xx < 5 and yy >= 0 and yy < 5 and zz >= 0 and zz < 5:
s += arr[j&1][zz][yy][xx] & 1
if arr[j&1][z][y][x] & 1: arr[1-(j&1)][z][y][x] = b[s]
else: arr[1-(j&1)][z][y][x] = a[s]
if cno: print()
cno += 1
print("Case ", cno, ":", sep='')
for z in range(5):
if z > 0: print()
for y in range(5): print(*arr[n&1][z][y], sep='')
|
s276344889 | p01000 | u847467233 | 1531458012 | Python | Python3 | py | Runtime Error | 2240 | 5644 | 1262 | # AOJ 1510 Independent Research
# Python3 2018.7.13 bal4u
mv = [[-1,-1,-1],[-1,-1,0],[-1,-1,1],[-1,0,-1],[-1,0,0],[-1,0,1],[-1,1,-1],[-1,1,0],[-1,1,1],
[0,-1,-1],[0,-1,0],[0,-1,1],[0,0,-1],[0,0,1],[0,1,-1],[0,1,0],[0,1,1],
[1,-1,-1],[1,-1,0],[1,-1,1],[1,0,-1],[1,0,0],[1,0,1],[1,1,-1],[1,1,0],[1,1,1]]
cno = 0
arr = [[[[0 for x in range(5)] for y in range(5)] for z in range(5)] for k in range(2)]
while True:
n = int(input())
if n == 0: break
for z in range(5):
if z > 0: input()
for y in range(5): arr[0][z][y] = list(map(int, input()))
a, b = [0]*27, [0]*27
ts = list(map(int, input().split()))
for t in ts[1:]: a[t] = 1
ts = list(map(int, input().split()))
for t in ts[1:]: b[t] = 1
for j in range(n):
for z in range(5):
for y in range(5):
for x in range(5):
s = 0;
for i in range(26):
xx, yy, zz = x+mv[i][0], y+mv[i][1], z+mv[i][2]
if xx >= 0 and xx < 5 and yy >= 0 and yy < 5 and zz >= 0 and zz < 5:
s += arr[j&1][zz][yy][xx] & 1
if arr[j&1][z][y][x] & 1: arr[1-(j&1)][z][y][x] = b[s]
else: arr[1-(j&1)][z][y][x] = a[s]
if cno: print()
cno += 1
print("Case ", cno, ":", sep='')
for z in range(5):
if z > 0: print()
for y in range(5): print(*arr[n&1][z][y], sep='')
|
s098882809 | p01006 | u605365762 | 1478082397 | Python | Python | py | Runtime Error | 0 | 0 | 1218 | # -*- coding:utf-8 -*-
import sys
def main():
data = []
while(True):
line = raw_input()
if not line: break
data.append(line)
for answer in proc(data):
print answer
def proc(data):
return [passwd for passwd in data if is_hitofude(passwd)]
def is_hitofude(text):
for first, second in get_pair(text):
if second == '': break
if not _can_slide(first, second):
return False
return True
def get_pair(text):
pair_list = list(text)
pair_list.reverse()
while(True):
if 2 <= len(pair_list):
yield (pair_list.pop(), pair_list[-1])
elif 1 == len(pair_list):
yield (pair_list.pop(), '')
else:
break
matrix = ["ABC",
"DEF",
"GHI"]
pair = []
for y, row in enumerate(matrix):
for x, base in enumerate(row):
if x+1 < len(row): pair.append((base, row[x+1])) #EF
if 0 <= x-1 : pair.append((base, row[x-1])) #ED
if y+1 < 3: pair.append((base, matrix[y+1][x])) #EH
if 0 <= y-1: pair.append((base, matrix[y-1][x])) #EB
def _can_slide(first, second):
return (first, second) in pair
if __name__ == '__main__':
main() |
s335409842 | p01006 | u605365762 | 1478082508 | Python | Python | py | Runtime Error | 0 | 0 | 1231 | # -*- coding:utf-8 -*-
import sys
def main():
data = []
while(True):
line = raw_input()
if not line: break
data.append(line)
for answer in proc(data):
print answer
return 0
def proc(data):
return [passwd for passwd in data if is_hitofude(passwd)]
def is_hitofude(text):
for first, second in get_pair(text):
if second == '': break
if not _can_slide(first, second):
return False
return True
def get_pair(text):
pair_list = list(text)
pair_list.reverse()
while(True):
if 2 <= len(pair_list):
yield (pair_list.pop(), pair_list[-1])
elif 1 == len(pair_list):
yield (pair_list.pop(), '')
else:
break
matrix = ["ABC",
"DEF",
"GHI"]
pair = []
for y, row in enumerate(matrix):
for x, base in enumerate(row):
if x+1 < len(row): pair.append((base, row[x+1])) #EF
if 0 <= x-1 : pair.append((base, row[x-1])) #ED
if y+1 < 3: pair.append((base, matrix[y+1][x])) #EH
if 0 <= y-1: pair.append((base, matrix[y-1][x])) #EB
def _can_slide(first, second):
return (first, second) in pair
if __name__ == '__main__':
main() |
s554284939 | p01006 | u605365762 | 1478082639 | Python | Python | py | Runtime Error | 0 | 0 | 1231 | # -*- coding:utf-8 -*-
import sys
def main():
data = []
while(True):
line = raw_input()
if not line: break
data.append(line)
for answer in proc(data):
print answer
return 0
def proc(data):
return [passwd for passwd in data if is_hitofude(passwd)]
def is_hitofude(text):
for first, second in get_pair(text):
if second == '': break
if not _can_slide(first, second):
return False
return True
def get_pair(text):
pair_list = list(text)
pair_list.reverse()
while(True):
if 2 <= len(pair_list):
yield (pair_list.pop(), pair_list[-1])
elif 1 == len(pair_list):
yield (pair_list.pop(), '')
else:
break
matrix = ["ABC",
"DEF",
"GHI"]
pair = []
for y, row in enumerate(matrix):
for x, base in enumerate(row):
if x+1 < len(row): pair.append((base, row[x+1])) #EF
if 0 <= x-1 : pair.append((base, row[x-1])) #ED
if y+1 < 3: pair.append((base, matrix[y+1][x])) #EH
if 0 <= y-1: pair.append((base, matrix[y-1][x])) #EB
def _can_slide(first, second):
return (first, second) in pair
if __name__ == '__main__':
main() |
s275221049 | p01006 | u605365762 | 1478082711 | Python | Python | py | Runtime Error | 0 | 0 | 1208 | import sys
def main():
data = []
while(True):
line = raw_input()
if not line: break
data.append(line)
for answer in proc(data):
print answer
return 0
def proc(data):
return [passwd for passwd in data if is_hitofude(passwd)]
def is_hitofude(text):
for first, second in get_pair(text):
if second == '': break
if not _can_slide(first, second):
return False
return True
def get_pair(text):
pair_list = list(text)
pair_list.reverse()
while(True):
if 2 <= len(pair_list):
yield (pair_list.pop(), pair_list[-1])
elif 1 == len(pair_list):
yield (pair_list.pop(), '')
else:
break
matrix = ["ABC",
"DEF",
"GHI"]
pair = []
for y, row in enumerate(matrix):
for x, base in enumerate(row):
if x+1 < len(row): pair.append((base, row[x+1])) #EF
if 0 <= x-1 : pair.append((base, row[x-1])) #ED
if y+1 < 3: pair.append((base, matrix[y+1][x])) #EH
if 0 <= y-1: pair.append((base, matrix[y-1][x])) #EB
def _can_slide(first, second):
return (first, second) in pair
if __name__ == '__main__':
main() |
s029438092 | p01006 | u633068244 | 1397005662 | Python | Python | py | Runtime Error | 0 | 0 | 214 | ref={"A":"BD","B":"ACE","C":"BF","D":"AEG","E":"BDFH","F":"CEI","G":"DH","H":"EGI","J":"HF"}
for i in range(1000):
p=raw_input()
for i in range(len(p)-1):
if p[i+1] not in ref[p[i]]:
break
else:
print p
|
s485008599 | p01008 | u847467233 | 1531466911 | Python | Python3 | py | Runtime Error | 410 | 5612 | 303 | # AOJ 1518: Last One
# Python3 2018.7.13 bal4u
ans = 0;
n = int(input())
for i in range(n):
p, ms = input().split();
ms = list(ms)
s = 0
for m in ms:
if m.isdigit(): s += int(m)
elif m.isupper(): s += ord(m)-ord('A')+10
else: s += ord(m)-ord('a')+36
ans ^= s
print("win" if ans else "lose")
|
s062955929 | p01040 | u539753516 | 1535989202 | Python | Python3 | py | Runtime Error | 30 | 6048 | 236 | import datetime
y1,m1,d1,y2,m2,d2=map(int,input().split())
q=(y2-y1)//400
y2-=400*q
a=688*q
d=datetime.date(y1,m1,d1)
while d<=datetime.date(y2,m2,d2):
if d.day==13 and d.weekday()==4:a+=1
d+=datetime.timedelta(days=1)
print(a)
|
s381107673 | p01040 | u539753516 | 1535989266 | Python | Python3 | py | Runtime Error | 30 | 6044 | 236 | import datetime
y1,m1,d1,y2,m2,d2=map(int,input().split())
q=(y2-y1)//400
y2-=400*q
a=688*q
d=datetime.date(y1,m1,d1)
while d<=datetime.date(y2,m2,d2):
if d.day==13 and d.weekday()==4:a+=1
d+=datetime.timedelta(days=1)
print(a)
|
s472119324 | p01048 | u885631908 | 1442946655 | Python | Python3 | py | Runtime Error | 20 | 7636 | 359 | #!/usr/bin/env python3
# -*- coding: utf-8 -*-
n = int(input())
i = 1
num = [0] * 13 #num[i] -> ?´???°???i???????????°??§????°??????°
while True:
cnt = 0
for j in range(1, i+1):
if i % j == 0:
cnt += 1
if num[cnt] == 0:
num[cnt] = i
if num[n] > 0:
ans = num[n]
break
i += 1
print(ans) |
s691926428 | p01052 | u847467233 | 1531481277 | Python | Python3 | py | Runtime Error | 20 | 5600 | 362 | # AOJ 1566 Movie
# Python3 2018.7.13 bal4u
n = int(input())
tbl = []
for i in range(n):
a, b = map(int, input().split())
tbl.append([b, a])
tbl.sort()
ans = saw = 0
seen = [0]*32
for i in range(1, 32):
for j in range(n):
if i < tbl[j][1] or tbl[j][0] < i: continue
if seen[j]: continue
ans += 100; seen[j] = 1; saw += 1
break;
print(ans+(31-saw)*50)
|
s141453435 | p01085 | u946263060 | 1530610989 | Python | Python3 | py | Runtime Error | 0 | 0 | 338 | N = input().split(" ")
a = [input() for i in range(int(N[0]))]
ma =int(N[2])
mi =int(N[1])
gap = []
x = mi
while x != ma + 1:
value = int(a[x - 1]) - int(a[x])
gap.append(value)
x = x + 1
import numpy as np
gapIndex = np.array(gap)
maxIndex = [i for i, x in enumerate(gapIndex) if x == max(gapIndex)]
print(int(maxIndex[0]) + 2)
|
s636481102 | p01085 | u946263060 | 1530613319 | Python | Python3 | py | Runtime Error | 0 | 0 | 546 | import numpy as np
while true:
N = input().split(" ")
if N[0] == 0:
break
a = [input() for i in range(int(N[0]))]
print(N)
print(a)
#b = int(a[int(N[1]) - 1]) - int(a[int(N[1])])
#print(b)
ma = int(N[2])
mi = int(N[1])
gap = []
x = mi
while x != ma + 1:
value = int(a[x - 1]) - int(a[x])
gap.append(value)
x = x + 1
#print(gap)
gapIndex = np.array(gap)
maxIndex = [i for i, x in enumerate(gapIndex) if x == max(gapIndex)]
print(int(maxIndex[0]) + 2)
|
s523785562 | p01085 | u100935362 | 1530663920 | Python | Python3 | py | Runtime Error | 0 | 0 | 504 | head = input().split(" ")
while head != "0 0 0":
num = int(head[0])
mini = int(head[1])
maxi = int(head[2])
scores = []
gaps = []
for i in range(int(head[0])):
scores.append(int(input()))
for i in range(mini, maxi):
oks = scores[:i]
ngs = scores[i:]
gap = oks[-1] - ngs[0]
gaps.append((i,gap))
filtered = list(filter(lambda x: x[1] == max(gaps), gaps))
sorted(filtered, lambda x: x[0], True)
print(filtered[0][0])
|
s887273046 | p01085 | u100935362 | 1530664538 | Python | Python3 | py | Runtime Error | 0 | 0 | 527 | head = input().split(" ")
while head != "0 0 0":
num = int(head[0])
mini = int(head[1])
maxi = int(head[2])
scores = []
gaps = []
for _ in range(int(head[0])):
scores.append(int(input()))
for i in range(mini, maxi + 1):
oks = scores[:i]
ngs = scores[i:]
gap = oks[-1] - ngs[0]
gaps.append((i,gap))
filtered = list(filter(lambda x: x[1] == max(map(lambda x: x[1], gaps)), gaps))
sorted(filtered,key=lambda x: x[0])
print(filtered[-1][0])
|
s139021500 | p01085 | u100935362 | 1530664642 | Python | Python3 | py | Runtime Error | 0 | 0 | 531 | head = input().split(" ")
while head != "0 0 0":
num = int(head[0])
mini = int(head[1])
maxi = int(head[2])
scores = []
gaps = []
for _ in range(int(head[0]) + 1):
scores.append(int(input()))
for i in range(mini, maxi + 1):
oks = scores[:i]
ngs = scores[i:]
gap = oks[-1] - ngs[0]
gaps.append((i,gap))
filtered = list(filter(lambda x: x[1] == max(map(lambda x: x[1], gaps)), gaps))
sorted(filtered,key=lambda x: x[0])
print(filtered[-1][0])
|
s192556215 | p01085 | u100935362 | 1530664887 | Python | Python3 | py | Runtime Error | 0 | 0 | 628 | answers = []
while True:
head = input()
if head == "0 0 0":
break
nums = head.split(" ")
num = int(head[0])
mini = int(head[1])
maxi = int(head[2])
scores = []
gaps = []
for _ in range(int(head[0])):
scores.append(int(input()))
for i in range(mini, maxi + 1):
oks = scores[:i]
ngs = scores[i:]
gap = oks[-1] - ngs[0]
gaps.append((i,gap))
filtered = list(filter(lambda x: x[1] == max(map(lambda x: x[1], gaps)), gaps))
sorted(filtered,key=lambda x: x[0])
answers.append(filtered[-1][0])
for i in answers:
print(i)
|
s025189554 | p01085 | u100935362 | 1530664917 | Python | Python3 | py | Runtime Error | 0 | 0 | 628 | answers = []
while True:
head = input()
if head == "0 0 0":
break
nums = head.split(" ")
num = int(nums[0])
mini = int(nums[1])
maxi = int(nums[2])
scores = []
gaps = []
for _ in range(int(head[0])):
scores.append(int(input()))
for i in range(mini, maxi + 1):
oks = scores[:i]
ngs = scores[i:]
gap = oks[-1] - ngs[0]
gaps.append((i,gap))
filtered = list(filter(lambda x: x[1] == max(map(lambda x: x[1], gaps)), gaps))
sorted(filtered,key=lambda x: x[0])
answers.append(filtered[-1][0])
for i in answers:
print(i)
|
s589918536 | p01085 | u100935362 | 1530665231 | Python | Python3 | py | Runtime Error | 0 | 0 | 671 | answers = []
while True:
head = input()
if head == "0 0 0":
break
nums = head.split(" ")
num = int(nums[0])
mini = int(nums[1])
maxi = int(nums[2])
scores = []
gaps = []
for _ in range(int(head[0])):
scores.append(int(input()))
for i in range(mini, maxi + 1):
oks = scores[:i]
ngs = scores[i:]
if len(oks) and len(ngs):
gap = oks[-1] - ngs[0]
gaps.append((i,gap))
filtered = list(filter(lambda x: x[1] == max(map(lambda x: x[1], gaps)), gaps))
sorted(filtered,key=lambda x: x[0])
answers.append(filtered[-1][0])
for i in answers:
print(i)
|
s786122745 | p01086 | u572046143 | 1527956780 | Python | Python3 | py | Runtime Error | 0 | 0 | 1335 | def main():
while True:
n = int(input().strip())
if n == 0:
break
phrases = []
for _ in range(n):
word = input().strip()
phrases.append(word)
PHRASE_LEN = [5,7,5,7,7]
found_flag = False
for i in range(n):
acc_len = 0
phrase_idx = 0
for j in range(i, n):
acc_len += len(phrases[j])
if acc_len == PHRASE_LEN[phrase_idx]:
if phrase_idx == (len(PHRASE_LEN)-1):
found_flag = True
break
acc_len = 0
phrase_idx += 1
elif acc_len > PHRASE_LEN[phrase_idx]:
break
if found_flag:
print(i+1)
break
if __name__ == "__main__":
main()
~
~
~
|
s047049858 | p01086 | u572046143 | 1527956866 | Python | Python3 | py | Runtime Error | 0 | 0 | 1335 | def main():
while True:
n = int(input().strip())
if n == 0:
break
phrases = []
for _ in range(n):
word = input().strip()
phrases.append(word)
PHRASE_LEN = [5,7,5,7,7]
found_flag = False
for i in range(n):
acc_len = 0
phrase_idx = 0
for j in range(i, n):
acc_len += len(phrases[j])
if acc_len == PHRASE_LEN[phrase_idx]:
if phrase_idx == (len(PHRASE_LEN)-1):
found_flag = True
break
acc_len = 0
phrase_idx += 1
elif acc_len > PHRASE_LEN[phrase_idx]:
break
if found_flag:
print(i+1)
break
if __name__ == "__main__":
main()
~
~
~
|
s390056250 | p01087 | u724963150 | 1496327175 | Python | Python3 | py | Runtime Error | 0 | 0 | 1379 | while True:
n=int(input())
if n==0:
break;
li=[input() for i in range(n)]
index=0
def pls(depth):
k=0
global index
while len(li[index])>depth and li[index][depth-1]=='.':
if (not li[index][depth]=='+') and (not li[index][depth]=='*'):
k+=int(li[index][depth])
if not index==n-1:
index+=1
else:
return k
elif li[index][depth]=='+':
index+=1
k+=pls(depth+1)
elif li[index][depth]=='*':
index+=1
k+=prd(depth+1)
else:
return k
def prd(depth):
k=1
global index
while len(li[index])>depth and li[index][depth-1]=='.':
if (not li[index][depth]=='+') and (not li[index][depth]=='*'):
k*=int(li[index][depth])
if not index==n-1:
index+=1
else:
return k
elif li[index][depth]=='+':
index+=1
k*=pls(depth+1)
elif li[index][depth]=='*':
index+=1
k*=prd(depth+1)
else:
return k
if li[0]=='+':
index+=1
print(pls(1))
elif li[0]=='*':
index+=1
print(prd(1)) |
s247136782 | p01087 | u731941832 | 1530458160 | Python | Python3 | py | Runtime Error | 0 | 0 | 824 | while True:
n = int(input())
if n == 0:break
a = [input() for _ in range(n)]
while True:
if len(a) == 1:break
c = 0
s = 0
for i in range(len(a)):
if a[i].count('.') > c:
c = a[i].count('.')
s = i
e = s
while e < len(a) and a[e].count('.') == a[s].count('.'):
e += 1
k = a[s - 1]
k.remove('.')
b = [a[i] for i in range(s, e)]
for i in len(b):
b[i].remove('.')
b[i] = int(b[i])
if k == '+':
a[s] = '.'*a[s].count('.')+str(sum(b))
del a[s + 1:e]
else:
m = 1
for i in b:
m *= i
a[s] = '.'*a[s].count('.')+str(m)
del a[s + 1:e]
print(a[0])
|
s680831152 | p01087 | u731941832 | 1530458477 | Python | Python3 | py | Runtime Error | 0 | 0 | 807 | while True:
n = int(input())
if n == 0:break
a = [input() for _ in range(n)]
while True:
if len(a) == 1:break
c = 0
s = 0
for i in range(len(a)):
if a[i].count('.') > c:
c = a[i].count('.')
s = i
e = s
while e < len(a) and a[e].count('.') == a[s].count('.'):
e += 1
k = a[s - 1].replace('.', '')
b = [a[i] for i in range(s, e)]
for i in len(b):
b[i] = int(b[i].replace('.', ''))
if k == '+':
a[s] = '.'*a[s].count('.')+str(sum(b))
del a[s + 1:e]
else:
m = 1
for i in b:
m *= i
a[s] = '.'*a[s].count('.')+str(m)
del a[s + 1:e]
print(a[0])
|
s925622797 | p01087 | u731941832 | 1530458526 | Python | Python3 | py | Runtime Error | 0 | 0 | 814 | while True:
n = int(input())
if n == 0:break
a = [input() for _ in range(n)]
while True:
if len(a) == 1:break
c = 0
s = 0
for i in range(len(a)):
if a[i].count('.') > c:
c = a[i].count('.')
s = i
e = s
while e < len(a) and a[e].count('.') == a[s].count('.'):
e += 1
k = a[s - 1].replace('.', '')
b = [a[i] for i in range(s, e)]
for i in range(len(b)):
b[i] = int(b[i].replace('.', ''))
if k == '+':
a[s] = '.'*a[s].count('.')+str(sum(b))
del a[s + 1:e]
else:
m = 1
for i in b:
m *= i
a[s] = '.'*a[s].count('.')+str(m)
del a[s + 1:e]
print(a[0])
|
s516783726 | p01087 | u467175809 | 1530533849 | Python | Python | py | Runtime Error | 0 | 0 | 1096 | #!/usr/bin/env python
from collections import deque
import itertools as it
import sys
import math
while True:
n = input()
lst = []
if n == 0:
break
if n == 1:
num = input()
print num
continue
for loop in range(n):
S = raw_input()
lst.append((len(S), S[-1]))
n += 1
c_lst = [0 for i in range(1000)]
v_lst = [0 for i in range(1000)]
rank = 1
for i in range(n):
r = lst[i][0]
c = lst[i][1]
while r < rank:
if c_lst[rank - 1] == '+':
v_lst[rank - 1] += v_lst[rank]
else:
v_lst[rank - 1] *= v_lst[rank]
rank -= 1
if c == '+':
r += 1
c_lst[r] = '+'
v_lst[r] = 0
rank += 1
continue
elif c == '*':
r += 1
c_lst[r] = '*'
v_lst[r] = 1
rank += 1
continue
if c_lst[r] == '+':
v_lst[r] += int(c)
else:
v_lst[r] *= int(c)
print v_lst[2]
|
s225659316 | p01088 | u659302741 | 1479646266 | Python | Python3 | py | Runtime Error | 40000 | 156120 | 3326 | from operator import itemgetter
def compute(prices, max_sum_having_coin):
"""
DP
t?????????????????????????????????????????????????????£???????????????t??¨?????¶???
????????§??????????????\???????????????
??????t???????????????500?????????????????°???ct???????????\????????¬??¨???????¨????st??§?????????????????????????????????????????§
???????????§???????????£????????????????°?????????????????????¨??????????????????????????????????????????i(i < t)??§???
500?????????????????°???ci, ????????\????????¬??¨???????¨????si??§????????¨????????¨??????????????§???????????£????????????????????¶?????¨???????????????????????§????°???§?????????
??????????°?????????????????????????????????¨?????????????????????t??????????????????????°?????????????????????????????????¨???????????¨??????????????????
"""
n = len(prices)
m = max_sum_having_coin
# table[i][j] = ??????i???????????¬??¨j???????????? (500??????????????§???, 500??????????????§?????¨????????¨??????????????£????????????????°????)
table = []
for i in range(n + 1):
table.append([None] * (m + 1))
table[0][0] = (0, 0)
for i in range(1, n + 1):
for j in range(0, m + 1):
price = prices[i - 1]
states = []
# ?????\???500?????????????????\???????????¨???
if price % 1000 != 0 and j >= 500 - price % 500:
temp = table[i - 1][j - (500 - price % 500)]
if temp != None:
states.append((temp[0], temp[1] + price))
# ?????\???????????¨???
temp = table[i - 1][j]
if temp != None:
states.append(temp)
# ?????\???500?????????????????\????????¨???
if price % 1000 == 0:
if j + 500 <= m:
temp = table[i - 1][j + 500]
if temp != None:
states.append((temp[0] + 1, temp[1] + price))
elif price % 1000 <= 500:
temp = table[i - 1][j - (500 - price % 500)]
if temp != None:
states.append((temp[0] + 1, temp[1] + price))
elif j + price % 500 <= m:
temp = table[i - 1][j + price % 500]
if temp != None:
states.append((temp[0] + 1, temp[1] + price))
if len(states) > 0:
states.sort(key=itemgetter(1))
states.sort(key=itemgetter(0), reverse=True)
table[i][j] = states[0]
max_state = None
for j in range(0, m + 1):
state = table[n][j]
if state == None:
continue
if max_state == None or state[0] > max_state[0] or (state[0] == max_state[0] and state[1] < max_state[1]):
max_state = state
return max_state
while True:
n = int(input())
if n == 0:
break
prices = []
for i in range(n):
prices.append(int(input()))
# ???????????????????????????500????????\????????????????????????????¨??????????500??????????¢?????????????
# ????????°????????????n????????§?????????????????????????¨????????????? 500 * n ??§??????
max_sum_having_coin = 500 * n
result = compute(prices, max_sum_having_coin)
print(result[0], result[1]) |
s787818687 | p01088 | u659302741 | 1479652250 | Python | Python3 | py | Runtime Error | 40000 | 84348 | 3772 | from operator import itemgetter
def compare(state1, state2):
if state1 == None:
return False
if state2 == None:
return True
return state1[0] > state2[0] or (state1[0] == state2[0] and state1[1] < state2[1])
def compute(prices, max_sum_having_coin):
"""
DP
t?????????????????????????????????????????????????????£???????????????t??¨?????¶???
????????§??????????????\???????????????
??????t???????????????500?????????????????°???ct???????????\????????¬??¨???????¨????st??§?????????????????????????????????????????§
???????????§???????????£????????????????°?????????????????????¨??????????????????????????????????????????i(i < t)??§???
500?????????????????°???ci, ????????\????????¬??¨???????¨????si??§????????¨????????¨??????????????§???????????£????????????????????¶?????¨???????????????????????§????°???§?????????
??????????°?????????????????????????????????¨?????????????????????t??????????????????????°?????????????????????????????????¨???????????¨??????????????????
"""
n = len(prices)
m = max_sum_having_coin
# table[i][j] = ??????i???????????¬??¨j???????????? (500??????????????§???, 500??????????????§?????¨????????¨??????????????£????????????????°????)
table = []
for i in range(n + 1):
table.append([None] * (m + 1))
table[0][0] = (0, 0)
for i in range(1, n + 1):
price = prices[i - 1]
for j in range(0, m + 1):
state = None
# ?????\???500?????????????????\???????????¨???
if price % 1000 != 0 and j >= 500 - price % 500:
temp = table[i - 1][j - (500 - price % 500)]
if temp != None:
temp = (temp[0], temp[1] + price)
if compare(temp, state):
state = temp
# ?????\???????????¨???
temp = table[i - 1][j]
if temp != None and compare(temp, state):
state = temp
# ?????\???500?????????????????\????????¨???
if price % 1000 == 0:
if j + 500 <= m:
temp = table[i - 1][j + 500]
if temp != None:
temp = (temp[0] + 1, temp[1] + price)
if compare(temp, state):
state = temp
elif price % 1000 <= 500:
temp = table[i - 1][j - (500 - price % 500)]
if temp != None:
temp = (temp[0] + 1, temp[1] + price)
if compare(temp, state):
state = temp
elif j + price % 500 <= m:
temp = table[i - 1][j + price % 500]
if temp != None:
temp = (temp[0] + 1, temp[1] + price)
if compare(temp, state):
state = temp
if state != None:
table[i][j] = state
max_state = None
for j in range(0, m + 1):
state = table[n][j]
if state == None:
continue
if compare(state, max_state):
max_state = state
return max_state
# results = []
while True:
n = int(input())
if n == 0:
break
prices = []
for i in range(n):
prices.append(int(input()))
# ???????????????????????????500????????\????????????????????????????¨??????????500??????????¢?????????????
# ????????°????????????n????????§?????????????????????????¨????????????? 500 * n ??§??????
# max_sum_having_coin = 500 * n
max_sum_having_coin = 10000
result = compute(prices, max_sum_having_coin)
# results.append(result)
print(result[0], result[1])
# for r in results:
# print(r) |
s055263711 | p01088 | u408260374 | 1495271269 | Python | Python3 | py | Runtime Error | 40000 | 198036 | 887 | MAX_COINS = 500 * 100
INF = 10 ** 9
def dfs(idx, coins):
if idx == N:
return 0, 0
elif dp[idx][coins] != -1:
return dp[idx][coins]
ret = (0, -INF)
# not buy
ret = max(ret, dfs(idx + 1, coins))
# buy using only bills
change = (1000 - P[idx] % 1000) % 1000
cand, money = dfs(idx + 1, coins + change % 500)
ret = max(ret, (cand + (change >= 500), money - P[idx]))
# buy using both and get 500
if (P[idx] + 500) % 1000 <= coins:
cand, money = dfs(idx + 1, coins - (P[idx] + 500) % 1000)
ret = max(ret, (cand + 1, money - P[idx]))
dp[idx][coins] = ret
# print(idx, coins, ret)
return ret
while True:
N = int(input())
if not N:
break
P = [int(input()) for _ in range(N)]
dp = [[-1] * (MAX_COINS + 1) for _ in range(N + 1)]
ans, money = dfs(0, 0)
print(ans, -money) |
s249232320 | p01088 | u408260374 | 1495271393 | Python | Python | py | Runtime Error | 40000 | 197036 | 961 | import sys
if sys.version[0] == '2':
range, input = xrange, raw_input
MAX_COINS = 500 * 100
INF = 10 ** 9
def dfs(idx, coins):
if idx == N:
return 0, 0
elif dp[idx][coins] != -1:
return dp[idx][coins]
ret = (0, -INF)
# not buy
ret = max(ret, dfs(idx + 1, coins))
# buy using only bills
change = (1000 - P[idx] % 1000) % 1000
cand, money = dfs(idx + 1, coins + change % 500)
ret = max(ret, (cand + (change >= 500), money - P[idx]))
# buy using both and get 500
if (P[idx] + 500) % 1000 <= coins:
cand, money = dfs(idx + 1, coins - (P[idx] + 500) % 1000)
ret = max(ret, (cand + 1, money - P[idx]))
dp[idx][coins] = ret
# print(idx, coins, ret)
return ret
while True:
N = int(input())
if not N:
break
P = [int(input()) for _ in range(N)]
dp = [[-1] * (MAX_COINS + 1) for _ in range(N + 1)]
ans, money = dfs(0, 0)
print(ans, -money) |
s727032503 | p01088 | u408260374 | 1495271478 | Python | Python3 | py | Runtime Error | 40000 | 198080 | 992 | import sys
if sys.version[0] == '2':
range, input = xrange, raw_input
sys.setrecursionlimit(10 ** 6)
MAX_COINS = 500 * 100
INF = 10 ** 9
def dfs(idx, coins):
if idx == N:
return 0, 0
elif dp[idx][coins] != -1:
return dp[idx][coins]
ret = (0, -INF)
# not buy
ret = max(ret, dfs(idx + 1, coins))
# buy using only bills
change = (1000 - P[idx] % 1000) % 1000
cand, money = dfs(idx + 1, coins + change % 500)
ret = max(ret, (cand + (change >= 500), money - P[idx]))
# buy using both and get 500
if (P[idx] + 500) % 1000 <= coins:
cand, money = dfs(idx + 1, coins - (P[idx] + 500) % 1000)
ret = max(ret, (cand + 1, money - P[idx]))
dp[idx][coins] = ret
# print(idx, coins, ret)
return ret
while True:
N = int(input())
if not N:
break
P = [int(input()) for _ in range(N)]
dp = [[-1] * (MAX_COINS + 1) for _ in range(N + 1)]
ans, money = dfs(0, 0)
print(ans, -money) |
s301182263 | p01088 | u408260374 | 1495271529 | Python | Python | py | Runtime Error | 40000 | 196968 | 992 | import sys
if sys.version[0] == '2':
range, input = xrange, raw_input
sys.setrecursionlimit(10 ** 6)
MAX_COINS = 500 * 100
INF = 10 ** 9
def dfs(idx, coins):
if idx == N:
return 0, 0
elif dp[idx][coins] != -1:
return dp[idx][coins]
ret = (0, -INF)
# not buy
ret = max(ret, dfs(idx + 1, coins))
# buy using only bills
change = (1000 - P[idx] % 1000) % 1000
cand, money = dfs(idx + 1, coins + change % 500)
ret = max(ret, (cand + (change >= 500), money - P[idx]))
# buy using both and get 500
if (P[idx] + 500) % 1000 <= coins:
cand, money = dfs(idx + 1, coins - (P[idx] + 500) % 1000)
ret = max(ret, (cand + 1, money - P[idx]))
dp[idx][coins] = ret
# print(idx, coins, ret)
return ret
while True:
N = int(input())
if not N:
break
P = [int(input()) for _ in range(N)]
dp = [[-1] * (MAX_COINS + 1) for _ in range(N + 1)]
ans, money = dfs(0, 0)
print(ans, -money) |
s232447923 | p01088 | u339921062 | 1499236979 | Python | Python | py | Runtime Error | 0 | 0 | 876 | while 1:
n = input()
if n == 0:
break
dp = [[None]*2001 for i in xrange(n+1)]
dp[0][0] = (0, 0)
for i in xrange(n):
cost = int(raw_input())
dost = cost % 1000
for j in xrange(2001):
if dp[i][j] is None:
continue
c, s = dp[i][j]
dp[i+1][j] = max(dp[i][j], dp[i+1][j])
if dost == 0:
if j >= 500:
dp[i+1][j + (500 - dost)] = max(dp[i+1][j + (500 - dost)], (c+1, s-cost))
else:
dp[i+1][j] = max(dp[i+1][j], (c, s-cost))
elif 1 <= dost <= 500+j:
dp[i+1][j + (500 - dost)] = max(dp[i+1][j + (500 - dost)], (c+1, s-cost))
else:
dp[i+1][j + (1000 - dost)] = max(dp[i+1][j + (1000 - dost)], (c, s-cost))
c, s = max(dp[n])
print c, -s |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.