无聊的时候写的一个程序

昨天没什么事情，于是在一个编程测试系统里面找了个题，花了点时间写了个程序，其题目如下：

企业喜欢用容易被记住的电话号码。让电话号码容易被记住的一个办法是将它写成一个容易记住的单词或者短语。例如，你需要给滑铁卢大学打电话时，可以拨打TUT-GLOP。有时，只将电话号码中部分数字拼写成单词。当你晚上回到酒店，可以通过拨打310-GINO来向Gino's订一份pizza。让电话号码容易被记住的另一个办法是以一种好记的方式对号码的数字进行分组。通过拨打必胜客的“三个十”号码3-10-10-10，你可以从他们那里订pizza。 

电话号码的标准格式是七位十进制数，并在第三、第四位数字之间有一个连接符。电话拨号盘提供了从字母到数字的映射，映射关系如下： 

A, B, 和C 映射到 2 

D, E, 和F 映射到 3 

G, H, 和I 映射到 4 

J, K, 和L 映射到 5 

M, N, 和O 映射到 6 

P, R, 和S 映射到 7 

T, U, 和V 映射到 8 

W, X, 和Y 映射到 9 

Q和Z没有映射到任何数字，连字符不需要拨号，可以任意添加和删除。 TUT-GLOP的标准格式是888-4567，310-GINO的标准格式是310-4466，3-10-10-10的标准格式是310-1010。

如果两个号码有相同的标准格式，那么他们就是等同的（相同的拨号） 

你的公司正在为本地的公司编写一个电话号码薄。作为质量控制的一部分，你想要检查是否有两个和多个公司拥有相同的电话号码。 

Input

输入的格式是，第一行是一个正整数，指定电话号码薄中号码的数量（最多100000）。余下的每行是一个电话号码。每个电话号码由数字，大写字母（除了Q和Z）以及连接符组成。每个电话号码中只会刚好有7个数字或者字母。

Output

对于每个出现重复的号码产生一行输出，输出是号码的标准格式紧跟一个空格然后是它的重复次数。如果存在多个重复的号码，则按照号码的字典升序输出。如果输入数据中没有重复的号码，输出一行： 

No duplicates. 

Sample Input

12

4873279

ITS-EASY

888-4567

3-10-10-10

888-GLOP

TUT-GLOP

967-11-11

310-GINO

F101010

888-1200

-4-8-7-3-2-7-9-

487-3279

Sample Output

310-1010 2

487-3279 4

888-4567 3

由题可知，这是一个关于字符串处理的编程问题，为了实现题目所要达到的要求，采用高级语言会是一个不错的选择，故我舍弃了c而直接用java实现。

不写其他的了，直接将代码贴出如下吧：

import java.io.BufferedReader;

import java.io.IOException;

import java.io.InputStreamReader;

import java.util.regex.Pattern;

import java.util.regex.Matcher;

import java.util.HashMap;

import java.util.Collection;

import java.util.Iterator;

import java.util.Set;

