Một danh sách chạy các câu hỏi và câu trả lời thường xuyên xuất hiện trong các cuộc phỏng vấn lập trình.
Vì mục tiêu của bài tập này là thực hành các kỹ năng logic cần thiết cho một cuộc phỏng vấn mã hóa, tôi sẽ tránh sử dụng hầu hết các phương thức JS tích hợp và sẽ dựa vào/trong khi và các vòng lặp để lặp lại thông qua các cấu trúc dữ liệu.
Ngoài ra, để đơn giản, tôi sẽ cho rằng các đầu vào dự kiến sẽ đúng nên tôi không phải lãng phí không gian để kiểm tra hoặc xác nhận lỗi. Vì vậy, nếu một mảng là tham số dự kiến, đầu vào sẽ không phải là một đối tượng, v.v.
Mảng
Một trong những cấu trúc dữ liệu phổ biến nhất trong lập trình. Những câu hỏi này là những câu hỏi liên quan đến mảng.
- Tìm số còn thiếu trong một mảng số nguyên nhất định từ 1 đến 100
Return: Integer - số còn thiếu trong mảng: integer — the missing number in the array: integer — the missing number in the array
Cách tiếp cận của tôi đối với giải pháp này là nhận ra rằng các con số theo thứ tự liên tiếp. Vì mảng được sắp xếp, chúng tôi có thể giải quyết vấn đề này trong một lần bằng cách nhìn về phía trước bằng cách sử dụng
const arr = [1,2,3,4,5,6,7,7,8,6,10];const findDupes = [arr] => {0 và so sánh điều đó với
const observed = {}; for[let i = 0; i < arr.length; i++] {
if[observed[arr[i]]] {
return arr[i]
} else {
observed[arr[i]] = arr[i];
}
}return false;
console.log[findDupes[arr]]; // Returns 7
}
const arr = [1,2,3,4,5,6,7,7,8,6,10];const findDupes = [arr] => {1. Nếu
const observed = {}; for[let i = 0; i < arr.length; i++] {
if[observed[arr[i]]] {
return arr[i]
} else {
observed[arr[i]] = arr[i];
}
}return false;
console.log[findDupes[arr]]; // Returns 7
}
const arr = [1,2,3,4,5,6,7,7,8,6,10];const findDupes = [arr] => {1 không bằng
const observed = {}; for[let i = 0; i < arr.length; i++] {
if[observed[arr[i]]] {
return arr[i]
} else {
observed[arr[i]] = arr[i];
}
}return false;
console.log[findDupes[arr]]; // Returns 7
}
const arr = [1,2,3,4,5,6,7,7,8,6,10];const findDupes = [arr] => {0, điều đó có nghĩa là
const observed = {}; for[let i = 0; i < arr.length; i++] {
if[observed[arr[i]]] {
return arr[i]
} else {
observed[arr[i]] = arr[i];
}
}return false;
console.log[findDupes[arr]]; // Returns 7
}
const arr = [1,2,3,4,5,6,7,7,8,6,10];const findDupes = [arr] => {0 là số bị thiếu.
const observed = {}; for[let i = 0; i < arr.length; i++] {
if[observed[arr[i]]] {
return arr[i]
} else {
observed[arr[i]] = arr[i];
}
}return false;
console.log[findDupes[arr]]; // Returns 7
}
let arr = [1,2,3,4,5,6,7,8,10];const findMissingNum = [arr] => {
for[var i = 0; i < arr.length - 1; i++] {
if[arr[i] + 1 != arr[i+1] ] {
return arr[i] + 1;
}
}return false;
console.log[findMissingNum[arr]]; // Returns 9, the missing number
}
Để đơn giản, 1 hoặc 100 sẽ được đưa vào mảng chắc chắn. Nếu không, một kiểm tra đơn giản nếu
const arr = [1,2,3,4,5,6,7,7,8,6,10];const findDupes = [arr] => {3 và
const observed = {}; for[let i = 0; i < arr.length; i++] {
if[observed[arr[i]]] {
return arr[i]
} else {
observed[arr[i]] = arr[i];
}
}return false;
}console.log[findDupes[arr]]; // Returns 7
const arr = [1,2,3,4,5,6,7,7,8,6,10];const findDupes = [arr] => {4 có thể trả về câu trả lời mà không cần lặp qua mảng.
const observed = {}; for[let i = 0; i < arr.length; i++] {
if[observed[arr[i]]] {
return arr[i]
} else {
observed[arr[i]] = arr[i];
}
}return false;
console.log[findDupes[arr]]; // Returns 7
}
2. Tìm một số trùng lặp trong một mảng số nguyên
Return: Integer - Số trùng lặp: integer — the duplicate number: integer — the duplicate number
Giả định: Nếu không tìm thấy sao chép, trả về sai;: if no duplicate is found, return false;: if no duplicate is found, return false;
Vấn đề này có thể dễ dàng giải quyết bằng cách sử dụng hàm băm. Khi chúng tôi đi qua mảng, chúng tôi sử dụng băm để theo dõi những con số nào chúng tôi đã thấy trước đây. Nếu chúng ta gặp một số chúng ta đã thấy trước đây, chúng ta sẽ trả lại số.
const arr = [1,2,3,4,5,6,7,7,8,6,10];const findDupes = [arr] => {
const observed = {}; for[let i = 0; i < arr.length; i++] {
if[observed[arr[i]]] {
return arr[i]
} else {
observed[arr[i]] = arr[i];
}
}return false;
console.log[findDupes[arr]]; // Returns 7
}
Lý do điều này hoạt động, là bằng cách thiết lập
const arr = [1,2,3,4,5,6,7,7,8,6,10];const findDupes = [arr] => {5, chúng ta có thể tìm kiếm một băm đơn giản với
const observed = {}; for[let i = 0; i < arr.length; i++] {
if[observed[arr[i]]] {
return arr[i]
} else {
observed[arr[i]] = arr[i];
}
}return false;
console.log[findDupes[arr]]; // Returns 7
}
const arr = [1,2,3,4,5,6,7,7,8,6,10];const findDupes = [arr] => {6, sẽ trả về
const observed = {}; for[let i = 0; i < arr.length; i++] {
if[observed[arr[i]]] {
return arr[i]
} else {
observed[arr[i]] = arr[i];
}
}return false;
console.log[findDupes[arr]]; // Returns 7
}
const arr = [1,2,3,4,5,6,7,7,8,6,10];const findDupes = [arr] => {7 hoặc
const observed = {}; for[let i = 0; i < arr.length; i++] {
if[observed[arr[i]]] {
return arr[i]
} else {
observed[arr[i]] = arr[i];
}
}return false;
console.log[findDupes[arr]]; // Returns 7
}
const arr = [1,2,3,4,5,6,7,7,8,6,10];const findDupes = [arr] => {8 nếu cặp giá trị khóa tồn tại hay không.
const observed = {}; for[let i = 0; i < arr.length; i++] {
if[observed[arr[i]]] {
return arr[i]
} else {
observed[arr[i]] = arr[i];
}
}return false;
console.log[findDupes[arr]]; // Returns 7
}
Lưu ý: Bạn cũng có thể làm điều này bằng cách sử dụng
const arr = [1,2,3,4,5,6,7,7,8,6,10];const findDupes = [arr] => {9 [xem MDN: Set - JavaScript]
const observed = {}; for[let i = 0; i < arr.length; i++] {
if[observed[arr[i]]] {
return arr[i]
} else {
observed[arr[i]] = arr[i];
}
}return false;
console.log[findDupes[arr]]; // Returns 7
}
const nums = new Set[];nums.add[1];
nums.has[1]; // true
3. Tìm số lượng lớn nhất và nhỏ nhất trong một loạt các số nguyên chưa được phân loại
Trả về: Đối tượng - Chứa giá trị của tối thiểu và tối đa: object — containing value of min and max: object — containing value of min and max
Điều này có thể được giải quyết bằng cách tạo biến tham chiếu
const nums = new Set[];nums.add[1];0 và
nums.has[1]; // true
const nums = new Set[];nums.add[1];1 được khởi tạo để bằng giá trị của mục đầu tiên trong mảng -
nums.has[1]; // true
const nums = new Set[];nums.add[1];2. Sau đó, chúng tôi lặp qua mảng và so sánh các giá trị của Min/Max với
nums.has[1]; // true
const nums = new Set[];nums.add[1];3. Nếu nó nhiều hay ít, chúng tôi cập nhật giá trị. Cuối cùng, tôi trả về một đối tượng với các giá trị của Min và Max.
nums.has[1]; // true
const arr = [1,2,3,4,5,6,7,7,8,6,10];const findDupes = [arr] => {4
const observed = {}; for[let i = 0; i < arr.length; i++] {
if[observed[arr[i]]] {
return arr[i]
} else {
observed[arr[i]] = arr[i];
}
}return false;
console.log[findDupes[arr]]; // Returns 7
}
4. Trả về một mảng hiển thị tổng tích lũy ở mỗi chỉ mục của một mảng số nguyênReturn an array showing the cumulative sum at each index of an array of integersReturn an array showing the cumulative sum at each index of an array of integers
Trả về: Mảng - Số nguyên hiển thị tổng tích lũy ở mỗi chỉ mục: array — integers showing the cumulative sum at each index: array — integers showing the cumulative sum at each index
Đầu tiên, chúng tôi đặt một mảng mới sẽ được khởi tạo để chứa giá trị tại chỉ mục 0 của
const nums = new Set[];nums.add[1];4. Điều này là do chúng tôi cần một giá trị tham chiếu bắt đầu để bắt đầu tính toán của chúng tôi. Sau đó, chúng tôi lặp qua danh sách bắt đầu từ INDEX 1 [vì chúng tôi đã có giá trị tại ____25. Đối với mỗi mục trong mảng, chúng tôi thêm giá trị hiện tại vào giá trị trước đó và đẩy nó vào mảng kết quả.
nums.has[1]; // true
const arr = [1,2,3,4,5,6,7,7,8,6,10];const findDupes = [arr] => {6
const observed = {}; for[let i = 0; i < arr.length; i++] {
if[observed[arr[i]]] {
return arr[i]
} else {
observed[arr[i]] = arr[i];
}
}return false;
console.log[findDupes[arr]]; // Returns 7
}
5. Tìm tất cả các số trùng lặp trong một mảng có nhiều bản sao
Return: Array - Chứa tất cả các bản sao được tìm thấy hoặc mảng trống nếu không tìm thấy: array — containing all duplicates found or empty array if none are found: array — containing all duplicates found or empty array if none are found
Giống như câu hỏi 2, tôi sẽ sử dụng bản đồ băm, nhưng thay vì đặt giá trị của [mảng [i]] = mảng [i], chúng tôi sẽ tăng số lượng. Tùy thuộc vào những gì chúng tôi muốn trả về, chúng tôi có thể trả lại đối tượng với các giá trị lặp lại hoặc chúng tôi có thể đẩy các số trùng lặp vào một mảng mới và trả lại mảng mới. Vì nó sạch hơn, và chúng ta có thể làm điều đó trong một lần, tôi sẽ làm sau này.
const arr = [1,2,3,4,5,6,7,7,8,6,10];const findDupes = [arr] => {7
const observed = {}; for[let i = 0; i < arr.length; i++] {
if[observed[arr[i]]] {
return arr[i]
} else {
observed[arr[i]] = arr[i];
}
}return false;
console.log[findDupes[arr]]; // Returns 7
}
Nếu không tìm thấy bản sao nào trong mảng, thì hàm sẽ trả về một mảng trống
6. Loại bỏ tất cả các bản sao khỏi một loạt các số nguyên
Return: Array - không có bất kỳ bản sao: array — without any duplicates: array — without any duplicates
Đối với giải pháp tiếp theo này, tôi đã có ý tưởng từ blogpost này cho thấy cách thực hiện việc này trong Java. Khái niệm này là làm điều ngược lại với những gì tôi đã làm trong Giải pháp 1 [nhìn 1 về phía trước], để theo dõi cái phía sau. Bằng cách theo dõi các mục trước đó gặp phải, chúng tôi biết liệu chúng tôi có gặp phải số hay không và có nên đẩy vào mảng kết quả hay không.
Lưu ý: Để giải pháp này hoạt động, chúng tôi cần một mảng được sắp xếp. Trong ví dụ Java, họ đã thực hiện một phương thức .Sort [] trên mảng trước khi lặp qua nó. Đối với tôi, tôi sẽ chỉ cho rằng chúng tôi đang nhận được một mảng được sắp xếp làm đầu vào.: in order for this solution to work, we need a sorted array. In the Java example, they performed a .sort[] method on the array before looping through it. For me, I will just assume that we are getting a sorted array as an input.: in order for this solution to work, we need a sorted array. In the Java example, they performed a .sort[] method on the array before looping through it. For me, I will just assume that we are getting a sorted array as an input.
const arr = [1,2,3,4,5,6,7,7,8,6,10];const findDupes = [arr] => {8
const observed = {}; for[let i = 0; i < arr.length; i++] {
if[observed[arr[i]]] {
return arr[i]
} else {
observed[arr[i]] = arr[i];
}
}return false;
console.log[findDupes[arr]]; // Returns 7
}
Nếu chúng ta có thể sắp xếp, chúng ta có thể sử dụng hàm băm tra cứu như trong các giải pháp trước.
7. Tìm tất cả các cặp trong một mảng các số nguyên có tổng bằng với một số đã cho
Trả về: Mảng - Kết hợp các cặp hoặc mảng trống.: array — matching pairs or empty arrays.: array — matching pairs or empty arrays.
Để đơn giản hóa, mảng đầu vào sẽ không có bản sao. Tuy nhiên, sẽ có những con số tiêu cực và tích cực. Đối với giải pháp, như trước đây, tôi sẽ sử dụng băm tra cứu. Như bạn có thể thấy, biết cách sử dụng băm tra cứu, có thời gian tra cứu liên tục, có thể rất hữu ích.
const arr = [1,2,3,4,5,6,7,7,8,6,10];const findDupes = [arr] => {9
const observed = {}; for[let i = 0; i < arr.length; i++] {
if[observed[arr[i]]] {
return arr[i]
} else {
observed[arr[i]] = arr[i];
}
}return false;
console.log[findDupes[arr]]; // Returns 7
}
Sự kết luận
Các giải pháp trên cho thấy cách bạn có thể sử dụng các khái niệm đơn giản để giải quyết nhiều vấn đề về mảng phổ biến với một giải pháp tuyến tính.Phải có các giải pháp khác có thể làm tốt hơn độ phức tạp tuyến tính, nhưng tôi sẽ để nó cho bạn để suy nghĩ về nó và đề xuất một số ý tưởng!
Nếu bạn mới bắt đầu, hy vọng điều này cho bạn thấy làm thế nào bạn có thể tránh xa các giải pháp cho vòng lặp lồng nhau thường xuất hiện trong tâm trí.
Bản thân tôi vẫn đang nghiên cứu các khái niệm và thủ thuật này để làm chủ cuộc phỏng vấn kỹ thuật, và tôi rất vui khi chia sẻ những ý tưởng này với người khác.
Nếu bạn thích bài viết này và muốn biết thêm, vui lòng kiểm tra: