小编Max*_*Max的帖子

我需要一个具有以下属性的数据结构：

1. 它包含整数。
2. 不允许重复（也就是说，它最多存储任何整数之一）。
3. 达到最大大小后，第一个元素将被删除。因此，如果容量为 3，则放入连续数字时将如下所示：{}, {1}, {1, 2}, {1, 2, 3}, {2, 3, 4}， {3,4,5}等
4. 只需要两个操作：将数字插入到该容器中（INSERT）并检查该数字是否已在容器中（EXISTS）。EXISTS 操作的数量预计约为 2 * INSERT 操作的数量。
5. 我需要这些操作尽可能快。

对于这种情况，最快的数据结构或数据结构组合是什么？

如果我运行了几个查询并且ObjectContext填充了实体,如果我不再需要这些实体,如何清除上下文.我知道我需要尽快处理上下文,但在这种情况下,这是不可能的.那么有什么方法可以从上下文中删除这些对象？

我有一个图表作为执行ListPlot[]功能的结果.我可以通过将点移动到其他位置并使用绘图工具添加新点来手动编辑此图形.

如何从编辑的图形中获取新点和更改点的坐标？

我在Delphi中使用相同数量的运算源代码,它被编译为32位和64位应用程序.从日志文件中我可以看到数字略有不同(1e-14相对误差).所以我想知道在运行32位和64位代码时,同一CPU是否可能以不同方式执行浮点运算.或者它是编译器负责的东西.

是否可以为具有特定属性的数据结构创建无冲突哈希函数.

1. 数据结构是int [] [] []
2. 它不包含重复项
3. 定义了包含在其中的整数范围.假设它是0..1000,最大整数绝对不大于10000.

最大的问题是这个哈希函数也应该非常快.有没有办法创建这样的哈希函数？也许在运行时取决于整数范围？

附加:我应该说这个哈希函数的目的是要快速检查是否处理了特定的组合.因此,当处理数据结构中的某些数字组合时,我会计算哈希值并存储它.然后,当处理数据结构中的另一个数字组合时,我将比较散列值.

在Mathematica中,我有一个点坐标列表

size = 50;
points = Table[{RandomInteger[{0, size}], RandomInteger[{0, size}]}, {i, 1, n}];

以及这些点所属的集群索引列表

clusterIndices = {1, 1, 1, 1, 1, 1, 1, 2, 2, 1, 2, 1, 2, 1, 1, 1, 1, 1, 1, 1};

根据clusterIndices值将点分成两个单独的列表的最简单方法是什么？

编辑:我提出的解决方案:

pointIndices =
  Map[#[[2]] &,
    GatherBy[MapIndexed[{#1, #2[[1]]} &, clusterIndices], First],
    {2}];
pointsByCluster = Map[Part[points, #] &, pointIndices];

有更好的方法吗？

当我尝试立即调用或跳转到VC++ 2010内联汇编程序时

_asm 
{
    call 00405B90h;
    jmp 00405B90h;
    jmp far 00405B90h;
}

它会产生错误

C2415: improper operand type

是否可能以及如何做到这一点？

到目前为止,我有一个解决方法:

_asm 
{
    push 00405B90h; // This is a jump work around
    call 00405B90h;        
}

当我需要在本地范围内进行转到时,我遇到了一个问题:

if(...)      
{
   DoSomethingHere();
   if (...) goto Label;
}
else if(...)
{
Label:
  DoSomethingHereToo();
}

,显然在C#中是不可能的.

是的我知道使用goto被认为是一种不好的做法,但在这种情况下使用goto更容易.因此,我宁愿不进入整个"goto是所有邪恶的来源"的讨论.对我来说,一个更有趣,更普遍的问题是C#中setjmp/longjmp的可能性.那么可能吗？

我有一个带有IDENTITY列的表

[Id] int IDENTITY(1, 1) NOT NULL

在添加/删除了一些行之后,我以Id值中的间隙结束:

Id   Name
---------
1    Tom
2    Bill
4    Kate

有没有一种简单的方法来压缩值

Id   Name
---------
1    Tom
2    Bill
3    Kate

？

在Mathematica中可能有内置函数或更好更快的方法

func[l_, g_, f_] := g @@ f @@@ Transpose[{Most[l], Rest[l]}]

这可以用来做这样的事情

l = {a, b, c, d}
func[l, Plus, (#1 - #2)^2 &]

我不知道这种功能的正确名称.折叠拉链类型的东西.

更新 Lot的解决方案.谢谢大家.

运用

Partition[l, 2, 1] 

代替

Transpose[{Most[l], Rest[l]}] 

绝对让它更清晰.

我试图在函数上运行时序,但是我得到了奇怪的结果:

func1[l_, g_, f_] := g @@ f @@@ Transpose[{Most[l], Rest[l]}]
func2[l_, g_, f_] := g @@ f @@@ Partition[l, 2, 1]
func3[l_, g_, f_] := g @@ ListConvolve[{1, 1}, l, {-1, 1}, {}, Times, f]
func4[l_, g_, f_] := g @@ Thread[f[Most@l, Rest@l]]
func5[l_, …

用其他.NET语言编写T4模板是否可行？特别是我对F#和IronPython感兴趣.

在我的应用程序中,我有许多对象可以执行一些持久的计算,让我们称之为客户端.我还有许多对象,其中包含要计算的任务的描述.像这样的东西:

let clients = [1..4]
let tasks = [1..20]

let calculate c t =
    printf "Starting task %d with client %d\n" t c
    Thread.Sleep(3000)
    printf "Finished task %d with client %d\n" t c

有了一个客户端,我一次只能启动一个任务.我想创建一个函数/类,它将任务分配给客户端并执行计算.我在C#中使用客户端队列完成了这一操作,因此只要将新任务分配给客户端,就会从队列中删除此客户端,并在计算完成后释放客户端并将其放入队列中再次.现在我有兴趣以功能的方式实现它.我试图尝试异步工作流程,但我想不出一个正确的方法来实现它.

这是一个类似F#的代码,我试图让它工作,但不能:

let rec distribute clients tasks calculate tasks_to_wait =
    match clients, tasks with
    | _ , [] -> ()           // No tasks - we're done!
    | [], th::tt ->          // No free clients, but there are still tasks to calculate.
             let released_client …

说,我有一个带有整数参数的模板类:

template <int N>
class A
{
public:
    static int get_N()
    {
        return N;
    }
};

template<typename T>
class B
{
public:
    B()
    {
        cout << "N = " << T::get_N() << endl; // Accessing N via the auxiliary method
    }
};

要在类BI中引用N模板参数,必须在A中创建一个辅助方法.我想做这样的事情:

template <int N>
class A
{
};

template<typename T>
class B
{
public:
    B()
    {
        cout << "N = " << T::N << endl; // Accessing N directly
    }
};

问题是我将有很多A模板特化,我真的不想将这个辅助方法复制到所有专门的类,我不想为此引入继承.有可能实现我想要的吗？