中软--华为机试题

  本人来到中软已经近一个月了，由于近来一直呆在资源池内修炼，都快生锈了，闲来无事，就将可能出现的中软机试考试题总结如下希望后来人可以参考！（仅供参考，如有意见请关闭本页面，装着没看见！）

一 字符串操作题；

    

package com.cs.arith;

import java.util.Arrays;
import java.util.Scanner;


/**
 * @author Cloud_zp
 * @category 字符串操作
 * 题目 ：输入一串数据，删除重复的数据。注意：读取字符串的顺序为从右往左，如果结果为0结束，则删除0；
 *     如果结果为负号‘-’就保留；
 * 例如：输入99876673 输出37689，输入 0542564 输出:4652 输入：-235432 输出：-2345
 * 
 *  
 *  
 */
public class ArithMetic {
	public static void main(String[] args) {
	 Scanner scan = new Scanner(System.in);
	 System.out.println("请输入一串字符。。。。。。。。。");
	 String str = scan.nextLine();
	 //首先将字符串倒叙
	 StringBuffer sb = new StringBuffer(str);
	 sb.reverse();
	 System.out.println("倒叙后的结果："+sb);
	 //将字符串转换成byte数组进行判断操作
	 byte[] bt = sb.toString().getBytes();
	 for (int i = 0; i < bt.length-1; i++) {
		for (int j = i+1; j < bt.length; j++) {
			//如果出现相同字符串，将字符换为空；
			if(bt[i]==bt[j]){
				bt[j]=' ';
			}
		}
	}
	 
	 str = new String(bt).replace(" ","");
	 //如果以0结尾去掉，如果以‘-’结尾将‘-’换到字符串的开头；
	 if(str.endsWith("0")){
		 str = str.substring(0,str.length()-1);
	 }else if(str.endsWith("-")){
		 str ="-" + str.substring(0,str.length()-1);
	 }
	 System.out.println(str);
	}

}

二 邮箱验证

  

package com.cs.arith;

import java.util.Scanner;

/**
 * @author Cloud_zp
 * @category 邮箱合法性检验；
 * 题目：邮箱地址合法性检验，合法输出字符“1”，不合法输出字符“0”
 * 合法条件：
 *  1 仅包含一个@。
 *  2 最后三位必须是“.com”.
 *  3 字符直接之间没有空格。
 *  4 有效数字是1~9，a~z、A~Z "." "@","-";
 * 
 */
public class EmailTest {
    public static void main(String[] args) {
		Scanner scan = new Scanner(System.in);
		System.out.println("请输入邮箱地址");
		String email = scan.nextLine();
		/**
		 * 正则表达式解释：
		 * ^:表示表达式开始；
		 * [a-z0-9A-Z//-]：表示这段字符允许出现的内容,其中//表示转意符号说明后面紧跟的符号为特殊符号，我试过了不是用转意也可以，但是后面出现"."的

               * 时候就必须使用转意符号了；
		 * +：表示前面的表达式可以出现一次或者多次；
		 * $:表示表达式结尾；
		 * 
		 */
		boolean flag = email.matches("^([a-z0-9A-Z\\-]+@([a-z0-9A-Z]+)\\.)com$");
		if(flag){
			System.out.println("1");
		}else{
			System.out.println("0");
		}
	}
}

三 分苹果

 

package com.cs.arith;

/**
 * @author Cloud_zp
 * @category 分苹果
 * 题目：有m个苹果分到n个相同的篮子里。允许有的篮子为空，一共有多少种分发？
 * 其中:0<=m<=10,0<=n<=10;
 * 
 */
public class BranchApple {
     public static void main(String[] args) {
		 System.out.println(branch(4,3));
	}
    public static int branch(int m,int n){
    	//如果拥有0个苹果或者拥有0个篮子，那么分发就是0种
    	if(m==0||n==0){
    		return 0;
    	}
   	 //如果拥有m个苹果，m》0那么只有一个篮子或者只有一个苹果拥有0个篮子，那么
    //都只有一种分法；
    	if(m==1||n==1){
    		return 1;
    	}
    //其他情况；
    	return (m+1)*(n-1);
    }
}

四 字符串翻转

package com.cs.arith;


import java.util.Scanner;


/**
 * @author Cloud_zp
 * @category 字符串反转 题目：输入一个字符。交换前后顺序后在输出。
 * 
 * 
 */
public class StringReverse {
	public static void main(String[] args) {
        Scanner scan = new Scanner(System.in);
        System.out.println("请输入一个字符串");
        String tager = scan.nextLine();
        StringBuffer sb = new StringBuffer(tager);
        sb.reverse();
        System.out.println(sb.toString());
	}
}

五 成绩计算

package com.cs.arith;

import java.util.Scanner;

/**
 * @author Cloud_zp
 * @category 成绩运算  
 * 题目：输入一个同学各科的高考成绩，计算出他的成绩和平均分，共四门课程，每个成绩范围
 * 0-150，超过范围则不计算在总分内 （但科目永远是四门）* 
 */
public class ScoreTest {
	 private static double count;
     public static void main(String[] args) {
    	 int i=0;
    	 while(i<4){
    		 countScore();
    		 i++;
    	 }
    	 System.out.println("总成绩是："+count);
    	 System.out.println("平均绩是："+count/4);
	}
     public static void countScore(){
    	Scanner scan = new  Scanner(System.in);
 		System.out.println("请输入成绩");
     	double score = scan.nextDouble();
     	if(score<=150&&score>=0){
     		count +=score;
     	}
     }
}

六 数列求和

package com.cs.arith;

/**
 * @author Cloud_zp
 * @category 数列求和
 * 题目：编写程序，输入一个正整数n，求下列算式的值。要求定义和调用函数fack(k)来计算
 * k的阶乘，函数返回值类型是double。
 * 1+1/2+...+1/n!
 * 输出保留5位小数。
 * 例子：
 * 输入:5
 * 输出:2.71667
 * 
 */
public class TestDemo {

	
	public static void main(String[] args) {
	 int n = 5;
	 double number = 0;
	 for (int i = 0; i <= n; i++) {
		number += 1/fack(i);
	}
	 System.out.println(number);

	}
	//阶乘表达式
	public static double fack(int k){
		if(k==1){
			return 1;
		}
		if(k>1){
			return k*fack(k-1);
		}
		return 1;
	}

}

七 字符串操作；

  

package com.cs.arith;

import java.util.Scanner;

/**
 * @author Cloud_zp
 * @category 字符串操作；
 * 题目：程序实现目标：输入一个字符串，将其中个个字符对应的ASCll值加5后，输出结果。
 * 程序要求：该字符串只包括小写字母，若他的值加5后大于’z‘,将其转换成从a开始的字符；
 * 
 * 
 */
public class TestDemo2 {

	
	public static void main(String[] args) {
		Scanner scan = new Scanner(System.in);
		System.out.println("请输入字符串");
		String str = scan.nextLine();
		//将字符串转换成char数组；
		char[] chars = str.toCharArray();
        for (int i = 0; i < chars.length; i++) {
        	//给每个字符的ASSCll值加上5；
        	int cn = (int)chars[i]+5;
        	//判断如果值大于z字母的Asscll值就将该字母从a开始重新编排；
        	if(cn>(int)'z'){
        		cn=cn-(int)'z'+(int)'a'-1;
        	}
        	chars[i]=(char)cn;
		}
        System.out.println(new String(chars));
	}

}

八 整型数组操作

package com.cs.arith;

import java.util.Scanner;



/**
 * @author Cloud_zp
 * @category 数组操作问题
 * 题目：求一个整形数组中的元素的平均值，并统计其中大于和小雨次平均值的元素个数。
 * 要求：
 *  输入：整形数组中的元素个数及各个元素。
 *  输出：整型数组中元素的平均值，大于和小于此平均值的元素个数。
 */
public class TestDemo3 {
    public static void main(String[] args) {
	//元素个数；
	int count=0;
	//数组内元素求和
	int sum = 0;
	//平均值
	double avg = 0;
	Scanner scan = new Scanner(System.in);
	System.out.println("请输入个数");
        //接受数组长度；
	int number = scan.nextInt();
	int[] ints = new int[number];
	for (int i = 0; i < ints.length; i++) {
	    System.out.println("请输入"+i+"个元素");
	    ints[i]=scan.nextInt();
	    sum += ints[i];
	}
	//求取平均值；
	avg = sum/number;
	
	//再次遍历数组得到元素值大于平均值的元素个数；
	for (int i = 0; i < ints.length; i++) {
	    if(ints[i]>avg){
		count++;
	    }
	}
	System.out.println("平均值是："+avg+"\n大于平均值的元素个数："+count);
    }
}

九 回文验证；

    

package com.cs.arith;

