populate array problem

This is a discussion on populate array problem within the C# Programming forums, part of the General Programming Boards category; I'm working on creating a punnette square. output array is a 2d 128 row by 14 (7 pairs) columns ( ...

  1. #1
    Registered User
    Join Date
    Oct 2010
    Posts
    9

    populate array problem

    I'm working on creating a punnette square.

    output array is a 2d 128 row by 14 (7 pairs) columns ( just for 1 side of the square).
    source is a 1d 7 column array.

    I have it hard coded atm but am looking for a solution to auto populate if I change the size of source (which would then change the output column size).


    Code:
           //dam[0]=den1; dam[1]=den2; dam[2]=da1; dam[3]=da2; dam[4]=db1; dam[5]=db; dam[6]=dc1; dam[7]=dc2;
                    //dam[8] = dd1; dam[9] = dd2; dam[10] = de1; dam[11] = de2; dam[12]=dv1; dam[13]=dv2;
                    int[] dam = damgtype.ToArray();
    
                    // dam data array populate //
                    // En                  |   A                 |    B                 |   C                   | D                   |   E                    | V //
    
    
                    damdata[0, 0] = dam[0]; damdata[0, 1] = dam[2]; damdata[0, 2] = dam[4]; damdata[0, 3] = dam[6]; damdata[0, 4] = dam[8]; damdata[0, 5] = dam[10]; damdata[0, 6] = dam[12];
                    damdata[1, 0] = dam[0]; damdata[1, 1] = dam[2]; damdata[1, 2] = dam[4]; damdata[1, 3] = dam[6]; damdata[1, 4] = dam[8]; damdata[1, 5] = dam[10]; damdata[1, 6] = dam[13];
                    damdata[2, 0] = dam[0]; damdata[2, 1] = dam[2]; damdata[2, 2] = dam[4]; damdata[2, 3] = dam[6]; damdata[2, 4] = dam[8]; damdata[2, 5] = dam[11]; damdata[2, 6] = dam[12];
                    damdata[3, 0] = dam[0]; damdata[3, 1] = dam[2]; damdata[3, 2] = dam[4]; damdata[3, 3] = dam[6]; damdata[3, 4] = dam[8]; damdata[3, 5] = dam[11]; damdata[3, 6] = dam[13];
                    damdata[4, 0] = dam[0]; damdata[4, 1] = dam[2]; damdata[4, 2] = dam[4]; damdata[4, 3] = dam[6]; damdata[4, 4] = dam[9]; damdata[4, 5] = dam[10]; damdata[4, 6] = dam[12]; //d2e1v1
                    damdata[5, 0] = dam[0]; damdata[5, 1] = dam[2]; damdata[5, 2] = dam[4]; damdata[5, 3] = dam[6]; damdata[5, 4] = dam[9]; damdata[5, 5] = dam[10]; damdata[5, 6] = dam[13];
                    damdata[6, 0] = dam[0]; damdata[6, 1] = dam[2]; damdata[6, 2] = dam[4]; damdata[6, 3] = dam[6]; damdata[6, 4] = dam[9]; damdata[6, 5] = dam[11]; damdata[6, 6] = dam[12]; //d2e2v1
                    damdata[7, 0] = dam[0]; damdata[7, 1] = dam[2]; damdata[7, 2] = dam[4]; damdata[7, 3] = dam[6]; damdata[7, 4] = dam[9]; damdata[7, 5] = dam[11]; damdata[7, 6] = dam[13];
                    damdata[8, 0] = dam[0]; damdata[8, 1] = dam[2]; damdata[8, 2] = dam[4]; damdata[8, 3] = dam[7]; damdata[8, 4] = dam[8]; damdata[8, 5] = dam[10]; damdata[8, 6] = dam[12]; //c2d1e1v1
                    damdata[9, 0] = dam[0]; damdata[9, 1] = dam[2]; damdata[9, 2] = dam[4]; damdata[9, 3] = dam[7]; damdata[9, 4] = dam[8]; damdata[9, 5] = dam[10]; damdata[9, 6] = dam[13];
                    damdata[10, 0] = dam[0]; damdata[10, 1] = dam[2]; damdata[10, 2] = dam[4]; damdata[10, 3] = dam[7]; damdata[10, 4] = dam[8]; damdata[10, 5] = dam[11]; damdata[10, 6] = dam[12]; //c2d1e2v1
                    damdata[11, 0] = dam[0]; damdata[11, 1] = dam[2]; damdata[11, 2] = dam[4]; damdata[11, 3] = dam[7]; damdata[11, 4] = dam[8]; damdata[11, 5] = dam[11]; damdata[11, 6] = dam[13];
                    damdata[12, 0] = dam[0]; damdata[12, 1] = dam[2]; damdata[12, 2] = dam[4]; damdata[12, 3] = dam[7]; damdata[12, 4] = dam[9]; damdata[12, 5] = dam[10]; damdata[12, 6] = dam[12]; //c2d2e1v1
                    damdata[13, 0] = dam[0]; damdata[13, 1] = dam[2]; damdata[13, 2] = dam[4]; damdata[13, 3] = dam[7]; damdata[13, 4] = dam[9]; damdata[13, 5] = dam[10]; damdata[13, 6] = dam[13];
                    damdata[14, 0] = dam[0]; damdata[14, 1] = dam[2]; damdata[14, 2] = dam[4]; damdata[14, 3] = dam[7]; damdata[14, 4] = dam[9]; damdata[14, 5] = dam[11]; damdata[14, 6] = dam[12]; //c2d2e2v1
                    damdata[15, 0] = dam[0]; damdata[15, 1] = dam[2]; damdata[15, 2] = dam[4]; damdata[15, 3] = dam[7]; damdata[15, 4] = dam[9]; damdata[15, 5] = dam[11]; damdata[15, 6] = dam[13];
                    damdata[16, 0] = dam[0]; damdata[16, 1] = dam[2]; damdata[16, 2] = dam[5]; damdata[16, 3] = dam[6]; damdata[16, 4] = dam[8]; damdata[16, 5] = dam[10]; damdata[16, 6] = dam[12]; //b2c1d1e1v1
                    damdata[17, 0] = dam[0]; damdata[17, 1] = dam[2]; damdata[17, 2] = dam[5]; damdata[17, 3] = dam[6]; damdata[17, 4] = dam[8]; damdata[17, 5] = dam[10]; damdata[17, 6] = dam[13];
                    damdata[18, 0] = dam[0]; damdata[18, 1] = dam[2]; damdata[18, 2] = dam[5]; damdata[18, 3] = dam[6]; damdata[18, 4] = dam[8]; damdata[18, 5] = dam[11]; damdata[18, 6] = dam[12]; //b2c1d1e2v1
                    damdata[19, 0] = dam[0]; damdata[19, 1] = dam[2]; damdata[19, 2] = dam[5]; damdata[19, 3] = dam[6]; damdata[19, 4] = dam[8]; damdata[19, 5] = dam[11]; damdata[19, 6] = dam[13];
                    damdata[20, 0] = dam[0]; damdata[20, 1] = dam[2]; damdata[20, 2] = dam[5]; damdata[20, 3] = dam[6]; damdata[20, 4] = dam[9]; damdata[20, 5] = dam[10]; damdata[20, 6] = dam[12]; //b2c1d2e1v1
                    damdata[21, 0] = dam[0]; damdata[21, 1] = dam[2]; damdata[21, 2] = dam[5]; damdata[21, 3] = dam[6]; damdata[21, 4] = dam[9]; damdata[21, 5] = dam[10]; damdata[21, 6] = dam[13];
                    damdata[22, 0] = dam[0]; damdata[22, 1] = dam[2]; damdata[22, 2] = dam[5]; damdata[22, 3] = dam[6]; damdata[22, 4] = dam[9]; damdata[22, 5] = dam[11]; damdata[22, 6] = dam[12]; //b2c1d2e2v1
                    damdata[23, 0] = dam[0]; damdata[23, 1] = dam[2]; damdata[23, 2] = dam[5]; damdata[23, 3] = dam[6]; damdata[23, 4] = dam[9]; damdata[23, 5] = dam[11]; damdata[23, 6] = dam[13];
                    damdata[24, 0] = dam[0]; damdata[24, 1] = dam[2]; damdata[24, 2] = dam[5]; damdata[24, 3] = dam[7]; damdata[24, 4] = dam[8]; damdata[24, 5] = dam[10]; damdata[24, 6] = dam[12]; //b2c2d1e1v1
                    damdata[25, 0] = dam[0]; damdata[25, 1] = dam[2]; damdata[25, 2] = dam[5]; damdata[25, 3] = dam[7]; damdata[25, 4] = dam[8]; damdata[25, 5] = dam[10]; damdata[25, 6] = dam[13];
                    damdata[26, 0] = dam[0]; damdata[26, 1] = dam[2]; damdata[26, 2] = dam[5]; damdata[26, 3] = dam[7]; damdata[26, 4] = dam[8]; damdata[26, 5] = dam[11]; damdata[26, 6] = dam[12];
                    damdata[27, 0] = dam[0]; damdata[27, 1] = dam[2]; damdata[27, 2] = dam[5]; damdata[27, 3] = dam[7]; damdata[27, 4] = dam[8]; damdata[27, 5] = dam[11]; damdata[27, 6] = dam[13];
                    damdata[28, 0] = dam[0]; damdata[28, 1] = dam[2]; damdata[28, 2] = dam[5]; damdata[28, 3] = dam[7]; damdata[28, 4] = dam[9]; damdata[28, 5] = dam[10]; damdata[28, 6] = dam[12]; // b2c2d2e1v1
                    damdata[29, 0] = dam[0]; damdata[29, 1] = dam[2]; damdata[29, 2] = dam[5]; damdata[29, 3] = dam[7]; damdata[29, 4] = dam[9]; damdata[29, 5] = dam[10]; damdata[29, 6] = dam[13];

  2. #2
    Super Moderator VirtualAce's Avatar
    Join Date
    Aug 2001
    Posts
    9,590
    After finding out what punnete square is (thank you Google), it looks fairly simple to code.

    Remove your hardcoded 'stuff'. I could tell you how to do it but that really wouldn't help you. Try it out using some loops or other data structures and post your attempt here. From there myself and perhaps more people can guide you in various directions based on your efforts.

  3. #3
    Registered User
    Join Date
    Oct 2010
    Posts
    9
    I took another crack at it trying various methods. This time I tried it from left to right instead of right to left.

    this is what I came up with:
    Code:
        int den = 1; int da = 1; int db = 1; int dc = 1; int dd = 1; int de = 1; int dv = 0; int x = 0;
    
                    do
                    {
                        // Broken
                        if (den <= 64)
                        { damdata[x, 0] = dam[0]; }
                        else { damdata[x, 0] = dam[1]; }
    
    
                        {
                            // Agouti
                            if (da <= 32)
                            { damdata[x, 1] = dam[2]; }
                            else { damdata[x, 1] = dam[3]; }
                            if (da == 64) // reset Agouti counter
                            { da = 1; }
                        }
                        {
                            // Brown
                            if (db <= 16)
                            { damdata[x, 2] = dam[4]; }
                            else { damdata[x, 2] = dam[5]; }
                            if (db == 32) // reset Brown counter
                            { db = 1; }
                        }
                        {
                            // Color
                            if (dc <= 8)
                            { damdata[x, 3] = dam[6]; }
                            else { damdata[x, 3] = dam[7]; }
                            if (dc == 16) // reset Color counter
                            { dc = 1; }
                        }
                        {
                            // Dilute
                            if (dd <= 4)
                            { damdata[x, 4] = dam[8]; }
                            else { damdata[x, 4] = dam[9]; }
                            if (dd == 8) // reset Dilute counter
                            { dd = 1; }
                        }
                        {
                            // Extension
                            if (de <= 2)
                            { damdata[x, 5] = dam[10]; }
                            else { damdata[x, 5] = dam[11]; }
                            if (de == 4) //reset Extension counter
                            { de = 1; }
                        }
                        {
                            // Vienna 
                            if (dv == 1)
                            { damdata[x, 6] = dam[12]; }
                            else { damdata[x, 5] = dam[13]; }
                            if (dv == 2) // reset Vienna counter
                            { dv = 1; }
                        }
                        x++; den++; da++; db++; dc++; dd++; de++; dv++;
                    } while (x < 127);
    Is there a more efficient way to do this?

    below is a description of the problem:
    Dam contains EnenAaBbCcDdEeVv
    What I need damdata to contain is:
    EnABCDEV
    ENABCDEv
    ENABCDeV
    EnABCDev
    EnABCdEV
    ect.....
    Last edited by DaleZ; 11-23-2010 at 03:31 PM. Reason: update

  4. #4
    Super Moderator VirtualAce's Avatar
    Join Date
    Aug 2001
    Posts
    9,590
    I guess I'm a bit lost but let's break the problem down to something much simpler.

    Excuse my terrible ASCII art grid:

    ____A___B___C___D____AB
    A__AA__AB__AC__AD____AAB
    B__BA__BB__BC__BD____BAB
    C__CA__CB__CC__CD___CAB
    D__AD__DB__DC__DD___DAB
    CB_CBA_CBB_CBC_CBD__CBAB

    To me it looks like you take every letter from the current row and add every letter from the current column. This should be simple to do once you set your columns and rows up correctly.
    Last edited by VirtualAce; 11-24-2010 at 12:46 AM.

Popular pages Recent additions subscribe to a feed

Similar Threads

  1. Replies: 3
    Last Post: 08-16-2010, 10:00 AM
  2. problem with qsort and array via calloc
    By Zimbobo in forum C Programming
    Replies: 2
    Last Post: 11-22-2009, 11:25 PM
  3. Array problem
    By TomBoyRacer in forum C++ Programming
    Replies: 3
    Last Post: 04-08-2007, 11:35 AM
  4. Replies: 6
    Last Post: 02-15-2005, 10:20 PM
  5. From stream/file to a string array problem
    By dradsws in forum C Programming
    Replies: 2
    Last Post: 10-01-2001, 06:24 PM

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21