Author Archives: Luis Fernando Chaim

NBO

O conceito de Next Best Offer (NBO), também conhecido como Próxima Melhor Oferta, é uma abordagem utilizada principalmente em marketing, vendas e atendimento ao cliente com o objetivo de identificar e oferecer, de forma personalizada, o produto, serviço ou ação mais relevante para um cliente em um dado momento.

🌟 O que é Next Best Offer?

Next Best Offer é uma estratégia orientada por dados que utiliza algoritmos de análise preditiva, inteligência artificial e machine learning para prever qual oferta tem maior probabilidade de ser aceita por um cliente. A ideia é aumentar a relevância da comunicação com o cliente e, assim, melhorar taxas de conversão, satisfação e retenção.


🎯 Objetivos principais

  • Personalizar a experiência do cliente
  • Aumentar o valor do cliente ao longo do tempo (Customer Lifetime Value)
  • Reduzir ofertas irrelevantes ou genéricas
  • Melhorar a eficiência das campanhas de marketing

⚙️ Como funciona?

O processo de NBO envolve várias etapas:

  1. Coleta de dados

    • Dados transacionais (compras anteriores, visitas ao site)
    • Dados demográficos
    • Comportamento digital (cliques, tempo de permanência, abandono de carrinho)
    • Dados contextuais (localização, hora, canal de acesso)
  2. Análise e segmentação

    • Machine learning é usado para identificar padrões e segmentar clientes com base em comportamento e preferências.
  3. Cálculo de probabilidade

    • Algoritmos avaliam a probabilidade de um cliente aceitar uma determinada oferta.
  4. Rankeamento das ofertas

    • As ofertas são priorizadas por relevância e valor para o cliente e para o negócio.
  5. Apresentação no canal apropriado

    • A oferta é feita no canal ideal (e-mail, app, call center, site etc.) no momento certo.

🧠 Técnicas e tecnologias envolvidas

  • Machine Learning / AI
  • Modelos preditivos e classificadores
  • Sistemas de Recomendação (Recommendation Engines)
  • Processamento de linguagem natural (NLP) para entender preferências a partir de interações

💼 Exemplos práticos

  • E-commerce: Após comprar um smartphone, o sistema recomenda capas ou fones de ouvido compatíveis.
  • Bancos: Cliente com padrão de gastos crescente recebe sugestão de upgrade de cartão de crédito.
  • Telecom: Oferta de pacote adicional quando o cliente se aproxima do limite de dados.
  • Streaming: Recomendação de filmes ou séries com base no histórico e no perfil de consumo.

🧩 Diferença entre NBO e NBE

Além do NBO, há também o conceito de Next Best Experience (NBE):

Conceito Foco
Next Best Offer Produto ou serviço certo para o cliente
Next Best Experience Melhor ação para melhorar a experiência do cliente, que pode não envolver venda

Exemplo de NBE: um atendimento proativo para resolver uma falha antes que o cliente reclame.


📈 Benefícios para o negócio

  • Aumento da taxa de conversão
  • Redução de churn (cancelamento)
  • Melhoria na experiência do cliente
  • Otimização de campanhas de marketing
  • Crescimento da fidelização

Se quiser, posso mostrar um exemplo técnico (em pseudocódigo ou com alguma linguagem) de como isso pode ser modelado, por exemplo, com um classificador de NBO. Quer seguir por esse caminho?

Legal! Vamos montar um exemplo técnico simplificado de como modelar o conceito de Next Best Offer (NBO) utilizando Machine Learning com classificação. Vou estruturar assim:


🧪 Exemplo Técnico de Next Best Offer com Classificação (em Python + scikit-learn)

🎯 Cenário

Imagine que somos uma empresa de telecom. Queremos prever qual o melhor produto/serviço para oferecer a um cliente com base no seu histórico de uso e perfil.

Temos 3 ofertas possíveis:

  • Plano Dados Premium
  • Upgrade para Fibra
  • Assinatura de Streaming

🧾 Dataset simplificado (exemplo)

idade tipo_cliente uso_dados (GB) visitas_app oferta_aceita
25 novo 10 3 Plano Dados Premium
40 regular 20 1 Upgrade para Fibra
30 novo 15 5 Assinatura de Streaming

🧠 Etapas do modelo

import pandas as pd
from sklearn.preprocessing import LabelEncoder
from sklearn.model_selection import train_test_split
from sklearn.ensemble import RandomForestClassifier

# 1. Dados simulados
dados = pd.DataFrame({
    'idade': [25, 40, 30, 22, 55],
    'tipo_cliente': ['novo', 'regular', 'novo', 'regular', 'novo'],
    'uso_dados': [10, 20, 15, 25, 5],
    'visitas_app': [3, 1, 5, 2, 4],
    'oferta_aceita': [
        'Plano Dados Premium',
        'Upgrade para Fibra',
        'Assinatura de Streaming',
        'Upgrade para Fibra',
        'Plano Dados Premium'
    ]
})

# 2. Pré-processamento
label_enc = LabelEncoder()
dados['tipo_cliente'] = label_enc.fit_transform(dados['tipo_cliente'])  # 'novo'=1, 'regular'=0
dados['oferta_aceita'] = label_enc.fit_transform(dados['oferta_aceita'])  # transforma em 0,1,2

X = dados.drop('oferta_aceita', axis=1)
y = dados['oferta_aceita']

# 3. Treinamento do modelo
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=42)
modelo = RandomForestClassifier()
modelo.fit(X_train, y_train)

# 4. Previsão do NBO para novo cliente
novo_cliente = pd.DataFrame({
    'idade': [28],
    'tipo_cliente': [label_enc.transform(['novo'])[0]],
    'uso_dados': [18],
    'visitas_app': [4]
})

previsao = modelo.predict(novo_cliente)
oferta_prevista = label_enc.inverse_transform(previsao)[0]
print(f"👉 Próxima Melhor Oferta: {oferta_prevista}")

🧠 O que está acontecendo?

  • Coletamos dados do cliente (idade, uso, perfil).
  • Treinamos um modelo com exemplos reais.
  • Para um novo cliente, o modelo prediz a oferta com maior probabilidade de aceitação.
  • Usamos Random Forest como classificador, mas outros algoritmos (como XGBoost, redes neurais ou regressão logística) também podem ser usados, dependendo do volume e complexidade dos dados.

Se você quiser, posso mostrar também um fluxo mais realista com pesos por lucratividadecanal ideal e até abordagem multi-oferta. Quer explorar mais algum desses pontos?

Plano de Estudo HackerRank

Aqui vai um plano de estudo de 12 semanas, pensado para te preparar para as entrevistas de emprego usando os desafios do HackerRank. Esse cronograma é flexível e pode ser ajustado ao seu ritmo e às suas necessidades, mas ele abrange os tópicos e algoritmos que costumam ser mais solicitados em processos seletivos.


Semana 1: Preparação e Revisão da Lógica de Programação

  • Objetivo: Garantir que você esteja confortável com a linguagem de programação que irá utilizar (Python, Java, C++, etc.) e com os fundamentos da lógica.
  • Atividades:
    • Revisão dos Fundamentos: Variáveis, estruturas condicionais, loops e recursão.
    • Exercícios Básicos: Utilize problemas simples do HackerRank para se familiarizar com a plataforma e o ambiente de desenvolvimento.
  • Dicas Importantes:
    • Certifique-se de entender bem a notação Big-O para poder analisar a complexidade dos algoritmos.
    • Mantenha um caderno ou documento com anotações dos principais “patterns” que você for encontrando.

Semana 2: Arrays e Strings

  • Objetivo: Refletir sobre os padrões de manipulação de dados lineares.
  • Atividades:
    • Estudo Teórico: Revisão de operações básicas em arrays (busca, iteração, divisão e conquista) e manipulação de strings (análise de padrões, substrings, palíndromos).
    • Prática: Resolva exercícios focados em arrays e strings, como encontrar subarrays com soma máxima, reversão de strings, anagramas e problemas de sliding window.
  • Dicas Importantes:
    • Ao resolver cada exercício, tente identificar se há padrões que se repetem e como otimizar a solução.

Semana 3: Listas Ligadas e Estruturas Dinâmicas

  • Objetivo: Compreender estruturas dinâmicas e a manipulação de ponteiros ou referências.
  • Atividades:
    • Estudo Teórico: Conceitos de listas encadeadas (simples e duplamente ligadas).
    • Prática: Exercícios envolvendo inserção, remoção, reversão de listas e a detecção de ciclos.
  • Dicas Importantes:
    • Visualize as estruturas desenhando diagramas simples à mão; isso ajuda na fixação dos conceitos.

Semana 4: Pilhas, Filas e Deque

  • Objetivo: Dominar o uso dessas estruturas para resolver problemas que exigem controle de ordem.
  • Atividades:
    • Estudo Teórico: Funcionamento e casos de uso para pilhas, filas e deques.
    • Prática: Exercícios sobre validação de expressões (como parênteses balanceados), avaliação de expressões e problemas que fazem uso de algoritmos de visitação.
  • Dicas Importantes:
    • Refaça os exercícios de formas diferentes para ver como pequenas alterações podem impactar a performance.

Semana 5: Recursão e Técnicas de Backtracking

  • Objetivo: Desenvolver a habilidade de pensar e implementar soluções recursivas.
  • Atividades:
    • Estudo Teórico: Conceitos de recursão, pilha de execução e backtracking para resolução de problemas.
    • Prática: Resolva problemas envolvendo geração de permutações, combinação de dados e labirintos com backtracking.
  • Dicas Importantes:
    • Escreva “tracebacks” manuais para entender a ordem de execução da sua recursão.

