SDE - 1

ACID Properties:
ACID stands for Atomicity, Consistency, Isolation, and Durability. These properties are a set of guidelines or principles that ensure reliable and consistent transaction processing in a database management system. Here's a brief explanation of each property:

1. Atomicity: Atomicity refers to the "all-or-nothing" property of a transaction. It ensures that a transaction is treated as a single, indivisible unit of work. Either all the operations within a transaction are successfully completed, or none of them are applied to the database. If any part of the transaction fails, the entire transaction is rolled back, and the database remains unchanged.

2. Consistency: Consistency ensures that a transaction brings the database from one valid state to another. It defines the integrity constraints that must be satisfied before and after a transaction is executed. In other words, a transaction should maintain the overall correctness and validity of the database. If a transaction violates any of the defined constraints, it is rolled back to maintain consistency.

3. Isolation: Isolation ensures that concurrent execution of transactions does not interfere with each other. Each transaction should be executed in isolation, as if it were the only transaction running on the system. Isolation prevents issues such as dirty reads (reading uncommitted data), non-repeatable reads (reading different data within the same transaction), and phantom reads (seeing new rows inserted by other transactions). Various isolation levels, such as Read Uncommitted, Read Committed, Repeatable Read, and Serializable, provide different levels of isolation.

4. Durability: Durability guarantees that once a transaction is committed and the changes are written to the database, they are permanent and will survive any subsequent system failures such as power outages or crashes. The changes become a permanent part of the database, even if the system crashes or restarts. This property is usually achieved through transaction logging and backup mechanisms.

Foreign Key:
In the context of databases, a foreign key is a column or a set of columns in a table that refers to the primary key or a unique key of another table. It establishes a relationship between two tables, known as a parent-child relationship. The foreign key in the child table references the primary key of the parent table, enforcing referential integrity.

The foreign key constraint ensures that the values in the foreign key column(s) of the child table match the values in the referenced column(s) of the parent table. It maintains the integrity and consistency of data across related tables. The foreign key constraint can prevent actions that would violate the relationship, such as inserting a value that doesn't exist in the referenced table or deleting a row that is referenced by another table.

SQL Queries on JOINS:
SQL JOINS allow you to combine rows from two or more tables based on a related column between them. Here are a few common SQL queries involving JOIN operations:

1. INNER JOIN: Returns only the rows that have matching values in both tables.
```sql
SELECT * FROM table1
INNER JOIN table2 ON table1.column = table2.column;
```

2. LEFT JOIN: Returns all rows from the left (first) table and the matching rows from the right (second) table. If there are no matches, NULL values are returned for the right table.
```sql
SELECT * FROM table1
LEFT JOIN table2 ON table1.column = table2.column;
```

3. RIGHT JOIN: Returns all rows from the right (second) table and the matching rows from the left (first) table. If there are no matches, NULL values are returned for the left table.
```sql
SELECT * FROM table1
RIGHT JOIN table2 ON table1.column = table2.column;
```

4. FULL OUTER JOIN: Returns all rows from both tables, including unmatched rows from both tables. If there is no match, NULL values are returned for the unmatched side.
```sql
SELECT * FROM table1
FULL OUTER JOIN table2 ON table1.column = table2.column;
```

5. CROSS JOIN: Returns the Cartesian product of both tables, which means each row from the first table is combined with each row from the second table.
```sql
SELECT * FROM table1
CROSS JOIN table2;
```

These are just a few examples of SQL queries involving JOIN operations. Depending on your specific requirements, you can modify the columns selected, add conditions, and perform other operations to retrieve the desired data from your tables.

The pillars of Object-Oriented Programming (OOP) are a set of fundamental principles that guide the design and implementation of object-oriented systems. These principles help in creating modular, reusable, and maintainable code. There are four main pillars of OOP:

1. Encapsulation: Encapsulation is the process of bundling data and methods that operate on that data into a single unit called an object. It allows the object to control its internal state and provides an interface for interacting with the object. Encapsulation promotes data hiding, which means that the internal state of an object is not accessible to the outside world. Instead, access to the object's data is controlled through well-defined methods or properties. This helps in achieving data abstraction, improves security, and allows for easier maintenance and modification of code.

2. Inheritance: Inheritance is a mechanism that allows objects to inherit properties and behaviours from other objects. It enables the creation of a hierarchical relationship between classes, where a subclass (derived class) can inherit the characteristics of a superclass (base class). Inheritance promotes code reuse, as common attributes and methods can be defined in a superclass and inherited by multiple subclasses. It facilitates the creation of specialized classes that add or override functionality while maintaining the common features defined in the superclass. Inheritance also supports the concept of polymorphism, where objects of different classes can be treated as objects of a common superclass.

3. Polymorphism: Polymorphism means "many forms" and refers to the ability of objects to exhibit different behaviours based on their data type or the context in which they are used. Polymorphism allows objects of different classes to be treated as objects of a common superclass, providing a way to write code that can work with objects of different types without knowing their specific classes. This is achieved through method overriding and method overloading. Method overriding allows a subclass to provide a different implementation of a method that is already defined in its superclass. Method overloading allows multiple methods with the same name but different parameters to be defined in a class. Polymorphism promotes code flexibility, extensibility, and modularity.

4. Abstraction: Abstraction is the process of simplifying complex systems by breaking them down into smaller, more manageable units. It involves identifying the essential features and behaviours of an object or a system and representing them clearly and concisely. Abstraction allows for the creation of abstract classes and interfaces that define common characteristics and behaviours without providing specific implementation details. It focuses on what an object does rather than how it does it. Abstraction helps reduce complexity, promote code reusability, and facilitate the maintenance and evolution of software systems.

These four pillars—encapsulation, inheritance, polymorphism, and abstraction—provide a solid foundation for designing and implementing object-oriented systems. They promote code organization, reusability, and flexibility, making it easier to develop and maintain complex software applications.

Tester: A tester is someone who performs software testing to find flaws. The tester additionally examines several features of the software. The tester is unaware of the software development process. A tester examines the software to see whether it contains any faults or flaws.

Ad hoc testing is a type of unstructured or informal software testing that seeks to interrupt the testing process in order to uncover potential defects or errors as soon as feasible. Ad hoc testing is a type of testing that is done at random and is usually an unplanned activity that does not use any documentation or test design methodologies to construct test cases.

1. I started with understanding the problem in depth first knowing what type of data are these linked list holding and if they are already sorted etc.
2. I gave a bootstrap approach to iterative compare and push the nodes to a new array.
3. After discussing on the possible solution finally came up with an optimised approach (Reversing lists approach)

Tip 1: Practise setTimeout and setInterval-based questions, since they are the most frequently asked questions
Tip 2: Understand the event loop mechanism