Automatize a contagem do número de ocorrências

Question

Eu quero saber quantas vezes 'ABCD' (arquivo A) vem em DB (arquivo B). Da mesma forma, quero saber sobre todas as linhas singles presentes no arquivo A contra o DB. Eu preciso de um comando automatizado que pode facilitar o meu trabalho porque eu tenho uma grande quantidade de dados no arquivo A e eu quero procurá-lo em muitos bancos de dados. Eu apenas deixo os personagens ousados para entender.

Arquivo A

ABCD
EFG
HIJKL
MNO
PQRSTU

Arquivo B

XYZABCDFORNTUFPSRWSABCFYWSZCFTHBFORTYBJNFABCDDEFGACVRTEFGPQRMNOOPQEFGZXXXYY

Saída desejada:

ABCD  2
EFG   3
HIJKL 4567
MNO   0
PQRSTU 7652

    

Answer 1

Minha sugestão é:

IFS=; while read -r word; do printf "%s " $word; grep -o $word b | wc -l; done < a

• usando while , encaixamos as palavras (arquivo a)
• printf "%s " $word : imprime o nome da palavra, por exemplo: ABCD
• grep -o $word b | wc -l : conta e imprime o número de ocorrências

Answer 2

Python

count_patterns.py script. Deve ser bastante bom para arquivos grandes. Usa OrderedDict para gravar todos os padrões do arquivo A fornecido na linha de comando e procura por eles no arquivo B.

#!/usr/bin/env python3
import sys
from collections import OrderedDict

with open(sys.argv[1]) as pattern_file, open(sys.argv[2]) as data_file:
    patterns = OrderedDict.fromkeys(map(str.strip, pattern_file), 0)

    for line in data_file:
        for p in patterns:
            patterns[p] += line.count(p)

for kv in patterns.items():
    print(*kv)

Uso:

$ ./count_patterns.py file_A.txt file_B.txt 
ABCD 4
EFG 3
HIJKL 0
MNO 1
PQRSTU 0

Abordagem de Bash.

Isso usa a substituição de processo de sed , o que nos permite dividir o arquivo A em novas linhas em ** e usar grep -c para contar o número de linhas correspondentes.

$ cat file_B.txt 
ABCD**FORNTUFPSRWSABCFYWSZCFTHBFORTYBJNF**ABCD**D**EFG**ACVRT**EFG**PQRMNOOPQ**EFG**ZXXXYY
ABCD**FORNTUFPSRWSABCFYWSZCFTHBFORTYBJNF**ABCD

$ cat file_A.txt 
ABCD
EFG
HIJKL
MNO
PQRSTU

$ while IFS= read -r pattern;  do  printf "%s\t" "$pattern";   grep -c "$pattern" < <( sed 's/\*\*/\n/g' file_B.txt ); done  < file_A.txt 
ABCD    4
EFG 3
HIJKL   0
MNO 1
PQRSTU  0

Não é a melhor maneira de fazer isso, provavelmente não é adequada para arquivos grandes, mas funciona. Não recomendamos o uso do método bash, mas se o conjunto de dados não for grande, funcionará.

    

Answer 3

Bash

Usando as matrizes associativas do Bash :

#!/bin/bash
set -eu
declare -A patterns

while IFS= read -r p; do
    patterns["$p"]=0
done < "$1"

while IFS='*' read -ra l; do
    for r in "${l[@]}"; do
        if [ -n "$r" ] && [ -v patterns["$r"] ]; then
            patterns[$r]=$((${patterns["$r"]} + 1))
        fi
    done
done < "$2"

for p in "${!patterns[@]}"; do
    printf '%s\t%u\n' "$p" "${patterns["$p"]}"
done

Uso:

bash count-patterns.sh pattern-list.txt word-list.txt

Python 3

Usando uma classe de dicionário personalizada e processamento de dados de estilo funcional:

#!/usr/bin/env python3
import sys, itertools, collections

class MyCounter(collections.UserDict):
    def __init__(self, _dict):
        self.data = _dict

    def update(self, iterable):
        for key in iterable:
            self.data[key] += 1

with open(sys.argv[1]) as pattern_file:
    patterns = MyCounter({ s.rstrip('\n'): 0 for s in pattern_file })

with open(sys.argv[2]) as wordlist_file:
    patterns.update(filter(patterns.__contains__,
        itertools.chain.from_iterable(map(
            lambda s: s.rstrip('\n').split('**'), wordlist_file))))

for p in patterns.items():
    print(*p, sep='\t')

Uso:

python3 count-patterns.py pattern-list.txt word-list.txt

C ++

#include <cstddef>
#include <utility>
#include <unordered_map>
#include <iostream>
#include <fstream>

namespace std
{
    template <class Ch, class Tr, class K, class V, class H, class Eq>
    basic_ostream<Ch,Tr> &operator<<( basic_ostream<Ch,Tr> &os,
        const std::unordered_map<K,V,H,Eq> &m )
    {
        for (const typename std::unordered_map<K,V,H,Eq>::value_type &i: m)
            os << i.first << '\t' << i.second << '\n';
        return os.flush();
    }
}

template <class Key, class Hash = std::hash<Key>, class Equal = std::equal_to<Key>>
class counter :
    public std::unordered_map<Key, std::size_t, Hash, Equal>
{
private:
    typedef std::unordered_map<Key, std::size_t, Hash, Equal> _base;

public:
    void update_existing( const Key &k, std::size_t count = 1 )
    {
        const typename _base::iterator match = this->find(k);
        if (match != this->end())
            match->second += count;
    }
};

int main( int argc, char *argv[] )
{
    if (argc != 3)
    {
        std::cerr << "Usage: " << argv[0] << " <PATTERN-FILE> <WORDLIST-FILE>" << std::endl;
        return 2;
    }

    counter<std::string> patterns;
    std::string buf;
    {
        std::ifstream pattern_file(argv[1]);
        while (pattern_file.good() && !std::getline(pattern_file, buf).fail())
            patterns.emplace(std::move(buf), 0);
    }

    if (!patterns.empty())
    {
        std::ifstream wordlist_file(argv[2]);
        while (wordlist_file.good() && !std::getline(wordlist_file, buf).fail())
        {
            static const char delim[] = {'*', '*'};
            std::size_t offset = 0, p = 0;
            while ((p = buf.find(delim, offset, sizeof(delim))) != std::string::npos)
            {
                patterns.update_existing(buf.substr(offset, p - offset));
                offset = p + sizeof(delim);
            }
            patterns.update_existing(buf.erase(0, offset));
        }
    }

    std::cout << patterns;
}

Compile com:

c++ -std=c++11 -o count-patterns count-patterns.cpp

Uso:

./count-patterns pattern-list.txt word-list.txt

    

Answer 4

Aqui está um programa awk que deve fazer o que você procura:

Código:

BEGIN {FS="*"}
FNR==NR {a[$0]=0; next}
{for (i=1; i<=NF; i++) if ($i in a) a[$i]++}
END {
    for (i in a) {
        print i, a[i]
    }
}

Como?

1. Defina o campo seperaotr como *
2. FNR==NR {a[$0]=0; next} carrega as palavras para combinar na matriz a
3. Para cada linha, teste e incremente se o campo entre * estiver em a
4. Imprimir a no bloco END

Executar com:

awk -f test.awk fileA DB

Resultados:

ABCD 2
HIJKL 0
EFG 3
MNO 0
PQRSTU 0