You are given a string keysPressed of length n, where keysPressed[i] was the ith key pressed in the testing sequence, and a sorted list releaseTimes, where releaseTimes[i] was the time the ith key was released. Both arrays are 0-indexed. The 0th key was pressed at the time 0, and every subsequent key was pressed at the exact time the previous key was released.

The tester wants to know the key of the keypress that had the longest duration. The ith keypress had a duration of releaseTimes[i] - releaseTimes[i - 1], and the 0th keypress had a duration of releaseTimes[0].

Note that the same key could have been pressed multiple times during the test, and these multiple presses of the same key may not have had the same duration.

Return the key of the keypress that had the longest duration. If there are multiple such keypresses, return the lexicographically largest key of the keypresses.

Example 1:

Input: releaseTimes = [9,29,49,50], keysPressed = "cbcd"
Output: "c"
Explanation: The keypresses were as follows:
Keypress for 'c' had a duration of 9 (pressed at time 0 and released at time 9).
Keypress for 'b' had a duration of 29 - 9 = 20 (pressed at time 9 right after the release of the previous character and released at time 29).
Keypress for 'c' had a duration of 49 - 29 = 20 (pressed at time 29 right after the release of the previous character and released at time 49).
Keypress for 'd' had a duration of 50 - 49 = 1 (pressed at time 49 right after the release of the previous character and released at time 50).
The longest of these was the keypress for 'b' and the second keypress for 'c', both with duration 20.
'c' is lexicographically larger than 'b', so the answer is 'c'.

Example 2:

Input: releaseTimes = [12,23,36,46,62], keysPressed = "spuda"
Output: "a"
Explanation: The keypresses were as follows:
Keypress for 's' had a duration of 12.
Keypress for 'p' had a duration of 23 - 12 = 11.
Keypress for 'u' had a duration of 36 - 23 = 13.
Keypress for 'd' had a duration of 46 - 36 = 10.
Keypress for 'a' had a duration of 62 - 46 = 16.
The longest of these was the keypress for 'a' with duration 16.

Constraints:

• releaseTimes.length == n
• keysPressed.length == n
• 2 <= n <= 1000
• 1 <= releaseTimes[i] <= 109
• releaseTimes[i] < releaseTimes[i+1]
• keysPressed contains only lowercase English letters.

Solution

package array;

public class Leetcode_1629_Slowest_key {

    public char slowestKey(int[] releaseTimes, String keyPressed) {
        int currentReleaseTime =0;
        int previousReleaseTime =0;
        int maxReleaseTime=0;
        char c = 'a';
        // iterate over previous time
        for (int i =0;i<releaseTimes.length;i++){

            // get current time difference from current and previous time
            currentReleaseTime=releaseTimes[i]-previousReleaseTime;

            // check if time is maximum if not update max time and character at that index
            if(maxReleaseTime<currentReleaseTime){
                maxReleaseTime=currentReleaseTime;
                c=keyPressed.charAt(i);
            }
            // if max time is equal current time check if character stored is lesser if so update character
            else if(maxReleaseTime==currentReleaseTime){
                if(c<keyPressed.charAt(i)) c = keyPressed.charAt(i);
            }

            // update the previous time
            previousReleaseTime=releaseTimes[i];
        }

        return c;
    }
}

Unit Testing

package array;

import com.google.common.truth.Truth;
import org.junit.Before;
import org.junit.Test;

import static org.junit.Assert.*;

public class Leetcode_1629_Slowest_keyTest {
    Leetcode_1629_Slowest_key sut;

    @Before
    public void setUp() throws Exception {
        sut = new Leetcode_1629_Slowest_key();
    }

    @Test
    public void testSlowestKey() {
        int[] releaseTimes = {9,29,49,50};
        String keyPressed = "cbcd";
        char result = 'c';
        Truth.assertThat(sut.slowestKey(releaseTimes, keyPressed))
                .isEqualTo(result);
    }

