bom saber disso, venho estudando programacao a alguns anos e esse assunto de algoritmos e estruturas de dados esta sendo ridiculamente dificil para mim, talvez seja melhor focar nisso no futuro, ou pelo menos nao me cobrar tanto por nao saber resolver 80% das questoes que eu tento resolver
Tem outros meios mais interessante pra se treinar a capacidade cognitiva e se tornar mais inteligente. Mas se isso faz vc se sentir mais engajado pra treinar isso, vá em frente
Boa parte dos que mandam bem nesse tipo de desafio simplesmente decoram a solução com a explicação, existem até livros acadêmico mostrando esses problemas e as soluções. Quer achar alguém preparado? Traz um problema não convencional.
@@Richsan E um exercício simples, ninguém vai virar Albert Ainstem fazendo leetcode, mas e um começo para o raciocínio de logica de programação. Logico que a milhares de pessoas que só irão decorar, pelo simples fato de que as pessoas são desleixadas com o seu intelecto e raciocínio, mas só de algumas verem os vídeos do augusto e irem atrás de se aperfeiçoar já faz com que elas comecem o treino cognitivo com foco em programação.
Outra solução que é linear para o primeiro problema: arr = radix_sort(arr) return maior_sequencia_array_ordenado(arr) como os números são limitados, dá para usar radix sort, que é O(n). Na prática, porém, roda mais lento que as ordenações presentes nas linguagens. Mas ainda assim atende conceitualmente o que foi pedido, e usa espaço adicional O(1) em vez de Θ(n) como no hash, e numa entrevista mostrar isso pode ser interessante.
Galegão, faz um tempo que consegui uma oferta de uma FAANG e de certa forma seus vídeos me ajudaram a me preparar para as entrevistas. Conteúdo muito brabo, que a gente só encontra do mesmo nível na gringa, muito obrigado por ajudar a todos meu mano!!
Sempre odiei estudar LeetCode e estrutura de dados, e estou conseguindo acompanhar mt bem as séries do Galego aqui e tá me ajudando bastante. Parabéns Galeeego
Cara! pra mim o que mais abriu minha mente foi o fato que eu tentava ao máximo evitar percorrer o array "sem fazer nada" (só transformando ele), sempre voltava a minha atenção em percorrer o array uma vez só. Mas o incrível é que só quando você abandona a ideia de querer passar uma vez só no array você é capaz de fazer a checagem de "esse elemento é o início da lista?" em O(1), que é o centro que permite a solução inteira ser O(n)
@15:55 pequena ineficiência no iterador. Deveria ter usado "for ... in num_set" ao invés de "for ... in nums" Se nums=[0,0,0,0,1,2,3,4,...,100], por exemplo, toda vez que iterar num=0 você vai verificar a sequencia 0,1,2,...,100 de novo. Usando num_set como iteravel você garante que so vai iterar em num=0 uma vez.
Bacana demais a sua iniciativa de abrir esses conceitos de programação aqui no TH-cam. Já te assisto há um tempo e é sempre bom aprender e reforçar conteúdos com os seus vídeos.
Cara, bigO é infinitamente a parte mais facil de resolver. Eu so nao lembrava se o sort era log N ou n log N mas é bem tranquilo. Essa do set eu nao pensaria nem a pau. kkkk
eu nunca voltei um vídeo tantas vezes kkk, se eu viajava por 10 segundos, tinha que voltar por que perdia o raciocíno kkkk. Parabéns pelo conteúdo vc é fera!
A resposta do primeiro problema está *incompleta*, e tem tempo Θ(n²). Para perceber isto, basta dar como entrada um array com n/2 zeros, e os demais números de 1 a n/2. Assim, para cada zero ele vai fazer n/2 buscas da mesma sequência, resultando em n²/4 operações. Para resolver isso pode-se manter um hash com todos os números iniciais já tratados, para que não sejam verificados mais de uma vez.
update: agora após ver o vídeo, que legal um ótimo exercício, parabéns pelo vídeo. agora vou refazer o exemplo kkkkk pausei o vídeo e tentei resolver, ta longe de ser ótimo mas cheguei nessa solução # l = [100,4,200,1,3,2] l = [0,3,7,2,5,8,4,6,0,1] def fu(l): cont = 1 for i in range(len(l) - 1): if l[i + 1] - l[i] == 1: cont += 1 else: break return cont l2 = list(set(l)) l2.sort() print(l2) resultado = fu(l2) print(resultado)
Eu foquei muito em crud e afins, peguei uma entrevista com live coding na letcode e me lasquei kkk era pra calcular o máximo de água que caberia dentro de um retângulo.
Recentemente terminei meu curso de tecnico de Desenvolviemnto de Sistemas e cai nesse video é normal nao ter entedido nada sobre esse tal "O(n log n)" e o que eu deveria estudar para sanar essa duvida, obrigado pelo seu tempo
o mercado hoje parte a partir de pleno+, mesmo deixando "explicito" que a vaga é de "estagio" (entre mil aspas) o nivel sempre parte de pleno+. Falo isso com tranquilidade, porque participei de um programa de bolsas na Compass UOL pra ser estagiario fiquei 4 ou 5 meses no programa de bolsas e no final escolheram um senior pra estagiar com eles kkkkkk
Antes de tudo, o vídeo é excelente. Mas tentando entender um pouco melhor o que foi abordado, está correto considerar a solução do primeiro problema O(n)? Ele diz que a busca em uma hash-table da vida é O(1), mas na verdade é Θ(1) e O(n). Tudo bem, eu entendo que pra boa parte das entradas, a gente iria bater no caso médio e então conseguir resolver em um tempo linear, mas é incorreto dizer que a solução é O(n), não?
Cara, uma coisa que não ficou claro é como você computou O(n) se existe um for dentro de outro for no problem 347. Me parece que no pior caso buckets[freq] pode ter um tamanho n. E com um k grande o suficiente isso não geraria uma especie de O(n + nˆ2)? Eu não tenho certeza se a notação ignoraria a influencia do k ou não. Se não ficou claro eu tento explicar de outra forma
É um loop dentro de um loop, mas o limite máximo de valores que vão ser visitados é 2N. Supondo que o primeiro bucket esteja cheio, todos os outros vazios, o a gente só visita 2n valores (n arrays vazios, e n valores no array cheio). Dado o input original N, a função ainda escala com complexidade temporal O(n). Da pra argumentar que é 3N ou 4N porque a gente visita os valores 3 ou 4x no máximo, mas não é N ao quadrado não. Eu sei que parece Nˆ2 por causa do loop dentro de loop, mas cada item só é visitado uma vez no máximo. Se eu aumentar o input em x1.000, o algoritmo não vai ficar 1 milhão de vezes mais lento.
Lembrei de um exercício... a2b3cb Precisa contar quantas letras tem de cada uma, exemplo acima, 1a 3b 3c Apanhei e não entreguei completo fui resolver outras questões e cá estou aqui querendo melhorar
Tentei resolver esse problema e fiquei com dor de cabeça kkkk, foquei em tentar encontrar uma solução O(n) mas tive muitos problemas com elementos repetidos no array, fico me perguntando o que me faltou pra resolver esse problema...
Obrigado pelo vídeo, incrível a explicação. Galera uma dúvida. Onde posso encontrar conceitos mais profundos conforme listado no vídeo? Eu quero me aprofundar mais em estrutura de dados.
Só complementando, Sobre você ignorar O(3n), O(10.00n) ou O(x n + 2) é que você ignora constantes, já que quando um gráfico tende ao infinito constantes não alteram o comportamento de um gráfico. Só é relevante para notação BIG O o que altera o comportamento do gráfico da função. Sugiro ler O livro dos ratinhos(entendendo Algoritmos) e também o estudo de funções na matéria de cálculo
Eu CHUTO que o O(1) virou "convenção" pra falar de hash maps, dicts, e afins é pq todas linguagens maduras implementam algoritmos de hash de baixíssima colisão. Levando a um O(n) em worst cases sendo o N algumas raríssimas colisões.
Mesmo se houver colisões, na maioria dos casos é possivel preservar as operações O(1), basta aplicar a sondagem no encadeamento dos elementos corretamente
@@andredesantacruz cara tu tá sendo muito cricri, isso pode ser bom ou ruim. Tem que levar em conta o contexto: 1. O vídeo é sobre entrevistas usando problemas de leetcode. A não ser que tu tenha muito azar de pegar um entrevistador querendo foder, talvez pra vagas mais seniores, ou alguém te indage diretamente sobre worst-case, ninguém vai encher o saco por causa disso. 2. Nas implementações modernas, a ocorrência de O(n) continua extramemente rara. Acho que dizer "sempre" seja talvez super-estritamente incorrecto, é aceitável 99%, porque o worst case de O(n) é de ordens de magnitude mais raro de ser alcançar do que um típico worst-case O(n) pra outros algoritmos. A simples colisao teórica é diminuida em ordens de magnitude, e em algumas implementacoes é realmente menor que O(n), como O(logn).
@@andrefig822 aí vai da subjetividade de cada um. Eu entendo teu ponto, mas na minha opinião está errado dizer "sempre" neste contexto, principalmente se tratando de entrevistas. Não fazer esse caveat e dizer que será sempre o(1) pode não tirar pontos em todas as entrevistas que você participar, mas certamente apontar isso te dará pontos, pois implica num entendimento mais amplo e mais correto sobre o algoritmo.
é um exemplo, ele diz SE tu sabe que é 6, depois ele usa len(nums) que é efetivamente tamanho. Resumindo, ele quer dizer que tu sempre sabe o tamanho e assim tu pode criar um array daquele tamanho
O máximo que um item pode aparecer é o tamanho do array "nums". Ele tirou 6 do primeiro exemplo do enunciado, pois imagina que o array fosse assim: [1,1,1,1,1,1]: Nesse caso o 1 apareceu 6 vezes, ou, o tamanho do array "nums".
"Como eu vou saber que o sort é nlogn?" Ué, estudando algoritmos e estruturas de dados hahahahah primeiro algoritmo deveria ser um sort simples tipo o bubble sort
Bubble é uns dos piores algoritms de ordenação que existem. Junto com ele está o insertionSort, counting e selection sort. Todos O(nˆ2). Os melhores são QuickSort, MergeSort e HeapSort, todos eles O(n log n). O QuickSort pode vir a ser O(nˆ2) também se você passar um array já ordenado pra ele, daí ele pena.
@31:08 há erro semantico nesta lógica. Exemplo: Quando o caractere em left não for uma letra e o caractere em right não for uma letra, o codigo vai entrar apenas no primeiro if corrigir apenas o left e pular o bloco do elif e do else. O caractere em right continuará errado por causa disso Pra corrigir ou faz a logica completa nas expressões como abaixo: If not s_list[left].isalpha() and not s_list[right].isalpha():continue Elif not s_list[left].isalpha() and s_list[right].isalpha():continue Elif s_list[left].isalpha() and not s_list[right].isalpha():continue Elif s_list[left].isalpha() and s_list[right].isalpha():continue Ou separa os código e faz a verificação uma após as outras. If not s_list[left].isalpha():continue If not s_list[right].isalpha():continue (Tem que substituir os 'continue' pelo codigo certo que não escrevi pra ser breve)
Eu não esperei você terminar e falei meio cedo kkkk Não tem erro semântico. Você só posterga a alteração pro próximo loop. Eu não sei se resulta em melhora ou não mas eu faria de outra maneira: Conferiria as letras nos ponteiros e corrigiria se não estivessem certos e já tentaria trocar as letras em todo loop. If not s_list[left].isalpha(): "corrige left" If not s_list[right].isalpha(): "corrige right" If s_list[left].isalpha() and s_list[right].isalpha(): "inverte letras" Assim pelo menos você move dois ponteiros e faz uma alteração na lista por loop, enquanto no seu código você faria no máximo uma operação por loop.
Ai na entrevista fazem LeetCode, querem na ponta da lingua tudo sobre a linguagem, live coding e etc. Pra contratar um cara que nao participa de Daily, nao fala com equipe, apenas arrasta card e mal aparece.
Caraca, maluco.
Toda vez que assisto o Galego eu descubro que preciso estudar mais e mais algoritmos. Mesmo tendo mais de 10 anos de carreira.
bom saber disso, venho estudando programacao a alguns anos e esse assunto de algoritmos e estruturas de dados esta sendo ridiculamente dificil para mim, talvez seja melhor focar nisso no futuro, ou pelo menos nao me cobrar tanto por nao saber resolver 80% das questoes que eu tento resolver
Área ingrata né, rsrs. Mas isso é bom, eu particularmente gosto dessa pulguinha atrás da orelha eterna hahahah
Eterno aprendiz né
@@renegildo4408 nao se sinta sozinho .. estamos na mesma .
Imagina eu 1 ano e pouco mds
tudo isso pra no fim vc fazer CRUD sem padrões
Ou tudo isso pra vc treinar a sua capacidade cognitiva e ser um ser humano mais inteligente
ou ganhar R$ 1.500,00
Tem outros meios mais interessante pra se treinar a capacidade cognitiva e se tornar mais inteligente.
Mas se isso faz vc se sentir mais engajado pra treinar isso, vá em frente
Boa parte dos que mandam bem nesse tipo de desafio simplesmente decoram a solução com a explicação, existem até livros acadêmico mostrando esses problemas e as soluções.
Quer achar alguém preparado? Traz um problema não convencional.
@@Richsan E um exercício simples, ninguém vai virar Albert Ainstem fazendo leetcode, mas e um começo para o raciocínio de logica de programação. Logico que a milhares de pessoas que só irão decorar, pelo simples fato de que as pessoas são desleixadas com o seu intelecto e raciocínio, mas só de algumas verem os vídeos do augusto e irem atrás de se aperfeiçoar já faz com que elas comecem o treino cognitivo com foco em programação.
Ótimo vídeo, como sempre. Traz mais sobre dsa, é sempre muito útil.
Opa, brigadão e pode deixar!
Outra solução que é linear para o primeiro problema:
arr = radix_sort(arr)
return maior_sequencia_array_ordenado(arr)
como os números são limitados, dá para usar radix sort, que é O(n). Na prática, porém, roda mais lento que as ordenações presentes nas linguagens. Mas ainda assim atende conceitualmente o que foi pedido, e usa espaço adicional O(1) em vez de Θ(n) como no hash, e numa entrevista mostrar isso pode ser interessante.
Galegão, faz um tempo que consegui uma oferta de uma FAANG e de certa forma seus vídeos me ajudaram a me preparar para as entrevistas. Conteúdo muito brabo, que a gente só encontra do mesmo nível na gringa, muito obrigado por ajudar a todos meu mano!!
Salve Flash, te anima fazer um review de todo o processo??
Sempre odiei estudar LeetCode e estrutura de dados, e estou conseguindo acompanhar mt bem as séries do Galego aqui e tá me ajudando bastante. Parabéns Galeeego
Cara! pra mim o que mais abriu minha mente foi o fato que eu tentava ao máximo evitar percorrer o array "sem fazer nada" (só transformando ele), sempre voltava a minha atenção em percorrer o array uma vez só.
Mas o incrível é que só quando você abandona a ideia de querer passar uma vez só no array você é capaz de fazer a checagem de "esse elemento é o início da lista?" em O(1), que é o centro que permite a solução inteira ser O(n)
@15:55 pequena ineficiência no iterador. Deveria ter usado "for ... in num_set" ao invés de "for ... in nums"
Se nums=[0,0,0,0,1,2,3,4,...,100], por exemplo, toda vez que iterar num=0 você vai verificar a sequencia 0,1,2,...,100 de novo.
Usando num_set como iteravel você garante que so vai iterar em num=0 uma vez.
Bacana demais a sua iniciativa de abrir esses conceitos de programação aqui no TH-cam. Já te assisto há um tempo e é sempre bom aprender e reforçar conteúdos com os seus vídeos.
Cara, bigO é infinitamente a parte mais facil de resolver. Eu so nao lembrava se o sort era log N ou n log N mas é bem tranquilo. Essa do set eu nao pensaria nem a pau. kkkk
Muito bom! Continue fazendo vídeos nesse tema, sua didática é ótima!
Professor, compra uma mesa digitalizadora, tipo aquelas para desenho. Creio que vai ficar muito bom e alinhado com tua didática !
eu nunca voltei um vídeo tantas vezes kkk, se eu viajava por 10 segundos, tinha que voltar por que perdia o raciocíno kkkk. Parabéns pelo conteúdo vc é fera!
A resposta do primeiro problema está *incompleta*, e tem tempo Θ(n²). Para perceber isto, basta dar como entrada um array com n/2 zeros, e os demais números de 1 a n/2. Assim, para cada zero ele vai fazer n/2 buscas da mesma sequência, resultando em n²/4 operações. Para resolver isso pode-se manter um hash com todos os números iniciais já tratados, para que não sejam verificados mais de uma vez.
Acho que uma outra forma de tratar isso é, percorrer o próprio `set` criado, visto que ele não vai conter números repetidos.
Muito bom o seu video, sou iniciante e me ajuda muito a estudar, por favor continue!
Obrigado pelo vídeo, aprendi bastante coisa e ainda consegui aplicar o que li até agora no livro de Algoritmos.
Fiz uma entrevista que teve leet code, e fiz exatamente isso ao ordenar uma lista, usei um .sort(), o que transformou minha solução em O(n log n).
update: agora após ver o vídeo, que legal um ótimo exercício, parabéns pelo vídeo. agora vou refazer o exemplo kkkkk
pausei o vídeo e tentei resolver, ta longe de ser ótimo mas cheguei nessa solução
# l = [100,4,200,1,3,2]
l = [0,3,7,2,5,8,4,6,0,1]
def fu(l):
cont = 1
for i in range(len(l) - 1):
if l[i + 1] - l[i] == 1:
cont += 1
else:
break
return cont
l2 = list(set(l))
l2.sort()
print(l2)
resultado = fu(l2)
print(resultado)
Muito bom o video, estou entrando na area e me ajudou mt.
Eu foquei muito em crud e afins, peguei uma entrevista com live coding na letcode e me lasquei kkk era pra calcular o máximo de água que caberia dentro de um retângulo.
Agora que pelo menos 5.553 pessoas já sabem disso, não estarei na frentekkkkkkkk brincadeiras à parte, ótimo vídeo Augusto!
Muito bom, ótima explicação!
Recentemente terminei meu curso de tecnico de Desenvolviemnto de Sistemas e cai nesse video é normal nao ter entedido nada sobre esse tal "O(n log n)" e o que eu deveria estudar para sanar essa duvida, obrigado pelo seu tempo
Sobre a Higlobe: qual é o ágil que eles usam na hora traduzir USD pra BLR? eles usam o câmbio que tá no google?
Muito bom esse video cara, parabens
muito bom, valeu Galeguinho kkk
Difícil é arrumar entrevista
o mercado hoje parte a partir de pleno+, mesmo deixando "explicito" que a vaga é de "estagio" (entre mil aspas) o nivel sempre parte de pleno+. Falo isso com tranquilidade, porque participei de um programa de bolsas na Compass UOL pra ser estagiario fiquei 4 ou 5 meses no programa de bolsas e no final escolheram um senior pra estagiar com eles kkkkkk
Antes de tudo, o vídeo é excelente. Mas tentando entender um pouco melhor o que foi abordado, está correto considerar a solução do primeiro problema O(n)? Ele diz que a busca em uma hash-table da vida é O(1), mas na verdade é Θ(1) e O(n). Tudo bem, eu entendo que pra boa parte das entradas, a gente iria bater no caso médio e então conseguir resolver em um tempo linear, mas é incorreto dizer que a solução é O(n), não?
Galego monstrooooo, top d+ ...
Pessoal, no segundo problema, tem loop aninhado. Alguém pra me explicar porque mesmo assim a solução é O(n).?Buguei
o segundo loop ocorre N vezes, pq é um loop das frequencias e tem N números no array de frequências
Qual o nome do software que usa para fazer os esboços no vídeo?
Cara, uma coisa que não ficou claro é como você computou O(n) se existe um for dentro de outro for no problem 347. Me parece que no pior caso buckets[freq] pode ter um tamanho n. E com um k grande o suficiente isso não geraria uma especie de O(n + nˆ2)? Eu não tenho certeza se a notação ignoraria a influencia do k ou não. Se não ficou claro eu tento explicar de outra forma
É um loop dentro de um loop, mas o limite máximo de valores que vão ser visitados é 2N. Supondo que o primeiro bucket esteja cheio, todos os outros vazios, o a gente só visita 2n valores (n arrays vazios, e n valores no array cheio). Dado o input original N, a função ainda escala com complexidade temporal O(n). Da pra argumentar que é 3N ou 4N porque a gente visita os valores 3 ou 4x no máximo, mas não é N ao quadrado não.
Eu sei que parece Nˆ2 por causa do loop dentro de loop, mas cada item só é visitado uma vez no máximo.
Se eu aumentar o input em x1.000, o algoritmo não vai ficar 1 milhão de vezes mais lento.
@@GutoGalego Ah po entendi, verdade. Acaba sendo um 4n porque de fato os n não se multiplicam pela ocorrência única!
augusto, qual q é esse teu aplicativo para fazer anotações e desenhos?
Também sempre quis saber @augusto
@@misesdev se chama excalildraw
Uma pena que a Highgloe não atue fora dos EUA, torcendo pra eles expandirem a operação pra Europa também.
Oiee, Que app vc usa pra desenhar amigo?
Lembrei de um exercício...
a2b3cb
Precisa contar quantas letras tem de cada uma, exemplo acima,
1a
3b
3c
Apanhei e não entreguei completo fui resolver outras questões e cá estou aqui querendo melhorar
E lá vamos nós.
Tentei resolver esse problema e fiquei com dor de cabeça kkkk, foquei em tentar encontrar uma solução O(n) mas tive muitos problemas com elementos repetidos no array, fico me perguntando o que me faltou pra resolver esse problema...
no segundo exercício qual seria a complexidade de mandar um groupBy e ordenar por count ? hahahaha
Excelente conteúdo! Uma dúvida, qual ferramenta você usa para fazer a drawing dos exemplos?
excalidraw
Obrigado pelo vídeo, incrível a explicação.
Galera uma dúvida. Onde posso encontrar conceitos mais profundos conforme listado no vídeo?
Eu quero me aprofundar mais em estrutura de dados.
Logo eu trago um vídeo sobre isso no canal, muita gente pede. Video explicando como se aprofundar em leetcode / DSA
Tu é foda demais
Seria bom dizer qual os que mais caem para cada nível (júnior, pleno, sênior).
Obrigado pela ajuda! Quem bom que você não focou em resolver usando ferramentas próprias de python, pois eu sou de C# rsrsrs
Qual o nome desse software em que você desenha?
excalildraw
Ainda sou um mero mortal, mas um dia gostaria de entender perfeitamente os seus vídeos
Galego, se o transformar em set é n, e o loop é n, a função é 2n não n², ai nas regras do bigO a gente ignora esses numeros né
se pra cada iteração vc fizesse um processo que é n ai sim seria n²
@Augusto, pode me indicar um bom livro que ensina bem tudo isso que foi abordado ?
Tudo isso é complicado. Mas daqui 1 semana vai ter algo nesse sentido aqui no canal, muita gente pedindo
a Higlobe só funciona com os EUA e em dólar? se eu trabalhar para algum país europeu também dá certo?
Que site é esse que tem os testes?
Só complementando,
Sobre você ignorar O(3n), O(10.00n) ou O(x n + 2)
é que você ignora constantes, já que quando um gráfico tende ao infinito constantes não alteram o comportamento de um gráfico.
Só é relevante para notação BIG O o que altera o comportamento do gráfico da função.
Sugiro ler O livro dos ratinhos(entendendo Algoritmos) e também o estudo de funções na matéria de cálculo
Acho que ele sabe disso, só escolheu explicar de uma forma mais intuitiva
Isso aí na matemática se chama análise assintótica, só o pessoal pesquisar esse termo se quiser se aprofundar nisso.
No minuto 23:02, deveria ter dito: Como o 3 apareceu 1 vez eu jogo ele aqui.
Pequena correção: não é sempre que hash maps terão operações em O(1). Se houver colisões, algumas operações podem chegar a O(n).
Eu CHUTO que o O(1) virou "convenção" pra falar de hash maps, dicts, e afins é pq todas linguagens maduras implementam algoritmos de hash de baixíssima colisão. Levando a um O(n) em worst cases sendo o N algumas raríssimas colisões.
@@cassiomorais2616 sim, é que no vídeo o cara diz que é "sempre" O(1), que está objetivamente errado.
Mesmo se houver colisões, na maioria dos casos é possivel preservar as operações O(1), basta aplicar a sondagem no encadeamento dos elementos corretamente
@@andredesantacruz cara tu tá sendo muito cricri, isso pode ser bom ou ruim. Tem que levar em conta o contexto:
1. O vídeo é sobre entrevistas usando problemas de leetcode. A não ser que tu tenha muito azar de pegar um entrevistador querendo foder, talvez pra vagas mais seniores, ou alguém te indage diretamente sobre worst-case, ninguém vai encher o saco por causa disso.
2. Nas implementações modernas, a ocorrência de O(n) continua extramemente rara. Acho que dizer "sempre" seja talvez super-estritamente incorrecto, é aceitável 99%, porque o worst case de O(n) é de ordens de magnitude mais raro de ser alcançar do que um típico worst-case O(n) pra outros algoritmos. A simples colisao teórica é diminuida em ordens de magnitude, e em algumas implementacoes é realmente menor que O(n), como O(logn).
@@andrefig822 aí vai da subjetividade de cada um. Eu entendo teu ponto, mas na minha opinião está errado dizer "sempre" neste contexto, principalmente se tratando de entrevistas. Não fazer esse caveat e dizer que será sempre o(1) pode não tirar pontos em todas as entrevistas que você participar, mas certamente apontar isso te dará pontos, pois implica num entendimento mais amplo e mais correto sobre o algoritmo.
Em 22:28 você diz que o máximo de vezes que um item pode aparecer é 6.
De onde você tirou isso? No exercício não fala nada.
é um exemplo, ele diz SE tu sabe que é 6, depois ele usa len(nums) que é efetivamente tamanho. Resumindo, ele quer dizer que tu sempre sabe o tamanho e assim tu pode criar um array daquele tamanho
@@daniellemes1163 Acredito que o corte que deixou confuso
é isso, é len(nums) o maximo, 6 era o exemplo atual. Logo dps eu inicializo buckets no numero de len(nums)
O máximo que um item pode aparecer é o tamanho do array "nums". Ele tirou 6 do primeiro exemplo do enunciado, pois imagina que o array fosse assim: [1,1,1,1,1,1]: Nesse caso o 1 apareceu 6 vezes, ou, o tamanho do array "nums".
To aprendendo mais aqui eu na faculdade 😂😂😂
"Como eu vou saber que o sort é nlogn?"
Ué, estudando algoritmos e estruturas de dados hahahahah primeiro algoritmo deveria ser um sort simples tipo o bubble sort
Bubble é uns dos piores algoritms de ordenação que existem. Junto com ele está o insertionSort, counting e selection sort. Todos O(nˆ2). Os melhores são QuickSort, MergeSort e HeapSort, todos eles O(n log n). O QuickSort pode vir a ser O(nˆ2) também se você passar um array já ordenado pra ele, daí ele pena.
Timsort é O( nlogn) também
Mano tu é parente do Gabriel Poliglota?
parece muito né? kkkkk
@@brunopidde3156 até a voz é igual
Muito bom!
@31:08 há erro semantico nesta lógica.
Exemplo:
Quando o caractere em left não for uma letra e o caractere em right não for uma letra, o codigo vai entrar apenas no primeiro if corrigir apenas o left e pular o bloco do elif e do else. O caractere em right continuará errado por causa disso
Pra corrigir ou faz a logica completa nas expressões como abaixo:
If not s_list[left].isalpha() and not s_list[right].isalpha():continue
Elif not s_list[left].isalpha() and s_list[right].isalpha():continue
Elif s_list[left].isalpha() and not s_list[right].isalpha():continue
Elif s_list[left].isalpha() and s_list[right].isalpha():continue
Ou separa os código e faz a verificação uma após as outras.
If not s_list[left].isalpha():continue
If not s_list[right].isalpha():continue
(Tem que substituir os 'continue' pelo codigo certo que não escrevi pra ser breve)
Eu não esperei você terminar e falei meio cedo kkkk
Não tem erro semântico. Você só posterga a alteração pro próximo loop.
Eu não sei se resulta em melhora ou não mas eu faria de outra maneira:
Conferiria as letras nos ponteiros e corrigiria se não estivessem certos e já tentaria trocar as letras em todo loop.
If not s_list[left].isalpha(): "corrige left"
If not s_list[right].isalpha(): "corrige right"
If s_list[left].isalpha() and s_list[right].isalpha(): "inverte letras"
Assim pelo menos você move dois ponteiros e faz uma alteração na lista por loop, enquanto no seu código você faria no máximo uma operação por loop.
Muito boom
Que vídeo bom
No fim é td um treino, só é um filtro e filtra quem nao estudou estes algoritmos
Boa!
Ai na entrevista fazem LeetCode, querem na ponta da lingua tudo sobre a linguagem, live coding e etc.
Pra contratar um cara que nao participa de Daily, nao fala com equipe, apenas arrasta card e mal aparece.
kkkkkkkkk eh bem isso.. e fica ai dando manutenção e espera alguma task aparecer e fica assim 2 ou 3 meses.. e ai aparece o layoff
kkkkkk, problemas de empresa grande, se fosse equipe de 4-5 devs todos fazem de tudo n tinha esse problema
muito bom
e no final ficar fazendo CRUD 😭😭😭
É, preciso estudar mais
Só reclama de LeetCode quem não tem capacidade de resolver os problemas.
Gosto do leetcode, mas ele é bem limitado em relação às linguagens de programação suportadas.