华为牛客笔试题

华为牛客笔试题
先来了解时间和空间复杂度。

时间复杂度：
一般情况下，算法中基本操作重复的次数就是问题规模n的某个函数f（n），进而分析f（n）随n的变化情况并确定T（n）的数量级。这里用‘o’来表示数量级，给出算法时间复杂度。
T（n）=o（f（n））；
它表示随问题规模n的增大，算法的执行时间增长率和f（n）增长率成正比，这称作算法的渐进时间复杂度。而我们一般情况下讨论的最坏的时间复杂度。
空间复杂度：
算法的空间复杂度并不是实际占用的空间，而是计算整个算法空间辅助空间单元的个数，与问题的规模没有关系。算法的空间复杂度S（n）定义为该算法所耗费空间的数量级。
S（n）=o（f（n））
若算法执行所需要的辅助空间相对于输入数据n而言是一个常数，则称这个算法空间复杂度辅助空间为o（1）；
递归算法空间复杂度：递归深度n*每次递归所要的辅助空间，如果每次递归所需要的辅助空间为常数，则递归空间复杂度o（n）。

递归算法空间复杂度：O(n32n)。

1.贪吃蛇

贪吃蛇的问题—相对比较难。现在有一个N*M(N，M=100)的方形矩形，在这个矩形的每一个方格上都放有一个随机值，一条可爱的小蛇从矩形的左上角开始出发，每次移动都只能移动一格，向右或向下，而每到达一格贪吃的小蛇都会吧该位置上的值吃个一干二净，直到到达右下角时停止。而贪吃的小蛇不怕撑死，它只想吃到最多，并输出路径。
```
#include <iostream>
#include<string>
#include <cstring>
#include<vector>
#include<sstream>
#include<algorithm>
#include <stdlib.h>
#include <stdio.h>
#include<stack>
#include<ctime>
using namespace std;

stack<int> st;
int value[100][100],best[100][100],n,m;
//value里面存储每个格子的值
//best 存储走到当前格子的最大值
//m,n为格子大小100*100

void initvalue()
{
    for(int i=0;i<m;i++)
        for(int j=1;j<n;j++)
    {
        srand(unsigned(time(NULL)));
        value[i][j]=(rand()%(1000-1+1))+1;//[a,b]
    }
    value[0][0]=0;

}

int searchmaxvalue()
{
    best[0][0]=0;
    for(int i=1;i<m;i++)
    {
        best[i][0]=value[i][0]+best[i-1][0];
    }
    for(int j=1;j<n;j++)
    {
        best[0][j]+=value[0][j]+best[0][j-1];
    }
    for(int i=1;i<m;i++)
        for(int j=1;j<n;j++)
    {
        best[i][j]=value[i][j]+max(best[i-1][j],best[i][j-1]);
    }
    return best[m-1][n-1];


}

void Pu(int n, int m) {
        st.push(n);
        st.push(m);
        if (n == 0 && m == 0)
            return;
        else if (n == 0 && m > 0)
            Pu(n, m-1);
        else if (n > 0 && m == 0)
            Pu(n-1, m);
        else {
            if (best[n-1][m] > best[n][m-1])
                Pu(n-1, m);
            else
                Pu(n, m-1);
        }
}
void print()
{
    Pu(99,99);
    while(!st.empty())
    {
        cout<<st.top()<<"__";
        st.pop();
        cout<<st.top();
        st.pop();
        cout<<endl;

    }
}


int main()
{

  m=100;
   n=100;
   initvalue();
   int bestvalue=searchmaxvalue();

   cout<<bestvalue;
   print();
   //先初始化价值矩阵之后，计算最大价值矩阵，然后输出路径

}

2. 方阵求和不一致问题
```
#include <stdio.h>

int main(){
int n=3,i,j;
int a[3][3];
int row[3] = {0};
int list[3] = {0};
int main_cross_line = 0;
int slave_cross_line = 0;
int array[10]={0};

for(i=0; i<n; i++){
for(j=0; j<n; j++){
scanf("%d", a[i][j]);
}
}

for(i=0; i<n; i++){
for(j=0; j<n; j++){
row[i] += a[i][j];
list[i] += a[j][i];
}
}

for(i=0; i<n; i++){
main_cross_line += a[i][i];
slave_cross_line += a[i][n-1-i];
}

array[0] = main_cross_line;
array[1] = slave_cross_line;
for(i=2; i<8; i++){
if(i < (3+2))
{
array[i] = row[i-2];
} else{
array[i] = list[i-2-3];
}
}

for(i=0; i<8; i++){
if(array[i] != array[i+1])
{
if(array[i] != array[i+2])
{
return array[i];
}else{
return array[i+1];
}
}
}

}

3. 特定和的子序列

给出一个数组和一个固定SUM，求出连续元素和为sum。例如：[1,2,3,4,5,6,7,8] sum = 10输出是1 2 3 4；sum= 15 输出是1 2 3 4 5；4 5 6；7 8。

public class Main {
public static void main(String[] args) {
int[] num = {1, 2, 2, 3, 4, 5, 6, 7, 8, 9};
int sum = 8;
findSum(num, sum);
}

public static void findSum(int[] num,int sum){
int left=0;
int right=0;
for(int i=0;i<num.length;i++){
int curSum = 0;
left = i;
right = i;
while(curSum<sum){
curSum += num[right++];
}
if(curSum==sum){
for(int j=left;j<right;j++){
System.out.print(num[j]+" ");
}
System.out.println();
}
}
}
}

4. 勾股定理

int main()
{
int a,b,c;
for(a=1;a<=100;a++)
for(b=1;b<=100;b++)
for(c=1;c<=100;c++)
{
if(a*a+b*b==c*c)
printf("%d,%d,%d ",a,b,c);
}
getchar();
}

5、小兔子繁殖

小兔子每三个月可以长大，长大后可以每月生一个，到达N天时有几只兔子

例如4天，有2只，5天有3只，。。。7天有6只。

import java.util.Scanner;

public class Main {

   public static void main(String[] args) {
       Scanner sc = new Scanner(System.in);
       System.out.print("请输入第几个月:");
       int month = sc.nextInt();
       System.out.println("第" + month + "个月，兔子的总数为:" + fun(month));
   }
   private static int fun(int month) {
       if((1 == month)||(2 == month))
           return 1;
       else
           return (fun(month-1) + fun(month-2));
   }
}

7. 字串查找，正则模糊匹配，输出找到字串的位置。

给出一个字符串，给出一个正则白表达式子串，找出可以找到子串的第一个位置。

例如:字符串asdfas，子串是d[sf]，（[]表示里边任意一个元素），输出为3，因为ds或df去匹配字符串，找到df输出位置为3。

import java.util.regex.Matcher;
import java.util.regex.Pattern;

public class Main
{
private static final String REGEX = "d[sf]";
private static final String INPUT = "asdfas";

public static void main( String args[] ){
Pattern p = Pattern.compile(REGEX);
Matcher m = p.matcher(INPUT); // 获取 matcher 对象
int count = 0;

while(m.find()) {
count++;
//System.out.println("Match number "+count);
System.out.println(/*"start(): "*/m.start()+1);
//System.out.println("end(): "+m.end());
}
}
}

8.找出比自己大的数

给一个数组，收尾相连，按照顺序找到比自己大的第一个数，找不到的存-1。

例如[35,25,48,37] ->输出[48,48,-1,48]

import java.util.Stack;

public class Main {
   public static void main(String[] args){
       int[] arr = {13,7,6,12};
       int[] res = get(arr);
       for(int ele:res){
           System.out.print(ele+" ");
       }

   }

   public static int[] get(int[] arr){
       int[] max=new int[arr.length];
       Stack<Integer> stack = new Stack<Integer>();
       stack.push(0);
       for(int i=1;i<arr.length;i++){
           int top = stack.peek();
           while (!stack.isEmpty() && arr[i]>arr[top]) {
               max[top]=arr[i];
               stack.pop();
               if (!stack.isEmpty()) {
                   top = stack.peek();
               }
           }
           stack.push(i);
       }
       while (!stack.isEmpty()) {
           int top = stack.pop();
           max[top]=-1;
       }
       return max;
   }
}

9、输出制定字母在字符串的中的索引

给定一个字符串，把字符串按照大写在前小写在后排序，输出排好后的第K个字母在原来字符串的索引。相同字母输出第一个出现的位置。

例如：输入hAkDAjByBq 4 输出 6 说明：排好序后AABBDhjkqy，第4个是B，第一个出现的在原字符串6这个位置。（索引是从0开始）

public class Main {
/*
* @param chars: The letter array you should sort by Case
* @return: nothing
*/
public static void main(String[] chars) {
char letter;
int mIndex;
String characters = "djndAFDAKDdahdawq";
char[] temp = characters.toCharArray();
letter = sortAndFindLetter(temp);
mIndex = characters.indexOf(letter);
System.out.println(letter + ":" + mIndex);
}

private static char sortAndFindLetter(char[] chars) {
// 借用大写字母的ASCII码表十进制小于小写字母，然后利用冒泡排序的思路一步解决。
int i=0, index = 4;
int j=chars.length-1;
char letter;
while(i<j){
if(chars[i]>'Z'){
char temp=chars[i];
chars[i]=chars[j];
chars[j]=temp;
j--;
}
else i++;
}
System.out.println(chars);
return letter = chars[index];
}
}

10、匹配子字符串的个数

给出一个母串，一个子串，母串中包含空格。计算出子串在母串中出现的次数。

例如: 母串：Akk bhah ahb bd，子串ha，输出是2

#include<stdio.h>

int fun(char *str,char *substr);
int main()
{
char str[81]="asd asasd fgasdas zx67asdmkl";
char substr[4]="asd";
int n;
n=fun(str,substr);
printf("%d ",n);
return 0;
}

int fun(char *str, char *substr)
{
int n = 0;
char *p, *q;

while (*str)
{
p = str;
q = substr;
while (*q)
{
if (*p == *q)
{
++p;
++q;
}
else
{
break;
}

}
if ('' == *q)
{
++n;
}
++str;
}
return n;
}

11.求解特定以元音字母开头和结尾的子串长度 --比较难

给定一个字符串，找出元音字母开头和结尾的字符串，并且满足包含非元音字母个数为n，输出这个子串的长度，不满足的输出0；

例如adfei n= 2 输出为5，本身这个串就是元音开头和结尾，并且df非元音，满足2个个数。

import java.util.HashMap;
import java.util.TreeSet;
import java.util.Scanner;
import java.util.TreeSet;

public class Main {
public static void main(String[] args) {
String string=null;//output:aab,ab
int fucount=0;
Boolean flag = false;

Scanner in = new Scanner(System.in);
string = in.nextLine();
fucount = in.nextInt();
TreeSet<Character> allChars=new TreeSet<>();
for (int i = 97; i < 123; i++) {
allChars.add((char)i);
}
//System.out.println(allChars);

TreeSet<Character> fuChars=allChars;
fuChars.remove('a');
fuChars.remove('o');
fuChars.remove('e');
fuChars.remove('i');
fuChars.remove('u');
//System.out.println(fuChars);

TreeSet<Character> yuanChars=new TreeSet<>();
yuanChars.add('a');
yuanChars.add('o');
yuanChars.add('e');
yuanChars.add('i');
yuanChars.add('u');
//System.out.println(yuanChars);
// 截止目前，fuChars存放輔音字符；yuanChars存放元音字母

HashMap<Integer, String> result=new HashMap<>();

for (int i = 0; i < string.length(); i++) {
char temp=string.charAt(i);

//如果不以元音字母開頭，直接退出
if(!yuanChars.contains(temp)){
continue;
}

//辅音字母开头
for (int j = i+1; j < string.length(); j++) {
char point=string.charAt(j);
if (!yuanChars.contains(point)) {
continue;
}
else {
String subStr=string.substring(i, j+1);//因为包括i；不包括j+1

result.put(result.size(), subStr);
//System.out.println(subStr);
}
}
}

if (result.size()!=0) {
//System.out.println(result.get(0));
//System.out.println(result.get(result.size()-1));
for(int m=0; m<result.size(); m++){
if(result.get(m).length() == (fucount +2)){
System.out.println(fucount + 2);
flag = true;
break;
}
}
}
if(!flag)
System.out.println(0);

}
}

12. 全排列

求出排列的指定排序的序列

例如由前k个数组成的排列中的第n个排列

例如k= 4，n =4 输出1342 说明1234 1243 1324 1342 1423 …

import java.util.HashMap;
import java.util.TreeSet;
import java.util.Scanner;
import java.util.List;
import java.util.ArrayList;

public class Main {
public static void main(String[] args) {
int n,k;
String string;
Scanner in = new Scanner(System.in);
n = in.nextInt();
k = in.nextInt();
string = getPermutation(n,k);
System.out.println(string);
}

public static String getPermutation(int n, int k) {
List<Integer> list = new ArrayList<>();
for(int i = 1; i <= n; i++) list.add(i);
int[] fact = new int[n]; // factori
fact[0] = 1;
for(int i = 1; i < n; i++) fact[i] = i * fact[i - 1];
k = k - 1;
StringBuilder sb = new StringBuilder();
for(int i = n; i > 0; i--){
int ind = k / fact[i - 1];
k = k % fact[i - 1];
sb.append(list.get(ind));
list.remove(ind);
}
return sb.toString();
}

}

13. 求子矩阵的最大和

import java.util.HashMap;
import java.util.TreeSet;
import java.util.Scanner;
import java.util.List;
import java.util.ArrayList;

public class Main {

public static void main(String[] args) {
//最大子矩阵的累加和
int matrix[][]={{-3,1,2},{1,3,-2},{1,1,1}};
maxSum(matrix);
}
public static void maxSum(int matrix[][])
{
if(matrix==null||matrix.length==0)
return;
int max=0;
int col=matrix[0].length,row=matrix.length;
for(int i=0;i<row;i++)
{
int arr[]=new int[col];
for(int j=i;j<row;j++)
{
//遍历所有的子行
for(int k=0;k<col;k++)
{
arr[k]+=matrix[j][k];
//将每子行的值进行相加然后利用子数组的最大和就可以求出子矩阵的最大和
}
max=Math.max(maxSum(arr), max);
//求出数组的子数组和最大值
}
}
System.out.println(max);
}
public static int maxSum(int arr[])
{
int max=0,sum=0;
for(int i=0;i<arr.length;i++)
{
if(sum<=0)
{
sum=arr[i];
}
else {
sum+=arr[i];
}
max=Math.max(sum, max);
}
return max;
}
}

14，找最小值

给出一个数字组成的字符串，去除指定个数的字符，剩余的组成最小值

这个解题思路可以是递归，按照顺序取剩余个数的字符，组成数字，依次比较获取，但是可能超时。

#include <iostream>
#include <stdio.h>

using namespace std;
class GetMinNumber{

public:
string deleteKBits_1(string str,int k){
int tlen=str.length();
bool flag=true;
int len;
while(k && flag){
len=str.length();
for(int i=0;i<len-1;i++){
if(str[i]>str[i+1]){
str.erase(i,1);
flag=true;
break;
}
}
k--;
}
return str.substr(0,tlen-k);
}

};

int main(){
class GetMinNumber getMinNumber;
int k/*= 3*/;
string str/*= "31141414"*/;
string result;
cin >> str;
cin >> k;
result = getMinNumber.deleteKBits_1(str, k);
cout << result;
}

15、数据分组：

给一个数组对元素分组，要求只有满足1、每组里的数据都相等；2、每组的元素个数都是N（N>=2），满足两个条件才允许分组，返回从小到大的分组。

例如例1、[1,3,3,1] ->[[1,1],[2,2]；例2、[1,1,4,3,3] -> []

import java.util.Scanner;
import java.util.Arrays;

public class Main{

public static void main(String[] args) {
Scanner scanner = new Scanner(System.in);
//System.out.println("请输入一个数");
String str = scanner.nextLine();
String[] numStr = str.split(" ");

if(numStr.length < 2){
System.out.println(0);
return;
}

int[] numInt = new int[numStr.length];
for(int i = 0; i< numStr.length; i++) {
numInt [i] = Integer.parseInt(numStr[i]);
}

Arrays.sort(numInt);

int same_count = 1;
for(int i = 0; i<numInt.length-1; i++){
if(numInt[i] == numInt[i+1]){
//System.out.println("same_count:" + same_count);
same_count++;
}
if(numInt[i] != numInt[i+1]){
break;
}
}

int[][] arrays = new int[numInt.length/same_count][same_count];

if(same_count==0){
System.out.println("return1");
System.out.println("[" + "]");
return;
}else{
if(numInt.length%same_count == 0){
for(int i=0; i<numInt.length/same_count; i++){
for(int j=0; j<same_count; j++){
arrays[i][j] = numInt[same_count*i + j];
}
for(int k=0; k<same_count-1; k++){
if(arrays[i][k] != arrays[i][k+1])
{
System.out.println("return2");
System.out.println("[" + "]");
return;
}
}
}
}else{

System.out.println("return3, numInt.length: " + numInt.length + "same_count:"+ same_count);
System.out.println("[" + "]");
return;
}
}

//boolean flag = true;
/*for(int i = 2 ; i < numStr.length ;i++){
if(numStr.length%i == 0){
flag = false;
}
}*/

//String demo = flag?"是质数":"不是质数";
//if(flag)
for(int n=0; n<numInt.length/same_count; n++){
System.out.print("[");
for(int m=0; m<same_count; m++){
System.out.print(arrays[n][m] + " ");
}
System.out.println("]");
}
}
}

16. 求子集的最大值：

给一个数组，找出相邻元素的和最大。

例如例1、[1,-2,4,8,-1,3,-4] -> 最大为14 ，因为相邻的4,8,-1,3之和。

import java.util.Scanner;

public class Main{
public static void main(String[] args) {
Scanner scanner = new Scanner(System.in);
//System.out.println("请输入一个数");
String str = scanner.nextLine();
String[] numStr = str.split(" ");
int maxSum = 0;

int[] numInt = new int[numStr.length];
for(int i = 0; i< numStr.length; i++) {
numInt [i] = Integer.parseInt(numStr[i]);
}
maxSum = calMaxSumOfArray(numInt);
System.out.println(maxSum);
}

public static int calMaxSumOfArray(int[] a) {
if (null == a) {
return 0;
}
if (a.length == 1) {
return a[0];
}
int sum = a[0];
int temp;
for (int i = 0; i < a.length - 1; i++) {
temp = a[i];
//开始从a[i]往它之后遍历，相加，再跟sum对比
for (int j = i + 1; j < a.length; j++) {
temp = temp + a[j];
if(sum < temp) {
sum = temp;
}
}
}
return sum;
}
}

//以上的算法时间复杂度是O(n^2).空间复杂度是O(1)。

方法二（动态规划）

import java.util.Scanner;

public class Main{
public static void main(String[] args) {
Scanner scanner = new Scanner(System.in);
//System.out.println("请输入一个数");
String str = scanner.nextLine();
String[] numStr = str.split(" ");
int maxSum = 0;

int[] numInt = new int[numStr.length];
for(int i = 0; i< numStr.length; i++) {
numInt [i] = Integer.parseInt(numStr[i]);
}
maxSum = calMaxSumOfArray(numInt);
System.out.println(maxSum);
}

public static int calMaxSumOfArray(int[] a) {
if (null == a) {
return 0;
}
if (a.length == 1) {
return a[0];
}
int sum = a[0];
int temp = a[0];
for (int i = 1; i < a.length; i++) {
temp = max(temp + a[i], a[i]);
if (sum < temp) {
sum = temp;
}
}
return sum;
}

public static int max(int a, int b) {
return a > b ? a : b;
}

}

//以上的算法时间复杂度是O(n).空间复杂度是O(n)。

17. 找出距离远点最大的距离

给一串字符串，里边有合法的坐标，找到最远的坐标，注意判断坐标的不合法（（1,01），（0,100）等），如果多个最远输出最早的一次。

例如例1、faaa(3,01)art53(7,4)dfgh4w(5,10) ->(5,10)

import java.util.Scanner;
import java.util.HashMap;
import java.util.Stack;

public class Main{
/*private boolean check(String str){
HashMap<Character, Character> map=new HashMap<>();
map.put(')', '(');
Stack<Character> s=new Stack<>();
for(int i=0;i<str.length();i++){
char c=str.charAt(i);
if(map.containsValue(c)){
s.push(c);
}else if(map.containsKey(c)){
if(!s.isEmpty()&&s.peek()==map.get(c)){
s.pop();
}else{
return false;
}
}
}
return s.isEmpty();
}*/
public static void main(String[] args) {
Main bd=new Main();
Scanner in = new Scanner(System.in);
String str = in.nextLine();
int index=0,i=0,max_index=0;
int[] max_distance = new int[100];
//System.out.println(bd.check(str));
String[] location = new String[100];
try{
while(!str.substring(index).isEmpty()){
str = str.substring(index);
location[i] = subString(str, "(", ")");
index = str.indexOf(")") + 1;
i++;
}
}catch(NullPointerException e){
e.printStackTrace();
}

for(int j=0; j<i; j++){
String[] integer = location[j].split(",");

int a = Integer.parseInt(integer[0]);
int b = Integer.parseInt(integer[1]);
int temp=0;
if((a>0&&a<100)&&(b>0&&b<100))
{
max_distance[j] = a*a + b*b;
}
else
{
max_distance[j] = 0;
}

if(max_distance[j]>temp)
{
temp = max_distance[j];
max_index = j;
}
//System.out.println(location[j]);
//System.out.println(max_distance[j]);
}
System.out.println(max_distance[max_index]);
System.out.println("(" + location[max_index] + ")");

}

public static String subString(String str, String start, String end)
{
int indexOfStart = str.indexOf(start);
int indexOfEnd = str.indexOf(end);
String local_str="";

if (indexOfStart < 0) {
return "0";
}
if (indexOfEnd < 0) {
return "0";
}

System.out.println(local_str);
return local_str = str.substring(indexOfStart+1, indexOfEnd);
}
}

18. 回文串 –题目比较难

先给出一个不是回文串的字符串，并且子串也是不包含回文串（大于等于2），请找出下一个字典序，满足子串也是不包含回文串的字符串。

cba –>NO，说明长度相同的字符串cbb和cbc，由于都有回文串不可接受，所以输出NO。

import java.util.Scanner;
import java.util.HashMap;
import java.util.Stack;

public class Main{
public static void main(String[] args) {
Scanner in = new Scanner(System.in);
String str = in.nextLine();
int length = str.length();
char last_letter = str.charAt(length-1);
char replace_letter = (char)(last_letter + 1);
System.out.println(replace_letter);
StringBuilder sb = new StringBuilder(str);
sb.replace(length-1,length, replace_letter+"");
System.out.println("" + sb);

}
}

19.替换字母，找出字典序最小的回文串。

给定一个只包含小写字母的字符串，你可以修改任意位置的字符（变换为a-z中任一个），然后重新排列字符串。现在要求用最少次数的修改得到一个回文串，若有多种方案，输出字典序最小的方案。

三、思路分析

题目本身有很多特殊条件可以利用，比如回文，偶数长的字符串所有字母出现的次数都为偶数，奇数长的字符串，必有一个字母出现次数为1次，那么对于偶数长度的字符串我们就要让所有那些多了一个（必然是只多一个），我们就标记他们，并且让字典序最大的变成最小的，次大的的变成次小的，而且容易知道，它的那些多了一个的字母也必然是偶数个；对于奇数长的字符串，多了一个的字母个数必然为奇数个，我们把中间的那个字母放在整个回文串的中间。
```
 1 #include <iostream>
 2 #include <stdio.h>
 3 #include <string.h>
 4 #include <cstring>
 5 using namespace std;
 6 const int N = 2e5+5;
 7 char s[N];
 8 int num[26]={0};
 9 // int mark[26]={0};
10 char trans[26]={0};
11 
12 int main()
13 {
14     scanf("%s",s);
15     int len = strlen(s);
16     int unuse = 0; char mid = '0';
17     for(int i=0; i<len; i++)
18         num[s[i]-'a']++;
19     for(int i=0; i<26; i++)
20     {
21         if(num[i]%2)
22             trans[++unuse] = 'a'+i;
23     }
24     /**cout << unuse << endl;*/
25     for(int i=1; i<=unuse/2; i++)
26     {
27         num[trans[i]-'a']++;
28         num[trans[unuse-i+1]-'a']--;
29     }
30     if(len%2) mid = trans[unuse/2+1];
31     int F=0, B=len-1; // 我们最后是通过记录改变完字母后的每个字母的出现次数来按照字典序重排字符串的
32     for(int i=0; i<26; i++) 
33     {
34         /**cout << num[i] << " ";*/
35         for(int j=F; j<F+num[i]/2; j++)
36             s[j] = 'a' + i;
37         F += num[i] / 2;
38         for(int j=B; j>B-num[i]/2; j--)
39             s[j] = 'a' + i;
40         B -= num[i] / 2;
41     }
42     if(len%2) s[len/2] = mid;
43     cout << s << endl;
44     return 0;
45 }
```
20. 找出过特定点的路劲长度

输入一个字符串，都是以大写字母组成，每个相邻的距离是1，第二个输入一个字符串，表示必过的点。说明每个点可过多次。

输入

ANTSEDXQOKPUVGIFWHJLYMCRZB

ABC

输出28

import java.util.Scanner;
import java.util.HashMap;
import java.util.Stack;

public class Main{
public static void main(String[] args) {
Scanner in = new Scanner(System.in);
String sourceStr = in.nextLine();
String pathStr = in.nextLine();
int length = pathStr.length();

char[] cusor = new char[length];
for(int i=0; i<length; i++)
{
cusor[i] = pathStr.charAt(i);
}

int[] pointAtSourceStr = new int[length];
int sumDistance = sourceStr.indexOf(cusor[0]);
System.out.println("fiste_letter_point:" + sumDistance);
for(int j=0; j<length-1; j++)
{
pointAtSourceStr[0] = sourceStr.indexOf(cusor[0]);
pointAtSourceStr[j+1] = sourceStr.indexOf(cusor[j+1]);
//System.out.println(pointAtSourceStr[j+1]);
sumDistance += getDistance(pointAtSourceStr[j+1], pointAtSourceStr[j]);
//System.out.println("sumDistance:" + sumDistance);
}

System.out.println(sumDistance);

}
private static int getDistance(int start, int end){
//int temp = Math.abs(start - end);
//System.out.println("start:" + start + ", end:" + end + ", abs:" + temp);
return Math.abs(start - end);
}
}

21.找出一条线上的相同元素个数–比较难

给一个矩阵，里边包含两种不同的字符，需要你找出水平、垂直、对角线、反对角线上相同元素最多的个数

输入

3,4

F,G,G,F

F,G,G,F

F,F,F,G

输出

3

import java.util.Scanner;
import java.util.HashMap;
import java.util.Stack;
import java.util.Arrays;
import java.util.ArrayList;

public class Main{
public static void main(String[] args) {
Scanner in = new Scanner(System.in);
String[] sourceStr = new String[10];
String[] temp = new String[10];
String[] row = new String[10];

for(int i=0; i<10; i++)
{
StringBuilder rowBuilder = new StringBuilder();
sourceStr[i] = in.nextLine();
temp = sourceStr[i].split(",");
for(String str:temp){
rowBuilder.append(str);
}
row[i] = rowBuilder.substring(0);
//System.out.println(row[i]);
}

char[][] matrix = new char[10][10];

for(int j=0; j<10; j++)
{
for(int k=0; k<10; k++)
{
matrix[j][k] = row[j].charAt(k);
}
}

StringBuilder mainCrossLine = new StringBuilder();
StringBuilder slaveCrossLine = new StringBuilder();
ArrayList<StringBuilder> listLines = new ArrayList<StringBuilder>();
for(int m=0; m<10; m++){
mainCrossLine.append(matrix[m][m]);
slaveCrossLine.append(matrix[m][9-m]);
for(int n=0;n<10; n++)
{
listLines.add(new StringBuilder());
/*if(m==2)
{
System.out.println("list3:" + matrix[n][m]);
}*/
listLines.get(m).append(matrix[n][m]);
}
}
String mainString = mainCrossLine.substring(0);
String slaveString = slaveCrossLine.substring(0);

String[] list = new String[10];
int maxNumber = 0;
for(int l=0; l<10; l++){
list[l] = listLines.get(l).substring(0);

/*if(l==2){
System.out.println("list3line:" + listLines.get(l).substring(0));
System.out.println("maxnum_list3:" + getMaxNumOfMatrix(list[l]));
}*/
maxNumber = maxNumber > getMaxNumOfMatrix(list[l]) ? maxNumber : getMaxNumOfMatrix(list[l]);
//System.out.println(list[l]);
maxNumber = maxNumber > getMaxNumOfMatrix(row[l]) ? maxNumber : getMaxNumOfMatrix(row[l]);
}

maxNumber = maxNumber > getMaxNumOfMatrix(mainString) ? maxNumber : getMaxNumOfMatrix(mainString);
maxNumber = maxNumber > getMaxNumOfMatrix(slaveString) ? maxNumber : getMaxNumOfMatrix(slaveString);

System.out.println(maxNumber);

}

private static int getMaxNumOfMatrix(String str){
int max = 0;
HashMap<Character, Integer> map = new HashMap<Character, Integer>(str.length());
for (char c : str.toCharArray()) {
Integer i = map.get(c);
int value = (i == null) ? 0 : i;
map.put(c, ++value);
max = value > max ? value : max;
}
//System.out.println(max);
return max;
}
}

22. 按字符串里的数字排序

给出的字符串结构是前边是字母、后边为数字，例如wew0145，要求给出一组数据，按照后边的数字从小到大排序。

输入

wr0068,lt01,qhy0027828,gh20425256,xj0033258,zmj00505562

输出

lt01,wr0068,qhy0027828,xj0033258,zmj00505562,gh20425256

说明

按照报名名单中员工工号中的数字部分升序排序输出。

备注:输入名单中工号中数字都是唯一的。

import java.util.Scanner;
import java.util.HashMap;
import java.util.List;
import java.util.Arrays;
import java.util.ArrayList;
import java.util.stream.Collectors;

public class Main{
public static void main(String[] args) {
String str ="wr0068,lt01,qhy0027828,gh20425256,xj0033258,zmj00505562";
List<String> strlist = Arrays.asList(str.split(","));

List<String> sortlist = strlist.stream().sorted((a,b)->Integer.valueOf(subStrChar(a)).compareTo(Integer.valueOf(subStrChar(b)))).collect(Collectors.toList());
//两种排序都正确
/* Collections.sort(strlist, new Comparator<String>() {
@Override
public int compare(String s1, String s2) {
int num1=Integer.parseInt(subStrChar(s1));
int num2=Integer.parseInt(subStrChar(s2));
return num1-num2;
}
});*/
System.out.println(sortlist);

}

public static String subStrChar(String st){
if (st.equals("") || st == null){
return null;
}
int stopPos=st.length();
for (int i=0;i<st.length();i++){ //// 遍历 st 的字符
char c =st.charAt(i);
if (c>='0' && c<='9'){ // 如果当前字符是数字
stopPos=i;
break;
}
}
return st.substring(stopPos,st.length());
}
}

23. 整数分解之素数

给定一个32位正整数，对其进行因数分解，分解成两个素数的乘积，如果不能分解输出-1，-1。

输入

15

输出

3，5

import java.util.Scanner;

import java.util.HashMap;
import java.util.List;
import java.util.Arrays;
import java.util.ArrayList;
import java.util.stream.Collectors;

public class Main{
public static void main(String[] args) {
Scanner s = new Scanner(System.in);
//System.out.print( "请键入一个正整数: ");
boolean onlyTow = false;
int n= s.nextInt();
int k=n-1;
int one;
int final_one=0;
int final_tow=0;
//System.out.print(n+"=");
while(k > 1) {
if(n%k == 0) {
onlyTow = true;
one = n/k;
for(int i = one-1; i > 1; i--){
if(one%i == 0)
{
onlyTow = false;
break;
}
}
for(int j = k-1; j>1; j--){
if(k%j == 0)
{
onlyTow = false;
break;
}
}
if(onlyTow){
if(one>k){
final_one = k;
final_tow = one;
}else{
final_one = one;
final_tow = k;
}
}
}
k--;
}
if(onlyTow)
System.out.println(final_one + "," + final_tow);
else
System.out.println("-1");
}
}

25. 现有一字符串仅由 '('，')'，'{'，'}'，'['，']'六种括号组成

若字符串满足以下条件之一，则为无效字符串：

①任一类型的左右括号数量不相等；

②存在未按正确顺序（先左后右）闭合的括号。

输出括号的最大嵌套深度，若字符串无效则输出0。

import java.util.Stack;
import java.util.Scanner;

/**
* 此题还可以引申至配对字符符匹配问题，如单引号，双引号匹配问题。
*
*/

public class Main {

public int matching(String expression)
{
int deepth = 0;
int temp_max = 0;
if(expression==null||expression=="")
{
return 0;
//System.out.println( "输入表达式为空或没有输入表达式" ) ;
}

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

for(int index=0 ; index<expression.length();index++)
{
switch(expression.charAt(index))
{
case '(':
stack.push(expression.charAt(index)) ;
break ;
case '{':
stack.push(expression.charAt(index)) ;
break ;
case '[':
stack.push(expression.charAt(index));
break;
case ')':
if(!stack.empty()&&stack.peek()=='(')
{
temp_max = temp_max > stack.size() ? temp_max : stack.size();
stack.pop() ;
}else{
return 0;
}
break ;
case '}':
if(!stack.empty()&&stack.peek()=='{')
{
temp_max = temp_max > stack.size() ? temp_max : stack.size();
stack.pop();
}else{
return 0;
}
break;
case ']':
if(!stack.empty()&&stack.peek()=='[')
{
temp_max = temp_max > stack.size() ? temp_max : stack.size();
stack.pop();
}else{
return 0;
}
break;
}
}
deepth = temp_max;
if(stack.empty())
return deepth ;
return 0 ;
}

public static void main(String[] args) {
Scanner in = new Scanner(System.in);

String expression = in.nextLine();

Main oj = new Main() ;

int deepth = oj.matching(expression) ;

System.out.println(deepth) ;

}

}

26. 字符串加密

给你一串未加密的字符串str，通过对字符串的每一个字母进行改变来实现加密，加密方式是在每一个字母str[i]偏移特定数组元素a[i]的量，数组a前三位已经赋值：a[0]=1,a[1]=2,a[2]=4。当i>=3时，数组元素a[i]=a[i-1]+a[i-2]+a[i-3]，

例如：原文 abcde 加密后 bdgkr，其中偏移量分别是1,2,4,7,13。

输入描述:

第一行为一个整数n（1<=n<=1000），表示有n组测试数据，每组数据包含一行，原文str（只含有小写字母，0<长度<=50）。

输出描述:

每组测试数据输出一行，表示字符串的密文

示例1：输入

1

xy

输出：

ya

import java.util.Scanner;
import java.util.ArrayList;

public class Main{
public static void main(String[] str){
Scanner in = new Scanner(System.in);
int lines = 0, len = 0;
String[] strings = new String[1000];
lines = in.nextInt();
//strings[0] = in.next();
int[] mask_array = new int[50];
mask_array[0] = 1;
mask_array[1] = 2;
mask_array[2] = 4;

//strings[0] = "xy";
for(int i = 0; i < lines; i++){
strings[i] = in.next();
//System.out.println(strings[i]);
len = strings[i].length();
if(len>3){
for(int j=3; j<len; j++){
mask_array[j] = mask_array[j-1] + mask_array[j-2] + mask_array[j-3];
//System.out.println("mask:" + mask_array[j]);
}
}
}

//String[] letters = new String[50];
//ArrayList<String> lineLists = new ArrayList<String>();
StringBuilder sb = new StringBuilder();
int letter_asc2;
char letter;
String[] maskedStr = new String[lines];

for(int k=0; k<lines; k++){
sb.delete(0,sb.length());
for(int m=0; m<len; m++)
{
letter_asc2 = (strings[k].charAt(m) + mask_array[m]);
if(letter_asc2 > 122)
{
letter_asc2 = 96 + (letter_asc2 - 122);
}
//System.out.println("letter_asc2:" + letter_asc2);
letter = (char)letter_asc2;
//System.out.println("letter:" + letter);
sb.append(letter);
}
maskedStr[k] = sb.substring(0);
}
//System.out.println(lines);
for(int n=0; n<lines; n++){
System.out.println(maskedStr[n]);
}
}
}

27. 求一颗二叉树深度

/*建立二叉树求解问题*/
#include<iostream>
using namespace std;
typedef struct Node
{
struct Node *lchild;
struct Node *rchild;
int val;
}BiTree,*LinkTree;

int flag; //判断函数递归是否结束

//求树的高度
int getTreeHeight(LinkTree rootNode)
{
if(rootNode==NULL) return 0;

int nLeft = getTreeHeight(rootNode->lchild);
int nRight = getTreeHeight(rootNode->rchild);
return (nLeft>nRight)?(nLeft+1):(nRight+1);
}

//依据节点建树
void CreatTree(LinkTree root,int father,int childVal)
{
// cout<<"CreatTree"<<endl;
//root->lchild=NULL;
//cout<<childVal<<" "<<father<<endl;
if(root==NULL) return;
// cout<<"Compare:"<<root->val<<" "<<father<<endl;
if(root!=NULL&&root->val==father)
{
// cout<<"INIT"<<endl;
if(root->lchild==NULL) //如果左子树为空，则建立左子树
{
root->lchild=new(BiTree);
root->lchild->val=childVal;
root->lchild->lchild=NULL;
root->lchild->rchild=NULL; //左右节点赋空
flag=1;
}
else //否则则建立右子树，因为合法，故非左即右
{
// cout<<"rchild"<<endl;
root->rchild=new(BiTree);
root->rchild->val=childVal;
root->rchild->lchild=NULL;
root->rchild->rchild=NULL;
flag=1;
}
return;

}
if(flag==0) //设置标记，防止无限调用循环，而且会减少函数调用的次数
{
CreatTree(root->lchild,father,childVal); //类似于深度优先，若一层不行，则往深入遍历
CreatTree(root->rchild,father,childVal);
}
else return;
}

int main()
{
int n,height;
cin>>n;
LinkTree root=new(BiTree);
root->val=0;
root->lchild=NULL;
//Creat(root,root->val,)
for(int i=0;i<n-1;i++)
{
flag=0;
int father;
int childVal;
cin>>father>>childVal;
CreatTree(root,father,childVal);
}
//cout<<root->val<<endl;
//cout<<root->rchild->val<<endl;
//cout<<root->rchild->val<<endl;
height=getTreeHeight(root);
cout<<height;
return 0;
}

28. Directory删除
```
某文件系统中有N个目录，每个目录都一个独一无二的ID。每个目录只有一个父目录，但每个父目录下可以有零个或者多个子目录，目录结构呈树状结构。

假设，根目录的ID为0，且根目录没有父目录，其他所有目录的ID用唯一的正整数表示，并统一编号。

现给定目录ID和其父目录ID的对应父子关系表[子目录ID，父目录ID]，以及一个待删除的目录ID，请计算并返回一个ID序列，表示因为删除指定目录后剩下的所有目录，返回的ID序列以递增序输出。

注意：

1、被删除的目录或文件编号一定在输入的ID序列中；

2、当一个目录删除时，它所有的子目录都会被删除。

输入描述:

输入的第一行为父子关系表的长度m；接下来的m行为m个父子关系对；最后一行为待删除的ID。序列中的元素以空格分割，参见样例。

输出描述:

输出一个序列，表示因为删除指定目录后，剩余的目录ID。

示例1

输入

5

8 6

10 8

6 0

20 8

2 6

8

输出

2 6
```
/*父节点的深度加一就是子节点的深度，从0开始一次往下遍历*/
/*0的深度为1，一次以此为基础向下遍历，则可得到最终深度 */
#include<iostream>
#include<vector>
#include<cmath>
#include<algorithm>
using namespace std;

int main()
{
int n;
int temp;
//int BiHeight=0; //the result
//int result[10000]={1};
int deleted_value = 0;
int deleted_index = 0;
vector<vector<int> > count; //to creat a array
cin>>n;
for(int i=0;i<n;i++)
{
vector<int> MiddleUse;
cin>>temp;
MiddleUse.push_back(temp);
cin>>temp;
MiddleUse.push_back(temp);
count.push_back(MiddleUse); //input the array
}
cin >> deleted_value;
sort(count.begin(),count.end()); //sort to calculate
//cout<< "print all counts: ";
/*for(int i=0;i<n;i++)
cout<<count[i][0]<<" "<<count[i][1]<<endl;
*/

for(int j=0; j<n-1; j++){
if(count[j][0] == deleted_value){
deleted_index = j;
}
}
//cout<<BiHeight<<endl;
//cout << "print counts post deleted:";
for(int k=0; k<deleted_index; k++){
if(count[k][1] == 0)
{
continue;
}
cout << count[k][0]<<" "<<count[k][1]<<endl;
}

}

29. 阿里五福

输入类似11010,00110，由0、1组成的长度为5的字符串，代表指定团队中每个人福卡获得情况

注意1：1人也可以是一个团队

注意2：多人之间的福卡以英文逗号隔开

输出描述:

输出该团队能凑齐多少套五福
```
示例1

输入

11001,11100

输出

0
```
import java.util.Scanner;
import java.util.ArrayList;

public class Main{
public static void main(String[] str){
Scanner in = new Scanner(System.in);

String[] strings = new String[10];

String line = in.nextLine();

strings = line.split(",");

int length = strings.length;
int matrix[][] = new int[length][5];

for(int i = 0; i < length ; i++){
//System.out.println(strings[i]);
//String[] integer_str = strings[i].split("");
for(int k=0; k<5; k++)
{
char c = strings[i].charAt(k);
String c_str = String.valueOf(c);
//System.out.println("integer_char:" + c_str);
if(c_str == "" || c_str == " "){
break;
}
matrix[i][k] = Integer.parseInt(c_str);
//System.out.println(matrix[i][k]);
}
}

int minNumber = length;

for(int i = 0; i < 5; i++){
int counter = 0;
for(int j = 0; j < length; j ++){
if(matrix[j][i] == 1)
{
counter++;
}
}
minNumber = minNumber < counter? minNumber : counter;
}
System.out.println(minNumber);
}
}

30. 区间重叠问题

给定一组闭区间，其中部分区间存在交集。任意两个给定区间的交集，称为公共区间（如：[1,2],[2,3]的公共区间为[2,2]，[3,5],[3,6]的公共区间为[3,5]）。公共区间之间若存在交集，则需要合并（如：[1,3],[3,5]区间存在交集[3,3]，须合并为[1,5])。按升序排列输出合并后的区间列表。
```
示例 1:

 输入: [[1,3],[2,6],[8,10],[15,18]]
输出: [[1,6],[8,10],[15,18]]
解释: 区间 [1,3] 和 [2,6] 重叠, 将它们合并为 [1,6].
示例 2:

 输入: [[1,4],[4,5]]
输出: [[1,5]]
解释: 区间 [1,4] 和 [4,5] 可被视为重叠区间。
```
import java.util.Arrays;
import java.util.Comparator;
import java.util.LinkedList;
import java.util.List;
import java.util.stream.Collectors;

