Write a program that takes an undefined number of `string` in arguments. For each argument, if the expression is correctly bracketed, the program prints on the standard output `OK` followed by a newline (`'\n'`), otherwise it prints `Error` followed by a newline.
Write a `program` that takes an undefined number of `string` in arguments. For each argument, if the expression is correctly bracketed, the program prints on the standard output `OK` followed by a newline (`'\n'`), otherwise it prints `Error` followed by a newline.
Symbols considered as brackets are parentheses `(` and `)`, square brackets `[` and `]` and curly braces `{` and `}`. Every other symbols are simply ignored.
An opening bracket must always be closed by the good closing bracket in the correct order. A `string` which does not contain any bracket is considered as a correctly bracketed`string`.
An opening bracket must always be closed by the good closing bracket in the correct order. A `string` which does not contain any bracket is considered as a correctly bracketed.
If there is no argument, the program must print nothing.
For receiving arguments from the command line you should use something like:
```rust
fn main() {
let args: Vec<String> = std::env::args().collect();
//...
}
```
### Usage
```console
$ go run . '(johndoe)' | cat -e
OK$
$ go run . '([)]' | cat -e
Error$
$ go run . '' '{[(0 + 0)(1 + 1)](3*(-1)){()}}' | cat -e
The code will always be valid, with less than 4096 operations.
`Brainfuck` is a minimalist language. It consists of an array of bytes (in this exercice 2048 bytes) all initialized with zero, and with a pointer to its first byte.
`Brainfuck` is a minimalist language. It consists of an array of bytes (in this exercise 2048 bytes) all initialized with zero, and with a pointer to its first byte.
Every operator consists of a single character :
@ -22,11 +22,11 @@ Any other character is a comment.
For receiving arguments from the command line you should use something like:
```rust
fn main() {
let args: Vec<String> = std::env::args().collect();
fn main() {
let args: Vec<String> = std::env::args().collect();
- Implement the `std::fmt::Display` trait for the structure table so that the table is printed like in the **[Usage](#usage)**. The length of each column must adjust to the longest element of the column and the element must be centered in the "cell" when possible. If the length of the element doees not allow to center exactly, it must descend slightly to the right.
- Implement the `std::fmt::Display` trait for the structure table so that the table is printed like in the **[Usage](#usage)**. The length of each column must adjust to the longest element of the column and the element must be centered in the "cell" when possible. If the length of the element does not allow to center exactly, it must be offset slightly to the left.
- Note: If the table is empty `println!` must not print anything.
- Note: If the table is empty (does not have a header), `println!` must not print anything.
- Define the associated function `new` which creates a new empty table.
- add_rows: which adds a new row to the table from a slice of strings.
- `add_rows`: which adds a new row to the table from a slice of strings.
- filter_cols: which receives a closure which receives a `&str` and returns a `bool` value:
- `filter_cols`: which receives a closure and returns a table with all the columns that yielded true when applying that closure. The closure will receive a `&str` and return a `bool` value.
- filter_cols returns a table with all the columns that yielded true when applied to the header.
- filter_rows: which receives a closure that receives a `&str` and returns a `bool` value
- filter_rows returns a table with all the columns that yielded true when applied to the elements of the selected column.
- `filter_rows`: which receives a closure and returns a table with all the rows that yielded true when applied to the elements of the selected column. The closure will receive a `&str` and return a `bool` value.
An API will have to be created to organize a queue of people.
You will need to create an *API* which will organize a queue of people, so that a program can organize a queue of people.
Using the given code declare the following functions:
The program requires the following functionsAdd the following associated functions to the `Queue` structure:
- `new` which will initialize the `Queue`
- `add` which receives the person's information, so it can be added to the `Queue`
- `invert_queue` which inverts the queue of persons
- `rm`, which will remove the person who finished ordering their food.
- `new`: which will initialize the `Queue`.
- `add`: which receives a person's information, to add them to the `Queue`.
- `invert_queue`: which reverses the queue.
- `rm`: which will remove the person who finished ordering their food. The removal should respect the FIFO method (first in first out. The function should return the removed person.
The removal should respect a FIFO system (first in first out). This function should return a tuple wrapped in an `Option` with the information of the removed person (check the usage)
- `search`, which returns a tuple with the information of a given person `id`
- `search`: which returns a tuple with the information of a given person `id`
You must also create a type called `Link`. This will be the connection of the structures `Queue` and `Person`.
Do not forget that this will be a recursion type and it must point to `None` if there is no persons.
In a chess game, a queen can attack pieces which are on the same row, column, or diagonal.
In a chess game, a queen can attack pieces which are on the same rank (row), file (column), or diagonal.
The purpose of this exercise is to find out if two queens can attack each other using the same rules.
The purpose of this exercise is to find out if two queens can attack each other.
The chess board will be represented as an 8 by 8 array.
The position of a chess piece on a chessboard will be represented by the struct `ChessPosition`. You must implement the associated function `new` which will return the position if it is valid, otherwise it will return `None`.
> Remember, chessboards have 8 files and 8 ranks (each from 0 to 7).
So, given the position of the two queens on a chess board, you will have to
implement the function `can_attack` in the given struct `Queen` with
the purpose of finding out whether the two queens can attack each other or not.
You will create the `Queen` struct with the associate function `can_attack`, which will return `true` if the queens can attack each other or not. You also need to implement the function `new` which creates a new `Queen` with a `ChessPosition`.
For this to be possible, you will also have to implement the struct `ChessPosition`
with the function `new`. This will allow you to verify if the position is valid or not. If the position is valid it will return that position, otherwise it will return `None`.
### Example
For example, if the white queen is at (2, 3) and the black queen is at (5, 6),
then the set-up would be like so:
If the white queen is at (2, 3) and the black queen is at (5, 6), then the set-up would be like the below. In this case, the two queens can attack each other because both pieces share a diagonal:
```
_ _ __ __ _ _
@ -29,8 +26,6 @@ _ _ _ _ _ _ _ _
_ _ __ __ _ _
```
In this case, the two queens can attack each other because both pieces share a diagonal.
David Mata
2 years ago
committed by
