[Turbo Pascal] Palindroom controleren*

[NickyVermeersch]

Ik zit nu al een geruime tijd mijn hoofd te breken over een oefening die ik moet doen op school in Turbo Pascal. We moeten een programma ontwikkelen dat controleert of een getal een palindroom is of niet (dwz. een getal dat je omgekeerd kan lezen, en toch nog hetzelfde is als het origineel zoals 'lepel').

Ik vermoed dat het iets te maken heeft met tabellen, de length functie, maar ik heb nog steeds geen zekerheid. Iemand een idee ?

[Soultaker]

Wat had je zelf al zoal bedacht? Kun je het wel met een woord doen?

Het makkelijkste (ook om te begrijpen) is natuurlijk het woord of getal omdraaien en dan controleren of het gelijk is aan het origineel.

[the_stickie]

a) dit is een huiswerkvraag
b) je zou dat getal ook als string kunnen lezen, omdaraaien en checken of jhet hetzelfde is
c) je zou eens op zoek kunnen gaan naar een wiskundige benadering (als die al bestaat)

[CrashOne]

Controleer de lengte, een even getal kan ht al niet zijn. Ga daarna stap gewijs (in een loop) controleren of het laatste getal gelijk is aan het eerste tot er niks meer te controleren valt of het getal gewoon omdraaien.

[ Voor 8% gewijzigd door CrashOne op 10-11-2005 20:43 ]

[roelio]

Waarom geen even getal?

[newpegasus]

Ik denk dat handig is deze functie recursief te gaan schrijven: stel een eindconditie (lengte string < 2), als hieraan niet voldoet wordt, roep functie aan met de string min de eerste en laatste letter. Zo heb ik hem ooit ook eens gemaakt...

/edit: in dit geval maak ik van de cijfers dus een string, maar dat maakt niet uit voor het vergelijken...

[ Voor 20% gewijzigd door newpegasus op 10-11-2005 20:47 ]

[CrashOne]

limoentje schreef op donderdag 10 november 2005 @ 20:45:
Waarom geen even getal?

Mijn fout, zat ff krom te denken

[Verwijderd]

Tja elk karakter in een tabel zetten, de tabel omdraaien en controleren of dat indentiek is...

[Soultaker]

Wat is die 'tabel' waar jullie het steeds over hebben. Bedoel je een array?

[Lolhozer]

Ik weet even niet hoe gemakkelijk het is om het getal om te draaien, maar anders zou je het originele door het omgedraaide kunnen delen, is het antwoord 1, dan palindroom, anders niet.

[the_stickie]

Lolhozer schreef op donderdag 10 november 2005 @ 20:56:
Ik weet even niet hoe gemakkelijk het is om het getal om te draaien, maar anders zou je het originele door het omgedraaide kunnen delen, is het antwoord 1, dan palindroom, anders niet.

Als dat zou kunnen hoe je helemaal niet tegaan delen:

if getal=omgedraaidgetal then ... of zoiets (TP is té lang geleden)

[Verwijderd]

Dat delen is nergens voor nodig. Je doet toch gewoon if(getal_bla1 = getal_bla2) --> palindroom.

@TS: Je hebt de oplossing nu. Je moet alleen uitzoeken hoe je met pascal een getal omdraait. In Java zou ik het wel weten, in Pascal niet, maar erg moeilijk kan dat toch niet zijn lijkt me?


bijvoorbeeld dit?

- maak van getal een string
- check lengte string
- maak string var aan ($getal_omgekeerd oid)
- loop per karacter de string af van achter naar voren en doe telkens $getal_omgekeerd += karakter.
- Van $getal_omgekeerd een integer maken
- test $getal == $getal_omgekeerd

[ Voor 35% gewijzigd door Verwijderd op 10-11-2005 21:05 ]

[Soultaker]

rubenski: je kunt een getal prima omdraaien zonder 'm onderweg te converteren naar een integer.

[NickyVermeersch]

als het ware dus een tweede array erbij voegen maar dan zorgen dat hij het omgekeerd oproept

bv origineel is een array van a b c d e f
dan aflopen met een tweede array maar dan omgekeerd f e d c b a

Het zou inderdaad wel praktisch zijn als er daar een bepaalde functie voor zou bestaan.

@the stickie, dit is niet echt een huiswerkvraag maar meer een extra oefening (van oefeningen lol)

[ Voor 15% gewijzigd door NickyVermeersch op 10-11-2005 21:12 ]

[KopjeThee]

Misschien helpt het om een functie te hebben die het n-de cijfer geeft uit de decimale representatie van het getal? Bijvoorbeeld:
3215556 : getal
6543210 : n
cijferOpPositie(4) = 1

In Java oid:

code:

int cijferOpPositie(int n, int getal)
{
  int macht = power(10,n); // pascal heeft ook wel een functie voor machtsverheffen, anders zelf iets bedenken...
  int cijfer = getal / macht;
  cijfer = cijfer % 10; // % is modulo

  return (cijfer);
}

int lengteGetal(int getal)
{
  int l = 0;
  while (getal != 0)
  {
    getal = getal / 10;
    l = l + 1;
  }

  return (l);
}

boolean isPalin(int getal)
{
  int l = lengteGetal(getal);
  for (int i = 0; i < l; ++i)
  {
    if (cijferOpPositie(i,getal) != cijferOpPositie(l-i-1,getal)) // != is "niet gelijk"
    {
      return (false);
    }
  }
  return (true);
}

Dit heb ik op geen enkele manier gecontroleerd hoor :-) Het is ook geen turbo pascal, maar zoiets kan in Pascal ook wel, maar dan iets anders opgeschreven.

[ Voor 14% gewijzigd door KopjeThee op 10-11-2005 21:18 ]

[PrisonerOfPain]

Cast het getal naar een string, en vergelijk de string met de omgedraaide variant.

[NickyVermeersch]

inderdaad dat zou hetzelfde werken als een array, maar we weten nog altijd niet hoe je effecient de string/tabel kan omdraaien zonder kilo's codes te schrijven

[Soultaker]

kopjethee: sorry, maar dat is echt dramatisch slechte code. Als je geen goede voorbeeldcode kunt schrijven, laat het dan liever achterwege; dit is niet echt educatief verantwoord.

[KopjeThee]

NickyVermeersch schreef op donderdag 10 november 2005 @ 21:23:
inderdaad dat zou hetzelfde werken als een array, maar we weten nog altijd niet hoe je effecient de string/tabel kan omdraaien zonder kilo's codes te schrijven

Er hoeft niks omgedraaid te worden. Stel je getal zit in een array "getal" met lengte "l". Dan van achter naar voor doorlopen:

code:

boolean isPalin(char getal[], int l)
{
  for (int i = 0; i < l; ++i)
  {
    if (getal[i] != getal[l - i - 1])
    {
      return (false);
    }
  }
  return (true);
}

[ Voor 6% gewijzigd door KopjeThee op 10-11-2005 21:35 ]

[Verwijderd]

NickyVermeersch schreef op donderdag 10 november 2005 @ 21:11:
als het ware dus een tweede array erbij voegen maar dan zorgen dat hij het omgekeerd oproept

bv origineel is een array van a b c d e f
dan aflopen met een tweede array maar dan omgekeerd f e d c b a

Het zou inderdaad wel praktisch zijn als er daar een bepaalde functie voor zou bestaan.

@the stickie, dit is niet echt een huiswerkvraag maar meer een extra oefening (van oefeningen lol)

En dit slaagt nog op minder... een array omdraaien door hem om te zetten naar een tweede array.... je kan een array ook van achter naar voor doorlopen...

Maar ik denk dat je je huiswerk zelf moet gaan maken nu, er is hier genoeg geholpen

[NickyVermeersch]

Ik ben al direct aan de slag gegaan en heb hier al goede tips ontvangen en suggesties

[KopjeThee]

Soultaker schreef op donderdag 10 november 2005 @ 21:24:
kopjethee: sorry, maar dat is echt dramatisch slechte code. Als je geen goede voorbeeldcode kunt schrijven, laat het dan liever achterwege; dit is niet echt educatief verantwoord.

Fijn dat je deze stelling zo goed beargumenteert. Erg nuttig. Laat dit soort opmerkingen dan ook vooral achterwege.

[Pino]

Als je heel even de woorden palindroom en pascal in google had gegooid had je een perfect voorbeeld gehad: http://www.scip.be/index....ArticlesProgram03&Lang=EN

[NMe]

Verwijderd schreef op donderdag 10 november 2005 @ 21:29:
Maar ik denk dat je je huiswerk zelf moet gaan maken nu, er is hier genoeg geholpen

