Status Updates From Grokking Algorithms An Illu...

Phew, made some progress after a long, Hash Tables are cool DS!

Erste Kapitel: Einführung in Algorithmen
Sehr gute Erläuterung der Landau-Notation (a.k.a. engl. Big-O-Notation) und der verschiedenen Laufzeiten von Algorithmen - lineare, logarithmische, faktorielle Laufzeiten.
Zweite Kapitel Selectionsort
Verkettete Listen vs Arrays
Selectionsort O(n x n)
Dritte Kapitel Rekursion

Erste Kapitel: Einführung in Algorithmen
Sehr gute Erläuterung der Landau-Notation (a.k.a. engl. Big-O-Notation) und der verschiedenen Laufzeiten von Algorithmen - lineare, logarithmische, faktorielle Laufzeiten.

Seamless and REALLY HIGH level introduction on how kinda simple algorithms and data structures concepts can be apply to machine learning

So far the book has been very good explaining concepts that usually are hard to grasp, this is achieved by the use of really good analogies and ilustrations.

Read more about Call stack

Didn't add to me that much in the first two chapters.
But the writer have an awesome way of simplifying complex concepts.
Take aways:
Big O doesn't mean e.g how many times we touched an object.
It measures the rate of growth in either time or space compared to the growth in our input.

Call stacks, Recursion, Quicksort, Elucid’s Algorithm, Functional programming — and a peak at Haskell language that has no loops 🤯

Linked and arrays as data types — what are these known as in Swift structures

Big O Notation concept presented

Finished first two chapters, implementing using Go

Really fun read so far. Bonus if it also happens to make my abysmal coding skills even slightly better

Arrays:
1. all the elements are stored right next to each other.
2. allow fast reads.
3. all elements should be the same type.

Linked lists:
1. elements are strewn all over, and one elements stores the address of the next one.
2. allow fast inserts and deletes.

Two types of access:
1. Random access - arrays - faster at reads
2. Sequential access - linked lists

Four main takeaways before ch. 4:
1. Run time of algorithms is expressed in Big O notation.
2. Algorithm speed is measured in growth of the number of operations, not in seconds.
3. As the size of the input increases, the run time of an algorithm increases super quick.
4. O(log n) is faster than O(n), and it gets way faster as the list of items grows.

Done 8/26/21, will review soon.

Binary search only works when your list is in sorted order.

An algorithm is a set of instructions for accomplishing a task. Every piece of code could be called an algorithm.

Eventhough I have previously studied the concepts before,the way concepts are explained are simply lucid,never before I understood divide and conquer and its applications in quicksort and other algorithms this clearly!

Perhaps got the best explanations of recursion eventhough i studied that before !

Complex ideas explained visually with simple examples makes the read more interesting. Back-cover of the book I found a quote which , I think, is the best description of the book--"Do you ever treat yourself learning algorithm in the same way that you read your fav novel?" its really close to that.If I didn't find the book, my quest for learning algorithm may have to take Big O(n!) instead of Big O(log n). huh!

The author's writing language is clear. It gets to the heart of the matter.

amazing till now!

Chapter 11 briefs of interesting topics
Trees
Inverted index
Transformada de fourier
Parallel algorithms
Mapreduce
Bloom filters
Sha algorithms
Diffie hellman
Linear programming

Chapter 9
KNN k-nearest neighbours
Classification
Regresión predict a response

Intro to AI

Chapter 9
Dynamic programming

Chapter 8
Greedy algoritmo
Sets
NP problems

Chapter 7
Weighted graphs
Directed graphs
DAG directed acycled graphs
Dijkstra’s algorithm
Negative weights

Chapter 6
Graphs
Breadth first search
Queues FIFO vs Stacks LIFO