相关疑难解决方法(0)

(为什么我这样做？见下面的解释)

考虑两个点集,A并B如下图所示

它可能看起来不像,但是set A在集合中是"隐藏的" B.它不容易被看到,因为相对于点B的缩放,旋转和平移.更糟糕的是,存在的一些点缺失,并且包含许多不存在的点.(x, y)AABBA

我需要找到必须应用于B集合的适当缩放,旋转和平移,以便将其与集合匹配A.在上面显示的情况中,正确的值是:

scale = 0.14, rot_angle = 0.0, x_transl = 35.0, y_transl = 2.0

产生(足够好)匹配

(红色,仅显示匹配的B点;这些点位于1000<x<2000, y~2000右侧第一个图中的扇区中).鉴于很多自由度(DoF:缩放+旋转+ 2D平移)我知道错过匹配的可能性,但是点的坐标不是随机的(尽管它们可能看起来像它)所以这个概率发生的事情很小.

我编写的代码(见下文)使用强力循环遍历从每个预定义范围取得的所有可能的DoF值.代码的核心是基于最小化每个点A到任何点的距离B

代码有效(它实际上生成了上面提到的解决方案),但由于解决方案的数量(即每个DoF的可接受值的组合)与更大的范围进行扩展,因此它可能会变得非常快速(也会使所有的我系统中的RAM)

如何提高代码的性能？我愿意接受任何解决方案,包括numpy和/或scipy.或许类似于Basing-Hopping来搜索最佳匹配(或相对接近的匹配)而不是我目前使用的强力方法？

import numpy as np
from scipy.spatial import distance
import math


def scalePoints(B_center, delta_x, delta_y, scale):
    """
    Scales xy points.

    http://codereview.stackexchange.com/q/159183/35351
    """ …

问题是打印两个给定字符串的所有可能的交错.所以我用Python编写了一个工作代码,运行方式如下:

def inter(arr1,arr2,p1,p2,arr):
    thisarr = copy(arr)
    if p1 == len(arr1) and p2 == len(arr2):
        printarr(thisarr)
    elif p1 == len(arr1):
        thisarr.extend(arr2[p2:])
        printarr(thisarr)
    elif p2 == len(arr2):
        thisarr.extend(arr1[p1:])
        printarr(thisarr)
    else:
        thisarr.append(arr1[p1])
        inter(arr1,arr2,p1+1,p2,thisarr)
        del thisarr[-1]
        thisarr.append(arr2[p2])
        inter(arr1,arr2,p1,p2+1,thisarr)
    return

它出现在字符串中的每个点上,然后对于一个递归调用,它将当前元素视为属于第一个数组,并在下一个调用中将其视为属于另一个数组.因此,如果输入的字符串ab和cd,它打印出来abcd,acbd,cdab,cabd,等p1,并p2都指向数组(因为Python中的字符串是不可改变的,我使用数组!).任何人都可以告诉我,这段代码的复杂程度是什么,是否可以改进？我编写了一个类似的代码来打印k给定数组的所有长度组合:

def kcomb(arr,i,thisarr,k):
     thisarr = copy(thisarr)
     j,n = len(thisarr),len(arr)
     if n-i<k-j or j >k:
        return
     if j==k:
        printarr(thisarr)
        return
     if i == n:
         return
     thisarr.append(arr[i])
     kcomb(arr,i+1,thisarr,k)
     del …

我有一个numpy数组[0,1,1,2,2,0,1,...]只包含数字0-k.我想创建一个新的数组,其中包含n个可能的0-k排列数组.k = 2且n = 6的小例子:

a = [0, 1, 0, 2]
permute(a)
result = [[0, 1, 0, 2]
          [0, 2, 0, 1]
          [1, 0, 1, 2]
          [2, 1, 2, 0]
          [1, 2, 1, 0]
          [2, 0, 2, 1]]

有没有人有任何关于如何实现这一目标的想法/解决方案？

这与问题如何在Python中生成列表的所有排列有关

如何生成符合以下条件的所有排列:如果两个排列彼此相反(即[1,2,3,4]和[4,3,2,1]),则认为它们相等且只有一个排列应该是最终结果.

例:

permutations_without_duplicates ([1,2,3])
[1, 2, 3]
[1, 3, 2]
[2, 1, 3]

我正在置换包含唯一整数的列表.

产生的排列数量很高,所以我想尽可能使用Python的生成器.

编辑:如果可能的话,我不想将所有排列的列表存储到内存中.

我有以下列表：

