Swayam Blog

Basic Overview of DSA

Sun, 05 Jan 2025 00:00:00 +0000

Arrays: Linear data structure with a fixed size, allowing random access to elements.
- Best for: Static datasets with frequent element access.
- Complexity:
  - Access: O(1)
  - Search: O(n)
  - Insertion/Deletion: O(n) Array
Linked Lists: Linear structure of nodes, where each node points to the next.
- Types: Singly, Doubly, Circular.
- Best for: Dynamic datasets with frequent insertions/deletions.
- Complexity:
  - Access/Search: O(n)
  - Insertion/Deletion: O(1) (at head/tail with pointer)
Hash Maps (or Hash Tables): Key-value pair storage with a hash function.
- Best for: Quick lookup and insertion.
- Complexity:
  - Average: O(1)
  - Worst-case: O(n)(due to hash collisions)
Stacks: LIFO (Last In, First Out) structure.
- Operations: Push, Pop, Peek.
- Best for: Recursive problems, expression evaluation.
- Complexity:
  - Push/Pop/Peek: O(1)
Queues: FIFO (First In, First Out) structure.
- Variants: Circular Queue, Deque, Priority Queue.
- Best for: Scheduling, buffering.
- Complexity:
  - Enqueue/Dequeue: O(1)
Trees: Hierarchical structure with nodes (root, parent, children).
- Types: Binary, Binary Search Tree (BST), AVL, Red-Black, etc.
- Best for: Hierarchical data, searching/sorting.
- Complexity:
  - Search/Insert/Delete: O(h), where h is the tree height.
  - Balanced trees maintain h=O(logn).
Graphs: Collection of nodes (vertices) connected by edges.
- Types: Directed, Undirected, Weighted, Unweighted.
- Representation: Adjacency Matrix/List.
- Best for: Network problems, pathfinding.
- Algorithms: DFS, BFS, Dijkstra’s, Prim’s, Kruskal’s.

Array

Sun, 02 Feb 2025 00:00:00 +0000

1. Sorting Algorithms

Sorting arranges elements in a specific order (ascending or descending).

Bubble Sort – Repeatedly swaps adjacent elements if they are in the wrong order.
Selection Sort – Selects the smallest/largest element and places it in order.
Insertion Sort – Builds the sorted array one element at a time.
Merge Sort – Uses the divide-and-conquer technique to sort.
Quick Sort – Selects a pivot and partitions elements around it.
Heap Sort – Uses a binary heap to sort efficiently.
Radix Sort – Sorts numbers digit by digit.
Counting Sort – Counts occurrences of elements (used for small range values).
Sorting

2. Searching Algorithms

Used to find an element in an array.

Linear Search – Searches sequentially from start to end.
Binary Search – Searches in a sorted array by dividing it into halves.
Jump Search – Jumps ahead by fixed steps and performs a linear search.
Interpolation Search – Improved binary search that assumes a uniform distribution of values.
Exponential Search – Useful for searching in unbounded or infinite-sized arrays.
Searching

3. Two-Pointer Techniques

Used for problems requiring element comparison or sum-based conditions.

Two-Sum Problem – Find two numbers in an array that add up to a target.
Three-Sum Problem – Find three numbers that sum to a target.
Dutch National Flag Algorithm – Used for sorting arrays with three types of elements (e.g., 0s, 1s, and 2s).

4. Divide and Conquer Algorithms

Breaks the array into smaller parts, solves each, and merges results.

Merge Sort – Recursively divides and merges sorted parts.
Quick Sort – Uses a pivot to partition the array.
Binary Search – Recursively searches a sorted array.

5. Greedy Algorithms

Make the best choice at each step to find an optimal solution.

Activity Selection Problem – Select maximum non-overlapping activities.
Interval Scheduling – Schedule tasks with given constraints.

6. Sliding Window Algorithms

Efficiently finds a subarray or subset in an array.

Fixed Window Size – Finds max/min sum of a subarray of size k.
Variable Window Size – Used for finding the smallest subarray with a sum ≥ target.
Maximum Sum Subarray (Kadane’s Algorithm) – Finds the largest sum of contiguous subarrays.

7. Hashing-Based Algorithms

Use hash tables for quick lookups and frequency counting.

Two Sum (Hash Map Approach) – Stores values and looks for complements.
Subarray with Zero Sum – Uses hashing to detect if a sum has occurred before.
Longest Consecutive Sequence – Uses a hash set to track elements.

8. Dynamic Programming (DP) Algorithms

Used for optimization problems.

Longest Increasing Subsequence (LIS) – Finds the longest increasing sequence.
0/1 Knapsack Problem – Determines the best way to pack items into a knapsack.
Subset Sum Problem – Finds if a subset with a given sum exists.
Coin Change Problem – Finds the minimum number of coins for a given amount.

9. Matrix Manipulation Algorithms

Arrays can be represented as matrices for solving problems.

Rotate a Matrix (90 degrees, 180 degrees, etc.)
Spiral Order Traversal – Traverse a 2D array in a spiral.
Flood Fill Algorithm – Used in image processing (similar to DFS/BFS).
Pathfinding (Dijkstra’s, Floyd-Warshall, etc.) – Find shortest paths in graphs represented as matrices.

10. Bit Manipulation Algorithms

Use bitwise operations to solve problems efficiently.

Finding the Single Non-Repeating Element (XOR Trick)
Counting Set Bits (Brian Kernighan’s Algorithm)
Subsets using Bitmasking – Generate all subsets using bitwise operations.

Searching

Sun, 02 Feb 2025 00:00:00 +0000

1. Linear Search

Approach: Sequentially checks each element in the array.
Time Complexity:
- Best: O(1)
- Worst: O(n)
- Average: O(n)
Space Complexity: O(1)

2. Binary Search (For Sorted Arrays Only)

Approach: Repeatedly divides the array in half and searches in the relevant half.
Time Complexity:
- Best: O(1)
- Worst: O(log n)
- Average: O(log n)
Space Complexity:
- O(1) (Iterative)
- O(log n) (Recursive, due to function call stack)

3. Jump Search (For Sorted Arrays)

Approach: Jumps ahead by a block size (√n) and does a linear search within that block.
Time Complexity:
- Best: O(1)
- Worst: O(√n)
- Average: O(√n)
Space Complexity: O(1)

4. Interpolation Search (For Uniformly Distributed Sorted Data)

Approach: Uses the formula to estimate the probable position of the target. $$ pos=left+ \frac {(target−arr[left])×(right−left)}{(arr[right]−arr[left])} $$

Time Complexity:
- Best: O(1)
- Worst: O(n) (when data is skewed)
- Average: O(log log n)
Space Complexity: O(1)

5. Exponential Search (For Unbounded Sorted Arrays)

Approach: Starts with small steps (1, 2, 4, 8…) to find a suitable range, then uses Binary Search.
Time Complexity:
- Best: O(1)
- Worst: O(log n)
- Average: O(log n)
Space Complexity: O(1)

6. Fibonacci Search (For Sorted Arrays)

Approach: Uses Fibonacci numbers instead of dividing by 2 like Binary Search.
Time Complexity:
- Best: O(1)
- Worst: O(log n)
- Average: O(log n)
Space Complexity: O(1)

Comparison Table

Algorithm	Best Case	Worst Case	Average Case	Space Complexity	Sorted Array Required?
Linear Search	O(1)	O(n)	O(n)	O(1)	No
Binary Search	O(1)	O(log n)	O(log n)	O(1) / O(log n)	Yes
Jump Search	O(1)	O(√n)	O(√n)	O(1)	Yes
Interpolation Search	O(1)	O(n)	O(log log n)	O(1)	Yes
Exponential Search	O(1)	O(log n)	O(log n)	O(1)	Yes
Fibonacci Search	O(1)	O(log n)	O(log n)	O(1)	Yes

Sorting

Sat, 01 Feb 2025 00:00:00 +0000

Sort

1. Comparison-Based Sorting

These algorithms compare elements to determine their order.

a. Bubble Sort

Repeatedly swaps adjacent elements if they are in the wrong order.
Time Complexity: O(n²)
Space Complexity: O(1)

b. Selection Sort

Finds the smallest element and places it in the correct position.
Time Complexity: O(n²)
Space Complexity: O(1)

c. Insertion Sort

Picks one element at a time and places it in its correct position.
Time Complexity: O(n²)
Space Complexity: O(1)
Efficient for small or nearly sorted data.

d. Merge Sort (Divide and Conquer)

