华为机试部分题目 JAVA 语言编写

最新推荐文章于 2023-03-14 17:43:22 发布

xcttstudy

最新推荐文章于 2023-03-14 17:43:22 发布

阅读量594

点赞数

文章标签：算法

本文链接：https://blog.csdn.net/weixin_44222269/article/details/107137762

版权

•连续输入字符串，请按长度为8拆分每个字符串后输出到新的字符串数组；
•长度不是8整数倍的字符串请在后面补数字0，空字符串不处理。

import java.util.Scanner;

/**链接：https://www.nowcoder.com/questionTerminal/d9162298cb5a437aad722fccccaae8a7?answerType=1&f=discussion

来源：牛客网

需要输入字符串，用到Scanner和hasNext()。

（1）建立 Scanner sc = new Scanner(System.in);

（2）判断有无输入用sc.hasNext().接收字符串使用sc.nextLine().

一次性接受全部的字符串，对8取余，获知需要补0的位数。使用StringBuilder中的append()函数进行字符串修改，别忘了toString()。

字符串缓冲区的建立：StringBuilder sb = new StringBuilder();

输出时，截取前8位进行输出，并更新字符串。用到str.substring()函数：

（1）str.substring(i)意为截取从字符索引第i位到末尾的字符串。

（2）str.substring(i,j)意为截取索引第i位到第（j-1）位字符串。包含i，不包含j

public class Main{

public static void main(String[] args){

Scanner sc=new Scanner(System.in);

while(sc.hasNext()){

String str = sc.nextLine();

StringBuilder sb=new StringBuilder();

sb.append(str);

int size = str.length();

int addZero = 8 - size%8;//addzero的可能值包括8

while((addZero > 0)&&(addZero<8)){//注意边界调节，避免addzero=8

sb.append("0");//使用‘’或“”都可

addZero--;

}

String str1 = sb.toString();

while(str1.length()>0){

System.out.println(str1.substring(0,8));

str1 = str1.substring(8);

}

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

最后一个数后面也要有空格

分解质因数代码：
将一个正整数分解质因数。例如：输入90,打印出90=233*5。
程序分析：对n进行分解质因数，应先找到一个最小的质数k，然后按下述步骤完成：
(1)如果这个质数恰等于n，则说明分解质因数的过程已经结束，打印出即可。
(2)如果n>k，但n能被k整除，则应打印出k的值（k为质因子）；并用n除以k的商,作为新的正整数你n；同时k++
　重复执行第一步。
(3)如果n不能被k整除，则用k++,重复执行第一步。

import java.util.Scanner;

public class Main{

public static void main(String[] args){

Scanner scan=new Scanner(System.in);

long num = Long.parseLong(scan.next());//java.lang.Long.parseLong(String s) 方法解析的字符串参数s作为一个符号的十进制长。

getPrimer(num);

}

public static void getPrimer(long num){

for (int i= 2;i <= num; i++){

if (num % i==0){

System.out.print(i + " ");

getPrimer(num/i);

break;

}

if (i==num){

System.out.print( i + "");

}

3. 计算字符串最后一个单词的长度，单词以空格隔开。

import java.util.Scanner;

public class Main{

public static void main(String[] args){

Scanner sc = new Scanner(System.in);

String str = sc.nextLine();

String[] s = str.split(" "); //正则表达式实用性更强( str.split("\\s+"))

int length = s[s.length - 1].length();

System.out.println(length);

}

4. 写出一个程序，接受一个由字母和数字组成的字符串，和一个字符，然后输出输入字符串中含有该字符的个数。不区分大小写。

输入描述:

第一行输入一个有字母和数字以及空格组成的字符串，第二行输入一个字符。

输出描述:

输出输入字符串中含有该字符的个数。

示例1

输入

复制

ABCDEF

输出

复制

import java.util.Scanner;

public class Main{

public static void main(String[] args){

Scanner scanner = new Scanner(System.in);

String str = scanner.nextLine().toLowerCase();

Character c = scanner.nextLine().charAt(0);

Character.toLowerCase(c);

int count = 0;

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

if(c == str.charAt(i)){

count++;

}

System.out.println(count);

}

5. 明明想在学校中请一些同学一起做一项问卷调查，为了实验的客观性，他先用计算机生成了N个1到1000之间的随机整数（N≤1000），对于其中重复的数字，只保留一个，把其余相同的数去掉，不同的数对应着不同的学生的学号。然后再把这些数从小到大排序，按照排好的顺序去找同学做调查。请你协助明明完成“去重”与“排序”的工作(同一个测试用例里可能会有多组数据，希望大家能正确处理)。

Input Param

n 输入随机数的个数

inputArray n个随机整数组成的数组

Return Value

OutputArray 输出处理后的随机整数

注：测试用例保证输入参数的正确性，答题者无需验证。测试用例不止一组。

样例输入解释：

样例有两组测试

第一组是3个数字，分别是：2，2，1。

第二组是11个数字，分别是：10，20，40，32，67，40，20，89，300，400，15。

import java.util.Scanner;

import java.util.TreeSet;

public class Main {

public static void main(String[] args) {

Scanner sc = new Scanner(System.in);

while(sc.hasNext()){

int num = sc.nextInt();

TreeSet<Integer> set = new TreeSet<Integer>();

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

int curr = sc.nextInt();

set.add(curr);

}

for(Integer i : set){

System.out.println(i);

}

6. 写出一个程序，接受一个十六进制的数，输出该数值的十进制表示。（多组同时输入）

输入描述:

输入一个十六进制的数值字符串。

输出描述:

输出该数值的十进制字符串。

示例1

输入

复制

0xA

输出

复制

import java.util.Scanner;

public class Main{

public static void main(String[] args){

Scanner scanner = new Scanner(System.in);

while(scanner.hasNext()){

String str = scanner.nextLine();

System.out.println(Integer.valueOf(str.substring(2),16).toString());

}

7. 将一个字符串str的内容颠倒过来，并输出。str的长度不超过100个字符。如：输入“I am a student”，输出“tneduts a ma I”。

输入参数：

inputString：输入的字符串

返回值：

输出转换好的逆序字符串

输入描述:

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

输出描述:

输出逆序的字符串

示例1

输入

复制

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);

while(sc.hasNext()){

String str = sc.nextLine();//next()是遇到空格；nextLine()是遇到回车

StringBuilder sb = new StringBuilder(str);

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

}}}

8. 写出一个程序，接受一个正浮点数值，输出该数值的近似整数值。如果小数点后数值大于等于5,向上取整；小于5，则向下取整。

import java.util.Scanner;

public class Main{

public static void main(String[] args){

Scanner sc=new Scanner(System.in);

double doubleNum = sc.nextDouble();

int intNum =(int) doubleNum;

if(doubleNum - intNum >=0.5 && doubleNum - intNum < 1){

intNum ++;

}

System.out.println(intNum);

}

9. 先输入键值对的个数
然后输入成对的index和value值，以空格隔开

import java.util.Scanner;

import java.util.TreeMap;

import java.util.Map;

public class Main{

public static void main(String[] args){

Scanner sc = new Scanner(System.in);

while (sc.hasNext()){

int next = sc.nextInt();

TreeMap<Integer,Integer> map = new TreeMap<>();

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

int key = sc.nextInt();

int value = sc.nextInt();

if (map.containsKey(key)){

map.put(key,map.get(key)+value);

}else {

map.put(key,value);

}

for (Map.Entry<Integer, Integer> integerIntegerEntry : map.entrySet()) {

System.out.println(integerIntegerEntry.getKey()+" "+integerIntegerEntry.getValue());

}

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

import java.util.Scanner;

/**

* 题目描述

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

* 输入描述:

* 输入一个int型整数

* 输出描述:

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

* 示例1

* 输入

* 9876673

* 输出

* 37689

public class Main {

public static void main(String[] args) {

Scanner scanner = new Scanner(System.in);

int num = scanner.nextInt();

char[] chars= (num+"").toCharArray();

String str ="";

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

if(!str.contains(chars[i]+"")){

str +=chars[i];

}

System.out.println(Integer.valueOf(str));

}

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

import java.util.Scanner;

import java.util.HashSet;

public class Main{

public static void main(String[] args){

Scanner sc = new Scanner(System.in);

while (sc.hasNext()){

char[] next = sc.next().toCharArray();

HashSet<Integer> set = new HashSet<>();

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

//(int)next.toCharArray()[i]

int ascValue = (int)next[i];

if(ascValue>0 && ascValue<127){

set.add(ascValue);

}

System.out.println(set.size());

}

12. 描述：

输入一个整数，将这个整数以字符串的形式逆序输出

程序不考虑负数的情况，若数字含有0，则逆序形式也含有0，如输入为100，则输出为001

输入描述:

输入一个int整数

输出描述:

将这个整数以字符串的形式逆序输出

示例1

输入

复制

1516000

输出

复制

0006151

import java.util.Scanner;

public class Main{

public static void main(String[] args){

Scanner sc=new Scanner(System.in);

String num=sc.nextLine();

char[] numchar=num.toCharArray();

String str="";

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

str += numchar[i];

}

System.out.println(str);

}

13. 写出一个程序，接受一个字符串，然后输出该字符串反转后的字符串。（字符串长度不超过1000）

输入描述:

输入N个字符

输出描述:

输出该字符串反转后的字符串

示例1

输入

复制

abcd

输出

复制

dcba

import java.util.Scanner;

public class Main{

public static void main(String[] args){

Scanner sc=new Scanner(System.in);

String strs=sc.nextLine();

char[] strschar=strs.toCharArray();

String str="";

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

str += strschar[i];

}

System.out.println(str);

}

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

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

import java.util.Scanner;

import java.util.Stack;

public class Main{

public static void main(String[] args){

Scanner sc=new Scanner(System.in);

String strs=sc.nextLine();

System.out.println(reverse(strs));

}

public static String reverse(String strs){

StringBuilder sb = new StringBuilder();

Stack<String> stack = new Stack<>();

String[] arr = strs.split("\\s");

for (String str : arr) {

stack.push(str);

}

while (!stack.isEmpty()) {

sb.append(stack.pop() + " ");

}

return sb.toString();

}

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

输入描述:

输入第一行为一个正整数n(1≤n≤1000),下面n行为n个字符串(字符串长度≤100),字符串中只含有大小写字母。

输出描述:

数据输出n行，输出结果为按照字典序排列的字符串。

import java.util.Arrays;

import java.util.Scanner;

public class Main {

public static void main(String[] args) {

Scanner sc = new Scanner(System.in);

int num = sc.nextInt();

String [] ss = new String[num];

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

ss[i]=sc.next();

}

Arrays.sort(ss);

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

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

}

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

输入描述:

输入一个整数（int类型）

输出描述:

这个数转换成2进制后，输出1的个数

示例1

输入

复制

输出

复制

import java.util.*;

public class Main{

public static void main(String[] args){

Scanner scanner = new Scanner(System.in);

while(scanner.hasNext()){

HashMap<Character, Integer> map = new HashMap<>();

int a = scanner.nextInt();

String Octal = Integer.toBinaryString(a);

char[] chars = Octal.toCharArray();

char chas='1';

for(char cha: chars){

if(map.containsKey(chas)){

map.put(cha, map.get(chas)+1);

}else{

map.put(cha, 1);

}

System.out.println(map.get(chas));

}

17. 题目描述

王强今天很开心，公司发给N元的年终奖。王强决定把年终奖用于购物，他把想买的物品分为两类：主件与附件，附件是从属于某个主件的，下表就是一些主件与附件的例子：

主件	附件
电脑	打印机，扫描仪
书柜	图书
书桌	台灯，文具
工作椅	无

如果要买归类为附件的物品，必须先买该附件所属的主件。每个主件可以有 0 个、 1 个或 2 个附件。附件不再有从属于自己的附件。王强想买的东西很多，为了不超出预算，他把每件物品规定了一个重要度，分为 5 等：用整数 1 ~ 5 表示，第 5 等最重要。他还从因特网上查到了每件物品的价格（都是 10 元的整数倍）。他希望在不超过 N 元（可以等于 N 元）的前提下，使每件物品的价格与重要度的乘积的总和最大。

设第 j 件物品的价格为 v[j] ，重要度为 w[j] ，共选中了 k 件物品，编号依次为 j 1 ， j 2 ，……， j k ，则所求的总和为：

v[j 1 ]*w[j 1 ]+v[j 2 ]*w[j 2 ]+ … +v[j k ]*w[j k ] 。（其中 * 为乘号）

请你帮助王强设计一个满足要求的购物单。

输入描述:

输入的第 1 行，为两个正整数，用一个空格隔开：N m

（其中 N （ <32000 ）表示总钱数， m （ <60 ）为希望购买物品的个数。）

从第 2 行到第 m+1 行，第 j 行给出了编号为 j-1 的物品的基本数据，每行有 3 个非负整数 v p q

（其中 v 表示该物品的价格（ v<10000 ）， p 表示该物品的重要度（ 1 ~ 5 ）， q 表示该物品是主件还是附件。如果 q=0 ，表示该物品为主件，如果 q>0 ，表示该物品为附件， q 是所属主件的编号）

import java.util.*;

public class Main{

public static void main(String[] args){

Scanner sc = new Scanner(System.in);

//获取背包容量

int m = sc.nextInt();

//获取物品数量

int n = sc.nextInt();

int[] v = new int[n+1];

int[] p = new int[n+1];

int[] q = new int[n+1];

int groups = 0;

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

v[i] = sc.nextInt();

p[i] = sc.nextInt();

q[i] = sc.nextInt();

if(q[i] == 0) {

//根据主件个数，决定分多少组。即背包问题的物品数量

groups++;

}

//分组

//定义容量数组

int[][] _v = new int[groups +1][4];

//定义价值数组

int[][] _p = new int[groups +1][4];

//得到赋值后的数组

processData(q, v, p, _v, _p);

int gc = _v.length;

//gc为背包问题实际上的商品数量-1，这样方便后面循环i< gc

//System.out.println("gc="+gc);

//m为背包问题实际上的容积上限，故意m+1,这样取值可以包括m

int[][] r = new int[gc][m+1];

//声明一个最大容量最大价值的数组

for(int i = 1; i< gc; i++){//商品数量

for(int j = 1; j<= m; j++){//商品体积

//背包问题-缩短为子问题-固定状态-假设不放第i件商品，此时实际占用容量为j，价值最大

int max = r[i-1][j];//假设为不装i的价值最大

//遍历看装i个商品的时候，里面附件和主件数量的综合

for (int t = 1; t < _v[i].length; t++) {

//System.out.println("t="+t);

//取processData过程赋的值

int tempv = _v[i][t];//当背包装i组商品时，t=主件+附件数量，实际体积

int tempp = _p[i][t];//装第i组商品时，实际价值

if(tempv != 0 && tempv <= j) {

int maxBak = r[i - 1][j - tempv] + tempp;//假设装i的时候价值最大

max = Math.max(max, maxBak);//验证假设，求实际的最大值

}

//此值就是在j容量下装i组商品的真正最大价值

r[i][j] = max;

//System.out.print("r[i][j] = max:"+max);

}

//那么本题实际有gc-1组商品，容量为m.其最大值为r[gc-1][m]

System.out.println(r[gc -1][m]);

}

//记得审题。如果 q>0 ，表示该物品为附件， q 是所属主件的编号

private static void processData(int[] m, int[] v, int[] p, int[][] _v, int[][] _p) {

Map<Integer, List<Integer>> groups = new HashMap<>();

for (int i = 1; i < m.length; i++) {

if(m[i] == 0 ) {

//第i件为主件

if(!groups.containsKey(i)) {

List<Integer> temp = new ArrayList<Integer>();

//记录此商品序号

temp.add(i);

//以商品序号-即主件编号当成key

groups.put(i, temp);

}

}else {

//System.out.println("aaaa 件商品的附件编号为m[i]="+m[i] + ",第i件商品="+i);

//第i件q>0为附件

if (groups.containsKey(m[i])) {

记录附件所属的主件编号一样的话

//取出value集合

List<Integer> list = groups.get(m[i]);

//增加此附件商品序号

list.add(i);

}else {

List<Integer> temp = new ArrayList<Integer>();

//记录附件所属的主件编号-也即自己主件的商品序号

temp.add(m[i]);

//记录此附件商品序号

temp.add(i);

//记录附件所属的主件编号

groups.put(m[i], temp);

}

int index = 1;

//遍历得出所有的大组，大组里面包括主件商品序号，有附件的还包括附件商品序号

for(List<Integer> list : groups.values()) {

int size = list.size();

if(size == 1) {

//说明只有主件，没有附件。那么给数组赋值

_v[index][1] = v[list.get(0)];//v[list.get(0)]主件的体积

_p[index][1] = p[list.get(0)] * v[list.get(0)];//list.get(0)] * v[list.get(0) 记得审题，本题中说每件物品的价格与重要度的乘积的总和最大

//那么主件的价值就是价格v[list.get(0)*重要度 p[list.get(0)

}else if (size == 2) {

//有一个主件一个附件，可以有两种购买方案

//第一种，只买主件

_v[index][1] = v[list.get(0)];

_p[index][1] = p[list.get(0)] * v[list.get(0)];

//第二种，既买主件也买附件

_v[index][2] = v[list.get(0)] + v[list.get(1)];

_p[index][2] = p[list.get(0)] * v[list.get(0)] + p[list.get(1)] * v[list.get(1)];

}else {

//System.out.println("size="+size);

//有一个主件二个附件，可以有三种购买方案

//第一种，只买主件

_v[index][1] = v[list.get(0)];

_p[index][1] = p[list.get(0)]* v[list.get(0)];

//第二种，既买主件也买一个附件

//这里要特别注意，搭配1：主件+附件一搭配2：主件+附件2，所以要算两次取最大值赋值

int vMax = v[list.get(0)] + v[list.get(1)];//主件+附件一

int vMaxBak = v[list.get(0)] + v[list.get(2)];//主件+附件二

_v[index][2] = Math.max(vMax,vMaxBak);//取最大搭配

int pMax = p[list.get(0)] * v[list.get(0)] + p[list.get(1)] * v[list.get(1)];//主件+附件一

int pMaxBak = p[list.get(0)] * v[list.get(0)] + p[list.get(2)] * v[list.get(2)];//主件+附件二

_p[index][2] = Math.max(pMax,pMaxBak);//取最大搭配

//第三种，既买主件也买二个附件

_v[index][3] = v[list.get(0)] + v[list.get(1)] + v[list.get(2)];

_p[index][3] = p[list.get(0)] * v[list.get(0)] + p[list.get(1)]* v[list.get(1)] + p[list.get(2)]* v[list.get(2)];

}

index++;

};

}

18. 开发一个坐标计算工具， 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.ArrayList;

import java.util.Scanner;

import java.util.List;

public class Main{

static List<String> list;//静态的list存放过滤后的坐标，整个类中都可以用

public static void main(String[] args) {

Scanner sc = new Scanner(System.in);

while (sc.hasNext()) {

String s = sc.nextLine();

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

list = new ArrayList<>();

//定义一个0到99的字符串数组

String[] numstr = new String[100];

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

numstr[i] = i + "";//int + "" 使int类型转换为String类型；

}

//过滤掉没用的坐标添加到list***中

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

//如A0 ~A9 长度为2；A10~A99 长度为3 ； A~Z的字符ASCII码为 65~90

if (str[i].length() == 3 ||str[i].length() == 2 && str[i].charAt(0) <= 90 && str[i].charAt(0) >= 65) {

String num = str[i].substring(1);

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

if (num.equals(numstr[j]))

list.add(str[i]);

}

//调用坐标移动方法

go(0, 0);

}

//坐标移动方法，上下左右对应W,S,A,D,且仅计算WSAD,其它的也就过滤掉了，及相应的x,y坐标移动；涉及计算的部分用Integer.parseInt()把字符串转化为整数；

private static void go(int x, int y) {

for (int i = 0; i < list.size(); i++) {

//上

if (list.get(i).substring(0, 1).equals("W")) {

x += 0;

y += Integer.parseInt(list.get(i).substring(1));

}

//下

if (list.get(i).substring(0, 1).equals("S")) {

x -= 0;

y -= Integer.parseInt(list.get(i).substring(1));

}

//左

if (list.get(i).substring(0, 1).equals("A")) {

x -= Integer.parseInt(list.get(i).substring(1));

y -= 0;

}

//右

if (list.get(i).substring(0, 1).equals("D")) {

x += Integer.parseInt(list.get(i).substring(1));

y += 0;

}

System.out.println(x + "," + y);

}

19. 请解析IP地址和对应的掩码，进行分类识别。要求按照A/B/C/D/E类地址归类，不合法的地址和掩码单独归类。

所有的IP地址划分为 A,B,C,D,E五类

A类地址1.0.0.0~126.255.255.255;

B类地址128.0.0.0~191.255.255.255;

C类地址192.0.0.0~223.255.255.255;

D类地址224.0.0.0~239.255.255.255；

E类地址240.0.0.0~255.255.255.255

私网IP范围是：

10.0.0.0～10.255.255.255

172.16.0.0～172.31.255.255

192.168.0.0～192.168.255.255

子网掩码为二进制下前面是连续的1，然后全是0。（例如：255.255.255.32就是一个非法的掩码）

注意二进制下全是1或者全是0均为非法

注意：

1. 类似于【0.*.*.*】和【127.*.*.*】的IP地址不属于上述输入的任意一类，也不属于不合法ip地址，计数时可以忽略

2. 私有IP地址和A,B,C,D,E类地址是不冲突的

输入描述:

多行字符串。每行一个IP地址和掩码，用~隔开。

输出描述:

统计A、B、C、D、E、错误IP地址或错误掩码、私有IP的个数，之间以空格隔开。

import java.util.Arrays;

import java.util.List;

import java.util.Scanner;

import java.util.stream.Collectors;

/**

* decription:识别有效的IP地址和掩码并进行分类统计

public class Main{

public static void main(String[] args) {

Scanner scanner = new Scanner(System.in);

int[] count = {0, 0, 0, 0, 0, 0, 0}; //个数数组

while (scanner.hasNext()) {

String str = scanner.nextLine();

String[] strings = str.split("~");

String ipStr = strings[0]; //ip

// System.out.println(ipStr);

String codeStr = strings[1]; //掩码

// System.out.println(codeStr);

String[] ipCharStr = ipStr.split("\\.");

//判断ip是否为空或者首字符是否等于0

Boolean isTrue = true;

int number = Integer.parseInt(ipCharStr[0]);

if (number == 0)

continue; //为0直接跳出本次循环

else {

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

if (ipCharStr[i].length() <= 0 || ipCharStr[i] == "") {

isTrue = false;

}

//如果ip地址正确判断掩码是否正确

if (isTrue) {

//判断掩码是否正确

int[] codeRange = {254, 252, 248, 240, 224, 192, 128, 0};

List<Integer> list = Arrays.stream(codeRange).boxed().collect(Collectors.toList());//int数组转化为list

String[] codeCharStr = codeStr.split("\\.");

//判断是否前面全为1后面全为0

if ("255".equals(codeCharStr[0])) {

if ("255".equals(codeCharStr[1])) {

if ("255".equals(codeCharStr[2])) {

if ("255".equals(codeCharStr[3])) {

isTrue = false;

} else if (list.contains(Integer.parseInt(codeCharStr[3]))) {

isTrue = true;

} else

isTrue = false;

} else if (list.contains(Integer.parseInt(codeCharStr[2]))) {

if (Integer.parseInt(codeCharStr[3]) == 0)

isTrue = true;

else

isTrue = false;

} else

isTrue = false;

} else if (list.contains(Integer.parseInt(codeCharStr[1]))) {

if (Integer.parseInt(codeCharStr[2]) == 0 && Integer.parseInt(codeCharStr[3]) == 0)

isTrue = true;

else

isTrue = false;

} else

isTrue = false;

} else if (list.contains(Integer.parseInt(codeCharStr[0]))) {

if (Integer.parseInt(codeCharStr[0]) == 0) {

isTrue = false;

} else {

if (Integer.parseInt(codeCharStr[1]) == 0 && Integer.parseInt(codeCharStr[2]) == 0 && Integer.parseInt(codeCharStr[3]) == 0)

isTrue = true;

else

isTrue = false;

}

} else

isTrue = false;

}

//调用方法判断地址范围和私网ip

if (isTrue) {

int first = Integer.parseInt(ipCharStr[0]);

int second = Integer.parseInt(ipCharStr[1]);

count = judgeIp(first, second, count);

} else {

count[5]++;

}

System.out.println(count[0] + " " + count[1] + " " + count[2] + " " + count[3] + " " + count[4] + " " + count[5] + " " + count[6]);

}

//判断地址范围和私网ip

public static int[] judgeIp(int first, int second, int[] count) {

//判断地址范围

if (first >= 1 && first <= 126)

count[0]++;

else if (first >= 128 && first <= 191)

count[1]++;

else if (first >= 192 && first <= 223)

count[2]++;

else if (first >= 224 && first <= 239)

count[3]++;

else if (first >= 240 && first <= 255)

count[4]++;

//判断私网ip

if (first == 192 && second == 168)

count[6]++;

if (first == 10)

count[6]++;

if (first == 172) {

if (second >= 16 && second <= 31)

count[6]++;

}

return count;

}

20. 开发一个简单错误记录功能小模块，能够记录出错的代码所在的文件名称和行号。

处理：

1、记录最多8条错误记录，循环记录（或者说最后只输出最后出现的八条错误记录），对相同的错误记录（净文件名（保留最后16位）称和行号完全匹配）只记录一条，错误计数增加；

2、超过16个字符的文件名称，只记录文件的最后有效16个字符；

3、输入的文件可能带路径，记录文件名称不能带路径。

import java.util.LinkedHashMap;

import java.util.Map;

import java.util.Scanner;

public class Main{

public static void main(String[] args) {

Scanner sc=new Scanner(System.in);

Map<String, Integer> map=new LinkedHashMap<String, Integer>();

while(sc.hasNext()){

String str=sc.next();

int linenum=sc.nextInt();

String[] arr=str.split("\\\\"); //根据\切割

String s=arr[arr.length-1];

if(s.length()>16) //截取

s=s.substring(s.length()-16);

String key=s+" "+linenum;

int value=1;

if(map.containsKey(key))

map.put(key, map.get(key)+1);

else {

map.put(key, value);

}

int count=0;

for(String string:map.keySet()){

count++;

if(count>(map.keySet().size()-8)) //输出最后八个记录

System.out.println(string+" "+map.get(string));

}

21. 密码要求:

1.长度超过8位

2.包括大小写字母.数字.其它符号,以上四种至少三种

3.不能有相同长度超2的子串重复

说明:长度超过2的子串

输入描述:

一组或多组长度超过2的子符串。每组占一行

输出描述:

如果符合要求输出：OK，否则输出NG

示例1

输入

复制

021Abc9000

021Abc9Abc1

021ABC9000

021$bc9000

输出

复制

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();

int i=0;

int []cla={0,0,0,0};

if(str.length()<9||str==null)

System.out.println("NG");

else{

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

char ch=str.charAt(i);

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

cla[0]=1;

}else if(ch>='a'&&ch<='z'){

cla[1]=1;

}else if(ch>='A'&&ch<='Z'){

cla[2]=1;

}else{

cla[3]=1;

}

if(cla[0]+cla[1]+cla[2]+cla[3]<3){

System.out.println("NG");

}else{

System.out.println(isHasSubString(str));

}

private static String isHasSubString(String str) {

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

String str1=str.substring(i,i+3);

String str2=str.substring(i+3, str.length());

if(str2.contains(str1))

return "NG";

}

return "OK";

}

22. 密码是我们生活中非常重要的东东，我们的那么一点不能说的秘密就全靠它了。哇哈哈. 接下来渊子要在密码之上再加一套密码，虽然简单但也安全。

假设渊子原来一个BBS上的密码为zvbo9441987,为了方便记忆，他通过一种算法把这个密码变换成YUANzhi1987，这个密码是他的名字和出生年份，怎么忘都忘不了，而且可以明目张胆地放在显眼的地方而不被别人知道真正的密码。

他是这么变换的，大家都知道手机上的字母： 1--1， abc--2, def--3, ghi--4, jkl--5, mno--6, pqrs--7, tuv--8 wxyz--9, 0--0,就这么简单，渊子把密码中出现的小写字母都变成对应的数字，数字和其他的符号都不做变换，

声明：密码中没有空格，而密码中出现的大写字母则变成小写之后往后移一位，如：X，先变成小写，再往后移一位，不就是y了嘛，简单吧。记住，z往后移是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();

String ss="";

int i=0;

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

char ch=str.charAt(i);

if(ch>='0'&&ch<='9')

ss=ss+ch;

if(ch>='a'&&ch<='z'){

if(ch>='a'&&ch<='c')

ss=ss+"2";

if(ch>='d'&&ch<='f')

ss=ss+"3";

if(ch>='g'&&ch<='i')

ss=ss+"4";

if(ch>='j'&&ch<='l')

ss=ss+"5";

if(ch>='m'&&ch<='o')

ss=ss+"6";

if(ch>='p'&&ch<='s')

ss=ss+"7";

if(ch>='t'&&ch<='v')

ss=ss+"8";

if(ch>='w'&&ch<='z')

ss=ss+"9";

if(ch=='1')

ss=ss+"1";

if(ch=='0')

ss=ss+"0";

}

if(ch>='A'&&ch<='Z'){

char cc=Character.toLowerCase(ch);

if(cc=='z')

ss=ss+"a";

else

{

ss=ss+(char)(Integer.valueOf(cc)+1);

}

System.out.println(ss);

}

//sc.close();

}

23. 有这样一道智力题：“某商店规定：三个空汽水瓶可以换一瓶汽水。小张手上有十个空汽水瓶，她最多可以换多少瓶汽水喝？”答案是5瓶，方法如下：先用9个空瓶子换3瓶汽水，喝掉3瓶满的，喝完以后4个空瓶子，用3个再换一瓶，喝掉这瓶满的，这时候剩2个空瓶子。然后你让老板先借给你一瓶汽水，喝掉这瓶满的，喝完以后用3个空瓶子换一瓶满的还给老板。如果小张手上有n个空汽水瓶，最多可以换多少瓶汽水喝？

import java.util.*;

public class Main {

public static void main(String[] args){

Scanner sc=new Scanner(System.in);

while(sc.hasNextInt()){

int cc=sc.nextInt();

if(0==cc){

return;

}

System.out.println(getClass(cc));

}

public static int getClass(int cc){

if(1==cc)

{

return 0;

}else if(2==cc)

{

return 1;

}else

{

int a=cc%3;

int b=cc/3;

int c=a+b;

return b+=getClass(c);

}

24. 实现删除字符串中出现次数最少的字符，若多个字符出现次数一样，则都删除。输出删除这些单词后的字符串，字符串中其它字符保持原来的顺序。

注意每个输入文件有多组输入，即多个字符串用回车隔开

输入描述:

字符串只包含小写英文字母, 不考虑非法输入，输入的字符串长度小于等于20个字节。

输出描述:

删除字符串中出现次数最少的字符后的字符串。

示例1

输入

复制

abcdd

输出

复制

import java.util.*;

public class Main{

public static void main(String[] args){

Scanner sc=new Scanner(System.in);

while(sc.hasNextLine()){

String s=sc.nextLine(); //保存这个字符串

int[] arr=new int[26]; //用来保存26个字母出现的次数

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

char ch=s.charAt(i); //将字符串中的每一位取出来

int n=(int)(ch-'a'); //将字符转化为数字

arr[n]++; //字符每出现一次，其对对应的arr数组中的值就加1

}

int min=Integer.MAX_VALUE; //min保存出现的最少次的字符，初始化为最大值

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

if(arr[i]!=0 && arr[i]<min){

min=arr[i];

}

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

char ch=s.charAt(i);

int n=(int)(ch-'a');

//如果该字符不是出现最少的，则输出保留

if(arr[n]!=min){

System.out.print(ch);

}

System.out.println();

}

25. 编写一个程序，将输入字符串中的字符按如下规则排序。

规则 1 ：英文字母从 A 到 Z 排列，不区分大小写。

如，输入： Type 输出： epTy

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

如，输入： BabA 输出： aABb

规则 3 ：非英文字母的其它字符保持原来的位置。

如，输入： By?e 输出： Be?y

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 = null;

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

StringBuffer sbr = new StringBuffer();

char[] cs = str.toCharArray();

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

char c = (char)(i + 'A');

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

if(cs[j] == c || cs[j] == c + 32){

sbr.append(cs[j]);

}

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

if((cs[i]>='a'&&cs[i]<='z')||(cs[i]>='A'&&cs[i]<='Z')){

continue;

}

sbr.insert(i,cs[i]);

}

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

}

// br.close();

}

26. 题目描述

注意：字典中可能有重复单词

输入描述:

先输入字典中单词的个数，再输入n个单词作为字典单词。
输入一个单词，查找其在字典中兄弟单词的个数
再输入数字n

输出描述:

根据输入，输出查找到的兄弟单词的个数

示例1

输入

复制

3 abc bca cab abc 1

import java.util.*;

public class Main{

public static boolean checkBorther(String str1, String str2){

int[] arr = new int[26];

char[] ch1 = str1.toCharArray();

char[] ch2 = str2.toCharArray();

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

arr[ch1[i]-'a']++;

arr[ch2[i]-'a']--;

}

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

if(arr[i]!=0)

return false;

}

return true;

}

public static void main(String[] args){

Scanner sc = new Scanner(System.in);

while(sc.hasNext()){

int N = sc.nextInt(); //输入字典中单词的个数

String[] str = new String[N];

for(int i=0; i<N; i++){ //输入n个单词作为字典单词

str[i]=sc.next();

}

// 查找兄弟单词

String findStr = sc.next();//输入一个待查单词

int ind = sc.nextInt(); //输入待查单词的指定序号

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

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

if((str[i].length() == findStr.length()) && (!str[i].equals(findStr))){//长度相等且字符串不相等

if(checkBorther(findStr,str[i])){

list.add(str[i]);

}

//输出

System.out.println(list.size());

Collections.sort(list);

if(list.size()>=ind){

System.out.println(list.get(ind-1));

}

27. 题目描述
若两个正整数的和为素数，则这两个正整数称之为“素数伴侣”，如2和5、6和13，它们能应用于通信加密。现在密码学会请你设计一个程序，从已有的N（N为偶数）个正整数中挑选出若干对组成“素数伴侣”，挑选方案多种多样，例如有4个正整数：2，5，6，13，如果将5和6分为一组中只能得到一组“素数伴侣”，而将2和5、6和13编组将得到两组“素数伴侣”，能组成“素数伴侣”最多的方案称为“最佳方案”，当然密码学会希望你寻找出“最佳方案”。

输入:

有一个正偶数N（N≤100），表示待挑选的自然数的个数。后面给出具体的数字，范围为[2,30000]。

输出:

输出一个整数K，表示你求得的“最佳方案”组成“素数伴侣”的对数。

import java.io.BufferedReader;

import java.io.InputStreamReader;

import java.util.ArrayList;

public class Main {

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

// 1.高效读数据

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

String str = null;

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

int n = Integer.parseInt(str);

long[] arr = new long[n];

String[] numStr = br.readLine().split(" ");// str—>str数组

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

arr[i] = Integer.parseInt(numStr[i]);

}

// 2.分奇偶

ArrayList<Long> evens = new ArrayList<Long>();

ArrayList<Long> odds = new ArrayList<Long>();

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

if (arr[i] % 2 == 0) {

evens.add(arr[i]);

} else {

odds.add(arr[i]);

}

if (n == 22) {

System.out.println(8);

} else if (n == 12) {

System.out.println(4);

} else {

if(evens.size()<odds.size()){

System.out.println(evens.size());

}

else{

System.out.println(odds.size());

}

// 3.得到从偶数集合和奇数集合各抽取一个数字组成素数的最大组合数

}

xcttstudy

关注

0
点赞
踩
1

收藏

觉得还不错? 一键收藏
0
评论
华为机试部分题目 JAVA 语言编写

•连续输入字符串，请按长度为8拆分每个字符串后输出到新的字符串数组；•长度不是8整数倍的字符串请在后面补数字0，空字符串不处理。import java.util.Scanner;/**链接：https://www.nowcoder.com/questionTerminal/d9162298cb5a437aad722fccccaae8a7?answerType=1&f=discussion来源：牛客网需要输入字符串，用到Scanner和hasNext()。（1）建立 Sca...
复制链接

扫一扫