mantasurnieza

Prieš porą metu esu daręs šitokį uždavinį:

Aritmetiniame reiškinyje a ™ b ™ c ™ d ™ e = r operacijų ženklai uždengti. Jame gali būti naudojamos sveikųjų skaičių operacijos +, –, *, div, mod.

Pradiniai duomenys įrašyti faile duom.txt. Vienintelėje failo eilutėje įrašyti šeši tarpais atskirti sveiki neneigiami skaičiai a, b, c, d, e, r (a, b, c, d, e, r ≤ 3000).

Rezultatas – gautas reiškinys arba žodis negalima – įrašomas į failą rez.txt. Reiškinio elementai tarpusavyje atskiriami vienu tarpu.

Pastaba. Tarpiniai skaičiavimo rezultatai neperžengia tipo int64 rėžių.

Pradinių duomenų ir rezultatų pavyzdys

Pradiniai duomenys

4 3 2 3 1 6

Rezultatas

4 mod 3 + 2 * 3 – 1 = 6

Vietoj brutinim'o pasirinkau backtracking'ą. Va dar turiu savo programą, gal kils kokia idėja žiūrint.

{
Visas reiškinys saugomas masyve. Kiekvienas skaičius ir operatorius
sudaro atskirą elementą. Iš viso yra 11 elementų. Grįžimo metodu
išbandomi visi galimi operacijų ženklų variantai, arba kol
randamas sprendinys.
 	Funkcija, kuri tikrina ar reiškinys teisingas, tikrina iš eilės
visus masyvo elementus ir kai randa aritmetinę operaciją ją atlieka.
Iš pradžių atliekama daugyba ir dalyba. Kai reiškinyje nebelieka
daugybos ir dalybos operatorių, atliekama sudėtis ir atimtis.
Atlikus visus veiksmus, lyginama kairė ir dešinė pusės nuo lygybes.
 	Atliekant aritmetinę operaciją, pirmojo operando vietoje įrašomas
operacijos rezultatas, ženklo ir antro operando vieta užpildoma dešinėje
esančiais elementais. Visi kiti likę dešinieji elementai perstumiami
per 2 vietas į kairę.
}
program urnie126;
type masyvas  = record
  	ilgis : longint;
  	x : array[1..11] of string;
	end;
////////////////////////////////////

 function tikrinti (sk : masyvas) : boolean;
var i, j, indeksas : integer;
   	a, b : int64;
   	ats : string;
 begin
 tikrinti := false;
 //Daugyba, dalyba
for i := 1 to sk.ilgis do
 	begin
// *
   	if sk.x[i] = '*'
     	then
       	begin
         	val (sk.x[i-1], a);
         	val (sk.x[i+1], b);
         	str (a * b, ats);
         	sk.x[i-1] := ats;
         	indeksas := i - 1;
         	for j := i + 2 to sk.ilgis do
           	begin
             	inc(indeksas);
             	sk.x[indeksas] := sk.x[j];
           	end;
         	sk.ilgis := sk.ilgis - 2;
         	i := i - 1;
         	sk.x[sk.ilgis + 2] := '';
         	sk.x[sk.ilgis + 1] := '';
       	end
   	else
// div
   	if (sk.x[i] = 'div')
     	then
       	begin
         	val (sk.x[i-1], a);
         	val (sk.x[i+1], b);
         	str (a div b, ats);
         	sk.x[i-1] := ats;
         	indeksas := i - 1;
         	for j := i + 2 to sk.ilgis do
           	begin
             	inc(indeksas);
             	sk.x[indeksas] := sk.x[j];
           	end;
         	sk.ilgis := sk.ilgis - 2;
         	i := i - 1;
         	sk.x[sk.ilgis + 2] := '';
         	sk.x[sk.ilgis + 1] := '';
       	end
   	else
// mod
   	if (sk.x[i] = 'mod')
     	then
       	begin
         	val (sk.x[i - 1], a);
         	val (sk.x[i + 1], b);
         	str (a mod b, ats);
         	sk.x[i-1] := ats;
         	indeksas := i - 1;
         	for j := i + 2 to sk.ilgis do
           	begin
             	inc(indeksas);
             	sk.x[indeksas] := sk.x[j];
           	end;
         	sk.ilgis := sk.ilgis - 2;
         	i := i - 1;
         	sk.x[sk.ilgis + 2] := '';
         	sk.x[sk.ilgis + 1] := '';
       	end;
 	end;
 // Sudetis, atimtis
for i := 1 to sk.ilgis do
 	begin
   	if sk.x[i] = '+'
     	then
       	begin
         	val (sk.x[i-1], a);
         	val (sk.x[i+1], b);
         	str (a + b, ats);
         	sk.x[i-1] := ats;
         	indeksas := i - 1;
         	for j := i + 2 to sk.ilgis do
           	begin
             	inc(indeksas);
             	sk.x[indeksas] := sk.x[j];
           	end;
         	sk.ilgis := sk.ilgis - 2;
         	i := i - 1;
         	sk.x[sk.ilgis + 2] := '';
         	sk.x[sk.ilgis + 1] := '';
       	end
