Verschlüsselung mithilfe der Bacon-Chiffre [gelöst]



  • Ich habe das Grundgerüst gebaut und möchte jetzt für jeden Buchstaben eine switch anweisung machen. Mit Neu=Neu+cipher[i]-32 erreiche ich das mein kleines L zu einem großen L wird. Soweit so gut, aber wie kann ich nun weitere zeichen an L anhängen. Nichts funktioniert, was ich versuche:

    #include <iostream>
    #include <math.h>
    
    using namespace std;
    
    char encrypt(string cipher, string eingabe)
    {
        char neu;
        for(int i=0;i<141;i++)
        {
            switch(eingabe[i])
            {
                case 32 :;break;
                case 46 :;break;
                case 97 :  neu=neu+cipher[i]-32; neu=neu+cipher[i+1];break;
                case 98 :; break;
                case 99 :; break;
                case 100:; break;
                case 101:; break;
                case 102:; break;
                case 103:; break;
                case 104:; break;
                case 105:; break;
                case 106:; break;
                case 107:; break;
                case 108:; break;
                case 109:; break;
                case 110:; break;
                case 111:; break;
                case 112:; break;
                case 113:; break;
                case 114:; break;
                case 115:; break;
                case 116:; break;
                case 117:; break;
                case 118:; break;
                case 119:; break;
                case 120:; break;
                case 121:; break;
                case 122:; break;
            }
    
        }
        return neu;
    }
    
    
    
    int main()
    {
        string neu;
        string eingabe;
        string cipher="loremipsumdolorsitametconsetetursadipscingelitrseddiamnonumyeirmodtemp"
        "orinviduntutlaboreetdoloremagnaaliquyameratseddiamvoluptuaatveroeosest";
    
        cout<< "Geben Sie einen zu verschluesselnden String ein!"<<endl;
        getline(cin,eingabe);
        neu=encrypt(cipher,eingabe);
        if (eingabe.length()<29)
        {
            cout<< "Die Verschluesselung lautet;"<<neu<< endl;
    
    
        }
        else
        {
            cout << "Eine Verschluesselung ist nicht moeglich!";
        }
        return 0;
    }
    


  • @Francesco sagte in Verschlüsselung mithilfe der Bacon-Chiffre:

    möchte jetzt für jeden Buchstaben eine switch anweisung machen.

    Wie wäre es mit einem Array?

    @Francesco sagte in Verschlüsselung mithilfe der Bacon-Chiffre:

    Mit Neu=Neu+cipher[i]-32 erreiche ich das mein kleines L zu einem großen L wird.

    std::tolower() gibt Dir den Kleinbuchstaben. <cctype>.



  • @Swordfish Vielen Dank für die ausführliche Antwort, leider sind wir noch ganz am Anfang von c++ und dürfen nur grundbefehle benutzen.



  • @Swordfish Arrays dürfen wir nicht benutzen, genau so wie tolower. Die Befehle die wir bisher haben sind s[], s.length(), switch, for und while schleifen. Das wars



  • @Francesco Es gibt keine "Befehle" in einer Sprache wie C oder C++. Es gibt Statements. Statements können Funktionsaufrufe beinhalten. Das was Du unter "Befehle" verstehst sind wahrscheinlich Klassen und Funktionen der C++ Standard Library. Was darfst Du davon verwenden? Was explizit nicht? Ein Lehrer der explizit verbietet neues zu lernen taugt irgendwie nicht.



  • @Francesco sagte in Verschlüsselung mithilfe der Bacon-Chiffre:

    Arrays dürfen wir nicht benutzen

    wtf? Eigene Funktionen darfst Du aber schreiben wie Du lustig bist?



  • @Francesco sagte in Verschlüsselung mithilfe der Bacon-Chiffre:

    #include <math.h>

    Lass das! Erstens ist das wenn schon <cmath> in C++ und zweitens brauchst Du es nicht.



  • @Swordfish sagte in Verschlüsselung mithilfe der Bacon-Chiffre:

    Eigene Funktionen darfst Du aber schreiben wie Du lustig bist?

    #include <iostream>
    
    bool my_isspace(char ch)
    {
        return ch == ' ';  // natuerlich nicht vollstaendig aber ausreichend
    }
    
    bool my_ispunct(char ch)
    {
        return ch == '.';  // ditto
    }
    
    bool my_isupper(char ch)
    {
        return 'A' <= ch && ch <= 'Z';
    }
    
    bool my_islower(char ch)
    {
        return 'a' <= ch && ch <= 'z';
    }
    
    char my_toupper(char ch)
    {
        if (!my_islower(ch))
            return ch;
        return 'A' + ch - 'a';
    }
    
    char my_tolower(char ch)
    {
        if (!my_isupper(ch))
            return ch;
        return 'a' + ch - 'A';
    }
    
    int main()
    {
        for (char ch = 'a'; ch <= 'z'; ++ch)
            std::cout.put(my_toupper(ch));
        std::cout.put('\n');
        
        for (char ch = 'A'; ch <= 'Z'; ++ch)
            std::cout.put(my_tolower(ch));
        std::cout.put('\n');
    }
    

    Und vor allem hör' bitte auf 97 zu schreiben wenn Du 'a' meinst. Schreib' 'a'.

    Wenn man davon ausgehen darf daß cipher wirklich wirklich nur aus Kleinbuchstaben besteht wird die Sache einfacher.



  • @Swordfish unser professor möchte, dass wir alles von grund auf lernen



  • @Francesco das ist keine Antwort auf meine Fragen.



  • @Swordfish ja eigene funktionen darf ich so schreiben wie ich möchte, mit unseren bisherigen kenntnissen. Welche s[i] zur Auslese einer Stelle in einem String, s.lenght() Länge des String s, Grundrechenoperationen und Logik, for und while schleifen. Das wars



  • @Francesco Das ist ja toll. Dann kannst Du std::string auch als arrayersatz für die zu enkodieren Zeichen verwenden und meine Funktionen oben um festzustellen um welche Art es sich handelt und um zwischen klein und groß zu konvertieren.

    std::string const encodable_chars{ "abcdefghijklmnopqrstuvwxyz. " };
    
    // ...
    
    std::size_t my_find(std::string const &str, char ch)
    {
        for (std::size_t i{}; i < str.length(); ++i)
            if (str[i] == ch)
                return i;
        return str.length();
    }
    

    Wenn my_find() das Zeichen nicht finden konnte gibt es str.length() zurück. Sonst ist es der Index des gefundenen Zeichens.



  • #include <cstdlib>
    #include <string>
    #include <iostream>
    
    constexpr size_t chunk_length{ 5 };
    
    bool my_islower(char ch)
    {
        return 'a' <= ch && ch <= 'z';
    }
    
    char my_toupper(char ch)
    {
        if (!my_islower(ch))
            return ch;
        return 'A' + ch - 'a';
    }
    
    bool get_bit(std::size_t value, std::size_t bit)
    {
        return (value >> bit) & 0x01;
    }
    
    std::string const encodable_chars{ "abcdefghijklmnopqrstuvwxyz. " };
    
    std::size_t my_find(std::string const &str, char ch)
    {
        for (std::size_t i{}; i < str.length(); ++i)
            if (str[i] == ch)
                return i;
        return str.length();
    }
    
    std::string encrypt(std::string const &message, std::string const &cipher)
    {
        std::string ciphertext;
        std::size_t const number_of_usable_chunks{ cipher.length() / chunk_length };
    
        for (std::size_t chunk_number{}; chunk_number < number_of_usable_chunks; ++chunk_number) {
            std::cout << "chunk number #" << chunk_number << '\n';
            std::string chunk;
            for (std::size_t i{}; i < chunk_length; ++i) {
                std::cout << cipher[chunk_number * chunk_length + i];
                chunk += cipher[chunk_number * chunk_length + i];
            }
            std::cout.put('\n');
    
            if (chunk_number < message.length()) {
                std::cout << "character to encode: " << message[chunk_number] << '\n';
                auto value{ my_find(encodable_chars, message[chunk_number]) };
                if (value == encodable_chars.length())
                    return {};
    
                for (std::size_t bit{ chunk_length }; bit; --bit) {
                    std::cout << chunk[chunk_length - bit] << ": " << get_bit(value, bit - 1) << "\t'";
                    if (get_bit(value, bit - 1))
                        chunk[chunk_length - bit] = my_toupper(chunk[chunk_length - bit]);
                    std::cout << chunk[chunk_length - bit] << "'\n";
                }
            }
            std::cout.put('\n');
            ciphertext += chunk;
        }
        return ciphertext;
    }
    
    int main()
    {
        std::string cipher{
            "loremipsumdolorsitametconsetetursadipscingelitrseddiamnonumyeirmodtemp"
            "orinviduntutlaboreetdoloremagnaaliquyameratseddiamvoluptuaatveroeosest"
        };
    
        std::cout << "Message: ";
        std::string message;
        if (!std::getline(std::cin, message)) {
            std::cerr << "Input Error :(\n\n";
            return EXIT_FAILURE;
        }
    
        auto ciphertext{ encrypt(message, cipher) };
        std::cout << ciphertext;
    }
    
    

    Kannst Du das nachvollziehen?



  • @Swordfish Ja danke dir ! 🙂


Anmelden zum Antworten