The following program will help you to remove duplicates from an array.

#include <stdio.h>
int main() {
    int n, a[100], b[100], calc = 0, i, j,count;
    printf("Enter no. of elements in array: ");
    scanf("%d", &n);
    printf("Enter %d integers: ", n);
    for (i = 0; i < n; i++)
        scanf("%d", &a[i]);
          
    for (i = 0; i<n; i++) {
        for (j = 0; j<calc; j++) {
           if(a[i] == b[j])
           break;  
        }
        if (j== calc) {
             b[calc] = a[i];
             calc++; 
        }
     }
     
     printf("Array obtained after removing duplicate elements: ");
     for (i = 0; i<calc; i++) { 
            printf("%d ", b[i]);
     }
     return 0;
}

Yes, we can compile a program without main() function Using Macro.

E.g.

#include<studio.h>
#define abc main
int abc ()
{
printf("Hello World ");
return 0;
}

#include<stdio.h>
struct full_byte
{
char first : 4;
char second : 4;
};

union A
{
char x;
struct full_byte by;
};

main()
{
char c = 100;
union A a;
a.x = c;
printf("the two nibbles are: %d and %d\n", a.by.first, a.by.second);
}

To override a defined macro we can use #ifdef and #undef preprocessors as follows:

• #ifdef A
• #undef A
• #endif
• #define A 10

If macro A is defined, it will be undefined using undef and then defined again using define.

#include <stdio.h>
#include <conio.h>
int reverse(int num);
int isPalindrome(int num);
int main()
{
    int num;
    printf("Enter a number: ");
    scanf("%d", &num);
if(isPalindrome(num) == 1)
{
 printf("the given number is a palindrome");
    }
    else
    {
        printf("the given number is not a palindrome number");
   }
    return 0;
}

int isPalindrome(int num)
{
    if(num == reverse(num))
    {
        return 1;
    }
    return 0;
}
int reverse(int num)
{
int rem;
    static int sum=0;
    if(num!=0){
            rem=num%10;
            sum=sum*10+rem;
            reverse(num/10);
    }
        else
             return sum;
    return sum;
}

#include<stdio.h>
#include<conio.h>
int main() {
	int j,num;
	printf("Please enter a number :");
	scanf("%d",&num);
    while(num>0)
    {
        j=num%10;
        if( j!=0 && j!=1 )
        {
           printf("num is not binary");
           break;
        }
        num=num/10;
        if(num==0)
        {
            printf("num is binary");
        }
    }
	getch();
}

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

int sumOfDigits(int num)
    {
            static int sum = 0;
            int rem;
            sum = sum + (num%10);
            rem = num/10;
            if(rem > 0)
            {
                sumOfDigits(rem);
            }
            return sum;
    }
int main() {
	int j,num;
	printf("Please enter a number :");
	scanf("%d",&num);
    printf("sum of digits of the number = %d ",sumOfDigits(num));
    getch();
}

Single Linked List

Circular Linked List

Circular linked list is a variation of a linked list where the last node is pointing to the first node's information part. Therefore the last node does not point to null.

Algorithm to find whether the given linked list is circular

A very simple way to determine whether the linked list is circular or not

• Traverse the linked list
• Check if the node is pointing to the head.
• If yes then it is circular.

Let's look at the snippet where we code this algorithm.

Create a structure for a linked list
Declare
-Variable to store data of the node.
-Pointer variable of struct type to store the address of next node.

function of datatype tool isCircular(firstgode){

-Store the value of first node in temp variable and make it traverse all nodes.
-temp-firstgode
-tempenext node pointed by temp(temp->next)
-run until temp is at null or firstNode

if (temp at null)
                not circular and returns false 
if (temp points first node)
                return true as its circular.
	}
	
function of datatype node newNode(data){

-To insert new nodes and link each one of them to the previous node by storing the address of the new node to the previous one.
-Then make them point to NULL.
}

In int main function

-First insert nodes for circular linked list and check its nature by calling isCircular function.
-Since it is true through if statement it prints "yes..
-Second insert a normal linked list and check its nature by calling isCircular function. As its not circular it prints "no",

It is majorly related to how the compiler reads( or parses) the entire code and breaks it into a set of instructions(or statements), to which semicolon in C acts as a boundary between two sets of instructions.

To call a function before the main(), pragma startup directive should be used. E.g.-

#pragma startup fun
void fun()
{
printf("In fun\n");
}
main()
{
printf("In main\n");
}

The output of the above program will be -

In fun
In main

This pragma directive, on the other hand, is compiler-dependent. This is not supported by gcc. As a result, it will ignore the startup directive and produce no error. But the output, in that case, will be -

In main

The differences between macros and functions can be explained as follows:

The difference between the Source Code and Object Code is that Source Code is a collection of computer instructions written using a human-readable programming language while Object Code is a sequence of statements in machine language, and is the output after the compiler or an assembler converts the Source Code.

The last point about Object Code is the way the changes are reflected. When the Source Code is modified, each time the Source Code needs to be compiled to reflect the changes in the Object Code.

In C header files must have the extension as .h, which contains function definitions, data type definitions, macro, etc. The header is useful to import the above definitions to the source code using the #include directive. For example, if your source code needs to take input from the user do some manipulation and print the output on the terminal, it should have stdio.h file included as #include <stdio.h>, with which we can take input using scanf() do some manipulation and print using printf().

The keyword “void” is a data type that literally represents no data at all. The most obvious use of this is a function that returns nothing:

void PrintHello() 
{ 
                printf("Hello\n"); 
                return;		// the function does "return", but no value is returned 
} 

Here we’ve declared a function, and all functions have a return type. In this case, we’ve said the return type is “void”, and that means, “no data at all” is returned. 
The other use for the void keyword is a void pointer. A void pointer points to the memory location where the data type is undefined at the time of variable definition. Even you can define a function of return type void* or void pointer meaning “at compile time we don’t know what it will return” Let’s see an example of that.

void MyMemCopy(void* dst, const void* src, int numBytes) 
{ 
                char* dst_c = reinterpret_cast<char*>(dst); 
                const char* src_c = reinterpret_cast<const char*>(src); 
                for (int i = 0; i < numBytes; ++i) 
		dst_c[i] = src_c[i]; 
} 

A dynamic data structure (DDS) refers to an organization or collection of data in memory that has the flexibility to grow or shrink in size, enabling a programmer to control exactly how much memory is utilized. Dynamic data structures change in size by having unused memory allocated or de-allocated from the heap as needed. 

Dynamic data structures play a key role in programming languages like C, C++, and Java because they provide the programmer with the flexibility to adjust the memory consumption of software programs.

For the sum of two numbers, we use the addition (+) operator. In these tricky C programs, we will write a C program to add two numbers without using the addition operator.

#include<stdio.h>
#include<stdlib.h>
int main()
{
                int x, y;
                printf("Enter two number: ");
                scanf("%d %d",&x,&y);

                // method 1
                printf("%d\n", x-(-y));

                // method 2
                printf("%d\n", -(-x-y));

                // method 3
                printf("%d\n", abs(-x-y));

                // method 4
                printf("%d", x-(~y)-1);

                return 0;
}

#include<stdio.h>
#include<stdlib.h>
int main()
{
                int x, y;
                printf("Enter two number: ");
                scanf("%d %d",&x,&y);
                printf("%d", x+(~y)+1);
                return 0;
}

The bitwise complement operator is used in this program. The bitwise complement of number ~y=-(y+1). So, expression will become x+(-(y+1))+1=x-y-1+1=x-y

#include<stdio.h>
int main()
{
                int x;
                printf("Enter a number: ");
                scanf("%d",&x);
                printf("%d", x<<1);
                return 0;
}

The left shift operator shifts all bits towards the left by a certain number of specified bits. The expression x<<1 always returns x*2. Note that the shift operator doesn’t work on floating-point values.

For multiple of x by 4, use x<<2. Similarly x<<3 multiply x by 8. For multiple of the number x by 2^n, use x<<n.

#include<stdio.h>
int main()
{
                int x;
                printf("Enter a number: ");
                scanf("%d", &x);
   (x&1)?printf("Odd"):printf("Even");
                return 0;
}

The bitwise and(&) operator can be used to quickly check the number is odd or even.

Assume that we have linked list 1 → 2 → 3 → Ø, we would like to change it to Ø ← 1 ← 2 ← 3.

While you travel the linked list, change the current node's next pointer to point to its previous element. reference to the previous nodes should be stored into a temp variable as shown so that we don’t lose track of the swapped node. You also need another pointer to store the next node before changing the reference. Also when we are done return the new head of the reversed list.

/* Function to reverse the linked list */
static void reverse(struct Node** head_ref) 
{ 
                struct Node* prev   = NULL; 
                struct Node* current = *head_ref; 
                struct Node* next; 
                while (current != NULL) 
    { 
                // store next
        next  = current->next;   

                // reverse curr node pointer 
        current->next = prev;    

                // move pointer one position ahead
        prev = current; 
        current = next; 
    } 
    *head_ref = prev; 
}

Given a string s containing just the characters '(', ')', '{', '}', '[' and ']', determine if the input string is valid.

An input string is valid if:

• Open brackets must be closed by the same type of brackets.
• Open brackets must be closed in the correct order.

Example 1:
 Input: s = "()"
 Output: true

Example 2:
 Input: s = "()[]{}"
 Output: true

Example 3:
 Input: s = "(]"
 Output: false

Below is the source code for C Program to Check for Balanced Parentheses using Stack which is successfully compiled and run on Windows System to produce desired output as shown below :

