Алгоритмы и Структуры Данных. Урок 1: Введение. Числа Фибоначчи.

[@alishevN]

КУРС ПО GIT: www.udemy.com/course/git-alishev/?referralCode=71994763964B8E2E6A4E

[@caspianniko8555]

i know im asking randomly but does anyone know of a way to log back into an instagram account..? I somehow lost my account password. I appreciate any assistance you can offer me

[@midnight_essay]

Спасибо огромное, что начал еще и этот курс, я и не надеялся, что после андроида и EE останутся силы на алгоритмы) Очень жду уроков по всем курсам, ужасно благодарен за труд)

[@olgasukhova777]

И я также:)

[@vadimoff22]

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

[@lowlight1063]

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

[@shukhratkasimov6791]

Все уроки отличные. Пересмотрел все уроки канала. Подход уроков просто шикарный. До этого смотрел много уроков, но всегда оставалось чувство неполноты. После уроков автора все стало на свои места. Очень благодарен автору за огромный труд. Ты №1.

[@claypresent6422]

Только не смей перестать!

[@igorshishikin7647]

Боже, это то что я так долго искал. alishev спасибо тебе огромное, продолжай снимать такой же качественный контент.

[@ernestmyrmyr9932]

прям идеальное дополнение к книге "Грокаем алгоритмы"! Спасибо !

[@wildjoe6259]

Спасибо за Вашу работу!!!

[@ИванАлешечкин-б8к]

Наиль, ты лучший! Спасибо тебе что ты есть!

[@alisaholainen6334]

Спасибо большое. Именно, с Фибоначчи я начинала изучение алгоритмов. Ваше видео было чУдным дополнением к моим знаниям

[@babkenromyan6129]

Доброе время суток, большое спасибо за урок! Более подробного и доступного объяснения я не нашел нигде!

[@rudikshul25]

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

[@RuslanZinovyev]

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

[@alexeystambulzhan]

очень хорошо объясняется, всё понятно, просмотрел все java курсы и купил новые на udemy, спасибо

[@Tokamame]

Отличная подача материала! Спасибо большое.

[@АлександрКожевников-ь2о]

Наиль Спасибо вам огромное, все очень понятно объясняете, одно удовольствие изучать АиСД по вашим урокам)

[@igorkudryk2199]

Спасибо за алгоритмы, надеюсь выйдет больше видео на эти темы :)

[@retropiligrim]

Спасибо тебе автор. Вкатываюсь в бэк с фронта и ты очень помогаешь.

[@alexanderwicked8990]

Отлично! Очень ждал материал именно по алгоритмам. Спасибо большое!

[@lowlight1063]

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

[@crataegus2653]

спасибо человечище!

[@ByTheKema]

Наиль, спасибо большое, ждал)

[@denistalko6585]

Отличный урок! Спасибо огромное! Очень понятно объясняете.

[@Chaevnicher]

число 1 000 000 000: твой алгоритм с массивами выполняется 23-31 сек, а если использовать три переменные - 3-5 сек) ```go var d int _, _ = fmt.Scanf("%d", &d) var a int64 = 0 var b int64 = 1 var c int64 = 0 for i:= 0; i < d; i++ { c = b b += a a = c } fmt.Println(a) ``` при 10 000 000 000 вариант с переменными выполнился за 13.233214662s твои массивы заполнили всю оперативную память (8гб) и 15гб памяти на ssd: Process finished with exit code 137 (interrupted by signal 9: SIGKILL) пам-пам! вот она сила алгоритмов на практике))

[@CrownlessX]

Я вот чёт тоже думал про переменные, а не массивы.. но, тем не менее, надо смотреть на логичность задачи. Кому понадобится 10 000 000 000 элемент чисел фибаначи?) BTW, такое число в лонг не запихать. БигИнт надо какой то.... Но опять же - где логика таких задач?)

[@Chaevnicher]

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

[@CrownlessX]

