def solve(limit, search_delta=0.3): lower = int(sqrt(limit) * (1 - search_delta)) upper = int(sqrt(limit) * (1 + search_delta)) primes = list(ibetween(gen_primes(), lower, upper)) info(f"Searching using prime factors {lower} < p < {upper}") result_n, result_q = None, inf for factors in combinations(primes, 2): n = prod(factors) if n > limit: continue phi_n = phi(n) if is_permutation(n, phi_n): q = n / phi_n if q < result_q: result_n, result_q = n, q info(f"n = {n}\tphi(n) = {phi_n}\tn/phi(n) = {q}") return result_n
def solve(target): for a in range(1, target // 2): for b in range(a + 1, target // 2): for c in range(b + 1, target // 2): if a + b + c == target and a * a + b * b == c * c: info(f"{a} + {b} + {c} = {target}") return a * b * c
def getTop100Keywords(site, query, max): keywordDict = {} site = site.lower() count = 0 q = queue.Queue(max + 1000) q.put(query) while not q.empty(): if count == max: break else: count += 1 keyword = q.get() relatedKeywords = [] if site == 'naver': relatedKeywords = search.searchRelatedKeywordNaver(keyword) elif site == 'daum': relatedKeywords = search.searchRelatedKeywordDaum(keyword) elif site == 'google': relatedKeywords = search.searchRelatedKeywordGoogle(keyword) log.info(keyword + ': ' + ','.join(relatedKeywords)) for relatedKeyword in relatedKeywords: if relatedKeyword == query: continue elif relatedKeyword in keywordDict.keys(): keywordDict[relatedKeyword] += 1 else: keywordDict[relatedKeyword] = 1 q.put(relatedKeyword) return keywordDict
def fetch(url): ''' return arbitrary URL data ''' filename = posixpath.split(url)[-1] logging.info('attempting to fetch %s', filename) filepath = os.path.join(STORAGE, filename) if filename.endswith(".zip"): unzippedname = filename[:-4] unzippedpath = os.path.join(STORAGE, unzippedname) if os.path.exists(unzippedpath): logging.debug('found cached content %s', unzippedpath) with open(unzippedpath, 'rb') as infile: return infile.read() if not os.path.exists(filepath): logging.info('fetching %s', url) with urlopen(url) as infile: with open(filepath, 'wb') as outfile: outfile.write(infile.read()) if filename.endswith(".zip"): zipped = zipfile.ZipFile(filepath) with zipped.open(unzippedname, 'r') as datafile: # 'rb' not accepted data = datafile.read() logging.debug('caching %s for next time', unzippedname) with open(unzippedpath, 'wb') as outfile: outfile.write(data) return data else: with open(filepath, 'rb') as infile: return infile.read()
def gen_partitions(): """Generates the partition sequence. This uses the Pentagonal number theorem: > The identity implies a marvelous recurrence for calculating p(n), the number of partitions of n: > p(n) = p(n-1) + p(n-2) - p(n-5) - p(n-7) + ... > > [...] the series will eventually become zeroes, enabling discrete calculation. * The sign follows the pattern --++ * The exponent coefficients are the generalized pentagonals - https://en.wikipedia.org/wiki/Partition_(number_theory) - https://en.wikipedia.org/wiki/Pentagonal_number_theorem - https://oeis.org/A000041 """ partitions = [1] signs = [1, 1, -1, -1] for n in count(): partitions.append(0) pentagonals = takewhile(lambda penta: penta <= n, gen_generalized_pentagonals()) for sign, penta in zip(cycle(signs), pentagonals): partitions[n] += sign * partitions[n - penta] if (partitions[n] == 0): break info(f"p({n})={partitions[n]}") yield partitions[n]
def solve(limit): products = set() for a in range(1, limit): digits_a = unique_digits(a) if not digits_a: continue for b in range(a + 1, limit): digits_b = unique_digits(b) if not digits_b: continue p = a * b digits_p = unique_digits(p) if not digits_p: continue no_common_digits = digits_a.isdisjoint(digits_b)\ and digits_b.isdisjoint(digits_p)\ and digits_p.isdisjoint(digits_a) contains_all_digits = (digits_a | digits_b | digits_p) == DIGITS if no_common_digits and contains_all_digits: info(f"{a} * {b} = {p}") products.add(p) return sum(products)
def solve(): result = 0 limit = 50_000 # Found by trial and error for n in range(3, limit): if n == digit_factorial(n): info(f"%s = {n}", " + ".join(map(lambda d: d + "!", (str(n))))) result += n return result
def solve(): limit = 10000 p = list(islice(gen_pentagonal(), limit)) ps = set(p) for j in range(1, limit): for k in range(j, limit): if p[k] - p[j] in ps and p[k] + p[j] in ps: info( f"Pk={p[k]}, Pj={p[j]}, Pk-Pj={p[k]-p[j]}, Pk+Pj={p[k]+p[j]}" ) return p[k] - p[j]
def solve(limit): max_primes = 0 coefficients = () for a, b in product(get_candidates(limit), repeat=2): primes = formula_primes(a, b) if len(primes) > max_primes: max_primes = len(primes) coefficients = (a, b) info(f"a={coefficients[0]}, b={coefficients[1]} yields {max_primes} primes") return prod(coefficients)
def solve(limit): divisor_sum = {} for n in range(limit): divisor_sum[n] = sum(proper_divisors(n)) result = 0 for a in range(1, limit): for b in range(a + 1, limit): if divisor_sum[a] == b and divisor_sum[b] == a: info(f"d({a}) = {b}\td({b}) = {a}") result += a + b return result
def solve(power, limit=100_000): """ >>> solve(4) 19316 """ result = 0 for n in range(2, limit): if n == sum_of_digits_raised(n, power): info(f"{n} = %s", " + ".join(map(lambda d: f"{d}^{power}", str(n)))) result += n return result
def solve(target): truncatable_primes = set() primes = dropwhile(lambda p: p in EXCLUDE, gen_primes()) for p in primes: if len(truncatable_primes) == target: break truncations_p = truncations(p) if all(map(is_prime, truncations_p)): info(f"{p} = {truncations_p}") truncatable_primes.add(p) return sum(truncatable_primes)
def solve(limit): """Returns the numbers of circular primes below limit. >>> solve(100) 13 """ primes = takewhile(lambda n: n < limit, gen_primes()) count = 0 for p in primes: if all(map(is_prime, rotations(p))): info(p) count += 1 return count
def solve(limit): """ >>> solve(150) """ solutions = pythagorean_perimeters(limit) max_solutions = 0 max_perimeter = 0 for perimeter, solutions in solutions.items(): if len(solutions) > max_solutions: info(f"p={perimeter}, {len(solutions)} solutions, {solutions}") max_perimeter = perimeter max_solutions = len(solutions) return max_perimeter
def solve(limit=7): d_min_x = {} for d in range(limit + 1): if square(d): continue x, y = pells_equation(d) d_min_x[d] = x info(f"D={d}, {x}^2 - {d}*{y}^2 = {(x*x) - (d*y*y)}") result = max(d_min_x, key=lambda k: d_min_x[k]) info(f"D={result}, x={d_min_x[d]}") return result
def solve(target=91, limit=6): result_area, result_delta = 0, inf for h in range(1, limit): for w in range(1, limit): rectangles = triangle(h) * triangle(w) delta = abs(rectangles - target) area = h * w if delta < result_delta: result_area, result_delta = area, delta info( f"{h}x{w}: rectangles={rectangles}, delta={delta}, area={area}" ) return result_area
def solve(): largest_pandigital = 0 limit = 100_000 scope = 999999999 for x in range(1, limit): for up_to in range(1, 10): c = int(concatenated_product(x, up_to)) if c > scope: break if is_pandigital(c) and c > largest_pandigital: info(f"{c}, n={up_to}") largest_pandigital = c return largest_pandigital
def solve(): result = 1 for n1 in range(1, 10): for d1 in range(n1 + 1, 10): for i in range(1, 10): n2 = n1 * 10 + i d2 = i * 10 + d1 f1 = Fraction(n1, d1) f2 = Fraction(n2, d2) if f1 == f2: info(f"{n2}/{d2} = {n1}/{d1}") result *= f1 return result.denominator
def handle_connection(self) -> None: """Accept and handle a client connection""" try: # Accept the incoming connection self.client_sock, self.client_addr = self.server_sock.accept() logging.info('Client connected: {}', self.client_addr[0]) while True: # Handle Pygame events and update the window self.handle_event(pygame.event.wait()) self.window.update() # Receive and handle a message from the client, if one is available if recv_avail(self.client_sock): message = recv_obj(self.client_sock, self.sock_timeout) self.handle_message(message) except socket.error as err: logging.error('Client disconnected: {}', err) finally: self.client_sock.close() self.client_sock = None self.client_addr = None
def solve(): digits = tuple(range(10)) cubes = combinations(digits, 6) cubes = map(set, cubes) cubes = map(flippable, cubes) pairs = combinations(cubes, 2) result = 0 for c1, c2 in pairs: for s1, s2 in SQUARES: if not ((s1 in c1 and s2 in c2) or (s2 in c1 and s1 in c2)): break else: result += 1 info(f"{c1}, {c2}") return result
def connect_and_run(self) -> None: """Connect to the server and run the client""" logging.info('Connecting to server: {}:{}', self.host, self.port) self.sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM) self.sock.settimeout(self.SOCKET_TIMEOUT) try: self.sock.connect((self.host, self.port)) except socket.error as err: logging.error('Unable to connect: {} (retrying in {}s)', err, self.RECONNECT_DELAY) return logging.info("Connected to server") # Initialize a timer to periodically send a SystemInfoMessage send_system_info_timer = Timer(self.SYSTEM_INFO_INTERVAL, start_expired=True) try: # Inform the server of the current state of the Arduino connection send_obj(self.sock, ArduinoConnectionMessage(self.arduino.is_connected())) while True: # Send a SystemInfoMessage if send_stats_interval has elapsed if send_system_info_timer.is_expired(): send_obj(self.sock, get_system_info_message()) send_system_info_timer.restart() # Receive and handle a command command = recv_obj(self.sock, self.SOCKET_TIMEOUT) self.handle_command(command) except socket.error as err: logging.error('Connection closed: {} (reconnecting in {}s)', err, self.RECONNECT_DELAY) finally: self.sock.close() # If the Arduino is connected, try and stop the motors if self.arduino.is_connected(): try: self.arduino.write_speeds(None) except serial.SerialException: pass # Stop the currently playing sound, if any self.sound_player.stop()
def run(self) -> None: """Run the server""" try: # Create and bind the server socket self.server_sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM) self.server_sock.settimeout(self.sock_timeout) self.server_sock.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1) self.server_sock.bind((self.host, self.port)) self.server_sock.listen(1) logging.info('Server started on {}:{}', self.host or 'INADDR_ANY', self.port) while True: # Handle Pygame events and update the window while waiting for an incoming connection while not recv_avail(self.server_sock): self.handle_event(pygame.event.wait()) self.window.update() # Once an incoming connection is being made, handle it self.handle_connection() finally: self.server_sock.close()
def solve(limit): """ >>> solve(6) 30 >>> solve(12) 61 """ minimum = defaultdict(lambda: inf) queue = deque([(2, )]) k2 = limit * 2 while queue: numbers = queue.popleft() p = prod(numbers) s = sum(numbers) k = len(numbers) + (p - s) if p > k2: continue if k > 1 and k <= limit: minimum[k] = min(minimum[k], p) info(f"k={k}: {s} = {numbers}") left = numbers + (numbers[-1], ) queue.append(left) right = numbers[:-1] + (numbers[-1] + 1, ) queue.append(right) product_sums = set(minimum.values()) info(product_sums) return sum(product_sums)
def solve(target): """ >>> solve(2000) 100 """ solutions = 0 # Let the length be the bound M for length_m in count(): for width_height in range(2 * length_m): path = sqrt(length_m**2 + width_height**2) if path.is_integer(): folds = width_height // 2 if width_height > length_m: folds -= width_height - (length_m + 1) solutions += folds if solutions > target: info(f"Solutions: {solutions}") return length_m
def solve(limit=50): numbers = set() primes = list(takewhile(lambda p: p < sqrt(limit), gen_primes())) for a in primes: a2 = a**2 for b in primes: b3 = b**3 ab = a2 + b3 for c in primes: c4 = c**4 abc = ab + c4 if abc >= limit: break info(f"{abc} = {a}^2 + {b}^3 + {c}^4") numbers.add(abc) return len(numbers)
def solve(limit): total = 0 n_1, n_2, sign = 1, 1, 1 while True: # Calculate the next n given the 2 previous n n = n_1 * 4 - n_2 + 2 * sign sides = (n, n, n + sign * 1) perimeter = sum(sides) if perimeter > limit: break total += perimeter area = triangle_area(*sides) info(f"{sides}, area={area}, perimeter={perimeter}") # Move the previous n forward and flip the sign n_1, n_2 = n, n_1 sign *= -1 return total
def solve(): data = read_data("p096_sudoku.txt") sudokus = parse_sudokus(data) result = 0 for i, sudoku in enumerate(sudokus, 1): solved = solve_sudoku(sudoku) top_left = join_digits(sudoku[0][0:3]) result += top_left info(f"Sudoku {i} {'solved' if solved else 'FAILED'}: {top_left}") info(sudoku) info("") return result
def colormap(force=False, view=False): ''' return cached file or create a new one ''' logging.info('colormap() called, force: %s, view: %s', force, view) init() print('content-type: text/json\r\n\r\n', end='') if os.path.exists(MAPFILE) and not force: logging.info('returning cached color map') with open(MAPFILE) as infile: colormap = infile.read() else: logging.info('creating new color map') colormap = json.dumps(create_colormap(view)) with open(MAPFILE, 'w') as outfile: outfile.write(colormap) print(colormap, end='')
def pretty_info(ring): """Log the ring like in the problem description.""" total = sum(ring[0]) solution_set = '; '.join(map(lambda g: ','.join(map(str, g)), ring)) info(f"{total}\t{solution_set}")
def launch_volcanojob(name, num_workers, image, working_dir, worker_command, master_command): # 删除旧的volcanojob if KFJ_RUN_ID: logging.info('Try delete old volcanojob.') with HiddenPrints(): try: k8s_client.delete_crd(group=crd_info['group'], version=crd_info['version'], plural=crd_info['plural'], namespace=KFJ_NAMESPACE, labels={"run-id": KFJ_RUN_ID}) k8s_client.delete_crd(group=crd_info['group'], version=crd_info['version'], plural=crd_info['plural'], namespace=KFJ_NAMESPACE, name=name) except: logging.info('Nothing to delete, name:{}, run_id:{}'.format( name, KFJ_RUN_ID)) time.sleep(10) # 创建新的volcanojob volcanojob_json = make_volcanojob(name=name, num_workers=num_workers, image=image, working_dir=working_dir, worker_command=worker_command, master_command=master_command) logging.info('Create new volcanojob %s' % name) logging.info(volcanojob_json) k8s_client.create_crd(group=crd_info['group'], version=crd_info['version'], plural=crd_info['plural'], namespace=KFJ_NAMESPACE, body=volcanojob_json) # 开子程程跟踪日志 logging.info('Begin tracing logs') command = "sh stern.sh '{name}' '{namespace}'".format( name=name, namespace=KFJ_NAMESPACE) log_proc = subprocess.Popen(command,stdin=subprocess.PIPE, stderr=subprocess.PIPE, \ stdout=subprocess.PIPE, universal_newlines=True, shell=True, bufsize=1) # 阻塞到Volcanojob结束或者用户任务结束 loop_time = 0 while True: time.sleep(10) volcanojob = k8s_client.get_one_crd(group=crd_info['group'], version=crd_info['version'], plural=crd_info['plural'], namespace=KFJ_NAMESPACE, name=name) if not volcanojob: # 获取volcanojob失败,再给一次机会 time.sleep(10) volcanojob = k8s_client.get_one_crd(group=crd_info['group'], version=crd_info['version'], plural=crd_info['plural'], namespace=KFJ_NAMESPACE, name=name) line = nonBlockRead(log_proc.stdout) while line: logging.info(line.strip()) line = nonBlockRead(log_proc.stdout) if loop_time % 60 == 0: logging.info("heartbeating, volcanojob status: {}".format( str(volcanojob['status']))) loop_time += 1 if not volcanojob: break if volcanojob and (volcanojob['status'] not in ("Running", "Pending")): break if not volcanojob: raise RuntimeError # ("Volcanojob disappear!!!Check if deleted artificial!!!") if volcanojob['status'] != 'Completed': logging.error("volcanojob %s finished, status %s" % (name, volcanojob['status'])) raise RuntimeError # ("volcanojob %s finished, status %s"%(name, volcanojob['status'])) logging.info("Volcanojob %s finished, status %s" % (name, volcanojob['status']))