Совершенное программирование проблемы собеседования

Сачин Малхотра

Программирование интервью тяжело!

Интервью скрининга телефона немного проще, чем традиционные интервью на месте доски. Интервью доской доски вовлекает много давления и тревоги из-за отсутствия редактора кода для кода. То, что эти интервью имеют общего, так это те, что навыки, которые они теряют.

Обычно интервью программирования будет включать один вызов программирования. Кандидат должен работать над этим на протяженность интервью. Отведенное время обычно 30-35 минут. Первые 10 минут занимаются введениями и другими вещами.

Учитывая проблему программирования, интервьюер обычно хочет кандидата:

Дайте рабочее решение Придумайте рабочее решение для проблемы. Это может быть решение грубой силы для начала. Критерием состоит в том, что кандидат должен иметь возможность комировать синтаксически правильную программу для алгоритма в этом небольшом временном раме.
Спросите разъяснения вопросов Задавайте вопросы, чтобы уточнить вещи, которые были намеренно оставлены. → Какой размер ввода? → Сколько номеров можно в массиве? → Что такое размер алфавита для данной строки? → Можем ли мы использовать дополнительную память? → Можем ли мы изменять данный ввод или это только чтение?
Синтаксически правильный код После того, как интервьюер убежден в решении, что кандидат описывает, они ожидают, что они будут писать рабочее решение для проблемы. В интервью доске это решение должно быть написано на доске. Whiteboard явно не имеет синтаксической коррекции! Это то, что делает это действительно сложно.
Придумать лучшие решения Если вы представляете только решение Brute Force для интервьюера, чтобы сломать неловкое молчание, они чаще всего не просят вас придумать лучшее решение. Разве это не ваш день удачи, и интервьюер убежден с решением, которое вы предложили?, Вид следующих вопросов, которые они вообще спрашивают: → Можете ли вы придумать лучшее решение? O (logn) → o (n) → Вы можете сделать ваше решение пространства эффективным? O (1) пространство.
Краевые чехлы Даже если вы смогли придумать оптимальное рабочее решение для проблемы, возможно, что вы пропустили несколько краевых чехлов. Возможно, вы пропустили несколько сценариев, которые не меняют алгоритм. Они могут повлиять на реализацию. Ожидается, что кандидат будет делать обширные сухие пробеги с кодом после его написания. Ожидается, что вы попробуете несколько тестовых случаев, чтобы найти любые проблемы, которые они могли бы оставить в их коде.
Анализ сложности Если в вашем интервью еще есть время времени, и интервьюер, кажется, доволен кодом, с которым вы придумали, они могут задать вам о времени и космической сложности вашего решения. Следовательно, анализ сложности также является критическим набором навыка, необходимый для взлома этих программированных интервью.

Да, это действительно подавляющее.

Этот пост на самом деле не о советах и трюках о подготовке и попытки программирования собеседования. Для этого есть много хороших сообщений. Если вы пришли сюда ищете некоторые общие руководства и советы, я хотел бы перенаправить вас на некоторые из моих любимых постов.

5 вещей, которые вам нужно знать в интервью программированию Эта статья предназначена для тех, кто пытается начать свою программирующую карьеру или готовится к интервью для … Medium.freecodeCamp.org 30-минутное руководство по качанию вашего следующего кодирования интервью Как я улучшился в кодировании интервью и получили предложения от крупных технологий компаний. Medium.freecodeCamp.org.

Я недавно столкнулся с проблемой программирования, которую мне пришлось решить в течение 1 часа. Это была часть конкурса программирования, проводимого на Лецкод. Я нашел эту проблему, чтобы быть великим кандидатом, который будет предложенным в интервью программированию. Я подробно пробудую проблему здесь и обсудим свои причины, почему это хорошая проблема собеседования. Я сделаю все возможное, чтобы попытаться связать его до пунктов, упомянутых ранее.

? Давайте играть в змей и лестницы

