Problème:

Générez une phrase lisible et compréhensible. Il doit contenir un sujet, un verbe et un objet, et les temps et les pluriels doivent correspondre. Le programme doit également être capable de générer plusieurs phrases différentes pour être qualifié.

Règles:

• Il n'est pas permis de coder en dur les phrases, ni de les lire directement à partir d'un fichier (je vous regarde, je les enlève)
• Vous pouvez avoir n'importe quel nombre de listes de mots
• Soumettez un exemple de phrase ou 2 qui ont été générés par votre programme
• N'importe quelle langue est acceptée
• C'est un concours de popularité , donc la réponse la plus votée gagne

Frapper

fgrep '/* ' /usr/src/linux* -r | cut -d '*' -f 2 | head -$((RANDOM)) | tail -1

Configuration requise: la source du noyau Linux installée dans / usr / src

Cela extrait les commentaires aléatoires de la source du noyau. La question de savoir si les phrases sont réellement compréhensibles peut être débattue.

Exemples de résultats réels:

• end of packet for rx
• I don't know what to do
• 256 byte packet data buffer.
• The rest of this junk is to help gdb figure out what goes where
• Convert page list back to physical addresses, what a mess.
• ???
• Only Sun can take such nice parts and fuck up the programming interface

Matlab

why

exemple de sorties:

>> why
The programmer suggested it.
>> why
To please a very terrified and smart and tall engineer.
>> why
The tall system manager obeyed some engineer.
>> why
He wanted it that way.

[Ceci est l'un des oeufs de Pâques de Matlab]

EDIT: vous pouvez voir le code de cette fonction ici: why.m

PHP

Avec suffisamment de temps, cela produira toute la littérature, passée, présente et future. Les règles ne mentionnaient pas qu'aucun autre texte ne pouvait être produit.

La chaîne 'TOS...'fournit une fréquence d'échelle logarithmique des lettres pour correspondre plus étroitement à l'anglais. Ceci est utilisé pour générer une chaîne plus grande avec les fréquences de lettre relatives approximatives.

$a = ord('A');
$s = '';

foreach (str_split('TOSRWQPPUALRQTTRGUUUQMMLMFZ') as $i=>$f)
{
    if (!ctype_alpha($c = chr($a + $i)))
        $c = ' ';
    $s .= str_repeat($c, round(exp((ord($f) - $a) / 3.976)));
}

$l = strlen($s) - 1;
for (;;)
    echo substr($s, mt_rand(0, $l), 1);

En l'exécutant, j'ai découvert des joyaux littéraires tels que:

• GO NOW- Vous en tant que sujet est impliqué.
• IM AOK - Je suis OK
• IM FDR - Je suis F (ranklin) D (eleano) R (oosevelt)

En outre, de nombreuses invectives expriment de manière concise leur mécontentement face à la situation actuelle. [Quelques lettres expurgées.]

• F**K
• S**T

De même, les éléments suivants utilisent la mise à l’échelle affinée:

• IS IT ON
• I AM STU
• I SEE HTML

C

char*strerror(),i;main(){for(;--i;)puts(strerror(i));}

Exemple de sortie:

Absence de connexion provoquée par le logiciel
. Un appel système interrompu doit être redémarré.

Il y a aussi beaucoup de phrases valides en sortie qui n'ont pas de sujet, verbe et objet:

Le minuteur a expiré Le
fichier existe

Java

Extrait la phrase d'introduction d'un article aléatoire de Wikipedia:

import java.io.InputStream;
import java.net.URL;
import javax.xml.parsers.DocumentBuilderFactory;
import org.w3c.dom.Document;

public class RandomSentence {
    public static void main (String[] args) throws Exception {
        String sentence;
        do {
            InputStream in = new URL("https://en.wikipedia.org/wiki/Special:Random").openStream();
            Document doc = DocumentBuilderFactory.newInstance().newDocumentBuilder().parse(in);
            String intro = doc.getElementsByTagName("p").item(0).getTextContent();
            sentence = intro.replaceAll("\\([^(]*\\) *", "").replaceAll("\\[[^\\[]*\\]", "").split("\\.( +[A-Z0-9]|$)")[0];
        } while (sentence.endsWith(":") || sentence.length() < 30 || sentence.contains("?"));
        System.out.println(sentence + ".");
    }
}

Parfois, vous obtenez malchanceux; J'essaie de minimiser cela en définissant une longueur de phrase minimale et en filtrant les phrases qui se terminent par ":" (toutes les pages d'homonymie commencent ainsi) ou qui contiennent un "?" (Il semble y avoir beaucoup d'articles avec des informations inconnues non résolues marquées par des points d'interrogation). Les limites de phrase sont une période suivie d'un espace suivi d'un chiffre ou d'une lettre majuscule.

Je filtre également le texte entre parenthèses (le résultat est toujours une phrase valide) pour essayer de supprimer certaines périodes qui ne sont pas des limites de phrase. Je filtre les accolades carrées pour supprimer les numéros de citation de la source. Exemples:

• Idle Cure était un groupe de rock d'arène de Long Beach, en Californie.
• La mise au point automatique est un processus optique non linéaire induit par le changement d'indice de réfraction de matériaux exposés à un rayonnement électromagnétique intense.
• TB10Cs4H3 est un membre de la classe de molécules d'ARN non codantes de type H / ACA qui guide les sites de modification des uridines en pseudouridines d'ARN de substrat.
• Le Ram sauvage à six têtes de la mythologie sumérienne était l'un des héros tués par Ninurta, dieu protecteur de Lagash, dans l'ancien Irak.
• Sugar Daddy est un terme d'argot pour un homme qui propose de soutenir une femme ou un homme généralement plus jeune après avoir noué une relation généralement sexuelle.
• La vieille église méthodiste unie Bethel est située au 222, rue Calhoun, à Charleston, en Caroline du Sud.
• Douglas Geers est un compositeur américain.

Si vous remarquez des problèmes de grammaire, c'est de votre faute si vous n'êtes pas un éditeur assidu de Wikipedia! ;-)

Soooo ... Puisqu'il s'agit d'un concours de popularité , je me suis amusé avec evalet avec les fonctions. Fondamentalement, je génère un nombre aléatoire, puis exécute une fonction aléatoire basée sur ce nombre (sur votre visage switch,!) Via eval.

PHP, ~ 9k sorties valides

<?php

//Subjects
function s1(){ echo "I "; $m = rand(1,20); eval ("v".$m."(0);");}
function s2(){ echo "You "; $m = rand(1,20); eval ("v".$m."(0);");}
function s3(){ echo "He "; $m = rand(1,20); eval ("v".$m."(1);");}
function s4(){ echo "She "; $m = rand(1,20); eval ("v".$m."(1);");}
function s5(){ echo "We "; $m = rand(1,20); eval ("v".$m."(0);");}
function s6(){ echo "They "; $m = rand(1,20); eval ("v".$m."(0);");}