/**
 * @author Cloud_zp
 *
 * @category 回文数字判断
 * 题目：有这样一类数字，他们顺着看和倒着看是相同的数，例如121，656，2332等，
 * 这样的数字称为：回文数字。编写一个函数，判断某数字是否是回文数字。
 * 要求实现方法：
 *  public String isPalindrome(String strln);
 *  输入：strln：整数，以字符串表示；
 *  输出：true :表示是回文；
 *      false:表示不是回文；
 *  注意：只需要完成函数的算法功能，中间不需要有任何io的输入输出流
 *  例子：
 *  输入：strln=121
 *  输出：true
 */
public class TestDemo4 {

   
    public static void main(String[] args) {
	TestDemo4 demo = new TestDemo4();
	System.out.println(demo.isPalindrome("11211"));;

    }
    public String isPalindrome(String strln){
	StringBuffer sb = new StringBuffer(strln);
	//使用buffer的reverse（）方法将原有字符串倒转，
	sb.reverse();
	//与原有字符串进行比较如果相同表示是回文，不相同表示不是回文；
	System.out.println(sb);
	if(sb.toString().equals(strln)){
	    return "true";
	}else{
	    return "false";
	}
    }

}

十 打印字符串；

  

package com.cs.arith;

import java.util.Random;
import java.util.Set;
import java.util.TreeSet;


/**
 * @author Cloud_zp
 *
 * @category 字符串操作
 * 题目：随即打印50个随即（4-10长度）的字符串，要求字符串包含范围是所有的英文字母无论大小写包，
 * 含所有的数字，按照编码顺序排序，每次打印4个，要求首字母对齐；
 */
public class TestDemo5 {
    
        public static void main(String[] args){  
             Set<String> set = new TreeSet<String>();
            for (int i = 1; i < 51; i++) {
		set.add(getString().substring(0, 10));
	    }
            int count =1;
            for (String string : set) {
		if(count%4==0){
		    System.out.println(string);;
		}else{
		    System.out.print(string+"\t");
		}
		count ++;
	    }
       }
        /**
         * 随即获取一个字符串长度4-10不等
         */
        public static String getString(){
            Random random = new Random();
            int length =(random.nextInt(7)+4);
            char[] chars = new char[length];
            //产生随机数决定每个字符串的长度4-10位
            for(int i=0;i<length;i++){
        	//产生一个随机数，用来判断产生字符的类型，是小写字母，还是大写字母，还是数字；
        	int flag = random.nextInt(3);
        	//flag为0产生一个小写字母
        	if(flag==0){
        	    chars[i] = (char)(random.nextInt(26)+(int)'a');
        	}
        	//flag为1产生一个大写字母
        	if(flag==1){
        	    chars[i] = (char)(random.nextInt(26)+(int)'A');
        	    
        	}
        	//flag为2随即随机产生一个数字2
        	if(flag==2){
        	    chars[i] = (char)(random.nextInt(10)+'0');
        	}
            }
            //返回字符串中不够十位的用空格补齐
            return new String(chars)+"      ";
        }
        
}  

十一 字符串操作

  

package com.cs.arith;

import java.util.HashMap;
import java.util.Map;

/**
 * @author Cloud_zp
 *
 * @category 字符串操作；
 * 题目：已知：：yi  er san  si  wu liu qi ba  jiu 分别对应123456789，
 * 对一段只含有这种字符的字符串进行转换，例如：
 * 输入：yiersansan
 * 输出:1233
 * 要求实现方法：
 * public String trunNumber(String data){
 * 	//TODO
 *     return  "";
 * }
 */
public class TestDemo6 {
   
    public static void main(String[] args) {
	TestDemo6 demo = new TestDemo6();
	System.out.println(demo.trunNumber("1888888"));;
    }
    
    public String trunNumber(String data){
	Map<Character,String> map = new HashMap<Character,String>();
	StringBuffer sb = new StringBuffer();
	map.put('1', "yi");
	map.put('2', "er");
	map.put('3', "san");
	map.put('5', "wu");
	map.put('6', "liu");
	map.put('7', "qi");
	map.put('8', "ba");
	map.put('9', "jiu");
	char[] chars  = data.toCharArray();
	for (int i = 0; i < chars.length; i++) {
	    sb.append(map.get(chars[i]));
	}
	return sb.toString();
    }
}

第十二 字符串操作

  

package com.cs.arith;

import java.util.HashMap;
import java.util.Map;
import java.util.Map.Entry;


