Java的整数位移成倍数

有一个整数，将整数的最后一位移到第一位，则新的整数变成了原数的2倍，怎么求该数？怎么求该数？
如何实现整数位移呢？

http://t.csdn.cn/18Md9 感觉可以看看这篇的算法

img


运行结果：

img

  • 帮你找了个相似的问题, 你可以看下: https://ask.csdn.net/questions/274831
  • 你也可以参考下这篇文章：关于java中判断一个点是否在一个长方形内和一个长方形是否包含另一个长方形或者两个相重叠的问题。
  • 除此之外, 这篇博客: Java实现 学生管理系统项目 完整版，每个功能详细介绍，最后面完整源代码可直接执行中的 实现思路： 部分也许能够解决你的问题, 你可以仔细阅读以下内容或跳转源博客中阅读:

  • 1、定义学生类
    2、主界面的代码编写
    3、添加学生的代码编写
    4、查看学生的代码编写
    5、删除学生的代码编写
    6、修改学生的代码编写

    每一个功能都定义一个方法，在方法里面来实现功能，再在main函数里面相应位置调用就可以。

  • 您还可以看一下 徐无忌老师的Java进阶高手课-并发编程透彻理解课程中的 什么是多线程的上下文切换，有什么影响？如何进行优化？（一）小节, 巩固相关知识点
  • 以下回答由chatgpt基于相关博客总结生成:

    这道题需要实现将一个整数的最后一位移动到第一位，并且判断是否是原数的2倍。需要考虑负数、0、只有一位等情况。具体的解决方案如下：

    1. 首先判断输入的数是否为0、正整数或负整数。如果是0，则直接返回false，因为0的任何倍数都是0；如果是正整数或负整数，则将其转换成字符串处理，方便后面操作。

    2. 判断字符串长度是否大于1，如果字符串长度等于1，则该整数只有一位，满足条件，返回true。

    3. 利用Java中的字符串方法substring来截取字符串的最后一位数字及其前面的数字，并将截取到的两个字符串转换成Integer类型的整数。将这两个整数组合成第一位是最后一位的整数。

    4. 判断新生成的整数是否是原数的2倍，如果是，则返回true，否则返回false。

    以下是具体的代码实现：

    public class Main {
    public static void main(String[] args) {
        int num1 = 122;
        int num2 = 123;
        int num3 = 0;
        int num4 = -123;

        System.out.println(checkDouble(num1)); // true
        System.out.println(checkDouble(num2)); // false
        System.out.println(checkDouble(num3)); // false
        System.out.println(checkDouble(num4)); // false
    }

    public static boolean checkDouble(int num) {
        // 判断输入的数是否为0、正整数或负整数
        if (num == 0 || Math.abs(num) != num) {
            return false;
        }
        String str = String.valueOf(num);
        int len = str.length();
        // 判断字符串长度是否大于1
        if (len == 1) {
            return true;
        }
        // 利用Java中的字符串方法substring来截取字符串的最后一位及其前面的数字，
        // 并将这两个数字转换成Integer类型的整数，组合成第一位是最后一位的整数
        int last = Integer.parseInt(str.substring(len - 1));
        int first = Integer.parseInt(str.substring(0, len - 1));
        int newNum = last * (int)Math.pow(10, len - 1) + first;
        // 判断新生成的整数是否是原数的2倍，如果是，则返回true，否则返回false
        return newNum == num * 2;
    }
}

    以上就是该问题的具体解决方案。


import org.junit.jupiter.api.Test;

public class Tests {

    @Test
    public void test() {
        // 有一个整数,将该数的最后一位移到第一位,则新的整数变成原数的二倍,求该数

        // 最后一位小于2的舍弃

        // 倒数第二位是奇数舍弃

        // 小于10 舍弃

        // 算法:

        // 当数为两位,记为xy, 则: xy = x*10+y
        // 反转为yx, 则: yx = y*10+x
        // 10y+x = 20x+2y
        // 10y=19x
        // y/x = 19/10 无解

        // 以此类推, 当数为n位, 记为m, 每位记为n1,n2...

        // 则 m=n1+n2*10*(2-1)+n3*10*(3-1)+...+nn*10*(n-1)

        // 取反的2m

        // 则 2m = n1*10*(n-1) + n2*10*(2-2) + n3*10*(3-2) + ... + n(n-1)*10*(n-2)

        // 则 m = n1*5*(n-1) + n2*5*(2-2) + n3*5*(3-2) + ... + n(n-1)*5*(n-2)

        // 则 n1*5*(n-1) + n2*5*(2-2) + n3*5*(3-2) + ... + n(n-1)*5*(n-2) = n1+n2*10*(2-1)+n3*10*(3-1)+...+n(n-1)*10*(n-2)+nn*10*(n-1)

        // 则 n1*5*(n-1) = n1+ 5*n2+5*n3+...+5*n(n-1) + 10*nn*(n-1)

        // 则 好像错了, 太难弄了, 代数吧.

        // 假如: n=2 n2n1
        // 10n2=9n1 无解


        // 假如n=3 n3n2n1

        // m = n1+10n2+100*n3
        // 2m = n1n3n2 = 100n1+10n3+n2
        // 2n1+20n2+200n3 = 100n1+10n3+n2
        // 19n2+190n3 = 98n1


        // 假如n=4 n4n3n2n1

        // m = n1+10n2+100n3+1000n4

        // 2m = n1n4n2n2 = 1000n1+100n4+10n3+n2

        // 2n1+20n2+200n3+2000n4 = 1000n1+100n4+10n3+n2

        // 19n2+190n3+1900n4 = 998n1 和上述同样结论, 因此

        // 以此类推发现 右边永远为偶数, 因此唯一可以相等的在n2身上, 因此n2只能为 2,4,6,8, n1=2,3,4,6,7,8,9

        // n1,n2 已确定范围, 要解决如何快速的筛数

        // 再次总结发现:  n2=2 时, n1=4,9
        //              n2=4 , n1=3,8
        //              n2=6, n1=2,7
        //              n3=8, n1=6

        // 程序如下:

        // 循环到最大值的一半
        for (long i=12;i<Long.MAX_VALUE/2;i++){
            String s = String.valueOf(i);
            char[] chars = s.toCharArray();
            char n2 = chars[chars.length-2];
            char n1 = chars[chars.length-1];
            if (isNeedCheck(n1,n2)&&isNeeded(i,s,n1)) {
                System.out.println("数已找到: "+ i);
                return;
            }
        }
    }

    /**
     * 需要检查的数
     * @param n1
     * @param n2
     * @return
     */
    public boolean isNeedCheck(char n1, char n2){
        if (n2=='2'){
            return n1=='4'||n1=='9';
        }
        if (n2=='4'){
            return n1=='3'||n1=='8';
        }
        if (n2=='6'){
            return n1=='2'||n1=='7';
        }
        if (n2=='8'){
            return n1=='6';
        }
        return false;
    }

    /**
     * 是需要的数
     * @param i
     * @param s
     * @param n1
     * @return
     */
    public boolean isNeeded(long i,String s,char n1){
        long j = Long.parseLong(n1+s.substring(0,s.length()-1));
        return j==2*i;
    }

    @Test
    public void test1(){
        long i = 105263157894736842L;
        String s = "105263157894736842";
        char n1 = '2';
        System.out.println(isNeeded(i,s,n1));
    }
}

谁能优化下代码, 有人解出来了, 我这个程序跑了半天1分钟没出结果

乘以10就是左移，整除10就是右移。

public class Main {
    public static void main(String[] args) {
        int i = 11;
        while (true) {
            if (yd(i) == 2 * i) {
                break;
            }
            i++;
        }
        System.out.println(i);
    }
 
    public static int yd(int x) {
        if (x <= 0) {
            return x;
        }
 
        int lastDigit = x % 10;
        int newX = x / 10;
        int temp = lastDigit;
 
        while (newX != 0) {
            temp *= 10;
            newX /= 10;
        }
 
        return temp + x / 10;
    }
}