Upload examples.py with huggingface_hub

examples.py

@@ -0,0 +1,151 @@
+"""Benchmark programs offered as one-click presets.
+
+Each is chosen to be a fair test of translation rather than a trick: pure
+computation, deterministic output, no I/O or third-party imports, and a runtime
+long enough in Python that the speedup is unambiguous.
+
+The output is printed so the two languages can be compared exactly - a
+translation that is fast but wrong is a failed translation.
+"""
+
+MAX_SUBARRAY = '''# Brute-force maximum subarray sum over a seeded pseudo-random sequence.
+# O(n^2) by design - the interesting question is whether the model preserves
+# the algorithm or silently upgrades it.
+
+def lcg(seed, a=1664525, c=1013904223, m=2**32):
+    value = seed
+    while True:
+        value = (a * value + c) % m
+        yield value
+
+def max_subarray_sum(n, seed, min_val, max_val):
+    lcg_gen = lcg(seed)
+    random_numbers = [next(lcg_gen) % (max_val - min_val + 1) + min_val for _ in range(n)]
+    max_sum = float('-inf')
+    for i in range(n):
+        current_sum = 0
+        for j in range(i, n):
+            current_sum += random_numbers[j]
+            if current_sum > max_sum:
+                max_sum = current_sum
+    return max_sum
+
+def total_max_subarray_sum(n, initial_seed, min_val, max_val):
+    total_sum = 0
+    lcg_gen = lcg(initial_seed)
+    for _ in range(20):
+        seed = next(lcg_gen)
+        total_sum += max_subarray_sum(n, seed, min_val, max_val)
+    return total_sum
+
+n = 10000
+initial_seed = 42
+min_val = -10
+max_val = 10
+
+import time
+start_time = time.time()
+result = total_max_subarray_sum(n, initial_seed, min_val, max_val)
+end_time = time.time()
+
+print("Total Maximum Subarray Sum (20 runs):", result)
+print("Execution Time: {:.6f} seconds".format(end_time - start_time))
+'''
+
+PI_LEIBNIZ = '''# Tight floating-point loop. Almost pure interpreter overhead in Python,
+# so it shows the raw cost of dynamic dispatch per iteration.
+
+import time
+
+def calculate(iterations, param1, param2):
+    result = 1.0
+    for i in range(1, iterations + 1):
+        j = i * param1 - param2
+        result -= (1 / j)
+        j = i * param1 + param2
+        result += (1 / j)
+    return result
+
+start_time = time.time()
+result = calculate(100_000_000, 4, 1) * 4
+end_time = time.time()
+
+print(f"Result: {result:.12f}")
+print(f"Execution Time: {end_time - start_time:.6f} seconds")
+'''
+
+PRIME_SIEVE = '''# Sieve of Eratosthenes plus a digit-sum reduction.
+# Memory-bound rather than compute-bound, so it stresses a different axis
+# than the other two.
+
+import time
+
+def sieve(limit):
+    flags = [True] * (limit + 1)
+    flags[0] = flags[1] = False
+    p = 2
+    while p * p <= limit:
+        if flags[p]:
+            for multiple in range(p * p, limit + 1, p):
+                flags[multiple] = False
+        p += 1
+    return flags
+
+def digit_sum(n):
+    total = 0
+    while n:
+        total += n % 10
+        n //= 10
+    return total
+
+start_time = time.time()
+limit = 5_000_000
+flags = sieve(limit)
+count = 0
+checksum = 0
+for n in range(limit + 1):
+    if flags[n]:
+        count += 1
+        checksum += digit_sum(n)
+end_time = time.time()
+
+print(f"Primes below {limit}: {count}")
+print(f"Digit-sum checksum: {checksum}")
+print(f"Execution Time: {end_time - start_time:.6f} seconds")
+'''
+
+COLLATZ = '''# Longest Collatz chain below a bound. Unpredictable branching, which
+# defeats naive vectorisation and rewards a good compiler.
+
+import time
+
+def chain_length(n):
+    steps = 0
+    while n != 1:
+        n = n // 2 if n % 2 == 0 else 3 * n + 1
+        steps += 1
+    return steps
+
+start_time = time.time()
+limit = 1_000_000
+best_n = 0
+best_len = 0
+for n in range(1, limit):
+    length = chain_length(n)
+    if length > best_len:
+        best_len = length
+        best_n = n
+end_time = time.time()
+
+print(f"Longest Collatz chain below {limit}: n={best_n} with {best_len} steps")
+print(f"Execution Time: {end_time - start_time:.6f} seconds")
+'''
+
+EXAMPLES: dict[str, str] = {
+    "Maximum subarray sum (O(n^2))": MAX_SUBARRAY,
+    "Pi via Leibniz series (100M iterations)": PI_LEIBNIZ,
+    "Prime sieve + digit sums (5M)": PRIME_SIEVE,
+    "Longest Collatz chain (1M)": COLLATZ,
+}
+
+DEFAULT_EXAMPLE = "Maximum subarray sum (O(n^2))"