Problem:

Erzeugen Sie einen Satz, der gelesen und verstanden werden kann. Es muss ein Subjekt, ein Verb und ein Objekt enthalten, und Zeitformen und Pluralformen müssen übereinstimmen. Das Programm muss auch in der Lage sein, mehrere unterschiedliche Sätze zu generieren, um sich zu qualifizieren.

Regeln:

• Das Hardcodieren von Sätzen ist nicht erlaubt und es wird auch nicht direkt aus einer Datei gelesen (ich schaue dich an, unclemeat)
• Sie können beliebig viele Wortlisten anlegen
• Senden Sie einen Beispielsatz oder 2, die von Ihrem Programm generiert wurden
• Jede Sprache wird akzeptiert
• Es ist ein Beliebtheitswettbewerb , also gewinnt die am meisten bewertete Antwort

Bash

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

Anforderungen: Linux-Kernel-Quelle in / usr / src installiert

Dadurch werden zufällige Kommentare aus der Kernelquelle entfernt. Ob die Sätze tatsächlich verständlich sind, ist umstritten.

Beispiele für die tatsächliche Ausgabe:

• 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

Beispiel für Ausgänge:

>> 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.

[Dies ist eines von Matlabs Ostereiern]

BEARBEITEN: Sie können den Code dieser Funktion hier sehen: why.m

PHP

Wenn genügend Zeit zur Verfügung steht, wird daraus die gesamte Literatur der Vergangenheit, Gegenwart und Zukunft hervorgehen. In den Regeln wurde nicht erwähnt, dass kein anderer Text erstellt werden darf.

Die Zeichenfolge 'TOS...'bietet eine logarithmische Häufigkeit der Buchstaben, um die Übereinstimmung mit Englisch zu verbessern. Dies wird verwendet, um eine größere Zeichenfolge mit den ungefähren relativen Buchstabenfrequenzen zu generieren.

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

Ich habe dabei solche literarischen Schätze entdeckt, wie:

• GO NOW- Sie als Subjekt sind impliziert.
• IM AOK - Mir geht es gut
• IM FDR - Ich bin F (ranklin) D (eleano) R (oosevelt)

Außerdem gibt es zahlreiche Anreize, um das Missfallen über die aktuelle Situation kurz auszudrücken. [Einige Briefe redigiert.]

• F**K
• S**T

Folgendes unter Verwendung der fein abgestimmten Skalierung:

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

C

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

Beispielausgabe:

Durch Software verursachter Verbindungsabbruch
Unterbrochener Systemaufruf sollte neu gestartet werden

Es gibt auch viele gültige Sätze ohne Subjekt, Verb und Objekt:

Timer abgelaufen
Datei existiert

Java

Zieht den Intro-Satz aus einem zufälligen Wikipedia-Artikel:

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 + ".");
    }
}

Manchmal hat man Pech; Ich versuche dies zu minimieren, indem ich eine minimale Satzlänge einstelle und Sätze herausfiltere, die mit ":" enden (alle Disambiguierungsseiten beginnen auf diese Weise) oder ein "?" (Es scheint viele Artikel mit ungelösten unbekannten Informationen zu geben, die mit Fragezeichen markiert sind). Satzgrenzen sind ein Punkt, gefolgt von einem Leerzeichen, gefolgt von einer Zahl oder einem Großbuchstaben.

Ich filtere auch Text in Klammern heraus (das Ergebnis ist immer noch ein gültiger Satz), um zu versuchen, einige Punkte zu entfernen, die keine Satzgrenzen sind. Ich filtere eckige Klammern heraus, um Quellenzitierungsnummern zu entfernen. Beispiele:

• Idle Cure war eine Arena-Rockband aus Long Beach, Kalifornien.
• Selbstfokussierung ist ein nichtlinearer optischer Prozess, der durch die Änderung des Brechungsindex von Materialien hervorgerufen wird, die intensiver elektromagnetischer Strahlung ausgesetzt sind.
• TB10Cs4H3 ist ein Mitglied der H / ACA-ähnlichen Klasse nichtkodierender RNA-Moleküle, die die Modifikationsstellen von Uridinen zu Pseudouridinen von Substrat-RNAs steuern.
• Der sechsköpfige wilde Widder in der sumerischen Mythologie war einer der Helden, die Ninurta, der Schutzgott von Lagash, im alten Irak erschlagen hatte.
• Sugar Daddy ist ein Slang-Begriff für einen Mann, der anbietet, eine typisch jüngere Frau oder einen typischen jüngeren Mann zu unterstützen, nachdem er eine Beziehung aufgebaut hat, die normalerweise sexuell ist.
• Die Old Bethel United Methodist Church befindet sich in der 222 Calhoun St., Charleston, South Carolina.
• Douglas Geers ist ein amerikanischer Komponist.

