합성어 단어는 각 단어의 일부를 소요하고 하나의 새로운 단어로 만드는 두 단어의 조합이다. 예를 들어 lion + tiger => liger 입니다.

한 쌍의 입력 단어에서 portmanteaus를 생성하는 프로그램을 작성해 봅시다. 컴퓨터는 영어에 능숙하지 않으므로 출력 포트만 티 우스가 눈과 귀에 좋도록 몇 가지 규칙을 설정해야합니다.

^{(여기에 예는 명확성을 위해 접두사와 접미사 사이에 구분 기호가 표시되어 li|ger있습니다. 그러나 프로그램의 실제 출력에는 구분 기호가 없어야합니다 liger.)}

• 각 portmanteau는 첫 번째 단어의 비어 있지 않은 접두사와 두 번째 단어의 비어 있지 않은 접두사로 구성됩니다 : yes to li|ger, no to |iger.
• 접두사가 모음으로 끝나는 경우 접미사는 자음으로 시작해야하며 그 반대의 경우는 yes lio|ger또는 or l|er, no lio|iger또는 or l|ger입니다. 모음 또는 자음 으로 계산할지 여부를 결정할 수 있습니다 y. 그러나 솔루션은 하나의 옵션을 선택해야합니다.
• 결과 단어에는 원래 단어가 모두 포함되어서는 안됩니다. yes to lio|ger, no to lion|iger또는 li|tiger.
  • 이 규칙은 문제의 부분이 두 단어의 일부로 구성되어 있어도 유지됩니다. two+ 를 입력 words하면 출력 tw|ords에 하위 문자열이 포함되어 있기 때문에 여전히 불법 words입니다. (이 쌍의 유일한 유효한 출력은입니다 t|ords.)

당신의 프로그램이나 기능은 두 단어를 가져 와서 그 순서대로 그 단어들로부터 형성 될 수있는 모든 즐거운 portmanteaus의 목록을 출력 / 반환해야합니다 .

세부

• 표준 입력 및 출력 방법이 적용됩니다. 표준 허점 은 금지되어 있습니다.
• 단어는 소문자로 구성되거나 원하는 경우 대문자만으로 구성됩니다.
• 두 개의 입력 단어를 목록, 튜플, 두 개의 개별 입력, 문자가 아닌 구분 기호가있는 단일 문자열 등으로 사용할 수 있습니다.
• 출력 형식도 비슷합니다. 문자열을 반환하거나 출력하는 경우 한 포트만 단어가 끝나고 다음 단어가 시작되는 곳이 명확 해 지도록 구분해야합니다.
• portmanteau 단어 안에 분리 문자가 없어야합니다.
• 출력 목록에 중복 결과가 포함되어 있으면 괜찮습니다. 중복을 제거해도됩니다.

테스트 사례

> 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

참조 솔루션

Pip 의 참조 솔루션은 다음과 같습니다 ( y자음으로 처리 ).

이것은 코드 골프입니다 : 각 언어에서 가장 짧은 답변이 이깁니다!

05AB1E , 28 바이트

y 모음 (자음과 동일한 바이트 수)입니다.

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

온라인으로 사용해보십시오! 또는 약간 수정 된 테스트 스위트

레티 나 , 72 바이트

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

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

Pyth , 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)

자바 (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 덕분 입니다.

언 골프 드 :

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
}

Japt , 32 바이트

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

apt 인터프리터

Shaggy의 Japt 구문에 대한 명확한 이해 덕분에 10 바이트가 절약되었습니다.

새로운 언어 기능으로 8 바이트 절약

ETH 프로덕션의 제안으로 2 바이트 절약

최신 버전의 Japt는 Cartesian Product 함수를 도입하여 상당히 많은 바이트를 절약하고 입력 순서를 복원 할 수있었습니다 (따라서 "lion" "tiger"출력 "liger"등). "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

파이썬 3 , 156150 바이트

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

Jonathan Frech 덕분에 -6 바이트

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

자바 스크립트 (ES6), 124 바이트

카레 구문에서 두 단어를 가져 와서 (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]/)

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

젤리 , 27 바이트

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

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

Yy 는 자음입니다. 두 경우 모두 지원됩니다. 중복을 반환합니다.

출력은 TIO를 통해 미리 결정되었습니다. +/€실제 출력을 보려면 바닥 글에서 제거하십시오 .

C ++ 11, 217202 바이트

[](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자음으로 취급 합니다. 여기에서 온라인으로 사용해보십시오 .

언 골프 드 :

// 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
}

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

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

Jonathan Frech 에서 3 바이트 . 그리고 10 바이트는 The Matt에 thx .

내 세상에서는 y모음이 아닙니다. (노울입니다!)

루비 , 113112109104 바이트

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}

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

이맥스 리스프 , 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는 자음으로 간주됩니다.

언 골프

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