产生易于理解的句子


55

问题:

生成一个可以阅读和理解的句子。它必须包含一个主语,动词和宾语,并且时态和复数必须匹配。该程序还必须能够生成几个不同的句子以符合条件。

规则:

  • 不允许对句子进行硬编码,也不能直接从文件中读取它们(我在看着你,很顺利)
  • 您可以有任意数量的单词列表
  • 提交由您的程序生成的示例句子或2
  • 接受任何语言
  • 这是一场,因此最受好评的答案胜出

7
我认为从某些答案(MatLab,我在看您)中可以很明显地看出,您应该修改规则,以便不允许数据挖掘从任何来源提取连续的单词。
2014年

当我成为聪明人的时候:由于这纯粹是一场人气大赛,因此应该只发布HotModelBikini jpg。那将获得比任何东西更多的选票。
2014年

7
如果有人使用“水牛”或“鱼”的重复词作为例句,我将予以支持!

7
这里的大多数答案都是从文本源中挖掘有效的完整句子,或者生成不符合条件的输出。在我看来,这两种方法似乎都与问题的精神背道而驰!如果有人真的想给人留下深刻的印象,我是否可以建议一个程序,该程序以一组有效的句子结构(例如[Adjective] [pl. noun] [verb] [adjective] [pl. noun],从真实词典中提取)作为开头(可能使用其中可用的Dictionary API之一)来填补空白?如果有空闲时间,我会自己写的!:(毕竟...Lazy Developers Write Lousy Programs.
Brian Lacy 2014年

1
@Pureferret单词列表将是单个单词的列表。硬编码将是完整句子的列表。使用单词列表,您通常需要在程序中添加一些逻辑以拼凑出完整的句子。使用硬编码的句子,您基本上只需要打印语句。
8bittree 2014年

Answers:


87

重击

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

要求:Linux内核源代码安装在/ usr / src中

这将随机注释从内核源代码中拉出。这些句子是否真正可以理解尚有争议。

实际输出示例:

  • 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

12
好一个!您应该将它们全部拉出并作为正式fortune数据库提交。
杰森·C

18
“ ???” 有史以来最好的评论
2014年

4
是否违反了“不直接从文件中读取它们”的第一条规则?
kuldeep.kamboj 2014年

6
我会说搜索系统源代码并从注释中过滤掉文本并没有真正算作“直接阅读”。
暴动

7
Slave Overflow。好听的名字为SE网站
TheDoctor

95

Matlab的

why

输出示例:

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

[这是Matlab的复活节彩蛋之一]

编辑:您可以在这里看到此函数的代码:why.m



8
第二个例子不是句子。这是一个不定式的短语。
wchargin

2
这里必不可少的答案不仅会产生句子(例如,请看其他获得较高评价的答案)。任务并没有说它只能创建句子,而是说它必须能够产生句子。
以利沙

51

的PHP

如果有足够的时间,这将产生过去,现在和将来的所有文献。规则没有提到没有其他文字可以产生。

该字符串'TOS...'提供字母的对数刻度频率,以更紧密地匹配英语。这用于生成具有近似相对字母频率的较大字符串。

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

运行它,我发现了以下文学瑰宝:

  • GO NOW- 暗示是一个主题。
  • IM AOK -我很好
  • IM FDR -我是F(ranklin)D(eleano)R(oosevelt)

另外,许多煽动者对当前情况简明表示不满。[一些字母被删除。]

  • F**K
  • S**T

同样,以下使用微调的缩放比例:

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

60
为什么,一堆猴子可以做同样的事情!
Tim S.

11
我喜欢!现在,创建一个程序来处理由此产生的字母并找到可理解的句子!:)
TheDoctor 2014年