//Verbs
function v1($n){ echo "want"; if($n==1)echo"s"; echo " to "; $z = rand(1,10); eval ("a".$z."();");}
function v2($n){ echo "need"; if($n==1)echo"s"; echo " to "; $z = rand(1,10); eval ("a".$z."();");}
function v3($n){ echo "ha"; if($n==1){echo"s";}else{echo"ve";} echo " to "; $z = rand(1,10); eval ("a".$z."();");}
function v4($n){ echo "wanted to "; $z = rand(1,10); eval ("a".$z."();");}
function v5($n){ echo "needed to "; $z = rand(1,10); eval ("a".$z."();");}
function v6($n){ echo "had to "; $z = rand(1,10); eval ("a".$z."();");}
function v7($n){ echo "eat"; if($n==1)echo"s"; echo " "; $w = rand(1,20); eval ("o".$w."();");}
function v8($n){ echo "think"; if($n==1)echo"s"; echo " about "; $w = rand(1,20); eval ("o".$w."();");}
function v9($n){ echo "ate "; $w = rand(1,20); eval ("o".$w."();");}
function v10($n){ echo "thought about "; $w = rand(1,20); eval ("o".$w."();");}
function v11($n){ echo "draw"; if($n==1)echo"s"; echo " "; $w = rand(1,20); eval ("o".$w."();");}
function v12($n){ echo "drew "; $w = rand(1,20); eval ("o".$w."();");}
function v13($n){ echo "smell"; if($n==1)echo"s"; echo " like "; $w = rand(1,20); eval ("o".$w."();");}
function v14($n){ echo "shot "; $w = rand(1,20); eval ("o".$w."();");}
function v15($n){ echo "destroy"; if($n==1)echo"s"; echo " "; $w = rand(1,20); eval ("o".$w."();");}
function v16($n){ echo "destroyed "; $w = rand(1,20); eval ("o".$w."();");}
function v17($n){ echo "melt"; if($n==1)echo"s"; echo " "; $w = rand(1,20); eval ("o".$w."();");}
function v18($n){ echo "saw "; $w = rand(1,20); eval ("o".$w."();");}
function v19($n){ echo "ha"; if($n==1){echo"s";}else{echo"ve";} echo " "; $w = rand(1,20); eval ("o".$w."();");}
function v20($n){ echo "had "; $w = rand(1,20); eval ("o".$w."();");}

//Auxiliaries
function a1(){ echo "punch "; $w = rand(1,20); eval ("o".$w."();");}
function a2(){ echo "drive "; $w = rand(1,20); eval ("o".$w."();");}
function a3(){ echo "mount "; $w = rand(1,20); eval ("o".$w."();");}
function a4(){ echo "see "; $w = rand(1,20); eval ("o".$w."();");}
function a5(){ echo "have "; $w = rand(1,20); eval ("o".$w."();");}
function a6(){ echo "eat "; $w = rand(1,20); eval ("o".$w."();");}
function a7(){ echo "stun "; $w = rand(1,20); eval ("o".$w."();");}
function a8(){ echo "kiss "; $w = rand(1,20); eval ("o".$w."();");}
function a9(){ echo "Ted "; $w = rand(1,20); eval ("o".$w."();");} //See "How I met Your Mother" for further informations :)
function a10(){ echo "blow "; $w = rand(1,20); eval ("o".$w."();");}

//Objects
function o1(){ echo "a cow!<br>";}
function o2(){ echo "a meatball!<br>";} 
function o3(){ echo "a car!<br>";} 
function o4(){ echo "shoes!<br>";} 
function o5(){ echo "pigs!<br>";} 
function o6(){ echo "a telephone!<br>";} 
function o7(){ echo "some bottles of water!<br>";} 
function o8(){ echo "a laptop!<br>";} 
function o9(){ echo "my shorts!<br>";} //Quote needed
function o10(){ echo "anchovies!<br>";}
function o11(){ echo "an alarm clock!<br>";}
function o12(){ echo "every second!<br>";}
function o13(){ echo "until the end!<br>";}
function o14(){ echo "sitting!<br>";}
function o15(){ echo "a sword!<br>";}
function o16(){ echo "fire!<br>";}
function o17(){ echo "the dust!<br>";}
function o18(){ echo "in the bedroom!<br>";}
function o19(){ echo "a poor ant!<br>";}
function o20(){ echo "a pencil!<br>";}

//Testing
$n = rand(1,6); eval ("s".$n."();");
$n = rand(1,6); eval ("s".$n."();");
$n = rand(1,6); eval ("s".$n."();");
$n = rand(1,6); eval ("s".$n."();");

?>

Quelques sorties ...

She draws a sword!
They thought about sitting!
You eat my shorts!
He wanted to Ted a cow!
You want to mount a poor ant!
She smells like anchovies!
He wanted to have shoes!
They wanted to see a pencil!

Projet PHP + Gutenberg

J'ai écrit un script PHP qui transforme un document en texte brut en un ensemble de mots bigrammes , qu'il utilise ensuite pour générer des phrases aléatoires. Voici quelques-uns des meilleurs exemples qu'il a générés à partir de la version intégrale du discours de Patrick Henry, "Give Me Liberty Or Give Me Death" , incluant les petits caractères du projet Gutenberg:

• Le projet Gutenberg Etext des nations et de l'esclavage!

• Nous nous excusons pour le 200e anniversaire de cette copie réduite!

• VOUS N'AVEZ AUCUNE AUTRE GARANTIE DE DOMMAGES GENERAUX, EXPRESSES OU ACCESSOIRES, mais pour moi, la mort!

Vous pouvez l'essayer par vous-même ici. Actualisez la page pour un nouveau lot de phrases.

Si vous voulez exécuter le code source vous-même, n'oubliez pas de charger $src_textavec le texte brut que vous avez choisi.

