深信服2018校園招聘C++工程師程式設計題

阿新 • • 發佈：2019-01-10

深信服2017的校園招聘的題目和這次的幾乎一樣，不知道貴公司是什麼樣的想法。做過2017的題目的同學應該會比較佔優勢。題目不難，比較考驗程式設計的技巧與準確度。

第一題：堆排序

題目：

函式heap_sort使用堆排序的方法對陣列arr進行排序，排序後的資料為降序，相關的程式碼如下，請補充確實的部分。

//  調整為小頂堆
static void heap_arrange(int arr[], int cur, int cnt)  //調整為小頂堆
{
    int heaptop_val = arr[cur]; //堆頂的值
    while (cur < cnt) {
        int 
 left = 2 * cur + 1;
        int right = 2 * cur + 2;
        int min = -1;
        int min_val = ________;
        if (left < cnt && arr[left] < min_val) { //檢查是否比左節點大
            min = left;
            min_val = arr[left];
        }
        if (right < cnt && arr[right] < min_val) {//檢查是否比右節點大 

            min = right;
        }
        if (min == ________)
            break;
        arr[cur] = ________;
        cur = ________;
    }
    arr[cur] = ________;
}

解析：

堆排序的原理就是樹上的插入排序，因此，堆排序的原理還是要準確理解的，這樣才能填出來，既然是插入排序，那麼，min_val就一直是heaptop_val；min_val與左右兩個孩子比較得出最小的那個元素，如果最小的元素還是heaptop_val

那麼min的值就沒變，仍然是-1，這個時候插入排序結束，找到了插入的位置就跳出；否則的話就把左右孩子最小的那個結點賦值給當前節點，故arr[cur] = arr[min]，更新當前節點cur = min；最後，把heaptop_val調到要插入的位置，即arr[cur] = heaptop_val。

程式碼：

//  調整為小頂堆
static void heap_arrange(int arr[], int cur, int cnt)  //調整為小頂堆
{
    int heaptop_val = arr[cur]; //堆頂的值
    while (cur < cnt) {
        int left = 2 * cur + 1;
        int right = 2 * cur + 2;
        int min = -1;
        int min_val = heaptop_val;
        if (left < cnt && arr[left] < min_val) { //檢查是否比左節點大
            min = left;
            min_val = arr[left];
        }
        if (right < cnt && arr[right] < min_val) {//檢查是否比右節點大
            min = right;
        }
        if (min == -1)
            break;
        arr[cur] = arr[min];
        cur = min;
    }
    arr[cur] = heaptop_val;
}

第二題：單鏈表氣泡排序

題目：

請實現list_sort，使用冒泡法將head指向的連結串列按val的值大小排成升序。
struct node {
    int val;
    struct node *next;
};

static void list_sort(struct node *head)
{

}

解析：

冒泡法大家都很熟悉，單鏈表來實現無非就是考到連結串列的基本操作，但是這裡我們簡化一下程式碼，也就是說，我們是採用交換兩結點的值的做法而不是交換兩個結點。

冒泡法有兩個迴圈，最裡面的迴圈是排序用的，而最外面的迴圈是排序需要的趟數，排序的趟數也就是連結串列的長度減一(排這麼多趟一定可以排好序，但是不一定需要這麼多)；

這樣一來就要求連結串列的長度，不好，注意到，如果排一趟序無可交換的元素，那麼就說明連結串列已經排好序了，所以，利用這個原理可以設定一個標誌變數f來維護一趟排序中是否有元素的交換，一趟排序後判一下f就可以知道是否跳出最外層的迴圈.

程式碼：

static void list_sort(struct node *head)
{
    //TODO:
    while (true) {
        int f = true;
        struct node * p = head;
        for (;p && p->next; p = p->next)
            if (p->val > p->next->val) {
                f = false;
                int tmp = p->val;
                p->val = p->next->val;
                p->next->val = tmp;
            }
        if (f)
            break;
    }
}

第三題：二進位制位反序

題目：

編寫函式reverse，將val(32位無符號整數)的二進位制位反序，比如，如果val的二進位制表示為1011000011111111，反序後val的二進位制表示為1111111100001101。
unsigned int reverse(unsigned int num)
{

}

解析：

做法很多，我的做法是把一邊去掉最後一位數，一邊生成反序後的十進位制數。

程式碼：

unsigned int reverse(unsigned int num)
{
    //TODO:
    unsigned int ret = 0;
    for (int i = 0; i < 32; i++, num /= 2)
        ret = ret * 2 + num % 2;
    return ret;
}

第四題

題目：

函式match檢查字串str是否匹配模板pattern，匹配則返回0，否則返回-1。

模板支援普通字元(a-z0-9A-Z)及萬用字元?和*，普通字元匹配該字元本身，?匹配任意一個字元，*匹配任意多個字元。比如字串abc對下述模板的匹配結果為：

模板 -結果

abc 0

a* 0

a*c 0

a*b -1

ab? 0

a? -1

請完成該函式程式碼：
int match(const char *str, const char *pattern)
{

}

模板	-結果
`abc`	0
`a*`	0
`a*c`	0
`a*b`	-1
`ab?`	0
`a?`	-1

解析：

由於資料不大，故可以暴力遞迴解決，遞迴的終止條件是：

strlen(str)等於0，並且strlen(pattern)等於0，這時匹配成功；

strlen(str)和strlen(pattern)有且只有一個為0，這時匹配失敗。

如果strlen(str)和strlen(pattern) 都不為0，那麼繼續遞迴：

pattern[0]為?，那麼就判斷pattern + 1和str + 1是否匹配；

pattern[0]位*，那麼判斷pattern + 1和str + i( $0 <= i < s t r l e n (s t r)$ )裡面是否有一個匹配，只要有一個匹配，那麼就匹配了，如果所有的都不匹配，那麼就不匹配了；

pattern[0]為字母或數字，那麼就判斷str[0]和pattern[0]是否相等，如果不相等就不匹配，如果相等，那麼還要判斷pattern + 1和str + 1是否匹配。

這個題還要注意一點，題目給出的輸入函式會把\n也會加入到字串中，因此可以先把\n去掉，不去掉也可以，那麼判斷pattern[0]的時候就要注意順序，先判斷*和?。

程式碼：

int match(const char *str, const char *pattern)
{
    //TODO:
    int str_len = strlen(str), pattern_len = strlen(pattern);
    if (!str_len && !pattern_len)
        return 0;
    if (!pattern_len || !str_len)
        return -1;
    if (pattern[0] == '*') {
        for (int i = 0; str[i]; i++)
            if (0 == match(str + i, pattern + 1))
                return 0;
        return -1;
    } else if (pattern[0] == '?') {
        return match(str + 1, pattern + 1);
    } else {
        return pattern[0] == str[0] ? match(str + 1, pattern + 1) : -1;
    }
}

DIY資料：

// input
abcd
*********************
// output
match

第五題：圍棋的“氣”

題目：

函式calc計算圍棋盤位置(x,y)處的棋子還有多少口氣。

某個位置處的棋子還有多少口氣的計算方法(簡化計算)：從該位置出發，向四個方向遍歷，允許拐彎，但不允許走斜線，如果遇到邊線和對方的棋子，則認為不能繼續往前走。遍歷完成後統計遍歷過程中遇到的未落子的位置個數，該位置個數即出發點棋子的氣的數目。

解析：

首先，這個簡化計算描述就不清楚，注意這句話：如果遇到邊線和對方的棋子，則認為不能繼續往前走，那麼遇到自己的棋子怎麼辦呢？這裡值得思考一下；

如果遇到邊線和對方的棋子和自己的棋子，則認為不能繼續往前走，那麼廣搜一下，看看目標位置能到的位置有多少個，但是我只過了 $66.6 %$ 的資料，不知道哪裡出了問題也不知道我是不是理解錯題目了，於是，我計算了下圍棋真正的氣。

首先找到該棋子的連通塊，然後統計連通塊外圍棋子的個數就是該棋子的氣。

