Pascal egzaminine uzduotis-Varzybos

Taigi, bandau isspresti sia egzaminine uzduoti, anksciau jau siameforume prasiau pagalbos delsios uzduoties, bet tuomet padariau nepilna josdali, o dabar noriu padaryti pilna.Yra kelios begiku katinu grupes, reikia is tu grupiu atrinkti puse grupes-greiciausiu katinu, jeigu nelyginis skaicius grupes nariu,tai prideti prie ju nariu skaiciaus 1 ir padalinti is 2.Na zodziu atlikau viska ka reikia, bet meta klaida ranges overrun,gal kas galit pagelbeti :) Komentarai surasyti sone, koks kodas uz ka atsakingas :) Taip pat sukuriau masyva masyve, kitaip sakant record tipas yra kaip masyvas ir jame esantys kintamieji yra dar masyvai :)

program varzybos;

type grupe=record
   vard:array[1..10] of string[18];
   min,sek:array[1..10] of integer;
end;

type mas=array[1..10] of grupe;
type masyv=array[1..10] of integer;


var i,k,j,b,tmp,tmp1:integer;
tmp2:string[18];
puse,n:masyv;
Df,Rf:text;
A:mas;

procedure Duomenys; [color="#000000"]//Nuskaito duomenis is duomenu failo[/color]
begin
   j:=1;
   Assign(Df,'U2.txt');
   Reset(Df);
   Readln(Df,k);
   for b := 1 to k do
   begin
       ReadLn(Df, n[b]); [color="#000000"]//nuskaito grupes nariu skaiciu[/color]
       for j:=1 to n[b] do
       Readln(Df,A[b].vard[i],A[b].min[i],A[b].sek[i]); [color="#000000"]//nuskaito grupes nariu duomenis[/color]
   end;
   Close(Df);
end;

procedure rikiavimas; [color="#000000"]//issrikiuoja narius nuo greiciausio iki leciausio[/color]
begin
   tmp:=0;
   tmp1:=0;
   Readln(Df,k);
   for b:=1 to k do
   begin
       Readln(Df,n[b]);
       for j:=1 to n[i] do
       begin
           for i:=1 to n[i] do
           begin
               if (A[b].min[j] < A[b].min[i]) or (A[b].min[j] = A[b].min[i]) and (A[b].sek[j] < A[b].sek[i]) then [color="#000000"]//lygina narius, jeigu atranda nari, kuris yra greitesnis, tai ji iskelia i virsu, o letesni nuleidzia i apacia :)[/color]
               begin
                   tmp := A[b].min[i];
                   A[b].min[i] := A[b].min[j];
                   A[b].min[j] := tmp;
                   tmp1 := A[i].sek[i];
                   A[b].sek[i] := A[b].sek[j];
                   A[b].sek[j] := tmp1;
                   tmp2 := A[i].vard[i];
                   A[b].vard[i] := A[b].vard[j];
                   A[b].vard[j] := tmp2;
               end;
           end;
       end;
   end;
end;
procedure atrinkimas; [color="#000000"]//atrenka tuos puse grupes nariu, kurie yra greiciausiai,kadangi jie jau isrikiuot didejimo tvarka, mumstereikia padalinti[/color]
begin
   for j := 1 to k do
   begin
       puse[j]:=n[j] div 2;
       for i := 1 to puse[j] do
       WriteLn(Rf, A[j].vard[i],' ',A[j].min[i],' ',A[j].sek[i]);
   end;
end;

begin
 Duomenys;
 rikiavimas;
 Assign(Rf,'U2rez.txt');
 Rewrite(Rf);
 atrinkimas;
 Close(Rf);
end.

Pridėk duomenų failą.

3
4
Katinas Batuotas  4 25
Katinas Ratuotas  3 59
Katinas Rainas    4 15
Katinas Jaunas    6 20
2
Katinas Rudas     6 25
Katinas Juodas    3 55
5
Katinas Baltas    3 58
Katinas Gauruotas 4 2
Katinas Plikas    4 5
Katinas Ilgas     4 4
Katinas Trumpas   4 6

Duomenu failo turinys cia :)

Čia tavo kodas patvarkytas nebus klaidos, o dėl rezultato tikslumo nežinau.

Klaidos čia buvo

1. Nebuvo i kintamojo o buvo b

Readln(Df,A[b].vard[i],A[b].min[i],A[b].sek[i]); [color="#000000"]//nuskaito grupes nariu duomenis[/color]

2. Rikiavime kam nuskaitymas dar? Readln(kažkas....); nereik

Patvarkyta.

program varzybos;