/**
 * @author Cloud_zp
 *
 * @category 字符串操作
 * 题目：手动输入一个字符串，仅限于小写字母，统计并输出在每个字符在字符串中出现的次数，并输出。提示（）
 *      可以使用Map）
 * 实例：aaabbbccc
 * 输出：a3
 *     b3
 *     c3 
 */
public class TestDemo8 {
    
    public static void main(String[] args) {
	check("aabbbbcccc");
    }
    
    public static void check(String str){
	//合法性检验
	boolean flag = str.matches("^[a-z]+$");
	if(flag){
        	char[] chars = str.toCharArray();
        	Map<Character, Integer> map = new HashMap<Character,Integer>();
        	
        	for (int i = 0; i < chars.length; i++) {
        	    if(map.containsKey(chars[i])){
        		map.put(chars[i],map.get(chars[i])+1);
        	    }else{
        		map.put(chars[i],1);
        	    }
        	}
        	for (Entry<Character, Integer> result : map.entrySet()) {
        	    System.out.println(result.getKey()+":"+result.getValue());
		}
	}else{
	    System.out.println("字符串不合法");
	}
    }
}

十二 字符串截取

package com.cs.arith;

/**
 * @author Cloud_zp
 * 
 * @category 字符串操作； 题目： 输入：a aa,cat tiger.123dd 输出：tiger
 *           功能描述：键盘输入一句话输出一句话中最长的单词，如果最长的出现多次，返回第一个。
 *           这句话只包含数字字母和标点。
 * */
public class TestDemo9 {

    public static void main(String[] args) {
	getStr("a aa,cat tiger.123dd");
    }

    public static void getStr(String str) {
	//按照要求将字符串截取成字符串数组；
	String[] consle = str.split("[\\.\\, ]");
	for (int i = 0; i < consle.length - 1; i++) {
	    for (int j = 1; j < consle.length; j++) {
		//将数组中的字符串与他之后的字符·串进行比较如果长度小于之后的字符串
		//就将前后交换；
		if (consle[i].length() < consle[j].length()) {
		    String temp = consle[i];
		    consle[i] = consle[j];
		    consle[j] = temp;
		}
	    }
	}
	System.out.println(consle[0]);
    }
}

十三  字符串转换

package com.cs.arith;

/**
 * @author Cloud_zp
 *
 * @category 字符串操作
 * 题目：将字符串中的字母全部替换成该字母的下一个字母，要是最后一位是z或者Z则替换为a或者A。
 * 输入：aBxyZ
 * 输出：bCyzA
 */
public class TestDemo10 {
    
   public static void main(String[] args) {
      System.out.println(getStr("aBxyZ"));;
   }
   public static String getStr(String str){
       char[] chars = str.toCharArray();
       for (int i = 0; i < chars.length; i++) {
	 if(chars[i]=='z'){
	    chars[i]='a';
	 }else if( chars[i]=='Z'){
	    chars[i]='A';
	 }else{
	     chars[i] = (char)(chars[i]+1);
	 }
      }
       return new String(chars);
   }
}

十四 字符串操作（重点）

package com.cs.arith;

import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.TreeMap;

/**
 * @author Cloud_zp
 *
 * @category 字符串操作
 * 题目：删除字符串中字符出现次数最少的字符，最少的要全部删除然后返回该字符串；
 * 输入：asdasdas
 * 返回：asasas
 */
public class TestDemo11 {
    
   public static void main(String[] args) {
       System.out.println(getStr("asdasdas"));;
   }
   public static String getStr(String str){
        //用来统计最少的那个字符串出现的次数出现次数；
       int min = str.length();
       //定义集合list用来记录最少出现字符串的下标；
       List<Character> list = new ArrayList<Character>();
       char[] chars = str.toCharArray();
       Map<Character, Integer> map = new HashMap<Character,Integer>();
       for (char c : chars) {
	   if(map.containsKey(c)){
	      map.put(c, map.get(c)+1);
           }else{
               map.put(c,1);
         }
       }
       //遍历集合找到出现次数最少的字符；
       for (char c : chars) {
	   //如果当前出现的字符次数小于等于最少字符出现次数，将当前字符记录在listji集合中；
	  if(min>map.get(c)){
	      //清空当前最少出现次数的记录；
	      min = map.get(c);
	      list.clear();
	      list.add(c);
	      //如果等于当前最少出现次数，就继续添加；
	  }else if(min==map.get(c)){
	      list.add(c);
	  }
       }
      for (Character c :list) {
	  //将出现较少的字符替换为空；
	str =str.replace(c+"", "");
      }
      return str;
   }
}