add index.md to each challenge, ts types refactoring

Author: Jakub Jirous

.github/labeler.yml

@@ -0,0 +1,2 @@
+code-challenge:
+  - any: ["src/**/*.ts"]

.github/pull_request_template.md

@@ -0,0 +1,27 @@
+## NAME
+
+- [Problem Description @ Code Signal](URL)
+
+---
+
+### PR Checklist:
+
+- [ ] Understand the problem
+  - You know what is known
+  - You know what is unknown
+  - You thought throw some edge cases that could potentially happen  
+- [ ] Devise a plan
+  - Writing a comment to code challenge what you want to do
+  - Showing the ability to take that problem and break it down to the parts
+  - Take the larger problem and take it down into smaller problems
+- [ ] Execute the plan
+  - Turning into an actual code
+- [ ] Review your solution
+  - Time to consider if there were a better approach
+  - Backwards realizing room for improvements
+- [ ] Unit test
+  - Cover your result with appropriate assertions
+
+---
+
+@octocat :+1: This PR looks great - it's ready to merge! :shipit:

.github/workflows/labeler.yml

@@ -0,0 +1,18 @@
+name: "Pull Request Labeler"
+
+on:
+  - pull_request_target
+
+jobs:
+  triage:
+    name: "Labeler"
+    permissions:
+      contents: read
+      pull-requests: write
+
+    runs-on: ubuntu-latest
+
+    steps:
+      - uses: actions/labeler@v4
+        with:
+          repo-token: "${{ secrets.GITHUB_TOKEN }}"

README.md

@@ -12,6 +12,7 @@ In preparation for technical interviews, I discovered this platform that provide
 
 <p align="center">
     <img src="https://sonarcloud.io/api/project_badges/measure?project=jakubjirous_code-signal&metric=coverage" alt="Coverage">
+    <img src="https://sonarcloud.io/api/project_badges/measure?project=jakubjirous_code-signal&metric=code_smells" alt="Code Smells">    
     <img src="https://sonarcloud.io/api/project_badges/measure?project=jakubjirous_code-signal&metric=ncloc" alt="Lines of Code">
 </p>
 
@@ -23,16 +24,16 @@ In preparation for technical interviews, I discovered this platform that provide
 
 #### The Journey Begins
 
-1) [Add](/src/arcade/intro/01-add/)
-2) [Century From Year](/src/arcade/intro/02-century-from-year/)
-3) [Check Palindrome](/src/arcade/intro/03-check-palindrome/)
+1) [Add](/src/arcade/intro/01-add/INDEX.md)
+2) [Century From Year](/src/arcade/intro/02-century-from-year/INDEX.md)
+3) [Check Palindrome](/src/arcade/intro/03-check-palindrome/INDEX.md)
 
 #### Edge Of The Ocean
 
-4) [Adjacent Elements Product](/src/arcade/intro/04-adjacent-elements-product/)
-5) [Shape Area](/src/arcade/intro/05-shape-area/)
-6) [Make Array Consecutive](/src/arcade/intro/06-make-array-consecutive/)
-7) [Almost Increasing Sequence](/src/arcade/07-almost-increasing-sequence/)
+4) [Adjacent Elements Product](/src/arcade/intro/04-adjacent-elements-product/INDEX.md)
+5) [Shape Area](/src/arcade/intro/05-shape-area/INDEX.md)
+6) [Make Array Consecutive](/src/arcade/intro/06-make-array-consecutive/INDEX.md)
+7) [Almost Increasing Sequence](/src/arcade/intro/07-almost-increasing-sequence/INDEX.md)
 
 ---
 

src/arcade/intro/01-add/INDEX.md

@@ -0,0 +1,34 @@
+# Add
+
+Write a function that returns the sum of two numbers.
+
+---
+
+### Example:
+
+- For `param1 = 1` and `param2 = 2`, the output should be `solution(param1, param2) = 3`.
+
+### Input/Output:
+
+- **[execution time limit]** 5 seconds (ts)
+
+
+- **[input]** integer `param1`
+  - Guaranteed constraints:
+    - $-1000 \le param1 \le 1000$
+
+
+- **[input]** integer `param2`
+  - Guaranteed constraints:
+    - $-1000 \le param2 \le 1000$
+
+
+- **[output]** integer
+  - The sum of the two inputs.
+
+---
+
+### Solution:
+
+- [Code](/src/arcade/intro/01-add/add.ts)
+- [Tests](/src/arcade/intro/01-add/test/add.test.ts)

src/arcade/intro/01-add/add.ts

@@ -1,9 +1,13 @@
+export type Param1 = number;
+export type Param2 = number;
+export type Output = number;
+
 /**
  * Write a function that returns the sum of two numbers.
  *
  * Example:
  * - for param1 = 1 and param2 = 2, the output should be solution(param1, param2) = 3
  */
-export const add = (param1: number, param2: number): number => {
+export const add = (param1: Param1, param2: Param2): Output => {
   return param1 + param2;
 };

src/arcade/intro/01-add/test/add.test.ts

@@ -1,9 +1,6 @@
-import { add } from "../add";
+import { add, Output, Param1, Param2 } from '../add';
 
-type FirstArg = number;
-type SecondArg = number;
-type ExpectedResult = number;
-type Cases = [FirstArg, SecondArg, ExpectedResult][];
+type Cases = [Param1, Param2, Output][];
 
 /**
  * Testing a function that returns the sum of two numbers.

src/arcade/intro/02-century-from-year/INDEX.md

@@ -0,0 +1,33 @@
+# Century From Year
+
+Given a year, return the century it is in. 
+
+The first century spans from the year 1 up to and including the year 100, the second - from the year 101 up to and including the year 200, etc.
+
+---
+
+### Example:
+
+- For `year = 1905`, the output should be `centuryFromYear(year) = 20`
+- For `year = 1700`, the output should be `centuryFromYear(year) = 17`
+
+### Input/Output:
+
+- **[execution time limit]** 5 seconds (ts)
+
+
+- **[input]** integer `year`
+  - A positive integer, designating the year.
+  - Guaranteed constraints:
+    - $1 \le year \le 2005$
+ 
+
+- **[output]** integer
+  - The number of the century the year is in.
+
+---
+
+### Solution:
+
+- [Code](/src/arcade/intro/02-century-from-year/century-from-year.ts)
+- [Tests](/src/arcade/intro/02-century-from-year/test/century-from-year.test.ts)

src/arcade/intro/02-century-from-year/century-from-year.ts

@@ -1,9 +1,12 @@
+export type Input = number;
+export type Output = number;
+
 /**
  * Given a year, return the century it is in.
  * The first century spans from the year 1 up to and including the year 100,
  * the second - from the year 101 up to and including the year 200, etc.
  * @param year
  */
-export const centuryFromYear = (year: number): number => {
+export const centuryFromYear = (year: Input): Output => {
   return Math.ceil(year / 100);
 };

src/arcade/intro/02-century-from-year/test/century-from-year.test.ts

@@ -1,8 +1,6 @@
-import { centuryFromYear } from "../century-from-year";
+import { centuryFromYear, Input, Output } from '../century-from-year';
 
-type FirstArg = number;
-type ExpectedResult = number;
-type Cases = [FirstArg, ExpectedResult][];
+type Cases = [Input, Output][];
 
 /**
  * Given a year, return the century it is in.

src/arcade/intro/03-check-palindrome/INDEX.md

@@ -0,0 +1,33 @@
+# Check Palindrome
+
+Given the string, check if it is a palindrome.
+
+---
+
+### Example:
+
+- For `inputString = "aabaa"`, the output should be `checkPalindrome(inputString) = true`
+- For `inputString = "abac"`, the output should be `checkPalindrome(inputString) = false`
+- For `inputString = "a"`, the output should be `checkPalindrome(inputString) = true`
+
+### Input/Output:
+
+- **[execution time limit]** 5 seconds (ts)
+
+
+- **[input]** string `inputString`
+  - A non-empty string consisting of lowercase characters.
+  - Guaranteed constraints:
+    - $1 \le inputString.length \le 10^{5}$
+ 
+
+- **[output]** boolean
+  - `true` if `inputString` is a palindrome
+  - `false` otherwise
+
+---
+
+### Solution:
+
+- [Code](/src/arcade/intro/03-check-palindrome/check-palindrome.ts)
+- [Tests](/src/arcade/intro/03-check-palindrome/test/check-palindrome.test.ts)

src/arcade/intro/03-check-palindrome/check-palindrome.ts

@@ -1,7 +1,10 @@
+export type Input = string;
+export type Output = boolean;
+
 /**
  * Given the string, check if it is a palindrome.
  * @param inputString
  */
-export const checkPalindrome = (inputString: string): boolean => {
+export const checkPalindrome = (inputString: Input): Output => {
   return inputString === [...inputString].reverse().join("");
 };

src/arcade/intro/03-check-palindrome/test/check-palindrome.test.ts

@@ -1,8 +1,6 @@
-import { checkPalindrome } from "../check-palindrome";
+import { checkPalindrome, Input, Output } from '../check-palindrome';
 
-type FirstArg = string;
-type ExpectedResult = boolean;
-type Cases = [FirstArg, ExpectedResult][];
+type Cases = [Input, Output][];
 
 /**
  * Test if it is a palindrome.

src/arcade/intro/04-adjacent-elements-product/INDEX.md

@@ -0,0 +1,32 @@
+# Adjacent Elements Product
+
+Given an array of integers, find the pair of adjacent elements that has the largest product and return that product.
+
+---
+
+### Example:
+
+- For `inputArray = [3, 6, -2, -5, 7, 3]`, the output should be `adjacentElementsProduct(inputArray) = 21`.
+- `7` and `3` produce the largest product.
+
+### Input/Output:
+
+- **[execution time limit]** 5 seconds (ts)
+
+
+- **[input]** array.integer `inputArray`
+  - An array of integers containing at least two elements.
+  - Guaranteed constraints:
+    - $2 \le inputArray.length \le 10$
+    - $-100 \le inputArray[i] \le 1000$
+ 
+
+- **[output]** integer
+  - The largest product of adjacent elements.
+
+---
+
+### Solution:
+
+- [Code](/src/arcade/intro/04-adjacent-elements-product/adjacent-elements-product.ts)
+- [Tests](/src/arcade/intro/04-adjacent-elements-product/test/adjacent-elements-product.test.ts)

src/arcade/intro/04-adjacent-elements-product/adjacent-elements-product.ts

@@ -1,10 +1,13 @@
+export type Input = number[];
+export type Output = number;
+
 /**
  * Given an array of integers, find the pair of adjacent elements that has the largest product and return that product.
- * @param input
+ * @param inputArray
  */
-export const adjacentElementsProduct = (input: number[]): number => {
-  return input.reduce((acc, value, index, arr) => {
-    const nextCase = value * arr[index - 1];
+export const adjacentElementsProduct = (inputArray: Input): Output => {
+  return inputArray.reduce((acc, value, index, array) => {
+    const nextCase = value * array[index - 1];
     return nextCase > acc ? (acc = nextCase) : acc;
   }, Number.NEGATIVE_INFINITY);
 };

src/arcade/intro/04-adjacent-elements-product/test/adjacent-elements-product.test.ts

@@ -1,8 +1,6 @@
-import { adjacentElementsProduct } from "../adjacent-elements-product";
+import { adjacentElementsProduct, Input, Output } from '../adjacent-elements-product';
 
-type FirstArg = number[];
-type ExpectedResult = number;
-type Cases = [FirstArg, ExpectedResult][];
+type Cases = [Input, Output][];
 
 /**
  * Given an array of integers, test the pair of adjacent elements that has the largest product and return that product.

src/arcade/intro/05-shape-area/INDEX.md

@@ -0,0 +1,35 @@
+# Shape Area
+
+We will define an `n`-interesting polygon. 
+
+Your task is to find the area of a polygon for a given `n`.
+
+A `1`-interesting polygon is just a square with a side of length `1`.  
+An `n`-interesting polygon is obtained by taking the `n - 1`-interesting polygon and appending `1`-interesting polygons to its rim, side by side.
+
+---
+
+### Example:
+
+- For `n = 2`, the output should be `shapeArea(n) = 5`
+- For `n = 3`, the output should be `shapeArea(n) = 13`
+
+### Input/Output:
+
+- **[execution time limit]** 5 seconds (ts)
+
+
+- **[input]** integer `n`
+  - Guaranteed constraints:
+    - $1 \le n \le 10^{4}$
+ 
+
+- **[output]** integer
+  - The area of the `n`-interesting polygon.
+
+---
+
+### Solution:
+
+- [Code](/src/arcade/intro/05-shape-area/shape-area.ts)
+- [Tests](/src/arcade/intro/05-shape-area/test/shape-area.test.ts)

src/arcade/intro/05-shape-area/shape-area.ts

@@ -1,3 +1,6 @@
+export type Input = number;
+export type Output = number;
+
 /**
  * Below we will define an n-interesting polygon.
  * Your task is to find the area of a polygon for a given n.
@@ -8,4 +11,4 @@
  *
  * @param n
  */
-export const shapeArea = (n: number): number => n * n + (n - 1) * (n - 1);
+export const shapeArea = (n: Input): Output => n * n + (n - 1) * (n - 1);

src/arcade/intro/05-shape-area/test/shape-area.test.ts

@@ -1,8 +1,6 @@
-import { shapeArea } from "../shape-area";
+import { Input, Output, shapeArea } from '../shape-area';
 
-type FirstArg = number;
-type ExpectedResult = number;
-type Cases = [FirstArg, ExpectedResult][];
+type Cases = [Input, Output][];
 
 /**
  * Test the area of a polygon for a given n.