头哥C++编程基础实训

第1关：对称数生成

#include <iostream>

#include <cmath>

using namespace std;

int main()

{

 int num;

 cin>>num;

//请在此添加代码，输入数字，并判断是否为正数，不是则输出“-1”；

//如果是大于3位的正整数，只取最后三位数字，并生成对称数；如果是小于等于三位的正整数，则直接生成对称数；

/**********Program**********/

if(num>0){

    int t;

    int a;

    a=num;

    for(t=0;num>0;t++){

        num=num/10;

    }

    num=a;

    if(t>3){

        cout<<num%1000;

        int j=0;

        for(;j<3;j++){

            cout<<num%10;

            num=num/10;

        }

    }else{

        cout<<num;

        int j=0;

        if(num>=100){

            for(;j<3;j++){

            cout<<num%10;

            num=num/10;

        }

        }else{

            for(;j<2;j++){

            cout<<num%10;

            num=num/10;

        }

        }

        }

   

}else{

    cout<<"-1";

}

/**********  End  **********/

 return 0;

}

第2关：黑洞陷阱

// 包含两种I/O库，可以使用任一种输入输出方式

#include <stdio.h>

#include <iostream>

using namespace std;

/**

 * 获取一个数字的每位数的数组，不足三位补 0

 * @param num

 */

int *getDigits(int num) {

    int *digits = new int[3];

    if (num < 10) {

        digits[0] = num;

        digits[1] = digits[2] = 0;

    } else if (num < 100) {

        digits[0] = num / 10;

        digits[1] = num % 10;

        digits[2] = 0;

    } else if (num < 1000) {

        digits[0] = num / 100;

        digits[1] = (num / 10) % 10;

        digits[2] = num % 10;

    }

    return digits;

}

/**

 * 获取最大值

 * @param nums

 * @return

 */

int getMax(const int nums[3]) {

    int max = 0;

    for (int i = 0; i < 3; ++i) {

        max = max > nums[i] ? max : nums[i];

    }

    return max;

}

/**

 * 获取最小值

 * @param nums

 * @return

 */

int getMin(const int nums[3]) {

    int min = 10;

    for (int i = 0; i < 3; ++i) {

        min = min < nums[i] ? min : nums[i];

    }

    return min;

}

/**

 * 一个数重组后的最大值

 * @param num

 * @return

 */

int getMaxNum(int num) {

    int *digits = getDigits(num);

    int max = getMax(digits);

    int min = getMin(digits);

    int mid = digits[0] + digits[1] + digits[2] - max - min;

    return max * 100 + mid * 10 + min;

}

/**

 * 一个数重组后的最小值

 * @param num

 * @return

 */

int getMinNum(int num) {

    int *digits = getDigits(num);

    int max = getMax(digits);

    int min = getMin(digits);

    int mid = digits[0] + digits[1] + digits[2] - max - min;

    return max + mid * 10 + min * 100;

}

int main() {

    int n;

    // 请在此添加代码，输出整数进入黑洞过程

    /********** Begin *********/

    int max, min, index = 0;

    cin >> n;

    while (n != 495) {

        index++;

        max = getMaxNum(n);

        min = getMinNum(n);

        n = max - min;

        cout << index << ":" << max << "-" << min << "=" << n << endl;

    }

    /********** End **********/

    return 0;

}

第3关：登月纸桥

#include <iostream>

using namespace std;

// foldTimes-计算建纸桥的折叠次数

// 参数：dis-星际距离（千米），thick-纸的厚度（毫米）

// 返回值：建桥需要折叠的次数

int foldTimes(double dis, double thick);

int main() {

    double dis, thick;

    cin >> dis >> thick;

    cout << "需要折叠" << foldTimes(dis, thick) << "次" << endl;

    return 0;

}

/**

 * 计算折叠的次数

 * @param dis

 * @param thick

 * @return

 */

int foldTimes(double dis, double thick) {

    // 请在这里补充代码，实现函数foldTimes

    /********** Begin *********/

    int cnt = 0;

    while (thick < dis * 1000000) {

        thick *= 2;

        cnt++;

    }

    return cnt;

    /********** End **********/

}

第4关：递归求函数值

#include <iostream>

using namespace std;

//请在此添加代码，定义recursion_fun()函数，输入int型数据，输出int型函数值；

/**********Program**********/

int recursion_fun(int n)

{

    if(n<=2)

        return n;

    else if(n<=5&&n>2)

        return (n-1)*(n-1);

    else return recursion_fun(n-1)-recursion_fun(n-4);

}

第5关：最大销售增幅

#include <iostream>

using namespace std;

// 函数maxIncrease：计算销售额增幅

// 参数：s-销售额数组，n-销售额数组长度，n>1

// 返回值：销售额最大增幅

int maxIncrease(int s[], int n);

int main()

{

    int n, a[30], i;     // 定义变量及数组，n-销售额个数，a-销售额数组

    cin >> n;      // 输入销售额数量，n>1

    // 输入n个销售额，分别存入a[0]到a[n-1]

    for(i = 0; i < n; i++)

        cin >> a[i];

    i = maxIncrease(a,n);

    cout << "最大销售增幅为：" << i << endl;

    return 0;

}

int maxIncrease(int s[], int n)

{

    //请在此添加代码，实现函数maxIncrease

    /********** Begin *********/

    int ans = 0xefefefef;

    for (int i = 0; i < n; i ++ ) {

        for (int j = i; j < n; j ++ ) {

            ans = max(ans, s[j] - s[i]);

        }

    }

    return ans;

    /********** End **********/

}

第6关：队列变换

#include <iostream>

using namespace std;

// 函数rotateLeft：矩阵循环左移

// 参数：a-100*100的二维数组，用来存储n行n列的数组（n<100)，存储在其~n-1行和~n-1列，

// m-循环左移的位数(0<m<n)

// 返回值：无，循环左移的结果写入原二维数组中

// 说明：传递多维数组时，形式参数中，除了第一维外，其它维的大小必须给出

// 方便编译器计算每个数组元素的地址

void rotateLeft(int a[][100],int n,int m);

int main()

{

    int a[100][100];     // 定义存储二维数组的空间

    int n, m;

    cin >> n >> m;     // 输入n和m

    // 输入n*n的矩阵，存储在数组a的~n-1行和~n-1列

    int i, j;

    for(i = 0; i < n; i++)

        for(j = 0; j < n; j++)

            cin >> a[i][j];

    // 循环左移

    // 说明：传递多维数组时，实在参数只需要给出数组名就可以了

    rotateLeft(a,n,m);

    // 输出循环右移的结果

    for(i = 0; i < n; i++)

    {

        for(j = 0; j < n; j++)

            cout << " " << a[i][j];

        cout << endl;

    }

    return 0;

}

int b[110][110];

void rotateLeft(int a[][100],int n,int m)

{

    // 请在此添加代码，实现函数rotateLeft

    /********** Begin *********/

    for (int i = 0; i < n; i ++ ) for (int j = 0; j < n; j ++ ) b[i][j] = a[i]

[j];

    for (int i = 0; i < n; i ++ ) {

        for (int j = 1; j <= m; j ++ ) a[i][n - m + j - 1] = b[i][j - 1];

        for (int j = 1; j <= n - m; j ++ ) a[i][j - 1] = b[i][m + j - 1];

    }

    /********** End **********/

}

第7关：大写字母好看

#include <iostream>

using namespace std;

void toUp(char * str);

int main()

{

    char s[1024];

    cin.getline(s,1024);     // 输入一行字符

    toUp(s);     // 调用toUp函数，转换成大写字母

    cout<<s<<endl;     // 输出变更后的新字符串

    return 0;

}

// 函数toUp：将str指向的字符串中的小写字母变成对应的大写字母

// 参数：str-指向字符串

void toUp(char * str)

{

    // 请在此添加代码，实现函数toUp

    /********** Begin *********/

    char*p=str;

    while(*p!='\0'){

        if(*p>='a' && *p<='z'){

            *p=*p+'A'-'a';

        }

        p++;

    }

    /********** End **********/

}

第8关：用指针实现pswap函数

#include <iostream>

using namespace std;

void pswap(int * p, int *q);

int main()

{

    int a, b;

    cin >> a >> b;     // 输入两个整数

    pswap(&a,&b);     // 调用pswap函数，交换a、b的值

    cout << a << " " << b << endl;     // 输出a、b的值

    return 0;

}

//函数pswap：交换指针p和q指向的单元中的整数值

//参数：p,q-int类型指针，指向要交换的整数

void pswap(int * p, int *q)

{

    // 请在此添加代码，实现函数pswap

    /********** Begin *********/

    int temp=*p;

    *p=*q;

    *q=temp;

    /********** End **********/

}

第9关：最大值函数

int Max(int a,int b)

{

    /********* Begin *********/

    //找出两个参数中最大的那个并返回

return a > b?a : b;

   

   

    /********* End *********/

}

int Max(int a,int b,int c)

{

    /********* Begin *********/

    //找出三个参数中最大的那个并返回

return Max(a,Max(b,c));

   

   

    /********* End *********/

}

第10关：猴子选大王

#include <iostream>

using namespace std;

// 函数king：猴子选大王

// 参数：a-猴子数组n-1个猴子分别占据下标为~n-1的位置，n-数组长度

// 返回值：新猴王的下标序号

int king(int a[], int n);

int main()

{

    // 定义变量及数组，n-猴子数量，a-猴子数组

    int n, a[1000], i;

    // 输入猴子数量，n>0

    cin >> n;

    // 初始化猴子数组,n个猴子分别占据~n的位置

    a[0] = 0; // 0号位置没有猴子

    for(i = 1;i <= n; i++)

        a[i] = i;

    // 选大王啦

    i = king(a, n );

    cout << i << "号猴子是大王。" << endl;

    return 0;

}

int king(int a[], int n)

{

    // 请在此添加代码，实现函数king

    /********** Begin *********/

int i,j,t=0;

for(i=0;i<=n;i++)

a[i]=1;

for(i=1;i<=n;i++)

{

    j=1;

    while(j<=3)

    {

        t=(t+1)%n;

        if(a[t]==1)j++;

    }

    a[t]=0;

}

return t;

    /********** End **********/

}