标签: lookup

我有三个列表,如下所示:

Initiatives
-----------
Initiative (single line text)

Themes
------
Theme      (single line text)
Initiative (Lookup from Initiatives:Initiative)
Points     (number)

Features
--------
Feature    (single line text)
Theme      (Lookup from Themes:Theme)
Points     (Lookup from Themes:Points)     # <- This here works fine.
Initiative (Lookup from Themes:Initiative) # <- This here is busted and can't do.

看到最后一行...... Initiative (Lookup from Themes:Initiative)< - 这就是我试图获得与主题相关的主动权.我尝试了很多不同的东西,只是无法弄清楚如何做到这一点.

它甚至可能吗？如果是这样,怎么样？

FWIW - 我使用的是SharePoint 2010,可以使用从Web工具到SharePoint Designer的任何内容.我是SharePoint 站点上的管理员,但不是服务器上的管理员.

如何使用字符向量变量作为参数动态查找多个字段并通过引用添加.在下面的情况下,我想查找两列并删除i.它们中的前缀.当然,他们可以覆盖具有相同名称的现有列.

library(data.table)
set.seed(1)
ID <- data.table(id = 1:3, meta = rep(1,3), key = "id")
JN <- data.table(idd = sample(ID$id, 3, FALSE), value = sample(letters, 3, FALSE), meta = rep(1,3), key = "idd")
select <- c("value","meta") # my fields to lookup
j.lkp <- call(":=", select, lapply(paste0("i.",select), as.symbol))
j.lkp
# `:=`(c("value", "meta"), list(i.value, i.meta))
ID[JN, eval(j.lkp)]
# Error in eval(expr, envir, enclos) : could not find function "i.value"
ID[JN, `:=`(c("value", "meta"), list(i.value, i.meta))]
#    id meta value
# …

我是一名前C++/STL程序员,试图使用c#/ .NET技术编写快速行进算法...

我正在搜索等效的STL方法"map :: insert",如果不存在,则在给定键处插入值,否则返回现有键值对的迭代器.

我找到的唯一方法是使用两个查找:一个在TryGetValue中,另一个在Add方法中:

List<Point> list;
if (!_dictionary.TryGetValue (pcost, out list))
{
    list = new List<Point> ();
    dictionary.Add (pcost, list);
}
list.Add (new Point { X = n.x, Y = n.y });

是否有一些东西可以解释为什么使用.NET容器不可能？还是我错过了一些观点？

谢谢.

我有一个

Lookup<TKey, TElement>

TElement指的是一串单词.我想将Lookup转换为:

Dictionary<int ,string []> or List<List<string>> ?

我读过一些关于使用的文章

Lookup<TKey, TElement>

但这还不足以让我理解.提前致谢.

为什么这样做,并正确查找值

但是一旦我改变了值的顺序,它会产生不正确的值？

首先,让我们从DataFrame 1(DF1)开始:

DF1 <- data.frame(c("06/19/2016", "06/20/2016", "06/21/2016", "06/22/2016", 
                    "06/23/2016", "06/19/2016", "06/20/2016", "06/21/2016",
                    "06/22/2016", "06/23/2016"),
                  c(1, 1, 1, 1, 1, 2, 2, 2, 2, 2),
                  c(149, 150, 151, 152, 155, 84, 83, 80, 81, 97),
                  c(101, 102, 104, 107, 99, 55, 55, 56, 57, 58),
                  c("MTL", "MTL", "MTL", "MTL", "MTL", "NY", "NY", 
                    "NY", "NY", "NY"))
colnames(DF1) <- c("date", "id", "sales", "cost", "city")

我也有DataFrame 2(DF2):