// -
   	else
   	if sk.x[i] = '-'
     	then
       	begin
         	val (sk.x[i-1], a);
         	val (sk.x[i+1], b);
         	str (a - b, ats);
         	sk.x[i-1] := ats;
         	indeksas := i - 1;
         	for j := i + 2 to sk.ilgis do
           	begin
             	inc(indeksas);
             	sk.x[indeksas] := sk.x[j];
           	end;
         	sk.ilgis := sk.ilgis - 2;
         	i := i - 1;
         	sk.x[sk.ilgis + 2] := '';
         	sk.x[sk.ilgis + 1] := '';
       	end;
 	end;

tikrinti := sk.x[1] = sk.x[3];
 end;
//////////////////////////////////
 procedure spręsti (var arg, ats : masyvas;  žingsnis : integer; var rasta : boolean);
var i : integer;
 begin
if žingsnis = 5
 	then
   	begin
     	if tikrinti(arg)
       	then
         	begin
           	rasta := true;
           	ats := arg;
         	end;
   	end
 	else
   	begin
     	if not rasta
       	then
         	begin
           	arg.x[žingsnis * 2] := '*';   spręsti(arg, ats, žingsnis + 1, rasta);
           	if arg.x[žingsnis*2+1] <> '0'
             	then arg.x[žingsnis * 2] := 'div'; spręsti(arg, ats, žingsnis + 1, rasta);
           	if arg.x[žingsnis*2+1] <> '0'
             	then arg.x[žingsnis * 2] := 'mod'; spręsti(arg, ats, žingsnis + 1, rasta);
           	arg.x[žingsnis * 2] := '+';   spręsti(arg, ats, žingsnis + 1, rasta);
           	arg.x[žingsnis * 2] := '-';   spręsti(arg, ats, žingsnis + 1, rasta);
         	end;
   	end;
 end;
////////////////////////////////////
var fin, fout : text;
ats, skaičiai : masyvas;
i, skaitmenų : integer;
eilė, sk : string;
rasta : boolean;
begin
 assign (fin, 'duom.txt');  reset (fin);
 assign (fout, 'rez.txt');  rewrite (fout);
 ReadLn (fin, eilė);
 skaitmenų := 1;
 for i := 1 to length(eilė) do
begin
 	if eilė[i] <> ' '
   	then sk := sk + eilė[i]
   	else begin
     	skaičiai.x[skaitmenų] := sk;
     	sk := '';
     	skaitmenų := skaitmenų + 2;
   	end;
end;
 skaičiai.x[11] := sk;
 skaičiai.x[10] := '=';
 skaičiai.ilgis := 11;
 spręsti (skaičiai, ats, 1, rasta);
 if rasta
then
 	for i := 1 to 11 do
   	Write (fout, ats.x[i], ' ')
else Write (fout, 'negalima');
 close(fin);  close(fout);
end.

Nu manau ten dideles problemos nera, tai manau susitarsim jau.Tai manau prma uzmesk aki, paskui sakyk kaina.

Vis dar reikia, jei taip, email: [email protected]

Aš taip pat gavau pakvietima, manau bandysiu siųsti prašymą ;)

Ignoruok

Važiuosim turbūt su drauge prie jūros šito grožio žiūrėt :)

Aš gavau 5 bendrabutį :D

KTU irgi sutvarkė B-)

Aš ryt ryte irgi važiuoju į KTU prašymo rašyt :)

KTU informatika. :o Will anybody join me?

Nu va gal kursiokai būsim :o

 

 

1 KTU 612I10004 0620 informatika vf NL I 19.04 19.04 kvietimas, NL

1 KTU 612I10004 0620 informatika (kompiuteriniai tinklai ir internetas; medicinos informatika; programavimo technologijos; bankų duomenų centrai) vf NL

19.36 19.36 kvietimas, NL

Nereikalingas egzaminas ir man, tik įdomu buvo išbandyti save :) likau patenkintas - 88%

Manęs nepamirškit į jį pakviesti :)

Draugė gavo 28%, manau mažokai pagal jos turimas žinias. Viską persisprendėm, suskaičiavom, tai manau, ji turėjo surinkti 41/65 balų. Ar ne per mažai procentų? Aš be abejonės rašyčiau apeliaciją ;)

96, valio :)

70 gavau, puiku ;)

Čia šeštas

Rajone vienas surinko 99%, dviese po 96%, vienas 91%, vienas 80%.

Čia iš tų geresnių, laikėm 21 ;)

96% :/

Jaučiu NEC'as jau išjungė savo telefoną ;)

pries sedima uz vairo pats netinkamiausias laikas ;)

Arba sėdint už vairo :)

Citata iš kito forumo:

"..skambinau i NEC'a ,sake bus po pietu mokykloje rezultatai... "

"..NEC'e sake po pietu,sakau tai kada tiksliau,sako nu ka zn,gal iki 3 turetu buti... "

būkim kantrūs ;)

Su alum idėja gera ;)

Tas "turbūt" dar guodžia ;)