感谢@ComradeSparklePony的标题。

这个挑战应该非常简单。给出三个列表。

第一个是名字的列表，在标题的情况下。

第二个是小写的形容词列表。

第三个是小写的名词列表。

请随机选择一个名称，可选的形容词和名词，然后输出<Name>'s <adjective> <noun>。但是，每个单词必须以相同的字母开头。您可以假设所有单词都以字母开头。您还可以假设（但是请注意在答案中）：

• 所有单词都完全由字母字符组成
• 每个名字至少有一个名词
• 每个名词至少有一个名字

但是，您不能假定名称和名词的特定对存在形容词，因为形容词是可选的，因此输出仍然有效。

您不必统一选择共享字母，尽管所有可用字母都必须具有非零的出现机会。但是，您必须确保给定字母的所有输出在您语言的随机数生成器的限制范围内，具有尽可能接近发生的机会。在形容词的情况下，这等同于有一个额外的条目，意思是“此字母没有形容词”，与该字母的所有其他形容词有相同的机会。

输入列表示例：

Joan Neil Nicola Oswald Sherman Stephanie
new novel old original second silent
jeep noun novel output second sheep snake

这些输入的示例输出（每行是一个单独的示例）：

Stephanie's second second
Sherman's silent snake
Oswald's original output
Nicola's novel novel
Neil's noun
Joan's jeep

请注意，在最后两个示例中，单词之间没有多余的空格。

这是代码高尔夫球，因此最短的代码不会打破任何标准漏洞，这是有道理的！

万一它有帮助，您可以以大写形式输入所有内容，但仍然需要以句子形式输出。

果冻， 27 25  24 字节

-1感谢Outgolfer的Erik（使用零代替空格字符）

Ż€2¦Œpḟ€0ZḢŒuEƲƇXż“'s“”K

一个完整的程序，该程序接受Python格式的字符串列表的形式的参数，该参数将输出打印到STDOUTt。

在线尝试！

怎么样？

Ż€2¦Œpḟ€0ZḢŒuEƲƇXż“'s“”K - Main Link: list of lists of lists of characters
 € ¦                     - sparse application...
  2                      - ...to indices: [2]
Ż                        - ...action: prepend a zero (place holder for no adjective)
    Œp                   - Cartesian product (all choices, including invalid ones)
       €                 - for each:
      ḟ 0                -   filter out any zeros
               Ƈ         - filter keep those for which:
              Ʋ          -   last four links as a monad:
         Z               -     transpose
          Ḣ              -     head
           Œu            -     upper-case
             E           -     all equal?
                X        - random (uniform) choice  e.g. [['B','o','b'],['b','l','u','e'],['b','a','g']]
                 ż       - zip with:
                  “'s“”  -   list [["'", 's'], []]       [[['B','o','b'],["'", 's']],[['b','l','u','e'],[]],['b','a','g']]
                       K - join with spaces              [['B','o','b'],["'", 's'],' ',['b','l','u','e'],[],' ','b','a','g']
                         - implicit (smashing) print     Bob's blue bag

05AB1E， 24 23  21字节

假设挑战允许，每个名称都有一个名词。

„'s«I¯ªâI‘ʒl€нË}Ωðý

在线尝试！

说明

„'s«                    # append "'s" to all names in the name-list
    I¯ª                 # append an empty list to the adjective-list
       â                # cartesian product between the lists
        Iâ              # cartesian product with the noun-list
          €˜            # deep flatten each sublist
            ʒ    }      # filter, keep only lists that when
             l          # converted to lowercase
              €н        # with only heads kept
                Ë       # have all elements equal
                  Ω     # pick a valid list uniformly at random
                   ðý   # and join by spaces

