华为机试题总结

1.题目描述

数据表记录包含表索引和数值，请对表索引相同的记录进行合并，即将相同索引的数值进行求和运算，输出按照key值升序进行输出。

输入描述:

先输入键值对的个数然后输入成对的index和value值，以空格隔开

输出描述:

输出合并后的键值对（多行）

示例1

输入

4
0 1
0 2
1 2
3 4

输出

0 3
1 2
3 4

思路：这边是键值对，想到map集合，在map集合中键是不能重复，值会自动覆盖，而本题是将相同键对应的值相加，所以可以在map集合上稍微修改，即遇到键相同的情况，先取出键对应的值，将值相加后在添加。注意：这里可以看出键值对的顺序是没有改变的，所以选用TreeMap，而不能选用HashMap,如果使用HashMap那么输出的键值对是无序的。

代码实现

import java.util.*;
public class Main
{
    public static void main(String[] args)
    {
        TreeMap<Integer,Integer> treeMap = new TreeMap<>();
        Scanner scanner = new Scanner(System.in);
        int n = scanner.nextInt();
        for(int i=0;i<n;i++)
        {
            int key = scanner.nextInt();
            int value = scanner.nextInt();
            if(treeMap.containsKey(key))
            {
                treeMap.put(key,treeMap.get(key)+value);//先将键对应值取出，相加后在添加
            }
            else
            {
                treeMap.put(key,value);
            }
        }
        for(Integer key:treeMap.keySet())                //使用for each循环比迭代方便
        {
            System.out.println(key+" "+treeMap.get(key));//获取键对应值方法是get，不要记成getKey
        }
    }
}

2.题目描述

输入一个int型整数，按照从右向左的阅读顺序，返回一个不含重复数字的新的整数。

输入描述:

输入一个int型整数

输出描述:

按照从右向左的阅读顺序，返回一个不含重复数字的新的整数

示例1

输入

9876673

输出

37689

基本思路：该题要先反转，再去重，反转想到使用StringBuffer类的reverse函数，去重想到用set集合，但是注意题中是有序的，所以用LinkedHashSet集合。（注意该题一定要先反转，再去重，先去重，再反转是不行的）

方法一：使用LinkedHashSet集合，或根据HashSet添加重复元素时返回false来判断

代码实现：

import java.util.*;
public class Main
{
    public static void main(String[] args)
    {
        int count=0;
        Scanner scanner = new Scanner(System.in);
        //String str = scanner.nextInt().toString();
        String str = Integer.toString(scanner.nextInt());
        String str1 = new StringBuffer(str).reverse().toString();
        //System.out.println(str1);
        TreeSet<Character> set = new TreeSet<>();
        for(int i=0;i<str1.length();i++)
        {
        	if(set.add(str1.charAt(i))==true)
        	{
        		System.out.print(str1.charAt(i));
        	}
        }
｝

如果使用LinkedHashSet使用如下的代码

      Set<Character> set = new LinkedHashSet<>();
      for(int i=0;i<str1.length();i++)
      {
	   set.add(str1.charAt(i));
      }
      for(char ch:set)
      {
	   System.out.print(ch);
      }

方法二：取出最后一个字符，然后取第二个字符，如果不相等，将第二个字符添加到第一个字符的后面，再取第三个字符，依次类推。该方法频繁用到取字符一部分组成新字符的函数substring()

代码实现：

        Scanner in = new Scanner(System.in);
	while(in.hasNext())
	{
	    String str = in.next();
	    String a = str.substring(str.length()-1,str.length());
	    for(int i=str.length()-2;i>=0;i--)
	    {
		 if(!a.contains(str.substring(i,i+1)))
		     a = a + str.substring(i,i+1);
	    }
		 System.out.print(a);
	}

方法三：参考别人的优秀代码

	Scanner in = new Scanner(System.in);
	while(in.hasNext())
	{
		String str = in.next();
		for(int i=str.length()-1;i>=0;i--)
		{
			System.out.print(str.charAt(i));
		}
	}

6.题目描述

假设一个球从任意高度自由落下，每次落地后反跳回原高度的一半; 再落下, 求它在第5次落地时，共经历多少米?第5次反弹多高？  

/**
     * 统计出第5次落地时，共经过多少米?
     * 
     * @param high 球的起始高度
     * @return 英文字母的个数
     */
    public static double getJourney(int high)
    {
        return 0;
    }
    
    /**
     * 统计出第5次反弹多高?
     * 
     * @param high 球的起始高度
     * @return 空格的个数
     */
    public static double getTenthHigh(int high)
    {
        return 0;
    }

输入描述:

输入起始高度，int型

输出描述:

分别输出第5次落地时，共经过多少米第5次反弹多高

示例1

输入

1

输出

2.875
0.03125

基本思路：使用递归解决：可以简单推出，第n个落地经过的米数=n-1次落地经过的米数+高度/(2^(n-2))。

代码实现：

import java.util.*;
public class Main
{
    public static void main(String[] args)
    {
        Scanner in = new Scanner(System.in);
        while(in.hasNext())
        {
            int m = Integer.parseInt(in.next());
            System.out.println(getJourney(m,5));
            System.out.println(getTenthHigh(m,5));
        }
    }
     public static double getJourney(int high,int number)
	    {
	        if(number==1)
	            return high;
	        else 
	            return getJourney(high,number-1) + high/Math.pow(2,number-2);//Java的求次方要用函数
	    }
	    public static double getTenthHigh(int high,int number)
	    {
	        return high/Math.pow(2,number);
	    }
}

更优的方法（使用循环来替代递归）：