introduction

Disons que S ₁ = a...bet S ₂ = ..c... Si nous les plaçons les uns sur les autres, nous obtenons:

a...b
..c..

Nous fusionnons les deux chaînes, avec le .caractère liquide (qui peut se chevaucher). Nous obtenons ceci:

a.c.b

Si l'une des chaînes est plus longue que l'autre, nous appliquons simplement le même algorithme:

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

becomes:

a.c...b

et

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

becomes:

a.c...b...

Si deux caractères entrent en collision, nous utilisons simplement le caractère du bas, par exemple

a..b
...c

becomes:

a..c

La tâche

Étant donné deux chaînes non vides, affichez la chaîne fusionnée . Remarque , vous pouvez supposer que l'entrée ne contient que des points et des lettres minuscules (ou des lettres majuscules si cela est plus pratique).

Cas de test

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

C'est du code-golf , donc la soumission avec le moins d'octets gagne!

Gelée , 5 octets

Œu»Œl

Entrée via des arguments de ligne de commande.

Essayez-le en ligne!

Explication

Ceci est un port direct de ma réponse CJam (voir cela pour une explication pourquoi cela fonctionne):

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

CJam, 9 octets

leul.e>el

Testez-le ici.

Explication

Fait usage du fait que '.' < upper case letters < lower case letters. De cette façon, lorsque vous prenez le maximum par élément entre deux chaînes, toute lettre remplace a ., mais nous pouvons faire qu'une lettre de la deuxième entrée remplace une lettre de la première si nous majuscules la première. Déroutant? Voici un des cas de test à titre d'exemple:

ab.ab.
b.b.b.

Convertissez d'abord en majuscules:

AB.AB.
b.b.b.

Prenez le maximum par élément:

bBbAb.

Convertir en minuscules:

bbbab.

Et voici comment le code fait cela:

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 caractères

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

Tester

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

Essayez-le en ligne ou exécutez la suite de tests

Sérieusement, 10 octets

,û,Z`M`MΣù

Essayez-le en ligne!

Utilise la même stratégie que la réponse CJam de Martin

Explication:

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

Octave, 50 octets

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

Haskell, 43 42 octets

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

Exemple d'utilisation: "ab.ab." # "b.b.b."-> "bbbab.".

Comment ça fonctionne:

• si les deux listes ne sont pas vides, choisissez la tête de la 1ère liste si la tête de la 2ème liste est ".", sinon choisissez la tête de la deuxième liste. Ajoutez un appel récursif avec la queue des listes.

• si au moins une liste est vide, ajoutez les deux listes.

Modifier: @Lynn a enregistré un octet. Merci!

Python 2, 47 octets

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

Julia, 101 octets

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

Il s'agit d'une fonction qui accepte deux chaînes et renvoie une chaîne.

Nous calculons mla longueur maximale des deux entrées, puis définissons une fonction rqui remplit à droite son entrée avec .s à longueur met la stockons comme argument de fonction. Nous avons ensuite ziples entrées capitonnées à droite et vérifions le minimum (tel que défini par le code ASCII) de chaque paire. Si c'est le cas ., nous utilisons le caractère qui a le plus gros code, sinon nous utilisons celui qui provient de la deuxième entrée. Le tableau résultant est joinédité dans une chaîne et renvoyé.

C, 106 89 octets

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

Testez en direct sur ideone .

Rétine , 55

$

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

La ligne 5 est un espace unique. La ligne 6 est une ligne vide (sans nouvelle ligne de fin).

Essayez-le en ligne.

J'ai commencé celui-ci dans GNU sed, (avec l'option -r). Port simple vers Retina une fois que j'aurai compris les expressions régulières. La version sed est:

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

Python 2, 70 octets

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

Essayez-le ici!

D'abord, nous créons zip les deux chaînes dans une seule liste. Si la deuxième chaîne est plus longue que la première, elle est complétée par None( map(None,x,y)fait cela).
Ensuite, nous parcourons cette liste en jétant le caractère de la première chaîne et kcelui de la deuxième chaîne. On choisit ksi ce n'est pas un point et sinonj .

Cela pourrait être de 61 octets si je pouvais produire le résultat sous forme de liste de caractères au lieu d'une chaîne.

Perl, 48 + 3 = 51 octets

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

Bah ne peut pas trouver de solution plus courte. (Même approche que la réponse JavaScript de @ Qwertiy).
Requiert -plet prend des contributions de stdinet-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 octets

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

Version en ligne

q / kdb +, 43 40 octets

Solution:

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

Exemple:

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

Explication:

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

Notes: Je profite de "Étant donné deux chaînes non vides " et je suppose que les entrées sont des chaînes. Dans kdb "c"est un atome, (),"c"est une chaîne, sinon il faut ajouter 6 octets au score, car nous ne pouvons pas utiliser $pour remplir un atome ...