2
+1-是否有机会使发现部分自动化?任务似乎是产生一个*(?)句子。顺便说一句:您花了多少时间;)
沃尔夫(Wolf

20
你是怎么F**KS**T提供不存在*'ABCDEFGHIJKMLNOPQRSTUVWXYZ '
glglgl 2014年

3
@Ypnypn- 'TOS...'字符串代表对数刻度中每个字母的频率。所以A有频率TB有频率OJ的最低频率A等于0,倒数为1。最后一个字符是空格,其频率为Zround或round(exp(25 / 3.976))= 538,因此空格的出现频率是的538倍J。只是认为这使“ 打字机猴子”问题整洁

42

C

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

输出示例:

软件引起的连接中断
中断的系统调用应重新启动

还有很多没有主语,动词和宾语的有效句子输出:

计时器已过期
文件存在


如何以及何时终止?(可以,但是我不明白为什么)
phil294

1
@Blauhirn --iichar初始值为0 的类型的变量)再次达到0 时,循环终止条件的值为false 。如果char是未签名的(例如ARM),i则将立即回绕到其最大值(通常为255)并递减为0。如果char是已签名的(大多数Intel系统),则行为严格来说是未定义的,但通常在达到最小值后(通常为-128),它将绕回其最大值(通常为127),并递减至0。因此,该程序通常将总共打印256行。
ecatmur

37

爪哇

从随机的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 + ".");
    }
}

有时你会倒霉;我试图通过设置最小句子长度并过滤掉以“:”(所有歧义页面以这种方式开头)或包含“?”结尾的句子来最小化此问题。(似乎有许多文章带有未解决的未知信息,并带有问号)。句子边界是一个句点,后跟空格,后跟数字或大写字母。

我还过滤掉括号中的文本(结果仍然是一个有效的句子),以尝试删除一些不是句子边界的句点。我过滤出方括号以删除源引文编号。例子:

  • Idle Cure是来自加利福尼亚长滩的竞技场摇滚乐队。
  • 自聚焦是由暴露于强电磁辐射的材料的折射率变化引起的非线性光学过程。
  • TB10Cs4H3是类H / ACA的非编码RNA分子的成员,它指导尿苷修饰为底物RNA的假尿苷。
  • 苏美尔神话中的六头野公羊是拉古什的赞助神尼努尔塔(Ninurta)杀死的古代英雄之一。
  • 傍大款是一个男人的语,在建立起通常是性关系的男人后,他愿意为典型的年轻女人或男人提供支持。
  • 老伯特利联合卫理公会教堂位于南卡罗来纳州查尔斯顿的222 Calhoun St.。
  • 道格拉斯·盖尔斯(Douglas Geers)是美国作曲家。

如果您发现任何语法问题,那么,这就是您不努力学习Wikipedia的错误!;-)


4
“有效”和“可理解”之间肯定有区别。宝贝,我这里有一些底物RNA假尿苷。
杰森·C

1
我第一次运行它时是这样的:Echinolittorina africana / Litorina africana Philippi,1847 / Litorina decollat​​a Philippi,1847 / Littorina africana / Littorina perplexa Turton,1932 / Nodilittorina africana./似乎有些维基页面应该从您的网站中排除搜索!;) 哈哈!OMG,我第二次运行它,它从Mikhail Gorbachev的Wiki页面返回了一行。谁分享我的名字。很怪异。
mikhailcazi14年

2
“ /”实际上并不存在!哈哈:PI用它来表示新行。也许我应该使用\ n。从这里:en.wikipedia.org/wiki/Afrolittorina_africana。右边的表在同义词下:)无论如何,这并不是一个不好的印象,所以请不要担心,因为Mikhail Gorbachev的事情很酷。之后的所有句子都是正常的。
mikhailcazi

2
您可能会发现该《物理学》答案是其中一篇文章的近期有趣的共同用户。
EP

2
这可能是概率的一个常见但高度不直观的方面:在拥有数十亿人口的世界中,百万分之一的事件可能很常见。也就是说,我不确定形式分析会说些什么。我也很惊讶!您可能还会注意到,其中不涉及“其他人”。
EP

34

太好了...因为这是,所以我在eval使用功能方面感到很开心。基本上,我会生成一个随机数,然后通过来基于该数字(在您的脸switch!)执行随机函数eval

PHP,〜9k有效输出

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

?>

一些输出...

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!

@ nyuszika7h,PHP_EOL仅等于\n\r\n,取决于操作系统,但绝不等于<br>或类似。
timmyRS

@timmyRS是的,您是对的,这是一条旧评论,我不知道当时为什么写。
nyuszika7h

