[推荐] 求100万一下自守数 [问题点数:20分]

Bbs1
本版专家分:0
结帖率 0%
Bbs2
本版专家分:390
Bbs2
本版专家分:124
Bbs2
本版专家分:215
Bbs6
本版专家分:8659
Blank
蓝花 2017年7月 Java大版内专家分月排行榜第三
Bbs1
本版专家分:5
Bbs4
本版专家分:1469
Bbs6
本版专家分:8659
Blank
蓝花 2017年7月 Java大版内专家分月排行榜第三
Bbs6
本版专家分:8659
Blank
蓝花 2017年7月 Java大版内专家分月排行榜第三
Bbs6
本版专家分:8659
Blank
蓝花 2017年7月 Java大版内专家分月排行榜第三
Bbs1
本版专家分:0
Bbs1
本版专家分:0
Bbs1
本版专家分:0
Bbs1
本版专家分:0
Bbs1
本版专家分:0
Bbs1
本版专家分:0
Bbs1
本版专家分:0
Bbs7
本版专家分:10173
Blank
红花 2017年12月 Java大版内专家分月排行榜第一
Blank
蓝花 2017年10月 Java大版内专家分月排行榜第三
Bbs1
本版专家分:0
Bbs1
本版专家分:0
Bbs1
本版专家分:0
Bbs1
本版专家分:0
Bbs1
本版专家分:0
Bbs1
本版专家分:0
Bbs1
本版专家分:50
Bbs3
本版专家分:540
Bbs1
本版专家分:0
Bbs5
本版专家分:3395
Bbs1
本版专家分:0
Bbs1
本版专家分:0
Blank
红花 2018年8月 Delphi大版内专家分月排行榜第一
2018年7月 Delphi大版内专家分月排行榜第一
2018年4月 Delphi大版内专家分月排行榜第一
2018年3月 Delphi大版内专家分月排行榜第一
Blank
黄花 2016年11月 Delphi大版内专家分月排行榜第二
Blank
蓝花 2011年10月 其他开发语言大版内专家分月排行榜第三
2010年8月 其他开发语言大版内专家分月排行榜第三
2007年5月 其他开发语言大版内专家分月排行榜第三
Bbs1
本版专家分:0
Bbs1
本版专家分:0
Bbs5
本版专家分:3395
Bbs1
本版专家分:0
Blank
红花 2018年8月 Delphi大版内专家分月排行榜第一
2018年7月 Delphi大版内专家分月排行榜第一
2018年4月 Delphi大版内专家分月排行榜第一
2018年3月 Delphi大版内专家分月排行榜第一
Blank
黄花 2016年11月 Delphi大版内专家分月排行榜第二
Blank
蓝花 2011年10月 其他开发语言大版内专家分月排行榜第三
2010年8月 其他开发语言大版内专家分月排行榜第三
2007年5月 其他开发语言大版内专家分月排行榜第三
Bbs1
本版专家分:0
Blank
红花 2018年8月 Delphi大版内专家分月排行榜第一
2018年7月 Delphi大版内专家分月排行榜第一
2018年4月 Delphi大版内专家分月排行榜第一
2018年3月 Delphi大版内专家分月排行榜第一
Blank
黄花 2016年11月 Delphi大版内专家分月排行榜第二
Blank
蓝花 2011年10月 其他开发语言大版内专家分月排行榜第三
2010年8月 其他开发语言大版内专家分月排行榜第三
2007年5月 其他开发语言大版内专家分月排行榜第三
Bbs1
本版专家分:0
Bbs1
本版专家分:0
Bbs2
本版专家分:140
Bbs1
本版专家分:0
Bbs1
本版专家分:0
Bbs1
本版专家分:0
Bbs1
本版专家分:0
Bbs1
本版专家分:0
Bbs1
本版专家分:0
Bbs1
本版专家分:0
Bbs1
本版专家分:0
Bbs2
本版专家分:253
其他相关推荐
趣味整数-自守数-java
问题描述: 如果某个数的平方的末尾几位数等于这个数,那么就称这个数为自守数。显然,5和6是自守数  5*5=25  6*6=36   25*25=125 求10000以内的自守数 方法1: public class Main { public static void getZsNum(int maxNum){ for(int i=5 ; i<=maxNum ; i++){ i
自守数 寻找出2千万以内的所有自守数。注意,2千万的平方已经超出了整数表达的最大范围,所以该程序使用了一个巧妙的方案。
/* 自守数 如果一个自然数的平方数的尾部仍然为该自然数本身,则称其为自守数。 例如: 5 x 5 = 25 76 x 76 = 5776 625 x 625 = 390625 下面代码的目的是寻找出2千万以内的所有自守数。 注意,2千万的平方已经超出了整数表达的最大范围,所以该程序使用了一个巧妙的方案。 如果我们仔细观察乘法的计算过程,就会发现实际上对乘积的尾数有贡献的环节,从而
一千万以内的自守
求一千万以下的自守数 如 5*5=25 25*25=625 如果有n由k位数构成 那么n的平方的末尾k位数必须和n相等 并且变量只能用证书
Java 自守
import java.util.Scanner; public class zishoushu { public static void main(String[] args) { Scanner sc=new Scanner(System.in); long x=sc.nextInt(); if(zishou(x)==1){ System.out.println("您输入
算法_趣味整数_Question3_自守数(java实现)
这篇文章讲述的是算法趣味整数部分的自守数问题的java实现,参考的书籍为清华大学出版社出版,贾蓓等编著的《c语言趣味编程1000例》,如有错误或者不当之处,还望各位大神批评指正。 问题描述 自守数是指一个数的平方的尾数等于该数自身的自然数。例如:5^2=25 , 25^2=625 , 76^2==5776 , 9376^2=87909376 求出100000以内的自守数。 算法分析 关键问...
华为OJ——自守
题目描述 自守数是指一个数的平方的尾数等于该数自身的自然数。例如:25^2 = 625,76^2 = 5776,9376^2 = 87909376。请求出n以内的自守数的个数 输入描述: int型整数 输出描述: n以内自守数的数量。 输入例子: 2000 输出例子: 8 import java.util.*; public class Main{
Java\Scala\Python三种语言求解经典编程实例(四)—— 求10000以内的自守
Java\Scala\Python三种语言求解经典编程实例(四)—— 求10000以内的自守
自守数20000以内
#include &lt;stdio.h&gt;void main(){//巧妙的绕过了 计算平方的过程,因为太大的数字平方超出了范围。long mul,number,k,a,b;printf("将输出200000以内的自守数:\n");for(number=0; number&lt;200000; number++)    {    for(mul=number,k=1; (mul/=10)&g...
c39 自守
/* 【程序39】 自守数 * 题目:求出1000以内的自守数。 * 程序分析:自守数:如果某一个数的平方的末几位数(原数是几位就取几位)等于它本身,则称之为自守数。如:5^2=25, 6^2=36。解题方法:(数的平方)对(10的[数位次方])取余==原数 */ #include int ten_to_n(int i) // 10的n次方, n为i的位数 { int j = 1;
求20000以内的自守
25的平方为625  76的平方为5776 9376的平方为87908376 很明显我们不能在算出结果后截取相应的位数 同样的 我们也不需要每个乘数的积 只需要相应位数即可
C语言---“自守数”问题
#include void main() { //巧妙的绕过了 计算平方的过程,因为太大的数字平方超出了范围。 long mul,number,k,a,b; printf("将输出100000以内的自守数:\n"); for(number=0; number0; k
自守数算法----C语言实现
#include //自守数算法 //ep : 25 ^ 2 = 625 76 ^ 2 = 5776 9376 ^ 2 = 87909376 /*ep : * 376 被乘数 * *376 乘数 * ------ --------- * 2256 第一个部分积=被乘数*乘数的倒数第一位 * 2632 第二个部分积=被乘数*
自守数的问题
【题目描述】 如果某个数的平方的末尾几位数等于这个数本身,那么就称这个数为自守数。例如,5是自守数,5*5=25。编程找出10000以内的所有自守数。 【输入描述】 无输入。 【输出描述】 每行输出一个自守数。 【输入样例】【输出样例】 1 5 6public class Zishoushu {/** * @param args */ public static void ma
自守10000以内(C)
#include &lt;stdio.h&gt;int J(long num )        //统计数字位数{   int i=0;    while (num&gt;0)    {        num=num/10;        i++;    }    return i;}long shi(int n)        //10的次方{   long cheng=1.0;    whil...
利用MATLAB求自守数,方法一:循环
什么是自守数? 一个数的平方的末尾即为数字等于它本身,如55=25,66=36… tic f=zeros(0,100); index=0; for p=5:100000 w=1+floor(log10(p)); %求解这个数的位数 %为什么用floor不用ceil,请自己运行ceil(log10(10))便知 m=mod(p^2,10^w); if p==m; ...
关于 自守数 的C语言算法
自守数 是指一个数的平方的尾数等于该数自身的自然数。 #include #include main() {     long int m,k,j,i,n,r,count,u,b,c,d,e;     for(i=0; i     {         n=i;         m=i;         for(count=1; n>=0; count++)    
【华为oj】自守
问题描述:自守数是指一个数的平方的尾数等于该数自身的自然数。例如:25的平方 = 625,76的平方 = 5776,9376的平方 = 87909376。请求出n以内的自守数的个数 接口说明  /*  功能: 求出n以内的自守数的个数  输入参数:  intn  返回值:     n以内自守数的数量。  */  public static int CalcAutomorphi
C语言求1000以内守形数
若正整数n是它的平方数的尾部,则称n为守形数,又称同构数。例如:6是其平方数36的尾部,76是其平方数5776的尾部,6和76都是守形数。
自守数是指一个数的平方的尾数等于该数自身的自然数。 例如25^2 = 625 76^2 = 5776 9376^2 = 87909376 请求出200000以内的自守
看到题目的第一反应就是从0-200000遍历求平方取余数,但是这便存在数据溢出的问题,所以我们不得不放弃简单暴力的方式。 //自守数 #include &lt;stdio.h&gt; int main() { long mul, number, k, ll, kk; printf("It exists following automorphic numbers...
华为OJ(自守数)
描述 自守数是指一个数的平方的尾数等于该数自身的自然数。例如:252 = 625,762 = 5776,93762 = 87909376。请求出n以内的自守数的个数 接口说明 /* 功能: 求出n以内的自守数的个数 输入参数: int n 返回值:     n以内自守数的数量。 */  public static int CalcAutomorphicNumbers( int n) {   
【C语言训练】自守数问题
题目描述 自守数是指一个数的平方的尾数等于该数自身的自然数。  例如:  25^2=625  76^2=5776  9376^2=87909376  请求出200000以内的自守数? 输入 输出 200000以内的自守数(包括0, 数之间用两个空格分开,包括末尾空格)  0  1  5  6  25  76  376  625  ????  ????  ..
自守数定义:一个自然数的平方的尾数等于该数本身。例如:25=625,76=5776,9376=87909376,则25、76、9376均是自守数。试建立一个类Self,求出指定范围内的自守
自守数定义:一个自然数的平方的尾数等于该数本身。例如:25=625,76=5776,9376=87909376,则25、76、9376均是自守数。试建立一个类Self,求出指定范围内的自守数,具体要求如下: (1)私有数据成员 int a[20]:存放求出的自守数。 int m , n , p:m、n存放自守数的取值范围,p存放求出的自守数的个数。 (2)公有成员函数 构造函数Self(
100亿个数取出最大的10000个
题目:100亿个整数,求最大的1万个数,并说出算法的时间复杂度  算法:如果把100亿个数全部读入内存,需要100 0000 0000 * 4B 大约40G的内存,这显然是不现实的。  我们可以在内存中维护一个大小为10000的最小堆,每次从文件读一个数,与最小堆的堆顶元素比较,若比堆顶元素大,  则替换掉堆顶元素,然后调整堆。最后剩下的堆内元素即为最大的1万个数,算法复杂度为O(NlogN)  
面试题-100万个数据前100大的数据
先取出前100个数,维护一个100个数的最小堆,遍历一遍剩余的元素,在此过程中维护堆就可以了。具体步骤如下: step1:取前m个元素(例如m=100),建立一个小顶堆。保持一个小顶堆得性质的步骤,运行时间为O(lgm);建立一个小顶堆运行时间为m*O(lgm)=O(m lgm); step2:顺序读取后续元素,直到结束。每次读取一个元素,如果该元素比堆顶元素小,直接丢弃 如果大于堆顶元素,则用该元
C++编程百例 27.自守
/*自守自守数是指一个数的平方的尾数等于该数自身的自然数。 例如:252=625 762=5776 93762=87909376*/ #include int main() {  for(int n=0;n  {   int m=0;   int n2=n;   //for(;;)   while(n2)   {    int k=n2%10;    m+=k*n;
C语言实验题——自守
描述 求出不超过整数N(N6)的最大的自守数,自守数是指一个数的平方的尾数等于该数自身的自然数,如762=5776. 输入 输入包括多行,每行是一个整数N, 输出 每行输出不超过N的最大的自守数。 样例输入 26 样例输出 25 #include #include using namespace std; int
判断是否是自守
bool IsAutoMorphicNum(unsigned int num) { unsigned long long int pow = (unsigned long long int )num*num; while(num) { if(num%10 != pow%10) return false; num /= 10, pow/= 10; } ret
C语言自守
以下是c语言282例子的代码#include int main(void) { long i,j,k1,k2,k3,a[10]={0},num,m,n,sum; printf("请输入一个范围:\n"); scanf("%ld",&num); for(j=0;j
如何从100万个数中找出最大的前100个数
摘自 http://blog.sina.com.cn/s/blog_682686610100xlrr.html  1.  算法如下:根据快速排序划分的思想  (1) 递归对所有数据分成[a,b)b(b,d]两个区间,(b,d]区间内的数都是大于[a,b)区间内的数  (2) 对(b,d]重复(1)操作,直到最右边的区间个数小于100个。注意[a,b)区间不用划分  (3) 返回上
1035: 自守数问题
题目Description 自守数是指一个数的平方的尾数等于该数自身的自然数。 例如: 25^2=625 76^2=5776 9376^2=87909376 请求出200000以内的自守数? InputOutput 200000以内的自守数(包括0, 数之间用两个空格分开) Sample InputSample Output 0 1 5 6 25 76 376
自守数判断
#include #include int getNum(long num) { int count = 0; while(num) { num/=10; count++; } return count; } int mypow(int n) { int p=1; int i; for(i= 0;
判断自守
题目描述: 如果某个数的平方的末尾几位数等于这个数,那么就称这个数为自守数。 显然,5和6是一位自守数(5x5=25 6x6=36),25x25=625 76x76=5776,所以25和76是两位自守数。 输入一个数,判断该数是否为自守数。解题思路:若采用“求出一个数的平方后再截取最后相应位数”的方法,显然是不可取的,因为计算机无法表示过大的整数。所以我们采取大数相乘的思想来存储这个数的平方。
C++自守
/***********************************************/ /* 求指定范围的自守数 */ /* */ /**/ /**/ /***********************************************/ #include #include using namespace std; v
趣味算法-自守
趣味算法-自守数: 一个正整数的平方的末尾几位数等于这个数本身,那么这个数为自守数。 1)  计算当前数x的位数n; 2)  计算当前数的平方数 xpower; 3)  计算平方数与原数的差,并对于10的n次方取模; 4)  若模为0则该数为自守数。 #include #include //0: not a ZiShou Number //1: is a ZiShou N
面试练习题-100w个数中找出最大的100个数
附、100w个数中找出最大的100个数。 方案1:在前面的题中,我们已经提到了,用一个含100个元素的最小堆完成。复杂度为O(100w*lg100)。 方案2:采用快速排序的思想,每次分割之后只考虑比轴大的一部分,知道比轴大的一部分在比100多的时候,采用传统排序算法排序,取前100个。复杂度为O(100w*100)。 方案3:采用局部淘汰法。选取前100个元素,并排序,记为序列L。然后一次
100万个数据里面找出100个最大的
参考博客: https://blog.csdn.net/beiyetengqing/article/details/8011792 /*基于quicksort实现的原理如下: 1. 假设数组为 array[N] (N = 1 亿),首先利用quicksort的原理把array分成两个部分,左边部分比 array[N - 1] (array中的最后一个值,即pivot) 大, 右边部分比pi...
【华为 OJ 】自守
自守数是指一个数的平方的尾数等于该数自身的自然数。例如:252 = 625,762 = 5776,93762 = 87909376。请求出n以内的自守数的个数   接口说明  /*  功能: 求出n以内的自守数的个数  输入参数:  int n  返回值:      n以内自守数的数量。  */    public static int C
3.2趣味整数之自守
1.问题描述 2.问题分析 3.算法设计 4.请给定数的长度 int numberOfDigit(long num){int count=0; while (num!=0) { num/=10; count++; }return count; }5.分离一个定数最后的几位 //分离一个定数 的最后k位 int lastNumber(long objectNum
自守数C++实现
/*任意输入一个自然数,判断其是否为自守数,并输出相应的信息。自守数的定义为:一个自然数其本身平方后的数的尾数等于这个数本身。例如:25×25=625,76×76=5776。*/
华为机试题:判断自守
描述:  题目标题: 自守数 如果某个数的平方的末尾几位数等于这个数,那么就称这个数为自守数。 显然,5和6是一位自守数(5x5=25 6x6=36),25x25=625 76x76=5776,所以25和76是两位自守数。   详细描述: 接口说明 原型:          Public static boolean i
上机题目(中级)-判断自守数(Java)
题目如下:代码如下:package huawei; public final class Demo { /* Description 判断是否是自守数 Prototype public static boolean isAutoMorphicNum(int num) Input Param num 需要判断的数 Ou
海量数据中找到最大的100个数Java版
//维持一个容量为100的小顶堆 public static int[] getTheMaxNums(int[] a){ int[] result = new int[100]; for(int i = 0;i&lt;100;i++){ result[i] = a[i]; } int len = result.length; for(int...
/*自守数 如果某个数的平方的末尾几位数等于这个数,那么就称这个数为自守数。*/
C++自守数的运算不是程序的错误   /*自守数 如果某个数的平方的末尾几位数等于这个数,那么就称这个数为自守数。*/ int 自守数(0), 数的平方(0), 判(1), 个数(0); while (自守数++ &lt; 10000) { 个数 = 自守数; 数的平方 = 自守数 * 自守数; 判 = 1; do { if (数的平方 % 10 != 个数 % 10) {...
100万个数中找出最大的前100个数
1.  算法如下:根据快速排序划分的思想  (1) 递归对所有数据分成[a,b)b(b,d]两个区间,(b,d]区间内的数都是大于[a,b)区间内的数  (2) 对(b,d]重复(1)操作,直到最右边的区间个数小于100个。注意[a,b)区间不用划分  (3) 返回上一个区间,并返回此区间的数字数目。接着方法仍然是对上一区间的左边进行划分,分为[a2,b2)b2(b2,d2]两个区间,取(
求A到B之间完全平方数的个数
题目:给定整数区间[A,B]问其中有多少个完全平方数。 输入格式: 多组数据,包含两个正整数A,B 1 思路:这边我们假设两个数,A:17,B:26 可以很明显的得出17内包含的完全平方数为:1^2,   2^2,   3^2,   4^2   同理26内包含的完全平方数为1^2    2^2    3^2    4^2   5^2 那么17到26内包含的完全平方数为5^2 判断一个数是
判断一个int型数字是否是自守
自守数 如果某个数的平方的末尾几位数等于这个数,那么就称这个数为自守数。 显然,5和6是一位自守数(5x5=25 6x6=36),25x25=625 76x76=5776,所以25和76是两位自守数。 详细描述: 接口说明 原型: Public static boolean isAutoMorphicNum( int num) 输入参数: num 需要判断的数 输出参数(指针
自守数!
Description 如果某个数的平方的末尾即尾数等于这个数,那么就称这个数为自守数。例如,5和6都是自守数(5x5=25 6x6=36)。同样,25x25=625 76x76=5776,所以25和76也是自守数。虽然0和1的平方的个位数仍然是0和1,但是他们太“平凡”了,研究他们没有意义,所以不算自守数。现在就请大家编写程序,来判断输入的数n(0≤n≤200000)是否为自守数。 Input
自守数(难度:半颗星)
问题描述:如果一个数n是一个自守数,它必须满足如下条件: 1. 如果n有k位数构成,那么n的平方的末尾k位数必须和n相等例如: 25是一个自守数,因为 25 * 25 = 625,并且25等于625后面两位25输出【1,10000】范围内的自守数。参考代码:#include int main() { int i, num, temp, factor; for
我们是很有底线的