简单错误记录

import java.util.*;
public class Main {
	public static void main(String[] args) {
		Scanner sc = new Scanner(System.in);
		Map<String, Integer> map = new LinkedHashMap<>();
		while (sc.hasNextLine()) {
			String s = sc.nextLine();
			if(s == null || "".equals(s)) break;
			String[] split = s.split("\\s");
			String key = split[0].substring(split[0].lastIndexOf('\\') + 1) + " " + split[1];
			map.put(key, map.containsKey(key) ? map.get(key) + 1 : 1);
		}
		List<Map.Entry<String, Integer>> list = new ArrayList<>(map.entrySet());
		Collections.sort(list, new Comparator<Map.Entry<String, Integer>>() {
			@Override
			public int compare(Map.Entry<String, Integer> o1, Map.Entry<String, Integer> o2) {
				return o2.getValue().compareTo(o1.getValue());
			}
		});
		for (int i = 0; i < 8; i ++) {
			String[] split = list.get(i).getKey().split("\\s");
			if(split[0].length() > 16) split[0] = split[0].substring(split[0].length() - 16);
			System.out.println(split[0] + " " + split[1] + " " + list.get(i).getValue());
		}
	}
}

只要知道可以使用文件名加上行数作为map的key，此题不难的

import java.util.*;

/**
 * 华为02-简单错误记录
 *
 * 第一次思路：因为一直在想如何使文件名如何对应多个行数的解决方法，卡了好多大会
 * 就这样越想越复杂，但是基本思路有了。
 * 就是用一个map记录文件名及其对应的在list中索引（由自增序号自动生成）。
 * list是用来存放新建的不重复的错误。
 * 这样我们每次对于一个新的错误，首先看map中是否有
 * 若有，我们通过索引找到list中的对应node，更新其次数
 * 若没有，map中存放文件名及其自增序号，同时在list中添加一条新的错误记录
 * 最后我们排序，取出前8个即可。
 * 
 * 技巧：
 * 1.如何解决文件名如何对应多个行数
 * 我擦，直接令文件名加上行数当成key就可以了啊！！！太妙了
 * 2.我们只需在list中添加错误记录时，注意要对超过16的处理一下
 * 3.Collection.sort()可以使用lambda表达式哦
 * Create by Special on 2018/2/14 22:01
 */
public class Main {

    static Map<String, Integer> fileOriginName;
    static List<Node> nodes = new ArrayList<>();

    static class Node{
        String name;
        int count;

        public Node(String name){
            this.name = name;
            this.count = 1;
        }

        public void add(int value){
            count += value;
        }
    }

    public static void main(String[] args) {
        Scanner input = new Scanner(System.in);
        fileOriginName = new HashMap<>();
        String fileName;
        int count = 0, index;
        while(input.hasNext()){
            fileName = input.nextLine();
            fileName = fileName.substring(fileName.lastIndexOf('\\') + 1);
            if(fileOriginName.containsKey(fileName)){
                nodes.get(fileOriginName.get(fileName)).add(1);
            } else{
                fileOriginName.put(fileName, count++);
                index = fileName.indexOf(' ');
                fileName = index > 16 ? fileName.substring(index - 16) : fileName;
                nodes.add(new Node(fileName));
            }
        }
        Collections.sort(nodes, (node1, node2) -> {
            return node2.count - node1.count;
        });
        Node node;
        for(int i = 0; i < Math.min(8, nodes.size()); i++){
            node = nodes.get(i);
            System.out.println(node.name + " " + node.count);
        }
    }
}

#include<iostream>
#include<string.h>
#include<memory.h>

using namespace std;
struct SRecord
{
	int cnterror;
	int lineNum;
	char fileName[17];
	char fileNameNumstr[40];
	SRecord *next;
};
int Insert(SRecord *head,SRecord *pSR)
{
	SRecord *cur=head->next;
	SRecord *preCur=head;
	while (cur)
	{
		if(!strcmp(cur->fileNameNumstr,pSR->fileNameNumstr))
		{
			cur->cnterror++;
			return 0;
		}
		preCur=cur;
		cur=cur->next;
	}
	pSR->cnterror++;
	preCur->next=pSR;
	pSR->next=nullptr;
	return 1;
}
void print(SRecord *head)
{
	if(!head->next)
		return ;
	SRecord *cur=head->next;
	SRecord *maxp=cur;
	SRecord *preMax=head;
	SRecord *preCur=head;
	while (cur)
	{
		if(cur->cnterror>maxp->cnterror)
		{
			preMax=preCur;
			maxp=cur;
		}
		preCur=cur;
		cur=cur->next;
	}
		cout<<maxp->fileName<<' '<<maxp->lineNum<<' '<<maxp->cnterror<<endl;
		preMax->next=maxp->next;
		delete maxp;
}
void desSR(SRecord *head)
{
	SRecord *cur=head;
	head=head->next;
	delete cur;
	while (head)
	{
		cur=head;
		head=head->next;
		delete cur;
	}
}
int main()
{
	char str[200];
	SRecord *pSR;
	SRecord *head=new SRecord;
	head->next=nullptr;
	while (cin.getline(str,sizeof(str)))
	{
		if (!strlen(str))
		{
			break;
		}
		char *token,*laststr;
		token=strtok(str,"\\");
		laststr=token;
		while (token)
		{
			laststr=token;
			token=strtok(nullptr,"\\");
		}

		pSR=new SRecord;
		memset(pSR,0,sizeof(SRecord));
		strcpy(pSR->fileNameNumstr,laststr);
		token=strtok(laststr," ");
		char fileNamestr[40],*pfileNamestr=token;
		strcpy(fileNamestr,token);
		int fileNamelen=strlen(fileNamestr);
		if(fileNamelen>=17)
		{
			fileNamelen-=16;
			pfileNamestr+=fileNamelen;
		}

		strcpy(pSR->fileName,pfileNamestr);
		token=strtok(nullptr," ");
		pSR->lineNum=atoi(token);
		
		//cout<<laststr<<endl<<pSR->fileName<<endl<<pSR->lineNum<<endl;	
		Insert(head,pSR);
	}
	for(int i=0;i<8;++i)
	print(head);

	desSR(head);
	//system("PAUSE");
	return 0;
}

#include <stdio.h>
#include <iostream>
#include <string.h>
#include <stdlib.h>
using namespace std;

typedef struct re{
    char docinfo[100];//文件名
	char ronu[10];//错误行号
    int docdisplaypos;//要从哪里开始展示文件
    int repos;//错误的初始位置
    int errcnt;//错误数量
}Record;

void quicksort(Record re[],int start,int last){
	if(start>=last){
		return ;
	}
    int left = start,pos=left+1,right=last;
    Record pivot = re[start],tmp;
    while(left != right){
        if(re[pos].errcnt < pivot.errcnt){
            tmp = re[right];
            re[right--] = re[pos];
            re[pos] = tmp;
        }else if(re[pos].errcnt > pivot.errcnt){
            re[left++] = re[pos++];
        }else{
            if(re[pos].repos<pivot.repos){
                re[left++] = re[pos++]; 
            }else{
                tmp = re[right];
                re[right--] = re[pos];
                re[pos] = tmp;
            }
        }
    }
    re[left] = pivot;
    quicksort(re,start,left-1);
    quicksort(re,left+1,last);
}

/*测试用例
E:\V1R2\product\fpgadrivea.c1111 1325
E:\V1R2\product\fpgadrivea.c11112 125
E:\V1R2\product\fpgadrive.c 1325
E:\V1R2\productss\fpgadrive.c 1325
E:\V1R2\product\fpgadrivea.c11112 1335

*/

Record reco[100];

int main(void){
    char s[300],rownum[10];

    char *pdoc;
    int doclength;
    int recnt = 0;
    int hasflag;
    while(cin>>s>>rownum){
       pdoc = strrchr(s,'\\');

       hasflag = 0;
       for(int i = 0; i<recnt;i++){
           if( 0 == strcmp(pdoc+1,reco[i].docinfo)){
			   if( 0 == strcmp(rownum,reco[i].ronu)){
				   reco[i].errcnt++;
				   hasflag = 1;
				   break;
			   }
           }
       }
       if( 1 == hasflag){
           continue;
       }
       strcpy(reco[recnt].docinfo,pdoc+1);
       strcpy(reco[recnt].ronu,rownum);
	   
       reco[recnt].repos = recnt;
       doclength = strlen(reco[recnt].docinfo);
       if( doclength > 16 ){
           reco[recnt].docdisplaypos = doclength-16;
       }else{
           reco[recnt].docdisplaypos = 0;
       }
       reco[recnt].errcnt = 1;
       recnt++;
	   
    }
    quicksort(reco,0,recnt-1);
    recnt = recnt>8?8:recnt;
	for(int i=0;i<recnt;i++){
		printf("%s %s %d\n",&reco[i].docinfo[reco[i].docdisplaypos],reco[i].ronu,reco[i].errcnt);
			
	}
    return 0;
}

from collections import OrderedDict
def solution(lines):
    records = OrderedDict()  # 有序字典，便于后期稳定输出
    
    for e in lines:
        line = e.split()
        name = line[0].split('\\')[-1]
        if (name, line[1]) not in records:records[(name, line[1])] = 1
        else:records[(name, line[1])] += 1
    return records
    

import sys

try:
    while True:
        lines = sys.stdin.readlines()
        # print lines
        if not lines:
            break
        ret = solution(lines)
        # print ret
        #result = zip(ret.keys(), ret.values())
        result = sorted(ret.iteritems(),key=lambda x:x[1], reverse=True) # 本身按递增排序的结果就是不稳定的，reverse之后就满足了。。
        # print result
        # print result[:8]
        
        for e in result[:8]:
            if len(e[0][0]) > 16:print e[0][0][-16:],e[0][1],e[1]
            else: print e[0][0],e[0][1],e[1]
            
        
except:
    # print result
    pass

大家帮忙运行一下我的程序，为什么能得出结果，但是提交的时候说是程序有错误？ package com.huawei.subject;

import java.util.ArrayList;
import java.util.Collections;
import java.util.Comparator;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.Scanner;

public class RecordError {

	private static Map<String, Object> map;
	private static List<Map<String, Object>> list;

	public static void main(String args[]) {
		Scanner sc = new Scanner(System.in);
		String file, fileName, midFileName;
		int errorLine, errorCount, lastIndex;
		
		list = new ArrayList<Map<String, Object>>();
		while (sc.hasNext()) {  
			map = new HashMap<String, Object>();
			file = sc.next(); // 输入的原始文件名(包括路径)
			if (file.equals("quit")) {  //跳出循环
				break;
			}
			StringBuilder sb = new StringBuilder();
			lastIndex = file.lastIndexOf("\\");
			sb.append(file.substring(lastIndex + 1));
			fileName = sb.toString();
		//	System.out.println("---"+file);
			// if (midFileName.lastIndexOf(" ") - 16 > 0) {//
			// 如果文件名超过16位。则去后16位
			// lastIndex = midFileName.lastIndexOf(" ") - 16;
			// fileName = midFileName.substring(lastIndex);
			// } else {
			// fileName = midFileName; // 文件名
			// }
			errorLine = sc.nextInt();
			errorCount = 1;
			int flag = 0;
			for (int i = 0; i < list.size(); i++) {
				if (list.get(i).get("fileName").toString().equals(fileName)
						&& Integer.parseInt(list.get(i).get("errorLine").toString()) == errorLine) {
					errorCount = Integer.parseInt(list.get(i).get("errorCount").toString()) + 1;
					list.get(i).put("errorCount", errorCount);
					flag = 1;
				}
			}
			// map.put("errorCount", errorCount);
			if (flag == 0) {
				map.put("fileName", fileName);
				map.put("errorLine", errorLine);
				map.put("errorCount", errorCount);
				list.add(map);
			}

		}
		sc.close();
		for (int i = 0; i < list.size(); i++) {
			midFileName = list.get(i).get("fileName").toString();
			if (midFileName.lastIndexOf(" ") - 16 > 0) {// 如果文件名超过16位。则去后16位
				lastIndex = midFileName.lastIndexOf(" ") - 16;
				fileName = midFileName.substring(lastIndex);
				list.get(i).put("fileName", fileName);
			}
		}

		Comparator<Map<String, Object>> cmp = new Comparator<Map<String, Object>>() {  
			@Override
			public int compare(Map<String, Object> m1, Map<String, Object> m2) {
				return Integer.parseInt(m1.get("errorCount").toString())
						- Integer.parseInt(m2.get("errorCount").toString()) == 0 ? 0
								: Integer.parseInt(m2.get("errorCount").toString())
										- Integer.parseInt(m1.get("errorCount").toString());
			}
		};
		Collections.sort(list, cmp);
        if(list.size()<=8){
        	for (Map map : list) {
    			System.out.print(map.get("fileName") + " " + map.get("errorLine") + " " + map.get("errorCount")+"  ");

    		}
        }else{
        	for(int i=0;i<8;i++){
        		System.out.print(list.get(i).get("fileName") + " " + list.get(i).get("errorLine") + " " + list.get(i).get("errorCount")+" ");
        	}
        	
        }
		

	}
} 

