Início / unix / Perguntas / 510325
Accepted
Anna1364
Asked: 2019-04-04 08:58:23 +0800 CST

como atribuir valores a intervalos com regiões sobrepostas?

  • 772

Eu tenho dois arquivos grandes, o primeiro arquivo contém alguns intervalos com 85K linhas:

head data.intervals
id  id_uniq numberA numberB
1   g1  5   20
1   g2  6   29
1   g3  17  35
1   g4  37  46
1   g5  50  63
1   g6  70  95
1   g7  87  93
2   g8  3   15
2   g9  10  33
2   g10 60  77
2   g11 90  132

o segundo arquivo contém algumas posições com mais de 2 milhões de linhas:

head data.posiitons
id  number
1   4
1   19
1   36
1   49
1   90
2   1
2   20
2   89
2   93
2   120

O que eu quero fazer é o seguinte: Para cada valor na coluna "number" do arquivo de posição, pesquise se é igual ou entre QUALQUER dos valores do par "numberA" e "numberB" do arquivo data.intervals.

Além disso, para esses valores de par "numberA" e "numberB", seu respectivo "id" deve corresponder ao "id" em data.position. Se tudo isso for verdade, quero inserir o respectivo "id.uniq" na coluna data.intervals da respectiva linha no arquivo data.posiitons.

Há outro problema aqui também: alguns desses intervalos se sobrepõem e uma posição pode estar dentro do intervalo de 2 ou mais de 2 intervalos. Quero atribuí-los a cada intervalo separadamente.

aqui está a saída final que desejo obter (NA significa que a posição não está dentro do intervalo de nenhum intervalo):

   id   number  assigned1
1   4   NA
1   19  g1,g2,g3
1   36  NA
1   49  NA
1   90  g6,g7
2   1   NA
2   20  g9
2   89  NA
2   93  g11
2   120 g11

existe alguma solução para fazer essa tarefa com um script bash ou perl?

text-processing command-line

