Dada una entrada de dos cadenas con secuencias de guiones bajos que representan las palabras correspondientes, genera las oraciones con los "espacios en blanco" rellenados.

La mejor manera de describir este desafío es con el ejemplo. Aquí hay un ejemplo de entrada:

programming _____________ and code golf
programming puzzles ______ code ____

Y aquí está la salida correspondiente:

programming ___puzzles___ and code golf
programming puzzles _and__ code golf

Para los propósitos de este desafío, una "palabra" se define como una secuencia de una o más letras minúsculas, y un "espacio en blanco" se define como uno o más guiones bajos (la entrada siempre contendrá solo letras minúsculas, espacios y guiones bajos) . Las palabras y los espacios en blanco en las cadenas de entrada están separadas por espacios individuales, y la suma del número de palabras y espacios en blanco en las oraciones siempre será igual.

El objetivo del desafío es llenar todos los espacios en blanco con las palabras correctas , que son las palabras que ocupan el mismo índice en la otra cadena cuando se dividen por espacios.

• La palabra debe estar centrada en el espacio en blanco, como se muestra con la palabra "rompecabezas" en el ejemplo anterior; un número igual de guiones bajos permanece a cada lado.

• Si la palabra no puede estar exactamente centrada, el guión bajo adicional puede ir a la izquierda o a la derecha (por ejemplo, la palabra "y" en el ejemplo anterior).

• Siempre habrá suficientes guiones bajos para que la palabra se ajuste, pero puede haber exactamente tantos como la longitud de la palabra (por ejemplo, la palabra "golf" en el ejemplo anterior).

• Nunca habrá un espacio en blanco en la misma posición en ambas cadenas.

La entrada / salida puede ser cualquiera de los siguientes (la entrada / salida no necesariamente tiene que ser a través del mismo método):

• cadena simple separada por cualquier carácter que no sea alfabético, un espacio o un guión bajo (por ejemplo, línea nueva o cadena separada por comas)

• una matriz / lista / etc. de dos cuerdas

• dos argumentos de línea de función / comando (solo entrada)

Como se trata de código golf , el código más corto en bytes ganará.

El ejemplo anterior se puede usar como un caso de prueba. Aquí hay un caso de prueba más grande (la segunda cadena en la salida puede variar ligeramente debido a un comportamiento de centrado diferente):

lorem _____ dolor _____ amet _______________ adipiscing elit mauris dapibus tincidunt _____________________________ accumsan fringilla proin vulputate viverra lorem fermentum dictum
lorem ipsum ______ sit _______ consectetur _______________ elit mauris dapibus tincidunt metus accumsan fringilla proin vulputate viverra lorem ____________________________ dictum

lorem ipsum dolor _sit_ amet __consectetur__ adipiscing elit mauris dapibus tincidunt ____________metus____________ accumsan fringilla proin vulputate viverra lorem fermentum dictum
lorem ipsum dolor_ sit _amet__ consectetur __adipiscing___ elit mauris dapibus tincidunt metus accumsan fringilla proin vulputate viverra lorem _________fermentum__________ dictum

Pyth, 30