Этот вопрос был частью недавнего еженедельного конкурса программирования, проведенного на Лецкод Отказ Это 1,5-часовой конкурс с 4 проблемами программирования различных сложностей. Это было отмечено как средняя проблема с трудом. Возможность решить это во время таймфрейма – это большая вещь, поскольку вы будете реализовать после прохождения статьи.

FYI, я не мог?

Змеи и лестницы – лецкод Выровняйте свои навыки кодирования и быстро посадили работу. Это лучшее место для расширения ваших знаний и подготовиться … leetcode.com.

Это большой вопрос, и я определенно призвал вам пройти через него, прежде чем читать.

Часть проблемы, которую я хочу, чтобы вы сосредоточились, является следующая:

Выглядит как типичная проблема динамической программирования

Либо это?

Если вы на некоторое время практикуете динамические проблемы с программированием, он должен быть отсутствием, что заявления о проблеме, аналогичные выше, обычно используют парадигму динамической программирования.

Причина, по которой мы говорим, что это потому, что для решения проблемы разрешимы с использованием динамического программирования, она должна иметь определенные характеристики.

Проблема должна быть разбивается на более мелкие подблемы. Субпроблемы могут быть использованы для решения основной проблемы. Оптимальные решения для подзоров должны помочь нам найти оптимальное решение основной проблем. Это означает, что проблема должна быть разрешима рекурсивно Отказ
Второе самое важное свойство – это то, что Перекрывающиеся подпункты Отказ По сути, какое динамическое программирование делает для нас, заключается в том, что он помогает нам повторно использовать оптимальные решения для подпроблем. Если у нас есть несколько путей рекурсионных путей с перекрывающимися подблемами, мы должны рассчитывать только для них ответы один раз. Затем награды повторно используют их. Это кеширование динамического программирования.

Причина, по которой эта проблема соответствует законопроекту для динамического программирования, является из-за следующих компонентов проблемы:

У нас есть сетка, где у каждой ячейки есть определенный номер. Этот номер может помочь нам определить состояние динамического решения программирования.
В каждой ячейке в сетке у нас есть 6 вариантов доступны. Они представляют 6 ценностей кости, которые мы можем получить на воспроизведение змей и лестниц. Естественно, эти 6 шагов помогают нам перейти от одного государства в другое состояние. Это представляет «Разомок в подпруги» часть требований динамического программирования.
Поскольку мы можем нарушить проблему вниз на более мелкие субпроблемы, у нас уже есть одно требование удовлетворено. Если вы думаете осторожно, можно добраться до одной и той же клетки на сетке несколько раз через разные маршруты. Давайте посмотрим на два возможных способа достижения ценности клетки 22 начиная с 1 Отказ

Путь, а затем проигрыватель в приведенном выше GIF, заключается в следующем:

--> Start at the node marked 1--> Dice value 3, hence move to node marked 4--> Dice value 6, hence move to node marked 10--> Since there was a snake at node 10, move to its head and hence the node valued 22.

Путь, а затем проигрыватель в приведенном выше GIF, заключается в следующем:

--> Start at the node marked 1--> Dice value 3, hence move to node marked 4--> Dice value 5, hence move to node marked 9--> Dice value 5, hence move to node marked 14--> Dice value 3, hence move to node marked 7--> Dice value 5, hence move to node marked 22

Как мы можем видеть из двух путей выше в образце змеи и лестницы сетки, есть два способа достижения узела. 22 Отказ Есть много других способов. Поместите по точке перекрывающихся подбсорблем, два показанные здесь достаточно.

Теперь, когда мы знаем, что одна ячейка определяет состояние нашего динамического решения программирования, и существует множество способов достижения одной и той же клетки, это подразумевает, что наше второе требование к проблеме динамической программирования также удовлетворены I.E. После расчета ответа на данную подпроблему оно не должно быть вычислено снова. Это должно быть просто повторно используется.

