OCW Scholar: Introduction to Computer Science and Programming

In this recitation, the class wraps up with dynamic programming and specifically the technique of memoization. Many code examples are presented to show all the applications of this technique.

This optional recitation reviews algorithm complexity and object-oriented programming in great detail with a focus on big O notation.

In this review session the solution to practice quiz 2 are presented in detail, and the main topics of unit 2 (on the quiz 2 topics sheet) as well as some technical topics are explained with some code examples.

This recitation reviews the details of directed and undirected node graphs as well as explaining the difference between depth-first search and breath-first search with an extensive explanation of the code involved in graph creation and the search methods

This recitation reviews hierarchical and kmeans clustering in great detail with many different code examples. It also discusses the merits and disadvantages of both clustering and how to calculate error.

This recitation video covers some basic probability and statistics, as well as simulation methods for estimating unknown probabilites. Includes worked examples, probability distributions, mean and standard deviation, and plotting graphs in Python.

This recitation discusses different types of data distributions, Monte Carlo simulations and data curve regressions in great detail and is heavy in code examples and explanations.

This recitation goes over the answers to Quiz 1 and introduces object-oriented programming (classes) in comparison to types.

This recitation covers lists, list elements, and a discussion of sorting techniques. Introduces recursion, base cases, and simplifying problems.

This recitation further explains recursion, pseudo code and debugging with several examples. The recitation also talks about optional parameters and floating point comparisons and float's representation in python.

This recitation reviews the basics and the specifics of loops, tuples, strings, and functions in detail.

This recitation covers an introduction to what coding is, how the computer executes code, and to simple coding constructs, including syntax, semantics, object types, if statements, and loops.

This lecture covers dynamic programming, optimal path, overlapping subproblems, specifications, restrictions, efficiency, and pseudo-polynomials.

This lecture covers graphs and graphing techniques in Python. Includes: pseudocode, nodes, edges, adjacency matrices, and adjacency lists.

This lecture covers clustering, include feature vectors, scaling, and k-means clustering.

In the final lecture we will discuss careers in computer science, computational thinking, abstraction, and automation.

This lecture covers queuing networks and simulations, Poisson distributions, wait time, queue length, server utilization, FIFO, LIFO, and SRPT.

This lecture discusses common statistical fallacies and how to avoid them. Topics include: statistics, plotting, correlation, causation, bias, logical fallacies, data enhancement, and the Texas sharpshooter fallacy.

This lecture continues discussion on analytical vs. simulation models for problem solving. Topics include Gaussian distributions, analytical models, simulations, exponential growth, probability, distributions, Monty Hall problem

In this lecture we continue working with simulations, covering the Monte Carlo simulation, Pascal's algorithm, inferential statistics, the gambler's fallacy, and the law of large numbers.

In this lecture we will continue our discussion of graphs and optimization. Examples include disease spread, degrees of separation, and shortest path problems.

This lecture relies heavily on probability as we continue working with simulations. We will cover stochastic methods, randomness, probability, data visualization, and plotting graphs using Python.

This lecture covers optimization techniques and clustering. Topics include: the knapsack problem, local and global optima, machine learning, training error, hierarchical clustering, k-means clustering, linkage criteria, and single vs. complete linkage.

This lecture covers optimization and algorithms, including the so-called greedy algorithms, modeling, and the 0-1 knapsack problem.

This lecture covers curve fitting, as well as arrays, the numpy function, pylab, least squares fit, and model predictions.

This lecture explains how a machine will interpret your written programs. Covers: decomposition, modules, functions, abstraction, formal and actual parameters, argument, scope, mapping, stacks, last in first out, strings, slicing.

In this lecture we will discuss statistical certainty. What are variance, standard deviation, and standard error? How can we determine the statistical significance of a result?

This lecture covers programming efficiency, problem reduction, RAM, as well as exponential growth, polynomial growth, logarithmic growth, and global variables.

This lecture covers some basics of debugging programs, including approximations and runtime errors.

This lecture discusses memory and search methods, including storage, indirection, sorting, merges.

In this lecture we will begin looking at simulations as a method of problem solving. This includes the use of the random walk model, and other analytic methods for problem solving.

This lecture covers object oriented programming, as well as abstract data types, specifications, subclasses, and inheritance.

This lecture covers the following topics: hashing, bucket, collision, linear rehash, exception, class, module, built-in class.

This lecture covers objects in python, including: tuples, lists, dictionaries, methods, identifiers, modifying objects, aliasing, mutability.

This lecture covers the following topics: dictionaries, modular abstraction, divide and conquer, recursion, tower of Hanoi, base case, Fibonacci sequence.

This lecture covers the building blocks of a program: objects, operators, variables, execution, and conditional statements. It also discusses common errors related to the topics covered.

This lecture covers problem solving in programming, including: termination, decrementing functions, exhaustive enumeration, brute force, while and for loops, approximation, specifications, bisection search.

This lecture covers course expectations, introduces computer programming and its uses, and begins to familiarize the student with concepts related to how programs work.