# include <stdio.h>
# include <stdlib.h>
# include <time.h>

int main() {
	int a,b,c,x,y,z;
	/*set values for array (characters)*/
	char ALPHA[26] = {
		  'A','B','C','D','E',
		  'F','G','H','I','J',
		  'K','L','M','N','O',
		  'P','Q','R','S','T',
		  'U','V','W','X','Y',
		  'Z' 
		  };
	
	FILE *fp;
	
	long g;	

	
	//clrscr();
	
	fp = fopen("gen2_1T.txt","w"); /*Will create and write Generator text file for 100,000 plate numbers to gen2_1T.txt flename*/
	
	srand(time(NULL));
	
	for (g=0;g<=99999;g++)
	{
		a=rand()%26;
		b=rand()%26;
		c=rand()%26;
		x=rand()%10;
		y=rand()%10;
		z=rand()%10;
		
		fprintf(fp,"%c%c%c%d%d%d\n",ALPHA[a],ALPHA[b],ALPHA[c],x,y,z);
	
	}
	
	fclose(fp);
	
	
	fp = fopen("gen2_1M.txt","w"); /*Will create and write Generator text file for 1,000,000 plate numbers to gen2_1M.txt flename */
	
	srand(time(NULL));
	
	for (g=0;g<=999999;g++)
	{
		a=rand()%26;
		b=rand()%26;
		c=rand()%26;
		x=rand()%10;
		y=rand()%10;
		z=rand()%10;
		
		fprintf(fp,"%c%c%c%d%d%d\n",ALPHA[a],ALPHA[b],ALPHA[c],x,y,z);
	
	}
	
	fclose(fp);
	
	fp = fopen("gen2_17M.txt","w");/*Will create and write Generator text file for 17,000,000 plate numbers to gen2_17M.txt flename */
	
	srand(time(NULL));
	
	for (g=0;g<17000000;g++)
	{
		a=rand()%26;
		b=rand()%26;
		c=rand()%26;
		x=rand()%10;
		y=rand()%10;
		z=rand()%10;	
		fprintf(fp,"%c%c%c%d%d%d\n",ALPHA[a],ALPHA[b],ALPHA[c],x,y,z);
	}
	fclose(fp);
	printf("done");
	getch();
	return 0;
}

#!/usr/local/bin/perl

use strict;
use warnings;

# Three base-26 digits (otherwise known as letters of the alphabet).
sub BASE26_MAX { 26 ** 3 }
# Three base-10 digits.
sub BASE10_MAX { 10 ** 3 }

# Take a number that is a 3-digit base-10 number, with a 3-digit base-26 number tacked on, and
# print it in a human readable fashion.
sub licEncToStr {
    my $n = shift;          # Input argument.
    my $v = $n % 1000;      # Get 3 trailing digits.
    my $w = int($n / 1000); # Get 3 alpha characters.

    # Get it in string format.
    return chr((($w / (26*26)) % 26) + 65) .
           chr((($w / 26) % 26) + 65) .
           chr(($w % 26) + 65) .
           sprintf("%03d", $v);
}

# Create a license generator.
sub createLicNoGen {
    my $used = { };

    return sub {
        my $r = int(rand() * BASE26_MAX()) * 1000 + int(rand() * BASE10_MAX());
        while(defined($used->{$r})) {
            $r = int(rand() * BASE26_MAX()) * 1000 + int(rand() * BASE10_MAX());
        }
        $used->{$r} = 1;
        return $r;
    };
}


# Generate 100000 pseudo-random license plate numbers

my $gen = createLicNoGen();
for(0..99999) {
    print "@{[licEncToStr($gen->())]}\n";
}

addToFile(fileName, getNewPlate());
for(i=1; i<plateCount; i++) {
	plate = getNewPlate();
	while(isInFile(fileName, plate)) {
		plate = getNewPlate();
	}
	addToFile(fileName, plate);
}

#define DIGIT_SIZE 1000

typedef struct AlphaType {
	char txt[4];
	struct AlphaType *next;
} AlphaType;

