5.3.1 6174问题

假设你有一个各位数字互不相同的四位数,把所有数字从大到小排序后得到a,从小到大排序后得到b,然后用a-b替换原来这个数,并且继续操作。
例如,从1234出发,依次可以得到4321-1234=3087、8730-378=8352、8532-2358=6174、7641-1467=6174。有趣的是,最后回到了自己。
要求:
输入一个n位数,输出操纵序列,直到出现循环(即新得到的数曾经得到过)。输入保证在循环之前最多只会产生1000个整数。
样例输入:1234
样例输出:1234 -> 3087 -> 8352 -> 6174 -> 6174

[分析]
需要解决的问题有:
[1] 如何得到下一个数? 
首先需要把各个数字排序,因此需要把各个数字提取出来。然后选择一种排序算法,先将提取的数字所组成的数组按照从小到大排序,然后再将其逆序,然后就可以得到下一个数了。
[2] 如何检查这个数是否已经出现过了? 
这个可以通过数组来实现。将每次得到的数字保存到一个数组中,然后遍历这个数组就可以判断这个数字是否已经得到过。

注意输入如果不是四位数 , 或者4个数字完全相同,则忽略否则会WA

 1 #include <stdio.h>
 2 #include <math.h>
 3 #include <string.h>
 4 #include <stdlib.h>
 5 #include <string.h>
 6 #include <iostream>
 7 #include <algorithm>
 8 using namespace std;
 9 int n, i, j, k;
10 int num1[5], num2[5], tar[5];
11 bool cmp1(int x, int y){
12     return x > y;
13 }
14 bool init(){
15     if(n > 9999 || n < 1000)    return false;
16     num1[1] = n / 1000;
17     num1[2] = n / 100;
18     num1[2] %= 10;
19     num1[3] = n / 10;
20     num1[3] %= 10;
21     num1[4] = n - 1000 * num1[1] - 100 * num1[2] - 10 * num1[3];
22     if(num1[1] == num1[2] && num1[2] == num1[3]23        && num1[3] == num1[4])    return false;
24     return true;
25 }
26 void deal(){
27     num1[1] = n / 1000;
28     num1[2] = n / 100;
29     num1[2] %= 10;
30     num1[3] = n / 10;
31     num1[3] %= 10;
32     num1[4] = n - 1000 * num1[1] - 100 * num1[2] - 10 * num1[3];
33     num2[1] = num1[1];
34     num2[2] = num1[2];
35     num2[3] = num1[3];
36     num2[4] = num1[4];
37     sort(num1+1, num1+1+4);
38     sort(num2+1, num2+1+4,cmp1);
39     if(n < 1000 && n >= 100){
40         num2[4] = num2[3];
41         num2[3] = num2[2];
42         num2[2] = num2[1];
43         num2[1] = 0;
44         return ;
45     }
46     else if( n < 100 && n >= 10){
47         num2[4] = num2[2];
48         num2[3] = num2[1];
49         num2[2] = 0;
50         num2[1] = 0;
51         return ;
52     }
53     else if( n < 10){
54         num2[4] = num2[1];
55         num2[1] = num2[2] = num2[3] = 0;
56         return ;
57     }
58 }
59 int main(){
60     int a, b, c, d;
61     int a1, b1, c1, d1;
62     int flag;
63     while(EOF != scanf("%d",&n)){
64         if(n == -1) break;
65         printf("N=%d:\n",n);
66         if(!init()){
67             printf("No!!\n");
68             continue;
69         }
70         flag = 0;
71         deal();
72         while(1){
73             ++flag;
74             num1[0] = num1[4] + num1[3] * 10 + num1[2] * 100 + num1[1] * 1000;
75             num2[0] = num2[4] + num2[3] * 10 + num2[2] * 100 + num2[1] * 1000;
76             n = num2[0] - num1[0];
77             if(n == 0 || n == 6174){
78                 printf("%d-%d=",num2[0],num1[0]);
79                 printf("%d\n",n);
80                 printf("Ok!! %d times\n",flag);
81                 break;
82             }
83             if(flag > 1000){ printf("No!!\n"); break;}
84             printf("%d-%d=",num2[0],num1[0]);
85             printf("%d\n",n);
86             deal();
87         }
88     }
89     return 0;
90 }

5.3.1 6174问题

时间: 2024-10-12 07:00:04

5.3.1 6174问题的相关文章

6174

