Skip to content

Latest commit

 

History

History
1966 lines (1654 loc) · 179 KB

README-ptbr.md

File metadata and controls

1966 lines (1654 loc) · 179 KB
Raw

Universidade de Entrevista de Programação

Originalmente eu criei isso como uma pequena lista to-do (a fazer) de tópicos de estudo para se tornar um engenheiro de software, mas isso cresceu para este imenso acervo que você consulta hoje. Após passar por todo esse plano de estudo, Eu fui contratado como Engenheiro de Desenvolvimento de Software na Amazon! Você provavelmente não vai precisar estudar tanto quanto eu. De qualquer maneira, tudo que você precisa está aqui.

Os itens listados aqui irão preparar você muito bem para uma entrevista em praticamente qualquer empresa de software, incluindo as gigantes como: Amazon, Facebook, Google ou Microsoft.

Boa sorte para todos vocês!

Original: Inglês

Tradutores: Marlon Aviz (Contribuições), marceloogeda (Contribuições), laris151 (Contribuições)

Traduções:

Traduções em progresso:

O que é isso?

Esse é o meu plano de estudo mensal para ir de desenvolvedor web (autodidata, sem formação em Ciência da Computação) à engenheiro de software em uma grande empresa.

Programando no quadro branco - do Vale do Silício da HBO

Essa longa lista foi extraída e expandida a partir das anotações de treinamento da Google, então essas são as coisas que você precisa saber. Eu adicionei alguns itens extras no final que podem aparecer na entrevista ou serem úteis para resolver um problema. Muitos itens são da obra “Get that job at Google” (Consiga aquele trabalho na Google) de Steve Yegge's e às vezes são expressados palavra-por-palavra nas anotações de treinamento da Google.

Isso é direcionado à novos engenheiros de software, ou àqueles que estão migrando de desenvolvimento de software/web para engenharia de software, onde conhecimento sobre ciência da computação é necessário. Se você tem vários anos de experiência e está alegando muitos anos de experiência com engenharia de software, pode esperar por uma entrevista mais difícil.

Se você tem vários anos de experiência com desenvolvimento de software/web, observe que grandes empresas como Google, Amazon, Facebook e Microsoft consideram engenharia de software como algo distinto de desenvolvimento de software/web e elas requerem conhecimento de ciência da computação.

Se você quer ser um engenheiro de confiabilidade ou engenheiro de sistemas, estude mais da lista opcional (rede, segurança).

Índice

---------------- Tudo abaixo é opcional ----------------

Por que usar?

Quando eu comecei esse projeto, eu não sabia diferenciar memória dinâmica de memória estática, não sabia notação Big-O, árvores, ou como percorrer um grafo. Se eu tivesse que escrever um algoritmo de ordenação, eu posso te dizer que ele não seria muito bom. Todas as estruturas de dados que eu já usei eram construídas dentro da linguagem, e eu não sabia como elas funcionavam por debaixo dos panos. Eu nunca tive que gerenciar memória a não ser que um processo que eu estava rodando desse um erro de "memória insuficiente", nesse caso eu teria que dar um jeito. Eu já usei alguns vetores multidimensionais na minha vida e milhares de vetores associativos, mas eu nunca criei estruturas de dados do zero.

É um longo plano. Você vai levar meses. Se você já é familiarizado com muitas dessas coisas, você vai precisar de muito menos tempo.

Como usar

Tudo abaixo é um esboço, e você deve abordar os itens em ordem de cima para baixo.

Eu estou usando a sintaxe de markdown especial do Github, incluindo listas de tarefas para verificar o progresso.

Crie um novo branch para você verificar itens assim, apenas coloque um x entre os colchetes: [x]

Bifurque (fork) um branch e siga os comandos abaixo

git checkout -b progress

git remote add jwasham https://github.com/jwasham/coding-interview-university

git fetch --all

Marque todas as caixas com X depois que você completar suas alterações

git add .

git commit -m "Marked x"

git rebase jwasham/main

git push --force

Mais sobre a sintaxe de markdown especial do Github

Não ache que você não é inteligente o suficiente

Sobre os recursos em vídeo

Alguns vídeos estão disponíveis somente ao ingressar em um curso no Coursera, EdX, ou Lynda.com. Esses são chamados de MOOCs (Curso Online Aberto e Massivo). Às vezes as aulas não estão em sessão, nesse caso você terá que esperar alguns meses, portanto não terá acesso até lá. Os cursos da Lynda.com não são gratuitos.

