在嵌套列表中定位项目并在python中解码密码[重复]

5 回答

• 0

  要将字符转换为整数，您可以执行以下操作：

  def char_to_num(char):
      return ord(char)-ord('A')
  

  要访问网格中的字符，你可以这样做（我假设输入被称为 input ）：

  word = ""
  for position in input.upper():
     word += grid[char_to_num(position[0])][char_to_num(position[1])]
  

  回复于 2024-04-27T06:17:37+08:00
• 1

  index=input('Enter the index:')
  index=list(index)
  a=[ord(i)-ord('A') for i in index]
  print(grid[a[0]][a[1]])
  

  回复于 2024-04-27T06:17:37+08:00
• 1

  >>> input_string = "FE CC ED ED CD"
  
  # Convert input string into integers
  # `ord()` converts 'A' to 65, 'B' to 66, etc
  >>> pairs = [tuple(ord(letter) - ord('A') for letter in pair) for pair in input_string.split()]
  [(5, 4), (2, 2), (4, 3), (4, 3), (2, 3)]
  
  # Now just retrieve the tuples from the list of pairs
  # And look up the index in the grid
  >>> output = ''.join(grid[x][y] for x, y in pairs)
  'HELLO'
  

  回复于 2024-04-27T06:17:37+08:00
• 0

  def letter_to_number(letter):
      return ord(letter.upper()) - ord('A')
  

  这样做的原因是 ord(x) 返回字符 x 的值，无论你的字符集是什么，并且无论是ASCII，Latin-1，UTF-8还是别的，这些字母都按顺序排列 .

  你可以通过在交互式解释器中试验它来看到这一点：

  >>> ord('A')
  65
  >>> ord('B')
  66
  >>> ord('F')
  70
  >>> ord('F') - ord('A')
  5
  

  回复于 2024-04-27T06:17:37+08:00
• 0

  您可以使用映射将字母转换为数字 . 这样的映射很容易从 string.ascii_uppercase 字符串生成：

  import string
  letter_to_index = {l: i for i, l in enumerate(string.ascii_uppercase)}
  

  使用 letter_to_index 然后将一个字母（例如 E ）变成一个数字（ 4 ）是微不足道的：

  >>> letter_to_index['E']
  4
  

  使用空格分隔的输入，这将变为：

  letters = []
  for coordinate in code.split():
      row, column = letter_to_index[coordinate[0]], letter_to_index[coordinate[1]]
      letters.append(grid[row][column])
  
  print ''.join(letters)
  

  其他技术使用 ord() 获取字母的ASCII序号（减去 ord('A') 使其基于0）或使用 .index() on string.ascii_uppercase （这将更慢） .

  将它们的相对速度与timeit module进行比较是确定哪一种是最快技术的最佳方法（如果你这么小心）：

  >>> import timeit
  >>> def lookup_map(coordinate):
  ...     return letter_to_index[coordinate[0]], letter_to_index[coordinate[1]]
  ... 
  >>> def lookup_ord(coordinate, orda=ord('A')):
  ...     return ord(coordinate[0]) - orda, ord(coordinate[1]) - orda
  ... 
  >>> def lookup_index(coordinate, upper=string.ascii_uppercase):
  ...     return upper.index(coordinate[0]), upper.index(coordinate[1])
  ... 
  >>> coords = [random.choice(string.ascii_uppercase[:6])+random.choice(string.ascii_uppercase[:6]) for _ in range(1000)]
  >>> timeit.timeit('[lookup(c) for c in coords]', 'from __main__ import coords, lookup_map as lookup', number=10000)
  3.883746862411499
  >>> timeit.timeit('[lookup(c) for c in coords]', 'from __main__ import coords, lookup_ord as lookup', number=10000)
  4.582481861114502
  >>> timeit.timeit('[lookup(c) for c in coords]', 'from __main__ import coords, lookup_index as lookup', number=10000)
  9.782031059265137
  

  字典（映射）方法最快;使用 ord() 紧随其后（如果你只计算 ord('A') 一次），并且使用 .index() 需要几乎三倍的时间 .

  回复于 2024-04-27T06:17:37+08:00