Python developer собеседование с задачей уровня хард из Яндекса . Ян Желанов

t.me/KZbinPronin
Чат для общения pyhton разработчиков и им сочуствующих. Свободное общение, тестовые и вопросы с собесов и прочее. Заходите, там вам рады.
Поддержать канал: www.tinkoff.ru/rm/pronin.andr...
Обычно денежка идёт на книжки про питончик. Но иногда на светлое и тёмное.
Виш лист
Хорошие книги по Питончику, которые могу рекомендовать (и хочу купить с вашей помощью).
Знакомство с Python | Бейдер Дэн (2023) - выглядит приятно для новичка
Чистый Python. Тонкости программирования для профи | Бейдер Дэн (2022) - хорошо для продолжения
Высоконагруженные приложения. Программирование, масштабирование, поддержка | Клеппман Мартин
Изучаем Python. Двухтомник. Марк Лутц. Очень подробно и структурно (Хочу дождаться 6го издания.. )
• Изучаем Python с Марко...
Читаем и разбираем ее тут
Куплено (огромное спасибо зрителям)
Python. К вершинам мастерства | Рамальо Лучано - 2е издание - сложно для новичка, но интересно
Паттерны разработки на Python: TDD, DDD и событийно-ориентированная архитектура -- хорошо про то, когда какой фреймворк применять
Видимо, дальше появтся еще нескромные желания. Но пока - так
Моя тележка andpronin -- стучите, если что.
Мой канал про обучению python с нуля и до мидла Андрей+=Пронин
/ @pypronin
Я в других сетях
🔗Вконтакте: CaptPronin
🔗Дзен: zen.yandex.ru/id/5fbd33919412...
#python #питон #программирование #Андрей_Пронин #собеседование #ЯнЖеланов

[@TheRunnerSVO]

А где задача уровня хард?)))

[@user-hb6lt3bt3d]

За день до собеса посмотрел это видео, попалась задачка с квадратами. Так что спасибо за контент=)

[@AndyPronin]

затянул?

[@rrrrr5042]

@@AndyPronin надо спрашивать: задонатил? 🤣

[@AndyPronin]

@@rrrrr5042 то дело добровольное)

[@sb9185]

@@user-tg4pb7uy5dскорее всего как первая

[@Kotemur1]

В первом решении нужно перед поиском индексов left и right первоначально присвоить их в 0 и len-1 соответственно, иначе в случае массивов, состоящих либо только из положительных чисел, либо отрицательных, эти индексы не присвоятся и всё будет плохо.

[@user-zs5dl2un7c]

В первой задаче можно было отрицательные числа в stack (LIFO) засунуть и сравнивать модуль или квадрат числа с числом или квадратом числа исходного массива, если число в стеке меньше то его выводить, а потом число исходного массива.

[@devpops3393]

а че не так с sorted?

[@freesx1306]

@@devpops3393 Вычислительная сложность алгоритма будет выше, чем методом двух указателей

[@alexkochevnicke5122]

@@freesx1306 а никто же задачу такую не ставил. Поэтому сначала можно sorted выходной список вернуть. Зачем на этом этапе усложнять?

[@freesx1306]

@@alexkochevnicke5122 ну все задачи на собеседовании в Яндекс требуют оптимального решения. Поэтому и надо усложнять. Даже если ты напишешь с sorted,то тебя спросят: а как улучшить?

[@vladkv2002]

Первую как-то сложно решали. Можно было 2 указателя: один с начала идет, второй с конца и результирующий массив заполнять с конца. Вторая интересная. С ходу придумал только за О(k*log + n*logk) + O(k) место.. Когда упомянули деки, то дошёл до O(n) + О(k) место. И вопрос: а как можно на такое жесткое собеседование попробоваться подопытным кроликом? =)

[@AndyPronin]

Если студент практикума - то через трудоустройство. Если нет - будет розыгрышь среди подписчиков в телеге t.me/KZbinPronin

[@tahirrasuljanov7770]

Брат, где ты учился? Я даже после того как он решил еле как понял😭

[@wheatfrog9447]

@@tahirrasuljanov7770 мне кажется он не понял условие задачи и решил слишком сложно когда можно было сделать гораздо проще. Может я чего-то не понимаю, но у меня всё решение заняло буквально 6 строчек....

[@user-ks7jf7pw8l]

@@wheatfrog9447 скинь решение

[@shakirkhakimov4310]

@@wheatfrog9447 my_list = [3, 4, 5, 8, 2, 3, 1] for i in sorted(my_list): print(i ** 2)

[@user-ih9tu1kn7i]

Задача 1: def solution(array: list[int]) -> list[int]: right = len(array) - 1 left = 0 result = [] while left array[right]: result.append(array[left] ** 2) left += 1 else: result.append(array[right] ** 2) right -= 1 return result[::-1]

[@AlexeiGoncharov-gq8dm]

У вас ошибка при сравнении. Сравнивать квадрат с обычным числом справа. Так же в конце идёт reverse, что добавляет сложности. Я бы делал через deque с appendleft.

[@user-ur9ll9zs5d]

В первой задаче похоже ошибка. Если в массиве нет отрицательных чисел, то в первом цикле for границы (left и right) не получат никакого значения, поэтому в следующем же цикле while появится ошибка: local variable 'left' referenced before assignment. Например в самом начале функции можно обозначить границы для таких краевых случаев : length = len(arr) plus = 0 minus = 0 for i in arr: if i >= 0: plus += 1 else: minus +=1 if plus == length: left = -1 right = 0 elif minus == length: left = length -1 right = length

[@Ilja600]

Добрый день, решение по сортировка показалось мне слишком мудреным, решил вроде как проще и понятней, тоже o(n): left_index = 0 #Индекс первого элемента right_index = len(array)-1 # 0 #Индекс последнего элемента result = [] while left_index right_number: #Если левое число больше правого result.append(left_number**2) # то добавляем в результат его квадрат left_index+=1 # Увеличиваем левый индекс else: result.append(right_number**2) #Иначе берем правое число right_index-=1 # И уменьшаем его индекс result[::-1] # Инвертируем Однако вариант sorted([number**2 for number in array]) все равно быстрее, можете объяснить почему?

