Le Python, c'est bien. Mangez-en.

« mai 2008
lun	mar	mer	jeu	ven	sam	dim
			1	2	3	4
5	6	7	8	9	10	11
12	13	14	15	16	17	18
19	20	21	22	23	24	25
26	27	28	29	30	31

« mai 2008

lun

mar

mer

jeu

ven

sam

dim

Et voilà :

from random import randint

class MarkovDictionary:
    """Stores possible suffixes for a given prefix."""
    
    def __init__(self):
        """Initialize an empty Markov dictionary."""
        self.dic = {}
    
    def getItem(self, key):
        """Get the possible suffixes list for a given prefix."""
        return self.dic[key]
    
    def addItem(self, prefix, suffix):
        """Add a possible suffix to a given prefix.""" 
        try:
            self.dic[prefix].append(suffix)
        except KeyError:
            self.dic[prefix] = [suffix]
    
    def getSuffix(self, prefix):
        """Get a random suffix for a given prefix."""
        list = self.dic[prefix]
        return list[randint(0, len(list) - 1)]

class MarkovGenerator:
    """Generate random words from a given words-list seed."""
    
    def __init__(self, initList, chunkSize = 3):
        """Initialize the generator with a initial words list.
        
        The chunk size attribute define the size of a single
        chunk from a word inside the initial words list. Chunks
        are combined to create new words.
        
        In short, the larger the chunk size, the closer the
        generated words are to the initial list "spirit", but
        also tends to be sometime too close to it.
        
        """
        self.initList = initList
        self.chunkSize = chunkSize
        self.dictionnary = MarkovDictionary()
        
        self.generateDictionary()
    
    def getRandomWords(self, maxTries = 100):
        """Get a list of random words generated using the initial
        words list and the Markov algorithm.
        
        The list size isn't fixed, but is always smaller than
        the specified maxTries attributes.
        
        """
        result = []
        counter = 0
        
        while len(result) < len(self.initList) and counter < maxTries:
            counter += 1
            prefix = " " * self.chunkSize
            name = ""
            
            while True:
                suffix = self.dictionnary.getSuffix(prefix)
                if suffix == "\n":
                    break
                else:
                    name += suffix
                    prefix = prefix[1:] + suffix
            
            if not name in result and not name in self.initList:
                result.append(name)
        
        return result
    
    def generateDictionary(self):
        """Generate a dictionary from the initial words list."""
        for nameIndex in range(len(self.initList)):
            name = self.initList[nameIndex]
            chunk = " " * self.chunkSize
            chunk += name
            
            for charIndex in range(len(name)):
                prefix = chunk[charIndex : charIndex + self.chunkSize]
                suffix = chunk[charIndex + self.chunkSize : charIndex + self.chunkSize + 1]
                self.dictionnary.addItem(prefix, suffix)
            
            self.dictionnary.addItem(chunk[len(name) : len(name) + self.chunkSize], "\n")

Et pour l'utiliser, c'est tout con :

En guise de liste de noms, j'ai utilisé la liste des noms des cyclones tropicaux de l'Atlantique Nord, ce qui m'a donné des trucs rigolos: Hanny, Palomas, Gertha, Doria, Humbertha, Bert, ... Cet algo est vraiment chouette. Si vous avez une liste de machins, essayez le dessus, c'est toujours drôle. Allez, salut.

Trackbacks

Commentaires

Ajouter un commentaire

Recherche:

Rechercher

Catégories:

Tags:

Archives:

Liens:

Contact

Projets

Collègues

Emplois

Divers

Syndication: