Programmation .NET/Internationalisation
L'internationalisation d'une application permet à celle-ci de s'adapter selon la langue et le pays de l'utilisateur :
Interface graphique.
L'internationalisation de l'interface graphique est la toute dernière phase du développement, lorsque tous les éléments de l'interface sont définitivement au point.
Cependant, en prévision, il faut laisser suffisamment de place pour les textes qui peuvent prendre plus de place une fois traduit.
Sous Visual Studio .Net, pour adapter chaque "form" à la langue de l'utilisateur :
Visual Studio .Net créera alors un fichier de ressources par langue sélectionnée, dont le nom est de la forme : "nom_de_form"."code_langue".resx
Pour ajouter de nouveaux contrôles à une "form", il faut sélectionner la langue codice_4 dans la propriété codice_3 de la "form" concernée.

Programmation algorithmique/Listes simplement chaînées

"à étoffer, clarifier, reformuler, etc..."
Une liste simplement chaînée est une structure de données pouvant contenir plusieurs éléments. Chaque élément possède un pointeur vers l'élément suivant. La liste est un pointeur vers le premier élément de la liste. Le dernier élément pointe vers une adresse spécifique (notée NIL) pour signifier la fin de la liste.
La clef d'un élément est d'un type quelconque. On peut ajouter des informations "utiles" aux éléments.
 ELEMENT : ENREGISTREMENT
 CLEF
 SUIVANT : ELEMENT
 FIN ENREGISTREMENT
 LISTE : ENREGISTREMENT
 TETE : ELEMENT
 FIN ENREGISTREMENT
Recherche dans une liste chaînée.
Recherche d'un élément ayant une clé CLEF dans une liste.
Complexité : O(N)
 FONCTION SIMPLE_LISTE:RECHERCHER(LISTE, CLEF)
 ELEMENT = LISTE.TETE
 TANT QUE ELEMENT <> NIL ET ELEMENT.CLEF <> CLEF
 ELEMENT = ELEMENT.SUIVANT
 FIN TANT QUE'
 RETOURNER ELEMENT
 FIN FONCTION
Recherche de l'élément suivant un élément ELEMENT dans une liste.
Complexité : O(1)
 FONCTION SIMPLE_LISTE:SUIVANT(LISTE, ELEMENT)
 RETOURNER ELEMENT.SUIVANT
 FIN FONCTION
Recherche de l'élément précédent un élément ELEMENT dans une liste.
Complexité : O(N)
 FONCTION SIMPLE_LISTE:PRECEDENT(LISTE, ELEMENT)
 ELEMENT_COURANT := LISTE.TETE
 TANT QUE ELEMENT_COURANT != NIL ET ELEMENT_COURANT.SUIVANT != ELEMENT
 ELEMENT_COURANT := ELEMENT_COURANT.SUIVANT
 FIN TANT QUE
 RETOURNER ELEMENT_COURANT
 FIN FONCTION
Itération contre récursion.
De nombreux problèmes sur les listes chaînées peuvent se traiter aussi bien de façon itérative (à l'aide de boucles) que de façon récursive (à l'aide d'appels récursifs de fonctions). 
La récursion (ou récursivité) se rattache plus à l'algorithmique fonctionnelle qu'à l'algorithmique impérative. 
Toutefois, les langages impératifs offrent souvent la possibilité de programmer par récursion, alors il est intéressant de choisir entre itération et récursion en toute connaissance de cause.
Voici donc un exemple d'algorithme utilisant la récursion, il s'agit de rechercher un élément dans une liste, comme plus haut.
Recherche d'un élément ayant une clé CLEF dans une liste (version récursive).
Complexité en temps: O(N). Complexité en espace : O(N) ou O(1) selon le support d'exécution.
 FONTION SIMPLE_LISTE: RECHERCHE(LISTE,CLEF)
 RETOURNER RECH_REC(LISTE.TETE)
 FIN FONCTION
 FONCTION SIMPLE_LISTE: RECH_REC(ELEMENT, CLEF)
 SI ELEMENT = NIL OU ELEMENT.CLEF = CLEF 
 ALORS RETOURNER ELEMENT
 SINON RETOURNER RECH_REC(ELEMENT.SUIVANT)
 FIN FONCTION
On notera que dans cet exemple on ne trouve ni affectation (ou assignation), ni séquence (succession inconditionnelle de deux instructions). Il s'agit donc bien d'un algorithme fonctionnel.
Selon le langage et le compilateur utilisé pour réaliser cet algorithme, les appels récursifs successifs seront stockés ou non en mémoire. On parle de pile d'appels récursifs. Dans le cas où le support d'exécution (c'est à dire l'interprète ou le code compilé) utilise une pile d'appels récursifs pour exécuter la fonction RECH_REC, la complexité en espace sera O(N), car pour chaque élément de la liste, on devra stocker en mémoire, sur la pile, l'information sur l'appel en cours. Dans le second cas, où le compilateur est capable de générer du code qui utilise un espace limité sur la pile, la complexité en espace sera O(1), comme pour la version itérative. 
À titre d'exemple, le compilateur GCC est capable de compiler certaines fonctions récursives écrites en C pour qu'elles utilisent un espace constant sur la pile, alors que l'interprète standard du langage Python empile systématiquement les appels récursifs.
Insertion.
Insertion d'un élément NOUVEL_ELEMENT en début de liste.
Complexité O(1)
 FONCTION SIMPLE_LISTE:INSERER_DEVANT(LISTE, NOUVEL_ELEMENT)
 ELEMENT := LISTE.TETE
 LISTE.TETE := NOUVEL_ELEMENT
 NOUVEL_ELEMENT.SUIVANT = ELEMENT
 FIN FONCTION
Insertion d'un élément NOUVEL_ELEMENT dans une liste après un élément ELEMENT.
Complexité : O(1)
 FONCTION SIMPLE_LISTE:INSERER_APRES(LISTE, ELEMENT, NOUVEL_ELEMENT)
 SI LISTE.TETE = NIL ALORS
 LISTE.TETE := NOUVEL_ELEMENT
 NOUVEL_ELEMENT.SUIVANT = NIL
 SINON
 NOUVEL_ELEMENT.SUIVANT := ELEMENT.SUIVANT
 ELEMENT.SUIVANT := NOUVEL_ELEMENT
 FIN SI
 FIN FONCTION
Insertion d'un élément NOUVEL_ELEMENT dans une liste avant un élément ELEMENT.
Complexité : O(N)
 FONCTION SIMPLE_LISTE:INSERER_AVANT(LISTE, ELEMENT, NOUVEL_ELEMENT)
 ELEMENT_PRECEDENT := SIMPLE_LISTE:PRECEDENT(LISTE, ELEMENT)
 SI ELEMENT_PRECEDENT = NIL ALORS
 LISTE.TETE := NOUVEL_ELEMENT
 NOUVEL_ELEMENT.SUIVANT := ELEMENT
 SINON
 ELEMENT_PRECEDENT.SUIVANT := NOUVEL_ELEMENT
 NOUVEL_ELEMENT.SUIVANT := ELEMENT
 FIN SI
 FIN FONCTION
Suppression.
Suppression d'un élément ELEMENT_SUPPRIME d'une liste.
Complexité : O(N)
 FONCTION SIMPLE_LISTE:SUPPRIMER(LISTE, ELEMENT_SUPPRIME)
 ELEMENT_PRECEDENT := SIMPLE_LISTE:PRECEDENT(LISTE, ELEMENT_SUPPRIME)
 SI ELEMENT_PRECEDENT != NIL ALORS
 ELEMENT_PRECEDENT.SUIVANT := ELEMENT_SUPPRIME.SUIVANT
 SINON
 LISTE.TETE := ELEMENT_SUPPRIME.SUIVANT
 FIN SI
 FIN FONCTION

Enseignement du roumain
La langue roumaine (limba română /'limba ro'mɨnə/) est une langue appartenant au groupe des langues romanes orientales de la branche romane de la famille des langues indo-européennes. Il est parlé par plus de 30 millions de locuteurs, principalement en Roumanie et en République de Moldavie (sous le nom de moldave).
Une grande partie du vocabulaire roumain de base est issue directement du latin (75% du vocabulaire total). Mais il existe également un substrat thrace - ~60 ou 300 mots - antérieur à la conquête romaine (voir Origine du peuple roumain), un superstrat slave - 10% ou 20% des mots, et un apport de mots français entre 1850 et 1950 encore plus superficiel que le superstrat slave. Le fond de base est latin avec des influences multiples. Pourtant les mots latins ont évolué différemment que dans la branche occidentale des langues romanes.
Par rapport aux autres langues latines, le roumain est "asymétrique": il est très facile pour un Roumain de comprendre l'italien, le français et l'espagnol, mais l'inverse n'est pas le cas en raison des influences slaves et de mutations phonétiques multiples.
L'orthographe du roumain est, à l'instar de celle de l'italien, très simple, car phonétique : à chaque phonème correspond une lettre. Pour des phonèmes que d'autres langues écrivent avec plusieurs lettres, le roumain utilise des diacritiques. Il y a cependant quelques exceptions : les sons /ke/, /ki/, /ge/ et /gi/ s'écrivent che, chi, ghe et ghi - trois lettres pour seulement deux phonèmes.

Programmation C sharp/Version imprimable

Programmation algorithmique/Listes doublement chaînées