sfondo

Python 3 ha molti tipi di letterali stringa. Ad esempio, la stringa this 'is' an exa\\m/plepuò essere rappresentata come:

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

Come puoi vedere, l'uso di delimitatori diversi per le stringhe può allungare o accorciare le stringhe modificando l'escaping necessario per alcuni caratteri. Alcuni delimitatori non possono essere usati per tutte le stringhe: r'manca sopra (vedi più avanti per la spiegazione). Conoscere le tue corde è molto utile nel golf di codice.

Si possono anche combinare più letterali stringa in uno:

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

Sfida

La sfida è, data una stringa ASCII stampabile, di produrre la sua rappresentazione letterale più corta in Python.

Dettagli sulla meccanica delle corde

Stringhe possono essere delimitate utilizzando ', ", '''e """. Una stringa termina quando il delimitatore iniziale viene colpito di nuovo senza caratteri di escape.

Se una stringa letterale inizia con '''o """viene consumata come delimitatore. Altrimenti 'o "viene utilizzato.

I personaggi possono essere sfuggiti posizionandoli \prima di loro. Ciò inserisce il carattere nella stringa ed elimina qualsiasi significato speciale che può avere. Ad esempio, nel 'a \' b'mezzo 'viene evaso e quindi non termina il valore letterale, e la stringa risultante è a ' b.

Facoltativamente, uno ro Rpuò essere inserito prima del delimitatore iniziale. In questo caso, la fuga \apparirà nel risultato. Ad esempio, r'a \' b'valuta a \' b. Questo è il motivo per cui a ' bnon può essere delimitato da r'.

Per scappare '''o """, basta sfuggire a uno dei personaggi.

Questi letterali possono essere concatenati insieme, il che concatena il loro contenuto.

Regole

• L'input è la stringa da golf. Solo ASCII stampabile, quindi nessuna nuova riga o altri caratteri speciali.
• L'output è il valore letterale della stringa golfizzata. Se ci sono più soluzioni, creane una.
• Per semplificare la sfida, in non rstringhe di eventuali fughe ad eccezione di \\, \'e \"sono considerati non validi. Non devono essere usati nell'output, anche se '\m'è uguale a '\\m'in Python. Ciò elimina la necessità di elaborare codici di escape speciali come \n.
• Non sono consentiti i builtin per il golf delle stringhe Python. Python reprè permesso, dato che è comunque scadente.
• Si applicano le regole standard del code-golf .

Esempi di ingressi / uscite

Ho fatto del mio meglio per verificarli, ma fatemi sapere se ci sono errori. Se ci sono più output validi per i casi, questi sono elencati sotto l'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''\''''

Grazie ad Anders Kaseorg per questi casi aggiuntivi:

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

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)

Provalo online!

Funziona ma è molto lento senza memoization, che è possibile aggiungere

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

Ha trovato una soluzione migliorata per uno dei casi di test:

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

Le versioni precedenti di questa risposta restituivano risultati errati su quanto segue, che potevano essere aggiunti come casi di test:

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