SOLUZIONE 15-07-99 (PASCAL)

Questionario cartaceo

123 in base 7 è 1 × 49 + 2 × 7 + 3 × 1 = 66.
66 = 7 × 9 + 3 × 1
e quindi in base 9 è
73 .
```
...     1...
...     2...
...     4...
```
- Utilizzando la periferica tastiera ed un editor (programma per scrivere semplici file testo) viene creato sul disco rigido un file che contiene il testo del programma. (Notare che Think Pascal offre anche un tale editor.)
- Utilizzando un compilatore viene controllato che il programma sia sintatticamente corretto e poi viene compilato, cioè tradotto in un programma in linguaggio macchina (il testo di tale programma sarà messo in un file sul disco rigido).
  Think Pascal offre la funzionalità per compilare.
- Tale programma viene eseguito, e per fare ciò viene trasferito nella memoria centrale.
  Think Pascal offre la funzionalità per eseguire.

program MEDIA;

 var
  TESTO: text;
  Num_Car, Num_Righe: integer;

begin
 reset(TESTO, 'TERESA');
 Num_Car := 0;
 Num_Righe := 0;
 
 while not EOF(TESTO) do
 begin
  while not EOLN(TESTO) do
  begin
   get(TESTO);
   Num_Car := Num_Car + 1;
  end;
  readln(TESTO);
  Num_Righe := Num_Righe + 1;
 end;
 close(TESTO);
 writeln('Lunghezza media: ', Num_Car / Num_Righe);
end.

Parte laboratorio

program IMMAGINI;

