Text encodieren und decodieren, der geshuffelt wurde

Gehscheiter · 7. Juni 2025 um 11:05

Sieht hier vielleicht jemand, was falsch wäre? Die decode-Methode soll den Originaltext zurückgeben:

Original: Das ist ein Test um zu sehen ob es funktioniert.
Encoded:  Das ist ein Tset um zu sheen ob es fterinonukit. 
Decoded:  Das ist ein Test um zu seehn ob es fuiioenrnttk.

„sehen“ und „funktioniert“ werden noch nicht wieder richtig decodiert.

Ich glaube inzwischen, die unshuffle-Methode könnte falsch sein.

import java.util.*;

public class Main {
    private static final Random random = new Random(0);

    public static void main(String[] args) {
        String input = "Das ist ein Test um zu sehen ob es funktioniert.";
        System.out.println("Original: " + input);
        System.out.println("Encoded:  " + encode(input));
        System.out.println("Decoded:  " + decode(encode(input)));
    }

    private static String encode(String input) {
        HashSet<Character> vokale = new HashSet<>(Arrays.asList('a', 'e', 'i', 'o', 'u', 'ä', 'ö', 'ü'));
        ArrayList<String> words = new ArrayList<>(Arrays.asList(input.split(" ")));
        ArrayList<String> words2 = new ArrayList<>();
        for (int i = 0; i < words.size(); i++) {
            String word = words.get(i);
//            if (word.length() <= 3 && i < words.size() - 1) {
//                String word2 = words.get(++i).toLowerCase(Locale.ROOT);
//                // word2 = word2.substring(0, 1).toUpperCase(Locale.ROOT) + word2.substring(1);
//                word = word.toLowerCase(Locale.ROOT) + word2;
//            }
            words2.add(word);
        }

        StringBuilder encoded = new StringBuilder();
        for (String word : words2) {
            if (word.length() > 3) {
                ArrayList<Character> vokaleInWord = new ArrayList<>();
                ArrayList<Character> consonants = new ArrayList<>();
                for (char c : word.substring(1, word.length() - 1).toCharArray()) {
                    if (vokale.contains(c)) {
                        vokaleInWord.add(c);
                    } else {
                        consonants.add(c);
                    }
                }
                Collections.shuffle(vokaleInWord, random);
                Collections.shuffle(consonants, random);
                double vokaleRatio = (double) vokaleInWord.size() / (vokaleInWord.size() + consonants.size());
                double consonantsRatio = (double) consonants.size() / (vokaleInWord.size() + consonants.size());

                int vokaleIndex = 0;
                int consonantsIndex = 0;
                ArrayList<Character> merged = new ArrayList<>();
                merged.add(word.charAt(0));
                for (int i = 0; i < word.length() - 2; i++) {
                    if ((double) vokaleIndex / vokaleRatio < (double) consonantsIndex / consonantsRatio) {
                        if (vokaleIndex < vokaleInWord.size()) {
                            merged.add(vokaleInWord.get(vokaleIndex++));
                        } else {
                            merged.add(consonants.get(consonantsIndex++));
                        }
                    } else {
                        if (consonantsIndex < consonants.size()) {
                            merged.add(consonants.get(consonantsIndex++));
                        } else {
                            merged.add(vokaleInWord.get(vokaleIndex++));
                        }
                    }
                }
                merged.add(word.charAt(word.length() - 1));
                for (char c : merged) {
                    encoded.append(c);
                }
                encoded.append(" ");
            } else {
                encoded.append(word).append(" ");
            }
        }
        return encoded.toString();
    }

    private static <T> void unshuffle(List<T> list, Random rnd) {
        int[] seq = new int[list.size()];
        for (int i = seq.length; i >= 1; i--) {
            seq[i - 1] = rnd.nextInt(i);
        }
        for (int i = 0; i < seq.length; i++) {
            Collections.swap(list, i, seq[i]);
        }
    }

