Silmukat ja taulukot

• Tehtävä 2.13 Avoimen taulukon ylärajan tarkistus

Seuraavassa esimerkissä on ohjelma, joka ensin tekee viisipaikkaisen kokonaislukutaulukon:

0	1	2	3	4
0	3	6	9	12

Sitten ohjelma laskee montako taulukon alkiota voidaan ottaa mukaan, ilman että summa ylittää vielä 10. Lopuksi tulostetaan ko. alkiot takaperin:

	3 lukua mahtuu alle 10 näiden summa on 9
	Luvut on: 6 3 0 

	
	
	#include <iostream.h>
	
	const int TKOKO=5;
	const int RAJA=10;
	
	
	
	
	
	void alusta(int luvut[], int n, int kasvu)
	/* Alustetaan taulukko sarjalla
	   0,kasvu,2*kasvu... */
	{
	  int i,luku=0;
	  for (i=0; i<n; i++) {
	    luvut[i] = luku;
	    luku += kasvu;
	  }
	}
	
	
	
	int montako_mahtuu(const int luvut[], int n,
	                   int raja)
	/* Mihin asti lukujen summa ei ylitä rajaa */
	{
	  int i=0,summa=0;
	  do {
	    summa += luvut[i];
	  } while ( summa < raja && ++i < n );
	  return i;
	}
	
	
	int summaa(const int luvut[], int n)
	{
	  int i=0,summa=0;
	  while ( i < n ) {
	    summa += luvut[i];
	    i++;
	  }
	  return summa;
	}
	
	
	
	void tulosta(ostream &os,
	             const int luvut[],int n)
	/* Tulostaa taulukon nurinpäin */
	{
	  int i;
	  for (i=n-1; i>=0; i--)
	    os << luvut[i] << " ";
	  os << endl;
	}
	
	int main(void)
	{
	  int luvut[TKOKO],n;
	  alusta(luvut,TKOKO,3);
	  n = montako_mahtuu(luvut,TKOKO,RAJA);
	  cout << n << " lukua mahtuu alle " << RAJA
	       << " näiden summa on "
	       << summaa(luvut,n) << endl;
	  cout << "Luvut on: ";
	  tulosta(cout,luvut,n);
	  return 0;
	}

	program Silmu;
	
	uses WinCRT;
	
	const TKOKO=5;
	const RAJA=10;
	
	{ Seuraavalla korvataan C:n ++i }
	function esi_lisaa(var i:integer):integer;
	begin inc(i); esi_lisaa := i; end;
	
	procedure alusta(var luvut:array of integer;
	                 n,kasvu:integer);
	{ Alustetaan taulukko sarjalla
	  0,kasvu,2*kasvu...                        }
	var i,luku:integer;
	begin
	  luku := 0;
	  for i:=0 to n-1 do begin
	    luvut[i] := luku;
	    inc(luku,kasvu);
	  end;
	end;
	
	function montako_mahtuu(const luvut:array of
	           integer; n,raja:integer):integer;
	{ Mihin asti lukujen summa ei ylitä rajaa }
	var i,summa:integer;
	begin
	  i := 0; summa := 0;
	  repeat
	    summa := summa + luvut[i];
	  until ( summa >= raja ) or
	        ( esi_lisaa(i) >= n );
	  montako_mahtuu := i;
	end;
	
	function summaa(const luvut:array of integer;
	                n:integer):integer;
	var i,summa:integer;
	begin
	  i := 0; summa := 0;
	  while ( i < n ) do begin
	    inc(summa,luvut[i]);
	    inc(i);
	  end;
	  summaa := summa;
	end;
	
	procedure tulosta(var f:textfile;
	   const luvut:array of integer; n:integer);
	{ Tulostaa taulukon nurinpäin }
	var i:integer;
	begin
	  for i:=n-1 downto 0 do
	    write(f,luvut[i],' ');
	writeln(f);
	end;
	
	{ Pääohjelma: }
	var luvut : array[0..TKOKO-1] of integer;
	    n : integer;
	begin
	  alusta(luvut,TKOKO,3);
	  n := montako_mahtuu(luvut,TKOKO,RAJA);
	  writeln(n,' lukua mahtuu alle ',RAJA,
	        ' näiden summa on ',summaa(luvut,n));
	  write('Luvut on: ');
	  tulosta(output,luvut,n);
	end.

• while do kuten C:ssä while
• do-while:n tilalle repeat until, jossa on lopettamisehto, ei jatkamisehto kuten C:ssä, eli ehto vastaavan C- ehdon komplementti
• for - silmukka on huomattavasti rajoittuneempi kuin C:ssä. Silmukkalaskurin arvo ei ole välttämättä tunnettu silmukan jälkeen, eikä laskurin arvon muuttaminen kesken silmukan välttämättä katkaise silmukkaa
• for-to osaa lisätä vain yhdellä
• alaspäin laskemista varten on oma for-downto
• taulukoiden esittelyssä esitellään alaraja..yläraja
• itse asiassa taulukon indeksityppinä voi olla mikä tahansa ordinaalityyppi (numeroituva tyyppi)
• moniulotteinen taulukko on taulukko taulukoista:

	var T: array[Boolean] of array[1..10] of array[3..6] of Real;
	{ on sama kuin: }
	var T: array[Boolean,1..10,3..6] of Real;
	{ Alkioon viitataan joko }
	  r := T[True][3][5];
	{tai}
	  r := T[True,3,5];

• avoimen taulukon luvut:array of integer koko saataisiin itse asiassa selville kutsuilla:

	Low	(luvut);     { aina 0 riippumatta varsinaisen taulukon alarajasta  }
	High(luvut);    { 4, eli alkuperäisen taulukon koko-1                 }
	SizeOf(luvut);  { 10 tai 20 riippuen onko 16 vai 32-bittinen kääntäjä }

• esimerkissä kuitenkin käytetään parametrina tuotua lukumäärää; näin voidaan laskea tuloksia myös osataulukoille. Tietysti pitäisi aina testata onko n <= High(luvut)+1, esimerkissä on pyritty vain matkimaan mahdollisimman paljon viereistä C- koodia.
• avointa taulukkoa (open array) voidaan kutsua myös vakiotaulukolla:

	tulosta(output,[1,2,4,8,16],5);

• jollei olisi tehty apufunktiota esi_lisaa, olisi repeat - silmukka pitänyt kirjoittaa esimerkiksi:

	  repeat { repeat edelleen väärin, koska jos n=0, viitataan lait.alkioon }
	    summa := summa + luvut[i];
	    if ( summa >= raja ) then break;
	    i := i + 1;
	  until ( i >= n );

• break - proseduurissa on sama vika kuin C:n break - lauseessakin: vain yksi taso voidaan katkaista. Tätä voidaan kiertää joko aliohjelman exit - lauseella tai goto - lauseella

Tehtävä 2.13 Avoimen taulukon ylärajan tarkistus

Muuta silmu.dpr - ohjelmaa siten, että kussakin aliohjelmassa tarkistetaan ettei taulukon ylärajaa ylitetä.

Miten em. muutoksen jälkeen kutsu tulosta(output,[1,2,4,8,16],5); voitaisiin korvata laskematta itse vakiotaulukon kokoa?