Como contar o número de um caractere específico em cada linha?

Eu queria saber como contar o número de um caractere específico em cada linha por alguns utilitários de processamento de texto?

Por exemplo, para contar "em cada linha do texto a seguir

"hello!" 
Thank you!

A primeira linha tem dois e a segunda linha tem 0.

Outro exemplo é contar (em cada linha.

Você pode fazer isso com sede awk:

$ sed 's/[^"]//g' dat | awk '{ print length }'
2
0

Onde datestá o texto de exemplo, sed exclui (para cada linha) todos os não "caracteres e awkimprime para cada linha seu tamanho (ou seja, lengthé equivalente a length($0), onde $0denota a linha atual).

Para outro personagem, você apenas precisa alterar a expressão sed. Por exemplo, para (:

's/[^(]//g'

Atualização: sed é um exagero para a tarefa - tré suficiente. Uma solução equivalente com tré:

$ tr -d -c '"\n' < dat | awk '{ print length; }'

Significa que trexclui todos os caracteres que não estão ( -csignifica complemento) no conjunto de caracteres "\n.

Eu usaria apenas awk

awk -F\" '{print NF-1}' <fileName>

Aqui, definimos o separador de campos (com o sinalizador -F) como o caractere; "tudo o que fazemos é imprimir o número de campos NF- 1. O número de ocorrências do caractere de destino será um a menos que o número de campos separados.

Para personagens engraçados que são interpretados pelo shell, você só precisa escapar deles, caso contrário a linha de comando tentará interpretá-los. Portanto, para ambos "e )você precisa escapar do separador de campos (com \).

Usando trard wc:

function countchar()
{
    while IFS= read -r i; do printf "%s" "$i" | tr -dc "$1" | wc -m; done
}

Uso:

$ countchar '"' <file.txt  #returns one count per line of file.txt
1
3
0

$ countchar ')'           #will count parenthesis from stdin
$ countchar '0123456789'  #will count numbers from stdin

No entanto, outra aplicação que não depende de programas externos, em bash, zsh, yashe algumas implementações / versões de ksh:

while IFS= read -r line; do 
  line="${line//[!\"]/}"
  echo "${#line}"
done <input-file

Use line="${line//[!(]}"para contar (.

As respostas que usam awkfalham se o número de correspondências for muito grande (que é a minha situação). Para a resposta de loki-astari , o seguinte erro é relatado:

awk -F" '{print NF-1}' foo.txt 
awk: program limit exceeded: maximum number of fields size=32767
    FILENAME="foo.txt" FNR=1 NR=1

Para a resposta do enzotib (e o equivalente do manatwork ), ocorre uma falha de segmentação:

awk '{ gsub("[^\"]", ""); print length }' foo.txt
Segmentation fault

A sedsolução de maxschlepzig funciona corretamente, mas é lenta (intervalos abaixo).

Algumas soluções ainda não sugeridas aqui. Primeiro, usando grep:

grep -o \" foo.txt | wc -w

E usando perl:

perl -ne '$x+=s/\"//g; END {print "$x\n"}' foo.txt

Aqui estão alguns horários para algumas das soluções (ordenadas do mais lento para o mais rápido); Limitei as coisas a one-liners aqui. 'foo.txt' é um arquivo com uma linha e uma sequência longa que contém 84922 correspondências.

## sed solution by [maxschlepzig]
$ time sed 's/[^"]//g' foo.txt | awk '{ print length }'
84922
real    0m1.207s
user    0m1.192s
sys     0m0.008s

## using grep
$ time grep -o \" foo.txt | wc -w
84922
real    0m0.109s
user    0m0.100s
sys     0m0.012s

## using perl
$ time perl -ne '$x+=s/\"//g; END {print "$x\n"}' foo.txt
84922
real    0m0.034s
user    0m0.028s
sys     0m0.004s

## the winner: updated tr solution by [maxschlepzig]
$ time tr -d -c '\"\n' < foo.txt |  awk '{ print length }'
84922
real    0m0.016s
user    0m0.012s
sys     0m0.004s

Outra awksolução:

awk '{print gsub(/"/, "")}'

Outra implementação possível com o awk e o gsub:

awk '{ gsub("[^\"]", ""); print length }' input-file

A função gsubé equivalente a sed's 's///g'.

Use gsub("[^(]", "")para contar (.

Decidi escrever um programa em C porque estava entediado.

Você provavelmente deve adicionar validação de entrada, mas fora isso está tudo pronto.

#include <stdio.h>
#include <string.h>

int main(int argc, char *argv[])
{
        char c = argv[1][0];
        char * line = NULL;
        size_t len = 0;
        while (getline(&line, &len, stdin) != -1)
        {
                int count = 0;
                char * s = line;
                while (*s) if(*s++ == c) count++;
                printf("%d\n",count);
        }
        if(line) free(line);
}

Para uma string, o mais simples seria com tre wc(não é necessário exagerar com awkou sed) - mas observe os comentários acima sobre tr, conta bytes, não caracteres -

echo $x | tr -d -c '"' | wc -m

onde $xé a variável que contém a sequência (não um arquivo) a ser avaliada.

Aqui está outra solução C que precisa apenas de STD C e menos memória:

#include <stdio.h>

int main(int argc, char **argv)
{
  if (argc < 2 || !*argv[1]) {
    puts("Argument missing.");
    return 1;
  }
  char c = *argv[1], x = 0;
  size_t count = 0;
  while ((x = getc(stdin)) != EOF)
    if (x == '\n') {
      printf("%zd\n", count);
      count = 0;
    } else if (x == c)
      ++count;
  return 0;
}

Podemos usar grepcom regexpara torná-lo mais simples e poderoso.

Contar caracteres específicos.

$ grep -o '"' file.txt|wc -l

Para contar caracteres especiais, incluindo caracteres de espaço em branco.

$ grep -Po '[\W_]' file.txt|wc -l

Aqui, estamos selecionando qualquer caractere com [\S\s]e com a -oopção que fazemos greppara imprimir cada correspondência (ou seja, cada caractere) em uma linha separada. E então use wc -lpara contar cada linha.

Talvez uma resposta mais direta e puramente estranha seria usar split. Split pega uma string e a transforma em uma matriz, o valor de retorno é o número de itens da matriz gerados + 1.

O código a seguir imprimirá o número de vezes "aparece em cada linha.

awk ' {print (split($0,a,"\"")-1) }' file_to_parse

mais informações sobre http://www.staff.science.uu.nl/~oostr102/docs/nawk/nawk_92.html

Aqui está um script Python simples para encontrar a contagem de "em cada linha de um arquivo:

#!/usr/bin/env python2
with open('file.txt') as f:
    for line in f:
        print line.count('"')

Aqui nós usamos o countmétodo do strtipo interno.

Para uma solução de bash pura (no entanto, é específica do bash): If $xé a variável que contém sua string:

x2="${x//[^\"]/}"
echo ${#x2}

A ${x//coisa remove todos os caracteres ", exceto , ${#x2}calcula a duração desse descanso.

(Sugestão original usando exprproblemas, consulte os comentários:)

expr length "${x//[^\"]/}"

Substitua apelo caractere a ser contado. Saída é o contador para cada linha.

perl -nE 'say y!a!!'

Comparação temporal das soluções apresentadas (não uma resposta)

A eficiência das respostas não é importante. No entanto, seguindo a abordagem @josephwb, tentei cronometrar todas as respostas apresentadas.

Utilizo como entrada a tradução em português de Victor Hugo "Les Miserables" (ótimo livro!) E conto as ocorrências de "a". Minha edição tem 5 volumes, muitas páginas ...

$ wc miseraveis.txt 
29331  304166 1852674 miseraveis.txt 

As respostas em C foram compiladas com o gcc (sem otimizações).

Cada resposta foi executada 3 vezes e escolha a melhor.

Não confie demais nesses números (minha máquina está realizando outras tarefas, etc.). Partilho esses momentos com você, porque obtive resultados inesperados e tenho certeza de que encontrará mais ...

• 14 de 16 soluções temporizadas levaram menos de 1s; 9 menos que 0,1s, muitos deles usando canos
• 2 soluções, usando bash linha por linha, processaram as linhas de 30k criando novos processos, calcule a solução correta em 10s / 20s.
• grep -oP aé o tempo da árvore mais rápido que grep -o a (10; 11 vs 12)
• A diferença entre C e outros não é tão grande quanto eu esperava. (7; 8 vs 2; 3)
• (conclusões bem-vindas)

(resulta em uma ordem aleatória)

=========================1 maxschlepzig
$ time sed 's/[^a]//g' mis.txt | awk '{print length}' > a2
real    0m0.704s ; user 0m0.716s
=========================2 maxschlepzig
$ time tr -d -c 'a\n' < mis.txt | awk '{ print length; }' > a12
real    0m0.022s ; user 0m0.028s
=========================3 jjoao
$ time perl -nE 'say y!a!!' mis.txt  > a1
real    0m0.032s ; user 0m0.028s
=========================4 Stéphane Gimenez
$ function countchar(){while read -r i; do echo "$i"|tr -dc "$1"|wc -c; done }

$ time countchar "a"  < mis.txt > a3
real    0m27.990s ; user    0m3.132s
=========================5 Loki Astari
$ time awk -Fa '{print NF-1}' mis.txt > a4
real    0m0.064s ; user 0m0.060s
Error : several -1
=========================6 enzotib
$ time awk '{ gsub("[^a]", ""); print length }' mis.txt > a5
real    0m0.781s ; user 0m0.780s
=========================7 user606723
#include <stdio.h> #include <string.h> // int main(int argc, char *argv[]) ...  if(line) free(line); }

$ time a.out a < mis.txt > a6
real    0m0.024s ; user 0m0.020s
=========================8 maxschlepzig
#include <stdio.h> // int main(int argc, char **argv){if (argc < 2 || !*argv[1]) { ...  return 0; }

$ time a.out a < mis.txt > a7
real    0m0.028s ; user 0m0.024s
=========================9 Stéphane Chazelas
$ time awk '{print gsub(/a/, "")}'< mis.txt > a8
real    0m0.053s ; user 0m0.048s
=========================10 josephwb count total
$ time grep -o a < mis.txt | wc -w > a9
real    0m0.131s ; user 0m0.148s
=========================11 Kannan Mohan count total
$ time grep -o 'a' mis.txt | wc -l > a15
real    0m0.128s ; user 0m0.124s
=========================12 Kannan Mohan count total
$ time grep -oP 'a' mis.txt | wc -l > a16
real    0m0.047s ; user 0m0.044s
=========================13 josephwb Count total
$ time perl -ne '$x+=s/a//g; END {print "$x\n"}'< mis.txt > a10
real    0m0.051s ; user 0m0.048s
=========================14 heemayl
#!/usr/bin/env python2 // with open('mis.txt') as f: for line in f: print line.count('"')

$ time pyt > a11
real    0m0.052s ; user 0m0.052s
=========================15 enzotib
$ time  while IFS= read -r line; do   line="${line//[!a]/}"; echo "${#line}"; done < mis.txt  > a13
real    0m9.254s ; user 0m8.724s
=========================16 bleurp
$ time awk ' {print (split($0,a,"a")-1) }' mis.txt > a14
real    0m0.148s ; user 0m0.144s
Error several -1

grep -n -o \" file | sort -n | uniq -c | cut -d : -f 1

onde grep faz todo o trabalho pesado: relata cada caractere encontrado em cada número de linha. O resto é apenas para somar a contagem por linha e formatar a saída.

Remova o -ne obtenha a contagem para o arquivo inteiro.

Contar um arquivo de texto de 1,5Meg em menos de 0,015 segundos parece rápido.
E funciona com caracteres (não bytes).

Uma solução para o bash. Nenhum programa externo é chamado (mais rápido para cadeias curtas).

Se o valor estiver em uma variável:

$ a='"Hello!"'

Isso imprimirá quantas "contém:

$ b="${a//[^\"]}"; echo "${#b}"
2