    private static String decode(String input) {
        HashSet<Character> vokale = new HashSet<>(Arrays.asList('a', 'e', 'i', 'o', 'u', 'ä', 'ö', 'ü'));
        ArrayList<String> words = new ArrayList<>(Arrays.asList(input.split(" ")));

        StringBuilder encoded = new StringBuilder();
        for (String word : words) {
            if (word.length() > 3) {
                ArrayList<Character> vokaleInWord = new ArrayList<>();
                ArrayList<Character> consonants = new ArrayList<>();
                String wordReversed = new StringBuilder(word).reverse().toString();
                for (char c : wordReversed.substring(1, word.length() - 1).toCharArray()) {
                    if (vokale.contains(c)) {
                        vokaleInWord.add(c);
                    } else {
                        consonants.add(c);
                    }
                }

                double vokaleRatio = (double) vokaleInWord.size() / (vokaleInWord.size() + consonants.size());
                double consonantsRatio = (double) consonants.size() / (vokaleInWord.size() + consonants.size());
                int vokaleIndex = 0;
                int consonantsIndex = 0;
                ArrayList<Character> merged = new ArrayList<>();
                for (int i = 0; i < word.length() - 2; i++) {
                    if ((double) vokaleIndex / vokaleRatio < (double) consonantsIndex / consonantsRatio) {
                        if (vokaleIndex < vokaleInWord.size()) {
                            merged.add(vokaleInWord.get(vokaleIndex++));
                        } else {
                            merged.add(consonants.get(consonantsIndex++));
                        }
                    } else {
                        if (consonantsIndex < consonants.size()) {
                            merged.add(consonants.get(consonantsIndex++));
                        } else {
                            merged.add(vokaleInWord.get(vokaleIndex++));
                        }
                    }
                }

                vokaleInWord = new ArrayList<>();
                consonants = new ArrayList<>();
                for (char c : merged) {
                    if (vokale.contains(c)) {
                        vokaleInWord.add(c);
                    } else {
                        consonants.add(c);
                    }
                }

                unshuffle(vokaleInWord, random);
                unshuffle(consonants, random);

                vokaleIndex = 0;
                consonantsIndex = 0;
                merged = new ArrayList<>();
                merged.add(word.charAt(0));
                for (int i = 0; i < word.length() - 2; i++) {
                    if ((double) vokaleIndex / vokaleRatio >= (double) consonantsIndex / consonantsRatio) {
                        if (vokaleIndex < vokaleInWord.size()) {
                            merged.add(vokaleInWord.get(vokaleIndex++));
                        } else {
                            merged.add(consonants.get(consonantsIndex++));
                        }
                    } else {
                        if (consonantsIndex < consonants.size()) {
                            merged.add(consonants.get(consonantsIndex++));
                        } else {
                            merged.add(vokaleInWord.get(vokaleIndex++));
                        }
                    }
                }
                merged.add(word.charAt(word.length() - 1));
                for (char c : merged) {
                    encoded.append(c);
                }
                encoded.append(" ");
            } else {
                encoded.append(word).append(" ");
            }
        }
        return encoded.toString();
    }
}

Gehscheiter · 7. Juni 2025 um 12:43

Ich denke, ich bin schon ein Stück weiter.

Collection.shuffle kann nicht umgekehrt werden
Man braucht den gleichen Random
Man braucht identische Seeds

import java.util.*;

public class Main {
    private static final int SEED = 42; // Fixed seed for reproducibility

    public static void main(String[] args) {
        ArrayList<Character> s1 = new ArrayList<>(Arrays.asList('a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i', 'j', 'k', 'l', 'm', 'n', 'o', 'p', 'q', 'r', 's', 't', 'u', 'v', 'w', 'x', 'y', 'z'));
        System.out.println("s1: " + s1);
        shuffle(s1);
        System.out.println("s2: " + s1);
        unshuffle(s1);
        System.out.println("s3: " + s1);

        String input = "Das ist ein Test um zu sehen ob es funktioniert.";
        System.out.println("Original: " + input);
        System.out.println("Encoded:  " + encode(input));
        System.out.println("Decoded:  " + decode(encode(input)));
    }

