[PASCAL] optellen aftrekken etc..

[GeNiTaLiX]

Hoi,

Ik heb een vraaggie, Ik wil een progje make waarin je op kan geven wat voor soort sommen je wilt doen, dus :

code:

    CASE keuze OF
      1: soort:='+';
      2: soort:='*';
      3: soort:='/';
      4: soort:=random(keuze);
    END;

Maar het probleem is dat je hiermee niet verder kan werken door ermee te rekenen, zit er niets anders op dan voor elk een procedure te maken o.i.d?

thx

btw

UNTIL leven=0 OR raad=getal;

was er mis met deze OR ?

[newpegasus]

heb je soort wel gedeclareerd als zijnde een variabele?

en is het niet leven="0" ?

[GeNiTaLiX]

soort is gedeclareerd als een char, en leven hoort zo... integers kunnen gwoon zo , ' ' is voor tekst en " " kent pascal niet.

[Verwijderd]

GeNiTaLiX schreef op 07 oktober 2004 @ 19:49:
btw

UNTIL leven=0 OR raad=getal;

was er mis met deze OR ?

"Or" heeft voorrang op "=", dus ziet pascal "0 or raad" als eerst, waardoor de rest fout gaat. Zet haakjes om je vergelijkingen dus

code:

until (leven = 0) or (raad = getal)

[GeNiTaLiX]

kee thx, nu nog het eigenlijke probleem

[NMe]

Misschien kun je proberen uit te leggen wat je met het "eigenlijke probleem" nou eigenlijk wil? Als keuze gelijk is aan '+', twee waarden optellen?

Delphi:

    CASE keuze OF
      1: waarde := waarde1 + waarde2;
      2: waarde := waarde1 * waarde2;
      3: waarde := waarde1 / waarde2
    END;

[Dutchie!]

laat je hele broncode eens zien en duidelijk je opdracht eens omschrijven want waarom heb je een leven nodig als je wilt optellen enzo ?

[GeNiTaLiX]

code:

VAR keuze,x:integer;
    soort:char;

BEGIN
  readln(keuze);
    CASE keuze OF
      1: soort:='+'; // hier keuze van optellen
      2: soort:='-';
      3: soort:='*';
    END;
  x:=random(100),soort,random(100); //hier moet ie dus de berekening van je keuze uitvoeren //werkt nie
  writeln(x); //werkt niet
  writeln((random(100),soort,random(100)); //werkt nie
  readln;

[Dutchie!]

Je wilt dus 2verschillende getallen (random door de computer) laten optellen zegmaar. correct ? en jij kan kiezen wat die gaat doen, + of - of : toch ? dat is je doel ?

Als dit je doel is, zou ik het denk ik anders maken maar pascal is al poosje geleden voor mij. Eigenlijk zou ik er weer eens in moeten gaan werken. Was altijd wel leuk

[SysRq]

Wat je beter kunt doen:

2 nieuwe integer variabelen voor de random functies. Dan kunt je dat ook weer presenteren. Op jouw manier kun je nooit meer achterhalen hoe de berekening tot stand gekomen is. 2x writeln(random(100)) geeft namelijk 2x een ander resultaat.

Het case-statement kun je beter zoiets van maken:

code:

CASE keuze OF
  1: x:= a + b;
  2: x:= a - b;
  3: x:= a * b;
end;

A en B zijn dan de variabelen die je met een random(100) gevuldt hebt.

Bekijk trouwens eens de help voor de functie writeln(); Je geeft nu namelijk een integer mee, terwijl de compiler een string verwacht.

Succes.

[Tomatoman]

GeNiTaLiX schreef op 07 oktober 2004 @ 20:23:

code:

stukje Pascal

Wat bedoel je precies met 'werkt nie'? De compiler geeft met zijn foutmeldingen duidelijk aan wat je niet goed doet.

Ik snap trouwens niet wat je op regel 11 probeert te doen. Lees in je leerboek nog eens na hoe je een functie of procedure schrijft en hoe je die aanroept, want ik vermoed dat dat is wat je probeert te doen.

Over regel 12: lees de documentatie eens na om te zien wat voor soort parameter WriteLn verwacht.

Over regel 13: je geeft nu drie parameters op, terwijl WriteLn er maar één verwacht.

[cinnamon]

Pascal is zeer strict met zijn regeltjes en wat dat betreft zou ik de verschillen tussen variabelen, variabele typen en operators nog eens doorlezen.

Voor zover mijn geheugen me niet in de steek laat , was er ook nog iets met 'Randomize'.

Verder zitten er, zoals al gemeld, meer fouten in de code, zodat de meldingen van de compiler je niet veel zullen helpen het geschetste probleem op te lossen.

[GeNiTaLiX]

een procedure aanroepen, ? .. nee da week wel hoe da werkt, dat was ook niet de eigenlijke code maar een simpel voorbeeld .. maar ik denk dat ik het ook wel zo ga doen.. met x:= a + b , alhoewel ik dan alle functies anders moet make .. hehe .. maar thx

mossolz

[Microkid]

code:

VAR keuze, x : integer;

BEGIN

  readln(keuze);
  CASE keuze OF
      1: x:=random(100) + random(100);
      2: x:=random(100) - random(100);
      3: x:=random(100) * random(100);
    END;
  writeln(x);

END

[ Voor 8% gewijzigd door Microkid op 07-10-2004 21:33 . Reden: END vergeten (is al weer 15 jaar geleden dat ik Pascal programmeerde ;)) ]

