programming assignment programming problems for module 1

Instantly share code, notes, and snippets.

sirenko / Data Structures and Algorithms-Coursera.org

• Download ZIP
• Star 3 You must be signed in to star a gist
• Fork 1 You must be signed in to fork a gist
• Embed Embed this gist in your website.
• Share Copy sharable link for this gist.
• Clone via HTTPS Clone using the web URL.
• Learn more about clone URLs
• Save sirenko/795c2aa60484d148780e4629750cfa0b to your computer and use it in GitHub Desktop.

Data Structures and Algorithms | UC San Diego

Data structures and algorithms specialization, master algorithmic programming techniques. learn algorithms through programming and advance your software engineering or data science career.

About This Specialization

This specialization is a mix of theory and practice: you will learn algorithmic techniques for solving various computational problems and will implement about 100 algorithmic coding problems in a programming language of your choice. No other online course in Algorithms even comes close to offering you a wealth of programming challenges that you may face at your next job interview. To prepare you, we invested over 3000 hours into designing our challenges as an alternative to multiple choice questions that you usually find in MOOCs. Sorry, we do not believe in multiple choice questions when it comes to learning algorithms…or anything else in computer science! For each algorithm you develop and implement, we designed multiple tests to check its correctness and running time — you will have to debug your programs without even knowing what these tests are! It may sound difficult, but we believe it is the only way to truly understand how the algorithms work and to master the art of programming. The specialization contains two real-world projects: Big Networks and Genome Assembly . You will analyze both road networks and social networks and will learn how to compute the shortest route between New York and San Francisco (1000 times faster than the standard shortest path algorithms!) Afterwards, you will learn how to assemble genomes from millions of short fragments of DNA and how assembly algorithms fuel recent developments in personalized medicine.

COURSE 1 - Algorithmic Toolbox

Current session: Jan 15

The course covers basic algorithmic techniques and ideas for computational problems arising frequently in practical applications: sorting and searching, divide and conquer, greedy algorithms, dynamic programming. We will learn a lot of theory: how to sort data and how it helps for searching; how to break a large problem into pieces and solve them recursively; when it makes sense to proceed greedily; how dynamic programming is used in genomic studies. You will practice solving computational problems, designing new algorithms, and implementing solutions efficiently (so that they run in less than a second).

WEEK 1 - Programming Challenges

Welcome to the first module of Data Structures and Algorithms! Here we will provide an overview of where algorithms and data structures are used (hint: everywhere) and walk you through a few sample programming challenges. The programming challenges represent an important (and often the most difficult!) part of this specialization because the only way to fully understand an algorithm is to implement it. Writing correct and efficient programs is hard; please don’t be surprised if they don’t work as you planned—our first programs did not work either! We will help you on your journey through the specialization by showing how to implement your first programming challenges. We will also introduce testing techniques that will help increase your chances of passing assignments on your first attempt. In case your program does not work as intended, we will show how to fix it, even if you don’t yet know which test your implementation is failing on.

• Video · Welcome!
• Programming Assignment · Programming Assignment 1: Programming Challenges
• Practice Quiz · Solving Programming Challenges
• Reading · Optional Videos and Screencasts
• Video · Solving the Sum of Two Digits Programming Challenges (screencast)
• Video · Solving the Maximum Pairwise Product Programming Challenge: Improving the Naive Solution, Testing, Debugging
• Video · Stress Test - Implementation
• Video · Stress Test - Find the Test and Debug
• Video · Stress Test - More Testing, Submit and Pass!
• Reading · Acknowledgements

WEEK 2 - Algorithmic Warm-up

In this module you will learn that programs based on efficient algorithms can solve the same problem billions of times faster than programs based on naïve algorithms. You will learn how to estimate the running time and memory of an algorithm without even implementing it. Armed with this knowledge, you will be able to compare various algorithms, select the most efficient ones, and finally implement them as our programming challenges!

• Video · Why Study Algorithms?
• Video · Coming Up
• Video · Problem Overview
• Video · Naive Algorithm
• Video · Efficient Algorithm
• Reading · Resources
• Video · Problem Overview and Naive Algorithm
• Video · Computing Runtimes
• Video · Asymptotic Notation
• Video · Big-O Notation
• Video · Using Big-O
• Practice Quiz · Logarithms
• Practice Quiz · Big-O
• Practice Quiz · Growth rate
• Video · Course Overview
• Programming Assignment · Programming Assignment 2: Algorithmic Warm-up

WEEK 3 - Greedy Algorithms

In this module you will learn about seemingly naïve yet powerful class of algorithms called greedy algorithms. After you will learn the key idea behind the greedy algorithms, you may feel that they represent the algorithmic Swiss army knife that can be applied to solve nearly all programming challenges in this course. But be warned: with a few exceptions that we will cover, this intuitive idea rarely works in practice! For this reason, it is important to prove that a greedy algorithm always produces an optimal solution before using this algorithm. In the end of this module, we will test your intuition and taste for greedy algorithms by offering several programming challenges.

• Video · Largest Number
• Video · Car Fueling
• Video · Car Fueling - Implementation and Analysis
• Video · Main Ingredients of Greedy Algorithms
• Practice Quiz · Greedy Algorithms
• Video · Celebration Party Problem
• Video · Efficient Algorithm for Grouping Children
• Video · Analysis and Implementation of the Efficient Algorithm
• Video · Long Hike
• Video · Fractional Knapsack - Implementation, Analysis and Optimization
• Video · Review of Greedy Algorithms
• Practice Quiz · Fractional Knapsack
• Programming Assignment · Programming Assignment 3: Greedy Algorithms

WEEK 4 - Divide-and-Conquer

