Merge pull request #3 from marcode24/challenges

feat: add josephus-survivor solution

Author: marcode24

codewars/arrays-similar/README.md

@@ -0,0 +1,18 @@
+# Arrays Similar
+
+## Description
+
+Write a function that determines whether the passed in sequences are similar. Similar means they contain the same elements, and the same number of ocurrences of elements.
+
+```js
+var arr1 = [1, 2, 2, 3, 4],
+    arr2 = [2, 1, 2, 4, 3],
+    arr3 = [1, 2, 3, 4],
+    arr4 = [1, 2, 3, '4']
+```
+
+```js
+arraysSimilar(arr1, arr2); // should equal true
+arraysSimilar(arr2, arr3); // should equal false
+arraysSimilar(arr3, arr4); // should equal false
+```

codewars/arrays-similar/solution.js

@@ -0,0 +1,10 @@
+const arraysSimilar = (arr1, arr2) => {
+  if (arr1.length !== arr2.length) {
+    return false;
+  }
+  arr1 = arr1.sort((a, b) => a - b);
+  arr2 = arr2.sort((a, b) => a - b);
+  return arr1.every((el, index) => el === arr2[index]);
+};
+
+module.exports = arraysSimilar;

codewars/arrays-similar/solution.test.js

@@ -0,0 +1,34 @@
+const arraysSimilar = require('./solution');
+
+describe('Arrays Similar', () => {
+  const testCases = [
+    {
+      input: [[1, 2, 3, 4, 5], [2, 3, 4, 1, 5]],
+      output: true,
+    },
+    {
+      input: [[1, 2, 3, 4, 5, 6, 7, 8, 9, 0], [5, 2, 3, 4, 7, 8, 9, 1, 0, 6]],
+      output: true,
+    },
+    {
+      input: [[1, 2, 3, '4', 5], [2, 3, 4, '1', 5]],
+      output: false,
+    },
+    {
+      input: [[1, 2, 3, '3', 5], [2, 3, 4, '1', 5]],
+      output: false,
+    },
+    {
+      input: [[2, 3], [1, 2, 4]],
+      output: false,
+    },
+  ];
+
+  it('should return a boolean type', () => {
+    expect(typeof arraysSimilar([1, 2], [2, 1])).toBe('boolean');
+  });
+
+  it.each(testCases)('should return $output', (testCase) => {
+    expect(arraysSimilar(...testCase.input)).toBe(testCase.output);
+  });
+});

codewars/chasers-schedule/README.md

@@ -0,0 +1,50 @@
+# Chasers Schedule
+
+## Description
+
+A runner, who runs with base speed s with duration t will cover a distances d: d = s * t
+However, this runner can sprint for one unit of time with double speed s * 2
+After sprinting, base speed s will permanently reduced by 1, and for next one unit of time runner will enter recovery phase and can't sprint again.
+
+Your task, given base speed s and time t, is to find the maximum possible distance d.
+
+Input:
+1 <= s < 1000
+1 <= t < 1000
+
+Example:
+Given s = 2 and t = 4.
+We could schedule when runner should sprint so we could get these possible sequences:
+
+```txt
+Seq.: RRRR
+=> s + s + s + s
+=> 2 + 2 + 2 + 2 = 8
+Seq.: RRRS
+=> s + s + s + s*2
+=> 2 + 2 + 2 + 2*2 = 10
+Seq.: RRSR
+=> s + s + s*2 + (s-1)
+=> 2 + 2 + 2*2 + (2-1) = 9
+Seq.: RSRR
+=> s + s*2 + (s-1) + (s-1)
+=> 2 + 2*2 + (2-1) + (2-1) = 8
+Seq.: RSRS
+=> s + s*2 + (s-1) + (s-1)*2
+=> 2 + 2*2 + (2-1) + (2-1)*2 = 9
+Seq.: SRRR
+=> s*2 + (s-1) + (s-1) + (s-1)
+=> 2*2 + (2-1) + (2-1) + (2-1) = 7
+Seq.: SRRS
+=> s*2 + (s-1) + (s-1) + (s-1)*2
+=> 2*2 + (2-1) + (2-1) + (2-1)*2 = 8
+Seq.: SRSR
+=> s*2 + (s-1) + (s-1)*2 + (s-1-1)
+=> 2*2 + (2-1) + (2-1)*2 + (2-1-1) = 7
+```
+
+Where:
+- R: Normal Run / Recovery
+- S: Sprint
+Based on above sequences, the maximum possible distance d is 10.
+

codewars/chasers-schedule/solution.js

@@ -0,0 +1,13 @@
+function chaserSchedule(speed, time) {
+  let distance = speed * time;
+  const maxSprints = Math.ceil(time / 2);
+
+  for (let i = 0; i < maxSprints; i++) {
+    if (speed - 3 * i > 0) {
+      distance += speed - 3 * i;
+    }
+  }
+  return distance;
+}
+
+module.exports = chaserSchedule;

codewars/chasers-schedule/solution.test.js