[@ivanabdullaev859]

Почему у интервьюируемого губы не накрашены? Непорядок, не труъ девелопер.

[@user-nr6ey5iv6z]

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

[@ivanabdullaev859]

@@user-nr6ey5iv6z Чувак, вайтишники должны видеть до чего ИТ доводит)

[@user-bv7rl9mo9t]

Жестко, но интересно, Ян молодец.

[@user-wj3me9oy7w]

Если знак минус убрать. Допустим массив [-5, 1, 4, 5] . То получится 5, 1, 4, и снова 5?

[@slyjpg]

Доброго дня всем! Вопросик по первой задачке) Почему её нельзя решить простой строчкой типа: sorted([i*i for i in list_test]) Или пользоваться данной функцией в решении запрещено?

[@denisbalyasnikov7185]

Можно, но тогда получится сложность nlogn + n, а хочется решить просто за n (благо исходный массив уже отсортирован)

[@slyjpg]

@@denisbalyasnikov7185 благодарю за ответ! 🙏

[@justpochta]

К тому же i*i вернет положительное число в случае входящего отрицательного

[@hellgap.5185]

@@denisbalyasnikov7185 зато sort отработает в любом случае быстрее, чем любой велосипед на питоне, т.к. у него плюсы под капотом

[@user-cw1ll2bi7n]

​@@denisbalyasnikov7185 так у тебя сложность алгоритма будет меньше, но на практике, у компьютера уходит больше времени на само создание функции. Проверено!😊

[@josemaldia]

Добавьте таймкоды. Где первая задачка, где вторая. И готовые решения.

[@fredbagi7552]

А lambda использовать и map пройтись , как вариант во второй задаче, если конечно нужен Python

[@davgf438]

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

[@davgf438]

@@slava_zxz Скоро будет 6 месяцев. Сейчас заканчиваю продвинутый синтаксис Питона, прошел основы SQL (Postgre, ещё хочу другую реализацию), основы html+css, и теоретическое введение в ООП. Сейчас хочу переходить к практике ООП и Джанге.

[@davgf438]

@@slava_zxz удачи нам в этом деле! Главное не терять мотивации

[@heybeachMIN]

@@davgf438 а вы делали какие-то пет проекты?

[@davgf438]

@@heybeachMIN ещё нет. Первый будет параллельно с изучением джанги. Ориентировочно через месяц. Ну и несколько ботов ещё хотел сделать, однако для них тоже нужно вникать в библиотеку.

[@heybeachMIN]

@@davgf438 А кроме ботов, какие Вы планируете делать пет проекты? Я слышал, что создание какой-нибудь соц сети очень хороший может дать плюс при трудоустройстве... Но, наверно, это чертовски сложно и долго плюс знания фронтеда нужно, скорее всего. Вообще, я только почти закончил курс на степике Поколение python: начинающие, так что мне далеко до Вашего уровня, но всё равно заранее интересно знать, какие люди делают пет проекты.

[@Misha-775]

Прикольное собеседование, погоняли по классическим алгосам) В последней, кстати, я подумал, нужно как-то извернуться, и придумал пару решений через рекурсию. "Разделяй и влавствуй", типо) Но не факт, что они в среднем сильно эффективнее обычного "в лоб" за O(n)

[@denisbalyasnikov7185]

Если что, в Python GIL - это и есть, по сути своей, mutex, который контролирует доступ к состоянию процесса интерпретатора. Многопоточный код писать на Python еще как можно, если он касается задач ввода/вывода. Оба героя плавают в этой теме, только один уверенно, а второй нет)

[@eurodoo]

цикл событий выполняется в одном потоке поэтому можно поподробнее о том как написать многопоточный код для задач ввода вывода?)))а то создатели питона не в курсе еще что оказывается есть такой гений который может))

[@eurodoo]

Вы написали многопоточных кол на питоне писать ещё как можно если он касается ввода вывода) 1.какой смысла писать ввод вывод с использованием многопоточности впринципе если асинхронщина в один поток отработает быстрее, далее он все равно не будет истинно многопоточным потому что gil)))

[@denisbalyasnikov7185]

@@eurodoo Ещё рекомендую все же разобраться как работают потоки в Python. Там создаются настоящие такие posix потоки ОС, которые успешно будут работать параллельно в случае ввода/вывода, потому что будут "отпускать" GIL. Что имеет смысл делать, а что нет - это вопрос другой. В технологиях все-таки нужно разбираться, однажды это спасает жизнь)

[@eurodoo]

@@denisbalyasnikov7185 что что они отпускают Гил, когда они его отпускают они не работают, а "ждут" загуглите эффект конвоя, у вас будет реальная многопоточность только если библиотека си которая используется написана питоном не блокирующуя например sha256))

[@denisbalyasnikov7185]

@@eurodoo Даже не представляю как бы мы жили, если бы поток после освобождения GIL больше ничего не делал, кроме как ждал. Эффект конвоя относится только к моменту, когда поток пытается снова захватить GIL, чтобы получить доступ к состоянию интерпретатора. Вы путаете много понятий. Обсуждение есть смысл продолжать после четкого понимания: 1. cpu-bound vs io-bound operations; 2. blocking vs non-blocking operations; 3. cooperative vs preemptive multitasking; 4. greenlets vs threads; 5. Раздел документации "Thread State and the Global Interpreter Lock" Очень надеюсь, что эта переписка будет кому-то полезна, и время на нее было потрачено не зря)

[@user-ku8sk7hz7t]

1 задача def foo(arr): return list(map(lambda x: x**2, filter(lambda x: (type(x) is int) if x > 0 else False, arr)))

[@he1vann-42]

ох уж этот синдром питониста, решать все в 1 строку

[@user-ur3mc6hb5d]

