Permutation lists?? Really Need Help

Discussion in 'C++' started by Roger B., Sep 25, 2003.

  1. Roger B.

    Roger B. Guest

    Hello,

    I am working on a personal interest project and have been racking my brain
    on this problem for about 5 hours total now, and tracking through old
    newsgroup posts but haven't figuried it out yet so heres my question.

    I want to be able to make a list of all possible combinations (repitiions
    are allowed) of numbers where X is a arbitrary initeger between something
    like 0 and 100
    and the number of x's is arbitrary as well in this example 10 x's are
    present.

    x,x,x,x,x,x,x,x,x,x

    I want to find all possible combinations for this. In the end I would have
    a list of all possible combinations of the x's in groups of ten whre each x
    would be a number between 0 and 100.

    Thanks for any help.
     
    Roger B., Sep 25, 2003
    #1
    1. Advertising

  2. Roger B. wrote:

    > I am working on a personal interest project and have been racking my brain
    > on this problem for about 5 hours total now [...]


    I'm not sure I believe that.

    > I want to be able to make a list of all possible combinations (repitiions
    > are allowed) of numbers where X is a arbitrary initeger between something
    > like 0 and 100
    > and the number of x's is arbitrary as well in this example 10 x's are
    > present.
    >
    > x,x,x,x,x,x,x,x,x,x
    >
    > I want to find all possible combinations for this. In the end I would have
    > a list of all possible combinations of the x's in groups of ten whre each x
    > would be a number between 0 and 100.


    You do know there are 100 000 000 000 000 000 000, right? Think
    of a systematic way of writing them. You might start like this:

    0,0,0,0,0,0,0,0,0
    0,0,0,0,0,0,0,0,1
    0,0,0,0,0,0,0,0,2
    0,0,0,0,0,0,0,0,3
    0,0,0,0,0,0,0,0,4

    The Arabs had this all worked out many centuries ago, and
    I'm pretty sure they didn't need C++ to do it.

    Good luck,
    Buster.
     
    Buster Copley, Sep 25, 2003
    #2
    1. Advertising

  3. On Thu, 25 Sep 2003 01:44:04 GMT, "Roger B." <>
    wrote:

    >Hello,
    >
    > I am working on a personal interest project and have been racking my brain
    >on this problem for about 5 hours total now, and tracking through old
    >newsgroup posts but haven't figuried it out yet so heres my question.
    >
    >I want to be able to make a list of all possible combinations (repitiions
    >are allowed) of numbers where X is a arbitrary initeger between something
    >like 0 and 100
    >and the number of x's is arbitrary as well in this example 10 x's are
    >present.
    >
    >x,x,x,x,x,x,x,x,x,x
    >
    >I want to find all possible combinations for this. In the end I would have
    >a list of all possible combinations of the x's in groups of ten whre each x
    >would be a number between 0 and 100.


    If you have a list of numbers that you would like to make permutations
    of, std::next_permutation() will do the job for you. If you want to
    count up every X from 0 to 100 you'll have to do that yourself, but it's
    easy.

    --
    Be seeing you.
     
    Thore B. Karlsen, Sep 25, 2003
    #3
  4. Roger B.

    Roger B. Guest

    That is not it. Not all numbers from 1 to 100 could be used in a group of
    10 x's. And Numbers could be repeated in the group of 10's. I need all
    combinations. And there are to many to find by hand, plus to do it by hand
    would end up being very confusing after a while. This is not just a count
    up of loops or what else. It is a lot more complicated than that.

    PS. TO BUSTER COPLEY - I don't bullsh** on my posts . It is a personal
    interest project. And I have worked on it for about 5 hours. Thank You.
    "Thore B. Karlsen" <> wrote in message
    news:...
    > On Thu, 25 Sep 2003 01:44:04 GMT, "Roger B." <>
    > wrote:
    >
    > >Hello,
    > >
    > > I am working on a personal interest project and have been racking my

    brain
    > >on this problem for about 5 hours total now, and tracking through old
    > >newsgroup posts but haven't figuried it out yet so heres my question.
    > >
    > >I want to be able to make a list of all possible combinations (repitiions
    > >are allowed) of numbers where X is a arbitrary initeger between something
    > >like 0 and 100
    > >and the number of x's is arbitrary as well in this example 10 x's are
    > >present.
    > >
    > >x,x,x,x,x,x,x,x,x,x
    > >
    > >I want to find all possible combinations for this. In the end I would

    have
    > >a list of all possible combinations of the x's in groups of ten whre each

    x
    > >would be a number between 0 and 100.

    >
    > If you have a list of numbers that you would like to make permutations
    > of, std::next_permutation() will do the job for you. If you want to
    > count up every X from 0 to 100 you'll have to do that yourself, but it's
    > easy.
    >
    > --
    > Be seeing you.
     
    Roger B., Sep 25, 2003
    #4
  5. [Please do not (repeated for your convenience, DO NOT) top-post, rearranged:]

    On Thu, 25 Sep 2003 02:50:43 GMT, "Roger B." <> wrote:

    >"Thore B. Karlsen" <> wrote in message
    >news:...
    >> On Thu, 25 Sep 2003 01:44:04 GMT, "Roger B." <>
    >> wrote:
    >>
    >> >Hello,
    >> >
    >> > I am working on a personal interest project and have been racking my

    >brain
    >> >on this problem for about 5 hours total now, and tracking through old
    >> >newsgroup posts but haven't figuried it out yet so heres my question.
    >> >
    >> >I want to be able to make a list of all possible combinations (repitiions
    >> >are allowed) of numbers where X is a arbitrary initeger between something
    >> >like 0 and 100
    >> >and the number of x's is arbitrary as well in this example 10 x's are
    >> >present.
    >> >
    >> >x,x,x,x,x,x,x,x,x,x
    >> >
    >> >I want to find all possible combinations for this. In the end I would

    >have
    >> >a list of all possible combinations of the x's in groups of ten whre each

    >x
    >> >would be a number between 0 and 100.

    >>
    >> If you have a list of numbers that you would like to make permutations
    >> of, std::next_permutation() will do the job for you. If you want to
    >> count up every X from 0 to 100 you'll have to do that yourself, but it's
    >> easy.


    Thore, you're mean.


    >That is not it. Not all numbers from 1 to 100 could be used in a group of
    >10 x's. And Numbers could be repeated in the group of 10's. I need all
    >combinations. And there are to many to find by hand, plus to do it by hand
    >would end up being very confusing after a while. This is not just a count
    >up of loops or what else. It is a lot more complicated than that.


    Have you considered, as Buster Copley did for you, the number of
    combinations?

    It may be that he misunderstood you, but the spirit of the argument
    was sound; the list will be _long_, and it's generated by simple
    counting (in the decimal system if you have ten unique values).




    >PS. TO BUSTER COPLEY - I don't bullsh** on my posts . It is a personal
    >interest project. And I have worked on it for about 5 hours. Thank You.


    It seems impossible that you worked on it for even 1 minute.

    Anyway, it doesn't have much to do with C++.

    So replies to this posting are redirected to [comp.programming], which
    I think is where you should have posted your problem in the first
    place.

    Hth.


    XFUT: [comp.programming].
     
    Alf P. Steinbach, Sep 25, 2003
    #5
  6. Enjoy!

    #include <iostream>
    #include <vector>

    typedef std::vector <int>::size_type sz_t;
    typedef unsigned digit_t;

    const sz_t size = 10;
    const digit_t modulus = 101;

    std::eek:stream &
    operator << (std::eek:stream & s, const std::vector <digit_t> & v)
    {
    for (sz_t i = 0, n = v.size (); i != n; ++ i)
    (i ? (s << ", ") : s) << v ;
    return s;
    }

    int main ()
    {
    std::vector <digit_t> v (size);
    while (v.back () != modulus)
    {
    std::cout << v << '\n';
    ++ v.front ();
    for (sz_t i = 0; i != size - 1; ++ i) if (v == modulus)
    {
    v = 0;
    ++ v [i + 1];
    }
    }
    }
     
    Buster Copley, Sep 25, 2003
    #6
  7. Roger B.

    Sam Holden Guest

    On Thu, 25 Sep 2003 02:50:43 GMT, Roger B. <> wrote:
    > That is not it. Not all numbers from 1 to 100 could be used in a group of
    > 10 x's. And Numbers could be repeated in the group of 10's. I need all
    > combinations. And there are to many to find by hand, plus to do it by hand
    > would end up being very confusing after a while. This is not just a count
    > up of loops or what else. It is a lot more complicated than that.


    You make no sense. The suggested solution is the normal way to
    generate permutations and combinations. Writing code to do it
    instead of a pen and paper is trivial enough.

    --
    Sam Holden
     
    Sam Holden, Sep 25, 2003
    #7
  8. On Thu, 25 Sep 2003 02:50:43 GMT, "Roger B." <>
    wrote:

    >That is not it. Not all numbers from 1 to 100 could be used in a group of
    >10 x's. And Numbers could be repeated in the group of 10's. I need all
    >combinations. And there are to many to find by hand, plus to do it by hand
    >would end up being very confusing after a while. This is not just a count
    >up of loops or what else. It is a lot more complicated than that.


    I honestly don't know what you're looking for. Do you want to do:

    0,0,0,0,0,0,0,0,0,0
    0,0,0,0,0,0,0,0,0,1
    0,0,0,0,0,0,0,0,0,2

    etc.

    Or do you want to start with a list like this:

    0,1,2,3,4,5,6,7,8,9

    and generate all the combinations of those given numbers.

    The first case is very easy to code, but will take a lifetime to finish
    if you want to go through all of them. For the second case, use
    std::next_permutation().

    --
    Be seeing you.
     
    Thore B. Karlsen, Sep 25, 2003
    #8
  9. Roger B.

    Gavin Deane Guest

    "Roger B." <> wrote in message news:<7Kscb.575053$uu5.94602@sccrnsc04>...

    <please don't top-post, thank you - rearranged>

    > > On Thu, 25 Sep 2003 01:44:04 GMT, "Roger B." <>
    > > wrote:
    > >
    > > >Hello,
    > > >
    > > > I am working on a personal interest project and have been racking my

    > brain
    > > >on this problem for about 5 hours total now, and tracking through old
    > > >newsgroup posts but haven't figuried it out yet so heres my question.
    > > >
    > > >I want to be able to make a list of all possible combinations (repitiions
    > > >are allowed) of numbers where X is a arbitrary initeger between something
    > > >like 0 and 100
    > > >and the number of x's is arbitrary as well in this example 10 x's are
    > > >present.
    > > >
    > > >x,x,x,x,x,x,x,x,x,x
    > > >
    > > >I want to find all possible combinations for this. In the end I would

    > have
    > > >a list of all possible combinations of the x's in groups of ten whre each

    > x
    > > >would be a number between 0 and 100.

    > >
    > > If you have a list of numbers that you would like to make permutations
    > > of, std::next_permutation() will do the job for you. If you want to
    > > count up every X from 0 to 100 you'll have to do that yourself, but it's
    > > easy.

    >
    > That is not it. Not all numbers from 1 to 100 could be used in a group of
    > 10 x's. And Numbers could be repeated in the group of 10's. I need all
    > combinations. And there are to many to find by hand, plus to do it by hand
    > would end up being very confusing after a while. This is not just a count
    > up of loops or what else. It is a lot more complicated than that.


    I'm still not sure of the question. Is what Buster Copley posted not
    what you're after? Before writing any C++ code, you will need to
    precisely and fully understand how you would solve the problem on
    paper, given enough time. If you've got that far, have you got any
    code you're having problems with?

    The standard advice is to break the problem into simple steps and
    implement them one at a time. Without understanding the problem it's
    difficult to try and suggest where to start.

    GJD
     
    Gavin Deane, Sep 25, 2003
    #9
  10. Roger B.

    Jerry Coffin Guest

    In article <ELrcb.568905$Ho3.104820@sccrnsc03>,
    says...
    > Hello,
    >
    > I am working on a personal interest project and have been racking my brain
    > on this problem for about 5 hours total now, and tracking through old
    > newsgroup posts but haven't figuried it out yet so heres my question.
    >
    > I want to be able to make a list of all possible combinations (repitiions
    > are allowed) of numbers where X is a arbitrary initeger between something
    > like 0 and 100
    > and the number of x's is arbitrary as well in this example 10 x's are
    > present.
    >
    > x,x,x,x,x,x,x,x,x,x
    >
    > I want to find all possible combinations for this. In the end I would have
    > a list of all possible combinations of the x's in groups of ten whre each x
    > would be a number between 0 and 100.


    Try a different approach. Storage alone for this is prohibitive for any
    practical purpose -- if you stored your list formatted as you've shown
    it above (i.e. numbers converted to text, commas in between them) you're
    looking at approximately 3 terabytes of storage. If you store the data
    in a fairly obvious binary form, you can get that down to roughly 1
    terabyte, but even that's still ridiculous.

    Thus the advice to find a different approach -- this one is a problem,
    not a solution.

    --
    Later,
    Jerry.

    The universe is a figment of its own imagination.
     
    Jerry Coffin, Sep 25, 2003
    #10
  11. "Roger B." wrote:
    >
    > That is not it. Not all numbers from 1 to 100 could be used in a group of
    > 10 x's.


    Why not?

    > And Numbers could be repeated in the group of 10's.


    Good.

    > I need all
    > combinations. And there are to many to find by hand, plus to do it by hand
    > would end up being very confusing after a while.


    Sure, that's why a computer is perfect for this. But nevertheless (maybe
    using smaller numbers), doing it by hand gives a good grasp at what the
    program is supposed to do.

    > This is not just a count
    > up of loops or what else.


    Basically: Yes it is. But how the loops look in specific and/or if
    maybe recursion is part of your soultion can only be decided if we
    understand your requirement.

    > It is a lot more complicated than that.


    I'm sure it is not complicated.
    The problem is, that nobody seems to understand your requirement
    completely. Thus we don't know what to suggest.

    Could you try to rephrase it?
    Also make sure we understand what is variable in your assignment
    and what is constant. As said: Choose smaller numbers and show
    an example. That helps a lot in understanding your problem.


    --
    Karl Heinz Buchegger
     
    Karl Heinz Buchegger, Sep 25, 2003
    #11
  12. Roger B.

    J. Campbell Guest

    "Roger B." <> wrote in message news:<ELrcb.568905$Ho3.104820@sccrnsc03>...
    > Hello,
    >
    > I am working on a personal interest project and have been racking my brain
    > on this problem for about 5 hours total now, and tracking through old
    > newsgroup posts but haven't figuried it out yet so heres my question.
    >
    > I want to be able to make a list of all possible combinations (repitiions
    > are allowed) of numbers where X is a arbitrary initeger between something
    > like 0 and 100
    > and the number of x's is arbitrary as well in this example 10 x's are
    > present.
    >
    > x,x,x,x,x,x,x,x,x,x
    >
    > I want to find all possible combinations for this. In the end I would have
    > a list of all possible combinations of the x's in groups of ten whre each x
    > would be a number between 0 and 100.
    >
    > Thanks for any help.



    This will work. However, don't wait up all night for the output.
    Were you to save this to a file, it would fill up a world's worth of
    hard-drives!!!

    #include <iostream>
    #include <fstream>

    using namespace std;

    int main(){
    int a,b,c,d,e,f,g,h,i,j;
    int max = 100;
    for(a=0;a<max;++a){
    for(b=0;b<max;++b){
    for(c=0;c<max;++c){
    for(d=0;d<max;++d){
    for(e=0;e<max;++e){
    for(f=0;f<max;++f){
    for(g=0;g<max;++g){
    for(h=0;h<max;++h){
    for(i=0;i<max;++i){
    for(j=0;j<max;++j){
    cout <<a<<" "<<b<<" "<<c<<" "<<d<<" "<<e<<" "
    <<f<<" "<<g<<" "<<h<<" "<<i<<" "<<j<<endl;
    }}}}}}}}}}
    }
     
    J. Campbell, Sep 25, 2003
    #12
  13. Roger B.

    Agent Mulder Guest

    <Roger B>
    > That is not it. Not all numbers from 1 to 100 could be used in a group of
    > 10 x's. And Numbers could be repeated in the group of 10's. I need all
    > combinations. And there are to many to find by hand, plus to do it by hand
    > would end up being very confusing after a while. This is not just a count
    > up of loops or what else. It is a lot more complicated than that.

    </>

    I still don't understand it. Is it the famous lion-cage in disguise? You have,
    say, 100 cages and 10 fierce lions. Each lion must have a cage on its own.
    How many ways are there to cage the lions? Is that the question? What do
    you try to solve? Write out 10 lines by hand so that I can see what you're
    after.

    -X
     
    Agent Mulder, Sep 25, 2003
    #13
  14. Roger B.

    D.F.S. Guest

    "Roger B." <> wrote in message
    news:ELrcb.568905$Ho3.104820@sccrnsc03...
    [snip]
    > I want to be able to make a list of all possible combinations

    (repitiions
    > are allowed) of numbers where X is a arbitrary initeger between

    something
    > like 0 and 100


    are you thinking of (pared down example, five numbers two at a time)?
    1,1 2,2 3,3 4,4 5,5
    1,2 2,3 3,4 4,5
    1,3 2,4 3,5
    1,4 2,4
    1,5

    Are you thinking along the line where order does not matter. 3 is only
    paired with 5 once.
    Are you trying to generate this sequence, or predict the predict the
    number of unique
    combinations?

    /*MAJOR clue here, Note that the number on the right is always equal
    to or greater than
    the number on the left. This makes 3, 5 legal but not 5, 3*/

    if you just want to count them... n =Number of numbers, k =How many in
    each group

    (n + k - 1)!
    -----------
    k! * (n- 1)!
     
    D.F.S., Sep 26, 2003
    #14
    1. Advertising

