python additionner 2 nombres positive sans utiliser operateur

python additionner 2 nombres positive sans utiliser operateur - Python - Programmation

Marsh Posté le 09-07-2024 à 14:37:52    

Bonjour
 
En python
 
Comment additionner 2 nombres positives sans utiliser l'opérateur plus
 
Veuillez m'aider s'il vous plait

Reply

Marsh Posté le 09-07-2024 à 14:37:52   

Reply

Marsh Posté le 09-07-2024 à 15:11:12    

Faut poser la question à chatgpt.

Citation :


 
Pour ajouter deux nombres positifs sans utiliser l'opérateur + en Python, vous pouvez utiliser les opérations bit à bit. Voici une méthode pour y parvenir :


Code :
  1. def addition_sans_plus(a, b):
  2.     while b != 0:
  3.         # Trouver les bits qui vont générer une retenue
  4.         carry = a & b
  5.        
  6.         # Additionner les bits sans tenir compte de la retenue
  7.         a = a ^ b
  8.        
  9.         # Calculer la retenue et la décaler d'un bit vers la gauche
  10.         b = carry << 1
  11.    
  12.     return a
  13. # Exemple d'utilisation
  14. num1 = 5
  15. num2 = 7
  16. resultat = addition_sans_plus(num1, num2)
  17. print(f"La somme de {num1} et {num2} est {resultat}" )


 

Citation :


 
Explication :
Opération AND bit à bit (& ) : Cette opération permet de trouver les bits qui vont générer une retenue. Par exemple, pour 5 (101 en binaire) et 7 (111 en binaire), 5 & 7 donne 101 & 111 = 101, ce qui signifie qu'il y a des retenues aux positions des bits où les deux nombres ont des 1.
 
Opération XOR bit à bit (^) : Cette opération permet de faire l'addition des bits sans tenir compte des retenues. Par exemple, 5 ^ 7 donne 101 ^ 111 = 010.
 
Décalage à gauche (<< ) : La retenue est décalée d'un bit vers la gauche pour l'ajouter à la prochaine position significative.
 
Boucle jusqu'à ce qu'il n'y ait plus de retenue : Le processus est répété jusqu'à ce que la retenue (b) devienne zéro.
 
Cette méthode utilise uniquement des opérations bit à bit pour simuler l'addition, évitant ainsi l'utilisation directe de l'opérateur +.

Reply

Marsh Posté le 09-07-2024 à 15:20:24    

merci beaucoup

Reply

Marsh Posté le 09-07-2024 à 15:32:55    

"Décalage à gauche (<< ) : La retenue est décalée d'un bit vers la gauche pour l'ajouter à la prochaine position significative. "
pouvez vous m'expliquer cette ligne

Reply

Marsh Posté le 09-07-2024 à 15:50:00    

admettons on a a est 25 et b est 37
 
25 en binaire est 110010
37 en binaire est 100101
25 & 37 est 100000 en décimal  32
 
et  
25 en binaire est 110010
37 en binaire est 100101
25 ^ 37 est 110111 en décimal 55
 
à partir de là je ne comprend pas

Reply

Marsh Posté le 09-07-2024 à 16:12:02    

non, tes valeurs binaires sont fausses.
 
Dans l'exemple que tu donnes, ça donne ça :  


iteration 0
carry : 1  000001
a     : 25  011001
b     : 37  100101
a apr : 60  111100
b apr : 2  000010
iteration 1
carry : 0  000000
a     : 60  111100
b     : 2  000010
a apr : 62  111110
b apr : 0  000000
La somme de 25 et 37 est 62


le carry = a & b , c est pour détecter les retenues 1 + 1 en binaire ca fait une retenue, alors que 0 + 0, 0 +1 et 1 + 0 non. Le 0 + 0 , on se fiche du resultat , et le 1 + 0 Et 0 +1 , ca donne 1. Donc carry contient la position des retenues
le a = a ^b, ca fait la somme seulement sur les bits sans retenue. Donc ici :
  a^b = 25 ^37 = 011001 ^ 100101 , ca fait qu'on ajoute 011001 ^ 100101 mais pas 011001 ^ 100101. Par contre , la retenue a été détectée et est stockée dans carry .
Ensuite b prend la valeur de toutes les retenues décalée de 1, ici, il n'y en a qu'une, le 000001 qui se transforme en 000010 , car 000001 + 000001 ca fait 000010
 
Ensuite, on refait un tour de boucle et on recommence, est ce que ca génère des retenues, etc... jusqu'à ce que b vaille 0.
 
 
Voilà un autre exemple avec des nombres plus grands :  
 

iteration 0
carry : 524  00000000001000001100
a     : 524  00000000001000001100
b     : 77647  00010010111101001111
a apr : 77123  00010010110101000011
b apr : 1048  00000000010000011000
iteration 1
carry : 1024  00000000010000000000
a     : 77123  00010010110101000011
b     : 1048  00000000010000011000
a apr : 76123  00010010100101011011
b apr : 2048  00000000100000000000
iteration 2
carry : 2048  00000000100000000000
a     : 76123  00010010100101011011
b     : 2048  00000000100000000000
a apr : 74075  00010010000101011011
b apr : 4096  00000001000000000000
iteration 3
carry : 0  00000000000000000000
a     : 74075  00010010000101011011
b     : 4096  00000001000000000000
a apr : 78171  00010011000101011011
b apr : 0  00000000000000000000
La somme de 524 et 77647 est 78171


 

Reply

Marsh Posté le 09-07-2024 à 16:13:58    

plus précisément :
 
000001 + 000001 , c'est 000001 x 2 , et x2 c'est un décalage vers la gauche donc << 1, donc 000010

Reply

Marsh Posté le 09-07-2024 à 17:25:31    

ok merci

Reply

Sujets relatifs:

Leave a Replay

Make sure you enter the(*)required information where indicate.HTML code is not allowed