一个小问题求各位帮助一下

随机生成10个5位自然数（不含0），输出由该自然数的各位数字组成的最小的数。例如，生成8593，则输出为3589。

提示：1. 要将5位数进行分解，并将每一位数存放在同一个一维数组中。

      2. 对该一维数组进行冒泡法排序。

      3. 对排好序的一维数组重新整合成一个5位数，并输出。

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

int main() {
    int nums[10];
    int digits[5];

    for (int i = 0; i < 10; i++) {
        nums[i] = rand() % 90000 + 10000;
    }

    printf("随机生成的数字：\n");
    for (int i = 0; i < 10; i++) {
        printf("%d ", nums[i]);
    }
    printf("\n");

    for (int i = 0; i < 10; i++) {
        int num = nums[i];
        for (int j = 0; j < 5; j++) {
            digits[j] = num % 10;
            num /= 10;
        }

        // 冒泡排序
        for (int j = 0; j < 4; j++) {
            for (int k = 0; k < 4 - j; k++) {
                if (digits[k] > digits[k + 1]) {
                    int temp = digits[k];
                    digits[k] = digits[k + 1];
                    digits[k + 1] = temp;
                }
            }
        }

        int minNum = 0;
        for (int j = 0; j < 5; j++) {
            minNum = minNum * 10 + digits[j];
        }

        printf("第%d个数组成的最小数：%d\n", i + 1, minNum);
    }

    return 0;
}

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

int main()
{
    srand(time(0));  // 初始化随机数
  
    for (int i = 0; i < 10; i++) {
        int n = rand() %90000 + 10000; // 生成5位数
        printf("%d - ", n);
        
        int num[5];    // 定义一维数组存储5位数字
        for (int j = 0; j < 5; j++) {
            num[j] = n % 10;   // 对5位数求余得到各位数字
            n /= 10;        
        }
        
        // 冒泡排序各位数字   
        for (int j = 0; j < 5; j++) {
            for (int k = 0; k < 4; k++) { 
                if (num[k] > num[k+1]) {      
                    int temp = num[k];
                    num[k] = num[k + 1];
                    num[k + 1] = temp;
                }                    
            } 
        }        
        
        // 重新整合5位数
        n = num[0] * 10000 + num[1] * 1000 + num[2] * 100 + num[3] * 10 + num[4];  
        printf("%d\n", n);
    }    
}

不知道你这个问题是否已经解决, 如果还没有解决的话:

• 这个问题的回答你可以参考下: https://ask.csdn.net/questions/7652804
• 你也可以参考下这篇文章：给一个不多于5位的正整数，要求：1.输出它的位数 2.将这个整数的每位数字逆序输出 3.将这个整数的每位数字顺序输出
• 除此之外, 这篇博客: 5种常见排序算法的完整实现中的 编写一个程序，要求生成一组随机数，根据输入不同指令调用相应的排序算法实现对它的顺序排序 部分也许能够解决你的问题, 你可以仔细阅读以下内容或者直接跳转源博客中阅读:
  

  预处理指令：

  #include <stdio.h>
  #include <stdlib.h>
  #include <time.h>
  #define N 20
  

  1-插入排序：

  void insert_sort(int aa[])/*插入排序*/
  {
      int i,j,temp;
      for(i=1;i<N;i++)/*从第二个元素开始*/
      {
          temp=aa[i];
          for(j=i-1;j>=0&&aa[j]>temp;j--)/*找到插入位置*/
              aa[j+1]=aa[j];/*往后移位*/
          aa[j+1]=temp;/*插入*/
      }
  }
  

  2-选择排序：

  void select_sort(int aa[])/*选择排序*/
  {
      int i,j,temp1,temp2;
      for(i=0;i<N-1;i++)
      {
          temp1=i;
          for(j=i;j<N;++j)/*找出最小值下标并存入临时变量temp1*/
              if(aa[temp1]>aa[j])
                  temp1=j;
          if(temp1!=i)/*交换*/
          {
              temp2=aa[i];
              aa[i]=aa[temp1];
              aa[temp1]=temp2;
          }
      }
  }
  

  3-冒泡排序：

  void bubble_sort(int aa[])/*冒泡排序*/
  {
      int i,j,temp;
      for(i=1;i<=N-1;i++)/*冒泡次数N-1次*/
          for(j=0;j<N-i;j++)/*单次冒泡*/
              if(aa[j]>aa[j+1])
              {
                  temp=aa[j];
                  aa[j]=aa[j+1];
                  aa[j+1]=temp;
              }
  }
  

  4-快速排序：

  void quick_sort(int aa[],int low,int high)/*快速排序(冒泡排序的全新升级版)*/
  {
      int i=low,j=high;
      int key;/*定义一个存放关键数的变量*/
      if(low<high)
      {
          key=aa[low];
          while(low<high)/*单次快速排序*/
          {
              for(;low<high&&aa[high]>key;high--);/*从后往前搜索找到第一个小于key的数*/
              if(low<high)
              {
                  aa[low]=aa[high];
                  low++;
              }
  
              for(;low<high&&aa[low]<key;low++);/*从前往后搜索找到第一个大于key的数*/
              if(low<high)
              {
                  aa[high]=aa[low];
                  high--;
              }
          }
          aa[low]=key;
          quick_sort(aa,i,low-1);
          quick_sort(aa,low+1,j);
      }
  }
  

  5-希尔排序：

  void shell_sort(int aa[])/*希尔排序（插入排序的全新升级版）*/
  {
      int d,i,j,temp;
      for(d=N/2;d>0;d/=2)/*控制增量的改变*/
          for(i=d;i<N;i++)/*控制即将要插入的元素的改变*/
          {
              temp=aa[i];/*保存插入元素的值*/
              for(j=i-d;aa[j]>temp&&j>=0;j-=d)/*找出插入位置*/
                  aa[j+d]=aa[j];
              aa[j+d]=temp;/*插入*/
          }
  }
  

  调用排序函数进行排序：

  void select_to_call(int aa[],char g1)/*根据输入的字符调用相应的排序函数*/
  {
      if(g1=='i')
          insert_sort(aa);
      if(g1=='s')
          select_sort(aa);
      if(g1=='b')
          bubble_sort(aa);
      if(g1=='q')
          quick_sort(aa,0,N-1);
      if(g1=='l')
          shell_sort(aa);
  }
  

  下面是入口函数：

  void main()
  {
      int aa[N],i;
      char g,t,h;
      srand((unsigned)(time(NULL)));/*播种*/
      do
      {
          printf("Randomly generate %d integer:\n",N);
          for(i=0;i<N;i++)/*生成一组随机数*/
          {
              aa[i]=rand()%99+1;
              printf("%d ",aa[i]);
          }
  
          printf("\n");
          printf("Input a character from i,s,b,q,l:");
          scanf("%c",&g);
          while(!(g=='i'||g=='s'||g=='b'||g=='q'||g=='l'))
          {
              printf("Wrong input！Please input again:");
              while((h=getchar())!='\n'&&h!=EOF);/*清空输入流缓存区数据*/
              scanf("%c",&g);
          }
  
          printf("the sort results are as follows:\n");
          select_to_call(aa,g);
          for(i=0;i<N;i++)
              printf("%d ",aa[i]);
          printf("\n\n");
          printf("input \"Y\" to continue next sort,otherwise exit:");
          while((h=getchar())!='\n'&&h!=EOF);
          t=getchar();
          while((h=getchar())!='\n'&&h!=EOF);
      }while(t=='Y');
  }
  

