精华内容
下载资源
问答
  • 判断一个整数是否是回文数回文数是指正序(从左向右)和倒序(从右向左)读都是一样的整数。 示例 1: 输入: 121 输出: true 示例 2: 输入: -121 输出: false LeetCode链接 解题思路 使用python解决非常简单 ...

    题目描述

    判断一个整数是否是回文数。回文数是指正序(从左向右)和倒序(从右向左)读都是一样的整数。

    示例 1:

    输入: 121
    输出: true

    示例 2:

    输入: -121 输出: false

    LeetCode链接

    解题思路

    使用python解决非常简单

    • 首先将数组转为字符串
    • 两个指针,一个从左往右遍历字符串,一个从右往左遍历,如果遇到两个不相等的情况,则不为回文数,直到两个指针相等

    代码实现

    class Solution:
        def isPalindrome(self, x: int) -> bool:
            s=str(x)
            l,r=0,s.__len__()-1
            while(l<=r):
                if s[l]==s[r]:
                    l+=1
                    r-=1
                else:return False
            return True
    
    展开全文
  • LeetCode回文数Python) 题目 :判断一个整数是否是回文数回文数是指正序(从左向右)和倒序(从右向左)读都是一样的整数。 示例 1: 输入: 121 输出: true 示例 2: 输入: -121 输出: false 解释: 从左向右读,...

    LeetCode回文数(Python)

    题目 :判断一个整数是否是回文数。回文数是指正序(从左向右)和倒序(从右向左)读都是一样的整数。

    示例 1:
    
    输入: 121
    输出: true
    示例 2:
    
    输入: -121
    输出: false
    解释: 从左向右读, 为 -121 。 从右向左读, 为 121- 。因此它不是一个回文数。
    示例 3:
    
    输入: 10
    输出: false
    解释: 从右向左读, 为 01 。因此它不是一个回文数。
    进阶:
    
    你能不将整数转为字符串来解决这个问题吗?
    
    class Solution(object):
        def isPalindrome(self,x):
            """
            :type x: int
            :rtype: bool
            """
            a = str(x)
            if a[0] != '-':
                b = a[::-1]
                if a ==  b:
                    return true
                else :
                    return false
            else:
                return false
    

    后来又看到了别人的一行代码。

    class Solution(object):
    	  def isPalindrome(self,x):
         	  return str(x)==str(x)[::-1]
    
    展开全文
  • Python回文数判断

    2021-01-29 14:16:42
    Python回文数判断 我们先来了解一下什么事回文数字,回文数字是指正着读和倒着读都能读的通的数字,那么我们怎么用Python判断1-1000的数字里面有多少回文数呢? l = [i for i in range(1,10001) if str(i) == str(i)...

    Python回文数判断

    我们先来了解一下什么事回文数字,回文数字是指正着读和倒着读都能读的通的数字,那么我们怎么用Python判断1-1000的数字里面有多少回文数呢?

    l = [i for i in range(1,1001) if str(i) == str(i)[::-1]]
    
    展开全文
  • 所谓回文字符串,就是正读和反读都一样的字符串,比如...判断回文字符串 方法一: def is_palindrome(s): return True if s == s[::-1] else False 方法二: def is_palindrome(s): length = len(s) if not leng...

    所谓回文字符串,就是正读和反读都一样的字符串,比如“level”或者“noon”等等就是回文串。即是对称结构

    判断回文字符串

    方法一:

    def is_palindrome(s):
        return True if s == s[::-1] else False

    方法二:

    def is_palindrome(s):
        length = len(s)
        if not length:  # 空字符串
            return True
        mid_index = length // 2  # 如果s长度为奇数则是中点,偶数则是后面那个中点
        index = 0
        status = True
        while index < mid_index:
            if s[index] == s[length - 1 - index]:
                index += 1
            else:
                status = False
                break
        return status
    

    判断回文链表

    思路

    1. 我们需要找到链表中点(快慢指针法)
    2. 将链表后半段倒置逆序排序
    3. 将前半段和后半段遍历比较,判断是否为回文链表,偶数情况,使用偶数定位中点策略,要确定是返回上中位数或下中位数

    注意事项:

    快慢指针定位中点时要区分奇偶情况,奇数情况,中点位置不需要矫正,偶数情况,使用偶数定位中点策略,要确定是返回上中位数或下中位数
    如果是返回上中位数,后半部分串头取next,如果是返回下中位数,后半部分串头既是当前节点位置,但前半部分串尾要删除掉当前节点

    代码

    class Solution(object):
        def is_palindrome(self, head: ListNode) -> bool:
            if head is None:  # 空
                return False
            if head.next is None:  # 1个节点
                return True
            slow = fast = head
    
            # 1. 定中点
            while fast and fast.next:
                slow = slow.next
                fast = fast.next.next
            # 快慢指针定位中点,此时fast已到达链尾,如果长度为奇数,则slow到达中心点,长度为偶数,则slow到达下中位点
    
            # 2. 后半段倒置
    
            pre = None  # 倒置后的最后一个节点必为None,以此确定第三步遍历时的终点
            cur = slow  # 当前要倒置的第一个节点
            nxt = slow.next  # 当前要倒置的节点的下一个节点
    
            while nxt:  # 只要没有到达原链表的终点就一直进行倒置
    
                cur.next = pre  # 将当前节点的下一个节点指向"前"一个节点,进行倒置
    
                # 相邻节点倒置完成后,向后整体偏移1个单位
    
                pre = cur
                cur = nxt
                nxt = cur.next
    
            # 当前cur是最后一个节点,需要和它前面的节点进行最后一次倒置,来完成整个后半段倒置
    
            cur.next = pre
    
            # 3. cur就是倒置完成后的后半段的头节点,同时遍历cur和head,如果遍历完cur未出现不同的节点,则为回文链表
    
            while cur.next:
                if cur.val != head.val:
                    return False
                cur = cur.next
                head = head.next
            # 此时cur为后半段的最后一个节点,还需要判断此时的cur和head的值是否相同
    
            return cur.val == head.val

    测试

    # head =None
    head = ListNode(1)
    head.next = ListNode(2)
    head.next.next = ListNode(1)
    
    print(Solution().is_palindrome(head))

    判断回文数

    思路

    映入脑海的第一个想法是将数字转换为字符串,并检查字符串是否为回文。但是,这需要额外的非常量空间来创建问题描述中所不允许的字符串。

    第二个想法是将数字本身反转,然后将反转后的数字与原始数字进行比较,如果它们是相同的,那么这个数字就是回文。 但是,如果反转后的数字大于 int.MAX,我们将遇到整数溢出问题。

    按照第二个想法,为了避免数字反转可能导致的溢出问题,为什么不考虑只反转int 数字的一半?毕竟,如果该数字是回文,其后半部分反转后应该与原始数字的前半部分相同。

    例如,输入 1221,我们可以将数字“1221”的后半部分从“21”反转为“12”,并将其与前半部分“12”进行比较,因为二者相同,我们得知数字 1221 是回文。

    让我们看看如何将这个想法转化为一个算法。

    算法

    首先,我们应该处理一些临界情况。所有负数都不可能是回文,例如:-123 不是回文,因为 - 不等于 3。所以我们可以对所有负数返回 false。

    现在,让我们来考虑如何反转后半部分的数字。 对于数字 1221,如果执行 1221 % 10,我们将得到最后一位数字 1,要得到倒数第二位数字,我们可以先通过除以 10 把最后一位数字从 1221 中移除,1221 / 10 = 122,再求出上一步结果除以10的余数,122 % 10 = 2,就可以得到倒数第二位数字。如果我们把最后一位数字乘以10,再加上倒数第二位数字,1 * 10 + 2 = 12,就得到了我们想要的反转后的数字。 如果继续这个过程,我们将得到更多位数的反转数字。

    现在的问题是,我们如何知道反转数字的位数已经达到原始数字位数的一半?

    我们将原始数字除以 10,然后给反转后的数字乘上 10,所以,当原始数字小于反转后的数字时,就意味着我们已经处理了一半位数的数字。

    代码

    
    class Solution(object):
        def is_palindrome(self, num: int) -> bool:
    
            # 当 x < 0 时,x 不是回文数
            # 如果数字的最后一位是 0,为了使该数字为回文,则其第一位数字也应该是 0
            # 只有 0 满足这一属性
            if num < 0 or (num % 10 == 0 and num != 0):
                return False
    
            reverted_num = 0
    
            while num > reverted_num:
                reverted_num = reverted_num * 10 + num % 10
                num /= 10
    
            # 当数字长度为奇数时,我们可以通过 revertedNumber / 10 去除处于中位的数字。
            #  例如,当输入为12321时,在 while 循环的末尾我们可以得到 x = 12,revertedNumber = 123,
            #  由于处于中位的数字不影响回文(它总是与自己相等),所以我们可以简单地将其去除。
            return num == reverted_num or num == reverted_num / 10
    
    # 测试
    print(Solution().is_palindrome(0))
    print(Solution().is_palindrome(10))
    print(Solution().is_palindrome(101))

    转载于:https://www.cnblogs.com/huchong/p/10499518.html

    展开全文
  • 力扣 回文数-python

    2021-01-27 18:38:20
    题目:判断一个整数是否是回文数回文数是指正序(从左向右)和倒序(从右向左)读都是一样的整数。 示例 1: 输入: 121 输出: true 示例 2: 输入: -121 输出: false 解释: 从左向右读, 为 -121 。 从右向左读, 为 ...
  • 这也算是一道经典的题目了,判断一个数是否是一个回文数,何为回文数,即从左往右读和从右往左读都一样。这里我的思路是把这个数从两端遍历,判断其是否相等,若有一位不相等,则这个数就不是回文数。 我这里用的是...
  • 回文数python练习)题目+思路题目思路代码实现(学习了官方的解法,减少了1半的时间)补充:字符串的操作实现 以下解题思路,仅表示个人做题思路或引荐别人的方法——如有引用我会标注出来的 题目+思路 题目 判断...
  • 9 - 回文数 - python

    2020-03-30 12:56:58
    判断一个整数是否是回文数回文数是指正序(从左向右)和倒序(从右向左)读都是一样的整数。 示例 1: 输入: 121 输出: true 示例 2: 输入: -121 输出: false 解释: 从左向右读, 为 -121 。 从右向左读, 为 121- ...
  • 判断一个整数是否是回文数回文数是指正序(从左向右)和倒序(从右向左)读都是一样的整数。 示例 1: 输入: 121 输出: true 示例 2: 输入: -121 输出: false 解释: 从左向右读, 为 -121 。 从右向左读, 为 121-...
  • 回文数Python实现)

    2019-08-25 21:20:31
    判断一个整数是否是回文数回文数是指正序(从左向右)和倒序(从右向左)读都是一样的整数。 示例 1: 输入: 121 输出: true 示例 2: 输入: -121 输出: false 解释: 从左向右读, 为 -121 。 从右向左读, 为 ...
  • 回文数,即 12321,就是一个回文数 def judge_repeat_num(num): num_t = num num_p = 0 while num != 0: num_p = num_p * 10 + num % 10 num = num // 10 if num_t == num_p: p...
  • 回文数-python3

    2019-03-11 13:08:50
    判断输入的正整数是不是回文数 回文数是指将一个正整数从左往右排列和从右往左排列值一样的数 例如: 121, 123454321 Version: 1.0.0 Author: Catherine Data: 2019-03-11 """ num = int(input(&...
  • 二话不说,直接上代码: 1 class Solution(object): 2 def isPalindrome(self, x): 3 """ 4 :type x: int 5 :rtype: bool 6 """ 7 x2 = str(x) 8 if x2 ==...
  • 9. 回文数Python

    2020-06-10 01:33:30
    LeetCode今天的每日一题(2020-06-10)如下,判断一个数字是否是回文数。传送门 注意题目的最后又一个进阶提示:你能不将整数转为字符串来解决这个问题吗?。也就是说你可以把数字先转为字符串,然后通过判断这个字符...
  • 9. 回文数python)

    千次阅读 2019-01-21 17:53:02
    判断一个整数是否是回文数回文数是指正序(从左向右)和倒序(从右向左)读都是一样的整数。 示例 1: 输入: 121 输出: true 示例 2: 输入: -121 输出: false 解释: 从左向右读, 为 -121 。 从右向左读, 为 121- 。...
  • 判断一个整数是否是回文数回文数是指正序(从左向右)和倒序(从右向左)读都是一样的整数。 示例 1: 输入: 121 输出: true 示例&nbsp;2: 输入: -121 输出: false 解释: 从左向右读, 为 -121 。 从右向左...
  • leetcode_回文数_python3

    2020-08-07 09:33:12
    判断一个整数是否是回文数,如果一个整数,正读和反读相同时,它就是回文数。 你可以假设每种输入只会对应一个答案。但是,你不能重复利用这个数组中同样的元素。 示例1: Input: 121 Output: true 示例2: Input: -...
  • 判断一个整数是否是回文数回文数是指正序(从左向右)和倒序(从右向左)读都是一样的整数。 示例 1: 输入: 121 输出: true 示例 2: 输入: -121 输出: false 解释: 从左向右读, 为 -121 。 从右向左读, 为 121- ...
  • LeetCode:9 回文数(python)

    2020-08-28 11:31:34
    判断一个整数是否是回文数回文数是指正序(从左向右)和倒序(从右向左)读都是一样的整数。 示例 1: 输入: 121 输出: true 示例 2: 输入: -121 输出: false 解释: 从左向右读, 为 -121 。 从右向左读, 为 121- 。...
  • 判断一个整数是否是回文数回文数是指正序(从左向右)和倒序(从右向左)读都是一样的整数。 示例 1: 输入: 121 输出: true 示例 2: 输入: -121 输出: false 解释: 从左向右读, 为 -121 。 从右向左读, 为 121- 。...
  • 判断一个整数是否是回文数回文数是指正序(从左向右)和倒序(从右向左)读都是一样的整数。 示例 1: 输入: 121 输出: true 示例 2: 输入: -121 输出: false 解释: 从左向右读, 为 -121 。 从右向左读, 为 121- 。...
  • 题目描述:判断一个整数是否是回文数回文数是指正序(从左向右)和倒序(从右向左)读都是一样的整数。 解答思想: 传入的x为整数形式,考虑到如果为负数,翻转都可能是非整数形式,所以直接对数做字符串化方便...
  • 判断一个整数是否是回文数回文数是指正序(从左向右)和倒序(从右向左)读都是一样的整数。 示例1: 输入: 121 输出: true 示例2: 输入: -121 输出: false 解释: 从左向右读, 为 -121 。 从右向左读, 为...
  • 判断一个整数是否是回文数回文数是指正序(从左向右)和倒序(从右向左)读都是一样的整数。 示例 1: 输入: 121 输出: true 示例 2: 输入: -121 输出: false 解释: 从左向右读, 为 -121 。 从右向左读, 为 121- 。...
  • 判断一个整数是否是回文数回文数是指正序(从左向右)和倒序(从右向左)读都是一样的整数。 示例1: 输入:121 输出:true 示例2: 输入:-121 输出:false 解释:从左向右读,为-121。从右向左读,为121-。因此...
  • LeetCode算法题——回文数python

    千次阅读 2018-06-04 20:58:55
    回文数:判断一个整数是否是回文数回文数是指正序(从左向右)和倒序(从右向左)读都是一样的整数。示例 1:输入: 121 输出: true 示例 2:输入: -121 输出: false 解释: 从左向右读, 为 -121 。 从右向左读, 为 ...
  • 回文数判断一个整数是否是回文数。回文数是指正序(从左向右)和倒序(从右向左)读都是一样的整数。进阶:第一种方法:将数字转为字符串,反转比较第二种方法(进阶):取余数,存列表,反转比较 判断一个整数是否是...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 597
精华内容 238
关键字:

回文数判断python

python 订阅