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

/*
 * Function to count the total number of characters in all the command-line input arguments to main (excluding the program name)
 */

unsigned int count_chars_in_args(int argc, char *argv[])
{
	unsigned int i;
	unsigned int count = 0;
	for(i = 1; i < argc; i++) {
		count += strlen(argv[i]);
	}
	return count;
}

/*
 * Function to convert endian representation. Input is converted from bigendian to little endian, and vice-versa.
 */
unsigned int endian_convert(unsigned int num)
{
	unsigned int res;
	unsigned char *cn = (unsigned char *)&num;
	unsigned char *cres = (unsigned char *)&res;
	/* Simply reverse the byte order */
	cres[0] = cn[3];
	cres[1] = cn[2];
	cres[2] = cn[1];
	cres[3] = cn[0];

	return res;
}

/* Function to reverse a string by creating a new string */
char *reverse_new_str(char *str)
{
	if(str == NULL) return str;

	/* Allocate 1 extra byte for the null character */
	char *res = (char *) malloc (strlen(str) + 1);

	int i, j;

	/* Copy in reverse order */
	for(i = strlen(str) - 1, j = 0; i >= 0; i--, j++) {
		res[j] = str[i];
	}

	/* Finally set the null byte */
	res[j] = '\0';

	return res;
}

/* Allocate a 2-D array where row[i] contains col[i] number of columns */
void *my_2d_alloc(int rows, int *col)
{
	/* First allocate rows */
	int **ret = (int **) malloc (rows * sizeof(int *));
	int i;

	/* For each row, number of columns is given by col[i]. Allocate those many ints */
	for (i = 0; i < rows; i++) {
		ret[i] = (int *) malloc (sizeof(int) * col[i]);
	}
	return ret;
}

/* Function to replace repeated consecutive characters by a single instance of the character. E.g., aaaabbbcabba becomes abcaba */
char *deduplicate_in_place(char *str)
{
	unsigned int i, j;
	i = j = 0;
        char prev = '\0';
	while(str[i] != '\0') {
		/* If the current char is not the same as previous char, retain it, else skip it */
		if(str[i] != prev) {
			str[j++] = str[i];
			prev = str[i];
		}
		i++;
	}
	str[j] = '\0';
	return str;
}

/* Function to compute the cumulative sum of all characters in a string */
unsigned int str_weight(char *str)
{
	unsigned int weight = 0;
	unsigned int i = 0;
	while(str[i] != '\0') {
		/* Treat each char as an integer and accumulate its ascii value */
		weight += str[i];
		i++;
	}
	return weight;
}

/* Given two integer arrays in1, in2, and an array of characters op, all of equal length (len), return an array of same length where ret[i] = in1[i] oper[i] in2[i]. op is either '+', '-', '*' or '/'. Guaranteed no overflow. No divide by zero. */
int *array_op(int *in1, char *op, int *in2, unsigned int len)
{
	int *ret = (int *) malloc (len * sizeof(int));
	unsigned int i = 0;
	for(i = 0; i < len; i++) {
		switch(op[i]) {
			case '+': ret[i] = in1[i] + in2[i]; break;
			case '-': ret[i] = in1[i] - in2[i]; break;
			case '*': ret[i] = in1[i] * in2[i]; break;
			case '/': ret[i] = in1[i] / in2[i]; break;
			default : printf("unsupported\n"); break;
		}
	}
	return ret;
}

/* Given a number and a bit pattern of length len <= 8, find the index in num where that pattern appears, -1 otherwise.*/
/* MASK(2) is 000...0011, MASK(3) is 000...0111, and so on. */
#define MASK(len)	((1UL << (len)) - 1)
int bit_hunt(unsigned long num, unsigned char pattern, unsigned int len)
{
	unsigned int i;
	/* We store cast it to long so we don't lose data when we shift */
	unsigned long temp = (unsigned long) pattern;

	/* Transform 0000....0111 to 1110....0000.
	 * Now, when we & it with a num, we extract the most significant len number of bits from the num */
        unsigned long mask = MASK(len) << (64 - len);

	for(i = 0; i < 64; i++) {
		/* Check if the len number of most significant bits are the same as pattern, if so, we have found a match.
		 * If not, we shift the number left to push the most significant bit out and compare the pattern with len number of
		 * bits starting from the next location.
		 */
		if( ((num << i) & mask) == (temp << (64-len)) ) {
			return i;
		}
	}

	/* If we don't find it, return -1 */
	return -1;
}


