Exercice 1 : (niv.1)

Écrire un programme qui trouvera tous ces nombres qui sont divisibles par $7$ mais qui ne sont pas un multiple de $5$, entre $2000$ et $3200$ (les deux inclus). Les nombres obtenus doivent être affichés dans une séquence séparée par des virgules sur une seule ligne.

l=[]
for i in range(2000, 3201):
    if (i%7==0) and (i%5!=0):
        l.append(str(i))

print('||'.join(l))

2002||2009||2016||2023||2037||2044||2051||2058||2072||2079||2086||2093||2107||2114||2121||2128||2142||2149||2156||2163||2177||2184||2191||2198||2212||2219||2226||2233||2247||2254||2261||2268||2282||2289||2296||2303||2317||2324||2331||2338||2352||2359||2366||2373||2387||2394||2401||2408||2422||2429||2436||2443||2457||2464||2471||2478||2492||2499||2506||2513||2527||2534||2541||2548||2562||2569||2576||2583||2597||2604||2611||2618||2632||2639||2646||2653||2667||2674||2681||2688||2702||2709||2716||2723||2737||2744||2751||2758||2772||2779||2786||2793||2807||2814||2821||2828||2842||2849||2856||2863||2877||2884||2891||2898||2912||2919||2926||2933||2947||2954||2961||2968||2982||2989||2996||3003||3017||3024||3031||3038||3052||3059||3066||3073||3087||3094||3101||3108||3122||3129||3136||3143||3157||3164||3171||3178||3192||3199

Exercice 2 : (niv.1)

Écrire une fonction fact(x) qui calcule $x!$.

Tester $8$, résultat : $40320$

Indication : utiliser la fonction input() de python

def fact(x):
    if x == 0:
        return 1
    return x * fact(x - 1)

x=int(input())
print(fact(x))

Exercice 3 : (niv.1)

En partant d'un nombre entier $n$, écrire un programme pour générer le dictionnaire qui contient les éléments $(i: i^2)$ pour tous les entier $i$ allant de $1$ à $n$ (les deux inclus). Afficher le dictionnaire.

Tester $8$, résultat: {1: 1, 2: 4, 3: 9, 4: 16, 5: 25, 6: 36, 7: 49, 8: 64}

n=int(input())
d=dict()
for i in range(1,n+1):
    d[i]=i*i

print(d)

Exercice 4 : (niv.1)

Écrire un programme qui accepte en entrée une séquence de nombre séparés par une virgule et qui génère une liste et un tuple qui contiennent la séquence.

Tester la séquence 34,67,55,33,12,98. La sortie sera :

['34', '67', '55', '33', '12', '98']

('34', '67', '55', '33', '12', '98')

a = "toto"
dir(a)

values=input()
l=values.split(",")
t=tuple(l)
print(l)
print(t)

Exercice 5. (niv.1)

Définir une classe qui contient comme élément une chaine de caractère et au moins deux méthodes : getString: pour entrer la chaine de caractère à partir de la console printString: pour afficher la chaine de caractère en majuscule.

class InputOutString(object):
    def __init__(self):
        self.s = ""

    def getString(self):
        self.s = input()

    def printString(self):
        print(self.s.upper())

strObj = InputOutString()
strObj.getString()
strObj.printString()

Exercice 6. (niv.2)

Écrire un programme qui calcule et affiche la valeur obtenue via la formule suivante: $$Q = \sqrt{\left[\frac{2 C D}{H}\right]}$$

Les valeurs des constantes sont $C=50$ et $H=30$ :

$D$ est la variable dont les valeurs doivent être entrées dans votre programme dans une séquence séparée par des virgules.

Exemple :

Tester la séquence : $100,150,180$. La sortie du programme devrait être : $18,22,24$.

import math
c=50
h=30
value = []
items=[x for x in input().split(',')]
for d in items:
    value.append(str(int(round(math.sqrt(2*c*float(d)/h)))))

print(','.join(value))

Exercice 7. (niv.2)

Écrire un programme qui prend en entrée deux chiffres, $X$ et $Y$, et génère une matrice (tableau à deux dimensions). La valeur de l'élément dans la $i$-ème ligne et la $j$-ème colonne du tableau doit être $i\times j$.

