Componer llenar los espacios en blanco

18

Digamos que tenemos un conjunto particular de funciones en cadenas. Estas funciones son como completar los espacios en blanco o madlibs, excepto que solo toman una entrada y la usan para completar todos sus espacios en blanco. Por ejemplo, podríamos tener una función similar a

I went to the ____ store and bought ____ today.

Si aplicamos esta función a la cadena, cheeseel resultado sería:

I went to the cheese store and bought cheese today.

Podemos representar estas funciones como una lista no vacía de cadenas, donde los espacios en blanco son simplemente los espacios entre cadenas. Por ejemplo, nuestra función anterior sería:

["I went to the ", " store and bought ", " today."]

Con esta representación solo hay una representación para cada función de este tipo y solo una función para cada representación.

Una cosa realmente interesante es que el conjunto de tales funciones está cerrado bajo composición. Es decir, la composición de dos de nuestras funciones es siempre otra de estas funciones. Por ejemplo, si compongo nuestra función anterior con

["blue ", ""]

(la función que antecede bluea la entrada) Obtenemos la función:

["I went to the blue ", " store and bought blue ", " today."]

Sin embargo, estos pueden volverse un poco más complejos. Por ejemplo, si componimos la primera función con

["big ", " and ", ""]

El resultado es

["I went to the big ", " and ", " store and bought big ", "and", " today."]

Tarea

Su tarea es tomar dos funciones como se describen como listas de cadenas no vacías y generar su composición como una lista de cadenas no vacía.

Para el propósito de este desafío, una lista puede ser cualquier contenedor ordenado que permita duplicados y una cadena puede ser un tipo de cadena nativa, una lista de caracteres o una lista de enteros.

Este es el respuestas de se puntuará en bytes, con menos bytes mejor.

Casos de prueba

["","xy"] ["ab",""] -> ["ab","xy"]
["x","y","z"] ["a","b"] -> ["xa","bya","bz"]
["xy"] ["ab"] -> ["xy"]
["","",""] ["a",""] -> ["a","a",""]
["x",""] ["","",""] -> ["x","",""]
["x","y","z"] ["a","b","c"] -> ["xa","b","cya","b","cz"]
["x","x","x"] ["a"] -> ["xaxax"]
["w","x","y","z"] ["ab","cd","e"] -> ["wab","cd","exab","cd","eyab","cd","ez"]
Asistente de trigo
fuente
1
Las 3 respuestas existentes actualmente fallan si se usa algún carácter ASCII no imprimible en la entrada (SOH, TAB o LF, dependiendo de la respuesta). Así que creo que realmente debería decidir si la entrada está restringida a ASCII imprimible o no.
Arnauld
@Arnauld Ok, bueno, a partir de ahora no tiene restricciones y no he visto una razón para cambiar eso, por lo que permanecerá.
Wheat Wizard
2
@KevinCruijssen la mía es válida ya que cero no es un personaje. Función de lenguaje afortunado que ayuda.
Jonathan Allan
1
@ SriotchilismO'Zaic Mi 05AB1E se estaba uniendo / dividiendo por nuevas líneas. Las respuestas de JavaScript y Haskell se unen / dividen por pestañas, la respuesta de C # por el carácter no imprimible `` (SOH), por lo que también son inválidos. Sin embargo, tampoco conozco a Perl 5 lo suficientemente bien. Para que uno sea válido.
Kevin Cruijssen
3
@Roman No puede suponer que ningún carácter aparecerá en la entrada para poder usarlo como separador. En realidad debes resolver el desafío.
Wheat Wizard

Respuestas:

11

Jalea , 6 bytes

j0j@ṣ0

Un enlace diádico que acepta la representación de la primera función a la derecha y la representación de la segunda función a la izquierda que produce la representación de la función resultante. Cada representación de función es una lista de listas de caracteres (Jelly no tiene otras cadenas).

Pruébalo en línea! (los argumentos del programa completo se dan en notación de Python; las cadenas se convierten en listas. El pie de página muestra una representación de Python de la salida del enlace).

Aquí hay un conjunto de pruebas que reformatea la salida del enlace como las entradas.

¿Cómo?

Aprovecha las listas de tipos mixtos de Jelly para permitir todo el dominio de representaciones (cualquier lista de listas de caracteres) utilizando el entero cero como marcador de posición:

j0j@ṣ0 - Link: b, a        e.g.    b = [['a','b'],['c','d'],['e']]
       -                   ...and  a = [['w'],['x'],['y'],['z']]
                             (i.e. test-case ["w","x","y","z"] ["ab","cd","e"])
