Wie zähle ich die Nummer eines bestimmten Zeichens in jeder Zeile?

Ich habe mich gefragt, wie die Nummer eines bestimmten Zeichens in jeder Zeile von einigen Textverarbeitungsprogrammen gezählt werden soll.

Zum Beispiel, um "in jeder Zeile des folgenden Textes zu zählen

"hello!" 
Thank you!

Die erste Zeile hat zwei und die zweite Zeile hat 0.

Ein weiteres Beispiel ist das Zählen (in jeder Zeile.

Sie können es mit sedund tun awk:

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

Wo datist Ihr Beispieltext, sed löscht (für jede Zeile) alle Nicht- "Zeichen und awkdruckt für jede Zeile ihre Größe (dh lengthentspricht length($0), wo $0bezeichnet die aktuelle Zeile).

Für einen anderen Charakter müssen Sie nur den sed-Ausdruck ändern. Zum Beispiel für (:

's/[^(]//g'

Update: Ist sed eine Art Overkill für die Aufgabe - trist ausreichend. Eine äquivalente Lösung mit trist:

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

Das bedeutet, dass tralle Zeichen gelöscht werden, die nicht -cim Zeichensatz enthalten sind ( Komplement bedeuten) "\n.

Ich würde einfach awk benutzen

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

Hier setzen wir das Feldtrennzeichen (mit dem -F-Flag) auf das Zeichen, "dann drucken wir nur die Anzahl der Felder NF- 1. Die Anzahl der Vorkommen des Zielzeichens ist eins weniger als die Anzahl der getrennten Felder.

Für lustige Zeichen, die von der Shell interpretiert werden, müssen Sie nur sicherstellen, dass Sie sie maskieren. Andernfalls versucht die Befehlszeile, sie zu interpretieren. Also für beide "und )Sie müssen das Feldtrennzeichen (mit \) zu entkommen .

Mit trard wc:

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

Verwendungszweck:

$ 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

Noch eine andere Implementierung , die auf externe Programme nicht verlassen, in bash, zsh, yashund einige Implementierungen / Versionen ksh:

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

Verwenden line="${line//[!(]}"für die Zählung (.

Die Antworten mit awkfehlschlagen , wenn die Anzahl der Spiele zu groß ist (was meine Situation passiert sein). Für die Antwort von loki-astari wird folgender Fehler gemeldet:

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

Bei der Antwort von enzotib (und der Entsprechung von manatwork ) tritt ein Segmentierungsfehler auf:

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

Die sedLösung von maxschlepzig funktioniert korrekt, ist aber langsam (Timings unten).

Einige hier noch nicht vorgeschlagene Lösungen. Erstens mit grep:

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

Und mit perl:

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

Hier sind einige Zeitangaben für einige der Lösungen (am langsamsten bis am schnellsten geordnet). Ich habe mich hier auf Einzeiler beschränkt. 'foo.txt' ist eine Datei mit einer Zeile und einer langen Zeichenfolge, die 84922 Übereinstimmungen enthält.

## 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

Eine andere awkLösung:

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

Eine weitere mögliche Implementierung mit awk und gsub:

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

Die Funktion gsubentspricht der von sed 's///g'.

Verwenden gsub("[^(]", "")für die Zählung (.

Ich beschloss, ein C-Programm zu schreiben, weil ich gelangweilt war.

Sie sollten wahrscheinlich eine Eingabevalidierung hinzufügen, aber ansonsten ist alles festgelegt.

#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);
}

Für eine Zeichenfolge wäre die einfachste mit trund wc(kein Overkill mit awkoder sed) - aber beachten Sie die obigen Kommentare zu tr, zählt Bytes, nicht Zeichen -

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

Dabei $xhandelt es sich um die Variable, die die auszuwertende Zeichenfolge (keine Datei) enthält.

Hier ist eine andere C-Lösung, die nur STD C und weniger Speicher benötigt:

#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;
}

Wir können grepmit verwenden regex, um es einfacher und leistungsfähiger zu machen.

Um ein bestimmtes Zeichen zu zählen.

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

Zum Zählen von Sonderzeichen einschließlich Leerzeichen.

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

Hier wählen wir ein beliebiges Zeichen mit [\S\s]und mit der -oOption, dass wir grepjede Übereinstimmung (dh jedes Zeichen) in einer separaten Zeile ausgeben. Und dann verwenden, wc -lum jede Zeile zu zählen.

Vielleicht wäre eine einfachere, rein unkomplizierte Antwort die Verwendung von Split. Split nimmt einen String und verwandelt ihn in ein Array. Der Rückgabewert ist die Anzahl der generierten Array-Elemente + 1.

Der folgende Code gibt die Anzahl der Ausdrucke aus "wird in jeder Zeile angezeigt.

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

Weitere Informationen zu split http://www.staff.science.uu.nl/~oostr102/docs/nawk/nawk_92.html

Hier ist ein einfaches Python-Skript, mit dem Sie die Anzahl "in jeder Zeile einer Datei ermitteln können:

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

Hier haben wir die countMethode des eingebauten strTyps verwendet.

Für eine reine Bash-Lösung (jedoch bash-spezifisch): Wenn $xdie Variable Ihren String enthält:

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

Das ${x//Ding entfernt alle Zeichen außer ", ${#x2}berechnet die Länge dieser Pause.

(Ursprünglicher Vorschlag mit exprdem es Probleme gibt, siehe Kommentare:)

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

Ersetzen Sie adurch das zu zählende Zeichen. Ausgabe ist der Zähler für jede Zeile.

perl -nE 'say y!a!!'

Zeitvergleich der vorgestellten Lösungen (keine Antwort)

Die Effizienz der Antworten ist nicht wichtig. Trotzdem habe ich nach dem @ josephwb-Ansatz versucht, alle vorgestellten Antworten zeitlich abzustimmen.

Als Eingabe verwende ich die portugiesische Übersetzung von Victor Hugo "Les Miserables" (großes Buch!) Und zähle die Vorkommen von "a". Meine Ausgabe hat 5 Bände, viele Seiten ...

$ wc miseraveis.txt 
29331  304166 1852674 miseraveis.txt 

C-Antworten wurden mit gcc zusammengestellt (keine Optimierungen).

Jede Antwort wurde dreimal ausgeführt und die beste ausgewählt.

Vertraue diesen Zahlen nicht zu sehr (meine Maschine erledigt andere Aufgaben usw. usw.). Ich teile diese Zeiten mit Ihnen, weil ich einige unerwartete Ergebnisse habe und ich bin sicher, dass Sie noch mehr finden werden ...

• 14 von 16 zeitgesteuerten Lösungen dauerten weniger als 1 Sekunde. 9 weniger als 0,1s, viele von ihnen mit Rohren
• 2 Lösungen, die bash Zeile für Zeile verwenden, die 30.000 Zeilen verarbeiten, indem neue Prozesse erstellt werden. Berechnen Sie die richtige Lösung in 10s / 20s.
• grep -oP aist Baum mal schneller als grep -o a (10; 11 vs 12)
• Der Unterschied zwischen C und anderen ist nicht so groß, wie ich erwartet hatte. (7; 8 vs 2; 3)
• (Schlussfolgerungen erwünscht)

(ergibt eine zufällige Reihenfolge)

=========================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

wo grep all das schwere heben macht: meldet jedes Zeichen, das in jeder Zeilennummer gefunden wurde. Der Rest besteht nur darin, die Anzahl pro Zeile zu summieren und die Ausgabe zu formatieren.

Entfernen Sie die -nund erhalten Sie die Zählung für die gesamte Datei.

Das Zählen einer 1,5-Megabyte-Textdatei in weniger als 0,015 Sekunden scheint schnell zu sein.
Und arbeitet mit Zeichen (nicht Bytes).

Eine Lösung für Bash. Kein externes Programm aufgerufen (schneller für kurze Zeichenfolgen).

Wenn sich der Wert in einer Variablen befindet:

$ a='"Hello!"'

Dies gibt aus, wie viele "es enthält:

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