Maximum Subarray

Introdução ao Subarray Máximo

O problema do Subarray Máximo nos pede para encontrar o subarray com a maior soma de um dado array. Este problema pode ser resolvido usando programação dinâmica e, mais especificamente, o Algoritmo de Kadane.

Problema de Submatriz Máxima

Dado um array de inteiros nums, encontre o subarray com a maior soma e retorne sua soma.

1 public class Solution {
2    public int maxSubArray(int[] nums) {
3        int maxSum = nums[0];
4        int currentSum = nums[0];
5
6        for (int i = 1; i < nums.length; i++) {
7            currentSum = Math.max(nums[i], currentSum + nums[i]);
8            maxSum = Math.max(maxSum, currentSum);
9        }
10
11        return maxSum;
12    }
13
14    public static void main(String[] args) {
15        Solution solution = new Solution();
16
17        int[] nums1 = {-2, 1, -3, 4, -1, 2, 1, -5, 4};
18        int[] nums2 = {1};
19        int[] nums3 = {5, 4, -1, 7, 8};
20
21
22        System.out.println(solution.maxSubArray(nums1)); // Expected output: 6
23        System.out.println(solution.maxSubArray(nums2)); // Expected output: 1
24        System.out.println(solution.maxSubArray(nums3)); // Expected output: 23
25    }
26}

Fonte: https://interviewing.io/questions/maximum-subarray

Phrasal Verbs

Geral

💬 Mini Diálogo 1 — “Wake up”

Anna: What time do you usually wake up?
Tom: Around 6:30. I need some quiet time before work.
Anna: Wow, I wish I could wake up that early!

🎯 wake up = acordar


💬 Mini Diálogo 2 — “Give up”

Mark: This math problem is so hard. I’m about to give up.
Lucy: Don’t give up! Let’s figure it out together.
Mark: Okay, thanks! I needed that.

🎯 give up = desistir


💬 Mini Diálogo 3 — “Pick up”

Sarah: Can you pick up the kids from school today?
Mike: Sure, what time?
Sarah: Around 3 PM. Thank you!

🎯 pick up = buscar (alguém), pegar


💬 Mini Diálogo 4 — “Look for”

Emma: I’m looking for my keys. Have you seen them?
Jake: Check the kitchen. You left them there this morning.
Emma: Oh right, thanks!

🎯 look for = procurar


💬 Mini Diálogo 5 — “Turn off”

Dad: Turn off the lights when you leave the room.
Josh: Sorry! I always forget.
Dad: It helps save energy.

🎯 turn off = desligar

Trabalho

💬 Mini Diálogo 1 — “Call off”

(cancelar algo)

Manager: We need to call off the meeting.
Assistant: Okay, should I inform everyone?
Manager: Yes, please send an email now.

🎯 call off = cancelar


💬 Mini Diálogo 2 — “Follow up”

(acompanhar, dar continuidade)

Ana: Did you follow up with the client?
Leo: Not yet, I’ll send them a quick message now.
Ana: Great. We need their feedback ASAP.

🎯 follow up = fazer acompanhamento, retorno


💬 Mini Diálogo 3 — “Run by”

(checar algo com alguém)

Clara: Can I run something by you real quick?
Boss: Sure, what’s up?
Clara: It’s about the new budget proposal.

🎯 run by = confirmar algo com alguém, pedir opinião


💬 Mini Diálogo 4 — “Take on”

(assumir responsabilidade ou tarefa)

John: I can’t take on any more projects right now.
Karen: No worries. I’ll ask someone else.
John: Thanks, I’m swamped.

🎯 take on = assumir (tarefa, responsabilidade)


💬 Mini Diálogo 5 — “Catch up”

(atualizar-se ou colocar-se em dia)

Lucas: I need some time to catch up on emails.
Maria: Sure, we’ve all been busy.
Lucas: I’ll join you in 10 minutes.

🎯 catch up (on) = colocar-se em dia, recuperar o tempo

Entregas de projetos