Wenn Sie Grammatikprobleme bemerken, liegt das daran, dass Sie kein sorgfältiger Wikipedia-Editor sind! ;-)

Soooo ... Da dies ein Beliebtheitswettbewerb ist , hatte ich ein bisschen Spaß mit evalund mit Funktionen. Grundsätzlich generiere ich eine Zufallszahl und führe dann eine auf dieser Zahl basierende Zufallsfunktion (in deinem Gesicht switch,!) Über aus eval.

PHP, ~ 9k gültige Ausgaben

<?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."();");

?>

Einige Ausgänge ...

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!

PHP + Projekt Gutenberg

Ich habe ein PHP-Skript geschrieben, das ein einfaches Textdokument in eine Reihe von Wort-Bigrammen umwandelt , aus denen dann zufällige Sätze generiert werden. Hier sind einige der besseren Beispiele, die aus der gesamten Klartextversion von Patrick Henrys Rede "Gib mir Freiheit oder gib mir den Tod" stammen , einschließlich des Kleingedruckten des Projekts Gutenberg:

• Das Projekt Gutenberg Völkertext und Sklaverei!

• Wir entschuldigen uns für das 200-jährige Bestehen dieses Kleingedruckten!

• SIE HABEN KEINE ANDEREN GEWÄHRLEISTUNGEN JEGLICHER ART, AUSDRÜCKLICHER ODER UNBEABSICHTIGTER SCHÄDEN, aber für mich der Tod!

Hier können Sie es selbst ausprobieren. Aktualisieren Sie die Seite für einen neuen Satzstapel.

Wenn Sie den Quellcode selbst ausführen möchten, vergessen Sie nicht, den $src_textvon Ihnen gewählten Klartext zu laden .

<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

Dieser Eintrag wählt Wörter aus dem gesamten Systemwörterbuch aus. Es nutzt die Tatsache aus, dass Sie die meisten Substantive in Verben umwandeln können und umgekehrt. Es werden einige Heuristiken verwendet, um Wörter zu klassifizieren und offensichtliche Unmöglichkeiten zu vermeiden.

Daraus ergeben sich einige beinahe vernünftige Aussagen:

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

Viele verrückte:

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

Und viele Sachen, die so klingen, als würde Monty Python unzüchtige Anspielungen machen:

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.

Version 3 wurde so geändert, dass eine beliebige Textdatei als Eingabe verwendet wird:

$ 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+'.'

Bash

Inspiriert von der Matlab-Antwort. Angenommen, Sie haben aptitudeinstalliert.

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

Mögliche Ausgaben (Screenshot aus diesem Wikipedia-Artikel)

Python:

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

Proben:

• Büffel Büffel Büffel.
• Büffelbüffelbüffelbüffelbüffelbüffelbüffel.

Leider ist der Umgang mit Zeichensetzung und Großschreibung etwas mangelhaft, aber andererseits wurden diese nicht als Anforderungen aufgeführt.

Auch hier ist ein Hinweis.

Rust + Toki Pona

Da jede Sprache akzeptiert wird, habe ich ein Programm in Rust geschrieben , das einige Sätze in Toki Pona erzeugt .

Toki Pona ist ein Versuch, eine minimale natürliche Sprache zu erschaffen, und es hat eine super einfache und regelmäßige Grammatik. Das ist eine sehr nützliche Eigenschaft für diesen Wettbewerb!

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

Ich spreche kein Toki Pona, aber ich habe die Syntax von Toki Pona als Satz von BNF-Regeln in Wikipedia gefunden. Ich habe für jede BNF-Regel eine Struktur oder eine Aufzählung erstellt und diese mit Anmerkungen versehen deriving(Rand), sodass ich eine Phrasekostenlose Zufallsstruktur generieren kann ! Dann habe ich ToStrfür jede dieser Strukturen implementiert, um sie in eine Zeichenfolge zu konvertieren.

