Cäsar-Verschlüsselung #

class Caesar {

   static String verschluessele(String text, int verschiebung) {
      String verschluesselt = "";
      // Hier kommt dein Code hin:


      return verschluesselt;
   }

   /**
    * Die Methode positionImAlphabet gibt für einzelne
    * Buchstaben deren Position (1..26) im Alphabet zurück.
    * Für Umlaute, andere Zeichen und längere Zeichenketten
    * wird -1 zurückgegeben.
    */
   static int positionImAlphabet(String zeichen) {
      int verschluesselt = -1;
      if(zeichen.length() == 1) {
         String alphabet = "abcdefghijklmnopqrstuvwxyz";
         verschluesselt = alphabet.indexOf(zeichen.toLowerCase());
         if(verschluesselt != -1) {
            verschluesselt++;
         }
      }
      return verschluesselt;
   }

   /**
    * Die Methode buchstabeAnPosition gibt für Zahlen zwischen
    * 1 und 26 Buchstaben zurück, die an der entsprechenden
    * Position im Alphabet stehen. Für alle anderen Zahlen
    * wird eine leere Zeichenkette zurückgegeben.
    */
   static String buchstabeAnPosition(int position) {
      String buchstabe = "";
      String alphabet = "abcdefghijklmnopqrstuvwxyz";
      if(position > 0 && position < 27) {
         buchstabe += alphabet.substring(position - 1, position);
      }
      return buchstabe;
   }

   static void teste() {
      // Getestet wird immer mit Verschiebung von 3
      int verschiebung = 3;
      String[][] testfälle = new String[4][2];
      testfälle[0][0] = "abc";
      testfälle[0][1] = "def";
      testfälle[1][0] = "Hallo";
      testfälle[1][1] = "kdoor";
      testfälle[2][0] = "xyz";
      testfälle[2][1] = "abc";
      testfälle[3][0] = "Mister X, das wird nichts!";
      testfälle[3][1] = "plvwhu a, gdv zlug qlfkwv!";

      boolean alleTestsBestanden = true;
      for (String[] testfall : testfälle) {
         String ergebnis = verschluessele(testfall[0], verschiebung);
         if(ergebnis.equals(testfall[1])) {
            println("+", "green");
         } else {
            println("Test fehlgeschlagen", "red");
            println("Testfall: " + testfall[0]);
            println("Erwartet wurde:");
            println(testfall[1]);
            println("Erhalten:");
            println(ergebnis);
            alleTestsBestanden = false;
         }
      }
      println(alleTestsBestanden ? "Alle Tests bestanden!" : "Einige Tests wurden nicht bestanden.");
   }
   
}

Caesar.teste();

import doctest

alphabet = 'abcdefghijklmnopqrstuvwxyz'

def verschluessele(text: str, verschiebung: int) -> str:
    """
    Nimmt Texte (Zeichenketten) und eine Verschiebung entgegen und gibt
    entsprechend verschlüsselte Texte zurück. Die Texte werden in Kleinbuchstaben
    ausgeben, Leerzeichen und Satzzeichen bleiben erhalten.
    
    >>> verschluessele('abc', 3)
    'def'
    >>> verschluessele('Hallo', 1)
    'ibmmp'
    >>> verschluessele('xyz', 3)
    'abc'
    >>> verschluessele('Mister X, das wird nichts!', 3)
    'plvwhu a, gdv zlug qlfkwv!'
    >>> verschluessele('plvwhu a, gdv zlug qlfkwv!', 23)
    mister x, das wird nichts!
    """

    # Ersetze pass durch deinen Code
    pass