💬 Mini Diálogo 1 — “Hand in”

(entregar algo oficialmente)

Carol: Have you handed in the final report yet?
Diego: Not yet. I’m doing the last review now.
Carol: Okay, but the deadline is at 5 PM sharp.

🎯 hand in = entregar (trabalho, relatório, etc.)


💬 Mini Diálogo 2 — “Wrap up”

(finalizar, concluir algo)

Jade: Let’s wrap up the presentation before lunch.
Felipe: Good idea. We just need to add the conclusion slide.
Jade: I’ll take care of that.

🎯 wrap up = finalizar


💬 Mini Diálogo 3 — “Fall behind”

(ficar para trás)

Lucas: We’re falling behind on this project.
Bea: I know. We need more people on the team.
Lucas: Or at least fewer last-minute changes.

🎯 fall behind = atrasar-se, ficar para trás no cronograma


💬 Mini Diálogo 4 — “Turn in”

(entregar, semelhante a “hand in” — usado mais nos EUA)

Nina: When are we supposed to turn in the prototype?
Josh: Friday morning, before the demo.
Nina: Okay, we’ll be ready.

🎯 turn in = entregar (projeto, trabalho, relatório)


💬 Mini Diálogo 5 — “Go over”

(revisar, analisar)

Manager: Let’s go over the timeline one more time.
Team: Sure, just to make sure we’re on track.
Manager: Exactly. No surprises next week.

🎯 go over = revisar, analisar em detalhes


 Liderança de Equipe


💬 Mini Diálogo 1 — “Step up”

(assumir responsabilidade, se destacar)

Sara: We’re short on team leads this week.
Andre: I can step up and take charge of the new task.
Sara: That would be amazing. Thank you!

🎯 step up = assumir a responsabilidade, dar um passo à frente


💬 Mini Diálogo 2 — “Bring up”

(levantar um assunto)

Leo: I’m not sure if I should bring up the issue with the client.
Maya: You should. Better now than during the launch.
Leo: True, I’ll mention it in the meeting.

🎯 bring up = mencionar, levantar um assunto


💬 Mini Diálogo 3 — “Back up”

(dar apoio a alguém)

Joana: I’ll support your decision in front of the board.
Carlos: Thanks. I really appreciate you backing me up.
Joana: That’s what teamwork is for.

🎯 back up = apoiar alguém


💬 Mini Diálogo 4 — “Check in”

(verificar como alguém está / acompanhar progresso)

Manager: Just checking in—how’s the new design going?
Rita: Pretty well! We’re ahead of schedule.
Manager: Great! Keep it up.

🎯 check in (with someone) = acompanhar, ver como a pessoa está indo


💬 Mini Diálogo 5 — “Lay out”

(explicar algo claramente, organizar ideias)

Victor: Can you lay out the plan for the onboarding process?
Emily: Sure, I’ll present the steps in today’s meeting.
Victor: Perfect, we need clarity.

🎯 lay out = explicar, apresentar de forma estruturada


Top 100 Phrasal Verbs

Phrasal Verb Significado em Português
ask out convidar para sair (romanticamente)
back up apoiar, dar suporte
blow up explodir, perder o controle
break down quebrar, parar de funcionar / desmoronar
break up terminar um relacionamento
bring up mencionar, levantar um assunto
call back retornar uma ligação
calm down acalmar-se
carry on continuar
check in fazer check-in
check out sair (do hotel) / dar uma olhada
clean up limpar
come across deparar-se com, encontrar por acaso
come back voltar
come in entrar
come on vamos lá / animar-se
come over visitar alguém
come up surgir (problema, assunto)
cut down (on) reduzir consumo de algo
cut off cortar, interromper
do over refazer
dress up vestir-se bem / fantasiar-se
drop off deixar alguém/algo em algum lugar
end up acabar sendo / acabar em
fall apart desmoronar (emocionalmente ou fisicamente)
fall down cair
figure out entender, encontrar uma solução
fill in preencher (formulário)
find out descobrir
get along (with) dar-se bem com alguém
get back voltar
get in entrar (carro, casa)
get off sair (ônibus, trabalho)
get on entrar (ônibus, avião) / dar-se bem
get out sair
get over superar (doença, término)
get up levantar-se
give away doar / revelar segredo
give back devolver
give up desistir
go ahead vá em frente
go back voltar
go on continuar, acontecer
go out sair (para se divertir)
grow up crescer
hand in entregar (trabalho, dever)
hang out passar tempo, sair
hang up desligar o telefone
hold on esperar / segurar firme
hurry up apressar-se
keep on continuar (fazendo algo)
keep up (with) acompanhar, manter o ritmo
let down decepcionar
log in entrar (sistema, site)
log out sair (sistema, site)
look after cuidar de
look around olhar em volta
look at olhar para
look for procurar
look forward to esperar ansiosamente
look out tomar cuidado
look up procurar (em dicionário, internet)
make up inventar / fazer as pazes / maquiar-se
move in mudar-se (para dentro)
move out mudar-se (para fora)
pass away falecer
pass out desmaiar / distribuir
pick up pegar / buscar / aprender
point out apontar, destacar
put away guardar
put off adiar
put on vestir / colocar
put out apagar (fogo, cigarro)
run out (of) ficar sem algo
run into encontrar por acaso
set up configurar / organizar
show off se exibir
shut down desligar, encerrar
sit down sentar-se
stand up levantar-se
stay up ficar acordado
take after parecer-se com (família)
take away levar embora
take back devolver / retirar o que disse
take off decolar / tirar (roupa)
take out levar para sair / tirar algo
take over assumir controle
tear up rasgar completamente
think over considerar, pensar bem
throw away jogar fora
throw up vomitar
try on experimentar roupa
turn down recusar / abaixar (volume)
turn off desligar / desanimar
turn on ligar / atrair
turn up aparecer / aumentar (volume)
wake up acordar
warm up aquecer / preparar-se
watch out prestar atenção, tomar cuidado
work out malhar / dar certo / resolver
write down anotar

Arrays parallelSort

O método Arrays.sort é bastante eficiente para a maioria dos casos, mas quando lidamos com arrays muito grandes, sua versão sequencial pode se tornar um gargalo, principalmente ao aproveitar apenas um único núcleo da CPU. Para arrays de tipos primitivos, o Java utiliza uma implementação de Dual-Pivot Quicksort, que tem, em média, complexidade de O(n log n). Entretanto, mesmo essa implementação bem otimizada pode enfrentar limitações em contextos de alto volume de dados, sobretudo se a ordenação for um dos pontos críticos de desempenho da aplicação.

Uma solução bastante interessante nesses cenários é utilizar o Arrays.parallelSort. Introduzido a partir do Java 8, esse método parte o array em segmentos menores e os classifica de forma concorrente, aproveitando o framework Fork/Join para distribuir as tarefas entre múltiplos núcleos. Essa abordagem pode reduzir significativamente o tempo total de ordenação em sistemas com múltiplos threads, especialmente em arrays de tamanho enorme. Além disso, para conjuntos de dados cuja chave seja numérica e limitada, algoritmos não-baseados em comparação, como Radix Sort ou Counting Sort, podem ser explorados, já que esses algoritmos podem apresentar desempenho linear sob determinadas condições.

Portanto, ao avaliar a performance do Arrays.sort com arrays grandes, a recomendação é considerar o uso de algoritmos paralelos, como o Arrays.parallelSort, que se aproveitam da arquitetura moderna multi-core. Essa solução não só melhora o tempo de execução, mas também distribui de forma mais equilibrada a carga de processamento, resultando em um desempenho superior para aplicações que lidam com volumes massivos de dados.

Você também pode explorar algoritmos específicos para tipos de dados particulares. Por exemplo, para ordenar strings ou outros objetos com um padrão de comparação complexo, uma combinação de particionamento eficiente e técnicas de otimização local pode trazer ganhos importantes. Essa abordagem pode ser ajustada conforme o perfil dos dados e o ambiente de execução, permitindo um balanceamento ideal entre uso de memória e velocidade de processamento.

