Écrivez un script pour réaliser chacune des tâches suivantes.
FACILE
Écrivez un script qui se sauvegarde lui-même, c'est-à-dire qu'il se copie dans un fichier nommé backup.sh.
Astuce : utilisez la commande cat et les paramètres de position appropriés.
Listez les répertoires et les sous-répertoires à partir du répertoire personnel de l'utilisateur et sauvegardez le résultat dans un fichier. Compressez le fichier, faites en sorte que le script demande à l'utilisateur d'insérer une clé USB et appuie sur ENTER. Enfin, enregistrez le fichier sur la clé après avoir vérifié qu'elle est bien montée grâce à l'analyse du résultat de la commande df. Remarque : Il faut démonter la clé USB avant de la retirer.
Convertissez les boucles for de l'Exemple 11.1, « Des boucles for simples » en boucles while. Indice : stockez les données dans un tableau et parcourez les éléments du tableau.
Après ce « gros lifting, » convertissez maintenant les boucles de l'exemple en boucles until.
Écrivez un script qui lit chaque ligne d'un fichier cible puis écrit la ligne sur stdout suivie d'une ligne vide. Ceci a pour effet de doubler l'espacement des lignes du fichier.
Incluez tout le code nécessaire pour vérifier que le script obtient l'argument nécessaire en ligne de commande (un nom de fichier), et que le fichier spécifié existe.
Quand le script s'exécute correctement, modifiez-le pour tripler l'espacement des lignes du fichier cible.
Enfin, écrivez un script pour supprimer toutes les lignes vides du fichier cible.
Écrivez un script qui s'affiche lui-même sur stdout mais à l'envers.
À partir d'une liste de noms de fichiers donnée en entrée, cherchez sur chaque fichier cible le type de compression utilisé en analysant la sortie de la commande file. Puis, appellez automatiquement la commande de décompression appropriée (gunzip, bunzip2, unzip, uncompress ou autre). Si un fichier cible n'est pas compressé, affichez un message d'erreur mais ne faites aucune autre action sur ce fichier particulier.
Générez un identifiant hexadécimal à six chiffres « unique » pour votre ordinateur. N'utilisez pas la commande défectueuse hostid. Indice : md5sum /etc/passwd, puis sélectionnez les six premiers chiffres du résultat.
Archivez dans une « archive tar » (fichier *.tar.gz) tous les fichiers de votre répertoire personnel (/home/votre-nom) qui ont été modifiés dans les dernières 24 heures. Indice : utilisez find.
Facultatif : vous pouvez baser là-dessus un script de sauvegarde.
Avec un identifiant de processus (PID) comme argument, ce script vérifiera, à un interval spécifié par l'utilisateur, si le processus donné est toujours en cours d'exécution. Vous pouvez utiliser les commandes ps et sleep.
Affichez (sur stdout) tous les nombres premiers entre 60000 et 63000. Le résultat devra être joliment présenté en colonnes (indice : utilisez printf).
Certaines loteries demandent de choisir cinq numéros différents entre 1 et 50. Écrivez un script générant cinq numéros uniques pseudo-aléatoires à l'intérieur de cet intervalle. Le script donnera la possibilité d'afficher les nombres sur stdout ou de les enregistrer dans un fichier avec la date et l'heure de fabrication. (Au cas où votre script génèrerait des numéros gagnants de manière constante, vous pourrez alors prendre votre retraite grâce à vos développements, et laisser la programmation shell à ceux d'entre nous qui ont besoin de travailler pour vivre.)
Intermédiaire
Écrivez une fonction de script déterminant si un argument passé est un entier ou une chaîne. La fonction renverra TRUE (0) s'il s'agit d'un entier et FALSE (1) s'il s'agit d'une chaîne.
Astuce : que renvoie l'expression suivante quand $1 n'est pas un entier ?
expr $1 + 0
En C, la fonction atoi permet de convertir un caractère en un entier. Écrivez une fonction shell qui fait la même chose. De même, écrivez une fonctions shell qui fait l'inverse, comme la fonction C itoa qui convertit un entier en un caractère ASCII.
Listez, un par un, tous les fichiers faisant plus de 100 Ko dans l'arborescence du répertoire /home/utilisateur. Donnez à l'utilisateur la possibilité de supprimer ou de compresser le fichier, puis continuez en affichant le suivant. Écrivez un journal avec le nom de tous les fichiers supprimés et l'heure de leur suppression.
Simulez par un script le fonctionnement de la commande obsolète banner.
Les comptes inactifs sur un serveur connecté font perdre de l'espace disque et peuvent représenter un risque pour la sécurité. Écrivez un script d'administration (appelé par root ou par le démon cron) pour vérifier et supprimer les comptes utilisateurs qui n'ont pas été utilisés durant les 90 derniers jours.
Écrivez un script pour un système multi-utilisateurs vérifiant l'utilisation du disque par les utilisateurs. Si un utilisateur dépasse une limite fixée (par exemple 500 Mo) pour son répertoire personnel (/home/utilisateur), alors le script lui envoie automatiquement un message électronique d'avertissement pour « voracité ».
Ce script devra utiliser les commandes du et mail. En option, il permettra le réglage et l'application de quotas, en utilisant les commandes quota et setquota.
Pour tous les utilisateurs connectés, affichez leur noms réels et l'heure et la date de leur dernière connexion.
Astuce : utilisez who, lastlog et analysez /etc/passwd.
Implémenter, sous la forme d'un script, une commande « sécurisée » de suppression, sdel.sh. Les noms de fichiers passés en tant qu'arguments de la ligne de commande à ce script ne sont pas supprimés, mais, à la place, compressés avec gzip s'ils ne sont pas déjà compressés (utilisez file pour le vérifier), puis déplacés dans le répertoire ~/TRASH. Une fois lancé, le script vérifie si le répertoire ~/TRASH contient des fichiers datant de plus de 48 heures et les supprime de façon permanente. (Une meilleure solution serait peut-être d'écrire un deuxième script pour cette dernière tâche et de demander au démon cron de le lancer périodiquement.)
Crédit supplémentaire : Écrivez le script pour qu'il gère fichiers et répertoires récursivement. Ceci donnera la possibilité de « supprimer en toute sécurité » des structures complètes de répertoire.
Quel est le moyen le plus efficace de faire la monnaie sur 1,68 euros en utilisant seulement les pièces en circulation courante (jusqu'à 50 centimes) ? Ce sont trois pièces de 50 centimes, une de 10, une de 5 et trois de un.
À partir d'une entrée arbitraire en ligne de commande en euros et centimes ($*.??), calculez la monnaie en utilisant le plus petit nombre de pièces. Si la monnaie de votre pays n'est pas l'euro, vous pouvez utiliser votre monnaie locale à la place. Le script devra analyser l'entrée en ligne de commande, puis la modifier en multiple de la plus petite unité monétaire (centime ou autre). Indice : jetez un oeil sur l'Exemple 24.8, « Convertir des nombres en chiffres romains ».
Résolvez une équation du second degré, de la forme Ax^2 + Bx + C = 0. Créez un script qui prend en argument les coefficients A, B et C, et renvoie les solutions avec cinq chiffres après la virgule.
Indice : envoyez les coefficients via un tube à bc en utilisant la formule bien connue x = ( -B +/- sqrt( B^2 - 4AC ) ) / 2A.
A l'aide des commandes bc et printf, affichez en un tableau joliment présenté, avec 8 chiffres significatifs, les logarithmes népériens des nombres décimaux allant de 0 et 100 avec un pas de 0,01.
Conseil : il faut utiliser bc avec l'option -l pour charger les fonctions mathématiques.
En vous basant sur Exemple T.1, « Un script qui génère une table ASCII », composez un script qui écrit sur un fichier une table Unicode complète.
Indice : utilisez l'option -e de echo : echo -e '\uXXXX', où XXXX et la désignation numérique du caractère Unicode. Pour cet exercice, il faut Bash version 4.2 ou plus.
Trouvez la somme de tous les nombres de cinq chiffres (dans l'intervalle 10000-99999) contenant exactement deux des chiffres de l'ensemble suivant : { 4, 5, 6 }. Ils peuvent se répéter à l'intérieur du même nombre et, dans ce cas, décomptés à chaque fois.
Quelques exemples de nombres correspondants : 42057, 74638 et 89515.
Un nombre porte-bonheur est un nombre tel que la somme de ses chiffres est égale à 7, ou à un nombre dont la somme des chiffres est elle-même égale à 7, etc... Par exemple, 62431 est un nombre porte-bonheur (6 + 2 + 4 + 3 + 1 = 16 et 1 + 6 = 7). Trouvez tous les nombres porte-bonheur entre 1000 et 10000.
En empruntant les images ASCII sur Exemple A.40, « Pétales autour d'une rose », écrivez un script qui joue au jeu de craps [ NDLR un jeu de casino américain]. Ce script doit prendre les paris d'un ou plusieurs joueurs, lancer les dés et tenir le registre des gains et des pertes ainsi que la situation financière de chaque joueur.
Écrivez un script capable de jouer au tic-tac-toe (morpion sur une grille de 3x3) avec un adversaire humain. Le script doit demander d'abord au joueur humain de choisir qui va commencer, et suivre une stratégie optimale pour ne jamais perdre. Pour simplifier, vous pouvez utiliser les images ASCII :
o | x |
----------
| x |
----------
| o |
À votre tour, adversaire humain : rangée ou
colonne ?
Classez par ordre alphabétique (suivant l'ordre ASCII) une chaîne de caractères arbitraire lue sur la ligne de commande.
Analysez /etc/passwd et affichez son contenu sous forme d'un tableau joliment présenté et agréable à lire.
Analyser /var/log/messages pour produire un fichier joliment formaté des connexions des utilisateurs avec l'heure de connexion. Le script peut devoir se lancer en tant que root (conseil : cherchez la chaîne « LOGIN »).
Certaines bases de données et tableurs utilisent un format de sauvegarde sous forme de texte séparé par des virgules, couramment appelé comma-separated values ou CSV. D'autres applications ont souvent besoin d'analyser de tels fichiers.
À partir d'un fichier de données au format CSV, de la forme :
Dupont,Pierre,235 S. Williams St.,Denver,CO,80221,(303) 244-7989
Smith,Tom,404 Polk Ave.,Los Angeles,CA,90003,(213) 879-5612
...
Reformatez les données et affichez-les sur stdout en colonnes de même largeur, munies d'un titre.
À partir d'une entrée texte au format ASCII provenant soit de stdin soit d'un fichier, justifiez à droite chaque ligne suivant une longueur de ligne spécifiée par l'utilisateur en ajustant l'espacement entre les mots et envoyez la sortie sur stdout.
En utilisant la commande mail, écrivez un script gérant une liste de diffusion simple. Le script envoie automatiquement par courrier électronique la lettre d'informations mensuelle de la compagnie, lue à partir d'un fichier texte spécifié aux adresses de la liste de diffusion que le script lit à partir d'un autre fichier spécifié.
Générez des mots de passe de huit caractères pseudo-aléatoires en utilisant les caractères contenus dans les intervalles [0-9], [A-Z], [a-z]. Chaque mot de passe doit contenir au moins deux chiffres.
Vous suspectez une utilisatrice en particulier, sur le réseau, d'abuser de ses droits et peut-être de tenter de corrompre le système. Écrivez un script qui surveille et trace automatiquement son activité de la semaine et supprime les entrées qui datent de plus de sept jours.
Vous pouvez utiliser last, lastlog et lastcomm pour vous aider dans la surveillance de ce diable en puissance.
En utilisant lynx avec l'option -traversal, écrivez un script qui vérifie les liens cassés d'un site web.
Difficile
Écrire un script pour vérifier et valider les mots de passe. Le but est de marquer les candidats « faibles » ou facilement devinables.
Un mot de passe en test sera en entrée du script via un paramètre de la ligne de commande. Pour être considéré comme acceptable, un mot de passe doit satisfaire les qualifications minimums suivantes :
Longueur minimum de huit caractères
Contenir au moins un caractère numérique
Contenir au moins un caractère non alphabétique, numérique et figurant : @, #, $, %, &, *, +, -, =
Optionnel :
Faire une vérification de type dictionnaire sur chaque séquence d'au moins quatre caractères consécutifs du mot de passe en test. Ceci éliminera les mots de passe contenant des « mots » disponibles dans un dictionnaire standard.
Autoriser le script à vérifier tous les mots de passe du système, sachant qu'ils ne se trouvent pas dans /etc/passwd.
Cet exercice a pour but de tester la maîtrise des expressions rationnelles.
Écrire un script qui génère une référence croisée (une concordance) sur un fichier cible. La sortie sera un listing de toutes les occurrences de mots dans le fichier cible avec les numéros de ligne où ils apparaissent. Habituellement, la syntaxe de liste liée est utilisée dans un tel cas. Du coup, vous avez intérêt à utiliser des tableaux pour cet exercice. Exemple 16.12, « Analyse de fréquence d'apparition des mots » n'est probablement pas un bon début.
Écrire un script qui calcule les racines carrées de nombres en utilisant la méthode de Newton.
L'algorithme pour cela, exprimé en pseudo-code Bash, est le suivant :
# Méthode d'Isaac Newton pour une extraction rapide #+ des racines carrées. tentative = $argument # $argument est le nombre dont on veut trouver la racine carrée. # $tentative est la tentative calculée -- ou une solution triviale -- #+ de la racine carrée. # Notre première tentative de racine carrée est l'argument lui-même. ancienne_tentative = 0 # $ancienne_tentative est l'ancien $tentative. tolerance = .000001 # La tolérance acceptée pour notre calcul. nb_boucles = 0 # Gardons trace du nombre de fois passé dans la boucle. # Certains arguments demanderont plus d'itérations que d'autres. while [ ABS( $tentative $ancienne_tentative ) -gt $tolerance ] # ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ Corrigez la syntaxe. # "ABS" est une fonction à virgule flottante pour trouver la valeur absolue #+ de la différence entre les deux termes. # Donc, tant que la différence entre la solution actuelle et ancienne #+ ne dépasse pas la tolérance, on continue. do ancienne_tentative = $tentative # Met $ancienne_tentative avec la valeur de $tentative. # ======================================================= tentative = ( $ancienne_tentative + ( $argument / $ancienne_tentative ) ) / 2.0 # = 1/2 ( ($ancienne_tentative **2 + $argument) / $ancienne_tentative ) # équivalent à : # = 1/2 ( $ancienne_tentative + $argument / $ancienne_tentative ) # c'est-à-dire une moyenne de la solution tentée et la proportion d'une déviation #+ de l'argument #+ (donc division par deux de l'erreur). # Ceci converge sur une solution précise #+ avec étonnament peu d'itérations de boucle... #+ pour arguments > $tolerance, bien sûr. # ======================================================= (( nb_boucles++ )) # Mise à jour du compteur de boucle. done
C'est une recette assez simple et dont la conversion en Bash semble au premier regard être assez facile. Cela étant dit, le problème est que Bash n'a pas de support natif pour les nombres à virgules flottantes. Donc, le rédacteur du script aura besoin d'utiliser bc ou peut-être awk pour convertir les nombres et faire les calculs. Ça peut donner un gros bazar...
Tracez tous les accès aux fichiers dans /etc sur une journée. Ce journal devra inclure le nom du fichier, le nom de l'utilisateur et l'heure d'accès. Vous indiquerez si le fichier a été modifié. Écrivez toute cette information dans un fichier journal, sous forme d'une suite d'enregistrements clairement séparés par des tablutations.
Écrivez un script pour tracer de façon continue tous les processus en cours d'exécution et pour garder trace de tous les processus fils que chaque parent lance. Si un processus lance plus de cinq fils, alors le script envoie un mail à l'administrateur système (ou root) avec toutes les informations intéressantes, ceci incluant l'heure, le PID du père, les PID des enfants, etc. Le script ajoute un rapport dans un journal toutes les dix minutes.
Supprimez tous les commentaires d'un script shell dont le nom est spécifié en ligne de commande. Remarque : la ligne en #! initiale ne doit pas subir le même traitement.
Supprimez toutes les balises HTML d'un fichier, puis reformatez-le en lignes de 60 à 75 caractères de longueur. Réajustez les espacements de paragraphes et de blocs de façon appropriée, et convertissez les tables HTML en leur équivalent texte approximatif.
Convertissez un fichier XML à la fois en HTML et en texte.
En option : un script qui convertit Docbook/SGML en XML.
Écrivez un script qui analyse un courrier électronique spam en faisant des recherches DNS à partir de l'adresse IP spécifiée dans les en-têtes pour identifier les hôtes relais ainsi que le fournisseur d'accès internet (FAI) d'origine. Le script renverra le message de spam non modifié aux FAI responsables. Bien sûr, il sera nécessaire de filtrer les adresses IP de votre propre FAI si vous ne voulez pas vous plaindre de vous-même.
Si nécessaire, utilisez les commandes d'analyse réseau appropriées.
Pour quelques idées, voir l'Exemple 16.41, « Analyser le domaine d'un courrier indésirable » et l'Exemple A.28, « Identification d'un spammer ».
En option : écrire un script qui recherche dans une liste de mails et supprime le pourriel suivant des filtres spécifiés.
Écrire un script automatisant le processus d'écriture de pages man.
Avec un fichier texte contenant l'information à formater en une page man, le script lira le fichier puis les commandes groff appropriées pour sortir les pages man sur stdout. Le fichier texte contient des blocs d'information sous des en-têtes standards pour en-têtes de pages man, c'est-à-dire NAME, SYNOPSIS, DESCRIPTION, etc.
Exemple A.39, « Éditeur de man page » est une première étape intéressante.
Fabriquez une sortie hexadécimale à partir d'un fichier binaire fourni en argumentau script. La sortie devra présentée joliment en tableau, le premier champ indiquant l'adresse, chacun des huit champs suivants un nombre hexa de quatre octets, et le dernier champ sera l'équivalent ASCII des huit champs précédents.
La suite évidente est d'étendre la sortie hexadécimal à un désassembleur. En utilisant une table de recherche ou une autre astuce, convertir les valeurs hexadécimales en jeu d'instructions pour x86.
En s'inspirant de l'Exemple 27.14, « Émuler une pile », écrivez un script qui émule un registre à décalage de 64 bits par un tableau. Implémentez des fonctions pour charger le registre, décaler à gauche, décaler à droite et faire une rotation. Enfin, écrivez une fonction qui interprète le contenu du registre comme huit caractères ASCII sur 8 bits.
Écrivez un script de résolution de déterminants [150] en étendant le calcul à partir des sous-déterminants, de manière récursive. Utilisez un déterminant 4 x 4 comme cas de test.
Écrivez un générateur de puzzle de « recherche de mots », un script qui cache dix mots (fournis en entrée) dans un tableau de 10 x 10 lettres choisies au hasard. Ces mots peuvent être cachés horizontalement, verticalement, ou en diagonale.
Question supplémentaire : écrivez un script qui résout des puzzles de mots. Pour que cela ne devienne pas trop complexe, le script trouvera seulement les mots horizontaux et verticaux (astuce : traitez chaque ligne et colonne comme une chaîne et cherchez les sous-chaînes).
Faites un anagramme des quatre lettres d'entrée. Par exemple, les anagrammes de word sont : do or rod row word. Vous pouvez utiliser /usr/share/dict/linux.words comme liste de référence.
Une « suite de mots » est une séquence de mots, chacun différant du précédent d'une seule lettre.
Par exemple, pour faire « suivre » vase à mark :
mark --> park --> part --> past --> vast --> vase
^ ^ ^ ^ ^
Écrivez un script résolvant des puzzles de type « suite de mots ». Étant donné un mot de départ et un mot de fin, le script donnera toutes les étapes intermédiaires de la « suite ». Notez que tous les mots de la séquence doivent être des mots existants dans le dictionnaire.
L'« index brouillard » d'un passage de texte permet d'estimer sa difficulté de lecture, par un nombre correspondant grossièrement à un niveau d'école. Par exemple, un passage d'index 12 devrait être compréhensible par toute personne ayant plus de 12 ans d'école.
La version 'Gunning' de cet index utilise l'algorithme suivant.
Choisissez une section de texte d'au moins 100 mots de longueur.
Comptez le nombre de phrases (une portion d'une phrase tronquée par les limites de la section de texte compte pour un).
Trouvez le nombre moyen de mots par phrase.
MOY_MOT_PHRASE = TOTAL_MOTS / PHRASES
Comptez le nombre de mots « difficiles » dans le segment -- ceux contenant au moins trois syllabes. Divisez cette quantité par le nombre total de mots pour obtenir la proportion de mots difficiles.
PRO_MOTS_DIFFIC = MOTS_LONGS / TOTAL_MOTS
L'index 'Gunning' est la somme des deux quantités ci-dessus, multiplié par 0,4, arrondie à l'entier le plus proche.
G_FOG_INDEX = int ( 0.4 * ( MOY_MOT_PHRASE + PRO_MOTS_DIFFIC ) )
L'étape 4 est de loin la partie la plus difficile de cet exercice. Il existe différents algorithmes pour estimer le nombre de syllabes dans un mot. Un moyen empirique consiste à considérer le nombre de lettres dans un mot et le mélange voyelles - consonnes.
Une stricte interprétation de l'index 'Gunning' ne compte pas les mots composés et les noms propres comme des mots « difficiles », mais cela compliquerait considérablement le script.
Le mathématicien français du 18è siècle Buffon inventa une expérience. Lâchez de manière répétée une aiguille de longueur n sur un sol en bois composé de planches longues et étroites. Les trous séparant les planches de largeur égale sont à une distance fixe d les uns des autres. Notez le nombre de lâchés et le nombre de fois où l'aiguille traverse une fente de parquet. Il se trouve que le rapport de ces deux nombres est un multiple fractionnel de PI.
Dans l'esprit de l'Exemple 16.50, « Calculer PI », écrivez un script qui lance une simulation de Monte Carlo de l'aiguille de Buffon. Pour simplifier le problème, initialisez la longueur de l'aiguille à la distance entre les fentes, n = d.
Indice : il y a en fait essentiellement deux variables : la distance du centre de l'aiguille à la fente la plus proche et l'angle d'inclinaison de l'aiguille par rapport à la fente. Vous pouvez utiliser bc pour réaliser les calculs.
Implémentez l'encodage Playfair (Wheatstone) dans un script.
La méthode Playfair encode le texte par substitution de chaque diagramme (groupe de deux lettres). En général, on utilise un carré de cinq lettres sur cinq composant un alphabet pour l'encodage et le décodage.
C O D E S A B F G H I K L M N P Q R T U V W X Y Z Chaque lettre de l'alphabet apparaît une fois. Le I représente aussi le J. Le mot clé choisi arbitrairement, "CODES" vient en premier, ensuite le reste de l'alphabet, de gauche à droite, en évitant les lettres déjà utilisées. Pour crypter, séparez le message texte en groupes de deux lettres. Si un groupe a deux lettres identiques, supprimez la seconde et formez un nouveau groupe. Si il reste une seule lettre à la fin, insérez le caractère "null", typiquement un "X". THIS IS A TOP SECRET MESSAGE TH IS IS AT OP SE CR ET ME SA GE Pour chaque digramme, il existe trois cas. ------------------------------------------ 1) Les deux lettres sont sur la même ligne du carré : remplacez chaque lettre par celle située immédiatement à droite sur la ligne. Si nécessaire, retournez au début de la ligne. ou 2) Les deux lettres sont dans la même colonne du carré : remplacez chaque lettre par celle située immédiatement en dessous dans la colonne. Si nécessaire, retournez en haut de la colonne. ou 3) Les deux lettres forment les coins d'un rectangle à l'intérieur du carré : remplacez chaque lettre par celle située sur la même rangée, dans l'autre coin du même rectangle. Le groupe "TH" fait partie du cas #3. G H M N T U (Rectangle avec "T" et "H" aux coins) T --> U H --> G Le groupe "SE" fait partie du cas #1. C O D E S (Ligne contenant "S" et "E") S --> C (on retourne au début de la ligne) E --> S ========================================================================= Pour décrypter un texte, inversez la procédure ci-dessus pour #1 et #2 (déplacez-vous dans la direction opposée pour la substitution). Pour le cas #3, prenez juste les deux coins restants du rectangle. L'ouvrage classique d'Helen Fouche Gaines, ELEMENTARY CRYPTANALYSIS (1939), fournit une description détaillée de l'encodage Playfair avec ses méthodes de résolution.
Ce script aura trois sections principales
Génération du carré clé basé sur un mot-clé saisi par l'utilisateur.
Encodage d'un message texte.
Décodage du texte encodé.
Ce script utilisera de façon poussée les tableaux et les fonctions. Vous pouvez vous inspirer de Exemple A.55, « L'algorithme de chiffrement de Cronsfeld ».
--
Merci de ne pas envoyer à l'auteur vos solutions aux exercices. Il y a d'autres façons plus appropriées de l'impressionner par votre intelligence : il vaut bien mieux par exemple lui envoyer des corrections de bogues ou des suggestions d'amélioration.
[150] Pour vous les personnes intelligentes qui ont échoué en 2ème année d'algèbre : un déterminant est une valeur numérique associée à une matrice multi-dimensionnelle (tableau de nombres).
Pour le cas simple du déterminant 2 x 2 : |a b| |b a| La solution est a*a - b*b, où "a" et "b" représentent des nombres.