#include<stdio.h>
#include<stdio.h>
int max, min;
int a[100];
void maxmin(int i, int j)
{
 int max1, min1, mid;
 if(i==j)
 {
  max = min = a[i];
 }
 else
 {
  if(i == j-1)
  {
   if(a[i] <a[j])
   {
    max = a[j];
    min = a[i];
   }
   else
   {
    max = a[i];
    min = a[j];
   }
  }
  else
  {
   mid = (i+j)/2;
   maxmin(i, mid);
   max1 = max; min1 = min;
   maxmin(mid+1, j);
   if(max <max1)
    max = max1;
   if(min > min1)
    min = min1;
  }
 }
}
int main ()
{
 int i, num;
 printf ("\nEnter the total number of numbers : ");
 scanf ("%d",&num);
 printf ("Enter the numbers : \n");
 for (i=1;i<=num;i++)
  scanf ("%d",&a[i]);

 max = a[0];
 min = a[0];
 maxmin(1, num);
 printf ("Minimum element in an array : %d\n", min);
 printf ("Maximum element in an array : %d\n", max);
 return 0;
}

#include <stdio.h>
int binary_search(int arr[],int l,int h,int key)

    {
	if(l<=h){
    int mid=(l+h)/2;
    if(arr[mid]==key)
        return mid;
    if(arr[mid]>key){
    return binary_search(arr,l,mid-1,key);
    return binary_search(arr,mid+1,h,key);
}

}
return -1;
}
int  bubblesort(int arr[],int n)
    {
	int i,j,temp;
    for(i=0;i<n-1;i++){
        for(j=0;j<n-i-1;j++){
            if(arr[j]>arr[j+1]){
                temp=arr[j];
                arr[j]=arr[j+1];
                arr[j+1]=temp;
                
            }
        }
    }
        return temp;
    }
void printarr(int arr[],int n){
    int i;
    for(i=0;i<n;i++){
        printf("%d",arr[i]);
    }
} 
int main(){
	int n,i,arr[7],key;
    printf("enter the element size\n");
    scanf("%d",&n);
    printf("enter the element you want to sort\n");
    for(i=0;i<n;i++){
        scanf("%d\n",&arr[i]);
    }
    bubblesort(arr,n);
    printarr(arr,n);
    
    printf("\nEnter the element you want to search");
    scanf("%d",&key);
    int result=binary_search(arr,0,n-1,key);
    if (result==-1){
    printf("element not found");
    return 0;
    }
    printf("element found at %d position",result);
return 0;
}

#include <stdio.h>

#define MAX 100

typedef struct Job {
  char id[5];
  int deadline;
  int profit;
} Job;

void jobSequencingWithDeadline(Job jobs[], int n);

int minValue(int x, int y) {
  if(x < y) return x;
  return y;
}

int main(void) {
  //variables
  int i, j;

  //jobs with deadline and profit
  Job jobs[5] = {
    {"j1", 2,  60},
    {"j2", 1, 100},
    {"j3", 3,  20},
    {"j4", 2,  40},
    {"j5", 1,  20},
  };

  //temp
  Job temp;

  //number of jobs
  int n = 5;

  //sort the jobs profit wise in descending order
  for(i = 1; i < n; i++) {
    for(j = 0; j < n - i; j++) {
      if(jobs[j+1].profit > jobs[j].profit) {
        temp = jobs[j+1];
        jobs[j+1] = jobs[j];
        jobs[j] = temp;
      }
    }
  }

  printf("%10s %10s %10s\n", "Job", "Deadline", "Profit");
  for(i = 0; i < n; i++) {
    printf("%10s %10i %10i\n", jobs[i].id, jobs[i].deadline, jobs[i].profit);
  }

  jobSequencingWithDeadline(jobs, n);

  return 0;
}

void jobSequencingWithDeadline(Job jobs[], int n) {
  //variables
  int i, j, k, maxprofit;

  //free time slots
  int timeslot[MAX];

  //filled time slots
  int filledTimeSlot = 0;

  //find max deadline value
  int dmax = 0;
  for(i = 0; i < n; i++) {
    if(jobs[i].deadline > dmax) {
      dmax = jobs[i].deadline;
    }
  }

  //free time slots initially set to -1 [-1 denotes EMPTY]
  for(i = 1; i <= dmax; i++) {
    timeslot[i] = -1;
  }

  printf("dmax: %d\n", dmax);

  for(i = 1; i <= n; i++) {
    k = minValue(dmax, jobs[i - 1].deadline);
    while(k >= 1) {
      if(timeslot[k] == -1) {
        timeslot[k] = i-1;
        filledTimeSlot++;
        break;
      }
      k--;
    }

    //if all time slots are filled then stop
    if(filledTimeSlot == dmax) {
      break;
    }
  }

  //required jobs
  printf("\nRequired Jobs: ");
  for(i = 1; i <= dmax; i++) {
    printf("%s", jobs[timeslot[i]].id);

    if(i < dmax) {
      printf(" --> ");
    }
  }

  //required profit
  maxprofit = 0;
  for(i = 1; i <= dmax; i++) {
    maxprofit += jobs[timeslot[i]].profit;
  }
  printf("\nMax Profit: %d\n", maxprofit);
}

# include<stdio.h>

void knapsack(int n, float weight[], float profit[], float capacity) {
   float x[20], tp = 0;
   int i, j, u;
   u = capacity;

   for (i = 0; i < n; i++)
      x[i] = 0.0;

   for (i = 0; i < n; i++) {
      if (weight[i] > u)
         break;
      else {
         x[i] = 1.0;
         tp = tp + profit[i];
         u = u - weight[i];
      }
   }

   if (i < n)
      x[i] = u / weight[i];

   tp = tp + (x[i] * profit[i]);

   printf("\nThe result vector is:- ");
   for (i = 0; i < n; i++)
      printf("%f\t", x[i]);

   printf("\nMaximum profit is:- %f", tp);

}

int main() {
   float weight[20], profit[20], capacity;
   int num, i, j;
   float ratio[20], temp;

   printf("\nEnter the no. of objects:- ");
   scanf("%d", &num);

   printf("\nEnter the wts and profits of each object:- ");
   for (i = 0; i < num; i++) {
      scanf("%f %f", &weight[i], &profit[i]);
   }

   printf("\nEnter the capacityacity of knapsack:- ");
   scanf("%f", &capacity);

   for (i = 0; i < num; i++) {
      ratio[i] = profit[i] / weight[i];
   }

   for (i = 0; i < num; i++) {
      for (j = i + 1; j < num; j++) {
         if (ratio[i] < ratio[j]) {
            temp = ratio[j];
            ratio[j] = ratio[i];
            ratio[i] = temp;

            temp = weight[j];
            weight[j] = weight[i];
            weight[i] = temp;

            temp = profit[j];
            profit[j] = profit[i];
            profit[i] = temp;
         }
      }
   }

   knapsack(num, weight, profit, capacity);
   return(0);
}

int num_liars = 0, num_liars_left = 0;
        for (int i = 0; i < n; i++) {
            if (claims[i] > 0) {  
                num_liars++; 
                num_liars_left += claims[i] - 1;  
            }
        }

        if (num_liars == 0) { 
            printf("0\n");
        } else if (num_liars > num_liars_left) { 
            printf("-1\n");
        } else {
            int num_truth_tellers = n - num_liars;  
            int num_liars_total = num_liars_left + (num_liars - num_truth_tellers);  
            printf("%d\n", num_liars_total/7);
        }
    }

    return 0;

#define max_size 10000
int stack[max_size];
int top = -1;

void push(char data) 
{
    if (top == max_size-1) 
    {
        printf("Stack Overflow\n");
        return;
    } 
    else 
    {
        stack[++top] = data;
    }
}

int isempty() 
{
    if (top <= -1) 
    {
        return 1;
    }
    return 0;
}

int pop() 
{
    if (isempty()) 
    {
        printf("Stack Underflow\n");
        return -1;
    }
    return stack[top--];
}

bool isValid(char * s)
{
    while(*s!='\0')
    {
        if(*s == '(' || *s == '{' || *s == '[')
        {
            push(*s);
        }
        else if(*s == ')' || *s == '}' || *s == ']')
        {
            if(isempty() || (*s == ')' && pop() != '(') || (*s == '}' && pop() != '{') || (*s == ']' && pop() != '['))
            {
                return 0;
            }
        }
        s++;
    }
    if(isempty())
    {
        return 1;
    }
    else
    {
        return 0;
    }
}#define max_size 10000
int stack[max_size];
int top = -1;

void push(char data) 
{
    if (top == max_size-1) 
    {
        printf("Stack Overflow\n");
        return;
    } 
    else 
    {
        stack[++top] = data;
    }
}

int isempty() 
{
    if (top <= -1) 
    {
        return 1;
    }
    return 0;
}

int pop() 
{
    if (isempty()) 
    {
        printf("Stack Underflow\n");
        return -1;
    }
    return stack[top--];
}

bool isValid(char * s)
{
    while(*s!='\0')
    {
        if(*s == '(' || *s == '{' || *s == '[')
        {
            push(*s);
        }
        else if(*s == ')' || *s == '}' || *s == ']')
        {
            if(isempty() || (*s == ')' && pop() != '(') || (*s == '}' && pop() != '{') || (*s == ']' && pop() != '['))
            {
                return 0;
            }
        }
        s++;
    }
    if(isempty())
    {
        return 1;
    }
    else
    {
        return 0;
    }
}

#include <stdio.h>

void print_number(int num)
{
    unsigned int number;

    if (num < 0)
    {
        number = -num;
        putchar('-');
    }
    else
    {
        number = num;
    }

    if (number / 10)
    {
        print_number(number / 10);
    }
    putchar('0' + (number % 10));
}

int main(void)
{
    int num = 1028;
    print_number(num);
    putchar('\n');
    return (0);
}

#include <stdio.h>
#include <stdarg.h>

//prototypes
void print_string(va_list arg);
void print_letter(va_list arg);
void print_integer(va_list arg);
void print_float(va_list arg);
void print_all(const char * const format, ...);

typedef struct print
{
    char *specifer;
    void(*print_func)(va_list arg);
}  print_t;

/**
 * main - check the code
 *
 * Return: Always 0.
 */

int main(void)
{
    print_all("ceis", 'A', 10, "Hello World");
    return(0);
}

/**
 * print_all- the function prints anything that is passed to the function
 * @format:the chareters that contains specifers
 *
 * Return: the function does not return anything
 */
void print_all(const char * const format, ...)
{
    int i , j, len;
    char *separator = "";
    va_list args;
    va_start(args, format);

    print_t functions[] = {
        {"c", print_letter},
        {"s", print_string},
        {"i", print_integer},
        {"f", print_float}
    };

    len = sizeof(functions) / sizeof(print_t);

    i = 0;

    //checking if format is null or if the current charater is null
    while(format && (*(format + i)))
    {
        j = 0;

        while(j < len && (*(format + i) != *(functions[j].specifer)))
        {
            j++;
        }
        if(j < len)
        {
            printf("%s",separator);
            functions[j].print_func(args);
            separator = ", ";
        }
        i++;
    }

    printf("\n");
    va_end(args);
}


//functions for printing different datatypes
void print_string(va_list arg)
{
    char *str;
    str = va_arg(arg, char*);

    printf("%s", str);
}

void print_letter(va_list arg)
{
    char str;
    str = va_arg(arg, int);

    printf("%c", str);
}

void print_integer(va_list arg)
{
    int num;
    num = va_arg(arg, int);

    printf("%d", num);
}

void print_float(va_list arg)
{
    float num;
    num = va_arg(arg, double);

    printf("%f", num);
}

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

//prototypes
int add(int , int);
int subtract(int, int);
int multiply(int, int);
int division(int, int);
int module(int,int);

//struct

/**
 * calculator: the struct creates the sign and the associated function
 * @sign the sign for calculation
 * @func: function pointer
 * Return: the function returns the result of the addition
*/
typedef struct calculator{
    char *sign;
    int (*func)(int, int);
} calc_t;

/**
 * main - the function gets commandline arguements and performs calculations on them
 * @argc: the number of commandline arguements
 * @argv: the array containing the arguements
 * 
 * Return: returns zero on success
*/

int main(int argc, char  *argv[]){
    int i, num1, num2, len, result;
    char *sign;

    calc_t functions[]={
        {"+", add},
        {"-", subtract},
        {"*", multiply},
        {"/", division},
        {"%", module}
    };

    if (argc != 4)
        return (0);

    num1 = atoi(argv[1]);
    num2 = atoi(argv[3]);
    sign = argv[2];  //you have to pass the multiplication sign like this "*" for it to work

    len = sizeof(functions) / sizeof(calc_t);

    i  = 0;
    while (i < len)
    {
        if (*(sign) == *(functions[i].sign))
        {
            result = functions[i].func(num1, num2);
            printf("Result: %d\n", result);
        }
        i++;
    }
    return (0);
}


//functions performing the calculations

int add(int a, int b)
{
    return (a + b);
}

int subtract(int a, int b)
{
    return (a - b);
}


int multiply(int a, int b)
{
    return (a * b);
}

int division(int a, int b)
{
    return (a / b);
}

int module(int a,int b)
{
    return (a % b);
}

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

/**
 * struct dog - creates the dog's information
 * @name: name of the dog
 * @age:age of the dog
 * @owner: owner of the dog
 *
 * Description:the struct creates the info on the dog
 */

struct dog
{
    char *name;
    float age;
    char *owner;
};

typedef struct dog dog_t;

// Fuction prototypes
dog_t *new_dog(char *name, float age, char *owner);
int _strlen(char *str);
char *_strcpy(char *dest, char *src);
void free_dog(dog_t *d);

/**
 * main - check the code
 *
 * Return: Always 0.
 */
int main(void)
{
    dog_t *my_dog;

    my_dog = new_dog("Poppy", 3.5, "Bob");
    printf("My name is %s, and I am %.1f :) - Woof!\n", my_dog->name, my_dog->age);
    free_dog(my_dog);
    return (0);
}

/**
 * _strlen-calculates the length of a string
 * @str: the string
 *
 * Return: returns the size of the string
 */

int _strlen(char *str)
{
    int i, len;

    len = 0;
    for (i = 0; str[i]; i++)
    {
        len++;
    }
    return (len);
}

/**
 * _strcpy- copies one string to another string
 * @dest: where we are coping the string to
 * @src: the source of the string
 *
 * Return: returns a pointer to dest
 */
char *_strcpy(char *dest, char *src)
{
    int i = 0;

    for (i = 0; src[i]; i++)
    {
        dest[i] = src[i];
    }
    dest[i] = '\0';

    return (dest);
}

/**
 * new_dog - the function creates a new dog
 * @name:the name of the dog
 * @age: the age of the dog
 * @owner: the owner of the dog
 *
 * Return: returns a pointer to the new created dog else null
 */

dog_t *new_dog(char *name, float age, char *owner)
{
    dog_t *ptr;
    int name_len;
    int owner_len;

    if (name == NULL || age < 0 || owner == NULL)
        return (NULL);

    ptr = malloc(sizeof(dog_t));
    if (ptr == NULL)
        return (NULL);

    name_len = _strlen(name) + 1;
    ptr->name = malloc(sizeof(char) * name_len);
    if (ptr->name == NULL)
    {
        free(ptr);
        return (NULL);
    }
    owner_len = _strlen(owner) + 1;
    ptr->owner = malloc(sizeof(char) * owner_len);
    if (ptr->owner == NULL)
    {
        free(ptr->name);
        free(ptr);
        return (NULL);
    }
    ptr->age = age;
    ptr->name = _strcpy(ptr->name, name);
    ptr->owner = _strcpy(ptr->owner, owner);

    return (ptr);
}

/**
 * free_dog- a function that frees the created dog
 * @d: pointer to the created dog
 *
 * Return: doesnt return anything
 */

void free_dog(dog_t *d)
{
    if (d == NULL)
        return;

    free(d->name);
    free(d->owner);
    free(d);
}

#include <stdio.h>

/**
 * _strcat- the function concatenates two strings
 * @dest: where we are copying the string to
 * @str: where we are getting the string from
 *
 * Return: returns a pointer to dest
 */

int _strlen(char *str)
{
    int i, len;

    len = 0;
    for (i = 0; str[i]; i++)
    {
        len++;
    }
    return (len);
}

char *_strcat(char *dest, char *src)
{
    int i, dest_len, index;

    dest_len = _strlen(dest);

    index = dest_len;
    dest[index] = ' ';
    index = index + 1;
    for (i = 0; dest[i] && src[i]; i++)
    {
        dest[index] = src[i];
        index++;
    }
    dest[index] = '\0';
    return (dest);
}

int main(void)
{
    char str1[50] = "Hello";
    char str2[] = "Word!";

    char *ptr = _strcat(str1, str2);
    printf("%s\n", ptr);
    return (0);
}

#include <stdio.h>

int _strlen(char *str)
{
    int len, i;

    len = 0;
    for (i = 0; str[i]; i++)
        len++;
    return (len);
}

void reverse_string(char *str)
{
    int i, j, size;
    size = _strlen(str);

    j = 0;
    for (i = size - 1; i > j; i--)
    {
        char temp = str[j];
        str[j] = str[i];
        str[i] = temp;
        j++;
    }
}

int main(void)
{
    char str[] = "JQK";
    reverse_string(str);

    printf("Reversed string: %s\n", str);

    return 0;
}

#include <stdio.h>

/**
 * _strlen-calculates the length of a string
 * @str: the string
 * Return: returns the length of the string
 */

int _strlen(char *str)
{
    int i, len;

    len = 0;
    for (i = 0; str[i]; i++)
    {
        len++;
    }
    return (len);
}

#include <stdio.h>

/**
 * _strcpy-copies the src string to dest
 * @dest: where we are coping the string to
 * @src: the string that we are copying
 *
 * Return: returns a pointer to the dest string
 */

char *_strcpy(char *dest, char *src)
{
    int i;

    for (i = 0; src[i]; i++)
    {
        dest[i] = src[i];
    }
    dest[i] = '\0';
    return (dest);
}

int main()
{
    char str1[20] = "Hello";
    char str2[20];
    char *ptr;

    ptr = _strcpy(str2, str1);

    printf("str1: %s\n", str1);
    printf("str2: %s\n", ptr);

    return 0;
}

#include <stdio.h>

/**
 * _strstr: used to search a given substring in the main string
 * @haystack: the string we are searching the substring  in
 * @needle: the substring we are searching in haystack
 *
 * Return: returns the pointer to the first occurrence of the given substring in the main string.
 */

char *_strstr(char *haystack, char *needle)
{
    int i, j;
    char *start;

    for (i = 0; haystack[i]; i++)
    {
        for (j = 0; needle[j]; j++)
        {
            if (haystack[i + j] != needle[j])
            {
                break;
            }
        }

        if (needle[j] == '\0')
        {
            start = &haystack[i];
            return (start);
        }
    }
    return (NULL);
}

int main()
{
    char main_string[50] = "Hello, how's the weather today?";
    char search_string[30] = "weather";

    char *found_string = _strstr(main_string, search_string);

    if (found_string == NULL)
    {
        printf("Substring not found in the string\n");
    }
    else
    {
        printf("Substring located -> %s\n", found_string);
    }

    return 0;
}

#include <stdio.h>
#include <stdlib.h>
int adjmat[10][10];
struct banks
{
    int netAmount;
    char name;
    char types[3];
};
struct Pair {
    int first;
    char second;
};
int GetMinIndex(struct banks listOfAmounts[],int numBanks)
{
    int min=INT_MAX,minIndex=-1;
    for(int i=0;i<numBanks;i++)
    {
        if(listOfAmounts[i].netAmount==0)
            continue;
        if(listOfAmounts[i].netAmount < min)
        {
            minIndex=i;
            min=listOfAmounts[i].netAmount;
        }
    }
    return minIndex;
}
int getSimpleMaxIndex(struct banks listOfNetAmounts[],int numBanks){
    int max=INT_MIN, maxIndex=-1;
    for(int i=0;i<numBanks;i++){
        if(listOfNetAmounts[i].netAmount == 0) continue;

        if(listOfNetAmounts[i].netAmount > max){
            maxIndex = i;
            max = listOfNetAmounts[i].netAmount;
        }
    }
    return maxIndex;
}/*
struct Pair getMaxIndex(struct banks listOfNetAmounts[], int numBanks, int minIndex, struct banks input[], int maxNumTypes)
{
    int max = INT_MIN;
    int maxIndex = -1;
    char matchingType[100];

    for (int i = 0; i < numBanks; i++) {
        if (listOfNetAmounts[i].netAmount == 0) continue;
        if (listOfNetAmounts[i].netAmount < 0) continue;

        //TODO
        //see complexity of intersection

        char v[maxNumTypes][100];
        char *ls = set_intersection((char *)listOfNetAmounts[minIndex].types, (char *)listOfNetAmounts[minIndex].types + listOfNetAmounts[minIndex].numTypes * 100, (char *)listOfNetAmounts[i].types, (char *)listOfNetAmounts[i].types + listOfNetAmounts[i].numTypes * 100, (char *)v);

        if ((ls - (char *)v) / 100 != 0 && max < listOfNetAmounts[i].netAmount) {
            max = listOfNetAmounts[i].netAmount;
            maxIndex = i;
            strcpy(matchingType, v[0]);
        }
    }

    //if there is NO such max which has a common type with any remaining banks then maxIndex has -1
    // also return the common payment type
    struct pair result;
    result.first = maxIndex;
    strcpy(result.second, matchingType);
    return result;
}*/
struct BankAndType {
    int bankIndex;
    char paymentType;
};

struct BankAndType getMaxIndex(struct banks* listOfNetAmounts, int numBanks, int minIndex, struct banks* input, int maxNumTypes) {
    int max = INT_MIN;
    int maxIndex = -1;
    char matchingType = '\0';

    for (int i = 0; i < numBanks; i++) {
        if (listOfNetAmounts[i].netAmount == 0 || listOfNetAmounts[i].netAmount < 0) {
            continue;
        }

        for (int j = 0; j < listOfNetAmounts[i].types; j++) {
            char currentType = listOfNetAmounts[i].types[j];

            for (int k = 0; k < minIndex; k++) {
                if (listOfNetAmounts[k].netAmount == 0 || listOfNetAmounts[k].netAmount > 0) {
                    continue;
                }

                for (int l = 0; l < listOfNetAmounts[k].types; l++) {
                    if (currentType == listOfNetAmounts[k].types[l]) {
                        if (listOfNetAmounts[i].netAmount > max) {
                            max = listOfNetAmounts[i].netAmount;
                            maxIndex = i;
                            matchingType = currentType;
                        }
                    }
                }
            }
        }
    }

    struct BankAndType result = { maxIndex, matchingType };
    return result;
}
void Minimizecashflow(int numBanks,struct banks input[6],char aindexOf[6],int numTras,int adjmat[6][6],int maxTypes)
{


   struct banks listOfNetAmounts[numBanks];
   for(int b=0;b<numBanks;b++)
   {
       listOfNetAmounts[b].name=input[b].name;
       for(int i=0;i<numBanks;i++)
       {
            listOfNetAmounts[b].types[i]=input[b].types[i];
       }

       int amount=0;
       for(int i=0;i<numBanks;i++){
            amount += (adjmat[i][b]);
        }
       for(int j=0;j<numBanks;j++){
            amount += ((-1) * adjmat[b][j]);
        }


        listOfNetAmounts[b].netAmount = amount;

   }




   struct Pair  ansGraph[numBanks][numBanks];
   int numZeroNetAmounts=0;
   int maxIndex=0;

    for(int i=0;i<numBanks;i++){
        if(listOfNetAmounts[i].netAmount == 0)
            numZeroNetAmounts++;
    }


    while(numZeroNetAmounts!=numBanks){

        int minIndex=GetMinIndex(listOfNetAmounts, numBanks);
        struct Pair maxAns = getMaxIndex(listOfNetAmounts, numBanks, minIndex,input,maxTypes);
        int maxIndex = maxAns.first;

       if(maxIndex == -1){

            (ansGraph[minIndex][0].first) += abs(listOfNetAmounts[minIndex].netAmount);
            //(ansGraph[minIndex][0].second) = *(input[minIndex].types.begin());

            int simpleMaxIndex = getSimpleMaxIndex(listOfNetAmounts, numBanks);
            (ansGraph[0][simpleMaxIndex].first) += abs(listOfNetAmounts[minIndex].netAmount);
           // (ansGraph[0][simpleMaxIndex].second) = *(input[simpleMaxIndex].types.begin());

            listOfNetAmounts[simpleMaxIndex].netAmount += listOfNetAmounts[minIndex].netAmount;
            listOfNetAmounts[minIndex].netAmount = 0;

            if(listOfNetAmounts[minIndex].netAmount == 0) numZeroNetAmounts++;

            if(listOfNetAmounts[simpleMaxIndex].netAmount == 0) numZeroNetAmounts++;

        }
        else{
            int transactionAmount;
            if(listOfNetAmounts[minIndex].netAmount < listOfNetAmounts[maxIndex].netAmount)
            {
                 transactionAmount=listOfNetAmounts[minIndex].netAmount;
            }
            else
            {
                 transactionAmount=listOfNetAmounts[maxIndex].netAmount;
            }

            (ansGraph[minIndex][maxIndex].first) += (transactionAmount);
           // (ansGraph[minIndex][maxIndex].second) = maxAns.second;

            listOfNetAmounts[minIndex].netAmount += transactionAmount;
            listOfNetAmounts[maxIndex].netAmount -= transactionAmount;

            if(listOfNetAmounts[minIndex].netAmount == 0) numZeroNetAmounts++;

            if(listOfNetAmounts[maxIndex].netAmount == 0) numZeroNetAmounts++;
        }

    }

   // printAns(ansGraph,numBanks,input);


}
int main()
{


     printf("\n---------------------------------------------------------------------------------------Welcome to CASH FLOW MINIMIZER SYSTEM--------------------------------------------------------------------------------------\n\n\n");
     int numBanks;
     printf("\nEnter The Number Of Banks:");
     scanf("%d",&numBanks);
     printf("\n----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------\n\n\n");




     struct  banks input[numBanks];
     char aindexOf[numBanks];
     int maxTypes;

     printf("Enter The Details Of The Banks and Transactions As Stated:\n");
     printf("Bank Name , Number Of Payment Modes It has and the Payment Modes.\n");
     printf("\n----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------\n\n\n");




     for(int i=0;i<numBanks;i++)
     {
         if(i==0)
             printf("WorldBank:");
         else{
             printf("Bank: %d ",i);
         }


         fflush(stdin);
         printf("\nEnter name of bank:");
         fflush(stdin);
         scanf("%c",&input[i].name);
         aindexOf[i]=input[i].name;
         fflush(stdin);
         printf("\nEnter Number Of Modes: ");
         int numTypes;
         scanf("%d",&numTypes);
         printf("\nClick \nPhone pay-1, \nPaytm-2, \nGoogle pay-3::");


         if(i==0)
            maxTypes=numTypes;

           int inputTypesofpayment;
           input[i].types[0]=0;//gpay
           input[i].types[1]=0;//paytm
           input[i].types[2]=0;//phonepe
           while(numTypes--)
           {

               scanf("%d",&inputTypesofpayment);
               input[i].types[inputTypesofpayment]=1;
           }
                 printf("\n----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------\n\n\n");

     }



     printf("\nEnter number of Trasaction.");
     int NumTras;
     scanf("%d",&NumTras);
     int adjmat[numBanks][numBanks];
     for(int i=0;i<numBanks;i++)
     {
         for(int j=0;j<numBanks;j++){
            adjmat[i][j]=0;
         }

     }




     printf("Debtor Bank , creditor Bank and amount\n");
     for(int i=0;i<NumTras;i++)
     {
         printf("\n%d: th trasaction:",i+1);
         fflush(stdin);
         char fBank,sBank;
         int amount;
         fflush(stdin);
         scanf("%c %c",&fBank,&sBank);
         fflush(stdin);
         scanf("%d",&amount);
         fflush(stdin);
         int retindf=0;
         int retinds=0;
         for(int i=0;i<numBanks;i++)
         {
             //printf("\nI am in");
             if(aindexOf[i]==fBank)
                 retindf=i;
             if(aindexOf[i]==sBank)
                  retinds=i;
         }

        adjmat[retindf][retinds]=amount;

     }


     /*for(int i=0;i<numBanks;i++)
     {
         for(int j=0;j<numBanks;j++){
            printf("%d ",adjmat[i][j]);
         }
         printf("\n");

     }*/


    Minimizecashflow(numBanks,input,aindexOf,NumTras,adjmat,3);

    return 0;

}

//
//  main.c
//  Re40Dia20NF1D2
//
//  Created by Siddhartha Shandilya on 15/04/23.
//

#include<stdio.h>
#include<math.h>

  /*------ Flow in a Square Channel with a particle in between  ---------*/
#define        NF          1
#define        Re          40.0
#define        u_inlet     0.2093333333
#define        NX          801   //no. of nodes in the x-direction
#define        NY          801   //no. of nodes in the y-direction

#define        a           20.0    //particle diameter
#define        radius      10.0     //particle radius
#define        g           400.0   // x-coordinate of the center of the spherical particle
#define        f           400.0   // y-coordinate of the center of the spherical particle
#define        lmtheta     2.25  // angular separation of lagrangian marker
#define        Q           9     // no. of direction of velocity vectors (D2Q9 model implemented)
#define        T           1001 // no. of time steps
#define        tau         0.814  // dimensionless relaxation time due to fluid–particle collisions
#define        visc        (tau-0.5)/3.0 //viscosity
#define        rho0        1.0   // density initialization
//#define      Ht          NY-1.0 //height in vertical direction
#define        pie         3.141592653589 //value of pie
#define        w0          4.0/9.0 // weighting coefficient
#define        w1          1.0/9.0 // weighting coefficients for i = 1,2,3,4
#define        w2          1.0/36.0 // weighting coefficients for i = 5,6,7,8
//#define      Ub          0.0


#define         h           1

double          Cd;
int             k;
int             cx          [Q]={0,1,0,-1,0,1,-1,-1,1}; //discrete velocity vectors
int             cy          [Q]={0,0,1,0,-1,1,1,-1,-1}; // discrete velocity vectors
double          t           [Q]={w0,w1,w1,w1,w1,w2,w2,w2,w2};
int             next_x      [NX][Q];
int             next_y      [NY][Q];
double          SumFX;
double          r;
double          FX          [NX][NY];
double          FY          [NX][NY];
double          f1          [NX][NY][Q];    //main probability distribution function
double          f2          [NX][NY][Q];    //temporary PDF
double          rho         [NX][NY];
double          ux          [NX][NY];
double          uy          [NX][NY];
double          U           [NX][NY];
double          V           [NX][NY];
//double        ux_eq       [NX][NY];
//double        uy_eq       [NX][NY];
double          bnode       [NX][NY];
//double        ux_exact    [NY];

void        tables();
void        initialise();
void        cal_obs();
void        IBM();
void        collision();
void        streaming();
void        data(int, int);
void        data_Cd(int, int);
//void        exact();

int main()
{
    int count = 0;
    tables();
    initialise();
    for(k=0; k<T; k++)
    {
        printf("k=%d\r\t",k);
        cal_obs();
        IBM();
        collision();
        streaming();
        
        if(k%50000==0)
        {
            data(count, k);
        }
        if(k==1000)
        {
            data_Cd(count, k);
        }
    }

    return 0;
}

void tables()
{
    int x,y,i;

    for(x=0; x<NX; x++)
    {
        for(y=0; y<NY; y++)
        {
            for(i=0; i<Q; i++)
            {
                next_x[x][i] = x + cx[i];

                if(next_x[x][i]<0)
                    next_x [x][i] = NX-1;
                if(next_x[x][i]>(NX-1))
                    next_x[x][i] = 0;

                next_y[y][i] = y + cy[i];

                if(next_y[y][i]<0)
                    next_y [y][i] = NY-1;
                if(next_y[y][i]>(NY-1))
                    next_y[y][i] = 0;
            }
        }
    }

    return ;
}


void initialise()
{
    int x,y,i;

    for(x=0; x<NX; x++)
    {
        for(y=0; y<NY; y++)
        {
            rho[x][y] = rho0;
            ux[x][y] = 0.0; uy[x][y] = 0.0;
            
            for(i=0; i<Q; i++)
            {
                f1[x][y][i] = rho0*t[i];

            }
        }
    }

    for(x=0; x<NX; x++)
    {
        for(y=0; y<NY; y++)
        {
            bnode[x][y] = 0.0;
            if(y==0 || y==(NY-1))
            {
                bnode[x][y] = 1.0;
            }
        }
    }

    return ;
}

double cal_dela(int x, int y, double bX, double bY) {
    double rX = x - bX;                      //x-coordinate difference between the current marker and the current node
    double rY = y - bY;                      //y-coordinate difference between the current marker and the current node

    double arX = fabsf(rX);                  //absolute value of 'r'
    double arY = fabsf(rY);                  // ,,

    double delX = 0, delY = 0;               //calculating delta function

    if(arX >= 0 && arX < 1)
        delX = 1/8.0*(3-(2*arX)+sqrt(1+(4*arX)-(4*arX*arX)));
    if(arX >= 1 && arX < 2)
        delX = 1/8.0*(5-(2*arX)-sqrt(-7+(12*arX)-(4*arX*arX)));
    else // |r| >= 2
        delX = 0;


    if(arY >= 0 && arY < 1)                 //calculating delta function (y);
        delY = 1/8.0*(3-(2*arY)+sqrt(1+(4*arY)-(4*arY*arY)));
    if(arY >= 1 && arY < 2)
        delY = 1/8.0*(5-(2*arY)-sqrt(-7+(12*arY)-(4*arY*arY)));
    else // |r| >= 2
        delY = 0;

    double D = delX * delY;                          //calculation of Eq. No. 26
    return D;
}
double delta2(int x, int y, double bX, double bY)