6174问题 时间限制: 1000 ms  |  内存限制: 65535 KB 难度: 2 描述 假 设你有一个各位数字互不相同的四位数,把所有的数字从大到小排序后得到a,从小到大后得到b,然后用a-b替换原来这个数,并且继续操作.例如,从 1234出发,依次可以得到4321-1234=3087.8730-378=8352.8532-2358=6174,又回到了它自己!现在要你写一个 程序来判断一个四位数经过多少次这样的操作能出现循环,并且求出操作的次数 比如输入1234执行顺序是1234->3

6174问题

描述 假设你有一个各位数字互不相同的四位数,把所有的数字从大到小排序后得到a,从小到大后得到b,然后用a-b替换原来这个数,并且继续操作.例如,从1234出发,依次可以得到4321-1234=3087.8730-378=8352.8532-2358=6174,又回到了它自己!现在要你写一个程序来判断一个四位数经过多少次这样的操作能出现循环,并且求出操作的次数 比如输入1234执行顺序是1234->3087->8352->6174->6174,输出是4 输入 第一行输入n,代表有n组

【每天一道算法题】整数循环节之和——数字黑洞6174

华为优招第三题,前两道题都比较简单,在这道题上卡住了.说实话不怪我,华为这道题描述有问题哦.其实不应该是较大的数,和较小的数.是最大的数和最小的数.(我在随机举例可能的数字组合上浪费了很多时间!!怒!) 整数之循环节点求和 描述: 任意一个不是用完全相同数字组成的四位数,如果对它们的每位数字重新排序,组成一个较大的数和一个较小的数,然后用较大数减去较小数,差不够四位数时在前面补零,类推下去,最后将变成一个固定的数:6174. 例如:4321-1234=3087 8730-378=8352 853

NYOJ 57 6174问题

啊哈!初次知道6174,还是在高中时,一本科普书上讲的.作为回忆,就把这道题AC了. 水题,不过去掉下面的注释,可以很直观的看到过程. 最后!!!为什么我用memset函数总是忘写#include<cstring>头文件!!! 时间限制:1000 ms  |  内存限制:65535 KB 难度:2 描述 假设你有一个各位数字互不相同的四位数,把所有的数字从大到小排序后得到a,从小到大后得到b,然后用a-b替换原来这个数,并且继续操作.例如,从1234出发,依次可以得到4321-1234=308

57.6174问题

描述 假设你有一个各位数字互不相同的四位数,把所有的数字从大到小排序后得到a,从小到大后得到b,然后用a-b替换原来这个 数,并且继续操作.例如,从1234出发,依次可以得到4321-1234=3087.8730-378=8352.8532-2358=6174,又回 到了它自己!现在要你写一个程序来判断一个四位数经过多少次这样的操作能出现循环,并且求出操作的次数 比如输入1234执行顺序是1234->3087->8352->6174->6174,输出是4 输入 第一行输入n,代表有

数字黑洞 - 6174

1 package com.niit.niitdigitalblackhole6174.main; 2 3 /** 4 * 验证数学黑洞 用户输入一个四位数,输入变换到6174的过程 5 * 例如:1234 6 * 4321 - 1234 = 3087 7 * 8730 - 0378 = 8352 8 * 8532 - 2358 = 6174 9 * @author Fatoland 10 */ 11 public class DigitalBlackHole6174 { 12 13 14 pu

南阳 6174

6174问题 时间限制:1000 ms  |  内存限制:65535 KB 难度:2 描述 假设你有一个各位数字互不相同的四位数,把所有的数字从大到小排序后得到a,从小到大后得到b,然后用a-b替换原来这个数,并且继续操作.例如,从1234出发,依次可以得到4321-1234=3087.8730-378=8352.8532-2358=6174,又回到了它自己!现在要你写一个程序来判断一个四位数经过多少次这样的操作能出现循环,并且求出操作的次数 比如输入1234执行顺序是1234->3087->

NYOJ_51 6174问题

题目地址 分析: 以后排序直接用库函数提供的sort很方便. 核心问题在于需要把一个数拆开排序. 其实在判断的时候直接判断6174即可,不需要判断是否和前一个数字相等. 心得: 水题需要锻炼自己的速度. 代码实现: #include<iostream> #include<algorithm> using namespace std; void ReverseMinus(int &a0) { int temp1,temp2; int *t = new int [4]; t[0

Algorithm --&gt; 6174问题

6174问题 假设一个各位数字不相同的四位数,把所有数字从大到小排序后得到a, 从小到大排序后得到b,然后用a-b替换原来这个数,继续操作.例如,从1234出发,依次有4321-1234=3078,8730-378=8352,8532-2358=6174,7641-1467=6174,回到了自己. 输入一个n位数,输出操作序列知道出现循环. 样例输入:1234 样例输出:1234 -> 3078 -> 8352 -> 6174 -> 6174 程序: #include<ios