牛客网 - 2018校招真题
排序 - 爱奇艺
https://www.nowcoder.com/practice/e496d8e885a949d18476b2dea1e594a9?tpId=90&tqId=30794&tPage=1&rp=1&ru=%2Fta%2F2018test&qru=%2Fta%2F2018test%2Fquestion-ranking
题目描述
牛牛有一个长度为n的整数序列,牛牛想对这个序列进行重排为一个非严格升序序列。牛牛比较懒惰,他想移动尽量少的数就完成重排,请你帮他计算一下他最少需要移动多少个序列中的元素。(当一个元素不在它原来所在的位置,这个元素就是被移动了的)
输入描述:
输入包括两行,第一行一个整数n(1 ≤ n ≤ 50),即序列的长度
第二行n个整数x[i](1 ≤ x[i] ≤ 100),即序列中的每个数
输出描述:
输出一个整数,即最少需要移动的元素个数
示例1
输入
复制
3
3 2 1
输出
复制
2
思路：先将数组备份到y，再将x排序，最后逐位比较x与y不同的数字个数
#include<cstdio> #include<iostream> #include<algorithm> #include<cstring> using namespace std; #define N 50 int main() { int n, x[N], y[N]; cin>>n; for(int i=0; i<n; i++) cin>>x[i]; memcpy(y, x, n*sizeof(int)); sort(x, x+n); int num = 0; for(int i=0; i<n; i++) { if(x[i] != y[i]) num++; } cout<<num<<endl; return 0; }
补充：
C++如何复制数组？
1. 字符数组 - strcpy()
头文件：#include <string.h> 或者 #include <cstring>
char *strcpy(char *dest, const char *src) 两个参数分别是目标数组和源数组，该函数返回一个指向最终的目标字符串 dest 的指针（不过一般并不需要用变量接收，直接strcpy(y, x)即可）。
2. int,float,double等数组 - memcpy()
头文件：#include <string.h> 或者 #include <cstring>
memcpy(void *str1, const void *str2, size_t n) 参数分别为目标数组、源数组、要被复制的字节数。
3. 循环赋值
Python 如何复制list?
1. y = a[:]
2. y = x.copy()
Python：
n, x = int(input()), list(map(int, input().split())) y = sorted(x) num = 0 for i in range(n): if x[i] != y[i]: num += 1 print(num)
判断题 - 爱奇艺
https://www.nowcoder.com/practice/ce5b35929ab84e3a806886d9667be00a?tpId=90&tqId=30790&tPage=1&rp=1&ru=%2Fta%2F2018test&qru=%2Fta%2F2018test%2Fquestion-ranking
题目描述
牛牛参加了一场考试,考试包括n道判断题,每做对一道题获得1分,牛牛考试前完全没有准备,所以考试只能看缘分了,牛牛在考试中一共猜测了t道题目的答案是"正确",其他的牛牛猜为"错误"。考试结束后牛牛知道实际上n道题中有a个题目的答案应该是"正确",但是牛牛不知道具体是哪些题目,牛牛希望你能帮助他计算可能获得的最高的考试分数是多少。
输入描述:
输入包括一行,一行中有三个正整数n, t, a(1 ≤ n, t, a ≤ 50), 以空格分割
输出描述:
输出一个整数,表示牛牛可能获得的最高分是多少。
示例1
输入
复制
3 1 2
输出
复制
2
思路：a与t的差值，为做错的题目数量，n减去此数，即为得分
#include<cstdio> #include<iostream> using namespace std; int main() { int n, t, a; cin>>n>>t>>a; cout<<n - abs(a - t)<<endl; return 0; }
Python：
n, t, a = map(int, input().split()) print(n - abs(t - a))
补充：abs()求绝对值，Python和C++都有
回文素数 - 爱奇艺
https://www.nowcoder.com/practice/4802faa9afb54e458b93ed372e180f5c?tpId=90&tqId=30793&tPage=1&rp=1&ru=%2Fta%2F2018test&qru=%2Fta%2F2018test%2Fquestion-ranking
题目描述
如果一个整数只能被1和自己整除,就称这个数是素数。
如果一个数正着反着都是一样,就称为这个数是回文数。例如:6, 66, 606, 6666
如果一个数字既是素数也是回文数,就称这个数是回文素数
牛牛现在给定一个区间[L, R],希望你能求出在这个区间内有多少个回文素数。
输入描述:
输入包括一行,一行中有两个整数(1 ≤ L ≤ R ≤ 1000)
输出描述:
输出一个整数,表示区间内回文素数个数。
示例1
输入
复制
100 150
输出
复制
2
Python:
def isPrime(num): if num == 1: return False for i in range(2, num): if num % i == 0: return False return True def isHuiwen(num): s = str(num); s2 = s[::-1] if s == s2: return True else: return False l, r = map(int, input().split()) count = 0 for num in range(l, r+1): if (isPrime(num)): if(isHuiwen(num)): count += 1 print(count)
补充：
sqrt() 函数在 math.sqrt下，所以需要import math
float、str、bytes 转int类型，直接使用int 函数就行 PYthon3 类型转换大全
range(a, b) 的范围是 a<= num < b， 注意范围
Ｃ＋＋：
#include<cstdio> #include<iostream> #include<cmath> #include<cstring> using namespace std; bool isPrime(int num); bool isHuiwen(int num); int main() { int l, r, counts = 0; int prime[1000]; memset(prime, 0, sizeof(prime)); cin>>l>>r; for(int i=l; i<=r; i++) { if(isPrime(i)) prime[i] = 1; } for(int i=l; i<=r; i++) { if(prime[i]) { if(isHuiwen(i)) counts++; } } cout<<counts<<endl; return 0; } bool isPrime(int num) { if(num == 1) return false; bool flag = true; for(int i=2; i<=sqrt(num); i++) { if(num%i == 0) { flag = false; break; } } return flag; } bool isHuiwen(int num) { bool flag = true; int digit[5]; int i = -1; while(num) { i++; digit[i] = num % 10; num /= 10; } for(int j=0; j<=i; j++, i--) { if(digit[i] != digit[j]) { flag = false; break; } } return flag; }
操作序列
https://www.nowcoder.com/practice/b53bda356a494154b6411d80380295f5?tpId=90&tqId=30783&tPage=1&rp=1&ru=%2Fta%2F2018test&qru=%2Fta%2F2018test%2Fquestion-ranking
题目描述
小易有一个长度为n的整数序列,a_1,...,a_n。然后考虑在一个空序列b上进行n次以下操作:
1、将a_i放入b序列的末尾
2、逆置b序列
小易需要你计算输出操作n次之后的b序列。
输入描述:
输入包括两行,第一行包括一个整数n(2 ≤ n ≤ 2*10^5),即序列的长度。
第二行包括n个整数a_i(1 ≤ a_i ≤ 10^9),即序列a中的每个整数,以空格分割。
输出描述:
在一行中输出操作n次之后的b序列,以空格分割,行末无空格。
示例1
输入
复制
4
1 2 3 4
输出
复制
4 2 1 3
超时代码：循环 + list.reverse()
n = int(input()) a = input().split() b = [] for i in range(n): b.append(a[i]) b.reverse() # print(" ".join(str(foo) for foo in b)) print(" ".join(b))
补充：list.reverse() 用于反向列表中元素。 该方法没有返回值，但是会对列表的元素进行反向排序。
超时代码2：循环 + str[::-1]
n = int(input()) a = input().split() s = '' for i in range(n): s += a[i] s = s[::-1] print(" ".join(list(s)))
补充：str = str[::-1] 可用于反转字符串， l = list(str) 用于将字符串分割成字母列表
通过代码Python：
思路：关键是时间复杂度 当n分别为2 3 4 5 6时看以下几个输出： 2 1 3 1 2 4 2 1 3 5 3 1 2 4 6 4 2 1 3 5 所以： n为奇数(odd)时：输出为奇数序列翻转+偶数序列 n为偶数(even)时：输出为偶数序列翻转+奇数序列
n = int(input()) a = input().split() odd = a[0::2] even = a[1::2] if n % 2 == 0: even.reverse() even.extend(odd) print(" ".join(even)) else: odd.reverse() odd.extend(even) print(" ".join(odd))
补充：list.extend(seq) 用于在列表末尾一次性追加另一个序列中的多个值（用新列表扩展原来的列表）。
- seq -- 元素列表，可以是列表、元组、集合、字典，若为字典,则仅会将键(key)作为元素依次添加至原列表的末尾。
- 该方法没有返回值，但会在已存在的列表中添加新的列表内容。
奇反+偶 和 偶反+奇 其实是正好相反的，所以优化一下如下：
n = int(input()) a = input().split() odd = a[0::2] even = a[1::2] out = [] odd.reverse() out.extend(odd) out.extend(even) if n % 2 == 0: out.reverse() print(" ".join(out))
C++：
#include<cstdio> #include<iostream> using namespace std; #define MAXN 200001 // const int MAXN = 200200; int main() { int n, a[MAXN]; cin>>n; for(int i=0; i<n; i++) cin>>a[i]; if(n%2) { for(int i=n-1; i>=0; i-=2) cout<<a[i]<<" "; for(int i=1; i<n-1; i+=2) i == n - 1 ? cout<<a[i] : cout<<a[i]<<" "; } else { for(int i=n-1; i>0; i-=2) cout<<a[i]<<" "; for(int i=0; i<n-1; i+=2) i == n - 1 ? cout<<a[i] : cout<<a[i]<<" "; } return 0; }
补充：C++ STL有函数可以实现数组翻转，不知道在这里会不会超时
https://blog.csdn.net/hnust_xiehonghao/article/details/9197549
#include<stdio.h> #include <vector> #include <queue> #include<algorithm> using namespace std; int main() { int i; vector<int>que; for(i=0;i<10;i++) que.push_back(i); for(i=0;i<10;i++) { printf("%d ",que[i]); } printf("\n"); reverse(que.begin(),que.end()); for(i=0;i<10;i++) { printf("%d ",que[i]); } return 0; } // 上面是对int类型进行倒置 把改成vector内容改成char型也可以 改成string应该也可以
交错01串
https://www.nowcoder.com/practice/3fbd8fe929ea4eb3a254c0ed34ac993a?tpId=90&tqId=30782&tPage=1&rp=1&ru=%2Fta%2F2018test&qru=%2Fta%2F2018test%2Fquestion-ranking
题目描述
如果一个01串任意两个相邻位置的字符都是不一样的,我们就叫这个01串为交错01串。例如: "1","10101","0101010"都是交错01串。
小易现在有一个01串s,小易想找出一个最长的连续子串,并且这个子串是一个交错01串。小易需要你帮帮忙求出最长的这样的子串的长度是多少。
输入描述:
输入包括字符串s,s的长度length(1 ≤ length ≤ 50),字符串中只包含'0'和'1'
输出描述:
输出一个整数,表示最长的满足要求的子串长度。
示例1
输入
复制
111101111
输出
复制
3
思路1：双层循环遍历
依次以每个字母作为起点，往后找最长子串，将最大长度存下来
思路2：单层遍历即可
从第一个字母开始，往后寻找子串；若中断（前后两个字母相等），则用length更新max_length，且length清零；从中断点开始再往后寻找
import sys for line in sys.stdin: line = line.strip() max_length = 1 for i in range(len(line)): j = i length = 1 while j < len(line) - 1: if line[j+1] == line[j]: break j += 1 length += 1 # max_length = length if length > max_length else max_length max_length = max(max_length, length) print(max_length) # 运行时长41ms
import sys for line in sys.stdin: line = line.strip() # 必须加，最后有个换行符 length = 1 max_length = 1 for i in range(1, len(line)): if line[i-1] != line[i]: length += 1 max_length = max(max_length, length) else: length = 1 print(max_length) # 运行时长：24ms
#include<cstdio> #include<iostream> #include<string> using namespace std; int main() { string str; int length = 1, max_length = 1; cin>>str; for(int i=1; i<str.length(); i++) { if(str[i-1] != str[i]) { length++; max_length = length > max_length ? length : max_length; } else { length = 1; } } cout<<max_length<<endl; return 0; }
# 运行时长：4ms
等差数列 - 网易
https://www.nowcoder.com/practice/e11bc3a213d24fc1989b21a7c8b50c3f?tpId=90&tqId=30781&tPage=1&rp=1&ru=/ta/2018test&qru=/ta/2018test/question-ranking
题目描述
如果一个数列S满足对于所有的合法的i,都有S[i + 1] = S[i] + d, 这里的d也可以是负数和零,我们就称数列S为等差数列。
小易现在有一个长度为n的数列x,小易想把x变为一个等差数列。小易允许在数列上做交换任意两个位置的数值的操作,并且交换操作允许交换多次。但是有些数列通过交换还是不能变成等差数列,小易需要判别一个数列是否能通过交换操作变成等差数列
输入描述:
输入包括两行,第一行包含整数n(2 ≤ n ≤ 50),即数列的长度。
第二行n个元素x[i](0 ≤ x[i] ≤ 1000),即数列中的每个整数。
输出描述:
如果可以变成等差数列输出"Possible",否则输出"Impossible"。
示例1
输入
复制
3
3 1 2
输出
复制
Possible
思路：
先排序，再比较前后两个数之差，全部相等便Possible，否则Impossible
n = int(input()) x = list(map(int, input().split())) x = sorted(x) sub = x[1] - x[0] flag = 1 for i in range(n-1): if x[i + 1] - x[i] != sub: flag = 0 break if flag: print('Possible') else: print("Impossible")
#include<cstdio> #include<iostream> #include<algorithm> using namespace std; int main() { int n, x[50]; cin>>n; for(int i=0; i<n; i++) cin>>x[i]; sort(x, x+n); int d = x[1] - x[0]; bool flag = true; for(int i=0; i<n-1; i++) { if(x[i+1] - x[i] != d) { flag = false; break; } } if(flag) cout<<"Possible"<<endl; else cout<<"Impossible"<<endl; return 0; }
六一儿童节 - 拼多多
https://www.nowcoder.com/practice/d2dfc62bf1ba42679a0e358c57da9828?tpId=90&tqId=30778&tPage=1&rp=1&ru=/ta/2018test&qru=/ta/2018test/question-ranking
题目描述
六一儿童节，老师带了很多好吃的巧克力到幼儿园。每块巧克力j的重量为w[j]，对于每个小朋友i，当他分到的巧克力大小达到h[i] (即w[j]>=h[i])，他才会上去表演节目。老师的目标是将巧克力分发给孩子们，使得最多的小孩上台表演。可以保证每个w[i]> 0且不能将多块巧克力分给一个孩子或将一块分给多个孩子。
输入描述:
第一行：n，表示h数组元素个数
第二行：n个h数组元素
第三行：m，表示w数组元素个数
第四行：m个w数组元素
输出描述:
上台表演学生人数
示例1
输入
复制
3
2 2 3
2
3 1
输出
复制
1
思路：
先排序h, w；依次遍历h，优先满足最小的h
n = int(input()) h = list(map(int, input().strip().split())) m = int(input()) w = list(map(int, input().strip().split())) num = 0 h = sorted(h) w = sorted(w) for baby in h: for candy in w: if baby <= candy: w.remove(candy) num += 1 break print(num)
C++:
#include<cstdio> #include<iostream> #include<algorithm> using namespace std; int main() { int n, m, h[1000], w[1000], num = 0; cin>>n; for(int i=0; i<n; i++) cin>>h[i]; cin>>m; for(int i=0; i<m; i++) cin>>w[i]; sort(h, h+n); sort(w, w+m); int j = -1; for(int i=0; i<n; i++) { while(j<m) { j++; // 放在判断语句的前面，不然break了之后，j不会自加 if(h[i] <= w[j]) { num++; break; } } } cout<<num<<endl; return 0; }
补充：
do { 语句; } while (表达式);
do…while 和 while 的执行过程非常相似，唯一的区别是：“do…while 是先执行一次循环体，然后再判别表达式”。当表达式为“真”时，返回重新执行循环体，如此反复，直到表达式为“假”为止，此时循环结束。
while 循环体内部不一定会执行，当表达式一开始就为假的时候它就不会执行。但 do…while 不管表达式开始为真还是为假，循环体内部都会先执行一次。
大整数相乘 - 拼多多
题目描述
有两个用字符串表示的非常大的大整数,算出他们的乘积，也是用字符串表示。不能用系统自带的大整数类型。
输入描述:
空格分隔的两个字符串，代表输入的两个大整数
输出描述:
输入的乘积，用字符串表示
示例1
输入
复制
72106547548473106236 982161082972751393
输出
复制
70820244829634538040848656466105986748
Python：
num1, num2 = map(int, input().strip().split()) print(str(num1 * num2))
补充：在Python 3里，只有一种整数类型 int，表示为长整型，没有 python2 中的 Long。 int 类型在python中是动态长度的。因为python3中int类型是长整型，理论支持无限大的数字
菜鸟教程 Python3基础教程 python中int类数据的内存解析
C++：
思路： 无论使用char[]，还是使用string,先将两个数组反转，这样方便一点，没那么绕 相乘后的位数不会超过len1+len2 比如123456 * 456789 123456 456789 s[i]*s[j] 的结果应该存到ans[i+j]的位置，如果数大于10，则应把10位部分，存到ans[i+j+1] 最后应将数组反转再输出
#include<cstdio> #include<iostream> #include<string> #include<cstring> #include<algorithm> using namespace std; int main() { string str1, str2; int len1, len2; cin>>str1>>str2; len1 = str1.length(); //len1 = str1.size();也可 len2 = str2.length(); int ans[2000]; //相乘结果 memset(ans, 0, sizeof(ans)); reverse(str1.begin(), str1.end()); //反转string字符串 reverse(str2.begin(), str2.end()); for(int i=0; i<len1; i++) { for(int j=0; j<len2; j++) { int mul = (str1[i] - '0') * (str2[j] - '0'); ans[i+j] += (mul % 10); ans[i+j+1] += (mul / 10); } } for(int i=0; i<len1+len2; i++) { ans[i+1] += ans[i] / 10; ans[i] = ans[i] % 10; } int t = len1 + len2 - 1; while(!ans[t]) { t--; //获取有效结果的长度，因为最后部分为0 } while(t>=0) { cout<<ans[t]; t--; } return 0; }
下面是使用string来存储结果的一种方法，但是是不能通过的，错误原因应该是在第一个循环
#include<cstdio> #include<iostream> #include<string> #include<algorithm> using namespace std; int main() { string str1, str2; int len1, len2; cin>>str1>>str2; len1 = str1.length(); len2 = str2.length(); string ans(len1+len2, '0'); reverse(str1.begin(), str1.end()); reverse(str2.begin(), str2.end()); for(int i=0; i<len1; i++) { for(int j=0; j<len2; j++) { int mul = (str1[i] - '0') * (str2[j] - '0'); ans[i+j] += (mul % 10); ans[i+j+1] += (mul / 10); } } for(int i=0; i<len1+len2; i++) { int temp = ans[i] - '0'; ans[i] = temp % 10 + '0'; ans[i+1] = (ans[i+1] - '0') + (temp / 10) + '0'; } reverse(ans.begin(), ans.end()); int pos = ans.find_first_not_of('0'); cout<<ans.substr(pos)<<endl; return 0; }
下面是网上别人的方法，string存的
#include <iostream> #include <string> #include <vector> #include <algorithm> using namespace std; string s1,s2; int main(){ cin>>s1>>s2; int len1 = s1.length(),len2 = s2.length(); string res(len1+len2,'0'); for(int i = len1-1;i>=0;--i){ for(int j = len2-1;j>=0;--j){ int mul = (s1[i] -'0')*(s2[j] - '0'); int sum = mul+(res[i+j+1] -'0'); res[i+j+1] = (sum%10 +'0'); res[i+j] = (res[i+j] -'0') +sum/10 + '0'; } } int pos = res.find_first_not_of('0'); cout<<res.substr(pos); }
下面是之前在Noj上写的一个版本：
#include<iostream> #include<cstring> using namespace std; void multiply(int len1, int len2); int A[1001]; int B[1001]; int mul[2002]; //相乘后的位数不会超过a+b int main() { char str_A[1001]; char str_B[1001]; int len_A, len_B; int len1, len2; int i, j; while(cin>>str_A && cin>>str_B) { memset(mul,0,sizeof(mul)); len_A = 0; len_B = 0; i = 0; j = 0; while(str_A[len_A] != '\0') { len_A++; //计算A的长度 } while(str_B[len_B] != '\0') { len_B++; //计算B的长度 } len1 = len_A; len2 = len_B; while(len_A) { A[i++] = str_A[--len_A] - '0'; //字符数组倒序转int数组 } while(len_B) { B[j++] = str_B[--len_B] - '0'; //字符数组倒序转int数组 } multiply(len1, len2); } return 0; } void multiply(int len1, int len2) { for(int i=0; i<len1; i++) { for(int j=0; j<len2; j++) { mul[i+j] += A[i] * B[j]; } } int t=0; //mul的下标从0开始，len1和len2是从1开始 while(t<len1+len2-1 || mul[t]!=0) { if(mul[t] >= 10) { mul[t+1] += mul[t]/10; mul[t] = mul[t]%10; } t++; } while(t>0) { t--; cout<<mul[t]; } // for(int i=t; i>=0; i--) // { // if(t==len1+len2-1) // { // if(mul[t] == 0) // { // ; // } // else // { // cout<<mul[i]; // } // } // else // { // cout<<mul[i]; // } // } cout<<endl; } 代码G
https://www.cnblogs.com/tanrong/p/9668654.html
补充：
C++如何输入含空格的字符串 头文件 string.h cstring string 区别 C语言和C++字符串 菜鸟教程
cin是C++中最常用的输入语句，当遇到空格或者回车键即停止，不能输入带空格的字符串；使用scanf或者cin.get (char *str, int maxnum)可以解决
#include <string> 才可以可以定义string str；
1）文件cstring，和string.h对应，c++版本的头文件，包含比如strcpy之类的字符串处理函数
2）文件string.h，和cstring对应，c版本的头文件，包含比如strcpy之类的字符串处理函数
3）文件string，包含std::string的定义，属于STL范畴
4）CString，MFC里的的字符串类
C++字符串反转 c++中字符串的反转
1.对于用char定义的字符串：使用string.h中的strrev函数
#include <iostream> #include <cstring> using namespace std; int main() { char s[]="123456";//不能是string类型； strrev(s); cout<<s<<endl; return 0; }
2.对于string类型的：使用algorithm中的reverse函数
#include<iostream> #include <cstring> #include <algorithm> using namespace std; int main() { string s[]="123456"; reverse(s.begin(),s.end()); cout<<s<<endl; return 0; }
3.自己编写函数：对于字符串的两边进行交换。
C++ string类 C++string类总结
// 可以用 ==、>、<、>=、<=、和!=比较字符串，可以用+或者+=操作符连接两个字符串，并且可以用[]获取特定的字符 // 可用下列函数来获得string的一些特性： int capacity()const; //返回当前容量（即string中不必增加内存即可存放的元素个数） int max_size()const; //返回string对象中可存放的最大字符串的长度 int size()const; //返回当前字符串的大小 int length()const; //返回当前字符串的长度 bool empty()const; //当前字符串是否为空 void resize(int len,char c); //把字符串当前大小置为len，多去少补，多出的字符c填充不足的部分 // 查找函数 size_type find( const basic_string &str, size_type index ); //返回str在字符串中第一次出现的位置（从index开始查找），如果没找到则返回string::npos size_type find( const char *str, size_type index ); // 同上 size_type find( const char *str, size_type index, size_type length ); //返回str在字符串中第一次出现的位置（从index开始查找，长度为length），如果没找到就返回string::npos size_type find( char ch, size_type index ); // 返回字符ch在字符串中第一次出现的位置（从index开始查找），如果没找到就返回string::npos // 其他常用函数 string &insert(int p,const string &s); //在p位置插入字符串s string &replace(int p, int n,const char *s); //删除从p开始的n个字符，然后在p处插入串s string &erase(int p, int n); //删除p开始的n个字符，返回修改后的字符串 string substr(int pos = 0,int n = npos) const; //返回pos开始的n个字符组成的字符串 void swap(string &s2); //交换当前字符串与s2的值 string &append(const char *s); //把字符串s连接到当前字符串结尾 void push_back(char c) //当前字符串尾部加一个字符c const char *data()const; //返回一个非null终止的c字符数组，data():与c_str()类似，用于string转const char*其中它返回的数组是不以空字符终止, const char *c_str()const; //返回一个以null终止的c字符串，即c_str()函数返回一个指向正规C字符串的指针, 内容与本string串相同,用于string转const char*
为C++数组全部赋同一个值的几种方法：
#include<iostream> #include<cstring> //memset所需头文件 using namespace std; int main() { int a[10]={0}; //输出全0 int b[10] = {1}; //第一个值为1，其余为0,所以不能用这种方式赋全部的值 int c[10]; int d[10]; int e[10]; memset(c, -1, sizeof(c)); //输出全为-1 memset(c, 0, sizeof(c)); //输出全为0 /**********或者用循环*************************/ for(int i=0; i<10; i++) d[i] = 6; int j = 0; while(j<10) { e[j] = 8; j++; } for(int i=0; i<10; i++) { //cout<<a[i]<<endl; //cout<<b[i]<<endl; //cout<<c[i]<<endl; //cout<<d[i]<<endl; cout<<e[i]<<endl; } return 0; }
最大乘积 - 拼多多
题目描述
给定一个无序数组，包含正数、负数和0，要求从中找出3个数的乘积，使得乘积最大，要求时间复杂度：O(n)，空间复杂度：O(1)
输入描述:
无序整数数组A[n]
输出描述:
满足条件的最大乘积
示例1
输入
3 4 1 2
输出
24
思路： 分以下几种情况： 先将数组从小到大排列 1. 全为负数：取后3 2. 负数+0：取后3 3. 整数+0：取后3 4. 负数+正数：最后3个正数 或者 前两个负数+最后一个正数 所以最终结果为max(后3， 前2×后3)
n = int(input().strip()) # 题目上没说输入n呀，看了答案才加了这一行，汗... list = list(map(int, input().strip().split())) # list = [int(i) for i in input().strip().split() ] list = sorted(list) # list.sort() try: ans = max(list[-1] * list[-2] * list[-3], list[0] * list[1] * list[-1]) print(ans) except: print(0)
补充：
虽然python3中sort()和sorted()都可以用来排序，但二者有以下两个最主要的区别：
1. sort只能应用在列表list上，而sorted可以对所有可迭代的对象进行排序的操作
2. sort方法会在原list上直接进行排序，不会创建新的list。而sorted（）函数只会返回一个排序后的当前对象的副本，而不会改变当前对象。
a.sort() b = sorted(a)
#include<cstdio> #include<iostream> #include<algorithm> using namespace std; int main() { int n, num[10000]; long ans; long sum1, sum2; cin>>n; for(int i=0; i<n; i++) { cin>>num[i]; } sort(num, num+n); if(n < 3) ans = 0; else { sum1 = num[n-1] * num[n-2]; // sum1 = num[n-1] * num[n-2] * num[n-3] 这样连着写不行，下同 sum1 *= num[n-3]; sum2 = num[0] * num[1]; sum2 *= num[n-1]; ans = sum1 > sum2 ? sum1 : sum2; // ans = max(sum1, sum2); } cout<<ans<<endl; return 0; }
补充：
STL sort()函数： c++sort函数的使用总结
头文件：#include < algorithm>
语法：sort（begin，end，cmp），cmp参数可以没有，如果没有默认非降序排序。
- 升序：sort(begin, end, less<data-type>()); eg. sort(begin, end, less<int>());
- 降序：sort(begin, end, greater<data-type>()).
类似于快排的方法，时间复杂度为n*log2(n)
