Contexte

Python 3 possède de nombreux types de littéraux de chaîne. Par exemple, la chaîne this 'is' an exa\\m/plepeut être représentée comme:

'this \'is\' an exa\\\\m/ple'
"this 'is' an exa\\\\m/ple"
r"this 'is' an exa\\m/ple"
'''this 'is' an exa\\\\m/ple'''
"""this 'is' an exa\\\\m/ple"""
r'''this 'is' an exa\\m/ple'''
r"""this 'is' an exa\\m/ple"""

Comme vous pouvez le voir, l'utilisation de délimiteurs différents pour les chaînes peut allonger ou raccourcir les chaînes en modifiant l'échappement nécessaire pour certains caractères. Certains délimiteurs ne peuvent pas être utilisés pour toutes les chaînes: r'est manquant ci-dessus (voir plus loin pour des explications). Connaître vos cordes est très utile dans le golf de code.

On peut également combiner plusieurs littéraux de chaîne en un seul:

'this \'is\' an ''''exa\\\\m/ple'''
"this 'is' an "r'exa\\m/ple'

Défi

Le défi est, étant donné une chaîne ASCII imprimable, de produire sa représentation littérale la plus courte en Python.

Détails sur la mécanique des cordes

Les chaînes peuvent être définies à l' aide ', ", '''et """. Une chaîne se termine lorsque le délimiteur de départ est de nouveau frappé sans échappement.

Si un littéral de chaîne commence par '''ou """est consommé comme délimiteur. Sinon 'ou "est utilisé.

Les personnages peuvent être échappés en plaçant un \devant eux. Cela insère le caractère dans la chaîne et élimine toute signification particulière qu'il peut avoir. Par exemple, au 'a \' b'milieu 'est échappé et ne termine donc pas le littéral, et la chaîne résultante est a ' b.

Facultativement, un rou Rpeut être inséré avant le délimiteur de départ. Si cela est fait, l'échappement \apparaîtra dans le résultat. Par exemple, r'a \' b'évalue à a \' b. C'est pourquoi a ' bne peut pas être délimité par r'.

Pour s'échapper '''ou """, il suffit d'échapper à l'un des personnages.

Ces littéraux peuvent être concaténés ensemble, ce qui concatène leur contenu.

Règles

• L'entrée est la chaîne de golf. ASCII imprimable uniquement, donc pas de sauts de ligne ni d'autres caractères spéciaux.
• La sortie est le littéral de la chaîne jouée. S'il existe plusieurs solutions, sortez-en une.
• Pour simplifier le défi, en non - rcordes tout échappe à l' exception \\, \'et \"sont considérés comme invalides. Ils ne doivent pas être utilisés dans la sortie, même s'ils '\m'sont égaux à '\\m'Python. Cela supprime la nécessité de traiter des codes d'échappement spéciaux tels que \n.
• Les fonctions intégrées pour jouer au golf avec des cordes Python sont interdites. Python represt autorisé, car il est de toute façon merdique.
• Les règles de code-golf standard s'appliquent.

Exemples d'entrées / sorties

J'ai fait de mon mieux pour les vérifier, mais faites-moi savoir s'il y a des erreurs. S'il existe plusieurs sorties valides pour les cas, elles sont toutes répertoriées sous l'entrée.

test
 -> 'test'
 -> "test"
te\st
 -> 'te\\st'
 -> "te\\st"
 -> r'te\st'
 -> r"te\st"
te'st
 -> "te'st"
te"st
 -> 'te"st'
t"e"s't
 -> 't"e"s\'t'
te\'st
 -> "te\\'st"
 -> r'te\'st'
 -> r"te\'st"
te\'\"st
 -> r'te\'\"st'
 -> r"te\'\"st"
t"'e"'s"'t"'s"'t"'r"'i"'n"'g
 -> """t"'e"'s"'t"'s"'t"'r"'i"'n"'g"""
 -> '''t"'e"'s"'t"'s"'t"'r"'i"'n"'g'''
t"\e"\s"\t"\s'\t"\r"\i"\n"\g
 -> r"""t"\e"\s"\t"\s'\t"\r"\i"\n"\g"""
 -> r'''t"\e"\s"\t"\s'\t"\r"\i"\n"\g'''
t"""e"""s"""'''t'''s'''"""t"""r"""'''i'''n'''g
 -> 't"""e"""s"""'"'''t'''s'''"'"""t"""r"""'"'''i'''n'''g"
t\"""e\"""s\"""'''t'''s'''\"""t\"""r\"""'''i'''n'''g
 -> r"""t\"""e\"""s\"""'''t'''s'''\"""t\"""r\"""'''i'''n'''g"""
t"e"s"t"s"t"r"i"n"g"\'\'\'\'\'\'\'\
 -> r't"e"s"t"s"t"r"i"n"g"\'\'\'\'\'\'\'''\\'
 -> r't"e"s"t"s"t"r"i"n"g"\'\'\'\'\'\'\''"\\"
"""t"'e"'s"'t"'s"'t"'r"'i"'n"'g'''
 -> """\"""t"'e"'s"'t"'s"'t"'r"'i"'n"'g'''"""
 -> '''"""t"'e"'s"'t"'s"'t"'r"'i"'n"'g''\''''

Merci à Anders Kaseorg pour ces cas supplémentaires:

\\'"\\'\
 -> "\\\\'\"\\\\'\\"
''"""''"""''
 -> '''''"""''"""'\''''

Python 3 , 264 262 octets

f=lambda s,b='\\',r=str.replace:min(sum([['r'+d+s+d,d+r(r(s[:-1],b,b+b),d,d[1:]+b+d[0])+b*(s[-1:]in[b,d[0]])+s[-1:]+d][d in r(r(s+d[1:],b+b,'x'),b+d[0],b)or r(s,b+b,'')[-1:]==b:]for d in["'",'"',"'''",'"""']],[f(s[:k])+f(s[k:])for k in range(1,len(s))]),key=len)

Essayez-le en ligne!

Cela fonctionne mais est très lent sans mémorisation, que vous pouvez ajouter avec

import functools
f=functools.lru_cache(None)(f)

Il a trouvé une solution améliorée pour l'un des cas de test:

t"e"s"t"s"t"r"i"n"g"\'\'\'\'\'\'\'\
 -> 't"e"s"t"s"t"r"i"n"g"'r"\'\'\'\'\'\'\'"'\\'
 -> r't"e"s"t"s"t"r"i"n"g"\'\'\'\'\'\'\'''\\'

Les versions précédentes de cette réponse ont renvoyé des résultats incorrects sur les éléments suivants, qui pourraient être ajoutés en tant que cas de test:

\\'"\\'\
 -> "\\\\'\"\\\\'\\"
''"""''"""''
 -> '''''"""''"""'\''''