int check(char exp[] )
{
                int i;
                char temp;
                for(i=0;i<strlen(exp);i++)
        {
                if(exp[i]=='(' || exp[i]=='{' || exp[i]=='[')
                        push(exp[i]);
                if(exp[i]==')' || exp[i]=='}' || exp[i]==']')
                if(top==-1)    /*stack empty*/
                        {
                printf("Right parentheses are more than left parentheses\n");
                return 0;
                        }
                else
                        {
                                temp=pop();
                if(!match(temp, exp[i]))
                                {
                printf("Mismatched parentheses are : ");
                printf("%c and %c\n",temp,exp[i]);
                return 0;
                                }
                        }
        }
                if(top==-1) /*stack empty*/
        {
                printf("Balanced Parentheses\n");
                return 1;
        }
                else
        {
                printf("Left parentheses more than right parentheses\n");
                return 0;
        }
}

Fibonacci sequence is characterized by the fact that every number after the first two is the sum of the two preceding ones. For example, consider below sequence

0, 1, 1, 2, 3, 5, 8, 13, 21, 34, . .. and so on

Where in F{n} = F{n-1} + F{n-2} with base values F(0) = 0 and <code>F(1) = 1

Below is naive implementation for finding the nth member of the Fibonacci sequence

// Function to find the nth Fibonacci number
int fib(int n)
{
                if (n <= 1) {
                return n;
    }
 
                return fib(n - 1) + fib(n - 2);
}
 
int main()
{
                int n = 8;
 
                printf("nth Fibonacci number is %d", fib(8));
 
                return 0;
}

Let's take an example of the following two linked lists which intersect at node c1.

Solution -

• Get count of the nodes in the first list, let count be c1.
• Get count of the nodes in the second list, let count be c2.
• Get the difference of counts d = abs(c1 – c2)
• Now traverse the bigger list from the first node till d nodes so that from here onwards both the lists have an equal no of nodes
• Then we can traverse both the lists in parallel till we come across a common node. (Note that getting a common node is done by comparing the address of the nodes)

// Function to get the intersection point 
// of the given linked lists 
int getIntersectionNode(Node* head1, Node* head2) 
{ 
    Node *curr1 = head1, *curr2 = head2; 
  
                // While both the pointers are not equal 
                while (curr1 != curr2) { 
  
                // If the first pointer is null then 
                // set it to point to the head of 
                // the second linked list 
                if (curr1 == NULL) { 
            curr1 = head2; 
        } 
  
                // Else point it to the next node 
                else { 
            curr1 = curr1->next; 
        } 
  
                // If the second pointer is null then 
                // set it to point to the head of 
                // the first linked list 
                if (curr2 == NULL) { 
            curr2 = head1; 
        } 
  
                // Else point it to the next node 
                else { 
            curr2 = curr2->next; 
        } 
    } 
  
                // Return the intersection node 
                return curr1->data; 
}

Merge two sorted linked lists and return them as a sorted list. The list should be made by splicing together the nodes of the first two lists.

NodePtr merge_sorted(NodePtr head1, NodePtr head2) {
  
                // if both lists are empty then merged list is also empty
                // if one of the lists is empty then other is the merged list
                if (head1 == nullptr) {
                return head2;
  } else if (head2 == nullptr) {
                return head1;
  }


  NodePtr mergedHead = nullptr;
                if (head1->data <= head2->data) {
    mergedHead = head1;
    head1 = head1->next;
  } else {
    mergedHead = head2;
    head2 = head2->next;
  }

  NodePtr mergedTail = mergedHead;
  
                while (head1 != nullptr && head2 != nullptr) {
    NodePtr temp = nullptr;
                if (head1->data <= head2->data) {
      temp = head1;
      head1 = head1->next;
    } else {
      temp = head2;
      head2 = head2->next;
    }

    mergedTail->next = temp;
    mergedTail = temp;
  }

                if (head1 != nullptr) {
    mergedTail->next = head1;
  } else if (head2 != nullptr) {
    mergedTail->next = head2;
  }

                return mergedHead;
}

Runtime Complexity Linear, O(m + n) where m and n are lengths of both linked lists. 

Memory Complexity Constant, O(1)

Maintain a head and a tail pointer on the merged linked list. Then choose the head of the merged linked list by comparing the first node of both linked lists. For all subsequent nodes in both lists, you choose the smaller current node and link it to the tail of the merged list, moving the current pointer of that list one step forward.

You keep doing this while there are some remaining elements in both lists. If there are still some elements in only one of the lists, you link this remaining list to the tail of the merged list.

Initially, the merged linked list is NULL. Compare the value of the first two nodes and make the node with the smaller value the head node of the merged linked list. In this example, it is 4 from head1.

Since it’s the first and only node in the merged list, it will also be the tail. Then move head1 one step forward.