華為牛客筆試題

本文轉載自查看原文 2020-07-18 22:50 1340

先來了解時間和空間復雜度。

時間復雜度：
一般情況下，算法中基本操作重復的次數就是問題規模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",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 ('\0' == *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;

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,F,F,G

輸出

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。

輸入

輸出

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：輸入

輸出：

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.

輸出

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\n",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. 求一個二叉樹是否為平衡樹

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

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

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種選擇A\B\C，但是價值不同，相臨的用戶不能選同一個，求出所有用戶選擇后總價值最大。

3個用戶

30 8 4

50 20 9

11 7 6

輸出65，因為選8 50 7

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]。

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

//對於這種剛好到達終點求步數的算法，可以利用遞歸來寫。

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組。

//類似的數字求和，數字分解，步數求和，步數分解都可以采用遞歸調用來實現

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來做的，但是保持先進先出的特點

稍加修改可以接成一個環。

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

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

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

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

輸出：

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

免責聲明！

本站轉載的文章為個人學習借鑒使用，本站對版權不負任何法律責任。如果侵犯了您的隱私權益，請聯系本站郵箱yoyou2525@163.com刪除。

猜您在找 牛客網—java筆試題牛客網筆試題整理 SQL筆試題(牛客網) 2017今日頭條前端筆試題（牛客網）牛客網--華為機試題相關知識（未完）算法題14 小Q歌單，牛客網，騰訊筆試題算法題15 安排機器牛客網，騰訊筆試題算法題16 貪吃的小Q 牛客網騰訊筆試題算法題 17 紙牌游戲牛客網騰訊筆試題【筆試題】2020華為筆試