Спору нет, хранить может и не стоит... но вопрос всё ж логически постановке задачи. Почему ты тогда не протестировал поиск гуголплексового значения?) Всё ж это больше выглядит, как - некчему докопаться, докопись до орфографии. Тут рассматривается ВАРИАНТЫ решения алгоритмов, а не единственное возможное. Вариант с хранением данных может пригодится в том случае, если мы постоянно будем числа искать - простая модификация и никаких вычислений в будущем.

[@skazhenyy_enot_]

бл, в шоке от твоего говнокода. Логика норм. Но названия. Блевануть мля.

[@NoName-ec4wg]

inp, array = int(input()), [0,1] for i in range(1, inp): array.append(array[i] + array[i-1]) print(array) ------------------------------- Как это выглядит на питоне с использованием списка в 3 строки) Базару нет, можно и с переменными, но все зависит от поставленных задач (тобишь от диапазона чисел). Да и видео вроде как называется не "самый эффективный алгоритм для решения задачи чисел Фибоначчи", если вы читали название:) Здесь PoC обьясняется и ради этого я сюда зашел как бы, алгоритм я для себя напишу и подберу уже сам. Темболее что это и логично, потому что ты хранишь все возможные числа до N в одном типе данных, по этому оно так оперативу и хавает, лол. Или может на ассемблере перепишем раз на то пошло? :D

[@isomurodovaziynat669]

Здравствуйте. Спасибо большое за уроки.

[@Andrzej3935]

"Тип int у нас перекрутился несколько раз..." - улыбнуло) Спасибо за прекрасные уроки!

[@andreyevlash725]

Вот ещё вариант: private static long fibEffective2(int n) { if (n

[@TezkaTszyu]

О, я как раз задал вопрос "зачем массив в плане памяти, 2*long против n*long" и уведел ваш комментарий 👍

[@АсланбекЕлбосынов]

@@TezkaTszyu +

[@adekakz9794]

тоже самое, но без массива. В массиве хранить данные удобнее, согласитесь

[@Artem_35_]

Спасибо большое! Очень интересно и доступно и отдельное спасибо за 1440p60! Очень жаль что на Udemy всего 720р... И подумайте о том, что бы прикрутить к своим видео тут какую-то донат-платформу. Думаю многие бы благодарили, каждый в меру своих возможностей.

[@Nexn0n]

Простой и понятный пример. Алгоритм можно ещё больше оптимизировать. Недавно в универе дали задание найти n-ое число Фибоначчи за время O(log n). А это уже бинарное возведение в степень и матрицы)

[@ivantyshchenko61]

Спасибо за видео! По поводу затрат памяти, я бы в массиве хранил только предыдущие 2 числа

[@ДмитрийВоробьёв-э1н]

Можно делать это и без массива, переменными

[@ДенисКрылов-л3х]

Спасибо за видео, очень доступно

[@ПетрДанькин-ф2с]

как всегда, все доходчиво и интересно

[@karensrapyan845]

private static long fibEffective(int N) { long a = 0; long b = 1; long sum = 0; for (int i = 0; i

[@MsDima9999]

maby i dont ubderstend something but if I put 10 in this method it returns 144 but not 55 What is wrong?

[@karensrapyan845]

@@MsDima9999 my function just shows some apprach for sum and as u see I wrote return sum or b which means I didnt tested that. The only info from my code u need to take it is using 3 vars

[@chupnmsk]

your algorithm is good, but it will return a number that will be 2 numbers from the desired one, because the loop starts at 0.

[@trrt9756]

спасибо за урок!

[@denzzero8920]

Благодарю, хорошо объяснил.

[@vladbasov8863]

Написал данный алгоритм (Effective) на swift, использовал Decimal в качестве типа данных, при n = 100 получил число 354224848179261915075. Это число отличается от результата на видео. Попробовал в инете онлайн калькулятор числа Фибоначи - результат был как в моей проге. Похоже с long такие вычисления не катят.

[@vyacheslavtatsianafilipovi5784]

Подскажите,а в какой последовательности правильнее смотреть ваши курсы? Например, Джава для начинающих,потом Алгоритмы и структуры,потом Продвинутая Джава,а потом уже к примеру Спринг.

[@ВикторГусев-н5т]

Спасибо! Очень понятно!

[@РадикГимадиев-ч3и]

Спасибо за урок! Подскажите, пожалуйста, как настроить Idea так, чтобы вверху над рабочей областью высвечивалось имя метода, в котором находится курсор, как у Вас в этом видео?

[@ДанилЯнчук-ч4щ]

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

[@aleksey8405]

Согласен. Нам достаточно выделить память лишь под массив из 3-х элементов, а не n+1. arr[0] - это будет F-2, arr[1] - это будет F-1, arr[2] - будет само число Фибоначчи. И в конце каждой итерации надо будет копировать значение arr[1] в arr[0], а значение arr[2] в arr[1]. И снова вычислять число Фибоначчии, т.е. arr[2] на основании этих двух значений (arr[0] и arr[1]). И тогда память также тратиться не будет. Но автор, в любом случае, молодец.

[@TezkaTszyu]

А зачем массив, если можно 2 предыдущих значения хранить в 2х переменных и в результате выдавать сумму? Ну в плане памяти 2*long против n*long

[@roman8735]

Спасибо отличное видео, жду ещё!! )))

