牛客网Java编程题总结

一定制一个模板

1 常用模板

import java.util.*;public class Main {public static void main(String[] args) {Scanner sc = new Scanner(System.in);while(sc.hasNext()){            // 注意，如果下面是nextInt，则这里必须是hasNextint num = sc.nextInt();......}}
}

2 常用模板

import java.util.*;public class Main {public static void main(String[] args) {Scanner input = new Scanner(System.in);// 下面这句一定要有while(input.hasNextLine()){          // 注意，如果下面是nextLine，则这里必须是hasNextLineString s=input.nextLine();       // 输入一个字符串......// lastIndexOf 表示" "在字符串中最后一次出现的下标System.out.println(s.length()-1-s.lastIndexOf(" "));}}
}

二变量字符串中的每一个字符常用语句

for(int i = 0;i < str.length();i++){ // 遍历字符串的每一个字符char ch = str.charAt(i); // 定位到每一个要比较的字符......
}

三大小写的转换

if(ch>='a'&&ch<='z'){             // 小写转大写，注意两者的间隔是是32temp = (char)((int)ch -32);
}

四 TreeSet具有排序和去重的功能

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); // 默认就是按照从小到大的顺序输出
}

五 substring的截取功能

// 输出s的前8位
System.out.println(s.substring(0, 8));
// 去掉s的前8位
s=s.substring(8)

六将十六进制转化为十进制核心代码

// ABCD = 10*pow(16,3)+11*pow(16,2)+12*pow(16,1)+10*pow(16,0)+
for(int i =0 ;i<s.length();i++)
{ch = s.charAt(i);if(ch>='0'&&ch<='9'){          // 0到9对应的整型值temp = ch-'0';}else if(ch>='A'&&ch<='Z'){    // A到Z对应的整型值temp = ch-'A'+10;}else if(ch>='a'&&ch<='z'){    // a到z对应的整型值temp = ch-'a'+10;}else{break;       // 非法跳出}n += temp*Math.pow(16,(s.length()-i-1));
}

七因式分解功能函数

//180 分解为  2 2 3 3 5
public static String getResult(long num){int pum = 2;    // 这里必须从2开始，先把所有为2的除尽，然后再把所有位3的除尽，依次类推String result = "";  // 记录分解后的质数while(num != 1){while(num%pum == 0){num = num/pum;                   // 得出下一次要分解的数result = result + pum + " ";     // 从小到大依次输出质数}pum++;}return result;
}

八 TreeMap是具有排序功能的Map

Map<Integer, Integer> map = new TreeMap<Integer, Integer>();
int n = sc.nextInt();   // 要合并的健值对个数
for (int i = 0; i < n; i++) {int s=sc.nextInt();     // 键int value=sc.nextInt();  // 值if (map.containsKey(s)) {        // map中已包含了这个键map.put(s, map.get(s) + value);      // 将该键的值类加} elsemap.put(s, value);         // 键值对加入到map中
}
for (Integer key : map.keySet()) {                // 默认按照键的升序排列，直接输出map的键值对System.out.println(key + " " + map.get(key));
}

九 String、StringBuffer、char常用函数以及相互转换的方法——提取不重复的整数

import java.util.Scanner;public class Main {public static void main(String[] args) {Scanner str = new Scanner(System.in);StringBuffer sb = new StringBuffer();sb.append(str.next());  // 静态字符串转动态字符串String st = sb.reverse().toString();  // StringBuffer的reverse很管用的char[] ch = st.toCharArray();    // 转字符数组String jud = "";     // 最终要得到的串for (int i = 0; i < ch.length ; i++){           // 遍历字符数组String s1 = String.valueOf(ch[i]);       // 将字符转字符串if(!jud.contains(s1)){       // 不包含字符才能加jud = jud + s1;}}System.out.println(Integer.parseInt(jud));}
}

十字符个数统计功能

public static int  getLen(String s) {int[] arr=new int[128];            // ASCII的字符表，对应为1或0,1表示字符串含有该字符，0，不含有该字符for(int i=0;i<s.length();i++){arr[s.charAt(i)]=1;            // s.charAt(i)表示对于的ASCII字符}int len=0;// 这里要注意，数组要用length，字符串要用length(),一个是有括号的，一个是没括号的for (int i = 0; i < arr.length; i++) {    // 这里length为128if(arr[i]==1){    // 为1，说明有该字符，就计数len++;}}return len;   // 这里的就是字符个数统计
}

十一数字颠倒功能

private static String reverse(int n){String str = String.valueOf(n);   // 将整数转化为字符串要用String.valueOf  将字符串转整数用  Integer.parseIntStringBuffer sb = new StringBuffer();    //可变长字符串一般用StringBufferfor(int i=str.length()-1;i>=0;i--){sb.append(str.charAt(i));          //倒序将字符加入到StringBuffer}return sb.toString();   // 注意这里要toString下
}

十二字符串反转功能

String s = in.nextLine();   // 输入字符串
char[] b = s.toCharArray();  // 字符串转字符数组
for (int i = b.length-1; i >= 0; i--) {   // 倒序输出System.out.print(b[i]);
}

十三句子逆序功能

public static String reverse(String str)
{String[] s=str.split(" ");            // 单词存到字符串数组StringBuffer sb=new StringBuffer();   // 缓存结果for(int i=s.length-1;i>0;i--)         // 逆序保存{sb.append(s[i]);sb.append(" ");}sb.append(s[0]);   // 最后一个要单独出来return sb.toString();   // 注意要toString
}

十四字符串按自然顺序排序

int num = Integer.parseInt(scan.nextLine());
for(int i=0;i<num;i++){list.add(scan.nextLine());   // 输入要排序的字符串
}Collections.sort(list);   // 对list集合元素按自然数升序排序
for(String str:list){          // 输出排序结果System.out.println(str);
}

十五求int型数据在内存中存储的1的个数

Scanner str = new Scanner(System.in);
int n = str.nextInt();   // 输入自然数
String se = Integer.toBinaryString(n);    // 自然数转二进制字符串，toBinaryString关键是这句
char[] ch = se.toCharArray();   // 继续转字符数组
int count = 0;
for(int i = 0;i<se.length();i++){       // 对一进行统计if(ch[i] == '1'){count++;}
}

十六子串重复，这里子串的长度大于等于2

private static String isHasSubString(String str) {/**  A B C D E F G    *   第1轮: ABC DEFG  看DEFG是否包含ABC*   第2轮：BCD EFG   看EFG是否包含BCD*   第3轮：CDE FG    看FG是否包含CDE*   第4轮：DEF G     看G是否包含DEF**/for (int i = 0; i < str.length() -3; i++) {String str1=str.substring(i,i+3);      // 前面3位子串String str2=str.substring(i+3);        // 后面的子串if(str2.contains(str1))                // 后面的子串包含前面的子串，就退出return "NG";}return "OK";
}

十七空瓶换汽水算法

import java.util.Scanner;
public class Main {public static void main(String[] args) {Scanner sc = new Scanner(System.in);while(sc.hasNext()){      // 循环输出int num = sc.nextInt();    // 输入空瓶if(num==0) break;      // 空瓶为0，程序结束int left = num;    // 剩余空瓶数int total = 0;     // 喝了多少瓶汽水while(left!=0){    // 只要剩余空瓶数不为0就可以换汽水if(left==2){       // 如果剩余空瓶数为2  可以多换一瓶，类加汽水数total+=1;break;}else if(left==1){    // 如果剩余空瓶数为1  ，不能换了break;}else{int curr = left/3;     // 剩余空瓶可以换的汽水数total+=curr;             // 累加汽水数left = left-curr*3+curr;    // 换完汽水，喝完汽水后，还剩的空瓶数，少了curr*3空瓶，但多出了curr}}System.out.println(total);}}
}

十八字符个数统计

import java.util.*;
public class Main{public static void main(String []args) {Scanner scan = new Scanner(System.in);String s = null;        // s代表要输入的字符串while(scan.hasNextLine()){s=scan.nextLine();int []count = new int[26];      // 对26个小写字母计数int min = Integer.MAX_VALUE;      // 最大的int值for(char c : s.toCharArray()){          // 遍历输入串，统计每个字符的个数，并算出最小字符的个数count[c - 'a']++;min = Math.min(min,count[c-'a']);}StringBuffer ret = new StringBuffer();    // 最终的串for(char c : s.toCharArray()){   // 遍历字符歘if(count[c - 'a'] != min){      // 过滤掉最小的字符ret.append(c);}}System.out.println(ret.toString());}}
}

十九字符串排序

str=scan.nextLine();
StringBuilder builder = new StringBuilder();   // 最终输出
for(int i=0;i<26;i++){                   // 外层循环遍历26个大写字母char c=(char)(i+'A');                // c定位到每一个大写字母for(int j=0;j<str.length();j++){     // 遍历输入的字符串char sc=str.charAt(j);if(c==sc||c==sc-32){             // 找到对应字母的大写字母和小写字母builder.append(sc);          // 遍历完1轮后，将对应的大写字母和小写字母输出到缓存}}
}
for(int i=0;i<str.length();i++){        // 遍历输入字符串char c=str.charAt(i);if(!(c>='a'&&c<='z')&&!(c>='A'&&c<='Z')){           //找到每一个非字母字符和它对应的下标builder.insert(i,c);                            // 在对应下标位置插入对应的非字母字符}
}
System.out.println(builder.toString());    // 最终输出变换后的串

二十操作集合的工具类Collections

Collections.sort(list); //将list集合按照自然排序，默认是生效
Collections.reverse(list); //将list集合元素反转

二十一判断兄弟单词算法

private static int check(String str, String s, char[] strChar) {   // 参考串cab     输入串bca     排完序的串abc（它是参考串cab排序后的结果）if (str.equals(s) || str.length() != s.length()) { //如果两个单词内容相同或长度不等，表明不是兄弟单词return 0;}char[] sChar = s.toCharArray();         // 将输入串转化为字符数组Arrays.sort(sChar);   //进行字典序排序return Arrays.equals(strChar, sChar) ? 1 : 0;  //比较排序后两个单词内容是否相等
}

二十二凯撒密码加密算法

private static String Encrypt(String line){char[] cha = line.toCharArray();             // 字符串数组化StringBuilder sb= new StringBuilder();       // 密文缓存for(int i=0;i<cha.length;i++){               // 遍历明文if (cha[i]>='a'&&cha[i]<='z'){           // 小写字母转大写if(cha[i]=='z'){sb.append('A');}else{sb.append((char)(cha[i]-32+1));  // 小写字母和大写字母相差32}}else if(cha[i]>='A'&&cha[i]<='Z'){      // 大写字母转小写if(cha[i]=='Z'){sb.append('a');}else{sb.append((char)(cha[i]+32+1));  // 小写字母和大写字母相差32}}else if(cha[i]>='0'&&cha[i]<='9'){      // 数字转化方法if(cha[i]=='9'){sb.append('0');}else{sb.append((char)(cha[i]+1));        // 注意：这里一定要进行强制类型转换}}else{sb.append(cha[i]);                    // 其他情况不变化}}return sb.toString();
}

二十三字符串和字符数组相关操作——实现字符串合并

说明：输入str1为"dec"，str2为"fab"，合并为“decfab”，分别对“dca”和“efb”进行排序，排序后为“abcedf”，转换后为“5D37BF”，a的二进制串是1010，它的反转是0101，也就是5

line=scan.nextLine();  //输入的字符串
String[] str=line.split(" ");   // 将输入的字符串转为为数字
String s=str[0]+str[1];      // 合并字符串
StringBuilder br1=new StringBuilder();    // 0,2,4 位置的缓存
StringBuilder br2=new StringBuilder();    // 1,3 5 位置的缓存
for(int i=0;i<s.length();i++) {           // 遍历缓存if(i%2==0) {br1.append(s.charAt(i));}else {br2.append(s.charAt(i));}
}
char[] ch1=br1.toString().toCharArray();   // 转字符数组
char[] ch2=br2.toString().toCharArray();   // 转字符数组
Arrays.sort(ch1);  // 排序
Arrays.sort(ch2);  // 排序
char[] ch=new char[ch1.length+ch2.length];    // 存新串
for(int i=0;i<ch.length;i++) {if(i%2==0) {ch[i]=ch1[i/2];   // 存 0,2,4 位置}else {ch[i]=ch2[i/2];   // 存1,3，5 位置}
}
char[] password = {'0','1','2','3','4','5','6','7','8','9','a','b','c','d','e','f','A','B','C','D','E','F'};
char[] dictionary = {'0','8','4','C','2','A','6','E','1','9','5','D','3','B','7','F','5','D','3','B','7','F'};
for(int i=0;i<ch.length;i++) {if((ch[i]>='0'&&ch[i]<='9')||(ch[i]>='a'&&ch[i]<='f')||(ch[i]>='A'&&ch[i]<='F')) {String temp = String.valueOf(password);    // 字符数组转字符串ch[i]=dictionary[temp.indexOf(ch[i])];     // 换后的值}
}
System.out.println(ch);

二十四清洗字符串

说明：

1、每个单词是以26个大写或小写英文字母构成；

2、非构成单词的字符均视为单词间隔符；

举例：fhdsj*fhdj 清洗后的结果是fhdsj fhdj

for (int i=0;i<line.length();i++){    //清洗原字符串char c=line.charAt(i);if ((c>='A'&&c<='Z')||(c>='a'&&c<='z')){str1.append(c);}else {str1.append(' ');}
}

二十五 IP点分十进制转十进制

public static void Change1(String str) {               // 点分十进制转十进制String[] data1 = str.split("\\.");     // 点分隔要转义data1[0] = Integer.toBinaryString(Integer.parseInt(data1[0]));data1[1] = Integer.toBinaryString(Integer.parseInt(data1[1]));data1[2] = Integer.toBinaryString(Integer.parseInt(data1[2]));data1[3] = Integer.toBinaryString(Integer.parseInt(data1[3]));// 转为标准的二进制串while(data1[0].length()<8) data1[0] = "0"+data1[0];while(data1[1].length()<8) data1[1] = "0"+data1[1];while(data1[2].length()<8) data1[2] = "0"+data1[2];while(data1[3].length()<8) data1[3] = "0"+data1[3];long sum = 0;// 采用的思想是左移为乘以2 ，然后加最低位，  依次类推for(int i=0;i<data1.length;i++) {     // 这里的长度为4for(int j=0;j<data1[0].length();j++) {     // 这里的长度为8sum = sum*2+(data1[i].charAt(j)-'0');    // 从左往右依次定位  10100010 10100010 10100010 10100010}}System.out.println(sum);   // 输出十进制
}

二十六十进制转IP点分十进制

public static void Change2(String str) {                  // 十进制转点分十进制long data2 = Long.parseLong(str);   // 字符串转数字String bindata2 = Long.toBinaryString(data2);   // 转二进制串String[] data = new String[4];// 10 01100010 10100010 10100010data[0] = bindata2.substring(0,bindata2.length()-3*8);       // 第一段data[1] = bindata2.substring(data[0].length(),data[0].length()+8);   // 第二段data[2] = bindata2.substring(data[0].length()+data[1].length(),data[0].length()+data[1].length()+8);  // 第三段data[3] = bindata2.substring(bindata2.length()-8,bindata2.length());  // 第4段System.out.print(Integer.valueOf(data[0],2)+".");   // 二进制转十进制System.out.print(Integer.valueOf(data[1],2)+".");System.out.print(Integer.valueOf(data[2],2)+".");System.out.println(Integer.valueOf(data[3],2));
}

二十七 Arrays排序应用

line = scan.nextLine();
char[] chs = line.toCharArray();   // 转字符数组
Arrays.sort(chs);         // 排序
System.out.println(chs);  // 输出

二十八蛇形矩阵算法和实现

/*
1 3 6 10 15
2 5 9 14
4 8 13
7 12
11
想找9，就先找到7，注意10、9、8、7在一条直线上
想找14，就先找11
也就是先找到斜线和第1列元素的值
* */
private static String getResult(int n){StringBuilder builder = new StringBuilder();// i代表行坐标，j代表列坐标，temp为[i,j]的值for(int i=1;i<=n;i++){//n-i+1为每行元素的个数for(int j=1;j<=n-i+1;j++){//[i,j]对应的第1列元素坐标是是[i+j-1,1],该坐标的值为1+1+2+ ...(i+j-1-1) = 1+(i+j-1)(i+j-2)/2//[i,j]对应的值1+(i+j-1)(i+j-2)/2+(j-1)int temp = 1+(i+j-1)*(i+j-2)/2+(j-1);builder.append(String.valueOf(temp)).append(" ");}builder.append("\n");//设置换行符// builder.setCharAt(builder.length()-1,'\n');}return builder.toString();
}

二十九统计每个月的兔子数

说明：有一只兔子，从出生后第3个月起每个月都生一只兔子，小兔子长到第三个月后每个月又生一只兔子，假如兔子都不死，问每个月的兔子总数为多少？

public static int getTotalCount(int monthCount)
{int a = 1;int b = 1;int c = 1;for(int i=2; i< monthCount; ++i) // 注意这里i的初始值是2，结束条件是i< monthCount{c = a + b;a = b;b = c;}return c;
}

三十名字漂亮度

说明：

给出一个名字，该名字有26个字符串组成，定义这个字符串的“漂亮度”是其所有字母“漂亮度”的总和。

每个字母都有一个“漂亮度”，范围在1到26之间。没有任何两个字母拥有相同的“漂亮度”。字母忽略大小写。

给出多个名字，计算每个名字最大可能的“漂亮度”。

public static int getBeauty(String name)   // 一个名字
{char[] chs = name.toLowerCase().toCharArray();    // 变成小写字符数组int[] target = new int[26];   // 用于记录每个字符出现的次数for(int i=0;i<chs.length;i++)    // 遍历名字target[chs[i] - 'a']++;Arrays.sort(target);    //排序int res = 0;for(int i=25;i>=0;i--)res += target[i] *(i+1);     //计算名字的漂亮度return res;
}

三十一按字节截取字符串

说明：

编写一个截取字符串的函数，输入为一个字符串和字节数，输出为按字节截取的字符串。但是要保证汉字不被截半个，如"我ABC"4，应该截为"我AB"，输入"我ABC汉DEF"6，应该输出为"我ABC"而不是"我ABC+汉的半个"。

str = scan.nextLine();
String[] tmp=str.split(" ");
String chars=tmp[0];                    // 字符串
int len=Integer.parseInt(tmp[1]);       // 截取的字符个数int count=0, i=0;
for (;i<chars.length();i++){char c=chars.charAt(i);if (c>='a'&&c<='z'||c>='A'&&c<='Z')count+=1;else count+=2;if (count>len) {             // 注意，这里是>号。如果有=号，还会再循环一次，i要多加一次break;}
}
System.out.println(chars.substring(0,i));

三十二输出单向链表中倒数第k个结点

// 下标 0     1       2       3       4       n-k     n-2     n-1     n
// 倒数 n     n-1     n-2     n-3     n-4     k       2       1       多申请一个
int n = sc.nextInt();
int[] arr = new int[n+1];    // 这里多申请一个内存，否则牛客网编译不过，IDEA不加一个测试没问题
for(int i = 0; i < n; i++){arr[i] = sc.nextInt();
}
int k = sc.nextInt();
//倒数的第k个，正数的是n-k+1，注意数组下标从0开始，因此是n-k
System.out.println(arr[n-k]);

三十三杨辉三角

/*1                                 第一行没有，输出为-11  1  1                              第二行没有，输出为-11  2  3  2  1                           奇数行，是2个数1  3  6  7  6  3  1                        4的倍数的偶数是第3个1  4  10 16 19 16 10  4  1                    奇数行，是2个数
1   5  15 20 45 51 45 30  15 5  1                 非4的倍数的偶数是第4个
*/
int n = in.nextInt();           // 输入的行号
// 如果n小于等于2，则没有偶数，为-1
if(n<=2)System.out.println(-1);// 如果是奇数行，则是第2个数
else if(n%2==1){System.out.println(2);
}else{// 如果是偶数行，且能被4整除，则是第3个数if(n%4==0)System.out.println(3);// 如果是偶数行，但不能被4整除，则是第4个数elseSystem.out.println(4);
}

三十四判断一个数是否是完全数

说明：

完全数（Perfect number），又称完美数或完备数，是一些特殊的自然数。

它所有的真因子（即除了自身以外的约数）的和（即因子函数），恰好等于它本身。

例如：28，它有约数1、2、4、7、14、28，除去它本身28外，其余5个数相加，1+2+4+7+14=28。

给定函数count(int n),用于计算n以内(含n)完全数的个数。计算范围, 0 < n <= 500000

返回n以内完全数的个数。异常情况返回-1

private static boolean isPerfect(int src){int sum = 1;  // 注意1要加进来，sum是满足条件的约数// 注意这里的条件i*ifor(int i =2;i*i<=src;i++){     //注意这里从2开始，另外质数的判断条件是i*i<=srcif(src%i==0){   // 必须能除断sum +=i;        // 加第1约数sum+=src/i;     // 加第2个约数}}if(sum==src){return true;}return false;
}

三十五大数相加

String str=scan.nextLine();
BigInteger a = new BigInteger(str.trim());   // 读入第一个大数
BigInteger b = new BigInteger(scan.nextLine().trim());     // 读入第二个大数
System.out.println(a.add(b).toString());          // 两个大数的相加还是大数

三十六输入n个数，输出其中最小的k个

StringBuffer sb = new StringBuffer();   // 一般放到StringBuffer中输出，不然会报错
Arrays.sort(num);    // 从小到大的排序
for(int j=0;j<k-1;j++){sb.append(num[j]+ " ");    // 先加前k-1个数
}
sb.append(num[k-1]);    // 再加最后一个数
System.out.println(sb.toString());

三十七找出字符串中第一个只出现一次的字符

String str;
while(scan.hasNextLine()) {str = scan.nextLine();char[] c = str.toCharArray();            //转数组int num[] = new int[128];                //用于计数每个字符for(int i = 0;i<str.length();i++){       // 对某个字符计数num[str.charAt(i)]++;}for(int i = 0;i<c.length;i++){       // 遍历字符数组if(num[c[i]]==1){                 //如果该字符只出现一次，打印该字符，并跳出System.out.println(c[i]);break;}if(i==(c.length-1))System.out.println(-1);       //如果找不到就打印-1}
}

三十八判断一个数是否是素数

private static boolean issushu(int num){      // 为素数就返回true，否则返回falsefor(int i=2;i<num;i++){           //2 到num-1 看是否能除尽，能除尽就是素数if(num%i==0){return false;}}return true;
}

三十九查找输入整数二进制中1的个数

public   static   int  findNumberOf1( int num){String binaryString = Integer.toBinaryString(num);   // 将一个整数转为二进制字符串int count = 0;for(int i=0;i<binaryString.length();i++){if(binaryString.substring(i,i+1).equals("1")){   // 依次判断串的每一位是否为1count++;}}return count;
}

四十查找两个字符串a,b中最长公共子串

// 第一个参数是短串，第二个参数是长串
/*
abcd   length = 4  abcd  abc bcd  ab bc cd a b c d  就是这样去找短串的子串
abcde
*/
private static String findLongStr(String shortStr,String longStr) {int length = shortStr.length();   // 短串长度String subShortStr;    //短串的子串// 第1轮  ，长度为length的短串，循环1次// 第2轮  ，长度为length-1的短串，循环2次// 第i轮  ，长度为length-i+1的短串，循环i次// 第length轮，长度为1的短串，循环length次for(int i=1;i<=length;i++){  // 所以，外层循环从1开始，循环length次for(int j=0;j<=i-1;j++){   // 所以，内层循环从0开始，循环i次  ，其中j代表短子串首字符的位置subShortStr = shortStr.substring(j,j+(length-i+1));if(longStr.contains(subShortStr)){return subShortStr;}}}return "";
}

四十一插入排序

//获取要排序的人的个数
int count = Integer.parseInt(str);
//获取输入的排序方法(升序还是降序) 0是降序 1是升序
int sortType = Integer.parseInt(scan.nextLine());
String[] users = new String[count];   // 姓名
int[] scores = new int[count];        // 分数
for(int i=0;i<count;i++){     // i代表插入前的数组，下标分别是[0,1,2,...  i-1]String line = scan.nextLine();    //姓名 分数String[] parts = line.split(" "); //[姓名,分数]String user = parts[0];                       // 姓名int score = Integer.parseInt(parts[1]);       // 分数// 插入排序的思想，一个个插入if(sortType==0){          // 降序int j = 0;for(j=i-1;j>=0;j--){if(scores[j]<score){            // 降序和升序就这里不一样scores[j+1] = scores[j];users[j+1] = users[j];}else{break;}}scores[j+1] = score;users[j+1] = user;}else{int j = 0;for(j=i-1;j>=0;j--){       // 下标分别是[0,1,2,...  i-1]  插入前，从后往前比较，j代表比较下标if(scores[j]>score){scores[j+1] = scores[j];users[j+1] = users[j];}else{   // 插入的数就是最大，不用比较了，直接跳出break;}}scores[j+1] = score;  // 这里的j加1，是因为循环跳出时，减去了1users[j+1] = user;}
}
for(int i=0;i<count;i++){System.out.println(users[i]+" "+scores[i]);
}

四十二字符串通配

public static boolean isMatch(String str1,String str2) {// sta1 = te?t*.*// replaceAll第一个是正则表达，第二个是正则表达是被替换的串str1=str1.replaceAll("\\?", "[0-9a-zA-Z]"); // 匹配一个字符str1=str1.replaceAll("\\*","[0-9a-zA-Z]*"); // 匹配0个或1个字符// 运行到这里  str1 = te[0-9a-zA-Z]t[0-9a-zA-Z]*.[0-9a-zA-Z]*// matches 参数是正则表达式if(str2.matches(str1))  return true;return false;
}

四十三百钱买百鸡

/*
x:公鸡
y：母鸡
100-x-y为小鸡
y=25-7x/4
*/
int y = 0;
for (int x = 0; ; x = x + 4) {int[] list = new int[3];   //分别放公鸡，母鸡，小鸡y = 25 - 7 * x / 4;list[0] = x;list[1] = y;list[2] = 100 - x - y;if (list[2] < 0 || list[1] < 0) {         // 母鸡和小鸡任何一个小于0，就跳出break;} else {System.out.println(list[0] + " " + list[1] + " " + list[2]);   // 输出各种情况}
}

四十四日期到天数的转换

public static int getAllDay(int year,int month,int day) {int[] dayary= {31,28,31,30,31,30,31,31,30,31,30,31};//判断闰年if(year%4==0) dayary[1]=29;int total=0;for(int i=0;i<month-1;i++) {total+=dayary[i];             // 1到month-1月的天数}total+=day;                       // month月的天数return total;
}

四十五求公共串的最大长度

// 第一个参数是短串，第二个参数是长串
/*
abcd   length = 4  abcd  abc bcd  ab bc cd a b c d  就是这样去找短串的子串
abcde
*/
private static int findLongStr(String shortStr,String longStr) {int length = shortStr.length();   // 短串长度String subShortStr;    //短串的子串// 第1轮  ，长度为length的短串，循环1次// 第2轮  ，长度为length-1的短串，循环2次// 第i轮  ，长度为length-i+1的短串，循环i次// 第length轮，长度为1的短串，循环length次for(int i=1;i<=length;i++){  // 所以，外层循环从1开始，循环length次for(int j=0;j<=i-1;j++){   // 所以，内层循环从0开始，循环i次  ，其中j代表短子串首字符的位置subShortStr = shortStr.substring(j,j+(length-i+1));if(longStr.contains(subShortStr)){return subShortStr.length();}}}return 0;
}

四十六尼克彻斯定理

说明：

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

例如：

1^3=1

2^3=3+5

3^3=7+9+11

4^3=13+15+17+19

/*
m 代表第一个奇数，
m   m+2             m+2(n-1)         =     n*n*n
m = n*n-n+1
* */
public static void GetSequeOddNum(int n){int temp = 0;// 经过数学计算，第1个奇数为n*n-n+1StringBuffer br = new StringBuffer();int m = n*n-n+1;for(int i = 0;i<n-1;i++){temp = m+2*i;br.append(temp).append("+");   // 注意，这里要用StringBuffer，否则通不过}br.append(temp+2);System.out.println(br.toString());
}

四十七整型数组合并

while(scan.hasNextInt()){TreeSet<Integer> list = new TreeSet<Integer>();  // 这句必须放在while循环内，否则运行错误StringBuffer sb= new StringBuffer();            // 这句必须放在while循环内，否则运行错误int n1 = scan.nextInt();   // 第一个数的个数for(int i=0;i<n1;i++){int curr = scan.nextInt();     // 第一组数list.add(curr);}int n2 = scan.nextInt();     //第二个数的个数for(int i=0;i<n2;i++){int curr = scan.nextInt();     // 第二组数list.add(curr);}for(Integer c:list){sb.append(c);           // 一定要用StringBuffer，否则编译不过}System.out.println(sb);
}

四十八长字符串包含短字符串的全部字符

public static void allshow(String strShort,String strLong){int count = 0;for(int i = 0;i<strShort.length();i++){if(strLong.contains(String.valueOf(strShort.charAt(i)))){count++;    // 长的包含短的就计数}}if(count == strShort.length()){       // count 等于 短的长度，就是全部包含System.out.println("true");}else{System.out.println("false");}
}

四十九统计大写字母

public static int CalcCapital(String line){int num =0 ;for(int i=0;i<line.length();i++){char ch = line.charAt(i);if(ch>='A'&&ch<='Z'){         // 大写字母统计num++;}}return num;
}

五十求最大连续bit数

int max = 0;
int temp = 0;String num = Integer.toBinaryString(Integer.parseInt(scan.nextLine()));
char[] ch = num.toCharArray();
for(int i=0;i<ch.length;i++){if(ch[i] == '1'){temp ++;   // 记录连续为1的个数max = Math.max(max,temp);}else{temp = 0;}
}
System.out.println(max);

五十一判断合法IP

String[] str=scan.nextLine().split("\\.");
int count = 0;   // 对点分十进制进行计数
try{for(int i=0;i<4;i++){int num = Integer.parseInt(str[i]);if((num>=0)&&(num<=255)){count++;}}
}catch(Exception e){System.out.println("NO");return;
}
if(count ==4){System.out.println("YES");     // 只有count =4 才说明它是合法IP
}else{System.out.println("NO");
}

五十二在字符串中找到最大的数字串

for(int i=0; i<str.length(); i++){char c = str.charAt(i); //从0开始if(c >= '0' && c <= '9'){if(temp == 0){temp = 1;       //1代表数字串标志，当数字串在字符串尾巴的情况，要用到这个标志}tstr += c;      // 最长串临时变量cnt++;          // 计数continue; //直接continue}else{  //遇到第一个非数字字符重置相关的中间变量if(cnt >= max){if(cnt > max){       //大于的情况max = cnt;      //目前的最大数字串res = tstr;}else{                // 相等的情况，要累加res += tstr;}}temp = 0;           // 最后要清零cnt = 0;tstr = "";}
}

五十三投票

说明：

4 4个被投票人

A B C D

8 8个投票人

A B C D E F G H

A : 1

B : 1

C : 1

D : 1

Invalid : 4

// 被投票人
int n = Integer.parseInt(scan.nextLine());
String[] nstr = scan.nextLine().split(" ");
int[] count = new int[n];
int valid = 0;// 投票人
int m = Integer.parseInt(scan.nextLine());
String[] mstr = scan.nextLine().split(" ");// 外层：遍历投票人  内层：遍历被投票人
for(int i=0;i<m;i++){for(int j=0;j<n;j++){if(mstr[i].equals(nstr[j])){count[j]++;   // 被投票人被投中valid++;  // 有效票break;}}
}for(int j=0;j<n;j++){System.out.println(nstr[j]+" : "+count[j]);
}
System.out.println("Invalid : "+(m-valid));

五十四数字前后加*

说明：

Jkdi234klowe90a3

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

String str = scan.nextLine();
StringBuffer sb = new StringBuffer();   // 输出串
StringBuffer sb1 = new StringBuffer();  // 代表临时要加的串
boolean isdigit = false;char[] ch = str.toCharArray();
// 遍历字符数组
for(int i=0;i<ch.length;i++){// 处理数字的情况if((ch[i]>='0')&&(ch[i]<='9')){isdigit = true;sb1.append(ch[i]);if(((i+1)<ch.length)&&(ch[i+1]>='0')&&(ch[i+1]<='9')){continue;}}else{  // 处理非数字的情况isdigit = false;sb1.append(ch[i]);}if(true == isdigit){   // 将数字加到临时串中sb.append("*");sb.append(sb1.toString());sb.append("*");}else{sb.append(sb1.toString());  // 将非数字加到临时串中}// 当加完数字或加完非数字，要清空临时串sb1.setLength(0);
}
System.out.println(sb.toString());

五十五格式化字符串输出

System.out.printf("%d %.1f\n",count,sum/count1);    // C语言格式输出，注意1位小数的写法

五十六自守数

说明：

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

// 求0到n之间的自守数
for(int i=0;i<=n;i++){m = i*i;strM = String.valueOf(m);  // 该自然数平方对应的字符串strMstrI = String.valueOf(i);  // 该自然数对应的字符串strI// strM的尾巴是否包含字符串strI，如果包含就说明该自然数是自守数，进行计数if(strM.substring(strM.length()-strI.length()).equals(strI)){count++;}
}
System.out.println(count);

五十七 Arrays排序——整数的升序和降序

String strCount = scan.nextLine();
// count个数进行排序
int count = Integer.parseInt(strCount);
// 输入count个字符串
String[] num = scan.nextLine().split(" ");
StringBuffer sb=new StringBuffer();
int[] inum= new int[count];
// 将字符串转为数字
for(int i = 0;i<count;i++){inum[i] = Integer.parseInt(num[i]);
}
// 0 是升序 1 是降序
int sorttype = Integer.parseInt(scan.nextLine());
Arrays.sort(inum); // 默认是升序
if(0 == sorttype){  // 升序排序int i=0;for(i = 0;i<count-1;i++){sb.append(inum[i]+" ");}sb.append(inum[count-1]);
}else if(1 == sorttype)  // 降序排序
{int i=0;for(i = count -1;i>0;i--){sb.append(inum[i]+" ");}sb.append(inum[0]);
}
System.out.println(sb.toString());

五十八字符个数统计输出

private static String fun(String str) {char[] chs=str.toCharArray();   // 转数组int[] num=new int[200];     //必须大于128for (char c : chs) {         // 统计每个字符的个数，保存到num中int i=(int)c;num[i]++;}int max=0;// 找到统计最大字符for(int i=0;i<num.length;i++){if(max<num[i]){max=num[i];}}StringBuffer sb=new StringBuffer();while(max!=0){// 遍历统计数组，先看有没有max个的字符，再看有没有max-1个的字符，依次找到各个字符for(int i=0;i<num.length;i++){if(max==num[i]){sb.append((char)i);}}max--;}return sb.toString();
}

五十九字符串安装8位输出——不足8位的补0

// 要输入字符串的个数
int count = Integer.parseInt(in.nextLine());
for (int i = 0; i < count; i++) {// 读入一个字符串String input = in.nextLine();// 字符串不能为空if (input == null || input.length() == 0) {continue;}// 去掉字符串两边的空格StringBuilder sb = new StringBuilder(input.trim());// 当字符串中字符的个数不是8个倍数，需要加零的个数if (sb.length() % 8 != 0) {int more = 8 - sb.length() % 8;for (int j = 0; j < more; j++) {sb.append("0");}}// 每一行输出8个字符for (int j = 0; j < sb.length(); j += 8) {System.out.println(sb.substring(j, j + 8));}
}

六十格式化输出

// 小数保留一位
System.out.format("%.1f",sum/count1);

六十一字符逆序

String str =  scan.nextLine();
// 将字符串转换为字符数组
char[] ch = str.toCharArray();
// 将数组逆序输出
for(int i=ch.length-1;i>=0;i--){System.out.print(ch[i]);
}

六十二求最小公倍数

int num1 = scan.nextInt();
int num2 = scan.nextInt();
// 先求得两个数中大的一个数
int temp = Math.max(num1,num2);
// 然后依次递增该数，如果该数可以同时整除这两个数，则说明该数是最小公倍数
do{if((temp%num1==0)&&(temp%num2==0)){System.out.println(temp);break;}temp++;
}
while(true);

六十三单选多选填空

https://gitee.com/cakin24/exam

牛客网Java编程题总结相关推荐

牛客网java编程题小猫钓鱼,纸牌
在这篇文章中,我将重新创造卡牌游戏<炉石传说>卡组制作工具的卡牌排名算法什么是<炉石传说> 炉石传说-一个虚拟纸牌游戏对于那些不知道的人来说,<炉石传说>是一款 ...
牛客网java编程题库
1. 前言最近面试了几家公司,体验了一下电话面试和今年刚火起来的视频面试, 虽然之前就有一些公司会先通过电话面试的形式先评估下候选人的能力水平,但好像不多,至少我以前的面试形式100%都是现场面试. ...
java正则题_牛客网java编程题整理（不定期更新）
文章目录 190516 - 调整数组顺序使奇数位于偶数前面题目我的代码高赞代码(via:海天一色) 190517 - 链表中倒数第k个结点题目我的代码高赞代码(via:渡不过己) 1905 ...
牛客网Java刷题知识点之关键字static、static成员变量、static成员方法、static代码块和static内部类...
不多说,直接上干货! 牛客网Java刷题知识点之关键字static static代表着什么在Java中并不存在全局变量的概念,但是我们可以通过static来实现一个"伪全局"的概 ...
牛客网Java刷题知识点之构造函数可以调用一般函数，但是一般函数不可以直接调用构造函数...
不多说,直接上干货! 通过牛客网Java刷题知识点之构造函数是什么.一般函数和构造函数什么区别呢.构造函数的重载.构造函数的内存图解我们对构造函数有了一个比较清楚的认识,当我们在创建对象时,我们会 ...
牛客网Java刷题知识点之Java 集合框架的构成、集合框架中的迭代器Iterator、集合框架中的集合接口Collection（List和Set）、集合框架中的Map集合...
不多说,直接上干货! 集合框架中包含了大量集合接口.这些接口的实现类和操作它们的算法. 集合容器因为内部的数据结构不同,有多种具体容器. 不断的向上抽取,就形成了集合框架. Map是一次添加一对元素. ...
牛客网Java刷题知识点之ArrayList 、LinkedList 、Vector 的底层实现和区别
不多说,直接上干货! 这篇我是从整体出发去写的. 牛客网Java刷题知识点之Java 集合框架的构成.集合框架中的迭代器Iterator.集合框架中的集合接口Collection(List和Set). ...
【百日冲大厂】第十篇,牛客网选择题+编程题井字棋+密码强度等级
前言: 大家好,我是良辰丫,刷题的第十篇,牛客网选择题+编程题井字棋+密码强度等级.
牛客网java刷题笔记2019-1-4
牛客网java刷题笔记 2019-1-4 1.java中可以用类中构造器调用其他类构造器(这个和C++中构造函数很类似)用于初始化程序变量值, 构造器和方法的区别: 功能和作用的不同构造器是为了创建 ...

牛客网Java编程题总结

牛客网Java编程题总结相关推荐

最新文章

热门文章