华为 2018 笔试题（IT应用软件开发工程师岗）

  昨天做的华为笔试题，三道编程题，嗯，总共600分，难度应该是依次上升吧，

通常分值分布是100分、200分、300分。两道AC了，一道75%，应该能进面试了吧。

趁着热乎来mark一下。

1.题意大概描述：输入一个整数，输出整数的位数，倒序输出它的每一位数字（数字

之间空格分开）和倒序的连续数值，而且题目限定了输入的整数不超过五位数。

题目所给例子：

输入：-12345

输出：-5 4 3 2 1

          -54321

import java.util.Scanner;
public class Main{
   public static void main(String[] args) throws Exception
   {
     Scanner sc = new Scanner(System.in);
     while(sc.hasNext())
     {
        String str = sc.nextLine();
        int flag = 0; //是否是负数标志位
        if(str.contains("-"))
       {
         flag = 1;
         str = str.substring(1);
       } 
       int len = str.length();
       System.out.println(len);
      if(flag == 1)
        System.out.print("-");
      for(int i = len-1; i >= 0;i--)
     { 
        if(i != 0)
          System.out.print(str.charAt(i)+" ");
        else
          System.out.println(str.charAt(i));
     }
      if(flag == 1)
        System.out.print("-");  
        System.out.println(new StringBuffer(str).reverse().toString());  
     }
   }
}

2. 题意大概描述：输入四个ip，前两个表示第一个ip段的起始地址和终止地址，后两个表示

第二个ip段的起始地址和终止地址（题目这么描述的时候，我有理由怀疑输入顺序有可能和

是起始ip地址和终止ip地址是不按顺序输入的），然后判断两个ip段是否有交集。若有则输出

Overlap IP，若没有则输出No Overlap IP。

题目所给例子：

输入：1.1.1.1

          255.255.255.255

          2.2.2.2

         3.3.3.3

输出：Overlap IP

这个题我是有点蒙，当时就直接跳转第三题了，怕时间不够，做完第三题再来做的第二题。

但是后来这个题还是没能AC，嗯，就是这道题通过率只有75%，对ip这个分段还是不熟悉，

有时间得把这个坑给填了。昨天写的代码如下(改天填坑)：

import java.util.Scanner;
public class Main{
    public static void main(String[] args)
    {
      Scanner sc = new Scanner(System.in);
      String[] ip = new String[4]; 
      while(sc.hasNext())
       {
          int[] numip = new int[4];
          for(int i =0;i<4;i++)
         {
            ip[i] = sc.nextLine(); 
            String[] arr = ip[i].split("\.");
            int[] ar = new int[4];
            for(int j=0;j<4;j++)
            {
               ar[j]= Integer.valueOf(arr[j]);
            }
              numip[i] = (ar[0]<<24)+(ar[1]<<16)+(ar[2]<<8)+(ar[3]);
         }
        if(Math.max(numip[0],numip[1]) <Math.min(numip[3],numip[2])
           ||Math.min(numip[0],numip[1])>Math.max(numip[3],numip[2])){
                System.out.println("No Overlap IP");
        }else{
              System.out.println("Overlap IP");
            }   
       }
    }
}

3.题意大概描述：输入一连串整数，整数之间以空格分开,，再输入一个整数表示

按照固定规则排序后的位置，然后输出重新排序后对应的这个位置的整数。题目

所给排序规则为：按照每个整数的后三位进行比较大小，按从小到大排序，不足

三位的按原数值参与比较。倘若按规则比较两个数值相同，则顺序为输入时的相对

位置。

题目所给例子：

输入：1223 22 3232 2016 

        ： 3

输出：1223

这个题以前做过类似的，按照后几位排序的，所以昨天先选择做的这道。

//正解。。 

public class Main {
public static void main(String[] args) {

    Scanner sc = new Scanner(System.in);
    while(sc.hasNext())
    {
         String input = sc.nextLine();
         int index = Integer.parseInt(sc.nextLine());
         System.out.println(sort(index, input));
    }
}

public static String sort(int index, String input) {

   String[] strs = input.split(" ");
   if (index > strs.length) return null;
   insertSort(strs);
  return strs[index - 1];
}

public static void insertSort(String[] strs) {

   for (int i = 1; i < strs.length; ++i)
   {
     int j = 0;
     while (j < i) {
     if (convert(strs[j]) <= convert(strs[i])) ++j;
     else break;
    }
   String tmp = strs[i];
   for (int k = i; k > j; --k)
   {
    strs[k] = strs[k - 1];
   }
   strs[j] = tmp;
 }
}

  public static int convert(String str)
 {
   int num = Integer.parseInt(str);
  if (str.length() > 3)
  {
   num = Integer.parseInt(str.substring(str.length() - 3));
  }
  return num;
 }
}

、、第一遍做的错误解，还没修正过来。。。。。
public class Main
{
    public static void main(String[] args) throws Exception
    {
        Scanner sc = new Scanner(System.in);
        while(sc.hasNext())
        {
            String str = sc.nextLine();
            int index = sc.nextInt();
            String[] strs = str.split(" "); 
            
            if(index<=0||index>strs.length)
                continue;
            int[] arr = convert(strs);
            for(int i = 0;i<strs.length;i++)
            {
                if(strs[i].contains(String.valueOf(arr[index-1])))
                    {
                    System.out.println(strs[i]);
                    break;
                    }
            }
        }
    }
    //将后三位转换为整数，并排序然后返回排序好了的数组
    public static int[] convert(String[] strs)
    {
        int[] numstrs = new int[strs.length];
        for(int i = 0;i < strs.length;i++)
        {
            if(strs[i].length()>3)
            numstrs[i]=Integer.parseInt(strs[i].substring(strs[i].length()-3));
             if(strs[i].length()>0&&strs[i].length()<=3) {
                numstrs[i]=Integer.parseInt(strs[i]);
            }
        }
        Arrays.sort(numstrs);
     // for(Integer num:numstrs)
      //      System.out.println("---"+num);
        return numstrs;
    }
}