Dat vind ik ook. Intussen zijn er genoeg tips geweest om dit op te moeten kunnen lossen, misschien moet je daarmee eerst maar eens gaan spelen.

@kopjethee: om te beginnen loop je als van begin tot einde door het hele getal heen, terwijl je eigenlijk alleen maar tot op de helft hoeft te gaan (even lengte) of tot één minder dan de helft (oneven lengte).

Overigens, een aantal mensen hier lijkt de indruk te hebben dat huiswerkvragen niet toegestaan zijn. Dat zijn ze wel, mits de topicstarter zelf ook maar moeite doet om tot een oplossing te komen.

[KopjeThee]

-NMe- schreef op donderdag 10 november 2005 @ 21:42:
[...]
@kopjethee: om te beginnen loop je als van begin tot einde door het hele getal heen, terwijl je eigenlijk alleen maar tot op de helft hoeft te gaan (even lengte) of tot één minder dan de helft (oneven lengte).

Ja, l/2 (dus naar beneden afgerond) zal wel goed gaan, denk ik. Erg weldoordacht is het misschien allemaal niet, maar ik wilde even vlug een idee geven van een mogelijk oplossing.

[Peedy]

Ik heb dit ooit eens in Visual Basic gemaakt.

code:

VERSION 5.00
Begin VB.Form Form1 
   Caption         =   "Palindroomchecker"
   ClientHeight    =   5730
   ClientLeft      =   60
   ClientTop       =   345
   ClientWidth     =   8010
   LinkTopic       =   "Form1"
   ScaleHeight     =   5730
   ScaleWidth      =   8010
   StartUpPosition =   3  'Windows Default
   Begin VB.CommandButton Command2 
      Caption         =   "Sluit"
      Height          =   375
      Left            =   4680
      TabIndex        =   3
      Top             =   4680
      Width           =   2055
   End
   Begin VB.CommandButton Command1 
      Caption         =   "Check"
      Height          =   375
      Left            =   2280
      TabIndex        =   1
      Top             =   1920
      Width           =   3255
   End
   Begin VB.TextBox Text1 
      Height          =   1095
      Left            =   1320
      TabIndex        =   0
      Top             =   600
      Width           =   4935
   End
   Begin VB.Label Label1 
      Height          =   615
      Left            =   1920
      TabIndex        =   2
      Top             =   3240
      Width           =   4335
   End
End
Attribute VB_Name = "Form1"
Attribute VB_GlobalNameSpace = False
Attribute VB_Creatable = False
Attribute VB_PredeclaredId = True
Attribute VB_Exposed = False
Private Sub Command1_Click()
If Len(Text1.Text) <= 3 Then
Label1.Caption = "Woord is te kort"
Else
If Mid$(Text1.Text, 1, 1) = Mid$(Text1.Text, Len(Text1.Text), 1) And Mid$(Text1.Text, 2, 1) = Mid$(Text1.Text, (Len(Text1.Text) - 1), 1) And Mid$(Text1.Text, 3, 1) = Mid$(Text1.Text, (Len(Text1.Text) - 2), 1) And Mid$(Text1.Text, 4, 1) = Mid$(Text1.Text, (Len(Text1.Text) - 3), 1) Then
Label1.Caption = "Het is wel een palindroom"
Else
Label1.Caption = "Het is geen palindroom"
End If
End If
End Sub

Private Sub Command2_Click()
End
End Sub

Edit: werkt niet bij lange woorden.. je kan hem zelf uiteraard langer maken, maar ik was te lui Was inderdaad ook voor school, en de leraar voerde 3 woorden in om te checken
Ik had het toch wel gefixt Werkt ook met lange woorden... is alweer 2 jaar geleden ditte

[ Voor 17% gewijzigd door Peedy op 10-11-2005 22:13 ]

[Soultaker]

kopjethee schreef op donderdag 10 november 2005 @ 21:33:
Fijn dat je deze stelling zo goed beargumenteert. Erg nuttig. Laat dit soort opmerkingen dan ook vooral achterwege.

Als je wil dat ik je help met je programmeerstijl open dan gerust een eigen topic. Ik zeg alleen dat het niet handig is om dit soort topics (waar een beginner uitleg vraagt) te vervuilen met de slechtgeschreven code van een andere beginner. Daar is de TS juist niet mee geholpen.

edit:
Dat geldt eigenlijk ook wel voor de meneer hier boven me.