/**
* 给出一个区间的集合，请合并所有重叠的区间。
*
* 示例 1:
*
* 输入: [[1,3],[2,6],[8,10],[15,18]]
* 输出: [[1,6],[8,10],[15,18]]
* 解释: 区间 [1,3] 和 [2,6] 重叠, 将它们合并为 [1,6].
* 示例 2:
*
* 输入: [[1,4],[4,5]]
* 输出: [[1,5]]
* 解释: 区间 [1,4] 和 [4,5] 可被视为重叠区间。
*/

public class SectionMerge {
public static void main(String[] args) {
int[][] intervals = {{1, 3}, {2, 6}, {8, 10}, {15, 18}};

SectionMerge tool = new SectionMerge();
int[][] newIntervals = tool.merge(intervals);
int size = newIntervals.length;
for (int i = 0; i < size; i++) {
System.out.println(Arrays.toString(newIntervals[i]));
}

}

public int[][] merge(int[][] intervals) {
if (intervals.length == 0) {
return new int[0][0];
}

List<Interval> intervalList = Arrays.stream(intervals)
.map(ints -> new Interval(ints[0], ints[1]))
.sorted(Comparator.comparingInt(interval -> interval.start))
.collect(Collectors.toList());

List<Interval> newInterList = new LinkedList<>();
int size = intervals.length;
for (int i = 0; i < size; i++) {
int left = intervalList.get(i).start;
int right = intervalList.get(i).end;

if (newInterList.isEmpty()) {
newInterList.add(intervalList.get(i));
}else if (newInterList.get(newInterList.size() - 1).end < left) {
newInterList.add(intervalList.get(i));
} else {
Interval newLast = newInterList.get(newInterList.size() - 1);
newInterList.remove(newInterList.size() - 1);

newLast.end = Integer.max(newLast.end, intervalList.get(i).end);
newInterList.add(newLast);
}
}

return getIntervalsByIntervalList(newInterList);
}

private int[][] getIntervalsByIntervalList(List<Interval> newInterList) {
int[][] intervals = new int[newInterList.size()][2];
int size = newInterList.size();
for (int i = 0; i < size; i++) {
intervals[i][0] = newInterList.get(i).start;
intervals[i][1] = newInterList.get(i).end;
}

return intervals;
}

private class Interval {
int start;
int end;

public Interval(int start, int end) {
this.start = start;
this.end = end;
}
}
}