Semana 6: Busca e Ordenação

  • Objetivo: Revisar algoritmos clássicos de ordenação e busca, fundamentais para otimização.
  • Atividades:
    • Estudo Teórico: Bubble Sort, Merge Sort, Quick Sort e Binary Search.
    • Prática: Resolva desafios que combinem ordenação com busca, como problemas que exijam divisão e conquista.
  • Dicas Importantes:
    • Sempre compare as diferentes abordagens para um mesmo problema e discuta sobre as vantagens e desvantagens de cada algoritmo.

Semana 7: Estruturas de Dados Avançadas – Árvores

  • Objetivo: Entender a estrutura, travessias e operações em árvores.
  • Atividades:
    • Estudo Teórico: Conceitos de árvores binárias e árvores de busca binária (BSTs); métodos de travessia (inorder, preorder, postorder).
    • Prática: Resolva problemas que envolvam a busca do menor ancestral comum (LCA), inserção e remoção em BSTs e a verificação de propriedades de árvores.
  • Dicas Importantes:
    • Pratique desenhando árvores e mapeando as chamadas recursivas para visualizar as travessias.

Semana 8: Grafos

  • Objetivo: Compreender as bases dos algoritmos de grafos, que aparecem com frequência em entrevistas.
  • Atividades:
    • Estudo Teórico: Conceitos de grafos direcionados e não direcionados; profundidade de busca (DFS) e largura de busca (BFS); algoritmos para caminhos mínimos.
    • Prática: Resolva desafios que envolvam encontrar componentes conectados, ciclos, e caminhos mínimos (como Dijkstra ou BFS em grafos não ponderados).
  • Dicas Importantes:
    • Use listas de adjacência para representar grafos e pratique implementações tanto recursivas quanto iterativas.

Semana 9: Programação Dinâmica (DP)

  • Objetivo: Desenvolver uma mentalidade para identificar subproblemas que se repetem.
  • Atividades:
    • Estudo Teórico: Conceitos de memoization versus tabulação, e como reconhecer problemas passíveis de DP.
    • Prática: Exercícios clássicos – Fibonacci, knapsack, longest common subsequence, e longest increasing subsequence.
  • Dicas Importantes:
    • Crie tabelas ou diagramas para rastrear suas soluções. Isso é essencial para debugar e otimizar algoritmos dinâmicos.

Semana 10: Algoritmos Gulosos (Greedy) e Técnica de Divisão de Problemas

  • Objetivo: Aprender a identificar e aplicar soluções “gulosas” quando aplicáveis.
  • Atividades:
    • Estudo Teórico: Explorar o conceito de escolhas locais que levam à solução global, com exemplos práticos.
    • Prática: Resolva problemas como seleção de atividades, mudanças de moedas e interval scheduling, onde a abordagem greedy é eficiente.
  • Dicas Importantes:
    • Sempre questione se a solução greedy garante a otimização total. Às vezes, ela funciona impecavelmente; em outras, pode ser um ponto de partida.

Semana 11: Simulações e Revisão Integrada

  • Objetivo: Unir os conhecimentos adquiridos e aumentar a velocidade de resolução.
  • Atividades:
    • Simulações de Entrevistas: Resolva problemas com limite de tempo para simular o ambiente de uma entrevista.
    • Revisão Cruzada: Identifique os tópicos em que você tem mais dificuldade e refaça exercícios para consolidar o aprendizado.
  • Dicas Importantes:
    • Grave-se explicando suas soluções (mesmo que só para você) para melhorar a clareza na comunicação do raciocínio.

Semana 12: Revisão Final, Soft Skills e Estratégias de Entrevista

  • Objetivo: Refinar sua abordagem e preparar sua “mindset” para a entrevista.
  • Atividades:
    • Revisão Geral: Faça uma recapitulação rápida dos tópicos estudados, focando em exercícios errados ou que geraram dúvidas.
    • Comunicação do Raciocínio: Pratique “pensar em voz alta” enquanto resolve problemas, explicando passo a passo como chegar à solução.
    • Feedback e Reflexão: Se possível, participe de sessões de mock interviews ou grupos de estudo para trocar feedback.
  • Dicas Importantes:
    • Além dos algoritmos, esteja preparado para perguntas comportamentais. A clareza na comunicação e a capacidade de justificar suas escolhas são tão importantes quanto a solução em si.

Considerações Adicionais

  • Flexibilidade e Adaptabilidade: Se sentir que algum tópico precisa de mais tempo, ajuste o cronograma. A ideia é que você se sinta confortável e confiante em cada área antes de avançar.
  • Registro de Progresso: Mantenha um diário de estudos, anotando os acertos, erros e insights. Isso irá ajudar a identificar padrões nos seus desafios e a medir a evolução.
  • Diversificar Fontes: Além do HackerRank, explore outras plataformas (como LeetCode, CodeSignal ou GeeksforGeeks) e recursos teóricos (livros, vídeos, blogs) para ampliar sua visão sobre cada tópico.
  • Saúde Mental e Descanso: Lembre-se de reservar tempo para pausas e reflexão. Algoritmos exigem tanto foco quanto criatividade, e um ritmo saudável de estudo é fundamental para manter a clareza mental.

Esse plano visa não só a prática intensa de resolução de problemas, mas também a internalização da lógica e a comunicação eficaz do seu raciocínio, que são pontos cruciais em entrevistas de emprego. Se você se aprofundar em cada tópico, registrando dúvidas e reforçando as áreas mais desafiadoras, estará preparado para enfrentar tanto as questões técnicas quanto as dinâmicas das entrevistas.

Caso queira expandir ainda mais sua preparação, podemos também explorar estratégias para designar revisões rápidas de complexidade ou até mesmo integrar estudos sobre design patterns e sistemas de arquitetura—tópicos que podem surgir em processos seletivos mais avançados.

Three Sum – 3Sum

Força Bruta

1class Solution {
2    public List<List<Integer>> threeSum(int[] nums) {
3        List<List<Integer>> threeSums = new ArrayList<>();
4        
5        for (int i = 0; i < nums.length; i++) {
6            for (int j = i+1; j < nums.length; j++) {
7                for (int k = j+1; k < nums.length; k++) {
8                    if (nums[i] + nums[j] + nums[k] == 0) {
9                        List<Integer> sortedAnswer = Arrays.asList(nums[i], nums[j], nums[k]);
10                        Collections.sort(sortedAnswer);
11                        if (!threeSums.contains(sortedAnswer)) {
12                            threeSums.add(sortedAnswer);
13                        }
14                    }
15                }
16            }
17        }
18        
19        return threeSums;
20    }
21}

Complexidade de Tempo/Espaço

  • Complexidade de tempo:O(n³)
  • Complexidade do espaço: O(len(answer))(a complexidade do espaço será dimensionada de acordo com o número de trigêmeos encontrados)

Hashmap de soma dupla

1class Solution {
2    public List<List<Integer>> threeSum(int[] nums) {
3        Arrays.sort(nums);
4        List<List<Integer>> threeSums = new ArrayList<>();
5        for (int i = 0; i < nums.length; i++) {
6            if (i > 0 && nums[i] == nums[i - 1]) {
7                continue;
8            }
9            int target = -nums[i];
10            int l = i + 1, r = nums.length - 1;
11            while (l < r) {
12                if (nums[l] + nums[r] == target) {
13                    threeSums.add(Arrays.asList(nums[i], nums[l], nums[r]));
14                    l++;
15                    while (l < r && nums[l] == nums[l - 1]) {
16                        l++;
17                    }
18                } else if (nums[l] + nums[r] < target) {
19                    l++;
20                } else {
21                    r--;
22                }
23            }
24        }
25        return threeSums;
26    }
27}

Complexidade de Tempo/Espaço

  • Complexidade de tempo:O(n²)
  • Complexidade do espaço: O(n)(ou O(1)se classificado no local)

Two Sum – 2Sum

Força Bruta

1import java.util.HashMap;
2
3 class Solution {
4  public static int[] twoSum(int[] nums, int target) {
5      // 1. Iterate over every possible number pair
6      for (int i = 0; i < nums.length; i++) {
7          // j is always ahead of i so that we don't re-evaluate already evaluated sums
8          for (int j = i + 1; j < nums.length; j++) {
9              // 2. Check if a given pair adds up to our target
10              if (nums[i] + nums[j] == target) {
11                  // Return the indices when a pair has been found
12                  return new int[]{i, j};
13              }
14          }
15      }
16      // Return an empty array if no pair is found
17      return new int[]{};
18  }
19 }

Análise de Complexidade Temporal/Espaço

  • Complexidade de Tempo: O(n^2), onde né o tamanho do array. Para cada número, precisamos avaliar todos os outros números do array.

  • Complexidade do espaço: O(1), desconsiderando a entrada, todas as outras variáveis ​​têm espaço constante.

Tabela de hash

1import java.util.HashMap;
2
3 class Solution {
4  public static int[] twoSum(int[] nums, int target) {
5        // Our hash table that stores at which index the number is at
6        HashMap<Integer, Integer> numToIndex = new HashMap<>();
7        
8        // 1. Iterate over every number in the array
9        for (int i = 0; i < nums.length; i++) {
10            // 2. Calculate the complement that would sum to our target
11            int complement = target - nums[i];
12            
13            // 3. Check if that complement is in our hash table
14            if (numToIndex.containsKey(complement)) {
15                return new int[]{numToIndex.get(complement), i};
16            }
17            
18            // 4. Add the current number to our hash table
19            numToIndex.put(nums[i], i);
20        }
21        
22        // If no solution found, return an empty array
23        return new int[]{};
24    }
25 }

