Come trovo la sovrapposizione di due stringhe in bash? [chiuso]

Ho due stringhe. Per il bene dell'esempio sono impostati in questo modo:

string1="test toast"
string2="test test"

Quello che voglio è trovare la sovrapposizione a partire dall'inizio delle stringhe. Con sovrapposizione intendo la stringa "test t" nel mio esempio precedente.

# I look for the command 
command "$string1" "$string2"
# that outputs:
"test t"

Se le stringhe fossero string1="atest toast"; string2="test test", non si sovrapporrebbero poiché il controllo inizia dall'inizio e la "a" all'inizio di string1.

Puoi pensare a una funzione come questa, con qualche controllo degli errori da aggiungere

common_prefix() {
  local n=0
  while [[ "${1:n:1}" == "${2:n:1}" ]]; do
    ((n++))
  done
  echo "${1:0:n}"
}

Questo può essere fatto interamente all'interno di bash. Sebbene la manipolazione delle stringhe in un ciclo in bash sia lenta, esiste un semplice algoritmo logaritmico nel numero di operazioni della shell, quindi bash puro è un'opzione praticabile anche per stringhe lunghe.

longest_common_prefix () {
  local prefix= n
  ## Truncate the two strings to the minimum of their lengths
  if [[ ${#1} -gt ${#2} ]]; then
    set -- "${1:0:${#2}}" "$2"
  else
    set -- "$1" "${2:0:${#1}}"
  fi
  ## Binary search for the first differing character, accumulating the common prefix
  while [[ ${#1} -gt 1 ]]; do
    n=$(((${#1}+1)/2))
    if [[ ${1:0:$n} == ${2:0:$n} ]]; then
      prefix=$prefix${1:0:$n}
      set -- "${1:$n}" "${2:$n}"
    else
      set -- "${1:0:$n}" "${2:0:$n}"
    fi
  done
  ## Add the one remaining character, if common
  if [[ $1 = $2 ]]; then prefix=$prefix$1; fi
  printf %s "$prefix"
}

La cassetta degli attrezzi standard include cmpper confrontare i file binari. Per impostazione predefinita, indica l'offset di byte dei primi byte diversi. C'è un caso speciale quando una stringa è un prefisso dell'altra: cmpproduce un messaggio diverso su STDERR; un modo semplice per affrontarlo è quello di prendere qualunque stringa sia la più corta.

longest_common_prefix () {
  local LC_ALL=C offset prefix
  offset=$(export LC_ALL; cmp <(printf %s "$1") <(printf %s "$2") 2>/dev/null)
  if [[ -n $offset ]]; then
    offset=${offset%,*}; offset=${offset##* }
    prefix=${1:0:$((offset-1))}
  else
    if [[ ${#1} -lt ${#2} ]]; then
      prefix=$1
    else
      prefix=$2
    fi
  fi
  printf %s "$prefix"
}

Si noti che cmpopera su byte, ma la manipolazione di stringhe di bash opera su caratteri. Ciò fa la differenza nelle impostazioni locali multibyte, ad esempio impostazioni locali che utilizzano il set di caratteri UTF-8. La funzione sopra stampa il prefisso più lungo di una stringa di byte. Per gestire le stringhe di caratteri con questo metodo, possiamo prima convertire le stringhe in una codifica a larghezza fissa. Supponendo che il set di caratteri della locale sia un sottoinsieme di Unicode, UTF-32 si adatta al conto.

longest_common_prefix () {
  local offset prefix LC_CTYPE="${LC_ALL:=$LC_CTYPE}"
  offset=$(unset LC_ALL; LC_MESSAGES=C cmp <(printf %s "$1" | iconv -t UTF-32) \
                                           <(printf %s "$2" | iconv -t UTF-32) 2>/dev/null)
  if [[ -n $offset ]]; then
    offset=${offset%,*}; offset=${offset##* }
    prefix=${1:0:$((offset/4-1))}
  else
    if [[ ${#1} -lt ${#2} ]]; then
      prefix=$1
    else
      prefix=$2
    fi
  fi
  printf %s "$prefix"
}

In sed, supponendo che le stringhe non contengano caratteri di nuova riga:

string1="test toast"
string2="test test"
printf "%s\n" "$string1" "$string2" | sed -e 'N;s/^\(.*\).*\n\1.*$/\1/'

Mi sembra rozzo, ma puoi farlo con la forza bruta:

#!/bin/bash

string1="test toast"
string2="test test"

L=1  # Prefix length

while [[ ${string1:0:$L} == ${string2:0:$L} ]]
do
    ((L = L + 1))
done

echo Overlap: ${string1:0:$((L - 1))}

Voglio che esista un algoritmo intelligente, ma non riesco a trovarne nessuno con una breve ricerca.