华为机试题及参考答案

原创 2013年12月03日 20:28:26

/*

 * 程序实现目标:输入一个字符串,将其各个字符对应的ASCII值加5后,输出结果。

       程序要求:该字符串只包含小写字母,若其值加5后的字符值大于'z',将其转换成从a开始的字符。

 */

public class Main001 {

    public static void main(String[] args) {

       Scanner scanner=new Scanner(System.in);

       String str="afdsfdsxz";

       char[] indata=str.toCharArray();

       addAccii(indata);

    } 

    public static void addAccii(char[] indata){

       for(int i=0;i<indata.length;i++){

           if((indata[i]+5)>122){

              indata[i]= 'a';

           }else{

              indata[i]= (char)(indata[i]+5);

           }

           System.out.print(indata[i]);

       }     

    }

}

/*

 * 功能描述:判断一个字符串中是否只含有相同的子字符串(子串长度>=2

        输入:abab

        返回:true

        输入:abcd

        返回:false

 */

public class Main002 {

static void main(String[] args) {

       String str = "ertyertyabcdabcdsdf464132132146464165479lhkjhnkjgibkjbjljdslfsajdlasdf4asdf5a7e";

        int count = 2;

        List<String> maxLengthList = newArrayList<String>();

        maxLengthList = checkString(str,count, maxLengthList);

        System.out.println(maxLengthList);

        StringBuilder sbBuilder = new StringBuilder();

        if (maxLengthList.isEmpty()) {

            System.out.println("无重复并且长度大于2的子串!");

        } else {

            int maxLength = maxLengthList.get(0).length();

            sbBuilder.append(maxLengthList.get(0)).append(",");

            for (int i = 1; i < maxLengthList.size(); i++) {

                if (maxLengthList.get(i).length() == maxLength){

                   sbBuilder.append(maxLengthList.get(i)).append(",");

                }

            }

            System.out.println("重复最长子串为:"

                    +sbBuilder.toString().substring(0,

                           sbBuilder.toString().length() - 1));

        }       

       String str1 = "abab";

        int startindex = 0;

        int count2 = 2;

        System.out.println(isHave(str.substring(0,count2), str1, startindex,

                count));

    }   

     public static List<String>checkString(String str, int count,

               List<String> maxLengthList) {

            if (count >str.length() / 2 + 1) {

                return maxLengthList;

            }

            for (int i = 0; i <str.length() - count; i++) {

               List<String> strList = new ArrayList<String>();

                String regex = str.substring(i,i + count) + "+?";

                Pattern pattern= Pattern.compile(regex);

                Matcher matcher= pattern.matcher(str);

                while (matcher.find()) {

                   strList.add(matcher.group());

                }

                if (strList.size()> 1

                       && !maxLengthList.contains(str.substring(i, i + count))) {

                   maxLengthList.add(str.substring(i, i + count));

                }

            }

            count++;

            if (count >str.length()) {

                return maxLengthList;

            }

            checkString(str,count, maxLengthList);

            Collections.sort(maxLengthList,new Comparator<Object>() {

                @Override

                publicint compare(Object o1,Object o2) {

                    int length1 =o1.toString().length();

                    int length2 =o2.toString().length();

                    return length1 - length2< 0 ? 1 : (length1 - length2 == 0 ? o1

                           .toString().compareTo(o2.toString()) : -1);

                }

            }

);

            return maxLengthList;

         }

     public static boolean isHave(Stringstr1, String str,int startindex,

                int count) {

            boolean isHave =false;

            ++startindex;

            if (count >str.length() / 2 + 1) {

                return isHave;

            }

            List<String>strList = new ArrayList<String>();

            String regex = str1+ "+?";

            Pattern pattern =Pattern.compile(regex);

            Matcher matcher =pattern.matcher(str);

            while (matcher.find()) {

               strList.add(matcher.group(0));

            }

            if (strList.size()> 1) {

                isHave = true;

            } else if(!str.endsWith(str1)) {

                int endIndex =startindex + count;

                if (endIndex >str.length()) {

                    return isHave;

                }

                isHave = isHave(str.substring(startindex,endIndex), str,

                       startindex, count);

            } else {

                ++count;

                isHave = isHave(str.substring(0,count), str, startindex, count);

            }

            return isHave;

        }

     }

 

/*

 * 3、手动输入一个存储整数的数组,要求输出数组里面的2个最大值。

实例:

输入:1,2,5,9,84,3,2

输出:84,9

 *  */

public class Main003 {

    public static void main(String[] args) {

       Main003 test = new Main003();

       int[] arr = {1,45,98,6,4};

       test.getMaxValue(arr); 

    }

    public void getMaxValue(int[] arr){

       int temp=0;

       if(arr.length<1){

           System.out.println("数组元素个数至少为2");

       }

       else{

       for(int i=0;i<arr.length-1;i++){

           for(int j=0;j<arr.length-1-i;j++){

             if(arr[i]>arr[i+1]){

              temp = arr[i];

              arr[i]=arr[i+1];

              arr[i+1]=temp;

             }

           }

       }

       System.out.print(arr[arr.length-1]+""+arr[arr.length-2]);

    }

    }

}

/*

 * 题目描述:

    有这样一类数字,他们顺着看和倒着看是相同的数,例如:121,656,2332等,

这样的数字就称为:回文数字。编写一个函数,判断某数字是否是回文数字。

要求实现方法:

    public String isPalindrome(String strIn);

【输入】strIn:整数,以字符串表示;

【返回】true:是回文数字;

        false: 不是回文数字;

【注意】只需要完成该函数功能算法,中间不需要有任何IO的输入输出

示例:

    输入:strIn = “121”

返回:”true

 */

public class Main004 {

    public static void main(String[] args) {

       String inputValue = JOptionPane.showInputDialog("请输入一个整数");

         long inputValueLong =Long.parseLong(inputValue);

         long temp =inputValueLong;

         long reverseLong = 0L;

         while(inputValueLong !=0)

         {

          reverseLong =reverseLong*10+inputValueLong%10;

          inputValueLong =inputValueLong/10;

         }

         if(reverseLong ==temp)

          System.out.println("你输入的是回文数");

         else

          System.out.println("你输入的不是回文数");

    }

}

 

/*

 * 6.手动输入一个字符串,仅限小写字母,统计并输出每个字符在字符串中出现的次数,并输出。

 *  提示(可以用Map)

         实例:

         输入:aaabbbccc

          输出: a 3

          b 3

          c 3

 */

public class Main006 {

    public static void main(String[] args) { 

       statTimes("dfsdfgerfgtewthgat");

    }

     static void statTimes(Stringparam)

      {

         if(param ==nullreturn;   

       //hashset保存不重复的值因此

       HashSet<Character>hSet = new HashSet<Character>();      

       char[] cs =param.toCharArray();      

       for (char c : cs)

        hSet.add(c);      

       ArrayList<Character>list = new ArrayList<Character>(hSet);     

       int n =hSet.size(); //有多少种字符   

       int[] times =new int[n]; //保存每种字符的出现次数

       for (char c : cs)  //进行统计

        times[list.indexOf(c)]++;

       for (int i = 0; i < n;i++)

        System.out.println("字符 " + list.get(i) +"出现了" + times[i] +"次。");

       //打印结果     

      }

}

/*

 * 要求实现方法public String addTwoBigNumber(String s1,string s2)

        大数相加,注意处理异常

 */

public class Main007 {

    String result,s1,s2;

    int s1Len, s2Len;

    public  Main007(Stringstr1,String str2)

    {

       s1=str1;

       s2=str2;

    }   

    /**

     * @param args

     */

    public static void main(String[] args) {

       Scanner sc=new Scanner(System.in);

       System.out.println("input thefirst number:");

       String s1=sc.nextLine();

       System.out.println("input thesecond number:");

       String s2=sc.nextLine();

       sc.close();

      

       Main007 a=new Main007(s1,s2);

       String res=a.add();

       System.out.println("my addresult is: "+res);

 

    }

 

   

    public boolean check()//输入异常检查

    {

       for(int i=0;i<s1Len;i++)

       {

           if(s1.charAt(i)>'9'||s1.charAt(i)<'0')

           {

              System.out.println("first inputis not a number");

              return false;

           }

       }

       for(int i=0;i<s2Len;i++)

       {

           if(s2.charAt(i)>'9'||s2.charAt(i)<'0')

           {

              System.out.println("secondinput is not a number");

              return false;

           }

       }

       return true;

    }

   

    public String add()

    {

       result="";

       s1Len=s1.length();

       s2Len=s2.length();

       if(check())

       {

           if(s1Len<s2Len)//make s1 longerthan s2

           {

              String tempStr=s2;

              s2=this.s1;

              s1=tempStr;

             

              int tempNum=s2Len;

              s2Len=s1Len;

              s1Len=tempNum;

           }

           int flag=0;//if there is acarry-over from the behind number

           int deltaLen=s1Len-s2Len;

           int sum;

           for(int i=s1Len-1; i>=0; i--)

           {

              if(i-deltaLen>=0)

                  sum=(s1.charAt(i)-'0')+(s2.charAt(i-deltaLen)-'0')+flag;

              else

                  sum=(s1.charAt(i)-'0')+flag;

              flag=0;

              if(sum>9)//if there is acarry-over

              {

                  sum-=10;

                  flag=1;

              }

              result=sum+result;          

           }

           if(flag==1)//if the highestbit has a carry-over

           {

              result="1"+result;

              flag=0;

           }     

       }

           returnresult;

    }

}

 

/*

 * 8、比较二维数组列最小值,组成一个新数组返回。(实现核心算法,不需要使用IO)

        输入:{{5,6,1,16},{7,3,9}}

        输出:intArrs ={1,3}

 */

public class Main008 {

    public static void main(String args[]) {

       // 写测试方法

       int[][] a = { { 5, 6, 1, 16 }, { 7, 3, 9 }, { 2, 4, 56 } };

       int[] ss =getColMin(a);

       for (int i = 0; i < ss.length; i++) {

           System.out.print(ss[i] +"");

       }

    }

    public static int[] getColMin(int a[][]) {

       int[] res =new int[a.length];

       for (int i = 0; i < a.length; i++) {

           int[] s = a[i];

           Arrays.sort(s);

           res[i] = s[0];

       }

       return res;

    }

}

 

/*

 * 输入:aaa,cat tiger.123dd

        输出: tiger

       功能描述:键盘输入一句话

               输出一句话中最长的单词,如果最长的出现多次,返回第一个。

               这句话只包含数字字母和标点。

 */

public class Main009 {

 

    private static String langWord(String inString) {

       int sum=0;

       String[] strings=inString.split("[ ,.1-9]");

       ArrayList<String> strings2=new ArrayList<String>();

       for (int i = 0; i < strings.length; i++) {

           if (sum<strings[i].length()) {

              sum=strings[i].length();

             strings2.add(strings[i]);

           }

       }

       return strings2.get(strings2.size()-1);

    }

   

    public static void main(String[] args) {

       System.out.println("请输入字符串:");

       Scanner scanner=new Scanner(System.in);

       String data=scanner.nextLine();

       System.out.println(langWord(data));

    }

}

/**

 * 10、功能描述:将字符串中的字母全部替换成字母的下一个字母,要是最后一位是zZ则替换为aA

 *       输入:aBxyZ

 *       输出:bCyzA

 */

public class Main010 {

    public static void main(String[] args) {

       String data = "aBxyZ";

       System.out.println(new Main010().nextString(data));

    }

    public String nextString(String data) {

       char[] arr = data.toCharArray();

       for (int i = 0; i < arr.length; i++) {

           if (arr[i] >='a' && arr[i] <= 'z' || arr[i] >='A'

                  && arr[i] <= 'Z') {

              if (arr[i] =='z' || arr[i] == 'Z') {

                  arr[i] = (char) (arr[i] - 25);

              } else if ((arr[i] >= 'a' && arr[i] <'z')

                     || (arr[i] >= 'A' && arr[i] <'Z')) {

                  arr[i] = (char) (arr[i] + 1);

              }

           }

       }

       String res = String.valueOf(arr);

       return res;

    }

}

 

/**

 *2、求一个整形数组中元素的平均值,并统计其中大于和小于此平均值的元素的个数

  要求:输入:整形数组中的元素个数及各个元素

             输出:整型数组中元素的平均值,大于和小于此平均值的元素个数

 */

public class Main011 {

 

    public static void main(String[] args) {

       int[] arr ={1,100};

       new Main011().getavage(arr, 2);

    }

    public void getavage(int[] arr,int num){

       if(num==0){

           System.out.println("数组为空");

       }else{

           double avage = 0.0;

           int sum = 0;

           int count1=0;

           int count2=0;

           for(int i=0;i<arr.length;i++){

              sum += arr[i];

           }

           avage = (double)sum/num;

           for(int j =0;j<num;j++){

              if(arr[j]>avage){

                  count1++;

              }else{

                  count2++;

              }

           }

           System.out.println("平均值:"+avage);

           System.out.println("大于平均值的元素个数:"+count1);

           System.out.println("小于平均值的元素个数:"+count2);

       }

    }

}

 

/*

 * 功能描述:已知:yier sansi wu liu qi ba jiu 分别对应123456789

        对一段只含有这几种字符串的字符串进行转换,如:

        输入:yiersansan

        输出:1233

 */

public class Main012 {

    public static void main(String[] args) {

       Replace("yiersansan","yi","1");

       System.out.println(Replace("yiersansan","yi","1"));

    }