{

    double D;
    double rX = x - bX;                      //x-coordinate difference between the current marker and the current node
    double rY = y - bY;                      //y-coordinate difference between the current marker and the current node
    double arX = fabs(rX);                  //absolute value of 'r'
    double arY = fabs(rY);
    double delX = 0.0; double delY = 0.0;

    if(arX <= 1)

        delX = 1.0 - arX;

    else

        delX = 0.0;

    

    if(arY <= 1)

        delY = 1.0 - arY;

    else

        delY = 0.0;

    

    D = delX * delY;

    

    return D;

}

void cal_obs()
{
    int x,y,i;
    //double dense;

    for(x=0; x<NX; x++)
    {
        for (y=0; y<NY; y++)
        {
            rho[x][y]=0.0; ux[x][y]=0.0; uy[x][y]=0.0;
            //if(bnode[x][y] !=1.0)
            {
                for (i=0; i<Q; i++)
                {
                    rho[x][y]     += f1[x][y][i];
                    ux[x][y]  += f1[x][y][i]*cx[i];
                    uy[x][y]  += f1[x][y][i]*cy[i];
                }
                //rho[x][y] = dense;
                ux[x][y]  = ux[x][y]/rho[x][y];
                uy[x][y]  = uy[x][y]/rho[x][y];
            }
        }
    }
return;
}

void IBM()
{
    double dels = (a * pie * lmtheta)/360.0;             //arc length calculation

    int b = 0;
    int markerCount = 360/lmtheta;                      //calculating no. of markers
    double UbX[markerCount], UbY[markerCount];           //velocities at markers
    double FbX[markerCount], FbY[markerCount];           //forces at markers
    double Fx[NX][NY];
    float  Fy[NX][NY];
    double SumFX;                                    //forces at grids
    for(int i=0; i<markerCount; ++i)
        UbX[i] = 0.0,                                     //initialising to zero
                UbY[i] = 0.0,
                FbX[i] = 0.0,
                FbY[i] = 0.0;

    for(int i=0; i<NX; i++)
        for(int j=0; j<NY; j++) {
            Fx[i][j] = 0.0;
            Fy[i][j] = 0.0;
        }

    //double radius = a/2.0;
    //iterate all the markers one by one
    for(double theta=0; theta<=360; theta+=lmtheta, b+=1)
    {
        double radiantheta = theta * (pie / 180.0);      //converting angle to radian
        double bX = (g + (a/2.0)*cos(radiantheta));        //calculating x-cordinate of lagrangian marker
        double bY = (f + (a/2.0)*sin(radiantheta));        //calculating y-cordinate of lagrangian marker
        int rbx = round(bX), rby = round(bY);           //rounding it to nearest integer

        //        for(int x=0; x<NX; x++)
        //        {
        //            for(int y=0; y<NY; y++)
        //            {


        int vicinity_map[4][2] = {
            // x,  y
            {-1, 0},  //left
            {+1, 0},  //right
            {0, +1},  //down
            {0, -1},  //up
        };

        int m=0;
        while(m != NF) {

            //iterate over each direction
            int rx, ry; //temp variables to store the coords of nodes in the vicinity of current marker
            for(int i=0; i<4; ++i) {
                //add in either(x or y) coord to move in one of the 4 desired directions
                //Note: we are not skipping any nearby node in any of the 4 directions
                rx = round(bX + vicinity_map[i][0]);
                ry = round(bY + vicinity_map[i][1]);

                double D = delta2(rx, ry, bX, bY);

                UbX[b] += (ux[rx][ry] * D * pow(h, 2)); //unforced velocity interpolation on markers
                UbY[b] += (uy[rx][ry] * D * pow(h, 2));
            }

            //OLD CODE
            //
            //for (int i = rbx - 1; i <= rbx + 1; i++)
            //{
            //    for (int j = rby - 1; j <= rby + 1; j++)
            //      {
            //        double distance = sqrt(pow(i-g, 2) + pow(j-f, 2));

            //
            //        if(distance > radius)                 //checking if the point is outside the circle
            //        {
            //            UbX[b] += (ux[i][j] * D * pow(h, 2));
            //            UbY[b] += (uy[i][j] * D * pow(h, 2));
            //        }
            //    }
            //}


            int Ub = 0;                             //calculating boundary force on markers
//            printf("f: %d, %d: %f\r\n", rbx, rby, rho[rbx][rby]);
            FbX[b] = (2*rho[rbx][rby] * Ub - UbX[b]) ;  //x-component of force on the marker from it's vicinity
            FbY[b] = (2*rho[rbx][rby] * Ub - UbY[b]) ;  //y-component


            for(int i=0; i<4; ++i)
            {
                //add in either(x or y) coord to move in one of the 4 desired directions
                //Note: we are not skipping any nearby node in any of the 4 directions
                rx = round(bX + vicinity_map[i][0/*delta in x-corrd*/]);
                ry = round(bY + vicinity_map[i][1/*delta in y-coord*/]);

                double D = delta2(rx, ry, bX, bY);

                Fx[rx][ry] += FbX[b] * D * dels;            //updating the force on neraby nodes of current markers
                Fy[rx][ry] += FbY[b] * D * dels;
            }

            ///OLD CODE
            //for (int i = rbx - 1; i <= rbx + 1; i++)
            //{
            //    for (int j = rby - 1; j <= rby + 1; j++)
            //  {
            //        double distance = sqrt(pow(i-g, 2) + pow(j-f, 2));

            //
            //        if(distance > radius)                    //checking if the point is outside the circle
            //         {
            //            Fx[i][j] += FbX[b] * D * dels;      //updating the force on nearby nodes of the current marker
            //            Fy[i][j] += FbY[b] * D * dels;
            //        }
            //    }
            //}
            //            }
            //        }

            m = m + 1;
        }
    }


    int dt = 1;
    //CFX = 0;
    SumFX = 0.0;                                              //calculating updated velocity on grids
    for(int i=0; i<NX; ++i)
    {
        for(int j=0; j<NY; ++j)
         {
//            printf("s: %d, %d: %f\r\n", i, j, rho[i][j]);
            ux[i][j] = ux[i][j] + (dt/(2*rho[i][j]))*Fx[i][j];
            uy[i][j] = uy[i][j] + (dt/(2*rho[i][j]))*Fy[i][j];
            FX[i][j] = Fx[i][j];
            FY[i][j] = Fy[i][j];
            SumFX += FX[i][j];
            Cd = -(SumFX)/(pow(u_inlet,2) * radius);
             printf("%d\t%lf\t\n", k,Cd);
            
            
//            printf("ff: %f, %f", Fx[i][j], Fy[i][j]);
        }
    }

    return;
}

void collision()
{
    int x,y,i;
    double udotc, u2, feq, force_term;

    for(x=0; x<NX; x++)
    {
        for(y=0; y<NY; y++)
        {
            U[x][y]=ux[x][y];
            V[x][y]=uy[x][y];

            if(bnode[x][y] != 1.0)
            {

                for(i=0; i<Q; i++)
                {
                    //U[x][y] = ux[x][y]+(fx*0.5)/rho[x][y];
                    //V[x][y] = uy[x][y]+(fy*0.5)/rho[x][y];

                    udotc = U[x][y]*cx[i]+V[x][y]*cy[i];
                    u2 = U[x][y]*U[x][y]+V[x][y]*V[x][y];

                    force_term = (1.0-0.5/tau)*t[i]*((3.0*(cx[i]-U[x][y])+9.0*cx[i]*(cx[i]*U[x][y]+cy[i]*V[x][y]))*FX[x][y]) + ((3.0*(cy[i]-V[x][y])+9.0*cy[i]*(cx[i]*U[x][y]+cy[i]*V[x][y]))*FY[x][y]) ;

                    feq = rho[x][y]*t[i]*(1+3.0*udotc+4.5*udotc*udotc-1.5*u2);
                    //f1[x][y][i] = f1[x][y][i]-(1.0/tau)*(f1[x][y][i]-feq);
                    f1[x][y][i] = f1[x][y][i]-(1.0/tau)*(f1[x][y][i]-feq) +(force_term);


                    // Compute force for each direction
                    //for (int i = 0; i < Q; i++)
                    //{
                    // Compute deviation of velocity from discrete velocity
                    //double dev = (c[i].x - u.x) / c*c;

                    // Compute dot product of e_i with u
                    //double dot = e[i].x * u.x + e[i].y * u.y + e[i].z * u.z;
                    //dot /= c * c*c*c;

                    // Compute dot product of previous result with e_i
                    //dot *= e[i];

                    // Compute weight factor for direction i
                    //double weight = w[i];

                    // Compute force for direction i
                    //double force = (1.0 - 0.5 * tau) * weight * (3.0 * dev + 9.0 * dot / (c * c * c * c));

                    // Add force to total force
                    //F.x += force * e[i].x;
                    //F.y += force * e[i].y;
                    //F.z += force * e[i].z;
                }
            }


        }
    }
    return ;
}

void streaming()
{


    int x,y,i,newx,newy;
    double rho_inlet, u_outlet;

    /*for(x=0; x<NX; x++)
    {
        for(y=0; y<NY; y++)
        {
            //if(bnode[x][y]!=1.0)
            {
                for(i=0; i<Q; i++)
                {
                    newx = next_x[x][i];
                    newy = next_y[y][i];

                    f1[newx][newy][i] = f2[x][y][i];
                }
            }
        }
    }*/
    for(x=0; x<NX; x++)
    {
        for (y=0; y<NY; y++)
        {
            for (i=0; i<Q; i++)
            {
                newx=next_x[x][i];
                newy=next_y[y][i];
                f2[newx][newy][i] = f1[x][y][i];
            }
        }
    }

    for(x=0; x<NX; x++)
    {
        for (y=0; y<NY; y++)
        {
            for (i=0; i<Q; i++)
            {
                f1[x][y][i]=f2[x][y][i];
            }
        }
    }
    /*------ Standard bounce-back scheme -----------*/
    for(x=0; x<NX; x++)
    {
        for(y=0; y<NY; y++)
        {
            if(y==0)
            {
                f1[x][y][2] = f1[x][y][4];
                f1[x][y][5] = f1[x][y][7];
                f1[x][y][6] = f1[x][y][8];

            }
            if(y==NY-1)
            {
                f1[x][y][4] = f1[x][y][2];
                f1[x][y][7] = f1[x][y][5];
                f1[x][y][8] = f1[x][y][6];
            }
        }
    }

    for (y=0; y<NY; y++)
    {
        rho_inlet = (f1[0][y][0]+f1[0][y][2]+f1[0][y][4]+2.0*(f1[0][y][3]+f1[0][y][6]+f1[0][y][7]))/(1.0-u_inlet);
        f1[0][y][1] = f1[0][y][3]+(2.0/3.0)*rho_inlet*u_inlet;
        f1[0][y][5] = f1[0][y][7]-(1.0/2.0)*(f1[0][y][2]-f1[0][y][4])+(1.0/6.0)*rho_inlet*u_inlet;
        f1[0][y][8] = f1[0][y][6]+(1.0/2.0)*(f1[0][y][2]-f1[0][y][4])+(1.0/6.0)*rho_inlet*u_inlet;
    }

    
    for (y=0; y<NY; y++)
    {
        for(x=NX-1; x<NX; x++)
        {
            u_outlet = -1.0 + (f1[x][y][0]+f1[x][y][2]+f1[x][y][4]+2.0*(f1[x][y][1]+f1[x][y][5]+f1[x][y][8]))/rho0;
            f1[x][y][3] = f1[x][y][1]-(2.0/3.0)*rho0*u_outlet;
            f1[x][y][7] = f1[x][y][5]-(1.0/6.0)*rho0*u_outlet+(1.0/2.0)*(f1[x][y][2]-f1[x][y][4]);
            f1[x][y][6] = f1[x][y][8]-(1.0/6.0)*rho0*u_outlet-(1.0/2.0)*(f1[x][y][4]-f1[x][y][2]);
        }
    }
    return;
}

void data(int data_counter, int id)
{
    int     x, y;
    //double  Cd;
    //double SumFX;
    FILE    *f3;
    char    phase   [100];

    /*  Data for Tecplot*/
    //SumFX = 0.0;
    sprintf ( phase, "IBM_phase%d.dat",id);
    f3 = fopen(phase, "w");
    fprintf( f3, "Variables = X, Y, RHO, U, V, Fx, Fy \n");
    fprintf(f3,"Zone I=   %d,J=   %d,F=POINT\n", NX, NY);
    for (y = NY - 1; y > -1; y--)
    {    for (x = 0; x < NX; x++)
        {
            //SumFX += FX[x][y];
            
            fprintf(f3,"%d\t%d\t%lf\t%lf\t%lf\t%0.10lf\t%0.10lf\n",x,y,rho[x][y],U[x][y],V[x][y],FX[x][y],FY[x][y]);
            fprintf(f3, "\n");

        }

    }
    
    fflush(f3);
    fclose(f3);

    return;
}
void data_Cd(int data_counter, int id)
{
    //int     k,x,y;
    //double  SumFX;
    //double  Cd;
    
    FILE    *f3;
    char    phase   [100];

    /*  Data for Tecplot*/
    //SumFX = 0.0;
    sprintf ( phase, "Cd%d.dat",id);
    f3 = fopen(phase, "w");
    fprintf( f3, "Variables = Time Steps, Cd \n");
    //fprintf(f3,"Zone I=   %d,J=   %d,F=POINT\n", NX, NY);
    
    
    for(k=0; k<T; k++)
    {

            
            fprintf(f3,"%d\t%lf\t\n", k,Cd);
            

    }

    
 
    

    
    fflush(f3);
    fclose(f3);

    return;
}

/*
void data(int, int)
{       {
        //store output in a file
        FILE    *f3;
        f3 = fopen("IB-LBM_Output.txt", "w");
        fprintf( f3, "Variables = X, Y, RHO, U, V \n");
        //double radius = a/2.0;
        for (int x = 0; x < NX; x++) {
            for (int y=0; y<NY; ++y) {
                //double distance = sqrt(pow(x-g, 2) + pow(x-f, 2));
                //only if the node is outside the circle, we are writing to the file
                //if(distance > radius) {
                fprintf(f3,"%d\t%d\t%lf\t%lf\t%lf\n",x,y,rho[x][y],ux[x][y],uy[x][y]);
                fprintf(f3, "\n");
                //}
            }
        }

        fflush(f3);
        fclose(f3);
        return;
        }
}*/

//
//  main.c
//  Re40Dia20NF1D2
//
//  Created by Siddhartha Shandilya on 15/04/23.
//

#include<stdio.h>
#include<math.h>

  /*------ Flow in a Square Channel with a particle in between  ---------*/
#define        NF          1
#define        Re          40.0
#define        u_inlet     0.2093333333
#define        NX          801   //no. of nodes in the x-direction
#define        NY          801   //no. of nodes in the y-direction

#define        a           20.0    //particle diameter
#define        radius      10.0     //particle radius
#define        g           400.0   // x-coordinate of the center of the spherical particle
#define        f           400.0   // y-coordinate of the center of the spherical particle
#define        lmtheta     2.25  // angular separation of lagrangian marker
#define        Q           9     // no. of direction of velocity vectors (D2Q9 model implemented)
#define        T           100001 // no. of time steps
#define        tau         0.814  // dimensionless relaxation time due to fluid–particle collisions
#define        visc        (tau-0.5)/3.0 //viscosity
#define        rho0        1.0   // density initialization
//#define      Ht          NY-1.0 //height in vertical direction
#define        pie         3.141592653589 //value of pie
#define        w0          4.0/9.0 // weighting coefficient
#define        w1          1.0/9.0 // weighting coefficients for i = 1,2,3,4
#define        w2          1.0/36.0 // weighting coefficients for i = 5,6,7,8
//#define      Ub          0.0


#define         h           1

//double        CFX;
//int           k;
int             cx          [Q]={0,1,0,-1,0,1,-1,-1,1}; //discrete velocity vectors
int             cy          [Q]={0,0,1,0,-1,1,1,-1,-1}; // discrete velocity vectors
double          t           [Q]={w0,w1,w1,w1,w1,w2,w2,w2,w2};
int             next_x      [NX][Q];
int             next_y      [NY][Q];
double          SumFX;
double          r;
double          FX          [NX][NY];
double          FY          [NX][NY];
double          f1          [NX][NY][Q];    //main probability distribution function
double          f2          [NX][NY][Q];    //temporary PDF
double          rho         [NX][NY];
double          ux          [NX][NY];
double          uy          [NX][NY];
double          U           [NX][NY];
double          V           [NX][NY];
//double        ux_eq       [NX][NY];
//double        uy_eq       [NX][NY];
double          bnode       [NX][NY];
//double        ux_exact    [NY];

void        tables();
void        initialise();
void        cal_obs();
void        IBM();
void        collision();
void        streaming();
void        data(int, int);
void        cal_Cd(int, int);
//void        exact();

int main()
{
    int count = 0, k;
    tables();
    initialise();
    for(k=0; k<T; k++)
    {
        printf("k=%d\r\t",k);
        cal_obs();
        IBM();
        collision();
        streaming();
        
        /*if(k%50000==0)
        {
            data(count, k);
        }*/
        if(k==100000)
        {
            cal_Cd(count, k);
        }
    }

    return 0;
}

void tables()
{
    int x,y,i;

    for(x=0; x<NX; x++)
    {
        for(y=0; y<NY; y++)
        {
            for(i=0; i<Q; i++)
            {
                next_x[x][i] = x + cx[i];

                if(next_x[x][i]<0)
                    next_x [x][i] = NX-1;
                if(next_x[x][i]>(NX-1))
                    next_x[x][i] = 0;

                next_y[y][i] = y + cy[i];

                if(next_y[y][i]<0)
                    next_y [y][i] = NY-1;
                if(next_y[y][i]>(NY-1))
                    next_y[y][i] = 0;
            }
        }
    }

    return ;
}


void initialise()
{
    int x,y,i;

    for(x=0; x<NX; x++)
    {
        for(y=0; y<NY; y++)
        {
            rho[x][y] = rho0;
            ux[x][y] = 0.0; uy[x][y] = 0.0;
            
            for(i=0; i<Q; i++)
            {
                f1[x][y][i] = rho0*t[i];

            }
        }
    }

    for(x=0; x<NX; x++)
    {
        for(y=0; y<NY; y++)
        {
            bnode[x][y] = 0.0;
            if(y==0 || y==(NY-1))
            {
                bnode[x][y] = 1.0;
            }
        }
    }

    return ;
}

double cal_dela(int x, int y, double bX, double bY) {
    double rX = x - bX;                      //x-coordinate difference between the current marker and the current node
    double rY = y - bY;                      //y-coordinate difference between the current marker and the current node

    double arX = fabsf(rX);                  //absolute value of 'r'
    double arY = fabsf(rY);                  // ,,

    double delX = 0, delY = 0;               //calculating delta function

    if(arX >= 0 && arX < 1)
        delX = 1/8.0*(3-(2*arX)+sqrt(1+(4*arX)-(4*arX*arX)));
    if(arX >= 1 && arX < 2)
        delX = 1/8.0*(5-(2*arX)-sqrt(-7+(12*arX)-(4*arX*arX)));
    else // |r| >= 2
        delX = 0;


    if(arY >= 0 && arY < 1)                 //calculating delta function (y);
        delY = 1/8.0*(3-(2*arY)+sqrt(1+(4*arY)-(4*arY*arY)));
    if(arY >= 1 && arY < 2)
        delY = 1/8.0*(5-(2*arY)-sqrt(-7+(12*arY)-(4*arY*arY)));
    else // |r| >= 2
        delY = 0;

    double D = delX * delY;                          //calculation of Eq. No. 26
    return D;
}
double delta2(int x, int y, double bX, double bY)

{

    double D;
    double rX = x - bX;                      //x-coordinate difference between the current marker and the current node
    double rY = y - bY;                      //y-coordinate difference between the current marker and the current node
    double arX = fabs(rX);                  //absolute value of 'r'
    double arY = fabs(rY);
    double delX = 0.0; double delY = 0.0;

    if(arX <= 1)

        delX = 1.0 - arX;

    else

        delX = 0.0;

    

    if(arY <= 1)

        delY = 1.0 - arY;

    else

        delY = 0.0;

    

    D = delX * delY;

    

    return D;

}

void cal_obs()
{
    int x,y,i;
    //double dense;

    for(x=0; x<NX; x++)
    {
        for (y=0; y<NY; y++)
        {
            rho[x][y]=0.0; ux[x][y]=0.0; uy[x][y]=0.0;
            //if(bnode[x][y] !=1.0)
            {
                for (i=0; i<Q; i++)
                {
                    rho[x][y]     += f1[x][y][i];
                    ux[x][y]  += f1[x][y][i]*cx[i];
                    uy[x][y]  += f1[x][y][i]*cy[i];
                }
                //rho[x][y] = dense;
                ux[x][y]  = ux[x][y]/rho[x][y];
                uy[x][y]  = uy[x][y]/rho[x][y];
            }
        }
    }
return;
}

void IBM()
{
    double dels = (a * pie * lmtheta)/360.0;             //arc length calculation

    int b = 0;
    int markerCount = 360/lmtheta;                      //calculating no. of markers
    double UbX[markerCount], UbY[markerCount];           //velocities at markers
    double FbX[markerCount], FbY[markerCount];           //forces at markers
    double Fx[NX][NY];
    float  Fy[NX][NY];                       //forces at grids
    for(int i=0; i<markerCount; ++i)
        UbX[i] = 0.0,                                     //initialising to zero
                UbY[i] = 0.0,
                FbX[i] = 0.0,
                FbY[i] = 0.0;

    for(int i=0; i<NX; i++)
        for(int j=0; j<NY; j++) {
            Fx[i][j] = 0.0;
            Fy[i][j] = 0.0;
        }

    //double radius = a/2.0;
    //iterate all the markers one by one
    for(double theta=0; theta<=360; theta+=lmtheta, b+=1)
    {
        double radiantheta = theta * (pie / 180.0);      //converting angle to radian
        double bX = (g + (a/2.0)*cos(radiantheta));        //calculating x-cordinate of lagrangian marker
        double bY = (f + (a/2.0)*sin(radiantheta));        //calculating y-cordinate of lagrangian marker
        int rbx = round(bX), rby = round(bY);           //rounding it to nearest integer

        //        for(int x=0; x<NX; x++)
        //        {
        //            for(int y=0; y<NY; y++)
        //            {


        int vicinity_map[4][2] = {
            // x,  y
            {-1, 0},  //left
            {+1, 0},  //right
            {0, +1},  //down
            {0, -1},  //up
        };

        int m=0;
        while(m != NF) {

            //iterate over each direction
            int rx, ry; //temp variables to store the coords of nodes in the vicinity of current marker
            for(int i=0; i<4; ++i) {
                //add in either(x or y) coord to move in one of the 4 desired directions
                //Note: we are not skipping any nearby node in any of the 4 directions
                rx = round(bX + vicinity_map[i][0]);
                ry = round(bY + vicinity_map[i][1]);

                double D = delta2(rx, ry, bX, bY);

                UbX[b] += (ux[rx][ry] * D * pow(h, 2)); //unforced velocity interpolation on markers
                UbY[b] += (uy[rx][ry] * D * pow(h, 2));
            }

            //OLD CODE
            //
            //for (int i = rbx - 1; i <= rbx + 1; i++)
            //{
            //    for (int j = rby - 1; j <= rby + 1; j++)
            //      {
            //        double distance = sqrt(pow(i-g, 2) + pow(j-f, 2));

            //
            //        if(distance > radius)                 //checking if the point is outside the circle
            //        {
            //            UbX[b] += (ux[i][j] * D * pow(h, 2));
            //            UbY[b] += (uy[i][j] * D * pow(h, 2));
            //        }
            //    }
            //}


            int Ub = 0;                             //calculating boundary force on markers
//            printf("f: %d, %d: %f\r\n", rbx, rby, rho[rbx][rby]);
            FbX[b] = (2*rho[rbx][rby] * Ub - UbX[b]) ;  //x-component of force on the marker from it's vicinity
            FbY[b] = (2*rho[rbx][rby] * Ub - UbY[b]) ;  //y-component


            for(int i=0; i<4; ++i)
            {
                //add in either(x or y) coord to move in one of the 4 desired directions
                //Note: we are not skipping any nearby node in any of the 4 directions
                rx = round(bX + vicinity_map[i][0/*delta in x-corrd*/]);
                ry = round(bY + vicinity_map[i][1/*delta in y-coord*/]);

                double D = delta2(rx, ry, bX, bY);

                Fx[rx][ry] += FbX[b] * D * dels;            //updating the force on neraby nodes of current markers
                Fy[rx][ry] += FbY[b] * D * dels;
            }

            ///OLD CODE
            //for (int i = rbx - 1; i <= rbx + 1; i++)
            //{
            //    for (int j = rby - 1; j <= rby + 1; j++)
            //  {
            //        double distance = sqrt(pow(i-g, 2) + pow(j-f, 2));

            //
            //        if(distance > radius)                    //checking if the point is outside the circle
            //         {
            //            Fx[i][j] += FbX[b] * D * dels;      //updating the force on nearby nodes of the current marker
            //            Fy[i][j] += FbY[b] * D * dels;
            //        }
            //    }
            //}
            //            }
            //        }

            m = m + 1;
        }
    }


    int dt = 1;
    //CFX = 0;
    //SumFX = 0.0;                                               //calculating updated velocity on grids
    for(int i=0; i<NX; ++i)
    {
        for(int j=0; j<NY; ++j)
         {
//            printf("s: %d, %d: %f\r\n", i, j, rho[i][j]);
            ux[i][j] = ux[i][j] + (dt/(2*rho[i][j]))*Fx[i][j];
            uy[i][j] = uy[i][j] + (dt/(2*rho[i][j]))*Fy[i][j];
            FX[i][j] = Fx[i][j];
            FY[i][j] = Fy[i][j];
            //SumFX += FX[i][j];
            
//            printf("ff: %f, %f", Fx[i][j], Fy[i][j]);
        }
    }

    return;
}

void collision()
{
    int x,y,i;
    double udotc, u2, feq, force_term;

    for(x=0; x<NX; x++)
    {
        for(y=0; y<NY; y++)
        {
            U[x][y]=ux[x][y];
            V[x][y]=uy[x][y];

            if(bnode[x][y] != 1.0)
            {

                for(i=0; i<Q; i++)
                {
                    //U[x][y] = ux[x][y]+(fx*0.5)/rho[x][y];
                    //V[x][y] = uy[x][y]+(fy*0.5)/rho[x][y];

                    udotc = U[x][y]*cx[i]+V[x][y]*cy[i];
                    u2 = U[x][y]*U[x][y]+V[x][y]*V[x][y];

                    force_term = (1.0-0.5/tau)*t[i]*((3.0*(cx[i]-U[x][y])+9.0*cx[i]*(cx[i]*U[x][y]+cy[i]*V[x][y]))*FX[x][y]) + ((3.0*(cy[i]-V[x][y])+9.0*cy[i]*(cx[i]*U[x][y]+cy[i]*V[x][y]))*FY[x][y]) ;

                    feq = rho[x][y]*t[i]*(1+3.0*udotc+4.5*udotc*udotc-1.5*u2);
                    //f1[x][y][i] = f1[x][y][i]-(1.0/tau)*(f1[x][y][i]-feq);
                    f1[x][y][i] = f1[x][y][i]-(1.0/tau)*(f1[x][y][i]-feq) +(force_term);


                    // Compute force for each direction
                    //for (int i = 0; i < Q; i++)
                    //{
                    // Compute deviation of velocity from discrete velocity
                    //double dev = (c[i].x - u.x) / c*c;

                    // Compute dot product of e_i with u
                    //double dot = e[i].x * u.x + e[i].y * u.y + e[i].z * u.z;
                    //dot /= c * c*c*c;

                    // Compute dot product of previous result with e_i
                    //dot *= e[i];

                    // Compute weight factor for direction i
                    //double weight = w[i];

                    // Compute force for direction i
                    //double force = (1.0 - 0.5 * tau) * weight * (3.0 * dev + 9.0 * dot / (c * c * c * c));

                    // Add force to total force
                    //F.x += force * e[i].x;
                    //F.y += force * e[i].y;
                    //F.z += force * e[i].z;
                }
            }


        }
    }
    return ;
}

void streaming()
{


    int x,y,i,newx,newy;
    double rho_inlet, u_outlet;

    /*for(x=0; x<NX; x++)
    {
        for(y=0; y<NY; y++)
        {
            //if(bnode[x][y]!=1.0)
            {
                for(i=0; i<Q; i++)
                {
                    newx = next_x[x][i];
                    newy = next_y[y][i];

                    f1[newx][newy][i] = f2[x][y][i];
                }
            }
        }
    }*/
    for(x=0; x<NX; x++)
    {
        for (y=0; y<NY; y++)
        {
            for (i=0; i<Q; i++)
            {
                newx=next_x[x][i];
                newy=next_y[y][i];
                f2[newx][newy][i] = f1[x][y][i];
            }
        }
    }

    for(x=0; x<NX; x++)
    {
        for (y=0; y<NY; y++)
        {
            for (i=0; i<Q; i++)
            {
                f1[x][y][i]=f2[x][y][i];
            }
        }
    }
    /*------ Standard bounce-back scheme -----------*/
    for(x=0; x<NX; x++)
    {
        for(y=0; y<NY; y++)
        {
            if(y==0)
            {
                f1[x][y][2] = f1[x][y][4];
                f1[x][y][5] = f1[x][y][7];
                f1[x][y][6] = f1[x][y][8];

            }
            if(y==NY-1)
            {
                f1[x][y][4] = f1[x][y][2];
                f1[x][y][7] = f1[x][y][5];
                f1[x][y][8] = f1[x][y][6];
            }
        }
    }

    for (y=0; y<NY; y++)
    {
        rho_inlet = (f1[0][y][0]+f1[0][y][2]+f1[0][y][4]+2.0*(f1[0][y][3]+f1[0][y][6]+f1[0][y][7]))/(1.0-u_inlet);
        f1[0][y][1] = f1[0][y][3]+(2.0/3.0)*rho_inlet*u_inlet;
        f1[0][y][5] = f1[0][y][7]-(1.0/2.0)*(f1[0][y][2]-f1[0][y][4])+(1.0/6.0)*rho_inlet*u_inlet;
        f1[0][y][8] = f1[0][y][6]+(1.0/2.0)*(f1[0][y][2]-f1[0][y][4])+(1.0/6.0)*rho_inlet*u_inlet;
    }

    
    for (y=0; y<NY; y++)
    {
        for(x=NX-1; x<NX; x++)
        {
            u_outlet = -1.0 + (f1[x][y][0]+f1[x][y][2]+f1[x][y][4]+2.0*(f1[x][y][1]+f1[x][y][5]+f1[x][y][8]))/rho0;
            f1[x][y][3] = f1[x][y][1]-(2.0/3.0)*rho0*u_outlet;
            f1[x][y][7] = f1[x][y][5]-(1.0/6.0)*rho0*u_outlet+(1.0/2.0)*(f1[x][y][2]-f1[x][y][4]);
            f1[x][y][6] = f1[x][y][8]-(1.0/6.0)*rho0*u_outlet-(1.0/2.0)*(f1[x][y][4]-f1[x][y][2]);
        }
    }
    return;
}

void data(int data_counter, int id)
{
    int     x, y;
    //double  Cd;
    //double SumFX;
    FILE    *f3;
    char    phase   [100];

    /*  Data for Tecplot*/
    //SumFX = 0.0;
    sprintf ( phase, "IBM_phase%d.dat",id);
    f3 = fopen(phase, "w");
    fprintf( f3, "Variables = X, Y, RHO, U, V, Fx, Fy \n");
    fprintf(f3,"Zone I=   %d,J=   %d,F=POINT\n", NX, NY);
    for (y = NY - 1; y > -1; y--)
    {    for (x = 0; x < NX; x++)
        {
            //SumFX += FX[x][y];
            
            fprintf(f3,"%d\t%d\t%lf\t%lf\t%lf\t%0.10lf\t%0.10lf\n",x,y,rho[x][y],U[x][y],V[x][y],FX[x][y],FY[x][y]);
            fprintf(f3, "\n");

        }

    }
    
    fflush(f3);
    fclose(f3);

    return;
}
void cal_Cd(int data_counter, int id)
{
    int     k,x,y;
    double  SumFX;
    double  Cd;
    
    FILE    *f3;
    char    phase   [100];

    /*  Data for Tecplot*/
    SumFX = 0.0;
    sprintf ( phase, "Cd%d.dat",id);
    f3 = fopen(phase, "w");
    fprintf( f3, "Variables = k, Cd \n");
    fprintf(f3,"Zone I=   %d,J=   %d,F=POINT\n", NX, NY);
    
    for (y = NY - 1; y > -1; y--)
    {    for (x = 0; x < NX; x++)
        {
            SumFX += FX[x][y];

        }
    }
    for(k=99999; k<T; k++)
    {

            Cd = -(SumFX)/(pow(u_inlet,2) * radius);
            fprintf(f3,"%d\t%lf\t%lf\t\n", k,Cd, SumFX);
            

    }

    
 
    

    
    fflush(f3);
    fclose(f3);

    return;
}

/*
void data(int, int)
{       {
        //store output in a file
        FILE    *f3;
        f3 = fopen("IB-LBM_Output.txt", "w");
        fprintf( f3, "Variables = X, Y, RHO, U, V \n");
        //double radius = a/2.0;
        for (int x = 0; x < NX; x++) {
            for (int y=0; y<NY; ++y) {
                //double distance = sqrt(pow(x-g, 2) + pow(x-f, 2));
                //only if the node is outside the circle, we are writing to the file
                //if(distance > radius) {
                fprintf(f3,"%d\t%d\t%lf\t%lf\t%lf\n",x,y,rho[x][y],ux[x][y],uy[x][y]);
                fprintf(f3, "\n");
                //}
            }
        }

        fflush(f3);
        fclose(f3);
        return;
        }
}*/

#include<stdio.h>
#include<math.h>

  /*------ Flow in a Square Channel with a particle in between  ---------*/
