Simulasi Wawancara Berwaktu: Masalah Mudah dan Menengah
Selesaikan tiga masalah dalam batas waktu 45 menit, jelaskan proses berpikir Anda seperti dalam wawancara sungguhan, lalu tinjau solusi optimal setelahnya
Simulasi Wawancara Berwaktu: Masalah Mudah dan Menengah adalah pelajaran DSA Interview Prep gratis di CoddyKit. Ini adalah pelajaran 2 dari 4. Kamu bisa membaca pelajaran lengkapnya di bawah secara gratis — lalu praktikkan langsung di browser dengan editor kode bawaan dan tutor AI 24/7. Ini adalah bagian dari jalur belajar DSA Interview Prep, dan progresmu tersinkronisasi di web dan aplikasi CoddyKit. Kursus DSA Interview Prep mencakup 4 pelajaran total.
Cara Menggunakan Wawancara Simulasi Ini
Pelajaran ini menyimulasikan sesi wawancara pemrograman nyata. Untuk setiap soal, Anda harus: (1) membacanya sekali, (2) mengidentifikasi pola dalam 60 detik, (3) menyatakan pendekatan dan kompleksitas Anda, (4) menulis solusi, dan (5) mengujinya dengan contoh. Atur pengatur waktu. Soal mudah seharusnya memerlukan 10–15 menit; soal menengah 20–25 menit.
Jangan melihat solusi lebih dahulu — hal itu menggagalkan tujuan latihan. Jika Anda buntu setelah 5 menit, baca ulang pernyataan soal dan carilah kata sinyal yang mengungkapkan polanya (terurut? minimum? semua kombinasi? sublarik?). Kemampuan untuk keluar dari kebuntuan sendiri sama pentingnya dengan kemampuan menyelesaikan soal dengan cepat.
# Mock interview timer simulation
import time
class InterviewTimer:
def __init__(self, total_minutes):
self.total = total_minutes * 60
self.start = None
def begin(self, problem_name):
self.start = time.time()
print(f'TIMER STARTED: {problem_name}')
print(f'You have {self.total//60} minutes. Go!')
def checkpoint(self, label):
if self.start:
elapsed = time.time() - self.start
remaining = self.total - elapsed
print(f'[{label}] Elapsed: {elapsed:.0f}s, Remaining: {remaining:.0f}s')
# Usage in real practice:
timer = InterviewTimer(15) # 15-minute easy problem
timer.begin('Two Sum')
time.sleep(1)
timer.checkpoint('Identified pattern')Soal Mudah 1: Tanda Kurung Valid
Soal: Diberikan teks yang hanya berisi '(', ')', '{', '}', '[', ']', tentukan apakah teks masukan valid. Teks valid jika setiap kurung buka ditutup oleh jenis kurung yang sama dalam urutan yang benar.
Sinyal: Pasangan yang cocok, urutan penting, kurung buka terbaru harus ditutup terlebih dahulu → Tumpukan. Masukkan kurung buka ke tumpukan; lakukan pop dan verifikasi pada kurung tutup. Jika tumpukan kosong saat kita mencoba melakukan pop, atau masih memiliki elemen tersisa di akhir, teks tersebut tidak valid. Waktu O(n), Ruang O(n).
def is_valid(s):
stack = []
matching = {')': '(', '}': '{', ']': '['}
for char in s:
if char in '({[':
stack.append(char)
else:
if not stack or stack[-1] != matching[char]:
return False
stack.pop()
return len(stack) == 0
# Test cases
test_cases = [
('()', True),
('()[]{}' , True),
('(]', False),
('([)]', False),
('{[]}', True),
('', True), # empty string is valid
('(((', False), # unmatched opens
(')]', False), # close without open
]
for s, expected in test_cases:
result = is_valid(s)
status = 'PASS' if result == expected else 'FAIL'
print(f'{status}: is_valid({repr(s)}) = {result} (expected {expected})')Soal Mudah 2: Waktu Terbaik untuk Membeli dan Menjual Saham
Soal: Diberikan sebuah larik prices dengan prices[i] sebagai harga saham pada hari ke-i, temukan keuntungan maksimum dari satu pembelian dan satu penjualan (harus membeli sebelum menjual). Kembalikan 0 jika tidak ada keuntungan yang mungkin diperoleh.
Sinyal: Perbedaan maksimum dengan posisi kiri harus mendahului posisi kanan → Lacak minimum berjalan saat menelusuri dari kiri ke kanan. Setiap hari, keuntungan potensialnya adalah current_price - min_so_far. Perbarui keuntungan maksimum. Ini memiliki kompleksitas O(n)/O(1) dan merupakan kasus khusus algoritme Kadane.
def max_profit(prices):
if not prices:
return 0
min_price = float('inf')
max_profit = 0
for price in prices:
if price < min_price:
min_price = price
elif price - min_price > max_profit:
max_profit = price - min_price
return max_profit
# Test cases
test_cases = [
([7, 1, 5, 3, 6, 4], 5), # buy at 1, sell at 6
([7, 6, 4, 3, 1], 0), # monotonically decreasing: no profit
([2, 4, 1], 2), # buy at 2, sell at 4
([1], 0), # single price: no transaction possible
([3, 3, 3], 0), # flat: no profit
]
for prices, expected in test_cases:
result = max_profit(prices)
status = 'PASS' if result == expected else 'FAIL'
print(f'{status}: max_profit({prices}) = {result} (expected {expected})')Soal Menengah 1: Penjumlahan Tiga Elemen
Soal: Diberikan sebuah larik, temukan semua tiga serangkai unik yang jumlahnya nol. Solusi tidak boleh memuat tiga serangkai duplikat.
Pola: Dua penunjuk yang diperluas ke tiga elemen. Urutkan larik. Untuk setiap elemen nums[i], gunakan dua penunjuk left = i+1, right = n-1 untuk menemukan pasangan yang jumlahnya sama dengan -nums[i]. Lewati duplikat dengan bergerak melewati nilai yang identik. Waktu O(n²), Ruang O(1) tidak termasuk keluaran. Pengurutan membuat penanganan duplikat menjadi rapi.
def three_sum(nums):
nums.sort()
result = []
n = len(nums)
for i in range(n - 2):
# Skip duplicate values for the first element
if i > 0 and nums[i] == nums[i - 1]:
continue
left, right = i + 1, n - 1
while left < right:
total = nums[i] + nums[left] + nums[right]
if total == 0:
result.append([nums[i], nums[left], nums[right]])
while left < right and nums[left] == nums[left + 1]:
left += 1 # skip duplicate lefts
while left < right and nums[right] == nums[right - 1]:
right -= 1 # skip duplicate rights
left += 1; right -= 1
elif total < 0:
left += 1
else:
right -= 1
return result
print(three_sum([-1, 0, 1, 2, -1, -4])) # [[-1,-1,2],[-1,0,1]]
print(three_sum([0, 0, 0, 0])) # [[0,0,0]]
print(three_sum([])) # []
print(three_sum([1, 2, -2, -1])) # []Soal Tingkat Menengah 2: Subrentang Terpanjang Tanpa Karakter Berulang
Masalah: Diberikan sebuah untaian karakter, temukan panjang subrentang terpanjang tanpa karakter berulang.
Pola: Gunakan jendela geser dengan himpunan (atau kamus posisi terakhir). Pertahankan jendela [kiri, kanan]. Perluas sisi kanan dengan memasukkan setiap karakter. Jika sebuah karakter berulang (sudah ada di dalam jendela), perkecil dari sisi kiri sampai karakter duplikat tersebut dihapus. Catat ukuran jendela maksimum yang ditemukan. Waktu O(n), Ruang O(min(n, ukuran alfabet)).
def length_of_longest_substring(s):
char_index = {} # character -> last seen index
left = 0
max_len = 0
for right, char in enumerate(s):
if char in char_index and char_index[char] >= left:
left = char_index[char] + 1 # shrink window past duplicate
char_index[char] = right
max_len = max(max_len, right - left + 1)
return max_len
# Test cases
test_cases = [
('abcabcbb', 3), # 'abc'
('bbbbb', 1), # 'b'
('pwwkew', 3), # 'wke'
('', 0), # empty string
('au', 2), # full string
('dvdf', 3), # 'vdf' (skip the first d)
]
for s, expected in test_cases:
result = length_of_longest_substring(s)
status = 'PASS' if result == expected else 'FAIL'
print(f'{status}: len_longest({repr(s)}) = {result} (expected {expected})')Soal Tingkat Menengah 3: Penukaran Koin
Masalah: Diberikan denominasi koin dan jumlah target, temukan jumlah minimum koin yang diperlukan untuk mencapai jumlah tersebut. Kembalikan -1 jika hal itu mustahil.
Pola: DP 1D klasik (varian masalah ransel tak terbatas). dp[i] = jumlah minimum koin untuk jumlah i. Inisialisasi dp[0] = 0, sedangkan semua nilai lainnya = tak terhingga. Untuk setiap jumlah dari 1 sampai target, coba semua denominasi koin. dp[i] = min(dp[i], dp[i - coin] + 1) untuk setiap koin yang valid. Waktu O(jumlah × panjang(koin)), Ruang O(jumlah).
def coin_change(coins, amount):
dp = [float('inf')] * (amount + 1)
dp[0] = 0 # 0 coins to make amount 0
for i in range(1, amount + 1):
for coin in coins:
if coin <= i and dp[i - coin] + 1 < dp[i]:
dp[i] = dp[i - coin] + 1
return dp[amount] if dp[amount] != float('inf') else -1
# Test cases
test_cases = [
([1, 5, 11], 15, 3), # 11+1+1+1+1... wait: 11+1+1+1+1=5 coins? No: 5+5+5=3
([2], 3, -1), # impossible (only even coins)
([1], 0, 0), # 0 coins for amount 0
([1, 2, 5], 11, 3), # 5+5+1
([186, 419, 83, 408], 6249, 20), # stress test
]
for coins, amount, expected in test_cases:
result = coin_change(coins, amount)
status = 'PASS' if result == expected else 'FAIL'
print(f'{status}: coin_change({coins}, {amount}) = {result} (expected {expected})')Alur Kerja Pemecahan Masalah di Bawah Tekanan Waktu
Ketika waktu hampir habis, prioritaskan dengan urutan berikut: (1) solusi coba semua kemungkinan yang berfungsi dan menghasilkan keluaran yang benar lebih diutamakan daripada solusi optimal yang belum selesai, (2) tangani kasus tepi secara jelas, (3) tulis kode yang rapi dan mudah dibaca, bukan kode satu baris yang rumit. Pewawancara lebih menyukai solusi O(n²) yang rapi dan lulus semua kasus uji daripada solusi O(n) dengan kesalahan yang sulit terlihat.
Jika Anda menyadari solusi O(n²) Anda salah, jangan meninggalkannya di tengah jalan—selesaikan, uji, lalu tawarkan untuk mengoptimalkannya jika waktu masih tersisa. Solusi optimal yang setengah jadi mendapat penilaian lebih rendah daripada solusi lengkap tetapi kurang optimal.
# Priority order when time runs out
priority = [
('First priority', 'Correct brute-force that passes all test cases'),
('Second priority', 'Optimal solution with bugs is WORSE than suboptimal correct'),
('Third priority', 'Edge cases handled visibly (empty input, single element, negatives)'),
('Fourth priority', 'Clean variable names and readable code'),
('Fifth priority', 'Add complexity statement as a comment at the top'),
]
print('Under time pressure, prioritise:')
for priority_level, desc in priority:
print(f' {priority_level}: {desc}')
# Adding complexity as a comment
def two_sum_commented(nums, target):
# Time: O(n), Space: O(n)
seen = {}
for i, n in enumerate(nums):
complement = target - n
if complement in seen:
return [seen[complement], i]
seen[n] = i
return []Meninjau Solusi Anda: Lima Pertanyaan
Sebelum mengatakan “Saya sudah selesai”, tanyakan kepada diri sendiri lima pertanyaan berikut:
- Apakah solusi ini menangani masukan kosong?
[],'',None, n=0 - Apakah solusi ini menangani satu elemen? Larik berukuran 1, pohon dengan satu simpul
- Apakah solusi ini menangani elemen yang semuanya sama?
[5, 5, 5, 5],'aaaa' - Apakah solusi ini menangani nilai minimum dan maksimum? Bilangan negatif, bilangan bulat yang sangat besar, 0
- Sudahkah saya menyebutkan kompleksitas waktu dan ruang? Notasi O-besar dengan justifikasi singkat
Kelima pemeriksaan ini menemukan sebagian besar kesalahan dalam solusi wawancara. Pewawancara mengharapkan kandidat menguji solusi mereka sendiri—mereka tidak akan memberi tahu bahwa solusi Anda memiliki kesalahan kecuali Anda meminta umpan balik.
# The five edge-case categories with examples
edge_cases = {
'Empty input': ['[] empty array', '"" empty string', 'None / null'],
'Single element': ['[42]', 'single node tree', 'n=1'],
'All same': ['[3,3,3,3]', '"aaaa"', 'uniform grid'],
'Extreme values': ['[-10^9, 10^9]', 'INT_MAX + 1 overflow check', '0 as input'],
'Already sorted': ['ascending + descending', 'already optimal input'],
}
for category, examples in edge_cases.items():
print(f'{category}:')
for ex in examples:
print(f' - {ex}')
print()
# Template for self-testing:
def test_my_solution(fn, test_cases):
for inputs, expected in test_cases:
result = fn(*inputs) if isinstance(inputs, tuple) else fn(inputs)
status = 'PASS' if result == expected else 'FAIL'
print(f'{status}: {inputs} => {result} (expected {expected})')Menangani Pertanyaan Lanjutan
Setelah Anda menyelesaikan masalah, pewawancara biasanya mengajukan pertanyaan lanjutan. Jenis yang umum meliputi:
- “Bisakah Anda melakukannya dengan ruang O(1)?” → Cari modifikasi langsung pada data atau trik matematika
- “Bagaimana jika n sangat besar?” → Bahas pendekatan pemrosesan aliran, pembagian halaman, atau pengambilan sampel
- “Bagaimana jika larik sudah terurut?” → Sering kali ada algoritma yang lebih sederhana
- “Bisakah Anda menjalankannya secara paralel?” → Identifikasi submasalah yang independen dan bahas MapReduce atau paralelisme tugas
Pertanyaan lanjutan menguji kedalaman pemahaman dan kemampuan beradaptasi. Katakan “Izinkan saya berpikir sejenak” daripada langsung menebak. Jeda yang penuh pertimbangan lebih baik daripada jawaban salah yang disampaikan dengan percaya diri.
# Follow-up answers for classic problems
follow_ups = [
{
'problem': 'Find duplicate in array 1..n (space O(n) solution uses set)',
'follow_up': 'Can you do it in O(1) space without modifying input?',
'answer': 'Floyd cycle detection: treat array as linked list (slow/fast pointer)',
},
{
'problem': 'Reverse a string (space O(n) with new array)',
'follow_up': 'Can you do it in-place?',
'answer': 'Two pointers from both ends, swap until they meet: O(n) time O(1) space',
},
{
'problem': 'Find max in array: O(n) single pass',
'follow_up': 'What if the array is streamed one element at a time?',
'answer': 'Same algorithm works! Running maximum handles infinite streams',
},
{
'problem': 'Merge sorted arrays O(n+m)',
'follow_up': 'What if you have K sorted arrays?',
'answer': 'Use a min-heap of (value, array_idx, element_idx): O(n log k)',
},
]
for fu in follow_ups:
print(f'Problem: {fu["problem"]}')
print(f'Follow-up: {fu["follow_up"]}')
print(f'Answer: {fu["answer"]}\n')Soal Latihan: Mengelompokkan Anagram
Masalah: Diberikan sebuah larik berisi untaian karakter, kelompokkan anagram yang sama. Kembalikan daftar kelompok.
Pola: Gunakan peta frekuensi sebagai kunci. Untuk setiap untaian karakter, urutkan karakternya (atau hitung tupel frekuensi karakter) sebagai kunci kanonis. Kelompokkan untaian karakter berdasarkan kunci ini menggunakan peta hash yang berisi daftar. Waktu O(n × m log m), dengan m sebagai panjang maksimum untaian karakter, Ruang O(n × m). Tidak diperlukan perulangan bersarang—cukup satu kali lintasan melalui larik.
from collections import defaultdict
def group_anagrams(strs):
# Method 1: sort each string as key
groups = defaultdict(list)
for s in strs:
key = ''.join(sorted(s)) # canonical form
groups[key].append(s)
return list(groups.values())
def group_anagrams_v2(strs):
# Method 2: character count tuple as key (avoids sorting)
groups = defaultdict(list)
for s in strs:
count = [0] * 26
for c in s:
count[ord(c) - ord('a')] += 1
key = tuple(count) # immutable, hashable
groups[key].append(s)
return list(groups.values())
test = ['eat', 'tea', 'tan', 'ate', 'nat', 'bat']
result = [sorted(g) for g in group_anagrams(test)]
result.sort()
print('Groups:', result)
# [['ate','eat','tea'], ['bat'], ['nat','tan']]
print('V2:', [sorted(g) for g in sorted(group_anagrams_v2(test), key=len)])Evaluasi Diri Setelah Simulasi
Setelah setiap wawancara simulasi, evaluasi diri Anda berdasarkan aspek-aspek berikut:
- Kecepatan mengenali pola: Apakah Anda mengenali polanya dalam <60 detik?
- Ketepatan kode: Apakah solusi pertama Anda lulus semua kasus uji?
- Penanganan kasus tepi: Apakah Anda menguji masukan kosong, satu elemen, dan ekstrem?
- Komunikasi: Apakah Anda menjelaskan alasan Anda sepanjang proses?
- Pemahaman kompleksitas: Apakah Anda menyebutkan kompleksitas waktu dan ruang?
- Pemulihan: Jika buntu, apakah Anda beralih dengan baik atau malah membeku?
Beri nilai 1–5 untuk setiap aspek. Fokuskan latihan Anda selama minggu berikutnya pada aspek dengan nilai terendah. Sebagian besar kandidat perlu meningkatkan kemampuan mengenali pola atau komunikasi—jarang keduanya sekaligus.
# Self-assessment scoring template
def self_assess(pattern_speed, code_correctness, edge_cases,
communication, complexity, recovery):
scores = {
'Pattern recognition (< 60s)': pattern_speed,
'Code correctness (all tests pass)': code_correctness,
'Edge case handling': edge_cases,
'Communication (thinking aloud)': communication,
'Complexity stated correctly': complexity,
'Recovery when stuck': recovery,
}
total = sum(scores.values())
max_total = len(scores) * 5
print('Self-Assessment Results:')
print('-'*50)
for dim, score in scores.items():
bar = '#' * score + '-' * (5 - score)
print(f'{dim:45s} [{bar}] {score}/5')
print(f'\nTotal: {total}/{max_total} ({total/max_total*100:.0f}%)')
weak = min(scores, key=scores.get)
print(f'Focus area: {weak}')
self_assess(4, 3, 4, 3, 5, 2) # example scoresPemeriksaan Singkat
Uji pemahaman Anda tentang konsep Struktur Data & Algoritma—Persiapan Wawancara Pemrograman dari pelajaran ini.
Ringkasan Pelajaran
Dalam pelajaran ini Anda mempelajari: hadapi masalah dengan alur kerja tetap—baca, kenali pola dalam 60 detik, nyatakan kompleksitas, tulis kode, lalu uji dengan lima kategori kasus tepi, solusi coba semua kemungkinan yang berfungsi lebih baik daripada solusi optimal yang belum selesai saat waktu hampir habis, dan evaluasi diri setelah setiap sesi latihan simulasi berdasarkan enam aspek (kecepatan, ketepatan, kasus tepi, komunikasi, kompleksitas, dan pemulihan) memusatkan peningkatan pada area yang tepat. Selanjutnya kita membahas penanganan kasus tepi dan praktik terbaik komunikasi peserta wawancara secara mendalam.
Pertanyaan yang Sering Diajukan
Apakah pelajaran “Simulasi Wawancara Berwaktu: Masalah Mudah dan Menengah” gratis?
Ya — teks lengkap “Simulasi Wawancara Berwaktu: Masalah Mudah dan Menengah” gratis dibaca di sini di web. Untuk praktiknya secara interaktif (editor kode bawaan dan tutor AI 24/7) dan buka sisa kursus DSA Interview Prep, upgrade ke CoddyKit PRO. Kursus DSA Interview Prep mencakup 4 pelajaran total.
Apa yang akan aku pelajari di “Simulasi Wawancara Berwaktu: Masalah Mudah dan Menengah”?
Selesaikan tiga masalah dalam batas waktu 45 menit, jelaskan proses berpikir Anda seperti dalam wawancara sungguhan, lalu tinjau solusi optimal setelahnya Kamu berlatih DSA Interview Prep dengan kode praktik yang langsung kamu jalankan di browser, dan tutor AI 24/7 menjawab pertanyaanmu saat kamu mengerjakan pelajaran ini.
Apakah aku perlu pengalaman untuk memulai DSA Interview Prep?
Tidak diperlukan pengalaman sebelumnya. DSA Interview Prep di CoddyKit dirancang untuk pemula hingga pelajar tingkat lanjut, jadi kamu bisa memulai di sini atau dari awal dan belajar sesuai kecepatan kamu sendiri. Ini adalah pelajaran 2 dari 4.
Berapa lama pelajaran “Simulasi Wawancara Berwaktu: Masalah Mudah dan Menengah” memakan waktu?
Sebagian besar pelajaran CoddyKit memakan waktu sekitar 5–10 menit. Setiap pelajaran ringkas dan interaktif, jadi kamu membuat kemajuan stabil dan melanjutkan dari tempat kamu tinggalkan di web dan aplikasi.
Bisakah aku menulis dan menjalankan kode dalam pelajaran DSA Interview Prep ini?
Ya. Setiap pelajaran DSA Interview Prep menyertakan editor kode bawaan, jadi kamu menulis dan menjalankan kode nyata langsung di browser dan mendapatkan umpan balik AI instan — tidak diperlukan penyiapan lokal.
Semua pelajaran dalam kursus ini
- Ringkasan Pengenalan Pola
- Simulasi Wawancara Berwaktu: Masalah Mudah dan Menengah
- Menangani Kasus Tepi dan Komunikasi Peserta Wawancara
- Pembahasan Masalah Sulit: Word Ladder II dan Alien Dictionary