Cambridge text transformer

Commenter

Contenu du snippet

http://g.cabanac.free.fr/JAVA/CAMBRIDGE (applet java)

Selon une étude de l'Université de Cambridge, l'ordre des lettres dans un mot n'a pas d'importance, la seule chose importante est que la première et la dernière soient à la bonne place. Le reste peut être dans un désordre total et vous pouvez toujours lire sans problème.
C'est parceque le cerveau humain ne lit pas chaque lettre elle-même, mais le mot comme un tout.
Impressionnant, non ?

Source / Exemple : 


package com.java_fan.cabanac.text ;

import java.util.StringTokenizer ;
import java.util.Arrays ;
import java.util.ArrayList ;
import java.util.Random ;

/**


     
  •  The Cambridge University text transformer...

    •  
  •  @author <A href="mailto:cabanac@java-fan.com">Guillaume CABANAC</A>

    •  
  •  @since 20 IX 2003

    •  
  • /

public class Cambridge
{
	/**


    	 
  •  Converts a text to a string array.

    • 	 
  • /

	private static String[] toStringArray(String text)
	{
		ArrayList tokensList = new ArrayList() ;
		StringTokenizer st =
			new StringTokenizer(text, "!?.:,-_()[]' \"\t\n\r\f", true) ;
		
		while(st.hasMoreTokens())
			tokensList.add(st.nextToken()) ;
			
		return (String[])tokensList.toArray(new String[0]) ;
	}
	
	
	/**


    	 
  •  An array is mixable if the elements are not the same

    • 	 
  •  @param letter The array to test

    • 	 
  •  @return true if mixable, false otherwise

    • 	 
  • /

	private static boolean isMixable(char[] letters)
	{
		char old ;
		final int n = letters.length ;
		
		// Shoudn't arrive
		if(n==0) return true ;
		
		old = letters[0] ;
		for(int i=1 ; i < n ; i++)
			if(letters[i] != old)
				return true ;
		// Each letters[i] is equal
		return false ;
	}
	
	/**


    	 
  •  Mixes every letter of the specified string

    • 	 
  •  @param word The string to mix-up

    • 	 
  •  @return a mixed string, that constains each letter of 

    • 	 
  •  <code>word
but in a different order
  • /

    • private static String mixLetters(String word)
    {
    /* The characters that compund the word String */
    final char[] chars = word.toCharArray() ;
    final int n = chars.length ;
    /* Stores each letter "selected" state */
    boolean[] selected = new boolean[chars.length] ;
    /* Pseudo-random numbers generator */
    final Random rand = new Random() ;
    /* The mixed result */
    StringBuffer mixed ;
    /* The potential result */
    String result ;

    // For example "ll"
    if(!isMixable(chars)) return word ;

    do
    {
    // Each letter isn't selected yet
    Arrays.fill(selected, false) ;
    mixed = new StringBuffer(n) ;

    // Repeats n times
    for(int i, lettersLeft=chars.length ; lettersLeft>0 ; lettersLeft--)
    {
    // Getting a random integer in range [0;lettersLeft[
    i = rand.nextInt(lettersLeft) ;
    // Searching the corresponding letter
    while(selected[i])
    i = (i+1) % n ;
    // Found : concatenates and notifies it has been chosen
    mixed.append(chars[i]) ;
    selected[i] = true ;
    }
    result = mixed.toString() ;
    }
    while(result.equals(word)) ;
    return result ;
    }

    /**
    • Mixes the "inner letters" of the specified word.
    • @param word The considered word
    • @return 
      word</word> if it is 3 letters or less length,
    • else The word mixes except the fist ans last letters
    • /
    private static String mixInnerLetters(String word) { final int length = word.length() ; final char fst, lst ; if(length < 4) return word ; if (length == 4) // Speeds up transformation and avoids problems such as "elle" // That can't be transformed : infinite loop while trying to obtain a // different word in mix letters return "" + word.charAt(0) + word.charAt(2) + word.charAt(1) + word.charAt(3) ; else { fst = word.charAt(0) ; lst = word.charAt(length-1) ; String toMixUp = word.substring(1, length-1) ; return fst + mixLetters(toMixUp) + lst ; } } public static String transform(String text) { StringBuffer res = new StringBuffer() ; String[] words = toStringArray(text) ; for(int i=0, n=words.length ; i<n ; i++) res.append(mixInnerLetters(words[i])) ; return res.toString() ; } public static String transform(String[] words) { StringBuffer sb = new StringBuffer() ; for(int i=0, n=words.length ; i<n ; i++) sb.append(words[i]+" ") ; return transform(sb.toString()) ; } public static void main(String[] args) { if (args.length != 0) { final long go = System.currentTimeMillis() ; String text = transform(args) ; final long stop = System.currentTimeMillis() ; System.out.println("Temps d'exécution: "+(stop-go)+" ms.") ; System.out.println(text) ; } else System.err.println("Usage: java Cambridge Le texte a transformer") ; } }

    Conclusion :


    Sleon une éutde de l'Uinversité de Cbdrimgae, l'odrre des lerttes dnas un mot n'a pas d'ipmortance, la sluee csohe ipmrotante est que la prèemire et la deèrnire soeint à la bnnoe pcale. Le rtsee puet êrte dnas un dédsorre tatol et vuos povuez touujors lrie snas prèoblme.
    C'est pquarcee le cearveu huamin ne lit pas chqaue lrttee elle-mmêe, mias le mot cmmoe un tuot.
    Isspimeronnant, non ?

    A voir également

    S'inscrire maintenant

    Vous n'êtes pas encore membre ?

    inscrivez-vous, c'est gratuit et ça prend moins d'une minute !

    Les membres obtiennent plus de réponses que les utilisateurs anonymes.

    Le fait d'être membre vous permet d'avoir un suivi détaillé de vos demandes et codes sources.

    Le fait d'être membre vous permet d'avoir des options supplémentaires.

    Du même auteur (tafanor)