Насколько вы подвержены тупняку, и немного holywar

<?php 
$file = file_get_contents('pg2600.txt');
preg_match_all("/[a-zA-Z]+/", $file, $matches);
$result = array_count_values($matches[0]);
var_dump($result);

$result = array_filter($result, function($el) use ($n) {
    return $el == $n;
});

if x in d:
    d[x] += 1
else:
    d[x] = 1

d.setdefault(x, 0) += 1

[k for k,v in d.items() if v == n]

[k for k,v in d.iteritems() if v == n]

import re
from collections import Counter

n = 5

c = Counter(re.findall(r'\w+', open("pg2600.txt", "r").read()))

print repr([k for k, v in c.items() if v == n])

#!/usr/bin/env python
import re

N = 5

with open('pg2600.txt', 'r') as f:
    word_list = re.findall(r'\w+', f.read())

def reduce_func(x, y):
	for key in y:
		x[key] = x.get(key, 0) + y[key]
	return x

mr_result = reduce(reduce_func, map(lambda x: {x: 1}, word_list))

print filter(lambda x: mr_result[x] == N, mr_result.keys())

#include <iostream>
#include <stdio.h>
#include <unordered_map>
#include <sys/time.h>

using namespace std;
bool delimiter[255] = {false};
unordered_map<string, int> mmap;
int main(int argc, const char * argv[])
{
    int N = 5;
    if (argc > 1)
    {
        N = atoi(argv[1]);
    }
    
    FILE * pFile = fopen("pg2600.txt", "r");
    
    struct timeval tv;
    gettimeofday(&tv,NULL);
    long startTime = tv.tv_sec * 1e6 + tv.tv_usec;
    
    char delim[] = {' ', ';', '!', ',', '.', ':', '\n', '\r', '?', '"', '(', ')', '\'', '-', '*'};
    for (int i = 0; i < sizeof(delim) / sizeof(char); i++)
    {
        delimiter[delim[i]] = true;
    }
    
    fseek (pFile , 0 , SEEK_END);
    long lSize = ftell (pFile);
    rewind (pFile);
    char * text = new char[lSize];
    fread(text, sizeof(char), lSize, pFile);
    long pos = 0, begin = 0, end = 0;
    
    while (pos < lSize)
    {
        if (delimiter[text[pos]])
        {
            pos++;
            continue;
        }
        begin = pos++;
        while (pos < lSize)
        {
            end = pos;
            if (delimiter[text[pos]])
            {
                pos++;
                break;
            }
            pos++;
        }
        string str(text + begin, text + end);
        mmap[str]++;
    }
    unordered_map<string, int>::iterator b = mmap.begin(), e = mmap.end();
    int count = 0;
    for (; b != e; b++)
    {
        if (b->second == N)
        {
            printf("%s, ", b->first.c_str());
            count++;
        }
    }
    
    gettimeofday(&tv,NULL);
    long endtime = tv.tv_sec * 1e6 + tv.tv_usec;
    printf("\nTotal: %d\nTime: %f\n",count, ((double)(endtime - startTime)) / 1e6);
    return 0;
}

#!/bin/sh
cat pg2600.txt | tr ' .,?:;' '\n' | sort | uniq -c | grep '^\s*5\s'

#!/usr/bin/env perl
use strict;

open my $fh, "<", "./input_file.txt" or die $!;
my $str = do {local $/; <$fh> };
my $n = 5;

my %h;
$h{$1}++ while $str =~ /(\w+)/g;

my $res;
for my $w (keys %h) {
    $res .= "$w, " if $h{$w} == $n;
}

print "$res\n";

real    0m0.427s
user    0m0.413s
sys     0m0.013s

real    0m0.567s
user    0m0.544s
sys     0m0.021s

require('fs').readFile('pg2600.txt', 'utf-8', function (error, text) {
    var N = 50,
        matches = {},
        item,
        k,
        len,
        result;

    result = text.match(/\w+/ig);

    for (k = 0, len = result.length; k < len; k += 1) {
        matches[result[k]] = (matches[result[k]] || 0) + 1;
    }

    for (item in matches) {
        if (matches[item] === N) {
            console.log(item + " :: " + matches[item]);
        }
    }
});

real	0m0.464s
user	0m0.428s
sys	0m0.035s

