1 Years Experienced Best Javascript Interview | Chakde Frontend Interview EP - 05 

Questions: 1. Chunk Approach 1: Using Slice Operation In this approach, we use the `slice` method to create subarrays. const chunk = (arr, size) => { let n = arr.length; const ans = []; for (let i = 0; i < n; i += size) { ans.push(arr.slice(i, i + size)); } return ans; } let arr = [1, 2, 3, 4, 5]; // Size = 1 let size = 1; let res = chunk(arr, size); console.log(res); // [[1], [2], [3], [4], [5]] // Size = 2 size = 2; res = chunk(arr, size); console.log(res); // [[1, 2], [3, 4], [5]] // Size = 3 size = 3; res = chunk(arr, size); console.log(res); // [[1, 2, 3], [4, 5]] Approach 2: Iterating Through the Array and Adding Chunks One by One In this approach, we iterate through the array and build chunks manually. const chunk = (arr, size) => { const ans = []; let chunk = []; for (let i = 0; i < arr.length; i++) { chunk.push(arr[i]); if (chunk.length === size || i === arr.length - 1) { ans.push([...chunk]); chunk.length = 0; } } return ans; } let arr = [1, 2, 3, 4, 5]; // Size = 1 let size = 1; let res = chunk(arr, size); console.log(res); // [[1], [2], [3], [4], [5]] // Size = 2 size = 2; res = chunk(arr, size); console.log(res); // [[1, 2], [3, 4], [5]] // Size = 3 size = 3; res = chunk(arr, size); console.log(res); // [[1, 2, 3], [4, 5]]

