Question

我正在尝试编写一个算法/代码（在java中）从大数字中取块（随机）并将块总和加到原来的大数字。并且，块的数量应该是动态的。例如：
假设，大数（LN）是300000。该算法需要较小的块（SC），其应该是随机的，例如80K，80K，40K，100K（基本上在Ks-不大于100k），其总和为LN（300000）。块的数量应取决于用户输入。

以下是我现在的代码：

AverageChunk=LargeNumber/NumberOfChunks;
LowerLimit = AverageChunk/1000 - 11;
UpperLimit = AverageChunk/1000 + 11;
n=1,chunkUntilNow=0,nextChunkIncrement=0,
nextChunkDecrement=0;nextFiveChunkDecrement=0;
totalChunkUntilNow = 0;cnt=0;
while(n<=NumberOfChunks){
    cnt++;
    chunk=random(LowerLimit to UpperLimit)*1000;
    takeChunk = chunk + nextChunkIncrement - nextFiveChunkDecrement;
    if(chunk < nextFiveChunkDecrement){  //CASE FLUCTUATE
        if((nextFiveChunkDecrement-chunk)>chunk){
            takeChunk = nextFiveChunkDecrement-chunk;
        }
    }    
    totalChunkUntilNow = totalChunkUntilNow + takeChunk;
    if(n%10 ==5){
        if(totalChunkUntilNow<AverageChunk){
            nextChunkIncrement = AverageChunk*cnt - totalChunkUntilNow;
            nextChunkDecrement = 0;
        }else{
            nextChunkDecrement = totalChunkUntilNow - AverageChunk*cnt;
            nextFiveChunkDecrement = nextChunkDecrement /5;
        }
    }
}

此当前代码采用largeNumber并将其除以numberOfRequiredChunks并找到averageChunkPerExtraction。 averageChunkPerExtraction除以1000，然后加上/减去11得到upperLimit / lowerLimit。然后在限制之间生成随机数并乘以1000以获得用于提取的随机块.......

但是这段代码会产生错误，上升/下降上限/下限和波动误差取决于它进入CASE FLUCTUATE的次数

Answer 1

这是一种快速而肮脏的方式。

import java.util.Random;

public class ChunkChunk {

    public static void main(String[] args) {
        if (args.length < 1) {
            System.out.println("Usage: ChunkChunk [Long Number] [number of chunks]");
            System.exit(0);
        }

        Random randGen = new Random();
        int startNum = Integer.parseInt(args[0]);
        int numChunks = randGen.nextInt(startNum/1000);
        int endNum = 0; 

        if (args.length == 2) {
           int arg2 = Integer.parseInt(args[1]);
           if (startNum % arg2 > 0) {
               System.out.println("Number of Chunks must be a distribution of 1k in large number");
               System.exit(0);
           } 
           numChunks = arg2;
        }

        System.out.println("Starting: " + startNum + "\tNumber of Chunks: " + numChunks);
        int startSeed = (startNum/numChunks);
        int index = 0;
        while(startNum > 0) {
            startSeed = (startNum/numChunks) >= 1000 ? startSeed : 1000; 
            int chunk = randGen.nextInt(startSeed) + 1;  
            chunk = (chunk / 1000) * 1000;
            if (chunk > 0) {
                if (numChunks == 1) {
                    endNum += startNum;
                    startNum = 0;
                } else {
                    startNum -= chunk;
                    endNum += chunk;
                }
                System.out.println(String.format("%d. Remaing: %d\t\tChunk: %d\t\t End: %d", ++index, startNum, chunk, endNum));
                numChunks--;
            }
        }

        System.out.println("Done");
    }
}

[Running] cd "/Users/raymonddoran/Development/TDF/StackOverflow/" && javac ChunkChunk.java && java ChunkChunk
Starting: 300000        Number of Chunks: 10
1. Remaing: 281000              Chunk: 19000             End: 19000
2. Remaing: 261000              Chunk: 20000             End: 39000
3. Remaing: 249000              Chunk: 12000             End: 51000
4. Remaing: 246000              Chunk: 3000              End: 54000
5. Remaing: 220000              Chunk: 26000             End: 80000
6. Remaing: 217000              Chunk: 3000              End: 83000
7. Remaing: 205000              Chunk: 12000             End: 95000
8. Remaing: 176000              Chunk: 29000             End: 124000
9. Remaing: 173000              Chunk: 3000              End: 127000
10. Remaing: 0          Chunk: 27000             End: 300000
Done

Answer 2

例如，你有300000个元素，4个像块数。每个尺寸平均为300k / 4 = 75k。决定不好！从一个简单的案例开始，4块，400.000。

最简单的案例：一块，大小400.000。你是如何代表这个大块的？你是如何代表4块的？你有没有听说过Lists，Vector，Arrays等集合？

一大块：

List<Integer> chunks = new List <> ();
chunks.add (400);

4 Chunks：

List<Integer> chunks = new List <> ();
chunks.add (100);
chunks.add (100);
chunks.add (100);
chunks.add (100);

4块变化：

List<Integer> chunks = new List <> ();
chunks.add (150); 
chunks.add (120);
chunks.add ( 80);
chunks.add ( 50);

5个参数化大小的块：

List<Integer> getChunks (int size, int chunkcount) {
    List<Integer> chunks = new List <> ();
    avgsize = size / chunkcount;
    chunks.add (150*avgsize/100); 
    chunks.add (120*avgsize/100);
    chunks.add ( 80*avgsize/100);
    chunks.add ( 50*avgsize/100);
    return chunks;
}

随机块：稍后再做。

将您的代码划分为独立的小模块，这些模块很容易被测试。

块的列表是容易传递给方法的东西，并且很容易从方法返回它。

使用简单的List编写程序，以便于测试。制作一个尽快运行的存根。一个hello-world - thingy，它打印出它的名字。您需要经常测试每一个新步骤。

从大数量获取块的算法，直到块总和为原始大数

2 个答案: