论坛 › C\C++交流 › 调换一个数的俩个数字位置，将该数最大化

霁清d 发表于 2021-10-1 02:01:11

调换一个数的俩个数字位置，将该数最大化

调换一个数中的两个数字位置，将该数最大化。
例如：15469 输出95461
       1234 输出 4231
       512 输出 521
#include <stdio.h>

int main()
{   
    long long int n,k;
    inti=0,j=0, m=0, t=0, b=0, c=0, A,B;
    scanf("%lld", &n);
    k=n;
    while(n != 0)
    {
      m++;      //m =数字的位数
      n /= 10;
    }
    for(i = 0; i < m; i++)
    {
      A=k%10;//A数组中是倒序存入每个数字
      k /= 10;
    }
    n=m;k=0;
    for(i = 0; i < m; i++)
    {
      B=A;    //B数组是正序存入每个数字
      n--;
    }
    for(b = 0; b < m; b++)
    {
      for(i = 0; i < (m-b); i++)
      {
         if (B < B)
            {
                t = B;
                B = B;      //两个for语句想要实现换位，目前没办法实现
                B = t;
                c++;
                break;
            }
      }
    }
    for(i=0; i<m; i++)
    {
      printf("%d", B); //输出B中每个元素
    }
    return 0;
}

霁清d 发表于 2021-10-1 02:01:58

如果有其他思路，也请各位大神告诉下。谢谢！！！

jhq999 发表于 2021-10-1 06:48:42

本帖最后由 jhq999 于 2021-10-1 06:50 编辑

例如：15469
先从最高位1和5469对比，把比1大5469的存起来，再对5469取最大与1交换，跳出所有循环；
如果没有比1大的，再从第二位5和469对比，把比5大的69存起来，再对比69取最大与5交换，跳出所有循环；
以此类推直到6和9对比

jhq999 发表于 2021-10-1 08:50:20

int main()
{   
        int val=856479,tmp=0,i=0,j=0,flag=0,max=0,count=0;
        char ch={0};
        i=0;
        while(val)
        {
                ch=val%10;
                val=val/10;
        }
        count=i-1;
       
        for (i =count; i >=0; i--)
        {
                max=i;
                j = i-1;
                for ( ;j >=0; j--)
                {
                        if (ch>ch)
                        {
                                max=j;
                                flag=1;
                        }
                }
                if (flag)
                {
                        tmp=ch;
                        ch=ch;
                        ch=tmp;
                        break;
                }
        }
    val=0;
        for (i = count; i>=0 ; i--)
        {
                val*=10;
                val+=ch;
        }
        return 0;
}

人造人 发表于 2021-10-1 09:07:31

#include <stdio.h>
#include <stdint.h>

static void swap(char *a, char *b) {
    char temp = *a;
    *a = *b; *b = temp;
}

void digits_get(char digits[], size_t *size, uint32_t value) {
    *size = 0;
    do {
      digits[(*size)++] = (value % 10) + '0';
      value /= 10;
    } while(value);
}

void digits_set(const char digits[], size_t size, uint32_t *value) {
    *value = 0;
    for(size_t i = 0; i < size; ++i) {
      *value *= 10;
      *value += digits - '0';
    }
}

void digits_sort(char digits[], size_t size) {
    for(size_t i = 0; i < size; ++i) {
      for(size_t j = i + 1; j < size; ++j) {
            if(digits < digits)
                swap(&digits, &digits);
      }
    }
}

int main(void) {
    char digits;
    size_t size;
    uint32_t n;
    scanf("%u", &n);
    digits_get(digits, &size, n);
    digits_sort(digits, size);
    digits_set(digits, size, &n);
    printf("%u\n", n);
    return 0;
}

人造人 发表于 2021-10-1 09:21:12

不要把所有东西都塞到 main 函数中呀
main 函数是 主函数
主函数只负责主逻辑
主逻辑是什么？
1. 用户输入一个数
2. 把这个数的各个数位提取出来
3. 对提取出来的数位排序
4. 把排好序的数位组装成一个新的数
5. 输出这个数

jhq999 发表于 2021-10-1 09:27:16

本帖最后由 jhq999 于 2021-10-1 09:29 编辑

人造人 发表于 2021-10-1 09:21
不要把所有东西都塞到 main 函数中呀
main 函数是 主函数
主函数只负责主逻辑


“调换一个数中的两个数字位置，将该数最大化。”只互换一次；
当然也可以先排序，然后按数位对比互换一次，然后再重新按数位输出。
感觉很麻烦

楼主的问题就是按从大到小排序的变种

人造人 发表于 2021-10-1 09:33:07

jhq999 发表于 2021-10-1 09:27
“调换一个数中的两个数字位置，将该数最大化。”只互换一次；
当然也可以先排序，然后按数位对比互换 ...

“只互换一次” 是什么意思？
看这个例子，没有看出 “只互换一次” 的意思
例如：15469 输出95461
         1234 输出 4231
         512 输出 521

jhq999 发表于 2021-10-1 09:40:43

人造人 发表于 2021-10-1 09:33
“只互换一次” 是什么意思？
看这个例子，没有看出 “只互换一次” 的意思
例如：15469 输出95461


15469 输出95461 如果不是一次应该是96541 ；1和9
1234 输出 4231应该是4321；1和4
512 输出 521；1和2

人造人 发表于 2021-10-1 09:53:45

jhq999 发表于 2021-10-1 09:40
15469 输出95461 如果不是一次应该是96541 ；1和9
1234 输出 4231应该是4321；1和4
512 输出 521；1 ...

明白了，感谢指出问题，^_^