void makeFile(char *fileName, int plateCount) {
	int i, digits;
	AlphaType *history[DIGIT_SIZE];
	AlphaType *item;
	FILE *pFile;
	
	pFile = fopen(fileName, "w");
	
	for(i=0; i<DIGIT_SIZE; i++) { history[i] = NULL; }
	
	srand(time(NULL));
	
	for(i=0; i<plateCount; i++) {
		item = NULL;
		while (item==NULL) {
			digits = rand()%DIGIT_SIZE;
			item = addToHistory(history, digits, getAlphaText());
		}
		fprintf(pFile, "%s%03d\n", item->txt, digits);
	}
	
	freeHistory(history);
	fclose(pFile);
}

	alphas = 5119; digits = 719;
	do {
        convert_alpha(letters, alphas);	
		convert_digit(numbers, digits);
		printf("%s-%s\t%d\t%d\n", letters, numbers, alphas, digits);
		alphas = (alphas + 5119) % 17576;
		digits = (digits + 719) % 1000;
	} while (alphas != 5119 || digits != 719);

#define PLATE_SIZE 7

typedef struct NodeType {
	char plate[PLATE_SIZE];
	struct NodeType *left;
	struct NodeType *right;
} NodeType;

int isAddToList(NodeType *list, char *plate, int size) {
	NodeType *node, **next;
	int cmp;
	
	node = list;
	while (node!=NULL) {
		cmp = strcmp(plate, node->plate);
		if (cmp==0) { return 0; }
		next = (cmp<0) ? &node->left : &node->right;
		if (*next==NULL) {
			*next = addToList(list, plate, size);
			return 1;
		} else {
			node = *next;
		}
	}
	// we should never ever get here! 
	return 0;
}


void makeFile(char *fileName, int plateCount) {
	int i;
	NodeType *list;
	
	list = (NodeType *) calloc(plateCount + 1,sizeof(NodeType));
	
	srand(time(NULL));
	
	addToList(list, getRandPlate(), 0);
	for(i=1; i<plateCount; i++) {
		while (!isAddToList(list, getRandPlate(), i));
	}
	
	dumpList(list, fileName);
	free(list);
}

#include <stdio.h>
#include <stdlib.h>
#include <time.h>

#define NUM_ALPHA 26
#define NUM_DIGIT 10

#define ALPHA_STEP 7639 
#define DIGIT_STEP 277 


void scramble(char *array, int length, int iterations);

//These are made global for convience but should be considered
//  to be constant after they have been scampled.
char Alpha1[26] = {
	'A','B','C','D','E',
	'F','G','H','I','J',
	'K','L','M','N','O',
	'P','Q','R','S','T',
	'U','V','W','X','Y',
	'Z' 
};
char Alpha2[26] = {
	'A','B','C','D','E',
	'F','G','H','I','J',
	'K','L','M','N','O',
	'P','Q','R','S','T',
	'U','V','W','X','Y',
	'Z' 
};
char Alpha3[26] = {
	'A','B','C','D','E',
	'F','G','H','I','J',
	'K','L','M','N','O',
	'P','Q','R','S','T',
	'U','V','W','X','Y',
	'Z' 
};
char Digit1[10] = {
	'0','1','2','3','4',
	'5','6','7','8','9'
};
char Digit2[10] = {
	'0','1','2','3','4',
	'5','6','7','8','9'
};
char Digit3[10] = {
	'0','1','2','3','4',
	'5','6','7','8','9'
};


//Rather than using a 2D array we can use the preprocessor to concatinate symbols
//This macro produces the line:
//    scramble(Alpha1, 26, 260);
#define SCRAMBLE_ALPHA(num) scramble(Alpha ## num, NUM_ALPHA, NUM_ALPHA * 10)
#define SCRAMBLE_DIGIT(num) scramble(Digit ## num, NUM_DIGIT, NUM_DIGIT * 10)

void convert_alpha(char str[4], int number);
void convert_digit(char str[4], int number);


