排序 - 爱奇艺
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)
# 运行时长41msimport 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，否则Impossiblen = 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;
}
代码Ghttps://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)
来源：oschina
链接：https://my.oschina.net/u/4342638/blog/3608268