Hilfe bei Grammatikalgorithmus



  • Hallo,

    seit 2015 arbeite ich an einer Software für behinderte Menschen. Das Hauptprogramm ist ein TTS Programm, welches über eine Bildschirmtastatur bedient wird, die die Wörter automatisch beugen soll.
    Also habe ich mir erst mal eine Protoklasse erstellt (l2sgrammatik.h):

    
    enum class ADJECTIVE{POSITIVE, COMPARATIVE, SUPERLATIVE};
    enum class GENUS{MASKULIN, FEMININ, NEUTRUM};
    enum class VERB{FPERSSING, SPERSSING, TPERSSING, FPERSPLU, SPERSPLU, TPERSPLU, IMPERATIV,
                    FPERSSINGPAST, SPERSSINGPAST, TPERSSPAST, FPERSPLUPAST, SPERSPLUPAST, TPERSPLUPAST, PERFECT, FUTURE};
    
    enum class FILENAME {FILEADJECTIVE, FILENOUN, FILEVERB, FILELIST};
    
    struct Adjective
    {
        QString Positive;
        QString Comperative;
        QString Superlative;
    };
    
    struct Nouns
    {
        QString Singular;
        QString Plural;
        QString genitivSingular;
        QString dativSingular;
        QString dativPlural;
    };
    
    struct Verbs
    {
        QString FPSingular;
        QString SPSingular;
        QString TPSingular;
        QString FPPlural;
        QString SPPlural;
        QString TPPlural;
        QString FPSingularPast;
        QString SPSingularPast;
        QString TPSingularPast;
        QString FPPluralPast;
        QString TPPluralPast;
        QString Perfect;
        QString Future;
    };
    class L2SGrammatikPROTO
    {
    
        virtual bool isUnregularVerb(QString verb)=0;
        virtual bool isUnregularAdjective(QString adjective)=0;
    
        virtual QString getNoun(QString word)=0;
        virtual QString getNounPl(QString word)=0;
        virtual QString getNounDaSi(QString word)=0;
        virtual QString getNounDaPl(QString word)=0;
        virtual QString getNounGeSi(QString word)=0;
        virtual QString getAdjective(QString word, ADJECTIVE declear)=0;
        virtual QString getAdjective(QString word, ADJECTIVE declear, int end)=0;
        virtual QString getPersonalPronoun(QString word)=0;
        virtual QString getVerb(QString word, VERB declear)=0;
    
        virtual void addWord(QString word)=0;
        virtual void setNoun(QString word)=0;
        virtual void setNounPl(QString word, GENUS gen)=0;
        virtual void setNounDaSi(QString word, GENUS gen)=0;
        virtual void setNounDaPl(QString word, GENUS gen)=0;
        virtual void setNounGeSi(QString word, GENUS gen)=0;
    
        virtual void openGrammatik(FILENAME fname)=0;
        virtual void saveGrammatik(FILENAME fname)=0;
    };
    }
    }
    
    

    Von der ich meine Klasse l2sdeutschgrammatik abgeleitet habe.
    Nun möchte ich saubere Algorithmen erstellen.
    würdet ihr diese Methode als sauber erachten:

    
    QString L2SDeutschGrammatik::getVerb(QString word, VERB declear)
    {
        if(!isUnregularVerb(word))
        {
            switch (declear)
            {
            case VERB::FPERSSING:
                word.append("e ");
                break;
            case VERB::SPERSSING:
                word.append("st ");
                break;
            case VERB::TPERSSING:
                word.append("t ");
                break;
            case VERB::FPERSPLU:
                word.append("en ");
                break;
            case VERB::SPERSPLU:
                word.append("t ");
                break;
            case VERB::TPERSPLU:
                word.append("en ");
                break;
            case VERB::FPERSSINGPAST:
            {
                if(!word.endsWith('t') || !word.endsWith('d') || !word.endsWith('m') || !word.endsWith('n'))
                {
                    word.append("ete ");
                }
                else
                {
                    word.append("te");
                }
            }
                break;
            case VERB::SPERSSINGPAST:
            {
                if(!word.endsWith('t') || !word.endsWith('d') || !word.endsWith('m') || !word.endsWith('n'))
                {
                    word.append("etest ");
                }
                else
                {
                    word.append("test");
                }
            }
                break;
            case VERB::TPERSSPAST:
            {
                if(!word.endsWith('t') || !word.endsWith('d') || !word.endsWith('m') || !word.endsWith('n'))
                {
                    word.append("ete ");
                }
                else
                {
                    word.append("te");
                }
            }
                break;
            case VERB::FPERSPLUPAST:
            {
                if(!word.endsWith('t') || !word.endsWith('d') || !word.endsWith('m') || !word.endsWith('n'))
                {
                    word.append("eten ");
                }
                else
                {
                    word.append("en ");
                }
            }
                break;
            case VERB::SPERSPLUPAST:
            {
                if(!word.endsWith('t') || !word.endsWith('d') || !word.endsWith('m') || !word.endsWith('n'))
                {
                    word.append("etet ");
                }
                else
                {
                    word.append("et");
                }
            }
            break;
            case VERB::TPERSPLUPAST:
            {
                if(!word.endsWith('t') || !word.endsWith('d') || !word.endsWith('m') || !word.endsWith('n'))
                {
                    word.append("eten ");
                }
                else
                {
                    word.append("ten");
                }
            }
                break;
            case VERB::KONJUNKTIV_I:
            {
    
            }
                break;
            case VERB::KONJUNKTIV_II:
            {
                int i=0;
                while(i<word.size() && !isAEOU(word[i]))
                {
                    i++;
                }
                if(word[i]=='a' || word[i]=='e')
                    word.replace(i,0,"ä");
                else if(word[i]=='A' || word[i]=='E')
                    word.replace(i,0,"Ä");
                else if(word[i]=='o')
                    word.replace(i,0,"ö");
                else if(word[i]=='O')
                    word.replace(i,0,"Ö");
                else if(word[i]=='u')
                    word.replace(i,0,"ü");
                else if(word[i]=='U')
                    word.replace(i,0,"Ü");
            }
                break;
            case VERB::PERFECT:
            {
                word = "ge"+getVerb(word, VERB::TPERSPLUPAST);
            }
                break;
            case VERB::IMPERATIV:
            {
    
            }
            }
        }
        return word;
    }
    

    Würdet ihr die unregelmäßigen Verben etc. in Listen schreiben? Ich bin für jede Idee (auch für die anderen Wortformen dankbar.

    Ich hoffe lange Codeblöcke sind nicht verpönt



  • @tobstar008 sagte in Hilfe bei Grammatikalgorithmus:

    würdet ihr diese Methode als sauber erachten:

    Nicht wirklich.



  • Eine Funktion 135 Zeilen? Nope.



  • hab ich mir gedacht... was wäre denn sauber?



  • Ohne es mir lange angesehen zu haben:

    • unnötige Blöcke und Klammern weglassen (nur ein Statement in z.B. if und die Klammern bei den cases)
    • in Funktionen auslagern
      (- ggf. in Map auslagern; nicht genau genug angesehen um sagen zu können, dass es sinnvoll ist.


  • char const *verb_suffixes[] = { "e ", "st ", "t ", "en ", "t ", "en " };
    enum VERB { FPERSSING, SPERSSING, TPERSSING, FPERSPLU, SPERSPLU, TPERSPLU, IMPERATIV, FPERSSINGPAST,
    			SPERSSINGPAST, TPERSSPAST, FPERSPLUPAST, SPERSPLUPAST, TPERSPLUPAST, PERFECT, FUTURE
    };
    
    QString L2SDeutschGrammatik::getVerb(QString word, VERB declear)
    {
    	if(isUnregularVerb(word))
    		return word;
    		
    	if (declear < IMPERATIV) {
    		word.append(verb_suffixes[declear]);
    		return word;
    	}
    
    	switch (declear)
    	{
    		// ...
    

    gibt es nicht zwischen * und *PAST auch einen Zusammenhang?

    @tobstar008 sagte in Hilfe bei Grammatikalgorithmus:

        case VERB::KONJUNKTIV_II:
        {
            int i=0;
            while(i<word.size() && !isAEOU(word[i]))
            {
                i++;
            }
            if(word[i]=='a' || word[i]=='e')
                word.replace(i,0,"ä");
            else if(word[i]=='A' || word[i]=='E')
                word.replace(i,0,"Ä");
            else if(word[i]=='o')
                word.replace(i,0,"ö");
            else if(word[i]=='O')
                word.replace(i,0,"Ö");
            else if(word[i]=='u')
                word.replace(i,0,"ü");
            else if(word[i]=='U')
                word.replace(i,0,"Ü");
        }
    

    Das geht mit RegEx sicher schöner.



  • Super ganz herzlichen Dank



  • FPERSSINGPAST und TPERSSPAST ist exakt dasselbe.


Log in to reply