└── README.md /README.md: -------------------------------------------------------------------------------- 1 | # Contents 2 | 3 | - [Summary](#summary) 4 | - [Curriculum](#curriculum) 5 | - [Projects](#projects) 6 | 7 | # Summary 8 | 9 | * This repository organizes all taken courses along with my solutions to assignments & any side project that I have done. 10 | * If you need Real-Time Help in these courses, Join [AC Discord](https://discord.gg/QrfTN2Aukx) or OSSU's Server. 11 | * It's all thanks to [OSSU](https://github.com/ossu/computer-science)s' incredible help, curriculum & courses order. 12 | 13 | # Curriculum 14 | - [CS Essential Prerequisite Tools \& Knowledge](#cs-essential-prerequisite-tools--knowledge) 15 | - [Intro CS](#intro-cs) 16 | - [Introduction to Programming](#introduction-to-programming) 17 | - [Introduction to Computer Science](#introduction-to-computer-science) 18 | - [Core CS](#core-cs) 19 | - [Core Programming](#core-programming) 20 | - [Core Theory](#core-theory) 21 | - [Algorithms-\&-Data-Structures](#algorithms--data-structures) 22 | - [Courseless](#courseless) 23 | - [Problem-Solving](#problem-solving) 24 | 25 | ## CS Essential Prerequisite Tools & Knowledge 26 | 27 | 1. [Computer Science concepts](https://www.youtube.com/playlist?list=PLWKjhJtqVAbn5emQ3RRG8gEBqkhf_5vxD). 28 | 2. Learning how to Google. 29 | 3. Learning Git. 30 | 4. Learning Basic Linux. 31 | 5. Learning how to take notes. 32 | 33 | ## Intro CS 34 | 35 | ### Introduction to Programming 36 | 37 | **Topics covered**: 38 | `simple programs` 39 | `simple data structures` 40 | 41 | [Python for Everybody](https://www.py4e.com/lessons) 42 | 43 | ### Introduction to Computer Science 44 | 45 | **Topics covered**: 46 | `computation` 47 | `imperative programming` 48 | `basic data structures and algorithms` 49 | 50 | [Introduction to Computer Science and Programming using Python](https://ocw.mit.edu/courses/electrical-engineering-and-computer-science/6-0001-introduction-to-computer-science-and-programming-in-python-fall-2016/) 51 | 52 | ## Core CS 53 | 54 | ### Core Programming 55 | 56 | **Topics covered**: 57 | `programming concepts` 58 | `basic syntax` 59 | `basic data structures` 60 | `data structures` 61 | `static typing` 62 | `dynamic typing` 63 | `divide and conquer` 64 | `unit testing` 65 | `programming paradigms` 66 | `functional programming` 67 | `ML-family languages (via Standard ML)` 68 | `Lisp-family languages (via Racket)` 69 | `object oriented programming` or `OOP` 70 | `racket` 71 | `java` 72 | `Ruby` 73 | `Universal Libraries` 74 | `tools` 75 | `C++` 76 | `algorithms` 77 | `algorithm complexity notions` 78 | `basic OS` 79 | `basic computer architecture` 80 | `UML` 81 | `software engineering` 82 | `advanced syntax` 83 | `object-oriented` 84 | `object-oriented analysis` 85 | `object-oriented design` 86 | `design patterns` 87 | `software architecture` 88 | `design for testing` 89 | `threading` 90 | `lexical scoping` 91 | `string search` 92 | | Course | Topics Covered | Course Portfolio | 93 | |:-:|:-|:-:| 94 | | [Java YT Tutorials by Derek Banas](https://www.youtube.com/playlist?list=PLE7E8B7F4856C9B19) |
`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](https://github.com/OmarShawky1/Chess) (Check [Side-Projects](#side-projects) for topics covered by this project) | 95 | | [How to Code - Simple Data](https://www.edx.org/course/how-to-code-simple-data) & [How to Code - Complex Data](https://www.edx.org/course/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](https://github.com/OmarShawky1/Course-How-To-Code-Data) | 96 | | [Programming Languages, Part A](https://www.coursera.org/learn/programming-languages), [Programming Languages, Part B](https://www.coursera.org/learn/programming-languages-part-b) & [Programming Languages, Part C](https://www.coursera.org/learn/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](https://github.com/OmarShawky1/Course-Programming-Languages) | 97 | | [Computer Science: Programming with a Purpose](https://www.coursera.org/learn/cs-programming-java) |
`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 | 98 | | [Mastering 4 Critical Skills using C++ 17 by Prof. Mostafa Saad](https://www.udemy.com/course/cpp-4skills/)|
`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 | 99 | | \* [Object Oriented Design - University of Alberta](https://www.coursera.org/learn/object-oriented-design)
\* [Object Oriented Analysis & Design - Tutorials Point](https://www.tutorialspoint.com/object_oriented_analysis_design/index.htm)
\* [NPTEL OOAD](https://nptel.ac.in/courses/106105153)|
`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 | 100 | | \* [Refactoring Guru](https://refactoring.guru/design-patterns) & [Source Making](https://sourcemaking.com/)
\* [Christoper Okhravi Design Patterns YT Playlist](https://www.youtube.com/playlist?list=PLrhzvIcii6GNjpARdnO4ueTUAVR9eMBpc) |
`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)
| - | 101 | | [Alberta Software Architecture Course on Coursera](https://www.coursera.org/learn/software-architecture) |
`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| 102 | 103 | 104 | ### Core Theory 105 | #### Algorithms-&-Data-Structures 106 | * "\*" means topic is repeated because it relates to multiple categories. 107 | 108 | **Topics covered**: 109 | `sorting and searching` 110 | `randomized algorithms` 111 | `data structures` 112 | `graph search` 113 | `shortest paths` 114 | `greedy algorithms` 115 | `minimum spanning trees` 116 | `dynamic programming` 117 | `string algorithms` 118 | `data Compression` 119 | `algorithm complexity notions` 120 | 121 | 122 | | Course | Topics Covered | Course Portfolio | 123 | |:-:|:-|:-:| 124 | | [Princeton Algorithms Course Part 1](https://www.coursera.org/learn/algorithms-part1) & [Princeton Algorithms Course Part 2](https://www.coursera.org/learn/algorithms-part2) |
`sorting and searching`, `shortest paths`, `randomized algorithms`, `data compression`, `data structures`, `algorithm complexity notions`
`sorting and searching`: `shortest paths`: `randomized algorithms`: (Shuffle sort),
`data compression`: (Run-length Encoding, Huffman Compression, LZW Compression, Burrows-Wheeler Algorithm, Shannon-Fano Algorithm)
`data structures`: `algorithm complexity notions`: (Problem Reduction, Linear programming, simplex algorithm, P, NP, CoNP, NP-Hard, Intractable)
| [My Solution](https://github.com/OmarShawky1/Course-Princeton-Algorithms-DS) | 125 | 126 | 127 | #### Courseless 128 | * Topics I learned from non-interactive course (Videos, Medium Posts...). 129 | 134 | 135 | |Subject|Topic| 136 | |:-:|:-| 137 | | `Data Structure` | Trees: AVL Trees, Segment Trees | 138 | | `Algorithms` | `divide and conquer` | 139 | 140 | #### Problem-Solving 141 | * Videos to watch before following courses: 142 | * [Prof. Mostafa Saad's YT Video about tackling problems that take time](https://youtu.be/9N1JQvUzBSY 143 | ) 144 | 145 | | Course | Topics Covered | Course Portfolio | 146 | |:-:|:-|:-:| 147 | |[Mastering 4 critical SKILLS using C++ 17 by Prof Mostafa Saad](https://www.udemy.com/course/cpp-4skills/)|`accumulation`: (Accumulation Array, Fixed Sliding Window),
`counting`: (Frequency Array, Counting increasing subarrays), || 148 | 149 | 150 | # Projects 151 | - [Side-Projects](#side-projects) 152 | - [Elected-Projects](#elected-projects) 153 | 154 | ## Side-Projects 155 | 156 | |Project|Topics Covered| 157 | |:-:|:-:| 158 | | [GUI Multiplayer Chess Over Local Connection](https://github.com/OmarShawky1/Chess) |`Java 8` `OOP` `JavaFx` `threads` `networking` and even more| 159 | 160 | 161 | ## Elected-Projects 162 | * Projects that are done in the aforementioned studied courses and desereve explicite mentioning. 163 | 164 | |Project|Topics Covered| 165 | |:-:|:-:| 166 | | [Burrows-Wheeler](https://github.com/OmarShawky1/Course-Princeton-Algorithms-DS#burrows-wheeler) | `suffix array`, `burrows-wheeler`, `data compression`, `key-indexed sorting` | 167 | | [Baseball Elimination](https://github.com/OmarShawky1/Course-Princeton-Algorithms-DS#baseball-elimination) | `directed graphs`, `mincut-maxflow`, `augmenting paths` | 168 | | [Seam-Carving](https://github.com/OmarShawky1/Course-Princeton-Algorithms-DS#seam-carving) | `directed graphs`, `image processsing`, `shortest paths` | 169 | | [Boogle](https://github.com/OmarShawky1/Course-Princeton-Algorithms-DS#boggle) | `character-based operation`, `tries`, `ternary tries`, `R-way tries` | 170 | | [WordNet](https://github.com/OmarShawky1/Course-Princeton-Algorithms-DS#wordnet) | `undirected graphs`, `graph searching`, `shortest paths`, `BFS`, `DFS` | 171 | | [kD-Trees](https://github.com/OmarShawky1/Course-Princeton-Algorithms-DS#kdtrees) | `red-black BST`, `kD BST`, `shortest paths` | 172 | | [8Puzzle](https://github.com/OmarShawky1/Course-Princeton-Algorithms-DS#8-puzzle) | `Minimum Priority Queue`, `A* Search Algorithm` | 173 | | [Collinear Points](https://github.com/OmarShawky1/Course-Princeton-Algorithms-DS#collinear) | `mergesort` | 174 | | [Made Up Programming Language](https://github.com/OmarShawky1/Course-Programming-Languages#week-7-hw5) | `interpreter` (Mini Interpreter (not via using Symbol Tables) to illustrate how they work conceptually) | 175 | --------------------------------------------------------------------------------