华为机试部分题目 JAVA 语言编写
-
•连续输入字符串，请按长度为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
A
输出
1
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
输出
10
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
输入
5
输出
2
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
输出
OK
NG
NG
OK
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
输出
dd
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.得到从偶数集合和奇数集合各抽取一个数字组成素数的最大组合数
}
}
}