[C] Hilfe beim Programmieren und Verständnis-Fragen zu Code-Beispielen ...

AW: [C] Hilfe beim Programmieren und Verständnis-Fragen zu Code-Beispielen ...

Ich musste deinen Code minimalst anpassen, damit das Ganze kompilierbar ist. Semantisch sollte sich jedoch nichts geändert haben. Auf jeden Fall gibt's 2 Probleme: Erstens, der Code gibt für jedes x-beliebige Wort "gefunden" aus, und zweitens, bei tatsächlich existierenden Wörtern stimmen die Koordinaten nicht (außer bei SECURITY; da stimmt witzigerweise alles).
Code:
int checkFind(int x, int y, int xDir, int yDir, char *searchString, int matrix[ROWS][COLUMNS]) { 
    int found = 0; // solange true, bis der erste (vergleichs-)fehler auftritt
    int step = 2; // beginnend nach dem 2. buchstaben - der erste war der hauptfund, der 2. war der "richtungsfund"
    int searchX = 0, searchY = 0;
    while (*(searchString+step) != '\0') {
        searchX = x+(xDir*step);
        searchY = y+(yDir*step);
        if (searchX >= ROWS || searchY >= COLUMNS) { // wurde der rand der matrix erreicht, bevor das ganze wort gefunden wurde - abbruch
            found = 1;
            break; // raus aus der while
        }
        if (*(searchString+step) != matrix[searchX][searchY]) { // stimmt der 2. buchstabe des suchstrings NICHT mit dem nächsten (in entsprechender richtung liegenden) feld-buchstaben der matrix überein -> abbrechen
            found = 1;
            break; // raus aus der while
        }
        step++; // is ja kein c++ oder? jedenfalls gehts dann nen buchstaben weiter, wenn bisher alles passt
    }
    return found;
}

void searchMatrix(char *searchString, int matrix[ROWS][COLUMNS]) { //  <- warum hast du da eigentlich sone seltsame variante? ^^
    int x=0, y=0, i=0;
    
    int max = 2; // wieviele suchrichtungen soll es geben? atm geh ich mal von nur 2en aus (vorwärts und runter)
    
    for (y=0; y<COLUMNS; y++) { // <- erst spalten
        for (x=0; x<ROWS; x++) { // dann zeilen ^^ - zumindest find ichs persönlich so leichter nachvollziehbar (von der reihenfolge der abarbeitung her)
            if (*searchString==matrix[x][y]) { // erster buchstabe des suchstrings entspricht dem aktuell betrachteten zeichen in der matrix?
                for (i=0; i<max; i++) {
                    switch (i) { // für jede suchrichtung die fälle bearbeiten - leicht erweiterbar
                        case 0: { // suche nach rechts weiter
                            if (checkFind(x, y, 1, 0, searchString, matrix)) { // überprüfe den fund, ned das es nur zufällig der buchstabe war und der rest nich passt
                                printf("found string '%s' at position %d|%d", searchString, x+1, y+1);
                                return; // und raus hier ^^
                            }
                            break;
                        }
                        case 1: { // suche nach unten weiter
                            if (checkFind(x, y, 0, 1, searchString, matrix)) {  // überprüfe den fund, ned das es nur zufällig der buchstabe war und  der rest nich passt
                                printf("found string '%s' at position %d|%d", searchString, x+1, y+1);
                                return; // und raus hier ^^
                            }
                            break;
                        }
                    // hier könnte man jetz ganz easy weitere suchrichtungen anfügen...
                    }
                }
            }
        }
    }
}
Vielen Dank, in jedem Fall, für die Mühe! Ich weiß deine Hilfe echt zu schätzen, aber ganz glücklich bin ich mit der Lösung trotzdem nicht. Auf der einen Seite, weil ich nicht selber darauf gekommen bin und auf der anderen Seite, weil ich das vermutlich selber auch nicht nachbauen könnte.

Wenn es dir also nichts ausmacht, würde ich gerne versuchen, mit deiner Hilfe den Weg, den ich im EDIT in meinem vorigen Posting beschrieben habe, weiterzugehen und zu schauen, ob das auch irgendwann zu einem funktionierenden Code führt. :)
 
Zuletzt bearbeitet:
AW: [C] Hilfe beim Programmieren und Verständnis-Fragen zu Code-Beispielen ...

sicher sicher, kann ich nur zu gut verstehen ^^ bringt ja nix, wenn man "hirnlos" kopiert, man muss es ja auch verstehen und anwenden können. und da hilft selber tüfteln und fummeln immer viel.

ps: hab ich wohl unbewusst auf security optimiert wa? xD
 
AW: [C] Hilfe beim Programmieren und Verständnis-Fragen zu Code-Beispielen ...

^^ LOL, ja, SECURITY hat er bei meinen Varianten auch immer gefunden, aber sonst nichts ... :fresse:
-----------------------

Bei meinem jetzigen Ansatz verzichte ich erstmal auf zu viel selbstgeschriebenen Code zu verzichten und versuche, die zentralen Dinge durch fertige Funktionen zu erledigen. Erst, wenn so alles funktioniert, möchte ich diese nach und nach durch selbstgeschriebenen Code ersetzen.
Code:
void searchMatrix(char *string, int matrix[ROWS][COLUMNS]) {
    int i=0, j=0, k=0, l=0, length=0;
    char searchString[13], [COLOR=royalblue][B]*coordinate[/B];
    
    while (*(string+length)!='\0') {
        length++;
    }

    while (i<ROWS) { [COLOR=seagreen]/* durchsuche jedes Feld, beginnend beim ersten, horizontal*/        for (j=0; j<COLUMNS; j++) {
            searchString[j]=matrix[i][j]; 
        }
        if ([COLOR=darkorchid][B]strstr[/B](searchString, string) != NULL) {
            [COLOR=royalblue][B]coordinate=strstr(searchString, string);[/B]            printf("%s found horizontally! %d %d\n", string, i+1, [COLOR=royalblue][B](*coordinate)+1[/B]); [COLOR=seagreen]/* wenn Wort gefunden, ... */            break; [COLOR=seagreen]/* ... verlasse Schleife */        } else { [COLOR=seagreen]/* sonst ... */            i++; [COLOR=seagreen]/* springe in die nächste Zeile und suche wieder */            if (i==12) { [COLOR=seagreen]/* wenn alle Zeile erfolglos durchsucht wurden, ... */                while (k<COLUMNS) { [COLOR=seagreen]/* selbes Spiel mit den Spalten */                    for (l=0; l<ROWS; l++) {
                        searchString[l]=matrix[l][k];
                    }
                    if ([B][COLOR=darkorchid]strstr[/B](searchString, string) != NULL) {
                        [COLOR=royalblue][B]coordinate=strstr(searchString, string);[/B]                        printf("%s found vertically! %d %d\n", string, [COLOR=royalblue][B](*coordinate)+1[/B], k+1));
                        break;
                    } else { [COLOR=seagreen]/* wurde Wort auch in Spalten nicht gefunden, ... */                        k++;
                        if (k==12) {
                            printf("%s not found!\n", string); [COLOR=seagreen]/* existiert es nicht in der Matrix */                            break;
                        }
                    }
                }
            }
        }
    }
}
Die Suche funktioniert und stimmt bereits für sämtliche Zeilen und Spalten der Matrix (:daumen:), nur leider gibt er noch völlig falsche Spalten-Koordinaten bei horizontal und falsche Zeile-Koordinaten bei vertikal gefundenen Wörtern aus. :huh:

Das liegt jetzt wohl an einer falschen Anwendung des Pointers von strstr, der ja nach meinem Verständnis auf den Feldindex des ersten Buchstaben des gefundenen Wortes zeigt. Kennst du dich mit der genauen Arbeitsweise von strstr aus? Wie genau lasse ich den Speicherinhalt des Pointers bei gefundenen Wörtern als die jeweilige Koordinate ausgeben?