jL;Cmm|*}J\_k.[lkhx#JdJkdCcR;Q

Toma entradas y salidas como una lista de dos cadenas. Utiliza un enfoque bastante básico de división-zip-doble mapa-centro-zip-unión.

Pruébalo aquí

Expandido:

jL;Cmm|*}J\_k.[lkhx#JdJkdCcR;Q   ##
                          cR;Q   ##  split
                         C       ##  zip
    mm                           ##  double map
      |*}J\_k.[lkhx#JdJkd        ##  centre
   C                             ##  zip
jL;                              ##  join

Explicaré más una vez que esté realmente satisfecho de que no puedo seguir jugando al golf, aunque debería ser bastante claro, dada la ubicuidad del enfoque de división-zip-doble mapa-centro-zip-unión y todo.

Retina , 102 100 93 88 bytes

El recuento de bytes asume la codificación ISO 8859-1.

$
!¶$`
m`(?<=^(\w+ )*)(?=_.*¶(?<-1>\w+ )*(\w+))
$2
(([a-z])+)(?<-2>_)*(_*)\3|!\D+
$3$1$3

Las cadenas estarán separadas por un salto de línea. Si queda un número impar de guiones bajos, el extraño aparecerá después de la palabra.

Pruébalo en línea!

Explicación

Supongo que este es el enfoque "duplicar-agregar-mirar hacia atrás-coincidir-agregar-centro", o algo parecido ...

$
!¶$`

Comenzamos duplicando la entrada (separada con un !y un salto de línea). El propósito de esto es que podemos procesar ambas líneas buscando palabras de la siguiente línea (en lugar de tener que tratar la segunda línea por separado).

m`(?<=^(\w+ )*)(?=_.*¶(?<-1>\w+ )*(\w+))
$2

Esto antepone la palabra correcta a cada espacio. Comenzamos contando la posición actual de la palabra con la mirada hacia atrás (?<=^(\w+ )*)(la posición se almacena como la profundidad del grupo 1). Luego, la búsqueda anticipada a) asegura que estamos al comienzo de una brecha al hacer coincidir _, luego salta a la siguiente línea con .*¶, coincide con el número correcto de palabras con (?<-1>\w+ )*para llegar a la posición correcta, y luego coincide con la palabra encontrada allí (\w+)en grupo 2.

(([a-z])+)(?<-2>_)*(_*)\3|!\D+
$3$1$3

Esta etapa hace tres cosas:

• Elimina los guiones bajos correspondientes a cada longitud de palabra. Esto se hace contando el largo de una palabra en el grupo 2con ([a-z])+y luego a juego que muchos guiones (que nunca están de vuelta escrito).
• Cambia la palabra al centro de la brecha al capturar la mitad de los guiones bajos restantes (_*)\3y escribir de $3$1$3nuevo.
• Elimina la entrada duplicada haciendo coincidir !\D+y reemplazando con nada.

Pitón 2, 109

def f(a,b):exec"print' '.join([x,y][x<'`'].center(len(x),'_')for x,y in zip(a.split(),b.split()));a,b=b,a;"*2

La función toma dos cadenas como argumentos e imprime la salida como en los ejemplos. Utiliza un enfoque aburrido, str.center(width, fillchar)haciendo la mayor parte del trabajo.

Pruébalo en línea .

Ruby, 111 109 caracteres

->l{l.map(&:split).transpose.map{|c|c[m=c[0]<c[1]?0:1]=c[1-m].center c[m].size,?_
c}.transpose.map{|s|s*' '}}

Entrada: conjunto de 2 cadenas; salida: conjunto de 2 cadenas.

Ejecución de muestra:

2.1.5 :001 > puts ->l{l.map(&:split).transpose.map{|c|c[m=c[0]<c[1]?0:1]=c[1-m].center c[m].size,?_;c}.transpose.map{|s|s*' '}}[[
2.1.5 :002 >       'programming _____________ and code golf',
2.1.5 :003 >       'programming puzzles ______ code ____',
2.1.5 :004 >       ]]
programming ___puzzles___ and code golf
programming puzzles _and__ code golf

JavaScript, 194185 bytes

f=(m,n)=>(m=m.split` `,n=n.split` `,G=(x,i,a)=>x[0]!='_'?x:(b=(a?n:m)[i],s=x.length-b.length,(k='_'.repeat(s/2))+b+k+(s%2?'_':'')),H=(e,y)=>e.map((x,i)=>G(x,i,y)).join` `,[H(m,1),H(n)])

Toma dos cadenas como parámetros y genera dos cadenas como matriz / lista

f=(m,n)=>(
    m=m.split` `,
    n=n.split` `,
    G=(x,i,a)=>
        x[0]!='_'?x:
        (
            b=(a?n:m)[i],
            s=x.length-b.length,
            (k='_'.repeat(s/2))+b+k+(s%2?'_':'')
        ),
    H=(e,y)=>e.map((x,i)=>G(x,i,y)).join` `,
    [H(m,1),H(n)]
)