Решение на С++ с декой, которое я использовал. Я проверил пустой ли массив, если да, то вернуть пустой массив. Иначе я добавил в очередь квадрат нулевого элемента массива Потом по циклу проходил с первого элемента до конца. Если квадрат i больше элемента в конце очереди, то я добавлял его в конец. Иначе я добавлял в начало. Потом скопировал элементы деки в массив и вернул его vector array_squares(vector& nums) { deque qe; vector result; if (!nums.empty()) qe.push_back(pow(nums[0], 2)); else return {}; for (auto i = nums.begin()+1; i != nums.end(); i++) { if (pow(*i, 2) > qe.back()) qe.push_back(pow(*i, 2)); else qe.push_front(pow(*i, 2)); } copy(qe.begin(), qe.end(), back_inserter(result)); return result; }

[@user-ur3mc6hb5d]

Это решение получилось компактнее, чем первое, но по памяти заняло больше

[@user-kt2kb6pb7l]

Всем здравствуйте. Почему нельзя было в первой задаче использовать sort() списка после возведения в квадрат ?

[@user-rm1re5xd1j]

Потому что таким образом сложность высокая

[@videoproizvodstvokino]

А chat gpt 4 уже проходил собес ?

[@usernoname-wv6of]

А такое решение второй задачи как воспринимается?) Если 1 элемент в окне, то возвращает сам входной массив. Если 2 и более чисел, то возвращает максимум из окна, оставшийся кусок массива отдает на функцию через рекурсию, пока не останется 1 элемент. def max_in_scope(array, k): if len(array) < 2: return array else: res = [] res.append(max(array[:k])) res.extend(max_in_scope(array[k:], k)) return res Первое, что пришло в голову

[@Ilja600]

По моему его решение с квадратами не работает правильно и работает дольше sorted(...)

[@user-cf9yl8fy5p]

Всем привет! Подскажите первую задачу можно было бы решить в одну строку по типу (return sorted([abs(num) ** 2 for num in array])? Это было бы правильным алгоритмом?

[@brossen392]

Это был бы рабочий алгоритм, но временная сложность у него O(N^2). На больших данных можно не уложиться по времени выполнения программы. Оптимальный алгоритм у этой задачи имеет сложность O(N)

[@user-ru2gn4uw4z]

@@brossen392 а можете подсказать, почему N**2? Насколько я вижу - сложность сортировки NlogN ну и сложность формирования самого массива N - Итого 2N * LogN - отбрасываем константы выходит N LogN Можете подсказать как получилось N**2?

[@brossen392]

@@user-ru2gn4uw4z я просто не был уверен какая сложность у встроенной сортировки, ошибся

[@roman88469]

Еще abs() убрать, там же квадрат

[@Bibliophilos]

Уровня хард литкода последняя задача ) на открытии Яндекс.Тренировок по алгосам сказали, что задачки «с легким налётом мидл» попадаются на собесах)))

[@novoidx4322]

медиум, не выше

[@whatistypescript4280]

​@@novoidx4322 вторая задача хард

[@user-vg6pj8gy4p]

Жостко

[@StrikerNSK1]

Так что там за проблема с GIL? Почему её нельзя решить?

[@Bibliophilos]

Ссылки тут не дает ютуб вставить. Погуглите про Бизли и ГИЛ.

[@StrikerNSK1]

@@Bibliophilos нашел большую статью на Хабре. Но можно простыми словами, для человека, который ещё даже на джуна не претендует?

[@Bibliophilos]

@@StrikerNSK1 GIL отпускает блокировку и отдает ОС операции ввода/вывода, плюс может некоторые функции на С языке выполнять в многопоточном режиме без блокировки. Вычисления компьютерные в основном распараллелить с джилом нельзя, потоки начинают ждать переключения поочередно и в итоге последовательный однопоточный код быстрее выполнит вычисления. Я не профи здесь, лучше почитать статейки.

[@user-bc1yc8hb9v]

@@StrikerNSK1 Сборщик мусора автоматом убирает ненужные данные, у данных есть ссылки, и без gil может случиться такое, что нужные данные удалятся, потому что не будет никто ссылаться в одном из потоков, вроде из-за этого

[@andreifedorov4950]

Ребята, извините, а по первой задачке так сделать нельзя было: arr = [-5, 1, 2, 3] squared_arr = [x**2 for x in arr] sorted_numbers = sorted(squared_arr, reverse=False) ?

[@rzhek9541]

Сложность будет O(nlogn)

[@altkun_]

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

[@alexandroppolus]

я решал где-то полгода назад, сделал с помощью стека максимумов, это прям первое что приходит в голову, если знать про очередь на двух стеках.

[@user7962]

Вторая задача Hard на leetcode: Sliding Window Maximum

[@grandnevert746]

Может я не понимаю условие, но почему нельзя быстро решить 1-ю задачу, просто добавив sorted к return. Тоесть: return sorted([number * number for number in array])

[@ZUKHOS1]

Будет сложность n*log n (так как сортировка столько работает) А надо за n сделать

[@RomanTchekashov]

Первая задача не будет работать, если на вход передать массив состоящий из отрицательных чисел. Мое решение на javascript: function getSortedIntArrayWithSquaredValues(sortedIntArray) { const result = new Array(sortedIntArray.length); let left = 0, right = sortedIntArray.length - 1, resultCurrentIdx = sortedIntArray.length - 1; while (left Math.abs(sortedIntArray[right])) { result[resultCurrentIdx--] = sortedIntArray[left] * sortedIntArray[left] left++; } else { result[resultCurrentIdx--] = sortedIntArray[right] * sortedIntArray[right] right--; } } return result; }

[@user-hq9xf9fh1v]

Решение второй задачи с помощью очереди - О(n) - идея в том, чтобы при движении окна постоянно поддерживать максимум в начале очереди if k == 1: return nums queue, ans = deque(), [] for i in range(len(nums)): if queue and queue[0] < i-k+1: queue.popleft() while queue and nums[i] > nums[queue[-1]]: queue.pop() queue.append(i) if i >= k-1: ans.append(nums[queue[0]]) return ans

[@nikolayveselovwp793]

А с каких пор добавление и удаление из очереди стало работать за 1?

[@user-ur3mc6hb5d]

