Aller au contenu

Fichier Capytale pour compléter les automatismes

Thème A : types de base⚓︎

Automatisme 1

Représenter en binaire le nombre d’écriture décimale 49.

110001

Automatisme 2

Représenter en base dix, le nombre dont l'écriture en base deux est 1010110 puis le nombre dont l'écriture en base 16 est 'A4'.

1010110 s'écrit \(64+16+4+2=86\) en base dix.

Automatisme 3

Déterminer le successeur des entiers dont l'écriture en base deux est :

  • 111
  • 10011
  • 10111
  • 111 a pour successeur 1000
  • 10011 a pour successeur 10100
  • 10111 a pour successeur 11000
Automatisme 4

On considère les nombres dont l'écriture en base 16 (en hexadécimal) sont de la forme suivante : un 1 suivi de 0 en nombre quelconque, comme 1, 10, 100, 1000 etc ... Tous ces nombres sont exactement :

  1. les puissances de 2
  2. les puissances de 8
  3. les puissances de 10
  4. les puissances de 16

Ce sont les puissances de 16.

Automatisme 5

Le résultat de l'addition en binaire \(101001 + 101\) est égal au nombre binaire :

  1. 101102
  2. 010101
  3. 101110
  4. 110000

Le résultat de l'addition en binaire \(101001 + 101\) est égal à \(101110\)

Automatisme 6

Quelle est la représentation hexadécimale de l'entier dont la représentation binaire s'écrit : 0100 1001 1101 0011 ?

  1. 18899
  2. 3D94
  3. 49D3
  4. 93A3

On remplace chaque bloc de 4 bits par sa représentation sur un chiffre en base 16 et on obtient 49D3

Automatisme 7

Le codage de César transforme un message en changeant chaque lettre en la décalant dans l'alphabet.

Par exemple, avec un décalage de 3, le A se transforme en D, le B en E, ..., le X en A, le Y en B et le Z en C. Les autres caractères ('!','?'...) ne sont pas codés.

La fonction position_alphabet ci-dessous prend en paramètre un caractère lettre et renvoie la position de lettre dans la chaîne de caractères ALPHABET s’il s’y trouve et -1 sinon.

La fonction cesar prend en paramètre une chaîne de caractères message et un nombre entier decalage et renvoie le nouveau message codé avec le codage de César utilisant le décalage decalage.

🐍 Script Python
ALPHABET = 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'

def position_alphabet(lettre):
    return ALPHABET.find(lettre)

def cesar(message, decalage):
    resultat = ''
    for ... in message :
        if lettre in ALPHABET :
            indice = ( ... )%26
            resultat = resultat + ALPHABET[indice]
        else:
            resultat = ...
    return resultat

def test_cesar():
    assert cesar('BONJOUR A TOUS. VIVE LA MATIERE NSI !',4) == 'FSRNSYV E XSYW. ZMZI PE QEXMIVI RWM !'
    assert cesar('GTSOTZW F YTZX. ANAJ QF RFYNJWJ SXN !',-5) == 'BONJOUR A TOUS. VIVE LA MATIERE NSI !'
🐍 Script Python
ALPHABET = 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'

def position_alphabet(lettre):
    return ALPHABET.find(lettre)

def cesar(message, decalage):
    resultat = ''
    for lettre in message :
        if lettre in ALPHABET :
            indice = (position_alphabet(lettre) + decalage)%26
            resultat = resultat + ALPHABET[indice]
        else:
            resultat = resultat + lettre
    return resultat

def test_cesar():
    assert cesar('BONJOUR A TOUS. VIVE LA MATIERE NSI !',4) == 'FSRNSYV E XSYW. ZMZI PE QEXMIVI RWM !'
    assert cesar('GTSOTZW F YTZX. ANAJ QF RFYNJWJ SXN !',-5) == 'BONJOUR A TOUS. VIVE LA MATIERE NSI !'
Automatisme 8

On considère des mots à trous : ce sont des chaînes de caractères contenant uniquement des majuscules et des caractères *. Par exemple INFO*MA*IQUE, ***I***E** et *S* sont des mots à trous.
Programmer une fonction correspond qui :

  • prend en paramètres deux chaînes de caractères mot et mot_a_trousmot_a_trous est un mot à trous comme indiqué ci-dessus,
  • renvoie :
    • True si on peut obtenir mot en remplaçant convenablement les caractères '*' de mot_a_trous.
    • False sinon.

