Hi Leute!
Ich hab folgendes Problem. Ich soll aus einem String (ich benutze dafür
Sätze) die evtl. darinstehenden Leerzeichen löschen. Dass man direkt
eine Stelle eines Arrays nicht löschen kann ist mir klar. Jetzt hab ich
es so versucht:
Das Programm liest mir eine Zeichenkette ein und schreibt mir in das
array "Dummy2" die Stellen des Strings als Zahl rein, in denen ein
Leerzeichen ist. Jetzt weiß ich zumindestens schon mal wie viel
Leerzeichen drin sind und an welchen Stellen. Nur wie bekomme ich jetzt
mit diesem gewonnenen Wissen die Leerzeichen aus meiner Zeichenkette
"satzpalindrom"?
Ich kann bisher nur Schleifen, Funktionen, Felder und Zeichenketten. Die
Funktion isalpha dürfen wir benutzen. Pointer oder ähnliches haben wir
noch nicht durchgenommen...
Könnt ihr mir helfen?
Tobias Mehrl schrieb:> Könnt ihr mir helfen?
Du gehst das falsch an.
Stell dir einfach vor, du müsstest den String umkopieren. Und du
kopierst einfach nur die Buchstaben um, die keine Leerzeichen sind.
Ooops. Fertig. Das Ergebnis ist dein Eingabstring ohne Leerzeichen.
Das umkopieren kann man auf 2 Arten machen: Entweder in ein neues
Character Array, oder aber eleganter in dasselbe Character Array. Aber
da du in deinem Programm sowieso schon dafür ein extra Array vorgesehen
hast, ist die erste Version fein.
vergiss nicht auf Tabulatoren und Satzzeichen. Die werden m.W. bei
Palindromen ebenfalls ignoriert :-)
Floh schrieb:> Sorry les erst jetzt das du keine Pointer hast.> allerdings lässt sich in diesem Fall der Pointer auch durch Zugriffe auf> das Array ersetzen.> :-)
Macht nichts.
er soll's ja selber lernen. Und so schwer ist das nicht. Er hatte nur zu
kompliziert gedacht.
(PS: Strings geht man besser mit einer while Schleife durch
while( *quelle != '\0' ) {
oder do .... while( *quelle )
meistens hat man dann weniger Sonderfälle.)
nein, weil die würde die Leerzeichen mitkopieren.
Du musst strcpy() nachbauen, mit der kleinen Änderung.
Ein sinnvolle Vorübung wäre m.E. deshalb, strcpy() nachzubauen
und dann anschließend zu ändern - wobei du in diesem Fall
in die gleiche Stelle kopieren kannst, von der du auch liest.
Probleme hab ich mit der kleinen Änderung... Ich will ja echte Zeichen
umkopieren. Irgendwie raff ich das an der Stelle nicht...
Könnt ihr mir vielleicht schrittweise helfen wie ich nun mein Problem in
meine nachgebaut strcpy implementiere?
Tobias Mehrl schrieb:> strcpy nachbauen? Ich würde es so machen:
Sieht nicht schlecht aus.
> Probleme hab ich mit der kleinen Änderung... Ich will ja echte Zeichen> umkopieren. Irgendwie raff ich das an der Stelle nicht...
Warum nicht?
satzpalindrom[i] ist das Zeichen an der Stelle i im String.
Es wird nur dann umkopiert, wenn es kein Leerzeichen ist.
Aber: Du kannst es nicht an die Stelle i in Text kopieren. Den das Ziel
kann ja eine ganz andere Indexnummer haben. Du wirst daher noch eine
2.te Variable brauchen, nennen wir sie j, in der steht wo denn in Text
das Zeichen satzpalindrom[i] abgelegt werden soll, wenn es denn kopiert
werden müsste.
Einfach mal auf dem Papier probieren.
Der Satz sei "He du"
satzpalindrom
+---+---+---+---+---+---+
| H | e | | d | u | \0|
+---+---+---+---+---+---+
text
+---+---+---+---+---+---+
| | | | | | |
+---+---+---+---+---+---+
und los gehts.
erstes Zeichen satzpalindrom[0]: H
ist kein Leerzeichen, wird also umkopiert. Wo genau hin? An text[0]
satzpalindrom
+---+---+---+---+---+---+
| H | e | | d | u | \0|
+---+---+---+---+---+---+
text
+---+---+---+---+---+---+
| H | | | | | |
+---+---+---+---+---+---+
nächstes Zeichen, satzpalindrom[1]: e
wieder: kein Leerzeichen, wird also umkopiert.
Wohin? nach text[1]
satzpalindrom
+---+---+---+---+---+---+
| H | e | | d | u | \0|
+---+---+---+---+---+---+
text
+---+---+---+---+---+---+
| H | e | | | | |
+---+---+---+---+---+---+
Nächstes Zeichen, satzpalindrom[2]:
Ist ein Leerzeichen, nichts weiter passiert
Nächstes Zeichen, satzpalindrom[3]: d
kein Leerzeichen, wird umkopiert
Wohin? nach text[2], denn zuletzt wurde ja text[1] beschrieben
satzpalindrom
+---+---+---+---+---+---+
| H | e | | d | u | \0|
+---+---+---+---+---+---+
text
+---+---+---+---+---+---+
| H | e | d | | | |
+---+---+---+---+---+---+
Nächstes Zeichen, satzpalindrom[4]: u
kein Leerzeichen, wird umkopiert
Wohin, nach text[3]
satzpalindrom
+---+---+---+---+---+---+
| H | e | | d | u | \0|
+---+---+---+---+---+---+
text
+---+---+---+---+---+---+
| H | e | d | u | | |
+---+---+---+---+---+---+
Und dann bleibt noch das abschliessende \0, das ja ebenfalls nicht als
Leerezeichen gilt und daher auch umkopiert wird
satzpalindrom
+---+---+---+---+---+---+
| H | e | | d | u | \0|
+---+---+---+---+---+---+
text
+---+---+---+---+---+---+
| H | e | d | u | \0| |
+---+---+---+---+---+---+
Das Eregbnis sieht richtig aus. Alle Leerzeichen sind verschwunden.
Ich würde es nicht so machen, weil der Aufruf von strlen()
überflüssig ist und nur Zeit kostet.
PS: machen kann man es natürlich auch so, ich will ja nicht
zuviel meckern.
Erstmal muß es korrekt funktionieren.
Nehmen wir mal als Beispiel den satz: Hallo du da! (ist zwar kein
Palindrom aber er hat Leerzeich und um die gehts ja.)
So, nun kopiere ich 'H' an meine 0te Stelle in meinem neuen Array;
genauso verfahre ich nun bis ich zum 'o' komme. Nun kommt aber an der 5.
Stellen ein Leerzeichen. Woher weiß nun aber die for-Schleife (mit der
ich ja umkopiere) das hier nun ein Leerezeichen kommt, welches sie nicht
kopieren darf?
Tobias Mehrl schrieb:> Nehmen wir mal als Beispiel den satz: Hallo du da! (ist zwar kein> Palindrom aber er hat Leerzeich und um die gehts ja.)>> So, nun kopiere ich 'H' an meine 0te Stelle in meinem neuen Array;> genauso verfahre ich nun bis ich zum 'o' komme. Nun kommt aber an der 5.> Stellen ein Leerzeichen. Woher weiß nun aber die for-Schleife (mit der> ich ja umkopiere)
Die for-Schleife weiss das auch nicht. DIe interessiert das auch nicht
weiter. Aber du kannst ja innerhalb des for noch ein if machen. Niemand
hindert dich daran. Und du musst den Buchstaben, wenn du ihn umkopierst
auch nicht nach text[i] kopieren
Klaus Wachtler schrieb:> Ich würde es nicht so machen, weil der Aufruf von strlen()> überflüssig ist und nur Zeit kostet.
Bitte bedenken: Er ist Anfänger!
Keine Pointer, einfacher naheliegender Code
Tobias Mehrl schrieb:> Und mit genau dieser if-Abfrage prüfe ich auf das Leerzeichen, stimmts?
Genau.
Aber scroll noch mal hoch.
Da fehlt noch eine Zutat. Ich hab weiter oben ein längeren Abschnitt
gemacht, der dich auf die wichtige Idee bringen soll.
Karl heinz Buchegger schrieb:> Bitte bedenken: Er ist Anfänger!> Keine Pointer, einfacher naheliegender Code
Es geht mit Index auch ohne strlen, aber ich habe ja auch
schon eingesehen, daß es nicht so wichtig ist :-)
Klaus Wachtler schrieb:> Karl heinz Buchegger schrieb:>> Bitte bedenken: Er ist Anfänger!>> Keine Pointer, einfacher naheliegender Code>> Es geht mit Index auch ohne strlen, aber ich habe ja auch> schon eingesehen, daß es nicht so wichtig ist :-)
:-)
(Bin neugierig, wann der Groschen bei ihm fällt)
Tobias Mehrl schrieb:> Könnt ihr mal gucken ob das so jetzt passt? mein compiler meckert nicht> und auch das ergebnis passt...
Ist richtig.
Habt ihr schon while-Schleifen gemacht?
Was mir gefällt:
Du hast bereits angefangen einen Formatier-Stil zu entwickeln. Noch
etwas zaghaft, aber das wird mit der Zeit.
Mach weiter so.
PS:
Wenn in einem else nichts steht, dann lass es besser weg. Code
übersichtlich zu machen ist eine Sache. Aber ihn ohne Not in die Länge
zu ziehen geht in die falsche Richtung
1
for(i=0;i<=len;i=i+1)
2
{
3
if(satzpalindrom[i]!=' ')
4
{
5
text[j]=satzpalindrom[i];
6
j=j+1;
7
}
8
}
ist genausogut, wenn nicht sogar besser weil nicht so in die Länge
gezogen. Je näher die abschliessende } zur jeweils öffnenden { steht,
umso leichter ist es den Überblick zu behalten, wie die einzelnen Teile
ineinander geschachtelt sind.
@Klaus:
Ich hab getline schon lang nicht mehr benutzt. Liefert das eigentlich
den \n mit oder nicht? (Das könnte einer der nächsten Stolpersteine
werden, nachdem er den String umgedreht hat)
Sorry, wenn ich das etwas unverständlich geschrieben hab.
Ich gebe z.B. eine Zeichenkette von 7 Zeichen ein. len1 passt noch das
gibt 7 aus. len2 ist aber dann unverständlicherweise 115... Was is'n da
jetzt falsch?
Karl heinz Buchegger schrieb:> @Klaus:> Ich hab getline schon lang nicht mehr benutzt. Liefert das eigentlich> den \n mit oder nicht? (Das könnte einer der nächsten Stolpersteine> werden, nachdem er den String umgedreht hat)
nein, tut es glaube ich nicht
Tobias Mehrl schrieb:> Ich gebe z.B. eine Zeichenkette von 7 Zeichen ein. len1 passt noch das> gibt 7 aus. len2 ist aber dann unverständlicherweise 115... Was is'n da> jetzt falsch?
Durch das isalpha wird die abschließende 0 nicht mitkopiert,
also ist der erzeugte String nicht terminiert.
Ein strlen() darauf zählt also bis zur ersten zufällig im Speicher
stehenden 0.
> Durch das isalpha wird die abschließende 0 nicht mitkopiert,> also ist der erzeugte String nicht terminiert.
Genau.
Und deshalb ist das hier
1
len2=strlen(ohneleer);
2
ohneleer[len2]=satzpalindrom[len1];//0-Terminierung an die richtige Stelle ins Array
so nicht möglich.
strlen ist darauf angewiesen, dass die 0-Terminierung schon am richtigen
Platz ist. Du musst daher deine 0-Terminierung auf einem anderen Weg an
die richtige Stelle schreiben. Und erst dann kannst du irgendeine der
str... Funktionen benutzen.
Du hast hier versucht, das Pferd von hinten aufzuzäumen.
Tobias Mehrl schrieb:> Darf ich über "ohneleer[len2] = satzpalindrom[len1];" schreiben?
Nein.
Denn len2 hast du ja noch nicht.
Aber du hast eine andere Variable, die dir verrät, wieviele Zeichen du
in ohneleer hineingegeben hast.
Hm, dann bin ich mit meinem Latein am Ende... Wie bring ich dann im
String ohneleer die 0-Terminierung in Abhängigkeit des eingegebenen
Strings an die richtige Stelle?
Tobias Mehrl schrieb:> Hm, dann bin ich mit meinem Latein am Ende... Wie bring ich dann im> String ohneleer die 0-Terminierung in Abhängigkeit des eingegebenen> Strings an die richtige Stelle?
Innerhalb der SChleife:
Wohin würde der nächste Buchstabe geschrieben werden, wenn noch einer da
wäre?
Überleg doch mal, welche Aussage dir dein j erlaubt!
Tobias Mehrl schrieb:> "Aber du hast eine andere Variable, die dir verrät, wieviele Zeichen du> in ohneleer hineingegeben hast.">> Soll das dann j sein?
:-)
>ohneleer[j+1]=satzpalindrom[len1];//0-Terminierung an die
12
>richtigeStelleinsArray
>>> Geht aber auch nicht. In ohneleer steht nach wie vor keine 0
Wenn du ohnehin weißt, dass du das Zeichen '\0' dort reinbugsieren
musst, warum schreibst du es dann nicht einfach als '\0' sondern
versuchst es dir aus satzpalindrom zu holen? Und dann dort auch noch von
der falschen Stelle.
Wenn du dir nicht sicher bist (da ist dann noch ein Fehler), dann spiels
auf einem Stück Papier durch
Gegeben sei der String
+---+---+---+---+---+---+ +---+---+---+---+---+---+---+---+
| H | e | | d | u | \0| | | | | | | | | |
+---+---+---+---+---+---+ +---+---+---+---+---+---+---+---+
den du nach rechts umkopieren musst.
Welche Werte haben in jedem Schleifendurchgang i und j, was passiert
innerhalb der Schleife
i j Aktion
-------------------------
0 0 H umkopieren, j wird 1
+---+---+---+---+---+---+ +---+---+---+---+---+---+---+---+
| H | e | | d | u | \0| | H | | | | | | | |
+---+---+---+---+---+---+ +---+---+---+---+---+---+---+---+
1 1
(du machst weiter)
Abgesehen davon, kann die Schleife auch getrost einmal weniger
durchlaufen werden.
Bisher hast du i<=len1, aber bei gleich len1 bist du ja an
der 0, die du wegen isalpha() sicher nicht kopierst.
i<len1 würde also auch reichen.
Karl heinz Buchegger schrieb:> Und dann dort auch noch von der falschen Stelle.
Daß es besser gleich als '\0' genommen werden könnte, ist natürlich
korrekt.
Aber wenn ich jetzt keinen Aussetzer habe, nimmt er es schon
von der richtigen Stelle (len1).
Klaus Wachtler schrieb:> Karl heinz Buchegger schrieb:>> Und dann dort auch noch von der falschen Stelle.>> Daß es besser gleich als '\0' genommen werden könnte, ist natürlich> korrekt.> Aber wenn ich jetzt keinen Aussetzer habe, nimmt er es schon> von der richtigen Stelle (len1).
Nope
> len1 = strlen(satzpalindrom);
>>ohneleer[j+1]=satzpalindrom[len1];//0-Terminierung an die
12
>>richtigeStelleinsArray
>>>>>> Geht aber auch nicht. In ohneleer steht nach wie vor keine 0> ...
Wo kommt jetzt ohneleer[j+1] = satzpalindrom[len1]; her?
Eben hieß es noch richtigerweise ohneleer[j] = satzpalindrom[len1];
Karl heinz Buchegger schrieb:> Klaus Wachtler schrieb:>> Karl heinz Buchegger schrieb:>>> Und dann dort auch noch von der falschen Stelle.>>>> Daß es besser gleich als '\0' genommen werden könnte, ist natürlich>> korrekt.>> Aber wenn ich jetzt keinen Aussetzer habe, nimmt er es schon>> von der richtigen Stelle (len1).>>> Nope>> len1 = strlen(satzpalindrom);
Arrgh.
Ja, du hast recht. War jetzt im Eifer des Gefechts.
Karl heinz Buchegger schrieb:> Nope
Doch!
Angenommen char str[] = "abc", dann hat len1=strlen(str) den Wert 3.
Und str[3] ist die abschließende 0, oder gebe ich besser mein
nicht existierendes Informatikdiplom zurück?
Tobias Mehrl schrieb:> Jetzt hab ich's so: (ich hab's auch auf dem papier durchgespielt.... da> passts)>>
1
len1=strlen(satzpalindrom);
2
>j=0;//Leerzeichen entfernen
3
>for(i=0;i<len1;i=i+1)
4
>{
5
>if(isalpha(satzpalindrom[i]))
6
>{
7
>ohneleer[j]=satzpalindrom[i];
8
>j=j+1;
9
>}
10
>}
11
>ohneleer[j]='\0';//0-Terminierung an die richtige Stelle ins
12
>Array
13
>
Ja, so passts.
j ist nach der Schleife gleich der Anzahl der umkopierten Buchstaben und
damit auch gleichzeitig die Länge des Strings. Nur der String muss das
auch noch wissen :-) Und dafür hast du jetzt korrekterweise gesorgt.
Ab jetzt steht in ohneleer wieder ein korrekter C-String mit dem man
weiterarbeiten kann.
Klaus Wachtler schrieb:> Tusch, und jetzt kann man es schöner machen :-)
:-) (auflach)
Der strlen ist dir ein Dorn im Auge.
Mir auch.
Fang an. Oder präsentieren wir ihm die Alternative? Ich denk es wäre
vertretbar, weil die Denkweise dann doch ganz anders ist.
Leute nochmal kurz für mich:
Ich hab jetzt den Code:
1
len1=strlen(satzpalindrom);
2
j=0;//Leerzeichen entfernen
3
for(i=0;i<len1;i=i+1)
4
{
5
if(isalpha(satzpalindrom[i]))
6
{
7
ohneleer[j]=satzpalindrom[i];
8
j=j+1;
9
}
10
}
11
ohneleer[j]='\0';
Wenn ich mir jetzt in Visual Studio 2010 die Strings ansehe, dann steht
in ohneleer zwar keine Leerzeichen mehr drin und nur noch die buchstaben
aber keine 0...
Tobias Mehrl schrieb:> Leute nochmal kurz für mich:>> Ich hab jetzt den Code:>> [c]> len1 = strlen(satzpalindrom);> j = 0; //Leerzeichen entfernen> for(i=0; i<len1; i=i+1)> {> if(isalpha(satzpalindrom[i]))> {> ohneleer[j] = satzpalindrom[i];> j = j + 1;> }> }> ohneleer[j] = '\0';> [c]>> Wenn ich mir jetzt in Visual Studio 2010 die Strings ansehe, dann steht> in ohneleer zwar keine Leerzeichen mehr drin und nur noch die buchstaben> aber keine 0...
Keine Sorge. Es steht eines drinnen.
Aber auch Visual Studio weiß, dass es sich bei einem char Array um einen
String handelt und zeigt dir den auch als String an.
Oder wo genau siehst du nach? Wenn du VS dazu zwingst, dir das Ding
einfach nur als Array zu präsentieren, dann findet sich dort auch wieder
das \0 Byte
Ja, aber sonst sieht es doch schon nett aus.
Eigentlich gehört das noch in eine Funktion, aber dafür braucht
man Zeiger zwecks Übergabe, und x=x+1 könnte man verkürzen, und
dann wäre da noch die Sache mit der do...while-Schleife.
Aber das ist letztlich alles Makulatur.
Klaus Wachtler schrieb:> Ja, aber sonst sieht es doch schon nett aus.>> Eigentlich gehört das noch in eine Funktion, aber dafür braucht> man Zeiger zwecks Übergabe, und x=x+1 könnte man verkürzen, und> dann wäre da noch die Sache mit der do...while-Schleife.>> Aber das ist letztlich alles Makulatur.
Ich denke so weit sind sie noch nicht im Unterricht. Also Funktionen und
so.
Aber, wenn ich das richtig interpretiere ist ja die Aufgabe noch nicht
fertig. Noch wissen wir ja nicht, ob die Eingabe ein Palindrom ist oder
nicht.
Tobias Mehrl schrieb:> Ich schaue mir die Variablen immer im lokalen Modus an... Und da, steht,> wie ihr sehen könnt, keine 0 an der Stelle 32 im array ohneleer...
Wann schaust du dir den String an?
Die Zeile mit der ='\0' muß erst ausgeführt worden sein!
Dazu muß der Debugger in der darauf folgenden Zeile stehen.
Falls doch nicht: welchen Wert hat j?
>> Wenn ich mir jetzt in Visual Studio 2010 die Strings ansehe, dann steht> in ohneleer zwar keine Leerzeichen mehr drin und nur noch die buchstaben> aber keine 0...
Wenn du dir das ansiehst, wo steht der gelbe Pfeil/Punkt vom Debugger im
Code?
Auf der Zeile
ohneleer[j] = '\0';
oder dahinter?
Die gelbe Markierung zeigt dir immer die Zeile, die als nächstes
ausgeführt wird aber noch nicht abgearbeitet wurde.
Frickler schrieb:> Wer <iostream> und <stdio.h> in einer Programmunit zusammen verwendet,> würde bei mir einen dicken Minuspunkt kassieren ;-)
Bei mir auch, aber erstmal nur weil es <cstdio> heißt.
Oder wenn er die beiden (alt und neu) auf dieselbe Datei anwendet,
aber das ist hier nicht der Fall :-)
Den/die Minuspunkt(e) kriegt von mir sein Lehrer.
Und zwar aus verschiedenen Gründen. Der wichtigste davon: Er kann sich
nicht entscheiden ob er C++ oder C unterrichten soll. Statt dessen
veranstaltet er da einen Mischmasch.
Wenn C, dann haben die C++ Header, cin und using nichts verloren.
Wenn C++, dann std::string anstelle von C-String Verarbeitung. Die kommt
später, viel später. In der Zwischenzeit sich an den Segnungen von
Objekten die auf sich selbst aufpassen erfreuen und zügig im Stoff
weiterkommen.
if(strcmp(ruckwartspalindrom,satzpalindrom_klein_ohneleer)==0)//Vergleich der beiden Zeichenketten
59
{
60
printf("Ja, ist ein Palindrom!\n");
61
}
62
else
63
{
64
printf("Nein, ist KEIN Palindrom!\n");
65
}
66
67
68
69
system("pause");
70
return0;
71
}
Jetzt möchte ich noch einzelne Programmteile in Funktionen auslagern
(das haben wir schon durchgemacht) aber ich denke, dass mach ich dann
lieber morgen. Kann ich mich morgen dazu wieder melden?
Das iostream brauch ich doch für cin.getline, oder?
Tobias Mehrl schrieb:> Ich hab fertig: Mein Programm für den Vergleich von Satzpalindromen> sieht so aus:
Okaaay
> Jetzt möchte ich noch einzelne Programmteile in Funktionen auslagern> (das haben wir schon durchgemacht) aber ich denke, dass mach ich dann> lieber morgen.
Ehe du das tust, schau dein Programm noch mal durch.
Da kann man noch viel tun
> Kann ich mich morgen dazu wieder melden?
Klar
>> Das iostream brauch ich doch für cin.getline, oder?
Schon. Aber was macht eigentlich cin in einem "C" Programm?
Karl heinz Buchegger schrieb:>> Jetzt möchte ich noch einzelne Programmteile in Funktionen auslagern>> (das haben wir schon durchgemacht) aber ich denke, dass mach ich dann>> lieber morgen.>> Ehe du das tust, schau dein Programm noch mal durch.> Da kann man noch viel tun
zb hier
1
len2=strlen(ohneleer);
2
j=0;
3
for(i=0;i<len2;i=i+1)//alle Buchstaben klein schreiben
4
{
5
kleinzeichen=tolower(ohneleer[i]);
6
satzpalindrom_klein_ohneleer[j]=kleinzeichen;
7
j=j+1;
8
}
9
satzpalindrom_klein_ohneleer[len2]='\0';
Wozu der strlen? Du kennst doch die Länge des Strings schon aus dem
vorhergehenden Teil.
Wozu brauchst du das j hier. j hat immer denselben Wert wie i.
Wozu die zusätzliche Variable 'kleinzeichen'
1
len2=j;// wenns schon eine Variable len2 braucht.
2
// ALternativ hätte man ja auch das j weiter oben
3
// gleich len2 nennen können
4
5
for(i=0;i<len2;i=i+1)//alle Buchstaben klein schreiben
Klaus Wachtler schrieb:> Nicht im Standard.
Echt?
OK. Dann ist das (wieder mal) mein Fehler. Bin davon ausgegangen, dass
das mitlerweile drinnen ist, weil ich beim schnellen Goggeln immer den
Verweis auf string.h gefunden habe.
Karl heinz Buchegger schrieb:> Oder präsentieren wir ihm die Alternative? Ich denk es wäre> vertretbar, weil die Denkweise dann doch ganz anders ist.
Tobias, bitte weglesen :)
unsigned int i,j;
...
// 0x20 raus
i=j=0;
while(text[i] = satzpalindrom[j++])
if (text[i] != ' ') i++;
// vergleich (i zeigt auf ende /0)
j=0;
while(j<i)
if (text[j++] != text[--i])
{ i++; j--; break; }
// ergebnis
if (j>=i)
printf("Ist 'n palidings");
else
printf("Ist keins");
Ich hoffe da ist jetzt (abgesehen vom Stil) kein logischer Fehler
drin...
Torsten K. schrieb:> Ich hoffe da ist jetzt (abgesehen vom Stil) kein logischer Fehler> drin...
Ich denke es müsste stimmen. (das tolower ist geschenkt)
Ich krieg die 2.te Schleife nicht weg, die ich brauch um einen Pointer
ans Stringende zu kriegen. Keine Chance. Mit weniger als 2 mal durch den
String gehts nicht. Ich wollte die Blanks 'on the fly' beim Durchmarsch
bis zur Mitte überspringen. Aber ich brauch 2 Pointer. Einen von vorne,
einen von hinten. Aber für den von hinten muss ich durch den String
durch.
@kbuchegg:
"Wozu der strlen? Du kennst doch die Länge des Strings schon aus dem
vorhergehenden Teil.
Wozu brauchst du das j hier. j hat immer denselben Wert wie i.
Wozu die zusätzliche Variable 'kleinzeichen'"
Das muss aber schon so heißen, oder?
1
for(i=0;i<len2;i=i+1)//alle Buchstaben klein schreiben
So, nun möchte ich nch mein Programm in Funktionen auslagern. Ich hab
hier ja drei Programmteile, nämlich "Leerzeichen entfernen", "String
umdrehen" und "Strings vergleichen". Die sollten sich doch jetzt ganz
einfach in Funktionen auslagern lassen, oder? Ich meine, abhängig sind
doch die 3 Funktionen doch eh nur von dem einmal ganz am anfang
eingegebenen string satzpalindrom, richtig?
Yalu X. schrieb:> Bei der Übergabe von Strings an Funktionen siehst du von den Pointern> normalerweise gar nichts, da du die Strings wie char-Arrays behandelst,> z.B. so:>>
1
>#include<stdio.h>
2
>#include<string.h>
3
>#include<ctype.h>
4
>
5
>intispalindrom(chars[]){
6
>inti=0,j=strlen(s)-1;
7
>
8
>while(i<j){
9
>if(!isalpha(s[i]))
10
>i++;
11
>elseif(!isalpha(s[j]))
12
>j--;
13
>elseif(tolower(s[i++])!=tolower(s[j--]))
14
>return0;
15
>}
16
>return1;
17
>}
18
>
oder rekursiv (nicht ganz, wer will bekommt aber das strlen auch noch
raus)
Tobias Mehrl schrieb:> @kbuchegg:>> "Wozu der strlen? Du kennst doch die Länge des Strings schon aus dem> vorhergehenden Teil.> Wozu brauchst du das j hier. j hat immer denselben Wert wie i.> Wozu die zusätzliche Variable 'kleinzeichen'">> Das muss aber schon so heißen, oder?>>
1
>for(i=0;i<len2;i=i+1)//alle Buchstaben klein schreiben
>> Wenn ich das j lasse, dann kopiere ich ab der 4. Stelle ins array
Du hast mich erwischt. War ein Copy&Paste Fehler.
Da j bei dir ja immer denselben Wert wie i hatte (an dieser Stelle) war
natürlich gemeint
1
for(i=0;i<len2;i=i+1)//alle Buchstaben klein schreiben