1.In this way we can also do the 1st question. function chunk(arr,size){ let result=[]; let i=0; while(i

Your videos are really brainstorming every time it is one level up , the way debounce can be asked and the scenarios that you asked helps a lot.

All the questions are amazing. Solved Chunk problem using splice. function chunk(arr, size) { if (size > arr.length) { return [arr]; } let count = Math.ceil(arr.length/size), result = [], startIndex = 0; for(let i = 0; i < count; i ++) { result.push(arr.splice(startIndex, size)); } return result; }

CODE Question 1 :- The approach is to take only 1 variable and use it repeatedly. Time Complexity is O(N) as we need to traverse the whole array. function chunk(arr, size) { if(size >= arr.length) return arr; if(size

Thank you Chirag for having me on your channel!

Every Video Of Chakde frontend Is A Gem for Us Thanks a lot Sir ❤❤❤❤

Awesome questions !! solution: /* chunk([1,2,3,4,5], 1) [[1],[2],[3],[4],[5]]; */ function chunk(arr, size) { let ans = []; let count = size; let temp = new Array(); for (let i = 0; i < arr.length; i++) { temp.push(arr[i]); count--; if (count { searchFn(...args); },delay); } } function print(data){ console.log(data); } let returnFun = debounce(print, 1000); returnFun("i"); returnFun("ip"); returnFun("iph"); returnFun("ipho"); /* q3 */ const count = (()=>{ let value = 0; function inner(){ value++; console.log(value); return value; } inner.reset = function(){ value=0; } return inner; })(); count();//1 count();//2 count();//3 count.reset()// count();//1 count();//2 count();//3

function chunk(arr, size) { let result = []; for (let i = 0; i < arr.length; i = i + size) { result.push(arr.slice(i, i + size)); } return result; }

For count function task may be we can assign reset and count as a property of countFn using dot operator. Example: function countFn() { countFn.count += 1; return countFn.count; } countFn.count = 0; countFn.reset = () => { countFn.count = 0; }

➡️➡️Using Splice which modifies the original arr and helps to easily cut out the portion and add it to result- var chunk = function (arr, size) { const result = []; while (arr.length > 0) { const portion = arr.splice(0, size); result.push(portion); } return result; };

So help me with something, once the miniAns is pushed in result array, why would the GC GC it?

Thank you for the Chakde Frontend Interview series! It has been very helpful! 😊 Sir could you please clarify something from Task 1? How is this approach better: result.push([...minAns]); // Copying the content to a new array minAns.length = 0; compared to this approach: result.push(minAns); minAns = []; // Creates a new array for minAns Both seem to clear the array and both create a new array in memory, but in different ways. Could you explain why the first method is considered better than the second one?

For the first question. my solution is. const chunk = (arr, size) => { const result = []; for(let i=0; i< arr.length / size; i++){ const chunked = arr.slice(i * size, (i+ 1) * size) result.push(chunked); } console.log(result) }

Sir you are a master piece ❤ I have a small request please bring a big project where you will do start things by explaining basics of any feature and we will end by creating that by our own . but please bring something.

Implemented chunk problem using slice: Here is the implementation. const chunk = (arr, size) => { const result = []; for (let i = 0; i < arr.length; ) { result.push(arr.slice(i, i + size)); i += size; } return result; };

Thanks, I am learning lots of programing trick and solutions to your this series

In the last question why the arrow function rather then normal function??

function fun(arr, size){ const result = (curSize)=>{ if(curSize < arr.length){ console.log(arr.slice(curSize, curSize +size)) result(curSize+size) } } return result(0) }

1. array chunking my solution: function chunk(arr,chunkSize){ let result = [] while(arr.length>chunkSize){ result.push(arr.splice(0,chunkSize)) arr.toSpliced(0,chunkSize) } result.push(arr) return result }

question 1 ) best way of writing code function divide(chunk, size){ let res = []; while(chunk.length > size){ res.push(chunk.splice(0,size)); } if(chunk.length) res.push(chunk) return res }

This is very helpful. I see this count(), count.reset() in libraries like jest. Thanks 🙏

Great video please do more such video for the beginners

These questions were quite a thinker!

Array length resetting to 0 makes the array empty was something new. Last i knew was that if we do function.length it gives us the number of arguments in the particular function

question 3) function createCount() { let counter = 0; const count = () => { counter++; return counter; }; count.reset = () => { counter = 0; }; return count; } // Usage: const count = createCount(); console.log(count()); // 1 console.log(count()); // 2 console.log(count()); // 3 count.reset(); // Reset the counter console.log(count()); // 1 console.log(count()); // 2 console.log(count()); // 3

function chunk(arr, size) { let tempArr = []; for (let i = 0; i < arr.length; i = i + size) { tempArr.push(arr.slice(i, size + i)); } console.log(tempArr); } My solution to the first question

Can anyone please tell me what code editor are they using ?

❤

Valuable Content ❤

Tysm for this interview sir ❤❤

It's really amazing video 😍. I have learnt lot of things from this video.which will help me my upcoming interview.thanks alot chirag sir🙏 . keep posting these type of video. One thing I want to share, I know Prikshit Chawla ,he is my instructor of advance javascript.the way he is teaching is amazing. He is good instructor also❤🥰.

Counter problem: function countFunction() { this.value +=1 return this.value } const context = { value: 0, } const count = countFunction.bind(context); count.reset = function () { this.value = 0 }.bind(context) Chunking problem: const chunk = (arr, size) => { if(arr.length

1. chunk const chunck = (arr,size) => { const chunkedArray = []; for(let i=0;i< arr.length;i+=size){ const subArr = arr.slice(i, i+size); chunkedArray.push(subArr) } return chunkedArray; }

Question 1 Solution function chunk(array, size) { const result = []; for (let i = 0; i < array.length; i += size) { result.push(array.slice(i, i + size)); } return result; } console.log(chunk([1, 2, 3, 4, 5], 1)); console.log(chunk([1, 2, 3, 4, 5], 3));

Lot's of high level concepts in your interviews......keep this but keep something for freshers also

let countValue= 0; // define function let count = () => { countValue += 1; console.log("Count Value after increment: " + countValue); // Define and attach the reset function inside the count function count.reset = () => { countValue = 0; console.log("Count Value after reset: " + countValue); } } count(); count(); count(); count.reset(); that approch is simple and best i think

( my Approach -> using pointer )function chunking(arr, chunk) { let result = []; let pointer = 0; for (let i = 0; i < arr.length; i++) { result[pointer] !== undefined ? result[pointer].push(arr[i]) : (result[pointer] = [arr[i]]); if (result[pointer].length === chunk) { pointer++; } } return result; } console.log(chunking([1, 2, 3, 4, 5], 1)); console.log(chunking([1, 2, 3, 4, 5], 2)); console.log(chunking([1, 2, 3, 4, 5], 3)); console.log(chunking([1, 2, 3, 4, 5], 4)); console.log(chunking([1, 2, 3, 4, 5], 5));

Befor watching this video i didn't know how garbage collector work but after the first question i understand thanks chirag

For the first question i feel chirag tried to go for over optimisation , Actually whatever the approach prikshit has given is the optimal solution. Here are the reasons why ? 1. spread operator copies the data from one array to another array which takes O(k) TC. 2. Updating the length of the array `arr.length = 0` will internally removes all the elements ( which is again be given to the garbage collector ) and takes an additional O(k) TC though it seems to take constant TC. So the overall TC for chirag's solution would be O( n * k ) where `n` total length of source array and `k` is the chunk size & SC will be O(k) But for the first approach which prikshit has written takes O(n) TC and O(k) SC.

let counter = 0; function count(){ return counter += 1; } count.reset = function(){ counter = 0; } count(); // 1 count(); // 2 count.reset(); // 0 count(); // 1 count(); // 2 count(); // 3 console.log(counter); // 3 Thoughts please?

is that it will work here 😅 sorry let i = 1; function count(){ console.log(i++); return { reset:function(){ i = 0; } } } count(); count(); count().reset(); count(); count(); count(); count();

This should do it const chunk = (array, size) => { const chunkedArray = []; for (let i = 0; i < array.length; i += size) { chunkedArray.push(array.slice(i, i + size)); } return chunkedArray; };

Doing great chirag 💯 💯 🎉

@Chirag Its Beauty..

Q1 Please review function chunk(data, size) { const update = []; let row = []; for (let i = 0; i < data.length; i++) { row.push(data[i]); if (row.length === size || i === data.length - 1) { update.push(row); row = []; } } return update; }

Is these correct way of doing ? function myCount() { let i = 0; function innerCount() { i++; console.log(i) } innerCount.reset = function() { i=0; } return innerCount; } const count = myCount();

learned a lot from the problem you ask...Prikshit Selected

First comment, we want more videos like this .

Wallmart my dream company

could we use this ◦•●◉✿keyword in the last question✿◉●•◦

More such interviews 😜

Hi Chirag could you please suggest from where we can find and prepare these type of questions. It will really helpful for us. Thanks in advance

Solution for question 1 in typescript: ``` const chunk = (arr: T[], size: number) => { let itemsArr: T[] = []; return arr.reduce((acc, item, index) => { itemsArr.push(item); if (itemsArr.length === size) { acc.push([...itemsArr]); itemsArr.length = 0; } if (index === arr.length - 1 && itemsArr.length > 0) { acc.push(itemsArr); } return acc; }, []); }; console.log(chunk([1, 2, 3, 4, 5], 3)); ```

let arr=[1,2,3,4,5], size=3 function chunk(arr:any[],size:number){ let ans=[]; let tempArr=[] for(let el of arr){ let k= tempArr.length;//0 if(k

// please implement your chunk(arr:any[],size:number) function chunk(arry=[],size){ let anotherArray = [] while (arry.length>0) { let smallArray = arry.splice(0,size) anotherArray.push(smallArray) } return anotherArray } console.log(chunk([1,2,3,4,5],1)) console.log(chunk([1,2,3,4,5],2)) console.log(chunk([1,2,3,4,5],3)) console.log(chunk([1,2,3,4,5],4)) console.log(chunk([1,2,3,4,5],5)) this is my answer

Brainstorming 🔥

let increCount =1 function count() { return increCount++ } count.reset = function (){ increCount = 1 } console.log(count()) console.log(count()) console.log(count()) count.reset() console.log(count()) console.log(count()) console.log(count())

this is also working.... let i = 0; function foo(){ console.log(i++); } foo.reset = function (){ i = 0; } foo(); foo(); foo(); foo.reset(); foo(); foo(); foo(); foo();

Prikshit sir 🫡

Accio faculty 😂

function chunk(arr, size){ let res = [] let min = [] arr.forEach((item, idx)=>{ if(min.length < size){ min.push(item) }else{ res.push(min) min = [item] } }) res.push(min) return res } console.log(chunk([1,2,3,4,5], 4)) not solved coding problem from last 1 year and after solving this problem, before the candidate now i feel like i am still worthy. 😛 thanks for the video @engineerchirag const count = (() =>{ let c = 0 return function (){ c++ return c } })() count.reset = () =>{ c = 0 return 0 } console.log(count()) console.log(count()) console.log(count.reset())

I have one doubt in debouncing problem if anyone can answer that. When declaring variable id or first inside debounce function, will it not create a new copy every time debounce is called. How can we remember the old ID or whether it is a first keystroke or not?? @engineerchirag

function chunk(arr, size) { return Array.from({ length: Math.ceil(arr.length / size) }, (_, i) => arr.slice(i * size, i * size + size) ); }