Exemple :

🐍 Script Python
>>> correspond('INFORMATIQUE', 'INFO*MA*IQUE')
True
>>> correspond('AUTOMATIQUE', 'INFO*MA*IQUE')
False
🐍 Script Python
def correspond(mot, mot_a_trous):
    if len(mot) != len(mot_a_trous):
        return False
    for k in range(len(mot)):
        if (mot_a_trous[k] != '*') and (mot_a_trous[k] != mot[k]):
            return False
    return True

Thème B : types construits⚓︎

Automatisme 9

Programmer la fonction dont on donne la spécification (référence Upylab : CAIx-0300 chapitre tableaux)

🐍 Script Python
def au_moins_un_zero(t):
    """
    Paramètre : t un tableau de nombres (int ou float)
    Précondition : t non vide
    Valeur renvoyée : un booléen indiquant si t contient au moins un zéro
    """
🐍 Script Python
def un_zero(tab):
    for e in tab:
        if e == 0:
            return True
    return False
Automatisme 10

Code Puzzle, fonction renvoyant le maximum d'un tableau

Automatisme 11

Code Puzzle, fonction testant l'appartenance d'un élément à un tableau

Automatisme 12

Code Puzzle, 0 <-> 1

Automatisme 13

On travaille sur des tableaux à deux dimensions qui représentent des images binaires : un pixel a pour valeur un entier : 0 pour un pixel noir et 1 pour un pixel blanc.

Compléter les fonctions ci-dessous en respectant leurs spécifications, les postconditions doivent être vérifiées.

🐍 Script Python
def image_noire(largeur, hauteur):
    """
    Paramètre : 
        largeur et hauteur deux entiers non nuls
    Valeur renvoyée :
        un tableau à 2 dimensions représentant une image
        binaire de dimensions (largeur, hauteur)
        rempli de 0
    """
    # à compléter avec un tableau en compréhension
    
def dimensions(tab):
    """
    Paramètre : 
        tab un tableau à deux dimensions d'entiers
        représentant une image binaire rectangulaire
    Valeur renvoyée :
        un tableau de deux entiers [largeur, hauteur]
        représentant les dimensions de l'image
    """
    # à compléter
    
def nombre_blancs(tab):
    """
    Paramètre : 
        tab un tableau à deux dimensions d'entiers
        représentant une image binaire rectangulaire
    Valeur renvoyée :
        un entier représentant le nombre de pixels 
        blancs (valeur 1)
    """
    # à compléter

# postconditions pour la fonction image_noire 
assert image_noire(2,1) == [[0,0]]
assert image_noire(1,2) == [[0], [0]]
assert image_noire(3,2) == [[0,0,0], [0,0,0]]


# postconditions pour la fonction dimensions 
assert dimensions([[], []]) == [2,0]
assert dimensions([[0,1,2], [3,4,5]]) == [2,3]

# postconditions pour la fonction nombre_blancs
assert nombre_blancs([[0,0], [0,0]]) == 0
assert nombre_blancs([[0,1,1], [0,1,0]]) == 3
assert nombre_blancs([[], []]) == 0
🐍 Script Python
def image_noire(largeur, hauteur):
    """
    Paramètre : 
        largeur et hauteur deux entiers non nuls
    Valeur renvoyée :
        un tableau à 2 dimensions représentant une image
        binaire de dimensions (largeur, hauteur)
        rempli de 0
    """
    return [[0 for _ in range(largeur)] for _ in range(hauteur)]

def dimensions(tab):
    """
    Paramètre : 
        tab un tableau à deux dimensions d'entiers
        représentant une image binaire rectangulaire
    Valeur renvoyée :
        un tableau de deux entiers [largeur, hauteur]
        représentant les dimensions de l'image
    """
    largeur = len(tab[0])
    hauteur = len(tab)
    return [largeur, hauteur]

def nombre_blancs(tab):
    """
    Paramètre : 
        tab un tableau à deux dimensions d'entiers
        représentant une image binaire rectangulaire
    Valeur renvoyée :
        un entier représentant le nombre de pixels 
        blancs (valeur 1)
    """
    largeur, hauteur = dimensions(tab)
    c = 0
    for i in range(hauteur):
        for j in range(largeur):
            if tab[i][j] == 1:
                c = c + 1
    return c
    

