-
本版专家分：0结帖率 0% -
昨天的校招 求一千万以下的自守数 如 5*5=25 25*25=625 如果有n由k位数构成 那么n的平方的末尾k位数必须和n相等 并且变量只能用证书 直接for循环是行不通了 有没有老铁有其他解决办法。问题点数：20分
-
本版专家分：390 -
public static void main(String[] args) throws Exception{
// TODO Auto-generated method stub
int sum = 0;
for(int i=1; i<10000000; i++){
int j = String.valueOf(i).length(); //位数
int k = (int)Math.pow(i, 2); //平方数
int l = Integer.parseInt(digit(k, j)); //平方数的最后x位数，x为i的位数
if(i==l){
sum += 1;
}
}
System.out.println(sum);
}
/**
* 求整数的最后x位
* @param num 整数
* @param i 最后x位数
* @return
*/
public static String digit(int num, int i){
StringBuffer sBuffer = new StringBuffer();
int j = String.valueOf(num).length();
if (j < i) {
return sBuffer.append(0).toString();
}
if (j == i) {
return sBuffer.append(num).toString();
}
for(int x=1; x<=i; x++){
int gewei = num%10;
num = num/10;
sBuffer.append(gewei);
}
return sBuffer.reverse().toString();
}
不知道这样是否可行，最后得出的结果是11
-
本版专家分：124 -
public static void test(){
int i,j;
for (i = 1; i < 100; i++){
j = i * i;
if (i<10 && j%10==i){
System.out.println(i);
} else if (j%100==i){
System.out.println(i);
}
}
}
类似这样的代码，不知是否可行
-
本版专家分：215
-
for (long j = 0; j < 10000000; j++) {
if (String.valueOf(j*j).endsWith(String.valueOf(j))) {
System.out.println(j);
}
}
不知道你说的用for循环是行不通的是什么意思，是面试官不让用for循环吗，如果是那我这个回答可以略过了，没有意义
-
本版专家分：8664
-
- 蓝花 2017年7月 Java大版内专家分月排行榜第三
-
-
什么叫变量只能用证书？？
-
本版专家分：1469 -
//blog.csdn.net/hanshileiai/article/details/8877890，这篇文章的想法不错。不会导致数据溢出问题。
-
本版专家分：8664
-
- 蓝花 2017年7月 Java大版内专家分月排行榜第三
-
-
K * K = NK 的模式
K <= sqrt(1000000) = 1000
难道要用迭代做？
public class Demo1 {
public static void main(String[] args){
for(int i = 1; i<1000;i++){
if(i < 10){
if((i * i - i) % 10 == 0){
System.out.println(i);
}
}
if(i < 100){
if((i * i - i) % 100 == 0){
System.out.println(i);
}
}
if(i < 1000){
if((i * i - i) % 1000 == 0){
System.out.println(i);
}
}
}
}
}
-
本版专家分：8664
-
- 蓝花 2017年7月 Java大版内专家分月排行榜第三
-
-
可以再改进改进，只留尾数为 5 或者 6 的数字
public class Demo1 {
public static void main(String[] args){
for(int i = 1; i<1000;i++){
if(i % 10 != 5 || i % 10 != 6){
continue;
}
if(i < 10){
if((i * i - i) % 10 == 0){
System.out.println(i);
}
}
if(i < 100){
if((i * i - i) % 100 == 0){
System.out.println(i);
}
}
if(i < 1000){
if((i * i - i) % 1000 == 0){
System.out.println(i);
}
}
}
}
}
-
本版专家分：8664
-
- 蓝花 2017年7月 Java大版内专家分月排行榜第三
-
-
public class Demo1 {
public static void main(String[] args){
for(int i = 1; i<1000;i++){
if(i % 10 != 5 && i % 10 != 6){
continue;
}
if(i < 10){
if((i * i - i) % 10 == 0){
System.out.println(i);
}
}else if(i < 100){
if((i * i - i) % 100 == 0){
System.out.println(i);
}
}else{
if((i * i - i) % 1000 == 0){
System.out.println(i);
}
}
}
}
}
-
本版专家分：0
-
说一下思路哈：
可以证明，如果n是一个自首数，那么n % 10 ^ (k-1) 必须也是一个自首数。所以可以通过k-1位的自首数来推导k位的自首数。
k=1时，自首数有1, 5, 6
k=2时，只需要验证11, 21, 31 ...91； 15, 25，35 ... 95；16，26,36... 96是否为自首数
...
k = m时，只需要在所有的m-1位的自首数前面枚举1到9并进行验证即可。
-
本版专家分：0
-
更正一下。。?？梢灾っ?，如果n是一个自首数，那么n % 10 ^ k 必须也是一个自首数。
证明：
n = a[1] + a[2] * 10 + a[3] * 10 ^ 3 + ...a[k-1] * 10 ^ (k-1) + a[k] * 10^k
因为n是自首数，所以：
n * n = a[1] + a[2] * 10 + a[3] * 10 ^ 3 + ...a[k-1] * 10 ^ (k-1) + t * 10 ^ k
等式两边同时对10^k取余
(n % 10 ^k) ^ 2 = a[1] + a[2] * 10 + a[3] * 10 ^ 3 + ...a[k-1] * 10 ^ (k-1)
其中n % 10 ^k = a[1] + a[2] * 10 + a[3] * 10 ^ 3 + ...a[k-1] * 10 ^ (k-1)
因此(n % 10 ^k) ^ 2 = n % 10 ^k
因此n % 10 ^k是一个自首数。
-
本版专家分：0
-
傻逼了，不能删帖，再次更正一下。。。忽略刚刚那个证明。。
可以证明，如果n是一个自首数，那么n % 10 ^ (k -1) 必须也是一个自首数。也就是说n的最低的k-1数也是自首数。
证明：
n = a[1] + a[2] * 10 + a[3] * 10 ^ 2 + ...a[k-1] * 10 ^ (k-2) + a[k] * 10^(k -1)
因为n是自首数，所以：
n * n = a[1] + a[2] * 10 + a[3] * 10 ^ 2 + ...a[k-1] * 10 ^ (k-2) + t * 10 ^ (k -1)
等式两边同时对10^(k-1)取余
(n % 10 ^(k-1) ) ^ 2 = a[1] + a[2] * 10 + a[3] * 10 ^ 2 + ...a[k-1] * 10 ^ ( k - 2)
又因为n % 10 ^(k-1) = a[1] + a[2] * 10 + a[3] * 10 ^ 2 + ...a[k-1] * 10 ^ ( k - 2)
所以(n % 10 ^(k-1) ) ^ 2 = n % 10 ^(k-1)
因此n % 10 ^(k-1)是一个自首数。
-
本版专家分：0
-
for (long x = 1; x <=10000000 ; x++) {
long sum = x*x;
long count=0;
while(sum!=0) {
sum/=10;
count++;
}
long num = x;
long count2=0;
while(num!=0) {
num/=10;
count2++;
}
long count3 = count-count2;
long beiShu = 10;
for (int i = 1; i <count3; i++) {
beiShu*=10;
}
if(((x*x)%beiShu)==x) {
System.out.println(x);
}
}
-
本版专家分：0
-
求出来了 先求出两个数之间要%多少个10 然后 x*x % n个10 等于x 就是自守数
纯long类型
-
本版专家分：0
-
以下代码可以求出300位以内所有的自首数：
public class SelfNum {
public static boolean isSelfNum(BigInteger n,BigInteger mod)
{
return n.multiply(n.subtract(BigInteger.ONE)).mod(mod).equals(BigInteger.ZERO);
}
public static void main( String[] args ) {
int k = 300;
List<BigInteger> list = new ArrayList<BigInteger>();
list.add(BigInteger.ONE);
list.add(BigInteger.valueOf(5));
list.add(BigInteger.valueOf(6));
BigInteger offset = BigInteger.ONE;
for(int i = 2 ; i <= k; i++)
{
offset = offset.multiply(BigInteger.TEN);
int size = list.size();
for(int j = 0; j < size; ++j)
{
for(int x = 1; x < 10; ++ x)
{
// tmp = offset * x + list(j)
BigInteger tmp = offset.multiply(BigInteger.valueOf(x)).add(list.get(j));
if(isSelfNum(tmp, offset.multiply(BigInteger.TEN)))
list.add(tmp);
}
}
}
for (int i = 0; i < list.size(); i++) {
System.out.println(list.get(i));
}
}
}
-
本版专家分：10223
-
- 红花 2017年12月 Java大版内专家分月排行榜第一
-
- 蓝花 2017年10月 Java大版内专家分月排行榜第三
-
-
思路搞清，轻松解决
/**
* 思路：n的平方对整的x次幂取余结果是n，则满足条件
* 例5*5=25 25%10=5
* 625*625=390625 625%(10*10*10)=625
* @author yx
*
* 2017-9-25
*/
public class Test {
public static void main(String[] args) {
for (int j = 0; j < 10000000; j++) {
for (int i = 1; i < String.valueOf(j).length(); i++) {
if (Math.pow(j % (Math.pow(10, i)), 2) == j) {
System.out.println(j + "," + (int) (j % (Math.pow(10, i))));
break;
}
}
}
}
}
结果：
25,5
36,6
625,25
5776,76
141376,376
390625,625
-
本版专家分：0
-
再改进一下，以下可以快速求出1000位以内所有的自首数：
public class SelfNum {
public static boolean isSelfNum(BigInteger n,BigInteger mod)
{
return n.multiply(n.subtract(BigInteger.ONE)).mod(mod).equals(BigInteger.ZERO);
}
public static void main( String[] args ) {
int k = 1000,firstEnable = 0, top = 3;
boolean[] enable = new boolean[ 3 * k];
List<BigInteger> list = new ArrayList<BigInteger>();
list.add(BigInteger.ONE);
list.add(BigInteger.valueOf(5));
list.add(BigInteger.valueOf(6));
enable[0] = enable[1] = enable[2] = true;
BigInteger offset = BigInteger.ONE;
for(int i = 2 ; i <= k; i++)
{
offset = offset.multiply(BigInteger.TEN);
int size = list.size();
for(int j = firstEnable; j < size; ++j)
{
if(!enable[j] || !isSelfNum(list.get(j), offset)) {
enable[j] = false;
continue;
}
for(int x = 1; x < 10; ++ x)
{
// tmp = offset * x + list(j)
BigInteger tmp = offset.multiply(BigInteger.valueOf(x)).add(list.get(j));
if(isSelfNum(tmp, offset.multiply(BigInteger.TEN))) {
enable[top++] = true;
list.add(tmp);
}
}
}
while (firstEnable < list.size() && !enable[firstEnable])
firstEnable++;
}
for (int i = 0; i < list.size(); i++) {
System.out.println(list.get(i));
}
}
}
使用C++估计会更快。。
-
本版专家分：0
-
再用链表优化一下：
public class SelfNum {
public static boolean isSelfNum(BigInteger n,BigInteger mod)
{
return n.multiply(n.subtract(BigInteger.ONE)).mod(mod).equals(BigInteger.ZERO);
}
public static void main( String[] args ) {
int k = 3000, head = 0, tail = 2;
int[] next = new int[3 * k];
int[] last = new int[3 * k];
List<BigInteger> list = new ArrayList<BigInteger>();
list.add(BigInteger.ONE);
list.add(BigInteger.valueOf(5));
list.add(BigInteger.valueOf(6));
next[0] = 1;next[1] = 2; next[2] = -1;
last[2] = 1;last[1] = 0; last[0] = -1;
BigInteger offset = BigInteger.ONE;
for(int i = 2 ; i <= k; i++)
{
offset = offset.multiply(BigInteger.TEN);
int size = list.size();
for(int j = next[head]; j < size && j != -1; j = next[j])
{
// 保证前i-1位数是自首数
if(!isSelfNum(list.get(j), offset)) {
// 第一个节点肯定不会被删除
next[last[j]] = next[j];
last[next[j]] = last[j];
continue;
}
for(int x = 1; x < 10; ++ x)
{
// tmp = offset * x + list(j)
BigInteger tmp = offset.multiply(BigInteger.valueOf(x)).add(list.get(j));
if(isSelfNum(tmp, offset.multiply(BigInteger.TEN))) {
last[tail + 1] = tail;
next[tail + 1] = -1;
next[tail] = tail + 1;
list.add(tmp);
tail ++;
}
}
}
}
for (int i = 0; i < list.size(); i++) {
System.out.println(list.get(i));
}
}
}
-
本版专家分：0
-
使用最终的优化可以快速求出3000位以内的自首数。
最终的优化之后，发现链表中的节点数目稳定在4个左右，因此性能瓶颈主要在大数的计算上。。
用c++进行大数计算，应该会有更好的效果。。
-
本版专家分：0
-
for(int i = 1;;i++){
String s = i*i+"";
String t = i+"";
if(i>10000000){
break;
}
if(s.indexOf(t)!=-1 && s.length()-s.indexOf(t)==t.length()){
System.out.println(i);
}
}
-
本版专家分：0
-
#include<stdio.h>
int main()
{
long int i,number,x,mul,k;//k为位数
printf("请输入需查询自守数的范围1~");
scanf("%ld",&x);
for(number=1;number<x;number++)
{
k=1;
mul=number;
for(k;mul>0;k+10)
{
mul=mul/10;
k=k*10;
}
if((number*number-number)%k==0)
{
printf("自守数%ld\n",number);
}
}
return 0;
}
#include<stdio.h>
int main()
{
long mul,number,k,a,b;
printf("It exists following automorphic nmberssmall than 100000: \n");
for( number=0;number<100000;number++)
{
for( mul=number,k=1;(mul/=10)>0;k*=10 );
a=k*10;
mul = 0;
b=10;
while(k>0)
{
mul=(mul+(number%(k*10))*(number%b-number%(b/10)))%a;
k /= 10;
b*=10;
}
if(number == mul)
printf("%ld ",number);
}
printf("\n");
return 0 ;
}
小白借下楼
谢谢楼主哦??！
我想请问第一个代码为啥输出不了自守数90625，而是87232.
求大佬解答??！ 谢谢啦??！
-
本版专家分：0
-
#include<stdio.h>
int main()
{
long int i,number,x,mul,k;//k为位数
printf("请输入需查询自守数的范围1~");
scanf("%ld",&x);
for(number=1;number<x;number++)
{
k=1;
mul=number;
for(k;mul>0;k+10)
{
mul=mul/10;
k=k*10;
}
if((number*number-number)%k==0)
{
printf("自守数%ld\n",number);
}
}
return 0;
}
#include<stdio.h>
int main()
{
long mul,number,k,a,b;
printf("It exists following automorphic nmberssmall than 100000: \n");
for( number=0;number<100000;number++)
{
for( mul=number,k=1;(mul/=10)>0;k*=10 );
a=k*10;
mul = 0;
b=10;
while(k>0)
{
mul=(mul+(number%(k*10))*(number%b-number%(b/10)))%a;
k /= 10;
b*=10;
}
if(number == mul)
printf("%ld ",number);
}
printf("\n");
return 0 ;
}
刚才发错了 麻烦楼主啦 谢谢楼主哦??！
我想请问第一个代码为啥输出不了自守数90625，而是87232.
求大佬解答??！ 谢谢啦??！
-
本版专家分：50
-
我比较好奇的是，为什么说for行不通
int max = 10000000;
int k = 0;
for (int n=1; n<max; n++) {
k = (int)Math.log10(n) + 1; // 数的长度
if ( (n%Math.pow(2, k)==0 || (n-1)%Math.pow(2, k)==0) && ((n)%Math.pow(5, k)==0 || (n-1)%Math.pow(5, k)==0) ) {
System.out.println("自守数：" + n);
}
}
-
本版专家分：705 -
首先这里讨论的是java
然后告诉你 第一段 代码 munber 是long型，你程序中当munber=87232时munber*munber超出long范围了，然后转为float或者double然后产生了误差。
-
本版专家分：0
-
public static void main(String[] args) {
// 自守数是指某个数的平方的末尾几位数等于这个数的数
//转成String，截取平方后数后几位与原数比较
//for循环条件里不能用int,百万内再平方就要越界了
String res = "";
for (BigDecimal i = new BigDecimal(0); i.compareTo(new BigDecimal(100000)) <= 0;) {
String str1 = String.valueOf(i);
String str2 = String.valueOf(i.multiply(i));
int b = str1.length();
int b1 = str2.length();
int c = b1 - b;
String substring = str2.substring(c);
if (substring.equals(str1)) {
res = res + str1 + ",";
}
i = i.add(new BigDecimal(1));
}
System.err.println(res);
}
-
本版专家分：3395 -
观察一下，只要个位数不是1、5、6的，直接 skip
可以少很多很多次循环和判断
-
本版专家分：0
-
结果应该是
0
1
25
76
376
625
Integer num=0;
for (int i = 0; Math.pow(i, 2)<1000000; i++) {
if (i / 100 >=1) { // 百位数
num = (Integer)(i*i);
String a = num.toString().substring(num.toString().length()-3);
if (a.equals(i+"")) {
System.out.println(i);
}
} else if (i / 10 > 1) { // 十位数
num = (Integer)(i*i);
String a = num.toString().substring(num.toString().length()-2);
if (a.equals(i+"")) {
System.out.println(i);
}
} else { //个位数
num = (Integer)(i*i);
String a = num.toString();
if (a.equals(i+"")) {
System.out.println(i);
}
}
}
-
本版专家分：0
-
-
红花
2018年8月 Delphi大版内专家分月排行榜第一
2018年7月 Delphi大版内专家分月排行榜第一
2018年4月 Delphi大版内专家分月排行榜第一
2018年3月 Delphi大版内专家分月排行榜第一
-
- 黄花 2016年11月 Delphi大版内专家分月排行榜第二
-
-
蓝花
2011年10月 其他开发语言大版内专家分月排行榜第三
2010年8月 其他开发语言大版内专家分月排行榜第三
2007年5月 其他开发语言大版内专家分月排行榜第三
-
-
是求一千万以内的自守数，不是求平方在一千万以内的自守数。
-
本版专家分：0
-
public static void test(){
int i,j;
for (i = 1; i < 100; i++){
j = i * i;
if (i<10 && j%10==i){
System.out.println(i);
} else if (j%100==i){
System.out.println(i);
}
}
}
-
本版专家分：0 -
忽略我，我混下积分，没分提问了
public static void test(){
int i,j;
for (i = 1; i < 100; i++){
j = i * i;
if (i<10 && j%10==i){
System.out.println(i);
} else if (j%100==i){
System.out.println(i);
}
}
}
-
本版专家分：3395
-
校招的笔试题应该不会太难
public class TestSelf {
public static void main(String[] args){
// 个位一定是0、1、5、6，其它的数不用考虑
int[] choice = new int[]{
0, 1, 5, 6
};
// 个位一定是0、1、5、6，所以从10位开始累加
for(int a = 0; a < 10000000 / 10; a++){
int p = a * 10;
for(int c : choice){
// 被测试的数
int v = p + c;
// 被测试的数的平方
long vv = v * v;
// 得到被测试的数的位数
int x = 1;
int v1 = v;
while(v1 > 0){
v1 = v1 / 10;
x *= 10;
}
// 对整10、整百……取余，如果与测试数相等，则是自守数
if(vv % x == v)
System.out.println(v);
}
}
}
}
结果：
0
1
5
6
25
76
376
625
9376
-
本版专家分：0
-
-
红花
2018年8月 Delphi大版内专家分月排行榜第一
2018年7月 Delphi大版内专家分月排行榜第一
2018年4月 Delphi大版内专家分月排行榜第一
2018年3月 Delphi大版内专家分月排行榜第一
-
- 黄花 2016年11月 Delphi大版内专家分月排行榜第二
-
-
蓝花
2011年10月 其他开发语言大版内专家分月排行榜第三
2010年8月 其他开发语言大版内专家分月排行榜第三
2007年5月 其他开发语言大版内专家分月排行榜第三
-
-
1. 0不是自守数，如果0是，则任意数都是了
2. 是求一千万以内的自守数，不是求平方在一千万以内的自守数
-
本版专家分：0
-
-
红花
2018年8月 Delphi大版内专家分月排行榜第一
2018年7月 Delphi大版内专家分月排行榜第一
2018年4月 Delphi大版内专家分月排行榜第一
2018年3月 Delphi大版内专家分月排行榜第一
-
- 黄花 2016年11月 Delphi大版内专家分月排行榜第二
-
-
蓝花
2011年10月 其他开发语言大版内专家分月排行榜第三
2010年8月 其他开发语言大版内专家分月排行榜第三
2007年5月 其他开发语言大版内专家分月排行榜第三
-
-
呃，0确实是自守数，我思维错乱了，这条不算，不过2仍然有效...
-
本版专家分：0
-
大神??！论坛知识长得快
-
本版专家分：0
-
凑下热闹
-
本版专家分：140 -
3楼这位老哥的感觉最简单呀！
-
本版专家分：0
-
public class SelfDefenseNumber {
/**
* @param args
*/
public static void main(String[] args) {
// TODO Auto-generated method stub
for(long i = 0L; i < 1000000; ++i) {
long j = i * i;
String a = Long.toString(i);
String c = Long.toString(j);
if(isEndWith(c.toCharArray(),a.toCharArray())) {
System.out.println(String.format("%s X %s = %s", a, a, c));
}
}
}
private static boolean isEndWith(char[] main, char[] sub) {
if(main.length == sub.length) {
return false;
}
final int length = sub.length + 1;
for(int i = 1; i < length; ++i) {
if(main[main.length - i] == sub[sub.length - i]) {
continue;
}
return false;
}
return true;
}
}
-
本版专家分：0
-
0 X 0 = 0
1 X 1 = 1
5 X 5 = 25
6 X 6 = 36
25 X 25 = 625
76 X 76 = 5776
376 X 376 = 141376
625 X 625 = 390625
9376 X 9376 = 87909376
90625 X 90625 = 8212890625
109376 X 109376 = 11963109376
890625 X 890625 = 793212890625
2890625 X 2890625 = 8355712890625
7109376 X 7109376 = 50543227109376
12890625 X 12890625 = 166168212890625
87109376 X 87109376 = 7588043387109376
212890625 X 212890625 = 45322418212890625
787109376 X 787109376 = 619541169787109376
1787109376 X 1787109376 = 3193759921787109376
100万太少了，要弄个21亿的
-
本版专家分：0
-
π是不是这个
-
本版专家分：0
-
-
本版专家分：0
-
-
本版专家分：0
-
程序的运算逻辑都没错误,添加数被截断的判断:
判断数的乘方的个位与数的个位的乘方的个位是否相等为依据.
-
本版专家分：0
-
不错，很厉害
-
本版专家分：0
-
沃克～果然是人才辈出哟
-
本版专家分：253
-
public class ZsNum {
public static void main(String[] args) {
long ji=0;
long k=0;
int lgval=0;
System.out.println("0*0=0");
for (int i=1;i<=1000000;i++)
{
ji=(long)i*i;
lgval=(int)Math.log10(i)+1;
if (ji%(long)Math.pow(10, lgval)==i)
{
System.out.println(i+"*"+i+"="+ji);
}
}
}
}
输出：
0*0=0
1*1=1
5*5=25
6*6=36
25*25=625
76*76=5776
376*376=141376
625*625=390625
9376*9376=87909376
90625*90625=8212890625
109376*109376=11963109376
890625*890625=793212890625
- 趣味算法-自守数
- 趣味算法-<em>自守</em>数： 一个正整数的平方的末尾几位数等于这个数本身，那么这个数为<em>自守</em>数。 1) ?计算当前数x的位数n； 2) ?计算当前数的平方数 xpower； 3) ?计算平方数与原数的差，并对于10的n次方取模； 4) ?若模为0则该数为<em>自守</em>数。 #include #include //0: not a ZiShou Number //1: is a ZiShou N
- 如何从100万个数中找出最大的前100个数
- 摘自?//blog.sina.com.cn/s/blog_682686610<em>100</em>xlrr.html ?1.? 算法如下：根据快速排序划分的思想? (1) 递归对所有数据分成[a,b）b（b,d]两个区间，(b,d]区间内的数都是大于[a,b)区间内的数? (2) 对(b,d]重复(1)操作，直到最右边的区间个数小于<em>100</em>个。注意[a,b)区间不用划分? (3) 返回上
- 华为机试题：判断自守数
- 描述:? 题目标题： <em>自守</em>数 如果某个数的平方的末尾几位数等于这个数，那么就称这个数为<em>自守</em>数。 显然，5和6是一位<em>自守</em>数（5x5=25?6x6=36），25x25=625?76x76=5776，所以25和76是两位<em>自守</em>数。 ? 详细描述： 接口说明 原型： ?????????Public?static?boolean?i
- 永恒的图灵：20位科学家对图灵思想的解构与超越
- 计算机科学丛书
- 100万个数中找出最大的前100个数
- 1.? 算法如下：根据快速排序划分的思想? (1) 递归对所有数据分成[a,b）b（b,d]两个区间，(b,d]区间内的数都是大于[a,b)区间内的数? (2) 对(b,d]重复(1)操作，直到最右边的区间个数小于<em>100</em>个。注意[a,b)区间不用划分? (3) 返回上一个区间，并返回此区间的数字数目。接着方法仍然是对上一区间的左边进行划分，分为[a2,b2）b2（b2,d2]两个区间，?。?/dd>
- 自守数（难度：半颗星）
- 问题描述：如果一个数n是一个<em>自守</em>数，它必须满足如下条件： 1. 如果n有k位数构成，那么n的平方的末尾k位数必须和n相等例如： 25是一个<em>自守</em>数，因为 25 * 25 = 625，并且25等于625后面两位25输出【1,<em>100</em>00】范围内的<em>自守</em>数。参考代码：#include int main() { int i, num, temp, factor; for
- 判断一个int型数字是否是自守数
- <em>自守</em>数 如果某个数的平方的末尾几位数等于这个数，那么就称这个数为<em>自守</em>数。 显然，5和6是一位<em>自守</em>数（5x5=25 6x6=36），25x25=625 76x76=5776，所以25和76是两位<em>自守</em>数。 详细描述： 接口说明 原型： Public static boolean isAutoMorphicNum( int num) 输入参数： num 需要判断的数 输出参数（指针
- 自守数！
- Description 如果某个数的平方的末尾即尾数等于这个数，那么就称这个数为<em>自守</em>数。例如，5和6都是<em>自守</em>数（5x5=25 6x6=36）。同样，25x25=625 76x76=5776，所以25和76也是<em>自守</em>数。虽然0和1的平方的个位数仍然是0和1，但是他们太“平凡”了，研究他们没有意义，所以不算<em>自守</em>数。现在就请大家编写程序，来判断输入的数n(0≤n≤200000)是否为<em>自守</em>数。 Input
- /*自守数 如果某个数的平方的末尾几位数等于这个数，那么就称这个数为自守数。*/
- C++<em>自守</em>数的运算不是程序的错误 ? /*<em>自守</em>数 如果某个数的平方的末尾几位数等于这个数，那么就称这个数为<em>自守</em>数。*/ int <em>自守</em>数(0), 数的平方(0), 判(1), 个数(0); while (<em>自守</em>数++ &lt; <em>100</em>00) { 个数 = <em>自守</em>数; 数的平方 = <em>自守</em>数 * <em>自守</em>数; 判 = 1; do { if (数的平方 % 10 != 个数 % 10) {...
- 求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 判断一个数是
- PAT乙级 1091 N-自守数 （15 分）
- 如果某个数 K 的平方乘以 N 以后，结果的末尾几位数等于 K，那么就称这个数为“N-<em>自守</em>数”。例如 3×922=25392，而 25392 的末尾两位正好是 92，所以 92 是一个 3-<em>自守</em>数。 本题就请你编写程序判断一个给定的数字是否关于某个 N 是 N-<em>自守</em>数。 输入格式： 输入在第一行中给出正整数 M（≤20），随后一行给出 M 个待检测的、不超过 <em>100</em>0 的正整数。 输出格式： 对每...
- 问题 A: 【循环】自守数 简单
- 题目描述： <em>自守</em>数是指一个数的平方的尾数等于该数自身的自然数。例如252=625,762=5776。 输入一个自然数，判断其是否为<em>自守</em>数。 如果是，则输出Yes，否则输出No 输入： 一个自然数 输出： 如果是<em>自守</em>数，输出Yes，否则输出No 样例输入： 25 样例输出： Yes 代码如下： include&lt;stdio.h&gt; main() { int a,b,i,j,x,m; scan...
- 求自守数的算法
- 求<em>自守</em>数，非常好哟，快来下载，等待你们，不会开心难受
- 一个整数，它加上100后是一个完全平方数，加上168又是一个完全平方数，请问该数是多少
- 解题思路：整数，太大的会溢出，可以截止到10万?？椒揭院笕∧?得到的数字是0，表示可以被开平方，是素数代码：public class Main11 {?? ?public static void main(String[] args) {?? ??? ?// TODO Auto-generated method stub?? ??? ?for(int i=1;i&lt;<em>100</em>000;i++){?...
- 蓝桥杯之自守数
- 如果一个自然数的平方数的尾部仍然为该自然数本身，则称其为<em>自守</em>数。 例如： 5 x 5 = 25 76 x 76 = 5776 625 x 625 = 390625 下面代码的目的是寻找出2千万以内的所有<em>自守</em>数。 注意，2千万的平方已经超出了整数表达的最大范围，所以该程序使用了一个巧妙的方案。 如果我们仔细观察乘法的计算过程，就会发现实际上对乘积的尾数有贡献的环节，
- 10亿以内的自守数
- 如果一个自然数的平方数的尾部仍然为该自然数本身，则称其为<em>自守</em>数。 例如： 5 x 5 = 25 76 x 76 = 5776 625 x 625 = 390625 下面代码的目的是寻找出2千万以内的所有<em>自守</em>数。 注意，2千万的平方已经超出了整数表达的最大范围，所以该程序使用了一个巧妙的方案。 如果我们仔细观察乘法的计算过程，就会发现实际上对乘积的尾数有贡献的环节，从而
- 100亿个整数，找出中位数
- <em>100</em>亿个整数，内存足够，如何找到中位数？内存不足，如何找到中位数？ （1）当内存足够时：采用快排，找到第n大的数。 ? 随机选取一个数，将比它小的元素放在它左边，比它大的元素放在右边 ? 如果它恰好在中位数的位置，那么它就是中位数，直接返回 ? 如果小于它的数超过一半，那么中位数一定在左半边，递归到左边处理（还是第几大） ? 否则中位数一定在右半边，根据左半边的元素个数
- 在10万以内判断，一个整数加上100后是一个完全平方数，再加上168又是一个完全平方数，求该数
- 题目：一个整数，它加上<em>100</em>后是一个完全平方数，再加上168又是一个完全平方数，请问该数是多少？?程序分析：在10万以内判断，先将该数加上<em>100</em>后再开方，再将该数加上268后再开方，如果开方后?的结果满足如下条件，即是结果。?程序源代码：#include#includeint main(){ long int i, x, y; for (i = 1; i { x = sqrt(i + <em>100</em>);
- 有一个100万的数组，里边有两个是重复的，如何设计算法找到
- 输出：两个重复的元素的索引 首先，直接两重循环查找不是不行，估计是最蠢的做法了。 其次，先用快速排序拍一遍，然后遍历，时间复杂度最好的情况是最坏的情况是nlogn+n 有人说是用hash，有人说用位图，不知道什么情况，用起来估计很麻烦。 其实最好想的一个方式为HashSet方式，在数量不那么大的情况下没问题的，<em>100</em>万同时加载到内存中可以接受，主要考虑时间复杂度。 代码如下：
- PAT 1091 N-自守数 （15 分）
- 如果某个数?K?的平方乘以?N?以后，结果的末尾几位数等于?K，那么就称这个数为“N-<em>自守</em>数”。例如?3×92?2??=25392，而?25392?的末尾两位正好是?92，所以?92?是一个?3-<em>自守</em>数。 本题就请你编写程序判断一个给定的数字是否关于某个?N?是?N-<em>自守</em>数。 输入格式： 输入在第一行中给出正整数?M（≤20），随后一行给出?M?个待检测的、不超过 <em>100</em>0 的正整数。 输...
- 华为上机题汇总（十八）
- 华为上机题汇总（十八）注：编译环境为Visual Studio 2012，答案仅供参考。目录华为上机题汇总十八 目录 第八十六题 第八十七题 第八十八题 第八十九题 第九十题第八十六题86.合并输入的两个整形数组并去掉重复的数字按升序输出； 案例输入：3 1 2 5 -10 3 2 案例输出：-10 1 2 3 5#include #include
- 大数据：随机生成10万个整数找出出现次数前一百的数
- 如何找出大数据中出现次数最多的前n位数
- 自守数源代码
- 这是一个辨别<em>自守</em>数的源代码，非常简单，但是很实用
- 100亿个数中找出最大的前K个数（海量数据topK问题）
- 分析：海量数据topK问题，在我们日常生活中应用非常广泛，比如微信的计步软件，它就是topK问题，统计出前K名，然后进行排序。那如何解决这个问题呢？我们用堆可以很好的解决这个问题。我们先用前K个数建立一个大堆/小堆（找最大前K个数用小堆，找最小前K个数用大堆，因为：如果找最大前K个数，我们建立一个大堆的话，我们需要用第N-K-1个数与堆顶元素比较，如果它比堆顶元素小我们就要舍弃它，但如果它比堆顶元...
- PTA 乙级题 N-自守数
- 1091 N-<em>自守</em>数 （15 分） 如果某个数 K 的平方乘以 N 以后，结果的末尾几位数等于 K，那么就称这个数为“N-<em>自守</em>数”。例如 3×92?2??=25392，而 25392 的末尾两位正好是 92，所以 92 是一个 3-<em>自守</em>数。 本题就请你编写程序判断一个给定的数字是否关于某个 N 是 N-<em>自守</em>数。 输入格式： 输入在第一行中给出正整数 M（≤20），随后一行给出 M 个待检测...
- PAT 乙级 1091 N-自守数 (15 分)
- #include&lt;iostream&gt; #include&lt;string&gt; #include&lt;algorithm&gt; #include&lt;stdio.h&gt; #include&lt;cctype&gt; #include&lt;map&gt; #include&lt;vector&gt; #include&lt;string.h&gt; #in
- 【华为OJ】自守数
- <em>自守</em>数是指一个数的平方的尾数等于该数自身的自然数。例如：25^2?=?625，76^2?=?5776，9376^2?=?87909376。请求出n以内的<em>自守</em>数的个数 输入：N 输出：N以内<em>自守</em>数的个数#include #include using namespace std; int main() { int n; int amount = 0; cin >> n; if (
- 在一堆很大的数中取出最小的前100个数
- 题目大意是：有很多很多数，
- 100万个数中找到最大的100个数
- 1. 算法如下：根据快速排序划分的思想 (1) 递归对所有数据分成[a,b）b（b,d]两个区间，(b,d]区间内的数都是大于[a,b)区间内的数 (2) 对(b,d]重复(1)操作，直到最右边的区间个数小于<em>100</em>个。注意[a,b)区间不用划分 (3) 返回上一个区间，并返回此区间的数字数目。接着方法仍然是对上一区间的左边进行划分，分为[a2,b2）b2（b2,d2]两个区间，?。╞2,d2]区间
- C#求自守数
- using System; using System.Collections.Generic; using System.Linq; using System.Text; using System.Threading.Tasks; namespace <em>自守</em>数 { class Program { static void Main(string[] args)
- 查找1亿个数里面最大的100个数。
- #include #include #include #include #include #include #include using namespace std; int main() { vector a(<em>100</em>000000,0); srand((int)time(0)); for(int i=0;i<<em>100</em>000000;i++) {
- 从100万个整数里找出100个最大的数
- <em>100</em>万个整数里找出<em>100</em>个最大的数（用哪种算法效率高） 以下为可能性最大的答案：部分排序？找出一个支点，把数组分为左右，一直分... 可以参考<em>一下</em>STL中nth_element的实现吧。选择第k大数有O(n)的算法，过程衍生自快排呵呵我看懂啦，是个好算法！顶！ 取前<em>100</em>个数排序,放入链表中.依次取后面的数与<em>100</em>个数的最小数比较,若取到的数比最小数大,则插入链表中,同时挤掉最小的数.这个过程中使用的链表,因为
- 同构数随即范围里找
- #include &lt;stdio.h&gt; #include &lt;math.h&gt; int main(int argc, char *argv[]) { int m,n,t,w,k=10,y,sum; scanf("%d,%d",&amp;m,&amp;n); if(m&gt;n) { t=m; m=n; n=t; } for(w=m;w&lt;=n;w++)...
- 100亿个数中寻找中位数
- 题目： 在一个大文件中有<em>100</em>亿个32位整数，乱序排列，要求找出中位数；内存限制为512M；请写出算法设计思路； 基本分析： （1）中位数的定义：一个给定排序好的序列，奇数个的话，我们就取中间的一个；偶数个的话，我们一般取中间两个数的平均值；因此对于本题，我们需得到中间的第50亿和第50亿+1这两个数； （2）首先512M的内存，如果都来装这个32位整数的话，可以存储2^(9+10
- 计算10000以内的平方数
- '''实例三：平方数的操作练习简述：一个整数，它加上<em>100</em>和加上268后都是一个完全平方数提问：请问该数是多少？Python解题思路分析：在<em>100</em>00以内判断，将该数加上<em>100</em>后再开方，加上268后再开方，如果开方后的结果满足如下条件，即是结果。说明：sqrt() 方法返回数字x的平方根，sqrt()是不能直接访问的，需要导入 math ?？?，通过静态对象调用该方法'''import math,t...
- 1：100地图分幅计算和图幅名称规范
- ?? 国家基本比例尺 国家基本比例尺有1：1万、1：2.5万 1：5万 1：10万 1：20万 1：50万 1：<em>100</em>万七种。普通地图按照比例尺通常分为小比例尺、中比例尺、大比例尺。通常1：5万和更大的比例尺称为大比例尺地图。1:10万到1：50万程为中比例尺地图。小于1:<em>100</em>万的称为小比例尺地图。 地图的分幅 目前我国地图分幅方案采用1：10
- 算法实现：如何从100亿个数中找到最大的10000个数
- 一看这个这个题目：也许你就蒙了，这么多的数排序，直接读入内存，内存是装不下的，一个解决办法：用堆排序，先取<em>100</em>00个数排序，排序的时间复杂度，nlogn=<em>100</em>00*log<em>100</em>0，设它为T0，那么后面的数据依次取一个和这个堆比较，堆里面永远保留最大的<em>100</em>00个数据，最后就输出这<em>100</em>00w个数据，不知道还有什么好的办法吗？
- 用MapReduce查找100万个数中的最大值
- //用MapReduce查找<em>100</em>万个数中的最大值 public?class?TopKApp?{ ????static?final?String?INPUT_PATH?=?"hdfs://chaoren:9000/input"; ????static?final?String?OUT_PATH?=?"hdfs://chaoren:9000/out"; ????public?static
- [练习]快速算出1到100万之间的素数
- import java.util.Scanner; public class PrimeNum { public static void main(String[] args) { Scanner AAA = new Scanner(System.in); int maxNum = AAA.nextInt();//输入最大范围 long start = System.current...
- 1091 N-自守数
- 1091 N-<em>自守</em>数 如果某个数 K 的平方乘以 N 以后，结果的末尾几位数等于 K，那么就称这个数为“N-<em>自守</em>数”。例如 3×92?2??=25392，而 25392 的末尾两位正好是 92，所以 92 是一个 3-<em>自守</em>数。 本题就请你编写程序判断一个给定的数字是否关于某个 N 是 N-<em>自守</em>数。 输入格式： 输入在第一行中给出正整数 M（≤20），随后一行给出 M 个待检测的、不超过 <em>100</em>0 ...
- 1091 N-自守数 （15 point(s)） - PAT乙级真题
- 如果某个数 K 的平方乘以 N 以后，结果的末尾几位数等于 K，那么就称这个数为“N-<em>自守</em>数”。例如 3×922?? = 25392，而 25392 的末尾两位正好是 92，所以 92 是一个 3-<em>自守</em>数。 本题就请你编写程序判断一个给定的数字是否关于某个 N 是 N-<em>自守</em>数。 输入格式： 输入在第一行中给出正整数 M（≤20），随后一行给出 M 个待检测的、不超过 <em>100</em>0 的正整数。 输...
- （百例编程）27.自守数
- 题目：<em>自守</em>数是指一个数的平方的尾数等于该数自身的自然数。例如：252=625 762=5776 93762=87909376 请求出200000以内的<em>自守</em>数。本问题所关心的是积的最后三位。分析产生积的后三位的过程，可以看出，在每一次的部分积中，并不是它的每一位都会对积的后三位产生影响。 #include using namespace std; int zhishu(int a,int b)
- 如何生成100万个无序不重复随机值
- 采取的方法如下代码： #include #define NUM <em>100</em>0000 void swap(int* pa,int* pb) { int temp = 0; temp = *pa; *pa = *pb; *pb = temp; } int main(void) { FILE *fp = NULL; unsigned i = 0,index = 0; int *p =
- php 随机生成100个100万以内的数，顺序查找，二分查找
- php 随机生成<em>100</em>个<em>100</em>万以内的数，顺序查找，二分查找 php 顺序查找，二分查找
- 求1~100能被7整除的数之和
- /*求1~<em>100</em>能被7整除的数之和*/#include main() { int n; long sum=0; for(n=1;n,sum); }· ·
- 广东11选五前三直遗漏
- 一个整数，它加上<em>100</em>后是一个完全平方数，再加上168又是一个完全平方数，请问该数是多少？
- Python_一个整数,加上100是一个完全平方数,再加上168也是一个完全平方数,求这个数?
- import math def getNum(): result = [] for i in range(-<em>100</em>, <em>100</em>00): a = math.sqrt(i + <em>100</em>) b = math.sqrt(i + <em>100</em> + 168) if int(a) == a and int(b) == b: resu...
我们是很有底线的