{gli elementi del tipo IMMAGINE rappresentano delle immagine a colori in modo digitale,}
{ogni elemento della matrice rappresenta un colore secondo un opportuno meccanismo di }
{codifica }

 const
  L = 5;
  H = 7;
  {larghezza e altezza delle immagini}

 type
  IMMAGINE = array[1..H, 1..L] of integer;

 var
  IM: IMMAGINE;
  C: char;

 {sottoprogramma che controlla se un'immagine e' a righe orrizontali}
  {per esempio quella che segue lo e'}
  { 3 3 3 3 3 }
  { 4 4 4 4 4 }
  { 3 3 3 3 3 }
  { 4 4 4 4 4 }
  { 3 3 3 3 3 }
  { 4 4 4 4 4 }
  { 3 3 3 3 3 }
  { mentre quest'altra non lo e' }
  { 3 3 0 3 3 }
  { 4 4 4 4 4 }
  { 0 3 3 0 3 }
  { 4 4 4 4 4 }
  { 3 3 3 0 3 }
  { 4 4 4 4 4 }
  { 3 3 3 3 3 }

 function RigheO (IM: IMMAGINE): boolean;
  var
   LoE: boolean;
   i, j: integer;
 begin
  LoE := true;

{controllo le righe dispari}
  i := 1;
  while (i lt;= H) and LoE do
  begin
   j := 1;
   while (j <= L) and LoE do
   begin
    if IM[i, j] 7lt;> IM[1, 1] then
     LoE := false;
    j := j + 1;
   end;
   i := i + 2;
  end;

{controllo le righe pari}
  i := 2;
  while (i <= H) and LoE do
  begin
   j := 1;
   while (j <= L) and LoE do
   begin
    if IM[i, j] <> IM[2, 1] then
     LoE := false;
    j := j + 1;
   end;
   i := i + 2;
  end;

  RigheO := LoE;
 end;

{sottoprogramma che controlla se un'immagine e' a bande orrizontali}
{per esempio quella che segue lo e'}
{		3 3 3 3 3 }
{         3 3 3 3 3 }
{         3 3 3 3 3 }
{         4 4 4 4 4 }
{         4 4 4 4 4 }
{         2 2 2 2 2 }
{         2 2 2 2 2 }

{mentre quest'altra non lo e' }
{         3 3 3 3 3 }
{         3 3 3 3 3 }
{         3 3 3 3 3 }
{         3 3 3 0 3 }
{         4 4 4 4 4 }
{         4 4 4 4 4 }
{         3 3 3 3 3 }

 function RigaTuttaDi (IM: IMMAGINE;
       riga, colore: integer): boolean;
  var
   LoE: boolean;
   j: integer;
 begin
  j := 1;
  for j := 1 to L do
   if IM[riga][j] <> colore then
    LoE := false;
  RigaTuttaDi := LoE;
 end;

 function BandeO (IM: IMMAGINE): boolean;
  var
   LoE: boolean;
   ColoreCorrente, i, j: integer;
 begin
  LoE := true;
  ColoreCorrente := IM[1, 1];
  i := 1;
  while (i < H) and LoE do
   if ColoreCorrente = IM[i, 1] then {puo' essere stessa banda}
   begin
    if RigaTuttaDi(IM, i, ColoreCorrente) then
     i := i + 1
    else
     LoE := false;
   end
   else
    ColoreCorrente := IM[i, 1]; {sicuramente una nuova banda}

  BandeO := LoE;
 end;

{sottoprogramma che controlla se un'immagine e' a quadretti}
{per esempio quella che segue lo e'}
{		  3 0 3 0 3 }
{         0 3 0 3 0 }
{         3 0 3 0 3 }
{         0 3 0 3 0 }
{         3 0 3 0 3 }
{         0 3 0 3 0 }
{         3 0 3 0 3 }

{mentre quest'altra non lo e' }
{         3 3 3 3 3 }
{         3 3 3 3 3 }
{         3 3 3 3 3 }
{         3 3 3 0 3 }
{         4 4 4 4 4 }
{         4 4 4 4 4 }
{         3 3 3 3 3 }

 function Quadretti (IM: IMMAGINE): boolean;
  var
   LoE: boolean;
   i, j: integer;
 begin
  LoE := true;

{i quadretti con somma indici pari devono essere uguali a IM [ 1 ] [ 1 ]}
{i quadretti con somma indici dispari devono essere uguali a IM [ 1 ] [ 2 ] }
  i := 1;
  while (i <= H) and LoE do
  begin
   j := 1;
   while (j <= L) and LoE do
   begin
    if (i + j) mod 2 = 0 then
    begin
     if IM[i, j] <> IM[1, 1] then
      LoE := false;
    end
    else if IM[i, j] <> IM[1, 2] then
     LoE := false;
    j := J + 1;
   end;
   i := i + 1;
  end;

  Quadretti := LoE;
 end;

 procedure READ_IM (var IM: IMMAGINE);
  var
   i, j: integer;
 begin
  for i := 1 to H do
  begin
   for j := 1 to L do
    read(IM[i, j]);
   readln;
  end;
 end;


begin
{dare un main per permettere di testare  le procedure definite sopra}
{e dire esplicitamente su quali immagini devono essere chiamate}


{ZERO =}
{ 0, 0, 0 , 0 , 0}
{ 0, 0, 0 , 0 , 0}
{ 0, 0, 0 , 0 , 0}
{ 0, 0, 0 , 0 , 0}
{ 0, 0, 0 , 0 , 0}
{ 0, 0, 0 , 0 , 0}
{ 0, 0, 0 , 0 , 0}

{ ZEROUNO = }
{ 0, 0, 0 , 0 , 0}
{ 1, 1, 1 , 1 , 1}
{ 0, 0, 0 , 0 , 0}
{ 1, 1, 1 , 1 , 1}
{ 0, 0, 0 , 0 , 0}
{ 1, 1, 1 , 1 , 1}
{ 0, 0, 0 , 0 , 0}

{ ZEROUNOq = }
{ 0, 0, 0 , 0 , 0}
{ 1, 1, 1 , 1 , 1}
{ 0, 0, 0 , 0 , 0}
{ 1, 1, 1 , 1 , 1}
{ 0, 0, 0 , 0 , 0}
{ 1, 1, 1 , 1 , 1}
{ 0, 0, 0 , 0 , 9}

{UNO23 = }
{ 1, 1, 1 , 1 , 1}
{ 2, 2, 2 , 2 , 2}
{ 2, 2, 2 , 2 , 2}
{ 3, 3, 3 , 3 , 3}
{ 3, 3, 3 , 3 , 3}
{ 3, 3, 3 , 3 , 3}
{ 3, 3, 3 , 3 , 3}

{IMMAGINE ACASO = }
{ 1, 1, 1 , 0 , 1}
{ 2, 2, 9 , 2 , 2}
{ 2, 2, 2 , 2 , 2}
{ 5, 3, 3 , 3 , 3}
{ 3, 3, 8 , 3 , 3}
{ 3, 3, 3 , 3 , 3}
{ 3, 3, 3 , 3 , 1}

{IMMAGINE QUAD = }
{ 8, 1, 8 , 1 , 8}
{ 1, 8, 1 , 8 , 1}
{ 8, 1, 8 , 1 , 8}
{ 1, 8, 1 , 8 , 1}
{ 8, 1, 8 , 1 , 8}
{ 1, 8, 1 , 8 , 1}
{ 8, 1, 8 , 1 , 8}

{IMMAGINE QUADq = }
{ 8, 1, 8 , 1 , 8}
{ 1, 8, 1 , 8 , 1}
{ 8, 1, 8 , 1 , 8}
{ 1, 8, 1 , 8 , 1}
{ 8, 1, 8 , 1 , 8}
{ 1, 8, 1 , 8 , 1}
{ 8, 1, 8 , 1 , 9}


 repeat
  writeln('Vuoi testare le funzioni ? (S/N)');
  readln(C);
  if C = 'S' then
  begin
   writeln('Dare la matrice riga per riga');
   READ_IM(IM);
   if RigheO(IM) then
    writeln('E'' a righe')
   else
    writeln('Non e'' a righe');
   if BandeO(IM) then
    writeln('E'' a bande')
   else
    writeln('Non e'' a bande');
   if Quadretti(IM) then
    writeln('E'' a quadretti')
   else
    writeln('Non e'' a quadretti');
  end;
 until C = 'N';
end.