# postconditions pour la fonction image_noire 
assert image_noire(2,1) == [[0,0]]
assert image_noire(1,2) == [[0], [0]]
assert image_noire(3,2) == [[0,0,0], [0,0,0]]


# postconditions pour la fonction dimensions 
assert dimensions([[], []]) == [0,2]
assert dimensions([[0,1,2], [3,4,5]]) == [3,2]


# postconditions pour la fonction nombre_blancs
assert nombre_blancs([[0,0], [0,0]]) == 0
assert nombre_blancs([[0,1,1], [0,1,0]]) == 3
assert nombre_blancs([[], []]) == 0

Thème C : traitement de données en tables⚓︎

Thème D : interactions entre l'homme et la machine sur le Web⚓︎

Thème E : architectures matérielles et systèmes d'exploitation⚓︎

Automatisme 14

Quelle commande permet de connaître le répertoire courant ?

  1. cd
  2. ls
  3. pwd
  4. chmod

pwd

Automatisme 15

Quelle commande permet de lister le contenu du répertoire courant ?

  1. cd
  2. ls
  3. pwd
  4. chmod

ls

Automatisme 16

Lorsque, en ligne de commande, on saisit la commande chmod u+rw a.txt ceci a pour effet :

  1. de permettre au propriétaire du fichier de modifier le contenu de ce fichier
  2. d'interdire au propriétaire de modifier le contenu de ce fichier
  3. d'interdire à tous les autres utilisateurs de lire le fichier
  4. d'effacer le fichier

chmod u+rw a.txt a pour effet de permettre au propriétaire du fichier de modifier le contenu de ce fichier

Automatisme 17

Dans un terminal sous Linux, quelle commande faut-il écrire pour donner à tout le monde le droit d'écriture sur un fichier information.py ?

  1. chmod o+w information.py
  2. chmod a+w information.py
  3. chmod o+x information.py
  4. chmod a+x information.py

chmod a+w information.py

Automatisme 18

Pour renommer un fichiertext1.txt en text1.old dans un même répertoire, quelle commande faut-il utiliser ?

  1. mv text1.txt ../text1.old
  2. mv text1.txt text1.old
  3. cp text1.txt text1.old
  4. lns text1.txt text1.old

mv text1.txt text1.old

Automatisme 19

Sous UNIX, que va réaliser la ligne de commande cat file.txt ?

  1. rien du tout
  2. l'affichage du contenu du fichier file.txt dans la console
  3. la création d'un fichier file.txt
  4. la suppression du fichier file.txt

l'affichage du contenu du fichier file.txt dans la console

Automatisme 20

Sous UNIX, que va réaliser la ligne de commande cat file.txt ?

  1. rien du tout
  2. l'affichage du contenu du fichier file.txt dans la console
  3. la création d'un fichier file.txt
  4. la suppression du fichier file.txt

l'affichage du contenu du fichier file.txt dans la console

Automatisme 21

Lorsque, en ligne de commande, on saisit la commande rm * ceci a pour effet :

  1. d'activer une télécommande
  2. d'accéder au répertoire parent du répertoire courant
  3. d'effacer tous les fichiers du répertoire courant et ses sous-répertoires
  4. d'effacer tous les fichiers du répertoire courant

d'effacer tous les fichiers du répertoire courant

Automatisme 22

On a exécuté la commande ls -l et obtenu l’affichage suivant :

📋 Texte
total 0
-rw-rw-rw- 1 etudiant etudiant 15 Jul 2 13:29 exercice
drwxrwxrwx 1 etudiant etudiant 512 Jul 2 13:37 seances

Que permettent d’affirmer les informations obtenues ?

  1. exercice et seances sont deux fichiers
  2. exercice est un fichier et seances est un répertoire
  3. exercice et seances sont deux répertoires
  4. exercice est un répertoire et seances est un fichier

exercice est un fichier et seances est un répertoire

Automatisme 23

Sachant que le répertoire courant contient les fichiers fich.txt, mafich.txt et programme.py, quel est le résultat de la commande ls fich* dans un shell Linux ?

  1. fich.txt mafich.txt
  2. mafich.txt
  3. fich.txt
  4. programme.py