[EDIT]
Ich habe mir jetzt testweise mal eine Hilfsfunktion zur Ermittlung der jeweiligen Zeilenkoordinate bei Spalten-Wörtern bzw. der jeweiligen Spaltenkoordinate bei Zeilen-Wörtern geschrieben, allerdings liefert die immer -52 und ich komme nicht darauf, warum ...
Code:
int checkPosition(char *string1, char *string2) {
    int i=0, result=0, length=0, count=0;

    while (*(string2+length)!='\0') { /* ermittle die Länge des zu suchenden Wortes */
        length++;
    }

    while (*(string1+i)!='\0' || *(string2+i)!='\0') { 
        if (*(string2+i)==*(string1+i)) { [COLOR=seagreen]/* vergleiche beide char strings buchstabenweise */            count++; [COLOR=seagreen]/* erhöhe Zähler bei Übereinstimmung */            if (count==length) { [COLOR=seagreen]/* sobald Zähler der Länge entspricht, ... */                [COLOR=royalblue][B]result=*(string2+(i-(length-1)));[/B] [COLOR=seagreen]/* ... berechne die Position des ersten Buchstabens des Suchwortes im Such-Feld */                return result;
            }
        }
        i++;
    }
}
^^ So müsste ich doch eigentlich die gewünschte Koordinate bekommen, oder?

Hier noch der derzeitig gesamte Code:
Code:
#include <stdio.h>
#include <stdlib.h>
#include <string.h>

#define ROWS 12
#define COLUMNS 12

int checkLength(char *string) {
    int length=0;

    while (*(string+length)!='\0') {
        length++;
    }

    return length;
}

int checkPosition(char *string1, char *string2) {
    int i=0, result=0, length=checkLength(string2), count=0;

    while (*(string1+i)!='\0' || *(string2+i)!='\0') {
        if (*(string2+i)==*(string1+i)) {
            count++;
            if (count==length) {
                result=*(string2+(i-(length-1)));
                return result;
            }
        }
        i++;
    }
}

void searchMatrix(char *string, int matrix[ROWS][COLUMNS]) {
    int i=0, j=0, k=0, l=0, length=checkLength(string);
    char searchString[13];

    while (i<ROWS) {
        for (j=0; j<COLUMNS; j++) {
            searchString[j]=matrix[i][j]; 
        }
        if (strstr(searchString, string) != 0) {
            printf("%s found horizontally! %d %d\n", string, i+1, checkPosition(searchString, string));
            break;
        } else {
            i++;
            if (i==12) {
                while (k<COLUMNS) {
                    for (l=0; l<ROWS; l++) {
                        searchString[l]=matrix[l][k];
                    }
                    if (strstr(searchString, string) != NULL) {
                        printf("%s found vertically! %d %d\n", string, checkPosition(searchString, string), k+1);
                        break;
                    } else {
                        k++;
                        if (k==12) {
                            printf("%s not found!\n", string);
                            break;
                        }
                    }
                }
            }
        }
    }
}

void printMatrix(int matrix[ROWS][COLUMNS]) {
    int i=0, j=0;

    printf("\n+---+---+---+---+---+---+---+---+---+---+---+---+\n");
    for (i=0; i<ROWS; i++) {
        for (j=0; j<COLUMNS; j++) {
            printf("| %c ", matrix[i][j]);
            if (j==11) {
                printf("|\n+---+---+---+---+---+---+---+---+---+---+---+---+\n");
            }
        }
    }
}

int main(void) {
    int matrix[ROWS][COLUMNS] = {{'X', 'S', 'E', 'C', 'U', 'R', 'I', 'T', 'Y', 'C', 'O', 'T'},
                                 {'M', 'E', 'D', 'I', 'A', 'H', 'E', 'R', 'C', 'S', 'T', 'A'},
                                 {'K', 'C', 'F', 'X', 'J', 'A', 'E', 'S', 'I', 'I', 'L', 'S'},
                                 {'M', 'U', 'I', 'N', 'T', 'R', 'U', 'S', 'I', 'O', 'N', 'K'},
                                 {'A', 'R', 'R', 'Z', 'F', 'W', 'N', 'K', 'I', 'G', 'V', 'Z'},
                                 {'L', 'E', 'E', 'N', 'C', 'R', 'Y', 'P', 'T', 'I', 'O', 'N'},
                                 {'W', 'K', 'W', 'O', 'R', 'M', 'P', 'E', 'U', 'O', 'J', 'X'},
                                 {'A', 'V', 'A', 'M', 'D', 'N', 'D', 'P', 'J', 'H', 'A', 'L'},
                                 {'R', 'L', 'L', 'N', 'V', 'I', 'R', 'U', 'S', 'P', 'E', 'E'},
                                 {'E', 'W', 'L', 'D', 'D', 'E', 'X', 'O', 'L', 'T', 'P', 'U'},
                                 {'X', 'J', 'P', 'R', 'C', 'T', 'C', 'P', 'A', 'P', 'R', 'C'},
                                 {'G', 'K', 'B', 'U', 'F', 'F', 'E', 'R', 'S', 'L', 'T', 'B'}};
    int i=0;
    char string[13];

    printf("Matrix Search - Available commands:\n");
    printf("1 .. Enter a search string\n");
    printf("9 .. Print the matrix\n");
    printf("0 .. Quit the program\n");
    
    for ( ; ; ) { 
        printf("\nPlease enter your command: ");
        scanf("%d", &i);
        if (i==0) {
            exit(0);
        } else if (i==9) {
            printMatrix(matrix);
        } else if (i==1) {
            printf("Please enter search string: ");
            scanf("%s", &string);
            searchMatrix(string, matrix);
        }
    }

    return 0;
}
 
Zuletzt bearbeitet:
AW: [C] Hilfe beim Programmieren und Verständnis-Fragen zu Code-Beispielen ...

mach dir doch wegen der koords nich sonen stress ^^ also bei meinem bsp zum beispiel geht das doch sehr simpel: er geht ja feld für feld durch, hat daher doch schon die koords vom jeweiligen buchstaben. findet er nun also das S bei 0|2 (glaub da wars bei deiner bsp-matrix), dann hat er ja genau diese x|y coord in dem moment. eben jene 0|2. für die suche in den umliegenden feldern, nutzt er ja ne komplett neue variable, x|y bleiben unberührt. findet er da nun irgendwo das E, gehen auch x und y, also 0|2 in die checkFind funke rein un ned die koordinate vom E. um dann nach dem C zu suchen, fängt step in checkFind ja bei 2 an. checkFind muss also nur prüfen, ob in der eingeschlagenen richtung das ganze wort zu finden is. das is dann der fall, wenn jeder einzelne buchstabe des suchworts in der richtung gefunden wird und die grenzen der matrix nich gesprengt werden. ein "fehler" is mir da im übrigen noch unterlaufen - ich prüfe nur, ob searchX und searchY über das maximum hnauslaufen, nich aber übers minimum. das wäre in dem fall wichtig, wo man auch nach links oder oben bspw suchen lässt. in dem einfachen falle is das aber kein problem.

gut, checkFind findet also das ganze wort und schmeisst true zurück, die if-bedingung in searchMatrix is erfüllt und er kann ganz simpel x|y ausgeben (so wie ich das im bsp auch schon gemacht hab - siehe mein printf).
 
AW: [C] Hilfe beim Programmieren und Verständnis-Fragen zu Code-Beispielen ...

^^ Fast genauso arbeitet ja meine Funktion checkPosition() auch?! Die schaut, ob alle gesuchten Buchstaben schön nebeneinander stehen und geht dabei bis zum letzten durch. Von dem zieht sie dann die Länge-1 des Suchwortes ab und müsste somit genau beim Startbuchstaben landen.

Ich sehe da jetzt nicht den großen Unterschied zu deiner Version, außer, dass es bei dir anscheinend funktioniert ...

Beziehungsweise, wenn ich die Funktion so umschreibe, müsste sie genau das selbe machen, wie deine:
Code:
int checkPosition(char *string1, char *string2) {
    int i=0, result=0, length=checkLength(string2), count=0;

    while (*(string1+i)!='\0' || *(string2+i)!='\0') { [COLOR=seagreen]/* solange der kürzere String (logischerweise das Suchwort) nicht vollständig durchlaufen ist ... */        if (*(string2+i)==*(string1+i)) { [COLOR=seagreen]/* ... vergleiche das Suchwort und die Zeile/Spalte buchstabenweise */            count++; [COLOR=seagreen]/* bei Übereinstimmung erhöhe den Zähler */            if (count==length) { [COLOR=seagreen]/* entspricht der Zähler irgendwann der Wortlänge, stehe alle richtigen Buchstaben nebeneinander */                return (*(string2)); [COLOR=seagreen]/* gib daher den Index des Anfangsbuchstabens des Suchwortes zurück */            }
        }
        i++;
    }
}
^^ Gibt aber auch nicht den richtigen Wert zurück. Da bekomme ich immer Werte im Bereich von 88 bis 60. Würde mich interessieren, wo das herkommt.
 
