被难麻了，来个高手

a905448839

7-49 Have Fun with Numbers

Notice that the number 123456789 is a 9-digit number consisting exactly the numbers from 1 to 9, with no duplication. Double it we will obtain 246913578, which happens to be another 9-digit number consisting exactly the numbers from 1 to 9, only in a different permutation. Check to see the result if we double it again!

Now you are suppose to check if there are more numbers with this property. That is, double a given number with k digits, you are to tell if the resulting number consists of only a permutation of the digits in the original number.

Input Specification:
Each input contains one test case. Each case contains one positive integer with no more than 20 digits.

Output Specification:
For each test case, first print in a line "Yes" if doubling the input number gives a number that consists of only a permutation of the digits in the original number, or "No" if not. Then in the next line, print the doubled number.

Sample Input:
1234567899
Sample Output:
Yes
2469135798

翻译
注意，123456789是一个9位数字，完全由1到9之间的数字组成，没有重复。把它翻倍，我们会得到246913578，它恰好是另一个9位数，包含了从1到9的数字，只是排列不同。如果我们再次加倍，看看结果如何!现在你要检查是否有更多的数字具有这个性质。也就是说，用k位数字将一个给定的数字加倍，你要判断得出的数字是否只由原数字中数字的一个排列组成。

输入说明
每个输入包含一个测试用例。每个例子包含一个不超过20位的正整数。

输出说明
对于每个测试用例，如果将输入数字加倍，得到的数字只包含原始数字的一个排列，则首先打印一行“Yes”;如果不包含，则打印“No”。然后在下一行中，打印加倍的数字。

Sample Input:
1234567899

Sample Output:
Yes
2469135798

我的代码：

1. #include<stdio.h>
   
2. void sum(long long n,int *p);
   
3. void sum(long long n,int *p)
   
4. {
   
5.         int i = 20;
   
6.         while(n)
   
7.         {
   
8.                 p[i] = n%10;
   
9.                 n /= 10;
   
10.                 i--;
    
11.         }
    
12.        
    
13. }
    
14. 
    
15. void PD(int *pn,int *pt);
    
16. void PD(int *pn,int *pt)
    
17. {
    
18.         int n,m;
    
19.        
    
20.         for(n = 0;n < 21; n++)
    
21.         {
    
22.                 for(m = 0;m < 21; m++)
    
23.                 {
    
24.                         if(pt[n] == pn[m])
    
25.                         {
    
26.                                 pt[n] = 100;
    
27.                                 pn[m] = 100;
    
28.                                
    
29.                                 continue;
    
30.                         }
    
31.                 }
    
32.         }
    
33. 
    
34. }
    
35. 
    
36. void Print(int *p);
    
37. void Print(int *p)
    
38. {
    
39.         int t = 1;
    
40.         int n;
    
41.        
    
42.         for(n = 0;n < 21;n++)
    
43.         {
    
44.                 if(t && p[n] == 0)
    
45.                 continue;
    
46.                 printf("%d",p[n]);
    
47.                 t = 0;
    
48.                
    
49.         }
    
50.         printf("\n");
    
51. }
    
52. 
    
53. 
    
54. 
    
55. 
    
56. int main()
    
57. {
    
58.         unsigned long long n,two_n;
    
59.         int pn[21] = {0};
    
60.         int pt[21] = {0};
    
61.         int i;
    
62. 
    
63. 
    
64.         scanf("%lld",&n);
    
65.         two_n = 2*n;
    
66.        
    
67.         sum(n,pn);
    
68.         sum(two_n,pt);
    
69.        
    
70.        
    
71.         int demo_pt[21];
    
72.         for(i = 0;i < 21;i++)
    
73.         {
    
74.                 demo_pt[i] = pt[i];
    
75.         }
    
76.        
    
77.         PD(pn,demo_pt);
    
78.        
    
79. 
    
80. //        Print(pn);
    
81. //        Print(pt);
    
82. //        Print(demo_pt);
    
83.        
    
84.         for(i = 0;i < 21; i++)
    
85.         {
    
86.                 if(demo_pt[i] != 100 && pn[i] != 100)
    
87.                 {
    
88.                         printf("No\n");
    
89.                         Print(pt);
    
90.                         return 0;
    
91.                 }
    
92.         }
    
93.        
    
94.         printf("Yes\n");
    
95.         Print(pt);
    
96. 
    
97.         return 0;
    
98. }
    

复制代码

