信息学奥赛一本通 第六章 函数 C语言非C++

发布时间:2024年01月05日

1150:求正整数2和n之间的完全数

#include <stdio.h>
#include <string.h>
#include <stdlib.h>
#include <time.h>

int main(int argc, const char *argv[])
{
    int num;
    // 读取用户输入的数字
    scanf("%d", &num);
    
    // 循环从2开始,直到用户输入的数字
    for (int i = 2; i <= num; i++) {
        int n = 0; // 用于累加因子

        // 内层循环,找出数字i的所有因子(不包括它自身)
        // 并计算这些因子的和
        for (int j = 1; j < i; j++) {
            if (i % j == 0) { // 如果j是i的因子
                n += j; // 累加因子
            }
        }

        // 如果因子的和等于数字本身,那么它是一个完数(Perfect Number)
        if (i == n) {
            printf("%d\n", i); // 打印完数
        }
    }

    return 0; // 程序成功结束
}

1151:素数个数

#include <stdio.h>
#include <string.h>
#include <stdlib.h>
#include <time.h>

int main(int argc, const char *argv[])
{
    int num; // 用于存储用户输入的数,即我们要找到所有小于或等于该数的素数
    scanf("%d", &num); // 从用户那里读取输入的数
    
    int arr[50000] = {0}; // 初始化一个大小为50000的数组,全部元素都设置为0
    int n = 0; // 用于计数找到的素数数量
    
    // 从2开始循环,一直到用户输入的那个数
    for (int i = 2; i <= num; i++) {
        if (arr[i] == 0) { // 如果当前数字对应的数组元素为0,表示它是素数
            n += 1; // 素数计数器加1
            
            // 将当前素数的所有倍数标记为非素数
            for (int j = i + i; j <= num; j += i) {
                arr[j] = 1; // 在数组中将该数标记为非素数
            }
        }
    }
    
    printf("%d", n); // 打印找到的素数总数
    
    return 0; // 返回0,表示程序成功完成
}

1152:最大数max(x,y,z)

#include <stdio.h>
#include <string.h>
#include <stdlib.h>
#include <time.h>

// 定义一个函数,用来找出三个整数中的最大值
float max(int a, int b, int c) {
    if (a >= b && a >= c) {
        return a;
    } else if (b >= c) {
        return b;
    } else {
        return c;
    }
}

int main(int argc, const char *argv[]) {
    int a, b, c;
    
    // 从用户那里读取三个整数
    scanf("%d%d%d", &a, &b, &c);
    
    // 根据给定公式计算比率,并将结果存储在变量 'm' 中
    float m = max(a, b, c) / (max(a + b, b, c) * max(a, b, b + c));
    
    // 将结果打印出来,并格式化为小数点后三位
    printf("%.3f", m);
    
    return 0;
}

1153:绝对素数

#include <stdio.h>
#include <string.h>
#include <stdlib.h>
#include <time.h>

int main(int argc, const char *argv[]) {
    // 素数筛选,标记数组
    int arr[100] = {0}; // 初始化所有元素为0,0表示素数,1表示非素数

    // 素数筛选逻辑,遍历2到99的数字
    for (int i = 2; i < 100; i++) {
        // 如果arr[i]为0,则i为素数
        if (arr[i] == 0) {
            // 将i的倍数标记为非素数
            for (int j = i + i; j < 100; j += i) {
                arr[j] = 1;
            }
        }
    }

    // 遍历1到99的数字
    for (int i = 1; i < 100; i++) {
        // shi表示当前数的十位数,ge表示个位数
        int shi = i / 10;
        int ge = i % 10;
        
        // 如果i大于10(确保有十位和个位),且i为素数,且十位和个位颠倒后的数也是素数
        if (i > 10 && arr[i] == 0 && arr[ge * 10 + shi] == 0) {
            printf("%d\n", i); // 打印这样的数
        }
    }

    return 0;
}

1154:亲和数

#include <stdio.h>
#include <string.h>
#include <stdlib.h>
#include <time.h>

// 定义函数getNum,用于计算一个数的所有真因子之和
int getNum(int a){
    int num=0;
    
    // 遍历所有小于a的正整数,寻找真因子
    for(int i=1;i<a;i++){
        // 如果i是a的因子,则将其累加到num上
        if(a%i==0){
            num+=i;
        }
    }
    // 返回所有真因子之和
    return num;
}

