Sfida

Scrivi un programma che applica una funzione iniettiva che accetta una coppia ordinata di stringhe come input e una stringa come output. In altre parole, ogni input deve essere mappato su un output univoco.

specifiche

• L'input può essere qualsiasi due stringhe di lunghezza arbitraria, ma sarà composto solo da caratteri ASCII stampabili (codici $[32, 126]$ ).
• Allo stesso modo, la stringa di output non ha limiti di lunghezza, ma deve contenere solo caratteri ASCII stampabili.
• Se la tua lingua non è in grado di gestire stringhe di lunghezza arbitraria, il programma potrebbe semplicemente funzionare teoricamente per stringhe di qualsiasi dimensione.
• La mappatura da input a output dovrebbe essere coerente tra le esecuzioni del programma. Altrimenti, la mappatura che usi dipende completamente da te, purché si tratti di un'iniezione.
• L'ingresso è ordinato. Se le due stringhe di input sono diverse, dovrebbero produrre un output diverso rispetto a se fossero state scambiate. $s \neq t \implies f(s, t) \neq f(t, s)$
• Non tutte le stringhe devono essere un possibile output.
• Vince la risposta più breve in ogni lingua!

Casi test

I seguenti ingressi dovrebbero comportare tutti output diversi. Per evitare confusione, le stringhe sono circondate da guillemets («») e separate da spazi singoli.

"Ciao mondo"
«Lelho» «drowl»
"diverso"
"non lo stesso"

«Codice» «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 byte

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

Provalo online!

Gli ingressi sono separati da un 0x01byte.

Questo si trasforma ["foo", "bar"]in fUToUToUTUTbUTaUTrUT. Per recuperare le due stringhe originali, prendi gruppi di 3 caratteri, trova quello in cui la seconda lettera non è Ue dividi lì.

JavaScript (ES6), 14 byte

Accetta l'input come una matrice di 2 stringhe. Ispirato dalla risposta di Luis .

JSON.stringify

Provalo online!

JavaScript (ES6),  21  20 byte

Accetta input come (a)(b).

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

Provalo online!

Restituisce la lunghezza di $a$ , seguito da una virgola, seguita dalla concatenazione di $a$ e $b$ .

jq -c, 0 byte

Provalo online!

Questo sicuramente sembra barare ...? Ma sembra rispettare le regole della sfida.

Per impostazione predefinita, jqprodurrà il suo input in un formato JSON leggibile dall'uomo. Il -cflag (compatto) indica jql'output in stile "compatto", che rimuove le nuove righe (poiché la sfida proibisce ASCII non stampabile).

Python 3 , 3 byte

str

Una funzione (incorporata) che, dato un elenco delle due stringhe, fornisce una rappresentazione in formato stringa dell'elenco

Provalo online!

Japt -S , 3 byte

Io ancora sento Devo mancare qualcosa qui ...

®mc

Provalo

Forse 2 byte:

mq

Provalo

O allungandolo con questo 1 byte:

U

Provalo

La prima versione associa ogni stringa dell'array ai suoi punti di codice e li emette uniti con uno spazio.

La seconda versione divide ogni stringa in un array di caratteri e li emette uniti con uno spazio.

E la terza versione, che sembra imbroglione, emette semplicemente l'ingresso con la -Qbandiera che fa il pesante sollevamento di srringifyesso.

Pyth , 4 byte

jNmC

Provalo online!

Ciò converte ciascuna stringa in base 256 e quindi le unisce in ordine con a ". Poiché i risultati sono ogni numero, "li separa in modo univoco e le stringhe originali possono essere recuperate con mCsdczN.

T-SQL, 38 bytes

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

Input is taken from a pre-existing table $i$ with varchar fields $a$ and $b$, per our IO rules.

Uses QUOTENAME, which surrounds the strings with [] and also escapes any internal brackets. Should map to a unique output.

Zsh, 7 bytes

<<<$@:q

Try it online!

