精华内容
下载资源
问答
  • Java回文

    2020-10-26 23:29:08
    标题Java回文数 回文数介绍: 设n是一任意自然数。若将n的各位数字反向排列所得自然数n1与n相等,则称n为一回文数。例如,若n=1234321,则称n为一回文数;但若n=1234567,则n不是回文数。 1.偶数个的数字也有回文...

    标题Java回文数

    回文数介绍:

    设n是一任意自然数。若将n的各位数字反向排列所得自然数n1与n相等,则称n为一回文数。例如,若n=1234321,则称n为一回文数;但若n=1234567,则n不是回文数。

    1.偶数个的数字也有回文数124421
    2.小数没有回文数**

    1千以内的回文数,在自然数!!!中,最小的回文数是0!!! 其次1,2,3,4,5,6,7,8,9,!!!11,22,33,44,55,66,77,88,99,101,111,121,131,141,151,161,171,181,191,202,212,222,232,242,252,262,272,282,292,303,313,323,333,343,353,363,373,383,393,404,414,424,434,444,454,464,474,484,494,505,515,525,535,545,555,565,575,585,595,606,616,626,636,646,656,666,676,686,696,707,717,727,737,747,757,767,777,787,797,808,818,828,838,848,858,868,878,888,898,909,919,929,939,949,959,969,979,989,999.

    平方回数:
    定义:一个回文数,它同时还是某一个数的平方,这样的数字叫做平方回数。例如:121。
    100以上至1000以内的平方回数只有3个,分别是:121、484、676。
    其中,121是11的平方。
    484是22的平方,同时还是121的4倍。
    676是26的平方,同时还是169的4倍。

    回文数算法:
    随意找一个十进制的数,把它倒过来成另一个数,再把这两个数相加,得一个和数,这是第一步;然后把这个和数倒过来,与原来的和数相加,又得到一个新的和数,这是第二步。照此方法,一步步接续往下算,直到出现一个“回文数”为n。例如:28+82=110,110+011=121,两步就得出了一个“回文数”。如果接着算下去,还会得到更多的“回文数”。这个过程称为“196算法”。

    个人求、判断回文数 算法
    从零开始遍历每一个数字,正序为第一个参数,和逆序相加之后除以二,得到结果为第二个参数,如果第一个参数等于等于第二个参数,说明该数字正序等于逆序,即说明该数字(正序或者逆序)是回文数。

    算了,个人脑子不好使。都逆序了,,直接跟正序比较相不相等不就得了吗,还相加作甚了🤣🤣😥😥

    Java代码:

    
    JAVA源程序:
    
    import java.util.*;
    public class Main{
    
    	public static void main(String[]args){
    	Scanner sc=new Scanner(System.in);
    	int a;
    	while(sc.hasNext())
    		{	
    		int a=new Scanner(System.in).nextInt();
    		isPlalindrome(a);
    		System.out.print((isPlalindrome(a)?"Yes ":"Not")+" ");
    		}	
    		sc.close();
    	}	
    	public	static	boolean	isPlalindrome(int b)
    	{
    	String	num=String.valueOf(b);
    	return	new	StringBuffer(num).reverse().toString().equalsIgnoreCase(num);
    			//返回字符串类型的逆序数,并与原数字比较大小。  
    	}
    	
    }
    
    

    运行结果:

    在这里插入图片描述

    很奇怪!!!为什么输入的第一个数!!!永远都没有输出!!!代码过程应该对第一个数进行了代码运行!!!请(希望😭/(ㄒoㄒ)/!)有会的同学或者大佬告知一下,,是不是这个程序哪里的漏洞 或者错误!!!

    判断是否为回文数 Java代码:

    可以直接对输入的数值进行操作
    
    import java.util.*;
    
    public class Main {
    
         public static void main(String[] args) {
         Scanner sc=new Scanner(System.in);
         while(sc.hasNext()) 
         {
          int n=sc.nextInt();
          int originalInteger = n;   
          int remainder ,reversedInteger = 0;     
          while( n!=0 )
          {
              remainder = n%10;	          
              reversedInteger = reversedInteger*10 + remainder;          
              n /= 10;
          }
          
          if (originalInteger == reversedInteger)
        	  System.out.println("isPlalindrome	  Yes  "+ originalInteger);
          else
        	  System.out.println(" isNotPlalindrome	  Not  "+ originalInteger);     
         } 
         sc.close();    
         }    
    }
    
    
    

    运行结果:
    在这里插入图片描述

    
    使用字符串进行判断:
    import java.util.*;
    
    public class Main{
    
     	public static void main(String args[]) {
      	Scanner sc=new Scanner(System.in);
    	int in=sc.nextInt();   
      	String str=in+" ";
      	int low=0;
      	int high=str.length()-1;
      	boolean isPalindrome=true;
      	while(low<high) 
      	{
    	   	if(str.charAt(low)!=str.charAt(high))
       		{
        	isPalindrome=false;
        	break;
      	 	}
       		low++;
      	 	high--;
      }
      if(isPalindrome) 
       		System.out.printf("Y");
      else
        	System.out.printf("N");   
    	}
    }
    

    StringBuffer 类型比较大小 是否使用toString() 方法 的区别:

    代码测试如下:

    import java.util.Scanner;
    public class Main {
    
         public static void main(String[] args) {
             StringBuffer strb1 = new StringBuffer("Java");		// 创建StringBuffer对象str1
             StringBuffer strb2 = new StringBuffer("Java");		// 创建StringBuffer对象str2
             
            System.out.println("****不使用toString()方法****");
            
             if (strb1.equals(strb2)) 
             {
                 System.out.println("相等");
             }else 
             {
                 System.out.println("不相等");
             }
             
             System.out.println("****使用toString()方法****");
             
             if (strb1.toString().equals(strb2.toString())) 
             {
                 System.out.println("相等");
             } else 
             {
                 System.out.println("不相等");
             }
             
         }
    }
    

    运行代码及结果:
    在这里插入图片描述
    在这里插入图片描述

    所以如何比较StringBuffer字符串内容是否相等呢?可以使用toString() 方法将StringBuffer的内容转换为String 字符串,再使用equals()方法比较。

    if (a.toString().equals(b.toString())) 
    		  {
                 System.out.println("相等//Yes");
              } 
             else 
              {
                 System.out.println("不相等//Not");
              }
    

    END

    展开全文
  • java回文

    2012-11-01 13:26:10
    程序开始时,弹出文件框,输入字符串,然后判断输入的字符串是不是回文串。程序结束时弹出文本框显示结果。
  • java回文数的判断方法

    2020-06-06 17:06:01
    判断是否是回文数 import java.util.*; public class Yanjiu2 { public static void main(String [] args){ Scanner sc = new Scanner(System.in); System.out.println("请输入整型数:"); int a = sc.nextInt()...

    判断是否是回文数

    import java.util.*;
    public class Yanjiu2 {
        public static void main(String [] args){
            Scanner sc = new Scanner(System.in);
            System.out.println("请输入整型数:");
            int a = sc.nextInt();
            System.out.println("--------------------------------");
            String b = a+"";
            String c = new StringBuffer(b).reverse().toString();//反转;
            System.out.println("倒序前:"+b);
            System.out.println("倒叙后:"+c);
            boolean e = b.equals(c);
            if(e)
                System.out.println(a+"是回文数");
            else
                System.out.println(a+"不是回文数");
        }
    }
    
    展开全文
  • java回文

    2019-10-07 22:11:12
    应用递归的思想,第几个和倒数第几个是否相同,如果不同则不是回文,如果相等继续看第n+1,倒数n-1如果相等就是回文函数类型用布尔型。。。。 package Ketang;import java.util.Scanner;public class Work { ...

    应用递归的思想,第几个和倒数第几个是否相同,如果不同则不是回文,如果相等继续看第n+1,倒数n-1如果相等就是回文函数类型用布尔型。。。。

     

     

     

    package Ketang;
    import java.util.Scanner;
    public class Work {

        public static boolean digui(String str1,int i,int j) {
            
            if(j==1||j==0) {
                return true;
            }
            else {
                if(str1.charAt(i)==str1.charAt(j)) {
                    return digui(str1,++i,--j);
                }
                else {
                    return false;
                }
            }
                
        }//end digui
        public static void main(String[] args) {
            Scanner sca=new Scanner(System.in);
            boolean bool;
            String str;
            str=sca.next();
            int i=0;
            int j=str.length()-1;
            bool=digui(str,i,j);
            if(bool==true) {
                System.out.println(str+" 是回文!");
            }
            else {
                System.out.println(str+" 不是回文");
            }

            
            
        }//end main
    }//end Work

    转载于:https://www.cnblogs.com/wwbzuiku/p/11586265.html

    展开全文
  • Java回文数的判断

    2020-11-22 10:57:28
    * 判断是否为回文字符串 * @author Administrator */ public class HuiWen { public static void main(String[] args) { System.out.println(f1("12321")); System.out.println(f2("abcba"));

    Java中回文数的判断

    1.字符串回文数判断

    package com.wyw;
    
    import java.util.Stack;
    
    /**
     * 判断是否为回文字符串
     * @author Administrator
     */
    public class HuiWen {
        public static void main(String[] args) {
            System.out.println(f1("12321"));
            System.out.println(f2("abcba"));
            System.out.println(f3("Aa           bcb aA "));
        }
    
        /**
         * 通过数组的方式进行判断
         * 1.创建两个大小为字符串长度大小的数组
         * 2.对字符串转变为数组
         * 3.把久数组的值放入新数组中
         * 4.进行两个数组的判断
         * 注意:字符串有length()方法,而数组有length属性。
         * @param target
         * @return
         */
        private static boolean f1(String target) {
            char[] str = new char[target.length()];
            char[] newStr = new char[target.length()];
            target.getChars(0,target.length(),str,0);
            for (int i = 0; i < str.length; i++) {
                newStr[i] = str[str.length - 1 -i];
            }
            for (int i = 0; i < str.length; i++) {
                if (str[i] != newStr[i]) {
                    return false;
                }
            }
            return true;
        }
    
        /**
         * 通过栈的方式进行回文数判断
         * 1.首先创建一个栈
         * 2.对栈进行入栈,然后出栈
         * 3.进行判断
         * @param target
         * @return
         */
        public static boolean f2(String target) {
            Stack<Character> stack = new Stack<>();
            for (int i = 0; i < target.length(); i++) {
                stack.push(target.charAt(i));
                //System.out.println(target.charAt(i));
            }
            for (int i = 0; i < target.length(); i++) {
                Character character = stack.pop();
                if (character != target.charAt(i)) {
                    return false;
                }
            }
            return true;
        }
    
        /**
         * 通过指针的方式进行回文数判断
         * 1.首先去除输入字符串的空格,以及使所有的字符变成小写
         * 2.创建两个指针,一个头指针,一个尾指针
         * 3.进行判断
         * @param target
         * @return
         */
    
        public static boolean f3(String target) {
            String newTarget = target.replaceAll(" ","").toLowerCase();
            System.out.println(newTarget);
            int preIndex = -1;
            int lastIndex = newTarget.length();
            for (int i = 0; i < newTarget.length()/2; i++) {
                preIndex++;
                lastIndex--;
                if (newTarget.charAt(preIndex) != newTarget.charAt(lastIndex)) {
                    return false;
                }
            }
            return true;
        }
    }
    
    

    2.链表回文数判断

    package com.wyw;
    
    import javax.print.attribute.standard.NumberUp;
    import java.util.Stack;
    
    /**
     * 判断是否为回文
     * @author Administrator
     */
    public class LinkedHuiWen {
        public static void main(String[] args) {
           Node head = new Node('a');
           Node b1 = new Node('b');
           Node b2 = new Node('a');
           Node b3 = new Node('b');
           Node b4 = new Node('a');
    
           head.next = b1;
           b1.next = b2;
           b2.next = b3;
           b3.next = b4;
    
           System.out.println(f2(head));
        }
    
        /**
         * 1.首先使用栈进行入栈
         * 2.进行出栈,并做比较
         * @param head
         * @return
         */
        static boolean f1(Node head) {
            Node ref = head;
            Stack<Character> stack = new Stack<>();
            while (ref != null){
                stack.push(ref.data);
                ref = ref.next;
            }
    
            ref = head;
            while (ref != null) {
                Character pop = stack.pop();
                if (pop != ref.data) {
                    return false;
                }
                ref = ref.next;
            }
            return true;
        }
    
        /**
         * 使用快慢指针来解决这个回文
         * @param head
         * @return
         */
        public static boolean f2(Node head) {
            // 快指针一次走两步
            Node q = head;
            // 慢指针一次走一步
            Node s = head;
            while (q != null && q.next !=null) {
                q = q.next.next;
                s = s.next;
            }
            q = s;
            
            // 链表的原地反转
            Node temp = new Node(s.data);
            temp.next = s.next;
    
            while (temp.next != null) {
                Node pre = s;
                s = temp.next;
                temp.data = s.data;
                temp.next = s.next;
                s.next = pre;
            }
    
            q.next = null;
            q = head;
            while (q.next != null) {
                if (q.data != s.data) {
                    return false;
                }
                q = q.next;
                s = s.next;
            }
            return true;
        }
    
        static class Node {
            public char data;
            public Node next;
    
            public Node(char data) {
                this.data = data;
            }
        }
    }
    
    

    3.双指针(Two Pointers)

    在这里插入图片描述

    3.1 同向指针

    在这里插入图片描述
    在这里插入图片描述
    在这里插入图片描述

    在这里插入图片描述

    public static int removeDuplicates(int[] nums) {
        // 1 2 2 2 3 4 5
        int i = 0, j = 0;
        while (j < nums.length) {
            if (i == 0 || nums[j] != nums[i - 1]) {
                nums[i] = nums[j];
                i++;
                j++;
            } else {
                j++;
            }
        }
        return i;
    }
    

    3.2 反向指针

    在这里插入图片描述

    编写一个函数,其作用是将输入的字符串反转过来。输入字符串以字符数组 char[] 的形式给出。
    不要给另外的数组分配额外的空间,你必须原地修改输入数组、使用 O(1) 的额外空间解决这一问题。 你可以假设数组中的所有字符都是 ASCII
    码表中的可打印字符。

    示例 1:

    输入:["h","e","l","l","o"]
    输出:["o","l","l","e","h"]
    

    示例 2:

    输入:["H","a","n","n","a","h"]
    输出:["h","a","n","n","a","H"]
    

    在这里插入图片描述
    在这里插入图片描述

      public  static void reverseString(char[] s) {
            int i = 0 , j = s.length - 1;
            while (i < j) {
                char temp = s[i];
                s[i] = s[j];
                s[j] = temp;
                i++;
                j--;
            }
            System.out.println(Arrays.toString(s));
        }
    
    展开全文
  • java回文整数

    2014-04-20 16:34:44
    使用方法输入一个数,判断是否为回文数列!
  • java回文数判断

    千次阅读 2019-07-30 16:08:19
    java简单算法实现回文数判断
  • 主要介绍了java 实现判断回文数字的实例代码的相关资料,需要的朋友可以参考下
  • Java回文判断

    2012-12-08 11:28:15
    java回文的实列,方便初学者快速掌握以及更好的理解Java回文的编写要点
  • Java 回文

    2021-04-06 21:18:14
    所谓“回文数”是指具有如下性质的整数:一个整数,当它的各位数字逆序排列,形成的整数与原整数相同,这样的数称为回文数。例如,素数11,373,其各位数字对换位置后仍然为11,373,因此这两个整数均为回文数。编写...
  • Java回文链表

    2019-10-14 12:35:20
    题目:请判断一个链表是否为回文链表。 示例 1: 输入: [1,2] 输出: false 示例 2: 输入: [1,2,2,1] 输出: true 示例3: 输入[1,2,2,3] 输出:false 使用方法:将链表保存到数组中,按照数组回文判断方式进行判断 ...
  • *** 判断一个整数是否是回文数。回文数是指正序(从左向右)和倒序(从右向左)读都是一样的整数。** * 示例 1: 输入: 121 输出: true 示例 2: 输入: -121 输出: false 解释: 从左向右读, 为 -121 。 从右向左读, ...
  • 可以发现中间的数就一直在中间,回文数判断只需要判断第一位与后一位 ,第二位与倒数第二位相对就行了 public static void main(String[] args) { int a=0,b=0,c=0,d=0; int f=10000; while(f<100000){ a=f/...
  • Java回文小程序

    2012-04-15 15:23:52
    输入:java 输出:ava 部分代码: try{ String str=textField.getText(); int num = str.length(); for(int i=0;i;i++){ char c=str.charAt(i); for(int j=i+1;j;j++){ char d=str.charAt(j); if(c==d){ ...
  • java 回文数(1-9999)

    2009-10-26 20:21:56
    编写一个java应用程序。用户从键盘输入一个1-9999之间的数,程序将判断这个数是几位数,并判断这个数是否回文数。回文数是指将数含有的数字逆序排列后得到的数和原数相同,例如12121,4224,6778776等都是回文数。
  • Java中判断回文数 1、什么是回文数呢? 就是这样的数字12321、11111、63936这样正着读和反着读都是一样的数字就叫做回文数。 2、要明白两种运算 :/和% /:相除运算,在这里要注意的是两个整数之间相处的话得到的...
  • java 回文判断——java程序设计 import java.util.Scanner; public class huiwen { public static void main(String[] args) { Scanner in=new Scanner(System.in); //输入定义 String s,d; s=in.next(); //...
  • java回文的要领

    2021-04-02 19:39:17
    java回文需要用到split方法 方法的原型为 public String[] Split(String regex,int limit) regex分隔的符号 limit为分隔开的个数 下面来一个实例 import java.util.Scanner; public class Demo2 { public ...
  • java 回文数代码下载

    2011-06-11 20:17:19
    public static void main(String[] args) { int flag=0; String s=""; for(int i=10;i;i++){ s=""; s=s+i; flag=0; for(int j=0;j()/2;j++){ if(s.charAt(j)!=s.charAt(s.length()-j-1)) ...}
  • Java 回文串判定

    2020-02-02 12:09:35
    回文串是指从左到右读和从右到左读是一样的。也就是说字符串和它翻转后的结果是相同的。 代码如下: public class 回文串判定 { public static void main(String[] args){ String str = "abcba"; System.out....
  • java回文算法

    2019-10-06 14:16:24
    1987891这个就是回文,判断“1987891”是不是回文? 1 public static boolean isPalindrome(String str) { return str.equals( new StringBuilder(str) .reverse() .toString() ); } ...
  • java回文

    2020-09-25 13:32:10
    //判断一个整数是否是回文数 public class Day_5 { //解法一:将整数反转,相等即为回文数 public boolean isPalindrome(int x) { int temp =x; int result = 0; // 特殊情况 if (x < 0) return false; ...
  • leetcode-java 回文链表

    2019-11-28 19:34:41
    回文链表 题目描述: leetcode 234.回文链表 请判断一个链表是否为回文链表。 示例 1: 输入: 1->2 输出: false 示例 2: 输入: 1->2->2->1 输出: true 进阶: 你能否用 O(n) 时间复杂度和 O(1) 空间...
  • java 回文的判断

    2009-06-17 19:43:06
    这是课堂上自己编写的判断回文的小程序,其中包括了标点符号,以及最后一个字符为空格的情况
  • 在本篇文章里小编给各位整理的是一篇关于Java判断字符串回文的代码实例内容,需要的朋友们可以跟着学习参考下。
  • java回文串的判断

    2013-11-05 10:22:55
    可以判断回文串。可以忽略大小写和逗号句号等问题。并且以框体的形式显示
  • java 回文

    2020-03-04 15:37:13
    判断一个整数是否是回文数。回文数是指正序(从左向右)和倒序(从右向左)读都是一样的整数。 示例 1: 输入: 121 输出: true 示例2: 输入: -121 输出: false 解释: 从左向右读, 为 -121 。 从右向左读, 为 121- ...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 21,955
精华内容 8,782
关键字:

java回文

java 订阅