Come mescolare i caratteri in una stringa

Question

Come mescolare i caratteri in una stringa (ad esempio, ciao potrebbe essere ehlol o lleoh o ...). Non voglio usare il metodo Collections.shuffle(...), c'è qualcosa di più semplice?

Answer 1

Non so nulla di più semplice. Ma è possibile utilizzare la funzionalità Math.rand() per generare un numero casuale all'interno della gamma della lunghezza del personaggio senza sostituire e che darebbe un'uscita mescolate

public class Shuffle { 
    public static void main(String[] args) { 
     Shuffle s = new Shuffle(); 
     s.shuffle("hello"); 

    } 
    public void shuffle(String input){ 
     List<Character> characters = new ArrayList<Character>(); 
     for(char c:input.toCharArray()){ 
      characters.add(c); 
     } 
     StringBuilder output = new StringBuilder(input.length()); 
     while(characters.size()!=0){ 
      int randPicker = (int)(Math.random()*characters.size()); 
      output.append(characters.remove(randPicker)); 
     } 
     System.out.println(output.toString()); 
    } 
} 
/* 
Sample outputs 
hlleo 
llheo 
leohl 
lleho 
*/ 

Answer 2

Si potrebbe iterare su tutti i personaggi, confrontando ogni uno con il prossimo. Quindi se Math.rand()> 0.5 scambia questo carattere con il prossimo, altrimenti passa al carattere successivo.

Answer 3

Esempio:

static String shuffle(String text){ 
    if (text.length()<=1) 
     return text; 

    int split=text.length()/2; 

    String temp1=shuffle(text.substring(0,split)); 
    String temp2=shuffle(text.substring(split)); 

    if (Math.random() > 0.5) 
     return temp1 + temp2; 
    else 
     return temp2 + temp1; 
}  

Answer 4

class ShuffleString 
{ 

    public static String shuffle(String s) 
    { 

     String shuffledString = ""; 

     while (s.length() != 0) 
     { 
      int index = (int) Math.floor(Math.random() * s.length()); 
      char c = s.charAt(index); 
      s = s.substring(0,index)+s.substring(index+1); 
      shuffledString += c; 
     } 

     return shuffledString; 

    } 

} 


public class foo{ 
    static public void main(String[] args) 
    { 

     String test = "hallo"; 
     test = ShuffleString.shuffle(test); 
     System.out.println(test); 
    } 
} 

uscita: ahlol

Answer 5

Non grandi prestazioni, ma abbastanza leggibile, a mio parere:

public static String shuffleString(String string) 
{ 
    List<String> letters = Arrays.asList(string.split("")); 
    Collections.shuffle(letters); 
    String shuffled = ""; 
    for (String letter : letters) { 
    shuffled += letter; 
    } 
    return shuffled; 
} 

Answer 6

Ecco il codice che non richiede né la ricorsione, nè conversione in una raccolta.

public static String shuffle(String string) { 
    StringBuilder sb = new StringBuilder(string.length()); 
    double rnd; 
    for (char c: string.toCharArray()) { 
     rnd = Math.random(); 
     if (rnd < 0.34) 
      sb.append(c); 
     else if (rnd < 0.67) 
      sb.insert(sb.length()/2, c); 
     else 
      sb.insert(0, c); 
    }  
    return sb.toString(); 
} 

Answer 7

Non so perché non si voglia usare la riproduzione casuale, a meno che non sia per la scuola. ;)

E se si è interessati alle prestazioni, non si può assolutamente utilizzare alcuna soluzione che concatena stringhe con "+".

Ecco la soluzione più compatta potevo venire con:

public static String shuffle(String string) { 
    if (StringUtils.isBlank(string) { 
     return string; 
    } 

    final List<Character> randomChars = new ArrayList<>(); 
    CollectionUtils.addAll(randomChars, ArrayUtils.toObject(string.toCharArray())); 
    Collections.shuffle(randomChars); 
    return StringUtils.join(randomChars, ""); 
} 

Answer 8

ne dite di questo:

public static String shuffle(String text) { 
    char[] characters = text.toCharArray(); 
    for (int i = 0; i < characters.length; i++) { 
     int randomIndex = (int)(Math.random() * characters.length); 
     char temp = characters[i]; 
     characters[i] = characters[randomIndex]; 
     characters[randomIndex] = temp; 
    } 
    return new String(characters); 
} 

Answer 9

 String shuffled; 
     do { 
      shuffled = Stream.of(text.split("")).sorted((o1, o2) -> ThreadLocalRandom.current().nextInt(3) - 1).collect(Collectors.joining()); 
     }while(shuffled.equals(text)); 

Answer 10

Che un fastidioso problema. Alla fine ho finito con questo:

import java.util.Collections; 
import com.google.common.primitives.Chars; 
import org.apache.commons.lang3.StringUtils; 

String shuffle(String s) { 
    List<Character> chars = Chars.asList(s.toCharArray()); 
    Collections.shuffle(chars); 
    return StringUtils.join(chars.stream().toArray()); 
} 

Sì, due biblioteche :)

Answer 11

Se si vuole ancora per ripristinare l'originale String più tardi, provare qualcosa di simile:

public static class ShuffledString 
{ 
    private List<Integer> indices; 
    private String string; 

    public ShuffledString(List<Integer> indices, String string) 
    { 
     this.indices = indices; 
     this.string = string; 
    } 

    public List<Integer> getIndices() 
    { 
     return indices; 
    } 

    public String getRegularString() 
    { 
     StringBuilder stringBuilder = new StringBuilder(); 

     for (int stringIndex = 0; stringIndex < indices.size(); stringIndex++) 
     { 
      int characterIndex = indices.indexOf(stringIndex); 
      stringBuilder.append(string.charAt(characterIndex)); 
     } 

     return stringBuilder.toString(); 
    } 
} 

public static ShuffledString shuffle(String input) 
{ 
    List<Integer> indices = new ArrayList<>(); 

    StringBuilder output = new StringBuilder(input.length()); 
    while (indices.size() < input.length()) 
    { 
     int randomIndex; 

     while (indices.contains(randomIndex = (int) (Math.random() * input.length()))) 
     { 

     } 

     indices.add(randomIndex); 
     output.append(input.charAt(randomIndex)); 
    } 

    return new ShuffledString(indices, output.toString()); 
}