AI Coding & CSE Fundamentals

Finding the Ultimate Champions: Max and Min in a C Array!

#include <stdio.h>
#include <limits.h>

int main() {
    int arr[] = {12, 34, 5, 78, 9, 101};
    int n = sizeof(arr) / sizeof(arr[0]);
    int max = INT_MIN;
    int min = INT_MAX;

    for (int i = 0; i < n; i++) {
        if (arr[i] > max) {
            max = arr[i];
        }
        if (arr[i] < min) {
            min = arr[i];
        }
    }

    printf("Max element: %d\n", max);
    printf("Min element: %d\n", min);
    return 0;
}

#CProgramming #Arrays #InputOutput

Unlocking Arrays: How to Read and Print Elements in C?

#include <stdio.h>

int main() {
 int n, i;
 printf("Enter the number of elements: ");
 scanf("%d", &n);
 int arr[n];
 printf("Enter %d elements:\n", n);
 for (i = 0; i < n; i++) {
 scanf("%d", &arr[i]);
 }
 printf("Array elements are: ");
 for (i = 0; i < n; i++) {
 printf("%d ", arr[i]);
 }
 printf("\n");
 return 0;
}

**Arrays in C: Your Data Containers!** 📦 Hey coders! Let's dive into arrays – super handy for storing multiple values of the *same type* under one name. Think of them as organized shelves for your data! **1D Arrays: The Simple List** 📜 * Imagine a single row of boxes, each holding a number. That's a 1D array! * **Declaration:** `int numbers[5];` (Creates an array named 'numbers' to hold 5 integers) * **Accessing Elements:** Use the index (starting from 0!). `numbers[0] = 10;` (assigns 10 to the *first* element) `printf("%d", numbers[3]);` (prints the *fourth* element). * **Initialization:** `int grades[3] = {85, 92, 78};` **2D Arrays: The Tables!** 📊 * Now picture a grid or a table. That's a 2D array, perfect for matrices or spreadsheet-like data. * **Declaration:** `int matrix[3][4];` (Creates a 3x4 matrix of integers - 3 rows, 4 columns) * **Accessing Elements:** Need *two* indices: `matrix[0][1] = 5;` (assigns 5 to the element in the *first* row and *second* column). * **Initialization:** `int board[2][2] = {{1, 2}, {3, 4}};` **Array Power-Ups: Searching & Sorting!** 🔍 🔢 * **Searching:** Find a specific value within an array. (Linear Search, Binary Search) * Example: `linearSearch(numbers, 5, 30);` (Searches array 'numbers' for the value 30) * **Sorting:** Arrange array elements in ascending or descending order. (Bubble Sort, Insertion Sort) * Example: `bubbleSort(numbers, 5);` (Sorts array 'numbers' using Bubble Sort) **Matrix Magic: Operations!** ➕➖✖️ * 2D arrays shine with matrix operations. Think image processing, game development, and more! * **Addition:** Add corresponding elements of two matrices to create a new matrix. * **Subtraction:** Subtract corresponding elements of two matrices. * **Multiplication:** More complex, involving rows and columns! * Example: `matrixMultiply(matrixA, matrixB, result, rowsA, colsA, colsB);` **Important Notes!** ⚠️ * Array indices start at 0! * Be careful not to access elements outside the array bounds (leads to errors!). * Arrays are powerful – master them for efficient data handling! #Cprogramming #Arrays #DataStructures #Coding #BeginnerCoding

#CProgramming #Recursion #NumberReversal

Can you reverse a number using recursion in C?

#include <stdio.h>

int reverse_number(int num, int reversed_num) {
  if (num == 0) {
    return reversed_num;
  }
  int remainder = num % 10;
  reversed_num = reversed_num * 10 + remainder;
  return reverse_number(num / 10, reversed_num);
}

int main() {
  int number = 12345;
  int reversed = reverse_number(number, 0);
  printf("Original number: %d\n", number);
  printf("Reversed number: %d\n", reversed);
  return 0;
}

#CProgramming #Recursion #DigitsSum

Unlocking Recursion: Can you sum the digits of a number recursively in C?

#include <stdio.h>

int sumOfDigits(int n) {
  if (n == 0)
    return 0;
  return (n % 10 + sumOfDigits(n / 10));
}

int main() {
  int num;
  scanf("%d", &num);
  printf("%d", sumOfDigits(num));
  return 0;
}

#Cprogramming #Recursion #PowerFunction

Recursive Power: Unleashing the Power of C Functions!

#include <stdio.h>

int power(int base, int exp) {
    if (exp == 0)
        return 1;
    else if (exp % 2 == 0) {
        int temp = power(base, exp / 2);
        return temp * temp;
    } else {
        return base * power(base, exp / 2) * power(base, exp / 2);
    }
}

int main() {
    int base, exp;
    printf("Enter base: ");
    scanf("%d", &base);
    printf("Enter exponent: ");
    scanf("%d", &exp);
    printf("%d^%d = %d", base, exp, power(base, exp));
    return 0;
}

#CProgramming #PrimeNumber #Algorithm

Is this number PRIME? C function to the rescue!

#include <stdio.h>
#include <stdbool.h>

bool isPrime(int n) {
  if (n <= 1) return false;
  for (int i = 2; i * i <= n; i++) {
    if (n % i == 0) return false;
  }
  return true;
}

int main() {
  int num;
  printf("Enter a number: ");
  scanf("%d", &num);
  if (isPrime(num)) {
    printf("%d is a prime number.\n", num);
  } else {
    printf("%d is not a prime number.\n", num);
  }
  return 0;
}

#CProgramming #GCDLCM #Algorithms

Can you find the Greatest Common Divisor (GCD) and Least Common Multiple (LCM) using functions in C?

#include <stdio.h>

int gcd(int a, int b) {
    if (b == 0) {
        return a;
    }
    return gcd(b, a % b);
}

int lcm(int a, int b) {
    return (a * b) / gcd(a, b);
}

int main() {
    int num1, num2;
    printf("Enter two positive integers: ");
    scanf("%d %d", &num1, &num2);

    printf("GCD of %d and %d is %d\n", num1, num2, gcd(num1, num2));
    printf("LCM of %d and %d is %d\n", num1, num2, lcm(num1, num2));

    return 0;
}

#CProgramming #Recursion #Fibonacci

Unlocking the Fibonacci Sequence: Can Recursion Show the Way?

#include <stdio.h>

int fibonacci(int n) {
    if (n <= 1)
        return n;
    return fibonacci(n - 1) + fibonacci(n - 2);
}

int main() {
    int n = 10;
    printf("Fibonacci sequence up to %d: ", n);
    for (int i = 0; i < n; i++) {
        printf("%d ", fibonacci(i));
    }
    printf("\n");
    return 0;
}

#CProgramming #Recursion #Factorial

Can Recursion Calculate Factorials in C?

#include <stdio.h>

int factorial(int n) {
 if (n == 0)
 return 1;
 else
 return n * factorial(n - 1);
}

int main() {
 int num = 5;
 printf("Factorial of %d is %d\n", num, factorial(num));
 return 0;
}

# C Functions & Recursion: Code Ninjas Unite! 🥷 Level up your C programming skills! Let's explore functions and recursion, powerful tools for writing clean and efficient code. ## What are Functions? 🤔 Imagine functions as mini-programs within your main program. They do specific tasks. * **Purpose:** Break down complex problems into smaller, manageable pieces. * **Benefit:** Code reusability! Write once, use many times. * **Example:** A function to calculate the area of a circle. You can call it whenever you need that calculation! ## Function Structure 🏗️ ```c // Function Declaration (Prototype) int add(int a, int b); // Function Definition int add(int a, int b) { return a + b; } // Function Call int result = add(5, 3); // result will be 8 ``` * **Declaration:** Tells the compiler about the function's name, return type, and parameters. * **Definition:** Contains the actual code that the function executes. * **Call:** Invokes the function, executing its code with specified arguments. ## Why Use Functions? 💡 * **Modularity:** Makes code easier to understand and maintain. * **Reusability:** Avoid writing the same code multiple times. * **Readability:** Improves the overall structure of your program. * **Debugging:** Simplifies the process of finding and fixing errors. ## Recursion: Functions Calling Themselves! 🔄 Think of recursion like a set of Russian nesting dolls. A function calls itself to solve smaller versions of the same problem. * **Base Case:** The condition that stops the recursion (essential!). * **Recursive Step:** The function calls itself with a modified input. ## Recursive Example: Factorial 🤯 ```c int factorial(int n) { if (n == 0) { // Base case: Factorial of 0 is 1 return 1; } else { return n * factorial(n - 1); // Recursive step } } ``` * `factorial(5)` becomes `5 * factorial(4)` which becomes `5 * 4 * factorial(3)` and so on until the base case. ## Recursion vs. Iteration ⚔️ Both solve repetitive tasks. Recursion can be elegant, but iteration (loops) is often more efficient in C. Choose wisely! * **Recursion:** Elegant, can be slower due to function call overhead. * **Iteration:** Usually faster, can be less readable for some problems. ## Level Up! 💪 Practice creating and using functions and recursive algorithms. Start with simple examples like calculating sums, finding maximums, or implementing Fibonacci sequences. You'll be a C code ninja in no time!

#Cprogramming #PascalTriangle #Algorithms