    @Test
    public void testSlowestKey2() {
        int[] releaseTimes = {12,23,36,46,62};
        String keyPressed = "spuda";
        char result = 'a';
        Truth.assertThat(sut.slowestKey(releaseTimes, keyPressed))
                .isEqualTo(result);
    }
    @Test
    public void testSlowestKey3() {
        int[] releaseTimes = {23,34,43,59,62,80,83,92,97};
        String keyPressed = "qgkzzihfc";
        char result = 'q';
        Truth.assertThat(sut.slowestKey(releaseTimes, keyPressed))
                .isEqualTo(result);
    }
}

Given a 1-indexed array of integers numbers that is already sorted in non-decreasing order, find two numbers such that they add up to a specific target number. Let these two numbers be numbers[index1] and numbers[index2] where 1 <= index1 < index2 < numbers.length.

Return the indices of the two numbers, index1 and index2, added by one as an integer array [index1, index2] of length 2.

The tests are generated such that there is exactly one solution. You may not use the same element twice.

Your solution must use only constant extra space.

Example 1:

Input: numbers = [2,7,11,15], target = 9
Output: [1,2]
Explanation: The sum of 2 and 7 is 9. Therefore, index1 = 1, index2 = 2. We return [1, 2].

Example 2:

Input: numbers = [2,3,4], target = 6
Output: [1,3]
Explanation: The sum of 2 and 4 is 6. Therefore index1 = 1, index2 = 3. We return [1, 3].

Example 3:

Input: numbers = [-1,0], target = -1
Output: [1,2]
Explanation: The sum of -1 and 0 is -1. Therefore index1 = 1, index2 = 2. We return [1, 2].

Constraints:

• 2 <= numbers.length <= 3 * 104
• -1000 <= numbers[i] <= 1000
• numbers is sorted in non-decreasing order.
• -1000 <= target <= 1000
• The tests are generated such that there is exactly one solution.

Solution

import java.util.HashMap;
public class Leetcode_167_Two_Sum_1_indexed_One_Pass {

    public int[] twoSum(int[] nums, int target) {
        HashMap<Integer, Integer> map = new HashMap<>();
        for (int i = 0; i < nums.length; i++) {
            int complement = target - nums[i];
            if (map.containsKey(complement)) {
                return new int[]{map.get(complement) + 1, i + 1};
            } else {

                map.put(nums[i], i);
            }
        }
        return null;
    }
}

Unit Tests

import com.google.common.truth.Truth;
import org.junit.After;
import org.junit.Before;
import org.junit.Test;

public class Leetcode_167_Two_Sum_1_indexed_One_PassTest {

    Leetcode_167_Two_Sum_1_indexed_One_Pass sut;

    @Before
    public void setUp() throws Exception {
        sut = new Leetcode_167_Two_Sum_1_indexed_One_Pass();

    }

    @Test
    public void resultCorrectFor3_3() {
        int[] result = {1, 2};
        int[] nums = {3, 3};
        int target = 6;
        int[] resultArray = sut.twoSum(nums, target);
        Truth.assertThat(resultArray).isEqualTo(result);
    }

    @Test
    public void resultCorrectFor2719() {
        int[] result = {1, 2};
        int[] nums = {2, 7, 11, 15};
        int target = 9;
        int[] resultArray = sut.twoSum(nums, target);
        Truth.assertThat(resultArray).isEqualTo(result);
    }

    @Test
    public void resultNotFound3_3() {
        int[] result = null;
        int[] nums = {3, 3};
        int target = 7;
        int[] resultArray = sut.twoSum(nums, target);
        Truth.assertThat(resultArray).isEqualTo(result);
    }

    @Test
    public void resultNotFound324() {
        int[] result = {2,3};
        int[] nums = {3, 2,4};
        int target = 6;
        int[] resultArray = sut.twoSum(nums, target);
        Truth.assertThat(resultArray).isEqualTo(result);
    }

    @After
    public void tearDown() throws Exception {
    }
}

With unit testing we can be sured our code is working for various inputs

Happy Coding!

2D Array - DS | HackerRank

Given a 2D Array, :

1 1 1 0 0 0
0 1 0 0 0 0
1 1 1 0 0 0
0 0 0 0 0 0
0 0 0 0 0 0
0 0 0 0 0 0

An hourglass in is a subset of values with indices falling in this pattern in ‘s graphical representation:

a b c
  d
e f g

There are hourglasses in . An hourglass sum is the sum of an hourglass’ values. Calculate the hourglass sum for every hourglass in , then print the maximum hourglass sum. The array will always be .

Example

-9 -9 -9  1 1 1 
 0 -9  0  4 3 2
-9 -9 -9  1 2 3
 0  0  8  6 6 0
 0  0  0 -2 0 0
 0  0  1  2 4 0

The hourglass sums are:

-63, -34, -9, 12, 
-10,   0, 28, 23, 
-27, -11, -2, 10, 
  9,  17, 25, 18

The highest hourglass sum is from the hourglass beginning at row , column :

0 4 3
  1
8 6 6

Note: If you have already solved the Java domain’s Java 2D Array challenge, you may wish to skip this challenge.

Function Description

Complete the function hourglassSum in the editor below.

hourglassSum has the following parameter(s):

• int arr[6][6]: an array of integers

Returns

• int: the maximum hourglass sum

Input Format

Each of the lines of inputs contains space-separated integers .

Constraints

Output Format

Print the largest (maximum) hourglass sum found in .

Sample Input

1 1 1 0 0 0
0 1 0 0 0 0
1 1 1 0 0 0
0 0 2 4 4 0
0 0 0 2 0 0
0 0 1 2 4 0

Sample Output

19

Explanation

contains the following hourglasses:

The hourglass with the maximum sum (19) is:

2 4 4
  2
1 2 4

Solution (Using Brute Force)

#include <bits/stdc++.h>

using namespace std;

string ltrim(const string &);
string rtrim(const string &);
vector<string> split(const string &);

/*
 * Complete the 'hourglassSum' function below.
 *
 * The function is expected to return an INTEGER.
 * The function accepts 2D_INTEGER_ARRAY arr as parameter.
 */

int hourglassSum(vector<vector<int>> a) {
    int i = 0, j = 0;
    int sum , result = -999;
  while (i <= 3)
  {
    j = 0;
    while (j <= 3)
    {
      for (int r = i; r < i + 3; r++)
      {

        for (int c = j; c < j + 3; c++)
        {
          if (r == i + 1 && ((c == j) || (c == j + 2)))
          {
          }
          else
          {
            sum += a[r][c];
          }
        }
      }
      result=max(sum,result);
    
      sum = 0;

      j++;
    }
    i++;
  }
  cout << result << endl;

  return result;
}

int main()
{
    ofstream fout(getenv("OUTPUT_PATH"));

    vector<vector<int>> arr(6);

    for (int i = 0; i < 6; i++) {
        arr[i].resize(6);

        string arr_row_temp_temp;
        getline(cin, arr_row_temp_temp);

        vector<string> arr_row_temp = split(rtrim(arr_row_temp_temp));

        for (int j = 0; j < 6; j++) {
            int arr_row_item = stoi(arr_row_temp[j]);

            arr[i][j] = arr_row_item;
        }
    }

    int result = hourglassSum(arr);

    fout << result << "\n";

    fout.close();

    return 0;
}

string ltrim(const string &str) {
    string s(str);

    s.erase(
        s.begin(),
        find_if(s.begin(), s.end(), not1(ptr_fun<int, int>(isspace)))
    );

    return s;
}

string rtrim(const string &str) {
    string s(str);

    s.erase(
        find_if(s.rbegin(), s.rend(), not1(ptr_fun<int, int>(isspace))).base(),
        s.end()
    );

    return s;
}

vector<string> split(const string &str) {
    vector<string> tokens;

    string::size_type start = 0;
    string::size_type end = 0;

    while ((end = str.find(" ", start)) != string::npos) {
        tokens.push_back(str.substr(start, end - start));

        start = end + 1;
    }

    tokens.push_back(str.substr(start));

    return tokens;
}

Given an integer array nums, find the subarray with the largest sum, and return its sum.

Example 1:

Input: nums = [-2,1,-3,4,-1,2,1,-5,4]
Output: 6
Explanation: The subarray [4,-1,2,1] has the largest sum 6.

Example 2:

Input: nums = [1]
Output: 1
Explanation: The subarray [1] has the largest sum 1.

Example 3:

Input: nums = [5,4,-1,7,8]
Output: 23
Explanation: The subarray [5,4,-1,7,8] has the largest sum 23.

Constraints:

• 1 <= nums.length <= 105
• -104 <= nums[i] <= 104

Follow up: If you have figured out the O(n) solution, try coding another solution using the divide and conquer approach, which is more subtle.

Solution

class Solution {
public:
    int sum=0,best=INT_MIN;
    int maxSubArray(vector<int>& v) {
      
     
for (int k = 0; k < v.size(); k++)
  {
    sum = max(v[k], sum + v[k]);
    best = max(sum, best);
  }
 return best;
      
  
        
    }
};

https://www.hackerrank.com/challenges/connecting-towns/problem

Cities on a map are connected by a number of roads. The number of roads between each city is in an array and city is the starting location. The number of roads from city to city is the first value in the array, from city to city is the second, and so on.

How many paths are there from city to the last city in the list, modulo ?

Example

There are roads to city , roads to city and roads to city . The total number of roads is .

Note
Pass all the towns Ti for i=1 to n-1 in numerical order to reach Tn.

Function Description

Complete the connectingTowns function in the editor below.

connectingTowns has the following parameters:

• int n: the number of towns
• int routes[n-1]: the number of routes between towns

Returns

• int: the total number of routes, modulo 1234567.

Input Format
The first line contains an integer T, T test-cases follow.

Each test-case has 2 lines.
The first line contains an integer N (the number of towns).
The second line contains N — 1 space separated integers where the ith integer denotes the number of routes, Ni, from the town Ti to Ti+1

Constraints
1 <= T<=1000
2< N <=100
1 <= routes[i] <=1000

Sample Input

2
3
1 3
4
2 2 2

Sample Output

3
8

Explanation
Case 1: 1 route from T1 to T2, 3 routes from T2 to T3, hence only 3 routes.
Case 2: There are 2 routes from each city to the next, hence 2 * 2 * 2 = 8.

Solution

#include <bits/stdc++.h>

using namespace std;

string ltrim(const string &);
string rtrim(const string &);
vector<string> split(const string &);

/*
 * Complete the 'connectingTowns' function below.
 *
 * The function is expected to return an INTEGER.
 * The function accepts following parameters:
 *  1. INTEGER n
 *  2. INTEGER_ARRAY routes
 */

int connectingTowns(int n, vector<int> routes) {
 unsigned long long result=1;
 for(int route:routes){
    
    result= (result*route)%1234567;
   
 }
      
      return result; 
}

int main()
{
    ofstream fout(getenv("OUTPUT_PATH"));

    string t_temp;
    getline(cin, t_temp);

    int t = stoi(ltrim(rtrim(t_temp)));

    for (int t_itr = 0; t_itr < t; t_itr++) {
        string n_temp;
        getline(cin, n_temp);

        int n = stoi(ltrim(rtrim(n_temp)));

        string routes_temp_temp;
        getline(cin, routes_temp_temp);

        vector<string> routes_temp = split(rtrim(routes_temp_temp));

        vector<int> routes(n - 1);

        for (int i = 0; i < n - 1; i++) {
            int routes_item = stoi(routes_temp[i]);

            routes[i] = routes_item;
        }

        int result = connectingTowns(n, routes);

        fout << result << "\n";
    }

    fout.close();

    return 0;
}

string ltrim(const string &str) {
    string s(str);

    s.erase(
        s.begin(),
        find_if(s.begin(), s.end(), not1(ptr_fun<int, int>(isspace)))
    );

    return s;
}

string rtrim(const string &str) {
    string s(str);

    s.erase(
        find_if(s.rbegin(), s.rend(), not1(ptr_fun<int, int>(isspace))).base(),
        s.end()
    );

    return s;
}

vector<string> split(const string &str) {
    vector<string> tokens;

    string::size_type start = 0;
    string::size_type end = 0;

    while ((end = str.find(" ", start)) != string::npos) {
        tokens.push_back(str.substr(start, end - start));

        start = end + 1;
    }

    tokens.push_back(str.substr(start));

    return tokens;
}

Leonardo loves primes and created queries where each query takes the form of an integer, . For each , count the maximum number of distinct prime factors of any number in the inclusive range .

Note: Recall that a prime number is only divisible by and itself, and is not a prime number.

Example

The maximum number of distinct prime factors for values less than or equal to is . One value with distinct prime factors is . Another is .

Function Description

Complete the primeCount function in the editor below.

primeCount has the following parameters:

• int n: the inclusive limit of the range to check

Returns

• int: the maximum number of distinct prime factors of any number in the inclusive range .

Input Format

The first line contains an integer, , the number of queries.
Each of the next lines contains a single integer, .

Constraints

Sample Input

6
1
2
3
500
5000
10000000000

Sample Output

0
1
1
4
5
10

Explanation

1. is not prime and its only factor is itself.
2. has prime factor, .
3. The number has prime factor, , has and has prime factors.
4. The product of the first four primes is . While higher value primes may be a factor of some numbers, there will never be more than distinct prime factors for a number in this range.

Solution

#include <bits/stdc++.h>

using namespace std;

string ltrim(const string &);
string rtrim(const string &);

/*
 * Complete the 'primeCount' function below.
 *
 * The function is expected to return an INTEGER.
 * The function accepts LONG_INTEGER n as parameter.
 */

int primeCount(long n) {
vector<int> primes = {2, 3, 5, 7, 11, 13, 17, 19, 23, 29, 31, 37, 41, 43, 47, 53, 59, 61, 67, 71, 73, 79, 83, 89, 97};


  unsigned long long product = 1;
  int count = 0;

  if (n == 1)
  {
    return count;
  }

  for (int prime : primes)
  {
// product of primes 
    product *= (unsigned long long)prime;

// exit conditions
    if (product > n)
      break;
    if (product == n)
    {
      count++;
      break;
    }

    count++;
  }
  return count;
}

int main()
{
    ofstream fout(getenv("OUTPUT_PATH"));

    string q_temp;
    getline(cin, q_temp);

    int q = stoi(ltrim(rtrim(q_temp)));

    for (int q_itr = 0; q_itr < q; q_itr++) {
        string n_temp;
        getline(cin, n_temp);

        long n = stol(ltrim(rtrim(n_temp)));

        int result = primeCount(n);

        fout << result << "\n";
    }

    fout.close();

    return 0;
}

string ltrim(const string &str) {
    string s(str);

    s.erase(
        s.begin(),
        find_if(s.begin(), s.end(), not1(ptr_fun<int, int>(isspace)))
    );

    return s;
}

string rtrim(const string &str) {
    string s(str);

    s.erase(
        find_if(s.rbegin(), s.rend(), not1(ptr_fun<int, int>(isspace))).base(),
        s.end()
    );

    return s;
}

Luke is daydreaming in Math class. He has a sheet of graph paper with rows and columns, and he imagines that there is an army base in each cell for a total of bases. He wants to drop supplies at strategic points on the sheet, marking each drop point with a red dot. If a base contains at least one package inside or on top of its border fence, then it’s considered to be supplied. For example:

Given and , what’s the minimum number of packages that Luke must drop to supply all of his bases?

Example

Packages can be dropped at the corner between cells (0, 0), (0, 1), (1, 0) and (1, 1) to supply bases. Another package can be dropped at a border between (0, 2) and (1, 2). This supplies all bases using packages.

Function Description

Complete the gameWithCells function in the editor below.

gameWithCells has the following parameters:

• int n: the number of rows in the game
• int m: the number of columns in the game

Returns

• int: the minimum number of packages required

Input Format

Two space-separated integers describing the respective values of and .

Constraints

Sample Input 0

2 2

Sample Output 0

1

Explanation 0

Luke has four bases in a grid. If he drops a single package where the walls of all four bases intersect, then those four cells can access the package:

Because he managed to supply all four bases with a single supply drop, we print as our answer.

Solution

#include <bits/stdc++.h>

using namespace std;

string ltrim(const string &);
string rtrim(const string &);
vector<string> split(const string &);

/*
 * Complete the 'gameWithCells' function below.
 *
 * The function is expected to return an INTEGER.
 * The function accepts following parameters:
 *  1. INTEGER n
 *  2. INTEGER m
 */

int gameWithCells(int n, int m) {
    // consider edges and corners of a cell,
    // if we put drops in corner it will be available to 4 adjacent cells
    // if we put in th edge and drag it to corner same case will occur
    // so the intersecting point covers 2 cells horizontally and 2 cells vertically
    // using the unit law we will
    
    return ((n/2)+bool(n%2)) * ((m/2)+bool(m%2)) ;
    // here each droping covers 2 rows and 2 columns as per the above explanation
    // 
}

int main()
{
    ofstream fout(getenv("OUTPUT_PATH"));

    string first_multiple_input_temp;
    getline(cin, first_multiple_input_temp);

    vector<string> first_multiple_input = split(rtrim(first_multiple_input_temp));

    int n = stoi(first_multiple_input[0]);

    int m = stoi(first_multiple_input[1]);

    int result = gameWithCells(n, m);

    fout << result << "\n";

    fout.close();

    return 0;
}

string ltrim(const string &str) {
    string s(str);

    s.erase(
        s.begin(),
        find_if(s.begin(), s.end(), not1(ptr_fun<int, int>(isspace)))
    );

    return s;
}

string rtrim(const string &str) {
    string s(str);

    s.erase(
        find_if(s.rbegin(), s.rend(), not1(ptr_fun<int, int>(isspace))).base(),
        s.end()
    );

    return s;
}

vector<string> split(const string &str) {
    vector<string> tokens;

    string::size_type start = 0;
    string::size_type end = 0;

    while ((end = str.find(" ", start)) != string::npos) {
        tokens.push_back(str.substr(start, end - start));

        start = end + 1;
    }

    tokens.push_back(str.substr(start));

    return tokens;
}

Happy Coding~

https://www.hackerrank.com/challenges/lowest-triangle/problem?isFullScreen=true

Given integers and , find the smallest integer , such that there exists a triangle of height , base , having an area of at least .

Example

The minimum height is . One example is a triangle formed at points (0, 0), (4, 0), (2, 3).

Function Description

Complete the lowestTriangle function in the editor below.

lowestTriangle has the following parameters:

• int b: the base of the triangle
• int a: the minimum area of the triangle

Returns

• int: the minimum integer height to form a triangle with an area of at least

Input Format

There are two space-separated integers and , on a single line.

Constraints

Sample Input 0

2 2

Sample Output 0

2

Explanation 0

The task is to find the smallest integer height of the triangle with base and area at least . It turns out, that there are triangles with height 2, base 2 and area 2, for example a triangle with corners in the following points: :

It can be proved that there is no triangle with integer height smaller than , base and area at least .

Sample Input 1

17 100

Sample Output 1

12

Explanation 1

