Défi

Écrivez un programme qui applique une fonction injective qui prend une paire ordonnée de chaînes en entrée et une chaîne en sortie. En d'autres termes, chaque entrée doit correspondre à une sortie unique.

Détails

• L'entrée peut être tout deux chaînes de longueur arbitraire, mais se compose uniquement de caractères ASCII imprimables (codes $[32, 126]$ ).
• De même, la chaîne de sortie n'a pas de restriction de longueur, mais elle doit être constituée uniquement de caractères ASCII imprimables.
• Si votre langue ne peut pas gérer des chaînes de longueur arbitraire, le programme peut simplement fonctionner théoriquement pour des chaînes de n'importe quelle taille.
• Le mappage des entrées aux sorties doit être cohérent entre les exécutions du programme. Sinon, le mappage que vous utilisez dépend entièrement de vous, tant qu'il s'agit d'une injection.
• L'entrée est ordonnée. Si les deux chaînes d'entrée sont différentes, elles doivent produire une sortie différente que si elles étaient échangées. $s \neq t \implies f(s, t) \neq f(t, s)$
• Toutes les chaînes n'ont pas besoin d'être une sortie possible.
• La réponse la plus courte dans chaque langue gagne!

Cas de test

Les entrées suivantes devraient toutes entraîner des sorties différentes. Pour éviter toute confusion, les chaînes sont entourées de guillemets («») et séparées par des espaces simples.

"Bonjour le monde"
«Lelho» «drowl»
"différent"
"pas le même"

«Code» «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 octets

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

Essayez-le en ligne!

Les entrées sont séparées par un 0x01octet.

Cela ["foo", "bar"]s'en fUToUToUTUTbUTaUTrUT. Pour récupérer les deux chaînes originales, prenez des groupes de 3 caractères, trouvez celui où ne se trouve pas la deuxième lettre Uet divisez-le.

JavaScript (ES6), 14 octets

Prend l'entrée comme un tableau de 2 chaînes. Inspiré par la réponse de Luis .

JSON.stringify

Essayez-le en ligne!

JavaScript (ES6),  21  20 octets

Prend l'entrée comme (a)(b).

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

Essayez-le en ligne!

Renvoie la longueur de $a$ , suivie d'une virgule, suivie de la concaténation de $a$ et $b$ .

jq -c, 0 octet

Essayez-le en ligne!

Cela ressemble vraiment à de la triche ...? Mais il semble respecter les règles du challenge.

Par défaut, jqaffichera son entrée dans un format JSON lisible par l'homme. L' -cindicateur (compact) indique jqde sortir dans un style "compact", ce qui supprime les nouvelles lignes (car le défi interdit les ASCII non imprimables).

Python 3 , 3 octets

str

Une fonction (intégrée) qui, étant donné une liste des deux chaînes, donne une représentation sous forme de chaîne de la liste

Essayez-le en ligne!

Japt -S , 3 octets

Je sens toujours que je dois manquer quelque chose ici ...

®mc

Essayez-le

Peut-être 2 octets:

mq

Essayez-le

Ou l'étirer avec cet octet:

U

Essayez-le

La première version mappe chaque chaîne du tableau à ses points de code et les renvoie joints à un espace.

La deuxième version divise chaque chaîne en un tableau de caractères et les renvoie jointes à un espace.

Et la troisième version, qui ressemble à de la triche, sort juste l'entrée avec le -Qdrapeau faisant le gros du travail srringify.

Pyth , 4 octets

jNmC

Essayez-le en ligne!

Cela convertit chaque chaîne en base 256, puis les joint dans l'ordre avec a ". Étant donné que les résultats sont chacun des nombres, les "sépare sans ambiguïté et les chaînes d'origine peuvent être récupérées avec mCsdczN.

T-SQL, 38 octets

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

L'entrée provient d'une table préexistante $i$avec varcharchamps$a$ et $b$, selon nos règles IO .

Utilise QUOTENAME, qui entoure les cordes []et échappe également aux supports internes. Devrait correspondre à une sortie unique.

Zsh , 7 octets

<<<$@:q

Essayez-le en ligne!

Joint implicitement les arguments sur les espaces. leq modificateur indique à zsh de citer les arguments, ce qui échappe de manière cruciale aux espaces, garantissant qu'un espace non échappé sépare sans ambiguïté les deux arguments.

(Sans q, "a " "b"et "a" " b"céderait tous les deux "a b".)

MATL , 1 octet

j

Le code prend en entrée un tableau de deux chaînes et génère une représentation sous forme de chaîne de ce tableau.

Essayez-le en ligne!

Explication

Le code lit simplement l'entrée comme une chaîne, non évaluée.

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!