introduzione

Diciamo che S ₁ = a...be S ₂ = ..c... Se li posizioniamo uno sopra l'altro, otteniamo:

a...b
..c..

Uniamo entrambe le stringhe, con il .carattere liquido (che può essere sovrapposto). Otteniamo questo:

a.c.b

Se una delle stringhe è più lunga dell'altra, applichiamo semplicemente lo stesso algoritmo:

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

becomes:

a.c...b

e

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

becomes:

a.c...b...

Se due personaggi si scontrano, usiamo solo il personaggio in basso, ad es

a..b
...c

becomes:

a..c

L'obiettivo

Dato due stringhe non vuote, genera la stringa unita . Nota , si può supporre che l'ingresso contiene solo i periodi e le lettere minuscole (o lettere maiuscole se questo è più conveniente).

Casi test

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

Questo è code-golf , quindi vince l'invio con il minor numero di byte!

Gelatina , 5 byte

Œu»Œl

Input tramite argomenti della riga di comando.

Provalo online!

Spiegazione

Questa è una porta diretta della mia risposta CJam (vedi che per una spiegazione del perché funziona):

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

CJam, 9 byte

leul.e>el

Provalo qui.

Spiegazione

Si avvale del fatto che '.' < upper case letters < lower case letters. In questo modo, quando si prende il massimo dal punto di vista dell'elemento tra due stringhe, qualsiasi lettera sovrascrive a ., ma possiamo fare in modo che una lettera dal secondo input abbia la precedenza su una lettera dal primo se si fa in maiuscolo il primo. Confondere? Ecco uno dei casi di test come esempio:

ab.ab.
b.b.b.

Converti prima in maiuscolo:

AB.AB.
b.b.b.

Prendi il massimo dal punto di vista degli elementi:

bBbAb.

Converti in minuscolo:

bbbab.

Ed ecco come funziona il codice:

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 caratteri

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

Test

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

Provalo online o esegui Test Suite

Scherzi a parte, 10 byte

,û,Z`M`MΣù

Provalo online!

Utilizza la stessa strategia della risposta CJam di Martin

Spiegazione:

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

Ottava, 50 byte

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

Haskell, 43 42 byte

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

Esempio di utilizzo: "ab.ab." # "b.b.b." -> "bbbab.".

Come funziona:

• se entrambi gli elenchi non sono vuoti, selezionare l'intestazione del primo elenco se è presente l'intestazione del secondo elenco "." , altrimenti scegli il titolo del secondo elenco. Aggiungi una chiamata ricorsiva con le code degli elenchi.

• se almeno una lista è vuota, aggiungi entrambe le liste.

Modifica: @Lynn ha salvato un byte. Grazie!

Python 2, 47 byte

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

Julia, 101 byte

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

Questa è una funzione che accetta due stringhe e restituisce una stringa.

Calcoliamo m come lunghezza massima dei due input, quindi definiamo una funzione rche riempie il suo input con .s di lunghezza me lo memorizziamo come argomento di funzione. Abbiamo quindi zipgli ingressi imbottiti corretti e controlliamo il minimo (come definito dal codice ASCII) di ogni coppia. Se è un ., usiamo qualunque carattere abbia il codice più grande, altrimenti usiamo qualunque sia il secondo input. L'array risultante viene joininserito in una stringa e restituito.

C, 106 89 byte

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

Prova dal vivo su ideone .

Retina , 55

$

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

La linea 5 è un singolo spazio. La riga 6 è una riga vuota (senza nuova riga finale).

Provalo online.

Ho iniziato questo in GNU sed, (con l'opzione -r). Porto diretto a Retina una volta che ho capito i regexes. La versione sed è:

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

Python 2, 70 byte

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

Provalo qui!

Per prima cosa creiamo zip entrambe le stringhe in un elenco. Se la seconda stringa è più lunga della prima, viene riempita con None(lo map(None,x,y)fa).
Quindi ripetiamo questo elenco con jil carattere della prima stringa e kquello della seconda stringa. Noi scegliamok se non è un punto e altrimentij .

Questo potrebbe essere 61 byte se potessi visualizzare il risultato come elenco di caratteri anziché come stringa.

Perl, 48 + 3 = 51 byte

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

Bah non riesce a trovare una soluzione più breve. (Stesso approccio della risposta JavaScript di @ Qwertiy).
Richiede -ple accetta input da 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 byte

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

Versione online

q / kdb +, 43 40 byte

Soluzione:

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

Esempio:

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

Spiegazione:

(#:)                // 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

Note: sto sfruttando "Dato due stringhe non vuote " e assumendo che gli input siano stringhe. In kdb "c"è un atomo, (),"c"è una stringa, altrimenti è necessario aggiungere 6 byte al punteggio, dato che non possiamo usare $per riempire un atomo ...