interview | 面试集锦：收集各种面试题目，以及解题思路或者答案，解题技巧等等

The error implies that it can't find a range to work with. As we are working with a table, the .Columns(2) wont work.

This part hints that you have a table that your are trying to sort.

There's two approaches that I can think of now, to solve this:

1. Sort a regular range by custom list

We can remove the table by:

1. Click on the table
2. Go to design tab
3. Convert to Range

Then your originally code will work (Changed Key1:=.Columns(2)):

If I were asked this, my first thought would be to use promises/futures. The idea behind them is that you can execute time-consuming operations asynchronously and they will somehow notify you when they've completed, either successfully or unsuccessfully, typically by calling a callback function. So the first step is to spawn five asynchronous tasks and get five promises.

Then I would join the five promises together, creating a unified promise that represents the five separate tasks. In JavaScript I might call Promise.all(); in Java I would use CompletableFuture.allOf().

I would want to make sure to handle both success and failure. The combined promise should succeed if all of the API calls succeed and fail if any of them fail. If any fail there should be appropriate error handling/reporting. What happens if multiple calls fail? How would a mix of successes and failures be reported? These would be design points to mention, though not necessarily solve during the interview.

Promises and futures typically have modular layering system that would allow edge cases like timeouts to be handled by chaining handlers together. If done right, timeouts could become just another error condition that would be naturally handled by the error handling already in place.

This solution would not require any state to be shared across threads, so I would not have to worry about mutexes or deadlocks or other thread synchronization problems.

She said she would use a flag variable to keep track of the number of API calls have returned.

One thing that makes great interviewees stand out is their ability to anticipate follow-up questions and explain details before they are asked. The best answers are fully fleshed out. They demonstrate that one has thought through one's answer in detail, and they have minimal handwaving.

When I read the above I have a slew of follow-up questions:

• How will she know when each API call has returned? Is she waiting for a function call to return, a callback to be called, an event to be fired, or a promise to complete?
• How is she causing all of the API calls to be executed concurrently? Is there multithreading, a fork-join pool, multiprocessing, or asynchronous execution?
• Flag variables are booleans. Is she really using a flag, or does she mean a counter?
• What is the variable tracking and what code is updating it?
• What is monitoring the variable, what condition is it checking, and what's it doing when the condition is reached?
• If using multithreading, how is she handling synchronization?
• How will she handle edge cases such API calls failing, or timing out?

A flag variable might lead to a workable solution or it might lead nowhere. The only way an interviewer will know which it is is if she thinks about and proactively discusses these various questions. Otherwise, the interviewer will have to pepper her with follow-up questions, and will likely lower their evaluation of her.

When I interview people, my mental grades are something like:

• S — Solution works and they addressed all issues without prompting.
• A — Solution works, follow-up questions answered satisfactorily.
• B — Solution works, explained well, but there's a better solution that more experienced devs would find.
• C — What they said is okay, but their depth of knowledge is lacking.
• F — Their answer is flat out incorrect, or getting them to explain their answer was like pulling teeth.

For me, it looks like you could get only two results:

• No result if two max values are the same, so no value is greater than the average.
• Only the greatest value if a next smaller value exists.

Another solution could be to select a pair and filter the array basex on the average of the pair.

So we have an actually correct answer here, the issue is that you're writing to the boolean but never reading from it. Without the Println(), it's not used in a conditional or any other expression anywhere that depends on its value, so the assignments to it don't affect the program flow. You could remove all of the lines assigning values to insideValley and the program would act no differently than it does right now (excepting the Println(), of course, which is why adding that "fixed" the issue).

Go is specifically designed to flag "junk" code like that, that adds nothing to the program flow, as a compiler error (well, in most cases. Unused globals and unused functions are some exceptions to that). Simply add in whatever is supposed to be using that boolean's value (such as a conditional based on its value), and you'll stop getting the "variable unused" error.

And as noted in the comments of Vishwa Ratna's answer, vars do not have to be used in every logical pathway. They only need to be used (ie. read from) in at least one logical pathway.

Not sure if I understood your question right but this article explains the single-threaded model of nodeJS pretty nicely imo (node-js-architecture-single-threaded-event-loop)

tldr:

NodeJS has a single thread for the event loop. I'm not sure about the specific data structure implementations but every request is added to a queue where it's picked up by the event loop, executed and response sent.

If the request performs blocking IO (or other blocking processes*), the operation is handed over to a different thread, the request is put in some waiting list and the event loop picks up a different request to handle. Once the blocking op is done, the event loop picks up the original request and plus the results of the op, continues processing the request then sends a response.

* If the blocking process is procedurally coded by you, you could end up blocking the event loop causing a DOS. One should use a worker thread for that.

** NodeJS also has the concept of multithreading using the cluster module so there's that but it's still generally considered single-threaded.

It's because there's no common inferred types and you didn't specify the types for all the Either.

So

As the comments mentions, you should look for a pattern in the sections (4 corners) and not in the total parts. We will enumerate the corners as a vector like this:

(a (top left),b (top Right) ,c (bottom left) ,d (bottom Right))

Also for sake of consistency and understanding we always fold from right to left in the vertical fold (right half on top of the left half) and from bottom to top in the horizontal fold (bottom half on top of the top half) and we start with horizontal as the first fold we will preform.

first we start with 1 in each corner so when we divide we get the sum of all corners like this:

(1,1,1,1) = 1 + 1 + 1 + 1 = 4 (n = 0)

lets see what will happen in each corner after few runs:

(2,1,2,1) = 2 + 1 + 2 + 1 = 6 (n = 1)

(4,2,2,1) = 4 + 2 + 2 + 1 = 9 (n = 2)

(6,3,4,2) = 6 + 3 + 4 + 2 = 15 (n = 3)

(9,6,6,4) = 9 + 6 + 6 + 4 = 25 (n = 4)

maybe at first its hard to see the relation between but actually the pattern is pretty simple:

(a,b,c,d) -> (a+b,a,c+d,c) when you fold vertically (from right to left)

and

(a,b,c,d) -> (a+c,b+d,a,b) when you fold horizontally (from bottom to top)

so you can get the recursive relationship and here some simple code in C for this:

You're actually using a brute-force approach, which is O(n!). Here's a O(n²) approach:

The problem is in