【NowCoder华为_C++】1~36题
目录
1、字符串最后一个单词的长度
2、计算字符个数
3、随机数生成、去重、排序
4、字符串分隔（判断+递归）
5、进制转换
6、质数因子
7、浮点数四舍五入整数
8、合并表记录
9、提取不重复的整数
10、字符个数统计
11、数字颠倒
12、字符串反转
13、句子逆序
14、字符串字典排序
15、整数转二进制的1的个数
16、购物单
17、坐标移动
18、识别IP和掩码并分组
19、错误记录
20、合格的密码
21、简单密码破解
22、空汽水瓶换新
23、删除字符串中出现次数最少的字符
24、合唱队（最长上升子序列）
25、数据分类处理
26、字符串排序
27、查找兄弟单词
28、素数伴侣
29、字符串加解密
30、字符串合并处理
31、单词句子倒排
32、密码截取（最长回文）
33、IP地址和十进制转换
34、字符串排序
35、蛇形矩阵
36、字符串加密
1、字符串最后一个单词的长度
#include
#include
using namespace std;
int main()
{
string str;
getline(cin,str);
int count=0;
int len = str.length();
for(int i=(len-1);i>=0;i--)
{
if(str[i]!=' ')
count++;
else
break;
}
cout< 2、计算字符个数
#include
#include
int main()
{
std::string str;
getline(std::cin, str);
int len = str.length();
char c;
std::cin>>c;
int count = 0;
for(int i = 0; i < len; i++)
{
// 不区分大小写
if(str[i] == c || str[i] + 32 == c || str[i] - 32 == c)
count++;
}
std::cout< 3、随机数生成、去重、排序
#include
#include
int main()
{
int N,value;
std::set m_set;
while(std::cin >> N)
{
m_set.clear();
while(N--)
{
std::cin >> value;
m_set.insert(value);
}
for (std::set::iterator it = m_set.begin(); it != m_set.end(); it++)
std::cout << *it << std::endl;
}
return 0;
} 4、字符串分隔（判断+递归）
#include
using namespace std;
void Process(string str) {
if (str.size() <= 8) {
int judge = 8-str.size();
for (int i = 0; i < judge; i++)
str += '0';
cout << str << endl;
} else {
string temp(str, 0, 8);
cout << temp << endl;
str.erase(str.begin(), str.begin()+8);
Process(str);
}
}
int main() {
string str1;
string str2;
cin >> str1;
cin >> str2;
Process(str1);
Process(str2);
return 0;
} 5、进制转换
#include
#include
#include
using namespace std;
int main()
{
string s;
while(cin>>s)
{
int bit=0;
int ans =0;
for(int i=s.length()-1;i>1;i--)
{
if(s[i]>='0'&&s[i]<='9')
ans+=(s[i]-'0')*pow(16,bit++);
else if(s[i]>='A'&&s[i]<='F')
ans+=(s[i]-'A'+10)*pow(16,bit++);
}
cout< 6、质数因子
#include
using namespace std;
int main()
{
long a;
while(cin>>a)
{
while(a!=1)
{
for(int i=2;i<=a;i++)
{
if(a%i==0)
{
//第一遍错误原因是不需要换行！！！！！
cout< 7、浮点数四舍五入整数
#include
using namespace std;
int main()
{
double num;
cin>>num;
if(num-(int)num>=0.5)
cout< 8、合并表记录
#include
#include 9、提取不重复的整数
#include
#include
using namespace std;
int main()
{
int num,n;
vector hash(10,0);
cin>>n;
while(n>0)
{
num=n%10;
n/=10;
if(hash[num]==0)
{
hash[num]=1;
cout< 10、字符个数统计
#include
#include 11、数字颠倒
#include
using namespace std;
int main()
{
int n;
cin>>n;
while(n>0)
{
cout< 12、字符串反转
13、句子逆序
#include
#include
#include
using namespace std;
int main()
{
string str;
stack s;
while(cin>>str)
{
s.push(str);
}
while(!s.empty())
{
cout< 14、字符串字典排序
#include
#include
#include
#include
using namespace std;
int main()
{
int n;
vector s;
string tmp;
while(cin>>n)
{
for(int i=0;i>tmp;
s.push_back(tmp);
}
sort(s.begin(),s.end());
}
for(auto x:s) cout< 15、整数转二进制的1的个数
#include
using namespace std;
int main()
{
int n,ans=0;
cin>>n;
while(n>0)
{
ans+=(n%2);
n/=2;
}
cout< 16、购物单
#include
#include
using namespace std;
int max(int m, int n)
{
return m>n?m:n;
}
int dp[3200];
int main()
{
int N,n,v,p,q;
cin >> N >> n;
N = N/10;
int *ZJ_Pri = new int[n+1](); int *ZJ_Imp = new int[n+1]();
int *FJ1_Pri = new int[n+1](); int *FJ1_Imp = new int[n+1]();
int *FJ2_Pri = new int[n+1](); int *FJ2_Imp = new int[n+1]();
for(int i=1; i<=n; i++)
{
cin >> v >> p >> q;
v = v / 10;
if(q == 0)
{
ZJ_Pri[i] = v;
ZJ_Imp[i] = v * p;
}
else if(FJ1_Pri[q] == 0)
{
FJ1_Pri[q] = v;
FJ1_Imp[q] = v * p;
}
else
{
FJ2_Pri[q] = v;
FJ2_Imp[q] = v * p;
}
}
for(int i = 1; i <= n; i++)//i---前i个物品
{
for(int j = N; j >=1; j--)//j--当前的钱数
{
if(j >= ZJ_Pri[i])
dp[j] = max(dp[j], dp[ j-ZJ_Pri[i] ] + ZJ_Imp[i]);
if(j >= ZJ_Pri[i] + FJ1_Pri[i])
dp[j] = max(dp[j], dp[ j-ZJ_Pri[i]-FJ1_Pri[i] ] + ZJ_Imp[i] + FJ1_Imp[i]);
if(j >= ZJ_Pri[i] + FJ2_Pri[i])
dp[j] = max(dp[j], dp[ j-ZJ_Pri[i]-FJ2_Pri[i] ] + ZJ_Imp[i] + FJ2_Imp[i]);
if(j >= ZJ_Pri[i] + FJ1_Pri[i] + FJ2_Pri[i])
dp[j] = max(dp[j], dp[ j-ZJ_Pri[i]-FJ1_Pri[i]-FJ2_Pri[i] ] + ZJ_Imp[i] + FJ1_Imp[i] + FJ2_Imp[i]);
}
}
cout << dp[N]*10 << endl;
delete[] ZJ_Pri;
delete[] ZJ_Imp;
delete[] FJ1_Pri;
delete[] FJ1_Imp;
delete[] FJ2_Pri;
delete[] FJ2_Imp;
return 0;
} 17、坐标移动
#include
#include
#include
using namespace std;
int main()
{
string Input;
while(cin>>Input)
{
int x=0,y=0;
int len = Input.length();
vector vec;
int keep=0;
for(int i=0;i='0'&&vec[i][1]<='9'&&vec[i][2]>='0'&&vec[i][2]<='9')
num=(vec[i][1]-'0')*10+(vec[i][2]-'0');
if(vec[i].length()==2&&vec[i][1]<='9'&&vec[i][1]>='0')
num=(vec[i][1]-'0');
if(vec[i].length()==1)
num=0;
switch(vec[i][0])
{
case 'A': x -= num;break;
case 'D': x += num;break;
case 'S': y -= num;break;
case 'W': y += num;break;
default:break;
}
}
cout< 18、识别IP和掩码并分组
#include
#include
#include
using namespace std;
vector> vec;
vector tmp;
vector res(7,0);
//收集字符串，并转化为数字。
//如果收集到的数字大于255，res[5]++ ,vec不保存
//如果连续出现两个'.'，res[5]++ ,vec不保存
void getstr(string str) {
while(cin >> str) {
int flag = 0;
int size = str.size();
int num = 0;
for(int i=0; i= 1 && str[i] == '.' && str[i-1] == '.') {
res[5]++;
flag = 1;
break;
}
if(str[i] != '.' && str[i] != '~') {
num = num*10 + str[i] - '0';
} else {
if(num > 255) {res[5]++; flag = 1; break;}
tmp.push_back(num);
num = 0;
}
}
if(flag) continue;
tmp.push_back(num);
vec.push_back(tmp);
tmp.clear();
}
}
//判断是否为掩码
bool ismask(vector mask) {
if((mask[4] == 254 || mask[4] == 252 || mask[4] == 248 || mask[4] == 240 || mask[4] == 224 || mask[4] == 192 || mask[4] == 128) &&
(mask[5] == 0 && mask[6] == 0 && mask[7] == 0)) return true;
if(mask[4] == 255 &&
(mask[5] == 254 || mask[5] == 252 || mask[5] == 248 || mask[5] == 240 || mask[5] == 224 || mask[5] == 192 || mask[5] == 128 || mask[5] == 0)
&& (mask[6] == 0 && mask[7] == 0)) return true;
if(mask[4] == 255 && mask[5] == 255 &&
(mask[6] == 254 || mask[6] == 252 || mask[6] == 248 || mask[6] == 240 || mask[6] == 224 || mask[6] == 192 || mask[6] == 128 || mask[6] == 0)
&& mask[7] == 0) return true;
if(mask[4] == 255 && mask[5] == 255 && mask[6] == 255 &&
(mask[7] == 254 || mask[7] == 252 || mask[7] == 248 || mask[7] == 240 || mask[7] == 224 || mask[7] == 192 || mask[7] == 128 || mask[7] == 0))
return true;
return false;
}
/*
//判断所有的IP地址划分为 A,B,C,D,E五类
A类地址1.0.0.0~126.255.255.255;
B类地址128.0.0.0~191.255.255.255;
C类地址192.0.0.0~223.255.255.255;
D类地址224.0.0.0~239.255.255.255；
E类地址240.0.0.0~255.255.255.255
私网IP范围是：
10.0.0.0～10.255.255.255
172.16.0.0～172.31.255.255
192.168.0.0～192.168.255.255 */
void judge(void){
int size = vec.size();
for(int i=0; i= 1 && vec[i][0] < 127) res[0]++;
if(vec[i][0] >= 128 && vec[i][0] < 192) res[1]++;
if(vec[i][0] >= 192 && vec[i][0] < 224) res[2]++;
if(vec[i][0] >= 224 && vec[i][0] < 240) res[3]++;
if(vec[i][0] >= 240 && vec[i][0] <= 255) res[4]++;
if(vec[i][0] == 10 ||
(vec[i][0] == 172 && vec[i][1] >= 16 && vec[i][1] < 32) ||
(vec[i][0] == 192 && vec[i][1] == 168)) res[6]++;
}
}
int main() {
string str;
getstr(str);
judge();
cout << res[0] << ' ' << res[1] << ' ' << res[2] << ' ' << res[3] << ' ' < 19、错误记录
#include
#include
#include
#include 20、合格的密码
#include
#include
using namespace std;
const string Err = "NG";
const string Ok = "OK";
enum type {
LOWER,
UPPER,
DIGIT,
OTHER,
MAX,
};
int main(void)
{
string s;
while (cin >> s){
//cout << "s : " << s << endl;
if (s.size() <= 8){
cout << Err << endl;
continue;
}
int State[type::MAX] = {0};
for (char c : s){
if (islower(c)){
State[type::LOWER] += 1;
}else if (isupper(c)){
State[type::UPPER] += 1;
}else if (isdigit(c)){
State[type::DIGIT] += 1;
}else{
State[type::OTHER] += 1;
}
}
int typenum = 0;
for (int i = 0; i < type::MAX; ++i){
if (State[i] > 0) typenum += 1;
}
if (typenum < 3){
cout << Err << endl;
continue;
}
// 判断有没有长度超过 2 的子串
int max_substr_len = 3;
string target;
bool isFound = false;
for (int i = 0; i < s.size()-max_substr_len; i ++){
for (int j = i + max_substr_len; j < s.size()-max_substr_len; j ++){
// 如果字符串相同
if (0 == s.compare(i, max_substr_len, s, j, max_substr_len)){
isFound = true;
break;
}
}
if (isFound) break;
}
if (isFound)
cout << Err << endl;
else
cout << Ok << endl;
}
return 0;
} 21、简单密码破解
#include
using namespace std;
int main()
{
int a[26]={2,2,2,3,3,3,4,4,4,5,5,5,6,6,6,7,7,7,7,8,8,8,9,9,9,9};
string str;
int i;
while(cin>>str)
{
for(i=0;i='A'&&str[i]<='Z')
{
str[i]+=33;
if(str[i]>'z')
{
str[i]-=26;
}
}
else if(str[i]>='a'&&str[i]<='z')
{
str[i]='0'+a[str[i]-'a'];
}
}
cout< 22、空汽水瓶换新
#include
#include
using namespace std ;
auto SWAPBOTTLENUM = 3 ;//3个konp
int solution(int emptyBottles)
{
if(emptyBottles == SWAPBOTTLENUM-1)
return 1 ;
else if(emptyBottles < SWAPBOTTLENUM-1)
return 0 ;
int drinked = 0 ;
int rest = 0 ;
drinked = emptyBottles / SWAPBOTTLENUM ;
rest = drinked + emptyBottles % SWAPBOTTLENUM ;
return drinked + solution(rest) ;
}
int main(int argc, char *argv[])
{
vector emp ;
vector sol ;
int temp ;
while(cin >> temp && temp != 0)
emp.push_back(temp) ;
for(auto item : emp)
sol.push_back(solution(item)) ;
for(auto item : sol){
cout << item << endl ;
}
return 0;
} 23、删除字符串中出现次数最少的字符
#include
#include
#include 24、合唱队（最长上升子序列）
#include
using namespace std;
int main()
{
int n;
int m[10000], dp1[10000], dp2[10000];
while(cin >> n)
{
for(int i = 0; i < n; i++)
{
cin >> m[i];
dp1[i] = 1;
for(int j = 0; j < i; j++)
{
if(m[i] > m[j]) dp1[i] = max(dp1[i], dp1[j]+1);
}
}
for(int i = n-1; i >= 0; i--)
{
dp2[i] = 1;
for(int j = n-1; j >= i; j--)
{
if(m[i] > m[j]) dp2[i] = max(dp2[i], dp2[j]+1);
}
}
int mn = 0;
for(int i = 0; i < n; i++)
{
if(dp1[i] + dp2[i] - 1 > mn) mn = dp1[i] + dp2[i] - 1;
}
cout << n-mn << endl;
}
return 0;
} 25、数据分类处理
#include
#include
#include
#include
#include
#include
using namespace std;
int I[10001];
bool has[10001];
bool check(int r, int i){//检测包含 i 包含 r
if(r>i)
return false;
int top = 1;
int bot = 1;
while(r/top!=0){
top*=10;
}
if(r==0){
top=10;
}
int k=0;
while(i*10/top!=0){
k=(i%top)/bot;
top*=10;
bot*=10;
if(k==r)
return true;
}
return false;
}
int main(){
int num_r;
int num_i;
int Rs;
set set_r;
vector output;
std::set::iterator it;
while(scanf("%d",&num_i)!=EOF){
set_r.clear();
output.clear();
for(int i=0;i 26、字符串排序
#include
using namespace std;
bool isChar(char ch){
return (ch>='a'&&ch<='z') || (ch>='A' && ch <='Z');
}
int toInt(char ch){
return ch>='A'&&ch <='Z'?ch-'A':ch-'a';
}
int main() {
string str;
while (getline(cin, str)){
int lastSwap;
int next, temp;
for(int j=str.size()-1;j>0;j=lastSwap){
lastSwap = 0;
for(int i=0; itoInt(str[next])){
temp = str[next];
str[next] = str[i];
str[i] = temp;
lastSwap = i;
}
}
}
}
cout << str << endl;
}
return 0;
} 27、查找兄弟单词
#include
#include
#include
using namespace std;
int Search_Brother_Word(int num)
{
string str; //字典里面的单词（小写英文字符）
string word; //指定的单词
vector vec; //用一个向量来存储单词（形成单词字典）
vector vec_BW; //用一个向量来存储兄弟单词（形成兄弟单词字典），BW 代表 Brother Word
int BW_index; //序号，用于查找指定单词的所有兄弟单词中序号所对应的兄弟单词（序号减一，因为从零开始）
//输入单词，形成单词字典
for (int i = 0; i < num; i++)
{
cin >> str;
vec.push_back(str);
}
sort(vec.begin(), vec.end()); //输入的多个单词按字典序排列
cin >> word; //指定单词，当然这个单词可能在、也可能不在原来的字典里面
cin >> BW_index; //指定单词 word 的所有兄弟单词中排在第 BW_index 的单词对应序号 BW_index - 1
//判断字典中的单词是否为指定单词的兄弟单词，若是，则将其写入兄弟单词向量 vec_BW
string word_copy = word; //拷贝一份指定的单词，作为基准比较（字母顺序未变动）
sort(word.begin(), word.end()); //指定的单词的字母按字典序排列
//遍历单词字典，寻找指定单词的兄弟单词并记录在兄弟单词字典中
for (int i = 0; i < vec.size(); i++)
{
//先判断字典中的单词的长度和指定单词的长度是否一致
if (vec[i].size() == word.size())
{
//长度相同且字母顺序不同的单词，才可能是兄弟单词，这里反复用单词的拷贝来作为基准
if (vec[i] != word_copy)
{
string copy = vec[i]; //提前拷贝一份字典中的单词，作为后续写入兄弟单词字典的样本（需要的话）
sort(vec[i].begin(), vec[i].end()); //字典中的单词的字母按字典序排列
//原本不相同的单词，经过字母排序后相同，才是互为兄弟单词
if (vec[i] == word)
{
vec_BW.push_back(copy);
}
}
}
}
//分类输出结果
//兄弟单词字典为空
if (vec_BW.size() == 0)
{
cout << 0 << endl;
}
//兄弟单词字典不为空，但待查找的兄弟单词不存在
else if (((vec_BW.size() > 0) && (vec_BW.size() < BW_index)) || ((vec_BW.size() > 0) && (BW_index < 1)))
{
cout << vec_BW.size() << endl;
}
//兄弟单词字典不为空，且待查找的兄弟单词存在
else if ((vec_BW.size() > 0) && (vec_BW.size() >= BW_index) && (BW_index >= 1))
{
cout << vec_BW.size() << '\n' << vec_BW[BW_index - 1] << endl;
}
return 0;
}
//主函数
int main()
{
int num;
while (cin >> num)
{
Search_Brother_Word(num);
}
return 0;
} 28、素数伴侣
#include
#include
#include
using namespace std;
class HungarianAlgorithm
{
public:
typedef std::list< std::pair > pairmatch;
private:
bool** graph;
size_t* match;
bool* request;
bool dfs(size_t i, size_t ny)
{
for (size_t j = 0; j < ny; ++j)
if (graph[i][j] && request[j])
{
request[j] = false;
if (match[j] == -1 || dfs(match[j], ny))
{
match[j] = i;
return request[j] = true;
}
}
return false;
}
protected:
pairmatch pairlist;
public:
template
HungarianAlgorithm(type const & G, size_t nx, size_t ny)
{
if (nx && ny)
{
graph = new bool*[nx];
for (size_t i = 0; i < nx; ++i)
graph[i] = new bool[ny];
match = new size_t[ny];
request = new bool[ny];
for (size_t i = 0; i < nx; ++i)
for (size_t j = 0; j < ny; ++j)
graph[i][j] = G(i, j);
for (size_t j = 0; j < ny; ++j)
match[j] = -1;
for (size_t j = 0; j < ny; ++j)
request[j] = true;
for (size_t i = 0; i < nx; ++i)
dfs(i, ny);
for (size_t j = 0; j < ny; ++j)
if (match[j] != -1)
pairlist.emplace_back(match[j], j);
for (size_t i = 0; i < nx; ++i)
delete[] graph[i];
delete[] graph;
delete[] match;
delete[] request;
}
}
pairmatch const& getmatch()const { return pairlist; }
};
bool isPrime(size_t n)
{
for (size_t i = 2; i*i <= n; ++i)
if (n%i == 0)
return false;
return true;
}
int main(void)
{
size_t n;
size_t data;
while (cin >> n)
{
vector< size_t > X, Y;
X.reserve(n);
Y.reserve(n);
size_t nx = 0;
size_t ny = 0;
for (size_t i = 0; i < n; ++i)
{
cin >> data;
if (data % 2)
X[nx++] = data;
else
Y[ny++] = data;
}
auto G = [&](size_t i, size_t j) {return isPrime(X[i] + Y[j]); };
auto p = HungarianAlgorithm(G, nx, ny).getmatch();
cout << p.size() << endl;
}
return 0;
}
29、字符串加解密
#include
#include
#include
using namespace std;
vector v1;
vector v2;
void EnCode(char ch)
{
if (ch>= 'a' && ch <= 'z')
{
if (ch == 'z') ch = 'A';
else
ch= ch - 31;
}
else if (ch >= 'A' && ch <= 'Z')
{
if (ch == 'Z') ch = 'a';
else
ch = ch +33;
}
else if (ch >= '0' && ch <= '9')
{
if (ch == '9') ch = '0';
else
ch = ch+1;
}
v1.push_back(ch);
}
void DeCode(char ch)
{
if (ch >= 'a' && ch <= 'z')
{
if (ch == 'a') ch = 'Z';
else
ch = ch - 33;
}
else if (ch >= 'A' && ch <= 'Z')
{
if (ch =='A') ch = 'z';
else
ch = ch + 31;
}
else if (ch >= '0' && ch <= '9')
{
if (ch == '0') ch = '9';
else
ch = ch - 1;
}
v2.push_back(ch);
}
int main()
{
string str1;
string str2;
while (getline(cin, str1))
{
getline(cin, str2);
if (str1 == "" || str2 == "") break;
int len1 = str1.size();
int len2 = str2.size();
for (int i = 0; i < len1; i++)
{
EnCode(str1[i]);
}
for (int i = 0; i < len2; i++)
{
DeCode(str2[i]);
}
for (int i = 0; i < v1.size(); i++)
cout << v1[i];
cout << endl;
for (int i = 0; i < v2.size(); i++)
cout << v2[i];
cout << endl;
v1.clear();
v2.clear();
}
} 30、字符串合并处理
#include
#include
using namespace std;
//字符串合并处理的函数接口
void Process_String(string str1, string str2, string strOutput)
{
//字典法：只考虑 '0' 到 '9' ，'a' 到 'f'，'A' 到 'F' 的字符即可，其余字符不做改变，照原输出
char Intput[] = {"0123456789abcdefABCDEF"}; //输入参照字典（数字 + 大小写字母）
// int Output[] = "084c2a6e195d3b7f5d3b7f"; //输出参照字典（小写）
char Output[] = {"084C2A6E195D3B7F5D3B7F"}; //输出参照字典（数字 + 大写字母）
strOutput = str1 + str2; //合并两个字符串
string odd_str; //下标为奇数的字符组成的字符串，奇数位字符串
string even_str; //下标为偶数的字符串组成的字符串，偶数位字符串
//根据字符在合并字符串中的次序，按字典序分奇数位、偶数位独立来排，但次序的奇偶性不变，即原来是奇数位，排序后还是奇数位
for (int i = 0; i < strOutput.size(); i++)
{
if (i % 2 == 0)
{
odd_str += strOutput[i];
}
else if (i % 2 == 1)
{
even_str += strOutput[i];
}
}
sort(odd_str.begin(), odd_str.end()); //奇排序
sort(even_str.begin(), even_str.end()); //偶排序
//将按奇数位、偶数位排序后的字符再填回合并字符串 strOutput
int j = 0; //奇数位字符串的下标
int k = 0; //偶数位字符串的下标
for (int i = 0; i < strOutput.size(); i++)
{
if (i % 2 == 0)
{
strOutput[i] = odd_str[j];
j++;
}
else if (i % 2 == 1)
{
strOutput[i] = even_str[k];
k++;
}
}
//对字符（符合字典 Input[]）所代表的 16 进制的数进行 BIT 倒序的操作，并转换为相应的大写字符
for (int i = 0; i < strOutput.size(); i++)
{
if ((strOutput[i] >= '0') && (strOutput[i] <= '9'))
{
strOutput[i] = Output[strOutput[i] - '0'];
}
else if ((strOutput[i] >= 'a') && (strOutput[i] <= 'f'))
{
strOutput[i] = Output[strOutput[i] - 'a' + 10];
}
else if ((strOutput[i] >= 'A') && (strOutput[i] <= 'F'))
{
strOutput[i] = Output[strOutput[i] - 'A' + 16];
}
}
cout << strOutput << endl;
return;
}
//主函数
int main()
{
string str1, str2, strOutput;
while (cin >> str1 >>str2)
{
Process_String(str1, str2, strOutput);
}
return 0;
} 31、单词句子倒排
#include
#include
#include
using namespace std;
//单词倒排的函数接口
int Word_Rev_Sort(string str)
{
vector vec; //用向量来存储单词
int len = str.size(); //获取字符串的长度
int sublen = 0; //记录每个子字符串（单词）的长度
//将句子中的单词分割，并将除最后一个单词之外的单词写入向量（如句子包含多个单词时）
for(int i = 0; i < len; i++)
{
if(((str[i] >= 'a') && (str[i] <= 'z')) || ((str[i] >= 'A') && (str[i] <= 'Z')))
{
sublen++;
continue;
}
else
{
if (sublen > 0)
{
vec.push_back(str.substr(i - sublen, sublen)); //将单词写入向量
sublen = 0; //重置单词的长度，记录下一个新单词的长度
}
}
}
//将最后一个单词写入向量，当句子仅有一个单词时同样适用
if (sublen > 0)
{
vec.push_back(str.substr(len - sublen, sublen)); //将单词写入向量
}
//倒序输出单词，并用空格隔开，形成单词倒排的句子
for (int i = vec.size() - 1; i > 0; i--)
{
cout << vec[i] << ' ';
}
cout << vec[0] << endl;
return 0;
}
//主函数
int main ()
{
string str;
while (getline(cin, str))
{
Word_Rev_Sort(str);
}
return 0;
} 32、密码截取（最长回文）
//思路：以某个元素为中心，向两边扩展，分别计算
//偶数长度的回文最大长度和奇数长度的回文最大长度。
//时间复杂度O(n^2)
#include
#include
using namespace std;
int main(){
string s;
while(cin>>s){
const int len = s.size();
if(len <= 1) return -1;
int maxLen = 0;
for(int i = 1; i < len; i++){
//寻找以i-1,i为中点偶数长度的回文
int low = i-1, high = i;
while(low >= 0 && high < len && s[low] == s[high]){
low--; high++;
}
if(high - low - 1 > maxLen)
maxLen = high - low -1;
//寻找以i为中心的奇数长度的回文
low = i- 1; high = i + 1;
while(low >= 0 && high < len && s[low] == s[high]){
low--; high++;
}
if(high - low - 1 > maxLen)
maxLen = high - low -1;
}
cout< 33、IP地址和十进制转换
#include
using namespace std;
int main()
{
long long n, a1, a2, a3, a4;
char ch;
while(cin >> a1 >> ch >> a2 >> ch >> a3 >> ch >> a4)
{
cin >> n;
long long res = 0;
res += (a1 << 24) + (a2 << 16) + (a3 << 8) + a4;
a1 = n >> 24;
a2 = (n >> 16) & 255;
a3 = (n >> 8) & 255;
a4 = n & 255;
cout << res << endl << a1 << '.' << a2 << '.' << a3 << '.' << a4 << endl;
}
return 0;
} 34、字符串排序
#include
#include
#include
#include
using namespace std;
vector a;
int main()
{
string str;
while (cin >> str)
{
a.clear();
int len = str.size();
for (int i = 0; i < len; i++)
{
a.push_back(str[i]);
}
sort(a.begin(), a.end());
for (vector::iterator it = a.begin(); it != a.end(); it++)
{
cout << *it;
}
cout << endl;
}
return 0;
} 35、蛇形矩阵
//解题思路：笨方法
//蛇形矩阵，顾名思义像蛇摆一样，具有弯曲但连续这个特点；
//从矩阵特点来看，就是沿着方阵的主对角线斜向下方向，以及沿着副对角线斜向上，依次递增 1；
//从输出矩阵元素的个数来看，总数是一个首项为 1 且公差为 1 的等差数列前 N 项和；
//利用等差数列的规律，可以得知，每一行或每一列的数列是一个阶梯级数（相邻两项的差逐渐递增）。
#include
using namespace std;
//输出蛇形矩阵的函数接口
int SerpentineMatrix (int N) {
int Column_d = 1; //初始化列间相邻两项的第一个差
int ColumnFirstItem = 1; //列首项
int RowFirstItem = 1; //行首项
//按行顺序输出矩阵元素
for (int i = 1; i <= N; i++) {
RowFirstItem = ColumnFirstItem; //将第 1 列的第 i 个元素按顺序拷贝作为第 i 行的首个元素
cout << ColumnFirstItem << ' '; //输出第 i 行的首个元素
ColumnFirstItem += Column_d;
Column_d++; //相邻两项的差递增 1
int Row_d = i + 1; //初始化第 i 行元素的行间相邻两项的第一个差
//按列顺序输出第 i 行的矩阵元素
for (int j = i + 1; j <= N; j++) {
RowFirstItem += Row_d;
cout << RowFirstItem << ' '; //输出第 i 行除首个元素之外的其余元素
Row_d++; //相邻两项的差递增 1
}
cout << endl; //第 i 行元素输出结束，换行。
}
return 0;
}
//主函数
int main (){
int N; //矩阵的阶数 N，由于是正整数，故大于或等于 1。
while (cin >> N) {
SerpentineMatrix (N);
}
return 0;
} 36、字符串加密
#include
#include
using namespace std;
void encrypt(string &key, string &str){
int flag[26] = {0};
string table;
for(auto &c : key){
c = toupper(c); // 转大写
if(!flag[c - 'A']){ // 去重
table.push_back(c);
flag[c - 'A'] = 1;
}
}
string tmp = table;
for(int i = 'A'; i <= 'Z'; ++i){
if(string::npos == tmp.find(i)) // 在tmp中没有找到
table.push_back(i);
}
for(auto &c : str){
if(isupper(c))
c = toupper(table[c - 'A']);
else
c = tolower(table[c - 'a']);
}
}
int main(){
string key, str;
while(cin >> key >> str){
encrypt(key, str);
cout << str << endl;
}
return 0;
}