Complexidade de Tempo/Espaço

  • Complexidade de Tempo: O(n), onde né o tamanho do array. Iteramos sobre cada número no array e as operações de consulta/adição da tabela de hash levam um tempo constante.
  • Complexidade do Espaço: O(n), onde né o tamanho do array. Nosso mapa de hash armazena todos os números no array de entrada.

Past Tenses

Past Tenses

Simple Past

Definição

Ação finalizada no passado.

Situações de uso

Fatos concluídos
Sequência de eventos
Históricos ou rotinas

Exemplos

I watched a movie last night.
She visited Paris in 2020.
They finished the project yesterday.

Palavras-chave

yesterday
ago
last (week, year, night)
in (ano passado)

Estrutura

Sujeito + verbo regular (-ed) ou irregular (2ª coluna)

Erros comuns/dicas
Trocar regular/irregular
Esquecer “-ed”
Dica: revise a lista de verbos
Past Continuous
Definição
Ação em andamento no passado
Situações de uso
Ação interrompida por outra
Descrever contexto ou cenário no passado
Exemplos
I was studying when you called.
They were playing football at 5 p.m.
She was cooking while it was raining.
Palavras-chave
while
when
as
at (hora)
Estrutura
Sujeito + was/were + verbo-ing
Erros comuns/dicas
Trocar was/were
Esquecer “-ing” no verbo
Dica: was (I/he/she/it), were (you/we/they)
Past Perfect
Definição
Ação anterior a outra no passado
Situações de uso
Destacar o “passado do passado”
Sequência de fatos; justificar ação anterior
Exemplos
She had left before he arrived.
I had eaten when they called me.
They had finished the test before the bell rang.
Palavras-chave
before
after
by the time
already
just
Estrutura
Sujeito + had + particípio passado
Erros comuns/dicas
Esquecer particípio
Usar had + verbo no passado simples
Dica: use para deixar clara a ordem dos eventos
Past Perfect Continuous
Definição
Ação contínua ocorrendo antes de outra ação passada
Situações de uso
Destacar a duração da ação até certo ponto
Justificar motivos/efeitos visíveis no passado
Exemplos
I had been studying for two hours when you arrived.
She had been working there before she moved.
They had been waiting for the bus for thirty minutes.
Palavras-chave
for
since
until
when
all (day, morning, afternoon)
Estrutura
Sujeito + had been + verbo-ing
Erros comuns/dicas
Esquecer “been”
Confundir com Past Continuous
Dica: destaque a duração da ação antes de outro fato passado
Diferenças e Semelhanças
Simple Past vs Past Continuous
Simple Past: ação completa
Past Continuous: ação em andamento/foi interrompida
Past Perfect vs outros tempos
Past Perfect: deixa claro que a ação veio antes
Past Perfect Continuous vs outros tempos
Foco na duração antes de outro evento passado
Semelhanças
Todos referem-se a eventos no passado
Usados em narrativas do passado
Palavras-chave/Marcadores temporais
Simple Past: yesterday, ago, last, when, in (ano)
Past Continuous: while, when, as, at (hora)
Past Perfect: before, after, by the time, just, already
Past Perfect Continuous: for, since, until, when, all day
Dicas práticas gerais
Atenção à estrutura e aos marcadores
Pratique exemplos do cotidiano
Revise verbos irregulares com frequência
Não use had + verbo no passado simples, sempre particípio!

Top 100 Coding Test

HackerRank LeetCode
Two Sum
Reverse a Linked List
Merge Intervals
Longest Substring Without Repeating Characters
Binary Tree Inorder Traversal
Valid Parentheses
Search in Rotated Sorted Array
Merge Two Sorted Lists
Maximum Subarray
Word Break
Coin Change
Climbing Stairs
Subtree of Another Tree
Product of Array Except Self
Valid Anagram
Linked List Cycle
Find Minimum in Rotated Sorted Array
Combination Sum
House Robber
Longest Palindromic Substring
Word Ladder
Pow(x, n)
Rotate Image
Group Anagrams
Maximum Depth of Binary Tree
Insert Interval
Subsets
Palindromic Substrings
Minimum Path Sum
3Sum
Best Time to Buy and Sell Stock
Course Schedule
Linked List Random Node
Min Stack
Reverse Integer
Integer to Roman
Roman to Integer
Palindrome Number
Container With Most Water
Longest Valid Parentheses
Maximum Product Subarray
Search Insert Position
Unique Paths
Decode Ways
Jump Game
Word Search
Set Matrix Zeroes
Trapping Rain Water
Sudoku Solver
Spiral Order Matrix
Permutations
LRU Cache
Validate Binary Search Tree
Recover Binary Search Tree
Kth Largest Element
Merge K Sorted Lists
Flatten Nested List Iterator
Binary Tree Zigzag Level Order Traversal
Longest Consecutive Sequence
Graph Valid Tree
Course Schedule II
Valid Palindrome
Longest Common Prefix
Find Peak Element
Find the Duplicate Number
First Missing Positive
N-Queens
Minimum Window Substring
Rotate List
Word Search II
Basic Calculator
First Unique Character in a String
Serialize and Deserialize Binary Tree
Sort Colors
Find Median from Data Stream
Isomorphic Strings
Reverse Linked List II
Maximal Square
Largest Rectangle in Histogram
Binary Tree Maximum Path Sum
House Robber II
N-Queens II
Best Time to Buy and Sell Stock II
Clone Graph
Sliding Window Maximum
Merge Sorted Array
Find the Celebrities
Regular Expression Matching
Distinct Subsequences
Longest Increasing Subsequence
Palindrome Partitioning
Different Ways to Add Parentheses
Serialize and Deserialize BST
Range Sum Query
Jump Game II
Copy List with Random Pointer
Critical Connections in a Network
Coin Change 2
Path Sum
Number of Islands
Two Sum
Add Two Numbers
Longest Substring Without Repeating Characters
Median of Two Sorted Arrays
Longest Palindromic Substring
Zigzag Conversion
Reverse Integer
String to Integer (atoi)
Palindrome Number
Regular Expression Matching
Container With Most Water
Integer to Roman
Roman to Integer
Longest Common Prefix
3Sum
3Sum Closest
Letter Combinations of a Phone Number
Valid Parentheses
Merge Two Sorted Lists
Remove Nth Node From End of List
Generate Parentheses
Merge k Sorted Lists
Swap Nodes in Pairs
Reverse Nodes in k-Group
Remove Duplicates from Sorted Array
Remove Element
Implement strStr()
Divide Two Integers
Substring with Concatenation of All Words
Next Permutation
Longest Valid Parentheses
Search in Rotated Sorted Array
Find First and Last Position of Element in Sorted Array
Search Insert Position
Valid Sudoku
Sudoku Solver
Count and Say
Combination Sum
Combination Sum II
First Missing Positive
Trapping Rain Water
Multiply Strings
Jump Game
Permutations
Permutations II
Rotate Image
Group Anagrams
Pow(x, n)
N-Queens
N-Queens II
Maximum Subarray
Spiral Matrix
Jump Game II
Merge Intervals
Insert Interval
Length of Last Word
Spiral Matrix II
Set Matrix Zeroes
Search a 2D Matrix
Sort Colors
Minimum Window Substring
Search in Rotated Sorted Array II
Remove Duplicates from Sorted List
Remove Duplicates from Sorted List II
Subsets
Word Search
Climbing Stairs
Set Matrix Zeroes
Search a 2D Matrix II
Sort Colors
Minimum Path Sum
Unique Paths
Unique Paths II
Subsets II
Word Ladder
Word Ladder II
Longest Consecutive Sequence
Palindrome Partitioning
Restore IP Addresses
Distinct Subsequences
Largest Rectangle in Histogram
Maximal Rectangle
Scramble String
Interleaving String
Minimum Edit Distance
Decode Ways
Unique Binary Search Trees
Unique Binary Search Trees II
Validate Binary Search Tree
Binary Tree Maximum Path Sum
Flatten Binary Tree to Linked List
Populating Next Right Pointers in Each Node
Populating Next Right Pointers in Each Node II
Binary Tree Inorder Traversal
Binary Tree Preorder Traversal
Binary Tree Postorder Traversal
Symmetric Tree
Binary Tree Level Order Traversal
Binary Tree Zigzag Level Order Traversal
Maximum Depth of Binary Tree

 

Top 100 Algoritmos

Exemplos de algoritmos e estruturas de dados frequentemente usados em entrevistas técnicas, com explicações e exemplos para ajudar na compreensão:

Two Sum

Dado um array de inteiros, encontre dois números que somam um valor alvo específico.

Abordagem: Use um hash map para armazenar cada número do array e seu índice. Para cada número, verifique se o complemento (target – número) existe no hash map.
Exemplo: nums = [2, 7, 11, 15], target = 9. A solução é [0, 1] (porque nums[0] + nums[1] == 9).
Considerações: Ideal para demonstrar conhecimento de hash tables e otimização de tempo de execução de O(n^2) para O(n).
Reverse a Linked List: Inverta a ordem dos nós em uma linked list.

Abordagem: Use três ponteiros: prev, current e next. Itere pela lista, invertendo a direção dos ponteiros.
Exemplo: 1 -> 2 -> 3 -> 4 -> 5 torna-se 5 -> 4 -> 3 -> 2 -> 1.
Considerações: Importante para entender manipulação de ponteiros e linked lists.

Merge Intervals:

Dado uma coleção de intervalos, combine todos os intervalos sobrepostos.

Abordagem: Ordene os intervalos pelo início e, em seguida, itere sobre eles, combinando os intervalos sobrepostos.
Exemplo: [[1,3],[2,6],[8,10],[15,18]] torna-se [[1,6],[8,10],[15,18]].
Considerações: Demonstra conhecimento de algoritmos de ordenação e manipulação de intervalos.

Longest Substring Without Repeating Characters:

Encontre o comprimento da maior substring sem caracteres repetidos.

Abordagem: Use a técnica de sliding window com um hash set para rastrear os caracteres no intervalo atual.
Exemplo: Para “abcabcbb”, a resposta é 3 (“abc”).
Considerações: Útil para demonstrar otimização de algoritmos com sliding window.

Binary Tree Inorder Traversal:

Percorra uma binary tree usando a ordem inorder (esquerda, raiz, direita).

Abordagem: Use recursão ou uma pilha para implementar a travessia inorder.
Exemplo: Para uma árvore com raiz 1, esquerda 2, direita 3, a travessia inorder é 2 -> 1 -> 3.
Considerações: Fundamental para entender algoritmos de travessia de árvores.

Valid Parentheses:

Determine se uma string contendo parênteses é válida (ou seja, cada parêntese de abertura tem um parêntese de fechamento correspondente).

Abordagem: Use uma pilha para rastrear os parênteses de abertura. Quando encontrar um parêntese de fechamento, verifique se corresponde ao parêntese de abertura no topo da pilha.
Exemplo: “()[]{}” é válido, “(]” não é.
Considerações: Demonstra conhecimento de estruturas de pilha e correspondência de caracteres.

Search in Rotated Sorted Array:

Pesquise um valor em um array ordenado que foi rotacionado.

Abordagem: Use uma variação da busca binária. Encontre o ponto de rotação e, em seguida, execute a busca binária na metade apropriada do array.
Exemplo: [4,5,6,7,0,1,2], target = 0. A resposta é 4 (índice de 0).
Considerações: Demonstra conhecimento de busca binária e manipulação de arrays rotacionados.

Merge Two Sorted Lists:

Combine duas sorted linked lists em uma única sorted linked list.

Abordagem: Use um ponteiro para rastrear a cabeça da nova lista e compare os nós das duas listas para determinar qual nó adicionar à nova lista.
Exemplo: 1->2->4, 1->3->4 torna-se 1->1->2->3->4->4.
Considerações: Importante para entender manipulação de linked lists e algoritmos de ordenação.

Maximum Subarray:

Encontre a soma máxima de um subarray contíguo.

Abordagem: Use o algoritmo de Kadane, que mantém a soma máxima atual e a soma máxima até o momento.
Exemplo: [-2,1,-3,4,-1,2,1,-5,4]. A resposta é 6 ([4,-1,2,1]).
Considerações: Demonstra conhecimento de programação dinâmica e otimização de algoritmos.

Word Break:

Determine se uma string pode ser segmentada em uma sequência de palavras do dicionário.

Abordagem: Use programação dinâmica para construir uma tabela booleana indicando se cada prefixo da string pode ser segmentado.
Exemplo: s = “leetcode”, wordDict = [“leet”, “code”]. A resposta é true.
Considerações: Demonstra conhecimento de programação dinâmica e manipulação de strings.

Coin Change:

Dado um conjunto de denominações de moedas e um valor alvo, encontre o número mínimo de moedas necessárias para atingir o valor alvo.

Abordagem: Use programação dinâmica para construir uma tabela que armazena o número mínimo de moedas necessárias para cada valor de 0 ao valor alvo.
Exemplo: coins = [1, 2, 5], amount = 11. A resposta é 3 (5 + 5 + 1).
Considerações: Demonstra conhecimento de programação dinâmica e problemas de otimização.

Climbing Stairs:

Calcule o número de maneiras distintas de subir até o topo de uma escada com n degraus, onde você pode subir 1 ou 2 degraus de cada vez.

Abordagem: Use programação dinâmica. O número de maneiras de subir até o degrau n é a soma do número de maneiras de subir até o degrau n-1 e o degrau n-2.
Exemplo: Para n = 3, a resposta é 3 (1+1+1, 1+2, 2+1).
Considerações: Demonstra conhecimento de programação dinâmica e sequências de Fibonacci.

Subtree of Another Tree:

Determine se uma árvore é uma subárvore de outra árvore.

Abordagem: Percorra a árvore maior e, para cada nó, verifique se a subárvore enraizada nesse nó é idêntica à árvore menor.
Considerações: Importante para entender algoritmos de travessia de árvores e recursão.

Product of Array Except Self:

Dado um array de inteiros, retorne um novo array onde cada elemento no índice i é o produto de todos os elementos no array original, exceto o elemento no índice i.

Abordagem: Calcule os produtos prefixados e sufixados do array e, em seguida, multiplique-os para obter o resultado.
Exemplo: [1,2,3,4] torna-se [24,12,8,6].
Considerações: Demonstra conhecimento de manipulação de arrays e otimização de algoritmos.

Valid Anagram:

Determine se duas strings são anagramas uma da outra (ou seja, contêm os mesmos caracteres na mesma quantidade, mas em uma ordem diferente).

Abordagem: Use um hash map para contar a frequência de cada caractere em ambas as strings. Se os hash maps forem iguais, as strings são anagramas.
Exemplo: “anagram” e “nagaram” são anagramas.
Considerações: Demonstra conhecimento de hash maps e manipulação de strings.

Linked List Cycle:

Determine se uma linked list contém um ciclo.

Abordagem: Use o algoritmo da lebre e da tartaruga (dois ponteiros, um movendo-se duas vezes mais rápido que o outro). Se houver um ciclo, os ponteiros se encontrarão.
Considerações: Importante para entender manipulação de linked lists e algoritmos de detecção de ciclos.

Find Minimum in Rotated Sorted Array:

Encontre o elemento mínimo em um array ordenado que foi rotacionado.

Abordagem: Use uma variação da busca binária. Compare o elemento do meio com o elemento mais à direita para determinar qual metade do array contém o mínimo.
Considerações: Demonstra conhecimento de busca binária e manipulação de arrays rotacionados.

Combination Sum:

Dado um conjunto de números candidatos e um valor alvo, encontre todas as combinações únicas dos números candidatos que somam o valor alvo.

Abordagem: Use backtracking para explorar todas as combinações possíveis dos números candidatos.
Considerações: Demonstra conhecimento de backtracking e algoritmos de busca.

House Robber:

Dado um array de inteiros representando os valores das casas ao longo de uma rua, determine o valor máximo que você pode roubar sem roubar duas casas adjacentes.

Abordagem: Use programação dinâmica para construir uma tabela que armazena o valor máximo que você pode roubar até cada casa.
Considerações: Demonstra conhecimento de programação dinâmica e problemas de otimização.

Longest Palindromic Substring:

Encontre a substring palindrômica mais longa em uma determinada string.

Abordagem: Use programação dinâmica ou expanda ao redor do centro para encontrar a substring palindrômica mais longa.
Considerações: Demonstra conhecimento de programação dinâmica e manipulação de strings.

Word Ladder:

Dado uma palavra inicial, uma palavra final e um dicionário de palavras, encontre o comprimento da sequência de transformação mais curta da palavra inicial para a palavra final, usando apenas palavras do dicionário e alterando apenas uma letra de cada vez.

Abordagem: Use a busca em largura (BFS) para explorar o espaço de busca de palavras possíveis.
Considerações: Demonstra conhecimento de algoritmos de busca em grafos e manipulação de strings.
Pow(x, n): Implemente a função para calcular x elevado à potência n.

Abordagem: Use recursão e divida e conquiste para calcular a potência de forma eficiente.
Considerações: Demonstra conhecimento de recursão e algoritmos de divisão e conquista.

Rotate Image:

Gire uma matriz quadrada (imagem) 90 graus no sentido horário.

Abordagem: Inverta a matriz ao longo da diagonal principal e, em seguida, inverta cada linha.
Considerações: Demonstra conhecimento de manipulação de matrizes e operações in-place.

Group Anagrams:

Dado um array de strings, agrupe os anagramas juntos.

Abordagem: Use um hash map para mapear cada string para sua versão ordenada. Todas as strings que são anagramas umas das outras terão a mesma versão ordenada.
Considerações: Demonstra conhecimento de hash maps e manipulação de strings.

Maximum Depth of Binary Tree:

Encontre a profundidade máxima de uma binary tree.

Abordagem: Use recursão para percorrer a árvore e calcular a profundidade de cada nó. A profundidade máxima é a profundidade máxima de qualquer nó na árvore.
Considerações: Fundamental para entender algoritmos de travessia de árvores e recursão.

Insert Interval:

Dado uma lista de intervalos não sobrepostos, insira um novo intervalo na lista.

Abordagem: Encontre a posição correta para inserir o novo intervalo e, em seguida, combine quaisquer intervalos sobrepostos.
Considerações: Demonstra conhecimento de manipulação de intervalos e algoritmos de ordenação.

Subsets:

Dado um conjunto de números distintos, retorne todos os subconjuntos possíveis.

Abordagem: Use backtracking para gerar todos os subconjuntos possíveis.
Considerações: Demonstra conhecimento de backtracking e algoritmos de busca.

Palindromic Substrings:

Dado uma string, conte o número de substrings palindrômicas.

Abordagem: Use programação dinâmica ou expanda ao redor do centro para encontrar todas as substrings palindrômicas.
Considerações: Demonstra conhecimento de programação dinâmica e manipulação de strings.

Minimum Path Sum:

Dado uma grade de números não negativos, encontre um caminho da parte superior esquerda para a parte inferior direita que minimize a soma de todos os números ao longo do caminho.

Abordagem: Use programação dinâmica para construir uma tabela que armazena a soma mínima do caminho até cada célula na grade.
Considerações: Demonstra conhecimento de programação dinâmica e problemas de otimização.

3Sum:

Dado um array de inteiros, encontre todos os triplos únicos que somam zero.

Abordagem: Ordene o array e, em seguida, itere sobre ele. Para cada elemento, use dois ponteiros para encontrar os dois outros elementos que somam zero.
Considerações: Demonstra conhecimento de algoritmos de ordenação e manipulação de arrays.

Find Peak Element:

Encontre um elemento de pico em um array. Um elemento de pico é um elemento que é maior que seus vizinhos.

Abordagem: Use busca binária para encontrar um elemento de pico.
Considerações: Demonstra conhecimento de busca binária e manipulação de arrays.

Serialize and Deserialize Binary Tree:

Serialize uma binary tree em uma string e, em seguida, desserialize a string de volta em uma binary tree.

Abordagem: Use uma travessia pré-ordem ou pós-ordem para serializar a árvore. Use a mesma travessia para desserializar a árvore.
Considerações: Importante para entender algoritmos de travessia de árvores e serialização/desserialização de dados.

Partition Equal Subset Sum:

Dado um array de inteiros, determine se o array pode ser particionado em dois subconjuntos com somas iguais.

Abordagem: Use programação dinâmica para construir uma tabela que armazena se cada soma possível pode ser alcançada usando um subconjunto dos números no array.
Considerações: Demonstra conhecimento de programação dinâmica e problemas de otimização.

Sort Colors:

Dado um array de cores (representadas por 0, 1 e 2), ordene as cores in-place.

Abordagem: Use o algoritmo de partição de três vias para ordenar as cores.
Considerações: Demonstra conhecimento de algoritmos de ordenação e operações in-place.

Letter Combinations of a Phone Number:

Dado um número de telefone, retorne todas as combinações de letras possíveis que o número pode representar.

Abordagem: Use backtracking para gerar todas as combinações possíveis de letras.
Considerações: Demonstra conhecimento de backtracking e algoritmos de busca.

Best Time to Buy and Sell Stock:

Dado um array de preços de ações, encontre o lucro máximo que você pode obter comprando e vendendo uma ação uma vez.

Abordagem: Mantenha o controle do preço mínimo e do lucro máximo. Itere sobre o array e atualize o preço mínimo e o lucro máximo conforme necessário.
Considerações: Demonstra conhecimento de problemas de otimização e manipulação de arrays.

Top K Frequent Elements:

Dado um array de inteiros, retorne os k elementos mais frequentes.

Abordagem: Use um hash map para contar a frequência de cada elemento. Em seguida, use uma fila de prioridade para armazenar os k elementos mais frequentes.
Considerações: Demonstra conhecimento de hash maps, filas de prioridade e algoritmos de ordenação.

Kth Largest Element in an Array:

Encontre o k-ésimo maior elemento em um array.

Abordagem: Use o algoritmo quickselect para encontrar o k-ésimo maior elemento.
Considerações: Demonstra conhecimento de algoritmos de seleção e manipulação de arrays.

Unique Paths:

Dado uma grade de m x n, encontre o número de caminhos únicos da parte superior esquerda para a parte inferior direita.

Abordagem: Use programação dinâmica para construir uma tabela que armazena o número de caminhos únicos até cada célula na grade.
Considerações: Demonstra conhecimento de programação dinâmica e problemas de otimização.

Longest Common Subsequence:

Encontre a subsequência comum mais longa de duas strings.

Abordagem: Use programação dinâmica para construir uma tabela que armazena o comprimento da subsequência comum mais longa de cada par de prefixos das duas strings.
Considerações: Demonstra conhecimento de programação dinâmica e manipulação de strings.

Implement Trie (Prefix Tree):

Implemente uma estrutura de dados trie (árvore de prefixos).

Abordagem: Use um nó para representar cada caractere em um prefixo. Cada nó tem um ponteiro para seus filhos e um sinalizador que indica se o nó representa o final de uma palavra.
Considerações: Importante para entender estruturas de dados de árvores e manipulação de strings.

Binary Search:

Implemente o algoritmo de busca binária.

Abordagem: Compare o valor alvo com o elemento do meio do array. Se o valor alvo for menor que o elemento do meio, pesquise na metade esquerda do array. Se o valor alvo for maior que o elemento do meio, pesquise na metade direita do array.
Considerações: Fundamental para entender algoritmos de busca e manipulação de arrays.

Flood Fill:

Dado uma imagem e uma coordenada inicial, preencha a região conectada da imagem com uma nova cor.

Abordagem: Use a busca em profundidade (DFS) ou a busca em largura (BFS) para percorrer a região conectada e preenchê-la com a nova cor.
Considerações: Demonstra conhecimento de algoritmos de busca em grafos e manipulação de matrizes.

Course Schedule:

Dado uma lista de cursos e seus pré-requisitos, determine se é possível concluir todos os cursos.

Abordagem: Use a detecção de ciclos em grafos. Construa um grafo onde cada nó representa um curso e cada aresta representa um pré-requisito. Se o grafo contiver um ciclo, não é possível concluir todos os cursos.
Considerações: Demonstra conhecimento de algoritmos de grafos e detecção de ciclos.

Lowest Common Ancestor of a Binary Search Tree:

Encontre o ancestral comum mais baixo de dois nós em uma binary search tree.

Abordagem: Percorra a árvore. Se ambos os nós estiverem na subárvore esquerda, o ancestral comum mais baixo está na subárvore esquerda. Se ambos os nós estiverem na subárvore direita, o ancestral comum mais baixo está na subárvore direita. Caso contrário, o nó atual é o ancestral comum mais baixo.
Considerações: Importante para entender algoritmos de travessia de árvores e propriedades de binary search trees.

Basic Calculator II:

Implemente uma calculadora básica para avaliar expressões de string.

Abordagem: Use uma pilha para armazenar os operandos e operadores. Itere sobre a string e execute as operações na ordem correta.
Considerações: Demonstra conhecimento de estruturas de pilha e manipulação de strings.

Jump Game:

Dado um array de inteiros, onde cada elemento representa o número máximo de degraus que você pode dar para frente, determine se você pode chegar ao último índice.

Abordagem: Mantenha o controle do índice mais distante que você pode alcançar. Itere sobre o array e atualize o índice mais distante conforme necessário. Se você puder alcançar o último índice, retorne true. Caso contrário, retorne false.
Considerações: Demonstra conhecimento de problemas de otimização e manipulação de arrays.

Zigzag Conversion:

Converta uma string em um padrão em zigue-zague com um determinado número de linhas.

Abordagem: Itere sobre a string e adicione cada caractere à linha apropriada. Em seguida, concatene as linhas para obter a string convertida.
Considerações: Demonstra conhecimento de manipulação de strings e padrões.

Set Matrix Zeroes:

Dado uma matriz, se um elemento for 0, defina toda a sua linha e coluna como 0.

Abordagem: Use o primeiro elemento de cada linha e coluna para rastrear se a linha ou coluna deve ser definida como 0.
Considerações: Demonstra conhecimento de manipulação de matrizes e operações in-place.

Permutations:

Dado um array de números distintos, retorne todas as permutações possíveis.

Abordagem: Use backtracking para gerar todas as permutações possíveis.
Considerações: Demonstra conhecimento de backtracking e algoritmos de busca.

LRU Cache:

Designe uma cache LRU (Least Recently Used).

Abordagem: Use uma combinação de um hash map e uma doubly linked list. O hash map armazena os pares chave-valor e a doubly linked list rastreia a ordem em que as chaves foram acessadas.
Considerações: Demonstra conhecimento de hash maps, linked lists e design de estruturas de dados.

N-Queens:

Resolva o problema das N-Rainhas. Coloque N rainhas em um tabuleiro de xadrez de N x N para que nenhuma rainha ataque outra.

Abordagem: Use backtracking para explorar todas as possíveis colocações das rainhas.
Considerações: Demonstra conhecimento de backtracking e algoritmos de busca.

Find Median from Data Stream:

Designe uma estrutura de dados que possa encontrar a mediana de um fluxo de dados.

Abordagem: Use duas filas de prioridade: uma fila máxima para armazenar a metade inferior dos dados e uma fila mínima para armazenar a metade superior dos dados.
Considerações: Demonstra conhecimento de filas de prioridade e design de estruturas de dados.

Maximum Product Subarray:

Encontre o produto máximo de um subarray contíguo.

Abordagem: Mantenha o controle do produto máximo atual, do produto mínimo atual e do produto máximo até o momento. Itere sobre o array e atualize os produtos conforme necessário.
Considerações: Demonstra conhecimento de problemas de otimização e manipulação de arrays.

Binary Tree Maximum Path Sum:

Encontre a soma máxima do caminho em uma binary tree.

Abordagem: Use recursão para percorrer a árvore e calcular a soma máxima do caminho para cada nó. A soma máxima do caminho é a soma máxima do caminho de qualquer nó na árvore.
Considerações: Importante para entender algoritmos de travessia de árvores e recursão.

Search a 2D Matrix:

Pesquise um valor em uma matriz 2D ordenada.

Abordagem: Use busca binária para encontrar a linha que pode conter o valor alvo. Em seguida, use busca binária novamente para encontrar o valor alvo na linha.
Considerações: Demonstra conhecimento de busca binária e manipulação de matrizes.

Valid Sudoku:

Determine se um tabuleiro de Sudoku é válido.