#define        NF          1
#define        Re          40.0
#define        u_inlet     0.1036333333 
#define        NX          801   //no. of nodes in the x-direction
#define        NY          801   //no. of nodes in the y-direction

#define        a           40.0    //particle diameter
#define        radius      20.0     //particle radius
#define        g           400.0   // x-coordinate of the center of the spherical particle
#define        f           400.0   // y-coordinate of the center of the spherical particle
#define        lmtheta     2.25  // angular separation of lagrangian marker
#define        Q           9     // no. of direction of velocity vectors (D2Q9 model implemented)
#define        T           100001 // no. of time steps
#define        tau         0.8109  // dimensionless relaxation time due to fluid–particle collisions
#define        visc        (tau-0.5)/3.0 //viscosity
#define        rho0        1.0   // density initialization
//#define      Ht          NY-1.0 //height in vertical direction
#define        pie         3.141592653589 //value of pie
#define        w0          4.0/9.0 // weighting coefficient
#define        w1          1.0/9.0 // weighting coefficients for i = 1,2,3,4
#define        w2          1.0/36.0 // weighting coefficients for i = 5,6,7,8
//#define      Ub          0.0


#define         h           1

//double        CFX;
//int           k;
int             cx          [Q]={0,1,0,-1,0,1,-1,-1,1}; //discrete velocity vectors
int             cy          [Q]={0,0,1,0,-1,1,1,-1,-1}; // discrete velocity vectors
double          t           [Q]={w0,w1,w1,w1,w1,w2,w2,w2,w2};
int             next_x      [NX][Q];
int             next_y      [NY][Q];
double          SumFX;
double          r;
double          FX          [NX][NY];
double          FY          [NX][NY];
double          f1          [NX][NY][Q];    //main probability distribution function
double          f2          [NX][NY][Q];    //temporary PDF
double          rho         [NX][NY];
double          ux          [NX][NY];
double          uy          [NX][NY];
double          U           [NX][NY];
double          V           [NX][NY];
//double        ux_eq       [NX][NY];
//double        uy_eq       [NX][NY];
double          bnode       [NX][NY];
//double        ux_exact    [NY];

void        tables();
void        initialise();
void        cal_obs();
void        IBM();
void        collision();
void        streaming();
void        data(int, int);
void        cal_Cd(int, int);
//void        exact();

int main()
{
    int count = 0, k;
    tables();
    initialise();
    for(k=0; k<T; k++)
    {
        printf("k=%d\r\t",k);
        cal_obs();
        IBM();
        collision();
        streaming();
        
        /*if(k%50000==0)
        {
            data(count, k);
        }*/
        if(k==100000)
        {
            cal_Cd(count, k);
        }
    }

    return 0;
}

void tables()
{
    int x,y,i;

    for(x=0; x<NX; x++)
    {
        for(y=0; y<NY; y++)
        {
            for(i=0; i<Q; i++)
            {
                next_x[x][i] = x + cx[i];

                if(next_x[x][i]<0)
                    next_x [x][i] = NX-1;
                if(next_x[x][i]>(NX-1))
                    next_x[x][i] = 0;

                next_y[y][i] = y + cy[i];

                if(next_y[y][i]<0)
                    next_y [y][i] = NY-1;
                if(next_y[y][i]>(NY-1))
                    next_y[y][i] = 0;
            }
        }
    }

    return ;
}


void initialise()
{
    int x,y,i;

    for(x=0; x<NX; x++)
    {
        for(y=0; y<NY; y++)
        {
            rho[x][y] = rho0;
            ux[x][y] = 0.0; uy[x][y] = 0.0;
            
            for(i=0; i<Q; i++)
            {
                f1[x][y][i] = rho0*t[i];

            }
        }
    }

    for(x=0; x<NX; x++)
    {
        for(y=0; y<NY; y++)
        {
            bnode[x][y] = 0.0;
            if(y==0 || y==(NY-1))
            {
                bnode[x][y] = 1.0;
            }
        }
    }

    return ;
}

double cal_dela(int x, int y, double bX, double bY) {
    double rX = x - bX;                      //x-coordinate difference between the current marker and the current node
    double rY = y - bY;                      //y-coordinate difference between the current marker and the current node

    double arX = fabsf(rX);                  //absolute value of 'r'
    double arY = fabsf(rY);                  // ,,

    double delX = 0, delY = 0;               //calculating delta function

    if(arX >= 0 && arX < 1)
        delX = 1/8.0*(3-(2*arX)+sqrt(1+(4*arX)-(4*arX*arX)));
    if(arX >= 1 && arX < 2)
        delX = 1/8.0*(5-(2*arX)-sqrt(-7+(12*arX)-(4*arX*arX)));
    else // |r| >= 2
        delX = 0;


    if(arY >= 0 && arY < 1)                 //calculating delta function (y);
        delY = 1/8.0*(3-(2*arY)+sqrt(1+(4*arY)-(4*arY*arY)));
    if(arY >= 1 && arY < 2)
        delY = 1/8.0*(5-(2*arY)-sqrt(-7+(12*arY)-(4*arY*arY)));
    else // |r| >= 2
        delY = 0;

    double D = delX * delY;                          //calculation of Eq. No. 26
    return D;
}
double delta2(int x, int y, double bX, double bY)

{

    double D;
    double rX = x - bX;                      //x-coordinate difference between the current marker and the current node
    double rY = y - bY;                      //y-coordinate difference between the current marker and the current node
    double arX = fabs(rX);                  //absolute value of 'r'
    double arY = fabs(rY);
    double delX = 0.0; double delY = 0.0;

    if(arX <= 1)

        delX = 1.0 - arX;

    else

        delX = 0.0;

    

    if(arY <= 1)

        delY = 1.0 - arY;

    else

        delY = 0.0;

    

    D = delX * delY;

    

    return D;

}

void cal_obs()
{
    int x,y,i;
    //double dense;

    for(x=0; x<NX; x++)
    {
        for (y=0; y<NY; y++)
        {
            rho[x][y]=0.0; ux[x][y]=0.0; uy[x][y]=0.0;
            //if(bnode[x][y] !=1.0)
            {
                for (i=0; i<Q; i++)
                {
                    rho[x][y]     += f1[x][y][i];
                    ux[x][y]  += f1[x][y][i]*cx[i];
                    uy[x][y]  += f1[x][y][i]*cy[i];
                }
                //rho[x][y] = dense;
                ux[x][y]  = ux[x][y]/rho[x][y];
                uy[x][y]  = uy[x][y]/rho[x][y];
            }
        }
    }
return;
}

void IBM()
{
    double dels = (a * pie * lmtheta)/360.0;             //arc length calculation

    int b = 0;
    int markerCount = 360/lmtheta;                      //calculating no. of markers
    double UbX[markerCount], UbY[markerCount];           //velocities at markers
    double FbX[markerCount], FbY[markerCount];           //forces at markers
    double Fx[NX][NY];
    float  Fy[NX][NY];                       //forces at grids
    for(int i=0; i<markerCount; ++i)
        UbX[i] = 0.0,                                     //initialising to zero
                UbY[i] = 0.0,
                FbX[i] = 0.0,
                FbY[i] = 0.0;

    for(int i=0; i<NX; i++)
        for(int j=0; j<NY; j++) {
            Fx[i][j] = 0.0;
            Fy[i][j] = 0.0;
        }

    //double radius = a/2.0;
    //iterate all the markers one by one
    for(double theta=0; theta<=360; theta+=lmtheta, b+=1)
    {
        double radiantheta = theta * (pie / 180.0);      //converting angle to radian
        double bX = (g + (a/2.0)*cos(radiantheta));        //calculating x-cordinate of lagrangian marker
        double bY = (f + (a/2.0)*sin(radiantheta));        //calculating y-cordinate of lagrangian marker
        int rbx = round(bX), rby = round(bY);           //rounding it to nearest integer

        //        for(int x=0; x<NX; x++)
        //        {
        //            for(int y=0; y<NY; y++)
        //            {


        int vicinity_map[4][2] = {
            // x,  y
            {-1, 0},  //left
            {+1, 0},  //right
            {0, +1},  //down
            {0, -1},  //up
        };

        int m=0;
        while(m != NF) {

            //iterate over each direction
            int rx, ry; //temp variables to store the coords of nodes in the vicinity of current marker
            for(int i=0; i<4; ++i) {
                //add in either(x or y) coord to move in one of the 4 desired directions
                //Note: we are not skipping any nearby node in any of the 4 directions
                rx = round(bX + vicinity_map[i][0]);
                ry = round(bY + vicinity_map[i][1]);

                double D = delta2(rx, ry, bX, bY);

                UbX[b] += (ux[rx][ry] * D * pow(h, 2)); //unforced velocity interpolation on markers
                UbY[b] += (uy[rx][ry] * D * pow(h, 2));
            }

            //OLD CODE
            //
            //for (int i = rbx - 1; i <= rbx + 1; i++)
            //{
            //    for (int j = rby - 1; j <= rby + 1; j++)
            //      {
            //        double distance = sqrt(pow(i-g, 2) + pow(j-f, 2));

            //
            //        if(distance > radius)                 //checking if the point is outside the circle
            //        {
            //            UbX[b] += (ux[i][j] * D * pow(h, 2));
            //            UbY[b] += (uy[i][j] * D * pow(h, 2));
            //        }
            //    }
            //}


            int Ub = 0;                             //calculating boundary force on markers
//            printf("f: %d, %d: %f\r\n", rbx, rby, rho[rbx][rby]);
            FbX[b] = (2*rho[rbx][rby] * Ub - UbX[b]) ;  //x-component of force on the marker from it's vicinity
            FbY[b] = (2*rho[rbx][rby] * Ub - UbY[b]) ;  //y-component


            for(int i=0; i<4; ++i)
            {
                //add in either(x or y) coord to move in one of the 4 desired directions
                //Note: we are not skipping any nearby node in any of the 4 directions
                rx = round(bX + vicinity_map[i][0/*delta in x-corrd*/]);
                ry = round(bY + vicinity_map[i][1/*delta in y-coord*/]);

                double D = delta2(rx, ry, bX, bY);

                Fx[rx][ry] += FbX[b] * D * dels;            //updating the force on neraby nodes of current markers
                Fy[rx][ry] += FbY[b] * D * dels;
            }

            ///OLD CODE
            //for (int i = rbx - 1; i <= rbx + 1; i++)
            //{
            //    for (int j = rby - 1; j <= rby + 1; j++)
            //  {
            //        double distance = sqrt(pow(i-g, 2) + pow(j-f, 2));

            //
            //        if(distance > radius)                    //checking if the point is outside the circle
            //         {
            //            Fx[i][j] += FbX[b] * D * dels;      //updating the force on nearby nodes of the current marker
            //            Fy[i][j] += FbY[b] * D * dels;
            //        }
            //    }
            //}
            //            }
            //        }

            m = m + 1;
        }
    }


    int dt = 1; 
    //CFX = 0; 
    //SumFX = 0.0;                                               //calculating updated velocity on grids
    for(int i=0; i<NX; ++i)
    {
        for(int j=0; j<NY; ++j)
         {
//            printf("s: %d, %d: %f\r\n", i, j, rho[i][j]);
            ux[i][j] = ux[i][j] + (dt/(2*rho[i][j]))*Fx[i][j];
            uy[i][j] = uy[i][j] + (dt/(2*rho[i][j]))*Fy[i][j];
            FX[i][j] = Fx[i][j];
            FY[i][j] = Fy[i][j];
            //SumFX += FX[i][j];
            
//            printf("ff: %f, %f", Fx[i][j], Fy[i][j]);
        }
    }

    return;
}

void collision()
{
    int x,y,i;
    double udotc, u2, feq, force_term;

    for(x=0; x<NX; x++)
    {
        for(y=0; y<NY; y++)
        {
            U[x][y]=ux[x][y];
            V[x][y]=uy[x][y];

            if(bnode[x][y] != 1.0)
            {

                for(i=0; i<Q; i++)
                {
                    //U[x][y] = ux[x][y]+(fx*0.5)/rho[x][y];
                    //V[x][y] = uy[x][y]+(fy*0.5)/rho[x][y];

                    udotc = U[x][y]*cx[i]+V[x][y]*cy[i];
                    u2 = U[x][y]*U[x][y]+V[x][y]*V[x][y];

                    force_term = (1.0-0.5/tau)*t[i]*((3.0*(cx[i]-U[x][y])+9.0*cx[i]*(cx[i]*U[x][y]+cy[i]*V[x][y]))*FX[x][y]) + ((3.0*(cy[i]-V[x][y])+9.0*cy[i]*(cx[i]*U[x][y]+cy[i]*V[x][y]))*FY[x][y]) ;

                    feq = rho[x][y]*t[i]*(1+3.0*udotc+4.5*udotc*udotc-1.5*u2);
                    //f1[x][y][i] = f1[x][y][i]-(1.0/tau)*(f1[x][y][i]-feq);
                    f1[x][y][i] = f1[x][y][i]-(1.0/tau)*(f1[x][y][i]-feq) +(force_term);


                    // Compute force for each direction
                    //for (int i = 0; i < Q; i++)
                    //{
                    // Compute deviation of velocity from discrete velocity
                    //double dev = (c[i].x - u.x) / c*c;

                    // Compute dot product of e_i with u
                    //double dot = e[i].x * u.x + e[i].y * u.y + e[i].z * u.z;
                    //dot /= c * c*c*c;

                    // Compute dot product of previous result with e_i
                    //dot *= e[i];

                    // Compute weight factor for direction i
                    //double weight = w[i];

                    // Compute force for direction i
                    //double force = (1.0 - 0.5 * tau) * weight * (3.0 * dev + 9.0 * dot / (c * c * c * c));

                    // Add force to total force
                    //F.x += force * e[i].x;
                    //F.y += force * e[i].y;
                    //F.z += force * e[i].z;
                }
            }


        }
    }
    return ;
}

void streaming()
{


    int x,y,i,newx,newy;
    double rho_inlet, u_outlet;

    /*for(x=0; x<NX; x++)
    {
        for(y=0; y<NY; y++)
        {
            //if(bnode[x][y]!=1.0)
            {
                for(i=0; i<Q; i++)
                {
                    newx = next_x[x][i];
                    newy = next_y[y][i];

                    f1[newx][newy][i] = f2[x][y][i];
                }
            }
        }
    }*/
    for(x=0; x<NX; x++)
    {
        for (y=0; y<NY; y++)
        {
            for (i=0; i<Q; i++)
            {
                newx=next_x[x][i];
                newy=next_y[y][i];
                f2[newx][newy][i] = f1[x][y][i];
            }
        }
    }

    for(x=0; x<NX; x++)
    {
        for (y=0; y<NY; y++)
        {
            for (i=0; i<Q; i++)
            {
                f1[x][y][i]=f2[x][y][i];
            }
        }
    }
    /*------ Standard bounce-back scheme -----------*/
    for(x=0; x<NX; x++)
    {
        for(y=0; y<NY; y++)
        {
            if(y==0)
            {
                f1[x][y][2] = f1[x][y][4];
                f1[x][y][5] = f1[x][y][7];
                f1[x][y][6] = f1[x][y][8];

            }
            if(y==NY-1)
            {
                f1[x][y][4] = f1[x][y][2];
                f1[x][y][7] = f1[x][y][5];
                f1[x][y][8] = f1[x][y][6];
            }
        }
    }

    for (y=0; y<NY; y++)
	{
		rho_inlet = (f1[0][y][0]+f1[0][y][2]+f1[0][y][4]+2.0*(f1[0][y][3]+f1[0][y][6]+f1[0][y][7]))/(1.0-u_inlet);
		f1[0][y][1] = f1[0][y][3]+(2.0/3.0)*rho_inlet*u_inlet;
		f1[0][y][5] = f1[0][y][7]-(1.0/2.0)*(f1[0][y][2]-f1[0][y][4])+(1.0/6.0)*rho_inlet*u_inlet;
		f1[0][y][8] = f1[0][y][6]+(1.0/2.0)*(f1[0][y][2]-f1[0][y][4])+(1.0/6.0)*rho_inlet*u_inlet;
	}

	
	for (y=0; y<NY; y++)
	{
		for(x=NX-1; x<NX; x++)
		{
			u_outlet = -1.0 + (f1[x][y][0]+f1[x][y][2]+f1[x][y][4]+2.0*(f1[x][y][1]+f1[x][y][5]+f1[x][y][8]))/rho0;
			f1[x][y][3] = f1[x][y][1]-(2.0/3.0)*rho0*u_outlet;
			f1[x][y][7] = f1[x][y][5]-(1.0/6.0)*rho0*u_outlet+(1.0/2.0)*(f1[x][y][2]-f1[x][y][4]);
			f1[x][y][6] = f1[x][y][8]-(1.0/6.0)*rho0*u_outlet-(1.0/2.0)*(f1[x][y][4]-f1[x][y][2]);
		}
	}
    return;
}

void data(int data_counter, int id)
{
    int     x, y;
    //double  Cd;
    //double SumFX;
    FILE    *f3;
    char    phase   [100];

    /*  Data for Tecplot*/
    //SumFX = 0.0;
    sprintf ( phase, "IBM_phase%d.dat",id);
    f3 = fopen(phase, "w");
    fprintf( f3, "Variables = X, Y, RHO, U, V, Fx, Fy \n");
    fprintf(f3,"Zone I=   %d,J=   %d,F=POINT\n", NX, NY);
    for (y = NY - 1; y > -1; y--)
    {    for (x = 0; x < NX; x++)
        {
            //SumFX += FX[x][y];
            
            fprintf(f3,"%d\t%d\t%lf\t%lf\t%lf\t%0.10lf\t%0.10lf\n",x,y,rho[x][y],U[x][y],V[x][y],FX[x][y],FY[x][y]);
            fprintf(f3, "\n");

        }

    }
    
    fflush(f3);
    fclose(f3);

    return;
}
void cal_Cd(int data_counter, int id)
{
    int     k,x,y;
    double  SumFX;
    double  Cd;
    
    FILE    *f3;
    char    phase   [100];

    /*  Data for Tecplot*/
    SumFX = 0.0;
    sprintf ( phase, "Cd%d.dat",id);
    f3 = fopen(phase, "w");
    fprintf( f3, "Variables = k, Cd \n");
    fprintf(f3,"Zone I=   %d,J=   %d,F=POINT\n", NX, NY);
    
    for (y = NY - 1; y > -1; y--)
    {    for (x = 0; x < NX; x++)
        {
            SumFX += FX[x][y];

        }
    }
    for(k=99999; k<T; k++)
    {

            Cd = -(SumFX)/(pow(u_inlet,2) * radius);
            fprintf(f3,"%d\t%lf\t%lf\t\n", k,Cd, SumFX);
            

    }   

    
 
    

    
    fflush(f3);
    fclose(f3);

    return;
}

/*
void data(int, int)
{       {
        //store output in a file
        FILE    *f3;
        f3 = fopen("IB-LBM_Output.txt", "w");
        fprintf( f3, "Variables = X, Y, RHO, U, V \n");
        //double radius = a/2.0;
        for (int x = 0; x < NX; x++) {
            for (int y=0; y<NY; ++y) {
                //double distance = sqrt(pow(x-g, 2) + pow(x-f, 2));
                //only if the node is outside the circle, we are writing to the file
                //if(distance > radius) {
                fprintf(f3,"%d\t%d\t%lf\t%lf\t%lf\n",x,y,rho[x][y],ux[x][y],uy[x][y]);
                fprintf(f3, "\n");
                //}
            }
        }

        fflush(f3);
        fclose(f3);
        return;
        }
}*/

#include<stdio.h>
#include<conio.h>

int main(){
    int a[3][3],b[3][3],c[3][3];
    int i,j,k;
    int temp = 0;

    printf("Plz., enter the values of first matrix: ");
    for ( i = 0; i < 3; i++)
    {
        for ( j = 0; j < 3; j++)
        {
            printf("a[%d][%d] = ",i,j);
            scanf("%d",&a[i][j]);
        }
    }
    for ( i = 0; i < 3; i++)
    {
        printf("|   ");
        for ( j = 0; j < 3; j++)
        {
            printf("%d  ",a[i][j]);
        }
        printf("    | \n");
    }


    printf("Plz., enter the values of second matrix: ");
    for ( i = 0; i < 3; i++)
    {
        for ( j = 0; j < 3; j++)
        {
            printf("b[%d][%d] = ",i,j);
            scanf("%d",&b[i][j]);
        }
    }

    for ( i = 0; i < 3; i++)
    {
        printf("|   ");
        for ( j = 0; j < 3; j++)
        {
            printf("%d  ",a[i][j]);
        }
        printf("    | \n");
    }


    printf("The multiplication of the given matrix is: ");

    for ( i = 0; i < 3; i++)
    {
        for ( j = 0; j < 3; j++)
        {
            for ( k = 0; k < 3; k++)
            {
                temp = 0;
                temp += a[i][k]*b[k][j];
            }
            c[i][j] += temp;
        }
    }

    for ( i = 0; i < 3; i++)
    {
        printf("|   ");
        for ( j = 0; j < 3; j++)
        {
            printf("%d  ",c[i][j]);
        }
        printf("    | \n");
    }
}

#include<stdio.h>
#include<conio.h>

void main(){
    int a[3][3],b[3][3];
    int i,j;
    printf("\n Plz., enter values of two matrix to add them...");
    printf("\n Enter values of first matrix: ");

    for ( i = 0; i < 3; i++)
    {
        for ( j = 0; j < 3; j++)
        {
            scanf("%d",&a[i][j]);
        }
    }

            for ( i = 0; i < 3; i++)
    {
        printf("|");
        for ( j = 0; j < 3; j++)
        {
            printf("\t %d",a[i][j]);
        }
        printf("\t |");
        printf("\n");
    }

    printf("\n Enter the value of second matrix: ");

    for ( i = 0; i < 3; i++)
    {
        for ( j = 0; j < 3; j++)
        {
            scanf("%d",&b[i][j]);
        }
    }

        for ( i = 0; i < 3; i++)
    {
        printf("|");
        for ( j = 0; j < 3; j++)
        {
            printf("\t %d",a[i][j]);
        }
        printf("\t |");
        printf("\n");
    }

    printf("\n");
    printf("The summation of two matrix: ");

    for ( i = 0; i < 3; i++)
    {
        printf("|");
        for ( j = 0; j < 3; j++)
        {
            printf("\t %d",(a[i][j]+b[i][j]));
        }
        printf("\t |");
        printf("\n");
    }
}

#include<stdio.h>
#include<conio.h>

void main(){
    int age;
    read:
        printf("Plz., enter your age, if you are not a chhote bachhi = ");
    scanf("%d", &age);

    if (age>=18)
    {
        printf("You are eligibe to vote. \n");
    }
    else
    {
        printf("Chhote bacchi ho kya ? \n");
    }
    goto read;
    }
}

#include<stdio.h>
#include<conio.h>

void main(){
    int age,x=1;

while (x=1)
{
    printf("\n Plz., enter your age, if you are not a chhote bacchi = ");
    scanf("%d",&age);
    age>=18?(printf("You are eligible for vote.")):(printf("Chhote bacchi ho kya."));
}
}

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

void main(){
    unsigned int x,year;
    system("clear");
    read:
        printf("Plz., enter any year:");
    scanf("%d",&year);
    if (year%4==0)
    {
        printf("You have enter a leap year. \n");
    }
    else{
        printf("You have enter a normal year. \n");
    }
    goto read;
    }

#include"stdio.h"
#include"conio.h"

int main(){
    int a,b=1;
    printf("Plz., enter any number to print table : ");
    scanf("%d",&a);

    for ( b = 1; b <= 10; b++)
    {
        printf("%d * %d = %d \n",a,b,(a*b));
    }
}

#include<stdio.h>
#include<conio.h>

int main(){
    int a,b,c;
    printf("Enter the values of two variables to swap them with each other... \n");
    printf("The value of a: ");
    scanf("%d",&a);
    printf("The value of b: ");
    scanf("%d",&b);

    a = a + b;
    b = a - b;
    a = a - b;

    printf("The value of a: %d \n",a);
    printf("The value of b: %d",b);
}

int main()
{
    int a;
    printf("Enter the max number upto which you have to list all prime number: ");
    scanf("%d", &a);

    for (int i = 1; i <= a; i++)
    {
        for (int j = 2; j <= (i - 1); j++)
        {
            if ((i % 2) != 0)
            {
                printf("%d \n", i);
                break;
            }
        }
    }
}

#include <stdio.h>
#include <conio.h>

int main()
{
    int num, i;
    int flag;
    flag = 0;
    printf("Plz., enter any number to check, it is prime number or not... \n");
    printf("Pz., enter any number: ");
    scanf("%d", &num);

    for (i = 2; i <= (num - 1); i++)
    {
        if (num % i == 0)
        {
            printf("The given %d is non-prime number.", num);
            flag = 0;
            break;
        }
        flag = 1;
    }

    if (flag == 1)
    {
        printf("You have enter a prime number.");
    }
}

#include<stdio.h>
#include<conio.h>

int main(){
    int power(int ,int);
    int result;
    int a,b;
    printf("Plz., enter a number: ");
    scanf("%d",&a);

    printf("Plz., enter power of the number: ");
    scanf("%d",&b);

    result = power(a,b);
    printf("%d to the power of %d is: %d",a,b,result);
}

int power(int a,int b)
{
    int i,j,result;
    result = a;
    for ( i = 1; i <= b; i++){
        if(i != 1)
        {
            a = result*a;
        }
    }
    return(a);
}

#include <stdio.h>
#include <conio.h>

int array = 3;
int main()
{
    int a[2][2];
    int i, j;
    printf("Plz., enter the values of matrix: ");

    for (i = 0; i < array; i++)
    {
        for (j = 0; j < array; j++)
        {
            printf("a[%d][%d] = ", i, j);
            scanf("%d",&a[i][j]);
        }
    }

    for (i = 0; i < 3; i++)
    {
        printf("|\t");
        for (j = 0; j < 3; j++)
        {
            printf("%d ",a[i][j]);
        }
        printf("\t|\n");
    }
}

#include<stdio.h>
#include<conio.h>

int main(){
    int a,b,opt;
    printf("For sum press : 1 \n For sub press : 2 \n For mul press : 3 \n For div press : 4 \n");
    printf("Plz., choose a option to perform any mathematcal operaton: ");
    again:
    scanf("%d",&opt);

    switch (opt)
    {
    case 1:
        printf("Enter your first no. : ");
        scanf("%d",&a);
        printf("Enter your second no. : ");
        scanf("%d",&b);
        printf("The sum of %d and %d is %d",a,b,(a+b));
        break;

    case 2:
        printf("Enter your first no. : ");
        scanf("%d",&a);
        printf("Enter your second no. : ");
        scanf("%d",&b);
        printf("The sum of %d and %d is %d",a,b,(a-b));
        break;

    case 3:
        printf("Enter your first no. : ");
        scanf("%d",&a);
        printf("Enter your second no. : ");
        scanf("%d",&b);
        printf("The mul of %d and %d is %d",a,b,(a*b));
        break;

    case 4:
        printf("Enter your first no. : ");
        scanf("%d",&a);
        printf("Enter your second no. : ");
        scanf("%d",&b);
        printf("The div of %d and %d is %d",a,b,(a/b));
        break;
    
    
    default:
        printf("Plz., choose a valid option... \n");
        goto again;
        break;
    }
}

#include<stdio.h>
#include<conio.h>

int main(){
    char c;
    printf("Plz., enter any character: ");
    scanf("%c",&c);
    printf("%d",c);
}

#include <stdio.h>
#include <conio.h>

#define PI 3.14159
float cal(float radius);
int main()
{
    int i;
    float area, radius;

    printf("To stop program insert value of radius = 0...");
    printf("\n Radius of circle: ");
    scanf("%f", &radius);

    for (i = 0; radius != 0; i++)
    {
        if (radius < 0)
        {
            area = 0;
        }
        else
        {
            area = cal(radius);
        }
        printf("Area of Circle is %f \n", area);
        scanf("%f", &radius);
    }
}

float cal(float r)
{
    float a;
    a = PI * r * r;
    return (a);
}

#include <stdio.h>
#include<stdlib.h>
struct node
{
    int data;
    struct node *next;

}*front=NULL,*rear=NULL;
void enq(int key)
{
    struct node *t;
    t=(struct node*)malloc(sizeof(struct node));
    if(t==NULL)
      printf("queue is full");
    else
    {
        t->data=key;
        t->next=NULL;
        if(front==NULL)
          front=rear=t;
        else
         {
             rear->next=t;
             rear=t;
         }
    }

}
int deq()
{
    int x=-1;
    struct node *t;
    if(front==NULL)
    {
        printf("queue is empty");

    }
    else
    {
         x=front->data;
        t=front;

        front=front->next;
        free(t);
    }
    return x;
}
int qempty()
{
    return front==NULL;
}
void BFS(int G[7][7],int s,int n)
{
    int i=s,j;
    int vis[7]={0};
    vis[i]=1;
    printf("%d ",i);
    enq(i);
    while(!qempty())
    {
        i=deq();

        for(int j=1;j<n;j++)
        {
            if(G[i][j]==1 && vis[j]==0)
            {
                 vis[j]=1;
                 printf("%d ",j);
                 enq(j);
            }
        }
    }
}
void dfs(int G[7][7],int s,int n)
{
    static int vis[7]={0};
    int j;
    if(vis[s]==0)
    {
        printf("%d ",s);
        vis[s]=1;
        for(int j=1;j<n;j++)
        {
            if(G[s][j]==1 &&vis[j]==0)
                dfs(G,j,n);
        }

    }
}
int main()
{


int G[7][7]={{0,0,0,0,0,0,0},
             {0,0,1,1,0,0,0},
             {0,1,0,0,1,0,0},
             {0,1,0,0,1,0,0},
             {0,0,1,1,0,1,1},
             {0,0,0,0,1,0,0},
            {0,0,0,0,1,0,0}};
           dfs(G,4,7);
}

#include <stdio.h>
#include<stdlib.h>
struct node
{
    int data;
    struct node *next;

}*front=NULL,*rear=NULL;
void enq(int key)
{
    struct node *t;
    t=(struct node*)malloc(sizeof(struct node));
    if(t==NULL)
      printf("queue is full");
    else
    {
        t->data=key;
        t->next=NULL;
        if(front==NULL)
          front=rear=t;
        else
         {
             rear->next=t;
             rear=t;
         }
    }

}
int deq()
{
    int x=-1;
    struct node *t;
    if(front==NULL)
    {
        printf("queue is empty");

    }
    else
    {
         x=front->data;
        t=front;

        front=front->next;
        free(t);
    }
    return x;
}
int qempty()
{
    return front==NULL;
}
void BFS(int G[7][7],int s,int n)
{
    int i=s,j;
    int vis[7]={0};
    vis[i]=1;
    printf("%d ",i);
    enq(i);
    while(!qempty())
    {
        i=deq();

        for(int j=1;j<n;j++)
        {
            if(G[i][j]==1 && vis[j]==0)
            {
                 vis[j]=1;
                 printf("%d ",j);
                 enq(j);
            }
        }
    }
}
int main()
{


int G[7][7]={{0,0,0,0,0,0,0},
             {0,0,1,1,0,0,0},
             {0,1,0,0,1,0,0},
             {0,1,0,0,1,0,0},
             {0,0,1,1,0,1,1},
             {0,0,0,0,1,0,0},
            {0,0,0,0,1,0,0}};
           BFS(G,4,7);
}

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


struct Node
{
   int data;
   struct Node*next;
};

struct Node * top = NULL;

void LinklistTraversal(struct Node * ptr){
    while(ptr!= NULL){
        printf("Element : %d \n",ptr->data);
        ptr = ptr->next;
    }
}
int isEmpty(struct Node * top)
{
    if (top == NULL){
        return 1;
    }
    else
    {
        return 0;
    }
}


int isFull(struct Node* top)
{
    struct Node * p = (struct Node *)malloc(sizeof(struct Node));
    if (p == NULL){
        return 1;
    }
    else

    {
       return 0;
    }
}

struct Node * push(struct Node* top,int x){
    if (isFull(top))
    {
        printf("Its overflow\n");
    }
    else{
        struct Node *n =(struct Node *)malloc(sizeof(struct Node));
        n->data =x;
        n->next=top;
        top=n;
        return top;
    }
    
}


int pop(struct Node * tp){
    if (isEmpty(tp))
    {
        printf("Its underflow\n");
    }
    else{
        struct Node* n=tp;
        top= (tp)->next;
        int x = n->data;
        free(n);
        return x;

    }
    
}



int main(){
    top = push(top,17);   
    top = push(top,19);   
    top = push(top,27);   
    top = push(top,22);   
    top = push(top,24);    
    top = push(top,21);   


    int element =pop(top);
    printf("Popped element is %d\n",element);

    LinklistTraversal(top); 
    return 0;
}

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

struct stack
{
   int size;
   int top;
   int *arr;
};

int isEmpty(struct stack * ptr){
    if ( ptr->top == -1){
        return 1;
    }
    return 0;
}

int isfull(struct stack *ptr){
    if(ptr->top == ptr->size-1){
       return 1;
    }
    return 0;
}

void push(struct stack *ptr, int value ){
    if (isfull(ptr)){
        printf("stack overflow!\n");
    }
    else{
        ptr->top++;
        ptr->arr[ptr->top] =value;
    }
}


int pop(struct stack *ptr){
    if(isEmpty(ptr)){
        printf("Underflow!");
    }
    else{
        int value  =  ptr->arr[ptr->top];
        ptr-> top--;
        return value;
    }

}

int peek(struct stack * sp ,int i){
    int index = sp -> top- i +1;
    if(index < 0){
        printf("invalid");
        return -1;

    }
    else{
        return sp->arr[index];
    }
}

int stacktop(struct stack * sp){
    return sp->arr[sp->top];
}

int bottom(struct stack * sp){
    return sp->arr[0];

}