人造人 发表于 2021-10-1 09:54:16

#include <stdio.h>
#include <stdint.h>

static void swap(char *a, char *b) {
    char temp = *a;
    *a = *b; *b = temp;
}

void digits_get(char digits[], size_t *size, uint32_t value) {
    *size = 0;
    do {
      digits[(*size)++] = (value % 10) + '0';
      value /= 10;
    } while(value);
}

void digits_set(const char digits[], size_t size, uint32_t *value) {
    *value = 0;
    for(int i = size - 1; i >= 0; --i) {
      *value *= 10;
      *value += digits - '0';
    }
}

void digits_change(char digits[], size_t size) {
    size_t max = 0, min = 0;
    for(size_t i = 0; i < size; ++i) {
      if(digits > digits) max = i;
      if(digits < digits) min = i;
    }
    swap(&digits, &digits);
}

int main(void) {
    char digits;
    size_t size;
    uint32_t n;
    scanf("%u", &n);
    digits_get(digits, &size, n);
    digits_change(digits, size);
    digits_set(digits, size, &n);
    printf("%u\n", n);
    return 0;
}

人造人 发表于 2021-10-1 09:57:37

人造人 发表于 2021-10-1 09:54


这样还是不对，我再研究研究

人造人 发表于 2021-10-1 10:12:32

本帖最后由 人造人 于 2021-10-1 10:14 编辑

这次可以了
1. 用户输入一个数
2. 把这个数的各个数位提取出来
3. 对提取出来的数位按题目要求交换
4. 把交换后的数位组装成一个新的数
5. 输出这个数
#include <stdio.h>
#include <stdint.h>

static void swap(char *a, char *b) {
    char temp = *a;
    *a = *b; *b = temp;
}

void digits_get(char digits[], size_t *size, uint32_t value) {
    *size = 0;
    do {
      digits[(*size)++] = (value % 10) + '0';
      value /= 10;
    } while(value);
    for(size_t i = 0, j = *size - 1; i < j; ++i, --j) \
      swap(&digits, &digits);
}

void digits_set(const char digits[], size_t size, uint32_t *value) {
    *value = 0;
    for(size_t i = 0; i < size; ++i) {
      *value *= 10;
      *value += digits - '0';
    }
}

void digits_swap(char digits[], size_t size) {
    for(size_t i = 0; i < size; ++i) {
      size_t max = i;
      for(size_t j = i + 1; j < size; ++j) {
            if(digits < digits) max = j;
      }
      if(max != i) {
            swap(&digits, &digits);
            return;
      }
    }
}

int main(void) {
    char digits;
    size_t size;
    uint32_t n;
    scanf("%u", &n);
    digits_get(digits, &size, n);
    digits_swap(digits, size);
    digits_set(digits, size, &n);
    printf("%u\n", n);
    return 0;
}

jhq999 发表于 2021-10-1 10:17:28

人造人 发表于 2021-10-1 09:57
这样还是不对，我再研究研究

排完序更麻烦，还得记录排序之前的数位，根本不用完全排序，只需要按高数位到底数位的顺序，和它后面对比取最大，如果有比它大的取最大的，互换，退出过程，否则继续直到最后两位结束

人造人 发表于 2021-10-1 10:19:38

jhq999 发表于 2021-10-1 10:17
排完序更麻烦，还得记录排序之前的数位，根本不用完全排序，只需要按高数位到底数位的顺序，和它后面对 ...

嗯，我改好了，你可以看看，应该是没问题了

jhq999 发表于 2021-10-1 10:49:20

人造人 发表于 2021-10-1 10:19
嗯，我改好了，你可以看看，应该是没问题了

我看没有问题了，测了3数

霁清d 发表于 2021-10-1 23:01:37

谢谢各位 谢谢！！

霁清d 发表于 2021-10-2 00:08:14

人造人 发表于 2021-10-1 10:12
这次可以了
1. 用户输入一个数
2. 把这个数的各个数位提取出来


打扰问下 如果是12222，好像没办法正确输出22221

人造人 发表于 2021-10-2 09:09:16

霁清d 发表于 2021-10-2 00:08
打扰问下 如果是12222，好像没办法正确输出22221

#include <stdio.h>
#include <stdint.h>

static void swap(char *a, char *b) {
    char temp = *a;
    *a = *b; *b = temp;
}

void digits_get(char digits[], size_t *size, uint32_t value) {
    *size = 0;
    do {
      digits[(*size)++] = (value % 10) + '0';
      value /= 10;
    } while(value);
    for(size_t i = 0, j = *size - 1; i < j; ++i, --j) \
      swap(&digits, &digits);
}

void digits_set(const char digits[], size_t size, uint32_t *value) {
    *value = 0;
    for(size_t i = 0; i < size; ++i) {
      *value *= 10;
      *value += digits - '0';
    }
}

void digits_swap(char digits[], size_t size) {
    for(size_t i = 0; i < size; ++i) {
      size_t max = i;
      for(size_t j = i + 1; j < size; ++j) {
            //if(digits < digits) max = j;
            if(digits <= digits) max = j;
      }
      if(max != i) {
            swap(&digits, &digits);
            return;
      }
    }
}

int main(void) {
    char digits;
    size_t size;
    uint32_t n;
    scanf("%u", &n);
    digits_get(digits, &size, n);
    digits_swap(digits, size);
    digits_set(digits, size, &n);
    printf("%u\n", n);
    return 0;
}

霁清d 发表于 2021-10-3 15:08:15

人造人 发表于 2021-10-2 09:09


谢谢 ！！{:10_302:}

查看完整版本: 调换一个数的俩个数字位置，将该数最大化