Array Cheatsheet.

We have a list of user objects and we need to display only the active users, sorted by their last login date. How would you chain array methods to achieve this, and what happens to the original array when you do?

Imagine you are building a shopping cart. When a user removes an item, you need to delete it from an array of items. How would you find and remove that item by its ID without leaving empty 'holes' in the array?

A teammate wrote a search filter that uses .filter() inside a .map() loop to cross-reference two arrays of 5,000 items each, and the UI is freezing. How would you diagnose the performance bottleneck and rewrite this to run in linear time?

We have a real-time dashboard receiving a stream of log events. The developer used unshift() to add new logs to the front of the array so they display first. As the log size grows, the app gets sluggish. Why is unshift causing issues here, and how would you refactor the data structure or rendering logic to fix it?

We are building an undo/redo history stack for a collaborative design tool. The state history array can grow extremely large. How would you design this history manager to prevent memory leaks and ensure that state transitions remain O(1) while keeping memory usage bounded?

In a high-throughput data visualization component, we need to process and render 100,000 data points every 16ms. Standard array methods like .map().filter().reduce() are causing garbage collection spikes and frame drops. How would you optimize this processing pipeline to avoid allocations and maintain 60fps?

Our enterprise monorepo has dozens of micro-frontends independently manipulating shared state arrays, leading to race conditions and unpredictable mutations. How would you design an architectural pattern or state-sharing contract to enforce immutability and predictable updates across these teams without introducing massive performance overhead?

We are migrating a legacy Node.js service that processes multi-gigabyte CSV exports in memory using massive array structures, frequently hitting out-of-memory limits. How would you architect a streaming, buffer-backed solution to replace these arrays, and how would you roll this out safely without breaking downstream consumers?