const permutation = (str) => {
  const result = [];

  // 用来交换数组的两个位置上的值
  const swap = (arr, start, end) => {
    const tmp = arr[start];
    arr[start] = arr[end];
    arr[end] = tmp;
    return arr;
  };

  // 开始执行递归逻辑
  // arr是当前传入的字符串数组
  // begin是当前开始处理的位置，开始为0
  const run = (arr, begin) => {
    if (begin === arr.length) {
      // 当begin累加到当前最大值时，将其输出
      res.push(arr.join(''));
    } else {
      for (let i = begin; i < arr.length; i++) {
        swap(arr, i, begin);
        run(arr, begin + 1);
        swap(arr, i, begin);
      }
    }
  };

  run(str.split(''), 0);
  return Array.from(new Set(res));
};
console.log(permutation('123'))
// 输出
// [ '123', '132', '213', '231', '321', '312' ]

const permutation = function (s) {
  const res = [];

  const arr = Array.from(s).sort();

  res.push(arr.join(''));

  const swap = (arr, i, j) => {
    const temp = arr[i];
    arr[i] = arr[j];
    arr[j] = temp;
  };

  const reverse = (arr, start) => {
    let left = start,
      right = arr.length - 1;
    while (left < right) {
      swap(arr, left, right);
      left++;
      right--;
    }
  };

  const nextPermutation = (arr) => {
    let i = arr.length - 2;
    while (i >= 0 && arr[i] >= arr[i + 1]) {
      i--;
    }
    if (i < 0) {
      return false;
    }
    let j = arr.length - 1;
    while (j >= 0 && arr[i] >= arr[j]) {
      j--;
    }
    swap(arr, i, j);
    reverse(arr, i + 1);
    return true;
  };

  while (nextPermutation(arr)) {
    res.push(arr.join(''));
  }

  return res;
};
console.log(permutation('123'))
// 输出
// [ '123', '132', '213', '231', '312', '321' ]

const permutation = (nums) => {
  const res = [];
  const len = nums.length;
  if (len === 0) {
    return res;
  }

  const depth = 0;
  const path = [];
  const used = {};

  dfs(nums, len, depth, path, used, res);

  return res;
};

const dfs = (nums, len, depth, path, used, res) => {
  if (len === depth) {
    res.push([...path]);
    return;
  }

  for (let i = 0; i < len; i++) {
    if (used[nums[i]]) {
      continue;
    }
    used[nums[i]] = true;
    path.push(nums[i]);
    dfs(nums, len, depth + 1, path, used, res);
    path.pop();
    used[nums[i]] = false;
  }
};

console.log(permutation('123'))

const a = '0123456789';
console.time();
console.log(方案二(a).length);
console.timeEnd();

console.time();
console.log(方案一(a).length);
console.timeEnd();

const newClimbStairs = (total, steps) => {
  const f = {};
  // 初始状态定位0，即没有爬楼
  f[0] = 0;

  for (let i = 1; i <= total; i++) {
    f[i] = 0;
    for (let j = 0; j < steps.length; j++) {
      if (i > steps[j]) {
        // 只要当前楼层大于当前步数，就进行累加
        f[i] = f[i - steps[j]] + f[i];
      }
      // 这里是一步登天的判断
      if (i === steps[j]) {
        // 如果发现当前楼层支持一步登天，就再加上1
        f[i] = f[i] + 1;
      }
    }
  }
  return f[total];
};

console.log(newClimbStairs(50, [1, 2]));
console.log(newClimbStairs(50, [1, 2, 50]));
// 20365011074
// 20365011075

// 将数组的值进行累加
const arrAll = (a) => {
  let sum = 0;
  for (let i = 0; i < a.length; i++) {
    sum += a[i];
  }
  return sum;
};

const start = (steps, target) => {
  const res = [];

  for (let i = 0; i < steps.length; i++) {
    res.push([steps[i]]);
  }

  // 把每一层都走一遍
  for (let i = 1; i <= target; i++) {
    // 给走过的层数，添加当前这一层需要走的步
    for (let j = 0; j < res.length; j++) {
      // 添加步数
      for (let m = 0; m < steps.length; m++) {
        const value = [...res[j], steps[m]];
        // 步数操作总层数，就不再进行计算了
        if (arrAll(value) <= target) {
          res.push(value);
        }
      }
    }
  }

  const result = [];

  for (let i = 0; i < res.length; i++) {
    if (arrAll(res[i]) === target) {
      result.push(res[i].join("-"));
    }
  }

  return Array.from(new Set(result));
};
console.log(start([1, 2, 3], 4));
// 输出
/**
[
  '1-3',     '2-2',
  '3-1',     '1-1-2',
  '1-2-1',   '2-1-1',
  '1-1-1-1'
]
总计7种爬法
*/

// run1和run2函数都返回promise
Promise.all([run1(), run2()]).then((res) => {
  // res的数据是个数组
  const [run1Res, run2Res] = res;
  console.log(run1Res, run2Res);
});

const MonacoWebpackPlugin = require('monaco-editor-webpack-plugin');
new MonacoWebpackPlugin({
    // 指定编辑器默认加载的语言
    languages: ['json', 'javascript', 'typescript', 'yaml'],
    // 自定义语言解释器worker
    customLanguages: [
        {
            label: 'yaml',
            // TODO: restore once https://github.com/pengx17/monaco-yaml/pull/48 is merged
            entry: 'monaco-yaml/lib/esm/monaco.contribution',
            worker: {
                id: 'vs/language/yaml/yamlWorker',
                // TODO: restore once https://github.com/pengx17/monaco-yaml/pull/48 is merged
                entry: 'monaco-yaml/lib/esm/yaml.worker.js'
            }
        }
    ]
})

// validation settings
monaco.languages.typescript.javascriptDefaults.setDiagnosticsOptions({
  noSemanticValidation: true,
  noSyntaxValidation: false
});

// compiler options
monaco.languages.typescript.javascriptDefaults.setCompilerOptions({
  target: monaco.languages.typescript.ScriptTarget.ES2016,
  allowNonTsExtensions: true,
  allowJs: true
});

// extra libraries
monaco.languages.typescript.javascriptDefaults.addExtraLib(`
declare class getValue {
    /**
    * 这是什么
    */
    antd: {
        message:{
            success:()=>void;
        }
    },
}
`,
  'filename/facts.d.ts'
);

/**
 * @param {getValue} event
 */
function getValue(event) {
    event.antd.message
}

f('1') === 1

f(1) === '1'