【牛客网：华为机试】08-15题

08. 合并表记录

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

思路：这题的键值对，还有key值升序，应该用map集合处理
map的方法：containsKey(key); map.keySet();

import java.util.*;
/**这里用到map集合知识*/
public class 合并表记录 {
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        SortedMap<Integer,Integer> map=new TreeMap<>();
        while (scanner.hasNext()){
            //键值对个数
            int n = scanner.nextInt();
            for (int i = 0; i < n; i++) {
                Integer index=scanner.nextInt();
                Integer value=scanner.nextInt();
                //如果之前的集合已经添加过这样的index,则会添加一个新的newValue
                if (map.containsKey(index)){
                    int newValue=map.get(index)+value;
                    map.put(index,newValue);
                }else {
                    map.put(index,value);
                }
            }
            //获取所有的key值，遍历key值，即所有的index值
            Set keys=map.keySet();
            Iterator it=keys.iterator();
            while (it.hasNext()){
                Object key = it.next();
                Object value=map.get(key);
                System.out.println(key+" "+value);
            }
        }
    }
}

---

09. 题目不重复的整数

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

方法1

思路一：使用字符串的相关方法，一次截取一个字符并去重
contains(String str)：判断参数str是否被包含在字符串中，并返回一个布尔类型的值。

1 String str = "student";
2 str.contains("stu");//true
3 str.contains("ok");//false

代码实现，方法一：

import java.util.Scanner;
public class Main {
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        while (scanner.hasNext()){
            String str = scanner.next();
            int length = str.length();
            //先将最后一个数取出，防止字符串越界
            String string = str.substring(length-1);

            //从右向左依次截取每个数并去重
            for(int i=length-2;i>=0;i--){
                String substring = str.substring(i, i + 1);
                if(!string.contains(substring)){
                    string+=substring;
                }
            }
            System.out.println(string);
        }
    }
}

方法2

代码实现，方法二：使用HashSet来去除重复元素

public class HashSetDemo {
    public static void main(String[] args) {
        HashSet<String> set = new HashSet<String>();
        set.add("语文");
        set.add("数学");
        set.add("英语");
        set.add("数学");
        set.add("语文");

        for(String key:set){
            System.out.println(key);
        }
    }
}

代码实现：

import java.util.HashSet;
import java.util.Scanner;

public class Main {
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        HashSet<String> set = new HashSet();

        while (scanner.hasNext()){
            String str = scanner.next();
            StringBuilder stringBuilder = new StringBuilder(str);
            stringBuilder.reverse();
            for(int i=0;i<stringBuilder.length();i++){
                String substring = stringBuilder.substring(i, i + 1);
                if(set.add(substring)){
                    System.out.print(substring);
                }
            }
        }
    }
}

---

10. 字符个数统计

编写一个函数，计算字符串中含有的不同字符的个数。字符在ACSII码范围内(0~127)，换行表示结束符，不算在字符里。不在范围内的不作统计。

思路：Hashset去重，substring()去截取每个字符添加到集合里面

import java.util.HashSet;
import java.util.Scanner;
public class 字符个数统计 {
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        while (scanner.hasNext()){
            String chars = scanner.nextLine();
            calculate(chars);
        }
    }
    public static void calculate(String chars){
        StringBuilder stringBuilder=new StringBuilder(chars);
        //去重
        HashSet<Object> set = new HashSet<>();
        int count=0;
        for (int i = 0; i < stringBuilder.length(); i++) {
            //一个一个截取字符添加到HashSet集合
            String substring = stringBuilder.substring(i, i + 1);
            //字符只能在0-127范围内
            if(substring.charAt(0)<0||substring.charAt(0)>127){
                continue;
            }else {
                if(set.add(substring)){
                    count++;
                }
            }
        }
        System.out.println(count);
    }
}

---

11. 数字颠倒

描述：输入一个整数，将这个整数以字符串的形式逆序输出，程序不考虑负数的情况，若数字含有0，则逆序形式也含有0，如输入为100，则输出为001

String是不可变类，但是StringBuilder是可变类，里面有个reverse()方法比较好用，翻转字符串(逆序)。

import java.util.Scanner;
public class 数字颠倒 {
    public static void main(String[] args) {
        Scanner scanner= new Scanner(System.in);
        while (scanner.hasNext()){
            int N = scanner.nextInt();
            String s=N+"";
            StringBuilder stringBuilder = new StringBuilder(s);
            //stringBuilder.reverse();逆序输出
            StringBuilder reverse = stringBuilder.reverse();
            System.out.println(reverse);
        }
    }
}

