标签: recurrence

我正在构建一个需要支持重复事件的组日历应用程序,但是我提出来处理这些事件的所有解决方案看起来都像是一个黑客.我可以限制前方可以看到的距离,然后立即生成所有事件.或者我可以将事件存储为重复,并在日历上向前看时动态显示它们,但如果有人想要更改特定事件实例的详细信息,我将不得不将它们转换为正常事件.

我确信有更好的方法可以做到这一点,但我还没有找到它.对重复事件建模的最佳方法是什么,您可以在其中更改特定事件实例的详细信息或删除特定事件实例？

(我正在使用Ruby,但请不要让这限制你的答案.如果有一个特定于Ruby的库或其他东西,那么,这很有用.)

给出一小段代码,您将如何确定一般的复杂性.我发现自己对Big O问题非常困惑.例如,一个非常简单的问题:

for (int i = 0; i < n; i++) {
    for (int j = 0; j < n; j++) {
        System.out.println("*");
    }
}

电讯局长用类似的东西解释了这一点.像这样是n选择2 =(n(n-1))/ 2 = n ^ 2 + 0.5,然后移除常数使其变为n ^ 2.我可以把int测试值和尝试但是这个组合的东西怎么样？

如果是if语句怎么办？如何确定复杂性？

for (int i = 0; i < n; i++) {
    if (i % 2 ==0) {
        for (int j = i; j < n; j++) { ... }
    } else {
        for (int j = 0; j < i; j++) { ... } …

我正在构建一个日历网站(ASP.NET MVC)应用程序(想想outlook的简单版本),我想开始支持重复出现的日历事件(每月,每年等)

现在我正在存储我的实际日期,但我想弄清楚是否重复,是否有意义继续存储日期(有一些明显的截止),或者我应该存储重复选项并在运行中生成日期.

它让我思考Outlook,谷歌邮件等是如何做这个或任何其他支持重复日历项目的服​​务.

对此有什么建议吗？

我试图解决这种情况

T(n)= 3 T(n/2)+ n lg n ..

我已经得出它属于主要定理案例2的解决方案,因为n lg n是O(n ^ 2)

但在参考解决方案手册后,我注意到他们有这个解决方案

解决方案说,对于0到0.58之间的e,n lg n = O(n ^(lg 3 - e))

所以这意味着n lg n是O(n)..这是对的吗？我错过了什么吗？

不是nlgn O(n ^ 2)？

我一直在编写以下重现关系的程序:

An = 5An-1 - 2An-2  - An-3 + An-4

输出应该是答案模数10 ^ 9 + 7 ..我为此写了一个蛮力方法如下......

long long int t1=5, t2=9, t3=11, t4=13, sum;
while(i--)
{
    sum=((5*t4) - 2*t3 - t2 +t1)%MOD;
    t1=t2;
    t2=t3;
    t3=t4;
    t4=sum;
}
printf("%lld\n", sum);

其中MOD= 10^9 +7 每件事似乎都是真的..但我得到了一些价值的否定答案..由于这个问题,我无法找到正确的解决方案...... Plz帮助保持正确的地方Modulus

我最近发现了一个竞赛问题,要求您计算字符串中必须插入的最小字符数(任何地方)以将其转换为回文结构.

例如,给定字符串:"abcbd"我们可以通过插入两个字符将其转换为回文:一个在"a"之后,另一个在"d"之后:"a d bcbd a ".

这似乎是一个类似问题的概括,要求同样的事情,除了字符只能在最后添加 - 这在使用哈希表的O(N)中有一个非常简单的解决方案.

我一直试图修改Levenshtein距离算法来解决这个问题,但还没有成功.任何有关如何解决这个问题的帮助(它不一定非常有效,我只对任何DP解决方案感兴趣)将不胜感激.

Martin Fowler 在这里为定期任务的调度定义了一个优雅的对象模型,它非常好地映射到OO代码.但是,将此映射到关系数据库模式以实现持久性是很棘手的.

任何人都可以建议一个模式+ SQL组合来封装他描述的所有功能,特别是在第11页的图像中.相交和联合是相当明显的 - 复杂性在于表示'时态表达式',它采用可变参数并且必须被解释不同的,然后将它们组合成'时间集'.

需要说明的是,有很多方法可以表示关系数据库中重复事件的概念.我希望大家输入的是如何映射这个特定的模型.

一些可能的选择:

• 'Meta'表定义参数的数量和使用.丑陋,但可能有效.但是,只有极少数的"时间表达"形式,因此它提供的极大灵活性可能太多了.
• 某种形式的表继承,由Postgres(以及可能是其他)RBMS支持.

序列化参数列表并将结果存储在varchar()中不是解决方案,因为该方法会阻止基于集合的查询:)

此问题来自2011 Codesprint(http://csfall11.interviewstreet.com/):

计算机科学的基础之一是知道数字如何以2的补码表示.想象一下,使用32位写下A和B之间的所有数字,包括2的补码表示.你会写下多少1？输入:第一行包含测试用例数T(<1000).每个下一个T行包含两个整数A和B.输出:输出T行,一行对应于每个测试用例.约束:-2 ^ 31 <= A <= B <= 2 ^ 31 - 1

样品输入:3 -2 0 -3 4 -1 4样品输出:63 99 37

说明:对于第一种情况,-2包含31 1后跟0,-1包含32 1和0包含0 1.因此,总是63.对于第二种情况,答案是31 + 31 + 32 + 0 + 1 + 1 + 2 + 1 = 99

我意识到你可以使用-X中的1的数量等于(-X)= X-1的补码中的0的数量以加速搜索的事实.该解决方案声称有一个O(log X)递归关系用于生成答案但我不明白.解决方案代码可以在这里查看:https://gist.github.com/1285119

如果有人能解释这种关系是如何产生的,我将不胜感激!

问题来自于算法导论第3版,P63,问题3-6,它作为迭代函数引入.我重写如下:

int T(int n){
   for(int count = 0; n > 2 ; ++count)
   {
      n = n/log?(n); 
   }
   return count;
}

然后给出尽可能紧的约束T(n).

我可以把它O(log n)和?(log n / log log n),但它可以是更严格？

PS:使用Mathematica,我已经了解到n=1*10^3281039,T(n)=500000

同时, T(n)=1.072435*log n/ log log n

并且系数n从from 1.22943(n = 2.07126*10^235)到1.072435(n = 1*10^3281039)下降.

愿这些信息有所帮助.

我在尝试计算此代码的时间复杂度时遇到了一些问题:

function foo (int a):
    if a < 1: 
        return 1
    else:
        for i = 1 to 4:
            foo(a - 3)
        for i = 1 to 4:
            foo(a / 2)
end function

据我所知:

T(n) = 1 if n<1

T(n) = 4T(n-3) + 4T(n/2)     if n>=1

     = 4(4T(n-6) + 4T((n-3)/2))  +  4(4T(n/2 - 3) + 4T(n/4))

     ~ 4^2 (T(n-6) + T((n-3)/2) + T(n/2-3) + T(n/4))

现在,它非常复杂,因为下一个T的数量增加了2 ^ n,而且孩子也很复杂.

有没有其他方法可以解决这个问题？