วีดีโอ

Glad you liked it!

Thank you! Happy to hear!

Hey! If you check how we defined Y_n at 2:30 and potentially also look into how P(X_1>=Y_1)=1/2 relates to the calculation at 1:59, you should see why we used Y20 at 4:08 - 4:45.

The induction hypothesis is that each p_i =1/2. If you replace them with 0.5, you get the result.

You're right, there is a typo in the video

You are correct, the return is the percentage change, and not the final value

I am unsure on why are you saying that the first person has a different probability of being chosen than the last. Which part of the induction proof is unclear?

i think the confusion comes from the fact that the first k people chosen to be seated in the airplane have to "survive" N-k rounds. In the example given with 4 people on the plane, it was implied that the 6th person who arrived would have the same chance to board the plane as the 5th, but as is pointed out in the algorithm, the random number is now generated from the set {1,2…6} so the 6th person has a 2/3 chance of boarding (if the value is 4 or lower they board). If you multiply out the probability of the first passenger "surviving" both rounds you’ll see it’s also 2/3, and this generalizes as more people attempt to board (4/5)*(5/6)*(6/7)…. So after N rounds each passenger has the same chance of boarding, namely k/N.

Yes, @anirudhjanardhan788 that is the correct explanation!

Ah, yeah, I got it. Thanks for the explanations!

You're welcome!

Thank you!

In the case of duplicating only one data point, the impact will be smaller, it will depend on the total number of data points and on the particular data point you choose to duplicate. It cannot be quantified as easily as duplicating the entire dataset.

This is just deduced from the assumptions of the OLS, mainly from the error term being normally distributed.

It might be, depend on how easily you can wrap your head around it.

There are a few resources available to understand Rsquared adjusted, such as investopedia, or this wiki page: en.wikipedia.org/wiki/Coefficient_of_determination

I do have some resources for finance on my website, in the section of books I recommend

Glad you liked it!

Hey! Great question. In the case of OLS, the coefficients stay unchanged as the changes we make end up simplifying nicely (see 4:00). However, for Ridge Regression, the closed form is w=(XX^T+λI)^(−1)Xy^T. Due to the extra lambda, coefficients will change (in a quite unpredictable way, from what I can tell). I've prepared a minimal working example here: colab.research.google.com/drive/1UKvPZwfCPGQWtumgyBcUGe3yyPeXNIvE?authuser=3#scrollTo=hoc9Xb9QuBvo&line=1&uniqifier=1

Hi! We arrived at the following recursive relation at 2:44, A(k+1) = A(k) + k+1 (*). For k=n-1, we get: A(n) = A(n-1) + (n-1)+1 = A(n-1) + n For k=n-2, we get: A(n-1) = A(n-2) + (n-2) + 1 = A(n-2) + n-1 ... For k=2, we get: A(3) = A(2) + 2 + 1 = A(2) + 3 For k=1, we get: A(2) = A(1) + 1 + 1 = A(1) + 2 ------------------------------------------------------------- (sum up and simplify) A(n) = n + n-1 + ... + 3 + 2 + A(1) Here, replacing A(1) with the 2 value from 1:25, you get that A(n) = n(n+1)/2+1. This was my approach. If I understand correctly, you propose that we also add this line For k=0, we get: A(1) = A(0) + 0 + 1 = A(0) + 1 And sum up and simplify after, leveraging A(0)=1. While I agree that this could be correct, it required some extra attention on defining A(0) as well as showing that (*) works for 0. I opted to avoid this :D

This is question A4/2014 at the Putnam competition.

Can you please add some more explanation on how dividing the n elements into s groups is related to the proof of reservoir sampling?

@@atypicalquant The algorithm (in this case, Reservoir Sampling) should achieve 2 goals: (i) Each element has a probability of s/n to be chosen (ii) ** Each subset of size s should have equal probability to be chosen I should not say the induction proof of wrong, but it is incomplete, as it only proofs point (i). why point (ii) is important ? Consider an alternative algorithm below: - We divide n elements into s groups (simply assume divisible) - Pick one group randomly - There are n/s groups, and we pick one randomly, with probability s/n - So, each element also has probability s/n to be chosen But if we perform the above "algorithm" repeatedly, if we pick an element "a" twice, all the other elements being picked together with "a" will be the same (which belong to the same group), which is not desired. So, we need something else to proof that Reservoir Sampling can indeed achieve goal (ii). Instead, we can relate the Reservoir Sampling with Fisher-Yates shuffle: If we consider the front s elements in a permutation is the "reservoir", then the two algorithms are equivalent. Since Fisher-Yates shuffle generates random permutation of n elements, the front s elements will be random subset of size s, having equal probability to be chosen, which proofed goal (ii) above.

