On rappelle que les années bissextiles sont les années divisibles par 4, à l'exception de
celles qui sont divisibles par 100 sans l'être par 400.
Par exemple, 2000 est
une année bissextile (2000 est divisible par 4. 2000 est divisible par 100 mais aussi par 400 : ne fait donc
pas partie des exceptions).
2012 est divisible par 4 (et pas par 100) : 2012 est bissextile.
1900 est divisible par 4, par 100 mais pas par 400. 1900 n'est pas bissextile.
Écrire une fonction :
Entrée : un entier naturel n
Sortie : l'année n est bissextile ou pas.
Une solution de l'exercice "Année bissextile".
def bissextile(n) :
if(n % 4 == 0 and n % 100 != 0) or (n % 400 == 0):
print("L'année {} est une année bissextille".format(n))
else :
print("L'année {} n'est pas une année bissextille".format(n))
bissextile(1900)
bissextile(2000)
bissextile(2002)
bissextile(2012)
Ce qui affiche :
L'année 1900 n'est pas une année bissextille
L'année 2000 est une année bissextille
L'année 2002 n'est pas une année bissextille
L'année 2012 est une année bissextille
PGCD.
Ecrire une fonction permettant de déterminer le pgcd de deux entiers naturels \( a \) et \( b \).
Résolution de l'exercice PGCD.
Premier programme.
def pgcd(a , b) :
"""
Cette fonction permet de calculer le PGCD de deux entiers naturels a et b
"""
while b!=0 :
aux= a
a=b
b= aux%b
return a
#Programme principal
a=int(input('Entrez un entier naturel a : '))
b=int(input('Entrez un entier naturel b : '))
c = pgcd(a , b)
print("Le PGCD de {} et de {} est {}.".format(a,b,c))
Second programme.
On peut en python se passer de la variable intermédiaire aux utilisée dans le programme précédent à l'aide
d'affectations parallèles.
Par exemple, si l'on veut échanger les valeurs des variables a et b, il suffit d'écrire a,b=b,a
en langage python
(dans la plupart des autres langages, une variable auxiliaire serait nécessaire).
Cette particularité permet d'écrire un programme plus proche de notre descriptif :
def pgcd(a , b) :
"""
Cette fonction permet de calculer le PGCD de deux entiers naturels a et b
"""
while (b!=0):
a,b =b, a%b
return a
#Programme principal
a=int(input('Entrez un entier naturel a : '))
b=int(input('Entrez un entier naturel b : '))
c = pgcd(a , b)
print("Le PGCD de {} et de {} est {}.".format(a,b,c))
Calcul des coefficients binomiaux
Rappel
Soit n un entier positif, on appelle factorielle \( n \) (et on note \( n! \)) l'entier égal au produit des entiers de 1 à \( n \).
Ainsi,
\[ n! = 1\times2\times3\times...\times(n-1)\times n \text{, et par convention, } 0! = 1\]
Le coeficient binomial \( \begin{pmatrix}n \\m \end{pmatrix} \text{ avec } m \leq n\) est donné par : \( \begin{pmatrix}n \\m \end{pmatrix} =
\frac{n!}{m! \times(n - m)!}\)
Ecrire un programme utilisant une fonction pour calculer le coefficient binomial \( \begin{pmatrix}n \\m \end{pmatrix}\).
Résolution de l'exercice "Calcul des coefficients binomiaux".
def factorielle(n) :
"""
Une fonction permettant de calculer n factoriel
"""
p = 1
if (n == 0) :
return p
else :
for i in range(1, n + 1) :
p = p*i
return p
#programme principal permettant de calculer le nombre de choix d'objets
m = int(input(" Entrer un entier naturel m : "))
A = factorielle(m)
q = int(input(" Entrer la valeur de q qui est inférieure à celle de m : "))
B = factorielle(q)
D = factorielle(m-q)
C = int(A/(B*D))
print(" Le nombre de choix de {} objets parmi {} est : {}".format(q,m,C))
Ce qui affiche pour \(n = 5\) et \( m = 2 \) :
Entrer un entier naturel m : 5
Entrer la valeur de q qui est inférieure à celle de m : 2
Le nombre de choix de 2 objets parmi 5 est : 10
Suite de Fibonacci
La suite de fibonnacci est définie par :
\[
\left\{
\begin{array}{r c l}
u _ 0 &=& u _ 1 = 1 \\
u _ {n+1}&=& u_{n}+u_{n-1} \text{ pour tout entier } n \geq 1 \\
\end{array}
\right.
\]
Écrire une fonction python :
Entrée : un entier naturel n,
Sortie : afficher tous les termes de la suite de Fibonacci de rang inférieur ou égal à n.
Résolution de l'exercice "Suite de Fibonacci".
def fibo (n) :
ress=1 #résultat fibo(1)
ancien=1 #ancien résultat fibo(0)
c=1 # compte n
while c < n :
tempor = ress
ress = ress + ancien # Formule
ancien = tempor
c = c+1
return ress
#Programme principal
n = int(input("Saisir l'entier naturel n : "))
for i in range(0,n+1):
u = fibo(i)
print("le terme de la suite de fibonacci au rang {} est {}".format(i,u))
Javanais.
Les règles du javanais :
On ajoute 'av' après chaque consonne ou groupe de consonnes (comme par exemple ch, cl, ph, tr,…) d’un mot.
Si le mot commence par une voyelle, on ajoute av devant cette voyelle.
On ne rajoute jamais av après la consonne finale d’un mot.
Écrire une fonction qui prend en entrée un mot et donne en sortie sa version javanaise.
La syllabe qui vient parasiter le mot (en javanais classique : 'av') viendra également en paramètre de la fonction.
def javanais(mot, syll) :
## on passe le mot en minuscules.
motminus=mot.lower()
voyelles='aeiouy'
Voyelles='AEIOUY'
consonnes='bcdfghjklmnpqrstvwxz'
Consonnes='BCDFGHJKLMNPQRSTVWXZ'
motjav='' # contiendra la traduction javanaise.
## boucle pour ajouter syll derrière les groupes de consonnes
## sauf derrière la consonne éventuelle de fin de mot.
for j in range(len(motminus)-1) :
if (mot[j] in consonnes and motminus[j+1] not in consonnes) :
motjav+=motminus[j]+syll
else :
motjav+=motminus[j]
## On ajoute la dernière lettre du mot de départ au résultat.
motjav+=motminus[-1]
## On ajoute syll au début du mot résultat
## si mot commençait par une voyelle.
if motminus[0] in voyelles :
motjav=syll+motjav
## Raffinement pour le fun.
## si le mot commençait par une majuscule (nom propre...)
## le résultat commencera par une majuscule.
if mot[0] in Voyelles or mot[0] in Consonnes:
motjav=motjav[0].upper()+motjav[1:]
return motjav
print("javanais('Abraracourcix','av') : ", javanais('Abraracourcix','av'))
print("javanais('Abraracourcix','oz') : ", javanais('Abraracourcix','oz'))
print("javanais('pythonique','ail') : ", javanais('pythonique','ail'))