Carte à puces – Bac informatique théorique 2019 [ Bac scientifique ]
Sujet bac informatique théorique 2019 (Bac scientifique)
Une société commerciale cherche à automatiser l'accès à ces services via des cartes à puces. Chaque carte est caractérisée par un identifiant unique, une date de création et un code d'accès. Pour cela, on propose d'écrire un programme Python permettant de :
1) Stocker les identifiants de N cartes dans un tableau IDENT (avec 3<= N <= 50), sachant que l'identifiant est une chaîne formée de 8 chiffres. 2) Stocker les dates de création de ces N cartes d'accès dans un tableau DATE, sachant qu'une date de création est une chaîne formée de deux parties : le jour J et le mois M séparés par le caractère "/" (On ne tiendra compte que des contrôles: J est un entier compris entre 1 et 31 et M est un entier compris entre 1 et 12) 3) Déterminer dans un tableau CODE les N codes à partir du tableau DATE en utilisant le principe ci-après, sachant qu'un code est une chaîne de 4 chiffres : - Concaténer J et M pour former un nombre de 2, 3 ou 4 chiffres. - Multiplier ce nombre par un entier aléatoire X compris entre 5 et 64 afin d'obtenir un nouveau nombre Y - Former le code de quatre chiffres comme suit : Si Y est un entier de 4 chiffres, déplacer le chiffre des milliers vers la droite de ce nombre. Si Y < 1000, ajouter des zéros (0) à droite de ce nombre pour que sa longueur soit égale à 4 Si Y > 9999, additionner le nombre formé de 4 chiffres de gauche au nombre formé des chiffres restants à droite jusqu'à ce que sa longueur soit égale à 4.
4) Afficher les informations relatives à chacune des cartes sous la forme suivante :
Identifiant de la carte : Date de sa création : Code
Exemple : Pour N=3 et les deux tableaux suivants :
IDENT:
| 12345678 | 23456789 | tableau 34567891 |
DATE:
| 8/11 | 2/1 | 24/12 |
On obtient le tableau CODE suivant:
CODE:
| 1108 | 6720 | 1314 |
En effet, les codes des cartes sont obtenus comme suit :
- Pour la carte N°1, la concaténation de J et M donne le nombre 811. En supposant que l'entier aléatoire X=10, le nombre obtenu est égal à 8110 (811*10) qui est composé de 4 chiffres. en déplaçant le chiffres des milliers (8) vers la droite, on obtient le code 1108.
- Pour la carte N°2, la concaténation de J et M donne le nombre 21. En supposant que l'entier aléatoire X=32 , le nombre obtenu est égal à 672(21*32) qui est < 1000. En ajoutant un zéro à droite pour que sa longueur soit égale à 4, on obtient le code 6720. - Pour la carte N°3, la concaténation de J et M donne le nombre 2412. En supposant que l'entier aléatoire X=53 , le nombre obtenu est égal à 127836(2412*53) qui est > 9999. Le nombre formé des 4 chiffres de gauche (1278) sera additionné au nombre formé des chiffres restants à droite (36), on obtient le code 1314 (1278+36).
Le programme affiche :
12345678 : 8/11 : 1108
23456789 : 2/1 : 6720
34567891 : 24/12 : 1314
Solution Algorithmique
Dans cet algorithme, On va utiliser 5 fonctions et 2 procédures:
Algorithme du programme Principal
|
1 2 3 4 5 6 |
Algorithme codes_cartes_puces Debut n<-saisie_taille() remplir(ident,date,n) inserer_afficher_codes(ident,date,code,n) Fin |
Déclaration des objets
| Objet | Type / Nature |
|---|---|
| ident | tableau des chaînes des caractères |
| date | tableau des chaînes des caractères |
| code | tableau des chaînes des caractères |
| n | entier |
La fonction saisie_taille
Cette fonction saisit la taille du tableau entre 3 et 50.
|
1 2 3 4 5 6 7 8 9 10 |
fonction saisie_taille():entier Début Ecrire("donner un entier entre 3 et 50 ")) Lire(n) Tant que (n<3) ou (n>50) faire Ecrire("donner un entier entre 3 et 50 ")) Lire(n) Fin tant que retourner n Fin |
Déclaration des objets
| Objet | Type / Nature |
|---|---|
| n | entier |
La fonction verif_identifiant
Cette fonction vérifie que la chaîne est formée de 8 chiffres.
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 |
fonction verif_identifiant(ch:chaine):booleen Début # verifier que l'identifiant est forme de 8 chiffres Si long(ch)=8 alors i<-0 Tant que (i<long(ch)-1) et ('0'<=ch[i]<='9') alors i<-i+1 Fin tant que retourner ('0'<=ch[i]<='9') # l'identifiant est forme de 8 chiffres Sinon return Faux # l'identifiant n'est pas forme de 8 chiffres Fin si Fin |
Déclaration des objets
| Objet | Type / Nature |
|---|---|
| i | entier |
La fonction generer_code
Cette fonction vérifie que le nouveau identifiant est unique dans le tableau des identifiant.
|
1 2 3 4 5 6 7 8 9 10 11 12 13 |
fonction verif_unicite_identifiant(t:tab;i:entier):booleen Début j<-0 #verifier que le nouveau identifiant est unique Tant que j<i et t[j]!=t[i] faire j=j+1 Fin tant que Si j=i alors retourner Vrai # le nouveau identifiant est unique Sinon retourner Faux # le nouveau identifiant n'est pas unique Fin si Fin |
Déclaration des objets
| Objet | Type / Nature |
|---|---|
| j | entier |
La fonction verif_date
Cette fonction vérifie que la date respecte le format J/M avec J est un entier compris entre 1 et 31 et M est un entier compris entre 1 et 12.
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 |
fonction verif_date(ch:chaine):booleen Début Si Pos(ch,'/') >=0 alors i<-0 Tant que (i<Pos(ch,'/')) et ('0'<=ch[i]<='9') alors i<-i+1 Fin tant que Si i=Pos(ch,'/') alors # verifier si le nombre des jours entre 1 et 31 Si (1<=Valeur(Sous_chaine(ch,0,Pos(ch,'/'))<=31) alors i<-i+1 Tant que i<long(ch) et ('0'<=ch[i]<='9') alors i<-i+1 Fin tant que Si i=long(ch) alors # verifier si le nombre des mois entre 1 et 12 retourner (1<=Valeur(Sous_chaine(ch,Pos(ch,'/')+1,long(ch)])<=12) Sinon retourner Faux Fin si Sinon retourner Faux Fin si Sinon retourner Faux Fin si Sinon retourner Faux Fin si Fin |
Déclaration des objets
| Objet | Type / Nature |
|---|---|
| i | entier |
La procédure remplir
Cette procédure remplit les deux tableaux IDENT et DATE respectivement par : les identificateurs et les dates de création des carte à puces.
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 |
procedure remplir(@ident:tab,@date:tab;n:entier) Début # saisir le 1er identifiant dans le tableau ident Ecrire("donner un identifiant N°0 forme de chiffres: ") Lire(ident[0]) Tant que (verif_identifiant(ident[0])=Faux) faire Ecrire("donner un identifiant N°0 forme de chiffres: ") lire(ident[0]) Fin tant que # saisir la 1ere date dans le tableau date Ecrire("donner date de creation identifiant N°0 forme jour/mois: ") Lire(date[0]) Tant que verif_date(date[0])=Faux faire Ecrire("donner date de creation identifiant N°0 forme jour/mois:") Lire(date[0]) Fin tant que # remplir le tableau des identifiants Pour i de 1 à n-1 faire Ecrire("donner un identifiant N°"+i+" forme de chiffres: ") Lire(ident[i]) Tant que (verif_identifiant(ident[i])=Faux) ou (verif_unicite_identifiant(ident,i)=Faux) faire Ecrire("donner un identifiant N°"+i+" forme de chiffres: ") Lire(ident[i]) Fin tant que # remplir le tableau des dates de creation des cartes Ecrire("donner date de creation identifiant N°"+i+" forme jour/mois: ") Lire(date[i]) Tant que (verif_date(date[i])=Faux) faire Ecrire("donner date de creation identifiant N°"+i+" forme jour/mois:") date[i] Fin tant que Fin pour Fin |
Déclaration des objets
| Objet | Type / Nature |
|---|---|
| i | entier |
La fonction generer_code
Cette fonction transforme la date de la création de la carte à puce pour obtenir un code.
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 |
Fonction generer_code(ch:chaine):chaine Début #concatiner j et m ch<-Sous_chaine(ch,0,Pos(ch,'/'))+Sous_chaine(ch, Pos(ch,'/')+1,long(ch)) x<-Alea(5, 64) ch<-Conch(Valeur(ch)*x) Si long(ch)=4 alors # Si le code est forme de 4 chiffres # deplacer le chiffredes milliers vers la droite du nombre retourner Sous_chaine(ch,1,long(ch))+ch[0] Sinon si long(ch)=3 alors# Si le code est forme de 3 chiffres retourner ch+'0' # ajouter 0 à la droite du nombre Sinon si long(ch)=2 alors # Si le code est forme de 2 chiffres retourner ch+'00' # ajouter 00 à la droite du nombre Sinon si long(ch)>4 alors #Si le code est forme de plus de 4 chiffres #additionner le nombre forme de 4 chiffres de gauche #au nombre forme des chiffre jusq'à sa longeur = 4 s<-Valeur(Sous_chaine(ch,0,4))+Valeur(Sous_chaine(ch,4,long(ch)) Tant que (s>10000) alors ch<-Convch(s) s<-Valeur(Sous_chaine(ch,0,4))+Valeur(Sous_chaine(ch,4,long(ch)) Fin tant que retourner str(s) Fin si Fin |
Déclaration des objets
| Objet | Type / Nature |
|---|---|
| s | entier |
La procédure inserer_afficher_codes
Cette procédure insère les codes dans le tableau code et affiche les données de chaque carte à puce.
|
1 2 3 4 5 6 7 |
procedure inserer_afficher_codes(ident:tab,date:tab,@code:tab,n:entier) Début Pour i de 0 à n-1 faire code[i]<-generer_code(date[i]) Ecrire(ident[i]+' : ' +date[i]+' : '+code[i]) Fin pour Fin |
Déclaration des objets
| Objet | Type / Nature |
|---|---|
| i | entier |
Solution en Python
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 |
from numpy import array from random import * # declaration du tableau des identifiants des cartes à puces ident=array([str]*60) # declaration du tableau des dates de creation des cartes à puces date=array([str]*60) # declaration du tableau des codes code=array([str]*60) def saisie_taille(): n=int(input("donner un entier entre 3 et 50: ")) while (n<3) or (n>50): n=int(input("donner un entier entre 3 et 50: ")) return n def verif_identifiant(ch): # verifier que l'identifiant est forme de 8 chiffres if len(ch)==8 : i=0 while (i<len(ch)-1) and ('0'<=ch[i]<='9'): i=i+1 return ('0'<=ch[i]<='9') # l'identifiant est forme de 8 chiffres else: return False # l'identifiant n'est pas forme de 8 chiffres def verif_unicite_identifiant(t,i): j=0 #verifier que le nouveau identifiant est unique while j<i and t[j]!=t[i]: j=j+1 if j==i : return True # le nouveau identifiant est unique else: return False # le nouveau identifiant n'est pas unique def verif_date(ch): if ch.find('/') >=0 : i=0 while (i<ch.find('/')) and ('0'<=ch[i]<='9'): i=i+1 if i==ch.find('/') : # verifier si le nombre des jours entre 1 et 31 if (1<=int(ch[0:ch.find('/')])<=31): i=i+1 while i<len(ch) and ('0'<=ch[i]<='9'): i=i+1 if i==len(ch): # verifier si le nombre des mois entre 1 et 12 return (1<=int(ch[ch.find('/')+1:len(ch)])<=12) else: return False else: return False else: return False else: return False def remplir(ident,date,n): # remplir le tableau des identifiants ident[0]=input("donner un identifiant N°0 forme de chiffres: ") while (verif_identifiant(ident[0])==False): ident[0]=input("donner un identifiant N°0 forme de chiffres: ") # remplir le tableau des dates de creation des cartes date[0]=input("donner date de creation identifiant N°0 forme jour/mois: ") while verif_date(date[0])==False: date[0]=input("donner date de creation identifiant N°0 forme jour/mois:") # remplir le tableau des identifiants for i in range (1,n) : ident[i]=input("donner un identifiant N°"+str(i)+" forme de chiffres: ") while (verif_identifiant(ident[i])==False) or (verif_unicite_identifiant(ident,i)==False): ident[i]=input("donner un identifiant N°"+str(i)+" forme de chiffres: ") # remplir le tableau des dates de creation des cartes date[i]=input("donner date de creation identifiant N°"+str(i)+" forme jour/mois: ") while (verif_date(date[i])==False): date[i]=input("donner date de creation identifiant N°"+str(i)+" forme jour/mois:") def generer_code(ch): #concatiner j et m ch=ch[0:ch.find('/')]+ch[ch.find('/')+1:len(ch)] x=randint(5, 64) ch=str(int(ch)*x) if len(ch)==4 :# Si le code est forme de 4 chiffres # deplacer le chiffredes milliers vers la droite du nombre return ch[1:len(ch)]+ch[0] elif len(ch)==3:# Si le code est forme de 3 chiffres return ch+'0' # ajouter 0 à la droite du nombre elif len(ch)==2: # Si le code est forme de 2 chiffres return ch+'00' # ajouter 00 à la droite du nombre elif len(ch)>4:#Si le code est forme de plus de 4 chiffres #additionner le nombre forme de 4 chiffres de gauche #au nombre forme des chiffre jusq'à sa longeur = 4 s=int(ch[0:4])+int(ch[4:len(ch)]) while (s>10000): ch=str(s) s=int(ch[0:4])+int(ch[4:len(ch)]) return str(s) def inserer_afficher_codes(ident,date,code,n): for i in range (n): code[i]=generer_code(date[i]) print(ident[i]+' : ' +date[i]+' : '+code[i]) #programme principal n=saisie_taille() remplir(ident,date,n) inserer_afficher_codes(ident,date,code,n) |
Exécution du programme:
Solution en Python et Designer QT
Pour créer une application en Python et Designer QT qui stocke les données des cartes à puces, on va suivre ces étapes:
1- Créer l'interface graphique avec Qt Designer
a- Ouvrez Qt Designer et créez un nouveau fichier de type Main Window.
b- Ajoutez ces widgets:
QLineEdit nommé 'ch1' pour entrer les identificateurs des cartes à puces
QLineEdit nommé 'ch2' pour entrer les dates de création des cartes à puces
QPushButton nommé 'remplirid_bt' pour mettre les identificateurs des cartes à puces dans le tableau IDENT.
QPushButton nommé 'remplirdate_bt' pour mettre les dates dans le tableau DATE.
QPushButton nommé 'afficher_bt' pour afficher la liste des identificateurs des cartes à puces ainsi que leurs dates de création et leurs codes générés.
QLabel nommé 'tabident_label' pour contenir les identificateurs des cartes à puces.
QLabel nommé 'tabdate_label' pour contenir les dates de création des cartes à puces.
QLabel nommé 'tabcode_label' pour contenir les codes des cartes à puces.
QLabel nommé 'msg' pour afficher des messages d'erreur.
QLabel nommé 'resultat' pour contenir la liste des nouveau-nés ayant une heure de naissance miroir et les nombres des nouveau-nés pour chaque type d'heure miroir.
Enregistrez le fichier avec l'extension .ui, par exemple tabtab-3.ui.
2- Créer le script Python pour l'application
Voici un exemple de script Python qui utilise l'interface graphique générée par Qt Designer.
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 163 164 165 166 167 168 169 170 171 172 173 174 175 176 177 178 179 180 181 182 183 184 185 186 187 188 189 190 191 192 193 194 195 196 197 198 199 200 201 202 203 204 205 206 207 208 209 210 211 212 213 214 215 216 217 218 219 220 221 222 223 224 225 226 227 228 229 230 231 232 |
from PyQt5.uic import loadUi from PyQt5.QtWidgets import QApplication from numpy import array from random import * # declaration du tableau des identifiants des cartes à puces ident=array([str]*60) # declaration du tableau des dates de creation des cartes à puces date=array([str]*60) # declaration du tableau des codes code=array([str]*60) app = QApplication([]) windows = loadUi ("tabtab-3.ui") # Fonction qui supprime des espaces de la chaine des carcatères def supprimer_espaces (ch) : while(ch[0]==' '): # elimnier tous les espaces au début de la chaine ch=ch[1:len(ch)] while(ch[len(ch)-1]==' '): # elimnier tous les espaces a la fin de la chaine ch=ch[0:len(ch)-1] while (ch.find(' ')>0): ch=ch.replace(" ", " ") # remplacer les doubles espaces apar un seul espace return ch def verif_unicite_identifiant(t,i): j=0 #verifier que le nouveau identifiant est unique while j<i and t[j]!=t[i]: j=j+1 if j==i : return True # le nouveau identifiant est unique else: return False # le nouveau identifiant n'est pas unique def verif_unicite_identifiant(t,i): j=0 #verifier que le nouveau identifiant est unique while j<i and t[j]!=t[i]: j=j+1 if j==i : return True # le nouveau identifiant est unique else: return False # le nouveau identifiant n'est pas unique # Procedure qui remplit le tableau IDENT des identificateurs def createTabIDENT(): windows.tabident_label.clear() windows.msg.clear() global n #pour la taile du tableau a des utilisateurs ch = windows.ch1.text() if ch=="": windows.msg.setText("Veuillez remplir la chaîne") else: windows.msg.clear() # effacer le message d erreur ch= supprimer_espaces(ch) i=0 j=0 ch1='' unicite_identifiant=True # pour verifier l'unicite des identificateurs test_8chiffres=True # parcourir les caracteres de la chaine CH1 while(i<len(ch)) and (test_8chiffres) and(unicite_identifiant) and (('0'<=ch[i].upper()<='9')or (ch[i]==' ')): if (ch[i]!=' ') : ch1=ch1+ch[i] if ((ch[i]==' ') or (i==len(ch)-1)) : # remplir le tableau IDENT par des identificateurs ident[j]=ch1 if j>=1: unicite_identifiant=verif_unicite_identifiant(ident,j) test_8chiffres=(len(ch1)==8) ch1='' j=j+1 i=i+1 if (i==len(ch)) and (test_8chiffres) and (unicite_identifiant) : if 3<=j<=50: n=j tab='' for k in range (j) : tab=tab+ 'ident['+str(k)+']= '+ident[k]+ '\n' #afficher les elements du tableau windows.tabident_label.setText(tab) else: windows.msg.setText("la taille du tableau a doit etre entre 3 et 50") else: windows.msg.setText("les identifiants doivent differentes et formes de 8 chiffres") def verif_heure(ch): # verifier la longueur de la chaine if len(ch)==5: # verifier la chaine est compse des chiffres et le symbole : if ('0'<=ch[0]<='2') and ('0'<=ch[1]<='9') and (ch[2]==':') and ('0'<=ch[3]<='5') and ('0'<=ch[4]<='9'): # verifier la valeur de HH est comprise entre 0 et 23 ## verifier la valeur de MM est comprise entre 0 et 59 if (0<=int(ch[0]+ch[1])<=23) and (0<=int(ch[3]+ch[4])<=59): return True else: return False else: return False else: return False def verif_date(ch): if ch.find('/') >=0 : i=0 while (i<ch.find('/')) and ('0'<=ch[i]<='9'): i=i+1 if i==ch.find('/') : # verifier si le nombre des jours entre 1 et 31 if (1<=int(ch[0:ch.find('/')])<=31): i=i+1 while i<len(ch) and ('0'<=ch[i]<='9'): i=i+1 if i==len(ch): # verifier si le nombre des mois entre 1 et 12 return (1<=int(ch[ch.find('/')+1:len(ch)])<=12) else: return False else: return False else: return False else: return False # Procedure qui remplit un tableau des dates de creation des cartes a puce def createTabDATE(): windows.tabdate_label.clear() windows.msg.clear() ch = windows.ch2.text() if ch=="": windows.msg.setText("Veuillez remplir la chaîne") else: windows.msg.clear() # effacer le message d erreur ch= supprimer_espaces(ch) i=0 j=0 ch1='' verifdate=True # parcourir les caracteres de la chaine CH2 while(i<len(ch)) and (verifdate) and (('0'<=ch[i]<='9')or (ch[i]==' ' )or (ch[i]=='/')): if ('0'<=ch[i]<='9')or (ch[i]=='/'): ch1=ch1+ch[i] if ((ch[i]==' ') or (i==len(ch)-1)) : # remplir le tableau date par des dates de creation des cartes a puce date[j]=ch1 # verifier le format de la date Jour/Mois verifdate=verif_date(ch1) ch1='' j=j+1 i=i+1 if (i==len(ch)) and (verifdate) : if j==n: #la taille du tableau r doit etre egal a la taille du tableau IDENT tab='' for k in range (j) : tab=tab+ 'date['+str(k)+']= '+date[k]+ '\n' #afficher les elements du tableau windows.tabdate_label.setText(tab) else: windows.msg.setText("la taille du tableau DATE doit etre egal a "+str(n)) else: windows.msg.setText("Les dates doivent etre sous forme jour/mois ") def generer_code(ch): #concatiner j et m ch=ch[0:ch.find('/')]+ch[ch.find('/')+1:len(ch)] x=randint(5, 64) ch=str(int(ch)*x) if len(ch)==4 :# Si le code est forme de 4 chiffres # deplacer le chiffredes milliers vers la droite du nombre return ch[1:len(ch)]+ch[0] elif len(ch)==3:# Si le code est forme de 3 chiffres return ch+'0' # ajouter 0 à la droite du nombre elif len(ch)==2: # Si le code est forme de 2 chiffres return ch+'00' # ajouter 00 à la droite du nombre elif len(ch)>4:#Si le code est forme de plus de 4 chiffres #additionner le nombre forme de 4 chiffres de gauche #au nombre forme des chiffre jusq'à sa longeur = 4 s=int(ch[0:4])+int(ch[4:len(ch)]) while (s>10000): ch=str(s) s=int(ch[0:4])+int(ch[4:len(ch)]) return str(s) def inserer_afficher_codes(): resultat='' tab='' for i in range (n): code[i]=generer_code(date[i]) tab=tab+ 'code['+str(i)+']= '+code[i]+ '\n' resultat=resultat+ident[i]+' : ' +date[i]+' : '+code[i]+'\n' #afficher les elements du tableau Code windows.tabcode_label.setText(tab) windows.resultat.setText(resultat) windows.remplirid_bt.clicked.connect ( createTabIDENT ) windows.remplirdate_bt.clicked.connect ( createTabDATE ) windows.afficher_bt.clicked.connect ( inserer_afficher_codes ) windows.show() app.exec_() |
Exécution du programme
1) Remplissage du tableau IDENT
2) Remplissage du tableau DATE
3) Remplissage du tableau CODE et affichage des données des cartes à puces
Vous pouvez voir aussi :
1) des exercices sur les chaînes des caractères
2) des exercices sur les tableaux
3) des sujets Bac pratique
4) des sujets Bac théorique
0 commentaire
laisser un commentaire
Passion de robotique
Tutoriels récents
Atelier robotique
Tutoriels populaires
Construction des robots
Tutoriels plus commentés
Bras robotique
Categories
Maison intelligente
