# include <iostream>
// #include <string> 
// #include <cmath>
// #include <cstdlib>
// #include <iomanip>
// #include <fstream>
// #include <vector>
using namespace std;
#define NN 1000
const int MAXHASH = 100000;


//selection sort, but record indices
int* sortindices (int* X , int size){
	int t,j;
	int * ret = new int[size];
	int * busy = new int[size]; 
	
	for ( t=0; t<size; t++) 
		busy[t]=0;
	
	int minval, minval_index;
	for ( t=0; t<size; t++){
		minval=99999999999;
		minval_index=-1;
		j=0; while (j<size){ 
			while(busy[j]==1) 
				j++; 
			if (j>=size) break;
			if (X[j]<minval) {
				minval=X[j]; minval_index=j; 
			}
			j++;
		}
		busy[minval_index]=1;
		ret[t]=minval_index;
		cout <<"    sortindices "<<t<<"   minval_index="<<minval_index<<"  val="<<minval<<endl;
	}
	delete [] busy;
	return ret;
}

//a simple hash function from words to integers (0, MAXHASH)
int myhash_function(char s[]){
	int sum=0,i=0,v;
//	cout<<"\n hash("<<s<<"):\n";
	while(s[i]>0){
		i++;
		v = s[i] * i*i;
		sum += v;
//		cout << "        "<< i <<"  "<< s[i-1]<<"  "<<v<<"   "<< sum<< endl;
	}
	int sumret  = sum % MAXHASH;
//	cout <<sum<<" % "<< MAXHASH << " = "<<sumret <<endl<<endl;
	return sumret;
}



///////////////////////////////////////////////////////
int* square(int *ptr)  {
	int *new_ptr = new int; // dynamically created int variable
	*new_ptr = (*ptr) * (*ptr);
//	(*ptr)++;
	return new_ptr; // valid return because this variable/location was created dynamically
	// int ret = (*ptr) * (*ptr);
	// 
	//  
	// return ret;
}
///////////////////////////////////////////////////
int main(){

 
// POINTERS
	int num1 = 10, num2 = 20;
	int *ptr;  // pointer to reference an int variable
	ptr = &num1;  // address operator is used to assign the address of num1 to ptr	
	cout << "The value of num1 is " << *ptr << endl;  // indirection operator used
	cout << "The location of num1 is " << &num1 << endl;
//	return 0;

	ptr = &num2;  // reassign the address of num2 to ptr
	cout << "The value of num2 is " << *ptr << endl;
	cout << "The location of num2 is " << ptr << endl;

	*ptr = 100; // num2 = 100
	cout << "Now the value of num2 is " << num2 << endl;

	*ptr += 100; // num2 += 100
	cout << "Now the value of num2 is " << *ptr << endl;
//return 0;


//ARRAYS and POINTER ARITHMETIC
	int ar[10] = {0,65+98*256,100,-3,6,15,6,0,2,9};
	int *arp = &ar[0 ]; // same as *arp=ar;
	// address of array elements
	for(int i = 0; i < 10; i++) 
		cout <<i << " Location="<< arp + i << " = "<< &ar[i] << "   value= " << ar[i] << " = "<<*(arp+i)<< endl;
//return 0;	
	

	cout<<" (arp+2)[5]="<<(arp+2)[5]<<endl;	
	cout<<"\n\n ((short)arp+2)[2]="<<((short*)arp+2)[2]<<endl;

//return 0;
	cout<<"\n\n *((char)arp+4)="<<*((char*)arp+4)<<endl;
	cout<<"\n\n *((char)arp+5)="<<((char*)arp)[5]<<endl;

//return 0;







//POINTER COMPARISON
	cout<< "\n\n POINTER COMPARISON\n"; 
	if(&(ar[0]) < &(ar[4]))
		cout << "address of the 5th element("<<&ar[4]<<") is larger than the address of the 1st("<<&ar[0]<<")" << endl;
	else
		cout << "address of the 1st element("<<&ar[0]<<") is larger than the address of the 5th("<<&ar[5]<<")" << endl;
		
//
	int var=17,var2=20;
	int* const pt=&var;
	*pt=100;	
//	pt = &var2;	//error
	cout <<"\n\n what I stored ="<<*pt<<endl;
//	return 0;


//ARRAY of POINTERS - where is memory allocated?
	cout<< "\n\n\n\n\n\n ARRAY OF POINTERS\n";	
	char * mywords[3];
	char w0[]="nuclear "; mywords[0]=w0;
//	cout<<"w0= "<<(void*)w0<<endl; 	return 0;
	char w1[]="nonproliferation ";	mywords[1]=w1;
	char w2[]="treaty"; mywords[2]=w2;	
	cout<<" my 3 words: "<<mywords[0]<<mywords[1]<<mywords[2]<<endl<<endl;
	cout<<endl<<"what is mywords[0]? :"<<mywords[0];	
	cout<<endl<<"\nwhat is trully mywords[0]? :"<<(void*)mywords[0];	

//return 0;

	
	int * P[3];
	int a=10, b=5, c=7;
	P[0]=&a; P[1]=&c; P[2]=&b; 
	cout<<"\n\n my array of pointers to numbers\n "<<P<<" "<< P[0]<<"    "<<*P[0] <<endl;
	cout<<P+1<<" "<<P[1]<<"    "<< **(P+1)<<endl;
	cout<<P+2<<" " <<P[2]<<"    "<<*P[2]<<" = "<<**(P+2)<<endl;
	
//return 0;
//////////////////////////////////////////////////////////////////////////////////////////
// TYPE CASTING,  LITTLE ENDIAN

	char C[]="abcd";
	char *p = C;
	cout<<"\n\nMORE TYPE CASTING\n"<< "p[0]="<<p[0]<< " p[1]="<<p[1]<< " p[2]="<<p[2]<< " p[3]="<<p[3]<<endl;
	cout<<"p="<<p<<endl;
	cout<<"*(short*)p="<<*(short*)p<<endl;
	cout<<"*((short*)p + 1)="<<*((short*)p + 1)<<endl;
	cout<<"*(short*)(p+1) ="<<*(short*)(p+1)<<endl;
	
//return 0;	
		
		
//   functions and pointers ///////////
	// int num;
	// cout << "\n\n POINTER PARAMETER\nEnter an integer: ";
	// cin >> num;
	// int* sqn= square(&num);  // function call
	// cout << "The square is " << sqn <<" ; input  number is "<<num<< endl;	
	// delete sqn;
	// return 0;	
	
		
////// Dynamic Memory Alloation ///////////////////////////////////////////////////
	int  *new_ptr;
	int size = 3; // array size initially 3
	char ans;
	int n;
	int count = 0;  // how many integers currently
	ptr = new int[size];  // dynamic memory allocation
	cout<<"\n\n DYNAMIC MEMORY ALLOCATION (new, delete)\n";
	while(1)  {
		cout << "is there another number? (-999 to exit)>> ";
	//	cin >> n;  // store the new number
		 n=-999;
		if(n == -999) break;
		cout << "what is the number?";
		ptr[count]=n;  // store the new number

		count++;  // increment the count
		
		if(count >= size)  {  // no more space left
			size += 5;  // increase the size
			new_ptr = new int[size];  // get a bigger array dynamically
			cout<<"     array re-allocated with size="<<size<<";";
			for(int i = 0; i < count; i++)
				new_ptr[i] = ptr[i];  // copy the existing integers to the new array
			delete [] ptr;  // free the space occupied by the old array
			ptr = new_ptr;  // reassign array pointer
		}
		cout << "  array adress="<<ptr<<endl;
	}
	// print out the stored numbers
	cout << "The numbers entered are:" << endl;
	for(int i = 0; i < count; i++)
		cout << ptr[i] << endl;
//	return 0;

// mallaoc, calloc and free
 	int * buffer = (int*) calloc (100,sizeof(int)); //allocates 100 integers
	buffer[0] = 10; buffer[99]=-181; buffer[12]=25;
	cout << endl << endl; 
	for (int i=0; i<100; i++) cout << buffer[i]<< " ";
	free(buffer);
	buffer[1]=7; // WRONG - writes where ?
//return 0;

	
//	return 0;
	
// 	BIT OPERATIONS - for LAB 6 	
	int t; 
	var=353;
	cout<<"\n\n BITS OF REPRESENTATION USING %\n"<<var<<" : ";
	int vn =var;
	// shifting variale 32 times	
	for (int i=1; i<=32; i++){
		t = var %2;
		cout<<t;
		var=var>>1;
	}
	cout<<endl;
	

	cout<<"first byte: "<<  (int)*((char*)&vn)  <<endl;
	cout<<"second byte: "<<(int) *( ((char*)&vn)+1)<<endl;
	cout<<"third byte: "<<(int)  *( ((char*)&vn)+2)<<endl;
	cout<<"fourth byte: "<<(int)*((char*)&vn+3)<<endl;
//return 0; 

// checking for the 2^power bit	with a mask
	var=353;
	cout<<"\n USING BITWISE &\n"<<var<<" : ";
	unsigned int t2=1;	
	for (int i=1; i<=32; i++){
		t = var & t2;
		if (t>0) cout<<1; else cout<<0;
		t2 = t2<<1; 
	}
//return 0;
	
	
	var=72; cout<<"\n\n SHIFTING, BITWISE OR/AND\n "<<var<<":";
	for (int i=1; i<=32; i++){
		t = var %2;
		cout<<t;
		var=var>>1;
	}	
	var=184; cout<<"\n"<<var<<":";
	for (int i=1; i<=32; i++){
		t = var %2;
		cout<<t;
		var=var>>1;
	}
	cout << "\n\n72 & 184 ="<<(72&184)<<endl;
	cout << "72 | 184 ="<<(72|184)<<endl<<endl;	
//return 0;	

	char stringbits[]="11010100";
	unsigned int nv=0; 
	cout <<"\n\n USING BITWISE OR:\n nv="<<nv<<endl;
	nv=nv | 1; cout <<"after OR with 1 nv="<< nv<<endl;
	nv=nv | 2; cout <<"after OR with 2 nv="<<  nv<<endl;
	nv=nv | 8; cout <<"after OR with 8 nv="<<  nv<<endl;
	nv=nv | 32; cout <<"after OR with 32 nv="<<  nv<<endl;
	
	

//return 0;
	

	
	
	
	
	
	
	
	
	
	
	
	
//////////////////// HASHING  //////////////////////////////////////	
// sorting indices
	cout<<"\n\n SORT INDICES:\n";
	int test [10] = {4, 7, -1, 4, 8, 2, 7, 13, 8, 4};
	int* sorted_ind = sortindices (test, 10);
	for (int t=0; t<10; t++) 
		cout << t <<"  "<<test[t]<<"        "<<sorted_ind[t]<<"  "<<test[sorted_ind[t]]<<endl;
//return 0;

	char ch[]= "Wonderland";
	int h = myhash_function(ch);
	cout <<" word="<<ch<<"  hash="<<h;
//	return 0;
// experient: hashing with random words	
	int word_size; //NN is defined 10000
	char* EXPTEXT[NN];
	int   EXPHASH[NN];
	for (int t=0;t<NN; t++){
		//generate a random word
		word_size=  rand() % 13+2;
		char* word = new char[word_size];
		for (int i=0; i<word_size; i++) {word[i]=rand()%26 + 97;}
		EXPTEXT[t] = word;
		EXPHASH[t] = myhash_function(word);
	//	cout <<word_size<<"  "<< word <<"  "<< EXPHASH[t] << endl;
	}
//	return 0;
	
	cout <<endl;
	int * sEXP = sortindices ( EXPHASH, NN);
	int prev_value=-1;
	int ind;
	for (int t=0; t<NN; t++) {
		ind = sEXP[t]; 
		cout<< EXPTEXT[ind]<<"   "<< EXPHASH[ind];
		if (prev_value==EXPHASH[ind]) cout<< "   collision";
		cout <<endl;
		prev_value=EXPHASH[ind];
	}	
	
	return 0;	


	
	
	cout<<"\n";

		

		
}