javascript

java

python

c#

node.js

android

reactjs

c++

php

jquery

html

css

git

ruby-on-rails

.net

ios

sql

c

string

ruby

算法-如何正确估算剩余的下载时间?

当然,您可以将剩余文件大小除以当前下载速度,但是,如果下载速度波动(并且会波动),则不会产生很好的结果。 产生更平稳倒数的更好算法是什么?

trans by 2019-10-15T22:44:31Z

算法-撤消/重做实施

让我思考一下如何实现撤消/重做功能-就像我们在文本编辑器中一样。我应该使用什么算法以及可能阅读什么。 谢谢。

trans by 2019-10-15T16:07:05Z

有没有一种可以像混色一样工作的混色算法?

RGB颜色的常见混合与绘画的混合颜色有很大不同,它是光的混合而不是颜料的混合。

例如:

Blue (0,0,255) + Yellow (255,255,0) = Grey (128,128,128)

(应该是蓝色+黄色=绿色)

是否有任何已知的颜色混合算法可以像混合真实颜色一样工作?


我的方法

我已经尝试过以下操作:

将两种颜色都转换为HSV并混合色相(乘以从饱和度计算得出的系数),以及饱和度和价值渠道的简单平均值。 然后我从两者计算平均亮度颜色并调整结果颜色以匹配此亮度。这工作得很好,但是色调混合有时是错误的,例如。 G。:

Red (Hue 0°) + Blue (Hue 240°) = Green (Hue 120°)

我发现有时需要将色相值偏移360°(当色相大于180°)。

Red (Hue 360°) + Blue (Hue 240°) = Magenta/fuchsia (Hue 300°)

但是这种转变也不是很好,例如:

Cyan (Hue 179°) + Red (Hue 0°) = Hue 89.5°
Cyan (Hue 181°) + Red (Hue 0°) --> shifting is performed (the difference is greater than 180°)
Cyan (Hue 181°) + Red (Hue 360°) = Hue 270.5°

(色调179 +红色)和(色调181 +红色)产生两种完全不同的颜色。


然后,我尝试了CIE Lab色彩空间(例如在Photoshop中),该色彩空间旨在更接近人类如何感知色彩。

我只对每个对应的两个通道使用了一个简单的平均值,但结果并不令人满意,例如,我得到蓝色(98,-16、93)和黄色(30、68,-112)中的粉色(64、26,-9.5)。 这些系数取自Photoshop。

也许我使用的操作与平均操作有所不同,它可以工作,但是我不知道


CMYK也不起作用,结果就像在RGB或LAB中一样。


似乎在这些颜色空间的任何一个中进行琐碎的加法或减色混合都不会产生自然的结果。


工作实施

Krita –绘画混合器