---

12. 字符串反转

写出一个程序，接受一个字符串，然后输出该字符串反转后的字符串。（字符串长度不超过1000）
本题和上题思路相同，不赘述：

import java.util.Scanner;
public class 字符串反转 {
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        while (scanner.hasNext()){
            String s = scanner.nextLine();
            StringBuilder stringBuilder=new StringBuilder(s);
            StringBuilder reverse = stringBuilder.reverse();
            System.out.println(reverse);
        }
    }
}

---

13. 句子逆序

将一个英文语句以单词为单位逆序排放。例如“I am a boy”，逆序排放后为“boy a am I”
所有单词之间用一个空格隔开，语句中除了英文字母外，不再包含其他字符
接口说明：

/**
 * 反转句子
 * 
 * @param sentence 原句子
 * @return 反转后的句子
 */
public String reverse(String sentence);

思路分析：

• 所有单词之间用一个空格隔开，可以使用split()方法,
• 通过栈的操作：先入后出，逆序输出

import java.util.Scanner;
import java.util.Stack;
/**通过栈的先入后出顺序：将以空格分好的数组进行入栈和出栈操作*/
public class 句子逆序 {
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        while (scanner.hasNext()){
            String s = scanner.nextLine();
            Stringtoreverse(s);
        }
    }
    public static void Stringtoreverse(String s){
        //分组：以空格
        String[] s1 = s.split(" ");
        //创建栈对象
        Stack stack=new Stack();
        //入栈和出栈操作
        for (int i = 0; i < s1.length; i++) {
            stack.push(s1[i]);
        }
        for (int j = 0; j < s1.length; j++) {
            System.out.print(stack.pop()+" ");
        }
    }
}

---

14. 字串的连接最长路径查找

给定n个字符串，请对n个字符串按照字典序排列。


思路：API中有一个专门对数组进行排序的方法：Arrays.Sort(arr)
字符串排序，先大写后小写

String[] strArray = new String[] {"z", "a", "C"};
Arrays.sort(strArray);
输出： [C, a, z]

代码实现：下面代码其实是有问题的，就是当我们输入大写字母的时候会先排大写字母再排小写字母，但是测试通过了。。。。。。一脸懵逼

public class Main {
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        while(scanner.hasNext()){
            int n = scanner.nextInt();
            String[] stringArr = new String[n];
            for(int i=0;i<n;i++){
               stringArr[i] = scanner.next();
            }
            Arrays.sort(stringArr);
            for(int i=0;i<n;i++){
                System.out.println(stringArr[i]);
            }
        }
    }
}

思路2：API中除了数组排序，还有就是集合排序，集合汇总有个工具类Collections也可以进行排序。

import java.util.*;

public class 字符串的连接最长路径查找 {
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        while (scanner.hasNext()){
            int n = scanner.nextInt();
            if (n<1||n>1000){
                scanner.close();
                return;
            }
            String []strings=new String[n];
            //List集合有序可重复
            List<String> list=new ArrayList<>();
            for (int i = 0; i <strings.length; i++) {
                strings[i] = scanner.next();
                if (strings[i].length()>100){
                    scanner.close();
                    return;
                }
                //添加到list集合
                list.add(strings[i]);
            }
            //Collections工具类中调用sort方法按大小排序，但是该方法只适应List集合
            Collections.sort(list);
            for(String s1:list){
                System.out.println(s1);
            }
        }
    }
}

---

15. 求int型整数在内存中存储时1的个数

输入一个int型的正整数，计算出该int型数据在内存中存储时1的个数。

思路：API中Integer类中的parseInt(String str，int radix)方法可以将任意进制的字符串转成十进制。同样Integer类中也有对应的方法可以将十进制转成其他进制。

通过调用Integer类的静态方法可以直接将一个int型整数转换为相应的二进制、八进制以及十六进制并且返回结果的字符串形式：

import java.util.Scanner;

public class int型数据在内存中存储时1的个数 {
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        while (scanner.hasNext()){
            int n = scanner.nextInt();
            //进制转换都是在Integer对象中,10进制转二进制字符串
            String s = Integer.toBinaryString(n);
            int count=0;
            for (int i = 0; i < s.length(); i++) {
                String substring = s.substring(i, i + 1);
                if("1".equals(substring)){
                    count++;
                }
            }
            System.out.println(count);
        }
    }
}