Java算法：华为机试算法（下），华为算法Java版，牛客网华为算法73~108题

最新推荐文章于 2024-04-27 11:25:24 发布

DougLeaMrConcurrency

最新推荐文章于 2024-04-27 11:25:24 发布

阅读量1.1k

点赞数 1

分类专栏： # Java算法 # Java基础文章标签： java java算法牛客网华为机试算法

本文链接：https://blog.csdn.net/qq_43265673/article/details/115314577

版权

Java基础同时被 3 个专栏收录

56 篇文章 3 订阅

订阅专栏

Java算法

37 篇文章 5 订阅

订阅专栏

其他

7 篇文章 0 订阅

订阅专栏

接上篇：Java算法：华为机试算法（中），华为算法Java版，牛客网华为算法55~72题

HJ73 计算日期到天数转换

计算日期到天数转换

题目描述

根据输入的日期，计算是这一年的第几天。。

测试用例有多组，注意循环输入

输入描述:

输入多行，每行空格分割，分别是年，月，日

输出描述:

成功:返回outDay输出计算后的第几天;

失败:返回-1

示例1

输入

2012 12 31

输出

366

import java.io.BufferedReader;

import java.io.IOException;

import java.io.InputStreamReader;

public class Main {

public static void main(String[] args) throws IOException {

BufferedReader br = new BufferedReader(new InputStreamReader(System.in));

String str = "";

while ((str = br.readLine()) != null) {

String[] strs = str.split(" ");

int year = Integer.parseInt(strs[0]);

int month = Integer.parseInt(strs[1]);

int day = Integer.parseInt(strs[2]);

int result = day;

for (int i = 1; i < month; i++) {

result += getMonthDays(year, i);

}

System.out.println(result);

}

public static int getMonthDays(int year, int month) {

if (month == 1 || month == 3 || month == 5 || month == 7 || month == 8 || month == 10 || month == 12) {

return 31;

}

if (month == 2) {

return year % 4 == 0 ? 29 : 28;

}

return 30;

}

HJ74 参数解析

参数解析

题目描述

在命令行输入如下命令：

xcopy /s c:\ d:\，

各个参数如下：

参数1：命令字xcopy

参数2：字符串/s

参数3：字符串c:\

参数4: 字符串d:\

请编写一个参数解析程序，实现将命令行各个参数解析出来。

解析规则：

1.参数分隔符为空格

2.对于用“”包含起来的参数，如果中间有空格，不能解析为多个参数。比如在命令行输入xcopy /s “C:\program files” “d:\”时，参数仍然是4个，第3个参数应该是字符串C:\program files，而不是C:\program，注意输出参数时，需要将“”去掉，引号不存在嵌套情况。

3.参数不定长

4.输入由用例保证，不会出现不符合要求的输入

输入描述:

输入一行字符串，可以有空格

输出描述:

输出参数个数，分解后的参数，每个参数都独占一行

示例1

输入

xcopy /s c:\\ d:\\

输出

xcopy

c:\\

d:\\

import java.io.*;

public class Main{

public static void main(String[] args)throws IOException{

BufferedReader br=new BufferedReader(new InputStreamReader(System.in));

String s;

while((s=br.readLine())!=null){

char[] chars=s.toCharArray();

StringBuffer ana=new StringBuffer();

int flag=0;

int count=1;

for(int i=0;i<chars.length;i++){

if(chars[i]=='\"'){

flag++;

continue;

}

if(chars[i]!=' '){

ana.append(chars[i]);

}

if(chars[i]==' '&&flag%2!=0){

ana.append(chars[i]);

}

if(chars[i]==' '&&flag%2==0){

ana.append("\n");

count++;

}

System.out.println(count+"\n"+ana.toString());

}

HJ75 公共字串计算

公共子串计算

题目描述

给定两个只包含小写字母的字符串，计算两个字符串的最大公共子串的长度。

注：子串的定义指一个字符串删掉其部分前缀和后缀（也可以不删）后形成的字符串。

输入描述:

输入两个只包含小写字母的字符串

输出描述:

输出一个整数，代表最大公共子串的长度

示例1

输入

asdfas

werasdfaswer

输出

import java.io.*;

public class Main{

public static void main(String[] args)throws Exception{

BufferedReader bf = new BufferedReader(new InputStreamReader(System.in));

String str1 = "";

String str2 = "";

while((str1 = bf.readLine())!= null && (str2 = bf.readLine())!= null){

int max = 0;

char[] cha1 = str1.toCharArray();

char[] cha2 = str2.toCharArray();

for(int i = 0; i < str1.length(); i++){

for(int j = 0; j < str2.length(); j++){

int t1 = i;

int t2 = j;

int count = 0;

while(cha1[t1] == cha2[t2]){

t1++;

t2++;

count++;

max = Math.max(count,max);

if(t1 == cha1.length || t2 == cha2.length) break;

}

System.out.println(max);

}

HJ76 尼科彻斯定理

尼科彻斯定理

题目描述

验证尼科彻斯定理，即：任何一个整数m的立方都可以写成m个连续奇数之和。

例如：

1^3=1

2^3=3+5

3^3=7+9+11

4^3=13+15+17+19

输入一个正整数m（m≤100），将m的立方写成m个连续奇数之和的形式输出。

本题含有多组输入数据。

输入描述:

输入一个int整数

输出描述:

输出分解后的string

示例1

输入

输出

31+33+35+37+39+41

import java.util.* ;

import java.io.*;

public class Main{

// public static void main(String[] args){

// Scanner scanner = new Scanner(System.in) ;

// while(scanner.hasNext()){

// int m = scanner.nextInt() ;

// System.out.println(method(m)) ;

// }

public static void main(String[] args) throws IOException{

BufferedReader br = new BufferedReader(new InputStreamReader(System.in));

String str = null;

while((str = br.readLine()) != null){

int num = Integer.parseInt(str);

System.out.println(method(num));

}

public static String method(int m){

int temp1 = m*m*m ;

int temp2 = m*m ;

StringBuffer sb = new StringBuffer() ;

for(int i=0;i<m;i++){

if(m%2!=0){

sb.append(temp2-2*(m/2)+2*i).append("+") ;

}else{

sb.append(temp2-m+1+2*i).append("+") ; ;

}

return sb.substring(0,sb.length()-1).toString() ;

}

HJ77 火车进站

火车进站

题目描述

给定一个正整数N代表火车数量，0<N<10，接下来输入火车入站的序列，一共N辆火车，每辆火车以数字1-9编号，火车站只有一个方向进出，同时停靠在火车站的列车中，只有后进站的出站了，先进站的才能出站。

要求输出所有火车出站的方案，以字典序排序输出。

输入描述:

有多组测试用例，每一组第一行输入一个正整数N（0

输出描述:

输出以字典序从小到大排序的火车出站序列号，每个编号以空格隔开，每个输出序列换行，具体见sample。

示例1

输入

1 2 3

输出

1 2 3

1 3 2

2 1 3

2 3 1

3 2 1

说明

第一种方案：1进、1出、2进、2出、3进、3出

第二种方案：1进、1出、2进、3进、3出、2出

第三种方案：1进、2进、2出、1出、3进、3出

第四种方案：1进、2进、2出、3进、3出、1出

第五种方案：1进、2进、3进、3出、2出、1出

请注意，[3,1,2]这个序列是不可能实现的。

import java.util.*;

public class Main{

private static Stack<String> stack1=new Stack<String>();

private static Stack<String> stack2=new Stack<String>();

private static List<String> list=new ArrayList<String>();

public static void ff(String str){

if(stack1.isEmpty()&&stack2.isEmpty()){

list.add(str.trim());

return;

}

if(!stack2.isEmpty()){

String str1=stack2.pop();

ff(str+" "+str1);

stack2.push(str1);

}

if(!stack1.isEmpty()){

String str2=stack1.pop();

stack2.push(str2);

ff(str);

stack2.pop();

stack1.push(str2);

}

public static void main(String[] args){

Scanner scanner=new Scanner(System.in);

while(scanner.hasNext()){

int n=scanner.nextInt();

scanner.nextLine();

String str=scanner.nextLine();

String[] ss=str.split(" ");

for(int i=ss.length-1;i>=0;i--)

stack1.push(ss[i]);

ff("");

Collections.sort(list);

for(String s:list)

System.out.println(s);

}

HJ80 整形数组合并

整形数组合并

题目描述

题目标题：

将两个整型数组按照升序合并，并且过滤掉重复数组元素。

输出时相邻两数之间没有空格。

请注意本题有多组样例。

输入描述:

输入说明，按下列顺序输入：

1 输入第一个数组的个数

2 输入第一个数组的数值

3 输入第二个数组的个数

4 输入第二个数组的数值

输出描述:

输出合并之后的数组

示例1

输入

1 2 5

-1 0 3 2

输出

-101235

import java.io.BufferedReader;

import java.io.InputStreamReader;

import java.util.Arrays;

public class Main {

public static void main(String[] args) throws Exception {

BufferedReader br = new BufferedReader(new InputStreamReader(System.in));

String line;

while ((line = br.readLine()) != null && line.length() > 0) {

String[] strs = br.readLine().split(" ");

int[] array1 = new int[strs.length];

for (int i = 0; i < array1.length; ++i)

array1[i] = Integer.parseInt(strs[i]);

line = br.readLine();

strs = br.readLine().split(" ");

int[] array2 = new int[strs.length];

for (int i = 0; i < array2.length; ++i)

array2[i] = Integer.parseInt(strs[i]);

System.out.println(combineBySort(array1, array2));

}

static String combineBySort(int[] array1, int[] array2) {

int[] outPut = new int[array1.length + array2.length];

Arrays.sort(array1);

Arrays.sort(array2);

int M = array1.length, R = array2.length;

int idx = 0, i = 0, j = 0;

if (array1[i] > array2[j]) {

outPut[idx++] = array2[j++];

} else if (array1[i] < array2[j]) {

outPut[idx++] = array1[i++];

} else {

outPut[idx++] = array1[i++];

j++;

}

while (i < M && j < R) {

if (array1[i] > array2[j]) {

if (outPut[idx - 1] != array2[j])

outPut[idx++] = array2[j];

++j;

} else if (array1[i] < array2[j]) {

if (outPut[idx - 1] != array1[i])

outPut[idx++] = array1[i];

++i;

} else {

if (outPut[idx - 1] != array1[i])

outPut[idx++] = array1[i];

++i;

++j;

}

if (i == M) {

while( j < R){

if (outPut[idx - 1] != array2[j])//去重

outPut[idx++] = array2[j];

j++;

}

} else {

for (; i < M; ++i)

if (outPut[idx - 1] != array1[i])

outPut[idx++] = array1[i];

}

StringBuilder sb = new StringBuilder();

for (i = 0; i < idx; ++i)

sb.append(outPut[i]);

return sb.toString();

}

HJ81 字符串匹配

字符串字符匹配

题目描述

判断短字符串中的所有字符是否在长字符串中全部出现。

请注意本题有多组样例输入。

输入描述:

输入两个字符串。第一个为短字符串，第二个为长字符串。两个字符串均由小写字母组成。

输出描述:

如果短字符串的所有字符均在长字符串中出现过，则输出true。否则输出false。

示例1

输入

abc

输出

true

import java.util.*;

import java.io.*;

public class Main{

public static void main(String[] args) throws IOException{

BufferedReader br=new BufferedReader(new InputStreamReader(System.in));

String str="";

String str2="";

while((str=br.readLine())!=null&&!"".equals(str)){

str2=br.readLine();

char[] arr=str.toCharArray();

boolean judge=true;

for(char c:arr){

if(!str2.contains(String.valueOf(c))){

judge=false;

break;

}

System.out.println(judge);

}

br.close();

}

HJ82 将真分数分解为埃及分数

将真分数分解为埃及分数

题目描述

分子为1的分数称为埃及分数。现输入一个真分数(分子比分母小的分数，叫做真分数)，请将该分数分解为埃及分数。如：8/11 = 1/2+1/5+1/55+1/110。

注：真分数指分子小于分母的分数，分子和分母有可能gcd不为1！

如有多个解，请输出任意一个。

请注意本题含有多组样例输入！

输入描述:

输入一个真分数，String型

输出描述:

输出分解后的string

示例1

输入

8/11

2/4

输出

1/2+1/5+1/55+1/110

1/3+1/6

说明

第二个样例直接输出1/2也是可以的

import java.io.BufferedReader;

import java.io.IOException;

import java.io.InputStreamReader;

/**

* 真分数转埃及分数

* 先化简

* 步骤一：用b除以a，得商数q1及余数r1,即b=a*q1+r1

* 步骤二： a/b=1/(q1+1）+(a-r1)/b(q1+1）

* 步骤三：重复步骤2，直到分解完毕

* 3/7=1/3+2/21=1/3+1/11+1/231

* @author Admin

* @date 2020-12-20

public class Main {

public static void main(String[] args){

BufferedReader br = new BufferedReader(new InputStreamReader(System.in));

String str = null;

try {

while((str = br.readLine())!= null){

String[] strArr = str.split("\\/");

int a = Integer.parseInt(strArr[0]);

int b = Integer.parseInt(strArr[1]);

String[] resArr = new String[1];

f(a, b, "", resArr);

System.out.println(resArr[0]);

}

} catch (NumberFormatException e) {

e.printStackTrace();

} catch (IOException e) {

e.printStackTrace();

}

public static void f(int a, int b, String resStr, String[] resArr){

if(a==1 || b%a==0){

int val = b/a;

resStr += 1+"/"+val;

resArr[0] = resStr;

return ;

}

else{

int q1 = b/a;

int r1 = b%a;

int val1 = q1+1;

resStr += 1+"/"+val1+"+";

a = a - r1;

b = b*(q1+1);

f(a, b, resStr, resArr);

}

return;

}

HJ83 二维数组操作

二维数组操作

输入描述:

输入数据按下列顺序输入：

1 表格的行列值

2 要交换的两个单元格的行列值

3 输入要插入的行的数值

4 输入要插入的列的数值

5 输入要查询的单元格的坐标

输出描述:

输出按下列顺序输出：

1 初始化表格是否成功，若成功则返回0，否则返回-1

2 输出交换单元格是否成功

3 输出插入行是否成功

4 输出插入列是否成功

5 输出查询单元格数据是否成功

示例1

输入

4 9

5 1 2 6

2 3

4 7

4 2 3 2

4 7

输出

-1

说明

本组样例共有2组样例输入。

第一组样例：

1.初始化数据表为4行9列，成功

2.交换第5行1列和第2行6列的数据，失败。因为行的范围应该是(0,3)，不存在第5行。

3.在第0行上方添加一行，成功。

4.在第8列左边添加一列，失败。因为列的总数已经达到了9的上限。

5.查询第2行第3列的值，成功。

第二组样例：

1.初始化数据表为4行7列，成功

2.交换第4行2列和第3行2列的数据，失败。因为行的范围应该是(0,3)，不存在第4行。

3.在第3行上方添加一行，成功。

4.在第3列左边添加一列，成功。

5.查询第4行7列的值，失败。因为虽然添加了一行一列，但数据表会在添加后恢复成4行7列的形态，所以行的区间仍然在[0,3]，列的区间仍然在[0,6]，无法查询到(4,7)坐标。

//package com.company;

import java.io.BufferedReader;

import java.io.IOException;

import java.io.InputStream;

import java.io.InputStreamReader;

import java.util.*;

public class Main {

public static void main(String[] args) throws IOException {

fx();

}

//region 83 二维数组操作

private static void fx() throws IOException {

BufferedReader br = new BufferedReader(new InputStreamReader(System.in));

String str = null;

while((str = br.readLine()) != null) {

String[] strs = str.split(" ");

//1. 行和列

int row = Integer.parseInt(strs[0]);

int column = Integer.parseInt(strs[1]);

if(row >= 0 && row <= 9 && column >= 0 && column <= 9) {

System.out.println("0");

} else {

System.out.println(-1);

}

//2.单元格的行列值

String[] values = br.readLine().split(" ");

int rowValue1 = Integer.parseInt(values[0]);

int columnValue1 = Integer.parseInt(values[1]);

// values = br.readLine().split(" ");

int rowValue2 = Integer.parseInt(values[2]);

int columnValue2 = Integer.parseInt(values[3]);

if(rowValue1 >= 0 && rowValue1 < row && rowValue2 >= 0 && rowValue2 < row

&& columnValue1 >= 0 && columnValue1 < column && columnValue2 >= 0 && columnValue2 < column) {

System.out.println(0);

} else {

System.out.println(-1);

}

//3. 插入的行的值

int insertRowValue = Integer.parseInt(br.readLine());

if(insertRowValue >= 0 && insertRowValue < row && (row + 1) <= 9) {

System.out.println(0);

} else {

System.out.println(-1);

}

//4. 插入的列值

int insertColumnValue = Integer.parseInt(br.readLine());

if(insertColumnValue >= 0 && insertColumnValue < column && (column + 1) <= 9) {

System.out.println(0);

} else {

System.out.println(-1);

}

//5. 运动轨迹的单元格

strs = br.readLine().split(" ");

int x = Integer.parseInt(strs[0]);

int y = Integer.parseInt(strs[1]);

if(x >= 0 && x < row && y >= 0 && y < column) {

System.out.println(0);

} else {

System.out.println(-1);

}

br.close();

}

//endregion

}

HJ84 统计大写字母个数

统计大写字母个数

题目描述

找出给定字符串中大写字符(即'A'-'Z')的个数。

输入描述:

本题含有多组样例输入

对于每组样例，输入一行，代表待统计的字符串

输出描述:

对于每组样例，输出一个整数，代表字符串中大写字母的个数

示例1

输入

add123#$%#%#O

150175017(&^%&$vabovbao

输出

import java.io.BufferedReader;

import java.io.InputStreamReader;

import java.io.IOException;

public class Main {

public static void main(String[] args) throws IOException {

BufferedReader br = new BufferedReader(new InputStreamReader(System.in));

String str;

while((str = br.readLine()) != null) {

char[] chars = str.toCharArray();

int count = 0;

for(int i = 0; i < chars.length; i++)

if(65 <= chars[i] && chars[i] <= 90) count ++;

System.out.println(count);

}

HJ85 字符串运用-密码截取

最长回文子串

题目描述

给定一个仅包含小写字母的字符串，求它的最长回文子串的长度。

所谓回文串，指左右对称的字符串。

所谓子串，指一个字符串删掉其部分前缀和后缀（也可以不删）的字符串

（注意：记得加上while处理多个测试用例）

输入描述:

输入一个仅包含小写字母的字符串

输出描述:

返回最长回文子串的长度

示例1

输入

cdabbacc

输出

说明

abba为最长的回文子串

import java.io.*;

public class Main{

public static void main(String[] args)throws IOException{

BufferedReader br = new BufferedReader(new InputStreamReader(System.in));

String str = null;

while((str = br.readLine())!=null && str.length()!=0){

char[] chars = str.toCharArray();

int n = chars.length;

int max = 1;

for(int i = 0; i < n-1; i++){//奇

int left = i - 1;

int right = i + 1;

int length = 1;

while(left>=0 && right<n && chars[left]==chars[right]){

length += 2;

left--;

right++;

}

max = max > length ? max : length;

}

for(int i = 0; i < n-1; i++){//偶

int length = 1;

if(chars[i]==chars[i+1]){

length = 2;

}else

continue;

int left = i - 1;

int right = i + 2;

while(left>=0 && right<n && chars[left]==chars[right]){

length += 2;

left--;

right++;

}

max = max > length ? max : length;

}

System.out.println(max);

}

HJ86 求最大连续bit数

求最大连续bit数

题目描述

求一个byte数字对应的二进制数字中1的最大连续数，例如3的二进制为00000011，最大连续2个1

本题含有多组样例输入。

输入描述:

输入一个byte数字

输出描述:

输出转成二进制之后连续1的个数

示例1

输入

输出

说明

3的二进制表示是11，最多有2个连续的1。

5的二进制表示是101，最多只有1个连续的1。

import java.io.*;

import java.util.*;

public class Main{

public static void main(String[] args)throws IOException{

BufferedReader bf=new BufferedReader(new InputStreamReader(System.in));

String value;

while((value=bf.readLine())!=null){

int num=Integer.parseInt(value);

char[] chars=Integer.toBinaryString(num).toCharArray();

int[] nums=new int[chars.length];

for(int index=0;index<chars.length;index++){

char chat=chars[index];

if(chat=='1'){

if(index==0)

nums[index]=1;

else{

nums[index]=nums[index-1]+1;

nums[index-1]=0;

}

Arrays.sort(nums);

System.out.println(nums[nums.length-1]);

}

HJ87 密码强度等级

密码强度等级

题目描述

密码按如下规则进行计分，并根据不同的得分为密码进行安全等级划分。

一、密码长度:

5 分: 小于等于4 个字符

10 分: 5 到7 字符

25 分: 大于等于8 个字符

二、字母:

0 分: 没有字母

10 分: 全都是小（大）写字母

20 分: 大小写混合字母

三、数字:

0 分: 没有数字

10 分: 1 个数字

20 分: 大于1 个数字

四、符号:

0 分: 没有符号

10 分: 1 个符号

25 分: 大于1 个符号

五、奖励:

2 分: 字母和数字

3 分: 字母、数字和符号

5 分: 大小写字母、数字和符号

最后的评分标准:

>= 90: 非常安全

>= 80: 安全（Secure）

>= 70: 非常强

>= 60: 强（Strong）

>= 50: 一般（Average）

>= 25: 弱（Weak）

>= 0: 非常弱

对应输出为：

VERY_SECURE

SECURE,

VERY_STRONG,

STRONG,

AVERAGE,

WEAK,

VERY_WEAK,

请根据输入的密码字符串，进行安全评定。

注：

字母：a-z, A-Z

数字：-9

符号包含如下： (ASCII码表可以在UltraEdit的菜单view->ASCII Table查看)

!"#$%&'()*+,-./ (ASCII码：x21~0x2F)

:;<=>?@ (ASCII<=><=><=><=><=>码：x3A~0x40)

[\]^_` (ASCII码：x5B~0x60)

{|}~ (ASCII码：x7B~0x7E)

输入描述:

本题含有多组输入样例。

每组样例输入一个string的密码

输出描述:

每组样例输出密码等级

示例1

输入

38$@NoNoNo

123

输出

VERY_SECURE

WEAK

说明

第一组样例密码强度为95分。

第二组样例密码强度为25分。

import java.io.*;

import java.util.*;

public class Main {

public static void main (String[] args) throws IOException{

BufferedReader bread= new BufferedReader(new InputStreamReader(System.in));

String kywd;

while((kywd = bread.readLine())!=null){

System.out.println(getScore(kywd));

}

public static String getScore(String kywd){

char[] kychars = kywd.toCharArray();

int numNum = 0;

int sinNum = 0;

int upNum=0;

int lowNum=0;

int score = 0;

for(int i=0;i<kychars.length;i++){

if(kychars[i]>0x2F&&kychars[i]<0x3A){

numNum++;

}else if(kychars[i]>0x40&&kychars[i]<0x5B){

upNum++;

}else if(kychars[i]>0x60&&kychars[i]<0x7B){

lowNum++;

}else if((kychars[i]>0x20&&kychars[i]<0x30)||(kychars[i]>0x39&&kychars[i]<0x41)||(kychars[i]>0x5A&&kychars[i]<0x61)||(kychars[i]>0x7A&&kychars[i]<0x7F)){

sinNum++;

}

/*判断长度*/

if(kychars.length<5){

score+=5;

}else if(kychars.length>4&&kychars.length<8){

score+=10;

}else if(kychars.length>7){

score+=25;

}

/*判断字母*/

if(upNum==0&&lowNum==0){

}

if(upNum>0){

score+=10;

}

if(lowNum>0){

score+=10;

}

/*判断数字*/

if(numNum==0){

}

if(numNum>0){

score+=10;

}

if(numNum>1){

score+=10;

}

/*判断符号*/

if(sinNum==0){

}

if(sinNum>0){

score+=10;

}

if(sinNum>1){

score+=15;

}

/*奖励*/

if((upNum==0||lowNum==0)&&(numNum>0)){

score+=2;

if(sinNum>0){

score+=1;

if(upNum==0&&lowNum==0){

score+=2;

}

/*评价结果*/

if(score>=90){

return "VERY_SECURE";

}

if(score>=80){

return "SECURE";

}

if(score>=70){

return "VERY_STRONG";

}

if(score>=60){

return "STRONG";

}

if(score>=50){

return "AVERAGE";

}

if(score>=25){

return "WEAK";

}

return "VERY_WEAK";

}

HJ88 扑克牌大小

扑克牌大小

题目描述

扑克牌游戏大家应该都比较熟悉了，一副牌由54张组成，含3~A、2各4张，小王1张，大王1张。牌面从小到大用如下字符和字符串表示（其中，小写joker表示小王，大写JOKER表示大王）：

3 4 5 6 7 8 9 10 J Q K A 2 joker JOKER

输入两手牌，两手牌之间用"-"连接，每手牌的每张牌以空格分隔，"-"两边没有空格，如：4 4 4 4-joker JOKER。

请比较两手牌大小，输出较大的牌，如果不存在比较关系则输出ERROR。

基本规则：

（1）输入每手牌可能是个子、对子、顺子（连续5张）、三个、炸弹（四个）和对王中的一种，不存在其他情况，由输入保证两手牌都是合法的，顺子已经从小到大排列；

（2）除了炸弹和对王可以和所有牌比较之外，其他类型的牌只能跟相同类型的存在比较关系（如，对子跟对子比较，三个跟三个比较），不考虑拆牌情况（如：将对子拆分成个子）；

（3）大小规则跟大家平时了解的常见规则相同，个子、对子、三个比较牌面大小；顺子比较最小牌大小；炸弹大于前面所有的牌，炸弹之间比较牌面大小；对王是最大的牌；

（4）输入的两手牌不会出现相等的情况。

输入描述:

输入两手牌，两手牌之间用"-"连接，每手牌的每张牌以空格分隔，"-"两边没有空格，如 4 4 4 4-joker JOKER。

输出描述:

输出两手牌中较大的那手，不含连接符，扑克牌顺序不变，仍以空格隔开；如果不存在比较关系则输出ERROR。

示例1

输入

4 4 4 4-joker JOKER

输出

joker JOKER

import java.io.BufferedReader;

import java.io.InputStreamReader;

public class Main{

public static void main(String []args) throws Exception{

BufferedReader bf = new BufferedReader(new InputStreamReader(System.in));

String str;

while( (str = bf.readLine()) != null){

String []ss = str.split("-");

if(ss[0].equals("joker JOKER") || ss[1].equals("joker JOKER")){

System.out.println("joker JOKER");

continue;

}

String[] str0 = ss[0].split(" ");

String[] str1 = ss[1].split(" ");

str0 = findString(str0);

str1 = findString(str1);

int len0 = str0.length;

int len1 = str1.length;

if(len0 == 4 || len1 == 4){

if(len0 == 4 && len1 == 4){

int temp = Integer.parseInt(str0[0]) - Integer.parseInt(str1[0]);

if(temp >=0){

System.out.println(ss[0]);

continue;

}

}else if(len0 == 4){

System.out.println(ss[0]);

continue;

}else{

System.out.println(ss[1]);

continue;

}

if(len0 != len1){

System.out.println("ERROR");

continue;

}

int temp = Integer.parseInt(str0[0]) - Integer.parseInt(str1[0]);

if(temp >= 0){

System.out.println(ss[0]);

continue;

}else{

System.out.println(ss[1]);

continue;

}

private static String[] findString(String[] str){

for(int i = 0;i<str.length;i++){

switch(str[i]){

case "J":

str[i] = "11";

break;

case "Q":

str[i] = "12";

break;

case "K":

str[i] = "13";

break;

case "A":

str[i] = "14";

break;

case "2":

str[i] = "15";

break;

}

return str;

}

HJ89 24点运算

24点运算

题目描述

计算24点是一种扑克牌益智游戏，随机抽出4张扑克牌，通过加(+)，减(-)，乘(*), 除(/)四种运算法则计算得到整数24，本问题中，扑克牌通过如下字符或者字符串表示，其中，小写joker表示小王，大写JOKER表示大王：

3 4 5 6 7 8 9 10 J Q K A 2 joker JOKER

本程序要求实现：输入4张牌，输出一个算式，算式的结果为24点。

详细说明：

1.运算只考虑加减乘除运算，没有阶乘等特殊运算符号，友情提醒，整数除法要当心；

2.牌面2~10对应的权值为2~10, J、Q、K、A权值分别为为11、12、13、1；

3.输入4张牌为字符串形式，以一个空格隔开，首尾无空格；如果输入的4张牌中包含大小王，则输出字符串“ERROR”，表示无法运算；

4.输出的算式格式为4张牌通过+-*/四个运算符相连，中间无空格，4张牌出现顺序任意，只要结果正确；

5.输出算式的运算顺序从左至右，不包含括号，如1+2+3*4的结果为24

6.如果存在多种算式都能计算得出24，只需输出一种即可，如果无法得出24，则输出“NONE”表示无解。

输入描述:

输入4张牌为字符串形式，以一个空格隔开，首尾无空格；

输出描述:

如果输入的4张牌中包含大小王，则输出字符串“ERROR”，表示无法运算；

示例1

输入

A A A A

输出

NONE

import java.io.BufferedReader;

import java.io.IOException;

import java.io.InputStreamReader;

public class Main {

private static String[] op = new String[]{"+","-","*","/"};

public static void main(String[] args) throws IOException {

BufferedReader re=new BufferedReader(new InputStreamReader(System.in));

String input;

while((input = re.readLine()) != null && !"".equals(input)){

String[] ss = input.split(" ");

int a = getInputNum(ss[0]);

int b = getInputNum(ss[1]);

int c = getInputNum(ss[2]);

int d = getInputNum(ss[3]);

// 只要有joker，直接返回ERROR

if(a==-1||b==-1||c==-1||d==-1){

System.out.println("ERROR");

continue;

}

compute(a,b,c,d);

}

/**

* 24点计算方法穷举

* @param a

* @param b

* @param c

* @param d

public static void compute(int a,int b,int c,int d) {

int[] arr={a,b,c,d};

// 运算符穷举数组

String[][] arr1 = symbol();

for(int i=0;i<4;i++){// 第一个数字

for(int j=0;j<4;j++){// 第二个数字

for(int k=0;k<4;k++){// 第三个数字

for(int p=0;p<4;p++){// 第四个数字

if((i!=j)&&(i!=k)&&(i!=p)&&(j!=k)&&(j!=p)&&(k!=p)){// 如果四个数字互不相等才计算，不然一个字符就会出现两次

// 遍历运算符穷举数组

for(String[] str:arr1){

// 依次计算，得出最终结论

int sum = sumNum(arr[i], arr[j], str[0]);

sum=sumNum(sum, arr[k], str[1]);

sum=sumNum(sum, arr[p], str[2]);

if(sum==24){

// 如果结果等于24，返回结果

String str1=change2(arr[i])+str[0]+change2(arr[j])+str[1]+change2(arr[k])+str[2]+change2(arr[p])+"";

System.out.println(str1);

return;

}

// 穷举之后仍然没有结果，返回none

System.out.println("NONE");

}

/**

* 穷举所有可能的运算符组合

* @return

public static String[][] symbol() {

//运算符共三个，每个四种可能性，4*4*4中运算符组合，每个组合有三个运算符

String[][] symbol = new String[64][3];

int p =0;

for(int i=0;i<4;i++){// 第一个运算符

for(int j=0;j<4;j++){// 第二个运算符

for(int k=0;k<4;k++){// 第三个运算符

symbol[p++]=new String[]{op[i],op[j],op[k]};

}

return symbol;

}

/**

* 两个数字计算结果

* @param a

* @param b

* @param symb

* @return

public static int sumNum(int a, int b, String symb) {

switch(symb){

case "+":

return a+b;

case "-":

return a-b;

case "*":

return a*b;

case "/":

return a/b;

default:

return 0;

}

/**

* 字符串转数字

* @param str

* @return

public static int getInputNum(String str){

switch(str.toUpperCase()){

case "A":

return 1;

case "J":

return 11;

case "Q":

return 12;

case "K":

return 13;

case "JOKER":

return -1;

default:

return Integer.parseInt(str);

}

/**

* 数字转化为字符串

* @param i

* @return

public static String change2(int i) {

switch(i){

case 1:

return "A";

case 11:

return "J";

case 12:

return "Q";

case 13:

return "K";

default:

return String.valueOf(i);

}

HJ90 合法IP

合法IP

题目描述

现在IPV4下用一个32位无符号整数来表示，一般用点分方式来显示，点将IP地址分成4个部分，每个部分为8位，表示成一个无符号整数（因此不需要用正号出现），如10.137.17.1，是我们非常熟悉的IP地址，一个IP地址串中没有空格出现（因为要表示成一个32数字）。

现在需要你用程序来判断IP是否合法。

注意本题有多组样例输入。

输入描述:

输入一个ip地址，保证是xx.xx.xx.xx的形式（xx为整数）

输出描述:

返回判断的结果YES or NO

示例1

输入

10.138.15.1

255.0.0.255

255.255.255.1000

输出

YES

import java.io.*;

import java.util.*;

public class Main{

public static void main(String[] args)throws IOException{

BufferedReader bf = new BufferedReader(new InputStreamReader(System.in));

String str = "";

while((str = bf.readLine()) != null){

String[] subIP = str.split("\\.");

for(int i =0; i < subIP.length; i++){

Integer intIP = Integer.valueOf(subIP[i]);

if(intIP >= 0 && intIP<=255){

if(i == subIP.length-1){

System.out.println("YES");

}

continue;

} else{

System.out.println("NO");

break;

}

HJ91 201301 JAVA 题目2-3级

走方格的方案数

题目描述

请计算n*m的棋盘格子（n为横向的格子数，m为竖向的格子数）沿着各自边缘线从左上角走到右下角，总共有多少种走法，要求不能走回头路，即：只能往右和往下走，不能往左和往上走。

本题含有多组样例输入。

输入描述:

每组样例输入两个正整数n和m，用空格隔开。(1≤n,m≤8)

输出描述:

每组样例输出一行结果

示例1

输入

2 2

1 2

输出

import java.io.BufferedReader;

import java.io.IOException;

import java.io.InputStreamReader;

/**

*题目描述

* 请编写一个函数（允许增加子函数），计算n x m的棋盘格子（n为横向的格子数，m为竖向的格子数）沿着各自边缘线从左上角走到右下角，总共有多少种走法，要求不能走回头路，即：只能往右和往下走，不能往左和往上走。

* 输入描述:

* 输入两个正整数

* 输出描述:

* 返回结果

* 示例1

* 输入

* 2

* 输出

* 6

public class Main {

public static void main(String[] args)throws IOException {

BufferedReader bReader = new BufferedReader(new InputStreamReader(System.in));

String line = null;

while ((line = bReader.readLine()) != null) {

int n=Integer.valueOf(line.substring(0,line.indexOf(" ")));

int m=Integer.valueOf(line.substring(line.indexOf(" ")+1));

System.out.println(getCount(n, m));

}

/**

* 获取路线数量

* @param n

* @param m

* @return

public static int getCount(int n,int m) {

int[][] dp=new int[n+1][m+1];

for(int i=0;i<n+1;i++) {

for(int j=0;j<m+1;j++) {

if(i==0||j==0){

// 边上的每一个点的可能性都是1，因为走到边上，就只能顺着边往下走了，可能性只能是1

dp[i][j]=1;

}else{

// 往后每一个点，都是后面两个点的可能性之和，因为它可以选择任意一个点来走，可能性就是下两个点的可能性相加

dp[i][j]=dp[i][j-1]+dp[i-1][j];

}

// 最终加到最后一个点，可能性就是所有的路线数量

return dp[n][m];

}

HJ92 在字符串中找出连续最长的数字串

在字符串中找出连续最长的数字串

题目描述

输入一个字符串，返回其最长的数字子串，以及其长度。若有多个最长的数字子串，则将它们全部输出（按原字符串的相对位置）

本题含有多组样例输入。

输入描述:

输入一个字符串。

输出描述:

输出字符串中最长的数字字符串和它的长度，中间用逗号间隔。如果有相同长度的串，则要一块儿输出（中间不要输出空格）。

示例1

输入

abcd12345ed125ss123058789

a8a72a6a5yy98y65ee1r2

输出

123058789,9

729865,2

import java.io.*;

import java.util.*;

import java.lang.*;

public class Main{

public static void main(String[] args)throws IOException{

BufferedReader br = new BufferedReader(new InputStreamReader(System.in));

String s;

while((s=br.readLine())!=null){

char[] ch = s.toCharArray();

int max= Integer.MIN_VALUE;

char[] temp = new char[ch.length];

int y = 0;

for(int i=0;i<ch.length;i++){

if(ch[i]>='0'&&ch[i]<='9'){

int count = 1;

for(int j=i+1;j<ch.length;j++,i++){

if(ch[j]>='0'&&ch[j]<='9'){

count++;

}

else{

break;

}

if(count>max){

int x=0;

max = count;

for(int k=i+1-max;k<=i;k++){

temp[x++] = ch[k];

y = x;

}

else if(count==max){

for(int k=i+1-max;k<=i;k++){

temp[y++] = ch[k];

}

if(y==0){

System.out.println(null+","+0);

}

else{

for(int z=0;z<y-1;z++){

System.out.print(temp[z]);

}

System.out.println(temp[y-1]+","+max);

}

HJ93 201301 JAVA题目0-1级

数组分组

题目描述

输入int型数组，询问该数组能否分成两组，使得两组中各元素加起来的和相等，并且，所有5的倍数必须在其中一个组中，所有3的倍数在另一个组中（不包括5的倍数），能满足以上条件，输出true；不满足时输出false。

本题含有多组样例输入。

输入描述:

第一行是数据个数，第二行是输入的数据

输出描述:

返回true或者false

示例1

输入

1 5 -5 1

3 5 8

输出

true

说明

第一个样例：

第一组：5 -5 1

第二组：1

第二个样例：由于3和5不能放在同一组，所以不存在一种分法。

import java.io.BufferedReader;

import java.io.InputStreamReader;

import java.util.ArrayList;

import java.util.Arrays;

import java.util.List;

import java.io.IOException;

/**

* 传入一个int型数组，返回该数组能否分成两组，使得两组中各元素加起来的和相等，

* 并且，所有5的倍数必须在其中一个组中，所有3的倍数在另一个组中（不包括5的倍数）

* @author chronos

public class Main {

public static void main(String[] args) throws IOException {

BufferedReader read = new BufferedReader(new InputStreamReader(System.in));

String input;

while ((input = read.readLine()) != null){

int n = Integer.parseInt(input);

int[] array = new int[n];

String[] strs = read.readLine().split(" ");

for(int i = 0; i < n; i++) {

array[i] = Integer.parseInt(strs[i]);

}

System.out.println(solution(array));

}

public static boolean solution(int[] array) {

if(array.length < 2)

return false;

int sum = 0, sum3 = 0;

ArrayList<Integer> list = new ArrayList<>();

for(int i = 0; i < array.length; i++) {

sum += array[i];

if(array[i] % 3 == 0 && array[i] != 0)

sum3 += array[i];

else if(array[i] % 5 == 0 && array[i] != 0)

continue;

else

list.add(array[i]);

}

if(sum % 2 != 0)

return false;

int num1 = sum / 2 - sum3; //第一个数组差的数

return dfs(list, num1, 0);

// int len = list.size();

// int[] remainder = new int[len];

// for(int i = 0; i < len; i++) {

// remainder[i] = list.get(i);

// }

// Arrays.sort(remainder);

//在剩下的数字中找到和为num1的，如果没有返回false

}

private static boolean dfs(List<Integer> bag, int target, int i) {

if (i == bag.size())

return target == 0;

// dfs搜索，对每个元素，选择或者放弃

return dfs(bag, target, i + 1) || dfs(bag, target - bag.get(i), i + 1);

}

HJ94 记票统计

记票统计

题目描述

请实现一个计票统计系统。你会收到很多投票，其中有合法的也有不合法的，请统计每个候选人得票的数量以及不合法的票数。

本题有多组样例输入。

输入描述:

输入候选人的人数n，第二行输入n个候选人的名字（均为大写字母的字符串），第三行输入投票人的人数，第四行输入投票。

输出描述:

按照输入的顺序，每行输出候选人的名字和得票数量，最后一行输出不合法的票数。

示例1

输入

A B C D

A D E CF A GG A B

输出

A : 3

B : 1

C : 0

D : 1

Invalid : 3

import java.io.*;

public class Main{

public static void main(String[] args)throws IOException{

BufferedReader br = new BufferedReader(new InputStreamReader(System.in));

String str;

while((str = br.readLine())!=null){

int candidate = Integer.parseInt(str);

String[] name = br.readLine().split(" ");

int voter = Integer.parseInt(br.readLine());

String[] vote = br.readLine().split(" ");

int invalid = 0;

int[] number = new int[candidate];

for(int i=0; i<name.length; i++){

for(int j =0; j<vote.length; j++){

if(name[i].equals(vote[j])){

number[i]++;

}

voter -= number[i];

}

invalid = voter;

for(int i=0; i<name.length; i++){

System.out.println(name[i] + " : " + number[i]);

}

System.out.println("Invalid : " + invalid);

}

HJ95 人民币转换

人民币转换

题目描述

考试题目和要点：

1、中文大写金额数字前应标明“人民币”字样。中文大写金额数字应用壹、贰、叁、肆、伍、陆、柒、捌、玖、拾、佰、仟、万、亿、元、角、分、零、整等字样填写。

2、中文大写金额数字到“元”为止的，在“元”之后，应写“整字，如532.00应写成“人民币伍佰叁拾贰元整”。在”角“和”分“后面不写”整字。

3、阿拉伯数字中间有“0”时，中文大写要写“零”字，阿拉伯数字中间连续有几个“0”时，中文大写金额中间只写一个“零”字，如6007.14，应写成“人民币陆仟零柒元壹角肆分“。

4、10应写作“拾”，100应写作“壹佰”。例如，1010.00应写作“人民币壹仟零拾元整”，110.00应写作“人民币壹佰拾元整”

5、十万以上的数字接千不用加“零”，例如，30105000.00应写作“人民币叁仟零拾万伍仟元整”

本题含有多组样例输入。

输入描述:

输入一个double数

输出描述:

输出人民币格式

示例1

输入

151121.15

10012.02

输出

人民币拾伍万壹仟壹佰贰拾壹元壹角伍分

人民币壹万零拾贰元贰分

import java.util.*;

import java.io.BufferedReader;

import java.io.InputStreamReader;

import java.io.IOException;

public class Main{

private static String[] chineseNum = {"零","壹","贰","叁","肆","伍","陆","柒","捌","玖"};

private static String[] chineseUnit = {null,"拾","佰","仟","万","拾","佰","仟","亿"};

public static void main(String[] args)throws IOException{

BufferedReader br=new BufferedReader(new InputStreamReader(System.in));

String str;

while((str=br.readLine())!=null){

String zn;

String sn=null;

if(str.contains(".")){

String[] split=str.split("\\.");

zn=split[0];

sn=split[1];

}else{

zn=str;

}

String res=format(zn);

StringBuilder sb=new StringBuilder(res);

if(!"人民币".equals(res)){

sb.append("元");

}

if(sn==null||"00".equals(sn))

sb.append("整");

else{

int jn=Integer.parseInt(String.valueOf(sn.charAt(0)));

if(jn!=0){

sb.append(chineseNum[jn]);

sb.append("角");

}

int fn=Integer.parseInt(String.valueOf(sn.charAt(1)));

if(fn!=0){

sb.append(chineseNum[fn]);

sb.append("分");

}

System.out.println(sb.toString());

}

public static String format(String zn){

StringBuilder sb=new StringBuilder("人民币");

boolean hasZero=false;

if("0".equals(zn)){

return sb.toString();

}

for(int i=0;i<zn.length();i++){

int unitIndex=zn.length()-i-1;

int n=Integer.parseInt(String.valueOf(zn.charAt(i)));

switch(n){

case 0:

if(!hasZero&&unitIndex!=4){

sb.append(chineseNum[0]);

hasZero=true;

}

break;

case 1:

if(!"拾".equals(chineseUnit[unitIndex])){

sb.append(chineseNum[1]);

}

hasZero=false;

break;

default:

sb.append(chineseNum[n]);

hasZero=false;

break;

}

if(chineseUnit[unitIndex]!=null){

if(!hasZero) sb.append(chineseUnit[unitIndex]);

}

if(sb.charAt(sb.length()-1)=='零')

return sb.substring(0,sb.length()-1);

else

return sb.toString();

}

HJ96 表示数字

表示数字

题目描述

将一个字符中所有的整数前后加上符号“*”，其他字符保持不变。连续的数字视为一个整数。

注意：本题有多组样例输入。

输入描述:

输入一个字符串

输出描述:

字符中所有出现的数字前后加上符号“*”，其他字符保持不变

示例1

输入

Jkdi234klowe90a3

5151

输出

Jkdi*234*klowe*90*a*3*

*5151*

import java.io.*;

public class Main{

public static void main(String[] args)throws IOException{

BufferedReader br = new BufferedReader(new InputStreamReader(System.in));

String str = "";

while ((str = br.readLine()) != null){

char[] c = str.toCharArray();

StringBuilder sb = new StringBuilder();

int i = 0;

while(i < c.length){

if (c[i] >= '0' && c[i] <= '9'){

sb.append("*");

sb.append(c[i]);

while(++i < c.length && c[i] >= '0' && c[i] <= '9'){

sb.append(c[i]);

}

sb.append("*");

}else{

sb.append(c[i]);

i++;

}

System.out.println(sb.toString());

}

HJ97 记负均正

记负均正

题目描述

首先输入要输入的整数个数n，然后输入n个整数。输出为n个整数中负数的个数，和所有正整数的平均值，结果保留一位小数。

本题有多组输入用例。

输入描述:

首先输入一个正整数n，

然后输入n个整数。

输出描述:

输出负数的个数，和所有正整数的平均值。

示例1

输入

1 2 3 4 5

输出

0 3.0

import java.io.*;

import java.util.*;

/*首先输入要输入的整数个数n，然后输入n个整数。输出为n个整数中负数的个数，和所有正整数的平均值，结果保留一位小数。*/

public class Main{

public static void main(String[] args) throws IOException{

BufferedReader br = new BufferedReader(new InputStreamReader(System.in));

String str;

while((str=br.readLine())!=null){

int n = Integer.parseInt(str);

String[] nums=br.readLine().split(" ");

int negative=0;

int positive=0;

int sum=0;

for(int i=0;i<nums.length;i++){

int num=Integer.parseInt(nums[i]);

if(num<0){

negative++;

}else if(num>0){

sum+=num;

positive++;

}

System.out.println(negative+" "+Math.round(sum*10.0/positive)/10.0);

}

HJ98 自动售货系统

自动售货系统

题目描述

1 总体说明

考生需要模拟实现一个简单的自动售货系统，实现投币、购买商品、退币、查询库存商品及存钱盒信息的功能。

系统初始化时自动售货机中商品为6种商品,商品的单价参见1.1规格说明，存钱盒内放置1元、2元、5元、10元钱币，商品数量和钱币张数通过初始化命令设置，参见2.1 系统初始化。

1.1规格说明

1. 商品:每种商品包含商品名称、单价、数量三种属性，其中商品名不重复。考生不能修改商品名称和单价，初始化命令设置商品数量。这些信息在考试框架中进行定义，考生在实现功能代码时可直接使用。

2. 存钱盒信息：钱币面额、张数两种属性。初始化命令设置各种面额钱币张数。这些信息在考试框架中进行定义，考生在实现功能代码时可直接使用。

3. 退币原则：

1) 根据系统存钱盒内钱币的信息，按钱币总张数最少的原则进行退币。

2) 如果因零钱不足导致不能退币，则尽最大可能退币，以减少用户损失。

例如：假设存钱盒内只有4张2元，无其它面额钱币。如果需要退币7元，系统因零钱不足无法退币，则继续尝试退币6元，最终系统成功退币3张2元,用户损失1元钱币。

4. 投币操作说明：每次投币成功，投入的钱币面额累加到投币余额；同时，本次投入的钱币放入存钱盒中，存钱盒相应面额钱币增加。

5. 投币余额：指当前自动售货机中用户剩余的可购买商品的钱币总额；例如：投入2元面额的钱币，投币余额增加2元；购买一件价格2元的商品，投币余额减少2元；

6. 投币余额约束：投币余额不能超过10元。

7. 退币操作说明：退币操作需要遵守退币原则；退币成功后，投币余额清零，同时扣除存钱盒相应的金额。

8. 购买商品操作说明：一次仅允许购买一件商品；购买商品成功后，自动售货机中对应商品数量减1，投币余额扣除本次购买商品的价格。

2 操作说明

命令字与第一个参数间使用一个空格分隔，多条命令采用分号隔开。考试系统会对输入命令格式进行处理，考生不需要关注输入命令格式的合法性，只需要实现命令处理函数。

2.1 系统初始化

命令格式：

r A1 数量 -A2 数量 -A3 数量 -A4 数量 -A5 数量 -A6 数量 1 元张数 -2 元张数 -5 元张数 -10 元张数

商品和各种面额钱币取值范围只是作为初始化命令的限制，其它场景下不限制取值范围；考试框架已经实现取值范围的检查，考生不需要关注。

功能说明：设置自动售货机中商品数量和存钱盒各种面额的钱币张数；

约束说明：系统在任意阶段均可执行r初始化系统；考生不需要关注参数的合法性，不需要关注增加或缺少参数的场景；

输出说明：输出操作成功提示（执行完r命令后系统会自动输出操作结果，考生不需要再次调用输出函数），例：

2.2 投币

命令格式：p 钱币面额

功能说明：

（1）如果投入非1元、2元、5元、10元的钱币面额（钱币面额不考虑负数、字符等非正整数的情况），输出“E002:Denomination error”；

（2）如果存钱盒中1元和2元面额钱币总额小于本次投入的钱币面额，输出“E003:Change is not enough, pay fail”，但投入1元和2元面额钱币不受此限制。

（3）如果自动售货机中商品全部销售完毕，投币失败。输出“E005:All the goods sold out”；

（4）如果投币成功，输出“S002:Pay success,balance=X”；

约束说明：

（1）系统在任意阶段都可以投币；

（2）一次投币只能投一张钱币；

（3）同等条件下，错误码的优先级：E002 > E003 > E005；

输出说明：如果投币成功，输出“S002:Pay success,balance=X”。

例：

2.3 购买商品

命令格式：b 商品名称

功能说明：

（1）如果购买的商品不在商品列表中，输出“E006:Goods does not exist”；

（2）如果所购买的商品的数量为0，输出“E007:The goods sold out”；

（3）如果投币余额小于待购买商品价格，输出“E008:Lack of balance”；

（4）如果购买成功，输出“S003:Buy success,balance=X”；

约束说明：

（1）一次购买操作仅能购买一件商品，可以多次购买；

（2）同等条件下，错误码的优先级：E006 > E007 > E008；

输出说明：

如果购买成功，输出“S003:Buy success,balance=X”。

例:

2.4 退币

命令格式：c

功能说明：

（1）如果投币余额等于0的情况下，输出“E009:Work failure”；

（2）如果投币余额大于0的情况下，按照退币原则进行“找零”，输出退币信息；

约束说明：

（1）系统在任意阶段都可以退币；

（2）退币方式必须按照退币原则进行退币；

输出说明：如果退币成功，按照退币原则输出退币信息。

例，退5元钱币:

2.5 查询

命令格式：q 查询类别

功能说明：

（1）查询自动售货机中商品信息，包含商品名称、单价、数量。根据商品数量从大到小进行排序；商品数量相同时，按照商品名称的先后顺序进行排序。

例如：A1的商品名称先于A2的商品名称，A2的商品名称先于A3的商品名称。

（2）查询存钱盒信息，包含各种面额钱币的张数；

（3）查询类别如下表所示:

1 查询存钱盒信息

如果“查询类别”参数错误，输出“E010:Parameter error”。“查询类别”参数错误时，不进行下面的处理；

输出说明：

“查询类别”为0时，输出自动售货机中所有商品信息（商品名称单价数量）例：

“查询类别”为1时，输出存钱盒信息（各种面额钱币的张数），格式固定。例：

输入描述:

依照说明中的命令码格式输入命令。

输出描述:

输出执行结果

示例1

输入

r 22-18-21-21-7-20 3-23-10-6;c;q0;p 1;b A6;c;b A5;b A1;c;q1;p 5;

r 28-12-11-1-16-10 19-30-8-11;b A1;p 1;

输出

S001:Initialization is successful

E009:Work failure

E010:Parameter error

S002:Pay success,balance=1

E008:Lack of balance

1 yuan coin number=1

2 yuan coin number=0

5 yuan coin number=0

10 yuan coin number=0

E008:Lack of balance

E009:Work failure

E010:Parameter error

S002:Pay success,balance=5

S001:Initialization is successful

E008:Lack of balance

S002:Pay success,balance=1

import java.io.BufferedReader;

import java.io.IOException;

import java.io.InputStreamReader;

public class Main {

public static void main(String[] args) throws IOException {

// TODO Auto-generated method stub

BufferedReader br=new BufferedReader(new InputStreamReader(System.in));

String str;

while((str=br.readLine())!=null) {

String[] strs=str.split(";");

int[] price=new int[] {2,3,4,5,8,6};

int[] goods=new int[6];

int[] money=new int[4];

int sum=0;

for(int i=0;i<strs.length;i++) {

String s=strs[i];

if(s.startsWith("r ")) {

String[] ss=s.substring(2).replace(" ", "-").split("-");

for(int j=0;j<goods.length;j++) {

goods[j]=Integer.parseInt(ss[j]);

}

for(int j=0;j<money.length;j++) {

money[j]=Integer.parseInt(ss[j+goods.length]);

}

System.out.println("S001:Initialization is successful");

}else if(s.startsWith("p ")) {

int input=Integer.parseInt(s.substring(2));

if(input !=1&&input!=2&&input!=5&&input!=10) {

System.out.println("E002:Denomination error");

continue;

}

if((money[0]+money[1]*2<input)&&(input==5||input==10)) {

System.out.println("E003:Change is not enough, pay fail");

continue;

}

boolean flag=false;

for(int g:goods) {

if(g!=0) {

flag=true;

}

if(!flag) {

System.out.println("E005:All the goods sold out");

continue;

}

sum+=input;

if(input==10) {

money[3]++;

}else if(input==5) {

money[2]++;

}else if(input==2) {

money[1]++;

}else if(input==1) {

money[0]++;

}

System.out.println("S002:Pay success,balance="+sum);

continue;

}else if(s.startsWith("b ")) {

String temp=s.substring(2);

if(!"A1".equals(temp)&&!"A2".equals(temp)&&!"A3".equals(temp)&&!"A4".equals(temp)&&!"A5".equals(temp)&&!"A6".equals(temp)) {

System.out.println("E006:Goods does not exist");

continue;

}

int index=Integer.parseInt(temp.substring(1))-1;

if(goods[index]==0) {

System.out.println("E007:The goods sold out");

continue;

}

if(price[index]>sum) {

System.out.println("E008:Lack of balance");

continue;

}

goods[index]--;

sum-=price[index];

System.out.println("S003:Buy success,balance="+sum);

continue;

}else if(s.startsWith("c")){

if(sum==0) {

System.out.println("E009:Work failure");

continue;

}else {

StringBuilder sb=new StringBuilder();

if(sum/10>=money[3]) {

sum-=money[3]*10;

sb.append("10 yuan coin number=").append(money[3]);

money[3]=0;

}else {

money[3]-=sum/10;

sb.append("10 yuan coin number=").append(sum/10);

sum-=(sum/10)*10;

}

if(sum/5>=money[2]) {

sum-=money[2]*5;

sb.insert(0,"\n").insert(0, money[2]).insert(0, "5 yuan coin number=");

money[2]=0;

}else {

money[2]-=sum/5;

sb.insert(0,"\n").insert(0, sum/5).insert(0, "5 yuan coin number=");

sum-=(sum/5)*5;

}

if(sum/2>=money[1]) {

sum-=money[1]*2;

sb.insert(0,"\n").insert(0, money[1]).insert(0, "2 yuan coin number=");

money[1]=0;

}else {

money[1]-=sum/2;

sb.insert(0,"\n").insert(0, sum/2).insert(0, "2 yuan coin number=");

sum-=(sum/2)*2;

}

if(sum>=money[0]) {

sum-=money[0];

sb.insert(0,"\n").insert(0, money[0]).insert(0, "1 yuan coin number=");

money[0]=0;

}else {

money[2]-=sum;

sb.insert(0,"\n").insert(0, sum).insert(0, "1 yuan coin number=");

sum=0;

}

System.out.println(sb);

sum=0;

continue;

}

}else if(s.startsWith("q")) {

if("q 0".equals(s)){

StringBuilder sb=new StringBuilder();

for(int j=0;j<goods.length;j++) {

sb.append("A").append(j+1).append(" ").append(goods[j]).append(" ").append(price[j]).append("\n");

}

System.out.print(sb);

continue;

}else if("q 1".equals(s)) {

System.out.println("1 yuan coin number="+money[0]+"\n"+"2 yuan coin number="+money[1]+"\n"+"5 yuan coin number="+money[3]+"\n"+"10 yuan coin number="+money[4]);

continue;

}else {

System.out.println("E010:Parameter error");

}

HJ99 自守数

自守数

题目描述

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

接口说明

功能: 求出n以内的自守数的个数

输入参数：

int n

返回值：

n以内自守数的数量。

public static int CalcAutomorphicNumbers( int n)

{

/*在这里实现功能*/

return 0;

}

本题有多组输入数据，请使用while(cin>>)等方式处理

输入描述:

int型整数

输出描述:

n以内自守数的数量。

示例1

输入

2000

输出

import java.io.*;

public class Main {

public static void main(String[] args) throws IOException {

BufferedReader br = new BufferedReader(new InputStreamReader(System.in));

String str = null;

while ((str = br.readLine()) != null) {

int n=Integer.valueOf(str);

int count=0;

for(int i=0;i<=n;i++){

int temp=i;

int j=1;

while(temp!=0){

temp=temp/10;

j=j*10;

}

if((i*i-i)%j==0){

count++;

}

System.out.println(count);

}

HJ100 等差数列

等差数列

题目描述

功能:等差数列 2，5，8，11，14。。。。

输入:正整数N >0

输出:求等差数列前N项和

本题为多组输入，请使用while(cin>>)等形式读取数据

输入描述:

输入一个正整数。

输出描述:

输出一个相加后的整数。

示例1

输入

输出

import java.io.*;

public class Main{

public static void main(String[] args) throws Exception{

BufferedReader br = new BufferedReader(new InputStreamReader(System.in));

String str = "";

while((str=br.readLine())!=null){

int n = Integer.parseInt(str);

System.out.println((3*n*n+n)/2);

}

HJ101 输入整型数组和排序标识，对其元素按照升序或降序进行排序

输入整型数组和排序标识，对其元素按照升序或降序进行排序

题目描述

输入整型数组和排序标识，对其元素按照升序或降序进行排序（一组测试用例可能会有多组数据）

本题有多组输入，请使用while(cin>>)处理

输入描述:

第一行输入数组元素个数

第二行输入待排序的数组，每个数用空格隔开

第三行输入一个整数0或1。0代表升序排序，1代表降序排序

输出描述:

输出排好序的数字

示例1

输入

1 2 4 9 3 55 64 25

1 2 3 4 5

输出

1 2 3 4 9 25 55 64

5 4 3 2 1

/**

* @FileName: Test

* @Author: KipFcrs

* @Date: 2020/8/3 16:27

import java.util.*;

import java.io.*;

public class Main {

public static void main(String[] args) throws IOException {

BufferedReader br = new BufferedReader(new InputStreamReader(System.in));

String inputCount;

while ((inputCount = br.readLine()) != null) {

int count = Integer.parseInt(inputCount);

String[] input = br.readLine().split(" ");

int flag = Integer.parseInt(br.readLine());

int[] num = new int[input.length];

for (int i = 0; i < input.length; i++) {

num[i] = Integer.parseInt(input[i]);

}

quickSort(num,0,num.length - 1);

StringBuilder sb = new StringBuilder();

if(flag == 0){

for (int j = 0; j < num.length; j++) {

sb.append(num[j]).append(" ");

}

}else{

for (int k = num.length - 1; k >= 0; k--) {

sb.append(num[k]).append(" ");

}

System.out.println(sb.substring(0,sb.length()-1));

}

public static void quickSort(int[] num, int L, int R) {

if (L >= R) {

return;

}

int p = partition(num, L, R);

quickSort(num, L, p - 1);

quickSort(num, p+1, R);

}

public static int partition(int[] num, int L, int R) {

int key = num[L];

int pivot = L;

for (int i = L + 1; i <= R; i++) {

if (num[i] < key) {

int temp = num[++pivot];

num[pivot] = num[i];

num[i] = temp;

}

int tt = num[pivot];

num[pivot] = num [L];

num[L] = tt;

return pivot;

}

HJ102 字符统计

字符统计

题目描述

输入一个只包含小写英文字母和数字的字符串，按照不同字符统计个数由多到少输出统计结果，如果统计的个数相同，则按照ASCII码由小到大排序输出。

本题含有多组样例输入

输入描述:

一个只包含小写英文字母和数字的字符串。

输出描述:

一个字符串，为不同字母出现次数的降序表示。若出现次数相同，则按ASCII码的升序输出。

示例1

输入

aaddccdc

1b1bbbbbbbbb

输出

cda

说明

第一个样例里，c和d出现3次，a出现2次，但c的ASCII码比d小，所以先输出c，再输出d，最后输出a.

import java.io.*;

import java.util.*;

public class Main{

public static void main(String[] args) throws IOException{

BufferedReader br = new BufferedReader(new InputStreamReader(System.in));

String str;

while((str=br.readLine())!=null){

char[] chArr = str.toCharArray();

int[] temp = new int[150];

for(int i=0;i<chArr.length;i++){

temp[chArr[i]]++;

}

int max = 0;

for(int j=0;j<temp.length;j++){

if(max<temp[j]){

max = temp[j];

}

StringBuilder sbf = new StringBuilder();

while(max!=0){

for(int j=0;j<temp.length;j++){

if(temp[j] == max){

sbf.append((char)j);

}

max--;

}

System.out.println(sbf.toString());

}

HJ103 Redraiment的走法

Redraiment的走法

题目描述

Redraiment是走梅花桩的高手。Redraiment可以选择任意一个起点，从前到后，但只能从低处往高处的桩子走。他希望走的步数最多，你能替Redraiment研究他最多走的步数吗？

本题含有多组样例输入

输入描述:

输入多行，先输入数组的个数，再输入相应个数的整数

输出描述:

输出结果

示例1

输入

2 5 1 5 4 5

3 2 1

输出

说明

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.io.*;

import java.util.*;

public class Main{

public static void main(String[] args) throws IOException{

BufferedReader read = new BufferedReader(new InputStreamReader(System.in));

String input;

while ((input = read.readLine())!=null){

int num = Integer.parseInt(input);

String[] strs = read.readLine().split(" ");

int[] nums = new int[num];

int max = 0;

for(int i=0;i<strs.length;i++){

nums[i] = Integer.parseInt(strs[i]);

}

int[] result = new int[num];

for(int i =0; i<nums.length;i++){

result[i]=1;

for(int j = 0;j<i;j++){

if(nums[j]<nums[i]){

result[i]=Math.max(result[i],result[j]+1);

}

max = 1;

for(int i=0;i<result.length;i++){

if(result[i]>max){

max=result[i];

}

System.out.println(max);

}

HJ105 记负均正II

记负均正II

题目描述

从输入任意个整型数，统计其中的负数个数并求所有非负数的平均值，结果保留一位小数，如果没有非负数，则平均值为0

本题有多组输入数据，输入到文件末尾，请使用while(cin>>)读入

数据范围小于1e6

输入描述:

输入任意个整数，每行输入一个。

输出描述:

输出负数个数以及所有非负数的平均值

示例1

输入

-13

-4

-7

输出

0.0

import java.io.*;

import java.util.*;

public class Main{

public static void main(String[] args) throws IOException{

BufferedReader br= new BufferedReader(new InputStreamReader(System.in));

String str;

int count=0;

int total=0;

int countNot=0;

while((str=br.readLine())!=null){

int num=Integer.parseInt(str);

if(num<0){

count++;

}else{

total+=num;

countNot++;

}

System.out.println(count);

if(countNot==0){

System.out.println(0.0);

}else{

long s=Math.round(total*10.0/countNot);

System.out.println(s/10+"."+s%10);

}

HJ106 字符逆序

字符逆序

题目描述

将一个字符串str的内容颠倒过来，并输出。str的长度不超过100个字符。

输入描述:

输入一个字符串，可以有空格

输出描述:

输出逆序的字符串

示例1

输入

I am a student

输出

tneduts a ma I

import java.io.IOException;

public class Main {

public static void main(String[] args) throws IOException {

int length = System.in.available();

if(length > 2) {

byte[] bts = new byte[length-1];

int flag = System.in.read(bts);

if(flag!= -1) {

byte[] tmp = new byte[bts.length];

for (int i = 0; i < tmp.length; i++) {

tmp[i] = bts[tmp.length - i - 1];

}

System.out.println(new String(tmp));

}

HJ107 求解立方根

求解立方根

题目描述

计算一个数字的立方根，不使用库函数。

保留一位小数。

输入描述:

待求解参数，为double类型（一个实数）

输出描述:

输入参数的立方根。保留一位小数。

示例1

输入

216

输出

6.0

import java.io.BufferedReader;

import java.io.IOException;

import java.io.InputStreamReader;

public class Main{

public static void main(String[]args) throws IOException {

BufferedReader br=new BufferedReader(new InputStreamReader(System.in));

double input=Double.parseDouble(br.readLine());

boolean flag=false;

if(input<0) {

flag=true;

input=-input;

}

double distance=input;//误差或者增加的距离

double index=0;

double last=0;

while(true) {

last=index*index*index;

if(last>input) {

index-=distance;

distance/=10;

}

if(distance<0.001) {

break;

}

index+=distance;

}

double result=(int)((index+0.05)*10)/10.0;

if(flag) {

result=0-result;

}

System.out.println(result);

}

HJ108 求最小公倍数

求最小公倍数

题目描述

正整数A和正整数B 的最小公倍数是指能被A和B整除的最小的正整数值，设计一个算法，求输入A和B的最小公倍数。

输入描述:

输入两个正整数A和B。

输出描述:

输出A和B的最小公倍数。

示例1

输入

5 7

输出

import java.io.*;

import java.util.*;

public class Main{

public static void main(String[] args) throws IOException{

BufferedReader br = new BufferedReader(new InputStreamReader(System.in));

String str;

while((str=br.readLine())!=null){

String[] strArr = str.split(" ");

int n = Integer.parseInt(strArr[0]);

int m = Integer.parseInt(strArr[1]);

int j = m*n;

if(n>m){

int temp = m;

m = n;

n =temp;

}

//最大公约数

while(n!=0){

int r = m%n;

m = n;

n = r;

}

int max = j/m;

System.out.println(max);

}

DougLeaMrConcurrency

关注

1
点赞
踩
5

收藏

觉得还不错? 一键收藏
0
评论
Java算法：华为机试算法（下），华为算法Java版，牛客网华为算法73~108题

接上篇：Java算法：华为机试算法（上），华为算法Java版，牛客网华为算法1~54题HJ73 计算日期到天数转换计算日期到天数转换题目描述根据输入的日期，计算是这一年的第几天。。测试用例有多组，注意循环输入输入描述:输入多行，每行空格分割，分别是年，月，日输出描述:成功:返回outDay输出计算后的第几天;失败:返回-1示例1输入2012 12 31输出366import java.io.BufferedReader;import .
复制链接

扫一扫