Давайте теперь посмотрим формальную динамическую формулировку программирования для этой проблемы.

dp[i] = Minimum number of steps from cell(i) to reach the destination cell.

dp[i] = min(dp[i + 1], dp[i + 2], ... dp[1 + 6])We have to choose the move that gives the minimum number of steps.

Вышеуказанная формулировка выглядит довольно чисто, и мы можем приступить к нему.

Тем не менее, есть большой недостаток в приведенной выше формулировке. ?

Как мы смоделировали нашу проблему, здесь – это то, что будет продолжаться до конца статьи. Итак, давайте сначала определим модель нашей проблемы. Затем продолжайте с описанием недостатка в динамическом подходе программирования.

Графическая модель

Мы можем рассмотреть каждый из клеток в наших змеях и лестнице сетке как узел в графе. Шесть возможных шагов, которые игрок может сделать из данной ячейки представлять края. Эти края – Направленные края. Ход, который берет нас от клетки Я к ячейке J , не обязательно возвращает нас из клетки J к ячейке Я Отказ Итак, для разработки проблемы у нас есть:

График G (V, E)
Каждая клетка в наших змеях и лестницах сетки представляет собой узел на графике. Естественно, есть N² Узлы на графике.
Каждый ход от клетки Я к ячейке J представляет направленный край на графике из узла Я к узлу J Отказ
Поскольку для каждой клетки в сетке у нас не более 6 ходов, это означает, что общее количество ребер на нашем графике будет 6n² Отказ

Давайте рассмотрим небольшую сетку и ее соответствующий график для более четкости.

И соответствующий график для этой сетки будет.

Недостаток в нашей формулировке DP

Теперь, когда мы определили нашу графическую модель для проблемы, мы можем посмотреть на недостаток в нашей динамической разработке программирования. Состав, на котором мы смотрели, было следующее:

dp[i] = Minimum number of steps from cell(i) to reach the destination cell.

dp[i] = min(dp[i + 1], dp[i + 2], ... dp[1 + 6])We have to choose the move which gives the minimum number of steps.

Если в проблеме не было никаких змей, то вышеуказанная формулировка была бы завершена сама по себе. Проблема, вызванная змеями, состоит из петли на нашем графике Отказ Змея может вернуть нас к уже посещенному состоянию на нашем графике.

Проблема, которую создает в нашей формулировке, заключается в том, что мы не можем рассматривать одну ячейку в сетке для определения состояния нашей динамической программированной композиции.

Давайте посмотрим, почему это имеет место с примером, и тогда мы увидим, как решить эту проблему различной формулировкой.

Это одна из возможных маршрутов достижения клетки 36, начиная с исходной ячейки 1.

Предположим, что мы хотим выяснить кратчайшее количество шагов, чтобы взять из ячейки 22 Для достижения целевой клетки 36 Отказ В приведенном выше случае игрок пошел от 1 -> 5 -> 16 (змея вверх!) -> 22. Как мы видим на вышеуказанном рисунке, игрок придет на TH E ячейка 11 из-за змеи. Тогда возьмите на шаг вперед I.e. T o ячейку 12. Наконец, возьмите змею до Destinat Ио n клетка 36. Это всего 1 шаг.

Следуя змею из 22 -> 11 и fr OM 12 - & GT; 36 не очень ход. Фактический ход – от 11 -> 12. Следовательно, минимальное количество шагов, необходимых для m ОВ E FR ом 22 до 36 – 1.

Теперь рассмотрим следующее состояние сетки, когда пользователь достиг этого 22 Отказ

Вышеуказанный сценарий также возможен во время рекурсии. В этом случае, когда игрок достигает клетки 22 У них нет 6 вариантов перед ними. Причина для этого, клетки 22 является отправной точкой для змеи. Если ячейка является отправной точкой для змеи, то она должна сопровождаться его головой. Игрок в конечном итоге посадка в ячейке 11 который уже посетил. Это цикл в нашей рекурсии. Так как мы не можем сделать какой-либо другой переход от ячейки 22 Нет никакого способа выяснить минимальное количество шагов от 22 до 36 Отказ

