精华内容
下载资源
问答
  • 2006-12-27 21:51:00


    物欲横流的世界,金钱总是会让人眼冒绿光,以金钱为标题难免有哗众取宠之嫌,身在金融场,天天与铜臭味相伴,谈金钱反而比谈情说爱更让自己舒服,所以文章满是铜臭味,实在羞于登大雅之堂。

    <script type="text/javascript"> google_ad_client = "pub-6924533005275861"; google_ad_slot = "0030867594"; google_ad_width = 300; google_ad_height = 250; </script><script type="text/javascript" src="http://pagead2.googlesyndication.com/pagead/show_ads.js"> </script>

    http://ike.126.com

    在现实中,我发现越简单的事实,越没有人提,从而使得我不停地绕弯路,而这些事实都可以用最简单的数学来表达,今天也不例外。

     

      利润率 期限  100倍
      100%  6.65   100.43 (=power(1+100%,6.65))
      90%  7.18   100.33
      80%  7.84   100.31
      70%  8.68   100.07
      60%  9.80   100.09
      50%  11.36   100.09
      40%  13.69   100.11
      30%  17.56   100.19
      20%  25.26   100.03
      10%  48.32   100.02
      5%   94.39   100.01
      2%   232.56  100.01

     

      以上就是最神奇的复利效应,为方便大家验证,我给出了用Excel软件计算的公式,这些数据相信大家一看就懂。结论就是:1万,你只要每“年”(这个期限随你定)赚100%,6.65年后你就是百万富翁,以此类推。

     

        对农民或穷人说100万是“1后面加6个0”,他们会说那是天文数字,这一生都不敢去想。为什么不敢去想?因为穷人早已被富人们洗了脑,而且是自愿被洗脑的,因为人越穷,就越是嫌贫爱富,中国自大清帝国衰落时起,便一直崇洋媚外至今,为什么?因为咱穷,所以忘了大清之前的朝代,全世界都在“崇东媚中”。说来说去,又是离不开人性二字。

     

       穷人们要致富,首先要富脑,怎么富脑?一条路:学习。怎么学?除了上学读书学习前人的死东西外,更要向社会学、向自然学、向人性学、向天地万物的根源学,学习只有返璞归真,才能明白大道至简至易,而不是至繁至难。据说毛泽东的很多伟大思想是在蹲茅房时想出来的,我信,我佩服他老人家,因为我们有许多的共同点(太高攀了),只是他爱江山,我爱金钱,殊途同归。

     

      金融市场每天几万亿资金在流动。 穷,正是我们的优势所在,既然已经是一穷二白,还有什么可恐惧的?就算你穷人害怕金融,可金融却时时刻刻在影响你的一切,房价、利率、职业、企业盛衰,哪一样能逃得了金融的影响?金融的根源正是利用了穷人的愚昧而存在着的,你不管它,可它管着你的生死。与其逃避,不如直接面对现实。

     

        但如果你在意了,我希望你静下心来,认真地、刻苦地思考一番,1万到100万究竟有多难?金融市场永恒的是波动,你是觉得1年50%可能性大,还是1月10%可能性大?你是觉得对10次的可能性大,还是对232次的可能性大?   无论你投资多少资金,你在《投资的真相》面前,结果都是完全一样,人性真的很奇怪,就是喜欢看绝对数,讨厌百分数。一听说某某又赚了5万块,就羡慕得不得了,一年5万,1个月不就相当于4000多块工资吗?那算得上是白领阶层啦,看来炒股真的很赚钱!你有没有问人家一句,你是用多少钱赚的?人家一定不好意思说,因为他(她)可能动用了100万,而他(她)一年的手续费说不定都超过5万,5%的利润有啥好羡慕的?

     

      百分数才是最实在的东西,如果你能深刻地理解“%”,你会从中学到很多人间真理,就像《投资的真相》中所说的“|-n%|≠n%”一样,一笔之差想隔万里啊。由此可见,数学看似精确恰恰最迷惑人,其实今天的学者们大多已忘记,数学也是来源于自然哲学,就连1+1=2都有它的哲学涵义,说不定它的原始涵义还是错误或片面的呢。既然一切学科都来源于自然、宇宙,凭什么就认为数学一定是宇宙真理?你看看你自己的身体,哪来的精确三角形、圆形、直线?拿显微镜看看,到处都是不规则图形,你永远也不可能找到精确的三角形。我们根据精确数学造出来的一切工具,哪一个能与大自然创造的物质相比?充其量不过是一堆死工具而已。

     

      怎么实现1万到100万?我无法提供任何完美的公式,我只能建议你慎重地做好每一个重大决策。金融市场永恒的是波动,记住这个事实,然后就去寻找那些如同绿灯般的波动,抓住它们,用时间和耐心守候着它们,一年复一年,也许不用10年,你便轻而易举地成为百万富翁。从上面的数据你可以看出,在60%到100%之间,你的决策次数起伏很小,只是7到10次而已,这意味着,你不一定非要追求年年100%,60%也可以啊,决策次数差不多,降低个10%的预期,也许你的胜算会更大一些。

     

      如今的上班族们,也不管未来有没有风险,都敢贷款按揭买个几十万甚至百万的房子,他们的按揭有的甚至达到30年,你想他们这30年都得耐心地拼命熬到头,你就10年也等不急啦?如果你愿意和他们一样,你可以用18年的时间来投资,每年将盈利预期降到30%,你的决策仍不过是1年1次,18年也不过是18次,你的胜算是不是更大一些?如果你真的每年只选择那些绿灯机会,18年后,你手中就是100万现金,而那些上班族们18年后换来的房子早已破旧不堪,你看看88年的房子现在是啥样,你就明白了,他们熬到房贷还清,人也老了,这一生也完了,而你却手握100万现金,你拿去买个债券什么的,每年收个5%的利息,也比上班强啊。

     

      如果你真有如此的耐心,30%你根本不必去找股票,直接做外汇就行了,一年玩它几回,就能搞定,你永远也不用担心外汇会破产或业绩作假。你所有的风险,也不过是1万而已,你就是捡破烂也能捡到啊。1万,工薪阶层也只须每月积累800多元就可以了。如果你的起始资金不至1万,而是2万、3万,你可能不需要等待太长时间便能赚到100万。

     

      1万到100万,比100万到1000万要容易得多,这又是金融界忽视的真理,穷人想发财,不啃富人身上的肉,难道啃泥巴啊?这世界有点头脑的都在围着富人转,可永远是富人少,穷人多,我爱人多的地方,就像我爱钱多的金融市场一样。

     

      未来的方向我已经给你指明了,但这远远不够,因为富人都是精明人,不是每个富人都像中航油那样好骗,今生你也不能指望巴菲特破产(不过你的孙子可以等他的孙子破产)。在金融市场中,众生平等,不存在谁欺负谁,真要说有欺负,也是穷人欺富人,因为富人这也怕那也怕,输了一次可能一生就没了(如果钱是借来的,可能还得坐牢房),而穷人天不怕地不怕,输了可以再来。金融归根结底就是一个零和游戏,有人赚就一定有人赔,就算今天的人不赔,也会有后来的人赔。富人想吃穷人,穷人更想吃富人,怎么较量?用你的脑袋!

     

      思想不是一日练成的,书山无路勤为径,学海无涯苦作舟。就算你真的能挣到100万,也别得意。因为,贫与富的根源是你自己,虽说贫吃富,富吃贫,但这不是根源,只是表象,根源是人性,而人性又是遵循自然的法则,所以绕来绕去,你也可以说是天注定,只是你可以试着跳出人性的束缚,部分实现“无为而无不为”,在有生之年不愁吃穿,这也是我们人类共同的梦想,但却永远不可能真正实现。虽然我不喜欢谈论宗教,但宗教经典大家还是应该翻翻。跳出人性的束缚,一个字是“难”,两个字是“太难”,绝大多数人最后都成了宗教信徒,而不是贪财小人,这就违背来金融市场的根本目的了。来这儿,你得把钱看得如同生命,而不是以贪财为可耻,但我相信,大俗近雅,以爱财之心爱生命,金融市场又何尝不是人间乐土呢?!
    http://ike.126.com


        最后,友情忠告:市场有风险,投资须谨慎,想发财就要敢冒险,怕风险就存银行,金融如太极,不要认得真,左右能逢源,快乐似神仙!

    更多相关内容
  • 如何在1亿个中找出最大的100(top K问题) ​ 最容易想到的方法是将数据全部排序,然后在排序后的集合中进行查找,最快的排序算法的时间复杂度一般为O(nlogn),如快速排序。但是在32位的机器上,每个float...

    如何在1亿个数中找出最大的100个数(top K问题)

    ​ 最容易想到的方法是将数据全部排序,然后在排序后的集合中进行查找,最快的排序算法的时间复杂度一般为O(nlogn),如快速排序。但是在32位的机器上,每个float类型占4个字节,1亿个浮点数就要占用400MB的存储空间,对于一些可用内存小于400M的计算机而言,很显然是不能一次将全部数据读入内存进行排序的。其实即使内存能够满足要求(我机器内存都是8GB),该方法也并不高效,因为题目的目的是寻找出最大的10000个数即可,而排序却是将所有的元素都排序了,做了很多的无用功。

    ​ 第二种方法为局部淘汰法,该方法与排序方法类似,用一个容器保存前10000个数,然后将剩余的所有数字——与容器内的最小数字相比,如果所有后续的元素都比容器内的10000个数还小,那么容器内这个10000个数就是最大10000个数。如果某一后续元素比容器内最小数字大,则删掉容器内最小元素,并将该元素插入容器,最后遍历完这1亿个数,得到的结果容器中保存的数即为最终结果了。此时的时间复杂度为O(n+m^2),其中m为容器的大小,即10000。

    ​ 第三种方法是分治法,将1亿个数据分成100份,每份100万个数据,找到每份数据中最大的10000个,最后在剩下的10010000个数据里面找出最大的10000个。如果100万数据选择足够理想,那么可以过滤掉1亿数据里面99%的数据。100万个数据里面查找最大的10000个数据的方法如下:用快速排序的方法,将数据分为2堆,如果大的那堆个数N大于10000个,继续对大堆快速排序一次分成2堆,如果大的那堆个数N大于10000个,继续对大堆快速排序一次分成2堆,如果大堆个数N小于10000个,就在小的那堆里面快速排序一次,找第10000-n大的数字;递归以上过程,就可以找到第1w大的数。参考上面的找出第1w大数字,就可以类似的方法找到前10000大数字了。此种方法需要每次的内存空间为10^64=4MB,一共需要101次这样的比较。*

    ​ 第四种方法是Hash法。如果这1亿个书里面有很多重复的数,先通过Hash法,把这1亿个数字去重复,这样如果重复率很高的话,会减少很大的内存用量,从而缩小运算空间,然后通过分治法或最小堆法查找最大的10000个数。

    ​ 第五种方法采用最小堆。首先读入前10000个数来创建大小为10000的最小堆,建堆的时间复杂度为O(mlogm)(m为数组的大小即为10000),然后遍历后续的数字,并于堆顶(最小)数字进行比较。如果比最小的数小,则继续读取后续数字;如果比堆顶数字大,则替换堆顶元素并重新调整堆为最小堆。整个过程直至1亿个数全部遍历完为止。然后按照中序遍历的方式输出当前堆中的所有10000个数字。该算法的时间复杂度为O(nmlogm),空间复杂度是10000(常数)。

    实际运行:

    ​ 实际上,最优的解决方案应该是最符合实际设计需求的方案,在时间应用中,可能有足够大的内存,那么直接将数据扔到内存中一次性处理即可,也可能机器有多个核,这样可以采用多线程处理整个数据集。

    ​ 下面针对不容的应用场景,分析了适合相应应用场景的解决方案。

    (1)单机+单核+足够大内存
    ​ 如果需要查找10亿个查询次(每个占8B)中出现频率最高的10个,考虑到每个查询词占8B,则10亿个查询次所需的内存大约是10^9 * 8B=8GB内存。如果有这么大内存,直接在内存中对查询次进行排序,顺序遍历找出10个出现频率最大的即可。这种方法简单快速,使用。然后,也可以先用HashMap求出每个词出现的频率,然后求出频率最大的10个词。

    (2)单机+多核+足够大内存
    ​ 这时可以直接在内存总使用Hash方法将数据划分成n个partition,每个partition交给一个线程处理,线程的处理逻辑同(1)类似,最后一个线程将结果归并。

    ​ 该方法存在一个瓶颈会明显影响效率,即数据倾斜。每个线程的处理速度可能不同,快的线程需要等待慢的线程,最终的处理速度取决于慢的线程。而针对此问题,解决的方法是,将数据划分成c×n个partition(c>1),每个线程处理完当前partition后主动取下一个partition继续处理,知道所有数据处理完毕,最后由一个线程进行归并。

    (3)单机+单核+受限内存
    ​ 这种情况下,需要将原数据文件切割成一个一个小文件,如次啊用hash(x)%M,将原文件中的数据切割成M小文件,如果小文件仍大于内存大小,继续采用Hash的方法对数据文件进行分割,知道每个小文件小于内存大小,这样每个文件可放到内存中处理。采用(1)的方法依次处理每个小文件。

    (4)多机+受限内存
    ​ 这种情况,为了合理利用多台机器的资源,可将数据分发到多台机器上,每台机器采用(3)中的策略解决本地的数据。可采用hash+socket方法进行数据分发。

    ​ 从实际应用的角度考虑,(1)(2)(3)(4)方案并不可行,因为在大规模数据处理环境下,作业效率并不是首要考虑的问题,算法的扩展性和容错性才是首要考虑的。算法应该具有良好的扩展性,以便数据量进一步加大(随着业务的发展,数据量加大是必然的)时,在不修改算法框架的前提下,可达到近似的线性比;算法应该具有容错性,即当前某个文件处理失败后,能自动将其交给另外一个线程继续处理,而不是从头开始处理。

    ​ top K问题很适合采用MapReduce框架解决,用户只需编写一个Map函数和两个Reduce 函数,然后提交到Hadoop(采用Mapchain和Reducechain)上即可解决该问题。具体而言,就是首先根据数据值或者把数据hash(MD5)后的值按照范围划分到不同的机器上,最好可以让数据划分后一次读入内存,这样不同的机器负责处理不同的数值范围,实际上就是Map。得到结果后,各个机器只需拿出各自出现次数最多的前N个数据,然后汇总,选出所有的数据中出现次数最多的前N个数据,这实际上就是Reduce过程。对于Map函数,采用Hash算法,将Hash值相同的数据交给同一个Reduce task;对于第一个Reduce函数,采用HashMap统计出每个词出现的频率,对于第二个Reduce 函数,统计所有Reduce task,输出数据中的top K即可。

    ​ 直接将数据均分到不同的机器上进行处理是无法得到正确的结果的。因为一个数据可能被均分到不同的机器上,而另一个则可能完全聚集到一个机器上,同时还可能存在具有相同数目的数据。

    以下是一些经常被提及的该类问题。

    (1)有10000000个记录,这些查询串的重复度比较高,如果除去重复后,不超过3000000个。一个查询串的重复度越高,说明查询它的用户越多,也就是越热门。请统计最热门的10个查询串,要求使用的内存不能超过1GB。

    (2)有10个文件,每个文件1GB,每个文件的每一行存放的都是用户的query,每个文件的query都可能重复。按照query的频度排序。

    (3)有一个1GB大小的文件,里面的每一行是一个词,词的大小不超过16个字节,内存限制大小是1MB。返回频数最高的100个词。

    (4)提取某日访问网站次数最多的那个IP。

    (5)10亿个整数找出重复次数最多的100个整数。

    (6)搜索的输入信息是一个字符串,统计300万条输入信息中最热门的前10条,每次输入的一个字符串为不超过255B,内存使用只有1GB。

    (7)有1000万个身份证号以及他们对应的数据,身份证号可能重复,找出出现次数最多的身份证号。

    重复问题
    ​ 在海量数据中查找出重复出现的元素或者去除重复出现的元素也是常考的问题。针对此类问题,一般可以通过位图法实现。例如,已知某个文件内包含一些电话号码,每个号码为8位数字,统计不同号码的个数。

    ​ 本题最好的解决方法是通过使用位图法来实现。8位整数可以表示的最大十进制数值为99999999。如果每个数字对应于位图中一个bit位,那么存储8位整数大约需要99MB。因为1B=8bit,所以99Mbit折合成内存为99/8=12.375MB的内存,即可以只用12.375MB的内存表示所有的8位数电话号码的内容。

    算法一:冒泡排序法

    千里之行,始于足下。我们先不说最好,甚至不说好。我们只问,如何“从10000个整数中找出最大的10个”?我最先想到的是用冒泡排序的办法:我们从头到尾走10趟,自然会把最大的10个数找到。方法简单,就不再这里写代码了。这个算法的复杂度是10N(N=10000)。

    算法二:

    有没有更好一点的算法呢?当然。维持一个长度为10的降序数组,每一个从数组拿到的数字都与这个降序数组的最小值比较。如果小于最小值,就舍弃;如果大于最小值,就把它插入到降序数组中的合适位置,舍弃原来的最小值。这样,遍历一遍就可以找到最大的10个数。因为需要在降序数组中插入一个数,对于遍历的每个数可能都需要这样,所以其复杂为5N。

    伪代码如下:

      A[N],a[m](分别为原始数组和降序数组,其中N=10000,m=10)
    
      a = A[0 ... 9](将数组A的前10个数赋给数组a)
    
      sort a(将组数a降序排序)
    
      for i in A[ 10 ... N](从10到N遍历数组A)
    
        if A[i] > a[9] then (如果当前值比降序数组中的最小值大)
    
          删除a[9]
    
          将A[i]插入a的合适位置,使a保持降序
    
        end if
    
      end for
    
      输出数组a
    
    

    其实算法二还有一个优点,就是当数组很大时,可以将数据分段读入内存处理,而这样做并不影响结果。

    1、首先一点,对于海量数据处理,思路基本上是确定的,必须分块处理,然后再合并起来。

    2、对于每一块必须找出10个最大的数,因为第一块中10个最大数中的最小的,可能比第二块中10最大数中的最大的还要大。

    3、分块处理,再合并。也就是Google MapReduce 的基本思想。Google有很多的服务器,每个服务器又有很多的CPU,因此,100亿个数分成100块,每个服务器处理一块,1亿个数分成100块,每个CPU处理一块。然后再从下往上合并。注意:分块的时候,要保证块与块之间独立,没有依赖关系,否则不能完全并行处理,线程之间要互斥。另外一点,分块处理过程中,不要有副作用,也就是不要修改原数据,否则下次计算结果就不一样了。

    4、上面讲了,对于海量数据,使用多个服务器,多个CPU可以并行,显著提高效率。对于单个服务器,单个CPU有没有意义呢?

    也有很大的意义。如果不分块,相当于对100亿个数字遍历,作比较。这中间存在大量的没有必要的比较。可以举个例子说明,全校高一有100个班,我想找出全校前10名的同学,很傻的办法就是,把高一100个班的同学成绩都取出来,作比较,这个比较数据量太大了。应该很容易想到,班里的第11名,不可能是全校的前10名。也就是说,不是班里的前10名,就不可能是全校的前10名。因此,只需要把每个班里的前10取出来,作比较就行了,这样比较的数据量就大大地减少了。

    之前看到一个面试题,1000个乱序正整数中找出10个最小值,要求高效快速,不能使用API。

    ​ 这学期学了些排序的方法,什么快速排序啊,冒泡啊,归并排序啊之类的。看到这个题的时候,第一反应是快速排序,因为它的名字叫快速嘛,应该够快吧。然后又想到这个题目不是要你完整的排序,只需要求出最小的10个就够了,那么冒泡法呢?冒泡法只冒前面10个数?

    ​ 发现这样子还是要遍历比较1000*10次。

    ​ 然后,利用类似于数据结构里的栈的特性?把这1000个数的前10个放到一个数组中,排好序,然后,剩下的990个数字,每个都与这10个数的最大数比较,大于则不考虑,小于就把最大值拿出来,把这个数放进去,这样的话,冒泡排序的比较次数就变成了990次,好像高效很多哦?

    展开全文
  • 看到这个题目的第一反应是:循环随机产生1-100的随机数,判断数组中是否已经有该,若已存在,则重新生成随机数;若不存在,则放入数组中。 实现代码如下所示: public void setData(int[] array){ Random rd = ...

    思路一:

    看到这个题目的第一反应是:循环随机产生1-100的随机数,判断数组中是否已经有该数,若已存在,则重新生成随机数;若不存在,则放入数组中。

    实现代码如下所示:

    public void setData(int[] array){
    		Random rd = new Random();
    		boolean isExit;
    		int len = array.length;
    		for(int i = 0; i < array.length; i++){
    			isExit = false;
    			//生成一个1-100之间的随机数
    			int num = rd.nextInt(len)+1;
    			//检验数组中是否已有该数
    			for(int j = 0; j < i; j++){
    				if(array[j] == num){
    					isExit = true;
    					i--;
    					break;
    				}
    			}
    			if(!isExit){
    				array[i] = num;
    			}
    		}
    	}

    运行查看结果,发现该方法可行,但是,当我们要随机产生的数变大时,这种方法所体现出的效率就会变得非常低。

    我们可以利用System.currentTimeMillis()方法来计算该算法所用的时间。

    测试:将产生的随机数改成1-10000,运行该程序:

    结果如下图所示(结果的一部分):


    我们可以看到,用这种算法效率很差,所以我们要想办法改进这个算法。我们先来想想这个算法的运行时间主要消耗在哪里?这应该是显而易见的,每生成一个随机数,程序就需要遍历整个数组来判断其中是否存在该数,这是很耗时的。能不能想办法不用每次都去遍历查找呢?有什么办法可以保证每次生成的数不会重复呢?

    思路二:

    我们不妨来逆向思考,事先将1-100这间的数顺序存入数组sorce中,随机产生一个位置,然后将该索引对应的数组元素依次放入数组array中,每次放入一个数后,都要将该数从source数组中删除,而下一次产生的随机数的范围也将所缩小。由于已生成的数已经被删除,所以每次产生的数就不会再重复。

    实现代码如下所示:


    	public void setNum(int[] source,int[] array){
    		Random rd = new Random();
    		int range = array.length;
    		int index = 0;
    		for(int i = 0; i <array.length; i++){
    			//随机产生一个位置
    			int pos = rd.nextInt(range);
    			//获取该位置的值
    			array[i] = source[pos];
    			//删除该索引在数组中的位置
    			for(int j = pos; j < array.length-1; j++){
    				source[j] = source[j+1];
    			}
    			//缩小随机数产生的范围
    			range--;
    		}
    	}

    在运行之前我们也将范围改成10000,来看看它的运行效率如何,运行结果如下图所示:



    由上图可以看出,由于省去了生成无效随机数的时间,效率提高了100多倍!


    思路三:

    不过这个算法也不是效率最高的方法,该算法还是存在弊端的,因为在生成了随机数之后,对整个数组进行了删除操作,其实也就是进行了一系列数据的交换,这也是比较耗时的,所以我们可以考虑的是:在保证不进行删除操作,但也能将产生的数从数组中剔除的方法。

    第一反应想到的应该会给这个数覆盖上其他的值,那应该赋什么值呢?0?如果赋0的话,那接下来生成随机数的范围就无法再是递减1的缩小了,那么有没有其他的方法呢?可不可以给它赋一个数组中还需要存在的数呢?我们不妨将数组中最后一个数赋给它,那么下次随机数的产生也还能采用思路二中的方法,主要思路如下所示:

    假设数组中的数为:1,2,3,4,5,6

    第一次随机产生的索引为3,即对应的是4,将4写入array数组中后,将6赋到array[3]中,则数组更新为:1,2,3,6,5,6(有效的数其实只有1,2,3,6,5)

    第二次随机产生的索引为4,即对应的是6,将6写入array数组中后,将5赋给array[4]中,则数组更新为:1,2,3,5,5,6(有效的数其实只有1,2,3,5)

    第三次随机产生的索引为1,即对应的是2,将2写入array数组中后,将5赋给array[1]中,则数组更新为:1,5,3,5,5,6(有效的数其实只有1,5,3)

    以此类推......

    采用这个方法,就不需要再对source数组中数进行删除(多次数据交换),而每一次产生随机数后,只需要执行一次数据交换即可,又在一定程度上提高了程序运行的效率。

    实现代码如下所示:

    public void setNum(int[] source,int[] array){
    		Random rd = new Random();
    		int range = array.length;
    		int index = 0;
    		for(int i = 0; i <array.length; i++){
    			//随机产生一个位置
    			int pos = rd.nextInt(range);
    			//获取该位置的值
    			array[i] = source[pos];
    			//改良:将最后一个数赋给被删除的索引所对应的值
    			source[pos] = source[range-1];
    			缩小随机数产生的范围
    			range--;
    		}
    	}
    最后,来看一下这个算法执行1-10000时的运行耗时:



    可见,该算法的耗时又比思路二的提高了近100倍!而比思路一快了1000多倍!

    所以,我们可以发现算法对一个程序的执行效率有着关键性的作用,我们在解决问题的时候应该逐步思考,在运行正确的情况下也应该多考虑程序的性能问题,找到程序中比较耗时的部分,然后再去思考是否有方法对其进行优化。

    展开全文
  • 破解你的密码需要多长时间

    千次阅读 2014-01-18 14:59:23
    这让弱口令使用者(纯字母和数字)和懒惰用户意识非字母数字字符的重要性。 坚信密码中某些特定数量字符就能保证安全是毫无意义的。字符的数量和字符类型有着很大的差别。 有大区别?添加一个字符(通常是不...



    分析:密码的强弱并没有严格的界限。

    一系列的安全事件敲响了我们麻木的头脑,如LinkedIneHarmony.com的事件。这让弱口令使用者(纯字母和数字)和懒惰用户意识到非字母数字字符的重要性。

    坚信密码中某些特定数量字符就能保证安全是毫无意义的。字符的数量和字符类型有着很大的差别。

    有多大区别?添加一个字符(通常是不常用的),使它不再是单词,可以直接避免字典攻击。

    以下是具体的测试数据:

    6个字符:22.5亿个组合(无特殊字符)

    1.由每秒攻击站点10000次的Web程序:需要3.7周
    2.脱机使用高功率的服务器或者台式机(1000亿/秒):0.0224秒
    3.使用大规模的并行处理器集群(100兆亿/秒):0.0000224秒

    10个字符:3.76(Quadrillion)个组合(无特殊字符)

    1.由每秒攻击站点10000次的Web程序:1194个世纪
    2.脱机使用高功率的服务器或者台式机(1000亿/秒):10.45小时
    3.使用大规模的并行处理器集群(100兆亿/秒):37.61秒。

    6个字符:7.6(trillion)个组合(有特殊字符)

    1.由每秒攻击站点10000次的Web程序:需要2.4个世纪
    2.脱机使用高功率的服务器或者台式机(1000亿/秒):1.26分钟
    3.使用大规模的并行处理器集群(100兆亿/秒):0.0756秒

    10个字符:171.3 Xextillion (171,269,557,687,901,638,419; 1.71 x 10^20)个组合(有特殊字符)

    1.由每秒攻击站点10000次的Web程序:5446万个世纪
    2.脱机使用高功率的服务器或者台式机(1000亿/秒):54.46年
    3.使用大规模的并行处理器集群(100兆亿/秒):2.83个星期




    源链接:http://www.freebuf.com/articles/3788.html

    展开全文
  •  并发是指在同一个时间点,同时请求服务的客户数量。  比如大家常说的:『 我的网站可以承受一万并发。 』在通常情况下指的是:如果同时有一万名用户访问网站,所有人都可以正常获得服务。而不会有超时或连接...
  • 大致涉及的知识点有: 基础语法 变量类型 运算符 条件判断 循环 字符串 列表 元组 字典 函数 异常 内置函数 面向对象 正则表达式 异常处理 … OK,我们开始今天的正题吧 第1题 问题:编写一个程序,找到2000年...
  • 从1到n整数中1出现的次数:O(logn)算法

    万次阅读 多人点赞 2016-07-26 13:13:54
    1. 题目描述输入一个整数n,求从1到n这n个整数的十进制表示中1出现的次数。例如输入12,从1到12这些整数中包含1的数字有1,10,11和12,1一共出现了5次。2. 题目来源第一次看到是在《剑指Offer》第2版上,leetcode和...
  • 我当时特别生气,模是我们三个人的事情,我本人也是比较通情达理的,如果你有事情我可以错开我们的见面讨论时间(那段时间我们安排一起讨论的时间并不,也就2次?),但是像这样玩失踪是极不负责任的行为!因为...
  • Python 计算从1-10000内的素数 素数:质数定义为在大于1的自然数中,除了1和它本身以外不再有其他因数。 利用for循环从1-10000将值赋值给i 在函数中判断i是否为素数,用这个求余这个以内的判断余数是否为0 ...
  • 目录: ===============================基础例题100道=============================== 1.输出 "Hello, World!" 2.输出整数 3.输出单个字符 ...5.输出双精度(double) ...(1)一次读取字符,并一个一个显示...
  • python OpenCV 按(帧/时间)间隔截取视频帧

    万次阅读 热门讨论 2020-04-16 10:43:59
    帧率(FPS):每秒钟播放的帧 1、如果你想直接通过帧间隔截取视频帧,那直接使用可以使用下面的代码: ...frameRate = 100 # 帧截取间隔(每隔100帧截取一帧) while(True): ret, frame ...
  • 1.下面代码通过函数调用对4N(1000>=N>=4)之间的偶数,验证哥德巴赫猜想,请补充代码。哥德巴赫猜想:即任一大于2的偶数都可写成两个素数之和。 m%i==0; scanf(“%d”,&N); if(isprime(i)==1&&...
  • 当echarts柱状图个数多,横坐标名称过时横坐标名称显示不全,网上并没有搜太好的方法,于是自己加工了下,将横坐标名称显示前六位,当鼠标放上面的时候显示全名,下面是示例代码,可以直接拷贝测试 ...
  • -- 核心线程,默认为1 --> <!-- 最大线程,默认为Integer.MAX_VALUE --> <!-- 队列最大长度,一般需要设置值>=notifyScheduledMainExecutor.maxNum;默认为Integer.MAX_VALUE--> ...
  • 给定一个十进制正整数N,写下从1开始,N的所有整数,然后一下其中出现的所有“1”的个数。 例如: N= 2,写下1,2。这样只出现了1个“1”。 N= 12,我们会写下1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12。这样...
  • 已迁往:http://www.wypblog.com/archives/141题目描述:将一个长度超过100位数字的十进制非负整数转换为二进制输出。输入:组数据,每行为一个长度不超过30位的十...1000分析:这个不应该存储一个int类型变
  • 在线用户:用户同时在一定时间段的在线数量 并发用户:某一时刻同时向服务器发送请求的用户 一般而言,我们习惯以5-20的比率来推算并发用户与在线用户之间的关系。即,并发与在线的比例约为5%-20% 比如,某...
  • 根号2以及π的计算--关于无理的畅想

    万次阅读 多人点赞 2017-07-02 12:38:43
    曾经写过两篇用朴素的原始...我一般假设自己从来没有学过微积分,没有学过高等代数,只有初中水平,把自己放在古人的位置上,看看如何本质上理解现代数学概念(当然,虽然古人在知识的丰富程度上不如我们,但他们中的
  • 计算网页停留时间的平均时

    千次阅读 2017-06-15 16:58:10
    需求:现在有好多用户访问某个网页的停留时间,要计算平均时。求均值是不太合理的,因为有的时间特别的,这样的时间应该是噪音数据,这样计算的均值感觉就偏大。我感觉应该先找到事件的分布,然后根据分布计算它...
  • RAID技术全解图解-RAID0、RAID1、RAID5、RAID100

    万次阅读 多人点赞 2018-07-31 18:15:32
    图文并茂 RAID 技术全解 – RAID0、RAID1、RAID5、RAID100……  RAID 技术相信大家都有接触过,尤其是服务器运维人员,RAID 概念很,有时候会概念混淆。这篇文章为网络转载,写得相当不错,它对 RAID 技术的概念...
  • IIS:连接、并发连接、最大并发工作线程、应用程序池的队列长度、应用程序池的最大工作进程详解 iis性能指标的各种概念:连接、并发连接、最大并发工作线程、应用程序池的队列长度、应用程序池的最大...
  • Oracle批量导入100万条数据不到1

    万次阅读 2016-12-22 13:48:26
    Oracle 批量导入100万条数据不到1
  • 万字图解Java线程

    万次阅读 多人点赞 2020-09-06 14:45:07
    文章篇幅较,大家也可以有选择的看具体章节,建议线程的代码全部手敲,永远不要相信你看到的结论,自己编码后运行出来的,才是自己的。 什么是java线程? 进程与线程 进程 当一个程序被运行,就开启了一个进程...
  • 响应时间问题分析

    万次阅读 2019-07-18 16:29:49
    不管是性能测试中,还是生产环境中,经常会遇到响应时间的问题。 响应时间是性能评估的一个重要指标,会对最终用户产生直接影响,一个产品是快是慢,响应时间是最直观的感受。 因此面对响应时间长的问题,一定想...
  • Python 经典算法100及解析

    万次阅读 多人点赞 2019-06-10 19:01:26
    1:找出字符串s="aaabbbccceeefff111144444"中,字符出现次数最多的字符 (1)考虑去重,首先将字符串进行过滤去重,这样在根据这些字符进行循环查询时,将会减少循环次数,提升效率。但是本人写的代码较为臃肿,有...
  • 1. 猜你喜欢推荐结果展示图以及商品详情页截图(目前猜你喜欢同时存在一行以及两行标题情况)。商品原始标题往往过(平均长度30字左右),在结果页中无法完整显示,只能点击进入商品详情页才能看到商品完整标题。 ...
  • nginx连接——keepalive

    千次阅读 2021-02-07 09:33:54
    参考:...clientnginx的连接是连接 nginxserver的连接是连接 1、保持和client的连接: 默认情况下,nginx已经自动开启了对client连接的keep alive支持(同时client发送的HTTP...
  • 在做性能测试的时候,很多人都用并发用户来衡量系统的性能,觉得系统能支撑的并发用户,系统的性能就越好;对TPS不是非常理解,也根本不知道它们之间的关系,因此非常有必要进行解释。 2. 术语定义 Ø ...
  • Python3 100例 原题地址: http://www.runoob.com/python/python-100-examples.html git地址: https://github.com/RichardFu123/Python100Cases 原例为Python2.7版本 重写过程中有不少是随意发挥的 ...
  • 寻找性能测试瓶颈,压测重要指标关系--并发、TPS、响应时间

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 792,804
精华内容 317,121
关键字:

从1数到100需要多长时间