SUMÁRIO
1. Two Sum (Soma de Dois Números) .................................................................................... 2
2. Reverse a String (Reverter uma String) .............................................................................. 2
3. FizzBuzz (multiplos) ........................................................................................................... 2
4. Palindrome Check (Verificação de Palíndromo) ................................................................. 2
5. Merge Sorted Arrays (Mesclar Arrays Ordenados) ............................................................. 2
6. Find the Missing Number (Encontrar o Número Faltante) ................................................. 2
7. Longest Common Prefix (Maior Prefixo Comum) ............................................................... 2
8. Climbing Stairs (Subindo Escadas)...................................................................................... 3
9. Valid Parentheses (Parênteses Válidos) ............................................................................. 3
10. Maximum Subarray (Subarray Máximo) .......................................................................... 3
11. Ocorrências do maior número ......................................................................................... 3
12. Maximo de 1s consecutivos ............................................................................................. 3
13. Encontre a maioria .......................................................................................................... 3
14. Encontrar o k-ésimo menor/maior elemento .................................................................. 4
15. Problema de Estruturas de Dados: Implementação de Filas ............................................ 4
16. Caminhos mais curtos em Grafos Ponderados (Dijkstra) .................................................. 4
17. Problema da Mochila (Knapsack Problem) ...................................................................... 4
18. Cálculo de Área e Perímetro ............................................................................................ 4
19. Problemas de Fatorização e Números Primos .................................................................. 5
20. Problemas de Matching (KMP - Knuth-Morris-Pratt) ....................................................... 5
21. Cálculo de Diferença de Tempo entre Duas Datas ........................................................... 6
1. Two Sum (Soma de Dois Números)
print(is_palindrome(s)) # Saída: True 2
Problema: Dada uma lista de números e um valor alvo, encontre
dois números na lista que somam o valor alvo. 5. Merge Sorted Arrays (Mesclar Arrays Ordenados)
Problema: Dada duas listas ordenadas, mesclar em uma única
def two_sum(nums, target): lista ordenada.
seen = {} Exemplo de Código:
for i, num in enumerate(nums):
complement = target - num def merge_sorted_arrays(arr1, arr2):
if complement in seen: merged = []
return [seen[complement], i] i=j=0
seen[num] = i
return [] while i < len(arr1) and j < len(arr2):
if arr1[i] < arr2[j]:
# Exemplo de uso [Link](arr1[i])
nums = [2, 7, 11, 15] i += 1
target = 9 else:
print(two_sum(nums, target)) # Saída: [0, 1] [Link](arr2[j])
j += 1
# o retorno é a posição dos números que somam o valor target.
# Adiciona os elementos restantes de arr1 ou arr2
[Link](arr1[i:])
2. Reverse a String (Reverter uma String)
[Link](arr2[j:])
Problema: Reverter uma string dada.
return merged
def reverse_string(s):
return s[::-1]
# Exemplo de uso
arr1 = [1, 3, 5]
# Exemplo de uso
arr2 = [2, 4, 6]
s = "hello"
print(merge_sorted_arrays(arr1, arr2)) # Saída: [1, 2, 3, 4, 5, 6]
print(reverse_string(s)) # Saída: "olleh"
6. Find the Missing Number (Encontrar o Número Faltante)
Problema: Dada uma lista contendo N - 1 números únicos, onde
3. FizzBuzz (multiplos)
os números estão entre 1 e N. Encontre o número que está
Problema: Imprimir números de 1 a N. Para múltiplos de 3,
faltando.
imprima "Fizz" em vez do número e para os múltiplos de 5,
Exemplo de Código:
imprima "Buzz". Para números que são múltiplos de ambos 3 e 5,
def find_missing_number(nums):
imprima "FizzBuzz".
n = len(nums) + 1
total_sum = n * (n + 1) // 2
def fizz_buzz(n):
return total_sum - sum(nums)
for i in range(1, n + 1):
if i % 3 == 0 and i % 5 == 0:
# Exemplo de uso
print("FizzBuzz")
nums = [1, 2, 4, 5, 6]
elif i % 3 == 0:
print(find_missing_number(nums)) # Saída: 3
print("Fizz")
elif i % 5 == 0:
print("Buzz") 7. Longest Common Prefix (Maior Prefixo Comum)
else: Problema: Dada uma lista de strings, encontre o maior prefixo
print(i) comum entre elas.
Exemplo de Código:
# Exemplo de uso def longest_common_prefix(strs):
fizz_buzz(15) if not strs:
return ""
4. Palindrome Check (Verificação de Palíndromo)
prefix = strs[0]
Problema: Verifique se uma string é um palíndromo (lê-se da
for s in strs[1:]:
mesma forma de trás para frente).
while not [Link](prefix):
Exemplo de Código:
prefix = prefix[:-1]
if not prefix:
def is_palindrome(s):
return ""
return s == s[::-1]
return prefix
# Exemplo de uso
# Exemplo de uso
s = "racecar"
strs = ["flower", "flow", "flight"] 11. Ocorrências do maior número 3
print(longest_common_prefix(strs)) # Saída: "fl" Problema: Encontrar o maior número e quantidade de
ocorrência dele
8. Climbing Stairs (Subindo Escadas)
def maxValNumOccurrences(nums):
Problema: Você está subindo uma escada. Pode subir 1 ou 2
maxVal = nums[0]
degraus de cada vez. De quantas formas diferentes pode subir
counter = 0
uma escada de N degraus?
for num in nums:
Exemplo de Código:
if num > maxVal:
def climb_stairs(n):
maxVal = num
if n == 1:
counter = 1
return 1
elif num == maxVal:
elif n == 2:
counter += 1
return 2
return [maxVal, counter]
first, second = 1, 2
# Exemplo de uso
for _ in range(3, n + 1):
nums = [1, 3, 3, 2, 3, 1, 3,]
first, second = second, first + second
result = maxValNumOccurrences(nums)
print(result) # Saída: [3, 4]
return second
# Exemplo de uso 12. Maximo de 1s consecutivos
n=5 Problema: Encontrar o maior número aparições consecutivas de
print(climb_stairs(n)) # Saída: 8 1 em um array.
def findMaxConsecuveOnes(nums: list[int])-> int:
9. Valid Parentheses (Parênteses Válidos)
counter = 0
Problema: Dada uma string contendo apenas os caracteres '(', ')',
solution = 0
'{', '}', '[' e ']', determine se a string é válida.
For num in nums:
Exemplo de Código:
if num == 1:
def is_valid(s):
counter += 1
stack = []
else:
mapping = {")": "(", "}": "{", "]": "["}
counter = 0
solution = max(solution, counter)
for char in s:
return solution
if char in mapping:
top_element = [Link]() if stack else '#'
print(findMaxConsecuveOnes([1,1,0,1,1,1,0]))
if mapping[char] != top_element:
return False
else: 13. Encontre a maioria
[Link](char) Problema: Encontrar o elemento que aparece a maior parte das
vezes.
return not stack
def majorityElement(nums):
# Exemplo de uso counter = 1
s = "()[]{}" ocorrencias = 1
print(is_valid(s)) # Saída: True majority_element = nums[0]
for i in range(1, len(nums)):
10. Maximum Subarray (Subarray Máximo)
if nums[i] == nums[i - 1]:
Problema: Dada uma lista de números inteiros, encontre o
counter += 1
subarray com a maior soma e retorne a soma.
else:
Exemplo de Código:
counter = 1
def max_sub_array(nums):
max_sum = current_sum = nums[0]
if counter > ocorrencias:
for num in nums[1:]:
ocorrencias = counter
current_sum = max(num, current_sum + num)
majority_element = nums[i]
max_sum = max(max_sum, current_sum)
return max_sum
return majority_element
# Exemplo de uso
# Exemplo de uso
nums = [-2,1,-3,4,-1,2,1,-5,4]
nums = [1, 1, 1, 2, 2, 2, 2]
print(max_sub_array(nums)) # Saída: 6 (subarray [4,-1,2,1])
print(majorityElement(nums)) # Saída: 2
14. Encontrar o k-ésimo menor/maior elemento distances[start] = 0 4
priority_queue = [(0, start)]
Dado um array de números inteiros, encontre o k-ésimo menor
elemento. while priority_queue:
current_distance, current_vertex =
Exemplo de Solução em Python: [Link](priority_queue)
def kth_smallest_element(nums, k): if current_distance > distances[current_vertex]:
[Link]() continue
return nums[k - 1]
for neighbor, weight in graph[current_vertex].items():
# Exemplo de uso distance = current_distance + weight
nums = [3, 1, 4, 1, 5, 9, 2, 6, 5, 3, 5]
k=4 if distance < distances[neighbor]:
result = kth_smallest_element(nums, k) distances[neighbor] = distance
print(f"O {k}-ésimo menor elemento é: {result}") [Link](priority_queue, (distance, neighbor))
15. Problema de Estruturas de Dados: Implementação de return distances
Filas
# Exemplo de uso
Implemente uma estrutura de dados fila (queue) utilizando listas graph = {
em Python. 'A': {'B': 1, 'C': 4},
'B': {'C': 2, 'D': 5},
Exemplo de Solução em Python: 'C': {'D': 1},
class Queue: 'D': {}
def __init__(self): }
[Link] = [] start_vertex = 'A'
distances = dijkstra(graph, start_vertex)
def enqueue(self, item): print(f"Distâncias mínimas a partir de {start_vertex}: {distances}")
[Link](item) 17. Problema da Mochila (Knapsack Problem)
def dequeue(self): Dado um conjunto de itens, cada um com um peso e um valor,
if not self.is_empty(): determine a quantidade máxima de valor que pode ser carregada
return [Link](0) em uma mochila de capacidade limitada.
else:
return None
Exemplo de Solução em Python:
def is_empty(self): def knapsack(weights, values, capacity):
return len([Link]) == 0 n = len(weights)
dp = [[0] * (capacity + 1) for _ in range(n + 1)]
def size(self):
return len([Link]) for i in range(1, n + 1):
for w in range(1, capacity + 1):
# Exemplo de uso if weights[i - 1] <= w:
queue = Queue() dp[i][w] = max(values[i - 1] + dp[i - 1][w - weights[i - 1]],
[Link](1) dp[i - 1][w])
[Link](2) else:
[Link](3) dp[i][w] = dp[i - 1][w]
print([Link]()) # Saída: 1
print([Link]()) # Saída: 2 return dp[n][capacity]
print([Link]()) # Saída: 1
# Exemplo de uso
16. Caminhos mais curtos em Grafos Ponderados (Dijkstra) weights = [1, 2, 3, 4, 5]
values = [10, 20, 30, 40, 50]
Dado um grafo ponderado e direcionado com pesos não negativos, capacity = 7
encontre o caminho mais curto de um vértice de origem para max_value = knapsack(weights, values, capacity)
todos os outros vértices. print(f"Valor máximo que pode ser carregado na mochila:
{max_value}")
Exemplo de Solução em Python: 18. Cálculo de Área e Perímetro
import heapq
Dadas as coordenadas de vértices de um polígono convexo,
def dijkstra(graph, start): calcule:
distances = {vertex: float('infinity') for vertex in graph}
área e o perímetro do polígono n //= divisor 5
divisor += 1
def distance(p1, p2):
return ((p1[0] - p2[0])**2 + (p1[1] - p2[1])**2)**0.5 return factors
def area(vertices): # Exemplo de uso
n = len(vertices) number = 84
area = 0.0 factors = prime_factors(number)
for i in range(n): print(f"Fatores primos de {number}: {factors}")
j = (i + 1) % n 20. Problemas de Matching (KMP - Knuth-Morris-Pratt)
area += vertices[i][0] * vertices[j][1]
area -= vertices[j][0] * vertices[i][1]
Dada uma string text e um padrão pattern, encontre todas as
area = abs(area) / 2.0
ocorrências do padrão dentro do texto utilizando o algoritmo KMP.
return area
Exemplo de Solução em Python:
def perimeter(vertices):
perimeter = 0.0 def kmp_search(text, pattern):
n = len(vertices) n = len(text)
for i in range(n): m = len(pattern)
j = (i + 1) % n lps = compute_lps(pattern)
perimeter += distance(vertices[i], vertices[j]) matches = []
return perimeter
i = 0 # índice para text[]
# Exemplo de uso j = 0 # índice para pattern[]
vertices = [(0, 0), (4, 0), (4, 3), (0, 3)] while i < n:
polygon_area = area(vertices) if pattern[j] == text[i]:
polygon_perimeter = perimeter(vertices) i += 1
print(f"Área do polígono: {polygon_area}") j += 1
print(f"Perímetro do polígono: {polygon_perimeter}")
if j == m:
[Link](i - j)
área e o perímetro do círculo j = lps[j - 1]
elif i < n and pattern[j] != text[i]:
import math if j != 0:
j = lps[j - 1]
def calcular_area_perimetro_circulo(raio): else:
area = [Link] * raio ** 2 i += 1
perimetro = 2 * [Link] * raio
return matches
return area, perimetro
def compute_lps(pattern):
# Exemplo de uso m = len(pattern)
raio = 5 lps = [0] * m
area, perimetro = calcular_area_perimetro_circulo(raio) length = 0
i=1
print(f"Para um círculo com raio {raio}:")
print(f"Área: {area:.2f}") while i < m:
print(f"Perímetro: {perimetro:.2f}") if pattern[i] == pattern[length]:
length += 1
lps[i] = length
19. Problemas de Fatorização e Números Primos i += 1
else:
Dado um número inteiro, determine todos os fatores primos desse if length != 0:
número. length = lps[length - 1]
else:
Exemplo de Solução em Python: lps[i] = 0
def prime_factors(n): i += 1
factors = []
divisor = 2 return lps
while n > 1: # Exemplo de uso
while n % divisor == 0: text = "ABABDABACDABABCABAB"
[Link](divisor) pattern = "ABABCABAB"
matches = kmp_search(text, pattern) 6
print(f"O padrão '{pattern}' foi encontrado nas posições:
{matches}")
# Saída: O padrão 'ABABCABAB' foi encontrado nas posições: [10]
21. Cálculo de Diferença de Tempo entre Duas Datas
Suponha que você precisa calcular a diferença de tempo entre
duas datas e horas fornecidas, e deseja obter o resultado em dias,
horas, minutos e segundos.
python
Copy code
from datetime import datetime
def calcular_diferenca_tempo(data_inicio, data_fim):
# Converter as strings para objetos datetime
inicio = [Link](data_inicio, '%Y-%m-%d %H:%M:%S')
fim = [Link](data_fim, '%Y-%m-%d %H:%M:%S')
# Calcular a diferença de tempo
diferenca = fim - inicio
# Extrair dias, horas, minutos e segundos da diferença
dias = [Link]
segundos_total = diferenca.total_seconds()
horas = int(segundos_total // 3600) % 24
minutos = int(segundos_total // 60) % 60
segundos = int(segundos_total % 60)
return dias, horas, minutos, segundos
# Exemplo de uso
data_inicio = '2024-07-15 08:00:00'
data_fim = '2024-07-17 15:30:45'
dias, horas, minutos, segundos =
calcular_diferenca_tempo(data_inicio, data_fim)
print(f"Tempo decorrido entre {data_inicio} e {data_fim}:")
print(f"{dias} dias, {horas} horas, {minutos} minutos e {segundos}
segundos.")