DSA and Dev Days: Arun's Learning Blog

Day 8: Exploring the Power of PHP

Arun Kumar — Sat, 23 Dec 2023 14:51:28 GMT

Introduction

Welcome to our PHP-centric space, where we embark on a comprehensive journey to unravel the incredible world of web development. Whether you're a budding programmer or a seasoned developer looking to expand your skill set, PHP (Hypertext Preprocessor) stands as a general-purpose server-side scripting language widely used for building dynamic and interactive websites.

Chapter 1: Getting Started with PHP

1.1 Why PHP?

PHP is a versatile scripting language known for its ease of integration, powerful features, and robust community support. Learning PHP opens the door to building dynamic web applications, managing databases, and creating a wide range of interactive features for websites.

PHP in web development

It is easily embedded into HTML.
It is compatible with Apache web server.
It doesn't need to be pre-compiled.
It has built-in integration with DBMS - MySQL.

Here are some examples of well-known websites and applications built with PHP: Facebook, WordPress, Wikipedia, Yahoo, Flickr, etc.

1.2 Setting Up Your Development Environment

Before we jump into coding, let's ensure your development environment is ready.

1.2.1 Installing a Web Server

PHP is typically run on a web server. You can choose popular options like Apache or Nginx, depending on your preferences.

1.2.2 Installing PHP

Head over to the official PHP website (php.net) to download and install the latest version of PHP. The website provides clear instructions for various operating systems.

1.2.3 Choosing a Code Editor

Selecting a suitable code editor is crucial for an efficient coding experience. Consider using Visual Studio Code, Sublime Text, or PHPStorm, which are widely used in the PHP development community.

1.3 Your First PHP Script


  echo "Hello, World!";
?>

Here's a breakdown of the code:

: This is the opening tag for PHP code. It indicates the start of the PHP script.


echo "Hello, World!";: The echo statement is used to output text. In this case, it outputs the string "Hello, World!". The semicolon ; is used to terminate the statement.

?>: This is the closing tag for PHP code. It indicates the end of the PHP script.


Save this code in a file with a .php extension (for example, hello.php). You can then run this script on a server with PHP installed by accessing it through a web browser.
1.4 PHP-HTML Integration for Web Dynamism

We can write both PHP and HTML code inside a PHP file.

HTML code must be written outside the PHP tags.

And, PHP code must always be written inside the PHP tags.

But we cannot write PHP code inside an HTML file.


Chapter 2: PHP Basics
2.1 PHP Syntax

The most commonly used tags are  to open a PHP block and ?> to close it.


All PHP statements must end with a semicolon.

All our PHP code must be written inside the PHP tags.

PHP code must be written in a file with extension ".php"

Single-line comments start with //.

Multi-line comments start with /* and end with */.


2.2 Variables and Data Types

Variables start with a dollar ($). $a, $str, $arr

A variable name can contain alpha-numeric characters and the underscore, but not any other special characters.

A variable name cannot start with a number.

It must start with either an alphabet or the underscore.

Variable names are case sensitive. Meaning, $a and $A are two different variables.

Common data types in PHP (integers, strings, float, arrays, booleans, object, NULL).


2.3 Operators

2.4 Conditional statements (if, else, elseif)

    $num = 10;
    if($num>0){
        echo "Positive integer";
    }else if($num<0){
        echo "Negative integer";
    }else{
        echo "Zero";
    }
?>

2.5 Switch statements

    switch ($variable) {
        case 'value':
            // code...
            break;

        default:
            // code...
            break;
?>

2.6 Looping structures (for, while, do-while, foreach)

    while(/*--condition--*/){
        // code...
    }

    for (/*--initialization--*/; /*--condition--*/; /*--iteration--*/){  
        // code...
    }

    do{
        // code...
    }while(/*--condition--*/);

    foreach($array as $element){
        // code... 
    }

    //Example for foreach...
    $arr= array(2,4,6,8,10);
    foreach ($arr as $i){
        echo $i." ";

    }
?>

2.7 Arrays

Numeric indexed array
  
      $arr = array(0,1,2,3,4,5,6,7,8,9); 
      // $arr = [0,1,2,3,4,5,6,7,8,9] -- is also correct
      // index starts from zero -- $arr[0] = 0;
      // append value 10 -- $arr[10] = 10;
  ?>


Associative indexed array

  
  // they have strings or texts as its indices
  // it more like a key value pair
      $years = array("Bill" => 1993, "George" => 2001, "Barack" => 2009);

      foreach ($years as $name => $year) {
          echo $name . " was first elected in " . $year . "\n";
      } 

      $years["Joe"] = 2021; // appends a new pair
  ?>


Multidimensional array
  
      $matrix = [
          [1, 2, 3],
          [4, 5, 6],
          [7, 8, 9]
      ];

      foreach($matrix as $row){
          foreach($row as $element){
              echo $element." ";
          }
      }
  ?>



2.7 Strings

// Escape characther (/) either adds a special meaning to the following character or if the following character is already special, the escape character removes its special meaning and treats it like a normal text character.
// double quotes (") - remove special char while printing
    echo "I am Arun \n I love Dogs"; 
    //I am Arun 
    //I love Dogs

// single quotes (') - print entire content within it 
    echo 'I am Arun \n I love Dogs'; 
    //I am Arun \n I love Dogs

//dot (.) operator is used for concatenation
?>

Chapter 3: Functions in PHP
3.1 Introduction to Functions
In the realm of programming, functions play a pivotal role in organizing and streamlining code. Let's delve into the fundamentals.
Functions: A function is a self-contained block of code designed to perform a specific task. It encapsulates a sequence of operations, takes inputs (if necessary), and produces an output.
Built-In Functions: These functions are pre-built and come with the programming language or specific libraries.
User-Defined Functions: These functions are created by the programmer based on specific requirements.
3.2 Creating and Using Functions
User defined functions

function addNumbers($a=0, $b=0) { //here a=0 and b=0 are given as default values
    return $a + $b;
}
$result = addNumbers(5, 7);
echo "Sum: $result"; // Output: Sum: 12
?>

Local Scope

function localVarExample() {
    $localVariable = "I am local";
    echo $localVariable;
}
localVarExample(); // Output: I am local
// echo $localVariable; // This would result in an error
?>

Global Scope

    $globalVariable = "I am global";
    function globalVarExample() {
        global $globalVariable; //accesses this global variable using the global keyword within the function
        echo $globalVariable;
    }
    globalVarExample(); // Output: I am global
    echo $globalVariable; // Output: I am global
?>

Call by value

    function incrementValue($number) {
        $number++;
        echo $number; //6
    }
    $originalNumber = 5;
    incrementValue($originalNumber);
    echo $originalNumber; //5
?>

Call by reference

    function incrementReference(&$number) {
        $number++;
        echo $number; //6
    }
    $originalNumber = 5;
    incrementReference($originalNumber);
    echo $originalNumber; //6
?>

3.3 Common Built-in Functions

    $str = 'abcdef';
    echo strlen($str); // 6    

    // explode function is similar to .split()
    $pizza  = "piece1 piece2 piece3 piece4 piece5 piece6";
    $pieces = explode(" ", $pizza);
    echo $pieces[0]; // piece1
    echo $pieces[1]; // piece2

    //implode function is similar to .join()
    $words = array("Hello", "World", "PHP", "is", "awesome");
    $result = implode(" ", $words);
    echo $result; // Hello World PHP is awesome

    /* Commonly used built-in functions
    String Functions:
        strlen() - Returns the length of a string.
        strpos() - Finds the position of the first occurrence of a substring in a string.
        str_replace() - Replaces all occurrences of a search string with a replacement string.
        strtolower() - Converts a string to lowercase.
        strtoupper() - Converts a string to uppercase.
        trim() - Removes whitespace or other predefined characters from both ends of a string.
        substr() - Returns a part of a string.
    Array Functions:
        count() - Counts the number of elements in an array.
        array_push() - Pushes one or more elements onto the end of an array.
        array_pop() - Pops the element off the end of an array.
        array_merge() - Merges two or more arrays.
        array_keys() - Returns all the keys or a subset of the keys of an array.
        array_values() - Returns all the values of an array.
    Math Functions:
        round() - Rounds a floating-point number.
        rand() - Generates a random number.
        floor() - Rounds fractions down to the nearest whole number.
        ceil() - Rounds fractions up to the nearest whole number.    
    Miscellaneous Functions:
        echo() - Outputs one or more strings.
        print() - Outputs a string.
        isset() - Checks if a variable is set and is not NULL.
        empty() - Checks if a variable is empty.
        htmlspecialchars() - Converts special characters to HTML entities.
    */    
?>

Chapter 4: PHP and Databases
4.1 Introduction to Databases
In web development, databases play a pivotal role in storing, managing, and retrieving data. They provide a structured and efficient way to organize information for dynamic web applications. Databases are essential for handling user data, content management, and various other aspects of web development.
4.2 Database related Functions

mysqli_connect()
  It is used to establish a connection with MySQL server.
  $conn = mysqli_connect($db_hostname, $db_username, $db_password, $db_name);
  It returns false, if there is any error in connecting with server.

mysqli_connect_error()
  It is used to return the last error message from the last call to mysqli_connect().
  echo mysqli_connect_error();

mysqli_query()
  It is used to execute an SQL query on the selected database.
  $result = mysqli_query($conn, $sql);
  $conn - > reference object
  $sql - > SQL query in string format

mysqli_fetch_assoc()
  It is used to fetch all the data from the reference object that we get from the mysqli_query() function in case of SELECT queries.
  $row = mysqli_fetch_assoc($result);

mysqli_error()
  It returns the last error message for the last call to mysqli_query()
  echo mysqli_error($conn);

mysqli_close()
  It closes the previously opened connections with the MySQL server.
  mysqli_close($conn);


4.3 Super Globals
Superglobals in PHP are predefined associative global arrays that are accessible from any part of the script, including functions, classes, and files. These arrays contain various types of data, such as form input, session information, server details, and more. Here are some commonly used superglobals:

$_GET:

Contains data sent to the script via URL parameters using the HTTP GET method.


$_POST:

Contains data sent to the script via the HTTP POST method, often used with HTML forms.

POST method is preferred over GET method due to safety concerns.



$_REQUEST:

Contains data from both $_GET, $_POST, and $_COOKIE. The values are determined by the request method.


$_SESSION:

Contains session variables that are accessible across multiple pages during a user's session.


$_COOKIE:

Contains values sent to the script via HTTP cookies.


$_SERVER:

Contains information about the server environment and the execution environment of the current script.


$_FILES:

Contains information about file uploads submitted through HTML forms.


$_ENV:

Contains environment variables.


$_GLOBALS:

Contains all global variables in the global scope.



These superglobals provide a convenient way to access and manipulate various types of data commonly used in web development. It's important to note that the data in these superglobals should be validated and sanitized before using it in your scripts to prevent security vulnerabilities such as injection attacks.
Here's a simple example using $_GET:

// Assuming the URL is: http://example.com/index.php?name=John
$name = $_GET['name'];
echo "Hello, $name!"; // Output: Hello, John!
?>

In this example, $_GET is used to retrieve the value of the 'name' parameter from the URL.
Chapter 5: Advanced PHP Concepts (to be continued...)
5.1 Registration, Identification, Authentication
5.2 Cookies
5.3 Sessions
Conclusion
In conclusion, our PHP journey delved into fundamental web development aspects, guiding both beginners and experts through PHP's versatile landscape. From syntax basics to dynamic PHP-HTML integration, functions, and seamless MySQL interaction, this guide laid a strong foundation. Emphasizing the significance of superglobals and validation, our journey anticipates exploring advanced PHP concepts like registration, authentication, cookies, and sessions. Stay tuned for insights into PHP's capabilities in upcoming chapters.
In closing, I'd like to express my gratitude to all our readers. Thank you for joining us on this PHP exploration. Your curiosity and enthusiasm drive us to continue sharing insights into the dynamic world of web development. Stay engaged, and we look forward to continuing this journey together.



Day 7: Mastering DBMS
Arun Kumar — Fri, 22 Dec 2023 12:30:43 GMT
Introduction
In the ever-evolving world of technology, effective data management is crucial for businesses and organizations to thrive. Database Management Systems (DBMS) play a pivotal role in organizing and managing vast amounts of data efficiently. In this tutorial, we will delve into the fundamentals of DBMS, with a focus on MySQL, one of the most popular relational database management systems, and the Structured Query Language (SQL), the standard language for interacting with relational databases.
What is DBMS?
A Database Management System (DBMS) is a software suite that facilitates the creation, maintenance, and manipulation of databases. It provides an interface for users and applications to interact with the database without dealing with the complexities of data storage and retrieval. DBMS ensures data integrity, security, and efficient management of information.
Why MySQL?
MySQL is an open-source relational database management system that has gained widespread popularity for its reliability, performance, and ease of use. It is suitable for a variety of applications, ranging from small-scale projects to large enterprise-level systems. MySQL supports SQL, making it a powerful choice for developers and database administrators.
Distinguish between SQL and MySQL
SQL serves as the language for interacting with databases, offering a common syntax across various systems (SQL is case insensitive and end with ';'). On the other hand, MySQL is one of several database systems that implement SQL. Think of SQL as the language and MySQL as a fluent speaker of that language.
Understanding Basic Terminologies

Database: A Database is where all the data (table) is stored.
Table: A Table is an arrangement of data in rows and columns.
Attribute: Attribute specify the kind of information a table stores.
Record/Data value: A record represent an instance of the entity the table represens.
SQL Commands
These SQL commands are mainly categorized into five categories:

DDL – Data Definition Language

DQL – Data Query Language

DML – Data Manipulation Language

DCL – Data Control Language

TCL – Transaction Control Language



Operations on Database
Display all the databases present
SQL query to show all the database in the system.
SHOW DATABASES;

Creating a database
SQL query to create a database named "college".
CREATE DATABASE college;

Selecting a database
SQL query to select the college database to perform operations on it.
USE college;

Check which database is selected
SELECT DATABASE(); is the query to check which database is selected.
SELECT DATABASE();

Delete a database
DROP DATABASE ; is the query to delete a database.
DROP DATABASE ;

Operations of Table
Display all the Tables
SHOW TABLES; (note the plural form) is the query to display all the tables present in the selected database.
SHOW TABLES;

Creating a table
Creating a table need concern is three things

Datatype - what type of data is going to be present in the column ( int, float, varchar, etc.).

Constraint - size of varchar, AUTO_INCREMENT, not null, etc.

Default value - It is applied in case the user doesn't give any input.


CREATE TABLE students (
    s_no INT NOT NULL AUTO_INCREMENT,
    name VARCHAR(255) NOT NULL,
    registration_number VARCHAR(255) NOT NULL,
    gender VARCHAR(255),
    department VARCHAR(255),
    no_of_compartment INT NOT NULL DEFAULT 0,
    PRIMARY KEY(s_no)
);





s_no name registration_number gender department no_of_compartment






Primary Key (PK):

A primary key is a column or a set of columns that uniquely identifies each record in a table.

It must have a unique value for each record and cannot contain NULL values.


View Description of table
This query shows the datatypes, constraints and default values of every attribute of a table.
DESC students;

Altering a Table

Adding a new attribute - add a column to the existing table
  ALTER TABLE tableName ADD columnName columnDefinition;
  ALTER TABLE students ADD semester varchar(255) NOT NULL DEFAULT 1;


Deleting an existing attribute - drop a column from the existing table
  ALTER TABLE tableName DROP columnName;
  ALTER TABLE students DROP semester;


Modifying an existing attribute - changing the constraints and datatypes of a pre-existing column
  ALTER TABLE students MODIFY no_of_compartment INT NOT NULL DEFAULT 1;


Changing the name of the attribute - rename a column
  ALTER TABLE table_name CHANGE old_attribute_name new_name constraints;
  ALTER TABLE students CHANGE no_of_compartment compartment INT NOT NULL DEFAULT 1;


Renaming the table
  ALTER TABLE students RENAME TO students_college;



Linking table
Foreign Key (FK):

A foreign key is a column or a set of columns in a table that refers to the primary key of another table.

It establishes a link between two tables, creating a relationship.

Helps maintain referential integrity between tables.

Defined using the FOREIGN KEY constraint.



Here while creating companies table, FOREIGN KEY(company_id) REFERENCES companies(id) is the query for linking company_id attribute of students table to primary key of companies table, i.e. id.
A Foreign Key is declared to break down complex tables into multiple smaller tables because complexity leads to a greater scope for mistakes.
Operations on Records
Inserting data
INSERT INTO table_name (attributes...) VALUES (values_corresponding_to_attribute..);
INSERT INTO students (name, registration_number, gender) VALUES ("ARUN", 312422106016, "Male");

INSERT INTO table_name VALUES (values_in_perfect_order_of_table);
INSERT INTO students VALUES (2, "KEN", 312422106000, "MALE", "ECE", 2);

Fetching data
SELECT * FROM students; --It displays entire table
SELECT name, gender FROM students; --It displays only specified attributes
SELECT * FROM students WHERE compartment>0; -- It display the records which satisfies the conditional only
-- WHERE clause can be combbined by AND, OR, =, !=, >, <, >=,<= operators
SELECT * FROM students order by name ASC; --It displays data in ordered way asc or desc

Updating data
UPDATE table_name SET attribute_name=value WHERE primary_key=value;
UPDATE students SET 
registration_number = 312422106001,
compartment = 0
WHERE s_no = 2;

Deleting data
DELETE FROM table_name WHERE primary_key=value;
DELETE FROM students WHERE s_no=2; --Absence of where clause will delete entire records

Database Relationships
It means association between two tables. It is of three types,

One to many
  These types of relationships can be resolved using a foreign key. Foreign keys must be able to uniquely identify a row from the other table. Hence, we have a foreign key on that table that can have multiple records referring to a single record of the other table, which needs to be uniquely identified.

One to One
  In these cases, the tables can be merged into one.

Many to many
  Resolving these relationships require formation of an intermediate new table.


JOIN Queries
It is used to merge multiple SQL queries, it works by combining two tables into a single virtual table.

In MySQL there are three types of join queries,
INNER JOIN

Inner join query shows the records only if associated values are present on both tables
  
  SELECT
      *
  FROM
      students
  INNER JOIN
      companies
  ON
      students.company_id=companies.id;
  /* It displays records associated with values in both tables */



LEFT JOIN

It displays all the data from left table irrespective of its association with the right table. But it displays data in right table only if has one association with left table.
  
  SELECT
      *
  FROM
      students
  LEFT JOIN
      companies
  ON
      students.company_id=companies.id; 
  /* It displays all records in left table, but right table require association with left table in order to be displayed*/



RIGHT JOIN

It displays all the data from right table irrespective of its association with the left table. But it displays data in left table only if has one association with right table.
  
  SELECT
      *
  FROM
      students
  RIGHT JOIN
      companies
  ON
      students.company_id=companies.id;
  /* It displays all records in right table, but left table require association with right table in order to be displayed */



Conclusion
This tutorial covered the fundamentals of Database Management Systems using MySQL and SQL. We explored creating databases, tables, and performing basic to advanced data manipulation operations. Understanding these concepts is crucial for anyone working with databases, and MySQL, with its robust features, serves as an excellent platform for database management.
Remember, this is just the beginning. The world of databases and SQL is vast, and continuous learning is key to mastering these essential skills in the realm of software development and data management.



Day 6: Binary Search Algorithm
Arun Kumar — Tue, 26 Sep 2023 14:29:49 GMT

Binary Search Overview

Binary search is a fast search algorithm that works on sorted arrays. It repeatedly divides the search interval in half, reducing the search space by half with each iteration.

It has a time complexity of O(log n) where "n" is the number of elements in the array. This makes it much more efficient than linear search for large data sets.


Java Code for Binary Search
public class BinarySearch {
    public static int binarySearch(int[] arr, int target) {
        int start = 0;
        int end = arr.length - 1;

        while (start <= end) {
            int mid = start + (end - start) / 2;

            if (arr[mid] == target) {
                return mid; // Return the index where the target is found
            } else if (arr[mid] < target) {
                start = mid + 1;
            } else {
                end = mid - 1;
            }
        }

        return -1; // Return -1 if the target is not found
    }

    public static void main(String[] args) {
        int[] arr = { 2, 4, 6, 8, 10, 12, 14 };
        int target = 8;
        int result = binarySearch(arr, target);
        if (result != -1) {
            System.out.println("Element found at index " + result);
        } else {
            System.out.println("Element not found in the array.");
        }
    }
}

Binary Search Algorithm
Binary search works by repeatedly dividing the search range in half until the desired element is found or the search range becomes empty.

Start with a sorted array: Binary search requires that the input array is sorted in ascending order.

Initialize variables:

left - The index of the leftmost element in the search range (initially 0).

right - The index of the rightmost element in the search range (initially the length of the array minus 1).



Repeat until the search range is empty: a. Calculate the middle index as mid = (left + right) / 2. b. Compare the element at the middle index with the target element. c. If the middle element is equal to the target, return its index (search successful). d. If the middle element is less than the target, update left to mid + 1. e. If the middle element is greater than the target, update right to mid - 1.

If the loop exits without finding the target, return -1 to indicate that the element is not in the array.


Finding Mid-term

The below-mentioned two expressions are used to calculate the middle index of a range, typically for binary search or similar algorithms. However, the first expression:
  int mid = left + (right - left) / 2;


is preferred over the second expression:

  int mid = (left + right) / 2;


The reason for this preference is to avoid potential integer overflow issues. The first expression ensures that the subtraction right - left is performed before dividing by 2. This is important because if left and right are very large integers, directly adding them together could result in an integer overflow, which may lead to incorrect results or undefined behavior.

By subtracting left from right first and then dividing by 2, you avoid this potential overflow problem and ensure the correct middle index is calculated, even for large values of left and right. Therefore, the first expression is a safer and more robust way to calculate the middle index in practice.


Order-Agnostic Binary-Search

The above code is good if we know that the array is sorted in ascending order, but what if we don't know whether it is sorted in ascending or descending order?

That's where Order-agnostic binary search comes into play.


Java Code for Order-Agnostic Binary Search
public class Main {
    public static int orderAgnosticBS(int[] arr, int target) {
        int start = 0;
        int end = arr.length - 1;

        // Determine the order of the array (ascending or descending)
        boolean isAscending = arr[start] < arr[end];

        while (start <= end) {
            int mid = start + (end - start) / 2;

            if (arr[mid] == target) {
                return mid; // Return the index where the target is found
            }

            if (isAscending) {
                if (arr[mid] < target) {
                    start = mid + 1;
                } else {
                    end = mid - 1;
                }
            } else {
                if (arr[mid] > target) {
                    start = mid + 1;
                } else {
                    end = mid - 1;
                }
            }
        }

        return -1; // Return -1 if the target is not found
    }

    public static void main(String[] args) {
        int[] ascendingArr = { 2, 4, 6, 8, 10, 12, 14 };
        int[] descendingArr = { 14, 12, 10, 8, 6, 4, 2 };

        int target = 8;
        int ascendingResult = orderAgnosticBS(ascendingArr, target);
        int descendingResult = orderAgnosticBS(descendingArr, target);

        if (ascendingResult != -1) {
            System.out.println("Element found at index " + ascendingResult + " in the ascending array.");
        } else {
            System.out.println("Element not found in the ascending array.");
        }

        if (descendingResult != -1) {
            System.out.println("Element found at index " + descendingResult + " in the descending array.");
        } else {
            System.out.println("Element not found in the descending array.");
        }
    }
}

Use Cases

Binary search is highly efficient and suitable for large sorted data sets.

It is commonly used in situations where you need to quickly find an element in a sorted list, such as searching in a sorted array or a dictionary.


Performance

Binary search has a time complexity of O(log n), making it very efficient for large data sets.

It divides the search space in half with each iteration, leading to fast search times.

For you to understand how efficient it is, let's take an example array of 1 million elements. In the worst-case scenario in a linear search algorithm, 1 million comparisons are made. However, in binary search algorithms, only 20 comparisons are made. I hope now you can understand the difference.


Conclusion

Binary search is a powerful and efficient algorithm for searching in sorted data sets.

It outperforms linear search for large data sets but requires that the data be sorted beforehand.

When you need to find elements in a sorted list, binary search is a top choice.





Day 5: Linear Search Algorithm + LeetCode
Arun Kumar — Mon, 25 Sep 2023 16:53:27 GMT

Certainly! Here are some notes on implementing a linear search algorithm in Java:
Linear Search Overview

Linear search is a basic searching algorithm that sequentially checks each element in a list or array until a match is found.

It's straightforward but not the most efficient for large data sets. It has a time complexity of O(n) where "n" is the number of elements in the list.


Java Code for Linear Search in 1D Array
public class LinearSearch {
    public static int linearSearch(int[] arr, int target) {
        for (int i = 0; i < arr.length; i++) {
            if (arr[i] == target) {
                return i; // Return the index where the target is found
            }
        }
        return -1; // Return -1 if the target is not found
    }

    public static void main(String[] args) {
        int[] arr = { 2, 4, 6, 8, 10, 12, 14 };
        int target = 8;
        int result = linearSearch(arr, target);
        if (result != -1) {
            System.out.println("Element found at index " + result);
        } else {
            System.out.println("Element not found in the array.");
        }
    }
}

Java Code for Linear Search in 2D Array
import java.util.*;

public class LinearSearch2D {
    public static int[] linearSearch2D(int[][] arr, int target) {
        for (int row = 0; row < arr.length; row++) {
            for (int col=0; colif (arr[row][col] == target) {
                    return new int[]{row,col}; // Return the index array where the target is found
                }
            }
        }
        return new int[]{-1}; // Return -1 if the target is not found
    }

    public static void main(String[] args) {
        int[][] arr = { 
            {1,2,3},
            {4,5},
            {6,7,8,9}
        };
        int target = 8;
        int[] result = linearSearch2D(arr, target);
        if (result[0] != -1) {
            System.out.println("Element found at index " + Arrays.toString(result));
        } else {
            System.out.println("Element not found in the array.");
        }
    }
}

LeetCode time (1295. Find Numbers with Even Number of Digits)

Given an array nums of integers, return how many of them contain an even number of digits.

Example 1:
  Input: nums = [12,345,2,6,7896]
  Output: 2
  Explanation: 
  12 contains 2 digits (even number of digits). 
  345 contains 3 digits (odd number of digits). 
  2 contains 1 digit (odd number of digits). 
  6 contains 1 digit (odd number of digits). 
  7896 contains 4 digits (even number of digits). 
  Therefore only 12 and 7896 contain an even number of digits.

  Example 2:
  Input: nums = [555,901,482,1771]
  Output: 1 
  Explanation: 
  Only 1771 contains an even number of digits.


I have attached my solution code below, ...


class Solution {
    public int findNumbers(int[] nums) {
       int ev = 0;
       for(int num: nums){
           if (evdigi(num)%2==0){
               ev++;
           }
       }
       return ev; 
    }
    public int evdigi(int n) {
        int digi = 0;
        while(n>0) {
            digi++;
            n/=10;
        }
        return digi;
    }
}

LeetCode time (1672. Richest Customer Wealth)

You are given an m x n integer grid accounts where accounts[i][j] is the amount of money the i^th customer has in the j^th bank. Return the wealth that the richest customer has.

A customer's wealth is the amount of money they have in all their bank accounts. The richest customer is the customer that has the maximum wealth.

Example 1:
  Input: accounts = [[1,2,3],[3,2,1]]
  Output: 6
  Explanation:
  1st customer has wealth = 1 + 2 + 3 = 6
  2nd customer has wealth = 3 + 2 + 1 = 6
  Both customers are considered the richest with a wealth of 6 each, so return 6.

  Example 2:
  Input: accounts = [[1,5],[7,3],[3,5]]
  Output: 10
  Explanation: 
  1st customer has wealth = 6
  2nd customer has wealth = 10 
  3rd customer has wealth = 8
  The 2nd customer is the richest with a wealth of 10.
  Example 3:


I have attached my solution code below, ...


class Solution {
    public int maximumWealth(int[][] accounts) {
        int sum = 0;
        for(int i=0; iint x = 0;
            for(int j=0; jif(i==0){
                sum = x;
            }else if (x>sum){
                sum = x;
            }
        }
        return sum;
    }
}

Key Points

The linearSearch function takes an array (arr) and a target value to search for.

It iterates through the array using a for loop and compares each element with the target value.

If a match is found, it returns the index of the element; otherwise, it returns -1 to indicate that the target is not in the array.

In the main method, we demonstrate how to use the linearSearch function.


Use Cases

Linear search is suitable for small data sets or when the data is not sorted.

It's a simple and intuitive algorithm that works well when there's no specific order to the data.


Performance

Linear search has a time complexity of O(n), meaning its execution time increases linearly with the size of the input array. For larger data sets, more efficient algorithms like binary search may be preferred.

Best case -> element found at 0th position of array itself -> O(1)

Worst case -> element not found in array -> O(n)


Conclusion
Remember that linear search is not the most efficient search algorithm for large data sets, but it can be a good choice for smaller arrays or when simplicity is more important than speed.



Day 4: Exploring  Arrays and ArrayList
Arun Kumar — Sun, 24 Sep 2023 16:55:46 GMT
Why do we need Array?
Arrays are essential data structures in programming because they allow us to store and manage collections of elements efficiently. They provide a way to group related data under a single variable name, simplifying code organization. Arrays facilitate easy access to individual elements through indexing, making it convenient for tasks like data retrieval and manipulation. They also enable repetitive operations and iterative processes, enhancing code readability and reducing redundancy.
Certainly! Here are some key notes about arrays in Java along with code examples:
Declaration and Initialization

Declare an array using square brackets after the data type.

Initialize an array using the new keyword or by specifying values enclosed in curly braces {}.


// Declaration and initialization of an integer array
int[] numbers = new int[5]; // Creates an array of size 5
// Here new keyword is used to create an object of size 5 in memory
int[] primeNumbers = {2, 3, 5, 7, 11}; // Initializes an array with values

Accessing Elements

Array elements are accessed using zero-based indexing.

Use square brackets [] to access elements.


int firstNumber = numbers[0]; // Accesses the first element (index 0)
int thirdPrime = primeNumbers[2]; // Accesses the third element (index 2)

Array Length

You can find the length of an array using the length property.

int length = numbers.length; // Gets the length of the 'numbers' array

Iterating Through Arrays

Use loops like for or foreach to iterate through array elements.

for (int i = 0; i < numbers.length; i++) {
    System.out.println(numbers[i]);
}

for (int prime : primeNumbers) {
    System.out.println(prime);
}

Arrays.toString( ) Method

Returns a string representation of the contents of the specified array.

The string representation consists of a list of the array's elements, enclosed in square brackets ("[]"). Adjacent elements are separated by the characters ", " (a comma followed by a space).

Elements are converted to strings as by String.valueOf(int). Returns "null" if arr is null.


// Create an array of integers
int[] numbers = {1, 2, 3, 4, 5};
// Use Arrays.toString to get a string representation of the array
String arrayString = Arrays.toString(numbers);
// Print the string representation
System.out.println("Array as a string: " + arrayString);
//Output : Array as a string: [1, 2, 3, 4, 5]

Multi-Dimensional Arrays

Java supports multi-dimensional arrays, such as 2D arrays for representing tables or matrices.

While declaring a 2D array in Java, it is not compulsory to add no of columns though, because they can change with each elements

int arr[][] = { {1, 2, 3}, {4, 5}, {6, 7, 8, 9, 10} };


int[][] matrix = {{1, 2, 3}, {4, 5, 6}, {7, 8, 9}};
int element = matrix[1][2]; // Accesses the element at row 1, column 2 (value 6)

Array Manipulation

Arrays can be sorted, searched, and modified using various methods and algorithms provided by Java.

Arrays.sort(numbers); // Sorts the 'numbers' array in ascending order
int index = Arrays.binarySearch(primeNumbers, 7); // Searches for the value 7 in 'primeNumbers'

Array Bounds and Exceptions

Be cautious to avoid accessing elements outside the array bounds, which can lead to ArrayIndexOutOfBoundsException.

int outOfBounds = numbers[10]; // This will throw an exception if the array size is less than 11

Dynamic Arrays

Java arrays have a fixed size. If you need a dynamic-sized array, consider using ArrayList from the java.util package.

import java.util.ArrayList;
//Syntax:
//ArrayList nameOfArrayList = new ArrayList<>();
//
ArrayList dynamicArray = new ArrayList<>();
dynamicArray.add(42); // Adds an element to the dynamic array

Arrays are a fundamental part of Java and are widely used for data storage and manipulation in various applications. They provide a structured way to work with collections of data, making them a crucial concept for Java developers.
Conclusion
In conclusion, arrays are the backbone of data storage and manipulation in Java. They offer an efficient means of organizing and managing collections of elements, streamlining code organization and enhancing readability. With the ability to access individual elements via indexing, arrays enable various data retrieval and manipulation tasks while reducing redundancy.
We've explored the essential aspects of arrays in Java, from their declaration and initialization to accessing elements and determining array length. Iteration through arrays, utilizing the Arrays.toString() method for representation, and even handling multi-dimensional arrays have been discussed.
Stay tuned for our next exploration into problems on Array, which provide dynamic array functionality and opens up new possibilities in Java programming. Arrays and ArrayLists are fundamental tools in a Java developer's toolkit, and mastering them will expand your capabilities as a programmer.



Day 3: Getting to Know the Basics
Arun Kumar — Sat, 23 Sep 2023 16:29:37 GMT

Introduction
Conditionals and loops are fundamental programming constructs in Java, as well as in many other programming languages. They allow you to control the flow of your program and perform repetitive tasks. In Java, you can use the if statement for conditionals and various loop constructs such as for, while, and do-while for looping. Let's explore how to use them:
Conditional Statements (if, else if, else)
Conditional statements allow you to execute different blocks of code based on certain conditions.
1. if statement:
int age = 18;
if (age >= 18) {
    System.out.println("You are an adult.");
}

2. else if statement:
int age = 15;
if (age >= 18) {
    System.out.println("You are an adult.");
} else if (age >= 13) {
    System.out.println("You are a teenager.");
} else {
    System.out.println("You are a child.");
}

Loops
Loops allow you to repeatedly execute a block of code as long as a certain condition is met.
1. for loop:
for (int i = 0; i < 5; i++) {
    System.out.println("Iteration " + i);
}

2. while loop:
int count = 0;
while (count < 5) {
    System.out.println("Count: " + count);
    count++;
}

3. do-while loop:
int number = 1;
do {
    System.out.println("Number: " + number);
    number++;
} while (number <= 5);

In a for loop, you specify the initialization, condition, and update of the loop variable all in one place. In a while loop, you specify the condition before entering the loop, and in a do-while loop, the condition is checked after executing the loop at least once.
Logical Operators
Certainly! Logical operators are often used in conjunction with conditional statements to create more complex conditions. In Java, there are three main logical operators: && (logical AND), || (logical OR), and ! (logical NOT).
1. Logical AND (&&):
The logical AND operator returns true if both of its operands are true.
boolean isAdult = true;
boolean hasID = true;

if (isAdult && hasID) {
    System.out.println("You can enter the club.");
} else {
    System.out.println("You cannot enter the club.");
}

2. Logical OR (||):
The logical OR operator returns true if at least one of its operands is true.
boolean isStudent = true;
boolean isEmployee = false;

if (isStudent || isEmployee) {
    System.out.println("You are part of the institution.");
} else {
    System.out.println("You are not affiliated.");
}

3. Logical NOT (!):
The logical NOT operator negates the value of its operand. If the operand is true, it returns false, and if the operand is false, it returns true.
boolean isLoggedIn = false;

if (!isLoggedIn) {
    System.out.println("Please log in to continue.");
}

Control Flow Statements
You can use control flow statements within loops and conditionals to control the flow of your program further. Examples include break and continue statements.
break statement:
for (int i = 0; i < 10; i++) {
    if (i == 5) {
        break; // Exit the loop when i reaches 5.
    }
    System.out.println("i: " + i);
}

continue statement:
for (int i = 0; i < 10; i++) {
    if (i % 2 == 0) {
        continue; // Skip even numbers.
    }
    System.out.println("Odd number: " + i);
}

These are the basic constructs for conditionals and loops in Java. You can combine them to create more complex control structures for your programs.
Switch Statements

Switch statements allow you to perform different actions based on different values of a variable.

The variable in a switch statement is compared against different case values.

Use break to exit the switch block after executing a case.

You can include a default case for when no other cases match.

Switch statements are often used when you have multiple choices to handle.


Example:
int day = 3;
switch (day) {
    case 1:
        System.out.println("Monday");
        break;
    case 2:
        System.out.println("Tuesday");
        break;
    case 3:
        System.out.println("Wednesday");
        break;
    default:
        System.out.println("Other day");
}

In this example, "Wednesday" will be printed because day is set to 3. If day were 5, "Other day" would be printed due to the default case.
Functions/ Methods in Java
Functions (also known as methods in Java) are blocks of code that perform a specific task or a set of tasks. They allow you to break down your code into smaller, reusable pieces. In Java, methods are defined inside classes. Here's an overview of how to work with methods in Java:

Method Declaration:
 You declare a method using the following syntax:
 return_type method_name(parameter_list) {
     // method body
 }


return_type: The data type of the value that the method returns. Use void if the method doesn't return a value.

method_name: The name of the method.

parameter_list: A list of parameters (inputs) the method accepts, separated by commas. You can have zero or more parameters.



Method Parameters:
 Parameters are variables that you define in the method's parameter list, and they act as placeholders for the values you want to pass into the method when you call it. For example:
 int add(int a, int b) {
     return a + b;
 }


Using Varargs (Variable-Length Arguments):
 Java provides varargs (variable-length arguments) to pass a variable number of arguments of the same type to a method. Varargs are represented using an ellipsis ... after the parameter type.
 javaCopy codepublic void printItems(String... items) {
     for (String item : items) {
         System.out.print(item + " ");
     }
     System.out.println();
 }

 // Calling the method with varargs
 printItems("Apple", "Banana", "Cherry"); // Outputs: Apple Banana Cherry

 The method can be called with any number of arguments (including none) of the specified type.

Method Body:
 The method body contains the code that gets executed when the method is called. For example:
 void greet(String name) {
     System.out.println("Hello, " + name + "!");
 }


Calling a Method:
 To use a method, you call it by its name, passing the required arguments if any, like this:
 int result = add(5, 3);
 greet("Alice");


add(5, 3) calls the add method with arguments 5 and 3 and stores the result in the result variable.

greet("Alice") calls the greet method with the argument "Alice."



Return Statement:
 If the method has a return type other than void, it must include a return statement to return a value of the specified type. For example:
 int add(int a, int b) {
     return a + b;
 }


Void Methods:
 Methods with a return type of void do not return any value. They are used for performing actions without returning a result. For example:
 void printMessage() {
     System.out.println("This is a void method.");
 }


Method Overloading:
 Java allows you to define multiple methods with the same name in the same class as long as they have different parameter lists. This is called method overloading. Java will determine which method to call based on the arguments you provide when calling it.
 int add(int a, int b) {
     return a + b;
 }

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


Static Methods:
 Static methods belong to the class rather than an instance of the class. You can call static methods using the class name, without creating an object of the class.
 public static void staticMethod() {
     System.out.println("This is a static method.");
 }



Now you have a basic understanding of how to define and use methods in Java. Methods are essential for structuring your code, making it more organized, and promoting reusability.
Scope in Java
In Java, scope refers to the region of your code where a particular variable can be accessed or used. Understanding the scope of variables is essential for writing error-free and maintainable code. Java has several types of variable scope:
Local Scope:

Variables declared within a method, constructor, or block of code have local scope.

They can only be accessed within that method, constructor, or block.

Local variables are not visible outside of their enclosing block, and they are destroyed when the block exits.


void myMethod() {
    int localVar = 42; // localVar is only accessible inside myMethod()
    System.out.println(localVar); // This is valid
}

Method or Parameter Scope:

Method parameters have scope within the method they are declared in.

They can shadow (hide) class-level fields with the same name.


int myVar = 10; // Class-level variable

void myMethod(int myVar) {
    System.out.println(myVar); // This will print the parameter myVar, not the class-level one
}

Class Scope (Instance Variables):

Instance variables (also called fields) are declared within a class but outside of any method, constructor, or block.

They have class scope and can be accessed by any method within the same class, as well as by objects of that class.

Each instance (object) of the class has its own copy of instance variables.


class MyClass {
    int instanceVar = 42; // Instance variable
}

Static Scope (Class Variables):

Static variables are declared using the static keyword within a class but outside of any method, constructor, or block.

They have class scope, just like instance variables.

However, there is only one copy of a static variable shared among all instances of the class.


class MyClass {
    static int staticVar = 42; // Static variable
}

Block Scope (Local Blocks):

Java allows you to create local blocks within methods, constructors, or other blocks.

Variables declared within these local blocks have scope limited to the block itself.


void myMethod() {
    int localVar = 42;

    {
        int blockVar = 10;
        System.out.println(localVar); // Accessible
        System.out.println(blockVar); // Accessible
    }

    System.out.println(localVar); // Accessible
    // System.out.println(blockVar); // Error: blockVar is not accessible here
}

Remember that the principle of variable scope is vital for preventing naming conflicts, understanding where variables are accessible, and managing memory efficiently in your Java programs.
Conclusion
In this blog post, we've embarked on a journey into the core concepts of Java programming. We've explored conditional statements, loops, methods, logical operators, and variable scope, all of which are foundational elements of Java development. Understanding these fundamentals is crucial as they provide the building blocks for writing organized, efficient, and maintainable Java code.
As you continue your Java programming journey, these concepts will serve as a solid foundation upon which you can build more complex applications. Whether you're a beginner taking your first steps into the world of Java or an experienced developer looking to refresh your knowledge, mastering these fundamentals is a vital step towards becoming a proficient Java programmer.
Keep practicing, exploring, and expanding your Java skills, and remember that each day brings us closer to becoming accomplished Java developers. Join me again tomorrow as we dive into the fascinating world of arrays, another essential component of Java programming. Until then, happy coding!



Day 2: First Java Program
Arun Kumar — Fri, 22 Sep 2023 17:00:34 GMT

Types of Programming Language

Procedural
  Contains a systematic order of statements, functions and commands to complete a task

Functional
  Used in situations where we have to perform lots of different operations on the same set of data, like ML.

Object Oriented
  Object-oriented programming centers around objects, which are instances of classes that encapsulate both data (attributes) and behaviors (methods).


Static vs Dynamic




Aspect Static Languages Dynamic Languages



Early Error Detection Offer early error detection This may lead to runtime errors related to type mismatches

Performance Better performance Provide flexibility

Type Definitions Require stricter type definitions Offer flexibility

Common Languages Java, C++, Swift Python, JavaScript, Ruby

Selection Criteria Project's requirements and developer preferences Project's requirements and developer preferences


Why Java?
Java is an excellent choice for learning Data Structures and Algorithms (DSA) because it offers strong support for object-oriented programming, which aligns well with DSA concepts, and its robust standard libraries provide a wide range of data structures and algorithms for practice and implementation. Additionally, Java's platform independence allows learners to focus on DSA principles without worrying about low-level system details.
Running Your First Java Programm - Hello, World!
To compile and run a Java file using the command prompt (cmd) on Windows, follow these steps:

Install Java (if not already installed):

Make sure you have Java Development Kit (JDK) installed on your computer. You can download it from the official Oracle website.


Write Your Java Code:

Use a text editor (e.g., Notepad) to write your Java code. Save the file with a ".java" extension. For example, you can create a file named "HelloWorld.java" with the following content:
  




    public class HelloWorld {
        public static void main(String[] args) {
            //Display Hello, World!
            System.out.println("Hello, World!");
        }
    }


Open Command Prompt (cmd):

Press Win + R, type "cmd," and press Enter to open the command prompt.


Navigate to the Directory Containing Your Java File:

Use the cd (change directory) command to navigate to the directory where your Java file is located. For example:



    cd path\to\your\java\file\directory


Compile the Java Program:

Use the javac command to compile your Java source file (replace "HelloWorld.java" with your file's name if different):



    javac HelloWorld.java

    If there are no syntax errors in your code, this will generate a bytecode file named "HelloWorld.class" in the same directory.

Run the Compiled Java Program:

To execute your Java program, use the java command followed by the name of the class containing the main method (without the ".class" extension):



    java HelloWorld

    If everything is set up correctly, you should see the output of your program, which is "Hello, World!" in this case.
That's it! You've compiled and run a Java program using the command prompt. You can now create more complex Java applications and follow the same process to compile and execute them.
Inputs in Java
The Scanner class in Java is a useful utility for reading input from various sources, such as the keyboard (standard input), files, or strings. It is part of the java.util package and provides methods for parsing and tokenizing input. Here's an overview of how to use the Scanner class for input in Java:

Import the Scanner class:
 To use the Scanner class, you need to import it at the beginning of your Java program:
 import java.util.Scanner;


Creating a Scanner object:
 You create a Scanner object to read input from a specific source. The most common source is the keyboard (standard input):
 Scanner input = new Scanner(System.in);

 This creates a Scanner object named input that reads input from the keyboard (System.in).

Reading Input:
 You can use various Scanner methods to read input based on the data type you expect. Here are some common methods:

nextLine(): Reads a line of text (including spaces) as a String.

nextInt(): Reads the next integer.

nextDouble(): Reads the next double-precision floating-point number.

nextBoolean(): Reads the next boolean value (true or false).

next().charAt(0): Reads the next char value.

next(): Reads individual words.
  Example:
  System.out.print("Enter your name: ");
  String name = input.nextLine();

  System.out.print("Enter your age: ");
  int age = input.nextInt();




Closing the Scanner:
 It's a good practice to close the Scanner when you're done with it to release any system resources it might be holding:
 input.close();

 However, in most simple console applications, it's not strictly necessary since System.in will still be open. But it's essential when dealing with other input sources like files.


Data Types in Java

Primitive Data Types (8):

byte: 1 byte, -128 to 127

short: 2 bytes, -32,768 to 32,767

int: 4 bytes, -2^31 to 2^31-1

long: 8 bytes, -2^63 to 2^63-1

float: 4 bytes, 7 decimal digits

double: 8 bytes, 15 decimal digits

char: 2 bytes, Unicode character

boolean: true or false



Reference Data Types:

Objects and references to objects.

String, Arrays, Custom Classes.



Wrapper Classes:

Convert primitives to objects.

E.g., Integer, Double, Boolean.



Casting:

Implicit (e.g., int to double).

Explicit (e.g., (int) 3.14).



Literals:

Constants: 1, 3.14, 'A', true.

Scientific Notation: 1.23e-4.



Type Conversion:

Widening (Implicit): Smaller to larger data type.

Narrowing (Explicit): Larger to smaller data type (may lose data).



String Data Type:

Sequence of characters.

"Hello, World!".

Concatenation with +.



Arrays:

Ordered collection of elements.

E.g., int[] numbers = {1, 2, 3};.



Enum Types:

User-defined data types with a fixed set of constants.

E.g., enum Days {MON, TUE, WED}.



Constants:

final keyword to create constants.

E.g., final double PI = 3.14.



Default Values:

Primitives: 0 (or false for boolean).

References: null.



Type Inference (Java 10+):

var keyword for local variables.

E.g., var num = 42;.




Remember that choosing the right data type is crucial for efficient memory usage and accurate data representation in your Java programs.
Type Casting
In Java, there are two main types of type casting: implicit casting (widening) and explicit casting (narrowing).
Implicit Casting (Widening):

Implicit casting occurs automatically when you assign a value of a smaller data type to a variable of a larger data type.

It's safe because there is no risk of data loss or loss of precision.


int intValue = 42;
double doubleValue = intValue; // Implicit casting from int to double

Explicit Casting (Narrowing):

Explicit casting is required when you want to convert a value of a larger data type to a smaller data type.

It may result in data loss or loss of precision, so you need to use a cast operator.


double doubleValue = 3.14;
int intValue = (int) doubleValue; // Explicit casting from double to int

Conclusion
In this insightful journey through the foundational concepts of Java programming, we've explored the various facets that make Java one of the most popular and versatile programming languages. From understanding the different types of programming languages to running our very first Java program, delving into input handling with the Scanner class, and comprehending the nuances of data types and type casting, we've laid a strong foundation for our coding endeavors.
Java, known for its robust support for object-oriented programming, is an ideal choice for learning Data Structures and Algorithms (DSA). It provides a seamless alignment between DSA concepts and object-oriented principles, allowing us to dive deeper into these critical areas of computer science.
As we continue this learning journey, we'll explore more intricate topics, build sophisticated applications, and embark on exciting coding challenges.
Stay tuned for the next chapter in our learning adventure, where we'll delve deeper into Java, tackle more advanced programming concepts, and work towards becoming proficient developers. Until then, happy coding!



Day 1: Mastering Git and GitHub
Arun Kumar — Thu, 21 Sep 2023 19:13:20 GMT

Introduction
Welcome to the world of version control and collaborative development! Git and GitHub have revolutionized the way we manage code, collaborate with teams, and track changes in software projects. In this comprehensive guide, I will take you on an in-depth journey through the fundamental concepts of Git and GitHub, starting from basic command-line operations to more advanced topics like branching, forking, and pull requests. Whether you're a beginner or looking to deepen your Git knowledge, this guide has you covered.
Developer Journey

Learn to Code --- Attend Events --- Participate in Hackathon --- Volunteer --- Freelance --- Apply for developer Job
Learn to Code --- Post your Own Projects --- Contribute to Open Source --- Internship --- Apply for developer Job

Section 1: Basic CMD Commands
Let's begin with the fundamentals of command-line operations on a Windows system. These commands are essential for navigating your file system and managing files and folders effectively.
notepad file-name       # Creates and opens a file in Notepad
code .                  # Opens VS code                                            
cls                     # Clears the screen
cd                      # Change directory
cd ..                   # Move up one level
mkdir                   # Create a new folder
dir                     # List all files in the folder
dir /a                  # Show hidden files
rmdir /s                # Delete a folder with all contents
rmdir                   # Delete an empty folder
echo > filename.ext     # Create new files in the folder
del "filename"          # Delete files
del /f                  # Force delete files
del *.*                 # Delete all files in the current folder
del "word*"             # Delete files whose names start with "word"
del "*word"             # Delete files that end with your specified word

Section 2: Git Commands (Local Repositories)
Now, let's dive into the essential Git commands for managing your local codebase effectively.
git init                # Initialize a Git repository
git add                 # Move a file to the staging area
git commit -m "message" # Commit changes to the local repository
git status              # Show the current status of updates
git log                 # Display commitment messages
git diff "file"         # Display differences (changes) made to a specific file
git checkout "file"     # Revert any local changes made to that file

Section 3: Pushing to GitHub

Working Directory ---> Staging Area ---> Local Repository ---> Remote Repository

Learn how to push your local repository to GitHub, making your code accessible to others.
git remote add origin https://github.com/Username/RepositoryName.git
git branch -M main
git push -u origin main

Section 4: Creating a New Repository on GitHub
Explore how to create a new GitHub repository from the command line. It involves setting up a central location to store, manage, and collaborate on software development or other digital content. Users can define repository details, configure access controls, and initialize the repository with their project files, enabling efficient version control and collaboration with teammates or the open-source community.
echo "# Test" >> README.mEd
git init
git add README.md
git commit -m "first commit"
git remote add origin https://github.com/Username/RepositoryName.git
git push -u origin main

Section 5: .gitignore
Use a .gitignore file to specify files and directories to exclude from Git commits, keeping your repository clean and secure.
# .gitignore content
*.log
secret.txt
# and more...

Section 6: Cloning a Repository
Discover how to clone a remote repository to your local machine for development.
git clone url

Section 7: Branching and Merging
Understand the essential concepts of branching and merging in Git.
What is a Branch? In Git, a branch is a separate line of development within a repository. It allows you to work on features, bug fixes, or experiments without affecting the main codebase (usually referred to as the "master" or "main" branch).
What is Merging? Merging is the process of combining changes from one branch into another. You typically merge a feature branch back into the main branch (e.g., "master" or "main") to incorporate your changes into the main codebase.
# Creating a new branch
git branch feature-branch

# Switching to a branch
git checkout feature-branch

# Creating and switching to a new branch
git checkout -b feature-branch

# Merging branches
git checkout main
git merge feature-branch

# Deleting a branch
git branch -d feature-branch

Section 8: Forking and Pull Requests
What is a Fork? Forking is the process of creating a copy of a repository (usually a public one) from one user's account or organization to another user's account or organization. The new copy is entirely separate from the original but starts with the same codebase.
What are Pull Requests? In collaborative workflows, such as those used on platforms like GitHub or GitLab, developers often create pull requests or merge requests to propose and discuss changes before merging them into the main branch. This allows for code review and collaboration.
Collaborate effectively on open-source projects using forks and pull requests.

Fork a Repository

Make Changes and Create a Pull Request

Collaborate and Review

Merge the Pull Request


Section 9: git pull
Combine fetching and merging in a single step to keep your local repository up to date.
git pull

Section 10: git reset
Learn how to undo commits and reset your repository when necessary.
git reset  #Visible on git log command

Section 11: Expressing Gratitude
As I embark on this thrilling journey of learning, I would like to extend my heartfelt gratitude to two individuals and their exceptional courses that have been guiding lights in my quest for knowledge.
Kunal Kushwaha:
I have been fortunate to follow the enlightening "Java + DSA + Interview Preparation Course" by Kunal Kushwaha, a comprehensive and free playlist available on YouTube. His dedication to making complex concepts accessible and his commitment to the community are truly admirable. Complete Git and GitHub Tutorial.
Dr. Angela Yu:
Another invaluable resource that has been pivotal in my journey is the, "The Complete 2023 Web Development Bootcamp" by Dr. Angela Yu on Udemy. With this course, I have been diving deep into the world of web development, exploring HTML, CSS, JavaScript, Node.js, React, MongoDB, Web3, and DApps. Dr. Angela Yu's course has provided me with not only the knowledge but also the practical skills necessary to become a full-stack web developer. The Complete 2023 Web Development Bootcamp
Thank you once again to Kunal Kushwaha and Dr. Angela Yu for their incredible contributions to the learning community.
Conclusion
In this guide, we've delved into the essential aspects of Git and GitHub, from mastering basic command-line operations to creating repositories, managing branches, and collaborating effectively. Git and GitHub are powerful tools that can enhance your coding experience and teamwork. As you progress, remember the significance of continuous learning and practice.
As you continue your journey in technology and software development, stay curious, share your knowledge, and keep pushing boundaries. Together, we can make remarkable strides in this ever-evolving field. Thank you for being part of this learning adventure, and I look forward to our continued exploration and innovation.
Until then, happy coding!




Day 0: Embarking on My Data Structures and Full Stack Learning Journey
Arun Kumar — Wed, 20 Sep 2023 12:17:13 GMT

Introduction
Hello, dear readers! Welcome to "DSA and Dev Days: Arun's Learning Blog." I'm thrilled to have you here with me as I embark on this exciting journey of learning data structures and full-stack development from scratch. This blog will serve as a chronicle of my daily adventures, triumphs, and challenges as I dive headfirst into the world of programming and technology.
A Little About Myself
Before we dive into the details of my learning journey, let me introduce myself. I'm Arun Kumar, a 2nd-year student at St. Joseph's Institute of Technology, pursuing a Bachelor's degree in Electronics and Communication Engineering (ECE). Despite my non-computer science background, I am deeply passionate about technology and programming.
Why I'm Starting This Blog
You might wonder, why start a blog about my learning journey? Well, the answer is simple: I believe in the power of documentation. Keeping a record of my experiences, progress, and the lessons I learn along the way not only helps me track my growth but also provides valuable insights to others who might be on a similar path.
The Beginning
Today marks Day Zero of my journey. I've set my sights on mastering data structures and full-stack development, and I'm starting from the crack of dawn. As the saying goes, "The journey of a thousand miles begins with a single step," and this blog is that very first step.
My Approach
I plan to blog daily, sharing my thoughts, challenges, and small victories. Each day will bring new challenges, but I'm determined to embrace them as opportunities for growth.
Connect with Me
If you'd like to connect with me and follow my journey on a more personal level, you can find me on LinkedIn here. I'd love to connect with fellow learners, mentors, or anyone passionate about technology.
Conclusion
I'm excited about what lies ahead, and I hope you are too! Whether you're a seasoned developer, a fellow learner, or someone simply curious about the world of programming, I invite you to join me on this exciting journey. Together, we'll explore the fascinating realms of data structures and full-stack development, one day at a time.
Stay tuned for Day One, where I'll share my first experiences and insights gained from day one. Also most importantly I will be sharing the resources which I will be using throughout my Journey. Until then, happy coding!

s_no	name	registration_number	gender	department	no_of_compartment

Aspect	Static Languages	Dynamic Languages
Early Error Detection	Offer early error detection	This may lead to runtime errors related to type mismatches
Performance	Better performance	Provide flexibility
Type Definitions	Require stricter type definitions	Offer flexibility
Common Languages	Java, C++, Swift	Python, JavaScript, Ruby
Selection Criteria	Project's requirements and developer preferences	Project's requirements and developer preferences