Implicitly joins the arguments on spaces. The q modifier tells zsh to quote the arguments, which crucially escapes spaces, ensuring an unescaped space unambiguously separates the two arguments.

(Without q, "a " "b" and "a" " b" would both yield "a b".)

MATL, 1 byte

j

The code takes an array of two strings as input, and outputs a string representation of that array.

Try it online!

Explanation

The code simply reads the input as a string, unevaluated.

Jelly, 2 bytes

ŒṘ

A monadic Link accepting a list of two lists of characters as its argument which yields a single list of characters.

Try it online!

How?

It's a built-in to get Python's string representation, simples.

Haskell, 4 bytes

show

The Haskell built-in to turn things into strings. The input is taken as a pair of strings.

Try it online!

05AB1E, 2 bytes

₁ö

Try it online! Interprets each string as a base-256 integer, then prints the two in the form [1, 2].

05AB1E, 1 byte (unknown validity)

â

Try it online!

Takes the cartesian product of the input with itself. Quotes in the input are not escaped, which could cause confusion. I brute-forced all combinations of up to 12 ", " and "], [" and didn’t find any collision; however, I can’t prove there aren’t any collisions for longer strings. If anybody can come up with a proof or counter-example, I’d highly appreciate it!

The trivial 0-byter fails because of quotes not being escaped: inputs (", ", empty string) and (empty string, ", ") both yield the output ["", "", ""].

The 1-byter º (mirror each input string) also fails because of this: inputs (", "" ,", empty string) and (empty string, " ,"", ") both yield the output ["", "" ,"", "" ,"", ""].

C# with 26 bytes (thanks to Lukas Lang, Kevin Cruijssen and Jo King)

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

tio.run lambda

Charcoal, 12 bytes

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

Try it online! Link is to verbose version of code. Explanation:

 Ｅ²             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

^{Many fixes thanks to mazzy}

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

Try it online!

Take five, oh my.

R, 4 bytes

dput

Try it online!

A built-in function which returns the string representation of the input (inspired by Jonathan Allan's answer )

Wolfram Language (Mathematica), 8 bytes

Compress

Try it online!

CSS + HTML, 55 + 20 = 75 bytes

Provide the inputs in the HTML after <code> tags. Visually injects letters one by one from each input into the output. When an input is longer than the other one, visual spaces are shown for missing letter(s) of the shorter input. Also one comma is added in HTML to force visual output uniqueness (I hope).

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

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

C# (Visual C# Interactive Compiler), 5 bytes

Print

Try it online!

Perl 6, 6 3 bytes

&dd

Try it online!

Outputs the object representation to STDERR.

Lua, 27 bytes

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

Try it online!

Full program, take input as arguments.

Inspired by zsh answer, as it also use %q modifier to use internal safe-string engine.

Also, I can think of just

('%q%q'):format

but I'm not sure if this is acceptable answer.

sed, 19 bytes

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

Try it online!

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

Try it online!

Input array of strings, output a single string.

Inspired by Arnauld's JSON.stringify answer.

C (gcc), 59 bytes

Thanks to Grimy for the suggestion.

Takes an array of input strings (of which "2" is the correct number for this challenge) and prints their character values, including the trailing NUL. Technically, the %p formatter used by printf is for pointers, but it works fine for displaying hex values of arbitrary integers if you're not picky about how they look!

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

Try it online!

Brachylog, 0 bytes

Input as an array of 2 strings, output in the format: Z = ["{{string 1 stringified}}","{{string 2 stringified}}"]

Inspired by Arnauld's JSON.stringify answer and Doorknob's empty jq answer

Try it online!

PHP, 9 bytes

serialize

Try it online!

Input is an array of 2 strings like this: ['abc', 'def']. Uses PHP's serialize to serialize the input into a string.

Bash, 11 bytes

echo ${@@Q}

Try it online!

${parameter@Q} quotes the parameter for reuse as input. In the case of an array, it quotes each element.

Ruby, 12 bytes

->*a{a.to_s}

Try it online!