informatikos VBE

Išsprendžiau 2009 metų užduotis, gal kam pravers:

program test;

const
dFile   = 'data.txt';
rFile   = 'result.txt';
dSize   = 50;

type
intArray = array[1..dSize] of integer;

function keiciamaSuma(a, b : intArray; c : integer) : integer; {a - nominalai; b - turimas nominalu kiekis; c - nominalu sk.}
var
i : integer;
begin
keiciamaSuma	:= 0;

for i := 1 to c do
begin
	keiciamaSuma	:= keiciamaSuma + a[i] * b[i];
end;
end;

procedure rikiuotiNominalai(var a : intArray; b : integer); {a - nominalai; b - nominalu sk.; c - isrikiuoti nominalai}
var
i, j, tmp : integer;
begin
for i := 1 to b - 1 do
	for j := i to b do
		if a[j] > a[i] then
		begin
			tmp	 := a[j];
			a[j]	:= a[i];
			a[i]	:= tmp;
		end;
end;

var
Df : text;

GilijosNominaluSk, GilijosStudentoKeiciamaSuma,
EglijosNominaluSk, EglijosStudentoKeiciamaSuma,
nominalai,
laikina1,
laikina2,
i : integer;

GilijosNominalai, GilijosNominaluKiekis,
EglijosNominalai, EglijosNominaluKiekis
: intArray;

begin
{skaitom faila}
Assign(Df, dFile);
Reset(Df);

{Gilijos studentas}
ReadLn(Df, GilijosNominaluSk);

for i := 1 to GilijosNominaluSk do
	Read(Df, GilijosNominalai[i]);

ReadLn(Df);

for i := 1 to GilijosNominaluSk do
	Read(Df, GilijosNominaluKiekis[i]);

ReadLn(Df);

{Eglijos studentas}
ReadLn(Df, EglijosNominaluSk);

for i := 1 to EglijosNominaluSk do
	Read(Df, EglijosNominalai[i]);

ReadLn(Df);

for i := 1 to EglijosNominaluSk do
	Read(Df, EglijosNominaluKiekis[i]);

{apskaiciuojame kiek nominalu kiekvienas studentas turi}
GilijosStudentoKeiciamaSuma := keiciamaSuma(GilijosNominalai, GilijosNominaluKiekis, GilijosNominaluSk);
EglijosStudentoKeiciamaSuma := keiciamaSuma(EglijosNominalai, EglijosNominaluKiekis, EglijosNominaluSk);

{rikiuojam nominalus mazejimo tvarka}
rikiuotiNominalai(GilijosNominalai, GilijosNominaluSk);
rikiuotiNominalai(EglijosNominalai, EglijosNominaluSk);

{apskaiciuojame Eglijos studento finansus}

laikina1	:= 0;

for i := 1 to EglijosNominaluSk do
begin
	nominalai   := GilijosStudentoKeiciamaSuma div EglijosNominalai[i];
	laikina1	:= laikina1 + nominalai;

	WriteLn(EglijosNominalai[i], ' ', nominalai);

	GilijosStudentoKeiciamaSuma := GilijosStudentoKeiciamaSuma - nominalai * EglijosNominalai[i];
end;

WriteLn(laikina1);

{apskaiciuojame Gilijos studento finansus}

laikina2	:= 0;

for i := 1 to GilijosNominaluSk do
begin
	nominalai   := EglijosStudentoKeiciamaSuma div GilijosNominalai[i];
	laikina2	:= laikina2 + nominalai;
	WriteLn(GilijosNominalai[i], ' ', nominalai);

	EglijosStudentoKeiciamaSuma := EglijosStudentoKeiciamaSuma - nominalai * GilijosNominalai[i];
end;

WriteLn(laikina2);

Close(Df);

ReadLn;
end.

program test2;

const
dFile   = 'data.txt';
rFile   = 'results.txt';
dSize   = 50;

