Pleasanortmanteaus

Question

एक portmanteau शब्द दो शब्दों का एक संयोजन है जो प्रत्येक शब्द का हिस्सा होता है और उन्हें एक नए शब्द में बनाता है। उदाहरण के लिए, शेर + बाघ => लाइगर ।

चलो इनपुट शब्दों की एक जोड़ी से पोर्टमिंटियस उत्पन्न करने के लिए एक कार्यक्रम लिखते हैं। कंप्यूटर अंग्रेजी में सर्वश्रेष्ठ नहीं हैं, इसलिए हमें यह सुनिश्चित करने के लिए कुछ नियमों को स्थापित करने की आवश्यकता होगी कि आउटपुट पोर्टमंटियस आंख और कान के लिए सुखद हैं।

^{(यहाँ उदाहरण उपसर्ग और स्पष्टता के लिए प्रत्यय के बीच एक विभाजक के साथ दिखाया गया है: li|ger। हालांकि, कार्यक्रम के वास्तविक आउटपुट एक विभाजक नहीं करना चाहिए था: liger।)}

• प्रत्येक पोर्टमंट्यू में पहले शब्द के एक गैर-रिक्त उपसर्ग शामिल होगा जो दूसरे शब्द के एक गैर-रिक्त प्रत्यय के लिए संक्षिप्त किया गया है: हाँ li|ger, को नहीं |iger।
• हाँ: एक स्वर के साथ उपसर्ग समाप्त हो जाती है, प्रत्यय एक व्यंजन, और इसके विपरीत के साथ शुरू करते हैं चाहिए lio|gerया l|erनहीं करने के लिए, lio|igerया l|ger। आप यह तय कर सकते हैं कि yस्वर या व्यंजन के रूप में गिना जाए । आपका समाधान एक विकल्प चुनना होगा और इसके साथ रहना होगा।
• परिणामी शब्द में या तो मूल शब्द नहीं होने चाहिए: हाँ lio|ger, नहीं lion|igerया नहीं li|tiger।
  • यह नियम तब भी रखता है जब प्रश्न का हिस्सा दोनों शब्दों के हिस्सों से बनता है: two+ के इनपुट के साथ words, आउटपुट tw|ordsअभी भी अवैध है क्योंकि इसमें सबस्ट्रिंग शामिल है words। (इस जोड़ी के लिए एकमात्र वैध आउटपुट होगा t|ords।)

आपके प्रोग्राम या फ़ंक्शन को दो शब्द लेने चाहिए और आउटपुट / सभी सुखद पोर्टेमेंटस की एक सूची वापस करनी चाहिए जो उस क्रम में उन शब्दों से बन सकते हैं।

विवरण

• मानक इनपुट और आउटपुट तरीके लागू होते हैं। मानक खामियों को मना किया जाता है।
• शब्दों में केवल निचले अक्षर शामिल होंगे (या, यदि आप चाहें, तो केवल अपरकेस अक्षर)।
• आप एक सूची के रूप में दो इनपुट शब्दों को ले सकते हैं, ट्यूपल, दो अलग-अलग इनपुट, एक गैर-पत्र सीमांकक के साथ एक स्ट्रिंग आदि।
• आउटपुट स्वरूप समान रूप से लचीला है; यदि आप वापस लौटते हैं या एक स्ट्रिंग का उत्पादन करते हैं, तो इसे ऐसे सीमांकित किया जाना चाहिए कि यह स्पष्ट हो जहां एक पोर्ट्मेंटो शब्द समाप्त होता है और अगला शुरू होता है।
• किसी पोर्ट्मेंटो शब्द के अंदर कोई सीमांकक नहीं होना चाहिए।
• यदि आपकी आउटपुट सूची में डुप्लिकेट परिणाम शामिल हैं तो यह ठीक है; डुप्लिकेट निकालना भी ठीक है।

परीक्षण के मामलों

> lion, tiger
< liger, ler, liger, lir, lioger, lior