​@@nikolayveselovwp793оно всегда было за O(1). Очередь сама по себе урезанный двусвязанный список. А в связанном списке добавление и удаление всегда работает за константное время. Так как в списке не нужно реаллочить память из одного участка памяти в другой, чтобы расширить или уменьшить список. Добавление в очередь происходит за счёт создания новой ссылки на новый элемент и связывание его с первым или последним элементом. Удаление работает точно также, но наоборот. Единственное, когда в списке(в очереди) происходит добавление за О(n) - это добавление или удаление в диапазоне от 1(не включительно) до последнего(не включительно)

[@nikolayveselovwp793]

@@user-ur3mc6hb5d да, извиняюсь, я почему то вместо очереди прочитал куча…

[@zebraturner7103]

А что если array = (90, 89, 87, 86, 85 etc)

[@maximbka4083]

numbers = [0, 2, 4, 6, 8, 10, 1, 3, 5, 7] k = 3 b = [] c = 0 d = [] for i in range(len(numbers)): b = numbers[i:k + i] c = max(b) d.append(c) if numbers[i:] == numbers[-3:]: break print(d) я так сделал, правда занимаюсь программированием недели 3-4

[@user-fy2wd3tk5n]

попробовал решить вторую задачу через деку и с минимальным обращением к мах(deq) в случае с большим k. пересчитывать max() по всей деке придется только в 1 случае из k. def frame(lst, k): from collections import deque result = [] de = deque(lst[0:k]) max_v = max(de) result.append(max_v) for i in range(k, len(lst)): val_l, val_r = de.popleft(), lst[i] de.append(val_r) result.append(max_v := max(de) if val_l == max_v else max_v :=max(max_v, val_r)) return result а первую задачу решал так def quad(lst): n = len(lst) l, r, result = 0, n-1, [0]*n lval, rval = lst[0]**2, lst[n-1]**2 for i in range(n-1, 0, -1): if rval > lval: result[i] = rval; r -= 1; rval = lst[r]**2 else: result[i] = lval; l += 1; lval = lst[l]**2 result[0] = rval return result

[@user-wf3gg8tz7z]

Во второй задаче, если будет массив из одинаковых/убывающий, например [2, 2, 2, 2, 2, ... , 2] или [5, 4, 3, 2, 1, ..., -100000] -- будет O(n*k) т.к. будешь каждый раз максимум пересчитывать

[@seoonlyRU]

хард))) лайк от СЕООНЛИ!

[@patricross8683]

a = [1,2,3,4,5] temp = [] for i in range(len(a)-2): temp.append(max(a[i:i+3])) print(temp) подойдет ли на 2-ой задаче?

[@runneso]

Сложность O(n*k) , поэтому не подойдёт

[@Lippaaa7596]

​@@runneso а вот такой ответ для 2 задачи подойдёт a=[2,5,1,3,8,9] k = 3 g = 0 while g < 4: print(max(a[g:k+g])) g+=1

[@Lippaaa7596]

​@@runneso и что это вообще за сложности как понять какая сложность?

[@runneso]

@@Lippaaa7596 та же самая сложность O(n*k), поэтому нет

[@_qdrx]

@@Lippaaa7596 читайте про Big O notation

[@user-bc1yc8hb9v]

задача на монотонность, где не надо смотреть возрастает, убывает или вообще из одного числа состоит, идем с 1 по предпоследнее число и сравниваем разницу(вычитание) с некст числом, если есть вычитание больше и меньше нуля то не монотонна pozitive = negative = False for i in range(n-1): dif = array[i] - array[i-1] if dif > 0: pozitive = True elif dif < 0: negative = True if pozitive and negative: print(' ne monotona') break

[@user-bc1yc8hb9v]

@Константин а первый элемент тоже надо проверять, так что с нуля

[@user-bc1yc8hb9v]

@Константин вы не поняли идею алгоритма, мне кажется)

[@user-bc1yc8hb9v]

@Константин =)

[@tertiumorganum5665]

первая кст - Squares of a Sorted Array на LC

[@user-of-world]

Берём 1 элемент массива, умножаем на самого себя. Есть до операции умножения он был меньше 0, то полученый результат - умножаем на - 1.

[@user-cw1ll2bi7n]

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

[@dimkas4284]

мб я не эксперт или что-то прослушал, но в первой задаче говорилось заранее, что список отсортированный, то есть на выходе ты вернешь такой же отсортированный список, если будешь просто по массиву циклом идти, но тогда вопрос, почему нельзя просто проверить каждый элемент на то, что он меньше нуля? Допустим : nums = [-9, -5, -2, 1, 2, 3, 4] arr = [] for i in nums: if i < 0: arr.append(-(i*i)) else: arr.append(i*i) print(arr)

[@SparePant]

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

[@dimkas4284]

@@SparePant уже формулировку задачи не помню) что там требуется?

[@valeriyv1073]

Это не сложные задачи. Первая - простая, если не считать, засады с отрицательными числами. Вторая - скорее средней сложности. Сразу на ум приходит max heap, O((n-k)*log(n)) ? Надо больше решать литкод. А с деком, да, это по моему monotonic stack называется на литкоде или что то близко

[@hash510]

да сразу ясно что в первой задаче подвох в том что отсортированный ввод может содержать отрицательние, ну и квадраты уже не будут отсортированы по умолчанию.. Роль дающего таски - это как маг 189 уровня: когда ты эту таску уже во сне видишь а испытуемый как молодой бобик - аж трясется от адреналина

[@7IdE]

Классный собекс. Когда человек вот так вот пишет код и продумывает свои действия - это прям бальзам на душу такое смотреть. Однако я так и не понял: он на какой грейд претендует? А то Руслан сказал, мол, "...на джуна подумают" - т.е. он на мидла и выше претендовал по собесу?

[@ruslansitdikov7145]

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

[@7IdE]

@@ruslansitdikov7145, в общем, в Яндекс можно даже не пытаться попасть. :D

[@7IdE]