@@atypicalquant The algorithm (in this case, Reservoir Sampling) should achieve 2 goals: (i) Each element has a probability of s/n to be chosen (ii) ** Each subset of size s should have equal probability to be chosen I should not say the induction proof of wrong, but it is incomplete, as it only proofs point (i). why point (ii) is important ? Consider an alternative algorithm below: - We divide n elements into s groups (simply assume divisible) - Pick only group randomly - There are n/s groups, and we pick one randomly, with probability s/n - So, each element also has probability s/n to be chosen But if we perform the above "algorithm" repeatedly, if we pick an element "a" twice, all the other elements being picked together with "a" will be the same (which belong to the same group), which is not desired. So, we need something else to proof that Reservoir Sampling can indeed achieve goal (ii). Instead, we can relate Reservoir Sampling with Fisher-Yates shuffle: If we consider the front s elements in a n-elements permutation to be the "reservoir", the two algorithms are equivalent. Since Fisher-Yates shuffle creates random permutations of n elements, for the first s spots is a random subset of size s, achieving our goal (ii)

@@atypicalquant The algorithm (in this case, Reservoir Sampling) should achieve 2 goals: (i) Each element has a probability of s/n to be chosen (ii) ** Each subset of size s should have equal probability to be chosen I should not say the induction proof of wrong, but it is incomplete, as it only proofs point (i). why point (ii) is important ? Consider an alternative algorithm below: - We divide n elements into s groups (simply assume divisible) - Pick only group randomly - There are n/s groups, and we pick one randomly, with probability s/n - So, each element also has probability s/n to be chosen But if we perform the above "algorithm" repeatedly, if we pick an element "a" twice, all the other elements being picked together with "a" will be the same (which belong to the same group), which is not desired. So, we need something else to proof that Reservoir Sampling can indeed achieve goal (ii). Instead, we can relate Reservoir Sampling with Fisher-Yates shuffle: If we consider the front s elements in a n-elements permutation to be the "reservoir", the two algorithms are equivalent. Since Fisher-Yates shuffle creates random permutations of n elements, for the first s spots is a random subset of size s, achieving our goal (ii)

@@atypicalquant The algorithm (in this case, Reservoir Sampling) should achieve 2 goals: (i) Each element has a probability of s/n to be chosen (ii) ** Each subset of size s should have equal probability to be chosen I should not say the induction proof of wrong, but it is incomplete, as it only proofs point (i). why point (ii) is important ? Consider an alternative algorithm below: - We divide n elements into s groups (simply assume divisible) - Pick only group randomly - There are n/s groups, and we pick one randomly, with probability s/n - So, each element also has probability s/n to be chosen But if we perform the above "algorithm" repeatedly, if we pick an element "a" twice, all the other elements being picked together with "a" will be the same (which belong to the same group), which is not desired. So, we need something else to proof that Reservoir Sampling can indeed achieve goal (ii). Instead, we can relate Reservoir Sampling with Fisher-Yates shuffle: If we consider the front s elements in a n-elements permutation to be the "reservoir", the two algorithms are equivalent. Since Fisher-Yates shuffle creates random permutations of n elements, for the first s spots is a random subset of size s, achieving our goal (ii)

Yes, choosing 4 planes according to the conditions will create 15 chunks. There is actually a very nice animation here: en.wikipedia.org/wiki/Cake_number

The time constraints are more of a guideline, used to compare the problems between them. In general, interviewers expect you to start moving towards a solution in this timeframe, but will not cut you off after 2 minutes. They might intervene and guide you towards a solution.

The expected value of a variable is the integral of X * pdf(X). Since the pdf(X) has to integrate to 1, we need to scale it with the total area of the triangle

Great solution!

Great solution!

Thanks a lot!

Happy to hear! You're welcome 😀

Salut. Desi ca motor si tractiune masina ar putea teoretic sa faca fata, eu personal nu as incerca. Daca mergi vara, dalele de pe sosea (se vad putin la 2:30) sunt foarte dure si inalte si iti vor scutura rau masina (mai ales daca ai niste jante mai mari) si poate chiar ti se va lovi scutul. Daca mergi iarna, nu cred ca vei putea urca pe drumul acoperit de zapada. Mai mult, din cate știu, nu ai Hill Descent Control pe seria 3. Chiar daca reusesti sa urci, nu va fi deloc usor coboratul foarte abrupt si poti ajunge într-o râpă.

This might be true about quant jobs. Still, I am happy about being able to help the small community we have built here.

Indeed one can use the concavity of the function log2(x) for this particular justification

Thank you!

That is not the correct answer. You can (re)watch the TH-cam short or find the full video on my channel page to learn why :D

This is such in an interesting approach! I'm sure this at least helps with the intuition of the answer, which you can then prove more rigorously.

Do you have to nail all 298 remaining? Or the first 2 also count so you have 1 nail 1 miss and need to nail 297 out of 298 remaining?

For the total of 298 hits, you need to hit 297 out of the remaining 298, given that the first two are known to be a hit and a miss

Hey! Unfortunately, at this time, I am not open to sharing the source code. It wouldn't help much anyway, as it was hastily written and relying on quite a few custom classes. If you have specific manim issues, I am happy to try and assist you with them.

You have correctly applied the algorithm to the example you have, and it indeed does not produce the correct result. This is because, as stated in the question, the algorithm works when the mode of the array has more than half of the frequency in the array. This is not the case for your example, giving that D has frequency 0.5.

my bad, I forgot to multiply with the probabilities of the branches

You can try and solve the problem by choosing right positions first and you will find that it generates the same answer. Once we fix the up(or right positions), the remaining can be set in only one way.