Проблема в:

Один только клетки не может представлять состояния нашей динамической программирования. Нам также нужно отслеживать клетки, посещаемые до того, как под рукой. Комбинация этих двух будет определять уникальное состояние в нашей формулировке DP.

Обновленная формулировка DP

Обновленная формулировка DP, как уже упоминалось ранее, придется принять во внимание посещаемые клетки и текущую ячейку, на котором находится плеер.

Поскольку состояние динамической программирования, как правило, используется в качестве ключа к кэше, которое хранит результаты для различных состояний ( Memoation ), просто сохраняя словарь или набор посещенных монтажных узлов клеток не выполнен. Эти структуры данных не одновременно одновременно.

Альтернативный подход, который может быть принят, это бит-маскировка. Мы можем использовать битовую маску, чтобы отметить ячейки сетки, которую пользователь уже посетил, прежде чем посещать определенную ячейку.

Давайте рассмотрим, если это даже осуществимый подход к последующим. Итак, для размера сетки 20-BY-20 Было бы 400 клетки, и нам нужна битовая маска 400 биты. Каждое из этих битовых значений будет представлять, если эта конкретная ячейка уже посещена или не во время рекурсии. Поскольку каждый из битов может иметь два разных значения: 0 и 1 , есть 2⁴⁰⁰ Возможные состояния сетки. Умножая его 400, так как нам также нужна текущая ячейка, мы получаем Whopping (2⁴⁰⁰ * 400).

Такое огромное количество возможных состояний не будет работать и вообще не тявлена. Это причина, по которой мы должны двигаться от динамического решения программирования для чего-то другого из-за чистого количества состояний в формулировке проблем.

Ширина первого поиска на спасение! ⛑.

Давайте попробуем сформулировать проблему немного по-другому. Мы уже говорили, что клетки в нашей сети представляют узлы в графе. 6 возможных ходов представляют собой направленные края на другие узлы на графике.

Мы хотим найти минимальное количество ходов достижения пункта назначения, начиная с начальной точки на сетке. Это сводится к Нахождение кратчайшего пути в невзвешенном графике.

Вы можете сказать, что этот график не восстал, либо можно сказать, что все края имеют равные веса. Следовательно, вес можно игнорировать. Нахождение кратчайшего пути в невзвешенном графике – это довольно стандартная проблема. Самый стандартный алгоритм для решения это Ширина первого поиска алгоритм Отказ

Нам не нужно ни одного специального состояния на нашем графике для широты первого поиска, как мы нуждались в случае динамического программирования. Мы определенно можем иметь несколько способов достижения определенного узла из исходного положения. Тем не менее, первый маршрут, который открыт в широко-первом алгоритме поиска, является самым коротким Отказ Это основа для алгоритма.

Это означает, что в первый раз мы сталкиваемся с узлом/ячейкой во время нашего поиска, количество выполненных до тех пор, пока не будет минимальным количеством движений, необходимых для доступа к этому состоянию/ячейке/узлу из исходного положения.

После этого, если мы снова сталкиваемся от того же узла, мы можем просто игнорировать это. У нас уже было кратчайший путь к этому узлу к тому времени. Это гарантирует, что мы не обрабатываем ни один узел графика более одного раза в ширину первого поиска.

Ширина первого алгоритма поиска использует очередь структура данных. Очередь содержит узлы графа на определенном уровне в любой момент времени. Поскольку мы будем обрабатывать каждый узел только один раз, максимально возможный размер очереди может быть O (n). Это верхняя граница по размеру очереди. Этот подход к проблеме очень тявлен и на самом деле является оптимальным способом этого.

Давайте посмотрим на псевдокод для алгоритма, который мы только что предложили для этой проблемы. Тогда мы посмотрим на реализацию для того же.