31. 连续数列

输入描述:

输入包含两个参数，1）连续正整数数列和S，2）数列里数的个数N。

输出描述:

如果有解输出数列K，如果无解输出-1

示例1

输入

525 6

输出

85 86 87 88 89 90

import java.util.Arrays;
import java.util.Comparator;
import java.util.LinkedList;
import java.util.List;
import java.util.stream.Collectors;
import java.util.Scanner;
import java.util.ArrayList;

public class Main {
public static void main(String[] args) {
Scanner in = new Scanner(System.in);
int target = in.nextInt();
int array_num = in.nextInt();
boolean matching_flag = false;
int[][] results = findContinuousSequence(target);

for(int i = 0; i < results.length; i++){
for(int j=0; j < results[i].length; j++){
if(array_num == results[i].length){
System.out.print(results[i][j] + " ");
matching_flag = true;
}
}
}
if(!matching_flag)
System.out.println(-1);
}

public static int[][] findContinuousSequence(int target) {
List<List<Integer>> res = new ArrayList<List<Integer>>();
int left = 1;
int right = 1;
int sum = 0;
while(right < target && left <= right){//这里注意是right<target 而不是sum < target。
sum += right;
//System.out.println("sssss" + sum + "right" + right + "left" + left);
while(sum > target){
sum -= left;
//System.out.println("vvv" + sum);
left ++;
}
if(sum == target){
//System.out.println(sum);
List<Integer> ans = new ArrayList<>(); //这里千万要注意，这个List对象一定要这里，这样res加的是不同的对象，如果你定义在函数开始时，那么真个res对象里只有1个ans对象，所有数据是连在一起的，没法按组（按行）分开。
for(int i = left; i <= right; i ++){
ans.add(i);
}
res.add(ans);
}
right ++;
}
int[][] result = new int[res.size()][];
int j = 0;
for(List<Integer> li : res){
int[] row = new int[li.size()];
int i = 0;
for(Integer lii : li){
row[i ++] = lii;
//System.out.println("有序整数："+lii);
}
result[j ++] = row;
}
return result;
}

}

32. 数字全排列
```
小明负责公司年会，想出一个趣味游戏：

屏幕给出1～9中任意3个不重复的数字，大家以最快时间给出这几个数字可拼成的数字从小到大排列位于第N位置的数字，其中N为给出的数字中最大的（如果不到这么多个数字则给出最后一个即可）。

注意：

1）2可以当做5来使用，5也可以当做2来使用进行数字拼接，且屏幕不能同时给出2和5；

2）6可以当做9来使用，9也可以当做6来使用进行数字拼接，且屏幕不能同时给出6和9。

 

如给出：1，4，8，则可以拼成的数字为：

1，4，8，14，18，41，48，81，84，148，184，418，481，814，841

那么最第N（即8）个的数字为81。

输入描述:

输入为以逗号分隔的描述3个int类型整数的字符串。

输出描述:

输出为这几个数字可拼成的数字从小到大排列位于第N（N为输入数字中最大的数字）位置的数字，如果输入的数字不在范围内或者有重复，则输出-1。

示例1

输入

1,4,8

输出

81

说明

可以构成的数字按从小到大排序为1，4，8，14，18，41，48，81，84，148，184，418，481，814，841，故第8个为81
```
import java.util.HashSet;
import java.util.Scanner;
import java.util.ArrayList;
import java.util.Collections;

public class Main {
public static int getNthNum(ArrayList array) {
if(array == null) {
return -1;
}
if(array.contains(2) && array.contains(5)) {
return -1;
}
if(array.contains(6) && array.contains(9)) {
return -1;
}
HashSet<Integer> hashSet = new HashSet<Integer>();
getCombinedNumsArray(array, hashSet);
for(int i=0; i<array.size();i++) {
if(array.get(i).equals(2)){
array.set(i, 5);
getCombinedNumsArray(array, hashSet);
}else if(array.get(i).equals(5)) {
array.set(i, 2);
getCombinedNumsArray(array, hashSet);
}else if(array.get(i).equals(6)) {
array.set(i, 9);
getCombinedNumsArray(array, hashSet);
}else if(array.get(i).equals(9)) {
array.set(i, 6);
getCombinedNumsArray(array, hashSet);
}
}
ArrayList<Integer> resArray = new ArrayList<>();
for(Integer i:hashSet) {
resArray.add(i);
}
Collections.sort(resArray);
System.out.println(resArray);
int maxNum = 0;
for(int i=0;i<array.size();i++) {
if((int) array.get(i)==2) {
maxNum = maxNum>5 ? maxNum : 5;
}else if((int) array.get(i)==6) {
maxNum = 9;
}else {
maxNum = maxNum > (int) array.get(i) ? maxNum : (int) array.get(i);
}
}
return resArray.get(maxNum-1);
}

public static void getCombinedNumsArray(ArrayList list, HashSet hashSet) {
int len = list.size();
for(int i=0; i<len; i++) {
hashSet.add((int) list.get(i));
for(int j=0; j<len; j++) {
if(j==i) {
continue;
}
hashSet.add((int) list.get(i)*10 + (int) list.get(j));
for(int k=0;k<len;k++) {
if(k==i || k==j) {
continue;
}
hashSet.add((int)list.get(i)*100 + (int)list.get(j)*10 + (int)list.get(k));
}
}
}
}

public static ArrayList getSingleNumsArray(String line) {
String[] threeValues = line.split(" *, *");
if(threeValues.length!=3) {
return null;
}else if(threeValues[0].equals(threeValues[1]) || threeValues[0].equals(threeValues[2])
|| threeValues[1].equals(threeValues[2])) {
return null;
}
ArrayList res = new ArrayList<Integer>();
for(String s:threeValues) {
int num;
try {
num = Integer.parseInt(s);
}catch(Exception e) {
return null;
}
if(1 > num || num > 9) {
return null;
}
res.add(num);
}
return res;
}

public static void main(String[] args) {
Scanner scan = new Scanner(System.in);
String line = scan.nextLine().trim();
ArrayList singleNumsArray = getSingleNumsArray(line);
System.out.println(getNthNum(singleNumsArray));
}
}

33. 堆栈中的剩余数字
```
向一个空栈中依次存入正整数， 假设入栈元素n(1<=n<=2^31-1)按顺序依次为nx...n4、n3、n2、n1, 每当元素入栈时，如果n1=n2+...+ny(y的范围[2,x]，1<=x<=1000)，则n1~ny全部元素出栈，重新入栈新元素m(m=2*n1)。

如：依次向栈存入6、1、2、3, 当存入6、1、2时，栈底至栈顶依次为[6、1、2]；当存入3时，3=2+1，3、2、1全部出栈，重新入栈元素6(6=2*3)，此时栈中有元素6；因为6=6，所以两个6全部出栈，存入12，最终栈中只剩一个元素12。

输入描述:

使用单个空格隔开的正整数的字符串，如"5 6 7 8"， 左边的数字先入栈，输入的正整数个数为x，1<=x<=1000。

输出描述:

最终栈中存留的元素值，元素值使用空格隔开，如"8 7 6 5"， 栈顶数字在左边。

示例1

输入

5 10 20 50 85 1

输出

1 170

说明

5+10+20+50=85， 输入85时，5、10、20、50、85全部出栈，入栈170，最终依次出栈的数字为1和170。
```
import java.util.HashSet;
import java.util.Scanner;
import java.util.ArrayList;
import java.util.Collections;

public class Main {

public static void main(String[] args) {
Scanner scan = new Scanner(System.in);
//String line = scan.nextLine().trim();
String string = scan.nextLine();

String[] integer = string.split(" ");

int i=0, sum=0;
ArrayList<Integer> intLists = new ArrayList<Integer>();
int pop_index = 0;

for(String str: integer){
intLists.add(Integer.parseInt(str));
i++;
}

for(int j=0; j<intLists.size(); j++)
{
sum += intLists.get(j);
if(j < intLists.size() -1){
if(sum == intLists.get(j+1)){
pop_index = j+1;
int added_integer = intLists.get(j+1)*2;
for(int k=0; k<=pop_index; k++){
intLists.remove(0);
}
intLists.add(added_integer);
j=0;
sum=0;
}
}
}

for(Integer result: intLists){
System.out.print(result + " ");
}
//ArrayList singleNumsArray = getSingleNumsArray(line);
}
}

34. 翻转文章片段

输入一个英文文章片段，翻转指定区间的单词顺序，标点符号和普通字母一样处理。例如输入字符串"I am a developer. "，区间[0,3]，则输出"developer. a am I"。

输入

I am a developer.

1

2

输出

I a am developer.

#include<iostream>
#include<vector>
#include<algorithm>
#include <string.h>
using namespace std;
int main()
{
string str, temp;
const char* deprator = " ";
getline(cin, str);
char* sentance = (char*)str.c_str();
char* p;
vector<string> s_vector;

p=strtok(sentance, deprator);
temp = p;
s_vector.push_back(temp);
while(p){
printf("%s ",p);
p = strtok(NULL, deprator);
if(p!=NULL){
temp = p;
s_vector.push_back(temp);
}
}

/*for(int i=0;i<100;i++){
cin >> str;
s_vector.push_back(str);
}*/

for(int i=0;i<s_vector.size();i++){
cout<<s_vector[i]<<" ";
}

reverse(s_vector.begin() + 1,s_vector.end());

cout<< "after reversing..." << endl;
for(int i=0;i<s_vector.size();i++){
cout<<s_vector[i]<<" ";
}
return 0;
}

