我正在进行一项统计分析,以确定在某个时间范围内,是否通过将较大的交易拆分成几个较小的交易来隐藏它的可能性。我的做法是将较大的数据集分成较小的子集(目前是12个数组),然后对每个子集运行一系列循环,以确定任何元素的组合是否能够达到目标范围。
以下是我的当前代码:
以下是我的当前代码:
amounts_matrix = [1380.54,9583.33,37993.04,3240.96...]
matrix_amounts = amounts_matrix.length
total_permutations = 0;
total_hits = 0;
target_range = 1
target = 130000
low_threshold = target - target_range
high_threshold = target + target_range
entries = []
range = 12
for(x = 0; x< matrix_amounts-(range-1); x++){
amounts = amounts_matrix.slice(x, x+range)
total_amounts = range
for(i = 0; i< total_amounts; i++){
entries.push(amounts[i])
totalcheck(entries)
entries = []
}
for(i = 0; i< total_amounts; i++){
for(j = i+1; j< total_amounts; j++){
entries.push(amounts[i])
entries.push(amounts[j])
totalcheck(entries)
entries = []
}
}
...
for(i = 0; i< total_amounts; i++){
for(j = i+1; j< total_amounts; j++){
for(k = j+1; k< total_amounts; k++){
for(l = k+1; l< total_amounts; l++){
for(m = l+1; m< total_amounts; m++){
for(n = m+1; n< total_amounts; n++){
for(o = n+1; o< total_amounts; o++){
for(p = o+1; p< total_amounts;p++){
for(q = p+1; q< total_amounts;q++){
for(r = q+1; r< total_amounts;r++){
for(s = r+1; s< total_amounts;s++){
for(t = s+1; t< total_amounts;t++){
entries.push(amounts[i])
entries.push(amounts[j])
entries.push(amounts[k])
entries.push(amounts[l])
entries.push(amounts[m])
entries.push(amounts[n])
entries.push(amounts[o])
entries.push(amounts[p])
entries.push(amounts[q])
entries.push(amounts[r])
entries.push(amounts[s])
entries.push(amounts[t])
totalcheck(entries)
entries = []
}
}
}
}
}
}
}
}
}
}
}
}
}
function totalcheck(array){
total_permutations += 1;
sum_amount = 0
for(z = 0; z < array.length; z++){
sum_amount += array[z]
}
if(sum_amount > low_threshold && sum_amount < high_threshold){
total_hits += 1
console.log(array)
console.log(sum_amount.toFixed(2))
console.log("---------------")
}
}
console.log("overall total hits = " + total_hits)
console.log("overall total permutations = " + total_permutations)
我对那些循环的深度感到非常尴尬,我想用一个函数来概括它们,只需告诉它要运行X个循环,而不必像这样一步步构建。 我发现的排列函数对我来说都不太可行,因为它们都构建了包含完整可能性的数组; 在我的函数中,我想要在进行循环时针对目标进行检查,以避免出现巨大的数组并遇到内存问题。 我该如何构建一个递归循环来实现这一点?