Ich habe die Strukturnamen absichtlich auf Französisch belassen, weil die BNF-Regeln, die ich gefunden habe, auf Französisch sind und auch, weil sie die Mehrsprachigkeit meines Beitrags wieder in den Vordergrund rücken!

Beispielausgaben

Einige Ausgaben und ihre Übersetzungen, die ich basierend auf den BNF-Regeln und einem Toki Pona-Wörterbuch gemacht habe . Ich bin mir sicher, dass diese Übersetzungen größtenteils falsch sind, aber Toki Pona lässt tatsächlich viel Raum für die Interpretation eines Satzes.

nasin mi tawa la jan li jaki

Während meiner Reise verschmutzte jemand

monsi li jaki li jan ike musi

Der Hintern ist schmutzig und ist eine lustige schlechte Person

sina li tawa ale jelo e kili tawa e insa

Sie haben die Frucht und das Zentrum in das gelbe Universum versetzt

Probleme

• Ich überprüfe nicht, ob ein Verb transitiv ist oder nicht, daher sind einige Sätze grammatikalisch falsch.
• Einige Strukturen sind rekursiv, und wenn eine Regel wiederholt werden kann, entscheide ich mich nach dem Zufallsprinzip für die Ausgabe von 0, 1 oder 2 Elementen. Dies kann zu sehr langen Sätzen führen, die Tausende von Wörtern enthalten ...
• Ich kann die Gültigkeit der Ausgabe nicht wirklich überprüfen, ich verlasse mich ausschließlich auf die BNF-Syntax, das Wörterbuch und meine eigenen wilden Vermutungen :)

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

Verwenden Sie das Backtracking von Prolog und eine generative Grammatik, die der englischen Grammatik nahekommt, um alle möglichen Sätze zu generieren .

Diese Version hat eine ziemlich begrenzte Vokabular- und Satzstruktur, sollte aber ziemlich einfach zu erweitern sein.

Der 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, []).

Führen Sie diese Abfrage aus:

sentence(L).

alle möglichen Sätze in dieser Sprache zu generieren.

Einige Beispielausgaben:

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: Erlaube Objekt-Nebensätze).

Python

Wie Sie wissen, können Sie in Python mit wenigen imports alles tun . Diese einfache Aufgabe kann mit diesem zweizeiligen Python-Skript erledigt werden.

import random

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

Die Anzahl der Sätze, die von diesem Skript generiert werden, ist recht groß: 10^12verschiedene Sätze. Wenn das Lesen einer Sitzung ca. 0,5 Sekunden dauert, dauert das Lesen aller Sätze mehr als 15000 Jahre!

Einige Beispielsätze:

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

Alle erzeugten Sätze enthalten jedoch ein Subjekt, ein Verb und ein Objekt.

AKTUALISIEREN:

Ich erhielt einige Kritiken über einige raffinierte Wörter, die dieses komplexe Werkzeug hervorbringen könnte. Hier ist eine etwas längere Version, die mit den meisten Wortlisten übereinstimmen sollte.

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))])+'.')

Hier sind einige Beispielsätze:

• 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.

Spielen mit dem internen Mathematica-Wörterbuch:

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

Sie haben Glück, sagen wir 70% der Zeit. Es erzeugt Dinge wie:

eine Amygdala elektrische Schaltung
dort Parkia war unrestrictive zackig obwohl
seine longanimous Gesellschaft
Doktor der Bildung unverständliche Antwort auf Kibbuz
wenig Musiktheater gegen Julius Caesar
ein Tai Kleiber
mähen in sportlichen Zentrum contra dein niggardliness
die erforderlichen extrinsische Detergentien
sans nekromantischen Hexer
diese Vena pectoralis mir gegenüber latria Trophäe Frau richtungsweisenden Investoren braun,
was für ein tragbares Feld von Feuer
umbra charmant, worauf meine Antwort eine
andere schraubenlose Trümmer Sturm geruchlos aslant Aral Sea komplexe Waffel
für angebliche Freude mongoloiden Typ Metall

aber manchmal:

Meine Adoption pro Lutzens Schlacht würde sich auszahlen, während Hejira von der
Gattung Seiurus, die neun gemeinsame Shiner-Subduktionen enthält, ihr Publikum herzerwärmte

Na ja, es spricht besser Englisch als ich.

VBA / Excel

[edit 2]