/**
 * 好像Java答案不多，我来献丑吧。
 * 正如大家之前所说，这个题主要是考细节。所以我只说说代码的细节：
 *   1. 读到文件路径，先用substring截取文件名。
 *   2. 用Entry对象保存单个记录和出现次数。
 *   3. 用Map来区分是否为新纪录,这要求Entry重新equals和hashCode。
 *   4. 真正使用的是LinkedHashMap，使得遍历key时可以按照插入顺序遍历，满足了题目要求。
 *   5. Arrays.sort对引用类型采用插入排序+归并排序，保证了排序稳定性，满足了题目要求。
 *   6. Entry实现了Comparable接口，其实更好是写一个Comparator，因为是刷题无所谓了。
 *   7. 对文件名长度的判定在Entry的toString中，这样写不好，因为是刷题无所谓了。
 **/
import java.util.Arrays;
import java.util.HashMap;
import java.util.LinkedHashMap;
import java.util.Scanner;

public class Main{
	public static void main(String[] args){
		Scanner scan = new Scanner(System.in);
		HashMap<Entry, Entry> records = new LinkedHashMap<Entry , Entry>();
		while(scan.hasNext()){
			String name = scan.next();
			int lines = scan.nextInt();
			int index = name.lastIndexOf('\\');
			//截取文件名
			if(index!=-1)
				name = name.substring(index+1);
			//生成Entry
			Entry entry = new Entry(name,lines);
			if(records.containsKey(entry)){
				//合并
				Entry old = records.get(entry);
				old.count++;
			}else{
				//新的
				records.put(entry, entry);
			}
		}  scan.close();  //获得结果
		Entry[] result = new Entry[records.size()];
		result = records.keySet().toArray(result);
		Arrays.sort(result);
		//输出结果
		int size = Math.min(8, result.length);
		for(int i=0;i<size;i++){
			System.out.println(result[i]);
		}
	}
	
	private static class Entry implements Comparable<Entry>{
		public String 	name;
		public int		lines;
		public int		count;
		
		public Entry(String n , int l){
			this.name = n;
			this.lines = l;
			this.count=1;
		}
		@Override
		public int compareTo(Entry e) {
			if(this.count<e.count)
				return 1;
			else if(this.count == e.count)
				return 0;
			else
				return -1;
		}
		@Override
		public int hashCode(){
			return name.hashCode()+lines;
		}
		@Override
		public boolean equals(Object obj){
			if(obj==this)
				return true;
			if(obj instanceof Entry){
				Entry e = (Entry)obj;
				if(e.name.equals(this.name)&&e.lines==this.lines)
					return true;
			}
			return false;
		}
		@Override
		public String toString(){
			if(name.length()<=16)
				return name+" "+lines+" "+count;
			else
				return name.substring(name.length()-16,name.length())+" "+lines+" "+count;
		}
	}
}

import java.util.ArrayList;
import java.util.Collections;
import java.util.Comparator;
import java.util.HashMap;
import java.util.Scanner;