Want to reply to this thread or ask your own question?

It takes just 2 minutes to sign up (and it's free!). Just click the sign up button to choose a username and then you can ask your own questions on the forum.
Similar Threads
  1. =?UTF-8?B?w4FuZ2VsIEd1dGnDqXJyZXogUm9kcsOtZ3Vleg==

    List of lists of lists of lists...

    =?UTF-8?B?w4FuZ2VsIEd1dGnDqXJyZXogUm9kcsOtZ3Vleg==, May 8, 2006, in forum: Python
    Replies:
    5
    Views:
    439
    =?UTF-8?B?w4FuZ2VsIEd1dGnDqXJyZXogUm9kcsOtZ3Vleg==
    May 15, 2006
  2. fadliwdt

    [help] String permutation with input

    fadliwdt, Nov 17, 2006, in forum: C Programming
    Replies:
    0
    Views:
    435
    fadliwdt
    Nov 17, 2006
  3. fadliwdt

    [help] String permutation with input

    fadliwdt, Nov 17, 2006, in forum: C Programming
    Replies:
    0
    Views:
    518
    fadliwdt
    Nov 17, 2006
  4. fool

    printing the permutation, help

    fool, Jul 7, 2006, in forum: C Programming
    Replies:
    6
    Views:
    389
    Flash Gordon
    Jul 8, 2006
  5. Replies:
    30
    Views:
    1,028
    Arne Vajhøj
    Feb 10, 2008
Loading...

Share This Page