Contents

• Summary
• Curriculum
• Projects

Summary

• This repository organizes all taken courses along with my solutions to assignments & any side project that I have done.
• If you need Real-Time Help in these courses, Join AC Discord or OSSU's Server.
• It's all thanks to OSSUs' incredible help, curriculum & courses order.

Curriculum

• CS Essential Prerequisite Tools & Knowledge
• Intro CS
  • Introduction to Programming
  • Introduction to Computer Science
• Core CS
  • Core Programming
  • Core Theory
    • Algorithms-&-Data-Structures
    • Courseless
    • Problem-Solving

CS Essential Prerequisite Tools & Knowledge

1. Computer Science concepts.
2. Learning how to Google.
3. Learning Git.
4. Learning Basic Linux.
5. Learning how to take notes.

Intro CS

Introduction to Programming

Topics covered: simple programs simple data structures

Python for Everybody

Introduction to Computer Science

Topics covered: computation imperative programming basic data structures and algorithms

Introduction to Computer Science and Programming using Python

Core CS

Core Programming

Topics covered: programming concepts basic syntax basic data structures data structures static typing dynamic typing divide and conquer unit testing programming paradigms functional programming ML-family languages (via Standard ML) Lisp-family languages (via Racket) object oriented programming or OOP racket java Ruby Universal Libraries tools C++ algorithms algorithm complexity notions basic OS basic computer architecture UML software engineering advanced syntax object-oriented object-oriented analysis object-oriented design design patterns software architecture design for testing threading lexical scoping string search

