Révisions

Exercice 1 : somcube

  • $1234$ $\leadsto$ [4, 3, 2, 1]
  • Divisions euclidiennes :
    • $1234 = 123 \times 10 + 4$
    • $123 = 12 \times 10 + 3$
    • $12 = 1 \times 10 + 2$
    • $1 = 0 \times 10 + 1$
    • $0$
    • ...
    • $0$
In [1]:
def somcube(n):
    """ Somme des cubes des chiffres de n """
    s = 0
    while n > 0:
        s = s + (n%10)**3
        n = n//10    # Attention : n=n//10 et pas n//10
    return s

somcube(1234), 1**3+2**3+3**3+4**3
Out[1]:
(100, 100)
In [2]:
def decomp(n):
    chiffres = []
    while n > 0:
        chiffres.append(n%10)
        n = n//10
    return chiffres

def somcube(n):
    return sum([x**3 for x in decomp(n)])

decomp(1234), somcube(1234)
Out[2]:
([4, 3, 2, 1], 100)
In [3]:
def egaux_somcube(k):
    """ Nombres entiers inférieurs ou égaux à k,
        égaux à la somme des cubes de leurs chiffres"""
    res = []
    for x in range(k+1):
        if x == somcube(x):
            res.append(x)
    return res

egaux_somcube(1000)
Out[3]:
[0, 1, 153, 370, 371, 407]
In [4]:
def somcube2(n):
    chaine = str(n)    # "1234"
    s = 0
    for caractere in chaine:    # "1", "2", "3" puis "4"
        chiffre = int(caractere)
        s = s + chiffre**3
    return s

somcube2(1234)
Out[4]:
100

Exercice 2 : matrices

In [5]:
# Matrice d'adjacence
G = [
    [ 0, -1, -1, -1, -1,  2, -1],
    [-1,  0,  1,  6, -1,  4, -1],
    [-1,  1,  0, -1,  3, -1, -1],
    [-1,  6, -1,  0,  1,  3,  2],
    [-1, -1,  3,  1,  0, -1, -1],
    [ 2,  4, -1,  3, -1,  0, -1],
    [-1, -1, -1,  2, -1, -1,  0],    
]
In [6]:
def voisins(mat, i):
    vois = []
    for j in range(len(mat[i])):
        if mat[i][j] > 0:
            vois.append(j)
    return vois

voisins(G, 5)
Out[6]:
[0, 1, 3]
In [7]:
def longueur(mat, L):
    long = 0
    for k in range(1, len(L)):
        dist = mat[L[k-1]][L[k]]
        if dist == -1:
            return -1
        else:
            long = long + dist
    return long

longueur(G, [0, 5, 2]), longueur(G, [0, 5, 1, 2])
Out[7]:
(-1, 7)

Exercice 3 : diviseurs

In [8]:
def dnt(n):
    L = []
    for d in range(2, n):
        if n%d == 0:
            L.append(d)
    return L

import math
def dnt_mieux(n):
    L = []
    racine = int(math.sqrt(n))
    for d in range(2, racine+1):
        if n%d == 0:
            L.extend([d, n//d])
    if n == racine**2:
        L.pop()
    return L

dnt_mieux(6), dnt_mieux(49)
Out[8]:
([2, 3], [7])
In [9]:
def sommeCarresDNT(n):
    return sum([x**2 for x in dnt_mieux(n)])

def sommeCarresDNT_bis(n):
    s = 0
    for x in dnt_mieux(n):
        s = s + x**2
    return s

Exercice 4 : suites de 0

In [10]:
t1 = [0, 1, 1, 1, 0, 0, 0, 1, 0, 1, 1, 0, 0, 0, 0]
In [11]:
def nombreZeros(t, i):
    nb = 0
    while i < len(t) and t[i]==0: # Attention à l'ordre !
        nb = nb + 1
        i = i + 1
    return nb

nombreZeros(t1, 4), nombreZeros(t1, 1), nombreZeros(t1, 8)
Out[11]:
(3, 0, 1)
In [12]:
def nombreZerosMax(t):
    """ En utilisant la fonction précédente : O(n^2)"""
    maxi = 0
    for i in range(len(t)):
        nb = nombreZeros(t, i) # Appel de fonction : O(n)
        if nb > maxi:
            maxi = nb
    return maxi

nombreZerosMax(t1)
Out[12]:
4
In [13]:
def nombreZerosMax_bis(t):
    """ Mieux : O(n) """
    maxi = 0
    nb = 0
    for i in range(len(t)):
        if t[i] == 1:
            nb = 0
        else:
            nb += 1
            if nb > maxi:
                maxi = nb
    return maxi

Master Mind

Bien placés : facile

  • [R, R, V, B]
  • [R, V, V, R]

Il suffit de compter les cases qui correspondent exactement

Bien+Mal placés :

  • [R, _, R, R]
  • [_, R, _, R]

On décompose couleur par couleur : ici j'ai 3 Rouges et 2 Rouges : c'est le min

In [ ]: