华为机试题-20190417

华为某次Java机试题

介绍

本次机试题,发生时间:2019年04月17日,19:00。

上一次试题,发生时间:2019年04月03日,19:00。

本次机试3题,均AC。

1

题目描述:
给定一个数组,里面有6个整数,求这个数组能够表示的最大24进制的时间是多少,输出这个时间,无法表示输出invalid。

输入描述:
输入为一个整数数组,数组内有六个整数。
输入整数数组长度为6,不需要考虑其他长度,元素值为0或者正整数,6个数字每个数字只能使用一次。

输出描述:
输出为一个24进制格式的时间,或者字符串“invalid”。

示例1
输入
[0,2,3,0,5,6]
输出
23:56:00
示例2
输入
[9,9,9,9,9,9]
输出
invalid

备注:
输出时间格式为xx:xx:xx格式。

代码

//直接暴力解决。
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Scanner;
public class Main {
	public static void main(String[] args) {
		final String s = "invalid";
		final String c = ":";
		Scanner in = new Scanner(System.in);
		String tempString = in.nextLine();
		in.close();
		tempString = tempString.substring(1, tempString.length() - 1);
		String [] tempInt = tempString.split(",");
		tempString = null;
		int [] input = new int [6];
        for(int i = 0; i < 6; i ++) {
            input[i] = Integer.parseInt(tempInt[i]);
        }
        tempInt = null;
        Arrays.sort(input);
        ArrayList<Integer> list = new ArrayList<>();
        for(int i = 0; i < 6; i ++) {
        	list.add(input[i]);
        }
        input = null;
        StringBuilder output = new StringBuilder();
        int i = getSpeci(list, 3); //第一位
        if(i != -1 ) {
        	output.append(list.remove(i));
        } else {
        	System.out.print(s);
        	return ;
        }
        if(output.charAt(0) == '2') {
        	i = getSpeci(list, 4); //第二位
        	if(i != -1 ) {
        		output.append(list.remove(i));
        		output.append(c);
        	}else {
            	System.out.print(s);
            	return ;
            }
        } else {
        	i = getSpeci(list, 10); //第二位
        	if(i != -1 ) {
        		output.append(list.remove(i));
        		output.append(c);
        	}else {
            	System.out.print(s);
            	return ;
            }
        }
        i = getSpeci(list, 6); //第三位
        if(i != -1 ) {
    		output.append(list.remove(i));
    	}else {
        	System.out.print(s);
        	return ;
        }
        i = getSpeci(list, 10); //第四位
    	if(i != -1 ) {
    		output.append(list.remove(i));
    		output.append(c);
    	}else {
        	System.out.print(s);
        	return ;
        }
    	i = getSpeci(list, 6); //第五位
        if(i != -1 ) {
    		output.append(list.remove(i));
    	}else {
        	System.out.print(s);
        	return ;
        }
        i = getSpeci(list, 10); //第六位
    	if(i != -1 ) {
    		output.append(list.remove(i));
    	}else {
        	System.out.print(s);
        	return ;
        }
        System.out.print(output);
	}
	static int getSpeci(ArrayList<Integer> list, int speci) {
		for(int i = list.size() - 1; i > -1; i --) {
			if(list.get(i) < speci) {
				return i;
			}
		}
		return -1;
	}
}

2

题目描述:
小王手里有点闲钱,想着做点卖水果的小买卖。给出两个数组m、n,用m[i]代表第i个水果的成本价,n[i]代表第i水果能卖出的价钱,假如现在有本钱k,试问最后最多能赚多少钱?

说明:
1 每种水果只需买一次,只能卖一次
2 数组m、n大小不超过50
3 数组元素为正整数,不超过1000

输入描述:
1 数组m、n
2 本钱k
备注:
1 首行输入逗号分隔的数组m的元素值
2 第二行输入逗号分隔的数组n的元素值
3 第三行输入本钱

输出描述:
最多能赚取多少钱。

示例1
输入
4,2,6,4
5,3,8,7
15
输出
22

说明
样例计算过程:
先买前3种水果,全部卖出,再买第4种水果,再卖出,最后本金变为22。

代码

import java.util.Arrays;
import java.util.Scanner;
public class Main {
	static class B implements Comparable<B> {
		int m;
		int n;
		B(int m, int n) {
			this.m = m;
			this.n = n;
		}
		@Override
		public int compareTo(B o) {
			if(m > o.m) {
				return 1;
			}
			if(m < o.m) {
				return -1;
			}
			if(n > o.n) {
				return -1;
			}
			if(n < o.n) {
				return 1;
			}
			return 0;
		}
	}
    public static void main(String[] args) {
        Scanner in = new Scanner(System.in);
        String [] mm = in.nextLine().split(",");
        String [] nn = in.nextLine().split(",");
        int k = in.nextInt();
        B [] b = new B [mm.length];
        for(int i = 0; i < b.length; i ++) {
        	b[i] = new B(Integer.parseInt(mm[i]), Integer.parseInt(nn[i]));
        }
        mm = null;
        nn = null;
        Arrays.sort(b);
        for(int i = 0; i < b.length; i ++) {
        	if(k >= b[i].m && b[i].n > b[i].m) {
        		k += (b[i].n - b[i].m);
        	}
        }
        System.out.print(k);
        in.close();
        
    }
}

3

题目描述
某多处理器多道批处理系统一次允许讲所有作业调入内存,且能并行执行,其并行数等于处理器个数。该系统采用SJF的调度方式(最短作业优先,系统在调度时,总是优先调度执行处理时间最短的作业)。
现给定处理器个数m,作业数n,每个作业的处理时间分别为t1, t2, … tn。
当n>m时,首先处理时间短的m个作业进入处理器处理,其他的进入等待,当某个作业处理完成时,依次从等待队列中取出处理时间最短的作业进入处理。
求系统处理完所有作业的耗时为多少?
注:不考虑作业切换的消耗。

输入描述:
输入2行,第一行为2个整数(采用空格分隔),分别标识处理器个数m个作业数n;第二行输入n个整数(采用空格分隔),标识每个作业的处理时长t1, t2,… tn。0<m, n<100,0<t1, t2,… tn<100。

输出描述:
输出处理总时长

示例1
输入
3 5
8 4 3 1 10
输出
13

备注:
注:不用考虑输入合法性。

代码:

import java.util.ArrayList;
import java.util.Arrays;
import java.util.Scanner;
public class Main{
	static class CPU{
		int time;
		CPU() {
			time = 0;
		}
	}
	public static void main(String[] args) {
		Scanner in = new Scanner(System.in);
		int m = in.nextInt();
		int n = in.nextInt();
		int [] task = new int [n];
		for(int i = 0; i < n; i ++) {
			task[i] = in.nextInt();
		}
		in.close();
		ArrayList<CPU> cpu = new ArrayList<>();
		for(int i = 0; i < m; i ++) {
			cpu.add(new CPU());
		}
		Arrays.sort(task);
		int total = 0;
		int index = 0;
		while(true) {
			int i = getZero(cpu);
			if(i == 101) {
				break;
			}
			if(i >= 0) {
				if(index == n) {
					cpu.remove(i);
				} else {
					cpu.get(i).time = task[index];
					index ++;
				}
			} else {
				total -= i;
			}
		}
		System.out.print(total);
	}
	static int getZero(ArrayList<CPU> cpu) {
		if(cpu.size() == 0) {
			return 101;
		}
		int min = 100;
		for(int i = 0; i < cpu.size(); i ++) {
			if(cpu.get(i).time == 0) {
				return i;
			}
			min = min > cpu.get(i).time ? cpu.get(i).time : min;
		}
		for(int i = 0; i < cpu.size(); i ++) {
			cpu.get(i).time -= min;
		}
		return -min;
	}
}

  • 7
    点赞
  • 21
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
评论 1
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值