स्वचालित रूप से एंटी-प्रेडिक्टिक रूप से एक एलिटरेटिव एरिया को इकट्ठा करता है

Question

शीर्षक के लिए @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

अंतिम दो उदाहरणों में शब्दों के बीच कोई अतिरिक्त स्थान न दें।

यह कोड-गोल्फ है , इसलिए सबसे छोटा कोड जो बिना मानक खामियों के जीतता है!

अप्रत्याशित घटना में जो इसे मदद करता है, आप ऊपरी मामले में सब कुछ इनपुट कर सकते हैं, लेकिन आपको अभी भी वाक्य के मामले में आउटपुट करने की आवश्यकता है।

Comments

क्या हम यह मानने के लिए सही हैं कि कार्यक्रम वापस आ जाना चाहिए: 1 नाम 1 विशेषण (यदि कोई नाम से मेल खाता है) 1 संज्ञा? या आप प्रत्येक नाम के लिए एक आउटपुट का उत्पादन करने के लिए कह रहे हैं?

— डेविड

हो सकता है कि आप अपने उदाहरण में you जोन ’और should जीप’ जोड़कर इस तथ्य को स्पष्ट करें कि किसी दिए गए पत्र के लिए कोई विशेषण नहीं हो सकता है?

— अरनौलद

आपके उदाहरण इनपुट को देखते हुए 3 में कोई विशेषण 1 का मौका है (क्योंकि सभी विशेषण "सूचियों" 2 लंबे हैं)? … और अगर also जोन ’और 'जीप’ भी होते, तो ना- jना के साथ 9 में मौका 4 बन जाता? आउटपुट के खिलाफ संभाव्यता रखने या सभी आउटपुट को एन्यूमरेट करने के लायक हो सकता है - जैसा कि मैं समझता हूं कि यह "न केवल किसी दिए गए पत्र के लिए सभी आउटपुट ...", बल्कि सभी अलग-अलग आउटपुट में समान संभावना (प्रत्येक सूची के भीतर अलग-अलग मूल्य दिए गए) होने चाहिए।

— जोनाथन एलन

@DavidC क्षमा करें, मुझे लगता है कि अतिरिक्त उदाहरण जोड़ने से यह स्पष्ट नहीं हो गया है; आप प्रत्येक मंगलाचरण के लिए केवल एक पंक्ति का उत्पादन करते हैं।

— नील

@ जोनाथनअलन "जोआन" और "जीप" जोड़ना "नील की संज्ञा" के सापेक्ष अवसरों को प्रभावित नहीं करेगा, "नील" और "संज्ञा" वाले अन्य विकल्पों के साथ तुलना में।

— नील

Answer 1

जेली ,  27 25  24 बाइट्स

-1 एग्री ऑफ द आउटोलफ़र के लिए धन्यवाद (एक अंतरिक्ष चरित्र के बजाय एक शून्य का उपयोग करें)

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

पायथन के रूप में एक तर्क को स्वीकार करने वाला एक पूर्ण कार्यक्रम स्ट्रिंग्स की सूची की प्रारूपित सूची है जो एसटीडीयूएसटी को आउटपुट प्रिंट करता है।

इसे ऑनलाइन आज़माएं!

कैसे?

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

Comments

24 बाइट्स ।

— एरिक आउटगॉल्फ

आह हाँ, अच्छा :)

— जोनाथन एलन

Answer 2

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

Comments

ओह, ¯ªऔर €˜स्मार्ट हैं! मेरे पास 26 बाइट का जवाब था, लेकिन विशेषण नहीं होने पर डबल-स्पेस को ठीक करने में समस्या हो रही थी ..

— केविन क्रूज़सेन

@ केविनक्रूजसेन: हाँ, यह वह हिस्सा था जिसमें मेरे साथ सबसे अधिक मुद्दे थे। मुझे यह महसूस करने में थोड़ा समय लगा कि मैं ¯खाली तारों को भरने के बजाय उपयोग कर सकता हूं जिन्हें मुझे बाद में मैन्युअल रूप से साफ करना था।

— एमिगा

Answer 3

आर , 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$

Comments

क्या किसी दिए गए पहले अक्षर के लिए यह एक दूसरे के लिए एक विशेषण के बराबर खाली मौका है?

— निक केनेडी

@NickKennedy हाँ, चूंकि sampleसमान वितरण से आ रही है। यह देखने का सबसे आसान तरीका इस स्थिति पर है कि नाम और संज्ञा एक ही अक्षर से शुरू होती है (जो ठीक है: यदि वे नहीं करते हैं, तो हम अस्वीकार कर देंगे)। अब जिस घटना को हम स्वीकार करते हैं उस पर शर्त: इसका मतलब है कि हम या तो खाली विशेषण खींचते हैं, या एक ही अक्षर से शुरू होने वाला विशेषण। इनमें से प्रत्येक संभावना में अभी भी समान संभावना है।