Zuletzt bearbeitet:
AW: [C] Hilfe beim Programmieren und Verständnis-Fragen zu Code-Beispielen ...

kurze verständnisfrage dazu nochmal:
du übergibst einmal das zu suchende wort (SECURITY = string1) und einmal die zeile/spalte der matrix? fängt die dabei erst beim S an oder is das die komplette spalte/zeile die übergeben wird?

gut, jetz zum eigentlichen problem:
return (*(string2));

zum einen - die klammern kannste weglassen ^^ zum anderen, was macht denn *string2? haste selber schon oft verwendet ^^ das liefert nich den index zurück, sondern das erste zeichen des strings. und dieses zeichen ist ein char. nun ist der returnwert der funktion aber int. ergo wird das ganze konvertiert zu einem int-wert. und wie casted man ein char zu einem int? ^^ ich sage nur ascii-wert. das S hat zum bsp den wert... 83. würdest du da nen string (also nen "echten" und nich das char*) zurückgeben wollen, würd er dann sicherlich meckern. er meckert hier nur nich, weil es halt kein problem is, nen char auf int zu casten (eben, weil er dann den entsprechenden ascii wert des zeichens angibt. andersrum gehts freilich aus int -> char).

du müsstest also die aktuelle matrix position kennen (vom letzten buchstaben) und dann die länge davon abziehen. und um die zu kennen, musst du sie wohl irgendwie mit übergeben. und genau das mach ich ja bei meiner funktion ^^ aber: wenn ich die anfangsposition übergebe - brauch ich sie am ende doch garnich zu berechnen ^^
 
AW: [C] Hilfe beim Programmieren und Verständnis-Fragen zu Code-Beispielen ...

string1 = Die gesamte Zeile bzw. die gesamte Spalte von Feld 0 bis 11
string2 = Suchwort

Das Problem sehe ich jetzt, danke, nur kann ich leider keinen Startwert mitübergeben, weil ich aus strstr keinen Startwert rausbekomme. Die Funktion überprüft ja nur, ob der eine string im anderen drinnen steckt, aber nicht, wo genau.
Auf den Startwert muss die Funktion checkPosition von selbst kommen und daran arbeite ich jetzt noch. --> Dass eben z.B. bei SECURITY nicht der ASCII Wert von S, sondern 2 als Position von S zurückgegeben wird.

[EDIT]
So komme ich der Sache anscheinend schon sehr nahe:
Code:
int checkPosition(char *string1, char *string2) {
    int i=0, j=0, result=0, length=checkLength(string2), count1=0, count2=0;

    while (*(string1+i)!='\0' || *(string2+i)!='\0') {
        if (*(string2+i)==*(string1+i)) {
            count1++;
            if (count1==length) { [COLOR=seagreen]/*  wenn der eine string im anderen drinnensteckt ... */                if (*(string2+j) != *(string1+j)) { [COLOR=seagreen]/* ...  und der erste Buchstabe des Suchwortes nicht zufällig auch der erste Buchstabe der Zeile/Spalte ist, ... */                    while (*(string1+j++) != *(string2+j)) { [COLOR=seagreen]/* ... gehe so viele Index-Felder weiter, bis eine Übereinstimmung mit dem Anfangsbuchstaben gefunden wurden. */                        count2++; [COLOR=seagreen]/* erhöhe dabei für jedes weitergesprungene Index-Feld den Zähler2 */                    }
                    return count2; [COLOR=seagreen]/* liefere den Wert von Zähler2, der nun die Koordinate des Anfangsbuchstaben des Suchwortes enthält, zurück */                } else { [COLOR=seagreen]/* wenn zufälligerweise sofort im erste Feldindex eine Übereinstimmung gefunden wird ... */                    j=1;
                    return j; [COLOR=seagreen]/* gib 1 zurück */                }
            }
        }
        i++;
    }
}
Manche Koordinaten (z.B. für MALWARE) stimmen schon, aber noch nicht alle ...

Wie kann das sein, dass der selbe Code für ein Wort stimmt und für alle anderen nicht???
 
Zuletzt bearbeitet:
AW: [C] Hilfe beim Programmieren und Verständnis-Fragen zu Code-Beispielen ...

ich glaub ich weis worans liegt:
while(*(string1+j++) != *(string2+j)) count2++;

also dieser innere durchgang zum rausfinden der position. als ich das grad abschrieb, fiel mir noch das dick-unterstrichene auf ^^ du hast da nen ++ hinterm j. copy-paste überbleibsel? ^^ soll so glaube nich da stehn oder? :P naja, der hauptfehler den ich meinte is das +j hinterm string2. du willst doch schauen, ob eines der felder der matrix-zeile mit dem ersten des suchstrings übereinstimmt. du musst also den matrix-string zeichen für zeichen durchgehen (+j) und dabei immer mit dem selben zeichen (dem ersten) des suchstrings vergleichen. das +j beim string2 muss also weg.

die grundidee passt erstmal, aber schau dir mal folgende beispielmatrixzeile an:
XGSPSECURITYDRF
was passiert denn hier? security startet bei index 4, bei index 2 is aber auch nen S... ^^ daher hatte ich diese prüfung bei mir quasi in 3 schritten gebaut. er schaut erst, ob er ein S findet, dann schaut er, ob er angrenzend ein E findet (was erst beim 2. S der fall is) und dann schaut er vom fundort des 2. S ausgehend in richtung des dort benachbart gefundenen E's, ob er auch noch CURITY findet.
 
AW: [C] Hilfe beim Programmieren und Verständnis-Fragen zu Code-Beispielen ...

^^ Doch, die Zeile war genau so beabsichtigt, wie du sie noch einmal angeführt hast. string1 ist ja das lange Feld in dem gesucht wird und unter der Annahme, dass der Startbuchstabe des zu suchenden Wortes nicht gleich am Anfang steht, muss eben ein paar Mal weitergesprungen werden. Das darf allerdings nicht auch im Suchwort (= string2) passieren, weil ja sonst nicht mehr nach S gesucht werden würde. Deswegen bleibt das j dort konstant auf 0.
+0 klingt vielleicht komisch, allerdings kommt ohne ein noch größerer Blödsinn raus, also wird's nicht so falsch sein.

Ich versuche jetzt noch, den Code entsprechend deiner Idee zu erweitern, allerdings kann ich nicht einfach deinen Part übernehmen, weil das dann nicht mehr zum Rest meiner Version passen würde. Außerdem will ich's ja, mit Hilfe, selber schaffen ... ;)

BTW: Genau wegen dem Problem, ob auch die nachfolgenden Buchstaben stimmen, war ja mein ursprünglicher Ansatz, das lange Feld bis zum letzten Buchstaben des Suchwortes zu druchlaufen und dann über die Wortlänge auf den ersten runterzurechnen. Ich glaube, da werde ich weitermachen.
 
Zuletzt bearbeitet:
AW: [C] Hilfe beim Programmieren und Verständnis-Fragen zu Code-Beispielen ...

achso, das soll gleich der increment fürs j sein? mach das lieber einzeln. wenn ich jetz nich völlig falsch liege, wird einerseits das j++ am anfang der rechnung ausgeführt (a=1+2 rechnet er glaube 2+1=3), so dass du nie den 0er index vergleichst (gut, wäre in dem falle glaube sogar zu verschmerzen) und andrerseits - viel wichtiger: mit j++ erhöhst du j. also auch das von string2+j! wenn du da sowas wie string2+0 stehen haben willst - dann lass die variable doch auch einfach weg >< um den ersten buchstaben von string2 zu erhalten, reicht nunmal ein einfaches *string2.

in dem bsp von mir (XGSPSECURITYDRF/SECURITY) vergleichst du im ersten durchlauf also G mit E (XGSPSECURITYDRF/SECURITY), dann S mit C usw usf. dass KANN nix werden ^^
 
AW: [C] Hilfe beim Programmieren und Verständnis-Fragen zu Code-Beispielen ...

Ja, das hätte das Inkrement sein sollen. Wenn ich das aus dem Schleifenkopf rausnehme und sonst wo in der Schleife reinschreibe, erhöht es ja wieder beide j gleichermaßen und das wollte ich verhindern. Ganz offensichtlich macht es auch einen Unterschied, ob nur *string2, oder *(string2+j) mit j=0 dasteht, weil ja auch die Ausgabe damit eine andere ist. Warum, erschließt sich mir allerdings auch nicht.

