Utilisation de Python et des expressions régulières de Dreamweaver
pour générer et modifier un grand nombre de questions dans les QCM
La fonction range de Python et utilisation des listes
En python la fonction range permet de générer facilement une liste de nombres. Elle s'utilise avec 1, 2 ou 3 paramètres. La fonction list permet d'afficher la liste obtenue.
Avec un seul paramètre n la fonction range(n) génère tous les entiers de 0 à n-1. Exemple :
list(range(10)) donne [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
Avec 2 paramètres n et p la fonction range(n,p) génère tous les entiers de n à p-1. Exemples :
list(range(1,10)) donne [1, 2, 3, 4, 5, 6, 7, 8, 9]
list(range(7,23)) donne [7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22]
Avec 3 paramètres n, p et k la fonction range(n,p,k) génère la liste d'entiers allant de n à p-1 de k en k. Exemples :
list(range(0,22,2)) donne [0, 2, 4, 6, 8, 10, 12, 14, 16, 18, 20] (nombres pairs de 0 à 20, n compris mais p-1 non compris)
list(range(1,20,2)) donne [1, 3, 5, 7, 9, 11, 13, 15, 17, 19] (nombres impairs de 1 à 19, n compris et p-1 compris)
list(range(63,281,17)) donne [63, 80, 97, 114, 131, 148, 165, 182, 199, 216, 233, 250, 267]
La fonction range de Python permet donc d'obtenir facilement une suite de nombres, consécutifs ou non, de longueur quelconque.
Application immédiate : générer une série de 48 additions :
for a in range (4,50,6):
for b in range(2,40,7):
print(a,'+',b,'=',a+b)
Le résultat est :
4 + 2 = 6
4 + 9 = 13
4 + 16 = 20
4 + 23 = 27
4 + 30 = 34
4 + 37 = 41
10 + 2 = 12
10 + 9 = 19
10 + 16 = 26
10 + 23 = 33
10 + 30 = 40
10 + 37 = 47
16 + 2 = 18
16 + 9 = 25
16 + 16 = 32
16 + 23 = 39
16 + 30 = 46
16 + 37 = 53
22 + 2 = 24
22 + 9 = 31
22 + 16 = 38
22 + 23 = 45
22 + 30 = 52
22 + 37 = 59
28 + 2 = 30
28 + 9 = 37
28 + 16 = 44
28 + 23 = 51
28 + 30 = 58
28 + 37 = 65
34 + 2 = 36
34 + 9 = 43
34 + 16 = 50
34 + 23 = 57
34 + 30 = 64
34 + 37 = 71
40 + 2 = 42
40 + 9 = 49
40 + 16 = 56
40 + 23 = 63
40 + 30 = 70
40 + 37 = 77
46 + 2 = 48
46 + 9 = 55
46 + 16 = 62
46 + 23 = 69
46 + 30 = 76
46 + 37 = 83
Comment s'assurer que les résultats des additions sont uniques ? Pour cela on va créer une liste contenant les 48 résultats, puis on va convertir la liste en ensemble grâce à la fonction set de Python, ce qui aura pour effet de supprimer les doublons. Si la taille de la liste et la taille de l'ensemble sont identiques alors il n'y a pas de doublons. De plus la méthode sort permet de trier la liste par ordre croissant et la méthode append permet d'ajouter un élément à la fin de la liste :
l=[]
for a in range (4,50,6):
for b in range(2,40,7):
l.append(a+b)
l.sort()
print('La liste :')
print(list(l))
print('L\'ensemble :')
print(set(l))
print('Taille de la liste :',len(l))
print('Taille de l\'ensemble :',len(set(l)))
Ce qui affiche (la liste et son ensemble ayant la même taille les résultats des additions sont uniques) :
La liste :
[6, 12, 13, 18, 19, 20, 24, 25, 26, 27, 30, 31, 32, 33, 34, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, 55, 56, 57, 58, 59, 62, 63, 64, 65, 69, 70, 71, 76, 77, 83]
L'ensemble :
{6, 12, 13, 18, 19, 20, 24, 25, 26, 27, 30, 31, 32, 33, 34, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, 55, 56, 57, 58, 59, 62, 63, 64, 65, 69, 70, 71, 76, 77, 83}
Taille de la liste : 48
Taille de l'ensemble : 48
Remarque : la liste est encadrée par des crochets alors que l'ensemble est encadré par des accolades.
Exemple de cas où les résultats sont multiples :
l=[]
for a in range (4,20,2):
for b in range(2,40,3):
l.append(a+b)
l.sort()
print('La liste :')
print(list(l))
print('L\'ensemble :')
print(set(l))
print('Taille de la liste :',len(l))
print('Taille de l\'ensemble :',len(set(l)))
Ce qui affiche :
La liste :
[6, 8, 9, 10, 11, 12, 12, 13, 14, 14, 15, 15, 16, 16, 17, 17, 18, 18, 18, 19, 19, 20, 20, 20, 21, 21, 21, 22, 22, 23, 23, 23, 24, 24, 24, 25, 25, 26, 26, 26, 27, 27, 27, 28, 28, 29, 29, 29, 30, 30, 30, 31, 31, 32, 32, 32, 33, 33, 33, 34, 34, 35, 35, 35, 36, 36, 36, 37, 37, 38, 38, 38, 39, 39, 39, 40, 40, 41, 41, 41, 42, 42, 42, 43, 43, 44, 44, 44, 45, 45, 46, 46, 47, 47, 48, 48, 49, 50, 50, 51, 52, 53, 54, 56]
L'ensemble :
{6, 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, 56}
Taille de la liste : 104
Taille de l'ensemble : 49
Enfin la concaténation de listes se fait tout simplement avec l'opérateur + :
x=[1,2,3]+[4,5] affectera à x la liste [1,2,3,4,5]
x=[47,53]+list(range(5,12)) donnera la liste [47, 53, 5, 6, 7, 8, 9, 10, 11]
for i in [1,2]+[3,4]+list(range(5,12))+[12]:print(i) affichera tous les entiers de 1 à 12
Les additions en hexadécimal
Le programme suivant en Python génère un fichier texte de 500 lignes contenant des additions en hexadécimal.
Les lettres de a à f ont été converti en majuscules grâce à la fonction upper() :
import random
for i in range(500):
a=random.randint(5,4095)
b=random.randint(1,64)
c=a+b
print(str(hex(a)).upper()+'+'+str(hex(b)).upper()+'='+str(hex(c)).upper())
Exemple de fichier généré :
0X215+0X12=0X227
0XC55+0XE=0XC63
0XAE3+0X37=0XB1A
0X1F+0X5=0X24
0X54E+0X10=0X55E
0X370+0X10=0X380
0X542+0X21=0X563
0X13E+0X40=0X17E
0XD42+0X34=0XD76
0XEB5+0X1E=0XED3
0X8FA+0X3B=0X935
0X2B+0X1E=0X49
0XF70+0X3F=0XFAF
0X8E1+0X39=0X91A
0XB73+0XA=0XB7D
0X575+0X3=0X578
0X80A+0X14=0X81E
Remarque : le résultat de l'addition peut parfois être sur 4 chiffres et non 3. Exemple : FE8 + 1A = 1002
En remplaçant le motif suivant :
0X([0-9,A-F]{1,3})\+0X([0-9,A-F]{1,3})=0X([0-9,A-F]{1,4})
Par ceci en utilisant les expressions régulières dans Dreamwever :
quest("Entrez en hexadécimal le résultat de l'addition hexadécimale $1 + $2 :");
rep("$1 + $2 = [$3]");
debut("Pour entrer des lettres saisissez-les en MAJUSCULES ou utilisez les boutons ci-dessous :");
caracteres_speciaux("0","1","2","3","4","5","6","7","8","9","A","B","C","D","E","F");
Le fichier est converti en 500 questions exploitables dans un QCM :
quest("Entrez en hexadécimal le résultat de l'addition hexadécimale 215 + 12 :");
rep("215 + 12 = [227]");
debut("Pour entrer des lettres saisissez-les en MAJUSCULES ou utilisez les boutons ci-dessous :");
caracteres_speciaux("0","1","2","3","4","5","6","7","8","9","A","B","C","D","E","F");
quest("Entrez en hexadécimal le résultat de l'addition hexadécimale C55 + E :");
rep("C55 + E = [C63]");
debut("Pour entrer des lettres saisissez-les en MAJUSCULES ou utilisez les boutons ci-dessous :");
caracteres_speciaux("0","1","2","3","4","5","6","7","8","9","A","B","C","D","E","F");
quest("Entrez en hexadécimal le résultat de l'addition hexadécimale AE3 + 37 :");
rep("AE3 + 37 = [B1A]");
debut("Pour entrer des lettres saisissez-les en MAJUSCULES ou utilisez les boutons ci-dessous :");
caracteres_speciaux("0","1","2","3","4","5","6","7","8","9","A","B","C","D","E","F");
quest("Entrez en hexadécimal le résultat de l'addition hexadécimale 1F + 5 :");
rep("1F + 5 = [24]");
debut("Pour entrer des lettres saisissez-les en MAJUSCULES ou utilisez les boutons ci-dessous :");
caracteres_speciaux("0","1","2","3","4","5","6","7","8","9","A","B","C","D","E","F");
quest("Entrez en hexadécimal le résultat de l'addition hexadécimale 54E + 10 :");
rep("54E + 10 = [55E]");
debut("Pour entrer des lettres saisissez-les en MAJUSCULES ou utilisez les boutons ci-dessous :");
caracteres_speciaux("0","1","2","3","4","5","6","7","8","9","A","B","C","D","E","F");
quest("Entrez en hexadécimal le résultat de l'addition hexadécimale 370 + 10 :");
rep("370 + 10 = [380]");
debut("Pour entrer des lettres saisissez-les en MAJUSCULES ou utilisez les boutons ci-dessous :");
caracteres_speciaux("0","1","2","3","4","5","6","7","8","9","A","B","C","D","E","F");
quest("Entrez en hexadécimal le résultat de l'addition hexadécimale 542 + 21 :");
rep("542 + 21 = [563]");
debut("Pour entrer des lettres saisissez-les en MAJUSCULES ou utilisez les boutons ci-dessous :");
caracteres_speciaux("0","1","2","3","4","5","6","7","8","9","A","B","C","D","E","F");
quest("Entrez en hexadécimal le résultat de l'addition hexadécimale 13E + 40 :");
rep("13E + 40 = [17E]");
debut("Pour entrer des lettres saisissez-les en MAJUSCULES ou utilisez les boutons ci-dessous :");
caracteres_speciaux("0","1","2","3","4","5","6","7","8","9","A","B","C","D","E","F");
quest("Entrez en hexadécimal le résultat de l'addition hexadécimale D42 + 34 :");
rep("D42 + 34 = [D76]");
debut("Pour entrer des lettres saisissez-les en MAJUSCULES ou utilisez les boutons ci-dessous :");
caracteres_speciaux("0","1","2","3","4","5","6","7","8","9","A","B","C","D","E","F");
quest("Entrez en hexadécimal le résultat de l'addition hexadécimale EB5 + 1E :");
rep("EB5 + 1E = [ED3]");
debut("Pour entrer des lettres saisissez-les en MAJUSCULES ou utilisez les boutons ci-dessous :");
caracteres_speciaux("0","1","2","3","4","5","6","7","8","9","A","B","C","D","E","F");
quest("Entrez en hexadécimal le résultat de l'addition hexadécimale 8FA + 3B :");
rep("8FA + 3B = [935]");
debut("Pour entrer des lettres saisissez-les en MAJUSCULES ou utilisez les boutons ci-dessous :");
caracteres_speciaux("0","1","2","3","4","5","6","7","8","9","A","B","C","D","E","F");
quest("Entrez en hexadécimal le résultat de l'addition hexadécimale 2B + 1E :");
rep("2B + 1E = [49]");
debut("Pour entrer des lettres saisissez-les en MAJUSCULES ou utilisez les boutons ci-dessous :");
caracteres_speciaux("0","1","2","3","4","5","6","7","8","9","A","B","C","D","E","F");
quest("Entrez en hexadécimal le résultat de l'addition hexadécimale F70 + 3F :");
rep("F70 + 3F = [FAF]");
debut("Pour entrer des lettres saisissez-les en MAJUSCULES ou utilisez les boutons ci-dessous :");
caracteres_speciaux("0","1","2","3","4","5","6","7","8","9","A","B","C","D","E","F");
quest("Entrez en hexadécimal le résultat de l'addition hexadécimale 8E1 + 39 :");
rep("8E1 + 39 = [91A]");
debut("Pour entrer des lettres saisissez-les en MAJUSCULES ou utilisez les boutons ci-dessous :");
caracteres_speciaux("0","1","2","3","4","5","6","7","8","9","A","B","C","D","E","F");
quest("Entrez en hexadécimal le résultat de l'addition hexadécimale B73 + A :");
rep("B73 + A = [B7D]");
debut("Pour entrer des lettres saisissez-les en MAJUSCULES ou utilisez les boutons ci-dessous :");
caracteres_speciaux("0","1","2","3","4","5","6","7","8","9","A","B","C","D","E","F");
quest("Entrez en hexadécimal le résultat de l'addition hexadécimale 575 + 3 :");
rep("575 + 3 = [578]");
debut("Pour entrer des lettres saisissez-les en MAJUSCULES ou utilisez les boutons ci-dessous :");
caracteres_speciaux("0","1","2","3","4","5","6","7","8","9","A","B","C","D","E","F");
quest("Entrez en hexadécimal le résultat de l'addition hexadécimale 80A + 14 :");
rep("80A + 14 = [81E]");
debut("Pour entrer des lettres saisissez-les en MAJUSCULES ou utilisez les boutons ci-dessous :");
caracteres_speciaux("0","1","2","3","4","5","6","7","8","9","A","B","C","D","E","F");
Autre motif de mise en forme en utilisant le même motif de recherche et le même fichier texte généré par Python :
quest("Complétez l'addition hexadécimale suivante :");
rep("$1 + [$2] = $3");
debut("Pour entrer des lettres saisissez-les en MAJUSCULES ou utilisez les boutons ci-dessous :");
caracteres_speciaux("0","1","2","3","4","5","6","7","8","9","A","B","C","D","E","F");
Troisième solution de mise en forme toujours en utilisant le même motif de recherche et le même fichier texte généré par Python :
quest("Complétez la soustraction hexadécimale suivante :");
rep("$3 - [$2] = $1");
debut("Pour entrer des lettres saisissez-les en MAJUSCULES ou utilisez les boutons ci-dessous :");
caracteres_speciaux("0","1","2","3","4","5","6","7","8","9","A","B","C","D","E","F");
Les soustractions en hexadécimal
Le programme suivant en Python génère un fichier texte contenant une soustraction en hexadécimal sur chaque ligne :
import random
for i in range(100):
a=random.randint(5,4095)
b=random.randint(1,64)
c=a-b
print(str(hex(a)).upper()+'-'+str(hex(b)).upper()+'='+str(hex(c)).upper())
ATTENTION : si a < b le résultat sera négatif, et Python renverra un nombre hexadécimal avec un signe moins comme par exemple -0X3A
La ligne correspondante ne sera alors pas convertie par l'expression régulière, ce qui provoquera un problème au niveau du QCM qui refusera d'afficher la page d'accueil. Pour détecter une telle ligne dans le fichier généré par Python il suffit d'y rechercher la chaîne "=-" avant l'application de l'expression régulière.
On peut aussi rechercher toutes les lignes erronées dans le fichier du QCM grâce à l'expression régulière suivante qui trouve les lignes hors commentaire qui ne finissent pas par un point virgule :
\n[^(//.*\n)].*[^;\n]\n
Exemple de fichier généré :
0XF79-0X40=0XF39
0X3E8-0X16=0X3D2
0XD3F-0X28=0XD17
0X14C-0X1D=0X12F
0XA0-0X37=0X69
0XB53-0X29=0XB2A
0XEFE-0X2C=0XED2
0XB2-0X2=0XB0
0X4EF-0X11=0X4DE
0X42F-0X1F=0X410
Les expressions régulières suivantes permettent de convertir directement dans Dreamweaver le fichier texte généré par Python en fichier mis en forme au format des QCM.
Motif de recherche :
0X([0-9,A-F]{1,3})-0X([0-9,A-F]{1,3})=0X([0-9,A-F]{1,3})
Motif de remplacement :
quest("Entrez en hexadécimal le résultat de la soustraction hexadécimale $1 - $2 :");
rep("$1 - $2 = [$3]");
debut("Pour entrer des lettres saisissez-les en MAJUSCULES ou utilisez les boutons ci-dessous :");
caracteres_speciaux("0","1","2","3","4","5","6","7","8","9","A","B","C","D","E","F");
Exemple de fichier QCM obtenu :
quest("Entrez en hexadécimal le résultat de la soustraction hexadécimale F79 - 40 :");
rep("F79 - 40 = [F39]");
debut("Pour entrer des lettres saisissez-les en MAJUSCULES ou utilisez les boutons ci-dessous :");
caracteres_speciaux("0","1","2","3","4","5","6","7","8","9","A","B","C","D","E","F");
quest("Entrez en hexadécimal le résultat de la soustraction hexadécimale 3E8 - 16 :");
rep("3E8 - 16 = [3D2]");
debut("Pour entrer des lettres saisissez-les en MAJUSCULES ou utilisez les boutons ci-dessous :");
caracteres_speciaux("0","1","2","3","4","5","6","7","8","9","A","B","C","D","E","F");
quest("Entrez en hexadécimal le résultat de la soustraction hexadécimale D3F - 28 :");
rep("D3F - 28 = [D17]");
debut("Pour entrer des lettres saisissez-les en MAJUSCULES ou utilisez les boutons ci-dessous :");
caracteres_speciaux("0","1","2","3","4","5","6","7","8","9","A","B","C","D","E","F");
quest("Entrez en hexadécimal le résultat de la soustraction hexadécimale 14C - 1D :");
rep("14C - 1D = [12F]");
debut("Pour entrer des lettres saisissez-les en MAJUSCULES ou utilisez les boutons ci-dessous :");
caracteres_speciaux("0","1","2","3","4","5","6","7","8","9","A","B","C","D","E","F");
quest("Entrez en hexadécimal le résultat de la soustraction hexadécimale A0 - 37 :");
rep("A0 - 37 = [69]");
debut("Pour entrer des lettres saisissez-les en MAJUSCULES ou utilisez les boutons ci-dessous :");
caracteres_speciaux("0","1","2","3","4","5","6","7","8","9","A","B","C","D","E","F");
quest("Entrez en hexadécimal le résultat de la soustraction hexadécimale B53 - 29 :");
rep("B53 - 29 = [B2A]");
debut("Pour entrer des lettres saisissez-les en MAJUSCULES ou utilisez les boutons ci-dessous :");
caracteres_speciaux("0","1","2","3","4","5","6","7","8","9","A","B","C","D","E","F");
quest("Entrez en hexadécimal le résultat de la soustraction hexadécimale EFE - 2C :");
rep("EFE - 2C = [ED2]");
debut("Pour entrer des lettres saisissez-les en MAJUSCULES ou utilisez les boutons ci-dessous :");
caracteres_speciaux("0","1","2","3","4","5","6","7","8","9","A","B","C","D","E","F");
quest("Entrez en hexadécimal le résultat de la soustraction hexadécimale B2 - 2 :");
rep("B2 - 2 = [B0]");
debut("Pour entrer des lettres saisissez-les en MAJUSCULES ou utilisez les boutons ci-dessous :");
caracteres_speciaux("0","1","2","3","4","5","6","7","8","9","A","B","C","D","E","F");
quest("Entrez en hexadécimal le résultat de la soustraction hexadécimale 4EF - 11 :");
rep("4EF - 11 = [4DE]");
debut("Pour entrer des lettres saisissez-les en MAJUSCULES ou utilisez les boutons ci-dessous :");
caracteres_speciaux("0","1","2","3","4","5","6","7","8","9","A","B","C","D","E","F");
quest("Entrez en hexadécimal le résultat de la soustraction hexadécimale 42F - 1F :");
rep("42F - 1F = [410]");
debut("Pour entrer des lettres saisissez-les en MAJUSCULES ou utilisez les boutons ci-dessous :");
caracteres_speciaux("0","1","2","3","4","5","6","7","8","9","A","B","C","D","E","F");
Le ET bit à bit en binaire
Le programme suivant en Python génère un fichier texte contenant une opération sur chaque ligne :
import random
for i in range(10):
a=random.randint(0,255)
b=random.randint(0,255)
c=a&b
print(str(bin(a))+'&'+str(bin(b))+'='+str(bin(c)))
Exemple de fichier généré :
0b10110111&0b10000000=0b10000000
0b11001101&0b10110100=0b10000100
0b1001001&0b10110=0b0
0b1001&0b10010001=0b1
0b11110010&0b10100101=0b10100000
0b11000001&0b1=0b1
0b11001101&0b10111101=0b10001101
0b11100010&0b100000=0b100000
0b1010001&0b10101011=0b1
0b10111&0b1110111=0b10111
Les expressions régulières suivantes permettent de convertir directement dans Dreamweaver le fichier texte généré par Python en fichier mis en forme au format des QCM.
Motif de recherche :
0b([0-1]{1,8})&0b([0-1]{1,8})=0b([0-1]{1,8})
Motif de remplacement :
quest("Entrez en binaire le résultat du ET bit à bit entre les nombres binaires $1 et $2 :");
rep("$1 ET $2 = [$3]");
debut("Entrez votre résultat SANS saisir les zéros non significatifs sur les poids forts");
caracteres_speciaux("0","1");
Exemple de fichier QCM obtenu :
quest("Entrez en binaire le résultat du ET bit à bit entre les nombres binaires 10110111 et 10000000 :");
rep("10110111 ET 10000000 = [10000000]");
debut("Entrez votre résultat SANS saisir les zéros non significatifs sur les poids forts");
caracteres_speciaux("0","1");
quest("Entrez en binaire le résultat du ET bit à bit entre les nombres binaires 11001101 et 10110100 :");
rep("11001101 ET 10110100 = [10000100]");
debut("Entrez votre résultat SANS saisir les zéros non significatifs sur les poids forts");
caracteres_speciaux("0","1");
quest("Entrez en binaire le résultat du ET bit à bit entre les nombres binaires 1001001 et 10110 :");
rep("1001001 ET 10110 = [0]");
debut("Entrez votre résultat SANS saisir les zéros non significatifs sur les poids forts");
caracteres_speciaux("0","1");
quest("Entrez en binaire le résultat du ET bit à bit entre les nombres binaires 1001 et 10010001 :");
rep("1001 ET 10010001 = [1]");
debut("Entrez votre résultat SANS saisir les zéros non significatifs sur les poids forts");
caracteres_speciaux("0","1");
quest("Entrez en binaire le résultat du ET bit à bit entre les nombres binaires 11110010 et 10100101 :");
rep("11110010 ET 10100101 = [10100000]");
debut("Entrez votre résultat SANS saisir les zéros non significatifs sur les poids forts");
caracteres_speciaux("0","1");
quest("Entrez en binaire le résultat du ET bit à bit entre les nombres binaires 11000001 et 1 :");
rep("11000001 ET 1 = [1]");
debut("Entrez votre résultat SANS saisir les zéros non significatifs sur les poids forts");
caracteres_speciaux("0","1");
quest("Entrez en binaire le résultat du ET bit à bit entre les nombres binaires 11001101 et 10111101 :");
rep("11001101 ET 10111101 = [10001101]");
debut("Entrez votre résultat SANS saisir les zéros non significatifs sur les poids forts");
caracteres_speciaux("0","1");
quest("Entrez en binaire le résultat du ET bit à bit entre les nombres binaires 11100010 et 100000 :");
rep("11100010 ET 100000 = [100000]");
debut("Entrez votre résultat SANS saisir les zéros non significatifs sur les poids forts");
caracteres_speciaux("0","1");
quest("Entrez en binaire le résultat du ET bit à bit entre les nombres binaires 1010001 et 10101011 :");
rep("1010001 ET 10101011 = [1]");
debut("Entrez votre résultat SANS saisir les zéros non significatifs sur les poids forts");
caracteres_speciaux("0","1");
quest("Entrez en binaire le résultat du ET bit à bit entre les nombres binaires 10111 et 1110111 :");
rep("10111 ET 1110111 = [10111]");
debut("Entrez votre résultat SANS saisir les zéros non significatifs sur les poids forts");
caracteres_speciaux("0","1");
Le ET bit à bit en hexadécimal
Le programme suivant en Python génère un fichier texte contenant une opération sur chaque ligne :
import random
for i in range(10):
a=random.randint(0,255)
b=random.randint(0,255)
c=a&b
print(str(hex(a)).upper()+'et'+str(hex(b)).upper()+'='+str(hex(c)).upper())
Exemple de fichier généré :
0XEEet0XC2=0XC2
0X86et0X85=0X84
0X8et0X8A=0X8
0X97et0XDB=0X93
0X96et0X2F=0X6
0X72et0X55=0X50
0X67et0X8A=0X2
0X71et0XDD=0X51
0XB2et0XAE=0XA2
0X0et0XAF=0X0
Les expressions régulières suivantes permettent de convertir directement dans Dreamweaver le fichier texte généré par Python en fichier mis en forme au format des QCM.
Motif de recherche :
0X([0-9,A-F]{1,2})et0X([0-9,A-F]{1,2})=0X([0-9,A-F]{1,2})
Motif de remplacement :
quest("Entrez en hexadécimal le résultat du ET bit à bit entre les nombres hexadécimaux $1 et $2 :");
rep("$1 ET $2 = [$3]");
debut("Pour entrer des lettres saisissez-les en MAJUSCULES ou utilisez les boutons ci-dessous :");
caracteres_speciaux("0","1","2","3","4","5","6","7","8","9","A","B","C","D","E","F");
Exemple de fichier QCM obtenu :
quest("Entrez en hexadécimal le résultat du ET bit à bit entre les nombres hexadécimaux EE et C2 :");
rep("EE ET C2 = [C2]");
debut("Pour entrer des lettres saisissez-les en MAJUSCULES ou utilisez les boutons ci-dessous :");
caracteres_speciaux("0","1","2","3","4","5","6","7","8","9","A","B","C","D","E","F");
quest("Entrez en hexadécimal le résultat du ET bit à bit entre les nombres hexadécimaux 86 et 85 :");
rep("86 ET 85 = [84]");
debut("Pour entrer des lettres saisissez-les en MAJUSCULES ou utilisez les boutons ci-dessous :");
caracteres_speciaux("0","1","2","3","4","5","6","7","8","9","A","B","C","D","E","F");
quest("Entrez en hexadécimal le résultat du ET bit à bit entre les nombres hexadécimaux 8 et 8A :");
rep("8 ET 8A = [8]");
debut("Pour entrer des lettres saisissez-les en MAJUSCULES ou utilisez les boutons ci-dessous :");
caracteres_speciaux("0","1","2","3","4","5","6","7","8","9","A","B","C","D","E","F");
quest("Entrez en hexadécimal le résultat du ET bit à bit entre les nombres hexadécimaux 97 et DB :");
rep("97 ET DB = [93]");
debut("Pour entrer des lettres saisissez-les en MAJUSCULES ou utilisez les boutons ci-dessous :");
caracteres_speciaux("0","1","2","3","4","5","6","7","8","9","A","B","C","D","E","F");
quest("Entrez en hexadécimal le résultat du ET bit à bit entre les nombres hexadécimaux 96 et 2F :");
rep("96 ET 2F = [6]");
debut("Pour entrer des lettres saisissez-les en MAJUSCULES ou utilisez les boutons ci-dessous :");
caracteres_speciaux("0","1","2","3","4","5","6","7","8","9","A","B","C","D","E","F");
quest("Entrez en hexadécimal le résultat du ET bit à bit entre les nombres hexadécimaux 72 et 55 :");
rep("72 ET 55 = [50]");
debut("Pour entrer des lettres saisissez-les en MAJUSCULES ou utilisez les boutons ci-dessous :");
caracteres_speciaux("0","1","2","3","4","5","6","7","8","9","A","B","C","D","E","F");
quest("Entrez en hexadécimal le résultat du ET bit à bit entre les nombres hexadécimaux 67 et 8A :");
rep("67 ET 8A = [2]");
debut("Pour entrer des lettres saisissez-les en MAJUSCULES ou utilisez les boutons ci-dessous :");
caracteres_speciaux("0","1","2","3","4","5","6","7","8","9","A","B","C","D","E","F");
quest("Entrez en hexadécimal le résultat du ET bit à bit entre les nombres hexadécimaux 71 et DD :");
rep("71 ET DD = [51]");
debut("Pour entrer des lettres saisissez-les en MAJUSCULES ou utilisez les boutons ci-dessous :");
caracteres_speciaux("0","1","2","3","4","5","6","7","8","9","A","B","C","D","E","F");
quest("Entrez en hexadécimal le résultat du ET bit à bit entre les nombres hexadécimaux B2 et AE :");
rep("B2 ET AE = [A2]");
debut("Pour entrer des lettres saisissez-les en MAJUSCULES ou utilisez les boutons ci-dessous :");
caracteres_speciaux("0","1","2","3","4","5","6","7","8","9","A","B","C","D","E","F");
quest("Entrez en hexadécimal le résultat du ET bit à bit entre les nombres hexadécimaux 0 et AF :");
rep("0 ET AF = [0]");
debut("Pour entrer des lettres saisissez-les en MAJUSCULES ou utilisez les boutons ci-dessous :");
caracteres_speciaux("0","1","2","3","4","5","6","7","8","9","A","B","C","D","E","F");
Le OU bit à bit en binaire
Le programme suivant en Python génère un fichier texte contenant une opération sur chaque ligne :
import random
for i in range(10):
a=random.randint(0,255)
b=random.randint(0,255)
c=a|b
print(str(bin(a))+'ou'+str(bin(b))+'='+str(bin(c)))
Exemple de fichier généré :
0b11011111ou0b100101=0b11111111
0b10100110ou0b10100000=0b10100110
0b11111100ou0b10111010=0b11111110
0b11001100ou0b1=0b11001101
0b10100001ou0b101010=0b10101011
0b10111010ou0b11101010=0b11111010
0b10110101ou0b11000=0b10111101
0b10011110ou0b1001001=0b11011111
0b10111000ou0b11101101=0b11111101
0b1000ou0b111001=0b111001
Les expressions régulières suivantes permettent de convertir directement dans Dreamweaver le fichier texte généré par Python en fichier mis en forme au format des QCM.
Motif de recherche :
0b([0-1]{1,8})ou0b([0-1]{1,8})=0b([0-1]{1,8})
Motif de remplacement :
quest("Entrez en binaire le résultat du OU bit à bit entre les nombres binaires $1 et $2 :");
rep("$1 OU $2 = [$3]");
debut("Entrez votre résultat SANS saisir les zéros non significatifs sur les poids forts");
caracteres_speciaux("0","1");
Exemple de fichier QCM obtenu :
quest("Entrez en binaire le résultat du OU bit à bit entre les nombres binaires 11011111 et 100101 :");
rep("11011111 OU 100101 = [11111111]");
debut("Entrez votre résultat SANS saisir les zéros non significatifs sur les poids forts");
caracteres_speciaux("0","1");
quest("Entrez en binaire le résultat du OU bit à bit entre les nombres binaires 10100110 et 10100000 :");
rep("10100110 OU 10100000 = [10100110]");
debut("Entrez votre résultat SANS saisir les zéros non significatifs sur les poids forts");
caracteres_speciaux("0","1");
quest("Entrez en binaire le résultat du OU bit à bit entre les nombres binaires 11111100 et 10111010 :");
rep("11111100 OU 10111010 = [11111110]");
debut("Entrez votre résultat SANS saisir les zéros non significatifs sur les poids forts");
caracteres_speciaux("0","1");
quest("Entrez en binaire le résultat du OU bit à bit entre les nombres binaires 11001100 et 1 :");
rep("11001100 OU 1 = [11001101]");
debut("Entrez votre résultat SANS saisir les zéros non significatifs sur les poids forts");
caracteres_speciaux("0","1");
quest("Entrez en binaire le résultat du OU bit à bit entre les nombres binaires 10100001 et 101010 :");
rep("10100001 OU 101010 = [10101011]");
debut("Entrez votre résultat SANS saisir les zéros non significatifs sur les poids forts");
caracteres_speciaux("0","1");
quest("Entrez en binaire le résultat du OU bit à bit entre les nombres binaires 10111010 et 11101010 :");
rep("10111010 OU 11101010 = [11111010]");
debut("Entrez votre résultat SANS saisir les zéros non significatifs sur les poids forts");
caracteres_speciaux("0","1");
quest("Entrez en binaire le résultat du OU bit à bit entre les nombres binaires 10110101 et 11000 :");
rep("10110101 OU 11000 = [10111101]");
debut("Entrez votre résultat SANS saisir les zéros non significatifs sur les poids forts");
caracteres_speciaux("0","1");
quest("Entrez en binaire le résultat du OU bit à bit entre les nombres binaires 10011110 et 1001001 :");
rep("10011110 OU 1001001 = [11011111]");
debut("Entrez votre résultat SANS saisir les zéros non significatifs sur les poids forts");
caracteres_speciaux("0","1");
quest("Entrez en binaire le résultat du OU bit à bit entre les nombres binaires 10111000 et 11101101 :");
rep("10111000 OU 11101101 = [11111101]");
debut("Entrez votre résultat SANS saisir les zéros non significatifs sur les poids forts");
caracteres_speciaux("0","1");
quest("Entrez en binaire le résultat du OU bit à bit entre les nombres binaires 1000 et 111001 :");
rep("1000 OU 111001 = [111001]");
debut("Entrez votre résultat SANS saisir les zéros non significatifs sur les poids forts");
caracteres_speciaux("0","1");
Le OU bit à bit en hexadécimal
Le programme suivant en Python génère un fichier texte contenant une opération sur chaque ligne :
import random
for i in range(10):
a=random.randint(0,255)
b=random.randint(0,255)
c=a|b
print(str(hex(a)).upper()+'ou'+str(hex(b)).upper()+'='+str(hex(c)).upper())
Exemple de fichier généré :
0X9Dou0XAC=0XBD
0XB7ou0XA5=0XB7
0X56ou0XE3=0XF7
0X7Bou0X33=0X7B
0X3Cou0X4C=0X7C
0XB6ou0X4C=0XFE
0XBCou0X71=0XFD
0X78ou0XC4=0XFC
0X64ou0X6C=0X6C
0X8ou0X31=0X39
Les expressions régulières suivantes permettent de convertir directement dans Dreamweaver le fichier texte généré par Python en fichier mis en forme au format des QCM.
Motif de recherche :
0X([0-9,A-F]{1,2})ou0X([0-9,A-F]{1,2})=0X([0-9,A-F]{1,2})
Motif de remplacement :
quest("Entrez en hexadécimal le résultat du OU bit à bit entre les nombres hexadécimaux $1 et $2 :");
rep("$1 OU $2 = [$3]");
debut("Pour entrer des lettres saisissez-les en MAJUSCULES ou utilisez les boutons ci-dessous :");
caracteres_speciaux("0","1","2","3","4","5","6","7","8","9","A","B","C","D","E","F");
Exemple de fichier QCM obtenu :
quest("Entrez en hexadécimal le résultat du OU bit à bit entre les nombres hexadécimaux 9D et AC :");
rep("9D OU AC = [BD]");
debut("Pour entrer des lettres saisissez-les en MAJUSCULES ou utilisez les boutons ci-dessous :");
caracteres_speciaux("0","1","2","3","4","5","6","7","8","9","A","B","C","D","E","F");
quest("Entrez en hexadécimal le résultat du OU bit à bit entre les nombres hexadécimaux B7 et A5 :");
rep("B7 OU A5 = [B7]");
debut("Pour entrer des lettres saisissez-les en MAJUSCULES ou utilisez les boutons ci-dessous :");
caracteres_speciaux("0","1","2","3","4","5","6","7","8","9","A","B","C","D","E","F");
quest("Entrez en hexadécimal le résultat du OU bit à bit entre les nombres hexadécimaux 56 et E3 :");
rep("56 OU E3 = [F7]");
debut("Pour entrer des lettres saisissez-les en MAJUSCULES ou utilisez les boutons ci-dessous :");
caracteres_speciaux("0","1","2","3","4","5","6","7","8","9","A","B","C","D","E","F");
quest("Entrez en hexadécimal le résultat du OU bit à bit entre les nombres hexadécimaux 7B et 33 :");
rep("7B OU 33 = [7B]");
debut("Pour entrer des lettres saisissez-les en MAJUSCULES ou utilisez les boutons ci-dessous :");
caracteres_speciaux("0","1","2","3","4","5","6","7","8","9","A","B","C","D","E","F");
quest("Entrez en hexadécimal le résultat du OU bit à bit entre les nombres hexadécimaux 3C et 4C :");
rep("3C OU 4C = [7C]");
debut("Pour entrer des lettres saisissez-les en MAJUSCULES ou utilisez les boutons ci-dessous :");
caracteres_speciaux("0","1","2","3","4","5","6","7","8","9","A","B","C","D","E","F");
quest("Entrez en hexadécimal le résultat du OU bit à bit entre les nombres hexadécimaux B6 et 4C :");
rep("B6 OU 4C = [FE]");
debut("Pour entrer des lettres saisissez-les en MAJUSCULES ou utilisez les boutons ci-dessous :");
caracteres_speciaux("0","1","2","3","4","5","6","7","8","9","A","B","C","D","E","F");
quest("Entrez en hexadécimal le résultat du OU bit à bit entre les nombres hexadécimaux BC et 71 :");
rep("BC OU 71 = [FD]");
debut("Pour entrer des lettres saisissez-les en MAJUSCULES ou utilisez les boutons ci-dessous :");
caracteres_speciaux("0","1","2","3","4","5","6","7","8","9","A","B","C","D","E","F");
quest("Entrez en hexadécimal le résultat du OU bit à bit entre les nombres hexadécimaux 78 et C4 :");
rep("78 OU C4 = [FC]");
debut("Pour entrer des lettres saisissez-les en MAJUSCULES ou utilisez les boutons ci-dessous :");
caracteres_speciaux("0","1","2","3","4","5","6","7","8","9","A","B","C","D","E","F");
quest("Entrez en hexadécimal le résultat du OU bit à bit entre les nombres hexadécimaux 64 et 6C :");
rep("64 OU 6C = [6C]");
debut("Pour entrer des lettres saisissez-les en MAJUSCULES ou utilisez les boutons ci-dessous :");
caracteres_speciaux("0","1","2","3","4","5","6","7","8","9","A","B","C","D","E","F");
quest("Entrez en hexadécimal le résultat du OU bit à bit entre les nombres hexadécimaux 8 et 31 :");
rep("8 OU 31 = [39]");
debut("Pour entrer des lettres saisissez-les en MAJUSCULES ou utilisez les boutons ci-dessous :");
caracteres_speciaux("0","1","2","3","4","5","6","7","8","9","A","B","C","D","E","F");
Le OU-Exclusif bit à bit en binaire
Le programme suivant en Python génère un fichier texte contenant une opération sur chaque ligne :
import random
for i in range(10):
a=random.randint(0,255)
b=random.randint(0,255)
c=a^b
print(str(bin(a))+'xor'+str(bin(b))+'='+str(bin(c)))
Exemple de fichier généré :
0b10111001xor0b10100111=0b11110
0b10110101xor0b10010101=0b100000
0b11111xor0b10001001=0b10010110
0b11000011xor0b10001101=0b1001110
0b10000000xor0b111000=0b10111000
0b1001011xor0b1010110=0b11101
0b1001101xor0b1001=0b1000100
0b1101001xor0b11010111=0b10111110
0b1110001xor0b11000100=0b10110101
0b1111001xor0b10010011=0b11101010
Les expressions régulières suivantes permettent de convertir directement dans Dreamweaver le fichier texte généré par Python en fichier mis en forme au format des QCM.
Motif de recherche :
0b([0-1]{1,8})xor0b([0-1]{1,8})=0b([0-1]{1,8})
Motif de remplacement :
quest("Entrez en binaire le résultat du OU-Exclusif bit à bit entre les nombres binaires $1 et $2 :");
rep("$1 XOR $2 = [$3]");
debut("Entrez votre résultat SANS saisir les zéros non significatifs sur les poids forts");
caracteres_speciaux("0","1");
Exemple de fichier QCM obtenu :
quest("Entrez en binaire le résultat du OU-Exclusif bit à bit entre les nombres binaires 10111001 et 10100111 :");
rep("10111001 XOR 10100111 = [11110]");
debut("Entrez votre résultat SANS saisir les zéros non significatifs sur les poids forts");
caracteres_speciaux("0","1");
quest("Entrez en binaire le résultat du OU-Exclusif bit à bit entre les nombres binaires 10110101 et 10010101 :");
rep("10110101 XOR 10010101 = [100000]");
debut("Entrez votre résultat SANS saisir les zéros non significatifs sur les poids forts");
caracteres_speciaux("0","1");
quest("Entrez en binaire le résultat du OU-Exclusif bit à bit entre les nombres binaires 11111 et 10001001 :");
rep("11111 XOR 10001001 = [10010110]");
debut("Entrez votre résultat SANS saisir les zéros non significatifs sur les poids forts");
caracteres_speciaux("0","1");
quest("Entrez en binaire le résultat du OU-Exclusif bit à bit entre les nombres binaires 11000011 et 10001101 :");
rep("11000011 XOR 10001101 = [1001110]");
debut("Entrez votre résultat SANS saisir les zéros non significatifs sur les poids forts");
caracteres_speciaux("0","1");
quest("Entrez en binaire le résultat du OU-Exclusif bit à bit entre les nombres binaires 10000000 et 111000 :");
rep("10000000 XOR 111000 = [10111000]");
debut("Entrez votre résultat SANS saisir les zéros non significatifs sur les poids forts");
caracteres_speciaux("0","1");
quest("Entrez en binaire le résultat du OU-Exclusif bit à bit entre les nombres binaires 1001011 et 1010110 :");
rep("1001011 XOR 1010110 = [11101]");
debut("Entrez votre résultat SANS saisir les zéros non significatifs sur les poids forts");
caracteres_speciaux("0","1");
quest("Entrez en binaire le résultat du OU-Exclusif bit à bit entre les nombres binaires 1001101 et 1001 :");
rep("1001101 XOR 1001 = [1000100]");
debut("Entrez votre résultat SANS saisir les zéros non significatifs sur les poids forts");
caracteres_speciaux("0","1");
quest("Entrez en binaire le résultat du OU-Exclusif bit à bit entre les nombres binaires 1101001 et 11010111 :");
rep("1101001 XOR 11010111 = [10111110]");
debut("Entrez votre résultat SANS saisir les zéros non significatifs sur les poids forts");
caracteres_speciaux("0","1");
quest("Entrez en binaire le résultat du OU-Exclusif bit à bit entre les nombres binaires 1110001 et 11000100 :");
rep("1110001 XOR 11000100 = [10110101]");
debut("Entrez votre résultat SANS saisir les zéros non significatifs sur les poids forts");
caracteres_speciaux("0","1");
quest("Entrez en binaire le résultat du OU-Exclusif bit à bit entre les nombres binaires 1111001 et 10010011 :");
rep("1111001 XOR 10010011 = [11101010]");
debut("Entrez votre résultat SANS saisir les zéros non significatifs sur les poids forts");
caracteres_speciaux("0","1");
Le OU-Exclusif bit à bit en hexadécimal
Le programme suivant en Python génère un fichier texte contenant une opération sur chaque ligne :
import random
for i in range(10):
a=random.randint(0,255)
b=random.randint(0,255)
c=a^b
print(str(hex(a)).upper()+'xor'+str(hex(b)).upper()+'='+str(hex(c)).upper())
Exemple de fichier généré :
0XA1xor0XE0=0X41
0X75xor0XF6=0X83
0X58xor0X69=0X31
0X8Cxor0XC7=0X4B
0XBAxor0X74=0XCE
0XB2xor0XDC=0X6E
0X69xor0XBA=0XD3
0XC1xor0X24=0XE5
0X5Fxor0XB=0X54
0XB7xor0X56=0XE1
Les expressions régulières suivantes permettent de convertir directement dans Dreamweaver le fichier texte généré par Python en fichier mis en forme au format des QCM.
Motif de recherche :
0X([0-9,A-F]{1,2})xor0X([0-9,A-F]{1,2})=0X([0-9,A-F]{1,2})
Motif de remplacement :
quest("Entrez en hexadécimal le résultat du OU-Exclusif bit à bit entre les nombres hexadécimaux $1 et $2 :");
rep("$1 XOR $2 = [$3]");
debut("Pour entrer des lettres saisissez-les en MAJUSCULES ou utilisez les boutons ci-dessous :");
caracteres_speciaux("0","1","2","3","4","5","6","7","8","9","A","B","C","D","E","F");
Exemple de fichier QCM obtenu :
quest("Entrez en hexadécimal le résultat du OU-Exclusif bit à bit entre les nombres hexadécimaux A1 et E0 :");
rep("A1 XOR E0 = [41]");
debut("Pour entrer des lettres saisissez-les en MAJUSCULES ou utilisez les boutons ci-dessous :");
caracteres_speciaux("0","1","2","3","4","5","6","7","8","9","A","B","C","D","E","F");
quest("Entrez en hexadécimal le résultat du OU-Exclusif bit à bit entre les nombres hexadécimaux 75 et F6 :");
rep("75 XOR F6 = [83]");
debut("Pour entrer des lettres saisissez-les en MAJUSCULES ou utilisez les boutons ci-dessous :");
caracteres_speciaux("0","1","2","3","4","5","6","7","8","9","A","B","C","D","E","F");
quest("Entrez en hexadécimal le résultat du OU-Exclusif bit à bit entre les nombres hexadécimaux 58 et 69 :");
rep("58 XOR 69 = [31]");
debut("Pour entrer des lettres saisissez-les en MAJUSCULES ou utilisez les boutons ci-dessous :");
caracteres_speciaux("0","1","2","3","4","5","6","7","8","9","A","B","C","D","E","F");
quest("Entrez en hexadécimal le résultat du OU-Exclusif bit à bit entre les nombres hexadécimaux 8C et C7 :");
rep("8C XOR C7 = [4B]");
debut("Pour entrer des lettres saisissez-les en MAJUSCULES ou utilisez les boutons ci-dessous :");
caracteres_speciaux("0","1","2","3","4","5","6","7","8","9","A","B","C","D","E","F");
quest("Entrez en hexadécimal le résultat du OU-Exclusif bit à bit entre les nombres hexadécimaux BA et 74 :");
rep("BA XOR 74 = [CE]");
debut("Pour entrer des lettres saisissez-les en MAJUSCULES ou utilisez les boutons ci-dessous :");
caracteres_speciaux("0","1","2","3","4","5","6","7","8","9","A","B","C","D","E","F");
quest("Entrez en hexadécimal le résultat du OU-Exclusif bit à bit entre les nombres hexadécimaux B2 et DC :");
rep("B2 XOR DC = [6E]");
debut("Pour entrer des lettres saisissez-les en MAJUSCULES ou utilisez les boutons ci-dessous :");
caracteres_speciaux("0","1","2","3","4","5","6","7","8","9","A","B","C","D","E","F");
quest("Entrez en hexadécimal le résultat du OU-Exclusif bit à bit entre les nombres hexadécimaux 69 et BA :");
rep("69 XOR BA = [D3]");
debut("Pour entrer des lettres saisissez-les en MAJUSCULES ou utilisez les boutons ci-dessous :");
caracteres_speciaux("0","1","2","3","4","5","6","7","8","9","A","B","C","D","E","F");
quest("Entrez en hexadécimal le résultat du OU-Exclusif bit à bit entre les nombres hexadécimaux C1 et 24 :");
rep("C1 XOR 24 = [E5]");
debut("Pour entrer des lettres saisissez-les en MAJUSCULES ou utilisez les boutons ci-dessous :");
caracteres_speciaux("0","1","2","3","4","5","6","7","8","9","A","B","C","D","E","F");
quest("Entrez en hexadécimal le résultat du OU-Exclusif bit à bit entre les nombres hexadécimaux 5F et B :");
rep("5F XOR B = [54]");
debut("Pour entrer des lettres saisissez-les en MAJUSCULES ou utilisez les boutons ci-dessous :");
caracteres_speciaux("0","1","2","3","4","5","6","7","8","9","A","B","C","D","E","F");
quest("Entrez en hexadécimal le résultat du OU-Exclusif bit à bit entre les nombres hexadécimaux B7 et 56 :");
rep("B7 XOR 56 = [E1]");
debut("Pour entrer des lettres saisissez-les en MAJUSCULES ou utilisez les boutons ci-dessous :");
caracteres_speciaux("0","1","2","3","4","5","6","7","8","9","A","B","C","D","E","F");
Les opérateurs bit à bit sur un seul quartet
Le programme suivant en Python génère un fichier texte contenant une opération sur chaque ligne :
import random
for i in range(3,12):
for j in range(12,16):
c=i^j
print(str(hex(i)).upper()+':'+str(hex(j)).upper()+'='+str(hex(c)).upper())
Dans ce programme, i varit de 3 à 11 (sans atteindre 12), j varit de 12 à 15 (sans atteindre 16), et le séparateur représentant l'opérateur entre les deux nombres dans le fichier généré est le caractère deux points (ce qui permet d'utiliser la même expression régulière quelque soit l'opération effectuée).
Exemple de fichier généré :
0X3:0XC=0XF
0X3:0XD=0XE
0X3:0XE=0XD
0X3:0XF=0XC
0X4:0XC=0X8
0X4:0XD=0X9
0X4:0XE=0XA
0X4:0XF=0XB
0X5:0XC=0X9
0X5:0XD=0X8
0X5:0XE=0XB
0X5:0XF=0XA
0X6:0XC=0XA
0X6:0XD=0XB
0X6:0XE=0X8
0X6:0XF=0X9
0X7:0XC=0XB
0X7:0XD=0XA
0X7:0XE=0X9
0X7:0XF=0X8
0X8:0XC=0X4
0X8:0XD=0X5
0X8:0XE=0X6
0X8:0XF=0X7
0X9:0XC=0X5
0X9:0XD=0X4
0X9:0XE=0X7
0X9:0XF=0X6
0XA:0XC=0X6
0XA:0XD=0X7
0XA:0XE=0X4
0XA:0XF=0X5
0XB:0XC=0X7
0XB:0XD=0X6
0XB:0XE=0X5
0XB:0XF=0X4
Les expressions régulières suivantes permettent de convertir directement dans Dreamweaver le fichier texte généré par Python en fichier mis en forme au format des QCM.
Motif de recherche :
0X([0-9,A-F]{1}):0X([0-9,A-F]{1})=0X([0-9,A-F]{1})
Motif de remplacement :
quest("Entrez en hexadécimal le résultat du OU-Exclusif bit à bit entre les nombres hexadécimaux $1 et $2 :");
rep("$1 XOR $2 = [$3]");
debut("Pour entrer des lettres saisissez-les en MAJUSCULES ou utilisez les boutons ci-dessous :");
caracteres_speciaux("0","1","2","3","4","5","6","7","8","9","A","B","C","D","E","F");
Cet exemple peut être modifié pour générer un QCM sur un seul quartet utilisant l'opérateur bit à bit OU, ET, ou OU-Exclusif en binaire comme en hexadécimal (6 possibilités au total). En configurant l'interval des valeurs entre 0 et 15 pour i comme pour j (avec range(0,16) dans le programme en Python), chacun des 6 cas donnera les 256 possibilité, soit 1536 questions au total.
Attention : pour les opérateurs logiques bit à bit en binaire les nombres auront entre 1 et 4 chiffres, et non forcément 1 seul comme en hexadécimal. Voici un exemple d'expressions régulières pour les opérateurs logiques sur 4 bits :
Motif de recherche :
0b([0-1]{1,4}):0b([0-1]{1,4})=0b([0-1]{1,4})
Motif de remplacement :
quest("Entrez en binaire le résultat du ET bit à bit entre les nombres binaires $1 et $2 :");
rep("$1 AND $2 = [$3]");
debut("Entrez votre résultat SANS saisir les zéros non significatifs sur les poids forts");
caracteres_speciaux("0","1");
Le décalage à gauche en hexadécimal
Le programme suivant en Python génère un fichier texte contenant une opération sur chaque ligne :
import random
for i in range(10):
a=random.randint(0,63)
b=a << 2
print(str(hex(a)).upper()+'donne'+str(hex(b)).upper())
Exemple de fichier généré :
0X13donne0X4C
0X30donne0XC0
0X2Bdonne0XAC
0X1Fdonne0X7C
0X19donne0X64
0XFdonne0X3C
0X1donne0X4
0X38donne0XE0
0X2Adonne0XA8
0X25donne0X94
Les expressions régulières suivantes permettent de convertir directement dans Dreamweaver le fichier texte généré par Python en fichier mis en forme au format des QCM.
Motif de recherche :
0X([0-9,A-F]{1,2})donne0X([0-9,A-F]{1,2})
Motif de remplacement :
quest("Que devient le nombre hexadécimal $1 après un décalage à gauche de 2 bits ?");
rep("Entrez votre réponse en hexadécimal : [$2]");
debut("Pour entrer des lettres saisissez-les en MAJUSCULES ou utilisez les boutons ci-dessous :");
caracteres_speciaux("0","1","2","3","4","5","6","7","8","9","A","B","C","D","E","F");
Exemple de fichier QCM obtenu :
quest("Que devient le nombre hexadécimal 13 après un décalage à gauche de 2 bits ?");
rep("Entrez votre réponse en hexadécimal : [4C]");
debut("Pour entrer des lettres saisissez-les en MAJUSCULES ou utilisez les boutons ci-dessous :");
caracteres_speciaux("0","1","2","3","4","5","6","7","8","9","A","B","C","D","E","F");
quest("Que devient le nombre hexadécimal 30 après un décalage à gauche de 2 bits ?");
rep("Entrez votre réponse en hexadécimal : [C0]");
debut("Pour entrer des lettres saisissez-les en MAJUSCULES ou utilisez les boutons ci-dessous :");
caracteres_speciaux("0","1","2","3","4","5","6","7","8","9","A","B","C","D","E","F");
quest("Que devient le nombre hexadécimal 2B après un décalage à gauche de 2 bits ?");
rep("Entrez votre réponse en hexadécimal : [AC]");
debut("Pour entrer des lettres saisissez-les en MAJUSCULES ou utilisez les boutons ci-dessous :");
caracteres_speciaux("0","1","2","3","4","5","6","7","8","9","A","B","C","D","E","F");
quest("Que devient le nombre hexadécimal 1F après un décalage à gauche de 2 bits ?");
rep("Entrez votre réponse en hexadécimal : [7C]");
debut("Pour entrer des lettres saisissez-les en MAJUSCULES ou utilisez les boutons ci-dessous :");
caracteres_speciaux("0","1","2","3","4","5","6","7","8","9","A","B","C","D","E","F");
quest("Que devient le nombre hexadécimal 19 après un décalage à gauche de 2 bits ?");
rep("Entrez votre réponse en hexadécimal : [64]");
debut("Pour entrer des lettres saisissez-les en MAJUSCULES ou utilisez les boutons ci-dessous :");
caracteres_speciaux("0","1","2","3","4","5","6","7","8","9","A","B","C","D","E","F");
quest("Que devient le nombre hexadécimal F après un décalage à gauche de 2 bits ?");
rep("Entrez votre réponse en hexadécimal : [3C]");
debut("Pour entrer des lettres saisissez-les en MAJUSCULES ou utilisez les boutons ci-dessous :");
caracteres_speciaux("0","1","2","3","4","5","6","7","8","9","A","B","C","D","E","F");
quest("Que devient le nombre hexadécimal 1 après un décalage à gauche de 2 bits ?");
rep("Entrez votre réponse en hexadécimal : [4]");
debut("Pour entrer des lettres saisissez-les en MAJUSCULES ou utilisez les boutons ci-dessous :");
caracteres_speciaux("0","1","2","3","4","5","6","7","8","9","A","B","C","D","E","F");
quest("Que devient le nombre hexadécimal 38 après un décalage à gauche de 2 bits ?");
rep("Entrez votre réponse en hexadécimal : [E0]");
debut("Pour entrer des lettres saisissez-les en MAJUSCULES ou utilisez les boutons ci-dessous :");
caracteres_speciaux("0","1","2","3","4","5","6","7","8","9","A","B","C","D","E","F");
quest("Que devient le nombre hexadécimal 2A après un décalage à gauche de 2 bits ?");
rep("Entrez votre réponse en hexadécimal : [A8]");
debut("Pour entrer des lettres saisissez-les en MAJUSCULES ou utilisez les boutons ci-dessous :");
caracteres_speciaux("0","1","2","3","4","5","6","7","8","9","A","B","C","D","E","F");
quest("Que devient le nombre hexadécimal 25 après un décalage à gauche de 2 bits ?");
rep("Entrez votre réponse en hexadécimal : [94]");
debut("Pour entrer des lettres saisissez-les en MAJUSCULES ou utilisez les boutons ci-dessous :");
caracteres_speciaux("0","1","2","3","4","5","6","7","8","9","A","B","C","D","E","F");
Autre motif de mise en forme en utilisant le même motif de recherche et le même fichier texte généré par Python :
quest("Quelle opération faut-il effectuer sur le nombre hexadécimal $1 pour obtenir le nombre hexadécimal $2 ?");
rep("[x] Un décalage à gauche");
rep("[ ] Un décalage à droite");
rep("[ ] d'1 bit");
rep("[x] de 2 bits");
rep("[ ] de 3 bits");
debut("Cochez 2 cases parmi les 5");
Le décalage à droite en hexadécimal
Le programme suivant en Python génère un fichier texte contenant une opération sur chaque ligne :
import random
for i in range(10):
a=random.randint(0,255)
b=a >> 2
print(str(hex(a)).upper()+'donne'+str(hex(b)).upper())
Exemple de fichier généré :
0XDDdonne0X37
0X5Fdonne0X17
0XDdonne0X3
0X2Adonne0XA
0X35donne0XD
0X9donne0X2
0XF2donne0X3C
0XC3donne0X30
0XBCdonne0X2F
0X2Cdonne0XB
Les expressions régulières suivantes permettent de convertir directement dans Dreamweaver le fichier texte généré par Python en fichier mis en forme au format des QCM.
Motif de recherche :
0X([0-9,A-F]{1,2})donne0X([0-9,A-F]{1,2})
Motif de remplacement :
quest("Que devient le nombre hexadécimal $1 après un décalage à droite de 2 bits ?");
rep("Entrez votre réponse en hexadécimal : [$2]");
debut("Pour entrer des lettres saisissez-les en MAJUSCULES ou utilisez les boutons ci-dessous :");
caracteres_speciaux("0","1","2","3","4","5","6","7","8","9","A","B","C","D","E","F");
Exemple de fichier QCM obtenu :
quest("Que devient le nombre hexadécimal DD après un décalage à droite de 2 bits ?");
rep("Entrez votre réponse en hexadécimal : [37]");
debut("Pour entrer des lettres saisissez-les en MAJUSCULES ou utilisez les boutons ci-dessous :");
caracteres_speciaux("0","1","2","3","4","5","6","7","8","9","A","B","C","D","E","F");
quest("Que devient le nombre hexadécimal 5F après un décalage à droite de 2 bits ?");
rep("Entrez votre réponse en hexadécimal : [17]");
debut("Pour entrer des lettres saisissez-les en MAJUSCULES ou utilisez les boutons ci-dessous :");
caracteres_speciaux("0","1","2","3","4","5","6","7","8","9","A","B","C","D","E","F");
quest("Que devient le nombre hexadécimal D après un décalage à droite de 2 bits ?");
rep("Entrez votre réponse en hexadécimal : [3]");
debut("Pour entrer des lettres saisissez-les en MAJUSCULES ou utilisez les boutons ci-dessous :");
caracteres_speciaux("0","1","2","3","4","5","6","7","8","9","A","B","C","D","E","F");
quest("Que devient le nombre hexadécimal 2A après un décalage à droite de 2 bits ?");
rep("Entrez votre réponse en hexadécimal : [A]");
debut("Pour entrer des lettres saisissez-les en MAJUSCULES ou utilisez les boutons ci-dessous :");
caracteres_speciaux("0","1","2","3","4","5","6","7","8","9","A","B","C","D","E","F");
quest("Que devient le nombre hexadécimal 35 après un décalage à droite de 2 bits ?");
rep("Entrez votre réponse en hexadécimal : [D]");
debut("Pour entrer des lettres saisissez-les en MAJUSCULES ou utilisez les boutons ci-dessous :");
caracteres_speciaux("0","1","2","3","4","5","6","7","8","9","A","B","C","D","E","F");
quest("Que devient le nombre hexadécimal 9 après un décalage à droite de 2 bits ?");
rep("Entrez votre réponse en hexadécimal : [2]");
debut("Pour entrer des lettres saisissez-les en MAJUSCULES ou utilisez les boutons ci-dessous :");
caracteres_speciaux("0","1","2","3","4","5","6","7","8","9","A","B","C","D","E","F");
quest("Que devient le nombre hexadécimal F2 après un décalage à droite de 2 bits ?");
rep("Entrez votre réponse en hexadécimal : [3C]");
debut("Pour entrer des lettres saisissez-les en MAJUSCULES ou utilisez les boutons ci-dessous :");
caracteres_speciaux("0","1","2","3","4","5","6","7","8","9","A","B","C","D","E","F");
quest("Que devient le nombre hexadécimal C3 après un décalage à droite de 2 bits ?");
rep("Entrez votre réponse en hexadécimal : [30]");
debut("Pour entrer des lettres saisissez-les en MAJUSCULES ou utilisez les boutons ci-dessous :");
caracteres_speciaux("0","1","2","3","4","5","6","7","8","9","A","B","C","D","E","F");
quest("Que devient le nombre hexadécimal BC après un décalage à droite de 2 bits ?");
rep("Entrez votre réponse en hexadécimal : [2F]");
debut("Pour entrer des lettres saisissez-les en MAJUSCULES ou utilisez les boutons ci-dessous :");
caracteres_speciaux("0","1","2","3","4","5","6","7","8","9","A","B","C","D","E","F");
quest("Que devient le nombre hexadécimal 2C après un décalage à droite de 2 bits ?");
rep("Entrez votre réponse en hexadécimal : [B]");
debut("Pour entrer des lettres saisissez-les en MAJUSCULES ou utilisez les boutons ci-dessous :");
caracteres_speciaux("0","1","2","3","4","5","6","7","8","9","A","B","C","D","E","F");
La conversion Décimal/Hexadécimal et Hexadécimal/Décimal
Le programme suivant en Python génère un fichier texte contenant une correspondance décimal;hexadécimal sur chaque ligne :
import random
for i in range(1,31):
print(str(i)+';'+str(hex(i)).upper())
for i in range(5,11):
n=2**i
print(str(n)+';'+str(hex(n)).upper())
print(str(n-1)+';'+str(hex(n-1)).upper())
print(str(n+1)+';'+str(hex(n+1)).upper())
for i in [34, 48, 80, 96, 112, 144, 272]:
print(str(i)+';'+str(hex(i)).upper())
Fichier généré :
1;0X1
2;0X2
3;0X3
4;0X4
5;0X5
6;0X6
7;0X7
8;0X8
9;0X9
10;0XA
11;0XB
12;0XC
13;0XD
14;0XE
15;0XF
16;0X10
17;0X11
18;0X12
19;0X13
20;0X14
21;0X15
22;0X16
23;0X17
24;0X18
25;0X19
26;0X1A
27;0X1B
28;0X1C
29;0X1D
30;0X1E
32;0X20
31;0X1F
33;0X21
64;0X40
63;0X3F
65;0X41
128;0X80
127;0X7F
129;0X81
256;0X100
255;0XFF
257;0X101
512;0X200
511;0X1FF
513;0X201
1024;0X400
1023;0X3FF
1025;0X401
34;0X22
48;0X30
80;0X50
96;0X60
112;0X70
144;0X90
272;0X110
Les expressions régulières suivantes permettent de convertir directement dans Dreamweaver le fichier texte généré par Python en fichier mis en forme au format des QCM.
Motif de recherche :
(\d+);0X([0-9,A-F]{1,4})
Motif de remplacement :
quest("Comment s'écrit en hexadécimal le nombre décimal $1 ?");
rep("$1<sub>(10)</sub> = [$2]<sub>(16)</sub>");
debut("Pour entrer des lettres saisissez-les en MAJUSCULES ou utilisez les boutons ci-dessous :");
caracteres_speciaux("0","1","2","3","4","5","6","7","8","9","A","B","C","D","E","F");
quest("Comment s'écrit en décimal le nombre hexadécimal $2 ?");
rep("$2<sub>(16)</sub> = [$1]<sub>(10)</sub>");
debut("Vous pouvez entrer les chiffres au clavier ou utiliser les boutons ci-dessous :");
caracteres_speciaux("0","1","2","3","4","5","6","7","8","9");
Exemple de fichier QCM obtenu :
quest("Comment s'écrit en hexadécimal le nombre décimal 17 ?");
rep("17<sub>(10)</sub> = [11]<sub>(16)</sub>");
debut("Pour entrer des lettres saisissez-les en MAJUSCULES ou utilisez les boutons ci-dessous :");
caracteres_speciaux("0","1","2","3","4","5","6","7","8","9","A","B","C","D","E","F");
quest("Comment s'écrit en décimal le nombre hexadécimal 11 ?");
rep("11<sub>(16)</sub> = [17]<sub>(10)</sub>");
debut("Vous pouvez entrer les chiffres au clavier ou utiliser les boutons ci-dessous :");
caracteres_speciaux("0","1","2","3","4","5","6","7","8","9");
quest("Comment s'écrit en hexadécimal le nombre décimal 18 ?");
rep("18<sub>(10)</sub> = [12]<sub>(16)</sub>");
debut("Pour entrer des lettres saisissez-les en MAJUSCULES ou utilisez les boutons ci-dessous :");
caracteres_speciaux("0","1","2","3","4","5","6","7","8","9","A","B","C","D","E","F");
quest("Comment s'écrit en décimal le nombre hexadécimal 12 ?");
rep("12<sub>(16)</sub> = [18]<sub>(10)</sub>");
debut("Vous pouvez entrer les chiffres au clavier ou utiliser les boutons ci-dessous :");
caracteres_speciaux("0","1","2","3","4","5","6","7","8","9");
quest("Comment s'écrit en hexadécimal le nombre décimal 19 ?");
rep("19<sub>(10)</sub> = [13]<sub>(16)</sub>");
debut("Pour entrer des lettres saisissez-les en MAJUSCULES ou utilisez les boutons ci-dessous :");
caracteres_speciaux("0","1","2","3","4","5","6","7","8","9","A","B","C","D","E","F");
quest("Comment s'écrit en décimal le nombre hexadécimal 13 ?");
rep("13<sub>(16)</sub> = [19]<sub>(10)</sub>");
debut("Vous pouvez entrer les chiffres au clavier ou utiliser les boutons ci-dessous :");
caracteres_speciaux("0","1","2","3","4","5","6","7","8","9");
quest("Comment s'écrit en hexadécimal le nombre décimal 20 ?");
rep("20<sub>(10)</sub> = [14]<sub>(16)</sub>");
debut("Pour entrer des lettres saisissez-les en MAJUSCULES ou utilisez les boutons ci-dessous :");
caracteres_speciaux("0","1","2","3","4","5","6","7","8","9","A","B","C","D","E","F");
quest("Comment s'écrit en décimal le nombre hexadécimal 14 ?");
rep("14<sub>(16)</sub> = [20]<sub>(10)</sub>");
La conversion Décimal/Binaire et Binaire/Décimal
Le programme suivant en Python génère un fichier texte contenant une correspondance décimal;binaire sur chaque ligne :
for i in range(1,31):
print(str(i)+';'+str(bin(i)))
for i in range(5,11):
n=2**i
print(str(n)+';'+str(bin(n)))
print(str(n-1)+';'+str(bin(n-1)))
print(str(n+1)+';'+str(bin(n+1)))
print(str(n+2)+';'+str(bin(n+2)))
print(str(n+4)+';'+str(bin(n+4)))
print(str(n+8)+';'+str(bin(n+8)))
for i in [48, 80, 96, 112, 144, 272]:
print(str(i)+';'+str(bin(i)))
Fichier généré :
1;0b1
2;0b10
3;0b11
4;0b100
5;0b101
6;0b110
7;0b111
8;0b1000
9;0b1001
10;0b1010
11;0b1011
12;0b1100
13;0b1101
14;0b1110
15;0b1111
16;0b10000
17;0b10001
18;0b10010
19;0b10011
20;0b10100
21;0b10101
22;0b10110
23;0b10111
24;0b11000
25;0b11001
26;0b11010
27;0b11011
28;0b11100
29;0b11101
30;0b11110
32;0b100000
31;0b11111
33;0b100001
34;0b100010
36;0b100100
40;0b101000
64;0b1000000
63;0b111111
65;0b1000001
66;0b1000010
68;0b1000100
72;0b1001000
128;0b10000000
127;0b1111111
129;0b10000001
130;0b10000010
132;0b10000100
136;0b10001000
256;0b100000000
255;0b11111111
257;0b100000001
258;0b100000010
260;0b100000100
264;0b100001000
512;0b1000000000
511;0b111111111
513;0b1000000001
514;0b1000000010
516;0b1000000100
520;0b1000001000
1024;0b10000000000
1023;0b1111111111
1025;0b10000000001
1026;0b10000000010
1028;0b10000000100
1032;0b10000001000
48;0b110000
80;0b1010000
96;0b1100000
112;0b1110000
144;0b10010000
272;0b100010000
Les expressions régulières suivantes permettent de convertir directement dans Dreamweaver le fichier texte généré par Python en fichier mis en forme au format des QCM.
Motif de recherche :
(\d+);0b([0-1]+)
Motif de remplacement :
quest("Comment s'écrit en binaire le nombre décimal $1 ?");
rep("$1<sub>(10)</sub> = [$2]<sub>(2)</sub>");
debut("Vous pouvez entrer les chiffres au clavier ou utiliser les boutons ci-dessous :");
caracteres_speciaux("0","1");
quest("Comment s'écrit en décimal le nombre binaire $2 ?");
rep("$2<sub>(2)</sub> = [$1]<sub>(10)</sub>");
debut("Vous pouvez entrer les chiffres au clavier ou utiliser les boutons ci-dessous :");
caracteres_speciaux("0","1","2","3","4","5","6","7","8","9");
Exemple de fichier QCM obtenu :
quest("Comment s'écrit en binaire le nombre décimal 18 ?");
rep("18<sub>(10)</sub> = [10010]<sub>(2)</sub>");
debut("Vous pouvez entrer les chiffres au clavier ou utiliser les boutons ci-dessous :");
caracteres_speciaux("0","1");
quest("Comment s'écrit en décimal le nombre binaire 10010 ?");
rep("10010<sub>(2)</sub> = [18]<sub>(10)</sub>");
debut("Vous pouvez entrer les chiffres au clavier ou utiliser les boutons ci-dessous :");
caracteres_speciaux("0","1","2","3","4","5","6","7","8","9");
quest("Comment s'écrit en binaire le nombre décimal 19 ?");
rep("19<sub>(10)</sub> = [10011]<sub>(2)</sub>");
debut("Vous pouvez entrer les chiffres au clavier ou utiliser les boutons ci-dessous :");
caracteres_speciaux("0","1");
quest("Comment s'écrit en décimal le nombre binaire 10011 ?");
rep("10011<sub>(2)</sub> = [19]<sub>(10)</sub>");
debut("Vous pouvez entrer les chiffres au clavier ou utiliser les boutons ci-dessous :");
caracteres_speciaux("0","1","2","3","4","5","6","7","8","9");
quest("Comment s'écrit en binaire le nombre décimal 20 ?");
rep("20<sub>(10)</sub> = [10100]<sub>(2)</sub>");
debut("Vous pouvez entrer les chiffres au clavier ou utiliser les boutons ci-dessous :");
caracteres_speciaux("0","1");
Comparaison de nombres dans deux bases différentes
Le programme suivant en Python génère 80 lignes au format X;0xY avec X (en décimal) < Y (en hexadécimal) :
for i in range(21,41):
print(str(i)+';'+str(hex(i+5)).upper())
for i in range(41,61):
print(str(i)+';'+str(hex(i+23)).upper())
for i in range(61,81):
print(str(i)+';'+str(hex(i+39)).upper())
for i in range(81,101):
print(str(i)+';'+str(hex(i+10)).upper())
Le programme suivant en Python génère 80 lignes au format X;0xY avec X (en décimal) > Y (en hexadécimal) :
for i in range(21,41):
print(str(i+33)+';'+str(hex(i)).upper())
for i in range(41,61):
print(str(i+8)+';'+str(hex(i)).upper())
for i in range(61,81):
print(str(i+17)+';'+str(hex(i)).upper())
for i in range(81,101):
print(str(i+1)+';'+str(hex(i)).upper())
Le programme suivant en Python génère 80 lignes au format X;0xY avec X (en décimal) = Y (en hexadécimal) :
for i in range(21,101):
print(str(i)+';'+str(hex(i)).upper())
Le programme suivant en Python génère 80 lignes au format 0xY;X avec X (en décimal) < Y (en hexadécimal) :
for i in range(21,41):
print(str(hex(i+2)).upper()+';'+str(i))
for i in range(41,61):
print(str(hex(i+11)).upper()+';'+str(i))
for i in range(61,81):
print(str(hex(i+47)).upper()+';'+str(i))
for i in range(81,101):
print(str(hex(i+35)).upper()+';'+str(i))
Le programme suivant en Python génère 80 lignes au format 0xY;X avec X (en décimal) > Y (en hexadécimal) :
for i in range(21,41):
print(str(hex(i)).upper()+';'+str(i+22))
for i in range(41,61):
print(str(hex(i)).upper()+';'+str(i+16))
for i in range(61,81):
print(str(hex(i)).upper()+';'+str(i+53))
for i in range(81,101):
print(str(hex(i)).upper()+';'+str(i+37))
Le programme suivant en Python génère 80 lignes au format 0xY;X avec X (en décimal) = Y (en hexadécimal) :
for i in range(21,101):
print(str(hex(i)).upper()+';'+str(i))
Exemple d'expression régulière de recherche (à adapter selon le cas utilisé parmi les 6 ci-dessus) :
(\d+);0X([0-9,A-F]+)
Exemple de motif de remplacement (à adapter) :
quest("Complétez la comparaison entre le nombre décimal $1 et le nombre hexadécimal $2 en entrant soit < soit = soit > :||Le nombre décimal $1 est-il inférieur, égal ou supérieur au nombre hexadécimal $2 ?");
rep("$1<sub>(10)</sub> [<] $2<sub>(16)</sub>");
debut("Vous pouvez entrer les caractères < = et > au clavier ou utiliser les boutons ci-dessous :");
caracteres_speciaux("<","=",">");
Analyse d'un algorigramme avec différentes valeurs pour les constantes
On donne un algorigramme où a, b et c sont des constantes et x, y et z sont des variables. On donne la valeur des constantes dans la question et on demande les valeurs de chaque variable dans la réponse. Exemple d'algorigramme avec 2 constante a et b et 2 variables x et y :
Le rôle de Python ici est de donner différentes valeurs aux constantes a et b et de calculer la valeur des variables x et y selon l'algorithme donné. Pour l'algorigramme ci-dessus voici le programme de base en Python :
# Fixe les constantes :
a=3
b=5# Calcule les variables :
x=a
if x<b:
y=2
else:
y=1# Affiche a;b;x;y :
print(a,';',b,';',x,';',y)
Ce programme donne :
3 ; 5 ; 3 ; 2
Pour obtenir une série de valeur on imbrique 2 boucles FOR pour donner différentes valeurs à a et à b. Par exemple tous les cas de 1 à 5 pour chacune des constantes, ce qui donnera 25 lignes soit 25 questions :
# fait varier a et b de 1 à 5 (25 cas)
for a in range(1,6):
for b in range(1,6):
# Calcule les variables selon l'algorigramme :
x=a
if x<b:
y=2
else:
y=1# Affiche a;b;x;y :
print(a,';',b,';',x,';',y)
Ce qui donne :
1 ; 1 ; 1 ; 1
1 ; 2 ; 1 ; 2
1 ; 3 ; 1 ; 2
1 ; 4 ; 1 ; 2
1 ; 5 ; 1 ; 2
2 ; 1 ; 2 ; 1
2 ; 2 ; 2 ; 1
2 ; 3 ; 2 ; 2
2 ; 4 ; 2 ; 2
2 ; 5 ; 2 ; 2
3 ; 1 ; 3 ; 1
3 ; 2 ; 3 ; 1
3 ; 3 ; 3 ; 1
3 ; 4 ; 3 ; 2
3 ; 5 ; 3 ; 2
4 ; 1 ; 4 ; 1
4 ; 2 ; 4 ; 1
4 ; 3 ; 4 ; 1
4 ; 4 ; 4 ; 1
4 ; 5 ; 4 ; 2
5 ; 1 ; 5 ; 1
5 ; 2 ; 5 ; 1
5 ; 3 ; 5 ; 1
5 ; 4 ; 5 ; 1
5 ; 5 ; 5 ; 1
Il reste à mettre en forme les questions à partir du fichier de sortie généré par Python. Pour cela on utilise la requête de transformation suivante :
Expression régulière de recherche :
(\d+) ; (\d+) ; (\d+) ; (\d+)
Motif de remplacement avec le nom et la résolution de l'image (à adapter) :
quest("Donnez les valeurs affectées aux variables x et y par l'algorigramme ci-contre sachant que les constantes a et b valent a=$1 et b=$2 :||Sachant que a=$1 et b=$2, combien valent les variables x et y après l'exécution de l'algorigramme ci-contre ?||Combien vaudront les variables x et y à la fin de cet algorigramme si a=$1 et b=$2 ?");
rep("x = [$3]");
rep("y = [$4]");
debut("Vous pouvez entrer les chiffres au clavier ou utiliser les boutons ci-dessous :");
caracteres_speciaux("0","1","2","3","4","5","6","7","8","9");
sch("images/algorigramme_1.png","190","286");
Il est biensûr très simple de dupliquer cet exemple en différentes variantes, soit en inversant la position du OUI et du NON dans le test, soit en remplaçant x<b par x<=b, x>b, x>=b, x=b ou x<>b, soit en permutant a et b, soit en modifiant les valeurs fixes affectées à y, soit surtout en utilisant plusieurs de ces modifications. Une fois de plus, grâce à ce nouveau générateur de seconde génération, il est possible d'obtenir en quelques minutes plusieurs centaines de questions favorisant l'imprévisibilité et obligeant à lire attentivement chaque algorigramme proposé.
Voici un autre exemple où cette fois on donne 3 constante a, b et c et on demande 3 variables x, y et z :
Pour obtenir le programme équivalent en Python on peut l'écrire à la main, mais on peut aussi s'inspirer de la version en langage C donné par Flowcode (à convertir en Python ou à compiler en C) :
//Décision
//Décision: a>=5?
if (FCV_A>=5)
{
//Calcul
//Calcul:
// x = c
FCV_X = FCV_C;
//Décision
//Décision: x>=b?
if (FCV_X>=FCV_B)
{
//Calcul
//Calcul:
// y = 8
FCV_Y = 8;
//Décision
//Décision: y>=a?
if (FCV_Y>=FCV_A)
{
//Calcul
//Calcul:
// z = b
FCV_Z = FCV_B;
} else {
//Calcul
//Calcul:
// z = a+1
FCV_Z = FCV_A+1;
}
} else {
//Calcul
//Calcul:
// y = b
FCV_Y = FCV_B;
//Décision
//Décision: y<>a?
if (FCV_Y!=FCV_A)
{
//Calcul
//Calcul:
// z = c+1
FCV_Z = FCV_C+1;
} else {
//Calcul
//Calcul:
// z = b+1
FCV_Z = FCV_B+1;
}
}
} else {
//Calcul
//Calcul:
// x = b
FCV_X = FCV_B;
//Décision
//Décision: x<c?
if (FCV_X<FCV_C)
{
//Calcul
//Calcul:
// y = c
FCV_Y = FCV_C;
//Décision
//Décision: y<7?
if (FCV_Y<7)
{
//Calcul
//Calcul:
// z = a
FCV_Z = FCV_A;
} else {
//Calcul
//Calcul:
// z = 2
FCV_Z = 2;
}
} else {
//Calcul
//Calcul:
// y = a
FCV_Y = FCV_A;
//Décision
//Décision: y=4?
if (FCV_Y==4)
{
//Calcul
//Calcul:
// z = c
FCV_Z = FCV_C;
} else {
//Calcul
//Calcul:
// z = 6
FCV_Z = 6;
}
}
}
Et voici l'équivalent en Python après modifications du code en C (la conversion du langage C généré par Flowcode en Python étant automatisable grâce aux expressions régulières, les possibilités sont à nouveau infinies ...) :
if a>=5:
x = c
if x>=b:
y = 8
if y>=a:
z = b
else:
z = a+1
else:
y = b
if y!=a:
z = c+1
else:
z = b+1
else:
x = b
if x<c:
y = c
if y<7:
z = a
else:
z = 2
else:
y = a
if y==4:
z = c
else:
z = 6
Il ne reste plus qu'à donner des valeurs aux constantes a, b et c puis à afficher les valeurs des variables x, y et z. Le programme en Python suivant donne seulement 3 valeurs (non continues) à chacune des 3 constantes, ce qui fait 27 cas au total afin de concerver l'équiprobabilité des questions sans créer de surabondance de certains algorigrammes :
for a in [4,5,8]:
for b in [3,7,8]:
for c in [2,7,9]:
if a>=5:
x = c
if x>=b:
y = 8
if y>=a:
z = b
else:
z = a+1
else:
y = b
if y!=a:
z = c+1
else:
z = b+1
else:
x = b
if x<c:
y = c
if y<7:
z = a
else:
z = 2
else:
y = a
if y==4:
z = c
else:
z = 6
print(a,';',b,';',c,';',x,';',y,';',z)
Et voici les 27 cas obtenus :
4 ; 3 ; 2 ; 3 ; 4 ; 2
4 ; 3 ; 7 ; 3 ; 7 ; 2
4 ; 3 ; 9 ; 3 ; 9 ; 2
4 ; 7 ; 2 ; 7 ; 4 ; 2
4 ; 7 ; 7 ; 7 ; 4 ; 7
4 ; 7 ; 9 ; 7 ; 9 ; 2
4 ; 8 ; 2 ; 8 ; 4 ; 2
4 ; 8 ; 7 ; 8 ; 4 ; 7
4 ; 8 ; 9 ; 8 ; 9 ; 2
5 ; 3 ; 2 ; 2 ; 3 ; 3
5 ; 3 ; 7 ; 7 ; 8 ; 3
5 ; 3 ; 9 ; 9 ; 8 ; 3
5 ; 7 ; 2 ; 2 ; 7 ; 3
5 ; 7 ; 7 ; 7 ; 8 ; 7
5 ; 7 ; 9 ; 9 ; 8 ; 7
5 ; 8 ; 2 ; 2 ; 8 ; 3
5 ; 8 ; 7 ; 7 ; 8 ; 8
5 ; 8 ; 9 ; 9 ; 8 ; 8
8 ; 3 ; 2 ; 2 ; 3 ; 3
8 ; 3 ; 7 ; 7 ; 8 ; 3
8 ; 3 ; 9 ; 9 ; 8 ; 3
8 ; 7 ; 2 ; 2 ; 7 ; 3
8 ; 7 ; 7 ; 7 ; 8 ; 7
8 ; 7 ; 9 ; 9 ; 8 ; 7
8 ; 8 ; 2 ; 2 ; 8 ; 9
8 ; 8 ; 7 ; 7 ; 8 ; 9
8 ; 8 ; 9 ; 9 ; 8 ; 8
Les questions du QCM sont obtenus grâce à la requête de transformation suivante :
Expression régulière de recherche :
(\d+) ; (\d+) ; (\d+) ; (\d+) ; (\d+) ; (\d+)
Motif de remplacement avec le nom et la résolution de l'image (à adapter) :
quest("Donnez les valeurs affectées aux variables x, y et z par l'algorigramme ci-contre sachant que les constantes a, b et c valent a=$1, b=$2 et c=$3 :||Sachant que a=$1, b=$2 et c=$3, combien valent les variables x, y et z après l'exécution de l'algorigramme ci-contre ?||Combien vaudront les variables x, y et z à la fin de cet algorigramme si a=$1, b=$2 et c=$3 ?");
rep("x = [$4]");
rep("y = [$5]");
rep("z = [$6]");
debut("Vous pouvez entrer les chiffres au clavier ou utiliser les boutons ci-dessous :");
caracteres_speciaux("0","1","2","3","4","5","6","7","8","9");
sch("images/algorigramme_2.png","865","550");
En donnant d'autres valeurs aux constantes a, b et c ou en donnant plus de valeurs il est très simple d'obtenir instantanément plusieurs centaines de questions différentes sur le même algorigramme.
Autre exemple utilisant une boucle Tant que :
Grâce à Python donnons à la constante a 20 valeurs différentes et affichons a, x et y :
for a in range(3,23):
x = 1
y = 1
while x<a:
x = x+1
y = y+2
print(a,';',x,';',y)
Résultat :
3 ; 3 ; 5
4 ; 4 ; 7
5 ; 5 ; 9
6 ; 6 ; 11
7 ; 7 ; 13
8 ; 8 ; 15
9 ; 9 ; 17
10 ; 10 ; 19
11 ; 11 ; 21
12 ; 12 ; 23
13 ; 13 ; 25
14 ; 14 ; 27
15 ; 15 ; 29
16 ; 16 ; 31
17 ; 17 ; 33
18 ; 18 ; 35
19 ; 19 ; 37
20 ; 20 ; 39
21 ; 21 ; 41
22 ; 22 ; 43
Les questions du QCM sont obtenus grâce à la requête de transformation suivante :
Expression régulière de recherche :
(\d+) ; (\d+) ; (\d+)
Motif de remplacement avec le nom et la résolution de l'image (à adapter) :
quest("Donnez les valeurs affectées aux variables x et y par l'algorigramme ci-contre sachant que la constante a vaut $1 :||Sachant que a=$1 combien valent les variables x et y après l'exécution de l'algorigramme ci-contre ?||Combien vaudront les variables x et y à la fin de cet algorigramme si a=$1 ?");
rep("x = [$2]");
rep("y = [$3]");
debut("Vous pouvez entrer les chiffres au clavier ou utiliser les boutons ci-dessous :");
caracteres_speciaux("0","1","2","3","4","5","6","7","8","9");
sch("images/algorigramme_3.png","77","412");
L'efficacité pour convertir un algorigramme Flowcode en série de questions pour QCM réside dans la maîtrise de la conversion du code en langage C généré par Flowcode en programme en Python. Voici l'essentiel à connaître, la conversion de programmes complexes pouvant être automatisée :
Affectation :
|
//Calcul //Calcul: // n = 3 FCV_N = 3; |
Le commentaire généré par Flowcode correspond parfaitement à la syntaxe de Python.
Test d'égalité :
|
//Décision } else { |
if n==3: |
La syntaxe du test d'égalité en Python est celle du C (==) et non celle de Flowcode (=).
Test de différence :
|
//Décision } else { |
if n!=3: a = 4 else: a = a+1 |
La syntaxe du test de différence en Python est celle du C (!=) et non celle de Flowcode (<>).
Boucle FOR :
|
//Boucle |
for i in range(5): n = n+1 |
En Python range(5) génère la liste [0,1,2,3,4] ce qui fait bien tourner la boucle FOR 5 fois (avec i, inutilisé ici, allant de 0 à 4).
Les 4 boucles WHILE possibles :
Boucle Tant que avec test au début de la boucle : on sort de la boucle si le test est FAUX
|
//Boucle |
while n<5: n = n+1 |
La boucle while du C ou de Python correspond naturellement à un bloc Tant que avec test au début de la boucle.
Boucle Jusqu'à avec test au début de la boucle : on sort de la boucle si le test est VRAI
|
//Boucle |
while not(n>5): n = n+1 |
En C comme en Python une boucle Jusqu'à est une boucle while avec complémentation de la contition. Le complément logique d'une condition toto s'écrit !(toto) en C mais s'écrit not(toto) en Python.
Boucle Tant que avec test à la fin de la boucle : on sort de la boucle si le test est FAUX
|
//Boucle if ((FCV_N<5) == 0) break; |
while True: |
Boucle Jusqu'à avec test à la fin de la boucle : on sort de la boucle si le test est VRAI
|
//Boucle if ((FCV_N>5) != 0) break; |
while True: n = n+1 if n>5: break |
Lorsque le test est à la fin de la boucle, en C comme en Python on commence une boucle while inifie puis on sort de la boucle grâce à break dès que la condition de sortie est atteinte.
Avec tout ça il est désormais possible d'automatiser la génération d'une série de questions sur le même algorigramme complexe en utilisant le code C généré par Flowcode pour calculer en Python la valeur des variables.
Choix de composants RC pour obtenir une constante de temps donnée
Le problème à exposer dans la question : on propose 3 valeurs de résistance et 3 valeurs de condensateur dans des cases à cocher, puis on demande de cocher 2 cases parmi les 6 afin d'obtenir une constante de temps donnée (c'est-à-dire le produit RxC).
Le programme en Python suivant donne les 81 produits possibles entre 2 chiffres compris entre 1 et 9 :
import random
for i in range(1,10):
for j in range(1,10):
k=i*j
print(str(i)+' Ωx'+str(j)+' F='+str(k)+' s')
Fichier texte généré avec les unités (ohm, farad et seconde) déjà positionnées dans les produits :
1 Ωx1 F=1 s
1 Ωx2 F=2 s
1 Ωx3 F=3 s
1 Ωx4 F=4 s
1 Ωx5 F=5 s
1 Ωx6 F=6 s
1 Ωx7 F=7 s
1 Ωx8 F=8 s
1 Ωx9 F=9 s
2 Ωx1 F=2 s
2 Ωx2 F=4 s
2 Ωx3 F=6 s
2 Ωx4 F=8 s
2 Ωx5 F=10 s
2 Ωx6 F=12 s
2 Ωx7 F=14 s
2 Ωx8 F=16 s
2 Ωx9 F=18 s
3 Ωx1 F=3 s
3 Ωx2 F=6 s
3 Ωx3 F=9 s
3 Ωx4 F=12 s
3 Ωx5 F=15 s
3 Ωx6 F=18 s
3 Ωx7 F=21 s
3 Ωx8 F=24 s
3 Ωx9 F=27 s
4 Ωx1 F=4 s
4 Ωx2 F=8 s
4 Ωx3 F=12 s
4 Ωx4 F=16 s
4 Ωx5 F=20 s
4 Ωx6 F=24 s
4 Ωx7 F=28 s
4 Ωx8 F=32 s
4 Ωx9 F=36 s
5 Ωx1 F=5 s
5 Ωx2 F=10 s
5 Ωx3 F=15 s
5 Ωx4 F=20 s
5 Ωx5 F=25 s
5 Ωx6 F=30 s
5 Ωx7 F=35 s
5 Ωx8 F=40 s
5 Ωx9 F=45 s
6 Ωx1 F=6 s
6 Ωx2 F=12 s
6 Ωx3 F=18 s
6 Ωx4 F=24 s
6 Ωx5 F=30 s
6 Ωx6 F=36 s
6 Ωx7 F=42 s
6 Ωx8 F=48 s
6 Ωx9 F=54 s
7 Ωx1 F=7 s
7 Ωx2 F=14 s
7 Ωx3 F=21 s
7 Ωx4 F=28 s
7 Ωx5 F=35 s
7 Ωx6 F=42 s
7 Ωx7 F=49 s
7 Ωx8 F=56 s
7 Ωx9 F=63 s
8 Ωx1 F=8 s
8 Ωx2 F=16 s
8 Ωx3 F=24 s
8 Ωx4 F=32 s
8 Ωx5 F=40 s
8 Ωx6 F=48 s
8 Ωx7 F=56 s
8 Ωx8 F=64 s
8 Ωx9 F=72 s
9 Ωx1 F=9 s
9 Ωx2 F=18 s
9 Ωx3 F=27 s
9 Ωx4 F=36 s
9 Ωx5 F=45 s
9 Ωx6 F=54 s
9 Ωx7 F=63 s
9 Ωx8 F=72 s
9 Ωx9 F=81 s
On ajoute "à la main" les préfixes des unités de mesure à chaque valeur dans le fichier texte (avec Ω pour les ohms et μ pour le préfixe micro) avec éventuellement des zéros supplémentaires :
1 MΩx1 μF=1 s
1 kΩx2 μF=2 ms
10 kΩx3 μF=30 ms
1 kΩx4 nF=4 μs
10 kΩx5 nF=50 μs
100 kΩx6 μF=600 ms
10 kΩx70 μF=700 ms
1 MΩx8 μF=8 s
1 MΩx90 μF=90 s
20 kΩx1 μF=20 ms
2 kΩx20 μF=40 ms
2 kΩx3 nF=6 μs
20 kΩx4 nF=80 μs
20 kΩx50 nF=1 ms
2 kΩx60 nF=120 μs
200 kΩx7 nF=1.4 ms
2 kΩx8 μF=16 ms
2 kΩx90 μF=180 ms
3 kΩx10 μF=30 ms
3 MΩx2 μF=6 s
30 MΩx3 μF=90 s
30 kΩx4 nF=120 μs
3 kΩx50 nF=150 μs
30 kΩx6 μF=180 ms
3 kΩx7 nF=21 μs
3 kΩx80 μF=240 ms
30 kΩx90 μF=2.7 s
40 kΩx10 nF=400 μs
40 MΩx2 μF=80 s
4 kΩx30 μF=120 ms
4 kΩx4 μF=16 ms
4 MΩx5 μF=20 s
4 kΩx60 nF=240 μs
40 kΩx7 μF=280 ms
4 k Ωx8n F=32μ s
40 kΩx9 nF=360 μs
50 MΩx1 μF=50 s
5 kΩx20 nF=100 μs
5 kΩx30 μF=150 ms
5 kΩx4 μF=20 ms
5 kΩx50 nF=250 μs
5 kΩx6 nF=30 μs
50 kΩx7 μF=350 ms
5 MΩx8 μF=40 s
50 kΩx9 nF=450 μs
6 kΩx10 μF=60 ms
6 kΩx2 μF=12 ms
60 kΩx30 nF=1.8 ms
60 MΩx4 μF=240 s
6 kΩx5 nF=30 μs
60 kΩx6 μF=360 ms
60 kΩx7 nF=420 μs
6 kΩx80 nF=480 μs
6 kΩx9 μF=54 ms
70 kΩx10 μF=700 ms
7 MΩx2 μF=14 s
7 kΩx3 nF=21 μs
7 kΩx4 μF=28 ms
7 kΩx50 nF=350 μs
7 kΩx60 μF=420 ms
70 kΩx7 μF=490 ms
70 MΩx8 μF=560 s
70 kΩx9 nF=630 μs
80 kΩx10 μF=800 ms
80 MΩx2 μF=160 s
8 kΩx30 μF=240 ms
8 kΩx4 nF=32 μs
8 MΩx5 μF=40 s
80 kΩx6 nF=480 μs
8 kΩx7 μF=56 ms
8 kΩx8 nF=64 μs
80 kΩx9 μF=720 ms
90 kΩx10 μF=900 ms
9 kΩx20 nF=180 μs
90 MΩx3 μF=270 s
9 kΩx40 μF=360 ms
90 kΩx5 nF=450 μs
9 kΩx6 nF=54 μs
9 kΩx7 μF=63 ms
9 MΩx8 μF=72 s
90 kΩx9 μF=810 ms
On ajoute 2 fausses valeurs de R et 2 fausses valeurs de C sur chaque ligne séparé par des deux points :
1 MΩx1 μF=1 s:10 MΩ:100 kΩ:2 μF:5 μF
1 kΩx2 μF=2 ms:10 kΩ:100 kΩ:20 μF:200 &mu
10 kΩx3 μF=30 ms:1 kΩ:100 kΩ:3 nF:1 μF
1 kΩx4 nF=4 μs:10 kΩ:100 kΩ:40 nF:400 nF
10 kΩx5 nF=50 μs:20 kΩ:30 kΩ:7 nF:9 nF
100 kΩx6 μF=600 ms:10 kΩ:1 kΩ:6 nF:30 μF
10 kΩx70 μF=700 ms:1 kΩ:2 kΩ:7 μF:20 μF
1 MΩx8 μF=8 s:1 kΩ:10 kΩ:18 μF:81 μF
1 MΩx90 μF=90 s:10 MΩ:2 MΩ:900 μF:70 μF
20 kΩx1 μF=20 ms:2 kΩ:40 kΩ:100 nF:3 μF
2 kΩx20 μF=40 ms:20 kΩ:4 kΩ:200 μF:1 μF
2 kΩx3 nF=6 μs:20 kΩ:200 kΩ:30 nF:300 nF
20 kΩx4 nF=80 μs:2 MΩ:200 kΩ:4 μF:40 μF
20 kΩx50 nF=1 ms:2 kΩ:1 kΩ:5 nF:10 nF
2 kΩx60 nF=120 μs:20 kΩ:2 MΩ:600 nF:60 μF
200 kΩx7 nF=1.4 ms:20 kΩ:2 kΩ:6 nF:50 nF
2 kΩx8 μF=16 ms:20 kΩ:40 kΩ:80 μF:40 μF
2 kΩx90 μF=180 ms:180 kΩ:20 kΩ:10 μF:900 μF
3 kΩx10 μF=30 ms:30 kΩ:60 kΩ:100 μF:5 μF
3 MΩx2 μF=6 s:30 MΩ:60 MΩ:20 μF:1 μF
30 MΩx3 μF=90 s:3 MΩ:1 MΩ:300 μF:9 μF
30 kΩx4 nF=120 μs:300 kΩ:6 kΩ:40 nF:2 nF
3 kΩx50 nF=150 μs:30 kΩ:15 kΩ:500 nF:100 nF
30 kΩx6 μF=180 ms:3 kΩ:2 kΩ:600 μF:9 μF
3 kΩx7 nF=21 μs:30 kΩ:4 kΩ:70 nF:90 nF
3 kΩx80 μF=240 ms:300 kΩ:12 kΩ:8 μF:2 μF
30 kΩx90 μF=2.7 s:3 kΩ:20 kΩ:9 μF:70 μF
40 kΩx10 nF=400 μs:4 kΩ:2 kΩ:1 nF:20 nF
40 MΩx2 μF=80 s:400 MΩ:8 MΩ:20 μF:1 μF
4 kΩx30 μF=120 ms:60 kΩ:6 kΩ:20 μF:2 μF
4 kΩx4 μF=16 ms:40 kΩ:40 kΩ:8 μF:20 μF
4 MΩx5 μF=20 s:2 MΩ:100 MΩ:100 μF:2 μF
4 kΩx60 nF=240 μs:40 kΩ:120 kΩ:600 nF:20 nF
40 kΩx7 μF=280 ms:4 kΩ:30 kΩ:700 μF:90 μF
4 kΩx8 nF=32μ s:40 k Ω:2 k Ω:80 nF:160 nF
40 kΩx9 nF=360 μs:4 kΩ:18 kΩ:900 pF:2 nF
50 MΩx1 μF=50 s:5 MΩ:200 kΩ:100 nF:100 μF
5 kΩx20 nF=100 μs:50 kΩ:500 kΩ:200 nF:2 μnF
5 kΩx30 μF=150 ms:50 kΩ:500 kΩ:300 μF:3 mF
5 kΩx4 μF=20 ms:2 kΩ:20 kΩ:1 nF:20 μF
5 kΩx50 nF=250 μs:50 kΩ:7 kΩ:500 nF:70 nF
5 kΩx6 nF=30 μs:15 kΩ:20 kΩ:20 nF:15 nF
50 kΩx7 μF=350 ms:5 kΩ:30 kΩ:700 nF:3 μF
5 MΩx8 μF=40 s:80 MΩ:20 MΩ:5 μF:20 μF
50 kΩx9 nF=450 μs:90 kΩ:9 kΩ:50 nF:5 nF
6 kΩx10 μF=60 ms:1 kΩ:12 kΩ:6 μF:50 μF
6 kΩx2 μF=12 ms:60 kΩ:2 kΩ:20 μF:60 μF
60 kΩx30 nF=1.8 ms:6 kΩ:3 kΩ:60 nF:3 nF
60 MΩx4 μF=240 s:60 kΩ:6 kΩ:4 &nF:40 nF
6 kΩx5 nF=30 μs:60 kΩ:600 kΩ:5 μF:50 nF
60 kΩx6 μF=360 ms:60 MΩ:60 Ω:60 μF:600 μF
60 kΩx7 nF=420 μs:50 kΩ:40 kΩ:6 nF:5 nF
6 kΩx80 nF=480 μs:8 kΩ:80 kΩ:60 nF:60 μF
6 kΩx9 μF=54 ms:9 kΩ:7 kΩ:8 μF:7 μF
70 kΩx10 μF=700 ms:7 MΩ:700 Ω:100 μF:1 μF
7 MΩx2 μF=14 s:20 kΩ:7 kΩ:20 μF:70 nF
7 kΩx3 nF=21 μs:70 kΩ:3 kΩ:30 nF:70 nF
7 kΩx4 μF=28 ms:4 kΩ:70 kΩ:40 μF:70 μF
7 kΩx50 nF=350 μs:5 kΩ:70 kΩ:7 nF:500 nF
7 kΩx60 μF=420 ms:6 kΩ:70 kΩ:7 μF:60 nF
70 kΩx7 μF=490 ms:7 kΩ:49 kΩ:700 μF:1 μF
70 MΩx8 μF=560 s:90 MΩ:80 MΩ:9 μF:6 μF
70 kΩx9 nF=630 μs:80 kΩ:90 kΩ:8 nF:6 nF
80 kΩx10 μF=800 ms:80 MΩ:800 Ω:10 pF:100 pF
80 MΩx2 μF=160 s:20 MΩ:80 kΩ:20 μF:80 μF
8 kΩx30 μF=240 ms:60 kΩ:4 kΩ:40 μF:300 μF
8 kΩx4 nF=32 μs:6 kΩ:7 kΩ:4 nF:3 nF
8 MΩx5 μF=40 s:80 MΩ:6 MΩ:6 μF:80 μF
80 kΩx6 nF=480 μs:24 kΩ:12 kΩ:2 nF:4 nF
8 kΩx7 μF=56 ms:9 kΩ:6 kΩ:9 μF:8 μF
8 kΩx8 nF=64 μs:7 kΩ:9 kΩ:7 nF:9 nF
80 kΩx9 μF=720 ms:60 kΩ:90 kΩ:80 μF:6 μF
90 kΩx10 μF=900 ms:900 kΩ:9 kΩ:10 nF:100 nF
9 kΩx20 nF=180 μs:6 kΩ:90 kΩ:3 nF:300 nF
90 MΩx3 μF=270 s:30 MΩ:3 MΩ:30 μF:900 μF
9 kΩx40 μF=360 ms:18 kΩ:900 Ω:2 μF:4 μF
90 kΩx5 nF=450 μs:45 kΩ:900 kΩ:10 μF:50 nF
9 kΩx6 nF=54 μs:7 kΩ:8 kΩ:9 nF:8 nF
9 kΩx7 μF=63 ms:8 kΩ:6 kΩ:6 μF:9 μF
9 MΩx8 μF=72 s:7 MΩ:6 MΩ:7 μF:9 μF
90 kΩx9 μF=810 ms:9 kΩ:810 kΩ:900 nF:10 μF
Le motif de recherche suivante découpe chaque ligne en 7 morceaux selon les réparateurs x, = ou deux points :
(.*)x(.*)=(.*):(.*):(.*):(.*):(.*)
Le motif de remplacement suivant replace chacun des 7 morceaux ($1 à $7) dans une question de QCM :
quest("Quelles valeurs donneriez-vous à R et à C afin que la constante de temps du circuit RC ci-contre soit égale à $3 ?//a");
rep("[x] R = $1");
rep("[x] C = $2");
rep("[ ] R = $4");
rep("[ ] R = $5");
rep("[ ] C = $6");
rep("[ ] C = $7");
debut("Cochez 2 cases parmi les 6");
sch("images/circuit_rc.png","488","114");
Exemple de fichier obtenu :
quest("Quelles valeurs donneriez-vous à R et à C afin que la constante de temps du circuit RC ci-contre soit égale à 72 s ?//a");
rep("[x] R = 9 MΩ");
rep("[x] C = 8 μF");
rep("[ ] R = 7 MΩ");
rep("[ ] R = 6 MΩ");
rep("[ ] C = 7 μF");
rep("[ ] C = 9 μF");
debut("Cochez 2 cases parmi les 6");
sch("images/circuit_rc.png","488","114");
quest("Quelles valeurs donneriez-vous à R et à C afin que la constante de temps du circuit RC ci-contre soit égale à 810 ms ?//a");
rep("[x] R = 90 kΩ");
rep("[x] C = 9 μF");
rep("[ ] R = 9 kΩ");
rep("[ ] R = 810 kΩ");
rep("[ ] C = 900 nF");
rep("[ ] C = 10 μF ");
debut("Cochez 2 cases parmi les 6");
sch("images/circuit_rc.png","488","114");
Condensateurs équivalents en série et en dérivation
On désire obtenir un fichier texte à 6 colonnes séparées par des point-virgules contenant :
Les capacités c1 et c2 varient chacune de 1 à 100 et le résultat de la colonne 4 (capacité équivalente des capacités c1 et c2 en série) doit être un nombre entier (il faut éliminer tous les cas où la fraction (c1*c2)/(c1+c2) ne donne pas un entier).
Voici le programme en Python qui génére un tel fichier :
import random
for c1 in range(1,101):
for c2 in range(1,101):
r1=c1+c2
r2=1.0*(c1*c2)/(c1+c2)
r3=r1
r4=r1
while (r3==r1) | (r3==r2) | (r4==r1) | (r4==r2) | (r3==r4):
r3=random.randint(1,100)
r4=random.randint(1,100)
if r2==int(r2):
print ("{};{};{};{};{};{}".format(c1,c2,r1,int(r2),r3,r4))
Exemple de fichier texte obtenu (le fichier complet possède 170 lignes) :
6;6;12;3;88;26
6;12;18;4;89;51
6;30;36;5;61;65
7;42;49;6;73;31
8;8;16;4;14;20
8;24;32;6;19;65
8;56;64;7;42;80
9;18;27;6;1;67
9;72;81;8;28;77
10;10;20;5;82;78
10;15;25;6;88;75
10;40;50;8;31;2
10;90;100;9;43;41
12;4;16;3;23;78
12;6;18;4;20;79
12;12;24;6;82;86
12;24;36;8;78;70
12;36;48;9;32;37
12;60;72;10;29;51
14;14;28;7;3;73
14;35;49;10;79;60
14;84;98;12;54;9
15;10;25;6;4;15
15;30;45;10;57;64
La mise en forme d'un tel fichier pour obtenir les questions du QCM est désormais classique comme le montre la requête de transformation suivante.
Expression régulière de recherche découpant chaque ligne en 6 champs selon le séparateur point-virgule :
(.*);(.*);(.*);(.*);(.*);(.*)
Motif de remplacement avec les capacités en micro-farad et posant 2 questions pour chaque ligne : en série et en dérivation :
quest("Quelle est la capacité équivalente obtenue en branchant en dérivation un condensateur C1 de $1 μF et un condensateur C2 de $2 μF ?//a");
rep("(o) $3 μF");
rep("( ) $4 μF");
rep("( ) $5 μF");
rep("( ) $6 μF");
sch("images/condensateur_derivation.png","244","194");quest("Quelle est la capacité équivalente obtenue en branchant en série un condensateur C1 de $1 μF et un condensateur C2 de $2 μF ?//a");
rep("( ) $3 μF");
rep("(o) $4 μF");
rep("( ) $5 μF");
rep("( ) $6 μF");
sch("images/condensateur_serie.png","408","77");
Remarque : sur les 10000 cas testés (100x100) il ne reste que 170 cas où la fraction produit/somme est un entier.
Mise en forme directe d'un fichier texte par expressions régulières et sans utiliser Python
On part d'un simple fichier texte possédant différents champs sur chaque ligne séparé par des points virgule. Le premier champ est la question, le deuxième est l'unique bonne réponse, les autres champs sont les mauvaises réponses :
Sur la courbe de charge du condensateur quelle est la valeur de la charge, en pourcentage de la tension totale, après un temps égal à 0 s ?;0%;40%;60%;75%;83%;88%;93%;95%;97%;99%;100%
Sur la courbe de charge du condensateur quelle est la valeur de la charge, en pourcentage de la tension totale, après un temps égal à 5 RC ?;100%;0%;40%;60%;75%;83%;88%;93%;95%;97%;99%
Sur la courbe de charge du condensateur quelle est la valeur de la charge, en pourcentage de la tension totale, après un temps égal à 4.5 RC ?;99%;100%;0%;40%;60%;75%;83%;88%;93%;95%;97%
Sur la courbe de charge du condensateur quelle est la valeur de la charge, en pourcentage de la tension totale, après un temps égal à 4 RC ?;97%;99%;100%;0%;40%;60%;75%;83%;88%;93%;95%
Sur la courbe de charge du condensateur quelle est la valeur de la charge, en pourcentage de la tension totale, après un temps égal à 3.5 RC ?;95%;97%;99%;100%;0%;40%;60%;75%;83%;88%;93%
Sur la courbe de charge du condensateur quelle est la valeur de la charge, en pourcentage de la tension totale, après un temps égal à 3 RC ?;93%;95%;97%;99%;100%;0%;40%;60%;75%;83%;88%
Sur la courbe de charge du condensateur quelle est la valeur de la charge, en pourcentage de la tension totale, après un temps égal à 2.5 RC ?;88%;93%;95%;97%;99%;100%;0%;40%;60%;75%;83%
Sur la courbe de charge du condensateur quelle est la valeur de la charge, en pourcentage de la tension totale, après un temps égal à 2 RC ?;83%;88%;93%;95%;97%;99%;100%;0%;40%;60%;75%
Sur la courbe de charge du condensateur quelle est la valeur de la charge, en pourcentage de la tension totale, après un temps égal à 1.5 RC ?;75%;83%;88%;93%;95%;97%;99%;100%;0%;40%;60%
Sur la courbe de charge du condensateur quelle est la valeur de la charge, en pourcentage de la tension totale, après un temps égal à RC ?;60%;75%;83%;88%;93%;95%;97%;99%;100%;0%;40%
Sur la courbe de charge du condensateur quelle est la valeur de la charge, en pourcentage de la tension totale, après un temps égal à 0.5 RC ?;40%;60%;75%;83%;88%;93%;95%;97%;99%;100%;0%
Sur la courbe de charge du condensateur au bout de combien de temps la charge vaut-elle 10% de la tension totale ?;0.1 RC;0.2 RC;0.3 RC;0.5 RC;0.7 RC;RC;1.35 RC;1.85 RC;2.7 RC;5 RC
Sur la courbe de charge du condensateur au bout de combien de temps la charge vaut-elle 100% de la tension totale ?;5 RC;0.1 RC;0.2 RC;0.3 RC;0.5 RC;0.7 RC;RC;1.35 RC;1.85 RC;2.7 RC
Sur la courbe de charge du condensateur au bout de combien de temps la charge vaut-elle 90% de la tension totale ?;2.7 RC;5 RC;0.1 RC;0.2 RC;0.3 RC;0.5 RC;0.7 RC;RC;1.35 RC;1.85 RC
Sur la courbe de charge du condensateur au bout de combien de temps la charge vaut-elle 80% de la tension totale ?;1.85 RC;2.7 RC;5 RC;0.1 RC;0.2 RC;0.3 RC;0.5 RC;0.7 RC;RC;1.35 RC
Sur la courbe de charge du condensateur au bout de combien de temps la charge vaut-elle 70% de la tension totale ?;1.35 RC;1.85 RC;2.7 RC;5 RC;0.1 RC;0.2 RC;0.3 RC;0.5 RC;0.7 RC;RC
Sur la courbe de charge du condensateur au bout de combien de temps la charge vaut-elle 60% de la tension totale ?;RC;1.35 RC;1.85 RC;2.7 RC;5 RC;0.1 RC;0.2 RC;0.3 RC;0.5 RC;0.7 RC
Sur la courbe de charge du condensateur au bout de combien de temps la charge vaut-elle 50% de la tension totale ?;0.7 RC;RC;1.35 RC;1.85 RC;2.7 RC;5 RC;0.1 RC;0.2 RC;0.3 RC;0.5 RC
Sur la courbe de charge du condensateur au bout de combien de temps la charge vaut-elle 40% de la tension totale ?;0.5 RC;0.7 RC;RC;1.35 RC;1.85 RC;2.7 RC;5 RC;0.1 RC;0.2 RC;0.3 RC
Sur la courbe de charge du condensateur au bout de combien de temps la charge vaut-elle 30% de la tension totale ?;0.3 RC;0.5 RC;0.7 RC;RC;1.35 RC;1.85 RC;2.7 RC;5 RC;0.1 RC;0.2 RC
Sur la courbe de charge du condensateur au bout de combien de temps la charge vaut-elle 20% de la tension totale ?;0.2 RC;0.3 RC;0.5 RC;0.7 RC;RC;1.35 RC;1.85 RC;2.7 RC;5 RC;0.1 RC
Le motif de recherche suivante découpe chaque ligne en 12 morceaux selon les réparateurs ; :
(.*);(.*);(.*);(.*);(.*);(.*);(.*);(.*);(.*);(.*);(.*);(.*)
Le motif de remplacement suivant replace chacun des 12 morceaux ($1 à $12) dans une question de QCM :
quest("$1//a");
rep("(o) $2");
rep("( ) $3");
rep("( ) $4");
rep("( ) $5");
rep("( ) $6");
rep("( ) $7");
rep("( ) $8");
rep("( ) $9");
rep("( ) $10");
rep("( ) $11");
rep("( ) $12");
Exemple de fichier obtenu :
quest("Sur la courbe de charge du condensateur quelle est la valeur de la charge, en pourcentage de la tension totale, après un temps égal à 0.5 RC ?//a");
rep("(o) 40%");
rep("( ) 60%");
rep("( ) 75%");
rep("( ) 83%");
rep("( ) 88%");
rep("( ) 93%");
rep("( ) 95%");
rep("( ) 97%");
rep("( ) 99%");
rep("( ) 100%");
rep("( ) 0%");
quest("Sur la courbe de charge du condensateur au bout de combien de temps la charge vaut-elle 10% de la tension totale ?//a");
rep("(o) 0.1 RC");
rep("( ) 0.2 RC");
rep("( ) 0.3 RC");
rep("( ) 0.5 RC");
rep("( ) 0.7 RC");
rep("( ) RC");
rep("( ) 1.35 RC");
rep("( ) 1.85 RC");
rep("( ) 2.7 RC");
rep("( ) 5 RC");
Recherche et supression des questions ayant pour réponse Aucune de ces propositions grâce aux expressions régulières de Dreamweaver
Expression régulière permettant de rechercher et de supprimer les questions dont la bonne réponse est "Aucune de ces propositions" :
quest.+\nrep.+\nrep.+\nrep.+\nrep\("\(o\) Aucune de ces propositions"\);\n
Rechercher les motifs correspondant à cette expresion régulière en utilisant l'option de recherche "Utiliser les expressions régulières" de Dreamweaver puis remplacer les occurrences trouvées par rien (ce qui supprime simplement chaque question trouvée).
Dans cette expression régulière, \n représente un retour à la ligne, .+ représente n'importe quel caractère un nombre quelconque de fois, et les caractères parenthèses ont été échapés : \( pour rechercher une parenthèse ouvrante et \) pour rechercher une parenthèse fermante.
Sous windows 7 il faut remplacer la saisie de \n par le caractère retour à la ligne saisie par Ctrl-Entrée.
Cette expression régulière trouvera les questions possédant seulement 4 réponses et dont la 4ème réponse est "(o) Aucune de ces propositions". Il s'agit précisément des questions générées par le générateur de 96 questions (qui génère 32 questions avec (o) Aucune de ces propositions et 64 questions sans). Pour rechercher tout autre motif il suffit d'adapter l'expression régulière.
L'expression régulière suivante sélectionne 3 questions consécutives ayant pour bonne réponse (o) Aucune de ces propositions avec 3 autres réponse fausses :
(quest.+\nrep.+\nrep.+\nrep.+\nrep\("\(o\) Aucune de ces propositions"\);\n){3}
L'expression régulière suivante trouve toutes les questions ayant pour bonne réponse (o) Aucune de ces propositions, quelque soit le nombre de réponses dans la question et quelque soit la position de (o) Aucune de ces propositions dans les réponses :
quest.*(\nrep.*)*\nrep\("\(o\) Aucune de ces propositions"\);(\nrep.*)*\n
L'expression régulière suivante trouve les questions ayant pour bonne réponse (o) Aucune de ces propositions avec au moins 4 autres réponse fausses :
quest.*(\nrep.*){4,10}\nrep\("\(o\) Aucune de ces propositions"\);\n
L'expression régulière suivante trouve toutes les questions ayant pour bonne réponse (o) Aucune de ces propositions, quelque soit le nombre de réponses dans la question, quelque soit la position de (o) Aucune de ces propositions dans les réponses, avec éventuellement un ou plusieurs </br> à la fin de la réponse, et avec éventuellement une image associée à la question (dernière ligne commençant par sch). Cette expression régulière permet de supprimer dans un QCM l'intégralité des questions ayant comme bonne réponse (o) Aucune de ces propositions :
quest.*(\nrep.*)*\nrep\("\(o\) Aucune de ces propositions(</br>)*"\);(\nrep.*)*(\nsch.*)?\n
L'expression régulière suivante recherche 2 caractères slash consécutifs dans une question autre que dans le //a placé à la fin des questions et permet de trouver //A ou ///A qui pose problème dans le QCM de logique :
quest\(".*//[^a].*
Recherche et supression des lignes erronnées dans le QCM
L'expression régulière suivante détecte toutes les lignes non conformes dans le QCM, c'est-à-dire une ligne qui n'est pas un commentaire commençant par //, et qui ne finit pas par un point virgule. Si une ligne finit par un caractère alphanumérique après le point virgule, aucune erreur ne sera signalée mais les questions suivant cette ligne erronnée seront ignorées. En cas de bug constaté (nombre de questions qui n'évolue pas en ajoutant des nouvelles questions à le fin du QCM, nouveau thème qui ne s'affiche pas, page d'accueil qui affiche seulement les boutons sans le texte ni les thèmes, etc.) il faut détecter les mauvaises lignes grâce à cette expression régulière :
\n[^(//.*\n)].*[^;\n]\n
Recherche et supression d'un gros morceau de fichier
Il arrive parfois qu'il faille supprimer une grande partie d'un fichier texte. Exemple : on vaut supprimer 20000 questions dans un fichier de QCM. Certes on peut très bien détecter une question par expression régulière, la remplacer par rien, puis demander à Dreamweaver de répéter l'opération pour chacune des 20000 occurences. Mais cette procédure est extrêmement longue (si encore Dreamweaver ne plante pas en plein milieu de la recherche ...). Si les 20000 questions à supprimer sont consécutives, on met une chaîne de caractère unique debut au début du paragraphe à supprimer, une autre chaîne unique fin à la fin, puis on sélectionne toutes les lignes (vides ou pas) comprises entre la ligne debut et la ligne fin grâce à l'expression nrégulière suivante :
debut(\n(.*))+\nfin
Remarque : dans la pratique, afin d'être sûr que les lignes debut et fin sont uniques on utilisera une suite de lettres et de chiffres aléatoires, et on s'assurera que chacune de ses 2 lignes sont bien uniques en les recherchant en un premier temps avant d'effectuer le remplacement.
Mais cette technique ne fonctionnera que pour un nombre limité de lignes à supprimer. En effet, si on veut supprimer plusieurs milliers de lignes dans un fichier Dreamweaver montrera ses limite et plantera systématiquement quelque soit la technique utilisé (supression des questions une par une, sélection puis suppression de 500 questions d'un coup, sélection puis supression de la totalité des questions à supprimer). Cas concret et réel déjà vécu : on dispose d'un fichier de QCM de plus de 6 Mo contenant plus de 21 000 questions et plus de 130 000 lignes et on veut en supprimer 20000 questions. Impossible de le faire dans Dreamweaver qui est lent et qui plante systématiquement. En revanche, le bloc note de Windows ouvre sans problème ce fichier de 130 000 lignes, permet de sélectionner sans problème les 20 000 questions d'un coup (clic au début + Shift + clic à la fin) et permet de supprimer plusieurs milliers de lignes consécutives sans planter. Idem pour ajouter des questions dans un fichier contenant plus de 100 000 lignes, il vaut mieux utiliser un éditeur simple comme le bloc note plutôt que Dreamweaver.
Moralité de cette expérience : aucune expression régulière, aussi complexe soit-elle, ne remplacera les techniques de base utilisées depuis toujours dans un éditeur de texte primitif ...
Duplication récurcive d'un fichier possédant une seule ligne
On part d'un fichier texte possédant une seule ligne finissant par \n. On désire un fichier possédant des milliers de lignes identiques à la première. Certe on peut faire une série de copier/coller en sélectionnant à chaque fois tous le fichier (Ctrl-A). Mais on peut aussi utiliser le motif de recherche suivant qui est une expression régulière qui sélectionne l'intégralité du fichier :
^((.*\n)*)$
Puis on le remplace par son double, c'est-à dire 2 fois le fichier :
$1$1
Pour accélérer la duplication, on peut remplacer le motif de remplacement $1$1 par $1$1$1$1$1$1$1$1$1$1$1$1$1$1$1$1$1$1$1$1$1$1$1$1$1$1$1$1 ce qui va multiplier non pas par 2 (comme le ferait un copier/coller), mais par 20 la taille du fichier à chaque application de la fonction Remplacer tout (Ctrl-F + Alt-U).
Remarque : dans les expressions régulières de Dreamweaver, ^ et $ représentent le début et la fin du fichier et non d'une ligne. De plus, \n représentera un retour à la ligne seulement si Dreamweaver est configuré pour utiliser des retours à la ligne de type Unix (dans le menu Edition + Préférences + Format de code).
Si on veut dupliquer l'unique ligne du fichier mais en effectuant une permutation circulaire des caractère à chaque nouvelle ligne, on utilisera l'expression régulière de recherche suivante :
^(((.{1})(.*)\n)*)$
Et le motif de remplacement suivant :
$1$4$3\n
Remarques :
$1 est le fichier entier
$2 est la dernière ligne entière, comprenant le retour à la ligne final
$3 est le premier caractère de cette dernière ligne
$4 est le reste de la dernière ligne (sans le retour à la ligne)
Par exemple, en partant d'un fichier possédant comme unique ligne :
abcdefghijklmnopqrstuvwxyz
On obtient aprés 25 duplications :
abcdefghijklmnopqrstuvwxyz
bcdefghijklmnopqrstuvwxyza
cdefghijklmnopqrstuvwxyzab
defghijklmnopqrstuvwxyzabc
efghijklmnopqrstuvwxyzabcd
fghijklmnopqrstuvwxyzabcde
ghijklmnopqrstuvwxyzabcdef
hijklmnopqrstuvwxyzabcdefg
ijklmnopqrstuvwxyzabcdefgh
jklmnopqrstuvwxyzabcdefghi
klmnopqrstuvwxyzabcdefghij
lmnopqrstuvwxyzabcdefghijk
mnopqrstuvwxyzabcdefghijkl
nopqrstuvwxyzabcdefghijklm
opqrstuvwxyzabcdefghijklmn
pqrstuvwxyzabcdefghijklmno
qrstuvwxyzabcdefghijklmnop
rstuvwxyzabcdefghijklmnopq
stuvwxyzabcdefghijklmnopqr
tuvwxyzabcdefghijklmnopqrs
uvwxyzabcdefghijklmnopqrst
vwxyzabcdefghijklmnopqrstu
wxyzabcdefghijklmnopqrstuv
xyzabcdefghijklmnopqrstuvw
yzabcdefghijklmnopqrstuvwx
zabcdefghijklmnopqrstuvwxy
Création de l'ensemble de Mandelbrot en Python
Python utilisant les nombres complexes en natif, il est très simple de tracer l'ensemble de Mandelbrot. Le programme suivant calcule tous les pixels d'une image représentant l'ensemble de Mandelbrot et stocke les résultats dans une liste enregistrée dans le fichier texte mandelbrot.txt :
x_min=-5
x_max=5
y_min=-5
y_max=5
res_x=320
res_y=200
l=[]
fic=open('mandelbrot.txt','w')
for px in range(1,res_x+1):
for py in range(1,res_y+1):
n=0
x=x_min+px*(x_max-x_min)/res_x
y=y_max-py*(y_max-y_min)/res_y
z=complex(x,y)
z2=z
while(abs(z)<2):
z=z*z+z2
n+=1
if n>=255:
break
l.append(n)
fic.write(str(l))
fic.close()
print('Taille de la liste :',len(l))
Pour enregistrer l'image directement dans un fichier PNG il faut utiliser le module Image de Python. Chaque pixel de l'image est alimenté par 3 octets R, V et B pour chacune des trois couleurs de base, et le nombre d'itérations est calculé automatiquement en fonction du grossissement :
import Image
import math
x_min=-2.61
x_max=1.33
y_min=-1.56
y_max=1.40
res_x=640
res_y=480
size = (res_x,res_y)
im = Image.new('RGB',size)
pix = im.load()
iterations=int(math.log(4/(x_max-x_min))/(12*math.log(10))*10000+200)
print("Calcul de l'image avec {} iterations ...".format(iterations))
for px in range(res_x):
for py in range(res_y):
n=0
x=x_min+px*(x_max-x_min)/res_x
y=y_max-py*(y_max-y_min)/res_y
z=complex(x,y)
z2=z
while(abs(z)<2):
z=z*z+z2
n+=1
if n>=iterations:
break
pix[px,py] = (0,n & 255,n >> 8)
im.save('mandelbrot.png')
Pour connaître les modules installé dans Python il faut taper help() puis modules. En tapant le nom d'un modules dans l'aide on obtient l'ensemble de ses fonctions.
Le script suivant calcule automatiquement sous Linux un lot d'image provenant de fichiers IDA représentant un zoom dans l'ensemble de Mandelbrot :
Fichier gecif.sh :
#!/bin/sh
######################################################
# Réalisé le 22 avril 2014 par Jean-Christophe MICHEL
# www.gecif.net
######################################################
# Convertit tous les fichier IDA en fichier ZOM contenant le zoom et le nom du fichier :
for fic in *.IDA
do
echo "Traitement de $fic ..."
nom=`echo $fic | cut -d'.' -f1`
cat $fic | grep "(* Ce commentaire" | grep -v "procedure" | grep -v "begin" | grep -v "end;" | grep -v " (*" | sed 's/(\*/\n/' | grep -v "commentaire" | sed 's/ //' | sed 's/:=/=/' | sed 's/;//' > $nom.ZOM
echo "nom_fic='$nom.PNG'" >> $nom.ZOM
rm $fic
done
#Pour chaque fichier ZOM calcule l'image en appelant gecif.py :
for fic in *.ZOM
do
rm zoom.py
rm zoom.pyc
mv $fic zoom.py
./gecif.py
done
Le programme en Python lit la taille du zoom (X_MIN, X_MAX, Y_MIN et Y_MAX) ainsi que le nom du fichier PNG dans un module appelé zoom.py :
Fichier gecif.py :
#!/usr/bin/python
######################################################
# Réalisé le 22 avril 2014 par Jean-Christophe MICHEL
# www.gecif.net
######################################################
import Image
import math
from zoom import *
res_x=640
res_y=480
size = (res_x,res_y)
im = Image.new('RGB',size)
pix = im.load()
iterations=int(math.log(4/(X_MAX-X_MIN))/(12*math.log(10))*10000+200)
print("Calcul de l'image {} avec {} iterations ...".format(nom_fic,iterations))
for px in range(res_x):
for py in range(res_y):
n=0
x=X_MIN+px*(X_MAX-X_MIN)/res_x
y=Y_MAX-py*(Y_MAX-Y_MIN)/res_y
z=complex(x,y)
z2=z
while(abs(z)<2):
z=z*z+z2
n+=1
if n>=iterations:
break
pix[px,py] = (0,n & 255,n >> 8)
im.save(nom_fic)
Uitlisation : copier gecif.sh et gecif.py dans un répertoire IDAxx contenant un lot de fichiers IDA, puis lancer gecif.sh : il convertit chaque fichier IDA en fichier ZOM en extrayant la taille du zoom, puis calcule chaque image en traitant tous les fichiers ZOM et en effaçant les fichiers ZOM au fur et à mesure. Dans cette version minimale de Gecif sous Linux il est impossible d'arrêter le traitement des images en cours de calcul. A la fin des calculs le lot de fichiers IDA est remplacé par un lot de fichiers PNG, dont la résolution est indiquée dans le programme gecif.py (le nombre d'itérations étant calculé automatiquement en fonction du grossissement du zoom).
Mais malheureusement il semble que le calcul d'images fractales avec Python sous Linux soit plus lent qu'avec gecif sous MS-DOS 7.1 programmé en Turbo Pascal ...
Mars 2014