Contar valores exclusivos em uma coluna com base em uma duplicata em outra coluna

Isso awkdeve funcionar para você:

awk '{
   uq[$0]                 # counts of full record
}
END {
   for (i in uq) {        # store frequency of uniques in fq
      sub(/ .*/, "", i)
      ++fq[i]
   }
   for (i in fq)          # print output from fq
      print i, fq[i]
}' file

CCCCCC 1
ABCDEF 2
DEF123 1
ABC123 2

Isso está perto o suficiente?

$ sort -u file.txt | cut -d' ' -f1 | uniq -c
   2 ABC123
   2 ABCDEF
   1 CCCCCC
   1 DEF123

Você pode filtrá-lo ainda mais com a | grep -vw '1'para imitar a HAVING COUNT(DISTINCT value) > 1semântica e eliminar as duas últimas linhas da saída neste exemplo (assumindo que esse não1 é um valor legal para um identificador!).

E é claro que você pode inverter a ordem das colunas de várias maneiras. Por exemplo

$ sort -u file.txt  |        # sort and eliminate multiple occurrences of the same '<identifier> <value>' pair
    cut -d' ' -f1   |        # keep only the identifier
    uniq -c         |        # collapse and count occurrences of the same identifier
    grep -vw '1'    |        # eliminate rows containing the word '1', assuming this can only be a count value, never an identifier!
    awk '{print $2 " " $1}'  # reverse column order to show '<identifier> <count>'
ABC123 2
ABCDEF 2

Com qualquer awk:

awk '
    !seen[$0]++ {++uniqs[$1]}
    END {for(id in uniqs) print id, uniqs[id]}
' file.txt

ou se o espaço em branco entre os campos puder variar, ainda usando qualquer awk:

awk '
    !seen[$1,$2]++ {++uniqs[$1]}
    END {for(id in uniqs) print id, uniqs[id]}
' file.txt

ou com GNU awk (para matrizes multidimensionais):

awk '
    !seen[$1][$2]++ {++uniqs[$1]}
    END {for(id in uniqs) print id, uniqs[id]}
' file.txt

DEF123 1
ABC123 2
ABCDEF 2
CCCCCC 1

Suposições:

• cada linha tem 2 strings delimitadas por espaço
• linhas duplicadas são verdadeiramente duplicadas (por exemplo, elas têm a mesma quantidade de espaços em branco iniciais, incorporados e finais)

Outra awkabordagem:

awk '
    { lines[$0] }                            # capture unique lines
END { for (line in lines) {                  # loop through list of unique lines
          split(line,a)                      # split line on white space
          counts[a[1]]++                     # count number of times we see the first field (aka "id")
      }
      for (id in counts)                     # loop through list of id
          print id, counts[id]               # print id and count
    }
' file.txt

Isso gera:

ABC123 2
DEF123 1
ABCDEF 2
CCCCCC 1

Se a saída precisar ser ordenada, canalize os resultados para o sortcomando apropriado, por exemplo:

$ awk '<see script from above>' file.txt | sort -k2,2nr -k1,1r
ABCDEF 2
ABC123 2
CCCCCC 1
DEF123 1

Aqui está um Ruby para fazer isso:

ruby -lane 'BEGIN{ cnt=Hash.new{|h,k| h[k]=[]} }
cnt[$F[0]]<<$F[1]
END{
    cnt.select{|k,v| v.length>1 }.
        each{|k,v| puts "#{k} #{v.uniq.length}"} 
}
' file.txt

Impressões:

ABC123 2
ABCDEF 2
DEF123 1

Não está claro se CCCCCC 1deveria estar na saída. Nesse caso, não há necessidade de filtrar:

ruby -lane 'BEGIN{ cnt=Hash.new{|h,k| h[k]=[]} }
cnt[$F[0]]<<$F[1]
END{ cnt.each{|k,v| puts "#{k} #{v.uniq.length}"} }
' file.txt

Impressões:

ABC123 2
ABCDEF 2
CCCCCC 1
DEF123 1

Você também pode fazer este canal POSIX:

sort -u file.txt | awk '{cnt[$1]++} END{for (e in cnt) print e, cnt[e]}'

Ou use awkapenas para eliminar a necessidade de uniqifing com sort -u:

awk '!seen[$0]++ {cnt[$1]++} END{for (e in cnt) print e, cnt[e]}' file.txt

Qualquer uma dessas impressões (talvez em ordem diferente):

CCCCCC 1
ABCDEF 2
DEF123 1
ABC123 2

Eu aproveitaria o GNU AWKpara esta tarefa da seguinte maneira, deixe file.txto conteúdo ser

ABC123 111111
ABC123 111111
ABCDEF 333333
ABCDEF 111111
CCCCCC 333333
ABC123 222222
DEF123 444444
DEF123 444444

então

awk '{arr[$1][$2]}END{for(i in arr){print i,length(arr[i])}}' file.txt

dá saída

DEF123 1
ABC123 2
ABCDEF 2
CCCCCC 1

Explicação: Eu uso um array 2D arr, mas sem armazenar nenhum valor (apenas chaves), então itero sobre a alavanca superior e para cada um detectei o número de subchaves usando lengtha função. Se você precisar de uma certa ordem na saída definida PROCINFO["sorted_in"]como BEGINuma ordem de digitalização de matriz predefinida, por exemplo

awk 'BEGIN{PROCINFO["sorted_in"]="@ind_str_asc"}{arr[$1][$2]}END{for(i in arr){print i,length(arr[i])}}' file.txt

dará saída

ABC123 2
ABCDEF 2
CCCCCC 1
DEF123 1

ou seja, ordem lexicográfica ascendente

(testado em GNU Awk 5.1.0)

Como eu faria algo assim no Bash?

Com basho uso de array associativo que (na minha opinião) é uma versão pobre da awkabordagem de mark markp-fuso.

declare -A id_value id_count

# Read each line from the file, splitting into id and value
while read -r id value; do
  id_value["$id $value"]=1  # Store the unique ID-value pair
done < file.txt

# Count unique values for each ID
for key in "${!id_value[@]}"; do
  id="${key%% *}"            # Extract the ID from the key
  ((id_count["$id"]++))      # Increment the count for this ID
done

##: declare -p id_count

# Print the results
for id in "${!id_count[@]}"; do
  printf '%s %s\n' "$id" "${id_count["$id"]}"
done

• Será muito, muito lento em dados/arquivos grandes.

• Consulte Problema com contexto aritmético de matriz associativa