✔ array in string

K

keydo

Grünschnabel
huhu,
mein kleines Programm macht erstmal folgendes :> es ließt eine Zahl bestehend aus den ziffern 0-9 von der Tastatur ein und gibt es auf der Console wieder in form der matrix aus. das klappt erstmal.

Nun soll ich ich einen neuen Datentyp erstellen der die 5 Pixelzeilen der Zeile einer Zahlendarstellung als Zeichenkette aufnehmen kann. Die einzelnen Pixel bestehen halt aus ' ' oder einem *chen ^^.

die zahl 12 liefere dann halt folgende 5 zeichenketten:

Code: 
..*.|.**.   // Zeichenkette 1
.**.|*..*   // Zeichenkette 2
*.*.|..*.   // Zeichenkette 3
..*.|.*..   // Zeichenkette 4
..*.|****   // Zeichenkette 5

Die leeren Felder sind immoment durch einen "." ersetzt.

Mein Problem ist, ich bekomme die einzelnen Zeilen nicht in den jeweiligen. Also Zeile 0 in den strg 0, Zeile 1 in strg1 ... und so wieter ... -.-

irgendwie stehe ich auf der Leitung... hat wer einen guten Einfall :> ?

Code: 
# include <stdio.h>
# include <stdlib.h>

# define WAIT for(;;)

char dots[11][5][4] = {
                            {
                                {' ', '*', '*', ' '},
                                {'*', ' ', ' ', '*'},
                                {'*', ' ', ' ', '*'},
                                {'*', ' ', ' ', '*'},
                                {' ', '*', '*', ' '}
                            },
                            {
                                {' ', ' ', '*', ' '},
                                {' ', '*', '*', ' '},
                                {'*', ' ', '*', ' '},
                                {' ', ' ', '*', ' '},
                                {' ', ' ', '*', ' '}
                            },
                            {
                                {' ', '*', '*', ' '},
                                {'*', ' ', ' ', '*'},
                                {' ', ' ', '*', ' '},
                                {' ', '*', ' ', ' '},
                                {'*', '*', '*', '*'}
                            },
                            {
                                {'*', '*', '*', ' '},
                                {' ', ' ', ' ', '*'},
                                {' ', '*', '*', ' '},
                                {' ', ' ', ' ', '*'},
                                {'*', '*', '*', ' '}
                            },
                            {
                                {' ', ' ', '*', ' '},
                                {' ', '*', ' ', ' '},
                                {'*', ' ', '*', ' '},
                                {'*', '*', '*', '*'},
                                {' ', ' ', '*', ' '}
                            },
                            {
                                {'*', '*', '*', '*'},
                                {'*', ' ', ' ', ' '},
                                {'*', '*', '*', ' '},
                                {' ', ' ', ' ', '*'},
                                {'*', '*', '*', ' '}
                            },
                            {
                                {' ', ' ', '*', '*'},
                                {' ', '*', ' ', ' '},
                                {' ', '*', '*', '*'},
                                {' ', '*', ' ', '*'},
                                {' ', '*', '*', '*'}
                            },
                            {
                                {'*', '*', '*', '*'},
                                {' ', ' ', ' ', '*'},
                                {' ', ' ', '*', ' '},
                                {' ', '*', ' ', ' '},
                                {' ', '*', ' ', ' '}
                            },
                            {
                                {' ', '*', '*', ' '},
                                {'*', ' ', ' ', '*'},
                                {' ', '*', '*', ' '},
                                {'*', ' ', ' ', '*'},
                                {' ', '*', '*', ' '}
                            },
                            {
                                {' ', '*', '*', '*'},
                                {' ', '*', ' ', '*'},
                                {' ', '*', '*', '*'},
                                {' ', ' ', ' ', '*'},
                                {' ', '*', '*', ' '}
                            },
{
                                {' ', ' ', ' ', ' '},
                                {' ', ' ', ' ', ' '},
                                {'*', '*', '*', '*'},
                                {' ', ' ', ' ', ' '},
                                {' ', ' ', ' ', ' '}
                            }
                        };

main()
    {
    unsigned char zahl[20];
    int zeile;
    int spalte;
    int index;
   
    printf( "Bitte Zahl eingeben: ");
    scanf( "%s", zahl);
    printf( "\n");
   
    for( zeile = 0; zeile < 5; zeile = zeile + 1)
        {
        for( index = 0; zahl[index] != 0; index = index + 1)
            {
            for( spalte = 0; spalte < 4; spalte = spalte + 1)
                 // hier entsteht gerade die Abfrage,
                 // WENN zahl[index] das "-", dann  springe zu  
                 // dots[11][zeile][spalte]
                 printf( "%c", dots[zahl[index]-'0'][zeile][spalte]);
               
            printf( "  ");
            }
        printf( "\n");
        }
    WAIT;
    }
 
