用C++写【题目描述】 利用标准输入输出 (scanf printt) ，输入两个整数a b, 出a/b的结果。 要求输入的两个数 据之间用逗号隔开。输出为三行，格式为： a/b=C" о (结果c用 十进制，八进制，十六进制三种 方式表示）。 样例输入 100,2 输出样例： 100/2=50 （十进制）

#include<stdio.h>
int main()
{
    int a,b,c;
    scanf("%d,%d",&a,&b);
    c=a/b;
    printf("%d/%d=%d (十进制)\n",a,b,c);
    printf("%d/%o=%o (八进制)\n",a,b,c);
    printf("%d/%x=%x (十六进制)\n",a,b,c);
    return 0;
}

相关问题

用C++定义一个大整数类，能完成大整数的+-*/输入和输出

好的，我知道了。关于您的问题，可以使用结构体和字符数组来实现大整数的输入、输出、加减乘除等运算，具体实现如下：

#include <stdio.h>
#include <string.h>
#define MAXN 1000

typedef struct BigInteger {
    int len, s[MAXN];
    BigInteger() {
        memset(s, 0, sizeof(s));
        len = 1;
    }
    BigInteger(const char* num) {
        memset(s, 0, sizeof(s));
        int L = strlen(num);
        len = L;
        for (int i = 0; i < L; i++) s[i] = num[L - i - 1] - '0';
    }
    BigInteger operator=(const char* num) {
        memset(s, 0, sizeof(s));
        int L = strlen(num);
        len = L;
        for (int i = 0; i < L; i++) s[i] = num[L - i - 1] - '0';
        return *this;
    }
    BigInteger operator=(int num) {
        char s[MAXN];
        sprintf(s, "%d", num);
        *this = s;
        return *this;
    }
    BigInteger operator+(const BigInteger& b) const {
        BigInteger c;
        c.len = 0;
        for (int i = 0, g = 0; g || i < max(len, b.len); i++) {
            int x = g;
            if (i < len) x += s[i];
            if (i < b.len) x += b.s[i];
            c.s[c.len++] = x % 10;
            g = x / 10;
        }
        return c;
    }
    BigInteger operator-(const BigInteger& b) const {
        BigInteger c;
        c.len = 0;
        for (int i = 0, g = 0; i < len; i++) {
            int x = s[i] - g;
            if (i < b.len) x -= b.s[i];
            if (x >= 0) {
                g = 0;
            } else {
                g = 1;
                x += 10;
            }
            c.s[c.len++] = x;
        }
        while (c.len > 1 && c.s[c.len - 1] == 0) c.len--;
        return c;
    }
    BigInteger operator*(const BigInteger& b) const {
        BigInteger c;
        c.len = len + b.len;
        for (int i = 0; i < len; i++) {
            for (int j = 0; j < b.len; j++) {
                c.s[i + j] += s[i] * b.s[j];
            }
        }
        for (int i = 0; i < c.len - 1; i++) {
            c.s[i + 1] += c.s[i] / 10;
            c.s[i] %= 10;
        }
        while (c.len > 1 && c.s[c.len - 1] == 0) c.len--;
        return c;
    }
    BigInteger operator/(const BigInteger& b) const {
        BigInteger c;
        c.len = len - b.len + 1;
        if (c.len < 0) {
            c.len = 1;
            return c;
        }
        BigInteger temp = *this;
        for (int i = c.len - 1; i >= 0; i--) {
            BigInteger r("0");
            r.s[0] = temp.s[i + b.len];
            while (r >= b) {
                r = r - b;
                c.s[i]++;
            }
            c.s[i] = c.s[i] % 10;
            BigInteger t("1");
            t = t * pow(10, i);
            r = b * c.s[i];
            temp = temp - r * t;
        }
        while (c.len > 1 && c.s[c.len - 1] == 0) c.len--;
        return c;
    }
    bool operator<(const BigInteger& b) const {
        if (len != b.len) return len < b.len;
        for (int i = len - 1; i >= 0; i--) {
            if (s[i] != b.s[i]) return s[i] < b.s[i];
        }
        return false;
    }
    bool operator>(const BigInteger& b) const {
        return b < *this;
    }
    bool operator<=(const BigInteger& b) const {
        return !(b < *this);
    }
    bool operator>=(const BigInteger& b) const {
        return !(*this < b);
    }
    bool operator!=(const BigInteger& b) const {
        return b < *this || *this < b;
    }
    bool operator==(const BigInteger& b) const {
        return !(b < *this) && !(b > *this);
    }
    void print() {
        for (int i = len - 1; i >= 0; i--) printf("%d", s[i]);
    }
} BIGINT;

int main() {
    char num1[MAXN], num2[MAXN];
    scanf("%s%s", num1, num2);
    BIGINT a(num1), b(num2);
    printf("a - b = ");
    (a - b).print();
    printf("\na * b = ");
    (a * b).print();
    printf("\na / b = ");
    (a / b).print();
    printf("\n");
    return 0;
}

以上代码中，我们使用了结构体 `BigInteger` 代表大整数，其中 `s` 数组存储各位数字，`len` 表示整数位数。同时，我们还定义了加减乘除等运算符号，可以直接使用。

c++实现求一个任意大小整数的精确阶乘值，即：求n！，n是任意大小的整数，n！的结果是精确值

### 回答1：
在 C 语言中，可以使用以下代码来实现求一个任意大小整数的精确阶乘值：

#include <stdio.h>
#include <gmp.h>

int main() {
  int n;
  mpz_t result;

  printf("Enter a number: ");
  scanf("%d", &n);

  mpz_init(result);
  mpz_fac_ui(result, n);

  printf("%d! = ", n);
  mpz_out_str(stdout, 10, result);
  printf("\n");

  mpz_clear(result);

  return 0;
}

这里使用了 GMP 库来实现高精度整数的计算。输入的整数 n 将会被计算为 n! 的结果，并以字符串形式输出。

### 回答2：
要实现求任意大小整数的精确阶乘值，可以使用大数运算的方法。大数运算是一种通过字符串等方式来表示和计算超过计算机位数限制的整数的技术。

首先，将输入的整数n转换为字符串形式，以便进行位数的处理。

然后，创建一个初始值为1的大数变量，用于保存阶乘的结果。

接下来，使用循环遍历从1到n的所有整数。在每次循环中，将当前循环变量转换为字符串形式，然后将该数字与大数变量相乘，得到乘积结果。

最后，更新大数变量的值为乘积结果，继续下一次循环。

当循环结束后，大数变量中的值就是n的阶乘结果。

下面是一段示例代码：

def factorial(n):
    n_str = str(n)
    result = 1

    for i in range(1, n + 1):
        i_str = str(i)
        result *= int(i_str)

    return result

n = int(input("请输入一个整数："))
result = factorial(n)
print(f"{n}的阶乘结果为：{result}")

该代码通过循环将1到n的所有整数依次相乘，最终得到n的阶乘结果。由于大数运算会产生较长的结果，可能需要使用更长的数据类型或其他方法来保存和处理。

### 回答3：
要求一个任意大小整数的精确阶乘值，可以使用大数计算的方法来实现。大数计算是指对超过计算机能够处理的整数进行运算的一种方法。

首先，我们需要一个数据结构来表示大数，可以使用数组来表示。数组的每个元素存储大数的每一位数字。例如，数组[1, 2, 3]表示数字123。

然后，我们可以使用循环来计算阶乘的结果。从2开始，每次将当前的结果与下一个数相乘，并将结果保存在数组中。在每次计算过程中，需要考虑进位的情况。

具体的步骤如下：

1. 初始化一个数组，数组的第一个元素为1，表示初始结果为1。
2. 从2开始，循环计算，直到n：
- 将当前的结果与当前的数相乘，结果保存在数组中。
- 需要考虑进位的情况。
3. 返回数组作为阶乘的精确值。

这种方法可以计算任意大小整数的阶乘，并保持结果的精确性。但是，由于计算大数需要使用数组表示数字并进行进位运算，效率较低。为了提高效率，可以使用其他方法，如通过数学公式或递归等方式来计算阶乘的结果。但无论哪种方法，都需要考虑大数计算的问题。