| # | Problem | Pass Rate (passed user / total user) |
|---|---|---|
| 11285 | Determinant |
|
| 11339 | linked list-insert, erase and remove |
|
| 11341 | The Blocks Problem |
|
Description
Determinant is a value computed from all the elements of a square matrix. A determinant of an N-by-N matrix can be recursively computed from N determinant (N-1)-by(N-1) sub-matrices (minors). You may check the examples below (from Wikipedia):
4-by-4 example:
3-by-3 example:
2-by-2 example:
In other words, you may calculate the determinant value by expanding the original determinant along the first row, multiplying each element by its corresponding minor, multiplying each product by the elements in the alternating series 1, -1, 1, -1, ... accordingly, and then summing up all the products.
For more details you may check:
https://en.wikipedia.org/wiki/Determinant#n_.C3.97_n_matrices
or
https://people.richland.edu/james/lecture/m116/matrices/determinant.html
Input
The first line contains an integer n (2 <= n <= 8), specifying the size of the square matrix A. Then following next n lines, each line containing n integers, define the entries of the matrix A. The range of values in the entries is from -4 to 4.
Output
For each case, output one line with the determinant of matrix A.
Sample Input Download
Sample Output Download
Tags
Discuss
Description
This problem will ask you to do some operations on a list. These operations contains insert, erase, print, remove and show. The position of first node is 0.
Input
The input consist of a number of operations. The first line specifies a non-negative integer N that specifies the number of operations. Each operations (I, E, P, R and S) are separated by a newline character (\n).
I stands for “insert”, following by a non-negative integer (insert position) and a non-negative integer (insert value, 0<=insert value<65536). Insert a node at insert position with insert value.
E stands for “erase”, following by a non-negative integer (start position) and a non-negative integer (end position). End position must be greater than or equal to start position. Erase multiple nodes from start position to end position (excluding end position). If start position is equal to end position, do not erase end position.
If any input positions in the two operations above is greater than or equal to the length of the list, treat the input position as the next position of the last position at the list.
For example, input is
I 0 0
I 1 1
S
Output should be
0 1
P stands for “print”, following by a non-negative integer (print position). Print the value of the node at print position.
If print position is greater than or equal to the length of the list, treat the input position as the last position at the list. If the
linked list is empty, do not print anything.
R stands for “remove”, following by a non-negative integer (remove value). Remove the nodes in the list with the value that is equal to remove value.
S stands for “show”. Print the value of all nodes in the list. Separate every prints by a whitespace character. If the list is empty, do not print anything.
For example, input is
5
E 1 1
E 1 2
P 2
R 1
S
Output should be nothing.
Output
Print a space after doing P or S operations (if P or S has printed something).
Sample Input Download
Sample Output Download
Partial Judge Code
11339.cPartial Judge Header
11339.hTags
Discuss
Description
Many areas of Computer Science use simple, abstract domains for both analytical and empirical studies. For example, an early AI study of planning and robotics (STRIPS) used a block world in which a robot arm performed tasks involving the manipulation of blocks.
In this problem you will model a simple block world under certain rules and constraints. Rather than determine how to achieve a specified state, you will “program” a robotic arm to respond to a limited set of commands.
The problem is to parse a series of commands that instruct a robot arm in how to manipulate blocks that lie on a flat table. Initially there are n blocks on the table (numbered from 0 to n − 1) with block bi adjacent to block bi+1 for all 0 ≤ i < n − 1 as shown in the diagram below:
The valid commands for the robot arm that manipulates blocks are:
- move a onto b
where a and b are block numbers, puts block a onto block b after returning any blocks that are stacked on top of blocks a
and b to their initial positions.
- move a over b
where a and b are block numbers, puts block a onto the top of the stack containing block b, after returning any blocks that
are stacked on top of block a to their initial positions.
- pile a onto b
where a and b are block numbers, moves the pile of blocks consisting of block a, and any blocks that are stacked above
block a, onto block b. All blocks on top of block b are moved to their initial positions prior to the pile taking place. The blocks
stacked above block a retain their order when moved.
- pile a over b
where a and b are block numbers, puts the pile of blocks consisting of block a, and any blocks that are stacked above block
a, onto the top of the stack containing block b. The blocks stacked above block a retain their original order when moved.
- quit
terminates manipulations in the block world.
Any command in which a = b or in which a and b are in the same stack of blocks is an illegal command. All illegal commands should be ignored and should have no affect on the configuration of blocks.
(This problem is provided by UVA.)
Input
The input begins with an integer n on a line by itself representing the number of blocks in the block world. You may assume that 0 < n < 25.
The number of blocks is followed by a sequence of block commands, one command per line. Your program should process all commands until the quit command is encountered.
You may assume that all commands will be of the form specified above. There will be no syntactically incorrect commands.
Output
The output should consist of the final state of the blocks world. Each original block position numbered i (0 ≤ i < n where n is the number of blocks) should appear followed immediately by a colon. If there is at least a block on it, the colon must be followed by one space, followed by a list of blocks that appear stacked in that position with each block number separated from other block numbers by a space. Don’t put any trailing spaces on a line.
There should be one line of output for each block position (i.e., n lines of output where n is the integer on the first line of input).