def solve(N, ss): f = 0 c = 0 for i, s in enumerate(ss): if c < i: f += i - c c += i - c
c += s
return f, c
for i in range(T): N, S = fin.readline().split() ss = [] for j in range(int(N)+1): ss.append(int(S[j])) solution = solve(int(N), ss) answer = "Case #%d: %s\n" % (i+1, solution[0]) print answer fout.write(answer)
def mult(qs): r = q('1') for vq in qs: r = r * vq return r
def mult_table(table, vs, a, b, indices): key = str(a) + ',' + str(b) if table.has_key(key): return table[key] else: cs = [x for x in indices if a < x < b] if not cs: value = mult(vs[a:b]) else: c = cs[len(cs)/2] value = mult_table(table, vs, a, c, indices) * mult_table(table, vs, c, b, indices) #print key, value, a, c, b table[key] = value return value
#print q('i') * q('j'), q('j') * q('k'), q('i') * q('j') * q('k') def solve(L, X, ijk): fqs = [] for i in ijk: if i == 'i' or i == 'j' or i == 'k': fqs.append(q(i)) qs = [] X = X % 16 extend = min(X, 4) for i in range(extend): qs.extend(fqs)
print qs lq = q('1') left_plus = [] left_minus = [] for i_l, l in enumerate(qs): # print lq, l lq = nx = lq * l if nx == q('i'): left_plus = [i_l+1, nx, l] if nx == -q('i'): left_minus = [i_l+1, nx, l] if left_plus and left_minus: break right_plus = [] right_minus = [] rq = q('1') for i_r, r in enumerate(reversed(qs)): rq = nx = r * rq if nx == q('k'): right_plus = [i_r+1, nx, r] elif nx == -q('k'): right_minus = [i_r+1, nx, r] if right_plus and right_minus: break if (not left_plus) and not left_minus: return "NO" if not right_plus and not right_minus: return "NO" dqs = [] for idqs in range(X):#range(min(X, 8)): dqs.extend(fqs)
lefts = [] rights = []
mc = {} mfqs = mult(fqs) indices = [] if left_plus: indices.append(left_plus[0]) lefts.append(left_plus) if left_minus: indices.append(left_minus[0]) lefts.append(left_minus) if right_plus: indices.append(len(dqs) - right_plus[0]) rights.append(right_plus) if right_minus: indices.append(len(dqs) - right_minus[0]) rights.append(right_minus) for ie in range(8): index = ie * len(fqs) indices.append(index) mc[str(index) + ',' + str(index + len(fqs))] = mfqs sorted_indices = sorted(set(indices))
# prev = -1 # mc = mult_table(qs, sorted_indices) # for ii in sorted_indices: # for ij in sorted_indices[]: # if # if prev > 0 # mc[[prev, index]] = mult(qs[prev:index+1]) # prev = index print mfqs, mc, sorted_indices for j_l in lefts: for j_r in rights: if j_l[0] + j_r[0] < len(dqs) + 2: #isj = mult_table(mc, dqs, j_l[0], len(dqs)-j_r[0], sorted_indices) isj = mult(dqs[j_l[0] : len(dqs) - j_r[0] ]) #print j_l[1], isj, j_r[1], j_l[1] * isj * j_r[1] if j_l[1] * isj * j_r[1] == -q('1'): return "YES" # else: # j_left = mult(dqs[j_l[0] : -1]) # j_right = mult(dqs[0 : len(dqs) - j_r[0]]) # j_middle = q('1') # for k_d in range(min(X - 8, 4)): # j_middle = j_middle * mfqs # if j_l[1] * j_left * j_middle * j_right * j_r[1] == -q('1'): # return "YES" return "NO" for i in range(T): L, X = map(int, fin.readline().split()) ijk = fin.readline() solution = solve(L, X, ijk) # if solution > candidate: # print 'ERROR', i + 1, solution, candidate # if solution != solution1: # print 'ERROR', i + 1, solution, solution1, candidate answer = "Case #%d: %s\n" % (i + 1, solution) print answer fout.write(answer)
Gabriel = "GABRIEL" Richard = "RICHARD" def solve(X, R, C): if (R * C) % X != 0: print "%" return Richard if R < X and C < X: print "<" return Richard if X > 6: print "6" return Richard min_l = 1 + (X - 1) / 2 if X > 2 and (R < min_l or C < min_l): print "sqrt" return Richard snake = 2 + (X - 2) / 3 if X > 3 and (R <= snake or C <= snake): print "snake" if X == 4: return Richard elif X == 5 and (R < 5 and C < 5): return Richard elif X == 6 and (R < 7 and C < 7): return Richard
return Gabriel
for i in range(T): X, R, C = map(int, fin.readline().split()) print i+1, X, R, C
solution = solve(X, R, C) # if solution > candidate: # print 'ERROR', i + 1, solution, candidate # if solution != solution1: # print 'ERROR', i + 1, solution, solution1, candidate answer = "Case #%d: %s\n" % (i + 1, solution) print answer fout.write(answer)
def solve(outlets, plugs, N, L): #print outlets, plugs plugs.sort()
shuffle = [] switch = [] unknown = [] for i in range(L): ips = [(p >> i) % 2 for p in plugs] ios = [(o >> i) % 2 for o in outlets] print i, ips, ios if ips.count(1) == ios.count(1): if ips.count(1) == ips.count(0): unknown.append(i) elif ips.count(0) == ios.count(1): if ips.count(1) == ips.count(0): unknown.append(i) else: shuffle.append(i) else: return "NOT POSSIBLE" shuffled_outlets = outlets[:] for s in shuffle: shuffled_outlets = [o ^ pow(2, s) for o in shuffled_outlets]
result = len(shuffle) print plugs print shuffled_outlets
if plugs == shuffled_outlets: return str(result)
for i in range(len(unknown)): for j in itertools.combinations(unknown, i+1): shuffled_outlets2 = shuffled_outlets[:] for k in j: shuffled_outlets2 = [o ^ pow(2, k) for o in shuffled_outlets2] shuffled_outlets2.sort() #print shuffled_outlets if plugs == shuffled_outlets2: return str(result + i + 1)
return "NOT POSSIBLE" for i in range(T): N, L = map(int, fin.readline().split()) outlets = [int(n, 2) for n in (fin.readline().split())] plugs = [int(n, 2) for n in (fin.readline().split())] print 'o', outlets print 'p', plugs solution = solve(outlets, plugs, N, L) if N == 1 and solution == "NOT POSSIBLE": print "ERROR1" if solution != "NOT POSSIBLE" and N < int(solution): print "ERROR2" answer = "Case #%d: %s\n" % (i+1, solution) print answer fout.write(answer)
#sorted_star2_indices = [v[0] for v in sorted(enumerate(star2s), key=lambda x:x[1])] sorted_star2_indices = [v[0] for v in sorted(enumerate(star2s), cmp=greater)] sorted_star2_values = [v[1] for v in sorted(enumerate(star2s), cmp=greater)]
for i in range(T): N = int(fin.readline()) stars = [] completed = [] for j in range(N): stars.append(map(int, fin.readline().split())) completed.append(False)
#sys.stdout = open(os.devnull, 'w') T = int(fin.readline())
def bribe(rs, s, e): if not rs: return 0 if s >= e: return 0 center = (s + e) / 2.0 closest = e + 2 for i in rs: if abs(center - i) < abs(center - closest): closest = i
left = [a for a in rs if a < closest] right = [a for a in rs if a > closest] print s, e, closest, e - s, left, right return (e - s) + bribe(left, s, closest - 1) + bribe(right, closest + 1, e)
solutions = {} def dynamic_bribe(rs, s, e, space): if not rs: return "", 0 if s >= e: return '', 0 s0 = 1 e0 = e - s + 1 rs0 = [a - s + 1 for a in rs]
key = str(e0) + ':' + (',').join(str(a) for a in rs0) keystr = str(s) + '~' + str(e) + ':' + (',').join(str(a) for a in rs) solution = solutions.get(key) if solution: #print space, s, e, rs, solution, "key:" + key #return '\n' + space + '<' + keystr + '_' + str(solution) + '>\n', solution return '', solution else: candidate = sys.maxint way = "" for r in rs: left = [a for a in rs if a < r] right = [a for a in rs if a > r] left_way, lc = dynamic_bribe(left, s, r-1, space + ' ') right_way, rc = dynamic_bribe(right, r+1, e, space + ' ') cc = (e - s) + lc + rc if cc < candidate: candidate = cc way = '\n' + space + '<' + keystr + '_' + str(cc) + ',' + left_way + ',' + right_way + '>\n' solution = candidate solutions[key] = solution #print space, s, e, rs, solution #return way, solution return '', solution
#print dynamic_bribe([3], 1, 8, '') def solve(P, Q, rs): a = bribe(rs, 1, P) #print '' #if a != b: # print "DIFFERENT", a, b, a > b return a
def dynamic_solve(P, Q, rs): way, b = dynamic_bribe(rs, 1, P, '') print way return b
cases = [15]
for i in range(T): #if i > 3: # break solutions = {} P, Q = map(int, fin.readline().split()) rsline = fin.readline() rs = map(int, rsline.split())
#if i in cases: if True: print P, Q, rs #answer = solve(P, Q, rs) #line = "Case #%d: %s" % (i+1, str(answer)) #print line + '; ' + rsline + '\n' #f1out.write(line + '\n') answer2 = dynamic_solve(P, Q, rs) line2 = "Case #%d: %s" % (i+1, str(answer2)) print line2 + '; ' + rsline + '\n' fout.write(line2 + '\n')
도쿄 메트로 (본사 : 도쿄도 타이토 구 사장 : 안쪽 義光)는 일본의 철도 사업자로서 처음으로 전선 열차 위치, 지연 시간 등에 관한 정보를 오픈 데이터에서 공개하고 해당 데이터를 활용 한 앱 개발을 겨루는 「오픈 데이터 활용 콘테스트」를 2014 년 9 월 12 일 (금)부터 실시합니다. 그랑프리 상금 100 만엔, 도쿄 메트로를 이용하는 고객의 생활을보다 편리하고보다 쾌적하게 될거야 우나 "더 기쁘다"응용 모집합니다. 행정이나 기업이 보유한 데이터를 공개하고 누구나 활용 가능하여 사회와 경제를 활성화시키는 '오 뿐데타 "가 세계적으로 주목을 받고 있습니다. 일본에서는 2013 년 6 월에 "세계 최첨단 IT 국가 창조 선언 말 '이 각의 결정되어 2015 년도 말에는 다른 선진국 수준으로 공공 데이터를 공개하는 것을 목표로 공공 데이터의 오픈 데이터 화를 추진하기위한 노력이 이루어지고 있습니다. 도쿄 메트로에서는 창립 10 주년을 기념하고 대중 교통 사업자 스스로 실시하는 것으로는 일본에서 처음 둥지에서 에 홈페이지에서 공개하고있는 열차 시간표, 역으로 승강 인원, 장애인 등의 정보와 함께 열차 위치, 늦게 인시 등에 관한 정보를 오픈 데이터화하고 해당 데이터를 활용 한 애플리케이션 개발 콘테스트를 YRP 유비키 작업 · 네트워킹 연구소의 협력으로 실시합니다. 평소 도쿄 메트로를 이용하고있는 고객을 비롯하여 2020 년 도쿄 올림픽 빠라린삐 클릭 개최를 응시 해 일본은 물론 해외 고객에게도 편리한 앱 개발을 밀어줍니다
YRP 유비쿼터스 네트워킹 연구소 YRP 유비쿼터스 네트워킹은 주변의 모든 물건에 통신 능력을 가진 마이크로 컴퓨터 터와 센서, 액추에이터 등이 포함 된 그들이 서로 정보를 교환하면서 협업하고 사람 동안 생활을 더 높은 지원하는 유비쿼터스 컴퓨팅 환경을 구축 할뿐만 아니라, 그 기반과 차세대 통신 프로토콜을 확립하는 것을 목적으로 설립 된 연구소입니다.
RECENT COMMENT