[@alekseyshibayev5243]

Привет друг, ты супер полезную работу делаешь, однако, на данном этапе, я хочу тебе сказать что фибоначчи 100 не влезает в long ((2^64) -1)

[@ruslanvolovik2745]

Как же не используется память при рекурсивном варианте если все равно же стек очень сильно забиваеться, а стек это же структура данных - то что хранит данные в памяти

[@pochan1585]

А если написать следующий код(на js), он сделан с рекрсией, но вычисляет так же быстро let a = 0, b = 1, c = 0, k = 1; function fibonachi(n) { c = a + b; k++; a = b; b = c; if(k == n) { console.log(c) } else { fibonachi(n); } } fibonachi(1300)

[@karenjantv2302]

Это гениально

[@yourownazog8069]

Шикарный урок

[@kensaitakeso]

The 100th Fibonacci number is 354,224,848,179,261,915,075. Since 100 is relatively large, it would take quite a bit of time and calculation to find the 100th Fibonacci number using our recursive formula. не помещается 100е число в лонг. если весь массив напечатать то видно что под конец вылазят отрицательные числа. наверно бигИнт нужно прикрутить но их складывать плюсом не выйдет

[@sorrelofsuccess5513]

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

[@Arimototoku]

ШикарнО:)

[@lulikb7547]

wow!!! SUPER

[@shushanbalayan6267]

спасибо, ну я решала эту задачу и без масива, для чего хранить в массиве если просто переопределив a1, a2 задача решается?

[@alishevN]

да, можно без массива.

[@OrionChrome]

Я тоже так сначала решил, до того как видео посмотрел. Просто переопределял x и y на каждой итерации и вычислял их сумму. Ну, думаю, этот способ явно "тупой", так как сразу в голову приходит, посмотрю ка я в видео что же там за умный способ показан, рекурсия наверное. А оказалось всё как раз наоборот.

[@aliaskararzykulov2361]

Спасибо за уроки. а почему когда в аргумент передаем 0 то скидывает ошибку ?ArrayIndexOutOfBoundsException: Index 1 out of bounds for length 1.

[@olgasukhova777]

Курс купила по яве🤗👌😍

[@AndriiRabinovych]

мне кажется допущена ошибка в 5:10 , в слайде. F100 = 3736710778780434371, а так то спасибо огромное!

[@go_alloman8106]

