It looks like you're new here. If you want to get involved, click one of these buttons!

- 140.8K All Categories
- 103.7K Programming Languages
- 6.5K Assembler Developer
- 1.9K Basic
- 40K C and C++
- 2.9K C#
- 7.9K Delphi and Kylix
- 4 Haskell
- 9.7K Java
- 4.1K Pascal
- 1.3K Perl
- 2K PHP
- 546 Python
- 37 Ruby
- 4.4K VB.NET
- 1.6K VBA
- 20.8K Visual Basic
- 2.6K Game programming
- 315 Console programming
- 91 DirectX Game dev
- 1 Minecraft
- 112 Newbie Game Programmers
- 2 Oculus Rift
- 9K Applications
- 1.8K Computer Graphics
- 741 Computer Hardware
- 3.4K Database & SQL
- 535 Electronics development
- 1.6K Matlab
- 628 Sound & Music
- 257 XML Development
- 3.3K Classifieds
- 199 Co-operative Projects
- 198 For sale
- 190 FreeLance Software City
- 1.9K Jobs Available
- 603 Jobs Wanted
- 209 Wanted
- 2.9K Microsoft .NET
- 1.8K ASP.NET
- 1.1K .NET General
- 3.4K Miscellaneous
- 8 Join the Team
- 354 Comments on this site
- 69 Computer Emulators
- 2.1K General programming
- 187 New programming languages
- 627 Off topic board
- 201 Mobile & Wireless
- 73 Android
- 126 Palm Pilot
- 338 Multimedia
- 154 Demo programming
- 184 MP3 programming
- Bash scripts
- 27 Cloud Computing
- 53 FreeBSD
- 1.7K LINUX programming
- 370 MS-DOS
- Shell scripting
- 321 Windows CE & Pocket PC
- 4.1K Windows programming
- 940 Software Development
- 417 Algorithms
- 68 Object Orientation
- 91 Project Management
- 95 Quality & Testing
- 268 Security
- 7.7K WEB-Development
- 1.8K Active Server Pages
- 61 AJAX
- 4 Bootstrap Themes
- 55 CGI Development
- 28 ColdFusion
- 224 Flash development
- 1.4K HTML & WEB-Design
- 1.4K Internet Development
- 2.2K JavaScript
- 37 JQuery
- 305 WEB Servers
- 150 WEB-Services / SOAP

setri
Member Posts: **1**

in Algorithms

Hello Folks,

With regards to math and algorithms in general, you are the only minds I could think of that could help me solve this problem I've been battling with for the past two days. Your help will be very much appreciated. So here it goes.

[hr]

The Question is I can have a series of numbers consisting of N number of sixes and a single other number between one and five. I have X number of individuals over which i can distribute the series of numbers.

So for instance X1 can take B number of sixes and 1 other integer and X2 can take C number of sixes such that B+C+ (1 other integer) will exhaust the series. In other words any number of X over which the distribution is done over must completely exhaust the series.

The purpose of the algorithm I want is to find out all the possible ways of distributing N sixes and 1 other integer over X number of individuals such that any number of X over which the distribution is done completely exhaust the series.

I hope I've explained the problem clearly enough?

I would also appreciate it if this addition could be made to the algorithm: the distributions may be done over any X individual in either negative bias or positive bias. so for instance X1 may take B number of -(sixes) and 1 -(other number) and X2 can take C number of sixes such that it completely exhausts the series thus if I have a series of 3 sixes and two to distribute over four individuals i can have the following distributions:

Distribution:1

X1:{6,6,6,1}

X2:

X3:

X4:

or

Distribution:2

X1:-{6,6,6,1}

X2:

X3:

X4:

or

Distribution:3

X1:{6,6}

X2:-{6,1}

X3:

X4:

or

Distribution:4

X1:{6,1}

X2:-{6}

X3:{1}

X4:

and so on!

Note:

X1:6,6,6,1=X1:6,1,6,6 = X1:1,6,6,6 and so on...

Well that's it. one way I thought of doing this was to do the math and find out the number of possible ways to do the distribution and then randomly generate some possible ways such that each newly generated pattern does not match a previously generated pattern of distribution, until the number of generated patterns equals the number of possible ways but of course this would take forever to complete and will be come very inefficient as the number of pattern grows!

The algorithms can be written in pseudo code or presented in a flow chart but languages such as java, c#, or basic are also welcome. c# is most preferred as this is the language I'm working in

