Bonjour,
on te demande de le faire avec Xcas c'est pour une bonne raison !

la calculette est largement insuffisante pour répondre aux questions posées.

21!=5,1090942*10^19 faux
Xcas donne la valeur exacte (c'est pour ça qu'on demande de le faire avec Xcas)

21! = 51090942171709440000

Xcas est gratuit et si tu ne veux pas l'installer, tu peux toujours l'utiliser "en ligne"
par exemple là

Merci ! Mais je l'ai installé et je ne comprends vraiment rien aux algorithmes, je ne comprends même pas les questions... Ne pourriez-vous pas m'aider s'il vous plaît?

les algorithmes ici c'est quasiment du français
"tant que" est une boucle que l'on exécute tant que (expression française courante) la condition qui est écrite derrière est vraie

c'est quoi cette condition ?
c'est "q est il égal à la partie entière de q"
(floor() = "partie entière de" : lire la doc de Xcas, mais c'est standard pour presque tous les logiciels cette fonction là)

dans quel cas un nombre n'est il pas égal à sa partie entière ?

cela te donnera la condition d'arrêt de la boucle

maintenant que fait-on dans cette boucle ?
on fait deux choses
- l'opération mystère que l'on demande dans la question (compléter les "...")
- et on divise q par 10

si on regarde d'un peu plus loin l'algorithme on remarque une variable "compteur" qui est le résultat que l'on affiche à la fin :
retourne compteur;
veut dire que ce programme "retourne" (renvoie, répond) la valeur de la variable compteur.

qu'affichera-t-on si on ne met rien à la place des ... ??
que vaudrait compteur depuis le début ? a-t-il été modifié ?
et donc tu l'as la ligne manquante !


pour la question b, on utilise une fonction irem()
voir dans la doc ce qu'elle calcule.

qu'est ce qu'on pourrait bien "retourner" à la fin du programme ?
(pareil que pour la a)


comme tout cet exercice à pratiquement comme seul but la prise en main du logiciel Xcas, il faut apprendre à se débrouiller avec
(lire la doc, essayer : ça ne mord pas etc c'est comme pour n'importe quel logiciel)

Je pense avoir compris pour le 2)
a)   je pense que la ligne manquante est:
compteur:=compteur+1;
b), je pense que c'est:
retourne c-1
c),ah, si, il faut compter les 5
le nombre de 0 à la fin, c'est la puissance de 5 quand on fait la décomposition de n!

En revanche le 3) je ne vois vraiment pas

OK

2c : ceci est une conjecture (sera démontrée question 3c pour affirmer qu'il y au moins autant de 2 que de 5)

3a)
on te demande de fabriquer toi-même un algorithme