Решение без массива вообще static int fib(int n) { int a = 0; int b = 1; int result=n; for (int i = 2; i

[@miapdesign5201]

Подскажите пожалуйста, в каком порядке нужно проходить курсы, размещенные у автора на канале? В плейлистах порядок курсов такой: 1. Java для начинающих 2. Android для начинающих 3. Java EE для начинающих 4. Алгоритмы и Структуры Данных 5. Spring Framework 6. Git Полный курс Но я не уверен, что проходить изучение будет правильно именно в таком порядке. Может кто-то знает с высоты собственного опыта?

[@costavashchuk7368]

Наиль, спасибо огромное! Замечательные курсы! Только возник вопрос. Сотое число не помещается в long, помоему. Попробовал long и BigInt, получился разный результат.

[@АлексейНицуленко]

Здравствуйте, начал осваивать IT с нуля, стараюсь освоить базис (до банального пересматриваю краткий курс информатики 10-11класс), начал с Вашей помощью учить python, понимаю, что нужны алгоритмы, но в первом же видео, вы пишете код на неизвестном мне языке. Хочу параллельно эти дисциплины проходить. Как быть? Нужно сначала бросить python и выучить другой язык? Вопросы может глупые, но все, я думаю, были на моей стадии ;)

[@BobrKurvva]

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

[@mikegemini9503]

Здравствуйте! Шикардос! Почему этот алгоритм не рассказывают, в учебниках? Рекурсия-рекурсией, но надо (имхо), сразу давать понятия об алгоритмах и вычислении их эффективности. Может, я не те книжки читал. Самоучка, если что.

[@programer8]

Давайте полный курс по Алгоритмам и структур данных для начинающих на udemy

[@ИльяХрулев-ь7ц]

А почему при использовании наивного алгоритма не возникает ошибка - стек овер флоу?

[@gevorghovhannisyan7784]

Не совсем понял рекурсивный метод. Можно по подробнее? Спасибо

[@MegaFeel1]

АиСД, вот за это отдельная спсаааа

[@Tokamame]

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

[@demontaraz]

Я не совсем понял зачем массив? Почему нельзя 2 переменные постоянно переопределять? Возможно по производительности ничего не изменилось бы, но по памяти всяко быстрее

[@LitvinenkoBoris-b7z]

Не обязательно помнить весь массив чисел Фибоначи, достаточно последних 2-х. В таком случае мы добьемся решения задачи за линейное время и константную память

[@aleksey8405]

Только хотел написать то же самое. Нам достаточно выделить память лишь под массив из 3-х элементов, а не n+1. arr[0] - это будет F-2, arr[1] - это будет F-1, arr[2] - будет само число Фибоначчи. И в конце каждой итерации надо будет копировать значение arr[1] в arr[0], а значение arr[2] в arr[1]. И снова вычислять число Фибоначчии, т.е. arr[2] на основании этих двух значений (arr[0] и arr[1]). И тогда память также тратиться не будет. А если делать так, как сделал автор - то при необходимости вычислить какое-нибудь огромное число Фибоначчи - просто памяти не хватит, и будет краш или типа того. Но в любом случае, видео очень полезное, спасибо большое автору!

[@konig231]

видео как всегда супер, однозначно лайк. но у меня есть вопрос по fibNaive (11:09). никак не могу понять, почему return fibNaive(n - 1) + fibNaive(n-2); не равен return (n - 1) + (n - 2);. буду очень признателен, если у кого-то появится желание ответить.

[@АлександрКозлов-в4в]

Может потому что "return fibNaive(n-1) + fibNaive(n-2)" - это рекурсивный вызов? т.е. зайдя в этот метод с неким n > 1, возвратным значением будет снова вызов этого же метода с новым n (один вызов будет n-1, другой n-2, которые в свою очередь о5 вызовут методы). Соответственно результат будет "комом" нарастать. А return (n - 1) + (n - 2) просто вернёт значение, произведя математическое действие. Передав методу параметр 5, он вернёт 7

[@RuslanZinovyev]

Потому что рекурсии в твоем примере (n - 1) + (n - 2) нет. Ответ будет не верным. А алгоритм для вычисления рекуррентный, поэтому без рекурсии никак. Запись вида fibNative(n - 1) + fibNative(n + 2) рекурсивна, функция вызывает саму себя дважды, рекомендую почитать про рекурсию если не понятно все равно.

[@konig231]

понял, спасибо!

[@konstantindobrinskiy9740]

Спасибо! А почему массив брали размером n+1, а не n ? Зачем тут на один размер вперед место еще резервировать?

[@alishevN]

Потому что нам надо найти все числа Фибоначчи от 0 до n, где n - аргумент метода. От 0 до n как раз n + 1 чисел Фибоначчи. Например, пользователь вводит 3. От 0 до n - [0,1,2,3] - 4 (n+1) числа Фибоначчи.

[@ДмитрийДмитриев-г5у]

Блин, нифига не понял.

[@alishevN]

В массиве long a = new long[n] при обращении a[n] будет ошибка ArrayIndexOutOfBound, потому что нумерация элементов в массивах начинается с 0.

[@MrVakial]

А почему тело цикла for не в фигурных скобках? Не понимаю. По идее ведь должно ошибку выдать.

[@yeson6581]

Мне искреннее интересно, как Наиль посчитал время вычисления 100-го числа Фибоначчи первым методом? Я забивал в код 50-е число и оно посчиталось довольно оперативно - 43 секунды. Кстати, используйте BigInteger вместо long для правильного расчёта например 100-го числа Фибоначчи и не забывайте про метод сложения - add и valueOf(n).

[@kkkaadoanswg]

возведи 43 секунды в 50 степень и удивишься

[@dendr576]

Скажите пожалуйста, как реализовать на python Фибоначчи именно списком?

[@alexanderlojhkin8997]

А зачем собственно тратить память на массив, если на выходе у нас только n число, при том что для расчетов нужны только n-1 и n-2, а не вся числовая последовательность, не будет ли более эффективным такой код: long n1=1; long n2=0; long r=0; for (int i=2;i!=n;i++){ r=n1+n2; n2=n1; n1=r; } return r;

[@alishevN]

да, вы правы. ваш код еще лучше.

[@dentor2005]

а ты пробовал этот код запустить и сравнить результат, например с он-лайн калькуляторами?

[@user-xl2tf4gq1g]

нужно заменить i !=n этим i

[@ilias3624]

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

[@aleksey8405]

На самом деле, нам достаточно выделить память лишь под массив из 3-х элементов, а не n+1. arr[0] - это будет F-2, arr[1] - это будет F-1, arr[2] - будет само число Фибоначчи. И в конце каждой итерации надо будет копировать значение arr[1] в arr[0], а значение arr[2] в arr[1]. И снова вычислять число Фибоначчии, т.е. arr[2] на основании этих двух значений (arr[0] и arr[1]). И тогда память также тратиться не будет.

[@footballlife9931]

спасибо

[@BillionairesHouse2024]

Сделай видео о дереаьях и графах, пожайлуста 😊😊😊

[@PimpLable]

11 -14 строку можно уместить в одну строку через тернарный оператор java.

[@ILawrance]

Разве у первого алгоритма сложность не 2^N , а у второго N? И именно в этом основная проблема

[@bulka6839]

Здравствуйте, это демо или полный курс?

[@siegfried_dd]

прошу вас, продолжайте эту тему с алгоритмами..

[@alishevN]

На следующей неделе.

[@elenoramalygina2796]

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

[@enered3944]

Объясните пожалуйста, почему длинна массива n+1?

[@pandainbyt]

Потому что первый элемент в массиве заполняется нулём

[@albertrain7093]

Я так и не понял, чесло 0 считать или нет? Если считать, то 5 - получается шестым числом, или 0 - это нулевое число Фибоначи? :) З.Ы. Спасибо за видео!!!

