Merge pull request #122 from sir-gon/hackerrank

Hackerrank

Author: sir-gon

docs/hackerrank/warmup/aVeryBigSum.md

@@ -0,0 +1,55 @@
+# [A Very Big Sum](https://www.hackerrank.com/challenges/a-very-big-sum)
+
+Difficulty: #easy
+Category: #warmup
+
+In this challenge, you are required to calculate and print the
+sum of the elements in an array, keeping in mind that some of
+those integers may be quite large.
+
+## Function Description
+
+Complete the aVeryBigSum function in the editor below.
+It must return the sum of all array elements.
+
+aVeryBigSum has the following parameter(s):
+
+- int ar[n]: an array of integers.
+
+## Return
+
+- long: the sum of all array elements
+
+## Input Format
+
+The first line of the input consists of an integer n.
+The next line contains  space-separated integers contained in the array.
+
+## Output Format
+
+Return the integer sum of the elements in the array.
+
+## Constraints
+
+$ 1 <= n < 10 $ \
+$ 0 <= ar[i] <= 10^10 $
+
+## Sample Input
+
+```text
+5
+1000000001 1000000002 1000000003 1000000004 1000000005
+```
+
+## Output
+
+```text
+5000000015
+```
+
+## Note
+
+The range of the 32-bit integer is
+($ -2^31 $) to ($ 2^31 - 1 $) or $ [-2147483648, 2147483647] $
+When we add several integer values, the resulting sum might exceed the
+above range. You might need to use long int C/C++/Java to store such sums.

docs/hackerrank/warmup/compareTriplets.md

@@ -0,0 +1,104 @@
+# [Compare the Triplets](https://www.hackerrank.com/challenges/compare-the-triplets)
+
+Difficulty: #easy
+Category: #warmup
+
+Alice and Bob each created one problem for HackerRank. A reviewer rates the two
+challenges, awarding points on a scale from 1 to 100 for three categories:
+problem clarity, originality, and difficulty.
+The rating for Alice's challenge is the triplet $ a = (a[0], a[1], a[2]) $,
+and the rating for Bob's challenge is the triplet $ b = (b[0], b[1], b[2]) $.
+
+The task is to find their comparison points by comparing $ a[0] $ with
+$ b[0] $, $ a[1] $ with $ b[1] $, and $ a[2] $ with $ b[2] $.
+
+- If $ a[i] > b[i] $, then Alice is awarded $ 1 $ point.
+- If $ a[i] < b[i] $, then Bob is awarded $ 1 $ point.
+- If $ a[i] = b[i] $, then neither person receives a point.
+
+Comparison points is the total points a person earned.
+Given a and b, determine their respective comparison points.
+
+## Example
+
+$ a = [1, 2, 3] $ \
+$ b = [3, 2, 1] $
+
+- For elements \*0\*, Bob is awarded a point because $ a[0] $.
+- For the equal elements $ a[1] $ and $ b[1] $, no points are earned.
+- Finally, for elements $ 2 $, $ a[2] > b[2] $ so Alice receives a point.
+
+The return array is $ [1, 1] $ with Alice's score first and Bob's second.
+
+## Function Description
+
+Complete the function compareTriplets in the editor below.
+compareTriplets has the following parameter(s):
+
+- int a[3]: Alice's challenge rating
+- int b[3]: Bob's challenge rating
+
+## Return
+
+- int[2]: Alice's score is in the first position, and Bob's score is in the second.
+
+## Input Format
+
+The first line contains 3 space-separated integers, $ a[0] $, $ a[1] $, and
+$ a[2] $, the respective values in triplet a.
+The second line contains 3 space-separated integers, $ b[0] $, $ b[1] $, and
+$ b[2] $, the respective values in triplet b.
+
+## Constraints
+
+- $ 1 \leq a[i] \leq 100 $
+- $ 1 \leq b[i] \leq 100 $
+
+## Sample Input 0
+
+```text
+5 6 7
+3 6 10
+```
+
+## Sample Output 0
+
+```text
+1 1
+```
+
+## Explanation 0
+
+In this example:
+
+- $ a = (a[0], a[1], a[2]) = (5, 6, 7) $
+- $ b = (b[0], b[1], b[2]) = (3, 6, 10) $
+
+Now, let's compare each individual score:
+
+- $ a[0] > b[0] $, so Alice receives $ 1 $ point. \
+- $ a[1] = b[1] $, so nobody receives a point. \
+- $ a[2] < b[2] $, so Bob receives $ 1 $ point.
+
+Alice's comparison score is $ 1 $, and Bob's comparison score is $ 1 $.
+Thus, we return the array $ [1, 1] $.
+
+## Sample Input 1
+
+```text
+17 28 30
+99 16 8
+```
+
+## Sample Output 1
+
+```text
+2 1
+```
+
+## Explanation 1
+
+Comparing the *0th* elements, $ 17 < 99 $ so Bob receives a point.
+Comparing the *1st* and *2nd* elements $ 28 > 16 $ and $ 30 > 8 $ so Alice
+ receives two points.
+The return array is $ [2, 1] $.

docs/hackerrank/warmup/diagonalDifference.md

@@ -0,0 +1,86 @@
+# [Diagonal Difference](https://www.hackerrank.com/challenges/diagonal-difference)
+
+Difficulty: #easy
+Category: #warmup
+
+Given a square matrix, calculate the absolute difference between the sums
+of its diagonals.
+For example, the square matrix $ arr $ is shown below:
+
+```text
+1 2 3
+4 5 6
+9 8 9
+```
+
+The left-to-right $ diagonal = 1 + 5 + 9 = 15 $.
+The right to left $ diagonal = 3 + 5 + 9 = 17 $.
+Their absolute difference is $ |15 - 17| = 2 $.
+
+## Function description
+
+Complete the $ diagonalDifference $ function in the editor below.
+diagonalDifference takes the following parameter:
+
+- int ` arr[n][m] `: an array of integers
+
+## Return
+
+- int: the absolute diagonal difference
+
+## Input Format
+
+The first line contains a single integer, n, the number of
+rows and columns in the square matrix arr.
+Each of the next n lines describes a row, arr[i], and consists of
+space-separated integers ` arr[i][j] `.
+
+## Constraints
+
+$ -100 \leq $ ` arr[i][j] ` $ \leq 100 $
+
+## Output Format
+
+Return the absolute difference between the sums of the matrix's
+two diagonals as a single integer.
+
+## Sample Input
+
+```text
+3
+11 2 4
+4 5 6
+10 8 -12
+```
+
+Sample Output
+
+```text
+15
+```
+
+## Explanation
+
+The primary diagonal is:
+
+```text
+11
+   5
+     -12
+```
+
+Sum across the primary diagonal: 11 + 5 - 12 = 4
+The secondary diagonal is:
+
+```text
+     4
+   5
+10
+```
+
+Sum across the secondary diagonal: $ 4 + 5 + 10 = 19 $
+Difference: $ |4 - 19| = 15 $
+
+*Note*: $ |x| $ is the
+[absolute value](https://www.mathsisfun.com/numbers/absolute-value.html)
+of $ x $

docs/hackerrank/warmup/miniMaxSum.md

@@ -0,0 +1,70 @@
+# [Mini-Max Sum](https://www.hackerrank.com/challenges/mini-max-sum)
+
+Difficulty: #easy
+Category: #warmup
+
+Given five positive integers, find the minimum and maximum values
+that can be calculated by summing exactly four of the five integers.
+Then print the respective minimum and maximum values as a single line
+of two space-separated long integers.
+
+## Example
+
+$ arr = [1, 3, 5, 7, 9] $
+The minimum sum is $ 1 + 3 + 5 + 7 = 16 $ and the maximum sum
+is $ 3 + 5 + 7 + 9 = 24 $. The function prints
+
+```text
+16 24
+```
+
+## Function Description
+
+Complete the miniMaxSum function in the editor below.
+miniMaxSum has the following parameter(s):
+
+- arr: an array of $ 5 $ integers
+
+## Print
+
+Print two space-separated integers on one line: the minimum sum and
+the maximum sum of 4 of 5 elements.
+
+## Input Format
+
+A single line of five space-separated integers.
+
+## Constraints
+
+$ 1 \leq arra[i] \leq 10^9 $
+
+## Output Format
+
+Print two space-separated long integers denoting the respective minimum
+and maximum values that can be calculated by summing exactly four of the
+five integers. (The output can be greater than a 32 bit integer.)
+
+## Sample Input
+
+```text
+1 2 3 4 5
+```
+
+## Sample Output
+
+```text
+10 14
+```
+
+## Explanation
+
+The numbers are $ 1, 2, 3, 4, $ and $ 5 $. Calculate the following sums using
+four of the five integers:
+
+1. Sum everything except $ 1 $, the sum is $ 2 + 3 + 4 + 5 = 14 $.
+2. Sum everything except $ 2 $, the sum is $ 1 + 3 + 4 + 5 = 13 $.
+3. Sum everything except $ 3 $, the sum is $ 1 + 2 + 4 + 5 = 12 $.
+4. Sum everything except $ 4 $, the sum is $ 1 + 2 + 3 + 5 = 11 $.
+5. Sum everything except $ 5 $, the sum is $ 1 + 2 + 3 + 4 = 10 $.
+
+**Hints**: Beware of integer overflow! Use 64-bit Integer.

docs/hackerrank/warmup/plusMinus.md

@@ -0,0 +1,80 @@
+# [Plus Minus](https://www.hackerrank.com/challenges/plus-minus)
+
+Difficulty: #easy
+Category: #warmup
+
+Given an array of integers, calculate the ratios of its elements
+that are positive, negative, and zero. Print the decimal value of
+each fraction on a new line with 6 places after the decimal.
+
+**Note**: This challenge introduces precision problems.
+The test cases are scaled to six decimal places, though answers
+with absolute error of up to $ 10^{-4} $ are acceptable.
+
+## Example
+
+$ arr = [1, 1, 0, -1, -1] $
+
+There are $ n = 5 $ elements, two positive, two negative and one zero.
+Their ratios are $ 2/5 = 0.400000 $, $ 2/5 = 0.400000 $ and $ 1/5 = 0.200000 $.
+Results are printed as:
+
+```text
+0.400000
+0.400000
+0.200000
+```
+
+## Function Description
+
+Complete the plusMinus function in the editor below.
+plusMinus has the following parameter(s):
+
+- int arr[n]: an array of integers
+
+## Print
+
+Print the ratios of positive, negative and zero values in the array.
+Each value should be printed on a separate line with $ 6 $ digits after
+the decimal. The function should not return a value.
+
+## Input Format
+
+The first line contains an integer, `n`, the size of the array.
+The second line contains `n` space-separated integers that describe `arr[n]`.
+
+## Constraints
+
+$ 0 < n \leq 100 $ \
+$ -100 \leq arr[i] \leq 100 $
+
+## Output Format
+
+**Print** the following  lines, each to  decimals:
+
+1. proportion of positive values
+2. proportion of negative values
+3. proportion of zeros
+
+## Sample Input
+
+```text
+STDIN           Function
+-----           --------
+6               arr[] size n = 6
+-4 3 -9 0 4 1   arr = [-4, 3, -9, 0, 4, 1]
+```
+
+## Sample Output
+
+```text
+0.500000
+0.333333
+0.166667
+```
+
+## Explanation
+
+There are $ 3 $ positive numbers, negative numbers, and $ 1 $ zero in the array.
+The proportions of occurrence are positive: $ 3/6 = 0.500000 $,
+negative: $ 2/6 = 0.333333 $ and zeros: $ 1/6 = 0.166667 $.