Principal Architect Interview Questions

Personal Introductions & Motivations
. “Tell me a bit about your career to date”
. “What motivated you to explore this opportunity?”
. “What are you looking for in your next role that perhaps you’re not getting in your current role?”

Team Structure & Maturity (Chief Architect outlines)
. “We currently have a hybrid architecture model; a small core EA team and domain architects embedded with product and engineering.”
. “We’re investing in raising the architectural bar across teams; you’d play a key role in maturing that culture.”

Architecture Challenges
. “One challenge we’re facing is fragmentation; different domains are solving similar problems in different ways.
. “There’s still a gap between business strategy and architecture outcomes; one of your core focuses would be bridging that.”

Architecture Specific Questions
• How do you define and drive technical direction across multiple domains or product lines?
• What methods do you use to ensure architectural alignment across distributed teams or department
• How do you establish and maintain architectural standards. patterns, and principles at scale?
• How do you grow and mentor other architects or senior engineers?
• Describe how you’ve worked with product and business leaders to shape a technology roadmap.
• Can you give an example of resolving conflict between architectural vision and product priorities?

Q&A
Opportunity for the Principal Architect to ask some questions:
• “What would success look like in the first 90 days?”
• “How is the architecture function currently perceived across engineering and business teams?”
• “How do you see me contributing to the cultural maturity and evolution of the architecture team?”

COC

Commercial Offer Catalog (Catálogo de Ofertas Comerciais) é um conceito amplamente utilizado em setores como telecomunicações, serviços financeiros, energia, e-commerce, e outros segmentos que envolvem a venda de produtos e serviços complexos. Ele funciona como uma base estruturada e centralizada onde todas as ofertas comerciais de uma empresa são definidas, organizadas, gerenciadas e disponibilizadas para os canais de venda.

A seguir, explico detalhadamente os principais conceitos relacionados ao Commercial Offer Catalog:


📚 O que é um Commercial Offer Catalog?

É um repositório centralizado de todas as ofertas comerciais de uma empresa. Nele são definidos os produtos e serviços que podem ser oferecidos aos clientes, bem como as regras de negócio, preços, elegibilidade, promoções, dependências técnicas e combinações possíveis entre os produtos.


  1. Produtos e Serviços

    • Itens individuais que compõem uma oferta, como internet banda larga, plano de telefonia, seguro, etc.
    • Pode conter atributos como: velocidade, franquia, tipo de cobertura, validade, entre outros.
  2. Ofertas

    • Conjunto de produtos/serviços agrupados com regras específicas.
    • Ex: “Combo Família” que inclui TV, internet e telefone fixo com desconto.
  3. Preços e Tarifas

    • Tabelas de preços, descontos aplicáveis, promoções temporárias e regras tributárias.
    • Pode incluir variações por região, canal de venda, perfil do cliente, etc.
  4. Regras de Elegibilidade

    • Define para quem a oferta está disponível (ex: apenas para novos clientes, ou em determinadas regiões).
  5. Validade e Ciclo de Vida

    • Período em que a oferta está ativa, expirando depois de uma data específica ou após condições de uso.
  6. Relacionamento entre Ofertas

    • Regras de compatibilidade, exclusividade ou dependência entre diferentes ofertas ou produtos.

🧠 Benefícios de um Commercial Offer Catalog bem estruturado

  • 🔄 Agilidade na criação e modificação de ofertas: Mudanças podem ser feitas rapidamente sem impacto no sistema como um todo.
  • 🛠 Reuso de componentes: Produtos e regras podem ser reutilizados em diferentes ofertas.
  • 🎯 Personalização: Permite ofertas personalizadas para diferentes segmentos ou perfis de cliente.
  • 📦 Unificação de canais: Garante que todos os canais de venda (loja, app, call center, site) ofereçam as mesmas informações e regras.
  • ✅ Governança e controle: Facilita a conformidade com regras regulatórias e políticas internas.

