我需要以特定的方式安排我的列表 - python

4 回答

• 2

  这将是一种具有递归函数的强力方法：

  import math
  
  def f(temp, numbers):
      for i, j in zip(temp[:-1], temp[1:]):
          sqrt = math.sqrt(i+j)
          if int(sqrt) != sqrt:
              return False
      if not numbers:
          return temp
      for i in numbers:
          result = f(temp + [i], [j for j in numbers if j != i])
          if result:
              break
      return result
  
  n = int(input("Arrange numbers from 1 to ").strip())
  numbers = list(range(1, n+1))
  print("Input:", numbers)
  print("Output:", f([], numbers))
  

  4示例：

  Arrange numbers from 1 to 4
  Input: [1, 2, 3, 4]
  Output: False
  

  15示例：

  Arrange numbers from 1 to 15
  Input: [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15]
  Output: [8, 1, 15, 10, 6, 3, 13, 12, 4, 5, 11, 14, 2, 7, 9]
  

  回复于 2024-04-27T02:22:49+08:00
• 3

  我'll make some slight improvements to the answer by @Jayjayyy. This code, slightly modified from @Jayjayyy' s，有点复杂但也更快 . 对于 n = 15 ，此代码在我的系统上快了7.5倍，对于 n = 30 ，它的速度提高了19倍 . 通过减少总和为平方数的检查次数并加快这些检查来完成此速度增加 . 我还移动了方数检查以减少例程调用自身的次数 .

  最后，我将一些变量名称更改为更自我记录 . 但@ Jayjayyy的代码因其简洁性而备受赞誉 .

  import math
  
  def f(listsofar, numbersleft):
      if not numbersleft:
          return listsofar
      result = False
      for i in numbersleft:
          if not listsofar or math.sqrt(listsofar[-1] + i).is_integer():
              result = f(listsofar + [i], [j for j in numbersleft if j != i])
              if result:
                  break
      return result
  
  n = int(input("Arrange numbers from 1 to ").strip())
  numbers = list(range(1, n+1))
  print("Input:", numbers)
  print("Output:", f([], numbers))
  

  回复于 2024-04-27T02:22:49+08:00
• 2

  你快到了 . 您可以使用图表完成最后的步骤 . 列表t会更好，因为表示边的元组对 .

  您也可以稍后修改列表，如下所示 .

  t =[3, 1, 8, 1, 15, 1, 1, 3, 6, 3, 13, 3, 5, 4, 12, 4, 4, 5, 11, 5, 3, 6, 10, 6, 2, 7, 9, 7, 1, 8, 7, 9, 6, 10, 15, 10, 5, 11, 14, 11, 4, 12, 13, 12, 3, 13, 12, 13, 2, 14, 11, 14, 1, 15, 10, 15]
  t = list(zip(t[::2],t[1::2]))
  

  我建议稍微修改原始代码 .

  import networkx as nx
  import math
  
  u = int(input("ENTER: "))
  l = []
  for i in range(1, u + 1):
      l.append(i)
  o = l
  t = []
  for elem in l:
      for x in o:
          p = elem + x
          p = math.sqrt(p)
          if p%1 == 0:
              if x == elem:
                  break
              else:
                  t.append((x, elem)) #to keep tuples instead
  

  现在，只需将其转换为图形问题 . 递归查找所有邻居，直到获得最大长度 . 跟踪您已访问过的邻居，以避免再次遍历相同的路径 .

  G = nx.Graph()
  G.add_edges_from(t)
  #Now, you need to find "new" neighbours for all possible combinations that make the longest chain in your case
  def findPaths(G, current_node, n, to_exclude = None):
      if to_exclude == None:
          to_exclude = set([current_node])
      else:
          to_exclude.add(current_node)
      if n==1:
          return [[current_node]]
      paths = [[current_node]+path for neighbor in G.neighbors(current_node) if neighbor not in to_exclude for path in findPaths(G,neighbor,n-1,to_exclude)]
      to_exclude.remove(current_node)
      return paths
  
  
  allpaths = []
  for node in G:
      allpaths.extend(findPaths(G, node, G.number_of_nodes()))
  if allpaths:
      print('match found')
      [print(x) for x in allpaths]
  else:
      print('no matches')
  

  回复于 2024-04-27T02:22:49+08:00
• 0

  当你使用两个For循环时，你通常会相互添加相同的数字，而不是列表中的下一个（所以l == x in o）中的elem始终为true

  当你使用（p％1 == 0）时，另一个总是为真

  并删除重复，更正您的代码，然后您可以轻松地将列表转换为这样的集合：

  NoDuplicatedList = set（t）

  t是要从中删除重复的列表 .

  你可能会失去你所拥有的清单的顺序 .

  回复于 2024-04-27T02:22:49+08:00