Coding Example Of C Programming
1. Hello, World!:
```c
#include <stdio.h>
int main() {
printf("Hello, World!\n");
return 0;
}
```
2. Input and Output:
```c
#include <stdio.h>
int main() {
int number;
printf("Enter a number: ");
scanf("%d", &number);
printf("You entered: %d\n", number);
return 0;
}
```
3. Arithmetic Operations:
```c
#include <stdio.h>
int main() {
int a = 10, b = 5;
int sum, diff, prod, quotient, remainder;
sum = a + b;
diff = a - b;
prod = a * b;
quotient = a / b;
remainder = a % b;
printf("Sum: %d\n", sum);
printf("Difference: %d\n", diff);
printf("Product: %d\n", prod);
printf("Quotient: %d\n", quotient);
printf("Remainder: %d\n", remainder);
return 0;
}
```
4. If-Else Statement:
```c
#include <stdio.h>
int main() {
int number;
printf("Enter a number: ");
scanf("%d", &number);
if (number % 2 == 0) {
printf("%d is even.\n", number);
} else {
printf("%d is odd.\n", number);
}
return 0;
}
```
5. Switch Statement:
```c
#include <stdio.h>
int main() {
int choice;
printf("Enter a choice (1-3): ");
scanf("%d", &choice);
switch (choice) {
case 1:
printf("You selected option 1.\n");
break;
case 2:
printf("You selected option 2.\n");
break;
case 3:
printf("You selected option 3.\n");
break;
default:
printf("Invalid choice.\n");
break;
}
return 0;
}
```
6. For Loop:
```c
#include <stdio.h>
int main() {
int i;
for (i = 1; i <= 10; i++) {
printf("%d ", i);
}
printf("\n");
return 0;
}
```
7. While Loop:
```c
#include <stdio.h>
int main() {
int i = 1;
while (i <= 10) {
printf("%d ", i);
i++;
}
printf("\n");
return 0;
}
```
8. Do-While Loop:
```c
#include <stdio.h>
int main() {
int i = 1;
do {
printf("%d ", i);
i++;
} while (i <= 10);
printf("\n");
return 0;
}
```
9. Nested Loop:
```c
#include <stdio.h>
int main() {
int i, j;
for (i = 1; i <= 5; i++) {
for (j = 1; j <= i; j++) {
printf("* ");
}
printf("\n");
}
return 0;
}
```
10. Arrays:
```c
#include <stdio.h>
int main() {
int numbers[5] = {1, 2, 3, 4, 5};
int i;
for (i = 0; i < 5; i++) {
printf("%d ", numbers[i]);
}
printf("\n");
return 0;
}
```
11. String Input and Output:
```c
#include <stdio.h>
int main() {
char name[20];
printf("Enter your name: ");
scanf("%s", name);
printf("Hello, %s!\n", name);
return 0;
}
```
12. Functions:
```c
#include <stdio.h>
int add(int a, int b) {
return a + b;
}
int main() {
int result = add(5, 3);
printf("Result: %d\n", result);
return 0;
}
```
13. Recursion:
```c
#include <stdio.h>
int factorial(int n) {
if (n == 0 || n == 1) {
return 1;
} else {
return n * factorial(n - 1);
}
}
int main() {
int num = 5;
int result = factorial(num);
printf("Factorial of %d is %d\n", num, result);
return 0;
}
```
14. Pointers:
```c
#include <stdio.h>
int main() {
int number = 10;
int *ptr;
ptr = &number;
printf("Value of number: %d\n", number);
printf("Address of number: %p\n", &number);
printf("Value of ptr: %p\n", ptr);
printf("Value at ptr: %d\n", *ptr);
return 0;
}
```
15. Structures:
```c
#include <stdio.h>
struct student {
char name[20];
int age;
float marks;
};
int main() {
struct student s;
printf("Enter name: ");
scanf("%s", s.name);
printf("Enter age: ");
scanf("%d", &s.age);
printf("Enter marks: ");
scanf("%f", &s.marks);
printf("Name: %s\n", s.name);
printf("Age: %d\n", s.age);
printf("Marks: %.2f\n", s.marks);
return 0;
}
```
16. File Input and Output:
```c
#include <stdio.h>
int main() {
FILE *file;
char data[100];
file = fopen("example.txt", "w");
if (file == NULL) {
printf("File could not be opened.\n");
return 1;
}
printf("Enter data to write to the file: ");
fgets(data, sizeof(data), stdin);
fprintf(file, "%s", data);
fclose(file);
printf("Data written to the file successfully.\n");
return 0;
}
```
17. Command Line Arguments:
```c
#include <stdio.h>
int main(int argc, char *argv[]) {
int i;
printf("Number of arguments: %d\n", argc);
for (i = 0; i < argc; i++) {
printf("Argument %d: %s\n", i, argv[i]);
}
return 0;
}
```
18. Dynamic Memory Allocation:
```c
#include <stdio.h>
#include <stdlib.h>
int main() {
int *numbers
;
int size, i;
printf("Enter the size of the array: ");
scanf("%d", &size);
numbers = (int *) malloc(size * sizeof(int));
if (numbers == NULL) {
printf("Memory allocation failed.\n");
return 1;
}
printf("Enter %d numbers:\n", size);
for (i = 0; i < size; i++) {
scanf("%d", &numbers[i]);
}
printf("Numbers entered: ");
for (i = 0; i < size; i++) {
printf("%d ", numbers[i]);
}
printf("\n");
free(numbers);
return 0;
}
```
19. Bitwise Operators:
```c
#include <stdio.h>
int main() {
int a = 5, b = 3;
printf("Bitwise AND: %d\n", a & b);
printf("Bitwise OR: %d\n", a | b);
printf("Bitwise XOR: %d\n", a ^ b);
printf("Bitwise NOT of %d: %d\n", a, ~a);
printf("Bitwise left shift: %d\n", a << 1);
printf("Bitwise right shift: %d\n", a >> 1);
return 0;
}
```
20. Enumerations:
```c
#include <stdio.h>
enum Day {SUNDAY, MONDAY, TUESDAY, WEDNESDAY, THURSDAY, FRIDAY, SATURDAY};
int main() {
enum Day today = WEDNESDAY;
switch (today) {
case SUNDAY:
printf("Today is Sunday.\n");
break;
case MONDAY:
printf("Today is Monday.\n");
break;
case TUESDAY:
printf("Today is Tuesday.\n");
break;
case WEDNESDAY:
printf("Today is Wednesday.\n");
break;
case THURSDAY:
printf("Today is Thursday.\n");
break;
case FRIDAY:
printf("Today is Friday.\n");
break;
case SATURDAY:
printf("Today is Saturday.\n");
break;
}
return 0;
}
```
21. Preprocessor Directives:
```c
#include <stdio.h>
#define PI 3.14159
#define SQUARE(x) ((x) * (x))
int main() {
float radius = 5.0;
float area;
area = PI * SQUARE(radius);
printf("Area of the circle: %.2f\n", area);
return 0;
}
```
22. Typedef:
```c
#include <stdio.h>
typedef struct {
int x;
int y;
} Point;
int main() {
Point p;
p.x = 3;
p.y = 5;
printf("Coordinates: (%d, %d)\n", p.x, p.y);
return 0;
}
```
23. Math Library Functions:
```c
#include <stdio.h>
#include <math.h>
int main() {
float number = 25.0;
float squareRoot = sqrt(number);
float sineValue = sin(number);
float cosineValue = cos(number);
float powerValue = pow(2.0, 3.0);
printf("Square root: %.2f\n", squareRoot);
printf("Sine value: %.2f\n", sineValue);
printf("Cosine value: %.2f\n", cosineValue);
printf("Power value: %.2f\n", powerValue);
return 0;
}
```
24. Constant Pointers:
```c
#include <stdio.h>
int main() {
int number = 10;
int *const ptr = &number;
printf("Value of number: %d\n", number);
printf("Value of ptr: %p\n", ptr);
printf("Value at ptr: %d\n", *ptr);
*ptr = 20;
printf("Value of number: %d\n", number);
printf("Value at ptr: %d\n", *ptr);
return 0;
}
```
25. Variable Number of Arguments:
```c
#include <stdio.h>
#include <stdarg.h>
int sum(int count, ...) {
int total = 0;
int i;
va_list args;
va_start(args, count);
for (i = 0; i < count; i++) {
total += va_arg(args, int);
}
va_end(args);
return total;
}
int main() {
int result = sum(4, 5, 10, 15, 20);
printf("Sum: %d\n", result);
return 0;
}
```
26. Bit Fields:
```c
#include <stdio.h>
struct {
unsigned int age : 3;
} person;
int main() {
person.age = 5;
printf("Age: %d\n", person.age);
return 0;
}
```
27. Command Line Input and Output:
```c
#include <stdio.h>
int main(int argc, char *argv[]) {
FILE *inputFile;
FILE *outputFile;
int number;
if (argc < 3) {
printf("Usage: program_name input_file output_file\n");
return 1;
}
inputFile = fopen(argv[1], "r");
if (inputFile == NULL) {
printf("Input file could not be opened.\n");
return 1;
}
outputFile = fopen(argv[2], "w");
if (outputFile == NULL) {
printf("Output file could not be opened.\n");
return 1;
}
while (fscanf(inputFile, "%d", &number) != EOF) {
fprintf(outputFile, "%d\n", number * 2);
}
fclose(inputFile);
fclose(outputFile);
printf("Output file created successfully.\n");
return 0;
}
```
28. Recursive Structures:
```c
#include <stdio.h>
struct Node {
int data;
struct Node *next;
};
void printList(struct Node *node) {
while (node != NULL) {
printf("%d ", node->data);
node = node->next;
}
printf("\n");
}
int main() {
struct Node node1, node2, node3;
node1.data = 1;
node2.data = 2;
node3.data = 3;
node1.next = &node2;
node2.next = &node3;
node3.next = NULL;
printList(&node1);
return 0;
}
```
29. Binary Search:
```c
#include <stdio.h>
int binarySearch(int arr[], int size, int key) {
int low = 0;
int high = size - 1;
int
mid;
while (low <= high) {
mid = (low + high) / 2;
if (arr[mid] == key) {
return mid;
} else if (arr[mid] < key) {
low = mid + 1;
} else {
high = mid - 1;
}
}
return -1;
}
int main() {
int arr[] = {2, 5, 8, 12, 16, 23, 38, 56, 72, 91};
int size = sizeof(arr) / sizeof(arr[0]);
int key = 23;
int index = binarySearch(arr, size, key);
if (index != -1) {
printf("Element found at index %d.\n", index);
} else {
printf("Element not found.\n");
}
return 0;
}
```
30. Bubble Sort:
```c
#include <stdio.h>
void bubbleSort(int arr[], int size) {
int i, j, temp;
for (i = 0; i < size - 1; i++) {
for (j = 0; j < size - 1 - i; j++) {
if (arr[j] > arr[j + 1]) {
temp = arr[j];
arr[j] = arr[j + 1];
arr[j + 1] = temp;
}
}
}
}
int main() {
int arr[] = {64, 34, 25, 12, 22, 11, 90};
int size = sizeof(arr) / sizeof(arr[0]);
int i;
printf("Array before sorting: ");
for (i = 0; i < size; i++) {
printf("%d ", arr[i]);
}
printf("\n");
bubbleSort(arr, size);
printf("Array after sorting: ");
for (i = 0; i < size; i++) {
printf("%d ", arr[i]);
}
printf("\n");
return 0;
}
```
31. Linked List:
```c
#include <stdio.h>
#include <stdlib.h>
struct Node {
int data;
struct Node *next;
};
void printList(struct Node *node) {
while (node != NULL) {
printf("%d ", node->data);
node = node->next;
}
printf("\n");
}
int main() {
struct Node *head = NULL;
struct Node *second = NULL;
struct Node *third = NULL;
head = (struct Node *) malloc(sizeof(struct Node));
second = (struct Node *) malloc(sizeof(struct Node));
third = (struct Node *) malloc(sizeof(struct Node));
head->data = 1;
head->next = second;
second->data = 2;
second->next = third;
third->data = 3;
third->next = NULL;
printList(head);
return 0;
}
```
32. Doubly Linked List:
```c
#include <stdio.h>
#include <stdlib.h>
struct Node {
int data;
struct Node *prev;
struct Node *next;
};
void printList(struct Node *node) {
while (node != NULL) {
printf("%d ", node->data);
node = node->next;
}
printf("\n");
}
int main() {
struct Node *head = NULL;
struct Node *second = NULL;
struct Node *third = NULL;
head = (struct Node *) malloc(sizeof(struct Node));
second = (struct Node *) malloc(sizeof(struct Node));
third = (struct Node *) malloc(sizeof(struct Node));
head->data = 1;
head->prev = NULL;
head->next = second;
second->data = 2;
second->prev = head;
second->next = third;
third->data = 3;
third->prev = second;
third->next = NULL;
printList(head);
return 0;
}
```
33. Circular Linked List:
```c
#include <stdio.h>
#include <stdlib.h>
struct Node {
int data;
struct Node *next;
};
void printList(struct Node *head) {
struct Node *current = head;
if (head != NULL) {
do {
printf("%d ", current->data);
current = current->next;
} while (current != head);
}
printf("\n");
}
int main() {
struct Node *head = NULL;
struct Node *second = NULL;
struct Node *third = NULL;
head = (struct Node *) malloc(sizeof(struct Node));
second = (struct Node *) malloc(sizeof(struct Node));
third = (struct Node *) malloc(sizeof(struct Node));
head->data = 1;
head->next = second;
second->data = 2;
second->next = third;
third->data = 3;
third->next = head;
printList(head);
return 0;
}
```
34. Stack using Array:
```c
#include <stdio.h>
#define MAX_SIZE 100
int stack[MAX_SIZE];
int top = -1;
void push(int item) {
if (top >= MAX_SIZE - 1) {
printf("Stack Overflow.\n");
} else {
stack[++top] = item;
}
}
int pop() {
if (top < 0) {
printf("Stack Underflow.\n");
return -1;
} else {
return stack[top--];
}
}
int peek() {
if (top < 0) {
printf("Stack is empty.\n");
return -1;
} else {
return stack[top];
}
}
int isEmpty() {
return top < 0;
}
void display() {
int i;
if (isEmpty()) {
printf("Stack is empty.\n");
} else {
printf("Stack elements: ");
for (i = top; i >= 0; i--) {
printf("%d ", stack[i]);
}
printf("\n");
}
}
int main() {
push(1);
push(2);
push(3);
push(4);
display();
printf("Popped element: %d\n", pop());
printf("Top element: %d\n", peek());
display();
return 0;
}
```
35. Stack using Linked List:
```c
#include <stdio.h>
#include <stdlib.h>
struct Node {
int data;
struct Node *next;
};
struct Node *top = NULL;
void push(int item) {
struct Node *newNode = (struct Node *) malloc(sizeof(struct Node));
if (newNode == NULL) {
printf("Stack Overflow.\n");
} else {
newNode->data = item;
newNode->next = top;
top = newNode;
}
}
int pop() {
struct Node *temp;
int item;
if (top == NULL) {
printf("Stack Underflow.\n");
return -1;
} else {
temp = top;
item = temp->data;
top = top->next;
free(temp);
return item;
}
}
int peek() {
if (top == NULL) {
printf("Stack is empty.\n");
return -1;
} else {
return top->data;
}
}
int isEmpty() {
return top == NULL;
}
void display() {
struct Node *temp;
if (isEmpty()) {
printf("Stack is empty.\n");
} else {
temp = top;
printf("Stack elements: ");
while (temp != NULL) {
printf("%d ", temp->data);
temp = temp->next;
}
printf("\n");
}
}
int main() {
push(1);
push(2);
push(3);
push(4);
display();
printf("Popped element: %d\n", pop());
printf("Top element: %d\n", peek());
display();
return 0;
}
```
36. Queue using Array:
```c
#include <stdio.h>
#define MAX_SIZE 100
int queue[MAX_SIZE];
int front = -1;
int rear = -1;
void enqueue(int item) {
if (rear == MAX_SIZE - 1) {
printf("Queue Overflow.\n");
} else {
if (front == -1) {
front = 0;
}
queue[++rear] = item;
}
}
int dequeue() {
int item;
if (front == -1 || front > rear) {
printf("Queue Underflow.\n");
return -1;
} else {
item = queue[front++];
return item;
}
}
int isEmpty() {
return front == -1 || front > rear;
}
void display() {
int i;
if (isEmpty()) {
printf("Queue is empty.\n");
} else {
printf("Queue elements: ");
for (i = front; i <= rear; i++) {
printf("%d ", queue[i]);
}
printf("\n");
}
}
int main() {
enqueue(1);
enqueue(2);
enqueue(3);
enqueue(4);
display();
printf("Dequeued element: %d\n", dequeue());
display();
return 0;
}
```
37. Queue using Linked List:
```c
#include <stdio.h>
#include <stdlib.h>
struct Node {
int data;
struct Node *next;
};
struct Node *front = NULL;
struct Node *rear = NULL;
void enqueue(int item) {
struct Node *newNode = (struct Node *) malloc(sizeof(struct Node));
if (newNode == NULL) {
printf("Queue Overflow.\n");
} else {
newNode->data = item;
newNode->next = NULL;
if (rear == NULL) {
front = rear = newNode;
} else {
rear->next = newNode;
rear = newNode;
}
}
}
int dequeue() {
struct Node *temp;
int item;
if (front == NULL) {
printf("Queue Underflow.\n");
return -1;
} else {
temp = front;
item = temp->data;
front = front->next;
if (front == NULL) {
rear = NULL;
}
free(temp);
return item;
}
}
int isEmpty() {
return front == NULL;
}
void display() {
struct Node *temp;
if (isEmpty()) {
printf("Queue is empty.\n");
} else {
temp = front;
printf("Queue elements: ");
while (temp != NULL) {
printf("%d ", temp->data);
temp = temp->next;
}
printf("\n");
}
}
int main() {
enqueue(1);
enqueue(2);
enqueue(3);
enqueue(4);
display();
printf("Dequeued element: %d\n", dequeue());
display();
return 0;
}
```
38. Selection Sort:
```c
#include <stdio.h>
void selectionSort(int arr[], int size) {
int i, j, minIndex, temp;
for (i = 0; i < size - 1; i++) {
minIndex = i;
for (j = i + 1; j < size; j++) {
if (arr[j] < arr[minIndex]) {
minIndex = j;
}
}
temp = arr[i];
arr[i] = arr[minIndex];
arr[minIndex] = temp;
}
}
int main() {
int arr[] = {64, 25, 12, 22, 11};
int size = sizeof(arr) / sizeof(arr[0]);
int i;
printf("Array before sorting: ");
for (i = 0; i < size; i++) {
printf("%d ", arr[i]);
}
printf("\n");
selectionSort(arr, size);
printf("Array after sorting: ");
for (i = 0; i < size; i++) {
printf("%d ", arr[i]);
}
printf("\n");
return 0;
}
```
39. Insertion Sort:
```c
#include <stdio.h>
void insertionSort(int arr[], int size) {
int i, j, key;
for (i = 1; i < size; i++) {
key = arr[i];
j = i - 1;
while (j >= 0 && arr[j] > key) {
arr[j + 1] = arr[j];
j--;
}
arr[j + 1] = key;
}
}
int main() {
int arr[] = {64, 25, 12, 22, 11};
int size = sizeof(arr) / sizeof(arr[0]);
int i;
printf("Array before sorting: ");
for (i = 0; i < size; i++) {
printf("%d ", arr[i]);
}
printf("\n");
insertionSort(arr, size);
printf("Array after sorting: ");
for (i = 0; i < size; i++) {
printf("%d ", arr[i]);
}
printf("\n");
return 0;
}
```
0 Comments