public class PhoneNumber1002 {

private String oldStr[];        //原始字符串

private String newStr[];        //数字大写字母字符串

private String phoneStr[]; //电话字符串

private HashMap phoneNum; //存放标准的电话字符串，及其个数

private int strNum;            //字符串个数

// 构造函数，初始化字符串个数，以及字符串

public PhoneNumber1002(){

int i=1;

String num_str,str_str;

String str[];

try{

BufferedReader num_in=new BufferedReader(new InputStreamReader(System.in));

num_str=num_in.readLine();

this.strNum=Integer.parseInt(num_str);

str=new String[strNum];

while(i<=strNum){

BufferedReader str_in=new BufferedReader(new InputStreamReader(System.in));

str_str=str_in.readLine();

str[i-1]=str_str;

i++;

}

this.oldStr=str;

}

catch(IOException e){

e.printStackTrace();

}

}

//这个是完成对初始化字符串的的转换，即对其进行简单的提取数字和大写字母

public void opInitalConvert(){

int i;

//先分配numStr个字符串指针空间

String[] newStr=new String[oldStr.length];

//然后为每个指针空间分配字符串

for(i=0;i

newStr[i]=new String("");

Pattern pattern=Pattern.compile("[0-9A-Z]+");

for(i=0;i

Matcher matcher=pattern.matcher(oldStr[i]);

while(matcher.find()){

newStr[i]=newStr[i]+matcher.group();

}

}

this.newStr=newStr;

}

//完成对最后数字和大写字母字符串的 最后转换，即变成标准的电话号码字符串

public void opLastConvert(){

int i,j;

String[] phoneStr=new String[strNum];

char[] charOfstr;

for(i=0;i

charOfstr=newStr[i].toCharArray();

for(j=0;j

if (charOfstr[j]=='A'|charOfstr[j]=='B'|charOfstr[j]=='C')

charOfstr[j]='2'; 

       else if (charOfstr[j]=='D'|charOfstr[j]=='E'|charOfstr[j]=='F')

charOfstr[j]='3';

       else if (charOfstr[j]=='G'|charOfstr[j]=='H'|charOfstr[j]=='I')

charOfstr[j]='4';

       else if (charOfstr[j]=='J'|charOfstr[j]=='K'|charOfstr[j]=='L')

charOfstr[j]='5';

       else if (charOfstr[j]=='M'|charOfstr[j]=='N'|charOfstr[j]=='O')

charOfstr[j]='6';

       else if (charOfstr[j]=='P'|charOfstr[j]=='R'|charOfstr[j]=='S')

charOfstr[j]='7';

       else if (charOfstr[j]=='V'|charOfstr[j]=='T'|charOfstr[j]=='U')

charOfstr[j]='8';

       else if (charOfstr[j]=='W'|charOfstr[j]=='X'|charOfstr[j]=='Y')

charOfstr[j]='9';

}

//phoneStr[i]=charOfstr.toString();

phoneStr[i]=new String(charOfstr);

phoneStr[i]=phoneStr[i].substring(0,3) + "-" + phoneStr[i].substring(3);

}

this.phoneStr=phoneStr;

}

//统计并计算，各个字符串的条数

public void calStr(){

int i;

Integer numValue;

phoneNum=new HashMap();

for(i=0;i

if(!phoneNum.containsKey(phoneStr[i]))

phoneNum.put(phoneStr[i],1);

else{

numValue=phoneNum.get(phoneStr[i]);

phoneNum.remove(phoneStr[i]);

phoneNum.put(phoneStr[i],numValue.intValue()+1);

}

}

}

//返回字符串个数

public int retNumOfstr(){

return this.strNum;

}

//返回原始字符串

public String[] retOldStr(){

return this.oldStr;

}

//返回经过初步处理后的数字和大写字母字符串

public String[] retNewStr(){

return this.newStr;

}

//返回经过最终处理的电话号码串

public String[] retPhoneStr(){

return this.phoneStr;

}

//返回经过最终处理的电话号码串

public HashMap retPhoneNum(){

return this.phoneNum;

}

//test 主函数 main

public static void main(String[] args) {

PhoneNumber1002 testphone=new PhoneNumber1002();

String[] oldstr,newstr,phonestr;

HashMap phonenum;

///////////////////////test////////////////////////

int i;

oldstr=testphone.retOldStr();

for(i=0;i

System.out.println(oldstr[i]);

testphone.opInitalConvert();

newstr=testphone.retNewStr();

for(i=0;i

System.out.println(newstr[i]);

///////////////////////test////////////////////////

testphone.opLastConvert();

phonestr=testphone.retPhoneStr();

for(i=0;i

System.out.println(phonestr[i]);

testphone.calStr();

phonenum=testphone.retPhoneNum();

Collection valueNum=phonenum.values();

Iterator it=valueNum.iterator();

int k=0;

while(it.hasNext()){

int tmp;

tmp=it.next().intValue();

if(tmp==1)

k++;

}

if(valueNum.size()==k)

System.out.println("No duplicates.");

else{

Set phoneNumber=phonenum.keySet();

Iterator it_key=phoneNumber.iterator();

int dhhmsl;

String dhhm="";

while(it_key.hasNext()){

dhhm=it_key.next();

dhhmsl=phonenum.get(dhhm).intValue();

if(dhhmsl!=1)

System.out.println(dhhm+" "+dhhmsl);

}

}

}

}

很基础，希望大家指正。