在c编程中交换一些数字

我有一个号码要排序。我知道如何按升序和降序排序，但问题是要在数字中切换位置值。

继续我的评论，回答您的问题：

我如何修改下面的代码以获得上面的代码，还是必须开始一个新的代码

我将从一个新的方法开始。为什么？虽然您可以使用一组占位符并设置各种条件来操纵整数值，以根据奇数/偶数完成中间数字或结束数字交换，但简单地将整数值转换为字符串，然后操纵字符要容易得多

如果您使用的是整数，则必须处理的最长整数是

INT\u MIN

（

-2147483648

），或

11个字符（
+1
，表示nul终止字符）。您只需使用
12
chars的静态字符缓冲区并调用
sprintf
即可将整数转换为字符串（同时在同一调用中获取其长度）。一个简单的奇偶测试，您知道交换中间字符或结束字符。要将结果字符串转换回整数，只需使用
strtol

您可以在开始时测试负值，处理正值形式，然后将结果值乘以
-1
，如果值为负值，则返回。（注意：在将正数形式指定为
-INT\u MIN
之前，您还应该测试
INT\u MIN
是否适合整数值。您还必须检查交换数字后生成的整数是否也适合整数值。--这是留给您的练习）

将这些部件组合在一起，您可以执行类似的操作：

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

enum {BASE = 10, MAXS = 12};            /* constants */

int minswap (int v)
{
    char buf[MAXS] = "";
    int neg = v < 0 ? -1 : 1,           /* flag negative numbers  */
        val = v * neg,                  /* handle as positive val */
        len = sprintf (buf, "%d", val); /* conver to str, get len */

    if (len % 2 == 0) {                 /* val is even */
        int m = len / 2;
        char tmp = buf[m - 1];          /* swap mid digits */
        buf[m - 1] = buf[m];
        buf[m] = tmp;
    }
    else {
        char tmp = *buf;                /* swap end digits */
        *buf = buf[len - 1];
        buf[len - 1] = tmp;
    }

    return (int)strtol (buf, NULL, BASE) * neg;
}

int main (void) {

    int v1 = 264802,
        v2 = 1357246;

    printf (" %d => %d\n", v1, minswap(v1));
    printf (" %d => %d\n", v2, minswap(v2));

    return 0;
}

仔细检查一下，如果有任何问题，请告诉我


不使用库函数

如果您需要在
minswap
函数中不使用任何C库函数，您可以轻松地将其替换为类似以下内容的循环：

enum {BASE = 10, MAXS = 12};            /* constants */

int minswap (int v)
{
    char buf[MAXS] = "";
    int neg = v < 0 ? -1 : 1,           /* flag negative numbers  */
        val = v * neg,                  /* handle as positive val */
        len = 0;

    while (len + 1 < MAXS && val) {     /* convert to string get len */
        buf[len++] = val % 10 + '0';
        val /= 10;
    }
    /* (you should validate len > 0 here) */

    if (len % 2 == 0) {                 /* val is even */
        int m = len / 2;
        char tmp = buf[m - 1];          /* swap mid digits */
        buf[m - 1] = buf[m];
        buf[m] = tmp;
    }
    else {
        char tmp = *buf;                /* swap end digits */
        *buf = buf[len - 1];
        buf[len - 1] = tmp;
    }

    while (len--)                       /* convert to int */
        val = val * 10 + buf[len] - '0';

    return val * neg;
}

enum{BASE=10，MAXS=12}；/*常数*/
int minswap（int v）
{
字符buf[MAXS]=“”；
int neg=v<0？-1:1，/*标志负数*/
val=v*neg，/*处理为正值val*/
len=0；
而（len+10）*/
如果（len%2==0）{/*val为偶数*/
int m=len/2；
字符tmp=buf[m-1]；/*交换中间数字*/
buf[m-1]=buf[m]；
buf[m]=tmp；
}
否则{
字符tmp=*buf；/*交换结束数字*/
*buf=buf[len-1]；
buf[len-1]=tmp；
}
而（len--）/*转换为int*/
val=val*10+buf[len]-'0'；
返回val*neg；
}

