Hintergrund

In Python 3 gibt es viele Arten von String-Literalen. Beispielsweise kann die Zeichenfolge this 'is' an exa\\m/pledargestellt werden als:

'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"""

Wie Sie sehen, können Sie durch die Verwendung verschiedener Trennzeichen für Zeichenfolgen Zeichenfolgen verlängern oder verkürzen, indem Sie die für bestimmte Zeichen erforderliche Maskierung ändern. Einige Trennzeichen können nicht für alle Zeichenfolgen verwendet werden: r'fehlt oben (Erklärung siehe später). Das Kennen Ihrer Saiten ist beim Codegolf sehr nützlich.

Man kann auch mehrere String-Literale zu einem kombinieren:

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

Herausforderung

Bei einer druckbaren ASCII-Zeichenfolge besteht die Herausforderung darin, die kürzeste Literaldarstellung in Python auszugeben .

Details zur Saitenmechanik

Strings kann unter Verwendung begrenzt ', ", '''und """. Ein String endet, wenn der Startbegrenzer erneut ohne Flucht getroffen wird.

Wenn ein Zeichenfolgenliteral mit beginnt '''oder """als Begrenzer verwendet wird. Ansonsten wird 'oder "verwendet.

Zeichen können durch Setzen eines \vor ihnen ausgeblendet werden. Dies fügt das Zeichen in die Zeichenkette ein und beseitigt jegliche spezielle Bedeutung. Beispielsweise wird in 'a \' b'der Mitte 'ein Escapezeichen eingefügt, wodurch das Literal nicht beendet wird, und die resultierende Zeichenfolge ist a ' b.

Optional kann vor dem Startbegrenzer eines von roder Reingefügt werden. In diesem Fall \wird das Escapezeichen im Ergebnis angezeigt. Wertet zum Beispiel r'a \' b'zu aus a \' b. Deshalb a ' bkann nicht durch eingegrenzt werden r'.

Um zu entkommen '''oder """, muss man nur eines der Zeichen entkommen.

Diese Literale können zusammen verkettet werden, wodurch ihr Inhalt verkettet wird.

Regeln

• Der Input ist die Saite zum Golfen. Nur druckbares ASCII, also keine Zeilenumbrüche oder sonstigen Sonderzeichen.
• Die Ausgabe ist das Golf-String-Literal. Wenn es mehrere Lösungen gibt, geben Sie eine aus.
• Um die Herausforderung, in nicht zu vereinfachen rStrings alle Fluchten Ausnahme \\, \'und \"gelten als ungültig. Sie dürfen nicht in der Ausgabe verwendet werden, auch wenn sie '\m'mit '\\m'Python identisch sind. Dadurch entfällt die Notwendigkeit, spezielle Escape-Codes wie z \n.
• Builtins zum Golfen von Python-Saiten sind nicht erlaubt. Pythons reprist erlaubt, da es sowieso beschissen ist.
• Es gelten die Standardregeln für Code-Golf .

Beispiel Ein- / Ausgänge

Ich habe mein Bestes gegeben, um dies zu überprüfen, aber ich möchte wissen, ob Fehler vorliegen. Wenn es zu den Fällen mehrere gültige Ausgaben gibt, werden sie alle unter der Eingabe aufgelistet.

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''\''''

Vielen Dank an Anders Kaseorg für diese zusätzlichen Fälle:

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

Python 3 , 264 262 Bytes

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)

Probieren Sie es online!

Dies funktioniert, ist aber ohne Memo sehr langsam, was Sie mit hinzufügen können

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

Es wurde eine verbesserte Lösung für einen der Testfälle gefunden:

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"\'\'\'\'\'\'\'''\\'

In früheren Versionen dieser Antwort wurden in den folgenden Fällen falsche Ergebnisse zurückgegeben, die als Testfälle hinzugefügt werden konnten:

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