Bei deinem Bsp komme ich nicht mit. Meine Funktion sucht doch zuerst einmal das S (wäre bei dir der dritte Buchstabe) und fängt erst dann zum Vergleichen an. Somit --> P == E? ... S == C? ...

------------------------------
Wie gesagt, ich probiere jetzt wieder meinen ursprünglichen Ansatz. Dann fängt die Rechnerei nämlich erst an, wenn ich schon weiß, dass die richtigen Buchstaben direkt hintereinander stehen. Dann einfach über die Wortlänge auf das richtige S runterrechnen, sollte kein Problem sein. :)

PS: Hier noch einmal die Matrix zum Nachschauen:
Code:
int matrix[ROWS][COLUMNS] = {{'X', [COLOR=royalblue]'S', 'E', 'C', 'U', 'R', 'I', 'T', 'Y', 'C', 'O', 'T'},
                             {'M', 'E', 'D', 'I', 'A', 'H', 'E', 'R', 'C', 'S', 'T', 'A'},
                             {'K', 'C', [COLOR=royalblue]'F', 'X', 'J', 'A', 'E', 'S', 'I', 'I', 'L', 'S'},
                             {[COLOR=royalblue]'M', 'U', [COLOR=royalblue]'I', 'N', 'T', 'R', 'U', 'S', 'I', 'O', 'N', 'K'},
                             {[COLOR=royalblue]'A', 'R', [COLOR=royalblue]'R', 'Z', 'F', 'W', 'N', 'K', 'I', 'G', 'V', 'Z'},
                             {[COLOR=royalblue]'L', 'E', [COLOR=royalblue]'E', 'N', 'C', 'R', 'Y', 'P', 'T', 'I', 'O', 'N'},
                             {[COLOR=royalblue]'W', 'K', [COLOR=royalblue]'W', 'O', 'R', 'M', 'P', 'E', 'U', 'O', 'J', 'X'},
                             {[COLOR=royalblue]'A', 'V', [COLOR=royalblue]'A', 'M', 'D', 'N', 'D', 'P', 'J', 'H', 'A', 'L'},
                             {[COLOR=royalblue]'R', 'L', [COLOR=royalblue]'L', 'N', [COLOR=royalblue]'V', 'I', 'R', 'U', 'S', 'P', 'E', 'E'},
                             {[COLOR=royalblue]'E', 'W', [COLOR=royalblue]'L', 'D', 'D', 'E', 'X', 'O', 'L', 'T', 'P', 'U'},
                             {'X', 'J', 'P', 'R', 'C', 'T', 'C', 'P', 'A', 'P', 'R', 'C'},
                             {'G', 'K', [COLOR=royalblue]'B', 'U', 'F', 'F', 'E', 'R', 'S', 'L', 'T', 'B'}};
[EDIT]
(Fast) geschafft!!! :D
Code:
int checkPosition(char *string1, char *string2) {
    int i=0, j=0, k=0, result=0, length=checkLength(string2), count1=0, count2=0;

    while (*(string1+i)!='\0' || *(string2+i)!='\0') {
        if (*(string2+i) != *(string1+i)) {
            count1++;
            j=i;
            if (*(string2+k) == *(string1+j)) {
                j++;
                k++;
                count2++;
                if (count2==length) {
                    [COLOR=royalblue][B]result=count1-(length-1);[/B]                    return result;
                }
            }
        }
        i++;
    }
}
Capture.JPG

^^ Wieso stimmen jetzt eigentlich sämtliche Koordinaten, nur bei MALWARE kommt so ein komischer Wert raus?
 
Zuletzt bearbeitet:
AW: [C] Hilfe beim Programmieren und Verständnis-Fragen zu Code-Beispielen ...

so, dank geht an meinen sohn, jetz darf ich alles nochma versuchen zu schreiben -.- kA wie der das immer schafft. der rennt am laptop vorbei und ff geht aus... mitten im text *kotz*

Wenn ich das aus dem Schleifenkopf rausnehme und sonst wo in der Schleife reinschreibe, erhöht es ja wieder beide j gleichermaßen und das wollte ich verhindern.
das wollt ich dir ja eben schon schreiben: auch in der schleife führt er das ding aus. wenn du also bei string1 das j inkrementierst, hat es beim string2 vergleich schon den erhöhten wert. diese funktionalität nutzte ich bei meinem bsp ja auch schon, als ich if(checkFind...) schrieb. er führt dann die checkFind funktion aus und die liefert je nachdem entweder true oder false zurück und danach entscheidet dann die if-bedingung, welcher weg gegangen wird.

gehn wir mal deinen code hier stück für stück durch (das würd ich eh immer empfehlen, dass mal zu machen. sicher nich für 100000 daten, aber so für 5-10 kann mans mal probieren ^^):
Code:
in die funktion geht nun also rein: string1 = XSECURITYCOT und string2 = SECURITY. das wäre die ausgangslage.
    solange nun also weder das zeichen bei *string1+i, noch bei *string2+i \0 ist, fahre fort. -> in unsrem fall ist i=0 und die anfangsbuchstaben sind X und S - die sind nicht \0 - weiter.
        [COLOR=red]*wenn jetzt *string1+i nicht das selbe wie *string2+i ist, mache weiter. wir sind noch bei X und S - die gleichen sich nicht, weiter gehts also.
            wir erhöhen count auf 1,
            j bekommt den wert von i, wird also 0
            ... hier kann man doch eigentlich schon abbrechen ^^
also pass auf: erstmal willst du doch bei * rausfinden, ob der erste buchstabe des suchstrings (string2) mit dem buchstaben an der aktuellen position im string1 übereinstimmt oder? du schiebst doch aber den vergleichsbuchstaben von string2 schonwieder gleichmäßig durch i durch die gegend ^^ sprich, wenn er das erste ding durch hat, dann sucht er bei string1+1 (erster durchlauf +0) -> S und vergleicht das mit string2+1 -> E. du willst doch aber sicher auch hier wieder das S von string2 zum vergleich heranziehen oder?

und dann is die ganze grundstruktur im eimer :P du sagst quasi "solange der erste buchstabe noch nich gefunden wurde, erhöhe den zähler1 (soweit so gut) und suche dann die restlichen buchstaben des suchwortes" oO wenn er den anfang noch garnich gefunden hat, wie kann er dann den rest vergleichen? ^^ die struktur muss also ganz anders aussehen:
Code:
while(beide nich zuende)
    if(*str1+i != *str2) erhöhe den zähler // hier wurds ja nich gefunden
    else vergleiche den restlichen teil // hier wurde ja der anfang gefunden, jetzt kann man auch vergleichen
jo, und da im else teil, da muss quasi dann der part rein, wo ich da oben aufgehört hatte. hier musst du jetzt auch str2 weiterschieben, weil du willst ja wissen, ob auch die anderen buchstaben in str1 folgen oder nich.

edit: was mich viel eher wundert is, dass da überhaupt irgendwas stimmt xD
 
AW: [C] Hilfe beim Programmieren und Verständnis-Fragen zu Code-Beispielen ...

Während dein Sohn "gezaubert" hat, habe ich fleißig editiert ... :D

Wir müssten eigentlich nur mehr die kuriose Ausgabe für MALWARE klären (siehe voriges Posting), den Rest habe ich während deines FF-Aussetzers erledigt. ;)

[EDIT]
Kann es sein, dass ich bei MALWARE irgendwie über die Feldgrenzen rauskomme? Sollte doch eigentlich durch den '\0'-Check verhindert werden?!
 
AW: [C] Hilfe beim Programmieren und Verständnis-Fragen zu Code-Beispielen ...

kam jetz zwar nich nochma dazu, mich intensiver mit deiner version zu befassen (müsst eigentlich scho im nest sein ><), aber mich hatte die lust gepackt es mal selbst zu bauen. das kam bei raus:

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

#define ROWS    12
#define COLUMNS    12