33

PHP +古腾堡计划

我写了一个PHP脚本,将纯文本文档转换为单词bigrams集合,然后将其用于生成随机句子。以下是帕特里克·亨利Patrick Henry)的“给我自由或让我死亡”演讲的纯文本版本(包括古腾堡计划的小字)所产生的一些更好的示例:

  • 国家和奴隶制的古腾堡计划文本!

  • 对于此小字200周年,我们深表歉意!

  • 您没有任何其他形式的明示或偶发性损害的保证,但是对我来说,死亡!

您可以在这里自己尝试。刷新页面以查找新的句子。

如果要自己运行源代码,请不要忘记加载$src_text所选的纯文本。

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

+10这真的是挑战精神!我现在找不到它,但是曾经有一个基于Google的在线句子生成器,其工作方式与此类似,但是bigrams(或可选的更大的n-gram)是通过搜索单词并观察从Google搜索结果中得出的在搜索结果预览摘要中紧随其后的是什么。也许我会重新创建它并将其发布在这里。
杰森C

这个怎么样!“先生,我们发现哪一个很高兴改善比赛。” 还是这个!“他们告诉我们,要改善Etext 6的这一部分,要付出可怕的代价”最后更新日期:2005年5月5日,仅针对我们的战斗而正式发布。”
Hosch250 2014年

1
But for me, death!:DI希望所有许可/协议都以同样强烈的态度结束。
纳文2014年

哈哈,“仅针对我们的战斗而正式发布。”
杰森C

1
我什么都没收到。:(
TheNumberOne 2015年

29

蟒蛇

此项从整个系统词典中选择单词。它利用了您可以将大多数名词变成动词,反之亦然的优势。它使用一些启发式方法对单词进行分类,并避免明显的可能性。

它产生了一些近乎理智的声明:

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

许多疯狂的:

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

还有很多听起来像Monty Python的小东西:

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.

版本3已修改为将任何文本文件作为输入:

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

代码(版本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+'.'

3
例句使我笑得很厉害,我在哭!xD
mikhailcazi14年

cat FILE | COMMANDUUOC ;)
nyuszika7h 2014年

谢谢@ nyuszika7h,我今天学到了一些东西。打破旧习惯可能很难...
AShelly

1
This smoke toasted some nonresidents.。哇。
phil294

25

重击

受到Matlab答案的启发。假设您已aptitude安装。

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

可能的输出(维基百科文章的屏幕截图)

在此处输入图片说明


7
我认为这不是. /----\ -------/ \ / \ / | -----------------/ --------\ ----------------------------------------------一个有效的句子。
svick 2014年

1
@svick you win可以是一个句子(隐含对象“ argument”)。即使不是,问题也不会禁止输出无效的情况。
ace_HongKong独立

23

蟒蛇:

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

样品:

  • 水牛城。
  • 布法罗水牛布法罗布法罗布法罗布法罗布法罗布法罗。

不幸的是,它对标点符号和大写字母的处理有些差,但是同样也没有将其列为要求。

另外,这里是参考。


3
不要在水牛文字上添加空格;改为使用' '.join(l)。那将摆脱尾随的空间。然后,您可以追加一个句点。
Blacklight Shining

@BlacklightShining更新了它。谢谢你的建议。
8bittree 2014年

别客气。+1代表水牛。:)
Blacklight Shining


1
itertools表示,print " ".join(takewhile(lambda _: randint(0, 5), repeat("buffalo"))).capitalize() + "."
nmclean 2014年

16

锈+ Toki Pona

任何语言都可以接受,因此我用Rust编写了一个程序,该程序在Toki Pona中生成了一些句子。

Toki Pona尝试创建一种最小限度的自然语言,并且具有超简单且规则的语法。这是本次比赛的一个非常有用的属性!

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

我不会讲Toki Pona,但是我在Wikipedia上发现Toki Pona语法是一组BNF规则。我为每个BNF规则创建了一个结构或枚举,并用对其进行了注释deriving(Rand),这为我提供了一种Phrase免费生成随机结构的方法!然后,我ToStr为每个这些结构实现了将它们转换为字符串的方法。

