Latar Belakang

Python 3 memiliki banyak jenis string literal. Misalnya, string this 'is' an exa\\m/pledapat direpresentasikan sebagai:

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

Seperti yang Anda lihat, menggunakan pembatas yang berbeda untuk string dapat memperpanjang atau memperpendek string dengan mengubah pelolosan yang diperlukan untuk karakter tertentu. Beberapa pembatas tidak dapat digunakan untuk semua string: r'tidak ada di atas (lihat nanti untuk penjelasan). Mengetahui string Anda sangat berguna dalam kode golf.

Satu juga dapat menggabungkan beberapa string literal menjadi satu:

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

Tantangan

Tantangannya adalah, diberi string ASCII yang dapat dicetak, untuk menampilkan representasi literalnya yang terpendek dalam Python.

Detail tentang mekanika string

String dapat dipisahkan menggunakan ', ", '''dan """. Sebuah string berakhir ketika pembatas awal dipukul lagi tanpa dihilangkan.

Jika string literal dimulai dengan '''atau """dikonsumsi sebagai pembatas. Kalau tidak 'atau "digunakan.

Karakter dapat diloloskan dengan menempatkan \sebelum mereka. Ini memasukkan karakter dalam string dan menghilangkan makna khusus yang dimilikinya. Misalnya, di 'a \' b'tengah 'luput dan dengan demikian tidak mengakhiri literal, dan string yang dihasilkan adalah a ' b.

Secara opsional, satu ratau Rdapat dimasukkan sebelum pembatas awal. Jika ini dilakukan, pelolosan \akan muncul di hasilnya. Misalnya, r'a \' b'evaluasi ke a \' b. Inilah sebabnya mengapa a ' btidak dapat dibatasi oleh r'.

Untuk melarikan diri '''atau """, seseorang hanya perlu melarikan diri dari salah satu karakter.

Literal ini dapat digabungkan bersama, yang menggabungkan isinya.

Aturan

• Inputnya adalah string ke golf. Hanya dicetak ASCII, jadi tidak ada baris baru atau karakter khusus lainnya.
• Outputnya adalah string literal golf. Jika ada beberapa solusi, hasilkan satu.
• Untuk menyederhanakan tantangan, dalam non- rstring setiap pelarian kecuali untuk \\, \'dan \"dianggap tidak valid. Mereka tidak boleh digunakan dalam output, meskipun '\m'sama dengan '\\m'di Python. Ini menghilangkan kebutuhan untuk memproses kode pelarian khusus seperti \n.
• Dibangun untuk golf string Python dilarang. Python reprdiizinkan, karena itu jelek.
• Aturan standar kode-golf berlaku.

Contoh input / output

Saya mencoba yang terbaik untuk memverifikasi ini, tetapi beri tahu saya jika ada kesalahan. Jika ada beberapa keluaran yang valid untuk kasing, semuanya tercantum di bawah input.

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

Terima kasih kepada Anders Kaseorg untuk kasus-kasus tambahan ini:

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

Python 3 , 264 262 byte

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)

Cobalah online!

Ini berfungsi tetapi sangat lambat tanpa memoisasi, yang dapat Anda tambahkan

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

Ia menemukan solusi yang lebih baik untuk salah satu kasus uji:

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

Versi sebelumnya dari jawaban ini menghasilkan hasil yang salah pada yang berikut, yang dapat ditambahkan sebagai kasus uji:

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