fich.txt

Automatisme 24

Dans la console Linux, quelle commande faut-il exécuter pour obtenir la documentation sur la commande pwd ?

  1. man pwd
  2. cd pwd
  3. mkdir pwd
  4. ls pwd

man pwd

Automatisme 25

Dans un shell sous Linux, Alice utilise la commande pwd.

Cette commande :

  1. liste les fichiers du répertoire courant
  2. liste les répertoires du répertoire courant
  3. affiche le chemin du répertoire courant
  4. affiche les permissions relatives au répertoire courant

affiche le chemin du répertoire courant

Automatisme 26

Sous Linux, la console indique que l'utilisateur se trouve dans le dossier /var/lib. Quelle commande doit-il exécuter pour revenir dans son dossier personnel /home/martin ?

  1. cd ~
  2. cd /home
  3. dir
  4. dir /home/martin

cd ~

Automatisme 27

Le shell Linux renvoie ce résultat à la commande ls -al :

📋 Texte
lrwxr--r-- 2 toto toto  807 juin 26 14:06 eclipse
drwxr-xr-x 2 toto toto  4096 juin 26 15:00 Doc_1
-rw-r-xr-x 2 toto toto  4096 juin 26 14:06 QCM
-rwxr-xr-x 2 toto toto  4096 juin 26 14:06 Doc_Travail

Quel est le nom du fichier du répertoire courant, de taille 4096 octets, exécutable par son propriétaire ?

  1. eclipse
  2. Doc_1
  3. QCM
  4. Doc_Travail

Doc_Travail

Thème F : langages et programmation⚓︎

Automatisme 28

Pour déterminer la liste des chiffres en base dix d'un entier naturel, un élève a écrit la fonction ci-dessous :

🐍 Script Python
def liste_chiffres(n):
    L = [n % 10]
    while n > 0:
        n = n // 10
        L.insert(0, n % 10)
    return L

Malheureusement sa fonction ne retourne pas le résultat attendu pour l'entier 730 :

📋 Texte
>>> liste_chiffres(730)
[0, 7, 3, 0]

Proposer une version corrigée de la fonction liste_chiffres.

🐍 Script Python
def liste_chiffres(n):
    L = [n % 10]
    while n >= 10:
        n = n // 10
        L.insert(0, n % 10)
    return L

Thème G : algorithmique⚓︎

Automatisme 29

Compléter les fonctions Python ci-dessous pour que les spécifications et les tests unitaires soient satisfaites.

🐍 Script Python
def est_decroissant(t):
    """
    Paramètre : 
        t un tableau de nombres
        précondition len(t) > 0 
    Valeur renvoyée : 
        booléen indiquant si t dans l'ordre décroissant
    """
    "à compléter"


def test_est_decroissant():
    assert not est_decroissant([k ** 2 for k in range(10)])
    assert est_decroissant([1])
    assert est_decroissant(list(range(10, -1, -1)))
    print("Tests unitaires réussis ")


def recherche_dicho_decroissant(x, t):
    """
    Paramètre : 
        t un tableau de nombres trié dans l'ordre décroissant
        x un nombre 
    Valeur renvoyée : 
        True si x dans t
        False si x pas dans t
    """
    a = 0
    b = len(t) - 1
    while a <= b:
        m = (a + b) // 2
        "à compléter"
    return None

def test_recherche_dicho_decroissant():
    t1 = list(range(10, -1, -1))
    assert recherche_dicho_decroissant(8, t1)
    assert recherche_dicho_decroissant(10, t1)
    assert recherche_dicho_decroissant(0, t1)
    assert not recherche_dicho_decroissant(4.5, t1)
    print("Tests unitaires réussis ")
🐍 Script Python
def est_decroissant(t):
    """
    Paramètre : 
        t un tableau de nombres 
        précondition len(t) > 0
    Valeur renvoyée : 
        booléen indiquant si t dans l'ordre décroissant
    """
    assert len(t) > 0, "t doit être non vide"
    for i in range(1, len(t)):
        if t[i-1] < t[i]:
            return False
    return True

def test_est_decroissant():
    assert not est_decroissant([k ** 2 for k in range(10)])
    assert est_decroissant([1])
    assert est_decroissant(list(range(10, -1, -1)))
    print("Tests unitaires réussis ")