我故意将结构名称保留为法语,因为我发现的BNF规则使用法语,而且还因为它增强了我提交内容的多语言性质!

样本输出

我根据BNF规则Toki Pona词典做了一些输出及其翻译。我确信这些翻译大部分都是错误的,但是Toki Pona实际上为句子的解释留出了很大的空间。

纳辛·塔瓦·拉扬·李·贾基

在我旅行期间,有人污染了

孟西·李·贾基·李·简·穆西

屁股很脏,是个有趣的坏人

新浪微博

您将水果和中心移至黄色宇宙

问题

  • 我不检查动词是否具有及物性,因此某些句子在语法上不正确。
  • 有些结构是递归的,当规则可以重复时,我随机选择输出0、1或2个元素。这可能会导致veeeeeery生成长句子,其中包含数千个单词...
  • 我不能真正验证输出的有效性,我完全依赖BNF语法,字典和我自己的疯狂猜测:)

1
=>“您将水果和中心移到了黄色的宇宙中”对于一台机器来说非常不错,通常只有高级的tp用户才能使用转换构造。
MatthewMartin

1
屁股(屁股?混蛋?)很脏,是个可笑的坏人。
MatthewMartin 2014年

1
嘿,谢谢您的评论,@ MatthewMartin!我当然没想到Toki Pona的演讲者会看我的论文,但我很高兴知道这些感官并不完整:)
barjak 2014年

提示:这不是代码高尔夫球。
nyuszika7h 2014年

1
@ nyuszika7h我不确定您的评论的目的是什么。确实,这不是一场代码高尔夫,而是一场人气比赛。
barjak 2014年

14

蟒蛇

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!

7
你能说那import antigravity导致了产出I LEARNED IT LAST NIGHT! EVERYTHING IS SO SIMPLE!吗?:D
ace_HongKong独立2014年

毫无疑问,是的。
Renae Lider

14

序言

使用prolog的回溯和近似英语语法的生成语法来生成所有可能的句子。

这个版本的词汇和句子结构相当有限,但是应该很容易扩展。

编码:

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

运行此查询:

sentence(L).

以这种语言生成所有可能的句子。

一些样本输出:

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

(编辑:允许对象从属子句)。


1
有例句输出吗?
TheDoctor 2014年

是的,我在答案中放了一些样本。尽管它总共产生2520个输出,所以我不能全部发布...
chrisd 2014年

11

蟒蛇

如您所知,您可以使用imports 进行python操作。这个简单的任务可以用这2行python脚本来完成。

import random

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

该脚本生成的句子数量非常庞大:10^12不同的句子。如果阅读一本句子大约需要0.5秒,那么阅读它们将花费超过15000年!

一些例句:

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

然而,所有生成的句子都包含一个主语,一个动词和一个宾语。

更新:

我收到了对该复杂工具可能产生的一些复杂单词的批评。这是一个稍长的版本,应该与大多数单词列表一致。

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

以下是一些示例句子:

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

我在字典中找不到您的某些单词
belisarius博士2014年

5
我调整了软件以更好地适应您的不良字典。
Antonio Ragagnin 2014年

2
好。在15000年后,我将发布证明以确保全部找到
belisarius博士2014年

10

玩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

例如,您有70%的时间很幸运。它生成如下内容:

一个杏仁电路
那边球花豆属是不受限制的,虽然衣衫褴褛的
他longanimous社会
博士生教育不知所云回复到基布兹
对凯撒的小音乐剧
的大五十雀
修剪下来嬉戏中心禁忌你niggardliness
所需的外在洗涤剂
SANS死灵巫师
这些腔胸大肌矿latria相反奖杯妻子引领潮流的投资者布朗
什么是随身携带的
火影本色迷人的地方到我的答案
另一个螺丝松动的碎片风暴无味的倾斜咸海复杂的华夫饼
适合自称蒙古型金属

但是有时:

我的领养者最不愿交战的卢岑会在切肉刀的赫吉拉(Hejira)的
九个普通发光俯仰类塞尤鲁斯(Seiurus)的那段时间里吸引观众

哦,对,它对英语的使用要比我的好。


8

VBA / Excel

[编辑2]