[Verwijderd]

Als ik het goed begrijp moet het een spelletje worden waarin kinderen sommen moeten oplossen; en je wil geloof ik weten hoe je kan opslaan wat voor soort sommen je wilt maken, en hoe je daar later mee kan rekenen.

Het probleem is dat Pascal geen functie heeft om een expressie in een string te evalueren, dus dat zul je (helaasch) zelf moeten maken. Je kan het naar smaak object-georienteerd doen (elke operator wordt dan een object), of je kan het met een jump-table doen.

Eenvoudig (niet erg net) voorbeeld:

Delphi:

function RandomOp : char;
begin
  case Random(4) of
    0 : Result := '+';
    1 : Result := '-';
    2 : Result := '*';
    3 : Result := '/';
    else Result := '/';
  end;
end;

function PlusFunction(a, b : Real) : Real;
begin
  Result := a + b;
end;

function MinusFunction(a, b : Real) : Real;
begin
  Result := a - b;
end;

function TimesFunction(a, b : Real) : Real;
begin
  Result := a * b;
end;

function DivFunction(a, b : Real) : Real;
begin
  Result := a / b;
end;

type
  TCalcFunction = function(a, b : Real) : Real;

var 
  Jumps : Array[char] of TCalcFunction;
  Input : String;
  DesiredOp : Char;
  a, b, c : Real;
  Guess : Real;

begin
  Randomize;

  FillChar(Jumps, 0, SizeOf(Jumps));
  Jumps['+'] := @PlusFunction;
  Jumps['-'] := @MinusFunction;
  Jumps['*'] := @TimesFunction;
  Jumps['/'] := @DivFunction;

  repeat
    WriteLn('Wat voor soort sommen wil je? +, -, *, / of leeg voor willekeurig');
    ReadLn(Input);
    If Length(Input) > 0 then
      DesiredOp := Input[1]
    else
      DesiredOp := RandomOp;
  until DesiredOp in ['+', '-', '*', '/'];

  a := Random(100);
  b := Random(100);

  c := Jumps[DesiredOp](a, b);

  WriteLn('Hoeveel is', a, DesiredOp, b, '?');
  ReadLn(Guess);

  If Guess = c then
    WriteLn('Goed!')
  else
    WriteLn('Fout! Het goede antwoord was', c);
end.

Deze code werkt alleen als je Delphi gebruikt (Turbo Pascal 7.0 misschien ook, weet ik niet zeker). Zoniet, dan moet je in de functies Result := vervangen door <FunctieNaam> :=.

Verder is de I/O niet echt top geregeld; ik weet niet zeker of het mogelijk is om Reals zo te ReadLn'en namelijk. Maar het illustreert het idee.

[GeNiTaLiX]

ahh ja mooi gedaan, 't werkt in me bloodshed pascal, alleen moeten het wel integers zijn, bij real worden het sommen van 20000000000e10 + 23000000000E10 hehe

ma thx

btw. waarvoor is deze regel:

code:

 FillChar(Jumps, 0, SizeOf(Jumps));

die is toch overbodig ?

[ Voor 27% gewijzigd door GeNiTaLiX op 07-10-2004 23:34 ]

[SvMp]

Pascal kan niet zomaar functies in een string gaan uitrekenen zonder dat je daar zelf het een en ander voor programmeert.

Alleen talen die veel hoger zijn kunnen dat (script talen). PHP kan daar bv. heel ver in gaan door complete regels PHP uit strings uit te voeren.

[ Voor 7% gewijzigd door SvMp op 07-10-2004 23:36 ]

[SvMp]

(per ongeluk, kan een modje dit weghalen)

[ Voor 85% gewijzigd door SvMp op 07-10-2004 23:36 ]

[curry684]

Sorry maar dit is echt niet de categorie vragen voor GoT, lees aub je boek nog eens een paar keer want dit is echt te basaal voor een topic