def recherche_dicho_decroissant(x, t):
    """
    Paramètre : 
        t un tableau de nombres trié dans l'ordre décroissant
        x un nombre 
    Valeur renvoyée : 
        True si x dans t
        False si x pas dans t
    """
    a = 0
    b = len(t) - 1
    while a <= b:
        m = (a + b) // 2
        if t[m] > x:
            a = m + 1
        elif t[m] < x:
            b = m - 1
        else:
            return True
    return False

def test_recherche_dicho_decroissant():
    t1 = list(range(10, -1, -1))
    assert recherche_dicho_decroissant(8, t1)
    assert recherche_dicho_decroissant(10, t1)
    assert recherche_dicho_decroissant(0, t1)
    assert not recherche_dicho_decroissant(4.5, t1)
    print("Tests unitaires réussis ")
Automatisme 30

Compléter la fonction Python ci-dessous pour que la spécification et les tests unitaires soient satisfaits.

🐍 Script Python
def index_premiere_occurence_dicho(x, t):
    """
    Paramètre : 
        t un tableau de nombres trié dans l'ordre croissant
        x un nombre 
    Valeur renvoyée : 
        l'index de la première de x dans t si x est dans t
        -1 sinon
    """
    a = 0
    b = len(t) - 1
    while a <= b:
        m = (a + b) // 2
        if t[m] < x:
            "à compléter"
        elif t[m] > x:
            "à compléter"
        else:
            "à compléter"
            return "à compléter"
    return -1

def tests_unitaires():
    """Tests unitaires pour index_premiere_occurrence_dicho"""
    assert index_premiere_occurence_dicho(10, [10, 10, 11, 12, 13]) == 0
    assert index_premiere_occurence_dicho(10, [9, 10, 11, 12, 13]) == 1
    assert index_premiere_occurence_dicho(10, [9, 9, 11, 12, 13]) == -1
    assert index_premiere_occurence_dicho(10, [7, 8, 9, 10]) == 3 
    assert index_premiere_occurence_dicho(10, [7, 10, 10,  10, 10]) == 1 
    assert index_premiere_occurence_dicho(10, []) == -1
    print('tests réussis')
🐍 Script Python
def index_premiere_occurrence_dicho(x, t):
    """
    Paramètre : 
        t un tableau de nombres trié dans l'ordre croissant
        x un nombre 
    Valeur renvoyée : 
        l'index de la première occurrence de x dans t si x est dans t
        -1 sinon
    """
    a = 0
    b = len(t) - 1
    while a <= b:
        m = (a + b) // 2
        if t[m] < x:
            a = m + 1
        elif t[m] > x:
            b = m - 1
        else:
            while m >= 0 and t[m] == x:
                m = m - 1
            return m + 1
    return -1

def tests_unitaires():
    """Tests unitaires pour index_premiere_occurrence_dicho"""
    assert index_premiere_occurence_dicho(10, [10, 10, 11, 12, 13]) == 0
    assert index_premiere_occurence_dicho(10, [9, 10, 11, 12, 13]) == 1
    assert index_premiere_occurence_dicho(10, [9, 9, 11, 12, 13]) == -1
    assert index_premiere_occurence_dicho(10, [7, 8, 9, 10]) == 3 
    assert index_premiere_occurence_dicho(10, [7, 10, 10,  10, 10]) == 1 
    assert index_premiere_occurence_dicho(10, []) == -1
    print('tests réussis')
Automatisme 31

Compléter la fonction Python ci-dessous pour que la spécification et les tests unitaires soient satisfaits.

🐍 Script Python
def insertion(t, x):
    """
    Paramètre : 
        t un tableau de nombres trié dans l'ordre croissant
        x un nombre 
    Valeur renvoyée : 
        nouveau tableau avec x inséré à sa place dans t
    """
    t2 = t + [x]
    i = len(t2) - 2
    # à compléter
    return t2

def tests_insertion():
    """Tests unitaires pour insertion"""
    assert insertion([], 10]) == [10]
    assert insertion([8], 10]) == [8, 10]
    assert insertion([8], 6]) == [6, 8]
    assert insertion([5, 8], 6]) == [5, 6, 8]
    assert insertion([5, 8], 8]) == [5, 8, 8]
    assert insertion([5, 8], 4]) == [4, 5, 8]
    print('tests réussis')
