标签: coding-efficiency

10^6在R代码中使用科学记数法(正如我通常所做的那样)导致计算时间明显长于使用计算器表示1e6:

> system.time(for (t in 1:1e7) x=10^6) 
  utilisateur     système      écoulé 
        4.792       0.000       4.281 
> system.time(for (t in 1:1e7) x=1e6) 
 utilisateur     système      écoulé 
       0.804       0.000       1.051
> system.time(for (t in 1:1e7) x=exp(6*log(10)))
 utilisateur     système      écoulé 
       6.301       0.000       5.702

为什么R会10^6在计算的大致相同的时间内重新计算exp{6*log(10)}？我理解R在计算时执行一个函数的事实10^6,但为什么它以这种方式编码？

的要求是,以确定最有效的方法来呈现一个字符串,例如,"#1a2b3c",其中"1a2b3c"随机从该组中选择

"abcdef0123456789"

要么

["a", "b", "c", "d", "e", "f", "0", "1", "2", "3", "4", "5", "6", "7", "8", "9"]

为了比较结果的一致性,弦.length应该是精确的7,如上面的例子所示.

确定过程时间的迭代次数应10000如下面的代码所示.

我们可以通过两个前瞻性的例子和基准来开始调查.这些方法的基准应包括在答案的文本中.请注意,如果可以使用更准确的基准测试,或者可以改进问题文本,请在评论时提出建议.相关:能够流利使用Javascript的人向我解释这里发生的事情简单.

function randColor() {
  return '#' + (function co(lor) {
    return (lor += [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 'a', 'b', 'c', 'd', 'e', 'f'][Math.floor(Math.random() * 16)]) &&
      (lor.length == 6) ? lor : co(lor);
  })('');
}

console.time("random string recursion");

for (let i …

我有一个监视 S3 存储桶的 AWS lambda 函数。当图像上传到存储桶时，lambda 函数会创建图像的缩略图。然而，我在函数中犯了一个错误，并将转换后的文件保存在正在监视的同一目录中，从而创建了无限循环。

它运行了大约一分钟，然后我停止了它，并在这段时间内创建了 600,000 张图像。但是，删除这些映像（使用 AWS 控制台）大约需要 20 分钟。

为什么会有这样的差异？我对其中的低级原因感兴趣。

目前我正在开发我的第一个应用程序,并且我注意到正在出现的某些工作流模式.具体来说,Android应用程序遵循一种类似树的用户活动流,其中每个用户操作通常要么进入树的更深的分支,要么返回到根.

因此,从中出现的开发模式是:添加可操作的小部件 - >为它们添加侦听器方法 - >发送意图以启动新活动并将数据传递给它们 - >构造新的活动布局和类以接收此数据 - >重复一遍.

然后在某些活动中会有小部件显示数据库数据(所以你必须设置CursorAdapters等),还有一些修改数据库数据(所以你必须实现更新/添加/删除方法等).

我的问题是:有没有办法自动化这个工作流程,或者以其他方式使其更有效率？即是某种基于模式的脚本,你在哪里绘制活动的树结构,什么项需要CursorAdapters等,然后它为该模式写出骨架类？似乎编码"狗工作",可以说,例如敲击应用程序的骨架方面,占用了大量的打字工作而不是丰富的功能.

我想我正在寻找的是洞察力量编码器或"精英"通常如何编写Android应用程序.

干杯

我有这个向量:

using namespace std;

vector< pair<short, string> > vec = {};

我想找出是否存在对<a, b>带b == X.

我知道std::find从<algorithm>,但不知道如何在这里使用它.

我应该写自己的功能吗？

bool is_in_vec(X)
{
    for (auto& e : vec)
        if (e.second == X)
            return true;
    return false;
}

这有效吗？

在 C++ 中实现图的邻接表表示的有效方法是什么？

1. 向量*边；
2. 列出*边；
3. 地图<int, int> *边缘;
4. 地图<int, 地图<int, int>> 边；

在我看来，应该是选项3或4，但我找不到使用它的任何缺点......有什么缺点吗？

有人可以帮助我，这将是实现邻接表和竞争性编程的最有效方法吗？

我已经看到过这个问题的以前的解决方案，但它都是带有检查功能的完整搜索，对我来说不够快。

我正在开发一个 C++ 程序，试图在给定的整数范围内高效地生成所有素数回文。对于主要部分，我通过消除 2 和 3 的所有倍数来减少我测试的除数，从而创建了一个快速素数测试器，不过这里的改进建议也将受到赞赏（函数粘贴在下面）。

我的主要问题是我需要足够快地生成回文，而不使用传统的完整搜索和回文测试来缓慢增加测试的整数。我当前的搜索代码和素性测试粘贴在下面。

我尝试增加中间数字的数字，然后增加外部数字的数字，但是因为随着时间的推移，会添加更多的数字，我什至无法拼凑出一个算法。

素性测试：

bool CheckPrime(int n){
    switch (n) {
    case 1: return false;  break;
    case 2: return true;  break;
    case 3: return true;  break;
    default: break;
    }
    if (n % 2 == 0 || n % 3 == 0) {
        return false;
    }
    for (int i = 5; i * i <= n; i = i + 6) {
        if (n % i == 0 || n % (i + 2) == …

这里是方法接收两个数组作为参数,得分数组(按降序排列),其中包含重复值,我删除了副本并将其存储在一个没有重复的新数组中,第二个数组包含特殊的玩家分数.

我需要在她的阵列中的每个分数中评估她在分数数组中的排名.我可以使用for循环,但它需要很长时间,我尝试使用Array .IndexOf方法但我得到-1为非现有值.

码:

static int[] climbingLeaderboard(int[] scores, int[] alice)
{
    var aliceRecord = new List<int>();
    int[] oneArray;
    oneArray = scores.Distinct().ToArray();
    foreach (var aliceScore in alice)
    {
        if (aliceScore < oneArray[oneArray.Length - 1])
        {
            aliceRecord.Add(oneArray.Length + 1);
        }
        else
        {
            var rank = Array.IndexOf(oneArray, aliceScore);
            if (rank < 0)
            {
              //Here I need the help
              //I comented the un efficient code
               //for (int i = 0; i < oneArray.Length; i++)
               //{
               //    if (aliceScore >= oneArray[i])
               //    {
               //        aliceRecord.Add(i …

我的JS代码:

console.clear();


function BaseClass(nname) {
  var name = nname;

  this.bc_PublicProperty = "DefaultValue_BaseClass";

  this.bc_getName = function GetName() {
    return name;
  };

  this.bc_setName = function SetName(nname) {
    name = nname;
  };
}

function SubClass(nname) {
  BaseClass.call(this, nname);

  this.sc_PublicProperty = "DefaultValue_SubClass";

  this.sc_getName = function GetName() {
    return name;
  };

  this.sc_setName = function SetName(nname) {
    name = nname;
  };
}

SubClass.prototype = Object.create(BaseClass.prototype);
SubClass.prototype.constructor = SubClass;

var bc = new BaseClass("Anton");
var sc = new SubClass("Bernd");

console.log("hasOwnProperty check on subclass object 'sc' returns true …

下面的代码从list.txt文件中搜索400多个数字,以查看它是否存在于指定的文件夹路径中的任何文件中.

该脚本非常慢并且尚未完成,因为它在运行25分钟后没有完成.我们正在搜索的文件夹是507 MB(532,369,408字节),它包含1,119个文件和480个文件夹.任何有助于提高搜索速度和效率的帮助都非常感谢.

$searchWords = (gc 'C:\temp\list.txt') -split ','
$results = @()
Foreach ($sw in $searchWords)
{
    $files = gci -path 'C:\Users\david.craven\Dropbox\Asset Tagging\_SJC Warehouse_\_Project Completed_\2018\A*' -filter "*$sw*" -recurse

    foreach ($file in $files)
    {
        $object = New-Object System.Object
        $object | Add-Member -Type NoteProperty –Name SearchWord –Value $sw
        $object | Add-Member -Type NoteProperty –Name FoundFile –Value $file.FullName
        $results += $object
    }

}

$results | Export-Csv C:\temp\output.csv -NoTypeInformation