Einführung

Angenommen, S ₁ = a...bund S ₂ = ..c... Wenn wir sie aufeinander legen, erhalten wir:

a...b
..c..

Wir verschmelzen beide Zeichenketten mit dem .flüssigen Zeichen (das sich überlappen kann). Wir bekommen das:

a.c.b

Wenn einer der Strings länger als der andere ist, wenden wir einfach denselben Algorithmus an:

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

becomes:

a.c...b

und

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

becomes:

a.c...b...

Wenn zwei Zeichen kollidieren, verwenden wir nur das unterste Zeichen, z

a..b
...c

becomes:

a..c

Die Aufgabe

Geben Sie bei zwei nicht leeren Zeichenfolgen die zusammengeführte Zeichenfolge aus. Beachten Sie, dass die Eingabe nur Punkte und Kleinbuchstaben enthält (oder Großbuchstaben, falls dies praktischer ist).

Testfälle

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

Das ist Code-Golf , also gewinnt die Einsendung mit der geringsten Anzahl von Bytes!

Gelee , 5 Bytes

Œu»Œl

Eingabe über Kommandozeilenargumente.

Probieren Sie es online!

Erläuterung

Dies ist ein direkter Port meiner CJam-Antwort (eine Erklärung, warum dies funktioniert, finden Sie hier):

Œ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 es hier.

Erläuterung

Nutzt die Tatsache, dass '.' < upper case letters < lower case letters. Auf diese Weise .überschreibt ein Buchstabe , wenn das elementweise Maximum zwischen zwei Zeichenfolgen gesetzt wird, a. Sie können jedoch festlegen, dass ein Buchstabe aus der zweiten Eingabe einen Buchstaben aus der ersten überschreibt, wenn der erste in Großbuchstaben geschrieben wird. Verwirrend? Hier ist einer der Testfälle als Beispiel:

ab.ab.
b.b.b.

Zuerst in Großbuchstaben konvertieren:

AB.AB.
b.b.b.

Nehmen Sie das elementweise Maximum:

bBbAb.

Zurück in Kleinbuchstaben konvertieren:

bbbab.

Und so funktioniert der Code:

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 Zeichen

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

Prüfung

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

Probieren Sie es online aus oder führen Sie die Test Suite aus

Im Ernst, 10 Bytes

,û,Z`M`MΣù

Probieren Sie es online!

Verwendet die gleiche Strategie wie Martins CJam-Antwort

Erläuterung:

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

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

Anwendungsbeispiel: "ab.ab." # "b.b.b."-> "bbbab.".

Wie es funktioniert:

• Wenn beide Listen nicht leer sind, wählen Sie den Kopf der ersten Liste, wenn der Kopf der zweiten Liste ist ".", oder wählen Sie den Kopf der zweiten Liste. Fügen Sie einen rekursiven Aufruf mit den Endpunkten der Listen hinzu.

• Wenn mindestens eine Liste leer ist, hängen Sie beide Listen an.

Bearbeiten: @Lynn hat ein Byte gespeichert. Vielen Dank!

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

Dies ist eine Funktion, die zwei Zeichenfolgen akzeptiert und eine Zeichenfolge zurückgibt.

Wir berechnen mdie maximale Länge der beiden Eingaben, definieren dann eine Funktion r, die ihre Eingabe mit .s auf Länge mauffüllt, und speichern diese als Funktionsargument. Wir wählen dann zipdie richtigen gepolsterten Eingänge und überprüfen das Minimum (wie durch den ASCII-Code definiert) jedes Paares. Wenn es ein ist ., verwenden wir dasjenige Zeichen, das den größeren Code hat, andernfalls verwenden wir dasjenige, das aus der zweiten Eingabe stammt. Das resultierende Array wird joinin eine Zeichenfolge umgewandelt und zurückgegeben.

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 live auf ideone .

Netzhaut , 55

$

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

Zeile 5 ist ein einzelnes Leerzeichen. Zeile 6 ist eine leere Zeile (ohne abschließenden Zeilenumbruch).

Probieren Sie es online aus.

Ich habe dieses in GNU sed gestartet (mit der Option -r). Einfacher Port zu Retina, sobald ich die Regexes herausgefunden habe. Die sed Version ist:

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

Probieren Sie es hier aus!

Zuerst erstellen wir beide Strings zu einer Liste. Wenn die zweite Zeichenfolge länger als die erste ist, wird sie mit None( map(None,x,y)tut das) aufgefüllt .
Dann iterieren wir über diese Liste, wobei jes sich um das Zeichen aus der ersten Zeichenfolge und kdas aus der zweiten Zeichenfolge handelt. Wir entscheiden, kob es kein Punkt ist und ansonsten j.

Dies könnten 61 Bytes sein, wenn ich das Ergebnis als Liste von Zeichen anstelle einer Zeichenfolge ausgeben könnte.

Perl, 48 + 3 = 51 Bytes

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

Bah kann keine kürzere Lösung finden. (Gleicher Ansatz wie die Antwort von @ Qwertiy in JavaScript).
Erfordert -plund nimmt Eingaben von stdinund entgegen-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;

Online Version

q / kdb + 43 40 Bytes

Lösung:

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

Beispiel:

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

Erläuterung:

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

Anmerkungen: Ich nutze den Vorteil von "Bei zwei nicht leeren Zeichenfolgen " und gehe davon aus, dass Eingaben Zeichenfolgen sind. In kdb "c"ist ein Atom, (),"c"ist ein String, sonst müssen 6 Bytes zum Score addiert werden, da wir kein Atom auffüllen können $...