int main(){
    struct stack * sp= (struct stack *)malloc(sizeof(struct stack));
    sp->size = 15;
    sp->top=-1;
    sp->arr=(int*)malloc(sp->size*sizeof(int));
    printf("Stack is succesfully created \n");

    push(sp,8);
    push(sp,1);
    push(sp,21);
    push(sp,4);
    push(sp,34);
    push(sp,56);
    push(sp,24);
    push(sp,19);
    push(sp,27);
    push(sp,14);
    push(sp,33);
 
    //pop(sp);

    //printf("Element popped: %d \n",pop(sp));

    for (int j = 1; j < sp -> top+2; j++)
    {
       printf("The value at point %d is %d\n",j,peek(sp,j));
    }

    printf("The top most element in the stack is %d\n",stacktop(sp));
    printf("The bottom element in the stack is %d \n",bottom(sp));

    return 0;
}

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

struct stack
{
   int size;
   int top;
   int *arr;
};

int isEmpty(struct stack * ptr){
    if ( ptr->top == -1){
        return 1;
    }
    return 0;
}

int isfull(struct stack *ptr){
    if(ptr->top == ptr->size-1){
       return 1;
    }
    return 0;
}

void push(struct stack *ptr, int value ){
    if (isfull(ptr)){
        printf("stack overflow!\n");
    }
    else{
        ptr->top++;
        ptr->arr[ptr->top] =value;
    }
}


int pop(struct stack *ptr){
    if(isEmpty(ptr)){
        printf("Underflow!");
    }
    else{
        int value  =  ptr->arr[ptr->top];
        ptr-> top--;
        return value;
    }

}

int peek(struct stack * sp ,int i){
    int index = sp -> top- i +1;
    if(index < 0){
        printf("invalid");
        return -1;

    }
    else{
        return sp->arr[index];
    }
}

int stacktop(struct stack * sp){
    return sp->arr[sp->top];
}

int bottom(struct stack * sp){
    return sp->arr[0];

}

int main(){
    struct stack * sp= (struct stack *)malloc(sizeof(struct stack));
    sp->size = 15;
    sp->top=-1;
    sp->arr=(int*)malloc(sp->size*sizeof(int));
    printf("Stack is succesfully created \n");

    push(sp,8);
    push(sp,1);
    push(sp,21);
    push(sp,4);
    push(sp,34);
    push(sp,56);
    push(sp,24);
    push(sp,19);
    push(sp,27);
    push(sp,14);
    push(sp,33);
 
    //pop(sp);

    //printf("Element popped: %d \n",pop(sp));

    for (int j = 1; j < sp -> top+2; j++)
    {
       printf("The value at point %d is %d\n",j,peek(sp,j));
    }

    printf("The top most element in the stack is %d\n",stacktop(sp));
    printf("The bottom element in the stack is %d \n",bottom(sp));

    return 0;
}

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

struct queue{
    int size;
    int f;
    int r;
    int *arr;
};

int isEmpty(struct queue *q){
    if (q->r == q->f )
    {
        return 1;
    }
    return 0;
}

int isFull(struct queue *q){
    if (q->r==q->size-1)
    {
        return 1;
    }
    return 0;
}

void enqueue(struct queue *q , int value){
    if (isFull(q))
    {
        printf("Its full\n");
    }
    else{
        q->r++;
        q->arr[q->r]=value;
        printf("Enqueued element : %d\n",value);
    }
    
}

int dequeue(struct queue *q){
    int a = -1;
    if(isEmpty(q)){
        printf("Its empty \n");
    }
    else{
        q->f++;
        a=q->arr[q->f];
    }
    return a;

}

int main(){
    struct queue q;
    q.size = 4;
    q.f = q.r = -1;
    q.arr = (int*)malloc(q.size*sizeof(int));

    enqueue(&q,17);
    enqueue(&q,9);
    enqueue(&q,2001);
    enqueue(&q,27);

   printf("%d\n",dequeue(&q));
    printf("%d\n",dequeue(&q));
    printf("%d\n",dequeue(&q));
    printf("%d\n",dequeue(&q));
    

    if (isEmpty(&q))
    {
        printf("Queue is empty\n");
    }
    if(isFull(&q)){
        printf("Queue is  full \n");
    }


    return 0;
}

#include <stdio.h>

void printArray(int *a, int n)
{
    for (int i = 0; i < n; i++)
    {
        printf("%d ", a[i]);
    }
    printf("\n ");
}

int partition(int a[], int low, int high)
{
    int pivot = a[low];
    int i = low + 1;
    int j = high;
    int temp;
    do
    {
        while (a[i] <= pivot)
        {
            i++;
        }
        while (a[j] > pivot)
        {
            j--;
        }
        if (i < j)
        {
            temp = a[i];
            a[i] = a[j];
            a[j] = temp;
        }
    } while (i < j);

    temp = a[low];
    a[low] = a[j];
    a[j] = temp;
    return j;
}

void quicksort(int a[], int low, int high)
{
    int partitionindex;

    if (low < high)
    {
        partitionindex = partition(a, low, high);
        quicksort(a, low, partitionindex - 1);
        quicksort(a, partitionindex + 1, high);
    }
}

int main()
{
    // int a[] = {56, 67, 6, 98, 9, 0, 7, 12};
    int a[] = {1, 5, 3, 23, 4, 9};
    int n = 6;
    printArray(a, n);
    quicksort(a, 0, n - 1);
    printArray(a, n);
    return 0;
}

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

struct stack
{
    int top;
    int size;
    int *arr;
};

int isEmpty(struct stack *ptr)
{
    if (ptr->top == -1)
    {
        return 1;
    }
    return 0;
}

int isFull(struct stack *ptr)
{
    if (ptr->top == ptr->size - 1)
    {
        return 1;
    }
    return 0;
}

void push(struct stack *ptr, int value)
{
    if (isFull(ptr))
    {
        printf("The stack is Overflow");
    }
    else
    {
        ptr->top++;
        ptr->arr[ptr->top] = value;
    }
}

char pop(struct stack *ptr)
{
    if (isEmpty(ptr))
    {
        printf("The stack is underflow");
    }
    else
    {
        char value = ptr->arr[ptr->top];
        ptr->top--;
        return value;
    }
}

char checkpranthesis(char *exp)
{
    struct stack *sp ;
    sp->size = 15;
    sp->top = -1;
    sp->arr = (char *)malloc(sp->size * sizeof(char));
    printf("Stack is succesfully created \n");

    for (int i = 0; exp[i] != '\0'; i++)
    {
        if (exp[i] == '(')
        {
            push(sp, '(');
        }
        else if (exp[i] == ')')
        {
            if (isEmpty(sp))
            {
                return 0;
            }
            pop(sp);
        }
    }
    if (isEmpty(sp))
    {
        return 1;
    }
    else
    {
        return 0;
    }
}

int main()
{
    char *exp = "(6+7)-((9*(8))";
    if (checkpranthesis(exp))
    {
        printf("It is matching");
    }
    else
    {
        printf("It is not matching");
    }

    return 0;
}

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

struct stack
{
    int size;
    int top;

    char *arr;
};

int stackTop(struct stack *sp)
{
    return sp->arr[sp->top];
}

int isEmpty(struct stack *ptr)
{
    if (ptr->top == -1)
    {
        return 1;
    }
    else
    {
        return 0;
    }
}

int isFull(struct stack *ptr)
{
    if (ptr->top == ptr->size - 1)
    {
        return 1;
    }
    else
    {
        return 0;
    }
}
void push(struct stack *ptr, char val)
{
    if (isFull(ptr))
    {
        printf("Stack Overflow !", val);
    }
    else
    {
        ptr->top++;
        ptr->arr[ptr->top] = val;
    }
}

char pop(struct stack *ptr)
{
    if (isEmpty(ptr))
    {
        printf("Stack Underflow!!");
        return -1;
    }
    else
    {
        char val = ptr->arr[ptr->top];
        ptr->top--;
        return val;
    }
}


int precedence(char ch)
{
    if (ch == '*' || ch == '/')
        return 3;
    else if (ch == '+' || ch == '-')
        return 2;
    else
        return 0;
}

int isOperator(char ch)
{
    if (ch == '+' || ch == '-' || ch == '*' || ch == '/')
        return 1;
    else
        return 0;
}

char *infixToPostfix(char *infix)
{
    struct stack *sp = (struct stack *)malloc(sizeof(struct stack));
    sp->size = 10;
    sp->top = -1;
    sp->arr = (char *)malloc(sp->size * sizeof(char));
    char *postfix = (char *)malloc((strlen(infix) + 1) * sizeof(char));
    int i = 0;
    int j = 0;

    while (infix[i] != '\0')
    {
        if (!isOperator(infix[i]))
        {
            postfix[j] = infix[i];
            j++;
            i++;
        }
        else
        {
            if (precedence(infix[i]) > precedence(stackTop(sp))){
                push(sp, infix[i]);
                i++;
            }
            else{
                postfix[j] = pop(sp);
                j++;
            }
        }
    }
    
    
    while (!isEmpty(sp))
    {
        postfix[j] = pop(sp);
        j++;
    }
    postfix[j] = '\0';
    return postfix;
}

int main()
{
    char *infix = "s-y/z-k*d";
    printf("Postfix is %s \n", infixToPostfix(infix));
    // Topostfix(infix);

    return 0;
}

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

struct stack
{
    int top;
    int size;
    int *arr;
};

char stackTop(struct stack* sp){
    return sp->arr[sp->top];
}

int match(char a, char b){
    if(a=='{' && b == '}'){
        return 1;
    }
    if(a=='[' && b == ']'){
        return 1;
    }
    if(a=='(' && b == ')'){
        return 1;
    }
  return 0;
}


int isEmpty(struct stack *ptr)
{
    if (ptr->top == -1)
    {
        return 1;
    }
    return 0;
}

int isFull(struct stack *ptr)
{
    if (ptr->top == ptr->size - 1)
    {
        return 1;
    }
    return 0;
     return 0;
}

void push(struct stack *ptr, int value)
{
    if (isFull(ptr))
    {
        printf("The stack is Overflow");
    }
    else
    {
        ptr->top++;
        ptr->arr[ptr->top] = value;
    }
}

char pop(struct stack *ptr)
{
    if (isEmpty(ptr))
    {
        printf("The stack is underflow");
    }
    else
    {
        char value = ptr->arr[ptr->top];
        ptr->top--;
        return value;
    }
}

char checkpranthesis(char *exp)
{
    struct stack *sp ;
    sp->size = 15;
    sp->top = -1;
    sp->arr = (char *)malloc(sp->size * sizeof(char));
    printf("Stack is succesfully created \n");

    char popped_ch;

    for (int i = 0; exp[i] != '\0'; i++)
    {
        if (exp[i] == '('|| exp[i]=='{' || exp[i]=='[')
        {
            push(sp, exp[i]);
        }
        else if (exp[i] == ')' || exp[i]=='}' || exp[i]==']')
        {
            if (isEmpty(sp))
            {
                return 0;
            }
            popped_ch = pop(sp);
            if(!match((popped_ch),exp[i])){
                return 0;
            }
        }
    }
    if (isEmpty(sp))
    {
        return 1;
    }
    else
    {
        return 0;
    }
}

int main()
{
    char *exp = "(6+7)-((9*(8))}";
    if (checkpranthesis(exp))
    {
        printf("It is matching");
    }
    else
    {
        printf("It is not matching");
    }

    return 0;
}

#include <stdio.h>

void printArary(int *a, int n)
{
    for (int i = 0; i < n; i++)
    {
        printf("%d ", a[i]);
    }
    printf("\n");
}

void merge(int a[], int mid, int low, int high)
{
    int i, j, k, b[100];
    i = low;
    j = mid + 1;
    k = low;

    while (i <= mid && j <= high)
    {
        if (a[i] < a[j])
        {
            b[k] = a[i];
            i++;
            k++;
        }
        else
        {
            b[k] = a[j];
            j++;
            k++;
        }
    }
    while (i <= mid)
    {
        b[k] = a[i];
        k++;
        i++;
    }

    while (j <= high)
    {
        b[k] = a[j];
        k++;
        j++;
    }
    for (int i = 0; i <= high; i++)
    {
        a[i] = b[i];
    }
}
void mergeSort(int a[], int low, int high){
    int mid;
    if (low < high){
        mid = (low + high) / 2;
        mergeSort(a, low, mid);
        mergeSort(a, mid+1, high);
        merge(a, mid, low, high);
    }
}


int main()
{
    int a[] = {3, 4, 33, 2, 34, 2, 3};
    int n = 7;
    printArary(a, n);
    mergeSort(a, 0, 6);
    printArary(a, n);

    return 0;
}

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

struct Node{
    int data;
    struct Node *next;
};

void traversal(struct Node *ptr){
    while (ptr != NULL)
    {
        printf("Element : %d\n", ptr->data);
        ptr = ptr->next;
    }
}

// Case 1
struct Node * insertAtFirst(struct Node *head, int data){
    struct Node * ptr = (struct Node *) malloc(sizeof(struct Node));
    ptr->data = data;

    ptr->next = head;
    return ptr; 
}

// Case 2
struct Node * insertAtIndex(struct Node *head, int data, int index){
    struct Node * ptr = (struct Node *) malloc(sizeof(struct Node));
    struct Node * p = head;
    int i = 0;

    while (i!=index-1)
    {
        p = p->next;
        i++;
    }
    ptr->data = data;
    ptr->next = p->next;
    p->next = ptr;
    return head;
}

// Case 3
struct Node * insertAtEnd(struct Node *head, int data){
    struct Node * ptr = (struct Node *) malloc(sizeof(struct Node));
    ptr->data = data;
    struct Node * p = head;

    while(p->next!=NULL){
        p = p->next;
    }
    p->next = ptr;
    ptr->next = NULL;
    return head;
}

// Case 4
struct Node * insertAfterNode(struct Node *head, struct Node *prevNode, int data){
    struct Node * ptr = (struct Node *) malloc(sizeof(struct Node));
    ptr->data = data;

    ptr->next = prevNode->next;
    prevNode->next = ptr;

    
    return head;
}



struct Node * insertbeginning(struct Node *head ,int data){
    struct Node *ptr = (struct Node *)malloc(sizeof(struct Node));
    ptr->data = data;
    ptr->next = head;
    return ptr;


}

struct Node * insertbetween(struct Node *head, int data ,int index)
{
    struct Node *ptr=(struct Node *)malloc(sizeof(struct Node));
    struct Node * p = head;
    ptr->data=data;
    int i =0;
    while ( i !=index-1)
    {
        p = p->next;
        i++;
    }
    ptr->next = p->next;
    return head;
}
// Case 1: Deleting the first element from the linked list
struct Node * deleteFirst(struct Node * head){
    struct Node * ptr = head;
    head = head->next;
    free(ptr);
    return head;
}

// Case 2: Deleting the element at a given index from the linked list
struct Node * deleteAtIndex(struct Node * head, int index){
    struct Node *p = head;
    struct Node *q = head->next;
    for (int i = 0; i < index-1; i++)
    {
        p = p->next;
        q = q->next;
    }
    
    p->next = q->next;
    free(q);
    return head;
}

// Case 3: Deleting the last element
struct Node * deleteAtLast(struct Node * head){
    struct Node *p = head;
    struct Node *q = head->next;
    while(q->next !=NULL)
    {
        p = p->next;
        q = q->next;
    }
    
    p->next = NULL;
    free(q);
    return head;
}



int main(){
    struct Node *head;
    struct Node *second;
    struct Node *third;
    struct Node *fourth;

    head = (struct Node*)malloc(sizeof(struct Node));
    second = (struct Node*)malloc(sizeof(struct Node));
    third = (struct Node *)malloc(sizeof(struct Node));
    fourth = (struct Node *)malloc(sizeof(struct Node));

    head ->data=3;
    head ->next=second;

    second ->data=9;
    second ->next=third;

    third ->data=7;
    third->next=fourth;

    fourth->data=34;
    fourth->next=NULL;

    //traversal(head);
    //printf("-----------\n");
  //  head = insertbeginning(head,17);

   // printf("-----------\n");
    //traversal(head);
    //printf("-----------\n");
    insertbetween(head,45,2);
    //printf("-----------\n");
    traversal(head);

    return 0;
}

#include <stdio.h>

void printArray(int *A, int n)
{
    for (int i = 0; i < n; i++)
    {
        printf("%d ", A[i]);
    }
    printf("\n ");
}

void insertoinSort(int *A, int n)
{
    int key, j;
    for (int i = 0; i < n - 1; i++)
    {
        key = A[i];
        j = i - 1;
        while (j >= 0 && A[j] > key)
        {
            A[j + 1] = A[j];
            j--;
        }
        A[j + 1] = key;
    }
}
int main()
{

    int A[] = {12, 2, 32, 11, 54, 32, 45, 67, 89};
    int n = 9;
    printf("Before sorting\n");
    printArray(A, n);
    insertoinSort(A, n);
    printf("After sorting \n");
    printArray(A, n);

    return 0;
}

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

struct Node
{
    int data;
    struct Node * next;
    struct Node * prev;
};

void traversal(struct Node * head){
    struct Node *ptr =head;
    do
    {
        printf("ELement : %d\n",ptr->data);
        ptr= ptr->next;

    } while (ptr!=head);

}


int main(){
    struct Node * head;
    struct Node * second;
    struct Node * third;
    struct Node * fourth;

    head =  (struct Node *)malloc(sizeof(struct Node));
    second =  (struct Node *)malloc(sizeof(struct Node));
    third =  (struct Node *)malloc(sizeof(struct Node));
    fourth =  (struct Node *)malloc(sizeof(struct Node));

    head->data =34;
    head ->next=second;

    second->data = 23;
    second ->next=third;

    third ->data=7;
    third->next=fourth;

    fourth->data=34;
    fourth->next=head;

    return 0;
}

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

struct Node
{
   int data;
   struct Node*next;
};
struct Node *f= NULL;
struct Node *r= NULL;
void enqueue(struct node *top  ,int d) //Insert elements in Queue
{
	struct node* n;
	n = (struct node*)malloc(sizeof(struct node));
	n->data = d;
	n->next = NULL;
	if((r==NULL)&&(f==NULL))
	{
		f = r = n;
		r->next = f;
	}
	else
	{
		r->next = n;
		r = n;
		n->next = f;
	}
} 
void dequeue(struct node * top) // Delete an element from Queue
{
	struct node* t;
	t = f;
	if((f==NULL)&&(r==NULL))
		printf("\nQueue is Empty");
	else if(f == r){
		f = r = NULL;
		free(t);
	}
	else{
		f = f->next;
		r->next = f;
		free(t);
	}
	
	
}
void print(){ // Print the elements of Queue
	struct node* t;
	t = f;
	if((f==NULL)&&(r==NULL))
		printf("\nQueue is Empty");
	else{
		do{
			printf("\n%d",t->data);
			t = t->next;
		}while(t != f);
	}
}

int main(){
	top = enqueue(top,17);
	
return 0;
}

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

struct circularQueue
{
    int size;
    int f;
    int r;
    int *arr;
};

int isEmpty(struct circularQueue *q)
{
    if (q->f == q->r)
    {
        return 1;
    }
    return 0;
}

int isFull(struct circularQueue *q)
{
    if ((q->r + 1) % q->size == q->f)
    {
        return 1;
    }
    return 0;
}

void enqueue(struct circularQueue *q, int value)
{
    if (isFull(q))
    {
        printf("It is Full\n");
    }
    else
    {
        q->r++;
        q->arr[q->r] = value;
        printf("ELment Enqueued is %d \n", value);
    }
}

int dequeue(struct circularQueue *q)
{
    int a = -1;
    if (isEmpty(q))
    {
        printf("It is Empty\n");
    }
    else
    {
        q->f = (q->f + 1) % q->size;
        a = q->arr[q->f];
    }
    return a;
}

int main()
{
    struct circularQueue q;
    {
        q.size = 5;
        q.f = q.r = 0;
        q.arr = (int *)malloc(q.size * sizeof(int));
    };
    enqueue(&q, 17);
    enqueue(&q, 17);
    enqueue(&q, 9);
    enqueue(&q, 2001);
    //enqueue(&q, 27);

    printf("Elment dequeued is :  %d\n", dequeue(&q));
    printf("Elment dequeued is :  %d\n", dequeue(&q));
    printf("Elment dequeued is :  %d\n", dequeue(&q));
    printf("Elment dequeued is :  %d\n", dequeue(&q));
   // printf("Elment dequeued is :  %d\n", dequeue(&q));*/

    if (isFull(&q))
    {
       printf("Queue is full Now!!");
    }
    if (isEmpty(&q))
    {
        printf("Queue is empty Now!!");
    }
    
    

    return 0;
}

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

struct Node
{
    int data;
    struct Node*next;
};

void traversal(struct Node * head){
    struct Node *ptr =head;
    do
    {
        printf("ELement : %d\n",ptr->data);
        ptr= ptr->next;

    } while (ptr!=head);
    
}

int inseratbeginiing(struct Node *head,int data){
    struct Node * ptr =(struct Node *)malloc(sizeof(struct Node));
    ptr->data=data;

    struct Node * p = head->next;
    while (p->next != head)
    {
        p=p->next;
    }

    p->next = ptr;
    ptr->next = head;
    head = ptr;
    return head;
    
}


int main(){
    struct Node * head;
    struct Node * second;
    struct Node * third;
    struct Node * fourth;
    struct Node * fifth;

    head = (struct Node*)malloc(sizeof(struct Node));
    second = (struct Node*)malloc(sizeof(struct Node));
    third = (struct Node *)malloc(sizeof(struct Node));
    fourth = (struct Node *)malloc(sizeof(struct Node));
    fifth = (struct Node *)malloc(sizeof(struct Node));

    head ->data=3;
    head ->next=second;

    second ->data=9;
    second ->next=third;

    third ->data=7;
    third->next=fourth;

    fourth->data=34;
    fourth->next=fifth;

    fifth ->data=17;
    fifth ->next = head;

    traversal(head);
    head = inseratbeginiing(head,90);
    traversal(head);

    
    return 0;
}

#include <stdio.h>
//------TO PRINT THE ARRAY-------
void printArray(int *A, int n)
{
  for (int i = 0; i < n; i++)
  {
    printf("%d ", A[i]);
  }
  printf("\n");
}

//-------BUBBLE SORTING THE ARRAY-----------
void bubbleSort(int *A, int n)
{
  int temp;
  int isSorted = 0;
  for (int i = 0; i < n - 1; i++)
  {
    //printf("Working on pass number : %d\n", i + 1);
    for (int j = 0; j < n - i - 1; j++)
    {
      if (A[j] > A[j + 1])
      {
        temp = A[j];
        A[j] = A[j + 1];
        A[j + 1] = temp;
      }
    }
  }
}

void BubllesortApdative(int *A, int n)
{
  int temp;
  int isSorted = 0;
  for (int i = 0; i < n - 1; i++)
  {
    printf("Working on the pass number %d\n", i + 1);
    isSorted = 1;
    for (int j = 0; j < n - 1 - i; j++)
    {
      if (A[j] > A[j + 1])
      {
        temp = A[j];
        A[j] = A[j + 1];
        A[j + 1] = temp;
        isSorted = 0;
      }
    }
    if (isSorted)
    {
      return;
    }
  }
}
int main()
{
  int A[] = {1, 23, 34, 32, 45, 5, 78, 9, 45, 43, 34, 4, 56, 67, 6};
  int n = 15;
  printArray(A, n);
  bubbleSort(A, n);
  printArray(A, n);

  return 0;
}

#include <stdio.h>
#include <stdlib.h>
// STRUCTURE OF THE TREE OR NODE
struct node
{
    int data;
    struct node *left;
    struct node *right;
};
// TO CREATE THE TREE AND INPUT THE DATA IN IT...
struct node *createnode(int data)
{
    struct node *n;
    n = (struct node *)malloc(sizeof(struct node));
    n->data = data;
    n->left = NULL;
    n->right = NULL;
    return n;
}
// PREPRDER TRAVERSAL
void preorder(struct node *root)
{
    if (root != NULL)
    {
        printf("%d ", root->data);
        preorder(root->left); // RECURSIVE METHOD
        preorder(root->right);
    }
}
// POSTORDER TREVERSAL
void postorder(struct node *root)
{
    if (root != NULL)
    {
        postorder(root->left);
        postorder(root->right); // RECURSIVE METHOD
        printf("%d ", root->data);
    }
}
// INORDER TRAVERSAL
void inorder(struct node *root)
{
    if (root != NULL)
    {
        inorder(root->left);
        printf("%d ", root->data); // RECURSIVE METHOD
        inorder(root->right);
    }
}

// TO check it is binary SEARCH tree is or not...

int IsBst(struct node *root)
{
    static struct node *prev = NULL;
    if (root != NULL)
    {
        if (!IsBst(root->left))
        {
            return 0;
        }
        if (prev != NULL && root->data <= prev->data)
        {
            return 0;
        }
        prev = root;
        return IsBst(root->right);
    }
    else
        return 1;
}

// Searching element in the binary search treee.

struct node *search(struct node *root, int key)
{
    if (root == NULL)
    {
        return NULL;
    }
    if (root->data == key)
    {
        return root;
    }
    else if (key > root->data)
    {
        return search(root->right, key); // RECURSIVE METHOD
    }
    else
        return search(root->left, key);
}

struct node *inOrderPredecessor(struct node* root){
    root = root->left;
    while (root->right!=NULL)
    {
        root = root->right;
    }
    return root;
}


struct node *deleteNode(struct node *root, int value){

    struct node* iPre;
    if (root == NULL){
        return NULL;
    }
    if (root->left==NULL&&root->right==NULL){
        free(root);
    }

    //searching for the node to be deleted
    if (value < root->data){
        deleteNode(root->left,value);
    }
    else if (value > root->data){
        deleteNode(root->right,value);
    }
    //deletion strategy when the node is found
    else{
        iPre = inOrderPredecessor(root);
        root->data = iPre->data;
        deleteNode(root->left, iPre->data);
    }
}

int main()
{

    struct node *s = createnode(5); // CREATING THE TREE
    struct node *s1 = createnode(3);
    struct node *s2 = createnode(6);
    struct node *s3 = createnode(1);
    struct node *s4 = createnode(4);
    struct node *s6 = createnode(7);

    s->left = s1;
    s->right = s2;
    s1->left = s3;
    s1->right = s4;
    s2->right = s6;

    // preorder(s);
    // printf("\n");
    // postorder(s);
    // printf("\n");
    inorder(s);
    printf("\n");

  /*  // PRINTING THE IT IS OR NOT BST TREE

    if (IsBst(s))
    {
        printf("It is a binary search tree\n");
    }
    else
        printf("It is not a binary search tree\n");

    // PRINTING ELEMENT IS FOUND OR NOT

    struct node *n = search(s, 5);
    if (n != NULL)
    {
        printf("Elemment Found %d \n", n->data);
    }
    else
    {
        printf("ELement is not found");
    }*/

    return 0;
}

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

struct node
{
    int data;
    struct node*left;
    struct node*right;

};

struct node *createNode(int data){
    struct node *n = (struct node *)malloc(sizeof(struct node)) ;
    n->data=data;
    n->left=NULL;
    n->right=NULL;
}
struct node * searchIter(struct node * root, int key){
    while (root!=NULL)
    {
        if(key==root->data){
            return root;
        }
        else if (key > root->data)
        {
            root = root->right;
        }else{
            root = root->left;
        }
        
    }
    return NULL;
    
}


int main(){

    //creating binary tree
struct node *p = createNode(5);
    struct node *p1 = createNode(3);
    struct node *p2 = createNode(6);
    struct node *p3 = createNode(1);
    struct node *p4 = createNode(4);
    //linking nodes
    p->left = p1;
    p->right = p2;
    p1->left = p3;
    p1->right = p4;



    struct node* n = searchIter(p, 6);
    if(n!=NULL){
    printf("Found: %d", n->data);
    }
    else{
        printf("Element not found");
    }
    return 0;
}

#include<stdio.h>
 
 
void display(int arr[], int n){
    // Code for Traversal
    for (int i = 0; i < n; i++)
    {
        printf("%d ", arr[i]);
    }
    printf("\n");   
}
 
int indInsertion(int arr[], int size, int element, int capacity, int index){
    // code for Insertion
    if(size>=capacity){
        return -1;
    }
    for (int i = size-1; i >=index; i--)
    {
        arr[i+1] = arr[i];
    }
    arr[index] = element;
    return 1; 
}
void indDeletion(int arr[], int size, int index)
{
    // code for Deletion
    for (int i = index; i < size-1; i++)
    {
        arr[i] = arr[i + 1];
    }  
}
 
 
int main(){
    int arr[100] = {7, 8, 12, 27, 88};
    int size = 5, element = 45, index=0;
    display(arr, size); 
   // indInsertion(arr, size, element, 100, index);
    //size +=1;
    //display(arr, size);
    indDeletion(arr,size,index);
    size--;
    display(arr,size);
    return 0;
}

#include<stdio.h>
#include<stdlib.h>
 
struct myArray
{
    int total_size;
    int used_size;
    int *ptr;
};
 
void createArray(struct myArray * a, int tSize, int uSize){
    // (*a).total_size = tSize;
    // (*a).used_size = uSize;
    // (*a).ptr = (int *)malloc(tSize * sizeof(int));
 
    a->total_size = tSize;
    a->used_size = uSize;
    a->ptr = (int *)malloc(tSize * sizeof(int));
}

void show(struct myArray *a){
    for (int i = 0; i < a->used_size; i++)
    {
        printf("%d\n", (a->ptr)[i]);
    }
}

void setVal(struct myArray *a){
    int n;
    for (int i = 0; i < a->used_size; i++)
    {
        printf("Enter element %d  :",i+1);
        scanf("%d", &n);
        (a->ptr)[i] = n;
    }
}
 
int main(){
    struct myArray marks;
    createArray(&marks, 10, 5);
    printf("We are running setVal now\n");
    setVal(&marks);
 
    printf("We are running show now\n");
    show(&marks);
 
    return 0;
}

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

struct node {
    int data;
    struct node *next;
};

struct node *head;

void insert_at_beginning(int value);
void insert_at_last(int value);
void insert_at_position(int value, int position);
void insert_after_value(int value, int data);

void delete_at_beginning();
void delete_at_last();
void delete_at_position(int position);
void delete_after_value(int value);

void print_list();
void print_reverse(struct node* current);

int find_index(int_value);

void find_all_indices(int value);

void reverse_list();

int main() {
    int option, choice, value, position, data;
    while (1) {
        printf("\nMENU\n");
        printf("1. Insert values\n");
        printf("2. Delete values from the list\n");
        printf("3. Traverse the list\n");
        printf("4. Find the index of 1st occurence of value in list\n");
        printf("5. Find all indices correspoding to occurence of value\n");
        printf("6. Reverse the sequence of value in the list\n");
        printf("Enter your option: ");
        scanf("%d", &option);
        
        switch(option){
            case 1:
                printf("1. Insert at beginning\n");
                printf("2. Insert after last\n");
                printf("3. Insert at position\n");
                printf("4. Insert after a particular value\n");
                printf("5. Exit\n");
                printf("Enter your choice: ");
                scanf("%d", &choice);
                
                switch (choice) {
                    case 1:
                        printf("Enter value to insert: ");
                        scanf("%d", &value);
                        insert_at_beginning(value);
                        break;
                    case 2:
                        printf("Enter value to insert: ");
                        scanf("%d", &value);
                        insert_at_last(value);
                        break;
                    case 3:
                        printf("Enter value to insert: ");
                        scanf("%d", &value);
                        printf("Enter position to insert: ");
                        scanf("%d", &position);
                        insert_at_position(value, position);
                        break;
                    case 4:
                        printf("Enter value to insert after: ");
                        scanf("%d", &value);
                        printf("Enter data to insert: ");
                        scanf("%d", &data);
                        insert_after_value(value, data);
                        break;
                    case 5:
                        exit(0);
                    default:
                        printf("Invalid choice\n");
                        break;
                }
                break;
            case 2:
                printf("1. Delete at beginning\n");
                printf("2. Delete after last\n");
                printf("3. Delete at position\n");
                printf("4. Delete after a particular value\n");
                printf("5. Exit\n");
                printf("Enter your choice: ");
                scanf("%d", &choice);
                
                switch (choice) {
                    case 1:
                        delete_at_beginning(value);
                        break;
                    case 2:
                        delete_at_last(value);
                        break;
                    case 3:
                        printf("Enter position to delete: ");
                        scanf("%d", &position);
                        delete_at_position(position);
                        break;
                    case 4:
                        printf("Enter value to delete a node after that particular value: ");
                        scanf("%d", &value);
                        delete_after_value(value);
                        break;
                    case 5:
                        exit(0);
                    default:
                        printf("Invalid choice\n");
                        break;
                }
                break;
            case 3:
                printf("1. Print all the values in list\n");
                printf("2. Print values in reverse\n");
                printf("3. Exit\n");
                printf("Enter your choice: ");
                scanf("%d", &choice);
                
                switch (choice) {
                    case 1:
                        print_list();
                        break;
                    case 2:
                        printf("List in reverse order: ");
                        print_reverse(head);
                        printf("\n");
                        break;
                }
                break;
            case 4:
                printf("Enter value to find index: ");
                scanf("%d", &value);
                int index = find_index(value);
                if (index == -1) {
                    printf("Value not found\n");
                } 
                else {
                    printf("Index of first occurrence of %d: %d\n", value, index);
                }
                break;
            case 5:
                printf("Enter value to find all indices: ");
                scanf("%d", &value);
                find_all_indices(value);
                break;
            case 6:
                reverse_list();
                printf("List reversed successfully\n");
                break;
        }
    }
}

void insert_at_beginning(int value) {
    struct node *new_node = (struct node*) malloc(sizeof(struct node));
    new_node->data = value;
    new_node->next = head;
    head = new_node;
    printf("Value %d inserted at beginning\n", value);
}

void insert_at_last(int value) {
    if (head == NULL) {
        insert_at_beginning(value);
        return;
    }

    struct node *current = head;
    while (current->next != NULL) {
        current = current->next;
    }

    struct node *new_node = (struct node*) malloc(sizeof(struct node));
    new_node->data = value;
    new_node->next = NULL;
    current->next = new_node;

    printf("Value %d inserted after last\n", value);
}