> tiger, lion
< tion, ton, tin, tigion, tigon, tigen

> spoon, fork
< sork, spork, spork, spok, spoork, spook

> smoke, fog
< sog, smog, smog, smokog

> gallop, triumph
< giumph, gumph, gariumph, gamph, gaph, gah, galiumph, galumph, galliumph, gallumph, galloriumph, gallomph, galloh

> breakfast, lunch
< bunch, brunch, brench, brech, breh, breanch, breach, breah, breakunch, breakfunch, breakfanch, breakfach, breakfah, breakfasunch

> two, words
< tords

> harry, ginny (if y is treated as a consonant)
< hinny, hanny, hany, hay, harinny, harrinny

> harry, ginny (if y is treated as a vowel)
> hinny, hy, hanny, hany, harinny, hary, harrinny

संदर्भ समाधान

पिप में एक संदर्भ समाधान है ( yएक व्यंजन के रूप में व्यवहार करता है )।

---

यह कोड-गोल्फ है : प्रत्येक भाषा में सबसे कम उत्तर जीतता है!

Comments

संबंधित । अधिक दूर से संबंधित ।

— DLosc

क्या सीमांकक स्थिर होना चाहिए या मैं शब्दों के बीच रिक्त स्थान का एक गुच्छा रख सकता हूं?

— आसून तुहिद

@AsoneTuhid ज़रूर, व्हॉट्सएप की परिवर्तनीय मात्रा एक स्वीकार्य सीमांकक होगी। एकमात्र आवश्यकता यह है कि "यह स्पष्ट है कि एक पोर्टमैंटेउ शब्द कहां समाप्त होता है और अगला एक शुरू होता है।"

— DLosc

Answer 1

05AB1E , 28 बाइट्स

y एक स्वर है (हालांकि व्यंजन के रूप में एक ही बाइट गिनती)।

нη¨sθ.s¨âʒ`нsθ‚žOsåË_}Jʒs¢Z_

इसे ऑनलाइन आज़माएं! या थोड़ा संशोधित टेस्ट सूट के रूप में

Comments

अच्छा जवाब! मजेदार है कि अंतिम फ़िल्टर के लिए काफी कुछ विकल्प हैं, लेकिन दुर्भाग्य से सभी एक ही बाइट-काउंट .. ʒs¢Z_; ʒsåO_; ʒsм__; आदि

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

Answer 2

रेटिना , 72 बाइट्स

L$w`(?<=[aeiou]()|.())((.+),(.+))\B(?!\4)(?<!\5\3)(?([aeiou])\2|\1)
$`$'

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

Comments

बाह, मुझे उतना ही मिल गया था, Lw$`(?<=[aeiou])(.+),(.+)(?<!^\2\1,\2)(?!\1)(?=[^aeiou])|(?<=[^aeiou])(.+),(.+)(?<!^\4\3,\4)(?!\3)(?=[aeiou])लेकिन मैं इसे सिरदर्द के कारण गोल्फिंग पर केंद्रित नहीं कर सका।

— नील

मेरा पहला प्रयास काफी हद तक समान था, हालाँकि मैंने किसी चीज़ के साथ अंत में स्वर / व्यंजन चीज़ की जाँच करके केंद्र के भाग को दोहराने से परहेज किया (?=.(?<=[aeiou]\1[^aeiou]|[^aeiou]\1[aeiou]))और फिर उसे अब वहाँ पहुँचाने के लिए कम से कम छह पुनरावृत्तियों की आवश्यकता थी।

— मार्टिन एंडर