@Константин, ну, хз. Если требование для прохождения - вот такие вот задачи, которую нужно решить оптимально за час - то вообще хз. Я бы еще понял, если бы было все из разряда "не важно - решил или нет, нужно было просто посмотреть на то, как мозги работают", но Руслан сказал, что нужно именно решить. И я вот вообще хз, насколько реально решить такую задачу за час, если видишь ее впервые. Да, если уже решал - другое дело. Но тем не менее.

[@7IdE]

@Константин, так-то никаого другого смысла, кроме того, что твои племянники шарят в алгосах, тут речи не идет.

[@TheRunnerSVO]

Тут уровень стажера даже не тянет 😁

[@user-hq3wz4vk7q]

Минут за 10 решил последнюю задачу , но код очень корявым у меня получился (

[@user-hq3wz4vk7q]

def search_max(array: list[int], k) -> list[int]: n = 0 lst_real = [] lst = [] for x in array: if n == k: lst_real.append(max(lst)) lst = [] lst.append(x) n = 0 else: lst.append(x) n += 1 lst_real.append(max(lst)) return lst_real

[@AndyPronin]

Огонь, если получился

[@user-do3zm3vp2f]

Решение первой задачки со сложностью O(n) arr := []int{-11, -10, 3, 4, 5, 6, 7, 8, 9} result := make([]int, len(arr), len(arr)) count := 0 for i := 0; i < len(arr); i++ { if arr[i] < 0 { result[len(arr)-1-i] = arr[i] * arr[i] count++ } else { result[i-count] = arr[i] * arr[i] } } fmt.Println(result)

[@user-vc2pk7qn5q]

Решение неправильное. Например, если заменить -10 на -2, итоговый массив будет [9, 16, 25, 36, 49, 64, 81, 4, 121]

[@emurze-nx7xh]

Task 1: Как я понимаю это О(n) + O(n) def main(_array: list[int]) -> list[int]: _array = copy.deepcopy(_array) return sorted(x*x for x in _array)

[@tygchjj]

Сортировка занимает nlog(n) и обход по списку n. В итоге n+nlog(n)

[@Viacha-wo3lb]

максимум на окне можно решить двумя стеками из пар. Я заполняю первый стек, пока он не размера k, заполняю скмим числом, и минимумом на префиксе . Далее я все элементы этого стека перекидываю во второй, пересчитывая новые минимумы от обратной стороны, теперь элементы в обратном порядке,, т. е сверху-первый(0) элемент массива. Теперь я начинаю опять заполнять первый стек, удаляя при этом элемент из второгг, я легко могу вычислить минмум на окне, это будет минимум из двух минимумов сверху стеков. Ну и повторяю это, пока не пройдусь по всему массиву

[@mikhailturasov9593]

По первой задаче пришла такая идея arr = [-5, -3, 0, 0, 2, 2, 6, 9] arr_res = [] i = len(arr)-1 j = 0 while len(arr) != len(arr_res): if (arr[i] ** 2) >= (arr[j] ** 2): arr_res.append(arr[i] ** 2) i -= 1 else: arr_res.append(arr[j] ** 2) j += 1 print(arr_res) немного покомпактнее

[@skeam9988]

Слишком много кода

[@mementomori6005]

Отличный собес с ушками =) очень позитивно, не хватает такого, а то все(большинство) как люди роботы сидят, жестко)))

[@AndyPronin]

Ян, вообще, аеселый

[@Kirill_rus_]

Ещё юбочку добавить и губки накрасить. Тьфу, что становится с мужиками...

[@mementomori6005]

@@Kirill_rus_ много бы я тебе ответил на это да думаю без толку это будет, определение по внешности это крайний призрак узкости так назову это. И да в кремневой долине таких как ты выразился не мужиков полно и они двигают мир и индустрию и это факт.

[@AndyPronin]

@@Kirill_rus_ На качество кода это не влияет, надеюсь. Я бы так одеваться не стал, но это дело каждого

[@Kirill_rus_]

@@mementomori6005 Да что ты мне про кремневою долину поёшь, я знаю, что на западе таких гей модников пруд пруди. Если мужики начнут красить волосики, надевать серёжки, косить под котиков надевая ушки, красить ноготки, то в мире будет хаос. Так и до гей парадов недалеко. Мужчина должен быть мужественным и опрятным, а не миловидной сюсей с ушками на бошке. И ладно если это ребёнок или девушка, но чтобы парень... Не, мир сходит сума. А такие как ты, кричат УРА на гей парадах ). Когда у тебя появится сын, и в 25 лет он подойдёт к тебе в латексных, обтягивающих штанишках с вырезом на попе, с волосами цвета радуги, накрашенными ресничками, напудренным носиком, и в розовой футболке с блёстками, и скажет: "папууууль, хаюхааай, зацени миникююююр" я представляю как ты в глубине души будешь "рад" своему мужскому воспитаннику))) . Ты скорее всего молодой ещё и на тиктоках и тупых блогерах поехал не в то русло. Но это моё мнение, ты можешь красить губы и не обращать на меня внимание )

[@CircumstanceN1]

а что за онлайн редактор кода используется?

[@AndyPronin]

Яндекса для собесов онлайн редактор

[@gipotube9854]

не знаю что по сложности, не разбирался еще в этом но решения такие получились: def square(array: list[int]) -> list[int]: return sorted([n**2 for n in array]) def func(array: list[int], k: int) -> list[int]: return [max(array[i:i+k]) for i in list(range(0, len(array)))[::k]] буду рад услышать мнение опытных людей)

[@warsonginc.9064]

Если не ошибаюсь, в задаче нужно было пройтись по всем числам с окном k, а не через k - поэтому решение с шагом [::k] пропустит 2/3 возможных вариантов

[@yavener]

Оба решения не верны. В первом - полностью игнорируется момент с тем, что исходный массив уже отсортирован и использовать встроенную функцию сортировки в задачке на алгоритмы явно запрещается (использование sorted после возведения всех значений в квадрат). Во втором - неверный шаг И, что важнее, ты проходишь по каждому элементу и считаешь результат для каждого субмассива. Представь, что к = 10000, а массив длинной в миллионы элементов, тогда ты должен посчитать миллионы раз подмассивы длиной 10000. Смысл в том что подмассивы отличаются друг от друга только на 1 элемент и этим нужно воспользоваться.