type
begikuDuomenuModelis = record
	vardas		: string[20];
	minutes, sekundes   : integer;
end;


var
grupes		  : array[1..8] of array[1..dSize] of begikuDuomenuModelis;
begikuSkGrupese : array[1..8] of integer;
atrinktiBegikai : array[1..8] of begikuDuomenuModelis;

i, j, k, grupiuSk, begikuSkGrupeje	: integer;
Df : text;

laikinas, laikinas2 : begikuDuomenuModelis;
naujasIndeksas : integer;

begin
Assign(Df, dFile);
Reset(Df);
ReadLn(Df, grupiuSk);

{nuskaitom duomenis i kintamaji}
for i := 1 to grupiuSk do
begin
	ReadLn(Df, begikuSkGrupeje);

	begikuSkGrupese[i]  := begikuSkGrupeje;

	for j := 1 to begikuSkGrupeje do
		ReadLn(Df, grupes[i][j].vardas, grupes[i][j].minutes, grupes[i][j].sekundes);
end;

{surikiuojame grupese esancius begikus pagal begimo greiti}
for i := 1 to grupiuSk do
	for j := 1 to begikuSkGrupese[i]-1 do
		for k := j to begikuSkGrupese[i] do
			if ((grupes[i][k].minutes * 60 + grupes[i][k].sekundes) < (grupes[i][j].minutes * 60 + grupes[i][j].sekundes)) then
			begin
				laikinas		:= grupes[i][k];
				grupes[i][k]	:= grupes[i][j];
				grupes[i][j]	:= laikinas;
			end;

{atrenkame puse begiku is kiekvienos grupes}
naujasIndeksas  := 1;
for i := 1 to grupiuSk do
	for j := 1 to Round(begikuSkGrupese[i]/2) do
	begin
		atrinktiBegikai[naujasIndeksas] := grupes[i][j];
		naujasIndeksas  := naujasIndeksas + 1;
	end;

{Dar karta perrikiuojame gautus rezultatas}
for i := 1 to naujasIndeksas-1 do
	for j := 1 to naujasIndeksas do
		if ((atrinktiBegikai[j].minutes * 60 + atrinktiBegikai[j].sekundes) > (atrinktiBegikai[i].minutes * 60 + atrinktiBegikai[i].sekundes)) then
		begin
			laikinas2		   := atrinktiBegikai[j];
			atrinktiBegikai[j]  := atrinktiBegikai[i];
			atrinktiBegikai[i]  := laikinas2;
		end;

{Pateikiame rezulta}
for i := 1 to naujasIndeksas-1 do
	WriteLn(atrinktiBegikai[i].vardas, atrinktiBegikai[i].minutes, ' ', atrinktiBegikai[i].sekundes);

ReadLn;
Close(Df);
end.

Taip pat būtų malonu išgirsti komentarus.

Visada

2010

program test3;

const
dFile   = 'data.txt';
rFile   = 'result.txt';
dSize   = 100;

var
kg1Sk,
kg2Sk, {sk. pakuociu po 1 ir 2 kg}
pkg1Sk,
pkg2Sk, {parduotas sk. pakuociu po 1 ir 2 kg}
pSk, {pirkeju sk.}
pp, {paskutinis pirkejas}
pkpa, {sk. pirkeju, kuriems pavyko apsipirkti}
i
: integer;

pageidavimai	: array[1..dSize] of integer;

procedure readFile;
var
Df : text;
begin
Assign(Df, dFile);
Reset(Df);

ReadLn(Df, kg1Sk, kg2Sk);
ReadLn(Df, pSk);

for i := 1 to pSk do
	ReadLn(Df, pageidavimai[i]);

Close(Df);
end;

