Merge pull request #56 from arindal1/main

Added: 3 JavaScript codes

Author: devvsakib

L-A/0010 Design Cancellable Function (L-A)/Design Cancellable Function.js

@@ -0,0 +1,22 @@
+const cancellable = (generator) => {
+  let cancel;
+  const cancelPromise = new Promise((_, reject) => {
+    cancel = () => reject("Cancelled");
+  });
+  // Every Promise rejection has to be caught.
+  cancelPromise.catch(() => {});
+
+  const promise = (async () => {
+    let next = generator.next();
+    while (!next.done) {
+      try {
+        next = generator.next(await Promise.race([next.value, cancelPromise]));
+      } catch (e) {
+        next = generator.throw(e);
+      }
+    }
+    return next.value;
+  })();
+
+  return [cancel, promise];
+};

L-A/0010 Design Cancellable Function (L-A)/README.md

@@ -0,0 +1,74 @@
+# 2650. Design Cancellable Function
+[LeetCode](https://leetcode.com/problems/design-cancellable-function/)
+
+Sometimes you have a long running task, and you may wish to cancel it before it completes. To help with this goal, write a function `cancellable` that accepts a generator object and returns an array of two values: a cancel function and a promise.
+You may assume the generator function will only yield promises. It is your function's responsibility to pass the values resolved by the promise back to the generator. If the promise rejects, your function should throw that error back to the generator.
+If the cancel callback is called before the generator is done, your function should throw an error back to the generator. That error should be the string `"Cancelled"` (Not an `Error` object). If the error was caught, the returned promise should resolve with the next value that was yielded or returned. Otherwise, the promise should reject with the thrown error. No more code should be executed.
+
+When the generator is done, the promise your function returned should resolve the value the generator returned. If, however, the generator throws an error, the returned promise should reject with the error.
+
+An example of how your code would be used:
+```javascript
+function* tasks() {
+  const val = yield new Promise(resolve => resolve(2 + 2));
+  yield new Promise(resolve => setTimeout(resolve, 100));
+  return val + 1; // calculation shouldn't be done.
+}
+const [cancel, promise] = cancellable(tasks());
+setTimeout(cancel, 50);
+promise.catch(console.log); // logs "Cancelled" at t=50ms
+```
+If instead `cancel()` was not called or was called after `t=100ms`, the promise would have resolved 5.
+
+ 
+## Example 1:
+
+Input: 
+```javascript
+generatorFunction = function*() { 
+  return 42; 
+}
+cancelledAt = 100
+```
+**Output:** `{"resolved": 42}`<br>
+**Explanation:**
+```javascript
+const generator = generatorFunction();
+const [cancel, promise] = cancellable(generator);
+setTimeout(cancel, 100);
+promise.then(console.log); // resolves 42 at t=0ms
+```
+The generator immediately yields 42 and finishes. Because of that, the returned promise immediately resolves 42. Note that cancelling a finished generator does nothing.
+
+## Example 2:
+
+Input:
+```javascript
+generatorFunction = function*() { 
+  const msg = yield new Promise(res => res("Hello")); 
+  throw `Error: ${msg}`; 
+}
+cancelledAt = null
+```
+**Output:** `{"rejected": "Error: Hello"}`<br>
+**Explanation:**
+A promise is yielded. The function handles this by waiting for it to resolve and then passes the resolved value back to the generator. Then an error is thrown which has the effect of causing the promise to reject with the same thrown error.
+
+## Example 3:
+
+Input: 
+```javascript
+generatorFunction = function*() { 
+  yield new Promise(res => setTimeout(res, 200)); 
+  return "Success"; 
+}
+cancelledAt = 100
+```
+**Output:** `{"rejected": "Cancelled"}`<br>
+**Explanation:**
+While the function is waiting for the yielded promise to resolve, cancel() is called. This causes an error message to be sent back to the generator. Since this error is uncaught, the returned promise rejected with this error.
+
+## Constraints:
+
+`cancelledAt == null or 0 <= cancelledAt <= 1000`<br>
+`generatorFunction` returns a generator object

L-A/0011 The Fiscal Code/README.md

@@ -0,0 +1,57 @@
+# The Fiscal Code
+**[Edabit Problem](https://edabit.com/challenge/Pa2rHJ6KeRBTF28Pg)**
+
+Each person in Italy has an unique identifying ID code issued by the national tax office after the birth registration: the Fiscal Code ([Codice Fiscale](https://en.wikipedia.org/wiki/Italian_fiscal_code_card)).
+
+Given an object containing the personal data of a person (name, surname, gender and date of birth) return the 11 code characters as a string following these steps:
+
+- Generate 3 capital letters from the surname, if it has:
+
+  - At least 3 consonants then the first three consonants are used. (Newman -> NWM).
+  - Less than 3 consonants then vowels will replace missing characters in the same order they appear (Fox -> FXO | Hope -> HPO).
+  - Less than three letters then "X" will take the third slot after the consonant and the vowel (Yu -> YUX).
+
+- Generate 3 capital letters from the name, if it has:
+
+  - Exactly 3 consonants then consonants are used in the order they appear (Matt -> MTT).
+  - More than 3 consonants then first, third and fourth consonant are used (Samantha -> SNT | Thomas -> TMS).
+  - Less than 3 consonants then vowels will replace missing characters in the same order they appear (Bob -> BBO | Paula -> PLA).
+  - Less than three letters then "X" will take the the third slot after the consonant and the vowel (Al -> LAX).
+ 
+- Generate 2 numbers, 1 letter and 2 numbers from date of birth and gender:
+
+  - Take the last two digits of the year of birth (1985 -> 85).
+  - Generate a letter corresponding to the month of birth (January -> A | December -> T) using the table for conversion included in the code.
+  - For males take the day of birth adding one zero at the start if is less than 10 (any 9th day -> 09 | any 20th day -> 20).
+  - For females take the day of birth and sum 40 to it (any 9th day -> 49 | any 20th day -> 60).
+ 
+### Examples:
+
+```javascipt
+fiscalCode({
+  name: "Matt",
+  surname: "Edabit",
+  gender: "M",
+  dob: "1/1/1900"
+}) ➞ "DBTMTT00A01"
+
+fiscalCode({
+  name: "Helen",
+  surname: "Yu",
+  gender: "F",
+  dob: "1/12/1950"
+}) ➞ "YUXHLN50T41"
+
+fiscalCode({
+  name: "Mickey",
+  surname: "Mouse",
+  gender: "M",
+  dob: "16/1/1928"
+}) ➞ "MSOMKY28A16"
+```
+
+**Notes:**
+- Code letters must be uppercase.
+- Date of birth is given in D/M/YYYY format.
+- The conversion table for months is already in the starting code.
+- Y is not a vowel.

L-A/0011 The Fiscal Code/TheFiscalCode.js

@@ -0,0 +1,79 @@
+function fiscalCode(data) {
+  const monthsConversion = {
+    '01': 'A', '02': 'B', '03': 'C', '04': 'D', '05': 'E', '06': 'H',
+    '07': 'L', '08': 'M', '09': 'P', '10': 'R', '11': 'S', '12': 'T'
+  };
+
+  // Helper function to generate code for names and surnames
+  function generateCode(name, isSurname) {
+    const vowels = 'AEIOU';
+    let consonants = '';
+    let code = '';
+
+    // Helper function to check if a character is a consonant
+    function isConsonant(char) {
+      return /[BCDFGHJKLMNPQRSTVWXYZ]/.test(char);
+    }
+
+    for (let i = 0; i < name.length && consonants.length < 3; i++) {
+      const char = name[i].toUpperCase();
+      if (isConsonant(char)) {
+        consonants += char;
+      }
+    }
+
+    if (consonants.length < 3) {
+      for (let i = 0; i < name.length && consonants.length < 3; i++) {
+        const char = name[i].toUpperCase();
+        if (vowels.includes(char)) {
+          consonants += char;
+        }
+      }
+    }
+
+    if (consonants.length < 3) {
+      consonants += 'X'.repeat(3 - consonants.length);
+    }
+
+    code = consonants;
+
+    if (isSurname) {
+      code += 'XXX';
+    } else {
+      code += name.length >= 3 ? name[0] + name[2] + name[3] : name + 'XX';
+    }
+
+    return code;
+  }
+
+  const surnameCode = generateCode(data.surname, true);
+  const nameCode = generateCode(data.name, false);
+
+  const year = data.dob.split('/')[2].slice(-2);
+  const month = monthsConversion[data.dob.split('/')[1]];
+  const day = (data.gender === 'F' ? 40 + parseInt(data.dob.split('/')[0]) : parseInt(data.dob.split('/')[0])).toString().padStart(2, '0');
+
+  return `${surnameCode}${nameCode}${year}${month}${day}`;
+}
+
+// Examples
+console.log(fiscalCode({
+  name: "Matt",
+  surname: "Edabit",
+  gender: "M",
+  dob: "1/1/1900"
+})); // ➞ "DBTMTT00A01"
+
+console.log(fiscalCode({
+  name: "Helen",
+  surname: "Yu",
+  gender: "F",
+  dob: "1/12/1950"
+})); // ➞ "YUXHLN50T41"
+
+console.log(fiscalCode({
+  name: "Mickey",
+  surname: "Mouse",
+  gender: "M",
+  dob: "16/1/1928"
+})); // ➞ "MSOMKY28A16"

L-B/0025 Seven Boom!/README.md

@@ -0,0 +1,17 @@
+# Seven Boom!
+[Edabit Problem](https://edabit.com/challenge/6R6gReGTGwzpwuffD)
+
+Create a function that takes an array of numbers and return `"Boom!"` if the digit 7 appears in the array. Otherwise, return `"there is no 7 in the array"`.
+
+Examples:
+```javascript
+sevenBoom([1, 2, 3, 4, 5, 6, 7]) ➞ "Boom!"
+// 7 contains the number seven.
+
+sevenBoom([8, 6, 33, 100]) ➞ "there is no 7 in the array"
+// None of the items contain 7 within them.
+
+sevenBoom([2, 55, 60, 97, 86]) ➞ "Boom!"
+// 97 contains the number seven.
+```
+

L-B/0025 Seven Boom!/SevenBoom.js

@@ -0,0 +1,8 @@
+function sevenBoom(arr) {
+  for (let i = 0; i < arr.length; i++) {
+    if (String(arr[i]).includes('7')) {
+      return 'Boom!';
+    }
+  }
+  return 'there is no 7 in the array';
+}