找連通塊我也沒有用廣搜，用的是一種擴散的想法，程式碼類似於這樣子：往目標棋子滴一滴墨水，然後一秒鐘後就會往外擴散，然後下一秒往外擴散，直到擴散不了。具體實現看程式碼。

程式碼：

int calc(struct weiqi *wq, int y, int x)
{
    //TODO:
    if (wq->board[x][y] == NONE)
        return -1;
    enum color nowChess = wq->board[x][y];

    int dirx[] = {0, 0, 1, -1};
    int diry[] = {1, -1, 0, 0};
    int used[19][19] = {0};
    used[x][y] = 1;
    while (true) {
        int f = 0;
        for (int i = 0; i < 19; i++) {
            for (int j = 0; j < 19; j++) {
                if (used[i][j]) {
                    for (int k = 0; k < 4; k++) {
                        int tx = i + dirx[k];
                        int ty = j + diry[k];
                        if (tx >= 0 && tx < 19 && ty >= 0 && ty < 19 &&
                            wq->board[tx][ty] == nowChess && !used[tx][ty])
                            used[tx][ty] = 1, f = 1;
                    }
                }
            }
        }
        if (!f)
            break;
    }
    int ans = 0;
    for (int i = 0; i < 19; i++) {
        for (int j = 0; j < 19; j++) {
            if (used[i][j] == 1) {
                for (int k = 0; k < 4; k++) {
                    int tx = i + dirx[k];
                    int ty = j + diry[k];
                    if (tx >= 0 && tx < 19 && ty >= 0 && ty < 19 &&
                        wq->board[tx][ty] == NONE && used[tx][ty] != 1)
                        used[tx][ty] = 2;
                }
            }
        }
    }
    for (int i = 0; i < 19; i++) {
        for (int j = 0; j < 19; j++) {
            ans += (used[i][j] == 2);
        }
    }
    return ans;
}

DIY資料：

// input
0000000000000000000
0011100000000000000
0001000000000000000
0001111000000000000
0000001000000000000
0000000000000000000
0000000000000000000
0000000000000000000
0000000000000000000
0000000000000000000
0000000000000000000
0000000000000000000
0000000000000000000
0000000000000000000
0000000000000000000
0000000000000110000
0000000000000000000
0000000000000000000
0000000000000000000
2,1
// output
16

五個題完整程式碼：

一、

#include <stdio.h>
#include <stdlib.h>
#include <assert.h>
static void heap_arrange(int arr[], int cur, int cnt);

static int heap_verify(int arr[], int cnt)
{
    int i;
    for (i = 0; i < cnt / 2; ++i) {
        int lhs = 2 * i + 1;
        int rhs = 2 * i + 2;

        if (lhs < cnt && arr[i] > arr[lhs]) {
            fprintf(stderr, "arr[%d]:%d > arr[%d]:%d\n", i, arr[i], lhs, arr[lhs]);
            return -1;
        }
        if (rhs < cnt && arr[i] > arr[rhs]) {
            fprintf(stderr, "arr[%d]:%d > arr[%d]:%d\n", i, arr[i], rhs, arr[rhs]);
            return -1;
        }
    }
    return 0;
}

static void heap_print(int arr[], int cnt)
{
    int layer = 0, num = 0;
    for (layer = 0; num < cnt; ++layer) {
        int i = 0;
        for (i = 0 ; i < (1 << layer) && num < cnt ; ++i)
            printf("%3d ", arr[num++]);
        printf("\n");
    }
}
static void heap_sort(int arr[], int cnt)
{
    int i;

    printf("origin:\n");
    heap_print(arr, cnt);
    //  建堆
    for (i = cnt / 2 - 1; i >= 0; --i) {
        heap_arrange(arr, i, cnt);
    }
    printf("make heap:\n", i);
    heap_print(arr, cnt);
    assert(heap_verify(arr, cnt) == 0);
    for (i = cnt - 1; i > 0; --i) {
        int tmp;
        tmp = arr[0];
        arr[0] = arr[i];
        arr[i] = tmp;
        printf("sort i=%d\n", i);
        heap_print(arr, cnt);
        heap_arrange(arr, 0, i);
        heap_print(arr, cnt);
        assert(heap_verify(arr, i) == 0);
    }
    printf("sorted:\n");
    heap_print(arr, cnt);
}
static int input(int **arr, int *size)
{
    int i;
    int ret;

    ret = fscanf(stdin, "%d\n", size);
    if (ret != 1)
        return -1;
    *arr = (int *)malloc(sizeof(int) * (*size));
    for (i = 0; i < *size; ++i) {
        fscanf(stdin, "%d ", &(*arr)[i]);
    }
    return 0;
}

int main(int argc, char *argv[])
{
    int *arr = NULL;
    int cnt = 0;
    int i;

    if (input(&arr, &cnt) < 0) {
        fprintf(stderr, "input error\n");
        return 0;
    }
    heap_sort(arr, cnt);
    return 0;
}
//  調整為小頂堆
static void heap_arrange(int arr[], int cur, int cnt)  //調整為小頂堆
{
    int heaptop_val = arr[cur]; //堆頂的值
    while (cur < cnt) {
        int left = 2 * cur + 1;
        int right = 2 * cur + 2;
        int min = -1;
        int min_val = heaptop_val;
        if (left < cnt && arr[left] < min_val) { //檢查是否比左節點大
            min = left;
            min_val = arr[left];
        }
        if (right < cnt && arr[right] < min_val) {//檢查是否比右節點大
            min = right;
        }
        if (min == -1)
            break;
        arr[cur] = arr[min];
        cur = min;
    }
    arr[cur] = heaptop_val;
}

二、

#include <stdio.h>
#include <malloc.h>

struct node {
    int val;
    struct node *next;
};

static void list_sort(struct node *head);

struct node *list_create(int arr[], int size)
{
    struct node *head = NULL;
    int i;
    for (i = size - 1; i >= 0; --i) {
        struct node *p = (struct node *)malloc(sizeof(struct node));

        p->val = arr[i];
        p->next = head;
        head = p;
    }
    return head;
}
static void list_print(struct node *head)
{
    for (; head; head = head->next) {
        printf("%d", head->val);
        if (head->next)
            printf(" ");
    }
    printf("\n");
}
static void list_free(struct node *head)
{
    struct node *next;
    while (head) {
        next = head->next;
        free(head);
        head = next;
    }
}
static int input(int **arr, int *size)
{
    int i;
    int ret;

    ret = fscanf(stdin, "%d\n", size);
    if (ret != 1)
        return -1;
    *arr = (int *)malloc(sizeof(int) * (*size));
    for (i = 0; i < *size; ++i) {
        fscanf(stdin, "%d ", &(*arr)[i]);
    }
    return 0;
}

int main(int argc, char *argv[])
{
    struct node *head;
    int *arr = NULL;
    int size = 0;

    if (input(&arr, &size) < 0) {
        fprintf(stderr, "input error\n");
        return 0;
    }
    head = list_create(arr, size);
    list_sort(head);
    list_print(head);
    list_free(head);
    free(arr);
    return 0;
}

static void list_sort(struct node *head)
{
    //TODO:
    while (true) {
        int f = true;
        struct node * p = head;
        for (;p && p->next; p = p->next)
            if (p->val > p->next->val) {
                f = false;
                int tmp = p->val;
                p->val = p->next->val;
                p->next->val = tmp;
            }
        if (f)
            break;
    }
}

三、

#include <stdio.h>
#include <string.h>

unsigned int reverse(unsigned int num)
{
    //TODO:
    unsigned int ret = 0;
    for (int i = 0; i < 32; i++, num /= 2)
        ret = ret * 2 + num % 2;
    return ret;
}

int main(int argc, char *argv[])
{
    unsigned int num = 0;
    unsigned int ret = 0;

    if (1 != fscanf(stdin, "0x%x", &num)) {
        fprintf(stderr, "input error\n");
        return 0;
    }
    ret = reverse(num);
    printf("%08x\n", ret);
    return 0;
}

四、

#include <stdio.h>
#include <string.h>
#include <ctype.h>
#include <malloc.h>

int match(const char *str, const char *pattern)
{
    //TODO:
    int str_len = strlen(str), pattern_len = strlen(str);
    if (!str_len && !pattern_len)
        return 0;
    if (!pattern_len || !str_len)
        return -1;
    if (pattern[0] == '*') {
        for (int i = 0; str[i]; i++)
            if (0 == match(str + i, pattern + 1))
                return 0;
        return -1;
    } else if (pattern[0] == '?') {
        return match(str + 1, pattern + 1);
    } else {
        return pattern[0] == str[0] ? match(str + 1, pattern + 1) : -1;
    }
}

int input(char **src, char **ptn)
{
    char buf[10240];

    *src = NULL;
    *ptn = NULL;
    if (fgets(buf, sizeof(buf), stdin) == 0)
        goto failed_;
    *src = strdup(buf);
    if (fgets(buf, sizeof(buf), stdin) == 0)
        goto failed_;
    *ptn = strdup(buf);
    return 0;
    failed_:
    if (*src)
        free(*src);
    if (*ptn)
        free(*ptn);
    *src = NULL;
    *ptn = NULL;
    return -1;
}

int main(int argc, char *argv[])
{
    char *src = NULL;
    char *ptn = NULL;

    if (input(&src, &ptn) < 0) {
        fprintf(stderr, "error\n");
        return 0;
    }

    if (match(src, ptn) == 0) {
        printf("match\n");
    } else {
        printf("unmatch\n");
    }
    return 0;
}

五、

#include <stdio.h>
#include <string.h>

enum color {
    NONE, WHITE, BLACK,         //棋子顏色，NONE表示未落子
};
struct weiqi {
    enum color board[19][19];   //棋盤上每個位置的落子
};

int calc(struct weiqi *wq, int y, int x)
{
    //TODO:
    if (wq->board[x][y] == NONE)
        return -1;
    enum color nowChess = wq->board[x][y];

    int dirx[] = {0, 0, 1, -1};
    int diry[] = {1, -1, 0, 0};
    int used[19][19] = {0};
    used[x][y] = 1;
    while (true) {
        int f = 0;
        for (int i = 0; i < 19; i++) {
            for (int j = 0; j < 19; j++) {
                if (used[i][j]) {
                    for (int k = 0; k < 4; k++) {
                        int tx = i + dirx[k];
                        int ty = j + diry[k];
                        if (tx >= 0 && tx < 19 && ty >= 0 && ty < 19 &&
                            wq->board[tx][ty] == nowChess && !used[tx][ty])
                            used[tx][ty] = 1, f = 1;
                    }
                }
            }
        }
        if (!f)
            break;
    }
    int ans = 0;
    for (int i = 0; i < 19; i++) {
        for (int j = 0; j < 19; j++) {
            if (used[i][j] == 1) {
                for (int k = 0; k < 4; k++) {
                    int tx = i + dirx[k];
                    int ty = j + diry[k];
                    if (tx >= 0 && tx < 19 && ty >= 0 && ty < 19 &&
                        wq->board[tx][ty] == NONE && used[tx][ty] != 1)
                        used[tx][ty] = 2;
                }
            }
        }
    }
    for (int i = 0; i < 19; i++) {
        for (int j = 0; j < 19; j++) {
            ans += (used[i][j] == 2);
        }
    }
    return ans;
}
int input(struct weiqi *wq, int *x, int *y)
{
    int row, col;
    int ret;
    char buf[80];

    for (row = 0; row < 19; ++row) {
        if (fgets(buf, sizeof(buf), stdin) == NULL)
            return -1;
        if (strlen(buf) < 19)
            return -1;
        for (col = 0; col < 19; ++col) {
            switch (buf[col]) {
                case '0':
                    wq->board[row][col] = NONE;
                    break;
                case '1':
                    wq->board[row][col] = WHITE;
                    break;
                case '2':
                    wq->board[row][col] = BLACK;
                    break;
                default:
                    return -1;
            }
        }
    }
    ret = fscanf(stdin, "%d,%d\n", x, y);
    if (ret != 2)
        return -1;
    for (row = 0 ; row < 19; ++row) {
        for (col = 0; col < 19; ++col) {
            fprintf(stderr, "%d ", wq->board[row][col]);
        }
        fprintf(stderr, "\n");
    }
    fprintf(stderr, "x = %d, y = %d\n", *x, *y);
    return 0;
}

