牛客华为机试-查找排序

前言：java编写，代码尽可能带注释，部分题目附上解题思路。力求方便，所以不写如有错误，请指出，谢谢。

1、百钱买百鸡问题

题目描述
公元前五世纪，我国古代数学家张丘建在《算经》一书中提出了“百鸡问题”：鸡翁一值钱五，鸡母一值钱三，鸡雏三值钱一。百钱买百鸡，问鸡翁、鸡母、鸡雏各几何？
详细描述：
接口说明
原型：
int GetResult(vector &list)
输入参数：
        无
输出参数（指针指向的内存区域保证有效）：
    list  鸡翁、鸡母、鸡雏组合的列表
返回值：
     -1 失败     
     0 成功

import java.util.Scanner;
public class Main{
    public static void main(String[] args){
        Scanner sc = new Scanner(System.in);
        while(sc.hasNext() ){
            int n = sc.nextInt(); // 将输入的1放入n，虽然没用
            // n1、n2、n3分别表示吉翁、继母、鸡雏
            int n1 = 0, n2 = 0, n3 = 0;
            //7x +4y = 100,两种思路：一、两层遍历；二、一层遍历
            for(n1 = 0; n1 <=14; n1++ ){
                for(n2 = 25; n2 >=0; n2--){
                    int sum = 7 * n1 + 4 * n2;
                    if(sum == 100){
                        n3 = 100-n1-n2;
                        System.out.println(n1 +" "+n2 + " "+n3);
                    }
                }
            }
            for(n1 = 0; n1 <= 14; n1++){
                double j;
                if(n1 == 0){
                    j = 25;
                }else{
                    j = (100-7*n1)/4.0;
                }
                if(Math.abs(j- Math.round(j)) < 1e-6){
                    n2 = (int)j;
                    n3 = 100 - n1 - n2;
                    System.out.println(n1 +" "+n2 + " "+n3);
                }
            }
        }
    }
} 

2、统计每个月兔子总数

题目描述
有一只兔子，从出生后第3个月起每个月都生一只兔子，小兔子长到第三个月后每个月又生一只兔子，假如兔子都不死，问每个月的兔子总数为多少？
    /**
     * 统计出兔子总数。
     * 
     * @param monthCount 第几个月
     * @return 兔子总数
     */
    public static int getTotalCount(int monthCount)
    {
        return 0;
    }

import java.util.Scanner;
public class Main{
    public static void main(String[] args){
        Scanner sc = new Scanner(System.in);
        while(sc.hasNext() ){
            int month = sc.nextInt();
            System.out.println(Main.getTotalCount(month));
        }
    }
    // 统计兔子总数
    public static int getTotalCount(int monthCount){
        if(monthCount < 0)
            return 0;
        // 初始化三个月份的兔子
        int oneMonthOld = 1;
        int twoMonthOld = 0;
        int threeMonthOld = 0;
        // 第一个月刚出生，所以月份要减一
        for(int i = 0; i < monthCount-1; i++){
            // 分别都长大一个月
            threeMonthOld += twoMonthOld;// 三月份的兔子要加上从二月份发育过来的
            twoMonthOld = oneMonthOld;
            oneMonthOld = threeMonthOld;

        }
        return oneMonthOld+twoMonthOld+threeMonthOld;
    }
}

3、查找组成一个偶数最接近的两个素数

注：这里动态规划，比较不好懂

题目描述
任意一个偶数（大于2）都可以由2个素数组成，组成偶数的2个素数有很多种情况，本题目要求输出组成指定偶数的两个素数差值最小的素数对

import java.util.Scanner;
public class Main{
    public static void main(String[] args){
        Scanner sc = new Scanner(System.in);
        while(sc.hasNext() ){
            int even = sc.nextInt();
            // 思路：从even/2向2查找质数，若另一个数也为质数满足条件
            int max = even/2;
            for(int i = max; i >=2; i--){
                if(Main.judge(i) && Main.judge(even-i)){
                    System.out.println(i);
                    System.out.println(even-i);
                    break;
                }
            }
        }
    }
    // 判断是否为质数
    public static boolean judge(int number){
        if(number <= 1){
            return false;
        }
        for(int i = 2; i < number; i++){
            // 若区间除了1和number外存在能整除number的数，则说明不是质数
            if((number % i) == 0){
                return false;
            }
        }
        return true;
    }
}

4、公共字串计算

题目描述
题目标题：
计算两个字符串的最大公共字串的长度，字符不区分大小写
详细描述：
接口说明
原型：
int getCommonStrLength(char * pFirstStr, char * pSecondStr);
输入参数：
     char * pFirstStr //第一个字符串
     char * pSecondStr//第二个字符串

import java.util.Scanner;
public class Main{
    public static void main(String[] args){
        Scanner sc = new Scanner(System.in);
        while(sc.hasNext() ){
            String str1 = sc.next();
            String str2 = sc.next();
            System.out.println(Main.getCommonStrLength(str1, str2));
        }
    }
    // 常规解法
    public static int getCommonStrLength(String str1, String str2){
        // 空值判断以及空指针异常
        if(str1 == null || str1.length() == 0 || str2 == null || str2.length()==0){
            return 0;
        }
        int len1 = str1.length();
        int len2 = str2.length();
        int  max = 0;// 初始化两个字符串的标志位，以及最大公共子串的长度
        for(int i = 0; i < len1;){
            for(int j = 0; j < len2;){
                // 找到第一个重复的字符，试图遍历公共子串
                if(str1.charAt(i) == str2.charAt(j)){
                    // 当出现相等时候，要保证后面一串尽可能相等，但需要找出最长的公共子串
                    // 出现相等则两个标志位一起走
                    int p1 = i, p2 = j;
                    int count = 0;
                    //System.out.println(p1 + " " + p2);
                    while(p1 < len1 && p2 < len2 && str1.charAt(p1) == str2.charAt(p2)){
                        //System.out.println(""+str1.charAt(p1));
                        p1++;
                        p2++;
                        count++;
                    }
                    // 走完公共子串后保存最大长度
                    if(count > max){
                        max = count;
                    }
                }
                //str2中当前字符与str1中当前字符不相等的，str2当前字符标志后移一位
                j++;
            }
            // 遍历str2字符串都没找到与str1中当前字符相等，str1当前字符标志后移一位
            i++;
        }
        return max;
    }
    // 动态规划的解法
    public static int getCommonStrLength(String str1, String str2) {
        int len1 = str1.length();
        int len2 = str2.length();
        int[][] dp = new int[len1 + 1][len2 + 1];// 默认初始化为0
        for (int i = 1; i <= len1; i++) {
            for (int j = 1; j <= len2; j++) {
                if (str1.charAt(i - 1) == str2.charAt(j - 1)) {
                    // 两层遍历，找出每一次字符相等位置，若找到公共子串，那么在二维数组中走向将一直斜向下
                    dp[i][j] = dp[i - 1][j - 1] + 1;
                } 
            }
        }
        int max = 0;
        for (int i = 0; i <= len1; i++) {
            for (int j = 0; j <= len2; j++) {
                if (max < dp[i][j])
                    max = dp[i][j];
            }
        }
        return max;
    }
}

5、成绩排序

注意：感觉同样分数同样成绩这里LinkedHashMap怕不合适吧

题目描述
查找和排序
题目：输入任意（用户，成绩）序列，可以获得成绩从高到低或从低到高的排列,相同成绩
都按先录入排列在前的规则处理。
例示：
jack      70
peter     96
Tom       70
smith     67

从高到低  成绩
peter     96
jack      70
Tom       70
smith     67

从低到高
smith     67
jack      70
Tom       70 
peter     96

注：0代表从高到低，1代表从低到高

// 名字可能相同，分数可能相同，要想唯一键，则利用名字加分数
import java.util.*;
public class Main{
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        while(sc.hasNext() ){
            String name;
            Integer score;
            List<Integer> scoreList = new ArrayList<>();
            Map<String, Integer> map = new LinkedHashMap<>(); // 存放score与name+" "+score的映射
            int sortNum = sc.nextInt();
            int sortMethod = sc.nextInt(); // 0 表示升序，1表示降序
            for(int i = 0; i < sortNum; i++){
                name = sc.next();
                score = sc.nextInt();
                scoreList.add(score);
                map.put(name+" "+score, score);
            }
            Collections.sort(scoreList);
            if(sortMethod == 0){
                // 降序
                Collections.reverse(scoreList);
            }
            int pre = -1;
            for(int s : scoreList){
                if(pre == s){
                    // scoreList中不用查找重复值
                    continue;
                }
                for(String key : map.keySet()){
                    if(map.get(key).equals(s)){
                        // 第一次找到
                        System.out.println(key);
                    }
                }
                pre = s;
            }
        }
    }
}

6、Redraiment的走法

注意：最长递增序列

题目描述
   Redraiment是走梅花桩的高手。Redraiment总是起点不限，从前到后，往高的桩子走，但走的步数最多，不知道为什么？你能替Redraiment研究他最多走的步数吗？ 
样例输入
6
2 5 1 5 4 5
样例输出
3
提示

Example: 
6个点的高度各为 2 5 1 5 4 5 
如从第1格开始走,最多为3步, 2 4 5 
从第2格开始走,最多只有1步,5 
而从第3格开始走最多有3步,1 4 5 
从第5格开始走最多有2步,4 5

所以这个结果是3。

import java.util.*;
 
public class Main {
    public static void main(String[] args) {
        Scanner input = new Scanner(System.in);
        while (input.hasNextInt()) {
            int n = input.nextInt();
            int[] a = new int[n];
            for (int i = 0; i < n; i++)
                a[i] = input.nextInt();
            System.out.println(getMaxSteps(a, n));
        }
    }
    // 转化成求最长递增子序列
    public static int getMaxSteps(int [] arr ,int n) {
        int[] dp = new int[n];
        for(int i = 0; i < n; i++){
            dp[i] = 1;
            for(int j = 0; j < i; j++){
                if(arr[j] < arr[i]){
                    dp[i] = Math.max(dp[i], dp[j]+1);
                }
            }
        }
        // 遍历数组找出最大值
        int max = 0;
        for(int i = 0; i < n; i++){
            if(dp[i] > max){
                max = dp[i];
            }
        }
        return max;
    }
}

7、字符统计

题目描述
如果统计的个数相同，则按照ASCII码由小到大排序输出 。如果有其他字符，则对这些字符不用进行统计。
实现以下接口：
输入一个字符串，对字符中的各个英文字符，数字，空格进行统计（可反复调用）
按照统计个数由多到少输出统计结果，如果统计的个数相同，则按照ASII码由小到大排序输出
清空目前的统计结果，重新统计
调用者会保证：
输入的字符串以‘\0’结尾。 

package zTestDay;


import java.util.*;

public class Main {
	// 方法一，hashMap加treeMap
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        while (sc.hasNext()) {
            Map<Character, Integer> map = new HashMap<>();
            String str = sc.next();
            for(int i = 0; i < str.length(); i++){
                Character key = str.charAt(i);
                // 只对英文字符，数字，空格统计
                if((key >= '0' && key <= '9') || (key >= 'A' && key <='Z') || (key >= 'a' && key <='z')  || key == ' '){
                    if(map.containsKey(key) ){
                        map.put(key, map.get(key)+1);
                    }else{
                        map.put(key, 1);
                    }
                }
            }
            Map<Integer, Character> treeMap = new TreeMap<>();
            for(Character key :map.keySet()){
                // 有相同次数key，无相同的val, 所以利用map的key与val构造treeMap新的唯一key
                treeMap.put(map.get(key) * 128 + 128 - key , key); // 这里必须是-key,才能使得出现相同的次数的字母按照assic降序排列
            }
            StringBuilder sb = new StringBuilder();
            for(Integer i : treeMap.keySet()){
                sb.append(treeMap.get(i));
            }
            System.out.println(sb.reverse().toString());
        }
    }
	// 方法二、treeMap与次数降序查找，能够运用主要是因为字符最多256
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        while (sc.hasNext()) {
            Map<Character, Integer> map = new TreeMap<>(); // 必须用treeMap
            Set<Integer> set = new HashSet<>();
            String str = sc.next();
            for(int i = 0; i < str.length(); i++){
                Character key = str.charAt(i);
                // 只对英文字符，数字，空格统计
                if((key >= '0' && key <= '9') || (key >= 'A' && key <='Z') || (key >= 'a' && key <='z')  || key == ' '){
                    if(map.containsKey(key) ){
                        map.put(key, map.get(key)+1);
                    }else{
                        map.put(key, 1);
                    }
                    set.add(map.get(key)); // 保存出现的次数，去重
                }
            }
            List<Integer> count = new ArrayList<>();
            for(Integer i :set){
                count.add(i);
            }
            Collections.reverse(count); // 将出现次数降序
            StringBuilder sb = new StringBuilder();
            for(Integer i : count){
                for(Character key : map.keySet()){
                    // 这里hashmap里面存储字符，所以数据不会太多，要不然不能两层循环
                    if(map.get(key) == i){
                        sb.append(key);
                    }
                }
            }
            System.out.println(sb.toString());
        }
    }
}

8、迷宫问题

题目描述
定义一个二维数组N*M（其中2<=N<=10;2<=M<=10），如5 × 5数组下所示： 
int maze[5][5] = {
        0, 1, 0, 0, 0,
        0, 1, 0, 1, 0,
        0, 0, 0, 0, 0,
        0, 1, 1, 1, 0,
        0, 0, 0, 1, 0,
};

它表示一个迷宫，其中的1表示墙壁，0表示可以走的路，只能横着走或竖着走，不能斜着走，要求编程序找出从左上角到右下角的最短路线。入口点为[0,0],既第一空格是可以走的路。
Input
一个N × M的二维数组，表示一个迷宫。数据保证有唯一解,不考虑有多解的情况，即迷宫只有一条通道。
Output
左上角到右下角的最短路径，格式如样例所示。

Sample Input
0 1 0 0 0
0 1 0 1 0
0 0 0 0 0
0 1 1 1 0
0 0 0 1 0

Sample Output
(0, 0)
(1, 0)
(2, 0)
(2, 1)
(2, 2)
(2, 3)
(2, 4)
(3, 4)
(4, 4)

import java.util.LinkedList;
import java.util.Scanner;
public class Main {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        while(sc.hasNext()){
            int rows = sc.nextInt();
            int cols = sc.nextInt();
            int[][] maze = new int[rows][cols]; // 0表示未访问，1表示以访问，-1表示无法访问
            for(int i = 0; i < rows; i++){
                for(int j = 0; j < cols; j++){
                    int val = sc.nextInt();
                    if(val == 1){
                        maze[i][j]=-1;
                    }
                }
            }
            //System.out.println(rows+" "+ cols);
            LinkedList<String> list = new LinkedList<>();
            findRoute(maze, 0, 0, rows, cols, list);
            for(String step : list){
                System.out.println(step);
            }
        }
    }

    private static boolean findRoute(int[][] maze, int i, int j, int rows, int cols, LinkedList<String> list) {
        if(i >= 0 && j >= 0 && i < rows && j < cols && maze[i][j] == 0){
            // 能访问（i,j)这位置
            maze[i][j] = 1;
            list.add("("+i+","+j+")");
            if(i == rows-1 && j == cols-1){
                // 已经找到了出口点
                return true;
            }
            if(findRoute(maze, i+1, j, rows, cols, list)
                    || findRoute(maze, i-1, j, rows, cols, list)
                    || findRoute(maze, i, j+1, rows, cols, list)
                    || findRoute(maze, i, j-1, rows, cols, list)){
                // 能继续访问下一步
                return true;
            }else{
                // 恢复未访问的状态
                maze[i][j] = 0;
                list.removeLast();
                return false;
            }
        }else{
            // 不能访问此位置
            return false;
        }
    }
}

9、字符串排序

注：思路不够简洁

题目描述
编写一个程序，将输入字符串中的字符按如下规则排序。

规则 1 ：英文字母从 A 到 Z 排列，不区分大小写。
如，输入： Type 输出： epTy

规则 2 ：同一个英文字母的大小写同时存在时，按照输入顺序排列。
如，输入： BabA 输出： aABb

规则 3 ：非英文字母的其它字符保持原来的位置。
如，输入： By?e 输出： Be?y 

import java.util.*;

// 利用treeMap的键排序，利用hashMap保存位置映射关系
public class Main {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        while (sc.hasNext()) {
            String input = sc.nextLine();
            TreeMap<Character, String> map = new TreeMap<>(); // 利用treemap的key排序，
            //ArrayList<Character> list = new ArrayList<>();
            HashMap<Integer, Character> hashMap = new HashMap<>(); // 非英文字母位置映射
            for (int i = 0; i < input.length(); i++) {
                char c = input.charAt(i); // 字符
                if (Character.isLetter(c)) {
                    // 字符为字母
                    char lower = Character.toLowerCase(c);
                    if (map.containsKey(lower)) {
                        map.put(lower, map.get(lower) + c); // 将小写字母作为key，小写后相同的字母按顺序排列为value
                    } else {
                        map.put(lower, c + "");
                    }
                    //list.add(c); // 列表添加字符
                } else {
                    // 若字符不为字母，保存位置映射关系
                    hashMap.put(i, c);
                }
            }
            // 这里同时可以利用集合排序，那么也不需要利用hashMap保存非字母位置，遍历输入字符串，非字母字符位置就知道了
/*            Collections.sort(list, new Comparator<Character>() {
                @Override
                public int compare(Character o1, Character o2) {
                    return Character.toLowerCase(o1) - Character.toLowerCase(o2);
                }
            });*/
            StringBuilder sb = new StringBuilder(); // 存储字符为字母的数组，并按照小写字母排序
            for (Character key : map.keySet()) {
                sb.append(map.get(key));
            }
            StringBuilder sb2 = new StringBuilder();
            int i = 0, j = 0;
            while (i < input.length()) {
                if (hashMap.containsKey(i)) {
                    sb2.append(hashMap.get(i));
                } else if (j < sb.length()) {
                    sb2.append(sb.charAt(j++));
                }
                i++;
            }
            System.out.println(sb2.toString());
        }
    }
}

