c++编程题数串

最新推荐文章于 2024-08-22 16:18:40 发布

7Maggie_C

最新推荐文章于 2024-08-22 16:18:40 发布

阅读量812

点赞数

分类专栏： c++ 文章标签： c

本文链接：https://blog.csdn.net/qq_36770641/article/details/81175998

版权

c++ 专栏收录该内容

42 篇文章 4 订阅

订阅专栏

刚刚结束小程序的比赛，今天进实验室把python-opencv的环境装了下，要开始好好学习了。

晚上无聊做了下c++的编程题，才发现好多东西都忘完了，悲催啊。好歹学的时候也92高分飘过呢。

不说了，看看这道题吧：

题目描述

设有n个正整数，将他们连接成一排，组成一个最大的多位整数。
如:n=3时，3个整数13,312,343,连成的最大整数为34331213。
如:n=4时,4个整数7,13,4,246连接成的最大整数为7424613。

输入描述:

有多组测试样例，每组测试样例包含两行，第一行为一个整数N（N<=100），第二行包含N个数(每个数不超过1000，空格分开)。

输出描述:

每组数据输出一个表示最大的整数。

示例1

输入

输出

12312
7424613

拿到题先分析下，一开始动手写的时候觉得挺简单的，就是找到每个数的最高位的值并比较，然后从大到小输出就行了，以下是我的原思路：

//
//  main.cpp
//  c++
//
//  Created by Maggie on 18/7/23.
//  Copyright © 2018年 Maggie. All rights reserved.
//

#include<iostream>
#include<cmath>
#include<algorithm>
using namespace std;
int main(void){
    int N;
    int nArr[100];
    int a[100];
    
    int datamax=0;
    int index=0;
    
    cin>>N;
   
    for(int i=0;i<N;i++){
        cin>>nArr[i];
        while(nArr[i]>10){        //找到每个数最高位的值
           a[i]= nArr[i]/10;
        }
        
    }
    
 
    for(int k=0;k<N;k++){
        if(datamax<a[k]){
            datamax=a[k];
            index=k;
        }
    }
    cout<<nArr[index];
    a[index]=0;

    
}

哈哈，应该没人运行吧。。是的，写着写着发现不对劲了，这样嵌套循环未免太多了，再写下去还有n-1次循环，电脑直接罢机了。原因还是由于太久不用c++，上来就用最笨的方法莽，唉，悲催啊。

最后去借鉴了下别人的思路，看到一大神，唰唰俩下解决战斗，由衷佩服，代码如下：

#include <string>
#include <algorithm>
#include <vector>
#include <iostream>
using namespace std;
int main() {
    int n;
    cin >> n;
    vector<string> sArray;
    for (int i=0;i<n;i++) {
        string temp;
        cin >> temp;
        sArray.push_back(temp);
    }
    sort(sArray.begin(), sArray.end(), [](string s1, string s2){
        return (s1+s2) > (s2+s1);
    });
    for (auto s:sArray) {
        cout << s;
    }
    return 0;
}

核心思路：

向量（Vector）是一个封装了动态大小数组的顺序容器（Sequence Container）。跟任意其它类型容器一样，它能够存放各种类型的对象。可以简单的认为，向量是一个能够存放任意类型的动态数组。

容器特性

1.顺序序列

顺序容器中的元素按照严格的线性顺序排序。可以通过元素在序列中的位置访问对应的元素。

2.动态数组

支持对序列中的任意元素进行快速直接访问，甚至可以通过指针算数进行该操作。操供了在序列末尾相对快速地添加/删除元素的操作。

3.能够感知内存分配器的（Allocator-aware）

容器使用一个内存分配器对象来动态地处理它的存储需求。

基本函数实现

1.构造函数

vector():创建一个空vector
vector(int nSize):创建一个vector,元素个数为nSize
vector(int nSize,const t& t):创建一个vector，元素个数为nSize,且值均为t
vector(const vector&):复制构造函数
vector(begin,end):复制[begin,end)区间内另一个数组的元素到vector中

2.增加函数

void push_back(const T& x):向量尾部增加一个元素X
iterator insert(iterator it,const T& x):向量中迭代器指向元素前增加一个元素x
iterator insert(iterator it,int n,const T& x):向量中迭代器指向元素前增加n个相同的元素x
iterator insert(iterator it,const_iterator first,const_iterator last):向量中迭代器指向元素前插入另一个相同类型向量的[first,last)间的数据

3.删除函数

iterator erase(iterator it):删除向量中迭代器指向元素
iterator erase(iterator first,iterator last):删除向量中[first,last)中元素
void pop_back():删除向量中最后一个元素
void clear():清空向量中所有元素

4.遍历函数

reference at(int pos):返回pos位置元素的引用
reference front():返回首元素的引用
reference back():返回尾元素的引用
iterator begin():返回向量头指针，指向第一个元素
iterator end():返回向量尾指针，指向向量最后一个元素的下一个位置
reverse_iterator rbegin():反向迭代器，指向最后一个元素
reverse_iterator rend():反向迭代器，指向第一个元素之前的位置

5.判断函数

bool empty() const:判断向量是否为空，若为空，则向量中无元素

6.大小函数

int size() const:返回向量中元素的个数
int capacity() const:返回当前向量张红所能容纳的最大元素值
int max_size() const:返回最大可允许的vector元素数量值

7.其他函数

void swap(vector&):交换两个同类型向量的数据
void assign(int n,const T& x):设置向量中第n个元素的值为x
void assign(const_iterator first,const_iterator last):向量中[first,last)中元素设置成当前向量元素

8.看着清楚

1.push_back 在数组的最后添加一个数据

2.pop_back 去掉数组的最后一个数据

3.at 得到编号位置的数据

4.begin 得到数组头的指针

5.end 得到数组的最后一个单元+1的指针

6．front 得到数组头的引用

7.back 得到数组的最后一个单元的引用

8.max_size 得到vector最大可以是多大

9.capacity 当前vector分配的大小

10.size 当前使用数据的大小

11.resize 改变当前使用数据的大小，如果它比当前使用的大，者填充默认值

12.reserve 改变当前vecotr所分配空间的大小

13.erase 删除指针指向的数据项

14.clear 清空当前的vector

15.rbegin 将vector反转后的开始指针返回(其实就是原来的end-1)

16.rend 将vector反转构的结束指针返回(其实就是原来的begin-1)

17.empty 判断vector是否为空

18.swap 与另一个vector交换数据

基本用法

#include < vector> 
using namespace std;

简单介绍

Vector<类型>标识符
Vector<类型>标识符(最大容量)
Vector<类型>标识符(最大容量,初始所有值)
Int i[5]={1,2,3,4,5}
Vector<类型>vi(I,i+2);//得到i索引值为3以后的值
Vector< vector< int> >v; 二维向量//这里最外的<>要有空格。否则在比较旧的编译器下无法通过。

具体实例见http://www.runoob.com/w3cnote/cpp-vector-container-analysis.html

I）Sort函数包含在头文件为#include<algorithm>的c++标准库中，调用标准库里的排序方法可以不必知道其内部是如何实现的，只要出现我们想要的结果即可！

II）Sort函数有三个参数：

（1）第一个是要排序的数组的起始地址。

（2）第二个是结束的地址（最后一位要排序的地址）

（3）第三个参数是排序的方法，可以是从大到小也可是从小到大，还可以不写第三个参数，此时默认的排序方法是从小到大排序。

Sort函数使用模板:

Sort(start,end,排序方法)

下面就具体使用sort（）函数结合对数组里的十个数进行排序做一个说明。

例一：sort函数没有第三个参数，实现的是从小到大

 1 #include<iostream>
 2 
 3 #include<algorithm>
 4 using namespace std;
 5 int main()
 6 {
 7    int a[10]={9,6,3,8,5,2,7,4,1,0};
 8    for(int i=0;i<10;i++)
 9    cout<<a[i]<<endl;
10   sort(a,a+10);
11    for(int i=0;i<10;i++)
12    cout<<a[i]<<endl;
13    return 0;
14 }

例二

通过上面的例子，会产生疑问：要实现从大到小的排序肿么办？

这就如前文所说需要在sort（）函数里的第三个参数里做文章了，告诉程序我要从大到小排序！

需要加入一个比较函数 complare(),此函数的实现过程是这样的

bool complare(int a,int b)

{

return a>b;

}

　　这就是告诉程序要实现从大到小的排序的方法。

 1 #include<iostream>
 2 #include<algorithm>
 3 using namespace std;
 4 bool complare(int a,int b)
 5 {
 6      return a>b;
 7 }
 8 int main()
 9 {
10      int a[10]={9,6,3,8,5,2,7,4,1,0};
11      for(int i=0;i<10;i++)
12      cout<<a[i]<<endl;
13      sort(a,a+10,complare);//在这里就不需要对complare函数传入参数了，
14 //这是规则
15      for(int i=0;i<10;i++)
16         cout<<a[i]<<endl;
17      return 0;
18 }

假设自己定义了一个结构体node

1 struct node
2 {
3   int a;
4   int b;
5   double c;
6 }

有一个node类型的数组node arr[100]，想对它进行排序：先按a值升序排列，如果a值相同，再按b值降序排列，如果b还相同，就按c降序排列。就可以写这样一个比较函数：

以下是代码片段：

1 bool cmp(node x,node y)
2 {
3    if(x.a!=y.a) return x.a<y.a;
4    if(x.b!=y.b) return x.b>y.b;
5    return x.c>y.c;
6 }

https://www.cnblogs.com/jjzzx/p/5122381.html

至于 for(auto i : v)，

这是c++11的新特性，范围for，相当于java的for each。v是一个可遍历的容器或流，比如vector类型，i就用来在遍历过程中获得容器里的每一个元素。

例如：vector<int> v={1,2,3,4};

for(auto i:v)

cout<<i;

结果就是1234

看了大神的代码，受益匪浅，一下子学到三个知识，感谢～