En nu weer on-topic graag.

[ Voor 7% gewijzigd door Soultaker op 10-11-2005 22:23 ]

[RobIII]

pEeDy16 schreef op donderdag 10 november 2005 @ 22:11:
Ik heb dit ooit eens in Visual Basic gemaakt.

Over slechte code gesproken

Volgens jouw ding is "aaaazxyaaaa" een palindroom

Onder VB6 kan het trouwens véél makkelijker:

Visual Basic:

Private Function IsPalindrome(strInput As String) As Boolean
    IsPalindrome = StrComp(strInput, StrReverse(strInput), vbTextCompare) = 0
End Function

En dan maakt de lengte niet uit, is het case-insensitive* en heb je meteen een mooie functie die netjes een boolean teruggeeft en handel je het dus niet af in een _click event...
Overigens in VB een "End" gebruiken is ook niet erg netjes (zéker niet in een form). Gebruik dan "Unload me" i.p.v. dat je ronduit het programma keihard onderuit trekt. Of trek je ook gewoon de stekker uit je PC als je 'm uit wil zetten?

En als je dan toch kicked op Mid$ of lusjes gebruiken ofzo, gebruik het dan zo:

Visual Basic:

Private Function IsPalindrome(strInput As String) As Boolean
    Dim T As Long
    Dim bIP As Boolean
    
    bIP = True
    If Len(strInput) > 0 Then
        For T = 1 To CLng(Len(strInput) / 2) + 1
            bIP = bIP And Mid(strInput, T, 1) = Mid(strInput, Len(strInput) - (T - 1), 1)
        Next
    End If
    IsPalindrome = bIP
End Function

Maar goed, ik zou voor de eerste gaan Veel cleaner

_{* En case-sensitive als je vbTextCompare vervangt door vbBinaryCompare...}

Het was trouwens even zoeken naar "echte" woorden in plaats van aaaazxyaaaa, maar "staanplaats" en "droogkoord" zijn dus bijvoorbeeld met jouw "palindroom-functie" wél een palindroom terwijl ze dat toch écht niet zijn.

[ Voor 122% gewijzigd door RobIII op 10-11-2005 22:50 ]

[CodeCaster]

Zit de functie Mid() niet in pascal?

Ik zou zoiets doen in visual basic:

Visual Basic:

Function IsPalin(strText) as Boolean

 Dim i as Long
 Dim L as long
 Dim L2 as long
 Dim bPalin as Boolean

 L = Len(strText) + 1
 L2 = Int(L / 2) ' Afronden naar beneden
 
 bPalin = True
 For i = 1 to L2

  If Not (Mid(strText, i, 1) = Mid(strText, L-i, 1)) Then
   bPalin = False
   Exit For
  End If

 Next

End Function

Hij loopt dus door de string en vergelijkt het eerste en het laatste teken, daarna het tweede en het éénnalaatste teken, enz...
Komen die tekens niet overeen, dan sprint je programma uit de loop.

[ Voor 3% gewijzigd door CodeCaster op 11-11-2005 09:04 ]

[Verwijderd]

CodeCaster schreef op vrijdag 11 november 2005 @ 09:03:
Zit de functie Mid() niet in pascal?

Jawel, maar daar heet hij Copy

Nog een (kleine) optimalisatie. Gebruik de backslash ( \ ), dan heb je je afronding niet eens nodig ( \ = DIV )

Maar zoals hierboven ook al gezegd, in VB kan het vele malen eenvoudiger door een string te vergelijken met strreverse(string)

[ Voor 33% gewijzigd door Verwijderd op 11-11-2005 09:48 ]

[PrisonerOfPain]

CodeCaster schreef op vrijdag 11 november 2005 @ 09:03:
Zit de functie Mid() niet in pascal?

Copy(str, offset, length)

[ Voor 0% gewijzigd door PrisonerOfPain op 11-11-2005 09:46 . Reden: Mja spuit elf... ]

[TXC]

RobIII schreef op donderdag 10 november 2005 @ 22:26:
[...]

Visual Basic:

Private Function IsPalindrome(strInput As String) As Boolean
    Dim T As Long
    Dim bIP As Boolean
    
    bIP = True
    If Len(strInput) > 0 Then
        For T = 1 To CLng(Len(strInput) / 2) + 1
            bIP = bIP And Mid(strInput, T, 1) = Mid(strInput, Len(strInput) - (T - 1), 1)
        Next
    End If
    IsPalindrome = bIP
