Desafío

Escriba un programa que aplique una función inyectiva que tome un par ordenado de cadenas como entrada y una cadena como salida. En otras palabras, cada entrada debe correlacionarse con una salida única.

Detalles específicos

• La entrada puede ser cualquiera de las dos cadenas de longitud arbitraria, pero consistirá solo en caracteres ASCII imprimibles (códigos $[32, 126]$ ).
• Del mismo modo, la cadena de salida no tiene restricción de longitud, pero debe consistir solo en caracteres ASCII imprimibles.
• Si su idioma no puede manejar cadenas de longitud arbitraria, el programa simplemente puede funcionar teóricamente para cadenas de cualquier tamaño.
• La asignación de entradas a salidas debe ser coherente entre las ejecuciones del programa. De lo contrario, el mapeo que use depende completamente de usted, siempre que sea una inyección.
• La entrada está ordenada. Si las dos cadenas de entrada son diferentes, deberían producir una salida diferente que si se intercambiaran. $s \neq t \implies f(s, t) \neq f(t, s)$
• No todas las cadenas deben ser una salida posible.
• ¡La respuesta más corta en cada idioma gana!

Casos de prueba

Las siguientes entradas deberían dar como resultado diferentes salidas. Para evitar confusiones, las cuerdas están rodeadas por guillemets («») y separadas por espacios individuales.

"Hola Mundo"
«Lelho» «drowl»
«Diffe» «_rent»
"no es el mísmo"

«Código» «Golf»
«Co» «deGolf»
«CodeGolf» «»

«» «»
«» «»
«» «»
«» «»
«» «»

"a B C D e F"
"a B C D e F"
"a B C D e F"
"a B C D e F"

«\» «" »
«\\» «\" »

brainfuck, 30 29 27 23 bytes

,[-[+.>]-[>+<---]>.-.,]

Pruébalo en línea!

Las entradas están separadas por un 0x01byte.

Esto se convierte ["foo", "bar"]en fUToUToUTUTbUTaUTrUT. Para recuperar las dos cadenas originales, tome grupos de 3 caracteres, encuentre el que no está en la segunda letra Uy divídalo allí.

JavaScript (ES6), 14 bytes

Toma la entrada como una matriz de 2 cadenas. Inspirado por la respuesta de Luis .

JSON.stringify

Pruébalo en línea!

JavaScript (ES6),  21  20 bytes

Toma entrada como (a)(b).

a=>b=>[a.length,a]+b

Pruébalo en línea!

Devuelve la longitud de $a$ , seguida de una coma, seguida de la concatenación de $a$ y $b$ .

jq -c, 0 bytes

Pruébalo en línea!

Esto definitivamente se siente como hacer trampa ...? Pero parece cumplir con las reglas del desafío.

De forma predeterminada, jqgenerará su entrada en un formato JSON legible para humanos. El -cindicador (compacto) le indica jqa la salida en estilo "compacto", que elimina las nuevas líneas (ya que el desafío prohíbe ASCII no imprimible).

Python 3 , 3 bytes

str

Una función (incorporada) que, dada una lista de las dos cadenas, proporciona una representación de cadena de la lista

Pruébalo en línea!

Japt -S , 3 bytes

Yo todavía siento que debo estar perdiendo algo aquí ...

®mc

Intentalo

Posiblemente 2 bytes:

mq

Intentalo

O estirándolo con este 1 byter:

U

Intentalo

La primera versión asigna cada cadena de la matriz a sus puntos de código y las muestra unidas con un espacio.

La segunda versión divide cada cadena en una matriz de caracteres y las muestra unidas con un espacio.

Y la tercera versión, que se siente como hacer trampa, solo genera la entrada con la -Qbandera haciendo el trabajo pesado srringify.

Pyth , 4 bytes

jNmC

Pruébalo en línea!

Esto convierte cada cadena en base 256 y luego las une en orden con a ". Como los resultados son números, los "separa inequívocamente y las cadenas originales se pueden recuperar con mCsdczN.

T-SQL, 38 bytes

SELECT QUOTENAME(a)+QUOTENAME(b)FROM i

La entrada se toma de una tabla preexistente $i$con varcharcampos$a$ y $b$, según nuestras reglas de IO .

Usos QUOTENAME, que rodea las cuerdas []y también escapa a los corchetes internos. Debe asignarse a una salida única.

Zsh , 7 bytes

<<<$@:q

Pruébalo en línea!

Se une implícitamente a los argumentos sobre espacios. El qmodificador le dice a zsh que cite los argumentos, lo que escapa de manera crucial a los espacios, asegurando que un espacio sin escape separe inequívocamente los dos argumentos.

(Sin q, "a " "b"y "a" " b"ambos cederían "a b").

MATL , 1 byte

j

El código toma una matriz de dos cadenas como entrada y genera una representación de cadena de esa matriz.

Pruébalo en línea!

Explicación

El código simplemente lee la entrada como una cadena, sin evaluar.

Jalea , 2 bytes

ŒṘ

Un enlace monádico que acepta una lista de dos listas de caracteres como argumento, lo que produce una sola lista de caracteres.

Pruébalo en línea!

¿Cómo?

Es una función integrada para obtener la representación de cadena de Python, simple.

