Agrupar e contar nomes de arquivos seguindo um padrão

Assumindo que seus nomes de arquivos são "bem comportados", ou seja, eles não contêm novas linhas, a seguinte combinação de lse awkfuncionaria:

ls -d my_file* | awk -F'_' 'NF==4{count[$3]++} END{for (i in count) printf "%s: %d\n", i, count[i]}'

Isso redirecionará a saída do lscomando que lista todos os arquivos que iniciam my_file*em um awkprograma. O awkprograma usará o _separador de campo as e verificará o 3º campo para rastrear a ocorrência em um array count, que usa o número do grupo como "índice do array".

Ao final, imprime uma visão geral de quantas vezes cada grupo ocorreu.

Perceber

• Existe uma proteção "mínima" contra nomes de arquivos completamente malformados, exigindo exatamente 4 desses campos. Isso pressupõe _que não pode fazer parte da parte a, d, f,... dos nomes de arquivo em seu exemplo.
• A saída não será necessariamente classificada de acordo com os nomes das categorias. A ordem de classificação dependerá de como awkpercorre os índices da matriz no for (i in count)loop. Se a classificação for desejada, você pode adicionar mais um pipe a sort. Alternativamente, se você usa GNU Awk, você pode adicionar uma configuração via

  BEGIN{PROCINFO["sorted_in"]="@ind_str_asc"}
  

  antes da NF==4{...}regra. Isso garantirá que os arrays sejam percorridos de acordo com o índice do array, classificados em ordem lexicográfica (ASCII).
• Isso funcionará com a limitação indicada no início e porque a estrutura do nome do arquivo é bastante simples. Em geral, é desencorajado analisar a saída de arquivosls .

for f in my_file_*_*.txt
do
    f="${f#my_file_}"
    printf "%s\n" "${f%%_*.txt}"
done |
sort |
uniq -c

O forloop reformata cada nome de arquivo fpara remover o inicial my_file_e o final _whatever.txt, depois classifica essa saída e usa uniqpara contar o número de ocorrências de cada valor exclusivo.

Eu o abordaria com um loop sobre um curinga e, em seguida, extrairia o campo do nome do arquivo com o recurso de expressão regular do bash em sua [[ construção de Expressão Condicional .

unset collect
declare -A collect
for f in ./*_*_*_*.txt
do 
  [[ $f =~ [^_]+_+[^_]+_+([^_]+)_+[^_]+.txt ]] &&
  ((collect["${BASH_REMATCH[1]}"]++))
done

for group in "${!collect[@]}"
do
  printf '%s: %d\n' "$group" "${collect["$group"]}"
done

O único campo entre parênteses é o terceiro delimitado por sublinhado; uma vez capturado, incrementamos esse valor em um array associativo ( collect).

Um nome de arquivo contendo quatro campos delimitados por sublinhado e terminando com a string .txté correspondido pelo padrão de globbing estendido +([!_])_+([!_])_+([!_])_+([!_]).txt. Cada +([!_])um corresponde a um ou mais caracteres sem sublinhado, assim como [^_]+faria com uma expressão regular estendida.

Podemos extrair o terceiro campo removendo os dois campos iniciais e o último campo junto com a .txtstring de sufixo.

#!/bin/bash

shopt -s extglob nullglob

names=( +([!_])_+([!_])_+([!_])_+([!_]).txt )
names=( "${names[@]#+([!_])_+([!_])_}" )
names=( "${names[@]%_+([!_]).txt}" )

printf '%s\n' "${names[@]}" | sort | uniq -c

O script assume apenas que o terceiro campo no nome do arquivo não contém novas linhas incorporadas.

Testando isso nos nomes de arquivos de exemplo na pergunta:

$ ls
list              my_file_A_f.txt   my_file_B_x.txt   my_file_D_g.txt
my_file_A_a.txt   my_file_A_t.txt   my_file_C_f.txt   my_file_E_r.txt
my_file_A_d.txt   my_file_B_r.txt   my_file_D_f.txt   script
$ ./script
   4 A
   2 B
   1 C
   2 D
   1 E

Você pode filtrar isso por meio de um awkscript simples para colocá-lo no formato que desejar.

$ ./script | awk '{ printf "%s: %d\n", $2, $1 }'
A: 4
B: 2
C: 1
D: 2
E: 1

Se seus nomes forem bem comportados, o que significa que não há caracteres de nova linha incorporados em nenhum deles, você pode simplificar um pouco o script e usar cutem vez disso.

#!/bin/bash

shopt -s extglob nullglob

printf '%s\n' +([!_])_+([!_])_+([!_])_+([!_]).txt |
cut -d _ -f 3 | sort | uniq -c

Usando Raku (anteriormente conhecido como Perl_6)

raku -e '.say for dir.split("_")[2,5,8...*].Bag.pairs.sort;'

Exemplo de entrada (lista de diretórios atual):

my_file_A_a.txt
my_file_A_d.txt
my_file_A_f.txt
my_file_A_t.txt
my_file_B_r.txt
my_file_B_x.txt
my_file_C_f.txt
my_file_D_f.txt
my_file_D_g.txt
my_file_E_r.txt

Saída de amostra:

A => 4
B => 2
C => 1
D => 2
E => 1

Como uma breve explicação, a listagem de diretórios atual dir()é obtida e dividida em _sublinhado. [Os nomes dos arquivos não começam/terminam com _sublinhado]. Os elementos obtidos são assim:

raku -e 'dir.split("_").raku.say;'

("my", "file", "A", "a.txt my", "file", "A", "d.txt my", "file", "A", "f.txt my", "file", "A", "t.txt my", "file", "B", "r.txt my", "file", "B", "x.txt my", "file", "C", "f.txt my", "file", "D", "f.txt my", "file", "D", "g.txt my", "file", "E", "r.txt").Seq

Depois disso, o Raku tem um mecanismo bastante robusto para gerar/compreender sequências: simplesmente digitar [2,5,8...*]permite extrair as letras A,B,C,D,E(a cada terceiro elemento, a numeração começa em 0). Então Bag, pairs, e sort.

(Se você tem certeza que não tem espaços em branco em seus nomes de arquivos, você pode adicionar uma segunda chamada split(" ")após a primeira. Então os elementos que você retiraria seriam [2,6,10...*]).

NOTA 1: Se você tiver nomes de arquivos estranhos que não se encaixam no padrão listado pelo OP (e estão atrapalhando suas contagens), você pode alterar odir chamada para algo como dir(test => / [ <-[_]>+ _ ] ** 3 /)subconjuntos de nomes de arquivos em um regex onde um ou mais os não sublinhados são seguidos por um sublinhado, repetido três vezes.

NOTA 2: Se você quiser duas colunas de saída (sem =>intermediários), basta alterar .saypara .put. Ou se você preferir uma saída mais 'Raku-ish', tente usar .raku.say, que retorna o seguinte:

:A(4)
:B(2)
:C(1)
:D(2)
:E(1)

https://docs.raku.org/routine/dir
https://docs.raku.org/type/Bag
https://raku.org

Ordenar, sed e uniq o suficiente:

ls |grep my_file | sed "s/.*_.*_\(.*\)_.*txt/\1/"|sort |uniq -c|sed "s/[^0-9]*\([0-9]*\) \(.*\)/\2: \1/"

Outro oneliner, apenas 3 variáveis:

count=0;chchange="dummy";ls | sed -n "s/.*my_file.*_\(.*\)_.*txt/\1/p"|sort|cat - <(echo end) |while read a ; do  if [ $a == $chchange ] ; then  ((count++));else if [ $chchange != "dummy" ] ;then  echo "$chchange $count"; fi; count=1; chchange=$a; fi;  done;

Precisa colocar uma linha extra na saída de classificação.