// 主函数
int main(int argc, const char *argv[])
{
    // 初始化变量i为2,因为1没有亲和数
    int i=2;
    // 初始化变量n
    int n;
    do{
        // i自增,用于查找下一个可能的亲和数
        i++;
        // 调用getNum函数,获取i的所有真因子之和
        n = getNum(i);
    
    // 循环条件:确保i的真因子之和n的真因子之和是i本身,且i不等于n
    // 如果不满足亲和数的定义,继续循环
    }while(i!=getNum(n)||i==n);
    
    // 当找到一对亲和数时,输出这对亲和数
    printf("%d %d",i,n);
        
    // 程序结束
    return 0;
}

1155:回文三位数

#include <stdio.h>
#include <string.h>
#include <stdlib.h>
#include <time.h>

// 判断一个三位数是否为回文数
int isH(int a){
    // 分别得到百位、十位和个位数
    int h = a / 100;        // 百位数
    int t = (a % 100) / 10; // 十位数
    int i = a % 10;         // 个位数
    // 如果百位和个位相同,则为回文数,返回1,否则返回0
    return h == i;
}

// 主函数
int main(int argc, const char *argv[])
{
    int arr[1000] = {0}; // 初始化一个长度为1000的数组,用于筛选素数
    
    // 循环从2遍历到999,寻找素数
    for (int i = 2; i < 1000; i++) {
        // 如果当前数字未被标记为非素数
        if (!arr[i]) {
            // 如果当前数字大于100,并且是回文数
            if (i > 100 && isH(i)) {
                // 打印出该回文素数
                printf("%d\n", i);
            }
            // 使用埃拉托斯特尼筛法标记所有i的倍数为非素数
            for (int j = i + i; j < 1000; j += i) {
                arr[j] = 1;
            }
        }
    }
    
    // 程序结束
    return 0;
}

1156:求π的值

#include <stdio.h> // 包含stdio.h头文件,用于使用printf函数
#include <math.h> // 包含math.h头文件,用于使用sqrt函数和atan函数

double arctanx(double x) {
    double result = 0; // 定义变量result,用于存储arctan(x)的近似值
    double term = x; // 定义变量term,用于存储每一项的值
    double numerator = x; // 定义变量numerator,用于存储每一项的分子
    double denominator = 1; // 定义变量denominator,用于存储每一项的分母
    int sign = 1; // 定义变量sign,用于存储每一项的正负号
    int n = 1; // 定义变量n,用于记录当前项的序号

    while (term >= 1e-6) { // 当最后一项小于10^-6时终止循环
        result += sign * term; // 累加每一项的值到结果中
        numerator *= x * x; // 更新分子,乘以x^2
        denominator += 2; // 更新分母,加2
        term = numerator / denominator; // 计算当前项的值
        sign = -sign; // 更新正负号
        n++; // 序号加1
    }

    return result; // 返回arctan(x)的近似值
}

int main() {
    double x = 1.0 / sqrt(3.0); // 定义x为1/√3

    double pi = 6 * arctanx(x); // 计算π的近似值

    printf("%.10lf\n", pi); // 打印π的近似值,保留到小数点后10位

    return 0; // 返回0,表示程序执行成功
}

1157:哥德巴赫猜想

#include <stdio.h> // 包含stdio.h头文件,用于使用printf函数
#include <stdbool.h> // 包含stdbool.h头文件,用于使用bool类型

bool isPrime(int n) {
    if(n <= 1) {
        return false; // 1不是素数
    }
    for(int i = 2; i * i <= n; i++) {
        if(n % i == 0) {
            return false; // 如果n能被i整除,说明n不是素数
        }
    }
    return true; // 如果n不能被任何数整除,说明n是素数
}

int main() {
    for(int evenNum = 6; evenNum <= 100; evenNum += 2) {
        printf("%d=", evenNum);
        bool found = false; // 用于标记是否找到了两个素数的组合
        for(int i = 2; i <= evenNum / 2; i++) {
            if(isPrime(i) && isPrime(evenNum - i)) {
                printf("%d+%d\n", i, evenNum - i); // 打印两个素数的组合
                found = true;
                break; // 找到一个组合就退出内层循环
            }
        }
        // 如果没有找到两个素数的组合,打印"未找到"
        if(!found) {
            printf("未找到\n");
        }
    }
    
    return 0; // 返回0,表示程序执行成功
}