提示错误：

歌者文明清理员

对于第一个测试用例，因为 long 类型在不同机器上的位数可能不同，导致无法容纳这么大的数值，因此需要使用 unsigned long long 类型进行存储和计算。
对于第三个测试用例，我们只需要判断输入数字是否包含了1~9所有数字即可，而不需要考虑是否只包含原始数字的一个排列。
下面是我修改后的代码，希望能够通过您提供的所有测试用例：

1. #include <stdio.h>
   
2. #include <string.h>
   
3. #include <stdbool.h>
   
4. #include <stdint.h>
   
5. 
   
6. void to_array(char str[], int num[]) {
   
7.     int len = strlen(str);
   
8.     for (int i = 0; i < len; i++) {
   
9.         if (str[i] == '-') {
   
10.             num[0] = -1; // 设置符号位
    
11.         } else {
    
12.             num[len - i] = str[i] - '0'; // 从低位到高位存储，方便后面计算
    
13.         }
    
14.     }
    
15. }
    
16. 
    
17. void to_num(int num[], char str[]) {
    
18.     int i;
    
19.     if (num[0] == -1) {
    
20.         str[0] = '-';
    
21.         i = 1;
    
22.     } else {
    
23.         for (i = 20; i >= 0 && !num[i]; i--); // 找到最高位非零的位置
    
24.     }
    
25.     if (i < 0) {
    
26.         str[0] = '0';
    
27.         str[1] = '\0';
    
28.         return;
    
29.     }
    
30.     for (int j = i; j >= 0; j--) {
    
31.         str[i - j + (num[0] == -1)] = num[j] + '0'; // 从高位到低位输出
    
32.     }
    
33.     str[i + 1 + (num[0] == -1)] = '\0';
    
34. }
    
35. 
    
36. bool is_permutation(int a[], int b[]) {
    
37.     int count[10] = {0};
    
38.     bool same_number = false;
    
39.     for (int i = 0; i < 21; i++) {
    
40.         count[a[i]]++;
    
41.         if (b[i] != a[i]) {
    
42.             same_number = false;
    
43.         }
    
44.         count[b[i]]--;
    
45.     }
    
46.     for (int i = 1; i <= 9; i++) {
    
47.         if (count[i] != 0) {
    
48.             return false;
    
49.         }
    
50.     }
    
51.     return !same_number;
    
52. }
    
53. 
    
54. int main() {
    
55.     char str[21];
    
56.     int n[21] = {0}, two_n[21] = {0};
    
57. 
    
58.     scanf("%s", str);
    
59.     to_array(str, n);
    
60. 
    
61.     // 判断输入是否为0
    
62.     if (n[0] == 0) {
    
63.         printf("Yes\n0\n");
    
64.         return 0;
    
65.     }
    
66. 
    
67.     // 计算2n
    
68.     unsigned long long carry = 0;
    
69.     for (int i = 1; i <= 20; i++) {
    
70.         two_n[i] = (n[i] * 2 + carry) % 10;
    
71.         carry = (n[i] * 2 + carry) / 10;
    
72.     }
    
73.     two_n[0] = carry;
    
74. 
    
75.     // 判断符号位是否改变
    
76.     if (n[0] == -1 && two_n[0] != -1 // 输入为负数，翻倍后变成正数
    
77.         || n[0] != -1 && two_n[0] == -1) { // 输入为正数，翻倍后变成负数
    
78.         printf("No\n");
    
79.         to_num(two_n, str);
    
80.         printf("%s\n", str);
    
81.         return 0;
    
82.     }
    
83. 
    
84.     // 判断是否只包含原始数字的一个排列
    
85.     if (is_permutation(n, two_n)) {
    
86.         printf("Yes\n");
    
87.     } else {
    
88.         printf("No\n");
    
89.     }
    
90.     to_num(two_n, str);
    
91.     printf("%s\n", str);
    
92. 
    
93.     return 0;
    
94. }

复制代码

isdkz

您的代码基本正确，但有一些细节上的问题，例如程序中的函数命名不够清晰。下面是您的代码的一个优化版本，对函数名进行了改进，并进行了一些细节调整。

1. #include <stdio.h>
   
2. 
   
3. void fill_digit_array(long long n, int *p);
   
4. void remove_common_digits(int *pn, int *pt);
   
5. void print_digits(int *p);
   
6. 
   
7. void fill_digit_array(long long n, int *p)
   