1. Initialize a queue for the BFS algorithm. Let's call it "Q".2. Add the first cell to the Q. Note that we also need to keep track of the level of nodes in our graph. The level will tell us the minimum number of moves made to reach a specific node. The level for the initial node would be 0.3. Process until the Q becomes empty.    a. Remove the front element of the Q. Let's call it "node".    b. For each of the 6 possible moves from "node", add the ones that have not been processed before, to the Q.4. If we encounter the destination node during the processing, simply return the level value at that point.

Есть много интересных моментов, которые мы должны решить, прежде чем смотреть на реализацию. Это от моей собственной попытки проблемы. Некоторые из них могут показаться слишком простым, чтобы быть упомянутыми. Я хотел поставить все эти случаи. Они важны для того, чтобы вы написали код для этого алгоритма, который мы обсуждали.

Значение клетки для сопоставления строки и колонны?

Первый из этих моментов, которые важно подумать о том, что отображение из клеточных значений к фактическим номерам строки и столбцами.

Помните, нам дают сетку некоторых значений, и каждая клетка сетки имеет нуждающийся. Система нумерации написана Бустрофедонически Снизу, начиная с левой нижней части доски, и переменное направление каждая строка.

То, как реализация была сделана здесь изначально, считает фактические номера строк и столбцов, а затем как-то используя их для прогресса в сетке.

Согласно проблеме, если ячейка содержит змею, то значение в этой ячейке является ячейкой назначения, где проигрыватель приземляется. Нам нужно сопоставить значение адресата назначения к соответствующей строке и номеру столбца.

Движение для ряда всегда легко. Мы либо перемещаемся в разных столбцах в том же строке, либо мы можем переместить одну строку вверх. Это все для ряда.

Что касается столбца, существует два возможных направления движения. Вопрос особенно сложно. Нумерация клеток чередуется от одного ряда к другому. Движение в ряду ряд (для различных шагов) также будет иметь переменные направления в чередующихся строках E.g. для 6-BY-6 Сетка, движение будет вправо для нижнего ряда, и он будет слева во втором последнем ряду.

Для 6-BY-6 Матрица, ряд номер 5 (Учитывая на основе 0-й индексации матричных рядов и столбцов) будет единственным содержащим клетки из 1 .. 6 и номер ряд 4 будет содержать клетки из 7 .. 12 Отказ

Это означает, что для даже пронумерованных рядов направление слева. Для нечетных рядов направление справа. Тем не менее, это сопоставление возвращается, когда N нечетно. Рассмотрим сценарий в 5-be-5 матрица

Последний ряд в этой матрице это 4 И эта строка имеет направление справа. Это означает, что в этих случаях даже пронумерованная строка имеет направление справа. Нечетная строка имеет направление слева.

Реализация Мудрый, мы можем использовать что-то вроде следующего.

even_direction = 1 if N % 2 != 0 else -1direction = even_direction * (1 if row % 2 == 0 else -1)

В нашей реализации мы рассмотрим ценность 1 для направления справа и значения -1 для представления направления слева. Причиной этого является простота, которую она вызывает в моделировании движения. Мы можем просто сделать что-то вроде:

for move in range(6):     new_cell = cell[r][c + direction]

C + направление будет либо идти к праву или налево. Это потому, что значение направление будет либо быть 1 или -1 в зависимости от стоимости N Отказ

Теперь мы можем посмотреть сопоставление сотовой ценности до соответствующей строки и индексов столбцов.

Обратите внимание, что следующий код должен быть выполнен только при нахождении змеи в одном из ячеек. Доска [ROW] [COL] будет содержать -1 представлять обычную ячейку. Следующий код выполнен, когда найден змея I.e Доска [ROW] [COL]! = -1