    public static String Replace(String source,String oldString,StringnewString){

        if (source ==null) {

            return null;

        }

        StringBuffer output = new StringBuffer();

        int lengOfsource = source.length();

        int lengOfold = oldString.length();

        int posStart;

        int pos;

        for (posStart = 0;(pos =source.indexOf(oldString, posStart))>=0;posStart=pos+lengOfold){

           output.append(source.substring(posStart,pos));

            output.append(newString);

        }

        if (posStart < lengOfsource) {

           output.append(source.substring(posStart));

        }

        return output.toString();

    }

}

/*

 * 功能描述:删除字符串中字符个数最少的字符,最少字符串有多个,最少的要全部删除

               然后返回该子字符串。

          输入:asdasdas

          输出:asasas

 */

public class Main013 {

 

    /**

     * 一、创建HashMap,然后统计字符串每个字母的次数,将字母作为HashMap的键,

     *      字母出现的次数作为值

                  二、得到最小的值,然后得到对应的字母

                  三、String.split("字母"),得到不包含该字符的字符串数据

                   四、用StringBuffer将这些字符串连接起来,最终得到需要的字符串

     * @param args

     */

    public static void main(String args[]){

       String str;

       int flg[] =new int[200];//只考虑小写或者大写的字母

       int min=5;

       char c='c';

       Scanner s = new Scanner(System.in);

       List<Object> v = new ArrayList<Object>();

       str=s.next();

       for(int i=0;i<str.length();i++){

       char ch =str.charAt(i);

       min=((++flg[ch]<min) ? flg[ch]:min);

       if(min<=flg[ch]){

       c=ch;

       }

       }

       for(int i=0;i<str.length();i++){

       char ch=str.charAt(i);

       if(ch==c){

       }else{

       v.add(ch);

       }

       }

       String ss=v.toString();

       System.out.println(ss);

 

       }

 

}

 

/*

 * 功能描述:找出一个int[]中满足 2^n的数字,然后组成的新的数组

输入:{4,38}

输出:{4,8}

 */

public class Main014 {

    /**

     * @param args

     */

    public static void main(String[] args) {

       int[] data1={256,2,4,3,1,15,16,28,44,32,64};

       int[] data2=nestString(data1);

       System.out.println(Arrays.toString(data2));

    }

    private static int[] nestString(int[] data) {

       List<Integer> list=new ArrayList<Integer>();

       for (int i = 0; i < data.length; i++) {

           int temp = data[i];

           while (temp != 2) {

           if (temp %2== 0) {

              temp /=2;

           }else {

              break;

           }

       }

           if (temp==2) {

              list.add(data[i]);

           }

     }

       int [] data2=newint[list.size()];

       for (int i = 0; i < list.size(); i++) {

           data2[i]=list.get(i);

       }

       return data2;

    }

}

 

/*

 *

功能描述:共data1个人,围成一圈,然后标号,从1-data1

                 然后从data2号开始从1报数,报3的出列,求出列序列。

                返回一个数组

如:

输入:32

输出:1,2,3

要求实现方法:

/*

 * data1:人数

 * data2 : 起始位置

 *

    public int[] circleOut(int data1,int data2)

    {

         int outNum = 3;

        //TODO

        return null;

    }

 */

public class Main015 {

/**

 * 约瑟夫环问题

 */

private static int count=0;//定义数到的人的编号count

public static void main(String[] args) {

    Scanner scanner=new Scanner(System.in);

    System.out.println("请输入人数:");

    int n=scanner.nextInt();

    System.out.println("请输入出局号码:");

    int m=scanner.nextInt();

    long s1  = System.currentTimeMillis();

    sortP(n,m);         

    long s2  = System.currentTimeMillis();    

    System.out.println("所用总时间:"+(s2-s1));

}

 

private static void sortP(int n,int m) {

    if(n==1){//特殊情况

       System.out.println(n);;

    }else {

       f1(n, m);

    }

}

//当人数大于1时执行此函数

private static void f1(int n,int m) {   

    int[] arr =new int[n];

    for(int j=0;j<n;j++){//循环执行n(总人数)次,排出出局次序

       for(int i = 0;i<m;i++){               

           count++;//每数一人count1

           measure(j, arr);//判断count是否已在数组中

           if(count>n){

              count=1;//count大于总人数将其置1

              measure(j, arr);//继续进行判断

           }            

       }

       arr[j]=count;//将出局人序号保存至数组

    }

    System.out.println("出局顺序为:"+Arrays.toString(arr));

    System.out.println("最后出局人为:"+arr[n-1]);

}

 

/*用于判断count是否已存在,若存在count1继续判断

 * 此函数用双重循环,若为单重不能保证count在数组唯一

 * */

private static void measure(int j,int[] arr) {

    for(int s = 0;s<j;s++){

       for(int w=0;w<j;w++){

           if(count==arr[w])count++;

       }

    }         

}

}

/*

 * 功能描述:统计一个数字转为二进制后,01的个数,组成数组返回

输入:6

输出:{1,2}

 */

public class Main016 {

 

