created

Author: prblmsolvrx

Diff for: Basic Algorithm Scripting/boo-who.js

@@ -0,0 +1,8 @@
+function booWho(bool) {
+  if(bool===true ||bool===false)
+  return true
+  else
+  return false;
+}
+
+booWho(null);

Diff for: Basic Algorithm Scripting/chunky-monkey.js

@@ -0,0 +1,10 @@
+function chunkArrayInGroups(arr, size) {
+  let result=[];
+  for(let i=0;i<arr.length;i=i+size)
+  {
+     result.push(arr.slice(i,(i+size)))
+  }
+  return result;
+}
+
+chunkArrayInGroups(["a", "b", "c", "d"], 2);

Diff for: Basic Algorithm Scripting/confirm-the-ending.js

@@ -0,0 +1,8 @@
+function confirmEnding(str, target) {
+  let targetlength=target.length;
+  let startindex=str.length-targetlength;
+  let result=str.substring(startindex);
+  return result===target;
+}
+
+confirmEnding("Bastian", "n");

Diff for: Basic Algorithm Scripting/convert-celsius-to-fahrenheit.js

@@ -0,0 +1,6 @@
+function convertCtoF(celsius) {
+  let fahrenheit=(celsius*(9/5))+32;
+  return fahrenheit;
+}
+
+convertCtoF(30);

Diff for: Basic Algorithm Scripting/factorialize-a-number.js

@@ -0,0 +1,10 @@
+function factorialize(num) {
+  let f=1;
+  for(let i=1;i<=num;i++)
+  {
+      f=f*i;
+  }
+  return f;
+}
+
+factorialize(5);

Diff for: Basic Algorithm Scripting/falsy-bouncer.js

@@ -0,0 +1,11 @@
+function bouncer(arr) {
+  let x = [];
+  for (let i = 0; i < arr.length; i++) {
+    if (arr[i] !== false && arr[i] !== null && arr[i] !== 0 && arr[i] !== undefined && !Number.isNaN(arr[i]) && arr[i] !== "") {
+      x.push(arr[i]);
+    }
+  }
+  return x;
+}
+
+bouncer([7, "ate", "", false, 9]);

Diff for: Basic Algorithm Scripting/find-the-longest-word-in-a-string.js

@@ -0,0 +1,12 @@
+function findLongestWordLength(str) {
+  let words=str.split(' ');
+  let max=0;
+  for(let i=0;i<words.length;i++)
+  {
+       if(words[i].length>max)
+       max=words[i].length;
+  }
+  return max;
+}
+
+findLongestWordLength("The quick brown fox jumped over the lazy dog");

Diff for: Basic Algorithm Scripting/finders-keepers.js

@@ -0,0 +1,18 @@
+function findElement(arr, func) {
+  let num = 0;
+  for(let i=0;i<arr.length;i++)
+  {
+    if(arr[i]%2===0)
+    {
+      num=arr[i];
+      break;
+    }
+  }
+  if(num===0)
+  {
+    return undefined;
+  }
+  return num;
+}
+
+findElement([1, 2, 3, 4], num => num % 2 === 0);

Diff for: Basic Algorithm Scripting/mutations.js

@@ -0,0 +1,19 @@
+function mutation(arr) {
+  // Convert both strings to uppercase to make the comparison case-insensitive
+  let x1 = arr[0].toUpperCase();
+  let x2 = arr[1].toUpperCase();
+
+  // Loop through each character in the second string
+  for (let i = 0; i < x2.length; i++) {
+    // Check if the current character in the second string is not found in the first string
+    if (x1.indexOf(x2[i]) < 0) {
+      // If a character is not found, return false immediately
+      return false;
+    }
+  }
+  // If all characters in the second string are found in the first string, return true
+  return true;
+}
+
+// Test the function with ["hello", "hey"]
+mutation(["hello", "hey"]);

Diff for: Basic Algorithm Scripting/repeat-a-string-repeat-a-string.js

@@ -0,0 +1,13 @@
+function repeatStringNumTimes(str, num) {
+  let r="";
+  for(let i=0;i<num;i++)
+  {
+      r=r+str;
+  }
+  if(num<0)
+  return "";
+  else
+  return r;
+}
+
+repeatStringNumTimes("abc", 3);

