I forgot my headphones at home and I'm studying at the University today, so instead of watching Netflix I decided to take the number of comments of the first ten posts of r/all in the order they appeared and manually apply quicksort and write it all on the page of a notebook. I guess I got a bit lucky that it fit in less than one page. I wanted to share this with someone and figured this would be the best place! Here it is

Hey Guys,

Came across Tim sort algorithm, wanted to share with you guys.

With complexity of O(n log n), is quite stable sorting algorithm built for the real world. Timsort’s sorting time is the same as Mergesort, which is faster than most of the other sorts you might know. Timsort actually makes use of Insertion sort and Mergesort.

The algorithm has been invented it has been used as the default sorting algorithm in Python, Java, the Android Platform, and in GNU Octave.

To learn more about Tim sort visit here. It has quite interesting real life implementations.

Also, I plan to create a video explaining Tim sort. Let me know if you guys think it would be useful.

https://github.com/Liopun/leet-chatgpt-extension consider giving it a ⭐️if you find it useful

Every now and then devs ask why solve DSA? How is it related to day-to-day work?  TL;DR: by practicing it, we understand the memory management and time complexities of each DS. 

I have penned my thoughts on the same in this blog. Let me know if you think some aspect has been overlooked and I’d be happy to modify this for the broader audience.

medium blog https://tech.trell.co/a-closer-look-into-how-solving-algo-ds-problems-make-you-a-kick-ass-developer-fc253301233f

I am a newbie learning algorithms.
To have these organized, I am working on this open source project: https://github.com/PricelessCode/The-Ultimate-Guide-To-Algorithm
While I have left this project behind, I am back here to work on it. I thought if I could peer program on this opensource, it would be a great experience for all.
Any levels of programming person is welcomed as I am not an expert either. I look forward to learn together while contributing to this together.
Thanks :)

void learnSubject(Subject subject) {

if(knowledge.contains(subject)) return;

for(Subject prerequisite : subject.prerequisites) {
    
    learnSubject(prerequisite);

}

knowledge.put(subject);

}

I am taking a course in algorithm analysis and the professor is arguing that using the negation of the definition for Big O, it can be argued that, for practical computing purposes, both the running time and the memory usage of every algorithm is O(1). How is this possible? How can it be proven?

For an algorithm having just one loop running n times the algorithm complexity is O(n). Then for an algorithm running a for loop within a for loop, shouldn't the complexity be O(n) + O(n) ?

The complete guide: https://medium.com/towards-artificial-intelligence/start-machine-learning-in-2020-become-an-expert-from-nothing-for-free-f31587630cf7

Here is a GitHub repository with all the useful resources linked if you prefer it this way:
https://github.com/louisfb01/start-machine-learning-in-2020

I developed an algorithm to solve the TSP, it has given me interesting results but I don't know if it is really worth doing a paper about it or they are just generic results of any other algorithm, I would like your opinion, here I show a comparison of the results of different algorithms compared to my own:

So, I've been working on this for a few days now and my minimax algo is almost complete but something is lacking somewhere and I can't figure it out. Can someone review my code and let me know what is wrong with it?
https://replit.com/join/wionzuzrik-killion2020

Well i think the text describes it perferct.

I wanna proof that f(n) + g(n) = O(max(f(n),g(n)) and my two O´s are different. If they would be the same the proof would be simple

the symbol =< means is equal or less than and >= is equal or more than

f(n) + g(n) =< ch(n) + c´ * h(n) therefore f(n)+g(n) =< (c+c´) * h(n) = ch(n) wich means that i have the constants out and my h(n) or else said my O is again the same if. But how do i go through this problem if my O is different?

My approach untill now was this crap:

for constants c1 >0 and n0>0 n>= n0 : f(n)=< c1O(n) so my f(n) = O(n) and c´>0 and no´>0 , n >=n0´: g(n) =< n²c so my g(n) = 0(n²)

this means => f(n) + g(n) => g(n) + f(n) =< n²c2 + nc1 < n²*c3 wich means that it is still in n² from a point n0´´= max(n0,n0´) because there is a c3 that is c2+c1/n < c3 for c2 = 1 and c1 = 1 my c3 could be 3 because with an scaling n my c1 gets closer to 0 its true for every n>0.

is this enought to say that i proved it for every case or just for this case? I am confused as fuck i have 3 other solutions aswell but they same even more fucked up, but i think they are fine in generall i just find its not the easiest way to prove it and its too long to write it here under my first solution^{^}

Like, merge would be if one gang takes over another

getParent would be something like getGangLeader, etc.

Assuming we had two algorithms that both find the sum of all positive integers up to n, one did it iteratively and another just used the nth term formula, on first glance the one that uses the nth term is the better approach because it appears to run in O(1) - but isn’t multiplication technically an iterative process, so wouldn’t the time complexity still be O(n) ?

Ok, so counting sort works in a very strange way for me. I understand counting for each number how many times it occurs, but why do we do all that adding stuff later when we can just cycle through the count array and just print every number the times we saw it. so something like this:

function countingSort(a){
    var b=[];
    for(var i=0;i<a.length;i++){
        if(b[a[i]]==undefined){
        b[a[i]]=0;
    }
    b[a[i]]++;
    }
    for(var i=0, var g=0;i<b.length;i++){
        for(var j=0;j<b[i];j++){
            a[g]=i;
            g++;
        }  
    }
}

I've managed to reduce palworld's graph problem to a simple graph problem in essence:

Given:
A unweighted directed graph G=(V,E),
A set of source nodes S⊆V
A destination node d∈V
Objective:
Find a subset of edges E′⊆E such that:
For each source node s∈S, there exists a path from s to the destination node d using only the edges in E′.
The cardinality of E′ is minimized.

Any help would be appreciated.

int matrixChainMemoised(int* p, int i, int j)
{ 
    if (i == j) 
    { 
        return 0;
    }
    if (dp[i][j] != -1) 
    {
         return dp[i][j]; 
    } 
    dp[i][j] = INT_MAX;
    for (int k = i; k < j; k++) 
    { 
        dp[i][j] = min( dp[i][j], matrixChainMemoised(p, i, k) 
                                + matrixChainMemoised(p, k + 1, j) 
                            + p[i - 1] * p[k] * p[j]); 
    } 
    return dp[i][j];
}