Remarque : $i=0,1, \ldots, X-1$ et $j=0,1, \ldots, Y-1$.

Exemple

Supposons que les entrées suivantes soient données au programme : $3,5$ Alors, la sortie du programme devrait être :

$[[0, 0, 0, 0, 0], [0, 1, 2, 3, 4], [0, 2, 4, 6, 8]]$

input_str = input()
dimensions=[int(x) for x in input_str.split(',')]
print(dimensions)

input_str = input()
dimensions=[int(x) for x in input_str.split(',')]
rowNum=dimensions[0]
colNum=dimensions[1]
multilist = [[0 for col in range(colNum)] for row in range(rowNum)]

for row in range(rowNum):
    for col in range(colNum):
        multilist[row][col]= row*col

print(multilist)

import numpy as np
input_str = input()
dimensions=[int(x) for x in input_str.split(',')]
rowNum=dimensions[0]
colNum=dimensions[1]
M = np.zeros([rowNum, colNum])
for row in range(rowNum):
    for col in range(colNum):
        M[row][col]= row*col
        
print(M)

3,5
[[0. 0. 0. 0. 0.]
 [0. 1. 2. 3. 4.]
 [0. 2. 4. 6. 8.]]

Exercice 8. (niv.2)

Écrire un programme qui prend en entrée une séquence de mots séparés par des virgules et qui affiche les mots dans une séquence séparée par des virgules après les avoir triés par ordre alphabétique.

Supposons que l'entrée suivante soit fournie au programme :

without,hello,bag,world

Alors, la sortie devrait être :

bag,hello,without,world

items=[x for x in input().split(',')]
items.sort()
print(','.join(items))

Exercice 9. (niv.2)

Écrire un programme qui prend une séquence de lignes en entrée et affiche les lignes après avoir mis tous les caractères de la phrase en majuscules.

Supposons que l'entrée suivante soit fournie au programme :

• Hello world

• Practice makes perfect

Alors, la sortie devrait être :

• HELLO WORLD

• PRACTICE MAKES PERFECT

lines = []
while True:
    s = input()
    if s:
        lines.append(s.upper())
    else:
        break;

for sentence in lines:
    print(sentence)

Hello world
Practice makes perfect

HELLO WORLD
PRACTICE MAKES PERFECT

Exercice 10. (niv.2)

Écrire un programme qui prend en entrée une séquence de mots séparés par des espaces blancs et qui imprime les mots après avoir supprimé tous les mots en double et les avoir triés par ordre alphabétique.

Tester le programme avec l'entrée suivante :

hello world and practice makes perfect and hello world again

La sortie sera :

again and hello makes perfect practice world

s = input()
words = [word for word in s.split(" ")]
print (" ".join(sorted(list(set(words)))))

Exercice 11. (niv.2)

Écrire un programme qui accepte en entrée une séquence de nombres binaires à $4$ chiffres séparés par des virgules et qui vérifie s'ils sont divisibles par $5$ ou non. Les nombres qui sont divisibles par $5$ doivent être imprimés dans une séquence séparée par des virgules.

Exemple :

0100,0011,1010,1001

Alors la sortie devrait être :

1010

value = []
items=[x for x in input().split(',')]
for p in items:
    intp = int(p, 2)
    if not intp%5:
        value.append(p)

print(','.join(value))

Exercice 12. (niv.2)

Écrire un programme qui trouve tous les nombres entre 1000 et 3000 (les deux inclus) tels que chaque chiffre du nombre est un nombre pair. Les nombres obtenus doivent être imprimés dans une séquence séparée par des virgules sur une seule ligne.

values = []
for i in range(1000, 3001):
    s = str(i)
    if (int(s[0])%2==0) and (int(s[1])%2==0) and (int(s[2])%2==0) and (int(s[3])%2==0):
        values.append(s)
print(",".join(values))

Exercice 13. (niv.2)

Écrire un programme qui accepte une phrase et calcule le nombre de lettres et de chiffres.

Tester l'entrée suivante :

hello world ! 123

La sortie attendue :

Lettres : 10

Chiffres : 3

Indications : isdigit() et isalpha() sont des méthodes de la classes str