In this module you will learn about a powerful algorithmic technique called Divide and Conquer. Based on this technique, you will see how to search huge databases millions of times faster than using naïve linear search. You will even learn that the standard way to multiply numbers (that you learned in the grade school) is far from the being the fastest! We will then apply the divide-and-conquer technique to design two efficient algorithms (merge sort and quick sort) for sorting huge lists, a problem that finds many applications in practice. Finally, we will show that these two algorithms are optimal, that is, no algorithm can sort faster!

• Video · Intro
• Video · Linear Search
• Video · Binary Search
• Video · Binary Search Runtime
• Practice Quiz · Linear Search and Binary Search
• Video · Problem Overview and Naïve Solution
• Video · Naïve Divide and Conquer Algorithm
• Video · Faster Divide and Conquer Algorithm
• Practice Quiz · Polynomial Multiplication
• Video · What is the Master Theorem?
• Video · Proof of the Master Theorem
• Practice Quiz · Master Theorem
• Video · Selection Sort
• Video · Merge Sort
• Video · Lower Bound for Comparison Based Sorting
• Video · Non-Comparison Based Sorting Algorithms
• Practice Quiz · Sorting
• Video · Overview
• Video · Algorithm
• Video · Random Pivot
• Video · Running Time Analysis (optional)
• Video · Equal Elements
• Video · Final Remarks
• Practice Quiz · Quick Sort
• Programming Assignment · Programming Assignment 4: Divide and Conquer

WEEK 5 - Dynamic Programming 1

In this final module of the course you will learn about the powerful algorithmic technique for solving many optimization problems called Dynamic Programming. It turned out that dynamic programming can solve many problems that evade all attempts to solve them using greedy or divide-and-conquer strategy. There are countless applications of dynamic programming in practice: from maximizing the advertisement revenue of a TV station, to search for similar Internet pages, to gene finding (the problem where biologists need to find the minimum number of mutations to transform one gene into another). You will learn how the same idea helps to automatically make spelling corrections and to show the differences between two versions of the same text.

• Video · Change Problem
• Practice Quiz · Change Money
• Video · The Alignment Game
• Video · Computing Edit Distance
• Video · Reconstructing an Optimal Alignment
• Practice Quiz · Edit Distance
• Programming Assignment · Programming Assignment 5: Dynamic

Programming 1

WEEK 6 - Dynamic Programming 2

In this module, we continue practicing implementing dynamic programming solutions.

• Practice Quiz · Knapsack
• Video · Knapsack with Repetitions
• Video · Knapsack without Repetitions
• Practice Quiz · Maximum Value of an Arithmetic Expression
• Video · Subproblems
• Video · Reconstructing a Solution
• Programming Assignment · Programming Assignment 6: Dynamic

Programming 2

COURSE 2 - Data Structures

Week 1 - basic data structures.

In this module, you will learn about the basic data structures used throughout the rest of this course. We start this module by looking in detail at the fundamental building blocks: arrays and linked lists. From there, we build up two important data structures: stacks and queues. Next, we look at trees: examples of how they’re used in Computer Science, how they’re implemented, and the various ways they can be traversed. Once you’ve completed this module, you will be able to implement any of these data structures, as well as have a solid understanding of the costs of the operations, as well as the tradeoffs involved in using each data structure.

• Reading · Welcome
• Video · Arrays
• Video · Singly-Linked Lists
• Video · Doubly-Linked Lists
• Reading · Slides and External References
• Video · Stacks
• Video · Queues
• Video · Trees
• Video · Tree Traversal
• Practice Quiz · Basic Data Structures
• Reading · Available Programming Languages
• Reading · FAQ on Programming Assignments
• Programming Assignment · Programming Assignment 1: Basic Data Structures

WEEK 2 - Dynamic Arrays and Amortized Analysis

In this module, we discuss Dynamic Arrays: a way of using arrays when it is unknown ahead-of-time how many elements will be needed. Here, we also discuss amortized analysis: a method of determining the amortized cost of an operation over a sequence of operations. Amortized analysis is very often used to analyse performance of algorithms when the straightforward analysis produces unsatisfactory results, but amortized analysis helps to show that the algorithm is actually efficient. It is used both for Dynamic Arrays analysis and will also be used in the end of this course to analyze Splay trees.

• Video · Dynamic Arrays
• Video · Amortized Analysis: Aggregate Method
• Video · Amortized Analysis: Banker’s Method
• Video · Amortized Analysis: Physicist’s Method
• Video · Amortized Analysis: Summary
• Quiz · Dynamic Arrays and Amortized Analysis

WEEK 3 - Priority Queues and Disjoint Sets

We start this module by considering priority queues which are used to efficiently schedule jobs, either in the context of a computer operating system or in real life, to sort huge files, which is the most important building block for any Big Data processing algorithm, and to efficiently compute shortest paths in graphs, which is a topic we will cover in our next course. For this reason, priority queues have built-in implementations in many programming languages, including C++, Java, and Python. We will see that these implementations are based on a beautiful idea of storing a complete binary tree in an array that allows to implement all priority queue methods in just few lines of code. We will then switch to disjoint sets data structure that is used, for example, in dynamic graph connectivity and image processing. We will see again how simple and natural ideas lead to an implementation that is both easy to code and very efficient. By completing this module, you will be able to implement both these data structures efficiently from scratch.

• Video · Introduction
• Video · Naive Implementations of Priority Queues
• Reading · Slides
• Video · Binary Trees
• Reading · Tree Height Remark
• Video · Basic Operations
• Video · Complete Binary Trees
• Video · Pseudocode
• Video · Heap Sort
• Video · Building a Heap
• Quiz · Priority Queues: Quiz
• Video · Naive Implementations
• Video · Trees for Disjoint Sets
• Video · Union by Rank
• Video · Path Compression
• Video · Analysis (Optional)
• Quiz · Quiz: Disjoint Sets
• Practice Quiz · Priority Queues and Disjoint Sets
• Programming Assignment · Programming Assignment 2: Priority Queues and Disjoint Sets

