MPSI, PCSI et la PTSI

Notification de cookies

Nous utilisons des cookies pour améliorer votre expérience. En poursuivant votre navigation sur ce site, vous acceptez l'utilisation de cookies. Plus d'informations

Exercices corrigés Python (Série 9)

Exercice 1

Un nombre heureux est un nombre entier qui, lorsqu’on ajoute les carrés de chacun de ses chiffres, puis les carrés des chiffres de ce résultat et ainsi de suite jusqu'à l’obtention d’un nombre à un seul chiffre égal à 1 (un).

Exemple :

N=7 est heureux, puisque :

  •  72=49
  •  42+92=97
  •  92+72=130
  •  12+32+02=10
  •  12+02=1

On est arrivé à un nombre d’un seul chiffre qui est égal à 1, donc N=7 est heureux

Travail demandé :

Ecrire une fonction heureux(nb) qui permet de déterminer si un nombre entier nb est heureux ou non.


Solution :
                                def heureux(nb):
                                    etat = False  # etat du nombre, est ce que c'est heureux ou non par défaut le nombre n'est pas heureux
                                    # verifier est ce que le nombre est inférieur à 10
                                    nombre = str(nb)
                                    limite = False
                                    while limite == False:
                                        s = 0
                                        for i in nombre:
                                            s += int(i)**2
                                        nombre = str(s)
                                        if nombre == '1':
                                            etat = True
                                            break
                                        if int(nombre) < 10:  # si le nombre<10 donc limite=True
                                            limite = True
                                    return etat
                                
                                
                                print(heureux(7))
                                
                            

Lorsque le code ci-dessus est compilé et exécuté, il produit le résultat suivant

True

Exercice 2

Un entier est dit distinct s’il est composé de chiffres distincts (différents).
Ecrire une fonction estdistinct(nb) qui permet de vérifier et d’afficher si nb est distinct ou non.

Exemple
  •  N=1273 est dit distinct car il est formé par les chiffres 1, 2, 7 et 3 qui sont tous distincts, donc, le programme affichera : cet entier est distinct
  •  N=1565 est dit non distinct car il est formé par les chiffres 1, 5, 6, 5 qui ne sont pas tous distincts (le chiffre 5 se répète deux fois, donc le programme affichera : cet entier est non distinct

Solution :
                                def robinson(n):
                                    U = 0
                                    for _ in range(1, n+1):
                                        ch = str(U)
                                        L = [0, 0, 0, 0, 0, 0, 0, 0, 0, 0]
                                        for chiffre in ch:
                                            L[int(chiffre)] += 1
                                        res = ''
                                        for j in range(9, -1, -1):
                                            if L[j] != 0:
                                                res += str(L[j])+str(j)
                                        U = int(res)
                                    print('Terme : ', n, ' est ', U)
                                
                                
                                robinson(5)
                                
                            

Lorsque le code ci-dessus est compilé et exécuté, il produit le résultat suivant

Terme : 5 est 13123110

Exercice 3

La suite de robinson est définie par :

  •  U0=0
  •  Un se construit en concaténant le nombre d’apparition de chacun des chiffres constituant le terme Un-1 suivi du chiffre lui-même, selon l’ordre décroissant des chiffres, pour tout n>0.

Exemple :

Pour n=5, U5=13123110

En effet :

  •  U0=0
  •  U1=10 car il y a une apparition (1) du chiffre 0 dans U0
  •  U2=1110 car il y’a une apparition (1) du chiffre 1 et une apparition (1) du chiffre 0 dans U1
  •  U3=3110 car il y’a une apparition (3) du chiffre 1 et une apparition (1) du chiffre 0 dans U2
  •  U4=132110 car il y’a une apparition (1) du chiffre 3, deux apparition du chiffre 1 et une apparition (1) du chiffre 0 dans U3
  •  U5=13123110 car il y’a une apparition (1) du chiffre 3, une apparition du chiffre 2, trois apparitions du chiffre 1 et une apparition (1) du chiffre 0 dans U3
Travail demandé :

Ecrire une fonction Robinson(N) permettant de calculer le Nième terme de la suite de robinson


Solution :
                                def estdistinct(n):
                                    etat = True
                                    if n > 0:
                                        ch = str(n)
                                        for lettre in ch:
                                            if ch.count(lettre) > 1:
                                                etat = False
                                                break
                                        if etat == True:
                                            print(n, ' est distinct')
                                        else:
                                            print(n, ' est non distinct')
                                    else:
                                        print('le nombre est négatif ')
                                
                                
                                estdistinct(1273)
                                estdistinct(1565)
                            

Lorsque le code ci-dessus est compilé et exécuté, il produit le résultat suivant

1273 est distinct
1565 est non distinct

Partager ce cours avec tes amis :

Rédigé par M. ESSADDOUKI

Learning a new programming language is an easy thing, but the most difficult thing is how to design efficient algorithms for real-world problems, so don't be a programmer, be a problems solver.

Cours Similaires :