科大讯飞 笔试题2021.8.15 Java版

1、将数的二进制表示中倒数第二个0改为1

如：10的二进制为1010，将倒数第二个0换为1后变为1110，结果为14

import java.util.ArrayList;
import java.util.List;

/**
 * @author Jefft
 * @date 2021/8/15 19:38
 */
public class Main {

    public int changeNumber (int num) {
        // write code here

        //10进制转为2进制
        List<Integer> list = new ArrayList<>();
        while (num != 0) {
            int i = num % 2;
            list.add(i);
            num /= 2;
        }

        //倒数第二个0转为1
        boolean isNum = false;
        //索引
        int index = -1;
        for (int i = 0;i < list.size();i++) {
            if (0 == list.get(i)) {
                if (!isNum) {
                    isNum = true;
                    continue;
                } else {
                    index = i;
                    break;
                }
            }
        }

        //2进制转10进制
        int res = 0;
        for (int i = 0;i < list.size();i++) {
            if (i == index || 1 == list.get(i)) {
                int n = 1;
                for (int j = 1;j <= i;j++) {
                    n *= 2;
                }
                res += n;
            }
        }
        return res;
    }


    public static void main(String[] args) {
        Main main = new Main();
        int i = main.changeNumber(15);
        System.out.println(i);  //90%
    }
}

2、求出字符串中包含26个字母的子串的最小长度，其中“？”可以代替其中一个字母

如：
“abcdefghijklmnopqrstuvw???abc”，结果为26
“abcdefghijklmnopqrstuvw?uvw??”，结果为29

import java.util.HashSet;
import java.util.Set;

/**
 * @author Jefft
 * @date 2021/8/15 19:56
 */
public class Main {
    public int findInterval (String str) {
        // write code here
        int res = -1;
        boolean hashChange= false;
        for (int i = 0;i < str.length();i++) {
            int len = getLen(str, i);
            if (len != -1) {
                if (!hashChange) {
                    res = len;
                    hashChange = true;
                } else {
                    res = Math.min(res, len);
                }
            }
        }
        return res;
    }

    public int getLen(String str, int index) {
        //Set去重，最后判断长度是否为26
        Set<Character> set = new HashSet<>();
        //应该到达的长度为26
        int len = 26;
        //从index开始遍历str
        for (int i = index;i < str.length();i++) {
            //遇到?则len = len - 1
            if ('?' == str.charAt(i)) {
                len -= 1;
            } else {
                set.add(str.charAt(i));
            }

            //如果到达则返回
            if (set.size() == len) {
                return i - index + 1;
            }
        }
        return -1;
    }

    public static void main(String[] args) {
        Main main = new Main();
        int acb = main.findInterval("abcdefghijklmnopqrstuvw???abc");
        System.out.println(acb);


    }
}

3、计算二叉树中距离为k的节点对的数量

对于上面的树，若令k = 3，则输出2。因为距离为3的节点对只有（4,3）和（5,3）

import java.util.ArrayList;
import java.util.List;

/**
 * @author Jefft
 * @date 2021/8/15 20:22
 */
public class Main {
    //节点集合
    static List<List<Integer>> lists = new ArrayList<>();
    /**
     * 代码中的类名、方法名、参数名已经指定，请勿修改，直接返回方法规定的值即可
     *
     *
     * @param root TreeNode类
     * @param k int整型
     * @return int整型
     */
    public int leafPairs (TreeNode root, int k) {
        // write code here
        List<Integer> ll = new ArrayList<>();
        ll.add(-1);
        lists.add(ll);
        if (root.left != null) {
            goNode(root.left, 1, ll);
        }
        if (root.right != null) {
            goNode(root.right, 2, ll);
        }


        int res = 0;
        for (int i = 0;i < lists.size() - 1;i++) {
            List<Integer> l1 = lists.get(i);
            int len1 = l1.size();

            for (int j = 1;j < lists.size();j++) {
                int curLen = 0;
                List<Integer> l2 = lists.get(j);
                int len2 = l2.size();
                int i1 = 0,i2 = 0;

                while (i1 < len1 && i2 < len2) {
                    if (l1.get(i1) != l2.get(i2)) {
                        curLen += 2;
                    }
                    i1++;
                    i2++;
                }
                //加上剩下的长度
                if (i1 >= len1) {
                    curLen += len2 - i2;
                }
                if (i2 >= len2) {
                    curLen += len1 - i1;
                }

                //符合加入
                if (curLen == k) {
                    res += 1;
                }
            }
        }
        return res;
    }

    /**
     *
     * @param node
     * @param leftOrRight 1 left ; 2 right
     * @param list
     */
    public static void goNode(TreeNode node, int leftOrRight, List<Integer> list) {
        //创建新的集合
        List<Integer> nList = new ArrayList<>(list);
        nList.add(leftOrRight);
        //将该节点添加到集合中
        lists.add(nList);

        //若左右子树不为空，则向下递归
        if (node.left != null) {
            goNode(node.left, 1, nList);
        }
        if (node.right != null) {
            goNode(node.right, 2, nList);
        }
    }


    public static void main(String[] args) {
        TreeNode root = new TreeNode(1);
        TreeNode root2 = new TreeNode(2);
        TreeNode root3 = new TreeNode(3);
        TreeNode root4 = new TreeNode(4);
        TreeNode root5 = new TreeNode(5);

        root2.left = root4;
        root2.right = root5;
        root.left = root2;
        root.right = root3;

        Main main = new Main();
        int i = main.leafPairs(root, 3);
        System.out.println(i);

    }
}

class TreeNode {
    int val = 0;
    TreeNode left = null;
    TreeNode right = null;
    public TreeNode(int val) {
        this.val = val;
    }
}