1397:简单算术表达式求值

#include<bits/stdc++.h>
using namespace std;
int calc(int a, int b, char c)//返回数字a,b通过运算符c运算后得到的结果 
{
	if(c == '+')
		return a + b;
	else if(c == '-')
		return a - b;
	else if(c == '*')
		return a * b;
	else if(c == '/')
		return a / b;
	else if(c == '%')
		return a % b;
}
int main()
{
  	int a, b;
  	char c;
  	cin >> a >> c >> b;
  	cout << calc(a, b, c);
    return 0;
}

1398:短信计费

#include<bits/stdc++.h>
using namespace std;
double price(int num)//求字符数量为num的短信的费用 
{
	if(num % 70 == 0)//如果字符数量是70的整数倍 
		return num / 70 * 0.1;//有num/70条短信 
	else//如果字符数量不是70的整数倍 
		return (num / 70 + 1) * 0.1;//有num/70+1条短信 
}
int main()
{
    int n, num;
    cin >> n;
    double sum = 0;//总费用 
    for(int i = 0; i < n; ++i)
    {
        cin >> num;
        sum += price(num);
    }
    cout << fixed << setprecision(1) << sum;
    return 0;
}

1399:甲流病人初筛

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <stdbool.h> // C语言中使用布尔值需要引入这个库

int main()
{
    double temperature; // 定义体温变量
    int isCough; // 定义是否咳嗽变量,C语言中没有bool类型,用int代替,0表示false,非0表示true
    int n, ct = 0; // n为病人数量,ct为初筛出甲流病人的计数
    char name[105]; // 定义一个字符数组存储名字,假设名字最长为104个字符加上一个结束符

    scanf("%d", &n); // 输入病人数量
    for(int i = 1; i <= n; ++i)
    {
        scanf("%s %lf %d", name, &temperature, &isCough); // 输入每个病人的名字,体温和是否咳嗽
        // 如果体温大于或等于37.5度并且咳嗽,则认为可能是甲流病人
        if(temperature >= 37.5 && isCough)
        {
            printf("%s\n", name); // 输出该病人的名字
            ct++; // 计数器增加
        }
    }
    printf("%d", ct); // 输出初筛出的甲流病人总数
    return 0;
}

1400:统计单词数

#include <stdio.h>
#include <string.h>
#include <ctype.h>

#define N 1000005
char s[N], word[105], temp[105];

void lower(char s[], int len){
    for(int i = 0; i < len; ++i)
        s[i] = tolower(s[i]);
}

int main(){
    int k = 0, firstPos = -1, ct = 0;
    fgets(word, 105, stdin);
    fgets(s, N, stdin);

    // remove the newline at the end of word and s
    word[strcspn(word, "\n")] = 0;
    s[strcspn(s, "\n")] = 0;

    int len = strlen(s), lenw = strlen(word);
    lower(word, lenw);
    lower(s, len);

    for(int i = 0; i <= len; ++i){
        if(s[i] == ' ' || s[i] == '\0'){
            temp[k] = '\0';
            if(strcmp(temp, word) == 0){
                ct++;
                if(firstPos == -1)
                    firstPos = i - lenw;
            }
            k = 0;
        }
        else{
            temp[k++] = s[i];
        }
    }
    if(firstPos == -1)
        printf("-1\n");
    else
        printf("%d %d\n", ct, firstPos);
    return 0;
}

1401:机器翻译

#include<stdio.h>
#include<string.h>
#include<stdbool.h>

bool hasWord[1005]; //hasWord[i]:内存中是否有单词i 
int mem[105], mi; //mem[i]:内存中第i位置的单词 mi:内存中刚刚保存单词的位置 
int ct, m, n, word; //ct:计数 

int main()
{
    memset(mem, -1, sizeof(mem)); //mem数组初值为-1,表示该位置没有保存单词。如果保存单词,值为非负整数。 
    scanf("%d%d", &m, &n);
    for(int i = 0; i < n; ++i)
    {
        scanf("%d", &word);
        if(hasWord[word] == false) //如果word单词不存在 
        {
            hasWord[word] = true; //将word单词设为已经存在 
            mi = (mi + 1) % m; //mi取循环数组中的下一个位置 
            if(mem[mi] >= 0) //如果这个内存中的新位置mi已经有值了 
                hasWord[mem[mi]] = false; //把mi位置保存的单词mem[mi]设为不存在 
            mem[mi] = word; //内存中新位置保存单词word 
            ct++; //这种情况需要到外存查字典 计数加1 
        }
    }
    printf("%d", ct);
    return 0;
}

1402:Vigenère密码

#include<stdio.h>
#include<string.h>

int main()
{
	char s_k[105], s_c[1005], st_c; //s_k:密钥字符串 s_c:密文字符串 st_c:标记当前字符是大写还是小写字母。 
	scanf("%s%s", s_k, s_c);
	int lc = strlen(s_c), lk = strlen(s_k), n_k[105], n_c; //n_k:密钥字母对应的数字构成的的数组 n_c:当前明文中字母对应的数字(A~Z对应0~25)
	for(int i = 0; i < lk; ++i) //求出n_k数组 
	{
		if(s_k[i] >= 'A' && s_k[i] <= 'Z')
			n_k[i] = s_k[i] - 'A';
		else
			n_k[i] = s_k[i] - 'a';
	}
	for(int i = 0, j = 0; i < lc; ++i, j = (j+1)%lk) //i:s_c的下标 j:n_k的下标
	{
		if(s_c[i] >= 'A' && s_c[i] <= 'Z')
		{
			st_c = 'A';
			n_c = s_c[i] - 'A';
		}
		else
		{
			st_c = 'a';
			n_c = s_c[i] - 'a';
		}
		printf("%c", (char)((n_c - n_k[j] + 26) % 26 + st_c));
	}
	return 0;
}

1403:素数对

#include <stdio.h>
#include <math.h>
#include <stdbool.h>

bool isPrime(int n)//求大于等于2的整数n是不是质数 
{
    for(int i = 2; i <= sqrt(n); ++i)
        if(n % i == 0)
            return false;
    return true;
}

int main()
{
    int n;
    scanf("%d", &n);
    bool isEmpty = true;
    for(int i = 4; i <= n; ++i)//i为较大的数字,较小的数字为i-2 
    {
        if(isPrime(i) && isPrime(i-2))//如果两个数都是质数 
        {
            isEmpty = false;
            printf("%d %d\n", i-2, i);
        }
    }
    if(isEmpty)
        printf("empty");
    return 0;
}

1404:我家的门牌号

#include<stdio.h>

int main()
{
    int n;
    scanf("%d", &n);
    for(int y = 1; y <= 100000; ++y)
        for(int x = 1; x <= y; ++x)
            if((1+y)*y/2-3*x == n)
            {
                printf("%d %d", x, y);
                return 0;        
            }
    return 0;
}

1405:质数的和与积

#include <stdio.h>
#include <math.h> // 用于调用sqrt()函数

// 函数用于检查一个数是否是质数
bool isPrime(int n)
{
    // 从2开始到sqrt(n),检查是否有因子
    for(int i = 2; i <= sqrt(n); ++i)
    {
        if(n % i == 0) // 如果发现因子,则n不是质数
            return false;
    }
    return true; // 如果没有发现因子,则n是质数
}

int main()
{
    int s, mx = 0; // s是输入的数,mx是我们要找的最大乘积
    scanf("%d", &s); // 读入s

    // 从2到s/2循环,寻找一对质数,它们的和为s
    for(int i = 2; i <= s/2 ; ++i)
    {
        // 如果i和s-i都是质数
        if(isPrime(i) && isPrime(s - i))
        {
            // 检查它们的乘积是否比目前发现的mx大
            if(i * (s - i) > mx)
                mx = i * (s - i); // 更新mx为更大的乘积
        }
    }
    printf("%d", mx); // 输出最大乘积
    return 0;
}

1406:单词替换

#include <stdio.h>     // 标准输入输出头文件
#include <string.h>    // 字符串操作头文件
#include <stdlib.h>    // 标准库头文件,包含动态内存分配函数

#define N 105

int main() {
    char *words[N], oriWord[N], tarWord[N], c; // words: 指针数组,words[i]指向一个字符串
    int wordNum = 0, j = 0; // wordNum: 单词数量,j: 单词下标
    words[wordNum] = (char *)malloc(N * sizeof(char)); // 申请长度为N的字符数组

    do {
        c = getchar(); // 读入一个字符
        if (c == ' ' || c == '\n') {
            words[wordNum][j] = '\0'; // 单词结束,添加字符串结束符
            wordNum++;
            j = 0;
            if (wordNum < N) {
                words[wordNum] = (char *)malloc(N * sizeof(char)); // 为下一个单词申请空间
            }
        } else {
            words[wordNum][j++] = c; // 将字符加入当前单词
        }
    } while (c != '\n'); // 读到换行符,输入结束

    scanf("%s %s", oriWord, tarWord); // 读入要被替换的单词和替换后的单词
    for (int i = 0; i < wordNum; ++i) {
        if (strcmp(oriWord, words[i]) == 0) { // 如果oriWord与第i个单词相同
            strcpy(words[i], tarWord); // 把第i个单词替换为tarWord
        }
    }

    for (int i = 0; i < wordNum; ++i) {
        printf("%s ", words[i]); // 输出单词
        free(words[i]); // 释放内存
    }
    return 0;
}


1407:笨小猴

#include <stdio.h>
#include <stdbool.h>
#include <math.h>
#include <string.h>

#define N 105

// 函数:判断自然数 n 是否是质数
bool isPrime(int n) {
    if (n < 2)
        return false;
    for (int i = 2; i <= sqrt(n); ++i) {
        if (n % i == 0)
            return false;
    }
    return true;
}

int main() {
    char s[N]; // 字符数组来存储字符串
    scanf("%s", s); // 读取字符串
    int chNum[26] = {0}, maxn = 0, minn = N; // chNum[i]:存储字母 'a'+i 出现的次数

    // 遍历字符串统计每个字母出现的次数
    for (int i = 0; i < strlen(s); ++i) {
        chNum[s[i] - 'a']++;
    }

    // 遍历字母表的每个字母
    for (int i = 0; i < 26; ++i) {
        if (chNum[i] > 0) { // 如果字母出现过
            if (chNum[i] > maxn) maxn = chNum[i];
            if (chNum[i] < minn) minn = chNum[i];
        }
    }

    // 判断最多和最少出现次数之差是否为质数
    if (isPrime(maxn - minn)) {
        printf("Lucky Word\n%d\n", maxn - minn);
    } else {
        printf("No Answer\n0\n");
    }
    return 0;
}

1408:素数回文数的个数

#include <stdio.h>
#include <math.h>
#include <stdbool.h>

// 判断n是否是质数
bool isPrime(int n) {
    if (n < 2) return false;
    for (int i = 2; i <= sqrt(n); ++i) {
        if (n % i == 0) {
            return false;
        }
    }
    return true;
}

// 判断两位或三位数n是否是回文数
bool isPal(int n) {
    int g, d; // g:最高位 d:最低位
    int a = n;

    // 获取最高位
    while (a >= 10) {
        a /= 10;
    }
    g = a;

    // 获取最低位
    d = n % 10;

    // 判断最高位与最低位是否相等
    return g == d;
}

int main() {
    int n, s = 0; // n:输入的数,s:回文质数的计数
    scanf("%d", &n); // 读取输入

    // 检查范围内的每个数是否是回文质数
    for (int i = 11; i <= n; ++i) {
        if (isPrime(i) && isPal(i)) {
            s++; // 如果是回文质数,计数加一
        }
    }

    printf("%d", s); // 输出回文质数的总数
    return 0;
}

1409:判决素数个数

#include <stdio.h>
#include <math.h>

// 判断正整数n是否是质数
int isPrime(int n) {
    if (n < 2)
        return 0; // 如果n小于2,那么它不是质数
    for (int i = 2; i <= (int)sqrt((double)n); ++i) {
        if (n % i == 0)
            return 0; // 如果n能被一个小于它的数整除,那么它不是质数
    }
    return 1; // 否则,n是质数
}

int main() {
    int ct = 0; // 质数计数器
    int x, y, temp;
    
    // 读取输入的两个数
    scanf("%d %d", &x, &y);
    
    // 如果x大于y, 交换它们的值以确保x小于等于y
    if (x > y) {
        temp = x;
        x = y;
        y = temp;
    }
    
    // 遍历x到y之间的每个整数,包括x和y本身
    for (int i = x; i <= y; ++i) {
        if (isPrime(i)) // 检查当前数字是否为质数
            ct++; // 如果是质数,计数器加1
    }
    
    // 输出质数的总数
    printf("%d", ct);
    
    return 0;
}

1410:最大质因子序列

#include <stdio.h>
#include <math.h>

// 判断大于等于2的整数n是否是质数
int isPrime(int n) {
    for (int i = 2; i <= (int)sqrt((double)n); ++i) {
        if (n % i == 0)
            return 0; // 如果n可以被i整除,则不是质数
    }
    return 1; // n是质数
}

// 求n的最大质因子
int maxPrimeFactor(int n) {
    for (int i = n; i >= 2; --i) { // 从大到小遍历
        if (n % i == 0 && isPrime(i))
            return i; // 找到最大的质因子
    }
    return 1; // 如果n为1,则返回1
}

int main() {
    int m, n;
    scanf("%d %d", &m, &n); // 输入m和n

    int isFirst = 1; // 标志位:是否是第一个输出的数字
    for (int i = m; i <= n; ++i) {
        if (!isFirst) {
            printf(","); // 如果不是第一个数字,输出逗号分隔符
        } else {
            isFirst = 0; // 更新标志位
        }
        printf("%d", maxPrimeFactor(i)); // 输出i的最大质因子
    }
    return 0;
}

1411:区间内的真素数

#include <stdio.h>
#include <math.h>
#include <stdbool.h>

bool isPrime(int n) //判断是否是质数
{
    if (n < 2)
        return false;
    for (int i = 2; i <= sqrt(n); ++i)
        if (n % i == 0)
            return false;
    return true;
}

int rev(int n) //数字反序
{
    int num = 0;
    for (int a = n; a > 0; a /= 10) //数字拆分 前提n >= 1
        num = num * 10 + a % 10;
    return num;
}

int main()
{
    int m, n;
    scanf("%d %d", &m, &n);
    bool hasShow = false; //是否已经有输出
    for (int i = m; i <= n; ++i)
    {
        if (isPrime(i) && isPrime(rev(i))) //如果i和i的逆序的数字都是质数
        {
            if (hasShow) //如果已经输出过
                printf(",");
            else
                hasShow = true;
            printf("%d", i);
        }
    }
    if (!hasShow) //如果没有输出过
        printf("No");
    return 0;
}


1412:二进制分类

#include <stdio.h>

// 函数原型声明
int isClassA(int n); // 声明判断数字n是否是A类数的函数

int main() {
    int ctA = 0; // A类数的个数
    int ctB = 0; // B类数的个数

    // 循环从1遍历到1000
    for(int i = 1; i <= 1000; ++i) {
        // 如果i是A类数
        if(isClassA(i)) {
            ctA++; // A类数个数加1
        } else {
            ctB++; // 否则B类数个数加1
        }
    }

    // 输出A类数和B类数的个数
    printf("%d %d", ctA, ctB);

    return 0; // 程序正常结束
}

// 判断数字n是否是A类数的函数定义
int isClassA(int n) {
    int s1 = 0; // 1的个数
    int s0 = 0; // 0的个数

    // 二进制下数字拆分,除基取余
    for(int a = n; a > 0; a /= 2) {
        // 如果这一位是1
        if(a % 2 == 1) {
            s1++; // 1的个数加1
        } else {
            // 如果这一位是0
            s0++; // 0的个数加1
        }
    }

    // 如果1比0多,那么是A类数
    return s1 > s0;
}

1413:确定进制

#include <stdio.h>
#include <string.h>
#include <stdbool.h>

// 函数原型声明
long long toVal(const char* s, int b); // 将字符串s在b进制下转为值
bool check(const char* s, int b); // 检查数字s是否可能是b进制下的数字

int main() {
    char s_p[50], s_q[50], s_r[50];  // 定义存放字符串的数组
    long long p, q, r;
    
    // 输入三个字符串
    scanf("%s %s %s", s_p, s_q, s_r);
    
    // 从二进制到四十进制
    for(int b = 2; b <= 40; ++b) {
        // 如果s_p, s_q, s_r都可以是b进制下的数字
        if(check(s_p, b) && check(s_q, b) && check(s_r, b)) {
            // 转换字符串为对应进制下的值
            p = toVal(s_p, b);
            q = toVal(s_q, b);
            r = toVal(s_r, b);
            
            // 如果满足乘积关系p * q == r
            if(p * q == r) {
                printf("%d", b);  // 输出进制数
                return 0;
            }
        }
    }
    
    // 如果没有找到满足条件的进制数,输出0
    printf("0");
    return 0;
}

// 将字符串s在b进制下转为值的函数定义
long long toVal(const char* s, int b) {
    long long val = 0;
    int len = strlen(s);  // 获取字符串长度
    for(int i = 0; i < len; ++i) {
        val = val * b + s[i] - '0';
    }
    return val;
}

// 检查字符串s是否可能是b进制下的数字的函数定义
bool check(const char* s, int b) {
    int len = strlen(s);
    for(int i = 0; i < len; ++i) {
        if(s[i] - '0' >= b) {
            return false;  // 如果某一位数字大于等于进制数b,则返回false
        }
    }
    return true;  // 否则返回true
}

1158:求1+2+3+…

#include <stdio.h>
#include <string.h>
#include <stdlib.h>
#include <time.h>


int add(int n){
    if(n==1){
        return 1;
    }
    return add(n-1)+n;
}

int main(int argc, const char *argv[])
{
    
    int n;
    scanf("%d",&n);
  
    printf("%d",add(n));
    
    return 0;
}

1159:斐波那契数列

#include <stdio.h> // 包含标准输入输出库

// 函数用于计算斐波那契数列的第n项
int getNum(int n) {
    if (n == 1 || n == 2) { // 斐波那契数列的前两项定义
        return n - 1;
    }
    // 递归计算斐波那契数列的第n项
    return getNum(n - 1) + getNum(n - 2);
}

int main(int argc, const char *argv[]) {
    int n;
    scanf("%d", &n); // 从用户输入中读取一个整数n
    
    printf("%d", getNum(n)); // 计算并打印斐波那契数列的第n项
    
    return 0; // 程序正常退出
}

1160:倒序数

#include <stdio.h> // 包含标准输入输出库

// 递归函数用于逆序打印整数的每一位
int digui(int n) {
    // 如果n只有一位,则直接返回该数字
    if (n / 10 == 0) return n;
    else {
        // 打印n的最后一位数字
        printf("%d", n % 10);
        // 递归调用函数,移除已打印的最后一位
        return digui(n / 10);
    }
}

int main(int argc, const char *argv[]) {
    int n;
    // 读取用户输入的整数
    scanf("%d", &n);
    
    // 输出最后一位数字并开始递归过程
    int lastDigit = digui(n);
    // 如果输入的数字只有一位,之前的递归调用不会打印任何东西
    // 因此需要检查并打印最后一位数字
    if (n / 10 == 0) {
        printf("%d", lastDigit);
    }
    
    return 0; // 程序正常退出
}

1161:转进制

#include <stdio.h>
#include <math.h>
#include <stdbool.h>

// 判断正整数n是否是质数
bool isPrime(int n) {
    if (n < 2)
        return false;
    for (int i = 2; i <= sqrt(n); ++i) {
        if (n % i == 0)
            return false;
    }
    return true;
}

int main() {
    int ct = 0; // 用来计数质数的数量
    int x, y, t; // x和y是范围,t用于交换

    // 读取用户输入的两个整数x和y
    scanf("%d %d", &x, &y);

    // 保证x不大于y
    if (x > y) {
        t = x;
        x = y;
        y = t;
    }

    // 循环遍历给定的范围[x, y]
    for (int i = x; i <= y; ++i) {
        if (isPrime(i)) {
            ct++; // 如果i是质数,则增加计数
        }
    }

    // 输出质数的数量
    printf("%d", ct);

    return 0; // 程序成功结束
}

1162:字符串逆序

#include <stdio.h>  // 包含标准输入输出头文件
#include <string.h> // 包含字符串操作函数的头文件

// revShow函数用于逆向输出字符数组s,s的长度为len
void revShow(char s[], int len) {
    if(len == 0) {
        return; // 如果长度为0,递归结束
    }
    printf("%c", s[len - 1]); // 输出数组的最后一个字符
    revShow(s, len - 1); // 递归调用,逆向输出剩余的字符
}

int main() {
    char s[1005]; // 定义字符数组,长度为1005
    fgets(s, 1005, stdin); // 使用fgets从标准输入读取字符串

    int len = strlen(s); // 获取字符串的实际长度
    if(s[len - 1] == '\n') {
        len--; // 如果字符串的最后一个字符是换行符,则减小长度
        s[len] = '\0'; // 替换换行符为字符串终止符
    }

    if(len > 0 && s[len - 1] == '!') {
        len--; // 如果字符串的最后一个字符是'!',则减小长度
        s[len] = '\0'; // 去掉最后的'!'
    }

    revShow(s, len); // 调用revShow函数逆向输出字符串
    return 0; // 程序结束
}

