simplification d'une factorielle Résolu/Fermé

Question

Bonjour,

Pouvez-vous m'aider pour comprendre comment je pourrais résoudre le problème s'il vous plaît.

Je dois réaliser une fonction qui simplifie les factorielles si l'entier est inférieur à 1000, je renvoie l'entier sinon si l'entier est plus petit que 1 million, je renvoie le nombre des milliers avec la notation "K" et ainsi de suite , pour les Méga (noté M), les Giga (noté G) et pour les Téra(noté T) .Puis, lorsque le nombre est plus grand que des Téra  je dois continuer avec des bilettres.

Voici un exemple :

1 : 1
1 : 1
2 : 2
6 : 6
24 : 24
120 : 120
720 : 720
5K : 5 040
40K : 40 320
362K : 362 880
3M : 3 628 800
39M : 39 916 800
479M : 479 001 600
6G : 6 227 020 800
87G : 87 178 291 200
1T : 1 307 674 368 000
20T : 20 922 789 888 000
355T : 355 687 428 096 000
6aa : 6 402 373 705 728 000
121aa : 121 645 100 408 832 000
2ab : 2 432 902 008 176 640 000
451ab : 51 090 942 171 709 440 000
1ac : 1 124 000 727 777 607 680 000
25ac : 25 852 016 738 884 976 640 000
620ac : 620 448 401 733 239 439 360 000
15ad : 15 511 210 043 330 985 984 000 000
403ad : 403 291 461 126 605 635 584 000 000
10ae : 10 888 869 450 418 352 160 768 000 000
304ae : 304 888 344 611 713 860 501 504 000 000
8af : 8 841 761 993 739 701 954 543 616 000 000

def factoriel( entier:int):
    
    if (entier == 1 or entier == 0):
        return 1

return entier * factoriel(entier - 1 )

def simplification(n : int):
    """
    permet de simplifier l'entier 
    """
    lst = ["K","M","G","T"]
    if (n < 1000):
        return n
    cpt = 0
    while (n > 1000):

n = n // 1000
        cpt += 1
        i
        print(cpt)
    if (cpt < len(lst)):#si le nombre n'est pas dans la liste le code plante
        n = str(n) + lst[cpt - 1]
    return n

for i in range(0, 100):
    n = factoriel(i)
    print(f"{n} :",simplification(n))

Je vous remercie d'avance.
Linux / Firefox 109.0

PierrotLeFou · Answer

Est-ce que ta question est de savoir comment générer une liste bi-lettres?Voici comment:
from string import ascii_uppercase as upper
# ...
big = [a+b for a in upper for b in upper]
Tu auras 676 symboles de plus.
De quoi aller jusqu'à 1000**688

Petit test:

>>> f = lambda n: 1 if n <= 1 else n * f(n-1)                                                                           
>>> from math import *                                                                                                  
>>> log10(f(100))                                                                                                       
157.97000365471578

45K · Answer

Du coup, générer une liste bi-lettre permet de transformer le factorielle d'un nombre comment celui-ci 8 841 761 993 739 701 954 543 616 000 000 en un ça " 8af " parce que je ne pense pas avoir compris le principe d'une liste bi-lettre.
Pouvez-vous m'expliquer s'il vous plaît ?

Utilisateur anonyme · Answer

Bonsoir

d'abord ce type de représentation n'est pas liée aux factorielles, mais aux grands nombres (ou au petits nombres).

Les 3 cas les plus courants sont

les masses :il y a le gramme et le kilo gramme (oui c'est le même k pour dire 1000 grammes)
	les distances: il y a le mètre et le kilomètre 
	le volume des données informatiques (le Giga octect...)

Si on prend une distance vraiment grande, l'unité astronomique (moyenne terre - soleil) vaut égale à 149 597 870 700 mètres, soit 149 597 871 km, ou 149 598 Mm, ou encore 150 Gm.

A chaque fois, on divise par 1000, on arrondi avec un nombre de décimales qui semble approprié au contexte (149, 597 870 700 Gm n'aurait pas vraiment de sens) et on ajoute la lettre signifiant le facteur d'échelle.

Jusque là, ce sont des représentations normées, le suivant devrait être P pour Péta.

Mais ton prof a décidé de te faire travailler autre chose, et à proposé sa propre représentation, le facteur d'échelle suivant est aa, puis  ab, puis ac, etc....

Il a juste changé de convention.

PierrotLeFou · Answer

Est-ce que tu comprends avec les suffixes à une lettre seulement? As-tu testé ce code?
La variable  cpt  représente la position dans le tableau  lst (une liste).
Pour continuer, tu n'as qu'à remettre cpt à 0, et tu continues à diviser le nombre par 1000.
Au lieu de prendre le suffixe dans lst, tu le prends dans la nouvelle liste.
Pour 100!, tu n'auras pas besoin de toute la liste.
10**157 ~= 1000**53

Utilisateur anonyme · Answer

Bonjour Pierrot

ta façon de générer la liste de bilettres peut s'apparenter à de la magie pour qui ne maîtrise pas encore python.

Certes, c'est net, propre et sans bavure, ça exploite toute la capacité de python, mais ça ne répond pas, je pense, au but recherché par le prof de 45k.

A mon avis, ce prof cherche à développer le sens de l'algorithmique.

A mon avis, il s'attend plus à une solution à base de boucle(s).

45k, je te propose une piste de réflexion.

Quel sera le bilettre pour cpt = 10?

Décris moi la démarche qui t'as permis de répondre.

45K · Answer

Je pense avoir compris le résultat s'est "af"

Mon raisonnement :
Je sais que ma première lettre sera un "a" parce qu'on n'a pas parcouru tout l'alphabet.
Puis, ma deuxième lettre sera le nombre d'éléments de ma liste - cpt du coup, j'obtiens 6 et la 6e lettre de l'alphabet est "f"

Utilisateur anonyme · Answer

C'est ça.

Et ton raisonnement est transposable en code.

45K · Answer

MERCI ! j'ai trouvé le code

PierrotLeFou · Answer

D'après ta réponse précédente, je ne suis pas convaincu que tu as compris.
Quel suffixe te donne 100! qui est de l'ordre de 10**157 comme je l'ai mentionné?
10**157 = 10**156 * 10
10**156 = 1000**52
Si je soustrait 10**12 pour les Tera (ou 1000**4), ça me donne 1000**48, donc la 48ième séquence.
(j'ai dit "soustrait", je parle des exposants)

Simplification d'une factorielle

9 réponses

Discussions similaires