Python：每日一题 49

badaoqingchen

冬雪雪冬 发表于 2017-5-20 21:55
我的理解，函数f需要2个参数x和y，但A只有一个元素，无法满足要求，所以直接返回A[0]了

那你用reduce函数的时候是怎么想的呀，因为‘A1’和上面那个情况是一样的

冬雪雪冬

badaoqingchen 发表于 2017-5-20 22:02
那你用reduce函数的时候是怎么想的呀，因为‘A1’和上面那个情况是一样的

以我的程序为例：

1. def spreadsheet(s):
   
2.     import re, functools
   
3.     if re.search(r'\dC', s):
   
4.         r, c = s.split('C')
   
5.         c = int(c)
   
6.         column = ''
   
7.         while c:
   
8.             c -= 1
   
9.             column = chr(c % 26 + 65) + column
   
10.             c //= 26
    
11.         return column + r[1:]
    
12.     else:
    
13.         c = re.search(r'\D+', s).group()
    
14.         r = re.search(r'\d+', s).group()
    
15.         c_lst =[ord(i) - 64 for i in c]
    
16.         c = functools.reduce(lambda x, y: x * 26 + y, c_lst)
    
17.         return 'R' + r + 'C' +  str(c)

复制代码

如果c只有一个字母，如"A"，则c_lst为[1]
reduce后，c=1
如果c有2个字母"AA", 则c-lst为[1, 1]
reduce后，c= 26*1 +1=27

badaoqingchen

冬雪雪冬 发表于 2017-5-20 22:08
以我的程序为例：

哦~也就是说如果只有一个元素的  reduce函数直接就返回那个元素了是吧

冬雪雪冬

badaoqingchen 发表于 2017-5-20 22:17
哦~也就是说如果只有一个元素的  reduce函数直接就返回那个元素了是吧

应该是

sue~sr

啊啊

badaoqingchen

冬雪雪冬 发表于 2017-5-20 22:29
应该是

好的 谢谢啦

余欲渔

因为Excel表最多就两个字母，就写简单点了

1. def spreadsheet(sr='A1'):
   
2.     R=0
   
3.     C=0
   
4.     if sr[0]=='R' and 'C'in sr:
   
5.         b=sr[1:].split('C')
   
6.         if b[0].isdigit() and b[1].isdigit():
   
7.             R=b[0]
   
8.             C=int(b[1])
   
9.             if C<=26:return chr(C+64)+R
   