3 respostas

  1. Best Answer

    Você poderia fazer isso comPerl usando o seguinte método:

    $ perl -lane '
   my($id, $uniq_id, $lower, $upper) = @F;
   $h{$id}{$uniq_id}{MIN} = $lower;
   $h{$id}{$uniq_id}{MAX} = $upper;
   push @{$order{$id}}, $uniq_id;
   }{
   while(<STDIN>) {
      chomp;
      my($id, $number) = split;
      print join "\t", $id, $number,
       join(",", grep { $h{$id}{$_}{MIN} < $number and $h{$id}{$_}{MAX} > $number } @{$order{$id}})
         || qw/NA/;;
   }
' data.intervals < data.posiitons

    Resultado:

    1  4     NA
1  19    g1,g2,g3
1  36    NA
1  49    NA
1  90    g6,g7
2  1     NA
2  20    g9
2  89    NA
2  93    g11
2  120   g11

    Funciona:

    • Leia o arquivo de intervalos primeiro e construa a estrutura de dados de um hash codificado no ID, ID exclusivo e contendo os pontos de extremidade do intervalo.
    • o%order hash armazena a ordem em que os IDs exclusivos foram encontrados para fins de reprodução na mesma ordem. OTW, a ordenação do hash é aleatória.
    • Em seguida, leia o arquivo de posições e primeiro descompacte cada registro (ou linha) e coloque-os nos escalares $id e $number.
    • grepdeve selecionar os IDs exclusivos que satisfaçam a restrição para o número estar no intervalo. Caso contrário, a "NA"é passado.
    • 2

  2. Este é o tipo de coisa para a qual você pode considerar usar um pequeno banco de dados - usando, por exemplo csvsql, o csvkit (que também fornece um csvformatutilitário útil).

    Por exemplo, supondo que seus dados estejam em arquivos separados por tabulação chamados intervalse positions, e usando o padrãosqlite , e usando o dialeto

    csvsql --tabs --query '
SELECT id,number,group_concat(id_uniq) AS "assigned1" 
FROM positions JOIN intervals USING(id)
WHERE number >= numberA AND number <= numberB
GROUP BY id,number ORDER BY id,number
' positions intervals | csvformat --out-tabs
id  number  assigned1
1   19  g1,g2,g3
1   90  g6,g7
2   20  g9
2   93  g11
2   120 g11

    É um pouco mais complicado obter as N/Aentradas também: para isso, você pode juntar a positionstabela original com os resultados e procurar NULLos valores do assigned1campo:

    csvsql --tabs --query '
SELECT id,number,IFNULL(assigned1,"NA") assigned1 FROM positions 
LEFT JOIN (
  SELECT id,number,group_concat(id_uniq) AS "assigned1" 
  FROM positions JOIN intervals USING(id) 
  WHERE number >= numberA AND number <= numberB
  GROUP BY id,number
) USING(id,number) ORDER BY id,number 
' positions intervals | csvformat --out-tabs
id  number  assigned1
1   4   NA
1   19  g1,g2,g3
1   36  NA
1   49  NA
1   90  g6,g7
2   1   NA
2   20  g9
2   89  NA
2   93  g11
2   120 g11
    • 1

  3. Assumindo que ambos os arquivos foram ordenados usando sort -b, você pode compor todas as combinações possíveis de cada linha nos dois arquivos que possuem o mesmo ID com

    join ranges.txt positions.txt

    Para simplificar, também estou ignorando o fato de que os arquivos têm cabeçalhos (considere removê-los).

    Isso produziria, para os dados fornecidos,

    1 g1 5 20 4
1 g1 5 20 19
1 g1 5 20 36
1 g1 5 20 49
1 g1 5 20 90
1 g2 6 29 4
1 g2 6 29 19
1 g2 6 29 36
[...] (in total 55 lines)

    Aqui você tem o ID, o "ID exclusivo", os dois valores do intervalo e a posição que deseja testar.

    Isso pode ser analisado por um awkprograma:

    join ranges.txt positions.txt |
awk '!($1 SUBSEP $5 in count) { count[$1,$5]=0 }
     $5 >= $3 && $5 <= $4 && ++count[$1,$5]
     END {
         for (i in count)
             if (count[i] == 0) {
                 split(i,s,SUBSEP)
                 print s[1], s[2], "NA"
             }
     }'

    Isso acompanharia os IDs vistos e a posição como chaves em uma countmatriz. O valor conteria o número de vezes que uma posição foi colocada em um intervalo. Precisamos disso para poder dizer "esta posição não foi encontrada em nenhum intervalo".

    Se a linha atual na saída de joincontiver uma posição no 5º campo que esteja dentro do intervalo dos campos 3 e 4, essa contagem será incrementada (e a linha será emitida).

    Isso gera todas as linhas na saída joinque correspondem às posições dentro dos intervalos. O ENDbloco trata posições não correspondidas fazendo um loop sobre o countarray e imprimindo as informações que você solicitou na pergunta, no formato que você solicitou lá sempre que o countvalor for zero.

    Para os dados fornecidos, isso produz

    1 g1 5 20 19
1 g2 6 29 19
1 g3 17 35 19
1 g6 70 95 90
1 g7 87 93 90
2 g9 10 33 20
2 g11 90 132 93
2 g11 90 132 120
2 89 NA
1 36 NA
1 4 NA
2 1 NA
1 49 NA

    Para recolher esses dados com base no "ID exclusivo", poderíamos passá-los por outro awkprograma. (Estou evitando salvar tudo em uma matriz no mesmo awk programa, pois pode haver muitos dados).

    awk '$NF == "NA" { print; next }
                 { key = $1 SUBSEP $NF }
     key == prev { group = group "," $2; next }
                 { if (group != "") print id, pos, group; id = $1; pos = $NF; group = $2; }
     END         { if (group != "") print id, pos, group }'

    Isso passa por qualquer linha cuja última coluna esteja, NApois elas já estão no formato correto. Em seguida, ele constrói uma "chave" do ID e da posição. Se esta chave for a mesma da linha anterior, o "ID exclusivo" é adicionado a uma string chamada groupcom uma vírgula como delimitador.

    Se a chave não for a mesma que a anterior, então encontramos um novo conjunto de correspondências de posição de ID e devemos gerar os dados para o grupo que acabamos de analisar. Isso é feito novamente no ENDbloco de saída dos dados para o último grupo.

    Juntando tudo isso e lembrando que ambos os arquivos de entrada precisam ser classificados, acabamos com

    join ranges.txt positions.txt |
awk '!($1 SUBSEP $5 in count) { count[$1,$5]=0 }
     $5 >= $3 && $5 <= $4 && ++count[$1,$5]
     END {
         for (i in count)
             if (count[i] == 0) {
                 split(i,s,SUBSEP)
                 print s[1], s[2], "NA"
             }
     }' |
awk '$NF == "NA" { print; next }
                 { key = $1 SUBSEP $NF }
     key == prev { group = group "," $2; next }
                 { if (group != "") print id, pos, group
                   prev = key; id = $1; pos = $NF; group = $2; }
     END         { if (group != "") print id, pos, group }'

    A saída disso é

    1 19 g1,g2,g3
1 90 g6,g7
2 20 g9
2 93 g11
2 89 NA
1 36 NA
1 4 NA
2 1 NA
1 49 NA
2 120 g11

    que, fora o pedido, é idêntico ao que você esperava. Para corrigir a ordenação, passe isso por sort -k1,1n -k2,2n.

    • -1

relate perguntas