void insert_at_position(int value, int position) {
    if (position == 0) {
        insert_at_beginning(value);
        return;
    }

    struct node *current = head;
    int i = 0;
    while (i < position - 1 && current != NULL) {
        current = current->next;
        i++;
    }

    if (current == NULL) {
        printf("Invalid position\n");
        return;
    }

    struct node *new_node = (struct node*) malloc(sizeof(struct node));
    new_node->data = value;
    new_node->next = current->next;
    current->next = new_node;

    printf("Value %d inserted at position %d\n", value, position);
}

// Function to insert a new node after a particular value in the linked list
void insert_after_value(int value, int data) {
    if (head == NULL) {
        printf("List is empty\n");
        return;
    }
    struct node* current = head;
    while (current != NULL && current->data != value) {
        current = current->next;
    }
    if (current == NULL) {
        printf("Value not found\n");
        return;
    }
    struct node* new_node = (struct node*) malloc(sizeof(struct node));
    new_node->data = data;
    new_node->next = current->next;
    current->next = new_node;
}


// Function to delete the first node from the linked list
void delete_at_beginning() {
    if (head == NULL) {
        printf("List is empty\n");
        return;
    }
    struct node* temp = head;
    head = head->next;
    free(temp);
}

// Function to delete the last node from the linked list
void delete_at_last() {
    if (head == NULL) {
        printf("List is empty\n");
        return;
    }
    if (head->next == NULL) {
        free(head);
        head = NULL;
        return;
    }
    struct node* current = head;
    while (current->next->next != NULL) {
        current = current->next;
    }
    free(current->next);
    current->next = NULL;
}

// Function to delete a node at a particular position/index in the linked list
void delete_at_position(int position) {
    if (head == NULL) {
        printf("List is empty\n");
        return;
    }
    if (position == 0) {
        delete_at_beginning();
        return;
    }
    struct node* current = head;
    int i;
    for (i = 0; i < position - 1 && current != NULL; i++) {
        current = current->next;
    }
    if (current == NULL || current->next == NULL) {
        printf("Invalid position\n");
        return;
    }
    struct node* temp = current->next;
    current->next = temp->next;
    free(temp);
}

// Function to delete the node after a particular value in the linked list
void delete_after_value(int value) {
    if (head == NULL) {
        printf("List is empty\n");
        return;
    }
    struct node* current = head;
    while (current != NULL && current->data != value) {
        current = current->next;
    }
    if (current == NULL || current->next == NULL) {
        printf("Value not found or last node\n");
        return;
    }
    struct node* temp = current->next;
    current->next = temp->next;
    free(temp);
}

void print_list() {
    struct node *current = head;
    printf("List: ");
    while (current != NULL) {
        printf("%d ", current->data);
        current = current->next;
    }
    printf("\n");
}

void print_reverse(struct node* current) {
    if (current == NULL) {
        return;
    }
    print_reverse(current->next);
    printf("%d ", current->data);
}

// Function to find the index of the first occurrence of a value in the linked list
int find_index(int value) {
    int index = 0;
    struct node* current = head;
    while (current != NULL) {
        if (current->data == value) {
            return index;
        }
        index++;
        current = current->next;
    }
    return -1; // Value not found
}

// Function to find all indices corresponding to the occurrence of a value in the linked list
void find_all_indices(int value) {
    int index = 0;
    struct node* current = head;
    printf("Indices of all occurrences of %d: ", value);
    while (current != NULL) {
        if (current->data == value) {
            printf("%d ", index);
        }
        index++;
        current = current->next;
    }
    printf("\n");
}

// Function to reverse the sequence of values in the linked list
void reverse_list() {
    struct node *prev_node, *current_node, *next_node;
    current_node = head;
    prev_node = NULL;
    while (current_node != NULL) {
        next_node = current_node->next;
        current_node->next = prev_node;
        prev_node = current_node;
        current_node = next_node;
    }
    head = prev_node;
}

int a[]={1,2,3,4,5};
  bool res=binary_search(a,a+5,20);
  int ind=lower_bound(a,a+5,3)-a;
  int indi=upper_bound(a,a+5,3)-a;
  cout<<indi<<endl;

int a[]={1,2,3,4,5};
  bool res=binary_search(a,a+5,20);
  cout<<res<<endl;

#include <stdio.h>
#include <stdlib.h>
struct node
{
   int data;
   struct node *next;
}*front=NULL,*rear=NULL;
void enqu(int x)
{

    struct node *t;
    t=(struct node*)malloc(sizeof(struct node));
    if(t==NULL)
        printf("queue is full");
    else
    {
         t->data=x;
         t->next=NULL;
        if(front==NULL)
             front=rear=t;
        else
        {
            rear->next=t;
            rear=t;
        }
    }
}
int deque()
{
    int x=-1;
    struct node *t;
    if(front==NULL)
        printf("queue i empty");
    else
    {
        t=front;
        x=t->data;
        front=front->next;
        free(t);
    }
    return x;
}
int qempty()
{
    return front==NULL;
}
void bfs(int g[][7],int i,int n)
{
   int v[7]={0};
   v[i]=1;
   printf("%d",i);
   enqu(i);
   while(!qempty())
   {
       int x=deque();
       for(int j=1;j<n;j++)
       {
           if(g[x][j]==1 &&v[j]==0)
           {
               printf("%d ",j);
               v[j]=1;
               enqu(j);
           }
       }
   }
}
void dfs(int g[][7],int i,int n)
{

    static int v[7]={0};
    printf("%d ",i);
    v[i]=1;
    for(int j=1;j<n;j++)
    {
        if(g[i][j]==1 && v[j]==0)
            dfs(g,j,n);
    }
}
int main()
{
   int g[7][7]={{0,0,0,0,0,0,0},
                {0,0,1,1,0,0,0},
                {0,1,0,0,1,0,0},
                {0,1,0,0,1,0,0},
                {0,0,1,1,0,1,1},
                {0,0,0,0,1,0,0},
                {0,0,0,0,1,0,0}};
      dfs(g,1,7);
}

#include <stdio.h>
#include <stdlib.h>
struct node
{
   int data;
   struct node *next;
}*front=NULL,*rear=NULL;
void enqu(int x)
{

    struct node *t;
    t=(struct node*)malloc(sizeof(struct node));
    if(t==NULL)
        printf("queue is full");
    else
    {
         t->data=x;
         t->next=NULL;
        if(front==NULL)
             front=rear=t;
        else
        {
            rear->next=t;
            rear=t;
        }
    }
}
int deque()
{
    int x=-1;
    struct node *t;
    if(front==NULL)
        printf("queue i empty");
    else
    {
        t=front;
        x=t->data;
        front=front->next;
        free(t);
    }
    return x;
}
int qempty()
{
    return front==NULL;
}
void bfs(int g[][7],int i,int n)
{
   int v[7]={0};
   v[i]=1;
   printf("%d",i);
   enqu(i);
   while(!qempty())
   {
       int x=deque();
       for(int j=1;j<n;j++)
       {
           if(g[x][j]==1 &&v[j]==0)
           {
               printf("%d ",j);
               v[j]=1;
               enqu(j);
           }
       }
   }
}
int main()
{
   int g[7][7]={{0,0,0,0,0,0,0},
                {0,0,1,1,0,0,0},
                {0,1,0,0,1,0,0},
                {0,1,0,0,1,0,0},
                {0,0,1,1,0,1,1},
                {0,0,0,0,1,0,0},
                {0,0,0,0,1,0,0}};
      bfs(g,4,7);
}

#include <bits/stdc++.h> 
int f(int ind,vector<int>&nums,vector<int>&dp)
{
    
    if(ind==0)
      return nums[ind];
    if(ind <1)
       return 0;

       if(dp[ind]!=-1)
      return dp[ind];
    int pick=nums[ind]+f(ind-2,nums,dp);
    int notp=0+f(ind-1,nums,dp);
    dp[ind]=max(pick,notp);
    return max(pick,notp);
}
int maximumNonAdjacentSum(vector<int> &nums){
    // Write your code here.
    int n=nums.size();
    vector<int> dp(n,-1);
    return f(n-1,nums,dp);
}

#include <bits/stdc++.h> 

int maximumNonAdjacentSum(vector<int> &nums){
    // Write your code here.
    int n=nums.size();

    int prev2=0;
    int pre=nums[0],curri=0;

    for(int i=1;i<n;i++)
    {
        int pick=nums[i];
        if(i>1)
         pick+=prev2;
         
        int notp=0+pre;
        curri=max(pick,notp);
        prev2=pre;
        pre=curri;
    }
    return pre;
}

#include <bits/stdc++.h> 
int f(int ind,vector<int>&nums,vector<int>&dp)
{
    
    if(ind==0)
      return nums[ind];
    if(ind <1)
       return 0;

       if(dp[ind]!=-1)
      return dp[ind];
    int pick=nums[ind]+f(ind-2,nums,dp);
    int notp=0+f(ind-1,nums,dp);
    dp[ind]=max(pick,notp);
    return max(pick,notp);
}
int maximumNonAdjacentSum(vector<int> &nums){
    // Write your code here.
    int n=nums.size();
    vector<int> dp(n,-1);
    return f(n-1,nums,dp);
}

#include<stdio.h>
#include<stdlib.h>
#define MAX_SIZE 100
struct Node
{
  int data;
  struct Node *left, *right;
};

struct Stack
{
  int size;
  int top;
  struct Node **array;
};

struct Node *newNode (int data)
{
  struct Node *node = (struct Node *) malloc (sizeof (struct Node));
  node->data = data;
  node->left = node->right = NULL;
  return node;
}

struct Stack *createStack (int size)
{
  struct Stack *stack = (struct Stack *) malloc (sizeof (struct Stack));
  stack->size = size;
  stack->top = -1;
  stack->array =
    (struct Node **) malloc (stack->size * sizeof (struct Node *));
  return stack;
}

int isFull (struct Stack *stack)
{
  return stack->top - 1 == stack->size;
}

int isEmpty (struct Stack *stack)
{
  return stack->top == -1;
}

void push (struct Stack *stack, struct Node *node)
{
  if (isFull (stack))
    return;
  stack->array[++stack->top] = node;
}

struct Node *pop (struct Stack *stack)
{
  if (isEmpty (stack))
    return NULL;
  return stack->array[stack->top--];
}

struct Node *peek (struct Stack *stack)
{
  if (isEmpty (stack))
    return NULL;
  return stack->array[stack->top];
}

void postorder (struct Node *root)
{
  if (root == NULL)
    return;

  struct Stack *stack = createStack (MAX_SIZE);
  do
    {
      while (root)
    {
      if (root->right)
        push (stack, root->right);
      push (stack, root);

      root = root->left;
    }

      root = pop (stack);

      if (root->right && peek (stack) == root->right)
    {
      pop (stack);
      push (stack, root);
      root = root->right;

    }
      else
    {
      printf ("%d ", root->data);
      root = NULL;
    }
    }
  while (!isEmpty (stack));
}

int main ()
{

  struct Node *root = NULL;
  root = newNode (10);
  root->left = newNode (20);
  root->right = newNode (30);
  root->left->left = newNode (40);
  root->left->right = newNode (50);
  root->right->left = newNode (60);
  root->right->right = newNode (70);
  printf ("Post order traversal of binary tree is :\n");
  printf ("[");
  postorder(root);
  printf ("]");

  return 0;
}

#include <stdio.h>
#include <stdlib.h>
struct node
{
    struct node *left;
    struct node *right;
    int data;
};

struct stack
{
    struct node *data;
    struct stack *next;
};

void push(struct stack **top, struct node *n);
struct node *pop(struct stack **top);
int isEmpty(struct stack *top);

int tree_traversal(struct node *root)
{
    struct node *temp = root;
    struct stack *s_temp = NULL;
    int flag = 1;
    while (flag)
    {
        if (temp)
        {
            printf("%d ", temp->data);
            push(&s_temp, temp);
            temp = temp->left;
        }
        else
        {
            if (!isEmpty(s_temp))
            {
                temp = pop(&s_temp);
                temp = temp->right;
            }
            else
                flag = 0;
        }
    }
}

void push(struct stack **top, struct node *n)
{
    struct stack *new_n = (struct stack *)malloc(sizeof(struct stack));
    new_n->data = n;
    new_n->next = (*top);
    (*top) = new_n;
}

int isEmpty(struct stack *top)
{
    if (top == NULL)
        return 1;
    else
        return 0;
}

struct node *pop(struct stack **top_n)
{
    struct node *item;
    struct stack *top;
    top = *top_n;
    item = top->data;
    *top_n = top->next;
    free(top);
    return item;
}

struct node *create_node(int data)
{
    struct node *new_n = (struct node *)malloc(sizeof(struct node));
    new_n->data = data;
    new_n->left = NULL;
    new_n->right = NULL;
    return (new_n);
}

int main()
{
    struct node *root;
    root = create_node(8);
    root->left = create_node(5);
    root->right = create_node(4);
    root->left->left = create_node(7);
    root->left->right = create_node(6);
    tree_traversal(root);
    return 0;
}

#include <stdio.h>
#include <stdlib.h>
struct node
{
    struct node *left;
    struct node *right;
    int data;
};

struct stack
{
    struct node *data;
    struct stack *next;
};

void push(struct stack **top, struct node *n);
struct node *pop(struct stack **top);
int isEmpty(struct stack *top);

int tree_traversal(struct node *root)
{
    struct node *temp = root;
    struct stack *s_temp = NULL;
    int flag = 1;
    while (flag)
    {
        if (temp)
        {
            printf("%d ", temp->data);
            push(&s_temp, temp);
            temp = temp->left;
        }
        else
        {
            if (!isEmpty(s_temp))
            {
                temp = pop(&s_temp);
                temp = temp->right;
            }
            else
                flag = 0;
        }
    }
}

void push(struct stack **top, struct node *n)
{
    struct stack *new_n = (struct stack *)malloc(sizeof(struct stack));
    new_n->data = n;
    new_n->next = (*top);
    (*top) = new_n;
}

int isEmpty(struct stack *top)
{
    if (top == NULL)
        return 1;
    else
        return 0;
}

struct node *pop(struct stack **top_n)
{
    struct node *item;
    struct stack *top;
    top = *top_n;
    item = top->data;
    *top_n = top->next;
    free(top);
    return item;
}

struct node *create_node(int data)
{
    struct node *new_n = (struct node *)malloc(sizeof(struct node));
    new_n->data = data;
    new_n->left = NULL;
    new_n->right = NULL;
    return (new_n);
}

int main()
{
    struct node *root;
    root = create_node(8);
    root->left = create_node(5);
    root->right = create_node(4);
    root->left->left = create_node(7);
    root->left->right = create_node(6);
    tree_traversal(root);
    return 0;
}

void mirror(struct node *t)
{
    if(t==NULL)
        return;
    else
    {
        struct node *m;
        m=t->left;
        t->left=t->right;
        t->right=m;
        mirror(t->left);
        mirror(t->right);

    }
}

int evl(char *postfix)
{
    int i=0,x1,x2,r=0;
    for(i=strlen(postfix); i>=0;i--)
    {
        if(isOperand(postfix[i]))
            push(postfix[i]-'0');
        else
        {
            x1=pop();
            x2=pop();
            switch(postfix[i])
            {
                case '+':r=x1+x2;break;
                case '-':r=x1-x2;break;
                case '*':r=x1*x2;break;
                case '/':r=x1/x2;break;
            }
            push(r);
        }
    }
    return pop();
}
int main()
{
    char *postfix="+2/62";
    printf("%d",evl(postfix));


}

int evl(char *postfix)
{
    int i=0,x1,x2,r=0;
    for(i=0;postfix[i]!='\0';i++)
    {
        if(isOperand(postfix[i]))
            push(postfix[i]-'0');
        else
        {
            x2=pop();
            x1=pop();
            switch(postfix[i])
            {
                case '+':r=x1+x2;break;
                case '-':r=x1-x2;break;
                case '*':r=x1*x2;break;
                case '/':r=x1/x2;break;
            }
            push(r);
        }
    }
    return pop();
}
int main()
{
    char *postfix="234*+82/-";
    printf("%d",evl(postfix));


}

#include <stdio.h>
#include <stdlib.h>
#include<strings.h>
struct Node
{
 char data;
 struct Node *next;
}*top=NULL;
void push(char x)
{
 struct Node *t;
 t=(struct Node*)malloc(sizeof(struct Node));

 if(t==NULL)
 printf("stack is full\n");
 else
 {
 t->data=x;
 t->next=top;
 top=t;
 }

}
char pop()
{
 struct Node *t;
 char x=-1;

 if(top==NULL)
 printf("Stack is Empty\n");
 else
 {
 t=top;
 top=top->next;
 x=t->data;
 free(t);
 }
 return x;
}
int pre(char x)
{
    if(x=='+'||x=='-')
        return 1;
    else if(x=='/' || x=='*')
        return 2;
    else if(x=='%' || x=='^')
        return 3;
    else
        return 0;

}
int isOperand(char x)
{
   if(x=='+' || x=='-' || x=='(' || x==')'|| x=='*'||x=='/'||x=='^')
      return 0;
   else
      return 1;

}
void intopost(char infix[])
{
    int i=0;
    while(infix[i]!='\0')
    {
        if(infix[i]=='(')
            push(infix[i++]);
        else if(isOperand(infix[i]))
        {
            scanf("%c",infix[i]);
            i++;
        }
        else if(infix[i]==')')
        {
            char x=pop();
                while(x!='(')
                {
                    printf("%c",x);;
                    x=pop();
                }
                i++;
        }
        else{
                if(top==NULL)
                    push(infix[i++]);
                else if(pre(infix[i])>pre(top->data))
                     push(infix[i++]);
                else
                   printf("%c",pop());

        }
    }
        while(top!=NULL)
            printf("%c",pop());


}
int main()
{
    char *infix;
    infix="a+(b*c)";
    intopost(infix);


}

#include <stdio.h>
#include <stdlib.h>
#include<strings.h>
struct Node
{
 char data;
 struct Node *next;
}*top=NULL;
void push(char x)
{
 struct Node *t;
 t=(struct Node*)malloc(sizeof(struct Node));

 if(t==NULL)
 printf("stack is full\n");
 else
 {
 t->data=x;
 t->next=top;
 top=t;
 }

}
char pop()
{
 struct Node *t;
 char x=-1;

 if(top==NULL)
 printf("Stack is Empty\n");
 else
 {
 t=top;
 top=top->next;
 x=t->data;
 free(t);
 }
 return x;
}
int pre(char x)
{
      if(x=='+' || x=='-')
          return 1;
      else if(x=='*' || x=='/')
         return 2;
      else if(x=='^')
          return 3;
    return 0;
}
int isOperand(char x)
{
 if(x=='+' || x=='-' || x=='*' || x=='/'||x=='^'||x==')')
    return 0;
 else
    return 1;

}
char *intopost(char infix[])
{
    int i=0,j=0;
   // push('(');
   // strcat(infix,')');
    char *postfix;
    int len=strlen(infix);
    postfix=(char*)malloc((len+2)*sizeof(char));
    while(infix[i]!='\0')
    {
           if(infix[i]=='(')
              push(infix[i++]);
           else if(isOperand(infix[i]))
              postfix[j++]=infix[i++];
            else if(infix[i]==')')
            {
                char x=pop();
                while(x!='(')
                {
                    postfix[j++]=x;
                    x=pop();
                }
                i++;
            }
            else
            {
                if(top==NULL)
                    push(infix[i++]);
                else if(pre(infix[i])>pre(top->data))
                     push(infix[i++]);
                else
                   postfix[j++]=pop();


            }
        }
            while(top!=NULL)
               postfix[j++]=pop();
      postfix[j]='\0';
      return postfix;

}
int main()
{
    int n;
    scanf("%d",&n);
    char infix[n];
    for(int i=0;i<n;i++)
       scanf("%c",&infix[i]);

     int i=0,j=n-1;
     while(i<j)
     {
         char temp=infix[i];
         infix[i]=infix[j];
         infix[j]=temp;
     }


    //printf("%s",infix);

   char *postfix=intopost(infix);
    i=0,j=n-1;
    while(i<j)
     {
         char temp=postfix[i];
         postfix[i]=postfix[j];
         postfix[j]=temp;
     }
      for(int i=0;i<n;i++)
       scanf("%c",postfix[i]);

  // printf("%s ",postfix);
      return 0;
}

// C program for Merge Sort 
#include <stdio.h>
#include <stdlib.h>
  
// Merges two subarrays of arr[].
// First subarray is arr[l..m]
// Second subarray is arr[m+1..r]
void merge(int arr[], int l, 
           int m, int r)
{
    int i, j, k;
    int n1 = m - l + 1;
    int n2 = r - m;
  
    // Create temp arrays
    int L[n1], R[n2];
  
    // Copy data to temp arrays 
    // L[] and R[] 
    for (i = 0; i < n1; i++)
        L[i] = arr[l + i];
    for (j = 0; j < n2; j++)
        R[j] = arr[m + 1 + j];
  
    // Merge the temp arrays back 
    // into arr[l..r]
    // Initial index of first subarray
    i = 0; 
  
    // Initial index of second subarray
    j = 0; 
  
    // Initial index of merged subarray
    k = l; 
    while (i < n1 && j < n2) 
    {
        if (L[i] <= R[j]) 
        {
            arr[k] = L[i];
            i++;
        }
        else 
        {
            arr[k] = R[j];
            j++;
        }
        k++;
    }
  
    // Copy the remaining elements 
    // of L[], if there are any
    while (i < n1) {
        arr[k] = L[i];
        i++;
        k++;
    }
  
    // Copy the remaining elements of 
    // R[], if there are any 
    while (j < n2) 
    {
        arr[k] = R[j];
        j++;
        k++;
    }
}
  
// l is for left index and r is 
// right index of the sub-array 
// of arr to be sorted 
void mergeSort(int arr[], 
               int l, int r)
{
    if (l < r) 
    {
        // Same as (l+r)/2, but avoids 
        // overflow for large l and h
        int m = l + (r - l) / 2;
  
        // Sort first and second halves
        mergeSort(arr, l, m);
        mergeSort(arr, m + 1, r);
  
        merge(arr, l, m, r);
    }
}
  
// UTILITY FUNCTIONS 
// Function to print an array 
void printArray(int A[], int size)
{
    int i;
    for (i = 0; i < size; i++)
        printf("%d ", A[i]);
    printf("\n");
}
  
// Driver code
int main()
{
    int arr[] = {12, 11, 13, 5, 6, 7};
    int arr_size = sizeof(arr) / sizeof(arr[0]);
  
    printf("Given array is \n");
    printArray(arr, arr_size);
  
    mergeSort(arr, 0, arr_size - 1);
  
    printf("\nSorted array is \n");
    printArray(arr, arr_size);
    return 0;
}

#include<stdio.h>
void quicksort(int number[25],int first,int last){
   int i, j, pivot, temp;
   if(first<last){
      pivot=first;
      i=first;
      j=last;
      while(i<j){
         while(number[i]<=number[pivot]&&i<last)
         i++;
         while(number[j]>number[pivot])
         j--;
         if(i<j){
            temp=number[i];
            number[i]=number[j];
            number[j]=temp;
         }
      }
      temp=number[pivot];
      number[pivot]=number[j];
      number[j]=temp;
      quicksort(number,first,j-1);
      quicksort(number,j+1,last);
   }
}
int main(){
   int i, count, number[25];
   printf("How many elements are u going to enter?: ");
   scanf("%d",&count);
   printf("Enter %d elements: ", count);
   for(i=0;i<count;i++)
   scanf("%d",&number[i]);
   quicksort(number,0,count-1);
   printf("Order of Sorted elements: ");
   for(i=0;i<count;i++)
   printf(" %d",number[i]);
   return 0;
}

// Selection sort in C
#include <stdio.h>
// function to swap the the position of two elements
void swap(int *a, int *b) {
  int temp = *a;
  *a = *b;
  *b = temp;
}
void selectionSort(int array[], int size) {
  for (int step = 0; step < size - 1; step++) {
    int min_idx = step;
    for (int i = step + 1; i < size; i++) 
{
      // To sort in descending order, change > to < in this line.
      // Select the minimum element in each loop.
      if (array[i] < array[min_idx])
        min_idx = i;
    }
    // put min at the correct position
    swap(&array[min_idx], &array[step]);
  }
}
// function to print an array
void printArray(int array[], int size) {
  for (int i = 0; i < size; ++i) {
    printf("%d  ", array[i]);
  }
  printf("\n");
}
// driver code
int main() {
  int data[] = {20, 12, 10, 15, 2};
  int size = sizeof(data) / sizeof(data[0]);
  selectionSort(data, size);
  printf("Sorted array in Acsending Order:\n");
  printArray(data, size);
}

// Selection sort in C
#include <stdio.h>
// function to swap the the position of two elements
void swap(int *a, int *b) {
  int temp = *a;
  *a = *b;
  *b = temp;
}
void selectionSort(int array[], int size) {
  for (int step = 0; step < size - 1; step++) {
    int min_idx = step;
    for (int i = step + 1; i < size; i++) 
{
      // To sort in descending order, change > to < in this line.
      // Select the minimum element in each loop.
      if (array[i] < array[min_idx])
        min_idx = i;
    }
    // put min at the correct position
    swap(&array[min_idx], &array[step]);
  }
}
// function to print an array
void printArray(int array[], int size) {
  for (int i = 0; i < size; ++i) {
    printf("%d  ", array[i]);
  }
  printf("\n");
}
// driver code
int main() {
  int data[] = {20, 12, 10, 15, 2};
  int size = sizeof(data) / sizeof(data[0]);
  selectionSort(data, size);
  printf("Sorted array in Acsending Order:\n");
  printArray(data, size);
}

#include <stdio.h>
 
void bubble_sort(long [], long);
 
int main()
{
  long array[100], n, c, d, swap;
 
  printf("Enter number of elements\n");
  scanf("%ld", &n);
 
  printf("Enter %ld longegers\n", n);
 
  for (c = 0; c < n; c++)
    scanf("%ld", &array[c]);
 
  bubble_sort(array, n);
 
  printf("Sorted list in ascending order:\n");
 
  for ( c = 0 ; c < n ; c++ )
     printf("%ld\n", array[c]);
 
  return 0;
}
 
void bubble_sort(long list[], long n)
{
  long c, d, t;
 
  for (c = 0 ; c < ( n - 1 ); c++)
  {
    for (d = 0 ; d < n - c - 1; d++)
    {
      if (list[d] > list[d+1])
      {
        /* Swapping */
 
        t         = list[d];
        list[d]   = list[d+1];
        list[d+1] = t;
      }
    }
  }
}

#include <stdio.h>
int main() {
  int r, c, a[100][100], b[100][100], sum[100][100], i, j;
  printf("Enter the number of rows (between 1 and 100): ");
  scanf("%d", &r);
  printf("Enter the number of columns (between 1 and 100): ");
  scanf("%d", &c);

  printf("\nEnter elements of 1st matrix:\n");
  for (i = 0; i < r; ++i)
    for (j = 0; j < c; ++j) {
      printf("Enter element a%d%d: ", i + 1, j + 1);
      scanf("%d", &a[i][j]);
    }

  printf("Enter elements of 2nd matrix:\n");
  for (i = 0; i < r; ++i)
    for (j = 0; j < c; ++j) {
      printf("Enter element b%d%d: ", i + 1, j + 1);
      scanf("%d", &b[i][j]);
    }

  // adding two matrices
  for (i = 0; i < r; ++i)
    for (j = 0; j < c; ++j) {
      sum[i][j] = a[i][j] + b[i][j];
    }

  // printing the result
  printf("\nSum of two matrices: \n");
  for (i = 0; i < r; ++i)
    for (j = 0; j < c; ++j) {
      printf("%d   ", sum[i][j]);
      if (j == c - 1) {
        printf("\n\n");
      }
    }

  return 0;
}

#include <stdio.h>
int main() {
  int a[10][10], transpose[10][10], r, c;
  printf("Enter rows and columns: ");
  scanf("%d %d", &r, &c);

  // asssigning elements to the matrix
  printf("\nEnter matrix elements:\n");
  for (int i = 0; i < r; ++i)
  for (int j = 0; j < c; ++j) {
    printf("Enter element a%d%d: ", i + 1, j + 1);
    scanf("%d", &a[i][j]);
  }

  // printing the matrix a[][]
  printf("\nEntered matrix: \n");
  for (int i = 0; i < r; ++i)
  for (int j = 0; j < c; ++j) {
    printf("%d  ", a[i][j]);
    if (j == c - 1)
    printf("\n");
  }

  // computing the transpose
  for (int i = 0; i < r; ++i)
  for (int j = 0; j < c; ++j) {
    transpose[j][i] = a[i][j];
  }

  // printing the transpose
  printf("\nTranspose of the matrix:\n");
  for (int i = 0; i < c; ++i)
  for (int j = 0; j < r; ++j) {
    printf("%d  ", transpose[i][j]);
    if (j == r - 1)
    printf("\n");
  }
  return 0;
}

#include <stdio.h>

/*Write C code that does the following operation. 
-	Asks and gets the number of WINs (3 points/win), DRAWs (1 points/draw) and LOSSes (0 points/loss) for four football teams. 
-	Records them in a multidimensional array. 
-	Calculates the total scores. 
-	Reports the score table.*/


int main() {
    int score[3][3];
    for(int i=0;i<3;i++)
    {
        printf("enter win draw and loss of team %d: ",i+1);
        scanf("%d %d %d ",&score[i][0],&score[i][1],&score[i][2]);
    }
    printf("team name\t  win\t draw\t loss\t points\n");
    for(int i=0;i<3;i++)
    {
        int points=score[i][0]*3+score[i][1]*1;
        printf("\nteam %d\t\t  %d\t\t  %d\t\t %d\t\t  %d\n",i+1,score[i][0],score[i][1],score[i][2],points);
    }
    
    
    return 0;
}


output:

enter win draw and loss of team 1: 2
1
1
1
enter win draw and loss of team 2: 2
3
1
enter win draw and loss of team 3: 3
3
2
team name	  win	 draw	 loss	 points

team 1		  2		  1		 1		  7

team 2		  1		  2		 3		  5

team 3		  1		  3		 3		  6

#include <iostream>
using namespace std;

int main()
{
    int *p;
    p= (int *)malloc(5*sizeof(int));  
    //will allocate memory for 5 integers, so it is an array of integers and it is assigned to p
    
    //initializing the values
    p[0] = 10;
    p[1] = 20;
    p[2] = 30;
    p[3] = 40;
    p[4] = 50;

    
    for(int i=0; i<5; i++)
    {
        cout << p[i] << endl;
    }
    
    return 0;
}

Product Documents

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

int main()
{
    int data[5]={14,33,27,35,10};
    int i,j;
    int swap;
    int temp;
    for(int i=0;i<5;i++)
    {
        printf("please enter array element %d: ",i+1);
        scanf("%d",&data[i]);
    }
    for(int i=0;i<5-1;i++)
    {
        swap=0;
        for(int j=0;j<5-1;j++)
        {
            if(data[j]>data[j+1])
            {
                temp=data[j];
                data[j]=data[j+1];
                data[j+1]=temp;
            }
        }
    }
    printf("bubble sort of array are: ");
    for(int i=0;i<5; i++)
    {
        printf("%d ",data[i]);
    }
    printf("\n");

    
    return 0;
}

#include <stdio.h>

int main() {
    int arr[10]={23,43,12,18,6,48,39,65,43,-3};
    int max = arr[0];
    int min = arr[0];
    int i;
    for(i=1;i<10;i++)
    {
        if(arr[i]>max)
            max=arr[i];
        if(arr[i]<min)
            min=arr[i];
    }
    printf("the maximum number of the array is %d ",max);
    printf("\nthe minimum number of the array is %d ",min);
    
    //find second maximium and minimum number of the array
    int max2=min;
    int min2=max;
    for(i=0;i<9;i++)
    {
        if(arr[i]!=max && arr[i]>max2)
        {
            max2=arr[i];
        }
        if(arr[i]!=min && arr[i]<min2)
        {
            min2=arr[i];
        }
    }
    printf("\nthe second maximum number is %d ",max2);
    printf("\nthe second minimum number is %d ",min2);
    return 0;
}

#include <stdio.h>
#include <stdlib.h>
void findMin(int n);
void findMax(int n);
 
int main() {
   int arr[10];
   int min=arr[0], minind=0;
   int max=arr[0],maxind=0;
   
    for(int i=0;i<=9;i++)
    {
        printf("please enter element %d: ",i+1);
        scanf("%d",&arr[i]);
    }
   for(int i=1;i<=9;i++)
   {
       if(arr[i]>max)
       {
           max=arr[i];
           maxind=i;
       }
       if(arr[i]<min)
       {
           min=arr[i];
           minind=i;
       }
   }
   printf("maximum number of the array is %d at index %d\n: ",max,maxind);
   printf("\nminimum number of the array is %d at index %d\n: ",min,minind);
  
return 0;
}

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

int main() {
    int arr1[6]={-20,-2,3,0,10,20};
    int arr2[4]={6,1,33,9};
    int arr3[100];
    int n1=5;
    int n2=4;
    int n3=n1+n2;
    for(int i=0; i<n1; i++)
    arr3[i]=arr1[i];
    for(int i=0; i<n2; i++)
    arr3[i + n1]= arr2[i];
    
    printf("the marged array are: ");
    for(int i=0; i<n3; i++)
    printf("%d ",arr3[i]);
    
    printf("\nFinal array after sorting: ");
    for(int i = 0; i < n3; i++){
        int temp;
        for(int j = i+1; j < n3; j++) {
            if(arr3[i] > arr3[j]) {
                temp = arr3[i];
                arr3[i] = arr3[j];
                arr3[j] = temp;
            }
        }
    }   
    for(int i = 0; i < n3 ; i++)      //print sorted array
        printf(" %d ",arr3[i]);
    

    return 0;
}

void findPeaks(int arr[],int n);
int main() {
    int arr[10];
    int i;
    int number;
    for(int i=0;i<10;i++)
    {
        printf("enter elment of the array %d: ",i+1);
        scanf("%d",&arr[i]);
    }
    for(int i=0;i<10;i++)
    {
        if(arr[i]>arr[i-1] && arr[i]>arr[i+1])
        {
            printf("the value of %d at index %d is a peak\n",arr[i],i);
        }
        else
        printf("No peak\n");
    }
    return 0;
}

/*Find minimum and maximum of the array and tell them where is the position*/
#include <stdio.h>
#include <stdlib.h>
void findMinimum(int arr[]);
void findMaximum(int arr[]);

int main() {
    int arr[10]={1,223,3,4,-11,6,7,8,9,10};
    int i;
    int minimum=arr[0];
    int maximum=arr[0];
    int minindex=0;
    int maxindex=0;
    for(int i=0;i<10;i++)
    {
        if(arr[i]<minimum)
        {minimum=arr[i];
        minindex=i+1;
        }
        if(arr[i]>maximum)
        {
            maximum=arr[i];
            maxindex=i+1;}
    }
    printf("\nthe minimum number of the array is %d at position %d",minimum,minindex);
    printf("\nthe maximum number of the array is %d at index %d",maximum,maxindex);
   
    return 0;
}

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

int main() {
    int arr[5]= {1,4,3,5,6,};
    int i,j;
    int un=0;
    for(int i=0;i<5;i++)
    {
        printf("%d ",i);
        for(j=i+1;j<5;j++)
        {
            if(arr[i]==arr[j])
            {
                un=1;
                break;
            }
        }
        //if(un==1)
        //break;
    }
    if(un==1)
    {
        printf("the value is not unique:");
    }
    else
    {
        printf("the value is unique");
    }
    

    return 0;
}

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

int main() {
   int arr[5]={100,60,40,78,99};
   int number;
   for(int i=0;i<5;i++)
   {
       printf("please enter numbers %d: ",i+1);
       scanf("%d",&arr[i]);
   }
   int min=arr[0];
   int max=arr[0];
   for(int i=0;i<5;i++)
   {
       if(arr[i]<min)
       min=arr[i];
       
       if(arr[i]>max)
       max=arr[i];
   }
   printf("\nmaximum number is %d: ",max);
   printf("\nminimum number is %d: ",min);
    return 0;
}

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

int main() {
    int arr[9]={1,10,20,30,40,50,60,70,80};
    int number;
    int i,j;
    int entry=-1;
    printf("please enter number that you are looking for: ");
    scanf("%d",&number);
    
    while(1)
    {
        for(int i=0;i<9;i++)
        {
            if(arr[i]==number)
            entry=i;
        }
        if(entry==-1)
        {
            printf("\n%d does not exist in the array",number);
        }
        else
        {
            printf("\n%d does exist in the array it is entry %d: ",number,entry+1);
        }
        printf("\nplease enter another number: ");
        scanf("%d",&number);
        entry==-1;
    }
    
    return 0;
}

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

/*2.	Write a C program that performs the following operations subsequently:
- Ask the user to enter the homework, midterm, and final exam grades of 10 students one by one and store them in an array (Create one array for each exam). Each grade is between 0 to 100.
- Calculate the overall grade and letter grade of each student. Homework represents the 30% of the overall grade, while midterm represents 30% and final represents 40%.
Student’s letter grade is determined as follows:
0 – 30 is equivalent to F
30	– 60 is equivalent to C
60	– 100 is equivalent to A.
- Your program should output the grade and letter grade of each student.*/


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

int main() {
   int homework[10];
   int midterm[10];
   int final[10];
   float overall[10];
   char letter[10];
   int i;
   for(int i=0;i<10;i++)
   {
       printf("please enter homework, midterm and final grade of student %d: ",i+1);
       scanf("%d\n %d\n %d\n",&homework[i],&midterm[i],&final[i]);
   }
   
    // 0 – 30 is equivalent to F
   // 30	– 60 is equivalent to C
  //  60	– 100 is equivalent to A.

   for(int i=0;i<10;i++)
   {
       overall[i]=homework[i]*0.3+midterm[i]*0.3+final[i]*0.4;
       if(overall[i]>=60)
       letter[i]='A';
       else if(overall[i]>=30 && overall[i]<59)
       letter[i]='C';
       else
       letter[i]='F';
       
       printf("student %d overall grade is %f his or her grade letter is %c\n",i+1,overall[i],letter[i]);
   }
    return 0;
}

#include <stdio.h>
#include <stdlib.h>
void printPattern;

int main() {
   int n=5;
   for(int i=1;i<=n;i++)
   {
       for(int j=1;j<=i;j++)
       {
           printf("*");
       }
       printf("\n");
   }
return 0;
}

// Online C compiler to run C program online
#include <stdio.h>
#include <stdlib.h>

int main() {
    int arr[5]= {1,2,3,5,4};
    int i,j;
    int un=0;
    for(int i=0;i<5;i++)
    {
        printf("%d ",i);
        for(j=i+1;j<5;j++)
        {
            if(arr[i]==arr[j])
            {
                un=1;
                break;
            }
        }
        
    }
    if(un==1)
    {
        printf("the value is not unique:");
    }
    else
    {
        printf("the value is unique");
    }
    

    return 0;
}

displaying pattern

    *
   ***
  *****
 *******

finding the minimum in an array

finding the maximum in an array

find all peak points in the array

printing the contents of the array in reverse order

reverse the contents of array

count the occurence of a specific value

merge two arrays together __arr = arr1 +  arr2

find the second largest element in the array

union of two sorted arrays

#include <stdio.h>
#include <stdlib.h>
void findMinimum(int arr[],int n);
void findMaximum(int arr[],int n);
void findPeaks(int arr[],int n);
void printReverse(int arr[],int n);
void reverse1(int arr[],int n);
void reverse2(int arr[],int n);
void printArray(int arr[], int n);
void countOccurence(int arr[],int n,int val);
void merge(int arr1[],int n1,int arr2[], int n2);
void secondLargest(int arr[], int n);


int main()
{
    int arr[10];
    int i;
    for(i=0;i<10;i++)
    {
        printf("Enter element %d: ",(i+1));
        scanf("%d",&arr[i]);
    }
    //findMinimum(arr,10);
    //findMaximum(arr,10);
    //findPeaks(arr,10);
    //printReverse(arr,10);
    //reverse1(arr,10);
    //reverse2(arr,10);
    countOccurence(arr,10,5);


    return 0;
}


void secondLargest(int arr[], int n)
{
    int max = arr[0];
    int min = arr[0];
    int i;
    for(i=1;i<n;i++)
    {
        if(arr[i]>max)
            max=arr[i];
        if(arr[i]<min)
            min=arr[i];
    }
    int max2=min;
    for(i=0;i<n;i++)
    {
        if(arr[i]!=max && arr[i]>max2)
        {
            max2=arr[i];
        }
        
    }
    
    
}


void merge(int arr1[],int n1,int arr2[], int n2)
{
    int merge[n1+n2];
    int i;
    for(i=0;i<n1;i++)
    {
        merge[i]=arr1[i];
    }
    for(i=0;i<n2;i++)
    {
        merge[n1+i]=arr2[i];
    }
    
}

void countOccurence(int arr[],int n, int val)
{
    int i;
    int counter=0;
    for(i=0;i<n;i++)
    {
        if(arr[i]==val)
            counter++;
    }

    printf("%d appears %d times in the array\n",val,counter);

}



void findMinimum(int arr[],int n)
{
    int min = arr[0];
    int minind = 0;
    int i;
    for(i=1;i<n;i++)
    {
        if(arr[i]<min)
            {min=arr[i];
             minind=i;}
    }
    printf("The min value is %d at index %d\n",min,minind);
}

void findMaximum(int arr[],int n)
{
    int max = arr[0];
    int maxind = 0;
    int i;
    for(i=1;i<n;i++)
    {
        if(arr[i]>max)
            {max=arr[i];
             maxind=i;}
    }
    printf("The max value is %d at index %d\n",max,maxind);
}

void findPeaks(int arr[],int n)
{
    int i;
    int peaks=0;
    for(i=1;i<9;i++)
    {
        if(arr[i]>arr[i-1] && arr[i]>arr[i+1])
         {
             printf("The value %d at index %d is a peak\n",arr[i],i);
             peaks++;
         }
    }

    if(peaks==0)
        printf("no peaks encountered");
}

void printReverse(int arr[],int n)
{
    int i;
    for(i=n-1;i>=0;i--)
    {
        printf("%d ",arr[i]);
    }
}

void reverse1(int arr[],int n)
{
    int revarr[n];
    int i;
    for(i=0;i<10;i++)
    {
        revarr[i]=arr[n-1-i];
    }
    printArray(revarr,10);
}

void reverse2(int arr[],int n)
{
   /* arr[0]<=>arr[9]
    arr[1]<=>arr[8]
    arr[2]<=>arr[7]
    arr[3]<=>arr[6]
    arr[4]<=>arr[5]*/
    int i,temp;
    for(i=0;i<(n/2);i++)
    {
        temp = arr[i];
        arr[i] = arr[n-1-i];
        arr[n-1-i] = temp;
    }

    printArray(arr,10);

}

void printArray(int arr[], int n)
{
    int i;
    for(i=0;i<n;i++)
        printf("%d ",arr[i]);
}

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


int main()
{
    /*
    // question 1
    int arr[10];
    int i;
    for(i=0;i<=9;i++)
    {
        printf("Element %d: ",i+1);
        scanf("%d",&arr[i]);
    }

    for(i=0;i<=9;i++)
    {
        printf("Element %d: %d\n",i+1,arr[i]);

    }*/


    /*
     // question 2
    int arr[10];
    int i;
    for(i=0;i<=9;i++)
    {
        printf("Element %d: ",i+1);
        scanf("%d",&arr[i]);
    }

    printf("Even numbers: ");
    for(i=0;i<=9;i++)
    {
        if(arr[i]%2==0)
            printf("%d ",arr[i]);
    }

    printf("\nOdd numbers: ");
    for(i=0;i<=9;i++)
    {
        if(arr[i]%2==1)
            printf("%d ",arr[i]);
    }

    */

    // q3
    int arr[10];
    int i;
    for(i=0;i<=9;i++)
    {
        printf("Element %d: ",i+1);
        scanf("%d",&arr[i]);
    }

    int sum=0;
    for(i=0;i<=9;i++)
    {
        sum=sum+arr[i];
    }
    printf("The sum of all elements is %d \n",sum);
    */


    //  Question 4
    /*
    int arr[10];
    int i;
    int evenCount=0, oddCount=0;
    for(i=0;i<=9;i++)
    {
        printf("Element %d: ",i+1);
        scanf("%d",&arr[i]);
    }

    for(i=0;i<=9;i++)
    {
        if(arr[i]%2==0)
            evenCount++;
        else
            oddCount++;
    }
    printf("The number of even elements is %d \n",evenCount);
    printf("The number of odd elements is %d \n",oddCount);
    */


 return 0;
 }

#include "MCMCLib.h"

// Define the log likelihood function
double log_likelihood(const gsl_vector *x, void *params)
{
    // Extract the parameters
    double mu = gsl_vector_get(x, 0);
    double sigma = gsl_vector_get(x, 1);

    // Compute the log likelihood
    double logL = -0.5 * log(2 * M_PI * sigma * sigma)
                  - 0.5 * (y - mu) * (y - mu) / (sigma * sigma);

    return logL;
}

// Define the function to perform MCMC sampling
void mcmc_sampling()
{
    // Set the initial values for the parameters
    gsl_vector *x = gsl_vector_alloc(2);
    gsl_vector_set(x, 0, mu0);
    gsl_vector_set(x, 1, sigma0);

    // Set the proposal distribution
    gsl_matrix *cov = gsl_matrix_alloc(2, 2);
    gsl_matrix_set_identity(cov);
    gsl_matrix_scale(cov, sigma_prop);

    // Set the MCMC options
    MCMCOptions options;
    options.n_burnin = 1000;
    options.n_iter = 10000;
    options.thinning = 10;

    // Set the MCMC data
    MCMCData data;
    data.n_params = 2;
    data.logL = log_likelihood;
    data.params = NULL;
    data.x = x;
    data.cov = cov;

    // Perform the MCMC sampling
    MCMCSample *sample = MCMCSample_alloc(options.n_iter);
    MCMC(options, data, sample);

    // Extract the samples
    for (int i = 0; i < sample->n; i++)
    {
        mu_samples[i] = gsl_vector_get(sample->x[i], 0);
        sigma_samples[i] = gsl_vector_get(sample->x[i], 1);
    }

    // Free the allocated memory
    MCMCSample_free(sample);
    gsl_vector_free(x);
    gsl_matrix_free(cov);
}

#include<stdio.h>

void WT(int processes[], int n, int bt[], int wt[])
{
	wt[0] = 0;
	
	for (int i = 1; i < n ; i++ )
		wt[i] = bt[i-1] + wt[i-1] ;
}

void TAT( int processes[], int n, int bt[], int wt[], int tat[])
{
	// bt[i] + wt[i]
	for (int i = 0; i < n ; i++)
		tat[i] = bt[i] + wt[i];
}

void AT( int processes[], int n, int bt[])
{
	int wt[n], tat[n], total_wt = 0, total_tat = 0;

	WT(processes, n, bt, wt);

	TAT(processes, n, bt, wt, tat);

	printf("Processes Bursttime Waitingtime Turn-aroundtime\n");

	for (int i=0; i<n; i++)
	{
		total_wt = total_wt + wt[i];
		total_tat = total_tat + tat[i];
		printf(" %d ",(i+1));
		printf("\t\t\t%d ", bt[i] );
		printf("\t\t\t\t%d ", wt[i] );
		printf("\t\t\t%d\n",tat[i] );
	}
	int s=(float)total_wt / (float)n;
	int t=(float)total_tat / (float)n;
	printf("Average waiting time = %d",s);
	printf("\n");
	printf("Average turn around time = %d ",t);
}

int main()
{
	int processes[] = { 1, 2, 3};
	int n = sizeof processes / sizeof processes[0];

	int burst_time[] = {10, 5, 8};

	AT(processes, n, burst_time);
	return 0;
}

#include <stdio.h>
int main()
{
   int i,j, k = 0;
   for (i = 1; i <= 5; ++i) {
      for (j = 1;j<= 5 - i; ++j) {
         printf("  ");
      }
      for(k=0;k!=2*i-1;++k) {
         printf("* ");
      }
      printf("\n");
   }
   return 0;
}

int char_to_int(char c) {
   if (c >= '0' && c <= '9') return c - '0';
   if (c >= 'A' && c <= 'F') return c - 'A' + 10;
   return 0; /* oops, something else... */
}

#include <stdint.h>
#include <stdio.h>

int main(void) {
  char myString[]="0x3f9d70a4";
  uint32_t num;
  float f;
  sscanf(myString, "%x", &num);  // assuming you checked input
  f = *((float*)&num);
  printf("the hexadecimal 0x%08x becomes %.3f as a float\n", num, f);
}

/*
  Rui Santos
  Complete project details at https://RandomNerdTutorials.com/esp32-microsd-card-arduino/
  
  Permission is hereby granted, free of charge, to any person obtaining a copy
  of this software and associated documentation files.
  
  The above copyright notice and this permission notice shall be included in all
  copies or substantial portions of the Software.
*/

// Libraries for SD card
#include "FS.h"
#include "SD.h"
#include <SPI.h>

//Libraries for BME280 sensor
#include <Adafruit_Sensor.h>
#include <Adafruit_BME280.h>

// Libraries to get time from NTP Server
#include <WiFi.h>
#include "time.h"

// Replace with your network credentials
const char* ssid     = "REPLACE_WITH_YOUR_SSID";
const char* password = "REPLACE_WITH_YOUR_PASSWORD";

// Timer variables
unsigned long lastTime = 0;
unsigned long timerDelay = 30000;

// BME280 I2C
Adafruit_BME280 bme;

// Variables to hold sensor readings
float temp;
float hum;
float pres;
String dataMessage;

// NTP server to request epoch time
const char* ntpServer = "pool.ntp.org";

// Variable to save current epoch time
unsigned long epochTime; 

// Function that gets current epoch time
unsigned long getTime() {
  time_t now;
  struct tm timeinfo;
  if (!getLocalTime(&timeinfo)) {
    //Serial.println("Failed to obtain time");
    return(0);
  }
  time(&now);
  return now;
}

// Initialize WiFi
void initWiFi() {
  WiFi.mode(WIFI_STA);
  WiFi.begin(ssid, password);
  Serial.print("Connecting to WiFi ..");
  while (WiFi.status() != WL_CONNECTED) {
    Serial.print('.');
    delay(1000);
  }
  Serial.println(WiFi.localIP());
}

// Init BME280
void initBME(){
  if (!bme.begin(0x76)) {
    Serial.println("Could not find a valid BME280 sensor, check wiring!");
    while (1);
  }
}

// Initialize SD card
void initSDCard(){
   if (!SD.begin()) {
    Serial.println("Card Mount Failed");
    return;
  }
  uint8_t cardType = SD.cardType();

  if(cardType == CARD_NONE){
    Serial.println("No SD card attached");
    return;
  }
  Serial.print("SD Card Type: ");
  if(cardType == CARD_MMC){
    Serial.println("MMC");
  } else if(cardType == CARD_SD){
    Serial.println("SDSC");
  } else if(cardType == CARD_SDHC){
    Serial.println("SDHC");
  } else {
    Serial.println("UNKNOWN");
  }
  uint64_t cardSize = SD.cardSize() / (1024 * 1024);
  Serial.printf("SD Card Size: %lluMB\n", cardSize);
}

// Write to the SD card
void writeFile(fs::FS &fs, const char * path, const char * message) {
  Serial.printf("Writing file: %s\n", path);

  File file = fs.open(path, FILE_WRITE);
  if(!file) {
    Serial.println("Failed to open file for writing");
    return;
  }
  if(file.print(message)) {
    Serial.println("File written");
  } else {
    Serial.println("Write failed");
  }
  file.close();
}

// Append data to the SD card
void appendFile(fs::FS &fs, const char * path, const char * message) {
  Serial.printf("Appending to file: %s\n", path);

  File file = fs.open(path, FILE_APPEND);
  if(!file) {
    Serial.println("Failed to open file for appending");
    return;
  }
  if(file.print(message)) {
    Serial.println("Message appended");
  } else {
    Serial.println("Append failed");
  }
  file.close();
}

void setup() {
  Serial.begin(115200);
  
  initWiFi();
  initBME();
  initSDCard();
  configTime(0, 0, ntpServer);
  
  // If the data.txt file doesn't exist
  // Create a file on the SD card and write the data labels
  File file = SD.open("/data.txt");
  if(!file) {
    Serial.println("File doesn't exist");
    Serial.println("Creating file...");
    writeFile(SD, "/data.txt", "Epoch Time, Temperature, Humidity, Pressure \r\n");
  }
  else {
    Serial.println("File already exists");  
  }
  file.close();
}

void loop() {
  if ((millis() - lastTime) > timerDelay) {
    //Get epoch time
    epochTime = getTime();
    
    //Get sensor readings
    temp = bme.readTemperature();
    //temp = 1.8*bme.readTemperature() + 32;
    hum = bme.readHumidity();
    pres = bme.readPressure()/100.0F;

    //Concatenate all info separated by commas
    dataMessage = String(epochTime) + "," + String(temp) + "," + String(hum) + "," + String(pres)+ "\r\n";
    Serial.print("Saving data: ");
    Serial.println(dataMessage);

    //Append the data to file
    appendFile(SD, "/data.txt", dataMessage.c_str());

    lastTime = millis();
  }
}

#include<stdio.h>
#include<conio.h>
void main()
{
   int a=10;
   int b=20;
   printf("%d \n",a<b); //true=1,false=0 a<=b,a>=bitand
   printf("%d \n",a==b); //t=1,f=0
   printf("%d \n",a!=b);
    getch();
}

#include<stdio.h>
#include<conio.h>
void main()
{
    int i=10;
    int x=i++;
    printf("%d \n",x);//10
    printf("%d \n",i);//11
    
    int j=5;
    int y=--j;//4
    printf("%d \n",y);
    getch();
}

#include<stdio.h>
#include<conio.h>
void main()
{
    int a=10;
    printf("%d \n",a);//10
    ++a;
    printf("%d \n",a);//11
    
    printf("%d \n",a++); //11
    
    printf("%d",a); //12
    
    getch();
}

#include<stdio.h>
#include<conio.h>
void main()
{
    int a,b,c,d;
    a=11;
    b=2;
    c=a%b;
    d=a/b;
    printf("reminder: %d \n",c);
    printf("quotient: %d",d);
}

#include<stdio.h>
#include<conio.h>

void main()
{
    int marks[10];
    
    marks[0]=50;
    marks[1]=20;
    
    for(int i=2;i<10;i++)
    {
        scanf("%d",&marks[i]);
    }
    
    for(int i=0;i<10;i++)
    {
        printf("marks: %d \n %d \n",i,marks[i]);    
    }
}

#include<stdio.h>
#include<conio.h>
void main()
{
    int a; //declaration
    a=5; //assign
    
    int b;
    b=2;
    
    int c,d,e;
    float f;
    c=a+b;
    d=a-b;
    e=a*b;
     f=(float)a/b;
    printf("%d %d %d %f",c,d,e,f);
    
}

#include<stdio.h>
#include<conio.h>
void main()
{
    char grade='A';
    printf("grade: %c \n",grade);
    
    double accuracy=10.12312344;
    printf("ACCURACY: %lf",accuracy); //lf= long float
    
}    
    

#include<stdio.h>
#include<conio.h>
void main()
{
    int a=5;
    printf("%d \n",a); //%d etc are  format specifiers \n new line command
    
    float b=9.2;
    printf("%f",b);
    
    getch();
}

#include<stdio.h>
#include<conio.h>
void main()
{
    int a; //declaration
    a=10; //assign
    
    int b;
    b=20;
    
    int c,d,e,f;
    c=a+b;
    d=a-b;
    e=a*b;
    f=a/b;
    printf("%d %d %d %d",c,d,e,f);
    
}

// Queue implementation in C

#include <stdio.h>
#include <stdlib.h>
#define SIZE 5

void enqueue();
void dequeue();
void display();

int items[SIZE], front = -1, rear = -1;

int main() {
  //deQueue is not possible on empty queue
  int x;
  
  printf("1 for enqueue\n");
  printf("2 for dequeue\n");
  printf("3 for display\n");
  printf("0 for exit\n");
  while(1)
  {
      printf("enter choise:");
      scanf("%d",&x);
      
      switch(x)
      {
        case 1:
            enqueue();
            break;
        case 2:
            dequeue();
            break;
        case 3:
            display();
            break;
        case 0:
            exit(1);
            printf("EXIT");
        default:
            printf("plz enter valid number\n");
      }
  }

  return 0;
}

void enqueue(){
    int value;
    
    printf("enter value to enqueue:");
    scanf("%d",&value);
    
  if (rear == SIZE - 1)
    printf("\nQueue is Full!!");
  else {
    if (front == -1)
      front = 0;
    rear++;
    items[rear] = value;
    printf("\nInserted -> %d\n", value);
  }
}

void dequeue(){
  if (front == -1)
    printf("\nQueue is Empty!!");
  else {
    printf("\nDeleted : %d\n", items[front]);
    front++;
    if (front > rear)
      front = rear = -1;
  }
}

// Function to print the queue
void display(){
  if (rear == -1)
    printf("\nQueue is Empty!!!");
  else {
    int i;
    printf("\nQueue elements are:\n");
    for (i = front; i <= rear; i++)
      printf("%d  ", items[i]);
  }
  printf("\n");
}

#include<stdio.h>
#include <stdlib.h>
int s[100],top=0,n;

void push()
{
    int x;
    
    if(top>=n)
    {
        printf("stack overflow\n");
    }
    else
    {
        printf("enter number:");
        scanf("%d",&x);
        top++;
        s[top]=x;
    }
}
void pop()
{
    if(top<=0)
    {
        printf("stack underflow\n");
    }
    else
    {
        printf("%d is popped\n",s[top]);
        top--;
    }
}
void peep()
{
    int i;
    
    printf("enter ith position:");
    scanf("%d",&i);
    
    if(top-i+1<=0)
    {
        printf("stack underflow\n");
    }
    else
    {
        printf("%d is %dth valur from the top\n",s[top-i+1],i);
    }
}
void change()
{
    int i,x;
    
    printf("enter ith position from top to change:");
    scanf("%d",&i);
    
    if(top-i+1<=0)
    {
        printf("stack underflow\n");
    }
    else
    {
        printf("enter new value:");
        scanf("%d",&x);
        
        s[top-i+1]=x;
        printf("new value of %dth position from top is %d\n",i,x);
    }
    
}
int main()
{
    int choise;
    
    printf("enter length of stack:");
    scanf("%d",&n);
    
    printf(" 1 for push \n");
    printf(" 2 for pop \n");
    printf(" 3 for peep \n");
    printf(" 4 for change \n");
    printf(" 0 for exit \n");
    
    
    while(1)
    {
        printf("enter choise:");
        scanf("%d",&choise);
        
        switch(choise)
        {
            case 1:
                push();
                break;
            case 2:
                pop();
                break;
            case 3:
                peep();
                break;
            case 4:
                change();
                break;
            case 0:
                exit(1);
                break;
            default:
                printf("enter valid number\n");
                
        }
    }
}

#include <stdio.h>

int main() {
    int myInt;
    myInt = 0xFFFFFFE2;
    printf("%d\n",myInt);

    return 0;
}

#include <cs50.h>
#include <stdio.h>

int main(void)
         {
         int x = get_int("x: ");
		 int y = get_int("y: ");
		 int z = x + y;
		 printf("%i\n", z);
         }

#include <stdio.h>

main(){
    int myAge[5];
    myAge[0] = 2;
    myAge[1] = 3;
    myAge[2] = 4;
    myAge[3] = 5;
    myAge[4] = 6;
    printf("my age is %i", myAge[0]);
    return 0;
}

#include <stdio.h>

main(){
    int age[5] = {2, 3, 4, 5, 6};
    printf("%d \n", age[0]);
    printf("%d \n", age[2]);
    printf("%d \n", age[3]);
    printf("%d \n", age[4]);
    return 0;
}

#include <cs50.h>
#include <studio.h>

int main(void)
         {
         string answer = get_string("What's your name? ");
		 printf("hello, %s\n", answer);
         }

#include <stdio.h>  
int binarySearch(int a[], int beg, int end, int val)    
{    
    int mid;    
    if(end >= beg)     
    {        mid = (beg + end)/2;    
/* if the item to be searched is present at middle */  
        if(a[mid] == val)    
        {                 
            return mid+1;    
        }    
            /* if the item to be searched is smaller than middle, then it can only be in left subarray */  
        else if(a[mid] < val)     
        {  
            return binarySearch(a, mid+1, end, val);    
        }    
            /* if the item to be searched is greater than middle, then it can only be in right subarray */  
        else     
        {  
            return binarySearch(a, beg, mid-1, val);    
        }          
    }    
    return -1;     
}   
int main() {  
  int a[] = {11, 14, 25, 30, 40, 41, 52, 57, 70}; // given array  
  int val = 40; // value to be searched  
  int n = sizeof(a) / sizeof(a[0]); // size of array  
  int res = binarySearch(a, 0, n-1, val); // Store result  
  printf("The elements of the array are - ");  
  for (int i = 0; i < n; i++)  
  printf("%d ", a[i]);   
  printf("\nElement to be searched is - %d", val);  
  if (res == -1)  
  printf("\nElement is not present in the array");  
  else  
  printf("\nElement is present at %d position of array", res);  
  return 0;  
}  

#include <stdlib.h>
#include <stdio.h>
#include <windows.h>
#include <psapi.h>
#define SIZE_TAB 200

volatile char program[SIZE_TAB];
CRITICAL_SECTION CriticalSection;
DWORD WINAPI aa(void *v);
DWORD WINAPI bb(void *v);

int main(int argc, char *argv[])
{
InitializeCriticalSection(&CriticalSection);

HANDLE thread_a = CreateThread(NULL, 0, aa, 0, 0, 0);
HANDLE thread_b = CreateThread(NULL, 0, bb, 0, 0, 0);

while (1)
{
    for (int i = 0; i<SIZE_TAB; i++)
        printf("%c", program[i]);
    Sleep(1000);
    printf("\n\n");
}

DeleteCriticalSection(&CriticalSection);

CloseHandle(thread_a);
CloseHandle(thread_b);
return 0;
}


 DWORD WINAPI aa(void *v)
 {

    EnterCriticalSection(&CriticalSection);
    for (int i = 0; i < SIZE_TAB; i++)
    {
        program[i] = 'A';
        for (int j = 0; j<8000; j++);
    }
    LeaveCriticalSection(&CriticalSection);

   }

   DWORD WINAPI bb(void *v)
   {

    EnterCriticalSection(&CriticalSection);
    for (int i = 0; i<SIZE_TAB; i++)
    {
        program[i] = 'B';
        for (int j = 0; j<8000; j++);
    }
    LeaveCriticalSection(&CriticalSection);
   } 

static void send_binary(esp_mqtt_client_handle_t client)
{
    spi_flash_mmap_handle_t out_handle;
    const void *binary_address;
    const esp_partition_t *partition = esp_ota_get_running_partition();
    esp_partition_mmap(partition, 0, partition->size, SPI_FLASH_MMAP_DATA, &binary_address, &out_handle);
    // sending only the configured portion of the partition (if it's less than the partition size)
    int binary_size = MIN(CONFIG_BROKER_BIN_SIZE_TO_SEND,partition->size);
    int msg_id = esp_mqtt_client_publish(client, "/topic/binary", binary_address, binary_size, 0, 0);
    ESP_LOGI(TAG, "binary sent with msg_id=%d", msg_id);
}

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

int main()
{
    printf("Hello world!\n");
    return 0;
}

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

int main()
{
int favNum = 90;
printf("My fav %s is %d", "number", 500);

    return 0;
}

#include <stdio.h>

#include <stdlib.h>


int main()

{

 int luckyNumber[] = {2, 2, 3, 33, 1};

 luckyNumber[1] = 200;

 printf("%d", luckyNumber[1]);

 return 0;

}

#include <stdio.h>

#include <stdlib.h>


int main()

{

 int luckyNumber[] = {2, 2, 3, 33, 1};

 printf("%d", luckyNumber[3]);

 return 0;

}

#include <stdio.h>

#include <stdlib.h>


int main()

{

 printf("Top");

 sayHi();

 printf("bottom");

 return 0;

}


VoidsayHi90(){

 printf("Hello world");

}

#include <stdio.h>

#include <stdlib.h>



int main()

{

 int num1;

 int num2;

 printf("Enter first number ");

 scanf("%d", &num1);

 printf("Enter second number ");

 scanf("%d", &num2);


 printf("Answer: %d, num1 + num2 ");


return 0;

}

#include <stdio.h>

#include <stdlib.h>


int main()

{

 char color[20];

 char pluralNoun [20];

 char personF[20];

 char personL[20];


 printf("Enter a color: ");

 scanf("%s", color);

 printf("Enter a pliuralNoun ");

 scanf("%s", pluralNoun);

 printf("Enter a person: ");

 scanf("%s%s", personF, personL);



 printf("The great American race is %s\n", color);

 printf("%s are Merican\n", pluralNoun);

 printf("I ate %s %s\n", personF, personL);


return 0;

}

#include <stdio.h>

main()
{
  printf("Hello Worlds\n");
  
  return 0;
}

char buffer[BUFFER_SIZE];
while (fscanf(stream, "%s", buffer) == 1) // expect 1 successful conversion
{
  // process buffer
}
if (feof(stream)) 
{
  // hit end of file
}
else
{
  // some other error interrupted the read
}

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

int main(){

    FILE *myFile;
    myFile = fopen("somenumbers.txt", "r");

    //read file into array
    int numberArray[16];
    int i;

    if (myFile == NULL){
        printf("Error Reading File\n");
        exit (0);
    }

    for (i = 0; i < 16; i++){
        fscanf(myFile, "%d,", &numberArray[i] );
    }

    for (i = 0; i < 16; i++){
        printf("Number is: %d\n\n", numberArray[i]);
    }

    fclose(myFile);

    return 0;
}

printf("Enter numbers from 1-1000 (To indicate you are done, enter 0)\n");
	
	// Getting input from user
	float input;
	for (int i = 0; i < numsLen; ++i) {
		printf("Enter a number: ");
		scanf("%f", &input);
		if (input == 0) break;
		nums[i] = input;
		++newLen;
	}

/*
  Rui Santos
  Complete project details at https://RandomNerdTutorials.com/esp8266-nodemcu-webserial-library/
  
  This sketch is based on the WebSerial library example: ESP8266_Demo
  https://github.com/ayushsharma82/WebSerial
*/

#include <Arduino.h>
#include <ESP8266WiFi.h>
#include <ESPAsyncTCP.h>
#include <ESPAsyncWebServer.h>
#include <WebSerial.h>

#define LED 2

AsyncWebServer server(80);

const char* ssid = "REPLACE_WITH_YOUR_SSID";          // Your WiFi SSID
const char* password = "REPLACE_WITH_YOUR_PASSWORD";  // Your WiFi Password

void recvMsg(uint8_t *data, size_t len){
  WebSerial.println("Received Data...");
  String d = "";
  for(int i=0; i < len; i++){
    d += char(data[i]);
  }
  WebSerial.println(d);
  if (d == "ON"){
    digitalWrite(LED, LOW);
  }
  if (d=="OFF"){
    digitalWrite(LED, HIGH);
  }
}

void setup() {
  Serial.begin(115200);
  pinMode(LED, OUTPUT);
  digitalWrite(LED, HIGH);
  WiFi.mode(WIFI_STA);
  WiFi.begin(ssid, password);
  if (WiFi.waitForConnectResult() != WL_CONNECTED) {
    Serial.printf("WiFi Failed!\n");
    return;
  }
  Serial.println("IP Address: ");
  Serial.println(WiFi.localIP());
  // WebSerial is accessible at "<IP Address>/webserial" in browser
  WebSerial.begin(&server);
  WebSerial.msgCallback(recvMsg);
  server.begin();
}

