小编Chr*_*ris的帖子

尝试在Debian Etch安装上更新一些存储库,并通过运行"apt-get update"获得以下错误

W: GPG error: http://www.debian-multimedia.org etch Release: The following signatures couldn't be verified because teh public key is not available: NO_PUBKEY 07DC563D1F41B907
W: You may want to run apt-get update to correct these problems

具有讽刺意味的是它指示我运行apt-get update是一个不错的踢球者......

我正在寻找一种如此未知但有用的算法或数据结构,您认为这是计算机科学或编程社区的可怕疏忽.如果只有我们都可以学习这样一两件事,有很多好会做很多未来的计划.

我能想出的最好的是插值搜索,只有极少数程序员知道,而每个人都知道二进制搜索.我认为毫无疑问,快速搜索有序列表是一种非常有用且基本的算法.

这两者几乎完全相同 - 所以这不是问题.

它对均匀分布的数据执行O(log(log(n))),而不是二进制搜索O(log(n)).这意味着搜索40亿个数字只需要5个探测器而不是32个,那就更好了!

在非完美统一的数据上,它在大多数情况下仍然表现得非常好.只有当数据真正偏离时才会像二进制搜索一样糟糕或者更糟糕.当数据高度偏斜时,这是O(n)最坏的情况,但在大多数现实情况下这种情况非常罕见.

即便如此,人们也可以构造一个偶数/奇数算法来在两者之间交替,并得到最差的二分搜索情况,并使用插值搜索的平均情况来缓解极端情况.

大多数程序员/图书馆都忽略了这一点.

谁能打败那个人？

想象一下,我有一个存储一系列稀疏向量的表.稀疏向量意味着它仅在数据结构中显式存储非零值.我可以有一个100万维向量,但我只存储非零的维度的值.因此,大小与非零条目的数量成比例,而不是向量的维度.

表定义如下:vector_id:int dimension:int value:float

现在,在正常的编程范围内,我可以在O(| v1 | + | v2 |)时间内计算两个向量的内积或点积.基本上算法是存储按维度排序的稀疏向量并迭代每个维度,直到找到维度之间的碰撞并乘以共享维度的值并继续添加它们直到你到达任一个向量的末尾.

什么是在SQL中实现这一目标的最快方法？

假设我有一个具有以下历史的分支:

A - B - C - D

在B和CI之间修改了一堆包含特定文件的文件,称之为foo.txt.

然后,在修订版D上,我修改了同一个文件foo.txt.

与此同时,我的一个朋友拍了我B目录的快照,并决定以某种方式调整foo.txt.让我们称之为修订版E.如果它们是同一个存储库的一部分,它们将如下所示:

A - B - C - D
     \
      E

然而,他们并非如此,我们只在我的存储库中安装了A - B - C - D然后他给我发了一个关于B和E之间差异的补丁.

由于我也搞乱了foo.txt,我不能直接将补丁应用到D,差异的上下文不匹配,它期待我在B或B附近.

看起来我想要创建我上面提到的假设存储库树,然后在此存储库中进行D和E之间的合并,以便以正确的顺序一起回放我的更改C和D.

所以我的问题:

• 这是根据历史"基线"应用更改的最明智的方法吗？
• 我有没有看到任何缺点？
• 如何干净利落地完成git？

我有两个表,第一个是一个大表(数百万行),最有趣的列是一个整数,我只称之为"键".我相信这个解决方案对于日期或日期时间范围也是相同的.

第二个表要小得多(数千行),有一堆我感兴趣的属性,这些属性是在一系列键上定义的.它具有以下结构:

key_lower_bound:int key_upper_bound:int interesting_value1:float interesting_value2:int interesting_value3:varchar(50)...

我想查找第一个表中的所有值,并根据第一个表中的键是否落在区间[key_lower_bound,key_upper_bound]内,将它们与第二个表"连接"起来.

这有点像稀疏内积或稀疏点积在数学上,但它有点奇怪,因为第二个表中涉及这些范围.不过,如果我在代码中写这个,那将是一个O(|第一个表| + |第二个表|)算法.我会指向两个(已排序)列表并逐个浏览它们,以确定第一个表中的每个键是否属于第二个表的范围.诀窍在于,每次检查第一个表中的键时,我都不会遍历第二个列表,因为两个列表都已排序.

当我构造最客观的SQL查询(涉及检查该键是> key_lower_bound和<key_upper_bound)时,它需要花费太长时间.

这个天真的查询会发生某种二次行为,因为我认为查询引擎正在对第二个表中的每一行进行比较,而实际上,如果第二个表是按key_lower_bounds排序的,那么这不是必需的.所以我得到一个O(|第一个表| x​​ |第二个表|)行为而不是所需的O(|第一个表| + |第二个表|)行为.

是否可以获得线性SQL查询来执行此操作？

我有这段简单的代码写入套接字,然后从服务器读取响应.服务器速度非常快(每次响应5ms).但是,尽管写入套接字很快 - 读取套接字的响应总是慢得多.有线索吗？

module UriTester
  module UriInfo
    class << self
      def send_receive(socket, xml)
#        socket = TCPSocket.open("service.server.com","2316")
        begin
        start = Time.now
          socket.print(xml)           # Send request
        puts "just printed the xml into socket #{Time.now - start}"
        rescue Errno::ECONNRESET
        puts "looks like there is an issue!!!"
          socket = TCPSocket.open("service.server.com","2316")
          socket.print(xml)           # Send request
        end
        response=""
        while (line =socket.recv(1024))
          response += line
          break unless line.grep(/<\/bcap>/).empty?
        end
        puts "SEND_RECEIVE COMPLETED. IN #{Time.now - start}"
#        socket.close
        response
      end
    end
  end
end

谢谢!