C Programming Language || Hands On Coding
Open in Telegram
Hands-on C programming language challenges for beginners. Learn building logic by solving programs. Owner: @Pradeep_saii
Show moreπ Analytical overview of Telegram channel C Programming Language || Hands On Coding
Channel C Programming Language || Hands On Coding (@c_programming_language_coding) in the English language segment is an active participant. Currently, the community unites 12 824 subscribers, ranking 9 562 in the Technologies & Applications category and 31 207 in the India region.
π Audience metrics and dynamics
Since its creation on Π½Π΅Π²ΡΠ΄ΠΎΠΌΠΎ, the project has demonstrated rapid growth, gathering an audience of 12 824 subscribers.
According to the latest data from 26 August, 2026, the channel demonstrates stable activity. Although there has been a change in the number of participants by -210 over the last 30 days and by -2 over the last 24 hours, overall reach remains high.
- Verification status: Not verified
- Engagement rate (ER): The average audience engagement rate is 12.56%. Within the first 24 hours after publication, content typically collects 2.42% reactions from the total number of subscribers.
- Post reach: On average, each post receives 1 612 views. Within the first day, a publication typically gains 310 views.
- Reactions and interaction: The audience actively supports content: the average number of reactions per post is 4.
- Thematic interests: Content is focused on key topics such as input, string, scanf("%d, array, element.
π Description and content policy
The author describes the resource as a platform for expressing subjective opinions:
βHands-on C programming language challenges for beginners. Learn building logic by solving programs.
Owner: @Pradeep_saiiβ
Thanks to the high frequency of updates (latest data received on 27 August, 2026), the channel maintains relevance and a high level of publication reach. Analytics show that the audience actively interacts with content, making it an important point of influence in the Technologies & Applications category.
12 824
Subscribers
-224 hours
-357 days
-21030 days
Posts Archive
π» Check for Balanced Brackets
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#define MAX_SIZE 100
typedef struct {
char data[MAX_SIZE];
int top;
} Stack;
void initialize(Stack *stack) {
stack->top = -1;
}
int isEmpty(Stack *stack) {
return stack->top == -1;
}
int isFull(Stack *stack) {
return stack->top == MAX_SIZE - 1;
}
void push(Stack *stack, char c) {
if (!isFull(stack)) {
stack->data[++stack->top] = c;
}
}
char pop(Stack *stack) {
if (!isEmpty(stack)) {
return stack->data[stack->top--];
}
return '0';
}
int isMatchingPair(char character1, char character2) {
if (character1 == '(' && character2 == ')')
return 1;
else if (character1 == '{' && character2 == '}')
return 1;
else if (character1 == '[' && character2 == ']')
return 1;
else
return 0;
}
int isBalanced(char *expression) {
Stack stack;
initialize(&stack);
int i;
for (i = 0; expression[i]; i++) {
if (expression[i] == '(' || expression[i] == '{' || expression[i] == '[')
push(&stack, expression[i]);
if (expression[i] == ')' || expression[i] == '}' || expression[i] == ']') {
if (isEmpty(&stack))
return 0;
char top = pop(&stack);
if (!isMatchingPair(top, expression[i]))
return 0;
}
}
return isEmpty(&stack);
}
int main() {
char expression[MAX_SIZE];
printf("Enter an expression: ");
scanf("%s", expression);
if (isBalanced(expression))
printf("Balancedn");
else
printf("Not Balancedn");
return 0;
}
Input: {([])}
Output: Balanced
Input: ([)]
Output: Not Balanced
Input: ((
Output: Not Balanced
Input: ))
Output: Not Balanced
Input: abc
Output: Balanced
Input: {a[b(c)d]e}
Output: Balanced
Input: {a[b(c)d]e
Output: Not Balancedπ» Check for Balanced Parentheses
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#define MAX_SIZE 100
struct Stack {
int top;
char items[MAX_SIZE];
};
void initialize(struct Stack *s) {
s->top = -1;
}
int isEmpty(struct Stack *s) {
return (s->top == -1);
}
int isFull(struct Stack *s) {
return (s->top == MAX_SIZE - 1);
}
void push(struct Stack *s, char c) {
if (isFull(s)) {
printf("Stack Overflow n");
return;
}
s->items[++(s->top)] = c;
}
char pop(struct Stack *s) {
if (isEmpty(s)) {
return '0';
}
return s->items[(s->top)--];
}
int isMatchingPair(char character1, char character2) {
if (character1 == '(' && character2 == ')')
return 1;
else if (character1 == '{' && character2 == '}')
return 1;
else if (character1 == '[' && character2 == ']')
return 1;
else
return 0;
}
int isBalanced(char exp[]) {
struct Stack s;
initialize(&s);
for (int i = 0; exp[i]; i++) {
if (exp[i] == '(' || exp[i] == '{' || exp[i] == '[')
push(&s, exp[i]);
if (exp[i] == ')' || exp[i] == '}' || exp[i] == ']') {
if (isEmpty(&s))
return 0;
char top = pop(&s);
if (!isMatchingPair(top, exp[i]))
return 0;
}
}
return (isEmpty(&s) ? 1 : 0);
}
int main() {
char exp[MAX_SIZE];
printf("Enter an expression: ");
scanf("%s", exp);
if (isBalanced(exp))
printf("Balanced n");
else
printf("Not Balanced n");
return 0;
}
Input: {([])}
Output: Balanced
Input: ([)]
Output: Not Balanced
Input: ((
Output: Not Balanced
Input: ))
Output: Not Balanced
Input: abc
Output: Balanced
Input: {[()]}
Output: Balancedπ» Implement Stack Using Linked List
#include <stdio.h>
#include <stdlib.h>
struct Node {
int data;
struct Node *next;
};
struct Node *top = NULL;
void push(int value) {
struct Node *newNode = (struct Node *)malloc(sizeof(struct Node));
if (newNode == NULL) {
printf("Stack Overflown");
return;
}
newNode->data = value;
newNode->next = top;
top = newNode;
printf("%d pushed to stackn", value);
}
void pop() {
if (top == NULL) {
printf("Stack Underflown");
return;
}
struct Node *temp = top;
top = top->next;
printf("%d popped from stackn", temp->data);
free(temp);
}
void peek() {
if (top == NULL) {
printf("Stack is emptyn");
return;
}
printf("Top element is %dn", top->data);
}
int isEmpty() {
return top == NULL;
}
int main() {
int choice, value;
while (1) {
printf("nStack Operations:n");
printf("1. Pushn");
printf("2. Popn");
printf("3. Peekn");
printf("4. IsEmptyn");
printf("5. Exitn");
printf("Enter your choice: ");
scanf("%d", &choice);
switch (choice) {
case 1:
printf("Enter value to push: ");
scanf("%d", &value);
push(value);
break;
case 2:
pop();
break;
case 3:
peek();
break;
case 4:
if (isEmpty())
printf("Stack is emptyn");
else
printf("Stack is not emptyn");
break;
case 5:
exit(0);
default:
printf("Invalid choicen");
}
}
return 0;
}
Stack Operations: 1. Push 2. Pop 3. Peek 4. IsEmpty 5. Exit Enter your choice: 1 Input: 10 Enter value to push: 10 Output: 10 pushed to stack Stack Operations: 1. Push 2. Pop 3. Peek 4. IsEmpty 5. Exit Enter your choice: 1 Input: 20 Enter value to push: 20 Output: 20 pushed to stack Stack Operations: 1. Push 2. Pop 3. Peek 4. IsEmpty 5. Exit Enter your choice: 3 Output: Top element is 20 Stack Operations: 1. Push 2. Pop 3. Peek 4. IsEmpty 5. Exit Enter your choice: 2 Output: 20 popped from stack Stack Operations: 1. Push 2. Pop 3. Peek 4. IsEmpty 5. Exit Enter your choice: 4 Output: Stack is not empty Stack Operations: 1. Push 2. Pop 3. Peek 4. IsEmpty 5. Exit Enter your choice: 2 Output: 10 popped from stack Stack Operations: 1. Push 2. Pop 3. Peek 4. IsEmpty 5. Exit Enter your choice: 4 Output: Stack is empty Stack Operations: 1. Push 2. Pop 3. Peek 4. IsEmpty 5. Exit Enter your choice: 2 Output: Stack Underflow Stack Operations: 1. Push 2. Pop 3. Peek 4. IsEmpty 5. Exit Enter your choice: 5
π» Implement Stack Using Array
#include <stdio.h>
#include <stdlib.h>
#define MAX_SIZE 100
int stack[MAX_SIZE];
int top = -1;
void push(int value) {
if (top >= MAX_SIZE - 1) {
printf("Stack Overflown");
return;
}
top++;
stack[top] = value;
printf("%d pushed to stackn", value);
}
void pop() {
if (top == -1) {
printf("Stack Underflown");
return;
}
printf("%d popped from stackn", stack[top]);
top--;
}
void peek() {
if (top == -1) {
printf("Stack is emptyn");
return;
}
printf("Top element is %dn", stack[top]);
}
int isEmpty() {
return top == -1;
}
int main() {
int choice, value;
while (1) {
printf("nStack Operations:n");
printf("1. Pushn");
printf("2. Popn");
printf("3. Peekn");
printf("4. IsEmptyn");
printf("5. Exitn");
printf("Enter your choice: ");
scanf("%d", &choice);
switch (choice) {
case 1:
printf("Enter value to push: ");
scanf("%d", &value);
push(value);
break;
case 2:
pop();
break;
case 3:
peek();
break;
case 4:
if (isEmpty()) {
printf("Stack is emptyn");
} else {
printf("Stack is not emptyn");
}
break;
case 5:
exit(0);
default:
printf("Invalid choicen");
}
}
return 0;
}
Stack Operations: 1. Push 2. Pop 3. Peek 4. IsEmpty 5. Exit Enter your choice: Input: 1 Enter value to push: Input: 10 10 pushed to stack Stack Operations: 1. Push 2. Pop 3. Peek 4. IsEmpty 5. Exit Enter your choice: Input: 1 Enter value to push: Input: 20 20 pushed to stack Stack Operations: 1. Push 2. Pop 3. Peek 4. IsEmpty 5. Exit Enter your choice: Input: 3 Top element is 20 Stack Operations: 1. Push 2. Pop 3. Peek 4. IsEmpty 5. Exit Enter your choice: Input: 4 Stack is not empty Stack Operations: 1. Push 2. Pop 3. Peek 4. IsEmpty 5. Exit Enter your choice: Input: 2 20 popped from stack Stack Operations: 1. Push 2. Pop 3. Peek 4. IsEmpty 5. Exit Enter your choice: Input: 2 10 popped from stack Stack Operations: 1. Push 2. Pop 3. Peek 4. IsEmpty 5. Exit Enter your choice: Input: 2 Stack Underflow Stack Operations: 1. Push 2. Pop 3. Peek 4. IsEmpty 5. Exit Enter your choice: Input: 4 Stack is empty Stack Operations: 1. Push 2. Pop 3. Peek 4. IsEmpty 5. Exit Enter your choice: Input: 5
π» Command Line Arguments Processing
#include <stdio.h>
#include <stdlib.h>
int main(int argc, char *argv[]) {
int num_args = argc;
if (num_args == 1) {
printf("No command-line arguments provided.n");
} else {
printf("Number of command-line arguments: %dn", num_args);
printf("Program name: %sn", argv[0]);
// Dynamically allocate memory to store the arguments
char **args = (char **)malloc((num_args - 1) * sizeof(char *));
if (args == NULL) {
printf("Memory allocation failed.n");
return 1;
}
printf("Other arguments:n");
for (int i = 1; i < num_args; i++) {
int arg_len = 0;
while (argv[i][arg_len] != '0') {
arg_len++;
}
args[i - 1] = (char *)malloc((arg_len + 1) * sizeof(char));
if (args[i - 1] == NULL) {
printf("Memory allocation failed.n");
// Free previously allocated memory
for(int j = 0; j < i - 1; j++) {
free(args[j]);
}
free(args);
return 1;
}
int j = 0;
while (argv[i][j] != '0') {
args[i - 1][j] = argv[i][j];
j++;
}
args[i - 1][j] = '0';
printf("Argument %d: %sn", i, args[i - 1]);
}
// Free the dynamically allocated memory
for (int i = 0; i < num_args - 1; i++) {
free(args[i]);
}
free(args);
}
return 0;
}
Number of command-line arguments: 4 Program name: ./program Other arguments: Argument 1: hello Argument 2: world Argument 3: 123
π» Array of Dynamic Strings
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
int main() {
int numStrings;
printf("Enter the number of strings: ");
scanf("%d", &numStrings);
getchar();
char **stringArray = (char **)malloc(numStrings * sizeof(char *));
if (stringArray == NULL) {
printf("Memory allocation failed.n");
return 1;
}
for (int i = 0; i < numStrings; i++) {
int stringLength;
printf("Enter the length of string %d: ", i + 1);
scanf("%d", &stringLength);
getchar();
stringArray[i] = (char *)malloc((stringLength + 1) * sizeof(char));
if (stringArray[i] == NULL) {
printf("Memory allocation failed for string %d.n", i + 1);
for (int j = 0; j < i; j++) {
free(stringArray[j]);
}
free(stringArray);
return 1;
}
printf("Enter string %d: ", i + 1);
fgets(stringArray[i], stringLength + 1, stdin);
stringArray[i][strcspn(stringArray[i], "n")] = 0;
}
printf("nEntered strings:n");
for (int i = 0; i < numStrings; i++) {
printf("String %d: %sn", i + 1, stringArray[i]);
}
for (int i = 0; i < numStrings; i++) {
free(stringArray[i]);
}
free(stringArray);
return 0;
}
Input: 2 Input: 5 Input: hello Input: 3 Input: bye Output: Enter the number of strings: Enter the length of string 1: Enter string 1: Enter the length of string 2: Enter string 2: Entered strings: String 1: hello String 2: bye
π» Dynamic Structure Allocation
#include <stdio.h>
#include <stdlib.h>
struct Person {
char name[50];
int age;
};
int main() {
struct Person *personPtr;
personPtr = (struct Person *)malloc(sizeof(struct Person));
if (personPtr == NULL) {
printf("Memory allocation failed!n");
return 1;
}
printf("Enter name: ");
scanf("%s", personPtr->name);
printf("Enter age: ");
scanf("%d", &personPtr->age);
printf("Name: %s, Age: %dn", personPtr->name, personPtr->age);
free(personPtr);
return 0;
}
Input: John Input: 30 Output: Enter name: Enter age: Name: John, Age: 30
π» Memory Pool Implementation
#include <stdio.h>
#include <stdlib.h>
#include <stdbool.h>
#define POOL_SIZE 1024
#define BLOCK_SIZE 32
typedef struct Block {
bool is_free;
struct Block *next;
} Block;
char memory_pool[POOL_SIZE];
Block *free_list;
void initialize_pool() {
int num_blocks = POOL_SIZE / BLOCK_SIZE;
Block *current_block = (Block *)memory_pool;
for (int i = 0; i < num_blocks; i++) {
current_block->is_free = true;
current_block->next = (Block *)((char *)current_block + BLOCK_SIZE);
current_block = current_block->next;
}
((Block *)((char *)current_block - BLOCK_SIZE))->next = NULL;
free_list = (Block *)memory_pool;
}
void *allocate_memory() {
if (free_list == NULL) {
printf("Memory pool is empty.n");
return NULL;
}
Block *allocated_block = free_list;
free_list = free_list->next;
allocated_block->is_free = false;
return (void *)((char *)allocated_block + sizeof(Block));
}
void deallocate_memory(void *ptr) {
if (ptr == NULL) return;
Block *block_to_free = (Block *)((char *)ptr - sizeof(Block));
block_to_free->is_free = true;
block_to_free->next = free_list;
free_list = block_to_free;
}
int main() {
initialize_pool();
int *num1 = (int *)allocate_memory();
if (num1 != NULL) {
*num1 = 42;
printf("Allocated memory: %dn", *num1);
}
int *num2 = (int *)allocate_memory();
if (num2 != NULL) {
*num2 = 99;
printf("Allocated memory: %dn", *num2);
}
deallocate_memory(num1);
deallocate_memory(num2);
return 0;
}
Allocated memory: 42 Allocated memory: 99
π» Custom Memory Allocator
#include <stdio.h>
#include <stdlib.h>
#include <stdbool.h>
#define MEMORY_SIZE 1024
static char memory[MEMORY_SIZE];
static bool memory_map[MEMORY_SIZE];
void* my_malloc(size_t size) {
if (size <= 0 || size > MEMORY_SIZE) {
return NULL;
}
for (int i = 0; i <= MEMORY_SIZE - size; i++) {
bool found = true;
for (int j = 0; j < size; j++) {
if (memory_map[i + j]) {
found = false;
break;
}
}
if (found) {
for (int j = 0; j < size; j++) {
memory_map[i + j] = true;
}
return (void*)&memory[i];
}
}
return NULL;
}
void my_free(void* ptr, size_t size) {
if (ptr == NULL) {
return;
}
char* start = (char*)memory;
char* current = (char*)ptr;
if (current < start || current >= start + MEMORY_SIZE) {
return;
}
size_t offset = current - start;
for (int i = 0; i < size; i++) {
memory_map[offset + i] = false;
}
}
int main() {
int* ptr1 = (int*)my_malloc(sizeof(int) * 5);
if (ptr1 == NULL) {
printf("Memory allocation failed!n");
return 1;
}
for (int i = 0; i < 5; i++) {
ptr1[i] = i * 2;
}
printf("Allocated memory at: %pn", (void*)ptr1);
for (int i = 0; i < 5; i++) {
printf("ptr1[%d] = %dn", i, ptr1[i]);
}
my_free(ptr1, sizeof(int) * 5);
printf("Memory freed.n");
return 0;
}
Allocated memory at: 0x602000000000 ptr1[0] = 0 ptr1[1] = 2 ptr1[2] = 4 ptr1[3] = 6 ptr1[4] = 8 Memory freed.
π» Memory Leak Detection
#include <stdio.h>
#include <stdlib.h>
int main() {
int *ptr;
ptr = (int *)malloc(sizeof(int));
if (ptr == NULL) {
printf("Memory allocation failed!n");
return 1;
}
printf("Memory allocated at address: %pn", (void *)ptr);
printf("Enter an integer value: ");
scanf("%d", ptr);
printf("Value stored: %dn", *ptr);
// free(ptr); //Uncomment this to prevent memory leak
ptr = NULL; //Setting to NULL after free is a good practice
return 0;
}
Memory allocated at address: 0x12345678 Enter an integer value: 10 Value stored: 10
π» Dynamic Array Resizing
#include <stdio.h>
#include <stdlib.h>
int main() {
int *arr;
int size = 2;
int count = 0;
int num;
arr = (int *)malloc(size * sizeof(int));
if (arr == NULL) {
printf("Memory allocation failed.n");
return 1;
}
printf("Enter numbers (enter -1 to stop):n");
while (1) {
scanf("%d", &num);
if (num == -1) {
break;
}
if (count == size) {
size *= 2;
arr = (int *)realloc(arr, size * sizeof(int));
if (arr == NULL) {
printf("Memory reallocation failed.n");
return 1;
}
}
arr[count] = num;
count++;
}
printf("The numbers you entered are:n");
for (int i = 0; i < count; i++) {
printf("%d ", arr[i]);
}
printf("n");
free(arr);
return 0;
}
Input: 1 Input: 2 Input: 3 Input: 4 Input: 5 Input: -1 Output: Enter numbers (enter -1 to stop): The numbers you entered are: 1 2 3 4 5
π» Binary Tree Implementation
#include <stdio.h>
#include <stdlib.h>
struct Node {
int data;
struct Node *left;
struct Node *right;
};
struct Node *createNode(int data) {
struct Node *newNode = (struct Node *)malloc(sizeof(struct Node));
newNode->data = data;
newNode->left = NULL;
newNode->right = NULL;
return newNode;
}
void inorderTraversal(struct Node *root) {
if (root != NULL) {
inorderTraversal(root->left);
printf("%d ", root->data);
inorderTraversal(root->right);
}
}
int main() {
struct Node *root = createNode(1);
root->left = createNode(2);
root->right = createNode(3);
root->left->left = createNode(4);
root->left->right = createNode(5);
printf("Inorder traversal of the binary tree is: ");
inorderTraversal(root);
printf("n");
return 0;
}
Inorder traversal of the binary tree is: 4 2 5 1 3
π» Queue Implementation using Dynamic Memory
#include <stdio.h>
#include <stdlib.h>
typedef struct {
int *data;
int front;
int rear;
int capacity;
} Queue;
Queue* createQueue(int capacity) {
Queue* queue = (Queue*)malloc(sizeof(Queue));
queue->capacity = capacity;
queue->front = 0;
queue->rear = -1;
queue->data = (int*)malloc(queue->capacity * sizeof(int));
return queue;
}
int isFull(Queue* queue) {
return (queue->rear == queue->capacity - 1);
}
int isEmpty(Queue* queue) {
return (queue->front > queue->rear);
}
void enqueue(Queue* queue, int item) {
if (isFull(queue)) {
printf("Queue is fulln");
return;
}
queue->rear = queue->rear + 1;
queue->data[queue->rear] = item;
printf("%d enqueued to queuen", item);
}
int dequeue(Queue* queue) {
if (isEmpty(queue)) {
printf("Queue is emptyn");
return -1;
}
int item = queue->data[queue->front];
queue->front = queue->front + 1;
return item;
}
int main() {
Queue* queue = createQueue(5);
enqueue(queue, 10);
enqueue(queue, 20);
enqueue(queue, 30);
enqueue(queue, 40);
enqueue(queue, 50);
printf("%d dequeued from queuen", dequeue(queue));
printf("%d dequeued from queuen", dequeue(queue));
printf("%d dequeued from queuen", dequeue(queue));
free(queue->data);
free(queue);
return 0;
}
10 enqueued to queue 20 enqueued to queue 30 enqueued to queue 40 enqueued to queue 50 enqueued to queue 10 dequeued from queue 20 dequeued from queue 30 dequeued from queue
π» Stack Implementation using Dynamic Memory
#include <stdio.h>
#include <stdlib.h>
struct Stack {
int *array;
int top;
unsigned capacity;
};
struct Stack* createStack(unsigned capacity) {
struct Stack* stack = (struct Stack*)malloc(sizeof(struct Stack));
stack->capacity = capacity;
stack->top = -1;
stack->array = (int*)malloc(stack->capacity * sizeof(int));
return stack;
}
int isFull(struct Stack* stack) {
return stack->top == stack->capacity - 1;
}
int isEmpty(struct Stack* stack) {
return stack->top == -1;
}
void push(struct Stack* stack, int item) {
if (isFull(stack))
return;
stack->array[++stack->top] = item;
printf("%d pushed to stackn", item);
}
int pop(struct Stack* stack) {
if (isEmpty(stack))
return -1;
return stack->array[stack->top--];
}
int peek(struct Stack* stack) {
if (isEmpty(stack))
return -1;
return stack->array[stack->top];
}
int main() {
struct Stack* stack = createStack(10);
push(stack, 10);
push(stack, 20);
push(stack, 30);
printf("%d popped from stackn", pop(stack));
printf("Top element is %dn", peek(stack));
return 0;
}
10 pushed to stack 20 pushed to stack 30 pushed to stack 30 popped from stack Top element is 20
π» Linked List Implementation
#include <stdio.h>
#include <stdlib.h>
struct Node {
int data;
struct Node *next;
};
int main() {
struct Node *head = NULL;
struct Node *temp = NULL;
int choice, value;
while (1) {
printf("1. Insert at beginningn");
printf("2. Displayn");
printf("3. Exitn");
printf("Enter your choice: ");
scanf("%d", &choice);
if (choice == 1) {
printf("Enter the value to insert: ");
scanf("%d", &value);
struct Node *newNode = (struct Node*)malloc(sizeof(struct Node));
newNode->data = value;
newNode->next = head;
head = newNode;
} else if (choice == 2) {
temp = head;
printf("Linked List: ");
while (temp != NULL) {
printf("%d ", temp->data);
temp = temp->next;
}
printf("n");
} else if (choice == 3) {
break;
} else {
printf("Invalid choice.n");
}
}
temp = head;
while (temp != NULL) {
struct Node *next = temp->next;
free(temp);
temp = next;
}
head = NULL;
return 0;
}
1. Insert at beginning 2. Display 3. Exit Enter your choice: 1 Enter the value to insert: 10 1. Insert at beginning 2. Display 3. Exit Enter your choice: 1 Enter the value to insert: 20 1. Insert at beginning 2. Display 3. Exit Enter your choice: 2 Linked List: 20 10 1. Insert at beginning 2. Display 3. Exit Enter your choice: 1 Enter the value to insert: 30 1. Insert at beginning 2. Display 3. Exit Enter your choice: 2 Linked List: 30 20 10 1. Insert at beginning 2. Display 3. Exit Enter your choice: 3
π» String Operations with Dynamic Memory
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
int main() {
char *str1 = NULL, *str2 = NULL, *combinedStr = NULL;
int len1, len2;
printf("Enter the length of the first string: ");
scanf("%d", &len1);
str1 = (char *)malloc((len1 + 1) * sizeof(char));
if (str1 == NULL) {
printf("Memory allocation failedn");
return 1;
}
printf("Enter the first string: ");
scanf(" %[^n]", str1);
printf("Enter the length of the second string: ");
scanf("%d", &len2);
str2 = (char *)malloc((len2 + 1) * sizeof(char));
if (str2 == NULL) {
printf("Memory allocation failedn");
free(str1);
return 1;
}
printf("Enter the second string: ");
scanf(" %[^n]", str2);
combinedStr = (char *)malloc((len1 + len2 + 1) * sizeof(char));
if (combinedStr == NULL) {
printf("Memory allocation failedn");
free(str1);
free(str2);
return 1;
}
strcpy(combinedStr, str1);
strcat(combinedStr, str2);
printf("Combined string: %sn", combinedStr);
free(str1);
free(str2);
free(combinedStr);
return 0;
}
Input: 5 Input: Hello Input: 3 Input: World Output: Enter the length of the first string: Enter the first string: Enter the length of the second string: Enter the second string: Combined string: HelloWorld
π» Matrix Operations with Dynamic Allocation
#include <stdio.h>
#include <stdlib.h>
int main() {
int rows, cols;
int i, j;
printf("Enter the number of rows: ");
scanf("%d", &rows);
printf("Enter the number of columns: ");
scanf("%d", &cols);
int **matrix = (int **)malloc(rows * sizeof(int *));
if (matrix == NULL) {
printf("Memory allocation failed.n");
return 1;
}
for (i = 0; i < rows; i++) {
matrix[i] = (int *)malloc(cols * sizeof(int));
if (matrix[i] == NULL) {
printf("Memory allocation failed.n");
// Free previously allocated memory
for (j = 0; j < i; j++) {
free(matrix[j]);
}
free(matrix);
return 1;
}
}
printf("Enter the elements of the matrix:n");
for (i = 0; i < rows; i++) {
for (j = 0; j < cols; j++) {
scanf("%d", &matrix[i][j]);
}
}
printf("The matrix is:n");
for (i = 0; i < rows; i++) {
for (j = 0; j < cols; j++) {
printf("%d ", matrix[i][j]);
}
printf("n");
}
// Free the allocated memory
for (i = 0; i < rows; i++) {
free(matrix[i]);
}
free(matrix);
return 0;
}
Input: 2 Input: 3 Input: 1 Input: 2 Input: 3 Input: 4 Input: 5 Input: 6 Output: Enter the number of rows: Enter the number of columns: Enter the elements of the matrix: The matrix is: 1 2 3 4 5 6
π» Dynamic 2D Array Operations
#include <stdio.h>
#include <stdlib.h>
int main() {
int rows, cols, i, j;
int **arr;
printf("Enter number of rows: ");
scanf("%d", &rows);
printf("Enter number of columns: ");
scanf("%d", &cols);
arr = (int **)malloc(rows * sizeof(int *));
if (arr == NULL) {
printf("Memory allocation failedn");
return 1;
}
for (i = 0; i < rows; i++) {
arr[i] = (int *)malloc(cols * sizeof(int));
if (arr[i] == NULL) {
printf("Memory allocation failedn");
for (j = 0; j < i; j++) {
free(arr[j]);
}
free(arr);
return 1;
}
}
printf("Enter elements of the array:n");
for (i = 0; i < rows; i++) {
for (j = 0; j < cols; j++) {
scanf("%d", &arr[i][j]);
}
}
printf("The array is:n");
for (i = 0; i < rows; i++) {
for (j = 0; j < cols; j++) {
printf("%d ", arr[i][j]);
}
printf("n");
}
for (i = 0; i < rows; i++) {
free(arr[i]);
}
free(arr);
return 0;
}
Input: 2 Input: 3 Input: 1 Input: 2 Input: 3 Input: 4 Input: 5 Input: 6 Output: Enter number of rows: Enter number of columns: Enter elements of the array: The array is: 1 2 3 4 5 6
π» Dynamic 1D Array Operations
#include <stdio.h>
#include <stdlib.h>
int main() {
int *arr;
int size, i;
printf("Enter the size of the array: ");
scanf("%d", &size);
arr = (int *)malloc(size * sizeof(int));
if (arr == NULL) {
printf("Memory allocation failed!n");
return 1;
}
printf("Enter the elements of the array:n");
for (i = 0; i < size; i++) {
scanf("%d", &arr[i]);
}
printf("The elements of the array are:n");
for (i = 0; i < size; i++) {
printf("%d ", arr[i]);
}
printf("n");
free(arr);
return 0;
}
Input: 5 Input: 10 Input: 20 Input: 30 Input: 40 Input: 50 Output: Enter the size of the array: Enter the elements of the array: The elements of the array are: 10 20 30 40 50