Course	Topics Covered	Course Portfolio
Java YT Tutorials by Derek Banas	programming concepts, basic syntax, basic data structures, OOP, threading, lexical scoping, string search programming concepts: (User input, Conditional Statement, for, while, do-while-loop, Methods & Fields, Exception Handling, Java Object), basic syntax: (Variables, Variables Types, Arithmetic Operations, if, loops {while, for}, Nesting, Access Modifiers, Non-Access Modifiers, Static Methods), basic data structures: (Arrays, LinkedList, ArrayList, String Builder), OOP: (Java Class, OOP Polymorphism: {Upcasting, Downcasting}, Inheritance: {Abstract Class, Interface, Method Overriding, Method Overloading}, Static, Final), threading, lexical scoping, string search	GUI Multiplayer Chess Over Local Connection (Check Side-Projects for topics covered by this project)
How to Code - Simple Data & How to Code - Complex Data	programming concepts, basic function structure, functional programming, dynamic typing programming concepts: (lexical scoping), basic function structure: (Function signature, First Order Function) functional programming: (Recursion, Mutual Recursion, Tail Recursion, High Order Function: {Function Consumer or passing function as argument}, map, filter, fold, Backtracking Search, Generative Recursion), dynamic typing	My Solution
Programming Languages, Part A, Programming Languages, Part B & Programming Languages, Part C which covers all topics in "Concepts of Programming Languages by Robert W. Sebesta 12th Edition" & "Programming Language Pragmatics by Michael Scott 4th edition"	programming concepts, functional programming, static typing, dynamic typing, ML-family languages (via Standard ML), Lisp-family languages (via Racket), OOP, Ruby, libraries, tools programming concepts: (Mutation, References/Pointers, : {Pairs, Tuples, Records}, Polymorphism (Functional, OOP, Bounded), Datatype Binding, Type Inference (Implicit Typing, Explicit Typing), Weak Typing, Strong Typing, Duck Typing, Method Overriding, Dynamic Dispatch, Double Dispatch, Interpreter), programming paradigms: (functional programming, OOP), functional programming: (Recursion, Mutual Recursion, Tail Recursion, Shadowing, Case Expression (AKA Pattern Matching), High Order Function, map, filter, fold, lexical scope, dynamic scope, Stream, Lazy Evaluation, Eager Evaluation, Memoization, Tokenization, Subtyping {Functional Sutyping, OOP Sutyping}, Generics), ML-family languages (via Standard ML), Lisp-family languages (via Racket), OOP, Ruby: (Classes, Object State, Arrays, Blocks, Hashes & Ranges, Subclassing: {Inheritance in java}, Mixins), universal libraries: (File Stream, I/O Stream, Math), tools: (Read Evaluate Print Loop (REPL), Debugger)	My Solution
Computer Science: Programming with a Purpose	programming concepts, basic syntax, basic data structures, Functional Programming, OOP programming concepts: (Abstraction, Decomposition, Standard Input & Output, Type Conversion, Type Checking, Functions, API, Modular Programming, Recursion, dynamic programming, divide and conquer, Memoization, Algorithmic Complexity, Abstract Datatypes, Compiler, Interpreter, Procedural Paradigm, Scripting Language, Special-Purpose Language), basic syntax: (Variables, Variables Types, Arithmetic Operations, if, loops {while, for}, Nesting, Access Modifiers, Non-Access Modifiers, Static Methods), basic data structures: (Primiteves, string, Arrays, kD Arrays), Functional Programming, OOP: (Methods, inheritance, Encapsulation)	No homework, Too trivial as I have done it after Algorithms course
Mastering 4 Critical Skills using C++ 17 by Prof. Mostafa Saad	programming concepts, C++ concepts, basic syntax, basic data structures, data structures, OOP, functional programming, algorithm complexity notions, algorithms, universal libraries, basic OS, basic computer architecture, UML, SE practices, software engineering, advanced syntax, advanced c++ programming concepts: (Type Conversion, Polymorphism: {Upcasting, Downcasting}, Exception Handling: {except, throw, noexcept, nothrow}, Compiler, Linker, Procedural Paradigm), C++ concepts: (Standard Input & Output, References/Pointers, STL, Headers & includes), basic syntax: (Variables, Variables Types, Arithmetic Operations, if, Loops {while, for}, Nesting, Access Modifiers, Non-Access Modifiers: {static, const, final}, Functions & Methods), basic data structures: (Primitives, string, Arrays {1D, 2D, kD}), data structures: (Encapsulation Techniques: {Struct, Pairs, Tuples}, STL: {Templates, queue, Priority Queues, Deque, Stack, Iterators, References, Pointers}, Vectors: {1D, 2D, kD}, Sets, Multisets, map), functional programming: (Recursion), OOP: (concepts: {Encapsulation, Abstraction, Data-Hiding, Decomposition, SOLID Principles, inheritance: {Abstract Class, Interface, Method Overriding, Method Overloading, Operator Overloading: {Unary, Subscript, Relational, Prefix, Postfix, Input, Output, Conversion, Assignment}}}, Class: {Constructor, Destructor, Copy Constructor, Delete Function, Initializer List}, Specifiers: {final, static, friend}), algorithm complexity notions: (Problem Reduction), algorithms: (sorting: {Count Sorting}), universal libraries: (File Streams, I/O Stream), basic OS: (Memory Stucture: {Stack, Heap}, Static Variables...), basic computer architecture: (bits & bytes, 2's Compliment, Signed & Unsigned Numbers, Floating Points & Rounding Numbers, Numbers Conversion/Casting), UML: (Class Diagram: {Association, Aggregation, Composition, Generalization, Multiplicity}), SE practices: (MVP, CRUD Operations, MVC, Refactoring), software engineering: (Coupling, Cohesion), advanced syntax: (variadic, Fold Expressions, functors (High Order Function), Lambda Expressions), advanced c++: (Move Semantics & Perfect Forwarding, Smart Pointers: {Unique Pointers, Shared Pointers, Weak Pointers}, Pointer to Pointer, Void Pointer, Function Pointer)	No portfolio, done after algorithms course and I just watched the content without finding any need to upload my solutions to problem sets
* Object Oriented Design - University of Alberta * Object Oriented Analysis & Design - Tutorials Point * NPTEL OOAD	object-oriented, object-oriented analysis, object-oriented design, UML object-oriented: (object-oriented analysis: {Object Modeling, Dynamic Modelling, Functional Modelling, Conceptual Design, Use Case, System Sequence Diagram, User Interface Documentation, Relational Data Model}, object-oriented design: {Principles: {Coupling, Cohesion, Sufficiency, Completeness, Primitives}, Technical Diagram, System Design, Design Patterrns}, OOP, UML), OOP: (Class: {Function Types: {Constructor, Destructor, Iterator, Getter, Setter}, Design by Contract}, Object: {Relations/Links: {Hierarchy: {Decomposition, Abstraction: {inheritance}}, Association, Aggregation}, Visibility, Synchronization}, OOP Polymorphism), UML: (Structural Diagram: {Class Diagram, Object diagram, Component Diagram, Deployment Diagram, Composite Diagram, Package Diagram}, Behavioral Diagram: {Usecase Diagram, Activity Diagram, State Diagram: {Behavioral State machine : {State, Sub State, Submachine State}, Protocol State machine, Timing Diagram}, Interaction Diagram: {Sequence Diagram, Communication Diagram, Timinng Diagram, Interactive Overview Diagram}})	Was no any
* Refactoring Guru & Source Making * Christoper Okhravi Design Patterns YT Playlist	design patterns, creational patterns, structural patterns, behavioral patterns design patterns: (creational patterns, structural patterns, behavioral patterns), creational patterns: (Abstract Factory, Facory Method, Builder, Prototype, Singelton, Object Pool), structural patterns: (Adapbter, Bridge, Composite, Decorator, Facade, Flyweight, Proxy, Private Class Data), behavioral patterns: (Chain of Responsibility, Command, Iterator, Mediator, Memento, Observer, State, Strategy, Template Visitor, Interpreter, Null Object, Servant of Helper Class)	-
Alberta Software Architecture Course on Coursera	software architecture, UML software architecture: (Kruchten’s 4+1 View Model, Layered Systems, Client-Server n-Tier, Pipe & Filters, Feedback loop, ATAM, Data Flow Architecture, Data Integrity, Deployment Target, Interoperability, Quality Attribute & Quality attribute Scenario), UML: (Behavioral Diagrams: {Sequence Diagram, Activity Diagram, State Machine Daigram}, Structure Diagram: {Deployment Diagram, Package Daigram, Class Diagram})	Assignments are locked, don't recommend course

Core Theory

Algorithms-&-Data-Structures

• "*" means topic is repeated because it relates to multiple categories.

Topics covered: sorting and searching randomized algorithms data structures graph search shortest paths greedy algorithms minimum spanning trees dynamic programming string algorithms data Compression algorithm complexity notions

Course	Topics Covered	Course Portfolio
Princeton Algorithms Course Part 1 & Princeton Algorithms Course Part 2	sorting and searching, shortest paths, randomized algorithms, data compression, data structures, algorithm complexity notions sorting and searching: Elementary sort: (Shell sort, Insertion sort, Selection sort) Mergesort Quicksort Binary Search Quick-Select 3-Way partitioning Heapsort A* Search Multi-Dimensional Search: (KdTree, Sweep Line Algorithm) Hash-Tables* Graph-Searching: (Depth-First Search, Breadth-First Search, Topological sort, Kosaraju-Sharir DFS Twice, Cycle Detection) * Maxflow-Mincut-problem: (Ford-Fulkerson Algorithm) String Sorting: (Key-Indexed Sort, LSD Radix Sort, MSD Radix Sort, 3-way Radix Quicksort, Manber-Myers MSD Sort, Suffix Sort, (and tries DS below)) String Searching: (Knuth-Morris-Pratt, Boyer-Moore Rabin-Karp) Substring Searching (AKA Pattern Matching, Regular Expression matching): (Prefix Matching, Suffix Matching, Longest Prefix, Palindrome and many more) shortest paths: Greedy Algorithms: (Kruskal's Algorithm, Prim's Algorithm, Dijkstra's Algorithm), Acyclic SP: (Seam-Carving) dynamic programming Algorithms: (Bellman-Ford's Algorithm, Dijkstra's Algorithm*) randomized algorithms: (Shuffle sort), data compression: (Run-length Encoding, Huffman Compression, LZW Compression, Burrows-Wheeler Algorithm, Shannon-Fano Algorithm) data structures: Linear: (Array, ArrayList, LinkedList, Stack, Queue, Priority Queues, Deque) Symbol-Table: (Suffix Array, Trees*, Tries*, Hash-Tables*, Graphs*, Sets*) Trees: (Binary Search Trees, Binary Heap, 2-3 Trees, Red-Black Trees, B-Trees) Multi-Dimensional Trees: (Space-Partitioning Trees, Interval Search Tree) Hash-Tables: (Seperate Chaining: {Two-probe hashing}, Linear Probing: {Double Hashing, Cuckoo Hashing}) Sets Graphs: (Directed Graphs, Undirected Graphs, Edge Weighted Graphs, Acyclic Graphs, Edge Weighted Directed Acyclic Graphs) Minimum Spanning Trees (MST) Flow-Network or Residual Network Tries: (R-way Tries, Ternary Search Tries, TST & R2 Hybrid Tries, Patricia Trie, Suffix Tree) Miscellaneous: (DFA (Deterministic Finite State Automaton)), NFA (Nondeterminstic Finite State Automaton) algorithm complexity notions: (Problem Reduction, Linear programming, simplex algorithm, P, NP, CoNP, NP-Hard, Intractable)	My Solution

Courseless

• Topics I learned from non-interactive course (Videos, Medium Posts...).

Subject	Topic
Data Structure	Trees: AVL Trees, Segment Trees
Algorithms	divide and conquer

Problem-Solving

• Videos to watch before following courses:
  • Prof. Mostafa Saad's YT Video about tackling problems that take time

Course	Topics Covered	Course Portfolio
Mastering 4 critical SKILLS using C++ 17 by Prof Mostafa Saad	accumulation: (Accumulation Array, Fixed Sliding Window), counting: (Frequency Array, Counting increasing subarrays),

Projects

• Side-Projects
• Elected-Projects

Side-Projects

Project	Topics Covered
GUI Multiplayer Chess Over Local Connection	Java 8 OOP JavaFx threads networking and even more

Elected-Projects

• Projects that are done in the aforementioned studied courses and desereve explicite mentioning.

Project	Topics Covered
Burrows-Wheeler	suffix array, burrows-wheeler, data compression, key-indexed sorting
Baseball Elimination	directed graphs, mincut-maxflow, augmenting paths
Seam-Carving	directed graphs, image processsing, shortest paths
Boogle	character-based operation, tries, ternary tries, R-way tries
WordNet	undirected graphs, graph searching, shortest paths, BFS, DFS
kD-Trees	red-black BST, kD BST, shortest paths
8Puzzle	Minimum Priority Queue, A* Search Algorithm
Collinear Points	mergesort
Made Up Programming Language	interpreter (Mini Interpreter (not via using Symbol Tables) to illustrate how they work conceptually)