Finish data structures adn basic algorithm challenges

Author: TheNewStyles

BasicAlgorithmScripting/sliceAndSplice.js

@@ -0,0 +1,27 @@
+// Basic Algorithm Scripting: Slice and Splice
+// You are given two arrays and an index.
+
+// Use the array methods slice and splice to copy each element of the first array into the second array, in order.
+
+// Begin inserting elements at index n of the second array.
+
+// Return the resulting array. The input arrays should remain the same after the function runs.
+
+// Remember to use Read-Search-Ask if you get stuck. Write your own code.
+
+// frankenSplice([1, 2, 3], [4, 5], 1) should return [4, 1, 2, 3, 5].
+// frankenSplice([1, 2], ["a", "b"], 1) should return ["a", 1, 2, "b"].
+// frankenSplice(["claw", "tentacle"], ["head", "shoulders", "knees", "toes"], 2) should return ["head", "shoulders", "claw", "tentacle", "knees", "toes"].
+// All elements from the first array should be added to the second array in their original order.
+// The first array should remain the same after the function runs.
+// The second array should remain the same after the function runs.
+
+function frankenSplice(arr1, arr2, n) {
+    // It's alive. It's alive!
+    let firstHalf = arr2.slice(0, n);
+    let secondHalf = arr2.slice(n, arr2.length); 
+  
+    return [...firstHalf, ...arr1, ...secondHalf];
+  }
+  
+  frankenSplice([1, 2, 3], [4, 5, 6], 1);

BasicDataStructures/checkIfAnObjectHasAProperty.js

@@ -0,0 +1,42 @@
+// Basic Data Structures: Check if an Object has a Property
+// Now we can add, modify, and remove keys from objects. But what if we just wanted to know if an object has a specific property? JavaScript provides us with two different ways to do this. One uses the hasOwnProperty() method and the other uses the in keyword. If we have an object users with a property of Alan, we could check for its presence in either of the following ways:
+
+// users.hasOwnProperty('Alan');
+// 'Alan' in users;
+// // both return true
+
+// We've created an object, users, with some users in it and a function isEveryoneHere, which we pass the users object to as an argument. Finish writing this function so that it returns true only if the users object contains all four names, Alan, Jeff, Sarah, and Ryan, as keys, and false otherwise.
+
+// The users object only contains the keys Alan, Jeff, Sarah, and Ryan
+// The function isEveryoneHere returns true if Alan, Jeff, Sarah, and Ryan are properties on the users object
+// The function isEveryoneHere returns false if Alan, Jeff, Sarah, and Ryan are not properties on the users object
+
+let users = {
+    Alan: {
+      age: 27,
+      online: true
+    },
+    Jeff: {
+      age: 32,
+      online: true
+    },
+    Sarah: {
+      age: 48,
+      online: true
+    },
+    Ryan: {
+      age: 19,
+      online: true
+    }
+  };
+  
+  function isEveryoneHere(obj) {
+    // change code below this line
+    return obj.hasOwnProperty('Alan')
+    && obj.hasOwnProperty('Jeff')
+    && obj.hasOwnProperty('Sarah')
+    && obj.hasOwnProperty('Ryan');
+    // change code above this line
+  }
+  
+  console.log(isEveryoneHere(users));

BasicDataStructures/generateAnArrayOfAllObjectKeysWithObjectKeys.js

@@ -0,0 +1,35 @@
+// Basic Data Structures: Generate an Array of All Object Keys with Object.keys()
+// We can also generate an array which contains all the keys stored in an object using the Object.keys() method and passing in an object as the argument. This will return an array with strings representing each property in the object. Again, there will be no specific order to the entries in the array.
+
+
+// Finish writing the getArrayOfUsers function so that it returns an array containing all the properties in the object it receives as an argument.
+
+// The users object only contains the keys Alan, Jeff, Sarah, and Ryan
+// The getArrayOfUsers function returns an array which contains all the keys in the users object
+
+let users = {
+    Alan: {
+      age: 27,
+      online: false
+    },
+    Jeff: {
+      age: 32,
+      online: true
+    },
+    Sarah: {
+      age: 48,
+      online: false
+    },
+    Ryan: {
+      age: 19,
+      online: true
+    }
+  };
+  
+  function getArrayOfUsers(obj) {
+    // change code below this line  
+    return Object.keys(obj);
+    // change code above this line
+  }
+  
+  console.log(getArrayOfUsers(users));