/* Given a number return 1 if it is a fibonacci number, else 0 */
unsigned int is_fibo(unsigned long num)
{
	unsigned long t0 = 0, t1 = 1, fibo;
	while(t1 >= t0) { /* Overflow will violate this condition, which is when we know the number is not fibonacci number */
		fibo = t0 + t1;
		if(fibo == num) return 1;
		t0 = t1;
		t1 = fibo;
	}

	return 0;
}

/* Write a function that accepts a number 'x' and a number 'terms' and returns the sin of the number 'x' upto 'terms' number of terms in the infinite series for sin(x). You will be provided the infinite series. */
double my_sin1(double x, unsigned int terms);

/* Write a function that accepts a number 'x' and a number 'delta' and returns the sin of the number 'x' accurate within 'delta' using the infinite series for sin(x). You will be provided the infinite series. You will also be allowed to use sin function from the math library to compute accuracy. */
double my_sin2(double x, unsigned int terms);

/* Given a string and indices i1 and i2, perform an in-place swap of characters at i1 and i2 in the string */
void char_swap(char *str, int i1, int i2)
{
	char t = str[i1];
	str[i1] = str[i2];
	str[i2] = t;
}

/* Declare a structure that contains an integer i, float f and char c. Write a function struct_array_alloc that accepts an integer n and allocates memory for an array of n structures using malloc (or any other malloc family of functions) */
struct s {
	char c;
	int i;
	float f;
};

struct s *struct_array_alloc(unsigned int n) {
	struct s *ret = (struct s*) malloc (n * sizeof(struct s));
	return ret;
}

/* Write a function paritize that accepts and returns an unsigned long number where the return number is the same as the input number except that the most significant bit of the return number is set to 1 if the number of 1s in the remaining bits is even, and 0 otherwise */
unsigned long paritize(unsigned long num)
{
	unsigned long ret = num;
	unsigned int count = 0;
	unsigned int i = 0;

	/* First, count the number of 1's in the lower 63 bits. */
	for(i = 0; i < 8 * sizeof(num) - 1; i++) {
		if(num & (1UL << i)) count ++;
	}

	/* If the count is even, set the 64th bit to 1, if not set it to 0 */
	if(count % 2 == 0) {
		ret |= (1UL << (8*sizeof(num) - 1));
	} else {
		ret &= ~(1UL << (8*sizeof(num) - 1));
	}
	return ret;
}

void print_in_binary(unsigned long n)
{
	int i;
	for(i = 63; i >= 0; i--) {
		if( (1UL << i) & n ) {
			printf("1 ");
		} else {
			printf("0 ");
		}
	}
	printf("\n");
}


int main(int argc, char *argv[]) {
	printf("count_chars_in_args: %u\n", count_chars_in_args(argc, argv));
	printf("endian_convert: %x -> %x\n", 0xdeadbeef, endian_convert(0xdeadbeef));

	char *res = reverse_new_str("Helloooo Worrrrlddd, how   are you?");
	printf("reverse_new_str: %s\n", res);
	printf("deduplicate_in_place: %s\n", deduplicate_in_place(res));
	printf("str_weight: %u\n", str_weight(res));

	int in1[] = {1, 2, 3, 4};
	int in2[] = {5, 7, 2, 1};
	char op[]  = {'+', '-', '*', '/'};
	int *ret = array_op(in1, op, in2, sizeof(in1)/sizeof(in1[0]));
	int i;
	for(i = 0; i < sizeof(in1)/sizeof(in1[0]); i++) {
		printf("array_op[%d]: %d\n", i, ret[i]);
	}
	free(ret);

	printf("bit_hunt: %x:%x:%u -> %d\n",0x10070ab,0x15, 5, bit_hunt(0x10070ab, 0x15, 5));
	printf("bit_hunt: %x:%x:%u -> %d\n",0xFFFFFFFF,0x5, 3, bit_hunt(0xFFFFFFFF, 0x5, 3));
	printf("bit_hunt: %x:%x:%u -> %d\n",0,0x5, 3, bit_hunt(0, 0x5, 3));
	printf("bit_hunt: %x:%x:%u -> %d\n",0xB,0x5, 3, bit_hunt(0xB, 0x5, 3));
	printf("is_fibo: 9: %u, 8: %u\n", is_fibo(9), is_fibo(8));
	char_swap(res, 4, 0);
	printf("char_swap: res, 4, 0: %s\n", res);
	printf("paritize: %lx -> %lx, %lx -> %lx\n", 0x2, paritize(0x2), 0x3, paritize(0x3));

	return 0;
}