1163:阿克曼(Ackmann)函数

#include <stdio.h> // 引入标准输入输出头文件

// akm函数是用来计算阿克曼函数(Ackermann function)的
// 它是一个递归函数,有两个整数参数m和n
int akm(int m, int n) {
    if (m == 0) {
        return n + 1; // 当m为0时,返回n+1
    }
    
    if (n == 0) {
        return akm(m - 1, 1); // 当n为0时,递归调用akm(m-1, 1)
    }
    
    return akm(m - 1, akm(m, n - 1)); // 其他情况,递归调用akm(m-1, akm(m, n-1))
}

int main() {
    int m, n;
    scanf("%d%d", &m, &n); // 从标准输入读取m和n的值
    printf("%d", akm(m, n)); // 计算并输出阿克曼函数的值
    
    return 0; // 程序结束
}

1164:digit函数

#include <stdio.h> // 引入标准输入输出头文件

// akm函数用于打印整数m的第n位数字(从右往左数)
// 例如,如果m是12345且n是2,那么它会打印出4
void akm(int m, int n) {
    if (n == 1) {
        printf("%d", m % 10); // 如果n为1,打印出m的最后一位数字
    } else {
        akm(m / 10, n - 1); // 否则,去掉m的最后一位数字,n减1后递归调用
    }
}

int main() {
    int m, n;
    scanf("%d%d", &m, &n); // 从标准输入读取m和n的值
    akm(m, n); // 调用akm函数
    
    return 0; // 程序结束
}

1165:Hermite多项式

#include <stdio.h> // 引入标准输入输出头文件

// h函数是用来计算赫米特多项式(Hermite polynomials)的递归函数
// n表示多项式的阶数,x是多项式的变量
double h(int n, int x) {
    if (n == 0)
        return 1; // n为0时,多项式的值为1
    else if (n == 1)
        return 2 * x; // n为1时,多项式的值为2x
    else
        // 递归计算多项式的值
        return 2 * x * h(n - 1, x) - 2 * (n - 1) * h(n - 2, x);
}

int main() {
    int m, n;
    scanf("%d%d", &m, &n); // 从标准输入读取m和n的值
    printf("%.2f", h(m, n)); // 调用h函数计算赫米特多项式的值,并保留两位小数输出
    
    return 0; // 程序结束
}

1166:求f(x,n)

#include <stdio.h>   // 引入标准输入输出头文件
#include <math.h>    // 引入数学函数头文件,为了使用sqrt函数

// solve函数用于递归地计算一个序列的值
// n 是递归的深度,x 是初始值
double solve(double n, double x) {
    if (n == 0)
        return x;   // 递归的基本情况,直接返回x
    else
        // 递归调用,计算 sqrt(n + solve(n - 1, x))
        return sqrt(n + solve(n - 1, x));
}

int main() {
    double x, n;
    scanf("%lf %lf", &x, &n); // 使用%lf来读取double类型的输入
    // 输出结果,使用%.2f来控制输出小数点后两位
    printf("%.2f", solve(n, x));
    return 0; // 程序结束
}

1167:再求f(x,n)

#include <stdio.h>  // 引入标准输入输出头文件

// solve函数用于递归地计算数列的值
// 参数n是递归的深度,x是初始值
double solve(double n, double x) {
    if (n == 0) {
        return x;  // 递归终止条件,当n为0时返回x
    } else {
        // 递归表达式,计算x除以(n + solve(n - 1, x))
        return x / (n + solve(n - 1, x));
    }
}

int main() {
    double x, n;
    // 使用scanf函数读取两个double类型的输入变量x和n
    scanf("%lf %lf", &x, &n);
    // 使用printf函数输出solve函数的结果
    // %.2f用于控制输出结果为小数点后两位
    printf("%.2f", solve(n, x));
    return 0;  // 程序结束
}

文章来源:https://blog.csdn.net/weixin_44738632/article/details/135416785
本文来自互联网用户投稿,该文观点仅代表作者本人,不代表本站立场。本站仅提供信息存储空间服务,不拥有所有权,不承担相关法律责任。