class ByValueComparator implements Comparator<String>{
	HashMap<String, Integer> base_map;
	public ByValueComparator(HashMap<String,Integer> map) {
		// TODO Auto-generated constructor stub
		this.base_map = map;
	}
	@Override
	public int compare(String str1, String str2) {
		// TODO Auto-generated method stub
		if(!base_map.containsKey(str1) || !base_map.containsKey(str2)){
			return 0;
		}
		if(base_map.get(str1) < base_map.get(str2)){
			return 1;
		}else{
			//相等也要返回-1，否则在排序时不会把相等的值放到TreeMap中，若=0则新值替代原值
			//为何相等是返回-1不是返回1，根据情况而定，返回1代表新值放到旧值前面，-1代表新值放在旧值后面
			return -1;
		}
	}
}
public class juan1_q2 {
	public static void main(String[] ags){
		HashMap<String, Integer> recMap = new HashMap<String, Integer>();
		Scanner input = new Scanner(System.in);
		String file = "";
		int errorLine = 0;
		int lastIndex = 0;
		String recName = null;
		while(input.hasNext()){
			file = input.next();
			errorLine = input.nextInt();
			lastIndex = file.lastIndexOf("\\");
			recName = (lastIndex < 0)?file:file.substring(lastIndex+1)+" "+errorLine;
			int count = 0;
			if(!recMap.containsKey(recName)){
				recMap.put(recName, 1);
			}else{
				count = recMap.get(recName);
				recMap.put(recName, count+1);
			}
		}
		input.close();
		//--------以上统计，以下排序取值-------------
		ArrayList<String> keys = new ArrayList<String>(recMap.keySet());
		ByValueComparator bvc = new ByValueComparator(recMap);
		Collections.sort(keys, bvc);
		for(int i = 0;i < (keys.size() > 8?8:keys.size());i++){
			String key = keys.get(i);
			StringBuilder res = new StringBuilder();
			lastIndex = key.lastIndexOf(" ");
			int value = recMap.get(key);
			if(lastIndex > 16){
				res.append(key.substring(lastIndex-16));
			}else{
				res.append(key);
			}
			res.append(" "+value);
			System.out.println(res.toString());
		}
	}
}
以上代码有两个问题：
1.comparator理解问题，返回1代表str1会放在str2后面，-1代表str1放在str2前面，若相等应该是返回0.
2.没有考虑输入顺序的排序，因此要使用LinkedHashMap代替HashMap来保存输入顺序的信息
修改代码通过，如下：
import java.util.ArrayList;
import java.util.Collections;
import java.util.Comparator;
import java.util.HashMap;
import java.util.LinkedHashMap;
import java.util.Scanner;

class ByValueComparator implements Comparator<String>{
	HashMap<String, Integer> base_map;
	public ByValueComparator(HashMap<String,Integer> map) {
		// TODO Auto-generated constructor stub
		this.base_map = map;
	}
	@Override
	public int compare(String str1, String str2) {
		// TODO Auto-generated method stub
		if(!base_map.containsKey(str1) || !base_map.containsKey(str2)){
			return 0;
		}
		if(base_map.get(str1) < base_map.get(str2)){
			return 1;
			
		}else if(base_map.get(str1) > base_map.get(str2)){
			//从大到小排序，因此若str1<str2，则返回1，即str2会排在str1前面；str1>str2,返回-1，则str1排在str2前面
			//从小到大排序，-1代表str1<str2；0代表==，不动位置；1代表str1>str2，str1放在str2后。
			return -1;
		}else{
			return 0;
		}
	}
}
public class juan1_q2 {
	public static void main(String[] ags){
		LinkedHashMap<String, Integer> recMap = new LinkedHashMap<String, Integer>();
		Scanner input = new Scanner(System.in);
		String file = "";
		int errorLine = 0;
		int lastIndex = 0;
		String recName = "";
		while(input.hasNext()){
			file = input.next();
			errorLine = input.nextInt();
			lastIndex = file.lastIndexOf("\\");
			recName = (lastIndex < 0)?file:file.substring(lastIndex+1)+" "+errorLine;
			int count = 0;
			if(!recMap.containsKey(recName)){
				recMap.put(recName, 1);
			}else{
				count = recMap.get(recName);
				recMap.put(recName, count+1);
			}
		}
		input.close();
		//--------以上统计，以下排序取值-------------
		ArrayList<String> keys = new ArrayList<String>(recMap.keySet());
		System.out.println(keys.toString());
		ByValueComparator bvc = new ByValueComparator(recMap);
		Collections.sort(keys, bvc);
		System.out.println(keys.toString());
		for(int i = 0;i < (keys.size() > 8?8:keys.size());i++){
			String key = keys.get(i);
			StringBuilder res = new StringBuilder();
			lastIndex = key.lastIndexOf(" ");
			int value = recMap.get(key);
			if(lastIndex > 16){
				res.append(key.substring(lastIndex-16));
			}else{
				res.append(key);
			}
			res.append(" ").append(value);
			System.out.println(res.toString());
		}
	}
}

