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);

modf函数将参数value分解为整数和小数部分，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  '.'  '\0'  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

或使用public boolean insertEmployeeDetails(Employee employee) { logger.debug("Starting EmployeeDaoImpl.insert() ....."); Session session = null; Transaction tx = null; boolean status = true; try { session = sessionFactory.openSession(); tx = session.beginTransaction(); EmployeeTopMetaData empMetaData = (EmployeeTopMetaData) session.createCriteria(EmployeeTopMetaData.class) // This is the line #50 .setProjection(Projections.property("valueEmpId")) .add(Restrictions.eq("testingId", 1234)) .add(Restrictions.eq("company_employee_id", 3345)) .uniqueResult(); if (empMetaData == null || empMetaData. getvalueEmpId() < 1) { throw new Exception("Invalid empMetaData"); } System.out.println("October 04 EmployeeTopMetaData: "); System.out.println(empMetaData. getvalueEmpId()); // Some more code to go session.persist(employee); tx.commit(); } catch(Exception ex) { tx.rollback(); ex.printStackTrace(); status = false; } finally { session.close(); } logger.debug("Completed EmployeeDaoImpl.insert() ....."); return status; } @John Bollinger。

EmployeeTopMetaData.java函数计算package abc.def.myproject.orm; @Entity @Table(name="EMPLOYEE_TOP_METADATA") public class EmployeeTopMetaData { public int getTestingId() { return testingId; } public void setTestingId(int testingId) { this.testingId = testingId; } public int getCompanyEmpId() { return company_employee_id; } public void setCompanyEmpId(int company_employee_id) { this.company_employee_id = company_employee_id; } public int getvalueEmpId() { return valueEmpId; } public void setvalueEmpId(int valueEmpId) { this.valueEmpId = valueEmpId; } @Id @Column(name="TESTING_ID") private int testingId; @Column(name="COMPANY_EMP_ID") private int company_employee_id; @Column(name="VALUE_EMP_ID") private int valueEmpId; }的浮点余数。

使用10 ^place的modding和使用10 ^place-1进行修改来提取每个2位数字。

减去2位数，然后将它们重新添加回来。

fmod()

输出

fmod

交换双C中的数字

7 个答案: