C-string umdrehen mit arrays < Algorithmen < Schule < Informatik < Vorhilfe
|
| Status: |
(Frage) beantwortet  | | Datum: | 20:42 Sa 04.03.2006 | | Autor: | MonoTon |
| Aufgabe | | Das Programm soll ein Wort einlesen und dieses mit Hilfe von arrays umgekehrt ausgeben. |
hier mein lösungsvorschlag, funktioniert nur leider nicht ganz so wie es sollte...
| 1: |
| | 2: | /* SPEICHERTAUSCH mit 2 arrays (sa, mar 4th 2006 19:40) */
| | 3: |
| | 4: | #include <stdio.h>
| | 5: | #include <conio.h>
| | 6: | #include <string.h>
| | 7: |
| | 8: | void main ()
| | 9: | {
| | 10: |
| | 11: | char array[30], tmp[30];
| | 12: | int i, j, smax, k;
| | 13: |
| | 14: | while(1)
| | 15: | {
| | 16: | printf("Bitte ein Wort eingeben: \ n ");
| | 17: | scanf("%s%*c",array);
| | 18: |
| | 19: | for( i=0 ; array[i] ! = '\ 0' ;i++ );
| | 20: |
| | 21: | j=i;
| | 22: | smax=i;
| | 23: |
| | 24: | printf(" smax = %d\ n", smax );
| | 25: |
| | 26: | for (i=j;i>0;i--) /*Diese Schleife zieht von i 1 ab.*/
| | 27: | {
| | 28: | for (k=0;k>i;k++) /*Diese schleife setzt k=0 und lässt k hochzählen*/
| | 29: | array[i]=tmp[k]; /*während die i-Schleife runterzählt und damit*/
| | 30: | } /*von hinten nach forne den string in tmp abspeichert*/
| | 31: |
| | 32: | printf("Das umgekehrte Wort lautet %d",tmp);
| | 33: |
| | 34: |
| | 35: | }
| | 36: |
| | 37: | }
|
Das Programm kann das Wort nicht rückwerts ausgeben, es gibt merkwürdiger Weise nur irgendeinen Zahlenwert aus. Bin für jede Hilfe dankbar!
mfg mono
|
|
| |
|
Hallo MonoTon,
![[willkommenir]](/images/smileys/willkommenir.png "[willkommenir]")
Ich habe mir dein Programm genommen, und es soweit verändert, daß es funktioniert:
| 1: |
| | 2: | /* SPEICHERTAUSCH mit 2 arrays (sa, mar 4th 2006 19:40) */
| | 3: |
| | 4: | #include <stdio.h>
| | 5: |
| | 6: | int main(int argc, char* argv[])
| | 7: | {
| | 8: | char array[30], tmp[30];
| | 9: | int smax, k;
| | 10: |
| | 11: | while(1)
| | 12: | {
| | 13: | printf("Bitte ein Wort eingeben:\n");
| | 14: | scanf("%s%*c",array);
| | 15: |
| | 16: | for(smax=0; array[smax] != '\0'; smax++);
| | 17: |
| | 18: | printf("smax = %d\n", smax);
| | 19: |
| | 20: | tmp[smax] = '\0'; /* Wir benutzen smax, um das Ende des Wortes zu markieren. */
| | 21: | for(k = smax-1; k >= 0; k--) /* Diese schleife setzt k auf den letzten Buchstaben
| | 22: | des Wortes und lässt k runterzählen */
| | 23: |
| | 24: | tmp[smax-k-1] = array[k]; /* hier wird von hinten nach forne der string in tmp abgespeichert */
| | 25: |
| | 26: | printf("Das umgekehrte Wort lautet: %s\n",tmp);
| | 27: | }
| | 28: |
| | 29: | return 0;
| | 30: | }
|
Variablen wie j oder i waren bei dir letztlich nicht notwendig, smax hat jetzt die Funktion einer Markierung des Ende des eingegebenen Wortes und die äußere FOR-Schleife habe ich auch entfernt. Und dann hattest du da z.B. array[..] = tmp[..] statt tmp[..] = array[..] stehen, obwohl du nachher tmp ausgibst  ; war aber wohl ein Versehen. Bis Zeile 18 funktioniert das Programm eigentlich wie bei dir. Danach kommt die Umkopierschleife. Die Anweisung in Zeile 20 markiert das Ende des neuen Wortes, welches ja mit dem Ende des Originalwortes identisch ist. Danach kommt eine Schleife die k runterzählt.
Also nochmal: von 0 bis smax-1 steht das eigentliche Wort; bei smax steht NULL. Die einzige Schwierigkeit hier ist die Kopiertgrenzen von tmp richtig zu wählen. Dazu reicht es aber den smax-1-ten (ersten) und 0-ten (letzten) Schritt der Kopieroperation zu betrachten. Es gilt:
smax-k-1 = smax-(smax-1)-1 = 0
Damit landet das smax-1-te Zeichen aus array auf der 0ten Position in tmp. Für k = 0 gilt: smax-k-1 = smax-1. Damit landet das 0-te Zeichen in array auf der smax-1ten Position in tmp und auf der smax-ten Position steht ja NULL, womit die Umkehrung erfolgt wäre.
Jetzt zu deiner Lösung:
> for (i=j;i>0;i--) /*Diese Schleife zieht von i 1
> ab.*/
> {
> for (k=0;k>i;k++) /*Diese schleife setzt k=0
> und lässt k hochzählen*/
> tmp[k]=array; /*während die i-Schleife
> runterzählt und damit*/
> } /*von hinten nach forne den
> string in tmp abspeichert*/
>
Ok, die innere Schleife sieht für i = SMAX so aus:
for(k = 0; k > SMAX; k++)
Aber eigentlich dürfte er hier den Schleifenrumpf doch gar nicht mehr ausführen, denn 0 ist nicht größer als SMAX also ist die Schleifenbedingung sofort nicht mehr erfüllt. Selbst für i = 0 dürfte der Schleifenrumpf niemals ausgeführt werden, weil [mm]0 \not> 0[/mm] ist. Also müßte dort eher sowas wie k <= SMAX stehen. Im Übrigen wäre doch der i-te Index während die innere Schleife ausgeführt wird immer derselbe, also würde tmp bei jedem Durchlauf der äußeren Schleife mit denselben Zeichen gefüllt werden. ![[kopfkratz3]](/images/smileys/kopfkratz3.gif "[kopfkratz3]")
Na ja, ich denke mit dem abgeänderten Programm bist Du jetzt erstmal ganz gut beraten.
Viele Grüße
Karl
|
|
|
| |
|
| Status: |
(Mitteilung) Reaktion unnötig  | | Datum: | 22:46 Do 23.03.2006 | | Autor: | MonoTon |
Dankeschön, hat mir sehr geholfen.
Aber auch ein paar andere Fragen aufgeworfen die sich inzwischen aber auch schon erledigt haben!
mfg
monoTon
|
|
|
| |
|
Hallo anna_h,
> Ich habe ein riesen Problem. Ich muss bis morgen ein
> c-programm schreiben das mir char umdreht.Den Code habe ich
> gegoogelt. Den habe ich ausprobiert und der klappt 1A 
Der Code, den du gefunden hast, stammte offenbar aus meiner Antwort zur obigen Diskussion. Deswegen habe ich den Code aus deiner Frage entfernt und die Frage hierhin verschoben.
> 1)Ist das ein reiner c-code, oder ist da c++ dabei?
Es kommt darauf an, was du unter "reinem c-code" verstehst. Z.B. akzeptieren manche älteren(?) Compiler nur folgende Möglichkeit Variablen zu deklarieren:
statt: int x,y,z;
schreibt man: int x;int y; int z; x=0;x=1;x=2;
(letzteres schreibt man, wenn man die Variablen noch mit Anfangswerten belegen möchte ("initialisieren").)
Als Antwort würde ich hier sagen: Es ist C-Quelltext und C++ sehe ich da nicht. (Wäre da C++ drin, sollte der Quelltext vom Compiler während der Übersetzung in Maschinensprache auch nicht akzeptiert werden.)
> 2) Was macht diese zeile genau int main(int argc, char*
> argv[]) ? Vorallem was bedeutet das *?
Lies dir z.B. ![[]](/images/popup.gif) das hier durch. 'int argc' gibt die Anzahl der Parameter an mit denen ein Programm aufgerufen wird. Es sollte, wenn ein Programm ohne Parameter aufgerufen wurde, zumindest 1 sein, da der Programmname und pfad immer in argv[0] abgelegt werden. argv ist ein Array von Zeigern auf Variablen vom Typ char. Wenn du z.B. ein Programm abc mit dem Parameter def aufrufst: ./abc def . Erhälst du
argv[1] zeigt auf "abc\0" und *argv[1] wäre z.B. gleich 'a'.
> 3) die ausgaben sind nicht klar!!! Was bedeutet
> ("%s%*c",array),("smax = [mm]%d\n",[/mm] smax) und ("Das umgekehrte
> Wort lautet: [mm]%s\n",tmp).[/mm]
> vorallem diese %buchstabe ist mir unklar.
Du kannst z.B. mit dieser Lektüre hier anfangen. Bei scanf wird also eine ganze Zeichenkette ohne Whitespace eingelesen und jegliche nachfolgenden Zeichen im Eingabestrom werden verworfen. Es handelt sich um zwei Formatbezeichner:
%: hier fängt ein Formatbezeichner an
s: liest mehrere Zeichen hintereinander ein bis ein Leer-, Return- oder Tabulatorzeichen gefunden wird.
%: siehe oben
*: liest Daten aus dem Eingabestrom und verwirft sie ohne diese in irgendeine Variable abzulegen
c: liest genau ein zeichen ein
Genauso funktioniert es auch bei printf; Nur das printf Daten aus einer Variablen nach den Vorgaben des Formatstrings ausliest und diese dann ausgibt.
> 4) Wo wird smax bestimmt?
In Zeile 16 siehst du eine for-Schleife mit leerem Schleifenrumpf, die dazu gedacht ist, das Ende (bzw. die Länge) der umzukopierenden Zeichenkette array auszumachen.
Viele Grüße
Karl
|
|
|
|