教过它如何使动词变位,下面的例子是简单的过去式:

温和的野生可卡因与历史性的即时决定并驾齐驱。区域安全章节在众多随机实体的内部迅速响起。黄色的右磁畴在磁性脆弱的性别后面消失了。致命的肉体污染开始超过死亡的不良感觉。认知勇敢的剧院走到了脆弱的意识文学的前沿。常规的实际输出抵抗远离喜欢的免疫部位。固定的经济双胞胎从邪恶的人类需要中认识到了这一点。

相关代码如下,其中不包括一堆无聊的辅助解析和循环函数。缺少的主要部分是各种单词列表(按词性排列),它们进行了复数形式,时态,词缀变化等。

所有单词词根都是随机选择的,但是我强迫它们按照特定的句子模式排列:

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

...这就是我用来生成上述输出的内容。它遵循的一般形式是“快速的红狐狸跳过了懒惰的棕色狗”。

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

[开始原始帖子]

仍在进行中,需要为时态和名词/动词复数添加逻辑,即:

您的平均旅行达到了我们的预期剂量,温度也没有超出我的番茄水平。

...这是可解析的,但意义不大。

编程使他们肮脏的渔民们远不如我们的猪肉。

对。并不是真正的句子,但是比一些JavaScript错误消息更好。

他的呼吁激起了我女士概述的所有生活中的问题,她的英语水平最高。

影射程序几乎是一流的...

遵循匿名代码。这个比赛有最后期限吗?

[编辑1]

生成以上代码的代码。

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

5
您的代码在哪里?
ace_HongKong独立2014年

参见我的代码编辑。
Brandon R. Gates

6

Perl 5

OK,程序的胆量就是这样:

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

它基本上是一个“ madlib”引擎。要实际生成有趣的句子,您需要填充%pad一些数据。这是一个例子%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',
  ],
);

这是我从中发现的智慧的一些样本%pad。这些句子没有进行长度,标点,语法等方面的编辑,尽管我挑选了一些无趣的句子并重新排列了句子出现的顺序-它们不再按照它们生成的顺序排列,但我正在尝试用它们来讲述一个故事:一个故事,希望您能同时感人和发人深省。

  • 蜘蛛网很短。
  • 蜘蛛网经常使人着迷。
  • 矮小的猴子在闪闪发光,但蜘蛛网贪婪地喝着。
  • 闪闪发光的(但有臭味的)猴子紧随小(闪闪发光的)大猩猩。
  • 珠穆朗玛峰的首脑会议欢迎装饰精美的剑龙。
  • 不仅珠穆朗玛峰的山顶很昂贵,而且电视节目《欢乐合唱团》的演员也跟随闪闪发光的大猩猩。
  • 电视节目《欢乐合唱团》的演员表类似于淡紫色的邮箱。
  • 昂贵的邮箱很高,而昂贵的剑龙则跳了Chuck Norris,而绿色的鞋子跳了牛肉沙拉三明治。
  • 牛肉沙拉三明治爱Chuck Norris。
  • 数以百万计的闪闪发光的鳗鱼是绿色的(但仍然很幽灵)。

现在,如果您可以通过编程方式填充垫
Pureferret,2014年

以编程方式填充pad并不是很大的挑战。只需刮擦警示语或其他内容即可。但是,这不会产生如此有趣的句子。
tobyink 2014年

这不是一个很大的挑战,但我认为这是其中的一个有趣部分。
Pureferret 2014年

5

Word女士

我不确定这是否可以接受,但是由于html是可以接受的,因此我认为这也是可以接受的。

 =rand(1,1)

例句:

在“插入”选项卡上,画廊包括旨在与文档的整体外观相协调的项目。

您可以使用这些图库来插入表格,页眉,页脚,列表,封面和其他文档构造块。

您还可以指定任意数量的句子和段落。


4

使用JSoupsimpleNLG进行的工作

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

}

问题:

  • 句子太简单了
  • 偶尔会出现404(没有良好的处理!)
  • 一次只产生一个句子
  • 使用开关盒!

样本输出:

Popoloca杏花菜豆。
热带的摩ri座束起束缚。
北京是枕头盒的代名词。
楚科奇人深深地影响着人们。


3

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

这将获取30个最流行的google搜索,执行“我觉得很幸运”搜索,然后显示该页面中至少包含3个单词的随机句子。

例子:

“她被认为是本次比赛的最爱。”

凯特提前一年从高中毕业。

“ 2014年4月15日,以促进遵守有关活人传记的政策。”

“我们代表布赖恩,他的家人,要感谢所有人的爱心,祈祷和支持。”

“这篇文章是关于美国篮球运动员的。”

“很抱歉,您的浏览器已禁用JavaScript或没有任何受支持的播放器。”


3

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

输出:

生成一个可以阅读和理解的句子


使用Stack Exchange的共享URI(例如/q/21571代替/questions/21571/generate-an-understandable-sentence)。
Blacklight Shining

2
由于这不是代码高尔夫球,因此为了提高可读性而使用换行符会很不错。
nyuszika7h 2014年

2

Shell脚本

该脚本将始终显示当前在此站点顶部的第一个问题的标题。我的假设是问题标题始终是可读的。而且它会动态变化。因此,每当有新问题出现并执行脚本时,它将给出最新的问题标题。

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

试验1输出

Find words containing every vowel

试用2输出

Hello World 0.0!

编辑

不使用任何文件。没有文件,我可以使用以下脚本。

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

输出量

Generate an understandable sentence

1
也不是直接从文件中读取它们……
rafaelcastrocouto 2014年

我进行了更改,以不使用文件。现在,它只使用了变量。这个怎么样?
Ramesh 2014年

2
删除不赞成票!
rafaelcastrocouto 2014年

2

JavaScript(ES6)

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

在控制台中运行它会产生

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

甚至更短:t='';for(f of [_=>foo,_=>null.a,_=>0..toString(0)])try{f()}catch(e){t+=e.message+'\n'}t
牙刷

2

另一个Python脚本

user3058846答案还不错,但是每次都会显示每个句子。在这里,我提出一个脚本,该脚本从PythonZen中输出随机语句:

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

一行,对于球迷:

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

(B,脏。)

例子:

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


Python中的另一种有趣方式

多亏@TheDoctor注入了想法:-)使导入输出静音,然后在模块中使用伪加密的dict播放。

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

使用通常是不好的做法shell=True。尽管在这种情况下并不是不安全的,但是由于您没有接受用户输入,因此我会选择subprocess.Popen(('python', '-c', 'import this'))
nyuszika7h 2014年

您是否知道是否可以沉默的诗import this,模块this中有一个变量,其中包含所有文本,但已加密。还有一个字典来解密它。
TheDoctor 2014年

1
@TheDoctor看我最新的答案:D
Maxime Lorant

1

Python 3

保证产生语法输出!(通常)

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)

要使其完全符合语法要求,请从中删除下划线wordregex。这将禁止使用多词条目,从而导致诸如“我们为您压缩”之类的不好的句子。

样品运行:

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?

到目前为止最喜欢的输出:

They you her.

查找:http : //en.wiktionary.org/wiki/you#Verb


0

蟒蛇

结果:

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

我从这里使用单词列表查找包含每个元音的单词

可以添加更多规则。例如,如果以“ ness”结尾的单词和该单词也以集合形式存在而没有后缀,则它是一个名词。

源代码:

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

3
我真的很喜欢Python和英语,还是要输出3个名词而不是2个名词和一个动词?
ace_HongKong独立2014年

@ace Oops,我决定在最后一分钟修复代码:-(
yegle 2014年

0

重击

尝试运行一个已存在但尚未安装的程序可以做到这一点(在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'

在不同的发行版中,它给您不同的句子。
TheDoctor 2014年

这就是为什么我在LM13中说
user80551

0

Python 3

马克西姆(马克西姆)的答案激发了“禅宗的Python”的另一种观点

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

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

4
请说明这是哪种语言。
Rodolfo Dias 2014年

1
@RodolfoDias我很确定这是Javascript ...虽然不确定。
TheDoctor 2014年
By using our site, you acknowledge that you have read and understand our Cookie Policy and Privacy Policy.
Licensed under cc by-sa 3.0 with attribution required.