procedure skaiciuokle;
var
noriPirkti : integer; {kiek klientas nori dar nusipirkti}
begin
pkpa	:= 0;
for i := 1 to pSk do
begin
	noriPirkti  := pageidavimai[i];

	while (kg2Sk <> 0) and (noriPirkti >= 2) do
	begin
		pkg2Sk	  := pkg2Sk + 1;
		kg2Sk	   := kg2Sk - 1;
		noriPirkti  := noriPirkti - 2;
	end;

	while (kg1Sk <> 0) and (noriPirkti >= 1) do
	begin
		pkg1Sk	  := pkg1Sk + 1;
		kg1Sk	   := kg1Sk - 1;
		noriPirkti  := noriPirkti - 1;
	end;

	if noriPirkti <> pageidavimai[i] then
	begin
		pp		  := pageidavimai[i] - noriPirkti;
		pkpa		:= pkpa + 1;
	end;
end;
end;

begin
readFile;
skaiciuokle;


WriteLn(pkg1Sk, ' ', pkg2Sk);
WriteLn(pkpa);
WriteLn(pp);

Readln;
end.

http://paste.org/pastebin/view/19430

program Gimtadienis;
{Informacinių Technologijų 2010 valstybinio egzamino 2 programavimo užduotis}

const file_in = 'U2.txt';
const file_out = 'U2rez.txt';

type masyvas = array[1..10] of integer;
type patiekloIrasas = record
 pav: string[15];
 kaina:masyvas;
end;
type patiekaluMasyvas = array[1..12] of patiekloIrasas;

var patiekaloKaina:masyvas; patiekalas:patiekaluMasyvas;
N,P:smallint;

procedure skaityti();
var fread:text; i,j:integer;
begin
 assign(fread, file_in); reset(fread);
 read(fread, N); readln(fread, P); //nuskaito kiek N-produktų, P-patiekalų

 for i:=1 to (N-1) do  //nuskaito patiekalų kainas
	 read(fread, patiekaloKaina[i]);
 readln(fread, patiekaloKaina[N]);

 for i:=1 to P do //nuskaito patiekalus ir jų sudėtį
 begin
	  read(fread, patiekalas[i].pav); //pavadinimas

	  for j:=1 to (N-1) do  //produktų kiekis
		  read(fread, patiekalas[i].kaina[j]);
	  readln(fread, patiekalas[i].kaina[N]);

 end;
 close(fread);
end;

{skaičuoja visą patiekalo kainą}
function visaPatiekaloKaina(kiekProduktu:masyvas):integer;
var i:integer;
begin
 visaPatiekaloKaina:=0;
 for i:=1 to N do
	 visaPatiekaloKaina:=visaPatiekaloKaina + (kiekProduktu[i] * patiekaloKaina[i]);
end;

{skaičiuoja svečio kainą}
function svecioKaina(patiekalas:patiekaluMasyvas):integer;
var i:integer;
begin
 svecioKaina:=0;
 for i:=1 to P do
	 svecioKaina:= svecioKaina + visaPatiekaloKaina(patiekalas[i].kaina);
end;

procedure rasyti();
var fwrite:text; i:integer;
begin
 assign(fwrite, file_out); rewrite(fwrite);

 {rašo patiekalą ir jo visą kainą}
 for i:=1 to P do
 begin
	 write(fwrite, patiekalas[i].pav, ' ');
	 writeln(fwrite, visaPatiekaloKaina(patiekalas[i].kaina));
 end;

 write(fwrite, svecioKaina(patiekalas) div 100, ' '); //litai
 write(fwrite, svecioKaina(patiekalas) mod 100); //centai

 close(fwrite);
end;

begin
 skaityti();
 rasyti();
end.

Patarčiau vengti globalių kintamųjų :)

Patarčiau vengti globalių kintamųjų :)

Ai... čia tokia 'sudėtinga' programa, plius pascalis, tai nematau reikalo kitokių kintamųjų naudot. Ir rašyt mažiau ir susigaudyt lengviau.

Aš nesuprantu, kam jus procedurom globalius kintamuosius naudojat, naudos nėra. Teisingai sako mantasurnieza, egzamine man regis uz tokias klaidas minusuoja balus. :) Prie to pačio įmesiu irgi šiokia tokia egzaminine, tik nepamenu kurių metų:

