Видео

Hello everyone, just wanted to make this video not only condensed further information over some aspirations and goals to share the information with you in an articulated format to be able to help you out in your journeys as well so best of luck to you as well when watching this if you have such interest 🙌

❤❤

where is link of pointer in description

This has potential

hell yeah brother 🔥🔥

Thank you so much dude i really needed this

Great stuff!

holy, 2 years of competitive programming theory compressed in less than 5 minutes! This will be my go to reference. Thank you so much

Nice work! Appreciate the condensed info 👍, saves alot of time

i had no clue what he was saying after no 7 first order derivatives

No laplacian? Great video btw!

Feels like going down memory lane from 20+ years ago. nice quick recap.

Great video, but i couldn't help but notice that you used external links and stuff that require pausing, which in my books doesn't *really* count as explaining it in under 5 minutes, but in terms of explaining the concepts it was okay

I'm high af right now

💗💗💗

Omg…. thank you so so sos s oss osos os oos much

Why am I here, just to suffer? 😔

this makes me sad

THANK YOUH

Indian students have to learn till 12th point within the age of 18

0:14 why does polynomial gets blurred

❤❤❤

I just finished calc 3 last semester. Feels great being able to understand everything being said in this vid.

What more videos bro

The topics sound familiar to me but I forget everything about it. The video is a good summary of the topics that helps me to recall the wonderful time in uni when I studied it hard 40 years ago.

Is there a good free pdf somewhere that I can use to learn this stuff? I have some textbooks but I don’t think any have referenced quantum linear algebra yet. If you already know of a good one that goes from beginner through to advanced, that would be an amazing bonus. Thank you.

If you put all of these slides into 1 pdf deck, that would be a great cheat sheet to look of how the things were called again to then look up the details again!

Incredible job brother!!

Amazing video, great refresher!

amazing. thanks man.

Excellent work amigo

i feel like i know the book(s) that you used for as reference pictures. Either stewart’s calculus or another book i can’t remember but has numerically, graphically and something else -lly at the end. Either way great video and definitely a good reference for us who’s attention spans are all over the place

Watching this at 2x 2.5 mins before my finals

Good job brother 👍

This video is art.

I realtor like the video> Keep on going buddy

Disclaimer 17:10, O(n) is linear, not constant. * Steps: 1. Input: We're given an array of integers and a target value. 2. What DSA/Algorithm to use: We will use a Hash Table to store the complement values. 3. What to do with data: We will iterate through the array, for each element, check if the complement value (target minus the current element) exists in the hash table. If it does, we have found a pair that sums up to the target. If it doesn't, we insert the current element into the hash table. 4. Output: We will return the indices of the two elements that sum up to the target. ===================================================================================//////// Pseudocode: // Input: Given an array of integers and a target value. 1. Initialize an empty hash table to store complement values. // What DSA/Algorithm to use: Hash Table. 2. Loop over each element in the array. a. Calculate the complement value by subtracting the current element from the target. b. Check if the complement value exists in the hash table. i. If it exists, return the indices of the current element and its complement from the hash table. ii. If it doesn't exist, insert the current element into the hash table. // Output: Return the indices of the two elements that sum up to the target. 3. Return an empty array (if no solution is found). ===================================================================================//////// Expanded pseudocode: // Input: Given an array of integers and a target value. // Step 1: Initialize an empty hash table to store complement values. Create an empty hash table. // What DSA/Algorithm to use: Hash Table. // Step 2: Loop over each element in the array. For each element at index i in the array: // Step 2a: Calculate the complement value by subtracting the current element from the target. Calculate the complement value as (target - nums[i]). // Step 2b: Check if the complement value exists in the hash table. If the complement value exists as a key in the hash table: // Step 2bi: If it exists, return the indices of the current element and its complement from the hash table. Return an array containing the indices stored in the hash table for the complement value and the current element. // Step 2bii: If it doesn't exist, insert the current element into the hash table. Insert the current element into the hash table with its index as the value. // Output: Return the indices of the two elements that sum up to the target. // Step 3: Return an empty array (if no solution is found). Return an empty array since no solution is found. ===================================================================================//////// C++ Solution with Expanded pseudocode, step by step, where each line of code has a comment from the expanded pseudocode. class Solution { public: vector<int> twoSum(vector<int>& nums, int target) { // Step 1: Input - Given an array of integers and a target value. unordered_map<int, int> hashTable; // What DSA/Algorithm to use: Hash Table. // Step 2: Loop over each element in the array. for (int i = 0; i < nums.size(); ++i) { // Step 2a: Calculate the complement value by subtracting the current element from the target. int complement = target - nums[i]; // Step 2b: Check if the complement value exists in the hash table. if (hashTable.count(complement)) { // Step 2bi: If it exists, return the indices of the current element and its complement from the hash table. return {hashTable[complement], i}; } // Step 2bii: If it doesn't exist, insert the current element into the hash table. hashTable[nums[i]] = i; } // Output: Return the indices of the two elements that sum up to the target. // Step 3: Return an empty array (if no solution is found). return {}; } }; ===================================================================================//////// Time complexity: O(n) - The solution requires iterating over the given array once, which takes O(n) time complexity, where n is the size of the array. Space complexity: O(n) - The solution utilizes a hash table to store complement values. In the worst case scenario, all elements may need to be stored in the hash table, resulting in O(n) space complexity. This solution is already optimized with optimal time and space complexity.

Why this is medium? It looks pretty straightforward, do you think medium/hard is harder? Meta’s guideline said focus on the medium and hard

Why space is m x n? We just modified the input , isn’t it o(1)?

Great videos! I think you can use the .contains() method instead of .count(). This should prevent some sort of internal loop over the data structure to count the elements.

Thank you very much for this! Was hoping for this tutorial. Thank you very much gunnar for this series!

Long timeee Again u back

Nice tutorials! Thx for sharing!

Underrated channel, thx for your efforts 👍

Amazing Explanation, Loved it!

Sir do add the stl video as well

Very gr8 content sir

really good

Hey bro. Do we required any special documents or certificates for 1st time upload? Can you guide me! It’s my 1st time and really don’t know hot to do it. Would really appreciate your response 😊