Implementing an algorithm for calculating resistances between two arbitrary points on a circuit board seems like a complex problem to solve in a short period of time. Luckily, [someone already solved it](https://gist.github.com/aelguindy/1747940) (and in Python too!) :-) The only thing that is left is to add scaffolding that parses the inputs, and collects and returns the answers:
```python# portion of the code "borrowed" from https://gist.github.com/aelguindy/1747940
import ssl, socket
def gauss_jordan(m, eps = 1.0/(10**10)):  """Puts given matrix (2D array) into the Reduced Row Echelon Form.     Returns True if successful, False if 'm' is singular.     NOTE: make sure all the matrix items support fractions! Int matrix will NOT work!     Written by Jarno Elonen in April 2005, released into Public Domain"""  (h, w) = (len(m), len(m[0]))  for y in range(0,h):    maxrow = y    for y2 in range(y+1, h):    # Find max pivot      if abs(m[y2][y]) > abs(m[maxrow][y]):        maxrow = y2    (m[y], m[maxrow]) = (m[maxrow], m[y])    if abs(m[y][y]) <= eps:     # Singular?      return False    for y2 in range(y+1, h):    # Eliminate column y      c = m[y2][y] / m[y][y]      for x in range(y, w):        m[y2][x] -= m[y][x] * c  for y in range(h-1, 0-1, -1): # Backsubstitute    c  = m[y][y]    for y2 in range(0,y):      for x in range(w-1, y-1, -1):        m[y2][x] -=  m[y][x] * m[y2][y] / c    m[y][y] /= c    for x in range(h, w):       # Normalize row y      m[y][x] /= c  return True
def preprocess(edges, V):    lists = []    for i in range(V): lists.append([])    for fro, to, res in edges:        lists[fro].append((to, res))        lists[to].append((fro, res))    return lists
def make_eqns(lists, node1, node2):    coeffs = []    Vars = len(lists)    for i, l in enumerate(lists):        cs = [0.0]*Vars        cs[i] = sum(1/b for (a, b) in l)        for other, res in l:            cs[other] -= 1.0/res        coeffs.append(cs)    rhs = [0] * Vars    rhs[node1] = 1.0    rhs[node2] = -1.0    n = max(node1, node2)    coeffs = [c[:n] + c[n + 1:] for c in coeffs]    return coeffs[:-1], rhs[:-1]
def calculate_resistance(nodes, edges, source, destination):    src = source    dst = destination    ls = preprocess(edges, nodes)    a, b = make_eqns(ls, src, dst)    M = [a[i] + [b[i]] for i in range(len(a))]    gauss_jordan(M)    return abs(M[min(src, dst)][-1])  class Connect(object):    def __init__(self, host, port):        self.context = ssl.create_default_context()        self.conn = self.context.wrap_socket(            socket.socket(socket.AF_INET),            server_hostname=host)        self.conn.connect((host, port))        self.f = self.conn.makefile('rwb', 0)    def __enter__(self):        return self.f    def __exit__(self, type, value, traceback):        self.f.close()
dim = 0conns = []results = []
with Connect('programming.pwn2win.party', 9001) as f:	for line in f:		line = line.strip()		tuple = line.split()		print line 		# parse resistances		if len(tuple) == 3:			conn = (int(tuple[0])-1,int(tuple[1])-1,float(tuple[2]))			conns.append(conn)			if conn[0]+1 > dim:				dim = conn[0]+1			if conn[1]+1 > dim:				dim = conn[1]+1		# parse paths		if len(tuple) == 2:			start = int(tuple[0])-1			end = int(tuple[1])-1			if start == end:				# resistance from point to itself is 0				val = 0			else:				val = calculate_resistance(dim, conns, start, end)			results.append(val)		
		if line == "":			print "-end of data-" 			for x in results:				val = "%.3f" % x				f.write(('%s\n' % val).encode('utf-8'))				print val 			dim = 0			conns = []			results = []```
The flag is ```CTF-BR{Us1n6_R3s1S73NCe_d1s7AnCe_15_3x7R3Me1y_us3ful1_in_p8ysIC5}```