-
本版专家分：0结帖率 0% -
昨天的校招 求一千万以下的自守数 如 5*5=25 25*25=625 如果有n由k位数构成 那么n的平方的末尾k位数必须和n相等 并且变量只能用证书 直接for循环是行不通了 有没有老铁有其他解决办法。
-
本版专家分：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循环吗，如果是那我这个回答可以略过了，没有意义
-
本版专家分：8704
-
- 蓝花 2017年7月 Java大版内专家分月排行榜第三
-
-
什么叫变量只能用证书？？
-
本版专家分：1469 -
//blog.csdn.net/hanshileiai/article/details/8877890，这篇文章的想法不错。不会导致数据溢出问题。
-
本版专家分：8704
-
- 蓝花 2017年7月 Java大版内专家分月排行榜第三
-
-
K * K = NK 的模式
K <= sqrt(1000000) = 1000
难道要用迭代做？
广东11选五前三直遗漏 www.hgaf.net
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);
}
}
}
}
}
-
本版专家分：8704
-
- 蓝花 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);
}
}
}
}
}
-
本版专家分：8704
-
- 蓝花 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));
}
}
}
-
本版专家分：10228
-
- 红花 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.
求大佬解答??！ 谢谢啦??！
-
本版专家分：80
-
我比较好奇的是，为什么说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);
}
}
-
本版专家分：1893
-
首先这里讨论的是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);
}
-
本版专家分：3405 -
观察一下，只要个位数不是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
-
-
红花
2019年2月 其他开发语言大版内专家分月排行榜第一
2019年1月 Delphi大版内专家分月排行榜第一
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);
}
}
}
-
本版专家分：3405
-
校招的笔试题应该不会太难
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
-
-
红花
2019年2月 其他开发语言大版内专家分月排行榜第一
2019年1月 Delphi大版内专家分月排行榜第一
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
-
-
红花
2019年2月 其他开发语言大版内专家分月排行榜第一
2019年1月 Delphi大版内专家分月排行榜第一
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
-
凑下热闹
-
本版专家分：180
-
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
-
沃克～果然是人才辈出哟
-
本版专家分：263
-
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
- Java趣味编程10----自守数
- <em>自守</em>数即某个数的平方的末尾几个数等于这个数本身，那么这个数就叫<em>自守</em>数。 如25 * 25=625，76*76=5776，所以25和76就是<em>自守</em>数。 所以，我们要取得结果的末尾几个数和原数比较，这里我们使用了字符串的方法，将结果转成String类型，然后通过获取子串的结果和原来的串相比较。 package _3InterestingInteger; /* <em>自守</em>数 */ public class ...
- 125.自守数
- 125.<em>自守</em>数? ?如果一个自然数的平方数的尾部仍然为该自然数本身，则称其为<em>自守</em>数。? ?例如：? ?5 x 5 = 25? ?76 x 76 = 5776? ?625 x 625 = 390625? ?下面代码的目的是寻找出2千万以内的所有<em>自守</em>数。? ?注意，2千万的平方已经超出了整数表达的最大范围，所以该程序使用了一个巧妙的方案。? ?如果我们仔细观察乘法的计算过程，就会发现实际上对乘积的尾数
- 【华为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 (
- 百度面试题：在100w个数中找最大的前100个数
- 在<em>100</em>w个数中找最大的前<em>100</em>个数 答案在文章评论部分，请注意查看:) 原文网址：//hi.baidu.com/mianshiti/blog/item/37652f27a3ac4320d5074252.html -----------------
- 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 ...
- 华为OJ（自守数）
- 描述 <em>自守</em>数是指一个数的平方的尾数等于该数自身的自然数。例如：252?=?625，762?=?5776，93762?=?87909376。请求出n以内的<em>自守</em>数的个数?接口说明?/*?功能:?求出n以内的<em>自守</em>数的个数?输入参数：?int?n?返回值：?????n以内<em>自守</em>数的数量。?*/??public?static?int?CalcAutomorphicNumbers(?int?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) 返回上
- c39 自守数
- /* 【程序39】 <em>自守</em>数 * 题目：求出<em>100</em>0以内的<em>自守</em>数。 * 程序分析：<em>自守</em>数：如果某一个数的平方的末几位数(原数是几位就取几位)等于它本身，则称之为<em>自守</em>数。如：5^2=25, 6^2=36。解题方法：（数的平方）对（10的[数位次方]）取余==原数 */ #include int ten_to_n(int i) // 10的n次方, n为i的位数 { int j = 1;
- 1091 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 个待检测...
- 在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>);
- Python中自守数算法的计算：
- Python中<em>自守</em>数算法的计算：
- 自守数20000以内
- #include &lt;stdio.h&gt;void main(){//巧妙的绕过了 计算平方的过程，因为太大的数字平方超出了范围。long mul,number,k,a,b;printf("将输出200000以内的<em>自守</em>数：\n");for(number=0; number&lt;200000; number++)? ? {? ? for(mul=number,k=1; (mul/=10)&g...
- /*自守数 如果某个数的平方的末尾几位数等于这个数，那么就称这个数为自守数。*/
- 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: 【循环】自守数 简单
- 题目描述： <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...
- 1091?N-自守数?（15 分）
- 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?个待检测...
- 100万个数据里面找出100个最大的
- 参考博客： https://blog.csdn.net/beiyetengqing/article/details/8011792 /*基于quicksort实现的原理如下： 1. 假设数组为 array[N] (N = 1 亿)，首先利用quicksort的原理把array分成两个部分，左边部分比 array[N - 1] (array中的最后一个值，即pivot) 大， 右边部分比pi...
- 基于C语言实现的网吧管理系统-背单词-自守数-进制转换
- 1 求解<em>自守</em>数1.1 问题描述判断任意输入的某数，是否是<em>自守</em>数。如果一个自然数的平方数的尾部仍然为该自然数本身， 则称其为<em>自守</em>数。例如：5x5=2576x76=5776625x625=3906251.2 功能要求可任意输入一个整数，输出其是否是<em>自守</em>数的结论。 参考文档和完整的文档和源码下载地址：https://www.write-bug.com/...
- 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 个待检测...
- [练习]快速算出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...
- 判断一个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 需要判断的数 输出参数（指针
- 从10万个数中找10个最大的数
- 对于这种题目，最普通的想法是先对这10万个数进行排序，然后再选取数组中前10个数，即为最后的答案，排序算法的时间复杂度不下于O(N lgN)。最好的方法是建立一个最小堆。 算法描述： 我们首先取10万个元素中的前10个元素来建立由10个元素组成的最小堆。这样堆顶元素便是当前已知元素的第10大的数；然后依次读取剩下的99990个元素，若读取的元素比堆顶元素大，则将堆顶元素和当前元素替换，并自堆顶至
- 1035: 自守数问题
- 题目Description <em>自守</em>数是指一个数的平方的尾数等于该数自身的自然数。 例如： 25^2=625 76^2=5776 9376^2=87909376 请求出200000以内的<em>自守</em>数? InputOutput 200000以内的<em>自守</em>数(包括0, 数之间用两个空格分开) Sample InputSample Output 0 1 5 6 25 76 376
- 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)
- 有一个100万的数组，里边有两个市重复的，如何设计算法找到
- ? package com.xiva.demo; import java.util.*; public class ArrayDemo{ @SuppressWarnings("rawtypes") public static void main(String[] args){ Date starTime = new Date(); ...
- TopK问题--100W个数种找出其中最大的前K个数；
- 一、<em>100</em>W个数种找出其中最大的前K个数—-建小堆 找最小–建大堆 ； 二、//<em>100</em>W个数种找出其中最大的前K个数； //知识回顾： //bit---比特 //Byte----字节 //*1T=1024GB //1GB=1024MB //1MB=1024KB //1KB=1024B //1B=8
- 100亿个整数，找出中位数
- <em>100</em>亿个整数，内存足够，如何找到中位数？内存不足，如何找到中位数？ （1）当内存足够时：采用快排，找到第n大的数。 ? 随机选取一个数，将比它小的元素放在它左边，比它大的元素放在右边 ? 如果它恰好在中位数的位置，那么它就是中位数，直接返回 ? 如果小于它的数超过一半，那么中位数一定在左半边，递归到左边处理（还是第几大） ? 否则中位数一定在右半边，根据左半边的元素个数
- 万以内数的认识
- 教学目的： 1、通过直观的数数使学生认识计数单位百、千、，并掌握数数方法，掌握10个一百是一千。建立数的概念，培养数感?！ ?、初步理解相邻计数单位间的十进关系?！ 〗萄е氐悖耗苁炝返厥б阅诘氖 〗萄训悖汗胀涫??！ 〗萄Ч蹋骸 ∫?、信息汇报 汇报收集到的有关<em>100</em>0以内数的资料?！ 《?、探究新知 1、数的认识?！ ?lt;em>100</em>0有多大？（估计说不清） 大的数往往可由...
- 华为OJ基础篇-自守数
- <em>自守</em>数是指一个数的平方的尾数等于该数自身的自然数
- 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]区间
- 自守数定义：一个自然数的平方的尾数等于该数本身。例如：25=625，76=5776，9376=87909376，则25、76、9376均是自守数。试建立一个类Self，求出指定范围内的自守
- <em>自守</em>数定义：一个自然数的平方的尾数等于该数本身。例如：25=625，76=5776，9376=87909376，则25、76、9376均是<em>自守</em>数。试建立一个类Self，求出指定范围内的<em>自守</em>数，具体要求如下： （1）私有数据成员 int a[20]：存放求出的<em>自守</em>数。 int m , n , p：m、n存放<em>自守</em>数的取值范围，p存放求出的<em>自守</em>数的个数。 （2）公有成员函数 构造函数Self(
- 算法实现：如何从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个数据，不知道还有什么好的办法吗？
- 从一亿个数中找出最大的一万个数
- 问题定义： ? ? ? ? 从一亿个数中找出最大的一万个数 不假思索： ? ? ? ? 拿到这道题，马上就会想到的方法是建立一个数组把1亿个数装起来，然后用for循环遍历这个数组，找出最大的1万个数来。原因很简单，如果要找最大的那个数，就是这样解决的；而找最大的一万个数，只是重复一万遍。这个解法类似于选择排序，一次将一个正确解放在合适的位置，重复一万次，所以时间复杂度为O(n *m)，如果你
- 求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 判断一个数是
- 100万以内的素数表
- <em>100</em>万以内的素数表
- 10月25日 c语言 找到10000以内所有完数
- #include ? ?? void main() ? { ? ? ? int num,sum,i; ? ? ? for(num=1;num ? ? { ? ? ? ? ? sum=1; ? ? ? ? ? for(i=2;i ? ? ? ? if(num%i==0)? sum=sum+i; ? ? ? ? ? if(sum==num) ? ? ? ? ? { ? ?
- 大数据：随机生成10万个整数找出出现次数前一百的数
- 如何找出大数据中出现次数最多的前n位数
- 计算10000以内的平方数
- '''实例三：平方数的操作练习简述：一个整数，它加上<em>100</em>和加上268后都是一个完全平方数提问：请问该数是多少？Python解题思路分析：在<em>100</em>00以内判断，将该数加上<em>100</em>后再开方，加上268后再开方，如果开方后的结果满足如下条件，即是结果。说明：sqrt() 方法返回数字x的平方根，sqrt()是不能直接访问的，需要导入 math ?？?，通过静态对象调用该方法'''import math,t...
- C语言 产生 1- 100万随机数,如果重复的话,能马上知道.
- 产生 1- <em>100</em>万随机数,如果重复的话,能马上知道. 解决思路就是:利用产生的随机数作为数组的下标 例如:产生的随机数为1,则a[1]++,最后a[1]的值即为随机数1出现的次数. 当然了,由于声明一个数组之后,初始值默认为0,所以1出现第一次时a[1]=0, 当1出现第二次时,a[1]=1了. ~(≧▽≦)/~啦啦啦 翠花,上代码!!!long arr[<em>100</em>0000] = {0};
- 有一个100万的数组，里边有两个是重复的，如何设计算法找到
- 输出：两个重复的元素的索引 首先，直接两重循环查找不是不行，估计是最蠢的做法了。 其次，先用快速排序拍一遍，然后遍历，时间复杂度最好的情况是最坏的情况是nlogn+n 有人说是用hash，有人说用位图，不知道什么情况，用起来估计很麻烦。 其实最好想的一个方式为HashSet方式，在数量不那么大的情况下没问题的，<em>100</em>万同时加载到内存中可以接受，主要考虑时间复杂度。 代码如下：
- 从 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,
- 【C++深度剖析教程40】使用数值型模板技术计算1+2+3+...+N的值
- 上一篇文章学习了数值型模板技术，并利用相关技术，实现了C++的数组类模板。点击文章查看上一篇文章：点击链接查看 本篇文章，继续利用模板技术来解决一个问题。 如果想求1+2+3+…+N的结果，有很多种方法?？梢匝繁槔?，可以直接使用公式求解。但是他们都不是最快的方法，我们今天使用模板技术，来最快速的求出结果。 1、回顾 模板参数可以是数值型参数。也就是非类型参数。如下图所示： 我们可以像上面定义一...
- java打印100-10000以内的水仙花数
- 做这个问题开始我的思路是正确的，可是，只是想一起打印<em>100</em>-<em>100</em>00的，后来才发现不可以。。public class shui{? public static void main(String[] args) ? {??System.out.println("开始输出水仙花数");??/*打印<em>100</em>-<em>100</em>0以内的水仙花。*/??int b,s,g;??? for(int i=<em>100</em>;i??
- 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>
- 用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
- 从100亿个整数中找出最大/最小的1000个整数
- 一句话总结：内存无法装下，用比较速度最快的数据结构。 先找最大的<em>100</em>0个整数 1、内存无法装下：先取出<em>100</em>1个整数，构建一个最小堆，堆顶永远是最小的整数。 2、比较：从剩余的整数中一次取出一个，跟最小堆堆顶相比，如果比堆顶小，就pass掉，接着??；如果比最小堆堆顶大，那么将之替换掉堆顶，然后调整最小堆 3、结果：<em>100</em>亿个整数全部操作完后，抛开堆顶，剩下的<em>100</em>0个就是最大的<em>100</em>0个
- java 求100000以内的相亲数
- 问题： 220的真因数之和为：1+2+4+5+10+11+20+22+44+55+110=284 284的真因数之和为：1+2+4+71+142=220 毕达哥拉斯把这样的数对A、B称为相亲数：A的真因数之和称为B，而B的真因数之和为A。求<em>100</em>000以内的相亲数。 代码： public static void main(String[] args) { int sA =
- 100亿个数中找出最大的前K个数（海量TopK问题）
- 对于这个问题，可以有以下思考： 给了多少内存存储这<em>100</em>亿个数据？ 先思考：堆排序效率是nlogn,再思考：可以将这些数据切成等份，再从每一份中找出最大前k个数据，但是效率不高。那如果利用堆的性质呢？ 小堆堆顶元素最小，先将前k个数建成小堆，那么堆顶元素就是最小的，k+1的数依次与堆顶元素进行比较，如果大于，则K+1与堆顶元素交换，依次循环直至所有数据全部比较完，那么这个堆里存放的是最大的前...
- C/C++ 编程计算2的100万次方（m的n次方）,超长结果输出文件
- C/C++ 编程计算2的<em>100</em>万次方（m的n次方）,超长结果输出文件
- C＃2008和.NET 3.5平台(红皮书经典)下载
- C＃2008和.NET 3.5平台----C＃2008和.NET 3.5平台----C＃2008和.NET 3.5平台 相关下载链接：[url=//download.csdn.net/download/hwhone/917813?utm_source=bbsseo]//download.csdn.net/download/hwhone/917813?utm_source=bbsseo[/url]
- 正则表达式的api下载
- 正则表达式api, 相关下载链接：[url=//download.csdn.net/download/yuehua_xiao/5147061?utm_source=bbsseo]//download.csdn.net/download/yuehua_xiao/5147061?utm_source=bbsseo[/url]
- 服装CAD打版破解软件(ET最新版）下载
- 服装CAD打版破解软件 最新ET破解免安装版 相关下载链接：[url=//download.csdn.net/download/u013004806/7153233?utm_source=bbsseo]//download.csdn.net/download/u013004806/7153233?utm_source=bbsseo[/url]
我们是很有底线的