{ Initialisation a vrai d'un tableau          }
{ de 8 booleens                               }

action principale()
  locales
    tb : Tableau[8] de booleen
    i : entier
  pour i de 0 à 7 faire
    tb[i] <- vrai
  fait
fin action

{ Initialisation d'un tableau d'entiers       }
{ avec les 50 premieres valeurs de factoriel  }

constante entier N <- 50

action principale()
  locales
    tb : Tableau[N] de entier
    i : entier
  tb[0] <- 1
  pour i de 1 à N-1 faire
    tb[i] <- tb[i-1]*i
  fait
  pour i de 0 à N-1 faire
    Ecran.afficher(tb[i])
    Ecran.sautDeLigne()
  fait
fin action

{ Initialisation d'un damier de jeu de dames  }
{  - 'B' pour pion blanc                      }
{  - 'N' pour pion blanc                      }
{  - '.' pour case vide                       }
{ Affichage du tableau apres initialisation   }

action principale()
  locales
    damier : Tableau[10][10] de caractere
    i,j : entier
  pour i de 0 à 9 faire
    pour j de 0 à 9 faire
      damier[i][j] <- '.'
    fait
  fait
  pour i de 0 à 8 pas 2 faire
    damier[i][0] <- 'N'
    damier[i+1][1] <- 'N'
    damier[i][2] <- 'N'
    damier[i+1][3] <- 'N'
    damier[i][6] <- 'B'
    damier[i+1][7] <- 'B'
    damier[i][8] <- 'B'
    damier[i+1][9] <- 'B'
  fait
fin action

/* Initialisation a vrai d'un tableau          */
/* de 8 booleens                               */

public class InitialisationTableauBoolean {

/* Programme principal                         */

  public static void main(String [] args) {
    boolean [] tn = { true,true,true,true,
                      true,true,true,true };
    }
}

/* Initialisation d'un tableau d'entiers       */
/* avec les 50 premieres valeurs de factoriel  */

public class TableauFactoriels {

/* Programme principal                         */

  public static void main(String [] args) {
    final int N = 50;
    int [] tb = new int[N];
    int i;
    tb[0] = 1;
    for ( i = 1 ; i < N ; i = i+1 ) {
      tb[i] = tb[i-1]*i; }
    for ( i = 0 ; i < N ; i = i+1 ) {
      Ecran.afficher(tb[i]);
      Ecran.sautDeLigne(); }
  }
}

/* Initialisation d'un tableau d'entiers       */
/* avec les 50 premieres valeurs de factoriel  */

public class TableauFactorielsLong {

/* Programme principal                         */

  public static void main(String [] args) {
    final int N = 50;
    long [] tb = new long[N];
    int i;
    tb[0] = 1;
    for ( i = 1 ; i < N ; i = i+1 ) {
      tb[i] = tb[i-1]*i; }
    for ( i = 0 ; i < N ; i = i+1 ) {
      Ecran.afficher(tb[i]);
      Ecran.sautDeLigne(); }
  }
}

/* Initialisation d'un damier de jeu de dames  */
/* 'B' pour pion blanc                         */
/* 'N' pour pion blanc                         */
/* '.' pour case vide                          */
/* Affichage du tableau apres initialisation   */

public class TableauDamier {

/* Programme principal                         */

  public static void main(String [] args) {
    char [][] damier = new char[10][10];
    int i,j;
    for ( i = 0 ; i < 10 ; i = i+1 ) {
      for ( j = 0 ; j < 10 ; j = j+1 ) {
        damier[i][j] = '.'; } }
    for ( i = 0 ; i <= 8 ; i = i+2 ) {
      damier[i][0] = 'N';
      damier[i+1][1] = 'N';
      damier[i][2] = 'N';
      damier[i+1][3] = 'N';
      damier[i+1][9] = 'B';
      damier[i][8] = 'B';
      damier[i+1][7] = 'B';
      damier[i][6] = 'B'; }
    for ( i = 0 ; i < 10 ; i = i+1 ) {
      for ( j = 0 ; j < 10 ; j = j+1 ) {
        Ecran.afficher(damier[i][j]); }
      Ecran.sautDeLigne(); }
  }
}

constante entier N <- ???

{ Passage d'un tableau en parametre           }
{ Modification du tableau a l'interieur       }
{ de l'action                                 }
{ -> Modification du tableau sur lequel       }
{    l'action a ete appelee                   }

action testPassage(tab)
  Données / Résultats
    tab : Tableau [N] de entier
  Locales
    i : entier
  pour i de 0 à N-1 faire
    Ecran.afficher(tab[i]," ")
  fait
  Ecran.sautDeLigne()
  pour i de 0 à N-1 faire
    tab[i] <- 9
  fait
  pour i de 0 à N-1 faire
    Ecran.afficher(tab[i]," ")
  fait
  Ecran.sautDeLigne()
fin action

{ Retour d'un tableau par une fonction        }
{ apres declaration et initialisation         }
  
Tableau [N] de entier fonction testRetour()
  Locales
    tab : Tableau [N] de entier
  tab[0] <- 0
  tab[1] <- 0
  tab[2] <- 0
  tab[3] <- 0
  tab[4] <- 1
  tab[5] <- 1
  tab[6] <- 1
  tab[7] <- 1
  retourner tab
fin fonction

/* Test de l'utilisation des tableaux          */
/* en parametre de methode                     */

public class PassageTableauEnParametre {

/* Passage d'un tableau en parametre           */
/* Modification du tableau a l'interieur       */
/* de la methode                               */
/* -> Modification du tableau sur lequel       */
/*    la methode a ete appelee                 */
  
  static void testPassage(int [] tab) {
    int i;
    for ( i = 0 ; i < tab.length ; i = i+1 ) {
      Ecran.afficher(tab[i]," "); }
    Ecran.sautDeLigne();
    for ( i = 0 ; i < tab.length ; i = i+1 ) {
      tab[i] = 9; }
    for ( i = 0 ; i < tab.length ; i = i+1 ) {
      Ecran.afficher(tab[i]," "); }
    Ecran.sautDeLigne();
  }

/* Retour d'un tableau par une action          */
/* apres declaration et initialisation         */
  
  static int [] testRetour() {
    int [] tab = { 0,0,0,0,1,1,1,1 };
    return tab;
  }
  
/* Programme principal                         */

  public static void main(String [] args) {
    int i;
/* Test de la methode testPassage              */
    int [] t1 = { 0,1,2,3,4,5,6,7 };
    testPassage(t1);
    for ( i = 0 ; i < t1.length ; i = i+1 ) {
      Ecran.afficher(t1[i]," "); }
    Ecran.sautDeLigne();
    Ecran.sautDeLigne();
/* Test de la methode testRetour               */
    int [] t2;
    t2 = testRetour();
    for ( i = 0 ; i < t2.length ; i = i+1 ) {
      Ecran.afficher(t2[i]," "); }
    Ecran.sautDeLigne();
  }
}

{ Declaration d'un tableau de variables           }
{ de type agrege position en deux dimensions      }

structure position2D
  x : reel <- 0.0
  y : reel <- 0.0
fin structure

{ Programme principal                             }

constante entier TAILLE <- 10

action principale()
  locales
    i : entier
    tpos : Tableau[TAILLE] de position2D
  pour i de 0 à TAILLE-1 faire
    Ecran.afficherln(tpos[i].x," ",tpos[i].y)
  fait
  Ecran.afficherln()
fin action

/* Declaration de tableaux de variables            */
/* de type agrege position en deux dimensions      */

public class TableauPosition2D {
  
/* Type agrege de stockage d'une position du plan  */
  
  static class Position2D {
    double x = 0.0;
    double y = 0.0; };

/* Programme principal                             */

  public static void main(String [] args) {
    int i;
    final int TAILLE = 10;
  /* Declaration du tableau                        */
    Position2D [] tpos = new Position2D[TAILLE];
  /* Initialisation des composantes par programme  */
    for ( i = 0 ; i < TAILLE ; i++ )
      tpos[i] = new Position2D();
  /* ********************************************  */
    for ( i = 0 ; i < tpos.length ; i++ )
      Ecran.afficherln(tpos[i].x," ",tpos[i].y);
  }
}

{ Declaration d'un tableau de variables           }
{ de type agrege position en deux dimensions      }

structure position2D
  x : reel <- 0.0
  y : reel <- 0.0
fin structure

{ Action d'affichage d'une position 2D            }

action afficher(p)
  donnees
    p : position2D
  Ecran.afficherln("[",p.x,",",p.y,"]")
fin action

{ Programme principal                             }

constante entier TAILLE <- 10

action principale()
  locales
    i : entier
    tpos : Tableau[TAILLE] de position2D
  pour i de 0 à TAILLE-1 faire
    afficher(tpos[i])
  fait
  Ecran.afficherln()
fin action

/* Declaration de tableaux de variables            */
/* de type agrege position en deux dimensions      */

public class TableauPosition2Dv2 {
  
/* Type agrege de stockage d'une position du plan  */
  
  static class Position2D {
    double x = 0.0;
    double y = 0.0; };

/* Affichage d'une position 2D                     */
  
  static void afficher(Position2D p) {
    Ecran.afficherln("[",p.x,",",p.y,"]");
  }

/* Programme principal                             */

  public static void main(String [] args) {
    int i;
    final int TAILLE = 10;
  /* Declaration du tableau tpos1                  */
  /* avec intialisation de ses champs              */
  /* lors de la declaration                        */
    Position2D [] tpos1 = { new Position2D(),
                            new Position2D(),
                            new Position2D(),
                            new Position2D(),
                            new Position2D() };
  /* Declaration du tableau tpos2                  */
    Position2D [] tpos2 = new Position2D[TAILLE];
  /* Initialisation des composantes par programme  */
    for ( i = 0 ; i < TAILLE ; i++ )
      tpos2[i] = new Position2D();
  /* ********************************************  */
    for ( i = 0 ; i < tpos1.length ; i++ )
      afficher(tpos1[i]);
    Ecran.sautDeLigne();
    for ( i = 0 ; i < tpos2.length ; i++ )
      afficher(tpos2[i]);
    Ecran.afficherln();
  }
}

{ Declaration d'un type agrege avec un tableau   }
{ parmi ses champs: Un ensemble de reels         }

constante entier TAILLE <- 15
  
{ Type agrege de stockage d'un ensemble de reels }
  
structure ensembleDeReel
  n : entier <- 0
  t : Tableau[TAILLE] de reel
fin structure
  
{ Action d'initialisation d'un ensemble de reels }

action initialisation(nb,v,e)
  Données
    nb : entier
    v : réel
  Résultats
    e : ensembleDeReel
  locales
    i : entier
  e.n <- nb
  pour i de 0 à e.n-1 faire
    e.t[i] <- v
  fait
fin action

{ Programme principal                            }

action principale()
  Locales
    i : entier
    e : ensembleDeReel
  initialisation(5,1.0,e)
  Ecran.afficher("Nombre valeurs : ",e.n)
  pour i de 0 à e.n faire
    Ecran.afficher(e.t[i])
  fait
fin action

/* Declaration d'un type agrege avec un tableau     */
/* parmi ses champs: Un ensemble de double          */

public class TypeAgregeAvecTableau {

  final static int TAILLE = 15;

/* Type agrege de stockage d'un ensemble de double  */
  
  static class EnsembleDeDouble {
    int n = 0;
    double [] t = new double[TAILLE]; };

/* Methode d'initialisation                         */
  
  public static void initialisation(int nb,double v,
                                    EnsembleDeDouble e) {
    int i;
    e.n = nb;
    for ( i = 0 ; i < e.n ; i = i+1 ) {
      e.t[i] = v; }
  }
  
/* Programme principal                              */

  public static void main(String [] args) {
    int i;
    EnsembleDeDouble e = new EnsembleDeDouble();
    initialisation(5,1.0,e);
    for ( i = 0 ; i < e.n ; i = i+1 )
      Ecran.afficherln(e.t[i]);
  }
}

/* Tests d'affectation entre tableaux           */

public class AffectationEntreTableaux {

/* Action d'affichage d'un tableau d'entiers    */
  
  static void affichage(int [] t) {
    int i;
    for ( i = 0 ; i < t.length ; i = i+1 ) {
      Ecran.afficher(t[i]," "); }
    Ecran.sautDeLigne();
  }

/* Action d'affectation des composantes         */
/* d'un tableau d'entiers cible                 */
/* avec les composantes                         */
/* d'un tableau d'entier source                 */
  
  static void affectation(int [] source,int [] cible) {
    int i;
    for ( i = 0 ; i < source.length ; i = i+1 ) {
      cible[i] = source[i]; }
  }
  
/* Programme principal                          */

  public static void main(String [] args) {
    int [] t1 = { 0,1,2,3 };
    int [] t2 = { 0,0,0,0 };
    int [] t3 = { 3,2,1,0 };
    affichage(t1);
    affichage(t2);
    affectation(t1,t2);
    affichage(t1);
    affichage(t2);
    t1[0] = 0;
    t1[1] = 0;
    t1[2] = 0;
    t1[3] = 0;
    affichage(t1);
    affichage(t2);
    Ecran.sautDeLigne();
    affichage(t1);
    affichage(t3);
    t1 = t3;
    affichage(t1);
    affichage(t3);
    t1[0] = 0;
    t1[1] = 0;
    t1[2] = 0;
    t1[3] = 0;
    affichage(t1);
    affichage(t3);
  }
}

/* Tests d'egalite entre 2 tableaux             */

public class TestEgaliteTableaux {

/* Fonction de test de l'egalite de 2 tableaux  */
/* d'entiers                                    */
  
  static boolean testEgalite(int [] ta,int [] tb) {
    boolean res;
    int i;
    res = true;
    if ( ta.length != tb.length ) {
      res = false; }
      else {
      i = 0;
      while ( ( res == true ) && ( i < ta.length ) ) {
        if ( ta[i] != tb[i] ) {
          res = false; }
        i = i+1; } }
    return res;
  }
  
/* Programme principal                          */

  public static void main(String [] args) {
    int [] t1 = { 0,1,2,3 };
    int [] t2 = { 0,0,0,0 };
    int [] t3 = { 0,1,2,3 };
    boolean egal;
    egal = (t1 == t2);
    Ecran.afficherln(egal);
    egal = (t1 == t3);
    Ecran.afficherln(egal);
    egal = testEgalite(t1,t2);
    Ecran.afficherln(egal);
    egal = testEgalite(t1,t3);
    Ecran.afficherln(egal);
  }
}

constante entier N <- ...

{ Initialisation d'un tableau                   }
{ de reel avec des 0.0                          }
  
action initialisation(tab)
  Résultats
    tab : Tableau[N] de reel
  Locales
    i : entier
  pour i de 0 à N-1 faire
    tab[i] <- 0.0
  fait
fin action

{ Initialisation d'un tableau de reel avec      }
{ des valeurs tirees au sort entre 0.0 et 1.0   }

action initRand(tab)
  Résultats
    tab : Tableau[N] de reel
  Locales
    i : entier
  pour i de 0 à N-1 faire
    tab[i] <- random()
  fait
fin action

{ Creation d'un tableau de reel initialise avec }
{ une serie croissante de nombres aleatoires    }

Tableau [N] de reel fonction initRandCroissant()
  Locales
    i : entier
    tab : Tableau[N] de reel
  tab[0] <- random()
  pour i de 1 à N-1 faire
    tab[i] <- tab[i-1]+random()
  fait
  retourner tab
fin fonction

/* Methode d'initialisation d'un tableau       */
/* de double avec des 0.0                      */

static void initialisation(double [] tab) {
  int i;
  for ( i = 0 ; i < tab.length ; i = i+1 ) {
    tab[i] = 0.0; }
}

/* Methode d'initialisation d'un tableau       */
/* de double avec des reels tires au sort      */
/* entre 0.0 et 1.0                            */

static void initRand(double [] tab) {
  int i;
  for ( i = 0 ; i < tab.length ; i = i+1 ) {
    tab[i] = Math.random(); }
}

/* Methode de creation d'un tableau de double  */
/* initialise avec une serie croissante        */
/* de nombres aleatoires                       */

static double [] initRandCroissant(int n) {
  int i;
  double [] tab = new double[n];
  tab[0] = Math.random();
  for ( i = 1 ; i < tab.length ; i = i+1 ) {
    tab[i] = tab[i-1]+Math.random(); }
  return tab;
}

{ Affichage d'un tableau de reels             }

constante entier N <- ...

action affichageTableau(t)
  Données
    t : Tableau [N] de reel
  Locales
    i : entier
  pour i de 0 à N-1 faire
    Ecran.afficherln(t[i]," ")
  fait
fin action

/* Methode d'affichage des valeurs contenues   */
/* dans un tableau de double                   */

static void affichageTableau(double [] t) {
  int i;
  for ( i = 0 ; i < t.length ; i = i+1 ) {
    Ecran.afficherln(t[i]); }
}

constante entier N <- ...
constante entier M <- ...

{ Test de l'egalite du contenu                }
{ de deux tableaux de reel                    }
  
booleen fonction testEgalite(t1,t2)
  Données
    t1 : Tableau [N] de reel
    t2 : Tableau [M] de reel
  Locales
    egalite : booleen
    i : entier
  egalite <- vrai
  si N <> M alors
    egalite <- faux
    sinon
    i <- 0
    tant que ( egalite et ( i < N ) ) faire
      egalite <- (t1[i] = t2[i])
      i <- i+1
    fait
  fsi
  retourner egalite
fin fonction

/* Methode de test de l'egalite du contenu     */
/* de deux tableaux de double                  */

static boolean testEgalite(double [] t1,
                           double [] t2) {
  boolean egalite = true;
  int i;
  if ( t1.length != t2.length ) {
    egalite = false; }
    else {
    i = 0;
    while ( egalite && ( i < t1.length ) ) {
      egalite = ( t1[i] == t2[i] );
      i = i+1; } }
  return egalite;
}

constante entier N <- ...

{ Calcul de la valeur minimale                }
{ d'un tableau de reel                        }
  
reel fonction minimum(t)
  Données
    t : Tableau [N] de reel
  Locales
    min : reel
    i : entier
  dans le cas de N
    0 :
      min <- NaN
    1 :
      min <- t[0]
    autres cas :
      min <- t[0]
      pour i de 1 à N-1 faire
        si t[i] < min alors
          min <- t[i]
        fsi
      fait
  fcas
  retourner min
fin fonction

/* Methode de calcul de la valeur minimale     */
/* d'un tableau de double                      */

static double minimum(double [] t) {
  double min;
  int i;
  switch (t.length) {
    case 0 : {
      min = Double.NaN; }
      break;
    case 1 : {
      min = t[0]; }
      break;
    default : {
      min = t[0];
      for ( i = 1 ; i < t.length ; i++ ) {
        if ( t[i] < min ) {
          min = t[i]; } } } }
  return min;
}

{ Creation d'une chaine de caracteres         }
{ a partir d'un tableau de caracteres         }

constante entier N <- 5

action principale()
  Locales
    s : chaine
    t : Tableau [N] de caractere
    i : entier
  s <- ""
  t[0] <- 'A'
  t[1] <- 'a'
  t[2] <- '.'
  t[3] <- 'z'
  t[4] <- 'Z'
  pour i de 0 à N-1 faire
    s <- s+t[i]
  fait
  Ecran.afficherln(N," : ",s)
fin action

{ Extraction sous forme de tableaux           }
{ de caracteres successifs des caracteres     }
{ d'un tableau de chaines de caracteres       }
{ Affichage de ces tableaux de caracteres     }

constante entier N <- 4
constante entier M <- ...

action principale()
  Locales
    ts : Tableau [N] de chaine
    i,j : entier
    tcl : entier
    tc : Tableau [M] de caractere
  ts[0] <- "ABC"
  ts[1] <- "!!&&%%"
  ts[2] <- ""
  ts[3] <- "âçéè"
  pour i de 0 à N-1 faire
    tc <- ts[i].toCharArray()           { ??? }
    tcl <- ts[i].length()               { ??? }
    Ecran.afficher(tcl," : ")
    pour j de 0 à tcl-1 faire
      Ecran.afficher(tc[j])
    fait
    Ecran.sautDeLigne()
  fait
fin action

/* Creation d'une chaine de caracteres         */
/* a partir d'un tableau de caracteres         */
/*                                             */
/* Extraction du contenu d'une chaine          */
/* de caracteres dans un tableau de caracteres */

public class UtilisationChaineEtTableauCaracteres {
  
/* Programme principal                         */

  public static void main(String [] args) {
/* Creation d'une chaine de caracteres         */
/* a partir d'un tableau de caracteres         */
    char [] t = { 'A','a','.','z','Z' };
    String s = String.valueOf(t);
    Ecran.afficherln(s.length()," caracteres : ",s);
/* Extraction sous forme de tableaux           */
/* de caracteres successifs des caracteres     */
/* d'un tableau de chaines de caracteres       */
/* Affichage de ces tableaux de caracteres     */
    String [] ts = { "ABC","!!&&%%","","àçéè" };
    char [] tc;
    int i,j;
    for ( i = 0 ; i < ts.length ; i++ ) {
      tc = ts[i].toCharArray();
      Ecran.afficher(tc.length," caracteres : ");
      for ( j = 0 ; j < tc.length ; j++ ) {
        Ecran.afficher(tc[j]); }
      Ecran.sautDeLigne(); }
    Ecran.sautDeLigne();
  }
}