#include <iostream>
#include <vector>
#include <string>
#include <algorithm>
using namespace std;

bool compare(pair<string, int> a, pair<string, int> b){
	return a.second > b.second;
}
int main(void){
	string input, file;
	vector<pair<string, int>> errors;
	while (getline(cin, input)){
		if (input.size() == 0)
			break;
		unsigned int f = input.rfind('\\');
		file = input.substr(f + 1);
		errors.push_back(make_pair(file, 1));
		for (int i = 0; i<(errors.size() - 1); i++){
			if (errors[i].first == file){
				errors[i].second++;
				errors.pop_back(); break;
			}
		}
	}
	stable_sort(errors.begin(), errors.end(), compare);
	int idx = 0;
	while (idx<8 && idx<errors.size()){
		string check = errors[idx].first;
		int t = check.find(' ');
		if (t>16)
			errors[idx].first.erase(0, t - 16);
		cout << errors[idx].first << ' ' << errors[idx].second << endl;
		idx++;
	}
}

您的代码已保存
运行错误:请检查是否存在数组、列表等越界非法访问，内存非法访问等情况
terminate called after throwing an instance of 'std::out_of_range'
what(): basic_string::substr: __pos (which is 18446744073709551614) > this->size() (which is 17)

#include<iostream>
#include<string>
#include<vector>
#include<algorithm>
using namespace std;
int outNum = 8; // 输出记录的数目
int nameLen = 16; //输出名字字符长度的上限
struct ErrRec{
    string s_Name;
    string s_LineNum;
    int s_Count = 0;
};

// 获取接收信息
vector<ErrRec>getInfo(vector<ErrRec>& result){
    string line;
    while (getline(cin, line)){
        int spaceIndex = line.find(' ');
        int slashIndex = line.find_last_of('\\');
        ErrRec individual;
        string lineNum = line.substr(spaceIndex + 1);
        string name = line.substr(slashIndex + 1, spaceIndex - slashIndex - 1);
        if (result.size() == 0){
            individual.s_LineNum = line.substr(spaceIndex + 1);
            individual.s_Name = line.substr(slashIndex + 1, spaceIndex - slashIndex - 1);
            individual.s_Count = 1;
            result.push_back(individual);
        }
        else{
            bool sign = false;
            // 遍历ErrRec的所有数据，判断当前记录是否已经被记录
            for (vector<ErrRec>::iterator it = result.begin(); it != result.end(); it++){
                // 当前错误已经被记录，计数+1
                if ((*it).s_LineNum == lineNum && (*it).s_Name == name){
                    (*it).s_Count++;
                    sign = true;
                    break;
                }
            }
            // 当前错误未被记录，在vector末端存入当前记录
            if (!sign){
                individual.s_LineNum = line.substr(spaceIndex + 1);
                individual.s_Name = line.substr(slashIndex + 1, spaceIndex - slashIndex - 1);
                individual.s_Count = 1;
                result.push_back(individual);
            }
        }
    }
    return result;
}

// 排序的自定义降序规则
bool compareRule(ErrRec a, ErrRec b){
    return a.s_Count > b.s_Count;
}

// 输出当前vector中的错误记录
void printResult(vector<ErrRec>& result){
    int printNum = 0;
    for (vector<ErrRec>::iterator it = result.begin(); it != result.end(); it++){
        // 判断当前记录的数目是否超过outNum，若超过则只输出前8个
        if (printNum == outNum){
            break;
        }

        // 判断it指向的错误记录的名字是否超过16个字符，若超过则作截断
        else{
            if ((*it).s_Name.length() > nameLen){
                int pose = nameLen - (*it).s_Name.length() - 1;
                string blockName = (*it).s_Name.substr(pose, nameLen);
                cout << blockName << " " << (*it).s_LineNum << " " << (*it).s_Count << endl;
            }
            else
                cout << (*it).s_Name << " " << (*it).s_LineNum << " " << (*it).s_Count << endl;
        }
        printNum++;
    }
}

