Comment puis-je mélanger les lettres d'un mot?

Quel est le moyen le plus facile à mélanger les lettres d'un mot qui est dans un tableau? J'ai quelques mots dans un tableau et j'ai à choisir au hasard un mot, mais que je tiens aussi à mélanger les lettres.

public static void main (String[] args ) {
    String [] animals = { "Dog" , "Cat" , "Dino" } ;    
    Random random = new Random();
    String word = animals [random.nextInt(animals.length)];

    System.out.println ( word ) ;
    //I Simply want to shuffle the letters of word     
}

Je suis censée ne pas utiliser cette Liste de chose. Je suis venu avec quelque chose comme ça, mais avec ce code, il tirages aléatoires de lettres, il n'est pas aléatoire. Peut-être que je peux la coder quelque chose comme ne pas imprimer si cette lettre est déjà imprimé?

//GET RANDOM LETTER
for (int i = 0; i< word.length(); i++ ) {

char c = (word.charAt(random.nextInt(word.length())));
System.out.print(c); } 
  }

Montrer uw ce que vous avez essayé 🙂
double possible de Comment shuffle caractères dans une chaîne de caractères
J'ai déjà visité cette page la liste des utilisations et je ne peux pas l'utiliser.
ajoutez ensuite à cette exigence dans votre question. De Plus, il y a quelques réponses que ne pas utiliser des listes
réfléchir à nouveau sur votre shuffle méthode. vous imprimez un caractère aléatoire, mais n'ont aucune protection contre l'impression que le même personnage à chaque fois. vous devez supprimer les caractères à partir de la parole que de les imprimer.

OriginalL'auteur morgothraud | 2013-12-14

Vraiment pas besoin pour la collecte et rien de plus que ce qui suit:

public static void main(String[] args) {

    //Create a random object
    Random r = new Random();

    String word = "Animals";

    System.out.println("Before: " + word );
    word = scramble( r, word );
    System.out.println("After : " + word );
}

public static String scramble( Random random, String inputString )
{
    //Convert your string into a simple char array:
    char a[] = inputString.toCharArray();

    //Scramble the letters using the standard Fisher-Yates shuffle, 
    for( int i=0 ; i<a.length ; i++ )
    {
        int j = random.nextInt(a.length);
        //Swap letters
        char temp = a[i]; a[i] = a[j];  a[j] = temp;
    }       

    return new String( a );
}

Pourquoi à l'aide de a.length-1 lorsque la condition est < plutôt que d'utiliser a.length. Lorsque la limitation de < a.length-1 le dernier caractère reste toujours à la même place. Lors de l'utilisation de < a.length et random.nextInt(a.length) le dernier caractère obtient également considéré dans le battage du processus, mais d'autres que cette solution a travaillé un régal! Grâce à @Rastikan
J'ai édité l'algorithme également shuffle le dernier caractère que par mes propres test et @mkli90 commentaire.

OriginalL'auteur Rastikan

Vous pouvez utiliser Collections.shuffle :

List<Character> l = new ArrayList<>();
for(char c :  word.toCharArray()) //for each char of the word selectionned, put it in a list
    l.add(c); 
Collections.shuffle(l); //shuffle the list

StringBuilder sb = new StringBuilder(); //now rebuild the word
for(char c : l)
  sb.append(c);

word = sb.toString();

Je suis censée ne pas utiliser cette Liste de chose.

Ensuite, vous pouvez créer deux StringBuilder objets. On tiendra le mot d'origine et on va créer le mélangées :

StringBuilder s = new StringBuilder(word);
StringBuilder wordShuffled = new StringBuilder();
while(s.length() != 0){
    int index = random.nextInt(s.length());
    char c = s.charAt(index);
    wordShuffled.append(c);
    s.deleteCharAt(index);
}
System.out.println(wordShuffled.toString());

J'ai trouvé quelque chose comme deleteCharAt mais je suppose que cela fonctionne avec
StringBuilder ou quelque chose. Je ne peux pas l'utiliser

Ici vous pouvez trouver quelques belles utilitaires de méthodes qui permet de mélanger un tableau.

public static char[] shuffleArray(char[] x) {    
       for ( int i = x.length; i > 0; i-- ) {
            int rand = (int)(Math.random()*(i));
            char temp = x[i-1];
            x[i-1] = x[rand];
            x[rand] = temp;
        }
       return x;
}

Puis il suffit d'appeler cette méthode et utiliser le constructeur String(char[] value) :

System.out.println(new String(shuffleArray(word.toCharArray())));

La prochaine fois, clairement, ce que vous pouvez utiliser/ne pas utiliser.

OriginalL'auteur Alexis C.

Comment quelque chose comme cela?

//Shuffle an array of characters.
public static void shuffleArray(char[] a) {
  int n = a.length; //the length of the array.
  for (int i = 0; i < n; i++) {
    int t = random.nextInt(n); //pick a random number 0 - the length.
    if (t == i) {              //if the random number is the loop counter
      if (i > 0) {             //check if we're at the first element.
        t = random.nextInt(i); //pick another number between 0 - and the loop counter.
      } else {
        t = a.length - 1;      //the end of the loop.
      }
    }
    a[i] ^= a[t];              //swap a[i] and a[t]
    a[t] ^= a[i];
    a[i] ^= a[t];
  }
}

private static Random random = new Random(); //the shared random.

public static void main(String[] args) {
  String[] animals = { "Dog", "Cat", "Dino" };
  String word = animals[random
      .nextInt(animals.length)];

  System.out.println(word);            //the random word.
  char[] arr = word.toCharArray();     //the char[] from the word.
  shuffleArray(arr);                   //shuffle it.
  System.out.println(new String(arr)); //print it.
}

Cela fonctionne comme je veux, mais pouvez-vous nous expliquer le swap partie parce que je n'ai aucune ide de ce que ^= et pourquoi sommes-nous permutation de 3 fois. @Elliott Frisch
C'est le XOR de swap. en.wikipedia.org/wiki/XOR_swap_algorithm

OriginalL'auteur Elliott Frisch

Vous devez vous connecter pour publier un commentaire.