Stringhe con contesto

Ai fini di questa sfida, una stringa con contesto è una tripla di stringhe, denominata contesto sinistro , parte dati e contesto giusto . Rappresenta una sottostringa di una stringa più lunga. Usiamo il tubo verticale |come separatore, quindi un esempio di stringa con contesto è cod|e-go|lf, dove si trova il contesto sinistro cod, i dati e-goe il contesto giusto lf. Questo esempio rappresenta la sottostringa e-godi code-golf.

Ora, per concatenare due stringhe con il contesto, procediamo come segue, usando aa|bcc|deee cc|de|eeecome esempi. Allineamo le stringhe come nel diagramma

a a|b c c|d e e
      c c|d e|e e e

in modo che le loro parti di dati siano adiacenti. La parte di dati della concatenazione è la concatenazione delle parti di dati, in questo caso bccde. Il contesto di sinistra è la parte che estende i fianchi alla sinistra della prima parte di dati, in questo caso aa. Allo stesso modo, il giusto contesto è eee, quindi la concatenazione è la stringa con il contesto aa|bccde|eee. Per un secondo esempio, considera a|bb|cde aabb|cd|, dove la seconda parola ha un contesto giusto vuoto. Lo schema di allineamento è

  a|b b|c d
a a b b|c d|

dove il contesto sinistro della seconda parola si estende oltre quello della prima. La concatenazione è aa|bbcd|.

Ma aspetta, c'è un gotcha: se le lettere del diagramma di allineamento non corrispondono, la concatenazione non esiste! Ad esempio, il diagramma di aa|bb|cced c|c|cè

a a|b b|c c
      c|c|c

dove be csulla quarta colonna non sono d'accordo, quindi non possono essere concatenati.

L'obiettivo

Il tuo compito è quello di scrivere un programma che includa due stringhe con il contesto le cui parti sono separate da |come sopra, e genera la loro concatenazione se esiste, e qualcos'altro in caso contrario. Il "qualcos'altro" può essere qualsiasi valore, incluso nessun output, purché non sia una stringa valida con contesto ed è la stessa in tutti i casi. Tuttavia, lanciare un errore non è accettabile. È possibile assegnare un programma STDIN-to-STDOUT o una funzione e sono accettate anche funzioni anonime. Vince il conteggio di byte più piccolo e non sono consentite scappatoie standard.

Casi test

aa|bcc|dee cc|de|eee -> aa|bccde|eee
a|bb|cd    aabb|cd|  -> aa|bbcd|
a|b|cccd   aab|cc|c  -> aa|bcc|cd
a|b|c      b||cd     -> a|b|cd
aa|bb|cc   c|c|c     -> None
aaa|b|c    abb|cd|d  -> None
|bb|cd     abb|c|ed  -> None
a|b|c      a||cd     -> None

Haskell, 184 182 201 199 155

s&t|(a,'|':b)<-f t,(x,'|':y)<-f$r s,x#b,a#y=r(y!r a)++b!r x|0<1=""
r=reverse
a!b=a++drop(length a-1)b
(#)a=and.zipWith(==)(r a).filter h
f=span h
h=(/='|')

esempio di esecuzione:

"|a|"&"|b|" -- returns "|ab|"
"|a|x"&"|b|" -- returns ""

se non c'è una corrispondenza verrà restituita una stringa vuota. altrimenti il ​​risultato sarebbe restituito.

spiegazione parziale:

# è una funzione che ottiene due stringhe e restituisce se corrispondono o meno.

! ottiene due stringhe e restituisce la prima concatenata con carattere aggiuntivo dalla seconda (se ce ne sono).

la funzione principale &usa span (/='|')per dividere gli input in due parti, a|b|ca a, b|c, controlla se i contesti corrispondono, e poi usa !due volte per assemblare l'output.

Modifica: la regolazione del mago in ritardo sembra essere abbastanza efficace.

Python (242 byte)

import itertools as i
s='|'
j=''.join
r=reversed
m=lambda a,b:j(j(*set(p+q))for p,q in i.izip_longest(a,b,fillvalue=''))
def c(A,B):
 u,v,w,x,y,z=(A+s+B).split(s)
 try:return j(r(m(r(u+v),r(x))))[:-len(v)]+s+v+y+s+m(w,y+z)[len(y):]
 except:0

Spiegazione

La funzione lambda mrestituisce il più lungo di due stringhe purché condividano un prefisso comune. Lo fa concatenando la stringa vuota ''al posto di qualsiasi valori mancanti, quindi ruotando il risultato (che può assumere le forme aa, ab, a, o bnei casi di partita / disadattamento / lunghezza diseguale) in una serie di personaggi unici in ciascuna posizione. joinsi aspetta un singolo argomento, quindi decomprimere un set con più di un elemento provocherà un aumento di aTypeError .

La funzione principale quindi

• usa mper combinare il contesto sinistro e parte dei dati la prima parola con il contesto sinistro della seconda (da destra a sinistra su stringhe invertite)
• concatena parti di dati,
• e ancora usa mper combinare il giusto contesto della prima parola con la parte di dati e il giusto contesto della seconda

Le parti di dati delle due parole originali sono tagliate dai lati destro e sinistro dei nuovi contesti.

Poiché sappiamo che i disallineamenti causano mun aumento di un TypeError, in questi casi prendiamo l'eccezione e implicitamente ritorniamo None.

analisi

TESTCASES = [
    ('aa|bcc|dee', 'cc|de|eee', 'aa|bccde|eee'),
    ('a|bb|cd', 'aabb|cd|', 'aa|bbcd|'),
    ('a|b|cccd', 'aab|cc|c', 'aa|bcc|cd'),
    ('a|b|c', 'b||cd', 'a|b|cd'),
    ('aa|bb|cc', 'c|c|c', None),
    ('aaa|b|c', 'abb|cd|d', None),
    ('|bb|cd', 'abb|c|ed', None),
    ('a|b|c', 'a||cd', None),
]

for A, B, R in TESTCASES:
    print '{:<10} {:<9} -> {}'.format(A, B, c(A, B))

Produzione

aa|bcc|dee cc|de|eee -> aa|bccde|eee
a|bb|cd    aabb|cd|  -> aa|bbcd|  
a|b|cccd   aab|cc|c  -> aa|bcc|cd 
a|b|c      b||cd     -> a|b|cd    
aa|bb|cc   c|c|c     -> None      
aaa|b|c    abb|cd|d  -> None      
|bb|cd     abb|c|ed  -> None      
a|b|c      a||cd     -> None