Algorithms
Your secret weapon to understanding--and using!--one of the most powerful influences in the world today From your Facebook News Feed to your most recent insurance premiums--even making toast!--algorithms play a role in virtually everything that happens in modern society and in your personal life. An...
| Otros Autores: | |
|---|---|
| Formato: | Libro electrónico |
| Idioma: | Inglés |
| Publicado: |
Hoboken, N.J.:
John Wiley
c2022.
Hoboken, New Jersey : [2022] |
| Edición: | Second edition |
| Colección: | --For dummies.
|
| Materias: | |
| Ver en Biblioteca Universitat Ramon Llull: | https://discovery.url.edu/permalink/34CSUC_URL/1im36ta/alma991009659942406719 |
Tabla de Contenidos:
- Intro
- Title Page
- Copyright Page
- Table of Contents
- Introduction
- About This Book
- Foolish Assumptions
- Icons Used in This Book
- Beyond the Book
- Where to Go from Here
- Part 1 Getting Started with Algorithms
- Chapter 1 Introducing Algorithms
- Describing Algorithms
- The right way to make toast: Defining algorithm uses
- Finding algorithms everywhere
- Using Computers to Solve Problems
- Getting the most out of modern CPUs and GPUs
- Working with special-purpose chips
- Networks: Sharing is more than caring
- Leveraging available data
- Distinguishing between Issues and Solutions
- Being correct and efficient
- Discovering there is no free lunch
- Adapting the strategy to the problem
- Describing algorithms in a lingua franca
- Facing problems that are like brick walls, only harder
- Structuring Data to Obtain a Solution
- Understanding a computer's point of view
- Arranging data makes the difference
- Chapter 2 Considering Algorithm Design
- Starting to Solve a Problem
- Modeling real-world problems
- Finding solutions and counterexamples
- Standing on the shoulders of giants
- Dividing and Conquering
- Avoiding brute-force solutions
- Keeping it simple, silly (KISS)
- Breaking down a problem is usually better
- Learning that Greed Can Be Good
- Applying greedy reasoning
- Reaching a good solution
- Computing Costs and Following Heuristics
- Representing the problem as a space
- Going random and being blessed by luck
- Using a heuristic and a cost function
- Evaluating Algorithms
- Simulating using abstract machines
- Getting even more abstract
- Working with functions
- Chapter 3 Working with Google Colab
- Defining Google Colab
- Understanding what Google Colab does
- Getting familiar with Google Colab features
- Working with Notebooks
- Creating a new notebook.
- Opening existing notebooks
- Saving notebooks
- Performing Common Tasks
- Creating code cells
- Creating text cells
- Creating special cells
- Editing cells
- Moving cells
- Using Hardware Acceleration
- Executing the Code
- Getting Help
- Chapter 4 Performing Essential Data Manipulations Using Python
- Performing Calculations Using Vectors and Matrixes
- Understanding scalar and vector operations
- Performing vector multiplication
- Creating a matrix is the right way to start
- Multiplying matrixes
- Defining advanced matrix operations
- Creating Combinations the Right Way
- Distinguishing permutations
- Shuffling combinations
- Facing repetitions
- Getting the Desired Results Using Recursion
- Explaining recursion
- Eliminating tail call recursion
- Performing Tasks More Quickly
- Considering divide and conquer
- Distinguishing between different possible solutions
- Chapter 5 Developing a Matrix Computation Class
- Avoiding the Use of NumPy
- Understanding Why Using a Class is Important
- Building the Basic Class
- Creating a matrix
- Printing the resulting matrix
- Accessing specific matrix elements
- Performing scalar and matrix addition
- Performing multiplication
- Manipulating the Matrix
- Transposing a matrix
- Calculating the determinant
- Flattening the matrix
- Part 2 Understanding the Need to Sort and Search
- Chapter 6 Structuring Data
- Determining the Need for Structure
- Making it easier to see the content
- Matching data from various sources
- Considering the need for remediation
- Stacking and Piling Data in Order
- Ordering in stacks
- Using queues
- Finding data using dictionaries
- Working with Trees
- Understanding the basics of trees
- Building a tree
- Representing Relations in a Graph
- Going beyond trees
- Building graphs
- Chapter 7 Arranging and Searching Data.
- Sorting Data Using Merge Sort and Quick Sort
- Understanding why sorting data is important
- Employing better sort techniques
- Using Search Trees and the Heap
- Considering the need to search effectively
- Building a binary search tree
- Performing specialized searches using a binary heap
- Relying on Hashing
- Putting everything into buckets
- Avoiding collisions
- Creating your own hash function
- Part 3 Exploring the World of Graphs
- Chapter 8 Understanding Graph Basics
- Explaining the Importance of Networks
- Considering the essence of a graph
- Finding graphs everywhere
- Showing the social side of graphs
- Understanding subgraphs
- Defining How to Draw a Graph
- Distinguishing the key attributes
- Drawing the graph
- Measuring Graph Functionality
- Counting edges and vertexes
- Computing centrality
- Putting a Graph in Numeric Format
- Adding a graph to a matrix
- Using sparse representations
- Using a list to hold a graph
- Chapter 9 Reconnecting the Dots
- Traversing a Graph Efficiently
- Creating the graph
- Applying breadth-first search
- Applying depth-first search
- Determining which application to use
- Sorting the Graph Elements
- Working on Directed Acyclic Graphs (DAGs)
- Relying on topological sorting
- Reducing to a Minimum Spanning Tree
- Getting the minimum spanning tree historical context
- Working with unweighted versus weighted graphs
- Creating a minimum spanning tree example
- Discovering the correct algorithms to use
- Introducing priority queues
- Leveraging Prim's algorithm
- Testing Kruskal's algorithm
- Determining which algorithm works best
- Finding the Shortest Route
- Defining what it means to find the shortest path
- Adding a negative edge
- Explaining Dijkstra's algorithm
- Explaining the Bellman-Ford algorithm
- Explaining the Floyd-Warshall algorithm.
- Chapter 10 Discovering Graph Secrets
- Envisioning Social Networks as Graphs
- Clustering networks in groups
- Discovering communities
- Navigating a Graph
- Counting the degrees of separation
- Walking a graph randomly
- Chapter 11 Getting the Right Web page
- Finding the World in a Search Engine
- Searching the Internet for data
- Considering how to find the right data
- Explaining the PageRank Algorithm
- Understanding the reasoning behind the PageRank algorithm
- Explaining the nuts and bolts of PageRank
- Implementing PageRank
- Implementing a Python script
- Struggling with a naive implementation
- Introducing boredom and teleporting
- Looking inside the life of a search engine
- Considering other uses of PageRank
- Going Beyond the PageRank Paradigm
- Introducing semantic queries
- Using AI for ranking search results
- Part 4 Wrangling Big Data
- Chapter 12 Managing Big Data
- Transforming Power into Data
- Understanding Moore's implications
- Finding data everywhere
- Getting algorithms into business
- Streaming Flows of Data
- Analyzing streams with the right recipe
- Reserving the right data
- Sketching an Answer from Stream Data
- Filtering stream elements by heart
- Demonstrating the Bloom filter
- Finding the number of distinct elements
- Learning to count objects in a stream
- Chapter 13 Parallelizing Operations
- Managing Immense Amounts of Data
- Understanding the parallel paradigm
- Distributing files and operations
- Employing the MapReduce solution
- Working Out Algorithms for MapReduce
- Setting up a MapReduce simulation
- Inquiring by mapping
- Chapter 14 Compressing and Concealing Data
- Making Data Smaller
- Understanding encoding
- Considering the effects of compression
- Choosing a particular kind of compression
- Choosing your encoding wisely.
- Encoding using Huffman compression
- Remembering sequences with LZW
- Hiding Your Secrets with Cryptography
- Substituting characters
- Working with AES encryption
- Part 5 Challenging Difficult Problems
- Chapter 15 Working with Greedy Algorithms
- Deciding When It Is Better to Be Greedy
- Understanding why greedy is good
- Keeping greedy algorithms under control
- Considering NP complete problems
- Finding Out How Greedy Can Be Useful
- Arranging cached computer data
- Competing for resources
- Revisiting Huffman coding
- Chapter 16 Relying on Dynamic Programming
- Explaining Dynamic Programming
- Obtaining a historical basis
- Making problems dynamic
- Casting recursion dynamically
- Leveraging memoization
- Discovering the Best Dynamic Recipes
- Looking inside the knapsack
- Touring around cities
- Approximating string search
- Chapter 17 Using Randomized Algorithms
- Defining How Randomization Works
- Considering why randomization is needed
- Understanding how probability works
- Understanding distributions
- Simulating the use of the Monte Carlo method
- Putting Randomness into your Logic
- Calculating a median using quick select
- Doing simulations using Monte Carlo
- Ordering faster with quick sort
- Chapter 18 Performing Local Search
- Understanding Local Search
- Knowing the neighborhood
- Presenting local search tricks
- Explaining hill climbing with n-queens
- Discovering simulated annealing
- Avoiding repeats using Tabu Search
- Solving Satisfiability of Boolean Circuits
- Solving 2-SAT using randomization
- Implementing the Python code
- Realizing that the starting point is important
- Chapter 19 Employing Linear Programming
- Using Linear Functions as a Tool
- Grasping the basic math you need
- Learning to simplify when planning
- Working with geometry using simplex.
- Understanding the limitations.
