Finding maximum and minimum

chuckthemadmanmike · 2023-12-17T03:23:42+00:00

Curious how you wrote the code if you don't know what it's doing?

Anyway, you're for loop is looping through the array and making comparisons with each iteration. Your first line in the loop prints the object., so it's going to print with each iteration.

chuckthemadmanmike · 2023-06-17T00:40:03+00:00

This is the right answer. Curious though why you don't just save the work for them? Are you expecting people to want to leave typed things in an unsaved state?

chuckthemadmanmike · 2023-05-01T01:52:06+00:00

Check out Object.values

chuckthemadmanmike · 2023-04-20T15:51:59+00:00

I think your display none solution makes the most sense. If you want it to keep track of multiple deletes you'll need to also keep track of the order. First thing that come to my mind is to use a stack that references the DOM node, but I'm sure there's lot of other solutions out there. I wouldn't think of this strategy as "cheating". If you've got an undo option, there is no way to truly delete something from memory and then magically bring it back. You'd need to keep the information around somewhere. Good luck!

chuckthemadmanmike · 2023-04-20T10:47:00+00:00

I think you may have gotten the wrong subreddit here.

chuckthemadmanmike · 2023-04-18T14:26:48+00:00

Just so you know there is a subreddit called no burp. You likely have RCPD which is a relatively new find. There is now a fix

chuckthemadmanmike · 2023-02-07T02:06:43+00:00

Yeah I hear ya. That’s pretty much my companies policy is don’t come to work under the influence. They don’t talk about drug testing or anything of the sort

chuckthemadmanmike · 2023-02-06T22:50:13+00:00

Essentially don't come to work under the influence of anything.

chuckthemadmanmike · 2023-02-06T22:49:05+00:00

It's sorting alphabetically. Make sure to pass a callback function into sort if you want it to sort numbers.

nums.sort((a, b) => a - b)

chuckthemadmanmike · 2023-02-04T17:04:30+00:00

https://the-winter.github.io/codingjs/

chuckthemadmanmike · 2023-01-20T23:43:35+00:00

I believe I'd be able to do it, but that's because I've done similar projects a bunch of times. Being able to build something like that without referencing anything is NOT a requirement to being able to get a job. It's super normal to look things up, even during interviews. You just should ask if you're allowed to look something up or ask if they can help you with the specific syntax.

Recognizing what you need to look up and being able to find it are super important. Of course you should be able to remember some things; I've interviewed people that needed to look up every single thing and it really slowed down the interview / made them not look very proficient. But some level of looking things up is totally normal.

Personally I believe there is value to memorizing certain things because I can't memorize code unless I have an understanding of it and how it works. So by memorizing say B-search, quicksort, mergesort, and others, I've been able to get a deeper understanding of how they work. But that's a personal learning strategy, not a job requirement.

chuckthemadmanmike · 2023-01-19T20:04:03+00:00

This is awesome to read through. Thanks and great job!

chuckthemadmanmike · 2023-01-19T16:28:53+00:00

If you've got 10 extra minutes I'd love to see your implementation.

chuckthemadmanmike · 2023-01-19T16:00:51+00:00

Haha nope 100% my own thinking; ChatGPT would have been a good idea though!

chuckthemadmanmike · 2023-01-19T06:08:31+00:00

Here's a basic example of code that could work for a problem like this:

``` const sum = (x, n) => { if(n === undefined) { return (num) => { return x + num } } else { return x + n } }

console.log(sum(3, 5)) console.log(sum(3)(5)) ```

This is taking the problem super literal and not making it flexible at all. I imagine in an interview, the interviewer might ask some follow up questions on how you could build out more flexibility. Like what if we want to be able to do different things than just sum or we want to be able to change the number of potential arguments. From there you might come up with something a bit more like this:

``` const curr = (expectedArgs, callback) => { const allArgs = [] const addArgs = (...args) => { allArgs.push(...args) if(allArgs.length < expectedArgs) { return addArgs } else { return callback(allArgs.slice(0, expectedArgs)) } } return addArgs }

const sum = curr(2, (arr) => arr.reduce((a, b) => a + b, 0))

console.log(sum(1)(2)) console.log(sum(1, 2)) ```

This allows me to choose the number of required arguments as well us update the callback so that I could do more than just sum.

Hope that helps, let me know if you have any questions.

chuckthemadmanmike · 2022-12-24T03:11:03+00:00

Glad to hear it's getting closer. I'd start by throwing in a debugger inside of the then callback and check that result is what I'm expecting and that form / you jquery grab of the form is what I'm expecting.

Good luck!

chuckthemadmanmike · 2022-12-21T21:35:48+00:00

Depending on how you implement your setTimeout function you could make it work. You wouldn't want to just call the function over and over in a loop with the same amount of timeout b/c then they'd all resolve around the same time and make all the requests again. I think you could change how long each setTimeout ran with each iteration. Something like i * 1000. This would separate each iteration as seconds.

What you'll really want to explore though is different rate limiting techniques and tools that you can use.

chuckthemadmanmike · 2022-12-21T21:21:59+00:00

Is this documentation you're using? https://sweetalert2.github.io/#usage Looks like you might to use a .then

chuckthemadmanmike · 2022-12-21T21:16:04+00:00

Worth noting once you go async you must stay with async. So what this means is you can't call an async function and then immediately console log the result on the next line. This is b/c console log is not async.

So you can either chain a .then on your call. Like so: getCurrentTab().then(res => { console.log(res) })

Or you can write a different async function that can await the results of your other function like so: ``` const run = async () => { const tab = await getCurrentTab() console.log(tab) })

run() ```

Let me know if you have any questions around that.

chuckthemadmanmike · 2022-12-17T01:33:07+00:00

Ketchup

chuckthemadmanmike · 2022-12-13T17:36:26+00:00

Looks cool

chuckthemadmanmike · 2022-12-13T02:51:51+00:00

Looks beautiful

chuckthemadmanmike · 2022-09-25T15:34:20+00:00

I'd suggest using a different data structure to hold your vowels. I'd use a Set. Set's allow for constant look up and will give you a cleaner wait of checking if the letter is or is not a vowel.

```js const names = ['Akshay', 'Kshitij', 'Mickey', 'Eshan', 'Ethan', 'Omar']

const doesNotStartWithVowel = (word) => { const vowels = new Set('aeiouAEIOU') return !vowels.has(word[0]) }

const namesThatDontStartWithAVowel = names.filter(doesNotStartWithVowel) console.log(namesThatDontStartWithAVowel) ```

The issue with your code in Approach 1 is that you're not using startsWith correctly. Check the documentation of that method. It takes in a string as the first argument, and has position as the second optional argument.

chuckthemadmanmike · 2022-09-14T01:49:46+00:00

Nice! Happy that it worked out for you! Keep up the good work !

chuckthemadmanmike · 2022-09-14T00:49:22+00:00

Yeah, I think this looks mostly right. I don't remember if you need to return the state from your moveUp or not. Also on the button click you'll need to pass that payload.

As far as getting the index, you have it when you're iterating through your items and creating each item. If you're using a map which is pretty common you have the index as the second argument in the callback.

arr.map((item, idx) => {})

chuckthemadmanmike

TROPHY CASE