标签: inversion

"依赖注入"和"控制反转"经常被认为是使用Spring框架开发Web框架的主要优点

如果可能的话,有人可以用一个例子用非常简单的术语解释它是什么吗？

我有一个pygame Surface,想要反转颜色.有没有比这更快更pythonic的方法？这很慢.

我知道从255中减去这个值不是"倒置颜色"的唯一定义,但它是我现在想要的.

我很惊讶pygame没有这样内置的东西!

谢谢你的帮助!

import pygame

def invertImg(img):
    """Inverts the colors of a pygame Screen"""

    img.lock()

    for x in range(img.get_width()):
        for y in range(img.get_height()):
            RGBA = img.get_at((x,y))
            for i in range(3):
                # Invert RGB, but not Alpha
                RGBA[i] = 255 - RGBA[i]
            img.set_at((x,y),RGBA)

    img.unlock()

当refine一个程序,当我的目标是a时,我试图通过inversion一个False假设来结束证明.这是我试图做的证据的简化版本.Type

Lemma strange1: forall T:Type, 0>0 -> T.
  intros T H.
  inversion H.  (* Coq refuses inversion on 'H : 0 > 0' *)

Coq抱怨道

Error: Inversion would require case analysis on sort 
Type which is not allowed for inductive definition le

但是,既然我什么都不做T,那应该没关系,......还是？

我摆脱了T这样的,证据经过:

Lemma ex_falso: forall T:Type, False -> T.
  inversion 1.
Qed.  

