标签: data-partitioning

假设我有一个列表和一个过滤功能.使用类似的东西

>>> filter(lambda x: x > 10, [1,4,12,7,42])
[12, 42]

我可以得到符合标准的元素.是否有一个我可以使用的函数可以输出两个列表,一个元素匹配,剩下的元素之一？我可以filter()两次调用该函数,但这有点难看:)

编辑:元素的顺序应该是守恒的,我可能多次使用相同的元素.

DataFrame repartition()和DataFrameWriter partitionBy()方法有什么区别？

我希望两者都习惯于"基于数据帧列分区数据"？或者有什么区别？

我有一组数字:

 Set<Integer> mySet = [ 1,2,3,4,5,6,7,8,9]

我想把它分成两组赔率和赔率.

我的方法是使用过滤器两次:

Set<Integer> set1 = mySet.stream().filter(y -> y % 2 == 0).collect(Collectors.toSet())
Set<Integer> set2 =mySet.stream().filter(y -> y % 2 != 0).collect(Collectors.toSet())

我不喜欢这个解决方案,因为我经历了整套两次.

有没有更聪明的方法呢？

我想通过指定每个分区中的元素数量将列表分区为列表列表.

例如,假设我有列表{1,2,... 11},并且想要对其进行分区,使得每个集合具有4个元素,最后一个集合尽可能多地填充元素.生成的分区看起来像{{1..4},{5..8},{9..11}}

写这个的优雅方式是什么？

我有一个矢量,例如c(1, 3, 4, 5, 9, 10, 17, 29, 30),我想将"相邻"元素组合在一起,形成一个规则的连续序列,在一个参差不齐的矢量中导致:

L1:1
L2:3,4,5
L3:9,10
L4:17
L5:29,30

朴素代码(前C程序员):

partition.neighbors <- function(v)
{
    result <<- list() #jagged array
    currentList <<- v[1] #current series

    for(i in 2:length(v))
    {
        if(v[i] - v [i-1] == 1)
        {
            currentList <<- c(currentList, v[i])
        }
        else
        {
            result <<- c(result, list(currentList))
            currentList <<- v[i] #next series
        }       
    }

    return(result)  
}

现在我明白了

a)R不是C(尽管有大括号)
b)全局变量是纯粹的邪恶
c)这是一种实现结果的非常低效的方法

,欢迎任何更好的解决方案.

给出O(n)算法,该算法将数组S作为输入,然后将S分成三组:负数,零和正数.演示如何在适当的位置实现它,即不分配新内存.你必须保持数字的相对顺序.例如:{-1,4,0​​,-2,1,2} ==> {-1,-2,0,4,1,2}

我不确定这样的解决方案是否会退出.我能想到的最佳解决方案是:

解决方案1:使用一个额外的整数数组,然后遍历整个数组得到负数,然后是0,然后是正数.

解决方案2:不要保持数字的相对顺序.然后循环数组两次:

    template <typename Type>  
void Partion(Type *array, int begin, int end, Type v, int &l, int &r) 
{  
    l = begin;  
    for (int i=begin; i!=end; ++i)  
    {  
        if (array[i] < v)  
            swap(array[i], array[l++]);  
    }  
    r = l;  
    for (int j=l; j!=end; ++j)  
    {  
        if (array[j] == v)  
            swap(array[j], array[r++]);  
    }  
} 

我很难将QuickSort与Hoare分区转换为C代码,但无法找到原因.我正在使用的代码如下所示:

void QuickSort(int a[],int start,int end) {
    int q=HoarePartition(a,start,end);
    if (end<=start) return;
    QuickSort(a,q+1,end);
    QuickSort(a,start,q);
}

int HoarePartition (int a[],int p, int r) {
    int x=a[p],i=p-1,j=r;
    while (1) {
        do  j--; while (a[j] > x);
        do  i++; while (a[i] < x);

        if  (i < j)
            swap(&a[i],&a[j]);
        else
            return j;
    }
}