Divides the array into halves, sorts them, and merges them.
Time Complexity: O(n log n)
Space Complexity: O(n)

e. Quick Sort (Divide and Conquer)

Picks a pivot, partitions the array, and sorts recursively.
Time Complexity: O(n log n) (Best & Avg), O(n²) (Worst)
Space Complexity: O(log n) (due to recursion)

f. Heap Sort

Converts the array into a heap and extracts elements in order.
Time Complexity: O(n log n)
Space Complexity: O(1)

g. Shell Sort

Variation of insertion sort that sorts elements at a gap.
Time Complexity: O(n log n) (Best), O(n²) (Worst)
Space Complexity: O(1)

2. Non-Comparison-Based Sorting

These algorithms do not compare elements directly.

a. Counting Sort

Counts occurrences of elements and places them in sorted order.
Time Complexity: O(n + k) (k is range of numbers)
Space Complexity: O(k)
Works only for integer values with a known range.

b. Radix Sort

Sorts numbers digit by digit using counting sort as a subroutine.
Time Complexity: O(nk) (k is number of digits)
Space Complexity: O(n + k)
Works well for fixed-size numbers like integers.

c. Bucket Sort

Divides elements into buckets and sorts each bucket individually.
Time Complexity: O(n + k) (depends on bucket distribution)
Space Complexity: O(n + k)
Works well for uniformly distributed data.

3. Hybrid Sorting Algorithms

These algorithms combine multiple sorting techniques.

a. Tim Sort

Combination of Merge Sort and Insertion Sort.
Used in Python’s built-in sorting (sorted() and .sort()).
Time Complexity: O(n log n)
Space Complexity: O(n)

b. Introsort

Hybrid of Quick Sort, Heap Sort, and Insertion Sort.
Used in C++ STL sort().
Time Complexity: O(n log n)
Space Complexity: O(log n)

Choosing the Right Sorting Algorithm

Algorithm	Best Case	Worst Case	Average Case	Space Complexity	Stable?
Bubble Sort	O(n)	O(n²)	O(n²)	O(1)	Yes
Selection Sort	O(n²)	O(n²)	O(n²)	O(1)	No
Insertion Sort	O(n)	O(n²)	O(n²)	O(1)	Yes
Merge Sort	O(n log n)	O(n log n)	O(n log n)	O(n)	Yes
Quick Sort	O(n log n)	O(n²)	O(n log n)	O(log n)	No
Heap Sort	O(n log n)	O(n log n)	O(n log n)	O(1)	No
Counting Sort	O(n + k)	O(n + k)	O(n + k)	O(k)	Yes
Radix Sort	O(nk)	O(nk)	O(nk)	O(n + k)	Yes
Bucket Sort	O(n + k)	O(n²)	O(n)	O(n + k)	Yes
Tim Sort	O(n)	O(n log n)	O(n log n)	O(n)	Yes

My Road map for cyber security

Sun, 26 Jan 2025 00:00:00 +0000

Month 1-3: Foundations

Networking Fundamentals

Learn TCP/IP, OSI model, and common protocols
Study network topologies and architecture
Practice with tools like Wireshark for packet analysis

Linux Essentials

Install a Linux distribution (e.g., Ubuntu or Kali Linux)
Master basic command-line operations
Learn file system structure and permissions

Programming Basics

Start with Python for cybersecurity
Learn basic scripting for automation
Practice with simple security-related coding projects

Month 4-6: Core Security Concepts

Information Security Principles

Study CIA triad (Confidentiality, Integrity, Availability)
Learn about access control models and authentication methods
Understand basic cryptography concepts

Web Application Security

Learn common web vulnerabilities (e.g., OWASP Top 10)
Practice identifying and exploiting basic web app flaws
Study secure coding practices

Network Security

Understand firewalls, IDS/IPS, and VPNs
Learn about common network attacks and defenses
Practice configuring basic network security tools

Month 7-9: Specialization and Practical Skills

Ethical Hacking Basics

Study penetration testing methodologies
Learn about reconnaissance and scanning techniques
Practice with vulnerable virtual machines (e.g., DVWA, Metasploitable)

Incident Response and Forensics

Understand the incident response lifecycle
Learn basic digital forensics techniques
Practice with forensic tools like Autopsy or EnCase

Cloud Security

