link2nowcoder剑指offer编程题目合集
- 二维数组中的查找 | 有序就有二分，二分搜索降低复杂度，整体O(nlgn）| 三星题
class Solution { public: bool Find(int target, vector<vector<int> > array) { //逐个在首个元素其目标值小的数组里面进行二分查找 if(array[0].size()==0)return false; for(int i=array.size()-1;i>=0;i--){ if(array[i][0]<=target){ int l = 0; int r = array[i].size(); while(l<r){ //注意行123的边界处理，当lr相邻时特殊处理 int mid = (l+r)/2;//行1 if(array[i][mid]==target)return true; else if(array[i][mid]<target){ l = mid+1;//行2 }else if(array[i][mid]>target){ r = mid;//行3 } } } } return false; } }; - 替换空格 | c风格字符串，指针，内存分配，按值传递 | 细节题
class Solution { public: void replaceSpace(char *str,int length) { //c风格字符串我不是很习惯，但是效率很高 //注意str只是个指针副本，要修改指向的内存，只能本地修改 /* char* tem = (char*)malloc(length*sizeof(char)*4); int j = 0; for(size_t i=0;i<length;i++){ if(str[i]=' '){ tem[j++]='%'; tem[j++]='2'; tem[j++]='0'; }else{ tem[j++]=str[i]; } } tem[j]='\0'; str = tem; */ if(str==NULL)return; int i = 0; int ni = 0; while(str[i]!='\0'){ if(str[i++]==' '){ ni+=3; }else{ ni++; } } while(i>=0){ if(str[i]==' '){ str[ni--]='0'; str[ni--]='2'; str[ni--]='%'; }else{ str[ni--]=str[i]; } i--; } } }; -
从尾到头打印链表 | 双指针 栈 链表 | 三星
/** * struct ListNode { * int val; * struct ListNode *next; * ListNode(int x) : * val(x), next(NULL) { * } * }; */ class Solution { public: vector<int> printListFromTailToHead(ListNode* head) { //双指针或者栈 //双指针解法 vector<int> res; if(head==NULL)return res; ListNode* f = head->next; ListNode* s = head; while(f->next!=NULL){ f = f->next; s = s->next; } while(1){ res.push_back(f->val); swap(f,s); if(f==head){ res.push_back(f->val); break; } s = head; while(s->next!=f)s = s->next; } return res; } };
-
输入某二叉树的前序遍历和中序遍历的结果，请重建出该二叉树。假设输入的前序遍历和中序遍历的结果中都不含重复的数字。例如输入前序遍历序列{1,2,4,7,3,5,6,8}和中序遍历序列{4,7,2,1,5,3,8,6}，则重建二叉树并返回。
/** * 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* reConstructBinaryTree(vector<int> pre,vector<int> vin) { //递归吧 if(pre.size()==0)return NULL; TreeNode* root(pre[0]); vector<int> pl; vector<int> vl; vector<int> pr; vector<int> vr; //写伪码了，根据先序的第一个节点为当前子树的root节点，将序列划分，然后递归处理。 //左子树中序遍历 vl 先序遍历 pl root->left = reConstructBinaryTree(pl,vl); //右子树中序遍历 vr 先序遍历 pr root->right = reConstructBinaryTree(pr,vr); return root; } };--
-
用两个栈来实现一个队列，完成队列的Push和Pop操作。 队列中的元素为int类型。
class Solution { public: void push(int node) { while(!stack2.empty()){ stack1.push(stack2.top()); stack2.pop(); } stack1.push(node); } int pop() { while(!stack1.empty()){ stack2.push(stack1.top()); stack1.pop(); } int tem = stack2.top(); stack2.pop(); return tem; } private: stack<int> stack1; stack<int> stack2; };--
-
一只青蛙一次可以跳上1级台阶，也可以跳上2级。求该青蛙跳上一个n级的台阶总共有多少种跳法（先后次序不同算不同的结果）。
class Solution { private: int count = 0; public: int jumpFloor(int number) { //回溯，自顶向下不太行,内存超限了 /*if(number==0)count++; else if(number<0)return 0; jumpFloor(number-1); jumpFloor(number-2); return count;*/ //动态规划 自底向上 int dp[number+1]; dp[0]=1; dp[1]=1; dp[2]=2; for(int i =3;i<=number;i++){ dp[i]=dp[i-1]+dp[i-2]; } return dp[number]; } };--
-
一只青蛙一次可以跳上1级台阶，也可以跳上2级……它也可以跳上n级。求该青蛙跳上一个n级的台阶总共有多少种跳法。
class Solution { public: int jumpFloorII(int number) { vector<int> dp(number+1,0); dp[0]=1; dp[1]=1; dp[2]=2; for(int i =3;i<=number;i++){ for(int j=0;j<i;j++){ dp[i]+=dp[j]; } } return dp[number]; } };==
-
我们可以用2*1的小矩形横着或者竖着去覆盖更大的矩形。请问用n个2*1的小矩形无重叠地覆盖一个2*n的大矩形，总共有多少种方法？(竖着插入是一种情况，此时加上dp[n-1]，横着插入是一种情况，此时加上dp[n-2]。横着插入需要一个来配合）
class Solution { public: int rectCover(int number) { //动态规划，自底向上 int dp[number+1]; dp[0]=0; dp[1]=1; dp[2]=2; for(int i=3;i<=number;i++){ dp[i]=dp[i-1]+dp[i-2]; } return dp[number]; } };--
-
输入一个整数，输出该数二进制表示中1的个数。其中负数用补码表示。(位运算的优先级比 != == 要低)
class Solution { public: int NumberOf1(int n) { int count = 0; unsigned int flag = 1; while(flag!=0){ if((n&flag)!=0)count++; flag <<= 1; } return count; } };--
-
输入一个整数数组，实现一个函数来调整该数组中数字的顺序，使得所有的奇数位于数组的前半部分，所有的偶数位于数组的后半部分，并保证奇数和奇数，偶数和偶数之间的相对位置不变。(相对位置不变，插入排序）
class Solution { public: void reOrderArray(vector<int> &array) { //遍历➕双指针，遇到奇数就放到最前面，遇到偶数跳过 int pt1 = 0; int pt2 = 0; while(pt2<array.size()){ if(array[pt2]%2==1){ int tem = pt2; int t = array[pt2]; while(tem>pt1){ array[tem]=array[tem-1]; tem--; } array[tem]=t; pt1++; } pt2++; } } };--
-
输入一个链表，输出该链表中倒数第k个结点。(双指针，很简单，但要注意k可能会大于链表中节点个数的细节
/* struct ListNode { int val; struct ListNode *next; ListNode(int x) : val(x), next(NULL) { } };*/ class Solution { public: ListNode* FindKthToTail(ListNode* pListHead, unsigned int k) { //双指针 第一个先走k步 ListNode* f = pListHead; ListNode* s = pListHead; while(k>0&&f!=NULL){ f=f->next; k--; } if(k>0)return NULL; while(f!=NULL){ f=f->next; s=s->next; } return s; } };--
-
输入一个链表，反转链表后，输出新链表的表头。(原地操作，不借助额外空间 ，要注意的是每当取->next时都要判断当前的指针是不是NULL）
/* struct ListNode { int val; struct ListNode *next; ListNode(int x) : val(x), next(NULL) { } };*/ class Solution { public: ListNode* ReverseList(ListNode* pHead) { if(pHead==NULL)return NULL; //原地操作 ListNode* f = pHead; ListNode* s = pHead; ListNode* h = pHead; f = f->next; while(f!=NULL&&f->next!=NULL){ f=f->next; s=s->next; } if(f==NULL) return pHead; pHead = f; while(f!=h){ f->next=s; f=s; s=h; while(s->next!=f&&f!=h){ s=s->next; } } f->next=NULL; return pHead; } };---
-
输入两个单调递增的链表，输出两个链表合成后的链表，当然我们需要合成后的链表满足单调不减规则。(好像是没办法在原地进行的
/* struct ListNode { int val; struct ListNode *next; ListNode(int x) : val(x), next(NULL) { } };*/ class Solution { public: ListNode* Merge(ListNode* pHead1, ListNode* pHead2) { ListNode* res = new ListNode(0); ListNode* tem = res; while(pHead1!=NULL&&pHead2!=NULL){ if(pHead1->val<=pHead2->val){ ListNode* t = new ListNode(pHead1->val); pHead1=pHead1->next; tem->next=t; tem=tem->next; }else{ ListNode* t = new ListNode(pHead2->val); pHead2=pHead2->next; tem->next=t; tem=tem->next; } } if(pHead1!=NULL)tem->next=pHead1; if(pHead2!=NULL)tem->next=pHead2; return res->next; } };---
-
操作给定的二叉树，将其变换为源二叉树的镜像。
/* struct TreeNode { int val; struct TreeNode *left; struct TreeNode *right; TreeNode(int x) : val(x), left(NULL), right(NULL) { } };*/ class Solution { public: void Mirror(TreeNode *pRoot) { //递归 if(pRoot==NULL)return; swap(pRoot->right,pRoot->left); Mirror(pRoot->right); Mirror(pRoot->left); } };/* struct TreeNode { int val; struct TreeNode *left; struct TreeNode *right; TreeNode(int x) : val(x), left(NULL), right(NULL) { } };*/ class Solution { public: void Mirror(TreeNode *pRoot) { //迭代 if(pRoot==NULL)return; queue<TreeNode*> t; t.push(pRoot); while(!t.empty()){ TreeNode* tem = t.front(); t.pop(); swap(tem->right,tem->left); if(tem->right!=NULL)t.push(tem->right); if(tem->left!=NULL)t.push(tem->left); } } };--
-
输入一个矩阵，按照从外向里以顺时针的顺序依次打印出每一个数字，例如，如果输入如下4 X 4矩阵： 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 则依次打印出数字1,2,3,4,8,12,16,15,14,13,9,5,6,7,11,10.
class Solution { public: vector<int> printMatrix(vector<vector<int> > matrix) { int u = 0; int d = matrix.size()-1; int l = 0; int r = matrix[0].size()-1; vector<int> res; while(u<=d&&l<=r){ for(int i=l;i<=r;i++){ res.push_back(matrix[u][i]); } u++; if(u>d)break; for(int i=u;i<=d;i++){ res.push_back(matrix[i][r]); } r--; if(r<l)break; for(int i=r;i>=l;i--){ res.push_back(matrix[d][i]); } d--; if(d<u)break; for(int i=d;i>=u;i--){ res.push_back(matrix[i][l]); } l++; if(l>r)break; } return res; } };---
-
定义栈的数据结构，请在该类型中实现一个能够得到栈中所含最小元素的min函数（时间复杂度应为O（1））。
class Solution { public: void push(int value) { stacks.push(value); if(value<minx)minx=value; } void pop() { stack<int> tem; stacks.pop(); minx = INT_MAX; while(!stacks.empty()){ tem.push(stacks.top()); if(stacks.top()<minx)minx=stacks.top(); stacks.pop(); } while(!tem.empty()){ stacks.push(tem.top()); tem.pop(); } } int top() { return stacks.top(); } int min() { return minx; } private: int minx = INT_MAX; stack<int> stacks; };--
-
输入两个整数序列，第一个序列表示栈的压入顺序，请判断第二个序列是否可能为该栈的弹出顺序。假设压入栈的所有数字均不相等。例如序列1,2,3,4,5是某栈的压入顺序，序列4,5,3,2,1是该压栈序列对应的一个弹出序列，但4,3,5,1,2就不可能是该压栈序列的弹出序列。（注意：这两个序列的长度是相等的）
class Solution { public: bool IsPopOrder(vector<int> pushV,vector<int> popV) { stack<int> s; int k=0; for(int i:pushV){ s.push(i); while(s.top()==popV[k]){ s.pop(); k++; if(k>=popV.size())break; } } if(s.empty())return true; else return false; } };---
-
从上往下打印出二叉树的每个节点，同层节点从左至右打印。
/* struct TreeNode { int val; struct TreeNode *left; struct TreeNode *right; TreeNode(int x) : val(x), left(NULL), right(NULL) { } };*/ class Solution { public: vector<int> PrintFromTopToBottom(TreeNode* root) { vector<int> res; if(root==NULL)return res; queue<TreeNode*> q; q.push(root); while(!q.empty()){ TreeNode* r = q.front(); q.pop(); if(r->left!=NULL){ q.push(r->left); } if(r->right!=NULL){ q.push(r->right); } res.push_back(r->val); } return res; } };--
-
输入一个复杂链表（每个节点中有节点值，以及两个指针，一个指向下一个节点，另一个特殊指针指向任意一个节点），返回结果为复制后复杂链表的head。（注意，输出结果中请不要返回参数中的节点引用，否则判题程序会直接返回空）
/* struct TreeNode { int val; struct TreeNode *left; struct TreeNode *right; TreeNode(int x) : val(x), left(NULL), right(NULL) { } };*/ class Solution { private: vector<TreeNode*> res; public: void dfs(TreeNode* pRootOfTree){ if(pRootOfTree->left!=NULL)dfs(pRootOfTree->left); res.push_back(pRootOfTree); if(pRootOfTree->right!=NULL)dfs(pRootOfTree->right); } void changeptr(){ if(res.size()!=0){ for(int i=0;i<res.size();i++){ if(i-1>=0){ res[i]->left=res[i-1]; }else{ res[i]->left=NULL; } if(i+1<res.size()){ res[i]->right=res[i+1]; }else{ res[i]->right=NULL; } } } } TreeNode* Convert(TreeNode* pRootOfTree) { if(pRootOfTree==NULL)return NULL; dfs(pRootOfTree); changeptr(); return res[0]; } };----
-
输入一个字符串,按字典序打印出该字符串中字符的所有排列。例如输入字符串abc,则打印出由字符a,b,c所能排列出来的所有字符串abc,acb,bac,bca,cab和cba。
输入描述:
输入一个字符串,长度不超过9(可能有字符重复),字符只包括大小写字母。class Solution { private: int re[10]; set<string> tem; string t; string s; public: vector<string> Permutation(string str) { vector<string> res; if(str=="")return res; for(int i=0;i<str.size();i++)re[i]=1; s=str; dfs(); for(auto it = tem.begin();it!=tem.end();it++){ res.push_back(*it); } return res; } void dfs(){ if(t.size()==s.size()){ tem.insert(t); return; } for(int i=0;i<s.size();i++){ if(re[i]==0)continue; else{ re[i]=0; t+=s[i]; dfs(); t=t.substr(0,t.size()-1); re[i]=1; } } } };---
-
数组中有一个数字出现的次数超过数组长度的一半，请找出这个数字。例如输入一个长度为9的数组{1,2,3,2,2,2,5,4,2}。由于数字2在数组中出现了5次，超过数组长度的一半，因此输出2。如果不存在则输出0。
class Solution { public: int MoreThanHalfNum_Solution(vector<int> numbers) { map<int,int> d; int maxn = INT_MIN; int tem; for(auto i:numbers){ d[i]+=1; if(d[i]>maxn){ maxn=d[i]; tem = i; } } int x = (numbers.size())/2; if(x<maxn){ return tem; }else return 0; } };---
-
输入n个整数，找出其中最小的K个数。例如输入4,5,1,6,2,7,3,8这8个数字，则最小的4个数字是1,2,3,4,。
class Solution { public: vector<int> GetLeastNumbers_Solution(vector<int> input, int k) { vector<int> res; if(input.size()==0||k==0||k>input.size())return res; priority_queue<int,vector<int>,less<int> > q; for(auto i:input){ if(q.size()<k){ q.push(i); }else{ if(i<q.top()){ q.pop(); q.push(i); } } } while(q.size()!=0){ res.push_back(q.top()); q.pop(); } return res; } };----
-
HZ偶尔会拿些专业问题来忽悠那些非计算机专业的同学。今天测试组开完会后,他又发话了:在古老的一维模式识别中,常常需要计算连续子向量的最大和,当向量全为正数的时候,问题很好解决。但是,如果向量中包含负数,是否应该包含某个负数,并期望旁边的正数会弥补它呢？例如:{6,-3,-2,7,-15,1,2,2},连续子向量的最大和为8(从第0个开始,到第3个为止)。给一个数组，返回它的最大连续子序列的和，你会不会被他忽悠住？(子向量的长度至少是1)
class Solution { public: int FindGreatestSumOfSubArray(vector<int> array) { //贪心 只返回最大值 很简单 如果要返回最大区间，还要在maxn重新赋值时进行记录区间位置 //这道题也算是很经典了 int maxn = INT_MIN; int tem = 0; for(auto i : array){ tem+=i; if(tem>maxn)maxn = tem; if(tem<0){ tem = 0; } } return maxn; } };----
-
求出1~13的整数中1出现的次数,并算出100~1300的整数中1出现的次数？为此他特别数了一下1~13中包含1的数字有1、10、11、12、13因此共出现6次,但是对于后面问题他就没辙了。ACMer希望你们帮帮他,并把问题更加普遍化,可以很快的求出任意非负整数区间中1出现的次数（从1 到 n 中1出现的次数）。
-
输入一个正整数数组，把数组里所有数字拼接起来排成一个数，打印能拼接出的所有数字中最小的一个。例如输入数组{3，32，321}，则打印出这三个数字能排成的最小数字为321323。
//这个答案是抄的 class Solution { public: string PrintMinNumber(vector<int> numbers) { int len = numbers.size(); if(len == 0) return ""; sort(numbers.begin(), numbers.end(), cmp); string res; for(int i = 0; i < len; i++){ res += to_string(numbers[i]); } return res; } static bool cmp(int a, int b){ //这个仿函数妙啊，加了之后比较，我确实没想到 string A = to_string(a) + to_string(b); string B = to_string(b) + to_string(a); return A < B; } };---
-
把只包含质因子2、3和5的数称作丑数（Ugly Number）。例如6、8都是丑数，但14不是，因为它包含质因子7。 习惯上我们把1当做是第一个丑数。求按从小到大的顺序的第N个丑数。（首先从丑数的定义我们知道，一个丑数的因子只有2,3,5，那么丑数p = 2 ^ x * 3 ^ y * 5 ^ z，换句话说一个丑数一定由另一个丑数乘以2或者乘以3或者乘以5得到，那么我们从1开始乘以2,3,5，就得到2,3,5三个丑数，在从这三个丑数出发乘以2,3,5就得到4，6,10,6，9,15,10,15,25九个丑数，我们发现这种方***得到重复的丑数，而且我们题目要求第N个丑数，这样的方法得到的丑数也是无序的。那么我们可以维护三个队列：https://www.nowcoder.com/profile/5810633/codeBookDetail?submissionId=16629921）
-
在一个字符串(0<=字符串长度<=10000，全部由字母组成)中找到第一个只出现一次的字符,并返回它的位置, 如果没有则返回 -1（需要区分大小写）.
class Solution { public: int FirstNotRepeatingChar(string str) { queue<int> s; vector<int> dict(100,0); for(int j=0;j<str.size();j++){ char i = str[j]; if(dict[i-'A']==0){ s.push(j); dict[i-'A']+=1; }else{ dict[i-'A']+=1; if(str[s.front()]==i){ if(!s.empty())s.pop(); while(!s.empty()&&dict[str[s.front()]-'A']>1){ s.pop(); } } } } if(s.empty())return -1; else return s.front(); } };---
-
在数组中的两个数字，如果前面一个数字大于后面的数字，则这两个数字组成一个逆序对。输入一个数组,求出这个数组中的逆序对的总数P。并将P对1000000007取模的结果输出。 即输出P%1000000007
class Solution { public: int InversePairs(vector<int> data) { int length = data.size(); return mergeSort(data, 0, length-1); } //归并排序的思想，先拆分 再合并 int mergeSort(vector<int>& data, int start, int end) { // 递归终止条件 if(start >= end) { return 0; } // 递归 int mid = (start + end) / 2; int leftCounts = mergeSort(data, start, mid); int rightCounts = mergeSort(data, mid+1, end); // 归并排序，并计算本次逆序对数 vector<int> copy(data); // 数组副本，用于归并排序 int foreIdx = mid; // 前半部分的指标 int backIdx = end; // 后半部分的指标 int counts = 0; // 记录本次逆序对数 int idxCopy = end; // 辅助数组的下标 while(foreIdx>=start && backIdx >= mid+1) { if(data[foreIdx] > data[backIdx]) { copy[idxCopy--] = data[foreIdx--]; //如果前半部分某个元素比后半部分的某个元素大，那么后半部分这个元素到后半部分的起 //点（升序排列）距离内都是逆序数 counts += backIdx - mid; } else { copy[idxCopy--] = data[backIdx--]; } } while(foreIdx >= start) { copy[idxCopy--] = data[foreIdx--]; } while(backIdx >= mid+1) { copy[idxCopy--] = data[backIdx--]; } for(int i=start; i<=end; i++) { data[i] = copy[i];//排好序的辅助数组给原数组赋值 } return (leftCounts+rightCounts+counts); } };----
-
输入两个链表，找出它们的第一个公共结点。
/* struct ListNode { int val; struct ListNode *next; ListNode(int x) : val(x), next(NULL) { } };*/ class Solution { public: ListNode* FindFirstCommonNode( ListNode* pHead1, ListNode* pHead2) { int l1=0; int l2=0; ListNode* p1 = pHead1; ListNode* p2 = pHead2; while(p1!=NULL){ p1=p1->next; l1++; } while(p2!=NULL){ p2=p2->next; l2++; } p1 = pHead1; p2 = pHead2; while(l1<l2){ l2--; p2=p2->next; } while(l2<l1){ l1--; p1=p1->next; } while(p1!=p2){ if(p1!=NULL)p1=p1->next; if(p2!=NULL)p2=p2->next; } return p1; } };----
-
统计一个数字在排序数组中出现的次数。(有序即二分，二分查找，lgn的复杂度
class Solution { private: vector<int> d; int t; public: int sl(){ int l = 0; int r = d.size()-1; while(l<r){ int mid = (l+r)/2; if(d[mid]==t)r=mid; else if(d[mid]>t)r=mid; else if(d[mid]<t)l=mid+1; } return l; } int sr(){ int l = 0; int r = d.size()-1; while(l<r){ int mid = (l+r)/2; if(d[mid]==t){ l=mid; if(l+1==r){ if(d[r]==t)return r; else return l; } } else if(d[mid]>t)r=mid; else if(d[mid]<t)l=mid+1; } return r; } int GetNumberOfK(vector<int> data ,int k) { d = data; t = k; int l = sl(); int r = sr(); if(l<d.size()&&d[l]==t) return r-l+1; else return 0; } };---
-
输入一棵二叉树，求该树的深度。从根结点到叶结点依次经过的结点（含根、叶结点）形成树的一条路径，最长路径的长度为树的深度。
/* struct TreeNode { int val; struct TreeNode *left; struct TreeNode *right; TreeNode(int x) : val(x), left(NULL), right(NULL) { } };*/ class Solution { private: int res=0; int tem; public: void dfs(TreeNode* r){ if(tem>res)res = tem; if(r->left!=NULL){ tem++; dfs(r->left); tem--; } if(r->right!=NULL){ tem++; dfs(r->right); tem--; } } int TreeDepth(TreeNode* pRoot) { if(pRoot!=NULL){ tem=1; dfs(pRoot); } return res; } };---
-
一个整型数组里除了两个数字之外，其他的数字都出现了两次。请写程序找出这两个只出现一次的数字。
class Solution { public: void FindNumsAppearOnce(vector<int> data,int* num1,int *num2) { queue<int> q; map<int,int> r; for(auto i:data){ if(r.find(i)==r.end()){ q.push(i); r[i]++; }else{ r[i]++; while(r[q.front()]>1)q.pop(); } } vector<int> res; while(!q.empty()){ if(r[q.front()]>1)q.pop(); else{ res.push_back(q.front()); q.pop(); } } *num1 = res[0]; *num2 = res[1]; } };---
-
小明很喜欢数学,有一天他在做数学作业时,要求计算出9~16的和,他马上就写出了正确答案是100。但是他并不满足于此,他在想究竟有多少种连续的正数序列的和为100(至少包括两个数)。没多久,他就得到另一组连续正数和为100的序列:18,19,20,21,22。现在把问题交给你,你能不能也很快的找出所有和为S的连续正数序列? Good Luck!
class Solution { public: vector<vector<int> > FindContinuousSequence(int sum) { //双指针 vector<vector<int> > res; int l = 1; int r = 2; int tem=l; while(l<r){ tem+=r; while(tem>sum){ tem-=l; l++; } if(l==r)break; if(tem==sum){ vector<int> t; for(int i=l;i<=r;i++)t.push_back(i); res.push_back(t); } r++; } return res; } };----
-
输入一个递增排序的数组和一个数字S，在数组中查找两个数，使得他们的和正好是S，如果有多对数字的和等于S，输出两个数的乘积最小的。
class Solution { public: vector<int> FindNumbersWithSum(vector<int> array,int sum) { int l = 0; int r = array.size()-1; int tmp = INT_MAX; vector<int> res; while(l<r){ if(array[l]+array[r]==sum){ if(tmp>(array[l]*array[r])){ tmp = array[l]*array[r]; vector<int> t(2,0); t[0]=array[l]; t[1]=array[r]; res = t; } l++; }else if(array[l]+array[r]<sum)l++; else if(array[l]+array[r]>sum)r--; } return res; } };-----
-
汇编语言中有一种移位指令叫做循环左移（ROL），现在有个简单的任务，就是用字符串模拟这个指令的运算结果。对于一个给定的字符序列S，请你把其循环左移K位后的序列输出。例如，字符序列S=”abcXYZdef”,要求输出循环左移3位后的结果，即“XYZdefabc”。是不是很简单？OK，搞定它！
class Solution { public: string LeftRotateString(string str, int n) { if(n<0)return NULL; if(n==0)return str; string tmp = str.substr(0,n); str.erase(0,n); str+=tmp; return str; } };-----
-
牛客最近来了一个新员工Fish，每天早晨总是会拿着一本英文杂志，写些句子在本子上。同事Cat对Fish写的内容颇感兴趣，有一天他向Fish借来翻看，但却读不懂它的意思。例如，“student. a am I”。后来才意识到，这家伙原来把句子单词的顺序翻转了，正确的句子应该是“I am a student.”。Cat对一一的翻转这些单词顺序可不在行，你能帮助他么？
class Solution { public: string ReverseSentence(string str) { if(str=="")return str; auto it1 = str.begin(); auto it2 = str.begin(); while(it2!=str.end()){ if(*it2==' '){ reverse(it1,it2); while(it2!=str.end()&&*it2==' '){ it2++; } it1 = it2; } if(it2!=str.end()) it2++; } reverse(it1,it2); reverse(str.begin(),str.end()); return str; } };---
-
LL今天心情特别好,因为他去买了一副扑克牌,发现里面居然有2个大王,2个小王(一副牌原本是54张^_^)...他随机从中抽出了5张牌,想测测自己的手气,看看能不能抽到顺子,如果抽到的话,他决定去买体育彩票,嘿嘿！！“红心A,黑桃3,小王,大王,方片5”,“Oh My God!”不是顺子.....LL不高兴了,他想了想,决定大\小 王可以看成任何数字,并且A看作1,J为11,Q为12,K为13。上面的5张牌就可以变成“1,2,3,4,5”(大小王分别看作2和4),“So Lucky!”。LL决定去买体育彩票啦。 现在,要求你使用这幅牌模拟上面的过程,然后告诉我们LL的运气如何， 如果牌能组成顺子就输出true，否则就输出false。为了方便起见,你可以认为大小王是0。
class Solution { public: bool IsContinuous( vector<int> numbers ) { if(numbers.size()!=5)return false; int maxn = INT_MIN; int minx = INT_MAX; int zc = 0; for(auto i:numbers){ if(i>maxn&&i!=0)maxn = i; if(i<minx&&i!=0)minx = i; if(i==0)zc++; } if(maxn-minx<5&&maxn-minx>0)return true; else if(maxn==minx&&zc==4)return true; else return false; } };----
-
将一个字符串转换成一个整数，要求不能使用字符串转换整数的库函数。 数值为0或者字符串不是一个合法的数值则返回0
class Solution { public: int StrToInt(string str) { long long int tmp = 0; int i = 0; while(str[i]<'0'||str[i]>'9'){ if(str[i]=='+'||str[i]=='-')i++; else return 0; } if(i>1)return 0; for(;i<str.size();i++){ if(str[i]<'0'||str[i]>'9')return 0; int t = str[i]-'0'; tmp = tmp*10 + t; } if(str[0]=='-')tmp *= -1; if(tmp>INT_MAX||tmp<INT_MIN)return 0; return tmp; } };----
-
在一个长度为n的数组里的所有数字都在0到n-1的范围内。 数组中某些数字是重复的，但不知道有几个数字是重复的。也不知道每个数字重复几次。请找出数组中任意一个重复的数字。 例如，如果输入长度为7的数组{2,3,1,0,2,5,3}，那么对应的输出是第一个重复的数字2。
class Solution { public: // Parameters: // numbers: an array of integers // length: the length of array numbers // duplication: (Output) the duplicated number in the array number // Return value: true if the input is valid, and there are some duplications in the array number // otherwise false bool duplicate(int numbers[], int length, int* duplication) { map<int,int> count; bool res=true; for(int i=0;i<length;i++){ if(numbers[i]>=length||numbers[i]<0)res=false; count[numbers[i]]++; } int i=0; while(i<length&&count[numbers[i]]<2)i++; if(i<length)*duplication = numbers[i]; else res = false; return res; } };-----
-
给定一个数组A[0,1,...,n-1],请构建一个数组B[0,1,...,n-1],其中B中的元素B[i]=A[0]*A[1]*...*A[i-1]*A[i+1]*...*A[n-1]。不能使用除法。
class Solution { public: vector<int> multiply(const vector<int>& A) { //这题目力扣见过 vector<int> dpl; vector<int> dpr; dpl.push_back(A[0]); for(int i=1;i<A.size()-1;i++){ dpl.push_back(A[i]*dpl[i-1]); } dpr.push_back(A[A.size()-1]); for(int i=A.size()-2;i>0;i--){ dpr.push_back(A[i]*dpr[A.size()-2-i]); } reverse(dpr.begin(),dpr.end()); vector<int> res; res.push_back(dpr[0]); for(int i=1;i<A.size()-1;i++){ res.push_back(dpr[i]*dpl[i-1]); } res.push_back(dpl[A.size()-2]); return res; } };-----
-
442
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