Abordagem: Verifique se cada linha, coluna e bloco 3×3 contém os dígitos de 1 a 9 sem repetição.
Considerações: Demonstra conhecimento de manipulação de matrizes e restrições.

Container with Most Water:

Dado um array de inteiros que representam as alturas das linhas verticais, encontre o contêiner que pode conter mais água.

Abordagem: Use dois ponteiros, um no início do array e outro no final do array. Mova o ponteiro com a menor altura em direção ao centro do array. Calcule a área do contêiner em cada etapa e atualize a área máxima conforme necessário.
Considerações: Demonstra conhecimento de problemas de otimização e manipulação de arrays.

Design Add and Search Words Data Structure:

Designe uma estrutura de dados que suporte adicionar novas palavras e pesquisar palavras que correspondam a um padrão.

Abordagem: Use uma trie (árvore de prefixos) para armazenar as palavras. Use a busca em profundidade (DFS) para pesquisar palavras que correspondam a um padrão.
Considerações: Demonstra conhecimento de estruturas de dados de árvores e algoritmos de busca.

Task Scheduler:

Dado um array de tarefas e um número inteiro n, encontre o número mínimo de unidades de tempo necessárias para concluir todas as tarefas.

Abordagem: Calcule a frequência de cada tarefa. O número mínimo de unidades de tempo é o número de vezes que a tarefa mais frequente precisa ser executada, mais o número de vezes que as outras tarefas precisam ser executadas.
Considerações: Demonstra conhecimento de problemas de otimização e manipulação de arrays.

Find the Duplicate Number:

Dado um array de inteiros contendo n + 1 inteiros onde cada inteiro está entre 1 e n (inclusive), prove que pelo menos um número duplicado deve existir. Suponha que haja apenas um número duplicado, encontre o número duplicado.

Abordagem: Use o algoritmo da lebre e da tartaruga (detecção de ciclo de Floyd).
Considerações: Demonstra conhecimento de algoritmos de detecção de ciclos e manipulação de arrays.

Maximum Width of Binary Tree:

Dado uma binary tree, escreva uma função para obter a largura máxima da árvore. A largura de uma linha é definida como o número de nós entre os dois nós não nulos mais distantes, que podem ser após o valor nulo.

Abordagem: Use a busca em largura (BFS) e atribua um índice a cada nó com base em sua posição.
Considerações: Demonstra conhecimento de algoritmos de travessia de árvores e manipulação de dados.

Evaluate Reverse Polish Notation:

Avalie o valor de uma expressão de Notação Polonesa Reversa (RPN), também conhecida como notação pós-fixada.

Abordagem: Use uma pilha para armazenar os operandos. Quando encontrar um operador, retire os dois operandos do topo da pilha, execute a operação e coloque o resultado de volta na pilha.
Considerações: Demonstra conhecimento de estruturas de pilha e manipulação de strings.

Spiral Matrix:

Dado uma matriz m x n, retorne todos os elementos da matriz em ordem espiral.

Abordagem: Mantenha o controle dos limites da matriz. Itere sobre a matriz em ordem espiral e atualize os limites conforme necessário.
Considerações: Demonstra conhecimento de manipulação de matrizes e padrões.

Surrounded Regions:

Dado uma matriz m x n de caracteres, capture todas as regiões ‘O’ que estão cercadas por ‘X’.

Abordagem: Percorra a borda da matriz. Para cada ‘O’ na borda, use a busca em profundidade (DFS) para marcar todas as regiões conectadas ‘O’ como ‘T’. Em seguida, itere sobre a matriz novamente. Converta todos os ‘O’ restantes em ‘X’ e todos os ‘T’ em ‘O’.
Considerações: Demonstra conhecimento de algoritmos de busca em grafos e manipulação de matrizes.

Valid Palindrome:

Dado uma string, determine se é um palíndromo, considerando apenas caracteres alfanuméricos e ignorando maiúsculas e minúsculas.

Abordagem: Use dois ponteiros, um no início da string e outro no final da string. Mova os ponteiros em direção ao centro da string, ignorando caracteres não alfanuméricos. Compare os caracteres em cada etapa. Se os caracteres forem diferentes, a string não é um palíndromo.
Considerações: Demonstra conhecimento de manipulação de strings e padrões.

Jump Game II:

Dado um array de inteiros, onde cada elemento representa o número máximo de degraus que você pode dar para frente, encontre o número mínimo de degraus necessários para chegar ao último índice.

Abordagem: Use uma abordagem gananciosa. Mantenha o controle do índice mais distante que você pode alcançar e o número de degraus que você deu. Itere sobre o array e atualize o índice mais distante e o número de degraus conforme necessário.
Considerações: Demonstra conhecimento de problemas de otimização e manipulação de arrays.

LRU Cache:

(Repetição do item 51, mantido para manter a sequência original) Designe uma cache LRU (Least Recently Used).

Abordagem: Use uma combinação de um hash map e uma doubly linked list. O hash map armazena os pares chave-valor e a doubly linked list rastreia a ordem em que as chaves foram acessadas.
Considerações: Demonstra conhecimento de hash maps, linked lists e design de estruturas de dados.

Longest Consecutive Sequence:

Dado um array de inteiros, encontre o comprimento da sequência consecutiva mais longa.

Abordagem: Use um hash set para armazenar todos os números no array. Itere sobre o array e, para cada número, verifique se é o início de uma sequência consecutiva. Se for, encontre o comprimento da sequência.
Considerações: Demonstra conhecimento de hash sets e manipulação de arrays.

Remove Nth Node From End of List:

Dado uma linked list, remova o n-ésimo nó do final da lista e retorne a cabeça da lista.

Abordagem: Use dois ponteiros. Mova o primeiro ponteiro n nós para frente. Em seguida, mova ambos os ponteiros até que o primeiro ponteiro chegue ao final da lista. Remova o nó apontado pelo segundo ponteiro.
Considerações: Importante para entender manipulação de linked lists.

Integer to Roman:

Converta um inteiro em um numeral romano.

Abordagem: Use um hash map para armazenar os valores dos numerais romanos. Itere sobre os numerais romanos em ordem decrescente e subtraia o valor do numeral romano do inteiro até que o inteiro seja 0.
Considerações: Demonstra conhecimento de hash maps e manipulação de números.

Roman to Integer:

Converta um numeral romano em um inteiro.

Abordagem: Use um hash map para armazenar os valores dos numerais romanos. Itere sobre o numeral romano e adicione o valor de cada numeral romano ao inteiro. Se o valor do numeral romano atual for menor que o valor do próximo numeral romano, subtraia o valor do numeral romano atual do inteiro.
Considerações: Demonstra conhecimento de hash maps e manipulação de números.

String to Integer (atoi):

Abordagem: Ignore espaços em branco, leia o sinal (se houver) e converta os caracteres numéricos subsequentes em um número inteiro.
Considerações: Lide com sobrecarga e valores fora do intervalo.

Zigzag Conversion:

Abordagem: Crie linhas que armazenem caracteres enquanto percorrem a string em zigue-zague, depois concatene os resultados.
Considerações: Evidencia manipulação de índices e padrões.

Multiply Strings:

Abordagem: Simule multiplicação manual, acumulando resultados parciais antes de somar.
Considerações: Desafio em otimizar manipulação de strings.

Median of Two Sorted Arrays:

Abordagem: Use busca binária para encontrar a mediana de forma eficiente.
Considerações: Demonstra habilidade em busca binária em contextos complexos.

Longest Increasing Subsequence:

Abordagem: Use programação dinâmica ou algoritmo de paciência para encontrar a sequência.
Considerações: Identificação de subsequências e otimização.

Reverse Nodes in k-Group:

Abordagem: Inverta nós de k em k numa lista ligada.
Considerações: Conhecimento aprofundado de manipulação de linked lists.

Word Search:

Abordagem: Use backtracking para verificar a presença de uma palavra em uma grade de caracteres.
Considerações: Algoritmos de busca em matrizes.

Edit Distance:

Abordagem: Use programação dinâmica para calcular a menor edição para transformar uma string em outra.
Considerações: Problemas de transformação e distâncias mínimas.

Minimum Window Substring:

Abordagem: Use a técnica de sliding window para encontrar o menor substrato que contém todos os caracteres.
Considerações: Manipulação de substrings e otimização.

Kth Largest Element in an Array:

Abordagem: Use heap ou Quickselect para eficiência.
Considerações: Algoritmos de ordenação e seleção.

Trapping Rain Water:

Abordagem: Use dois ponteiros para calcular a água retida entre colunas.
Considerações: Análise de problemas de espaço e volume.

Binary Search Tree Iterator:

Abordagem: Use uma pilha para implementar a travessia em ordem.
Considerações: Orthogonalidade em travessias de árvores.

Clone Graph:

Abordagem: Use busca em profundidade ou largura para clonar o gráfico.
Considerações: Estruturas de dados e clonagem.

Longest Common Subsequence:

Abordagem: Use programação dinâmica para encontrar a subsequência comum mais longa entre duas strings.
Considerações: Sequências e problemas de alinhamento.

Graph Valid Tree:

Abordagem: Verifique conectividade e aciclicidade usando BFS ou DFS.
Considerações: Estrutura de grafos e validez de árvores.

Game of Life:

Abordagem: Simule as transições de células vivas e mortas em uma matriz.
Considerações: Manipulação de matrizes e simulação.

Number of Islands:

Abordagem: Use BFS ou DFS para contar e marcar as ilhas em uma matriz.
Considerações: Conectividade em 2D.

Lowest Common Ancestor of a Binary Tree:

