Algoritmo de lectura curiosa Java

CRoS #1 Mar '11

Tengo que crear un programa el cual dado un texto te lo modifique tal que así.

“Sgeun un etsduio de una uivenrsdiad ignlsea, no ipmotra el odren en el que las ltears etsan ersciats, la uicna csoa ipormtnate es que la pmrirea y la utlima ltera esten ecsritas en la psiocion cocrrtea. El rsteo peuden estar ttaolmntee mal y aun pordas lerelo sin pobrleams. Etso es pquore no lemeos cada ltera por si msima snio la paalbra cmoo un tdoo. Pesornamelnte me preace icrneilbe..."

Se me han ocurrido varias ideas, pero con resultados pésimos.

Cual es el algoritmo más eficiente ?, he leido algo de utilizar el math random pero no se me ocurre ninguna manera para no repetir letras...

gracias por adelantado.

tOWERR #2 Mar '11

Solamente palabras no?
Articulos, preposiciones y tal no?

Yandr0s #3 Mar '11

Pues... nose, si lo que tiens que haces realmente es desordenar cada palabra excepto primera y ultima letra.. se me ocurre que por cada palabra, y por cada letra puedes generar un num aleatorio entre 1 y el tamaño -2 ( penultiuma letra ) y cambiar las posiciones.

Prueba y a ver que sale xD

R3DKNIF3 #4 Mar '11

repetir letras?

Yo dividiría x palabras en un arraylist, controlaría la primera y ultima letra de cada string (teniendo encuenta puntos y comas) y haría aleatoriamente modificaciones de posición del resto.

1

JuAn4k4 #5 Mar '11

String input = ...
if (input != null && input.length()>0) {
String[] words = input.split(" ");

StringBuilder out = new StringBuilder();

for (String word : words ) {

 if (word.length() > 3) { // puedo intercambiar algo
  out.append(word.substring(0,1));
  out.append(randomize(word.substring(1,word.length()-2));
  out.append(word.substring(word.length()-1));
 }
}
}


function String randomize(String input) {
// Modificar string alternando caracteres
 

 char[] content = unsorted.toCharArray();
 int tam = content .length; // tamaño de la entrada

 int indx1=0, indx2=0;

 // Repetir tantas veces como se quiera:
 for (int i=0; i<5; i++) {
 indx1 = (Math.random().intValue() *100) % tam; // indx1 de 0...tam-1
 indx2 = (Math.random().intValue() *100) % tam;
 if (indx1 == indx2) {
   if (indx1 > 0) {
     indx1--;
   } else {
    indx1++;
   }
 }
 char aux = content[indx1];
 content[indx1] = content[indx2];
 content[indx2] = aux;
 } 

 return new String(content);

}

reformat-code !

2 1 respuesta

LOc0 #6 Mar '11

Como off-topic, una versión en PHP que ilustra el concepto de "potencia" de un lenguaje de programación:

function lectura_curiosa($t)
{
	$p='[\wáéíóúñÁÉÍÓÚÑ]';
	return preg_replace_callback("/($p)($p{2,})($p)/", create_function('$m', 'return $m[1].str_shuffle($m[2]).$m[3];'), $t);
}

DEMO AQUÍ

Salu2

1 2 respuestas

CRoS #7 Mar '11

#5 bravo!!!

Habia encontrado una "manera" con el metodo sort, pero tu algoritmo es genial.

char[] remover = word.toCharArray();
java.util.Arrays.sort(remover);
sorted = new String(remover);

luego lo añades con los substring de la primera y ultima letra.
saludos.

elkaoD #8 Mar '11

#6 más bien la potencia de las regex

1 respuesta

LOc0 #9 Mar '11

#8 Off-topiqueando, en Java tb tienes Regex:

JAVA_VERSION

import java.util.Random;
import java.util.regex.Matcher;
import java.util.regex.Pattern;

public class LecturaCuriosa {

public static final String texto="Según un estudio de una universidad inglesa, no importa el orden en el que las letras están escritas, la única cosa importante es que la primera y la última letra estén escritas en la posición correcta. El resto pueden estar totalmente mal y aún podrás leerlo sin problemas. Esto es porque no leemos cada letra por sí misma sino la palabra como un todo. Personalmente me parece increíble.";;

public static void main(String args[])
{
	Pattern pat = Pattern.compile("([\\wáéíóúñÁÉÍÓÚÑ])([\\wáéíóúñÁÉÍÓÚÑ]{2,})([\\wáéíóúñÁÉÍÓÚÑ])");
	Matcher match = pat.matcher(texto);
	StringBuffer out = new StringBuffer();

	while(match.find())
		match.appendReplacement(out, match.group(1)+shuffle(match.group(2))+match.group(3));
	    
	match.appendTail(out);
	System.out.println(out);
}

public static String shuffle(String c)
{
	String out=new String();
	Random random=new Random(System.currentTimeMillis());
	int p[]=new int[c.length()],r,i;

	for(i=0, java.util.Arrays.fill(p, -1); i<c.length(); p[r]=i++)
	{
		while(p[(r=random.nextInt(c.length()))] >= 0);
		out+=c.charAt(r);
	}
		
	return out;
}
}

¿Entiendes ahora a lo que me refería ?

Salu2

1 respuesta

CRoS #10 Mar '11

#6 Acabo lo de pulsar lo de la demo, la verdad que no entiendo bien lo de concepto de "potencia" de un lenguaje de programación: , supongo que te refieres a que con 5 lineas de codigo php has hecho la demo no? , resumen para noobs xD.

#9 los metodos matcher y pattern son muy potentes me los tendre que estudiar (no acabo de entender las linea 11) por cierto buen algoritmo se nota que dominas mucho.

un saludo!

LOc0 #11 Mar '11

Me refería a eso mismo. De todas formas, tp se puede llevar al extremo. Cada lenguaje tiene sus fuertes y la clave está en saber elegir.

La línea 11 es una REGEX http://es.wikipedia.org/wiki/Expresi%C3%B3n_regular Básicamente es una forma súper reducida de decirle al método find de matcher que busque un carácter alfabético seguido de 2 o más caracteres alfabéticos y que termine en otro carácter alfabético. (Vamos, que busque palabras de más de 3 letras y pase de espacios, comas y demás).

Las Regex son una cosa rara al principio, pero tendrás que aprender a manejarlas sí o sí tarde o temprano (al menos si pretendes programar alguna cosa medianamente "seria").

Me piro a sobar!

Salu2

PD:

spoiler

Algoritmo de lectura curiosa Java

Usuarios habituales

Tags