Diff for: Basic Algorithm Scripting/return-largest-numbers-in-arrays.js

@@ -0,0 +1,18 @@
+function largestOfFour(arr) {
+  let resultarr=[];
+  for(let i=0;i<arr.length;i++)
+  {
+    let max=-9999999999;
+    for(let j=0;j<arr[i].length;j++)
+    {
+         if(arr[i][j]>max)
+         {
+           max=arr[i][j];
+         }
+    }
+    resultarr.push(max);
+  }
+  return resultarr;
+}
+
+largestOfFour([[4, 5, 1, 3], [13, 27, 18, 26], [32, 35, 37, 39], [1000, 1001, 857, 1]]);

Diff for: Basic Algorithm Scripting/reverse-a-string.js

@@ -0,0 +1,12 @@
+function reverseString(str) {
+  let newstr="";
+  for(let i=0;i<str.length;i++)
+  {
+     let ch=str.charAt(i);
+     newstr=ch+newstr;
+  }
+  str=newstr;
+  return str;
+}
+
+reverseString("hello");

Diff for: Basic Algorithm Scripting/slice-and-splice.js

@@ -0,0 +1,19 @@
+function frankenSplice(arr1, arr2, n) {
+  // Copy arr2 to avoid modifying the original array
+  let newArr = arr2.slice();
+
+  // Loop through each element in arr1
+  for (let i = 0; i < arr1.length; i++) {
+    // Use splice to insert the current element of arr1 into newArr
+    // The index at which to insert is calculated as n + i
+    // 0 is the delete count (we're not deleting any elements)
+    // arr1[i] is the element to insert
+    newArr.splice(n + i, 0, arr1[i]);
+  }
+
+  // Return the modified newArr with arr1 spliced in at index n
+  return newArr;
+}
+
+// Example usage: splice [1, 2, 3] into [4, 5, 6] at index 1
+frankenSplice([1, 2, 3], [4, 5, 6], 1);

Diff for: Basic Algorithm Scripting/title-case-a-sentence.js

@@ -0,0 +1,9 @@
+function titleCase(str) {
+  let words = str.toLowerCase().split(' ');
+  for (let i = 0; i < words.length; i++) {
+    words[i] = words[i][0].toUpperCase() + words[i].substring(1);
+  }
+  return words.join(' ');
+}
+
+titleCase("I'm a little tea pot");

Diff for: Basic Algorithm Scripting/truncate-a-string.js

@@ -0,0 +1,10 @@
+function truncateString(str, num) {
+  let x=str.substring(0,num);
+  x=x+"...";
+  if(str.length>num)
+  return x;
+  else
+  return str;
+}
+
+truncateString("A-tisket a-tasket A green and yellow basket", 8);

Diff for: Basic Algorithm Scripting/where-do-i-belong.js

@@ -0,0 +1,16 @@
+function getIndexToIns(arr, num) {
+  arr.sort((a,b)=>a-b);
+  let x;
+  for(let i=0;i<arr.length;i++)
+  {
+    if(arr[i]>=num)
+    {
+      x=i;
+      break;
+    }
+  }
+  if(x===undefined)
+  x=arr.length;
+  return x;
+}
+getIndexToIns([40, 60], 50);

Diff for: Basic DataStructure in Javascript/access-an-arrays-contents-using-bracket-notation.js

@@ -0,0 +1,5 @@
+let myArray = ["a", "b", "c", "d"];
+// Only change code below this line
+myArray[1]="a";
+// Only change code above this line
+console.log(myArray);

Diff for: Basic DataStructure in Javascript/access-property-names-with-bracket-notation.js

@@ -0,0 +1,16 @@
+let foods = {
+  apples: 25,
+  oranges: 32,
+  plums: 28,
+  bananas: 13,
+  grapes: 35,
+  strawberries: 27
+};
+
+function checkInventory(scannedItem) {
+  // Only change code below this line
+  return foods[scannedItem];
+  // Only change code above this line
+}
+
+console.log(checkInventory("apples"));

Diff for: Basic DataStructure in Javascript/add-items-to-an-array-with-push-and-unshift.js

