Simple portmanteau with longest overlap

Question

I've been using a library called Djangular recently, which integrates Django and Angular.

After a while I thought 'Wouldn't it be fun to programmatically generate portmanteau?'

Here are some examples (e.g. testcases):

Django + Angular -> Djangular
Camel + Leopard -> Cameleopard
Spoon + Fork -> Spoork
Ham + Hammer -> Hammer

The general rule is to find the first common letter working backwards on first word, and working forwards on the last word. Not all portmanteau can be found this way though...

I've deliberately picked 'simple' ones to generate (for instance we're ignoring things like Zebra + Donkey = Zedonk, which is too arbitrary to generate programmatically - the correct behaviour).

Ties can be resolved eitherway - suppose you have cart + ante - both carte, (since t is the last common letter in the first word) and cante, (since a is the first common letter of the last word) are value. Unfun loopholes are not allowed (including pulling 'solved' examples off wikipedia)

This is code golf, so shortest answer wins. I'll pick the winner a month from posting. Please post the output for all your code.

Answer 1

Python 3, 128 79 bytes

Let me know if I got anything wrong and critiques are always welcome.

def f(a,b):
    c=len(a)-1-a[::-1].find(b[1])
    if a[-1]==b[0]:return a[:-1]+b
    if a[c]==a[c-1]:c-=1
    return a[:c]+b[1:]

Called with f(word 1,word 2) and returns the portmanteau. Will throw an error if the inputs aren't compatible. Works for all test cases.

Edit:

If I've read the edits to this question correctly, this updated code should work

f=lambda a,b:a[:-1]+b if a[-1]==b[0] else a[:len(a)-1-a[::-1].find(b[1])]+b[1:]

Answer 2

Ruby, 53 49 bytes

Work in progress; I don't have much time atm, will fix later:

f=->s,t{s+"_"+t=~/(.*?)(.+)(.*?)_.*?\2/;$1+$2+$'}

Doesn't give the expected result for camel + leopard:

f["django","angular"] -> "djangular"
f["camel","leopard"] -> "card"
f["croissant","donut"] -> "cronut"
f["spoon","fork"] -> "spork"
f["ham","hammer"] -> "hammer"

Answer 3

CoffeeScript, 111 bytes/characters

Source:

l="toLowerCase";f=(a,b)->return a.substr(0,i)+b.substr(j)[l]()for c,j in b when(i=a[l]().lastIndexOf(c[l]()))>0

Try it online!

To use:

alert("
#{f("Django","Angular")}
#{f("Camel","Leopard")}
#{f("Spoon","Fork")}
#{f("Ham","Hammer")}
")

I hoped it will be shorter, but.... ok, still better than PHP :D

The examples result in (using the alert statement above):

Djangular Cameleopard Spoork Hammer

Explanation (Might not be valid coffescript):

l="toLowerCase"; # Keeps code shorter (and DRY :D )
f=(a,b)->
  return a.substr(0,i)+b.substr(j)[l]() # Return the result
     for c,j in b # Postfix for loop
       when(i=a[l]().lastIndexOf(c[l]()))>0 
         # Run the return statement only when the 
         # character `c` is found (also stores its last position in `i`)

Answer 4

Haskell, 61 bytes

Doesn't handle case, but that doesn't seem to be a big deal? Tell me if it is.

a!b=maybe(init a!b)((a++).(`drop`b))$last a`lookup`zip b[1..]

Then "Django"!"Angular" is "Djangular".

Answer 5

PHP (270 bytes)

function portmanteau($s1, $s2){ $r = ''; $y = false; foreach(str_split($s1) as $c1){ $r .= $c1; foreach(str_split($s2) as $c2){ if($y){ $r.= $c2; } if(strtolower($c1)==strtolower($c2)){ $y = true; continue; } } if($y){ break; } } if(!$y) $r .= $s2; return ucfirst($r); }

Ungolfed:

function portmanteau($str1, $str2){
    $resultingString = '';

    $letterMatched = false;
    foreach(str_split($str1) as $char){
        $resultingString .= $char;

        foreach(str_split($str2) as $char2){
            if($letterMatched){
                $resultingString.= $char2;
            }

            if(strtolower($char)==strtolower($char2)){
                $letterMatched = true;
                continue;
            }
        }
        if($letterMatched){
            break;
        }
    }
    if(!$letterMatched) $resultingString .= $str2;

    return ucfirst($resultingString);
}

Usage:

echo portmanteau('Croissant', 'Donut');

Tested and works with the examples in the question.

Answer 6

Haskell, 148 bytes

C/case isn't restored though. Without case this was 99...

import Data.Char
o a b=|a==""=b|0<1=a
p""b=""
p a""=""
p a b|last a==head b=a++tail b|0<1=o(p(init a)b)(p a(tail b))
z a b=p(t a)(t b)
t=map toLower

Answer 7

Perl, 138

I'm sure someone can optimize this further
($a,$b,$l,$r)=(@ARGV,0);for$A(split//,$a){$r.=$A;for$B(split//,$b){$r.=$B if$l;if($A=~/$B/i){$l=1;next;}}last if$l;}$r.=$b if!$l;
138 w/ optimizations and output
($a,$b,$l,$r)=(@ARGV,0);for$A($a=~/./g){$r.=$A;for$B($b=~/./g){$r.=$B if$l;if($A=~/$B/i){$l=1;next;}}last if$l;}$r.=$b if!$l;print"$r\n";

Answer 8

rs, 24 bytes

(.*)(.).* .*?(\2.*)/\1\3

To copy the initial post from @refi64 here's the live demo and all test cases. The only improvement is that you can spare the \2 back reference by including it in the third group.

I didn't want to pollute with an answer that's actually a comment, but some person on Stack Exchange decided that you can't comment when you're a newcomer and that edits should be refused, because that should obviously be a comment. Thus, sorry for that misplaced content.

Answer 9

rs, 26 bytes

(.*)(.).* .*?\2(.*)/\1\2\3

Live demo and all test cases.

So far this is the shortest answer!

The underlying logic is pretty simple. It just matches greedily on the first word (to get the last common character) and non-greedily on the second (to get the first common character). It then replaces the string with everything but the text in between the two characters.