Haskell, 4 bytes

show

El Haskell incorporado para convertir las cosas en cuerdas. La entrada se toma como un par de cadenas.

Pruébalo en línea!

05AB1E , 2 bytes

₁ö

Pruébalo en línea! Interpreta cada cadena como un entero de base 256, luego imprime las dos en el formulario [1, 2].

05AB1E, 1 byte (validez desconocida)

â

Pruébalo en línea!

Toma el producto cartesiano de la entrada consigo mismo. Las citas en la entrada no se escapan, lo que podría causar confusión. Forcé brutalmente todas las combinaciones de hasta 12 ", "y"], [" no encontré ninguna colisión; Sin embargo, no puedo demostrar que no haya colisiones para cadenas más largas. Si alguien puede presentar una prueba o un contraejemplo, ¡lo agradecería mucho!

El trivial 0-byter falla debido a que no se escapan las comillas: las entradas ( ", ", cadena vacía) y (cadena vacía, ", ") producen la salida ["", "", ""].

El 1 byter º(espejo de cada cadena de entrada) también falla debido a esto: las entradas ( ", "" ,", cadena vacía) y (cadena vacía, " ,"", ") producen la salida ["", "" ,"", "" ,"", ""].

C # con 26 bytes (gracias a Lukas Lang, Kevin Cruijssen y Jo King)

a=>b=>$"{a.Length}.{a}{b}"

tio.run lambda

Carbón de leña , 12 bytes

⪫Ｅ²⭆⪪Ｓ"⪫""λ,

Pruébalo en línea! El enlace es a la versión detallada del código. Explicación:

 Ｅ²             Repeat twice
     Ｓ          Input a string
    ⪪ "         Split it on `"`s
   ⭆            Map over each piece and join
       ⪫""λ     Wrap each piece in `"`s
⪫          ,    Join the two results with a `,`
                Implicitly print

PowerShell , 22 bytes

^{Muchas correcciones gracias a mazzy}

"$($args|% le*)"+$args

Pruébalo en línea!

Toma cinco, oh mi.

R , 4 bytes

dput

Pruébalo en línea!

Una función incorporada que devuelve la representación de cadena de la entrada (inspirada en la respuesta de Jonathan Allan )

Wolfram Language (Mathematica) , 8 bytes

Compress

Pruébalo en línea!

CSS + HTML, 55 + 20 = 75 bytes

Proporcione las entradas en el HTML después de las <code>etiquetas. Inyecta visualmente letras una por una de cada entrada en la salida. Cuando una entrada es más larga que la otra, se muestran espacios visuales para las letras faltantes de la entrada más corta. También se agrega una coma en HTML para forzar la unicidad de la salida visual (espero).

*{position:absolute;letter-spacing:9px}code>code{left:9px

<code>abcdefg<code>hijklmn</code>,

C # (compilador interactivo de Visual C #) , 5 bytes

Print

Pruébalo en línea!

Perl 6 , 6 3 bytes

&dd

Pruébalo en línea!

Emite la representación del objeto a STDERR.

Lua , 27 bytes

print(('%q%q'):format(...))

Pruébalo en línea!

Programa completo, tome la entrada como argumentos.

Inspirado por la respuesta zsh, ya que también usa un %qmodificador para usar el motor interno de cadena segura.

Además, puedo pensar en

('%q%q'):format

pero no estoy seguro si esta es una respuesta aceptable.

sed , 19 bytes

N
s/ /. /g
s/\n/: /

Pruébalo en línea!

N          # append the second string into the pattern space
s/ /. /g   # prefix all spaces with ".". Now ": " will not occur in the stiring
s/\n/: /   # replace the newline with ": "

JavaScript (SpiderMonkey) , 6 bytes

uneval

Pruébalo en línea!

Entrada de matriz de cadenas, salida de una sola cadena.

Inspirado por la respuesta JSON.stringify de Arnauld .

C (gcc) , 59 bytes

Gracias a Grimy por la sugerencia.

Toma una matriz de cadenas de entrada (de las cuales "2" es el número correcto para este desafío) e imprime sus valores de caracteres, incluido el final NUL. Técnicamente, el %pformateador utilizado printfes para punteros, ¡pero funciona bien para mostrar valores hexadecimales de enteros arbitrarios si no eres exigente sobre cómo se ven!

f(s,t)char**s,*t;{for(;t=*s++;)for(;printf("%p",*t++)^5;);}

Pruébalo en línea!

Brachylog , 0 bytes

Entrada como un conjunto de 2 cadenas, salida en el formato: Z = ["{{string 1 stringified}}","{{string 2 stringified}}"]

Inspirado por la respuesta JSON.stringify de Arnauld y la respuesta jq vacía de Doorknob

Pruébalo en línea!

PHP , 9 bytes

serialize

Pruébalo en línea!

De entrada es una matriz de 2 cadenas, como este: ['abc', 'def']. Utiliza la serialización de PHP para serializar la entrada en una cadena.

Bash , 11 bytes

echo ${@@Q}

Pruébalo en línea!

${parameter@Q}cita el parámetro para su reutilización como entrada. En el caso de una matriz, cita cada elemento.

Rubí , 12 bytes.

->*a{a.to_s}

Pruébalo en línea!