<html>
<head>
<title>Give Me Liberty Or Give Me Death</title>
<style>
body { margin:4em 6em; text-align:center; background-color:#feb; }
h1 { font-weight:normal; font-size:2em; margin-bottom:2em; }
blockquote { font-style:italic; }
</style>
</head>
<body>
<h1>A collection of quotes randomly generated from Patrick Henry's speech
<a href="http://www.gutenberg.org/ebooks/6">Give Me Liberty Or Give Me Death</a>
(and its accompanying Project Gutenberg blurb).</h1>
<?php

/* Give Me Liberty Or Give Me Death */
/* Plain text available from http://www.gutenberg.org/ebooks/6 */
$src_text = file_get_contents('libertyordeath.txt');

$bigrams = array();
$openers = array();
$loc = 0;
$new_sentence = true;
$last = false;
while (preg_match('/\'?\w+[^\s\[\]\*\(\)"#@]*/',$src_text,$matches,PREG_OFFSET_CAPTURE,$loc)) {
  $w = $matches[0][0];
  $loc = $matches[0][1]+strlen($w);
  $bareword = preg_replace('/\W/','',$w);
  if ($last) {
    if (!isset($bigrams[$last][$w])) $bigrams[$last][$w] = 1;
    else $bigrams[$last][$w]++;
  }
  if (!isset($bigrams[$bareword])) $bigrams[$bareword] = array();
  $last = $bareword;
  if ($new_sentence && preg_match('/^[A-Z]/',$w)) {
    if (!isset($openers[$w])) $openers[$w] = 1;
    else $openers[$w]++;
    $new_sentence = false;
  }
  if (ends_sentence($w)) {
    $new_sentence = true;
    $last = false;
  }
}

/* Now generate ten random sentences */

for ($ns=0; $ns<10; $ns++) {

  echo "<blockquote><p>";

  /* Choose a starting word */

  $sum = 0;
  foreach ($openers as $w=>$c) $sum += $c;
  $r = mt_rand(0,$sum);
  foreach ($openers as $w=>$c) {
    $r -= $c;
    if ($r<=0) break;
  }

  /* Barf out additional words until end of sentence reached */

  while(1) {
    echo "$w ";
    if (ends_sentence($w)) break;
    $bareword = preg_replace('/\W/','',$w);
    $sum = 0;
    foreach ($bigrams[$bareword] as $w=>$c) $sum += $c;
    $r = mt_rand(0,$sum);
    foreach ($bigrams[$bareword] as $w=>$c) {
      $r -= $c;
      if ($r<=0) break;
    }
  }

  echo "</p></blockquote>\n";
}

function ends_sentence($w) {
  if (!preg_match('/[\.\?!]$/',$w)) return false;
  if (preg_match('/^(\w|St|Mr|Ms|Mrs|Messrs|i\.e|e\.g|etc|Rd)\./i',$w)) return false;
  return true;
}

?>
</body>
</html>

Python

Cette entrée sélectionne les mots du dictionnaire du système entier. Il tire parti du fait que vous pouvez transformer la plupart des noms en verbes et inversement. Il utilise quelques heuristiques pour classifier les mots et éviter les impossibilités évidentes.

Il produit quelques déclarations presque saines:

The snigger westernizes the bacteriologist.
A drizzle stoked the sentiments.

Beaucoup d'aliénés:

Tipper's orthopaedic knitwear plates a payroll.
A fibula teletypewritered a yogi.
The protozoan's spiralling skydive coats this veterinarian

Et beaucoup de choses qui ressemblent à Monty Python font des insinuations obscènes:

That rolling indictment tarries some bang's bulge.
Some inflammatory tush's intermarriage sextants some postman.
Some pentagon's manufacturer squeaked the wolverine.
A disagreeable participant is entertaining my optimized spoonful.

La version 3 a été modifiée pour prendre n'importe quel fichier texte en entrée:

$ man python | python words.py
The disabled comma-separated source is using those wizards at exit.
$ cat COPYING | python words.py  #GPL
My user accord actions a gnu of software.
$ cat pg2591.txt | python words.py #Grimm's Fairy Tales 
Some bargain receives my threepence.
Any wrong worms your world.
$ cat words.py | python words.py #self reflection
Your filter_possesive not_nouned those prepositions.
$ ls /usr/bin | python words.py  #directory lists
Their dropbox funziped an arch.

Code (version 3) :

import random
import string
import sys
import re

#words = open("/usr/share/dict/words").readlines()
words = re.sub("[]:;.,:?!<>{}()|=\"`[]",' ',sys.stdin.read(),flags=re.M).split()
words = list(set(words))

articles=('','a ','the ','some ','this ','that ','my ','any ','your ','their ',
             'all ','more '
             'an ') #an must be last
pl_articles=('','some ','those ','many ','the ','these ')
prepositions = ('of','by','to','for','from','in','with','on','which','when','at',
                     'into','as','if','near')
conjunctions = ('and','or','but')
verbs = ('is','are','was', 'be','do','came','been','had','have')
pronouns_s = ('he','she','it','we','you')
pronouns_o = ('him','her','them')

possesive=False
modifiers=0
use_prep = None

MAX_MODIFIERS=2

def is_modifier(w):
    return ("'" in w or
        w[-2:] in ('ry','ed','er','ic','al')  or
        w[-3:] in ('ing','est','ble','ous') or
        w[-4:] in ('less','ical','mmon') )

def is_verb(w):
    return (w in verbs or 
        w[-2:] in ('ed',) or
        w[-3:] in ('ing','ize') )

def is_article(w):
    return w+' ' in articles or w+' ' in pl_articles

def is_conjunction(w):
    return w in conjunctions

def filter_possesive(w,always=False): 
    global possesive
    #allow only one
    result = True if "'" in w else False
    if result:
        if always: return False
        if not possesive: 
            possesive = True
            return False
    return result

def is_preposition(w):
    global use_prep
    if w in prepositions:
        use_prep = w
        return True
    return False

def is_adverb(w):
    return w[-2:]=='ly'

def is_gerund(w):
    return w[-3:]=='ing'

def is_plural(w):
    return w[-1]=='s'

def not_verb(w):
    return (w in ('you','they','our','yes') or 
              w[-4:] in ('ness','such') or
              w in pronouns_o or w in pronouns_s
              )

def not_noun(w):
    return (w in verbs)


def getword():
    while True:
        w=words[random.randrange(len(words))].rstrip()
        if w[0] in string.ascii_uppercase: continue
        if is_article(w) or is_preposition(w):  continue
        if filter_possesive(w): continue 
        #print w
        return w

def get_article():
    return articles[random.randrange(len(articles)-1)]

#print '--s--'
substr=''
conjunction = False
while True:
    w=getword()
    if is_modifier(w):
        if modifiers < MAX_MODIFIERS:
            substr+=w+' '
            modifiers+=1
        else: continue
    elif is_adverb(w) or is_plural(w) or not_noun(w): continue
    else:
        if is_conjunction(w): 
            conjunction = w
            continue    
        substr= substr+w+' '
        if conjunction:
            substr+=conjunction+' '
            conjunction = False
            continue
        if w in pronouns_s: 
            substr = w+' '
            art=''
        else:
            art = get_article()
            if art is 'a ' and substr[0] in 'aeiou': art='an '
        substr= string.capwords(art+substr,'.')
        break

#print '--v--'
verbstr=''
while True:
    w=getword()
    if not_verb(w) or filter_possesive(w,True): continue
    elif is_adverb(w): verbstr+=w+' '
    elif is_gerund(w):
        verbstr+='is '+w+' '
        break
    elif is_verb(w):
        verbstr= verbstr+w+' '
        break
    elif is_modifier(w) or is_conjunction(w): continue
    else:
        if not is_plural(w):
            w=w+'ed' if w[-1]!='e' else w+'d'
        verbstr= verbstr+w+' '
        break

#print '--o--'
obstr=''
conjunction = False
while True:
    w=getword()
    if is_modifier(w):
        if modifiers<MAX_MODIFIERS:
            obstr+=w+' '
            modifiers+=1
        else: continue
    elif is_adverb(w) or not_noun(w) or w in pronouns_s: continue
    else:
        if is_conjunction(w): 
            conjunction = w
            continue
        obstr = obstr+w
        if conjunction:
            obstr+=' '+conjunction+' '
            conjunction = False
            continue
        if is_plural(w):
            art = pl_articles[random.randrange(len(pl_articles))] 
        else:
            art = articles[random.randrange(len(articles)-1)] 
            if art is 'a ' and obstr[0] in 'aeiou': art='an '
        if w in pronouns_o:
            obstr=w
        else:
            obstr= art+obstr
        break

#print '--p--'
while use_prep:
    w=getword()
    if (is_modifier(w) or is_preposition(w) or 
         is_gerund(w) or not_noun(w) or is_conjunction(w)):
        continue
    obstr+=' '+use_prep+' '+w
    use_prep=None

print substr+verbstr+obstr+'.'

Frapper

Inspiré par la réponse Matlab. Suppose que vous avez aptitudeinstallé.

r=$[ RANDOM % 7 ]
a=''
for i in `seq $r`; do a=$a'v'; done
if [ $r -ne 0 ]; then a='-'$a; fi
aptitude $a moo

Résultats possibles (capture d'écran de cet article de Wikipédia)

Python:

import random
l = ['Buffalo']
while random.randint(0,5) > 0:
    l.append('buffalo')
print ' '.join(l) + '.'

Échantillons:

• Buffalo Buffalo Buffalo.
• Buffles buffles buffles buffles buffles buffles buffles buffles buffles.

Malheureusement, la ponctuation et la capitalisation sont gérées de manière quelque peu médiocre, mais là encore, elles ne figuraient pas parmi les exigences.

Aussi, voici une référence.

Rouille + Toki Pona

Toutes les langues sont acceptées, j'ai donc écrit un programme en Rust qui génère des phrases en Toki Pona .

Toki Pona tente de créer un langage naturel minimal et possède une grammaire super simple et régulière. C'est une propriété très utile pour ce concours!

use std::rand;

#[deriving(Rand)]
struct Phrase { a: Option<~GNominal>, b: ~Sujet, c: ~Predicat }

#[deriving(Rand)]
enum Sujet { A(~GNominal), B(~SCompose) }

#[deriving(Rand)]
enum Predicat { C(~GVerbal), D(~PCompose) }

#[deriving(Rand)]
struct SCompose { a: ~Sujet, b: ~Sujet }

#[deriving(Rand)]
struct PCompose { a: ~Predicat, b: ~Predicat }

#[deriving(Rand)]
struct GNominal { a: ~nom::Nom, b: Multi<~adjectif::Adjectif> }

#[deriving(Rand)]
struct GVerbal { a: ~verbe::Verbe, b: Multi<~adjectif::Adjectif>, c: Multi<~ODirect> }

#[deriving(Rand)]
struct ODirect { a: ~GNominal}

#[deriving(Rand)]
enum Multi<T> { Zero, One(T), Two((T,T)) }

mod nom {
    #[deriving(Rand)]
    #[deriving(ToStr)]
    pub enum Nom {akesi,ala,ale,anpa,ante,ijo,ike,ilo,insa,jaki,jan,jo,kala,kalama,kama,kasi,ken,kili,kiwen,ko,kon,kule,kulupu,lape,lawa,len,lete,linja,lipu,luka,lupa,ma,mama,mani,meli,mi,mije,moku,moli,monsi,mun,musi,mute,nanpa,nasin,nena,nimi,noka,oko,olin,ona,pakala,pali,palisa,pana,pilin,pimeja,pini,pipi,poka,poki,pona,seli,selo,sewi,sijelo,sike,sina,sinpin,sitelen,sona,soweli,suli,suno,supa,suwi,tan,tawa,telo,tenpo,toki,tomo,tu,unpa,uta,utala,walo,wan,waso,wawa,weka,wile}
}

mod verbe {
    #[deriving(Rand)]
    #[deriving(ToStr)]
    pub enum Verbe {ante,awen,ijo,ike,jaki,jan,jo,kalama,kama,ken,kepeken,kule,kute,lape,lawa,lete,lili,lon,lukin,moku,moli,musi,mute,nasa,olin,open,pakala,pali,pana,pilin,pimeja,pini,pona,seli,sin,sitelen,sona,suli,suwi,tawa,telo,toki,tu,unpa,utala,wan,wawa,weka,wile,}
}

mod adjectif {
    #[deriving(Rand)]
    #[deriving(ToStr)]
    pub enum Adjectif {ala,ale,anpa,ante,awen,ike,insa,jaki,jan,jelo,kama,kin,kiwen,kon,kule,kute,kulupu,lape,laso,lawa,lete,lili,linja,loje,luka,lukin,mama,meli,mi,mije,moli,monsi,mun,musi,mute,nasa,ni,olin,ona,pali,pimeja,pini,poka,pona,sama,seli,sewi,sike,sin,sina,suli,suwi,taso,tawa,toki,tomo,unpa,uta,walo,wan,wawa,weka,wile,}
}

impl ToStr for Phrase {
    fn to_str(&self) -> ~str {
        self.a.as_ref().map_or(~"", |g| format!("{:s} la ", g.to_str()))
        + format!("{:s} li {:s}", self.b.to_str(), self.c.to_str())
    }
}

impl ToStr for Sujet {
    fn to_str(&self) -> ~str {
        match *self {
            A(ref v) => v.to_str(),
            B(ref v) => v.to_str(),
        }
    }
}

impl ToStr for Predicat {
    fn to_str(&self) -> ~str {
        match *self {
            C(ref v) => v.to_str(),
            D(ref v) => v.to_str(),
        }
    }
}

impl ToStr for SCompose {
    fn to_str(&self) -> ~str {
        format!("{:s} en {:s}", self.a.to_str(), self.b.to_str())
    }
}

impl ToStr for PCompose {
    fn to_str(&self) -> ~str {
        format!("{:s} li {:s}", self.a.to_str(), self.b.to_str())
    }
}

impl ToStr for GNominal {
    fn to_str(&self) -> ~str {
        format!("{:s} {:s}", self.a.to_str(), self.b.to_str())
    }
}

impl ToStr for GVerbal {
    fn to_str(&self) -> ~str {
        format!("{:s} {:s} {:s}", self.a.to_str(), self.b.to_str(), self.c.to_str())
    }
}

impl ToStr for ODirect {
    fn to_str(&self) -> ~str {
        format!("e {:s}", self.a.to_str())
    }
}

impl<T: ToStr> ToStr for Multi<~T> {
    fn to_str(&self) -> ~str {
        match *self {
            Zero => ~"",
            One(ref v) => v.to_str(),
            Two((ref v,ref w)) => format!("{:s} {:s}", v.to_str(), w.to_str()),
        }
    }
}

fn main() {
    let phrase = rand::random::<Phrase>();
    println!("{:s}\n{:?}", phrase.to_str(), phrase);
}

Je ne parle pas Toki Pona, mais j'ai trouvé la syntaxe de Toki Pona en tant qu'ensemble de règles BNF sur Wikipedia. J'ai créé une structure ou une énumération pour chaque règle BNF et je les ai annotées deriving(Rand), ce qui me permet de générer Phrasegratuitement une structure aléatoire ! Ensuite, j'ai implémenté ToStrpour chacune de ces structures pour les convertir en chaîne.

J'ai intentionnellement laissé les noms de structures en français, parce que les règles BNF que j'ai trouvées sont en français, et aussi parce qu'elles renforcent le caractère multilingue de ma soumission!

Exemples de sorties

Certaines sorties et leurs traductions, basées sur les règles de la BNF et un dictionnaire Toki Pona . Je suis sûr que ces traductions sont généralement fausses, mais Toki Pona laisse beaucoup de place à l'interprétation d'une phrase.

nasin mi tawa la jan li jaki

Pendant mon voyage, quelqu'un a pollué

monsi li jaki li jan ike musi

Le cul est sale et est une mauvaise personne drôle

sina li tawa ale jelo e kili tawa e insa

Vous avez déplacé le fruit et le centre vers l'univers jaune

Problèmes

• Je ne vérifie pas si un verbe est transitif ou non, certaines phrases sont donc grammaticalement incorrectes.
• Certaines structures sont récursives et lorsqu'une règle peut être répétée, je choisis au hasard de générer 0, 1 ou 2 éléments. Cela peut conduire à des phrases veeeeeery longues générées, contenant des milliers de mots ...
• Je ne peux pas vraiment vérifier la validité de la sortie, je me fie entièrement à la syntaxe BNF, au dictionnaire et à mes propres suppositions sauvages :)

Python

import this

The Zen of Python, by Tim Peters

Beautiful is better than ugly.
Explicit is better than implicit.
Simple is better than complex.
Complex is better than complicated.
Flat is better than nested.
Sparse is better than dense.
Readability counts.
Special cases aren't special enough to break the rules.
Although practicality beats purity.
Errors should never pass silently.
Unless explicitly silenced.
In the face of ambiguity, refuse the temptation to guess.
There should be one-- and preferably only one --obvious way to do it.
Although that way may not be obvious at first unless you're Dutch.
Now is better than never.
Although never is often better than *right* now.
If the implementation is hard to explain, it's a bad idea.
If the implementation is easy to explain, it may be a good idea.
Namespaces are one honking great idea -- let's do more of those!

Prolog

Utilisez le retour arrière de prolog et une grammaire générative se rapprochant de la grammaire anglaise pour générer toutes les phrases possibles.

Cette version a un vocabulaire et une structure de phrase assez limités, mais elle devrait être assez facile à étendre.

Le code:

% Define the vocabulary
verb(V) :- V = 'eats' | V = 'fights' | V = 'finds'.
subj_pronoun(P) :- P = 'he' | P = 'she' | P = 'it'.
obj_pronoun(P) :- P = 'him' | P = 'her' | P = 'it'.
name(N) :- N = 'alice' | N = 'bob'.
noun(N) :- N = 'cat' | N = 'door' | N = 'pen'.
article(H) :- H = 'the' | H = 'a'.

% Grammar
subject_phrase_short(H) :- subj_pronoun(H)
                         | name(H).
% Subordinate clause. Don't use verb_phrase here to avoid recursive clauses.
sub_clause([Which, Verb|T], Rest) :- Which = 'which', verb(Verb),
                                     object_noun_phrase_short(T, Rest).
subject_phrase([H|T], Rest) :- subject_phrase_short(H), Rest = T.
object_noun_phrase_short([A, N | T], Rest) :- article(A), noun(N), Rest = T
                                            | obj_pronoun(A), Rest = [N|T].
object_phrase(L, Rest) :- object_noun_phrase_short(L, Rest)
                        | object_noun_phrase_short(L, Rest1), sub_clause(Rest1, Rest).
verb_phrase([H|T], Rest) :- verb(H), object_phrase(T, Rest).
sentence(S) :- subject_phrase(S, Rest), verb_phrase(Rest, []).

Exécutez cette requête:

sentence(L).

générer toutes les phrases possibles dans cette langue.

Quelques exemples de sorties:

L = [he, eats, the, cat] ;
L = [she, finds, a, door] ;
L = [alice, fights, the, door] ;
L = [he, fights, the, cat, which, eats, the, pen] ;
L = [alice, eats, him, which, finds, the, cat] ;

(EDIT: Autoriser les clauses subordonnées d'objet).

Python

Comme vous le savez, vous pouvez tout faire en python avec quelques imports. Cette tâche simple peut être accomplie avec ce script python de 2 lignes.

import random

print ("I like the number "+str(random.uniform(0,1)))

Le nombre de phrases générées par ce script est énorme: 10^12différentes phrases. Si la lecture d'une phrase vous prend environ 0,5 seconde, sa lecture durera plus de 15 000 ans!

Quelques exemples de phrases:

• I like the number 0.444371877853
• I like the number 0.358614422548

Pourtant, toutes les phrases générées contiennent un sujet, un verbe et un objet.

MISE À JOUR:

J'ai reçu des critiques sur certains mots sophistiqués que cet outil complexe pourrait produire. Voici une version légèrement plus longue qui devrait être en accord avec la plupart des listes de mots.

import random

print ('I like the number'+''.join([' '+{'0':'zero','.':'point','1':'one','2':'two','3':'three','4':'four','5':'five','6':'six','7':'seven','8':'eight','9':'nine'}[digit] for digit in str(random.uniform(0,1))])+'.')

Voici quelques exemples de phrases:

• I like the number zero point six three five nine zero eight one five eight four two four.
• I like the number zero point four nine zero eight four four three two zero six two seven.

Jouer avec le dictionnaire interne Mathematica:

res = {};
SeedRandom[42 + 1];
Do[
  (While[
    If[(c = Flatten@WordData[RandomChoice[WordData[All]], "Examples"][[All, 2]]) != {},
     StringPosition[(c1 = RandomChoice@c), "'" | "-" | "\\" | "`"] != {}, True, True]];
   sp = ToLowerCase /@ StringSplit[c1, (WhitespaceCharacter .. | ",")];
   toChange = RandomSample[Range@#, RandomInteger[IntegerPart[{#/2, #}]]] &@Length@sp;
   If[StringPosition[ToString@WordData[sp[[#]], "Definitions"],  "WordData"] == {}, 
    sp[[#]] = RandomChoice@ WordData[All, RandomChoice@WordData[sp[[#]], "PartsOfSpeech"]]]
             & /@ toChange;
   AppendTo[res, StringJoin@Riffle[sp, " "]];)
  ,
  {10}];
res

Vous avez de la chance, par exemple, 70% du temps. Il génère des choses comme:

un circuit électrique amygdalien
là - bas Parkia était non restrictive si saccadée
sa société longanimous
Docteur de l' éducation réponse inintelligible pour kibboutz
petit théâtre musical contre Jules César
un Tai sittelle
faucher dans le centre sportif contre ta vilenie
les détergents extrinsèques requis
sorcier sans nécromancie
ces vena pectoral latrie mine de face trophée femme investisseurs branchés brun
quel homme-portable champ de feu
umbra charmante où ma réponse
un autre vis-lâche débris tempête inodore aslant mer complexe complexe de la mer d'Aal
pour professe délice mongoloïde type

mais parfois:

adoption de la mine moins bataille de Lutzen gagnerait de l'argent pendant que Hejira du couperet
neuf genre de subduction du méné moyen Seiurus réconforte son public

Eh bien, son anglais est meilleur que le mien.

VBA / Excel

[modifier 2]

L'ont appris à conjuguer des verbes, les exemples ci-dessous sont du passé simple:

La cocaïne sauvage modérée a glissé devant la décision historique instantanée. Le chapitre sur les coffres régionaux s'est cassé dans l'une des nombreuses entités aléatoires. Le domaine jaune droit a été supprimé derrière le sexe fragile magnétique. La pollution physique fatale a commencé au-delà de la pauvre sensation morte. Le théâtre cognitif courageux est allé à l'avant de la littérature consciente fragile. La sortie réelle conventionnelle a résisté loin du site immunitaire préféré. Le jumeau économique fixe a reconnu le besoin humain diabolique.

Le code pertinent suit, à l’exclusion de nombreuses fonctions ennuyeuses d’analyse syntaxique et de bouclage. Les principales parties manquantes sont les différentes listes de mots (par parties du discours) qui font la pluralisation, les temps, les conjugaisons, etc.

Tous les mots racines sont choisis au hasard, mais je les force à être disposés dans un motif de phrase particulier:

Debug.Print getWords("ad adj adj nns vpa1s pl ad adj adj nns")

... ce que j'ai utilisé pour générer la sortie ci-dessus. Il suit la forme générale de "Le renard roux rapide a sauté par-dessus le chien brun paresseux".

Function getWords(strStruc As String) As String
    Dim i As Long
    Dim s As Long
    Dim strIn As String
    Dim strOut As String

    getWords = ""
    s = numElements(strStruc)
    For i = 1 To s
        strIn = parsePattern(strStruc, i)
        Select Case strIn
            Case ",", ";", ":", """" 'punctuation
                strOut = strIn
                getWords = Trim(getWords)
            Case "ai", "ad" 'indefinite article, definite article
                strOut = getArticle(strIn)
            Case "adj" 'adjective
                strOut = getWord("adj", 1)
            Case "nns" 'noun nominative singular
                strOut = getWord("n", 1)
            Case "nnp" 'noun nominative plural
                strOut = getWord("n", 2)
            Case "nps" 'noun posessive singular
                strOut = getWord("n", 3)
            Case "npp" 'noun posessive plural
                strOut = getWord("n", 4)
            Case "vpr1s" 'Present 1st Person Singular
                strOut = getWord("v", 1)
            Case "vpr2s" 'Present 2nd Person Singular
                strOut = getWord("v", 2)
            Case "vpr3s" 'Present 3rd Person Singular
                strOut = getWord("v", 3)
            Case "vi" 'Infinitive
                strOut = getWord("v", 4)
            Case "vpp" 'Present Participle
                strOut = getWord("v", 5)
            Case "vi" 'Imperative/Subjunctive
                strOut = getWord("v", 6)
            Case "vpa1s" 'Past Tense First Person
                strOut = getWord("v", 7)
            Case "vpa2s" 'Past Tense Second Person
                strOut = getWord("v", 8)
            Case "vpa3s" 'Past Tense Third Person
                strOut = getWord("v", 9)
            Case "vppr1s" 'Present Progressive First Person Singular
                strOut = getWord("v", 10)
            Case "vppr2s" 'Present Progressive Second Person Singular
                strOut = getWord("v", 11)
            Case "vppr3s" 'Present Progressive Third Person Singular
                strOut = getWord("v", 12)
            Case "vppe1s" 'Present Perfect First Person Singular
                strOut = getWord("v", 13)
            Case "vppe2s" 'Present Perfect Second Person Singular
                strOut = getWord("v", 14)
            Case "vpp3s" 'Present Perfect Third Person Singular
                strOut = getWord("v", 15)
            Case "vi1s" 'Imperfect First Person Singular
                strOut = getWord("v", 16)
            Case "vi2s" 'Imperfect Second Person Singular
                strOut = getWord("v", 17)
            Case "v13s" 'Imperfect Third Person Singular
                strOut = getWord("v", 18)
            Case "vsf" 'Simple Future
                strOut = getWord("v", 19)
            Case "vfp" 'Future Progressive
                strOut = getWord("v", 20)
            Case "vc" 'Conditional
                strOut = getWord("v", 21)
            Case "vcp" 'Conditional Perfect
                strOut = getWord("v", 22)
            Case "vci" 'Conditional Imperfect
                strOut = getWord("v", 23)
            Case "pl" 'location prepositions
                strOut = getWord("pl", 1)
        End Select
        getWords = getWords & strOut & " "
    Next i
End Function

[commencer le post original]

Encore un travail en cours, besoin d’ajouter une logique pour les temps et la pluralisation nom / verbe, à savoir:

Votre voyage moyen notre dose supposée ni une augmentation de la température au-delà de ma tomate.

... ce qui est analysable, mais n'a pas beaucoup de sens.

La programmation permet à leur sale pêcheur de loin notre caste de porc à la place aucune phrase.

Droite. Pas vraiment une phrase, mais mieux que certains messages d'erreur JavaScript.

Son appel soulève chaque question en direct que ma dame esquisse en anglais.

La routine de sous-entendus est presque top tho 'tho' ...

Code à suivre bientôt. Ce concours a-t-il une date limite?

[modifier 1]

Code qui a généré ce qui précède.

Function getWord(sht As Worksheet) As String
    Dim i As Long
    Dim freq As Long
    Dim c As Long
    Dim f As Double
    Dim fSum As Double

    c = 4
    fSum = WorksheetFunction.Count(sht.Columns(c))
    f = Rnd() * fSum
    i = 2
    Do
        If i >= f Then Exit Do
        i = i + 1
    Loop
    getWord = sht.Cells(i, 1).Value
End Function
Function PCase(str As String) As String
    PCase = UCase(Left(str, 1)) & Right(str, Len(str) - 1)
End Function
Sub doMakeSentences01()
    Dim shtIn As Worksheet
    Dim shtOut As Worksheet
    Dim strSheet As String
    Dim rIn As Long
    Dim rOut As Long
    Dim cFreq As Long
    Dim c As Long
    Dim strPattern As String
    Dim w As Long
    Dim strOut As String
    Dim strIn As String
    Dim strWord As String

    cFreq = 4
    Set shtOut = Sheets("Output")
    rOut = shtOut.Range("A65536").End(xlUp).Row + 1

    strPattern = "anvajncanvian"
    For rOut = rOut To rOut + 1000
        strOut = ""
        For w = 1 To Len(strPattern)
            Set shtIn = Sheets(Mid(strPattern, w, 1))
            strWord = getWord(shtIn)
            If w = 1 Then strWord = PCase(strWord)
            strOut = strOut & strWord & " "
        Next w
        strOut = Trim(strOut) & "."
        shtOut.Cells(rOut, 1).Value = strOut
    Next rOut
End Sub

Perl 5

OK, le courage du programme est juste ceci:

use v5.14;
my %pad = (
    ...
);
sub pad { shift =~ s(\{(.+?)\}){pad($pad{$1}[rand(@{$pad{$1}})])}rogue }
say ucfirst pad '{START}';

C'est fondamentalement un moteur "madlib". Pour générer des phrases intéressantes, vous devez renseigner %padcertaines données. Voici un exemple %pad...

my %pad = (
  START => ['{complex}.'],
  complex => [
    '{simple}',
    '{simple}, and {simple}',
    '{simple}, and {complex}',
    '{simple}, but {simple}',
    '{simple}, yet {simple}',
    'even though everybody knows {simple}, {simple}',
    'not only {simple}, but also {simple}',
  ],
  simple => [
    '{thing} {verb}s {thing}',
    '{thing} {verb}s {adverb}',
    '{thing} is {adjective}',
    '{things} {verb} {thing}',
    '{things} {verb} {adverb}',
    '{things} are {adjective}',
    '{thing} {past_verb} {thing}',
    '{things} {past_verb} {thing}',
  ],
  thing => [
    'the {adjective} gorilla',
    'the {adjective} mailbox',
    'Archbishop Desmond Tutu',
    'the beef salad sandwich',
    'the {adjective} stegosaur',
    'the summit of Mt Everest',
    'Chuck Norris',
    'the cast of television\'s "Glee"',
    'a {adjective} chocolate cake',
  ],
  things => [
    '{adjective} shoes',
    'spider webs',
    'millions of {adjective} eels',
    '{adjective} children',
    '{adjective} monkeys',
    '{things} and {things}',
    'the British crown jewels',
  ],
  verb => [
    'love',
    'hate',
    'eat',
    'drink',
    'follow',
    'worship',
    'respect',
    'reject',
    'welcome',
    'jump',
    'resemble',
    'grow',
    'encourage',
    'capture',
    'fascinate',
  ],
  past_verb => [  # too irregular to derive from {verb}
    'loved',
    'ate',
    'followed',
    'worshipped',
    'welcomed',
    'jumped',
    'made love to',
    'melted',
  ],
  adverb => [
    'greedily',
    'punctually',
    'noisily',
    'gladly',
    'regularly',
  ],
  adjective => [
    'enormous',
    'tiny',
    'haunted',
    'ghostly',
    'sparkling',
    'highly-decorated',
    'foul-smelling',
    '{adjective} (yet {adjective})',
    'expensive',
    'yellow',
    'green',
    'lilac',
    'tall',
    'short',
  ],
);

Voici quelques exemples de la sagesse que j'ai découverte grâce à cela %pad. Ces phrases n’ont pas été modifiées en termes de longueur, de ponctuation, de grammaire, etc., bien que j’aie choisi des phrases inintéressantes et que j’ai réarrangé l’ordre dans lequel elles apparaissent - elles ne sont plus dans l’ordre dans lequel elles ont été générées. utilisez-les pour raconter une histoire: une histoire, je l'espère, à la fois touchante et stimulante.

• Les toiles d'araignées sont courtes.
• Les toiles d'araignées fascinent régulièrement.
• Les singes courts sont étincelants, mais les toiles d'araignées boivent goulûment.
• Des singes étincelants (pourtant nauséabonds) suivaient le gorille minuscule (pourtant étincelant).
• Le sommet de l'Everest a accueilli le stégosaure très décoré.
• Non seulement le sommet du mont Everest est cher, mais le casting de "Glee" de la télévision a suivi le gorille étincelant.
• Le casting de "Glee" de la télévision ressemble à la boîte aux lettres lilas.
• La boîte aux lettres coûteuse est grande, et le stégosaure coûteux saute Chuck Norris, mais des chaussures vertes ont sauté du sandwich à la salade de boeuf.
• Le sandwich à la salade de boeuf aimait Chuck Norris.
• Des millions d'anguilles scintillantes sont vertes (mais fantomatiques).

Ms Word

Je ne suis pas sûr que cela soit acceptable, mais comme le HTML l'est, je pense que cela devrait également être acceptable.

 =rand(1,1)

Exemples de phrases:

Dans l'onglet Insertion, les galeries incluent des éléments conçus pour se coordonner avec l'aspect général de votre document.

Vous pouvez utiliser ces galeries pour insérer des tableaux, des en-têtes, des pieds de page, des listes, des pages de couverture et d'autres blocs de construction de documents.

vous pouvez également spécifier un nombre quelconque de phrases et de paragraphes.

Un travail en cours utilisant JSoup et simpleNLG

import java.io.IOException;
import java.util.ArrayList;
import java.util.Arrays;

import org.jsoup.Jsoup;
import org.jsoup.nodes.Document;
import org.jsoup.nodes.Element;

import simplenlg.framework.NLGFactory;
import simplenlg.lexicon.Lexicon;
import simplenlg.phrasespec.SPhraseSpec;
import simplenlg.realiser.english.Realiser;

/**
 * Scapes words from Wiktionary then assembles them into sentences
 * 
 * @author pureferret
 *
 */
public class SentenceBuilder {
    static ArrayList<String> ListOfWordTypes= new ArrayList<>(Arrays.asList("Noun","Verb","Adjective","Adverb","Proper noun","Conjunction"));
    private static String RandomWiktWord ="http://toolserver.org/~hippietrail/randompage.fcgi?langname=English";  
    /**
     * @param args
     */
    public static void main(String[] args) {
        Lexicon lexicon = Lexicon.getDefaultLexicon();
        NLGFactory nlgFactory = new NLGFactory(lexicon);
        Realiser realiser = new Realiser(lexicon);

        ArrayList<String> nounList = new ArrayList<String>();
        ArrayList<String> verbList = new ArrayList<String>();
        ArrayList<String> adjeList = new ArrayList<String>();
        ArrayList<String> adveList = new ArrayList<String>();
        ArrayList<String> pnouList = new ArrayList<String>();
        ArrayList<String> conjList = new ArrayList<String>();


        String word= null;
        String wordType = null;

        try {
            newDoc:
            while( nounList.size()<1 ||
                    verbList.size()<1 ||
//                  adjeList.size()<2 ||
//                  adveList.size()<2 ||
                    pnouList.size()<1){
                Document doc = Jsoup.connect(RandomWiktWord).get();
                Element bodyElem = doc.body();
                word = bodyElem.select("h1>span[dir=auto]").get(0).ownText();
                int wtIdx = 0;
                while(wtIdx<bodyElem.select("div#mw-content-text span.mw-headline").size()){
                    wordType = bodyElem.select("div#mw-content-text span.mw-headline").get(wtIdx).id()
                            .replace("_", " ");
                    wtIdx++;
                    switch (wordType) {
                    case "Proper noun":
                        pnouList.add(word);
                        continue newDoc;
                    case "Noun":
                        nounList.add(word);
                        continue newDoc;
                    case "Verb":
                        verbList.add(word);
                        continue newDoc;
                    case "Adjective":
                        adjeList.add(word);
                        continue newDoc;
                    case "Adverb":
                        adveList.add(word);
                        continue newDoc;
                    case "Conjunction":
                        conjList .add(word);
                        continue newDoc;
                    default:
                        break;
                    }
                }
            }
                SPhraseSpec p = nlgFactory.createClause();
                p.setSubject(pnouList.get(0));
                p.setVerb(verbList.get(0));
                p.setObject(nounList.get(0));

                String output2 = realiser.realiseSentence(p); // Realiser created earlier.
                System.out.println(output2);

        } catch (IOException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
            System.err.println(word + " is a " + wordType);
        } catch (IndexOutOfBoundsException e) {
            e.printStackTrace();
            System.err.println(word + " is a " + wordType);
        }
    }

}

Problèmes:

• Les phrases sont trop simples
• Parfois 404s (sans une bonne manipulation!)
• Ne génère qu'une phrase à la fois
• Utilise un boîtier de commutateur!

Exemples de sortie:

Popoloca pète des haricots d'Espagne.
Le tropique du Capricorne rayonne les corps.
Beijing a synonyme les boîtes à oreillers.
Les Tchouktches ont inculturé.

PHP

<?php
  $trends = file_get_contents('http://www.google.com/trends/hottrends/widget?pn=p1&tn=30');
  preg_match_all("/widget-title-in-list'>(.+?)</", $trends, $m);

  $q = urlencode($m[1][array_rand($m[1])]);
  $page = file_get_contents("http://www.google.com/search?q=$q&btnI=1");
  preg_match_all('/[A-Z]([\w,]+ ){2,}[\w, ]+?[.!]/', strip_tags($page), $m);

  echo $m[0][array_rand($m[0])];

Cela récupère les 30 recherches Google les plus en vogue, effectue une recherche "Je me sens chanceux", puis affiche une phrase aléatoire de cette page avec au moins 3 mots.

Exemples:

"Elle a été considérée comme une favorite de la médaille dans cette épreuve."

"Kate a obtenu son diplôme d'études secondaires un an plus tôt."

"15 avril 2014, pour promouvoir le respect de la politique en matière de biographies de personnes vivantes."

"Au nom de Bryan, nous, sa famille, souhaitons remercier tout le monde pour le déversement d'amour, de prières et de soutien."

"Cet article concerne le basketteur américain."

"Désolé, JavaScript est désactivé ou aucun lecteur n'est pris en charge."

Python 2.7

python2.7 -c "import urllib2, pprint; pprint.pprint([str(x[:x.find('<')]) for x in unicode(urllib2.urlopen('http://codegolf.stackexchange.com/questions/21571/generate-an-understandable-sentence').read(), 'utf8').split('<p>') if x.find('<') >= 1][1].split('.')[0])"

sortie:

Générer une phrase lisible et compréhensible

Shell Scripting

Ce script affichera toujours le titre de la première question actuellement placée en haut de ce site. Mon hypothèse est que le titre de la question sera toujours lisible par l'homme. Et cela changera dynamiquement. Ainsi, chaque fois qu'une nouvelle question arrive et que le script est exécuté, il donne le titre de la dernière question.

curl "codegolf.stackexchange.com" -s |  w3m -dump -T text/html > foo.txt
awk 'f;/more tags/{f=1}' foo.txt > foo1.txt
sed '8q;d' foo1.txt

Essai 1 sortie

Find words containing every vowel

Essai 2 sortie

Hello World 0.0!

MODIFIER

Ne pas utiliser de fichiers. Sans fichiers, je peux utiliser le script ci-dessous.

value1=$(curl "codegolf.stackexchange.com" -s |  w3m -dump -T text/html)
echo "$value1" | grep -A 8 "more tags" | tail -1

Sortie

Generate an understandable sentence

JavaScript (ES6)

var t='';for(f of [_=>foo,_=>null.a,_=>0..toString(0)])try{f()}catch(e){t+=e.message+'\n';}t

L'exécuter dans la console produit

foo is not defined
null has no properties
radix must be an integer at least 2 and no greater than 36

Encore un autre script Python

La réponse de user3058846 n'est pas mauvaise, mais elle affiche toutes les phrases, à chaque fois. Ici, je propose un script qui sort une phrase aléatoire du zen de Python :

from random import choice
import subprocess
proc = subprocess.Popen(('python', '-c', 'import this'), stdout=subprocess.PIPE,)
# Get output of proc, split by newline
sentences = [x for x in proc.communicate()[0].splitlines() if x != '']
print(choice(sentences))

En une ligne, pour les fans de code-golf :

from random import choice;import subprocess;print(choice([x for x in subprocess.Popen("python -c 'import this'",shell=True,stdout=subprocess.PIPE).communicate()[0].split('\n') if x]))

^{_{(Boooh, sale.)}}

Exemples:

>>> a()  # <--- a is just the oneline above
Explicit is better than implicit.
>>> a() 
Although never is often better than *right* now.
>>> a() 
Errors should never pass silently.
>>> a() 
Special cases aren't special enough to break the rules.

Une autre façon amusante en Python

Merci à @TheDoctor pour avoir eu l'idée :-) Mettez la sortie d'importation en mode silencieux, puis jouez avec le dict pseudo-crypté dans le module.

import sys, random 
_stdout, sys.stdout = sys.stdout, open('/tmp/trash', 'w')  # silent the stdout just for the import
import this
sys.stdout = _stdout
lst = []
for x in this.s:
    if x in this.d:
        lst.append(this.d[x])
    else:
        lst.append(x)

# Then, example from the interpreter
>>> random.choice(''.join(lst).split('\n'))
'Beautiful is better than ugly.'
>>> random.choice(''.join(lst).split('\n'))
'Although never is often better than *right* now.'
>>>

Python 3

Garanti de générer une sortie grammaticale! (Habituellement.)

import re
from urllib.request import urlopen
from random import random, choice as pick

letters = "abcdefghijklmnopqrstuvwxyz"
wordregex = re.compile(r'a href="/wiki/([a-z_]+)"')
subjects = {1:("I","we"), 2:("you",), 3:("they",)}
objects = {1:("me","us"), 2:("you",), 3:("him","her","it","them")}
patterns = ["{0} {1} {2}.",
            "Why do {0} {1} {2}?",
            "It's because {0} {1} {2}, of course.",
            "Did {0} {1} {2}?",
            "{0} will not {1} {2}!",
            ]

wiktionaryurl = "http://en.wiktionary.org/w/index.php?" + \
              "title=Category:English_{0}&pagefrom={1}"

def getWord(category):
    subset = pick(letters) + pick(letters)
    url = wiktionaryurl.format(category, subset)
    try:
        response = urlopen(url)
    except:
        print("An error occurred while connecting to the Internet!")
        return "fail"
    page = str(response.read())
    word = pick(wordregex.findall(page))
    word = word.replace("_", " ")
    return word

for i in range(10):
    verb = getWord("transitive_verbs")
    subjPerson = pick([1,2,3])
    subj = pick(subjects[subjPerson])
    if random() > 0.4:
        # Use a plural noun for the object
        obj = getWord("plurals")
    else:
        # Use a pronoun for the object
        objPerson = pick([1,2,3])
        while subjPerson == objPerson and subjPerson in (1,2):
            objPerson = pick([1,2,3])
        obj = pick(objects[objPerson])
    sentence = pick(patterns).format(subj, verb, obj)
    sentence = sentence[0].upper() + sentence[1:]
    print(sentence)

Pour le rendre parfaitement grammatical, supprimez le trait de soulignement de wordregex. Cela interdira les entrées de plusieurs mots qui mènent à de mauvaises phrases telles que "Nous vous compressons."

Échantillon échantillon:

We appropriate journals.
I will not masticate you!
Did you lower me?
Why do I sag estoppels?
They will not proofread you!
It's because you unbeguile mucosae, of course.
Why do I flack zakuski?
You will not visit junkpiles!
Did they goat us?
Why do we prefix nolids?

Sortie préférée jusqu'à présent:

They you her.

Recherchez-la: http://en.wiktionary.org/wiki/you#Verb .

Python

Résultat:

$ python mksentence.py
infringement lecture attainment
Produce more? (Y/N)y
impeachment recoup ornament
Produce more? (Y/N)y
maladjustment edit discouragement
Produce more? (Y/N)y
embellishment guest punishment
Produce more? (Y/N)y
settlement section escapement
Produce more? (Y/N)y
segment withhold recruitment
Produce more? (Y/N)

J'ai utilisé la liste de mots à partir d'ici Trouver les mots contenant chaque voyelle

Quelques règles supplémentaires peuvent être ajoutées. Par exemple, si un mot se terminant par "ness" et que le mot existe également dans l'ensemble sans le suffixe, il s'agit d'un nom.

Code source:

#!/usr/bin/env python
# vim: set fileencoding=utf-8 ts=4 sw=4 tw=72 :

from __future__ import (unicode_literals, absolute_import,
                        division, print_function)

import random                     

if __name__ == "__main__":        
    filename = 'corncob_lowercase.txt'
    noun = set()
    verb = set()
    whole_words_set = {word.rstrip() for word in open(filename)}

    for word in whole_words_set:
        if word.endswith('ment'):
            noun.add(word)
        elif word.endswith('ing'):
            if word[:-3] in whole_words_set:
                verb.add(word[:-3])
            elif word[:-3]+"e" in whole_words_set:
                verb.add(word[:-3]+"e")
    noun_list = list(noun)
    verb_list = list(verb)
    while True:                   
        sentence = "%s %s %s" % (random.choice(noun_list),
                                 random.choice(verb_list),
                                 random.choice(noun_list))                                                                                           
        print(sentence)
        if input("Produce more? (Y/N)").lower() == "n":
            break

Frapper

Essayer d'exécuter un programme existant mais non installé donne ceci (dans Linux Mint 13).

$ say
The program 'say' is currently not installed.  To run 'say' please ask your administrator to install the package 'gnustep-gui-runtime'

Python 3

Une autre prise au zen de Python , inspirée par la réponse de Maxime .

import codecs
import os
import sys
import random

stdout = sys.stdout
sys.stdout = open(os.devnull, 'r+')

import this

sys.stdout.close()
sys.stdout = stdout

zen = codecs.decode(this.s, 'rot-13').splitlines()

print(random.choice(zen))

var vocab={
    noun:{
        tp:{
            singular:["Mike","Chan","Karl","Mithun","Debasish","Kamal","Group","Crowd","He","She"],
            plural:["They"],
        },
        fp:{
            singular:["I"],
            plural:["We"]
        },
        sp:{
            singular:["You"],
            plural:["You"]
        }

    },
    verbIndicator:{
        tp:{
            present:{
                singular:["is"],
                plural:["are"]
            },
            past:{
                singular:["was"],
                plural:["were"]
            }
        },
        fp:{
            present:{
                singular:["am"],
                plural:["are"]
            },
            past:{
                singular:["was"],
                plural:["were"]
            }
        },
        sp:{
            present:{
                singular:["are"],
                plural:["are"]
            },
            past:{
                singular:["were"],
                plural:["were"]
            }
        }
    },
    verb:{
        continuous:{
            consumer:["having"],
            performer:["doing","playing","watching"]
        },
        simple:{
            consumer:["had"],
            performer:["did","played","watched"]
        }
    },
    dependentAction:{
        consumer:["food","fun","badtime"],
        performer:["movie","cricket","song","dance"]
    },
    independentAction:["Cooking","Playing","singing"],
    adjective:["good","bad","excellent","awesome"],
    object:["boy","Person","girl","Human being","Man","Mental"]
}

var referenceBook={
    figure:["fp","sp","tp"],
    time:["present","past"],
    singularity:["singular","plural"],
    verState:{
        present:["continuous"],
        past:["continuous","simple"]
    },
    objectRole:["consumer","performer"]
};

function getTerm(term) {
    var cur = referenceBook[term] || [];
    var randomIndex = Math.ceil((Math.random() * 93967)) % cur.length;
    return cur[randomIndex]

}
function getToken(key) {
    var path = key.split("-");
    var token = vocab;
    path.forEach(function(s) {
        token = token[s];
   });

    return token[Math.ceil((Math.random() * 1000)) % token.length];

}

function generateSentence(rules) {
    rules.forEach(function(str) {
        var m = str.match(/{[^}]*}/g)

        var variable = {};
        if (m) {
            m.forEach(function(s) {
                s = s.replace(/(^{)|(}$)/g, "");
                variable[s] = getTerm(s);
            });

            for (var each in variable) {
                str = str.replace(new RegExp("{" + each + "}", 'g'), variable[each]);

            }
        }
        var cur = str.split("|");
        var sentence = "";
        cur.forEach(function(s) {
            sentence += " " + getToken(s);

        })
        console.log(sentence);

    })


};
/*

In the rules array, I specify rules for the sentence to be genrated

*/

var rules = [
    "noun-{figure}-{singularity}|verbIndicator-{figure}-{time}-{singularity}|verb-continuous-{objectRole}|dependentAction-{objectRole}", 
    "noun-sp-singular|adjective|object"
];

generateSentence(rules);