WEEK 4 - Hash Tables

In this module you will learn about very powerful and widely used technique called hashing. Its applications include implementation of programming languages, file systems, pattern search, distributed key-value storage and many more. You will learn how to implement data structures to store and modify sets of objects and mappings from one type of objects to another one. You will see that naive implementations either consume huge amount of memory or are slow, and then you will learn to implement hash tables that use linear memory and work in O(1) on average! In the end, you will learn how hash functions are used in modern disrtibuted systems and how they are used to optimize storage of services like Dropbox, Google Drive and Yandex Disk!

• Video · Applications of Hashing
• Video · Analysing Service Access Logs
• Video · Direct Addressing
• Video · List-based Mapping
• Video · Hash Functions
• Video · Chaining Scheme
• Video · Chaining Implementation and Analysis
• Video · Hash Tables
• Video · Phone Book Problem
• Video · Phone Book Problem - Continued
• Video · Universal Family
• Video · Hashing Integers
• Video · Proof: Upper Bound for Chain Length (Optional)
• Video · Proof: Universal Family for Integers (Optional)
• Video · Hashing Strings
• Video · Hashing Strings - Cardinality Fix
• Quiz · Hash Tables and Hash Functions
• Video · Search Pattern in Text
• Video · Rabin-Karp’s Algorithm
• Video · Optimization: Precomputation
• Video · Optimization: Implementation and Analysis
• Video · Instant Uploads and Storage Optimization in Dropbox
• Video · Distributed Hash Tables
• Practice Quiz · Hashing
• Programming Assignment · Programming Assignment 3: Hash Tables

WEEK 5 - Binary Search Trees

In this module we study binary search trees, which are a data structure for doing searches on dynamically changing ordered sets. You will learn about many of the difficulties in accomplishing this task and the ways in which we can overcome them. In order to do this you will need to learn the basic structure of binary search trees, how to insert and delete without destroying this structure, and how to ensure that the tree remains balanced.

• Video · Search Trees
• Video · Balance
• Video · AVL Trees
• Video · AVL Tree Implementation
• Video · Split and Merge
• Practice Quiz · Binary Search Trees

WEEK 6 - Binary Search Trees 2

In this module we continue studying binary search trees. We study a few non-trivial applications. We then study the new kind of balanced search trees - Splay Trees. They adapt to the queries dynamically and are optimal in many ways.

• Video · Applications
• Video · Splay Trees: Introduction
• Video · Splay Trees: Implementation
• Video · (Optional) Splay Trees: Analysis
• Practice Quiz · Splay Trees
• Programming Assignment · Programming Assignment 4: Binary Search Trees

COURSE 3 - Algorithms on Graphs

Week 1 - decomposition of graphs 1.

Graphs arise in various real-world situations as there are road networks, computer networks and, most recently, social networks! If you’re looking for the fastest time to get to work, cheapest way to connect set of computers into a network or efficient algorithm to automatically find communities and opinion leaders hot in Facebook, you’re going to work with graphs and algorithms on graphs. In this module, you will learn ways to represent a graph as well as basic algorithms for decomposing graphs into parts. In the programming assignment of this module, you will apply the algorithms that you’ve learned to implement efficient programs for exploring mazes, analyzing Computer Science curriculum, and analyzing road networks. In the first week of the module, we focus on undirected graphs.

• Video · Graph Basics
• Video · Representing Graphs
• Video · Exploring Graphs
• Video · Connectivity
• Video · Previsit and Postvisit Orderings
• Programming Assignment · Programming Assignment 1: Decomposition of Graphs

WEEK 2 - Decomposition of Graphs 2

This week we continue to study graph decomposition algorithms, but now for directed graphs.

• Video · Directed Acyclic Graphs
• Video · Topological Sort
• Video · Strongly Connected Components
• Video · Computing Strongly Connected Components
• Programming Assignment · Programming Assignment 2: Decomposition of Graphs

WEEK 3 - Paths in Graphs 1

In this module you will study algorithms for finding Shortest Paths in Graphs. These algorithms have lots of applications. When you launch a navigation app on your smartphone like Google Maps or Yandex.Navi, it uses these algorithms to find you the fastest route from work to home, from home to school, etc. When you search for airplane tickets, these algorithms are used to find a route with the minimum number of plane changes. Unexpectedly, these algorithms can also be used to determine the optimal way to do currency exchange, sometimes allowing to earh huge profit! We will cover all these applications, and you will learn Breadth-First Search, Dijkstra’s Algorithm and Bellman-Ford Algorithm. These algorithms are efficient and lay the foundation for even more efficient algorithms which you will learn and implement in the Shortest Paths Capstone Project to find best routes on real maps of cities and countries, find distances between people in Social Networks. In the end you will be able to find Shortest Paths efficiently in any Graph. This week we will study Breadth-First Search algorithm.

• Video · Most Direct Route
• Video · Breadth-First Search
• Video · Breadth-First Search (continued)
• Video · Implementation and Analysis
• Video · Proof of Correctness
• Video · Proof of Correctness (continued)
• Video · Shortest-Path Tree
• Video · Reconstructing the Shortest Path
• Programming Assignment · Programming Assignment 3: Paths in Graphs

WEEK 4 - Paths in Graphs 2

This week we continue to study Shortest Paths in Graphs. You will learn Dijkstra’s Algorithm which can be applied to find the shortest route home from work. You will also learn Bellman-Ford’s algorithm which can unexpectedly be applied to choose the optimal way of exchanging currencies. By the end you will be able to find shortest paths efficiently in any Graph.

