praleisti ženklai

Sveiki.

Ilgai galvojau ir nesugalvojau kaip reikia spręsti uždavinius kuomet reikia sudėlioti veiksmų ženklus

pvz 2 1 4 2=3

Veiksmai atliekami iš kairės į dešine nekreipiant dėmesio i dalybos daugybos pirmenybę.

Ar vienintelis būdas ir yra perrinkimas?

Sveiki.

Ilgai galvojau ir nesugalvojau kaip reikia spręsti uždavinius kuomet reikia sudėlioti veiksmų ženklus

pvz 2 1 4 2=3

Veiksmai atliekami iš kairės į dešine nekreipiant dėmesio i dalybos daugybos pirmenybę.

Ar vienintelis būdas ir yra perrinkimas?

Aiškiau suformuluok ko nori iš mūsų, nes mes ne ekstraseansai...

Šiaip tai 2*1+4/2=3

dar

2 - 1 + 4 - 2 = 3

Aiškiau suformuluok ko nori iš mūsų, nes mes ne ekstraseansai...

o spėju jis turėjo galvoj, klausimą ar yra kox nors algoritmas, kuriuo būtų galima sužinot tuos ženklus, o ne bruteforce'int lygtį bandant visus įmanomus variantus. Gan aišiai parašė :)

@ia sud4tingesnis pavyzdys

Parašykite programą, kuri tarp duotojo skaičiaus skaitmenų įterptų simbolius „+“, „−“,

„*“, „/“ ir lygiai vieną simbolį „=“ taip, kad išeitų teisinga lygybė. Tarp kiekvienos

gretimų skaitmenų poros turi būti įterptas lygiai vienas iš išvardintų simbolių.

Kad Juliui būtų lengviau skaičiuoti mintinai, susitarsime, kad:

• kiekvienoje lygybės pusėje reiškinio reikšmė skaičiuojama atliekant veiksmus iš

kairės į dešinę, t. y., nekreipiant dėmesio į operacijų prioritetus. Pavyzdžiui,

reiškinys 1 + 2 * 3 − 4 / 5 turi būti apskaičiuojamas taip: (((1 + 2) * 3) − 4) / 5 = 1;

Jeigu 2715534 tai pavyzdžiui 2*7*1+5=5*3+4

5132 tai 5+1=3*2

Man reikia, kad užvestumėte ant kelio sudarant algortimą.Pradziai pakaktu ir sudelioti zenklus vienoje puseje, pvz z x c=10. Manau, kad turi būti efektivesnis sprendimas nei tikrinti visus įmanomus variantus.

Šiaip tai 2*1+4/2=3

http://www.gogaminggiant.com/wp-content/uploads/2010/07/facepalm.jpg

Šiaip tai 2*1+4/2=3

4=3, ane?

4=3, ane?

paskaityk atidžiau sąlygą.. daugyba ir dalyba neturi pirmumo teisės

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.