前言+說明

旺仔兄弟們，這個是拼多多應屆生的筆試，總共四道演算法題，下面由我一一道來，如果覺得博主分享的不錯，希望能留下您的一鍵三連（評論+點贊+收藏），您的支持就是我的動力，您的三連對我特別重要，
注明：下述題目只用于學習交流所用，禁止用于商業銷售，同時在題解方面也希望大家能提出寶貴建議，共同進步！

一、演算法編程題

題目描述

給定N條線段，判斷其中是否存在任意兩條線段a和b，使得線段a完全包含在線段b之中，
例如：線段a = [1 , 3] 完全包含在b =[0 , 4] 之中，端點相同的線段也可以看作包含，例如a = [0 , 3] ， b = [0 ,4]，或者a = [1, 2]，b = [0, 4]，或者a = [1，2]，b = [1,2]，
現在，請你幫助多多寫一個程式完成上述之判定，

輸入描述

第一行，一個整數N，表示線段的數量，（2 <= N <= 10,000）
之后N行，每行兩個數字：Li 和 Ri ，分別表示第 i 個線段的兩個端點，（0 <= Li <= Ri <= 10,000）

輸出描述

共一行，一個字串，
如果存在任意兩條線段滿足其中一條被另一條被另一條包含，則輸出 " true " ，反之則輸出 " false "，
（不包括引號，注意區分大小寫）

示例1

輸入輸出示例僅供除錯，后臺判題資料一般不包含示例

輸入
4
1 3
4 5
7 10
13 18

輸出
false

示例2

輸入輸出示例僅供除錯，后臺判題資料一般不包含示例

輸入
4
2 3
1 9
4 10
5 20

輸出
true

參考代碼：

import java.util.Scanner;

public class Main {
    public static void main(String[] args){
        Scanner sc = new Scanner(System.in);
        int N = sc.nextInt();
        int[][] arr = new int[N][2];
        for (int i=0; i<N; i++){
            for (int j=0; j<2; j++){
                arr[i][j] = sc.nextInt();
            }
        }

        boolean ans = false;//用于存盤結果
        flag:for (int k1=0; k1<N; k1++){
            for (int k2=k1+1; k2<N; k2++) {
                ans = judgle(arr[k1], arr[k2]);
                if (ans){
                    break flag;//如果ans為true直接跳出到flag(兩個for回圈)
                }
            }
        }

        System.out.println(ans);

    }

    public static boolean judgle(int[] a, int[] b){
        if (a[0] >= b[0] && a[1] <= b[1]){
            return true;
        }
        return false;
    }
}

二、演算法編程題

題目描述

多多雞和多多鴨在玩一個紙牌游戲，名字叫做小貓釣魚，游戲規則如下：

起初，多多雞和多多鴨各有N張手牌，手牌的順序是固定的，兩人只能按照順序出牌，多多雞先出：
然后，多多雞和多多鴨輪流在牌桌上以接龍的方式放置卡牌，即放置的卡牌按照先后順序從左到右排成一行；
當某個人放置的一張卡牌的數字在桌牌上已經出現過時，他會把這兩張以及兩張之間的牌收走作為贏得的籌碼，同時需要再放一張手牌接在牌尾；
如果手中已經無牌，則直接跳過，由對方放牌；
當兩人手中都無牌時，游戲結束；
游戲結束時，若牌桌上還有剩余的牌，則多多雞取走牌面為奇數的牌作為籌碼，多多鴨取走牌面為偶數的牌作為籌碼；

最后籌碼數多的人獲勝，兩者籌碼一樣多則平局，

請問最后多多雞和多多鴨各能獲取多少籌碼？

輸入描述

共3行，
第一行，一個整數 N
第二行，N 個整數 a, …a…，用空格隔開，表示多多雞的手牌數字
第三行，N 個整數 b, …b…，用空格隔開，表示多多鴨的手牌數字

輸出描述

共一行，一個字串，
如果存在任意兩條線段滿足其中一條被另一條被另一條包含，則輸出 " true " ，反之則輸出 " false "，
（不包括引號，注意區分大小寫）

示例1

輸入輸出示例僅供除錯，后臺判題資料一般不包含示例

輸入
2
1 1
2 2

輸出
3 1

示例2

輸入輸出示例僅供除錯，后臺判題資料一般不包含示例

輸入
4
1 2 3 4
5 6 7 8

輸出
4 4

參考代碼

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

public class Main {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        int N = sc.nextInt();
        int[][] arr = new int[2][N];
        for (int i = 0; i < 2; i++) {
            for (int j = 0; j < N; j++) {
                arr[i][j] = sc.nextInt();
            }
        }
        //多多雞手上的牌
        List<Integer> chickenList = Arrays.stream(arr[0]).boxed().collect(Collectors.toList());
        //多多鴨手上的牌
        List<Integer> duckList = Arrays.stream(arr[1]).boxed().collect(Collectors.toList());

        List<Integer> list = new ArrayList<Integer>();//用于存放桌面上的牌
        int num = 0;//記錄最后桌上的牌面陣列

        int[] ans = new int[2];//用于記錄多多雞和多多鴨的最終成績，
        //兩者手中都無牌時，退出
        while(!chickenList.isEmpty() || !duckList.isEmpty()){
            //多多雞先出
            if (!chickenList.isEmpty()){
                if (list.contains(chickenList.get(0))) {
                    list.add(chickenList.remove(0));
                    ans[0] += caculate(list);
                }else if (!chickenList.isEmpty()){
                    list.add(chickenList.remove(0));
                }


            }
            if(!duckList.isEmpty()){//多多鴨后出
                if (list.contains(duckList.get(0))){
                    list.add(duckList.remove(0));
                    ans[1] += caculate(list);
                }else if (!duckList.isEmpty()){
                    list.add(duckList.remove(0));
                }
            }
        }
        //多多雞和多多鴨牌全部出完后，桌面上還有牌
        while (!list.isEmpty()){
            num = list.remove(0);
            if (num%2 == 1){
                ans[0]++;
            }else{
                ans[1]++;
            }
        }
        System.out.println(Arrays.toString(ans));

    }

    public static int caculate(List<Integer> list){
        int len = list.size();
        int last = list.get(len-1);
        while(list != null){
            list.remove(list.size() - 1);
            if (last == list.get(list.size()-1)){
                list.remove(list.size()-1);
                return len - list.size();
            }
        }
        return 0;
    }
}

三、演算法編程題

題目描述

多多君最近在研究無限數字集合，其中一種生成無限數字集合的方式是：

1.初始狀態集合中只有一個種子元素A，
2.對于集合中的每個元素X，有X + B也屬于該集合，
3.對于集合中的每個元素X，有X * C也屬于該集合，
多多君想知道，對于給定的引數A、B和C，數字Q是否屬于該集合，

輸入描述

第一行，一個整數T，表示測驗用例的組數，（1 <= T <= 100）
對于每組測驗用例，分別各一行，每行四個整數：A，B，C和Q，分別代表無限集合的引數和需要進行判斷的數字，（1 <= A，B，C，Q <= 1,000,000,000）

輸出描述

對于每組測驗資料：
輸出一行，若Q屬于該無限集合則輸出1，否則輸出0，

示例1

輸入輸出示例僅供除錯，后臺判題資料一般不包含示例

輸入
3
1 2 3 5
2 3 2 10
3 3 3 7

輸出
1
1
0

說明

第一組用例：5 = 1 * 3 + 2，屬于該集合，
第二組用例：10 = (2 + 3) * 2，屬于該集合，
第三組用例：集合中的元素從小到大分別為：3，6，9，12 … 均為3的倍數，故7不屬于該集合，

參考代碼

import java.util.*;
public class Main {
    public static void main(String[] args){
        Scanner sc = new Scanner(System.in);
        int N = sc.nextInt();
        int[][] arr = new int[N][4];

        for (int i=0; i<N; i++){
            for (int j=0; j<4; j++){
                arr[i][j] = sc.nextInt();
            }
        }

        for (int[] row : arr){
            if (conclude(row)){
                System.out.println(1);
            }else {
                System.out.println(0);
            }
        }
    }

    public static boolean conclude(int[] row){
        List<Integer> list = new ArrayList<Integer>();
        list.add(row[0]);
        int first = list.get(0);
        while (!list.isEmpty()){
            if (first > row[3]){
                return false;
            }else if(first == row[3]){
                return true;
            }
            list.add(first + row[1]);
            list.add(first * row[2]);
            first = list.remove(0);
        }
        return false;
    }
}

四、演算法編程題

題目描述

多多最近在研究乘法，現在他拿到了一堆數字，他可以把這堆數字任意排列并組成一個乘法算式，他想知道怎么排列組合，能讓最終乘出來的結果最大，

輸入描述

共一行，10個整數，分別表示0到9的數量，保證每個數字的數量不超過100，并且總數量不小于2，

輸出描述

共一行，一個整數，表示輸出來的結果的最大值，

示例1

輸入輸出示例僅供除錯，后臺判題資料一般不包含示例

輸入
0 4 0 0 0 0 0 0 0 0

輸出
121

說明

11 * 11 = 121

示例2

輸入輸出示例僅供除錯，后臺判題資料一般不包含示例

輸入
2 3 0 1 0 0 0 0 0 0

輸出
3100 * 11 = 34100

備注

對于20%的測驗資料，每個數字的數量不超過2，

參考代碼（一）

//硬計算出來
import java.util.Scanner;

public class Main {
    public static void main(String[] args){
        Scanner sc = new Scanner(System.in);
        int[] arr = new int[10];
        long[] ansArr = new long[2];//結果數值int型可能不夠
        long[] tempArr = new long[2];
        long maxNum = 0L;//存盤最大結果

        for (int i=0; i<10 ; i++){
            arr[i] = sc.nextInt();
        }

        for (int j=arr.length-1; j>0; j--){
            if (arr[j] != 0){
                tempArr = ansArr;
                ansArr = merge(arr[j],j,tempArr);
            }
        }

        if (arr[0] != 0){
            ansArr[0] = mergeZero(ansArr[0],arr[0]);
        }

        maxNum = new Long(ansArr[0] * ansArr[1]);
        System.out.println(maxNum);

    }

    private static long mergeZero(long ans, int num) {
        for (int i=0; i<num;i++){
            ans *= 10;
        }
        return ans;
    }

    public static long[] merge(int num, int index, long[] tempArr){
        if (num%2 == 0){
            for (int i=1; i<=num; i++){
                if (i%2 == 1){
                    tempArr[0] = tempArr[0]*10 + index;
                }else {
                    tempArr[1] = tempArr[1]*10 + index;
                }
            }
        }else{
            if (tempArr[0] <= tempArr[1]){
                for (int i=1; i<=num; i++){
                    if (i%2 == 1){
                        tempArr[0] = tempArr[0]*10 + index;
                    }else {
                        tempArr[1] = tempArr[1]*10 + index;
                    }
                }
            }else {
                for (int i=1; i<=num; i++){
                    if (i%2 == 1){
                        tempArr[1] = tempArr[1]*10 + index;
                    }else {
                        tempArr[0] = tempArr[0]*10 + index;
                    }
                }
            }

        }
        return tempArr;
    }
}

參考思路（二）

可將上述tempArr[0]和tempArr[1]按List集合方式存盤，List中的元素都是0~9的數，相乘的結果以List集合逆序形式存盤，有進位時：將進位數值加到下一個陣列元素中，依次類推進行陣列元素添加，最后將結果List集合數字按順序輸出的拼接數即為正確結果，解決了結果長度限制，