Eu agradeceria a ajuda de vocês em adicionar recursos públicos gratuitos que sempre estejam disponíveis, como vídeos do YouTube para acompanhar os vídeos de curso online.
Eu gosto de usar palestras de universidades;

Processo de Entrevista e Preparação Geral para a Entrevista

Escolha Uma Linguagem para a Entrevista

Você pode escolher uma linguagem com a qual você esteja confortável para fazer a parte de programação (parte prática) da entrevista, mas para grandes empresas, essas são ótimas opções:

  • C++
  • Java
  • Python

Você também poderia usar essas, mas dê uma lida por aí antes. Podem haver ressalvas:

  • JavaScript
  • Ruby

Você precisa estar confortável com a linguagem e ser bem informado.

Leia mais sobre as escolhas:

Veja recursos de linguagens aqui

Você vai ver aprendizado de C, C++ e Python incluído abaixo, porque é o que estou aprendendo. Tem alguns livros envolvidos, veja no final.

Lista de Livros

Essa é uma lista menor comparada à que eu usei. Está abreviada para economizar seu tempo.

Preparação para a Entrevista

Se você tem muito tempo sobrando:

Arquitetura de Computador

Se estiver com pouco tempo:

  • Write Great Code: Volume 1: Understanding the Machine (Escreva um Excelente Código: Volume 1: Compreendendo a Máquina)
    • O livro foi publicado em 2004, e está meio desatualizado, mas é um recurso incrível para se compreender um computador resumidamente.
    • O autor inventou HLA (High-level Assembly ou, no português, Assembly de alto nível), então considere as menções e exemplos em HLA com cautela. Não é usado amplamente, mas contém exemplos decentes de como o assembly funciona.
    • Esses capítulos valem a pena serem lidos para lhe dar uma boa base:
      • Chapter 2 - Numeric Representation (Capítulo 2 - Representação Numérica)
      • Chapter 3 - Binary Arithmetic and Bit Operations (Capítulo 3 - Aritmética Binária e Operações Bit)
      • Chapter 4 - Floating-Point Representation (Representação em Ponto Flutuante)
      • Chapter 5 - Character Representation (Representação de Caractere)
      • Chapter 6 - Memory Organization and Access (Organização e Acesso de Memória)
      • Chapter 7 - Composite Data Types and Memory Objects (Tipos de Dados Compostos e Objetos de Memória)
      • Chapter 9 - CPU Architecture (Arquitetura de CPU)
      • Chapter 10 - Instruction Set Architecture (Arquitetura de Conjunto de Instruções)
      • Chapter 11 - Memory Architecture and Organization (Arquitetura e Organização de Memória)

Se você tem mais tempo (eu quero esse livro):

Específico de Linguagem

Você precisa escolher uma linguagem para a entrevista (veja acima). Aqui estão minhas recomendações por linguagem. Eu não tenho recursos para todas as linguagens. Contribuições são bem-vindas.

Se você ler um desses, você deverá ter todo conhecimento de estrutura de dados e algoritmos que precisará para começar a resolver problemas de programação. Você pode pular todas as aulas em vídeo nesse projeto, a não ser que você queira uma revisão.

Recursos adicionais específicos a cada linguagem aqui.

C++

Eu não li esses dois, mas eles são muito bem avaliados e escritos por Sedgewick. Ele é incrível.

Se você tiver uma recomendação melhor para C++, por favor me informe. Busco por recursos completos.

Java

OU:

  • Data Structures and Algorithms in Java (Estrutura de Dados e Algoritmos em Java)
    • por Goodrich, Tamassia, Goldwasser
    • usado como texo opcional para o curso introdutório de Ciência da Computação na Universidade da Califórnia em Berkeley
    • veja o meu resumo sobre a versão em Python abaixo. Esse livro abrange os mesmos tópicos.

Python

Livros Opcionais

Algumas pessoas recomendam esses, mas eu acho que está além do necessário, a não ser que você tenha muitos anos de experiência em engenharia de software e está esperando por uma entrevista muito mais difícil:

  • Algorithm Design Manual (Skiena) (Manual de Design de Algoritmo)

    • Como uma revisão e reconhecimento de problema
    • A parte de catálogos de algoritmos está muito além da margem de dificuldade que você terá em uma entrevista.
    • Esse livro tem 2 partes:
      • livro de aula sobre estrutura de dados e algoritmos
        • prós:
          • é uma boa revisão assim como qualquer texto de algoritmos seria
          • boas estórias da experiência dele resolvendo problemas na indústria e na universidade
          • exemplo de código em C
        • contras:
          • pode ser tão denso ou impenetrável quanto CLRS (Introdução a Algoritmos), e em alguns casos, CLRS pode ser uma alternativa melhor para alguns temas
          • capítulos 7, 8 e 9 podem ser sofridos para acompanhar, já que alguns itens não são bem explicados ou requerem mais cérebro do que eu tenho
          • não me entenda mal: Eu gosto de Skiena, do estilo de ensino dele, e maneirismos, mas pode não ser um material do tipo da universidade Stony Brook.
      • catálogo de algoritmos
        • essa é a verdadeira razão para você comprar esse livro.
        • prestes a chegar nessa parte. Vou atualizar aqui assim que eu terminar de ler essa parte.
    • Pode alugar no kindle
    • Half.com é um ótimo recurso para livros com bons preços.
    • Respostas:
    • Errata

  • Introduction to Algorithms (Introdução à Algoritmos)

    • Importante: Ler esse livro só terá um valor limitado. Esse livro é ótimo para revisão de algoritmos e estrutura de dados, mas não irá te ensinar a escrever um bom código. Você deve ser capaz de codificar uma solução decente eficientemente.
    • Half.com é um ótimo recurso para livros com bons preços.
    • também conhecido como CLR, às vezes CLRS, porque Stein estava atrasado para o negócio

  • Programming Pearls (Pérolas de Programação)

    • Os primeiros capítulos apresentam soluções inteligentes para problemas de programação (alguns bem velhos usando suporte magnético)
      mas isso é só uma introdução. Esse é um guia sobre design e arquitetura de programa, parecido com Code Complete, mas muito mais curto.

  • "Algorithms and Programming: Problems and Solutions" by Shen ("Algoritmos e Programação: Problemas e Soluções" por Shen)

    • Um bom livro, mas depois de trabalhar nos problemas em várias páginas eu fiquei frustrado com o Pascal, loops do...while, arrays de 1 índice (index), e resultados de satisfação pós-condição pouco claros.
    • Prefiro gastar tempo em problemas de programação de outro livro ou problemas de programação online.

Antes de começar

Essa lista cresceu por longos meses, e sim, ela meio que saiu do controle!

Aqui estão alguns erros que eu cometi para que você tenha uma experiência melhor.

1. Você não se lembrará de tudo

Assisti a horas de vídeos e fiz anotações e meses depois havia muito que eu não lembrava. Eu passei 3 dias revisando minhas anotações e fazendo flashcards para que eu pudesse relembrar.

Por favor, leia para que você não cometa os meus erros:

Retaining Computer Science Knowledge

2. Use Flashcards

Para solucionar o problema, eu fiz um pequeno site de flashcards onde eu poderia adicionar dois tipos de flashcards: genérico e código.
Cada cartão tem formatação diferente.

Eu fiz um website focado em mobile para que eu pudesse rever no meu celular, tablet, onde quer que eu esteja.

Faça o seu próprio, grátis:

Tenha em mente que eu exagerei e tenho cartões abrangendo desde linguagem assembly e trivialidades de Python até aprendizado de máquina e estatísticas. É demais para o que é requerido. 

Nota: A primeira vez que você reconhece que sabe a resposta, não a marque como conhecida. Você tem que ver o mesmo cartão e respondê-lo várias vezes corretamente antes de realmente conhecê-lo. A repetição colocará esse conhecimento mais aprodundado em seu cérebro.

Uma alternativa ao uso do meu site de flashcards é Anki, que me foi recomendado várias vezes. Ele usa um sistema de repetição para ajuda-lo a se lembrar. É fácil de usar, está disponível em todas as plataformas e possui um sistema de sincronização em nuvem. Ele custa 25 dólares no iOS, mas é gratuito em outras plataformas.

Meu banco de dados de flashcards em formato Anki: https://ankiweb.net/shared/info/25173560 (obrigado @xiewenya)

3. Revise, Revise e Revise

Eu mantenho um conjunto de anotações em ASCII, OSI stack, Notações Big-O, e muito mais. Eu os estudo quando tenho algum tempo livre.

Faça uma pausa durante os problemas de programação por meia hora e passe por seus flashcards.

4. Foco

Há um monte de distrações que podem ocupar um tempo valioso. Foco e concentração são difíceis.

O que você não verá

Essas são tecnologias predominantes, mas não são partes desse plano de estudo:

  • SQL
  • Javascript
  • HTML, CSS, e outras tecnologias de front-end

O Plano Diário

Alguns temas levam um dia, e alguns vão levar vários dias. Alguns são apenas aprendizado sem nada para implementar.

A cada dia eu pego um tema da lista abaixo, assisto vídeos sobre aquele tema, e escrevo uma implementação em:

  • C - usando structs e funções que usam struct * e alguma outra coisa como argumentos.
  • C++ - sem usar types internos.
  • C++ - usando types internos, como std::list da STL para uma lista ligada
  • Python - usando types internos (para continuar praticando Python)
  • e escrevo testes para garantir que estou fazendo certo, às vezes uso apenas declarações simples de asser()
  • Você pode fazer com Java também ou alguma outra linguagem, eu apenas prefiro essas cima.

Você não precisa de todas essas linguagens. Você precisa de apenas uma linguagem para a entrevista.

Por que programar em todas essas linguagens?

  • Prática, prática, prática, até eu enjoar e poder implementar sem problemas (algumas tem muitos casos com valores de entrada extremos, ou seja, muito pequenos ou muito grandes, e também têm muitos detalhes de escrituração para lembrar)
  • Trabalhar dentro das restrições básicas (alocar/liberar memória sem ajuda de um coletor de lixo (com exceção de Python))
  • Fazer uso de types internos para que eu possa ter experiência em usar ferramentas internas para problemas do mundo real (não vou escrever minha própria implementação de lista ligada durante a etapa de produção)

Talvez eu não tenha tempo para fazer tudo isso para cada tema, mas eu vou tentar.

Você pode ver meu código aqui:

Você não precisa memorizar os detalhes intrínsecos de cada algoritmo.

Escreva código em um quadro branco ou papel, não em um computador. Teste com umas amostras de valores de entrada (input). Depois teste em um computador.

Conhecimento Prévio

  • Aprenda C

    • C está em todo lugar. Você vai ver exemplos em livros, aulas, vídeos, em todo lugar enquanto você estiver estudando.
    • C Programming Language, Vol 2 (Linguagem de Programação C, Vol 2)
      • Esse é um livro curto, mas vai te ajudar a ter um ótimo domínio da linguagem C e se você praticar um pouco você irá se tornar proficiente rapidamente. Entender C te ajuda a entender como os programas e a memória funcionam.
      • answers to questions (respostas para as questões)

  • Como computadores processam um programa:

Complexidade Algorítmica / Big-O / Análise assintótica