j0     - join b with zeros         ['a','b',0,'c','d',0,'e']    
  j@   - join a with that          ['w','a','b',0,'c','d',0,'e','x','a','b',0,'c','d',0,'e','y','a','b',0,'c','d',0,'e','z']
    ṣ0 - split at zeros            [['w','a','b'],['c','d'],['e','x','a','b'],['c','d'],['e','y','a','b'],['c','d'],['e','z']
                             (i.e.: ["wab","cd","exab","cd","eyab","cd","ez"])

Si necesitáramos lidiar con cualquiera de las listas mixtas de Jelly (incluidas las de cualquier profundidad o forma) podríamos usar este byte de ocho: j,©⁹jœṣ®que usa los argumentos emparejados como el marcador de posición.

Jonathan Allan
fuente
5

Python 3.8 (prelanzamiento) ,  60  58 bytes

lambda a,b:(v:='&'.join(a+b)+'$').join(b).join(a).split(v)

Una función sin nombre que acepta dos listas de cadenas ay bque devuelve una lista de cadenas.

Pruébalo en línea! O vea el conjunto de pruebas .

¿Cómo?

Primero forma una cadena de separación v, que no se puede encontrar dentro ao b. Luego forma una cadena uniendo las cadenas bcon copias de v. Luego forma una cadena uniendo las cadenas acon copias de eso. Finalmente divide esa cadena en instancias de vpara dar una lista de cadenas.

Garantizando al mismo tiempo vno está en ao btambién hay que asegurarse de que vno hará que nos separamos temprano en el caso en que todas las cuerdas en ay bson iguales. Para hacerlo, formamos vuniendo todas las cadenas en ambas listas con instancias de una cadena (aquí '&') y agregamos un carácter adicional diferente (aquí '$'). Tenga en cuenta que hacer cualquiera de ellas de forma aislada no es suficiente ya que todas las cadenas en las entradas podrían ser iguales al carácter elegido.

Jonathan Allan
fuente
¿Podría dar una entrada de ejemplo donde &se requiere? y usar ''.join(a+b)+'$'no es suficiente?
Wheat Wizard
Me tomó un tiempo pero ['$','$'] ['$','$']sería uno.
Wheat Wizard
Sí, si todas las cadenas son iguales al '$'carácter elegido y el resultado será más de una cadena, necesitamos un carácter diferente para evitar la división temprana.
Jonathan Allan
2

05AB1E , 4 15 19 9 11 bytes

«TýR©ý¹sý®¡

A diferencia de la respuesta de Jelly, la cadena "0", el entero 0y el flotador de 05AB1E 0.0son todos (algo) iguales, por lo que no puedo dividir / unir por un entero. Esta es la razón por la que teníamos los +15 bytes como soluciones alternativas, aunque ahora lo he devuelto a 9 bytes. Gracias a @JonathanAllan por encontrar 2 errores.

Pruébelo en línea o verifique todos los casos de prueba .

Explicación:

«            # Merge the two (implicit) input-lists together
 Tý          # Then using a "10" delimiter join all strings together
   R         # Reverse this string
    ©        # Store this string in variable `®` (without popping)
     ý       # Use this string as delimiter to join the second (implicit) input-list
      ¹sý    # Then join the first input-list by this entire string
         ®¡  # And split it back on variable `®` so it's the expected list of strings
             # (after which this result is output implicitly)
Kevin Cruijssen
fuente
2
Esto falla si la entrada tiene nuevas líneas (OP ha dicho que la entrada no está restringida actualmente).
Erik el Outgolfer
@EriktheOutgolfer Todas las demás respuestas tienen el mismo problema por cierto.
Kevin Cruijssen
@EriktheOutgolfer Definitivamente se puede jugar un poco más, pero por ahora se solucionó de forma rápida y sucia.
Kevin Cruijssen
1
Uh, perdón por esto ... no funcionará si las listas de entrada contienen cadenas que solo contienen nuevas líneas :( (se dividirá temprano)
Jonathan Allan
1
@JonathanAllan Lol ... Ah, bueno, supongo que solo puedo agradecerte por encontrar estos errores ... Espero que esté solucionado ahora y no encuentres nada más ... Aunque tengo la sensación de que podrías ...
Kevin Cruijssen
2

Japt , 8 bytes

Adapta el enfoque de Jonathan .

qVqN²)qN

Intentalo

qVqN²)qN     :Implicit input of arrays U & V (N=[U,V])
q            :Join U with
 Vq          :  V joined with
   N²        :    Push 2 to N (modifying the original), which gets coerced to a string
             >     e.g., N=[["a","b"],["c","d"]] -> N=[["a","b"],["c","d"],2] -> "a,b,c,d,2"
     )       :End join
      qN     :Split on the modified N, which, again, gets coerced to a string
             > e.g., N=[["a","b"],["c","d"],2] -> "a,b,c,d,2"
