xxx公司三道笔试题

/*
 问题：假设一条路上种了一排苹果树，苹果树上各自结了果子。一位果农沿路采摘果实，
 规则是不能连续采摘两颗果树上的果实。假设果树上的果实用一个list来表示apples[]，
 请为果农设计一个最优的采摘方式，使得他能收获最多的果实
*/

public class 不相邻元素的最大和_递归 {
    public int dpRob(int[] nums, int n, int[] array) {
        if (n < 0)
            return 0;
        if(array[n] == -1)
            array[n] = Math.max(dpRob(nums, n-1, array), dpRob(nums, n-2, array) + nums[n]);
        return array[n];
    }
    public int rob(int[] apples) {
        int[] array = new int[apples.length];
        Arrays.fill(array, -1); //此处数组元素要初始化为负数
        int max = dpRob(apples, apples.length-1, array);
        System.out.print("可最大化采摘苹果数量的路径是：");
        for(int i = 0; i < array.length; i++) {
            if(i == array.length - 1) {
                System.out.println(array[i]);
            } else {
                System.out.print(array[i] + ",");
            }
        }
        return max;
    }

    public static void main(String[] args) {
        System.out.println("请输入所有苹果树上的苹果数量，中间使用英文空格分隔：");
        Scanner sc = new Scanner(System.in);
        String str = sc.nextLine();
        String[] applesStr = str.split(" ");
        int[] apples = new int[applesStr.length];
        for(int i = 0; i < applesStr.length; i++) {
            apples[i] = Integer.valueOf(applesStr[i]);
        }
        不相邻元素的最大和_递归 不相邻元素的最大和递归 = new 不相邻元素的最大和_递归();
        try {
            System.out.println("最大可采摘的苹果数量和为：" + 不相邻元素的最大和递归.rob(apples));
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

/*
 问题：字符串反转及获取重复字符。
一个简单的字符串，其中有重复的字符，例如“abcdeabfff”，写段代码将改字符串反转，
并且获取重复字符及其位置
*/

import java.util.ArrayList;
import java.util.Collections;
import java.util.HashMap;
import java.util.Map;

public class 字符串反转及重复字符计算 {
    public static String reverse(String s) {
        char[] str = s.toCharArray();
        int begin = 0;
        int end = s.length() - 1;
        while (begin < end) {
            str[begin] = (char) (str[begin] ^ str[end]);
            str[end] = (char) (str[begin] ^ str[end]);
            str[begin] = (char) (str[end] ^ str[begin]);
            begin++;
            end--;
        }
        return new String(str);
    }

    /**
     * 找出重复字符、记录重复字符次数、记录重复字符位置
     */
    public Map getRepeatStrAndCountAndIndex(String[] strArray) {
        Map<String, Map<Integer, ArrayList>> map = new HashMap<>();//key值记录重复的字符串，value记录出现的次数和位置
        int i = 0;
        for (String str : strArray) {
            if (map.get(str) == null) {
                Map<Integer, ArrayList> countAndWhere = new HashMap<>();//key值记录重复字符串出现的次数，value记录重复字符出现的位置
                int count = 1;//重复字符串计数器
                ArrayList<Integer> list = new ArrayList<>();
                list.add(i);//重复字符串下标
                countAndWhere.put(count, list);
                map.put(str, countAndWhere);
            } else {
                for (int cnt : map.get(str).keySet()) {
                    ArrayList index = map.get(str).get(cnt);
                    index.add(i);//增加出现index位置
                    cnt++;
                    map.get(str).put(cnt, index);//更新计数器和下标信息
                    map.get(str).remove(--cnt);//删除掉之前的记录信息
                }
            }
            i++;
        }
        return map;
    }

    public void display(String[] strArray) throws Exception {
        if (strArray == null) {
            throw new Exception("输入数组为空，请重新输入");
        }
        Map<String, HashMap<Integer, ArrayList>> map = getRepeatStrAndCountAndIndex(strArray);
        ArrayList count = new ArrayList<Integer>();//存取所有字符串出现的次数
        for (Map.Entry<String, HashMap<Integer, ArrayList>> key : map.entrySet()) {//循环获取记录字符串重复次数和位置map
            for (Map.Entry<Integer, ArrayList> map1 : key.getValue().entrySet()) {//循环获取记录字符串重复次数
                count.add(map1.getKey());
            }
        }
        Collections.sort(count);//对集合排序，默认是升序，最后一个是重复次数最多的
        //打印重复次数最多的元素信息
        for (String key : map.keySet()) {//循环获取所有的重复字符串
            for (int c : map.get(key).keySet()) {//循环获取重复字符串的次数
                if (c == (int) count.get(count.size() - 1)) {//和最大重复次数对比，相等就代表当前的字符串是重复次数最多的那个
                    System.out.printf("重复次数最多的字符是：%s,重复次数%d,所在位置：%s\n", key, c, map.get(key).get(c));
                }
            }
        }
        //输出指定重复次数的字符串信息
        for (String key : map.keySet()) {
            for (int c : map.get(key).keySet()) {
                System.out.printf("重复字符：%s,重复次数：%d,重复字符出现位置：%s\n", key, c, map.get(key).get(c));
            }
        }
    }

    public static void main(String[] args) {
        String example = "abcdeabfff";
        char[] charArray = example.toCharArray();
        System.out.println("字符串反转结果：" + reverse(example));

        String[] strArray = new String[charArray.length];
        for (int i = 0; i < charArray.length; i++) {
            strArray[i] = charArray[i] + "";
        }
        字符串反转及重复字符计算 字符串反转及重复字符计算 = new 字符串反转及重复字符计算();
        try {
            字符串反转及重复字符计算.display(strArray);
        } catch (Exception e) {
            e.printStackTrace();
        }
    }

}

/*
 问题：回文素数：所谓回文数就是顺着读和倒着读一样的数(例如：11，121，1991…)，
 回文素数就是既是回文数又是素数(只能被1和自身整除的数)的数。
 编程找出11～9999之间的回文素数。
*/

public class 回文素数 {
    public static void main(String[] args) {
        for (int i = 11; i < 9999; i++) {
            if (i == getReverseNumber(i) && isPrimeNumber(i)) {
                System.out.println(i);
            }
        }

    }

    /**
     * 判断是否是素数
     */
    public static boolean isPrimeNumber(int n) {
        if (n < 2) {
            return false;
        }
        int z = (int) Math.sqrt(n);
        for (int i = 2; i <= z; i++) {
            if (n % i == 0) {
                return false;
            }
        }
        return true;
    }

    /**
     * 获取反转后的数
     */
    public static Integer getReverseNumber(int n) {
        int temp = 0;
        while (n > 0) {
            temp = temp * 10 + (n % 10);
            n = n / 10;
        }
        return temp;
    }

}