Cómo mezclar caracteres en una cadena

Question

Cómo mezclar los caracteres en una cadena (por ejemplo, hola podría ser ehlol o lleoh o ...). No quiero usar el método Collections.shuffle(...), ¿hay algo más simple?

Answer 1

No sé nada más simple. Sin embargo, se puede utilizar la funcionalidad Math.rand() para generar un número aleatorio dentro del rango de la longitud del personaje sin sustituir y que le daría una salida de barajado

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

Se podría iterar sobre todos los personajes, la comparación de cada uno con el siguiente Luego, si Math.rand()> 0.5 intercambian este carácter con el siguiente, de lo contrario pasen al siguiente caracter.

Answer 3

Ej:

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); 
    } 
} 

Salida: ahlol

Answer 5

No es un gran rendimiento, pero bastante legible en mi opinión:

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

Aquí está el código que no requiere ni la recursividad, ni convirtiendo a una Colección.

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

No estoy seguro de por qué no quieres usar el orden aleatorio, a menos que sea para la escuela. ;)

Y si le preocupa el rendimiento, definitivamente no puede usar ninguna solución que concatene cadenas con "+".

Aquí está la solución más compacta que podía llegar a:

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

¿Qué tal esto:

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

Lo que un problema molesto. Finalmente terminé con esto:

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í, dos bibliotecas :)

Answer 11

Si aún desea restaurar el original String más adelante, intentar algo como esto:

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()); 
}