    private static String encode(String input) {
        HashSet<Character> vokale = new HashSet<>(Arrays.asList('a', 'e', 'i', 'o', 'u', 'ä', 'ö', 'ü'));
        ArrayList<String> words = new ArrayList<>(Arrays.asList(input.split(" ")));
        ArrayList<String> words2 = new ArrayList<>();
        for (int i = 0; i < words.size(); i++) {
            String word = words.get(i);
//            if (word.length() <= 3 && i < words.size() - 1) {
//                String word2 = words.get(++i).toLowerCase(Locale.ROOT);
//                // word2 = word2.substring(0, 1).toUpperCase(Locale.ROOT) + word2.substring(1);
//                word = word.toLowerCase(Locale.ROOT) + word2;
//            }
            words2.add(word);
        }

        StringBuilder encoded = new StringBuilder();
        for (String word : words2) {
            if (word.length() > 3) {
                ArrayList<Character> vokaleInWord = new ArrayList<>();
                ArrayList<Character> consonants = new ArrayList<>();
                for (char c : word.substring(1, word.length() - 1).toCharArray()) {
                    if (vokale.contains(c)) {
                        vokaleInWord.add(c);
                    } else {
                        consonants.add(c);
                    }
                }
                shuffle(vokaleInWord);
                shuffle(consonants);
                double vokaleRatio = (double) vokaleInWord.size() / (vokaleInWord.size() + consonants.size());
                double consonantsRatio = (double) consonants.size() / (vokaleInWord.size() + consonants.size());

                int vokaleIndex = 0;
                int consonantsIndex = 0;
                ArrayList<Character> merged = new ArrayList<>();
                merged.add(word.charAt(0));
                for (int i = 0; i < word.length() - 2; i++) {
                    if ((double) vokaleIndex / vokaleRatio < (double) consonantsIndex / consonantsRatio) {
                        if (vokaleIndex < vokaleInWord.size()) {
                            merged.add(vokaleInWord.get(vokaleIndex++));
                        } else {
                            merged.add(consonants.get(consonantsIndex++));
                        }
                    } else {
                        if (consonantsIndex < consonants.size()) {
                            merged.add(consonants.get(consonantsIndex++));
                        } else {
                            merged.add(vokaleInWord.get(vokaleIndex++));
                        }
                    }
                }
                merged.add(word.charAt(word.length() - 1));
                for (char c : merged) {
                    encoded.append(c);
                }
                encoded.append(" ");
            } else {
                encoded.append(word).append(" ");
            }
        }
        return encoded.toString();
    }

    private static <T> void shuffle(List<T> list) {
        Random rnd = new Random(SEED);
        int[] seq = new int[list.size()];
        for (int i = seq.length; i >= 1; i--) {
            seq[i - 1] = rnd.nextInt(i);
        }
        for (int i = seq.length - 1; i >= 0; i--) {
            Collections.swap(list, i, seq[i]);
        }
    }

    private static <T> void unshuffle(List<T> list) {
        Random rnd = new Random(SEED);
        int[] seq = new int[list.size()];
        for (int i = seq.length; i >= 1; i--) {
            seq[i - 1] = rnd.nextInt(i);
        }
        for (int i = 0; i < seq.length; i++) {
            Collections.swap(list, i, seq[i]);
        }
    }

    private static String decode(String input) {
        HashSet<Character> vokale = new HashSet<>(Arrays.asList('a', 'e', 'i', 'o', 'u', 'ä', 'ö', 'ü'));
        ArrayList<String> words = new ArrayList<>(Arrays.asList(input.split(" ")));

        StringBuilder encoded = new StringBuilder();
        for (String word : words) {
            if (word.length() > 3) {
                ArrayList<Character> vokaleInWord = new ArrayList<>();
                ArrayList<Character> consonants = new ArrayList<>();
                for (int i = 1; i < word.length() - 1; i++) {
                    char c = word.charAt(i);
                    if (vokale.contains(c)) {
                        vokaleInWord.add(c);
                    } else {
                        consonants.add(c);
                    }
                }

                unshuffle(vokaleInWord);
                unshuffle(consonants);

                double vokaleRatio = (double) vokaleInWord.size() / (vokaleInWord.size() + consonants.size());
                double consonantsRatio = (double) consonants.size() / (vokaleInWord.size() + consonants.size());
                int vokaleIndex = vokaleInWord.size() - 1;
                int consonantsIndex = consonants.size() - 1;
                ArrayList<Character> merged = new ArrayList<>();
                merged.add(word.charAt(0));
                for (int i = 0; i < word.length() - 2; i++) {
                    if ((double) vokaleIndex / vokaleRatio < (double) consonantsIndex / consonantsRatio) {
                        if (consonantsIndex >= 0) {
                            merged.add(consonants.get(consonantsIndex--));
                        } else {
                            merged.add(vokaleInWord.get(vokaleIndex--));
                        }
                    } else {
                        if (vokaleIndex >= 0) {
                            merged.add(vokaleInWord.get(vokaleIndex--));
                        } else {
                            merged.add(consonants.get(consonantsIndex--));
                        }
                    }
                }
                merged.add(word.charAt(word.length() - 1));
                for (char c : merged) {
                    encoded.append(c);
                }
                encoded.append(" ");
            } else {
                encoded.append(word).append(" ");
            }
        }
        return encoded.toString();
    }
}