(1) value = board[row][col](2) snake_dest_row = N - (value / N) - 1(3) new_direction = even_direction * (1 if snake_dest_row % 2 == 0 else -1)(4) snake_dest_column = (value % N)                        (5) if new_direction < 0:(6)    snake_dest_column = N - 1 - snake_dest_column                        (7) next_cell = (snake_dest_row, snake_dest_column)

Линия 1

Дает нам значение, хранящуюся на текущей ячейке. Текущая ячейка представлена ряд и Col Отказ

Линия 2.

Используя значение, хранящееся в ячейке, мы находим строку, где эта ячейка будет расположена. Помните, что значение представляет ячейку, нам нужно переместить игрока, так как они столкнулись с змеей.

Линия 3.

Поскольку мы выяснили ряд, где будет расположена новая клетка (адресата назначения), мы также можем понять направление клеток в этом конкретном ряду. Мы обсудили направления справа и осталось в зависимости от стоимости N, выше.

Линия 4, 5 и 6

Представляет смещение для выяснения значения столбца. Для ряда, который имеет направление, идущее вправо, сам смещение будет представлять индекс столбца. Если направление слева, то смещение будет справа. Мы находим индекс столбца, используя N - snake_dest_column - 1 Отказ

Проблемные значения клетки?

Как упоминалось ранее, клетки либо содержат -1 Или они содержат змею. То, как представляется змея – это значение клетки, которое представляет собой ячейку назначения, которую игрок достигнет, следуя этой змеи.

Таким образом, при обращении с футляром змеи мы должны быть в состоянии получить номер строки и столбца, где будет находиться соответствующая ячейка.

Мы видели в предыдущем разделе, как мы можем это сделать. Однако в коде есть небольшая ошибка.

Рассмотрим сценарий, где у нас есть 4-BY-4 сетка. Особая ячейка содержит змею, которая берет игрока, чтобы (или чей элементу назначения) 8 Отказ Давайте посмотрим соответствующие значения строки и столбца, которые мы получаем, используя код выше.

value = 8even_direction = -1snake_dest_row = 4 - (8 / 4) - 1 = 1new_direction = -1 * (-1) = 1snake_dest_column = 8 % 4 = 0

next_cell = (1, 0)

Очевидно, что это не правильная клетка. Правильная клетка, представляющая значение 8 это (2, 0) И нет (1, 0) Отказ То, как мы исправим это, не рассматривая значение, как это, но вычитание 1 от него. Тогда эта проблема не возникает.

value = board[row][col] - 1

Сделать один шаг за змею?

Одним из последних важных компонентов реализации является придерживаясь правила, упомянутому в заявлении о проблеме, в котором говорится, что «вы берете только змею или лестницу максимум один раз за шаг». Если пункт назначения на змею или лестницу – начало другой змеи или лестницы, Вы не продолжаете двигаться Отказ

Путь BFS работает, мы обрабатываем узел в настоящее время из очереди, глядя на свой список соседних. Затем рассмотрите все узлы, которые еще не обрабатывали, а затем добавьте их в очередь.

Итак, для данной клетки было бы 6 соседних узлов. За исключением некоторых случаев, когда это невозможно иметь 6 ходов во всем. Мы должны рассмотреть все их и добавить, что они еще не обрабатываются в очередь.

Для перемехов не требуется никакого специального обращения в клетки, которые не содержат змеи. Итак, все, что мы делаем в этом случае, это:

if board[row][col + direction] == -1:    process it normally

В случае, если шаг мы делаем, земли нас со змеей, вместо рассмотрения/обработки узла, в котором мы находимся после хода, мы рассмотрим целевую клетку змеи и добавляем ее в очередь, если она не обрабатывалась раньше. Давайте рассмотрим пример для этого.

Как вы можете видеть на рисунке выше, мы не учитываем узел 4 при обработке 6 ходов, соответствующих ячейке 1 Отказ Вместо этого мы рассмотрим возможное место для 4 I.E. 11 Отказ

