题目1：给定两个已经升序排序好的的序列 A={a1,a2,a3,…an} 和 B={b1,b2,b3…bn} ，一个数 R，找出满足以下条件的的(ai,bj)序列对。

1.ai<=bj

2.bj 和 ai 两者的距离 满足 bj-ai<=R , 要是该条件不满足，就从序列 B 中找出 和 ai 距离最接近 R 的一个点 bj(同时要满足条件 1)

输入样例：

A={1,3,5},b={2,4,6},R=1

输出样例：

(1,2)(3,4)(5,6)

遍历所有序列对，找出满足条件的对即可

import syss=sys.stdin.readline()#获取A、B、R的值，用正则表达式匹配会更容易a=s.find('{')b=s.find('}')a_str=s[a+1:b].split(',')A=[int(x) for x in a_str]a=s.rfind('{')b=s.rfind('}')b_str=s[a+1:b].split(',')B=[int(x) for x in b_str]a=s.rfind('=')R=int(s[a+1:])RES=[]for x in A:    has_find=False        for y in B:                if x<= y and y-x<=R:            RES.append((x,y))            has_find=True                elif x<=y and y-x>R and has_find==False:            RES.append((x,y))                        breakfor x in RES:        print('({},{})'.format(x[0],x[1]),end='')

题目2：给出一个不多于 5 位的整数，进行反序处理，要求(1)求出它是几位数(2)分别输出每一个数字(空格隔开)(3)按逆序输出各位数字(仅数字间以空格间隔，负号与数字之间不需要间隔)

输入描述：

位数不大于 5 的整数

输出描述：

1. 整数位数

2. 空格间隔输出结果

3. 逆序整数

#include#includeusing namespace std;int main(){  string str;  char c;  bool sign = false;  while (cin >> str){    int length = str.length();    if (str[0] == '-' || str[0] == '+'){      length--;      c = str[0];      sign = true;      str = str.substr(1, length);    }    cout << length << endl;    for (int i = 0; i < length; i++){      cout << str[i] << " ";    }    cout << endl;    if (sign){      cout << c;    }    for (int i = length - 1; i >= 0; i--){      cout << str[i];    }    cout << endl;  }}

题目3：有一个数组 a [N] 顺序存放 0~N-1，要求每隔两个数删掉一个数，到末尾时循环至开头继续进行，求最后一个被删掉的数的原始下标位置。以 8 个数 (N=7) 为例:｛0，1，2，3，4，5，6，7｝，0->1->2 (删除)->3->4->5 (删除)->6->7->0 (删除), 如此循环直到最后一个数被删除。

输入描述:

每组数据为一行一个整数n(小于等于1000)，为数组成员数,如果大于1000，则对a[999]进行计算。

输出描述:

一行输出最后一个被删掉的数的原始下标位置。

输入例子 1:

8

输出例子 1:

6

首先确定需要输出什么，定义输出变量 resindex, 分析如何做，需什么变量都定义了，最后结束的条件也确定好，循环自然就完成了

#include#includeusing namespace std;int main(){  int N;  while (cin >> N){    vector isdel(N,0);    int resindex;    int num = 0;    int totalnum = N;    while (totalnum>0){      for (int i = 0; i < N; i++){        if (isdel[i]== 0)          num++;        if (num == 3){          isdel[i] = 1;          num = 0;          totalnum--;        }        if (totalnum == 0){          resindex = i;          break;        }      }    }    cout << resindex << endl;  }}

题目4：数学老师想知道从某某同学当中，分数最高的是多少，现在请你编程模拟数学老师的询问。当然，数学老师有时候需要更新某位同学的成绩。

输入描述:

输入包括多组测试数据。

每组输入第一行是两个正整数N和M(0 < N <= 30000,0 < M < 5000),分别代表学生的数目和操作的数目。

学生ID编号从1编到N。

第二行包含N个整数，代表这N个学生的初始成绩，其中第i个数代表ID为i的学生的成绩

接下来又M行，每一行有一个字符C(只取‘Q’或‘U’)，和两个正整数A,B,当C为'Q'的时候, 表示这是一条询问操作，他询问ID从A到B(包括A,B)的学生当中，成绩最高的是多少

当C为‘U’的时候，表示这是一条更新操作，要求把ID为A的学生的成绩更改为B。

输出描述:

对于每一次询问操作，在一行里面输出最高成绩.

输入例子:

5 7

1 2 3 4 5

Q 1 5

U 3 6

Q 3 4

Q 4 5

U 4 5

U 2 9

Q 1 5

输出例子:

5

6

5

9

#include using namespace std;int grades[30000];int max(int x, int y){  int  temp;  temp = grades[x];  for (int i = x+1; i <= y; i++)  {    if (temp    {      temp = grades[i];    }  }  return temp;}int main() {  int N, M, x, y;  char j;  while(cin >> N >> M)        {  for (int i = 0; i < N; i++)  {    cin >> grades[i];   }   for(;M--;)        {    cin >> j >> x >> y;    if (j =='Q')    {            if(x>y)                {                int temp2=y;                y=x;                x=temp2;                         }      int temp = max( x - 1, y - 1);      cout << temp << endl;    }    else if (j =='U')    {      grades[x - 1] = y;    }    else    {      cout << "您输入有误" << endl;    }       }    }    return 0;}

题目5：给定一个数组，其中元素按升序排序，将其转换为高度平衡 BST。

因为是升序数组，那么中间的数字一定是根节点值，然后在对左右两边的数组进行查找根节点的递归。一次处理左右子树。

/** * Definition for binary tree * struct TreeNode { *     int val; *     TreeNode *left; *     TreeNode *right; *     TreeNode(int x) : val(x), left(NULL), right(NULL) {} * };  */class Solution {public:    TreeNode *sortedArrayToBST(vector &num) {                return sortedArrayToBST(0, num.size()-1, num);    }    TreeNode *sortedArrayToBST(int left, int right, vector &num){                if (left > right)                        return NULL;                int mid = (left + right)/2 + (left + right)%2 ;        TreeNode *root = new TreeNode(num[mid]);        root->left = sortedArrayToBST(left, mid-1, num);        root->right = sortedArrayToBST(mid+1, right, num);                return root;    }};

题目6：将单链表翻转。

有三种方式。

一：用数组存储单链表的值，然后重新逆序赋值，效率较低。

二：利用三个指针，在原来的基础上进行逆序。这种方法比较实用，效率也高。

三：从第 2 个节点到第 N 个节点，依次逐节点插入到第 1 个节点 (head 节点) 之后，最后将第一个节点挪到新表的表尾。需要新建一个链表，这种方法和第二种差不多。

下面列出方法二的代码：

