在 C 中以双精度交换数字

Question

我想在 C 中做的是交换两位数字。

例如，如果输入是54321.987，我想交换第2位和第4位，输出应该是52341.987。

太小的示例：12.34 会输出 1002.34。

Answer 1

使用字符串化方法：
还有更优雅的方法，但您可以看到这个伪代码的步骤（并改进）以进行字符串化、移动值和转换回数字。

char buf1[20];
char buf2[20];
char *dummy;
double val = 54321.987;

sprintf(buf1, "%9.3f", val );
//Now the number is in string form: "54321.987".  Just move the two elements  
buf2[0]=buf1[0];
buf2[1]=buf1[3];
buf2[2]=buf1[2];
buf2[3]=buf1[1]; //and so on
//now convert back:

val = strtod(buf2, &dummy);
printf("%9.3f\n", val);

或者，一个函数可以用来做本质上相同的事情：（仍然是字符串化）

double swap_num_char(double num, int precision, int c1, int c2); //zero index for c1 and c2


int main(void)
{

    double val = 54321.987;

    printf("%9.3f\n", swap_num_char(val, 3, 1, 3));

    return 0;   
}

double swap_num_char(double num, int precision, int c1, int c2)
{
    char buf[25]; 
    char format[10];
    char *dummy;
    char c;

    sprintf(format, "%s0.%df", "%", precision);

    sprintf(buf, format, num);

    c = buf[c1];
    buf[c1] = buf[c2];
    buf[c2] = c;

    num = strtod(buf, &dummy);

    return num;
}

Answer 2

如果你希望输入的数字是双倍的，那么你可以这样做：

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

    int main()
    {
        double numbergiven = 56789.1234;
        double dummy;
        double _4th_digit = (10*modf(numbergiven/10000, &dummy)) - modf(numbergiven/1000, &dummy);
        double _2th_digit = (10*modf(numbergiven/100, &dummy)) - modf(numbergiven/10, &dummy);
        numbergiven = numbergiven - (_4th_digit * 1000) + (_2th_digit * 1000);
        numbergiven = numbergiven + (_4th_digit * 10) - (_2th_digit * 10);
        printf("%lf",numbergiven);
        return 0;
    }

如果你不熟悉 modf 那么你可以简单地这样做：

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

    int main()
    {
        double numbergiven = 56789.1234;
        int number = numbergiven;
        int _4th_digit = (number/1000) - (10*(number/10000));
        int _2th_digit = (number/10) - (10*(number/100));
        numbergiven = numbergiven - (_4th_digit * 1000) + (_2th_digit * 1000);
        numbergiven = numbergiven + (_4th_digit * 10) - (_2th_digit * 10);
        printf("%lf",numbergiven);
        return 0;
    }

Answer 3

您可以通过简单的操作得到您感兴趣的两位数字：

您可以使用

double x = 54321.987;
double tens = ((int)(x / 10)) % 10;        // Result is 2
double thousands = ((int)(x / 1000)) % 10; // Result is 4

然后你就可以把原来的数字减去，并将它们添加回新位置：

x = x - (tens * 10.0) - (thousands * 1000.0); // result is 50301.987
x = x + (tens * 1000.0) + (thousands * 10.0); // result is 52341.987

现在只需减少表达式：

x = x + tens * (1000.0 - 10.0) - thousands * (1000.0 - 10.0);

最后的表达式是：

x += (tens - thousands) * 990.0;

或者，如果您不想要中间变量：

x += (((int)(x/10))%10 - ((int)(x/1000))%10) * 990;

Answer 4

一种解决方案是提取数字，然后交换它们。

您使用 floor():

提取数字（至少从正数中提取）

int place1 = 1; /* 0-based*/
double desiredPowerOf10 = powersOf10[place1];
double nextPowerOf10 = powersOf10[place1 + 1];
double digit1 = floor(number / desiredPowerOf10) - floor(number/nextPowerOf10) * 10;

然后您可以减去数字并以不同的幂将它们加回去：

double digitsRemoved = number - (digit1 * power1 + digit2 * power2);
double digitsSwapped = digitsRemoved + digit1 * power2 + digit2 * power1;

不过，对于非常大的数字，这可能会导致精度损失。

Answer 5

1 - 使用 modf() 将数字分成整数和小数部分。

double modf(double value, double *iptr);

The modf functions break the argument value into integral and fractional parts, C11 §7.12.6.12

2 - 将整数部分打印为字符串并进行交换。

3 - 重建

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

double swap2_4digit(double x) {
  if (signbit(x)) {
    return -swap2_4digit(-x);
  }
  printf("Before %f\n", x);
  double ipart;
  double fpart = modf(x, &ipart);
  //       ms_digit    digits  '.'  '[=11=]'  min_size  
  char buf[1 + DBL_MAX_10_EXP + 1 +  1   + 4];  // Insure buffer is big enough

  strcpy(buf, "0000");  // Handle small numbers
  sprintf(buf + strlen(buf), "%.0f", ipart);
  size_t len = strlen(buf);
  char ch = buf[len - 2];
  buf[len - 2] = buf[len - 4];
  buf[len - 4] = ch;

  x = atof(buf) + fpart;
  printf("After  %f\n", x);
  return x;
}

int main(void) {
  swap2_4digit(54321.987);
  swap2_4digit(12.34);
}

输出

Before 54321.987000
After  52341.987000
Before 12.340000
After  1002.340000

留给OP的东西。为其他数字位置通用。

Answer 6

Double 作为位序列存储在内存中，但您想使用十进制数字进行运算。使用 double 变量执行此操作，您可能不会收到原始数字，因为 floating-point arithmetic.

因此，您应该使用 double 的字符串表示形式进行操作。主要方面是字符串将包含多少位数字。但很明显，您从输入中获得了数字。将其扫描为字符串，而不是 double.

有一个工作代码：

#include <stdio.h>
#include <stddef.h>

#define BUFSIZE 255

void swap_digits(char *str, int n, int m) {
    char *digit1 = NULL;
    char *digit2 = NULL;

    int count = 0;
    while (*str && (!digit1 || !digit2)) {
        if (*str != '.') {
            count++;
            if (count == n) {
                digit1 = str;
            }
            if (count == m) {
                digit2 = str;
            }
        }

        str++;
    }

    if (digit1 && digit2) {
        char tmp = *digit1;
        *digit1 = *digit2;
        *digit2 = tmp;
    }
}

int main(void) {
    char buffer[BUFSIZE];
    scanf("%s", buffer);

    // it is preferably to validate input

    swap_digits(buffer, 2, 4);
    printf(buffer);
    return 0;
}

Answer 7

或使用fmod() .

The fmod functions compute the floating-point remainder of x/y.

提取2位数字，每个数字与10^place的modding和10^place-1.[=17=的modding不同]

减去 2 位数字，然后将它们交换回来。

double swap_digit(double x, unsigned a, unsigned b) {
  printf("Before %f\n", x);
  double a_place = pow(10.0, a);
  double b_place = pow(10.0, b);
  double scaled_digit_a = fmod(x, a_place) - fmod(x, a_place/10);
  double scaled_digit_b = fmod(x, b_place) - fmod(x, b_place/10);
  x -= scaled_digit_a + scaled_digit_b;
  x += scaled_digit_a/a_place*b_place + scaled_digit_b/b_place*a_place;
  printf("After  %f\n", x);
  return x;
}

int main(void) {
  swap_digit(54321.987,2,4);
  swap_digit(12.34,2,4);
}

输出

Before 54321.987000
After  52341.987000
Before 12.340000
After  1002.340000

在 C 中以双精度交换数字

Swap digits in a double in C

c

double

swap

digits