program grybai;
const duom = 'U1.txt';
var b, r, l : array [1..31] of integer;
	i : integer;
	f : text;

procedure duomenu_nuskaitymas;
var n, b1, r1, l1, diena : integer;
begin
assign(f, duom);
reset(f);
readln(f, n);
for i:= 1 to n do begin
				  readln(f, diena, b1, r1, l1);
				  b[diena] := b1 + b[diena];
				  r[diena] := r1 + r[diena];
				  l[diena] := l1 + l[diena];
				  end;
close(f);
end;

procedure duomenu_irasymas;
begin
assign(f, 'U1rez.txt');
rewrite(f);
for i := 1 to 31 do begin
					if b[i] or r[i] or l[i] <> 0 then writeln(f, i,' ',b[i],' ',r[i],' ',l[i]);
					end;
end;

procedure daugiausia_grybu;
var diena, max, ls : integer;
begin
max := 0;
for i := 1 to 31 do begin
					ls := b[i] + r[i] + l[i];
					if ls > max then begin
									 max := ls;
									 diena := i;
									 end;
					end;
writeln(f, diena,' ',max);
close(f);
end;

begin
duomenu_nuskaitymas;
duomenu_irasymas;
daugiausia_grybu;
end.

Kiek žinau už globalius kintamuosius tik olimpiadose baudzia, egzaminuose ne.

Beje kas tiksliai yra tie globalūs kintamieji, kuo jie skiriasi nuo kitų ?

Aš nesuprantu, kam jus procedurom globalius kintamuosius naudojat, naudos nėra. Teisingai sako mantasurnieza, egzamine man regis uz tokias klaidas minusuoja balus. :) Prie to pačio įmesiu irgi šiokia tokia egzaminine, tik nepamenu kurių metų:

Už ciklo kintamąjį, aprašytą kaip globalų, reiktų tau nagus nukapot. :) :)

O dar nesupranta, kam procedūrom globalius naudojam ;D

Ir išviso, kurių aš globalių būčiau galėjęs išvengt? 4 aprašyti, visi 4 ir reikalingi tolimesnėse procedūrose.

Globalūs kintamieji tai tie kur tik programoj aprasyti, o lokalūs tie kur procedūrose, funkcijose būna naudojami, taip ?

Globalūs kintamieji tai tie kur tik programoj aprasyti, o lokalūs tie kur procedūrose, funkcijose būna naudojami, taip ?

Ne tik naudojami, bet svarbiausia kad aprašyti. Kurių negali pasiimt kitos procedūros, funkcijos, jei jie nepersiunčiami.

procedure suma (a, b : integer; var c : integer);

var i : integer;

Tai čia i būtų lokalus kintamasis ?

procedure suma (a, b : integer; var c : integer);

var i : integer;

 

Tai čia i būtų lokalus kintamasis ?

Aha. Bet vat ar a su b lokalūs jau nebežinau.

Aha. Bet vat ar a su b lokalūs jau nebežinau.

Globalūs, tik tiek kad neišvedami.

Aha. Bet vat ar a su b lokalūs jau nebežinau.

a ir b išvis yra procedūros argumentai, nemanau ar juos kas skirsto į globalius ir lokalius.

O šiaip kintamieji į šiuos tipus skirstomi pagal jų galiojimo sritį. Jei kintamasis galioja tik pagrindinėje programoje ar (tik) kitoje programos dalyje (procedūroje ar funkcijoje), jis vadinamas lokaliuoju. O jei kintamasis galioja visoje programoje (ir funkcijose bei procedūrose), jis vadinamas globaliu.

Ar globalus, ar lokalus kintamasis priklauso nuo to kurioje vietoje jis aprašomas:

program
 var g;

 function
var l;
 begin
 end;

 var l;
begin
end;

kur l, tan lokalūs, kur g - globalūs.