Back Matter

Search in book...
Toggle Font Controls
Create new playlist

Name your new playlist

Playlist description (optional)
Sign In

Email address

Password

Forgot Password?

or

Continue with Facebook

Continue with Google
Sign Up

Full Name

Email address

Confirm Email Address

Password

or

Continue with Facebook

Continue with Google

Previous Chapter

Short Introduction to Python 3.10

Bibliography

[ALP16] Adnan Aziz, Tsung-Hsien Lee, and Amit Prakash, Elements Of Programming Interviews in Python (CreateSpace Independent Publishing Platform, 2016).
[Bad17] Dan Bader, Python Tricks: A Buffet of Awesome Python Features (Dan Bader, 2017).
[Bha16] Aditya Y. Bhargava, Grokking Algorithms (Manning, 2016).
[Ind20] Michael Inden, Der Weg zum Java-Profi 5th edition (dpunkt.verlag, 2020).
[Jai19] Hemant Jain, Problem Solving in Data Structures and Algorithms Using Python 2nd edition (2019).
[McD16] Gayle Laakmann McDowell, Cracking the Coding Interview 6th edition (CareerCup, 2016).
[MKG18] John Mongan, Noah Kindler, and Eric Giguère, Programming Interviews Exposed 4th edition (Wrox, 2018).
[MW19] Alex Miller and Lawrence Wu, Daily Coding Problem (2019).
[Okk17] Brian Okken, Python Testing with pytest: Simple, Rapid, Effective, and Scalable (O’Reilly, 2017).
[Oli18] Bruno Oliveira, pytest Quick Start Guide: Write better Python code with simple and maintainable tests (Packt Publishing, 2018).
[Pre00] Bruno R. Preiss, Data Structures and Algorithms with Object-Oriented Design Patterns in Java (Wiley, 2000).
[Sed92] Robert Sedgewick, Algorithmen (Addison-Wesley, 1992).
[Sed11] Robert Sedgewick, Algorithms 4th edition (Addison Wesley, 2011).
[Urb18] Matthew Urban, Top 30 Java Interview Coding Tasks (net-boss, 2018).
[vH16] Rick van Hattern, Mastering Python. (Packt Publishing, 2016).
[Wei10] Mark Allen Weiss, Data Structures and Problem Solving Using Java 4th edition (Pearson, 2010).
[Wen17] Jay Wengrow, A Common-Sense Guide to Data Structures and Algorithms (The Pragmatic Programmers, 2017).

Index

Abstract syntax tree (AST)

Arrays

add_one(digits)

algorithm

data structure

verification

building blocks

erase diamonds

algorithm

erase_chains(values2dim)

erases

fall_down(values2dim) 301

falling down

helper functions

implementation

modification

preliminary considerations

solution

verification

errors

even/odd numbers

algorithm

helper functions

implementation

less copying

optimization

solution

variation

verification

features

flip

horizontal flipping algorithm

implementation

limitation

modification

optimization

solution

verification

vertical flipping mode

flood filling process

algorithm

filling process

pattern specification

solution

verification

generalizations

inplace rotation

algorithm

helper variables

innermost level

inwards

iterative

outer layer

procedure layer

recursive

verification

jewels board init

check validation

diagonals

get_dimension() function

graphical representation

initialization

little source code vs. small method

validity check

verification

minimum and maximum

algorithm

helper functions

implementation

solution

verification

multidimensional array

NumPy

one-dimensional

SeeOne-dimensional arrays

palindrome

advantage

algorithm

is_palindrome(values) function

iterative variant

Python shortcut

solution

unit testing

verification

split

algorithm

arbitrary integers

inplace

inplace function

lists

Pythonic algorithm

quick sort partition

Quick Sort variants

sorting partition

verification

Backtracking

n-Queens problem

Sudoku solver

Binary trees/binary search trees (BST)

ASCII output

BinaryTreeNode class

breadth-first search

algorithm

implementation

level-order

verification

checking process

algorithm

solution

verification

completeness

full/perfect checking

implementation

nodes

recursive

solution

verification

inorder/preorder/postorder

inorder solution

insight

iterative implementations

postorder

preorder

surprise algorithm

verification

insertion

integers

letters/numbers

level sum

algorithm

implementation

solution

verification

math evaluation

algorithm

implementation

solution

verification

meaning

mirroring tree

node/edges

postorder

printer

connecting lines

drawing node

implementation

representation

solution

tree width

problematic insertion order

properties

completeness/perfectness

level and height

rotation

reconstruction

algorithm

lists

preorder and inorder

verification

rotation

algorithm

implementation

nodes

preliminary considerations

solution

verification

structure storage/terminology

supplementary literature

symmetry

algorithm

imaginary vertical line

mirror tree

solution

verification

symmetry property

textual/real digits

traversals

breadth-first/depth-first searches

depth-first search methods

level order/breadth-first

tree height

algorithm

implementation

solution

verification

tree representation

algorithm

helper functions

memory optimization

solution

spacing node

verification

utility module

Bucket sort algorithm

solution

verification

Container classes

Data structure

braces

algorithm

enumeration

solution

verification

check magic triangle

algorithm

intermediate inspection

problem solving strategies

solution

verification

common elements

algorithm

matching functions

Python shortcut

solution

stack class

verification

digits

addition

inverse

safe_get_at() function

verification

ZIP() method

Excel magic select

SeeExcel magic select

FIFO

SeeFirst In, First Out (FIFO)

frequent elements

algorithm

histogram

solution

verification

list merge

algorithm

implementation

Python shortcut

solution

verification

list reverse

algorithm

elements

inplace

order inplace

performant random index

Python shortcut

random index access

reverse() function

verification

longest sequence

greedy algorithm

mini optimization

modeling stock prices/altitudes

optimized algorithm

solution

verification

magic triangle

maximum profit

algorithm

max_revenue(prices) function

solution

verification

Pascal’s triangle

algorithm

representation

solution

verification

remove duplication

algorithm

Python shortcut

remove_duplicates(values)

solution

verification

stack class

algorithm

requirements

StackIsEmptyException

verification

visibilities

stack/queue

algorithm

check procedures

implementation

solution

verification

well-formed braces

Data structures, supplementary literature

Decorators

argument checks

checking multiple parameters

explicit checks

functools module

logging function calls/parameter passing

syntactic sugar

wrapped function

Excel magic selection

algorithm

implementation

modification

Python shortcut

solution

verification

First In, First Out (FIFO)

elements

emulate stack and queue

implementation

G, H, I, J, K

Greatest common divisor (GCD)

Last-In-First-Out (LIFO)

Least common multiplier (LCM)

LIFO data structure

Lists/sets/key-value mappings (dictionaries)

Lowest common ancestor (LCA)

algorithm

solution

verification

Mathematical operations

arithmetic operations

algorithm

blank lines

built-in function

even/odd number

function

statistics

verification

Armstrong numbers

algorithm

equation

formulas

generic version

verification

checksum

algorithm

calculation

verification

combinatorics

algorithm

computation

Python shortcut

solve_quadratic() function

transformation

verification

decimal number

divider

lambda expressions

functional programming

len() method

sort() method

syntax

max change calculator

algorithm

coins/numbers

maximum value

verification

modulo operation (%)/division

number_as_text(n)

number games

pair prime numbers

algorithm

optimization

principles

program structure

results

verification

perfect number

prime factorization

algorithm

multiplication

optimized algorithm

solution

verification

prime numbers

algorithm

Python shortcut

results

verification

related numbers

algorithm

calc_friends(max_exclusive)

equations

verification

roman numbers

algorithm

decimal numbers

verification

roman numeral system

Sieve of Eratosthenes

supplementary literature

text numbers

Memoization

edit distances

Fibonacci numbers

Pascal’s triangle

pure functions

Python on-board tools

cross-cutting concern

decorator

disadvantages

LRU cache

Pascal’s triangle

techniques

recursive implementation

Merge Sort

Minesweeper board

algorithm

artificial border

bombs

calc_bomb_count(bombs)

initialization

place_bombs_randomly()

position-based processing

print_board()

solution

verification

Multidimensional arrays

accessing values

definition

get_dimension(values) function

implementation

is_on_board()

modeling directions

np.empty()

print()

Python command line

random numbers

rotations

strings conversion

variation

n-Queens problem

algorithm

approach

diagonals

get_dimension()

helper function

implementation

queens

solution

task implementation

verification

Numerical Python (NumPy)

advantage

comprehensions

functionalities

getsizeof() function

index based access

lists

matrix multiplication

memory consumption

particular value

performance comparison

recapitulation

One-dimensional arrays

enumerate() function

functionality

interim

optimization

problem-solving strategies

readability/comprehensibility

remove duplication

rotation

sorted input

swapping elements

textual output

tuple assignment

unsorted/arbitrary numbers

O-notation

algorithms

complexity classes, binary search

definition

estimations

input data

normal instructions

sorting algorithms

time complexities

Palindrome property

algorithm

iterative variant

optimized algorithm

position pointers

recursive variant

Programming style

block comments

count_substrings() function

decorators and sanity checks

information

PEP 8 coding standard

recursive termination and descent

source code compactness

Zen

PyCharm project

pip tool

sources

tests

utility functions

pytest

handle expected exceptions

installation

parameterized test

collection literals

source code

test execution

console

HTML representation

IDE PyCharm

unit test

Python

checks

project sources

shortcut

solution

tooling

Zen

Python 3.10

case distinctions

pipe operator (|)

combination

match

matching patterns and conditions

Python 3.9.x

wildcard case

context managers

error messages

assignment (=)

possibilities

string

type checks

zip() extension

Quick sort

Recursion

backtracking

edit distance

algorithm

case-insensitive

memoization

modifications

performance test

verification

Labyrinth

advantages

algorithm

implementation

solution

verification

longest common subsequence

algorithm

implementation

memoization

modification

performance test

solution

verification

math operator checker

algorithm

combinations

verification

memorization

SeeMemoization

n-Queens problem

