Jadi ada anda. Lega. Lelah. Anda akhirnya datang dengan pendekatan untuk menyelesaikan pertanyaan kod rumit penemuduga anda meminta anda. Mungkin anda juga menulisnya di papan putih, garis demi baris. Dan anda membuat masa yang baik! Anda hanya 20 minit ke dalam mesyuarat. Pewawancara anda harus kagum.
Betul kan?
"Ini akan berfungsi, tetapi ada idea bagaimana untuk melakukannya dengan lebih cekap?"
Hati tenggelam. Anda fikir anda telah selesai dengan bahagian reka bentuk algoritma rumit! Anda cuba memikirkan lebih banyak cara untuk menyelesaikan masalah ini, tetapi apa yang anda boleh fikirkan ialah satu pendekatan yang telah anda temui.
Ini berlaku kepada hampir semua orang. Dan bukan kerana mereka bodoh. Ini kerana kebanyakan orang tidak mempunyai kaedah untuk meningkatkan kecekapan algoritma mereka.
Tetapi sebenarnya, ada banyak. Pada masa yang akan datang, anda terpaksa cuba menggunakan ketiga pendekatan ini.
1. Gunakan Peta Hash
Itu betul. Peta Hash / array bersekutu / kamus (mereka pergi dengan banyak nama, bergantung kepada bahasa pengaturcaraan yang anda gunakan) mempunyai keupayaan ajaib untuk menurunkan runtime algoritma.
Sebagai contoh, katakan soalan itu adalah untuk mencari nombor yang paling banyak di dalam pelbagai nombor.
Pemikiran pertama anda mungkin untuk melompat ke dalam beberapa gelung. Untuk setiap nombor kami, tentukan kiraannya dan lihat apakah itu yang terbesar. Bagaimanakah kita dapat mengira bilangan setiap nombor? Gelung melalui array, mengira berapa kali ia berlaku! Jadi kita bercakap tentang dua gelung bersarang. Dalam pseudocode:
def get_mode (nums): max_count = 0 mode = null for potential_mode in nums: count = 0 for number in our_array: count + = 1 if count> = max_count: mode = potential_mode max_count =
Sekarang, kita sedang melengkung melalui array kita sekali untuk setiap item dalam array-tetapi kita boleh melakukan lebih baik. Dalam notasi O yang besar, itulah masa O (n 2 ).
Jika kita menyimpan kiraan kami dalam peta hash (nombor pemetaan kepada kiraan mereka), kita boleh menyelesaikan masalah itu hanya dalam satu masa melalui array (O (n) masa!):
def get_mode (nums): max_count = 0 mode = null counts = new HashMap, bermula setiap nilai pada 0 untuk potential_mode dalam nums: counts + = 1 if counts> max_count: mode = potential_mode max_count =
Lebih cepat lagi!
2. Gunakan Manipulasi Bit
Ini akan membezakan anda dari pek. Ia tidak terpakai kepada setiap masalah, tetapi jika anda menyimpannya di poket belakang anda dan membuangnya pada waktu yang tepat, anda akan kelihatan seperti rockstar.
Berikut adalah contoh: Katakan kami mempunyai pelbagai nombor, di mana setiap nombor muncul dua kali, kecuali satu nombor yang hanya berlaku sekali. Kami sedang menulis fungsi untuk mencari nombor kesepian dan tidak berulang.
Naluri pertama anda mungkin menggunakan peta hash, kerana kami hanya membincangkannya. Itulah naluri yang baik untuk dimiliki! Dan ia akan berfungsi untuk yang ini. Kita boleh membuat peta "penting" yang sama, dan menggunakannya untuk melihat nombor mana yang berakhir dengan kiraan 1.
Tetapi ada cara yang lebih baik. Jika anda biasa dengan manipulasi bit, anda mungkin biasa dengan XOR. Satu perkara yang istimewa tentang XOR ialah jika anda mengilang nombor dengan sendirinya, bit "membatalkan" kepada 0. Untuk masalah ini, jika kita XOR setiap nombor dalam array bersama-sama, kita akan dibiarkan dengan satu nombor yang didn 't membatalkan:
def find_unrepeated (nums): unrepeated = 0 for num in nums: unrepeated = unrepeated XOR num return unrepeated
3. Pergi ke bawah
Tulis fungsi yang mengeluarkan nombor Fibonacci "nth", diberi nombor n. Yang satu ini klasik, dan ia menjadi sangat baik untuk rekursi:
def fib (n): jika n ialah 0 atau 1: pulangan 1 pulangan balik (n-1) + fib (n-2)
Tetapi jawapan rekursif mudah bukanlah satu-satunya! Fikirkan dengan teliti tentang fungsi ini. Anggap n ialah 5. Untuk mendapatkan jawapan, ia secara berurutan memanggil fib (4) dan fib (3). Sekarang, apa panggilan itu untuk fib (4) lakukan? Ia memanggil fib (3) dan fib (2). Tetapi kami hanya mengatakan kami sudah ada panggilan untuk fib (3)! Fungsi rekursif comel ini banyak mengulangi kerja. Kos keseluruhan masa ternyata adalah O (2 n ). Itulah yang buruk dari O (n 2 ).
Daripada pergi dari n secara rekursif ke bawah ke 1, mari kita pergi "bawah-bawah, " dari 1 ke n. Ini membolehkan kita melangkau rekursi:
def fib (n): previous = 0 previous_previous = 1 untuk i dalam julat 1 hingga n: current = previous + previous_previous previous_previous = sebelumnya sebelumnya = current return current
Kod ini lebih panjang, tetapi ia lebih berkesan! Turun ke O (n) masa. Sebagai bonus tambahan dengan membuka algoritma rekursif, kami menjimatkan ruang. Semua panggilan rekursif membina dalam timbunan panggilan, yang terletak dalam memori dan dikira ke arah kos ruang kami. Fungsi rekursif kami mempunyai kos ruang O (n), tetapi pergerakan ini mengambil ruang O (1).
Seterusnya, pewawancara anda meminta anda untuk meningkatkan kecekapan penyelesaian anda, cuba berjalan melalui strategi ini dan melihat jika mereka membantu. Dengan amalan yang cukup, anda mungkin akan mendapati diri anda melompat terus ke penyelesaian yang dioptimumkan, melangkau penyelesaian yang lebih naif. Dan itu satu perkara yang hebat. Ia bukan hanya bermakna anda menjadi pewawancara yang lebih baik-ini bermakna anda menjadi jurutera yang lebih baik.
