Programmation modulaire pratique
Applications de l'arithmétique modulaire dans le monde réel
L'arithmétique modulaire va bien au-delà des simples calculs mathématiques et trouve des applications cruciales dans divers domaines du développement logiciel et de l'informatique.
Cryptographie et sécurité
Simulation de chiffrement RSA
def generate_keypair(p, q):
n = p * q
phi = (p-1) * (q-1)
def mod_inverse(a, m):
for x in range(1, m):
if (a * x) % m == 1:
return x
return None
## Public key generation
e = 65537
d = mod_inverse(e, phi)
return ((e, n), (d, n))
## Example key generation
public, private = generate_keypair(61, 53)
print("Public Key:", public)
print("Private Key:", private)
Techniques de validation de données
Validation de numéro de carte de crédit
def luhn_algorithm(card_number):
digits = [int(x) for x in str(card_number)]
checksum = 0
for i in range(len(digits)-2, -1, -1):
digit = digits[i] * 2
checksum += digit if digit < 10 else digit - 9
return (checksum + digits[-1]) % 10 == 0
## Validation examples
print(luhn_algorithm(4111111111111111)) ## Valid card
print(luhn_algorithm(4111111111111112)) ## Invalid card
Optimisation algorithmique
Implémentation de table de hachage
class ModularHashTable:
def __init__(self, size=100):
self.size = size
self.table = [[] for _ in range(size)]
def _hash_function(self, key):
return hash(key) % self.size
def insert(self, key, value):
index = self._hash_function(key)
self.table[index].append((key, value))
def get(self, key):
index = self._hash_function(key)
for stored_key, value in self.table[index]:
if stored_key == key:
return value
raise KeyError(key)
Visualisation de l'arithmétique modulaire
graph TD
A[Input Data] --> B[Modular Hash Function]
B --> C{Distribute to Buckets}
C --> D[Efficient Storage]
C --> E[Quick Retrieval]
Technique |
Complexité temporelle |
Complexité spatiale |
Recherche standard |
O(n) |
O(n) |
Hachage modulaire |
O(1) |
O(n) |
Résolution de collisions |
O(k) |
O(1) |
Cas d'utilisation pratiques
Implémentation de tampon circulaire
class CircularBuffer:
def __init__(self, capacity):
self.buffer = [None] * capacity
self.capacity = capacity
self.head = 0
self.tail = 0
self.size = 0
def enqueue(self, item):
if self.is_full():
self.head = (self.head + 1) % self.capacity
else:
self.size += 1
self.buffer[self.tail] = item
self.tail = (self.tail + 1) % self.capacity
def is_full(self):
return self.size == self.capacity
Techniques avancées
Opérations basées sur le temps
def periodic_task_scheduler(interval, total_time):
for current_time in range(total_time):
if current_time % interval == 0:
print(f"Executing task at time {current_time}")
## Run tasks every 5 time units
periodic_task_scheduler(5, 30)
Pratiques recommandées par LabEx
- Utilisez l'arithmétique modulaire pour une distribution efficace des données
- Implémentez des fonctions de hachage avec des opérations de modulo
- Tenez compte des implications sur les performances dans les systèmes à grande échelle
Conclusion
La programmation modulaire pratique démontre la polyvalence de l'arithmétique modulaire pour résoudre efficacement et élégamment des problèmes de calcul complexes.