# CodeVita Predictions 2 for Codevita V6

This set consists of other zone problemsets so go through it carefully if you wanna get better results.

## Treasure Hunt

Captain Bill the Hummingbird and his crew recieved an interesting challenge offer. Some stranger gave them a map, potion of teleportation and said that only this potion might help them to reach the treasure.

Bottle with potion has two values *x* and *y* written on it. These values define four moves which can be performed using the potion:

Map shows that the position of Captain Bill the Hummingbird is (*x*_{1}, *y*_{1}) and the position of the treasure is (*x*_{2}, *y*_{2}).

You task is to tell Captain Bill the Hummingbird whether he should accept this challenge or decline. If it is possible for Captain to reach the treasure using the potion then output “YES”, otherwise “NO” (without quotes).

The potion can be used infinite amount of times.

The first line contains four integer numbers *x*_{1}, *y*_{1}, *x*_{2}, *y*_{2} ( – 10^{5} ≤ *x*_{1}, *y*_{1}, *x*_{2}, *y*_{2} ≤ 10^{5}) — positions of Captain Bill the Hummingbird and treasure respectively.

The second line contains two integer numbers *x*, *y* (1 ≤ *x*, *y* ≤ 10^{5}) — values on the potion bottle.

Print “YES” if it is possible for Captain to reach the treasure using the potion, otherwise print “NO” (without quotes).

0 0 0 6 2 3

YES

1 1 3 6 1 5

NO

In the first example there exists such sequence of moves:

- — the first type of move
- — the third type of move

### Greedy Change

## Brokerage charge:

**Input Format:**

Line1 | Brokerage rate |

Line 2 | Buying amount |

Line 3 | Selling amount |

Line 4 | Quantity |

**Output Format:**

Line 1 | For Valid Input,printProfit OrLoss For Invalid Input,printInvalid Input |

Line 2 | For Valid Input,printAmount of Profit / Loss faced in transaction |

SNo. | Input | Output |
---|---|---|

1 | 0.03 315 316 100 | Profit 67.42 |

1 | 0.03 315 @ 100 | Invalid Input |

1 | 0.03 315 315.32 100 | Loss 0.53 |

### LPS

Given a sequence, the objective is to find the longest progressive sequence arranged in ascending order. Detailed descriptions are as:

**Problem**

A sequence is said to be progressive if it doesn’t decrease at any point in time.

For example 1 1 2 2 is a progressive sequence but 1 2 1 is not a progressive sequence. Let S be the sequence and be represented by L spaced integers Ki, now your task is to find out the first longest progressive sequence present in the given sequence (S).

**Input Format:**

First line will contain T, the length of the sequence and next line will contain T spaced integers Ki (where i = 0,1, …,L).

Line 1 T,where T is the length of the sequence

Line 2 Ki,where Ki is integer in sequence separated by space

**Constraints:**

1<=T<=10^6(one million)

1<=Ki<=10^9(one billion)

**Output Format:**

Line 1 longest progressive sequence present in the given sequence

**Sample Test Cases:**

SNo. | Input | Output |
---|---|---|

1 | 4 1 1 2 1 | 1 1 2 |

2 | 5 1 2 1 2 2 | 1 2 2 |

### Cipher

Borya has recently found a big electronic display. The computer that manages the display stores some integer number. The number has *n*decimal digits, the display shows the encoded version of the number, where each digit is shown using some lowercase letter of the English alphabet.

There is a legend near the display, that describes how the number is encoded. For each digit position *i* and each digit *j* the character *c* is known, that encodes this digit at this position. Different digits can have the same code characters.

Each second the number is increased by 1. And one second after a moment when the number reaches the value that is represented as *n*9-s in decimal notation, the loud beep sounds.

Andrew knows the number that is stored in the computer. Now he wants to know how many seconds must pass until Borya can definitely tell what was the original number encoded by the display. Assume that Borya can precisely measure time, and that the encoded number will first be increased exactly one second after Borya started watching at the display.

Input data contains multiple test cases. The first line of input contains *t* (1 ≤ *t* ≤ 100) — the number of test cases.

Each test case is described as follows. The first line of the description contains *n* (1 ≤ *n* ≤ 18) — the number of digits in the number. The second line contains *n* decimal digits without spaces (but possibly with leading zeroes) — the number initially stored in the display computer. The following *n* lines contain 10 characters each. The *j*-th character of the *i*-th of these lines is the code character for a digit *j* – 1in position *i*, most significant digit positions are described first.

For each test case print an integer: the number of seconds until Borya definitely knows what was the initial number stored on the display of the computer. Do not print leading zeroes.

3 2 42 abcdefghij jihgfedcba 2 42 aaaaaaaaaa aaaaaaaaaa 1 2 abcdabcdff

0 58 2 {Code with Code@ter}