comment ferais tu à la main pour répondre à la question ? (pas de machine pas d'algorithme, juste quelle méthode)
(diverses possibilité de méthodes pour faire ça)

traduire alors une de ces méthodes (au choix) en un algorithme
c'est à dire décrire précisément et exactement les opérations et l'enchainement de ces opérations (en français et formules)

alors la traduction de cet algorithme en langage Xcas sera assez facile

mais il faut commencer par le commencement :
comment peut on faire à la main pour obtenir l'exposant de 5 dans la décomposition en facteurs premiers ?

merci. je ne comprends vraiment pas

de toute façon je dois quitter.
pas le temps de te faire un cours sur comment on peut faire à la main pour compter l'exposant de 5 dans une décomposition à la main en facteurs premiers (ou pas d'ailleurs, on s'en fiche des autres facteurs premiers) !!!

parce que je suis persuadé que tu sais le faire, à la min avec une feuille de papier

simplement que le seul mot "Xcas" et "algorithme" te bloque complètement pour uniquement des raisons purement psychologiques.

comment ferais tu à la main pour calculer l'exposant de 5 dans la décomposition de 18046875 (au hasard)

Bonsoir,

Avec XCas la commande factoriser_entier(21!) donne
2^18*3^9*5^4*7^3*11*13*17*19
Voici pour exemple un programme en Visual Basic (mode console) qui extrait l'exposant du nombre 5
(dim est une commande de déclaration d'une variable)
(l'apostrophe débute un commentaire sur le restant de la ligne)

Dim n As String = "2^18*3^9*5^4*7^3*11*13*17*19"
        Dim p As String = "5"
        If n.Contains(p) Then
            Dim i As Integer = InStr(n, p) 'premier caractère en position 1
            i += -1 + p.Length 'premier caractère à l'indes i=0
            Dim e As Integer = 0 ' e sera l'exposant trouvé
            If n.ElementAt(i) = "^" Then 'y-a-t'il un exposant ?
                Dim j As Integer = i + 1 'reconstituer l'exposant chiffre à chiffre
                While IsNumeric(n.ElementAt(j))
                    e = e * 10 + Val(n.ElementAt(j)) 'Val convertit le caractère en chiffre
                    j += 1
                End While
            Else
                e = 1
            End If
            Console.WriteLine(p & "^" & e)
        Else
            Console.WriteLine("p n'est pas un facteur premier de n")
        End If

re Bonsoir

dans mon programme-exemple , après

If n.Contains(p) Then
            Dim i As Integer = InStr(n, p)

re Bonsoir,

Trouver l'exposant du facteur premier 5 dans 21!

Dim nombre As BigInteger 'créer 21!
        nombre = 1
        For i = 1 To 21
            nombre *= i
        Next

        Dim d As BigInteger
        d = 5
        Dim exp As Integer = 0
        Do
            If BigInteger.Remainder(nombre, d) = 0 Then
                nombre /= d
                exp += 1
            Else
                Exit Do
            End If
        Loop
        Console.WriteLine("l'exposant de " & d.ToString & " est " & exp)

re,

d'une part on demande de le faire avec Xcas et ensuite il s'agit encore et toujours de ne pas brûler les étapes

par quelle méthode décrite avec des mots je vais trouver

cette étape est absolument indispensable avant d'imaginer écrire la moindre ligne de code que ce soit
et doit être faite explicitement


donc ici il se dégage deux méthodes principales :

- décomposer N en facteurs premiers et "lire" dans cette décomposition l'exposant de 5

autre méthode
- diviser par 5 autant qu'on peut (tant que ça donne un nombre entier) et le nombre de fois qu'on aura pu diviser par 5 est l'exposant de 5 dans la décomposition (j'écrivais bien "ou pas")

cette deuxième méthode ressemble tellement à "combien de fois on a pu diviser par 10 pour trouver le nombre de zéros à la fin" que l'algorithme pour la réaliser est quasiment le même que celui qui a déja été écrit !!!

je le rappelle :

nbZero(n):={
local compteur, q;
compteur:=0;
q:=n/10
tant que q==floor(q) faire
compteur = compteur+1; // ligne ajoutée qui faisait l'objet de la question d'avant
q:=q/10
ftantque;
retourne compteur;
}:;

j'ai mis en rouge le seul truc à modifier pour obtenir l'exposant de 5 !!
la modification est instantanée (et changer le nom du programme bien entendu )

Bonjour,

A mathafou : Vous donnez des solutions absolument précises et dans le droit fil de l'exercice. Très bien, mais...
en l'occurrence, et sans doute en raison d'une connaissance insuffisante de la programmation XCas, on ne voit pas quel type de données sont manipulées, ni quelles divisions sont effectuées (q:=n/10) alors que c'est toujours connu en typage statique (C,C++, VB.net,..) ou dynamique (Python, différence entre q/10 et q//10) : Ce sont les comparaisons qui risquent d'être illusoires ( q==floor(q) )...

on est d'accord que cet exercice n'est pas "portable" tel quel dans un autre langage
il n'empêche que quel que soit le langage la méthodologie est toujours la même pour analyser le problème avant d'écrire la moindre ligne de code

et ensuite on traduit l'algorithme (dans lequel on ne se pose pas de questions sur la taille des mots de la machine etc) en un programme.
et en adaptant ce codage aux particularités du langage utilisé, aux caractéristiques "physiques" sur le codage dans la machine des "nombres" mathématiques.

l'algorithme est une représentation purement "mathématique" et idéalisée des opérations à effecteur
en mathématique les nombres entiers sont des nombres entiers et c'est tout et une division donne un nombre réel "idéal" avec toute son infinité de décimales au besoin.

c'est à la traduction de cet algorithme "en machine" qu'on se posera ce genre de questions.
et on est parfaitement d'accord que là il faudra bien se poser ces questions de précision, de types de nombres etc.

tu as raison de le faire remarquer "au plus tôt" même si ça passe inaperçu en Xcas qui choisit de lui même la précision "suffisante" sans rien en dire à l'utilisateur.
en être conscient rapidement dans l'apprentissage de la programmation est indispensable.