codewars

1、

Complete the solution so that the function will break up camel casing, using a space between words.

Example

"camelCasing"  =>  "camel Casing"
"identifier"   =>  "identifier"
""             =>  ""

my ans :  步骤繁琐 正则不熟悉

function Fn(string){
 var arr = string.splir('')
 var indexArr=[]
 arr.map((item,index)=>{
  if(item.toUpperCase()===item){
        indexArr.push(index)
  }
 var count = 0;
 for( var i = 0 ; i<indexArr.length; i++){
    arr.splice(indexArr[i]+count,0,' ')
    count++
  }
    return arr.join('')
})}

注意插入多个大写字母 需要加count 下标向后移count

better ans:

function solution(string) {
  return(string.replace(/([A-Z])/g, ' $1'));

}

function solution(string) {
  return string.replace(/([a-z])([A-Z])/g, "$1 $2");
}

const solution = string => {
  return [...string].map((char) => {
    return (char === char.toUpperCase()) ? ` ${char}` : char;
  }).join('');
}

 2、

You are given an array (which will have a length of at least 3, but could be very large) containing integers. The array is either entirely comprised of odd integers or entirely comprised of even integers except for a single integer N. Write a method that takes the array as an argument and returns this "outlier" N.

Examples

[2, 4, 0, 100, 4, 11, 2602, 36]
Should return: 11 (the only odd number)

[160, 3, 1719, 19, 11, 13, -21]
Should return: 160 (the only even number)

my ans :

function findOutlier(int){
  var even = int.filter(a=>a%2==0);
  var odd = int.filter(a=>a%2!==0);
  return even.length==1? even[0] : odd[0];
}

3、

Implement the function unique_in_order which takes as argument a sequence and returns a list of items without any elements with the same value next to each other and preserving the original order of elements.

For example:

uniqueInOrder('AAAABBBCCDAABBB') == ['A', 'B', 'C', 'D', 'A', 'B']
uniqueInOrder('ABBCcAD')         == ['A', 'B', 'C', 'c', 'A', 'D']
uniqueInOrder([1,2,2,3,3])       == [1,2,3]

my ans:

var uniqueInOrder=function(iterable){
  //your code here - remember iterable can be a string or an array
  if(typeof(iterable) === 'string') iterable =iterable.split('');
  var arr = []
  if(Array.isArray(iterable) && iterable.length >0 ){
    iterable.map((item,index)=>{
      if(iterable[index] === iterable[index+1]){
        arr.splice(index+1 , '')
      }else{
        arr.push(item)
      }
    })
  }
  return arr;
}


借鉴改进：
var uniqueInOrder=function(iterable){
  //your code here - remember iterable can be a string or an array
  //array string均可以用 for循环遍历 无需上个赘述判断转化  无返回值 会改变原数组
  var arr = []
  for(var i = 0 ; i<iterable.length; i++){
    if(iterable[i] !== arr[arr.length-1]){
        arr.push(iterable[i])
      }
  }
  return arr;
}

better ans :

var uniqueInOrder=function(iterable){
    return [...iterable].filter((a, i) => a !== iterable[i-1])
}

4、Are they the "same"?

Given two arrays a and b write a function comp(a, b) (orcompSame(a, b)) that checks whether the two arrays have the "same" elements, with the same multiplicities (the multiplicity of a member is the number of times it appears). "Same" means, here, that the elements in b are the elements in a squared, regardless of the order.

Examples

Valid arrays

a = [121, 144, 19, 161, 19, 144, 19, 11]  
b = [121, 14641, 20736, 361, 25921, 361, 20736, 361]

my ans :

滤清思路 找对方向  次幂算出来比较是否相同

  function suq(array1) {
      return array1.map((item) => item = item * item)
    }

    function comp(array1, array2) {
      //your code here
      if (!array1 || !array2) return false
      array1.sort((a, b) => a - b)
      array2.sort((a, b) => a - b)
      
      var array1 = suq(array1)
       array1.map(item => {
        const index = array2.indexOf(item)
        if (index !== -1) {
         array2.splice(index, 1)
        }
        return array2
      })

      return array2.length === 0;

    }


spilce会改变原数组  

better ans :

function comp(array1, array2) {
  if(array1 == null || array2 == null) return false;
  array1.sort((a, b) => a - b); array2.sort((a, b) => a - b);
  return array1.map(v => v * v).every((v, i) => v == array2[i]);
}


function comp(a, b) {
  return !!a && !!b && a.map(x => x*x).sort().join() == b.sort().join();
}


function comp(array1, array2) {
  if (array1 == null || array2 == null) return false;
  array1.sort((a, b) => a - b);
  array2.sort((a, b) => a - b);
  return array1.every((item, index) => item * item == array2[index]);
}


function comp(array1, array2){
  return !!array2 && !!array1 && array2.every( a=> array1.some( (b,i)=> a===b*b && delete array1[i] ) )  
}

You are given an array(list) strarr of strings and an integer k. Your task is to return the first longest string consisting of k consecutive strings taken in the array.

Examples:

strarr = ["tree", "foling", "trashy", "blue", "abcdef", "uvwxyz"], k = 2

my ans :忘记保存   

better ans： 

function longestConsec(strarr, k) {
		var longest = "";
		for(var i=0;k>0 && i<=strarr.length-k;i++){
			var tempArray = strarr.slice(i,i+k);
			var tempStr = tempArray.join("");
			if(tempStr.length > longest.length){
				longest = tempStr;
			}
		}
		return longest;
}


function longestConsec(strarr, k) {
  if( strarr.length==0 || k> strarr.length || k <1 ) return "";
  let lens = strarr.map( (_,i,arr) => arr.slice(i,i+k).join('').length ),
      i = lens.indexOf( Math.max(...lens) );
  return strarr.slice(i,i+k).join('')
}


const longestConsec = (strarr, k) =>
  k > strarr.length || k <= 0 ? `` :
    [...Array(strarr.length - k + 1)].reduce((pre, _, idx) => (str => str.length > pre.length ? str : pre)(strarr.slice(idx, idx + k).join(``)), ``);



function longestConsec(source, k) {  
  return new Array(Math.max(0, Math.min(k >= 0 ? source.length - k + 1 : k, source.length)))
        .fill('')
        .map((s, i) => source.slice(i, i + k).join(''))
        .reduce((max, x) => max.length < x.length ? x : max, '');
}