10、质数因子

题目描述
功能:输入一个正整数，按照从小到大的顺序输出它的所有质因子（重复的也要列举）（如180的质因子为2 2 3 3 5 ）
最后一个数后面也要有空格 

import java.util.*;

public class Main {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        while (sc.hasNext()) {
            Long input = sc.nextLong();
            ArrayList<Integer> list = new ArrayList<>();
            int n = 2;
            while(input >= 2){
                if(input % n == 0){
                    // 若能整除,添加质数因子
                    input = input / n;
                    list.add(n);
                }else{
                    // 找下一个质数
                    //n = getNext(n);
                    n++; // 这里压根不需要找下一个质数，而是加一就行，和质数定义有关
                }
            }
            for(Integer i : list){
                System.out.print(i + " ");
            }
        }
    }

    // 找出下一位质数
    private static int getNext(int n) {
        while(true){
            n++;
            if(judge(n)){
                return n;
            }
        }
    }

    // 判断是否为质数
    private static boolean judge(int n) {
        for(int i = 2; i < n; i++){
            if(n % i == 0){
                return false;
            }
        }
        return true;
    }
}

11、自守数

题目描述
自守数是指一个数的平方的尾数等于该数自身的自然数。
例如：25^2 = 625，76^2 = 5776，9376^2 = 87909376。请求出n以内的自守数的个数 

import java.util.*;

public class Main {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        while (sc.hasNext()) {
            Long input = sc.nextLong();
            int cnt = 1;
            for(int i = 1; i <= input; i++){
                // 0 也算自守数
                if(judge(i)){
                    cnt++;
                }
            }
            System.out.println(cnt);
        }
    }
    // 判断是否自守数
    private static boolean judge(long i) {
        int count = 1; // 统计是几位数
        if(i <= 0)
            return false;
        while(i >= (long)Math.pow(10, count)){
            count++;
        }
        long square = i * i;
        long divisor = (long)Math.pow(10, count); //若尾数部分全部相同，相减后整除10次方位数，如25就是两位数，除以100
        if((square - i) % divisor == 0){
            return true;
        }
        return false;
    }
}

12、多线程

注意：牛客上看到的通过案列Java不对，只能本地通过，牛客不通过

题目描述
问题描述：有4个线程和1个公共的字符数组。线程1的功能就是向数组输出A，线程2的功能就是向字符输出B，线程3的功能就是向数组输出C，线程4的功能就是向数组输出D。要求按顺序向数组赋值ABCDABCDABCD

import java.util.Scanner;

public class Main {
    public static void main(String[] args) throws Exception{
        Object a = new Object();
        Object b = new Object();
        Object c = new Object();
        Object d = new Object();
        Scanner sc  = new Scanner(System.in);
        while (sc.hasNext()){
            int count = sc.nextInt();

            Runnable pa = new MyRunnable("A", d, a, count);
            Runnable pb = new MyRunnable("B", a, b, count);
            Runnable pc = new MyRunnable("C", b, c, count);
            Runnable pd = new MyRunnable("D", c, d, count);

            new Thread(pa).start();
            Thread.sleep(1);
            new Thread(pb).start();
            Thread.sleep(1);
            new Thread(pc).start();
            Thread.sleep(1);
            new Thread(pd).start();
        }
    }
}

class MyRunnable implements Runnable{
    private String name;
    private Object prev;
    private Object self;
    private int count;

    MyRunnable(String name, Object prev, Object self, int count) {
        this.name = name;
        this.prev = prev;
        this.self = self;
        this.count = count;
    }
    @Override
    public void run() {
        // int count = 10;
        while (count > 0) {
            synchronized (prev){
                synchronized (self){
                    System.out.print(name);
                    count--;
                    self.notify();
                }
                try {
                    prev.wait();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        }
    }
}