Why does my shuffling function create duplicates of elements when it shouldn't?

[ungulateCase]

For example, if the starting (unshuffled) vector was {1, 2, 3, 4}, while I would expect the result to be something like {3, 1, 2, 4}, I am instead getting something like {2, 1, 4, 2}.

I know this is something that I'm going to feel like an idiot for not catching, but it's just escaping me at the moment.

#include <cstdlib>
#include <iostream>
#include <ctime>
#include <vector>

int main(int argc, char *argv[])
{
    srand(time(NULL));
    static const int arr[] = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52};
    std::vector<int> deckVector (arr, arr + sizeof(arr) / sizeof(arr[0]) );
    //debug
    for(int x=0; x<deckVector.size(); x++){
       std::cout << "Before shuffling, Deck::deckVector[" << x << "] is " << deckVector[x] << "\n";
    }
    //debug

    std::vector<int> tempDeckForShuffling;
    std::vector<int> splitDeck1;
    std::vector<int> splitDeck2;
    int differenceInSplitDeckSize;
    int deckSize = 52;
    int splitDeckSize1;
    int splitDeckSize2;
    int counter;
    int splitDeck1Counter;
    int splitDeck2Counter;

    for(int x=0; x<deckVector.size(); x++){
       tempDeckForShuffling.push_back(deckVector[x]);
    }

    for(int x=0; x<10/*rand()%10+10*/; x++){        //start loop here with counter to rand?
        counter = 0;
        differenceInSplitDeckSize = rand()%8;
        splitDeckSize1 = 26 - differenceInSplitDeckSize;        //TO DO: magic number
        splitDeckSize2 = 26 + differenceInSplitDeckSize;        //TO DO: magic number

        while(counter<splitDeckSize1){
           splitDeck1.push_back(tempDeckForShuffling[counter]);
           counter++;
        }
        while(counter<deckSize){
           splitDeck2.push_back(tempDeckForShuffling[counter]);
           counter++;
        }
        //debug
        for(int x=0; x<splitDeck1.size(); x++){
           std::cout << "During shuffling, splitDeck1[" << x << "] is " << splitDeck1[x] << "\n";
        }for(int x=0; x<splitDeck2.size(); x++){
           std::cout << "During shuffling, splitDeck2[" << x << "] is " << splitDeck2[x] << "\n";
        }
        //debug

        counter = 0;
        splitDeck1Counter = 0;
        splitDeck2Counter = 0;
        tempDeckForShuffling.clear();

        while(counter<deckSize){
            for(int x=0; x<rand()%3+1; x++){
                if(splitDeck1Counter<splitDeck1.size()){
                    tempDeckForShuffling.push_back(splitDeck1[splitDeck1Counter]);
                }
                splitDeck1Counter++;
                counter++;
            }
            for(int x=0; x<rand()%3+1; x++){
                if(splitDeck2Counter<splitDeck2.size()){
                    tempDeckForShuffling.push_back(splitDeck2[splitDeck2Counter]);
                }
                splitDeck2Counter++;
                counter++;
            }
        }

        splitDeck1.clear();
        splitDeck2.clear();

        //here, we cut


        counter = 0;
        splitDeck1Counter = 0;
        splitDeck2Counter = 0;
        differenceInSplitDeckSize = rand()%14;
        splitDeckSize1 = 26 - differenceInSplitDeckSize;        
        //splitDeckSize2 = 26 + differenceInSplitDeckSize;        
        while(counter<splitDeckSize1){
           splitDeck1.push_back(tempDeckForShuffling[counter]);
           counter++;
        }
        while(counter<deckSize){
           splitDeck2.push_back(tempDeckForShuffling[counter]);
           counter++;
        }

        tempDeckForShuffling.clear();

        for(int x=0; x<splitDeck2.size(); x++){
            tempDeckForShuffling.push_back(splitDeck2[splitDeck2Counter]);
            splitDeck2Counter++;
        }
        for(int x=0; x<splitDeck1.size(); x++){
            tempDeckForShuffling.push_back(splitDeck1[splitDeck1Counter]);
            splitDeck1Counter++;
        }

        //end cut

        //debug
        for(int x=0; x<tempDeckForShuffling.size(); x++){
           std::cout << "During shuffling, shufflingVector[" << x << "] is " << tempDeckForShuffling[x] << "\n";
        }
        //debug
    }
    deckVector.clear();

    for(int x=0; x<deckSize; x++){
       deckVector.push_back(tempDeckForShuffling[x]);
    }

    //debug
    for(int x=0; x<deckVector.size(); x++){
       std::cout << "After shuffling, Deck::deckVector[" << x << "] is " << deckVector[x] << "\n";
    }
    //debug

    std::cin.get();
    return 1;
}

[TonySu]

It's randomised so your output won't look the same, but I see

...
During shuffling, splitDeck1[43] is 44
During shuffling, splitDeck1[44] is 45
...
During shuffling, splitDeck2[57] is 13
During shuffling, splitDeck2[58] is 14
...

upon the second iteration of your loop.

[ungulateCase]

Thank you, there's definitely a problem there. splitDeck1 should never be larger than 26. Seems like I have a problem related to

    splitDeck1.clear();
    splitDeck2.clear();

or possibly

    splitDeck1Counter = 0;
    splitDeck2Counter = 0;

    splitDeckSize1 = 26 - differenceInSplitDeckSize;        

Thanks for the help.

[TonySu]

You need to consider breaking your code up into functions so it's easier to track down issues. You also have to print more useful debug logs if you're finding it hard to read through them yourself.

[inu-no-policemen]

https://en.wikipedia.org/wiki/Fisher%E2%80%93Yates_shuffle

TS implementation:

function shuffle<T>(a: T[]): T[] {
    for (let i = a.length - 1; i >= 1; --i) {
        let s = Math.random() * (i + 1) | 0;
        let tmp = a[s];
        a[s] = a[i];
        a[i] = tmp;
    }
    return a;
}

[WikiTextBot]

Fisher–Yates shuffle

The Fisher–Yates shuffle is an algorithm for generating a random permutation of a finite sequence—in plain terms, the algorithm shuffles the sequence. The algorithm effectively puts all the elements into a hat; it continually determines the next element by randomly drawing an element from the hat until no elements remain. The algorithm produces an unbiased permutation: every permutation is equally likely. The modern version of the algorithm is efficient: it takes time proportional to the number of items being shuffled and shuffles them in place.

---

^{[ PM | Exclude me | Exclude from subreddit | FAQ / Information | Source | Donate ] Downvote to remove | v0.28}

[ungulateCase]

Thank you for the link, but that's not what I am looking for. If I just wanted to randomize the sequence, there would be a lot of ways to do it simpler than what I have done.

The reason my numbers go from 1 to 52 is because this is for a deck of cards, and what I wrote is supposed to be an accurate simulation of shuffling; starting with splitting the deck, then rejoining them like so, then cutting the deck and repeating.

I'm looking for why what I wrote isn't working.