（注意：实际上不需要使用
-/+'0'
转换为字符值，因为您只需在中间或末端位置交换值，但为了完整性起见，其中包括了这一点。）

仔细检查一下，如果您还有其他问题，请告诉我。
试试这个

#include <stdio.h>

unsigned power(unsigned base, unsigned exp){
    unsigned result = 1;
    while(exp > 0){
        if(exp & 1)
            result = result * base;
        base = base * base;
        exp >>=1;
    }
    return result;//Overflow is not considered
}
int pow10(int exp){
    return power(10, exp);
}
int get_num_at(int n, int pos){
    int exp = pow10(pos);
    return n / exp % 10;//Changed by advice of chux
}
int swap(int n, int pos1, int pos2){
    if(pos1 == pos2)
        return n;
    int n1 = get_num_at(n, pos1);
    int n2 = get_num_at(n, pos2);
    return n - n1 * pow10(pos1) - n2 * pow10(pos2) + n1 * pow10(pos2) + n2 * pow10(pos1);
}
int length(int n){
    int len = 1;

    while(n /= 10)
        ++len;
    return len;
}
int arrange(int v){
    int len = length(v), half = len / 2;

    return (len & 1) ? swap(v, 0, len-1) : swap(v, half-1, half);//0 origin
}

int main (void) {
    int v;

    scanf("%d", &v);
    printf ("%d\n", arrange(v));
}

#包括
无符号幂（无符号基、无符号exp）{
无符号结果=1；
而（exp>0）{
if（exp&1）
结果=结果*基数；
基数=基数*基数；
exp>>=1；
}
返回结果；//不考虑溢出
}
int pow10（int exp）{
返回功率（10，exp）；
}
int get_num_at（int n，int pos）{
int exp=功率10（位置）；
返回n/exp%10；//由chux的建议更改
}
整数交换（整数n，整数pos1，整数pos2）{
if（pos1==pos2）
返回n；
int n1=在（n，位置1）处获取数量；
int n2=在（n，位置2）处获取数量；
返回n-n1*pow10（pos1）-n2*pow10（pos2）+n1*pow10（pos2）+n2*pow10（pos1）；
}
整数长度（整数n）{
int len=1；
而（n/=10）
++len；
回程透镜；
}
整数排列（整数v）{
int len=长度（v），一半=len/2；
返回（len&1）？交换（v，0，len-1）：交换（v，half-1，half）；//0原点
}
内部主（空）{
INTV；
scanf（“%d”和“&v”）；
printf（“%d\n”，排列（v））；
}
这是一个没有任何标准库调用、数组或字符串的解决方案，除了打印结果：

#include <stdio.h>

long long shuffle(int v) {
    int i, n, x, d0, d1;
    long long p;

    /* compute the number of digits and the largest power of 10 <= v */
    for (x = v, p = 1, n = 1; x > 9; x /= 10, p *= 10, n++)
        continue;

    if (n & 1) {
        /* odd number of digits, swap first and last */
        d0 = v % 10;
        d1 = v / p;
        return d0 * p + v % p - d0 + d1;
    } else {
        /* even number of digits, swap middle 2 digits */
        for (i = 0, p = 1; i < n / 2 - 1; i++, p *= 10)
            continue;
        d0 = (v / p) % 10;
        d1 = (v / p) / 10 % 10;
        return v + p * (d0 - d1) * 9;
    }
}

int main(void) {
    printf("%d => %lld\n", 0, shuffle(0));
    printf("%d => %lld\n", 1, shuffle(1));
    printf("%d => %lld\n", 42, shuffle(42));
    printf("%d => %lld\n", 24, shuffle(24));
    printf("%d => %lld\n", 264802, shuffle(264802));
    printf("%d => %lld\n", 1357246, shuffle(1357246));

    return 0;
}

注:


我不处理负数
倒过来的数字可能不适合
int
，因此我使用了类型
long-long
，但在
int
与
long
具有相同范围的系统上，仍然可能会得到不正确的结果
我完成了作业，代码如下。这有点原始，但它很有效。谢谢大家的贡献

int swapvalues(int input, int digit)
{
  int swapsort = 0; //initializes swapsort to 0
  int lastdigit; //finds he last digit of input
  int digits; //the total number of digits - 1
  int firstdigit; //finds the first digit of the input
  int middledigit; //finds the first middle digit in an even digit number
  int secondmiddledigit; //finds the second middle digit in an even digit number
  int firsthalf; //the first half of an even digit number
  int firsthalf2; //the second half of an even digit number
  int spacing; //the spacing between the output and the input
  if(digit % 2 != 0)
  {
    lastdigit  = input % 10;
    digits     = digit - 1;
    firstdigit = (int)(input / pow(10, digits));
    swapsort  = lastdigit;
    swapsort *= (int) pow(10, digits);
    swapsort += input % ((int)pow(10, digits));
    swapsort -= lastdigit;
    swapsort += firstdigit;
  }
  else
  {
    firsthalf = input / pow(10, (digit / 2));
    middledigit = firsthalf % 10;
    firsthalf2 = input / pow(10, (digit / 2) - 1);
    secondmiddledigit = firsthalf2 % 10;
    spacing = (((secondmiddledigit * 10) + (middledigit)) - ((middledigit * 10) + (secondmiddledigit))) * pow(10, ((digit / 2) - 1));
    swapsort = input + spacing;
  }
  return(swapsort);
}

int-lcv//初始化循环控制变量
-这不会初始化变量，它会声明它是正确的，很好的捕获，谢谢如果您尝试通过操纵整数值本身有条件地交换数字，您的逻辑将变得不必要的复杂，最好将数字转换为其字符串表示形式，有条件地交换中间或结尾字符，然后将结果字符串转换为int。这要容易得多。（提示-整数长度不能超过10个字符（11带有前面的
'-'
符号），如果使用
sprintf
转换为字符串很简单。（不要忘记为nul终止字符留出空间）.使用strtol

返回也很简单。但问题是我不能使用标准库。我只允许使用循环控制结构（do、while和for循环）和if-else语句来完成任务。很遗憾，我不允许使用字符串和数组。好的，只需修改循环以填充缓冲区，就可以了。您可以简单地返回int。我

0 => 0
1 => 1
42 => 24
24 => 42
264802 => 268402

int swapvalues(int input, int digit)
{
  int swapsort = 0; //initializes swapsort to 0
  int lastdigit; //finds he last digit of input
  int digits; //the total number of digits - 1
  int firstdigit; //finds the first digit of the input
  int middledigit; //finds the first middle digit in an even digit number
  int secondmiddledigit; //finds the second middle digit in an even digit number
  int firsthalf; //the first half of an even digit number
  int firsthalf2; //the second half of an even digit number
  int spacing; //the spacing between the output and the input
  if(digit % 2 != 0)
  {
    lastdigit  = input % 10;
    digits     = digit - 1;
    firstdigit = (int)(input / pow(10, digits));
    swapsort  = lastdigit;
    swapsort *= (int) pow(10, digits);
    swapsort += input % ((int)pow(10, digits));
    swapsort -= lastdigit;
    swapsort += firstdigit;
  }
  else
  {
    firsthalf = input / pow(10, (digit / 2));
    middledigit = firsthalf % 10;
    firsthalf2 = input / pow(10, (digit / 2) - 1);
    secondmiddledigit = firsthalf2 % 10;
    spacing = (((secondmiddledigit * 10) + (middledigit)) - ((middledigit * 10) + (secondmiddledigit))) * pow(10, ((digit / 2) - 1));
    swapsort = input + spacing;
  }
  return(swapsort);
}