Delphi Template

Arpanet
921 views

Open Source Your Knowledge, Become a Contributor

Technology knowledge has to be shared and made accessible for free. Join the movement.

Create Content

Bienvenue au tutoriel Delphi pour codingame !

Ce tutoriel a pour but de vous rappeler quelques principes de base de la programmation Pascal Delphi, ainsi que le fonctionnement d'une classe particulièrement utile dans les exercices codingame (TStringList).

Vous pouvez tester les exemples ci-dessous en les recopiant dans la fenêtre ci-dessous et en cliquant sur Run.

Quelques rappels du Pascal

  • Pascal est case insensitive donc la variable Liste est la même que LISTE et la même que liste
  • les instructions sont séparées par des ;
  • tout ce qui est après // sur une ligne est un commentaire (sauf à l'intérieur d'une chaîne de caractères)
  • l'opérateur d'affectation est :=
  • l'opérateur de comparaison est =
  • les variables doivent être déclarées dans une section var avant d'être utilisées dans la section begin...end et ça vaut même pour les indices de boucle !
  • le type charactère est char (c'est un type sur 8 bits, vous n'aurez pas besoin du type WideChar sur 16 bits) pour les exercices
  • les chaînes de caractères litérales sont entre ' et pas entre "
  • l'opérateur de concaténation de chaînes de caractères est +
writeln('La valeur de NOM est ' + NOM);
  • la fonction Chr(n) permet d'obtenir le char de code n
writeln(Chr(97));
  • la fonction Ord('x') permet d'obtenir le code du char 'x'
writeln(IntToStr(Ord('a')));
  • la fonction IntToStr(N) permet d'obtenir la chaîne de caractères contenant la réprésentation décimale de l'entier N ; la fonction StrToInt(S) permet d'obtenir la valeur décimale de l'entier dont la chaîne S contient la représentation décimale (vous devez ajouter uses sysutils; au début de votre programme avant d'utiliser ces fonctions)
  • l'instruction break permet d'interrompre la boucle directement englobante

Un peu plus Delphi

Pour être plus proche du Delphi vous devez ajouter la directive suivante au début du programme :

{$MODE DELPHI} 

Pour lire sur l'entrée standard

La procédure readln permet de lire une ligne sur l'entrée standard et la retourne dans la variable passée en paramètre

var
  Line : String;
begin
  readln(Line);
end;

Pour écrire sur les sorties standards

La procédure writeln permet d'écrire une ligne sur les sorties standard StdOut (par défaut) et StdErr :

writeln('Résultat sur StdOut');
writeln(StdErr, 'trace sur StdErr');

Quelques fonctions opérant sur des chaînes de caractères

  • la fonction LeftStr(const S: string; Count: Integer): string; retourne une chaîne contenant les Count premiers caractères de S
  • la fonction RightStr(const S: string; Count: Integer): string; retourne une chaîne contenant les Count derniers caractères de S
  • la fonction Trim(const S: string): string; retourne une chaîne copie de S en enlevant les espaces (et caractères de contrôle) au début et à la fin de S
  • la fonction LeftTrim(const S: string): string; retourne une chaîne copie de S en enlevant les espaces (et caractères de contrôle) au début de S
  • la fonction RightTrim(const S: string): string; retourne une chaîne copie de S en enlevant les espaces (et caractères de contrôle) à la fin de S
var
  S : string ;
begin
  S := '  Y2 for ever  !    ';
  writeln(LeftStr(Trim(S),2)); // Y2
end;

Les tableaux

  • la déclaration d'un tableau statique
var
   Nombres : array[1..10] of Integer;
  • la sélection d'un élément se fait avec l'indice entre crochets []
begin
   Nombres[5] := 5000;
   writeln("Nombres[5] contains " + IntToStr(Nombres[5]));
   ...
end;
  • la fonction Length retourne le nombre d'éléments du tableau
   writeln(IntToStr(Length(Nombres)));
  • la déclaration d'un tableau dynamique dont la taille est définie ou modifiée avec la procédure SetLength et dont l'index va de 0 à Length()-1
var
   Nombres : array of Integer;
   I       : Integer;
begin
   SetLength(Nombres, 10);
   for I := 0 to Length(Nombres)-1 do
   begin
      Nombres[I] := I;
   end;
end;

Le couteau suisse : TStringList

Vous aurez rapidement besoin d'une structure flexible de type hashmap ou dictionnaire clé/valeur. En Delphi vous pouvez utiliser TStringList pour remplir ce rôle de couteau suisse. Cette classe est très riche mais voici quelques cas d'usage simples à connaître :

  • n'oubliez pas le uses classes; en début de votre programme pour avoir accès à ces classes
  • avant l'ajout du premier élément, la structure doit être initialisée avec la fonction TStringList.Create() et lorsqu'elle n'est plus utilisée la mémoire allouée doit être libérée en utilisant la méthode Free.
  • la méthode Add ajoute une chaîne à la liste
  • la propriété Count retourne le nombre de chaînes dans la liste
  • la fonction IndexOf retourne l'indice (base 0) de la chaîne dans la liste ou -1 si elle n'est pas dans la liste
  • les [] permettent d'accéder à la chaîne à un indice donné (comme dans un tableau dynamique avec indice base 0)
  • la propriété Text (resp. CommaText) retourne une chaîne contenant toutes les chaînes de la liste séparées par des '\n' (resp. ','), et peut même être utilisée pour initialiser la liste mais cela dépasse le cadre de ce simple tuto
uses classes, sysutils;
var
   Dict : TStringList;
begin
   Dict := TStringList.Create();
   Dict.Add('Un');
   Dict.Add('Deux');
   Dict.Add('Trois');
   writeln('Deux est en position : ' + IntToStr(Dict.IndexOf('Deux')));
   writeln('A la position 0 il y a : ' + Dict[0]);
   writeln(Dict.Text);
   Dict.Free;
end;

Documentation complémentaire

Pour expérimenter

Vous pouvez éditer la zone ci-dessous, et copier/coller les exemples et les exécuter :

Run
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
{$MODE DELPHI}
uses sysutils, classes;
var
Dict : TStringList;
I : Integer;
begin
Dict := TStringList.Create();
Dict.Add('Un');
Dict.Add('Deux');
Dict.Add('Trois');
writeln('Deux est en position : ' + IntToStr(Dict.IndexOf('Deux')));
writeln('A la position 0 il y a : ' + Dict[0]);
// write content on StdErr
writeln(StdErr, '--------------');
write(StdErr, Dict.Text);
writeln(StdErr, '--------------');
// write content on StdOut
for I := 0 to Dict.Count-1 do
writeln(Dict[i]);
Dict.Free;
end.
XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX
Open Source Your Knowledge: become a Contributor and help others learn. Create New Content