🧱 Arquitetura e Tecnologias Envolvidas

  • Pode ser implementado usando padrões como:
    • TM Forum SID e eTOM, no setor de telecomunicações.
    • APIs RESTful para expor o catálogo a sistemas de CRM, portais e apps.
    • Soluções COTS (Commercial Off-the-Shelf) como Oracle BRM, Amdocs Catalog, Ericsson e outros.
    • Microservices e Headless CMS, em implementações mais modernas.

🌍 Exemplos de uso

  • Uma operadora de telecom usa o catálogo para definir quais planos de internet estão disponíveis em cada cidade.
  • Um banco usa o catálogo para compor pacotes de serviços bancários com tarifas específicas para clientes universitários.
  • Um e-commerce usa o catálogo para definir combos promocionais e personalizáveis com base no histórico de compras do cliente.

Se quiser, posso te mostrar um exemplo prático em modelo JSON ou Java de como um sistema poderia representar uma oferta no catálogo. Também posso explorar como isso se integra com sistemas de CRM, Order Management ou Billing. Quer seguir por aí?

Legal! Vamos explorar um exemplo prático de como uma oferta comercial poderia ser representada em um modelo de dados (JSON) e depois podemos discutir como isso se integra com sistemas como CRM, Order Management e Billing.


📦 Exemplo de uma Oferta Comercial em JSON

{
  "offerId": "COMBO_FAMILIA_2025",
  "name": "Combo Família 2025",
  "description": "Internet + TV + Telefone fixo com desconto exclusivo",
  "status": "ACTIVE",
  "validFrom": "2025-01-01",
  "validTo": "2025-12-31",
  "channelsAvailable": ["ONLINE", "CALL_CENTER", "RETAIL_STORE"],
  "eligibilityRules": {
    "customerType": ["NEW", "EXISTING"],
    "region": ["SP", "RJ", "MG"]
  },
  "products": [
    {
      "productId": "INTERNET_500MB",
      "name": "Internet 500MB",
      "price": {
        "monthly": 99.9
      }
    },
    {
      "productId": "TV_HD_150CANAIS",
      "name": "TV HD com 150 canais",
      "price": {
        "monthly": 79.9
      }
    },
    {
      "productId": "TELEFONE_FIXO_ILIMITADO",
      "name": "Telefone Fixo Ilimitado",
      "price": {
        "monthly": 29.9
      }
    }
  ],
  "bundlePrice": {
    "monthly": 169.9,
    "discount": 39.8
  },
  "technicalDependencies": [
    "EQUIPAMENTO_MODEM",
    "EQUIPAMENTO_TV_BOX"
  ]
}

🔄 Integrações com Outros Sistemas

🧾 1. CRM (Customer Relationship Management)

  • O CRM consulta o catálogo para mostrar ofertas elegíveis no momento da venda.
  • Permite recomendar ofertas com base no perfil do cliente.
  • Utiliza as regras de elegibilidade do catálogo.

📦 2. Order Management (OM)

  • Recebe a oferta selecionada e quebra em componentes técnicos para orquestrar a ativação.
  • Garante que todas as dependências técnicas sejam respeitadas (ex: entrega de modem, ativação da linha).

💰 3. Billing (Faturamento)

  • Usa o catálogo para saber como calcular o valor da fatura do cliente.
  • Identifica preços promocionais, período de vigência, descontos, etc.

🛠 Arquitetura baseada em microservices (exemplo simplificado)

[Front-End Web/App]
      ↓
[API Gateway]
      ↓
[Commercial Catalog Service] ←→ [Product Catalog]
      ↓
[CRM] ←→ [Order Management System] ←→ [Billing System]

Cada componente consulta o Commercial Catalog Service para garantir consistência.


Se quiser, posso converter esse modelo JSON em um POJO Java com classes como OfferProductPrice, e até simular um endpoint REST para consumir o catálogo. Quer seguir para a parte Java?

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.