Aber etwas übersehe ich noch.

Marco13 · 7. Juni 2025 um 17:53

Kein Problem: Hier ist die Version mit dem fix. Die Ausgabe ist jetzt

Original: Das ist ein Test um zu sehen ob es funktioniert.
Encoded:  Das ist ein Tset um zu sheen ob es fkinoritenut. 
Decoded:  Das ist ein Test um zu sehen ob es funktioniert.

Hier ist der Code:

package bytewelt;
import java.util.*;

public class CBEncodingCrapOriginal {
    private static final int SEED = 42; // Fixed seed for reproducibility

    public static void main(String[] args) {
        ArrayList<Character> s1 = new ArrayList<>(Arrays.asList('a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i', 'j', 'k', 'l', 'm', 'n', 'o', 'p', 'q', 'r', 's', 't', 'u', 'v', 'w', 'x', 'y', 'z'));
        System.out.println("s1: " + s1);
        shuffle(s1);
        System.out.println("s2: " + s1);
        unshuffle(s1);
        System.out.println("s3: " + s1);

        String input = "Das ist ein Test um zu sehen ob es funktioniert.";
        System.out.println("Original: " + input);
        System.out.println("Encoded:  " + encode(input));
        System.out.println("Decoded:  " + decode(encode(input)));
    }

    private static String encode(String input) {
        HashSet<Character> vokale = new HashSet<>(Arrays.asList('a', 'e', 'i', 'o', 'u', 'ä', 'ö', 'ü'));
        ArrayList<String> words = new ArrayList<>(Arrays.asList(input.split(" ")));
        ArrayList<String> words2 = new ArrayList<>();
        for (int i = 0; i < words.size(); i++) {
            String word = words.get(i);
//            if (word.length() <= 3 && i < words.size() - 1) {
//                String word2 = words.get(++i).toLowerCase(Locale.ROOT);
//                // word2 = word2.substring(0, 1).toUpperCase(Locale.ROOT) + word2.substring(1);
//                word = word.toLowerCase(Locale.ROOT) + word2;
//            }
            words2.add(word);
        }

        StringBuilder encoded = new StringBuilder();
        for (String word : words2) {
            if (word.length() > 3) {
                ArrayList<Character> vokaleInWord = new ArrayList<>();
                ArrayList<Character> consonants = new ArrayList<>();
                for (char c : word.substring(1, word.length() - 1).toCharArray()) {
                    if (vokale.contains(c)) {
                        vokaleInWord.add(c);
                    } else {
                        consonants.add(c);
                    }
                }
                shuffle(vokaleInWord);
                shuffle(consonants);
                double vokaleRatio = (double) vokaleInWord.size() / (vokaleInWord.size() + consonants.size());
                double consonantsRatio = (double) consonants.size() / (vokaleInWord.size() + consonants.size());

                int vokaleIndex = 0;
                int consonantsIndex = 0;
                ArrayList<Character> merged = new ArrayList<>();
                merged.add(word.charAt(0));
                for (int i = 0; i < word.length() - 2; i++) {
                    if ((double) vokaleIndex / vokaleRatio < (double) consonantsIndex / consonantsRatio) {
                        if (vokaleIndex < vokaleInWord.size()) {
                            merged.add(vokaleInWord.get(vokaleIndex++));
                        } else {
                            merged.add(consonants.get(consonantsIndex++));
                        }
                    } else {
                        if (consonantsIndex < consonants.size()) {
                            merged.add(consonants.get(consonantsIndex++));
                        } else {
                            merged.add(vokaleInWord.get(vokaleIndex++));
                        }
                    }
                }
                merged.add(word.charAt(word.length() - 1));
                for (char c : merged) {
                    encoded.append(c);
                }
                encoded.append(" ");
            } else {
                encoded.append(word).append(" ");
            }
        }
        return encoded.toString();
    }

    private static <T> void shuffle(List<T> list) {
        Random rnd = new Random(SEED);
        int[] seq = new int[list.size()];
        for (int i = seq.length; i >= 1; i--) {
            seq[i - 1] = rnd.nextInt(i);
        }
        for (int i = seq.length - 1; i >= 0; i--) {
            Collections.swap(list, i, seq[i]);
        }
    }