DF2 <- data.frame(c("06/19/2016", "06/27/2016", "06/22/2016", "06/23/2016"),
                  c(1, 1, 2, 2),
                  c(9999, 8888, 777, 555),
                  c("LON", "LON", "QC", …

我似乎尽管有大量的算法和函数用于从唯一项目列表中生成任何大小的唯一组合,但是在非唯一项目列表(即包含重复项的列表)中没有可用的相同的价值.)

问题是如何在生成器函数中生成ON-THE-FLY所有来自非唯一列表的独特组合,而不需要过滤重复计算的昂贵计算？

现在,由于对这个问题有一个很有动力的答案,因此更容易提供我期望实现的目标:

首先,让我们提供一些代码,说明如何检查组合comboB是否与另一个组合重复(comboA):

comboA = [1,2,2]
comboB = [2,1,2]
print("B is a duplicate of A:", comboA.sort()==comboB.sort())

在给定的例子中,B是A的副本,print()打印为True.

在这里解决了获取能够在非唯一列表的情况下即时提供独特组合的生成器功能的问题:从非唯一项目列表中获取独特的组合,更快？,但是提供的生成器函数需要查找并且需要内存,以便在大量组合的情况下导致问题.

在当前版本的答案提供功能完成工作没有任何查找,似乎是正确的答案,但......

摆脱查找的目的是在列表重复的情况下加速生成唯一组合.

我最初(编写这个问题的第一个版本)错误地认为,不需要创建用于确保唯一性所需的查找集的代码预期会比需要查找的代码具有优势.事实并非如此.至少并非总是如此.截至目前提供的答案中的代码不使用查找,但是如果没有冗余列表或者列表中只有少量冗余项,则需要花费更多时间来生成所有组合.

这里有一些时间来说明目前的情况:

-----------------
 k: 6 len(ls): 48
Combos   Used Code                               Time
---------------------------------------------------------
12271512 len(list(combinations(ls,k)))       :  2.036 seconds
12271512 len(list(subbags(ls,k)))            : 50.540 seconds
12271512 len(list(uniqueCombinations(ls,k))) :  8.174 seconds
12271512 len(set(combinations(sorted(ls),k))):  7.233 seconds
---------------------------------------------------------
12271512 len(list(combinations(ls,k)))       :  2.030 seconds
       1 len(list(subbags(ls,k)))            :  0.001 seconds
       1 len(list(uniqueCombinations(ls,k))) :  3.619 seconds …

前段时间,我学到了一些关于大O符号和不同算法效率的知识.

例如,循环遍历数组中的每个项目以执行某些操作

foreach(item in array)
    doSomethingWith(item)

是一种O(n)算法,因为程序执行的周期数与数组的大小成正比.

令我惊讶的是,表查找是O(1).也就是说,在哈希表或字典中查找键

value = hashTable[key]

无论表格是否有一个密钥,十个密钥,一百个密钥或一个千兆字节密钥,它都会占用相同的周期数.

这真的很酷,我很高兴这是真的,但这对我来说不直观,我不明白为什么这是真的.

我可以理解第一个O(n)算法,因为我可以将它与现实生活中的例子进行比较:如果我有纸张要加盖,我可以逐个浏览每张纸并盖上每张纸.对我来说很有意义的是,如果我有2000张纸,使用这种方法印花的时间比用1000张纸要长两倍.

但我无法理解为什么表查找O(1).我想如果我有一本字典,并且我想找到多态的定义,我将花费O(logn)时间找到它:我将在字典中打开一些页面,看看它是否在多态之前或之后按字母顺序排列.例如,如果它是在P部分之后,我可以在打开的页面之后删除字典中的所有内容,并使用字典的其余部分重复该过程,直到我找到单词polymorphism.

这不是一个O(1)过程:通常需要更长的时间才能在千页词典中找到单词而不是两页词典.我很难想象一个过程需要相同的时间,而不管字典的大小.

tl; dr:你能解释一下如何用O(1)复杂性进行表查找吗？

(如果你告诉我如何复制这个惊人的O(1)查找算法,我肯定会得到一个很大的字典,所以我可以向所有朋友展示我的忍者词典查找技巧)

编辑:大多数答案似乎取决于这个假设:

您可以在固定时间内访问字典中的任何页面

如果这是真的,我很容易看到.但我不知道为什么这个基本假设是正确的:我会使用相同的过程来逐字查找页面.

内存地址也一样,用什么算法加载内存地址？是什么让从地址中找到一块内存变得如此便宜？换句话说,为什么内存访问O(1)？

我是Python的新手,我正在寻找一个标准函数来告诉我元素是否存在于数组中.我找到了该index方法,但如果找不到该元素,则抛出异常.我只需要一些简单的函数,true如果元素在数组中,或者false如果没有,则会返回.

基本上相当于PHP in_array.

Python 的内置异常文档定义LookupError为：

当映射或序列上使用的键或索引无效时引发的异常的基类：IndexError、KeyError。这可以通过 codecs.lookup() 直接引发。

这个基类应该只在捕获使用索引和键访问字典的尝试部分时使用，当一个人想要速记捕获两者时，还是有另一种情况下你会使用它？