int matrix[ROWS][COLUMNS] = {{'X', 'M', 'K', 'M', 'A', 'L', 'W', 'A', 'R', 'E', 'X', 'G'},
                             {'S', 'E', 'C', 'U', 'R', 'E', 'K', 'V', 'L', 'W', 'J', 'K'},
                             {'E', 'D', 'F', 'I', 'R', 'E', 'W', 'A', 'L', 'L', 'P', 'B'},
                             {'C', 'I', 'X', 'N', 'Z', 'N', 'O', 'M', 'N', 'D', 'R', 'U'},
                             {'U', 'A', 'J', 'T', 'F', 'C', 'R', 'D', 'V', 'D', 'C', 'F'},
                             {'R', 'H', 'A', 'R', 'W', 'R', 'M', 'N', 'I', 'E', 'T', 'F'},
                             {'I', 'E', 'E', 'U', 'N', 'Y', 'P', 'D', 'R', 'X', 'C', 'E'},
                             {'T', 'R', 'S', 'S', 'K', 'P', 'E', 'P', 'U', 'O', 'P', 'R'},
                             {'Y', 'C', 'I', 'I', 'I', 'T', 'U', 'J', 'S', 'L', 'A', 'S'},
                             {'C', 'S', 'I', 'O', 'G', 'I', 'O', 'H', 'P', 'T', 'P', 'L'},
                             {'O', 'T', 'L', 'N', 'V', 'O', 'J', 'A', 'E', 'P', 'R', 'T'},
                             {'T', 'A', 'S', 'K', 'Z', 'N', 'X', 'L', 'E', 'U', 'C', 'B'}};

int strLenght(char *string) {
    int length = 0;
    while (*(string+length) != '\0') {
        length++;
    }
    return length;
}

void printMatrix(int x, int y, int xDir, int yDir, int strLen) {
    int i, j, k;
    bool isPart;

    for(i = 0; i <= ROWS; i++) printf("+-----");
    printf("+\n");
    for(i = 0; i <= ROWS; i++) {
        if(i == 0) printf("| x\\y ");
        else if(i <= 10) printf("|  %d  ", i - 1);
        else printf("|  %d ", i - 1);
    }
    printf("|\n");
    for(i = 0; i <= ROWS; i++) printf("+=====");
    printf("+\n");
    for(j = 0; j < COLUMNS; j++) {
        for(i = 0; i <= ROWS; i++) {
            if(i == 0) {
                if(j < 10) printf("|  %d |", j);
                else  printf("| %d |", j);
            } else if(strLen > 0) {
                if(x == i-1 && y == j) printf("| [%c] ", matrix[i - 1][j]);
                else {
                    isPart = false;
                    for(k = 0; k < strLen; k++) {
                        if((x + (k * xDir)) == i-1 && (y + (k * yDir)) == j) {
                            printf("| (%c) ", matrix[i - 1][j]);
                            isPart = true;
                        }
                    }
                    if(!isPart) printf("|  %c  ", matrix[i - 1][j]);
                }
            } else printf("|  %c  ", matrix[i - 1][j]);
        }
        printf("|\n");
        for(i = 0; i <= ROWS; i++) printf("+-----");
        printf("+\n");
    }
}

// Position des Funds, Offsets zur Richtungsbestimmung und die eigentlichen Daten -> sucht detailliert nach dem vermeindlich gefundenen Wort
bool checkFind(int x, int y, int xDir, int yDir, char *searchString) {
    bool found = true; // solange true, bis der erste (vergleichs-)fehler auftritt
    int step = 2; // beginnend nach dem 2. buchstaben - der erste war der hauptfund, der 2. war der "richtungsfund"
    int searchX = 0, searchY = 0;
    while(*(searchString+step) != '\0') {
        searchX = x+(xDir*step);
        searchY = y+(yDir*step);
        if(searchX >= ROWS || searchY >= COLUMNS || searchX < 0 || searchY < 0) { // wurde der rand der matrix erreicht, bevor das ganze wort gefunden wurde? - abbruch
            found = false;
            break; // raus aus der while
        }
        if(*(searchString+step) != (char)matrix[searchX][searchY]) { // stimmt der nächste buchstabe des suchstrings NICHT mit dem nächsten (in entsprechender richtung liegenden) feld-buchstaben der matrix überein? -> abbrechen
            found = false;
            break; // raus aus der while
        }
        step = step + 1; // is ja kein c++ oder? jedenfalls gehts dann nen buchstaben weiter, wenn bisher alles passt
    }
    return found;
}

// durchsucht die Matrix nach den ersten Hinweisen auf das gesuchte Wort
void searchMatrix(char *searchString) {
    int maxDir = 8; // wieviele suchrichtungen soll es geben? atm geh ich mal von nur 2en aus (vorwärts und runter)
    int x, y, i;
    for(y = 0; y < COLUMNS; y++) { // <- erst spalten
        for(x = 0; x < ROWS; x++) { // dann zeilen
            if(*searchString == (char)matrix[x][y]) { // erster buchstabe des suchstrings entspricht dem aktuell betrachteten zeichen in der matrix?
                for(i = 0; i < maxDir; i++) {
                    switch(i) { // für jede suchrichtung die fälle bearbeiten - leicht erweiterbar
                    case 0: { // suche nach rechts weiter
                        if(checkFind(x, y, 1, 0, searchString)) { // überprüfe den fund, ned das es nur zufällig der buchstabe war und der rest nich passt
                            printf("String '%s' an Position %d|%d in Richtung %d|%d gefunden.\n", searchString, x, y, 1, 0);
                            printMatrix(x, y, 1, 0, strLenght(searchString));
                            return;
                        }
                        break;
                    }
                    case 1: { // suche nach rechts unten weiter
                        if(checkFind(x, y, 1, 1, searchString)) {  // überprüfe den fund, ned das es nur zufällig der buchstabe war und  der rest nich passt
                            printf("String '%s' an Position %d|%d in Richtung %d|%d gefunden.\n", searchString, x, y, 1, 1);
                            printMatrix(x, y, 1, 1, strLenght(searchString));
                            return;
                        }
                        break;
                    }
                    case 2: { // suche nach unten weiter
                        if(checkFind(x, y, 0, 1, searchString)) {  // überprüfe den fund, ned das es nur zufällig der buchstabe war und  der rest nich passt
                            printf("String '%s' an Position %d|%d in Richtung %d|%d gefunden.\n", searchString, x, y, 0, 1);
                            printMatrix(x, y, 0, 1, strLenght(searchString));
                            return;
                        }
                        break;
                    }
                    case 3: { // suche nach links unten weiter
                        if(checkFind(x, y, -1, 1, searchString)) {  // überprüfe den fund, ned das es nur zufällig der buchstabe war und  der rest nich passt
                            printf("String '%s' an Position %d|%d in Richtung %d|%d gefunden.\n", searchString, x, y, -1, 1);
                            printMatrix(x, y, -1, 1, strLenght(searchString));
                            return;
                        }
                        break;
                    }
                    case 4: { // suche nach links weiter
                        if(checkFind(x, y, -1, 0, searchString)) {  // überprüfe den fund, ned das es nur zufällig der buchstabe war und  der rest nich passt
                            printf("String '%s' an Position %d|%d in Richtung %d|%d gefunden.\n", searchString, x, y, -1, 0);
                            printMatrix(x, y, -1, 0, strLenght(searchString));
                            return;
                        }
                        break;
                    }
                    case 5: { // suche nach links oben weiter
                        if(checkFind(x, y, -1, -1, searchString)) {  // überprüfe den fund, ned das es nur zufällig der buchstabe war und  der rest nich passt
                            printf("String '%s' an Position %d|%d in Richtung %d|%d gefunden.\n", searchString, x, y, -1, -1);
                            printMatrix(x, y, -1, -1, strLenght(searchString));
                            return;
                        }
                        break;
                    }
                    case 6: { // suche nach oben weiter
                        if(checkFind(x, y, 0, -1, searchString)) {  // überprüfe den fund, ned das es nur zufällig der buchstabe war und  der rest nich passt
                            printf("String '%s' an Position %d|%d in Richtung %d|%d gefunden.\n", searchString, x, y, 0, -1);
                            printMatrix(x, y, 0, -1, strLenght(searchString));
                            return;
                        }
                        break;
                    }
                    case 7: { // suche nach rechts oben weiter
                        if(checkFind(x, y, 1, -1, searchString)) {  // überprüfe den fund, ned das es nur zufällig der buchstabe war und  der rest nich passt
                            printf("String '%s' an Position %d|%d in Richtung %d|%d gefunden.\n", searchString, x, y, 1, -1);
                            printMatrix(x, y, 1, -1, strLenght(searchString));
                            return;
                        }
                        break;
                    }
                    }
                }
            }
        }
    }
}

int _tmain(int argc, _TCHAR* argv[]) {
    bool end = false;
    int i = 0;
    char string[12];

    printf("Matrix-Suche - Waehle Aktion:\n");
    printf("1 .. Wortsuche\n");
    printf("9 .. Matrix ausgeben\n");
    printf("0 .. Program beenden\n");

    while(!end) {
        printf("\nKommando: ");
        scanf("%d", &i);
        if (i==0) {
            end = true;
        } else if (i==9) {
            printMatrix(0,0,0,0,0);
        } else if (i==1) {
            printf("Welches Wort wird gesucht? ");
            scanf("%s", &string);
            searchMatrix(string);
        }
    }
    return 0;
}