[@alishevN]

Можно считать, можно не считать. Даже в википедии приведено два варианта.

[@albertrain7093]

спасибо большое!

[@eugenesmith9940]

при n+1, видимо, не считают (точнее начинают считать с 0. Т.е 0 (это нулевое число), 1 (1-е число), 1 (2-е число), 2 (3-е число) и т.д)

[@VitaliyZlobin]

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

[@kek_pupold]

Мне кажется все так думали, потому что "наивный метод" намного сложнее, там логика извращенная какая-то

[@stas4985]

если ты не понял рекурсию то еще придет время и будешь ее пытаться понять

[@dragulaxis]

@@kek_pupold да там же школьная формула, вы чего.

[@kek_pupold]

@@dragulaxis я даже не помню про что я писал, нашел когда ответить )

[@3x0d7s]

Что скажете по поводу моей реализации метода получения числа Фибоначчи? class Fibbonacci{ static final int n0 = 0; static final int n1 = 1; static long toGetNumber(int n){ if (n < 2) return n; else{ long sum2 = n0, sum1 = n1; for(long x = 2; x

[@---fq2kd]

кролики не только ценный мех!

[@MrPe4KiN96]

это всё конечно очень хорошо, но что делать если и тип лонг переполнится?)

[@alishevN]

Использовать класс BigInteger.

[@WaveTheEmeraldDragon]

Спасибо за восхитительные уроки! (Кстати именно при Fn92 он уже переполняется -> 7540113804746346429). Но уроки и правда хорошие. Как досмотрю ютуб - подпишусь на новый курс.

[@apterion]

Тут что-то не так. В 64 битах 20 порядков в десятичном представлении -- у вас 19. В rust мне не удалось 100-е число Фибоначчи вычислить -- упёрся в ограничения unsigned int 64 (в отладочной сборке rust это проверяет). Да, действительно, там переполнение. Пора переезжать на 128 бит)) P.S. Запустил без проверок на переполнение -- результат как у вас стал. Починил!))