此外,我真的不明白为什么HoarePartition工作.有人可以解释它为什么有效,或者至少把我链接到一篇文章吗？

我已经看到了分区算法的逐步完成,但我没有直观的感觉.在我的代码中,它似乎甚至没有用.例如,给定数组

13 19  9  5 12  8  7  4 11  2  6 21

它将使用数据透视表13,但最终会使用数组

 6  2  9  5 12  8  7  4 11 19 13 21 

并将返回 …

我正在尝试查询Windows Azure存储中的表,并且最初TableQuery.CombineFilters在TableQuery<RecordEntity>().Where函数中使用如下:

TableQuery.CombineFilters(
    TableQuery.GenerateFilterCondition("PartitionKey",   QueryComparisons.GreaterThanOrEqual, lowDate),
    TableOperators.And,
    TableQuery.GenerateFilterCondition("PartitionKey", QueryComparisons.LessThanOrEqual, lowDate),
    TableQuery.GenerateFilterCondition("PartitionKey", QueryComparisons.Equal, entityId)
));

不幸的是,CombineFilters最多只允许2个查询条件.所以我现在正在这样做:

var tableQuery = new TableQuery<RecordRowEntity>()
            .Where(TableQuery.CombineFilters("PartitionKey", string.Format("(PartitionKey ge '{0}') and (PartitionKey le '{1}') and (RowKey eq '{2}')", low, high, entityId));

有没有其他方法可以做到这一点.我认为目前我正在这样做的方式很容易受到Azure Api工作方式的影响.

我在解决以下问题时遇到问题:

对于具有特定分数的配对值,如何将它们分组,只返回具有最佳分数的不同配对值？

例如,假设我有一个包含以下行值的表:

(t1,p1,65)
(t1,p2,60)
(t1,p3,20)
(t2,p1,60)
(t2,p2,59)
(t2,p3,15)

前两列表示配对值,第三列表示配对分数(t1,p1,65).最佳分数为.由于现在使用了t1和p1,我想将它们排除在进一步分析之外.

下一个最好的分数是(t2,p2,59).虽然(t1,p2)得分为60,但我想排除它,因为已经使用了"t1".(t2,p1)也有60分,但由于p1也已被使用,因此该对被排除在外.

这导致不同的对分数值:

(t1,p1,65)
(t2,p2,59)

有没有办法只用一个查询生成这个结果？我试图想出分组和分区结果的方法,但由于必须根据分数等级对已使用的值进行一些计算,我发现这很难接近.

编辑:

要生成数据:

with t(t, p, score) as (
    (values ('t1','p1',65),
           ('t1','p2',60),
           ('t1','p3',20),
           ('t2','p1',60),
           ('t2','p2',59),
           ('t2','p3',15)
     ))
select t.* from t;

我有一个像这样的浮点数组:

[1.91, 2.87, 3.61, 10.91, 11.91, 12.82, 100.73, 100.71, 101.89, 200]

现在,我想像这样对数组进行分区:

[[1.91, 2.87, 3.61] , [10.91, 11.91, 12.82] , [100.73, 100.71, 101.89] , [200]]

// [200]因为群集支持较少而被视为异常值

我必须为几个数组找到这种段,我不知道分区大小应该是多少.我试图通过使用层次聚类(Agglomerative)来实现它 ,它为我提供了令人满意的结果.然而,问题是,我被建议不要将聚类算法用于一维问题,因为它们没有理论上的理由(因为它们用于多维数据).

我花了很多时间来寻找解决方案.但是,建议似乎完全不同,如:这个和这个 VS. 这和这个和这个.

我找到了另一个建议,而不是聚类,即自然中断优化.但是,这也需要声明分区号,如K-means(右？).

这很混乱(特别是因为我必须在几个阵列上执行这种分段,并且不可能知道最佳分区号).

有什么方法可以找到分区(因此我们可以通过一些理论上的合理性来减少分区内的差异并最大化分区之间的差异)？

任何指向文章/论文的指针(如果可用的C/C++/Java实现)都有一些理论上的理由对我很有用.