用C语言写一个用户随机输入两个数，计算最大公因数

以下是用C语言实现计算最大公因数的代码：

#include <stdio.h>

int gcd(int a, int b) {
    if (b == 0) {
        return a;
    }
    return gcd(b, a % b);
}

int main() {
    int a, b;
    printf("请输入两个整数：\n");
    scanf("%d %d", &a, &b);
    int result = gcd(a, b);
    printf("最大公因数为：%d\n", result);
    return 0;
}

这个程序会提示用户输入两个整数，然后计算它们的最大公因数并输出结果。

相关问题

C语言实现多个分组的RSA加密解密算法

RSA算法是一种非对称加密算法，它需要一对公私钥来实现加密和解密。

首先，我们需要生成一对公私钥。生成方法如下：

1. 随机选取两个大质数p, q。
2. 计算n = p*q，Φ = (p-1)(q-1)。
3. 随机选取一个小于Φ且与Φ互质的整数e，即e与Φ的最大公因数为1。
4. 计算d，使得 ed ≡ 1 (mod Φ)，即d为e关于Φ的逆元，可以用扩展欧几里得算法求得。

此时，公钥为(n, e)，私钥为(d)。

接下来，我们可以实现加密和解密操作：

1. 加密：将明文转换为整数M，计算密文C = M^e mod n。
2. 解密：将密文转换为整数C，计算明文M = C^d mod n。

接下来，我们将RSA算法扩展为可以支持多个分组的情况：

1. 将明文分成若干个小组，每组的大小不超过n的长度。
2. 对于每个小组，将其转换为整数，然后使用公钥进行加密。
3. 加密后的密文是一个整数序列，将其拼接成一个大整数C。
4. 对密文C使用私钥进行解密，获得一个大整数M。
5. 将M拆分为多个小组，每个小组对应一个明文分组。

这样，我们就实现了多个分组的RSA加密解密算法。需要注意的是，RSA算法的安全性和效率都和密钥的长度和选取方式有关，建议使用足够长的密钥并遵循安全的密钥选取方式。

rsa加密解密算法c语言

RSA加密解密算法是一种非对称加密算法，它的加密和解密过程使用了不同的密钥，其中公钥用于加密，私钥用于解密。以下是RSA加密解密算法的C语言实现。

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

#define MAX_SIZE 1000

// 计算幂模
long long pow_mod(long long a, long long b, long long c)
{
    long long ans = 1;
    a = a % c;

    while (b > 0)
    {
        if (b % 2 == 1)
            ans = (ans * a) % c;

        b = b / 2;
        a = (a * a) % c;
    }

    return ans;
}

// 判断一个数是否为质数
int is_prime(long long n)
{
    if (n <= 1)
        return 0;

    for (long long i = 2; i <= sqrt(n); i++)
    {
        if (n % i == 0)
            return 0;
    }

    return 1;
}

// 获取一个随机质数
long long get_prime()
{
    long long prime;
    srand((unsigned)time(NULL));

    do
    {
        prime = rand() % MAX_SIZE + 1;
    } while (!is_prime(prime));

    return prime;
}

// 计算最大公因数
long long gcd(long long a, long long b)
{
    if (a == 0)
        return b;

    return gcd(b % a, a);
}

// 计算模反元素
long long mod_inverse(long long a, long long m)
{
    long long m0 = m, t, q;
    long long x0 = 0, x1 = 1;

    if (m == 1)
        return 0;

    while (a > 1)
    {
        q = a / m;
        t = m;

        m = a % m, a = t;
        t = x0;

        x0 = x1 - q * x0;
        x1 = t;
    }

    if (x1 < 0)
        x1 += m0;

    return x1;
}

// 生成公钥和私钥
void generate_key(long long *e, long long *d, long long *n)
{
    long long p, q, phi, e_key;

    // 获取两个随机质数
    p = get_prime();
    q = get_prime();

    // 计算n和phi
    *n = p * q;
    phi = (p - 1) * (q - 1);

    // 获取与phi互质的随机数e
    do
    {
        e_key = rand() % (phi - 2) + 2;
    } while (gcd(e_key, phi) != 1);

    *e = e_key;
    *d = mod_inverse(e_key, phi);
}

// RSA加密
void encrypt(char *plaintext, long long e, long long n, char *ciphertext)
{
    long long i, len = strlen(plaintext), m, c;
    char temp[MAX_SIZE];
    strncpy(temp, plaintext, MAX_SIZE);

    for (i = 0; i < len; i++)
    {
        m = temp[i];
        c = pow_mod(m, e, n);
        sprintf(&ciphertext[i * 4], "%04lld", c);
    }
}

// RSA解密
void decrypt(char *ciphertext, long long d, long long n, char *plaintext)
{
    long long i, len = strlen(ciphertext) / 4, m, c;
    char temp[MAX_SIZE];

    for (i = 0; i < len; i++)
    {
        strncpy(temp, &ciphertext[i * 4], 4);
        c = atol(temp);
        m = pow_mod(c, d, n);
        plaintext[i] = m;
    }

    plaintext[len] = '\0';
}

int main()
{
    long long e, d, n;
    char plaintext[MAX_SIZE], ciphertext[MAX_SIZE];

    printf("请输入明文:");
    scanf("%s", plaintext);

    // 生成公钥和私钥
    generate_key(&e, &d, &n);

    // RSA加密
    encrypt(plaintext, e, n, ciphertext);
    printf("加密后的密文:%s\n", ciphertext);

    // RSA解密
    decrypt(ciphertext, d, n, plaintext);
    printf("解密后的明文:%s\n", plaintext);

    return 0;
}

注意，上述代码中的MAX_SIZE定义了最大字符串长度，需要根据实际情况进行修改。在encrypt函数中，将每个字符的加密结果转化为4位数字，这样可以确保每个字符的加密结果都是固定的长度。在decrypt函数中，每次从密文中读取4位数字并解密为对应的字符。