javascript

java

python

c#

android

node.js

reactjs

c++

php

html

jquery

css

.net

ios

git

ruby-on-rails

sql

c

string

ruby

算法-为什么在链表中查找循环时将指针增加2,为什么不3,4,5?

我已经看过一个问题,该问题涉及在链表中查找循环的算法。 我已经读过弗洛伊德(Floyd)的循环查找算法解决方案,在很多地方都提到要使用两个指针。 一个指针(较慢/乌龟)增加一个,其他指针(较快/野兔)增加2。当它们相等时,我们发现循环,如果更快的指针到达null,则链表中没有循环。

现在我的问题是为什么我们将指针增加2。 增加2是必要的,或者我们可以将其增加X以获得结果。 如果将更快的指针增加2,是否有必要找到一个循环,或者是否存在需要将3或5或x增加的情况。

trans by 2020-01-19T22:39:09Z

财务-电子金融交易所最常使用的订单匹配算法是哪些?

电子金融交易所最常用的订单匹配算法是哪些?某处是否有订单匹配算法的列表?

trans by 2020-01-19T16:53:22Z

算法-合并排序链接列表

我最近重新整理了一些基本知识,发现合并对链表进行排序是一个非常好的挑战。 如果您有一个好的实现,那么请在此处展示它。

trans by 2020-01-19T15:25:59Z

算法-简单的Python挑战:对数据缓冲区的最快按位异或

挑战:

对两个相等大小的缓冲区执行按位XOR。 缓冲区必须是python str类型,因为传统上这是python中数据缓冲区的类型。 返回结果值str。请尽快执行此操作。

输入是两个1兆字节(2 ** 20字节)字符串。

挑战在于使用python或现有的第三方python模块(宽松的规则:或创建自己的模块)来击败我效率低下的算法。边际增加是无用的。

from os import urandom
from numpy import frombuffer,bitwise_xor,byte

def slow_xor(aa,bb):
    a=frombuffer(aa,dtype=byte)
    b=frombuffer(bb,dtype=byte)
    c=bitwise_xor(a,b)
    r=c.tostring()
    return r

aa=urandom(2**20)
bb=urandom(2**20)

def test_it():
    for x in xrange(1000):
        slow_xor(aa,bb)
trans by 2020-01-19T03:50:59Z

语言不可知论-比较两个字符串的相似程度有哪些算法?

我需要比较字符串,以确定它们是否代表同一件事。 这涉及人为输入的案例标题,缩写和其他小细节可能有所不同。 例如,考虑以下两个标题:

std::string first = "Henry C. Harper v. The Law Offices of Huey & Luey, LLP";

相对于:

std::string second = "Harper v. The Law Offices of Huey & Luey, LLP";

一个人可以迅速判断出它们很可能是相同的。 我目前采用的方法是通过小写所有字母并删除所有标点和空格来规范化字符串,从而得到:

std::string firstNormalized = "henrycharpervthelawofficesofhueylueyllp";

和:

std::string secondNormalized = "harpervthelawofficesofhueylueyllp";

在这种情况下进行比较,一个是另一个的子序列,但是您可以想象不一定要发生其他更复杂的变体,但它们有很多共同的子序列。 偶尔也可能会有人为输入错误,例如转置字母和拼写错误。

也许某种字符差异程序可能会有所帮助? 我见过很好的行差异程序,用于比较要检查的代码中的差异,是否存在基于字符的类似内容,也许是增强功能? 如果您可以计算出连续字符的数量,然后将未共享字符的比例与未共享字符的比率相乘,也许这是一个很好的启发式方法?

最后,我需要确定是否将它们视为相同的布尔值决定。 它不一定是完美的,但理想情况下应该很少出错。

我可以使用哪种算法来量化两个字符串彼此之间的相似度,然后通过某种启发式方法将其转换为是/否答案?

trans by 2020-01-19T03:03:18Z

算法-为什么合并排序最坏情况下运行时间O(n log n)?

有人可以用简单的英语或简单的方式向我解释吗?

trans by 2020-01-19T00:38:28Z

java-与find-min / find-max的堆栈比O(n)更有效?

我对创建类似于堆栈的Java数据结构感兴趣,该结构尽可能有效地支持以下操作:

  • 推送,它会在堆栈顶部添加一个新元素,
  • 弹出,删除堆栈的顶部元素,
  • Find-Max,它返回(但不会删除)堆栈中的最大元素,并且
  • Find-Min,它返回(但不删除)堆栈中的最小元素,并且