Abordagem: Use recursão para localizar o ancestral comum.
Considerações: Travessia de árvores e aninhamento.

Decode Ways:

Abordagem: Use programação dinâmica para calcular maneiras de decodificar uma string numérica em letras.
Considerações: Problemas de mapeamento e interpretação.

House Robber II:

Abordagem: Use programação dinâmica, considerando casas organizadas em um círculo.
Considerações: Otimização de problemas cíclicos.

Randomized Set:

Abordagem: Use uma combinação de array e hash map para permitir operações de tempo constante.
Considerações: Estruturas de dados de conjunto.

Sliding Window Maximum:

Abordagem: Use um deque para obter máximos em um intervalo deslizante.
Considerações: Algoritmos de janelas deslizantes.

Merge K Sorted Lists:

Abordagem: Use uma fila de prioridade para mesclar as listas eficientemente.
Considerações: Estruturas de dados de filas de prioridade.

Binary Tree Right Side View:

Abordagem: Use BFS para capturar a visão direita de uma árvore.
Considerações: Visualização e travessia de árvores.

Palindrome Partitioning:

Abordagem: Use backtracking para encontrar todas as partições palindrômicas possíveis.
Considerações: Particionamento e reconhecimento de padrões.

Vertical Order Traversal of a Binary Tree:

Abordagem: Use BFS com coordenadas para imprimir a ordem vertical.
Considerações: Visualização em árvores e coordenadas.

Peeking Iterator:

Abordagem: Adapte um iterador para permitir espiar o próximo elemento.
Considerações: Manipulação de iteradores.

Kth Smallest Element in a BST: –

Abordagem: Use in-order traversal para encontrar o k-ésimo elemento. – Considerações: Ordem de árvores binárias e travessia.

ThreeSum – 3Sum

Python

# 3Sum
nums = [-1, 0, 1, 2, -1, -4]
result = []
nums.sort()
print(nums)
r=len(nums)-1
for i in range(len(nums)-2):
   l = i + 1 # we don't want l and i to be the same value.
   # for each value of i, l starts one greater
   # and increments from there.
   while (l < r):
      sum_ = nums[i] + nums[l] + nums[r]
      if (sum_ < 0):
         l = l + 1
      elif (sum_ > 0):
         r = r - 1
      else: # 0 is False in a boolean context
         result.append([nums[i],nums[l],nums[r]])
         l = l + 1 # increment l when we find a combination that works
print(result)

Java

class Solution {
2    public List<List<Integer>> threeSum(int[] nums) {
3        Arrays.sort(nums);
4        List<List<Integer>> threeSums = new ArrayList<>();
5        for (int i = 0; i < nums.length; i++) {
6            if (i > 0 && nums[i] == nums[i - 1]) {
7                continue;
8            }
9            int target = -nums[i];
10            int l = i + 1, r = nums.length - 1;
11            while (l < r) {
12                if (nums[l] + nums[r] == target) {
13                    threeSums.add(Arrays.asList(nums[i], nums[l], nums[r]));
14                    l++;
15                    while (l < r && nums[l] == nums[l - 1]) {
16                        l++;
17                    }
18                } else if (nums[l] + nums[r] < target) {
19                    l++;
20                } else {
21                    r--;
22                }
23            }
24        }
25        return threeSums;
26    }

Javascript

const threeSum = (nums) => {
2  const sortedNums = nums.sort((a, b) => a - b);
3  const threeSums = [];
4  for (let i = 0; i < nums.length; i++) {
5    // avoid duplicates
6    if (i > 0 && sortedNums[i] === sortedNums[i - 1]) {
7      continue;
8    }
9    const target = -sortedNums[i];
10    let [l, r] = [i + 1, sortedNums.length - 1];
11    while (l < r) {
12      if (sortedNums[l] + sortedNums[r] === target) {
13        threeSums.push([sortedNums[i], sortedNums[l], sortedNums[r]]);
14        l += 1;
15        // avoid duplicates again
16        while (l < r && sortedNums[l] === sortedNums[l - 1]) {
17          l += 1;
18        }
19      } else if (sortedNums[l] + sortedNums[r] < target) {
20        l += 1;
21      } else {
22        r -= 1;
23      }
24    }
25  }
26  return threeSums;
27};

 

Fontes:

https://interviewing.io/questions/three-sum

Java Factory

O padrão de design de fábrica é usado quando temos uma superclasse com várias subclasses e, com base na entrada, precisamos retornar uma das subclasses. Esse padrão tira a responsabilidade da instanciação de uma classe do programa cliente para a classe de fábrica. Vamos primeiro aprender como implementar um padrão de design de fábrica em Java e, em seguida, veremos as vantagens do padrão de fábrica. Veremos alguns dos usos do padrão de design de fábrica no JDK. Observe que esse padrão também é conhecido como Padrão de Design de Método de Fábrica .

Padrão de Design de Fábrica Super Classe

A superclasse no padrão de design de fábrica pode ser uma interface, uma classe abstrata ou uma classe Java normal. Para nosso exemplo de padrão de design de fábrica, temos uma superclasse abstrata com um método sobrescrito toString() para fins de teste.

package com.journaldev.design.model;

public abstract class Computer {
	
	public abstract String getRAM();
	public abstract String getHDD();
	public abstract String getCPU();
	
	@Override
	public String toString(){
		return "RAM= "+this.getRAM()+", HDD="+this.getHDD()+", CPU="+this.getCPU();
	}
}

Subclasses de Padrão de Design de Fábrica

Digamos que temos duas subclasses, PC e Servidor, com a implementação abaixo.

package com.journaldev.design.model;

public class PC extends Computer {

	private String ram;
	private String hdd;
	private String cpu;
	
	public PC(String ram, String hdd, String cpu){
		this.ram=ram;
		this.hdd=hdd;
		this.cpu=cpu;
	}
	@Override
	public String getRAM() {
		return this.ram;
	}

	@Override
	public String getHDD() {
		return this.hdd;
	}

	@Override
	public String getCPU() {
		return this.cpu;
	}

}

Observe que ambas as classes estão estendendo Computera superclasse.

package com.journaldev.design.model;

public class Server extends Computer {

	private String ram;
	private String hdd;
	private String cpu;
	
	public Server(String ram, String hdd, String cpu){
		this.ram=ram;
		this.hdd=hdd;
		this.cpu=cpu;
	}
	@Override
	public String getRAM() {
		return this.ram;
	}

	@Override
	public String getHDD() {
		return this.hdd;
	}

	@Override
	public String getCPU() {
		return this.cpu;
	}

}

Classe de fábrica

Agora que temos superclasses e subclasses prontas, podemos escrever nossa classe de fábrica. Aqui está a implementação básica.

package com.journaldev.design.factory;

import com.journaldev.design.model.Computer;
import com.journaldev.design.model.PC;
import com.journaldev.design.model.Server;

public class ComputerFactory {

	public static Computer getComputer(String type, String ram, String hdd, String cpu){
		if("PC".equalsIgnoreCase(type)) return new PC(ram, hdd, cpu);
		else if("Server".equalsIgnoreCase(type)) return new Server(ram, hdd, cpu);
		
		return null;
	}
}

Alguns pontos importantes sobre o método Factory Design Pattern são:

  1. Podemos manter a classe Factory Singleton ou podemos manter o método que retorna a subclasse como estático .
  2. Observe que, com base no parâmetro de entrada, diferentes subclasses são criadas e retornadas. getComputeré o método de fábrica.

padrão de fábrica java, padrão de fábrica, padrão de projeto de fábrica, diagrama de classe de padrão de fábrica

Aqui está um programa cliente de teste simples que usa a implementação do padrão de design de fábrica acima.

package com.journaldev.design.test;

import com.journaldev.design.factory.ComputerFactory;
import com.journaldev.design.model.Computer;

public class TestFactory {

	public static void main(String[] args) {
		Computer pc = ComputerFactory.getComputer("pc","2 GB","500 GB","2.4 GHz");
		Computer server = ComputerFactory.getComputer("server","16 GB","1 TB","2.9 GHz");
		System.out.println("Factory PC Config::"+pc);
		System.out.println("Factory Server Config::"+server);
	}

}

A saída do programa acima é:

Factory PC Config::RAM= 2 GB, HDD=500 GB, CPU=2.4 GHz
Factory Server Config::RAM= 16 GB, HDD=1 TB, CPU=2.9 GHz

Vantagens do Padrão de Projeto de Fábrica

  1. O padrão de design de fábrica fornece uma abordagem ao código para interface em vez de implementação.
  2. O padrão Factory remove a instanciação de classes de implementação reais do código do cliente. O padrão Factory torna nosso código mais robusto, menos acoplado e fácil de estender. Por exemplo, podemos facilmente alterar a implementação da classe PC porque o programa cliente não tem conhecimento disso.
  3. O padrão de fábrica fornece abstração entre classes de implementação e cliente por meio de herança.

Exemplos de padrões de design de fábrica no JDK

  1. Os métodos java.util.Calendar, ResourceBundle e NumberFormat getInstance()usam o padrão Factory.
  2. valueOf()método em classes wrapper como Boolean, Integer etc.

Tutorial em vídeo do YouTube sobre o padrão de design de fábrica

Recentemente, carreguei um vídeo no YouTube para o padrão Factory Design, por favor, dê uma olhada. Por favor, curta e compartilhe o vídeo e inscreva-se no meu canal do YouTube. https://www.youtube.com/watch?v=J1QU\_R4MQQc

Você pode baixar o código de exemplo do meu Projeto GitHub .

Java Singleton

Implementação do Padrão Java Singleton

Para implementar um padrão singleton, temos diferentes abordagens, mas todas elas têm os seguintes conceitos comuns.