int main() {
	int alphas, digits;
	char letters[4], numbers[4];
	srand(time(NULL));
	//Scramble the numbers and digits...
//	SCRAMBLE_ALPHA(1);
	SCRAMBLE_ALPHA(2);
	SCRAMBLE_ALPHA(3);
	SCRAMBLE_DIGIT(1);
	SCRAMBLE_DIGIT(2);
	SCRAMBLE_DIGIT(3);


//	for (alphas = 0; alphas < 26*26*26; alphas++) {
//        convert_alpha(letters, alphas);	
//		for (digits = 0; digits < 1000; digits++) {
//			convert_digit(numbers, digits);
//			printf("%s-%s \n", letters, numbers);
//		}
//	}
	alphas = ALPHA_STEP; digits = DIGIT_STEP;
	do {
        convert_alpha(letters, alphas);	
		convert_digit(numbers, digits);
		printf("%s-%s\t%d\t%d\n", letters, numbers, alphas, digits);
		alphas = (alphas + ALPHA_STEP) % 17576;
		digits = (digits + DIGIT_STEP) % 1000;
	} while (alphas != ALPHA_STEP || digits != DIGIT_STEP);
	    
 	   
	
	getchar();	
	return 0;
	

}

void scramble(char *array, int length, int iterations) {
	int a, b, i;
	char temp;
	for (i = 0; i < iterations; ++i) {
		a = rand() % length;
		b = rand() % length;
		temp = array[a];
		array[a] = array[b];
		array[b] = temp;
    }
    return;
}

void convert_alpha(char str[4], int number) {
	 str[2] = Alpha1[(number % NUM_ALPHA)];
	 number /= NUM_ALPHA;
	 str[1] = Alpha2[(number % NUM_ALPHA)];
	 number /= NUM_ALPHA;
	 str[0] = Alpha3[(number % NUM_ALPHA)];
	 str[3] = 0;
	 return;
}

void convert_digit(char str[4], int number) {
	 str[2] = Digit1[(number % NUM_DIGIT)];
	 number /= NUM_DIGIT;
	 str[1] = Digit2[(number % NUM_DIGIT)];
	 number /= NUM_DIGIT;
	 str[0] = Digit3[(number % NUM_DIGIT)];
	 str[3] = 0;
	 return;
}

#include <iostream>
#include <string>
#include <bitset>
#include <cstdlib>

static const int BASE26_MAX = 26 * 26 * 26;
static const int BASE10_MAX = 10 * 10 * 10;

void licEncToStr(int n, char* ret, int len)
{
    int v = n % 1000;
    int w = n / 1000;

    snprintf(ret, 
             len, 
             "%c%c%c%03d", 
             ((w / (26*26)) % 26) + 65,
             ((w /     26 ) % 26) + 65,
             ((w          ) % 26) + 65,
             v);
}

class licNoGen
{
    public:
        licNoGen() : usefunc(true) { }
        int gen() {
            int r;
            int collisions = 0;

            if(usefunc) {
                r = (std::rand() % BASE26_MAX) * 1000 + (std::rand() % BASE10_MAX);
            }
            else {
                r = lastr;
            }

            while(bs.test( r )) { r = (r + 10263217) % (BASE26_MAX * BASE10_MAX); collisions++; }
            bs.set( r );
            lastr = r;

            if(collisions > 500) { usefunc = false; }
            return r;
        }

    private:
        std::bitset<BASE26_MAX * BASE10_MAX> bs;
        bool usefunc;
        int lastr;
};

int main()
{
    licNoGen* gen = new licNoGen();

    std::srand(std::time(NULL));
    int count = BASE26_MAX * BASE10_MAX;
    char ret[7];
    ret[6] = 0;
    while(count--) {
        licEncToStr(gen->gen(), ret, sizeof(ret) / sizeof(ret[0]));
        std::cout << ret << "\n";
    }

    delete gen;
    
    return 0;
}

    for (int i = 1; i<= 26; i++)
    {
              for (int j=1; j<=26; j++)
              {
              
               for(int x = 1; x<=26; x++)
                      {
                       cout<<j<<", "<<i<<", "<<x<<endl; 
                      }
               }
            cout<<endl;
    }