Cette action est irreversible, confirmez la suppression du commentaire ?
Signaler le commentaire
Veuillez sélectionner un problème
Nudité
Violence
Harcèlement
Fraude
Vente illégale
Discours haineux
Terrorisme
Autre
Olivier Miakinen
Le 30/09/2022 Í 07:17, ast a écrit :
Devinette: Que retourne cette petite fonction python (m et n sont 2 entiers naturels) def f(m, n): while n: m, n = m ^ n, (m & n) << 1 return m
Je n'ai pas encore compris comment ça fonctionne, mais cette fonction semble être une façon compliquée de réaliser une opération simple. Des quelques tests que j'ai réalisés, cela fonctionne même avec des nombres négatifs, sauf que l'appel suivant semble boucler indéfiniment : f(-10,12) -- Olivier Miakinen
Le 30/09/2022 Í 07:17, ast a écrit :
Devinette: Que retourne cette petite fonction python
(m et n sont 2 entiers naturels)
def f(m, n):
while n:
m, n = m ^ n, (m & n) << 1
return m
Je n'ai pas encore compris comment ça fonctionne, mais cette fonction
semble être une façon compliquée de réaliser une opération simple.
Des quelques tests que j'ai réalisés, cela fonctionne même avec des
nombres négatifs, sauf que l'appel suivant semble boucler indéfiniment :
f(-10,12)
Devinette: Que retourne cette petite fonction python (m et n sont 2 entiers naturels) def f(m, n): while n: m, n = m ^ n, (m & n) << 1 return m
Je n'ai pas encore compris comment ça fonctionne, mais cette fonction semble être une façon compliquée de réaliser une opération simple. Des quelques tests que j'ai réalisés, cela fonctionne même avec des nombres négatifs, sauf que l'appel suivant semble boucler indéfiniment : f(-10,12) -- Olivier Miakinen
Olivier Miakinen
Le 30/09/2022 Í 11:14, je répondais Í ast :
Devinette: Que retourne cette petite fonction python (m et n sont 2 entiers naturels) def f(m, n): while n: m, n = m ^ n, (m & n) << 1 return m
Je n'ai pas encore compris comment ça fonctionne, mais cette fonction semble être une façon compliquée de réaliser une opération simple. Des quelques tests que j'ai réalisés, cela fonctionne même avec des nombres négatifs, sauf que l'appel suivant semble boucler indéfiniment : f(-10,12)
Bien évidemment ce n'est pas le seul cas o͹ ça boucle indéfiniment, mais lorsque ça ne boucle pas le résultat est conforme aux attentes. -- Olivier Miakinen
Le 30/09/2022 Í 11:14, je répondais Í ast :
Devinette: Que retourne cette petite fonction python
(m et n sont 2 entiers naturels)
def f(m, n):
while n:
m, n = m ^ n, (m & n) << 1
return m
Je n'ai pas encore compris comment ça fonctionne, mais cette fonction
semble être une façon compliquée de réaliser une opération simple.
Des quelques tests que j'ai réalisés, cela fonctionne même avec des
nombres négatifs, sauf que l'appel suivant semble boucler indéfiniment :
f(-10,12)
Bien évidemment ce n'est pas le seul cas o͹ ça boucle indéfiniment, mais
lorsque ça ne boucle pas le résultat est conforme aux attentes.
Devinette: Que retourne cette petite fonction python (m et n sont 2 entiers naturels) def f(m, n): while n: m, n = m ^ n, (m & n) << 1 return m
Je n'ai pas encore compris comment ça fonctionne, mais cette fonction semble être une façon compliquée de réaliser une opération simple. Des quelques tests que j'ai réalisés, cela fonctionne même avec des nombres négatifs, sauf que l'appel suivant semble boucler indéfiniment : f(-10,12)
Bien évidemment ce n'est pas le seul cas o͹ ça boucle indéfiniment, mais lorsque ça ne boucle pas le résultat est conforme aux attentes. -- Olivier Miakinen
Olivier Miakinen
Le 30/09/2022 Í 11:14, j'écrivais :
def f(m, n): while n: m, n = m ^ n, (m & n) << 1 return m
Je n'ai pas encore compris comment ça fonctionne
Ok, j'ai compris comment ça fonctionne. Réponse en ROT-13. Cbhe har cnver qr ovgf qbaaéf Í yn cbfvgvba x (p'rfg-Í -qver qr cbvqf 2^x) : - f'vyf fbag gbhf yrf qrhk ahyf vyf erfgrag ahyf nceèf y'bcéengvba ; - fv y'ha qrf qrf qrhk inhg méeb rg y'nhger ha, nceèf y'bcéengvba ba ergebhir ha qnaf z rg méeb qnaf a Í prggr cbfvgvba ; - f'vyf fbag gbhf yrf qrhk étnhk Í ha, ba ergebhir méeb qnaf z Í prggr cbfvgvba, rg ha qnaf a Í yn cbfvgvba x+1. P'rfg-Í -qver dhr 2^x nwbhgé Í 2^x qbaar 2^(x+1). Crgvg Í crgvg ba rssrpghr qbap yn fbzzr qr z rg qr a, b͹ Í pundhr égncr ba ergebhir yrf fbzzrf fnaf ergrahr qnaf z rg yrf ergrahrf qnaf a. -- Olivier Miakinen
Le 30/09/2022 Í 11:14, j'écrivais :
def f(m, n):
while n:
m, n = m ^ n, (m & n) << 1
return m
Je n'ai pas encore compris comment ça fonctionne
Ok, j'ai compris comment ça fonctionne. Réponse en ROT-13.
Cbhe har cnver qr ovgf qbaaéf Í yn cbfvgvba x (p'rfg-Í -qver qr
cbvqf 2^x) :
- f'vyf fbag gbhf yrf qrhk ahyf vyf erfgrag ahyf nceèf y'bcéengvba ;
- fv y'ha qrf qrf qrhk inhg méeb rg y'nhger ha, nceèf y'bcéengvba
ba ergebhir ha qnaf z rg méeb qnaf a Í prggr cbfvgvba ;
- f'vyf fbag gbhf yrf qrhk étnhk Í ha, ba ergebhir méeb qnaf z Í
prggr cbfvgvba, rg ha qnaf a Í yn cbfvgvba x+1. P'rfg-Í -qver dhr
2^x nwbhgé Í 2^x qbaar 2^(x+1).
Crgvg Í crgvg ba rssrpghr qbap yn fbzzr qr z rg qr a, b͹ Í pundhr
égncr ba ergebhir yrf fbzzrf fnaf ergrahr qnaf z rg yrf ergrahrf
qnaf a.
def f(m, n): while n: m, n = m ^ n, (m & n) << 1 return m
Je n'ai pas encore compris comment ça fonctionne
Ok, j'ai compris comment ça fonctionne. Réponse en ROT-13. Cbhe har cnver qr ovgf qbaaéf Í yn cbfvgvba x (p'rfg-Í -qver qr cbvqf 2^x) : - f'vyf fbag gbhf yrf qrhk ahyf vyf erfgrag ahyf nceèf y'bcéengvba ; - fv y'ha qrf qrf qrhk inhg méeb rg y'nhger ha, nceèf y'bcéengvba ba ergebhir ha qnaf z rg méeb qnaf a Í prggr cbfvgvba ; - f'vyf fbag gbhf yrf qrhk étnhk Í ha, ba ergebhir méeb qnaf z Í prggr cbfvgvba, rg ha qnaf a Í yn cbfvgvba x+1. P'rfg-Í -qver dhr 2^x nwbhgé Í 2^x qbaar 2^(x+1). Crgvg Í crgvg ba rssrpghr qbap yn fbzzr qr z rg qr a, b͹ Í pundhr égncr ba ergebhir yrf fbzzrf fnaf ergrahr qnaf z rg yrf ergrahrf qnaf a. -- Olivier Miakinen
Michel Talon
Le 30/09/2022 Í 07:17, ast a écrit :
Devinette: Que retourne cette petite fonction python (m et n sont 2 entiers naturels) def f(m, n):  while n:    m, n = m ^ n, (m & n) << 1  return m pour ceux qui ne connaissent pas python "while n" c'est "pendant que n est non nul" ^ est l'opérateur "ou exclusif" bit Í bit & est le "et" bit Í bit << 1 décalage Í gauche bit Í bit et ajout d'un 0 Í droite a, b = c, d affectation simultanée a <- c et b <- d
m+n -- Michel Talon
Le 30/09/2022 Í 07:17, ast a écrit :
Devinette: Que retourne cette petite fonction python
(m et n sont 2 entiers naturels)
def f(m, n):
 while n:
   m, n = m ^ n, (m & n) << 1
 return m
