小编col*_*ang的帖子

对于一个简单的数组长度为5的问题(实际上数组长度可能是20 ..)

我有一个预定义的一套模式,如AAAAB,AAABA,BAABC,BCAAA,....每个模式与输入数组的长度相同.我需要一个函数,它接受任何整数数组作为输入,并返回它匹配的所有模式.(一个数组可能匹配几个模式)尽可能快.

" A "表示在该模式中,A位置的所有数字都相等.例如,AAAAA仅表示所有数字相等,{ 1,1,1,1,1 }与AAAAA匹配.

" B "表示位置B处的数字不等于A位置处的数字.(即,不是A的数字的通配符)B表示的数字不必相等.例如,ABBAA表示第1,第4,第5个数字等于,例如x,第2个,第3个不等于x. { 2,3,4,2,2 }与ABBAA相匹配.

" C "表示该位置可以是任何数字(即数字的通配符).{ 1,2,3,5,1 }匹配ACBBA, { 1,1,3,5,1 }也匹配ACBBA

我正在寻找一种有效的(在比较数字方面)算法.它不一定是最优的,但不应该是最佳的.我觉得它有点像决策树......

一种非常简单但效率低下的方法如下:

• 尝试将每个模式与输入匹配.说AABCA反对{a,b,c,d,e}.它检查是否(a=b=e && a!=c).

• 如果模式的数量是n,模式/数组的长度是m,则复杂度约为O(n*m)

更新:

请随意为这个问题提出更好的措辞,因为我不知道如何在没有混淆的情况下简单地理解问题.

理想的算法需要某种准备,比如将模式集转换为决策树.因此,对于某些特殊模式集,预处理后的复杂性可以实现为O(log n*log m).(只是猜测) …

我知道预分配矢量或矩阵很有用,因为它们总是存储在一个连续的内存块中.

但是,就列表而言,它可以包含差异长度和模式的元素.所以我的第一个猜测是列表可能只包含指向其元素的真实地址的指针.我对么？这里有一个相关的问题列表的内部实现是什么？它说列表本质上是一个数组,但它不包括元素如何存储在列表中,而每个元素的大小可能会改变.

示例1:如果列表包含a,b,c,d,e,何时myList$a<-1:1000000,是否已修改列表(仅a表示更新)或整个列表是否已复制和更新？

例2

> system.time( { myList <- list()
+                myList$a <- 1:10000000
+                myList$b <- 1:10000100
+                myList$c <- 1:10000200 
+                myList$d <- 1:10000300})
   user  system elapsed 
   0.01    0.02    0.03

> system.time({ myList2<-list(a=1:10000000,b=1:10000100,c=1:10000200,d=1:10000300) })
   user  system elapsed 
   0.00    0.03    0.03 

由于没有预先分配,myList效率会非常低myList2吗？或者没有明显的性能差异,无论有多大a,b,c,d,因为第一个只复制指针几倍？

这是预分配.列表看起来如何？它是否仅为指针预分配内存？如果是这种情况,我没有看到任何用途,因为无论如何都没有太多数据复制指针.