🐍 Script Python
def insertion(t, x):
    """
    Paramètre : 
        t un tableau de nombres trié dans l'ordre croissant
        x un nombre 
    Valeur renvoyée : 
        nouveau tableau avec x inséré à sa place dans t
    """
    t2 = t + [x]
    i = len(t2) - 2
    while i >= 0 and t2[i] > x:
        t2[i + 1] = t2[i]
        i = i - 1
    t2[i + 1] = x
    return t2
        
def test_insertion():
    """Tests unitaires pour insertion"""
    assert insertion([], 10) == [10]
    assert insertion([8], 10) == [8, 10]
    assert insertion([8], 6) == [6, 8]
    assert insertion([5, 8], 6) == [5, 6, 8]
    assert insertion([5, 8], 8) == [5, 8, 8]
    assert insertion([5, 8], 4) == [4, 5, 8]
    print('tests réussis')

Compléter la fonction Python ci-dessous pour que la spécification et les tests unitaires soient satisfaits.

🐍 Script Python
def tri_insertion(t):
    """
    Paramètre : 
        t un tableau de nombres
    Valeur renvoyée : 
        nouveau tableau trié dans l'ordre croissant
    """
    if len(t) == 0:
        return []
    tc = [t[0]]
    for i in range(1, len(t)):                
        "à compléter"
    return tc
        
def test_tri_insertion():
    """Tests unitaires pour insertion"""
    assert tri_insertion([]) == []
    assert tri_insertion([8, 10]) == [8, 10]
    assert tri_insertion([8, 8]) == [8, 8]
    assert tri_insertion([8, 6, 4]) == [4, 6, 8]
    assert tri_insertion([6, 4, 8]) == [4, 6, 8]
    print('tests réussis')
🐍 Script Python
def tri_insertion(t):
    """
    Paramètre : 
        t un tableau de nombres 
    Valeur renvoyée : 
        nouveau tableau trié dans l'ordre croissant
    """
    tc = [t[0]]
    for i in range(1, len(t)):                
        tc = insertion(tc, t[i])
    return tc
        
def test_tri_insertion():
    """Tests unitaires pour insertion"""
    assert tri_insertion([]) == []
    assert tri_insertion([8, 10]) == [8, 10]
    assert tri_insertion([8, 8]) == [8, 8]
    assert tri_insertion([8, 6, 4]) == [4, 6, 8]
    assert tri_insertion([6, 4, 8]) == [4, 6, 8]
    print('tests réussis')
Automatisme 32

La fonction fusion prend deux tableaux t1 et t2 d'entiers triées par ordre croissant et les fusionne en une liste triée L12 qu'elle renvoie.

Le code Python, à compléter, de la fonction est :

🐍 Script Python
def fusion(t1,t2):
    n1 = len(t1)
    n2 = len(L2)
    t12 = [0] * (n1 + n2)
    i1 = 0
    i2 = 0
    i = 0
    while i1 < n1 and ... :
        if t1[i1] < t2[i2]:
            t12[i] = ...
            i1 = ...
        else:
            t12[i] = t2[i2]
            i2 = ...
        i += 1
    while i1 < n1:
        t12[i] = ...
        i1 = i1 + 1
        i = ...
    while i2 < n2:
        t12[i] = ...
        i2 = i2 + 1
        i = ...
    return t12

def test_fusion():
    assert fusion([1,6,10],[0,7,8,9]) == [0, 1, 6, 7, 8, 9, 10]
🐍 Script Python
def fusion(t1,t2):
    n1 = len(t1)
    n2 = len(L2)
    t12 = [0] * (n1 + n2)
    i1 = 0
    i2 = 0
    i = 0
    while i1 < n1 and i2 < n2:
        if t1[i1] < t2[i2]:
            t12[i] = t1[i]
            i1 = i1 + 1
        else:
            t12[i] = t2[i2]
            i2 = i2 + 1
        i += 1
    while i1 < n1:
        t12[i] = t1[i]
        i1 = i1 + 1
        i = i + 1
    while i2 < n2:
        t12[i] = t2[i]
        i2 = i2 + 1
        i = i + 1 
    return t12

def test_fusion():
    assert fusion([1,6,10],[0,7,8,9]) == [0, 1, 6, 7, 8, 9, 10]