int main(){
    vector<ErrRec> result;
    result = getInfo(result);
    stable_sort(result.begin(), result.end(), compareRule);
    printResult(result);
    system("pause");
    return 0;
}

def judge_in(str_in,ans): //判断相同的错误记录函数，返回布尔值以及当前出现次数
    for i in ans:
        if str_in in i[0]:
            return [True,i[1]]
    return [False,0]
try:
    ans = []
    while True: //坑爹的判题器，无限接收样例输入
        ans_str = ''
        line = input().split()
        road = line[0]
        code = int(line[1])
        temp = road.split("\\")
        filename = temp[-1]
        sym = judge_in(filename+' '+str(code),ans)
        if sym[0]: //取布尔类型的值做判断是否是重复错误
            index = ans.index([filename+' '+str(code),sym[1]])
            ans[index][1] +=1
        else:
            ans_str += filename + ' ' + str(code)
            ans.append([ans_str,1])
except:
    ans = sorted(ans,key=lambda x:x[1],reverse=True)//按照出现次数排序
    for i in range(8):
        tp = ans[i][0].split()
        if len(tp[0])>16://判断字符是否不符合16个，进行差异化输出
            print(tp[0][-16:],tp[1],ans[i][1])
        else:
            print(ans[i][0],ans[i][1])

import java.util.*;

public class Main{
    public static void main(String[] args)
    {
        Scanner sc = new Scanner(System.in);
        HashMap<String,Integer> hashmap = new HashMap<>();
        List<String> arraylist = new ArrayList<>();

        while(sc.hasNext())
        {
            String[] info = sc.nextLine().split("\\\\");
            String parseInfo = info[info.length - 1];
            if(arraylist.contains(parseInfo)){
                hashmap.put(parseInfo,hashmap.get(parseInfo)+1);
            }else{
                arraylist.add(parseInfo);
                hashmap.put(parseInfo,1);
            }
        }
        int temp = 1;
        arraylist.sort(new Comparator<String>() {
            @Override
            public int compare(String o1, String o2) {
                if(hashmap.get(o1)<hashmap.get(o2)){
                    return 1;
                }else if(hashmap.get(o1)>hashmap.get(o2)){
                    return -1;
                }else{
                    if (arraylist.indexOf(o1)>arraylist.indexOf(o2)){
                        return 1;
                    }else{
                        return -1;
                    }
                }
            }
        });
        sc.close();
        for (String s : arraylist ){
            if(temp>8){
                break;
            }
            temp++;
            int length = s.split(" ")[0].length();
            int cut_l = length - 16;
            int olength = s.length() - cut_l;
            if(length<=16){
                System.out.println(s+" "+hashmap.get(s));
            }else
            {
                System.out.println(s.substring(s.length()-olength,s.length())+" "+hashmap.get(s));
            }
        }
        
    }
}

import java.util.Scanner;

public class Main {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        int i = 0;
        int falg = 0;
        String[] result = new String[8];
        int[] count = new int[8];
        while (sc.hasNextLine()) {
            String line = sc.nextLine();
            if (line.equals("")) break;
            line = line.substring(line.lastIndexOf("\\") + 1);
            String[] ss = line.split(" ");
            for (int j = 0; j < 8; j++) {
                if (count[j] != 0)
                    if (line.equals(result[j])) {
                        count[j]++;
                        falg = 1;
                    }
            }
            if (falg == 0) {
                result[i] = line;
                count[i] = 1;
                i++;
            }
        }
        for (int j = 0; j < 8; j++) {
            if (count[j] != 0)
                if (result[j].substring(0,result[j].indexOf(" ")).length() <= 16)
                    System.out.println(result[j] + " " + count[j]);
                else System.out.println(result[j].substring(result[j].length() - 16) + " " + count[j]);
        }
    }
}
//idea里输出正确这里输出顺序不一样，显示错误