这篇博客主要介绍了华为机试牛客网的编程题目，涵盖字符串操作、进制转换、位运算、排序算法、基础数学问题、数组和哈希处理、二维数组、递归、链表操作等多个方面，旨在提升编程能力和算法理解。
华为机试牛客网（1）
字符串题
截取字符串
1.输入待截取的字符串
2.输入一个正整数k，代表截取的长度
输出截取后的字符串
import java.util.*;
public class Main {
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
String str;
while (sc.hasNext()) {
//输入待截取的字符串
str = sc.nextLine();
//输入截取的长度
int length = sc.nextInt();
//截取
String result = str.substring(0, length);
System.out.println(result);
}
}
}
字符串最后一个单词的长度
计算字符串最后一个单词的长度，单词以空格隔开，字符串长度小于5000。（注：字符串末尾不以空格为结尾）
输入：
hello nowcoder
输出：
8
说明：
最后一个单词为nowcoder，长度为8
import java.util.Scanner;
public class Main{
public static void main(String[] args){
Scanner sc=new Scanner(System.in);
String str= sc.nextLine();
String sss[]=str.split(" ");
int length=sss[sss.length-1].length();
System.out.println(length);
}
}
计算某字符出现次数
输入描述：
第一行输入一个由字母、数字和空格组成的字符串，第二行输入一个字符（保证该字符不为空格）。
输出描述：
输出输入字符串中含有该字符的个数。（不区分大小写字母）
示例1
输入：
ABCabc
A
输出：
2
import java.util.*;
public class Main {
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
//完整字符串
String str1=sc.nextLine().toLowerCase();
//单个字符
String str2=sc.nextLine().toLowerCase();
//完整字符串长度-把该单个字符替换无空格=减少的长度=出现的次数
int num=str1.length()-str1.replaceAll(str2,"").length();
System.out.println(num);
}
}
字符串分隔
•输入一个字符串，请按长度为8拆分每个输入字符串并进行输出；
•长度不是8整数倍的字符串请在后面补数字0，空字符串不处理。
依次输出所有分割后的长度为8的新字符串
输入：
abc
输出：
abc00000
import java.util.*;
public class Main {
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
String str;
while(sc.hasNext()){
str=sc.nextLine();
while(str.length()>8){
//输出长度为8的字符串
System.out.println(str.substring(0,8));
//截取后面的字符串
str=str.substring(8);
}
//最后一个长度为0-8的字符串，补8个0
str=str+"00000000";
//输出长度为8的字符串
System.out.println(str.substring(0,8));
}
}
}
字符个数统计
输入描述：输入一行没有空格的字符串。多个相同的字符只计算一次
输出描述：输出 输入字符串 中范围在(0~127，包括0和127)字符的种数。
示例1
输入：abc
输出：3
示例2
输入：aaa
输出：1
import java.util.*;
public class Main {
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
String str;
//使用HashSet 不重复
HashSet<Character> hset=new HashSet<>();
while (sc.hasNext()) {
str=sc.nextLine();
char[] ch=str.toCharArray();
for(char num:ch){
hset.add(num);
}
System.out.println(hset.size());
}
}
}
数字颠倒
输入一个整数，将这个整数以字符串的形式逆序输出
程序不考虑负数的情况，若数字含有0，则逆序形式也含有0，如输入为100，则输出为001
输入：1516000
输出：0006151
import java.util.*;
public class Main {
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
String str;
while (sc.hasNext()) {
int num=sc.nextInt();
str=String.valueOf(num);
StringBuilder builder=new StringBuilder(str);
System.out.println(builder.reverse());
}
}
}
字符串反转
输入一个只包含小写字母的字符串，然后输出该字符串反转后的字符串
import java.util.Scanner;
public class Main {
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
String str=sc.nextLine();
System.out.println(new StringBuilder(str).reverse());
}
}
字符串排序
给定 n 个字符串，请对 n 个字符串按照字典序排列。字符串中只含有大小写字母。
import java.util.*;
public class Main {
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
//指定输入字符串的个数
int size = sc.nextInt();
//保存字符串的数组
String[] arr = new String[size];
//输入字符串
for (int i = 0; i <size; i++) {
arr[i] = sc.next();
}
Arrays.sort(arr);
//遍历输出
for (String str : arr) {
System.out.println(str);
}
}
}
简单密码
现在有一种密码变换算法。
九键手机键盘上的数字与字母的对应： 1–1， abc–2, def–3, ghi–4, jkl–5, mno–6, pqrs–7, tuv–8 wxyz–9, 0–0，把密码中出现的小写字母都变成九键键盘对应的数字，如：a 变成 2，x 变成 9.
而密码中出现的大写字母则变成小写之后往后移一位，如：X ，先变成小写，再往后移一位，变成了 y ，例外：Z 往后移是 a 。
数字和其它的符号都不做变换。
输入：
YUANzhi1987
输出：
zvbo9441987
import java.util.*;
/*
1.先用map把预定的键值对保存起来，将键单独存在keys里面
2.判断是数字就不变，是大写字母就转小写字母，再+1；是Z就变a
3.遍历keys集合，判断每一个key是否包含当前的字符，包含则getkey()，把值赋给当前字符的引用
4.遍历输出字符数组中的元素
*/
public class Main {
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
HashMap<String, Character> map = new HashMap<>();
map.put("1", '1');
map.put("abc", '2');
map.put("def", '3');
map.put("ghi", '4');
map.put("jkl", '5');
map.put("mno", '6');
map.put("pqrs", '7');
map.put("tuv", '8');
map.put("wxyz", '9');
map.put("0", '0');
Set<String> keys = map.keySet();
String str;
//ASII码 65-90为26个大写英文字母 97-122为26个小写英文字母
while (sc.hasNext()) {
str = sc.nextLine();
char[] cs=str.toCharArray();//转成char数组便于修改
for(int i=0;i<cs.length;i++){//遍历char数组
if(cs[i]>='0'&&cs[i]<='9'){//如果是正整数值不变
cs[i]=cs[i];
}else if(cs[i]>='A'&&cs[i]<='Y'){ //如果是大写字母，+32转小写，+1到下一个字母
cs[i]=(char)(cs[i]+32+1);
}else if(cs[i]=='Z'){ //如果是Z,变成a
cs[i]='a';
}else{//都是小写字母了
for(String key:keys){
if(key.contains(String.valueOf(cs[i]))){
cs[i]=map.get(key);
}
}
}
}
//遍历输出数组元素
for(char c:cs){
System.out.print(c);
}
}
}
}
删除字符串中出现次数最少的字符
实现删除字符串中出现次数最少的字符，若出现次数最少的字符有多个，则把出现次数最少的字符都删除。输出删除这些单词后的字符串，字符串中其它字符保持原来的顺序。
import java.util.*;
/*
map.getOrDefault(x,y)
如果map中存在key为x的，则返回该key对应的value值
如果不存在，则返回y作为默认值
*/
public class Main {
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
String str;
while (sc.hasNext()) {
str = sc.nextLine();
char[] ch=str.toCharArray();
//统计每个字符的数量
HashMap<Character,Integer> map=new HashMap<>();
for(char c:ch){
map.put(c,map.getOrDefault(c,0)+1);
}
//找出数量最少的字符数量
Collection<Integer> values= map.values();
Integer min=Collections.min(values);
//遍历key，找出value为min的字母用空字符替换
for(Character character:map.keySet()){
if(map.get(character)==min){
str=str.replaceAll(String.valueOf(character),"");
}
}
System.out.println(str);
}
}
}
单词倒排
对字符串中的所有单词进行倒排。
说明：
1、构成单词的字符只有26个大写或小写英文字母；
2、非构成单词的字符均视为单词间隔符；
3、要求倒排后的单词间隔符以一个空格表示；如果原字符串中相邻单词间有多个间隔符时，倒排转换后也只允许出现一个空格间隔符；
4、每个单词最长20个字母；
输入：$bo*y gi!r#l
输出：l r gi y bo
import java.util.*;
public class Main {
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
//按不是英文字母的规则拆分
String[] split=sc.nextLine().split("[^a-zA-Z]+");
StringBuilder bulider=new StringBuilder();
//倒序遍历数组
for(int i=split.length-1;i>=0;i--){
bulider.append(split[i]+" ");
}
System.out.println(bulider.toString().trim());
}
}
图片整理
Lily上课时使用字母数字图片教小朋友们学习英语单词，每次都需要把这些图片按照大小（ASCII码值从小到大）排列收好。请大家给Lily帮忙，通过代码解决。
Lily使用的图片使用字符"A"到"Z"、“a"到"z”、"0"到"9"表示。
输入描述：一行，一个字符串，字符串中的每个字符表示一张Lily使用的图片。
输出描述：Lily的所有图片按照从小到大的顺序输出（即字符串中的每个字符按ASCII码值从小到大排序输出）
import java.util.*;
public class Main {
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
String str;
while (sc.hasNext()) {
str = sc.nextLine();
char[] ch=str.toCharArray();
//Arrays.sort()排序是按ASCII码进行排序的
Arrays.sort(ch);
String result=String.valueOf(ch);
System.out.println(result);
}
}
}
统计字符
输入一行字符，分别统计出包含英文字母、空格、数字和其它字符的个数。
输入：
1qazxsw23 edcvfr45tgbn hy67uj m,ki89ol.\\/;p0-=\\][
输出：
26
3
10
12
import java.util.*;
public class Main {
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
String str;
while (sc.hasNext()) {
str = sc.nextLine();
//清除英文字母，对比先后的长度
String str1 = str.replaceAll("[a-zA-Z]+", "");
System.out.println(str.length() - str1.length());//英文字符个数
//清除空格，对比先后的长度
String str2 = str1.replaceAll(" ", "");
System.out.println(str1.length() - str2.length());//空格个数
//清除数字，对比先后的长度
String str3 = str2.replaceAll("[0-9]+", "");
System.out.println(str2.length() - str3.length());//数字个数
System.out.println(str3.length());//其他字符的个数
}
}
}
统计大写字母个数
找出给定字符串中大写字符(即’A’-‘Z’)的个数。
输入：A 1 0 1 1150175017(&^%&$vabovbaoadd 123#$%#%#O
输出：2
import java.util.*;
public class Main {
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
String str;
while (sc.hasNext()) {
str = sc.nextLine();
//清除英文字母，对比先后的长度
String str1 = str.replaceAll("[A-Z]+", "");
System.out.println(str.length() - str1.length());//大写英文字符个数
}
}
}
字符逆序
将一个字符串str的内容颠倒过来，并输出。
输入：
I am a student
输出：
tneduts a ma I
import java.util.*;
public class Main {
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
String str;
while (sc.hasNext()) {
str = sc.nextLine();
StringBuilder builder = new StringBuilder(str);
String result = builder.reverse().toString();
System.out.println(result);
}
}
}
字符串字符匹配
输入描述：输入两个字符串。第一个为短字符串，第二个为长字符串。两个字符串均由小写字母组成。
输出描述：如果短字符串的所有字符均在长字符串中出现过，则输出字符串"true"。否则输出字符串"false"。
输入：
bc
abc
输出：
true
import java.util.*;
public class Main {
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
while (sc.hasNext()) {
//把短字符串的字符加入到Set中，
//把长字符的字符从Set中剔除，如果最后Set为空，则满足条件。
String shortstr = sc.nextLine();
String longstr = sc.nextLine();
Set<Character> set=new HashSet<>();
for(int i=0;i<shortstr.length();i++){
set.add(shortstr.charAt(i));
}
for(int i=0;i<longstr.length();i++){
set.remove(longstr.charAt(i));
}
System.out.println(set.size()==0);
}
}
}
字符统计
输入一个只包含小写英文字母和数字的字符串，按照不同字符统计个数由多到少输出统计结果，如果统计的个数相同，则按照ASCII码由小到大排序输出。
输入：aaddccdc
输出：cda
说明：样例里，c和d出现3次，a出现2次，但c的ASCII码比d小，所以先输出c，再输出d，最后输出a.
import java.util.*;
public class Main {
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
while (sc.hasNext()) {
String str = sc.nextLine();
HashMap<Character, Integer> map = new HashMap<>();
//把 字符-出现次数 放入HashMap中
for (char ch : str.toCharArray()) {
map.put(ch, map.getOrDefault(ch, 0) + 1);
}
//再把字符放入ArrayList中，自定义比较器进行sort
List<Character> chList = new ArrayList<>(map.keySet());
Collections.sort(chList, new Comparator() {
public int compare(Object o1, Object o2) {
Character ch1 = (Character) o1;
Character ch2 = (Character) o2;
if (map.get(ch1) > map.get(ch2)) {//先按照字符出现次数排列，次数高的排前面
return -1;
} else if (map.get(ch1) < map.get(ch2)) {
return 1;
} else {
return ch1 -ch2;//按照字符ASCII顺序升序排列。此处自动拆箱为char再自动转型为int
}
}
});
//输出排序后的字符
for (Character ch : chList) {
System.out.print(ch.toString());
}
}
}
}
句子逆序
输入一个英文语句，每个单词用空格隔开。保证输入只包含空格和字母。
输出得到逆序的句子
输入：
I am a boy
输出：
boy a am I
import java.util.*;
public class Main {
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
String str;
StringBuilder builder=new StringBuilder();
while (sc.hasNext()) {
str = sc.nextLine();
//按空格拆分
String[] strarr=str.split(" ");
//倒着遍历
for(int i=strarr.length-1;i>=0;i--){
builder.append(strarr[i]+" ");
}
System.out.println(builder.toString().trim());
}
}
}
坐标移动
开发一个坐标计算工具， A表示向左移动，D表示向右移动，W表示向上移动，S表示向下移动。从（0,0）点开始移动，从输入字符串里面读取一些坐标，并将最终输入结果输出到输出文件里面。
输入：
合法坐标为A(或者D或者W或者S) + 数字（两位以内） 坐标之间以;分隔。
非法坐标点需要进行丢弃。如AA10; A1A; % ; YAD; 等。
下面是一个简单的例子 如： A10;S20;W10;D30;X;A1A;B10A11;;A10;
处理过程：
起点（0,0）
- A10 = （-10,0）
- S20 = (-10,-20)
- W10 = (-10,-10)
- D30 = (20,-10)
- x = 无效
- A1A = 无效
- B10A11 = 无效
- 一个空 不影响
- A10 = (10,-10)
结果 （10， -10）
import java.util.*;
public class Main {
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
String str;
Map<Character, Integer> map = new HashMap<Character, Integer>();
while (sc.hasNext()) {
str = sc.nextLine();
//以；拆分
String[] strarr = str.split(";");
//遍历字符串数组，使用正则排除不符合规则的字符串
String regex = "[WASD][0-9]{1,2}";
for (String arr : strarr) {
if (arr.matches(regex)) {
map.put(arr.charAt(0), map.getOrDefault(arr.charAt(0),
0) + Integer.valueOf(arr.substring(1)));
}
}
int x=0,y=0;
x=x-map.get('A')+map.get('D');
y = y - map.get('S') + map.get('W');
System.out.println(x+","+y);
}
}
}
查找两个字符串a,b中的最长公共子串
查找两个字符串a,b中的最长公共子串。若有多个，输出在较短串中最先出现的那个。
输入：
abcdefghijklmnop
abcsafjklmnopqrstuvw
输出：
jklmnop
双指针法
import java.util.Scanner;
public class Main {
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
String s1 = sc.nextLine();
String s2 = sc.nextLine();
if (s1.length() > s2.length()) {
// 确保s1比较短
String tmp = s1;
s1 = s2;
s2 = tmp;
}
// 存储最长子串
String result = "";
// 左指针
int left = 0;
// 右指针，从第一个字符开始移动
int right = left + 1;
while (right <= s1.length()) {
String tmp = s1.substring(left, right);
if (s2.contains(tmp)) {
if (result.length() < tmp.length()) {
result = tmp;
}
// 是子串的情况下，只移动右指针
right++;
} else {//不是字串
// 左指针移动一位
left++;
right = left + 1;//右指针从左指针右边重新开始
}
}
System.out.println(result);
}
}
进制转换
十六进制转十进制
接受一个十六进制的数，输出该数值的十进制表示。（十六进制以0x开头，后面的数字才是）
示例1
输入：
0xAA
输出：
170
import java.util.*;
public class Main {
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
String str;
while(sc.hasNext()){
str=sc.nextLine().toUpperCase();
System.out.println( getNumber(str));
}
}
private static int getNumber(String str){
int result=0;
HashMap<Character,Integer> map=new HashMap<>();
map.put('0',0);
map.put('1',1);
map.put('2',2);
map.put('3',3);
map.put('4',4);
map.put('5',5);
map.put('6',6);
map.put('7',7);
map.put('8',8);
map.put('9',9);
map.put('A',10);
map.put('B',11);
map.put('C',12);
map.put('D',13);
map.put('E',14);
map.put('F',15);
//输入的字符串从第3位开始截取
str=str.substring(2);
//转字符数组
char[] num=str.toCharArray();
//遍历字符数组，公式y=y*16+x
for(char ch:num){
result=result*16+map.get(ch);
}
return result;
}
}
十进制和二进制转换
原理：ip地址的每段可以看成是一个0-255的整数，把每段拆分成一个二进制形式组合起来，然后把这个二进制数转变成
一个长整数。
举例：一个ip地址为10.0.3.193
每段数字 相对应的二进制数
10 00001010
0 00000000
3 00000011
193 11000001
组合起来即为：00001010 00000000 00000011 11000001,转换为10进制数就是：167773121，即该IP地址转换后的数字就是它了。
输入描述：
1 输入IP地址
2 输入10进制型的IP地址
输出描述：
1 输出转换成10进制的IP地址
2 输出转换后的IP地址
输入：
10.0.3.193
167969729
输出：
167773121
10.3.3.193
十进制转成二进制输出： **Integer.toBinaryString()**方法是将int类型的数字转化为二进制然后以字符串形式输出。
二进制转十进制：Integer.parseInt(String s) 一个参数，将字符串转成十进制整数
Integer.parseInt(String s,int radix) 两个参数，第二个参数 radix代表解析什么进制的数；
import java.util.*;
public class Main {
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
String str;
while (sc.hasNext()) {
str = sc.nextLine();
if (str.contains(".")) {
System.out.println(ipToNum(str));
} else {
System.out.println(numToIp(str));
}
}
}
private static long ipToNum(String str) {
//按"."先拆分,注意.要转义
String[] iparr = str.split("\\.");
StringBuilder stringBuilder = new StringBuilder();
for (int i = 0; i < iparr.length ; i++) {
//先把字符串变int
int ipint = Integer.parseInt(iparr[i]);
//整数转为二进制字符串
String ipbinarystr = Integer.toBinaryString(ipint);
//拼接起来，如果位数不够8位先补齐
while (ipbinarystr.length() < 8) {
ipbinarystr = "0" + ipbinarystr;
}
stringBuilder.append(ipbinarystr);
}
//把拼接好的二进制字符串转成十进制输出，使用Long
return Long.parseLong(stringBuilder.toString(), 2);
}
private static String numToIp(String str) {
//167773121
//把输入的字符串转成Long型整数
long num = Long.parseLong(str);
//转成二进制
String binaryString = Long.toBinaryString(num);
//不足4*8=32位补齐
while (binaryString.length() < 32) {
binaryString = "0" + binaryString;
}
//00001010 00000000 00000011 11000001
String[] iparr = new String[4];
for (int i = 0; i < 4; i++) {
//每8位截取一串
String substring = binaryString.substring(8 * i, 8 * i + 8);
//转成十进制
int ipint = Integer.parseInt(substring, 2);
iparr[i] = String.valueOf(ipint);
}
//[10 0 3 193]
//使用String.join(String分隔符，数组/集合)为每个字符加间隔符
String result = String.join(".", iparr);
return result;
}
}
位运算
求int型正整数在内存中存储时1的个数
输入一个 int 型的正整数，计算出该 int 型数据在内存中存储时 1 的个数。
数据范围：保证在 32 位整型数字范围内
输入：5
输出：2
import java.util.*;
public class Main {
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
while (sc.hasNext()) {
int num = sc.nextInt();
//Integer转二进制字符串
String str = Integer.toBinaryString(num);
String[] split = str.split("0");
//遍历数组，里面都为1，只是个数不一样，拼接起来
StringBuilder builder=new StringBuilder();
for(String s:split){
builder.append(s);
}
int size=builder.toString().trim().length();
System.out.println(size);
}
}
}
求最大连续bit数
求一个int类型数字对应的二进制数字中1的最大连续数。
例如3的二进制为00000011，最大连续2个1
import java.util.*;
public class Main {
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
while (sc.hasNext()) {
int num = sc.nextInt();
//Integer转二进制字符串
String str = Integer.toBinaryString(num);
String[] split = str.split("0");
int[] count = new int[20];
//遍历数组，里面都为1，个数不一样，统计个数放到新数字中
for (int i = 0; i < split.length; i++) {
int length = split[i].length();
count[i] = length;
}
Arrays.sort(count);//排序从小到大
System.out.println(count[count.length - 1]); //输出最大的
}
}
}
排序
明明的随机数
明明生成了NN个1到500之间的随机整数。请你删去其中重复的数字，即相同的数字只保留一个，把其余相同的数去掉，然后再把这些数从小到大排序，按照排好的顺序输出。
TreeSet 自动去重排序
import java.util.*;
public class Main {
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
//获取个数
int num = sc.nextInt();
//创建TreeSet进行去重排序
TreeSet<Integer> set = new TreeSet<>();
//输入
for (int i = 0 ; i < num ; i++) {
set.add(sc.nextInt());
}
//输出
Iterator iterator = set.iterator();
while (iterator.hasNext()) {
System.out.println(iterator.next());
}
}
}
质数因子
输入一个整数，按照从小到大的顺序输出它的所有质数的因子，以空格隔开。
输入：180
输出：2 2 3 3 5
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-5rNyMzRL-1670643288451)(C:\Users\Betty\Pictures\Snipaste_2022-12-07_15-05-19.png)]
import java.util.*;
public class Main {
public static void main(String[] args) {
// 处理输入
Scanner sc = new Scanner(System.in);
while (sc.hasNext()) {
// 获取需要求解的值
int target = sc.nextInt();
int y = 2;// 因子从2开始算
while (target != 1) { // 短除法，除到目标值为1为止
if (target % y == 0) { // 能能够整除2
System.out.print(y + " ");
target /= y;
} else { // 更新y的值
if (y > target / y) y = target; //如果剩余值为质数
else y++; //y值增加1
}
}
}
}
}
输入整型数组和排序标识
输入整型数组和排序标识，对其元素按照升序或降序进行排序
输入描述：
第一行输入数组元素个数
第二行输入待排序的数组，每个数用空格隔开
第三行输入一个整数0或1。0代表升序排序，1代表降序排序
输出描述：
输出排好序的数字
升序和降序排列
import java.util.*;
public class Main {
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
while (sc.hasNext()) {
int size = sc.nextInt();
int[] arr = new int[size];
for (int i = 0; i <size ; i++) {
arr[i]= sc.nextInt();
}
int sort = sc.nextInt();
if (sort==0){
ascSort(arr);
}
if (sort==1){
descSort(arr);
}
}
}
private static void ascSort(int[] arr) {
Arrays.sort(arr);//默认从小到大排序
//遍历输出
StringBuilder builder = new StringBuilder();
for (int num : arr) {
builder.append(num+" ");
}
System.out.println(builder.toString().trim());
}
private static void descSort(int[] arr) {
Integer[] integers = new Integer[arr.length];
for (int i = 0; i < arr.length; i++) {
integers[i]=Integer.valueOf(arr[i]);
}
//Comparator<T> Collections.reverseOrder() 方法 数组必须是包装类型，否则会编译不通过
Arrays.sort(integers,Collections.reverseOrder());//默认升序，加一个比较器反转
//遍历输出
StringBuilder builder = new StringBuilder();
for (int num : integers) {
builder.append(num+" ");
}
System.out.println(builder.toString().trim());
}
}
字符串排序
编写一个程序，将输入字符串中的字符按如下规则排序。
规则 1 ：英文字母从 A 到 Z 排列，不区分大小写。
如，输入： Type 输出： epTy
规则 2 ：同一个英文字母的大小写同时存在时，按照输入顺序排列。
如，输入： BabA 输出： aABb
规则 3 ：非英文字母的其它字符保持原来的位置。
如，输入： By?e 输出： Be?y
输入：
A Famous Saying: Much Ado About Nothing (2012/8).
输出：
A aaAAbc dFgghh: iimM nNn oooos Sttuuuy (2012/8).
import java.util.*;
public class Main {
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
String str;
while (sc.hasNext()) {
str = sc.nextLine();
String result = sort(str);
System.out.println(result);
}
}
private static String sort(String str) {
//先将英文字母收集起来
ArrayList<Character> letters = new ArrayList<>();
for (char ch : str.toCharArray()) {
//Character 对象的 isLetter() 方法用于判断指定字符是否为字母
if (Character.isLetter(ch)) {
letters.add(ch);
}
}
//将英文字母从小到大排序好
letters.sort(new Comparator<Character>() {//自定义比较器
@Override
public int compare(Character o1, Character o2) {//o1 后一位 o2 前一位
return Character.toLowerCase(o1) - Character.toLowerCase(o2);//返回正数就是相当于true，不调整，负数false要调整顺序
}
});
//非英文字母则直接添加
StringBuilder result= new StringBuilder();
for (int i = 0,j=0; i <str.length(); i++) {
if (Character.isLetter(str.charAt(i))){
result.append(letters.get(j++));
}else {
result.append(str.charAt(i));
}
}
return result.toString();
}
}
查找兄弟单词
定义一个单词的“兄弟单词”为：交换该单词字母顺序（注：可以交换任意次），而不添加、删除、修改原有的字母就能生成的单词。
兄弟单词要求和原来的单词不同。例如： ab 和 ba 是兄弟单词。 ab 和 ab 则不是兄弟单词。
现在给定你 n 个单词，另外再给你一个单词 x ，让你寻找 x 的兄弟单词里，按字典序排列后的第 k 个单词是什么？
注意：字典中可能有重复单词。
输入描述：
输入只有一行。 先输入字典中单词的个数n，再输入n个单词作为字典单词。 然后输入一个单词x 最后后输入一个整数k
输出描述：
第一行输出查找到x的兄弟单词的个数m 第二行输出查找到的按照字典顺序排序后的第k个兄弟单词，没有符合第k个的话则不用输出。
输入：
6 cab ad abcd cba abc bca abc 1
输出：
3
bca
说明：
abc的兄弟单词有cab cba bca，所以输出3
经字典序排列后，变为bca cab cba，所以第1个字典序兄弟单词为bca
import java.util.*;
public class Main {
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
String str;
while (sc.hasNext()) {
//输入只有一行
str = sc.nextLine();
String[] split = str.split(" ");
//第一个是字典单词的个数
Integer zidianNum = Integer.parseInt(split[0]);
//最后一个是k，需要第几个兄弟单词
Integer k = Integer.parseInt(split[split.length - 1]);
//倒数第2个是单词x,基准单词
String x = split[split.length - 2];
//定义一个兄弟单词的集合
ArrayList<String> list = new ArrayList<>();
//遍历字典单词
for (int i = 1; i <= zidianNum; i++) {
if (isBrother(x, split[i])) {//是兄弟单词,加入兄弟单词集合
list.add(split[i]);
}
}
//对兄弟单词集合排序
Collections.sort(list);
System.out.println(list.size());//输出兄弟单词的个数
// 1<=k<=兄弟单词个数
if (k >= 1 && k <= list.size()) {
System.out.println(list.get(k-1));
}
}
}
private static boolean isBrother(String x, String zidianword) {
if (x.length() != zidianword.length() || zidianword.equals(x)) {//字典单词和基准单词长度不一致或内容一模一样时，false
return false;
}
char[] chars1 = x.toCharArray();
char[] chars2 = zidianword.toCharArray();
//对字典单词和基准单词做排序，最后如果一样，说明含有的字母是相同的
Arrays.sort(chars1);
Arrays.sort(chars2);
return new String(chars1).equals(new String(chars2));
}
}
基础数学
取近似值
写出一个程序，接受一个正浮点数值，输出该数值的近似整数值。如果小数点后数值大于等于 0.5 ,向上取整；小于 0.5 ，则向下取整。
(int)小数-----》只取整数部分，不管小数四舍五入
import java.util.*;
public class Main {
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
String str;
while (sc.hasNext()) {
double doub=sc.nextDouble();
//取出整数部分
int a=(int)doub;
//判断小数部分大于0.5进1
if((doub-a)>=0.5){
a=(int)(doub+0.5);
}
System.out.println(a);
}
}
}
记负均正
输入 n 个整型数，统计其中的负数个数并求所有非负数的平均值，结果保留一位小数，如果没有非负数，则平均值为0
import java.text.DecimalFormat;
import java.util.Scanner;
public class Main {
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
int count1 = 0;//非负数个数
int count2 = 0;//负数个数
double sum = 0.0;
while (sc.hasNextInt()) {
int cur = sc.nextInt();
if (cur >= 0) { //非负数
count1++;
sum += cur;
} else {
count2++;
}
}
System.out.println(count2);
DecimalFormat df = new DecimalFormat("0.0");
System.out.printf(df.format(sum / count1));
}
}
数组和哈希
合并表记录
输入描述：
先输入键值对的个数n（1 <= n <= 500）
接下来n行每行输入成对的index和value值，以空格隔开
输出描述：
输出合并后的键值对（多行）
输入：
4
0 1
0 2
1 2
3 4
输出：
0 3
1 2
3 4
import java.util.*;
public class Main {
public static void main(String[] args) {
Scanner in = new Scanner(System.in);
while (in.hasNext()) {
int size = in.nextInt();
TreeMap<Integer,Integer> treemap=new TreeMap<>();
for (int i = 0; i < size; i++) {
int key = in.nextInt();
int value = in.nextInt();
if(treemap.containsKey(key)){
treemap.put(key,treemap.get(key)+value);
}else{
treemap.put(key,value);
}
}
for(Map.Entry<Integer,Integer> entry:treemap.entrySet()){
System.out.println(entry.getKey()+" "+entry.getValue());
}
}
}
}
提取不重复的整数
输入一个 int 型整数，按照从右向左的阅读顺序，返回一个不含重复数字的新的整数。
保证输入的整数最后一位不是 0 。
输入：
9876673
输出：
37689
import java.util.*;
public class Main {
public static void main(String[] args) {
Scanner in = new Scanner(System.in);
while (in.hasNextInt()) {
int number = in.nextInt();
char[] charr=String.valueOf(number).toCharArray();
//LinkedHashSet遍历的时候可以按插入的顺序输出
LinkedHashSet<Character> set=new LinkedHashSet<>();
for(int i=charr.length-1;i>=0;i--){
set.add(charr[i]);
}
for(Character cc:set){
System.out.print(cc);
}
}
}
}
两数之和
给出一个整型数组 numbers 和一个目标值 target，请在数组中找出两个加起来等于目标值的数的下标，返回的下标按升序排列。
（注：返回的数组下标从1开始算起，保证target一定可以由数组里面2个数字相加得到）
import java.util.*;
public class Solution {
public int[] twoSum (int[] numbers, int target) {
int[] result = new int[2];
Map<Integer, Integer> map = new HashMap<>();
for (int i = 0; i < numbers.length; i++) {
if (map.get(target - numbers[i]) != null) {
result[0] = map.get(target - numbers[i]) + 1;
result[1] = i + 1;
return result;
}
map.put(numbers[i], i);
}
return result;
}
}
二维数组
矩阵乘法
第一行包含一个正整数x，代表第一个矩阵的行数
第二行包含一个正整数y，代表第一个矩阵的列数和第二个矩阵的行数
第三行包含一个正整数z，代表第二个矩阵的列数
之后x行，每行y个整数，代表第一个矩阵的值
之后y行，每行z个整数，代表第二个矩阵的值
输入：
2
3
2
1 2 3
3 2 1
1 2
2 1
3 3
输出：
14 13
10 11
import java.util.*;
public class Main {
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
while (sc.hasNext()) {
int x = sc.nextInt();
int y = sc.nextInt();
int z = sc.nextInt();
//定义第一个矩阵 x行，每行y个数
int[][] matrix1=new int[x][y];//二维数组[行][列]
//输入第一个矩阵的值
for (int i = 0; i <x; i++) {
for (int j = 0; j <y ; j++) {
matrix1[i][j]=sc.nextInt();
}
}
//定义第二个矩阵 y行，每行z个数
int[][] matrix2=new int[y][z];
//输入第二个矩阵的值
for (int i = 0; i <y; i++) {
for (int j = 0; j <z ; j++) {
matrix2[i][j]=sc.nextInt();
}
}
//定义结果矩阵
int[][] matrix3=new int[x][z];
//计算 矩阵计算见矩阵计算公式
for (int i = 0; i <x; i++) {
for (int j = 0; j <z ; j++) {
for (int k = 0; k <y ; k++) {
matrix3[i][j]+=matrix1[i][k]*matrix2[k][j];
}
}
}
//遍历输出
for (int i = 0; i <x ; i++) {
for (int j = 0; j <z ; j++) {
System.out.print(matrix3[i][j]);
System.out.print(" ");
}
System.out.println("");//一行输出完换行
}
}
}
}
递归
跳台阶
一只青蛙一次可以跳上1级台阶，也可以跳上2级。求该青蛙跳上一个 n 级的台阶总共有多少种跳法（先后次序不同算不同的结果）。
public class Solution {
public int jumpFloor(int target) {
if (target == 1) {
return 1;
}
if (target == 2) {
return 2;
}
return jumpFloor(target - 1) + jumpFloor(target - 2);
}
}
岛屿数量
给你一个由1（陆地）和0（水）组成的二维网格，请你计算网格中岛屿的数量。
岛屿：上下左右相连有1的都被认为是连续岛屿。随便从一个1出发可以到达其他1
import java.util.*;
public class Main {
public static void main(String[] args) {
char[][] chars = new char[4][5];
chars[0][0]='1';chars[0][1]='1';chars[0][2]='0';chars[0][3]='1';chars[0][4]='0';
chars[1][0]='1';chars[1][1]='1';chars[1][2]='0';chars[1][3]='1';chars[1][4]='0';
chars[2][0]='1';chars[2][1]='1';chars[2][2]='0';chars[2][3]='1';chars[2][4]='0';
chars[3][0]='0';chars[3][1]='0';chars[3][2]='0';chars[3][3]='0';chars[3][4]='1';
int landnum = numIslands(chars);
System.out.println("岛屿数量===="+landnum);
}
public static int numIslands(char[][] grid) {
//定义一个表示岛屿数量的变量
int count = 0;
//这个两层for循环是用来遍历整张二维表格中所有的陆地,其中 i 表示行，j 表示列
for (int i = 0; i < grid.length; i++) {
for (int j = 0; j < grid[0].length; j++) {
//逐行逐列的找1，找到一个1，就count+1，然后把这个1相连的1都变0
if (grid[i][j] == '1') {
dfs(grid, i, j);//此方法就是把所有这个1相连的1，改成0
count++;
}
}
}
//返回岛屿的数量
return count;
}
// 此dfs模板可以记住
public static void dfs(char[][] grid, int i, int j) {//i 行 j 列
//防止 i 和 j 越界，也就是防止超出岛屿（上下左右）的范围。特别注意当遍历到海洋的时候也退出循环
if (i < 0 || j < 0 || i >= grid.length || j >= grid[0].length || grid[i][j] == '0') return;
//将遍历过的陆地改为海洋，防止重复遍历
grid[i][j] = '0';
//下
dfs(grid, i + 1, j);
//上
dfs(grid, i - 1, j);
//右
dfs(grid, i, j + 1);
//左
dfs(grid, i, j - 1);
}
}
链表
从单向链表中删除指定值的节点
输入一个单向链表和一个节点的值，从单向链表中删除等于该值的节点，删除后如果链表中无节点则返回空指针。链表的值不能重复。
构造过程，例如输入一行数据为:
6 2 1 2 3 2 5 1 4 5 7 2 2
则第一个参数6表示输入总共6个节点，第二个参数2表示头节点值为2，剩下的2个一组表示第2个节点值后面插入第1个节点值，为以下表示:
1 2 表示为
2->1
链表为2->1
3 2表示为
2->3
链表为2->3->1
5 1表示为
1->5
链表为2->3->1->5
4 5表示为
5->4
链表为2->3->1->5->4
7 2表示为
2->7
链表为2->7->3->1->5->4
最后的链表的顺序为 2 7 3 1 5 4
最后一个参数为2，表示要删掉节点为2的值
删除 结点 2
则结果为 7 3 1 5 4
import java.util.*;
public class Main {
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
while (sc.hasNext()) {
int total = sc.nextInt();
int head = sc.nextInt();
List<Integer> list = new ArrayList<>();
list.add(head);
//输入total-1组值
for (int i = 0; i < total - 1 ; i++) {
int aa = sc.nextInt();
int bb = sc.nextInt();
list.add(list.indexOf(bb)+1, aa);
}
int remove = sc.nextInt(); //需要移除的数
list.remove(list.indexOf(remove));
for (Integer integer : list) {
System.out.print(integer + " ");
}
}
}
}
模拟
汽水瓶
某商店规定：三个空汽水瓶可以换一瓶汽水，允许向老板借空汽水瓶（但是必须要归还）。
小张手上有n个空汽水瓶，她想知道自己最多可以喝到多少瓶汽水。
输入例子：
3
10
81
0
输出例子：
1
5
40
import java.util.*;
public class Main {
public static void main(String[] args) {
Scanner in = new Scanner(System.in);
while (in.hasNextInt()) {
int kongnum = in.nextInt();
int count = 0;
while (kongnum > 2) {
int heshu = heshu(kongnum);//换到的汽水数量
count = count + heshu;//已经喝到的汽水数量
kongnum = kongnum - heshu * 3 + heshu;//剩余空瓶的数量
if (kongnum == 2) {
//剩余空瓶=2，可以借一个空瓶，再换一汽水，可以结束了
count = count + 1;
break;
}
}
if (!(count == 0)) {
System.out.println(count);
}
}
}
private static int heshu(int kongnum) {
//空瓶数量/3 = 换到的汽水数量 =喝完变成空瓶的数量
return (int)kongnum / 3;
}
}
字符串加解密
对输入的字符串进行加解密，并输出。
加密方法为：
当内容是英文字母时则用该英文字母的后一个字母替换，同时字母变换大小写,如字母a时则替换为B；字母Z时则替换为a；
当内容是数字时则把该数字加1，如0替换1，1替换2，9替换0；
其他字符不做变化。
解密方法为加密的逆过程。
输入描述：
第一行输入一串要加密的密码
第二行输入一串加过密的密码
输出描述：
第一行输出加密后的字符
第二行输出解密后的字符
输入：
abcdefg
BCDEFGH
输出：
BCDEFGH
abcdefg
import java.util.*;
public class Main {
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
String jiamicode=sc.nextLine();
String jiemicode = sc.nextLine();
System.out.println(jiami(jiamicode));
System.out.println(jiemi(jiemicode));
}
private static String jiami(String jiamicode){
// 65-90为26个大写英文字母 97-122为26个小写英文字母
//转字符数组
char[] jiamichar = jiamicode.toCharArray();
//遍历字符数组
for (int i = 0; i < jiamichar.length; i++) {
if(jiamichar[i]>='a'&&jiamichar[i]<'z'){//是小写字母
//则后一个字母替换并变大写
jiamichar[i]=(char)(jiamichar[i]+1-32);
}else if(jiamichar[i]>='A'&&jiamichar[i]<'Z'){//是大写字母
//则后一个字母替换并变小写
jiamichar[i]=(char)(jiamichar[i]+1+32);
}else if(jiamichar[i]=='Z'){//大写Z
jiamichar[i]='a';
}else if(jiamichar[i]=='z'){//小写z
jiamichar[i]='A';
}else if(jiamichar[i]>='0'&&jiamichar[i]<='9'){//数字
if (jiamichar[i]=='9'){
jiamichar[i]='0';
}else {
jiamichar[i]=(char)(jiamichar[i]+1);
}
}else {//剩下的都是其他字符，不做改变
jiamichar[i]=jiamichar[i];
}
}
return String.valueOf(jiamichar);
}
private static String jiemi(String jiemicode){
// 65-90为26个大写英文字母 97-122为26个小写英文字母
//转字符数组
char[] jiemichar = jiemicode.toCharArray();
//遍历字符数组
for (int i = 0; i < jiemichar.length; i++) {
if(jiemichar[i]>='a'&&jiemichar[i]<='z'){//是小写字母
if (jiemichar[i]=='a'){
jiemichar[i]='Z';
}else {
jiemichar[i]=(char)(jiemichar[i]-1-32);
}
}else if(jiemichar[i]>='A'&&jiemichar[i]<='Z'){//是大写字母
if (jiemichar[i]=='A'){
jiemichar[i]='z';
}else {
jiemichar[i]=(char)(jiemichar[i]-1+32);
}
}else if(jiemichar[i]>='0'&&jiemichar[i]<='9'){//数字
if (jiemichar[i]=='0'){
jiemichar[i]='9';
}else {
jiemichar[i]=(char)(jiemichar[i]-1);
}
}else {//剩下的都是其他字符，不做改变
jiemichar[i]=jiemichar[i];
}
}
return String.valueOf(jiemichar);
}
}
密码验证合格程序
密码要求:
1.长度超过8位
2.包括大小写字母.数字.其它符号,以上四种至少三种
3.不能有长度大于2的包含公共元素的子串重复 （注：其他符号不含空格或换行）
输入描述：一组字符串。
输出描述：如果符合要求输出：OK，否则输出NG
输入：
021Abc9000
021Abc9Abc1
021ABC9000
021$bc9000
输出：
OK
NG
NG
OK
import java.util.*;
public class Main {
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
String str;
while (sc.hasNext()) {
str = sc.nextLine();
//长度不超过8位，NG
if(str.length()<=8){
System.out.println("NG");
continue;
}
//种类是否有至少三种
if (!typeIsOk(str)){
System.out.println("NG");
continue;
}
//是都有长度大于2的字串重复
if (!isSubstringRepeats(str)) {//有
System.out.println("NG");
continue;
}
System.out.println("OK");
}
}
/*
需要包含大写字母，小写字母，数字，其他字符，至少三种
定义一个数组[0，0，0，0]出现一种，0变1，最后统计之和是否>=3 <3=>NG
*/
private static boolean typeIsOk(String str){
int[] typearr=new int[]{0,0,0,0};//[大写，小写，数字，其他]
char[] chars = str.toCharArray();
for (int i = 0; i < chars.length; i++) {
if (chars[i]>='a'&&chars[i]<='z'){
typearr[1]=1;
}else if (chars[i]>='A'&&chars[i]<='Z'){
typearr[0]=1;
}else if (chars[i]>='0'&&chars[i]<='9'){
typearr[2]=1;
}else {
typearr[3]=1;
}
}
//相加
if(typearr[0]+typearr[1]+typearr[2]+typearr[3]<3){
return false;
}
return true;
};
private static boolean isSubstringRepeats(String str){
boolean flag=true;
for (int i = 0; i <=str.length()-6 ; i++) {
for (int j = i+3; j <=str.length()-3; j++) {
String str1=str.substring(i,i+3);
String str2= str.substring(j,j+3);
if(str1.equals(str2)){
flag=false;
break;
}
}
}
return flag;
}
}
统计每个月兔子的总数
有一种兔子，从出生后第3个月起每个月都生一只兔子，小兔子长到第三个月后每个月又生一只兔子。
一月的时候有一只兔子，假如兔子都不死，问第n个月的兔子总数为多少？
import java.util.*;
public class Main {
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
while (sc.hasNext()) {
int month = sc.nextInt();//第month月
ArrayList<Rabbit> farm = new ArrayList<>();
//1.初始化农场有一只兔子，年龄为0
Rabbit rabbit = new Rabbit(0);
farm.add(rabbit);
//每过去一个月，兔子年龄会增加，同时满了2个月的兔子会生产
for (int i = 1; i <= month ; i++) { //遍历第i月，假设是第i月初
//月初。。。。。。。。。。
int n = farm.size();
for (int j = 0; j < n; j++) {//遍历兔子
Rabbit rabbit1 = farm.get(j);
//月末。。。。。。。。。。
if (rabbit1.getAge() >=
2) { //只要兔子年龄在满2个月以后，每月生一只兔子
farm.add(new Rabbit(
1));//这里不是0，是1，因为这月初出生，过完这月age=1
}
rabbit1.setAge(rabbit.getAge() + 1);
}
}
//得到兔子的总数
int number = farm.size();
System.out.println(number);
}
}
static class Rabbit {
private int age;
public Rabbit(int age) {
this.age = age;
}
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
}
}
称砝码
现有n种砝码，重量互不相等，分别为 m1,m2,m3…mn ；
每种砝码对应的数量为 x1,x2,x3…xn 。现在要用这些砝码去称物体的重量(放在同一侧)，问能称出多少种不同的重量。
输入描述：
对于每组测试数据：
第一行：n — 砝码的种数(范围[1,10])
第二行：m1 m2 m3 … mn — 每种砝码的重量(范围[1,2000])
第三行：x1 x2 x3 … xn — 每种砝码对应的数量(范围[1,10])
输出描述：
利用给定的砝码可以称出的不同的重量数
示例1
输入：
2
1 2
2 1
输出：
5
说明：
可以表示出0，1，2，3，4五种重量。
import java.util.*;
public class Main {
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
while (sc.hasNext()) {
int type = sc.nextInt();//砝码种类
int[] zhongliang = new int[type];//砝码重量数组
for (int i = 0; i < type; i++) {
zhongliang[i] = sc.nextInt();//砝码重量
}
int num = 0;//砝码总个数
int[] number = new int[type];//砝码重量对应的个数数组
for (int i = 0; i < type; i++) {
number[i] = sc.nextInt();
num = num + number[i];
}
//System.out.println("砝码总个数：" + num);
ArrayList<Integer> fama = getfama(num, number, zhongliang);//得到砝码集合，值为重量
//[1,1,2] 取0个，取1个，直到取3个
HashSet<Integer> set = new HashSet<>();//保存不同重量数的集合
set.add(0);
/*
利用集合去重的性质
先在集合里面添加0
当第一个砝码进来的时候
{0} 变成 {0,0+1}->{0,1}
当第二个砝码进来之后
{0，1} 变成 {0，1，0+1，1+1}--> {0,1,2}
当第三个砝码进来之后
{0,1,2} 变成{0，1，2，0+2，1+2，2+2}
---》 {0,1,2,3,4}
*/
for (int i = 0; i < fama.size(); i++) {//遍历砝码集合
ArrayList<Integer> list = new ArrayList<>(set);
int famai=fama.get(i);
Iterator iterator = list.iterator();
while (iterator.hasNext()) {//遍历List集合,添加到set中
int next = (int) iterator.next();
set.add(next +famai);
}
//System.out.println(set);
}
//System.out.println("最后的结果===="+set);
System.out.println(set.size());
}
}
private static ArrayList<Integer> getfama ( int num, int[] number, int[] zhongliang){//砝码总个数，砝码每种个数数组，砝码每种重量数组
ArrayList<Integer> fama = new ArrayList<>(num);//砝码总集合，里面显示的是重量
//遍历个数集合
for (int i = 0; i < number.length; i++) {
int shuliang = number[i];
int zhong = zhongliang[i];
for (int j = 1; j <= shuliang; j++) {
fama.add(zhong);
}
}
return fama;
}
}
扫一扫
1万+
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
