小编use*_*670的帖子

所以我试图在Fibonacci序列中尽可能紧凑地写出第n个数:

public uint fibn ( uint N ) 
{
   return (N == 0 || N == 1) ? 1 : fibn(N-1) + fibn(N-2);
}

但我想知道我是否可以通过改变来使其更加紧凑和高效

(N == 0 || N == 1)

进入单一比较.是否有一些奇特的位移操作可以做到这一点？

每当我读到async- 时await,用例示例总是存在一个您不想冻结的UI.所有编程书籍/教程都是相同的,或者UI阻止是唯一的例子async- await作为开发人员我应该知道.

有没有人可以使用的例子async- await在算法中剔除性能优势？就像让我们采取任何经典的编程面试问题:

• 在二叉树中查找最近的共同祖先
• 给出a[0],a[1]......,a[n-1]表示基数为10的数字,找到使用相同数字的下一个最高数字
• 找到两个排序数组的中位数(即如果你要合并它们的中位数)
• 给定一组数字1,2......,n丢失一个数字,找到丢失的数字
• 找到数组中最大的2个数字

有没有办法使用async- await具有性能优势？如果是这样,如果你只有1个处理器怎么办？那么你的机器不是只是在任务之间分配时间而不是同时真正地执行它们吗？

我想返回满足一元谓词的第一个元素的索引.

例:

[1,2,3,4,5,6,7].indexOf((x) => x % 3 === 0) // returns 2

有这样的功能吗？我打算用的替代方案是

[1,2,3,4,5,6,7].reduce((retval,curelem,idx) => 
{
   if(curelem % 3 === 0 && retval === undefined)
       retval = idx; 
   return retval;
}, undefined);

但是当然效率会降低,因为它在找到元素后不会停止遍历数组.

假设我的数据库中有一个表格

                           Registrants
=======================================================================
  id |    name    |            email        |    registration_date
=======================================================================
  1  |   "Sam"    | "sammypie49@gmail.com"  |    "2016-03-26T14:25:10"
-----------------------------------------------------------------------
  2  |   "Bob"    | "bthebuilder@msn.com"   |    "2015-12-01T10:09:30"
-----------------------------------------------------------------------
  .  |     .      |           .             |              .
-----------------------------------------------------------------------
  .  |     .      |           .             |              .
-----------------------------------------------------------------------
  .  |     .      |           .             |              .
-----------------------------------------------------------------------
  .  |     .      |           .             |              .

我希望每个注册人在注册后100天自动删除.什么是正确的方法,最好的方法是什么？

我打算做的那种粗制滥造的方式就是创造一个sproc

CREATE PROCEDURE FlushOldRegistrants
AS
BEGIN
   DELETE FROM Registrants WHERE DATEADD(day,100,registration_date) < GETDATE()
END

并且在我的服务器端代码中每隔一段时间调用一次sproc就像