Lanudo
fuente
¿Qué hay Nen este caso? Si lo entiendo correctamente (usando la funcionalidad de búsqueda del enlace TryIt), se repite Ndos veces ( ). Luego usa eso para unir la segunda entrada V( VqN²), y luego usa toda la cadena para unir la primera entrada U( implícita) ( q...)). Y finalmente divide la cadena resultante en N( qN). ¿Pero qué hay Nen este caso?
Kevin Cruijssen
Ah, espera, creo que he buscado el p(...)método incorrecto en la búsqueda. Añade las 2dos entradas emparejadas juntas, ¿no? Solo da como resultado [["w","x","y","z"],["ab","cd","e"],2], y utiliza toda esa lista para unirse. ¿Por qué la final qNno deja la 2lista de resultados en ese caso? ¿O modifica el original N?
Kevin Cruijssen
1
@KevinCruijssen, agregó una explicación, pero ya la tienes resuelta. Y sí, la pushincorporación de elementos a una matriz en JS modifica la matriz original.
Shaggy
1

Haskell , 62 bytes

[a]#(c:d)=(a++c):d
(a:b)#c=a:b#c
[a]%b=[a]
(a:b)%c=[a]#c#(b%c)

Pruébalo en línea!

Aquí está mi respuesta de Haskell. Funciona en cualquier tipo de lista.

Asistente de trigo
fuente
1

J , 44 43 42 29 bytes

_<;._1@,(;@}:@,@,.(,_&,)&.>/)

Pruébalo en línea!

-13 bytes gracias a millas!

Este enfoque utiliza números enteros y se debe a millas.

enfoque original con cuerdas

g=.[:}.@,,.
f=.(<@0<@;;._1@,];@g<"0@[)<@0<@g]

Pruébalo en línea!

Nota: He ajustado -3 fuera del TIO para tener en cuenta f=.

Utiliza el método de Jonathan Allen, adaptado para J.

Esto fue sorprendentemente difícil de jugar al golf, ya que J no tiene un método incorporado de "unión", y me gustaría ver si se puede mejorar significativamente.

g es un verbo auxiliar que nos da "unirse"

Jonás
fuente
Al trabajar con la lista de enteros como entrada, encontré una solución de 29 caracteres , _<;._1@,(;@}:@,@,.(,_&,)&.>/)usa infinito _como valor centinela para saber dónde dividir <;._1. La unión se realiza primero utilizando reducir /para formar un cuadro grande, luego solo se configura el arreglo.
millas
Eso es impresionante. Gracias @miles. Este definitivamente sentía que había espacio para mejorar, pero no veía cómo.
Jonás
@miles ¿No debería g&.:(a.&i.&.>)contar para los bytes o me falta algo?
Jonás
El PO mencionó que de entrada podría ser como una lista de caracteres o como una lista de números enteros, por lo que la función de ayuda es simplemente convertir de cajas de arrays de char a las cajas de matrices int para facilitar la visualización
millas
Ah, lo olvidé, gracias
Jonás,
0

Perl 5 ( -lp), 20 bytes

Como comentó @JonathanAllan, este es un programa completo que utiliza, para IO, una pestaña como separador de listas y una nueva línea para separar las dos listas.

chop($n=<>);s/  /$n/g

TIO

la pestaña y la nueva línea se eligieron porque es más conveniente verificar los casos de prueba; de lo contrario, podrían cambiarse a caracteres no imprimibles \1y \2.

( -02l012p)

chop($n=<>);s//$n/g

TIO

Cómo funciona,

  • -02 : para establecer el separador de registro de entrada en \2
  • -l: para eliminar el separador de entrada del argumento predeterminado $_y agregar el separador de registro de salida a la salida predeterminada
  • -012: para establecer el separador de registro de salida en \012( \n) para que la salida sea más fácil de verificar
  • -p : para imprimir el argumento predeterminado

  • $n=<>; : para leer el siguiente registro y asignar a $n

  • chop$n; : para eliminar el separador de $n
  • s/\x1/$n/g: para reemplazar todas las ocurrencias de \1con$n
Nahuel Fouilleul
fuente
2
Mi Perl es casi inexistente, pero creo que este es un programa completo que utiliza, para IO, una pestaña como separador de listas y una nueva línea para separar las dos listas. ¿Cómo puede aceptar entradas con estos caracteres?
Jonathan Allan
@JonathanAllan, tienes razón, no tuve tiempo de agregar una explicación al enviar, intentaré hacerlo
Nahuel Fouilleul
0

JavaScript (ES6),  62  59 bytes

Guardado 3 bytes gracias a @Shaggy

Esta es una versión fija de la respuesta de Luis (ahora eliminada) para admitir todos los caracteres.

a=>b=>a.map(e=escape).join(b.map(e)).split`,`.map(unescape)

Pruébalo en línea!

Arnauld
fuente