Scramble un Mot à l'aide de Java

J'ai voulu brouiller une Chaîne, afin de le rendre illisible et donc est venu avec cette méthode:

public String scrambleWord(String start_word){

     char[] wordarray = start_word.toCharArray();

        char[] dummywordarray = start_word.toCharArray();

        Random random = new Random();

        int r = random.nextInt(wordarray.length-1);
        int i = 0;

        int j = r+1;

        while(i <= r){

            dummywordarray[wordarray.length -i-1] = wordarray[i];

            i++;
        }


        while (j <= wordarray.length -1){

            dummywordarray[j-r-1] = wordarray[j];

            j++;

        }

        String newword = String.valueOf(dummywa);



        return newword;

J'ai DONC d'abord converti la chaîne en un tableau de char, et dans ma méthode j'ai dû reproduire le char array "dummywordarray". En passant une seule fois grâce à cet algorithme, chaque lette rof la parole aura changé de position. Mais il ne sera pas brouillés très bien, dans le sens que vous pourriez vous remettre ensemble un coup d'œil.
J'ai DONC passé une Chaîne de moins de 9 caractères à l'aide de la méthode de 7 fois, et les mots sont assez bien codé, c'est à dire illisible.
Mais je l'ai essayé avec un 30 chaîne de caractères, et il a fallu 500 passe avant que je puisse le garantir il a été bien brouillés. 500!
Je suis sûr qu'il y est un meilleur algorithme, j'aimerais avoir quelques conseils sur
a)l'amélioration de cette méthode
ou
b)une meilleure façon.

  • Qu'entendez-vous par "Bien Brouillés'
  • Voulez-vous simplement d'une façon aléatoire de lettres, et il sera irrécupérable plus tard? Ou avez-vous réellement envie d'un algorithme de chiffrement pour créer un réversibles shuffle?
  • Bien brouillés est assez subjective. Je suis désolé, je ne peux pas vous donner une définition correcte. Si le mot d'origine est le fauteur de troubles, alors makerelbuort, tromakbleuer ne sont pas "bien scarmbled. Vous pouvez les remettre ensemble après cinq secondes.
  • Il n'est pas nécessaire de les inverser. Je veux juste une belle shuffle qui est efficace.
  • La nature de l'aléatoire est que, parfois, "fauteur de troubles" sera au hasard brouillés comme "fauteur de troubles". La capacité de l'esprit humain pour résoudre des anagrammes ou des fatras à différents stades de la "shuffledness" est un problème beaucoup plus important qui a peu à voir avec la programmation de l'OMI.
  • Merci Mark Peters. Je sais qu'il y a des valeurs aberrantes où peut-être même le mot d'origine pourraient revenir. Mais pour la majeure partie des cas, quand j'ai mis mon 30 caractères phrase (sans les espaces) dans l'algorithme, le plus souvent, il a été mis-dos-ensemble-mesure, sans beaucoup d'effort mental, à moins que je passe par la méthode ci-dessus, des centaines de fois. Je suppose que c'est prévu que j'aurais à exécuter la parole par le biais de la méthode à plusieurs reprises, mais j'ai pensé 500+, poussant raisonnable.
  • Dans ce cas, les Collections.shuffle est un bon algorithme. Il garantit que chaque permutation est tout aussi probable.

InformationsquelleAutor | 2010-11-22
  1. 19

    Comment sur

    ArrayList<Character> chars = new ArrayList<Character>(word.length());
for ( char c : word.toCharArray() ) {
   chars.add(c);
}
Collections.shuffle(chars);
char[] shuffled = new char[chars.size()];
for ( int i = 0; i < shuffled.length; i++ ) {
   shuffled[i] = chars.get(i);
}
String shuffledWord = new String(shuffled);

    En d'autres termes, vous pouvez prendre avantage de l'existant java.util.Les Collections.shuffle(Liste) méthode. Malheureusement, vous devez sauter à travers quelques cerceaux pour l'utiliser, puisque vous ne pouvez pas utiliser les primitives dans les Génériques.

    Edit:

    Le fonctionnement de base de shuffle œuvres (voir la Javadoc pour l'explication complète), est comme ceci:

    for position = last_index to first_index
   let swap_pos = random number between first_index and position, inclusive
   swap(swap_pos, position)

    Edit 2:

    Cette approche est beaucoup moins verbeux avec la Goyave est Caractères utilitaires:

    List<Character> chars = Chars.asList(word.toCharArray());
Collections.shuffle(chars);
String shuffledWord = new String(Chars.toArray(chars));
    • Simple et sympathique. Vous pouvez utiliser des Tableaux.asList(mot.toCharArray()) pour réduire davantage.
    • Je pense que ce serait List<char[]> depuis Character[] n'est pas le même que char[].
    • Merci, je vais regarder à cela. Je n'ai beaucoup d'expérience avec les médicaments Génériques, mais je vais donner un coup de feu. Mais savez-vous de l'algorithme dans le suffle(liste) méthode? Je me demande juste comment ils le font.
    • Pouvez-vous utiliser char[] shuffled = chars.ToArray(char[] shuffled) pour supprimer la deuxième for de construire?
    • Non, malheureusement, ça ne compile pas, de nouveau, car char n'est pas applicable pour un paramètre de type générique.
    • Le lien que j'ai inclus les points de la Javadoc, qui va dans le détail sur la façon dont le shuffle algorithme fonctionne. Je vais mettre un résumé dans mon post.
    • Notez que c'est un Knuth shuffle ou shuffle de Fisher–Yates. en.wikipedia.org/wiki/Shuffling#Randomization
    • Il semble que mon algorithme de calcul est plus lourd qu'il n'en faut ot, par une grande marge. Bien que l'avantage de mon shuffle est qu'il me permet de définir le degré de la "difficulté" de la lecture aléatoire (compte tenu de l'aléatoire d'un mot, pas de cartes).

    InformationsquelleAutor Mark Peters