Some one-liner solutions on FCC exercises. Most are my own doing. Some picked from FCC chat.

#Some FCC one-liner solutions

Some FCC one-liner solutions

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;
}

Binary agents.js

function binaryAgent(str) {
  return str.split(" ").map(function(elem){
	return String.fromCharCode(parseInt(elem,2));
  }).join("");
}

Boo who.js

function boo(bool) {
  return !!bool===bool;
}

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("");
}

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];
  });
}

Chunky monkey.js

function chunk(arr, size) {
  return arr.length ? [arr.splice(0,size)].concat(chunk(arr,size)):[];   
}

Confirm the ending.js

function end(str, target) {
  return str.slice(-target.length)===target;
}

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 two arrays.js

function diff(arr1, arr2) {
    return arr1.concat(arr2).filter(function(val, index, array){
      return array.indexOf(val)===array.lastIndexOf(val);
    }); 
}

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]];
  });
}

Drop it.js

function drop(arr, func) {
  return (arr.length && !func(arr[0])) ? drop(arr.slice(1),func) : arr;  
}

Everything be true.js

function every(collection, pre) {
  return collection.every(function(obj){
    return obj[pre];
  });
}

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;
}

Falsy bouncer.js

function bouncer(arr) {
  return arr.filter(function(val){return val;});
}

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);
}

Finders keepers.js

function find(arr, func) {
  return arr.length ? (func(arr[0]) ? arr[0] : find(arr.slice(1),func)) : undefined;
}

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;
    });
}

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);
}

Mutations.js

function mutation(arr) {
  return arr[1].toLowerCase().split("").every(function(val){
    return arr[0].toLowerCase().indexOf(val)>-1;
  });
}

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);
}

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");  
}

Repeat a string.js

function repeat(str, num) {
  return num>0 ? str+repeat(str,num-1) : "";   
}

Return largest numbers in arrays.js

function largestOfFour(arr) {
  return arr.map(function(innerArray){
    return Math.max.apply(null,innerArray);
  });  
}

Reverse a string.js

function reverseString(str) {
  return str.length ? reverseString(str.slice(1))+str.charAt(0) : "";
}

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("");
}

Seek and destroy.js

function destroyer(arr) {
  return arr.filter(function(val) {
    return Array.prototype.indexOf.call(this,val,1)===-1;
  },arguments);
}

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]);
}

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;
    });
  });
}

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;
}

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;  
}

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);
        }); 
    }, []);
}

Title case a sentence.js

function titleCase(str) {
  return str.split(' ').map(function(val){
    return val.charAt(0).toUpperCase() + val.substr(1).toLowerCase();
  }).join(' ');
}

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];
    });
  });
}

Where do I belong.js

function where(arr, num) {
  return arr.reduce(function(prev, curr){
    return curr<num ? prev+1 : prev;
  },0); 
}

awesome! 😄

Great job 👍