Script.SetInterval(delegate {
    using (var conn = …

我正试图解决几乎就是这个问题.特别是我给一个字符串s,使得s.Length % 4 == 0各s[i]是一个'A','C','T'或'G'.我想找到我可以更换,使每个最小子'A','C','T'并'G'准确显示s.Length / 4时间.

例如,使用s="GAAATAAA"中,一个最佳的解决方案是更换一个子"AAATA"带"TTCCG",从而产生"GTTCCGAA".

我在下面的评论中描述了我的方法,我想知道它是否真的正确,因为它会让我得到正确的答案.

using System;
using System.Collections.Generic;
using System.IO;
using System.Linq;
using System.Text;
class Solution
{
    static string ReplacementForSteadiness(string s)
    {   
        var counter = new Dictionary<char,int>() {
            { 'A', 0 }, { 'C', 0 }, { 'G', 0 }, { 'T', 0 …

例如，与

k=10
A=[2,1,3]
B=[7,8,9]

答案是肯定的，因为您可以重新排列元素

A=[1,2,3]
B=[9,8,7]

A[i]+B[i] >= 10 = k那么对于来说这是真的i=0,1,2。我的算法是贪心的，就像

int k = parameters[1];
int[] A = Array.ConvertAll(Console.ReadLine().Split(' '), Int32.Parse);
int?[] B = Array.ConvertAll(Console.ReadLine().Split(' '), Extensions.ToNullableInt);

Array.Sort(B);
for(int j = 0; j < A.Length; ++j)
{
    bool found = false;
    for(int m = 0; j < B.Length && !found; ++j)
    {
        if(B[m] == null)
            continue;
        if((A[j] + B[m]) >= k)
        {
            found = true;
            B[m] = null;
        }
    }
    if(!found)
    {
        Console.WriteLine("NO");
        return;
    }
} …

这个帖子说LINQ OrderBy使用Quicksort.我正在努力解决这个问题,因为它OrderBy返回了一个IEnumerable.

我们以下面的代码为例.

int[] arr = new int[] { 1, -1, 0, 60, -1032, 9, 1 }; 
var ordered = arr.OrderBy(i => i); 
foreach(int i in ordered)
    Console.WriteLine(i); 

循环相当于

var mover = ordered.GetEnumerator();
while(mover.MoveNext())
    Console.WriteLine(mover.Current);

在MoveNext()返回下一个最小元素.该LINQ工作,除非你通过使用查询的"套现"的方式ToList()或类似的,还有不应该产生的任何中间的列表,所以每次你打电话MoveNext()的IEnumerator找到下一个最小元素.这没有意义,因为在Quicksort的执行过程中,没有当前最小和下一个最小元素的概念.

我在这里思考的缺陷在哪里？

我有一个prototype写在Array类上的函数，比如

Array.prototype.myfunc = () => 
{
   // ... 
}

当我在一个数组上调用它时，身体this指window的是

var result = [1, 69, -1, 1].myfunc();

我怎样才能让它引用它被调用的数组？

总结一下游戏，有 N 个高度为 M 的塔，每回合玩家可以将一座塔减少到除其高度但不等于其高度的数字，目标是让对手在以下情况下无路可走：轮到他了。

例如，如果N=2,M=2第一个玩家输了，因为他唯一能做的动作是将其中一个塔降低到高度 1，之后另一个玩家唯一能做的动作是将另一个塔降低到高度 1，现在第一个玩家有没有动作可做。

我开始写这个，但它变得太复杂了，我无法真正看到非素数上的“模式”，M例如4。我应该有更好的方式来思考这个问题吗？

1 --> Lose
1 1 --> Lose
1 1 1 --> Lose
etc. 

2 --> Win
2 2 --> Lose
2 2 2 --> Win
2 2 2 2 --> Lose
etc. 

3 --> Win
3 3 --> Lose
3 3 3 --> Win
3 3 3 3 --> Lose
etc.

4 --> Win
4 4 --> Lose (see tree below)

                   4,4                        1's turn
                  / …

这让我很困惑.

我的理解是,当我编译应用程序时,它变成了我的操作系统读取的优化代码.我的源代码中的内容(如变量名,行号等)不再具有意义.

那么我怎样才能构建和运行代码

try
{
    // ... 
}
catch ( Exception E )
{
    Console.WriteLine("Exception occured: {0}", E.StackTrace);
} 

并获取有关我的源代码的哪一部分可以解除异常的所有详细信息.

现在,我明白在.NET中我的C#代码并不是最初的低级"操作系统代码",而是微软中介语言.我猜测MIL为了生成这个异常信息,我在源代码和编译代码之间存在某种类型的映射.这似乎是一个巨大的浪费,不是吗？因此,.NET中的"编译"并不是真正将源代码转换为机器代码; 除了源代码之外,它还在创建机器代码.这意味着我的Windows机器上的所有应用程序都有与其源代码相关的元数据.

或者我完全错了这一切？