[R，155个 148字节的

-7个字节，感谢Giuseppe（*用于sample）

function(x,y,z){`*`=sample
while(T)T=length(unique(c(tolower(substr(c(a<-x*1,b<-c(y,"")*1,c<-z*1),1,1)),"")))-2
paste0(a,"'s ",b,if(nchar(b))" ",c)}

在线尝试！

使用拒绝抽样：随机抽取名称，形容词（可能为空字符串）和名词，直到第一个字母匹配为止。通过计算由第一个字母加上空字符串组成的向量中的唯一元素的数量是否为长度2来检查此条件，这允许空形容词。

然后输出结果，如果形容词不是空的，则用额外的空格打印。

以相同字母开头的不同可能性具有相同的出现概率，因为 sample来自均匀分布。最简单的方法是以名称和名词以相同字母开头的情况为条件（这很好：如果不这样，我们会拒绝）。现在以我们接受的事件为条件：这意味着我们将绘制空的形容词或以相同字母开头的形容词。这些可能性中的每一个仍然具有相等的概率。

$10^5$

JavaScript（ES6）， 139 124 122  120字节

@Neil节省2个字节

将输入作为(names,adjectives)(nouns)。

(N,a)=>F=n=>/^(.)\S+( \1\S+)+$/i.test(s=(g=a=>a[Math.random()*a.length|0])(N)+"'s "+[(o=g([,...a]))&&o+' ']+g(n))?s:F(n)

在线尝试！

或检查 500万次抽奖的分布

怎么样？

$g$

g = a => a[Math.random() * a.length | 0]

$g$$s$

s = g(N) + "'s " +
    [(o = g([, ...a])) && o + ' '] +
    g(n)

然后，我们检查所有初始字母是否与以下正则表达式相同：

/^(.)\S+( \1\S+)+$/i

$s$

Python 3中， 161个154 151 147 145字节

（感谢ArBo，MemberionOfIgnorance和Neil为我的第一次高尔夫贡献了2、3和4个字节！）

from random import*
c=choice
def f(N,a,n):
 s=c(N);w=s[0].lower();o=N
 while o[0]!=w:o=c(n)
 print(s+"'s",c([x+" "for x in a if x[0]==w]+[""])+o)

在线尝试！（执行50万次）

• 将三个列表作为输入。

• 每个名称至少假设一个名词。

得分相同，高尔夫得分更高：

Python 3，145个字节

from random import*
c=choice
def f(N,a,n):
 s=c(N);y=lambda p,e=[]:c([x+" "for x in p if x[0]==s[0].lower()]+e);print(s+"'s",y(a,[""])+y(n)[:-1])

在线尝试！（执行50万次）

如果允许尾随空格，则仅为140（通过删除方形[:-1]）

果冻，28个字节

1ịZḢXɓŒuḢ=ɗƇ€Ż€2¦X€ḟ0ż“'s“”K

在线尝试！

在我看到@JonathanAllan的简短回答之前就写了这个，但是认为它值得发表，因为它使用了不同的方法。@EriktheOutgolfer在该答案上的建议节省了3个字节。

一个完整的程序，它使用字符串列表的列表并隐式地打印随机选择的项目。每个名称至少假设一个名词。

C＃（Visual C＃交互式编译器），176个字节

(a,b,c)=>(a=a[z.Next(a.Count)])+"'s "+b.Where(x=>(x[0]&95)==a[0]).Append("").OrderBy(x=>z.Next()).Last()+" "+c.OrderBy(x=>z.Next()).Last(x=>(x[0]&95)==a[0]);var z=new Random();

在线尝试！

红色，179字节

func[a b c][random a random c
foreach k c[if k/1 = h: a/1/1 + 32[g: rejoin[sp k]]]collect/into[foreach
d b[if d/1 = h[keep rejoin[sp d]]]]e: copy[""]random e rejoin[a/1"'s"e/1 g]]

在线尝试！

说明：

Red[]
f: func[a b c][                     ; a function with 3 arguments
    random a                        ; shuffle the list of names in place
    random c                        ; shuffle the list of nouns in place
    foreach k c [                   ; for each item in the shuffled list of nouns
        if k/1 = h: a/1/1 + 32 [    ; check if it begins with the same lowercase letter
                                    ; as the first name in the shuffled list of names
            g: rejoin [" " k]       ; if yes, then insert a " " in front of it save it as g
        ]                           ; thus I always get the last match
    ]
    collect/into [                  ; collect in a new list e
        foreach d b [               ; all items form the adjectives list
            if d/1 = h [            ; that start with the same lowercase letter as the 1st noun
                keep rejoin [" " d] ; insert a " " in form of the adjective
            ]
        ]
    ] e: copy[""]                   ; the list initially has a single item - the empty string
   random e                         ; shuffle the extracted adjectives list
   rejoin [a/1 "'s" e/1 g]          ; return the formatted string
]

斯卡拉，234 226 234 206字节

-28由于我认为它必须接受StdIn，所以现在是一个函数

def f(a:List[String],b:List[String],c:List[String])=scala.util.Random.shuffle(for(d<-a;e<-("" +: b);g<-c;if(d.head.toLower==g.head&&(e.isEmpty||e.head==g.head))) yield s"$d's $e $g".replace("  ", " ")).head

在线尝试！

取消高尔夫：

def f(names: List[String], adjectives: List[String], nouns: List[String]) = {
  val allPossible = for {
    name <- names
    adjective <- ("" +: adjectives) // Add the choice of no adjective
    noun <- nouns
    if (name.head.toLower == noun.head && (adjective.isEmpty || adjective.head == noun.head)) // Filter out so only matching entries remain
  } yield
    s"$name's $adjective $noun"
      .replace("  ", " ") // Get rid of artifact created by the empty adjective selection

  scala.util.Random.shuffle(allPossible.toList).head // Get a random element
}

红宝石，94字节

->a,b,c{"#{n=a.sample}'s #{s=[p,*b.grep(r=/^#{n[0]}/i)].sample;s+" "if s}#{c.grep(r).sample}"}

在线尝试！

图标，167163字节

procedure f(a,b,c)
!a:=:?a&\x;!c:=:?c&\x;d:=[""]
e:=!b&e[1]==(t:=char(32+ord(a[1,1])))&put(d," "||e)&\x
!d:=:?d&\x;return(!a||"'s"||!d||" "||(k:=!c&t==k[1]&k))
end

在线尝试！

使用与我的Red答案相同的算法。