( ^मेरी पिछली टिप्पणी में s गलत हैं) दरअसल, मैंने कभी उस ()|.()तरकीब के बारे में नहीं सोचा होगा, मैं शायद रुक जाता Lw$`(?<=([aeiou])|.)((.+),(.+))(?<!\4\2)(?!\3)(?=(?(1)[^aeiou]|[aeiou]))।

— नील

Answer 3

पायथ , 38 बाइट्स

f!s}RTQm+hd_edfxFm}ed"aeiou"T*._hQ.__e

इनपुट दो शब्दों की एक सूची है, और y को व्यंजन के रूप में नहीं माना जाता है।

इसे यहाँ ऑनलाइन आज़माएँ , या यहाँ पर सभी परीक्षण मामलों को सत्यापित करें ।

f!s}RTQm+hd_edfxFm}ed"aeiou"T*._hQ.__e   Implicit: Q=eval(input())
                                hQ       First input word
                              ._         All prefixes of the above
                                     e   Second input word (Q inferred)
                                  .__    Reverse, take all prefixes
                             *           Cartesian product of the above
              f                          Filter the above using:
                 m          T              Map d in the current element using:
                   ed                        The last letter of the word part
                  }  "aeiou"                 Is it contained in the vowel list?
               xF                          Take the XOR of the list
                                         (This ensures that the word parts meet at one consonant)
       m                                 Map d in the filtered set using:
        +hd_ed                             Add the first part to the reversed second part
f                                        Filter the above using:
  s}RTQ                                    Does the portmanteau contain either of the input words?
 !                                         Logical NOT (remove from list if the above is true)

Answer 4

जावा 8, 228 225 215 बाइट्स

v->w->{String r="",t,p=" aeiou";for(int i=w.length(),j;--i>0;)for(j=1;j<v.length();)r+=(t=v.substring(0,j)+w.substring(i)).matches(v+".*|.*"+w)|p.indexOf(t.charAt(j-1))*p.indexOf(t.charAt(j++))>0?"":t+" ";return r;}

सिंटैक्स में दो स्ट्रिंग्स लेता है और एक स्ट्रिंग लौटाता है। yव्यंजन के रूप में व्यवहार करता है। इसे यहाँ ऑनलाइन आज़माएँ ।

2 बाइट गोल्फिंग के लिए DLosc को धन्यवाद ।

Ungolfed:

v -> w -> { // lambda taking two String parameters in currying syntax
    String r = "", // result
    t, // temporary variable used for storing
       // the portmanteau candidate currently being evaluated
    p = " aeiou"; // vowels for the purposes of this function;
                  // the leading space is so that they all have a positive index
    for(int i = w.length(), j; --i > 0; ) // loop over all proper suffixes
                                          // of the second word
        for(j = 1; j < v.length(); )      // loop over all proper prefixes
                                          // of the first word
            r += // construct the portmanteau candidate
                 (t = v.substring(0, j) + w.substring(i))
                 // if it contains one of the input words ...
                 .matches(v + ".*|.*" + w)
                 // ... or the boundary is consonant-consonant 
                 // or vowel-vowel (here we make use of the facts
                 // that all the vowels have a positive index, and
                 // indexOf() returns -1 in case of no match) ...
                 | p.indexOf(t.charAt(j-1)) * p.indexOf(t.charAt(j++)) > 0
                 ? "" // ... reject it ...
                 : t + " "; // ... else add it to the result
    return r; // return the result
}

Answer 5

जाप , 32 बाइट्स

å+ ïVw å+)f_xè"%v$" uÃmrÈ+YwÃkøN

जाप दुभाषिया

जाप्ते के वाक्य-विन्यास की स्पष्ट समझ के लिए शुक्रिया 10 बाइट्स सहेजे गए।

एक नई भाषा सुविधा के कारण 8 बाइट्स सहेजे गए

ETHproductions के कुछ सुझावों के लिए 2 बाइट का धन्यवाद बचा

जैप के नवीनतम संस्करण ने कार्टेशियन उत्पाद फ़ंक्शन को पेश किया, जिसने काफी कुछ बाइट्स बचाए और मुझे इनपुट के क्रम को बहाल करने की अनुमति दी (इसलिए "शेर" "बाघ" "लिगर" और ऐसे)। "y" अभी भी एक व्यंजन के रूप में माना जाता है।

स्पष्टीकरण:

   ï     )       Cartesian product of...
å+                prefixes of first input
    Vw å+         and suffixes of second input.

f_         Ã     Remove the ones where...
  xè"%v$"         the number of vowels at the joining point
          u       is not 1.

m     Ã          Replace each pair with...
 rÈ+Yw            the prefix and suffix joined together
       køN       then remove the ones that contain either input

Comments

Japt (फिर से!) में आपका स्वागत है। मैं निश्चित रूप से यहां अधिक गोल्फिंग के लिए कुछ क्षमता देख सकता हूं; जब मैं कंप्यूटर पर वापस आऊंगा, तो मुझे इस पर उचित नज़र होगी।

— झबरा

मेरे फोन से आपके लिए कुछ त्वरित बचत ।

— झबरा

Answer 6

पायथन 3 , 156 150 बाइट्स

मैंने yएक व्यंजन के रूप में माना है ।

lambda a,b:{a[:i]+b[j:]for i in range(1,len(a))for j in range(1,len(b))if((a[i-1]in'aeiou')^(b[j]in'aeiou'))*0**(a in a[:i]+b[j:]or b in a[:i]+b[j:])}

-6 बाइट्स जोनाथन फ्रेच को धन्यवाद

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

Comments

संभावित 150 बाइट्स ।

— जोनाथन फ्रीच

@JonathanFrech इसे खोलने के लिए धन्यवाद

— PieCot

आप lambda x=0इसे सहेजने के लिए डिफ़ॉल्ट तर्कों का उपयोग कर सकते हैं ... 0 वर्ण, नाराज होकर। lambda a,b,v='aeiou',r=range:{a[:i]+b[j:]for i in r(1,len(a))for j in r(1,len(b))if((a[i-1]in v)^(b[j]in v))*0**(a in a[:i]+b[j:]or b in a[:i]+b[j:])}(अभी भी १५०)

— द मैट

Answer 7

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

सिंटैक्स में 2 शब्दों को ले जाता है (a)(b)और परिणामों को प्रिंट करता है alert()। Y मान लेता है कि एक व्यंजन है।

a=>b=>[...a].map(c=>[...b].map((C,j)=>!(w=s+b.slice(j)).match(a+'|'+b)&v.test(c)-v.test(C)&&alert(w),s+=c),s='',v=/[aeiou]/)

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

Answer 8

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

¹Ƥp¹ÐƤ}Ø.ị"e€Øc⁻/ƲƇẎ€wÐḟƒ@,

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

Yy एक व्यंजन है। दोनों मामलों का समर्थन किया। रिटर्न डुप्लिकेट करता है।

टीआईओ में आउटपुट को पूर्व निर्धारित किया गया है। +/€वास्तविक आउटपुट देखने के लिए पाद से निकालें ।

Answer 9

सी ++ 11, 217 202 बाइट्स

[](auto v,auto w){auto r=v,t=v,p=v;r="",p="aeiou";for(int i=w.size(),j;--i;)for(j=v.size();j;)(t=v.substr(0,j)+w.substr(i)).find(v)+1|t.find(w)+1|p.find(t[j-1])<5==p.find(t[j--])<5?v:r+=t+" ";return r;}

का भारी उपयोग करता है std::string#find। yव्यंजन के रूप में व्यवहार करता है। इसे यहाँ ऑनलाइन आज़माएँ ।

Ungolfed:

// lambda; relies on auto to keep declarations short
[] (auto v, auto w) {
    // let's declare some strings. To keep it terse, we're using auto and the type of the arguments.
    auto r = v, // result string
    t = v,      // temporary string for storing the portmanteau candidate
    p = v;      // vowels string
    // now assign them their values
    r = "",    // result starts empty
    p = "aeiou"; // vowels don't include 'y'
    for(int i = w.size(), j; --i; ) // suffixes of the second word
        for(j = v.size(); j; ) // prefixes of the first word
            // create the portmanteau candidate
            (t = v.substr(0, j) + w.substr(i))
            // if it includes one of the input words ...
            .find(v) + 1 | t.find(w) + 1
            // ... or the boundary is consonant-consonant or vowel-vowel ...
            | p.find(t[j - 1]) < 5 == p.find(t[j--]) < 5
            ? v // ... discard it ...
            : r += t + " "; // ... else add it to the result.
    return r; // return the result
}

Answer 10

पायथन 2 , 179 176 166 162 बाइट्स

lambda s,t:[w for w in g(s,t)if(s in w)<1>(t in w)]
g=lambda s,t:s[:-1]and[s[:-1]+t[j:]for j in range(1,len(t))if(s[-2]in'aeiou')^(t[j]in'aeiou')]+g(s[:-1],t)or[]

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

जोनाथन फ्रेच से 3 बाइट्स । और 10 बाइट्स द मैट पर ।

मेरी दुनिया में, yएक स्वर नहीं है। (यह एक yowl है!)

Comments

वहाँ में आवारा रिक्त स्थान हैं t) ifऔर t) or []।

— जोनाथन फ्रीच जूल

@ जॉननाथ फ्रीच: धन्यवाद! वहाँ थोड़ा आलसी हो गया ...

— चास ब्राउन

मैं देख रहा हूँ ... मुझे लगता है कि तुम भी थोड़ा आलसी हो गया था, जबकि मेरा नाम टाइप कर रहा था: P

— जोनाथन फ्रैच

* जोनाथन: डी'ओह! खैर, कम से कम मैं लगातार था! :)

— चास ब्राउन

@ मैट: धन्यवाद! असल में, मैंने एक अतिरिक्त 2 बाइट्स को निचोड़ कर देखा (s in w)<1>(t in w)।

— चास ब्राउन

Answer 11

रूबी , 113 112 109 104 बाइट्स

y एक व्यंजन है

यह प्रश्न में उदाहरण के समान डुप्लिकेट को आउटपुट करता है, मुझे उसी लूप का उपयोग करना चाहिए

->a,b,i=j=1{r=a[0,i]+b[j..-1];g=:aeiou;!g[a[i-1]]^g[b[j]]|r[a]|r[b]||z=[*z,r];b[j+=1]||a[i+=j=1]?redo:z}

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

Answer 12

एमएसीएस लिस्प , 306 + 13 = 319 बाइट्स

+13 के लिए (require'seq)

(require'seq)(lambda(a b)(dotimes(i(1-(length b)))(dotimes(j(1-(length a)))(progn(setq w(substring a 0(1+ j))x(substring b(1+ i))c(concat w x))(defun V(c)(seq-contains"aeiou"(elt c 0)'char-equal))(if(not(or(string-prefix-p a c)(string-suffix-p b c)))(if(V(substring w -1))(if(not(V x))(print c))(if(V x)(print c))))))))

यह ऑनलाइन की कोशिश करो!

एक अनाम लंबो फ़ंक्शन को परिभाषित करता है। उद्धरणों से घिरे हर एक के साथ न्यूलाइन-सेपरेट पोर्टेमैटिस के अनुक्रम को आउटपुट करता है। गोल्फ युक्तियाँ स्वागत है। पत्र yको व्यंजन माना जाता है।

Ungolfed

(require 'seq)                                                                                                                                                           
(defun Portmanteus(word1 word2)
  "Find all valid portmanteus of the two given words"
  (dotimes (i (1- (length word2)))
    (dotimes (j (1- (length word1)))
      (progn
        (setq w (substring word1 0 (1+ j)) w2 (substring word2 (1+ i)) comb (concat w w2))
        (defun isVowel (c) (seq-contains "aeiou" (elt c 0) 'char-equal))
        (if (not (or (string-prefix-p word1 comb) (string-suffix-p word2 comb)))
          (if (isVowel (substring w -1))
            (if (not (isVowel w2))
              (princ (format "%s\n" comb))
            )
            (if (isVowel w2)
              (princ (format "%s\n" comb))
            )
          )
        )
      )
    )
  )
)