标签: aggregate

可能重复:
有效地查找数字的所有除数

这更像是一个效率问题,而不是通用的"找到一种方法",但在得到一些奇怪的结果后,我想看看是否有人可以告诉我为什么最后一种方式如此低效:

方式1:蛮力,没有优化

    public static List<int> proper_divisors(int x)
    {
        List<int> toreturn = new List<int>();
        for (int i = 1; i <= Math.Floor(Math.Sqrt(x)); i++)
        {
            if (x % i == 0)
            {
                toreturn.Add(i);
                toreturn.Add(x / i);
            }
        }
        if (toreturn.ElementAt(toreturn.Count() / 2) == toreturn.ElementAt(toreturn.Count() / 2 - 1))
        {
            toreturn.Remove(toreturn.ElementAt(toreturn.Count() / 2));
        }

        return toreturn;
    }

方式2:与之前相同,但这一次,检查它是否为第一个(因为这些情况占用了大部分时间,使用miller-rabin进行初步检查)

        public static List<int> proper_divisors(int x)
    {
        List<int> toreturn = new List<int>();
        if (!isprime(x))
        {
            for (int i = 1; i <= Math.Floor(Math.Sqrt(x)); i++) …

考虑以下mypair类(我不确定这是否是最好的做事方式,但似乎有效):

#include <iostream>

struct A
{
  A() {}
  A(const A&) { std::cout << "Copy" << std::endl; }
  A(A&&) { std::cout << "Move" << std::endl; }
  std::string s;
};

template <class T0, class T1>
struct mypair
{
  T0 x0;
  T1 x1;
};

template <class T0, class T1, int N = -1>
struct get_class {};

template<class T0, class T1>
struct get_class<T0, T1, 0>
{
  static T0& get_func(mypair<T0, T1>& x) { return x.x0; }
  static const T0& get_func(const mypair<T0, T1>& x) …

有更快的方法吗？我想这是不必要的慢,并且这样的任务可以通过基本功能完成.

df <- ddply(df, "id", function(x) cbind(x, perc.total = sum(x$cand.perc)))

我是很新的R.我已经看过了by(),aggregate()和tapply(),但并没有让他们在所有或我想要的方式工作.我希望将总和附加到原始数据帧,而不是返回较短的向量.做这个的最好方式是什么？

编辑:这是应用于我的数据的答案的速度比较.

> # My original solution
> system.time( ddply(df, "id", function(x) cbind(x, perc.total = sum(x$cand.perc))) )
   user  system elapsed 
 14.405   0.000  14.479 

> # Paul Hiemstra
> system.time( ddply(df, "id", transform, perc.total = sum(cand.perc)) )
   user  system elapsed 
 15.973   0.000  15.992 

> # Richie Cotton
> system.time( with(df, tapply(df$cand.perc, df$id, sum))[df$id] )
   user  system elapsed 
  0.048   0.000   0.048 

> # John
> system.time( …

我真正的问题与记录哪些大量的反病毒产品同意给定的样本是给定的反病毒家族的成员有关.该数据库有数百万个样本,每个样本都有数十种反病毒产品投票.我想问一个问题,如"对于包含名称'XYZ'的恶意软件,哪个样本得票最多,哪些供应商投票支持？" 得到如下结果:

"BadBadVirus"  
                     V1  V2  V3  V4  V5  V6  V7  
Sample 1 - 4 votes    1   0   1   0   0   1   1      
Sample 2 - 5 votes    1   0   1   0   1   1   1   
Sample 3 - 5 votes    1   0   1   0   1   1   1  

 total     14         3       3       2   3   3  

可能会用来告诉我供应商2和供应商4或者不知道如何检测这种恶意软件,或者他们将其命名为不同的东西.

我会尝试略微概括我的问题,同时希望不会破坏你帮助我的能力.假设我有五个选民(Alex,Bob,Carol,Dave,Ed)被要求查看五张照片(P1,P2,P3,P4,P5)并决定照片的"主要主题"是什么.对于我们的例子,我们只假设它们仅限于"猫","狗"或"马".不是每个选民都对每件事都投票.

数据以这种形式存在于数据库中:

Photo, Voter, Decision
(1, 'Alex', 'Cat')
(1, 'Bob', 'Dog')
(1, 'Carol', 'Cat')
(1, 'Dave', 'Cat')
(1, 'Ed', 'Cat')
(2, 'Alex', 'Cat')
(2, 'Bob', 'Dog') …

我有一个数据帧:

Type Name Cost
  A   X    545
  B   Y    789
  C   Z    477
  D   X    640
  C   X    435
  B   Z    335
  A   X    850
  B   Y    152

我的数据框中有所有这样的组合,类型为['A','B','C','D']和名称['X','Y','Z'].我使用groupby方法获取特定组合的统计数据,如AX,AY,AZ.这是一些代码:

df = pd.DataFrame({'Type':['A','B','C','D','C','B','A','B'] ,'Name':['X','Y','Z','X','X','Z','X','Y'], 'Cost':[545,789,477,640,435,335,850,152]})
df.groupby(['Name','Type']).agg([mean,std])  
#need to use mad instead of std  

我需要消除超过3 MAD的观察结果; 就像是:

test = df[np.abs(df.Cost-df.Cost.mean())<=(3*df.Cost.mad())]

我对此感到困惑,因为df.Cost.mad()返回整个数据上的Cost的MAD而不是特定的Type-Name类别.我怎么能把两者结合起来？

我有一个名为"names.txt"的文件,其中包含以下内容:

{"1":[1988, "Anil 4"], "2":[2000, "Chris 4"], "3":[1988, "Rahul 1"],
"4":[2001, "Kechit 3"], "5":[2000, "Phil 3"], "6":[2001, "Ravi 4"],
"7":[1988, "Ramu 3"], "8":[1988, "Raheem 5"], "9":[1988, "Kranti 2"],
"10":[2000, "Wayne 1"], "11":[2000, "Javier 2"], "12":[2000, "Juan 2"],
"13":[2001, "Gaston 2"], "14":[2001, "Diego 5"], "15":[2001, "Fernando 1"]}

问题陈述:文件"names.txt"包含一些格式的学生记录 -

{"number": [year of birth, "name rank"]}

解析此文件并根据年份对其进行隔离,然后根据排名对名称进行排序.首先进行隔离然后排序.输出应采用以下格式 -

{year : [Names of students in sorted order according to rank]}

所以预期的产量是 -

{1988:["Rahul 1","Kranti 2","Rama 3","Anil 4","Raheem 5"],
2000:["Wayne 1","Javier 2","Jaan 2","Phil 3","Chris …

我正在使用django 1.9

型号:

class Comment(models.Model):
    title = models.CharField(max_length=250, null=False)
    date = models.DateField(auto_now_add=True)

由于'extra()'将在django中弃用,我试图弄清楚如何在不使用'额外'的情况下按年份计算评论组

这是带额外的代码:

Comment.objects.extra(select={'year': "EXTRACT(year FROM date)",
    'month': "EXTRACT(month from date)"})\
    .values('year', 'month').annotate(Count('pk'))

谢谢您的帮助.

为什么我不能像这样对std :: array进行脱盐？

#include <array>

struct Point
{
    float x;
    float y;
};

int main()
{
   std::array<Point, 3> m_points { 
      { 1.0f, 1.0f }, 
      { 2.0f, 2.0f }, 
      { 3.0f, 3.0f }
   };
}

这样做我得到错误:

错误:初始化程序太多了 std::array<Point, 3ul>

但它的工作原理如下:

std::array<Point, 3> m_points { 
   Point{ 1.0f, 1.0f }, 
   Point{ 2.0f, 2.0f }, 
   Point{ 3.0f, 3.0f } 
};

相比之下,std::map可以使用以下两种方式初始化:

   std::map<int, int> m1 {std::pair<int, int>{1,2}, std::pair<int, int>{3,4}}; 
   std::map<int, int> m2 {{1,2}, {3,4}};

我有一个关于域驱动设计的问题.在我的应用程序的用户帐户/配置文件有界上下文中,有一个用户实体,其中包含帐户信息(ID,用户名,密码,电子邮件,盐等)和个人资料信息(全名,头像,生日,性别等).我还有另一个有效的工作岗位/应用上下文,其中每个工作岗位都有雇主用户,每个工作申请都有申请人用户.

问题是,作业有限上下文中的雇主/申请人用户是否应该是我用于用户帐户有限上下文的相同用户实体？或者我应该为雇主和申请人设计不同的用户类型实体？

如您所见,只有来自帐户有界上下文的ID,全名,电子邮件和头像等信息才与作业有限的上下文相关.如果雇主/申请人是来自帐户/用户档案的相同用户实体,则它将加载更多无用的数据(不需要知道雇主/申请人的用户密码).但是如果我为它们创建不同的实体类,它将使数据持久性更加棘手,因为在不同实体类中进行的更改可以更改同一数据库表中的相同数据.

你怎么看？我是否应该为不同的有界上下文/聚合使用一个用户实体用于所有或不同的用户实体？如果需要后者,我该如何处理数据/实体持久性？

对于一个小项目,我有一个匹配和结果的注册表.每场比赛都在球队之间进行(可以是单人球队),并且有一个胜利者.所以,我有Match和Team模型,通过加盟MatchTeam模式.这看起来像(简化)^{见下面的注释}

class Team(models.Model):
    ...

class Match(models.Model):
    teams = ManyToManyField(Team, through='MatchTeam')
    ...

class MatchTeam(models.Model):
    match = models.ForeignKey(Match, related_name='matchteams',)
    team = models.ForeignKey(Team)
    winner = models.NullBooleanField()
    ...

现在我想在比赛中做一些统计数据,从查找谁是最能打败你的人开始.我不完全确定如何做到这一点,至少,没有效率.

在SQL(这里只是近似),我的意思是这样的:

SELECT their_matchteam.id, COUNT(*) as cnt
FROM matchteam AS your_mt  
JOIN matchteam AS their_mt ON your_mt.match_id = their_mt.match_id
WHERE your.matchteam.id IN <<:your teams>> 
  your_matchteam.winner = false
GROUP BY their_matchteam.team_id
ORDER BY cnt DESC

^{(这也需要一个"his_mt不是your_mt"子句btw,但这个概念很明确,对吧？)}

虽然我没有将它作为SQL进行测试,但它只是为了深入了解我正在寻找的东西:我想通过Django聚合找到这个结果.

根据手册,我可以使用聚合注释结果,在本例中为a Count.我正在SQL中做的MatchTeams直接加入MatchTeams可能是一个捷径,因为它们Match之间应该存在一个？至少,我不知道如何将其翻译成Django

所以也许我需要为我的团队找到某些匹配项,然后用另一个团队的计数来注释它们？但是"另一支球队"是什么？

快速写入看起来像: …