Masd925 · April 6, 2017 10:46 · abhisekp · Mar 2, 2016 · meaudotme · Apr 12, 2016
diff --git a/#Some FCC one-liner solutions b/#Some FCC one-liner solutions
 Some FCC one-liner solutions
diff --git a/Arguments optional.js b/Arguments optional.js
 function add() {
  return (arguments.length===2 && typeof(arguments[0])==='number' && typeof(arguments[1])==='number') ? 
    arguments[0] + arguments[1] :
    (arguments.length===1 && typeof(arguments[0])==='number') ? add.bind(null, arguments[0]) : undefined;
 }
diff --git a/Binary agents.js b/Binary agents.js
 function binaryAgent(str) {
  return str.split(" ").map(function(elem){
 	return String.fromCharCode(parseInt(elem,2));
  }).join("");
 }
diff --git a/Boo who.js b/Boo who.js
 function boo(bool) {
  return !!bool===bool;
 }
diff --git a/Caesars Cipher.js b/Caesars Cipher.js
 function rot13(str) {
  return str.split("").map(function(char){
      return ((cc=char.charCodeAt(0))>64 && cc<91) ? String.fromCharCode(cc%26+65) : char;
  }).join("");
 }
diff --git a/Check for palindromes.js b/Check for palindromes.js
 function palindrome(str) {
  return str.replace(/[\W_]/g,"").toLowerCase().split("").every(function(elem,index,array){
      return elem===array[array.length-1-index];
  });
 }
diff --git a/Chunky monkey.js b/Chunky monkey.js
 function chunk(arr, size) {
  return arr.length ? [arr.splice(0,size)].concat(chunk(arr,size)):[];   
 }
diff --git a/Confirm the ending.js b/Confirm the ending.js
 function end(str, target) {
  return str.slice(-target.length)===target;
 }
diff --git a/Counting cards.js b/Counting cards.js
 function cc(card) {
  return (count+={2:1,3:1,4:1,5:1,6:1,7:0,8:0,9:0,10:-1,J:-1,Q:-1,K:-1,A:-1}[card]) + (count>0 ? " Bet" : " Hold");
 }
diff --git a/Diff two arrays.js b/Diff two arrays.js
 function diff(arr1, arr2) {
    return arr1.concat(arr2).filter(function(val, index, array){
      return array.indexOf(val)===array.lastIndexOf(val);
    }); 
 }
diff --git a/DNA pairing.js b/DNA pairing.js
 function pair(str){
  return Array.prototype.map.call(str, function(val){
    return [val,{A:'T', T: 'A', C: 'G', G: 'C'}[val]];
  });
 }
diff --git a/Drop it.js b/Drop it.js
 function drop(arr, func) {
  return (arr.length && !func(arr[0])) ? drop(arr.slice(1),func) : arr;  
 }
diff --git a/Everything be true.js b/Everything be true.js
 function every(collection, pre) {
  return collection.every(function(obj){
    return obj[pre];
  });
 }
diff --git a/Exact change.js b/Exact change.js
 function checkCashRegister(price, cash, cid) {    
  return  (changeLeft = cash-price) && (change = cid.reverse().reduce(function(prev,curr){
    return (amount = (Math.min(changeLeft,curr[1])+(LAMBDA=0.0000001))/
           (note = {"ONE HUNDRED":100,"TWENTY":20,"TEN":10,"FIVE":5,"ONE":1,"QUARTER":0.25,
                    "DIME":0.10,"NICKEL":0.05,"PENNY":0.01}[curr[0]])>>0) ? 
             prev.push([curr[0],amount*note]) && (curr[1] -= amount*note)+1 && (changeLeft -= amount*note)+1 && prev
             :
             prev;
  },[])) &&
  changeLeft>LAMBDA ? 
    "Insufficient Funds" 
    :          
    cid.every(function(elem){return elem[1]<LAMBDA;}) ? "Closed" : change;
 }
diff --git a/Falsy bouncer.js b/Falsy bouncer.js
 function bouncer(arr) {
  return arr.filter(function(val){return val;});
 }
diff --git a/Find the longest word in a string.js b/Find the longest word in a string.js
 function findLongestWord(str) {
  return str.split(' ').reduce(function(prev, curr) {
    return Math.max(prev, curr.length);
  }, 0);
 }
diff --git a/Finders keepers.js b/Finders keepers.js
 function find(arr, func) {
  return arr.length ? (func(arr[0]) ? arr[0] : find(arr.slice(1),func)) : undefined;
 }
diff --git a/Inventory update.js b/Inventory update.js
 function updateInventory(old, del) {
    return del.reduce(function(prev,curr){        
        return ((ind = (itemNames = old.reduce(function(prev,curr){
            return  prev.concat(curr[1]);
        },[])).indexOf(curr[1]))===-1) ?
            itemNames.push(curr[1])&&prev.concat([curr])
        :
            (prev[ind][0] += curr[0])&&prev;                   
    },old).sort(function(a,b){
        return a[1]===b[1] ? 0 : 
        a[1] < b[1] ? -1 : 1;
    });
 }
diff --git a/Missing letters.js b/Missing letters.js
 function fearNotLetter(str) {
  if (str.length>1) return str.charCodeAt(1)===str.charCodeAt(0)+1 ? fearNotLetter(str.slice(1)) : String.fromCharCode(str.charCodeAt(0)+1);
 }
diff --git a/Mutations.js b/Mutations.js
 function mutation(arr) {
  return arr[1].toLowerCase().split("").every(function(val){
    return arr[0].toLowerCase().indexOf(val)>-1;
  });
 }
diff --git a/Pairwise.js b/Pairwise.js
 function pairwise(arr, arg) {
  return arr.reduce(function(prev,curr,index){
    arr.forEach(function(elem,ind){
      if (ind>index && curr+elem===arg && prev.indexOf(index)===-1 && prev.indexOf(ind)===-1) prev.push(index,ind);
    });
    return prev;
  },[]).reduce(function(cur,pre){return cur+pre;},0);
 }
diff --git a/Profile lookup.js b/Profile lookup.js
 function lookUp(firstName, prop){
    return contacts.reduce(function(prev,curr){
       return curr.firstName===firstName ? 
           curr.hasOwnProperty(prop) ? curr[prop] : "No such property" 
       : 
           prev;
    },"No such contact");  
 }
diff --git a/Repeat a string.js b/Repeat a string.js
 function repeat(str, num) {
  return num>0 ? str+repeat(str,num-1) : "";   
 }
diff --git a/Return largest numbers in arrays.js b/Return largest numbers in arrays.js
 function largestOfFour(arr) {
  return arr.map(function(innerArray){
    return Math.max.apply(null,innerArray);
  });  
 }
diff --git a/Reverse a string.js b/Reverse a string.js
 function reverseString(str) {
  return str.length ? reverseString(str.slice(1))+str.charAt(0) : "";
 }
diff --git a/Roman numeral converter.js b/Roman numeral converter.js
 function convert(num) { 
  return Array.prototype.reduce.call(num.toString(),function(prev,curr,index,array){
     return prev.concat([[0],[1],[1,1],[1,1,1],[1,5],[5],[5,1],[5,1,1],[5,1,1,1],[1,10]][curr].map(function(elem){
         return elem*Math.pow(10,array.length-1-index);
     })); 
  },[]).map(function(elem){
      return ['M', 'D', 'C', 'L', 'X', 'V', 'I'][[1000,500,100,50,10,5,1].indexOf(elem)];
  }).join("");
 }
diff --git a/Seek and destroy.js b/Seek and destroy.js
 function destroyer(arr) {
  return arr.filter(function(val) {
    return Array.prototype.indexOf.call(this,val,1)===-1;
  },arguments);
 }
diff --git a/Smallest common multiple.js b/Smallest common multiple.js
 function smallestCommons(arr) {
    return arguments.length===1 ?
        Array.apply(null, {length: Math.max(arr[0],arr[1])-Math.min(arr[0],arr[1])+1})
            .map(function(value, index){
                return Math.min(arr[0],arr[1]) + index;
            })
            .reduce(function(prev,curr){return prev*curr / smallestCommons(prev,curr);})
            :
            arguments[1]===0 ? arguments[0] : smallestCommons(arguments[1], arguments[0]%arguments[1]);
 }