[@dragulaxis]

Посмотрел 6 минут ролика и всё понял, написал прогу с ArrayList, так как F(100) не вмещается в long.

[@aliakseidev5390]

Коммент поддержки

[@rigfftreee8190]

Более эффективный вариант public long getFib(int n) { long ar [] = new long[] {0,1}; for (int i = 2; i

[@mashkovvan]

Честно говоря рассчет не верный, лонг заканчивается на 92 элементе массива

[@MuratFatykhov]

Вообще, в среднем вычисление числа Фибоначчи с помощью этого алгоритма занимает 50 тысяч лет 😂 Размотало 😂

[@ujin7835]

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

[@ViktorAr2023]

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

[@lukianhrabchuk3909]

100-й элемент вычислило за мгновение... Я что-то не так делаю?

[@ОлегМосягин-р8й]

Очень странный пример. Я всегда считал, что "наивный способ" это как раз такой, когда ты программно воссоздаешь ручной способ проделывания операций. А знание алгоритмов нужно, чтобы сделать все гораздо эффективнее неочевидным способом. Но на видео как раз обратная ситуация. Я специально написал свое решение (с 3-мя переменными, без массива) перед тем, как было показано "наивное" и сильно удивился, когда узнал, что оно было оптимальным. У меня вопрос: зачем изучать алгоритмы, если можно представить ручной способ, а потом просто запрограммировать его?

[@maximpanfilov4388]

Крутой курс) Что планируется в будущем???

[@alishevN]

Разбор задач из собеседований

[@АртемДеренчук]

Заебись, а то что 100-ый элемент нельзя через long посчитать, то похер)))) Число 100-го элемента считается через BigInteger и оно будет немного больше...

[@NarkotikAsd]

function fibona(n){ let art = [n+1]; art[0]=0; art[1]=1; for(let i = 2; i

[@eugenesmith9940]

потому что 100-е число Фибоначчи выходит за пределы примитива long. Верхний лимит в данном случае - это 92-е число.

[@pertshgalstyan6189]

izmini kachestvo plz

[@alishevN]

сейчас должно быть ок

[@pertshgalstyan6189]

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

[@alishevN]

К сожалению, это максимальное качество.

[@pertshgalstyan6189]

alishev ок, Спасибо за урок