a5

TWINP.cpp

@@ -0,0 +1,65 @@
+#include <iostream>
+#include <vector>
+
+#define LIMIT 20000000
+
+int main() {
+
+    int c;
+
+    std::cin >> c;
+
+    std::vector<int> nums;
+    std::vector<int> twins;
+
+    int max = 0;
+    while (c != 0) {
+        int a;
+
+        std::cin >> a;
+        if (a > max) {
+            max = a;
+        }
+        nums.push_back(a);
+
+        c--;
+    }
+
+    std::vector<bool> sieve(LIMIT + 1, true);
+    sieve[0] = sieve[1] = false;
+
+    for (int p = 2; p * p <= LIMIT; ++p) {
+        if (sieve[p]) {
+            for (int i = p * p; i <= LIMIT; i += p) {
+                sieve[i] = false;
+            }
+        }
+    }
+
+    int last = 0;
+    int k = 0;
+    for (int p = 2; p <= LIMIT; ++p) {
+        if (sieve[p]) {
+            k++;
+
+            if ((p - last) == 2) {
+                for (int n : nums) {
+                    if (n == k) {
+                        printf("%d %d", p, last);
+                    }
+                }
+            }
+
+            last = p;
+        }
+    }
+
+
+
+
+
+}
+
+
+
+

TWINP.py

@@ -0,0 +1,53 @@
+# n is the largest number prime pair we need
+def prime_pairs(n):
+    if n <= 0:
+        return []
+
+    limit = 1000
+    primes = []
+    sieve = [True] * (limit + 1)
+    sieve[0] = sieve[1] = False
+    prime_pairs = []
+
+    while True:
+        print(len(sieve))
+        for p in range(2, int(limit**0.5) + 1):
+            if sieve[p]:
+                for i in range(p * p, limit + 1, p):
+                    sieve[i] = False
+
+        for p in range(2, limit + 1):
+            if sieve[p]:
+                primes.append(p)
+            if len(primes) > 1:
+                if primes[-1] - primes[-2] == 2 and (primes[-2], primes[-1]) not in prime_pairs:
+                    prime_pairs.append((primes[-2], primes[-1]))
+
+        if len(prime_pairs) >= n:
+            break
+
+        limit *= 2
+        sieve.extend([True] * (limit - len(sieve) + 1))
+
+        print(prime_pairs)
+
+    return prime_pairs
+
+def main():
+    n = int(input())
+
+    nums = []
+
+    for i in range(n):
+        nums.append(int(input()))
+
+    primes_list = prime_pairs(max(nums))
+
+    for num in nums:
+        print(f'{primes_list[num - 1][0]} {primes_list[num - 1][1]}')
+
+
+if __name__ == '__main__':
+    main()
+
+

TWINP2.cpp

@@ -0,0 +1,41 @@
+#include <iostream>
+#include <vector>
+
+std::vector<bool> sieve(int limit) {
+    std::vector<bool> is_prime(limit + 1, true);
+    is_prime[0] = is_prime[1] = false;
+
+    for (int i = 2; i * i <= limit; i++) {
+        if (is_prime[i]) {
+            for (int j = i * i; j <= limit; j += i) {
+                is_prime[j] = false;
+            }
+        }
+    }
+    return is_prime;
+}
+
+int main() {
+    int T;
+    std::cin >> T;
+
+    int limit = 20000000;
+
+    std::vector<bool> is_prime = sieve(limit);
+
+    std::vector<std::pair<int, int>> twin_primes;
+
+    for (int i = 2; i < limit - 2; ++i) {
+        if (is_prime[i] && is_prime[i + 2]) {
+            twin_primes.push_back({i, i + 2});
+        }
+    }
+
+    while (T--) {
+        int N;
+        std::cin >> N;
+        printf("%d %d\n", twin_primes[N - 1].first, twin_primes[N - 1].second);
+    }
+
+    return 0;
+}

test.py

@@ -0,0 +1,11 @@
+a = [1,2,3,4,1]
+
+def find_thing(l: list[int]) -> bool:
+    for n in l:
+        if l.count(n) > 1:
+            return True
+
+    return False
+
+assert find_thing(a) == True
+