这个数据结构最快的实现是什么? 我应该如何用Java编写它?

trans by 2020-01-18T08:49:46Z

算法-两个矩形相交

我有两个分别具有4个值的矩形:

左侧位置X,顶部位置Y,宽度W和高度H

X1, Y1, H1, W1
X2, Y2, H2, W2

矩形不旋转,如下所示:

+--------------------> X axis
|
|    (X,Y)      (X+W, Y)
|    +--------------+
|    |              |
|    |              |
|    |              |
|    +--------------+
v    (X, Y+H)     (X+W,Y+H)

Y axis

确定两个矩形的交点是否为空的最佳解决方案是什么?

trans by 2020-01-17T00:21:05Z

算法-哈希表运行时复杂度(插入,搜索和删除)

为什么我在哈希表上仍然看到这些函数的不同运行时复杂性?

在Wiki上,搜索和删除均为O(n)(我认为哈希表的要点是具有恒定的查找,因此如果搜索为O(n)的意义是什么)。

在一段时间以前的一些课程笔记中,我看到了许多复杂的情况,具体取决于某些细节,包括一个包含所有O(1)的细节。 如果我可以全部获得O(1),为什么还要使用其他实现?

如果我以C ++或Java之类的语言使用标准哈希表,那么我期望的时间复杂度是多少?

trans by 2020-01-16T17:02:25Z

c ++-不相交的线段同时最小化累积长度

我想找到一种更好的算法来解决以下问题:

二维中有N个起点(紫色)和N个目标点(绿色)。 我想要一种算法,该算法通过线段(棕色)将起点连接到目标点,而这些线段中的任何一条都不相交(红色),同时使所有线段的累积长度最小。

我在C ++中的第一个工作是排列所有可能的状态,找到无交集的状态,以及其中那些具有最小总段长O(n!)的状态。 但是我认为必须有更好的方法。

enter image description here

任何想法? 还是搜索的好关键字?

trans by 2020-01-15T17:36:09Z

算法:如何使用RGB值从红色通过黄色渐变为绿色?

我想基于0到100的值显示颜色。一端(100)为纯红色,另一端(0)为纯绿色。 在中间(50),我希望它是黄色的。

我希望颜色逐渐从一种逐渐淡入另一种,以便在75时,颜色是一半红色和一半黄色,等等。

如何编程RGB值以反映这种褪色? 谢谢。

trans by 2020-01-15T00:37:54Z

c ++-获取(-1)^ n的正确方法是什么?

许多算法需要计算n%2?-1:1;(均为整数),通常将其作为序列中的一个因子。 也就是说,因数n为奇数2270750626366358529,因偶数n为1530。 在C ++环境中,经常会看到:

#include<iostream>
#include<cmath>
int main(){
   int n = 13;
   std::cout << std::pow(-1, n) << std::endl;
}

什么是更好的惯例? (或者是其他东西),

std::pow(-1, n)
std::pow(-1, n%2)
(n%2?-1:1)
(1-2*(n%2))  // (gives incorrect value for negative n)

编辑:

另外,用户@SeverinPappadeux提出了另一种基于(全局?)数组查找的替代方法。 我的版本是:

const int res[] {-1, 1, -1}; // three elements are needed for negative modulo results
const int* const m1pow = res + 1; 
...
m1pow[n%2]

这可能不会解决这个问题,但是通过使用发出的代码,我们可以放弃一些选项。

首先,没有优化,最终的竞争者是:

   1 - ((n & 1) << 1);

(7个操作,无内存访问)

  mov eax, DWORD PTR [rbp-20]
  add eax, eax
  and eax, 2
  mov edx, 1
  sub edx, eax
  mov eax, edx
  mov DWORD PTR [rbp-16], eax

   retvals[n&1];

(5次操作,内存-注册?-访问)

  mov eax, DWORD PTR [rbp-20]
  and eax, 1
  cdqe
  mov eax, DWORD PTR main::retvals[0+rax*4]
  mov DWORD PTR [rbp-8], eax

现在进行优化(-O3)

   1 - ((n & 1) << 1);

(4个操作,无内存访问)

  add edx, edx
  mov ebp, 1
  and edx, 2
  sub ebp, edx

  retvals[n&1];

(4个操作,内存-注册?-访问)

  mov eax, edx
  and eax, 1
  movsx rcx, eax
  mov r12d, DWORD PTR main::retvals[0+rcx*4]

   n%2?-1:1;

(4次操作,无内存访问)

  cmp eax, 1
  sbb ebx, ebx
  and ebx, 2
  sub ebx, 1

测试在这里。 我不得不进行一些杂技操作,以得到有意义的代码,而这些代码不会一起消除所有操作。

结论(目前)

因此,最终取决于级别的优化和表达能力:

  • n%2?-1:1;总是很好,但表达能力不是很好。
  • n%2?-1:1;为内存访问付出了代价。
  • n%2?-1:1;是富有表现力的,而且很好,但只有经过优化。
trans by 2020-01-14T20:38:04Z

java-如何处理数字猜谜游戏(带有扭曲)算法?

我正在学习编程(Python和算法),并试图从事一个我觉得很有趣的项目。 我已经创建了一些基本的Python脚本,但是不确定如何为我尝试构建的游戏找到解决方案。

游戏的运作方式如下:

将为用户提供带有值的项目。 例如,

Apple = 1
Pears = 2
Oranges  = 3

然后,他们将有机会选择自己喜欢的任何组合(即100个苹果,20个梨和一个橙子)。 计算机获得的唯一输出是总价值(在此示例中,当前价值为143美元)。 计算机将尝试猜测它们所拥有的。 显然,第一轮将无法正确获得。

         Value    quantity(day1)    value(day1)
Apple      1        100                100
Pears      2         20                 40
Orange     3          1                  3
Total               121                143

下一轮用户可以修改其号码,但不能超过总数的5%(或我们可以选择的其他百分比。例如,我将使用5%)。 水果的价格可以(随机)变化,因此总价值也可以基于此变化(为简单起见,在此示例中,我不更改水果的价格)。 使用上面的示例,在游戏的第2天,用户在第3天返回了$ 152和$ 164的值。这是一个示例:

Quantity (day2)   %change (day2)    Value (day2)   Quantity (day3)   %change (day3)   Value(day3)
 104                                 104            106                                106
  21                                  42             23                                 46
   2                                   6              4                                 12
 127               4.96%             152            133               4.72%            164

*(我希望表格能正确显示,我必须手动将它们隔开,所以希望它不仅可以在屏幕上显示,如果无法正常工作,请告诉我,我将尝试上传屏幕截图。)

我正在尝试查看是否可以确定一段时间后的数量(假设用户将有耐心继续输入数字)。 我现在知道,我唯一的限制是总值不能超过5%,所以现在我的精度不能超过5%,因此用户将永远输入该值。

到目前为止我做了什么

到目前为止,这是我的解决方案(不多)。 基本上,我采用所有值并找出它们的所有可能组合(本部分已完成)。 然后,我将所有可能的组合作为字典放入数据库(例如,对于$ 143,可能会有一个字典条目{apple:143,Pears:0,Oranges:0} ..一直到{apple :0,Pears:1,Oranges:47}。每当我得到一个新号码时,我都会这样做,因此我会列出所有可能性。

这是我被困的地方。 在使用上述规则时,如何找出最佳解决方案? 我认为我需要一个适应度函数,该函数可以自动比较两天的数据并删除与前几天的数据相差5%以上的所有可能性。

问题:

因此,我的问题是用户更改了总数,并获得了所有概率的列表,我该如何处理呢? 我需要学习什么? 是否有适用的算法或可以使用的理论? 或者,为了帮助我理解我的错误,您能否建议我可以添加哪些规则以使该目标变得可行(如果它不处于当前状态。我正在考虑添加更多水果并说他们必须选择至少3个,等等。)? 另外,我对遗传算法只有一个模糊的理解,但是我想如果可以使用的话我可以在这里使用它们?

我非常渴望学习,因此任何建议或技巧都将不胜感激(只是请不要告诉我这个游戏是不可能的)。

更新:获得很难解决的反馈。 因此,我想我会在游戏中添加另一个条件,即不会干扰玩家的行为(游戏对他们而言保持不变),但是每天水果的价值都会改变价格(随机)。 这样会更容易解决吗? 因为在5%的移动范围内,并且某些水果值发生了变化,所以随着时间的推移,只有少数几种组合是可能的。

第1天,一切皆有可能,并且达到足够近的范围几乎是不可能的,但是由于水果价格会发生变化,并且用户只能选择5%的变化,因此(随着时间的推移)不应将范围缩小。 在上面的示例中,如果价格波动足够大,我想我可以蛮力提出一个可以让我猜出一个范围的解决方案,但我试图找出是否有更优雅的解决方案或其他解决方案来将范围缩小 时间。

UPDATE2:在阅读并询问后,我相信这是一个隐含的马尔可夫/维特比问题,可以追踪水果价格以及总金额的变化(对最后一个数据点加权最重)。 我不确定如何应用这种关系。 我认为是这种情况,可能是错误的,但至少我开始怀疑这是某种类型的机器学习问题。

更新3:我创建了一个测试用例(具有较小的数字)和一个生成器,以帮助自动执行用户生成的数据,并且我试图从中创建图形以查看更可能的情况。

这是代码,以及总值和关于用户实际收获数量的注释。

#!/usr/bin/env python
import itertools

# Fruit price data
fruitPriceDay1 = {'Apple':1, 'Pears':2, 'Oranges':3}
fruitPriceDay2 = {'Apple':2, 'Pears':3, 'Oranges':4}
fruitPriceDay3 = {'Apple':2, 'Pears':4, 'Oranges':5}

# Generate possibilities for testing (warning...will not scale with large numbers)
def possibilityGenerator(target_sum, apple, pears, oranges):
    allDayPossible = {}
    counter = 1
    apple_range = range(0, target_sum + 1, apple)
    pears_range = range(0, target_sum + 1, pears)
    oranges_range = range(0, target_sum + 1, oranges)
    for i, j, k in itertools.product(apple_range, pears_range, oranges_range):
        if i + j + k == target_sum:
            currentPossible = {}

            #print counter
            #print 'Apple', ':', i/apple, ',', 'Pears', ':', j/pears, ',', 'Oranges', ':', k/oranges
            currentPossible['apple'] = i/apple
            currentPossible['pears'] = j/pears
            currentPossible['oranges'] = k/oranges

            #print currentPossible
            allDayPossible[counter] = currentPossible
            counter = counter +1
    return allDayPossible

# Total sum being returned by user for value of fruits
totalSumDay1=26 # Computer does not know this but users quantities are apple: 20, pears 3, oranges 0 at the current prices of the day
totalSumDay2=51 # Computer does not know this but users quantities are apple: 21, pears 3, oranges 0 at the current prices of the day
totalSumDay3=61 # Computer does not know this but users quantities are apple: 20, pears 4, oranges 1 at the current prices of the day
graph = {}
graph['day1'] = possibilityGenerator(totalSumDay1, fruitPriceDay1['Apple'], fruitPriceDay1['Pears'], fruitPriceDay1['Oranges'] )
graph['day2'] = possibilityGenerator(totalSumDay2, fruitPriceDay2['Apple'], fruitPriceDay2['Pears'], fruitPriceDay2['Oranges'] )
graph['day3'] = possibilityGenerator(totalSumDay3, fruitPriceDay3['Apple'], fruitPriceDay3['Pears'], fruitPriceDay3['Oranges'] )

# Sample of dict = 1 : {'oranges': 0, 'apple': 0, 'pears': 0}..70 : {'oranges': 8, 'apple': 26, 'pears': 13}
print graph
trans by 2020-01-14T15:04:05Z

确定音频采样键的算法

我对确定音频样本的音乐键很感兴趣。 算法将如何(或可能)尝试近似音乐音频样本的键?

Antares Autotune和Melodyne是完成此类任务的两个软件。

谁能给外行人一些解释,说明这将如何工作? 通过分析和弦进行等的频谱来数学推断歌曲的键。

这个话题使我非常感兴趣!

编辑-从每个对此问题做出贡献的人中都能找到精采的资源和大量信息。

特别是来自:the_mandrill和DanielBrückner。

trans by 2020-01-12T12:06:40Z

如何在不使用++或+或其他算术运算的情况下将两个数字相加

如何在不使用++或+或任何其他算术运算符的情况下将两个数字相加?

这是很久以前在一些校园采访中问的一个问题。 无论如何,今天有人问了一些关于位操作的问题,在回答中提到了一个美丽的斯坦福钻头。 我花了一些时间研究它,并认为实际上可能是该问题的答案。 我不知道,我找不到。 是否存在答案?

trans by 2020-01-12T10:12:36Z

c ++-在点周围拟合矩形

我试图在一组8个2D点周围安装一个矩形,同时尝试最小化覆盖区域。

例:

enter image description here

矩形可以缩放和旋转。 但是,它需要保留一个矩形。

我的第一种方法是用力蛮力旋转每一个可能的位置,使矩形尽可能靠近,然后计算覆盖面积。 然后,最佳拟合将是最小面积的旋转。

但是,这听起来并不是最好的解决方案。

有什么更好的方法吗?

trans by 2020-01-12T06:04:45Z

算法挑战:从图像生成配色方案

背景

因此,我正在研究Web应用程序的新版本。 而且,我们发现我们的用户痴迷于懒惰。 真的很懒。 实际上,我们为他们做的工作越多,他们对服务的热爱就越多。 现有应用程序的一部分要求用户选择要使用的配色方案。 但是,我们有一张图片(用户网站的屏幕截图),那么为什么我们不能仅仅满足他们的懒惰并为他们做呢? 答:我们可以,这将是一个有趣的编程练习! :)

