Cảm ơn @ComradeSparklePony cho tiêu đề.

Thử thách này nên rất đơn giản. Bạn được đưa ra ba danh sách.

Đầu tiên là một danh sách các tên đầu tiên, trong trường hợp tiêu đề.

Thứ hai là một danh sách các tính từ, trong trường hợp thấp hơn.

Thứ ba là một danh sách các danh từ, trong trường hợp thấp hơn.

Vui lòng chọn ngẫu nhiên một tên, tính từ tùy chọn và danh từ và đầu ra <Name>'s <adjective> <noun>. Tuy nhiên, mỗi từ phải bắt đầu bằng cùng một chữ cái. Bạn có thể cho rằng tất cả các từ bắt đầu bằng một chữ cái. Bạn cũng có thể giả sử (nhưng lưu ý trong câu trả lời của bạn nếu bạn làm):

• rằng tất cả các từ chỉ bao gồm các ký tự chữ cái
• rằng có ít nhất một danh từ cho mỗi tên
• rằng có ít nhất một tên cho mỗi danh từ

Tuy nhiên, bạn không thể cho rằng một tính từ tồn tại cho một cặp tên và danh từ cụ thể, vì tính từ này là tùy chọn nên đầu ra vẫn sẽ hợp lệ.

Bạn không phải chọn thư được chia sẻ thống nhất, mặc dù tất cả các chữ cái có sẵn phải có cơ hội xảy ra khác không. Tuy nhiên, bạn phải đảm bảo rằng tất cả các kết quả đầu ra cho một chữ cái đã cho có khả năng xảy ra gần như bằng nhau trong giới hạn của trình tạo số ngẫu nhiên trong ngôn ngữ của bạn. Trong trường hợp tính từ, điều này tương đương với việc có thêm một mục có nghĩa là "không có tính từ cho chữ cái này" có cùng cơ hội với tất cả các tính từ khác cho chữ cái đó.

Danh sách đầu vào ví dụ:

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

Các đầu ra ví dụ cho các đầu vào này (mỗi dòng là một ví dụ riêng):

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

Lưu ý không có khoảng trắng thừa giữa các từ trong hai ví dụ cuối.

Đây là môn đánh gôn , vì vậy đoạn mã ngắn nhất không phá vỡ sơ hở tiêu chuẩn!

Trong trường hợp không chắc là nó có ích, bạn có thể nhập mọi thứ bằng chữ in hoa, nhưng bạn vẫn cần xuất ra trong trường hợp câu.

Thạch ,  27 25  24 byte

-1 nhờ Erik the Outgolfer (sử dụng số 0 thay vì ký tự khoảng trắng)

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

Một chương trình đầy đủ chấp nhận một đối số ở dạng danh sách các chuỗi được định dạng của Python sẽ in kết quả đầu ra thành STDOUTt.

Hãy thử trực tuyến!

Làm sao?

Ż€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 byte

Giả sử có một danh từ cho mỗi tên, như được cho phép bởi thử thách.

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

Hãy thử trực tuyến!

Giải trình

„'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 byte

-7 byte nhờ Giuseppe (sử dụng *cho 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)}

Hãy thử trực tuyến!

Sử dụng lấy mẫu từ chối: vẽ ngẫu nhiên một tên, một tính từ (có thể là chuỗi trống) và một danh từ cho đến khi các chữ cái đầu tiên khớp. Điều kiện này được kiểm tra bằng cách đếm nếu số phần tử duy nhất trong vectơ được hình thành từ các chữ cái đầu tiên, cộng với chuỗi trống, có độ dài 2 - điều này cho phép tính từ trống.

Sau đó in kết quả, với một khoảng trắng thừa nếu tính từ không trống.

Các khả năng khác nhau bắt đầu bằng cùng một chữ cái có xác suất xuất hiện bằng nhau, do samplerút ra từ phân phối thống nhất. Cách dễ nhất để thấy điều này là dựa vào sự kiện rằng tên và danh từ bắt đầu bằng cùng một chữ cái (điều này tốt: nếu họ không, chúng tôi sẽ từ chối). Bây giờ điều kiện về sự kiện mà chúng tôi chấp nhận: điều này có nghĩa là chúng tôi rút ra tính từ trống hoặc tính từ bắt đầu bằng cùng một chữ cái. Mỗi khả năng này vẫn có xác suất như nhau.

$10^5$

JavaScript (ES6),  139 124 122  120 byte

Lưu 2 byte nhờ @Neil

Đưa đầu vào là (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)

Hãy thử trực tuyến!

Hoặc kiểm tra phân phối trên 5 triệu rút thăm

Làm sao?

$g$

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

$g$$s$

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

Sau đó chúng tôi kiểm tra xem tất cả các chữ cái ban đầu có giống với biểu thức chính quy sau không:

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

$s$

Python 3 , 161 154 151 147 145 byte

( Cảm ơn ArBo, EmbodimentOfIgnorance, Neil, người đã đóng góp 2, 3 và 4 byte cho sân golf đầu tiên của tôi! )

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)

Hãy thử trực tuyến! (với 500k thực thi)

• Có ba danh sách làm đầu vào.

• Giả sử ít nhất một danh từ cho mỗi tên.

Cùng một số điểm, nhiều golf-y:

Python 3 , 145 byte

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

Hãy thử trực tuyến! (với 500k thực thi)

Nó chỉ là 140 nếu cho phép các khoảng trắng ở cuối (bằng cách loại bỏ mặt vuông [:-1])

Thạch , 28 byte

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

Hãy thử trực tuyến!

Đã viết điều này trước khi tôi thấy câu trả lời ngắn hơn của @ JonathanAllan, nhưng nghĩ rằng nó đáng để đăng vì nó sử dụng một cách tiếp cận khác. Đã lưu 3 byte bởi đề xuất của @ EriktheOutgolfer về câu trả lời đó.

Một chương trình đầy đủ lấy một danh sách các danh sách các chuỗi và in ngầm định một sự phân bổ được chọn ngẫu nhiên. Giả sử ít nhất một danh từ cho mỗi tên.

C # (Trình biên dịch tương tác Visual C #) , 176 byte

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

Hãy thử trực tuyến!

Màu đỏ , 179 byte

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

Hãy thử trực tuyến!

Giải trình:

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
]

Scala , 234 226 234 206 byte

-28 do thực tế tôi nghĩ rằng nó phải chấp nhận StdIn, bây giờ nó là một chức năng

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

Hãy thử trực tuyến!

Ung dung:

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
}

Ruby , 94 byte

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

Hãy thử trực tuyến!

Biểu tượng , 167 163 byte

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

Hãy thử trực tuyến!

Sử dụng thuật toán tương tự như Redcâu trả lời của tôi .