im großen und ganzen also das, was ich schon prototypisch entwickelt hatte hier. die printMatrix funktion is ebbes aufgeplustert, da ich die für ne anzeige des gefundenen strings mitbenutz - klappt soweit ganz gut. mit "kein fund" hab ichs jetz garnich probiert *hm* na wird scho passen ^^

ABER: mir fielen noch 2 elementare dinge auf, wo ich mich frag, wieo das bei dir überhaupt funzt :P
zum einen: matrix is vom typ int. auch wenn du die mit chars initialisierst, da stehen int werte drin. ham wir ja schon gelernt - char in int gecasted ergibt den ascii wert des zeichens. soweit kein problem. bei printf("%c", matrix[x][y]); macht das auch nix aus, das hier nen char verlangt wird und nen int geliefert und die funktion das wohl dann intern casted (solange möglich, in unserem fall hier isses das). aber, wir vergleichen ja auch häufiger buchstaben/chars des suchwortes mit dem wert der matrix an ner x|y position. sprich, du vergleichst nen char mit nem int value. kA ob er das auch automatisch dann macht, aber ich hab fürn notfall nen (char)matrix[x][y] draus gemacht. das es bei dir funzt, spricht für ne automatische umwandlung.

gut, und dann hab ich noch nen logischen fehler enddeckt: deine matrix-variable is falsch aufgebaut. sie sieht zwar optisch richtig aus, ist aber "intern" über die diagonale gespiegelt. ich hatte die nämlich mal ausgeben lassen, und da war security plötlich von oben nach unten geschrieben in der ersten spalte >< das mag vom programm her kein eigentliches problem sein, aber fürs eigene verständnis finde ich, is das nen böser stolperstein. wenn man die matrix im code liest, würde ich persönlich davon ausgehen, dass das S von Security an position 0|1 steht - es steht aber in wirklichkeit an 1|0. das verwirrt ^^ deshalb findest du bei mir bei der matrix deklaration ne angepasste variante.

zur erklärung: du hast ja matrix[x=2][y=2] = { {a, b}, {c, d} }; <- {a, b} steht für das x0 und {c, d} für x1. wenn mans also tabellarisch aufschreibt, ist jeder teilpart, den du hier in einer zeile aufschreibst (weils anders nich sehr schön geht ^^), eine spalte. a oder c wären dann jeweils y0 - also die erste zeile, obwohl sie im code spaltenförmig angeordnet sind. hoffe, du verstehst was ich meine.

jedenfalls: diese verdrehung kann natürlich im endeffekt zu "unerwarteten" ergebnissen/koordinaten führen. wenn man das weiss, lässt sich der ein oder andere fehler vllt vermeiden. und: bei der printMatrix funktion siehst du dann auch wunderbar, wieso man am besten zuerst die spalten in ner for-schleife durchgeht und dann erst die zeilen. du hast es dort wieder "falschherum" gemacht und dadurch wird die "intern falsche" tabelle wieder richtig gedreht. quasi falsch und falsch = richtig ^^ naja, wie ich sagte: an und für sich mags egal sein, sieht halt nur blöde aus, wenn er sagt "fund bei 1|0" und in der ausgabe steht das teil aber bei 0|1 >< man muss hier also schon auf ne passende harmonie achten.

nun gut, vllt hilft dir mein laufendes proggi ja irgendwie weiter. ich verkrümel mich erstma schnellsten ins nest...
 
AW: [C] Hilfe beim Programmieren und Verständnis-Fragen zu Code-Beispielen ...

^^ Also von einer angeblichen Verdrehung der Matrix merkt man bei meiner Version gar nichts. Es stimmen auch alle Koordinaten, ohne, dass ich da jetzt manuell was hätte vertauschen müssen. Ganz habe ich auch noch nicht verstanden, was du überhaupt meinst. Werde mir deine Erklärung morgen im ausgeschlafenen Zustand noch einmal durchdenken ...

Die einzige falsche Koordinate ist der Startwert (Spaltenkoordinate bzw. nach deiner Logik wahrscheinlich Zeilenkoordinate, was aber keine Rolle spielt, da ich eh nur mit einem Feld arbeite und keiner Matrix) von MALWARE. Die ist bei jedem Programmdurchlauf ein anderer Wert, der aber immer 7-stellig ist. Jetzt gerade z.B. 1440093. Das sieht für mich nicht nach einer Verdrehung von irgendwas aus, sondern eher, als würde ich bei diesem Wort irgendwie über die Feldgrenze hinauskommen, oder mit einem falschen Datentyp arbeiten.
Ersteres sollte aber eigentlich nicht möglich sein, weil ich ja extra auf '\0' überprüfe. Letzteres kann's aber auch nicht wirklich sein, weil der selbe Code ja für sämtlichen anderen Wörter das richtige Ergebnis liefert. Ich hätte gehofft, du erkennst in meinen knapp 20 Zeilen der Funktion checkPosition(), wo der Hund begraben liegt (der Fehler muss ja in der Funktion sein, oder?) ...

Über die Tatsache, dass ich eine int matrix definiert habe, sonst aber eigentlich nur mit char variablen und strings arbeite und das Ganze trotzdem funktioniert, habe ich mich auch schon gewundert (:D). Ich habe testweise sogar schon das int vor matrix mal durch char ersetzt, hat aber überhaupt keinen Unterschied gemacht. Man kann also, denke ich, wirklich davon ausgehen, dass sich der Compiler um die nötigen Typumwandlungen kümmert.

Ich hoffe, wir finden den kleinen Fehler bei MALWARE noch. Wenn nicht, muss ich mich halt mit meiner jetzigen Version zufriedengeben. Ich finde die eigentlich ziemlich gut und sie liefert zu 87,5 % das richtige Ergebnis, LOL. Man darf halt nur nicht zufällig das Wort MALWARE erwischen. :fresse:

PS: Was ich auch noch probieren möchte, ist, die Bibliotheksfunktion strstr durch selbstgeschriebenen Code zu ersetzen. Wie ich dir schon in's Profil schrieb, vermute ich stark, dass ich den Code dafür eh schon in checkPosition() drinnen stehen habe. Müsste, wenn ich richtig liege, nur etwas angepasst werden.
 
AW: [C] Hilfe beim Programmieren und Verständnis-Fragen zu Code-Beispielen ...

joa, im endeffekt is strstr genau das, was wir hier selber bauen. ursprünglich auf die ganze matrix (string in matrix) bezogen, in deinem falle jetzt auch auf string in string - also genau das selbe ^^ nur das die funktion halt nicht die position zurück gibt, sondern halt nen zeiger auf den wortanfang von dem gesuchten string im gesamtstring.

und ich meinte jau auch, das die "verdrehung" der matrix im grunde kein problem is - solange man dran denkt. bei deiner printMatrix funke haste unbewusst dran gedacht, da du hier die forschleifen genau falschherum verschachtelt hast ^^ (-> for(i) { for(j) { matrix[j] }} statt for(j) { for(i) { matrix[j] }}). dadurch geht er die erste spalte von oben nach unten durch und schreibt sie von links nach rechts auf um dann mit der nächsten spalte weiterzumachen. aber normalerweise will man sowas ja wie den text in einem buch aufschreiben: zeile für zeile von links nach rechts. und würdest du dass so machen, dann wäre die ganze ausgabe verdreht (aber würde die interne matrix korrekt darstellen).

und warum is das so "verdreht"? ich versuchs mal zu erklären:
wenn du nen einfaches array definierst, also zum bsp int matrix[2], dann sieht dass ja so aus:
Code:
int matrix[2] = {0,
                 1}
machst du daraus jetzt nen 2dimensionales array, hat man statt 0 und 1 wieder nen array. also quasi jeder array eintrag ist selber ein array:
Code:
int matrix[2][2] = { {0, 1},
                     {2, 3}}
da man jetzt eben bei [][] irgendwie immer [x][y] assoziiert und x in nem koorinatensystem immer von links nach rechts geht und y von oben nach unten (oder andersrum, jedenfalls diese richtung da ^^), würde man jetzt also alle x einträge von links nach rechts aufreihen und die y teile untereinander. dann folgt sowas daraus:
Code:
+-------------+
| +---+ +---+ |
| | 0 | | 2 | |
| | 1 | | 3 | |
| +---+ +---+ |
+-------------+
sprich: aus der aufgeschriebenen reihenfolge
01
23