@@ -0,0 +1,9 @@
+function mixedNumbers(arr) {
+  // Only change code below this line
+     arr.push(7, 'VIII', 9);
+     arr.unshift('I', 2, 'three');
+  // Only change code above this line
+  return arr;
+}
+
+console.log(mixedNumbers(['IV', 5, 'six']));

Diff for: Basic DataStructure in Javascript/add-items-using-splice.js

@@ -0,0 +1,8 @@
+function htmlColorNames(arr) {
+  // Only change code below this line
+  arr.splice(0,2,'DarkSalmon','BlanchedAlmond');
+  // Only change code above this line
+  return arr;
+}
+
+console.log(htmlColorNames(['DarkGoldenRod', 'WhiteSmoke', 'LavenderBlush', 'PaleTurquoise', 'FireBrick']));

Diff for: Basic DataStructure in Javascript/add-key-value-pairs-to-javascript-objects.js

@@ -0,0 +1,13 @@
+const foods = {
+  apples: 25,
+  oranges: 32,
+  plums: 28
+};
+
+// Only change code below this line
+foods["bananas"]=13;
+foods["grapes"]=35;
+foods["strawberries"]=27;
+// Only change code above this line
+
+console.log(foods);

Diff for: Basic DataStructure in Javascript/check-for-the-presence-of-an-element-with-indexof.js

@@ -0,0 +1,10 @@
+function quickCheck(arr, elem) {
+  // Only change code below this line
+   if(arr.indexOf(elem)>=0)
+   return true;
+   else
+   return false;
+  // Only change code above this line
+}
+
+console.log(quickCheck(['squash', 'onions', 'shallots'], 'mushrooms'));

Diff for: Basic DataStructure in Javascript/check-if-an-object-has-a-property.js

@@ -0,0 +1,29 @@
+let users = {
+  Alan: {
+    age: 27,
+    online: true
+  },
+  Jeff: {
+    age: 32,
+    online: true
+  },
+  Sarah: {
+    age: 48,
+    online: true
+  },
+  Ryan: {
+    age: 19,
+    online: true
+  }
+};
+
+function isEveryoneHere(userObj) {
+  // Only change code below this line
+  if(userObj.hasOwnProperty('Alan')&&userObj.hasOwnProperty('Jeff')&&userObj.     hasOwnProperty('Sarah')&&userObj.hasOwnProperty('Ryan'))
+  return true;
+  else 
+  return false;
+  // Only change code above this line
+}
+
+console.log(isEveryoneHere(users));

Diff for: Basic DataStructure in Javascript/combine-arrays-with-the-spread-operator.js

@@ -0,0 +1,7 @@
+function spreadOut() {
+  let fragment = ['to', 'code'];
+  let sentence=['learning',...fragment,'is', 'fun']; // Change this line
+  return sentence;
+}
+
+console.log(spreadOut());

Diff for: Basic DataStructure in Javascript/copy-an-array-with-the-spread-operator.js

@@ -0,0 +1,12 @@
+function copyMachine(arr, num) {
+  let newArr = [];
+  while (num >= 1) {
+    // Only change code below this line
+    newArr.push([...arr]);
+    // Only change code above this line
+    num--;
+  }
+  return newArr;
+}
+
+console.log(copyMachine([true, false, true], 2));

Diff for: Basic DataStructure in Javascript/copy-array-items-using-slice.js

@@ -0,0 +1,8 @@
+function forecast(arr) {
+  // Only change code below this line
+  arr=arr.slice(2,4);
+  return arr;
+}
+
+// Only change code above this line
+console.log(forecast(['cold', 'rainy', 'warm', 'sunny', 'cool', 'thunderstorms']));

Diff for: Basic DataStructure in Javascript/create-complex-multi-dimensional-arrays.js

@@ -0,0 +1,9 @@
+let myNestedArray = [
+  // Only change code below this line
+  ['unshift', false, 1, 2, 3, 'complex', 'nested'],
+  ['loop', 'shift', 6, 7, 1000, 'method'],
+  ['concat', false, true, 'spread', 'array',["deep"]],
+  ['mutate', 1327.98, 'splice', 'slice', 'push',[["deeper"]]],
+  ['iterate', 1.3849, 7, '8.4876', 'arbitrary', 'depth',[[["deepest"]]]]
+  // Only change code above this line
+];