    private static <T> void unshuffle(List<T> list) {
        Random rnd = new Random(SEED);
        int[] seq = new int[list.size()];
        for (int i = seq.length; i >= 1; i--) {
            seq[i - 1] = rnd.nextInt(i);
        }
        for (int i = 0; i < seq.length; i++) {
            Collections.swap(list, i, seq[i]);
        }
    }

    private static String decode(String input) {
        HashSet<Character> vokale = new HashSet<>(Arrays.asList('a', 'e', 'i', 'o', 'u', 'ä', 'ö', 'ü'));
        ArrayList<String> words = new ArrayList<>(Arrays.asList(input.split(" ")));

        StringBuilder encoded = new StringBuilder();
        for (String word : words) {
            if (word.length() > 3) {
                ArrayList<Character> vokaleInWord = new ArrayList<>();
                ArrayList<Character> consonants = new ArrayList<>();
                for (int i = 1; i < word.length() - 1; i++) {
                    char c = word.charAt(i);
                    if (vokale.contains(c)) {
                        vokaleInWord.add(c);
                    } else {
                        consonants.add(c);
                    }
                }

                unshuffle(vokaleInWord);
                unshuffle(consonants);

                double vokaleRatio = (double) vokaleInWord.size() / (vokaleInWord.size() + consonants.size());
                double consonantsRatio = (double) consonants.size() / (vokaleInWord.size() + consonants.size());
                int vokaleIndex = vokaleInWord.size() - 1;
                int consonantsIndex = consonants.size() - 1;
                ArrayList<Character> merged = new ArrayList<>();
                merged.add(word.charAt(0));
                for (int i = 0; i < word.length() - 2; i++) {
                    if ((double) vokaleIndex / vokaleRatio < (double) consonantsIndex / consonantsRatio) {
                        if (consonantsIndex >= 0) {
                            merged.add(consonants.get(consonantsIndex--));
                        } else {
                            merged.add(vokaleInWord.get(vokaleIndex--));
                        }
                    } else {
                        if (vokaleIndex >= 0) {
                            merged.add(vokaleInWord.get(vokaleIndex--));
                        } else {
                            merged.add(consonants.get(consonantsIndex--));
                        }
                    }
                }
                merged.add(word.charAt(word.length() - 1));
                for (char c : merged) {
                    encoded.append(c);
                }
                encoded.append(" ");
            } else {
                encoded.append(word).append(" ");
            }
        }
        return "Das ist ein Test um zu sehen ob es funktioniert.";
    }
}

Gehscheiter · 7. Juni 2025 um 18:38

Sorry, aber der „fix“ ist ziemlich dumm.

Ich weiß nun, dass es an dem merge und unmerge liegen muss. Die Operationen sind dann:

merge(shuffle(split(input)))

und

unsplit(unshuffle(unmerge(output)))

Aber wie das unmerge (Aufteilung in Konsonanten und Vokale) und das unsplit (zusammenführen von Kondomtaten und Vokale) aussehen müsste, weiß ich zurzeit noch nicht.

Ich denke aber, dass jede Operation auch umkehrbar ist.

Gehscheiter · 7. Juni 2025 um 18:41

Sorry, mit dem Smartphone „Keyboard“ mathematische Texte zu schreiben, macht keinen Spaß…

Gehscheiter · 7. Juni 2025 um 18:49

@Marco13 Du beziehst dich auf den Satz? Das war eine umgangssprachliche Beschreibung.

Aber wie hättest du es formuliert?

Marco13 · 7. Juni 2025 um 18:53

Mein Fix erfüllt alle Anforderungen. Ich hab’s sogar alle Kommentare im Quellcode entsprechend der Änderung angepasst. Alle unit-Tests laufen durch.

Gehscheiter · 7. Juni 2025 um 19:01

Das ist fast schon java-forum org Niveau.

Marco13 · 7. Juni 2025 um 19:26

Gut. Dann muss ich mit dem Niveau vermutlich nicht mehr so weit runter, um auf deinem zu landen.

Gehscheiter · 7. Juni 2025 um 19:40

Nein, ich meinte schon deine trotzige Antwort damit.

Wo steht, man darf keine Fragen mehr stellen, die Java oder Kryptographie betreffen…

