牛客网 - 2018校招真题

时间 2020-06-22

原文原文链接

排序 - 爱奇艺

https://www.nowcoder.com/practice/e496d8e885a949d18476b2dea1e594a9?tpId=90&tqId=30794&tPage=1&rp=1&ru=%2Fta%2F2018test&qru=%2Fta%2F2018test%2Fquestion-rankinghtml

题目描述
牛牛有一个长度为n的整数序列,牛牛想对这个序列进行重排为一个非严格升序序列。牛牛比较懒惰,他想移动尽可能少的数就完成重排,请你帮他计算一下他最少须要移动多少个序列中的元素。(当一个元素不在它原来所在的位置,这个元素就是被移动了的)
输入描述:
输入包括两行,第一行一个整数n(1 ≤ n ≤ 50),即序列的长度
第二行n个整数x[i](1 ≤ x[i] ≤ 100),即序列中的每一个数
输出描述:
输出一个整数,即最少须要移动的元素个数
示例1
输入
复制
3
3 2 1
输出
复制
2python

思路：先将数组备份到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; }

补充：ios

C++如何复制数组？c++

1. 字符数组 - strcpy()git

头文件：#include <string.h> 或者 #include <cstring>web

char *strcpy(char *dest, const char *src) 两个参数分别是目标数组和源数组，该函数返回一个指向最终的目标字符串 dest 的指针（不过通常并不须要用变量接收，直接strcpy(y, x)便可）。数组

2. int,float,double等数组 - memcpy()app

头文件：#include <string.h> 或者 #include <cstring>less

memcpy(void *str1, const void *str2, size_t n) 参数分别为目标数组、源数组、要被复制的字节数。ide

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次如下操做:
一、将a_i放入b序列的末尾
二、逆置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))

Python

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 无论表达式开始为真仍是为假，循环体内部都会先执行一次。

大整数相乘 - 拼多多

https://www.nowcoder.com/practice/0f0badf5f2204a6bb968b0955a82779e?tpId=90&tqId=30777&tPage=1&rp=1&ru=%2Fta%2F2018test&qru=%2Fta%2F2018test%2Fquestion-ranking

题目描述
有两个用字符串表示的很是大的大整数,算出他们的乘积，也是用字符串表示。不能用系统自带的大整数类型。
输入描述:
空格分隔的两个字符串，表明输入的两个大整数
输出描述:
输入的乘积，用字符串表示
示例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); }

C++

下面是以前在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

View Code

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; }

View Code

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; }

View Code

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; }

C++数组赋值

最大乘积 - 拼多多

https://www.nowcoder.com/practice/5f29c72b1ae14d92b9c3fa03a037ac5f?tpId=90&tqId=30776&tPage=1&rp=1&ru=%2Fta%2F2018test&qru=%2Fta%2F2018test%2Fquestion-ranking

题目描述
给定一个无序数组，包含正数、负数和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)