[@imwisagist1783]

Первое збс, второе не рабочее так как пропустит кучу чисел) def solution(arr: list[int], window: int) -> list[int]: if len(arr) < window or window

[@auuureuuhuuhehhrrreeiccaan2989]

первая простая очень если делать линейку по памяти, если на собесе попросят сделать константу, то это гроб с 4 указателями)

[@incognitoincognito2532]

Константа по памяти - в смысле с записью ответа во входной массив? Ну да, неприятно выходит

[@tertiumorganum5665]

а у меня литкод захавал и решение с мультисетом за логарифм, писаное на коленке

[@user-of6wq5it1t]

Понял что ни на одно подобное собеседование я не пойду )А программирование будет моим хобби)

[@inexoudi9z167]

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

[@flurixoww]

@@inexoudi9z167 Талант тут не нужен. Здесь нужна практика чем больше ты чем то занимаешься тем легче. На должном уровне ты уже не боишься задачи,если она сложная и ты с ней не сталкивался то просто предётся больше времени на это посвятить.Как говорится глаза боятся а руки делают.

[@inexoudi9z167]

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

[@flurixoww]

​@@inexoudi9z167 Каждый второй может быть программистом но человек просто не выдерживает. Человек не выдерживает того что вся информация и тд не лежит на поверхности . Не знаю к чему тут самая умственно затратная сфера, да может человек который занимается машинным обучением,крипто графий и тд вот там да тебе нужно будет хорошенько подумать . Но большенство задач которые тебе будут давать это что то по типу вот сделай программу которая будет отслеживать автобус по гпс , для этого не надо иметь много ума для этого требуется только время.

[@jamuelsexon]

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

[@googa9541]

Я так и не понял эту задачу последнюю он не смог решить или что?

[@AndyPronin]

Нет. Не смог

[@galandec2000]

а о какой версии вообще речь идет? а то будет больно и хейта горы.))

[@Surf391711]

Второе задание вариант с deque: from collections import deque def max_in_frame(sequence, k): res = [] if k > 0: queue = deque() for i in sequence: queue.append(i) if len(queue) == k: res.append(max(queue)) queue.popleft() if not res and queue: res.append(max(queue)) return res

[@zloykrotz]

вторая: l = [6, 2, 3, 7, 0, 1] k = 3 for i in range(len(l)): print(max(l[i:k+i])) if i + k == len(l): break

[@AndyRoid1986]

ну или for i in range(len(l)-k+1): print(max(l[i:k+i]))

[@oybekyuldashov8269]

def foo(numbers: list[int], k: int) -> list[int]: return list(map(max, [numbers[i:i + k] for i in range(len(numbers) - k + 1)]))

[@yokep0]

Замечание по самому собеседованию. Если чел не вытягивает первую задачу, то он либо перенервничал, либо не знает базы. В любом случае надо было настоять на доп вопросе - написать все тесты для массива из int. А это: все "-", переход через 0 с нолем, переход через 0 без ноля, все "+", и эти варианты с четным и нечетным массивом. Если не вспомнить базу - дальнейший кодинг бесполезен (а как я представляю, его код тесты не пройдёт). Ну и без указания, что квадрат от int в ряде случаев дает выход за пределы, задачу нельзя считать полностью решенной.

[@user-ur3mc6hb5d]

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

[@azizbekmurodov2450]

def square(lst): c = [] for i in range(len(lst)): b = lst[i]**2 c.append(b) c.sort() return c a = [-5,4,2,3] b = square(a) print(b) А так не легче?

[@Indigest256]

В таком решении не учитывается отсортированность массива. Такое решение будет работать медленнее на больших объёмах данных.

[@zloykrotz]

первая: l = [-5, 1, 2, 3] def quarter(array): return sorted([i * i for i in array]) print(quarter(l)) Или я чего-то не понимаю?

[@pjerli7157]

Простите, но по факту, стоит некая задача прогеру. Он сортировкой не будет пользоваться? Будет тратить время? Ни ужели на конечном продукте есть время и желание скорость расчитывать? Я про массовые задачи!

[@nar937]

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

[@MrLotrus]

Если высоконагруженный сервис, то будет и время, и желание.

[@AlekseyMaximov]

вторую решил оч быстро так: def solution(nums: list[int], k: int) -> list[int]: res = [] it = iter(nums) try: frame = [next(it) for _ in range(k)] while True: mv = max(frame) res.append(mv) new_element = next(it) frame = frame[1:] frame.append(new_element) except StopIteration: pass return res nums = [6, 2, 3, 7, 0, 1, 3, 4, 13, -2, -5, 12] res = solution(nums, 3) print(res) почему так? потому что входные данные могут быть большими и не помещаться в память.

[@andrewlebowski7259]

Очень интересно, но ничего не понятно))

[@OGIDOG1]

