Introdução

Digamos que S ₁ = a...be S ₂ = ..c... Se os colocarmos um em cima do outro, obtemos:

a...b
..c..

Mesclamos as duas strings, com o .caractere líquido (que pode se sobrepor). Temos isso:

a.c.b

Se uma das strings for mais longa que a outra, aplicaremos o mesmo algoritmo:

a.....b
..c..  

becomes:

a.c...b

e

a.....b
..c.......

becomes:

a.c...b...

Se dois caracteres colidirem, apenas usamos o caractere inferior, por exemplo

a..b
...c

becomes:

a..c

A tarefa

Dadas duas cadeias não vazias, produza a cadeia mesclada . Observe que você pode supor que a entrada contenha apenas pontos e letras minúsculas (ou maiúsculas, se for mais conveniente).

Casos de teste

Input              Output
a....b ..c...      a.c..b
aaaaaa bbbbbb      bbbbbb
ab.ab. b.b.b.      bbbab.
a.......b c        c.......b

Isso é código-golfe , então a submissão com a menor quantidade de bytes ganha!

Gelatina , 5 bytes

Œu»Œl

Entrada via argumentos da linha de comando.

Experimente online!

Explicação

Esta é uma porta direta da minha resposta CJam (veja isso para uma explicação sobre por que isso funciona):

Œu     # Convert first argument to upper case.
  »    # Element-wise maximum between both strings.
   Œl  # Convert result back to lower case.

CJam, 9 bytes

leul.e>el

Teste aqui.

Explicação

Faz uso do fato de que '.' < upper case letters < lower case letters. Dessa forma, ao usar o máximo em elementos entre duas cadeias, qualquer letra substitui a ., mas podemos fazer uma letra da segunda entrada substituir uma letra da primeira se colocarmos em maiúscula a primeira. Confuso? Aqui está um dos casos de teste como exemplo:

ab.ab.
b.b.b.

Converter primeiro em maiúsculas:

AB.AB.
b.b.b.

Tome o máximo em elementos:

bBbAb.

Converter de volta para minúsculas:

bbbab.

E aqui está como o código faz isso:

l    e# Read first line.
eu   e# Convert to upper case.
l    e# Read second line.
.e>  e# Take element-wise maximum. If the lengths are different, the additional elements
     e# from the longer list are just appended.
el   e# Convert back to lower case.

Javascript ES6, 52 55 caracteres

(a,b)=>b.replace(/\./g,(m,i)=>a[i]||m)+a.slice(b.length)

Teste

f=(a,b)=>b.replace(/\./g,(m,i)=>a[i]||m)+a.slice(b.length)
;`
a....b ..c...      a.c..b
aaaaaa bbbbbb      bbbbbb
ab.ab. b.b.b.      bbbab.
a.......b c        c.......b
c a....b           a....b
`.split('\n').filter(Boolean).map(s=>s.split(/\s+/)).every(a=>f(a[0],a[1])==a[2])

Pyth, 11

smenD\.d.TQ

Experimente online ou execute o Test Suite

Sério, 10 bytes

,û,Z`M`MΣù

Experimente online!

Usa a mesma estratégia da resposta CJam de Martin

Explicação:

,û,Z`M`MΣù
,û          get first string, uppercase
  ,Z        get second string, zip with first string
    `M`M    map maximum
        Σù  join and uppercase

Oitava, 50 bytes

function c=m(a,b)c=b;c(a>0)=a;i=b>46;c(i)=b(i);end

Haskell, 43 42 bytes

(a:b)#(c:d)|c<'a'=a:b#d|1<2=c:b#d
a#b=a++b

Exemplo de uso: "ab.ab." # "b.b.b."-> "bbbab.".

Como funciona:

• se as duas listas não estiverem vazias, escolha o cabeçalho da 1ª lista, se o cabeçalho da 2ª lista estiver ".", ou escolha o cabeçalho da segunda lista. Anexe uma chamada recursiva com as caudas das listas.

• se pelo menos uma lista estiver vazia, anexe as duas listas.

Editar: @Lynn salvou um byte. Obrigado!

Python 2, 47 bytes

lambda s,t:`map(max,s.upper(),t)`[2::5].lower()

Julia, 101 bytes

f(s,t,r=i->rpad(i,max((n=endof)(s),n(t)),"."))=join([min(a,b)<90?max(a,b):b for(a,b)=zip(r(s),r(t))])

Esta é uma função que aceita duas strings e retorna uma string.

Computamos mcomo o comprimento máximo das duas entradas, depois definimos uma função rque preenche corretamente sua entrada com .s para comprimento me a armazena como argumento de função. Em seguida, zipas entradas acolchoadas à direita e verificamos o mínimo (conforme definido pelo código ASCII) de cada par. Se for um ., usamos qualquer caractere com o código maior, caso contrário, usamos o que vier da segunda entrada. A matriz resultante é joined em uma string e retornada.

C, 106 89 bytes

i,j,k;f(s,z)char*s,*z;{for(i=0,j=k=1;j|k;i++)putchar((k=k?z[i]:0)>46|!(j=j?s[i]:0)?k:j);}

Teste ao vivo em ideone .

Retina , 55

$

+ `(.? (\ S *) (\ w) | (\ S) (\ S *).?) (\ S *. *)
US $ 2 US $ 5 US $ 6 US $ 3 US $ 4

A linha 5 é um espaço único. A linha 6 é uma linha vazia (sem nova linha à direita).

Experimente online.

Comecei este no GNU sed (com a opção -r). Porto direto para Retina, uma vez que eu tenho as regexes descobertas. A versão sed é:

s/$/ /
:
s/(.?(\S* )(\w)|(\S)(\S* ).?)(\S* .*)/\2\5\6\3\4/
t
s/ *//

Python 2, 70 bytes

lambda x,y:"".join([k if k!="."and k else j for j,k in map(None,x,y)])

Experimente aqui!

Primeiro, criamos zip as duas strings em uma lista. Se a segunda corda for maior que a primeira, ela será preenchida com None( map(None,x,y)faz isso).
Em seguida, iteramos nesta lista jsendo o caractere da primeira string e ko da segunda string. Nós escolhemos kse não é um ponto e caso contrárioj .

Isso poderia ter 61 bytes se eu pudesse produzir o resultado como lista de caracteres em vez de uma sequência.

Perl, 48 + 3 = 51 bytes

s/\./substr($^I,$.=pos,1)||$&/ge;$_.=substr$^I,$.

Bah não consegue encontrar uma solução mais curta. (Mesma abordagem que a resposta do JavaScript de @ Qwertiy).
Requer -ple recebe informações de stdine-i

$ perl -i'a...ce' -ple's/\./substr($^I,$.=pos,1)||$&/ge;$_.=substr$^I,$.' <<< '..b.d..f'
a.b.de..f

PHP> = 7.1, 58 bytes

for([,$x,$y]=$argv;~$c=$y[$i++];)$c<_?:$x[$i-1]=$c;echo$x;

Versão Online

q / kdb +, 43 40 bytes

Solução:

lower{l:max(#:)each(x;y);upper[l$x]|l$y}

Exemplo:

q)lower{l:max(#:)each(x;y);upper[l$x]|l$y}["a..b..";"...c"]
"a..c.."

Explicação:

(#:)                // k equivalent of count
max (#:) each(x;y)  // takes each string, count the length, return maximum
l$x                 // whites-space pad string x to length l
|                   // take the maximum (per Martin's strategy)
upper[...]          // convert padded string 1 to uppercase
lower{...}          // convert result of function to lowercase

Notas: Estou aproveitando "Dadas duas strings não vazias " e assumindo que as entradas são strings. No kdb "c"é um átomo, (),"c"é uma string, caso contrário, precisamos adicionar 6 bytes à pontuação, pois não podemos usar $para preencher um átomo ...