constante entier N <- 20

{ Type agrege de stockage d'un ensemble       }
{ d'au maximum 20 chaines de caracteres       }
  
structure ensembleDeChaines
  entier n <- 0
  chaine [N] s
fin structure

{ Action d'affichage des chaines              }
{ de caracteres contenues dans un ensemble    }
{ de chaines de caracteres                    }
{ edc : L'ensembleDeChaines à afficher        }
  
action affichage(-> ensembleDeChaines edc)
  entier i
  pour i de 0 à edc.n faire
    afficherln(edc.s[i])
  fait
fin action

{ Fonction d'ajout d'une chaine de caracteres }
{ à un ensemble de chaines de caracteres      }
{ Retourne vrai si l'ajout a abouti           }
{ Retourne faux si plus de place              }
{ edc : L'ensembleDeChaines où l'ajout        }
{       est effectué                          }
{ s : La chaine ajoutée                       }
  
booleen fonction ajout(-> ensembleDeChaines edc ->,
                       -> chaine s)
  res booleen
  si edc.n < N alors
    edc.s[edc.n] <- s
    edc.n <- edc.n+1
    res <- vrai
    sinon
    res <- faux
  fsi
  retourner res
fin fonction

{ Fonction de test de l'appartenance          }
{ d'une chaine de caracteres                  }
{ a un ensemble de chaines de caracteres      }
{ Retour de vrai si present, faux sinon       }
{ edc : L'ensembleDeChaines où la recherche   }
{       est effectuée                         }
{ s : La chaine recherchée                    }

booleen fonction appartient(-> ensembleDeChaines edc,
                            -> chaine s)
  booleen res
  res <- faux
  i <- 0
  tantque ( res == faux ) et ( i < edc.n ) faire
    res <- (edc.s[i] == s)
    i <- i+1
  fait
  retourner res
fin fonction

{ Fonction de fusion de deux ensembles        }
{ de chaines de caracteres dans un ensemble   }
{ de chaines de caracteres                    }
{ Retour de faux si fusion impossible         }
{ car pas assez de place et ne touche pas     }
{ au parametre en sortie                      }
{ Retour de vrai sinon                        }
{ edc1 : Le premier ensembleDeChaines         }
{ edc2 : Le second ensembleDeChaines          }
{ edc : L'ensembleDeChaines issu de la fusion }

booleen fonction fusion(-> ensembleDeChaines edc1,
                        -> ensembleDeChaines edc2,
                        ensembleDeChaines edc ->)
  entier i
  booleen res
  si edc1.n+e2.n <= N alors
    edc.n <- 0
    pour i de 0 à edc1.n-1 faire
      ajout(edc,edc1.s[i])
    fait
    pour i de 0 à edc2.n-1 faire
      ajout(edc,edc2.s[i])
    fait
	  res <- vrai
    sinon
    res <- faux
  fsi
  retourner res
fin fonction

{ Fonction de retrait d'une chaine            }
{ de caracteres a un ensemble de chaines      }
{ de caracteres                               }
{ Retour de vrai si le retrait a abouti       }
{ Retour de faux sinon                        }
{ edc : L'ensembleDeChaines où le retrait     }
{       est réalisé                           }
{ s : La chaine retirée                       }

booleen fonction retrait(-> ensembleDeChaines edc ->,
                         -> chaine s)
  booleen res
  entier i
  res <- faux
  i <- 0
  tantque ( res == faux ) et ( i < edc.n ) faire
    res <- (edc.s[i] == s)
    i <- i+1
  fait
  si res alors
    pour i de i à edc.n-1 faire
      edc.s[i-1] <- edc.s[i]
    fait
    edc.n <- edc.n-1
  fsi
  retourner res
fin fonction

{ Fonction de test si un ensemble de chaines  }
{ de caracteres est vide                      }
{ Retour de vrai si c'est le cas, faux sinon  }
{ edc : L'ensembleDeChaines testé             }
  
booleen fonction estVide(-> ensembleDeChaines edc)
  retourner (edc.n == 0)
fin fonction