— रॉबिन राइडर

धन्यवाद, अच्छी तरह से समझाया।

— निक केनेडी

@NickKennedy धन्यवाद, मैं अनुभवजन्य रूप से समान होने की पुष्टि करने के लिए लिंक के साथ पोस्ट में उस स्पष्टीकरण को जोड़ूंगा।

— रॉबिन राइडर

148 बाइट्स

— ग्यूसेप

Answer 4

जावास्क्रिप्ट (ईएस 6),  139 124 122  120 बाइट्स

@ बाइस के लिए 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$

Comments

+[(o=g([,...a]))&&o+' ']+मुझे लगता है कि 2 बाइट्स बचाता है?

— नील

@ नील आह, हाँ। अच्छा है।

— अरनौलद

Answer 5

पायथन 3 , 161 154 151 147 145 बाइट्स

( धन्यवाद Arbo, EmbodimentOfIgnorance, नील जिन्होंने मेरे गोल्फ में 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)

इसे ऑनलाइन आज़माएं! (500k निष्पादन के साथ)

• तीन सूचियों को इनपुट के रूप में लेता है।

• प्रत्येक नाम के लिए कम से कम एक संज्ञा मानता है।

---

समान स्कोर, अधिक गोल्फ-वाई:

पायथन 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 निष्पादन के साथ)

यह केवल 140 है यदि अनुगामी व्हाट्सएप की अनुमति है (वर्ग चेहरे को हटाकर [:-1])

Comments

अच्छा पहला जवाब! आप पहले लूप में एक बाइट बचा सकते हैं while t>""<t[0]!=w:। तीसरी लाइन में print(s+"'s",t+(t and" ")+o)छोड़ कर आप अंतिम लाइन को भी बदल सकते हैं u=।

— अरबो

मैंने अपना समाधान बदलना शुरू कर दिया क्योंकि पिछली आवश्यकताओं को फिट नहीं किया था

— निकोला सैप

152 बाइट्स (पाद टिप्पणी में URL फिट करने के लिए हटा दिया गया)

— अज्ञानता का अवतार

आप केवल चर का उपयोग कर रहे हैं tताकि आप कोड को इनलाइन करके 4 बाइट्स बचा सकें। मुझे लगता है कि आप oएक समान कोड पैटर्न का उपयोग करने के लिए स्विच कर सकते हैं t, और फिर उस को भी इनलाइन करके एक और 4 बाइट बचा सकते हैं।

— नील

धन्यवाद, आप लोग वास्तव में मदद कर रहे हैं! @ नहीं, मैं रिफ्लेक्टर करने में सक्षम नहीं oहूं: मैं इस तक पहुंचता हूं: 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))( 137 ) लेकिन सशर्त व्हाट्सएप को जोड़कर, एक वैकल्पिक arg के माध्यम से y, मेरी लागत 11 बाइट्स है

— निकोला सैप

Answer 6

जेली , 28 बाइट्स

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

इसे ऑनलाइन आज़माएं!

इससे पहले कि मैंने @ जोनाथनअल्लन के छोटे से उत्तर को देखा, यह लिखा, लेकिन यह एक अलग दृष्टिकोण का उपयोग करने के बाद से इसे पोस्ट करने के लायक समझा। उस उत्तर पर @ EriktheOutgolfer के सुझाव द्वारा 3 बाइट्स सहेजे गए।

एक पूर्ण कार्यक्रम स्ट्रिंग्स और अव्यवस्थित रूप से चयनित अनुप्रास को छापने की सूची की एक सूची ले रहा है। प्रति नाम कम से कम एक संज्ञा मानता है।

Answer 7

C # (विजुअल 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();

इसे ऑनलाइन आज़माएं!

Comments

आप मान सकते हैं कि नाम एक अपरकेस अक्षर से शुरू होते हैं, इसलिए आप तुलना के लिए अन्य अक्षरों को ऊपर ले जा सकते हैं, जिससे आपको 10 बाइट्स बचाने चाहिए?

— नील

@ नील यप, ठीक 10 बाइट्स :)

— इग्नोरेंस

Answer 8

लाल , 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
]

Answer 9

स्काला , 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

इसे ऑनलाइन आज़माएं!

Ungolfed:

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
}

Answer 10

रूबी , 94 बाइट्स

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

इसे ऑनलाइन आज़माएं!

Answer 11

आइकन , 167 163 बाइट्स

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उत्तर के समान एल्गोरिथ्म का उपयोग करता है ।