diff --git a/Sorted union.js b/Sorted union.js
 function unite(arr1, arr2, arr3) {
  return Array.prototype.reduce.call(arguments, function(prev,curr){
    return prev.concat(curr).filter(function(val, index, array){
      return array.indexOf(val)===index;
    });
  });
 }
diff --git a/Steamroller.js b/Steamroller.js
 function steamrollArray(arr) {  // recursive
    return Array.isArray(arr) ? Array.prototype.concat.apply([],arr.map(steamrollArray)):arr;
 }

 function steamrollArray(arr) {  // non-recursive
    while (arr.some(Array.isArray)) {
        arr = Array.prototype.concat.apply([],arr);
    }
    return arr;
 }
diff --git a/Sum all primes.js b/Sum all primes.js
 function sumPrimes(num) {
  return arguments.length!==1 ?
    num>1 ? 
      sumPrimes(num-1, arguments[1].filter(function(val){return val%num!==0;}).concat(num))        
    : 
      arguments[1].reduce(function(a,b){return a+b;})   
  :
    num>1 ? sumPrimes(num-1, [num]) : 0;  
 }
diff --git a/Symmetric difference.js b/Symmetric difference.js
 function sym(args) {
    return Array.prototype.slice.call(arguments).reduce(function(prev, curr){
        return prev.concat(curr.filter(function(val, index){
            return curr.indexOf(val)===index;
        })).filter(function(val,ind,array){
            return array.indexOf(val)===array.lastIndexOf(val);
        }); 
    }, []);
 }
diff --git a/Title case a sentence.js b/Title case a sentence.js
 function titleCase(str) {
  return str.split(' ').map(function(val){
    return val.charAt(0).toUpperCase() + val.substr(1).toLowerCase();
  }).join(' ');
 }
diff --git a/Where art thou.js b/Where art thou.js
 function where(collection, source) {
  return collection.filter(function(obj){
    return Object.keys(source).every(function(key){
      return obj[key]===source[key];
    });
  });
 }
diff --git a/Where do I belong.js b/Where do I belong.js
 function where(arr, num) {
  return arr.reduce(function(prev, curr){
    return curr<num ? prev+1 : prev;
  },0); 
 }
	function add() {
	return (arguments.length===2 && typeof(arguments[0])==='number' && typeof(arguments[1])==='number') ?
	arguments[0] + arguments[1] :
	(arguments.length===1 && typeof(arguments[0])==='number') ? add.bind(null, arguments[0]) : undefined;
	}
	function binaryAgent(str) {
	return str.split(" ").map(function(elem){
	return String.fromCharCode(parseInt(elem,2));
	}).join("");
	}
	function rot13(str) {
	return str.split("").map(function(char){
	return ((cc=char.charCodeAt(0))>64 && cc<91) ? String.fromCharCode(cc%26+65) : char;
	}).join("");
	}
	function palindrome(str) {
	return str.replace(/[\W_]/g,"").toLowerCase().split("").every(function(elem,index,array){
	return elem===array[array.length-1-index];
	});
	}
	function chunk(arr, size) {
	return arr.length ? [arr.splice(0,size)].concat(chunk(arr,size)):[];
	}
	function end(str, target) {
	return str.slice(-target.length)===target;
	}
	function cc(card) {
	return (count+={2:1,3:1,4:1,5:1,6:1,7:0,8:0,9:0,10:-1,J:-1,Q:-1,K:-1,A:-1}[card]) + (count>0 ? " Bet" : " Hold");
	}
	function diff(arr1, arr2) {
	return arr1.concat(arr2).filter(function(val, index, array){
	return array.indexOf(val)===array.lastIndexOf(val);
	});
	}
	function pair(str){
	return Array.prototype.map.call(str, function(val){
	return [val,{A:'T', T: 'A', C: 'G', G: 'C'}[val]];
	});
	}
	function drop(arr, func) {
	return (arr.length && !func(arr[0])) ? drop(arr.slice(1),func) : arr;
	}