So as to the question why I'm doing this, If you haven't already guessed

I want to find out all the possible moves a player can make with any of his/her active pieces in a ludo game.

So If there's is a more efficient way of doing it other than the algorithm I stated above, Please share

With regards to math and algorithms in general, you are the only minds I could think of that could help me solve this problem I've been battling with for the past two days. Your help will be very much appreciated. So here it goes.

[hr]

The Question is I can have a series of numbers consisting of N number of sixes and a single other number between one and five. I have X number of individuals over which i can distribute the series of numbers.

So for instance X1 can take B number of sixes and 1 other integer and X2 can take C number of sixes such that B+C+ (1 other integer) will exhaust the series. In other words any number of X over which the distribution is done over must completely exhaust the series.

The purpose of the algorithm I want is to find out all the possible ways of distributing N sixes and 1 other integer over X number of individuals such that any number of X over which the distribution is done completely exhaust the series.

I hope I've explained the problem clearly enough?

I would also appreciate it if this addition could be made to the algorithm: the distributions may be done over any X individual in either negative bias or positive bias. so for instance X1 may take B number of -(sixes) and 1 -(other number) and X2 can take C number of sixes such that it completely exhausts the series thus if I have a series of 3 sixes and two to distribute over four individuals i can have the following distributions:

Distribution:1

X1:{6,6,6,1}

X2:

X3:

X4:

or

Distribution:2

X1:-{6,6,6,1}

X2:

X3:

X4:

or

Distribution:3

X1:{6,6}

X2:-{6,1}

X3:

X4:

or

Distribution:4

X1:{6,1}

X2:-{6}

X3:{1}

X4:

and so on!

Note:

X1:6,6,6,1=X1:6,1,6,6 = X1:1,6,6,6 and so on...

Well that's it. one way I thought of doing this was to do the math and find out the number of possible ways to do the distribution and then randomly generate some possible ways such that each newly generated pattern does not match a previously generated pattern of distribution, until the number of generated patterns equals the number of possible ways but of course this would take forever to complete and will be come very inefficient as the number of pattern grows!

The algorithms can be written in pseudo code or presented in a flow chart but languages such as java, c#, or basic are also welcome. c# is most preferred as this is the language I'm working in

So as to the question why I'm doing this, If you haven't already guessed

I want to find out all the possible moves a player can make with any of his/her active pieces in a ludo game.

So If there's is a more efficient way of doing it other than the algorithm I stated above, Please share

Terms of use / Privacy statement / Publisher: Lars Hagelin

Programmers Heaven articles / Programmers Heaven files / Programmers Heaven uploaded content / Programmers Heaven C Sharp ebook / Operated by CommunityHeaven

© 1997-2015 Programmersheaven.com - All rights reserved.

## Comments

39def distribute( list/vector/array individuals, int sixes):

if sixes == 0:

print individuals

else:

for i in individuals:

i += 1

distribute( individuals, sixes-1)

i -= 1

individuals is a list/vector/array with length == however many individuals you like. You will have to declare that externally. sixes is the amount of sixes you want to distribute. The pseudo code is (roughly) Python with type declarations. So, the for loop will set i to each element in the individuals list. Although, I suppose you would want to modify the list at spot x, not x, so it's a little misleading. But, hey, you don't have that syntax in the C family anyway, right?

Pretend that we have our sixes indexed for a moment. The for loop will put 6-1 in the first spot. Then, it will call distribute and put 6-2 in the first spot. It keeps doing this all the way through 6-N. When it gets to the Nth six, it will print the configuration and remove 6-N from the first individual. It will give 6-N to each individual until they have all gotten it. Then, it will pull back and move 6-(N-1). It's hard to explain, so if you are really curious, check out dynamic programming.

Also, I wrote it out (in Python), and it works fine, except that it generates the some answers multiple times. So, it could stand to be improved upon.

Anyway, as for the other number on the end, I came up with two solutions. The first is to pass distribute N+1 sixes and assume the six on the end is your number. Then, idk, do some fancy string printing work or something to make the last six into your number. The other option would involve (somehow) passing each complete configuration back to your main function and sticking your number in each one of its spots. But that would require a substantial rewrite of my function. In Python, it might be doable with generators, but I'm not sure what the C#/Java equivalent of that would be. Hope this helps.

39