Rituels : Fonctions à savoir écrire. (Term. NSI)

1. Fonction liste_entiers : Écrire la fonction liste_entiers, prenant en paramètre un entier positif n et qui renvoie la liste (type list) de tous les entiers compris entre 0 et n (inclus). De préférence en compréhension

def liste_entiers(n: int)->list:
    return [val for val in range(n + 1)]

Variante possible à savoir faire : même fonction mais avec $n$ entier (donc qui peut être négatif).

2. Fonction maximum_tableau : Écrire la fonction maximum_tableau, prenant en paramètre un tableau non vide d'entiers noté tab (de type list) et qui renvoie le plus grand élément de ce tableau.

# Une correction possible :
def maximum_tableau(tab: list)->int:
    assert len(tab) > 0
    maxi = tab[0]
    for val in tab:
        if val >= maxi:
            maxi = val
    return maxi

Variante possible à savoir faire : la fonction minimum_tableau.

3. Fonction indice_max : Écrire la fonction indice_max, prenant en paramètre un tableau non vide d'entiers noté tab (de type list) et qui renvoie l'indice du 1er plus grand élément de ce tableau.

# Une correction possible :
def indice_max(tab: list)->int:
    i_maxi = 0
    for i in range(len(tab)):
        if tab[i] > tab[i_maxi]:  # > pour le 1er + grand élt
            i_maxi = i
    return i_maxi

Variante possible à savoir faire : la fonction indice_mini.

4. Fonction recherche_plus : Écrire la fonction recherche_plus, prenant en paramètres un tableau non vide d'entiers noté tab (de type list) et un entier n, et qui renvoie la liste des indices de toutes les occurrence de l’élément cherché. Si l’élément n’est pas présent, la fonction renvoie une liste vide.

# Une correction possible :
def recherche_plus(tab, n):
    indices = []
    for i in range(len(tab)):
        if tab[i] == n:
            indices.append(i)
    return indices

Variante possible à savoir faire : trouver la dernière occurence.

5. Fonction somme : Écrire la fonction somme, prenant en paramètre un tableau de nombres (de type float) noté tab (de type list) et qui renvoie la somme de tous les nombres du tableau.

# Une correction possible :
def somme(tab: list)->float:
    accumulateur = 0
    for val in tab:
        accumulateur += val
    return accumulateur

Variante possible à savoir faire : calculer la moyenne des nombres du tableau.

6. Fonction nb_occurences : Écrire la fonction nb_occurences, prenant en paramètres un élément elt et un tableau tab (type list) d’éléments du même type et qui renvoie le nombre de fois où l’élément apparaît dans le tableau.

# Une correction possible :
def nb_occurences(tab: list, elt)->int:
    compteur = 0
    for val in tab:
        if val == elt:
            compteur += 1
    return compteur

Variante possible à savoir faire : Stocker les occurences de chaque valeur dans un dictionnaire.

7. Fonction inverse_car : Écrire la fonction inverse_car, prenant en paramètre une chaîne de caractères ch (de type str) et qui renvoie cette chaîne de caractères en ordre inverse.

# Une correction possible :
def inverse_car(ch: str)->str:
    new_ch = ''
    for car in ch:
        new_ch = car + new_ch
    return new_ch

# On peut utiliser l'astuce des slices : ch[::-1] mais ce n'est pas ce qui est attendu dans ces rituels.

8. Fonction fibo_recursif : Écrire la fonction récursive fibo_recursif, prenant en paramètre un entier naturel n et qui renvoie la valeur d'indice n de la suite de Fibonacci définie par $F_0=0$, $F_1=1$ et pour tout entier naturel $n>=2 : F_n=F_{n-1} + F_{n-2}$.

def fibo_recursif(n :int)->int:
    if n <= 1:
        return n
    return fibo_recursif(n - 1) + fibo_recursif(n - 2)

9. Fonction multiplication : Ècrire en récursif une fonction multiplication qui prend en paramètre 2 entiers n1 et n2 (pas forcément positifs) et qui renvoie le produit des 2.

def multiplication(n1, n2):
    if n2 == 0:
        return 0
    if n2 < 0:
        return -n1 + multiplication(n1, n2 + 1)
    return n1 + multiplication(n1, n2 - 1)

10. Fonction ecriture_binaire_entier_positif : Écrire une fonction ecriture_binaire_entier_positif qui prend en paramètre un entier positif n et qui renvoie une chaine de caractère correspondant à l’écriture binaire de n.

def ecriture_binaire_entier_positif(n):
    if n == 0:
        return "0"
    resultat = ""
    while n > 0:
        reste = n % 2  
        resultat = str(reste) + resultat  #astuce pour inverser
        n = n // 2  
    return resultat

11. Fonction enumere : Écrire une fonction enumere qui prend en paramètre un tableau tab (type list) et renvoie un dictionnaire d dont les clés sont les éléments de tab avec pour valeur associée la liste des indices de l’élément dans le tableau tab.

enumere([1, 1, 2, 3, 2, 1])renvoie {1: [0, 1, 5], 2: [2, 4], 3: [3]}

def enumere(tab):
    d = {}
    for i in range(len(tab)):
        element = tab[i]
        if element not in d:
            d[element] = []  
        d[element].append(i)
    return d