aa = ['aa1', 'aa2', 'aa3', 'aa4', 'aa5']
bb = ['bb1', 'bb2', 'bb3', 'bb4', 'bb5']
cc = ['cc1', 'cc2', 'cc3', 'cc4', 'cc5']

我想像这样创建一个熊猫数据框：

aa    bb    cc
aa1   bb1   cc1
aa2   bb1   cc1
aa3   bb1   cc1
aa4   bb1   cc1
aa5   bb1   cc1
aa1   bb2   cc1
aa1   bb3   cc1
aa1   bb4   cc1
aa1   bb5   cc1
aa1   bb1   cc2
aa1   bb1   cc3
aa1   bb1   cc4
aa1   bb1   cc5

我不知道如何做到这一点。我看过例子： How to generate all permutations of a list in Python

我可以使用以下方法单独进行每个排列：

import itertools
itertools.permutations(['aa1','aa2','aa3','aa4','aa5']) …

通常有人说不建议在python中使用递归函数(递归深度限制,内存消耗等)

我从这个问题中得到了一个排列的例子.

def all_perms(str):
  if len(str) <=1:
    yield str
  else:
    for perm in all_perms(str[1:]):
        for i in range(len(perm)+1):
            yield perm[:i] + str[0:1] + perm[i:]

后来我把它变成了一个不递归的版本(我是一个蟒蛇新手)

def not_recursive(string):
  perm = [string[0]]
  for e in string[1:]:
    perm_next = []
    for p in perm:
        perm_next.extend(p[:i] + e + p[i:] for i in range(len(p) + 1))
    perm = perm_next

  for p in perm:
    yield p

我比较了他们

before=time()
print len([p for p in all_perms("1234567890")])
print "time of all_perms %i " % (time()-before)

before=time() …

假设我有一个包含8个对象的列表,编号为1-8.

这些物体被放入三个盒子中,3个放在一个盒子里,3个放在另一个盒子里,2个放在最后一个盒子里.通过数学,有8C3*5C3 = 560种方法可以做到这一点.我想在那里循环560项.Python有什么方法可以这样做吗？

结果应如下所示:

list=['12','345',678'], ['12','346','578'], ..., etc.

请注意,['12','345','678']并且['12','354',876']为此目的被认为是相同的.

我想制作一个for循环这个列表.Python有什么方法可以这样做吗？

这是我得到的解决方案,但它似乎很难看.

import itertools
for c1,c2 in itertools.combinations(range(8),2):
            l2=list(range(8))
            l2.pop(c2)
            l2.pop(c1)
            for c3,c4,c5 in itertools.combinations(l2,3):
                l3=l2[:]
                l3.remove(c5)
                l3.remove(c4)
                l3.remove(c3)
                c6,c7,c8=l3
                print(c1,c2,c3,c4,c5,c6,c7,c8)

我试图显示数字列表的所有可能的排列,例如,如果我有334我想得到:

3 3 4
3 4 3
4 3 3

我需要能够为任何长达12位左右的数字组执行此操作.

我确信使用像itertools.combinations这样的东西可能相当简单,但是我不能完全正确地使用语法.

TIA Sam

我正在尝试用Python中的数据做一些组合的东西.我看了如何在Python中生成列表的所有排列的问题,但认为这不符合我的需要..我有这种类型的数据...:

    group1-Steve
    group1-Mark
    group1-Tom
    group2-Brett
    group2-Mick
    group2-Foo
    group3-Dan
    group3-Phil

...我需要制作三个元素的所有可能组合,每组只有一个,不重复,保存到每个组合的列表.

我知道在这种情况下有18种可能的不同组合(3*3*2 = 18),但不知道我怎么能写这段代码.我读过Pyncomb包,但不知道在这种情况下应用的功能; 也许有一个功能可以完成这项工作.

希望有人能帮助我......

提前致谢;

PEIXE

我今天正在考虑这个问题,我带来了以下伪代码(Python 3.2):

def anagrams( string ):

    for c in string:
      anagram = c + anagram( string - {c} ) # remove the char from its position in the string
      print(anagram)

    return

def main():

    word = "abcd"
    anagrams( word )

    return

但是,我想知道这种操作的pythonic方法:anagram = c + anagram(string - {c})

我怎么能从字符串中删除该字符？例如:

"abc" -> 'a' + "bc" -> 'a' + 'b' + "c" -> 'a' + 'b' + 'c' = 'abc'
             + "cb" -> 'a' + 'c' + "b" -> 'a' + 'c' + …