挑战

给定图像,如何创建相应的配色方案? 换句话说,如何选择图像中的主要X色(其中X由网络应用定义)。 我们在特定情况下使用的图片是用户网站的屏幕截图,以全分辨率(例如1280x1024)拍摄。 (注意:请简单描述您的算法-无需发布实际的伪代码。)

奖励积分(街道信誉积分,不是实际的SO积分):

  • 描述一种简单但有效的算法。 代码是我们创建代码的方式-使其保持简单美观。
  • 允许用户根据各种“心情”(例如“色彩鲜艳”,“明亮”,“静音”,“深色”等)调整配色方案(la Kuler)
  • 描述一种可靠地确定网站屏幕截图中使用的主要文本颜色的方法(可能需要使用自己的单独算法)。

灵感

现有几个执行类似功能的站点。 随时检查一下并问自己:“我将如何重复此操作?我该如何改进它?”

  • [http://www.pictaculous.com/]
  • [http://www.cssdrive.com/imagepalette/index.php]
  • [http://kuler.adobe.com/#create/fromanimage]
trans by 2020-01-10T23:10:59Z

算法-为什么迭代k路合并O(nk ^ 2)?

k路合并是将k个大小为n的排序数组作为输入的算法。 它输出所有元素的单个排序数组。

通过使用合并排序算法中心的“合并”例程,将数组1合并到数组2,然后将数组3合并到此合并的数组,依此类推,直到所有k个数组都合并为止。

我以为该算法为O(kn),因为该算法遍历k个数组(每个数组的长度为n)一次。 为什么是O(nk ^ 2)?

trans by 2020-01-10T21:54:48Z

算法-计算旋转矩形中的最大矩形

我试图找到一种最佳方法来计算最大的(面积内)矩形,该矩形可以包含在旋转的矩形内。

一些图片应该(希望)有助于形象化我的意思:

input rectangle with given width and height rotate erctangle by alpha degrees output inner rectangle

给出了输入矩形的宽度和高度,以及旋转它的角度。 输出矩形没有旋转或倾斜。

我走的是漫长的路线,我甚至不确定它是否可以处理极端情况(无双关语)。 我敢肯定有一个优雅的解决方案。 有小费吗?

编辑:输出矩形点不必一定要触摸输入矩形的边缘。 (感谢E先生)

trans by 2020-01-09T23:45:31Z

mysql-如何检查字符串看起来是随机的还是人为产生的和可发音的?

为了识别[可能]机器人生成的用户名。

假设您有一个用户名,例如“ bilbomoothof” ..可能是胡说八道,但它仍然包含发音,因此看起来是人为产生的。

我接受它可能是从音节字典或单词部分中随机生成的,但让我们假设一下,该机器人有点儿垃圾。

  1. 假设您有一个用户名,例如“ sdfgbhm342r3f”,对人类来说是显然是一个随机字符串。 但是可以是否可以通过编程方式识别?
  2. 是否有可用的算法(类似于Soundex等。)可以识别其中的明显声音这样的字符串?

非常适合在PHP / MySQL中使用的解决方案。

trans by 2020-01-09T19:14:38Z

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