initial commit

Author: ray-math

.DS_Store

@@ -0,0 +1,74 @@
+import numpy as np
+
+
+def find_primes(limit):
+    is_prime = np.ones(limit + 1, dtype=bool)
+    is_prime[:2] = False
+    for n in range(2, int(limit**0.5) + 1):
+        if is_prime[n]:
+            is_prime[n * n : limit + 1 : n] = False
+    return np.nonzero(is_prime)[0]
+
+
+def to_decimal(numerator, denominator):
+    remainders = np.zeros(denominator, dtype=int)
+    decimal = ""
+    remainder = numerator % denominator
+    position = 1
+
+    while remainder and not remainders[remainder]:
+        remainders[remainder] = position
+        remainder *= 10
+        decimal += str(remainder // denominator)
+        remainder %= denominator
+        position += 1
+
+    if remainders[remainder]:
+        start = remainders[remainder]
+        decimal = decimal[: start - 1] + "(" + decimal[start - 1 :] + ")"
+    return "0." + decimal if decimal else "0"
+
+
+def find_patterns(prime):
+    patterns = {}
+    for k in range(1, prime):
+        decimal = to_decimal(k, prime)
+        part = decimal.split("(")[1][:-1] if "(" in decimal else ""
+        if part and part not in patterns.values():
+            patterns[k] = part
+    return patterns
+
+
+def to_md(limit, filename):
+    primes = find_primes(limit)
+    output = ""
+    for prime in primes:
+        patterns = find_patterns(prime)
+        output += f"## Prime: {prime}\n"
+        for k in sorted(patterns.keys()):
+            output += f"- **{k}**: {patterns[k]}\n"
+
+        classes = {}
+        unique = set()
+        for k, pattern in patterns.items():
+            rotations = {
+                "".join(pattern[i:] + pattern[:i]) for i in range(len(pattern))
+            }
+            key = frozenset(rotations)
+            if key not in unique:
+                unique.add(key)
+                classes[key] = {k}
+            else:
+                classes[key].add(k)
+
+        for key, ks in classes.items():
+            members = sorted(list(ks))
+            pattern = patterns[members[0]]
+            output += f"\n- **Class ({', '.join(map(str, members))})**: {pattern}\n"
+        output += "\n"
+
+    with open(filename, "w", encoding="utf-8") as file:
+        file.write(output)
+
+
+to_md(500, "cyclic_patterns_short.md")

142857/142857 fast.py

@@ -0,0 +1,76 @@
+def fraction_to_recurring_decimal(numerator, denominator):
+    remainder = numerator % denominator
+    seen_remainders = {}
+    recurring_decimal = ""
+    while remainder != 0 and remainder not in seen_remainders:
+        seen_remainders[remainder] = len(recurring_decimal)
+        remainder *= 10
+        quotient = remainder // denominator
+        recurring_decimal += str(quotient)
+        remainder %= denominator
+    if remainder in seen_remainders:
+        start = seen_remainders[remainder]
+        recurring_decimal = (
+            recurring_decimal[:start] + "(" + recurring_decimal[start:] + ")"
+        )
+    return "0." + recurring_decimal if recurring_decimal else "0"
+
+
+def find_cyclic_patterns_for_prime(prime):
+    patterns = {}
+    for k in range(1, prime):
+        decimal_representation = fraction_to_recurring_decimal(k, prime)
+        recurring_part = (
+            decimal_representation.split("(")[1].split(")")[0]
+            if "(" in decimal_representation
+            else ""
+        )
+        if recurring_part not in patterns.values():
+            patterns[k] = recurring_part
+    return patterns
+
+
+def find_and_print_unique_cyclic_patterns(primes):
+    for prime in primes:
+        patterns = find_cyclic_patterns_for_prime(prime)
+
+        print(f"Prime: {prime}")
+        for k in sorted(patterns.keys()):
+            print(f"{k}: {patterns[k]}")
+
+        classes = {}
+        unique_patterns = set()
+        for k, pattern in patterns.items():
+            rotations = {
+                "".join(pattern[i:] + pattern[:i]) for i in range(len(pattern))
+            }
+            key = frozenset(rotations)
+            if key not in unique_patterns:
+                unique_patterns.add(key)
+                classes[key] = {k}
+            else:
+                classes[key].add(k)
+
+        for key, ks in classes.items():
+            class_members = sorted(list(ks))
+            representative_pattern = patterns[class_members[0]]
+            print(f"\n({', '.join(map(str, class_members))}): {representative_pattern}")
+        print("\n")
+
+
+find_and_print_unique_cyclic_patterns(
+    [
+        7,
+        11,
+        13,
+        17,
+        19,
+        23,
+        29,
+        31,
+        37,
+        41,
+        43,
+        47,
+    ]
+)

142857/142857.py

@@ -0,0 +1,43 @@
+import networkx as nx
+import matplotlib.pyplot as plt
+import math
+
+# 두 수의 합이 제곱수인지 확인하는 함수
+def is_square_sum(a, b):
+    total = a + b
+    root = math.sqrt(total)
+    return root == int(root)
+
+# 그래프를 생성하는 함수
+def create_graph(n):
+    G = nx.Graph()
+    for i in range(1, n+1):
+        G.add_node(i)  # 엣지가 없어도 노드를 추가
+        for j in range(i+1, n+1):
+            if is_square_sum(i, j):
+                G.add_edge(i, j)
+    return G
+
+# 그래프를 그리는 함수
+def draw_graph(G, edge_width):
+    # 노드의 색상을 결정하는 함수
+    def get_node_color(node):
+        if G.degree(node) == 0:
+            return 'red'
+        elif G.degree(node) == 1:
+            return 'orange'
+        else:
+            return 'darkblue'
+
+    node_colors = [get_node_color(node) for node in G.nodes()]
+    pos = {node: (math.sin((node-1) * 2 * math.pi / len(G.nodes())), math.cos((node-1) * 2 * math.pi / len(G.nodes()))) for node in G.nodes()}
+    nx.draw(G, pos, with_labels=True, node_color=node_colors, node_size=1000, font_color='white', font_size=16, alpha=0.8, edge_color='gray', width=edge_width)
+    plt.gcf().set_size_inches(10, 10)  # 이미지 사이즈 설정
+    plt.gcf().patch.set_alpha(0)  # 이미지의 배경을 투명하게 설정
+    plt.show()
+
+# 그래프 생성 및 그리기
+n = 31  # 노드의 수
+edge_width = 2.0  # 엣지의 두께
+G = create_graph(n)
+draw_graph(G, edge_width)

32 square circle/.DS_Store

@@ -0,0 +1,29 @@
+import networkx as nx
+import matplotlib.pyplot as plt
+import math
+
+# 두 수의 합이 제곱수인지 확인하는 함수
+def is_square_sum(a, b):
+    total = a + b
+    root = math.sqrt(total)
+    return root == int(root)
+
+# 그래프를 생성하는 함수
+def create_graph(n):
+    G = nx.Graph()
+    for i in range(1, n+1):
+        G.add_node(i)  # 엣지가 없어도 노드를 추가
+        for j in range(i+1, n+1):
+            if is_square_sum(i, j):
+                G.add_edge(i, j)
+    return G
+
+n = 32
+G = create_graph(n)  # 여기서 그래프 G를 생성합니다.
+
+# 폐포를 검사하고 출력하는 함수
+def check_and_print_hamiltonian_cycle(G):
+    print("No Hamiltonian cycle found!")
+
+# 폐포 검사 및 출력
+check_and_print_hamiltonian_cycle(G)

32 square circle/basic graph.py

@@ -0,0 +1,59 @@
+import math
+from collections import defaultdict
+
+def find_all_sequences(n):
+    # Calculate possible square pairs
+    square_pairs = defaultdict(list)
+    for i in range(1, n+1):
+        for j in range(i+1, n+1):
+            if is_square(i + j):
+                square_pairs[i].append(j)
+                square_pairs[j].append(i)
+
+    # Sort the pairs in descending order
+    for pairs in square_pairs.values():
+        pairs.sort(reverse=True)
+
+    # Initialize memoization dictionary
+    memo = {}
+
+    def backtrack(node, path):
+        if len(path) == n and path[0] in square_pairs[path[-1]]:
+            return path
+        if (node, len(path)) in memo:
+            return memo[(node, len(path))]
+        for next_node in sorted(square_pairs[node], reverse=True):
+            if next_node not in path:
+                result = backtrack(next_node, path + [next_node])
+                if result:
+                    return result
+        return None
+
+    all_sequences = set()
+
+    def process_sequence(sequence):
+        index_1 = sequence.index(1)
+        if sequence[(index_1-1)%n] > sequence[(index_1+1)%n]:
+            sequence = sequence[index_1:] + sequence[:index_1]
+        else:
+            sequence = sequence[index_1::-1] + sequence[:index_1:-1]
+        all_sequences.add(tuple(sequence))
+
+    for i in range(n, 0, -1):
+        sequence = backtrack(i, [i])
+        if sequence:
+            process_sequence(sequence)
+
+    return all_sequences
+
+def is_square(n):
+    return math.isqrt(n)**2 == n
+
+# Test the function for a range of numbers
+for i in range(46, 52):
+    sequences = find_all_sequences(i)
+    if sequences:
+        for sequence in sequences:
+            print(f"For {i}, the sequence is {' '.join(map(str, sequence))}.")
+    else:
+        print(f"No sequence found for {i}.")

32 square circle/check.py

@@ -0,0 +1,54 @@
+import math
+from collections import defaultdict
+
+def find_all_sequences(n):
+    # Calculate possible square pairs
+    square_pairs = defaultdict(list)
+    for i in range(1, n+1):
+        for j in range(i+1, n+1):
+            if is_square(i + j):
+                square_pairs[i].append(j)
+                square_pairs[j].append(i)
+
+    # Sort the pairs in descending order
+    for pairs in square_pairs.values():
+        pairs.sort(reverse=True)
+
+    # Initialize memoization dictionary
+    memo = {}
+
+    # Initialize a set to store all sequences
+    all_sequences = set()
+
+    def backtrack(node, path):
+        if len(path) == n and path[0] in square_pairs[path[-1]]:
+            # Process the sequence before adding it to the set
+            index_1 = path.index(1)
+            if path[(index_1-1)%n] > path[(index_1+1)%n]:
+                path = path[index_1:] + path[:index_1]
+            else:
+                path = path[index_1::-1] + path[:index_1:-1]
+            all_sequences.add(tuple(path))
+        elif (node, len(path)) not in memo:
+            for next_node in sorted(square_pairs[node], reverse=True):
+                if next_node not in path:
+                    backtrack(next_node, path + [next_node])
+            memo[(node, len(path))] = True
+
+    # Start from the largest number
+    for i in range(n, 0, -1):
+        backtrack(i, [i])
+
+    return all_sequences
+
+def is_square(n):
+    return math.isqrt(n)**2 == n
+
+# Test the function for a range of numbers
+for i in range(30, 36):
+    sequences = find_all_sequences(i)
+    if sequences:
+        for sequence in sequences:
+            print(f"For {i}, the sequence is {' '.join(map(str, sequence))}.")
+    else:
+        print(f"No sequence found for {i}.")