Hi.
keydo hat gesagt.:
Mein Problem ist, ich bekomme die einzelnen Zeilen nicht in den jeweiligen.
Zum Vergrößern anklicken....
Also ich weiß nicht was damit meinst, aber ich würde die Ziffern etwas anders speichern:
C: 
const char dots[3][5][5] = {
  {
    " ** ",
    "*  *",
    "*  *",
    "*  *",
    " ** "
  },
  {
    "  * ",
    " ** ",
    "* * ",
    "  * ",
    "  * "
  },
  /* usw. */
};
Der Vorteil ist man kann auf einen Blick sehen was gespeichert ist und die Ausgabe ist auch sehr einfach:
C: 
for( index = 0; zahl[index] != 0; index = index + 1)
	{
	  printf( "%s  ", dots[zahl[index]-'0'][zeile]);               
	}
Gruß
 
Hallo, das sieht übersichtlicher aus, das stimmt 8) ...

Immoment habe ich ein 3d - Array, welches die ganzen Zahlen beinhaltet.

Nun soll folgendes passieren. Jede Zeile 0-4 soll in einen String gespeichert werden.
Wir gehen davon aus, der Benutzer hat eine 0 eingegeben so sehe der Inhalt wie folgt aus:

Code: 
string strg0,strg1,strg2,strg3,strg4;


" ** "     // <- Inhalt von strg0
"*  *"     // <- Inhalt von strg1
"*  *"     // <- Inhalt von strg2
"*  *"     // <- Inhalt von strg3
" ** "     // <- Inhalt von strg4

Gibt nun der Benutzer die zahlen 10 ein soll der Inhalt anders aussehen:
Code: 
"  * " " ** "    // <- Inhalt von strg0
" ** " "*  *"    // <- Inhalt von strg1
"* * " "*  *"    // <- Inhalt von strg2
"  * " "*  *"    // <- Inhalt von strg3
"  * " " ** "    // <- Inhalt von strg4

Hast du eine Idee ? 8)
 
Hi.

Du könntest einfach die Funktion strcat statt printf verwenden:
C: 
char strg0[100] = "", strg1[100] = "", /* usw. */ ;

strcat( strg0, dots[zahl[index]-'0'][0]); strcat(strg0, "  ");
strcat( strg1, dots[zahl[index]-'0'][1]); strcat(strg1, "  ");
Gruß
 
oh danke, klingt gut versuch ich gleich einmal umzusetzen.

gibt es eine Variante wo ich einen Zähler für die variable string mitlaufen lassen kann? Das wenn der Index vom array in die Zeile 2 springt, nun auch die Zeile 2 in strg2 gespeichert wird?

Ich bin erstmal essen und überleg in Ruhe ^^
 
Mein Problem mit dem Array war gewesen.

Code: 
#define MAX_ZEILE 5
#define MAX_SPALTE [200]

char testarray[MAX_ZEILE][SPALTE];

//...

testarray[zeile][spalte] =  [zahl[index]-'0'][zeile][spalte]);

//...


Das er halt mir von den eingegeben Zahlen nur die letzte Zahl gespeichert hat.

Ich vermute er wird dann, sobald sich die Zahl geändert hat, die Zeile und Spalte auf 0 gesetzt haben und die vorrigen Ziffern somit überschreiben haben.

Ist den die Lösung ein 3d-Array in ein 2D-Array übersichtlicher als die ein 3D-Array in die jeweiligen Strings zu packen?

Wenn ich eine komplette Zeile. unabhängig von der anzahl der Ziffern in die entsprechenden Zeile des 2D array bekomme würde ich das auch gut finde. Das mit den strings war nur meine Alternative.
 
Momentan wird das aktuelle elemente aus dots dem array testarray hinzugefügt.

Code: 
// ...
testarray[zeile][spalte_i] = dots[zahl[index]-'0'][zeile][spalte]);

//... sobald sich die Zeile ändert

spalte_i = 0;


Nun habe ich ein Problem bei der Ausgabe des 2D-Arrays, Es funktioniert gut, sofern ich in meiner Schleife sagen kann welches das letzte elemt des arrays ist.

Code: 
						for(int t = 0; t < 8; t++) 
						{
							for(int s = 0; s < 10; s++)
							{
								cout << testarray[t][s];
							}
							cout << endl;
						}

In diesem Fall geht er bis zur Spalte 10.
Wie kann ich eine Scleife machen die nur bis zur letzten eingegeben zahl ausließt?

-> Ich würde erstmal, sofern eine Zeile bis zum Ende kopiert wurde, ein '\0' anhängen.
-> Dann setze ich die spalte_i wider auf null, die Zeile erhöht er automatisch.

nun wie bringe ich der for schleife bei, nur bis zum '\0' Zeichen zu lesen und dann für die Zeile aufzuhören?
 
keydo hat gesagt.:
In diesem Fall geht er bis zur Spalte 10.
Wie kann ich eine Scleife machen die nur bis zur letzten eingegeben zahl ausließt?

-> Ich würde erstmal, sofern eine Zeile bis zum Ende kopiert wurde, ein '\0' anhängen.
-> Dann setze ich die spalte_i wider auf null, die Zeile erhöht er automatisch.

nun wie bringe ich der for schleife bei, nur bis zum '\0' Zeichen zu lesen und dann für die Zeile aufzuhören?
Zum Vergrößern anklicken....
Wenn das char Array ordentlich mit \0 terminiert ist, brauchst du keine Schleife. Du kannst den String dann einfach ausgeben.

Gruß
 
Um antworten zu können musst du eingeloggt sein.

Neue Beiträge

Zurück