剑指Offer——乐视笔试题+知识点总结

剑指Offer——乐视笔试题+知识点总结

情景回顾

• 时间:2016.9.19 15：10-17：10
• 地点:山东省网络环境智能计算技术重点实验室
• 事件:乐视笔试

  总体来说，乐视笔试内容体量不算少，主要分为35道选择题，3道编程题，时间稍微有点紧张。

编程题

数字游戏

package cn.edu.ujn.practice;
import java.util.ArrayList;
import java.util.Collections;
import java.util.Comparator;
import java.util.Scanner;
/**
 *
 * @author SHQ
数字游戏
    时间限制：C/C++语言 1000MS；其他语言 3000MS
    内存限制：C/C++语言 65536KB；其他语言 589824KB
题目描述：
    真是一个无聊的夜晚啊，小B和小C在宿舍中实在无聊之极，因此决定玩一个数字游戏打发时间。小B首先开始，她给小C的问题是：

    给定任意一个整数，小C可以交换该数中任意的不同位，能够得到的最小数值是多少？前提是不能有前导0。

    小C很快就给出了一个答案，小B希望你来帮她检验答案的正确性，你能帮忙吗？
输入
    输入中有多组测试数据。每组测试数据的第一行为一个没有前导0的整数n（0=< n =< 10^9），第二行为另一个整数m（0=<m=<10^9），小C给出的问题答案。
输出
    对每组测试数据，在单独的行中输出结果，若小C的答案是正确的，输出YES，否则输出NO。

    样例输入
    3310
    1033
    4
    5
    样例输出
    YES
    NO

    思路:
        拆分+比较器   40%
 */
public class LeShi_1 {

    public static void main(String[] args) {
        Scanner in = new Scanner(System.in);
        while (in.hasNextInt()) {//注意while处理多个case
            int a = in.nextInt();
            int b = in.nextInt();
            System.out.println(resolution(a, b));
        }
    }

    private static String resolution(int a, int b){
        if(a < 0 || b < 0 || a > 1000000000 || b > 1000000000)
            return "NO";
        if(a == 0 && b == 0){
            return "YES";
        }
        if(a == 0 && b != 0){
            return "NO";
        }
        ArrayList<Integer> list = new ArrayList<Integer>();
        while(a > 0){
            list.add(a % 10);
            a /= 10;
        }
        int [] numbers = new int [list.size()];
        for(int i = 0; i < list.size(); i++){
            numbers[i] = list.get(i);
        }

        String result = PrintMinNumber(numbers);
//      System.out.println(result);
        if(result.equals(String.valueOf(b)))
            return "YES";
        else
            return "NO";
    }

    private static String PrintMinNumber(int [] numbers) {
        if(numbers == null || numbers.length == 0){
            return null;
        }
        ArrayList<Integer> list = new ArrayList<Integer>();
        for(int i = 0; i < numbers.length; i++){
            list.add(numbers[i]);
        }
        // 升序(自定义比较器)
        Collections.sort(list, new Comparator<Integer>() {
            @Override
            public int compare(Integer str1, Integer str2) {// 实现接口中的方法
                return (str1+""+str2).compareTo(str2+""+str1);
            }
        });

        StringBuffer sb = new StringBuffer();
        int cnt = 0;
        for(int str : list){
            if(str == 0)
                cnt++;
        }
        sb.append(list.get(cnt));
        for(int i = 0; i < cnt; i++){
            sb.append(0);
        }
        for(int i = cnt+1; i < list.size(); i++){
            sb.append(list.get(i));
        }
        return sb.toString();
    }
}

  此题通过率40%。用到了之前在《剑指Offer》中类似的代码。可见，多刷题，有效的刷题还是有效果的。

数正方形

时间限制：C/C++语言 1000MS；其他语言 3000MS

内存限制：C/C++语言 65536KB；其他语言 589824KB

题目描述：

小B正在做一个关于图像理解方面的研究，她的目标是识别图像中的轮廓。当前阶段，她希望能够识别正方形。图像用一个矩阵表示，矩阵的每个元素对应于图像中的一个像素点，值为0或1，0表示背景，1表示前景。需要寻找的正方形必须满足线宽为单像素，且大小至少为2x2。她希望你能帮她找出图像中满足如下条件的两类正方形：

正方形的边与矩阵边缘平行；

正方形的边与矩阵对角线平行；

如以下矩阵中只有一个第一类正方形：

0000000

0111100

0100100

0100100

0111100

以下的矩阵中只有一个第二类正方形：

0000000

0010000

0101000

0010000

0000000

此外，不管何种类型的正方形，其每条边必须等长，且不能有任何边或顶点的像素与不属于该正方形的像素相连接。

输入

输入中有多组测试数据。第一行为一个整数t（1 =< t =< 10000），表示测试数据的组数，接下来是t组测试数据。每组测试数据的第一行为两个整数n和m（2<=n, m<=250），n和m分别为矩阵的行数和列数，接下来是n行数据，每行由m个0或1构成。

每个测试输入中的字符数不超过10^6个。

输出

对每组测试数据，在单独的行中输出矩阵中符合要求的正方形的数量。

样例输入

3

8 8

00010001

00101000

01000100

10000010

01000100

00101000

11010011

11000011

10 10

1111111000

1000001000

1011001000

1011001010

1000001101

1001001010

1010101000

1001001000

1000001000

1111111000

12 11

11111111111

10000000001

10111111101

10100000101

10101100101

10101100101

10100000101

10100000101

10111111101

10000000001

11111111111

00000000000

样例输出

1

2

3

跳跃的蚂蚱

package cn.edu.ujn.practice;

import java.util.Scanner;

/**
 *
 * @author SHQ
跳跃的蚂蚱
    时间限制：C/C++语言 1000MS；其他语言 3000MS
    内存限制：C/C++语言 65536KB；其他语言 589824KB
题目描述：
    小B对脑筋急转弯问题很有兴趣，她觉得这种问题的挑战能够反映一个人的应急反应能力。她正在开发一个智力测试的游戏，游戏的主角是一个蚂蚱。蚂蚱最初位于0点处，可以在直线上向正向或反向两个方向跳跃。比较特别的是，蚂蚱每次跳跃的距离比前一次跳跃多一个单位，第一次跳跃的距离为一个单位。

    小B的问题是，如果让蚂蚱跳跃到x处，需要经过多少次跳跃，你能解决这个问题吗？
输入
    输入中有多组测试数据。每组测试数据为单独的一行，包含一个整数x（-10^9 =< x =< 10^9）。
输出
    对每组测试数据，在单独的行中输出蚂蚱最少需要跳跃的次数。

样例输入
    2
    6
    0
样例输出
    3
    3
    0
*/
public class LeShi_3 {

    public static void main(String[] args) {
        Scanner in = new Scanner(System.in);
        while (in.hasNextInt()) {
            int a = in.nextInt();
            System.out.println(resolution(a));
        }
    }

    private static int resolution(int a){
        int cnt = 0;
        int pos = 0;
        int jump = 1;
        if(a == 0)
            return 0;
        while(true){
            cnt++;
            if(a > pos + jump){
                // 起始向右跳
                pos += jump;
            }else if (a < pos + jump){
                // 起始向左跳
                pos -= jump;
            }
            if(jump != 1 && pos+jump == a)
                return cnt;
            jump++;
        }
    }
}