Leerzeichen aus einem String löschen?

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 :-)

> Ich würds so probieren (ohne Gewähr)

Die letzte Zuweisung kann man sich schenken, wenn man eine
do...while-Schleife nimmt.
Die passt hier besser.

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.

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.

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?

Sieht korrekt aus.

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)

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.

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?

:-)

doch

Tobias Mehrl schrieb:
> So siehts aus:
>
>

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+1] = satzpalindrom[len1];    //0-Terminierung an die

12

> richtige Stelle ins Array

>
>
> 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);

Karl heinz Buchegger schrieb:
> Tobias Mehrl schrieb:
>> So siehts aus:
>>
>>

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+1] = satzpalindrom[len1];    //0-Terminierung an die

12

>> richtige Stelle ins Array

>>
>>
>> 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?

ok, abgehakt

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.

Tusch, und jetzt kann man es schöner machen :-)

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.

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?

Tobias Mehrl schrieb:
> 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';

12

>

>
> 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 Minuspunkt bekommt er von mir stattdessen für das using namespace 
std;

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.

Karl heinz Buchegger schrieb:
> Den/die Minuspunkt(e) kriegt von mir sein Lehrer.

Ja, erstmal hat er als mildernde Umstände "schlechter Umgang".

OK, Tobias

Wie gehts weiter auf dem Weg zum Palindrom?
Wie sieht dein Plan aus?

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

6

 {

7

   satzpalindrom_klein_ohneleer[j] = tolower(ohneleer[i]);

8

 }

9

 satzpalindrom_klein_ohneleer[len2] = '\0';

Man hätte allerdings das tolower auch gleich in die erste SChleife mit 
aufnehmen können:

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

   satzpalindrom_klein_ohneleer[j] = tolower( satzpalindrom[i] );

8

   j = j + 1;

9

  }

10

 }

11

 ohneleer[j] = '\0';    //0-Terminierung an die richtige Stelle ins Array

dann fällt schon mal Code weg, es fallen Variablen weg, etc.

Aber es ist ok.
Zum jetzigen Zeitpunkt zählt 'funktioniert' noch ein wenig mehr.

PS:
Wegen dem vorletzten Programmteil.
SChau dir mal deinen Vorrat an Funktionen in string.h durch.
Da gibt es eine Funktion namens strrev

Nicht im Standard.

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:
> while(text[i] = satzpalindrom[j++])

Sollte natürlich doppelt geklammert werden:
while((text[i] = satzpalindrom[j++]))

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.

Torsten K. schrieb:
> Tobias, bitte weglesen  :)

Guter Rat! :-)

Eigentlich ja.

Um Strings an Funktionen zu übergeben, brauchst du aber Zeiger.
Ggf. willst du dich erst über die schlau machen.

Nicht sinnvoll.
Nimm dir ein Buch, mach am WE Pointer, und du hast einen Vorsprung.

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

int ispalindrom(char s[]) {

6

  int i=0, j=strlen(s)-1;

7

8

  while(i < j) {

9

    if(!isalpha(s[i]))

10

      i++;

11

    else if(!isalpha(s[j]))

12

      j--;

13

    else if(tolower(s[i++]) != tolower(s[j--]))

14

      return 0;

15

  }

16

  return 1;

17

}

18

19

int main(void) {

20

  char line[100];

21

22

  printf("Bitte einen Satz eingeben:\n");

23

  fgets(line, sizeof line, stdin);

24

  if(ispalindrom(line))

25

    printf("Ja, ist ein Palindrom!\n");

26

  else

27

    printf("Nein, ist KEIN Palindrom!\n");

28

}

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

> int ispalindrom(char s[]) {

6

>   int i=0, j=strlen(s)-1;

7

> 

8

>   while(i < j) {

9

>     if(!isalpha(s[i]))

10

>       i++;

11

>     else if(!isalpha(s[j]))

12

>       j--;

13

>     else if(tolower(s[i++]) != tolower(s[j--]))