    public static void main(String[] args) { 

        test(); 

        test2();

    } 

    /**

     * 统计二进制数中0的个数[除法操作]

     */ 

    public static void test() { 

        int d = 6; 

        int count = 0; 

        while (d != 0) { 

            if (d % 2 == 0) { 

                count++; 

            } 

            d /= 2; 

        } 

        System.out.println(count); 

    } 

 

    /**

     * 统计二进制数中0的个数[与操作]

     */ 

    public static void test1() { 

        int d = 6; 

        int count = 0; 

        while (d != 0) { 

            if ((d & 0x01) != 1) { 

                count++; 

            } 

            d >>= 1; 

        } 

        System.out.println(count); 

    } 

    /**

     * 统计二进制数中1的个数的方法。时间复杂度只与1的个数有关。

     */ 

    public static void test2() { 

        int n = 6; 

        int count = 0; 

        while (n != 0) { 

            count++; 

            n = n & (n - 1); 

        } 

        System.out.println(count); 

    } 

}

 

 

/*

 * 功能描述:对一个二进制数的每位进行01反转,求翻转后的二进制所对应的十进制

输入:110

输出:5

 

 */

public class Main017 {

 

    public static void main(String[] args) { 

        test(); 

    } 

    /**

     * 反转二进制数并输出结果的十进制值是多少

     */ 

    public static void test() { 

        int d = 110; 

        int len = Integer.toBinaryString(d).length(); 

        int b[] =new int[len]; 

        int index = 0; 

        while (d != 0) { 

            b[index++] = d & 0x01; 

            d >>= 1; 

        } 

        int c = 0; 

        d = 0; 

        while (c < len) { 

            d = d * 2 + b[c]; 

            c++; 

        } 

        System.out.println(d); 

    } 

}

 

/*

 * 功能描述:判断一个字符串中的"( )"是否配对

输入:if(a.equals(a))

输出:true

 

 */

public class Main018 {

   public static void main(String[] args) {

         System.out.println(isStack("{}{}{{{}sss}}"));

        // System.out.println(isStack("{"));

        // System.out.println(isStack(""));

        // System.out.println(isStack("{{fdsfs}}{}")); 

         System.out.println(isStack("{}}"));  

        }

        private static boolean isStack(Stringstring) {

         Stack<Character>stackz = new Stack<Character>();

         for (int i = 0; i <string.length(); i++) {

          if (string.charAt(i)=='{') {

          stackz.push(string.charAt(i));

          } else if (string.charAt(i)== '}') {

           if (stackz.isEmpty()){

            return false;

           } else {

            stackz.pop();

           }

          }

         }

         if (stackz.isEmpty()){

          return true;

         } else {

          return false;

         }

        }

}

 

/*

 * 功能描述:查找一个字符串的子字符串集

输入:abab

输出:a bab ba aba bab

 */

public class Main019 {

    /**

     * @param args

     */

    public static void main(String[] args) {

       perenum("abcdef",3);

    }

    public static ArrayList<String> perenum(String str,int m)

    {  

       ArrayList<String>  strArr = new ArrayList<String>();  

       Find(strArr,"",str);

       return null;

    }

    public static String Find(ArrayList<String> strArr,StringstrBef,String str)

    {  

       for(int i=0 ;i<str.length();++i)

       {

           String allstr = strBef+str.charAt(i);

           String str1=str.substring(i+1);

           Find(strArr,allstr,str1);

           strArr.add(allstr);

           System.out.print(allstr+"\n");

       }

            return str;

    }

 

}

/*

 * 功能描述:数组的循环移位,

输入:{a,b,c,},2

输出:{b,c,a}

 */

public class Main020 {

 

    /**

     * @param args

     */

    public static void main(String[] args) {

         int[] n ={7,4,8,9,1,5};

          char[]n2={'a','b','c'};

         for(int i=0;i<n.length;i++){

          outNum(n);

          System.out.println();

          moveNum(n);

         }

        } 

        private static void moveNum(int[] n) {//数组元素移位

         int temp = n[n.length-1];

         for(int i=n.length-1;i>0;i--){

          n[i] = n[i-1];

         }

         n[0] = temp;

        } 

        private static void outNum(int[] n) {//输出数组

         for(int i=0;i<n.length;i++){

          System.out.print(n[i]);

         }

       }     

}

 

/*

 * 程序实现目标:输入一个字符,将字符转换为小写,将其对应的ASCII值加5后,输出结果。

 

         程序要求:若其值加5后的字符值大于'z',将其转换成从a开始的字符。

       输入:‘A’

      输出:‘f’

 */

public class Main021 {