BasicDataStructures/iterateThroughTheKeysOfAnObjectWithAForInStatement.js

@@ -0,0 +1,56 @@
+// Basic Data Structures: Iterate Through the Keys of an Object with a for...in Statement
+// Sometimes you may need to iterate through all the keys within an object. This requires a specific syntax in JavaScript called a for...in statement. For our users object, this could look like:
+
+// for (let user in users) {
+//   console.log(user);
+// };
+
+// // logs:
+// Alan
+// Jeff
+// Sarah
+// Ryan
+// In this statement, we defined a variable user, and as you can see, this variable was reset during each iteration to each of the object's keys as the statement looped through the object, resulting in each user's name being printed to the console.
+
+// NOTE:
+// Objects do not maintain an ordering to stored keys like arrays do; thus a keys position on an object, or the relative order in which it appears, is irrelevant when referencing or accessing that key.
+
+
+// We've defined a function, countOnline; use a for...in statement within this function to loop through the users in the users object and return the number of users whose online property is set to true.
+
+// The users object contains users Jeff and Ryan with online set to true and users Alan and Sarah with online set to false
+// The function countOnline returns the number of users with the online property set to true
+
+let users = {
+    Alan: {
+      age: 27,
+      online: false
+    },
+    Jeff: {
+      age: 32,
+      online: true
+    },
+    Sarah: {
+      age: 48,
+      online: false
+    },
+    Ryan: {
+      age: 19,
+      online: true
+    }
+  };
+  
+  function countOnline(obj) {
+    // change code below this line
+    let count = 0;  
+    for (let user in obj) {
+      if(obj[user].online == true) {
+        count++;
+      }
+    }
+  
+    return count;
+    // change code above this line
+  }
+  
+  console.log(countOnline(users));

BasicDataStructures/modifyAnArrayStoredInAnObject.js

@@ -0,0 +1,38 @@
+// Basic Data Structures: Modify an Array Stored in an Object
+// Now you've seen all the basic operations for JavaScript objects. You can add, modify, and remove key-value pairs, check if keys exist, and iterate over all the keys in an object. As you continue learning JavaScript you will see even more versatile applications of objects. Additionally, the optional Advanced Data Structures lessons later in the curriculum also cover the ES6 Map and Set objects, both of which are similar to ordinary objects but provide some additional features. Now that you've learned the basics of arrays and objects, you're fully prepared to begin tackling more complex problems using JavaScript!
+
+
+// Take a look at the object we've provided in the code editor. The user object contains three keys. The data key contains five keys, one of which contains an array of friends. From this, you can see how flexible objects are as data structures. We've started writing a function addFriend. Finish writing it so that it takes a user object and adds the name of the friend argument to the array stored in user.data.friends and returns that array.
+
+// The user object has name, age, and data keys
+// The addFriend function accepts a user object and a friend string as arguments and adds the friend to the array of friends in the user object
+// addFriend(user, "Pete") should return ["Sam", "Kira", "Tomo", "Pete"]
+
+let user = {
+    name: 'Kenneth',
+    age: 28,
+    data: {
+      username: 'kennethCodesAllDay',
+      joinDate: 'March 26, 2016',
+      organization: 'freeCodeCamp',
+      friends: [
+        'Sam',
+        'Kira',
+        'Tomo'
+      ],
+      location: {
+        city: 'San Francisco',
+        state: 'CA',
+        country: 'USA'
+      }
+    }
+  };
+  
+  function addFriend(userObj, friend) {
+    // change code below this line  
+    userObj.data.friends.push(friend);
+    return userObj.data.friends;
+    // change code above this line
+  }
+  
+  console.log(addFriend(user, 'Pete'));