Note ajoutée depuis : le plus ancien billet de ces archives. Du Pascal, comme l'utilitaire de recherche de doublons trois ans plus tard.
Unité pédagogique utilisée dans l'enseignement de la méthode inductive appliquée aux boucles while et for.
Pascal utilisé pour obtenir un code « lisible » pour les débutants, sans pour autant utiliser du LDA.
unit seqint;
interface
uses
Classes, SysUtils;
const
Nmax = 25 ;
MinInt = -99 ;
MaxInt = 99 ;
MaxSize = MaxInt - MinInt ;
type
TtypeSeqInt = ( Vide, Singleton, Positive, Constante, Croissante,
Decroissante, StrictCroissante, StrictDecroissante,
Lotto, NoDouble, Double, DoubleSvt, MaxMult,
MaxMult2, NoDoubleSvt, Quelconque ) ;
//
// Vide ................ : séquence vide.
// Singleton ........... : séquence avec un seul élément.
// Positive ............ : séquence où tous les éléments sont >= 0.
// Constante ........... : séquence où tous les éléments ont la même valeur.
// Croissante .......... : séquence où les éléments successifs sont supérieurs
// ou égaux aux éléments précédents.
// Decroissante ........ : séquence où les éléments successifs sont inférieurs
// ou égaux aux éléments précédents.
// StrictCroissante .... : séquence où les éléments successifs sont strictement
// supérieurs aux éléments précédents.
// StrictDecroissante .. : séquence où les éléments successifs sont strictement
// inférieurs aux éléments précédents.
// Lotto ............... : séquence de nombres uniques entre 1 et 42.
// NoDouble ............ : séquence ne comportant pas de doublons.
// Double .............. : séquence comportant un ou plusieurs doublons.
// DoubleSvt ........... : séquence comportant un ou plusieurs doublons
// successifs.
// MaxMult ............. : séquence comportant plusieurs maxima de même valeur.
// MaxMult2 ............ : séquence comportant plusieurs maxima de deux valeurs
// différentes.
// NoDoubleSvt ......... : séquence ne comportant pas de doublons consécutifs.
// Quelconque .......... : suite sans propriétés définies.
//
TArrayInt = array[0..MaxSize] of integer ;
TSeqInt = class
private
s : TArrayInt;
len : integer;
public
constructor Create(t:TTypeSeqInt);
constructor _(t:array of longint) ;
end;
TSeqIter = class
private
seq : TSeqInt ;
icur : Integer ;
public
constructor init( seq : TseqInt ) ;
function AuBout : boolean ;
function ValeurCourante : integer ;
end;
ESequence = class(Exception)
end;
// --------------------------------------------------------
implementation
function DansTableau ( const t : TArrayInt; const val : longint ) : boolean ;
var k : integer ;
begin
result := false ;
for k := low(t) to high(t) do
begin
if t[k] = val then
begin
result := true ;
break ;
end;
end;
end;
// ---------
// TseqInt
// ---------
//
// TseqInt.Create
//
// Création automatique d'une séquence d'entiers.
//
constructor TseqInt.Create(t:TTypeSeqInt);
var x, k, l : integer ;
var indice1, indice2 : integer ;
var maxi1, maxi2, occurence1, occurence2 : integer ;
begin
randomize ;
case t of
Vide : len := 0;
Singleton : begin
len := 1 ;
s[0] := random ( maxInt - minInt ) + minInt ;
end;
Constante : begin
len := 2 + random( Nmax - 1 );
x := MinInt + random(198) ;
for k := 0 to len do s[k] := x ;
end;
Croissante : begin
len := 2 + random( Nmax - 1 );
x := MinInt + random (20) ;
for k := 0 to len do
begin
x := x + random(20)*random(2);
if x > maxint then
begin
len := k - 1 ;
break ;
end;
s[k] := x ;
end;
end;
Decroissante : begin
len := 2 + random( Nmax - 1 );
x := maxint - random(20) ;
for k := 0 to len do
begin
x := x - random(20)* random(2);
if x < minint then
begin
len := k - 1 ;
break ;
end;
s[k] := x ;
end;
end;
StrictCroissante : begin
len := 2 + random( Nmax - 1 );
x := minInt + random(20) ;
for k := 0 to len do
begin
x := x + 1 + random(20);
if x > maxint then
begin
len := k - 1 ;
break ;
end;
s[k] := x ;
end;
end;
StrictDeCroissante : begin
len := 2 + random( Nmax - 1 );
x := maxint - random(20) ;
for k := 0 to len do
begin
x := x - 1 - random(20);
if x < minint then
begin
len := k - 1 ;
break ;
end;
s[k] := x ;
end;
end;
Double : begin
len := 2 + random ( Nmax - 1 );
for k := 0 to ( len - 1 ) do
s[k] := MinInt + random(198);
indice1 := random ( len - 2 );
indice2 := random ( len - 2 );
while indice2 = indice1 do indice2 := random ( len - 2 );
s[indice2] := s[indice1];
end;
DoubleSvt : begin
len := 2 + random ( Nmax - 1 );
for k := 0 to ( len - 1 ) do
s[k] := MinInt + random(198);
indice1 := random ( len - 2 );
s[indice1+1] := s[indice1];
end;
Lotto : begin
len := 6 ;
s[0] := random(42);
for k := 1 to ( len - 1 ) do
begin
while DansTableau(s, x) do x := random(42);
s[k] := x ;
end;
end;
MaxMult : begin
len := 2 + random ( Nmax - 1 ) ;
for k := 0 to ( len - 1 ) do
s[k] := MinInt + random(148);
maxi1 := 50 + random (40);
occurence1 := 2 ;
for k := 1 to occurence1 do
begin
indice1 := random(len-1);
while s[indice1] = maxi1 do indice1 := random(len-1) ;
s[indice1] := maxi1 ;
end;
end;
MaxMult2 : begin
len := 4 + random ( Nmax - 3 ) ;
for k := 0 to ( len - 1 ) do
s[k] := MinInt + random(148);
maxi1 := 50 + random (20);
maxi2 := 70 + random (20);
occurence1 := 2 ;
occurence2 := 2 ;
for k := 1 to occurence1 do
begin
indice1 := random(len-1);
while s[indice1] = maxi1 do indice1 := random(len-1) ;
s[indice1] := maxi1 ;
end;
for k := 1 to occurence2 do
begin
indice2 := random(len-1);
while ((s[indice2] = maxi1) or (s[indice2] = maxi2)) do indice2 := random(len-1) ;
s[indice2] := maxi2 ;
end;
end;
NoDouble : begin
len := 1 + random ( Nmax );
s[0] := minInt + random(198) ;
for k := 1 to ( len - 1 ) do
begin
x := minInt + random(198) ;
while DansTableau(s, x) do x := minInt + random(198) ;
s[k] := x ;
end;
end;
NoDoubleSvt : begin
len := 1 + random ( Nmax );
s[0] := minInt + random(198) ;
for k := 1 to ( len - 1 ) do
begin
s[k] := minInt + random(198) ;
while s[k] = s[k-1] do s[k] := minInt + random(198) ;
end;
end;
Positive : begin
len := random ( Nmax );
for k := 0 to ( len - 1 ) do
s[k] := 0 + random ( 99 );
end;
Quelconque : begin
len := random ( Nmax );
for k := 0 to ( len - 1 ) do
s[k] := minInt + random(198) ;
end;
end;
end;
//
// TseqInt._
//
// Déclaration manuelle d'une séquence d'entiers
//
constructor TseqInt._(t:array of integer);
var k : integer ;
begin
len := high(t)+1;
for k := 0 to high(t) do
begin
s[k]:=t[k];
end;
end;
// ----------
// TSeqIter
// ----------
constructor TSeqIter.Init ( seq : TseqInt ) ;
begin
self.seq := seq ;
icur := 0 ;
end;
function TseqIter.AuBout : boolean ;
begin
result := ( icur >= seq.len );
end;
function TseqIter.ValeurCourante : integer ;
begin
if AuBout then raise ESequence.create('Erreur d''iteration : Sequence AuBout.')
else
begin
result := seq.s[icur] ;
inc(icur);
end;
end;
end.