[Pascal]recursieve palindroom tester

[Shook]

Hey, Ik moet een recursieve palindroom tester maken, en naar mijn idee klopt de code. Pascal is het er alleen niet mee eens. In mijn (en lerares) begrip is een palindroom een woord wat je vanaf het midden kan omdraaien. Denk dus aan:
Radar, regelnevenleger, meetsysteem, maar hij zou dus ook 12344321 en 1234321 moeten pakken. Dit is de code:


program palindroompje;
uses wincrt;

var woord:string;
teller,positie1,positie2:integer;


procedure PalinRec(t,p1,p2:integer;w:string);
begin
if t < ((length(w))/2) and (w[(p1)]) = (w[(p2)]) then
begin
PalinRec(t+1,p1+1,p2-1,w);
writeln('Het is een palindroom');
end;

else
writeln('Helaas het is GEEN palindroom');
end;


begin
teller:=0;
positie1:=1;
positie2:=(length(woord));
writeln('Geef een palindroom, en het programma zal het testen');
readln(woord);
PalinRec(teller,positie1,positie2,woord);
end.


Het probleem is dat hij het "="-teken niet snapt tussen de "(w[(p1)]) = (w[(p2)])" met als fout melding een type mismatch.

Ik weet dat er ook nog een div in moet bij de gedeeld door 2, maar das niet het probleem nu. Thanxs alvast voor reacties.

[MeIsTwisted]

Delphi:

program palindroompje;
uses wincrt;

var woord:string;
teller,positie1,positie2:integer;


procedure PalinRec(t,p1,p2:integer;w:string);
begin
if t < ((((length(w))/2) = (w[(p2)])) and ((w[(p1)]) = (w[(p2)]))) then
begin
PalinRec(t+1,p1+1,p2-1,w);
writeln('Het is een palindroom');
end;

else
writeln('Helaas het is GEEN palindroom');
end;


begin
teller:=0;
positie1:=1;
positie2:=(length(woord));
writeln('Geef een palindroom, en het programma zal het testen');
readln(woord);
PalinRec(teller,positie1,positie2,woord);
end.

moet het dit niet zijn? ik kan me vergissen hoor

[Knutselsmurf]

Pak het probleem eens een klein beetje anders aan.

string X is een palindroom als de eerste en de laatste karakters gelijk zijn en de rest van de string een palindroom is. Een lege string en een string met 1 enkel karakter zijn ook palindromen.


De manier zoals jij het hebt opgeschreven is niet recursief.

[Soultaker]

De gegeven procedure is zeker wél recursief! Ik kan echter niet direct zien wat er mis mee is. Dit vraagt dus om een debugsessie. Heb je dat al geprobeerd?

[Shook]

hey cool, wist ik veel dat je dit in een pascal schermpje kon doen

maar dit is niet de oplossing. Je zegt nu:

als t < lengte woord / 2 = 1e positie van het woord en jadajada

een < en = in een vergelijking kan niet echt.

[MeIsTwisted]

stom, lama, ben een btje brak van weekend

[Soultaker]

Gebruik voortaan trouwens [code]-tags, svp, dat leest wel zo makkelijk.

[Sybr_E-N]

Loop je if-statement eens na, denk dat het probleem in (w[(p1)]) zit. Moet dat niet w[p1] zijn?.

[Soultaker]

Dat maakt niet uit Sybr. Enkelvoudige termen tussen haakjes worden gewoon als zodanig ge-evalueert (feitelijk elimineert de compiler ze al).

Als ik de topicstarter goed begrijp (al is 'ie niet zo duidelijk) lag het aan het verkeerd plaatsen van haakjes in de if constructie; dit moest: " if ((t < (length(w) / 2) and (w[p1] = w[p2]))" (of iets dergelijks) worden, zoals Shook suggereerde.

[Knutselsmurf]

Soultaker schreef op 11 November 2002 @ 21:33:
De gegeven procedure is zeker wél recursief! Ik kan echter niet direct zien wat er mis mee is. Dit vraagt dus om een debugsessie. Heb je dat al geprobeerd?

De oplosmethode is niet recursief, de implementatie wel. Terwijl de ECHTE recursieve oplossing, zoals ik hierboven beschreven heb, in mijn ogen charmanter is en eenvoudiger te debuggen.


Zal zoiets worden:

code:

function palindroom(s:string):boolean;
begin
  result:=
      (length(s)<=1)  {een string met 0 of 1 karakters is een palindroom}
     or 
       ((s[1]=s[length(s)]) {eerste en laatste karakter zijn gelijk}
            and palindroom(copy(s,2,length(s)-2))); {dan bekijken we ook het middenstuk}
end;

Let er wel op dat deze code uitgaat van een niet-volledige boolean-evaluatie.
Als

code:

(length(s)<=1)

bijvoorbeeld true oplevert, zal de rest niet meer uitgevoerd worden, omdat vanwege de OR het resultaat altijd gelijk (TRUE) zal zijn.
Een zelfde geldt voor de AND.

[Tomatoman]

Knutselsmurf schreef op 11 november 2002 @ 22:16:
[...] Let er wel op dat deze code uitgaat van een niet-volledige boolean-evaluatie.
Als

code:

(length(s)<=1)

bijvoorbeeld true oplevert, zal de rest niet meer uitgevoerd worden, omdat vanwege de OR het resultaat altijd gelijk (TRUE) zal zijn.
Een zelfde geldt voor de AND.

Om je op weg te helpen: dat doe je door {$BOOLEVAL OFF} of (korter) {$B-} in je code te zetten. Alle code die daar achteraan komt, wordt gecompileerd met niet-volledige boolean-evaluatie. Standaard staat boolean evaluatie trouwens op {$B-} ingesteld (dat is immers sneller).

[Tomatoman]

Getest en goed bevonden:

Delphi:

function IsPalindroom(const Woord: string): Boolean;
var
  Woordlengte, HalveWoordlengte: Integer;

  function LettersGelijk(Index: Integer): Boolean;
  begin
    if Index > HalveWoordlengte then
      Result := True
    else
      Result := (Woord[Index] = Woord[Woordlengte + 1 - Index]) and
        LettersGelijk(Index + 1);
  end;

begin
  Woordlengte := Length(Woord);
  HalveWoordlengte := Length(Woord) div 2;
  Result := (Woordlengte > 0) and LettersGelijk(1);
end;

LettersGelijk is een recursieve functie. Stel dat je het woord 'lepel' test met IsPalindroom. Woordlengte = 5, HalveWoordlengte = 2. LettersGelijk(1) controleert of de letters op positie 1 en positie 5+1-1 (de achterste letter) gelijk zijn. Zo nee, dan klaar (Result = False). Zo ja, dan wordt LettersGelijk(2) aangeroepen door LettersGelijk(1) - dat is dus recursief. Er wordt bij 'lepel' geconstateerd dat de letter op positie 2 en de voorlaatste letter gelijk zijn. Dan wordt LettersGelijk(3) aangeroepen. Aangezien 3 groter is dan HalveWoordlengte, zijn we klaar in is het functieresultaat True.

Bij een even aantal letters worden alle letters vergeleken, bij een oneven aantal letters wordt de middelste letter overgeslagen. De middelste letter is immers altijd 'goed'.

Tip: zet een breakpoint op regel 14 (begin). Zodra het programma daar aankomt en wordt onderbroken, kies je in Delphi View - Debug Windows - Call Stack (of Ctrl+Alt+S), en stap je vervolgens met F7 regel voor regel door de code heen. In de call stack zie je precies wat er gebeurt bij een recursieve functie.

[ Voor 0% gewijzigd door Tomatoman op 12-11-2002 12:43 . Reden: kromme zin rechtgemaakt ]

[gjkamstra]

Misschien een beetje off-topic, maar dit soort problemen zijn veel sneller opgelost (complexiteit) dmv dynamisch programeren:
pascal:

Delphi:

program bla(input,output);

var
r,i:integer;

function max(a,b : integer): integer;
begin
   if (a>b) then max := a else max := b;
end;

procedure dwim;
var
   s       : string[255];
   l,r,d,n : integer;
   a       : array[0..200,1..200] of integer;

begin
   readln(s);
   n := length(s);
   if n=1 then begin
      writeln(0);
   end else begin
      
   for l := 1 to n do a[0,l] := 1;
   for l := 1 to n-1 do  a[1,l] := ord(s[l] = s[l+1]) +1;
   a[1,n] := 0;

   for d := 2 to n-1 do begin
      for l := 1 to n - d do begin
     if (s[l] = s[l+d]) then begin
        
        a[d,l] := a[d-2,l+1] + 2;
     end else begin
       a[d,l] := max(a[d-1,l], a[d-1,l+1])
     end ;
     
    
       
             end;
   end;

   writeln(n - max(a[n-1,1], a[n-2,1]));
end;
end;

begin
   readln(r);
   for i:=1 to r do begin
      dwim;
   end;
end.

[Knutselsmurf]

gjkamstra schreef op 12 november 2002 @ 12:36:
Misschien een beetje off-topic, maar dit soort problemen zijn veel sneller opgelost (complexiteit) dmv dynamisch programeren:
pascal:

Delphi:

program bla(input,output);

var
r,i:integer;

function max(a,b : integer): integer;
begin
   if (a>b) then max := a else max := b;
end;

procedure dwim;
var
   s       : string[255];
   l,r,d,n : integer;
   a       : array[0..200,1..200] of integer;

begin
   readln(s);
   n := length(s);
   if n=1 then begin
      writeln(0);
   end else begin
      
   for l := 1 to n do a[0,l] := 1;
   for l := 1 to n-1 do  a[1,l] := ord(s[l] = s[l+1]) +1;
   a[1,n] := 0;

   for d := 2 to n-1 do begin
      for l := 1 to n - d do begin
     if (s[l] = s[l+d]) then begin
        
        a[d,l] := a[d-2,l+1] + 2;
     end else begin
       a[d,l] := max(a[d-1,l], a[d-1,l+1])
     end ;
     
    
       
             end;
   end;

   writeln(n - max(a[n-1,1], a[n-2,1]));
end;
end;

begin
   readln(r);
   for i:=1 to r do begin
      dwim;
   end;
end.

Doe dit maar eens even toelichten dan. Vertel mij waarom deze oplossing eenvoudiger is, dan de functie met 1 regel code die ik eerder geschreven heb.

[Knutselsmurf]

tomatoman schreef op 12 november 2002 @ 12:30:
Getest en goed bevonden:

Delphi:

function IsPalindroom(const Woord: string): Boolean;
var
  Woordlengte, HalveWoordlengte: Integer;

  function LettersGelijk(Index: Integer): Boolean;
  begin
    if Index > HalveWoordlengte then
      Result := True
    else
      Result := (Woord[Index] = Woord[Woordlengte + 1 - Index]) and
        LettersGelijk(Index + 1);
  end;

begin
  Woordlengte := Length(Woord);
  HalveWoordlengte := Length(Woord) div 2;
  Result := (Woordlengte > 0) and LettersGelijk(1);
end;

LettersGelijk is een recursieve functie. Stel dat je het woord 'lepel' test met IsPalindroom. Woordlengte = 5, HalveWoordlengte = 2. LettersGelijk(1) controleert of de letters op positie 1 en positie 5+1-1 (de achterste letter) gelijk zijn. Zo nee, dan klaar (Result = False). Zo ja, dan wordt LettersGelijk(2) aangeroepen door LettersGelijk(1) - dat is dus recursief. Er wordt bij 'lepel' geconstateerd dat de letter op positie 2 en de voorlaatste letter gelijk zijn. Dan wordt LettersGelijk(3) aangeroepen. Aangezien 3 groter is dan HalveWoordlengte, zijn we klaar in is het functieresultaat True.

Bij een even aantal letters worden alle letters vergeleken, bij een oneven aantal letters wordt de middelste letter overgeslagen. De middelste letter is immers altijd 'goed'.

Tip: zet een breakpoint op regel 14 (begin). Zodra het programma daar aankomt en wordt onderbroken, kies je in Delphi View - Debug Windows - Call Stack (of Ctrl+Alt+S), en stap je vervolgens met F7 regel voor regel door de code heen. In de call stack zie je precies wat er gebeurt bij een recursieve functie.

Deze oplossing werkt, maar persoonlijk vindt ik hem minder fraai. Je hebt 2 functies nodig, waarbij je overstapt van een recursieve definitie naar het recursief tellen van karakters, terwijl dat ook in een while-lus kan.
De eerder door mij beschreven functie blijft IMHO dichter bij de recursieve definitie.
Ispalindroom('lepel') zal Ispalindroom ('epe') aanroepen en die roept Ispalindroom('p') aan. Een steeds kortere string dus.

[Tomatoman]

Knutselsmurf schreef op 12 november 2002 @ 12:54:
[...] Deze oplossing werkt, maar persoonlijk vindt ik hem minder fraai. Je hebt 2 functies nodig, waarbij je overstapt van een recursieve definitie naar het recursief tellen van karakters, terwijl dat ook in een while-lus kan. [...]

Eens.

[gjkamstra]

Oplossing is niet eenvoudiger (in tegen deel zelf).
Hij is alleen veel sneller als hij wordt uitgevoerd, complexiteit is O(l^2) ipv 2^l (l=lengte string)
Dit was trouwens een opgave van het NKP2001 (Nederlands kampioenschap Programeren)

[Knutselsmurf]

gjkamstra schreef op 12 November 2002 @ 12:58:
Oplossing is niet eenvoudiger (in tegen deel zelf).
Hij is alleen veel sneller als hij wordt uitgevoerd, complexiteit is O(l^2) ipv 2^l (l=lengte string)
Dit was trouwens een opgave van het NKP2001 (Nederlands kampioenschap Programeren)

Ik ben bang dat je je nu aan het vergissen bent. De door bij beschreven oplossing is O(l). Het bepalen of een woord een palindroom is, lijkt mij niet een opgave voor het NKP. Die opgave was volgens mij, dat je, door zo min mogelijk letters weg te laten, van een woord een palindroom kon maken. Is toch iets anders.........

[RickN]

gjkamstra schreef op 12 November 2002 @ 12:58:
Oplossing is niet eenvoudiger (in tegen deel zelf).
Hij is alleen veel sneller als hij wordt uitgevoerd, complexiteit is O(l^2) ipv 2^l (l=lengte string)
Dit was trouwens een opgave van het NKP2001 (Nederlands kampioenschap Programeren)

Are you kidding me? De oplossing van de topic starter, of iig de herziene versie heeft lineaire complexiteit hoor.....

[RickN]

Knutselsmurf schreef op 11 november 2002 @ 22:16:
[...]

De oplosmethode is niet recursief, de implementatie wel. Terwijl de ECHTE recursieve oplossing, zoals ik hierboven beschreven heb, in mijn ogen charmanter is en eenvoudiger te debuggen.


Zal zoiets worden:

code:

function palindroom(s:string):boolean;
begin
  result:=
      (length(s)<=1)  {een string met 0 of 1 karakters is een palindroom}
     or 
       ((s[1]=s[length(s)]) {eerste en laatste karakter zijn gelijk}
            and palindroom(copy(s,2,length(s)-2))); {dan bekijken we ook het middenstuk}
end;

Let er wel op dat deze code uitgaat van een niet-volledige boolean-evaluatie.
Als

code:

(length(s)<=1)

bijvoorbeeld true oplevert, zal de rest niet meer uitgevoerd worden, omdat vanwege de OR het resultaat altijd gelijk (TRUE) zal zijn.
Een zelfde geldt voor de AND.

Twee dingen:

De oplossing van de topicstarter is natuurlijk wel recursief; dat jouw oplossing mooier is staat verder buiten kijf.

Jouw code gaat niet uit van niet-volledige boolean evaluatie. Je functie heeft geen zijeffecten en overbodige evaluaties ervan zullen dus geen effect hebben op het uiteindelijke resultaat. Het enige wat een lazy boolean evaluatie je hier biedt is een eenvoudig early-out mechanisme.

[Knutselsmurf]

RickN schreef op 12 november 2002 @ 13:14:
[...]


Twee dingen:

De oplossing van de topicstarter is natuurlijk wel recursief; dat jouw oplossing mooier is staat verder buiten kijf.

Jouw code gaat niet uit van niet-volledige boolean evaluatie. Je functie heeft geen zijeffecten en overbodige evaluaties ervan zullen dus geen effect hebben op het uiteindelijke resultaat. Het enige wat een lazy boolean evaluatie je hier biedt is een eenvoudig early-out mechanisme.

Mijn code maakt wel degelijk gebruik van niet-volledige boolean evaluatie. Met volledige evaluatie zal altijd de functie opnieuw aangeroepen worden, hetgeen OF leidt tot een error OF een oneindige loop. Is een beetje afhankelijk hoe de copy-functie reageert. Juist door de niet-volledige evaluatie is er een stop-conditie ingebouwd.

En verder vindt ik dat de oplossing van de TS recursief geimplementeerd is, maar zeker niet recursief ontworpen. Op een dergelijke manier kan ik een tellertje ook nog wel recursief implementeren.......

[RickN]

Knutselsmurf schreef op 12 november 2002 @ 13:45:
[...]

Mijn code maakt wel degelijk gebruik van niet-volledige boolean evaluatie. Met volledige evaluatie zal altijd de functie opnieuw aangeroepen worden, hetgeen OF leidt tot een error OF een oneindige loop. Is een beetje afhankelijk hoe de copy-functie reageert. Juist door de niet-volledige evaluatie is er een stop-conditie ingebouwd.

lol, oneindige loop, nie gezien

En verder vindt ik dat de oplossing van de TS recursief geimplementeerd is, maar zeker niet recursief ontworpen. Op een dergelijke manier kan ik een tellertje ook nog wel recursief implementeren.......

Ja, een tellertje kun je ook recursief implementeren, en als je dat doet is het een recursieve functie. De topic starter heeft de informatie overdracht tussen de recursieve aanroepen van de functie wat anders gecodeerd dan jij. Jij met het doorsturen van een kortere string, de topicstarter met het doorsturen van twee elkaar naderende indices in die string. Afgezien van de totaal nutteloze variable t die in de stopconditie wordt gebruikt (hiervoor zou het verschil tussen de twee indices gebruikt moeten worden) vind ik dit een erg nette en best voor de hand liggende recursieve aanroep, die, wegens jouw gebruik van de copy functie, waarschijnlijk nog wat sneller dan jouw methode zal zijn ook....

[Knutselsmurf]

RickN schreef op 12 november 2002 @ 13:54:
[...]

lol, oneindige loop, nie gezien


[...]


Ja, een tellertje kun je ook recursief implementeren, en als je dat doet is het een recursieve functie. De topic starter heeft de informatie overdracht tussen de recursieve aanroepen van de functie wat anders gecodeerd dan jij. Jij met het doorsturen van een kortere string, de topicstarter met het doorsturen van twee elkaar naderende indices in die string. Afgezien van de totaal nutteloze variable t die in de stopconditie wordt gebruikt (hiervoor zou het verschil tussen de twee indices gebruikt moeten worden) vind ik dit een erg nette en best voor de hand liggende recursieve aanroep, die, wegens jouw gebruik van de copy functie, waarschijnlijk nog wat sneller dan jouw methode zal zijn ook....

Maar twee indices die naar elkaar toelopen kune je dan veel beter met een while-lusje proggen, dat is dan weer veel sneller. En dan issie niet meer recursief.

[RickN]

De meeste, zoniet alle (hier is ooit een discussie over geweest op GoT) recursieve functie kun je omschrijven naar een equivalente iteratieve oplossing, dat geldt ook voor jouw oplossing. En of de oplossing recursief ontworpen is kun je natuurlijk niet zeggen want je kent de denkwijze van de TS niet. Sowieso kun je moeilijk spreken over een ontwerp als je alleen een stuk code voor ogen hebt.

[dusty]

Het gebruik van indices is zelfs overbodig.

Waarom zou je elke keer overnieuw de hele string meegeven?

Een andere oplossing is namelijk om te kijken of de eerste letter gelijk is aan de laatste letter. is dit het geval dan roep je je eigen functie weer aan om te kijken of wat er tussen die letters misschien toevallig ook een palindroom is.

[Knutselsmurf]

RickN schreef op 12 November 2002 @ 14:06:
De meeste, zoniet alle (hier is ooit een discussie over geweest op GoT) recursieve functie kun je omschrijven naar een equivalente iteratieve oplossing, dat geldt ook voor jouw oplossing. En of de oplossing recursief ontworpen is kun je natuurlijk niet zeggen want je kent de denkwijze van de TS niet. Sowieso kun je moeilijk spreken over een ontwerp als je alleen een stuk code voor ogen hebt.

Hier heb je helemaal gelijk mee.

Waarom ik over dat ontwerp begon is de volgende reden: De TS begon over recursie, terwijl zijn oplossing in mijn ogen een 'recursivering' van een while lus is. In mijn eerste post in dit topic heb ik daarom een recursieve definitie gegeven van een palindroom, als basis voor de functie die ik later heb uitgeschreven.

BTW, een andere manier om te controleren is natuurlijk het omkeren van je string en vergelijken met het origineel. Als je als definitie van een palindroom geeft dat een palindroom een woord is, dat achterste voren geschreven hetzelfde is, zit deze oplossing weer dichterbij de definitie, maar dat even terzijde.

[Knutselsmurf]

dusty schreef op 12 november 2002 @ 14:30:
Het gebruik van indices is zelfs overbodig.

Waarom zou je elke keer overnieuw de hele string meegeven?

Een andere oplossing is namelijk om te kijken of de eerste letter gelijk is aan de laatste letter. is dit het geval dan roep je je eigen functie weer aan om te kijken of wat er tussen die letters misschien toevallig ook een palindroom is.

Zo dus

[Soultaker]

Je kunt in Pascal toch ook pointers gebruiken? Dan kun je je een hoop parameter passing en string copying besparen. Dat is trouwens wel gepruts in de marge; de eerste uitwerking werkt ook goed.

[StratoFarmer]

ik heb zojuist een palindroomchecker in PHP geschreven, met output van het proces.
misschien leuk om te bekijken. Je kunt het hier ook in actie zien.

PHP:

//$woord is de input om te checken

function isPalindroom ($string) {
    echo "<HR>";
    echo "<BR>string= ". $string;
    
    $lengte = strlen($string);
    echo "<BR>lengte= ". $lengte;
    
    $eersteletter = substr($string,0,1);
    $laatsteletter = substr($string,$lengte -1,1);
    $kleinerstring = substr($string,1,$lengte -2);

    echo "<BR>eerste letter= ". $eersteletter;
    echo "<BR>laatste letter= ". $laatsteletter;

    if ($lengte > 1) {
        if ( $eersteletter == $laatsteletter ) {
            echo "<BR>-overeenkomst-";
            $string = $kleinerstring;
            return isPalindroom($string);
        } else {
            echo "<BR>-geen overeenkomst-";
            return(false);
        }
    }
    echo "<HR><BR>-laatste letter is geweest-";
    return(true);
}

if ( isPalindroom($woord) ) {
    echo "<BR><BR>'". $woord ."' is inderdaad een palindroom!";
} else {
    echo "<BR><BR>nee, '". $woord ."' is geen palindroom";
}

edit: er was een probleem met PHP wat betreft het recursief aanroepen van de functie, blijkbaar moet je dat met "return functie" oplossen...vaag.

[ Voor 0% gewijzigd door StratoFarmer op 12-11-2002 19:30 . Reden: php bug? geen id... ]

[Shook]

thanxs voor ieder zijn reacties. Ik weet dat de oplossing ook in een while-loop kan, maar het is een opdracht die èn recursief èn iteratief opgelost moest worden. Helaas heeft niemand me nog kunnen vertellen, wat ik precies fout heb gedaan. De foutmelding "Type mismatch" is iets wat ik niet snap. Verder moet ik zeggen dat Dusty zn opmerking over de overbodige teller een goed punt vindt. Ik zal eens kijken of ik dat er in kan verwerken. (had niet gedacht zo'n keurige discussie op te wekken)

[Spaceman Spiff]

Shook schreef op 11 November 2002 @ 21:21:
Hey, Ik moet een recursieve palindroom tester maken, en naar mijn idee klopt de code. Pascal is het er alleen niet mee eens. In mijn (en lerares) begrip is een palindroom een woord wat je vanaf het midden kan omdraaien. Denk dus aan:
Radar, regelnevenleger, meetsysteem, maar hij zou dus ook 12344321 en 1234321 moeten pakken. Dit is de code:


program palindroompje;
uses wincrt;

var woord:string;
teller,positie1,positie2:integer;


procedure PalinRec(t,p1,p2:integer;w:string);
begin
if t < ((length(w))/2) and (w[(p1)]) = (w[(p2)]) then
begin
PalinRec(t+1,p1+1,p2-1,w);
writeln('Het is een palindroom');
end;

else
writeln('Helaas het is GEEN palindroom');
end;


begin
teller:=0;
positie1:=1;
positie2:=(length(woord));
writeln('Geef een palindroom, en het programma zal het testen');
readln(woord);
PalinRec(teller,positie1,positie2,woord);
end.


Het probleem is dat hij het "="-teken niet snapt tussen de "(w[(p1)]) = (w[(p2)])" met als fout melding een type mismatch.

Ik weet dat er ook nog een div in moet bij de gedeeld door 2, maar das niet het probleem nu. Thanxs alvast voor reacties.

Jemig, wat een gezwam in de reply's hierboven.

Het probleem zit hem in het feit dat "positie2:=(length(woord));" uitgevoerd wordt voordat het woord is ingevoert. Zet dit na de "readln" en dan heeft "positie2" wel een geldige waarde.

[Shook]

Knutselsmurf schreef op 11 November 2002 @ 21:30:
Pak het probleem eens een klein beetje anders aan.
string X is een palindroom als de eerste en de laatste karakters gelijk zijn en de rest van de string een palindroom is. Een lege string en een string met 1 enkel karakter zijn ook palindromen.
De manier zoals jij het hebt opgeschreven is niet recursief.

Deze reactie had ik nog ff over het hoofd gezien. Je hebt bijna gelijk, mijn verhaal is ook recursief, maar door het op deze manier te doen, is ie super recursief. Absolute oplossing. * Shook start tpw weer ff op.

Spaceman: Aaaaaargh!!! Je hebt helemaal gelijk

[RickN]

Nou, volgens mij zit de fout in je originele code in het plaatsen van de haakjes in de if-statement. Ten eerste staan er veel te veel waardoor het onoverzichtelijk wordt. Als ik overbodige haakjes weghaal staat er:

code:

t < length(w)/2 and w[p1] = w[p2]

Als je daar

code:

(t < length(w)/2) and (w[p1] = w[p2])

van maakt ben je er denk ik....

[dusty]

Knutselsmurf schreef op 12 november 2002 @ 14:42:
[...]

Zo dus

Hey, Jij hier?

Moet ik toch weer gaan opletten en de threads volledig lezen

[jonggoud.nl]

StratoFarmer schreef op 12 November 2002 @ 15:29:
ik heb zojuist een palindroomchecker in PHP geschreven, met output van het proces.
misschien leuk om te bekijken. Je kunt het hier ook in actie zien.

PHP:

heel veel code

Dit is geen palindroom tester, het test alleen de 1e en de laatste letter. Je krijgt dus zelfs bij A1625412784A een 'is goed' te zien.

Je zal dus die substring moeten herhalen tot het midden v/h woord. (letters/2 afronden naar boven). En als ze allemaal '' ok ' hebbenis het goed.

[Shook]

Delphi:

program palindroompje;
uses wincrt;

var woord:string;
    positie1,positie2:integer;
    antwoord:boolean;


procedure PalinRec(p1,p2:integer;w:string; var a:boolean);
begin
     if ((w[(p1)]) = (w[(p2)])) then
        begin
             PalinRec(p1+1,p2-1,w,a);
             a:=true;
        end;
end;

begin
     writeln('Geef een palindroom, en het programma zal het testen');
     readln(woord);
     positie1:=1;
     positie2:=(length(woord));
     PalinRec(positie1,positie2,woord,antwoord);
        If antwoord = true then
           begin
              writeln('Het is een palindroom');
           end
        Else
           begin
              writeln('Jammer, het is geen palindroom');
           end;

end.

Nou jongens, ik ben er eindelijk uit, hoe simpel kan je het maken. Deze test niet tot het midden, maar de stop conditie zit gewoon aan het einde van het woord afhankelijk vanaf welke kant je begint te lezen. Ook heb ik een boolean variabele bijgevoegd om netjes één keer weer te geven of het wel of niet een Palindroom is. Nogmaals bedankt y'all!!

edit: Hij klopt nog niet helemaal, hij checkt nu alleen de eerste en laatste letter....

Eigenlijk moet ik er nog een If statement in kwijt. Hij moet nog kunnen checken:

Als de procedure (lengt(woord)) keer is uitgevoerd, dan a:=true. Iemand een idee hoe dit te implementeren?

Ben er nu helemaal uit, ik geloof dat dit hem is:

Delphi:

program palindroompje;
uses wincrt;

var woord:string;
    positie1,positie2,teller:integer;


procedure PalinRec(p1,p2:integer;w:string; var t:integer);

begin
     if ((w[(p1)]) = (w[(p2)])) then
        begin
             PalinRec(p1+1,p2-1,w,t);
             t:=t+1;
        end;
end;

procedure PalinLoop(p1,p2:integer;w:string; var t:integer);
begin
   while ((w[(p1)]) = (w[(p2)])) do
      begin
         p1:=p1+1;
         p2:=p2-1;
         t:=t+1;
      end;
end;

 
begin{Hoofdprogramma}
     writeln('Geef een palindroom, en het programma zal het testen');
     readln(woord);
     teller:=0;
     positie1:=1;
     positie2:=(length(woord));
     PalinRec(positie1,positie2,woord,teller);
        If teller = (length(woord)) then
           begin
              writeln('Het is een palindroom');
           end
        else
           begin
              writeln('Jammer, het is geen palindroom');
           end;

{Programma met een loop ipv recursief}

     writeln('We gaan het nogmaals proberen, voer een woord in.');
     readln(woord);
     teller:=0;
     positie1:=1;
     positie2:=(length(woord));
     palinLoop(positie1,positie2,woord,teller);
        if teller = (length(woord)) then
           begin
              writeln('Het is een palindroom');
           end
        else
           begin
              writeln('Jammer, het is geen palindroom');
           end;                     
end.{Einde hoofdprogramma}

Je geeft nu dus een teller mee, en als de teller overeenkomt met de lengte van het woord, dan weet je dat hij het hele woord is doorlopen. Het kan dan niks anders dan een Palindroom zijn. * Shook happy

[markvt]

he jammer nu ik dit zo lees en even mijn archief doorploos ben ik helaas mijn palindroom checker kwijt, heb er nog wel 1 in c gevonden ik checkte zo

als lengte van string 1 dan palindroom anders
als string [eerste] = laatste en string [tweede] = string [eennalaatste] dan palindroom

op die wijze dit natuurlijk wel in een mooie loop

[Apollo_Futurae]

offtopic:
om alle programmeurs die nog met imperatieve talen werken te pesten hier een palindroomtester in haskell:

code:

palindroom woord = woord == reverse woord

[Soultaker]

Of logisch:

Prolog:

palindroom(Woord) :- reverse(Woord,Woord).

[StratoFarmer]

jonggoud.nl schreef op 12 november 2002 @ 16:03:
[...]

Dit is geen palindroom tester, het test alleen de 1e en de laatste letter. Je krijgt dus zelfs bij A1625412784A een 'is goed' te zien.

Je zal dus die substring moeten herhalen tot het midden v/h woord. (letters/2 afronden naar boven). En als ze allemaal '' ok ' hebbenis het goed.

idd, ik heb het opgelost. Maar ik moet nog wel uitzoeken wat nu precies het probleem was met PHP...