在一组数中寻找加和最接近某个值的数组合

已于 2022-04-15 17:41:35 修改
阅读量1w 收藏 27
点赞数 6
分类专栏： 科学计算 文章标签： python mathematica
于 2021-02-04 18:19:20 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/xenonhu/article/details/113661908
版权

在一组数中寻找加和最接近某个值的数组合

今天碰到个小问题，就是需要在一组数中，找到加和数最接近某个值的一系列数。

比如：
[8.05, 6.98, 6.19, 5, 22.96,4.71,4.74,4.25,6.34,2.77,7.31,3.59,18.28,19.55]
中找到最接近84.01的一组数。

这个问题，所有的可能元素的加和组合数为16383，即：

Binomial[14, 1] + Binomial[14, 2] + Binomial[14, 3] + 
 Binomial[14, 4] + Binomial[14, 5] + Binomial[14, 6] + 
 Binomial[14, 7] + Binomial[14, 8] + Binomial[14, 9] + 
 Binomial[14, 10] + Binomial[14, 11] + Binomial[14, 12] + 
 Binomial[14, 13] + Binomial[14, 14]

用mathematica软件

如果求加和等于给定值的计算在mathematica软件中是很方便的，两句话就能搞定了。

array = Subsets[{8.05, 6.98, 6.19, 5, 22.96, 4.71, 4.74, 4.25, 6.34, 2.77, 7.31, 3.59, 18.28, 19.55}, 13];
Do[sumt = Total[array[[i]]];  If[sumt == 84.01, Print[array[[i]]]], {i, 1, Length[array]}]

结果为：

{6.98,6.19,5,22.96,4.71,4.74,4.25,7.31,3.59,18.28}

其中用到的函数是Subsets用于抽取list中元素的组合，13不带花括号则组合包括对所有数量小于等于13的情况。

如果要计算接近的情况，比如相差0.02的情况：

array = Subsets[{8.05, 6.98, 6.19, 5, 22.96, 4.71, 4.74, 4.25, 6.34, 
    2.77, 7.31, 3.59, 18.28, 19.55}, 13];
Do[err = Abs[Total[array[[i]]] - 84.01];
 If[err < 0.02, 
  If[err == 0, Print[err, array[[i]]]; Break[], 
   Print[err, array[[i]]]]], {i, 1, Length[array]}]

结果为：

0.02{8.05,6.19,22.96,4.71,4.25,18.28,19.55}
0.01{8.05,6.19,22.96,4.74,4.25,18.28,19.55}
0.02{8.05,22.96,4.25,7.31,3.59,18.28,19.55}
0.01{6.19,5,22.96,4.71,7.31,18.28,19.55}
0.02{6.19,5,22.96,4.74,7.31,18.28,19.55}
0.02{8.05,6.98,6.19,5,22.96,4.71,4.25,6.34,19.55}
0.02{8.05,6.98,5,22.96,4.25,6.34,7.31,3.59,19.55}
0.{6.98,6.19,5,22.96,4.71,4.74,4.25,7.31,3.59,18.28}

但实际上用mathematica软件做数值计算并不是非常合适，如果语句写的不好，那么很容易卡死。

使用python进行计算

其实最新想到的，并实践的是利用python来解决。这可能跟当前的知识应用状态相关，第一反应就是试图联系线性规划，如果有现成的求解器，那么就不用算了，但略一思索，似乎是不能用的。反而只是一些简单的加和，应该就可以解决。然后第二反应是怎么来解决，没有精确等于解的情况，我想这应该是一个范围，既能得到临界大于，也能得到临界小于的解。所以很自然想到排列，给出一个排列，那么从头计算到尾，自然能够得到最接近解的小于和大于的值。

所以首先实现了一个基于排列的蒙特卡洛方法解：

def MC_permutation():
	data1=[]
	res_data=[]
	res_j=0
	res_jp=0
	res_s1=0
	res_s2=0
	res_err=100.0
	outflag=False

	for i in range(200000):
		data1[:]=data[:]
		random.shuffle(data1) 
		#print("data1=",data1)
		sumt=0
		for j in range(len(data1)):
			sumts=sumt
			sumt=sumt+data1[j]
			if(sumt>suma):
				ds1=abs(sumts-suma)
				ds2=abs(sumt-suma)
				ds=min(ds1,ds2)
				if (ds < res_err):
					#print('')
					#print('ds=',ds)
					#print('i=',i,'data1=',data1)
					#print('j=',j,data1[j])
					#print('sum=',sumts,sumt)
					res_err=ds
					res_data[:]=data1[:]
					res_jp=j
					if (ds1 < ds2):
						res_j=j
					else:
						res_j=j+1
					#print(ds1,ds2)
					#print(j,res_j)
					res_s1=sumts
					res_s2=sumt
				if(ds<0.000001): outflag=True
				break
		if outflag: break

	print("")
	print('permutes=',res_data)
	print(res_jp,res_s1,res_s2)
	print('res_data=',sorted(res_data[:res_j]),' sum=',sum(res_data[:res_j]))
	print(res_s1,res_s2,res_err)

其核心是利用shuffle函数来进行排列的蒙特卡洛采样。

解决了问题以后，有点时间，我想看看利用组合其实也是一样的，那么遍历也是一样的，其实上面的mathematcia软件的计算就是遍历的方法。

基于组合的的蒙特卡洛方法解：

#利用组合的蒙特卡洛方法
def MC_combination():

	lendata=len(data)
	data1=[]
	res_data=[]
	res_st=0.0
	data1[:]=data[:]
	res_err=1000.0
	for i in range(20000):
		k=random.randrange(2,lendata+1) 
		data2=random.sample(data1, k)
		#print('i=',i,'k=',k)
		#print('data2=',data2)
		sumt=sum(data2)
		ds=abs(sumt-suma)
		if (ds < res_err):
			#print('')
			#print('ds=',ds)
			#print('i=',i,'data2=',data2)
			#print('k=',k)
			#print('sum=',sumt)
			res_err=ds
			res_data=data2
			res_st=sumt
			if( ds < 0.0000001): break
	
	print("")
	print('res_data=',sorted(res_data))
	print(res_st,res_err)

其核心是利用random.sample函数来进行组合的蒙特卡洛采样。

而遍历的方法为：

#利用遍历的方法
def sch_emuration():
	lendata=len(data)
	res_data=[]
	res_st=0.0
	res_err=1000.0
	i=0
	outflag=False
	for k in range(1,lendata+1):
		for da in itertools.combinations(data,k):
			i=i+1
			sumt=sum(da)
			#print('i=',i,' k=',k)
			#print('data=',da)
			#print('sumt=',sumt)
			ds=abs(sumt-suma)
			if (ds < res_err):
				#print('')
				#print('ds=',ds)
				#print('data=',da)
				#print('sum=',sumt)
				res_err=ds
				res_data[:]=da[:]
				res_st=sumt
				if(ds<0.0000001): 
					outflag=True
					break
					#pass
		if outflag: break
	
	print("")
	print('res_data=',sorted(res_data))
	print(res_st,res_err)

其核心是利用itertools.combinations遍历所有的组合。

运行结论：

三种方法都能快速的得到结果。

小结

运用mathematica和python对在一组数中寻找加和最接近某个值的数组合问题进行了求解。由于组合数不大，所以利用遍历的方法是不错的。
如果问题更大，那么可能用蒙特卡洛方法也许会在时间上取得优势。

附完整程序

#!/usr/bin/env python3
#_∗_coding: utf-8 _∗_


"""
在一组数中，找到加和数最接近某个值得一系列数。
比如在：
[8.05, 6.98, 6.19, 5, 22.96,4.71,4.74,4.25,6.34,2.77,7.31,3.59,18.28,19.55]
中找到最接近84.01的一组数
"""
import os
import string
import re
import sys
import datetime
import time
import copy
import json
import operator #数学计算操作符
import random
import itertools

data=[8.05, 6.98, 6.19, 5, 22.96,4.71,4.74,4.25,6.34,2.77,7.31,3.59,19.55] #18.28,
suma=84.01

#利用遍历的方法-列出附近的所有解
def sch_emuration_all(de):
	lendata=len(data)
	res_data=[]
	res_st=0.0
	res_err=1000.0
	i=0
	for k in range(1,lendata+1):
		for da in itertools.combinations(data,k):
			i=i+1
			sumt=sum(da)
			#print('i=',i,' k=',k)
			#print('data=',da)
			#print('sumt=',sumt)
			ds=abs(sumt-suma)
			if (ds < res_err):
				#print('')
				#print('ds=',ds)
				#print('data=',da)
				#print('sum=',sumt)
				res_err=ds
				res_data[:]=da[:]
				res_st=sumt
			if (ds <= de):
				print('err=%.2f'%ds,' sum=%.2f'%sumt,' data=',sorted(da))

	print("")
	print('res_data=',sorted(res_data))
	print(res_st,res_err)


#利用遍历的方法
def sch_emuration():
	lendata=len(data)
	res_data=[]
	res_st=0.0
	res_err=1000.0
	i=0
	outflag=False
	for k in range(1,lendata+1):
		for da in itertools.combinations(data,k):
			i=i+1
			sumt=sum(da)
			#print('i=',i,' k=',k)
			#print('data=',da)
			#print('sumt=',sumt)
			ds=abs(sumt-suma)
			if (ds < res_err):
				#print('')
				#print('ds=',ds)
				#print('data=',da)
				#print('sum=',sumt)
				res_err=ds
				res_data[:]=da[:]
				res_st=sumt
				if(ds<0.0000001): 
					outflag=True
					break
					#pass
		if outflag: break
	
	print("")
	print('res_data=',sorted(res_data),' sum=',sum(res_data))
	print(res_st,res_err)


#利用组合的蒙特卡洛方法
def MC_combination():

	lendata=len(data)
	data1=[]
	res_data=[]
	res_st=0.0
	data1[:]=data[:]
	res_err=1000.0
	for i in range(20000):
		k=random.randrange(2,lendata+1) 
		data2=random.sample(data1, k)
		#print('i=',i,'k=',k)
		#print('data2=',data2)
		sumt=sum(data2)
		ds=abs(sumt-suma)
		if (ds < res_err):
			#print('')
			#print('ds=',ds)
			#print('i=',i,'data2=',data2)
			#print('k=',k)
			#print('sum=',sumt)
			res_err=ds
			res_data=data2
			res_st=sumt
			if( ds < 0.0000001): break
	
	print("")
	print('res_data=',sorted(res_data),' sum=',sum(res_data))
	print(res_st,res_err)
	
	



#利用排列的蒙特卡洛方法
def MC_permutation():
	data1=[]
	res_data=[]
	res_j=0
	res_jp=0
	res_s1=0
	res_s2=0
	res_err=100.0
	outflag=False

	for i in range(200000):
		data1[:]=data[:]
		random.shuffle(data1) 
		#print("data1=",data1)
		sumt=0
		for j in range(len(data1)):
			sumts=sumt
			sumt=sumt+data1[j]
			if(sumt>suma):
				ds1=abs(sumts-suma)
				ds2=abs(sumt-suma)
				ds=min(ds1,ds2)
				if (ds < res_err):
					#print('')
					#print('ds=',ds)
					#print('i=',i,'data1=',data1)
					#print('j=',j,data1[j])
					#print('sum=',sumts,sumt)
					res_err=ds
					res_data[:]=data1[:]
					res_jp=j
					if (ds1 < ds2):
						res_j=j
					else:
						res_j=j+1
					#print(ds1,ds2)
					#print(j,res_j)
					res_s1=sumts
					res_s2=sumt
				if(ds<0.000001): outflag=True
				break
		if outflag: break

	print("")
	print('permutes=',res_data)
	print(res_jp,res_s1,res_s2)
	print('res_data=',sorted(res_data[:res_j]),' sum=',sum(res_data[:res_j]))
	print(res_s1,res_s2,res_err)


				
if __name__ == "__main__":

	#遍历的方法
	t1=time.process_time()
	sch_emuration()
	t2=time.process_time()
	print('time elapsed',t2-t1)

	#排列的MC方法
	t1=time.process_time()
	MC_combination()
	t2=time.process_time()
	print('time elapsed',t2-t1)
	

	#组合的MC方法
	t1=time.process_time()
	MC_permutation()
	t2=time.process_time()
	print('time elapsed',t2-t1)

	'''
	datan=sorted([3.59, 6.19, 7.31, 4.25, 18.28, 22.96, 4.71, 6.98, 5, 4.74])
	print(datan)
	print(sum(datan))
	'''

	print("")
	sch_emuration_all(0.05)
	'''
hu_shidong
关注
专栏目录
n个数中寻找m个数，使得和最接近值sum
枝寒不栖
04-03 3007
题目表述：从n个数中找到m个数，使得其和最接近一个值sum。 # -*- coding: utf-8 -*- # @Time : 2019/4/3 10:54 # @Author : RIO # @desc: TODO:DESC a = [8, 7, 3, 2, 6, 1, 5, 9, 4, 10] # 总共多少个数字 total = 10 # 选出多少个数字 _len = 4 # 最...
Java从一组数组中找出最接近目标值的值
weixin_34220179的博客
06-12 6073
两种算法： 1.原始数据是乱序的 2.原始数据是有序的 1. 1 package test; 2 3 import java.io.File; 4 5 public class Test { 6 /** 7 * 假设原始数据是乱序 8 */ 9 static int[] src = new int[] { ...
凑数字 凑金额 的最佳递归程序（by_kagawa）
01-30
经常会碰到一堆数字中选几个组成或最接近某一数字（比如凑发票），这个小程序就是干这个的，非常简洁高效，很有用！
从一个数组中找出最接近目标_给定一个无序数组找出数组中两个数之和等于目标值的所有组合...
weixin_35662051的博客
01-26 1116
问题：给定一个无序数组和一个目标值，找出数组中两个数之和等于目标值的所有组合，并指出其时间复杂度？https://blog.csdn.net/weixin_48502062/article/details/107436828参考答案：假设数组是[3,5,3,5]，目标值是8。答案是否可重复，题里没说，所以分3种情况。如下：1.重复。答案是【0，1】【0，3】【1，2】【2，3】，序号组合，共4种组...
求解数组中N数之和最接近目标值的算法详解
最新发布
fudaihb的博客
06-06 1920
在算法和数据结构的领域中，找到数组中N个元素的和最接近给定目标值的问题是一项经典而有趣的挑战。本文将详细探讨这一问题的解法，包括其背景、常见的解决思路、具体的实现方法以及一些优化技巧。希望读者能够通过本文的学习，深入理解该问题并掌握相关算法的应用。
一组数中寻找加和最接近某个值的组合 JAVA实现
lizefeng1998的博客
04-02 8258
一组数中寻找加和最接近某个值的组合 JAVA 最近帮人做了一个题，就是在一组数中寻找一个子集合，使得这个子集合的数的加和最接近给定的某个值，此外，这些数的类型是浮点数。我第一想到是用01背包问题去解，但是感觉对于整型数好做，浮点数会难以控制精度。再次我给出三种做法，第一种是暴力做法，第二三中方法都是基于蒙特卡洛算法。 1、暴力法 这个方法的思路是使用深度优先遍历将给定数组的所有子集合给出，在代码中，我们按子集合内数字的个数依次给出，例如对于数组[1,2,3]，我们先给出只有一个数字的子集合[1],[2],[
（算法）求数组中数字组合(可多值组合)相加最接近目标数的组合(可能多个)
秃头计划——启动！
11-22 1万+
  今天没事，撸一道算法题   题目要求： 给出一个升序排序的可能重复值的数字数组和一个目标值 其中目标值大于数组中最小数，求数组中数字组合(可多值组合)相加最接近目标数的组合(可能多个) 不考虑空间复杂度，效率最优的算法; 样例: 数组为[3,4,8]，目标值为9，最接近组合为[8];   这道题我的解题思路是：    1.先得到数组的全部不重复不为空的子集    2.将子集的和作为key，子集的元素作为value存进map    3.将子集的和与给定值
挑选数值求和使之最接近给定的值
mabide1234的博客
03-16 692
300,350,330,410,366,369,380,371.34,361.25，使用算法挑选几个数字求和，使该数字最接近1200.
java找出和最接近指定值_如何找到数组元素与特定值最接近的和？
weixin_39624700的博客
03-02 1525
小编典典对于这种问题，通常将使用动态编程。但是，本质上可以归结为保留一组可能的总和，然后将输入值一个接一个地添加，如以下代码所示，并且具有相同的渐近运行时间：O(nK)，其中n输入数组的大小和K目标值。但是，以下版本中的常量可能更大，但我认为代码比动态编程版本容易遵循。public class Test {public static void main(String[] args) {int K ...
Python 寻找一个一维数组中最接近某个值的元素
u011699626的博客
02-21 910
今天做仿真的时候遇到了一个问题，就是如何获取一组数据中最接近某个元素的值。至于，二维或者三维数组可以先展平为一维数组，或者使用循环结构，这里不再做展示。可以看到，我们也成功获取到了想要的结果。可以看到，我们成功获取到了想要的结果。我们想要获取到这中间最接近。比如，这里有一个一维数组。如果我们想要获取到最接近。
根据提供的某数值，找出与其最接近的一组数据
10-17
根据提供的某数值，找出与其最接近的一组数据
找出哪几个数值的和接近目标值
10-21
标题 "找出哪几个数值的和接近目标值" 描述了一个常见的算法问题，它涉及到寻找一组数值中的若干项，使得它们的和最接近于一个给定的目标值。在计算机科学和编程领域，这样的问题通常用于数据处理、数据分析或者优化...
算法 - 从数组中找出和为给定值的所有组合(java)
se-tester的专栏
01-09 2884
public class Pairs { public static void main(String[] args) { Pairs pairs = new Pairs(); // 输出结果为： //[1, 2] //[1, 2, 0] //[1, 3, 0, -1] //[1, 3, -1] //[3] //[3, 0] //[0, -1, 4] .
数组中找出n个数相加，最接近num的
xinpz的博客
11-19 4904
数学问题 -数组中找出n个数相加，最接近num的 有同事提过这个问题，现在有时间了实现下做个整理，主要当时排列组合的概念都不知道是啥了，更不用说实现功能了。 已经不知道排列组合，二项式定理，集合的可以先复习下相关概念和公式算法。 java实现排列组合https://blog.csdn.net/xinpz/article/details/109728624 目录 数学问题 -数组中找出n个数相加，最接近num的 一、概述 问题：数组中找出n个数相加，最接近num的 实现思路： 1...
求数组中多个数相加等于某一值
热门推荐
益达的小作坊
07-29 1万+
主要思想：排序+两端逼近 内容：排序使得整个数组有序从而可以使用双指针从数组的两端向中间逼近所需要的值7、3Sum 顾名思义，求数组中3个数相加等于某一特定的数自己写了一个似乎是O(n^2) 汗颜 在Two Sum的引导下，我成功使用了unordered_map 然而在run code的时候就发现了一个无法解决的问题： Your input [-1,0,1,2,-1,-4] Your a
给定升序数组，以及目标值，查找出最接近目标值的所有数组组合
qq_31217363的博客
11-10 4024
学习需要记录，还有进步的空间，争做越来越好的自己！！！ 解题思路： 1、已知给定的数组是升序的，需要找出和目标值target相近的一些数字的组合，我们通过先找出大于等于的一部分，把这部分先过滤，这样剩下的组合才是需要排查的范围。 2、假如排查后剩下：1，2，3，4，5，7 ；target=10 的话，我们依次拿数组 7开头的 1，2，3，4，5 5开头的1，2，3，4 … 这样递归/循环数组去寻找 3、每次循环我们都用Map存储下对应循环的深度以及开头的值 4、注意存值的时候需要过滤重复的数字组合
调java用数组元素_java – 如何找到数组元素与特定值最接近的总和？
weixin_39653764的博客
02-23 265
您通常会使用动态编程来解决此类问题.但是,这基本上归结为保持一组可能的总和并逐个添加输入值,如下面的代码所示,并具有相同的渐近运行时间：O(n K),其中n是输入的大小数组和K是目标值.但是,下面版本中的常量可能更大,但我认为代码比动态编程版本更容易理解.public class Test {public static void main(String[] args) {int K = 44;Li...
java数组元素相加_Java 找到数组中两个元素相加等于指定数的所有组合
weixin_42384267的博客
02-12 1588
思路1：可以用hash表来存储数组中的元素，这样我们取得一个数后，去判断sum - val 在不在数组中，如果在数组中，则找到了一对二元组，它们的和为sum，该算法的缺点就是需要用到一个hash表，增加了空间复杂度。思路2：同样是基于查找，我们可以先将数组排序，然后依次取一个数后，在数组中用二分查找，查找sum -val是否存在，如果存在，则找到了一对二元组，它们的和为sum，该方法与上面的方法相...
windows下利用Mingw和msmpi编译运行mpi并行程序
xenonhu的博客
10-10 1万+
windows下利用Mingw和msmpi编译运行mpi并行程序目前windows下mpi实现版本已经由微软负责，软件名为msmpi。而原来mpi标准团队的windows下的mpich2实现已经很久没有更新了，当然使用以前下载的mpich2来构建mpi并行程序是没有问题的，但如果要使用mpich3一些新特性，那么就需要使用微软提供的msmpi。msmpi可以与intel，pgi编译器配合使用，但这些
R语言 mosaicplot中超过残差预期值是什么意思？
09-27
### 回答1： 在 R 语言中，`mosaicplot()` 是一种用于绘制马赛克图的函数。马赛克图是一种用于显示两个或更多变量之间关系的图形，其中每个矩形代表一个单元格，并且单元格的大小表示该组合在数据集中出现的频率。 当超过预期的频率或期望值在某些单元格中出现时，称为“超差”（residuals），也可以称为“残差”。这些残差可能表示了数据中的某些趋势或关系，因此对于发现和理解数据中的这些趋势和关系非常有用。在 `mosaicplot()` 中，可以使用 `shade` 参数来突出显示残差。 因此，在 `mosaicplot()` 中超过预期的残差值是指某些组合的观察频率与期望频率之间的差异，可以通过使用 `shade` 参数来突出显示这些残差值。当 `shade=TRUE` 时，`mosaicplot()` 会使用颜色编码来突出显示超出预期的频率或残差。 ### 回答2： 在R语言的mosaicplot中，超过残差预期值意味着观察到的在两个或多个分类变量之间的关系比预期的关系更强烈或有更高的相关性。例如，在一个交叉分类表中，残差预期值是根据行与列变量的独立性来计算的，如果观察到的数据显示某些分类组合的频数明显高于预期值，那么这些组合将呈现出超过残差预期值的情况。 超过残差预期值的情况可能表示两个或多个分类变量之间存在某种关联或相互影响。这种关联或相互影响可能是由于随机性或偶然性导致的，也可能是由于真实的因果关系或其他未知因素导致的。 通过mosaicplot中超过残差预期值的现象，我们可以得出两个分类变量之间存在关联的初步推断。这可以为进一步的研究提供指导，例如建立适当的统计模型或进行更详细的数据分析以验证这种关联的可靠性。 ### 回答3： 在R语言中，使用mosaicplot函数绘制的马赛克图（mosaic plot）可以用于可视化多个分类变量之间的关系。其中，超过残差预期值的意思是某个分类变量在两个或多个其他分类变量之间的相关性大于预期值。 具体来说，残差预期值是根据每个分类变量的边际比例计算得出的。如果两个分类变量之间存在关联，那么马赛克图中的矩形区块（tiles）的颜色会相对平均分布，即呈现出一种期望的均衡状态。如果某个矩形区块的颜色比预期值更接近某一侧（亮色或暗色），则表示该分类变量在两个或多个其他分类变量之间存在显著的正相关或负相关。 因此，超过残差预期值的意思是某个矩形区块的颜色偏离了期望的均衡状态，表明该分类变量在其他分类变量之间具有较强的相关性。这一现象可能暗示着一个有趣的关联关系，需要进一步的数据分析与解释。用户可以通过观察马赛克图中的颜色分布情况，来揭示分类变量之间的关系以及背后的统计意义。
评论 3
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值