8. {
   
9.     int i = 20;
   
10.     while (n)
    
11.     {
    
12.         p[i] = n % 10;
    
13.         n /= 10;
    
14.         i--;
    
15.     }
    
16. }
    
17. 
    
18. void remove_common_digits(int *pn, int *pt)
    
19. {
    
20.     int n, m;
    
21. 
    
22.     for (n = 0; n < 21; n++)
    
23.     {
    
24.         for (m = 0; m < 21; m++)
    
25.         {
    
26.             if (pt[n] == pn[m])
    
27.             {
    
28.                 pt[n] = 100;
    
29.                 pn[m] = 100;
    
30.                 continue;
    
31.             }
    
32.         }
    
33.     }
    
34. }
    
35. 
    
36. void print_digits(int *p)
    
37. {
    
38.     int t = 1;
    
39.     int n;
    
40. 
    
41.     for (n = 0; n < 21; n++)
    
42.     {
    
43.         if (t && p[n] == 0)
    
44.             continue;
    
45.         printf("%d", p[n]);
    
46.         t = 0;
    
47.     }
    
48.     printf("\n");
    
49. }
    
50. 
    
51. int main()
    
52. {
    
53.     unsigned long long n, two_n;
    
54.     int pn[21] = {0};
    
55.     int pt[21] = {0};
    
56.     int i;
    
57. 
    
58.     scanf("%lld", &n);
    
59.     two_n = 2 * n;
    
60. 
    
61.     fill_digit_array(n, pn);
    
62.     fill_digit_array(two_n, pt);
    
63. 
    
64.     int demo_pt[21];
    
65.     for (i = 0; i < 21; i++)
    
66.     {
    
67.         demo_pt[i] = pt[i];
    
68.     }
    
69. 
    
70.     remove_common_digits(pn, demo_pt);
    
71. 
    
72.     for (i = 0; i < 21; i++)
    
73.     {
    
74.         if (demo_pt[i] != 100 && pn[i] != 100)
    
75.         {
    
76.             printf("No\n");
    
77.             print_digits(pt);
    
78.             return 0;
    
79.         }
    
80.     }
    
81. 
    
82.     printf("Yes\n");
    
83.     print_digits(pt);
    
84. 
    
85.     return 0;
    
86. }
    

复制代码

此代码首先计算输入数值的两倍，然后将它们转换为整数数组。之后，从这两个数组中移除所有相同的数字。如果所有数字都被移除，说明两个数值具有相同的数字组成，只是排列不同。根据这一条件，输出“Yes”或“No”，并打印出加倍后的数值。

a905448839

isdkz 发表于 2023-5-4 22:42
您的代码基本正确，但有一些细节上的问题，例如程序中的函数命名不够清晰。下面是您的代码的一个优化版本， ...

输入9999999999999999999不对

fc1735

1. #include <stdio.h>
   
2. #include <stdlib.h>
   
3. #include <string.h>
   
4. 
   
5. int cmp(const void *a, const void *b) { return *(char*)a - *(char*)b; }
   
6. #define MAX_SIZE 20
   
7. int main() {
   
8.   char orig[MAX_SIZE + 1], doubled[MAX_SIZE + 2]; scanf("%s", orig);
   
9.   char buff[MAX_SIZE + 2] = {'0',};
   
10.   for (int i = strlen(orig); i > 0; i--) {
    
11.     int n = (orig[i - 1] - '0') * 2 + buff[i];
    
12.     buff[i - 1] += n / 10;
    
13.     buff[i] = n % 10 + '0';
    
14.   }
    
15.   char *res = buff[0] > '0' ? buff : buff + 1;
    
16.   strcpy(doubled, res);
    
17.   qsort(orig, strlen(orig), sizeof(char), cmp);
    
18.   qsort(res, strlen(res), sizeof(char), cmp);
    
19.   puts(strcmp(orig, res) == 0 ? "Yes" : "No");
    
20.   puts(doubled);
    
21. }

复制代码

歌者文明清理员

问题解决了饿吗

a905448839

歌者文明清理员 发表于 2023-5-5 16:47
问题解决了饿吗

还没呢，你可以看一下我的新帖

a905448839

歌者文明清理员 发表于 2023-5-5 16:47
问题解决了饿吗

我用字符数组解决这道题 但是又出现了一点小状况 已发新贴

https://fishc.com.cn/forum.php?mod=viewthread&tid=227896&extra=&mobile=2