Study cloud service models (IaaS, PaaS, SaaS)
Learn about shared responsibility models
Practice securing cloud environments (e.g., AWS, Azure)

Month 10-12: Advanced Topics and Career Preparation

Threat Intelligence

Learn about threat actors and their motivations
Study threat intelligence platforms and feeds
Practice creating threat intelligence reports

Governance, Risk, and Compliance

Understand common security frameworks (e.g., NIST, ISO 27001)
Learn about risk assessment methodologies
Study relevant regulations (e.g., GDPR, HIPAA)

Career Development

Build a professional network (join cybersecurity communities, attend webinars)
Create a portfolio of projects and write-ups
Prepare for entry-level cybersecurity certifications (e.g., CompTIA Security+)

Throughout the year:

Stay updated with cybersecurity news and trends
Participate in Capture The Flag (CTF) competitions
Contribute to open-source security projects
Practice ethical hacking on platforms like Hack-The-Box or Try-Hack-Me

Network

Thu, 02 Jan 2025 00:00:00 +0000

What is computer networking?

Networking, or computer networking, is the process of connecting two or more computing devices, such as desktop computers, mobile devices, routers or applications, to enable the transmission and exchange of information and resources.

Networked devices rely on communications protocols—rules that describe how to transmit or exchange data across a network—to share information over physical or wireless connections.

Key networking components and devices

Before we delve into more complex networking topics, it’s important to understand fundamental networking components, including:

IP address: An IP address is the unique number assigned to every network device in an Internet Protocol (IP) network; each IP address identifies the device’s host network and its location on the network. When one device sends data to another, the data includes a “header” that includes the IP addresses of both the sending and receiving devices.
Nodes: A node is a network connection point that can receive, send, create or store data. It’s essentially any network device—computers, printers, modems, bridges or switches—that can recognize, process and transmit information to another network node. Each node requires some form of identification (such an IP or MAC address) to receive access to the network.
Routers: A router is a physical or virtual device that sends data “packets” between networks. Routers analyze the data within packets to determine the best transmission path and use sophisticated routing algorithms to forward data packets until they reach their destination node.
Switches: A switch is a device that connects network devices and manages node-to-node communication across a network, making sure that data packets reach their intended destination. Unlike routers, which send information between networks, switches send information between nodes within a network.

Consequently, “switching” refers to how data is transferred between devices on a network. Networks rely on three main types of switching:
- Circuit switching establishes a dedicated data communication path between nodes in a network, so no other traffic can traverse the same path. Circuit switching sees to it that full bandwidth is available during every transmission.
- Message switching sends whole messages from the source node to the destination node, with the message traveling from switch to switch until it reaches the destination.
- Packet switching involves breaking down data into independent components to make data transmission less demanding of network resources. With packet switching, packets—instead of entire data streams—travel through the network to their end destination.
Ports: A port indicates a specific connection between network devices, with each port identified by a number. If an IP address is analogous to a hotel address, then ports are the suites and room numbers. Computers use port numbers to determine which application, service or process should receive which messages.
Gateways: Gateways are hardware devices that facilitate communication between two different networks. Routers, firewalls and other gateway devices use rate converters, protocol translators and other technologies to make inter-network communication possible between otherwise incompatible devices.

Network types by communication type

Computing networks can transmit data using a range of transmission dynamics, including: Multipoint networks

In a multipoint network,

multiple devices share channel capacity and network links.

Point-to-point networks

Network devices establish a direct node-to-node link to transmit data.

Broadcast networks

On broadcast networks, several interested “parties” (devices) can receive one-way transmissions from a single sending device. Television stations are a great example of broadcast networks.

Virtual private networks (VPNs)

A VPN is a secure, point-to-point connection between two network endpoints. It establishes an encrypted channel that keeps a user’s identity and access credentials, as well as any data transferred, inaccessible to hackers.

Network communication protocols

Whether it’s the internet protocol (IP) suite, Ethernet, wireless LAN (WLAN) or cellular communication standards, all computer networks follow communication protocols—sets of rules that every node on the network must follow in order to share and receive data. Protocols also rely on gateways to enable incompatible devices to communicate (a Windows computer attempting to access Linux servers, for instance)

Many modern networks run on TCP/IP models, which include four network layers.

Network access layer. Also called the data link layer or the physical layer, the network access layer of a TCP/IP network includes the network infrastructure (hardware and software components) necessary for interfacing with the network medium. It handles physical data transmission—using Ethernet and protocols such as the address resolution protocol (ARP)—between devices on the same network.
Internet layer. The internet layer is responsible for logical addressing, routing and packet forwarding. It primarily relies on the IP protocol and the Internet Control Message Protocol (ICMP), which manages addressing and routing of packets across different networks.
Transport layer. The TCP/IP transport layer enables data transfer between upper and lower layers of the network. Using TCP and UDP protocols, it also provides mechanisms for error checking and flow control.

TCP is a connection-based protocol that is generally slower but more reliable than UDP. UDP is a connectionless protocol that is faster than TCP but does not provide guaranteed transfer. UDP protocols facilitate packet transmission for time-sensitive apps (such as video streaming and gaming platforms) and DNS lookups.**
Application layer. TCP/IP’s application layer uses HTTP, FTP, Post Office Protocol 3 (POP3), SMTP, domain name system (DNS) and SSH protocols to provide network services directly to applications. It also manages all the protocols that support user applications

OSI Model

The Open Systems Interconnection (OSI) model—also called the OSI reference model—is a conceptual model that divides network communication and interoperability into seven abstract layers. It provides a standardized model that enables different applications, computer systems and networks to communicate.

The OSI model emerged as a solution to communication incompatibilities between the diverse array of networking protocols in use around the turn of the century. The layers of OSI gave developers and engineers a framework for building interoperable hardware and software across networks by providing a categorical approach to networking.

At each layer of the stack—typically shown in reverse order to illustrate how data moves through a network—the OSI model provides guidelines and criteria for network components and their unique computing functions.

The layers are:

Layer 7: The application layer initiates communication with the network, including the protocols and data manipulation processes that convert computer-readable network data into user-readable responses.
Layer 6: The presentation layer prepares data for the application layer, including data translation, compression and encryption.
Layer 5: The session layer initiates and terminates connections between two devices interacting on the network, making sure that resources are neither overused nor underutilized.
Layer 4: The transport layer transmits end-to-end data between two devices interacting on the network, making sure that data isn’t lost, misconfigured or corrupted.
Layer 3: The network layer handles data addressing, routing and forwarding processes for devices interacting across different networks. If the devices are on the same network, they don’t need the network layer to interact.
Layer 2: Unlike the network layer, the data link layer manages data routing between two interacting devices on the same network.
Layer 1: The physical layer comprises the physical assets, like routers and USB cables, that convert data into strings of 1s and 0s for transmission to higher layers.

source1 source2 source3

Cyber Security

Sat, 28 Dec 2024 00:00:00 +0000

Hi guys lets Start our cyber security journey is From today

In this Journey we are going to learn about the fundamentals of cyber security

Programming for Cybersecurity
Cybersecurity Basics
Networking Fundamentals
Operating Systems Security
Cryptography
Penetration Testing

I am thing of starting form c and c++ as they are low level languages and help me with my college also and in cyberspace also.

I am thing of complete the basic in 12 Months so that i can get some internship and grow my self.

Lets start this Journey of mine form 1 Jan 2025 This is my new Year Resolution that I will Cyber Security internship by the end of this year.

I am think of Posting my work weekly here as i know no body is reading this this but it helps me feel motivated to do the work

Thanks

My First blog

Fri, 06 Dec 2024 00:00:00 +0000

This is my First blog to help me log my life throughout my college life

So lets being

fuck you

About Me

Thu, 05 Dec 2024 00:00:00 +0000

Hi, I’m Swayam

Welcome to my little corner of the internet! I’m a passionate learner and creator with a love for all things science, technology, and creativity. From exploring the mysteries of astrophysics to diving into the logic of mathematics and robotics, I’m captivated by how the universe works and how we can shape it through innovation.

As a developer, I enjoy programming and building applications. Currently, I’m developing a project that combines Flask for backend development with React on the frontend, bridging technology and user experience seamlessly.

Outside of coding, I’m an avid reader, a fan of anime, and a movie enthusiast. I also enjoy music and the art of storytelling, finding inspiration in every form of creativity.

Curiosity fuels me, and I’m always looking to expand my knowledge, whether it’s through books, new projects, or exploring the vast realms of science and technology.

Let’s connect and explore the infinite possibilities together!