제목에 대한 @ComradeSparklePony에게 감사합니다.

이 도전은 매우 간단해야합니다. 세 가지 목록이 제공됩니다.

첫 번째는 제목의 경우 이름 목록입니다.

두 번째는 소문자의 형용사 목록입니다.

세 번째는 소문자로 된 명사 목록입니다.

이름, 선택적 형용사, 명사 및 출력을 임의로 선택하십시오 <Name>'s <adjective> <noun>. 그러나 각 단어는 같은 문자로 시작해야합니다. 모든 단어가 문자로 시작한다고 가정 할 수 있습니다. 당신은 또한 가정 할 수 있습니다 (그렇다면 대답에주의하십시오).

• 모든 단어는 알파벳 문자로만 구성됩니다
• 각 이름에 대해 하나 이상의 명사가 있음
• 명사마다 하나 이상의 이름이 있음

그러나 형용사가 선택 사항이므로 출력이 여전히 유효하기 때문에 특정 쌍의 이름과 명사에 형용사가 존재한다고 가정 할 수 없습니다.

사용 가능한 모든 문자가 0이 아닌 확률을 가져야하지만 공유 문자를 균일하게 선택할 필요는 없습니다. 그러나 주어진 문자에 대한 모든 출력이 언어의 난수 생성기의 한계 내에서 가능한 한 똑같이 발생할 가능성이 있는지 확인해야합니다. 형용사의 경우, 이것은이 편지에 대한 다른 형용사와 같은 기회를 갖는 "이 편지에 대한 형용사 없음"을 의미하는 추가 항목을 갖는 것과 동등합니다.

입력 목록 예 :

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

마지막 두 예제에서 단어 사이에 추가 공백이 없습니다.

이것은 code-golf 이므로 표준 허점을 깨지 않는 가장 짧은 코드가 승리합니다!

도움이되지 않는 경우 대문자로 모든 것을 입력 할 수 있지만 여전히 문장으로 출력해야합니다.

젤리 ,  27 25  24 바이트

Outgolfer Erik 덕분에 -1 (공백 문자 대신 0 사용)

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

출력을 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 주세페에 (사용 덕분에 바이트 *를 들어 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$

자바 스크립트 (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)

온라인으로 사용해보십시오!

또는 5 백만 추첨에 대한 분포 확인

어떻게?

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

파이썬 3 , 161154151147145 바이트

( 내 첫 골프 2, 3, 4 바이트 기여 덕분에 ARBÖ, EmbodimentOfIgnorance, 닐! )

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)

온라인으로 사용해보십시오! (500k 실행)

• 세 개의 목록을 입력으로 사용합니다.

• 각 이름에 대해 하나 이상의 명사를 가정합니다.

같은 점수, 더 많은 골프 -y :

파이썬 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])

온라인으로 사용해보십시오! (500k 실행)

후행 공백이 허용되면 (정사각형을 제거하여 [:-1]) 140입니다.

젤리 , 28 바이트

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

온라인으로 사용해보십시오!

@JonathanAllan의 짧은 대답을보기 전에 이것을 썼지 만 다른 접근법을 사용하기 때문에 게시 할 가치가 있다고 생각했습니다. 해당 답변에 대한 @EriktheOutgolfer의 제안으로 3 바이트를 절약했습니다.

문자열 목록의 목록을 가져와 임의로 선택된 alliteration을 암시 적으로 인쇄하는 전체 프로그램. 이름 당 하나 이상의 명사를 가정합니다.

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대답 과 동일한 알고리즘을 사용합니다 .