Rellene mutuamente los espacios en blanco

11

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 , 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
Pomo de la puerta
fuente
Buen desafío bidireccional.
Rɪᴋᴇʀ

Respuestas:

5

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.

FryAmTheEggman
fuente
8
Ahhh, el enfoque clásico de división-zip-doble map-center-zip-join. Recuerdo con cariño que se utilizó como un ejemplo introductorio en mi conferencia Algorithms 101.
Martin Ender
3
@ MartinBüttner Sí, tengo algunos malos recuerdos porque dormí en esa clase, tuve que resolver problemas en el examen usando el enfoque de duplicar-agregar-mirar hacia atrás-coincidir-agregar-centro en su lugar.
FryAmTheEggman
44
Iré a aplicar un poco de agua fría a la quemadura.
Martin Ender
7

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.
Martin Ender
fuente
4

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 .

grc
fuente
1
No creo que lo necesite z, a menos que me falte algo, simplemente puede hacer el intercambio después de la impresión y en línea z.
FryAmTheEggman
@FryAmTheEggman sí, tienes razón. Gracias :)
grc
2

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
hombre trabajando
fuente
1

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

remoto
fuente
1

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 ____"]

ingrese la descripción de la imagen aquí

DavidC
fuente
0

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 
hombre trabajando
fuente
0

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
Cole Cameron
fuente
0

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.

Neil
fuente