Mart, Witam, Wszystkich(nie jestem ani Matematykiem, ani Informatykiem)
Jeżeli to jest znane, nawet ogólnie dostępna "Informacja" przepraszam, za "dziwny, kolejny post o prawie tym samym" ( wydaje mi się, jednak że o innym)"
Mam pytanie o sumowanie liczb identycznych liczb binarnych w postaci:
(binarna lustrzana x) + (n ilości 0) + (binarna i lustrzana x)
Czy zawsze ten człon liczby binarnej (x), w prostym równaniu
(x)(0)(x) tej {liczby binarnej (x)(0)(x)}, jest podzielna,
za wyjątkiem (niektórych przypadków) przez ten człon (x)
print("reguła (111 0 111)/(111)?")
print("reguła (111 00 111)/(111)?")
print("reguła (111 000 111)/(111)?")
Program w Pythonie :
def decimal_to_binary(decimal_number):
"""Konwertuje liczbę dziesiętną na zapis binarny."""
return bin(decimal_number)[2:]
def binary_to_decimal(binary_number):
"""Konwertuje liczbę binarną na system dziesiętny."""
return int(binary_number, 2)
def perform_binary_operations(decimal_number):
"""Przeprowadza operacje binarne zgodnie z podanymi zasadami."""
binary = decimal_to_binary(decimal_number)
error_count = 0 # Licznik błędów
# Operacje
binary_results = []
for i in range(1, 101): # Dodajemy od 1 do 10 zer w środku
binary_result = binary + "0" * i + binary
decimal_result = binary_to_decimal(binary_result)
binary_results.append((i, binary_result, decimal_result))
# Wyniki
print(f"Badana liczba: {decimal_number}, liczba bitów: {len(decimal_to_binary(decimal_number))}")
print(f"Schemat binarny: {decimal_to_binary(decimal_number)}")
for idx, (i, binary_result, decimal_result) in enumerate(binary_results, start=1):
factor = decimal_number
divisible = decimal_result // factor
product = factor * divisible # Wynik mnożenia liczb z drugiego nawiasu
equality_check = "OK" if product == decimal_result else "BŁĄD"
if equality_check == "BŁĄD":
error_count += 1 # Zliczanie błędów
print(f"{idx}. ({decimal_result}) = ({factor} * {divisible}) = ({product}) [{equality_check}]")
# Podsumowanie błędów
print(f"\nLiczba błędów: {error_count}")
# Główna funkcja programu
if __name__ == "__main__":
print("MART, Generator Liczb Złożonych/Suma Liczb Binarnych?")
print("reguła (111 0 111)/(111)?")
print("reguła (111 00 111)/(111)?")
print("reguła (111 000 111)/(111)?")
print(",,,,,,,,,,,,,,,,,,,,,,,,,,,,,")
number = int(input("Podaj liczbę dziesiętną: "))
perform_binary_operations(number)
W postaci lewa strona = prawej:
Podaj liczbę dziesiętną: 11
Badana liczba: 11, liczba bitów: 4
Schemat binarny: 1011
1. (363) = (11 * 33) = (363) [OK] 101101011
2. (715) = (11 * 65) = (715) [OK] 1011001011
3. (1419) = (11 * 129) = (1419) [OK] 10110001011
GDYBY , TO BYŁO REGUŁĄ? Stworzyli byśmy "Algorytm Liczb Złożonych"
Kod programu dla trybu A)
Wprowadza:
Liczbę zer (ks) – stała liczba zer (od 0 do maksymalnej liczby).
Liczbę n – ilość liczb do wygenerowania (kolejne liczby n1, n2, ..., nm).
Program generuje wzór (n)(ks)(n) dla podanej liczby n oraz stałej liczby zer.
Program w Pythonie:
import random
def is_prime(n, k=5):
"""
Test Rabina-Millera do sprawdzania, czy liczba jest pierwsza.
- n: liczba do przetestowania.
- k: liczba iteracji testu (im większa, tym większa dokładność).
"""
if n <= 1:
return False
if n <= 3:
return True
if n % 2 == 0:
return False
# Rozkład n-1 na d * 2^r
r, d = 0, n - 1
while d % 2 == 0:
r += 1
d //= 2
# Test główny
for _ in range(k):
a = random.randint(2, n - 2)
x = pow(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 decimal_to_binary(decimal_number):
"""Konwertuje liczbę dziesiętną na zapis binarny."""
return bin(decimal_number)[2:]
def binary_to_decimal(binary_number):
"""Konwertuje liczbę binarną na system dziesiętny."""
return int(binary_number, 2)
def generate_nksn(n, ks, count):
"""
Generuje liczby w trybie (n)(ks)(n).
- n: liczba początkowa w systemie dziesiętnym.
- ks: stała liczba zer.
- count: liczba kolejnych wartości n do wygenerowania.
"""
results = []
prime_count = 0 # Licznik liczb pierwszych
composite_count = 0 # Licznik liczb złożonych
for i in range(count):
current_n = decimal_to_binary(n + i) # Liczba n w systemie binarnym
binary_result = current_n + "0" * ks + current_n
decimal_result = binary_to_decimal(binary_result)
primality = "(p)" if is_prime(decimal_result) else "(z)"
# Zliczanie liczb pierwszych i złożonych
if primality == "(p)":
prime_count += 1
else:
composite_count += 1
results.append((binary_result, decimal_result, primality))
return results, prime_count, composite_count
# Główna funkcja programu
if __name__ == "__main__":
print("Tryb A: Generowanie liczb w postaci (n)(ks)(n) z weryfikacją pierwszości")
print("Tryb A: wg. Mart'a")
print("-" * 60)
try:
ks = int(input("Podaj liczbę stałych zer (ks): "))
n = int(input("Podaj początkową liczbę (n): "))
count = int(input("Podaj liczbę kolejnych n do wygenerowania: "))
results, prime_count, composite_count = generate_nksn(n, ks, count)
print(f"{'Liczba binarna':<40} {'Liczba dziesiętna':>20} {'Pierwszość':>10}")
print("-" * 70)
for binary, decimal, primality in results:
print(f"{binary:<40} {decimal:>20} {primality:>10}")
# Podsumowanie wyników
print("-" * 70)
print(f"Liczba liczb pierwszych (p): {prime_count}")
print(f"Liczba liczb złożonych (z): {composite_count}")
except ValueError as e:
print(f"Błąd: {e}")
Kod programu dla trybu B)
Tryb B działa w sposób analogiczny do trybu A,
ale uwzględnia zmienną liczbę zer (kn) między dwiema stałymi wartościami (x).
Test Rabina-Millera gwarantuje oznaczenie liczb jako p (pierwsza) lub z (złożona).
Program w Pythonie:
import random
def is_prime(n, k=5):
"""
Test Rabina-Millera do sprawdzania, czy liczba jest pierwsza.
- n: liczba do przetestowania.
- k: liczba iteracji testu (im większa, tym większa dokładność).
"""
if n <= 1:
return False
if n <= 3:
return True
if n % 2 == 0:
return False
# Rozkład n-1 na d * 2^r
r, d = 0, n - 1
while d % 2 == 0:
r += 1
d //= 2
# Test główny
for _ in range(k):
a = random.randint(2, n - 2)
x = pow(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 decimal_to_binary(decimal_number):
"""Konwertuje liczbę dziesiętną na zapis binarny."""
return bin(decimal_number)[2:]
def binary_to_decimal(binary_number):
"""Konwertuje liczbę binarną na system dziesiętny."""
return int(binary_number, 2)
def generate_xknx(x, max_zeros):
"""
Generuje liczby w trybie (x)(kn)(x).
- x: stała liczba w systemie dziesiętnym.
- max_zeros: maksymalna liczba zer (kn).
"""
x_binary = decimal_to_binary(x)
results = []
prime_count = 0 # Licznik liczb pierwszych
composite_count = 0 # Licznik liczb złożonych
for kn in range(max_zeros + 1): # Ilość zer od 0 do max_zeros
binary_result = x_binary + "0" * kn + x_binary
decimal_result = binary_to_decimal(binary_result)
primality = "(p)" if is_prime(decimal_result) else "(z)"
# Zliczanie liczb pierwszych i złożonych
if primality == "(p)":
prime_count += 1
else:
composite_count += 1
results.append((kn, binary_result, decimal_result, primality))
return results, prime_count, composite_count
# Główna funkcja programu
if __name__ == "__main__":
print("Tryb B: Generowanie liczb w postaci (x)(kn)(x) z weryfikacją pierwszości")
print("Tryb B: wg. Mart'a")
print("-" * 60)
try:
x = int(input("Podaj liczbę stałą (x): "))
max_zeros = int(input("Podaj maksymalną liczbę zer (kn): "))
results, prime_count, composite_count = generate_xknx(x, max_zeros)
for kn, binary, decimal, primality in results:
# Wyświetlanie wyniku w dwóch wierszach
print(f"({kn}) ({binary})")
print(f"({decimal}) {primality}")
print("-" * 30) # Separator dla czytelności
# Podsumowanie wyników
print("-" * 60)
print(f"Liczba liczb pierwszych (p): {prime_count}")
print(f"Liczba liczb złożonych (z): {composite_count}")
except ValueError as e:
print(f"Błąd: {e}")
Czy to jest "Reguła? czy "Przypadek?. To jest Pytanie?
