[28]Excel表列序号和Pow(x, n)

最新推荐文章于 2025-12-22 10:54:55 发布

原创最新推荐文章于 2025-12-22 10:54:55 发布 · 160 阅读

0 ·

CC 4.0 BY-SA版权

文章标签：

#excel #python

Tis 专栏收录该内容

27 篇文章

订阅专栏

文章讲述了如何将Excel表格的列标题转换为对应的列序号，以及如何高效地实现指数运算（Pow）。提供了两种不同的Python解决方案，包括正向计数和快速幂的方法，并对比了它们在处理复杂情况时的效率差异。

*内容来自leetcode

1.Excel表列序号

题目要求

给你一个字符串 columnTitle ，表示 Excel 表格中的列名称。返回该列名称对应的列序号。

例如：

A -> 1
B -> 2
C -> 3
...
Z -> 26
AA -> 27
AB -> 28
...

示例 1:

输入: columnTitle = "A"
输出: 1

示例 2:

输入: columnTitle = "AB"
输出: 28

提示：

1 <= columnTitle.length <= 7
columnTitle 仅由大写英文组成
columnTitle 在范围 ["A", "FXSHRXW"] 内

思路

不同长度的列名称所能表示的列的个数是可以算出来的，比如一个长度为1的列所能表达的列范围为1-26，长度为2的列所能表达的范围为27-26*26，以此类推。所以可以通过列名称的长度推断出当前长度能表示的列序号的起点，比如长度为3 的列名称表示序号的起点为"AAA"表示的26*26+1。然后再根据不同的字母进行累加，比如"ACA"就是在"AAA"的基础上加26*3，最终就可以得到最后的结果。

class Solution:
    def titleToNumber(self, columnTitle: str) -> int:
        n = len(columnTitle)
        res = 1
        minN = 1
        for i in range(1,n):
            minN *= 26
            res += minN

        for letter in columnTitle:
            dis = ord(letter) - ord('A')
            res += dis * minN
            minN //= 26
        return res

官方题解是正着直接进行计数的，称之为进制转化

class Solution:
    def titleToNumber(self, columnTitle: str) -> int:
        number, multiple = 0, 1
        for i in range(len(columnTitle) - 1, -1, -1):
            k = ord(columnTitle[i]) - ord("A") + 1
            number += k * multiple
            multiple *= 26
        return number

2.Pow(x, n)

题目要求

实现 pow(x, n) ，即计算 x 的整数 n 次幂函数（即，xn ）。

示例 1：

输入：x = 2.00000, n = 10
输出：1024.00000
示例 2：

输入：x = 2.10000, n = 3
输出：9.26100

思路

首先提醒，在python中有现成的对幂函数的实现，因此可以直接

return x ** n

具体实现来说，最为直观的思路就是通过循环来一次次的乘法来完成。

class Solution:
    def myPow(self, x: float, n: int) -> float:
        ans = 1
        if n == 0:
            return 1
        elif n > 0:
            while n > 0:
                ans *= x 
                n -= 1
        else:
            while n < 0 :
                ans *= (1/x)
                n += 1
        return ans

问题就在于在遇到一些比较复杂的例子的时候这种方法的时间超时。

所以就需要使用快速幂来实现，幂函数的计算过程如下

x→x2→x4→x8→x16→x32→x64

从直接算需要对x乘63次减为了6次。

具体实现来说，有迭代和递归两种方式

首先是迭代

class Solution:
    def myPow(self, x: float, n: int) -> float:
        if n == 0:
            return 1
        dd = n if n > 0 else -n
        res = 1
        while dd != 0:
            if dd % 2 != 0:
                res *= x
            x *= x
            dd //= 2
        return res if n > 0 else 1/res

递归

递归的实现是根据迭代的代码改的

class Solution:
    #递归
    def myPow(self, x: float, n: int) -> float:
        def getAns(x, dd, res):
            if dd == 0:
                return res
            if dd % 2 != 0:
                res *= x
            x *= x
            return getAns(x,dd//2,res)

        dd = n if n > 0 else -n
        ans = getAns(x,dd,1)
        
        return ans if n > 0 else 1/ans

官方的

class Solution:
    #递归
    def myPow(self, x: float, n: int) -> float:
        def getAns(N):
            if N == 0:
                return 1
            y = getAns(N//2)
            return y*y if N % 2 == 0 else y*y*x

        return getAns(n) if n > 0 else 1/getAns(-n)