void loop() {
  WebSerial.println("Hello!");
  delay(2000);
}

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

int main () {
   int i, n;
   time_t t;
   
   n = 5;
   
   /* Intializes random number generator */
   srand((unsigned) time(&t));

   /* Print 5 random numbers from 0 to 49 */
   for( i = 0 ; i < n ; i++ ) {
      printf("%d\n", rand() % 50);
   }
   
   return(0);
}

float rstoc(x) {
  float decimal = abs(x - trunc(x));

  float random_selector = (float)rand() / RAND_MAX;

  float adjustor;
  if (random_selector < decimal) adjustor = 1;
  else adjustor = 0;

  // consider sign
  if(x < 0) adjustor = -1 * adjustor;

  return trunc(x) + adjustor;
}

int solution(int n) {
    int right = n & -n;    // 가장 오른쪽 1인 비트의 값
    int x     = n + right; // 원래 수 + 가장 오른쪽 비트
    
    return x | (((x ^ n) >> 2) / right); // 줄어든 1의 개수만큼 오른쪽부터 채운다
}

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

struct node {
   int data;
   int key;
   struct node *next;
};

struct node *head = NULL;
struct node *current = NULL;

//display the list
void printList() {
   struct node *ptr = head;
   printf("\n[ ");
	
   //start from the beginning
   while(ptr != NULL) {
      printf("(%d,%d) ",ptr->key,ptr->data);
      ptr = ptr->next;
   }
	
   printf(" ]");
}

//insert link at the first location
void insertFirst(int key, int data) {
   //create a link
   struct node *link = (struct node*) malloc(sizeof(struct node));
	
   link->key = key;
   link->data = data;
	
   //point it to old first node
   link->next = head;
	
   //point first to new first node
   head = link;
}

//delete first item
struct node* deleteFirst() {

   //save reference to first link
   struct node *tempLink = head;
	
   //mark next to first link as first 
   head = head->next;
	
   //return the deleted link
   return tempLink;
}

//is list empty
bool isEmpty() {
   return head == NULL;
}

int length() {
   int length = 0;
   struct node *current;
	
   for(current = head; current != NULL; current = current->next) {
      length++;
   }
	
   return length;
}

//find a link with given key
struct node* find(int key) {

   //start from the first link
   struct node* current = head;

   //if list is empty
   if(head == NULL) {
      return NULL;
   }

   //navigate through list
   while(current->key != key) {
	
      //if it is last node
      if(current->next == NULL) {
         return NULL;
      } else {
         //go to next link
         current = current->next;
      }
   }      
	
   //if data found, return the current Link
   return current;
}

//delete a link with given key
struct node* delete(int key) {

   //start from the first link
   struct node* current = head;
   struct node* previous = NULL;
	
   //if list is empty
   if(head == NULL) {
      return NULL;
   }

   //navigate through list
   while(current->key != key) {

      //if it is last node
      if(current->next == NULL) {
         return NULL;
      } else {
         //store reference to current link
         previous = current;
         //move to next link
         current = current->next;
      }
   }

   //found a match, update the link
   if(current == head) {
      //change first to point to next link
      head = head->next;
   } else {
      //bypass the current link
      previous->next = current->next;
   }    
	
   return current;
}

void sort() {

   int i, j, k, tempKey, tempData;
   struct node *current;
   struct node *next;
	
   int size = length();
   k = size ;
	
   for ( i = 0 ; i < size - 1 ; i++, k-- ) {
      current = head;
      next = head->next;
		
      for ( j = 1 ; j < k ; j++ ) {   

         if ( current->data > next->data ) {
            tempData = current->data;
            current->data = next->data;
            next->data = tempData;

            tempKey = current->key;
            current->key = next->key;
            next->key = tempKey;
         }
			
         current = current->next;
         next = next->next;
      }
   }   
}

void reverse(struct node** head_ref) {
   struct node* prev   = NULL;
   struct node* current = *head_ref;
   struct node* next;
	
   while (current != NULL) {
      next  = current->next;
      current->next = prev;   
      prev = current;
      current = next;
   }
	
   *head_ref = prev;
}

void main() {
   insertFirst(1,10);
   insertFirst(2,20);
   insertFirst(3,30);
   insertFirst(4,1);
   insertFirst(5,40);
   insertFirst(6,56); 

   printf("Original List: "); 
	
   //print list
   printList();

   while(!isEmpty()) {            
      struct node *temp = deleteFirst();
      printf("\nDeleted value:");
      printf("(%d,%d) ",temp->key,temp->data);
   }  
	
   printf("\nList after deleting all items: ");
   printList();
   insertFirst(1,10);
   insertFirst(2,20);
   insertFirst(3,30);
   insertFirst(4,1);
   insertFirst(5,40);
   insertFirst(6,56);
   
   printf("\nRestored List: ");
   printList();
   printf("\n");  

   struct node *foundLink = find(4);
	
   if(foundLink != NULL) {
      printf("Element found: ");
      printf("(%d,%d) ",foundLink->key,foundLink->data);
      printf("\n");  
   } else {
      printf("Element not found.");
   }

   delete(4);
   printf("List after deleting an item: ");
   printList();
   printf("\n");
   foundLink = find(4);
	
   if(foundLink != NULL) {
      printf("Element found: ");
      printf("(%d,%d) ",foundLink->key,foundLink->data);
      printf("\n");
   } else {
      printf("Element not found.");
   }
	
   printf("\n");
   sort();
	
   printf("List after sorting the data: ");
   printList();
	
   reverse(&head);
   printf("\nList after reversing the data: ");
   printList();
}

#include <stdio.h>

int main() {
    int marks[4];
    int *ptr;
    ptr = &marks[0];
    int i;
    
    for(i=0;i<4;i++){
        printf("enter the value of the marks: %d\n" , i+1);
        scanf("%d" , ptr);
        ptr++;
        
    }
     for(i=0;i<4;i++){
         printf(" the value of the marks %d is :%d\n" , i+1 , marks[i]);
     }
    
	//code
	return 0;
}

#include <stdio.h>
int factorial(int a);


int main() {
    int a =3;
    
    printf("the value of factorial is %d" , factorial(a));
	//code
	return 0;
}

int factorial(int a){
 
 
 if(a==0 || a==1){
     return 1;
 }else{
     return a * factorial(a-1);
 }
}

#include <stdio.h>
void printpattern(int n);

int main() {
    int n = 4;
    
    printpattern(n);
    
    
	//code
	return 0;
}
void printpattern(int n){
    int i;
    if(n == 1){
        printf("*\n");
        return;
    }
    printpattern(n-1);
    for(i=0;i<2*n-1;i++){
        printf("*");
        
    }
    printf("\n");
}

#include <stdio.h>
int fib(int a);

int main() {
    int a;
    printf("enter the number\n");
    scanf("%d" , &a);
    
    
    printf("the sequence will be %d" , fib(a));
	//code
	return 0;
}

int fib(int a){
    int f;
    if (a == 1 || a == 2){
        return 1;
        
    }else{
        f = fib(a-2) + fib(a-1);
        return f;
    }
}

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


int main() {
    
    int number , nguess=1 , guess;
    srand(time(0));
    number = rand()%100+1;
    
   // printf("the number is %d" , number);
    
    do{
        printf("guess the number between 1-100 %d\n" , guess);
        scanf("%d" , &guess);
        
        if(guess<number){
            
            printf("enter higher number\n");
            
        }
        else if(guess>number){
            
            printf("enter lower number\n");
        }
    else {
        
        printf("you guessed the number in %d attempts\n" , nguess);
    }
    
    nguess++;
    } while(guess!=number);
    
	//code
	return 0;
}

#include <stdio.h>

int main() {
    
    int i=1;
    int n;
    
    printf("enter the number\n");
    scanf("%d" , &n);
    
    do{
        printf("%d\n" , i*n);
        
        i++;
    }while(i <= 10);
	//code
	return 0;
}

#include <stdio.h>

int main() {
    
    int i = 0;
    
    for (i=0; i<50 ; i++) {
        
    if(i %2==0){
        
        printf("the n even numbers are %d\n" , i);
    }
        /* code */
    }
	//code
	return 0;
}

#include <stdio.h>

int main() {
    
     int year;
     printf("enter the year\n");
     scanf("%d" , &year);
     
     
     (year %4 ==0) ? (printf("the year is leap year")) : (printf("the year is not leap year"));
	//code
	return 0;
}

#include <stdio.h>

int main() {
    
    int i = 0;
    
    while(i<50){
        
        if(i %2==0){
            
            printf("the number is even %d\n" , i);
        }
        
        i++;
    }
	//code
	return 0;
}

#include <stdio.h>

int main() {
    
    float a , b , c , d;
    
    printf("enter the numbers\n");
    scanf(" %f %f %f %f" , &a , &b , &c , &d);
    
   
    if(a > b && a > c && a > d){
        
        printf("a is the greatesr number %f" , a);
    }
    
     if(b > a && b > c && b > d){
        
        printf("b is the greatesr number %f" , b);
    }
    
     if(c > b && c > a && c > d){
        
        printf("c is the greatesr number %f" , c);
    } 
    
    
    if(d > b && d > c && d > a){
        
        printf("d is the greatesr number %f" , d);
    }
	//code
	return 0;
}

#include <stdio.h>

int main() {
    int i = 0;
    int n;
    
    printf("enter the value of n\n");
    scanf("%d" , &n);
    
    
    do{
        
     printf("the first n numbers are %d\n" , i+1);
     
     i++;
    }
    while(i < n);
	//code
	return 0;
}

include <msp430.h>

int main(void)
{
    WDTCTL = WDTPW | WDTHOLD;                          // Stop watchdog timer

    // Configure two FRAM waitstate as required by the device datasheet for MCLK
    // operation at 24MHz(beyond 8MHz) _before_ configuring the clock system.
   // FRCTL0 = FRCTLPW | NWAITS_2;

    __bis_SR_register(SCG0);                           // disable FLL
    CSCTL3 |= SELREF__REFOCLK;                         // Set REFO as FLL reference source
    CSCTL0 = 0;                                        // clear DCO and MOD registers
    CSCTL1 |= DCORSEL_7;                               // Set DCO = 24MHz
    CSCTL2 = FLLD_0 + 732;                             // DCOCLKDIV = 24MHz
    __delay_cycles(3);
    __bic_SR_register(SCG0);                           // enable FLL
    while(CSCTL7 & (FLLUNLOCK0 | FLLUNLOCK1));         // FLL locked

    CSCTL4 = SELMS__DCOCLKDIV | SELA__REFOCLK;        // set default REFO(~32768Hz) as ACLK source, ACLK = 32768Hz
                                                       // default DCOCLKDIV as MCLK and SMCLK source
    CSCTL5 = DIVS_2;                                   // se divide totul la 2

    P1DIR |= BIT0 | BIT1 | BIT2;                       // set ACLK SMCLK and LED pin as output
    P1SEL1 |= BIT0 | BIT1;                             // set ACLK and  SMCLK pin as second function


    PM5CTL0 &= ~LOCKLPM5;                              // Disable the GPIO power-on default high-impedance mode
                                                       // to activate previously configured port settings

    while(1)
    {
        P1OUT ^= BIT2;                                 // Toggle P1.2 using exclusive-OR
        __delay_cycles(12000000);                       // Delay for 12000000*(1/MCLK)=0.5s
    }
}

#include <String.h>
#include <stdio.h>
int main() {
  // initializing the pointer string array
  char *names[] = {"tree", "bowl", "hat", "mice", "toon"};
  char *temp; // temporary variable for swaping the values
  int i, j, a;
  printf("The names are:\n");
  for (i = 0; i < 5; i++)
    printf("%s\n", names[i]);
  // arranging names in alphabetically using selection sort
  for (i = 0; i < 5; i++) {
    for (j = i + 1; j < 5; j++) {
      // compares the two string and returns an integer value
      // if the value of a is greater than 0 then swapping begins
      a = strcmp(names[i], names[j]);
      
      if (a > 0) {
        temp = names[i];
        names[i] = names[j];
        names[j] = temp;
      }
    }
  }
  printf("The arranged names are:\n");
  for (i = 0; i < 5; i++)
    printf("%s\n", names[i]);
  return 0;
}

#include "Arduino.h"
#include "SoftwareSerial.h"
#include "DFRobotDFPlayerMini.h"
#include <Adafruit_NeoPixel.h>
#include <Servo.h>

// sensors
#define LDR0pin A0 
#define LDR1pin A1 
#define LDR2pin A2 
#define LDR3pin A3 
#define LDR4pin A4 

// servos/motors
#define boo1pin 2
#define boo2pin 3
#define ceilingpin 4

// gun
#define buttpin 5
#define indipin 6
#define laserpin 7

// LEDs
#define melodypin 8
#define mompin 9
#define DATA_PIN 10 
#define NUM_LEDS 20 

// DFPlayer
SoftwareSerial mySoftwareSerial(12, 13); // TX, RX
DFRobotDFPlayerMini myDFPlayer;

// led strips
Adafruit_NeoPixel lightning_strip = Adafruit_NeoPixel(NUM_LEDS, DATA_PIN, NEO_GRB + NEO_KHZ800);
Adafruit_NeoPixel melody = Adafruit_NeoPixel(2, melodypin, NEO_GRB + NEO_KHZ800);
Adafruit_NeoPixel mom = Adafruit_NeoPixel(2, mompin, NEO_GRB + NEO_KHZ800);

// servos
// twelve servo objects can be created on most boards
Servo servo0;  // create servo1 object to control a servo1
Servo servo1;
Servo servo2;

// ADJUST FOR LIGHT THRESHOLDS
short laserThresh = 240;
short altThresh = 255;

// lightning
unsigned long flickerTime = 0, fadeInTime = 0;
byte i = 6, lowBright = 10, highBright = 255;
boolean lightState = true;

// boo servos
unsigned long booTime = 0;
boolean booState = false;

// mom, melody, ceiling trigger times
unsigned long momTime = 0, melodyTime = 0, ceilingTime = 0;

 // used for debouncing button
unsigned long lastDebounceTime = 0, highTime = 1, lasthighTime = 0;
byte buttonState, lastButtonState = HIGH;
boolean adjust = true;

// sensors
byte LDR0 = 0, LDR1 = 0, LDR2 = 0, LDR3 = 0, LDR4 = 0, LDR5 = 0;

void setup() {
  lightning_strip.begin();
  lightning_strip.setBrightness(lowBright);
  setLightning(0,255,0);

  melody.begin();
  melody.setBrightness(100);
  setMelody(0,0,0);

  mom.begin();
  mom.setBrightness(100);
  setMom(0,0,0);
  
  mySoftwareSerial.begin(9600);
  Serial.begin(9600);
  
  Serial.println();
  Serial.println(F("DFRobot DFPlayer Mini Demo"));
  Serial.println(F("Initializing DFPlayer ... (May take 3~5 seconds)"));
  
  if (!myDFPlayer.begin(mySoftwareSerial)) {  //Use softwareSerial to communicate with mp3.
    Serial.println(F("Unable to begin:"));
    Serial.println(F("1.Please recheck the connection!"));
    Serial.println(F("2.Please insert the SD card!"));
    while(true);
  }
  Serial.println(F("DFPlayer Mini online."));

  // CHANGE TO 20
  myDFPlayer.volume(30);  //Set volume value (0~30).

  // gun
  pinMode(laserpin, OUTPUT);
  pinMode(indipin, OUTPUT);
  pinMode(buttpin, INPUT_PULLUP);

  // sensors
  pinMode(LDR0pin, INPUT);
  pinMode(LDR1pin, INPUT);
  pinMode(LDR2pin, INPUT);
  pinMode(LDR3pin, INPUT);
  pinMode(LDR4pin, INPUT);

  // servos
  
  servo0.attach(boo1pin);
  servo1.attach(boo2pin);  // attaches the servo1 on pin 9 to the servo1 object
  servo2.attach(ceilingpin);

  // initialize servo positions:
  servo0.write(40); // boo1 swivels out RIGHT
  servo1.write(40); // boo2 swivels out LEFT
  servo2.write(90); // ceiling starts horizontal

  // opening song
  myDFPlayer.playMp3Folder(0);
}

void loop() {
  LDR0 = analogRead(LDR0pin);
  LDR1 = analogRead(LDR1pin);
  LDR2 = analogRead(LDR2pin);
  LDR3 = analogRead(LDR3pin);
  LDR4 = analogRead(LDR4pin);

  //trigger(trig_time, reload_time);
  //default (250, 1000)
  trigger(250, 1000);

  // boo(toggle_interval
  boo(2000);

  //lightning(flickerRate, blackout_time);
  lightning(150, 3000);
  lightning_strip.show();
  Serial.println(LDR4);

  //targetHit(playTime)
  melodyHit(4000);
  momHit(5500);
  ceiling(3000);
}

void ceiling (short playTime) {
  if (LDR4 > laserThresh) {
     ceilingTime = millis();
     myDFPlayer.playMp3Folder(4);
  }
  
  if (millis() - ceilingTime < playTime) servo2.write(0);
  else servo2.write(90);
}

void melodyHit (short playTime) {
  // if target hit, reset routine
  if (LDR2 > laserThresh) {
    melodyTime = millis();
    myDFPlayer.playMp3Folder(2);
  }

  if ((millis() - melodyTime < playTime)&&(melodyTime > 0)) setMelody(128, 0, 128);
  else setMelody(0, 0, 0);
}

void momHit (short playTime) {
  // if target hit, reset routine
  if (LDR3 > laserThresh) {
    momTime = millis();
    myDFPlayer.playMp3Folder(3);
  }

  if ((millis() - momTime < playTime)&&(momTime > 0)) setMom(128, 0, 128);
  else setMom(0, 0, 0);
}

void boo (short toggle_interval) {
  if (millis() - booTime > toggle_interval) {
    booState = !booState;
    booTime = millis();
  }
  
  if (booState)  {
    servo0.write(40);
    servo1.write(40);
  }
  
  else  {
    servo0.write(160);
    servo1.write(160);
  }
}

void lightning (short flickerRate, short blackout) {
  if (i > 6) i = 6;
  
  // if target hit, reset routine
  if ((LDR0 > laserThresh)||(LDR1 > laserThresh)) {
    i = 0;
    lightning_strip.setBrightness(highBright);
    lightState = true;
    myDFPlayer.playMp3Folder(1);
  }

  // flicker on/off 5 times at flickerRate
  if ((millis() - flickerTime > flickerRate)&& (i < 5)) 
  {
    lightState = !lightState;
    if (lightState) setLightning(255,255,255);
    else setLightning(0,0,0);
    i++;
    flickerTime = millis();
  }

  // lights stay off for blackout time
  else if ((millis() - flickerTime > blackout)&& (i == 5)) 
  {
    lightning_strip.setBrightness(lowBright);
    for (short j = 0 ; j < 255 ; ) {
      if (fadeInTime - millis() > 25) {
        setLightning(0, j, 0);
        j++;
      }
      fadeInTime = millis();
    }
    
    lightState = !lightState;
    flickerTime = millis();
    i++;
    
  }
}

void trigger(short trig_time, short reload) {
  adjust = digitalRead(buttpin);

  if (adjust != lastButtonState) {
    lastDebounceTime = millis();
  }
  
  if ((millis() - lastDebounceTime) > 50) {
    
    if (adjust != buttonState) {
      buttonState = adjust;
  
      if ((buttonState == LOW) && (millis() > 500)) {
        highTime = millis();
      }
    }
  }
  lastButtonState = adjust;

  if ((millis() - highTime <= trig_time)&&(millis() > 500)) {
    if (highTime-lasthighTime >= reload) {
      digitalWrite(laserpin, HIGH);
      lasthighTime = highTime;
    }
    digitalWrite(indipin, LOW);
  }
  else {
    digitalWrite(laserpin, LOW);
    digitalWrite(indipin, HIGH);
  }
}

// Set all LEDs to a given color and apply it (visible)
void setLightning (byte red, byte green, byte blue) {
  for(byte i = 0; i < NUM_LEDS; i++ ) {
    lightning_strip.setPixelColor(i, lightning_strip.Color(red, green, blue));
  }
  lightning_strip.show();
}

// Set all LEDs to a given color and apply it (visible)
void setMom (byte red, byte green, byte blue) {
  for(byte i = 0; i < 2; i++ ) {
    mom.setPixelColor(i, mom.Color(red, green, blue));
  }
  mom.show();
}

// Set all LEDs to a given color and apply it (visible)
void setMelody (byte red, byte green, byte blue) {
  for(byte i = 0; i < 2; i++ ) {
    melody.setPixelColor(i, melody.Color(red, green, blue));
  }
  melody.show();
}

// rdtsc.cpp
// processor: x86, x64
#include <stdio.h>
#include <intrin.h>

#pragma intrinsic(__rdtsc)

int main()
{
    unsigned __int64 i;
    i = __rdtsc();
    printf_s("%I64d ticks\n", i);
}

static void Main(string[] args)
{
    Action<int> firstAction = DoWorkWithOneParameter;
    Action<int, int> secondAction = DoWorkWithTwoParameters;
    Action<int, int, int> thirdAction = DoWorkWithThreeParameters;

    firstAction(1); // Print 1
    secondAction(1, 2); // Print 1-2
    thirdAction(1, 2, 3); //Print 1-2-3
}

public static void DoWorkWithOneParameter(int arg)
{
    Console.WriteLine(arg);
}

public static void DoWorkWithTwoParameters(int arg1, int arg2)
{
    Console.WriteLine(arg1 + "-" + arg2);
}

public static void DoWorkWithThreeParameters(int arg1, int arg2, int arg3)
{
    Console.WriteLine(arg1 + "-" + arg2 + "-" + arg3);
}

static void Main(string[] args)
{
    Action act = () =>
    {
        Console.WriteLine("No Parameter");
    };

    Action<int> actWithOneParameter = (arg1) =>
        {
            Console.WriteLine("Par: " + arg1);
        };

    Action<int, int> actWithTwoParameter = (arg1, arg2) =>
        {
            Console.WriteLine("Par1: " + arg1 + ", Par2: " + arg2);
        };

    act();
    actWithOneParameter(1);
    actWithTwoParameter(1, 2);
}

using System;

namespace pass_function_as_parameter
{
    class Program
    {
        static int functionToPass(int x)
        {
            return x + 10;
        }
        static void function(Func<int, int> functionToPass)
        {
            int i = functionToPass(22);
            Console.WriteLine("i = {0}", i);
        }
        static void Main(string[] args)
        {
            function(functionToPass);
        }
    }
}

using System;

namespace pass_function_as_parameter
{
    class Program
    {
        static void functionToPass2(int x)
        {
            int increment = x + 10;
            Console.WriteLine("increment = {0}",increment);
        }
        static void function2(Action<int> functionToPass2)
        {
            functionToPass2(22);
        }
        static void Main(string[] args)
        {
            function2(functionToPass2);
        }
    }
}

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

int check_fibonacci(int fibonacci[], int total)
{
    int i, j, result, sum;

    for(i = 0, j = 2; i < total - 2; i++,j++)
    {
        sum = fibonacci[i] + fibonacci[i+1];

        if(fibonacci[j] == sum)
        {
           result = 1;
        }
        else
        {
            result = 0;
        }
    }
    return result;
}


void main()
{

  int total;
  printf("co bao nhieu so : ");
  scanf("%d", &total);
  int fibonacci[total];

  for(int i = 0; i < total; i++)
  {
      printf("fibonacci %d = ", i + 1);
      scanf("%d", &fibonacci[i]);
  }

   if(check_fibonacci(fibonacci, total) == 1)
   {
       printf("\nla day so fibonacci");
   }
   else
   {
      printf("\nkhong phai day so fibonacci");
   }

}

$ gcc -shared libanswer.so answer.c

vector* sum( vector* v, int n ) {
    vector* r = ( vector* )( malloc( sizeof( vector ) ) );
    for( i = 0; i < n; i++ ) {
        r = add( r, v + i );
    }
    
    return r;
}

typedef struct __vector {
    int x;
    int y;
} vector;

vector* add( vector* a, vector* b ) {
    vector* r = ( vector* )( malloc( sizeof( vector ) ) );
    r->x = a->x + b->x;
    r->y = a->y + b->y;
    
    return r;
}

a = a ^ b;
b = a ^ b;
a = a ^ b;

#include<stdio.h>
#include<windows.h>



void ReadWay(int number)
{
SetConsoleOutputCP(65001);
     int ways;
      ways = number/10;

      switch(ways)
      {

        case 1:
            printf("mười ");
            break;
        case 2:
            printf("hai ");
            break;
        case 3:
            printf("ba ");
            break;
        case 4:
            printf("bốn ");
            break;
        case 5:
            printf("năm ");
            break;
        case 6:
            printf("sáu ");
            break;
        case 7:
            printf("bảy ");
            break;
        case 8:
            printf("tám ");
            break;
        case 9:
            printf("chín ");
            break;
      }

      ways = number%10;
      switch(ways)
      {
        case 0:
            ways = number/10;
            if(ways == 1)
            {
                printf("");
            }
            else
            {
               printf("mươi ");
            }

            break;
        case 1:
            ways = number/10;
            if(ways == 1)
            {
                printf("một");
            }
            else
            {
               printf("mươi mốt");
            }

            break;
        case 2:
            ways = number/10;
            if(ways == 1)
            {
                printf("hai");
            }
            else
            {
                printf("mươi hai");
            }

            break;
        case 3:
            ways = number/10;
            if(ways == 1)
            {
                printf("ba");
            }
            else
            {
                printf("mươi ba");
            }

            break;
        case 4:
            ways = number/10;
            if(ways == 1)
            {
                printf("bốn");
            }
            else
            {
                printf("mươi bốn");
            }

            break;
        case 5:
            ways = number/10;
            if(ways == 1)
            {
                printf("lăm");
            }
            else
            {
               printf("mươi lăm");
            }

            break;
        case 6:
            ways = number/10;
            if(ways == 1)
            {
                printf("sáu");
            }
            else
            {
                printf("mươi sáu");
            }

            break;
        case 7:
            ways = number/10;
            if(ways == 1)
            {
                printf("bảy");
            }
            else
            {
                printf("mươi bảy");
            }

            break;
        case 8:
            ways = number/10;
            if(ways == 1)
            {
                printf("tám");
            }
            else
            {
               printf("mươi tám");
            }

            break;
        case 9:
            ways = number/10;
            if(ways == 1)
            {
                printf("chín");
            }
            else
            {
               printf("mươi chín");
            }

            break;
      }
}


void main()
{
  SetConsoleOutputCP(65001);
  float number, save;
  save = number;
 do
{
   //check input data
   do
    {
    printf("nhập số nguyên: ");
    scanf("%f", &number);

    save = number;

        if(number != (int)number)
        {
        printf("lỗi! phải nhập số nguyên\n");
        }

    }while(number != (int)number);

   //end program
     if(number == 0)
    {
        exit(0);
    }

    system("cls");
    printf("%d đọc là: ", (int)save);

    ReadWay(number);

    printf("\n\nnếu muốn dừng chương trình! >>nhập 0<<\n\n");


}while(number != 0);


}

#include<stdio.h>

//sum
void CountTime(int day, int month, int year)
{
     int Dayth;
     printf("%d/%d/%d is: ", day, month, year);

     for(int i = 1; i < month;i++)
     {
         if( i == 1 || i == 3 || i == 5 || i == 7 || i ==  9 || i == 11)
         {
             if(month == 1)
             {
                Dayth = 0;
             }
             else
             {
                Dayth =  Dayth + 31;
             }

         }
         else if(i == 4 || i == 6 ||i == 8 || i == 10 || i == 12)
         {
             Dayth =  Dayth + 30;
         }
         else
         {
             Dayth =  Dayth + 28;
         }
     }

     printf("[%d]th day in year", Dayth + day);

}


void main()
{
  int day, month, year;


  //check input data
do
{
  do
  {
      printf("enter day: ");
      scanf("%d", &day);
      if(day > 31 || day <= 0)
      {
          printf(">>ERROR! day <= 30\n");
      }
  }while(day > 31 || day <= 0);

  do
  {
     printf("enter month: ");
     scanf("%d", &month);
     if(month > 12 || month < 1)
     {
         printf(">>ERROR! month >= 12\n");
     }
  }while(month > 12 || month < 1);

  if(month == 2 && day > 28 || month == 4 && day > 30 ||
       month == 6 && day > 30 || month == 8 && day > 30 ||
       month == 10 && day > 30 || month == 12 && day > 30)
  {
      printf(">>ERROR! day of month\n");
      printf("month [2] : 28 day\n");
      printf("month [4] [6] [8] [10] [12] : 30 day\n");
      printf("month [1] [3] [5] [7] [9] [11] : 31 day\n\n");
  }

}while(month == 2 && day > 28 || month == 4 && day > 30 ||
       month == 6 && day > 30 || month == 8 && day > 30 ||
       month == 10 && day > 30 || month == 12 && day > 30);

  do
  {
     printf("enter year: ");
     scanf("%d", &year);
     if(year < 2000)
     {
         printf(">>ERROR! year >= 2000");
     }
  }while(year < 2000);


  CountTime(day, month, year);
}

#include<stdio.h>



void NextTime(int day, int month, int year)
{
    // count day and month
    day = day + 1;
    printf("Next time: ");
    if(month == 1 || month == 3 || month == 5 || month == 7 || month == 9 || month == 11)
    {

        if(day > 31 && month < 12)
        {
           printf("1/%d/", month + 1);
        }
        else if(day <= 31 && month < 12)
        {
            printf("%d/%d/",day ,month);
        }
    }

    else if(month == 4 || month == 6 || month == 8 || month == 10 || month == 12)
    {
        if(day > 30 && month == 12)
        {
            printf("1/1/");
        }
        else if(day > 30 && month < 12)
        {
            printf("1/%d/", month + 1);
        }
        else if(day <= 30 && month <= 12)
        {
            printf("%d/%d/", day, month);
        }
    }
    else if(month == 2)
    {
        if(day > 28)
        {
        printf("1/3/");
        }
        else if(day <= 28)
        {
            printf("%d/2/", day);
        }
    }


//count year
  if( day > 30 && month == 12)
  {

     printf("%d", year + 1);
  }
  else if(day <= 31 && month < 12 || day > 31 && month < 12 )
  {
    printf("%d", year);
  }
}



void main()
{
  int day, month, year;


  //check input data
do
{
  do
  {
      printf("enter day: ");
      scanf("%d", &day);
      if(day > 31 || day <= 0)
      {
          printf(">>ERROR! day <= 30\n");
      }
  }while(day > 31 || day <= 0);

  do
  {
     printf("enter month: ");
     scanf("%d", &month);
     if(month > 12 || month < 1)
     {
         printf(">>ERROR! month >= 12\n");
     }
  }while(month > 12 || month < 1);

  if(month == 2 && day > 28 || month == 4 && day > 30 ||
       month == 6 && day > 30 || month == 8 && day > 30 ||
       month == 10 && day > 30 || month == 12 && day > 30)
  {
      printf(">>ERROR! day of month\n");
      printf("month [2] : 28 day\n");
      printf("month [4] [6] [8] [10] [12] : 30 day\n");
      printf("month [1] [3] [5] [7] [9] [11] : 31 day\n\n");
  }

}while(month == 2 && day > 28 || month == 4 && day > 30 ||
       month == 6 && day > 30 || month == 8 && day > 30 ||
       month == 10 && day > 30 || month == 12 && day > 30);

  do
  {
     printf("enter year: ");
     scanf("%d", &year);
     if(year < 2000)
     {
         printf(">>ERROR! year >= 2000");
     }
  }while(year < 2000);


  NextTime(day, month, year);
}

#include<stdio.h>



void increasing(float num1, float num2, float num3)
{
    float save = 0;
    printf("increasing: ");
    if(num1  > num2)
    {
        save = num2;
        num2 = num1;
        num1 = save;
    }
    if(num2 > num3)
    {
        save = num3;
        num3 = num2;
        num2 = save;
    }
    if(num1 > num2)
    {
        save = num2;
        num2 = num1;
        num1 = save;
    }
    printf("%.1f %.1f %.1f", num1, num2, num3);

}
void main()
{
  float num1, num2, num3;
    printf("enter number 1: ");
    scanf("%f", &num1);
    printf("enter number 2: ");
    scanf("%f", &num2);
    printf("enter number 3: ");
    scanf("%f", &num3);

  increasing(num1, num2, num3);
}

#include<stdio.h>


//change negative number to positive number
void change(float num1, float num2, float num3)
{
    printf("changed: [%.1f] [%.1f] [%.1f]", num1 * -1, num2 * -1, num3 * -1);
}
void main()
{
  float num1, num2, num3;
  printf("please enter negative numbers\n");
  
  //check input data 
  do 
  {
    printf("enter number 1: ");
    scanf("%f", &num1);
    printf("enter number 2: ");
    scanf("%f", &num2);
    printf("enter number 3: ");
    scanf("%f", &num3);

     if(num1 >= 0 || num2 >= 0 || num3 >= 0)
     {
      printf("please enter negative numbers\n");
     }
  }while(num1 >= 0);

  change(num1, num2, num3);
}

#include<stdio.h>

void main()
{
  int n, sum;
  int count = 0;
    printf("enter n: ");
    scanf("%d", &n);

    for(int i = 1; i < n;i++)
    {
      sum = sum + i;
       if(sum >= n)
       {
           break;
       }
       count = count + 1;
    }

    printf("count = %d", count);
}

#include<stdio.h>

void main()
{
  int n, sum;
    printf("enter n: ");
    scanf("%d", &n);

    for(int i = 1; i < n;i++)
    {
       if(i % 2 == 0)
       {
           continue;
       }
       sum = sum + i;
    }

    printf("sum of odd numbers = %d", sum);
}

#include<stdio.h>

void main()
{
    for(int i = 65; i <= 90;i++)
    {
       printf("%c, ", i);
    }
}

#include<stdio.h>



int FindX(int n)
{
    int sum, count;
    for(int j = 1; sum <= n;j++)
  {
    sum = sum + j;
        if(sum > n)
        {
        break;
        }
    count = count + 1;
  }
  return count;
}
void main()
{
int n;
    printf("enter n: ");
  do
   {
     scanf("%d", &n);
     if(n < 0)
       {
         printf("n must greater than 0")
       }
   }while(n < 0)
    
    printf("X = %d", FindX(n));
    getch();
}

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

//check duplicate ID
int check_ID(int ID[], int i)
{
 int result;

 for(int j = 0; j < i; j++)
 {
    if(ID[i] == ID[j])
    {
      result = 1;
    }
 }
   return result;
}

//input student information
void InputStudentInfor(int ID[], float grade[], int total)
{

 int i, j, check_input ;
 char temp;

 for(i = 0; i < total; i++)
 {
    do
    {
       printf("\n--> Student %d | ID: ", i+1);
       fflush(stdin);
       check_input = scanf("%d%c", &ID[i], &temp);//check_input will check how many values are scanned

       if(check_input == 2 && temp != '\n' || check_input == 0)
       {
         printf("\n--- ERROR! can't enter character\n");
       }
       else if(ID[i] < 0)
       {
         printf("\n--- ERROR! please, enter positive number\n");
       }
       else if(check_ID(ID, i)== 1)
       {
         printf("\n--- Student ID already exists\n");
       }
       else
       {
         break;
       }

    }while(check_input == 2 && temp != '\n' || check_input == 0 || ID[i] < 0 || check_ID(ID, i)== 1);


    do
    {
       printf("\n--> Grade %d : ", i+1);//check_input will check how many values are scanned
       fflush(stdin);
       check_input = scanf("%f%c", &grade[i], &temp);

       if(check_input == 2 && temp != '\n' || check_input == 0 )
       {
         printf("\n--- ERROR! can't enter character\n");
       }
       else if(grade[i] < 0 || grade[i] > 10)
       {
         printf("\n--- ERROR! please, enter number from 1 to 10\n");
       }
       else
       {
         break;
       }

    }while(check_input == 2 && temp != '\n' || check_input == 0 || grade[i] < 0 || grade[i] > 10);
 }
}

//


// Output information of student entered
void OutputStudentInfor(int ID[],float grade[], int total)
{
 for(int i = 0; i < total; i++)
 {
    printf("|%d Student ID: [%d] | Grade: %.2f |\n",i+1 ,ID[i], grade[i]);
 }
}

// Find maximum grade
float FindMaxGrade(float grade[], int total)
{
 float max = grade[0];
 for(int i = 1; i < total;i++ )
 {
    if( max < grade[i])
    {
      max = grade[i];
    }
 }
    return max;
}

//Fin minimum grade
float FindMinGrade(float grade[], int total)
{
 float min = grade[0];
 for(int i = 1; i < total;i++ )
 {
    if( min > grade[i])
    {
      min = grade[i];
    }
 }
    return min;
}

void main()
{
 int total, choice, check_input;
 char temp;
 system("color 0A");//change the color of all characters to green in the console window

   // enter the number of elements of the array and check input data
 do
 {
   printf("--> Enter total number of  student: ");
   fflush(stdin);
   check_input = scanf("%d%c", &total, &temp);//check_input will check how many values are scanned

   if(check_input == 2 && temp != '\n' || check_input  == 0)
   {
     printf("\n--- ERROR! can't enter character<<\n\n");
   }
   else if(total <= 0)
   {
     printf("\n--- ERROR! please, enter value must be greater than 0\n\n");
   }
   else
   {
     break;
   }

 }while(total <= 0 || check_input == 2 && temp !='\n' || check_input == 0);

 system("cls");

 int ID[total];
 float grade[total];

 printf(">>> Enter student ID and grade\n");

 InputStudentInfor(ID, grade, total);
 system("cls");
 printf(">>> Finished entering data");
   //menu initialization
 do
 {

    printf("\n\n\n\t\tMENU");
    printf("\n****************************************\n");
    printf("* 1. Re-enter data                     *\n");
    printf("* 2. print ID and grade of student     *\n");
    printf("* 3. Find maximum grade                *\n");
    printf("* 4. Find minimum grade                *\n");
    printf("* 5. Exit                              *\n");
    printf("****************************************\n\n");

 //check input data
    do
    {
        printf("--> Enter choice: ");
        fflush(stdin);
        check_input = scanf("%d%c", &choice, &temp);//check_input will check how many values are scanned

        if(check_input == 2 && temp != '\n' || check_input  == 0)
        {
            printf("\n--- ERROR! can't enter character<<\n\n");
        }
        else if(choice > 5 || choice < 1)
        {
            printf("\n--- ERROR! please choose from 1 to 5\n\n");
        }
        else
        {
            break;
        }

    }while(check_input == 2 && temp != '\n' || check_input  == 0 ||  choice > 5 || choice < 1);

    system("cls"); //delete screen

    //function selection
    switch(choice)
    {
        case 1:
            system("cls");
            printf(">>> Re-enter data\n\n");

            InputStudentInfor(ID, grade, total);

            printf(">>> Finished entering data");
            system("cls");
            break;

        case 2:
            system("cls");
            printf(">>> List ID and grade of student\n\n\n");

            OutputStudentInfor(ID, grade, total);
            break;

        case 3:
            system("cls");
            printf(">>> Maximum grade: %.2f \n", FindMaxGrade(grade, total));
            break;

        case 4:
            system("cls");
            printf(">>> Minimum grade: %.2f \n", FindMinGrade(grade, total));
             break;

        default :
            printf("\n>>> Program has ended!\n");
            exit(0);
    }

 }while(choice <= 4);
}

uint64_t rdtsc() {
  uint32_t hi, lo;
  __asm__ __volatile__ ("rdtsc" : "=a"(lo), "=d"(hi));
 
  return ( (uint64_t)lo)|( ((uint64_t)hi)<<32 );
 }

#include "sodium.h"

int foo() {
  char myString[32];
  uint32_t myInt;
  if (sodium_init() < 0) return 1;
  randombytes_buf(myString, 32);
  myInt = randombytes_uniform(10);
}

int fd = open("/dev/urandom", O_RDONLY);
if (fd == -1)
	goto nodevurandom
if (fstat(fd, &st) == -1 || !S_ISCHR(st.st_mode)) {
	close(fd);
	goto nodevrandom;
}
if (ioctl(fd, RNDGETENTCNT, &cnt) == -1) {
	close(fd);
	goto nodevrandom;
}
ssize_t ret = read(fd, (char *)buf + i, wanted);
if (ret == -1) {
	if (errno == EAGAIN || errno == EINTR)
		continue;
		close(fd);
		goto nodevrandom;
}
close(fd);
if (gotdata(buf, len) == 0) {
	errno = save_errno;
	return 0;
}
nodevrandom:
	errno = EIO;
	return -1;

int sum_num(int num[], int total)
{
    int sum;
    for(int i = 0; i < total;i++)
    {
        sum = sum +  num[i];
    }
    return sum;
}
int findmax(int num[], int total)
{
    int max;
    max = num[0];
    for(int i = 1; i < total;i++)
    {
        if(max < num[i])
            {
                max = num[i];
            }
    }
    return max;
}
int findmin(int num[], int total)
{
    int min;
    min = num[0];
    for(int i = 1; i < total;i++)
    {
        if(min > num[i])
            {
                min = num[i];
            }
    }
    return min;
}
void main()
{
   int sum, max, min, total;
    printf("enter total: ");
    scanf("%d", &total);
   int num[total];
   for(int i = 0;i < total;i++)
   {
      printf("num %d : ",i+1);
      scanf("%d", &num[i]);
   }

   sum = sum_num(num, total);
   max = findmax(num, total);
   min = findmin(num, total);
   printf("sum = %d\n", sum);
   printf("max = %d\nmin = %d", max, min);
}

#include<stdio.h>



int findexpon(int number, int index)
{
    int expon = 1;
    for(int i = 1; i <= index; i++)
    {
        expon = expon  * number;
    }

    return expon;
}

int finfact(int number)
{
    int sum;
    int fact = 1;
    for(int i = 1; i <= number; i++)
    {
        fact = fact * i ;
    }
    return fact;
}

void main()
{
    int number, fact, index, expon;
    printf("enter value :  ");
    scanf("%d", &number);
    printf("enter exponential: ");
    scanf("%d", &index);

    expon = findexpon(number, index);
    fact = finfact(number);
    
    if(index > 0)
      {
        printf("%d! = %d\n",number, fact);
        printf("%d^%d = %d", number, index, expon);
      }
    else
      {
        printf("enter exponential > 0")
      }


}

#include<stdio.h>
#include<stdbool.h>
#include<conio.h>
#include<math.h>
#include<string.h>

void main()
{
    float s, r, p;
    float area(float r);
    float perimeter(float r);
    printf("enter radius: ");
    scanf("%f", &r);
    s = area(r);
    p = perimeter(r);
    printf("area of circle is %f", s);
    printf("\nPerimeter of circle is %f", p);


}

float area(float r)
{
    float s;
    s = 3.14 * r * r;
    return s;
}

float perimeter(float r)
{
    float p = 2 * 3.14 * r;
    return p;

}

#include<stdio.h>
#include<stdbool.h>
#include<conio.h>
#include<math.h>
#include<string.h>

void main()
{
   int num1, num2, sum;
   char math;
   printf("Enter num 1: ");
   scanf("%d", &num1);
   printf("enter num 2: ");
   scanf("%d", &num2);
   fflush(stdin);
   printf("Enter calculation : ");
   scanf("%C", &math);
   switch(math)
   {
       case '+':
       sum = add(num1, num2);
       printf("%d + %d = %d",num1 ,num2, sum);
       break;
       case '-':
       sum = sub(num1, num2);
       printf("%d - %d = %d",num1 ,num2, sum);
   }




}

int add(int a, int b)
{
     int sum;
     sum = a + b;
    return sum;
}

int sub(int a, int b)
{
    int sum;
    a - b;
    return sum;
}

#include<stdio.h>

void main()
{
int month;
    printf("enter month: ");
    do
    {
       scanf("%d", &month);
       if(month <= 0 || month > 12)
       {
           printf("enter month from 1 to 12\n");
           printf("enter month: ");
       }
    }while(month <= 0 || month > 12);

  if(month == 1 || month == 2 || month == 3 )
  {
     printf("%d month is the 1st quarter", month);
  }
  else if(month == 4 || month == 5 || month == 6)
  {
     printf("%d month is the sendcon quarter", month);
  }
  else if(month == 7 || month == 8 || month == 9)
  {
     printf("%d month is the third quarter", month);
  }
  else
  {
     printf("%d month is the fourth quarter", month);
  }
}

#include<stdio.h>
#include<stdbool.h>
#include<conio.h>
#include<math.h>
#include<string.h>
//đếm số lượng chữ số của số nguyên dương
void main()
{
   int n;
   int i;
   int count = 0;
   printf("enter number: ");
   scanf("%d", &n);

   for(i = 1; i <= n; i++)
   {
    count++;
    n = n/10;
   }
    printf("entered number has %d digits", count+1);
    getch();
}

#include<stdio.h>
#include<stdbool.h>
#include<conio.h>
#include<math.h>
#include<string.h>

void main()
{
   int number;  
   int i, surplus, sum; 

   printf("enter number: "); // nhập số cần đảo ngược
   scanf("%d", &num);
   printf("how many digits in the entered number : ");
   scanf("%d", &sum);

   printf("reversed number of %d is ", num);
   for (i = 1; i <= sum;i++)
   {
       surplus = num%10;   // tìm số dư của số đã cho và in lần lượt sẽ được số đảo ngược
       printf("%d", surplus);
       num = num/10;
   }
  
    getch();
}

#include<stdio.h>
#include<stdbool.h>
#include<conio.h>
#include<math.h>
#include<string.h>

void main()
{
   int temp, i, j;
   temp = 0;
   char chars[20];

    printf("enter chars : ");
    gets(chars);

    if(chars[0] != 'G')
    {
        temp = 1;

    }
    else if (chars[1] != 'C')
    {
        temp = 1;

    }
    else
    {
        for (i = 2; i < strlen(chars);i++)
        {

            if(isdigit(chars[i]) == 0)
                {
                    temp = 1;
                }
                break;
        }
    }

     if ( temp == 0)
     {
         printf("student ID: ");
         puts(chars);
     }
     else
     {
        printf("enter error");
     }

    getch();

}

#include<stdio.h>
#include<stdbool.h>
#include<conio.h>
#include<math.h>
#include<string.h>

void main()
{
   int temp, i, j;
   temp = 0;
   char chars[20];

    printf("enter chars : ");
    gets(chars);

    for(i = 0, j = strlen(chars)-1; i < j; i++, j--)
    {
        if(chars[i] != chars[j])
        {
            temp = 1;
            break;
        }
    }

     if ( temp == 0)
     {
         printf("symmetric chain");
     }
     else
     {
        printf("not symmetric chain");
     }

    getch();

}

#include<stdio.h>
#include<stdbool.h>
#include<conio.h>
#include<math.h>
#include<string.h>

void main()
{
   int result;
   char studentID[20];

   printf("enter ID length  must is 7 characters: ");
A:
   gets(studentID);

   result = strlen(studentID);

   if(result == 7)
   {
       printf("true");
   }
   else
   {
       printf("ID length  must is 7 characters\n");
       printf("re-enter : ");
       goto A;
   }

    getch();

}

#include<stdio.h>
#include<stdbool.h>
#include<conio.h>
#include<math.h>
#include<string.h>

void main()
{
   int choice;
   int choose;
   char str1[20], str2[20];

   printf("enter string 1: ");
   gets(str1);
   printf("enter string 2: ");
   gets(str2);


  do
  {
   printf("\n");
   printf("==========================\n");
   printf("= 1. compare two strings =\n");
   printf("= 2. copy string         =\n");
   printf("= 3. concatenation       =\n");
   printf("= 4. exit                =\n");
   printf("==========================\n");

   printf("choice: ");
   scanf("%d", &choice);
   int result;

   switch(choice)
   {
   case 1:
    result = strcmp(str1, str2);
    if(result == 0)
    {
        printf("two strings is equal");
    }
    if (result > 0)
    {
       printf("string 1 > string 2");
    }
    else
    {
        printf("string 1 < string 2");
    }
    break;
   case 2:
       printf("you wants copy string 1 into 2(input: 1)or 2 into 1(input 2) ?\n");
       printf("choose: ");
       scanf("%d", &choose);
        if(choose == 2)
        {
            strcpy(str1, str2);
            printf("string 2: ");
            puts(str2);
            printf("string 1: ");
            puts(str1);

        }
        else
        {
            strcpy(str2, str1);
            printf("string 2: ");
            puts(str2);
            printf("string 1: ");
            puts(str1);
        }
        break;
   case 3:
        printf("you wants concatenation string 1 into 2(input: 1)or 2 into 1(input 2) ?\n");
        printf("choose: ");
         scanf("%d", &choose);
        if(choose == 2)
        {
            strcat(str1, str2);
            printf("string 1:");
            puts(str1);
        }
        else
        {
            strcat(str2, str1);
            printf ("string 2: ");
            puts(str2);

        }
    break;
   default :
       exit(0);
    break;
   }

  }while( choice <= 3);






    getch();

}

#include<stdio.h>
#include<stdbool.h>
#include<conio.h>
#include<math.h>
#include<string.h>

void main()
{
   char str[5][20];
   int i;

   for (i = 0; i < 5; i++)
   {
     printf("enter string %d: ", i+1);
     gets(str[i]);
   }

   for(i = 0;i<5;i++)
   {
      printf("string entered %: ", i+1);
      puts(str[i]);
   }


    getch();

}

#include<stdio.h>
#include<math.h>
#include<stdbool.h>
void main()
{
    int a[20];
    int j, i, k, h, save;

    i = -1;

    do
    {
        i++;
        printf("enter value a  %d = ", i + 1);
        scanf("%d", &a[i]);
    }while(a[i] >= 0);

    for (k = 0; k < i - 1; k++)
    {
        for (h =k + 1; h < i; h++)
        {
             if(a[k]>a[h])
             {
                save = a[k];
                a[k] = a[h];
                a[h] = save;
             }
        }
    }

   printf("a = ");
   for ( j = 0; j < i; j++ )
      printf("%d\t", a[j]);

  getch();
}

#include<stdio.h>
#include<math.h>
#include<stdbool.h>
void main()
{
    int A[20] ;
    int B[20];
    int i, j, n;

    printf("enter value n : ");
    scanf("%d", &n);


    for( i = 0; i < n; i++)
    {
        printf("A %d = ", i + 1);
        scanf("%d", &A[i]);



    }


        for (i = n-1, j = 0; i >= 0;i--, j++)
    {
        B[j] = A[i];

    }

    printf("B = ");
    for (j = 0; j < n;j++)
    {
        printf(" %d", B[j]);
    }


  getch();
}

#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
 
#define MY_TMP_FILE "/tmp/file.tmp"
 
 
int main(int argc, char* argv[])
{
    FILE * f;
    if (!access(MY_TMP_FILE, F_OK)) {
        printf external link("File exists!\n");
        return EXIT_FAILURE;
    }
    tmpFile = fopen(MY_TMP_FILE, "w");
 
    if (tmpFile == NULL) {
        return EXIT_FAILURE;
    }
 
    fputs("Some text...\n", tmpFile);
 
    fclose(tmpFile);
 
    return EXIT_SUCCESS;
}

#include <stdio.h>
int main () {
    char username[8];
    int allow = 0;
    printf external link("Enter your username, please: ");
    gets(username);
    if (grantAccess(username)) {
        allow = 1;
    }
    if (allow != 0) {
        privilegedAction();
    }
    return 0;
}

#define R(a,b) (((a) << (b)) | ((a) >> (32 - (b))))
void salsa20_word_specification(uint32 out[16],uint32 in[16])
{
    int i;
    uint32 x[16];
    for (i = 0;i < 16;++i) x[i] = in[i];
    for (i = 20;i > 0;i -= 2) {
        x[ 4] ^= R(x[ 0]+x[12], 7);  x[ 8] ^= R(x[ 4]+x[ 0], 9);
        x[12] ^= R(x[ 8]+x[ 4],13);  x[ 0] ^= R(x[12]+x[ 8],18);
        x[ 9] ^= R(x[ 5]+x[ 1], 7);  x[13] ^= R(x[ 9]+x[ 5], 9);
        x[ 1] ^= R(x[13]+x[ 9],13);  x[ 5] ^= R(x[ 1]+x[13],18);
        x[14] ^= R(x[10]+x[ 6], 7);  x[ 2] ^= R(x[14]+x[10], 9);
        x[ 6] ^= R(x[ 2]+x[14],13);  x[10] ^= R(x[ 6]+x[ 2],18);
        x[ 3] ^= R(x[15]+x[11], 7);  x[ 7] ^= R(x[ 3]+x[15], 9);
        x[11] ^= R(x[ 7]+x[ 3],13);  x[15] ^= R(x[11]+x[ 7],18);
        x[ 1] ^= R(x[ 0]+x[ 3], 7);  x[ 2] ^= R(x[ 1]+x[ 0], 9);
        x[ 3] ^= R(x[ 2]+x[ 1],13);  x[ 0] ^= R(x[ 3]+x[ 2],18);
        x[ 6] ^= R(x[ 5]+x[ 4], 7);  x[ 7] ^= R(x[ 6]+x[ 5], 9);
        x[ 4] ^= R(x[ 7]+x[ 6],13);  x[ 5] ^= R(x[ 4]+x[ 7],18);
        x[11] ^= R(x[10]+x[ 9], 7);  x[ 8] ^= R(x[11]+x[10], 9);
        x[ 9] ^= R(x[ 8]+x[11],13);  x[10] ^= R(x[ 9]+x[ 8],18);
        x[12] ^= R(x[15]+x[14], 7);  x[13] ^= R(x[12]+x[15], 9);
        x[14] ^= R(x[13]+x[12],13);  x[15] ^= R(x[14]+x[13],18);
    }
    for (i = 0;i < 16;++i) out[i] = x[i] + in[i];
}

i = 0
j = 0
for b in range(m):
    i = (i + 1) % 256
    j = (j + S[i]) % 256
    S[i], S[j] = S[j], S[i]
    KS[b] = S[(S[i] + S[j]) % 256]

j = 0;
S = range(256)
for i in range(256):
    j = (j + S[i] + K[i%n]) % 256
    S[i], S[j] = S[j], S[i]

#include <stdio.h>
int main()
{
	int lenght,bredth;
	int end;
	printf("what is the lenght of the rectangle \n");
	scanf("%d",&lenght);
	printf("what is the bredth of rectangle \n");
    scanf("%d",&bredth);
    printf("area of rectangle = %d \n",lenght*bredth);
    printf("Programe By Aaryan \n");
    printf("press any key to proseed");
    scanf("%d",&end);
	return 0;
} 

#include<stdio.h>
#define take(n) scanf("%d",&n);
#define rep(i,a,b) for(int i=a;i<b;i++)
void add_10(int n){
    printf("Enter a number\n");
    int x;
    take(x);
    printf("%d+%d=%d\n",n,x,n+x);
}
void multiply_10(int n){
    printf("Enter a number\n");
    int x;
    take(x);
    printf("%d*%d=%d\n",n,x,n*x);
}

int main()
{
    int n=10;
    char choice;
    int flag=0;
    do{
        printf("Enter your choice either a or b, any other to exit\n");
        scanf("%c",&choice);
        switch(choice){
            case 'A':
            case 'a': add_10(n);
            break;
            case 'B':
            case 'b': multiply_10(n);
            break;
            default: flag=1;
        }
    }while(flag==0);
return 0;
}

#include<stdio.h>
typedef struct student{
    int roll;
    char name[100];
    int marks[3];
}st;
void takeinput(st candidate[]){
     for(int i=0;i<5;i++){
        printf("\nFor student %d\n",i+1);
        printf("Enter the following details\n");
        printf("roll:");
        scanf("%d",&candidate[i].roll);
        printf("name:");
        scanf("%s",candidate[i].name);
        for(int j=0;j<3;j++){
            printf("marks in subject %d:",j+1);
            scanf("%d",&candidate[i].marks[j]);
        }
     }
}
void printinput(st candidate[]){
    printf("The details of all the students are as follows\n");
    for(int i=0;i<5;i++){
        printf("\nroll no:%d\nname:%s\n",candidate[i].roll,candidate[i].name);
        for(int j=0;j<3;j++){
            printf("marks in subject %d:%d\n",j+1,candidate[i].marks[j]);
        }
    }
}
void average_st_mks(st candidate[]){
    printf("Enter the serial number(1-5) of the student whose average marks to be known\n");
    int no;
    scanf("%d",&no);
    int sum=0;
    for(int i=0;i<3;i++) sum+=candidate[no-1].marks[i];
    float avg=(float)sum/3;
    printf("The average marks candidate bearing roll:%d is %.2f\n",candidate[no-1].roll,avg);
}
void average_subj_mks(st candidates[]){
    printf("Enter the serial number(1-3) of the subject whose average is to be known\n");
    int subject_number;
    scanf("%d",&subject_number);
    int sum=0;
    for(int i=0;i<5;i++){
        sum+=candidates[i].marks[subject_number-1];
    }
    float avg=(float)sum/5;
    printf("The average score of students in subject no:%d is %.2f\n",subject_number,avg);
}
void swap(st *candidate){
    printf("Enter the serial number(1-5) of student whose subject marks are to be swapped\n");
    int i;
    scanf("%d",&i);
    printf("Enter the serial number(1-3) of two subjects whose marks to be swapped\n");
    int a,b;
    scanf("%d%d",&a,&b);
    int temp=candidate[i-1].marks[a-1];
    candidate[i-1].marks[a-1]=candidate[i-1].marks[b-1];
    candidate[i-1].marks[b-1]=temp;
}
void print_mks_student(st candidate[]){
    printf("Enter the serial number(1-5) of the student you want to print marks\n");
    int n;
    scanf("%d",&n);
    for(int i=0;i<3;i++){
        printf("subject %d: %d mks\n",i+1,candidate[n-1].marks[i]);
    }
}
void upp_to_low(st candidate[]){
    printf("Enter the serial number(1-5) of student you want to convert name to lowercase\n");
    int n;
    scanf("%d",&n);
    int i=0;
    do{
        char ch=candidate[n-1].name[i];
        if(ch>=65 && ch<=90) candidate[n-1].name[i]=ch+32;
        i++;
    }while(candidate[n-1].name[i]!='\0');
    printf("student name changed to %s\n",candidate[n-1].name);
}
int main(){
    st candidate[5];
    int flag=1;
    char choice;
    do{
        printf("\nEnter the choice from the menu as per mentioned in the question paper\n");
        printf("The choice should be between a-g(lowercase)\nEnter any other character to stop the program\n");
        scanf(" %c",&choice);
        switch(choice){
        case 'a':takeinput(candidate);
        break;
        case 'b':printinput(candidate); 
        break;
        case 'c':average_st_mks(candidate);
        break;
        case 'd':average_subj_mks(candidate);
        break;
        case 'e':swap(candidate);
        break;
        case 'f':print_mks_student(candidate);
        break;
        case 'g':upp_to_low(candidate);
        break;
        default: flag=0;
        }
    }while(flag==1);
    return 0;
}

class int_ptr_wrapper
{
public:
    int_ptr_wrapper(int value = 0) :
    mInt(new int(value))
    {}

    // note! needs copy-constructor and copy-assignment operator!

    ~int_ptr_wrapper()
    {
        delete mInt;
    }

private:
    int* mInt;
};

class Wrapper
{
 private:
  CLib *lib;

 public:
  Wrapper() { lib = lib_init(); } // Lib initialisieren
  ~Wrapper() { lib_cleanup(&init); } // Lib freigeben

  std::string DoSomething() 
  { 
    char *cstr = lib_get_str(); // String anfordern (malloc!)

    std::string s = str;  // in std::string kopieren

    lib_free_str(cstr); // String freigeben (free)

    return s; // std::string zurückgeben. Alles easy.
  }
};

sdk_path="/Library/Developer/CommandLineTools/SDKs"

#include <stdio.h>

int main(){
  char str[20];
  
  fgets(str, 20, stdin); // read from stdin
  puts(str); // print read content out to stdout
  
  // open the file
  FILE *f = fopen("file.txt" , "r"); 
  
  // if there was an error
  if(f == NULL){
    perror("Error opening file"); // print error
    return(-1); 
  }
  // if there was no error
  else{ 
    fgets(str, 20, f); // read from file
    puts(str); // print read content out to stdout
  }
  
  fclose(f); // close file
  
  return(0);
}

#include "SevSeg.h"
SevSeg sevseg;

int LEDRa = 33;
int LEDGa = 32;

int LEDRb = 23;
int LEDGb = 22;

int LEDRc = 50;
int LEDGc = 51;

int LEDRd = 42;
int LEDGd = 43;

int IRa1 = 44;
int IRa2 = 52;

int IRb1 = 49;
int IRb2 = 48;

int IRc1 = 35;
int IRc2 = 37;

int IRd1 = 47;
int IRd2 = 46;

int RoadATraffic[] = {0, 0};
int RoadBTraffic[] = {0, 0};
int RoadCTraffic[] = {0, 0};
int RoadDTraffic[] = {0, 0};

char jam[] = {'a', 'b', 'c', 'd', 'a', 'b', 'c', 'd', 'a', 'b', 'c', 'd', 'a', 'b', 'c', 'd'};

void setup() {
  pinMode (LEDRa, OUTPUT);
  pinMode (LEDGa, OUTPUT);

  pinMode (LEDRb, OUTPUT);
  pinMode (LEDGb, OUTPUT);

  pinMode (LEDRc, OUTPUT);
  pinMode (LEDGc, OUTPUT);

  pinMode (LEDRd, OUTPUT);
  pinMode (LEDGd, OUTPUT);

  pinMode (IRa1, INPUT);
  pinMode (IRa2, INPUT);

  pinMode (IRb1, INPUT);
  pinMode (IRb2, INPUT);

  pinMode (IRc1, INPUT);
  pinMode (IRc2, INPUT);

  pinMode (IRd1, INPUT);
  pinMode (IRd2, INPUT);

  byte numDigits = 2;
  byte digitPins[] = {11, 10};
  byte segmentPins[] = {9, 8, 6, 3, 4, 7, 2, 5};
  bool resistorsOnSegments = true;

  byte hardwareConfig = COMMON_CATHODE;
  sevseg.begin(hardwareConfig, numDigits, digitPins, segmentPins, resistorsOnSegments);
  sevseg.setBrightness(90);

  Serial.begin(9600); // open the serial port at 9600 bps:
}

static int counter = 5;
int jam_ind = 0;
int current_route = 0;

void loop() {
    //display();
    RoadATraffic[0] = (digitalRead (IRa1) != 1) ? ( 1 ) : ( 0 );
    RoadATraffic[1] = (digitalRead (IRa2) != 1) ? ( 1 ) : ( 0 );

    RoadBTraffic[0] = (digitalRead (IRb1) != 1) ? ( 1 ) : ( 0 );
    RoadBTraffic[1] = (digitalRead (IRb2) != 1) ? ( 1 ) : ( 0 );

    RoadCTraffic[0] = (digitalRead (IRc1) != 1) ? ( 1 ) : ( 0 );
    RoadCTraffic[1] = (digitalRead (IRc2) != 1) ? ( 1 ) : ( 0 );

    RoadDTraffic[0] = (digitalRead (IRd1) != 1) ? ( 1 ) : ( 0 );
    RoadDTraffic[1] = (digitalRead (IRd2) != 1) ? ( 1 ) : ( 0 );

    int sum1 = RoadATraffic[0] + RoadATraffic[1];
    int sum2 = RoadBTraffic[0] + RoadBTraffic[1];
    int sum3 = RoadCTraffic[0] + RoadCTraffic[1];
    int sum4 = RoadDTraffic[0] + RoadDTraffic[1];

    Serial.print(current_route);
    Serial.print('\n');
    Serial.print(jam_ind);
    Serial.print('\n');
    Serial.print('\n');

    change_route(jam[current_route]);
    display();
      
    if (sum1 >= sum2 && sum1 >= sum3 && sum1 >= sum4) {     // Road A Jam
      if (jam[current_route] == 'a' && counter == 1) {
        increase_jam_ind();
        jam[jam_ind] = 'a';
      } else if (jam[current_route] != 'a' && jam[jam_ind] != 'a') {
        increase_jam_ind();
        jam[jam_ind] = 'a';
      }
    }

    if (sum2 >= sum1 && sum2 >= sum3 && sum2 >= sum4) { // Road B Jam
      if (jam[current_route] == 'b' && counter == 1) {
        increase_jam_ind();
        jam[jam_ind] = 'b';
      } else if (jam[current_route] != 'b' && jam[jam_ind] != 'b') {
        increase_jam_ind();
        jam[jam_ind] = 'b';
      }
    }
    
    if (sum3 >= sum1 && sum3 >= sum2 && sum3 >= sum4) { // Road C Jam
      if (jam[current_route] == 'c' && counter == 1) {
        increase_jam_ind();
        jam[jam_ind] = 'c';
      } else if (jam[current_route] != 'c' && jam[jam_ind] != 'c') {
        increase_jam_ind();
        jam[jam_ind] = 'c';
      }
    }
      
    if (sum4 >= sum1 && sum4 >= sum2 && sum4 >= sum3) { // Road D Jam
      if (jam[current_route] == 'd' && counter == 1) {
        increase_jam_ind();
        jam[jam_ind] = 'd';
      } else if (jam[current_route] != 'd' && jam[jam_ind] != 'd') {
        increase_jam_ind();
        jam[jam_ind] = 'd';
      }
    }  
}

void display() {
  for (int h = 1; h<10000; h++){
    sevseg.setNumber(counter);
    sevseg.refreshDisplay();  
  }
  if (counter <= 0) {
    counter = 5;
    current_route++;
  }

  if (current_route > 15) { 
    current_route = 0;
  }
  
  counter--;
}

void change_route(char route) {
  switch (route) {
    case 'a':
      digitalWrite(LEDGa, HIGH);
      digitalWrite(LEDRa, LOW);
    
      digitalWrite(LEDGb, LOW);
      digitalWrite(LEDRb, HIGH);
    
      digitalWrite(LEDGc, LOW);
      digitalWrite(LEDRc, HIGH);
    
      digitalWrite(LEDGd, LOW);
      digitalWrite(LEDRd, HIGH);
      break;

    case 'b':
      digitalWrite(LEDGa, LOW);
      digitalWrite(LEDRa, HIGH);
    
      digitalWrite(LEDGb, HIGH);
      digitalWrite(LEDRb, LOW);
    
      digitalWrite(LEDGc, LOW);
      digitalWrite(LEDRc, HIGH);
    
      digitalWrite(LEDGd, LOW);
      digitalWrite(LEDRd, HIGH);
      break;

    case 'c':
      digitalWrite(LEDGa, LOW);
      digitalWrite(LEDRa, HIGH);
    
      digitalWrite(LEDGb, LOW);
      digitalWrite(LEDRb, HIGH);
    
      digitalWrite(LEDGc, HIGH);
      digitalWrite(LEDRc, LOW);
    
      digitalWrite(LEDGd, LOW);
      digitalWrite(LEDRd, HIGH);
      break;

    case 'd':
      digitalWrite(LEDGa, LOW);
      digitalWrite(LEDRa, HIGH);
    
      digitalWrite(LEDGb, LOW);
      digitalWrite(LEDRb, HIGH);
    
      digitalWrite(LEDGc, LOW);
      digitalWrite(LEDRc, HIGH);
    
      digitalWrite(LEDGd, HIGH);
      digitalWrite(LEDRd, LOW);
      break;
  }
}

void increase_jam_ind() {
  jam_ind++;
  if (jam_ind > 15) {
    jam_ind = 0;
  }
}

#include <linux/limits.h>

char current_path[PATH_MAX];