@@ -0,0 +1,31 @@
+const chaserSchedule = require('./solution');
+
+describe('Chasers Schedule', () => {
+  const testCases = [
+    {
+      input: [2, 4],
+      expected: 10,
+    },
+    {
+      input: [1, 1],
+      expected: 2,
+    },
+    {
+      input: [829, 135],
+      expected: 161453,
+    },
+    {
+      input: [742, 775],
+      expected: 667182,
+    },
+  ];
+
+  it('should return a number type', () => {
+    expect(typeof chaserSchedule(1, 1)).toBe('number');
+  });
+
+  it.each(testCases)('should return $output', (testCase) => {
+    const { input, expected } = testCase;
+    expect(chaserSchedule(...input)).toBe(expected);
+  });
+});

codewars/consecutive-strings/README.md

@@ -0,0 +1,32 @@
+# Consecutive Strings
+
+## Description
+
+You are given an array(list) strarr of strings and an integer k. Your task is to return the first longest string consisting of k consecutive strings taken in the array.
+
+Examples:
+
+```txt
+strarr = ["tree", "foling", "trashy", "blue", "abcdef", "uvwxyz"], k = 2
+
+Concatenate the consecutive strings of strarr by 2, we get:
+
+treefoling   (length 10)  concatenation of strarr[0] and strarr[1]
+folingtrashy ("      12)  concatenation of strarr[1] and strarr[2]
+trashyblue   ("      10)  concatenation of strarr[2] and strarr[3]
+blueabcdef   ("      10)  concatenation of strarr[3] and strarr[4]
+abcdefuvwxyz ("      12)  concatenation of strarr[4] and strarr[5]
+
+Two strings are the longest: "folingtrashy" and "abcdefuvwxyz".
+The first that came is "folingtrashy" so 
+longest_consec(strarr, 2) should return "folingtrashy".
+
+In the same way:
+longest_consec(["zone", "abigail", "theta", "form", "libe", "zas", "theta", "abigail"], 2) --> "abigailtheta"
+```
+
+n being the length of the string array, if n = 0 or k > n or k <= 0 return "" (return Nothing in Elm, "nothing" in Erlang).
+
+Note
+
+consecutive strings : follow one after another without an interruption

codewars/consecutive-strings/solution.js

@@ -0,0 +1,16 @@
+const longestConsec = (strarr, k) => {
+  if (k <= 0 || k > strarr.length) {
+    return '';
+  }
+  let longestWord = '';
+  let longestWordTemp = '';
+  for (let i = 0; i <= strarr.length - k; i++) {
+    longestWordTemp = strarr.slice(i, i + k).join('');
+    if (longestWordTemp.length > longestWord.length) {
+      longestWord = longestWordTemp;
+    }
+  }
+  return longestWord;
+};
+
+module.exports = longestConsec;

codewars/consecutive-strings/solution.test.js

@@ -0,0 +1,48 @@
+const longestConsec = require('./solution');
+
+describe('Consecutive Strings', () => {
+  const testCases = [
+    {
+      input: ['zone', 'abigail', 'theta', 'form', 'libe', 'zas'],
+      k: 2,
+      output: 'abigailtheta',
+    },
+    {
+      input: ['ejjjjmmtthh', 'zxxuueeg', 'aanlljrrrxx',
+        'dqqqaaabbb', 'oocccffuucccjjjkkkjyyyeehh'],
+      k: 1,
+      output: 'oocccffuucccjjjkkkjyyyeehh',
+    },
+    {
+      input: [],
+      k: 3,
+      output: '',
+    },
+    {
+      input: ['itvayloxrp', 'wkppqsztdkmvcuwvereiupccauycnjutlv',
+        'vweqilsfytihvrzlaodfixoyxvyuyvgpck'],
+      k: 2,
+      output: 'wkppqsztdkmvcuwvereiupccauycnjutlvvweqilsfytihvrzlaodfixoyxvyuyvgpck',
+    },
+    {
+      input: ['it', 'wkppv', 'ixoyx', '3452', 'zzzzzzzzzzzz'],
+      k: 3,
+      output: 'ixoyx3452zzzzzzzzzzzz',
+    },
+    {
+      input: ['it', 'wkppv', 'ixoyx', '3452', 'zzzzzzzzzzzz'],
+      k: 0,
+      output: '',
+    },
+  ];
+
+  it('should return a string type', () => {
+    const result = longestConsec(['zone', 'abigail', 'theta', 'form', 'libe', 'zas'], 2);
+    expect(typeof result).toBe('string');
+  });
+
+  it.each(testCases)('should return "$output"', (testCase) => {
+    const result = longestConsec(testCase.input, testCase.k);
+    expect(result).toBe(testCase.output);
+  });
+});

codewars/i-am-very-very-very/README.md

@@ -0,0 +1,22 @@
+# I Am Very Very Very
+
+## Description
+
+You are very very happy and very very very excited to solve this Kata.
+Show it to us by creating a function iam such as:
+
+```js
+iam('happy') // returns the string "I am happy"
+iam('excited') // returns the string "I am excited"
+iam()('scared') // returns the string "I am very scared"
+iam()()('interested') // returns the string "I am very very interested"
+```
+and so on...
+
+As you understood, the function iam accept 1 optional parameter.
+If provided, the function returns a string.
+If NOT provided, it must returns a function allowing to continue the sentence.
+
+I am very very very curious to see you approach the problem.
+
+Enjoy!