CAESARS CIPHER

In this challenge we have to decode a cipher message. More about cipher can be found out here.

So we have a simplest and most widely known ciphers called Caesar cipher, also called shift cipher. Basically in a shift cipher the meanings of the letters are shifted by some set value.

An example of this type of modern cipher is the ROT13 cipher, where the values of the letters are shifted by 13 places. Thus 'A' ↔ 'N', 'B' ↔ 'O' and so on.

So we have to write a function which takes a ROT13 encoded string as input and returns a decoded string.

Other conditions are:-

1.  All letters should be uppercase.

2.  Non-alphabetic character i.e. spaces and punctuation's are not to be transformed, but have to be passed on.

At last the list of clues in the form of helpful links are as follows:

•     String.charCodeAt()
•     String.fromCharCode()

It took me very less time to implement the algorithm. In this algorithm I loop thorough all the string elements converting each of them to equivalent uni-code values and then pushing them to the array. Finally I joined all the elements using the join() method of arrays.

                 function rot13(str) { // LBH QVQ VG!
                 arr = [];
                 for (var i = 0; i < str.length; i++){
                     var a = str.charCodeAt(i);
                     if(a >= 65 && a <= 77){
                         a += 13;
                     } else if(a >= 78 && a <= 90){
                         a -= 13;
                     } else {
                       a = a;
                     }
                     var c = String.fromCharCode(a);
                     arr.push(c);
                }

            }

WHERE DO I BELONG

This challenge requires returning the lowest index at which a value  that is second argument should be inserted into an array which is the first argument after sorting it.

The algorithm was quite straight forward, only thing that made me to think was what if the number is to inserted at index greater than last index of the array e.

Clue is given in the form of link below:

• Array.sort()

This JavaScript method sort() is quite self explanatory. It sorts the array so that we can find the right index of the second argument.

 So here is my implementation of the algorithm.

        function where(arr, num) {
            arr1 = arr.sort(function(a, b) {  //sort the array first
                                return a - b;
                            });
            for (var i = 0; i <= arr1.length; i++){
                if (num <= arr1[i]){
                    return i;
                }
                if (arr[i] === undefined){
                    return i;
    
                }
            }
        }

SEEK AND DESTROY

In this challenge we are provided with an initial array i.e the first argument in the destroyer function It is followed by one or more arguments. We have to remove all elements from the first array that are of the same value as are these arguments.

Following clues are given for reference:

• Arguments object

• Array.filter()

To be frank I have to sweat out a lot with this algorithm, First it took me a while to get my head around the Arguments Objects. I used  Read-Search-Ask technique to get more clues and finally after a lot of efforts i got to the following solution.

My solution for the problem is given below:

   function destroyer(arr) {
       arr1 = [];         //create a new array of arguments
       for ( i = 1; i < arguments.length; i++){
           j = arguments[i];
           arr1.push(j);
       }
       function checker(value) {   // returns items not in index
           return arr1.indexOf(value) === -1;
       }
       return arr.filter(checker);  //Filter the items given by 
                                    //checker func
   }

FALSY BOUNCER

In this challenge we have to remove all falsy values from an array.

Falsy values in JavaScript are:-

 false, null, 0, "", undefined, and NaN.

The under-mentioned clues are provided as helpful links:

• Boolean Objects

• Array.filter()

For this challenge I went through the clues that are given in the form of clickable links above, again leading to MDN JavaScript documentation.

Then on with little bit of tweaking I was able to implement the under-mentioned solution for the challenge.

So, here is my solution.

                function bouncer(arr) {
             function Boolean(value){
                 var i = 0;
                 arr1 = [NaN, 0, false, null, undefined];
                 if (arr1[i] === value){
                     i++;
                 } 
                 return value;
             }
             return arr.filter(Boolean);
           }

Let me know about any improvements that can be done to the above program by commenting below.

MUTATIONS

This Challenge requires to return true if the string in the first element of the array contains all of the letters of the string in the second element of the array.

For example, ["hello", "Hello"], have to return true because all of the letters in the second string are present in the first, after ignoring case.

The arguments ["hello", "hey"] should have to return false because the string in first element "hello" does not contain a "y".

Similarly, ["Alien", "line"], should be returning true because all of the letters in "line" are there in "Alien".

Clue in the form of helpful links is as given below. Its a clickable link leading to MDN documentation to study more about the string method indexOf():

• String.indexOf()

Again using a little trail & error and the Read-Search-Ask technique. I can up with following solution.



                       function mutation(arr) {
                     var a = arr[0].toLowerCase();
                     var b = arr[1].toLowerCase();
                     if (a === b) {
                         return true;
                     } else {
                         var c = b.split("");
                         var i = 0;
                         for (var j = 0; j < b.length; j++){
                             i = a.indexOf(c[j]);
                                 if (i === -1)
                                     break;
                         }   
                         if (i !== -1){
                             return true;
                         } else {
                             return false;
                         }   
                    }       
                }

SLASHER FLICK

In this challenge I have to return the remaining elements of an array after chopping off n elements from the head.

The head means the beginning of the array, or the zeroth index.

Following links are given as a clue:

• Array.slice()

• Array.splice()

This challenge makes use of both the above JavaScript methods.

The slice() method has already been discussed in chunky Monkey challenge. Here is the link to the post.

CHUNKY MONKEY 

The splice method is new one, you can go through it on MDN javascript documentation here.

As for my solution to the problem, It took me few permutation and combination before arriving on the solution.

My solution is as follows.


                   function slasher(arr, howMany) {
                   var i = arr.slice(0,arr.length);
                   var x = arr.splice(howMany, i.length);
                       return x;
              }

If you have any suggestion, please let me know by commenting below the post.

CHUNKY MONKEY

Challenge this time is to write a function that splits an array (first argument) into groups the length of size (second argument) and returns them as a two-dimensional array.

 The clues are as given below:

• Array.push()

The push() method adds one or more elements to the end of an array and returns the new length of the array.

The syntax is as follows:

arr.push(element1, ..., elementN)

elementN

 

The elements to add to the end of the array.

• Array.slice() 

The slice() method extracts a section of a string and returns a new string.

The syntax is as follows;

str.slice(beginSlice[, endSlice])

  

beginSlice

The zero-based index at which to begin extraction. 

 

endSlice

Optional. The zero-based index at which to end extraction.

So below is my solution of the challenge:

           function chunk(arr, size) {
               newArray = [];
               for (var i = 0; i < arr.length; i+=size){
                   var x = arr.slice(i, i+size);
                   newArray.push(x);
               }
               return newArray;
               }