Estrutura de Dados

  • Arrays

    • Implementar um vetor de redimensionamento automático.
    • Descrição:
    • Implementar um vetor (array mutável com redimensionamento automático):
      • Praticar programação usando arrays e ponteiros, e matemática de ponteiros para pular para um índice ao invés de usar indexação.
      • novo array de dados brutos com memória alocada
        • pode alocar array de números inteiros por de baixo dos panos, só não pode usar seus recursos
        • começa com 16, ou se o número inicial for maior, usar potência de 2 - 16, 32, 64, 128
      • size() - número de itens
      • capacity() - número de itens que pode conter
      • is_empty()
      • at(index) - retorna o item que está no índice fornecido, dá erro se o índice estiver fora da capacidade do array
      • push(item)
      • insert(índice, item) - insere "item" no "índice", muda o valor daquele índice e move os elementos excedentes para a direita
      • prepend(item) - pode usar o insert acima no índice 0
      • pop() - remove do final, retorna o valor
      • delete(índice) - deleta o item no índice fornecido, deslocando todos os elementos excedentes para a esquerda
      • remove(item) - busca pelo valor e remove o índice contendo ele (mesmo que esteja em múltiplos lugares)
      • find(item) - busca pelo valor e retorna o primeiro índice com aquele valor, -1 se não encontrar
      • resize(nova_capacidade) // função privada
        • quando você atinge o limite da capacidade, redimensone para dobrar a capacidade
        • quando estiver usando pop() em um item, se o tamanho for 1/4 da capacidade, redimensionar para a metade da capacidade
    • Tempo
      • O(1) para adicionar/remover no final (amortizado para alocações para mais espaço), índice ou atualização
      • O(n) para inserir/remover em algum outro lugar
    • Espaço
      • contíguo na memória, então proximidade ajuda no desempenho
      • espaço necessário = (capacidade do array, a qual é >= n) * tamanho do item, mas mesmo que seja 2n, ainda será O(n)

  • Listas Ligadas

    • Descrição:
    • C Code (video) (Código em C - vídeo) - não o vídeo inteiro, apenas as partes sobre estrutura de nodes (nós) e alocação de memória.
    • Listas Ligadas vs Arrays:
    • why you should avoid linked lists (video) (por que você deve evitar listas ligadas - vídeo)
    • Peguei vocês: você precisa de conhecimento de ponteiro para ponteiro: (para quando você passar um ponteiro para uma funcção que poderá mudar o endereço para o qual o ponteiro aponta) Essa página é só para ter uma noção sobre ponteiro para ponteiro. Eu não recomendo o estilo transversal dessa lista. Legibilidade e manutenção sofrem devido à engenhosidade.
    • implementar (eu fiz com e sem ponteiro de cauda, ponteiro que aponta para o último node (nó) da lista):
      • size() - retorna o número de elementos de dados na lista
      • empty() - boleano retorna verdadeiro se estiver vazio
      • value_at(índice) - retorna o valor do item n (começando no 0 para o primeiro)
      • push_front(valor) - adiciona um item no início da lista, logo antes do seu atual primeiro elemento
      • pop_front() - remove o item do início da lista e retorna o seu valor
      • push_back(valor) - adiciona um item no final da lista
      • pop_back() - remove um item do final e retorna seu valor
      • front() - obtém valor do item que está no início da lista
      • back() - obtém valor do item que está no final da lista
      • insert(índice, valor) - insere "valor" no "índice", e depois o item atual naquele índice é apontado pelo novo item no "índice"
      • erase(índice) - remove o node (nó) no índice fornecido
      • value_n_from_end(n) - retorna o valor do node (nó) na posição n a partir do final da lista
      • reverse() - reverte a lista
      • remove_value(valor) - remove o primeiro item na lista com esse valor
    • Listas Ligadas Duplamente

  • Stack

  • Queue (Fila)

    • Using Queues First-In First-Out(video) (Usando queues FIFO(Primeiro a entrar, último a sair) - vídeo)
    • Queue (video)
    • Circular buffer/FIFO (Buffer circular/Primeiro a entrar, último a sair)
    • Priority Queues (video) (Queues com Prioridade - vídeo)
    • Implementar usando lista ligada, com ponteiro de cauda (aponta para o último elemento de uma lista):
      • enqueue(valor) - adiciona "valor" na posição na cauda (final da lista)
      • dequeue() - retorna um valor e remove o elemento menos recentemente adicionado (início da lista))
      • empty()
    • Implementar usando arrays de tamanho-fixo:
      • enqueue(valor) - adiciona um item no final do armazenamento disponível
      • dequeue() - retorna um valor e remove um elemento menos recentemente adicionado
      • empty()
      • full()
    • Custo:
      • uma implementação ruim usando lista ligada na qual você coloca na fila (enqueue) no head (cabeça/início da lista) e tira da fila (dequeue) no tail (cauda/final da lista) seria O(n) porque você precisaria do penúltimo elemento, causando uma transversal completa a cada dequeue
      • enqueue: O(1) (amortizado, lista ligada e array [sondagem])
      • dequeue: O(1) (lista ligada e array)
      • empty (vazio): O(1) (lista ligada e array)

  • Tabela hash

Mais Conhecimento