Если предположить, что была змея от 11 До некоторого другого узла, то мы не будем обработать это. Мы уже обработали одну змею переход от 4-11 Отказ Здесь не может быть продолжение змеиных ходов. Это важно отметить.

Давайте посмотрим на реализацию, которая приносит все эти идеи вместе.

Можем ли мы избавиться от «направления»? ?

Оказывается, есть более простой способ сделать то, что выполняется, используя dash_direction переменная выше.

По сути, мы хотим знать, учитывая номер строки, в чем в нем направление клеток. Это вправо или к левому?

Причина, по которой нам нужна эта информация, потому что это помогает нам решить последний номер столбца, когда мы сталкиваемся с змеей.

Вместо того, чтобы полагаться на dash_direction Переменная, мы можем использовать простую проверку, как следующее:

if N % 2 != row % 2:   direction = rightelse   direction = left

Это охватывает все дела для нас. Помните, направление для ряда зависит от значения N Отказ

N даже и ряд даже, тогда N% 2% 2 И, следовательно, направление будет к левый Отказ
N даже и ряд странно, то N% 2% 2 И, следовательно, направление будет к правильно Отказ
N нечетно и ряд странно, то N% 2% 2 И, следовательно, направление будет к левый Отказ
N нечетно и ряд даже, тогда N% 2% 2 И, следовательно, направление будет к правильно Отказ

Спасибо Divya Godayal за то, что предложил этот упрощенный чек. Это определенно сокращает длину кода и охватывает все вышеперечисленные случаи. Ваше здоровье!

Сопоставление наоборот

В приведенном выше реализации мы работали с номерами строки и столбцов. Затем сопоставило со значением клетки до номера ряда и столбца, когда требуется (в случае змеи). Мы также можем решить эту проблему, работая наоборот.

Вместо этого гораздо проще работать с номерами ячейки. Начиная с 1 И для каждой клетки мы должны рассмотреть следующий 6 клетки.

Все, что нам придется сделать, это тогда набрать эти значения клетки соответствующим ряд и Колонка Числа (опять же, чтобы проверить наличие или отсутствие каких-либо змей). Мы уже видели, как это сделать в приведенной выше реализации.

Это сокращает код. Решение, которое я объяснил выше, это тот, с которым я придумал, думая о проблеме. Я хотел объяснить это так, как это сделать все яснее. Это может быть не лучший способ отправиться в написание кода для алгоритма описания. Это помогает описать все предостережения.

Почему опять это проблема лучшего программирования?

Вы можете быть записаны на динамическое программирование на основе решений (как я?). В таком случае вам нужно рассуждать и выйти из этой лазейки. DP не работает здесь.
Придумываясь с подходом на основе BFS, здесь является супер критический. Нужна хорошая хватания алгоритмов на основе графика. Важно отображать проблему на Нахождение кратчайших путей в невзвешенном графике.
Написание кода для сопоставления значений ячейки к соответствующей строке и номерам столбцов могут быть супер запутаны, особенно в течение временных ограничений. Это не большой кусок кода, но вы должны быть в состоянии подумать об этом правильно.
Обработка краевого корпуса, когда мы получаем неверное отображение, если мы рассмотрим значения клетки, как оно есть. Нам пришлось вычесть 1 из целлюлозного значения, прежде чем отображать его до соответствующей строки и столбца. Невыполнение этого приведет к неверным результатам.
Написать правильный, рабочий код во время ограничения времени также является жесткой задачей. Вам действительно нужно держать свой крутой.

В целом эта проблема проверяет много различных аспектов программирования и мышления, способности программиста. Я чувствую, что это один из самых важных аспектов для тестирования во время таких интервью.

Не то чтобы эти интервью – лучший способ нанять кандидатов. Поскольку они существуют, эта проблема выявляет много различных качеств, которые интервьюеры ищут в кандидатах.

Если вы нашли статью, чтобы быть полезной, поделитесь этим как можно больше?

Оглавление