10.             return chr(C//26+64)+chr(C%26+64)+R
    
11.     lsr=len(sr)
    
12.     for i in range(lsr):
    
13.         if sr[i] in '0123456789':
    
14.             zm=sr[:i]
    
15.             sz=sr[i:]
    
16.             break
    
17.     if len(zm)==1:return 'R'+sz+'C'+str(ord(zm[0])-64)
    
18.     return 'R'+sz+'C'+str((ord(zm[0])-64)*26+ord(zm[1])-64)
    
19. print(spreadsheet('M15'))

复制代码

余欲渔

冬雪雪冬 发表于 2017-5-19 16:09
重新写了。

RC13，这样的时候你这个返回是错误的

冬雪雪冬

余欲渔 发表于 2017-5-22 13:40
RC13，这样的时候你这个返回是错误的

跟你的结果一样呀

solomonxian

关键是26进制中A代表0，Z代表25

1. # 行的信息只要加减"R"和移动位置；列的信息估计要26进制转换
   
2. def spreadsheet(s):
   
3.     num_1,num_2 = s.find('R'),s.find('C')
   
4.     if num_1 !=-1 and num_2 and s[num_1 +1:num_2].isdigit(): # 字母中间夹数字是RC显示
   
5.         row = s[num_1 +1:num_2]
   
6.         col = int(s[num_2 +1:])
   
7.         output = ""
   
8.         while col:
   
9.             output = str(chr((col-1)%26 + 65))+output # 26进制后按Unicode换成字母
   
10.             col = (col-1)//26  # 字母开头A=0，Z=25
    
11.         return output+row
    
12.     else:
    
13.         row = "".join([i for i in s if i.isdigit()])
    
14.         num = [ord(i)-64 for i in s.replace(row,"")[::-1]]
    
15.         col = str(sum([i*26**j for i,j in zip(num,range(len(num)))])) # 按权重算列数
    
16.         return "R"+row+"C"+col

复制代码

张大象

1. def spreadsheet(x):
   
2.         import re,functools
   
3.         if re.search(r'\dC',x):
   
4.                 r,c = re.search(r'(\d+)C(\d+)',x).groups()
   
5.                 str1 = ''
   
6.                 c = int(c)
   
7.                 while c:
   
8.                         if c%26 == 0:
   
9.                                 str1 = chr(26+64) +str1
   
10.                                 c = c//26 - 1
    
11.                         else:
    
12.                                 str1 = chr(c%26+64) + str1
    
13.                                 c = c//26
    
14.                 return str1+r
    
15.         else:
    
16.                 d = re.search(r'\d+',x).group()
    
17.                 s = re.search(r'\D+',x).group()
    
18.                 LS = [ord(i)-64 for i in s]
    
19.                 ssum = functools.reduce(lambda x,y:x*26+y,LS)
    
20.                 return 'R'+d+'C'+str(ssum)

复制代码

victor.xu

1. def SpreadSheetExchange(st):
   
2.     lis1 = [i for i in range(1, 27)]
   
3.     lis2 = [j for j in range(65, 91)]
   
4.     lis3 = [chr(i) for i in lis2]
   
5.     dic1 = dict(zip(lis1, lis3))
   
6.     dic2 = dict(zip(lis3, lis1))
   
7.     if st.count('R') == 1 and st.count('C') == 1 and st[1] != 'C':
   
8.         t = st.partition('C')
   
9.         Column = int(t[2])
   
10.         st = t[0]
    
11.         t = st.partition('R')
    
12.         Row = int(t[2])
    
13.         lis = []
    
14.         while Column != 0:
    
15.                   lis.insert(0, Column % 26)
    
16.                   Column //= 26
    
17.         st = ''
    
18.         for i in lis:
    
19.             st += dic1[i]
    
20.         return st + str(Row)
    
21.     else:
    
22.         Column = []
    
23.         Column_num = []
    
24.         Row = []
    
25.         for i in range(len(st)):
    
26.             if ord(st[i]) >= 65:
    
27.                 Column.append(st[i])
    
28.             else:
    
29.                 Row.append(st[i])
    
30.         for i in Column:
    
31.             Column_num.append(dic2[i])
    
32.         Column_num.reverse()
    
33.         Sum = 0
    
34.         for i in range(len(Column_num)):
    
35.             Sum += Column_num[i] * 26 ** i
    
36.         st = ''
    
37.         for i in Row:
    
38.             st += i
    
39.         return 'R' + st + 'C' + str(Sum)
    
40. st = ['A1', 'R1C1', 'D5', 'R5C4', 'AA48', 'R48C27', 'BK12', 'R12C63']
    
41. for i in st:
    
42.     print('%-19s%-19s' % (i, SpreadSheetExchange(i)))

复制代码

牧之

萧丹夜

第一眼太简单了，然而还是花了很多时间，不过也学到了

1. import test
   
2. import re
   
3. 
   
4. def spreadsheet(s):
   
5.     # 分割（区分）
   
6.     pattern = re.compile(r'([A-Z]+)([0-9]+)')
   
7.     x = pattern.findall(s)
   
8.     # 转换
   
9.     result = ''
   
10.     if len(x) == 1:
    
11.         k = 0
    
12.         i = 0
    
13.         for each in x[0][0][::-1]:
    
14.             i += (ord(each)-64) * (26 ** k)
    
15.             k += 1
    
16.         result = 'R' + x[0][1] + 'C' + str(i)
    
17.         return result
    
18.     if len(x) == 2:
    
19.         n = 0
    
20.         k = int(x[1][1])
    
21.         while(26 ** n <= k):          # x[1][1]为列数 十进制转26进制（字母）
    
22.             n += 1
    
23.         for i in range(n-1,-1,-1):
    
24.             y = k // (26 ** i)
    
25.             k -= y * (26 ** i)
    
26.             result += chr(y + 64)
    
27.         if result.find('@') != -1:
    
28.             index = result.find('@')
    
29.             # result[index] = 'Z'
    
30.             # result[index-1] = chr(ord(result[index-1])-1)
    
31.             result = result[:index-1] + chr(ord(result[index-1])-1) + 'Z' + result[index+1:]
    
32.         if result[0] == '@':
    
33.             result = result[1:]
    
34.         return result + x[0][1]

复制代码

小强工作室

学习中

我不会啊

赞

咕咕鸡鸽鸽

kanakn

holiday_python

学习

19971023

1

nononoyes

'''
https://docs.python.org/zh-cn/3.7/library/string.html?highlight=string#module-string
string.ascii_letters
下文所述 ascii_lowercase 和 ascii_uppercase 常量的拼连。 该值不依赖于语言区域。
string.ascii_lowercase
小写字母 'abcdefghijklmnopqrstuvwxyz'。 该值不依赖于语言区域，不会发生改变。
string.ascii_uppercase
大写字母 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'。 该值不依赖于语言区域，不会发生改变。
string.digits
字符串 '0123456789'。
string.hexdigits
字符串 '0123456789abcdefABCDEF'。
string.octdigits
字符串 '01234567'。
string.punctuation
由在 C 语言区域中被视为标点符号的 ASCII 字符组成的字符串。
string.printable
由被视为可打印符号的 ASCII 字符组成的字符串。 这是 digits, ascii_letters, punctuation 和 whitespace 的总和。
string.whitespace
由被视为空白符号的 ASCII 字符组成的字符串。 其中包括空格、制表、换行、回车、进纸和纵向制表符。
'''
#给出26进制的对应关系
import string
#生成26位大写字母
temp = string.ascii_uppercase
dict1 = {}
count =1
count1 = 0
dict2 = {}
#按照大写字母的递增顺序给出大写字母和数字的对应关系并存放在字典中dict1中 dict1 = ｛'A': 1, 'B': 2......'Y': 25, 'Z': 26｝
for i in temp:
    dict1[i] = count
    count +=1
#按照数字的递增和大写字母的递增顺序的对应关系来存放在字典dict2中
for i in range(1,27):
    dict2[i] = temp[count1]
    count1 +=1

#求各个进制下面给定一个数，然后求这个数的各个数字
def getnum(num,bin):
    list1 = []
    length = len(str(num))
    while length>0:
        #通过数值对26求余数，得到最低位的数字并保存
        i = num %bin
        #num = num对26取整除，将num的值更新为除以26之后的商
        num = num //bin
        list1.append(i)
        #length控制循环次数
        length -= 1
    #由于列表中的值时从低位到高数，因为取反后，得到从高位到低位的各个数字列表
    list2 = list(reversed(list1))
    return list2

def spreadsheet(sheet):
    if (sheet.find('R') != -1 ) and (sheet.find('C') != -1 ) and (sheet.find('C')-sheet.find('R')>=2):
        sheet_num1 = ''.join(sheet.split('R'))
        sheet_num2 = sheet_num1.split('C')
        #得到行的值
        num_r= sheet_num2[0]
        #得到列的值
        num_c = sheet_num2[1]
        #根据列的值来计算对应的字母
        lst = getnum(int(num_c),26)
        result_str = ''.join(dict2[i] for i in lst)
        result = result_str+str(num_r)
        return result

    else:
        #得到字母
        sheet_alpha = ''.join(j for j in sheet if j.isalpha())
        length = len(sheet_alpha)
        sum =0
        count = 0
        #根据字母来计算对应的行也就是C
        for i in range(length-1,-1,-1):
            sum += dict1[sheet_alpha[count]]*(26**i)
            count+=1
        #得到对应的列也就是
        sheet_num = ''.join(k for k in sheet if k.isdigit())
        result = 'R'+sheet_num+'C'+str(sum)
        return result

print(spreadsheet('R12C63'))