Haben gelernt, wie man Verben konjugiert. Die folgenden Beispiele sind einfache Vergangenheitsform:

Das gemäßigte Wildkokain folgte der historischen Sofortentscheidung. Das regionale Sicherheitskapitel schnappte innerhalb der zahlreichen zufälligen Entität. Die gelbe rechte Domäne wurde hinter dem magnetischen fragilen Geschlecht entfernt. Die physische tödliche Verschmutzung begann nach dem toten, armen Gefühl. Das kognitiv mutige Theater rückte an die Spitze der fragilen, bewussten Literatur. Der herkömmliche tatsächliche Ausgang widerstand der bevorzugten Immunstelle. Der feste wirtschaftliche Zwilling, der aus der bösen menschlichen Notwendigkeit erkannt wurde.

Es folgt der entsprechende Code, mit Ausnahme einiger langweiliger Hilfsparsing- und Schleifenfunktionen. Die Hauptteile, die fehlen, sind die verschiedenen Wortlisten (nach Teilen der Sprache), die Pluralisierung, Zeitformen, Konjugationen usw. ausführen.

Alle Wortwurzeln werden zufällig ausgewählt, aber ich zwinge sie, in einem bestimmten Satzmuster angeordnet zu werden:

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

... das ist, was ich verwendet habe, um die Ausgabe oben zu erzeugen. Es folgt die allgemeine Form von "Der schnelle Rotfuchs sprang über den faulen braunen Hund."

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

[ursprünglicher Beitrag beginnen]

Noch in Arbeit, muss Logik für Zeiten und Substantiv / Verb-Pluralisierung hinzugefügt werden, nämlich:

Ihre durchschnittliche Reise unsere angenommene Dosis noch ein Temperaturanstieg über meine Tomate hinaus.

... was syntaktisch analysiert werden kann, aber wenig Sinn ergibt.

Die Programmierung ermöglicht ihrem dreckigen Angler fern unserer Schweineguss stattdessen keinen Satz.

Richtig. Nicht wirklich ein Satz, aber besser als einige JavaScript-Fehlermeldungen.

Sein Appell hebt jede Live-Frage auf, die meine Dame ihr Englisch überflügelt.

Die Anspielung Routine ist fast erstklassig, obwohl ...

Code, um anon zu folgen. Hat dieser Wettbewerb eine Deadline?

[edit 1]

Code, der das oben Genannte generiert hat.

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, der Mut des Programms ist genau das:

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

Es ist im Grunde ein "madlib" Motor. Um tatsächlich interessante Sätze zu generieren, müssen Sie %padeinige Daten eingeben. Hier ist ein Beispiel %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',
  ],
);

Hier sind einige Beispiele der Weisheit, die ich daraus entdeckt habe %pad. Diese Sätze wurden nicht nach Länge, Interpunktion, Grammatik usw. bearbeitet, obwohl ich einige uninteressante herausgesucht und die Reihenfolge, in der die Sätze erscheinen, neu geordnet habe - sie sind nicht mehr in der Reihenfolge, in der sie erzeugt wurden, sondern ich versuche es Verwenden Sie sie, um eine Geschichte zu erzählen: eine Geschichte, die Sie hoffentlich sowohl berühren als auch zum Nachdenken anregen wird.

• Spinnennetze sind kurz.
• Spinnennetze faszinieren regelmäßig.
• Kleine Affen funkeln, aber Spinnweben trinken gierig.
• Funkelnde (noch übel riechende) Affen folgten dem winzigen (noch funkelnden) Gorilla.
• Der Gipfel des Mount Everest begrüßte den hochdekorierten Stegosaurier.
• Nicht nur der Gipfel des Mount Everest ist teuer, sondern auch die Besetzung der Fernsehsendung "Glee" folgte dem funkelnden Gorilla.
• Die Besetzung von "Glee" im Fernsehen ähnelt dem lila Briefkasten.
• Der teure Briefkasten ist groß, und der teure Stegosaurier springt auf Chuck Norris, doch grüne Schuhe sprangen auf das Rindfleischsalat-Sandwich.
• Das Rindfleischsalat Sandwich liebte Chuck Norris.
• Millionen funkelnder Aale sind grün (und doch gespenstisch).

Frau Word

Ich bin nicht sicher, ob dies akzeptabel ist, aber da HTML dies ist, denke ich, sollte dies auch akzeptabel sein.

 =rand(1,1)

