Swift: concatene dos matrices sin duplicar el sufijo/prefijo compartido

Tengo una situación en la que necesito unir dos matrices que a menudo tienen un subarreglo superpuesto.

Entonces si tengo:

let input1 = ["A", "B", "F", "E"]

y

let input2 = ["F", "E", "A", "G"]

el resultado debe ser:

let result = ["A", "B", "F", "E", "A", "G"]

Entonces, es un poco como una "unión" en el sentido de que la salida no duplica el subarreglo/intersección compartido y contiene ambos arreglos en su estado original (solo superpuestos/intersectados). La forma canónica de hacer algo similar es con Conjuntos, pero eso eliminaría la segunda "A".

Solución del problema

Solo por diversión, puede usar comienza con predicado mientras itera su primera secuencia desde el final de la siguiente manera:

let first: [String] = ["A", "B", "F", "E"]
let second: [String] = ["F", "E", "A", "G"]
var pos = first.endIndex
while pos > first.startIndex,
 second.starts(with: first[pos...], by: { $0!= $1}),
!second.isEmpty {
 first.formIndex(before: &pos)
}
let result = first[..<pos] + second // ["A", "B", "F", "E", "A", "G"] 

Esto dará como resultado una subsecuencia, en este caso un segmento de matriz. Si necesita una matriz, simplemente establezca explícitamente el tipo resultante:

let result: [String] = first[..<pos] + second

Según los comentarios de OP, si necesita hacer coincidir la subsecuencia por pares, simplemente compense cada dos elementos:

let first = "ABFF"
let second = "FFAG"
var pos = first.endIndex
while pos > first.startIndex,
 second.starts(with: first[pos...], by: { $0!= $1 }),
!second.isEmpty {
 first.formIndex(&pos, offsetBy: -2)
}
let result: String = first[..<pos] + second // "ABFFAG"

Si necesita los elementos de cadena separados por espacios:

var first = "A B C D E F G D E"
var second = "D E F C B A"
first.removeAll(where: \.isWhitespace)
second.removeAll(where: \.isWhitespace)
var pos = first.endIndex
while pos > first.startIndex,
 second.starts(with: first[pos...], by: { $0!= $1 }),
!second.isEmpty {
 first.formIndex(&pos, offsetBy: -2)
}
let result = (first[..<pos] + second)
 .map(String.init)
 .joined(separator: " ")
result // "A B C D E F G D E F C B A"