tło

Python 3 ma wiele rodzajów literałów łańcuchowych. Na przykład ciąg this 'is' an exa\\m/plemoże być reprezentowany jako:

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

Jak widać, użycie różnych ograniczników dla ciągów może wydłużyć lub skrócić ciągi, zmieniając odstępy wymagane dla niektórych znaków. Niektórych ograniczników nie można używać dla wszystkich ciągów: r'brakuje go powyżej (wyjaśnienie znajduje się później). Znajomość łańcuchów jest bardzo przydatna w golfie kodowym.

Można także łączyć wiele literałów łańcuchowych w jeden:

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

Wyzwanie

Wyzwaniem jest, biorąc pod uwagę ciąg ASCII do wydrukowania, wygenerowanie najkrótszej dosłownej reprezentacji w Pythonie.

Szczegóły dotyczące mechaniki strun

Łańcuchy mogą być rozdzielane za pomocą ', ", '''i """. Łańcuch kończy się, gdy początkowy ogranicznik zostanie ponownie uderzony bezkolizyjnie.

Jeśli literał łańcuchowy zaczyna się od '''lub """jest używany jako separator. W przeciwnym razie 'lub "jest używany.

Postacie można uciec, stawiając \przed nimi. To wstawia znak do łańcucha i eliminuje wszelkie specjalne znaczenie, jakie może mieć. Na przykład, 'a \' b'pośrodku 'jest znak ucieczki, a zatem nie kończy się literałem, a wynikowy ciąg znaków to a ' b.

Opcjonalnie jeden z rlub Rmoże być wstawiony przed początkowym ogranicznikiem. Jeśli tak się stanie, \w wyniku pojawi się znak ucieczki . Na przykład r'a \' b'ocenia na a \' b. Dlatego a ' bnie może być rozdzielany przez r'.

Ucieczki '''lub """jeden tylko musi uciec jeden z bohaterów.

Te literały można łączyć razem, co łączy ich zawartość.

Zasady

• Dane wejściowe to ciąg do golfa. Tylko ASCII do wydruku, więc nie ma nowego wiersza ani innych znaków specjalnych.
• Wynikiem jest dosłowny ciąg golfowy. Jeśli istnieje wiele rozwiązań, wypisz jedno.
• Aby uprościć wyzwanie, w nie- rciągów żadnych ucieczek z wyjątkiem \\, \'i \"są uznawane za nieważne. Nie można ich używać w danych wyjściowych, nawet jeśli '\m'są one równe '\\m'w Pythonie. Eliminuje to potrzebę przetwarzania specjalnych kodów ucieczki, takich jak \n.
• Wbudowane do gry w golfa ciągi Python są niedozwolone. Python reprjest dozwolony, ponieważ i tak jest gówniany.
• Obowiązują standardowe zasady gry w golfa .

Przykładowe wejścia / wyjścia

Starałem się jak najlepiej to sprawdzić, ale daj mi znać, jeśli występują błędy. Jeśli istnieje wiele prawidłowych danych wyjściowych do przypadków, wszystkie są wymienione poniżej danych wejściowych.

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

Podziękowania dla Andersa Kaseorga za te dodatkowe przypadki:

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

Python 3 , 264 262 bajtów

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)

Wypróbuj online!

Działa, ale działa bardzo wolno bez zapamiętywania, które można dodać

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

Znaleziono ulepszone rozwiązanie dla jednego z przypadków testowych:

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

Poprzednie wersje tej odpowiedzi zwracały niepoprawne wyniki w następujących przypadkach, które można dodać jako przypadki testowe:

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