int main()
{
    struct weiqi wq;
    int x = 0, y = 0;
    int cnt;

    memset(&wq, 0, sizeof(wq));
    if (input(&wq, &x, &y) < 0) {
        fprintf(stderr, "error!\n");
        return 1;
    }
    cnt = calc(&wq, x, y);

    printf("%d\n", cnt);
    return 0;
}

深信服2018校園招聘C++工程師程式設計題

深信服2017的校園招聘的題目和這次的幾乎一樣，不知道貴公司是什麼樣的想法。做過2017的題目的同學應該會比較佔優勢。題目不難，比較考驗程式設計的技巧與準確度。第一題：堆排序題目：函式heap_sort使用堆排序的方法對陣列arr進行排

深信服 2019校園招聘研發試卷-2018.09.21

就做出來一道題，慚愧感覺樣例第三個有問題 1 2 3 3 6 9 我覺得應該輸出1 1，可樣例輸出UNKNOWN 以下是錯誤程式碼，0% 實在找不到問題，，，GG #include &l

深信服2018.10.13 C++開發秋招筆試題（第一題）

第一題：記得不太清了，湊合看吧！輸入：第一行：T 表示有T個測試用例以下N行：輸入的T個測試用例測試用例：每個輸入包含四個輸入，a，b，c，n 1<=a,b,c<=9,abc三個值為初始輸入，將它們放到輸出結果中，

OPPO 2019校園招聘C/C++開發工程師(手機方向) 筆試程式設計題-2018.09.10

思路： 1. 分割字串，提取數字 2. multimap儲存 3. 遍歷找到相應結果輸出 #include <iostream> #include <map> #

今日頭條2018校園招聘後端開發工程師(第三批)程式設計題

昨天做了下頭條的後端開發工程師的程式設計題，這編碼量大啊，兩個小時，三個程式設計題，一個改錯題，一個設計題，說實話，很考技術含量，而且程式設計題中有兩個還特別考細心編碼，如果兩個小時能做三個題，確實非常不錯了，寫下解題報告吧，根據自己截的圖和別人截的圖把題還原下

今日頭條2018校園招聘後端開發工程師(第四批)程式設計題

這一場題目還是挺好玩的，也挺有技巧的，這樣的題目做起來才有意思。原題連結：點這兒。第一題：程式設計題1 題目： >有三隻球隊，每隻球隊編號分別為球隊1，球隊2，球隊3，這三隻球隊一共需要進行n 場比賽。現在已經踢完了k場比賽，每場比

網易2018校園招聘程式設計題

[程式設計題] 魔法幣時間限制：1秒空間限制：32768K 小易準備去魔法王國採購魔法神器,購買魔法神器需要使用魔法幣,但是小易現在一枚魔法幣都沒有,但是小易有兩臺魔法機器可以通過投入x(x可以為0)個魔法幣產生更多的魔法幣。魔法機器1:如果投入x個魔法幣,魔法機器會將其變

2018校招面經-深信服-網申-技術服務工程師掛麵

招聘要求筆試試題只有40個選擇，2個簡答，相對於其他公司而言，筆試是相當簡單的。我以為面試也會特別簡單，你以為只是你以為。筆試簡答題目記得一個：身份認證三種技術在真實世界，對使用者的身份認證基本方法可以分為這三種： (1)基於資訊祕密的身份認證根據你所知道

[2018]試卷：網易2018校園招聘程式設計題真題集合

[程式設計題] 魔法幣小易準備去魔法王國採購魔法神器,購買魔法神器需要使用魔法幣,但是小易現在一枚魔法幣都沒有,但是小易有兩臺魔法機器可以通過投入x(x可以為0)個魔法幣產生更多的魔法幣。魔法機器1:如果投入x個魔法幣,魔法機器會將其變為2x+1個魔法幣

迅雷2018演算法工程師-程式設計題-python