struct ListNode {        int val;    ListNode *next;    ListNode(int x) : val(x), next(NULL) {}};ListNode *ReverseList(ListNode *head){    ListNode *pre, *cur, *net;//前驱，中间，后继节点。    pre = head;    cur = pre->next;        while (cur){        net = cur->next;        cur->next = pre;        pre = cur;        cur = net;    }        //这里翻转完成之后起初的头结点就是尾节点了。所以    head->next = NULL;        *head = p1;        return head;}

题目7：给定链接列表，每次颠倒链表k的节点并返回其修改的列表。如果节点的数量不是k的倍数，则最后的左出节点应该保持原样。你不能更改节点中的值，只有节点本身可能会更改，只允许常量存储器。

例如：

给定这个链表：1-> 2-> 3-> 4-> 5

对于k = 2，你应该返回：2-> 1-> 4-> 3-> 5

对于k = 3，你应该返回：3-> 2-> 1-> 4-> 5

这里实用了常量数组存储链表的值，然后进行局部链表的翻转，利用 reverse 函数进行翻转。

/** * Definition for singly-linked list. * struct ListNode { *     int val; *     ListNode *next; *     ListNode(int x) : val(x), next(NULL) {} * };  */class Solution {public:    ListNode *reverseKGroup(ListNode *head, int k) {                if (!head)             return head;                if (k == 1)                        return head;        vector<int> res;        ListNode *temp = head;        ListNode *newhead = head;                while (temp){            res.push_back(temp->val);            temp = temp->next;        }                        for (int i=0; i+k<=res.size(); i+=k){            reverse(res.begin()+i, res.begin()+i+k);        }                        for (int i=0; i            newhead->val = res[i];            newhead = newhead->next;        }                //delete temp;        return head;    }};

题目8：将链接列表从位置m反转到n。做它在就地和一次通过。

例如：

给定1-> 2-> 3-> 4-> 5-> NULL，m = 2和n = 4，

return1-> 4-> 3-> 2-> 5-> NULL。

提示：

给定m，n满足以下条件：

1≤m≤n≤列表长度。

这个题目也是局部进行链表的翻转，可以使用数组进行存储翻转，但是效率比较低。这个题目纯粹的是考察链表的基本功问题。我们只要将指定区间里面的部分进行翻转(和翻转整个链表一样)，设置三个指针，我们这里讲指定范围内最后面的节点依次的往前面移动，这样就实现了联煸的翻转。

/** * Definition for singly-linked list. * struct ListNode { *     int val; *     ListNode *next; *     ListNode(int x) : val(x), next(NULL) {} * };  */class Solution {public:    ListNode *reverseBetween(ListNode *head, int m, int n) {                //在指定的范围之内，将链表末端的节点依次插入到前面，实现翻转。        if (head == NULL)                        return head;        ListNode *dummy = new ListNode(0);//新生成一个新链表节点，作为空的头结点        dummy->next = head;        ListNode *pre = dummy;                for (int i=1; i            pre = pre->next;        }        ListNode *cur = pre->next;        ListNode *net = cur->next;                //翻转次数为两次，依次将后面的元素调取到指定位置前面，指定三个指针来进行操作即可                //①：1 2 3 4 5 -> 1 3 2 4 5  将3调到2的前面                //②：1 3 2 4 5 -> 1 4 3 2 5  将4调到3的前面        for (int i=0; i//调取次数n-m            cur->next = net->next;            net->next = pre->next;            pre->next = net;            net = cur->next;        }                return dummy->next;    }};

题目9：要开发一款教育类 App，帮助幼儿在识数阶段做一百以内自然数 [0,99] 的加减法。屏幕上会显示 “1”“2”“3”“4”“5”“6”“7”“8”“9”“0”“+”“-”“=” 这些按钮，用户在按了若干按钮之后，如果按了 “=”，则会把按 “=” 之前的字符作为一个算式，计算结果。中间结果或最后结果可以为负数。

输入描述：

输入为一个字符串，形如 “23+86-6+37+24-8-13”.

输入字符串中保证：

不会包含除 “1”“2”“3”“4”“5”“6”“7”“8”“9”“0”“+”“-”“=” 之外的字符；

长度不为 0；

不以 “+” 或 “-” 开始和结束

例子：

输入：1+2-1+3+4

输出：9

• 遍历字符串

• 到 “+” 或 “-” 进入求和算法部分，同时标记 “+” 或 “-” 出现位置

• 求出两个符号间数字的大小

• 对数字进行求和

注：第一个求和数字和最后一个求和数字要单独编写程序

#include #include using namespace std; int main(){    string str;    while(cin >> str)    {        int sum = 0;    //所有输入数据求和        int temp = 0;   //“+”或“-”前面的数字        int flag = 0;   //“+”或“-”所在的位置        for(int i = 0; i < str.size(); i++)     //遍历字符串        {            if(str[i] < '0' || str[i] > '9')    //找到+ -号            {                for(int j = flag; j < i; j++)   //计算符号前面的数字大小                    temp = temp * 10 + (str[j] - '0');                if(flag == 0)                   //对第一个数求和                {   sum += temp;    temp = 0;   }                else                {                    if(str[flag - 1] == '+')     //对其他数求和                    {   sum += temp;    temp = 0;   }                    else if(str[flag - 1] == '-')                    {   sum -= temp;    temp = 0;   }                }                flag = i + 1;            }        }        for(int j = flag; j < str.size(); j++)    //对最后一个数求和            temp = temp * 10 + (str[j] - '0');        if(str[flag - 1] == '+')        {   sum += temp;    temp = 0;   }        else if(str[flag - 1] == '-')        {   sum -= temp;    temp = 0;   }        cout << sum << endl;    }}

题目10：两个任意长度的正数相减，这两个正数可以带小数点，也可以是整数，请输出结果。输入的字符串中，不会出现除了数字与小数点以外的其它字符，不会出现多个小数点以及小数点在第一个字符的位置等非法情况，所以考生的程序中无须考虑输入的数值字符串非法的情况。

详细要求以及约束：

1. 输入均为正数，但输出可能为负数；

2. 输入输出均为字符串形式；

3. 如果输出是正数则不需要带符号，如果为负数，则输出的结果字符串需要带负号

例如：2.2-1.1 直接输出为 “1.1”，1.1-2.2 则需要输出为 “-1.1”

4. 输出的结果字符串需要过滤掉整数位前以及小数位后无效的 0，小数位为全 0 的，直接输出整数位

例如相减结果为 11.345，此数值前后均不可以带 0，“011.345” 或者 “0011.34500” 等等前后带无效 0 的均视为错误 输出。例如 1.1-1.1 结果为 0.0，则直接输出 0。

要求实现函数：

voidDecrease(char *input1, char*input2, char *output)

【输入】 char *iinput1 被减数

char*input2 减数

【输出】 char *output 减法结果

【返回】 无

示例

输入：char *input1="2.2"

char*input2="1.1"

输出：char*output="1.1"

输入：char *input1="1.1"

char*input2="2.2"

输出：char *output="-1.1"

倘若存在小数，则用”0“填充使得操作数的小数位数均相等。倘若操作数 2 比操作数 1 大。则交换操作数 2 和 1，并记录结果负号标记。

确定借位标识符 add=0。每一处的结果 result [i]=input1 [i]-input2 [i]-add。

修正最后的结果，使得末尾和开头不必要的 0 去掉

#include#includeusing namespace std;const string sub(string num1,string num2){      if(num1.empty()||num2.empty())          return NULL;      int add=0;//进位标志位  if(num1.compare(num2)==0)    return "0";  //始终保证num1>=num2  bool flag=true;//代表计算结果为正  bool xiaoshu=false;//表征是否存在小数，若存在，则修改结果时，注意去掉结果尾部多余的0  if(num1.length()0)){    flag=false;//代表计算结果为负    num1.swap(num2);  }  int size1=num1.length();  int size2=num2.length();  string result(size1,'0');  //计算过程    int i;   int temp;      for(i=0;i    if(num1[size1-i-1]=='.'&&num2[size2-i-1]=='.'){      result[size1-i-1]='.';      i++;      xiaoshu=true;    }        temp=num1[size1-i-1]-num2[size2-i-1]-add;          add=0;          if(temp<0){              temp+=10;              add=1;          }          result[size1-i-1]=temp+'0';      }    if(size1>size2)           result[size1-i-1]=num1[size1-i-1]-add;     for(i=0;i-1);i++)          result[i]=num1[i];    //去掉字串删除开头和结尾存在的多余的0  i=0;  while(i'0'&&result[i+1]!='.')    i++;  int j=size1-1;  while(xiaoshu&&j>=0&&result[j]=='0')     j--;  if(result[j]=='.')//去掉多余的小数点，即计算结果为整数    j--;  result=result.substr(i,j-i+1);   //加入正负标记位  if(!flag)    result='-'+result;  return result;}void Decrease(char *input1,char*input2, char *output){    //为空情况的判别  if(!input1&&!input2){    *output='\0';return;}  else if(!input1){    strcpy(output+1,input2);    *output='-';    return;  }  else if(!input2){    strcpy(output,input1);    return;  }  string Input1(input1);  string Input2(input2);  //计算小数点后的长度,将小数点后长度补充至一致。倘若不存在小数点，则长度为0。  int i=Input1.find('.');  int j=Input2.find('.');  if(i==string::npos)    i=0;  else      i=Input1.size()-1-i;  if(j==string::npos)    j=0;  else     j=Input2.size()-1-j;  //用0补全，使得两个数的小数点位数相同。若操作数没有小数点，则略过此步骤。  int max=i;  if(max    max=j;    if(i==0)      Input1.push_back('.');    for(int k=0;k      Input1.push_back('0');  }  else if(max!=0)  {    if(j==0)      Input2.push_back('.');    for(int k=0;k      Input2.push_back('0');  }  strcpy(output,sub(Input1,Input2).data());//计算结果并赋值输出}int main(){      string num1,num2;      getline(cin,num1);      getline(cin,num2);   char* output=new char[100];  memset(output,0,100);  Decrease(const_cast<char*>(num1.data()),const_cast<char*>(num2.data()),output);//此处注意将string-> const char* ->char*  cout<endl;   delete []output;  return 0;}

计算机视觉常见面试题型介绍及解答

第一期 | 第二期 | 第三期 | 第四期 | 第五期 |

第六期 | 第七期 | 第八期 | 第九期 | 第十期 | 第11期

腾讯算法工程师笔试真题介绍及解析汇总合集

第一期 | 第二期 | 第三期 | 第四期 | 第五期

阿里算法岗位最新编程题介绍及解析

第一期 | 第二期 | 第三期 | 第四期 | 第五期 | 第六期 | 第七期

华为研发工程师编程题型介绍及解析

第一期