Задний план

Python 3 имеет много типов строковых литералов. Например, строка 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"
'''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"""

Как вы можете видеть, использование разных разделителей для строк может удлинять или сокращать строки, изменяя экранирование, необходимое для определенных символов. Некоторые разделители нельзя использовать для всех строк: r'отсутствует выше (объяснение см. Ниже ). Знание своих струн очень полезно в кодовом гольфе.

Можно также объединить несколько строковых литералов в один:

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

Вызов

Задача состоит в том, чтобы при наличии печатаемой строки ASCII вывести ее самое короткое литеральное представление в Python.

Детали по механике струн

Строки могут быть разделены с помощью ', ", '''и """. Строка заканчивается, когда начальный разделитель снова удаляется без экранирования.

Если строковый литерал начинается с '''или """он используется в качестве разделителя. В противном случае 'или "используется.

Персонажей можно избежать, поместив \перед ними. Это вставляет символ в строку и устраняет любое особое значение, которое он может иметь. Например, в 'a \' b'середине 'экранируется и, таким образом, не заканчивается литерал, и в результате получается строка a ' b.

Необязательно, один из rили Rможет быть вставлен перед начальным разделителем. Если это будет сделано, побег \появится в результате. Например, r'a \' b'оценивает до a \' b. Вот почему a ' bне может быть разграничен r'.

Чтобы убежать '''или """нужно убежать только от одного из персонажей.

Эти литералы могут быть объединены вместе, что объединяет их содержимое.

правила

• Входом является строка в гольф. Только для печати в формате ASCII, поэтому не нужно переводить строки или другие специальные символы.
• На выходе получается строковый литерал. Если существует несколько решений, выведите одно.
• Чтобы упростить задачу, в не- rструн любой ускользает за исключением \\, \'и \"считается недействительным. Они не должны использоваться в выходных данных, даже если они '\m'совпадают с '\\m'Python. Это избавляет от необходимости обрабатывать специальные escape-коды, такие как \n.
• Встроенные элементы для игры в гольф Python не разрешены. Python reprразрешен, так как он все равно дрянной.
• Применяются стандартные правила игры в гольф .

Пример входов / выходов

Я старался изо всех сил, чтобы проверить это, но дайте мне знать, если есть ошибки. Если в случаях есть несколько действительных выходов, они все перечислены под входом.

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

Спасибо Anders Kaseorg за эти дополнительные случаи:

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

Python 3 , 264 262 байта

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)

Попробуйте онлайн!

Это работает, но очень медленно без напоминания, которое вы можете добавить с

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

Было найдено улучшенное решение для одного из тестовых случаев:

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

Предыдущие версии этого ответа возвращали неверные результаты на следующих, которые могут быть добавлены в качестве контрольных примеров:

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