35. 二叉树从上往下从左往右按层打印

import java.util.Scanner;
import java.util.Arrays;
import java.util.ArrayList;

public class Main{

class TreeNode{
int value;
TreeNode left;
TreeNode right;

public TreeNode(int val){
this.value = val;
}
}
public ArrayList<ArrayList<Integer>> printBTree(TreeNode rootNode){
ArrayList<ArrayList<Integer>> results = new ArrayList<ArrayList<Integer>>();
ArrayList<Integer> start = new ArrayList<Integer>();
ArrayList<Integer> temp = new ArrayList<Integer>();
ArrayList<TreeNode> queue = new ArrayList<TreeNode>();
start.add(rootNode.value);
int low = 0;
int high = 1;
int end = high;
results.add(start);
queue.add(rootNode);
while(low < high){
TreeNode fake = queue.get(low);
if(fake.left!=null){
temp.add(fake.left.value);
queue.add(fake.left);
high++;
}else if(fake.right!=null){
temp.add(fake.right.value);
queue.add(fake.right);
high++;
}
low++;
}
results.add(temp);

return results;
}

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

//}
}

35. 跳数问题

数字从1开始，遇到数字7就会跳过，比如6后边直接是8，69后边直接是80，现在给你个数字，问是第几位？

比如输入8，输出7，就是第7个数。那89那？请你编程输出。

//利用存入ArrayList去遍历的方法

import java.util.Scanner;
import java.util.ArrayList;

public class Main {
public static void main(String[] args){
Scanner in = new Scanner(System.in);
int target = in.nextInt();
ArrayList<Integer> intList = new ArrayList<Integer>();

for(int i = 0; i < target; i++){
if(!isInclude7(i+1)){
intList.add(i+1);
}
//System.out.println("index:" + (intList.indexOf(i+1) + 1));
}
System.out.println(findIndexOf(target, intList) + 1);
}

public static boolean isInclude7(int a){
while((a/10 != 0) || (a/10 == 0) && (a%10 == 7)){
if(a%10 == 7){
return true;
}
a=a/10;
}
return false;
}

public static int findIndexOf(int b, ArrayList<Integer> list){
for(int i=0; i < list.size(); i++){
if(list.get(i) == b)
{
return i;
}
}
return 0;
}
}

类似的，看下一题，这题是遇到相应数字就+1；

逢4必过

在餐厅购买食物时，有N个人需要取票进行排队等待，但是中国人十分讲究吉利这个数字，故排队中产生数字4的时候，就进行跳过，例如：第1个人领食物，号码是1，第5个人领食物，号码是6，第50000个人领食物，号码是86626。
要求：输入：50000 输出：86626

//利用遍历并实时判断计数的方法

import java.util.Scanner;

public class Main {

public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
//System.out.println("请输入值：");
int i = sc.nextInt();
int sum = 0;
for (int j = 0; j <= i + sum; j++) {
if (ran(j) == 1) {
sum++;
}
}
//System.out.println("结果为：");
System.out.println(sum + i);
}

public static int ran(int k) {
while (k > 1) {
if (k % 10 == 4) {
return 1;
} else {
k = k / 10;
}
}
return 0;
}
}

36.输出匹配字符串的开始下标

给出母串和子串，输出子串能够在母串完全匹配的开始位置

比如 asdfasdfa，fas 输出3，就是最小下标

import java.util.Scanner;

public class Main {

public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
//System.out.println("请输入值：");
String src_str = sc.nextLine();
String sub_str = sc.nextLine();

System.out.println(src_str.indexOf(sub_str));
}
}

还有类似的题目，要求输出字串出现的次数，

这种更方便的办法，就是用split(substr)去分割字串，分割数-1就是出现的次数，如果substr出现在末尾，则需要加回去。

37. 组最大数字

给出几组字符串的数字，需要获得组成的最大数字

比如输入123，546，8，32，输出854632123

import java.util.Scanner;
import java.util.HashMap;
import java.util.List;
import java.util.Arrays;
import java.util.ArrayList;
import java.util.stream.Collectors;
import java.util.Scanner;

public class Main{
public static void main(String[] args) {
//String str ="wr0068,lt01,qhy0027828,gh20425256,xj0033258,zmj00505562";
Scanner in = new Scanner(System.in);
String src_str = in.nextLine();
String[] str = src_str.split(",");
int[] intStr = new int[str.length];
for(int i=0; i<intStr.length; i++){
intStr[i] = Integer.parseInt(str[i]);
}
//System.out.println("" + Arrays.toString(intStr));

bubbleSort(intStr);
//System.out.println("" + Arrays.toString(intStr));
StringBuilder sb = new StringBuilder();

for(int j=intStr.length -1; j>=0; j--){
sb.append(""+intStr[j]);
}
System.out.println(sb.substring(0));
}
/*自定义比较两个整数大小*/
private static boolean bigger(int num1,int num2) {
//取整数第一位进行比较,如果第一位整数相等，则取第2位比较，一次类推
int[] temp1 = new int[10];
int[] temp2 = new int[10];
int end1 = 0;
int end2 = 0;
for(int i = 0; i<10; i++){
if(num1/10 != 0)
{
temp1[i] = num1%10;
num1 = num1/10;
}else{
temp1[i] = num1;
end1 = i;
break;
}
}
/*
for(int i=0; i<= end1; i++)
{
System.out.println("temp1:" + temp1[i] + "end1:" + end1);
}*/

for(int i = 0; i<10; i++){
if(num2/10 != 0)
{
temp2[i] = num2%10;
num2 = num2/10;
}else{
temp2[i] = num2;
end2 = i;
if(num2 == 8)
//System.out.println("end2:" + end2);
break;
}
}

//以下的比较是比较整数后三位大小
/*
String s = num1 + "";
int length = s.length();
// 如果数的长度大于3，截取最后三位
if (length > 3)
num1 = Integer.parseInt(s.substring(length - 3, length));
s = num2 + "";
length = s.length();
if (length > 3)
num2 = Integer.parseInt(s.substring(length - 3, length));
*/
int i=end1;
int j=end2;
boolean isBig = false;
for(; i>=0&&j>=0; i--,j--){
if(temp1[i] > temp2[j]){
//System.out.println("temp1:" + temp1[i] + ">" + "temp2:" + temp2[j] + ", true");
isBig = true;
break;
}else if(temp1[i] == temp2[j]){
continue;
}
else{
//System.out.println("temp1:" + temp1[i] + ">" + "temp2:" + temp2[j] + ", false");
//System.out.println("temp1 < temp2, false");
isBig = false;
break;
}
}
//System.out.println("return default:" + isBig);
return isBig;

}

/**
* 冒泡排序
*/
private static int [] bubbleSort(int a[]){
int length=a.length;
for(int i=0;i<length;i++)
for(int j=1;j<length-i;j++){
// 利用自定义的比较大小函数，如果前一个数比后一个数大，则两数交换，相等不交换，保证其稳定性
if(bigger(a[j-1], a[j]))
{
int tmp=a[j];
a[j]=a[j-1];
a[j-1]=tmp;
}

}

return a;
}
}

38. 求一个二叉树是否为平衡树

import java.util.Scanner;
import java.util.HashMap;
import java.util.List;
import java.util.Arrays;
import java.util.ArrayList;
import java.util.stream.Collectors;
import java.util.Scanner;
import java.lang.Math;

public class Main{
public static void main(String[] args) {

}

class TreeNode{
int value;
TreeNode left;
TreeNode right;
public TreeNode(int value){
this.value = value;
}
}

public boolean isBalanceTree(TreeNode rootNode){
if(rootNode == null)
{
return true;
}else if(Math.abs(getTreeDeepth(rootNode.left)- getTreeDeepth(rootNode.right)) > 1 ){
return false;
}else{
return isBalanceTree(rootNode.left)&&isBalanceTree(rootNode.right);
}
}

private int getTreeDeepth(TreeNode rootNode){
if(rootNode == null)
{
return 0;
}else{
int left = getTreeDeepth(rootNode.left);
int right = getTreeDeepth(rootNode.right);
int result = left>right?left+1:right+1;
return result;
}
}
}
```
39. 金字塔
微商模式比较典型，下级每赚100元就要上交15元，给出每个级别的收入，求出金字塔尖上的人收入

比如

（代理商代号）  （上级代理商代号）  （代理商转的钱）

1                  0                    223

2                  0                    323

3                  2                    1203

输出是0（金字塔顶代理商）105 （最终的钱数）
————————————————
版权声明：本文为CSDN博主「傻X」的原创文章，遵循CC 4.0 BY-SA版权协议，转载请附上原文出处链接及本声明。
原文链接：https://blog.csdn.net/tiger9991/article/details/107037724
```
import java.util.Scanner;
import java.util.HashMap;
import java.util.List;
import java.util.Arrays;
import java.util.ArrayList;
import java.util.stream.Collectors;
import java.util.Scanner;
import java.lang.Math;

public class Main{
public static void main(String[] args) {
Scanner in = new Scanner(System.in);
int n = 10;
String[] src_str = new String[10];
int[] money = new int[10];
for(int i =0; i<n; i++)
{
src_str[i] = in.nextLine();
String[] temp = src_str[i].split(" ");
money[i] = Integer.parseInt(temp[2]);
}

int layer = 0;
int cur_count = 0;
for(; cur_count<=n;){
cur_count += Math.pow(2, layer);
//j=j*2
layer++;
}

int array1[] = new int[2];
int array2[] = new int[4];
int array3[] = new int[8];
/*
int array4[] = new int[16];
int array5[] = new int[32];
int array6[] = new int[64];*/

for(int i=0; i<2; i++){
array1[i] = money[i+1];
}
for(int i=0; i<4; i++){
array2[i] = money[i+3];
}
for(int i=0; i<3; i++){
array3[i] = money[i+7];
}
/*
for(int i=0; i<16; i++){
array4[i] = money[i+15];
}
for(int i=0; i<32; i++){
array5[i] = money[i+31];
}
for(int i=0; i<38; i++){
array6[i] = money[i+63];
}*/

double result = getSumPerLayer(array1, 1) + getSumPerLayer(array2, 2) + getSumPerLayer(array3, 3); /*+ getSumPerLayer(array4, 4)
+ getSumPerLayer(array5, 5) + getSumPerLayer(array6, 6);*/

System.out.println((int)result);

}

private static double getSumPerLayer(int[]array, int layer){
double sum=0;
for(int i=0; i<array.length; i++){
sum += array[i];
}
sum = sum*Math.pow(0.15, layer);
return sum;
}

}

40. 特殊计算

特殊符号代替普通的计算方式比如x#y = 2*x+y，x$y = x+3y，#优先级高于$

比如输入5#2$6 输出结果就是30，因为先算5#2 = 12，再算12$6=30

import java.util.Scanner;
import java.util.HashMap;
import java.util.List;
import java.util.Arrays;
import java.util.ArrayList;
import java.util.stream.Collectors;
import java.util.Scanner;
import java.lang.Math;