document.body.innerHTML = '<pre>' +
    "f('lorem _____ dolor _____ amet _______________ adipiscing elit mauris dapibus tincidunt _____________________________ accumsan fringilla proin vulputate viverra lorem fermentum dictum', 'lorem ipsum ______ sit _______ consectetur _______________ elit mauris dapibus tincidunt metus accumsan fringilla proin vulputate viverra lorem ____________________________ dictum')<br>" +
    f('lorem _____ dolor _____ amet _______________ adipiscing elit mauris dapibus tincidunt _____________________________ accumsan fringilla proin vulputate viverra lorem fermentum dictum', 'lorem ipsum ______ sit _______ consectetur _______________ elit mauris dapibus tincidunt metus accumsan fringilla proin vulputate viverra lorem ____________________________ dictum') + "<br><br>" +
    "f('programming _____________ and code golf', 'programming puzzles ______ code ____')<br>" +
    f('programming _____________ and code golf', 'programming puzzles ______ code ____')
'</pre>'

Mathematica 223

Debe haber una forma más corta de hacer esto.

k=StringLength;m=StringSplit;
g=Partition[Riffle[m@#,m@#2],2]/.{{a_,a_}:> a<>" ",{a_,b_/; StringTake[b,1]=="_"}:> a<>" ",
{a_,b_}:>Table["_",Ceiling[z=(k@a-k@b)/2]]<>b<>""<>Table["_",Floor@z]<>" "}&;
s_~h~t_:={""<>g[s,t],""<>g[t,s]}

Ejecución de la muestra

h["programming _____________ and code golf", "programming puzzles ______ code ____"]

Gema, 208 203 caracteres

\B=@set{i;0}
<I>=@push{${v;f};$0}@incr{i}
\n=@set{v;s}@set{i;0}
 =
\E=@repeat{$i;@cmps{$f;$s;@set{f;@fill-center{$f;$s}};;@set{s;@fill-center{$s;$f}}}@set{F;$f ${F;}}@set{S;$s ${S;}}@pop{f}@pop{s}}$F\n$S

El hecho de que Gema tiene la función perfecta para esta tarea: .@fill-center{background;value}

Entrada: 2 líneas separadas por nueva línea (sin nueva línea final); salida: 2 líneas separadas de nueva línea (con espacios finales, no parece estar prohibido).

Ejecución de muestra:

bash-4.3$ echo -ne 'programming _____________ and code golf\nprogramming puzzles ______ code ____' |
> gema '\B=@set{i;0};<I>=@push{${v;f};$0}@incr{i};\n=@set{v;s}@set{i;0}; =;\E=@repeat{$i;@cmps{$f;$s;@set{f;@fill-center{$f;$s}};;@set{s;@fill-center{$s;$f}}}@set{F;$f ${F;}}@set{S;$s ${S;}}@pop{f}@pop{s}}$F\n$S'
programming ___puzzles___ and code golf 
programming puzzles _and__ code golf 

C, 197 bytes

#define c(w,y)l=strspn(w,"_"),r=strcspn(y," "),memcpy(w+(l-r)/2,y,r),w+=l,y+=r;
main(l,v,w,y,r)char**v,*w,*y;{for(w=v[1],y=v[2];*w;w++,y++)if(*w^*y)if(*w^95)c(y,w)else c(w,y)puts(v[1]);puts(v[2]);}

Salida

$ ./a.out "lorem _____ dolor _____ amet _______________ adipiscing elit mauris dapibus tincidunt _____________________________ accumsan fringilla proin vulputate viverra lorem fermentum dictum" "lorem ipsum ______ sit _______ consectetur _______________ elit mauris dapibus tincidunt metus accumsan fringilla proin vulputate viverra lorem ____________________________ dictum"
lorem ipsum dolor _sit_ amet __consectetur__ adipiscing elit mauris dapibus tincidunt ____________metus____________ accumsan fringilla proin vulputate viverra lorem fermentum dictum
lorem ipsum dolor_ sit _amet__ consectetur __adipiscing___ elit mauris dapibus tincidunt metus accumsan fringilla proin vulputate viverra lorem _________fermentum__________ dictum

ES6, 122 bytes

a=>a.map(s=>s.split` `).map((s,n,a)=>s.map((w,i)=>w<'a'?(l=w.length,t=w+a[n^1][i]+w,t.substr(t.length-l>>1,l)):w).join` `)

Toma una matriz de dos cadenas como un solo parámetro y devuelve otra matriz de dos cadenas.