End Function

Waarom gebruikt iedereen een for lus? Een while is (vooral bij lange getallen) veel efficiënter, omdat daar uitgesprongen kan worden zodra duidelijk is dat het geen palindroom meer kan zijn omdat één van de vergelijkingen mank loopt.

Visual Basic:

Dim IsPalinDrome as Boolean

while IsPaldindrome  = true and T < CLng(Len(strInput) / 2) + 1
'etc.
T = T + 1
'etc

[RobIII]

^^
Je hebt gelijk, maar je mist het hele punt; zoals ik al aangaf heb je niet eens een lus nodig (lees de post eens vanaf het begin en het ging er mij om dat als meneer een lus wou gebruiken (of dat nou for/while/do...loop is) dat het met de mid(bla) blabla moest om karakters 1 voor 1 van links naar rechts te vergelijken. Een For-lus exit je overigens net zo makkelijk in VB6 (exit for) maar dat is (idd) niet zo netjes als een while lus.

In de praktijk zal blijken dat het geen ene reet uit maakt of je die 2 (of 5 of whatever paar) karakters extra nou nog vergelijkt als je eigenlijk al weet dat het geen palindroom is; die "optimalisatie" is niet eens meetbaar of bijna niet. Mocht je deze functie nu 100.000 keer aanroepen in een lus, dan zou het misschien meetbaar zijn...

En nee, ik zit nu niet te wachten op iemand die me even komt uitleggen dat het toch wel 0.000001 sec. en 2872 extra CPU-cycles kost...

"Premature Optimization is the root of all evil"

[ Voor 4% gewijzigd door RobIII op 11-11-2005 10:19 ]

[TXC]

RobIII schreef op vrijdag 11 november 2005 @ 10:13:
En nee, ik zit nu niet te wachten op iemand die me even komt uitleggen dat het toch wel 0.000001 sec. en 2872 extra CPU-cycles kost...

"Premature Optimization is the root of all evil"

Was idd wat mugge(n)zifterij van me, had het bovenste deel van je post wel gelezen trouwens

[Peedy]

RobIII schreef op donderdag 10 november 2005 @ 22:26:
[...]

Over slechte code gesproken

Volgens jouw ding is "aaaazxyaaaa" een palindroom

Het was trouwens even zoeken naar "echte" woorden in plaats van aaaazxyaaaa, maar "staanplaats" en "droogkoord" zijn dus bijvoorbeeld met jouw "palindroom-functie" wél een palindroom terwijl ze dat toch écht niet zijn.

Hehe, was een VB lesje in de 4e klas middelbare school Zolang hij het bij een paar woorden goed deed, kregen we al een voldoende

[chris]

Ik zou het gewoon zo doen in ruby:

code:

def palindroom?(x)
  return x.to_s == x.to_s.reverse
end

Maar dat is een beetje flauw natuurlijk.

[Hydra]

Meh, hoezo moeilijk doen:

Simpel:

code:

        public bool Pal1(int i) 
        {
            string s = i.ToString();

            for(i = 0;i < (s.Length / 2 + 1);i++) 
            {
                if(s[i] != s[s.Length - 1 - i])
                    return false;
            }

            return true;
        }

Simpeler (maar valsspelen):

code:

        public bool Pal2(int i) 
        {
            char[] a = i.ToString().ToCharArray();
            Array.Reverse(a);
            return new string(a) == i.ToString();
        }

De bovenste is waar je leraar waarschijnlijk naar op zoek is. Via een for-loop (of hoe die dingen in pascal ook heten). Het gaat erom dat je via een loop posities aan het begin met die aan het eind vergelijkt.

[Soultaker]

Ik geloof dat praktisch iedereen die tussenstap maakt met een string, maar dat hoeft absoluut niet. Een string omdraaien kun je doen door steeds een karakter van het einde van de invoer te nemen en dat aan de achterkant van de uitvoer toe te voegen:

Stap	Invoer	Uitvoer
1	abcde
2	abcd	e
3	abc	ed
4	ab	edc
5	a	edcb
6		edcba

Een getal omdraaien kan op dezelfde manier, mits je er een cijfer aan het eind kunt afhalen en toevoegen. Een getal erafhalen kan met a/10 en a%10 (waarbij % staat voor modulo, de rest na deling). Als bijvoorbeeld a gelijk is aan 12345, dan is a/10 gelijk aan 1234 (integer deling rond altijd omlaag af) en a%10 gelijk aan 5.

Evenzo kun je een cijfer aan een getal toevoegen door het getal te vermenigvuldigen door 10 en er het cijfer bij op te tellen. Als ik 4 wil toevoegen aan 123, doe ik dus (123*10)+4 == 1234.

Nu kun je hetzelfde algoritme mplementeren om een getal om te draaien:

C:

unsigned int a = 12345, b = 0;
while(a != 0) {
    int x = a%10;    /* Laatste cijfer van a */
    b = 10*b + x;    /* Voeg x achteraan toe aan b */
    a = a / 10;      /* Verwijder laatste cijfer van a */
}
/* b is nu 54321! */

(En ja, de code is wat langer dan strict noodzakelijk.)

De operators / en % zijn in Pascal respectievelijk div (van division) en mod (van modulo), als ik het

[ Voor 4% gewijzigd door Soultaker op 11-11-2005 16:56 ]

[NickyVermeersch]

Na lang prutsen en veel verschillende programma's is dit tot nu toe het best werkende :

Alhoewel het programma effectief kan herkennen of het woord een hypodroom is of niet, is het alsof het in een oneindige loop zit en crasht.

code:

Program Oefening10;
Uses WinCrt;
Var  woord:String;
     n:Integer; {n is de onbekende Lengte}
     x:Integer; {x is een teller}
     Y:Integer; {Y is de invloed op de Index}

Procedure Init;
 Begin
  x:=0;
  Y:=1;
  WriteLn('Geef uw woord in aub...');
  ReadLn(woord);
  n:=Length(woord);
  
  For x := 1 to n do
   Begin
     If Woord[X]= Woord[N] Then
       Repeat
        If Woord[X+Y] = Woord[X-Y] Then
         WriteLn('OK');
         Inc(Y);
       Until Y = N       
       Else
        WriteLn('NOT OK');                             {toen dacht ik aan Index 1 vergelijken met Index n}
   End;                                    {en dan Index 2 vergelijken met Index n-1}
                                       {en van die "1" een variable maken die het programma elke keer laat vermeerderen}

 End;

Begin {Main}
 Init;
End.

Waarschijnlijk een stomme fout over het hoofd gezien, maar ik vindt deze niet =/

[KopjeThee]

Moet het middenstuk niet meer zoiets zijn?

code:

  X := n/2; {X is het midden van de string}

  For Y := 1 to n/2 do
   Begin
        If Woord[X+Y] != Woord[X-Y] Then
        WriteLn('NOT OK');  
       end  
   End;

P.S. Soultaker, doe eens iets aan die code van je. Ik hoef dit verder niet te beargumenteren. Als je argumenten wilt, moet je maar een ander topic openen.

[ Voor 25% gewijzigd door KopjeThee op 11-11-2005 19:19 ]

[Hydra]

kopjethee schreef op vrijdag 11 november 2005 @ 19:07:
P.S. Soultaker, doe eens iets aan die code van je.

Wat is daar mis mee?

[mandroid]

moet je in de vergelijking niet
Woord[X+Y] = Woord[n-Y]
gebruiken

[NickyVermeersch]

lord-evil schreef op vrijdag 11 november 2005 @ 19:37:
moet je in de vergelijking niet
Woord[X+Y] = Woord[n-Y]
gebruiken

Dan geeft ie nog altijd dezelfde fout weer

[RobIII]

NickyVermeersch schreef op vrijdag 11 november 2005 @ 20:00:
[...]


Dan geeft ie nog altijd dezelfde fout weer

Je zou natuurlijk gewoon je code eens kunnen debuggen, er door heen stappen, wat moeite doen enzovoorts in plaats van dat we je aan je handje gaan houden. Programmeren is ook debuggen, en een erg belangrijke skill als je wat wil maken van dat vak.

Er staan zat oplossingen in dit topic waar je je code van kunt afleiden, er zijn zat voorbeelden op internet te vinden en zo heel erg moeilijk is je opdracht nou ook weer niet. Het is zeg maar niet bepaald rocket science

Mocht je er niet uit komen, probeer dan je opdracht eens uit te werken in pseudo-code, een PSD of whatever (wat je gegarandeerd ook hebt geleerd voordat je aan Pascal begon) en zet dat om naar code. Bedenk desnoods voor jezelf hoe je het zelf zou controleren of een woord een palindroom is en schrijf dat stapsgewijs in code op.

Vast een oproepje dus aan posters na mij: geef nou niet alles weg en laat de TS zelf ook wat denkwerk verrichten

[ Voor 48% gewijzigd door RobIII op 11-11-2005 20:08 ]

[NickyVermeersch]

Ik heb nu eindelijk eenwat stabiele code die niet meer crash en nu kan herkennen of het woord een palindroom is of niet. Echter als het geen palindroom is loopt het nog vast, dus zoek ik nog ff voort naar een oplossing (Else is niet gelukt).

code:

Program Oefening10;
Uses WinCrt;
Var  woord:String;
     n:Integer; {n is de onbekende Lengte}
     x:Integer; {x is een teller}
     Y:Integer; {Y is de invloed op de Index}

Procedure Init;
 Begin
  x:=0;
  Y:=0;
  WriteLn('Geef uw woord in aub...');
  ReadLn(woord);
  n:=Length(woord);
  
  For x := 1 to n do
   Begin
     If Woord[X+Y] = Woord[N-Y] Then
      Begin
      WriteLn('OK');
      Inc(Y);
      End;
     Else
      Begin
      WriteLn('NOT OK');
      End;
   End;   
 End;

Begin {Main}
 Init;
End.

edit: Else toegevoegd waarmee ik werkte

[ Voor 10% gewijzigd door NickyVermeersch op 13-11-2005 02:17 ]

[Verwijderd]

NickyVermeersch schreef op zondag 13 november 2005 @ 01:59:
Ik heb nu eindelijk eenwat stabiele code die niet meer crash en nu kan herkennen of het woord een palindroom is of niet. Echter als het geen palindroom is loopt het nog vast, dus zoek ik nog ff voort naar een oplossing (Else is niet gelukt).

code:

Program Oefening10;
Uses WinCrt;
Var  woord:String;
     n:Integer; {n is de onbekende Lengte}
     x:Integer; {x is een teller}
     Y:Integer; {Y is de invloed op de Index}

Procedure Init;
 Begin
  x:=0;
  Y:=0;
  WriteLn('Geef uw woord in aub...');
  ReadLn(woord);
  n:=Length(woord);
  
  For x := 1 to n do
   Begin
     If Woord[X+Y] = Woord[N-Y] Then
      Begin
      WriteLn('OK');
      Inc(Y);
      End;
     Else
      Begin
      WriteLn('NOT OK');
      End;
   End;   
 End;

Begin {Main}
 Init;
End.

edit: Else toegevoegd waarmee ik werkte

de fout zit in je vergelijking, en wel in de woord[x+y], Kijk maar eens goed !
Je checkt :
run 1 : karakter 1 met length(x) - 1
run 2 : karakter 3 met length(x) - 2
run 3 : karakter 5 met length(x) - 3
..
..
run n : karakter ((n-1) * 2) + 1 met length(x) - n

De volgende code zou volgens mij moeten werken

Delphi:

  for x := 1 to (length(woord) div 2) do { we hoeven maar de helft van de karakters te checken }
    begin
      if woord[x] <> woord[length(woord) - x + 1] then
        begin
          { Er is een fout, we hoeven niet meer verder te gaan }
          WriteLn('Niet ok') ; 
          Halt(0) ; { stop programma }
        end ;
    end ;
  { Als we hier zijn, zijn alle karakters goedgekeurd }
  WriteLn ('Ok') ;

En ja, je kunt de lengte van het woord ook nog wel even in een variabele zetten ter optimalisatie.

[ Voor 21% gewijzigd door Verwijderd op 13-11-2005 02:29 ]

[NickyVermeersch]

Dus de fout zat in de vergelijking

[Emmeau]

ranzige pseudocode hoe ik dit ooit heb opgelost

code:

bool IsPalindroom(S string, l int, r int)
{
    if l < r then
        IsPalindroom = (S[l]==S[r]) and IsPalindroom(S,l+1,r-1)
    else
        IsPalindroom = true
    endif
}

/* aanroepen met IsPalindroom(<palindroomstring>, 1, length(palindroomstring)> */

Eventueel nog een functie eromheen schrijven die IsPalindroom aanroept met de juiste argumenten.

[ Voor 5% gewijzigd door Emmeau op 13-11-2005 02:35 ]