面试编程题

Question

1)请写一个方法，接受两个整数数组a和b，返回一个新的数组，该数组中的每一个元素都是字符串，字符串的格式为：x=y。
其中，x代表a数组中的一个值，y代表该值在b数组中出现的次数。
a数组中可以包含重复值，但返回的结果中不允许包含重复值。
2）编写一个程序，接受2个参数（代表两个文件），程序打开参数1代表的文件，读取每一行，将每行内容反转后写入参数2代表的文件。
如若文件一内容如下：
abc
123
则生成的文件2为：
cba
321

Answer 1

for exampleString[] fun1(int[] a, int b) {
    Map m = new HashMap();
    int count;
    for (int i=0; i<a.length; i++) {
        count = 0;
        for (int j=0; j<b.length; j++) {
            if (a[i] == b[j]) count++;
        }
        m.put(""+a[i], a[i]+"="+count);
    }    return m.values().toArrays(new String[0]);}void fun2(String f1, String f2) {
    try {
        BufferedReader br = new BufferedReader(new InputStreamReader(new FileInputStream(f1)));
        BufferWriter bw = new BufferedWriter(new OutputStreamWriter(new FileOutputStream(f2)));
        for (String s=br.readLine(); s!=null; s=br.readLine()) {
            s = new StringBuilder(s).reverse().toString();
            bw.write(s, 0, s.length());
            bw.newLine();
        }
        bw.flush();
        bw.close();
        br.close();
    } catch (Throwable e) {
        e.printStackTrace();
    }
}

Answer 2

question 1: public String[] args(int[] nums1, int[] nums2) {
        String result = "";
        for (int i = 0; i < nums1.length; i++) {
            int count = 0;
            for (int j = 0; j < nums2.length; j++) {
                if (nums1[i] == nums2[j]) {
                    count++;
                }
            }            if (result.indexOf(nums1[i] + "=") == -1) {
                result += nums1[i] + "=" + count + ";";
            }
        }        result.split("[;]");
    }question2:
和上面的一样的，通过StringBuilder类的反转方法。

Answer 3