wird plötzlich intern
02
13

^^ wie gesagt, solange man dran denkt und damit rechnet/kalkuliert, is das ja kein problem - aber mir macht sowas dann immer unnötige schierigkeiten >< daher sollte das eher als hinweis dienen. weil wenn ich dann die position der 2 ausgegeben haben will, rechne ich halt damit, das der mir jetz ne 1|0 ausschmeisst und würde mich dann wundern, wieso er aber stattdessen die 0|1 ausgibt.

und zu deiner funktion nochmal: wie gesagt, schreib die erstmal sinnvoll um. ich frag mich ja echt, wieso da überhaupt was gescheites bei rauskommt ^^ die grundlogik der funktion haut vorn und hinten nicht hin (was wohl auch das mit maleware verursachen wird).

die logik deiner schleifen da is folgende:
gehe alle buchstaben durch und vergleiche sie bis das stringende erreicht wurde.
hierbei machst du WIEDER den fehler, dass du beide strings "weiterschiebst". also den betrachteten buchstaben. du willst doch erstmal im einen string den anfangsbuchstaben des anderen strings wiederfinden. dazu musst du vom ersten string alle buchstaben nacheinander IMMER mit dem ersten des 2. strings vergleichen. sprich: hier den 2. string auch weiter zu schieben sabotiert die ganze idee dahinter.
dann gehts weiter:
wenn der aktuell betrachtete buchstabe nicht mit dem (eigentlich) anfangsbuchstaben des 2. strings übereinstimmt (auch hier vergleichst du wieder den 2. 3. 4. buchstaben des gesamtstrings mit dem 2. 3. 4. buchstaben des suchstrings - kann doch nix werden), erhöhe den zähler (für die position, wos losgeht. der gedanke ist auch wieder richtig - die ausführung sinnfrei :P
und jetzt kommt ja DER knackpunkt noch in der ganzen logik:
wenn er den wortanfang von str2 in str1 NICHT gefunden hat, schaue nach dem rest von str2? das gehört in den else teil des letzten vergleichs - nämlich WENN der anfangsbuchstabe im str1 gefunden wurde, DANN musst du schauen, ob nachfolgend das ganze wort noch dranhängt. also: bau erstmal deine ganze konstruktion da um, so kann das nie was werden ^^
 
AW: [C] Hilfe beim Programmieren und Verständnis-Fragen zu Code-Beispielen ...

Mich hat das Problem auch interessiert, und hab auch mal ne Funktion dazu geschrieben.
Ich wollte dieses switch(){case...} der 8 Suchrichtungen vermeiden, und hab mir überlegt, dass man ja nur wissen muss, ob X, bzw. Y erhöht oder erniedrigt wird (oder gleichbleibt). Dabei ist das herausgekommen:
Code:
bool findExpression(char * * Matrix, int Size, char * Expression, MatrixPosition * ExprPosition) //besser Referenz, falls C++ (In ExprPosition wird die gefundene Position gespeichert)
{
    //Alle Felder der Matrix werden durchgegangen, und werden nach dem Anfangsbuchstaben durchsucht. Danach kanns in 8 Richtungen weitergehen
    for(int i = 0; i < Size; i++)
    {
        for(int j = 0; j < Size; j++)
        {
            //Für jedes Feld wird in 8 Richtungen weitergesucht
            for(int SearchMode = 0; SearchMode < 8; SearchMode++)
            {
                int XDirection = 0, YDirection = 0; //Richtung in die nach dem ersten Buchstaben weitergesucht wird -- -1 , 0 , 1 
                int X = i, Y = j; // Startposition, an der jetzt nach dem ersten Buchstaben gesucht wird
                int CurrentExprPos = 0; // Position innerhalb des gesuchten Wortes
                
                //Festlegung der Suchrichtung. 
                if((SearchMode+1)%8 >= 0 && (SearchMode+1)%8 <3) YDirection = 1; 
                else if(SearchMode > 2 && SearchMode < 6) YDirection = -1;
                if(SearchMode > 0 && SearchMode < 4) XDirection = 1;
                else if(SearchMode > 4 && SearchMode <= 7) XDirection = -1;

                if(strlen(Expression) <= 1) return false; // Expression zu klein? gleich beenden, weils keinen Sinn macht
                
                //Hier wird jetzt geprüft: Eine Schleife, die bei (i|j) beginnt, und dann in die Festgelegte Richtung weitersucht.
                //Solange alle Buchstaben übereinstimmen, wird in die festgelegte Richtung weitergegangen
                while(Expression[CurrentExprPos] == Matrix[X][Y])
                {
                    CurrentExprPos++;

                    if(CurrentExprPos == strlen(Expression)) //Wort vollständig gefunden, Ergebnis festhalten
                    {
                        //Endposition ist die jetzige Position
                        ExprPosition->EndX=X;
                        ExprPosition->EndY=Y;

                        //Startposition war das Feld an dem wir den ersten Buchstaben gefunden haben
                        ExprPosition->StartX=i;
                        ExprPosition->StartY=j;
                        return true;
                    }
                    else
                    {
                        //Und zum nächsten Buchtaben...
                        X+=XDirection; 
                        Y+=YDirection;

                        if(X<0 || Y < 0 || X >=Size || Y>=Size) break; //Um nicht aus dem Rahmen zu gehen ;)
                    }
                }
            }
        }
    }
    return false;
}
Ich bin bei dem Problem mit der "MALWARE" auch nicht mehr mitgekommen, da auch niemand wirklich versteht, warums da hapert, würde ich eventuell empfehlen, das ganze nochmal von vorne anzufangen, weil irgendwie ist da der Wurm drinnen.
Weil das wird nicht nur bei "MALWARE" so sein, wenn andere Matrizen getestet werden, liefert das jetzige ja keine zuverlässigen Werte, dh. in einem komplexeren Programm wären die Folgen net so schön ;)
Vom Prinzip her ist die Sache ja einfach, man muss an jedem Feld der Matrix nach dem Anfangsbuchstaben suchen, und dann in 8 Richtungen weiterüberprüfen. Das Startfeld ist dann das Feld, wo man den Anfangsbuchstaben gefunden hat, und das Endfeld, das letzte Feld, an dem man gemerkt hat, dass man den String gefunden hat :)
 
AW: [C] Hilfe beim Programmieren und Verständnis-Fragen zu Code-Beispielen ...

^^ OK, danke euch beiden. War eh selber schon kurz davor, die Funktion checkPosition() neu zu schreiben. Ich bin mir schon ziemlich sicher, dass meine Logik bzw. Idee gut ist, allerdings kann's schon sein, dass der Code nicht ganz das macht, was ich meine. Sooo falsch kann er aber auch wieder nicht sein, wenn er für fast alles das richtige Ergebnis liefert. Naja, mach's trotzdem neu ...

@ DarkMo
Erklären könnte ich es selber nicht, aber ich glaube, ich seh's schon was du mit "verdreht" meinst. Wenn ich's aber unbewusst eh richtig mache, will ich mir da nicht weiter den Kopf darüber zerbrechen. Ich finde das nämlich schon relativ verwirrend. ;)
 
AW: [C] Hilfe beim Programmieren und Verständnis-Fragen zu Code-Beispielen ...

Bevor ich mit der Matrix-Suche weitermachen kann, muss ich schnell ein anderes Programm machen. Dabei soll über die Leibniz-Reihe PI angenähert werden. In mehreren Runden unterschiedlich genau.

[EDIT]
Hat sich schon alles erledigt. Hab's geschafft ... ;)
Code:
#include <stdio.h>

#define LIMIT_ONE 10
#define LIMIT_TWO 100
#define LIMIT_THREE 100000

double approx(double k) {
    int i=0;
    double j=0.0, result=0.0, countPos=0.0, countNeg=0.0; 

    for (i=1, j=1; i<=k; i++, j+=2) { 
        if (i%2==0) { 
            countNeg-=(1/j);
        } else {
            countPos+=(1/j);
        }
    }

    [COLOR=seagreen]/* 
    PI = (1/1 - 1/3 + 1/5 - 1/7 + 1/9 - 1/11 + 1/13 - ...) * 4

   [COLOR=seagreen] Funktionsweise: Brüche erhalten "gedankliche Indexe". Z.B. 1/1 = erster Bruch = "Index" 1. 
    Ist der Index eine gerade Zahl, berechne den Bruch und subtrahiere das Ergebnis von countNeg.
    Ist der Index eine ungerade Zahl, berechne den Bruch und addiere das Ergebnis zu countPos. 
    Das Gesamtergebnis ist countPos + countNeg und das Ganze * 4.

   [COLOR=seagreen] In der Schleife zählt i die Brüche bis zur maximal gewünschten Anzahl und j die Schrittweite zwischen den Divisoren durch.
    */
    result=countPos+countNeg;

    return (result*4);
}

int main(void) {
    int k=0;

    printf("Bruchanzahl Naeherungswert\n==============================\n");
    for (k=1; k<=LIMIT_ONE; k++) { [COLOR=seagreen]/* k ist immer Anzahl der Brüche, für die die Berechnung stattfinden soll */        if (k==LIMIT_ONE) {
            printf("%d %26.15lf\n", k, approx((double)k));
        } else {
            printf("%d %27.15lf\n", k, approx((double)k));
        }
    }
    for (k=20; k<=LIMIT_TWO; k+=10) {
        if (k==LIMIT_TWO) {
            printf("%d %25.15lf\n", k, approx((double)k));
        } else {
            printf("%d %26.15lf\n", k, approx((double)k));
        }
    }
    for (k=1000; k<=LIMIT_THREE; k*=10) {
        if (k==(LIMIT_THREE/10)) {
            printf("%d %23.15lf\n", k, approx((double)k));
        } else if (k==(LIMIT_THREE)/100) {
            printf("%d %24.15lf\n", k, approx((double)k));
        } else {
            printf("%d %22.15lf\n", k, approx((double)k)); 
        }
    }
    putchar('\n');

    return 0;
}
Weiter geht's mit der Matrix. Aber erst schlafen gehen (siehe Uhrzeit des edits) ... :D
 
Zuletzt bearbeitet:
AW: [C] Hilfe beim Programmieren und Verständnis-Fragen zu Code-Beispielen ...

@ Mods
Sorry für Tripple-Posting, aber ich editiere eh schon, was das Zeug hält. Wenn ich jede News in's letzte Posting reineditiere, haben wir ein Posting mit ~ 10 Edits und kein Mensch sieht, dass sich im Thread was getan hat.


Habe die Funktion jetzt neu geschrieben und jetzt geht's!!! Funktioniert absolut richtig für alles ... :D :daumen:
Code:
int checkPosition(char *string1, char *string2) {
    int i=0, j=0, length=checkLength(string2), count=0, start=0;

    while (*(string1+i)!='\0' || *(string2+i)!='\0') {
        start=i;
        if (*(string1+i) == *(string2+j)) {
            j++;
            if (j==length) {
                return (start-(length-1));
            }
        }
        i++;
    }
}
Habe zusätzlich auch schon eine Funktion geschrieben, die mir die Bibliotheksfunktion strstr ersetzt und die funktioniert ebenfalls einwandfrei! :daumen:
Code:
int compareStrings(char *string1, char *string2) {
    int i=0, j=0, length=checkLength(string2);

    while (*(string1+i)!='\0' || *(string2+i)!='\0') {
        if (*(string1+i) == *(string2+j)) {
            j++;
            if (j==length) {
                return 0;
            }
        }
        i++;
    }

    return 1;
}
Da die beiden Funktionen checkPosition() und compareStrings() extrem ähnlich sind, will ich es jetzt nur noch schaffen, sie zu einer Funktion zu kombinieren. Dann hätten wir alles geschafft. ;)

[EDIT]
Soeben die Kombination der Funktionen auch noch geschafft! checkPosition() ist Geschichte. Hier der finale Code:
Code:
#include <stdio.h>
#include <stdlib.h>

#define ROWS 12
#define COLUMNS 12

int checkLength(char *string) {
    int length=0;

    while (*(string+length)!='\0') {
        length++;
    }

    return length;
}

[B][COLOR=royalblue]int compareStrings(char *string1, char *string2) {
    int i=0, j=0, length=checkLength(string2), count=0, start=1;
 [COLOR=royalblue]     while (*(string1+i)!='\0' || *(string2+i)!='\0') {
        start=i;
        if (*(string1+i) == *(string2+j)) {
            j++;
            if (j==length) {
                return (start+1-(length-1));
            }
        }
        i++;
    }
 [COLOR=royalblue]     return 0;
}[/B]

void searchMatrix(char *string, int matrix[ROWS][COLUMNS]) {
    int i=0, j=0, k=0, l=0, length=checkLength(string);
    char searchString[13];

    while (i<ROWS) {
        for (j=0; j<COLUMNS; j++) {
            searchString[j]=matrix[i][j]; 
        }
        [B][COLOR=royalblue]if (compareStrings(searchString, string)) {[/B] [COLOR=seagreen]/* wenn Rückgabewert von [I]compareStrings()[/I] ungleich 0 */            printf("%s found horizontally! %d %d\n", string, i+1, [B][COLOR=royalblue]compareStrings(searchString, string)[/B]);
            break;
        } else {
            i++;
            if (i==12) {
                while (k<COLUMNS) {
                    for (l=0; l<ROWS; l++) {
                        searchString[l]=matrix[l][k];
                    }
                    [COLOR=royalblue][B]if (compareStrings(searchString, string)) {[/B]                        printf("%s found vertically! %d %d\n", string, [COLOR=royalblue][B]compareStrings(searchString, string)[/B], k+1);
                        break;
                    } else {
                        k++;
                        if (k==12) {
                            printf("%s not found!\n", string);
                            break;
                        }
                    }
                }
            }
        }
    }
}

void printMatrix(int matrix[ROWS][COLUMNS]) {
    int i=0, j=0;

    printf("\n+---+---+---+---+---+---+---+---+---+---+---+---+\n");
    for (i=0; i<ROWS; i++) {
        for (j=0; j<COLUMNS; j++) {
            printf("| %c ", matrix[i][j]);
            if (j==11) {
                printf("|\n+---+---+---+---+---+---+---+---+---+---+---+---+\n");
            }
        }
    }
}

int main(void) {
    int matrix[ROWS][COLUMNS] = {{'X', 'S', 'E', 'C', 'U', 'R', 'I', 'T', 'Y', 'C', 'O', 'T'},
                                 {'M', 'E', 'D', 'I', 'A', 'H', 'E', 'R', 'C', 'S', 'T', 'A'},
                                 {'K', 'C', 'F', 'X', 'J', 'A', 'E', 'S', 'I', 'I', 'L', 'S'},
                                 {'M', 'U', 'I', 'N', 'T', 'R', 'U', 'S', 'I', 'O', 'N', 'K'},
                                 {'A', 'R', 'R', 'Z', 'F', 'W', 'N', 'K', 'I', 'G', 'V', 'Z'},
                                 {'L', 'E', 'E', 'N', 'C', 'R', 'Y', 'P', 'T', 'I', 'O', 'N'},
                                 {'W', 'K', 'W', 'O', 'R', 'M', 'P', 'E', 'U', 'O', 'J', 'X'},
                                 {'A', 'V', 'A', 'M', 'D', 'N', 'D', 'P', 'J', 'H', 'A', 'L'},
                                 {'R', 'L', 'L', 'N', 'V', 'I', 'R', 'U', 'S', 'P', 'E', 'E'},
                                 {'E', 'W', 'L', 'D', 'D', 'E', 'X', 'O', 'L', 'T', 'P', 'U'},
                                 {'X', 'J', 'P', 'R', 'C', 'T', 'C', 'P', 'A', 'P', 'R', 'C'},
                                 {'G', 'K', 'B', 'U', 'F', 'F', 'E', 'R', 'S', 'L', 'T', 'B'}};
    int i=0;
    char string[13];

    printf("Matrix Search - Available commands:\n");
    printf("1 .. Enter a search string\n");
    printf("9 .. Print the matrix\n");
    printf("0 .. Quit the program\n");
    
    for ( ; ; ) { 
        printf("\nPlease enter your command: ");
        scanf("%d", &i);
        if (i==0) {
            exit(0);
        } else if (i==9) {
            printMatrix(matrix);
        } else if (i==1) {
            printf("Please enter search string: ");
            scanf("%s", &string);
            searchMatrix(string, matrix);
        }
    }

    return 0;
}
Danke für die super Hilfe!!! :daumen: :daumen: :daumen:
 
Zuletzt bearbeitet:
Zurück