1. 用x,y表示一個整數範圍區間，現在輸入一組這樣的範圍區間(用空格隔開)，請輸出這些區間的合併。輸入描述: 一行整數，多個區間用空格隔開。區間的逗號是英文字元。輸出描述: 合併後的區間，用過空格隔開，行末無空格 ''' 1.首先按照x元素排序，把第一個區間存入

平安智慧城市2019校園招聘-演算法工程師筆試題目

1. 請求出 1 + 2！ + 3！ + 4！+ 5！+ ...... + 20！的和。輸入：沒有輸入。輸出：前20個數字階乘的和。輸入樣例：無輸入。輸出樣例

京東2018校園招聘面試題學習

今天早上面試了京東，分享並重溫一下期中的知識點： 1.Java中Integer型和int型的區別： a.Java 中的資料型別分為基本資料型別和引用資料型別。int是基本資料型別，直接存放值，

ThoughtWorks 2018校園招聘作業題目 -- 計程車

題目描述題目僅供技術交流，未經公司允許，不得傳播。題目分析這道題本身不難，按照保養規則模擬即可。但是，對於測試用例二的CAR0001，和CAR0003，根據題目中報廢規則，筆者認為屬於“報廢”。但給出的輸出沒有包含這兩輛車。如

今日頭條2018校園招聘後端方向(9.10)

時間限制：1秒空間限制：65536K 題目描述作為一個手串藝人，有金主向你訂購了一條包含n個雜色串珠的手串——每個串珠要麼無色，要麼塗了若干種顏色。為了使手串的色彩看起來不那麼單調，金主要求，手串上的任意一種顏色（不能包含無色），在任意連續的m個串

2018阿里秋招線上程式設計題（Java開發工程師）

題目：小猴子下山，沿著下山的路有一排桃樹，每棵樹都結了一些桃子。小猴子想摘桃子，但是又一些條件需要遵守，小瘦子只能沿著下山的方向走，不能回頭，每棵樹最多摘一個，而且一旦摘了一棵樹的桃子，就不能再摘比

京東2018實習C++筆試程式設計題

#ifndef jingdongbishi_h #define jingdongbishi_h //求1~N的最小公倍數。把每個數字分解質因數，算他們每個質因數的貢獻，然後乘起來。 //根據唯一分解定理和最小公倍數定理，求每個質數相乘即可 #define maxn 1000

思科2018校園招聘硬體筆試試題及其答案

看到有同學感興趣再分享一篇 1、Which is the Thevenin equivalent for the circuit below? A VO=49+8I B VO=49-8I C&nbs

網易2018校園招聘：字串碎片 [python]

''' [程式設計題] 字串碎片時間限制：1秒空間限制：32768K 一個由小寫字母組成的字串可以看成一些同一字母的最大碎片組成的。例如,"aaabbaaac"是由下面碎片組成的:'aaa','

南方電網2018校園招聘計算機類崗位面試、筆試經歷

先說明一下，南方電網的校園招聘成績計算是面試（60%）+筆試（40%），其中筆試成績必須及格。從網申講起吧，網申每人可選多個單位多個崗位，這個可以參考別人的意見、綜合考慮後再做選擇。填報順序不代表志願順序，志願問題會在面試時再具體問到的。到篩選簡歷階段，

今日頭條2018校園招聘第一題 ---POJ 2479

第一次參加公司的招聘筆試，雖然只是抱著試試水的心態去參加的，可惜的是第一題就做錯了。。。。。第一題，其實只是一個求最大子段和的變式題，不過筆試的時候也不知道怎麼了，就是不知道思路，最後還寫了一個錯的思路題目大意：筆試題是求兩個不相鄰區間的最大子段和， OJ題是不相交區間

深信服2018校園招聘C++工程師程式設計題

第一題：堆排序

題目：

解析：

程式碼：

第二題：單鏈表氣泡排序

題目：

解析：

程式碼：

第三題：二進位制位反序

題目：

解析：

程式碼：

第四題

題目：

解析：

程式碼：

DIY資料：

第五題：圍棋的“氣”

題目：

解析：

程式碼：

DIY資料：

五個題完整程式碼：

一、

二、

三、

四、

五、

相關推薦