Árvores

  • Árvores - Anotações e Fundamentos

    • Series: Trees (video) (Série: Árvores - vídeo)
    • contrução básica de árvore
    • transversal
    • algorítmos de manipulação
    • Busca em largura (conhecido no Inglês como BFS ou breadth-first search)
      • MIT (vídeo)
      • ordem de nível (busca em largura, usando filas) complexidade de tempo: O(n) complexidade de espaço: melhor: O(1), pior: O(n/2)=O(n)
    • Busca em profundidade (conhecido no Inglês como DFS ou depth-first search)
      • MIT (vídeo)
      • anotações: complexidade de tempo: O(n) space complexity: melhor: O(log n) - altura média da árvore pior: O(n)
      • em-ordem ou ordem simétrica(na busca em profundidade (ou DFS): percorre subárvore esquerda em ordem simétrica (em-ordem), visita a raiz, percorre subárvore direita em ordem simétrica)
      • pós-ordem (na busca em profundidade (ou DFS): percorre subárvore esquerda em pós-ordem, percorre subárvore direita em pós-ordem, visita a raiz)
      • pré-ordem (na busca em profundidade (ou DFS): visita a raiz, percorre subárvore esquerda em pré-ordem, percorre subárvore direita em pré-ordem)

  • Árvores binárias de busca: ABB

  • Memória Dinâmica (heap) / Filas Prioritárias / Memória Dinâmica Binária (heap binary)

    • visualizada como uma árvore, mas geralmente é linear no armazenamento (array, lista ligada)
    • Heap (Memória DInâmica)
    • Introduction (video) (Introdução - vídeo)
    • Naive Implementations (video) (Implementações Ingênuas - vídeo)
    • Binary Trees (video) (Árvores Binárias - vídeo)
    • Tree Height Remark (video) (Observações sobre Altura de Árvore - vídeo)
    • Basic Operations (video) (Operações Básicas - vídeo)
    • Complete Binary Trees (video) (Árvores Binárias Completas - vídeo)
    • Pseudocode (video) (Pseudocódigo - vídeo)
    • Heap Sort - jumps to start (video) (Algoritmo de Ordenação heapsort - pula para o começo - vídeo)
    • Heap Sort (video) (Algoritmo de Ordenação heapsort - vídeo)
    • Building a heap (video) (Construindo uma memória dinâmica (heap) - vídeo)
    • MIT: Heaps and Heap Sort (video) (MIT: Memórias Dinâmias e heapsort - vídeo)
    • CS 61B Lecture 24: Priority Queues (video) (CS (Ciência da Computação) 61B Aula 24: Filas Prioritárias - vídeo)
    • Linear Time BuildHeap (max-heap) (BuildHeap em Tempo Linear (heap máxima))
    • Implementar uma heap máxima (max-heap):
      • insert
      • sift_up - necessário insert
      • get_max - retorna o item max (maior item), sem removê-lo
      • get_size() - retorna o número de elementos armazenados
      • is_empty() - retorna "true" se o heap não contém elementos
      • extract_max - retorna o item max (maior item), removendo ele
      • sift_down - necessário para extract_max
      • remove(i) - remove o item no índice x
      • heapify - cria um heap a partir de um array de elementos, necessário para heap_sort
      • heap_sort() - pega um array não-ordenado e o transforma em um array ordenado "in-place" (sem gerar um novo array) usando uma heap máxima (max-heap)
        • nota: usando uma heap mínima (min-heap) ao invés de uma heap máxima (max-heap) poderia salvar operações, mas duplicar o espaço necessário (não é possível fazer "in-place")

Ordenação

Como um resumo, aqui está uma representação visual de 15 algoritmos de ordenação. Se você precisa de mais detalhes sobre o assunto, veja a seção "Ordenação" em Detalhes Adicionais Sobre Alguns Assuntos

Grafos

Grafos podem ser usados para representar muitos problemas na Ciência da Computação, então essa seção é longa, assim como árvores e ordenação também foram.

Você ganhará mais prática com grafos no livro do Skiena (veja a seção de livros abaixo) e os livros da entrevista

Ainda Mais Conhecimento

Design de Sistema, Escalabilidade, Tratamento de Dados

Revisão Final

Essa seção terá vídeos mais curtos que você pode assistir rapidamente para revisar a maioria dos conceitos importantes.
É legal se você quiser dar uma refrescada na memória.

Prática com Questões de Programação

Agora que você sabe todos os temas de Ciência da Computação acima, é hora de praticar respondendo problemas de programação.

Prática com Questõs de Programação não é sobre memorizar respostas para problemas de programação.

Por que você precisa praticar com problemas de programação:

  • reconhecimento de problemas, e onde as devidas estruturas de dados e algoritmos se encaixam
  • coleta de requerimentos para o problema
  • pensar alto (falar enquanto resolve o problema) assim como você irá fazer em uma entrevista
  • escrever código em um quadro branco ou papel, não no computador
  • encontrar complexidade de espaço e tempo para suas soluções
  • testar suas soluções

