Problema para filtrar a matriz de seqüências para remover duplicatas com seqüências deslocadas

1

Eu tive alguns problemas para fazer uma matriz de comparação de listas para remover duplicatas. Meu array é composto de sequências de valores ternários como este:

{0, 0, 1, 0, 1, 1, 1, 2, 2, 0, 1, 2, 1}  
{0, 0, 2, 0, 2, 2, 2, 1, 1, 0, 2, 1, 2}  
{0, 1, 0, 1, 1, 1, 2, 2, 0, 1, 2, 1, 0}  
{0, 1, 1, 1, 2, 2, 0, 1, 2, 1, 0, 0, 1}  
{0, 1, 2, 1, 0, 0, 1, 0, 1, 1, 1, 2, 2}    
{0, 2, 0, 2, 2, 2, 1, 1, 0, 2, 1, 2, 0}  
{0, 2, 1, 2, 0, 0, 2, 0, 2, 2, 2, 1, 1}  
{0, 2, 2, 2, 1, 1, 0, 2, 1, 2, 0, 0, 2}  
{1, 0, 0, 1, 0, 1, 1, 1, 2, 2, 0, 1, 2}  
{1, 0, 1, 1, 1, 2, 2, 0, 1, 2, 1, 0, 0}  
{1, 0, 2, 1, 2, 0, 0, 2, 0, 2, 2, 2, 1}  
{1, 1, 0, 2, 1, 2, 0, 0, 2, 0, 2, 2, 2}  
{1, 1, 1, 2, 2, 0, 1, 2, 1, 0, 0, 1, 0}  
{1, 1, 2, 2, 0, 1, 2, 1, 0, 0, 1, 0, 1}  
{1, 2, 0, 0, 2, 0, 2, 2, 2, 1, 1, 0, 2}  
{1, 2, 1, 0, 0, 1, 0, 1, 1, 1, 2, 2, 0}  
{1, 2, 2, 0, 1, 2, 1, 0, 0, 1, 0, 1, 1}  
{2, 0, 0, 2, 0, 2, 2, 2, 1, 1, 0, 2, 1}

Eu tentei com um loop while para encontrar duplicatas com a ajuda de um subscript testsequence.sh que é um wrapper de script do Mathematica para identificar se duas seqüências são as mesmas:

{0, 0, 1, 0, 1, 1, 1, 2, 2, 0, 1, 2, 1}  
{0, 1, 0, 1, 1, 1, 2, 2, 0, 1, 2, 1, 0}

Estes dois são os mesmos com uma mudança para a esquerda; meu subscrito retorna 1 nesse caso e o subscrito é usado assim:

./testsequence.sh "'echo ${foundsequence[0]}'" "'echo ${foundsequence[1]}'"

Minha primeira tentativa com o loop while comparou apenas a primeira sequência com outras, removendo apenas metade das duplicatas.

O bom resultado deve ser:

{0, 0, 1, 0, 1, 1, 1, 2, 2, 0, 1, 2, 1}  
{0, 0, 2, 0, 2, 2, 2, 1, 1, 0, 2, 1, 2}  

Como elas são as únicas duas sequências únicas na lista.

Esteja ciente de que as sequências na matriz não são de comprimento fixo. Eles podem variar de 2 a 121 ou até mais de comprimento. É por isso que quero manter meus índices para comparar duas linhas da matriz.

    
por Begoul 02.11.2016 / 19:10

1 resposta

0

Aqui está um laço bash que lê a entrada de um arquivo chamado 'input' em uma matriz chamada input , então faz um loop sobre aquela matriz e testa para ver se aquela sequência em particular foi vista antes; se não foi visto, imprime o valor. Em seguida, ele gira essa sequência por todas as 13 posições, adicionando esses valores a uma matriz associativa de rotação conhecida. Eu simplifiquei os dados para mostrar o método; você pode pegar o loop do shell e ajustar a entrada ou saída conforme necessário.

#!/usr/bin/env bash
readarray -t input < input
declare -A rotations
for((i=0; i < ${#input[*]}; i++))
do
  x=${input[i]}
  [[ ${rotations[$x]:-0} -eq 0 ]] && printf "%s\n" "$x"
  for((r=0; r < 13; r++))
  do
    new=${x:r}${x:0:r}
    rotations[$new]=1
  done
done

Exemplo de dados de entrada (copiados da pergunta e simplificados):

0010111220121
0020222110212
0101112201210
0111220121001
0121001011122
0202221102120
0212002022211
0222110212002
1001011122012
1011122012100
1021200202221
1102120020222
1112201210010
1122012100101
1200202221102
1210010111220
1220121001011
2002022211021

Exemplo de saída:

0010111220121
0020222110212
    
por 02.11.2016 / 21:45

Tags