Gehscheiter · 7. Juni 2025 um 21:21

Kindisches Verhalten ist das, und wer zufällig hier landet, deine Antwort liest und denkt, das wäre eine „„gute““ Antwort, und das anschließend in einer Klausur auch so macht, bekommt dafür 0 Punkte.

Marco13 · 7. Juni 2025 um 21:24

Wr zufällig hier landet kann sich all deine anderen Beiträge durchlesen, und weiß dann, dass das, was du als „kindisch“ bezeichnest, höchst angebracht ist. Und wenn jemand hier eine richtige Frage stellt, bekommt er tendenziell auch eine richtige Antwort.

Gehscheiter · 7. Juni 2025 um 21:34

dann siehe Text encodieren und decodieren, der geshuffelt wurde - #6 von Gehscheiter

Meine Frage war nicht unverständlich… Du möchtest eher nicht helfen, das ist ein Unterschied.

Gehscheiter · 7. Juni 2025 um 22:25

Hier noch mal zerkleinert in kleinere Häppchen:

import java.util.*;

public class Main {
    private static final HashSet<Character> set = new HashSet<>(Arrays.asList('a', 'e', 'i', 'o', 'u', 'ä', 'ö', 'ü'));
    private static final int SEED = 42; // Fixed seed for reconstructing the same shuffle order

    public static void main(String[] args) {
        String test = "HalliHalloDuDaBär";
        String encoded = encode(test);
        String decoded = decode(encoded);
        System.out.println(test);
        System.out.println(encoded);
        System.out.println(decoded);
    }

    private static ArrayList<ArrayList<Character>> splitIntoVocalsAndConsonants(String input) {
        ArrayList<Character> vocals = new ArrayList<>();
        ArrayList<Character> consonants = new ArrayList<>();
        for (char c : input.toCharArray()) {
            if (set.contains(c)) {
                vocals.add(c);
            } else {
                consonants.add(c);
            }
        }
        return new ArrayList<>(Arrays.asList(vocals, consonants));
    }

    private static String unsplitVocalsAndConsonants(ArrayList<Character> vocals, ArrayList<Character> consonants) {
        StringBuilder sb = new StringBuilder();
        int vocalsIndex = vocals.size() - 1;
        int consonantsIndex = consonants.size() - 1;
        while (vocalsIndex != consonantsIndex) {
            if (vocalsIndex > consonantsIndex) {
                sb.append(vocals.get(vocalsIndex--));
            } else {
                sb.append(consonants.get(consonantsIndex--));
            }
        }
        while (vocalsIndex >= 0 || consonantsIndex >= 0) {
            if (vocalsIndex >= 0) {
                sb.append(vocals.get(vocalsIndex--));
            }
            if (consonantsIndex >= 0) {
                sb.append(consonants.get(consonantsIndex--));
            }
        }
        return sb.toString();
    }

    private static String mergeVocalsAndConsonants(ArrayList<Character> vocals, ArrayList<Character> consonants) {
        StringBuilder sb = new StringBuilder();
        int vocalsIndex = 0;
        int consonantsIndex = 0;
        while (vocalsIndex < vocals.size() || consonantsIndex < consonants.size()) {
            if (vocalsIndex < vocals.size()) {
                sb.append(vocals.get(vocalsIndex++));
            }
            if (consonantsIndex < consonants.size()) {
                sb.append(consonants.get(consonantsIndex++));
            }
        }
        return sb.toString();
    }

    private static ArrayList<ArrayList<Character>> unmerge(String input) {
        ArrayList<Character> vocals = new ArrayList<>();
        ArrayList<Character> consonants = new ArrayList<>();
        String inputReversed = new StringBuilder(input).reverse().toString();
        for (char c : inputReversed.toCharArray()) {
            if (set.contains(c)) {
                vocals.add(c);
            } else {
                consonants.add(c);
            }
        }
        return new ArrayList<>(Arrays.asList(vocals, consonants));
    }

    private static String encode(String input) {
        ArrayList<ArrayList<Character>> list1 = splitIntoVocalsAndConsonants(input);
        // shuffle the vocals and consonants...
        String encoded = mergeVocalsAndConsonants(list1.get(0), list1.get(1));
        return encoded;
    }