Tem uma introdução ótima para resolução de problema metódica e comunicativa em uma entrevista. Você vai adquirir isso dos livros de entrevista de programação, também, mas eu acho isso aqui excelente: Algorithm design canvas (Quadro de design de algoritmo)

Não tem quadro branco em casa? Faz sentido. Eu sou um estranho e tenho um grande quadro branco. Ao invés de um quadro branco, pegue um grande caderno de desenho de uma loja de arte. Você pode sentar no sofá e praticar. Esse é o meu "sofá de quadro branco". Eu adicionei a caneta na foto para comparação de dimensões. Se você usar uma caneta, você vai desejar que você pudesse apagar. Fica uma bagunça bem rápido.

meu sofá de quadro branco

Suplementar:

Leia e Faça os Problemas de Programação (nessa ordem):

Veja a Lista de Livros acima

Exercícios/desafios de programação

Depois que você enche o cérebro com novos aprendizados, é hora de botar ele para trabalhar. Faça desafios de programação todo dia, o máximo que você puder.

Vídeos de Questões de Entrevista de Programação:

Websites de desafios:

Repositórios de desafios:

Entrevistas Simuladas:

Quando a entrevista estiver se aproximando

Seu Currículo

  • Veja itens sobre preparo de currículo em "Cracking The Coding Interview" (Decifrando A Entrevista De Programação) e atrás do livro "Programming Interviews Exposed" (Entrevistas de Programação Expostas)

Esteja pensando à respeito para quando a entrevista chegar

Pense em 20 questões da entrevista que você vai ter, seguindo a linha de raciocínio dos itens abaixo. Tenha 2-3 respostas para cada. Tenha uma história, não apenas dados, sobre algo que você realizou.

  • Por que você quer esse trabalho?
  • Qual um problema difícil que você tenha resolvido?
  • Maiores desafios enfrentados?
  • Melhores/piores designs que você já viu?
  • Ideias para melhorar um produto existente.
  • Como você trabalha melhor, como um indivíduo e como parte de uma equipe?
  • Quais das suas habilidades ou experiências seriam recursos úteis na função e por quê?
  • O que você mais gostou no [trabalho x / projeto y]?
  • Qual foi o maior desafio que você enfrentou no [trabalho x / projeto y]?
  • Qual foi o bug mais difícil que você enfrentou no [trabalho x / projeto y]?
  • O que você aprendeu no [trabalho x / projeto y]?
  • O que você teria feito melhor no [trabalho x / projeto y]?

Tenha questões para o entrevistador

Algumas das minhas (eu posso já saber a resposta, mas o quero a opinião deles ou a perspectiva da equipe):
  • Quão grande é sua equipe?
  • Como é o seu ciclo de desenvolvimento? Você trabalha com modelo em cascata (waterfall)/sprints/método ágil (agile)?
  • Correrias por causa de prazos são comuns? Ou tem flexibilidade?
  • Como as decisões são tomadas na sua equipe?
  • Quantas reuniões você tem por semana?
  • Você sente que o seu ambiente de trabalho te ajuda a se concentrar?
  • No que você está trabalhando?
  • O que você gosta a respeito desse trabalho?
  • Como é o balanço vida-trabalho?

Quando Você Conseguir O Trabalho

Parabéns!

Continue aprendendo.

O aprendizado nunca para.

*****************************************************************************************************
*****************************************************************************************************

Tudo abaixo deste ponto é opcional.
Ao estudar o que vem a seguir, você vai ter maior exposição a mais conceitos de Ciência da Computação, e está mais bem preparado para 
qualquer trabalho de engenharia de software. Você será um engenheiro de software muito mais completo.

*****************************************************************************************************
*****************************************************************************************************

Livros Adicionais

Aprendizagem Adicional

Esses tópicos provavelmente não aparecerão em uma entrevista, mas eu adicionei eles para ajudar você a se tornar um engenheiro de software mais completo, e para você ficar ciente de certas tecnologias e algoritmos, assim você terá mais ferramentas a disposição.

--

Detalhes Adicionais Sobre Alguns Assuntos

Eu adicionei esses detalhes para reforçar algumas ideias já apresentadas acima, mas não quis incluir elas
acima porque aí é simplesmente demais. É fácil exagerar em um tema.
Você quer ser contratado nesse século, certo?

Séries de Vídeos

Sente-se e aproveite. "Netflix e habilidade" :P

Cursos de Ciência da Computação