public class App 
{
    public static void main( String[] args ) throws IOException
    {
        Map<String, Holder> words = new HashMap<>(20000);
        Pattern p = Pattern.compile("\\w+", Pattern.CASE_INSENSITIVE);
        int n = Integer.parseInt(args[1]);
        
        try (BufferedReader in = new BufferedReader(new FileReader(args[0]), 6000)) {
	  try (PrintWriter out = new PrintWriter(new BufferedOutputStream(System.out, 6000))) {
            
            String line = null;
            while(( line = in.readLine()) != null ) {
                Matcher m = p.matcher(line);
                while(m.find()) {
                    Holder holder = words.get(m.group());
                    if (holder != null) {
                        holder.num++;
                        if (holder.num == n) {
                            out.println(m.group());
                        }
                    } else {
                        words.put(m.group(), new Holder());
                    }
                }
            }
        }}
        
    }
    
    private static class Holder {
      
      int num = 1;
      
    }
}

time java -cp ./target/classes/ com.qitsoft.warandpeace.App /home/serj/Documents/pg2600.txt 5

real    0m0.257s
user    0m0.388s
sys     0m0.024s

#!/usr/bin/perl
$N=5;$,=", ";print(grep{$Y{$_}==$N}keys(do{($X=do{open X,'<pg2600.txt';local$/;<X>})=~s/(\w+)/$Y{$1}++/ge;\%Y}))

#!/usr/bin/env perl

my $n = 5;
my %words;

open FH,'<','/tmp/pg2600.txt';
local $/;
while (<FH>) { $words{$_}++ for (split /\W+/) };

print '['.(join ", ", grep {$words{$_} == $n} keys %words).']';

fs = require("fs")
re = /\w+/ig
N = 5

await fs.readFile "input_file.txt", "utf8", defer err, data

words = {}
while word = re.exec(data)?[0]
  words[word] = (words[word] || 0) + 1

for word, count of words
  console.log(word) if N == count

from collections import Counter
import re
n = 5
f = open('pg2600.txt', 'r')
text = f.read().lower()
f.close()
c = Counter(re.findall(r'\w+', text))
print repr([word for word in c if c[word] == n])

#test3.py
def test1():
    n = 5
    with open("./pg2600.txt", "r") as f:
        s = f.read()
    d={}
    for x in re.findall(r'\w+',s):
        if x in d:
            d[x] += 1
        else:
            d[x] = 1
    print repr([k for k,v in d.items() if v == n])
#чуть модифицированный test3.py
def test2():
    n = 5
    with open("./pg2600.txt", "r") as f:
        s = f.read()
    d=defaultdict(int)
    for x in re.findall(r'\w+',s):
        d[x] += 1
    print repr([k for k,v in d.items() if v == n])

test1 : 0.518
test2 : 0.468

import sys
import re
from collections import defaultdict

n     = int(sys.argv[1])
fname = sys.argv[2]
d     = defaultdict(int)
regex = re.compile(r'\w+')

with open(fname, 'rb') as f:
    for line in f:
        for match in regex.finditer(line):
            d[match.group()] += 1

print '\n'.join((k for k, v in d.iteritems() if v == n))

Моё:   0,65s user 0,01s system 99% cpu 0,663 total
test3: 0,37s user 0,02s system 97% cpu 0,401 total

import string
from collections import defaultdict


def main():
    n = 5
    s = '.-;:,/\'"?!()*\n'
    tr = string.maketrans(s, ' '*len(s))
    f = string.translate(open('pg2600.txt').read().lower(), tr)
    acc = defaultdict(int)
    for i in f.split():
        acc[i] += 1
    for k,v in acc.iteritems():
        if v == n:
            print k

main()

package main

import (
	"bufio"
	"fmt"
	"log"
	"os"
	"strings"
	"unicode"
)

const (
	fileName = "input_file.txt"
	N        = 1000
)

func main() {
	wordsMap := make(map[string]int)
	file, err := os.Open(fileName)
	if err != nil {
		log.Fatal(err)
	}
	defer file.Close()

	scanner := bufio.NewScanner(file)
	for scanner.Scan() {
		str := scanner.Text()
		words := strings.Fields(str)
		for _, word := range words {
			word := strings.TrimRightFunc(strings.ToLower(word), unicode.IsPunct)
			if len(word) > 0 {
				if _, ok := wordsMap[word]; ok {
					wordsMap[word] += 1
				} else {
					wordsMap[word] = 1
				}
			}
		}
	}

	if err := scanner.Err(); err != nil {
		log.Fatal(err)
	}

	for word, count := range wordsMap {
		if count > N {
			fmt.Println(word, ":", count)
		}
	}
}

real	0m0.337s
user	0m0.325s
sys	0m0.009s