Beispielsätze:

Auf der Registerkarte Einfügen enthalten die Galerien Elemente, die so gestaltet sind, dass sie mit dem allgemeinen Erscheinungsbild Ihres Dokuments übereinstimmen.

Mit diesen Galerien können Sie Tabellen, Kopf- und Fußzeilen, Listen, Deckblätter und andere Dokumentbausteine ​​einfügen.

Sie können auch eine beliebige Anzahl von Sätzen und Absätzen angeben.

Eine laufende Arbeit mit JSoup und 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);
        }
    }

}

Probleme:

• Sätze sind zu einfach
• Gelegentlich 404s (ohne gutes Handling!)
• Es wird immer nur ein Satz erzeugt
• Verwendet ein Schaltergehäuse!

Beispielausgaben:

Popoloca prickethes Prunkbohnen.
Tropic of Capricorn strahlt Körper aus.
Peking synonymiseds Kissenkästen.
Chukchis kultiviert das Beeinflussen.

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

Hiermit werden die 30 am häufigsten verwendeten Google-Suchanfragen abgerufen, eine Suche nach "Ich fühle mich glücklich" durchgeführt und anschließend ein zufälliger Satz von dieser Seite mit mindestens 3 Wörtern angezeigt.

Beispiele:

"Sie wurde als Medaillenfavoritin der Veranstaltung angesehen."

"Kate hat die High School ein Jahr früher abgeschlossen."

"15. April 2014, um die Einhaltung der Richtlinie zu Biografien lebender Menschen zu fördern."

"Im Namen von Bryan möchten wir, seine Familie, uns bei allen für die Ausgießung von Liebe, Gebeten und Unterstützung bedanken."

"In diesem Artikel geht es um den amerikanischen Basketballspieler."

"Entschuldigung, in Ihrem Browser ist entweder JavaScript deaktiviert oder es wird kein Player unterstützt."

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])"

Ausgabe:

Erzeugen Sie einen Satz, der gelesen und verstanden werden kann

Shell Scripting

In diesem Skript wird immer der Titel der ersten Frage angezeigt, die sich derzeit oben auf dieser Site befindet. Ich gehe davon aus, dass der Fragentitel immer für Menschen lesbar ist. Und es wird sich dynamisch ändern. Wenn eine neue Frage eingeht und das Skript ausgeführt wird, wird der neueste Fragentitel angezeigt.

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

Versuch 1 Ausgabe

Find words containing every vowel

Versuch 2 Ausgabe

Hello World 0.0!

BEARBEITEN

Keine Dateien verwenden. Ohne Dateien kann ich das folgende Skript verwenden.

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

Ausgabe

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

Das Ausführen in der Konsole erzeugt

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

Noch ein Python-Skript

Die Antwort von user3058846 ist nicht schlecht, aber es werden jedes Mal alle Sätze angezeigt. Hier schlage ich ein Skript vor, das einen zufälligen Satz aus dem Zen of Python ausgibt :

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

In einer Zeile für Code-Golf- Fans:

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, dreckig.)}}

Beispiele:

>>> 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.

Ein weiterer lustiger Weg in Python

Danke an @TheDoctor für die Idee :-) Schalte die Importausgabe stumm und spiele dann mit dem pseudo-verschlüsselten Diktat im Modul.

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

Garantiert grammatikalische Ausgaben! (Gewöhnlich.)

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)

Löschen Sie den Unterstrich von, um die Grammatik zu optimieren wordregex. Dies verbietet Einträge mit mehreren Wörtern, die zu schlechten Sätzen wie "Wir machen Sie fertig" führen.

Probelauf:

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?

Bisherige Lieblingsausgabe:

They you her.

Nachschlagen: http://en.wiktionary.org/wiki/you#Verb .

Python

Ergebnis:

$ 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)

Ich habe die Wortliste von hier verwendet. Finde Wörter, die jeden Vokal enthalten

Einige weitere Regeln können hinzugefügt werden. Wenn beispielsweise ein Wort, das mit "ness" endet, und das Wort auch in set ohne das Suffix vorhanden ist, handelt es sich um ein Nomen.

Quellcode:

#!/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

Bash

Der Versuch, ein Programm auszuführen, das existiert, aber nicht installiert ist, führt dazu (in 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

Eine weitere Einstellung von The Zen of Python , inspiriert von Maximes Antwort .

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