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



  • @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