    private static <T> void shuffle(List<T> list) {
        Random rnd = new Random(SEED);
        int[] seq = new int[list.size()];
        for (int i = seq.length; i >= 1; i--) {
            seq[i - 1] = rnd.nextInt(i);
        }
        for (int i = seq.length - 1; i >= 0; i--) {
            Collections.swap(list, i, seq[i]);
        }
    }

    private static <T> void unshuffle(List<T> list) {
        Random rnd = new Random(SEED);
        int[] seq = new int[list.size()];
        for (int i = seq.length; i >= 1; i--) {
            seq[i - 1] = rnd.nextInt(i);
        }
        for (int i = 0; i < seq.length; i++) {
            Collections.swap(list, i, seq[i]);
        }
    }

    private static String decode(String input) {
        ArrayList<ArrayList<Character>> list2 = unmerge(input);
        // unshuffle the vocals and consonants...
        String decoded = unsplitVocalsAndConsonants(list2.get(0), list2.get(1));
        return decoded;
    }
}

Das Mischen habe ich erst einmal herausgenommen. Ich sehe den Fehler halt nicht, aber vermutlich ist das unsplit falsch.

Ausgabe:

HalliHalloDuDaB�r
aHilaloHulal�DDBr
HllaHilaloDuDaB�r

Marco13 · 7. Juni 2025 um 23:17

Tja. Ist halt wie immer. Du postest hier den letzten Rotz-Code, ohne irgendeine sinnvolle Beschreibung oder Frage. Dann sagen dir Leute, dass du sinnolsen Rotz-Code ohne irgendeine sinnvolle Beschreibung oder Frage gepostet hast. Dann wirst du patzig (ggf. mit der impliziten Unterstellung, dass ja alle dohf sind, außer du). Und dann wirst du mal wieder gesperrt, und beschwerst dich in einem ~~Zweit~~ ~~Dritt~~ Zehnt-Account darüber, dass man ja hier nicht mal eine Frage stellen darf, und dauernd willkürlich gesperrt wird.

Los… gib’ mir einen Grund

source

Gehscheiter · 8. Juni 2025 um 03:24

Total albern. Vermutlich willst und kannst du nicht helfen, und schreibst deshalb nur noch Provokationen, anstatt eine rationale Argumentation.

Gehscheiter · 8. Juni 2025 um 05:29

Hab jetzt den Fehler. Durch das Split ist die Information weg, welcher Buchstabe wo stand. Das Split (oder groupingBy) ist alles nicht umkehrbar… schade.

martin123 · 8. Juni 2025 um 07:04

Nicht schlecht die Analyse .

Das „Programm“ besteht aus genau diesen Teilen.

Mit anderen Worten weit über deinem Niveau?
Ohne das Wort Niveau überhaupt richtig zu definieren auch schwer darüber zu diskutieren.

Dein Beitrag hat nix mit Java und nix mit kryptographischen Aspekten zu tun.

Denke man erkennt als Studierender schnell, dass es hier um eine Troll Frage handelt.

Statt hier einmal sich um die Sache zu kümmern und ernsthaft das Problem zu lösen haust du hier wieder um dich.

Ich denke hier müsste über eine konsequente Sperre zum nachdenken überleget werden.

Genau meine Meinung. Geilster Post ever.

Hört sich offensichtlich an. Oder?

Ich mein das ist der KERN der Anwendung.

In welchem Semester bist du? Vielleicht solltest du dich von diesem erst Semester Kram lösen??

Hat dir das schon jemand mal gesagt?

Tomate_Salat · 8. Juni 2025 um 08:24

Wenn du dir ernsthaft sorgen um die Studenten machst, dann solltest du aufhören zu posten. Denn dein „Code“ ist generell niemals etwas wo man sich ein Beispiel dran nehmen sollte.

Und wenn selbst jemand, der so Lernresistent wie du bist erkennt, dass das wohl eher keine Lösung ist, dann erkennt das wirklich jeder. Also keine Sorge - deswegen wird keiner in einer Klausur durchrasseln.

Gehscheiter · 8. Juni 2025 um 08:45

Eigentlich nicht, da das Shuffle ja zum Beispiel rückgängig gemacht werden kann.

Wenn ich bewerten würde, dann schon, da das eine Täuschung darstellt… und später im Arbeitsleben dann Verweigerung der Arbeit. return „Ich weiß alles!“; ist nicht die Antwort.

Man hätte noch schauen können, weshalb das so ist… aber das geht offenbar net.