rekursive Folgen mit Arrays(C) < Praxis < Informatik < Vorhilfe
|
| Status: |
(Frage) beantwortet  | | Datum: | 18:40 Di 02.04.2013 | | Autor: | Mija |
| Aufgabe | Schreiben Sie ein C-Programm, in dem ein Array a von ganzen Zahlen erzeugt, auf eine bestimmte Weise initialisiert und dann formatiert auf dem Bildschirm ausgegeben wird. Der Benutzer soll im Dialog entscheiden, mit welchen Werten das Array initialisiert werden soll:
a) mit Potenzen von 2: [mm] $a_n [/mm] = [mm] 2^n [/mm] , n = 0, 1, ...$
b) als Fibonacci-Folge: [mm] $a_n [/mm] = [mm] a_{n−1} [/mm] + [mm] a_{n−2} [/mm] , n = 0, 1, ..., [mm] a_0 [/mm] = 0, [mm] a_1 [/mm] = 1$ usw.
c) mit Fakultät von n: [mm] $a_n [/mm] = n!, [mm] a_0 [/mm] = 1, [mm] a_1 [/mm] = 1$ usw.
d) als Collatz-Folge:
a_n = a_(n−1)/2, wenn a_(n−1) gerade,
a_n = (3a_(n−1) + 1)/2$, wenn a_(n−1) ungerade.
Für den Startwert [mm] $a_0$ [/mm] generieren Sie eine Zufallszahl zwischen 2 und 100.
Der Dialog könnte so aussehen:
Array initialisieren und ausgeben
=================================
Fakultaet: 1
2-Potenzen: 2
Fibonacci-Folge: 3
Collatz-Folge: 4
Ende: 0
=================================
Ihre Wahl? 1
Beachten Sie dabei folgende Hinweise bzw. Anforderungen an das Programm:
a) Die Größe des Arrays ist 15 und soll als eine symbolische Konstante MAX_LAENGE definiert werden.
b) Für die Arten der Initialisierung definieren Sie einen Aufzählungstyp initart.
c) Die Initialisierung des Arrays soll in einer eigenen Funktion init() passieren.
Diese Funktion soll zwei Parameter erhalten: das Array und die Art der Initialisierung. In der Funktion benutzen Sie die switch()-Anweisung, in der die Initialisierungsart ausgewertet wird.
d) Für die Berechnung der Folgenglieder schreiben Sie rekursive Funktionen potenz_2(), fibo(), faku() und collatz().
e) Schreiben Sie eine Funktion ausgabe(), in der das Array auf dem Bildschirm ausgegeben wird. Für die Ausgabe definieren Sie eine zweite symbolische Konstante PRO_ZEILE, die angibt, wieviel Arrayelemente in einer Zeile ausgegeben werden soll. Setzen Sie diese Konstante auf 5 und benutzen Sie diese Konstante für die Ausgabe. Geben Sie die Arrayelemente mit der Breite 10 aus. |
Hallo, ich habe ein paar Fragen zu der obenstehenden Aufgabe:
- sind meine Funktionen zu den einzelnen Folgen soweit richtig?
- Wie muss ich die Datentypen in der Funktion init() und den Rückgabetyp in den einzelnen Folgen-Funktionen anpassen? Ich habe schon etwas herumexperimentiert, bin aber zu noch keiner vollständig richtigen Lösung gekommen.
- Wie muss ich nach Bearbeitung von Frage 2 meine main anpassen? Ist mein bisheriger weg soweit richtig? Habe ich noch etwas vergessen?
- Wie kann ich das gewünschte Format für die Ausgabe (Punkt e) realisieren?
Ich würde mich sehr freuen, wenn mir jemand weiterhelfen könnte! 
| 1: |
| | 2: | #include <stdio.h>
| | 3: | #include <stdlib.h>
| | 4: | #include <math.h>
| | 5: | #include <time.h>
| | 6: | #define MAX_LAENGE 15
| | 7: | #define PRO_ZEILE 5
| | 8: |
| | 9: | //Funktionsdeklarationen
| | 10: | void clearBuffer();
| | 11: | int init(int*,int,int);
| | 12: | int faku(int*,int);
| | 13: | int potenz_2(int*,int);
| | 14: | int fibo(int*,int);
| | 15: | int collatz(int*,int);
| | 16: | void ausgabe(int*,int,int);
| | 17: |
| | 18: | //Funktionsdefinitionen
| | 19: |
| | 20: | void clearBuffer()
| | 21: | {
| | 22: | char Dummy;
| | 23: | do
| | 24: | {
| | 25: | scanf_s("%c", &Dummy);
| | 26: | } while (Dummy != '\n');
| | 27: |
| | 28: | return;
| | 29: | }
| | 30: |
| | 31: | //Initialisierung des Arrays durch Eingabe der gewuenschten Folge
| | 32: | int init(int* array, int initart, int dim)
| | 33: | {
| | 34: | int i=0;
| | 35: | int* folgenglied[MAX_LAENGE];
| | 36: | int groesse = MAX_LAENGE;
| | 37: | switch(initart)
| | 38: | {
| | 39: | case 0: printf("\nEnde."); return 0; break;
| | 40: | case 1: folgenglied = faku(array, groesse); return folgenglied; break;
| | 41: | case 2: folgenglied = potenz_2(array, groesse); return folgenglied; break;
| | 42: | case 3: folgenglied = fibo(array, groesse); return folgenglied; break;
| | 43: | case 4: folgenglied = collatz(array, groesse); return folgenglied; break;
| | 44: | default: printf("\nUngueltige Eingabe!"); return 0; break;
| | 45: | }
| | 46: | }
| | 47: |
| | 48: | //Fakultaet
| | 49: | int faku(int* n, int dim)
| | 50: | {
| | 51: | int i;
| | 52: | for (i=0; i<dim; i++)
| | 53: | {
| | 54: | if (i==0)
| | 55: | {
| | 56: | n[i] = 1;
| | 57: | }
| | 58: | else
| | 59: | {
| | 60: | n[i] = (i*faku(n, i-1));
| | 61: | }
| | 62: | return n[i];
| | 63: | printf("%d! = %d\n", i, n[i]);
| | 64: | }
| | 65: | }
| | 66: |
| | 67: | //2er-Potenzen
| | 68: | int potenz_2(int* n, int dim)
| | 69: | {
| | 70: | int i;
| | 71: | for (i=0; i<dim; i++)
| | 72: | {
| | 73: | if (i>0)
| | 74: | {
| | 75: | n[i] = (2*potenz_2(n, i-1));
| | 76: | }
| | 77: | else
| | 78: | {
| | 79: | n[i] = 1;
| | 80: | }
| | 81: | return n[i];
| | 82: | printf("2^(%d) = %d\n", i, n[i]);
| | 83: | }
| | 84: | }
| | 85: |
| | 86: | //Fibonacci-Folge
| | 87: | int fibo(int* n, int dim)
| | 88: | {
| | 89: | int i;
| | 90: | for (i=0; i<dim; i++)
| | 91: | {
| | 92: | if (i==0)
| | 93: | {
| | 94: | n[i] = 0;
| | 95: | }
| | 96: | else if (i>0 && i<3)
| | 97: | {
| | 98: | n[i] = 1;
| | 99: | }
| | 100: | else if (i>=3)
| | 101: | {
| | 102: | n[i] = fibo(n, i-2) + fibo(n, i-1);
| | 103: | }
| | 104: | return n[i];
| | 105: | }
| | 106: | }
| | 107: |
| | 108: | //Collatz-Folge
| | 109: | int collatz(int* n, int dim)
| | 110: | {
| | 111: | int i;
| | 112: | srand(time(NULL));
| | 113: | n[0] = rand() % 99 + 2; //Startwert als Zufallszahl zwischen 2 und 100 generieren
| | 114: |
| | 115: | for(i = 1; i < dim; i++)
| | 116: | {
| | 117: | if (n[i-1] % 2 == 0) //Zahl ist gerade
| | 118: | {
| | 119: | n[i] = collatz(n, (i-1)/2);
| | 120: | }
| | 121: | else //Zahl ist ungerade
| | 122: | {
| | 123: | n[i] = collatz(n, (3*(i-1)+1)/2);
| | 124: | }
| | 125: | return n[i];
| | 126: | }
| | 127: | }
| | 128: |
| | 129: | void ausgabe(int* array, int initart, int dim)
| | 130: | {
| | 131: | int i=0;
| | 132: |
| | 133: | if (initart>0 && initart<5)
| | 134: | {
| | 135: | printf("\n\nDie Folgenglieder Ihrer ausgewaehlten Folge sind:\n\n");
| | 136: | for (i=0; i<dim; i++)
| | 137: | {
| | 138: | printf("%d, ", array[i]);
| | 139: | }
| | 140: | }
| | 141: |
| | 142: | printf("\n\n\n");
| | 143: |
| | 144: | return;
| | 145: | }
| | 146: |
| | 147: | //Main-Programm
| | 148: | int main(void)
| | 149: | {
| | 150: | int i=0;
| | 151: | int arr[MAX_LAENGE];
| | 152: | int initarthier;
| | 153: | int folgenglieder[MAX_LAENGE];
| | 154: |
| | 155: | //Eingabe
| | 156: | printf("Array initialisieren und ausgeben\n");
| | 157: | printf("=================================\n");
| | 158: | printf("Fakultaet: 1\n");
| | 159: | printf("2-Potenzen: 2\n");
| | 160: | printf("Fibonacci-Folge: 3\n");
| | 161: | printf("Collatz-Folge: 4\n");
| | 162: | printf("Ende: 0\n");
| | 163: | printf("=================================\n");
| | 164: | printf("Ihre Wahl? ");
| | 165: | scanf("%d", &initarthier);
| | 166: | //clearBuffer();
| | 167: |
| | 168: | //Initialisierung und Berechnung der Folgenglieder
| | 169: | folgenglieder[i] = init(arr, initarthier, MAX_LAENGE);
| | 170: |
| | 171: | //Ausgabe
| | 172: | ausgabe(folgenglieder, initarthier, MAX_LAENGE);
| | 173: |
| | 174: | return 0;
| | 175: | } |
|
|
| |
|
Hallo Mija,
> Schreiben Sie ein C-Programm, in dem ein Array a von ganzen
> Zahlen erzeugt, auf eine bestimmte Weise initialisiert und
> dann formatiert auf dem Bildschirm ausgegeben wird. Der
> Benutzer soll im Dialog entscheiden, mit welchen Werten das
> Array initialisiert werden soll:
> a) mit Potenzen von 2: [mm]a_n = 2^n , n = 0, 1, ...[/mm]
> b) als
> Fibonacci-Folge: [mm]a_n = a_{n−1} + a_{n−2} , n = 0, 1, ..., a_0 = 0, a_1 = 1[/mm]
> usw.
> c) mit Fakultät von n: [mm]a_n = n!, a_0 = 1, a_1 = 1[/mm] usw.
> d) als Collatz-Folge:
> [mm][code]a_n[/mm] = a_(n−1)/2[/code], wenn
> a_(n−1) gerade,
> [mm][code]a_n[/mm] = (3a_(n−1) + 1)/2[/code]$, wenn
> a_(n−1) ungerade.
> Für den Startwert [mm]a_0[/mm] generieren Sie eine Zufallszahl
> zwischen 2 und 100.
>
> Der Dialog könnte so aussehen:
> Array initialisieren und ausgeben
> =================================
> Fakultaet: 1
> 2-Potenzen: 2
> Fibonacci-Folge: 3
> Collatz-Folge: 4
> Ende: 0
> =================================
> Ihre Wahl? 1
>
> Beachten Sie dabei folgende Hinweise bzw. Anforderungen an
> das Programm:
> a) Die Größe des Arrays ist 15 und soll als eine
> symbolische Konstante MAX_LAENGE definiert werden.
> b) Für die Arten der Initialisierung definieren Sie
> einen Aufzählungstyp initart.
> c) Die Initialisierung des Arrays soll in einer eigenen
> Funktion init() passieren.
> Diese Funktion soll zwei Parameter erhalten: das Array und
> die Art der Initialisierung. In der Funktion benutzen Sie
> die switch()-Anweisung, in der die Initialisierungsart
> ausgewertet wird.
> d) Für die Berechnung der Folgenglieder schreiben Sie
> rekursive Funktionen [mm][code]potenz_2()[/code],[/mm] fibo(),
> faku() und collatz().
> e) Schreiben Sie eine Funktion ausgabe(), in der das Array
> auf dem Bildschirm ausgegeben wird. Für die Ausgabe
> definieren Sie eine zweite symbolische Konstante
> PRO_ZEILE, die angibt, wieviel Arrayelemente in einer Zeile
> ausgegeben werden soll. Setzen Sie diese Konstante auf 5
> und benutzen Sie diese Konstante für die Ausgabe. Geben
> Sie die Arrayelemente mit der Breite 10 aus.
> Hallo, ich habe ein paar Fragen zu der obenstehenden
> Aufgabe:
>
> - sind meine Funktionen zu den einzelnen Folgen soweit
> richtig?
> - Wie muss ich die Datentypen in der Funktion init() und
> den Rückgabetyp in den einzelnen Folgen-Funktionen
> anpassen? Ich habe schon etwas herumexperimentiert, bin
> aber zu noch keiner vollständig richtigen Lösung
> gekommen.
> - Wie muss ich nach Bearbeitung von Frage 2 meine main
> anpassen? Ist mein bisheriger weg soweit richtig? Habe ich
> noch etwas vergessen?
> - Wie kann ich das gewünschte Format für die Ausgabe
> (Punkt e) realisieren?
>
Zunächst sind die Warnings und Errors im Programm zu beseitigen.
Ich habe Dein Programm Folgen.c genannt.
Dies liefer mir dann beim compilieren folgende Warnings und Errors:
Folgen.c: In function ‘init’:
Folgen.c:41:22: error: incompatible types when assigning to type ‘int *[15]’ from type ‘int’
Folgen.c:41:46: warning: return makes integer from pointer without a cast
Folgen.c:41:46: warning: function returns address of local variable
Folgen.c:42:22: error: incompatible types when assigning to type ‘int *[15]’ from type ‘int’
Folgen.c:42:50: warning: return makes integer from pointer without a cast
Folgen.c:42:50: warning: function returns address of local variable
Folgen.c:43:22: error: incompatible types when assigning to type ‘int *[15]’ from type ‘int’
Folgen.c:43:46: warning: return makes integer from pointer without a cast
Folgen.c:43:46: warning: function returns address of local variable
Folgen.c:44:22: error: incompatible types when assigning to type ‘int *[15]’ from type ‘int’
Folgen.c:44:49: warning: return makes integer from pointer without a cast
Folgen.c:44:49: warning: function returns address of local variable
Folgen.c:34:6: warning: unused variable ‘i’
Folgen.c: In function ‘collatz’:
Folgen.c:128:2: warning: control reaches end of non-void function
Folgen.c: In function ‘fibo’:
Folgen.c:107:2: warning: control reaches end of non-void function
Folgen.c: In function [mm] ‘potenz_2’:
[/mm]
Folgen.c:85:1: warning: control reaches end of non-void function
Folgen.c: In function ‘faku’:
Folgen.c:66:1: warning: control reaches end of non-void function
> Ich würde mich sehr freuen, wenn mir jemand weiterhelfen
> könnte!
In den Funktionen faku(), [mm] potenz_2(), [/mm] fibo() und collatz() sollen
doch nur die Folgenglieder berechnet werden, nicht das Array
gefüllt werden.
Gruss
MathePower
|
|
|
| |
|
| Status: |
(Frage) beantwortet | | Datum: | 20:17 Di 02.04.2013 | | Autor: | Mija |
Kann ich die Aufgabe nicht auch lösen, wenn ich das Array schon in den Folgen-Funktionen fülle?
Wo kann ich das denn sonst füllen? In der Ausgabe?
Hm, ich komme in Sachen Fehler- und Warnungsbeseitigung leider gerade garnicht weiter..
|
|
|
| |
|
Hallo Mija,
> Kann ich die Aufgabe nicht auch lösen, wenn ich das Array
> schon in den Folgen-Funktionen fülle?
Theoretisch kannst Du das auch tun,
erfüllt aber die Forderungen an das Programm nicht.
> Wo kann ich das denn sonst füllen? In der Ausgabe?
>
In der Funktion init();
> Hm, ich komme in Sachen Fehler- und Warnungsbeseitigung
> leider gerade garnicht weiter..
Dann poste doch die Fehler-und Warnungsmeldungen,
wo Du nicht weiter kommst.
Gruss
MathePower
|
|
|
| |
|
| Status: |
(Frage) beantwortet | | Datum: | 11:54 Mi 03.04.2013 | | Autor: | Mija |
Hallo, ich habe momentan folgende Fehlermeldungen und Warnungen, bei denen ich nicht weiter komme bzw. wenn ich die versuche zu korrigieren, folgen immer wieder weitere Fehlermeldungen/Warnungen:
12 IntelliSense: Ein Wert vom Typ ""int"" kann keiner Entität vom Typ ""int *"" zugewiesen werden. 45
13 IntelliSense: Ein Wert vom Typ ""int"" kann keiner Entität vom Typ ""int *"" zugewiesen werden. 46
14 IntelliSense: Ein Wert vom Typ ""int"" kann keiner Entität vom Typ ""int *"" zugewiesen werden. 47
15 IntelliSense: Ein Wert vom Typ ""int"" kann keiner Entität vom Typ ""int *"" zugewiesen werden. 48
16 IntelliSense: Ein Wert vom Typ ""int *"" kann keiner Entität vom Typ ""int"" zugewiesen werden. 178
Warnung 1 warning C4047: '=': Anzahl der Dereferenzierungen bei 'int *' und 'int' unterschiedlich 45
Warnung 2 warning C4047: '=': Anzahl der Dereferenzierungen bei 'int *' und 'int' unterschiedlich 46
Warnung 3 warning C4047: '=': Anzahl der Dereferenzierungen bei 'int *' und 'int' unterschiedlich 47
Warnung 4 warning C4047: '=': Anzahl der Dereferenzierungen bei 'int *' und 'int' unterschiedlich 48
Warnung 5 warning C4244: 'Funktion': Konvertierung von [mm] 'time_t' [/mm] in 'unsigned int', möglicher Datenverlust 120
Warnung 7 warning C4047: '=': Anzahl der Dereferenzierungen bei 'int' und 'int *' unterschiedlich 178
Warnung 8 warning C4715: "faku": Nicht alle Steuerelementpfade geben einen Wert zurück. 71
Warnung 9 warning C4715: [mm] "potenz_2": [/mm] Nicht alle Steuerelementpfade geben einen Wert zurück. 91
Warnung 10 warning C4715: "fibo": Nicht alle Steuerelementpfade geben einen Wert zurück. 113
Warnung 11 warning C4715: "collatz": Nicht alle Steuerelementpfade geben einen Wert zurück. 135
Hier ist mein aktueller Code:
| 1: |
| | 2: | #include <stdio.h>
| | 3: | #include <stdlib.h>
| | 4: | #include <math.h>
| | 5: | #include <time.h>
| | 6: | #define MAX_LAENGE 15
| | 7: | #define PRO_ZEILE 5
| | 8: |
| | 9: | //Funktionsdeklarationen
| | 10: | void clearBuffer();
| | 11: | int* init(int*,int,int);
| | 12: | int faku(int*,int);
| | 13: | int potenz_2(int*,int);
| | 14: | int fibo(int*,int);
| | 15: | int collatz(int*,int);
| | 16: | void ausgabe(int*,int,int);
| | 17: |
| | 18: | //Funktionsdefinitionen
| | 19: |
| | 20: | void clearBuffer()
| | 21: | {
| | 22: | char Dummy;
| | 23: | do
| | 24: | {
| | 25: | scanf_s("%c", &Dummy);
| | 26: | } while (Dummy != '\n');
| | 27: |
| | 28: | return;
| | 29: | }
| | 30: |
| | 31: | //Initialisierung des Arrays durch Eingabe der gewuenschten Folge
| | 32: | int* init(int* array, int initart, int dim)
| | 33: | {
| | 34: | int i=0;
| | 35: | int* folgenglied;
| | 36: | int groesse = MAX_LAENGE;
| | 37: | switch(initart)
| | 38: | {
| | 39: | case 0: printf("\nEnde."); return 0; break;
| | 40: | case 1: folgenglied = faku(array, groesse); return folgenglied; break;
| | 41: | case 2: folgenglied = potenz_2(array, groesse); return folgenglied; break;
| | 42: | case 3: folgenglied = fibo(array, groesse); return folgenglied; break;
| | 43: | case 4: folgenglied = collatz(array, groesse); return folgenglied; break;
| | 44: | default: printf("\nUngueltige Eingabe!"); return 0; break;
| | 45: | }
| | 46: | }
| | 47: |
| | 48: | //Fakultaet
| | 49: | int faku(int* n, int dim)
| | 50: | {
| | 51: | int i;
| | 52: | for (i=0; i<dim; i++)
| | 53: | {
| | 54: | if (i==0)
| | 55: | {
| | 56: | n[i] = 1;
| | 57: | return n[i];
| | 58: | }
| | 59: | else
| | 60: | {
| | 61: | n[i] = (i*faku(n, i-1));
| | 62: | return n[i];
| | 63: | }
| | 64: | printf("%d! = %d\n", i, n[i]);
| | 65: | }
| | 66: | }
| | 67: |
| | 68: | //2er-Potenzen
| | 69: | int potenz_2(int* n, int dim)
| | 70: | {
| | 71: | int i;
| | 72: | for (i=0; i<dim; i++)
| | 73: | {
| | 74: | if (i>0)
| | 75: | {
| | 76: | n[i] = (2*potenz_2(n, i-1));
| | 77: | return n[i];
| | 78: | }
| | 79: | else
| | 80: | {
| | 81: | n[i] = 1;
| | 82: | return n[i];
| | 83: | }
| | 84: | printf("2^(%d) = %d\n", i, n[i]);
| | 85: | }
| | 86: | }
| | 87: |
| | 88: | //Fibonacci-Folge
| | 89: | int fibo(int* n, int dim)
| | 90: | {
| | 91: | int i;
| | 92: | for (i=0; i<dim; i++)
| | 93: | {
| | 94: | if (i==0)
| | 95: | {
| | 96: | n[i] = 0;
| | 97: | }
| | 98: | else if (i>0 && i<3)
| | 99: | {
| | 100: | n[i] = 1;
| | 101: | }
| | 102: | else if (i>=3)
| | 103: | {
| | 104: | n[i] = fibo(n, i-2) + fibo(n, i-1);
| | 105: | }
| | 106: | return n[i];
| | 107: | }
| | 108: | }
| | 109: |
| | 110: |
| | 111: | //Collatz-Folge
| | 112: | int collatz(int* n, int dim)
| | 113: | {
| | 114: | int i;
| | 115: | srand(time(NULL));
| | 116: | n[0] = rand() % 99 + 2; //Startwert als Zufallszahl zwischen 2 und 100 generieren
| | 117: |
| | 118: | for(i = 1; i < dim; i++)
| | 119: | {
| | 120: | if (n[i-1] % 2 == 0) //Zahl ist gerade
| | 121: | {
| | 122: | n[i] = collatz(n, (i-1)/2);
| | 123: | }
| | 124: | else //Zahl ist ungerade
| | 125: | {
| | 126: | n[i] = collatz(n, (3*(i-1)+1)/2);
| | 127: | }
| | 128: | return n[i];
| | 129: | }
| | 130: | }
| | 131: |
| | 132: |
| | 133: | void ausgabe(int* array, int initart, int dim)
| | 134: | {
| | 135: | int i=0;
| | 136: |
| | 137: | if (initart>0 && initart<5)
| | 138: | {
| | 139: | printf("\n\nDie Folgenglieder Ihrer ausgewaehlten Folge sind:\n\n");
| | 140: | for (i=0; i<dim; i++)
| | 141: | {
| | 142: | printf("%d, ", array[i]);
| | 143: | }
| | 144: | }
| | 145: |
| | 146: | printf("\n\n\n");
| | 147: |
| | 148: | return;
| | 149: | }
| | 150: |
| | 151: | //Main-Programm
| | 152: | int main(void)
| | 153: | {
| | 154: | int i=0;
| | 155: | int arr[MAX_LAENGE];
| | 156: | int initarthier;
| | 157: | int folgenglieder[MAX_LAENGE];
| | 158: |
| | 159: | //Eingabe
| | 160: | printf("Array initialisieren und ausgeben\n");
| | 161: | printf("=================================\n");
| | 162: | printf("Fakultaet: 1\n");
| | 163: | printf("2-Potenzen: 2\n");
| | 164: | printf("Fibonacci-Folge: 3\n");
| | 165: | printf("Collatz-Folge: 4\n");
| | 166: | printf("Ende: 0\n");
| | 167: | printf("=================================\n");
| | 168: | printf("Ihre Wahl? ");
| | 169: | scanf_s("%d", &initarthier);
| | 170: | //clearBuffer();
| | 171: |
| | 172: | //Initialisierung und Berechnung der Folgenglieder
| | 173: | folgenglieder[i] = init(arr, initarthier, MAX_LAENGE);
| | 174: |
| | 175: | //Ausgabe
| | 176: | ausgabe(folgenglieder, initarthier, MAX_LAENGE);
| | 177: |
| | 178: | return 0;
| | 179: | } |
|
|
|
| |
|
| Status: |
(Frage) beantwortet | | Datum: | 14:42 Mi 03.04.2013 | | Autor: | Mija |
Hallo, die Fehlersuche hat sich nun erledigt. Ich habe es etwas gelöst.
Nun habe ich noch eine Frage zur Formatierung der Ausgabe:
Wie kann ich das wie in der Aufgabenstellung beschreieben lösen? Also das 5 Folgenglieder pro Zeile mit einer Breite von jeweils 10 ausgegeben wird? Ich habe leider noch nichts hilfreiches gefunden.
Ich würde mich sehr freuen, wenn mir da noch jemand weiterhelfen könnte! Danke!
|
|
|
| |
|
Hallo Mija,
> Hallo, die Fehlersuche hat sich nun erledigt. Ich habe es
> etwas gelöst.
>
> Nun habe ich noch eine Frage zur Formatierung der Ausgabe:
> Wie kann ich das wie in der Aufgabenstellung beschreieben
> lösen? Also das 5 Folgenglieder pro Zeile mit einer Breite
> von jeweils 10 ausgegeben wird? Ich habe leider noch nichts
> hilfreiches gefunden.
>
Gebe die Elemente einer Zeile mit printf("%10d",array[i])" aus.
Am Ende jeder Zeile ist ein printf("\n") auszugeben.
> Ich würde mich sehr freuen, wenn mir da noch jemand
> weiterhelfen könnte! Danke!
Gruss
MathePower
|
|
|
| |
|
| Status: |
(Frage) beantwortet | | Datum: | 21:15 Mi 03.04.2013 | | Autor: | Mija |
Hallo Mathepower,
also meine Funktion ausgabe() sieht nun so aus:
| 1: |
| | 2: | void ausgabe(int* array, int initart, int dim)
| | 3: | {
| | 4: | int i=0, k=0;
| | 5: |
| | 6: | if (initart>0 && initart<5)
| | 7: | {
| | 8: | printf("\n\nDie Folgenglieder Ihrer ausgewaehlten Folge sind:\n\n");
| | 9: | for (k=0; k<dim/PRO_ZEILE; k++)
| | 10: | {
| | 11: | for (i=0; i<PRO_ZEILE; i++)
| | 12: | {
| | 13: | printf("%10d", array[i]);
| | 14: | }
| | 15: | printf("\n");
| | 16: | }
| | 17: | }
| | 18: |
| | 19: | printf("\n\n\n");
| | 20: | return;
| | 21: | } |
Allerdings bekomme ich nun in jeder Zeile immer dieselben Folgenelemente ausgegeben (denn die for-Schleife in der for-Schleife fängt ja immer wieder von 0 an zu zählen).
Wie kann ich das ändern?
|
|
|
| |
|
Hi!
| 1: | > void ausgabe(int* array, int initart, int dim)
| | 2: | > {
| | 3: | > int i=0, k=0;
| | 4: | >
| | 5: | > if (initart>0 && initart<5)
| | 6: | > {
| | 7: | > [mm] printf("\n\nDie[/mm] Folgenglieder Ihrer ausgewaehlten Folge
| | 8: | > [mm]sind:\n\n");[/mm]
| | 9: | > for (k=0; k<dim/PRO_ZEILE; k++)
| | 10: | > {
| | 11: | > for (i=0; i<PRO_ZEILE; i++)
| | 12: | > {
| | 13: | > printf("%10d", array[i]);[/i]
| | 14: | > [i] }[/i]
| | 15: | > [i] [mm] printf("\n");[/mm][/i]
| | 16: | > [i] }[/i]
| | 17: | > [i] }[/i]
| | 18: | > [i] [/i]
| | 19: | > [i][mm] printf("\n\n\n");[/mm][/i]
| | 20: | > [i] return;[/i]
| | 21: | > [i] }[/i] |
So wie ich das jetzt verstanden habe, sollst du einfach 3 Zeilen mit jeweils 5 Folgengliedern ausgeben? MAX_LAENGE ist also die Maximalzahl an Folgengliedern (hier 15 Stück), die ausgegeben werden sollen. Verbessere mich wenn ich falsch liege.
Du brauchst auf jeden Fall nur eine for-Schleife. Diese soll von i=1 bis i<=MAX_LAENGE laufen.
Innerhalb der for-Schleife gibst du jedes Element des Arrays aus. Allerdings an der Stelle i-1, da wir in der for-Schleife bei 1 beginnen.
Danach brauchst du eine if-Bedingung, in der du mit dem Modulo Operator prüfst, ob i%5 == 0 ist. Ist dies der Fall, so machst du einen Zeilenumbruch.
Das wars dann auch schon.
Valerie
|
|
|
|