   public static void main(String[] args) {

       Main021 test = new Main021();

       String data = "q";

       String regex = "^[a-z]*$";

       if (data.matches(regex)) {

       System.out.println(test.getString(data));

       } else {

       System.out.println("输入的字符串不合法");

        }

       }

       public char[] getString(String data) {

       char[] arr = data.toCharArray();

       for (int i = 0; i < arr.length; i++) {

       if (arr[i] + 5 >'z') {

       arr[i] = (char) (arr[i] - 21);

       } else {

       arr[i] = (char) (arr[i] + 5);

       }

       }

       return arr;

       }

}

/*

 * 要求:将一个二维数组进行逆序,逆序后所有的元素行列不定,进行随机排列

 */

public class Main022 {

    /**

     * @param args

     */

    public static void main(String[] args) {

       // TODO Auto-generatedmethod stub

    }

 

}

 

/*

 * 根据输入m数据,找出strm个字符的所有字符串

例如"abc"m=2

"ab" "ac""bc"

"abcd" m=3

"abc" "acd""bcd" "abd"

 */

public class Main023 {

    public static void main(String[] args) {

       perenum("abcdef",3);

    }

    public static ArrayList<String> perenum(String str,int m)

    {  

       ArrayList<String>  strArr = new ArrayList<String>();   

       Find(strArr,"",str,m);

       return null;

    }

    public static String Find(ArrayList<String> strArr,StringstrBef,String str,int m)

    {  

       for(int i=0 ;i<str.length();++i)

       {

           String allstr = strBef+str.charAt(i);

           String str1=str.substring(i+1);

           Find(strArr,allstr,str1,m);

           strArr.add(allstr);

           if (allstr.length()==m) {

              System.out.print(allstr+"\n");

           }      

       }         

       return str;

    }

}

 

/*

 * 分解质因数

   eg:输入 28

       输出 2*2*7

 */

public class Main024 {

    static boolean is_odd(int n)

      {

       if(n==2||n==3)return true;

       if(n%2==0)return false;

       int i;

       for(i=3;i<=n/2;i+=2)

        if(n%i==0)return false;

       return true;

      }  

      public static void main(String[]args)

      {

         try { Scanner in=new Scanner(System.in);

          System.out.println("输入数值");

          int n=in.nextInt();

          int i;

          System.out.print(n+"=");

          for(i=2;i<=n;i++)

          {

           if(!is_odd(i))continue;

           if(n%i==0)

           {

            while(true)

            {

             System.out.print(i);

             n/=i;

             if(n!=1) System.out.print("*");

             if(n%i!=0)break;

            }

           }

          }

          System.out.println();          

       } catch (Exception e) {

           System.out.println("输入的不是整数!");

           //e.printStackTrace();

           System.exit(0);

       }     

}

      }

 

/*

 * n个长度的字符串中取m个长度的组合

 */

public class Main025 {

 

    /**

     * @param args

     */

    public static void main(String[] args) {

       perenum("abcdef",3);

    }

    public static ArrayList<String> perenum(String str,int m)

    {  

       ArrayList<String>  strArr = new ArrayList<String>();   

       Find(strArr,"",str,m);   

       return null;

    }

   

    public static String Find(ArrayList<String> strArr,StringstrBef,String str,int m)

    {  

       for(int i=0 ;i<str.length();++i)

       {

           String allstr = strBef+str.charAt(i);

           String str1=str.substring(i+1);

           Find(strArr,allstr,str1,m);

           strArr.add(allstr);

           if (allstr.length()==m) {

              System.out.print(allstr+"\n");

           }          

       }          

       return str;

    } 

}

 

/*

 *   二维数组转置

例:1 2 3

    4 5 6

 

转置

    1 4

    2 5

    3 6

 */

public class Main026 { 

    /**

     * @param args

     */

    public static void main(String[] args) {

       int[][] aa={{1,2,3},{4,5,6}};

       int[][] bb=turn(aa);

       for(int[] ii:bb){

           for(int i:ii){

              System.out.print(i+" ");

           }

           System.out.println();

       }

    }

public static int[][] turn(int[][] aa) {

    int lencol=aa[0].length;

    int lenrow=aa.length;

    int [][] rr=newint[lencol][lenrow];

    for (int i = 0; i < lencol; i++) {

       for (int j = 0; j < lenrow; j++) {

           rr[i][j]=aa[j][i];

       }

    }

    return rr;

}

}

}

/*

 * 功能描述:输入字符串,将该字符串中数字放到非数字的后面,并保持原有顺序不变。

例如:h3a2p0p1y----------happy3201

 */

public class Main027 {

    /**

     * @param args

     */

    public static void main(String[] args) {

           sof("h3a2p0p1y");

    }

