CZY LICZBY PIERWSZE I ZŁOŻONE MAJA COŚ WSPÓLNEGO Z LICZBAMI KWADRATOWYMI?
(OCZYWIŚCIE MOGĘ SIĘ MYLIĆ, BO NIE JESTEM MATEMATYKIEM)
PROGRAM W PYTHONIE:
import math
def is_prime(n):
"""Funkcja sprawdzająca, czy liczba n jest liczbą pierwszą."""
if n <= 1:
return False
for i in range(2, int(math.sqrt(n)) + 1):
if n % i == 0:
return False
return True
def znajdz_wartosci_n(x, max_n=1000000):
znalezione = [] # lista do przechowywania wartości n, dla których wynik jest całkowity
for n in range(1, max_n + 1):
# Oblicz sumę ciągu arytmetycznego dla danego n
suma = n * (x + n)
# Sprawdź, czy suma jest kwadratem liczby całkowitej
pierwiastek = math.isqrt(suma)
if pierwiastek * pierwiastek == suma:
znalezione.append((n, suma, pierwiastek))
# Wyświetl wyniki
if znalezione:
print(f"Dla x = {x}, znaleziono następujące wartości n:")
for n, suma, pierwiastek in znalezione:
print(f" n = {n}, Suma = {suma}, Pierwiastek = {pierwiastek}")
else:
print(f"Dla x = {x}, nie znaleziono wartości n, dla których suma jest kwadratem liczby całkowitej w zakresie n = 1 do {max_n}.")
# Przykład użycia:
x = int(input("Podaj wartość x: "))
if is_prime(x):
print(f"{x} jest liczbą pierwszą.")
else:
print(f"{x} jest liczbą złożoną.")
znajdz_wartosci_n(x)
WYOBRAŹ SOBIE JEDNĄ IGLE ORAZ STÓG SIANA, ZNAJDZIESZ JĄ, NAWET WIESZ GDZIE SIĘ ZNAJDUJE W TYM STOGU, CO WIĘCEJ WIESZ ILE JEST WSZYSTKICH ŹDZIEBŁ+IGIEŁ, ALE NIE ZNASZ ILOŚCI SAMYCH IGIEŁ? IGŁA to 0 LUB ZERA ,
a STÓG SIANA ZBIÓR JEDYNEK TYPU 1,1,1,1,1,1,1...
RAZEM TWORZĄ SUMĘ X=1,1,1,1,1,0,1,1,1..., ZNAMY WARTOŚĆ SUMY I WIEMY Z OBSERWACJI, ŻE DLA LICZB PIERWSZYCH SUMA TA, TO:
JEDNO 0 I ILOŚĆ JEDYNEK (X-1)
To stwierdziłem, badając proste równanie z pierwiastkiem:
W= √(x + n**2)=LC+R
LC- liczba całkowita
R- reszta dodatnia/>=0
np. 9=√(17+8*8), 22=√(43+21*21), 49=√(97+48*48)
lecz równieź 13=√(25+12*12), 61=√(121+60*60)
PROGRAM PYTHON:
import math
def test_pierwiastka(x, n_max):
"""
Test liczb na podstawie wzoru (√(x + n**2)).
x: liczba testowana
n_max: maksymalna wartość n do sprawdzenia = x
"""
zero_count = 0 # Zmienna do zliczania zerowych reszt
print(f"Wartość x: {x}") # Wyświetlamy wartość x
for n in range(1, n_max + 1):
w = math.sqrt(x + n**2) # Obliczamy pierwiastek
LC = int(w) # Zaokrąglamy całkowitą część liczby w
reszta = w - LC # Liczymy resztę po odjęciu całkowitej części
# Używamy dynamicznego progu porównania: 1e-12 * x
if reszta < 1e-12 * x: # Jeśli reszta bliska zeru
print(f"n = {n}, R = 0000000000") # Wyświetlamy widoczne "0000000000"
zero_count += 1 # Zwiększamy Licznik Zerowych Reszt
else:
print(f"n = {n}, R = 1") # Wszystkie pozostałe traktujemy jako 1
print(f"Liczba zerowych reszt: {zero_count}")
# Przykład użycia:
x = int(input("Podaj liczbę x: "))
test_pierwiastka(x, x)
Podaj liczbę x:
13
Wartość x: 13
n = 1, R = 1
n = 2, R = 1
n = 3, R = 1
n = 4, R = 1
n = 5, R = 1
n = 6, R = 0000000000
n = 7, R = 1
n = 8, R = 1
n = 9, R = 1
n = 10, R = 1
n = 11, R = 1
n = 12, R = 1
n = 13, R = 1
Liczba zerowych reszt: 1
Podaj liczbę x:
15
Wartość x: 15
n = 1, R = 0000000000
n = 2, R = 1
n = 3, R = 1
n = 4, R = 1
n = 5, R = 1
n = 6, R = 1
n = 7, R = 0000000000
n = 8, R = 1
n = 9, R = 1
n = 10, R = 1
n = 11, R = 1
n = 12, R = 1
n = 13, R = 1
n = 14, R = 1
n = 15, R = 1
Liczba zerowych reszt: 2
Podaj liczbę x:
9
Wartość x: 9
n = 1, R = 1
n = 2, R = 1
n = 3, R = 1
n = 4, R = 0000000000
n = 5, R = 1
n = 6, R = 1
n = 7, R = 1
n = 8, R = 1
n = 9, R = 1
Liczba zerowych reszt: 1
JEDNAK SZUKANIE JEDNEGO ZERA WCALE NIE JEST TAKIE PROSTE,
GDY NIE WIEMY ILE TAK NA PRAWDĘ ICH JEST?
TĄ JEDNĄ LICZBĘ :
UDAŁO MI SIĘ SPRAWDZIĆ NOWYM PROGRAMEM !!!
NOWY FAJNY PROGRAM W PYTHONIE:
import math
import random
import time
def factorial_limited(n):
"""Funkcja do obliczenia silni dla liczb w bezpiecznym zakresie."""
if n <= 1:
return 1
result = 1
for i in range(2, n + 1):
result *= i
if result > 1e18: # Ograniczenie, aby uniknąć ogromnych liczb
return float('inf')
return result
def miller_rabin_test(n, k=10):
"""
Test Millera-Rabina do sprawdzania pierwszości liczby.
Parametry:
- n: liczba do sprawdzenia
- k: liczba iteracji testu
"""
if n <= 1:
return False
if n <= 3:
return True
if n % 2 == 0:
return False
# Znajdowanie d i r takie, że n-1 = d * 2^r
r, d = 0, n - 1
while d % 2 == 0:
d //= 2
r += 1
# Wykonywanie k testów
for _ in range(k):
a = random.randint(2, n - 2)
x = pow(a, d, n) # a^d % n
if x == 1 or x == n - 1:
continue
for _ in range(r - 1):
x = pow(x, 2, n)
if x == n - 1:
break
else:
return False
return True
def test_pierwiastka_paraboliczna(x):
"""Test paraboliczny do wykrywania liczb pierwszych i złożonych."""
zero_count = 0
zero_indices = []
print(f"Przetwarzanie liczby x: {x}")
start_time = time.time() # Początek pomiaru czasu
max_time = 5 # Maksymalny czas na wykonanie funkcji (w sekundach)
for a in range(1, int(math.isqrt(x)) + 1):
if x % a == 0: # Sprawdzamy, czy a jest dzielnikiem x
b = x // a # Wyznaczamy b jako drugi czynnik
# Sprawdzamy, czy a i b są tej samej parzystości
if (a + b) % 2 == 0 and (b - a) % 2 == 0:
# Obliczamy w i n
w = (a + b) // 2
n = (b - a) // 2
print(f"a = {a}, b = {b}, n = {n}, W = {w}")
zero_count += 1
zero_indices.append(n)
# Jeśli znajdziemy więcej niż jedno zero, kontynuujemy
if zero_count >= 2:
break
# Sprawdzamy czas wykonania
if time.time() - start_time > max_time:
print(f"Przekroczono maksymalny czas na test paraboliczny. Przechodzimy do testu Millera-Rabina.")
break
print(f"Liczba zerowych reszt: {zero_count}")
print(f"Indeksy zerowych reszt: {zero_indices}")
return zero_count, zero_indices
def czy_znaleziono_trapez(x):
"""Sprawdza, czy istnieje kombinacja podstaw i wysokości h >= 2 dla danego pola trapezu x."""
print("\nMART, LICZBY PIERWSZE TEST PIERWSZEŃSTWA")
print(f"Podaj wartość liczby x: {x}")
# Ustawianie maksymalnej liczby iteracji
if x < 21:
max_iterations = 5
print(f"Dla liczby x = {x}, ustawiono maksymalną liczbę iteracji na {max_iterations}.")
else:
silnia_x = factorial_limited(x)
if silnia_x == float('inf'):
n = max(1, math.isqrt(x) // int(math.log(x, 10)))
max_iterations = math.isqrt(x) // n * 1024
else:
max_iterations = math.isqrt(x // silnia_x)
print(f"Ustawiono maksymalną liczbę iteracji na: {max_iterations}")
max_h = math.isqrt(x)
iteration_count = 0
is_composite = False
for h in range(2, max_h + 1):
iteration_count += 1
if x % h == 0:
print(f"Liczba x = {x} jest liczbą złożoną. Znaleziono dzielnik h = {h}.")
is_composite = True
break
if iteration_count > max_iterations:
print(f"Nie znaleziono dzielnika w limicie iteracji dla liczby x = {x}.")
break
# Test paraboliczny
zero_count, zero_indices = test_pierwiastka_paraboliczna(x)
# Wynik dla liczb złożonych
if is_composite or zero_count >= 2:
print(f"Liczba x = {x} jest liczbą złożoną.")
print(f"Indeksy zerowych reszt: {zero_indices}")
else:
print(f"Liczba x = {x} może być liczbą pierwszą.")
# Zawsze wykonujemy test Millera-Rabina na końcu
print("Przechodzimy do testu Millera-Rabina...")
if miller_rabin_test(x):
print(f"Liczba x = {x} jest prawdopodobnie pierwsza (test Millera-Rabina).")
else:
print(f"Liczba x = {x} jest liczbą złożoną (potwierdzono testem Millera-Rabina).")
# Przykład użycia
x = int(input("Podaj wartość liczby x: "))
czy_znaleziono_trapez(x)
TA DUŻA LICZBA JEST PODZIELNA PRZEZ TRZY, SZUKAM WIĘC JAKIEJŚ PIERWSZEJ(HE HE), MOŻE NIC SZCZEGÓLNEGO NIE WPROWADZA TEN PROGRAM, ALE PRAWIE DOWOLNIE WIELKA LICZĘ ZAPISANA CYFRAMI MOŻNA SPRAWDZIĆ (OGRANICZA NAS SAM PYTHON-ILOŚĆ ZNAKÓW CHYBA?)
A, LICZBY PIERWSZE I KWADRATOWE RÓŻNIĄ SIĘ TYLKO JEDYNYM 0!!!
MART, LICZBY PIERWSZE TEST PIERWSZEŃSTWA
Podaj wartość liczby x: 25
Ustawiono maksymalną liczbę iteracji na: 1024
Liczba x = 25 jest liczbą złożoną. Znaleziono dzielnik h = 5.
Przetwarzanie liczby x: 25
a = 1, b = 25, n = 12, W = 13
a = 5, b = 5, n = 0, W = 5
Liczba zerowych reszt: 2
Indeksy zerowych reszt: [12, 0]
Liczba x = 25 jest liczbą złożoną.
Indeksy zerowych reszt: [12, 0]
MART, LICZBY PIERWSZE TEST PIERWSZEŃSTWA
Podaj wartość liczby x: 23
Ustawiono maksymalną liczbę iteracji na: 1024
Przetwarzanie liczby x: 23
a = 1, b = 23, n = 11, W = 12
Liczba zerowych reszt: 1
Indeksy zerowych reszt: [11]
Przechodzimy do testu Millera-Rabina...
Liczba x = 23 jest prawdopodobnie pierwsza (test Millera-Rabina).
MIŁEGO LICZENIA 