type grupe=record
vard:array[1..50] of string[18];
min,sek:array[1..50] of integer;
end;

type mas=array[1..50] of grupe;
type masyv=array[1..50] of integer;


var i,k,j,b,tmp,tmp1:integer;
tmp2:string[18];
puse,n:masyv;
Df,Rf:text;
A:mas;

procedure Duomenys; //[color="#000000"]//Nuskaito duomenis is duomenu failo[/color]
begin
Assign(Df,'U2.txt');
Reset(Df);
Readln(Df,k);
//writeln(k);
for b:= 1 to k do
begin
   	ReadLn(Df, n[b]); ///[color="#000000"]//nuskaito grupes nariu skaiciu[/color]
   	//writeln(n[b]);
   	for j:=1 to n[b] do
   	begin
       	Readln(Df,A[b].vard[j],A[b].min[j],A[b].sek[j]); ///[color="#000000"]//nuskaito grupes nariu duomenis[/color]
       	//writeln(A[b].vard[j],A[b].min[j],' ',A[b].sek[j]);
   	end;
end;
Close(Df);
end;

procedure rikiavimas; //[color="#000000"]//issrikiuoja narius nuo greiciausio iki leciausio[/color]
begin
tmp:=0;
tmp1:=0;
 //  Readln(Df,k);
for b:=1 to k do
begin
//	Readln(Df,n[b]);
   	for j:=1 to n[b] do
   	begin
       	for i:=1 to n[b] do
       	begin
           	if (A[b].min[j] < A[b].min[i]) or (A[b].min[j] = A[b].min[i]) and (A[b].sek[j] < A[b].sek[i]) then //[color="#000000"]//lygina narius, jeigu atranda nari, kuris yra greitesnis, tai ji iskelia i virsu, o letesni nuleidzia i apacia :)[/color]
           	begin
               	tmp := A[b].min[i];
               	A[b].min[i] := A[b].min[j];
               	A[b].min[j] := tmp;
               	tmp1 := A[i].sek[i];
               	A[b].sek[i] := A[b].sek[j];
               	A[b].sek[j] := tmp1;
               	tmp2 := A[i].vard[i];
               	A[b].vard[i] := A[b].vard[j];
               	A[b].vard[j] := tmp2;
           	end;
       	end;
   	end;
end;
end;
procedure atrinkimas; //[color="#000000"]//atrenka tuos puse grupes nariu, kurie yra greiciausiai,kadangi jie jau isrikiuot didejimo tvarka, mumstereikia padalinti[/color]
begin
for j := 1 to k do
begin
   	puse[j]:=n[j] div 2;
   	for i := 1 to puse[j] do
   	WriteLn(Rf, A[j].vard[i],' ',A[j].min[i],' ',A[j].sek[i]);
end;
end;

begin
 Duomenys;
 rikiavimas;
 Assign(Rf,'U2rez.txt');
 Rewrite(Rf);
 atrinkimas;
 Close(Rf);
end.

Paprastesnis kodas būtu jei laiką pasiverstum į minutes ir tada skaičiuotum, rikiuotum, o įrašant vėl atgal paverti į sekundes ir minutes.

As ta i pakeiciau kintamuoju j, bet vistiek meta klaida ranges overrun, ka tai galetu reiksti? :)

As ta i pakeiciau kintamuoju j, bet vistiek meta klaida ranges overrun, ka tai galetu reiksti? :)

Klaida reiškia masyvo indekso viršijimą

Rikiavime dar ten patvarkiau pasižiūrėk. .

for j:=1 to n do

As ta i pakeiciau kintamuoju j, bet vistiek meta klaida ranges overrun, ka tai galetu reiksti? :)

a) bandai priskirti per didelę reikšmę kintamajam

b) bandai atlikti veiksmą su neegzistuojančiu masyvo elementu.

a) tarkim turi integer tipo kintamąjį x. Maksimalus skaičius kurį gali priskirti integeriui yra apie 32 000, tai jei bandytum x priskirti 89 486 išmestu ši error.

b) Turi masyvą A:array [1.10] of integer; Jei bandytum atlikti veiksmą su masyvo elementu neesančiame intervale [1;10] (pvz A[11] ar A[-5]), tai irgi išmestu tą patį error. Dažniausiai šį klaidą atsiranda (nors pas mane) blogai suprogramavus nuskaitinėjimą.

P.S. Visados išmetus klaidai gali pažiūrėti kurioje kodo eilutėje tą klaidą išmeta. Tereikia uždaryti klaidos pranešimą ir paspausti alt+F5. Pamatysi kažką panašaus į:

Runtime error 201 at 0x0040CF54

0x0040CF54 main, line 6 of c:/xxx/local/temp/noname2.pas

0x0040C609

Paryškinta vieta nurodo eilutės numerį. Šis dalykas labai padeda sutaupyti laiko, kas egzamine labai svarbu :) .

Tai man meta klaida 39 eiluteje, kitaip sakant, ten kur yra rikiavimas, ties "for b:=1 to k do" eilute, bet ten nieko blogo neizvelgiu kaip ir :) Wigai, o gali paaiskinti kam tu taip padarei? :)

Tai man meta klaida 39 eiluteje, kitaip sakant, ten kur yra rikiavimas, ties "for b:=1 to k do" eilute, bet ten nieko blogo neizvelgiu kaip ir :) Wigai, o gali paaiskinti kam tu taip padarei? :)

Mano kodą bandai meta klaidą ? Pas tave ten blogai buvo padaryta su kintamaisiais sumaišyta. O būtent ką padariau nori sužinoti?

Čia mano programa rašyta seniau, pas tave dar kažkur klaida yra skaičiavime.

program varzybos;
type sarasas=record
       	vardas:string[18];
       	laikas:integer;
end;
mas=array[1..50] of sarasas;

//Surandame geriausią bėgiką.
function Geriausias(k:integer; GG:mas):integer;
var i,nr,m:integer;
begin
nr:=0; m:=0;
for i:=1 to k do
if GG[i].laikas > m
then m:=GG[i].laikas;

for i:=1 to k do
if GG[i].laikas <= m then
begin
   	m:=GG[i].laikas;
   	nr:=i;
end;
Geriausias:=nr;
end;

//Perrikiojame masyvą ir pašaliname geriausią bėgiką
procedure Perrikiojame(id,k:integer; var GG:mas);
var i:integer;
begin
for i:=id to k-1 do
begin
   	GG[i].vardas:=GG[i+1].vardas;
   	GG[i].laikas:=GG[i+1].laikas;
end;
end;

//Surikiuojame masyvą laiko didėjimo tvarka
procedure Rikiavimas(k:integer; var G:mas);
var i,j,laikas:integer;
vardas:string[20];
begin
for i:=1 to k-1 do
   	for j:=i+1 to k do
   	if G[i].laikas > G[j].laikas then
   	begin
       	vardas:=G[j].vardas;
       	G[j].vardas:=G[i].vardas;
       	G[i].vardas:=vardas;
       	laikas:=G[j].laikas;
       	G[j].laikas:=G[i].laikas;
       	G[i].laikas:=laikas;
   	end;
end;
//Nuskaituome failą.
procedure Duomenys(var kk:integer; var G:mas);
var i,j,n,k,id,kiek,ii,min,sek:integer;
F1:text;
GG:mas;
begin
assign(F1,'U2.txt');
reset(F1);
readln(F1,n);
ii:=0;
for i:=1 to n do
begin
   	readln(F1,k);
   	for j:=1 to k do
   	begin
       	readln(F1,GG[j].vardas,min,sek);
       	GG[j].laikas:=(min*60)+sek;
   	end;
   	//Apskaičiuojame kiek reikės geriausių rezultatų iš grupės.
   	kiek:=k mod 2;
   	if kiek = 0 then kiek:=k div 2
   	else kiek:=round(k/2);
   	//Skaičiuos kiek bus išviso geriausių bėgikų.
   	kk:=kk+kiek;
   	//Ciklas vyks tiek kiek reikės atrinkti iš grupės geriausių bėgikų.
   	while kiek > 0 do
   	begin
       	ii:=ii+1;
       	id:=Geriausias(k,GG); //Surandame geriausio bėgiko indeksą masyve.
       	G[ii].vardas:=GG[id].vardas; //Priskiriame kitam masyvui geriausią rezultatą.
       	G[ii].laikas:=GG[id].laikas;
       	Perrikiojame(id,k,GG); //Pašaliname iš masyvo geriausią rezultatą.
       	kiek:=kiek-1;
   	end;
end;
close(F1);
end;
//Įrašome failą.
procedure Rezultatas(k:integer; G:mas);
var i:integer;
F2:text;
begin
assign(F2,'U2rez.txt');
rewrite(F2);
for i:=1 to k do
writeln(F2,G[i].vardas,' ',G[i].laikas div 60,' ',G[i].laikas mod 60);
close(F2);
end;
//Programa
var G:mas;
k:integer;
begin
Duomenys(k,G);
Rikiavimas(k,G);
Rezultatas(k,G);
end.