全排列

	let str = 'abc';

      const getPL = str =>{
          if(typeof str !== 'string'){
              return false;
          }
          const getFun = str => {
              if(str.length <=1){
                  return [str]
              }
              let res = [];
              for(let i = 0;i<str.length;i++){
                  let newS = str[i];
                  let newStr = getFun(str.slice(0,i)+str.slice(i+1))
                  for(let j = 0;j<newStr.length;j++){
                      res.push(newS + newStr[j]);
                  }
              }
              return res;
          }
          return getFun(str)
      }
      const getArrPl = arr =>{
          if(!Array.isArray(arr)){
              return false;
          }
          const getFun = arr => {
              if(arr.length <=1){
                  return arr;
              }
              let res = [];
              for(let i = 0;i<arr.length;i++){
                  let newS = arr[i];
                  let newStr = getFun(arr.slice(0,i).concat(arr.slice(i+1)))
                  // console.log(newStr);
                  for(let j = 0;j<newStr.length;j++){
                  
                      res.push(newS.toString() + newStr[j].toString());
                  }
              }
              return res;
          }
          let res = getFun(arr)
          return Math.min(...res);
      }

      const goodPl = arr =>
          Array.isArray(arr)?parseInt(arr.sort((a,b)=>{
              let sa = parseInt(a).toString()
              let sb = parseInt(b).toString()
              let flag = false;
              sa.length > sb.length && ([sa,sb] = [sb,sa],flag = true)
              for(let i = 0 ;i<sa.length;i++){
                  if(sa[i] != sb[i]){
                      return !flag ? sa[i] - sb[i]:sb[i]-sa[i]
                  }
              }
              let j = sa.length;
              while(sb[j] === sb[sa.length-1] && j<sb.length){
                  j++;
              }
              // console.log(j);
              if( j !== sb.length){
                  return flag?sb[j]-sb[sa.length-1]:sb[sa.length-1] - sb[j];
              }
              return 1;
              // return flag? 1:-1;
          }).join('')):false;