• Video · Fastest Route
• Video · Dijkstra’s Algorithm: Intuition and Example
• Video · Dijkstra’s Algorithm: Implementation
• Video · Dijkstra’s Algorithm: Proof of Correctness
• Video · Dijkstra’s Algorithm: Running Time
• Video · Currency Exchange
• Video · Currency Exchange: Reduction to Shortest Paths
• Video · Bellman-Ford Algorithm
• Video · Bellman-Ford Algorithm: Proof of Correctness
• Video · Negative Cycles
• Video · Infinite Arbitrage
• Programming Assignment · Programming Assignment 4: Paths in Graphs

WEEK 5 - Minimum Spanning Trees

In this module, we study the minimum spanning tree problem. We will cover two elegant greedy algorithms for this problem: the first one is due to Kruskal and uses the disjoint sets data structure, the second one is due to Prim and uses the priority queue data structure. In the programming assignment for this module you will be computing an optimal way of building roads between cities and an optimal way of partitioning a given set of objects into clusters (a fundamental problem in data mining).

• Video · Building a Network
• Video · Greedy Algorithms
• Video · Cut Property
• Video · Kruskal’s Algorithm
• Video · Prim’s Algorithm
• Programming Assignment · Programming Assignment 5: Minimum Spanning Trees

WEEK 6 - Advanced Shortest Paths Project (Optional)

In this module, you will learn Advanced Shortest Paths algorithms that work in practice 1000s (up to 25000) of times faster than the classical Dijkstra’s algorithm on real-world road networks and social networks graphs. You will work on a Programming Project based on these algorithms. You will find the shortest paths on the real maps of parts of US and the shortest paths connecting people in the social networks. We encourage you not only to use the ideas from this module’s lectures in your implementations, but also to come up with your own ideas for speeding up the algorithm! We encourage you to compete on the forums to see whose implementation is the fastest one :)

• Video · Programming Project: Introduction
• Video · Bidirectional Search
• Video · Six Handshakes
• Video · Bidirectional Dijkstra
• Video · Finding Shortest Path after Meeting in the Middle
• Video · Computing the Distance
• Video · A* Algorithm
• Video · Performance of A*
• Video · Bidirectional A*
• Video · Potential Functions and Lower Bounds
• Video · Landmarks (Optional)
• Video · Highway Hierarchies and Node Importance
• Video · Preprocessing
• Video · Witness Search
• Video · Query
• Video · Node Ordering
• Reading · Slides and External Refernces
• Practice Quiz · Bidirectional Dijkstra, A* and Contraction

Hierarchies

• Practice Programming Assignment · Advanced Shortest Paths

COURSE 4 - Algorithms on Strings

Week 1 - suffix trees.

How would you search for a longest repeat in a string in LINEAR time? In 1973, Peter Weiner came up with a surprising solution that was based on suffix trees, the key data structure in pattern matching. Computer scientists were so impressed with his algorithm that they called it the Algorithm of the Year. In this lesson, we will explore some key ideas for pattern matching that will - through a series of trials and errors - bring us to suffix trees.

• Video · From Genome Sequencing to Pattern Matching
• Video · Brute Force Approach to Pattern Matching
• Video · Herding Patterns into Trie
• Reading · Trie Construction - Pseudocode
• Video · Herding Text into Suffix Trie
• Video · Suffix Trees
• Reading · FAQ
• Programming Assignment · Programming Assignment 1

WEEK 2 - Burrows-Wheeler Transform and Suffix Arrays

Although EXACT pattern matching with suffix trees is fast, it is not clear how to use suffix trees for APPROXIMATE pattern matching. In 1994, Michael Burrows and David Wheeler invented an ingenious algorithm for text compression that is now known as Burrows-Wheeler Transform. They knew nothing about genomics, and they could not have imagined that 15 years later their algorithm will become the workhorse of biologists searching for genomic mutations. But what text compression has to do with pattern matching??? In this lesson you will learn that the fate of an algorithm is often hard to predict – its applications may appear in a field that has nothing to do with the original plan of its inventors.

• Video · Burrows-Wheeler Transform
• Video · Inverting Burrows-Wheeler Transform
• Video · Using BWT for Pattern Matching
• Reading · Using BWT for Pattern Matching
• Video · Suffix Arrays
• Reading · Pattern Matching with Suffix Array
• Video · Approximate Pattern Matching
• Programming Assignment · Programming Assignment 2

WEEK 4 - Constructing Suffix Arrays and Suffix Trees

In this module we continue studying algorithmic challenges of the string algorithms. You will learn an O(n log n) algorithm for suffix array construction and a linear time algorithm for construction of suffix tree from a suffix array. You will also implement these algorithms and the Knuth-Morris-Pratt algorithm in the last

Programming Assignment in this course.

• Video · Suffix Array
• Video · General Strategy
• Video · Initialization
• Reading · Counting Sort
• Video · Sort Doubled Cyclic Shifts
• Video · SortDouble Implementation
• Video · Updating Classes
• Video · Full Algorithm
• Quiz · Suffix Array Construction
• Video · Suffix Array and Suffix Tree
• Video · LCP Array
• Video · Computing the LCP Array
• Reading · Computing the LCP Array - Additional Slides
• Video · Construct Suffix Tree from Suffix Array and LCP Array
• Reading · Suffix Tree Construction - Pseudocode
• Programming Assignment · Programming Assignment 3

COURSE 5 - Advanced Algorithms and Complexity

Week 1 - flows in networks.

Network flows show up in many real world situations in which a good needs to be transported across a network with limited capacity. You can see it when shipping goods across highways and routing packets across the internet. In this unit, we will discuss the mathematical underpinnings of network flows and some important flow algorithms. We will also give some surprising examples on seemingly unrelated problems that can be solved with our knowledge of network flows.

• Reading · Slides and Resources on Flows in Networks
• Video · Network Flows
• Video · Residual Networks
• Video · Maxflow-Mincut
• Video · The Ford–Fulkerson Algorithm
• Video · Slow Example
• Video · The Edmonds–Karp Algorithm
• Video · Bipartite Matching
• Video · Image Segmentation
• Quiz · Flow Algorithms

WEEK 2 - Linear Programming

Linear programming is a very powerful algorithmic tool. Essentially, a linear programming problem asks you to optimize a linear function of real variables constrained by some system of linear inequalities. This is an extremely versatile framework that immediately generalizes flow problems, but can also be used to discuss a wide variety of other problems from optimizing production procedures to finding the cheapest way to attain a healthy diet. Surprisingly, this very general framework admits efficient algorithms. In this unit, we will discuss some of the importance of linear programming problems along with some of the tools used to solve them.

• Reading · Slides and Resources on Linear Programming
• Video · Linear Programming
• Video · Linear Algebra: Method of Substitution
• Video · Linear Algebra: Gaussian Elimination
• Video · Convexity
• Video · Duality
• Video · (Optional) Duality Proofs
• Video · Linear Programming Formulations
• Video · The Simplex Algorithm
• Video · (Optional) The Ellipsoid Algorithm
• Quiz · Linear Programming Quiz

WEEK 3 - NP-complete Problems

Although many of the algorithms you’ve learned so far are applied in practice a lot, it turns out that the world is dominated by real-world problems without a known provably efficient algorithm. Many of these problems can be reduced to one of the classical problems called NP-complete problems which either cannot be solved by a polynomial algorithm or solving any one of them would win you a million dollars (see Millenium Prize Problems) and eternal worldwide fame for solving the main problem of computer science called P vs NP. It’s good to know this before trying to solve a problem before the tomorrow’s deadline :) Although these problems are very unlikely to be solvable efficiently in the nearest future, people always come up with various workarounds. In this module you will study the classical NP-complete problems and the reductions between them. You will also practice solving large instances of some of these problems despite their hardness using very efficient specialized software based on tons of research in the area of NP-complete problems.

• Reading · Slides and Resources on NP-complete Problems
• Video · Brute Force Search
• Video · Search Problems
• Video · Traveling Salesman Problem
• Video · Hamiltonian Cycle Problem
• Video · Longest Path Problem
• Video · Integer Linear Programming Problem
• Video · Independent Set Problem
• Video · P and NP
• Video · Reductions
• Video · Showing NP-completeness
• Video · Independent Set to Vertex Cover
• Video · 3-SAT to Independent Set
• Video · SAT to 3-SAT
• Video · Circuit SAT to SAT
• Video · All of NP to Circuit SAT
• Video · Using SAT-solvers
• Quiz · NP-complete Problems

WEEK 4 - Coping with NP-completeness

After the previous module you might be sad: you’ve just went through 5 courses in Algorithms only to learn that they are not suitable for most real-world problems. However, don’t give up yet! People are creative, and they need to solve these problems anyway, so in practice there are often ways to cope with an NP-complete problem at hand. We first show that some special cases on NP-complete problems can, in fact, be solved in polynomial time. We then consider exact algorithms that find a solution much faster than the brute force algorithm. We conclude with approximation algorithms that work in polynomial time and find a solution that is close to being optimal.

• Reading · Slides and Resources on Coping with NP-completeness
• Video · 2-SAT
• Video · 2-SAT: Algorithm
• Video · Independent Sets in Trees
• Video · 3-SAT: Backtracking
• Video · 3-SAT: Local Search
• Video · TSP: Dynamic Programming
• Video · TSP: Branch and Bound
• Video · Vertex Cover
• Video · Metric TSP
• Video · TSP: Local Search
• Quiz · Coping with NP-completeness
• Programming Assignment · Programming Assignment 4

WEEK 5 - Streaming Algorithms (Optional)

In most previous lectures we were interested in designing algorithms with fast (e.g. small polynomial) runtime, and assumed that the algorithm has random access to its input, which is loaded into memory. In many modern applications in big data analysis, however, the input is so large that it cannot be stored in memory. Instead, the input is presented as a stream of updates, which the algorithm scans while maintaining a small summary of the stream seen so far. This is precisely the setting of the streaming model of computation, which we study in this lecture. The streaming model is well-suited for designing and reasoning about small space algorithms. It has received a lot of attention in the literature, and several powerful algorithmic primitives for computing basic stream statistics in this model have been designed, several of them impacting the practice of big data analysis. In this lecture we will see one such algorithm (CountSketch), a small space algorithm for finding the top k most frequent items in a data stream.

• Video · Heavy Hitters Problem
• Video · Reduction 1
• Video · Reduction 2
• Video · Basic Estimate 1
• Video · Basic Estimate 2
• Video · Final Algorithm 1
• Video · Final Algorithm 2
• Video · Proofs 1
• Video · Proofs 2
• Practice Quiz · Quiz: Heavy Hitters
• Practice Programming Assignment · (Optional) Programming Assignment 5

COURSE 6 - Genome Assembly Programming Challenge

Upcoming session: Jan 22

WEEK 1 - The 2011 European E. coli Outbreak

In April 2011, hundreds of people in Germany were hospitalized with a deadly disease that often started as food poisoning with bloody diarrhea. It was the beginning of the deadliest outbreak in recent history, caused by a mysterious bacterial strain that we will refer to as E. coli X. Within a few months, the outbreak had infected thousands and killed 53 people. To prevent the further spread of the outbreak, computational biologists all over the world had to answer the question “What is the genome sequence of E. coli X?” in order to figure out what new genes it acquired to become pathogenic. The 2011 German outbreak represented an early example of epidemiologists collaborating with computational biologists to stop an outbreak. In this Genome Assembly Programming Challenge, you will follow in the footsteps of the bioinformaticians investigating the outbreak by developing a program to assemble the genome of the deadly E. coli X strain. However, before you embark on building a program for assembling the E. coli X strain, we have to explain some genomic concepts and warm you up by having you solve a simpler problem of assembling a small virus.