Lemma strange2: forall T:Type, 0>0 -> T.
  intros T H.
  apply ex_falso.  (* …

我正在尝试反转 go 中的字符串，但在处理字符时遇到问题。与 C 不同，GO 将字符串视为字节向量，而不是字符，这里称为符文。我尝试进行一些类型转换来完成作业，但到目前为止我还做不到。

这里的想法是生成 5 个字符串，其中随机字符大小为 100、200、300、400 和 500，然后反转它们的字符。我能够轻松地使 C 工作，但在 GO 中，该语言返回一个错误，指出无法执行分配。

 func inverte() {
    var c = "A"
    var strs, aux string

    rand.Seed(time.Now().UnixNano())
    // Gera 5 vetores de 100, 200, 300, 400, e 500 caracteres
    for i := 1; i < 6; i++ {
        strs = randomString(i * 100)
        fmt.Print(strs)

        for i2, j := 0, len(strs); i2 < j; i2, j = i+1, j-1 {
           aux = strs[i2]
           strs[i2] = strs[j]
           strs[j] = aux
       } …

在IDLE中运行代码时出现以下错误:

Traceback (most recent call last):   File "C:/Python34/inversion3.py",
line 44, in <module>
    nInversions.inversionMergeSort(m)   File "C:/Python34/inversion3.py", line 16, in inversionMergeSort
     left = m[0:half] TypeError: slice indices must be integers or None or have an __index__ method

码:-

from collections import deque

m = []
f = open("IntegerArray.txt")
for line in f:
    m.append(int(line))

class InversionCount:

    def __init__(self, n):
        self.n = n
    def inversionMergeSort(self, m):
        if len(m) <= 1:
            return m
        half = len(m)/2
        left = m[0:half]
        right = m[half:]
        left = self.inversionMergeSort(left) …

给定两个列表，每个列表包含N个间隔（数字线的子集），每个间隔具有起点和终点的形式。一个列表中的这些间隔中有多少对包含另一列表中的间隔？

例如：

如果列表A是{(1,7), (2,9)}且列表B是{(3,6), (5,8)}

那么，其中A的间隔包含B中的间隔的对的计数为3对：

(1,7),(3,6)
(2,9)(3,6)
(2,9)(5,8)

目标是射击O（n log n）。

我目前的算法是先按x坐标排序，然后将其作为一个列表。然后按y坐标对列表进行排序，并计算两个列表之间的倒数。但是我的问题是为什么这行得通？任何见识将不胜感激。

我目前正在可视化的方式是以下几何方式（线的每个交点都是num求逆的计数）：

注意：我不确定如何在列表列表中检查反转。只是试图找到一种可以给出O（n log n）的方法。如果有其他方法很高兴听到建议。

在我的应用程序中，当用户启用可访问性颜色反转模式时，我需要进行一些 UI 更改。

我们是否有任何 API 可以检查 Android 中颜色反转模式的启用/禁用状态？

我正在编写一个算法，该算法将返回一个具有确定长度和反转次数（数字对，其中左侧数字大于右侧数字）的数组。即数组 [3, 1, 4, 2] 包含三个反演 (3, 1), (3, 2) 和 (4, 2)。所以在实践中，当给定长度 n=3 和反转次数 k=3 时，算法应该生成一个数组 [3, 1, 4, 2] （或另一个满足这些要求的数组）。

由于反转次数也是按升序对数组进行排序所必须进行的交换次数，因此我通过创建一个从 1 到 n - 1 的数组并反向使用插入排序算法来解决这个问题k 交换。

这种方法适用于较小的输入，但该算法应该能够有效地生成高达 n=10^6 和 k=n(n-1)/2 以及介于两者之间的任何数组，因此该算法应该在 O (n log n) 时间而不是 O(n^2)。下面是代码：

import java.util.*;

public class Inversions {

    public int[] generate(int n, long k) {        

        // Don't mind these special cases

        if (n == 1) {

            int[] arr = {1};

            return arr;
        }

        if (k == 0) {

            int[] arr = …

我想在Octave中得到一个可逆矩阵但是作为整数矩阵,所以:

x = [9,15;19,2];
inv(x)

我得到:

[-0.0074906, 0.0561798; 0.0711610, -0.0337079]

但我想让[22,17;25,21] 任何人都知道如何反转矩阵？

在 A 列中的值与 B 列中的值相反的情况下，查找重复项的最快方法是什么？

例如，如果我有一个 DataFrame ：

     Column A           Column B
0           C                  P
1           D                  C
2           L                  G
3           A                  D
4           B                  P
5           B                  G
6           P                  B
7           J                  T
8           P                  C
9           J                  T

结果将是：

     Column A           Column B
0           C                  P
8           P                  C
4           B                  P
6           P                  B

我试过 ：

df1 = df
df2 = df
for i in df2.index:
     res = df1[(df1['Column A'] == df2['Column A'][i]) & (df1['Column …

在通过分而治之的方法查找数组中的反转次数的过程中我遇到了实现merge-step的问题:我们有两个排序的数组,任务是计算第一个数组的元素时的个案数大于第二个元素.

例如,如果是数组v1 = [1,2,4], v2 = [0,3,5],我们应该计算4次反转.

所以,我在Matlab中实现了合并步骤,但我坚持如何快速实现它的问题.

首先,我尝试过蛮力方法

tempArray = arrayfun(@(x) length(find(v2>x)), v1)

它的工作速度和下一个片段一样慢

l = 1;
s = 0;
for ii = 1:n1 
    while(l <= n2 && p1(ii)>p2(l))
        l = l + 1;
    end
    s = s + l - 1;
end

有没有一种方法可以让它更快？

编辑

谢谢你的答案和方法!我为进一步的工作找到了有趣的东西.

这是片段,它应该是我尝试过的最快的片段

n1 = length(vec1); n2 = length(vec2);

uniteOne = [vec1, vec2];

[~, d1] = sort(uniteOne);
[~, d2] = sort(d1); % Find ind-s IX such that B(IX) = A, where B = …

这是我在维基百科网站上找到的一个问题（我想很好地学习排序算法）。无论如何，这是一个问题 - 你能向我解释一下如何展示它吗？

练习：假设 I 是数组 A 中的反转次数，则证明算法插入排序 (A) 的运行时间为 O(n + I)。

我在SO中发现了一个帖子,其中算法是用python代码实现的.这是本文中伪代码的直接实现.

但是,在伪代码中,有一行,其中count由数组'a'中剩余元素的数量递增.在上面的python代码中,它给出为

count += len(a) - i

我们不能这样做

count += len(a[i:])

而且,而不是

c += a[i:] + b[j:]

我写,

c.append(a[i:])
c.append(b[j:])

总的来说,我的版本看起来像这样

def merge(left,right):
    i=0
    j=0
    count=0
    c=[]
    while i<len(left) and j<len(right):
        c.append(min(left[i],right[j]))
        if right[j]< left[i]:
            count+=len(left[i:])
            j+=1
        else:
            i+=1
    c.append(left[i:])
    c.append(right[j:])
    return count,c


def dnc(input):
    if len(input)==1:
        return 0,input
    mid=len(input)/2
    left=input[:mid]
    right=input[mid:]
    l,left=dnc(left)
    r,right=dnc(right)
    m,result=merge(left,right)
    count=l+r+m
    return count,result

唉!,当我在排序的数组上计算它时,我得到3而不是0

if __name__=='__main__':
    input =[1,2,3,4,5]
    ct,res=dnc(input)
    print ct

我做错了什么？有人可以帮我找出来吗？