s = input()
d={"Chiffres":0, "Lettres":0}
for c in s:
    print(type(c))
    if c.isdigit():
        d["Chiffres"]+=1
    elif c.isalpha():
        d["Lettres"]+=1
    else:
        pass
print("Lettres", ":" ,d["Lettres"])
print("Chiffres", ":",d["Chiffres"])

Exercice 14. (niv.2)

Écrire un programme qui calcule le nombre de lettres majuscules et minuscules d'une phrase.

Tester la phrase :

Bonjour le monde !

Indications : isupper() et islower() sont des méthodes de la classes str

s = input()
d={"UPPER CASE":0, "LOWER CASE":0}
for c in s:
    if c.isupper():
        d["UPPER CASE"]+=1
    elif c.islower():
        d["LOWER CASE"]+=1
    else:
        pass
print("UPPER CASE", ":",d["UPPER CASE"])
print("LOWER CASE", ":", d["LOWER CASE"])

Exercice 15. (niv.2)

Écrire un programme qui calcule la valeur de a+aa+aaa+aaaa avec un chiffre donné comme valeur de a.

Tester: 9

Résultat attendu : 11106

a = input()
n1 = int( "%s" % a )
n2 = int( "%s%s" % (a,a) )
n3 = int( "%s%s%s" % (a,a,a) )
n4 = int( "%s%s%s%s" % (a,a,a,a) )
print(n1+n2+n3+n4)

Exercice 16. (niv.2)

Utiliser une compréhension de liste pour mettre au carré chaque nombre impair d'une liste. La liste est entrée par une séquence de nombres séparés par des virgules.

Tester : 1,2,3,4,5,6,7,8,9

Résultat attendu : [1, 9, 25, 49, 81]

values = input()
numbers = [int(x)**2 for x in values.split(",") if int(x)%2!=0]
print(numbers)

Exercice 17. (niv.2)

Écrire un programme qui calcule le montant net d'un compte bancaire sur la base d'un journal de transactions provenant de l'entrée de la console. Le format du journal des transactions est le suivant :

• D 100

• W 200

D signifie dépôt et W signifie retrait.

Tester:

• D 300

• D 300

• W 200

• D 100

Résultat attendu: 500

netAmount = 0
while True:
    s = input()
    if not s:
        break
    values = s.split(" ")
    operation = values[0]
    amount = int(values[1])
    if operation=="D":
        netAmount+=amount
    elif operation=="W":
        netAmount-=amount
    else:
        pass
print(netAmount)

Exercice 18. (niv.3)

Un site web demande aux utilisateurs de saisir un nom d'utilisateur et un mot de passe pour s'enregistrer. Écrire un programme pour vérifier la validité du mot de passe saisi par les utilisateurs. Voici les critères pour vérifier le mot de passe :

1. Au moins une lettre entre [a-z].
2. Au moins un chiffre entre [0-9].
3. Au moins une lettre entre [A-Z].
4. Au moins un caractère de [$#@].
5. Longueur minimale du mot de passe de transaction : 6
6. Longueur maximale du mot de passe de la transaction : 12

Votre programme doit accepter une séquence de mots de passe séparés par des virgules et les vérifier en fonction des critères ci-dessus. Les mots de passe qui correspondent aux critères doivent être imprimés, chacun étant séparé par une virgule.

Tester les mots de passe suivant : ABd1234@1,a F1#,2w3E*,2We3345

Résultat attendu : ABd1234@1

import re
value = []
items=[x for x in input().split(',')]
for p in items:
    if len(p)<6 or len(p)>12:
        continue
    else:
        pass
    if not re.search("[a-z]",p):
        continue
    elif not re.search("[0-9]",p):
        continue
    elif not re.search("[A-Z]",p):
        continue
    elif not re.search("[$#@]",p):
        continue
    elif re.search("\s",p):
        continue
    else:
        pass
    value.append(p)
print(",".join(value))

Exercice 19. (niv.3)

Écrire un programme pour trier les tuples (nom, âge, taille) par ordre croissant où le nom est une chaîne de caractères, l'âge et la taille sont des nombres. Les tuples sont entrés par la console. Les critères de tri sont les suivants

1 : Trier en fonction du nom ;
2 : Puis trier en fonction de l'âge ;
3 : Puis trier en fonction du score.

La priorité est la suivante : nom > âge > score.

Si les tuples suivants sont donnés en entrée du programme :

• Tom,19,80
• Jean,20,90
• Jony,17,91
• Jony,17,93
• Json,21,85

La sortie du programme devrait être :

[('Jean', '20', '90'), ('Jony', '17', '91'), ('Jony', '17', '93'), ('Json', '21', '85'), ('Tom', '19', '80')]

from operator import itemgetter, attrgetter

l = []
while True:
    s = input()
    if not s:
        break
    l.append(tuple(s.split(",")))

print(sorted(l, key=itemgetter(0,1,2)))

Exercice 20. (niv.3)

Définir une classe avec un générateur qui peut itérer les nombres divisibles par $7$ entre une plage donnée de $0$ à $n$.

def putNumbers(n):
    i = 0
    while i<n:
        j=i
        i=i+1
        if j%7==0:
            yield j 

for i in putNumbers(100):
    print(i)                        

Exercice 21. (niv.3)

Un robot se déplace dans un plan à partir de l'origine $(0,0)$. Le robot peut se déplacer vers le HAUT, le BAS, la GAUCHE et la DROITE avec un pas donné. La trace du mouvement du robot est représentée comme suit :

• HAUT 5
• BAS 3
• GAUCHE 3
• DROITE 2

Les chiffres après la direction sont des étapes. Écrire un programme qui calcule et affiche la distance entre la position actuelle après une séquence de mouvements et le point d'origine. Si la distance est un flottant, il suffit d'afficher le nombre entier le plus proche.

Si les tuples suivants sont donnés en entrée du programme :

• HAUT 5
• BAS 3
• GAUCHE 3
• DROITE 2

Le résultat attendu :2

import math
pos = [0,0]
while True:
    s = input()
    if not s:
        break
    movement = s.split(" ")
    direction = movement[0]
    steps = int(movement[1])
    if direction=="HAUT":
        pos[0]+=steps
    elif direction=="BAS":
        pos[0]-=steps
    elif direction=="GAUCHE":
        pos[1]-=steps
    elif direction=="DROITE":
        pos[1]+=steps
    else:
        pass

print(int(round(math.sqrt(pos[1]**2+pos[0]**2))))

Exercice 22. (niv.3)

Écrire un programme pour calculer et afficher la fréquence des mots à partir d'un texte d'entrée. La sortie doit être produite après un tri alphanumérique.

Tester la phrase : New to Python or choosing between Python 2 and Python 3? Read Python 2 or Python 3.

Résultat attendu :

• 2:2
• 3.:1
• 3?:1
• New:1
• Python:5
• Read:1
• and:1
• between:1
• choosing:1
• or:2
• to:1

freq = {}   # frequency of words in text
line = input()
for word in line.split():
    freq[word] = freq.get(word,0)+1

words = [x for x in freq.keys()]
words.sort()

for w in words:
    print("%s:%d" % (w,freq[w]))

Exercice 23. (niv.3)

Écrire un programme qui peut filtrer les nombres pairs dans une liste en utilisant la fonction filter(). La liste est la liste [1,2,3,4,5,6,7,8,9,10].

• Utiliser filter() pour filtrer certains éléments d'une liste.
• Utiliser lambda pour définir des fonctions anonymes.

li = [1,2,3,4,5,6,7,8,9,10]
evenNumbers = filter(lambda x: x%2==0, li)
print(evenNumbers)

Exercice 24.

Écrire un programme qui fait appel à la fonction map() pour créer une liste dont les éléments sont le carré des éléments de [1,2,3,4,5,6,7,8,9,10].

li = [1,2,3,4,5,6,7,8,9,10]
squaredNumbers = map(lambda x: x**2, li)
print(list(squaredNumbers))

Exercice 25.

Écrire un programme qui permet de créer une liste dont les éléments sont des carrés de nombres pairs dans [1,2,3,4,5,6,7,8,9,10].

li = [1,2,3,4,5,6,7,8,9,10]
evenNumbers = map(lambda x: x**2, filter(lambda x: x%2==0, li))
print(list(evenNumbers))