    public static String  sof(StringinString) {

       char[] t=inString.toCharArray();

       ArrayList<String> list1=new ArrayList<String>();

       ArrayList<String> list2=new ArrayList<String>();

       for (int i = 0; i < t.length; i++) {

           if (t[i]>=48 && t[i]<=57) {

              list1.add(t[i]+"");

           }else if((t[i]>=97&&t[i]<=122)||(t[i]>=65&&t[i]<=91)) {

              list2.add(t[i]+"");

           }

       }

       String string1="";

       for (Iterator iterator = list2.iterator();iterator.hasNext();) {

           string1=string1+(String)iterator.next();

          

       }

       String string2="";

       for (Iterator iterator = list1.iterator();iterator.hasNext();) {

           string2=string2+(String)iterator.next(); 

       }

       System.out.println(string1+string2);

       return string1+string2;

    }

}

 

/*

 * 有一个字符串,请将其中的数字按大小排序

要求:用最简单的方式实现,考虑性能

输入:  "32, 43, 76, 4, 54, 2, 93, 1"

 

 */

public class Main028 {

    /**

     * @param args

     */

    public static void main(String[]args){

         String str=new String("13a64bc52");

         char[]strArray=str.toCharArray();

         List<Character>a=new ArrayList<Character>();

         List<Integer> b=newArrayList<Integer>();

         for(int i=0;i<strArray.length;i++)

         {

          if(strArray[i]<='9'&&strArray[i]>='0')

          a.add((Character)strArray[i]);

          else

           b.add((Integer)i);

         }

         int [] integerArray=newint[a.size()];

         for(inti=0;i<a.size();i++)

         integerArray[i]=Character.digit((char)a.get(i), 10);

         integerArray=bubbingSort(integerArray);

         int [] rs=newint[str.length()];

         int count=0;

         for(int i=0;i<rs.length;i++)

         {

          for(Iterator<Integer>it=b.iterator();it.hasNext();)

          {

           int x=it.next();

           rs[x]=strArray[x];

          }

          if(rs[i]!=0)

           continue;

          else

           {

          rs[i]=integerArray[count];

           count++;

          }

         }

         for(int i=0;i<rs.length;i++)

         {

          if(rs[i]>9||rs[i]<0)

           System.out.print((char)rs[i]);

          else

           System.out.print(rs[i]);

         }

        }

        public static int[] bubbingSort(int[] a){

         int swap=0;

         for(int i=a.length-1;i>=0;i--)

          for(int j=0;j<i;j++)

          {

           if(a[i]<a[j])

           {

            swap=a[i];

            a[i]=a[j];

            a[j]=swap;

           }          

          }

         return a;

        }}

 

/*

 * 从一个字符串中返回给定单词的位置,如果有多个,则返回第一次出现的位置,如果没有,则返回0

例子:"hello world","hello"

结果:1

 */

public class Main029 {

 

    /**

     * @param args

     */

    public static void main(String[] args) {

      

       System.out.println(theLocation("ahello  world","hello"));

    }

    public static int theLocation(String str1,String str2) {

    int sum=0;

    if (str1.contains(str2)) {

       String [] arrray1=str1.split(" ");

       for (int i = 0; i < arrray1.length; i++) {

           if (arrray1[i].trim().equals("")) {

              ++sum;

           }

           if (str2.equals(arrray1[i])) {

              return i-sum+1;

           }

           System.out.println(arrray1[i]);

       }

    }

    return 0;

}

}

 

/*

 * 输入是一个表达式,比如说是1*2-3+4*5,要求计算出这个表达式的值。

 

思路:不瞻前,只顾后。

 

在计算的时候,如果当前运算符是乘除法,则直接计算出来,再考虑后续的。

如果当前的操作符不是乘除,则顾后,查看后面的操作符是不是乘除法,

如果是乘除法,则计算乘除法,否则把当前的加减法计算出来,再计算后续的。

 */

public class Main030 {

 

    public static void main(String ss[]) { 

        String s = "1+2*3*4+5"

        System.out.println(calculate(s.toCharArray())); 

    } 

 

    private static double calculate(char[] expr) { 

        double c1 = Double.parseDouble(expr[0]+""); 

        double c2 = Double.parseDouble(expr[2]+""); 

        int index = 3; 

        char op = expr[1]; 

        while (index < expr.length) { 

            if (expr[index] =='*' || expr[index] == '/') { 

                // 如果是乘除法,则先计算 

                c2 = cal(c2, Double.parseDouble(expr[index+ 1] +""), 

                        expr[index]); 

            } else

                // 如果不是乘除法,则计算出来结果 

                c1 = cal(c1, c2,op); 

                op = expr[index]; 

                c2 = Double.parseDouble(expr[index+ 1] +""); 

            } 

            index += 2; 

        } 

