Contexte
Python 3 possède de nombreux types de littéraux de chaîne. Par exemple, la chaîne this 'is' an exa\\m/ple
peut ê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 r
ou R
peut ê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 ' b
ne 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 -
r
cordes 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
repr
est 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:
\\'"\\'\
-> "\\\\'\"\\\\'\\"
''"""''"""''
-> '''''"""''"""'\''''
u'
et b'
?
b
ne peuvent même pas être combinés avec des cordes régulières, donc je les ai juste laissées de côté.
"
ou'
->"""t"'e"'s"'t"'s"'t"'r"'i"'n"'g'''