Use o código e tenha 10% de desconto!

Introdução à Computação Da Lógica aos jogos com Ruby

Guilherme Silveira
Capa

Introdução à Computação: Da Lógica aos jogos com Ruby

Sumário

  • 1 - Introdução
    • 1.1 - Programação
    • 1.2 - Para o professor
    • 1.3 - Quem sou eu
    • 1.4 - Agradecimentos
  • 2 - Prefácio por Fábio Akita
    • 3 - Jogo da adivinhação
      • 3.1 - O jogo: entrada e saída básica
      • 3.2 - Será que acertou? O operador de comparação ==
      • 3.3 - Operador de atribuição e variáveis
      • 3.4 - Operadores de comparação
      • 3.5 - Entrada e saída
      • 3.6 - O que são funções
      • 3.7 - Refatoração: \n
      • 3.8 - Interpretador ou compilador
      • 3.9 - Resumindo
    • 4 - Controle de fluxo
      • 4.1 - Mas e se... if e else
      • 4.2 - Code smell: comentários
      • 4.3 - Condições aninhadas (nested ifs)
      • 4.4 - Code smell: copy e paste
      • 4.5 - O laço for (loop)
      • 4.6 - Aplicando o laço for ao nosso programa
      • 4.7 - Code smell: Magic numbers
      • 4.8 - Refatoração: extrair variável
      • 4.9 - Quebrando o laço com o break
      • 4.10 - Resumindo
    • 5 - Funções
      • 5.1 - Funções
      • 5.2 - Boa prática: encapsulamento de comportamento
      • 5.3 - Escopo de variáveis
      • 5.4 - Code smell: variáveis sem controle de escopo e variáveis globais
      • 5.5 - Retorno de função
      • 5.6 - Variáveis locais
      • 5.7 - Extraindo mais uma função
      • 5.8 - Boa prática: early return
      • 5.9 - Pequenas refatorações específicas da linguagem
      • 5.10 - Resumindo: o poder da extração de código
      • 5.11 - Resumindo
    • 6 - Arrays
      • 6.1 - Criando e manipulando arrays
      • 6.2 - Aplicando o array ao nosso jogo
      • 6.3 - Facilidades de um array
      • 6.4 - Simplificando nosso código de array
      • 6.5 - Arrays e Strings
      • 6.6 - Interpolação de Strings
      • 6.7 - Funções e métodos
      • 6.8 - Testando métodos no IRB
      • 6.9 - Resumindo
    • 7 - Pontos e matemática
      • 7.1 - Ponto flutuante
      • 7.2 - Simulação do código
      • 7.3 - Matemática
      • 7.4 - Unless... e a dupla negação
      • 7.5 - Número aleatório
      • 7.6 - Operadores matemáticos
      • 7.7 - Sistema de tipos
      • 7.8 - Resumindo
    • 8 - Binário
      • 8.1 - Binário
      • 8.2 - Binário e letras
      • 8.3 - Bits: 8, 16, 32, 64
      • 8.4 - Bits e números com ponto flutuante
      • 8.5 - Hexadecimal
      • 8.6 - Bits e imagens
      • 8.7 - Resumindo
    • 9 - Nível de dificuldade e o case
      • 9.1 - Case...when...end
      • 9.2 - Escopo de variável local
      • 9.3 - Trapaceando
      • 9.4 - Corrigindo o número sorteado
      • 9.5 - While: jogando diversas vezes
      • 9.6 - loop do...end
      • 9.7 - Resumindo
    • 10 - Arte ASCII: jogo da adivinhação
      • 10.1 - Melhorando nossa interface com o usuário
    • 11 - Exercícios extras: jogo da adivinhação
      • 11.1 - Melhorando o jogo de adivinhação
      • 11.2 - Outros desafios
    • 12 - Jogo da forca
      • 12.1 - Chute de uma palavra completa e a comparação com ==
      • 12.2 - Encontrando um algoritmo
      • 12.3 - Implementando o algoritmo
      • 12.4 - Boa prática: explorando a documentação
      • 12.5 - next... Evitando chutes repetidos
      • 12.6 - Resumindo
    • 13 - Responsabilidades
      • 13.1 - Mostrando parte da palavra secreta
      • 13.2 - Separando a interface com o usuário da lógica de negócios
      • 13.3 - Extraindo a lógica de negócios
      • 13.4 - Extraindo a lógica de um chute válido
      • 13.5 - Implementação: mostrando parte da palavra secreta
      • 13.6 - Resumindo
    • 14 - Entrada e saída de arquivo: palavras aleatórias e o top player
      • 14.1 - Lendo um arquivo de palavras, nosso dicionário
      • 14.2 - Limpando a entrada de dados
      • 14.3 - Processamento e memória devem ser otimizadas?
      • 14.4 - Escrita para arquivo: o melhor jogador
      • 14.5 - Lendo o melhor jogador
      • 14.6 - Refatoração: extrair arquivo
      • 14.7 - A pilha de execução
      • 14.8 - Resumindo
    • 15 - Arte ASCII: jogo da forca
      • 15.1 - Melhorando nossa interface com o usuário
    • 16 - Exercícios extras: jogo da forca
      • 16.1 - Melhorando o jogo da forca
      • 16.2 - Outros desafios
    • 17 - Foge-foge, um jogo baseado no Pacman
      • 17.1 - Definindo a base do jogo e o mapa
      • 17.2 - Array de array: matriz
      • 17.3 - Movimento
      • 17.4 - Refatorando
      • 17.5 - O vazio, o nulo
      • 17.6 - Laço funcional básico
      • 17.7 - Extraindo a posição
      • 17.8 - Refatorando
      • 17.9 - Passagem por referência ou valor?
      • 17.10 - Detecção de colisão com o muro e o fim do mapa
      • 17.11 - Refatorando com || e &&
      • 17.12 - Duck typing na prática
      • 17.13 - for i x for linha
      • 17.14 - Resumindo
    • 18 - Botando os fantasmas para correr: arrays associativos, duck typing e outros
      • 18.1 - Array associativo: case e +1, -1
      • 18.2 - Movimento dos fantasmas: o desafio no duck typing
      • 18.3 - Movimento dos fantasmas: reutilização de função
      • 18.4 - Fantasma contra fantasma?
      • 18.5 - Resumindo
    • 19 - Matrizes e memória
      • 19.1 - Teletransportando fantasmas: cuidados a tomar com a memória
      • 19.2 - Corrigindo o teletransporte
      • 19.3 - Copiando nosso mapa
      • 19.4 - Movendo os fantasmas na matriz copiada
      • 19.5 - Refatorando o movimento do fantasma
      • 19.6 - O fantasma cavaleiro
      • 19.7 - Movimento aleatório dos fantasmas
      • 19.8 - Quando o herói perde
      • 19.9 - Retorno nulo ou opcional?
      • 19.10 - Resumindo
    • 20 - Estruturas e classes: uma introdução a Orientação a Objetos
      • 20.1 - A bagunça dos defs
      • 20.2 - Extraindo uma primeira estrutura
      • 20.3 - Usando uma estrutura
      • 20.4 - Code smell: feature envy
      • 20.5 - Boa prática: buscar quem invoca antes de refatorar
      • 20.6 - Boa prática: Tell, don't ask
      • 20.7 - Atributos e attr_accessor
      • 20.8 - Estrutura ou Classe?
      • 20.9 - A verdade por trás de métodos, funções e lambdas
      • 20.10 - Resumindo
    • 21 - Destruindo os fantasmas: o mundo da recursão
      • 21.1 - Destruindo os fantasmas
      • 21.2 - Andando para a direita
      • 21.3 - Recursão infinita
      • 21.4 - A base da recursão
      • 21.5 - Base da recursão: distância quatro ou muro
      • 21.6 - Recursão para todos os lados: busca em profundidade
      • 21.7 - Resumindo
    • 22 - Exercícios extras: jogo do foge-foge
      • 22.1 - Melhorando o Jogo do foge-foge
      • 22.2 - Outros desafios
    • 23 - Como continuar
      • 23.1 - Praticar
      • 23.2 - Estrutura de dados e algoritmos
      • 23.3 - Orientação a Objetos?
      • 23.4 - Competições de programação da ACM
      • 23.5 - Outra linguagem?
      • 23.6 - Compartilhe e boa jornada
    • 24 - Apêndice — Instalando o Ruby
      • 24.1 - Instalação no Windows
      • 24.2 - Instalação no Linux
      • 24.3 - Instalação no Mac OS X
      • 24.4 - O editor de texto

    Dados do produto

    Número de páginas:
    288
    ISBN:
    978-85-5519-016-2
    Data publicação:
    05/2015

    Compartilhe!

    Compartilhe no Facebook Compartilhe no Twitter