Значи там сте. Облекчен. Изчерпани. Най-накрая измислите подход за решаване на трудния въпрос за кодиране, който ви задава вашият интервюиращ. Може би дори сте го написали на дъската, ред по ред. И си изкарал хубаво време! Вие сте само на 20 минути от срещата. Вашият интервюиращ трябва да бъде впечатлен.
Така ли е?
„Това ще работи, но някакви идеи как да го направите по-ефективно?“
Сърцето ти потъва. Мислехте, че сте приключили с сложната част за проектиране на алгоритъм! Опитвате се да измислите повече начини за решаване на проблема, но всичко, което можете да измислите, е единственият подход, който вече сте измислили.
Това се случва на почти всички. И не е, защото са глупави. Това е така, защото повечето хора нямат метод за подобряване на ефективността на своите алгоритми.
Но истината е, че има много. Следващия път, когато се спънете, опитайте да приложите тези три общи подхода.
1. Използвайте Hash Map
Това е вярно. Хеш картите / асоциативните масиви / речници (те отиват с много имена, в зависимост от това, какъв език за програмиране използвате) имат магическа способност да намалят времето на изпълнение на алгоритмите.
Да предположим, че въпросът беше да се намери най-повтореното число в масив от числа.
Първата ви мисъл може да е да скочите в някои бримки. За всяко от нашите номера измислете броя му и вижте дали е най-голямото. Как да вземем броя за всяко число? Прекарайте през масива, като броите колко пъти се появява! Значи говорим за две вложени вериги. В псевдокод:
def get_mode (nums): max_count = 0 режим = нула за потенциал_мод в числа: count = 0 за номер в our_array: count + = 1 ако count> = max_count: mode = poten_mode max_count = count return mode
В момента преглеждаме веднъж целия ни масив за всеки елемент от масива - но можем да направим по-добре. В голяма O нотация, това е общо O (n 2 ) време.
Ако съхраним нашите числа в хеш карта (картографиране на числата към техните числа), можем да решим проблема само с една разходка през масива (O (n) време!):
def get_mode (nums): max_count = 0 режим = null counts = нов HashMap, започвайки всяка стойност от 0 за potencijal_mode в числа: counts + = 1, ако брои> max_count: mode = potencijal_mode max_count = брои режим на връщане
Много по-бързо!
2. Използвайте бит манипулация
Това наистина ще ви раздели от опаковката. Не се отнася за всеки проблем, но ако държите това в задния си джоб и го извадите в подходящия момент, ще изглеждате като рокзвезда.
Ето пример: Да предположим, че имахме масив от числа, където всяко число се появява два пъти, с изключение на едно число, което се среща само веднъж. Пишем функция, за да намерим самотното, не повтарящо се число.
Първият ви инстинкт може да е да използвате хеш карта, тъй като току-що говорихме за това. Това е добър инстинкт! И ще работи за този. Можем да направим много подобна карта за броене и да я използваме, за да видим кое число завършва с брой 1.
Но има още по-добър начин. Ако сте запознати с битовите манипулации, може да сте запознати с XOR. Едно нещо, което е специално за XOR е, че ако XOR число със себе си, битовете „отменят“ до 0. За този проблем, ако XOR всяко число в масива заедно, ще останем с едно число, което не не се отказвам:
def find_unrepepeated (nums): неповторен = 0 за num в nums: не повтарян = неповтарящ XOR число връщане не повторено
3. Отидете отдолу нагоре
Напишете функция, която извежда „n-тото“ число на Фибоначи, дадено число n. Този е класика и се поддава много добре на рекурсия:
def fib (n): ако n е 0 или 1: върнете 1 връщане fib (n-1) + fib (n-2)
Но простият рекурсивен отговор не е единственият! Помислете внимателно какво прави тази функция. Да предположим, че n е 5. За да получи отговор, той рекурсивно извиква fib (4) и fib (3). Сега какво прави този призив към fib (4)? Той нарича fib (3) и fib (2). Но току-що казахме, че вече имаме призив за fib (3)! Тази сладка рекурсивна функция върши много повтаряща се работа. Общият разход за време се оказва O (2 n ). Това е лошо - много по-лошо от O (n 2 ).
Вместо да преминаваме от n рекурсивно надолу към 1, нека преминем „отдолу нагоре“ от 1 до n. Това ни позволява да пропуснем рекурсията:
def fib (n): предишен = 0 предишен_предив = 1 за i в диапазон от 1 до n: текущ = предишен + предишен_предишен предишен_предив = предишен предишен = текущ връщащ ток
Кодът е по-дълъг, но е много по-ефективен! До долу (O) време. Като допълнителен бонус с разгръщането на рекурсивни алгоритми спестяваме място. Всички тези рекурсивни обаждания се натрупват в стека за разговори, който седи в паметта и се отчита към нашата космическа цена. Рекурсивната ни функция имаше разходи за O (n) пространство, но тази итеративна заема O (1) пространство.
Следващия път, когато интервюиращият ви поиска да подобрите ефективността на вашето решение, опитайте да преминете през тези стратегии и да видите дали те помагат. При достатъчно практика вероятно ще се окажете, че скачате право към оптимизираното решение, прескачайки по-наивното решение. И това е страхотно нещо. Това не означава просто, че ставаш по-добър интервюиращ - това означава, че ставаш по-добър инженер.
