Howdy, Stranger!

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

Sign In with Facebook Sign In with Google Sign In with OpenID

Categories

We have migrated to a new platform! Please note that you will need to reset your password to log in (your credentials are still in-tact though). Please contact lee@programmersheaven.com if you have questions.
Welcome to the new platform of Programmer's Heaven! We apologize for the inconvenience caused, if you visited us from a broken link of the previous version. The main reason to move to a new platform is to provide more effective and collaborative experience to you all. Please feel free to experience the new platform and use its exciting features. Contact us for any issue that you need to get clarified. We are more than happy to help you.

Permutation and Combination Algorithm Please help!!!

setrisetri Posts: 1Member
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

Comments

  • bubbatremellbubbatremell Posts: 39Member
    I don't know C#, but I might have a dynamic programming solution to help you out. It would go something like this:

    def 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.
  • bubbatremellbubbatremell Posts: 39Member
    I gave it some more thought, and I believe the number of repeated columns goes up quite a bit as you add more sixes and more spots. My algorithm really doesn't solve the problem all that well. Sorry.
Sign In or Register to comment.