# HackerRank

Programming Problems from## C# Solutions

#### Hash Tables: Ransom Note

A kidnapper wrote a ransom note but is worried it will be traced back to him. He found a magazine and wants to know if he can cut out whole words from it and use them to create an untraceable replica of his ransom note. The words in his note are case-sensitive and he must use whole words available in the magazine, meaning he cannot use substrings or concatenation to create the words he needs.

Given the words in the magazine and the words in the ransom note, print Yes if he can replicate his ransom note exactly using whole words from the magazine; otherwise, print No.

#### Stacks: Balanced Brackets

A bracket is considered to be any one of the following characters: (, ), {, }, [, or ].

Two brackets are considered to be a matched pair if the an opening bracket (i.e., (, [, or {) occurs to the left of a closing bracket (i.e., ), ], or }) of the exact same type. There are three types of matched pairs of brackets: [], {}, and ().

A matching pair of brackets is not balanced if the set of brackets it encloses are not matched. For example, {[(])} is not balanced because the contents in between { and } are not balanced. The pair of square brackets encloses a single, unbalanced opening bracket, (, and the pair of parentheses encloses a single, unbalanced closing square bracket, ].

By this logic, we say a sequence of brackets is considered to be balanced if the following conditions are met:

- It contains no unmatched brackets.
- The subset of brackets enclosed within the confines of a matched pair of brackets is also a matched pair of brackets.

Given `n`

strings of brackets, determine whether each sequence of brackets is balanced. If a string is
balanced, print YES on a new line; otherwise, print NO on a new line.

#### Strings: Making Anagrams

Alice is taking a cryptography class and finding anagrams to be very useful. We consider two strings to be anagrams of each other if the first string's letters can be rearranged to form the second string. In other words, both strings must contain the same exact letters in the same exact frequency For example, bacdc and dcbac are anagrams, but bacdc and dcbad are not.

Alice decides on an encryption scheme involving two large strings where encryption is dependent on the minimum number of character deletions required to make the two strings anagrams. Can you help her find this number?

Given two strings, `a`

and `b`

, that may or may not be of the same length, determine the minimum
number of character deletions required to make and anagrams. Any characters can be deleted
from either of the strings.

#### Arrays: Left Rotation

A left rotation operation on an array of size `n`

shifts each of the array's
elements `1`

unit to the left. For example, if `2`

left rotations are
performed on array `[1, 2, 3, 4, 5]`

, then the array would become
`[3, 4, 5, 1, 2]`

.

Given an array of `n`

integers and a number, `d`

, perform `d`

left rotations on the array. Then print the updated array as a single line of space-separated
integers.

#### Lonely Integer

Consider an array of `n`

integers, `A = [a(0), a(1), ... a(n-1)]`

, where all but one of
the integers occur in pairs. In other words, every element in `A`

occurs exactly twice except
for one unique element.

Given `A`

, find and print the unique element.

#### Palindrome Index

Given a string, `S`

, of lowercase letters, determine the index of the character whose removal
will make `S`

a palindrome. If `S`

is already a palindrome or no such character exists, then
print `-1`

. There will always be a valid solution, and any correct answer is acceptable. For
example, if "bcbc", we can either remove 'b' at index `0`

or 'c' at index `3`

.

#### CamelCase

Alice wrote a sequence of words in CamelCase as a string of letters, `s`

, having the following
properties:

- It is a concatenation of one or more words consisting of English letters.
- All letters in the first word are lowercase.
- For each of the subsequent words, the first letter is uppercase and rest of the letters are lowercase.

Given `s`

, print the number of words in `s`

on a new line.

#### PanGrams

Roy wanted to increase his typing speed for programming contests. So, his friend advised him to type the sentence "The quick brown fox jumps over the lazy dog" repeatedly, because it is a pangram. (Pangrams are sentences constructed by using every letter of the alphabet at least once.)

After typing the sentence several times, Roy became bored with it. So he started to look for other pangrams.

Given a sentence `s`

, tell Roy if it is a pangram or not.

#### RectangularGames

You are given an infinite 2-d grid with the bottom left cell referenced as (1,1). All the cells contain a value of zero initially. Let's play a game?

The game consists of **N** steps wherein each step you are given two integers **a** and **b**. The value
of each of the cells in the co-ordinate (u, v) satisfying 1 ≤ u ≤ a and 1 ≤ v ≤ b, is increased by 1.
After **N** such steps, if **X** is the largest number amongst all the cells in the rectangular board,
can you print the number of **X**'s in the board?

#### Angry Professor

A Discrete Mathematics professor has a class of `N`

students. Frustrated with their lack of discipline,
he decides to cancel class if fewer than `K`

students are present when class starts.

Given the arrival time of each student, determine if the class is canceled.

## C++ Solutions

#### Linked Lists: Detect a Cycle

A linked list is said to contain a *cycle* if any node is visited more than once while
traversing the list.

Complete the function provided in the editor below. It has one parameter: a pointer
to a *Node* object named `head`

that points to the head of a linked list. Your
function must return a boolean denoting whether or not there is a cycle in the list.
If there *is* a cycle, return *true*; otherwise, return *false*.

#### Operator Overloading

Classes define new types in C++. Types in C++ not only interact by means of constructions and assignments but also via operators. For example:

```
int a=2, b=1, c;
c = b + a;
```

The result of variable c will be 3. Similarly, classes can also perform operations using operator overloading . Operators are overloaded by means of operator functions, which are regular functions with special names. Their name begins with the operator keyword followed by the operator sign that is overloaded. The syntax is:

`type operator sign (parameters) { /*... body ...*/ }`

You are given a main() function which takes a set of inputs to create two matrices and prints the
result of their addition. You need to write the class *Matrix* which has a member *a* of type
*vector<vector<int>>*. You also need to write a member function to overload the operator **+**.
The function's job will be to add two objects of *Matrix* type and return the resultant *Matrix*.

#### Preprocessor Solution

Preprocessor directives are lines included in the code preceded by a hash sign (#). These lines are directives for the preprocessor. The preprocessor examines the code before actual compilation of code begins and resolves all these directives before any code is actually generated by regular statements.

```
#define INF 10000000
if( val == INF) {
//Do something
}
After the preprocessor has replaced the directives, the code will be
if( val == 10000000) { //Here INF is replaced by the value with which it's defined.
//Do something
}
```

You can also define function macros which have parameters.

```
#define add(a, b) a + b
int x = add(a, b);
The second statement after the preprocessor has replaced the directives will be:
int x = a + b;
```

To know more about preprocessor directives, you can go to this link

You're spending your afternoon at a local school, teaching kids how to code. You give them a simple task: find the difference between the maximum and minimum values in an array of integers.

After a few hours, they came up with some promising source code. Unfortunately, it doesn't compile! Since you don't want to discourage them, you decide to make their code work without modifying it by adding preprocessor macros.

Review the locked stub code in your editor and add the preprocessor macros necessary to make the code work.

#### Truck Tour

Suppose there is a circle. There are `N`

petrol pumps on that circle. Petrol pumps are numbered `0`

to
`(N - 1)`

(both inclusive). You have two pieces of information corresponding to each of the petrol pump:
(1) the amount of petrol that particular petrol pump will give, and (2) the distance from that petrol pump
to the next petrol pump.

Initially, you have a tank of infinite capacity carrying no petrol. You can start the tour at any of the petrol pumps. Calculate the first point from where the truck will be able to complete the circle. Consider that the truck will stop at each of the petrol pumps. The truck will move one kilometer for each litre of the petrol.

#### Tree Problems

##### PreOrder Traversal

Complete the *preOrder* function in your editor below, which has `1`

parameter: a pointer to the root of
a binary tree. It must print the values in the tree's preorder traversal as a single line of
space-separated values.

##### PostOrder Traversal

Complete the *postOrder* function in your editor below, which has `1`

parameter: a pointer to the root of
a binary tree. It must print the values in the tree's postorder traversal as a single line of
space-separated values.

##### InOrder Traversal

Complete the *inOrder* function in your editor below, which has `1`

parameter: a pointer to the root of
a binary tree. It must print the values in the tree's inorder traversal as a single line of
space-separated values.

##### Height of a Binary Tree

The height of a binary tree is the number of edges between the tree's root and its furthest leaf. This
means that a tree containing a single node has a height of `0`

.

Complete the *getHeight* function provided in your editor so that it returns the height of a binary tree.
This function has a parameter, `root`

, which is a pointer to the root node of a binary tree.