Jadi begitulah. Lega. Habis. Anda akhirnya menemukan pendekatan untuk menyelesaikan pertanyaan koding yang rumit yang diminta pewawancara Anda. Mungkin Anda bahkan menuliskannya di papan tulis, baris demi baris. Dan Anda membuat waktu yang baik! Anda hanya 20 menit ke pertemuan. Pewawancara Anda harus terkesan.
Kanan?
"Ini akan berhasil, tetapi ada ide untuk melakukannya dengan lebih efisien?"
Jantungmu tenggelam. Anda pikir Anda sudah selesai dengan bagian desain algoritma yang rumit! Anda mencoba memikirkan lebih banyak cara untuk menyelesaikan masalah, tetapi yang dapat Anda pikirkan adalah satu-satunya pendekatan yang telah Anda lakukan.
Ini terjadi pada hampir semua orang. Dan itu bukan karena mereka bodoh. Itu karena kebanyakan orang tidak memiliki metode untuk meningkatkan efisiensi algoritma mereka.
Tetapi kenyataannya adalah, ada banyak. Lain kali Anda bingung, coba terapkan tiga pendekatan umum ini.
1. Gunakan Peta Hash
Betul. Peta hash / array asosiatif / kamus (kamus ini memiliki banyak nama, tergantung pada bahasa pemrograman yang Anda gunakan) memiliki kemampuan ajaib untuk menurunkan runtime algoritma.
Sebagai contoh, misalkan pertanyaannya adalah menemukan angka yang paling sering diulang dalam array angka.
Pikiran pertama Anda mungkin melompat ke beberapa lingkaran. Untuk masing-masing nomor kami, cari tahu jumlahnya dan lihat apakah itu yang terbesar. Bagaimana kita mendapatkan hitungan untuk setiap nomor? Loop melalui array, menghitung berapa kali itu terjadi! Jadi kita berbicara tentang dua loop bersarang. Dalam pseudocode:
def get_mode (nums): max_count = 0 mode = null untuk potential_mode di nums: count = 0 untuk angka di our_array: count + = 1 jika count> = max_count: mode = potential_mode max_count = count return mode
Saat ini, kami mengulang seluruh array kami sekali untuk setiap item dalam array - tetapi kami bisa melakukan yang lebih baik. Dalam notasi O besar, itu total O (n 2 ) waktu.
Jika kami menyimpan jumlah kami di peta hash (memetakan angka ke jumlah mereka), kami dapat memecahkan masalah hanya dengan satu berjalan melalui array (O (n) waktu!):
def get_mode (nums): max_count = 0 mode = null counts = HashMap baru, mulai setiap nilai pada 0 untuk potential_mode dalam nums: jumlah + = 1 jika jumlah> max_count: mode = potential_mode max_count = jumlah mode pengembalian
Lebih cepat!
2. Gunakan Bit Manipulasi
Ini benar-benar akan membedakan Anda dari paket. Ini tidak berlaku untuk setiap masalah, tetapi jika Anda menyimpannya di saku belakang dan memecahkannya pada waktu yang tepat, Anda akan terlihat seperti bintang rock.
Berikut ini sebuah contoh: Misalkan kita memiliki array angka, di mana setiap angka muncul dua kali, kecuali satu angka yang hanya terjadi sekali. Kami sedang menulis fungsi untuk menemukan nomor yang kesepian dan tidak diulang.
Insting pertama Anda mungkin menggunakan peta hash, karena kami baru saja membicarakannya. Itu naluri yang baik untuk dimiliki! Dan itu akan berhasil untuk yang satu ini. Kita bisa membuat peta "jumlah" yang sangat mirip, dan menggunakannya untuk melihat nomor mana yang berakhir dengan hitungan 1.
Tapi ada cara yang lebih baik. Jika Anda terbiasa dengan manipulasi bit, Anda mungkin terbiasa dengan XOR. Satu hal yang istimewa tentang XOR adalah bahwa jika Anda XOR angka dengan dirinya sendiri, bit "membatalkan" ke 0. Untuk masalah ini, jika kita XOR setiap angka dalam array bersama-sama, kita akan dibiarkan dengan satu nomor yang tidak dapat dibatalkan:
def find_unrepeat (nums): tidak berulang = 0 untuk num dalam num: tidak berulang = tidak berulang XOR num kembali tidak berulang
3. Go Bottom-up
Tulis fungsi yang menampilkan angka Fibonacci "n", diberi angka n. Yang ini klasik, dan cocok untuk rekursi:
def fib (n): jika n adalah 0 atau 1: return 1 return fib (n-1) + fib (n-2)
Tetapi jawaban rekursif sederhana bukan satu-satunya! Pikirkan baik-baik apa fungsi fungsi ini. Misalkan n adalah 5. Untuk mendapatkan jawabannya, ia secara rekursif memanggil fib (4) dan fib (3). Sekarang, apa yang dilakukan panggilan ke fib (4)? Itu disebut fib (3) dan fib (2). Tapi kami baru saja mengatakan kami sudah memiliki panggilan ke Fib (3)! Fungsi rekursif imut ini melakukan banyak pekerjaan yang berulang. Total biaya waktu ternyata menjadi O (2 n ). Itu buruk - jauh lebih buruk daripada O (n 2 ).
Daripada beralih dari n ke 1 secara rekursif, mari kita "bottom-up, " dari 1 ke n. Ini memungkinkan kita melewati rekursi:
def fib (n): sebelumnya = 0 prior_previous = 1 untuk i dalam rentang 1 ke n: saat ini = sebelumnya + sebelumnya_previous sebelumnya_previous = sebelumnya sebelumnya = arus balik saat ini
Kode ini lebih panjang, tetapi jauh lebih efisien! Turun ke O (n) waktu. Sebagai bonus tambahan dengan membuka gulungan algoritma rekursif, kami menghemat ruang. Semua panggilan rekursif itu menumpuk di tumpukan panggilan, yang berada di memori dan diperhitungkan dalam biaya ruang kami. Fungsi rekursif kami memiliki biaya ruang O (n), tetapi yang berulang ini membutuhkan ruang O (1).
Lain kali pewawancara Anda meminta Anda untuk meningkatkan efisiensi solusi Anda, cobalah menelusuri strategi-strategi ini dan melihat apakah mereka membantu. Dengan latihan yang cukup, Anda mungkin akan langsung melompat ke solusi optimal, melewatkan solusi yang lebih naif. Dan itu hal yang hebat. Itu tidak hanya berarti Anda menjadi pewawancara yang lebih baik - itu berarti Anda menjadi insinyur yang lebih baik.