первая задача: import numpy as np print(np.sort(np.array(input_array_here)**2)) вторая задача: [max(a[i:k+i]) for i in range(len(a)) if k+i

[@user-ob2mc5rc7t]

В первой задаче не проще ли было: sorted_list = [-5, -3, -2, -1, 0, 2, 3, 4, 5] squared_sorted_list = sorted([x**2 for x in sorted_list]) print(squared_sorted_list)

[@ruslanaliev2216]

сложность твоего решения получается O(nlogn) а можно за О(n) решить

[@ralfringer4600]

капец сложно, я хотел начать учить пайтон, тут сплошная математика ... наверное не потяну

[@justman073]

Если правильно понял вторую задачу, то вроде как она у меня решилась следующим кодом(При условии, что k натуральное число и длинна массива больше k): def solution(array: list[int]) -> list[int]: nums = [random.randint(0, 20) for i in range(10)] # рандомно генерирующийся список k = random.randint(2, 6) # рандомный размер окна step = 0 res = [] while len(nums) >= k: res.append(max(nums[step:k])) step += 1 k += 1 return res

[@dimkas4284]

n*k, не допустимое время работы

[@ammoney159]

const solution = (numbers, k) => { if (numbers.length < k) throw new Error("Invalid array"); let results = []; for (let i = 0; i < numbers.length - (k - 1); i++) { let num = numbers[i]; let array = numbers.slice(i, i + k); results.push(Math.max(...array)); } return results; } решение на js второй задачи

[@virus8727]

чайник, утюг... С ДЕРЕВЯННЫХ СЧЕТОВ!

[@user-ur3mc6hb5d]

Решение, которое я сделал для первой задачи на C++ vector array_squares(vector& nums) { if (nums.empty()) return {}; if (nums.size() == 1) return { nums[0] * nums[0] }; int left, right, gold_mid = 0; if (nums[nums.size()-1] < 0) gold_mid = nums.size()-1; for (int i = 0, j = 1; j < nums.size() and gold_mid != 0; i++, j++) if (nums[i] < 0 and nums[j] >= 0) gold_mid = j; left = gold_mid - 1; right = gold_mid; vector result; while (left >= 0 and right < nums.size()) { if (pow(nums[left], 2) < pow(nums[right], 2)) result.push_back(pow(nums[left--], 2)); else result.push_back(pow(nums[right++], 2)); } while (left >= 0) result.push_back(pow(nums[left--], 2)); while (right < nums.size()) result.push_back(pow(nums[right++], 2)); return result; } Первое что я сделал - это проверил на базу. Если массив пустой, то вернуть пустой массив. Если массив содержит 1 элеиент, то вернуть массив с квадратом этого элемента. Я создал переменные, которые будут указывать на левую и правую часть подмассива и еще одна переменная содержит золотую середину. Это та середина, где если идти влево - будут отрицательные числа, а вправо - положительные. Потом я сделал проверку, если последний элемент массива отрицателен, то установить как золотую середину на последний элемент. Дальше был цикл, который ищет эту золотую середину, если она не найдена. Проверяется, если первый указатель меньше 0 и второй указатель равен нулю или больше его, то это золотая середина. Дальше я присвоил в указатель на левый подмассив индекс золотой середины - 1 и для правого индекс золотой середины. Дальше как в сортировке слиянием я сравнивал. Если квадрат текущего элемента указателя из левого подмассива меньше квадрата текущего элемента указателя из правого подмассива, то добавить левый. Иначе правый. Всё это делалось пока один из указателей не выйдет за пределы подмассивов. Потом я создал 2 цикла, которые заполняли результирующий массив оставшимися элементами из правого и левого подмассива. Потом я вернул массив. И так в худшем случае у меня получилось бы 2 прохода по массиву. Первый проход это поиск середины и второй проход это сравнение и добавление в результирующий массив. Насколько я понял получилось О(2*n). И по памяти вышло O(n)

[@user-ur3mc6hb5d]

@@user-ms7vs4ue6q погляжу на досуге что там. Я уже давно забыл про эту задачу

[@user-uv2mh7qy5h]

Вторую задачу задачу можно решить без deque за O(n)

[@amonra3211]

Тоже попытался решить задачу №2 своим способом. Ну и посмотрел приведенные здесь пути. У меня получилось так. Программа сначала находит максимум в окне, а потом с каждый шагом проверяет, не уползло ли оно в данный момент настолько далеко, что этот максимум оказался за его пределами. Когда уползло - снова применяется max() и максимум пересчитывается. При этом, текущий максимум (который все еще в окне) хранится в отдельной переменной и с каждым шагом сравнивается с новым попавшим окно числом на предмет обновления. То есть, получается, что самая минимальная сложность - это когда мы применяем функцию max() один раз в k смещений? Кто еще как это видит?

[@wrestler91100]

тогда сложно n*k, а надо n+k

[@mikeofs1304]

​@@wrestler91100 Ну и как же получить n + k, просвети?

[@mikeofs1304]

Это единственный правильный способ избавится от n max(k)

[@wrestler91100]

@@mikeofs1304 При помощи стека с поддержкой максимум from collections import deque def maxSlidingWindow(nums: list[int], k: int) -> list[int]: window = deque() # в стек складываем индексы элементов окна, при этом в вверху стека лежит индекс макс элемента result = [] for i in range(len(nums)): # проходимся по массиву while window and window[0] = k - 1: # если указатель i дошел до конца окна и окно начало двигаться, то result.append(nums[window[0]]) # добавляем текущий максимум в результирующий массив return result

[@Surf391711]

Вторую я так сделал: def sectorwise(sequence, sector=2): if not sequence or sector

[@user-tm1pt7hv8x]

Сложность O(n*k). Можно О(n).

[@tobemaguire7389]

первая: def pops(nums): for i in range(len(nums)): nums[i] **= 2 return sorted(nums) print(pops([])) print(pops([1, 2, 3, 4, 5, 6])) print(pops([-5, -3, 0, 2, 10])) или так: def pops(nums): return sorted([i ** 2 for i in nums])

[@user-et2kj6ou4m]

Решение второй задачи

[@idleprepress]

Скользящее окно пишется в пяток строк на islice, потом йелдишь max от него, и всё.

[@werft2266]

сложность n*k

[@molod1]

Я первую задачу так решил def func(list: list) -> list: res = [] for i in list: res.append(i ** 2) res.sort() return res

[@user-vx4fl1is2w]

Не оптимально

[@user-qw9ct3ot6e]

Вторая задача def find_max_num_in_group(nums: list[int], k: int) -> list[int]: result = [] groups = (len(nums) - k) + 1 for index in range(groups): result.append(max(nums[index:index + k])) return result

[@archimg1221]

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

[@AndyPronin]

Да

[@AndyPronin]

На самом деле, они оба выпускники) я и у Яна и у Руслана наставником был в своё время.

[@MrLotrus]

@@AndyPronin Вот только у Руслана хорошие знания и до ЯП были по алгосам)

[@AndyPronin]

@@MrLotrus ага. Кто на что учился

[@class_python]

