Introducción

Digamos que S ₁ = a...by S ₂ = ..c... Si los colocamos uno encima del otro, obtenemos:

a...b
..c..

Fusionamos ambas cadenas, con el .carácter de líquido (que puede superponerse). Obtenemos esto:

a.c.b

Si una de las cadenas es más larga que la otra, solo aplicamos el mismo algoritmo:

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

becomes:

a.c...b

y

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

becomes:

a.c...b...

Si dos caracteres chocan, solo usamos el carácter inferior, por ejemplo

a..b
...c

becomes:

a..c

La tarea

Dadas dos cadenas no vacías, genera la cadena combinada . Tenga en cuenta que puede suponer que la entrada solo contiene puntos y letras minúsculas (o letras mayúsculas si es más conveniente).

Casos de prueba

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

Este es el código de golf , por lo que gana el envío con la menor cantidad de bytes.

Jalea , 5 bytes

Œu»Œl

Entrada a través de argumentos de línea de comandos.

Pruébalo en línea!

Explicación

Este es un puerto directo de mi respuesta de CJam (vea eso para obtener una explicación de por qué esto 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

Pruébalo aquí.

Explicación

Hace uso del hecho de que '.' < upper case letters < lower case letters. De esta manera, cuando se toma el máximo de elementos entre dos cadenas, cualquier letra anula a ., pero podemos hacer que una letra de la segunda entrada anule una letra de la primera si escribimos en mayúscula la primera. ¿Confuso? Este es uno de los casos de prueba como ejemplo:

ab.ab.
b.b.b.

Convertir primero a mayúsculas:

AB.AB.
b.b.b.

Tome el elemento máximo sabio:

bBbAb.

Convertir de nuevo a minúsculas:

bbbab.

Y así es como el código hace eso:

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)

Prueba

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

Pruébelo en línea o ejecute Test Suite

En serio, 10 bytes

,û,Z`M`MΣù

Pruébalo en línea!

Utiliza la misma estrategia que la respuesta de Martin CJam

Explicación:

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

Octava, 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

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

Cómo funciona:

• si ambas listas no están vacías, elija el encabezado de la primera lista si el encabezado de la segunda lista lo está ".", de lo contrario, elija el encabezado de la segunda lista. Agregue una llamada recursiva con las colas de las listas.

• si al menos una lista está vacía, agregue ambas listas.

Editar: @Lynn guardó un byte. ¡Gracias!

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 es una función que acepta dos cadenas y devuelve una cadena.

Calculamos mcomo la longitud máxima de las dos entradas, luego definimos una función rque rellena correctamente su entrada con .s a la longitud my la almacenamos como un argumento de función. Luego, zipingresamos las entradas acolchadas a la derecha y verificamos el mínimo (según lo definido por el código ASCII) de cada par. Si es un ., usamos el carácter que tenga el código más grande, de lo contrario, usamos el que provenga de la segunda entrada. La matriz resultante se joinedita en una cadena y se devuelve.

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);}

Prueba en vivo en ideone .

Retina , 55

PS

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

La línea 5 es un espacio único. La línea 6 es una línea vacía (sin nueva línea final).

Pruébalo en línea.

Comencé este en GNU sed, (con la opción -r). Puerto directo a Retina una vez que resolví las expresiones regulares. La versión sed es:

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

Pruébalo aquí!

Primero creamos zip ambas cadenas en una lista. Si la segunda cadena es más larga que la primera, se rellena con None( map(None,x,y)hace eso).
Luego iteramos sobre esta lista con jel carácter de la primera cadena y kel de la segunda cadena. Elegimos ksi no es un punto y de lo contrario j.

Esto podría ser de 61 bytes si pudiera generar el resultado como una lista de caracteres en lugar de una cadena.

Perl, 48 + 3 = 51 bytes

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

Bah no puede encontrar una solución más corta. (El mismo enfoque que la respuesta de JavaScript de @ Qwertiy).
Requiere -ply toma entrada de stdiny-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;

Versión en línea

q / kdb +, 43 40 bytes

Solución:

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

Ejemplo:

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

Explicación:

(#:)                // 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: Estoy aprovechando "Dadas dos cadenas no vacías " y suponiendo que las entradas son cadenas. En kdb "c"es un átomo, (),"c"es una cadena, de lo contrario es necesario agregar 6 bytes a la puntuación, ya que no podemos usar $para rellenar un átomo ...