• 您还可以看一下 李宁老师的跟宁哥学区块链开发视频课程（5）：在以太坊上发布自己的代币课程中的 课程概述小节, 巩固相关知识点
  
• 以下回答来自chatgpt:

  根据题目要求，我们需要随机生成10个5位的自然数，并将每个自然数的各位数字重新排列后得到最小的数。

  解决这个问题的思路可以如下：

  1. 首先，我们需要生成10个5位的自然数。可以使用随机数生成函数来生成这些数。由于题目要求不含0，所以随机数的范围可以设定为10000到99999之间。具体的步骤如下：
  2. 导入random模块。
  3. 创建一个空列表来存储随机生成的10个数。
  4. 使用for循环来生成10个随机数，并将它们添加到列表中。

  ```python import random

  def generate_numbers(): numbers = [] for _ in range(10): number = random.randint(10000, 99999) numbers.append(number) return numbers ```

  1. 接下来，我们需要将每个自然数的各位数字重新排列后得到最小的数。可以按照以下步骤来实现：
  2. 首先将每个自然数分解成单个数字，并将它们存储在一个一维数组中。
  3. 对数组进行排序，从小到大排序。
  4. 将排好序的数字重新组合在一起，就可以得到最小的数。

  python def rearrange_numbers(numbers): rearranged_numbers = [] for number in numbers: # 分解成单个数字 digits = [int(digit) for digit in str(number)] # 将数字排序 digits.sort() # 重新组合数字 rearranged_number = int("".join(map(str, digits))) rearranged_numbers.append(rearranged_number) return rearranged_numbers

  1. 最后，我们需要将随机生成的10个数和重新排列后的最小数进行打印输出。可以按照以下步骤来实现：
  2. 使用zip函数将原始数和重新排列后的数配对。
  3. 使用for循环遍历配对后的数，并打印输出。

  python def print_numbers(numbers, rearranged_numbers): for number, rearranged_number in zip(numbers, rearranged_numbers): print(f"原始数:{number}，重新排列后的最小数:{rearranged_number}")

  完整的代码如下所示：

  import random
  
  def generate_numbers():
      numbers = []
      for _ in range(10):
          number = random.randint(10000, 99999)
          numbers.append(number)
      return numbers
  
  def rearrange_numbers(numbers):
      rearranged_numbers = []
      for number in numbers:
          # 分解成单个数字
          digits = [int(digit) for digit in str(number)]
          # 将数字排序
          digits.sort()
          # 重新组合数字
          rearranged_number = int("".join(map(str, digits)))
          rearranged_numbers.append(rearranged_number)
      return rearranged_numbers
  
  def print_numbers(numbers, rearranged_numbers):
      for number, rearranged_number in zip(numbers, rearranged_numbers):
          print(f"原始数:{number}，重新排列后的最小数:{rearranged_number}")
  
  # 生成10个5位的自然数
  numbers = generate_numbers()
  
  # 重新排列数
  rearranged_numbers = rearrange_numbers(numbers)
  
  # 打印输出
  print_numbers(numbers, rearranged_numbers)
  

  运行这段代码，即可得到随机生成的10个5位的自然数和它们重新排列后的最小数的输出结果。

如果你已经解决了该问题, 非常希望你能够分享一下解决方案, 写成博客, 将相关链接放在评论区, 以帮助更多的人 ^-^