面试题目

一、斗鱼实习笔试

1.题目：一个数如果恰好等于它的因子之和，这个数就称为"完数"。例如6=1＋2＋3.编程找出1000以内的所有完数。

//求 1~m 内的完数
    private static ArrayList<Integer> getAllWanShu(int m){
        ArrayList<Integer> list=new ArrayList<Integer>();
        for(int i=1;i<m;i++){
            int temSum=0;
            for(int j=1;j<i/2+1;j++){
                if(i%j==0)
                    temSum+=j;
            }
            if(temSum==i)
                list.add(i);
        }    
        return list;
    }

 2.介绍下不同场景下 Activity 生命周期的变化过程

https://blog.csdn.net/cadi2011/article/details/52326093

3.两个 Activity 之间如何传递数据

4.Service 的启动方法（2个）

5.Android 中持久化信息的方式有（5个）

6.java 对象的 4 中引用类型

　　https://www.cnblogs.com/dolphin0520/p/3784171.html

　　https://blog.csdn.net/u011277123/article/details/78830391

• 强引用就是指在程序代码之中普遍存在的，类似“Object obj=new Object()”，这类的引用，只要强引用存在，垃圾收集器永远不会回收掉引用的对象。
• 软引用是用来描述一些还有用但非必须的对象。对于软引用关联着的对象，在系统将要发生内存溢出异常之前，将会把这些对象列进回收范围之中进行第二次回收。如果这次回收还没有足够的内存，才会抛出内存溢出异常。
• 弱引用也是用来描述非必须对象的，但是它的强度比软引用更弱一些，被软引用关联的对象只能生存到下一次垃圾收集发生之前。当垃圾收集器工作时，无论当前内存是否足够，都会回收掉只被弱引用关联的对象。
• 虚引用是最弱的一种引用关系。一个对象是否有虚引用的存在，完全不会对其生存时间构成影响，也无法通过虚引用来取得一个对象实例。为一个对象设置虚引用关联的唯一目的就是能在这个对象被垃圾收集器回收时收到一个系统通知。

二、虎牙实习笔试

1.今有一个 char 数组，内容全是小写英文字母，且无重复，返回排列个数

2.输入一个整数数组，实现一个函数来调整该数组中数字的顺序，使得所有的奇数位于数组的前半部分，所有的偶数位于数组的后半部分，并保证奇数和奇数，偶数和偶数之间的相对位置不变。

3.有 2*n 个人合影，站成前后两排，人数前后排一样，每排必须从矮到高，后排每个人也必须比前排对应的那个人高，假定这些人身高没有相等的，问一共有多少种排法。

　　该问题等价于：n个自然数1~n进栈（栈无穷大），任何一个数进栈的同时可以选择出栈，比如第一个数进栈完毕，下一个动作可以选择出栈或后一个数进栈，进栈次序为1、2、3……n，问不同的出栈次序有几种？ 

　　该问题等价于：n个1和n个0组成一个2n位的2进制数，要求从左到右扫描，1的累计数不小于0的累计数，试求满足这条件的数有多少？

　　https://blog.csdn.net/qq_38216239/article/details/78738785

　　https://blog.csdn.net/vast_sea/article/details/8173362

三、华为实习笔试

1.定义一种新的数据结构，分为小端和大端，该结构有 9 个字符组成，小端开头字符为数字 0，如 0abcdefgh，大端开头字符为数字 1，如 1abcdefgh；

    给定一组数据，编程实现，提取小端内容和大端内容，要求，小端内容反转，大端内容保持不变，提取的内容用空格间隔，最后一个数据无空格；

　例如 输入 2 0abcdefgh1abcdefgh   输出hgfedcba abcdefgh

package huawei;
import java.util.ArrayList;

public class Main {
    public static void main(String[] args) {
        
         System.out.println(solve(2, "0abcdefgh1abcdefgh"));
    }
    public static String solve(int n,String str){
            ArrayList<String> list=new ArrayList<>();
            int[] index=new int[n+1];
            for(int i=0;i<=n;i++) 
                index[i]=9*i;
            int j=0;
            while(j<n) {
                list.add(str.substring(index[j], index[j+1]));
                j++;
            }
            StringBuilder res=new StringBuilder();
            for(int i=0;i<list.size()-1;i++) {
                String tem=helper(list.get(i));
                res.append(tem+" ");
            }
            res.append(helper(list.get(list.size()-1)));
            return res.toString();   
   }
    private static String helper(String str) {
        StringBuilder builder=new StringBuilder(str);
        if(builder.charAt(0)=='1') {
            builder.deleteCharAt(0);
            return builder.toString();
        }else {
            builder.deleteCharAt(0);
            builder.reverse();
            return builder.toString();
        }
    }
}

2.平原上，一群蜜蜂离开蜂巢采蜜，要连续采集5片花丛后归巢。
已知5片花丛相对蜂巢的坐标，请你帮它们规划一下到访花丛的顺序，以使飞翔总距离最短。