from random import randint # для первой задачи изменить массив а, включив в него отрицательные числа (randint(-10, 10)) например a = [(randint(1, 100)) for x in range(20)] print(sorted([i**2 for i in a if i > 0] + [(i*(-1))*(i*(-1)) for i in a if i < 0])) # первое решение for i in range(len(a) - 2): print(max(a[i:i+3])) # второе решение while len(a) != 3: print(max(a[:3])) del a[0]

[@imwisagist1783]

Решение первой задачи не рабочее. Думаю люди это чувствовали поэтому проверять не стали. По производительности лучшего решения чем sorted([num * num for num in arr]) На следующих входных данных я не нашёл. solution([-5000, -3, -2, -1, 0, 1, 2, 3, 4, 5000] * 50000)

[@Mister_Molox]

[-5000, -3, -2, -1, 0, 1, 2, 3, 4, 5000] * 50000 -- не является отсортированным массивом

[@AlexeiGoncharov-gq8dm]

Смотрю на решение первой задачи - очень кривая простыня с кучей ветвлений. Думаю, что там полюбому ошибка будет, запускайте, а в итоге "ок, по коду будет работать" оО))

[@a1dwow]

Я тут из мира Java залетел, мне кажется первую задачку можно решить намного проще: int[] input = new int[]{-10, -7, -6, -4, -3, -2, 0, -1, 1, 2, 3, 4, 5, 6, 7}; LinkedList result = new LinkedList(); int lIndex = input.length - 1; int rIndex = 0; while (rIndex = rightNum) { result.addFirst(leftNum * leftNum); rIndex++; } else { result.addFirst(rightNum * rightNum); lIndex--; } }

[@bohdanzhuravel5642]

pd.Series(nums).rolling(window=k).max() Вот и вторая задачка)))

[@user-nr6ey5iv6z]

Яндекс практикум дорогое обучение?

[@maxgromov7494]

У автора канала есть промокод на 15% скидку на любой курс. Ценники на сайте Яндекс Практикум

[@_uniqpr0]

Вторая задача тоже легкая, на срезы. Рукалицо.

[@rzhek9541]

Гайд как публично опозориться

[@user-oj7ct4lt4x]

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

[@AlexeiGoncharov-gq8dm]

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

[@user-cn6gq8mf2v]

Яндекс для своих. Если ты не лох с такими петушками татарского происхождения водится не будешь😅

[@silentlyow]

​@@AlexeiGoncharov-gq8dmВ начале видео говорилось, что приглашённый - программист в Яндйексе а не интервьюер. Конечно с вами сюсюкатьая никто на собесе в яндекс не будет. Не пойму почему вы придрались к формулировке первой задачи. Человек нормально разъяснил условие, а добавил некоторые фразы так как сразу понял что кандидат не слишком умный (что собственно так и есть)

[@AlexeiGoncharov-gq8dm]

@@silentlyow у Яндекса собез слабый, если что) собственно оттуда и такие сотрудники, которые сформулировать таск не в состоянии)

[@chandlerbingm1]

Да, он фиговый

[@AndreiIvanov-ph8sx]

А в Яндекс только с "ушками" берут?

[@AndyPronin]

Ян не попал в Яндекс в итоге. Так что, нет

[@user-ih9tu1kn7i]

Задача 2: def solution(array: list[int], k: int) -> list[int]: from collections import deque dq = deque() ret = [] for i in range(len(array)): while dq and dq[0] = k - 1: ret.append(array[dq[0]]) return ret

[@user-cw1ll2bi7n]

Судя по коду он будет работать и будет работать правильно. А нельзя его запустить, чтобы проверить?😂😂😂

[@scad_]

def some_func(list): return [-(data ** 2) if data < 0 else data ** 2 for data in list] print(some_func([-5, 1, 2, 3 ,4])) слишком долгие страдания

[@bocik2854]

свой код то запускал? он выводит [-25, 1, 4, 9, 16], а правильный ответ [1, 4, 9, 16, 25]

[@scad_]

@@bocik2854 послушайте внимательнее условие задачи

[@2173045]

Что за жесть 😱

[@AndyPronin]

Яндекс.

[@Mister_Molox]

За O(2n) не сложно в принципе вторую задачку сделать)

[@Mister_Molox]

Очень хочется сюда выложить ответ, но не буду)

[@whatistypescript4280]

При достаточно маленьком k это и будет за 2n с дэком

[@Memes_563]

Ну первая задачка прям изи. Я про список

[@yauhent671]

Что-то парень растерялся со второй задачей. Самый простой вариант имхо найти максимум и его индекс в первом окне и потом сравнивать новый элемент с максимумом и проверить индекс на попадание в окно. Если индекс за пределами окна - искать максимум в срезе.

[@absent6322]

ваше решение O(n^2)

[@yauhent671]

​@@absent6322 только если список отсортирован по убыванию. В остальных случаях где-то между On и On**2

[@absent6322]

@@yauhent671 ты же понимаешь что такое О-notation, это про худший случай, если вкратце.

[@yauhent671]

@@absent6322 Da, znaju

[@wad881988]

Перед этим алгоритмом нужно проверить список на монотонность. Если он монотонно возрастающий, то ответ это сам список начиная с k. Если он монотонно убывающий, то ответ это сам список до len-k. Если ни то ни другое, то тогда уже юзать алгоритм. Поэтому и был вопрос про проверку на монотонность, которую, как я понимаю, можно осуществить просто путем вычитания из каждого значения списка его предыдущего значения с последующей проверкой на больше / меньше 0.

[@VA-jo9tv]

первая задач с оптимизацией - это deque def square_sort(sorted_array: list[int]) -> list[int]: if sorted_array[0] >= 0: return [x**2 for x in sorted_array] result = [] sorted_deque = deque(sorted_array) while sorted_deque: if abs(sorted_deque[0]) > abs(sorted_deque[-1]): append_item = sorted_deque.popleft() else: append_item = sorted_deque.pop() result = [append_item**2] + result return list(result)

[@user-ku8sk7hz7t]

2 задача def bar(arr, k): for i in range(0, len(arr) - k + 1): indexes = (arr[x] for x in range(i, i + k)) print(max(indexes))

[@wrestler91100]

здесь сложность опять же n*k

[@Revasha228Crime]

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