Intro to Computer Programming Unit 1 Review: Programming and Algorithms Basics

Key Concepts and Terminology

• Programming involves writing instructions for computers to execute specific tasks and solve problems
• Algorithms are step-by-step procedures for solving problems or accomplishing tasks
• Variables store and manipulate data within a program
• Data types define the kind of data that can be stored in a variable (integers, floating-point numbers, characters, strings)
• Control structures determine the flow of execution in a program (conditionals, loops)
• Functions are reusable blocks of code that perform specific tasks
• Modular programming breaks down complex problems into smaller, manageable parts
• Debugging is the process of identifying and fixing errors in code

Programming Fundamentals

• Programming languages provide a way to communicate instructions to computers
  • High-level languages (Python, Java) are easier for humans to read and write
  • Low-level languages (Assembly, Machine Code) are closer to the computer's native language
• Syntax refers to the rules and structure of a programming language
• Semantics describe the meaning and behavior of programming constructs
• Compilers translate high-level language code into machine-readable instructions
• Interpreters execute code line by line without prior compilation
• Integrated Development Environments (IDEs) provide tools for writing, debugging, and running code
• Version control systems (Git) help manage changes to code over time

Basic Data Types and Variables

• Variables are named containers for storing data
  • Variable names should be descriptive and follow naming conventions (camelCase, snake_case)
  • Variables must be declared with a specific data type before use
• Primitive data types include integers (whole numbers), floating-point numbers (decimals), characters (single letters or symbols), and booleans (true/false)
• Composite data types include arrays (ordered collections of elements) and structs (user-defined data structures)
• Type conversion allows changing the data type of a variable (explicit or implicit)
• Constants are variables whose values cannot be modified after initialization
• Operators perform operations on variables and values (+, -, *, /, %, ==, !=, <, >)

Control Structures and Logic

• Conditional statements execute code based on whether a condition is true or false
  • If statements execute a block of code if a condition is true
  • Else statements provide an alternative block of code to execute if the condition is false
  • Else if statements allow testing multiple conditions in sequence
• Loops repeatedly execute a block of code until a condition is met
  • For loops iterate over a sequence (array, range of numbers) for a fixed number of times
  • While loops execute as long as a condition remains true
  • Do-while loops always execute at least once before checking the condition
• Logical operators combine conditions (AND (&&), OR (||), NOT (!))
• Switch statements provide a way to test a variable against multiple possible values

Functions and Modular Programming

• Functions are reusable blocks of code that perform specific tasks
  • Function declarations define the function name, parameters, and return type
  • Function calls execute the code within a function
• Parameters are variables that receive values when a function is called
• Return statements specify the value a function should output when it completes
• Scope refers to the visibility and accessibility of variables within a program
  • Local variables are only accessible within the function or block where they are declared
  • Global variables can be accessed from anywhere in the program
• Recursion occurs when a function calls itself to solve a problem by breaking it down into smaller subproblems

Introduction to Algorithms

• Algorithms are step-by-step procedures for solving problems or accomplishing tasks
• Pseudocode is a high-level, informal description of an algorithm using plain language
• Flowcharts visually represent the steps and decision points in an algorithm
• Time complexity measures how the running time of an algorithm increases with input size (Big O notation)
• Space complexity measures how the memory usage of an algorithm increases with input size
• Searching algorithms find specific elements within a data structure (linear search, binary search)
• Sorting algorithms arrange elements in a specific order (bubble sort, insertion sort, merge sort)

Common Programming Patterns

• Iteration patterns involve repeating a process until a condition is met
  • Counting loops repeat a fixed number of times
  • Sentinel loops continue until a specific value (sentinel) is encountered
• Accumulator patterns keep a running total or product of values
• Filtering patterns select elements from a collection based on specific criteria
• Mapping patterns transform elements from one representation to another
• Reduction patterns combine elements of a collection into a single value (sum, product, maximum)
• Recursion patterns solve problems by breaking them down into smaller subproblems
  • Divide-and-conquer algorithms (merge sort, quicksort) recursively divide problems into smaller instances

Debugging and Problem-Solving Techniques

• Debugging is the process of identifying and fixing errors in code
  • Syntax errors occur when code violates the rules of the programming language
  • Runtime errors occur during program execution (division by zero, accessing an array out of bounds)
  • Logical errors produce unexpected results due to flaws in the algorithm or implementation
• Print statements can help track the values of variables at different points in the program
• Breakpoints allow pausing program execution at specific lines of code to inspect variables and program state
• Rubber duck debugging involves explaining code line by line to an inanimate object to clarify thinking and identify issues
• Problem-solving strategies include:
  • Breaking down problems into smaller, manageable parts
  • Identifying patterns and similarities to previously solved problems
  • Considering edge cases and boundary conditions
  • Collaborating with others and seeking feedback on proposed solutions