输入描述
以蜂巢为平面坐标原点的5片花丛A、B、C、D、E的坐标，坐标值为整数。
输出描述
从出发到返回蜂巢最短路径的长度取整值，取整办法为舍弃小数点后面的值。

示例1
输入
200 0 200 10 200 50 200 30 200 25
输出
456
说明
样例中的10个数，相邻两个分别为一组，表示一个花丛相对蜂巢的坐标：A(x1, y1)、B(x2, y2)、C(x3, y3)、D(x4, y4)、E(x5, y5)，分表代表x1,y1,x2,y2,x3,y3,x4,y4,x5,y5

有权值的哈密顿回路问题就是Tsp(旅行商问题)

方法一：贪心算法（参考博文：https://www.cnblogs.com/demodashi/p/8458103.html）

package practice;

 public class Tsp {
    private int cityNum;//城市数量
    private double[][] distance;//距离矩阵
    private int[] cols;//代表列，也表示是否走过，走过置0
    private int[] rows;//代表行，选过置0；
    private int[] x;//存放城市坐标x
    private int[] y;//存放城市坐标y
    
    public Tsp(int n,int[] x,int[] y){
        cityNum=n;
        this.x=x;
        this.y=y;
        init();
    }
    private void init(){
        distance=new double[cityNum][cityNum];
        //计算矩阵距离值
        for(int i=0;i<cityNum-1;i++){
            distance[i][i]=0;
            for(int j=i+1;j<cityNum;j++){//计算 i代表的城市 与j代表的城市之间的距离
                double rij=Math.sqrt((x[i]-x[j])*(x[i]-x[j])+(y[i]-y[j])*(y[i]-y[j]));
                //int tij=(int)Math.round(rij);//四舍五入
                /*if(tij>rij){//取整办法为舍弃小数点后面的值
                    distance[i][j]=tij-1;
                    distance[j][i]=distance[i][j];
                }else{
                    distance[i][j]=tij;
                    distance[j][i]=tij;
                }*/
                distance[i][j]=rij;
                distance[j][i]=rij;
            }
        }
        distance[cityNum-1][cityNum-1]=0;
        
        cols=new int[cityNum];
        cols[0]=0;//第0个地方已经拜访过，但是还没有进行选择
        for(int i=1;i<cityNum;i++)
            cols[i]=1;
        rows=new int[cityNum];
        for(int i=0;i<cityNum;i++)
            rows[i]=1;
        print(distance);
    }
    private void print(double[][] distance) {
        for(int i=0;i<cityNum;i++){
            for(int j=0;j<cityNum;j++){
                System.out.print(distance[i][j]+" ");
            }
            System.out.println();
        }
        
    }
    public void solve(){
        double[] tem=new double[cityNum];
        String path="0";
        double s=0;//计算走过的距离
        int i=0;//当前走到的城市，并在该出做出选择(初始化为第0个城市)
        int j=0;//下一个要去的地方
        //默认从第0个城市开始进行选择（当前第0个城市已经走过来，要进行选择下一步了）
        while(rows[i]==1){
            for(int k=0;k<cityNum;k++){
                tem[k]=distance[i][k];//其它城市距当前城市 i 的距离
            }
            j=selectMin(tem);//选择下一个要去的地方
            rows[i]=0;//置0，表示已经在该城市做出选择；
            path+="-->"+j;
            cols[j]=0;//置0，表示已经走过该城市，接下来在该城市做选择
            s=s+distance[i][j];
            i=j;        
        }
        int s1=(int)Math.round(s);
        if(s1>s) s1=s1-1;
        
        System.out.println("路径:"+path);
        System.out.println("总距离"+s1);
    }
    //该函数设计很巧妙
    private int selectMin(double[] d) {
        int j=0,k=0;
        double minDis=d[0];
        //寻找第一个没有被拜访过的城市（即第一个可用的节点）
        while(cols[j]==0){
            j++;
            if(j>=cityNum) return 0;//已经走过所有的城市了，直接回到初始城市
            minDis=d[j];
            k=j;
        }
        //从可用节点 j 开始往后扫描，找到距离最小的节点
        for(;j<cityNum;j++){
            if(cols[j]==1){//该城市还没有被拜访过
                if(minDis>=d[j]){
                    minDis=d[j];
                    k=j;
                }
            }
        }
        return k;
    }    
 }

 

public static void main(String[] args) {
        
        String string=null;
        
        Scanner scan=new Scanner(System.in);
        if(scan.hasNextLine()){
            string=scan.nextLine();
        }
        scan.close();
        
        String[] str=string.split(" ");
        int len=str.length;
        int[] x=new int[len/2+1];
        int[] y=new int[len/2+1];
        x[0]=0;
        y[0]=0;
        int i=1,j=1;
        for(int k=0;k<str.length;k++){
            if(k%2==0)
                x[i++]=Integer.valueOf(str[k]);
            else{
                y[j++]=Integer.valueOf(str[k]);
            }
        }
        
        Tsp tsp=new Tsp(6, x, y);
        tsp.solve();
    }