def position_im_alphabet(zeichen: str) -> int:
    """
    Die Funktion positionImAlphabet gibt für einzelne
    Buchstaben deren Position (1..26) im Alphabet zurück.
    Für Umlaute, andere Zeichen und längere Zeichenketten
    wird -1 zurückgegeben.
    
    >>> position_im_alphabet('c')
    3
    >>> position_im_alphabet('Z')
    26
    >>> position_im_alphabet(' ')
    -1
    >>> position_im_alphabet('abc')
    -1
    """
    verschluesselt = -1
    if len(zeichen) == 1 and zeichen.lower() in alphabet:
        verschluesselt = alphabet.index(zeichen.lower()) + 1 
    return verschluesselt;

def buchstabe_an_position(position: int) -> str:
    """
    Die Funktion buchstabe_an_position gibt für Zahlen zwischen
    1 und 26 Buchstaben zurück, die an der entsprechenden
    Position im Alphabet stehen. Für alle anderen Zahlen
    wird eine leere Zeichenkette zurückgegeben.
    
    >>> buchstabe_an_position(2)
    'b'
    >>> buchstabe_an_position(25)
    'y'
    >>> buchstabe_an_position(27)
    ''
    >>> buchstabe_an_position(-1)
    ''
    """
    if 0 < position < 27:
        return alphabet[position - 1]
    return ''
        
if __name__ == '__main__':
    doctest.testmod()

class Caesar {

   static String verschluessele(String text, int verschiebung) {
      StringBuilder verschlusselterText = new StringBuilder();
      // Hier kommt dein Code hin:



      return verschlusselterText.toString();
   }

   /**
    * Die Methode positionImAlphabet gibt für einzelne
    * Buchstaben deren Position (1..26) im Alphabet zurück.
    * Für Umlaute, andere Zeichen und längere Zeichenketten
    * wird -1 zurückgegeben.
    */
   static int positionImAlphabet(String zeichen) {
      int verschluesselt = -1;
      if(zeichen.length() == 1) {
         String alphabet = "abcdefghijklmnopqrstuvwxyz";
         verschluesselt = alphabet.indexOf(zeichen.toLowerCase());
         if(verschluesselt != -1) {
            verschluesselt++;
         }
      }
      return verschluesselt;
   }

   /**
    * Die Methode buchstabeAnPosition gibt für Zahlen zwischen
    * 1 und 26 Buchstaben zurück, die an der entsprechenden
    * Position im Alphabet stehen. Für alle anderen Zahlen
    * wird eine leere Zeichenkette zurückgegeben.
    */
   static String buchstabeAnPosition(int position) {
      String buchstabe = "";
      String alphabet = "abcdefghijklmnopqrstuvwxyz";
      if(position > 0 && position < 27) {
         buchstabe += alphabet.substring(position - 1, position);
      }
      return buchstabe;
   }

   static void println(Object o) {
       System.out.println(o.toString());
   }
}

import org.junit.jupiter.api.Test;
import static org.junit.jupiter.api.Assertions.assertEquals;

public class CaesarTest {

    @Test
    void testVerschluessele() {
        assertEquals("def", Caesar.verschluessele("abc", 3));
        assertEquals("ibmmp", Caesar.verschluessele("Hallo", 1));
        assertEquals("abc", Caesar.verschluessele("xyz", 3));
        assertEquals("plvwhu a, gdv zlug qlfkwv!", Caesar.verschluessele("Mister X, das wird nichts!", 3));
        assertEquals("mister x, das wird nichts!", Caesar.verschluessele("plvwhu a, gdv zlug qlfkwv!", 23));
    }

    @Test
    void testPositionImAlphabet() {
        assertEquals(3, Caesar.positionImAlphabet("c"));
        assertEquals(26, Caesar.positionImAlphabet("Z"));
        assertEquals(-1, Caesar.positionImAlphabet(" "));
        assertEquals(-1, Caesar.positionImAlphabet("abc"));
    }

    @Test
    void testBuchstabeAnPosition() {
        assertEquals("b", Caesar.buchstabeAnPosition(2));
        assertEquals("y", Caesar.buchstabeAnPosition(25));
        assertEquals("", Caesar.buchstabeAnPosition(27));
        assertEquals("", Caesar.buchstabeAnPosition(-1));
    }
}