public class Main{
public static void main(String[] args) {
Scanner in = new Scanner(System.in);
String str = in.nextLine();
String[] strDividedByDolor = str.split("\$");
/*for(int j =0 ;j < 2; j++){
System.out.println("strbydolor:" + strDividedByDolor[j]);
}*/
String[] strDividedByHash = new String[10];
int i = 0;
int[] firsStepInt = new int[strDividedByDolor.length];
int result = 0;
for(String temp:strDividedByDolor){
strDividedByHash = temp.split("#");

if(strDividedByHash.length>1){
firsStepInt[i] = operator_hash(Integer.parseInt(strDividedByHash[0]), Integer.parseInt(strDividedByHash[1]));
i++;
}else{
firsStepInt[i] = Integer.parseInt(temp);
i++;
}
}
result = operator_dolor(firsStepInt[0], firsStepInt[1]);
System.out.println(result);

}

private static int operator_hash(int left, int right){
return 2*left + right;
}

private static int operator_dolor(int left, int right){
return left+3*right;
}

}

41 .
```
能量消耗

给出一批用户，每个用户有3种选择ABC，但是价值不同，相临的用户不能选同一个，求出所有用户选择后总价值最大。

3个用户

30 8 4

50 20 9

11 7 6

输出65，因为选8 50 7
```
import java.util.Scanner;
import java.util.HashMap;
import java.util.List;
import java.util.Arrays;
import java.util.ArrayList;
import java.util.stream.Collectors;
import java.util.Scanner;
import java.lang.Math;
import java.util.Collections;
import java.util.Comparator;

public class Main{
public static void main(String[] args) {
Scanner in = new Scanner(System.in);
int people_num = in.nextInt();
int[][] matrix = new int[people_num][3];
ArrayList<Integer> integerList = new ArrayList<Integer>();
for(int i=0; i<people_num; i++){
for(int j=0; j<3; j++)
{
matrix[i][j] = in.nextInt();
integerList.add(matrix[i][j]);
}
}

Collections.sort(integerList, new Comparator<Integer>(){
@Override
public int compare(Integer a, Integer b){
return b-a;
}
});
/*for(Integer a: integerList){
System.out.println(a);
}*/

int[] target = new int[3];
int cusor = 2;
boolean flag = true;
for(int i=0; i<3; i++){
target[i] = integerList.get(i);
}
while(flag){
if(isTheSameRow(target[0], target[1], matrix) || isTheSameRow(target[1], target[2], matrix) || isTheSameRow(target[0], target[2], matrix)){
flag = true;
if((cusor+1) < integerList.size()){
target[2] = integerList.get(cusor+1);
cusor++;
continue;
}else{
break;
}
}else{
flag = false;
}

if(isTheSameList(target[0], target[1], matrix) || isTheSameList(target[1], target[2], matrix) || isTheSameList(target[0], target[2], matrix)){
flag = true;
if((cusor+1) < integerList.size()){
target[2] = integerList.get(cusor+1);
cusor++;
continue;
}else{
break;
}
}else{
flag = false;
}
}

int result=0;
for(int i=0; i<3; i++){
result += target[i];
}
System.out.println(result);

}

private static boolean isTheSameRow(int a, int b, int[][] matrix){
int i = 0; //int mark;
loops: for(;i<matrix.length; i++){
for(int j=0; j<3; j++){
if(matrix[i][j] == a){
//mark = i;
break loops;
}
}
}
int[] row = matrix[i];
for(int j=0; j<3; j++){
if(row[j] == b){
return true;
}
}
return false;
}

private static boolean isTheSameList(int a, int b, int[][] matrix){
int j = 0; //int mark;
loops: for(; j<3; j++){
for(int i=0;i<matrix.length; i++){
if(matrix[i][j] == a){
//mark = i;
break loops;
}
}
}
int[] list = new int[matrix.length];
for(int i=0; i<matrix.length; i++){
list[i] = matrix[i][j];
if(list[i] == b){
return true;
}
}
return false;
}
}

42. 数组元素划分

给出一个数组，按照这种规则划分，规则是在同一类里的都能被这个类里的最小的数字整除。

比如[2,3,4]，输出是2个类划分，即[2,4]和[3]。

import java.util.Scanner;
import java.util.HashMap;
import java.util.List;
import java.util.Arrays;
import java.util.ArrayList;
import java.util.stream.Collectors;
import java.util.Scanner;
import java.lang.Math;
import java.util.Collections;
import java.util.Comparator;

public class Main{
public static void main(String[] args) {
Scanner in = new Scanner(System.in);
String integers = in.nextLine();
String[] src_str = integers.split(",");
int[] src_int = new int[src_str.length];
for(int i = 0; i<src_str.length; i++){
src_int[i] = Integer.parseInt(src_str[i]);
}

ArrayList<Integer> integerList = new ArrayList<Integer>();
for(int i=0; i<src_int.length; i++){
integerList.add(src_int[i]);
}

Collections.sort(integerList, new Comparator<Integer>(){

@Override
public int compare(Integer a, Integer b){
return a-b;
}
});
for(int i = 0; i<src_str.length; i++)
{
//System.out.println(integerList.get(i));
}
//int[][] category = new int[10][10];
int original_min = integerList.get(0);

ArrayList<ArrayList<Integer>> result = new ArrayList<ArrayList<Integer>>();
ArrayList<Integer> first = new ArrayList<Integer>();
ArrayList<Integer> second = new ArrayList<Integer>();
ArrayList<Integer> third = new ArrayList<Integer>();
ArrayList<Integer> fourth = new ArrayList<Integer>();
ArrayList<Integer> fifth = new ArrayList<Integer>();
ArrayList<Integer> sixth = new ArrayList<Integer>();
ArrayList<Integer> seventh = new ArrayList<Integer>();
ArrayList<Integer> eighth = new ArrayList<Integer>();
ArrayList<Integer> nineth = new ArrayList<Integer>();
ArrayList<Integer> tenth = new ArrayList<Integer>();

//first.add(original_min);
int i = 0;
for(Integer temp: integerList){
if(first.size() == 0){
first.add(integerList.get(i));
}else if(integerList.get(i)%original_min == 0){
first.add(integerList.get(i));
}else if((second.size() == 0) || (integerList.get(i)%second.get(0) == 0)){
second.add(integerList.get(i));
}
else if((third.size() == 0) || (integerList.get(i)%third.get(0) == 0)){
third.add(integerList.get(i));
}else if(fourth.size() == 0 || (integerList.get(i)%fourth.get(0) == 0)){
fourth.add(integerList.get(i));
}else if(fifth.size() == 0 || (integerList.get(i)%fifth.get(0) == 0)){
fifth.add(integerList.get(i));
}else if(sixth.size() == 0 || (integerList.get(i)%sixth.get(0) == 0)){
sixth.add(integerList.get(i));
}else if(seventh.size() == 0 || (integerList.get(i)%seventh.get(0) == 0)){
seventh.add(integerList.get(i));
}else if(eighth.size() == 0 || (integerList.get(i)%eighth.get(0) == 0)){
eighth.add(integerList.get(i));
}else if(nineth.size() == 0 || (integerList.get(i)%nineth.get(0) == 0)){
nineth.add(integerList.get(i));
}else if(tenth.size() == 0 || (integerList.get(i)%tenth.get(0) == 0)){
tenth.add(integerList.get(i));
}
i++;
}

result.add(first);
result.add(second);
result.add(third);
result.add(fourth);
result.add(fifth);
result.add(sixth);
result.add(seventh);
result.add(eighth);
result.add(nineth);
result.add(tenth);

for(ArrayList list: result){
System.out.println(list);
}
}
}

43.
```
8、到达终点

给定一个数组，从第一个开始，正好走到数组最后，所使用的最少步骤数。要求：

第一步从第一元素开始，第一步小于<len/2（len为数组的长度）。从第二步开始，只能以所在成员的数字走相应的步数，不能多也不能少, 如果目标不可达返回-1，输出最少的步骤数，不能往回走。

输入7 5 9 4 2 6 8 3 5 4 3 9输出2

输入1 2 3 7 1 5 9 3 2 1输出-1
```
//对于这种刚好到达终点求步数的算法，可以利用递归来写。

import java.util.Scanner;
import java.util.HashMap;
import java.util.List;
import java.util.Arrays;
import java.util.ArrayList;
import java.util.stream.Collectors;
import java.util.Scanner;
import java.lang.Math;
import java.util.Collections;
import java.util.Comparator;

public class Main{

private static int counter = 1;

public static void main(String[] args) {
Scanner in = new Scanner(System.in);
String integers = in.nextLine();
String[] src_str = integers.split(",");
int[] src_int = new int[src_str.length];
for(int i = 0; i<src_str.length; i++){
src_int[i] = Integer.parseInt(src_str[i]);
}
int result = -1;
//int counter = 0;

int limit = src_int.length/2;
ArrayList<Integer> resultList = new ArrayList<Integer>();

for(int i = 0; i<limit; i++){
counter = 1;
result = stepIn(src_int.length, src_int, i, counter);
if(result != -1)
resultList.add(result);
}

Collections.sort(resultList, new Comparator<Integer>(){
@Override
public int compare(Integer a, Integer b){
return a-b;
}
});

if(resultList.size() > 0){
if(resultList.get(0) == 1){
System.out.println(resultList.get(1));
}else{
System.out.println(resultList.get(0));
}
}else if(result == -1){
System.out.println(result);
}

}

private static int stepIn(int total_length, int[] src_int, int original, int counter){
int length = total_length;
int[] integer = src_int;
int stepValue = 0;
//int i = original;

counter++;
stepValue = src_int[original];

/*
if(original == 5)
{
System.out.println("original:" + original + "stepValu:" + stepValue);
}*/
if(original + stepValue == total_length-1){
return counter;
}else if(original + stepValue > total_length-1){
return -1;
}else{
original = original + stepValue;
return stepIn(length, integer, original, counter);
}
}
}

44. 数字分解

给你一个数可以分解成几组的连续的自然数之和？

比如8可以分解成8，即1组，比如6可以分解成6,123，即2组。

//类似的数字求和，数字分解，步数求和，步数分解都可以采用递归调用来实现

import java.util.Scanner;
import java.util.HashMap;
import java.util.List;
import java.util.Arrays;
import java.util.ArrayList;
import java.util.stream.Collectors;
import java.util.Scanner;
import java.lang.Math;
import java.util.Collections;
import java.util.Comparator;

public class Main{

private static int counter = 0;

public static void main(String[] args) {
Scanner in = new Scanner(System.in);
int target = in.nextInt();

int sum;
int result = -1;
int numOfMatched = 0;

for(int i = 1; i <= target; i++){
sum = 0;
result = plusContinuous(sum, i, target);
if(result != -1){
numOfMatched++;
}
}

if(numOfMatched != 0){
System.out.println(numOfMatched);
}

}

private static int plusContinuous(int sum, int b, int target){
counter++;
if(sum+b == target){
return counter;
}else if(sum+b > target){
return -1;
}else{
sum = sum + b;
b++;
return plusContinuous(sum, b, target);
}
}
/*
private static int stepIn(int total_length, int[] src_int, int original, int counter){
int length = total_length;
int[] integer = src_int;
int stepValue = 0;
//int i = original;

counter++;
stepValue = src_int[original];

//if(original == 5)
//{
//System.out.println("original:" + original + "stepValu:" + stepValue);
//}
if(original + stepValue == total_length-1){
return counter;
}else if(original + stepValue > total_length-1){
return -1;
}else{
original = original + stepValue;
return stepIn(length, integer, original, counter);
}
}*/
}

45. java循环链表的创建之一：

可以借助ConcurrentLinkedQueue这个类，它本身继承自List来做的，但是保持先进先出的特点

稍加修改可以接成一个环。

import java.util.Scanner;
import java.util.HashMap;
import java.util.List;
import java.util.Arrays;
import java.util.ArrayList;
import java.util.stream.Collectors;
import java.util.Scanner;
import java.lang.Math;
import java.util.Collections;
import java.util.Comparator;
import java.util.concurrent.ConcurrentLinkedQueue;
import java.util.Iterator;

public class Main{

private static int counter = 0;
private CircularLinkedList linkedList = new CircularLinkedList();

public static void main(String[] args) {
Scanner in = new Scanner(System.in);
int target = in.nextInt();
Main obj = new Main();
int sum;
int result = -1;
int numOfMatched = 0;

obj.linkedList.add(3);
obj.linkedList.add(4);
obj.linkedList.add(5);
obj.linkedList.add(6);

//obj.linkedList.print();
for(int i=0; i<8; i++)
{
System.out.println(obj.linkedList.next());
}

}

public class CircularLinkedList<Integer>{
private ConcurrentLinkedQueue<Integer> list;
private Iterator<Integer> iterator;

public CircularLinkedList(){
list = new ConcurrentLinkedQueue<>();
iterator = list.iterator();
}
/*
public void print(){
if(iterator.hasNext()){
System.out.println("iterator.next:" + iterator.next());
}else{
iterator = list.iterator();
System.out.println("iterator has no next");
if(!iterator.hasNext()){
System.out.println("iterator has no next again");
}else{
System.out.println("iterator.next:" + iterator.next());
}
}
System.out.println(list);
}*/

public Integer next(){
if(!iterator.hasNext()){
iterator = list.iterator();
}
return iterator.next();
}

public void add(Integer a){
list.add(a);
}
}

}

46. 喊7的次数重排

喊7是一个传统的聚会游戏，N个人围成一圈，按顺时针从1到N编号。编号为1的人从1开始喊数，下一个人喊的数字为上一个人的数字加1，但是当数字是7的倍数或者数字本身含有7的话，要喊"过"。现给定一个长度为N的数组，存储了打乱顺序的每个人喊"过"的次数，请把它还原成正确的顺序，即数组的第i个元素存储编号i的人喊"过"的次数。

输入为一行，为空格分隔的喊"过"的次数

示例1

输入

0 1 0

输出

1 0 0

import java.util.Scanner;
import java.util.HashMap;
import java.util.List;
import java.util.Arrays;
import java.util.ArrayList;
import java.util.stream.Collectors;
import java.util.Scanner;
import java.lang.Math;
import java.util.Collections;
import java.util.Comparator;
import java.util.concurrent.ConcurrentLinkedQueue;
import java.util.Iterator;

public class Main{

public static void main(String[] args) {
Scanner in = new Scanner(System.in);
final int [] numRelated7 = {7,14,17,21,27,28,35,37,42,47,49,56,57,63,67,70,71,72,73,74,75,76,77,78,79,84,87,91,97,98};
int peoplesequence[] = new int[10];
int sum = 0;
int i=0;

while(in.hasNextInt()){
peoplesequence[i] = in.nextInt();
i++;
}

System.out.println(peoplesequence);
for(int a : peoplesequence){
sum += a;
}

int[] candicate_nums = new int[sum];
for(int j = 0 ; j< sum; j++)
{
candicate_nums[j] = numRelated7[j];
}

System.out.println("candicate_nums:" + candicate_nums);

int[] resultsequence = new int[i];

for(int k=0; k<sum; k++){
if(candicate_nums[k]%i==1){
if(i>1)
resultsequence[0]++;
}else if(candicate_nums[k]%i==2){
if(i>2)
resultsequence[1]++;
}else if(candicate_nums[k]%i==3){
if(i>3)
resultsequence[2]++;
}else if(candicate_nums[k]%i==4){
if(i>4)
resultsequence[3]++;
}else if(candicate_nums[k]%i==5){
if(i>5)
resultsequence[4]++;
}else if(candicate_nums[k]%i==6){
if(i>6)
resultsequence[5]++;
}else if(candicate_nums[k]%i==7){
if(i>7)
resultsequence[6]++;
}else if(candicate_nums[k]%i==8){
if(i>8)
resultsequence[7]++;
}else if(candicate_nums[k]%i==9){
if(i>9)
resultsequence[8]++;
}
}

for(int temp: resultsequence){
System.out.println(temp);
}

StringBuffer str = new StringBuffer();
for(int m=0; m<resultsequence.length; m++)
{
str.append(resultsequence[m] + " ");
}
String result_str = str.substring(0).trim();
System.out.println(result_str);

}
}

47. 字符串动态规划问题，计算两个字符串的最大公共字串的长度，字符不区分大小写。

题目标题：

计算两个字符串的最大公共字串的长度，字符不区分大小写

详细描述：

接口说明

原型：

int getCommonStrLength(char * pFirstStr, char * pSecondStr);

输入参数：

char * pFirstStr //第一个字符串

char * pSecondStr//第二个字符串

输入：

asdfas
werasdfaswer

输出： 6

import java.util.Scanner;
import java.util.HashMap;
import java.util.List;
import java.util.Arrays;
import java.util.ArrayList;
import java.util.stream.Collectors;
import java.util.Scanner;
import java.lang.Math;
import java.util.Collections;
import java.util.Comparator;
import java.util.concurrent.ConcurrentLinkedQueue;
import java.util.Iterator;
import java.util.regex.Matcher;
import java.util.regex.Pattern;

public class Main {
public static void main(String[] args){
Scanner in = new Scanner(System.in);
String substr = in.nextLine();
String mainstr = in.nextLine();

//String[][] littlestr = new String[substr.length()-1][];
ArrayList<ArrayList<String>> strQueue = new ArrayList<ArrayList<String>>();

for(int left=0; left< substr.length() - 1 ; left++)
{
ArrayList<String> sublist = new ArrayList<String>();
for(int right=substr.length(); right > left; right--){
sublist.add(substr.substring(left,right));
strQueue.add(sublist);
}
}

loop: for(ArrayList<String> temp: strQueue){
for(String str: temp){
if(mainstr.toLowerCase().indexOf(str)>0)
{
System.out.println(str.length());
break loop;
}
}
}
}
}

48. 求一个字串的漂亮度

给出一个名字，该名字有26个字符串组成，定义这个字符串的“漂亮度”是其所有字母“漂亮度”的总和。
每个字母都有一个“漂亮度”，范围在1到26之间。没有任何两个字母拥有相同的“漂亮度”。字母忽略大小写。
给出多个名字，计算每个名字最大可能的“漂亮度”。

输入：
```
zhangsan
lisi
```
输出：

192

101
import java.util.Scanner;
import java.util.HashMap;
import java.util.List;
import java.util.Arrays;
import java.util.ArrayList;
import java.util.stream.Collectors;
import java.util.Scanner;
import java.lang.Math;
import java.util.Collections;
import java.util.Comparator;
import java.util.concurrent.ConcurrentLinkedQueue;
import java.util.Iterator;
import java.util.regex.Matcher;
import java.util.regex.Pattern;

public class Main {
private int[] charcounts = new int[26];

public static void main(String[] args){
Scanner in = new Scanner(System.in);
String str1 = in.nextLine();
String str2 = in.nextLine();
int begin1 = 26;
int begin2 = 26;
int sum1 = 0, sum2 = 0;

Main main1 = new Main();
Main main2 = new Main();

main1.charcounts = main1.charCount(str1);
main2.charcounts = main2.charCount(str2);

ArrayList<Integer> list1 = new ArrayList<Integer>();
ArrayList<Integer> list2 = new ArrayList<Integer>();
for(int i = 0; i < main1.charcounts.length; i++){
list1.add(Integer.valueOf(main1.charcounts[i]));
}

for(int i = 0; i < main2.charcounts.length; i++){
list2.add(Integer.valueOf(main2.charcounts[i]));
}

Collections.sort(list1, new Comparator<Integer>(){
@Override
public int compare(Integer a, Integer b){
return b-a;
}
});

Collections.sort(list2, new Comparator<Integer>(){
@Override
public int compare(Integer a, Integer b){
return b-a;
}
});

for(Integer temp: list1){
sum1 += temp*begin1;
begin1--;
}
for(Integer temp: list2){
sum2 += temp*begin2;
begin2--;
}

System.out.println(sum1);
System.out.println(sum2);

}

public int[] charCount(String str){
int[] charcounts = new int[26];
char[] array = str.toCharArray();
int count = 0;
int j = 0;

for(int i = 0; i<str.length(); i++){
count = str.length() - str.replace(array[i] + "", "").length();
charcounts[j] = count;
str = str.replace(array[i] + "", "");
array = str.toCharArray();
i = -1;
j++;
}
return charcounts;
}

}

49. 围棋走步题（可以抽象成一个逆向坐标来处理）

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

输入：

2 2

输出：

6

import java.util.Scanner;
import java.util.HashMap;
import java.util.List;
import java.util.Arrays;
import java.util.ArrayList;
import java.util.stream.Collectors;
import java.util.Scanner;
import java.lang.Math;
import java.util.Collections;
import java.util.Comparator;
import java.util.concurrent.ConcurrentLinkedQueue;
import java.util.Iterator;
import java.util.regex.Matcher;
import java.util.regex.Pattern;
/**
* 题目描述
请编写一个函数（允许增加子函数），计算n x m的棋盘格子（n为横向的格子数，m为竖向的格子数）沿着各自边缘线从左上角走到右下角，总共有多少种走法，要求不能走回头路，即：只能往右和往下走，不能往左和往上走。
*/

//利用把右下角看成（0，0）坐标，把左上角看成是(100,100)坐标，这样往右走和往下走都是减1.
public class Main {
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
while(sc.hasNext()){
int num1= sc.nextInt();
int num2= sc.nextInt();
System.out.println(methods(num1,num2));
}
}
private static int methods(int a, int b){
if((a == 0) || (b == 0)){//无论那边先到0，都只有1种走法，所以1个数字到0即可返回。
return 1;
}
return methods(a-1, b) + methods(a, b-1);
}
}
相关阅读:
WinForm 清空界面控件值的小技巧
 MVC 图片上传总是request.files.count() 等于0
LinqToSQL 左连接右连接内链接
 C# utc datetime 互相转化
 mvc javascript form.submit()
Java API中文版下载
 jQuery的链式操作
 【转】Eclipse/MyEclipse中使用复制粘贴功能卡的解决办法
 servlet什么时候被实例化？
Jquery总结 $("h3 a", patch);
原文地址：https://www.cnblogs.com/rainey-forrest/p/13337978.html

华为牛客笔试题

三、思路分析

逢4必过