• Video · 2011 European E. coli outbreak
• Video · Assembling phage genome
• Reading · What does it mean to assemble a genome?
• Reading · Project Description
• Programming Assignment · Programming Assignment 1: Assembling the phi174X Genome Using Overlap Graphs

WEEK 2 - Assembling Genomes Using de Bruijn Graphs

DNA sequencing approach that led to assembly of a small virus in 1977 went through a series of transformations that contributed to the emergence of personalized medicine a few years ago. By the late 1980s, biologists were routinely sequencing viral genomes containing hundreds of thousands of nucleotides, but the idea of sequencing a bacterial (let alone the human) genome containing millions (or even billions) of nucleotides remained preposterous and would cost billions of dollars. In 1988, three biologists (independently and simultaneously!) came up with an idea to reduce sequencing cost and proposed the futuristic and at the time completely implausible method of DNA arrays. None of these three biologists could have possibly imagined that the implications of his own experimental research would eventually bring him face-to-face with challenging algorithmic problems. In this module you will learn about the algorithmic challenge of DNA sequencing using information about short k-mers provided by DNA arrays. You will also travel to the 18the century to learn about the Bridges of Konigsberg and solve a related problem of assembling a jigsaw puzzle!

• Video · DNA arrays
• Video · Assembling genomes from k-mers
• Video · De Bruijn graphs
• Video · Bridges of Königsberg and universal strings
• Video · Euler theorem
• Programming Assignment · Programming Assignment 2: Assembling the phi174X Genome Using De Bruijn Graphs

WEEK 3 - Genome Assembly Faces Real Sequencing Data

Our discussion of genome assembly has thus far relied upon various assumptions. In this module, we will face practical challenges introduced by quirks in modern sequencing technologies and discuss some algorithmic techniques that have been devised to address these challenges. Afterwards, you will assemble the smallest bacterial genome that lives symbiotically inside leafhoppers. Its sheltered life has allowed it to reduce its genome to only about 112,091 nucleotides and 137 genes. And afterwards, you will be ready to assemble the E. coli X genome!

• Video · Splitting the genome into contigs
• Video · From reads to read-pairs
• Video · Genome assembly faces real sequencing data
• Programming Assignment · Programming Assignment 3: Genome Assembly Faces Real Sequencing Data

rebelliard commented Sep 25, 2018

How did you generate this? I'd like to do this for other courses.

Sorry, something went wrong.

sirenko commented Dec 5, 2018

@rebelliard : FWIW, roughly, it was done in the following way:

• open the page you want to convert in your browser of choice, in my case it was Chrome
• open developer tools and locate tag having the content you want to convert. You can use pointer "select element to inspect for it". Usually desirable content is enclosed into the "<div>..</div>" tag.
• point the mouse's cursor at the desirable block, and with the right button select from the drop-down menu "Copy > Copy Element"
• in the text browser of your choice, create valid html document with empty body
• paste the copied ("<div>") block into the body and save it
• with the pandoc (can be installed from https://github.com/jgm/pandoc ) convert saved html document into the .org (in my case, but you may prefer markdown target format) with the following command:
• clean up result .org file in the editor of your choice. In my case it was Emacs with multiple-cursors package.

Module 1 Programming Problems

Programming Problems should be submitted to gradescope .

If you need instructions on how to submit your .py files to gradescope, watch the video at the end of this page.

Due date: Friday, January 12, 2024 at 7pm

https://uarizona.co1.qualtrics.com/jfe/form/SV_0q8KC0FwVhCiYD4

This is a survey to collect information on your expectations for CSc 110 Computer Programming I. The completion of this survey is required and will be used for grading purposes.

Programming Problem 1

Due date: Thursday, January 18, 2024 at 7pm

Write a python program that prints out the string “Hello World!”. Be careful with capitalization and punctuation. Remember to write code inside a function called main() .

The exact output of the program should be:

Name the program hello.py . Make sure that gradescope ( https://www.gradescope.com/courses/487587/assignments/2554285 ) gives you the points for passing the test case.

Programming Problem 2

Write a python program that prints out the following excerpt from Amanda Gorman’s poem, “The Hill We Climb”:

Name the program poem.py . Remember to write code inside a function called main() . Make sure that gradescope gives you the points for passing the test case. You can submit your solution to gradescope as many times as you want before the deadline.

HINT: print() has a parameter called end which is set as end="\n" by default – change that to end="" to remove the last newline character.

Make sure you do the reading for this module, especially the section on Escape Sequences

How to submit to gradescope video

• Search Unit Name
• Search Cornell
• Instructions
• Concepts/defs
• Navigation 6

CS1130. Transition to OO programming. Spring 2011

Programming assignment for module 1.

The programming assignment for module 1 is to develop a class with fields, getter/setter methods, function toString, and two other methods. As you develop the class, you will also develop a JUnit testing class, which will contain the test cases for the class.

You have a choice of assignments. They are basically the same, but we provide alternatives so that you can choose one that interests you the most.

How the assignment is "graded"

You won't be finished with this assignment until your class is correct and you have appropriate test cases. When you think that your assignment is finished, submit it on the CMS. We will process it as follows:

If the field specifications and the javadoc specifications for the class and methods are not appropriate, we will ask you to fix them and resubmit the assignment. If the field and javadoc specs are ok, we will look at your test cases. If they are inadequate, we will ask you to fix them and resubmit the assignment. If the specs and test cases are adequate, we will test your program. If there are errors, we will ask you to correct them and resubmit. If at any point we determine that you did not develop the class and test cases appropriately, we may ask you to stop working on this assignment and do one of the alternatives instead. Basically, you are expected to develop the methods and test cases for them in groups, moving on to the next group only when the current group of methods are correct.

You won't be able to take the test for module 1 until your programming assignment is done. To save yourself —and the course staff— time, please read the assignment instructions carefully and work so that we don't have to ask you to revise and resubmit.

The alternatives for the programming assignment

• Is CS 121 a good fit for you?
• Academic Honesty
• Introductory Labs
• M1: Introduction to Programming
• M2: Functions
• M3: Dictionaries & File Basics
• M4: Classes and Objects
• M6: Recursion
• M7 (Bonus): Pandas
• Getting Help
• How to Learn in this Class
• Asking Questions on Piazza
• Office Hours
• Coursework Basics
• Testing Your Code
• Virtual Desktop
• Working Remotely with Visual Studio Code and SSH
• Style Guide
• The Debugging Guide
• Pre-recorded Lectures
• Textbook Chapters
• Zoom Sessions
• Short Exercises
• Programming Assignment

M1: Introduction to Programming ¶

This first module provides an introduction to basic programming concepts and skills.

Pre-recorded Lectures ¶

The pre-recorded lectures are available through Canvas.

The lectures include a video to introduce the module (“Introduction to Module M1”) and a series of 5-15 minute videos divided into three sections:

1a.1 - Introduction

1a.2 - Writing and Running your First Program

1a.3 - Variables

1a.4 - Expressions

1a.5 - Bonus: Types Revisited

1b.1 - Introduction

1b.2 - Conditional Statements

1b.3 - “for” loops

1b.4 - Example: Primality Testing

1b.5 - “while” loops

1c.1 - Introduction

1c.2 - List Creation and Basic Usage

1c.3 - List Iteration

1c.4 - Adding/Removing Elements from a List

1c.5 - List Slicing

1c.6 - Lists of Lists

1c.7 - Tuples

1c.8 - Strings

1c.9 - Bonus: List Comprehensions

1c.10 - Bonus: Lists in Memory

Textbook Chapters ¶

The chapters corresponding to this module are:

Computational Thinking

Programming Basics

Control Flow Statements

Lists, Tuples, and Strings

A PDF version of the textbook is also available here .

You will be asked to log in with your CNetID before you can see the textbook.

Please note that the pre-recorded lectures cover largely the same material as the book. We recommend starting with the pre-recorded lectures, and then reading through the book (but do not feel bad if you find yourself skipping large portions of the textbook, if you feel they tread on material that you already understood when watching the lectures)

Zoom Sessions ¶

You will find the links to the Zoom sessions on Canvas.

Wednesday, September 30th : Introduction to CS 121

Friday, October 2nd : Q&A and Git

Wednesday, October 7th : Lab #1

Friday, October 9th : Q&A and List/Loops Examples

Lab #1: Lists and Loops

In the October 7th lecture, we will be working through a few of the problems in this lab. You are not expected to complete the lab before that lecture, but you should try to read through it so you are familiar with its contents.

Short Exercises ¶

Short Exercises #1 , due Sunday, Oct 11 at 3pm CDT

Programming Assignment ¶

Programming Assignment #1 , due Friday, Oct 16 at 3pm CDT

• school Campus Bookshelves
• menu_book Bookshelves
• perm_media Learning Objects
• login Login
• how_to_reg Request Instructor Account
• hub Instructor Commons
• Download Page (PDF)
• Download Full Book (PDF)
• Periodic Table
• Physics Constants
• Scientific Calculator
• Reference & Cite
• Tools expand_more
• Readability

selected template will load here

This action is not available.

1.4: Practice 1 Introduction to Programming

• Last updated
• Save as PDF
• Page ID 11237

• Kenneth Leroy Busbee
• Houston Community College via OpenStax CNX

Learning Objectives

With 100% accuracy during a: memory building activity, exercises, lab assignment, problems, or timed quiz/exam; the student is expected to:

• Define the terms on the definitions as listed in the modules associated with this chapter.
• Install the Bloodshed Dev-C++ 5 compiler
• Make minor modifications to an existing program

Memory Building Activities

Link to:   MBA 01

True or False:

• Beginning programmers participate in all phases of the Systems Development Life Cycle.
• The Bloodshed Dev-C++ 5 compiler/IDE is the preferred compiler for this textbook/collection, however any C++ compiler will work.
• Most compilers can be installed on a flash drive.
• In addition to function as the name of a sub-program, the computer industry also uses macro, procedure and module.
• Generally functions fall into two categories: Program Control and Specific Task.

Lab Assignment

Creating a folder or sub-folder for chapter 01 files.

Within the Chapter 1 Connexions modules you were given directions on how to install the  Bloodshed Dev-C++ 5 compiler/IDE  and to test your installation with the Compiler_Test.cpp source code file. If you have not done this, return to the Connexions materials and complete this task.

In the compiler installation directions you were asked to make a folder named: Cpp_Source_Code_Files. All of your lab assignments in this course assume you have that folder on the same drive as your compiler (either drive C: your hard disk drive, or on a flash drive). If you don’t have that folder, go create it now.

Depending on your compiler/IDE, you should decide where to download and store source code files for processing. Prudence dictates that you create these folders as needed prior to downloading source code files. A suggested sub-folder for the  Bloodshed Dev-C++ 5 compiler/IDE  might be named:

• Chapter_01 within the folder named: Cpp_Source_Code_Files

If you have not done so, please create the folder(s) and/or sub-folder(s) as appropriate.

Download the Lab File(s)

Download and store the following file(s) to your storage device in the appropriate folder(s). You may need to right click on the link and select "Save Target As" in order to download the file.

Download from Connexions:   Compiler_Test.cpp

Detailed Lab Instructions

Read and follow the directions below carefully, and perform the steps in the order listed.

• Navigate to your sub-folder: Chapter_01 and rename the Compiler_Test.cpp source code file to:  Lab_01.cpp
• If you are having problems seeing the file extensions, visit the “Show Hide File Extensions” instructions within the Appendix.
• Start your compiler and open the source code file. Carefully make the following modifications:
• Change the comments at the top, specifically:
• The filename should be: Lab_01.cpp
• Purpose should be: Average the weight of three people
• Remove the next 2 lines of comment talking about the main idea
• Author: put your name and erase my name and copyright
• Date: Put today's date
• Remove the next 3 lines of comment dealing with licensing (don't erase the asterisk line)

During the rest of the course you will often use a source code file provided by the instructor as your starting point for a new lab assignment. Sometimes you will use a source code file that you have created as your starting point for a new lab assignment. Either way, you should modify the comments area as appropriate to include at a minimum the four lines of information (filename, purpose, author and date) as established in this lab assignment.

• We are now going to make simple modifications to this program so that it is able to average the weight of three people. Do the following:
• Within the variables area, change the variable names for age1 and age2 to weight1 and weight2. Add another variable of integer data type with the identifier name of weight3.
• The input area has two prompts and requests for data from the user. They are paired up – a prompt and getting data from the keyboard. We need to modify the prompt to ask for weight instead of age. We need to change the variable name from age1 to weight1. Do this for the second pair that prompts and gets the second data item. Create a third pair that prompts and gets the third data item.
• The process area has only one line of code and we need to make changes that add the weight3 and divides by 3.0 instead of 2.0. The code should look like this:
• answer = (weight1 + weight2 + weight3) / 3.0;
• The output area needs the text modified from ages to weights.
• Build (compile and run) your program. You have successfully written this program if when it run and you put in the three weights; it tells you the correct average.
• After you have successfully written this program, if you are taking this course for college credit, follow the instructions from your professor/instructor for submitting it for grading.

Problem 01a - Instructions

List the steps of the Systems Development Life Cycle and indicate which step you are likely to work in as a new computer professional.

• MapReduce Algorithm
• Linear Programming using Pyomo
• Networking and Professional Development for Machine Learning Careers in the USA
• Predicting Employee Churn in Python
• Airflow Operators

Solving Assignment Problem using Linear Programming in Python

Learn how to use Python PuLP to solve Assignment problems using Linear Programming.

In earlier articles, we have seen various applications of Linear programming such as transportation, transshipment problem, Cargo Loading problem, and shift-scheduling problem. Now In this tutorial, we will focus on another model that comes under the class of linear programming model known as the Assignment problem. Its objective function is similar to transportation problems. Here we minimize the objective function time or cost of manufacturing the products by allocating one job to one machine.

If we want to solve the maximization problem assignment problem then we subtract all the elements of the matrix from the highest element in the matrix or multiply the entire matrix by –1 and continue with the procedure. For solving the assignment problem, we use the Assignment technique or Hungarian method, or Flood’s technique.

The transportation problem is a special case of the linear programming model and the assignment problem is a special case of transportation problem, therefore it is also a special case of the linear programming problem.

In this tutorial, we are going to cover the following topics:

Assignment Problem

A problem that requires pairing two sets of items given a set of paired costs or profit in such a way that the total cost of the pairings is minimized or maximized. The assignment problem is a special case of linear programming.

For example, an operation manager needs to assign four jobs to four machines. The project manager needs to assign four projects to four staff members. Similarly, the marketing manager needs to assign the 4 salespersons to 4 territories. The manager’s goal is to minimize the total time or cost.

Problem Formulation

A manager has prepared a table that shows the cost of performing each of four jobs by each of four employees. The manager has stated his goal is to develop a set of job assignments that will minimize the total cost of getting all 4 jobs.  

Initialize LP Model

In this step, we will import all the classes and functions of pulp module and create a Minimization LP problem using LpProblem class.

Define Decision Variable

In this step, we will define the decision variables. In our problem, we have two variable lists: workers and jobs. Let’s create them using  LpVariable.dicts()  class.  LpVariable.dicts()  used with Python’s list comprehension.  LpVariable.dicts()  will take the following four values:

• First, prefix name of what this variable represents.
• Second is the list of all the variables.
• Third is the lower bound on this variable.
• Fourth variable is the upper bound.
• Fourth is essentially the type of data (discrete or continuous). The options for the fourth parameter are  LpContinuous  or  LpInteger .

Let’s first create a list route for the route between warehouse and project site and create the decision variables using LpVariable.dicts() the method.

Define Objective Function

In this step, we will define the minimum objective function by adding it to the LpProblem  object. lpSum(vector)is used here to define multiple linear expressions. It also used list comprehension to add multiple variables.

Define the Constraints

Here, we are adding two types of constraints: Each job can be assigned to only one employee constraint and Each employee can be assigned to only one job. We have added the 2 constraints defined in the problem by adding them to the LpProblem  object.

Solve Model

In this step, we will solve the LP problem by calling solve() method. We can print the final value by using the following for loop.

From the above results, we can infer that Worker-1 will be assigned to Job-1, Worker-2 will be assigned to job-3, Worker-3 will be assigned to Job-2, and Worker-4 will assign with job-4.

In this article, we have learned about Assignment problems, Problem Formulation, and implementation using the python PuLp library. We have solved the Assignment problem using a Linear programming problem in Python. Of course, this is just a simple case study, we can add more constraints to it and make it more complicated. You can also run other case studies on Cargo Loading problems , Staff scheduling problems . In upcoming articles, we will write more on different optimization problems such as transshipment problem, balanced diet problem. You can revise the basics of mathematical concepts in  this article  and learn about Linear Programming  in this article .

• Solving Blending Problem in Python using Gurobi
• Transshipment Problem in Python Using PuLP

You May Also Like

Python Decorators

Grid Search in scikit-learn

Working with Pandas Date and Time