question stringlengths 34 5.67k | answer stringlengths 20 20.1k | support_files listlengths 0 4 | metadata dict |
|---|---|---|---|
Add a method isFull() to /******************************************************************************
* Compilation: javac FixedCapacityStackOfStrings.java
* Execution: java FixedCapacityStackOfStrings
* Dependencies: StdIn.java StdOut.java
*
* Stack of strings implementation with a fixed-size array.
*... | /******************************************************************************
* Compilation: javac FixedCapacityStackOfStrings.java
* Execution: java FixedCapacityStackOfStrings
* Dependencies: StdIn.java StdOut.java
*
* Stack of strings implementation with a fixed-size array.
*
* % more tobe.txt
* ... | [] | {
"number": "1.3.1",
"code_execution": true,
"url": "https://algs4.cs.princeton.edu/13stacks/FixedCapacityStackOfStrings.java",
"params": [
"5 < tobe.txt"
],
"dependencies": [
"StdIn.java",
"StdOut.java"
],
"chapter": null,
"chapter_title": null,
"section": null,
"section_title": null,... |
Write a stack client Parentheses.java that reads in sequence of left and right parentheses, braces, and brackets from standard input and uses a stack to determine whether the sequence is properly balanced. For example, your program should print true for [()]{}{[()()]()} and false for [(]). | /******************************************************************************
* Compilation: javac Parentheses.java
* Execution: java Parentheses
* Dependencies: In.java Stack.java
*
* Reads in a text file and checks to see if the parentheses are balanced.
*
* % java Parentheses
* [()]{}{[()()]()}
... | [] | {
"number": "1.3.4",
"code_execution": true,
"url": "https://algs4.cs.princeton.edu/13stacks/Parentheses.java",
"params": [
"<<< \"[(])\"",
"<<< \"[()]{}{[()()]()}\""
],
"dependencies": [
"In.java",
"Stack.java"
],
"chapter": null,
"chapter_title": null,
"section": null,
"section_t... |
Add a method peek to '/******************************************************************************
* Compilation: javac Stack.java
* Execution: java Stack < input.txt
* Dependencies: StdIn.java StdOut.java
* Data files: https://algs4.cs.princeton.edu/13stacks/tobe.txt
*
* A generic stack, implemente... | /******************************************************************************
* Compilation: javac Stack.java
* Execution: java Stack < input.txt
* Dependencies: StdIn.java StdOut.java
* Data files: https://algs4.cs.princeton.edu/13stacks/tobe.txt
*
* A generic stack, implemented using a singly linke... | [] | {
"number": "1.3.7",
"code_execution": true,
"url": "https://algs4.cs.princeton.edu/13stacks/Stack.java",
"params": [
"< tobe.txt"
],
"dependencies": [
"StdIn.java",
"StdOut.java"
],
"chapter": null,
"chapter_title": null,
"section": null,
"section_title": null,
"type": null
} |
Write a filter Program InfixToPostfix.java that converts an arithmetic expression from infix to postfix. | /******************************************************************************
* Compilation: javac InfixToPostfix.java
* Execution: java InfixToPostFix
* Dependencies: Stack.java StdIn.java StdOut.java
*
* Reads in a fully parenthesized infix expression from standard input
* and prints an equivalent po... | [] | {
"number": "1.3.10",
"code_execution": true,
"url": "https://algs4.cs.princeton.edu/13stacks/InfixToPostfix.java",
"params": [
"<<EOF\n( 2 + ( ( 3 + 4 ) * ( 5 * 6 ) ) )\nEOF",
"<<EOF\n( ( ( 5 + ( 7 * ( 1 + 1 ) ) ) * 3 ) + ( 2 * ( 1 + 1 ) ) )\nEOF"
],
"dependencies": [
"Stack.java",
"StdIn.j... |
Write a program EvaluatePostfix.java that that takes a postfix expression from standard input, evaluates it, and prints the value. | /******************************************************************************
* Compilation: javac EvaluatePostfix.java
* Execution: java EvaluatePostfix < file.txt
* Dependencies: Stack.java StdIn.java StdOut.java
*
* Evaluates postfix expresions using a stack.
*
* Windows users: replace [Ctrl-d] wit... | [] | {
"number": "1.3.11",
"code_execution": true,
"url": "https://algs4.cs.princeton.edu/13stacks/EvaluatePostfix.java",
"params": [
"<<EOF\n3 4 5 + *\nEOF",
"<<EOF\n1 2 3 4 5 * + 6 * * +\nEOF",
"<<EOF\n7 16 16 16 * * * 5 16 16 * * 3 16 * 1 + + +\nEOF",
"<<EOF\n7 16 * 5 + 16 * 3 + 16 * 1 +\nEOF"
]... |
Develop a class ResizingArrayQueueOfStrings that implements the queue abstraction with a fixed-size array,
and then extend your implementation
to use array resizing
to remove the size restriction. | /******************************************************************************
* Compilation: javac ResizingArrayQueue.java
* Execution: java ResizingArrayQueue < input.txt
* Dependencies: StdIn.java StdOut.java
* Data files: https://algs4.cs.princeton.edu/13stacks/tobe.txt
*
* Queue implementation wi... | [] | {
"number": "1.3.14",
"code_execution": true,
"url": "https://algs4.cs.princeton.edu/13stacks/ResizingArrayQueue.java",
"params": [
"< tobe.txt"
],
"dependencies": [
"StdIn.java",
"StdOut.java"
],
"chapter": null,
"chapter_title": null,
"section": null,
"section_title": null,
"type":... |
Josephus problem. In the Josephus problem from antiquity, N people are in dire straits and agree to the following strategy to reduce the population. They arrange themselves in a circle (at positions numbered from 0 to N-1) and proceed around the circle, eliminating every Mth person until only one person is left. Legend... | /******************************************************************************
* Compilation: javac Josephus.java
* Execution: java Josephus m n
* Dependencies: Queue.java
*
* Solves the Josephus problem.
*
* % java Josephus 2 7
* 1 3 5 0 4 2 6
*
****************************************************... | [] | {
"number": "1.3.37",
"code_execution": true,
"url": "https://algs4.cs.princeton.edu/13stacks/Josephus.java",
"params": [
"2 7"
],
"dependencies": [
"Queue.java"
],
"chapter": null,
"chapter_title": null,
"section": null,
"section_title": null,
"type": null
} |
Develop classes QuickUnionUF.java that implement quick-union. | /******************************************************************************
* Compilation: javac QuickUnionUF.java
* Execution: java QuickUnionUF < input.txt
* Dependencies: StdIn.java StdOut.java
* Data files: https://algs4.cs.princeton.edu/15uf/tinyUF.txt
* https://algs4.cs.princeton.e... | [] | {
"number": "1.5.7",
"code_execution": true,
"url": "https://algs4.cs.princeton.edu/15uf/QuickUnionUF.java",
"params": [
"< tinyUF.txt",
"< mediumUF.txt"
],
"dependencies": [
"StdIn.java",
"StdOut.java"
],
"chapter": null,
"chapter_title": null,
"section": null,
"section_title": nu... |
Develop classes QuickFindUF.java that implement quick-find. | /******************************************************************************
* Compilation: javac QuickFindUF.java
* Execution: java QuickFindUF < input.txt
* Dependencies: StdIn.java StdOut.java
* Data files: https://algs4.cs.princeton.edu/15uf/tinyUF.txt
* https://algs4.cs.princeton.edu... | [] | {
"number": "1.5.7",
"code_execution": true,
"url": "https://algs4.cs.princeton.edu/15uf/QuickFindUF.java",
"params": [
"< tinyUF.txt",
"< mediumUF.txt"
],
"dependencies": [
"StdIn.java",
"StdOut.java"
],
"chapter": null,
"chapter_title": null,
"section": null,
"section_title": nul... |
Transaction sort test client. Write a class SortTransactions.java that consists of a static method main() that reads a sequence of transactions from standard
input, sorts them, and prints the result on standard output. | /******************************************************************************
* Compilation: javac SortTransactions.java
* Execution: java SortTransactions < input.txt
* Dependencies: StdOut.java
* Data file: https://algs4.cs.princeton.edu/21elementary/tinyBatch.txt
*
* % java SortTransactions < tra... | [] | {
"number": "2.1.22",
"code_execution": true,
"url": "https://algs4.cs.princeton.edu/21elementary/SortTransactions.java",
"params": [
"< tinyBatch.txt"
],
"dependencies": [
"StdOut.java"
],
"chapter": null,
"chapter_title": null,
"section": null,
"section_title": null,
"type": null
} |
Insertion sort with sentinel. Develop an implementation InsertionX.java of insertion sort that eliminates the j > 0 test in the inner loop by first putting the smallest item into position | /******************************************************************************
* Compilation: javac InsertionX.java
* Execution: java InsertionX < input.txt
* Dependencies: StdOut.java StdIn.java
* Data files: https://algs4.cs.princeton.edu/21elementary/tiny.txt
* https://algs4.cs.princet... | [] | {
"number": "2.1.23",
"code_execution": true,
"url": "https://algs4.cs.princeton.edu/21elementary/InsertionX.java",
"params": [
"< words3.txt",
"< tiny.txt"
],
"dependencies": [
"StdOut.java",
"StdIn.java"
],
"chapter": null,
"chapter_title": null,
"section": null,
"section_title":... |
Insertion sort without exchanges. Develop an implementation InsertionX.java of insertion sort that moves larger items to the right one position rather
than doing full exchanges. | /******************************************************************************
* Compilation: javac InsertionX.java
* Execution: java InsertionX < input.txt
* Dependencies: StdOut.java StdIn.java
* Data files: https://algs4.cs.princeton.edu/21elementary/tiny.txt
* https://algs4.cs.princet... | [] | {
"number": "2.1.24",
"code_execution": true,
"url": "https://algs4.cs.princeton.edu/21elementary/InsertionX.java",
"params": [
"< words3.txt",
"< tiny.txt"
],
"dependencies": [
"StdOut.java",
"StdIn.java"
],
"chapter": null,
"chapter_title": null,
"section": null,
"section_title":... |
Use of a static array like aux[] is inadvisable in library software because
multiple clients might use the class concurrently. Give an implementation of Merge.java that
does not use a static array. | /******************************************************************************
* Compilation: javac Merge.java
* Execution: java Merge < input.txt
* Dependencies: StdOut.java StdIn.java
* Data files: https://algs4.cs.princeton.edu/22mergesort/tiny.txt
* https://algs4.cs.princeton.edu/22me... | [] | {
"number": "2.2.9",
"code_execution": true,
"url": "https://algs4.cs.princeton.edu/22mergesort/Merge.java",
"params": [
"< tiny.txt",
"< words3.txt"
],
"dependencies": [
"StdOut.java",
"StdIn.java"
],
"chapter": null,
"chapter_title": null,
"section": null,
"section_title": null,
... |
Improvements. Write a program MergeX.java that implements the three improvements to mergesort that are described in the text: add a cutoff from small subarrays, test whether the array is already in order, and avoid the copy by switching arguments in the recursive code | /******************************************************************************
* Compilation: javac MergeX.java
* Execution: java MergeX < input.txt
* Dependencies: StdOut.java StdIn.java
* Data files: https://algs4.cs.princeton.edu/22mergesort/tiny.txt
* https://algs4.cs.princeton.edu/22... | [] | {
"number": "2.2.11",
"code_execution": true,
"url": "https://algs4.cs.princeton.edu/22mergesort/MergeX.java",
"params": [
"< tiny.txt",
"< words3.txt"
],
"dependencies": [
"StdOut.java",
"StdIn.java"
],
"chapter": null,
"chapter_title": null,
"section": null,
"section_title": null... |
Inversions. Develop and implement a linearithmic algorithm Inversions.java for computing the number of inversions in a given array (the number of exchanges that would be performed by insertion sort for that array—see Section 2.1). This quantity is related to the Kendall tau distance | /******************************************************************************
* Compilation: javac Inversions.java
* Execution: java Inversions < input.txt
* Dependencies: StdIn.java StdOut.java
*
* Read array of n integers and count number of inversions in n log n time.
*
*****************************... | [] | {
"number": "2.2.19",
"code_execution": true,
"url": "https://algs4.cs.princeton.edu/22mergesort/Inversions.java",
"params": [
"< 1Kints.txt",
"< 2Kints.txt",
"< 4Kints.txt",
"< 8Kints.txt",
"< 16Kints.txt",
"< 32Kints.txt"
],
"dependencies": [
"StdIn.java",
"StdOut.java"
]... |
Index sort. Develop a version of Merge.java that does not rearrange the array, but returns an int[] perm such that perm[i] is the index of the ith smallest entry in the array. | /******************************************************************************
* Compilation: javac Merge.java
* Execution: java Merge < input.txt
* Dependencies: StdOut.java StdIn.java
* Data files: https://algs4.cs.princeton.edu/22mergesort/tiny.txt
* https://algs4.cs.princeton.edu/22me... | [] | {
"number": "2.2.20",
"code_execution": true,
"url": "https://algs4.cs.princeton.edu/22mergesort/Merge.java",
"params": [
"< tiny.txt",
"< words3.txt"
],
"dependencies": [
"StdOut.java",
"StdIn.java"
],
"chapter": null,
"chapter_title": null,
"section": null,
"section_title": null,... |
Write a program Sort2distinct.java that sorts an array that is known to contain just two distinct key values. | /******************************************************************************
* Compilation: javac Sort2distinct.java
* Execution: java Sort2distinct binary-string
* Dependencies: StdOut.java
*
* Partitions the array of specified as the command-line.
* Assumes there are at most 2 distinct elements.
*... | [] | {
"number": "2.3.5",
"code_execution": true,
"url": "https://algs4.cs.princeton.edu/23quicksort/Sort2distinct.java",
"params": [
"01001111011100111011011101001100",
"10110111001101111100001011011011",
"10110100010000111011000111110000",
"01110100010010011010011111001001",
"110001010010010111... |
Best case. Write a program QuickBest.java that produces a best-case array (with no duplicates) for Quick.sort(): an array of N distinct keys with the property that every partition will produce subarrays that differ in size by at most 1 (the same subarray sizes that would happen for an array of N equal keys). For the pu... | /******************************************************************************
* Compilation: javac QuickBest.java
* Execution: java QuickBest n
* Dependencies: StdOut.java
*
* Generate a best-case input of size n for standard quicksort.
*
* % java QuickBest 3
* BAC
*
* % java QuickBest 7
* DACB... | [] | {
"number": "2.3.16",
"code_execution": true,
"url": "https://algs4.cs.princeton.edu/23quicksort/QuickBest.java",
"params": [
"3",
"7",
"15"
],
"dependencies": [
"StdOut.java"
],
"chapter": null,
"chapter_title": null,
"section": null,
"section_title": null,
"type": null
} |
Fast three-way partitioning. (J. Bentley and D. McIlroy). Implement an entropy-optimal sort QuickBentleyMcIlroy.java based on keeping equal keys at both the left and right ends of the subarray. Maintain indices p and q such that a[lo..p-1] that a[q+1..hi] are all equal to a[lo], an index i such that a[p..i-1] are all l... | /******************************************************************************
* Compilation: javac QuickX.java
* Execution: java QuickX < input.txt
* Dependencies: StdOut.java StdIn.java
* Data files: https://algs4.cs.princeton.edu/23quicksort/tiny.txt
* https://algs4.cs.princeton.edu/23... | [] | {
"number": "2.3.22",
"code_execution": true,
"url": "https://algs4.cs.princeton.edu/23quicksort/QuickX.java",
"params": [
"< tiny.txt",
"< words3.txt"
],
"dependencies": [
"StdOut.java",
"StdIn.java"
],
"chapter": null,
"chapter_title": null,
"section": null,
"section_title": null... |
Design a linear-time certification algorithm to check whether an array pq[] is a min-oriented heap. | /******************************************************************************
* Compilation: javac MaxPQ.java
* Execution: java MaxPQ < input.txt
* Dependencies: StdIn.java StdOut.java
* Data files: https://algs4.cs.princeton.edu/24pq/tinyPQ.txt
*
* Generic max priority queue implementation with a bi... | [] | {
"number": "2.4.15",
"code_execution": true,
"url": "https://algs4.cs.princeton.edu/24pq/MaxPQ.java",
"params": [
"< tinyPQ.txt"
],
"dependencies": [
"StdIn.java",
"StdOut.java"
],
"chapter": null,
"chapter_title": null,
"section": null,
"section_title": null,
"type": null
} |
Computational number theory. Write a program CubeSum.java that prints out all integers of the form \(a^3 + b^3\)
where \(a\) and \(b\) are integers between 0 and \(n<\) in sorted order,
without using excessive space. That is, instead of computing an array of
the \(n^2\) sums and sorting them, build a minimum-oriented p... | /******************************************************************************
* Compilation: javac CubeSum.java
* Execution: java CubeSum n
* Dependencies: MinPQ.java
*
* Print out integers of the form a^3 + b^3 in sorted order, where
* 0 <= a <= b <= n.
*
* % java CubeSum 12
* 0 = 0^3 + 0^3
* 1... | [] | {
"number": "2.4.25",
"code_execution": true,
"url": "https://algs4.cs.princeton.edu/24pq/CubeSum.java",
"params": [
"4",
"12"
],
"dependencies": [
"MinPQ.java"
],
"chapter": null,
"chapter_title": null,
"section": null,
"section_title": null,
"type": null
} |
Interval 1D data type. Write three static comparators for Interval1D.java, one that compares intervals by their left endpoing, one that compares intervals by their right endpoint, and one that compares intervals by their length. | /******************************************************************************
* Compilation: javac Insertion.java
* Execution: java Insertion < input.txt
* Dependencies: StdOut.java StdIn.java
* Data files: https://algs4.cs.princeton.edu/21elementary/tiny.txt
* https://algs4.cs.princeton... | [
"https://algs4.cs.princeton.edu/21elementary/words3.txt",
"https://algs4.cs.princeton.edu/21elementary/tiny.txt"
] | {
"number": "2.5.27",
"code_execution": true,
"url": "https://algs4.cs.princeton.edu/25applications/Insertion.java",
"params": [
"< tiny.txt",
"< words3.txt"
],
"dependencies": [
"StdOut.java",
"StdIn.java"
],
"chapter": null,
"chapter_title": null,
"section": null,
"section_title"... |
Sort files by name. Write a program FileSorter.java that takes the name of a directory as a command line input and prints out all of the files in the current directory, sorted by filename. Hint: use the java.io.File data type. | /******************************************************************************
* Compilation: javac FileSorter.java
* Execution: java FileSorter directory-name
* Dependencies: StdOut.java
*
* Prints out all of the files in the given directory in
* sorted order.
*
* % java FileSorter .
*
***********... | [] | {
"number": "2.5.28",
"code_execution": true,
"url": "https://algs4.cs.princeton.edu/25applications/FileSorter.java",
"params": [
"java FileSorter ."
],
"dependencies": [
"StdOut.java"
],
"chapter": null,
"chapter_title": null,
"section": null,
"section_title": null,
"type": null
} |
Write a client
program GPA.java that creates a symbol table mapping letter grades to numerical
scores, as in the table below, then reads from standard input a list of letter
grades and computes and prints the GPA (the average of the numerical
scores of the corresponding grades). A+ A A- B+ B B- C... | /******************************************************************************
* Compilation: javac GPA.java
* Execution: java GPA < input.txt
* Dependencies: ST.java
*
* Create a symbol table mapping letter grades to numerical
* scores, then read a list of letter grades from standard input,
* and pri... | [] | {
"number": "3.1.1",
"code_execution": true,
"url": "https://algs4.cs.princeton.edu/31elementary/GPA.java",
"params": [
"<<EOF\nA- B+ B+ B-\nEOF"
],
"dependencies": [
"ST.java"
],
"chapter": null,
"chapter_title": null,
"section": null,
"section_title": null,
"type": null
} |
Develop a symbol-table implementation ArrayST.java that uses an (unordered) array as the underlying data structure to implement our basic symbol table API. | /******************************************************************************
* Compilation: javac ArrayST.java
* Execution: java ArrayST < input.txt
* Dependencies: StdIn.java StdOut.java
* Data files: https://algs4.cs.princeton.edu/31elementary/tinyST.txt
*
*
* Symbol table implementation with uno... | [
"https://algs4.cs.princeton.edu/31elementary/tinyST.txt"
] | {
"number": "3.1.2",
"code_execution": true,
"url": "https://algs4.cs.princeton.edu/31elementary/ArrayST.java",
"params": [
"< tinyST.txt"
],
"dependencies": [
"StdIn.java",
"StdOut.java"
],
"chapter": null,
"chapter_title": null,
"section": null,
"section_title": null,
"type": null
... |
Implement size(), delete(), and keys() for SequentialSearchST.java. | /******************************************************************************
* Compilation: javac SequentialSearchST.java
* Execution: java SequentialSearchST
* Dependencies: StdIn.java StdOut.java
* Data files: https://algs4.cs.princeton.edu/31elementary/tinyST.txt
*
* Symbol table implementation w... | [
"https://algs4.cs.princeton.edu/31elementary/tinyST.txt"
] | {
"number": "3.1.5",
"code_execution": true,
"url": "https://algs4.cs.princeton.edu/31elementary/SequentialSearchST.java",
"params": [
"< tinyST.txt"
],
"dependencies": [
"StdIn.java",
"StdOut.java"
],
"chapter": null,
"chapter_title": null,
"section": null,
"section_title": null,
"t... |
Implement the delete() method for BinarySearchST.java. | /******************************************************************************
* Compilation: javac BinarySearchST.java
* Execution: java BinarySearchST
* Dependencies: StdIn.java StdOut.java
* Data files: https://algs4.cs.princeton.edu/31elementary/tinyST.txt
*
* Symbol table implementation with bina... | [
"https://algs4.cs.princeton.edu/31elementary/tinyST.txt"
] | {
"number": "3.1.16",
"code_execution": true,
"url": "https://algs4.cs.princeton.edu/31elementary/BinarySearchST.java",
"params": [
"< tinyST.txt"
],
"dependencies": [
"StdIn.java",
"StdOut.java"
],
"chapter": null,
"chapter_title": null,
"section": null,
"section_title": null,
"type... |
Implement the floor() method for BinarySearchST.java . | /******************************************************************************
* Compilation: javac BinarySearchST.java
* Execution: java BinarySearchST
* Dependencies: StdIn.java StdOut.java
* Data files: https://algs4.cs.princeton.edu/31elementary/tinyST.txt
*
* Symbol table implementation with bina... | [
"https://algs4.cs.princeton.edu/31elementary/tinyST.txt"
] | {
"number": "3.1.17",
"code_execution": true,
"url": "https://algs4.cs.princeton.edu/31elementary/BinarySearchST.java",
"params": [
"< tinyST.txt"
],
"dependencies": [
"StdIn.java",
"StdOut.java"
],
"chapter": null,
"chapter_title": null,
"section": null,
"section_title": null,
"type... |
Certification. Add assert statements to BinarySearchST.java to check algorithm invariants and data structure integrity after every
insertion and deletion. For example, every index i should always be equal to rank(select(i)) and the array should
always be in order. | /******************************************************************************
* Compilation: javac BinarySearchST.java
* Execution: java BinarySearchST
* Dependencies: StdIn.java StdOut.java
* Data files: https://algs4.cs.princeton.edu/31elementary/tinyST.txt
*
* Symbol table implementation with bina... | [
"https://algs4.cs.princeton.edu/31elementary/tinyST.txt"
] | {
"number": "3.1.30",
"code_execution": true,
"url": "https://algs4.cs.princeton.edu/31elementary/BinarySearchST.java",
"params": [
"< tinyST.txt"
],
"dependencies": [
"StdIn.java",
"StdOut.java"
],
"chapter": null,
"chapter_title": null,
"section": null,
"section_title": null,
"type... |
End of preview. Expand in Data Studio
No dataset card yet
- Downloads last month
- 7