The task is to find the smallest integer height of the triangle with base 17 and area at least 100 . It turns out, that there are triangles with height 12, base 17and area 102, for example a triangle with corners in the following points: (2,2), (19,2), (16,14).

It can be proved that there is no triangle with integer height smaller than 12, base 17 and area 100 at least .

Solution

#include <bits/stdc++.h>

using namespace std;

string ltrim(const string &);
string rtrim(const string &);
vector<string> split(const string &);

/*
 * Complete the 'lowestTriangle' function below.
 *
 * The function is expected to return an INTEGER.
 * The function accepts following parameters:
 *  1. INTEGER trianglebase
 *  2. INTEGER area
 */

int lowestTriangle(int trianglebase, int area) {
    /*
     here is 
    - formula for triangle area= 1/2 * base * height
    - bool (2*area%trianglebase) this part is for rounding up;
    */
    return (2*area/trianglebase)+bool(2*area%trianglebase);

}

int main()
{
    ofstream fout(getenv("OUTPUT_PATH"));

    string first_multiple_input_temp;
    getline(cin, first_multiple_input_temp);

    vector<string> first_multiple_input = split(rtrim(first_multiple_input_temp));

    int trianglebase = stoi(first_multiple_input[0]);

    int area = stoi(first_multiple_input[1]);

    int height = lowestTriangle(trianglebase, area);

    fout << height << "\n";

    fout.close();

    return 0;
}

string ltrim(const string &str) {
    string s(str);

    s.erase(
        s.begin(),
        find_if(s.begin(), s.end(), not1(ptr_fun<int, int>(isspace)))
    );

    return s;
}

string rtrim(const string &str) {
    string s(str);

    s.erase(
        find_if(s.rbegin(), s.rend(), not1(ptr_fun<int, int>(isspace))).base(),
        s.end()
    );

    return s;
}

vector<string> split(const string &str) {
    vector<string> tokens;

    string::size_type start = 0;
    string::size_type end = 0;

    while ((end = str.find(" ", start)) != string::npos) {
        tokens.push_back(str.substr(start, end - start));

        start = end + 1;
    }

    tokens.push_back(str.substr(start));

    return tokens;
}

At the annual meeting of Board of Directors of Acme Inc. If everyone attending shakes hands exactly one time with every other attendee, how many handshakes are there?

Example

n=3;

There are attendees 3, p1, p2 and p3. p1 shakes hands with p2 and p3 , and p2 shakes hands with p3 . Now they have all shaken hands after 3 handshakes.

Function Description

Complete the handshakes function in the editor below.

handshakes has the following parameter:

• int n: the number of attendees

Returns

• int: the number of handshakes

Input Format
The first line contains the number of test cases .
Each of the following lines contains an integer, .

Constraints

1 ≤ t ≤ 1000

0 < n < 10e6

Sample Input

2
1
2

Sample Output

0
1

Explanation

Case 1 : The lonely board member shakes no hands, hence 0.
Case 2 : There are 2 board members, so 1 handshake takes place.

Solution

#include <bits/stdc++.h>

using namespace std;

string ltrim(const string &);
string rtrim(const string &);

/*
 * Complete the 'handshake' function below.
 *
 * The function is expected to return an INTEGER.
 * The function accepts INTEGER n as parameter.
 */

int handshake(int n) {
    /* n!/r!(n-r)! finding ncr (combinations) if normalized
     
    n!/2!(n-2)!
    n(n-1)(n-2)!/(n-2)!2!
    n(n-1)/2!
    n(n-1)/2 (as factorial of 2 is 2*1==2)
    */
return n*(n-1)/2;
}

int main()
{
    ofstream fout(getenv("OUTPUT_PATH"));

    string t_temp;
    getline(cin, t_temp);

    int t = stoi(ltrim(rtrim(t_temp)));

    for (int t_itr = 0; t_itr < t; t_itr++) {
        string n_temp;
        getline(cin, n_temp);

        int n = stoi(ltrim(rtrim(n_temp)));

        int result = handshake(n);

        fout << result << "\n";
    }

    fout.close();

    return 0;
}

string ltrim(const string &str) {
    string s(str);

    s.erase(
        s.begin(),
        find_if(s.begin(), s.end(), not1(ptr_fun<int, int>(isspace)))
    );

    return s;
}

string rtrim(const string &str) {
    string s(str);

    s.erase(
        find_if(s.rbegin(), s.rend(), not1(ptr_fun<int, int>(isspace))).base(),
        s.end()
    );

    return s;
}

https://www.hackerrank.com/challenges/find-point/problem?isFullScreen=true

Consider two points , and . We consider the inversion or point reflection, , of point across point to be a rotation of point around .

Given sets of points and , find for each pair of points and print two space-separated integers denoting the respective values of and on a new line.

Function Description

Complete the findPoint function in the editor below.

findPoint has the following parameters:

• int px, py, qx, qy: x and y coordinates for points and

Returns

• int[2]: x and y coordinates of the reflected point

Input Format

The first line contains an integer, , denoting the number of sets of points.
Each of the subsequent lines contains four space-separated integers that describe the respective values of , , , and defining points and .

Constraints

Sample Input

2
0 0 1 1
1 1 2 2

Sample Output

2 2
3 3

Explanation

The graphs below depict points , , and for the points given as Sample Input:

Solution

#include <bits/stdc++.h>

using namespace std;

string ltrim(const string &);
string rtrim(const string &);
vector<string> split(const string &);

/*
 * Complete the 'findPoint' function below.
 *
 * The function is expected to return an INTEGER_ARRAY.
 * The function accepts following parameters:
 *  1. INTEGER px
 *  2. INTEGER py
 *  3. INTEGER qx
 *  4. INTEGER qy
 */

/*
*    explanation
*    p`x-qx = qx-px; // 180 degree to the point of px to qx is p`x
*    p`y-qy = qy-py; // 180 degree to the point of py to qy is p`y
*/
vector<int> findPoint(int px, int py, int qx, int qy) {
vector<int> r;
int value1,value2;
value1= 2*qx-px;
value2= 2*qy-py;

r.push_back(value1);
r.push_back(value2);

return r;
}

int main()
{
    ofstream fout(getenv("OUTPUT_PATH"));

    string n_temp;
    getline(cin, n_temp);

    int n = stoi(ltrim(rtrim(n_temp)));

    for (int n_itr = 0; n_itr < n; n_itr++) {
        string first_multiple_input_temp;
        getline(cin, first_multiple_input_temp);

        vector<string> first_multiple_input = split(rtrim(first_multiple_input_temp));

        int px = stoi(first_multiple_input[0]);

        int py = stoi(first_multiple_input[1]);

        int qx = stoi(first_multiple_input[2]);

        int qy = stoi(first_multiple_input[3]);

        vector<int> result = findPoint(px, py, qx, qy);

        for (size_t i = 0; i < result.size(); i++) {
            fout << result[i];

            if (i != result.size() - 1) {
                fout << " ";
            }
        }

        fout << "\n";
    }

    fout.close();

    return 0;
}

string ltrim(const string &str) {
    string s(str);

    s.erase(
        s.begin(),
        find_if(s.begin(), s.end(), not1(ptr_fun<int, int>(isspace)))
    );

    return s;
}

string rtrim(const string &str) {
    string s(str);

    s.erase(
        find_if(s.rbegin(), s.rend(), not1(ptr_fun<int, int>(isspace))).base(),
        s.end()
    );

    return s;
}

vector<string> split(const string &str) {
    vector<string> tokens;

    string::size_type start = 0;
    string::size_type end = 0;

    while ((end = str.find(" ", start)) != string::npos) {
        tokens.push_back(str.substr(start, end - start));

        start = end + 1;
    }

    tokens.push_back(str.substr(start));

    return tokens;
}