CareerCup

This is my code: but it is not working as expected: As in the loop is being detected but I am not able to remove the loop

function Node(element){
        this.element = element;
        this.next = null;
    }
    function LList() {
        this.head = new Node("head");
        this.head.next = this.head;
        this.find = find;
        this.insert = insert;
        this.display = display;
       

    }

    function find(item){
        var curr = this.head;
        while(curr.element != item){
            curr = curr.next;
        }
        return curr;
    }

    function insert(newElem, after){
        var newNode = new Node(newElem);
        var curr = this.find(after);
        newNode.next = curr.next;
        curr.next = newNode;
    }

    function display() {
        var currNode = this.head;
        while ((currNode.next !== null) &&
        (currNode.next.element !== "head")) {
            console.log(currNode.next.element);
            currNode = currNode.next;
        }
    }

    function findPrevious(item){
     var curr = this.head;
        while(curr.next !== null && curr.next.element !== item){
            curr =curr.next;
        }
        return curr;
    }

    var furniture = new LList();
    furniture.insert("chair","head");
    furniture.insert("table", "chair");
    furniture.insert("couch", "table");
    furniture.insert("stool","couch");
    //furniture.display();

    function detectALoop(list){
        var slow = list.head;
        var fast = list.head;
        while(slow && fast && fast.next){
            slow = slow.next;
            fast = fast.next.next;

            if(slow === fast){
               removeLoop (slow, list);
                return 1;
            }
        }
        return 0;
    }

    function removeLoop(loopNode, list)
    {
        var ptr1 = loopNode;
        var ptr2 = loopNode;
        var looplen = 1,i;


        // count the number of nodes in loop
        while(ptr1.next != ptr2)
        {
            ptr1 = ptr1.next;
            looplen++;
        }
        console.log(looplen)
        ptr1 = list.head;
        ptr2 = list.head;
        for(i=0; i <= looplen; i++)
        {
            ptr2 = ptr2.next;
        }



        while(ptr2.next != ptr1.next)
        {
            ptr1 = ptr1.next;
            ptr2 = ptr2.next;
        }

        ptr2.next = null; // breaking the loop
    }


    console.log(detectALoop(furniture))
    furniture.display();

Something in these lines:

var arr = ["aab", "bac", "aaa", "cda"];
    function wordChaining(arr){
     var index = 1;
        var arr = arr.sort();
        console.log(arr);
        var sortedArr = [arr[0]];
        var lastchar;
        while(index < arr.length){
            console.log("arr",arr[index].substring(0,1), arr, arr[index]);
            console.log("sorted",sortedArr[index-1].substring(arr[index-1].length-1), sortedArr, sortedArr[index-1])
         if(arr[index].substring(0,1)==sortedArr[index-1].substring(sortedArr[index-1].length-1)){
             sortedArr.push(arr[index]);
         }
            index++
        }
        return (sortedArr.length == arr.length) ? sortedArr : false;

    }
    console.log(wordChaining(arr))

The expected answer is 4, 20. I get 2,20 :(

Something in these lines. But it gives me an incorrect output

var allNodes =[];
  function NodeClass(value){

      this.value = value;


  }

   var  root = new NodeClass(20);
   root.left = new NodeClass(8);
   root.right = new NodeClass(22);
   root.left.left = new NodeClass(4);
   root.left.right = new NodeClass(12);
   root.left.right.left = new NodeClass(10);
   root.left.right.right = new NodeClass(14);
   var target = root.left.right;

   function printkdistanceNodeDown(root,  k) {
       // Base Case
       if (root == null || k < 0)  return;

       // If we reach a k distant node, print it
       if (k==0)
       {
         //  console.log(root.value);
           allNodes.push(root.value)
           return;
       }


       // Recur for left and right subtrees
       printkdistanceNodeDown(root.left, k-1);
       printkdistanceNodeDown(root.right, k-1);
   }

   function printkdistanceNode(root, target ,  k) {
       // Base Case 1: If tree is empty, return -1
       if (root == null) return -1;

       
       if (root == target)
       {
           printkdistanceNodeDown(root, k);
           return 0;
       }

       // Recur for left subtree
       var dl = printkdistanceNode(root.left, target, k);

       // Check if target node was found in left subtree
       if (dl != -1)
       {
           
           if (dl + 1 == k){
               console.log(root.value);
               allNodes.push(root.value);
           }

           
           else
               printkdistanceNodeDown(root.right, k-dl-2);

           
           return 1 + dl;
       }

       
       var dr = printkdistanceNode(root.right, target, k);
       if (dr != -1)
       {
           if (dr + 1 == k){
               console.log(root.value);
               allNodes.push(root.value);

           }

           else
               printkdistanceNodeDown(root.left, k-dr-2);
           return 1 + dr;
       }

       
       return -1;
   }

    console.log(printkdistanceNode(root, target, 2));

This algorithm is same as the one for "Printing all nodes at distance k from a given node".

Distance is the height. If distance is 2, we need all the nodes that are two edges away from that node.

I am not able to solve this using javascript

function getArrayRange(first, last){
        var arrRange =[];
        for(var i=first; i<=last; i++){

            arrRange.push(i);
        }
        return arrRange
    }
    //console.log(getArrayRange(7,21))

    function removeSubArr(arr){
        var obj = {};
        var fullArr = [];
        for (var i=0; i<arr.length; i++){
            for(var j=0; j<arr[i].length; j++){
                fullArr.push(getArrayRange(arr[i][0], arr[i][1]));
              obj[arr[i]] = getArrayRange(arr[i][0], arr[i][1]);
            }
        }

        for(var prop in obj){
           if(obj.hasOwnProperty(prop)){

               for(var i =0; i< fullArr.length; i++){
                   if(subArrCheck(obj[prop], fullArr[i]) == true){
                       fullArr.splice(i,1);
                   }
               }


           }
        }

        return fullArr;
    }

    function subArrCheck(arr, subarr) {


        var i, found, j;
        for (i = 0; i < 1 + (arr.length - subarr.length); ++i) {
            found = true;
            for (j = 0; j < subarr.length; ++j) {
                if (arr[i + j] !== subarr[j]) {
                    found = false;
                    break;
                }
            }
            if (found) return true;
        }
        return false;
    };

    console.log(removeSubArr([[2, 6],[3, 5],[7, 21],[20, 21]]));