> system.time( { myList <- vector("list", 4)
+                myList[[1]] <- 1:10000000
+                myList[[2]] <- 1:10000100
+                myList[[3]]  <- 1:10000200 
+ …

最初我在x86模式下遇到了stackoverflow异常.我注意到x64会优化尾递归,所以我切换到x64编译.并且它在调试模式下优雅地运行.但是当我尝试运行发布代码时...它再次抛出stackoverflow ..任何可能的原因？

我已经做了一些关于List.Contains,Array.Contains,IEnumerable.Contains,ICollection.Contains和IList.Contains的基准测试.

结果是:

array pure 00:00:45.0052754 // 45 sec, slow
array as IList 00:00:02.7900305
array as IEnumerable 00:00:46.5871087 // 45 sec, slow
array as ICollection 00:00:02.7449889
list pure 00:00:01.9907563
list as IList 00:00:02.6626009
list as IEnumerable 00:00:02.9541950
list as ICollection 00:00:02.3341203

我发现如果Array.Contains直接调用会很慢(这相当于调用IEnumerable)

另外我觉得奇怪的是,MSDN数组页面没有contains在扩展方法部分列出的方法.

示例代码:

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Diagnostics;

namespace arrayList
{
    class Program
    {
        static void Main(string[] args)
        {
            Stopwatch watch = new Stopwatch();
            Int64 n = 100000000;
            Int64[] myarray = …

董事会是int[][],我想找到这种形状

  1
    1
    1

从板上的所有4个对称(旋转)变体并记录位置.例如

      ...
      ...
  ... x x x x x x ...
  ... x x 1 1 x x ...
  ... x 1 x x x x ...
  ... x x x x x x ...
      ...
      ...

使用F#处理这类问题会更​​好吗？

下面是我的c#代码,用于垂直检查模式(水平检查的代码是simillar)

    List<Position> GetMatchVertical(int reelID)
    {
        List<Position> ret = new List<Position>();

        var myReel = board[reelID];
        var leftReel = reelID - 1 >= 0 ? board[reelID - 1] : null;
        var rightReel = reelID + 1 < boardSize …

 var a = new double[7000,7000];

 FillValue(a,3);

似乎.Net a在执行第一行后实际上并没有分配任何内存.只有在它正在运行时,FillValue它才会逐渐占用内存.(约400MB)

任何人都可以向我提供有关它的更多细节吗？我认为a默认初始化后填充0,怎么可能根本没有内存？

R似乎忽略了我的最后一行,这很奇怪.Rprofile.

例如,在 .Rprofile

 ...
 test<-function()1 # without line ending

因此,test除非成功加载其余部分,否则永远不会加载.如果我手动加载它source(".Rprofile"),test加载正常.

这是理想的行为吗？

在R studio下使用Linux 3.0中的R 3.0 +

任何人都可以重现这个吗？

df = pd.DataFrame({'a':[2,3,5], 'b':[1,2,3], 'c':[12,13,14]})
df.set_index(['a','b'], inplace=True)
display(df)
s = df.iloc[1]
# How to get 'a' and 'b' value from s? 

令人讨厌的是,列成为索引,我们不能简单地使用df ['colname']来获取值.

它鼓励我们使用set_index(drop=False)吗？

我有一个结构

struct Foo {
    foo1: String,
    foo2: String,
    foo3: String,
    foo4: String,
    // ...
}

我想Foo从向量创建一个实例。

let x = vec!["a".to_string(), "b".to_string(), "c".to_string(), "d".to_string()];
match x.as_slice() {
    &[ref a, ref b, ref c, ref d] => {
        let foo = Foo {
            foo1: a.to_string(),
            foo2: b.to_string(),
            foo3: c.to_string(),
            foo4: d.to_string(),
        };

    },
    _ => unreachable!(),
}

我必须复制字符串吗？有没有更好的方法将向量解构为a, b, c,d并转移所有权？

事实上，我不介意x解构后被彻​​底摧毁。所以我希望除了切片之外还有向量的模式匹配。目前看来我们只能解构切片。

在性能提示中，它说f(x::Int...) = tuple(x...)不会专门化。它还建议用于(@which f(...)).specializations检查专业化。

f(x::Int...) = tuple(x...)

f(1)
f(1, 2)
f(1, 2, 3)
f(1, 2, 3, 4)

a = first(methods(f)).specializations

Core.TypeMapEntry(Core.TypeMapEntry(nothing, Tuple{typeof(f),Int64}, nothing, svec(), 0x0000000000000001, 0xffffffffffffffff, MethodInstance for f(::Int64), true, true, false), Tuple{typeof(f),Int64,Vararg{Int64,N} where N}, nothing, svec(), 0x0000000000000001, 0xffffffffffffffff, MethodInstance for f(::Int64, ::Vararg{Int64,N} where N), false, true, true)

我如何解释TypeMapEntry? 如何以编程方式访问它（我发现很难从输出中读取）？它做了多少专业？