pour ceux qui ne connaissent pas python
"while n" c'est "pendant que n est non nul"
^ est l'opérateur "ou exclusif" bit Í bit
& est le "et" bit Í bit
<< 1 décalage Í gauche bit Í bit et ajout d'un 0 Í droite
a, b = c, d affectation simultanée a <- c et b <- d
Devinette: Que retourne cette petite fonction python (m et n sont 2 entiers naturels) def f(m, n):  while n:    m, n = m ^ n, (m & n) << 1  return m pour ceux qui ne connaissent pas python "while n" c'est "pendant que n est non nul" ^ est l'opérateur "ou exclusif" bit Í bit & est le "et" bit Í bit << 1 décalage Í gauche bit Í bit et ajout d'un 0 Í droite a, b = c, d affectation simultanée a <- c et b <- d
m+n -- Michel Talon
Olivier Miakinen
[diapublication, suivi vers fr.sci.maths seul] Bonjour, Le 30/09/2022 Í 07:17, ast avait écrit :
def f(m, n): while n: m, n = m ^ n, (m & n) << 1 return m
Comme l'écrivait Michel Talon, cette fonction retourne simplement la somme des entiers m et n, du moins cela fonctionne pour tous les entiers positifs. À chaque tour de boucle, on retrouve dans m la somme bit Í bit des nombres m et n *sans tenir compte des retenues*, et dans n la somme de toutes les retenues. Au bout d'un petit nombre de tours de boucle, il n'y a plus aucune retenue Í faire, et alors le nombre n vaut 0 tandis que le nombre m contient le résultat attendu Í savoir la somme des nombres m et n de départ. Je voudrais maintenant étendre la question d'ast, en faisant suivre vers fr.sci.maths seul car ça n'a plus rien de spécifique Í python. Lorsque l'un des nombres est négatif, il arrive que l'algorithme ne s'arrête jamais. Par exemple lorsque m vaut -1 et que n vaut n'importe quel nombre strictement positif. Ma question est alors de déterminer pour quelles valeurs de m et n le programme s'arrête et pour quelles valeurs il ne s'arrête jamais. Question subsidiaire : lorsque le programme s'arrête, combien de tours de boucle a-t-il réalisés ? Précision pour la représentation des nombres en binaire, un nombre positif comporte « Í gauche » une infinité de chiffres binaires valant zéro, tandis que les nombres négatifs ont une infinité de chiffres Í 1. Exemples : 3 = ...0000011 2 = ...0000010 1 = ...0000001 0 = ...0000000 -1 = ...1111111 -2 = ...1111110 -3 = ...1111101 -4 = ...1111100 -- Olivier Miakinen
[diapublication, suivi vers fr.sci.maths seul]
Bonjour,
Le 30/09/2022 Í 07:17, ast avait écrit :
def f(m, n):
while n:
m, n = m ^ n, (m & n) << 1
return m
Comme l'écrivait Michel Talon, cette fonction retourne simplement
la somme des entiers m et n, du moins cela fonctionne pour tous les
entiers positifs. À chaque tour de boucle, on retrouve dans m la
somme bit Í bit des nombres m et n *sans tenir compte des retenues*,
et dans n la somme de toutes les retenues. Au bout d'un petit
nombre de tours de boucle, il n'y a plus aucune retenue Í faire, et
alors le nombre n vaut 0 tandis que le nombre m contient le résultat
attendu Í savoir la somme des nombres m et n de départ.
Je voudrais maintenant étendre la question d'ast, en faisant suivre
vers fr.sci.maths seul car ça n'a plus rien de spécifique Í python.
Lorsque l'un des nombres est négatif, il arrive que l'algorithme ne
s'arrête jamais. Par exemple lorsque m vaut -1 et que n vaut n'importe
quel nombre strictement positif.
Ma question est alors de déterminer pour quelles valeurs de m et n
le programme s'arrête et pour quelles valeurs il ne s'arrête jamais.
Question subsidiaire : lorsque le programme s'arrête, combien de
tours de boucle a-t-il réalisés ?
Précision pour la représentation des nombres en binaire, un nombre
positif comporte « Í gauche » une infinité de chiffres binaires
valant zéro, tandis que les nombres négatifs ont une infinité de
chiffres Í 1.
[diapublication, suivi vers fr.sci.maths seul] Bonjour, Le 30/09/2022 Í 07:17, ast avait écrit :
def f(m, n): while n: m, n = m ^ n, (m & n) << 1 return m
Comme l'écrivait Michel Talon, cette fonction retourne simplement la somme des entiers m et n, du moins cela fonctionne pour tous les entiers positifs. À chaque tour de boucle, on retrouve dans m la somme bit Í bit des nombres m et n *sans tenir compte des retenues*, et dans n la somme de toutes les retenues. Au bout d'un petit nombre de tours de boucle, il n'y a plus aucune retenue Í faire, et alors le nombre n vaut 0 tandis que le nombre m contient le résultat attendu Í savoir la somme des nombres m et n de départ. Je voudrais maintenant étendre la question d'ast, en faisant suivre vers fr.sci.maths seul car ça n'a plus rien de spécifique Í python. Lorsque l'un des nombres est négatif, il arrive que l'algorithme ne s'arrête jamais. Par exemple lorsque m vaut -1 et que n vaut n'importe quel nombre strictement positif. Ma question est alors de déterminer pour quelles valeurs de m et n le programme s'arrête et pour quelles valeurs il ne s'arrête jamais. Question subsidiaire : lorsque le programme s'arrête, combien de tours de boucle a-t-il réalisés ? Précision pour la représentation des nombres en binaire, un nombre positif comporte « Í gauche » une infinité de chiffres binaires valant zéro, tandis que les nombres négatifs ont une infinité de chiffres Í 1. Exemples : 3 = ...0000011 2 = ...0000010 1 = ...0000001 0 = ...0000000 -1 = ...1111111 -2 = ...1111110 -3 = ...1111101 -4 = ...1111100 -- Olivier Miakinen
Olivier Miakinen
Le 30/09/2022 Í 07:17, ast a écrit :
Devinette: Que retourne cette petite fonction python (m et n sont 2 entiers naturels) def f(m, n): while n: m, n = m ^ n, (m & n) << 1 return m
Même question, en ajoutant un simple ~ Í la troisième ligne : def f(m, n): while n: m, n = m ^ n, (~m & n) << 1 return m
pour ceux qui ne connaissent pas python "while n" c'est "pendant que n est non nul" ^ est l'opérateur "ou exclusif" bit Í bit & est le "et" bit Í bit << 1 décalage Í gauche bit Í bit et ajout d'un 0 Í droite a, b = c, d affectation simultanée a <- c et b <- d
Toujours pour ceux qui ne connaissent pas python : ~ est l'opérateur « inverser tous les bits » (les 1 deviennent des 0 et les 0 deviennent des 1) En particulier, si m est un nombre entier, -m est égal Í (~m + 1) -- Olivier Miakinen
Le 30/09/2022 Í 07:17, ast a écrit :
Devinette: Que retourne cette petite fonction python
(m et n sont 2 entiers naturels)
def f(m, n):
while n:
m, n = m ^ n, (m & n) << 1
return m
Même question, en ajoutant un simple ~ Í la troisième ligne :
def f(m, n):
while n:
m, n = m ^ n, (~m & n) << 1
return m
pour ceux qui ne connaissent pas python
"while n" c'est "pendant que n est non nul"
^ est l'opérateur "ou exclusif" bit Í bit
& est le "et" bit Í bit
<< 1 décalage Í gauche bit Í bit et ajout d'un 0 Í droite
a, b = c, d affectation simultanée a <- c et b <- d
Toujours pour ceux qui ne connaissent pas python :
~ est l'opérateur « inverser tous les bits » (les 1 deviennent des 0
et les 0 deviennent des 1)
En particulier, si m est un nombre entier, -m est égal Í (~m + 1)
Devinette: Que retourne cette petite fonction python (m et n sont 2 entiers naturels) def f(m, n): while n: m, n = m ^ n, (m & n) << 1 return m
Même question, en ajoutant un simple ~ Í la troisième ligne : def f(m, n): while n: m, n = m ^ n, (~m & n) << 1 return m
pour ceux qui ne connaissent pas python "while n" c'est "pendant que n est non nul" ^ est l'opérateur "ou exclusif" bit Í bit & est le "et" bit Í bit << 1 décalage Í gauche bit Í bit et ajout d'un 0 Í droite a, b = c, d affectation simultanée a <- c et b <- d
Toujours pour ceux qui ne connaissent pas python : ~ est l'opérateur « inverser tous les bits » (les 1 deviennent des 0 et les 0 deviennent des 1) En particulier, si m est un nombre entier, -m est égal Í (~m + 1) -- Olivier Miakinen
ast
Le 30/09/2022 Í 11:29, Olivier Miakinen a écrit :
Le 30/09/2022 Í 11:14, j'écrivais :
def f(m, n): while n: m, n = m ^ n, (m & n) << 1 return m
Je n'ai pas encore compris comment ça fonctionne
Ok, j'ai compris comment ça fonctionne. Réponse en ROT-13. Cbhe har cnver qr ovgf qbaaéf Í yn cbfvgvba x (p'rfg-Í -qver qr cbvqf 2^x) : - f'vyf fbag gbhf yrf qrhk ahyf vyf erfgrag ahyf nceèf y'bcéengvba ; - fv y'ha qrf qrf qrhk inhg méeb rg y'nhger ha, nceèf y'bcéengvba ba ergebhir ha qnaf z rg méeb qnaf a Í prggr cbfvgvba ; - f'vyf fbag gbhf yrf qrhk étnhk Í ha, ba ergebhir méeb qnaf z Í prggr cbfvgvba, rg ha qnaf a Í yn cbfvgvba x+1. P'rfg-Í -qver dhr 2^x nwbhgé Í 2^x qbaar 2^(x+1). Crgvg Í crgvg ba rssrpghr qbap yn fbzzr qr z rg qr a, b͹ Í pundhr égncr ba ergebhir yrf fbzzrf fnaf ergrahr qnaf z rg yrf ergrahrf qnaf a.
oui bien vu m contient la somme sans les retenues et n contient les retenues On additionne les retenues après coup, ce qui génère de nouvelles retenues, et on réitère pendant qu'il y a des retenues.
Le 30/09/2022 Í 11:29, Olivier Miakinen a écrit :
Le 30/09/2022 Í 11:14, j'écrivais :
def f(m, n):
while n:
m, n = m ^ n, (m & n) << 1
return m
Je n'ai pas encore compris comment ça fonctionne
Ok, j'ai compris comment ça fonctionne. Réponse en ROT-13.
Cbhe har cnver qr ovgf qbaaéf Í yn cbfvgvba x (p'rfg-Í -qver qr
cbvqf 2^x) :
- f'vyf fbag gbhf yrf qrhk ahyf vyf erfgrag ahyf nceèf y'bcéengvba ;
- fv y'ha qrf qrf qrhk inhg méeb rg y'nhger ha, nceèf y'bcéengvba
ba ergebhir ha qnaf z rg méeb qnaf a Í prggr cbfvgvba ;
- f'vyf fbag gbhf yrf qrhk étnhk Í ha, ba ergebhir méeb qnaf z Í
prggr cbfvgvba, rg ha qnaf a Í yn cbfvgvba x+1. P'rfg-Í -qver dhr
2^x nwbhgé Í 2^x qbaar 2^(x+1).
Crgvg Í crgvg ba rssrpghr qbap yn fbzzr qr z rg qr a, b͹ Í pundhr
égncr ba ergebhir yrf fbzzrf fnaf ergrahr qnaf z rg yrf ergrahrf
qnaf a.
oui bien vu
m contient la somme sans les retenues et n contient les retenues
On additionne les retenues après coup, ce qui génère de nouvelles
retenues, et on réitère pendant qu'il y a des retenues.
Le 30/09/2022 Í 11:29, Olivier Miakinen a écrit :
Le 30/09/2022 Í 11:14, j'écrivais :
def f(m, n): while n: m, n = m ^ n, (m & n) << 1 return m
Je n'ai pas encore compris comment ça fonctionne
Ok, j'ai compris comment ça fonctionne. Réponse en ROT-13. Cbhe har cnver qr ovgf qbaaéf Í yn cbfvgvba x (p'rfg-Í -qver qr cbvqf 2^x) : - f'vyf fbag gbhf yrf qrhk ahyf vyf erfgrag ahyf nceèf y'bcéengvba ; - fv y'ha qrf qrf qrhk inhg méeb rg y'nhger ha, nceèf y'bcéengvba ba ergebhir ha qnaf z rg méeb qnaf a Í prggr cbfvgvba ; - f'vyf fbag gbhf yrf qrhk étnhk Í ha, ba ergebhir méeb qnaf z Í prggr cbfvgvba, rg ha qnaf a Í yn cbfvgvba x+1. P'rfg-Í -qver dhr 2^x nwbhgé Í 2^x qbaar 2^(x+1). Crgvg Í crgvg ba rssrpghr qbap yn fbzzr qr z rg qr a, b͹ Í pundhr égncr ba ergebhir yrf fbzzrf fnaf ergrahr qnaf z rg yrf ergrahrf qnaf a.
oui bien vu m contient la somme sans les retenues et n contient les retenues On additionne les retenues après coup, ce qui génère de nouvelles retenues, et on réitère pendant qu'il y a des retenues.