implementation

solution

palindromes

algorithm

longest substrings

LOTTOL

step-by-step procedure

strings

subproblems

substrings

verification

Sudoku solver

algorithm

auxiliary function

backtracking problems

checking modification

clever testing

digits

implementation

reasonable optimizations

solve_sudoku(board)

valid solution

verification

supplementary literature

Towers of Hanoi problem

algorithm

execution

graphical format

recursion

solution

task definition

verification

water jug problem

algorithm

implementation

solution

verification

Recursive functions

algorithmic tasks

draw_snowflake()

fractal implementation

iterative variant

palindrome property

stylized representation

complexity reduction

conversion

algorithm

octal and hexadecimal numbers

optimization

to_binary(n)

verification

count_substrings

implementation

optimization

solution

variation

verification

endless calls/stack frame

exponential function

exponentiation

is_power_of_2(n)

iterative version

power_of(value, exponent)

verification

Fibonacci numbers

iterative

mathematical definition

optimization

recursive

value progression

verification

GCD

iterative version

LCM

natural numbers

solution

verification

iterative

mathematical operation

calculation formula

clarification

restricted call depth

factorial

Fibonacci numbers

Python shortcut

sum of numbers (n)

tail-recursive

min_rec(values)

multiplication

number palindromes

solution

string functionalities

verification

Pascal’s triangle

permutations

computation

solution

process digits

count_digits(value)

cross sum

divmod() function

built-in function len()

sanity checks

verification

RecursionError

reverse string

algorithm

reverse_string(text)

verification

ruler

draw_interval() function

draw_ruler() function

solution

verification

sum_rec(values)

algorithm

solution

verification

termination condition

Search/sorting algorithm

binary search

iterative

recursive

recursive function

verification

bucket sort algorithm

implementation

solution

verification

contains all

algorithm

contains_all() function

Python shortcut

solution

verification

in()/index()/count()

insertion sort

implementation

solution

verification

partitioning

algorithm

solution

three letters

two letters

verification

partitioning

quick sort

implementation

solution

verification

rindex() and rfind()

rotated data

binary search

comparisons

flank change efficient

implementation

preliminary considerations

solution

verification

schematic sequence

selection sort

implementation

solution

verification

sorting

SeeSorting algorithms

supplementary literature

Sequential data types

data structure

SeeData structure

key-value mappings (dictionaries)

definition

filtering elements

functions and operations

implementation

LIFO data structure

lists

check implementation

collect_all()

comprehension

elements

improved variants

inplace variants

operations

remove_all()

operations

sets

operations

single elements

solving tasks

Slicing operations

conversion

individual characters/substrings

iteration

output

Sorting algorithms

analogy

bucket sort

comprehensibility

insertion

definition

implementation

position

stable sort

merging process

quick

copying option

inplace implementation

main()

pivot

selection

splitting algorithm

Spiral traversal

algorithm

assumption

basic procedure

generic method

procedure

results

verification

Strings

anagram

algorithm

implementation

Python shortcut

solution

verification

braces

algorithm

check_braces(text)

solution

verification

capitalization

capitalize(text)

modification

solution

special treatment variant

split() method

verification

whitespace

character sequences

conversion

algorithm

octal numbers

solution

str_to_number(text)

verification

conversions and extractions

duplicate letters

implementation

Python shortcut

solution

verification

equality

filled frame

algorithm

print_box(width, height, fillchar)

solution

verification

formatting output

functions

guessing vowels

algorithm

Python shortcut

solution

translate_vowel(text, replacement)

verification

histogram

joiner

implementation

solution

morse code

algorithm

bonus

Python/match

solution

to_morse_code(text)

verification

number conversions

binary numbers

is_binary_number(number)

solution

palindrome

algorithm

implementation

iterative solution

regular expression

solution

verification

pattern checker

algorithm

matches_pattern(pattern, text)

problem solving strategies

solution

verification

print tower

algorithm

print_tower(n)

recursion

solution

verification

processing

process single characters

remove duplication

remove_duplicates(text)

solution

verification

reverses

implementation

solution

verification

rotation

algorithm

implementation

solution

verification

slicing

SeeSlicing operations

supplementary literature

tennis score

algorithm

counting rules

solution

tennis_score() function

verification

version numbers

algorithm

compare_versions(version1, version2)

solution

verification

Structure

algorithm

examination

task structure

Sudoku checker

algorithm

bonus

puzzle

valid solution

verification

Supplementary literature

algorithms/data structures

arrays

binary trees

books

data structures

gold bags, fake detection

horse race

exclusion procedure

matrix

simplification

solution

interview

maintainability

mathematical knowledge

performance

programming puzzles

programming tasks

recursion

search/sorting algorithm

strings

unit tests

Traversing trees

algorithm

append() method

implementation

list

solution

verification

U, V, W, X, Y, Z

Unit test, Pytest

..................Content has been hidden....................

You can't read the all page of ebook, please click here login for view all page.

Table of Contents for Back Matter

Create new playlist

Sign In

Sign Up

Table of Contents for
Back Matter