        returncal(c1, c2, op); 

    } 

 

    private static double cal(double a,double b, char op) { 

        switch (op) { 

        case '+'

            return a + b; 

        case '-'

            return a - b; 

        case '*'

            return a * b; 

        case '/'

            return a / b; 

        } 

        return -1; 

    } 

 

}

 

/*

 * 最长公共子串和最长公共子序列

 */

public class Main31 {

    public static void main(String ss[]) { 

        get("abcdefg","hbcsefgk"); 

    } 

 

    private static void get(String s1, String s2) { 

 

        int lcslen = 0; 

        int pos_x = -1, pos_y = -1; 

        // 初始化二维数组 

        int flag[][] =new int[s1.length() + 1][s2.length() + 1]; 

        for (int i = 0; i < s1.length() + 1; i++) { 

            flag[i][0] = 0; 

        } 

        for (int i = 0; i < s2.length() + 1; i++) { 

            flag[0][i] = 0; 

        } 

 

        for (int i = 1; i <= s1.length(); i++) { 

            for (int j = 1; j <= s2.length(); j++) { 

                if (s1.charAt(i - 1) == s2.charAt(j - 1)){ 

                    flag[i][j] = flag[i - 1][j- 1] + 1; 

                    if (flag[i][j] > lcslen) { 

                        lcslen =flag[i][j]; 

                        pos_x = i;// 记录下最大长度在二维数组中的位置 

                        pos_y = j; 

                    } 

                } else

                    flag[i][j] = 0; 

                } 

            } 

        } 

        // 方便观察,输出二维矩阵 

        for (int i = 0; i < s1.length() + 1; i++) { 

            for (int j = 0; j < s2.length() + 1; j++) { 

                System.out.print(flag[i][j]); 

            } 

            System.out.println(); 

        } 

        // 输出最长子串 

        StringBuilder sb = newStringBuilder(); 

        while (flag[pos_x][pos_y] != 0) { 

            sb.append(s1.charAt(pos_x -1)); 

            pos_x--; 

            pos_y--; 

        } 

        System.out.println(sb.toString()); 

    } 

}

 

相关文章推荐

华为嵌入式面试题及参考答案

(1)什么是预编译,何时需要预编译: 答案: 1、总是使用不经常改动的大型代码体。 2、程序由多个模块组成,所有模块都使用一组标准的包含文件和相同的编译选项。在这种情况下...

华为C语言试题及参考答案

  • 2012年05月08日 12:43
  • 4KB
  • 下载

非常全的linux面试笔试题及参考答案

一.填空题: 1. 在Linux系统中,以 文件 方式访问设备 . 2. Linux内核引导时,从文件/etc/fstab 中读取要加载的文件系统. 3. Linux文件系统中每个文件用 i节点来标...

《招聘一个靠谱的iOS》|| 文章 || 面试题 || 参考答案

招聘一个靠谱的 iOS 近一年内陆续面试了不少人了,从面试者到面试官的转变让我对 iOS 招聘有了更多的感受。经过了前段时间的一大波面试,我们终于找到了志同道合的小伙伴,面试也暂时告一段落了。总...

面试题集锦及参考答案

一、String,StringBuffer, StringBuilder 的区别是什么?String为什么是不可变的? 参考答案:String,StringBuffer, StringBuilder...

.NET 面试题总结 (附有参考答案) 第1部分

什么是面向对象? 面向对象OO = 面向对象的分析(OOA) + 面向对象的设计(OOD) + 面向对象的编程(OOP); 通俗的解释就是万物皆对象,把所有的事物都看作一个个可以独立的对象(单元)...

阿里巴巴公司DBA笔试题及参考答案

一:SQL tuning 类   1:列举几种表连接方式   2:不借助第三方工具,怎样查看sql的执行计划   3:如何使用CBO,CBO与RULE的区别   4:如何定位重要(消...

2014-04-17-网易有道-研发类-笔试题&参考答案

一套卷子,共10道小题,3道变成编程大题

网友整理的Android面试题集-附网友提供的参考答案

1. 什么是Activity? 四大组件之一,一般的,一个用户交互界面对应一个activity setContentView() ,// 要显示的布局 , activity 是Context的子...

非常全的linux面试笔试题及参考答案

一.填空题: 1. 在Linux系统中,以 文件 方式访问设备 。 2. Linux内核引导时,从文件 /etc/fstab 中读取要加载的文件系统。 3. Linux文件系统中每个文件用 i节...
内容举报
返回顶部
收藏助手
不良信息举报
您举报文章:华为机试题及参考答案
举报原因:
原因补充:

(最多只允许输入30个字)