光栅图形编辑器Krita在某个时候可以实现更逼真的色彩混合:[http://commit-digest.org/issues/2007-08-12/](Painterly混合器插件)

他们说这是第一个使用描述颜料行为的Kubelka和Munk方程实现特殊技术的公共应用程序。

这是Krita混色的视频:[https://www.youtube.com/watch?v=lyLPZDVdQiQ]

FiftyThree的论文

在FiftyThree开发的iOS版Paper应用中,也有关于混色的文章。 他们描述了他们在该地区的创新和实验方式,还提供了蓝色和黄色混合得到绿色的样本。 但是,此处并未真正描述实际的过程或算法。

报价:

“在寻找一种好的混合算法时,我们最初尝试在各种颜色空间内进行插值:RGB,HSV和HSL,然后是CieLAB和CieLUV。结果令人失望,” Chen说。 “我们知道红色和黄色应该产生橙色,或者红色和蓝色应该变成紫色-但是无论使用哪种颜色空间,都无法获得这些颜色。有一个工程公理:做最简单的事情就是 嗯,我们现在尝试了最简单的方法,但感觉并不遥远。”

似乎与Krita一样,Paper实现了Kubelka-Munk模型:

Kubelka-Munk模型的每种颜色至少具有六个值,包括每种RGB颜色的反射和吸收值。 “尽管屏幕上的颜色外观可以从三个维度来描述,但是色彩的融合实际上是在一个六维空间中进行的,” FiftyThree的联合创始人兼首席执行官Georg Petschnigg解释说。 Kubelka-Munk的论文使团队能够将美学问题转化为数学框架。 [...]

从所有这些信息来看,基于Kubelka-Munk模型的实现似乎是前进的方向,并提供了更加接近现实的结果。

尽管它看起来像一个复杂的过程,但我还没有看到很多有关如何实现这样的信息。


相关问题

这些问题都在同一问题之后发布。

他们都没有真正的答案。

  • 计算RGB中的混合色
  • 在其他两种颜色之间寻找颜色的算法-在绘画颜色的颜色空间中
  • 像Krita一样实现Kubelka-Munk来混合颜料等颜色

其他相关链接和资源

  • Twitter上的Kubelka-Munk搜索
  • 混合涂料(!! Con 2016)戴安娜·廖(Diana Liao)
    • 滑梯
    • 视频
  • 绘画启发的颜色混合和合成,以实现可视化(N. Gossett,B。Chen)
trans by 2019-10-14T22:55:54Z

语言不可知论-计算相交光盘数量的算法

给定N整数的数组A,我们在2D平面上绘制N个圆盘,使得第i个圆盘的中心为(0,i),半径为A[i]。如果第k个圆盘和第j个圆盘相交,则我们说第k个圆盘和第j个圆盘相交 第j个光盘至少有一个共同点。

写一个函数

int number_of_disc_intersections(int[] A);

给定数组A(如上所述)描述了N个光盘,该数组返回相交的光盘对数。 例如,给定N

A[0] = 1
A[1] = 5
A[2] = 2
A[3] = 1
A[4] = 4
A[5] = 0

有11对相交的光盘:

0th and 1st
0th and 2nd
0th and 4th
1st and 2nd
1st and 3rd
1st and 4th
1st and 5th
2nd and 3rd
2nd and 4th
3rd and 4th
4th and 5th

因此该函数应返回11。如果相交对的数量超过10,000,000,则函数应返回-1。 该函数可以假定N不超过10,000,000。

trans by 2019-10-14T18:13:49Z

算法-生成给定字符串的所有唯一子字符串

给定一个字符串1..n,什么是生成一组所有唯一子字符串的最快方法?

示例:对于1..n,我们将获得O(n^2)

天真的算法是遍历整个字符串,并在每次迭代中生成长度为1..n的子字符串,从而产生O(n^2)上限。

更好的约束可能吗?

(从技术上讲这是家庭作业,因此也欢迎只使用指针)

trans by 2019-10-13T23:17:47Z

算法-查找两个图节点之间的所有路径

我正在研究Dijkstras算法的实现,以检索路由网络上互连节点之间的最短路径。 我正在努力。 当我将起始节点传递到算法中时,它将返回所有节点的所有最短路径。

我的问题:如何检索从节点A到节点G的所有可能路径,甚至从节点A到节点A的所有可能路径。

trans by 2019-10-13T20:40:25Z

c-感知器学习算法未收敛到0

这是我在ANSI C中的感知器实现:

#include <stdio.h>
#include <stdlib.h>
#include <math.h>

float randomFloat()
{
    srand(time(NULL));
    float r = (float)rand() / (float)RAND_MAX;
    return r;
}

int calculateOutput(float weights[], float x, float y)
{
    float sum = x * weights[0] + y * weights[1];
    return (sum >= 0) ? 1 : -1;
}

int main(int argc, char *argv[])
{
    // X, Y coordinates of the training set.
    float x[208], y[208];

    // Training set outputs.
    int outputs[208];

    int i = 0; // iterator

    FILE *fp;

    if ((fp = fopen("test1.txt", "r")) == NULL)
    {
        printf("Cannot open file.\n");
    }
    else
    {
        while (fscanf(fp, "%f %f %d", &x[i], &y[i], &outputs[i]) != EOF)
        {
            if (outputs[i] == 0)
            {
                outputs[i] = -1;
            }
            printf("%f   %f   %d\n", x[i], y[i], outputs[i]);
            i++;
        }
    }

    system("PAUSE");

    int patternCount = sizeof(x) / sizeof(int);

    float weights[2];
    weights[0] = randomFloat();
    weights[1] = randomFloat();

    float learningRate = 0.1;

    int iteration = 0;
    float globalError;

    do {
        globalError = 0;
        int p = 0; // iterator
        for (p = 0; p < patternCount; p++)
        {
            // Calculate output.
            int output = calculateOutput(weights, x[p], y[p]);

            // Calculate error.
            float localError = outputs[p] - output;

            if (localError != 0)
            {
                // Update weights.
                for (i = 0; i < 2; i++)
                {
                    float add = learningRate * localError;
                    if (i == 0)
                    {
                        add *= x[p];
                    }
                    else if (i == 1)
                    {
                        add *= y[p];
                    }
                    weights[i] +=  add;
                }
            }

            // Convert error to absolute value.
            globalError += fabs(localError);

            printf("Iteration %d Error %.2f %.2f\n", iteration, globalError, localError);

            iteration++;
        }

        system("PAUSE");

    } while (globalError != 0);

    system("PAUSE");
    return 0;
}

我正在使用的训练集:数据集

我删除了所有不相关的代码。 基本上现在执行的操作是读取globalError文件,并将文件中的值加载到三个数组中:xyoutputs

然后是一个感知器学习算法,由于某种原因,该算法没有收敛到0(globalError应该收敛到0),因此我得到了一个无限的do while循环。

当我使用较小的训练集(如5分)时,效果很好。 有什么想法可能是问题所在吗?

我编写的算法与此C#Perceptron算法非常相似:


编辑:

这是带有较小训练集的示例:

#include <stdio.h>
#include <stdlib.h>
#include <math.h>

float randomFloat()
{
    float r = (float)rand() / (float)RAND_MAX;
    return r;
}

int calculateOutput(float weights[], float x, float y)
{
    float sum = x * weights[0] + y * weights[1];
    return (sum >= 0) ? 1 : -1;
}

int main(int argc, char *argv[])
{
    srand(time(NULL));

    // X coordinates of the training set.
    float x[] = { -3.2, 1.1, 2.7, -1 };

    // Y coordinates of the training set.
    float y[] = { 1.5, 3.3, 5.12, 2.1 };

    // The training set outputs.
    int outputs[] = { 1, -1, -1, 1 };

    int i = 0; // iterator

    FILE *fp;

    system("PAUSE");

    int patternCount = sizeof(x) / sizeof(int);

    float weights[2];
    weights[0] = randomFloat();
    weights[1] = randomFloat();

    float learningRate = 0.1;

    int iteration = 0;
    float globalError;

    do {
        globalError = 0;
        int p = 0; // iterator
        for (p = 0; p < patternCount; p++)
        {
            // Calculate output.
            int output = calculateOutput(weights, x[p], y[p]);

            // Calculate error.
            float localError = outputs[p] - output;

            if (localError != 0)
            {
                // Update weights.
                for (i = 0; i < 2; i++)
                {
                    float add = learningRate * localError;
                    if (i == 0)
                    {
                        add *= x[p];
                    }
                    else if (i == 1)
                    {
                        add *= y[p];
                    }
                    weights[i] +=  add;
                }
            }

            // Convert error to absolute value.
            globalError += fabs(localError);

            printf("Iteration %d Error %.2f\n", iteration, globalError);          
        }

        iteration++;

    } while (globalError != 0);

    // Display network generalisation.
    printf("X       Y     Output\n");
    float j, k;
    for (j = -1; j <= 1; j += .5)
    {
        for (j = -1; j <= 1; j += .5)
        {
            // Calculate output.
            int output = calculateOutput(weights, j, k);
            printf("%.2f  %.2f  %s\n", j, k, (output == 1) ? "Blue" : "Red");
        }
    }

    // Display modified weights.
    printf("Modified weights: %.2f %.2f\n", weights[0], weights[1]);

    system("PAUSE");
    return 0;
}
trans by 2019-10-13T09:06:42Z

自动完成算法?

我指的是当用户在Google中键入搜索字词时用于提供查询建议的算法。

我主要感兴趣:1.最重要的结果(最可能的查询,而不是任何匹配的结果)2.匹配子字符串3.模糊匹配

我知道您可以使用Trie或广义Trie来查找匹配项,但不满足上述要求...

前面在这里问过类似的问题

trans by 2019-10-13T07:55:02Z

python-查找字符串中子序列出现的次数

例如,假设字符串是pi的前10位数字1.*2.*3,子序列为123。请注意,该序列出现了两次:

3141592653
 1    2  3
   1  2  3

这是一个面试问题,我无法回答,也无法想到一种有效的算法,这困扰着我。 我觉得应该可以使用一个简单的正则表达式,但是像1.*2.*3这样的正则表达式不会返回每个子序列。 我在Python中的幼稚实现(每1个计数后的2个计数为3)已经运行了一个小时,但还没有完成。

trans by 2019-10-11T19:03:37Z

图表-图表上“精巧”的网格线间隔的算法

我需要一种合理的智能算法来为图形(图表)提供“不错”的网格线。

例如,假设条形图的值分别为10、30、72和60。您知道:

最小值:10最大值:72射程:62

第一个问题是:您从什么开始? 在这种情况下,0是直观的值,但这在其他数据集上不成立,因此我猜测:

网格最小值应为0或比范围内数据的最小值低的“ nice”值。 或者,可以指定它。

网格最大值应为该范围内的最大值之上的“ nice”值。 或者,可以指定它(例如,如果要显示百分比,则可能需要0到100,而不考虑实际值)。

应该指定该范围内的网格线(刻度)的数量,或者指定给定范围内的网格线的数量(例如3-8),以使值成为“ nice”(即整数),并最大程度地利用图表区域。 在我们的示例中,80将是一个明智的最大值,因为它将使用图表高度的90%(72/80),而100将创建更多的浪费空间。

有人知道一个好的算法吗? 语言无关紧要,因为我将按需要实现语言。

trans by 2019-10-11T16:33:25Z

的“ For”循环第一次迭代

我想询问在第一次循环迭代中是否存在一种优雅的pythonic方式来执行某些功能。我能想到的唯一可能性是:

first = True
for member in something.get():
    if first:
        root.copy(member)
        first = False
    else:
        somewhereElse.copy(member)
    foo(member)
trans by 2019-10-11T12:41:19Z

linq-C#确定Lis中的重复项

要求:在未排序的列表中,确定是否存在重复项。 我执行此操作的典型方法是n平方嵌套循环。 我想知道其他人如何解决这个问题。 Linq中是否有一种优雅,高性能的方法? 带有lambda或比较器的通用类会很好。

trans by 2019-10-10T21:37:28Z

交换两个变量而不使用临时变量

我希望能够交换两个变量,而无需在C#中使用临时变量。 能做到吗?

decimal startAngle = Convert.ToDecimal(159.9);
decimal stopAngle = Convert.ToDecimal(355.87);

// Swap each:
//   startAngle becomes: 355.87
//   stopAngle becomes: 159.9
trans by 2019-10-10T09:27:58Z

人工智能-我可以使用哪种井字游戏算法来确定AI的“最佳举动”?

在井字游戏实施中,我想最具挑战性的部分是确定机器要发挥的最佳动作。

可以采用哪些算法? 我正在研究从简单到复杂的实现。 我将如何解决这部分问题?

trans by 2019-10-09T01:44:33Z

图自动布局算法

为了简化问题,我有一个图形,其中包含2D平面上的节点和边。

我想要做的是单击一个按钮,它使图形自动布局以使其看起来干净。 我的意思是说,边的最小交叉,节点之间的间隔很好,甚至可以表示图形比例(加权边)。

我知道这完全是什么看起来很干净的图形的主观,但是有人知道算法是从头开始的,而不是重新发明轮子的吗?

谢谢。

trans by 2019-10-07T07:36:38Z

算法-后缀树和Tries。 有什么区别?

我正在阅读大约Tries,通常称为前缀树和Suffix Trees
尽管我找到了Trie的代码,但找不到Suffix Tree的示例。我还感觉到,构建Trie的代码与Suffix Tree的代码相同,唯一的区别是在我们存储的前一种情况下 前缀,但在后缀中。
这是真的? 谁能帮我解决这个问题? 示例代码将对您大有帮助!

trans by 2019-10-07T02:32:21Z

算法-如何以编程方式对图像进行卡通化?

我的应用程序可以处理人的照片和视频,我想对其进行卡通化处理。 因此,我需要一种算法来手动执行此操作(我们为产品使用c ++ / Qt,它具有图像处理类),或者可能需要一些CLI程序来为我执行该操作,我可以从自己的应用程序中调用和使用它。

trans by 2019-10-04T23:39:35Z

nlp-确定语句/文本的正面还是负面的算法

我需要一种算法来确定句子,段落或文章的语气是消极还是积极……或者更好的是消极还是积极。

例如:

杰森(Jason)是我见过的最糟糕的SO用户(-10)

Jason是SO用户(0)

Jason是我见过的最好的SO用户(+10)

杰森(Jason)最擅长吸吮SO(-10)

在SO方面,Jason做得不好时表现最差(+10)

不容易吧? :)

我不希望有人向我解释这种算法,但是我认为学术界某个地方已经有很多此类工作。 如果您能指出一些文章或研究,我会喜欢的。

谢谢。

trans by 2019-10-04T19:04:57Z

排序-插入排序与冒泡排序算法

我试图了解一些排序算法,但是我正努力查看气泡排序和插入排序算法的区别。

我知道两者都是O(n2),但是在我看来,冒泡排序只是将每次通过时数组的最大值冒泡到顶部,而插入排序只是将每次通过时将最小值沉到底部。 他们不是在做完全相同的事情,但方向不同吗?

对于插入排序,比较/潜在交换的次数从零开始,并且每次都增加(即0、1、2、3、4,...,n),但对于冒泡排序,则发生相同的行为,但是在结束时 排序(即n,n-1,n-2,... 0),因为气泡排序在排序时不再需要与最后一个元素进行比较。

尽管如此,似乎人们普遍认为插入排序通常更好。 谁能告诉我为什么?

编辑:我主要是对算法工作方式的差异感兴趣,而不是它们的效率或渐进复杂性。

trans by 2019-10-03T19:40:12Z

算法-在间隔列表中搜索间隔重叠?

说[a,b]表示从a到b的实线上的间隔,a <b,包括端点(即[a,b] =所有x的集合,使得a <= x <= b)。 同样,如果[a,b]和[c,d]共享任何x使得x在[a,b]和[c,d]两者中,则它们是“重叠的”。

给定间隔列表([x1,y1],[x2,y2],...),找到所有与[x,y]重叠的间隔的最有效方法是什么?

显然,我可以尝试每种方法并在O(n)中得到它。 但是我想知道是否可以以某种巧妙的方式对间隔列表进行排序,我可以通过二进制搜索在O(log N)中找到/ one /重叠项,然后从列表中的该位置“环顾四周”以查找 所有重叠的间隔。 但是,如何对间隔进行排序,以使这种策略可行?

请注意,列表项本身中的元素之间可能存在重叠,这使得这很难。

我已经尝试通过按其左端,右端,中间的时间间隔对间隔进行排序,但是似乎都没有导致详尽的搜索。

救命?

trans by 2019-10-02T12:12:36Z

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 下一页 共20页