qybao(阿宝) 的第一题的解答有点问题for (int i = 0; i < nums1.length; i++) {
            int count = 0;
            for (int j = 0; j < nums2.length; j++) {
                if (nums1[i] == nums2[j]) {           //这里有必要要加个判断，重复的就不需要统计了！
                    count++;
                }
........
if(!map.containsKey()){if (nums1[i] == nums2[j]) {      
                    count++;
                }
}这样改，我觉得比较好！

Answer 4

第一题怎么会有问题呢？判断不判断，结果都是一样的
Map会自动把相同key的对象值给替换掉的，只不过加了判断可以少做一些循环，但是判断内部本身也会自己循环比较的，所以就索性不判断了。相反
 if (result.indexOf(nums1[i] + "=") == -1) {
                result += nums1[i] + "=" + count + ";";
            }
这样的判断是不正确的，比如，当nums[i]=1时，如果已经存在了"11=xxx"或者"21=xxx"等等，那最后结果不是就没有"1=xxx"了吗？

Answer 5

1楼的 
BufferWriter bw = new BufferedWriter(new OutputStreamWriter(new FileOutputStream(f2)));
这句话应该该为 
BufferedWriter bw = new BufferedWriter(new OutputStreamWriter(new FileOutputStream(f2)));

Answer 6

qybao(阿宝 说的对，那种情况，的确是我没有考虑到，我把原先的代码改了一下。我觉得用集合类来处理是个比较好的方法。不过如果题目规定不能使用集合类的方法，还有没有好的解决方法，这个我比较感兴趣。
public String[] args(int[] nums1, int[] nums2) {
        String result = "";
        for (int i = 0; i < nums1.length; i++) {
            int count = 0;
            for (int j = 0; j < nums2.length; j++) {
                if (result.indexOf("[" + nums1[i] + "]" + "=") == -1) {
                    if (nums1[i] == nums2[j]) {
                        count++;
                    }
                }
            }            if (result.indexOf("[" + nums1[i] + "]" + "=") == -1) {
                result += "[" + nums1[i] + "]" + "=" + count + ";";
            }
        }
        result = result.replaceAll("\\[", "").replaceAll("\\]", "");        return result.split("[;]");    }

Answer 7

package test;import java.io.BufferedReader;
import java.io.File;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.FileReader;
import java.io.IOException;
import java.io.PrintStream;public class Files { /**
 * @param args第二题字符转换
 */
public void fileReverse(File file1,File file2){
String receive=null;
String result=new String();
StringBuffer sb=new StringBuffer();
try {
BufferedReader br=new BufferedReader(new FileReader(file1));
PrintStream bw=new PrintStream(new FileOutputStream(file2));
while((receive=br.readLine())!=null){
sb=sb.append(receive);
sb=sb.reverse();
result=sb.toString();
bw.println(result);
sb=new StringBuffer();
System.out.println(result);
}
} catch (FileNotFoundException e) {
// TODO 自动生成 catch 块
e.printStackTrace();
} catch (IOException e) {
// TODO 自动生成 catch 块
e.printStackTrace();
}
}
public static void main(String[] args) {
// TODO 自动生成方法存根
Files f=new Files();
File file1=new File("c:/file1.txt");
File file2=new File("c:/file2.txt");
f.fileReverse(file1, file2);
}}
上边所写的stringbuilder 是什么东东？ 应该是StringBuffer吧！！！

Answer 8

第一题，如果重复元素很多的话，先把数组a 放到hashmap 里，去掉重复元素，在循环判断，结果放到另一个数组里，会好一点不？这样就减少了一些循环/。

Answer 9

StringBuilder是jdk1.5带的，1.4是没有的，StringBuilder非线程安全，但效率比StringBuffer高，1.4的就还只能用StringBuffer不用集合就把你的代码改一下，你的代码生成太多String对象，效率太低
public String[] args(int[] nums1, int[] nums2) {
        StringBuffer result = new StringBuffer(";");
        for (int i = 0; i < nums1.length; i++) {
            if (result.indexOf(";" + nums1[i] + "=") >= 0) {
                continue;
            }
            int count = 0;
            for (int j = 0; j < nums2.length; j++) {
                if (nums1[i] == nums2[j]) {
                    count++;
                }
            }
            result.append(nums1[i]).append("=").append(count).append(";");
        }
        result.delete(0, 1);        return result.toString().split(";");    }

Answer 10

第一题，如果重复元素很多的话，先把数组a 放到hashmap 里，去掉重复元素，在循环判断，结果放到另一个数组里，会好一点不？这样就减少了一些循环/。
--------------------
Map本来就能把相同key的元素保留一份，所以可以不作判断，当然，作判断可以减少一些循环，但是判断本身也是会作相应的比较处理的
String[] fun1(int[] a, int b) {
    Map m = new HashMap();
    int count;
    for (int i=0; i<a.length; i++) {
        if (m.containsKey(""+a[i])) { //containsKey本身也会做去循环比较的
            continue;
        }
        count = 0;
        for (int j=0; j<b.length; j++) {
            if (a[i] == b[j]) count++;
        }
        m.put(""+a[i], a[i]+"="+count); //这里如果有相同的key的话，只会保留一份，我之所以不加上面的判断，就是为了让LZ清楚这一点
    }    return m.values().toArrays(new String[0]);}

Answer 11

qybao(阿宝)这个......，确实之前有点低效，这个改的不错！~

Answer 12

这样行不行： 
把数组b做压缩返回二维数组(b中的值和其重覆数）bz
把数值a压缩反回一个一维数组（a中不重复的数）az，
再az,bz做个交集。在a，b重复比较多的话，可能会有点算法优势吧。关键是压缩的算法。