  • Construtor privado para restringir a instanciação da classe de outras classes.
  • Variável estática privada da mesma classe que é a única instância da classe.
  • Método estático público que retorna a instância da classe. Este é o ponto de acesso global para o mundo externo obter a instância da classe singleton.

Nas próximas seções, aprenderemos diferentes abordagens para implementação de padrões singleton e preocupações de design com a implementação.

1. Inicialização rápida

Na inicialização ansiosa, a instância da classe singleton é criada no momento do carregamento da classe. A desvantagem da inicialização ansiosa é que o método é criado mesmo que o aplicativo cliente não o esteja usando. Aqui está a implementação da classe singleton de inicialização estática:

package com.journaldev.singleton;

public class EagerInitializedSingleton {

    private static final EagerInitializedSingleton instance = new EagerInitializedSingleton();

    // private constructor to avoid client applications using the constructor
    private EagerInitializedSingleton(){}

    public static EagerInitializedSingleton getInstance() {
        return instance;
    }
}

Se sua classe singleton não estiver usando muitos recursos, essa é a abordagem a ser usada. Mas na maioria dos cenários, classes singleton são criadas para recursos como Sistema de Arquivos, conexões de Banco de Dados, etc. Devemos evitar a instanciação, a menos que o cliente chame o getInstancemétodo. Além disso, esse método não fornece nenhuma opção para tratamento de exceções.

2. Inicialização de bloco estático

A implementação da inicialização de bloco estático é semelhante à inicialização ansiosa, exceto que a instância da classe é criada no bloco estático que fornece a opção de tratamento de exceções .

package com.journaldev.singleton;

public class StaticBlockSingleton {

    private static StaticBlockSingleton instance;

    private StaticBlockSingleton(){}

    // static block initialization for exception handling
    static {
        try {
            instance = new StaticBlockSingleton();
        } catch (Exception e) {
            throw new RuntimeException("Exception occurred in creating singleton instance");
        }
    }

    public static StaticBlockSingleton getInstance() {
        return instance;
    }
}

Tanto a inicialização rápida quanto a inicialização de bloco estático criam a instância antes mesmo que ela seja usada, e essa não é a melhor prática a ser usada.

3. Inicialização preguiçosa

O método de inicialização lazy para implementar o padrão singleton cria a instância no método de acesso global. Aqui está o código de exemplo para criar a classe singleton com esta abordagem:

package com.journaldev.singleton;

public class LazyInitializedSingleton {

    private static LazyInitializedSingleton instance;

    private LazyInitializedSingleton(){}

    public static LazyInitializedSingleton getInstance() {
        if (instance == null) {
            instance = new LazyInitializedSingleton();
        }
        return instance;
    }
}

A implementação anterior funciona bem no caso do ambiente single-threaded, mas quando se trata de sistemas multi-threaded, pode causar problemas se vários threads estiverem dentro da ifcondição ao mesmo tempo. Isso destruirá o padrão singleton e ambos os threads obterão instâncias diferentes da classe singleton. Na próxima seção, veremos diferentes maneiras de criar uma classe singleton thread-safe .

4. Singleton seguro para threads

Uma maneira simples de criar uma classe singleton thread-safe é fazer com que o método de acesso global seja sincronizado para que apenas uma thread possa executar esse método por vez. Aqui está uma implementação geral dessa abordagem:

package com.journaldev.singleton;

public class ThreadSafeSingleton {

    private static ThreadSafeSingleton instance;

    private ThreadSafeSingleton(){}

    public static synchronized ThreadSafeSingleton getInstance() {
        if (instance == null) {
            instance = new ThreadSafeSingleton();
        }
        return instance;
    }

}

A implementação anterior funciona bem e fornece segurança de thread, mas reduz o desempenho devido ao custo associado ao método synchronized, embora precisemos dele apenas para os primeiros threads que podem criar instâncias separadas. Para evitar essa sobrecarga extra toda vez, o princípio de bloqueio verificado duas vezes é usado. Nessa abordagem, o bloco synchronized é usado dentro da ifcondição com uma verificação adicional para garantir que apenas uma instância de uma classe singleton seja criada. O seguinte trecho de código fornece a implementação de bloqueio verificado duas vezes:

public static ThreadSafeSingleton getInstanceUsingDoubleLocking() {
    if (instance == null) {
        synchronized (ThreadSafeSingleton.class) {
            if (instance == null) {
                instance = new ThreadSafeSingleton();
            }
        }
    }
    return instance;
}

Continue seu aprendizado com a classe Thread Safe Singleton .

5. Implementação de Bill Pugh Singleton

Antes do Java 5, o modelo de memória Java tinha muitos problemas, e as abordagens anteriores costumavam falhar em certos cenários em que muitos threads tentavam obter a instância da classe singleton simultaneamente. Então Bill Pugh surgiu com uma abordagem diferente para criar a classe singleton usando uma classe auxiliar estática interna . Aqui está um exemplo da implementação do Singleton de Bill Pugh:

package com.journaldev.singleton;

public class BillPughSingleton {

    private BillPughSingleton(){}

    private static class SingletonHelper {
        private static final BillPughSingleton INSTANCE = new BillPughSingleton();
    }

    public static BillPughSingleton getInstance() {
        return SingletonHelper.INSTANCE;
    }
}

Observe a classe estática interna privada que contém a instância da classe singleton. Quando a classe singleton é carregada, SingletonHelpera classe não é carregada na memória e somente quando alguém chama o getInstance()método, essa classe é carregada e cria a instância da classe singleton. Essa é a abordagem mais amplamente usada para a classe singleton, pois não requer sincronização.

6. Usando Reflexão para destruir o Padrão Singleton

A reflexão pode ser usada para destruir todas as abordagens de implementação singleton anteriores. Aqui está uma classe de exemplo:

package com.journaldev.singleton;

import java.lang.reflect.Constructor;

public class ReflectionSingletonTest {

    public static void main(String[] args) {
        EagerInitializedSingleton instanceOne = EagerInitializedSingleton.getInstance();
        EagerInitializedSingleton instanceTwo = null;
        try {
            Constructor[] constructors = EagerInitializedSingleton.class.getDeclaredConstructors();
            for (Constructor constructor : constructors) {
                // This code will destroy the singleton pattern
                constructor.setAccessible(true);
                instanceTwo = (EagerInitializedSingleton) constructor.newInstance();
                break;
            }
        } catch (Exception e) {
            e.printStackTrace();
        }
        System.out.println(instanceOne.hashCode());
        System.out.println(instanceTwo.hashCode());
    }

}

Ao executar a classe de teste anterior, você notará que hashCodeambas as instâncias não são as mesmas, o que destrói o padrão singleton. O Reflection é muito poderoso e usado em muitos frameworks como Spring e Hibernate. Continue seu aprendizado com o Tutorial Java Reflection .

7. Enumeração Singleton

Para superar essa situação com o Reflection, Joshua Bloch sugere o uso de enumpara implementar o padrão de design singleton, já que Java garante que qualquer enumvalor seja instanciado apenas uma vez em um programa Java. Como os valores Java Enum são globalmente acessíveis, o singleton também é. A desvantagem é que o enumtipo é um tanto inflexível (por exemplo, ele não permite inicialização preguiçosa).

package com.journaldev.singleton;

public enum EnumSingleton {

    INSTANCE;

    public static void doSomething() {
        // do something
    }
}

8. Serialização e Singleton

Às vezes, em sistemas distribuídos, precisamos implementar Serializableinterface na classe singleton para que possamos armazenar seu estado no sistema de arquivos e recuperá-lo em um momento posterior. Aqui está uma pequena classe singleton que implementa Serializableinterface também:

package com.journaldev.singleton;

import java.io.Serializable;

public class SerializedSingleton implements Serializable {

    private static final long serialVersionUID = -7604766932017737115L;

    private SerializedSingleton(){}

    private static class SingletonHelper {
        private static final SerializedSingleton instance = new SerializedSingleton();
    }

    public static SerializedSingleton getInstance() {
        return SingletonHelper.instance;
    }

}

O problema com a classe singleton serializada é que sempre que a desserializamos, ela criará uma nova instância da classe. Aqui está um exemplo:

package com.journaldev.singleton;

import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.ObjectInput;
import java.io.ObjectInputStream;
import java.io.ObjectOutput;
import java.io.ObjectOutputStream;

public class SingletonSerializedTest {

    public static void main(String[] args) throws FileNotFoundException, IOException, ClassNotFoundException {
        SerializedSingleton instanceOne = SerializedSingleton.getInstance();
        ObjectOutput out = new ObjectOutputStream(new FileOutputStream(
                "filename.ser"));
        out.writeObject(instanceOne);
        out.close();

        // deserialize from file to object
        ObjectInput in = new ObjectInputStream(new FileInputStream(
                "filename.ser"));
        SerializedSingleton instanceTwo = (SerializedSingleton) in.readObject();
        in.close();

        System.out.println("instanceOne hashCode="+instanceOne.hashCode());
        System.out.println("instanceTwo hashCode="+instanceTwo.hashCode());

    }

}

Esse código produz esta saída:

Output
instanceOne hashCode=2011117821
instanceTwo hashCode=109647522

Então ele destrói o padrão singleton. Para superar esse cenário, tudo o que precisamos fazer é fornecer a implementação do readResolve()método.

protected Object readResolve() {
    return getInstance();
}

Depois disso, você notará que hashCodeambas as instâncias são iguais no programa de teste.

Fonte: https://www.digitalocean.com/community/tutorials/java-singleton-design-pattern-best-practices-examples