InterviewPrep

Welcome to my interview prep repo. This repo will (eventually - it's still in progress) contain everything I use for fundamental interview prep for technical software interviews.

This repo contains the general interview topics: data structures, algorithms, time complexity, etc. Further, it contains more tailored material, such as OOP and design, software engineering practices and processes, and more technical topics like databases, OS, networks, and AI. Lastly, it contains some solutions to Cracking the Coding Interview and Leetcode.

Table of Contents

(This ToC is updated as I write out the repo. Eventually I'll even add links for these sections)

Chapter 1: Data Structures

1. Arrays
2. Linked Lists
3. Stacks
4. Queues
5. Trees
   • Binary Trees
   • Binary Search Trees
   • Red Black Trees
   • Heaps and Priority Queues
   • Trie Trees (Prefix Trees)
6. Graphs
7. Sets
8. Hash Tables

Chapter 2: Algorithms

1. Sorting
   • Bubble Sort
   • Selection Sort
   • Insertion Sort
   • Merge Sort
   • Quicksort
   • Radix Sort
   • Heapsort
2. Searching
   • Linear/Sequential Search
   • Binary Search
   • Breadth-First Search
   • Depth-First Search
3. Recursion
4. Dynamic Programming
5. Divide and Conquer
6. Greedy Algorithms
7. Dijkstra's Algorithm

Chapter 3: System Design

TODO

Chapter 4: Programming Languages

In progress

Cracking the Coding Interview Solutions

1. Arrays and Strings (Ch. 1)
2. Linked Lists (Ch. 2)
3. Stacks and Queues (Ch. 3)
4. Trees and Graphs (Ch. 4)
5. Recursion and Dynamic Programming (Ch. 8)

Practice Problems

This directory is Leetcode practice problems. Some are prepended with a company name - this was likely gotten via searching for example questions for this company.

Roadmap (in progress)

Below is tentative plan for the repo and not really part of the README as it matters to you. This is just a dump of potential topics and a rough outline of how they'd be organized.

Interview Prep:

Chapter 1: Data Structures
    For each data structure, give the following:
        Overview/Description
            Time complexity
            Space complexity
    I: Arrays
    II: List
    III: Linked List
    IV: Set
    V: Stack
    VI: Queue
    VII: Heap
    VIII: Hash table
    IX: Trees
    X: Graphs

Chapter 2: Algorithms
    I: Sorting
        Bubble
        Insertion
        Selection
        Quick sort
        Merge sort
        Heap sort
        Radix sort
    II: Graph algorithms
        DFS
        BFS
        Topo
        Dijkstra's
        Bellman-Ford
        Prim's
        Kruskal's
        (other algos we talked about in 577)
    III: Dynamic Programming
    IV: Combinatorics
    V: P/NP
    VI: Greedy algorithms
    VII: AI algorithms

Chapter 3: Programming Languages and Methods
    Run through different languages and how they stack up in the following things:
        How it compiles/is interpreted
        How it runs
        Static vs. dynamic
        Strong vs. weakly typed
        Performance: strengths, weaknesses

Chapter 4: Nitty Gritty Computing
    Memory, CPU, storage, etc. and how it all works together
    Databases
    Networking
    Operating systems

Chapter 5: Software Engineering
    Processes: Agile, scrum, kanban
    Development:
        DevOps
        Test-driven development
    Tests:
        How to write proper unit tests
        What unit tests should cover
        Different types of tests: unit, integration, smoke, regression

Chapter 6: Cracking the Coding Interview

Lastly, if you made it this far, this is some ASCII art I made that I thought was cool and didn't have anywhere else to put.

  ////////        ///        /////          ///
     //        ///  ///      //  //      ///   ///
     //        ///  ///      //  //      ///   ///
     //        ///  ///      //  //      ///   ///
     //          ///         /////          ///